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