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