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 /* Radix preferred - but we require GTSE for now */ 1115 prom_debug("Asking for radix with GTSE\n"); 1116 ibm_architecture_vec.vec5.mmu = OV5_FEAT(OV5_MMU_RADIX); 1117 ibm_architecture_vec.vec5.radix_ext = OV5_FEAT(OV5_RADIX_GTSE); 1118 } else if (supported.hash_mmu) { 1119 /* Default to hash mmu (if we can) */ 1120 prom_debug("Asking for hash\n"); 1121 ibm_architecture_vec.vec5.mmu = OV5_FEAT(OV5_MMU_HASH); 1122 } else { 1123 /* We're probably on a legacy hypervisor */ 1124 prom_debug("Assuming legacy hash support\n"); 1125 } 1126 1127 if (supported.xive) { 1128 prom_debug("Asking for XIVE\n"); 1129 ibm_architecture_vec.vec5.intarch = OV5_FEAT(OV5_XIVE_EXPLOIT); 1130 } 1131 } 1132 1133 static void __init prom_send_capabilities(void) 1134 { 1135 ihandle root; 1136 prom_arg_t ret; 1137 u32 cores; 1138 1139 /* Check ibm,arch-vec-5-platform-support and fixup vec5 if required */ 1140 prom_check_platform_support(); 1141 1142 root = call_prom("open", 1, 1, ADDR("/")); 1143 if (root != 0) { 1144 /* We need to tell the FW about the number of cores we support. 1145 * 1146 * To do that, we count the number of threads on the first core 1147 * (we assume this is the same for all cores) and use it to 1148 * divide NR_CPUS. 1149 */ 1150 1151 cores = DIV_ROUND_UP(NR_CPUS, prom_count_smt_threads()); 1152 prom_printf("Max number of cores passed to firmware: %lu (NR_CPUS = %lu)\n", 1153 cores, NR_CPUS); 1154 1155 ibm_architecture_vec.vec5.max_cpus = cpu_to_be32(cores); 1156 1157 /* try calling the ibm,client-architecture-support method */ 1158 prom_printf("Calling ibm,client-architecture-support..."); 1159 if (call_prom_ret("call-method", 3, 2, &ret, 1160 ADDR("ibm,client-architecture-support"), 1161 root, 1162 ADDR(&ibm_architecture_vec)) == 0) { 1163 /* the call exists... */ 1164 if (ret) 1165 prom_printf("\nWARNING: ibm,client-architecture" 1166 "-support call FAILED!\n"); 1167 call_prom("close", 1, 0, root); 1168 prom_printf(" done\n"); 1169 return; 1170 } 1171 call_prom("close", 1, 0, root); 1172 prom_printf(" not implemented\n"); 1173 } 1174 1175 #ifdef __BIG_ENDIAN__ 1176 { 1177 ihandle elfloader; 1178 1179 /* no ibm,client-architecture-support call, try the old way */ 1180 elfloader = call_prom("open", 1, 1, 1181 ADDR("/packages/elf-loader")); 1182 if (elfloader == 0) { 1183 prom_printf("couldn't open /packages/elf-loader\n"); 1184 return; 1185 } 1186 call_prom("call-method", 3, 1, ADDR("process-elf-header"), 1187 elfloader, ADDR(&fake_elf)); 1188 call_prom("close", 1, 0, elfloader); 1189 } 1190 #endif /* __BIG_ENDIAN__ */ 1191 } 1192 #endif /* #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV) */ 1193 1194 /* 1195 * Memory allocation strategy... our layout is normally: 1196 * 1197 * at 14Mb or more we have vmlinux, then a gap and initrd. In some 1198 * rare cases, initrd might end up being before the kernel though. 1199 * We assume this won't override the final kernel at 0, we have no 1200 * provision to handle that in this version, but it should hopefully 1201 * never happen. 1202 * 1203 * alloc_top is set to the top of RMO, eventually shrink down if the 1204 * TCEs overlap 1205 * 1206 * alloc_bottom is set to the top of kernel/initrd 1207 * 1208 * from there, allocations are done this way : rtas is allocated 1209 * topmost, and the device-tree is allocated from the bottom. We try 1210 * to grow the device-tree allocation as we progress. If we can't, 1211 * then we fail, we don't currently have a facility to restart 1212 * elsewhere, but that shouldn't be necessary. 1213 * 1214 * Note that calls to reserve_mem have to be done explicitly, memory 1215 * allocated with either alloc_up or alloc_down isn't automatically 1216 * reserved. 1217 */ 1218 1219 1220 /* 1221 * Allocates memory in the RMO upward from the kernel/initrd 1222 * 1223 * When align is 0, this is a special case, it means to allocate in place 1224 * at the current location of alloc_bottom or fail (that is basically 1225 * extending the previous allocation). Used for the device-tree flattening 1226 */ 1227 static unsigned long __init alloc_up(unsigned long size, unsigned long align) 1228 { 1229 unsigned long base = alloc_bottom; 1230 unsigned long addr = 0; 1231 1232 if (align) 1233 base = _ALIGN_UP(base, align); 1234 prom_debug("alloc_up(%x, %x)\n", size, align); 1235 if (ram_top == 0) 1236 prom_panic("alloc_up() called with mem not initialized\n"); 1237 1238 if (align) 1239 base = _ALIGN_UP(alloc_bottom, align); 1240 else 1241 base = alloc_bottom; 1242 1243 for(; (base + size) <= alloc_top; 1244 base = _ALIGN_UP(base + 0x100000, align)) { 1245 prom_debug(" trying: 0x%x\n\r", base); 1246 addr = (unsigned long)prom_claim(base, size, 0); 1247 if (addr != PROM_ERROR && addr != 0) 1248 break; 1249 addr = 0; 1250 if (align == 0) 1251 break; 1252 } 1253 if (addr == 0) 1254 return 0; 1255 alloc_bottom = addr + size; 1256 1257 prom_debug(" -> %x\n", addr); 1258 prom_debug(" alloc_bottom : %x\n", alloc_bottom); 1259 prom_debug(" alloc_top : %x\n", alloc_top); 1260 prom_debug(" alloc_top_hi : %x\n", alloc_top_high); 1261 prom_debug(" rmo_top : %x\n", rmo_top); 1262 prom_debug(" ram_top : %x\n", ram_top); 1263 1264 return addr; 1265 } 1266 1267 /* 1268 * Allocates memory downward, either from top of RMO, or if highmem 1269 * is set, from the top of RAM. Note that this one doesn't handle 1270 * failures. It does claim memory if highmem is not set. 1271 */ 1272 static unsigned long __init alloc_down(unsigned long size, unsigned long align, 1273 int highmem) 1274 { 1275 unsigned long base, addr = 0; 1276 1277 prom_debug("alloc_down(%x, %x, %s)\n", size, align, 1278 highmem ? "(high)" : "(low)"); 1279 if (ram_top == 0) 1280 prom_panic("alloc_down() called with mem not initialized\n"); 1281 1282 if (highmem) { 1283 /* Carve out storage for the TCE table. */ 1284 addr = _ALIGN_DOWN(alloc_top_high - size, align); 1285 if (addr <= alloc_bottom) 1286 return 0; 1287 /* Will we bump into the RMO ? If yes, check out that we 1288 * didn't overlap existing allocations there, if we did, 1289 * we are dead, we must be the first in town ! 1290 */ 1291 if (addr < rmo_top) { 1292 /* Good, we are first */ 1293 if (alloc_top == rmo_top) 1294 alloc_top = rmo_top = addr; 1295 else 1296 return 0; 1297 } 1298 alloc_top_high = addr; 1299 goto bail; 1300 } 1301 1302 base = _ALIGN_DOWN(alloc_top - size, align); 1303 for (; base > alloc_bottom; 1304 base = _ALIGN_DOWN(base - 0x100000, align)) { 1305 prom_debug(" trying: 0x%x\n\r", base); 1306 addr = (unsigned long)prom_claim(base, size, 0); 1307 if (addr != PROM_ERROR && addr != 0) 1308 break; 1309 addr = 0; 1310 } 1311 if (addr == 0) 1312 return 0; 1313 alloc_top = addr; 1314 1315 bail: 1316 prom_debug(" -> %x\n", addr); 1317 prom_debug(" alloc_bottom : %x\n", alloc_bottom); 1318 prom_debug(" alloc_top : %x\n", alloc_top); 1319 prom_debug(" alloc_top_hi : %x\n", alloc_top_high); 1320 prom_debug(" rmo_top : %x\n", rmo_top); 1321 prom_debug(" ram_top : %x\n", ram_top); 1322 1323 return addr; 1324 } 1325 1326 /* 1327 * Parse a "reg" cell 1328 */ 1329 static unsigned long __init prom_next_cell(int s, cell_t **cellp) 1330 { 1331 cell_t *p = *cellp; 1332 unsigned long r = 0; 1333 1334 /* Ignore more than 2 cells */ 1335 while (s > sizeof(unsigned long) / 4) { 1336 p++; 1337 s--; 1338 } 1339 r = be32_to_cpu(*p++); 1340 #ifdef CONFIG_PPC64 1341 if (s > 1) { 1342 r <<= 32; 1343 r |= be32_to_cpu(*(p++)); 1344 } 1345 #endif 1346 *cellp = p; 1347 return r; 1348 } 1349 1350 /* 1351 * Very dumb function for adding to the memory reserve list, but 1352 * we don't need anything smarter at this point 1353 * 1354 * XXX Eventually check for collisions. They should NEVER happen. 1355 * If problems seem to show up, it would be a good start to track 1356 * them down. 1357 */ 1358 static void __init reserve_mem(u64 base, u64 size) 1359 { 1360 u64 top = base + size; 1361 unsigned long cnt = mem_reserve_cnt; 1362 1363 if (size == 0) 1364 return; 1365 1366 /* We need to always keep one empty entry so that we 1367 * have our terminator with "size" set to 0 since we are 1368 * dumb and just copy this entire array to the boot params 1369 */ 1370 base = _ALIGN_DOWN(base, PAGE_SIZE); 1371 top = _ALIGN_UP(top, PAGE_SIZE); 1372 size = top - base; 1373 1374 if (cnt >= (MEM_RESERVE_MAP_SIZE - 1)) 1375 prom_panic("Memory reserve map exhausted !\n"); 1376 mem_reserve_map[cnt].base = cpu_to_be64(base); 1377 mem_reserve_map[cnt].size = cpu_to_be64(size); 1378 mem_reserve_cnt = cnt + 1; 1379 } 1380 1381 /* 1382 * Initialize memory allocation mechanism, parse "memory" nodes and 1383 * obtain that way the top of memory and RMO to setup out local allocator 1384 */ 1385 static void __init prom_init_mem(void) 1386 { 1387 phandle node; 1388 char *path, type[64]; 1389 unsigned int plen; 1390 cell_t *p, *endp; 1391 __be32 val; 1392 u32 rac, rsc; 1393 1394 /* 1395 * We iterate the memory nodes to find 1396 * 1) top of RMO (first node) 1397 * 2) top of memory 1398 */ 1399 val = cpu_to_be32(2); 1400 prom_getprop(prom.root, "#address-cells", &val, sizeof(val)); 1401 rac = be32_to_cpu(val); 1402 val = cpu_to_be32(1); 1403 prom_getprop(prom.root, "#size-cells", &val, sizeof(rsc)); 1404 rsc = be32_to_cpu(val); 1405 prom_debug("root_addr_cells: %x\n", rac); 1406 prom_debug("root_size_cells: %x\n", rsc); 1407 1408 prom_debug("scanning memory:\n"); 1409 path = prom_scratch; 1410 1411 for (node = 0; prom_next_node(&node); ) { 1412 type[0] = 0; 1413 prom_getprop(node, "device_type", type, sizeof(type)); 1414 1415 if (type[0] == 0) { 1416 /* 1417 * CHRP Longtrail machines have no device_type 1418 * on the memory node, so check the name instead... 1419 */ 1420 prom_getprop(node, "name", type, sizeof(type)); 1421 } 1422 if (strcmp(type, "memory")) 1423 continue; 1424 1425 plen = prom_getprop(node, "reg", regbuf, sizeof(regbuf)); 1426 if (plen > sizeof(regbuf)) { 1427 prom_printf("memory node too large for buffer !\n"); 1428 plen = sizeof(regbuf); 1429 } 1430 p = regbuf; 1431 endp = p + (plen / sizeof(cell_t)); 1432 1433 #ifdef DEBUG_PROM 1434 memset(path, 0, PROM_SCRATCH_SIZE); 1435 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1); 1436 prom_debug(" node %s :\n", path); 1437 #endif /* DEBUG_PROM */ 1438 1439 while ((endp - p) >= (rac + rsc)) { 1440 unsigned long base, size; 1441 1442 base = prom_next_cell(rac, &p); 1443 size = prom_next_cell(rsc, &p); 1444 1445 if (size == 0) 1446 continue; 1447 prom_debug(" %x %x\n", base, size); 1448 if (base == 0 && (of_platform & PLATFORM_LPAR)) 1449 rmo_top = size; 1450 if ((base + size) > ram_top) 1451 ram_top = base + size; 1452 } 1453 } 1454 1455 alloc_bottom = PAGE_ALIGN((unsigned long)&_end + 0x4000); 1456 1457 /* 1458 * If prom_memory_limit is set we reduce the upper limits *except* for 1459 * alloc_top_high. This must be the real top of RAM so we can put 1460 * TCE's up there. 1461 */ 1462 1463 alloc_top_high = ram_top; 1464 1465 if (prom_memory_limit) { 1466 if (prom_memory_limit <= alloc_bottom) { 1467 prom_printf("Ignoring mem=%x <= alloc_bottom.\n", 1468 prom_memory_limit); 1469 prom_memory_limit = 0; 1470 } else if (prom_memory_limit >= ram_top) { 1471 prom_printf("Ignoring mem=%x >= ram_top.\n", 1472 prom_memory_limit); 1473 prom_memory_limit = 0; 1474 } else { 1475 ram_top = prom_memory_limit; 1476 rmo_top = min(rmo_top, prom_memory_limit); 1477 } 1478 } 1479 1480 /* 1481 * Setup our top alloc point, that is top of RMO or top of 1482 * segment 0 when running non-LPAR. 1483 * Some RS64 machines have buggy firmware where claims up at 1484 * 1GB fail. Cap at 768MB as a workaround. 1485 * Since 768MB is plenty of room, and we need to cap to something 1486 * reasonable on 32-bit, cap at 768MB on all machines. 1487 */ 1488 if (!rmo_top) 1489 rmo_top = ram_top; 1490 rmo_top = min(0x30000000ul, rmo_top); 1491 alloc_top = rmo_top; 1492 alloc_top_high = ram_top; 1493 1494 /* 1495 * Check if we have an initrd after the kernel but still inside 1496 * the RMO. If we do move our bottom point to after it. 1497 */ 1498 if (prom_initrd_start && 1499 prom_initrd_start < rmo_top && 1500 prom_initrd_end > alloc_bottom) 1501 alloc_bottom = PAGE_ALIGN(prom_initrd_end); 1502 1503 prom_printf("memory layout at init:\n"); 1504 prom_printf(" memory_limit : %x (16 MB aligned)\n", prom_memory_limit); 1505 prom_printf(" alloc_bottom : %x\n", alloc_bottom); 1506 prom_printf(" alloc_top : %x\n", alloc_top); 1507 prom_printf(" alloc_top_hi : %x\n", alloc_top_high); 1508 prom_printf(" rmo_top : %x\n", rmo_top); 1509 prom_printf(" ram_top : %x\n", ram_top); 1510 } 1511 1512 static void __init prom_close_stdin(void) 1513 { 1514 __be32 val; 1515 ihandle stdin; 1516 1517 if (prom_getprop(prom.chosen, "stdin", &val, sizeof(val)) > 0) { 1518 stdin = be32_to_cpu(val); 1519 call_prom("close", 1, 0, stdin); 1520 } 1521 } 1522 1523 #ifdef CONFIG_PPC_POWERNV 1524 1525 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL 1526 static u64 __initdata prom_opal_base; 1527 static u64 __initdata prom_opal_entry; 1528 #endif 1529 1530 /* 1531 * Allocate room for and instantiate OPAL 1532 */ 1533 static void __init prom_instantiate_opal(void) 1534 { 1535 phandle opal_node; 1536 ihandle opal_inst; 1537 u64 base, entry; 1538 u64 size = 0, align = 0x10000; 1539 __be64 val64; 1540 u32 rets[2]; 1541 1542 prom_debug("prom_instantiate_opal: start...\n"); 1543 1544 opal_node = call_prom("finddevice", 1, 1, ADDR("/ibm,opal")); 1545 prom_debug("opal_node: %x\n", opal_node); 1546 if (!PHANDLE_VALID(opal_node)) 1547 return; 1548 1549 val64 = 0; 1550 prom_getprop(opal_node, "opal-runtime-size", &val64, sizeof(val64)); 1551 size = be64_to_cpu(val64); 1552 if (size == 0) 1553 return; 1554 val64 = 0; 1555 prom_getprop(opal_node, "opal-runtime-alignment", &val64,sizeof(val64)); 1556 align = be64_to_cpu(val64); 1557 1558 base = alloc_down(size, align, 0); 1559 if (base == 0) { 1560 prom_printf("OPAL allocation failed !\n"); 1561 return; 1562 } 1563 1564 opal_inst = call_prom("open", 1, 1, ADDR("/ibm,opal")); 1565 if (!IHANDLE_VALID(opal_inst)) { 1566 prom_printf("opening opal package failed (%x)\n", opal_inst); 1567 return; 1568 } 1569 1570 prom_printf("instantiating opal at 0x%x...", base); 1571 1572 if (call_prom_ret("call-method", 4, 3, rets, 1573 ADDR("load-opal-runtime"), 1574 opal_inst, 1575 base >> 32, base & 0xffffffff) != 0 1576 || (rets[0] == 0 && rets[1] == 0)) { 1577 prom_printf(" failed\n"); 1578 return; 1579 } 1580 entry = (((u64)rets[0]) << 32) | rets[1]; 1581 1582 prom_printf(" done\n"); 1583 1584 reserve_mem(base, size); 1585 1586 prom_debug("opal base = 0x%x\n", base); 1587 prom_debug("opal align = 0x%x\n", align); 1588 prom_debug("opal entry = 0x%x\n", entry); 1589 prom_debug("opal size = 0x%x\n", (long)size); 1590 1591 prom_setprop(opal_node, "/ibm,opal", "opal-base-address", 1592 &base, sizeof(base)); 1593 prom_setprop(opal_node, "/ibm,opal", "opal-entry-address", 1594 &entry, sizeof(entry)); 1595 1596 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL 1597 prom_opal_base = base; 1598 prom_opal_entry = entry; 1599 #endif 1600 prom_debug("prom_instantiate_opal: end...\n"); 1601 } 1602 1603 #endif /* CONFIG_PPC_POWERNV */ 1604 1605 /* 1606 * Allocate room for and instantiate RTAS 1607 */ 1608 static void __init prom_instantiate_rtas(void) 1609 { 1610 phandle rtas_node; 1611 ihandle rtas_inst; 1612 u32 base, entry = 0; 1613 __be32 val; 1614 u32 size = 0; 1615 1616 prom_debug("prom_instantiate_rtas: start...\n"); 1617 1618 rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas")); 1619 prom_debug("rtas_node: %x\n", rtas_node); 1620 if (!PHANDLE_VALID(rtas_node)) 1621 return; 1622 1623 val = 0; 1624 prom_getprop(rtas_node, "rtas-size", &val, sizeof(size)); 1625 size = be32_to_cpu(val); 1626 if (size == 0) 1627 return; 1628 1629 base = alloc_down(size, PAGE_SIZE, 0); 1630 if (base == 0) 1631 prom_panic("Could not allocate memory for RTAS\n"); 1632 1633 rtas_inst = call_prom("open", 1, 1, ADDR("/rtas")); 1634 if (!IHANDLE_VALID(rtas_inst)) { 1635 prom_printf("opening rtas package failed (%x)\n", rtas_inst); 1636 return; 1637 } 1638 1639 prom_printf("instantiating rtas at 0x%x...", base); 1640 1641 if (call_prom_ret("call-method", 3, 2, &entry, 1642 ADDR("instantiate-rtas"), 1643 rtas_inst, base) != 0 1644 || entry == 0) { 1645 prom_printf(" failed\n"); 1646 return; 1647 } 1648 prom_printf(" done\n"); 1649 1650 reserve_mem(base, size); 1651 1652 val = cpu_to_be32(base); 1653 prom_setprop(rtas_node, "/rtas", "linux,rtas-base", 1654 &val, sizeof(val)); 1655 val = cpu_to_be32(entry); 1656 prom_setprop(rtas_node, "/rtas", "linux,rtas-entry", 1657 &val, sizeof(val)); 1658 1659 /* Check if it supports "query-cpu-stopped-state" */ 1660 if (prom_getprop(rtas_node, "query-cpu-stopped-state", 1661 &val, sizeof(val)) != PROM_ERROR) 1662 rtas_has_query_cpu_stopped = true; 1663 1664 prom_debug("rtas base = 0x%x\n", base); 1665 prom_debug("rtas entry = 0x%x\n", entry); 1666 prom_debug("rtas size = 0x%x\n", (long)size); 1667 1668 prom_debug("prom_instantiate_rtas: end...\n"); 1669 } 1670 1671 #ifdef CONFIG_PPC64 1672 /* 1673 * Allocate room for and instantiate Stored Measurement Log (SML) 1674 */ 1675 static void __init prom_instantiate_sml(void) 1676 { 1677 phandle ibmvtpm_node; 1678 ihandle ibmvtpm_inst; 1679 u32 entry = 0, size = 0, succ = 0; 1680 u64 base; 1681 __be32 val; 1682 1683 prom_debug("prom_instantiate_sml: start...\n"); 1684 1685 ibmvtpm_node = call_prom("finddevice", 1, 1, ADDR("/vdevice/vtpm")); 1686 prom_debug("ibmvtpm_node: %x\n", ibmvtpm_node); 1687 if (!PHANDLE_VALID(ibmvtpm_node)) 1688 return; 1689 1690 ibmvtpm_inst = call_prom("open", 1, 1, ADDR("/vdevice/vtpm")); 1691 if (!IHANDLE_VALID(ibmvtpm_inst)) { 1692 prom_printf("opening vtpm package failed (%x)\n", ibmvtpm_inst); 1693 return; 1694 } 1695 1696 if (prom_getprop(ibmvtpm_node, "ibm,sml-efi-reformat-supported", 1697 &val, sizeof(val)) != PROM_ERROR) { 1698 if (call_prom_ret("call-method", 2, 2, &succ, 1699 ADDR("reformat-sml-to-efi-alignment"), 1700 ibmvtpm_inst) != 0 || succ == 0) { 1701 prom_printf("Reformat SML to EFI alignment failed\n"); 1702 return; 1703 } 1704 1705 if (call_prom_ret("call-method", 2, 2, &size, 1706 ADDR("sml-get-allocated-size"), 1707 ibmvtpm_inst) != 0 || size == 0) { 1708 prom_printf("SML get allocated size failed\n"); 1709 return; 1710 } 1711 } else { 1712 if (call_prom_ret("call-method", 2, 2, &size, 1713 ADDR("sml-get-handover-size"), 1714 ibmvtpm_inst) != 0 || size == 0) { 1715 prom_printf("SML get handover size failed\n"); 1716 return; 1717 } 1718 } 1719 1720 base = alloc_down(size, PAGE_SIZE, 0); 1721 if (base == 0) 1722 prom_panic("Could not allocate memory for sml\n"); 1723 1724 prom_printf("instantiating sml at 0x%x...", base); 1725 1726 memset((void *)base, 0, size); 1727 1728 if (call_prom_ret("call-method", 4, 2, &entry, 1729 ADDR("sml-handover"), 1730 ibmvtpm_inst, size, base) != 0 || entry == 0) { 1731 prom_printf("SML handover failed\n"); 1732 return; 1733 } 1734 prom_printf(" done\n"); 1735 1736 reserve_mem(base, size); 1737 1738 prom_setprop(ibmvtpm_node, "/vdevice/vtpm", "linux,sml-base", 1739 &base, sizeof(base)); 1740 prom_setprop(ibmvtpm_node, "/vdevice/vtpm", "linux,sml-size", 1741 &size, sizeof(size)); 1742 1743 prom_debug("sml base = 0x%x\n", base); 1744 prom_debug("sml size = 0x%x\n", (long)size); 1745 1746 prom_debug("prom_instantiate_sml: end...\n"); 1747 } 1748 1749 /* 1750 * Allocate room for and initialize TCE tables 1751 */ 1752 #ifdef __BIG_ENDIAN__ 1753 static void __init prom_initialize_tce_table(void) 1754 { 1755 phandle node; 1756 ihandle phb_node; 1757 char compatible[64], type[64], model[64]; 1758 char *path = prom_scratch; 1759 u64 base, align; 1760 u32 minalign, minsize; 1761 u64 tce_entry, *tce_entryp; 1762 u64 local_alloc_top, local_alloc_bottom; 1763 u64 i; 1764 1765 if (prom_iommu_off) 1766 return; 1767 1768 prom_debug("starting prom_initialize_tce_table\n"); 1769 1770 /* Cache current top of allocs so we reserve a single block */ 1771 local_alloc_top = alloc_top_high; 1772 local_alloc_bottom = local_alloc_top; 1773 1774 /* Search all nodes looking for PHBs. */ 1775 for (node = 0; prom_next_node(&node); ) { 1776 compatible[0] = 0; 1777 type[0] = 0; 1778 model[0] = 0; 1779 prom_getprop(node, "compatible", 1780 compatible, sizeof(compatible)); 1781 prom_getprop(node, "device_type", type, sizeof(type)); 1782 prom_getprop(node, "model", model, sizeof(model)); 1783 1784 if ((type[0] == 0) || (strstr(type, "pci") == NULL)) 1785 continue; 1786 1787 /* Keep the old logic intact to avoid regression. */ 1788 if (compatible[0] != 0) { 1789 if ((strstr(compatible, "python") == NULL) && 1790 (strstr(compatible, "Speedwagon") == NULL) && 1791 (strstr(compatible, "Winnipeg") == NULL)) 1792 continue; 1793 } else if (model[0] != 0) { 1794 if ((strstr(model, "ython") == NULL) && 1795 (strstr(model, "peedwagon") == NULL) && 1796 (strstr(model, "innipeg") == NULL)) 1797 continue; 1798 } 1799 1800 if (prom_getprop(node, "tce-table-minalign", &minalign, 1801 sizeof(minalign)) == PROM_ERROR) 1802 minalign = 0; 1803 if (prom_getprop(node, "tce-table-minsize", &minsize, 1804 sizeof(minsize)) == PROM_ERROR) 1805 minsize = 4UL << 20; 1806 1807 /* 1808 * Even though we read what OF wants, we just set the table 1809 * size to 4 MB. This is enough to map 2GB of PCI DMA space. 1810 * By doing this, we avoid the pitfalls of trying to DMA to 1811 * MMIO space and the DMA alias hole. 1812 * 1813 * On POWER4, firmware sets the TCE region by assuming 1814 * each TCE table is 8MB. Using this memory for anything 1815 * else will impact performance, so we always allocate 8MB. 1816 * Anton 1817 */ 1818 if (pvr_version_is(PVR_POWER4) || pvr_version_is(PVR_POWER4p)) 1819 minsize = 8UL << 20; 1820 else 1821 minsize = 4UL << 20; 1822 1823 /* Align to the greater of the align or size */ 1824 align = max(minalign, minsize); 1825 base = alloc_down(minsize, align, 1); 1826 if (base == 0) 1827 prom_panic("ERROR, cannot find space for TCE table.\n"); 1828 if (base < local_alloc_bottom) 1829 local_alloc_bottom = base; 1830 1831 /* It seems OF doesn't null-terminate the path :-( */ 1832 memset(path, 0, PROM_SCRATCH_SIZE); 1833 /* Call OF to setup the TCE hardware */ 1834 if (call_prom("package-to-path", 3, 1, node, 1835 path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) { 1836 prom_printf("package-to-path failed\n"); 1837 } 1838 1839 /* Save away the TCE table attributes for later use. */ 1840 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base)); 1841 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize)); 1842 1843 prom_debug("TCE table: %s\n", path); 1844 prom_debug("\tnode = 0x%x\n", node); 1845 prom_debug("\tbase = 0x%x\n", base); 1846 prom_debug("\tsize = 0x%x\n", minsize); 1847 1848 /* Initialize the table to have a one-to-one mapping 1849 * over the allocated size. 1850 */ 1851 tce_entryp = (u64 *)base; 1852 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) { 1853 tce_entry = (i << PAGE_SHIFT); 1854 tce_entry |= 0x3; 1855 *tce_entryp = tce_entry; 1856 } 1857 1858 prom_printf("opening PHB %s", path); 1859 phb_node = call_prom("open", 1, 1, path); 1860 if (phb_node == 0) 1861 prom_printf("... failed\n"); 1862 else 1863 prom_printf("... done\n"); 1864 1865 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"), 1866 phb_node, -1, minsize, 1867 (u32) base, (u32) (base >> 32)); 1868 call_prom("close", 1, 0, phb_node); 1869 } 1870 1871 reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom); 1872 1873 /* These are only really needed if there is a memory limit in 1874 * effect, but we don't know so export them always. */ 1875 prom_tce_alloc_start = local_alloc_bottom; 1876 prom_tce_alloc_end = local_alloc_top; 1877 1878 /* Flag the first invalid entry */ 1879 prom_debug("ending prom_initialize_tce_table\n"); 1880 } 1881 #endif /* __BIG_ENDIAN__ */ 1882 #endif /* CONFIG_PPC64 */ 1883 1884 /* 1885 * With CHRP SMP we need to use the OF to start the other processors. 1886 * We can't wait until smp_boot_cpus (the OF is trashed by then) 1887 * so we have to put the processors into a holding pattern controlled 1888 * by the kernel (not OF) before we destroy the OF. 1889 * 1890 * This uses a chunk of low memory, puts some holding pattern 1891 * code there and sends the other processors off to there until 1892 * smp_boot_cpus tells them to do something. The holding pattern 1893 * checks that address until its cpu # is there, when it is that 1894 * cpu jumps to __secondary_start(). smp_boot_cpus() takes care 1895 * of setting those values. 1896 * 1897 * We also use physical address 0x4 here to tell when a cpu 1898 * is in its holding pattern code. 1899 * 1900 * -- Cort 1901 */ 1902 /* 1903 * We want to reference the copy of __secondary_hold_* in the 1904 * 0 - 0x100 address range 1905 */ 1906 #define LOW_ADDR(x) (((unsigned long) &(x)) & 0xff) 1907 1908 static void __init prom_hold_cpus(void) 1909 { 1910 unsigned long i; 1911 phandle node; 1912 char type[64]; 1913 unsigned long *spinloop 1914 = (void *) LOW_ADDR(__secondary_hold_spinloop); 1915 unsigned long *acknowledge 1916 = (void *) LOW_ADDR(__secondary_hold_acknowledge); 1917 unsigned long secondary_hold = LOW_ADDR(__secondary_hold); 1918 1919 /* 1920 * On pseries, if RTAS supports "query-cpu-stopped-state", 1921 * we skip this stage, the CPUs will be started by the 1922 * kernel using RTAS. 1923 */ 1924 if ((of_platform == PLATFORM_PSERIES || 1925 of_platform == PLATFORM_PSERIES_LPAR) && 1926 rtas_has_query_cpu_stopped) { 1927 prom_printf("prom_hold_cpus: skipped\n"); 1928 return; 1929 } 1930 1931 prom_debug("prom_hold_cpus: start...\n"); 1932 prom_debug(" 1) spinloop = 0x%x\n", (unsigned long)spinloop); 1933 prom_debug(" 1) *spinloop = 0x%x\n", *spinloop); 1934 prom_debug(" 1) acknowledge = 0x%x\n", 1935 (unsigned long)acknowledge); 1936 prom_debug(" 1) *acknowledge = 0x%x\n", *acknowledge); 1937 prom_debug(" 1) secondary_hold = 0x%x\n", secondary_hold); 1938 1939 /* Set the common spinloop variable, so all of the secondary cpus 1940 * will block when they are awakened from their OF spinloop. 1941 * This must occur for both SMP and non SMP kernels, since OF will 1942 * be trashed when we move the kernel. 1943 */ 1944 *spinloop = 0; 1945 1946 /* look for cpus */ 1947 for (node = 0; prom_next_node(&node); ) { 1948 unsigned int cpu_no; 1949 __be32 reg; 1950 1951 type[0] = 0; 1952 prom_getprop(node, "device_type", type, sizeof(type)); 1953 if (strcmp(type, "cpu") != 0) 1954 continue; 1955 1956 /* Skip non-configured cpus. */ 1957 if (prom_getprop(node, "status", type, sizeof(type)) > 0) 1958 if (strcmp(type, "okay") != 0) 1959 continue; 1960 1961 reg = cpu_to_be32(-1); /* make sparse happy */ 1962 prom_getprop(node, "reg", ®, sizeof(reg)); 1963 cpu_no = be32_to_cpu(reg); 1964 1965 prom_debug("cpu hw idx = %lu\n", cpu_no); 1966 1967 /* Init the acknowledge var which will be reset by 1968 * the secondary cpu when it awakens from its OF 1969 * spinloop. 1970 */ 1971 *acknowledge = (unsigned long)-1; 1972 1973 if (cpu_no != prom.cpu) { 1974 /* Primary Thread of non-boot cpu or any thread */ 1975 prom_printf("starting cpu hw idx %lu... ", cpu_no); 1976 call_prom("start-cpu", 3, 0, node, 1977 secondary_hold, cpu_no); 1978 1979 for (i = 0; (i < 100000000) && 1980 (*acknowledge == ((unsigned long)-1)); i++ ) 1981 mb(); 1982 1983 if (*acknowledge == cpu_no) 1984 prom_printf("done\n"); 1985 else 1986 prom_printf("failed: %x\n", *acknowledge); 1987 } 1988 #ifdef CONFIG_SMP 1989 else 1990 prom_printf("boot cpu hw idx %lu\n", cpu_no); 1991 #endif /* CONFIG_SMP */ 1992 } 1993 1994 prom_debug("prom_hold_cpus: end...\n"); 1995 } 1996 1997 1998 static void __init prom_init_client_services(unsigned long pp) 1999 { 2000 /* Get a handle to the prom entry point before anything else */ 2001 prom_entry = pp; 2002 2003 /* get a handle for the stdout device */ 2004 prom.chosen = call_prom("finddevice", 1, 1, ADDR("/chosen")); 2005 if (!PHANDLE_VALID(prom.chosen)) 2006 prom_panic("cannot find chosen"); /* msg won't be printed :( */ 2007 2008 /* get device tree root */ 2009 prom.root = call_prom("finddevice", 1, 1, ADDR("/")); 2010 if (!PHANDLE_VALID(prom.root)) 2011 prom_panic("cannot find device tree root"); /* msg won't be printed :( */ 2012 2013 prom.mmumap = 0; 2014 } 2015 2016 #ifdef CONFIG_PPC32 2017 /* 2018 * For really old powermacs, we need to map things we claim. 2019 * For that, we need the ihandle of the mmu. 2020 * Also, on the longtrail, we need to work around other bugs. 2021 */ 2022 static void __init prom_find_mmu(void) 2023 { 2024 phandle oprom; 2025 char version[64]; 2026 2027 oprom = call_prom("finddevice", 1, 1, ADDR("/openprom")); 2028 if (!PHANDLE_VALID(oprom)) 2029 return; 2030 if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0) 2031 return; 2032 version[sizeof(version) - 1] = 0; 2033 /* XXX might need to add other versions here */ 2034 if (strcmp(version, "Open Firmware, 1.0.5") == 0) 2035 of_workarounds = OF_WA_CLAIM; 2036 else if (strncmp(version, "FirmWorks,3.", 12) == 0) { 2037 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL; 2038 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim"); 2039 } else 2040 return; 2041 prom.memory = call_prom("open", 1, 1, ADDR("/memory")); 2042 prom_getprop(prom.chosen, "mmu", &prom.mmumap, 2043 sizeof(prom.mmumap)); 2044 prom.mmumap = be32_to_cpu(prom.mmumap); 2045 if (!IHANDLE_VALID(prom.memory) || !IHANDLE_VALID(prom.mmumap)) 2046 of_workarounds &= ~OF_WA_CLAIM; /* hmmm */ 2047 } 2048 #else 2049 #define prom_find_mmu() 2050 #endif 2051 2052 static void __init prom_init_stdout(void) 2053 { 2054 char *path = of_stdout_device; 2055 char type[16]; 2056 phandle stdout_node; 2057 __be32 val; 2058 2059 if (prom_getprop(prom.chosen, "stdout", &val, sizeof(val)) <= 0) 2060 prom_panic("cannot find stdout"); 2061 2062 prom.stdout = be32_to_cpu(val); 2063 2064 /* Get the full OF pathname of the stdout device */ 2065 memset(path, 0, 256); 2066 call_prom("instance-to-path", 3, 1, prom.stdout, path, 255); 2067 prom_printf("OF stdout device is: %s\n", of_stdout_device); 2068 prom_setprop(prom.chosen, "/chosen", "linux,stdout-path", 2069 path, strlen(path) + 1); 2070 2071 /* instance-to-package fails on PA-Semi */ 2072 stdout_node = call_prom("instance-to-package", 1, 1, prom.stdout); 2073 if (stdout_node != PROM_ERROR) { 2074 val = cpu_to_be32(stdout_node); 2075 prom_setprop(prom.chosen, "/chosen", "linux,stdout-package", 2076 &val, sizeof(val)); 2077 2078 /* If it's a display, note it */ 2079 memset(type, 0, sizeof(type)); 2080 prom_getprop(stdout_node, "device_type", type, sizeof(type)); 2081 if (strcmp(type, "display") == 0) 2082 prom_setprop(stdout_node, path, "linux,boot-display", NULL, 0); 2083 } 2084 } 2085 2086 static int __init prom_find_machine_type(void) 2087 { 2088 char compat[256]; 2089 int len, i = 0; 2090 #ifdef CONFIG_PPC64 2091 phandle rtas; 2092 int x; 2093 #endif 2094 2095 /* Look for a PowerMac or a Cell */ 2096 len = prom_getprop(prom.root, "compatible", 2097 compat, sizeof(compat)-1); 2098 if (len > 0) { 2099 compat[len] = 0; 2100 while (i < len) { 2101 char *p = &compat[i]; 2102 int sl = strlen(p); 2103 if (sl == 0) 2104 break; 2105 if (strstr(p, "Power Macintosh") || 2106 strstr(p, "MacRISC")) 2107 return PLATFORM_POWERMAC; 2108 #ifdef CONFIG_PPC64 2109 /* We must make sure we don't detect the IBM Cell 2110 * blades as pSeries due to some firmware issues, 2111 * so we do it here. 2112 */ 2113 if (strstr(p, "IBM,CBEA") || 2114 strstr(p, "IBM,CPBW-1.0")) 2115 return PLATFORM_GENERIC; 2116 #endif /* CONFIG_PPC64 */ 2117 i += sl + 1; 2118 } 2119 } 2120 #ifdef CONFIG_PPC64 2121 /* Try to detect OPAL */ 2122 if (PHANDLE_VALID(call_prom("finddevice", 1, 1, ADDR("/ibm,opal")))) 2123 return PLATFORM_OPAL; 2124 2125 /* Try to figure out if it's an IBM pSeries or any other 2126 * PAPR compliant platform. We assume it is if : 2127 * - /device_type is "chrp" (please, do NOT use that for future 2128 * non-IBM designs ! 2129 * - it has /rtas 2130 */ 2131 len = prom_getprop(prom.root, "device_type", 2132 compat, sizeof(compat)-1); 2133 if (len <= 0) 2134 return PLATFORM_GENERIC; 2135 if (strcmp(compat, "chrp")) 2136 return PLATFORM_GENERIC; 2137 2138 /* Default to pSeries. We need to know if we are running LPAR */ 2139 rtas = call_prom("finddevice", 1, 1, ADDR("/rtas")); 2140 if (!PHANDLE_VALID(rtas)) 2141 return PLATFORM_GENERIC; 2142 x = prom_getproplen(rtas, "ibm,hypertas-functions"); 2143 if (x != PROM_ERROR) { 2144 prom_debug("Hypertas detected, assuming LPAR !\n"); 2145 return PLATFORM_PSERIES_LPAR; 2146 } 2147 return PLATFORM_PSERIES; 2148 #else 2149 return PLATFORM_GENERIC; 2150 #endif 2151 } 2152 2153 static int __init prom_set_color(ihandle ih, int i, int r, int g, int b) 2154 { 2155 return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r); 2156 } 2157 2158 /* 2159 * If we have a display that we don't know how to drive, 2160 * we will want to try to execute OF's open method for it 2161 * later. However, OF will probably fall over if we do that 2162 * we've taken over the MMU. 2163 * So we check whether we will need to open the display, 2164 * and if so, open it now. 2165 */ 2166 static void __init prom_check_displays(void) 2167 { 2168 char type[16], *path; 2169 phandle node; 2170 ihandle ih; 2171 int i; 2172 2173 static unsigned char default_colors[] = { 2174 0x00, 0x00, 0x00, 2175 0x00, 0x00, 0xaa, 2176 0x00, 0xaa, 0x00, 2177 0x00, 0xaa, 0xaa, 2178 0xaa, 0x00, 0x00, 2179 0xaa, 0x00, 0xaa, 2180 0xaa, 0xaa, 0x00, 2181 0xaa, 0xaa, 0xaa, 2182 0x55, 0x55, 0x55, 2183 0x55, 0x55, 0xff, 2184 0x55, 0xff, 0x55, 2185 0x55, 0xff, 0xff, 2186 0xff, 0x55, 0x55, 2187 0xff, 0x55, 0xff, 2188 0xff, 0xff, 0x55, 2189 0xff, 0xff, 0xff 2190 }; 2191 const unsigned char *clut; 2192 2193 prom_debug("Looking for displays\n"); 2194 for (node = 0; prom_next_node(&node); ) { 2195 memset(type, 0, sizeof(type)); 2196 prom_getprop(node, "device_type", type, sizeof(type)); 2197 if (strcmp(type, "display") != 0) 2198 continue; 2199 2200 /* It seems OF doesn't null-terminate the path :-( */ 2201 path = prom_scratch; 2202 memset(path, 0, PROM_SCRATCH_SIZE); 2203 2204 /* 2205 * leave some room at the end of the path for appending extra 2206 * arguments 2207 */ 2208 if (call_prom("package-to-path", 3, 1, node, path, 2209 PROM_SCRATCH_SIZE-10) == PROM_ERROR) 2210 continue; 2211 prom_printf("found display : %s, opening... ", path); 2212 2213 ih = call_prom("open", 1, 1, path); 2214 if (ih == 0) { 2215 prom_printf("failed\n"); 2216 continue; 2217 } 2218 2219 /* Success */ 2220 prom_printf("done\n"); 2221 prom_setprop(node, path, "linux,opened", NULL, 0); 2222 2223 /* Setup a usable color table when the appropriate 2224 * method is available. Should update this to set-colors */ 2225 clut = default_colors; 2226 for (i = 0; i < 16; i++, clut += 3) 2227 if (prom_set_color(ih, i, clut[0], clut[1], 2228 clut[2]) != 0) 2229 break; 2230 2231 #ifdef CONFIG_LOGO_LINUX_CLUT224 2232 clut = PTRRELOC(logo_linux_clut224.clut); 2233 for (i = 0; i < logo_linux_clut224.clutsize; i++, clut += 3) 2234 if (prom_set_color(ih, i + 32, clut[0], clut[1], 2235 clut[2]) != 0) 2236 break; 2237 #endif /* CONFIG_LOGO_LINUX_CLUT224 */ 2238 2239 #ifdef CONFIG_PPC_EARLY_DEBUG_BOOTX 2240 if (prom_getprop(node, "linux,boot-display", NULL, 0) != 2241 PROM_ERROR) { 2242 u32 width, height, pitch, addr; 2243 2244 prom_printf("Setting btext !\n"); 2245 prom_getprop(node, "width", &width, 4); 2246 prom_getprop(node, "height", &height, 4); 2247 prom_getprop(node, "linebytes", &pitch, 4); 2248 prom_getprop(node, "address", &addr, 4); 2249 prom_printf("W=%d H=%d LB=%d addr=0x%x\n", 2250 width, height, pitch, addr); 2251 btext_setup_display(width, height, 8, pitch, addr); 2252 } 2253 #endif /* CONFIG_PPC_EARLY_DEBUG_BOOTX */ 2254 } 2255 } 2256 2257 2258 /* Return (relocated) pointer to this much memory: moves initrd if reqd. */ 2259 static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end, 2260 unsigned long needed, unsigned long align) 2261 { 2262 void *ret; 2263 2264 *mem_start = _ALIGN(*mem_start, align); 2265 while ((*mem_start + needed) > *mem_end) { 2266 unsigned long room, chunk; 2267 2268 prom_debug("Chunk exhausted, claiming more at %x...\n", 2269 alloc_bottom); 2270 room = alloc_top - alloc_bottom; 2271 if (room > DEVTREE_CHUNK_SIZE) 2272 room = DEVTREE_CHUNK_SIZE; 2273 if (room < PAGE_SIZE) 2274 prom_panic("No memory for flatten_device_tree " 2275 "(no room)\n"); 2276 chunk = alloc_up(room, 0); 2277 if (chunk == 0) 2278 prom_panic("No memory for flatten_device_tree " 2279 "(claim failed)\n"); 2280 *mem_end = chunk + room; 2281 } 2282 2283 ret = (void *)*mem_start; 2284 *mem_start += needed; 2285 2286 return ret; 2287 } 2288 2289 #define dt_push_token(token, mem_start, mem_end) do { \ 2290 void *room = make_room(mem_start, mem_end, 4, 4); \ 2291 *(__be32 *)room = cpu_to_be32(token); \ 2292 } while(0) 2293 2294 static unsigned long __init dt_find_string(char *str) 2295 { 2296 char *s, *os; 2297 2298 s = os = (char *)dt_string_start; 2299 s += 4; 2300 while (s < (char *)dt_string_end) { 2301 if (strcmp(s, str) == 0) 2302 return s - os; 2303 s += strlen(s) + 1; 2304 } 2305 return 0; 2306 } 2307 2308 /* 2309 * The Open Firmware 1275 specification states properties must be 31 bytes or 2310 * less, however not all firmwares obey this. Make it 64 bytes to be safe. 2311 */ 2312 #define MAX_PROPERTY_NAME 64 2313 2314 static void __init scan_dt_build_strings(phandle node, 2315 unsigned long *mem_start, 2316 unsigned long *mem_end) 2317 { 2318 char *prev_name, *namep, *sstart; 2319 unsigned long soff; 2320 phandle child; 2321 2322 sstart = (char *)dt_string_start; 2323 2324 /* get and store all property names */ 2325 prev_name = ""; 2326 for (;;) { 2327 /* 64 is max len of name including nul. */ 2328 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1); 2329 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) { 2330 /* No more nodes: unwind alloc */ 2331 *mem_start = (unsigned long)namep; 2332 break; 2333 } 2334 2335 /* skip "name" */ 2336 if (strcmp(namep, "name") == 0) { 2337 *mem_start = (unsigned long)namep; 2338 prev_name = "name"; 2339 continue; 2340 } 2341 /* get/create string entry */ 2342 soff = dt_find_string(namep); 2343 if (soff != 0) { 2344 *mem_start = (unsigned long)namep; 2345 namep = sstart + soff; 2346 } else { 2347 /* Trim off some if we can */ 2348 *mem_start = (unsigned long)namep + strlen(namep) + 1; 2349 dt_string_end = *mem_start; 2350 } 2351 prev_name = namep; 2352 } 2353 2354 /* do all our children */ 2355 child = call_prom("child", 1, 1, node); 2356 while (child != 0) { 2357 scan_dt_build_strings(child, mem_start, mem_end); 2358 child = call_prom("peer", 1, 1, child); 2359 } 2360 } 2361 2362 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start, 2363 unsigned long *mem_end) 2364 { 2365 phandle child; 2366 char *namep, *prev_name, *sstart, *p, *ep, *lp, *path; 2367 unsigned long soff; 2368 unsigned char *valp; 2369 static char pname[MAX_PROPERTY_NAME]; 2370 int l, room, has_phandle = 0; 2371 2372 dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end); 2373 2374 /* get the node's full name */ 2375 namep = (char *)*mem_start; 2376 room = *mem_end - *mem_start; 2377 if (room > 255) 2378 room = 255; 2379 l = call_prom("package-to-path", 3, 1, node, namep, room); 2380 if (l >= 0) { 2381 /* Didn't fit? Get more room. */ 2382 if (l >= room) { 2383 if (l >= *mem_end - *mem_start) 2384 namep = make_room(mem_start, mem_end, l+1, 1); 2385 call_prom("package-to-path", 3, 1, node, namep, l); 2386 } 2387 namep[l] = '\0'; 2388 2389 /* Fixup an Apple bug where they have bogus \0 chars in the 2390 * middle of the path in some properties, and extract 2391 * the unit name (everything after the last '/'). 2392 */ 2393 for (lp = p = namep, ep = namep + l; p < ep; p++) { 2394 if (*p == '/') 2395 lp = namep; 2396 else if (*p != 0) 2397 *lp++ = *p; 2398 } 2399 *lp = 0; 2400 *mem_start = _ALIGN((unsigned long)lp + 1, 4); 2401 } 2402 2403 /* get it again for debugging */ 2404 path = prom_scratch; 2405 memset(path, 0, PROM_SCRATCH_SIZE); 2406 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1); 2407 2408 /* get and store all properties */ 2409 prev_name = ""; 2410 sstart = (char *)dt_string_start; 2411 for (;;) { 2412 if (call_prom("nextprop", 3, 1, node, prev_name, 2413 pname) != 1) 2414 break; 2415 2416 /* skip "name" */ 2417 if (strcmp(pname, "name") == 0) { 2418 prev_name = "name"; 2419 continue; 2420 } 2421 2422 /* find string offset */ 2423 soff = dt_find_string(pname); 2424 if (soff == 0) { 2425 prom_printf("WARNING: Can't find string index for" 2426 " <%s>, node %s\n", pname, path); 2427 break; 2428 } 2429 prev_name = sstart + soff; 2430 2431 /* get length */ 2432 l = call_prom("getproplen", 2, 1, node, pname); 2433 2434 /* sanity checks */ 2435 if (l == PROM_ERROR) 2436 continue; 2437 2438 /* push property head */ 2439 dt_push_token(OF_DT_PROP, mem_start, mem_end); 2440 dt_push_token(l, mem_start, mem_end); 2441 dt_push_token(soff, mem_start, mem_end); 2442 2443 /* push property content */ 2444 valp = make_room(mem_start, mem_end, l, 4); 2445 call_prom("getprop", 4, 1, node, pname, valp, l); 2446 *mem_start = _ALIGN(*mem_start, 4); 2447 2448 if (!strcmp(pname, "phandle")) 2449 has_phandle = 1; 2450 } 2451 2452 /* Add a "linux,phandle" property if no "phandle" property already 2453 * existed (can happen with OPAL) 2454 */ 2455 if (!has_phandle) { 2456 soff = dt_find_string("linux,phandle"); 2457 if (soff == 0) 2458 prom_printf("WARNING: Can't find string index for" 2459 " <linux-phandle> node %s\n", path); 2460 else { 2461 dt_push_token(OF_DT_PROP, mem_start, mem_end); 2462 dt_push_token(4, mem_start, mem_end); 2463 dt_push_token(soff, mem_start, mem_end); 2464 valp = make_room(mem_start, mem_end, 4, 4); 2465 *(__be32 *)valp = cpu_to_be32(node); 2466 } 2467 } 2468 2469 /* do all our children */ 2470 child = call_prom("child", 1, 1, node); 2471 while (child != 0) { 2472 scan_dt_build_struct(child, mem_start, mem_end); 2473 child = call_prom("peer", 1, 1, child); 2474 } 2475 2476 dt_push_token(OF_DT_END_NODE, mem_start, mem_end); 2477 } 2478 2479 static void __init flatten_device_tree(void) 2480 { 2481 phandle root; 2482 unsigned long mem_start, mem_end, room; 2483 struct boot_param_header *hdr; 2484 char *namep; 2485 u64 *rsvmap; 2486 2487 /* 2488 * Check how much room we have between alloc top & bottom (+/- a 2489 * few pages), crop to 1MB, as this is our "chunk" size 2490 */ 2491 room = alloc_top - alloc_bottom - 0x4000; 2492 if (room > DEVTREE_CHUNK_SIZE) 2493 room = DEVTREE_CHUNK_SIZE; 2494 prom_debug("starting device tree allocs at %x\n", alloc_bottom); 2495 2496 /* Now try to claim that */ 2497 mem_start = (unsigned long)alloc_up(room, PAGE_SIZE); 2498 if (mem_start == 0) 2499 prom_panic("Can't allocate initial device-tree chunk\n"); 2500 mem_end = mem_start + room; 2501 2502 /* Get root of tree */ 2503 root = call_prom("peer", 1, 1, (phandle)0); 2504 if (root == (phandle)0) 2505 prom_panic ("couldn't get device tree root\n"); 2506 2507 /* Build header and make room for mem rsv map */ 2508 mem_start = _ALIGN(mem_start, 4); 2509 hdr = make_room(&mem_start, &mem_end, 2510 sizeof(struct boot_param_header), 4); 2511 dt_header_start = (unsigned long)hdr; 2512 rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8); 2513 2514 /* Start of strings */ 2515 mem_start = PAGE_ALIGN(mem_start); 2516 dt_string_start = mem_start; 2517 mem_start += 4; /* hole */ 2518 2519 /* Add "linux,phandle" in there, we'll need it */ 2520 namep = make_room(&mem_start, &mem_end, 16, 1); 2521 strcpy(namep, "linux,phandle"); 2522 mem_start = (unsigned long)namep + strlen(namep) + 1; 2523 2524 /* Build string array */ 2525 prom_printf("Building dt strings...\n"); 2526 scan_dt_build_strings(root, &mem_start, &mem_end); 2527 dt_string_end = mem_start; 2528 2529 /* Build structure */ 2530 mem_start = PAGE_ALIGN(mem_start); 2531 dt_struct_start = mem_start; 2532 prom_printf("Building dt structure...\n"); 2533 scan_dt_build_struct(root, &mem_start, &mem_end); 2534 dt_push_token(OF_DT_END, &mem_start, &mem_end); 2535 dt_struct_end = PAGE_ALIGN(mem_start); 2536 2537 /* Finish header */ 2538 hdr->boot_cpuid_phys = cpu_to_be32(prom.cpu); 2539 hdr->magic = cpu_to_be32(OF_DT_HEADER); 2540 hdr->totalsize = cpu_to_be32(dt_struct_end - dt_header_start); 2541 hdr->off_dt_struct = cpu_to_be32(dt_struct_start - dt_header_start); 2542 hdr->off_dt_strings = cpu_to_be32(dt_string_start - dt_header_start); 2543 hdr->dt_strings_size = cpu_to_be32(dt_string_end - dt_string_start); 2544 hdr->off_mem_rsvmap = cpu_to_be32(((unsigned long)rsvmap) - dt_header_start); 2545 hdr->version = cpu_to_be32(OF_DT_VERSION); 2546 /* Version 16 is not backward compatible */ 2547 hdr->last_comp_version = cpu_to_be32(0x10); 2548 2549 /* Copy the reserve map in */ 2550 memcpy(rsvmap, mem_reserve_map, sizeof(mem_reserve_map)); 2551 2552 #ifdef DEBUG_PROM 2553 { 2554 int i; 2555 prom_printf("reserved memory map:\n"); 2556 for (i = 0; i < mem_reserve_cnt; i++) 2557 prom_printf(" %x - %x\n", 2558 be64_to_cpu(mem_reserve_map[i].base), 2559 be64_to_cpu(mem_reserve_map[i].size)); 2560 } 2561 #endif 2562 /* Bump mem_reserve_cnt to cause further reservations to fail 2563 * since it's too late. 2564 */ 2565 mem_reserve_cnt = MEM_RESERVE_MAP_SIZE; 2566 2567 prom_printf("Device tree strings 0x%x -> 0x%x\n", 2568 dt_string_start, dt_string_end); 2569 prom_printf("Device tree struct 0x%x -> 0x%x\n", 2570 dt_struct_start, dt_struct_end); 2571 } 2572 2573 #ifdef CONFIG_PPC_MAPLE 2574 /* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property. 2575 * The values are bad, and it doesn't even have the right number of cells. */ 2576 static void __init fixup_device_tree_maple(void) 2577 { 2578 phandle isa; 2579 u32 rloc = 0x01002000; /* IO space; PCI device = 4 */ 2580 u32 isa_ranges[6]; 2581 char *name; 2582 2583 name = "/ht@0/isa@4"; 2584 isa = call_prom("finddevice", 1, 1, ADDR(name)); 2585 if (!PHANDLE_VALID(isa)) { 2586 name = "/ht@0/isa@6"; 2587 isa = call_prom("finddevice", 1, 1, ADDR(name)); 2588 rloc = 0x01003000; /* IO space; PCI device = 6 */ 2589 } 2590 if (!PHANDLE_VALID(isa)) 2591 return; 2592 2593 if (prom_getproplen(isa, "ranges") != 12) 2594 return; 2595 if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges)) 2596 == PROM_ERROR) 2597 return; 2598 2599 if (isa_ranges[0] != 0x1 || 2600 isa_ranges[1] != 0xf4000000 || 2601 isa_ranges[2] != 0x00010000) 2602 return; 2603 2604 prom_printf("Fixing up bogus ISA range on Maple/Apache...\n"); 2605 2606 isa_ranges[0] = 0x1; 2607 isa_ranges[1] = 0x0; 2608 isa_ranges[2] = rloc; 2609 isa_ranges[3] = 0x0; 2610 isa_ranges[4] = 0x0; 2611 isa_ranges[5] = 0x00010000; 2612 prom_setprop(isa, name, "ranges", 2613 isa_ranges, sizeof(isa_ranges)); 2614 } 2615 2616 #define CPC925_MC_START 0xf8000000 2617 #define CPC925_MC_LENGTH 0x1000000 2618 /* The values for memory-controller don't have right number of cells */ 2619 static void __init fixup_device_tree_maple_memory_controller(void) 2620 { 2621 phandle mc; 2622 u32 mc_reg[4]; 2623 char *name = "/hostbridge@f8000000"; 2624 u32 ac, sc; 2625 2626 mc = call_prom("finddevice", 1, 1, ADDR(name)); 2627 if (!PHANDLE_VALID(mc)) 2628 return; 2629 2630 if (prom_getproplen(mc, "reg") != 8) 2631 return; 2632 2633 prom_getprop(prom.root, "#address-cells", &ac, sizeof(ac)); 2634 prom_getprop(prom.root, "#size-cells", &sc, sizeof(sc)); 2635 if ((ac != 2) || (sc != 2)) 2636 return; 2637 2638 if (prom_getprop(mc, "reg", mc_reg, sizeof(mc_reg)) == PROM_ERROR) 2639 return; 2640 2641 if (mc_reg[0] != CPC925_MC_START || mc_reg[1] != CPC925_MC_LENGTH) 2642 return; 2643 2644 prom_printf("Fixing up bogus hostbridge on Maple...\n"); 2645 2646 mc_reg[0] = 0x0; 2647 mc_reg[1] = CPC925_MC_START; 2648 mc_reg[2] = 0x0; 2649 mc_reg[3] = CPC925_MC_LENGTH; 2650 prom_setprop(mc, name, "reg", mc_reg, sizeof(mc_reg)); 2651 } 2652 #else 2653 #define fixup_device_tree_maple() 2654 #define fixup_device_tree_maple_memory_controller() 2655 #endif 2656 2657 #ifdef CONFIG_PPC_CHRP 2658 /* 2659 * Pegasos and BriQ lacks the "ranges" property in the isa node 2660 * Pegasos needs decimal IRQ 14/15, not hexadecimal 2661 * Pegasos has the IDE configured in legacy mode, but advertised as native 2662 */ 2663 static void __init fixup_device_tree_chrp(void) 2664 { 2665 phandle ph; 2666 u32 prop[6]; 2667 u32 rloc = 0x01006000; /* IO space; PCI device = 12 */ 2668 char *name; 2669 int rc; 2670 2671 name = "/pci@80000000/isa@c"; 2672 ph = call_prom("finddevice", 1, 1, ADDR(name)); 2673 if (!PHANDLE_VALID(ph)) { 2674 name = "/pci@ff500000/isa@6"; 2675 ph = call_prom("finddevice", 1, 1, ADDR(name)); 2676 rloc = 0x01003000; /* IO space; PCI device = 6 */ 2677 } 2678 if (PHANDLE_VALID(ph)) { 2679 rc = prom_getproplen(ph, "ranges"); 2680 if (rc == 0 || rc == PROM_ERROR) { 2681 prom_printf("Fixing up missing ISA range on Pegasos...\n"); 2682 2683 prop[0] = 0x1; 2684 prop[1] = 0x0; 2685 prop[2] = rloc; 2686 prop[3] = 0x0; 2687 prop[4] = 0x0; 2688 prop[5] = 0x00010000; 2689 prom_setprop(ph, name, "ranges", prop, sizeof(prop)); 2690 } 2691 } 2692 2693 name = "/pci@80000000/ide@C,1"; 2694 ph = call_prom("finddevice", 1, 1, ADDR(name)); 2695 if (PHANDLE_VALID(ph)) { 2696 prom_printf("Fixing up IDE interrupt on Pegasos...\n"); 2697 prop[0] = 14; 2698 prop[1] = 0x0; 2699 prom_setprop(ph, name, "interrupts", prop, 2*sizeof(u32)); 2700 prom_printf("Fixing up IDE class-code on Pegasos...\n"); 2701 rc = prom_getprop(ph, "class-code", prop, sizeof(u32)); 2702 if (rc == sizeof(u32)) { 2703 prop[0] &= ~0x5; 2704 prom_setprop(ph, name, "class-code", prop, sizeof(u32)); 2705 } 2706 } 2707 } 2708 #else 2709 #define fixup_device_tree_chrp() 2710 #endif 2711 2712 #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC) 2713 static void __init fixup_device_tree_pmac(void) 2714 { 2715 phandle u3, i2c, mpic; 2716 u32 u3_rev; 2717 u32 interrupts[2]; 2718 u32 parent; 2719 2720 /* Some G5s have a missing interrupt definition, fix it up here */ 2721 u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000")); 2722 if (!PHANDLE_VALID(u3)) 2723 return; 2724 i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000")); 2725 if (!PHANDLE_VALID(i2c)) 2726 return; 2727 mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000")); 2728 if (!PHANDLE_VALID(mpic)) 2729 return; 2730 2731 /* check if proper rev of u3 */ 2732 if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev)) 2733 == PROM_ERROR) 2734 return; 2735 if (u3_rev < 0x35 || u3_rev > 0x39) 2736 return; 2737 /* does it need fixup ? */ 2738 if (prom_getproplen(i2c, "interrupts") > 0) 2739 return; 2740 2741 prom_printf("fixing up bogus interrupts for u3 i2c...\n"); 2742 2743 /* interrupt on this revision of u3 is number 0 and level */ 2744 interrupts[0] = 0; 2745 interrupts[1] = 1; 2746 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts", 2747 &interrupts, sizeof(interrupts)); 2748 parent = (u32)mpic; 2749 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent", 2750 &parent, sizeof(parent)); 2751 } 2752 #else 2753 #define fixup_device_tree_pmac() 2754 #endif 2755 2756 #ifdef CONFIG_PPC_EFIKA 2757 /* 2758 * The MPC5200 FEC driver requires an phy-handle property to tell it how 2759 * to talk to the phy. If the phy-handle property is missing, then this 2760 * function is called to add the appropriate nodes and link it to the 2761 * ethernet node. 2762 */ 2763 static void __init fixup_device_tree_efika_add_phy(void) 2764 { 2765 u32 node; 2766 char prop[64]; 2767 int rv; 2768 2769 /* Check if /builtin/ethernet exists - bail if it doesn't */ 2770 node = call_prom("finddevice", 1, 1, ADDR("/builtin/ethernet")); 2771 if (!PHANDLE_VALID(node)) 2772 return; 2773 2774 /* Check if the phy-handle property exists - bail if it does */ 2775 rv = prom_getprop(node, "phy-handle", prop, sizeof(prop)); 2776 if (!rv) 2777 return; 2778 2779 /* 2780 * At this point the ethernet device doesn't have a phy described. 2781 * Now we need to add the missing phy node and linkage 2782 */ 2783 2784 /* Check for an MDIO bus node - if missing then create one */ 2785 node = call_prom("finddevice", 1, 1, ADDR("/builtin/mdio")); 2786 if (!PHANDLE_VALID(node)) { 2787 prom_printf("Adding Ethernet MDIO node\n"); 2788 call_prom("interpret", 1, 1, 2789 " s\" /builtin\" find-device" 2790 " new-device" 2791 " 1 encode-int s\" #address-cells\" property" 2792 " 0 encode-int s\" #size-cells\" property" 2793 " s\" mdio\" device-name" 2794 " s\" fsl,mpc5200b-mdio\" encode-string" 2795 " s\" compatible\" property" 2796 " 0xf0003000 0x400 reg" 2797 " 0x2 encode-int" 2798 " 0x5 encode-int encode+" 2799 " 0x3 encode-int encode+" 2800 " s\" interrupts\" property" 2801 " finish-device"); 2802 }; 2803 2804 /* Check for a PHY device node - if missing then create one and 2805 * give it's phandle to the ethernet node */ 2806 node = call_prom("finddevice", 1, 1, 2807 ADDR("/builtin/mdio/ethernet-phy")); 2808 if (!PHANDLE_VALID(node)) { 2809 prom_printf("Adding Ethernet PHY node\n"); 2810 call_prom("interpret", 1, 1, 2811 " s\" /builtin/mdio\" find-device" 2812 " new-device" 2813 " s\" ethernet-phy\" device-name" 2814 " 0x10 encode-int s\" reg\" property" 2815 " my-self" 2816 " ihandle>phandle" 2817 " finish-device" 2818 " s\" /builtin/ethernet\" find-device" 2819 " encode-int" 2820 " s\" phy-handle\" property" 2821 " device-end"); 2822 } 2823 } 2824 2825 static void __init fixup_device_tree_efika(void) 2826 { 2827 int sound_irq[3] = { 2, 2, 0 }; 2828 int bcomm_irq[3*16] = { 3,0,0, 3,1,0, 3,2,0, 3,3,0, 2829 3,4,0, 3,5,0, 3,6,0, 3,7,0, 2830 3,8,0, 3,9,0, 3,10,0, 3,11,0, 2831 3,12,0, 3,13,0, 3,14,0, 3,15,0 }; 2832 u32 node; 2833 char prop[64]; 2834 int rv, len; 2835 2836 /* Check if we're really running on a EFIKA */ 2837 node = call_prom("finddevice", 1, 1, ADDR("/")); 2838 if (!PHANDLE_VALID(node)) 2839 return; 2840 2841 rv = prom_getprop(node, "model", prop, sizeof(prop)); 2842 if (rv == PROM_ERROR) 2843 return; 2844 if (strcmp(prop, "EFIKA5K2")) 2845 return; 2846 2847 prom_printf("Applying EFIKA device tree fixups\n"); 2848 2849 /* Claiming to be 'chrp' is death */ 2850 node = call_prom("finddevice", 1, 1, ADDR("/")); 2851 rv = prom_getprop(node, "device_type", prop, sizeof(prop)); 2852 if (rv != PROM_ERROR && (strcmp(prop, "chrp") == 0)) 2853 prom_setprop(node, "/", "device_type", "efika", sizeof("efika")); 2854 2855 /* CODEGEN,description is exposed in /proc/cpuinfo so 2856 fix that too */ 2857 rv = prom_getprop(node, "CODEGEN,description", prop, sizeof(prop)); 2858 if (rv != PROM_ERROR && (strstr(prop, "CHRP"))) 2859 prom_setprop(node, "/", "CODEGEN,description", 2860 "Efika 5200B PowerPC System", 2861 sizeof("Efika 5200B PowerPC System")); 2862 2863 /* Fixup bestcomm interrupts property */ 2864 node = call_prom("finddevice", 1, 1, ADDR("/builtin/bestcomm")); 2865 if (PHANDLE_VALID(node)) { 2866 len = prom_getproplen(node, "interrupts"); 2867 if (len == 12) { 2868 prom_printf("Fixing bestcomm interrupts property\n"); 2869 prom_setprop(node, "/builtin/bestcom", "interrupts", 2870 bcomm_irq, sizeof(bcomm_irq)); 2871 } 2872 } 2873 2874 /* Fixup sound interrupts property */ 2875 node = call_prom("finddevice", 1, 1, ADDR("/builtin/sound")); 2876 if (PHANDLE_VALID(node)) { 2877 rv = prom_getprop(node, "interrupts", prop, sizeof(prop)); 2878 if (rv == PROM_ERROR) { 2879 prom_printf("Adding sound interrupts property\n"); 2880 prom_setprop(node, "/builtin/sound", "interrupts", 2881 sound_irq, sizeof(sound_irq)); 2882 } 2883 } 2884 2885 /* Make sure ethernet phy-handle property exists */ 2886 fixup_device_tree_efika_add_phy(); 2887 } 2888 #else 2889 #define fixup_device_tree_efika() 2890 #endif 2891 2892 #ifdef CONFIG_PPC_PASEMI_NEMO 2893 /* 2894 * CFE supplied on Nemo is broken in several ways, biggest 2895 * problem is that it reassigns ISA interrupts to unused mpic ints. 2896 * Add an interrupt-controller property for the io-bridge to use 2897 * and correct the ints so we can attach them to an irq_domain 2898 */ 2899 static void __init fixup_device_tree_pasemi(void) 2900 { 2901 u32 interrupts[2], parent, rval, val = 0; 2902 char *name, *pci_name; 2903 phandle iob, node; 2904 2905 /* Find the root pci node */ 2906 name = "/pxp@0,e0000000"; 2907 iob = call_prom("finddevice", 1, 1, ADDR(name)); 2908 if (!PHANDLE_VALID(iob)) 2909 return; 2910 2911 /* check if interrupt-controller node set yet */ 2912 if (prom_getproplen(iob, "interrupt-controller") !=PROM_ERROR) 2913 return; 2914 2915 prom_printf("adding interrupt-controller property for SB600...\n"); 2916 2917 prom_setprop(iob, name, "interrupt-controller", &val, 0); 2918 2919 pci_name = "/pxp@0,e0000000/pci@11"; 2920 node = call_prom("finddevice", 1, 1, ADDR(pci_name)); 2921 parent = ADDR(iob); 2922 2923 for( ; prom_next_node(&node); ) { 2924 /* scan each node for one with an interrupt */ 2925 if (!PHANDLE_VALID(node)) 2926 continue; 2927 2928 rval = prom_getproplen(node, "interrupts"); 2929 if (rval == 0 || rval == PROM_ERROR) 2930 continue; 2931 2932 prom_getprop(node, "interrupts", &interrupts, sizeof(interrupts)); 2933 if ((interrupts[0] < 212) || (interrupts[0] > 222)) 2934 continue; 2935 2936 /* found a node, update both interrupts and interrupt-parent */ 2937 if ((interrupts[0] >= 212) && (interrupts[0] <= 215)) 2938 interrupts[0] -= 203; 2939 if ((interrupts[0] >= 216) && (interrupts[0] <= 220)) 2940 interrupts[0] -= 213; 2941 if (interrupts[0] == 221) 2942 interrupts[0] = 14; 2943 if (interrupts[0] == 222) 2944 interrupts[0] = 8; 2945 2946 prom_setprop(node, pci_name, "interrupts", interrupts, 2947 sizeof(interrupts)); 2948 prom_setprop(node, pci_name, "interrupt-parent", &parent, 2949 sizeof(parent)); 2950 } 2951 2952 /* 2953 * The io-bridge has device_type set to 'io-bridge' change it to 'isa' 2954 * so that generic isa-bridge code can add the SB600 and its on-board 2955 * peripherals. 2956 */ 2957 name = "/pxp@0,e0000000/io-bridge@0"; 2958 iob = call_prom("finddevice", 1, 1, ADDR(name)); 2959 if (!PHANDLE_VALID(iob)) 2960 return; 2961 2962 /* device_type is already set, just change it. */ 2963 2964 prom_printf("Changing device_type of SB600 node...\n"); 2965 2966 prom_setprop(iob, name, "device_type", "isa", sizeof("isa")); 2967 } 2968 #else /* !CONFIG_PPC_PASEMI_NEMO */ 2969 static inline void fixup_device_tree_pasemi(void) { } 2970 #endif 2971 2972 static void __init fixup_device_tree(void) 2973 { 2974 fixup_device_tree_maple(); 2975 fixup_device_tree_maple_memory_controller(); 2976 fixup_device_tree_chrp(); 2977 fixup_device_tree_pmac(); 2978 fixup_device_tree_efika(); 2979 fixup_device_tree_pasemi(); 2980 } 2981 2982 static void __init prom_find_boot_cpu(void) 2983 { 2984 __be32 rval; 2985 ihandle prom_cpu; 2986 phandle cpu_pkg; 2987 2988 rval = 0; 2989 if (prom_getprop(prom.chosen, "cpu", &rval, sizeof(rval)) <= 0) 2990 return; 2991 prom_cpu = be32_to_cpu(rval); 2992 2993 cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu); 2994 2995 if (!PHANDLE_VALID(cpu_pkg)) 2996 return; 2997 2998 prom_getprop(cpu_pkg, "reg", &rval, sizeof(rval)); 2999 prom.cpu = be32_to_cpu(rval); 3000 3001 prom_debug("Booting CPU hw index = %lu\n", prom.cpu); 3002 } 3003 3004 static void __init prom_check_initrd(unsigned long r3, unsigned long r4) 3005 { 3006 #ifdef CONFIG_BLK_DEV_INITRD 3007 if (r3 && r4 && r4 != 0xdeadbeef) { 3008 __be64 val; 3009 3010 prom_initrd_start = is_kernel_addr(r3) ? __pa(r3) : r3; 3011 prom_initrd_end = prom_initrd_start + r4; 3012 3013 val = cpu_to_be64(prom_initrd_start); 3014 prom_setprop(prom.chosen, "/chosen", "linux,initrd-start", 3015 &val, sizeof(val)); 3016 val = cpu_to_be64(prom_initrd_end); 3017 prom_setprop(prom.chosen, "/chosen", "linux,initrd-end", 3018 &val, sizeof(val)); 3019 3020 reserve_mem(prom_initrd_start, 3021 prom_initrd_end - prom_initrd_start); 3022 3023 prom_debug("initrd_start=0x%x\n", prom_initrd_start); 3024 prom_debug("initrd_end=0x%x\n", prom_initrd_end); 3025 } 3026 #endif /* CONFIG_BLK_DEV_INITRD */ 3027 } 3028 3029 #ifdef CONFIG_PPC64 3030 #ifdef CONFIG_RELOCATABLE 3031 static void reloc_toc(void) 3032 { 3033 } 3034 3035 static void unreloc_toc(void) 3036 { 3037 } 3038 #else 3039 static void __reloc_toc(unsigned long offset, unsigned long nr_entries) 3040 { 3041 unsigned long i; 3042 unsigned long *toc_entry; 3043 3044 /* Get the start of the TOC by using r2 directly. */ 3045 asm volatile("addi %0,2,-0x8000" : "=b" (toc_entry)); 3046 3047 for (i = 0; i < nr_entries; i++) { 3048 *toc_entry = *toc_entry + offset; 3049 toc_entry++; 3050 } 3051 } 3052 3053 static void reloc_toc(void) 3054 { 3055 unsigned long offset = reloc_offset(); 3056 unsigned long nr_entries = 3057 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long); 3058 3059 __reloc_toc(offset, nr_entries); 3060 3061 mb(); 3062 } 3063 3064 static void unreloc_toc(void) 3065 { 3066 unsigned long offset = reloc_offset(); 3067 unsigned long nr_entries = 3068 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long); 3069 3070 mb(); 3071 3072 __reloc_toc(-offset, nr_entries); 3073 } 3074 #endif 3075 #endif 3076 3077 /* 3078 * We enter here early on, when the Open Firmware prom is still 3079 * handling exceptions and the MMU hash table for us. 3080 */ 3081 3082 unsigned long __init prom_init(unsigned long r3, unsigned long r4, 3083 unsigned long pp, 3084 unsigned long r6, unsigned long r7, 3085 unsigned long kbase) 3086 { 3087 unsigned long hdr; 3088 3089 #ifdef CONFIG_PPC32 3090 unsigned long offset = reloc_offset(); 3091 reloc_got2(offset); 3092 #else 3093 reloc_toc(); 3094 #endif 3095 3096 /* 3097 * First zero the BSS 3098 */ 3099 memset(&__bss_start, 0, __bss_stop - __bss_start); 3100 3101 /* 3102 * Init interface to Open Firmware, get some node references, 3103 * like /chosen 3104 */ 3105 prom_init_client_services(pp); 3106 3107 /* 3108 * See if this OF is old enough that we need to do explicit maps 3109 * and other workarounds 3110 */ 3111 prom_find_mmu(); 3112 3113 /* 3114 * Init prom stdout device 3115 */ 3116 prom_init_stdout(); 3117 3118 prom_printf("Preparing to boot %s", linux_banner); 3119 3120 /* 3121 * Get default machine type. At this point, we do not differentiate 3122 * between pSeries SMP and pSeries LPAR 3123 */ 3124 of_platform = prom_find_machine_type(); 3125 prom_printf("Detected machine type: %x\n", of_platform); 3126 3127 #ifndef CONFIG_NONSTATIC_KERNEL 3128 /* Bail if this is a kdump kernel. */ 3129 if (PHYSICAL_START > 0) 3130 prom_panic("Error: You can't boot a kdump kernel from OF!\n"); 3131 #endif 3132 3133 /* 3134 * Check for an initrd 3135 */ 3136 prom_check_initrd(r3, r4); 3137 3138 /* 3139 * Do early parsing of command line 3140 */ 3141 early_cmdline_parse(); 3142 3143 #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV) 3144 /* 3145 * On pSeries, inform the firmware about our capabilities 3146 */ 3147 if (of_platform == PLATFORM_PSERIES || 3148 of_platform == PLATFORM_PSERIES_LPAR) 3149 prom_send_capabilities(); 3150 #endif 3151 3152 /* 3153 * Copy the CPU hold code 3154 */ 3155 if (of_platform != PLATFORM_POWERMAC) 3156 copy_and_flush(0, kbase, 0x100, 0); 3157 3158 /* 3159 * Initialize memory management within prom_init 3160 */ 3161 prom_init_mem(); 3162 3163 /* 3164 * Determine which cpu is actually running right _now_ 3165 */ 3166 prom_find_boot_cpu(); 3167 3168 /* 3169 * Initialize display devices 3170 */ 3171 prom_check_displays(); 3172 3173 #if defined(CONFIG_PPC64) && defined(__BIG_ENDIAN__) 3174 /* 3175 * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else 3176 * that uses the allocator, we need to make sure we get the top of memory 3177 * available for us here... 3178 */ 3179 if (of_platform == PLATFORM_PSERIES) 3180 prom_initialize_tce_table(); 3181 #endif 3182 3183 /* 3184 * On non-powermacs, try to instantiate RTAS. PowerMacs don't 3185 * have a usable RTAS implementation. 3186 */ 3187 if (of_platform != PLATFORM_POWERMAC && 3188 of_platform != PLATFORM_OPAL) 3189 prom_instantiate_rtas(); 3190 3191 #ifdef CONFIG_PPC_POWERNV 3192 if (of_platform == PLATFORM_OPAL) 3193 prom_instantiate_opal(); 3194 #endif /* CONFIG_PPC_POWERNV */ 3195 3196 #ifdef CONFIG_PPC64 3197 /* instantiate sml */ 3198 prom_instantiate_sml(); 3199 #endif 3200 3201 /* 3202 * On non-powermacs, put all CPUs in spin-loops. 3203 * 3204 * PowerMacs use a different mechanism to spin CPUs 3205 * 3206 * (This must be done after instanciating RTAS) 3207 */ 3208 if (of_platform != PLATFORM_POWERMAC && 3209 of_platform != PLATFORM_OPAL) 3210 prom_hold_cpus(); 3211 3212 /* 3213 * Fill in some infos for use by the kernel later on 3214 */ 3215 if (prom_memory_limit) { 3216 __be64 val = cpu_to_be64(prom_memory_limit); 3217 prom_setprop(prom.chosen, "/chosen", "linux,memory-limit", 3218 &val, sizeof(val)); 3219 } 3220 #ifdef CONFIG_PPC64 3221 if (prom_iommu_off) 3222 prom_setprop(prom.chosen, "/chosen", "linux,iommu-off", 3223 NULL, 0); 3224 3225 if (prom_iommu_force_on) 3226 prom_setprop(prom.chosen, "/chosen", "linux,iommu-force-on", 3227 NULL, 0); 3228 3229 if (prom_tce_alloc_start) { 3230 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-start", 3231 &prom_tce_alloc_start, 3232 sizeof(prom_tce_alloc_start)); 3233 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-end", 3234 &prom_tce_alloc_end, 3235 sizeof(prom_tce_alloc_end)); 3236 } 3237 #endif 3238 3239 /* 3240 * Fixup any known bugs in the device-tree 3241 */ 3242 fixup_device_tree(); 3243 3244 /* 3245 * Now finally create the flattened device-tree 3246 */ 3247 prom_printf("copying OF device tree...\n"); 3248 flatten_device_tree(); 3249 3250 /* 3251 * in case stdin is USB and still active on IBM machines... 3252 * Unfortunately quiesce crashes on some powermacs if we have 3253 * closed stdin already (in particular the powerbook 101). It 3254 * appears that the OPAL version of OFW doesn't like it either. 3255 */ 3256 if (of_platform != PLATFORM_POWERMAC && 3257 of_platform != PLATFORM_OPAL) 3258 prom_close_stdin(); 3259 3260 /* 3261 * Call OF "quiesce" method to shut down pending DMA's from 3262 * devices etc... 3263 */ 3264 prom_printf("Quiescing Open Firmware ...\n"); 3265 call_prom("quiesce", 0, 0); 3266 3267 /* 3268 * And finally, call the kernel passing it the flattened device 3269 * tree and NULL as r5, thus triggering the new entry point which 3270 * is common to us and kexec 3271 */ 3272 hdr = dt_header_start; 3273 3274 /* Don't print anything after quiesce under OPAL, it crashes OFW */ 3275 if (of_platform != PLATFORM_OPAL) { 3276 prom_printf("Booting Linux via __start() @ 0x%lx ...\n", kbase); 3277 prom_debug("->dt_header_start=0x%x\n", hdr); 3278 } 3279 3280 #ifdef CONFIG_PPC32 3281 reloc_got2(-offset); 3282 #else 3283 unreloc_toc(); 3284 #endif 3285 3286 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL 3287 /* OPAL early debug gets the OPAL base & entry in r8 and r9 */ 3288 __start(hdr, kbase, 0, 0, 0, 3289 prom_opal_base, prom_opal_entry); 3290 #else 3291 __start(hdr, kbase, 0, 0, 0, 0, 0); 3292 #endif 3293 3294 return 0; 3295 } 3296