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