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