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