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