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