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 os_term_args.nargs = cpu_to_be32(1); 1777 os_term_args.nret = cpu_to_be32(1); 1778 os_term_args.args[0] = cpu_to_be32(__pa(str)); 1779 prom_rtas_hcall((uint64_t)&os_term_args); 1780 } 1781 #endif /* CONFIG_PPC_SVM */ 1782 1783 /* 1784 * Allocate room for and instantiate RTAS 1785 */ 1786 static void __init prom_instantiate_rtas(void) 1787 { 1788 phandle rtas_node; 1789 ihandle rtas_inst; 1790 u32 base, entry = 0; 1791 __be32 val; 1792 u32 size = 0; 1793 1794 prom_debug("prom_instantiate_rtas: start...\n"); 1795 1796 rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas")); 1797 prom_debug("rtas_node: %x\n", rtas_node); 1798 if (!PHANDLE_VALID(rtas_node)) 1799 return; 1800 1801 val = 0; 1802 prom_getprop(rtas_node, "rtas-size", &val, sizeof(size)); 1803 size = be32_to_cpu(val); 1804 if (size == 0) 1805 return; 1806 1807 base = alloc_down(size, PAGE_SIZE, 0); 1808 if (base == 0) 1809 prom_panic("Could not allocate memory for RTAS\n"); 1810 1811 rtas_inst = call_prom("open", 1, 1, ADDR("/rtas")); 1812 if (!IHANDLE_VALID(rtas_inst)) { 1813 prom_printf("opening rtas package failed (%x)\n", rtas_inst); 1814 return; 1815 } 1816 1817 prom_printf("instantiating rtas at 0x%x...", base); 1818 1819 if (call_prom_ret("call-method", 3, 2, &entry, 1820 ADDR("instantiate-rtas"), 1821 rtas_inst, base) != 0 1822 || entry == 0) { 1823 prom_printf(" failed\n"); 1824 return; 1825 } 1826 prom_printf(" done\n"); 1827 1828 reserve_mem(base, size); 1829 1830 val = cpu_to_be32(base); 1831 prom_setprop(rtas_node, "/rtas", "linux,rtas-base", 1832 &val, sizeof(val)); 1833 val = cpu_to_be32(entry); 1834 prom_setprop(rtas_node, "/rtas", "linux,rtas-entry", 1835 &val, sizeof(val)); 1836 1837 /* Check if it supports "query-cpu-stopped-state" */ 1838 if (prom_getprop(rtas_node, "query-cpu-stopped-state", 1839 &val, sizeof(val)) != PROM_ERROR) 1840 rtas_has_query_cpu_stopped = true; 1841 1842 prom_debug("rtas base = 0x%x\n", base); 1843 prom_debug("rtas entry = 0x%x\n", entry); 1844 prom_debug("rtas size = 0x%x\n", size); 1845 1846 prom_debug("prom_instantiate_rtas: end...\n"); 1847 } 1848 1849 #ifdef CONFIG_PPC64 1850 /* 1851 * Allocate room for and instantiate Stored Measurement Log (SML) 1852 */ 1853 static void __init prom_instantiate_sml(void) 1854 { 1855 phandle ibmvtpm_node; 1856 ihandle ibmvtpm_inst; 1857 u32 entry = 0, size = 0, succ = 0; 1858 u64 base; 1859 __be32 val; 1860 1861 prom_debug("prom_instantiate_sml: start...\n"); 1862 1863 ibmvtpm_node = call_prom("finddevice", 1, 1, ADDR("/vdevice/vtpm")); 1864 prom_debug("ibmvtpm_node: %x\n", ibmvtpm_node); 1865 if (!PHANDLE_VALID(ibmvtpm_node)) 1866 return; 1867 1868 ibmvtpm_inst = call_prom("open", 1, 1, ADDR("/vdevice/vtpm")); 1869 if (!IHANDLE_VALID(ibmvtpm_inst)) { 1870 prom_printf("opening vtpm package failed (%x)\n", ibmvtpm_inst); 1871 return; 1872 } 1873 1874 if (prom_getprop(ibmvtpm_node, "ibm,sml-efi-reformat-supported", 1875 &val, sizeof(val)) != PROM_ERROR) { 1876 if (call_prom_ret("call-method", 2, 2, &succ, 1877 ADDR("reformat-sml-to-efi-alignment"), 1878 ibmvtpm_inst) != 0 || succ == 0) { 1879 prom_printf("Reformat SML to EFI alignment failed\n"); 1880 return; 1881 } 1882 1883 if (call_prom_ret("call-method", 2, 2, &size, 1884 ADDR("sml-get-allocated-size"), 1885 ibmvtpm_inst) != 0 || size == 0) { 1886 prom_printf("SML get allocated size failed\n"); 1887 return; 1888 } 1889 } else { 1890 if (call_prom_ret("call-method", 2, 2, &size, 1891 ADDR("sml-get-handover-size"), 1892 ibmvtpm_inst) != 0 || size == 0) { 1893 prom_printf("SML get handover size failed\n"); 1894 return; 1895 } 1896 } 1897 1898 base = alloc_down(size, PAGE_SIZE, 0); 1899 if (base == 0) 1900 prom_panic("Could not allocate memory for sml\n"); 1901 1902 prom_printf("instantiating sml at 0x%llx...", base); 1903 1904 memset((void *)base, 0, size); 1905 1906 if (call_prom_ret("call-method", 4, 2, &entry, 1907 ADDR("sml-handover"), 1908 ibmvtpm_inst, size, base) != 0 || entry == 0) { 1909 prom_printf("SML handover failed\n"); 1910 return; 1911 } 1912 prom_printf(" done\n"); 1913 1914 reserve_mem(base, size); 1915 1916 prom_setprop(ibmvtpm_node, "/vdevice/vtpm", "linux,sml-base", 1917 &base, sizeof(base)); 1918 prom_setprop(ibmvtpm_node, "/vdevice/vtpm", "linux,sml-size", 1919 &size, sizeof(size)); 1920 1921 prom_debug("sml base = 0x%llx\n", base); 1922 prom_debug("sml size = 0x%x\n", size); 1923 1924 prom_debug("prom_instantiate_sml: end...\n"); 1925 } 1926 1927 /* 1928 * Allocate room for and initialize TCE tables 1929 */ 1930 #ifdef __BIG_ENDIAN__ 1931 static void __init prom_initialize_tce_table(void) 1932 { 1933 phandle node; 1934 ihandle phb_node; 1935 char compatible[64], type[64], model[64]; 1936 char *path = prom_scratch; 1937 u64 base, align; 1938 u32 minalign, minsize; 1939 u64 tce_entry, *tce_entryp; 1940 u64 local_alloc_top, local_alloc_bottom; 1941 u64 i; 1942 1943 if (prom_iommu_off) 1944 return; 1945 1946 prom_debug("starting prom_initialize_tce_table\n"); 1947 1948 /* Cache current top of allocs so we reserve a single block */ 1949 local_alloc_top = alloc_top_high; 1950 local_alloc_bottom = local_alloc_top; 1951 1952 /* Search all nodes looking for PHBs. */ 1953 for (node = 0; prom_next_node(&node); ) { 1954 compatible[0] = 0; 1955 type[0] = 0; 1956 model[0] = 0; 1957 prom_getprop(node, "compatible", 1958 compatible, sizeof(compatible)); 1959 prom_getprop(node, "device_type", type, sizeof(type)); 1960 prom_getprop(node, "model", model, sizeof(model)); 1961 1962 if ((type[0] == 0) || (prom_strstr(type, "pci") == NULL)) 1963 continue; 1964 1965 /* Keep the old logic intact to avoid regression. */ 1966 if (compatible[0] != 0) { 1967 if ((prom_strstr(compatible, "python") == NULL) && 1968 (prom_strstr(compatible, "Speedwagon") == NULL) && 1969 (prom_strstr(compatible, "Winnipeg") == NULL)) 1970 continue; 1971 } else if (model[0] != 0) { 1972 if ((prom_strstr(model, "ython") == NULL) && 1973 (prom_strstr(model, "peedwagon") == NULL) && 1974 (prom_strstr(model, "innipeg") == NULL)) 1975 continue; 1976 } 1977 1978 if (prom_getprop(node, "tce-table-minalign", &minalign, 1979 sizeof(minalign)) == PROM_ERROR) 1980 minalign = 0; 1981 if (prom_getprop(node, "tce-table-minsize", &minsize, 1982 sizeof(minsize)) == PROM_ERROR) 1983 minsize = 4UL << 20; 1984 1985 /* 1986 * Even though we read what OF wants, we just set the table 1987 * size to 4 MB. This is enough to map 2GB of PCI DMA space. 1988 * By doing this, we avoid the pitfalls of trying to DMA to 1989 * MMIO space and the DMA alias hole. 1990 */ 1991 minsize = 4UL << 20; 1992 1993 /* Align to the greater of the align or size */ 1994 align = max(minalign, minsize); 1995 base = alloc_down(minsize, align, 1); 1996 if (base == 0) 1997 prom_panic("ERROR, cannot find space for TCE table.\n"); 1998 if (base < local_alloc_bottom) 1999 local_alloc_bottom = base; 2000 2001 /* It seems OF doesn't null-terminate the path :-( */ 2002 memset(path, 0, sizeof(prom_scratch)); 2003 /* Call OF to setup the TCE hardware */ 2004 if (call_prom("package-to-path", 3, 1, node, 2005 path, sizeof(prom_scratch) - 1) == PROM_ERROR) { 2006 prom_printf("package-to-path failed\n"); 2007 } 2008 2009 /* Save away the TCE table attributes for later use. */ 2010 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base)); 2011 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize)); 2012 2013 prom_debug("TCE table: %s\n", path); 2014 prom_debug("\tnode = 0x%x\n", node); 2015 prom_debug("\tbase = 0x%llx\n", base); 2016 prom_debug("\tsize = 0x%x\n", minsize); 2017 2018 /* Initialize the table to have a one-to-one mapping 2019 * over the allocated size. 2020 */ 2021 tce_entryp = (u64 *)base; 2022 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) { 2023 tce_entry = (i << PAGE_SHIFT); 2024 tce_entry |= 0x3; 2025 *tce_entryp = tce_entry; 2026 } 2027 2028 prom_printf("opening PHB %s", path); 2029 phb_node = call_prom("open", 1, 1, path); 2030 if (phb_node == 0) 2031 prom_printf("... failed\n"); 2032 else 2033 prom_printf("... done\n"); 2034 2035 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"), 2036 phb_node, -1, minsize, 2037 (u32) base, (u32) (base >> 32)); 2038 call_prom("close", 1, 0, phb_node); 2039 } 2040 2041 reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom); 2042 2043 /* These are only really needed if there is a memory limit in 2044 * effect, but we don't know so export them always. */ 2045 prom_tce_alloc_start = local_alloc_bottom; 2046 prom_tce_alloc_end = local_alloc_top; 2047 2048 /* Flag the first invalid entry */ 2049 prom_debug("ending prom_initialize_tce_table\n"); 2050 } 2051 #endif /* __BIG_ENDIAN__ */ 2052 #endif /* CONFIG_PPC64 */ 2053 2054 /* 2055 * With CHRP SMP we need to use the OF to start the other processors. 2056 * We can't wait until smp_boot_cpus (the OF is trashed by then) 2057 * so we have to put the processors into a holding pattern controlled 2058 * by the kernel (not OF) before we destroy the OF. 2059 * 2060 * This uses a chunk of low memory, puts some holding pattern 2061 * code there and sends the other processors off to there until 2062 * smp_boot_cpus tells them to do something. The holding pattern 2063 * checks that address until its cpu # is there, when it is that 2064 * cpu jumps to __secondary_start(). smp_boot_cpus() takes care 2065 * of setting those values. 2066 * 2067 * We also use physical address 0x4 here to tell when a cpu 2068 * is in its holding pattern code. 2069 * 2070 * -- Cort 2071 */ 2072 /* 2073 * We want to reference the copy of __secondary_hold_* in the 2074 * 0 - 0x100 address range 2075 */ 2076 #define LOW_ADDR(x) (((unsigned long) &(x)) & 0xff) 2077 2078 static void __init prom_hold_cpus(void) 2079 { 2080 unsigned long i; 2081 phandle node; 2082 char type[64]; 2083 unsigned long *spinloop 2084 = (void *) LOW_ADDR(__secondary_hold_spinloop); 2085 unsigned long *acknowledge 2086 = (void *) LOW_ADDR(__secondary_hold_acknowledge); 2087 unsigned long secondary_hold = LOW_ADDR(__secondary_hold); 2088 2089 /* 2090 * On pseries, if RTAS supports "query-cpu-stopped-state", 2091 * we skip this stage, the CPUs will be started by the 2092 * kernel using RTAS. 2093 */ 2094 if ((of_platform == PLATFORM_PSERIES || 2095 of_platform == PLATFORM_PSERIES_LPAR) && 2096 rtas_has_query_cpu_stopped) { 2097 prom_printf("prom_hold_cpus: skipped\n"); 2098 return; 2099 } 2100 2101 prom_debug("prom_hold_cpus: start...\n"); 2102 prom_debug(" 1) spinloop = 0x%lx\n", (unsigned long)spinloop); 2103 prom_debug(" 1) *spinloop = 0x%lx\n", *spinloop); 2104 prom_debug(" 1) acknowledge = 0x%lx\n", 2105 (unsigned long)acknowledge); 2106 prom_debug(" 1) *acknowledge = 0x%lx\n", *acknowledge); 2107 prom_debug(" 1) secondary_hold = 0x%lx\n", secondary_hold); 2108 2109 /* Set the common spinloop variable, so all of the secondary cpus 2110 * will block when they are awakened from their OF spinloop. 2111 * This must occur for both SMP and non SMP kernels, since OF will 2112 * be trashed when we move the kernel. 2113 */ 2114 *spinloop = 0; 2115 2116 /* look for cpus */ 2117 for (node = 0; prom_next_node(&node); ) { 2118 unsigned int cpu_no; 2119 __be32 reg; 2120 2121 type[0] = 0; 2122 prom_getprop(node, "device_type", type, sizeof(type)); 2123 if (prom_strcmp(type, "cpu") != 0) 2124 continue; 2125 2126 /* Skip non-configured cpus. */ 2127 if (prom_getprop(node, "status", type, sizeof(type)) > 0) 2128 if (prom_strcmp(type, "okay") != 0) 2129 continue; 2130 2131 reg = cpu_to_be32(-1); /* make sparse happy */ 2132 prom_getprop(node, "reg", ®, sizeof(reg)); 2133 cpu_no = be32_to_cpu(reg); 2134 2135 prom_debug("cpu hw idx = %u\n", cpu_no); 2136 2137 /* Init the acknowledge var which will be reset by 2138 * the secondary cpu when it awakens from its OF 2139 * spinloop. 2140 */ 2141 *acknowledge = (unsigned long)-1; 2142 2143 if (cpu_no != prom.cpu) { 2144 /* Primary Thread of non-boot cpu or any thread */ 2145 prom_printf("starting cpu hw idx %u... ", cpu_no); 2146 call_prom("start-cpu", 3, 0, node, 2147 secondary_hold, cpu_no); 2148 2149 for (i = 0; (i < 100000000) && 2150 (*acknowledge == ((unsigned long)-1)); i++ ) 2151 mb(); 2152 2153 if (*acknowledge == cpu_no) 2154 prom_printf("done\n"); 2155 else 2156 prom_printf("failed: %lx\n", *acknowledge); 2157 } 2158 #ifdef CONFIG_SMP 2159 else 2160 prom_printf("boot cpu hw idx %u\n", cpu_no); 2161 #endif /* CONFIG_SMP */ 2162 } 2163 2164 prom_debug("prom_hold_cpus: end...\n"); 2165 } 2166 2167 2168 static void __init prom_init_client_services(unsigned long pp) 2169 { 2170 /* Get a handle to the prom entry point before anything else */ 2171 prom_entry = pp; 2172 2173 /* get a handle for the stdout device */ 2174 prom.chosen = call_prom("finddevice", 1, 1, ADDR("/chosen")); 2175 if (!PHANDLE_VALID(prom.chosen)) 2176 prom_panic("cannot find chosen"); /* msg won't be printed :( */ 2177 2178 /* get device tree root */ 2179 prom.root = call_prom("finddevice", 1, 1, ADDR("/")); 2180 if (!PHANDLE_VALID(prom.root)) 2181 prom_panic("cannot find device tree root"); /* msg won't be printed :( */ 2182 2183 prom.mmumap = 0; 2184 } 2185 2186 #ifdef CONFIG_PPC32 2187 /* 2188 * For really old powermacs, we need to map things we claim. 2189 * For that, we need the ihandle of the mmu. 2190 * Also, on the longtrail, we need to work around other bugs. 2191 */ 2192 static void __init prom_find_mmu(void) 2193 { 2194 phandle oprom; 2195 char version[64]; 2196 2197 oprom = call_prom("finddevice", 1, 1, ADDR("/openprom")); 2198 if (!PHANDLE_VALID(oprom)) 2199 return; 2200 if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0) 2201 return; 2202 version[sizeof(version) - 1] = 0; 2203 /* XXX might need to add other versions here */ 2204 if (prom_strcmp(version, "Open Firmware, 1.0.5") == 0) 2205 of_workarounds = OF_WA_CLAIM; 2206 else if (prom_strncmp(version, "FirmWorks,3.", 12) == 0) { 2207 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL; 2208 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim"); 2209 } else 2210 return; 2211 prom.memory = call_prom("open", 1, 1, ADDR("/memory")); 2212 prom_getprop(prom.chosen, "mmu", &prom.mmumap, 2213 sizeof(prom.mmumap)); 2214 prom.mmumap = be32_to_cpu(prom.mmumap); 2215 if (!IHANDLE_VALID(prom.memory) || !IHANDLE_VALID(prom.mmumap)) 2216 of_workarounds &= ~OF_WA_CLAIM; /* hmmm */ 2217 } 2218 #else 2219 #define prom_find_mmu() 2220 #endif 2221 2222 static void __init prom_init_stdout(void) 2223 { 2224 char *path = of_stdout_device; 2225 char type[16]; 2226 phandle stdout_node; 2227 __be32 val; 2228 2229 if (prom_getprop(prom.chosen, "stdout", &val, sizeof(val)) <= 0) 2230 prom_panic("cannot find stdout"); 2231 2232 prom.stdout = be32_to_cpu(val); 2233 2234 /* Get the full OF pathname of the stdout device */ 2235 memset(path, 0, 256); 2236 call_prom("instance-to-path", 3, 1, prom.stdout, path, 255); 2237 prom_printf("OF stdout device is: %s\n", of_stdout_device); 2238 prom_setprop(prom.chosen, "/chosen", "linux,stdout-path", 2239 path, prom_strlen(path) + 1); 2240 2241 /* instance-to-package fails on PA-Semi */ 2242 stdout_node = call_prom("instance-to-package", 1, 1, prom.stdout); 2243 if (stdout_node != PROM_ERROR) { 2244 val = cpu_to_be32(stdout_node); 2245 2246 /* If it's a display, note it */ 2247 memset(type, 0, sizeof(type)); 2248 prom_getprop(stdout_node, "device_type", type, sizeof(type)); 2249 if (prom_strcmp(type, "display") == 0) 2250 prom_setprop(stdout_node, path, "linux,boot-display", NULL, 0); 2251 } 2252 } 2253 2254 static int __init prom_find_machine_type(void) 2255 { 2256 char compat[256]; 2257 int len, i = 0; 2258 #ifdef CONFIG_PPC64 2259 phandle rtas; 2260 int x; 2261 #endif 2262 2263 /* Look for a PowerMac or a Cell */ 2264 len = prom_getprop(prom.root, "compatible", 2265 compat, sizeof(compat)-1); 2266 if (len > 0) { 2267 compat[len] = 0; 2268 while (i < len) { 2269 char *p = &compat[i]; 2270 int sl = prom_strlen(p); 2271 if (sl == 0) 2272 break; 2273 if (prom_strstr(p, "Power Macintosh") || 2274 prom_strstr(p, "MacRISC")) 2275 return PLATFORM_POWERMAC; 2276 #ifdef CONFIG_PPC64 2277 /* We must make sure we don't detect the IBM Cell 2278 * blades as pSeries due to some firmware issues, 2279 * so we do it here. 2280 */ 2281 if (prom_strstr(p, "IBM,CBEA") || 2282 prom_strstr(p, "IBM,CPBW-1.0")) 2283 return PLATFORM_GENERIC; 2284 #endif /* CONFIG_PPC64 */ 2285 i += sl + 1; 2286 } 2287 } 2288 #ifdef CONFIG_PPC64 2289 /* Try to figure out if it's an IBM pSeries or any other 2290 * PAPR compliant platform. We assume it is if : 2291 * - /device_type is "chrp" (please, do NOT use that for future 2292 * non-IBM designs ! 2293 * - it has /rtas 2294 */ 2295 len = prom_getprop(prom.root, "device_type", 2296 compat, sizeof(compat)-1); 2297 if (len <= 0) 2298 return PLATFORM_GENERIC; 2299 if (prom_strcmp(compat, "chrp")) 2300 return PLATFORM_GENERIC; 2301 2302 /* Default to pSeries. We need to know if we are running LPAR */ 2303 rtas = call_prom("finddevice", 1, 1, ADDR("/rtas")); 2304 if (!PHANDLE_VALID(rtas)) 2305 return PLATFORM_GENERIC; 2306 x = prom_getproplen(rtas, "ibm,hypertas-functions"); 2307 if (x != PROM_ERROR) { 2308 prom_debug("Hypertas detected, assuming LPAR !\n"); 2309 return PLATFORM_PSERIES_LPAR; 2310 } 2311 return PLATFORM_PSERIES; 2312 #else 2313 return PLATFORM_GENERIC; 2314 #endif 2315 } 2316 2317 static int __init prom_set_color(ihandle ih, int i, int r, int g, int b) 2318 { 2319 return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r); 2320 } 2321 2322 /* 2323 * If we have a display that we don't know how to drive, 2324 * we will want to try to execute OF's open method for it 2325 * later. However, OF will probably fall over if we do that 2326 * we've taken over the MMU. 2327 * So we check whether we will need to open the display, 2328 * and if so, open it now. 2329 */ 2330 static void __init prom_check_displays(void) 2331 { 2332 char type[16], *path; 2333 phandle node; 2334 ihandle ih; 2335 int i; 2336 2337 static const unsigned char default_colors[] __initconst = { 2338 0x00, 0x00, 0x00, 2339 0x00, 0x00, 0xaa, 2340 0x00, 0xaa, 0x00, 2341 0x00, 0xaa, 0xaa, 2342 0xaa, 0x00, 0x00, 2343 0xaa, 0x00, 0xaa, 2344 0xaa, 0xaa, 0x00, 2345 0xaa, 0xaa, 0xaa, 2346 0x55, 0x55, 0x55, 2347 0x55, 0x55, 0xff, 2348 0x55, 0xff, 0x55, 2349 0x55, 0xff, 0xff, 2350 0xff, 0x55, 0x55, 2351 0xff, 0x55, 0xff, 2352 0xff, 0xff, 0x55, 2353 0xff, 0xff, 0xff 2354 }; 2355 const unsigned char *clut; 2356 2357 prom_debug("Looking for displays\n"); 2358 for (node = 0; prom_next_node(&node); ) { 2359 memset(type, 0, sizeof(type)); 2360 prom_getprop(node, "device_type", type, sizeof(type)); 2361 if (prom_strcmp(type, "display") != 0) 2362 continue; 2363 2364 /* It seems OF doesn't null-terminate the path :-( */ 2365 path = prom_scratch; 2366 memset(path, 0, sizeof(prom_scratch)); 2367 2368 /* 2369 * leave some room at the end of the path for appending extra 2370 * arguments 2371 */ 2372 if (call_prom("package-to-path", 3, 1, node, path, 2373 sizeof(prom_scratch) - 10) == PROM_ERROR) 2374 continue; 2375 prom_printf("found display : %s, opening... ", path); 2376 2377 ih = call_prom("open", 1, 1, path); 2378 if (ih == 0) { 2379 prom_printf("failed\n"); 2380 continue; 2381 } 2382 2383 /* Success */ 2384 prom_printf("done\n"); 2385 prom_setprop(node, path, "linux,opened", NULL, 0); 2386 2387 /* Setup a usable color table when the appropriate 2388 * method is available. Should update this to set-colors */ 2389 clut = default_colors; 2390 for (i = 0; i < 16; i++, clut += 3) 2391 if (prom_set_color(ih, i, clut[0], clut[1], 2392 clut[2]) != 0) 2393 break; 2394 2395 #ifdef CONFIG_LOGO_LINUX_CLUT224 2396 clut = PTRRELOC(logo_linux_clut224.clut); 2397 for (i = 0; i < logo_linux_clut224.clutsize; i++, clut += 3) 2398 if (prom_set_color(ih, i + 32, clut[0], clut[1], 2399 clut[2]) != 0) 2400 break; 2401 #endif /* CONFIG_LOGO_LINUX_CLUT224 */ 2402 2403 #ifdef CONFIG_PPC_EARLY_DEBUG_BOOTX 2404 if (prom_getprop(node, "linux,boot-display", NULL, 0) != 2405 PROM_ERROR) { 2406 u32 width, height, pitch, addr; 2407 2408 prom_printf("Setting btext !\n"); 2409 prom_getprop(node, "width", &width, 4); 2410 prom_getprop(node, "height", &height, 4); 2411 prom_getprop(node, "linebytes", &pitch, 4); 2412 prom_getprop(node, "address", &addr, 4); 2413 prom_printf("W=%d H=%d LB=%d addr=0x%x\n", 2414 width, height, pitch, addr); 2415 btext_setup_display(width, height, 8, pitch, addr); 2416 btext_prepare_BAT(); 2417 } 2418 #endif /* CONFIG_PPC_EARLY_DEBUG_BOOTX */ 2419 } 2420 } 2421 2422 2423 /* Return (relocated) pointer to this much memory: moves initrd if reqd. */ 2424 static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end, 2425 unsigned long needed, unsigned long align) 2426 { 2427 void *ret; 2428 2429 *mem_start = _ALIGN(*mem_start, align); 2430 while ((*mem_start + needed) > *mem_end) { 2431 unsigned long room, chunk; 2432 2433 prom_debug("Chunk exhausted, claiming more at %lx...\n", 2434 alloc_bottom); 2435 room = alloc_top - alloc_bottom; 2436 if (room > DEVTREE_CHUNK_SIZE) 2437 room = DEVTREE_CHUNK_SIZE; 2438 if (room < PAGE_SIZE) 2439 prom_panic("No memory for flatten_device_tree " 2440 "(no room)\n"); 2441 chunk = alloc_up(room, 0); 2442 if (chunk == 0) 2443 prom_panic("No memory for flatten_device_tree " 2444 "(claim failed)\n"); 2445 *mem_end = chunk + room; 2446 } 2447 2448 ret = (void *)*mem_start; 2449 *mem_start += needed; 2450 2451 return ret; 2452 } 2453 2454 #define dt_push_token(token, mem_start, mem_end) do { \ 2455 void *room = make_room(mem_start, mem_end, 4, 4); \ 2456 *(__be32 *)room = cpu_to_be32(token); \ 2457 } while(0) 2458 2459 static unsigned long __init dt_find_string(char *str) 2460 { 2461 char *s, *os; 2462 2463 s = os = (char *)dt_string_start; 2464 s += 4; 2465 while (s < (char *)dt_string_end) { 2466 if (prom_strcmp(s, str) == 0) 2467 return s - os; 2468 s += prom_strlen(s) + 1; 2469 } 2470 return 0; 2471 } 2472 2473 /* 2474 * The Open Firmware 1275 specification states properties must be 31 bytes or 2475 * less, however not all firmwares obey this. Make it 64 bytes to be safe. 2476 */ 2477 #define MAX_PROPERTY_NAME 64 2478 2479 static void __init scan_dt_build_strings(phandle node, 2480 unsigned long *mem_start, 2481 unsigned long *mem_end) 2482 { 2483 char *prev_name, *namep, *sstart; 2484 unsigned long soff; 2485 phandle child; 2486 2487 sstart = (char *)dt_string_start; 2488 2489 /* get and store all property names */ 2490 prev_name = ""; 2491 for (;;) { 2492 /* 64 is max len of name including nul. */ 2493 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1); 2494 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) { 2495 /* No more nodes: unwind alloc */ 2496 *mem_start = (unsigned long)namep; 2497 break; 2498 } 2499 2500 /* skip "name" */ 2501 if (prom_strcmp(namep, "name") == 0) { 2502 *mem_start = (unsigned long)namep; 2503 prev_name = "name"; 2504 continue; 2505 } 2506 /* get/create string entry */ 2507 soff = dt_find_string(namep); 2508 if (soff != 0) { 2509 *mem_start = (unsigned long)namep; 2510 namep = sstart + soff; 2511 } else { 2512 /* Trim off some if we can */ 2513 *mem_start = (unsigned long)namep + prom_strlen(namep) + 1; 2514 dt_string_end = *mem_start; 2515 } 2516 prev_name = namep; 2517 } 2518 2519 /* do all our children */ 2520 child = call_prom("child", 1, 1, node); 2521 while (child != 0) { 2522 scan_dt_build_strings(child, mem_start, mem_end); 2523 child = call_prom("peer", 1, 1, child); 2524 } 2525 } 2526 2527 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start, 2528 unsigned long *mem_end) 2529 { 2530 phandle child; 2531 char *namep, *prev_name, *sstart, *p, *ep, *lp, *path; 2532 unsigned long soff; 2533 unsigned char *valp; 2534 static char pname[MAX_PROPERTY_NAME] __prombss; 2535 int l, room, has_phandle = 0; 2536 2537 dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end); 2538 2539 /* get the node's full name */ 2540 namep = (char *)*mem_start; 2541 room = *mem_end - *mem_start; 2542 if (room > 255) 2543 room = 255; 2544 l = call_prom("package-to-path", 3, 1, node, namep, room); 2545 if (l >= 0) { 2546 /* Didn't fit? Get more room. */ 2547 if (l >= room) { 2548 if (l >= *mem_end - *mem_start) 2549 namep = make_room(mem_start, mem_end, l+1, 1); 2550 call_prom("package-to-path", 3, 1, node, namep, l); 2551 } 2552 namep[l] = '\0'; 2553 2554 /* Fixup an Apple bug where they have bogus \0 chars in the 2555 * middle of the path in some properties, and extract 2556 * the unit name (everything after the last '/'). 2557 */ 2558 for (lp = p = namep, ep = namep + l; p < ep; p++) { 2559 if (*p == '/') 2560 lp = namep; 2561 else if (*p != 0) 2562 *lp++ = *p; 2563 } 2564 *lp = 0; 2565 *mem_start = _ALIGN((unsigned long)lp + 1, 4); 2566 } 2567 2568 /* get it again for debugging */ 2569 path = prom_scratch; 2570 memset(path, 0, sizeof(prom_scratch)); 2571 call_prom("package-to-path", 3, 1, node, path, sizeof(prom_scratch) - 1); 2572 2573 /* get and store all properties */ 2574 prev_name = ""; 2575 sstart = (char *)dt_string_start; 2576 for (;;) { 2577 if (call_prom("nextprop", 3, 1, node, prev_name, 2578 pname) != 1) 2579 break; 2580 2581 /* skip "name" */ 2582 if (prom_strcmp(pname, "name") == 0) { 2583 prev_name = "name"; 2584 continue; 2585 } 2586 2587 /* find string offset */ 2588 soff = dt_find_string(pname); 2589 if (soff == 0) { 2590 prom_printf("WARNING: Can't find string index for" 2591 " <%s>, node %s\n", pname, path); 2592 break; 2593 } 2594 prev_name = sstart + soff; 2595 2596 /* get length */ 2597 l = call_prom("getproplen", 2, 1, node, pname); 2598 2599 /* sanity checks */ 2600 if (l == PROM_ERROR) 2601 continue; 2602 2603 /* push property head */ 2604 dt_push_token(OF_DT_PROP, mem_start, mem_end); 2605 dt_push_token(l, mem_start, mem_end); 2606 dt_push_token(soff, mem_start, mem_end); 2607 2608 /* push property content */ 2609 valp = make_room(mem_start, mem_end, l, 4); 2610 call_prom("getprop", 4, 1, node, pname, valp, l); 2611 *mem_start = _ALIGN(*mem_start, 4); 2612 2613 if (!prom_strcmp(pname, "phandle")) 2614 has_phandle = 1; 2615 } 2616 2617 /* Add a "phandle" property if none already exist */ 2618 if (!has_phandle) { 2619 soff = dt_find_string("phandle"); 2620 if (soff == 0) 2621 prom_printf("WARNING: Can't find string index for <phandle> node %s\n", path); 2622 else { 2623 dt_push_token(OF_DT_PROP, mem_start, mem_end); 2624 dt_push_token(4, mem_start, mem_end); 2625 dt_push_token(soff, mem_start, mem_end); 2626 valp = make_room(mem_start, mem_end, 4, 4); 2627 *(__be32 *)valp = cpu_to_be32(node); 2628 } 2629 } 2630 2631 /* do all our children */ 2632 child = call_prom("child", 1, 1, node); 2633 while (child != 0) { 2634 scan_dt_build_struct(child, mem_start, mem_end); 2635 child = call_prom("peer", 1, 1, child); 2636 } 2637 2638 dt_push_token(OF_DT_END_NODE, mem_start, mem_end); 2639 } 2640 2641 static void __init flatten_device_tree(void) 2642 { 2643 phandle root; 2644 unsigned long mem_start, mem_end, room; 2645 struct boot_param_header *hdr; 2646 char *namep; 2647 u64 *rsvmap; 2648 2649 /* 2650 * Check how much room we have between alloc top & bottom (+/- a 2651 * few pages), crop to 1MB, as this is our "chunk" size 2652 */ 2653 room = alloc_top - alloc_bottom - 0x4000; 2654 if (room > DEVTREE_CHUNK_SIZE) 2655 room = DEVTREE_CHUNK_SIZE; 2656 prom_debug("starting device tree allocs at %lx\n", alloc_bottom); 2657 2658 /* Now try to claim that */ 2659 mem_start = (unsigned long)alloc_up(room, PAGE_SIZE); 2660 if (mem_start == 0) 2661 prom_panic("Can't allocate initial device-tree chunk\n"); 2662 mem_end = mem_start + room; 2663 2664 /* Get root of tree */ 2665 root = call_prom("peer", 1, 1, (phandle)0); 2666 if (root == (phandle)0) 2667 prom_panic ("couldn't get device tree root\n"); 2668 2669 /* Build header and make room for mem rsv map */ 2670 mem_start = _ALIGN(mem_start, 4); 2671 hdr = make_room(&mem_start, &mem_end, 2672 sizeof(struct boot_param_header), 4); 2673 dt_header_start = (unsigned long)hdr; 2674 rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8); 2675 2676 /* Start of strings */ 2677 mem_start = PAGE_ALIGN(mem_start); 2678 dt_string_start = mem_start; 2679 mem_start += 4; /* hole */ 2680 2681 /* Add "phandle" in there, we'll need it */ 2682 namep = make_room(&mem_start, &mem_end, 16, 1); 2683 prom_strcpy(namep, "phandle"); 2684 mem_start = (unsigned long)namep + prom_strlen(namep) + 1; 2685 2686 /* Build string array */ 2687 prom_printf("Building dt strings...\n"); 2688 scan_dt_build_strings(root, &mem_start, &mem_end); 2689 dt_string_end = mem_start; 2690 2691 /* Build structure */ 2692 mem_start = PAGE_ALIGN(mem_start); 2693 dt_struct_start = mem_start; 2694 prom_printf("Building dt structure...\n"); 2695 scan_dt_build_struct(root, &mem_start, &mem_end); 2696 dt_push_token(OF_DT_END, &mem_start, &mem_end); 2697 dt_struct_end = PAGE_ALIGN(mem_start); 2698 2699 /* Finish header */ 2700 hdr->boot_cpuid_phys = cpu_to_be32(prom.cpu); 2701 hdr->magic = cpu_to_be32(OF_DT_HEADER); 2702 hdr->totalsize = cpu_to_be32(dt_struct_end - dt_header_start); 2703 hdr->off_dt_struct = cpu_to_be32(dt_struct_start - dt_header_start); 2704 hdr->off_dt_strings = cpu_to_be32(dt_string_start - dt_header_start); 2705 hdr->dt_strings_size = cpu_to_be32(dt_string_end - dt_string_start); 2706 hdr->off_mem_rsvmap = cpu_to_be32(((unsigned long)rsvmap) - dt_header_start); 2707 hdr->version = cpu_to_be32(OF_DT_VERSION); 2708 /* Version 16 is not backward compatible */ 2709 hdr->last_comp_version = cpu_to_be32(0x10); 2710 2711 /* Copy the reserve map in */ 2712 memcpy(rsvmap, mem_reserve_map, sizeof(mem_reserve_map)); 2713 2714 #ifdef DEBUG_PROM 2715 { 2716 int i; 2717 prom_printf("reserved memory map:\n"); 2718 for (i = 0; i < mem_reserve_cnt; i++) 2719 prom_printf(" %llx - %llx\n", 2720 be64_to_cpu(mem_reserve_map[i].base), 2721 be64_to_cpu(mem_reserve_map[i].size)); 2722 } 2723 #endif 2724 /* Bump mem_reserve_cnt to cause further reservations to fail 2725 * since it's too late. 2726 */ 2727 mem_reserve_cnt = MEM_RESERVE_MAP_SIZE; 2728 2729 prom_printf("Device tree strings 0x%lx -> 0x%lx\n", 2730 dt_string_start, dt_string_end); 2731 prom_printf("Device tree struct 0x%lx -> 0x%lx\n", 2732 dt_struct_start, dt_struct_end); 2733 } 2734 2735 #ifdef CONFIG_PPC_MAPLE 2736 /* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property. 2737 * The values are bad, and it doesn't even have the right number of cells. */ 2738 static void __init fixup_device_tree_maple(void) 2739 { 2740 phandle isa; 2741 u32 rloc = 0x01002000; /* IO space; PCI device = 4 */ 2742 u32 isa_ranges[6]; 2743 char *name; 2744 2745 name = "/ht@0/isa@4"; 2746 isa = call_prom("finddevice", 1, 1, ADDR(name)); 2747 if (!PHANDLE_VALID(isa)) { 2748 name = "/ht@0/isa@6"; 2749 isa = call_prom("finddevice", 1, 1, ADDR(name)); 2750 rloc = 0x01003000; /* IO space; PCI device = 6 */ 2751 } 2752 if (!PHANDLE_VALID(isa)) 2753 return; 2754 2755 if (prom_getproplen(isa, "ranges") != 12) 2756 return; 2757 if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges)) 2758 == PROM_ERROR) 2759 return; 2760 2761 if (isa_ranges[0] != 0x1 || 2762 isa_ranges[1] != 0xf4000000 || 2763 isa_ranges[2] != 0x00010000) 2764 return; 2765 2766 prom_printf("Fixing up bogus ISA range on Maple/Apache...\n"); 2767 2768 isa_ranges[0] = 0x1; 2769 isa_ranges[1] = 0x0; 2770 isa_ranges[2] = rloc; 2771 isa_ranges[3] = 0x0; 2772 isa_ranges[4] = 0x0; 2773 isa_ranges[5] = 0x00010000; 2774 prom_setprop(isa, name, "ranges", 2775 isa_ranges, sizeof(isa_ranges)); 2776 } 2777 2778 #define CPC925_MC_START 0xf8000000 2779 #define CPC925_MC_LENGTH 0x1000000 2780 /* The values for memory-controller don't have right number of cells */ 2781 static void __init fixup_device_tree_maple_memory_controller(void) 2782 { 2783 phandle mc; 2784 u32 mc_reg[4]; 2785 char *name = "/hostbridge@f8000000"; 2786 u32 ac, sc; 2787 2788 mc = call_prom("finddevice", 1, 1, ADDR(name)); 2789 if (!PHANDLE_VALID(mc)) 2790 return; 2791 2792 if (prom_getproplen(mc, "reg") != 8) 2793 return; 2794 2795 prom_getprop(prom.root, "#address-cells", &ac, sizeof(ac)); 2796 prom_getprop(prom.root, "#size-cells", &sc, sizeof(sc)); 2797 if ((ac != 2) || (sc != 2)) 2798 return; 2799 2800 if (prom_getprop(mc, "reg", mc_reg, sizeof(mc_reg)) == PROM_ERROR) 2801 return; 2802 2803 if (mc_reg[0] != CPC925_MC_START || mc_reg[1] != CPC925_MC_LENGTH) 2804 return; 2805 2806 prom_printf("Fixing up bogus hostbridge on Maple...\n"); 2807 2808 mc_reg[0] = 0x0; 2809 mc_reg[1] = CPC925_MC_START; 2810 mc_reg[2] = 0x0; 2811 mc_reg[3] = CPC925_MC_LENGTH; 2812 prom_setprop(mc, name, "reg", mc_reg, sizeof(mc_reg)); 2813 } 2814 #else 2815 #define fixup_device_tree_maple() 2816 #define fixup_device_tree_maple_memory_controller() 2817 #endif 2818 2819 #ifdef CONFIG_PPC_CHRP 2820 /* 2821 * Pegasos and BriQ lacks the "ranges" property in the isa node 2822 * Pegasos needs decimal IRQ 14/15, not hexadecimal 2823 * Pegasos has the IDE configured in legacy mode, but advertised as native 2824 */ 2825 static void __init fixup_device_tree_chrp(void) 2826 { 2827 phandle ph; 2828 u32 prop[6]; 2829 u32 rloc = 0x01006000; /* IO space; PCI device = 12 */ 2830 char *name; 2831 int rc; 2832 2833 name = "/pci@80000000/isa@c"; 2834 ph = call_prom("finddevice", 1, 1, ADDR(name)); 2835 if (!PHANDLE_VALID(ph)) { 2836 name = "/pci@ff500000/isa@6"; 2837 ph = call_prom("finddevice", 1, 1, ADDR(name)); 2838 rloc = 0x01003000; /* IO space; PCI device = 6 */ 2839 } 2840 if (PHANDLE_VALID(ph)) { 2841 rc = prom_getproplen(ph, "ranges"); 2842 if (rc == 0 || rc == PROM_ERROR) { 2843 prom_printf("Fixing up missing ISA range on Pegasos...\n"); 2844 2845 prop[0] = 0x1; 2846 prop[1] = 0x0; 2847 prop[2] = rloc; 2848 prop[3] = 0x0; 2849 prop[4] = 0x0; 2850 prop[5] = 0x00010000; 2851 prom_setprop(ph, name, "ranges", prop, sizeof(prop)); 2852 } 2853 } 2854 2855 name = "/pci@80000000/ide@C,1"; 2856 ph = call_prom("finddevice", 1, 1, ADDR(name)); 2857 if (PHANDLE_VALID(ph)) { 2858 prom_printf("Fixing up IDE interrupt on Pegasos...\n"); 2859 prop[0] = 14; 2860 prop[1] = 0x0; 2861 prom_setprop(ph, name, "interrupts", prop, 2*sizeof(u32)); 2862 prom_printf("Fixing up IDE class-code on Pegasos...\n"); 2863 rc = prom_getprop(ph, "class-code", prop, sizeof(u32)); 2864 if (rc == sizeof(u32)) { 2865 prop[0] &= ~0x5; 2866 prom_setprop(ph, name, "class-code", prop, sizeof(u32)); 2867 } 2868 } 2869 } 2870 #else 2871 #define fixup_device_tree_chrp() 2872 #endif 2873 2874 #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC) 2875 static void __init fixup_device_tree_pmac(void) 2876 { 2877 phandle u3, i2c, mpic; 2878 u32 u3_rev; 2879 u32 interrupts[2]; 2880 u32 parent; 2881 2882 /* Some G5s have a missing interrupt definition, fix it up here */ 2883 u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000")); 2884 if (!PHANDLE_VALID(u3)) 2885 return; 2886 i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000")); 2887 if (!PHANDLE_VALID(i2c)) 2888 return; 2889 mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000")); 2890 if (!PHANDLE_VALID(mpic)) 2891 return; 2892 2893 /* check if proper rev of u3 */ 2894 if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev)) 2895 == PROM_ERROR) 2896 return; 2897 if (u3_rev < 0x35 || u3_rev > 0x39) 2898 return; 2899 /* does it need fixup ? */ 2900 if (prom_getproplen(i2c, "interrupts") > 0) 2901 return; 2902 2903 prom_printf("fixing up bogus interrupts for u3 i2c...\n"); 2904 2905 /* interrupt on this revision of u3 is number 0 and level */ 2906 interrupts[0] = 0; 2907 interrupts[1] = 1; 2908 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts", 2909 &interrupts, sizeof(interrupts)); 2910 parent = (u32)mpic; 2911 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent", 2912 &parent, sizeof(parent)); 2913 } 2914 #else 2915 #define fixup_device_tree_pmac() 2916 #endif 2917 2918 #ifdef CONFIG_PPC_EFIKA 2919 /* 2920 * The MPC5200 FEC driver requires an phy-handle property to tell it how 2921 * to talk to the phy. If the phy-handle property is missing, then this 2922 * function is called to add the appropriate nodes and link it to the 2923 * ethernet node. 2924 */ 2925 static void __init fixup_device_tree_efika_add_phy(void) 2926 { 2927 u32 node; 2928 char prop[64]; 2929 int rv; 2930 2931 /* Check if /builtin/ethernet exists - bail if it doesn't */ 2932 node = call_prom("finddevice", 1, 1, ADDR("/builtin/ethernet")); 2933 if (!PHANDLE_VALID(node)) 2934 return; 2935 2936 /* Check if the phy-handle property exists - bail if it does */ 2937 rv = prom_getprop(node, "phy-handle", prop, sizeof(prop)); 2938 if (!rv) 2939 return; 2940 2941 /* 2942 * At this point the ethernet device doesn't have a phy described. 2943 * Now we need to add the missing phy node and linkage 2944 */ 2945 2946 /* Check for an MDIO bus node - if missing then create one */ 2947 node = call_prom("finddevice", 1, 1, ADDR("/builtin/mdio")); 2948 if (!PHANDLE_VALID(node)) { 2949 prom_printf("Adding Ethernet MDIO node\n"); 2950 call_prom("interpret", 1, 1, 2951 " s\" /builtin\" find-device" 2952 " new-device" 2953 " 1 encode-int s\" #address-cells\" property" 2954 " 0 encode-int s\" #size-cells\" property" 2955 " s\" mdio\" device-name" 2956 " s\" fsl,mpc5200b-mdio\" encode-string" 2957 " s\" compatible\" property" 2958 " 0xf0003000 0x400 reg" 2959 " 0x2 encode-int" 2960 " 0x5 encode-int encode+" 2961 " 0x3 encode-int encode+" 2962 " s\" interrupts\" property" 2963 " finish-device"); 2964 }; 2965 2966 /* Check for a PHY device node - if missing then create one and 2967 * give it's phandle to the ethernet node */ 2968 node = call_prom("finddevice", 1, 1, 2969 ADDR("/builtin/mdio/ethernet-phy")); 2970 if (!PHANDLE_VALID(node)) { 2971 prom_printf("Adding Ethernet PHY node\n"); 2972 call_prom("interpret", 1, 1, 2973 " s\" /builtin/mdio\" find-device" 2974 " new-device" 2975 " s\" ethernet-phy\" device-name" 2976 " 0x10 encode-int s\" reg\" property" 2977 " my-self" 2978 " ihandle>phandle" 2979 " finish-device" 2980 " s\" /builtin/ethernet\" find-device" 2981 " encode-int" 2982 " s\" phy-handle\" property" 2983 " device-end"); 2984 } 2985 } 2986 2987 static void __init fixup_device_tree_efika(void) 2988 { 2989 int sound_irq[3] = { 2, 2, 0 }; 2990 int bcomm_irq[3*16] = { 3,0,0, 3,1,0, 3,2,0, 3,3,0, 2991 3,4,0, 3,5,0, 3,6,0, 3,7,0, 2992 3,8,0, 3,9,0, 3,10,0, 3,11,0, 2993 3,12,0, 3,13,0, 3,14,0, 3,15,0 }; 2994 u32 node; 2995 char prop[64]; 2996 int rv, len; 2997 2998 /* Check if we're really running on a EFIKA */ 2999 node = call_prom("finddevice", 1, 1, ADDR("/")); 3000 if (!PHANDLE_VALID(node)) 3001 return; 3002 3003 rv = prom_getprop(node, "model", prop, sizeof(prop)); 3004 if (rv == PROM_ERROR) 3005 return; 3006 if (prom_strcmp(prop, "EFIKA5K2")) 3007 return; 3008 3009 prom_printf("Applying EFIKA device tree fixups\n"); 3010 3011 /* Claiming to be 'chrp' is death */ 3012 node = call_prom("finddevice", 1, 1, ADDR("/")); 3013 rv = prom_getprop(node, "device_type", prop, sizeof(prop)); 3014 if (rv != PROM_ERROR && (prom_strcmp(prop, "chrp") == 0)) 3015 prom_setprop(node, "/", "device_type", "efika", sizeof("efika")); 3016 3017 /* CODEGEN,description is exposed in /proc/cpuinfo so 3018 fix that too */ 3019 rv = prom_getprop(node, "CODEGEN,description", prop, sizeof(prop)); 3020 if (rv != PROM_ERROR && (prom_strstr(prop, "CHRP"))) 3021 prom_setprop(node, "/", "CODEGEN,description", 3022 "Efika 5200B PowerPC System", 3023 sizeof("Efika 5200B PowerPC System")); 3024 3025 /* Fixup bestcomm interrupts property */ 3026 node = call_prom("finddevice", 1, 1, ADDR("/builtin/bestcomm")); 3027 if (PHANDLE_VALID(node)) { 3028 len = prom_getproplen(node, "interrupts"); 3029 if (len == 12) { 3030 prom_printf("Fixing bestcomm interrupts property\n"); 3031 prom_setprop(node, "/builtin/bestcom", "interrupts", 3032 bcomm_irq, sizeof(bcomm_irq)); 3033 } 3034 } 3035 3036 /* Fixup sound interrupts property */ 3037 node = call_prom("finddevice", 1, 1, ADDR("/builtin/sound")); 3038 if (PHANDLE_VALID(node)) { 3039 rv = prom_getprop(node, "interrupts", prop, sizeof(prop)); 3040 if (rv == PROM_ERROR) { 3041 prom_printf("Adding sound interrupts property\n"); 3042 prom_setprop(node, "/builtin/sound", "interrupts", 3043 sound_irq, sizeof(sound_irq)); 3044 } 3045 } 3046 3047 /* Make sure ethernet phy-handle property exists */ 3048 fixup_device_tree_efika_add_phy(); 3049 } 3050 #else 3051 #define fixup_device_tree_efika() 3052 #endif 3053 3054 #ifdef CONFIG_PPC_PASEMI_NEMO 3055 /* 3056 * CFE supplied on Nemo is broken in several ways, biggest 3057 * problem is that it reassigns ISA interrupts to unused mpic ints. 3058 * Add an interrupt-controller property for the io-bridge to use 3059 * and correct the ints so we can attach them to an irq_domain 3060 */ 3061 static void __init fixup_device_tree_pasemi(void) 3062 { 3063 u32 interrupts[2], parent, rval, val = 0; 3064 char *name, *pci_name; 3065 phandle iob, node; 3066 3067 /* Find the root pci node */ 3068 name = "/pxp@0,e0000000"; 3069 iob = call_prom("finddevice", 1, 1, ADDR(name)); 3070 if (!PHANDLE_VALID(iob)) 3071 return; 3072 3073 /* check if interrupt-controller node set yet */ 3074 if (prom_getproplen(iob, "interrupt-controller") !=PROM_ERROR) 3075 return; 3076 3077 prom_printf("adding interrupt-controller property for SB600...\n"); 3078 3079 prom_setprop(iob, name, "interrupt-controller", &val, 0); 3080 3081 pci_name = "/pxp@0,e0000000/pci@11"; 3082 node = call_prom("finddevice", 1, 1, ADDR(pci_name)); 3083 parent = ADDR(iob); 3084 3085 for( ; prom_next_node(&node); ) { 3086 /* scan each node for one with an interrupt */ 3087 if (!PHANDLE_VALID(node)) 3088 continue; 3089 3090 rval = prom_getproplen(node, "interrupts"); 3091 if (rval == 0 || rval == PROM_ERROR) 3092 continue; 3093 3094 prom_getprop(node, "interrupts", &interrupts, sizeof(interrupts)); 3095 if ((interrupts[0] < 212) || (interrupts[0] > 222)) 3096 continue; 3097 3098 /* found a node, update both interrupts and interrupt-parent */ 3099 if ((interrupts[0] >= 212) && (interrupts[0] <= 215)) 3100 interrupts[0] -= 203; 3101 if ((interrupts[0] >= 216) && (interrupts[0] <= 220)) 3102 interrupts[0] -= 213; 3103 if (interrupts[0] == 221) 3104 interrupts[0] = 14; 3105 if (interrupts[0] == 222) 3106 interrupts[0] = 8; 3107 3108 prom_setprop(node, pci_name, "interrupts", interrupts, 3109 sizeof(interrupts)); 3110 prom_setprop(node, pci_name, "interrupt-parent", &parent, 3111 sizeof(parent)); 3112 } 3113 3114 /* 3115 * The io-bridge has device_type set to 'io-bridge' change it to 'isa' 3116 * so that generic isa-bridge code can add the SB600 and its on-board 3117 * peripherals. 3118 */ 3119 name = "/pxp@0,e0000000/io-bridge@0"; 3120 iob = call_prom("finddevice", 1, 1, ADDR(name)); 3121 if (!PHANDLE_VALID(iob)) 3122 return; 3123 3124 /* device_type is already set, just change it. */ 3125 3126 prom_printf("Changing device_type of SB600 node...\n"); 3127 3128 prom_setprop(iob, name, "device_type", "isa", sizeof("isa")); 3129 } 3130 #else /* !CONFIG_PPC_PASEMI_NEMO */ 3131 static inline void fixup_device_tree_pasemi(void) { } 3132 #endif 3133 3134 static void __init fixup_device_tree(void) 3135 { 3136 fixup_device_tree_maple(); 3137 fixup_device_tree_maple_memory_controller(); 3138 fixup_device_tree_chrp(); 3139 fixup_device_tree_pmac(); 3140 fixup_device_tree_efika(); 3141 fixup_device_tree_pasemi(); 3142 } 3143 3144 static void __init prom_find_boot_cpu(void) 3145 { 3146 __be32 rval; 3147 ihandle prom_cpu; 3148 phandle cpu_pkg; 3149 3150 rval = 0; 3151 if (prom_getprop(prom.chosen, "cpu", &rval, sizeof(rval)) <= 0) 3152 return; 3153 prom_cpu = be32_to_cpu(rval); 3154 3155 cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu); 3156 3157 if (!PHANDLE_VALID(cpu_pkg)) 3158 return; 3159 3160 prom_getprop(cpu_pkg, "reg", &rval, sizeof(rval)); 3161 prom.cpu = be32_to_cpu(rval); 3162 3163 prom_debug("Booting CPU hw index = %d\n", prom.cpu); 3164 } 3165 3166 static void __init prom_check_initrd(unsigned long r3, unsigned long r4) 3167 { 3168 #ifdef CONFIG_BLK_DEV_INITRD 3169 if (r3 && r4 && r4 != 0xdeadbeef) { 3170 __be64 val; 3171 3172 prom_initrd_start = is_kernel_addr(r3) ? __pa(r3) : r3; 3173 prom_initrd_end = prom_initrd_start + r4; 3174 3175 val = cpu_to_be64(prom_initrd_start); 3176 prom_setprop(prom.chosen, "/chosen", "linux,initrd-start", 3177 &val, sizeof(val)); 3178 val = cpu_to_be64(prom_initrd_end); 3179 prom_setprop(prom.chosen, "/chosen", "linux,initrd-end", 3180 &val, sizeof(val)); 3181 3182 reserve_mem(prom_initrd_start, 3183 prom_initrd_end - prom_initrd_start); 3184 3185 prom_debug("initrd_start=0x%lx\n", prom_initrd_start); 3186 prom_debug("initrd_end=0x%lx\n", prom_initrd_end); 3187 } 3188 #endif /* CONFIG_BLK_DEV_INITRD */ 3189 } 3190 3191 #ifdef CONFIG_PPC64 3192 #ifdef CONFIG_RELOCATABLE 3193 static void reloc_toc(void) 3194 { 3195 } 3196 3197 static void unreloc_toc(void) 3198 { 3199 } 3200 #else 3201 static void __reloc_toc(unsigned long offset, unsigned long nr_entries) 3202 { 3203 unsigned long i; 3204 unsigned long *toc_entry; 3205 3206 /* Get the start of the TOC by using r2 directly. */ 3207 asm volatile("addi %0,2,-0x8000" : "=b" (toc_entry)); 3208 3209 for (i = 0; i < nr_entries; i++) { 3210 *toc_entry = *toc_entry + offset; 3211 toc_entry++; 3212 } 3213 } 3214 3215 static void reloc_toc(void) 3216 { 3217 unsigned long offset = reloc_offset(); 3218 unsigned long nr_entries = 3219 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long); 3220 3221 __reloc_toc(offset, nr_entries); 3222 3223 mb(); 3224 } 3225 3226 static void unreloc_toc(void) 3227 { 3228 unsigned long offset = reloc_offset(); 3229 unsigned long nr_entries = 3230 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long); 3231 3232 mb(); 3233 3234 __reloc_toc(-offset, nr_entries); 3235 } 3236 #endif 3237 #endif 3238 3239 #ifdef CONFIG_PPC_SVM 3240 /* 3241 * Perform the Enter Secure Mode ultracall. 3242 */ 3243 static int enter_secure_mode(unsigned long kbase, unsigned long fdt) 3244 { 3245 register unsigned long r3 asm("r3") = UV_ESM; 3246 register unsigned long r4 asm("r4") = kbase; 3247 register unsigned long r5 asm("r5") = fdt; 3248 3249 asm volatile("sc 2" : "+r"(r3) : "r"(r4), "r"(r5)); 3250 3251 return r3; 3252 } 3253 3254 /* 3255 * Call the Ultravisor to transfer us to secure memory if we have an ESM blob. 3256 */ 3257 static void setup_secure_guest(unsigned long kbase, unsigned long fdt) 3258 { 3259 int ret; 3260 3261 if (!prom_svm_enable) 3262 return; 3263 3264 /* Switch to secure mode. */ 3265 prom_printf("Switching to secure mode.\n"); 3266 3267 /* 3268 * The ultravisor will do an integrity check of the kernel image but we 3269 * relocated it so the check will fail. Restore the original image by 3270 * relocating it back to the kernel virtual base address. 3271 */ 3272 if (IS_ENABLED(CONFIG_RELOCATABLE)) 3273 relocate(KERNELBASE); 3274 3275 ret = enter_secure_mode(kbase, fdt); 3276 3277 /* Relocate the kernel again. */ 3278 if (IS_ENABLED(CONFIG_RELOCATABLE)) 3279 relocate(kbase); 3280 3281 if (ret != U_SUCCESS) { 3282 prom_printf("Returned %d from switching to secure mode.\n", ret); 3283 prom_rtas_os_term("Switch to secure mode failed.\n"); 3284 } 3285 } 3286 #else 3287 static void setup_secure_guest(unsigned long kbase, unsigned long fdt) 3288 { 3289 } 3290 #endif /* CONFIG_PPC_SVM */ 3291 3292 /* 3293 * We enter here early on, when the Open Firmware prom is still 3294 * handling exceptions and the MMU hash table for us. 3295 */ 3296 3297 unsigned long __init prom_init(unsigned long r3, unsigned long r4, 3298 unsigned long pp, 3299 unsigned long r6, unsigned long r7, 3300 unsigned long kbase) 3301 { 3302 unsigned long hdr; 3303 3304 #ifdef CONFIG_PPC32 3305 unsigned long offset = reloc_offset(); 3306 reloc_got2(offset); 3307 #else 3308 reloc_toc(); 3309 #endif 3310 3311 /* 3312 * First zero the BSS 3313 */ 3314 memset(&__bss_start, 0, __bss_stop - __bss_start); 3315 3316 /* 3317 * Init interface to Open Firmware, get some node references, 3318 * like /chosen 3319 */ 3320 prom_init_client_services(pp); 3321 3322 /* 3323 * See if this OF is old enough that we need to do explicit maps 3324 * and other workarounds 3325 */ 3326 prom_find_mmu(); 3327 3328 /* 3329 * Init prom stdout device 3330 */ 3331 prom_init_stdout(); 3332 3333 prom_printf("Preparing to boot %s", linux_banner); 3334 3335 /* 3336 * Get default machine type. At this point, we do not differentiate 3337 * between pSeries SMP and pSeries LPAR 3338 */ 3339 of_platform = prom_find_machine_type(); 3340 prom_printf("Detected machine type: %x\n", of_platform); 3341 3342 #ifndef CONFIG_NONSTATIC_KERNEL 3343 /* Bail if this is a kdump kernel. */ 3344 if (PHYSICAL_START > 0) 3345 prom_panic("Error: You can't boot a kdump kernel from OF!\n"); 3346 #endif 3347 3348 /* 3349 * Check for an initrd 3350 */ 3351 prom_check_initrd(r3, r4); 3352 3353 /* 3354 * Do early parsing of command line 3355 */ 3356 early_cmdline_parse(); 3357 3358 #ifdef CONFIG_PPC_PSERIES 3359 /* 3360 * On pSeries, inform the firmware about our capabilities 3361 */ 3362 if (of_platform == PLATFORM_PSERIES || 3363 of_platform == PLATFORM_PSERIES_LPAR) 3364 prom_send_capabilities(); 3365 #endif 3366 3367 /* 3368 * Copy the CPU hold code 3369 */ 3370 if (of_platform != PLATFORM_POWERMAC) 3371 copy_and_flush(0, kbase, 0x100, 0); 3372 3373 /* 3374 * Initialize memory management within prom_init 3375 */ 3376 prom_init_mem(); 3377 3378 /* 3379 * Determine which cpu is actually running right _now_ 3380 */ 3381 prom_find_boot_cpu(); 3382 3383 /* 3384 * Initialize display devices 3385 */ 3386 prom_check_displays(); 3387 3388 #if defined(CONFIG_PPC64) && defined(__BIG_ENDIAN__) 3389 /* 3390 * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else 3391 * that uses the allocator, we need to make sure we get the top of memory 3392 * available for us here... 3393 */ 3394 if (of_platform == PLATFORM_PSERIES) 3395 prom_initialize_tce_table(); 3396 #endif 3397 3398 /* 3399 * On non-powermacs, try to instantiate RTAS. PowerMacs don't 3400 * have a usable RTAS implementation. 3401 */ 3402 if (of_platform != PLATFORM_POWERMAC) 3403 prom_instantiate_rtas(); 3404 3405 #ifdef CONFIG_PPC64 3406 /* instantiate sml */ 3407 prom_instantiate_sml(); 3408 #endif 3409 3410 /* 3411 * On non-powermacs, put all CPUs in spin-loops. 3412 * 3413 * PowerMacs use a different mechanism to spin CPUs 3414 * 3415 * (This must be done after instanciating RTAS) 3416 */ 3417 if (of_platform != PLATFORM_POWERMAC) 3418 prom_hold_cpus(); 3419 3420 /* 3421 * Fill in some infos for use by the kernel later on 3422 */ 3423 if (prom_memory_limit) { 3424 __be64 val = cpu_to_be64(prom_memory_limit); 3425 prom_setprop(prom.chosen, "/chosen", "linux,memory-limit", 3426 &val, sizeof(val)); 3427 } 3428 #ifdef CONFIG_PPC64 3429 if (prom_iommu_off) 3430 prom_setprop(prom.chosen, "/chosen", "linux,iommu-off", 3431 NULL, 0); 3432 3433 if (prom_iommu_force_on) 3434 prom_setprop(prom.chosen, "/chosen", "linux,iommu-force-on", 3435 NULL, 0); 3436 3437 if (prom_tce_alloc_start) { 3438 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-start", 3439 &prom_tce_alloc_start, 3440 sizeof(prom_tce_alloc_start)); 3441 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-end", 3442 &prom_tce_alloc_end, 3443 sizeof(prom_tce_alloc_end)); 3444 } 3445 #endif 3446 3447 /* 3448 * Fixup any known bugs in the device-tree 3449 */ 3450 fixup_device_tree(); 3451 3452 /* 3453 * Now finally create the flattened device-tree 3454 */ 3455 prom_printf("copying OF device tree...\n"); 3456 flatten_device_tree(); 3457 3458 /* 3459 * in case stdin is USB and still active on IBM machines... 3460 * Unfortunately quiesce crashes on some powermacs if we have 3461 * closed stdin already (in particular the powerbook 101). 3462 */ 3463 if (of_platform != PLATFORM_POWERMAC) 3464 prom_close_stdin(); 3465 3466 /* 3467 * Call OF "quiesce" method to shut down pending DMA's from 3468 * devices etc... 3469 */ 3470 prom_printf("Quiescing Open Firmware ...\n"); 3471 call_prom("quiesce", 0, 0); 3472 3473 /* 3474 * And finally, call the kernel passing it the flattened device 3475 * tree and NULL as r5, thus triggering the new entry point which 3476 * is common to us and kexec 3477 */ 3478 hdr = dt_header_start; 3479 3480 prom_printf("Booting Linux via __start() @ 0x%lx ...\n", kbase); 3481 prom_debug("->dt_header_start=0x%lx\n", hdr); 3482 3483 #ifdef CONFIG_PPC32 3484 reloc_got2(-offset); 3485 #else 3486 unreloc_toc(); 3487 #endif 3488 3489 /* Move to secure memory if we're supposed to be secure guests. */ 3490 setup_secure_guest(kbase, hdr); 3491 3492 __start(hdr, kbase, 0, 0, 0, 0, 0); 3493 3494 return 0; 3495 } 3496