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/config.h> 20 #include <linux/kernel.h> 21 #include <linux/string.h> 22 #include <linux/init.h> 23 #include <linux/threads.h> 24 #include <linux/spinlock.h> 25 #include <linux/types.h> 26 #include <linux/pci.h> 27 #include <linux/proc_fs.h> 28 #include <linux/stringify.h> 29 #include <linux/delay.h> 30 #include <linux/initrd.h> 31 #include <linux/bitops.h> 32 #include <asm/prom.h> 33 #include <asm/rtas.h> 34 #include <asm/page.h> 35 #include <asm/processor.h> 36 #include <asm/irq.h> 37 #include <asm/io.h> 38 #include <asm/smp.h> 39 #include <asm/system.h> 40 #include <asm/mmu.h> 41 #include <asm/pgtable.h> 42 #include <asm/pci.h> 43 #include <asm/iommu.h> 44 #include <asm/btext.h> 45 #include <asm/sections.h> 46 #include <asm/machdep.h> 47 48 #ifdef CONFIG_LOGO_LINUX_CLUT224 49 #include <linux/linux_logo.h> 50 extern const struct linux_logo logo_linux_clut224; 51 #endif 52 53 /* 54 * Properties whose value is longer than this get excluded from our 55 * copy of the device tree. This value does need to be big enough to 56 * ensure that we don't lose things like the interrupt-map property 57 * on a PCI-PCI bridge. 58 */ 59 #define MAX_PROPERTY_LENGTH (1UL * 1024 * 1024) 60 61 /* 62 * Eventually bump that one up 63 */ 64 #define DEVTREE_CHUNK_SIZE 0x100000 65 66 /* 67 * This is the size of the local memory reserve map that gets copied 68 * into the boot params passed to the kernel. That size is totally 69 * flexible as the kernel just reads the list until it encounters an 70 * entry with size 0, so it can be changed without breaking binary 71 * compatibility 72 */ 73 #define MEM_RESERVE_MAP_SIZE 8 74 75 /* 76 * prom_init() is called very early on, before the kernel text 77 * and data have been mapped to KERNELBASE. At this point the code 78 * is running at whatever address it has been loaded at. 79 * On ppc32 we compile with -mrelocatable, which means that references 80 * to extern and static variables get relocated automatically. 81 * On ppc64 we have to relocate the references explicitly with 82 * RELOC. (Note that strings count as static variables.) 83 * 84 * Because OF may have mapped I/O devices into the area starting at 85 * KERNELBASE, particularly on CHRP machines, we can't safely call 86 * OF once the kernel has been mapped to KERNELBASE. Therefore all 87 * OF calls must be done within prom_init(). 88 * 89 * ADDR is used in calls to call_prom. The 4th and following 90 * arguments to call_prom should be 32-bit values. 91 * On ppc64, 64 bit values are truncated to 32 bits (and 92 * fortunately don't get interpreted as two arguments). 93 */ 94 #ifdef CONFIG_PPC64 95 #define RELOC(x) (*PTRRELOC(&(x))) 96 #define ADDR(x) (u32) add_reloc_offset((unsigned long)(x)) 97 #define OF_WORKAROUNDS 0 98 #else 99 #define RELOC(x) (x) 100 #define ADDR(x) (u32) (x) 101 #define OF_WORKAROUNDS of_workarounds 102 int of_workarounds; 103 #endif 104 105 #define OF_WA_CLAIM 1 /* do phys/virt claim separately, then map */ 106 #define OF_WA_LONGTRAIL 2 /* work around longtrail bugs */ 107 108 #define PROM_BUG() do { \ 109 prom_printf("kernel BUG at %s line 0x%x!\n", \ 110 RELOC(__FILE__), __LINE__); \ 111 __asm__ __volatile__(".long " BUG_ILLEGAL_INSTR); \ 112 } while (0) 113 114 #ifdef DEBUG_PROM 115 #define prom_debug(x...) prom_printf(x) 116 #else 117 #define prom_debug(x...) 118 #endif 119 120 121 typedef u32 prom_arg_t; 122 123 struct prom_args { 124 u32 service; 125 u32 nargs; 126 u32 nret; 127 prom_arg_t args[10]; 128 }; 129 130 struct prom_t { 131 ihandle root; 132 phandle chosen; 133 int cpu; 134 ihandle stdout; 135 ihandle mmumap; 136 ihandle memory; 137 }; 138 139 struct mem_map_entry { 140 u64 base; 141 u64 size; 142 }; 143 144 typedef u32 cell_t; 145 146 extern void __start(unsigned long r3, unsigned long r4, unsigned long r5); 147 148 #ifdef CONFIG_PPC64 149 extern int enter_prom(struct prom_args *args, unsigned long entry); 150 #else 151 static inline int enter_prom(struct prom_args *args, unsigned long entry) 152 { 153 return ((int (*)(struct prom_args *))entry)(args); 154 } 155 #endif 156 157 extern void copy_and_flush(unsigned long dest, unsigned long src, 158 unsigned long size, unsigned long offset); 159 160 /* prom structure */ 161 static struct prom_t __initdata prom; 162 163 static unsigned long prom_entry __initdata; 164 165 #define PROM_SCRATCH_SIZE 256 166 167 static char __initdata of_stdout_device[256]; 168 static char __initdata prom_scratch[PROM_SCRATCH_SIZE]; 169 170 static unsigned long __initdata dt_header_start; 171 static unsigned long __initdata dt_struct_start, dt_struct_end; 172 static unsigned long __initdata dt_string_start, dt_string_end; 173 174 static unsigned long __initdata prom_initrd_start, prom_initrd_end; 175 176 #ifdef CONFIG_PPC64 177 static int __initdata iommu_force_on; 178 static int __initdata ppc64_iommu_off; 179 static unsigned long __initdata prom_tce_alloc_start; 180 static unsigned long __initdata prom_tce_alloc_end; 181 #endif 182 183 /* Platforms codes are now obsolete in the kernel. Now only used within this 184 * file and ultimately gone too. Feel free to change them if you need, they 185 * are not shared with anything outside of this file anymore 186 */ 187 #define PLATFORM_PSERIES 0x0100 188 #define PLATFORM_PSERIES_LPAR 0x0101 189 #define PLATFORM_LPAR 0x0001 190 #define PLATFORM_POWERMAC 0x0400 191 #define PLATFORM_GENERIC 0x0500 192 193 static int __initdata of_platform; 194 195 static char __initdata prom_cmd_line[COMMAND_LINE_SIZE]; 196 197 static unsigned long __initdata prom_memory_limit; 198 199 static unsigned long __initdata alloc_top; 200 static unsigned long __initdata alloc_top_high; 201 static unsigned long __initdata alloc_bottom; 202 static unsigned long __initdata rmo_top; 203 static unsigned long __initdata ram_top; 204 205 #ifdef CONFIG_KEXEC 206 static unsigned long __initdata prom_crashk_base; 207 static unsigned long __initdata prom_crashk_size; 208 #endif 209 210 static struct mem_map_entry __initdata mem_reserve_map[MEM_RESERVE_MAP_SIZE]; 211 static int __initdata mem_reserve_cnt; 212 213 static cell_t __initdata regbuf[1024]; 214 215 216 #define MAX_CPU_THREADS 2 217 218 /* 219 * Error results ... some OF calls will return "-1" on error, some 220 * will return 0, some will return either. To simplify, here are 221 * macros to use with any ihandle or phandle return value to check if 222 * it is valid 223 */ 224 225 #define PROM_ERROR (-1u) 226 #define PHANDLE_VALID(p) ((p) != 0 && (p) != PROM_ERROR) 227 #define IHANDLE_VALID(i) ((i) != 0 && (i) != PROM_ERROR) 228 229 230 /* This is the one and *ONLY* place where we actually call open 231 * firmware. 232 */ 233 234 static int __init call_prom(const char *service, int nargs, int nret, ...) 235 { 236 int i; 237 struct prom_args args; 238 va_list list; 239 240 args.service = ADDR(service); 241 args.nargs = nargs; 242 args.nret = nret; 243 244 va_start(list, nret); 245 for (i = 0; i < nargs; i++) 246 args.args[i] = va_arg(list, prom_arg_t); 247 va_end(list); 248 249 for (i = 0; i < nret; i++) 250 args.args[nargs+i] = 0; 251 252 if (enter_prom(&args, RELOC(prom_entry)) < 0) 253 return PROM_ERROR; 254 255 return (nret > 0) ? args.args[nargs] : 0; 256 } 257 258 static int __init call_prom_ret(const char *service, int nargs, int nret, 259 prom_arg_t *rets, ...) 260 { 261 int i; 262 struct prom_args args; 263 va_list list; 264 265 args.service = ADDR(service); 266 args.nargs = nargs; 267 args.nret = nret; 268 269 va_start(list, rets); 270 for (i = 0; i < nargs; i++) 271 args.args[i] = va_arg(list, prom_arg_t); 272 va_end(list); 273 274 for (i = 0; i < nret; i++) 275 args.args[nargs+i] = 0; 276 277 if (enter_prom(&args, RELOC(prom_entry)) < 0) 278 return PROM_ERROR; 279 280 if (rets != NULL) 281 for (i = 1; i < nret; ++i) 282 rets[i-1] = args.args[nargs+i]; 283 284 return (nret > 0) ? args.args[nargs] : 0; 285 } 286 287 288 static void __init prom_print(const char *msg) 289 { 290 const char *p, *q; 291 struct prom_t *_prom = &RELOC(prom); 292 293 if (_prom->stdout == 0) 294 return; 295 296 for (p = msg; *p != 0; p = q) { 297 for (q = p; *q != 0 && *q != '\n'; ++q) 298 ; 299 if (q > p) 300 call_prom("write", 3, 1, _prom->stdout, p, q - p); 301 if (*q == 0) 302 break; 303 ++q; 304 call_prom("write", 3, 1, _prom->stdout, ADDR("\r\n"), 2); 305 } 306 } 307 308 309 static void __init prom_print_hex(unsigned long val) 310 { 311 int i, nibbles = sizeof(val)*2; 312 char buf[sizeof(val)*2+1]; 313 struct prom_t *_prom = &RELOC(prom); 314 315 for (i = nibbles-1; i >= 0; i--) { 316 buf[i] = (val & 0xf) + '0'; 317 if (buf[i] > '9') 318 buf[i] += ('a'-'0'-10); 319 val >>= 4; 320 } 321 buf[nibbles] = '\0'; 322 call_prom("write", 3, 1, _prom->stdout, buf, nibbles); 323 } 324 325 326 static void __init prom_printf(const char *format, ...) 327 { 328 const char *p, *q, *s; 329 va_list args; 330 unsigned long v; 331 struct prom_t *_prom = &RELOC(prom); 332 333 va_start(args, format); 334 #ifdef CONFIG_PPC64 335 format = PTRRELOC(format); 336 #endif 337 for (p = format; *p != 0; p = q) { 338 for (q = p; *q != 0 && *q != '\n' && *q != '%'; ++q) 339 ; 340 if (q > p) 341 call_prom("write", 3, 1, _prom->stdout, p, q - p); 342 if (*q == 0) 343 break; 344 if (*q == '\n') { 345 ++q; 346 call_prom("write", 3, 1, _prom->stdout, 347 ADDR("\r\n"), 2); 348 continue; 349 } 350 ++q; 351 if (*q == 0) 352 break; 353 switch (*q) { 354 case 's': 355 ++q; 356 s = va_arg(args, const char *); 357 prom_print(s); 358 break; 359 case 'x': 360 ++q; 361 v = va_arg(args, unsigned long); 362 prom_print_hex(v); 363 break; 364 } 365 } 366 } 367 368 369 static unsigned int __init prom_claim(unsigned long virt, unsigned long size, 370 unsigned long align) 371 { 372 struct prom_t *_prom = &RELOC(prom); 373 374 if (align == 0 && (OF_WORKAROUNDS & OF_WA_CLAIM)) { 375 /* 376 * Old OF requires we claim physical and virtual separately 377 * and then map explicitly (assuming virtual mode) 378 */ 379 int ret; 380 prom_arg_t result; 381 382 ret = call_prom_ret("call-method", 5, 2, &result, 383 ADDR("claim"), _prom->memory, 384 align, size, virt); 385 if (ret != 0 || result == -1) 386 return -1; 387 ret = call_prom_ret("call-method", 5, 2, &result, 388 ADDR("claim"), _prom->mmumap, 389 align, size, virt); 390 if (ret != 0) { 391 call_prom("call-method", 4, 1, ADDR("release"), 392 _prom->memory, size, virt); 393 return -1; 394 } 395 /* the 0x12 is M (coherence) + PP == read/write */ 396 call_prom("call-method", 6, 1, 397 ADDR("map"), _prom->mmumap, 0x12, size, virt, virt); 398 return virt; 399 } 400 return call_prom("claim", 3, 1, (prom_arg_t)virt, (prom_arg_t)size, 401 (prom_arg_t)align); 402 } 403 404 static void __init __attribute__((noreturn)) prom_panic(const char *reason) 405 { 406 #ifdef CONFIG_PPC64 407 reason = PTRRELOC(reason); 408 #endif 409 prom_print(reason); 410 /* Do not call exit because it clears the screen on pmac 411 * it also causes some sort of double-fault on early pmacs */ 412 if (RELOC(of_platform) == PLATFORM_POWERMAC) 413 asm("trap\n"); 414 415 /* ToDo: should put up an SRC here on p/iSeries */ 416 call_prom("exit", 0, 0); 417 418 for (;;) /* should never get here */ 419 ; 420 } 421 422 423 static int __init prom_next_node(phandle *nodep) 424 { 425 phandle node; 426 427 if ((node = *nodep) != 0 428 && (*nodep = call_prom("child", 1, 1, node)) != 0) 429 return 1; 430 if ((*nodep = call_prom("peer", 1, 1, node)) != 0) 431 return 1; 432 for (;;) { 433 if ((node = call_prom("parent", 1, 1, node)) == 0) 434 return 0; 435 if ((*nodep = call_prom("peer", 1, 1, node)) != 0) 436 return 1; 437 } 438 } 439 440 static int inline prom_getprop(phandle node, const char *pname, 441 void *value, size_t valuelen) 442 { 443 return call_prom("getprop", 4, 1, node, ADDR(pname), 444 (u32)(unsigned long) value, (u32) valuelen); 445 } 446 447 static int inline prom_getproplen(phandle node, const char *pname) 448 { 449 return call_prom("getproplen", 2, 1, node, ADDR(pname)); 450 } 451 452 static void add_string(char **str, const char *q) 453 { 454 char *p = *str; 455 456 while (*q) 457 *p++ = *q++; 458 *p++ = ' '; 459 *str = p; 460 } 461 462 static char *tohex(unsigned int x) 463 { 464 static char digits[] = "0123456789abcdef"; 465 static char result[9]; 466 int i; 467 468 result[8] = 0; 469 i = 8; 470 do { 471 --i; 472 result[i] = digits[x & 0xf]; 473 x >>= 4; 474 } while (x != 0 && i > 0); 475 return &result[i]; 476 } 477 478 static int __init prom_setprop(phandle node, const char *nodename, 479 const char *pname, void *value, size_t valuelen) 480 { 481 char cmd[256], *p; 482 483 if (!(OF_WORKAROUNDS & OF_WA_LONGTRAIL)) 484 return call_prom("setprop", 4, 1, node, ADDR(pname), 485 (u32)(unsigned long) value, (u32) valuelen); 486 487 /* gah... setprop doesn't work on longtrail, have to use interpret */ 488 p = cmd; 489 add_string(&p, "dev"); 490 add_string(&p, nodename); 491 add_string(&p, tohex((u32)(unsigned long) value)); 492 add_string(&p, tohex(valuelen)); 493 add_string(&p, tohex(ADDR(pname))); 494 add_string(&p, tohex(strlen(RELOC(pname)))); 495 add_string(&p, "property"); 496 *p = 0; 497 return call_prom("interpret", 1, 1, (u32)(unsigned long) cmd); 498 } 499 500 /* We can't use the standard versions because of RELOC headaches. */ 501 #define isxdigit(c) (('0' <= (c) && (c) <= '9') \ 502 || ('a' <= (c) && (c) <= 'f') \ 503 || ('A' <= (c) && (c) <= 'F')) 504 505 #define isdigit(c) ('0' <= (c) && (c) <= '9') 506 #define islower(c) ('a' <= (c) && (c) <= 'z') 507 #define toupper(c) (islower(c) ? ((c) - 'a' + 'A') : (c)) 508 509 unsigned long prom_strtoul(const char *cp, const char **endp) 510 { 511 unsigned long result = 0, base = 10, value; 512 513 if (*cp == '0') { 514 base = 8; 515 cp++; 516 if (toupper(*cp) == 'X') { 517 cp++; 518 base = 16; 519 } 520 } 521 522 while (isxdigit(*cp) && 523 (value = isdigit(*cp) ? *cp - '0' : toupper(*cp) - 'A' + 10) < base) { 524 result = result * base + value; 525 cp++; 526 } 527 528 if (endp) 529 *endp = cp; 530 531 return result; 532 } 533 534 unsigned long prom_memparse(const char *ptr, const char **retptr) 535 { 536 unsigned long ret = prom_strtoul(ptr, retptr); 537 int shift = 0; 538 539 /* 540 * We can't use a switch here because GCC *may* generate a 541 * jump table which won't work, because we're not running at 542 * the address we're linked at. 543 */ 544 if ('G' == **retptr || 'g' == **retptr) 545 shift = 30; 546 547 if ('M' == **retptr || 'm' == **retptr) 548 shift = 20; 549 550 if ('K' == **retptr || 'k' == **retptr) 551 shift = 10; 552 553 if (shift) { 554 ret <<= shift; 555 (*retptr)++; 556 } 557 558 return ret; 559 } 560 561 /* 562 * Early parsing of the command line passed to the kernel, used for 563 * "mem=x" and the options that affect the iommu 564 */ 565 static void __init early_cmdline_parse(void) 566 { 567 struct prom_t *_prom = &RELOC(prom); 568 const char *opt; 569 char *p; 570 int l = 0; 571 572 RELOC(prom_cmd_line[0]) = 0; 573 p = RELOC(prom_cmd_line); 574 if ((long)_prom->chosen > 0) 575 l = prom_getprop(_prom->chosen, "bootargs", p, COMMAND_LINE_SIZE-1); 576 #ifdef CONFIG_CMDLINE 577 if (l == 0) /* dbl check */ 578 strlcpy(RELOC(prom_cmd_line), 579 RELOC(CONFIG_CMDLINE), sizeof(prom_cmd_line)); 580 #endif /* CONFIG_CMDLINE */ 581 prom_printf("command line: %s\n", RELOC(prom_cmd_line)); 582 583 #ifdef CONFIG_PPC64 584 opt = strstr(RELOC(prom_cmd_line), RELOC("iommu=")); 585 if (opt) { 586 prom_printf("iommu opt is: %s\n", opt); 587 opt += 6; 588 while (*opt && *opt == ' ') 589 opt++; 590 if (!strncmp(opt, RELOC("off"), 3)) 591 RELOC(ppc64_iommu_off) = 1; 592 else if (!strncmp(opt, RELOC("force"), 5)) 593 RELOC(iommu_force_on) = 1; 594 } 595 #endif 596 597 opt = strstr(RELOC(prom_cmd_line), RELOC("mem=")); 598 if (opt) { 599 opt += 4; 600 RELOC(prom_memory_limit) = prom_memparse(opt, (const char **)&opt); 601 #ifdef CONFIG_PPC64 602 /* Align to 16 MB == size of ppc64 large page */ 603 RELOC(prom_memory_limit) = ALIGN(RELOC(prom_memory_limit), 0x1000000); 604 #endif 605 } 606 607 #ifdef CONFIG_KEXEC 608 /* 609 * crashkernel=size@addr specifies the location to reserve for 610 * crash kernel. 611 */ 612 opt = strstr(RELOC(prom_cmd_line), RELOC("crashkernel=")); 613 if (opt) { 614 opt += 12; 615 RELOC(prom_crashk_size) = 616 prom_memparse(opt, (const char **)&opt); 617 618 if (ALIGN(RELOC(prom_crashk_size), 0x1000000) != 619 RELOC(prom_crashk_size)) { 620 prom_printf("Warning: crashkernel size is not " 621 "aligned to 16MB\n"); 622 } 623 624 /* 625 * At present, the crash kernel always run at 32MB. 626 * Just ignore whatever user passed. 627 */ 628 RELOC(prom_crashk_base) = 0x2000000; 629 if (*opt == '@') { 630 prom_printf("Warning: PPC64 kdump kernel always runs " 631 "at 32 MB\n"); 632 } 633 } 634 #endif 635 } 636 637 #ifdef CONFIG_PPC_PSERIES 638 /* 639 * There are two methods for telling firmware what our capabilities are. 640 * Newer machines have an "ibm,client-architecture-support" method on the 641 * root node. For older machines, we have to call the "process-elf-header" 642 * method in the /packages/elf-loader node, passing it a fake 32-bit 643 * ELF header containing a couple of PT_NOTE sections that contain 644 * structures that contain various information. 645 */ 646 647 /* 648 * New method - extensible architecture description vector. 649 * 650 * Because the description vector contains a mix of byte and word 651 * values, we declare it as an unsigned char array, and use this 652 * macro to put word values in. 653 */ 654 #define W(x) ((x) >> 24) & 0xff, ((x) >> 16) & 0xff, \ 655 ((x) >> 8) & 0xff, (x) & 0xff 656 657 /* Option vector bits - generic bits in byte 1 */ 658 #define OV_IGNORE 0x80 /* ignore this vector */ 659 #define OV_CESSATION_POLICY 0x40 /* halt if unsupported option present*/ 660 661 /* Option vector 1: processor architectures supported */ 662 #define OV1_PPC_2_00 0x80 /* set if we support PowerPC 2.00 */ 663 #define OV1_PPC_2_01 0x40 /* set if we support PowerPC 2.01 */ 664 #define OV1_PPC_2_02 0x20 /* set if we support PowerPC 2.02 */ 665 #define OV1_PPC_2_03 0x10 /* set if we support PowerPC 2.03 */ 666 #define OV1_PPC_2_04 0x08 /* set if we support PowerPC 2.04 */ 667 #define OV1_PPC_2_05 0x04 /* set if we support PowerPC 2.05 */ 668 669 /* Option vector 2: Open Firmware options supported */ 670 #define OV2_REAL_MODE 0x20 /* set if we want OF in real mode */ 671 672 /* Option vector 3: processor options supported */ 673 #define OV3_FP 0x80 /* floating point */ 674 #define OV3_VMX 0x40 /* VMX/Altivec */ 675 676 /* Option vector 5: PAPR/OF options supported */ 677 #define OV5_LPAR 0x80 /* logical partitioning supported */ 678 #define OV5_SPLPAR 0x40 /* shared-processor LPAR supported */ 679 /* ibm,dynamic-reconfiguration-memory property supported */ 680 #define OV5_DRCONF_MEMORY 0x20 681 #define OV5_LARGE_PAGES 0x10 /* large pages supported */ 682 683 /* 684 * The architecture vector has an array of PVR mask/value pairs, 685 * followed by # option vectors - 1, followed by the option vectors. 686 */ 687 static unsigned char ibm_architecture_vec[] = { 688 W(0xfffe0000), W(0x003a0000), /* POWER5/POWER5+ */ 689 W(0xffff0000), W(0x003e0000), /* POWER6 */ 690 W(0xfffffffe), W(0x0f000001), /* all 2.04-compliant and earlier */ 691 5 - 1, /* 5 option vectors */ 692 693 /* option vector 1: processor architectures supported */ 694 3 - 1, /* length */ 695 0, /* don't ignore, don't halt */ 696 OV1_PPC_2_00 | OV1_PPC_2_01 | OV1_PPC_2_02 | OV1_PPC_2_03 | 697 OV1_PPC_2_04 | OV1_PPC_2_05, 698 699 /* option vector 2: Open Firmware options supported */ 700 34 - 1, /* length */ 701 OV2_REAL_MODE, 702 0, 0, 703 W(0xffffffff), /* real_base */ 704 W(0xffffffff), /* real_size */ 705 W(0xffffffff), /* virt_base */ 706 W(0xffffffff), /* virt_size */ 707 W(0xffffffff), /* load_base */ 708 W(64), /* 128MB min RMA */ 709 W(0xffffffff), /* full client load */ 710 0, /* min RMA percentage of total RAM */ 711 48, /* max log_2(hash table size) */ 712 713 /* option vector 3: processor options supported */ 714 3 - 1, /* length */ 715 0, /* don't ignore, don't halt */ 716 OV3_FP | OV3_VMX, 717 718 /* option vector 4: IBM PAPR implementation */ 719 2 - 1, /* length */ 720 0, /* don't halt */ 721 722 /* option vector 5: PAPR/OF options */ 723 3 - 1, /* length */ 724 0, /* don't ignore, don't halt */ 725 OV5_LPAR | OV5_SPLPAR | OV5_LARGE_PAGES, 726 }; 727 728 /* Old method - ELF header with PT_NOTE sections */ 729 static struct fake_elf { 730 Elf32_Ehdr elfhdr; 731 Elf32_Phdr phdr[2]; 732 struct chrpnote { 733 u32 namesz; 734 u32 descsz; 735 u32 type; 736 char name[8]; /* "PowerPC" */ 737 struct chrpdesc { 738 u32 real_mode; 739 u32 real_base; 740 u32 real_size; 741 u32 virt_base; 742 u32 virt_size; 743 u32 load_base; 744 } chrpdesc; 745 } chrpnote; 746 struct rpanote { 747 u32 namesz; 748 u32 descsz; 749 u32 type; 750 char name[24]; /* "IBM,RPA-Client-Config" */ 751 struct rpadesc { 752 u32 lpar_affinity; 753 u32 min_rmo_size; 754 u32 min_rmo_percent; 755 u32 max_pft_size; 756 u32 splpar; 757 u32 min_load; 758 u32 new_mem_def; 759 u32 ignore_me; 760 } rpadesc; 761 } rpanote; 762 } fake_elf = { 763 .elfhdr = { 764 .e_ident = { 0x7f, 'E', 'L', 'F', 765 ELFCLASS32, ELFDATA2MSB, EV_CURRENT }, 766 .e_type = ET_EXEC, /* yeah right */ 767 .e_machine = EM_PPC, 768 .e_version = EV_CURRENT, 769 .e_phoff = offsetof(struct fake_elf, phdr), 770 .e_phentsize = sizeof(Elf32_Phdr), 771 .e_phnum = 2 772 }, 773 .phdr = { 774 [0] = { 775 .p_type = PT_NOTE, 776 .p_offset = offsetof(struct fake_elf, chrpnote), 777 .p_filesz = sizeof(struct chrpnote) 778 }, [1] = { 779 .p_type = PT_NOTE, 780 .p_offset = offsetof(struct fake_elf, rpanote), 781 .p_filesz = sizeof(struct rpanote) 782 } 783 }, 784 .chrpnote = { 785 .namesz = sizeof("PowerPC"), 786 .descsz = sizeof(struct chrpdesc), 787 .type = 0x1275, 788 .name = "PowerPC", 789 .chrpdesc = { 790 .real_mode = ~0U, /* ~0 means "don't care" */ 791 .real_base = ~0U, 792 .real_size = ~0U, 793 .virt_base = ~0U, 794 .virt_size = ~0U, 795 .load_base = ~0U 796 }, 797 }, 798 .rpanote = { 799 .namesz = sizeof("IBM,RPA-Client-Config"), 800 .descsz = sizeof(struct rpadesc), 801 .type = 0x12759999, 802 .name = "IBM,RPA-Client-Config", 803 .rpadesc = { 804 .lpar_affinity = 0, 805 .min_rmo_size = 64, /* in megabytes */ 806 .min_rmo_percent = 0, 807 .max_pft_size = 48, /* 2^48 bytes max PFT size */ 808 .splpar = 1, 809 .min_load = ~0U, 810 .new_mem_def = 0 811 } 812 } 813 }; 814 815 static void __init prom_send_capabilities(void) 816 { 817 ihandle elfloader, root; 818 prom_arg_t ret; 819 820 root = call_prom("open", 1, 1, ADDR("/")); 821 if (root != 0) { 822 /* try calling the ibm,client-architecture-support method */ 823 if (call_prom_ret("call-method", 3, 2, &ret, 824 ADDR("ibm,client-architecture-support"), 825 root, 826 ADDR(ibm_architecture_vec)) == 0) { 827 /* the call exists... */ 828 if (ret) 829 prom_printf("WARNING: ibm,client-architecture" 830 "-support call FAILED!\n"); 831 call_prom("close", 1, 0, root); 832 return; 833 } 834 call_prom("close", 1, 0, root); 835 } 836 837 /* no ibm,client-architecture-support call, try the old way */ 838 elfloader = call_prom("open", 1, 1, ADDR("/packages/elf-loader")); 839 if (elfloader == 0) { 840 prom_printf("couldn't open /packages/elf-loader\n"); 841 return; 842 } 843 call_prom("call-method", 3, 1, ADDR("process-elf-header"), 844 elfloader, ADDR(&fake_elf)); 845 call_prom("close", 1, 0, elfloader); 846 } 847 #endif 848 849 /* 850 * Memory allocation strategy... our layout is normally: 851 * 852 * at 14Mb or more we have vmlinux, then a gap and initrd. In some 853 * rare cases, initrd might end up being before the kernel though. 854 * We assume this won't override the final kernel at 0, we have no 855 * provision to handle that in this version, but it should hopefully 856 * never happen. 857 * 858 * alloc_top is set to the top of RMO, eventually shrink down if the 859 * TCEs overlap 860 * 861 * alloc_bottom is set to the top of kernel/initrd 862 * 863 * from there, allocations are done this way : rtas is allocated 864 * topmost, and the device-tree is allocated from the bottom. We try 865 * to grow the device-tree allocation as we progress. If we can't, 866 * then we fail, we don't currently have a facility to restart 867 * elsewhere, but that shouldn't be necessary. 868 * 869 * Note that calls to reserve_mem have to be done explicitly, memory 870 * allocated with either alloc_up or alloc_down isn't automatically 871 * reserved. 872 */ 873 874 875 /* 876 * Allocates memory in the RMO upward from the kernel/initrd 877 * 878 * When align is 0, this is a special case, it means to allocate in place 879 * at the current location of alloc_bottom or fail (that is basically 880 * extending the previous allocation). Used for the device-tree flattening 881 */ 882 static unsigned long __init alloc_up(unsigned long size, unsigned long align) 883 { 884 unsigned long base = RELOC(alloc_bottom); 885 unsigned long addr = 0; 886 887 if (align) 888 base = _ALIGN_UP(base, align); 889 prom_debug("alloc_up(%x, %x)\n", size, align); 890 if (RELOC(ram_top) == 0) 891 prom_panic("alloc_up() called with mem not initialized\n"); 892 893 if (align) 894 base = _ALIGN_UP(RELOC(alloc_bottom), align); 895 else 896 base = RELOC(alloc_bottom); 897 898 for(; (base + size) <= RELOC(alloc_top); 899 base = _ALIGN_UP(base + 0x100000, align)) { 900 prom_debug(" trying: 0x%x\n\r", base); 901 addr = (unsigned long)prom_claim(base, size, 0); 902 if (addr != PROM_ERROR && addr != 0) 903 break; 904 addr = 0; 905 if (align == 0) 906 break; 907 } 908 if (addr == 0) 909 return 0; 910 RELOC(alloc_bottom) = addr; 911 912 prom_debug(" -> %x\n", addr); 913 prom_debug(" alloc_bottom : %x\n", RELOC(alloc_bottom)); 914 prom_debug(" alloc_top : %x\n", RELOC(alloc_top)); 915 prom_debug(" alloc_top_hi : %x\n", RELOC(alloc_top_high)); 916 prom_debug(" rmo_top : %x\n", RELOC(rmo_top)); 917 prom_debug(" ram_top : %x\n", RELOC(ram_top)); 918 919 return addr; 920 } 921 922 /* 923 * Allocates memory downward, either from top of RMO, or if highmem 924 * is set, from the top of RAM. Note that this one doesn't handle 925 * failures. It does claim memory if highmem is not set. 926 */ 927 static unsigned long __init alloc_down(unsigned long size, unsigned long align, 928 int highmem) 929 { 930 unsigned long base, addr = 0; 931 932 prom_debug("alloc_down(%x, %x, %s)\n", size, align, 933 highmem ? RELOC("(high)") : RELOC("(low)")); 934 if (RELOC(ram_top) == 0) 935 prom_panic("alloc_down() called with mem not initialized\n"); 936 937 if (highmem) { 938 /* Carve out storage for the TCE table. */ 939 addr = _ALIGN_DOWN(RELOC(alloc_top_high) - size, align); 940 if (addr <= RELOC(alloc_bottom)) 941 return 0; 942 /* Will we bump into the RMO ? If yes, check out that we 943 * didn't overlap existing allocations there, if we did, 944 * we are dead, we must be the first in town ! 945 */ 946 if (addr < RELOC(rmo_top)) { 947 /* Good, we are first */ 948 if (RELOC(alloc_top) == RELOC(rmo_top)) 949 RELOC(alloc_top) = RELOC(rmo_top) = addr; 950 else 951 return 0; 952 } 953 RELOC(alloc_top_high) = addr; 954 goto bail; 955 } 956 957 base = _ALIGN_DOWN(RELOC(alloc_top) - size, align); 958 for (; base > RELOC(alloc_bottom); 959 base = _ALIGN_DOWN(base - 0x100000, align)) { 960 prom_debug(" trying: 0x%x\n\r", base); 961 addr = (unsigned long)prom_claim(base, size, 0); 962 if (addr != PROM_ERROR && addr != 0) 963 break; 964 addr = 0; 965 } 966 if (addr == 0) 967 return 0; 968 RELOC(alloc_top) = addr; 969 970 bail: 971 prom_debug(" -> %x\n", addr); 972 prom_debug(" alloc_bottom : %x\n", RELOC(alloc_bottom)); 973 prom_debug(" alloc_top : %x\n", RELOC(alloc_top)); 974 prom_debug(" alloc_top_hi : %x\n", RELOC(alloc_top_high)); 975 prom_debug(" rmo_top : %x\n", RELOC(rmo_top)); 976 prom_debug(" ram_top : %x\n", RELOC(ram_top)); 977 978 return addr; 979 } 980 981 /* 982 * Parse a "reg" cell 983 */ 984 static unsigned long __init prom_next_cell(int s, cell_t **cellp) 985 { 986 cell_t *p = *cellp; 987 unsigned long r = 0; 988 989 /* Ignore more than 2 cells */ 990 while (s > sizeof(unsigned long) / 4) { 991 p++; 992 s--; 993 } 994 r = *p++; 995 #ifdef CONFIG_PPC64 996 if (s > 1) { 997 r <<= 32; 998 r |= *(p++); 999 } 1000 #endif 1001 *cellp = p; 1002 return r; 1003 } 1004 1005 /* 1006 * Very dumb function for adding to the memory reserve list, but 1007 * we don't need anything smarter at this point 1008 * 1009 * XXX Eventually check for collisions. They should NEVER happen. 1010 * If problems seem to show up, it would be a good start to track 1011 * them down. 1012 */ 1013 static void reserve_mem(u64 base, u64 size) 1014 { 1015 u64 top = base + size; 1016 unsigned long cnt = RELOC(mem_reserve_cnt); 1017 1018 if (size == 0) 1019 return; 1020 1021 /* We need to always keep one empty entry so that we 1022 * have our terminator with "size" set to 0 since we are 1023 * dumb and just copy this entire array to the boot params 1024 */ 1025 base = _ALIGN_DOWN(base, PAGE_SIZE); 1026 top = _ALIGN_UP(top, PAGE_SIZE); 1027 size = top - base; 1028 1029 if (cnt >= (MEM_RESERVE_MAP_SIZE - 1)) 1030 prom_panic("Memory reserve map exhausted !\n"); 1031 RELOC(mem_reserve_map)[cnt].base = base; 1032 RELOC(mem_reserve_map)[cnt].size = size; 1033 RELOC(mem_reserve_cnt) = cnt + 1; 1034 } 1035 1036 /* 1037 * Initialize memory allocation mecanism, parse "memory" nodes and 1038 * obtain that way the top of memory and RMO to setup out local allocator 1039 */ 1040 static void __init prom_init_mem(void) 1041 { 1042 phandle node; 1043 char *path, type[64]; 1044 unsigned int plen; 1045 cell_t *p, *endp; 1046 struct prom_t *_prom = &RELOC(prom); 1047 u32 rac, rsc; 1048 1049 /* 1050 * We iterate the memory nodes to find 1051 * 1) top of RMO (first node) 1052 * 2) top of memory 1053 */ 1054 rac = 2; 1055 prom_getprop(_prom->root, "#address-cells", &rac, sizeof(rac)); 1056 rsc = 1; 1057 prom_getprop(_prom->root, "#size-cells", &rsc, sizeof(rsc)); 1058 prom_debug("root_addr_cells: %x\n", (unsigned long) rac); 1059 prom_debug("root_size_cells: %x\n", (unsigned long) rsc); 1060 1061 prom_debug("scanning memory:\n"); 1062 path = RELOC(prom_scratch); 1063 1064 for (node = 0; prom_next_node(&node); ) { 1065 type[0] = 0; 1066 prom_getprop(node, "device_type", type, sizeof(type)); 1067 1068 if (type[0] == 0) { 1069 /* 1070 * CHRP Longtrail machines have no device_type 1071 * on the memory node, so check the name instead... 1072 */ 1073 prom_getprop(node, "name", type, sizeof(type)); 1074 } 1075 if (strcmp(type, RELOC("memory"))) 1076 continue; 1077 1078 plen = prom_getprop(node, "reg", RELOC(regbuf), sizeof(regbuf)); 1079 if (plen > sizeof(regbuf)) { 1080 prom_printf("memory node too large for buffer !\n"); 1081 plen = sizeof(regbuf); 1082 } 1083 p = RELOC(regbuf); 1084 endp = p + (plen / sizeof(cell_t)); 1085 1086 #ifdef DEBUG_PROM 1087 memset(path, 0, PROM_SCRATCH_SIZE); 1088 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1); 1089 prom_debug(" node %s :\n", path); 1090 #endif /* DEBUG_PROM */ 1091 1092 while ((endp - p) >= (rac + rsc)) { 1093 unsigned long base, size; 1094 1095 base = prom_next_cell(rac, &p); 1096 size = prom_next_cell(rsc, &p); 1097 1098 if (size == 0) 1099 continue; 1100 prom_debug(" %x %x\n", base, size); 1101 if (base == 0 && (RELOC(of_platform) & PLATFORM_LPAR)) 1102 RELOC(rmo_top) = size; 1103 if ((base + size) > RELOC(ram_top)) 1104 RELOC(ram_top) = base + size; 1105 } 1106 } 1107 1108 RELOC(alloc_bottom) = PAGE_ALIGN((unsigned long)&RELOC(_end) + 0x4000); 1109 1110 /* Check if we have an initrd after the kernel, if we do move our bottom 1111 * point to after it 1112 */ 1113 if (RELOC(prom_initrd_start)) { 1114 if (RELOC(prom_initrd_end) > RELOC(alloc_bottom)) 1115 RELOC(alloc_bottom) = PAGE_ALIGN(RELOC(prom_initrd_end)); 1116 } 1117 1118 /* 1119 * If prom_memory_limit is set we reduce the upper limits *except* for 1120 * alloc_top_high. This must be the real top of RAM so we can put 1121 * TCE's up there. 1122 */ 1123 1124 RELOC(alloc_top_high) = RELOC(ram_top); 1125 1126 if (RELOC(prom_memory_limit)) { 1127 if (RELOC(prom_memory_limit) <= RELOC(alloc_bottom)) { 1128 prom_printf("Ignoring mem=%x <= alloc_bottom.\n", 1129 RELOC(prom_memory_limit)); 1130 RELOC(prom_memory_limit) = 0; 1131 } else if (RELOC(prom_memory_limit) >= RELOC(ram_top)) { 1132 prom_printf("Ignoring mem=%x >= ram_top.\n", 1133 RELOC(prom_memory_limit)); 1134 RELOC(prom_memory_limit) = 0; 1135 } else { 1136 RELOC(ram_top) = RELOC(prom_memory_limit); 1137 RELOC(rmo_top) = min(RELOC(rmo_top), RELOC(prom_memory_limit)); 1138 } 1139 } 1140 1141 /* 1142 * Setup our top alloc point, that is top of RMO or top of 1143 * segment 0 when running non-LPAR. 1144 * Some RS64 machines have buggy firmware where claims up at 1145 * 1GB fail. Cap at 768MB as a workaround. 1146 * Since 768MB is plenty of room, and we need to cap to something 1147 * reasonable on 32-bit, cap at 768MB on all machines. 1148 */ 1149 if (!RELOC(rmo_top)) 1150 RELOC(rmo_top) = RELOC(ram_top); 1151 RELOC(rmo_top) = min(0x30000000ul, RELOC(rmo_top)); 1152 RELOC(alloc_top) = RELOC(rmo_top); 1153 1154 prom_printf("memory layout at init:\n"); 1155 prom_printf(" memory_limit : %x (16 MB aligned)\n", RELOC(prom_memory_limit)); 1156 prom_printf(" alloc_bottom : %x\n", RELOC(alloc_bottom)); 1157 prom_printf(" alloc_top : %x\n", RELOC(alloc_top)); 1158 prom_printf(" alloc_top_hi : %x\n", RELOC(alloc_top_high)); 1159 prom_printf(" rmo_top : %x\n", RELOC(rmo_top)); 1160 prom_printf(" ram_top : %x\n", RELOC(ram_top)); 1161 #ifdef CONFIG_KEXEC 1162 if (RELOC(prom_crashk_base)) { 1163 prom_printf(" crashk_base : %x\n", RELOC(prom_crashk_base)); 1164 prom_printf(" crashk_size : %x\n", RELOC(prom_crashk_size)); 1165 } 1166 #endif 1167 } 1168 1169 1170 /* 1171 * Allocate room for and instantiate RTAS 1172 */ 1173 static void __init prom_instantiate_rtas(void) 1174 { 1175 phandle rtas_node; 1176 ihandle rtas_inst; 1177 u32 base, entry = 0; 1178 u32 size = 0; 1179 1180 prom_debug("prom_instantiate_rtas: start...\n"); 1181 1182 rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas")); 1183 prom_debug("rtas_node: %x\n", rtas_node); 1184 if (!PHANDLE_VALID(rtas_node)) 1185 return; 1186 1187 prom_getprop(rtas_node, "rtas-size", &size, sizeof(size)); 1188 if (size == 0) 1189 return; 1190 1191 base = alloc_down(size, PAGE_SIZE, 0); 1192 if (base == 0) { 1193 prom_printf("RTAS allocation failed !\n"); 1194 return; 1195 } 1196 1197 rtas_inst = call_prom("open", 1, 1, ADDR("/rtas")); 1198 if (!IHANDLE_VALID(rtas_inst)) { 1199 prom_printf("opening rtas package failed (%x)\n", rtas_inst); 1200 return; 1201 } 1202 1203 prom_printf("instantiating rtas at 0x%x ...", base); 1204 1205 if (call_prom_ret("call-method", 3, 2, &entry, 1206 ADDR("instantiate-rtas"), 1207 rtas_inst, base) != 0 1208 || entry == 0) { 1209 prom_printf(" failed\n"); 1210 return; 1211 } 1212 prom_printf(" done\n"); 1213 1214 reserve_mem(base, size); 1215 1216 prom_setprop(rtas_node, "/rtas", "linux,rtas-base", 1217 &base, sizeof(base)); 1218 prom_setprop(rtas_node, "/rtas", "linux,rtas-entry", 1219 &entry, sizeof(entry)); 1220 1221 prom_debug("rtas base = 0x%x\n", base); 1222 prom_debug("rtas entry = 0x%x\n", entry); 1223 prom_debug("rtas size = 0x%x\n", (long)size); 1224 1225 prom_debug("prom_instantiate_rtas: end...\n"); 1226 } 1227 1228 #ifdef CONFIG_PPC64 1229 /* 1230 * Allocate room for and initialize TCE tables 1231 */ 1232 static void __init prom_initialize_tce_table(void) 1233 { 1234 phandle node; 1235 ihandle phb_node; 1236 char compatible[64], type[64], model[64]; 1237 char *path = RELOC(prom_scratch); 1238 u64 base, align; 1239 u32 minalign, minsize; 1240 u64 tce_entry, *tce_entryp; 1241 u64 local_alloc_top, local_alloc_bottom; 1242 u64 i; 1243 1244 if (RELOC(ppc64_iommu_off)) 1245 return; 1246 1247 prom_debug("starting prom_initialize_tce_table\n"); 1248 1249 /* Cache current top of allocs so we reserve a single block */ 1250 local_alloc_top = RELOC(alloc_top_high); 1251 local_alloc_bottom = local_alloc_top; 1252 1253 /* Search all nodes looking for PHBs. */ 1254 for (node = 0; prom_next_node(&node); ) { 1255 compatible[0] = 0; 1256 type[0] = 0; 1257 model[0] = 0; 1258 prom_getprop(node, "compatible", 1259 compatible, sizeof(compatible)); 1260 prom_getprop(node, "device_type", type, sizeof(type)); 1261 prom_getprop(node, "model", model, sizeof(model)); 1262 1263 if ((type[0] == 0) || (strstr(type, RELOC("pci")) == NULL)) 1264 continue; 1265 1266 /* Keep the old logic in tack to avoid regression. */ 1267 if (compatible[0] != 0) { 1268 if ((strstr(compatible, RELOC("python")) == NULL) && 1269 (strstr(compatible, RELOC("Speedwagon")) == NULL) && 1270 (strstr(compatible, RELOC("Winnipeg")) == NULL)) 1271 continue; 1272 } else if (model[0] != 0) { 1273 if ((strstr(model, RELOC("ython")) == NULL) && 1274 (strstr(model, RELOC("peedwagon")) == NULL) && 1275 (strstr(model, RELOC("innipeg")) == NULL)) 1276 continue; 1277 } 1278 1279 if (prom_getprop(node, "tce-table-minalign", &minalign, 1280 sizeof(minalign)) == PROM_ERROR) 1281 minalign = 0; 1282 if (prom_getprop(node, "tce-table-minsize", &minsize, 1283 sizeof(minsize)) == PROM_ERROR) 1284 minsize = 4UL << 20; 1285 1286 /* 1287 * Even though we read what OF wants, we just set the table 1288 * size to 4 MB. This is enough to map 2GB of PCI DMA space. 1289 * By doing this, we avoid the pitfalls of trying to DMA to 1290 * MMIO space and the DMA alias hole. 1291 * 1292 * On POWER4, firmware sets the TCE region by assuming 1293 * each TCE table is 8MB. Using this memory for anything 1294 * else will impact performance, so we always allocate 8MB. 1295 * Anton 1296 */ 1297 if (__is_processor(PV_POWER4) || __is_processor(PV_POWER4p)) 1298 minsize = 8UL << 20; 1299 else 1300 minsize = 4UL << 20; 1301 1302 /* Align to the greater of the align or size */ 1303 align = max(minalign, minsize); 1304 base = alloc_down(minsize, align, 1); 1305 if (base == 0) 1306 prom_panic("ERROR, cannot find space for TCE table.\n"); 1307 if (base < local_alloc_bottom) 1308 local_alloc_bottom = base; 1309 1310 /* It seems OF doesn't null-terminate the path :-( */ 1311 memset(path, 0, sizeof(path)); 1312 /* Call OF to setup the TCE hardware */ 1313 if (call_prom("package-to-path", 3, 1, node, 1314 path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) { 1315 prom_printf("package-to-path failed\n"); 1316 } 1317 1318 /* Save away the TCE table attributes for later use. */ 1319 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base)); 1320 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize)); 1321 1322 prom_debug("TCE table: %s\n", path); 1323 prom_debug("\tnode = 0x%x\n", node); 1324 prom_debug("\tbase = 0x%x\n", base); 1325 prom_debug("\tsize = 0x%x\n", minsize); 1326 1327 /* Initialize the table to have a one-to-one mapping 1328 * over the allocated size. 1329 */ 1330 tce_entryp = (unsigned long *)base; 1331 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) { 1332 tce_entry = (i << PAGE_SHIFT); 1333 tce_entry |= 0x3; 1334 *tce_entryp = tce_entry; 1335 } 1336 1337 prom_printf("opening PHB %s", path); 1338 phb_node = call_prom("open", 1, 1, path); 1339 if (phb_node == 0) 1340 prom_printf("... failed\n"); 1341 else 1342 prom_printf("... done\n"); 1343 1344 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"), 1345 phb_node, -1, minsize, 1346 (u32) base, (u32) (base >> 32)); 1347 call_prom("close", 1, 0, phb_node); 1348 } 1349 1350 reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom); 1351 1352 if (RELOC(prom_memory_limit)) { 1353 /* 1354 * We align the start to a 16MB boundary so we can map 1355 * the TCE area using large pages if possible. 1356 * The end should be the top of RAM so no need to align it. 1357 */ 1358 RELOC(prom_tce_alloc_start) = _ALIGN_DOWN(local_alloc_bottom, 1359 0x1000000); 1360 RELOC(prom_tce_alloc_end) = local_alloc_top; 1361 } 1362 1363 /* Flag the first invalid entry */ 1364 prom_debug("ending prom_initialize_tce_table\n"); 1365 } 1366 #endif 1367 1368 /* 1369 * With CHRP SMP we need to use the OF to start the other processors. 1370 * We can't wait until smp_boot_cpus (the OF is trashed by then) 1371 * so we have to put the processors into a holding pattern controlled 1372 * by the kernel (not OF) before we destroy the OF. 1373 * 1374 * This uses a chunk of low memory, puts some holding pattern 1375 * code there and sends the other processors off to there until 1376 * smp_boot_cpus tells them to do something. The holding pattern 1377 * checks that address until its cpu # is there, when it is that 1378 * cpu jumps to __secondary_start(). smp_boot_cpus() takes care 1379 * of setting those values. 1380 * 1381 * We also use physical address 0x4 here to tell when a cpu 1382 * is in its holding pattern code. 1383 * 1384 * -- Cort 1385 */ 1386 extern void __secondary_hold(void); 1387 extern unsigned long __secondary_hold_spinloop; 1388 extern unsigned long __secondary_hold_acknowledge; 1389 1390 /* 1391 * We want to reference the copy of __secondary_hold_* in the 1392 * 0 - 0x100 address range 1393 */ 1394 #define LOW_ADDR(x) (((unsigned long) &(x)) & 0xff) 1395 1396 static void __init prom_hold_cpus(void) 1397 { 1398 unsigned long i; 1399 unsigned int reg; 1400 phandle node; 1401 char type[64]; 1402 int cpuid = 0; 1403 unsigned int interrupt_server[MAX_CPU_THREADS]; 1404 unsigned int cpu_threads, hw_cpu_num; 1405 int propsize; 1406 struct prom_t *_prom = &RELOC(prom); 1407 unsigned long *spinloop 1408 = (void *) LOW_ADDR(__secondary_hold_spinloop); 1409 unsigned long *acknowledge 1410 = (void *) LOW_ADDR(__secondary_hold_acknowledge); 1411 #ifdef CONFIG_PPC64 1412 /* __secondary_hold is actually a descriptor, not the text address */ 1413 unsigned long secondary_hold 1414 = __pa(*PTRRELOC((unsigned long *)__secondary_hold)); 1415 #else 1416 unsigned long secondary_hold = LOW_ADDR(__secondary_hold); 1417 #endif 1418 1419 prom_debug("prom_hold_cpus: start...\n"); 1420 prom_debug(" 1) spinloop = 0x%x\n", (unsigned long)spinloop); 1421 prom_debug(" 1) *spinloop = 0x%x\n", *spinloop); 1422 prom_debug(" 1) acknowledge = 0x%x\n", 1423 (unsigned long)acknowledge); 1424 prom_debug(" 1) *acknowledge = 0x%x\n", *acknowledge); 1425 prom_debug(" 1) secondary_hold = 0x%x\n", secondary_hold); 1426 1427 /* Set the common spinloop variable, so all of the secondary cpus 1428 * will block when they are awakened from their OF spinloop. 1429 * This must occur for both SMP and non SMP kernels, since OF will 1430 * be trashed when we move the kernel. 1431 */ 1432 *spinloop = 0; 1433 1434 /* look for cpus */ 1435 for (node = 0; prom_next_node(&node); ) { 1436 type[0] = 0; 1437 prom_getprop(node, "device_type", type, sizeof(type)); 1438 if (strcmp(type, RELOC("cpu")) != 0) 1439 continue; 1440 1441 /* Skip non-configured cpus. */ 1442 if (prom_getprop(node, "status", type, sizeof(type)) > 0) 1443 if (strcmp(type, RELOC("okay")) != 0) 1444 continue; 1445 1446 reg = -1; 1447 prom_getprop(node, "reg", ®, sizeof(reg)); 1448 1449 prom_debug("\ncpuid = 0x%x\n", cpuid); 1450 prom_debug("cpu hw idx = 0x%x\n", reg); 1451 1452 /* Init the acknowledge var which will be reset by 1453 * the secondary cpu when it awakens from its OF 1454 * spinloop. 1455 */ 1456 *acknowledge = (unsigned long)-1; 1457 1458 propsize = prom_getprop(node, "ibm,ppc-interrupt-server#s", 1459 &interrupt_server, 1460 sizeof(interrupt_server)); 1461 if (propsize < 0) { 1462 /* no property. old hardware has no SMT */ 1463 cpu_threads = 1; 1464 interrupt_server[0] = reg; /* fake it with phys id */ 1465 } else { 1466 /* We have a threaded processor */ 1467 cpu_threads = propsize / sizeof(u32); 1468 if (cpu_threads > MAX_CPU_THREADS) { 1469 prom_printf("SMT: too many threads!\n" 1470 "SMT: found %x, max is %x\n", 1471 cpu_threads, MAX_CPU_THREADS); 1472 cpu_threads = 1; /* ToDo: panic? */ 1473 } 1474 } 1475 1476 hw_cpu_num = interrupt_server[0]; 1477 if (hw_cpu_num != _prom->cpu) { 1478 /* Primary Thread of non-boot cpu */ 1479 prom_printf("%x : starting cpu hw idx %x... ", cpuid, reg); 1480 call_prom("start-cpu", 3, 0, node, 1481 secondary_hold, reg); 1482 1483 for (i = 0; (i < 100000000) && 1484 (*acknowledge == ((unsigned long)-1)); i++ ) 1485 mb(); 1486 1487 if (*acknowledge == reg) 1488 prom_printf("done\n"); 1489 else 1490 prom_printf("failed: %x\n", *acknowledge); 1491 } 1492 #ifdef CONFIG_SMP 1493 else 1494 prom_printf("%x : boot cpu %x\n", cpuid, reg); 1495 #endif /* CONFIG_SMP */ 1496 1497 /* Reserve cpu #s for secondary threads. They start later. */ 1498 cpuid += cpu_threads; 1499 } 1500 1501 if (cpuid > NR_CPUS) 1502 prom_printf("WARNING: maximum CPUs (" __stringify(NR_CPUS) 1503 ") exceeded: ignoring extras\n"); 1504 1505 prom_debug("prom_hold_cpus: end...\n"); 1506 } 1507 1508 1509 static void __init prom_init_client_services(unsigned long pp) 1510 { 1511 struct prom_t *_prom = &RELOC(prom); 1512 1513 /* Get a handle to the prom entry point before anything else */ 1514 RELOC(prom_entry) = pp; 1515 1516 /* get a handle for the stdout device */ 1517 _prom->chosen = call_prom("finddevice", 1, 1, ADDR("/chosen")); 1518 if (!PHANDLE_VALID(_prom->chosen)) 1519 prom_panic("cannot find chosen"); /* msg won't be printed :( */ 1520 1521 /* get device tree root */ 1522 _prom->root = call_prom("finddevice", 1, 1, ADDR("/")); 1523 if (!PHANDLE_VALID(_prom->root)) 1524 prom_panic("cannot find device tree root"); /* msg won't be printed :( */ 1525 1526 _prom->mmumap = 0; 1527 } 1528 1529 #ifdef CONFIG_PPC32 1530 /* 1531 * For really old powermacs, we need to map things we claim. 1532 * For that, we need the ihandle of the mmu. 1533 * Also, on the longtrail, we need to work around other bugs. 1534 */ 1535 static void __init prom_find_mmu(void) 1536 { 1537 struct prom_t *_prom = &RELOC(prom); 1538 phandle oprom; 1539 char version[64]; 1540 1541 oprom = call_prom("finddevice", 1, 1, ADDR("/openprom")); 1542 if (!PHANDLE_VALID(oprom)) 1543 return; 1544 if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0) 1545 return; 1546 version[sizeof(version) - 1] = 0; 1547 /* XXX might need to add other versions here */ 1548 if (strcmp(version, "Open Firmware, 1.0.5") == 0) 1549 of_workarounds = OF_WA_CLAIM; 1550 else if (strncmp(version, "FirmWorks,3.", 12) == 0) { 1551 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL; 1552 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim"); 1553 } else 1554 return; 1555 _prom->memory = call_prom("open", 1, 1, ADDR("/memory")); 1556 prom_getprop(_prom->chosen, "mmu", &_prom->mmumap, 1557 sizeof(_prom->mmumap)); 1558 if (!IHANDLE_VALID(_prom->memory) || !IHANDLE_VALID(_prom->mmumap)) 1559 of_workarounds &= ~OF_WA_CLAIM; /* hmmm */ 1560 } 1561 #else 1562 #define prom_find_mmu() 1563 #endif 1564 1565 static void __init prom_init_stdout(void) 1566 { 1567 struct prom_t *_prom = &RELOC(prom); 1568 char *path = RELOC(of_stdout_device); 1569 char type[16]; 1570 u32 val; 1571 1572 if (prom_getprop(_prom->chosen, "stdout", &val, sizeof(val)) <= 0) 1573 prom_panic("cannot find stdout"); 1574 1575 _prom->stdout = val; 1576 1577 /* Get the full OF pathname of the stdout device */ 1578 memset(path, 0, 256); 1579 call_prom("instance-to-path", 3, 1, _prom->stdout, path, 255); 1580 val = call_prom("instance-to-package", 1, 1, _prom->stdout); 1581 prom_setprop(_prom->chosen, "/chosen", "linux,stdout-package", 1582 &val, sizeof(val)); 1583 prom_printf("OF stdout device is: %s\n", RELOC(of_stdout_device)); 1584 prom_setprop(_prom->chosen, "/chosen", "linux,stdout-path", 1585 path, strlen(path) + 1); 1586 1587 /* If it's a display, note it */ 1588 memset(type, 0, sizeof(type)); 1589 prom_getprop(val, "device_type", type, sizeof(type)); 1590 if (strcmp(type, RELOC("display")) == 0) 1591 prom_setprop(val, path, "linux,boot-display", NULL, 0); 1592 } 1593 1594 static void __init prom_close_stdin(void) 1595 { 1596 struct prom_t *_prom = &RELOC(prom); 1597 ihandle val; 1598 1599 if (prom_getprop(_prom->chosen, "stdin", &val, sizeof(val)) > 0) 1600 call_prom("close", 1, 0, val); 1601 } 1602 1603 static int __init prom_find_machine_type(void) 1604 { 1605 struct prom_t *_prom = &RELOC(prom); 1606 char compat[256]; 1607 int len, i = 0; 1608 #ifdef CONFIG_PPC64 1609 phandle rtas; 1610 int x; 1611 #endif 1612 1613 /* Look for a PowerMac */ 1614 len = prom_getprop(_prom->root, "compatible", 1615 compat, sizeof(compat)-1); 1616 if (len > 0) { 1617 compat[len] = 0; 1618 while (i < len) { 1619 char *p = &compat[i]; 1620 int sl = strlen(p); 1621 if (sl == 0) 1622 break; 1623 if (strstr(p, RELOC("Power Macintosh")) || 1624 strstr(p, RELOC("MacRISC"))) 1625 return PLATFORM_POWERMAC; 1626 #ifdef CONFIG_PPC64 1627 /* We must make sure we don't detect the IBM Cell 1628 * blades as pSeries due to some firmware issues, 1629 * so we do it here. 1630 */ 1631 if (strstr(p, RELOC("IBM,CBEA")) || 1632 strstr(p, RELOC("IBM,CPBW-1.0"))) 1633 return PLATFORM_GENERIC; 1634 #endif /* CONFIG_PPC64 */ 1635 i += sl + 1; 1636 } 1637 } 1638 #ifdef CONFIG_PPC64 1639 /* If not a mac, try to figure out if it's an IBM pSeries or any other 1640 * PAPR compliant platform. We assume it is if : 1641 * - /device_type is "chrp" (please, do NOT use that for future 1642 * non-IBM designs ! 1643 * - it has /rtas 1644 */ 1645 len = prom_getprop(_prom->root, "device_type", 1646 compat, sizeof(compat)-1); 1647 if (len <= 0) 1648 return PLATFORM_GENERIC; 1649 if (strcmp(compat, RELOC("chrp"))) 1650 return PLATFORM_GENERIC; 1651 1652 /* Default to pSeries. We need to know if we are running LPAR */ 1653 rtas = call_prom("finddevice", 1, 1, ADDR("/rtas")); 1654 if (!PHANDLE_VALID(rtas)) 1655 return PLATFORM_GENERIC; 1656 x = prom_getproplen(rtas, "ibm,hypertas-functions"); 1657 if (x != PROM_ERROR) { 1658 prom_printf("Hypertas detected, assuming LPAR !\n"); 1659 return PLATFORM_PSERIES_LPAR; 1660 } 1661 return PLATFORM_PSERIES; 1662 #else 1663 return PLATFORM_GENERIC; 1664 #endif 1665 } 1666 1667 static int __init prom_set_color(ihandle ih, int i, int r, int g, int b) 1668 { 1669 return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r); 1670 } 1671 1672 /* 1673 * If we have a display that we don't know how to drive, 1674 * we will want to try to execute OF's open method for it 1675 * later. However, OF will probably fall over if we do that 1676 * we've taken over the MMU. 1677 * So we check whether we will need to open the display, 1678 * and if so, open it now. 1679 */ 1680 static void __init prom_check_displays(void) 1681 { 1682 char type[16], *path; 1683 phandle node; 1684 ihandle ih; 1685 int i; 1686 1687 static unsigned char default_colors[] = { 1688 0x00, 0x00, 0x00, 1689 0x00, 0x00, 0xaa, 1690 0x00, 0xaa, 0x00, 1691 0x00, 0xaa, 0xaa, 1692 0xaa, 0x00, 0x00, 1693 0xaa, 0x00, 0xaa, 1694 0xaa, 0xaa, 0x00, 1695 0xaa, 0xaa, 0xaa, 1696 0x55, 0x55, 0x55, 1697 0x55, 0x55, 0xff, 1698 0x55, 0xff, 0x55, 1699 0x55, 0xff, 0xff, 1700 0xff, 0x55, 0x55, 1701 0xff, 0x55, 0xff, 1702 0xff, 0xff, 0x55, 1703 0xff, 0xff, 0xff 1704 }; 1705 const unsigned char *clut; 1706 1707 prom_printf("Looking for displays\n"); 1708 for (node = 0; prom_next_node(&node); ) { 1709 memset(type, 0, sizeof(type)); 1710 prom_getprop(node, "device_type", type, sizeof(type)); 1711 if (strcmp(type, RELOC("display")) != 0) 1712 continue; 1713 1714 /* It seems OF doesn't null-terminate the path :-( */ 1715 path = RELOC(prom_scratch); 1716 memset(path, 0, PROM_SCRATCH_SIZE); 1717 1718 /* 1719 * leave some room at the end of the path for appending extra 1720 * arguments 1721 */ 1722 if (call_prom("package-to-path", 3, 1, node, path, 1723 PROM_SCRATCH_SIZE-10) == PROM_ERROR) 1724 continue; 1725 prom_printf("found display : %s, opening ... ", path); 1726 1727 ih = call_prom("open", 1, 1, path); 1728 if (ih == 0) { 1729 prom_printf("failed\n"); 1730 continue; 1731 } 1732 1733 /* Success */ 1734 prom_printf("done\n"); 1735 prom_setprop(node, path, "linux,opened", NULL, 0); 1736 1737 /* Setup a usable color table when the appropriate 1738 * method is available. Should update this to set-colors */ 1739 clut = RELOC(default_colors); 1740 for (i = 0; i < 32; i++, clut += 3) 1741 if (prom_set_color(ih, i, clut[0], clut[1], 1742 clut[2]) != 0) 1743 break; 1744 1745 #ifdef CONFIG_LOGO_LINUX_CLUT224 1746 clut = PTRRELOC(RELOC(logo_linux_clut224.clut)); 1747 for (i = 0; i < RELOC(logo_linux_clut224.clutsize); i++, clut += 3) 1748 if (prom_set_color(ih, i + 32, clut[0], clut[1], 1749 clut[2]) != 0) 1750 break; 1751 #endif /* CONFIG_LOGO_LINUX_CLUT224 */ 1752 } 1753 } 1754 1755 1756 /* Return (relocated) pointer to this much memory: moves initrd if reqd. */ 1757 static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end, 1758 unsigned long needed, unsigned long align) 1759 { 1760 void *ret; 1761 1762 *mem_start = _ALIGN(*mem_start, align); 1763 while ((*mem_start + needed) > *mem_end) { 1764 unsigned long room, chunk; 1765 1766 prom_debug("Chunk exhausted, claiming more at %x...\n", 1767 RELOC(alloc_bottom)); 1768 room = RELOC(alloc_top) - RELOC(alloc_bottom); 1769 if (room > DEVTREE_CHUNK_SIZE) 1770 room = DEVTREE_CHUNK_SIZE; 1771 if (room < PAGE_SIZE) 1772 prom_panic("No memory for flatten_device_tree (no room)"); 1773 chunk = alloc_up(room, 0); 1774 if (chunk == 0) 1775 prom_panic("No memory for flatten_device_tree (claim failed)"); 1776 *mem_end = RELOC(alloc_top); 1777 } 1778 1779 ret = (void *)*mem_start; 1780 *mem_start += needed; 1781 1782 return ret; 1783 } 1784 1785 #define dt_push_token(token, mem_start, mem_end) \ 1786 do { *((u32 *)make_room(mem_start, mem_end, 4, 4)) = token; } while(0) 1787 1788 static unsigned long __init dt_find_string(char *str) 1789 { 1790 char *s, *os; 1791 1792 s = os = (char *)RELOC(dt_string_start); 1793 s += 4; 1794 while (s < (char *)RELOC(dt_string_end)) { 1795 if (strcmp(s, str) == 0) 1796 return s - os; 1797 s += strlen(s) + 1; 1798 } 1799 return 0; 1800 } 1801 1802 /* 1803 * The Open Firmware 1275 specification states properties must be 31 bytes or 1804 * less, however not all firmwares obey this. Make it 64 bytes to be safe. 1805 */ 1806 #define MAX_PROPERTY_NAME 64 1807 1808 static void __init scan_dt_build_strings(phandle node, 1809 unsigned long *mem_start, 1810 unsigned long *mem_end) 1811 { 1812 char *prev_name, *namep, *sstart; 1813 unsigned long soff; 1814 phandle child; 1815 1816 sstart = (char *)RELOC(dt_string_start); 1817 1818 /* get and store all property names */ 1819 prev_name = RELOC(""); 1820 for (;;) { 1821 /* 64 is max len of name including nul. */ 1822 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1); 1823 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) { 1824 /* No more nodes: unwind alloc */ 1825 *mem_start = (unsigned long)namep; 1826 break; 1827 } 1828 1829 /* skip "name" */ 1830 if (strcmp(namep, RELOC("name")) == 0) { 1831 *mem_start = (unsigned long)namep; 1832 prev_name = RELOC("name"); 1833 continue; 1834 } 1835 /* get/create string entry */ 1836 soff = dt_find_string(namep); 1837 if (soff != 0) { 1838 *mem_start = (unsigned long)namep; 1839 namep = sstart + soff; 1840 } else { 1841 /* Trim off some if we can */ 1842 *mem_start = (unsigned long)namep + strlen(namep) + 1; 1843 RELOC(dt_string_end) = *mem_start; 1844 } 1845 prev_name = namep; 1846 } 1847 1848 /* do all our children */ 1849 child = call_prom("child", 1, 1, node); 1850 while (child != 0) { 1851 scan_dt_build_strings(child, mem_start, mem_end); 1852 child = call_prom("peer", 1, 1, child); 1853 } 1854 } 1855 1856 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start, 1857 unsigned long *mem_end) 1858 { 1859 phandle child; 1860 char *namep, *prev_name, *sstart, *p, *ep, *lp, *path; 1861 unsigned long soff; 1862 unsigned char *valp; 1863 static char pname[MAX_PROPERTY_NAME]; 1864 int l, room; 1865 1866 dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end); 1867 1868 /* get the node's full name */ 1869 namep = (char *)*mem_start; 1870 room = *mem_end - *mem_start; 1871 if (room > 255) 1872 room = 255; 1873 l = call_prom("package-to-path", 3, 1, node, namep, room); 1874 if (l >= 0) { 1875 /* Didn't fit? Get more room. */ 1876 if (l >= room) { 1877 if (l >= *mem_end - *mem_start) 1878 namep = make_room(mem_start, mem_end, l+1, 1); 1879 call_prom("package-to-path", 3, 1, node, namep, l); 1880 } 1881 namep[l] = '\0'; 1882 1883 /* Fixup an Apple bug where they have bogus \0 chars in the 1884 * middle of the path in some properties, and extract 1885 * the unit name (everything after the last '/'). 1886 */ 1887 for (lp = p = namep, ep = namep + l; p < ep; p++) { 1888 if (*p == '/') 1889 lp = namep; 1890 else if (*p != 0) 1891 *lp++ = *p; 1892 } 1893 *lp = 0; 1894 *mem_start = _ALIGN((unsigned long)lp + 1, 4); 1895 } 1896 1897 /* get it again for debugging */ 1898 path = RELOC(prom_scratch); 1899 memset(path, 0, PROM_SCRATCH_SIZE); 1900 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1); 1901 1902 /* get and store all properties */ 1903 prev_name = RELOC(""); 1904 sstart = (char *)RELOC(dt_string_start); 1905 for (;;) { 1906 if (call_prom("nextprop", 3, 1, node, prev_name, 1907 RELOC(pname)) != 1) 1908 break; 1909 1910 /* skip "name" */ 1911 if (strcmp(RELOC(pname), RELOC("name")) == 0) { 1912 prev_name = RELOC("name"); 1913 continue; 1914 } 1915 1916 /* find string offset */ 1917 soff = dt_find_string(RELOC(pname)); 1918 if (soff == 0) { 1919 prom_printf("WARNING: Can't find string index for" 1920 " <%s>, node %s\n", RELOC(pname), path); 1921 break; 1922 } 1923 prev_name = sstart + soff; 1924 1925 /* get length */ 1926 l = call_prom("getproplen", 2, 1, node, RELOC(pname)); 1927 1928 /* sanity checks */ 1929 if (l == PROM_ERROR) 1930 continue; 1931 if (l > MAX_PROPERTY_LENGTH) { 1932 prom_printf("WARNING: ignoring large property "); 1933 /* It seems OF doesn't null-terminate the path :-( */ 1934 prom_printf("[%s] ", path); 1935 prom_printf("%s length 0x%x\n", RELOC(pname), l); 1936 continue; 1937 } 1938 1939 /* push property head */ 1940 dt_push_token(OF_DT_PROP, mem_start, mem_end); 1941 dt_push_token(l, mem_start, mem_end); 1942 dt_push_token(soff, mem_start, mem_end); 1943 1944 /* push property content */ 1945 valp = make_room(mem_start, mem_end, l, 4); 1946 call_prom("getprop", 4, 1, node, RELOC(pname), valp, l); 1947 *mem_start = _ALIGN(*mem_start, 4); 1948 } 1949 1950 /* Add a "linux,phandle" property. */ 1951 soff = dt_find_string(RELOC("linux,phandle")); 1952 if (soff == 0) 1953 prom_printf("WARNING: Can't find string index for" 1954 " <linux-phandle> node %s\n", path); 1955 else { 1956 dt_push_token(OF_DT_PROP, mem_start, mem_end); 1957 dt_push_token(4, mem_start, mem_end); 1958 dt_push_token(soff, mem_start, mem_end); 1959 valp = make_room(mem_start, mem_end, 4, 4); 1960 *(u32 *)valp = node; 1961 } 1962 1963 /* do all our children */ 1964 child = call_prom("child", 1, 1, node); 1965 while (child != 0) { 1966 scan_dt_build_struct(child, mem_start, mem_end); 1967 child = call_prom("peer", 1, 1, child); 1968 } 1969 1970 dt_push_token(OF_DT_END_NODE, mem_start, mem_end); 1971 } 1972 1973 static void __init flatten_device_tree(void) 1974 { 1975 phandle root; 1976 unsigned long mem_start, mem_end, room; 1977 struct boot_param_header *hdr; 1978 struct prom_t *_prom = &RELOC(prom); 1979 char *namep; 1980 u64 *rsvmap; 1981 1982 /* 1983 * Check how much room we have between alloc top & bottom (+/- a 1984 * few pages), crop to 4Mb, as this is our "chuck" size 1985 */ 1986 room = RELOC(alloc_top) - RELOC(alloc_bottom) - 0x4000; 1987 if (room > DEVTREE_CHUNK_SIZE) 1988 room = DEVTREE_CHUNK_SIZE; 1989 prom_debug("starting device tree allocs at %x\n", RELOC(alloc_bottom)); 1990 1991 /* Now try to claim that */ 1992 mem_start = (unsigned long)alloc_up(room, PAGE_SIZE); 1993 if (mem_start == 0) 1994 prom_panic("Can't allocate initial device-tree chunk\n"); 1995 mem_end = RELOC(alloc_top); 1996 1997 /* Get root of tree */ 1998 root = call_prom("peer", 1, 1, (phandle)0); 1999 if (root == (phandle)0) 2000 prom_panic ("couldn't get device tree root\n"); 2001 2002 /* Build header and make room for mem rsv map */ 2003 mem_start = _ALIGN(mem_start, 4); 2004 hdr = make_room(&mem_start, &mem_end, 2005 sizeof(struct boot_param_header), 4); 2006 RELOC(dt_header_start) = (unsigned long)hdr; 2007 rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8); 2008 2009 /* Start of strings */ 2010 mem_start = PAGE_ALIGN(mem_start); 2011 RELOC(dt_string_start) = mem_start; 2012 mem_start += 4; /* hole */ 2013 2014 /* Add "linux,phandle" in there, we'll need it */ 2015 namep = make_room(&mem_start, &mem_end, 16, 1); 2016 strcpy(namep, RELOC("linux,phandle")); 2017 mem_start = (unsigned long)namep + strlen(namep) + 1; 2018 2019 /* Build string array */ 2020 prom_printf("Building dt strings...\n"); 2021 scan_dt_build_strings(root, &mem_start, &mem_end); 2022 RELOC(dt_string_end) = mem_start; 2023 2024 /* Build structure */ 2025 mem_start = PAGE_ALIGN(mem_start); 2026 RELOC(dt_struct_start) = mem_start; 2027 prom_printf("Building dt structure...\n"); 2028 scan_dt_build_struct(root, &mem_start, &mem_end); 2029 dt_push_token(OF_DT_END, &mem_start, &mem_end); 2030 RELOC(dt_struct_end) = PAGE_ALIGN(mem_start); 2031 2032 /* Finish header */ 2033 hdr->boot_cpuid_phys = _prom->cpu; 2034 hdr->magic = OF_DT_HEADER; 2035 hdr->totalsize = RELOC(dt_struct_end) - RELOC(dt_header_start); 2036 hdr->off_dt_struct = RELOC(dt_struct_start) - RELOC(dt_header_start); 2037 hdr->off_dt_strings = RELOC(dt_string_start) - RELOC(dt_header_start); 2038 hdr->dt_strings_size = RELOC(dt_string_end) - RELOC(dt_string_start); 2039 hdr->off_mem_rsvmap = ((unsigned long)rsvmap) - RELOC(dt_header_start); 2040 hdr->version = OF_DT_VERSION; 2041 /* Version 16 is not backward compatible */ 2042 hdr->last_comp_version = 0x10; 2043 2044 /* Reserve the whole thing and copy the reserve map in, we 2045 * also bump mem_reserve_cnt to cause further reservations to 2046 * fail since it's too late. 2047 */ 2048 reserve_mem(RELOC(dt_header_start), hdr->totalsize); 2049 memcpy(rsvmap, RELOC(mem_reserve_map), sizeof(mem_reserve_map)); 2050 2051 #ifdef DEBUG_PROM 2052 { 2053 int i; 2054 prom_printf("reserved memory map:\n"); 2055 for (i = 0; i < RELOC(mem_reserve_cnt); i++) 2056 prom_printf(" %x - %x\n", 2057 RELOC(mem_reserve_map)[i].base, 2058 RELOC(mem_reserve_map)[i].size); 2059 } 2060 #endif 2061 RELOC(mem_reserve_cnt) = MEM_RESERVE_MAP_SIZE; 2062 2063 prom_printf("Device tree strings 0x%x -> 0x%x\n", 2064 RELOC(dt_string_start), RELOC(dt_string_end)); 2065 prom_printf("Device tree struct 0x%x -> 0x%x\n", 2066 RELOC(dt_struct_start), RELOC(dt_struct_end)); 2067 2068 } 2069 2070 #ifdef CONFIG_PPC_MAPLE 2071 /* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property. 2072 * The values are bad, and it doesn't even have the right number of cells. */ 2073 static void __init fixup_device_tree_maple(void) 2074 { 2075 phandle isa; 2076 u32 isa_ranges[6]; 2077 2078 isa = call_prom("finddevice", 1, 1, ADDR("/ht@0/isa@4")); 2079 if (!PHANDLE_VALID(isa)) 2080 return; 2081 2082 if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges)) 2083 == PROM_ERROR) 2084 return; 2085 2086 if (isa_ranges[0] != 0x1 || 2087 isa_ranges[1] != 0xf4000000 || 2088 isa_ranges[2] != 0x00010000) 2089 return; 2090 2091 prom_printf("fixing up bogus ISA range on Maple...\n"); 2092 2093 isa_ranges[0] = 0x1; 2094 isa_ranges[1] = 0x0; 2095 isa_ranges[2] = 0x01002000; /* IO space; PCI device = 4 */ 2096 isa_ranges[3] = 0x0; 2097 isa_ranges[4] = 0x0; 2098 isa_ranges[5] = 0x00010000; 2099 prom_setprop(isa, "/ht@0/isa@4", "ranges", 2100 isa_ranges, sizeof(isa_ranges)); 2101 } 2102 #else 2103 #define fixup_device_tree_maple() 2104 #endif 2105 2106 #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC) 2107 static void __init fixup_device_tree_pmac(void) 2108 { 2109 phandle u3, i2c, mpic; 2110 u32 u3_rev; 2111 u32 interrupts[2]; 2112 u32 parent; 2113 2114 /* Some G5s have a missing interrupt definition, fix it up here */ 2115 u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000")); 2116 if (!PHANDLE_VALID(u3)) 2117 return; 2118 i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000")); 2119 if (!PHANDLE_VALID(i2c)) 2120 return; 2121 mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000")); 2122 if (!PHANDLE_VALID(mpic)) 2123 return; 2124 2125 /* check if proper rev of u3 */ 2126 if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev)) 2127 == PROM_ERROR) 2128 return; 2129 if (u3_rev < 0x35 || u3_rev > 0x39) 2130 return; 2131 /* does it need fixup ? */ 2132 if (prom_getproplen(i2c, "interrupts") > 0) 2133 return; 2134 2135 prom_printf("fixing up bogus interrupts for u3 i2c...\n"); 2136 2137 /* interrupt on this revision of u3 is number 0 and level */ 2138 interrupts[0] = 0; 2139 interrupts[1] = 1; 2140 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts", 2141 &interrupts, sizeof(interrupts)); 2142 parent = (u32)mpic; 2143 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent", 2144 &parent, sizeof(parent)); 2145 } 2146 #else 2147 #define fixup_device_tree_pmac() 2148 #endif 2149 2150 static void __init fixup_device_tree(void) 2151 { 2152 fixup_device_tree_maple(); 2153 fixup_device_tree_pmac(); 2154 } 2155 2156 static void __init prom_find_boot_cpu(void) 2157 { 2158 struct prom_t *_prom = &RELOC(prom); 2159 u32 getprop_rval; 2160 ihandle prom_cpu; 2161 phandle cpu_pkg; 2162 2163 _prom->cpu = 0; 2164 if (prom_getprop(_prom->chosen, "cpu", &prom_cpu, sizeof(prom_cpu)) <= 0) 2165 return; 2166 2167 cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu); 2168 2169 prom_getprop(cpu_pkg, "reg", &getprop_rval, sizeof(getprop_rval)); 2170 _prom->cpu = getprop_rval; 2171 2172 prom_debug("Booting CPU hw index = 0x%x\n", _prom->cpu); 2173 } 2174 2175 static void __init prom_check_initrd(unsigned long r3, unsigned long r4) 2176 { 2177 #ifdef CONFIG_BLK_DEV_INITRD 2178 struct prom_t *_prom = &RELOC(prom); 2179 2180 if (r3 && r4 && r4 != 0xdeadbeef) { 2181 unsigned long val; 2182 2183 RELOC(prom_initrd_start) = is_kernel_addr(r3) ? __pa(r3) : r3; 2184 RELOC(prom_initrd_end) = RELOC(prom_initrd_start) + r4; 2185 2186 val = RELOC(prom_initrd_start); 2187 prom_setprop(_prom->chosen, "/chosen", "linux,initrd-start", 2188 &val, sizeof(val)); 2189 val = RELOC(prom_initrd_end); 2190 prom_setprop(_prom->chosen, "/chosen", "linux,initrd-end", 2191 &val, sizeof(val)); 2192 2193 reserve_mem(RELOC(prom_initrd_start), 2194 RELOC(prom_initrd_end) - RELOC(prom_initrd_start)); 2195 2196 prom_debug("initrd_start=0x%x\n", RELOC(prom_initrd_start)); 2197 prom_debug("initrd_end=0x%x\n", RELOC(prom_initrd_end)); 2198 } 2199 #endif /* CONFIG_BLK_DEV_INITRD */ 2200 } 2201 2202 /* 2203 * We enter here early on, when the Open Firmware prom is still 2204 * handling exceptions and the MMU hash table for us. 2205 */ 2206 2207 unsigned long __init prom_init(unsigned long r3, unsigned long r4, 2208 unsigned long pp, 2209 unsigned long r6, unsigned long r7) 2210 { 2211 struct prom_t *_prom; 2212 unsigned long hdr; 2213 unsigned long offset = reloc_offset(); 2214 2215 #ifdef CONFIG_PPC32 2216 reloc_got2(offset); 2217 #endif 2218 2219 _prom = &RELOC(prom); 2220 2221 /* 2222 * First zero the BSS 2223 */ 2224 memset(&RELOC(__bss_start), 0, __bss_stop - __bss_start); 2225 2226 /* 2227 * Init interface to Open Firmware, get some node references, 2228 * like /chosen 2229 */ 2230 prom_init_client_services(pp); 2231 2232 /* 2233 * See if this OF is old enough that we need to do explicit maps 2234 * and other workarounds 2235 */ 2236 prom_find_mmu(); 2237 2238 /* 2239 * Init prom stdout device 2240 */ 2241 prom_init_stdout(); 2242 2243 /* 2244 * Get default machine type. At this point, we do not differentiate 2245 * between pSeries SMP and pSeries LPAR 2246 */ 2247 RELOC(of_platform) = prom_find_machine_type(); 2248 2249 /* Bail if this is a kdump kernel. */ 2250 if (PHYSICAL_START > 0) 2251 prom_panic("Error: You can't boot a kdump kernel from OF!\n"); 2252 2253 /* 2254 * Check for an initrd 2255 */ 2256 prom_check_initrd(r3, r4); 2257 2258 #ifdef CONFIG_PPC_PSERIES 2259 /* 2260 * On pSeries, inform the firmware about our capabilities 2261 */ 2262 if (RELOC(of_platform) == PLATFORM_PSERIES || 2263 RELOC(of_platform) == PLATFORM_PSERIES_LPAR) 2264 prom_send_capabilities(); 2265 #endif 2266 2267 /* 2268 * Copy the CPU hold code 2269 */ 2270 if (RELOC(of_platform) != PLATFORM_POWERMAC) 2271 copy_and_flush(0, KERNELBASE + offset, 0x100, 0); 2272 2273 /* 2274 * Do early parsing of command line 2275 */ 2276 early_cmdline_parse(); 2277 2278 /* 2279 * Initialize memory management within prom_init 2280 */ 2281 prom_init_mem(); 2282 2283 #ifdef CONFIG_KEXEC 2284 if (RELOC(prom_crashk_base)) 2285 reserve_mem(RELOC(prom_crashk_base), RELOC(prom_crashk_size)); 2286 #endif 2287 /* 2288 * Determine which cpu is actually running right _now_ 2289 */ 2290 prom_find_boot_cpu(); 2291 2292 /* 2293 * Initialize display devices 2294 */ 2295 prom_check_displays(); 2296 2297 #ifdef CONFIG_PPC64 2298 /* 2299 * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else 2300 * that uses the allocator, we need to make sure we get the top of memory 2301 * available for us here... 2302 */ 2303 if (RELOC(of_platform) == PLATFORM_PSERIES) 2304 prom_initialize_tce_table(); 2305 #endif 2306 2307 /* 2308 * On non-powermacs, try to instantiate RTAS and puts all CPUs 2309 * in spin-loops. PowerMacs don't have a working RTAS and use 2310 * a different way to spin CPUs 2311 */ 2312 if (RELOC(of_platform) != PLATFORM_POWERMAC) { 2313 prom_instantiate_rtas(); 2314 prom_hold_cpus(); 2315 } 2316 2317 /* 2318 * Fill in some infos for use by the kernel later on 2319 */ 2320 if (RELOC(prom_memory_limit)) 2321 prom_setprop(_prom->chosen, "/chosen", "linux,memory-limit", 2322 &RELOC(prom_memory_limit), 2323 sizeof(prom_memory_limit)); 2324 #ifdef CONFIG_PPC64 2325 if (RELOC(ppc64_iommu_off)) 2326 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-off", 2327 NULL, 0); 2328 2329 if (RELOC(iommu_force_on)) 2330 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-force-on", 2331 NULL, 0); 2332 2333 if (RELOC(prom_tce_alloc_start)) { 2334 prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-start", 2335 &RELOC(prom_tce_alloc_start), 2336 sizeof(prom_tce_alloc_start)); 2337 prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-end", 2338 &RELOC(prom_tce_alloc_end), 2339 sizeof(prom_tce_alloc_end)); 2340 } 2341 #endif 2342 2343 #ifdef CONFIG_KEXEC 2344 if (RELOC(prom_crashk_base)) { 2345 prom_setprop(_prom->chosen, "/chosen", "linux,crashkernel-base", 2346 PTRRELOC(&prom_crashk_base), 2347 sizeof(RELOC(prom_crashk_base))); 2348 prom_setprop(_prom->chosen, "/chosen", "linux,crashkernel-size", 2349 PTRRELOC(&prom_crashk_size), 2350 sizeof(RELOC(prom_crashk_size))); 2351 } 2352 #endif 2353 /* 2354 * Fixup any known bugs in the device-tree 2355 */ 2356 fixup_device_tree(); 2357 2358 /* 2359 * Now finally create the flattened device-tree 2360 */ 2361 prom_printf("copying OF device tree ...\n"); 2362 flatten_device_tree(); 2363 2364 /* 2365 * in case stdin is USB and still active on IBM machines... 2366 * Unfortunately quiesce crashes on some powermacs if we have 2367 * closed stdin already (in particular the powerbook 101). 2368 */ 2369 if (RELOC(of_platform) != PLATFORM_POWERMAC) 2370 prom_close_stdin(); 2371 2372 /* 2373 * Call OF "quiesce" method to shut down pending DMA's from 2374 * devices etc... 2375 */ 2376 prom_printf("Calling quiesce ...\n"); 2377 call_prom("quiesce", 0, 0); 2378 2379 /* 2380 * And finally, call the kernel passing it the flattened device 2381 * tree and NULL as r5, thus triggering the new entry point which 2382 * is common to us and kexec 2383 */ 2384 hdr = RELOC(dt_header_start); 2385 prom_printf("returning from prom_init\n"); 2386 prom_debug("->dt_header_start=0x%x\n", hdr); 2387 2388 #ifdef CONFIG_PPC32 2389 reloc_got2(-offset); 2390 #endif 2391 2392 __start(hdr, KERNELBASE + offset, 0); 2393 2394 return 0; 2395 } 2396