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