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