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