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 * To tell the firmware what our capabilities are, we have to pass 640 * it a fake 32-bit ELF header containing a couple of PT_NOTE sections 641 * that contain structures that contain the actual values. 642 */ 643 static struct fake_elf { 644 Elf32_Ehdr elfhdr; 645 Elf32_Phdr phdr[2]; 646 struct chrpnote { 647 u32 namesz; 648 u32 descsz; 649 u32 type; 650 char name[8]; /* "PowerPC" */ 651 struct chrpdesc { 652 u32 real_mode; 653 u32 real_base; 654 u32 real_size; 655 u32 virt_base; 656 u32 virt_size; 657 u32 load_base; 658 } chrpdesc; 659 } chrpnote; 660 struct rpanote { 661 u32 namesz; 662 u32 descsz; 663 u32 type; 664 char name[24]; /* "IBM,RPA-Client-Config" */ 665 struct rpadesc { 666 u32 lpar_affinity; 667 u32 min_rmo_size; 668 u32 min_rmo_percent; 669 u32 max_pft_size; 670 u32 splpar; 671 u32 min_load; 672 u32 new_mem_def; 673 u32 ignore_me; 674 } rpadesc; 675 } rpanote; 676 } fake_elf = { 677 .elfhdr = { 678 .e_ident = { 0x7f, 'E', 'L', 'F', 679 ELFCLASS32, ELFDATA2MSB, EV_CURRENT }, 680 .e_type = ET_EXEC, /* yeah right */ 681 .e_machine = EM_PPC, 682 .e_version = EV_CURRENT, 683 .e_phoff = offsetof(struct fake_elf, phdr), 684 .e_phentsize = sizeof(Elf32_Phdr), 685 .e_phnum = 2 686 }, 687 .phdr = { 688 [0] = { 689 .p_type = PT_NOTE, 690 .p_offset = offsetof(struct fake_elf, chrpnote), 691 .p_filesz = sizeof(struct chrpnote) 692 }, [1] = { 693 .p_type = PT_NOTE, 694 .p_offset = offsetof(struct fake_elf, rpanote), 695 .p_filesz = sizeof(struct rpanote) 696 } 697 }, 698 .chrpnote = { 699 .namesz = sizeof("PowerPC"), 700 .descsz = sizeof(struct chrpdesc), 701 .type = 0x1275, 702 .name = "PowerPC", 703 .chrpdesc = { 704 .real_mode = ~0U, /* ~0 means "don't care" */ 705 .real_base = ~0U, 706 .real_size = ~0U, 707 .virt_base = ~0U, 708 .virt_size = ~0U, 709 .load_base = ~0U 710 }, 711 }, 712 .rpanote = { 713 .namesz = sizeof("IBM,RPA-Client-Config"), 714 .descsz = sizeof(struct rpadesc), 715 .type = 0x12759999, 716 .name = "IBM,RPA-Client-Config", 717 .rpadesc = { 718 .lpar_affinity = 0, 719 .min_rmo_size = 64, /* in megabytes */ 720 .min_rmo_percent = 0, 721 .max_pft_size = 48, /* 2^48 bytes max PFT size */ 722 .splpar = 1, 723 .min_load = ~0U, 724 .new_mem_def = 0 725 } 726 } 727 }; 728 729 static void __init prom_send_capabilities(void) 730 { 731 ihandle elfloader; 732 733 elfloader = call_prom("open", 1, 1, ADDR("/packages/elf-loader")); 734 if (elfloader == 0) { 735 prom_printf("couldn't open /packages/elf-loader\n"); 736 return; 737 } 738 call_prom("call-method", 3, 1, ADDR("process-elf-header"), 739 elfloader, ADDR(&fake_elf)); 740 call_prom("close", 1, 0, elfloader); 741 } 742 #endif 743 744 /* 745 * Memory allocation strategy... our layout is normally: 746 * 747 * at 14Mb or more we have vmlinux, then a gap and initrd. In some 748 * rare cases, initrd might end up being before the kernel though. 749 * We assume this won't override the final kernel at 0, we have no 750 * provision to handle that in this version, but it should hopefully 751 * never happen. 752 * 753 * alloc_top is set to the top of RMO, eventually shrink down if the 754 * TCEs overlap 755 * 756 * alloc_bottom is set to the top of kernel/initrd 757 * 758 * from there, allocations are done this way : rtas is allocated 759 * topmost, and the device-tree is allocated from the bottom. We try 760 * to grow the device-tree allocation as we progress. If we can't, 761 * then we fail, we don't currently have a facility to restart 762 * elsewhere, but that shouldn't be necessary. 763 * 764 * Note that calls to reserve_mem have to be done explicitly, memory 765 * allocated with either alloc_up or alloc_down isn't automatically 766 * reserved. 767 */ 768 769 770 /* 771 * Allocates memory in the RMO upward from the kernel/initrd 772 * 773 * When align is 0, this is a special case, it means to allocate in place 774 * at the current location of alloc_bottom or fail (that is basically 775 * extending the previous allocation). Used for the device-tree flattening 776 */ 777 static unsigned long __init alloc_up(unsigned long size, unsigned long align) 778 { 779 unsigned long base = RELOC(alloc_bottom); 780 unsigned long addr = 0; 781 782 if (align) 783 base = _ALIGN_UP(base, align); 784 prom_debug("alloc_up(%x, %x)\n", size, align); 785 if (RELOC(ram_top) == 0) 786 prom_panic("alloc_up() called with mem not initialized\n"); 787 788 if (align) 789 base = _ALIGN_UP(RELOC(alloc_bottom), align); 790 else 791 base = RELOC(alloc_bottom); 792 793 for(; (base + size) <= RELOC(alloc_top); 794 base = _ALIGN_UP(base + 0x100000, align)) { 795 prom_debug(" trying: 0x%x\n\r", base); 796 addr = (unsigned long)prom_claim(base, size, 0); 797 if (addr != PROM_ERROR && addr != 0) 798 break; 799 addr = 0; 800 if (align == 0) 801 break; 802 } 803 if (addr == 0) 804 return 0; 805 RELOC(alloc_bottom) = addr; 806 807 prom_debug(" -> %x\n", addr); 808 prom_debug(" alloc_bottom : %x\n", RELOC(alloc_bottom)); 809 prom_debug(" alloc_top : %x\n", RELOC(alloc_top)); 810 prom_debug(" alloc_top_hi : %x\n", RELOC(alloc_top_high)); 811 prom_debug(" rmo_top : %x\n", RELOC(rmo_top)); 812 prom_debug(" ram_top : %x\n", RELOC(ram_top)); 813 814 return addr; 815 } 816 817 /* 818 * Allocates memory downward, either from top of RMO, or if highmem 819 * is set, from the top of RAM. Note that this one doesn't handle 820 * failures. It does claim memory if highmem is not set. 821 */ 822 static unsigned long __init alloc_down(unsigned long size, unsigned long align, 823 int highmem) 824 { 825 unsigned long base, addr = 0; 826 827 prom_debug("alloc_down(%x, %x, %s)\n", size, align, 828 highmem ? RELOC("(high)") : RELOC("(low)")); 829 if (RELOC(ram_top) == 0) 830 prom_panic("alloc_down() called with mem not initialized\n"); 831 832 if (highmem) { 833 /* Carve out storage for the TCE table. */ 834 addr = _ALIGN_DOWN(RELOC(alloc_top_high) - size, align); 835 if (addr <= RELOC(alloc_bottom)) 836 return 0; 837 /* Will we bump into the RMO ? If yes, check out that we 838 * didn't overlap existing allocations there, if we did, 839 * we are dead, we must be the first in town ! 840 */ 841 if (addr < RELOC(rmo_top)) { 842 /* Good, we are first */ 843 if (RELOC(alloc_top) == RELOC(rmo_top)) 844 RELOC(alloc_top) = RELOC(rmo_top) = addr; 845 else 846 return 0; 847 } 848 RELOC(alloc_top_high) = addr; 849 goto bail; 850 } 851 852 base = _ALIGN_DOWN(RELOC(alloc_top) - size, align); 853 for (; base > RELOC(alloc_bottom); 854 base = _ALIGN_DOWN(base - 0x100000, align)) { 855 prom_debug(" trying: 0x%x\n\r", base); 856 addr = (unsigned long)prom_claim(base, size, 0); 857 if (addr != PROM_ERROR && addr != 0) 858 break; 859 addr = 0; 860 } 861 if (addr == 0) 862 return 0; 863 RELOC(alloc_top) = addr; 864 865 bail: 866 prom_debug(" -> %x\n", addr); 867 prom_debug(" alloc_bottom : %x\n", RELOC(alloc_bottom)); 868 prom_debug(" alloc_top : %x\n", RELOC(alloc_top)); 869 prom_debug(" alloc_top_hi : %x\n", RELOC(alloc_top_high)); 870 prom_debug(" rmo_top : %x\n", RELOC(rmo_top)); 871 prom_debug(" ram_top : %x\n", RELOC(ram_top)); 872 873 return addr; 874 } 875 876 /* 877 * Parse a "reg" cell 878 */ 879 static unsigned long __init prom_next_cell(int s, cell_t **cellp) 880 { 881 cell_t *p = *cellp; 882 unsigned long r = 0; 883 884 /* Ignore more than 2 cells */ 885 while (s > sizeof(unsigned long) / 4) { 886 p++; 887 s--; 888 } 889 r = *p++; 890 #ifdef CONFIG_PPC64 891 if (s > 1) { 892 r <<= 32; 893 r |= *(p++); 894 } 895 #endif 896 *cellp = p; 897 return r; 898 } 899 900 /* 901 * Very dumb function for adding to the memory reserve list, but 902 * we don't need anything smarter at this point 903 * 904 * XXX Eventually check for collisions. They should NEVER happen. 905 * If problems seem to show up, it would be a good start to track 906 * them down. 907 */ 908 static void reserve_mem(u64 base, u64 size) 909 { 910 u64 top = base + size; 911 unsigned long cnt = RELOC(mem_reserve_cnt); 912 913 if (size == 0) 914 return; 915 916 /* We need to always keep one empty entry so that we 917 * have our terminator with "size" set to 0 since we are 918 * dumb and just copy this entire array to the boot params 919 */ 920 base = _ALIGN_DOWN(base, PAGE_SIZE); 921 top = _ALIGN_UP(top, PAGE_SIZE); 922 size = top - base; 923 924 if (cnt >= (MEM_RESERVE_MAP_SIZE - 1)) 925 prom_panic("Memory reserve map exhausted !\n"); 926 RELOC(mem_reserve_map)[cnt].base = base; 927 RELOC(mem_reserve_map)[cnt].size = size; 928 RELOC(mem_reserve_cnt) = cnt + 1; 929 } 930 931 /* 932 * Initialize memory allocation mecanism, parse "memory" nodes and 933 * obtain that way the top of memory and RMO to setup out local allocator 934 */ 935 static void __init prom_init_mem(void) 936 { 937 phandle node; 938 char *path, type[64]; 939 unsigned int plen; 940 cell_t *p, *endp; 941 struct prom_t *_prom = &RELOC(prom); 942 u32 rac, rsc; 943 944 /* 945 * We iterate the memory nodes to find 946 * 1) top of RMO (first node) 947 * 2) top of memory 948 */ 949 rac = 2; 950 prom_getprop(_prom->root, "#address-cells", &rac, sizeof(rac)); 951 rsc = 1; 952 prom_getprop(_prom->root, "#size-cells", &rsc, sizeof(rsc)); 953 prom_debug("root_addr_cells: %x\n", (unsigned long) rac); 954 prom_debug("root_size_cells: %x\n", (unsigned long) rsc); 955 956 prom_debug("scanning memory:\n"); 957 path = RELOC(prom_scratch); 958 959 for (node = 0; prom_next_node(&node); ) { 960 type[0] = 0; 961 prom_getprop(node, "device_type", type, sizeof(type)); 962 963 if (type[0] == 0) { 964 /* 965 * CHRP Longtrail machines have no device_type 966 * on the memory node, so check the name instead... 967 */ 968 prom_getprop(node, "name", type, sizeof(type)); 969 } 970 if (strcmp(type, RELOC("memory"))) 971 continue; 972 973 plen = prom_getprop(node, "reg", RELOC(regbuf), sizeof(regbuf)); 974 if (plen > sizeof(regbuf)) { 975 prom_printf("memory node too large for buffer !\n"); 976 plen = sizeof(regbuf); 977 } 978 p = RELOC(regbuf); 979 endp = p + (plen / sizeof(cell_t)); 980 981 #ifdef DEBUG_PROM 982 memset(path, 0, PROM_SCRATCH_SIZE); 983 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1); 984 prom_debug(" node %s :\n", path); 985 #endif /* DEBUG_PROM */ 986 987 while ((endp - p) >= (rac + rsc)) { 988 unsigned long base, size; 989 990 base = prom_next_cell(rac, &p); 991 size = prom_next_cell(rsc, &p); 992 993 if (size == 0) 994 continue; 995 prom_debug(" %x %x\n", base, size); 996 if (base == 0 && (RELOC(of_platform) & PLATFORM_LPAR)) 997 RELOC(rmo_top) = size; 998 if ((base + size) > RELOC(ram_top)) 999 RELOC(ram_top) = base + size; 1000 } 1001 } 1002 1003 RELOC(alloc_bottom) = PAGE_ALIGN((unsigned long)&RELOC(_end) + 0x4000); 1004 1005 /* Check if we have an initrd after the kernel, if we do move our bottom 1006 * point to after it 1007 */ 1008 if (RELOC(prom_initrd_start)) { 1009 if (RELOC(prom_initrd_end) > RELOC(alloc_bottom)) 1010 RELOC(alloc_bottom) = PAGE_ALIGN(RELOC(prom_initrd_end)); 1011 } 1012 1013 /* 1014 * If prom_memory_limit is set we reduce the upper limits *except* for 1015 * alloc_top_high. This must be the real top of RAM so we can put 1016 * TCE's up there. 1017 */ 1018 1019 RELOC(alloc_top_high) = RELOC(ram_top); 1020 1021 if (RELOC(prom_memory_limit)) { 1022 if (RELOC(prom_memory_limit) <= RELOC(alloc_bottom)) { 1023 prom_printf("Ignoring mem=%x <= alloc_bottom.\n", 1024 RELOC(prom_memory_limit)); 1025 RELOC(prom_memory_limit) = 0; 1026 } else if (RELOC(prom_memory_limit) >= RELOC(ram_top)) { 1027 prom_printf("Ignoring mem=%x >= ram_top.\n", 1028 RELOC(prom_memory_limit)); 1029 RELOC(prom_memory_limit) = 0; 1030 } else { 1031 RELOC(ram_top) = RELOC(prom_memory_limit); 1032 RELOC(rmo_top) = min(RELOC(rmo_top), RELOC(prom_memory_limit)); 1033 } 1034 } 1035 1036 /* 1037 * Setup our top alloc point, that is top of RMO or top of 1038 * segment 0 when running non-LPAR. 1039 * Some RS64 machines have buggy firmware where claims up at 1040 * 1GB fail. Cap at 768MB as a workaround. 1041 * Since 768MB is plenty of room, and we need to cap to something 1042 * reasonable on 32-bit, cap at 768MB on all machines. 1043 */ 1044 if (!RELOC(rmo_top)) 1045 RELOC(rmo_top) = RELOC(ram_top); 1046 RELOC(rmo_top) = min(0x30000000ul, RELOC(rmo_top)); 1047 RELOC(alloc_top) = RELOC(rmo_top); 1048 1049 prom_printf("memory layout at init:\n"); 1050 prom_printf(" memory_limit : %x (16 MB aligned)\n", RELOC(prom_memory_limit)); 1051 prom_printf(" alloc_bottom : %x\n", RELOC(alloc_bottom)); 1052 prom_printf(" alloc_top : %x\n", RELOC(alloc_top)); 1053 prom_printf(" alloc_top_hi : %x\n", RELOC(alloc_top_high)); 1054 prom_printf(" rmo_top : %x\n", RELOC(rmo_top)); 1055 prom_printf(" ram_top : %x\n", RELOC(ram_top)); 1056 #ifdef CONFIG_KEXEC 1057 if (RELOC(prom_crashk_base)) { 1058 prom_printf(" crashk_base : %x\n", RELOC(prom_crashk_base)); 1059 prom_printf(" crashk_size : %x\n", RELOC(prom_crashk_size)); 1060 } 1061 #endif 1062 } 1063 1064 1065 /* 1066 * Allocate room for and instantiate RTAS 1067 */ 1068 static void __init prom_instantiate_rtas(void) 1069 { 1070 phandle rtas_node; 1071 ihandle rtas_inst; 1072 u32 base, entry = 0; 1073 u32 size = 0; 1074 1075 prom_debug("prom_instantiate_rtas: start...\n"); 1076 1077 rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas")); 1078 prom_debug("rtas_node: %x\n", rtas_node); 1079 if (!PHANDLE_VALID(rtas_node)) 1080 return; 1081 1082 prom_getprop(rtas_node, "rtas-size", &size, sizeof(size)); 1083 if (size == 0) 1084 return; 1085 1086 base = alloc_down(size, PAGE_SIZE, 0); 1087 if (base == 0) { 1088 prom_printf("RTAS allocation failed !\n"); 1089 return; 1090 } 1091 1092 rtas_inst = call_prom("open", 1, 1, ADDR("/rtas")); 1093 if (!IHANDLE_VALID(rtas_inst)) { 1094 prom_printf("opening rtas package failed (%x)\n", rtas_inst); 1095 return; 1096 } 1097 1098 prom_printf("instantiating rtas at 0x%x ...", base); 1099 1100 if (call_prom_ret("call-method", 3, 2, &entry, 1101 ADDR("instantiate-rtas"), 1102 rtas_inst, base) != 0 1103 || entry == 0) { 1104 prom_printf(" failed\n"); 1105 return; 1106 } 1107 prom_printf(" done\n"); 1108 1109 reserve_mem(base, size); 1110 1111 prom_setprop(rtas_node, "/rtas", "linux,rtas-base", 1112 &base, sizeof(base)); 1113 prom_setprop(rtas_node, "/rtas", "linux,rtas-entry", 1114 &entry, sizeof(entry)); 1115 1116 prom_debug("rtas base = 0x%x\n", base); 1117 prom_debug("rtas entry = 0x%x\n", entry); 1118 prom_debug("rtas size = 0x%x\n", (long)size); 1119 1120 prom_debug("prom_instantiate_rtas: end...\n"); 1121 } 1122 1123 #ifdef CONFIG_PPC64 1124 /* 1125 * Allocate room for and initialize TCE tables 1126 */ 1127 static void __init prom_initialize_tce_table(void) 1128 { 1129 phandle node; 1130 ihandle phb_node; 1131 char compatible[64], type[64], model[64]; 1132 char *path = RELOC(prom_scratch); 1133 u64 base, align; 1134 u32 minalign, minsize; 1135 u64 tce_entry, *tce_entryp; 1136 u64 local_alloc_top, local_alloc_bottom; 1137 u64 i; 1138 1139 if (RELOC(ppc64_iommu_off)) 1140 return; 1141 1142 prom_debug("starting prom_initialize_tce_table\n"); 1143 1144 /* Cache current top of allocs so we reserve a single block */ 1145 local_alloc_top = RELOC(alloc_top_high); 1146 local_alloc_bottom = local_alloc_top; 1147 1148 /* Search all nodes looking for PHBs. */ 1149 for (node = 0; prom_next_node(&node); ) { 1150 compatible[0] = 0; 1151 type[0] = 0; 1152 model[0] = 0; 1153 prom_getprop(node, "compatible", 1154 compatible, sizeof(compatible)); 1155 prom_getprop(node, "device_type", type, sizeof(type)); 1156 prom_getprop(node, "model", model, sizeof(model)); 1157 1158 if ((type[0] == 0) || (strstr(type, RELOC("pci")) == NULL)) 1159 continue; 1160 1161 /* Keep the old logic in tack to avoid regression. */ 1162 if (compatible[0] != 0) { 1163 if ((strstr(compatible, RELOC("python")) == NULL) && 1164 (strstr(compatible, RELOC("Speedwagon")) == NULL) && 1165 (strstr(compatible, RELOC("Winnipeg")) == NULL)) 1166 continue; 1167 } else if (model[0] != 0) { 1168 if ((strstr(model, RELOC("ython")) == NULL) && 1169 (strstr(model, RELOC("peedwagon")) == NULL) && 1170 (strstr(model, RELOC("innipeg")) == NULL)) 1171 continue; 1172 } 1173 1174 if (prom_getprop(node, "tce-table-minalign", &minalign, 1175 sizeof(minalign)) == PROM_ERROR) 1176 minalign = 0; 1177 if (prom_getprop(node, "tce-table-minsize", &minsize, 1178 sizeof(minsize)) == PROM_ERROR) 1179 minsize = 4UL << 20; 1180 1181 /* 1182 * Even though we read what OF wants, we just set the table 1183 * size to 4 MB. This is enough to map 2GB of PCI DMA space. 1184 * By doing this, we avoid the pitfalls of trying to DMA to 1185 * MMIO space and the DMA alias hole. 1186 * 1187 * On POWER4, firmware sets the TCE region by assuming 1188 * each TCE table is 8MB. Using this memory for anything 1189 * else will impact performance, so we always allocate 8MB. 1190 * Anton 1191 */ 1192 if (__is_processor(PV_POWER4) || __is_processor(PV_POWER4p)) 1193 minsize = 8UL << 20; 1194 else 1195 minsize = 4UL << 20; 1196 1197 /* Align to the greater of the align or size */ 1198 align = max(minalign, minsize); 1199 base = alloc_down(minsize, align, 1); 1200 if (base == 0) 1201 prom_panic("ERROR, cannot find space for TCE table.\n"); 1202 if (base < local_alloc_bottom) 1203 local_alloc_bottom = base; 1204 1205 /* It seems OF doesn't null-terminate the path :-( */ 1206 memset(path, 0, sizeof(path)); 1207 /* Call OF to setup the TCE hardware */ 1208 if (call_prom("package-to-path", 3, 1, node, 1209 path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) { 1210 prom_printf("package-to-path failed\n"); 1211 } 1212 1213 /* Save away the TCE table attributes for later use. */ 1214 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base)); 1215 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize)); 1216 1217 prom_debug("TCE table: %s\n", path); 1218 prom_debug("\tnode = 0x%x\n", node); 1219 prom_debug("\tbase = 0x%x\n", base); 1220 prom_debug("\tsize = 0x%x\n", minsize); 1221 1222 /* Initialize the table to have a one-to-one mapping 1223 * over the allocated size. 1224 */ 1225 tce_entryp = (unsigned long *)base; 1226 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) { 1227 tce_entry = (i << PAGE_SHIFT); 1228 tce_entry |= 0x3; 1229 *tce_entryp = tce_entry; 1230 } 1231 1232 prom_printf("opening PHB %s", path); 1233 phb_node = call_prom("open", 1, 1, path); 1234 if (phb_node == 0) 1235 prom_printf("... failed\n"); 1236 else 1237 prom_printf("... done\n"); 1238 1239 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"), 1240 phb_node, -1, minsize, 1241 (u32) base, (u32) (base >> 32)); 1242 call_prom("close", 1, 0, phb_node); 1243 } 1244 1245 reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom); 1246 1247 if (RELOC(prom_memory_limit)) { 1248 /* 1249 * We align the start to a 16MB boundary so we can map 1250 * the TCE area using large pages if possible. 1251 * The end should be the top of RAM so no need to align it. 1252 */ 1253 RELOC(prom_tce_alloc_start) = _ALIGN_DOWN(local_alloc_bottom, 1254 0x1000000); 1255 RELOC(prom_tce_alloc_end) = local_alloc_top; 1256 } 1257 1258 /* Flag the first invalid entry */ 1259 prom_debug("ending prom_initialize_tce_table\n"); 1260 } 1261 #endif 1262 1263 /* 1264 * With CHRP SMP we need to use the OF to start the other processors. 1265 * We can't wait until smp_boot_cpus (the OF is trashed by then) 1266 * so we have to put the processors into a holding pattern controlled 1267 * by the kernel (not OF) before we destroy the OF. 1268 * 1269 * This uses a chunk of low memory, puts some holding pattern 1270 * code there and sends the other processors off to there until 1271 * smp_boot_cpus tells them to do something. The holding pattern 1272 * checks that address until its cpu # is there, when it is that 1273 * cpu jumps to __secondary_start(). smp_boot_cpus() takes care 1274 * of setting those values. 1275 * 1276 * We also use physical address 0x4 here to tell when a cpu 1277 * is in its holding pattern code. 1278 * 1279 * -- Cort 1280 */ 1281 extern void __secondary_hold(void); 1282 extern unsigned long __secondary_hold_spinloop; 1283 extern unsigned long __secondary_hold_acknowledge; 1284 1285 /* 1286 * We want to reference the copy of __secondary_hold_* in the 1287 * 0 - 0x100 address range 1288 */ 1289 #define LOW_ADDR(x) (((unsigned long) &(x)) & 0xff) 1290 1291 static void __init prom_hold_cpus(void) 1292 { 1293 unsigned long i; 1294 unsigned int reg; 1295 phandle node; 1296 char type[64]; 1297 int cpuid = 0; 1298 unsigned int interrupt_server[MAX_CPU_THREADS]; 1299 unsigned int cpu_threads, hw_cpu_num; 1300 int propsize; 1301 struct prom_t *_prom = &RELOC(prom); 1302 unsigned long *spinloop 1303 = (void *) LOW_ADDR(__secondary_hold_spinloop); 1304 unsigned long *acknowledge 1305 = (void *) LOW_ADDR(__secondary_hold_acknowledge); 1306 #ifdef CONFIG_PPC64 1307 /* __secondary_hold is actually a descriptor, not the text address */ 1308 unsigned long secondary_hold 1309 = __pa(*PTRRELOC((unsigned long *)__secondary_hold)); 1310 #else 1311 unsigned long secondary_hold = LOW_ADDR(__secondary_hold); 1312 #endif 1313 1314 prom_debug("prom_hold_cpus: start...\n"); 1315 prom_debug(" 1) spinloop = 0x%x\n", (unsigned long)spinloop); 1316 prom_debug(" 1) *spinloop = 0x%x\n", *spinloop); 1317 prom_debug(" 1) acknowledge = 0x%x\n", 1318 (unsigned long)acknowledge); 1319 prom_debug(" 1) *acknowledge = 0x%x\n", *acknowledge); 1320 prom_debug(" 1) secondary_hold = 0x%x\n", secondary_hold); 1321 1322 /* Set the common spinloop variable, so all of the secondary cpus 1323 * will block when they are awakened from their OF spinloop. 1324 * This must occur for both SMP and non SMP kernels, since OF will 1325 * be trashed when we move the kernel. 1326 */ 1327 *spinloop = 0; 1328 1329 /* look for cpus */ 1330 for (node = 0; prom_next_node(&node); ) { 1331 type[0] = 0; 1332 prom_getprop(node, "device_type", type, sizeof(type)); 1333 if (strcmp(type, RELOC("cpu")) != 0) 1334 continue; 1335 1336 /* Skip non-configured cpus. */ 1337 if (prom_getprop(node, "status", type, sizeof(type)) > 0) 1338 if (strcmp(type, RELOC("okay")) != 0) 1339 continue; 1340 1341 reg = -1; 1342 prom_getprop(node, "reg", ®, sizeof(reg)); 1343 1344 prom_debug("\ncpuid = 0x%x\n", cpuid); 1345 prom_debug("cpu hw idx = 0x%x\n", reg); 1346 1347 /* Init the acknowledge var which will be reset by 1348 * the secondary cpu when it awakens from its OF 1349 * spinloop. 1350 */ 1351 *acknowledge = (unsigned long)-1; 1352 1353 propsize = prom_getprop(node, "ibm,ppc-interrupt-server#s", 1354 &interrupt_server, 1355 sizeof(interrupt_server)); 1356 if (propsize < 0) { 1357 /* no property. old hardware has no SMT */ 1358 cpu_threads = 1; 1359 interrupt_server[0] = reg; /* fake it with phys id */ 1360 } else { 1361 /* We have a threaded processor */ 1362 cpu_threads = propsize / sizeof(u32); 1363 if (cpu_threads > MAX_CPU_THREADS) { 1364 prom_printf("SMT: too many threads!\n" 1365 "SMT: found %x, max is %x\n", 1366 cpu_threads, MAX_CPU_THREADS); 1367 cpu_threads = 1; /* ToDo: panic? */ 1368 } 1369 } 1370 1371 hw_cpu_num = interrupt_server[0]; 1372 if (hw_cpu_num != _prom->cpu) { 1373 /* Primary Thread of non-boot cpu */ 1374 prom_printf("%x : starting cpu hw idx %x... ", cpuid, reg); 1375 call_prom("start-cpu", 3, 0, node, 1376 secondary_hold, reg); 1377 1378 for (i = 0; (i < 100000000) && 1379 (*acknowledge == ((unsigned long)-1)); i++ ) 1380 mb(); 1381 1382 if (*acknowledge == reg) 1383 prom_printf("done\n"); 1384 else 1385 prom_printf("failed: %x\n", *acknowledge); 1386 } 1387 #ifdef CONFIG_SMP 1388 else 1389 prom_printf("%x : boot cpu %x\n", cpuid, reg); 1390 #endif /* CONFIG_SMP */ 1391 1392 /* Reserve cpu #s for secondary threads. They start later. */ 1393 cpuid += cpu_threads; 1394 } 1395 1396 if (cpuid > NR_CPUS) 1397 prom_printf("WARNING: maximum CPUs (" __stringify(NR_CPUS) 1398 ") exceeded: ignoring extras\n"); 1399 1400 prom_debug("prom_hold_cpus: end...\n"); 1401 } 1402 1403 1404 static void __init prom_init_client_services(unsigned long pp) 1405 { 1406 struct prom_t *_prom = &RELOC(prom); 1407 1408 /* Get a handle to the prom entry point before anything else */ 1409 RELOC(prom_entry) = pp; 1410 1411 /* get a handle for the stdout device */ 1412 _prom->chosen = call_prom("finddevice", 1, 1, ADDR("/chosen")); 1413 if (!PHANDLE_VALID(_prom->chosen)) 1414 prom_panic("cannot find chosen"); /* msg won't be printed :( */ 1415 1416 /* get device tree root */ 1417 _prom->root = call_prom("finddevice", 1, 1, ADDR("/")); 1418 if (!PHANDLE_VALID(_prom->root)) 1419 prom_panic("cannot find device tree root"); /* msg won't be printed :( */ 1420 1421 _prom->mmumap = 0; 1422 } 1423 1424 #ifdef CONFIG_PPC32 1425 /* 1426 * For really old powermacs, we need to map things we claim. 1427 * For that, we need the ihandle of the mmu. 1428 * Also, on the longtrail, we need to work around other bugs. 1429 */ 1430 static void __init prom_find_mmu(void) 1431 { 1432 struct prom_t *_prom = &RELOC(prom); 1433 phandle oprom; 1434 char version[64]; 1435 1436 oprom = call_prom("finddevice", 1, 1, ADDR("/openprom")); 1437 if (!PHANDLE_VALID(oprom)) 1438 return; 1439 if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0) 1440 return; 1441 version[sizeof(version) - 1] = 0; 1442 /* XXX might need to add other versions here */ 1443 if (strcmp(version, "Open Firmware, 1.0.5") == 0) 1444 of_workarounds = OF_WA_CLAIM; 1445 else if (strncmp(version, "FirmWorks,3.", 12) == 0) { 1446 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL; 1447 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim"); 1448 } else 1449 return; 1450 _prom->memory = call_prom("open", 1, 1, ADDR("/memory")); 1451 prom_getprop(_prom->chosen, "mmu", &_prom->mmumap, 1452 sizeof(_prom->mmumap)); 1453 if (!IHANDLE_VALID(_prom->memory) || !IHANDLE_VALID(_prom->mmumap)) 1454 of_workarounds &= ~OF_WA_CLAIM; /* hmmm */ 1455 } 1456 #else 1457 #define prom_find_mmu() 1458 #endif 1459 1460 static void __init prom_init_stdout(void) 1461 { 1462 struct prom_t *_prom = &RELOC(prom); 1463 char *path = RELOC(of_stdout_device); 1464 char type[16]; 1465 u32 val; 1466 1467 if (prom_getprop(_prom->chosen, "stdout", &val, sizeof(val)) <= 0) 1468 prom_panic("cannot find stdout"); 1469 1470 _prom->stdout = val; 1471 1472 /* Get the full OF pathname of the stdout device */ 1473 memset(path, 0, 256); 1474 call_prom("instance-to-path", 3, 1, _prom->stdout, path, 255); 1475 val = call_prom("instance-to-package", 1, 1, _prom->stdout); 1476 prom_setprop(_prom->chosen, "/chosen", "linux,stdout-package", 1477 &val, sizeof(val)); 1478 prom_printf("OF stdout device is: %s\n", RELOC(of_stdout_device)); 1479 prom_setprop(_prom->chosen, "/chosen", "linux,stdout-path", 1480 path, strlen(path) + 1); 1481 1482 /* If it's a display, note it */ 1483 memset(type, 0, sizeof(type)); 1484 prom_getprop(val, "device_type", type, sizeof(type)); 1485 if (strcmp(type, RELOC("display")) == 0) 1486 prom_setprop(val, path, "linux,boot-display", NULL, 0); 1487 } 1488 1489 static void __init prom_close_stdin(void) 1490 { 1491 struct prom_t *_prom = &RELOC(prom); 1492 ihandle val; 1493 1494 if (prom_getprop(_prom->chosen, "stdin", &val, sizeof(val)) > 0) 1495 call_prom("close", 1, 0, val); 1496 } 1497 1498 static int __init prom_find_machine_type(void) 1499 { 1500 struct prom_t *_prom = &RELOC(prom); 1501 char compat[256]; 1502 int len, i = 0; 1503 #ifdef CONFIG_PPC64 1504 phandle rtas; 1505 int x; 1506 #endif 1507 1508 /* Look for a PowerMac */ 1509 len = prom_getprop(_prom->root, "compatible", 1510 compat, sizeof(compat)-1); 1511 if (len > 0) { 1512 compat[len] = 0; 1513 while (i < len) { 1514 char *p = &compat[i]; 1515 int sl = strlen(p); 1516 if (sl == 0) 1517 break; 1518 if (strstr(p, RELOC("Power Macintosh")) || 1519 strstr(p, RELOC("MacRISC"))) 1520 return PLATFORM_POWERMAC; 1521 i += sl + 1; 1522 } 1523 } 1524 #ifdef CONFIG_PPC64 1525 /* If not a mac, try to figure out if it's an IBM pSeries or any other 1526 * PAPR compliant platform. We assume it is if : 1527 * - /device_type is "chrp" (please, do NOT use that for future 1528 * non-IBM designs ! 1529 * - it has /rtas 1530 */ 1531 len = prom_getprop(_prom->root, "model", 1532 compat, sizeof(compat)-1); 1533 if (len <= 0) 1534 return PLATFORM_GENERIC; 1535 compat[len] = 0; 1536 if (strcmp(compat, "chrp")) 1537 return PLATFORM_GENERIC; 1538 1539 /* Default to pSeries. We need to know if we are running LPAR */ 1540 rtas = call_prom("finddevice", 1, 1, ADDR("/rtas")); 1541 if (!PHANDLE_VALID(rtas)) 1542 return PLATFORM_GENERIC; 1543 x = prom_getproplen(rtas, "ibm,hypertas-functions"); 1544 if (x != PROM_ERROR) { 1545 prom_printf("Hypertas detected, assuming LPAR !\n"); 1546 return PLATFORM_PSERIES_LPAR; 1547 } 1548 return PLATFORM_PSERIES; 1549 #else 1550 return PLATFORM_GENERIC; 1551 #endif 1552 } 1553 1554 static int __init prom_set_color(ihandle ih, int i, int r, int g, int b) 1555 { 1556 return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r); 1557 } 1558 1559 /* 1560 * If we have a display that we don't know how to drive, 1561 * we will want to try to execute OF's open method for it 1562 * later. However, OF will probably fall over if we do that 1563 * we've taken over the MMU. 1564 * So we check whether we will need to open the display, 1565 * and if so, open it now. 1566 */ 1567 static void __init prom_check_displays(void) 1568 { 1569 char type[16], *path; 1570 phandle node; 1571 ihandle ih; 1572 int i; 1573 1574 static unsigned char default_colors[] = { 1575 0x00, 0x00, 0x00, 1576 0x00, 0x00, 0xaa, 1577 0x00, 0xaa, 0x00, 1578 0x00, 0xaa, 0xaa, 1579 0xaa, 0x00, 0x00, 1580 0xaa, 0x00, 0xaa, 1581 0xaa, 0xaa, 0x00, 1582 0xaa, 0xaa, 0xaa, 1583 0x55, 0x55, 0x55, 1584 0x55, 0x55, 0xff, 1585 0x55, 0xff, 0x55, 1586 0x55, 0xff, 0xff, 1587 0xff, 0x55, 0x55, 1588 0xff, 0x55, 0xff, 1589 0xff, 0xff, 0x55, 1590 0xff, 0xff, 0xff 1591 }; 1592 const unsigned char *clut; 1593 1594 prom_printf("Looking for displays\n"); 1595 for (node = 0; prom_next_node(&node); ) { 1596 memset(type, 0, sizeof(type)); 1597 prom_getprop(node, "device_type", type, sizeof(type)); 1598 if (strcmp(type, RELOC("display")) != 0) 1599 continue; 1600 1601 /* It seems OF doesn't null-terminate the path :-( */ 1602 path = RELOC(prom_scratch); 1603 memset(path, 0, PROM_SCRATCH_SIZE); 1604 1605 /* 1606 * leave some room at the end of the path for appending extra 1607 * arguments 1608 */ 1609 if (call_prom("package-to-path", 3, 1, node, path, 1610 PROM_SCRATCH_SIZE-10) == PROM_ERROR) 1611 continue; 1612 prom_printf("found display : %s, opening ... ", path); 1613 1614 ih = call_prom("open", 1, 1, path); 1615 if (ih == 0) { 1616 prom_printf("failed\n"); 1617 continue; 1618 } 1619 1620 /* Success */ 1621 prom_printf("done\n"); 1622 prom_setprop(node, path, "linux,opened", NULL, 0); 1623 1624 /* Setup a usable color table when the appropriate 1625 * method is available. Should update this to set-colors */ 1626 clut = RELOC(default_colors); 1627 for (i = 0; i < 32; i++, clut += 3) 1628 if (prom_set_color(ih, i, clut[0], clut[1], 1629 clut[2]) != 0) 1630 break; 1631 1632 #ifdef CONFIG_LOGO_LINUX_CLUT224 1633 clut = PTRRELOC(RELOC(logo_linux_clut224.clut)); 1634 for (i = 0; i < RELOC(logo_linux_clut224.clutsize); i++, clut += 3) 1635 if (prom_set_color(ih, i + 32, clut[0], clut[1], 1636 clut[2]) != 0) 1637 break; 1638 #endif /* CONFIG_LOGO_LINUX_CLUT224 */ 1639 } 1640 } 1641 1642 1643 /* Return (relocated) pointer to this much memory: moves initrd if reqd. */ 1644 static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end, 1645 unsigned long needed, unsigned long align) 1646 { 1647 void *ret; 1648 1649 *mem_start = _ALIGN(*mem_start, align); 1650 while ((*mem_start + needed) > *mem_end) { 1651 unsigned long room, chunk; 1652 1653 prom_debug("Chunk exhausted, claiming more at %x...\n", 1654 RELOC(alloc_bottom)); 1655 room = RELOC(alloc_top) - RELOC(alloc_bottom); 1656 if (room > DEVTREE_CHUNK_SIZE) 1657 room = DEVTREE_CHUNK_SIZE; 1658 if (room < PAGE_SIZE) 1659 prom_panic("No memory for flatten_device_tree (no room)"); 1660 chunk = alloc_up(room, 0); 1661 if (chunk == 0) 1662 prom_panic("No memory for flatten_device_tree (claim failed)"); 1663 *mem_end = RELOC(alloc_top); 1664 } 1665 1666 ret = (void *)*mem_start; 1667 *mem_start += needed; 1668 1669 return ret; 1670 } 1671 1672 #define dt_push_token(token, mem_start, mem_end) \ 1673 do { *((u32 *)make_room(mem_start, mem_end, 4, 4)) = token; } while(0) 1674 1675 static unsigned long __init dt_find_string(char *str) 1676 { 1677 char *s, *os; 1678 1679 s = os = (char *)RELOC(dt_string_start); 1680 s += 4; 1681 while (s < (char *)RELOC(dt_string_end)) { 1682 if (strcmp(s, str) == 0) 1683 return s - os; 1684 s += strlen(s) + 1; 1685 } 1686 return 0; 1687 } 1688 1689 /* 1690 * The Open Firmware 1275 specification states properties must be 31 bytes or 1691 * less, however not all firmwares obey this. Make it 64 bytes to be safe. 1692 */ 1693 #define MAX_PROPERTY_NAME 64 1694 1695 static void __init scan_dt_build_strings(phandle node, 1696 unsigned long *mem_start, 1697 unsigned long *mem_end) 1698 { 1699 char *prev_name, *namep, *sstart; 1700 unsigned long soff; 1701 phandle child; 1702 1703 sstart = (char *)RELOC(dt_string_start); 1704 1705 /* get and store all property names */ 1706 prev_name = RELOC(""); 1707 for (;;) { 1708 /* 64 is max len of name including nul. */ 1709 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1); 1710 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) { 1711 /* No more nodes: unwind alloc */ 1712 *mem_start = (unsigned long)namep; 1713 break; 1714 } 1715 1716 /* skip "name" */ 1717 if (strcmp(namep, RELOC("name")) == 0) { 1718 *mem_start = (unsigned long)namep; 1719 prev_name = RELOC("name"); 1720 continue; 1721 } 1722 /* get/create string entry */ 1723 soff = dt_find_string(namep); 1724 if (soff != 0) { 1725 *mem_start = (unsigned long)namep; 1726 namep = sstart + soff; 1727 } else { 1728 /* Trim off some if we can */ 1729 *mem_start = (unsigned long)namep + strlen(namep) + 1; 1730 RELOC(dt_string_end) = *mem_start; 1731 } 1732 prev_name = namep; 1733 } 1734 1735 /* do all our children */ 1736 child = call_prom("child", 1, 1, node); 1737 while (child != 0) { 1738 scan_dt_build_strings(child, mem_start, mem_end); 1739 child = call_prom("peer", 1, 1, child); 1740 } 1741 } 1742 1743 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start, 1744 unsigned long *mem_end) 1745 { 1746 phandle child; 1747 char *namep, *prev_name, *sstart, *p, *ep, *lp, *path; 1748 unsigned long soff; 1749 unsigned char *valp; 1750 static char pname[MAX_PROPERTY_NAME]; 1751 int l, room; 1752 1753 dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end); 1754 1755 /* get the node's full name */ 1756 namep = (char *)*mem_start; 1757 room = *mem_end - *mem_start; 1758 if (room > 255) 1759 room = 255; 1760 l = call_prom("package-to-path", 3, 1, node, namep, room); 1761 if (l >= 0) { 1762 /* Didn't fit? Get more room. */ 1763 if (l >= room) { 1764 if (l >= *mem_end - *mem_start) 1765 namep = make_room(mem_start, mem_end, l+1, 1); 1766 call_prom("package-to-path", 3, 1, node, namep, l); 1767 } 1768 namep[l] = '\0'; 1769 1770 /* Fixup an Apple bug where they have bogus \0 chars in the 1771 * middle of the path in some properties, and extract 1772 * the unit name (everything after the last '/'). 1773 */ 1774 for (lp = p = namep, ep = namep + l; p < ep; p++) { 1775 if (*p == '/') 1776 lp = namep; 1777 else if (*p != 0) 1778 *lp++ = *p; 1779 } 1780 *lp = 0; 1781 *mem_start = _ALIGN((unsigned long)lp + 1, 4); 1782 } 1783 1784 /* get it again for debugging */ 1785 path = RELOC(prom_scratch); 1786 memset(path, 0, PROM_SCRATCH_SIZE); 1787 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1); 1788 1789 /* get and store all properties */ 1790 prev_name = RELOC(""); 1791 sstart = (char *)RELOC(dt_string_start); 1792 for (;;) { 1793 if (call_prom("nextprop", 3, 1, node, prev_name, 1794 RELOC(pname)) != 1) 1795 break; 1796 1797 /* skip "name" */ 1798 if (strcmp(RELOC(pname), RELOC("name")) == 0) { 1799 prev_name = RELOC("name"); 1800 continue; 1801 } 1802 1803 /* find string offset */ 1804 soff = dt_find_string(RELOC(pname)); 1805 if (soff == 0) { 1806 prom_printf("WARNING: Can't find string index for" 1807 " <%s>, node %s\n", RELOC(pname), path); 1808 break; 1809 } 1810 prev_name = sstart + soff; 1811 1812 /* get length */ 1813 l = call_prom("getproplen", 2, 1, node, RELOC(pname)); 1814 1815 /* sanity checks */ 1816 if (l == PROM_ERROR) 1817 continue; 1818 if (l > MAX_PROPERTY_LENGTH) { 1819 prom_printf("WARNING: ignoring large property "); 1820 /* It seems OF doesn't null-terminate the path :-( */ 1821 prom_printf("[%s] ", path); 1822 prom_printf("%s length 0x%x\n", RELOC(pname), l); 1823 continue; 1824 } 1825 1826 /* push property head */ 1827 dt_push_token(OF_DT_PROP, mem_start, mem_end); 1828 dt_push_token(l, mem_start, mem_end); 1829 dt_push_token(soff, mem_start, mem_end); 1830 1831 /* push property content */ 1832 valp = make_room(mem_start, mem_end, l, 4); 1833 call_prom("getprop", 4, 1, node, RELOC(pname), valp, l); 1834 *mem_start = _ALIGN(*mem_start, 4); 1835 } 1836 1837 /* Add a "linux,phandle" property. */ 1838 soff = dt_find_string(RELOC("linux,phandle")); 1839 if (soff == 0) 1840 prom_printf("WARNING: Can't find string index for" 1841 " <linux-phandle> node %s\n", path); 1842 else { 1843 dt_push_token(OF_DT_PROP, mem_start, mem_end); 1844 dt_push_token(4, mem_start, mem_end); 1845 dt_push_token(soff, mem_start, mem_end); 1846 valp = make_room(mem_start, mem_end, 4, 4); 1847 *(u32 *)valp = node; 1848 } 1849 1850 /* do all our children */ 1851 child = call_prom("child", 1, 1, node); 1852 while (child != 0) { 1853 scan_dt_build_struct(child, mem_start, mem_end); 1854 child = call_prom("peer", 1, 1, child); 1855 } 1856 1857 dt_push_token(OF_DT_END_NODE, mem_start, mem_end); 1858 } 1859 1860 static void __init flatten_device_tree(void) 1861 { 1862 phandle root; 1863 unsigned long mem_start, mem_end, room; 1864 struct boot_param_header *hdr; 1865 struct prom_t *_prom = &RELOC(prom); 1866 char *namep; 1867 u64 *rsvmap; 1868 1869 /* 1870 * Check how much room we have between alloc top & bottom (+/- a 1871 * few pages), crop to 4Mb, as this is our "chuck" size 1872 */ 1873 room = RELOC(alloc_top) - RELOC(alloc_bottom) - 0x4000; 1874 if (room > DEVTREE_CHUNK_SIZE) 1875 room = DEVTREE_CHUNK_SIZE; 1876 prom_debug("starting device tree allocs at %x\n", RELOC(alloc_bottom)); 1877 1878 /* Now try to claim that */ 1879 mem_start = (unsigned long)alloc_up(room, PAGE_SIZE); 1880 if (mem_start == 0) 1881 prom_panic("Can't allocate initial device-tree chunk\n"); 1882 mem_end = RELOC(alloc_top); 1883 1884 /* Get root of tree */ 1885 root = call_prom("peer", 1, 1, (phandle)0); 1886 if (root == (phandle)0) 1887 prom_panic ("couldn't get device tree root\n"); 1888 1889 /* Build header and make room for mem rsv map */ 1890 mem_start = _ALIGN(mem_start, 4); 1891 hdr = make_room(&mem_start, &mem_end, 1892 sizeof(struct boot_param_header), 4); 1893 RELOC(dt_header_start) = (unsigned long)hdr; 1894 rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8); 1895 1896 /* Start of strings */ 1897 mem_start = PAGE_ALIGN(mem_start); 1898 RELOC(dt_string_start) = mem_start; 1899 mem_start += 4; /* hole */ 1900 1901 /* Add "linux,phandle" in there, we'll need it */ 1902 namep = make_room(&mem_start, &mem_end, 16, 1); 1903 strcpy(namep, RELOC("linux,phandle")); 1904 mem_start = (unsigned long)namep + strlen(namep) + 1; 1905 1906 /* Build string array */ 1907 prom_printf("Building dt strings...\n"); 1908 scan_dt_build_strings(root, &mem_start, &mem_end); 1909 RELOC(dt_string_end) = mem_start; 1910 1911 /* Build structure */ 1912 mem_start = PAGE_ALIGN(mem_start); 1913 RELOC(dt_struct_start) = mem_start; 1914 prom_printf("Building dt structure...\n"); 1915 scan_dt_build_struct(root, &mem_start, &mem_end); 1916 dt_push_token(OF_DT_END, &mem_start, &mem_end); 1917 RELOC(dt_struct_end) = PAGE_ALIGN(mem_start); 1918 1919 /* Finish header */ 1920 hdr->boot_cpuid_phys = _prom->cpu; 1921 hdr->magic = OF_DT_HEADER; 1922 hdr->totalsize = RELOC(dt_struct_end) - RELOC(dt_header_start); 1923 hdr->off_dt_struct = RELOC(dt_struct_start) - RELOC(dt_header_start); 1924 hdr->off_dt_strings = RELOC(dt_string_start) - RELOC(dt_header_start); 1925 hdr->dt_strings_size = RELOC(dt_string_end) - RELOC(dt_string_start); 1926 hdr->off_mem_rsvmap = ((unsigned long)rsvmap) - RELOC(dt_header_start); 1927 hdr->version = OF_DT_VERSION; 1928 /* Version 16 is not backward compatible */ 1929 hdr->last_comp_version = 0x10; 1930 1931 /* Reserve the whole thing and copy the reserve map in, we 1932 * also bump mem_reserve_cnt to cause further reservations to 1933 * fail since it's too late. 1934 */ 1935 reserve_mem(RELOC(dt_header_start), hdr->totalsize); 1936 memcpy(rsvmap, RELOC(mem_reserve_map), sizeof(mem_reserve_map)); 1937 1938 #ifdef DEBUG_PROM 1939 { 1940 int i; 1941 prom_printf("reserved memory map:\n"); 1942 for (i = 0; i < RELOC(mem_reserve_cnt); i++) 1943 prom_printf(" %x - %x\n", 1944 RELOC(mem_reserve_map)[i].base, 1945 RELOC(mem_reserve_map)[i].size); 1946 } 1947 #endif 1948 RELOC(mem_reserve_cnt) = MEM_RESERVE_MAP_SIZE; 1949 1950 prom_printf("Device tree strings 0x%x -> 0x%x\n", 1951 RELOC(dt_string_start), RELOC(dt_string_end)); 1952 prom_printf("Device tree struct 0x%x -> 0x%x\n", 1953 RELOC(dt_struct_start), RELOC(dt_struct_end)); 1954 1955 } 1956 1957 1958 static void __init fixup_device_tree(void) 1959 { 1960 #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC) 1961 phandle u3, i2c, mpic; 1962 u32 u3_rev; 1963 u32 interrupts[2]; 1964 u32 parent; 1965 1966 /* Some G5s have a missing interrupt definition, fix it up here */ 1967 u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000")); 1968 if (!PHANDLE_VALID(u3)) 1969 return; 1970 i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000")); 1971 if (!PHANDLE_VALID(i2c)) 1972 return; 1973 mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000")); 1974 if (!PHANDLE_VALID(mpic)) 1975 return; 1976 1977 /* check if proper rev of u3 */ 1978 if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev)) 1979 == PROM_ERROR) 1980 return; 1981 if (u3_rev < 0x35 || u3_rev > 0x39) 1982 return; 1983 /* does it need fixup ? */ 1984 if (prom_getproplen(i2c, "interrupts") > 0) 1985 return; 1986 1987 prom_printf("fixing up bogus interrupts for u3 i2c...\n"); 1988 1989 /* interrupt on this revision of u3 is number 0 and level */ 1990 interrupts[0] = 0; 1991 interrupts[1] = 1; 1992 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts", 1993 &interrupts, sizeof(interrupts)); 1994 parent = (u32)mpic; 1995 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent", 1996 &parent, sizeof(parent)); 1997 #endif 1998 } 1999 2000 2001 static void __init prom_find_boot_cpu(void) 2002 { 2003 struct prom_t *_prom = &RELOC(prom); 2004 u32 getprop_rval; 2005 ihandle prom_cpu; 2006 phandle cpu_pkg; 2007 2008 _prom->cpu = 0; 2009 if (prom_getprop(_prom->chosen, "cpu", &prom_cpu, sizeof(prom_cpu)) <= 0) 2010 return; 2011 2012 cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu); 2013 2014 prom_getprop(cpu_pkg, "reg", &getprop_rval, sizeof(getprop_rval)); 2015 _prom->cpu = getprop_rval; 2016 2017 prom_debug("Booting CPU hw index = 0x%x\n", _prom->cpu); 2018 } 2019 2020 static void __init prom_check_initrd(unsigned long r3, unsigned long r4) 2021 { 2022 #ifdef CONFIG_BLK_DEV_INITRD 2023 struct prom_t *_prom = &RELOC(prom); 2024 2025 if (r3 && r4 && r4 != 0xdeadbeef) { 2026 unsigned long val; 2027 2028 RELOC(prom_initrd_start) = is_kernel_addr(r3) ? __pa(r3) : r3; 2029 RELOC(prom_initrd_end) = RELOC(prom_initrd_start) + r4; 2030 2031 val = RELOC(prom_initrd_start); 2032 prom_setprop(_prom->chosen, "/chosen", "linux,initrd-start", 2033 &val, sizeof(val)); 2034 val = RELOC(prom_initrd_end); 2035 prom_setprop(_prom->chosen, "/chosen", "linux,initrd-end", 2036 &val, sizeof(val)); 2037 2038 reserve_mem(RELOC(prom_initrd_start), 2039 RELOC(prom_initrd_end) - RELOC(prom_initrd_start)); 2040 2041 prom_debug("initrd_start=0x%x\n", RELOC(prom_initrd_start)); 2042 prom_debug("initrd_end=0x%x\n", RELOC(prom_initrd_end)); 2043 } 2044 #endif /* CONFIG_BLK_DEV_INITRD */ 2045 } 2046 2047 /* 2048 * We enter here early on, when the Open Firmware prom is still 2049 * handling exceptions and the MMU hash table for us. 2050 */ 2051 2052 unsigned long __init prom_init(unsigned long r3, unsigned long r4, 2053 unsigned long pp, 2054 unsigned long r6, unsigned long r7) 2055 { 2056 struct prom_t *_prom; 2057 unsigned long hdr; 2058 unsigned long offset = reloc_offset(); 2059 2060 #ifdef CONFIG_PPC32 2061 reloc_got2(offset); 2062 #endif 2063 2064 _prom = &RELOC(prom); 2065 2066 /* 2067 * First zero the BSS 2068 */ 2069 memset(&RELOC(__bss_start), 0, __bss_stop - __bss_start); 2070 2071 /* 2072 * Init interface to Open Firmware, get some node references, 2073 * like /chosen 2074 */ 2075 prom_init_client_services(pp); 2076 2077 /* 2078 * See if this OF is old enough that we need to do explicit maps 2079 * and other workarounds 2080 */ 2081 prom_find_mmu(); 2082 2083 /* 2084 * Init prom stdout device 2085 */ 2086 prom_init_stdout(); 2087 2088 /* 2089 * Get default machine type. At this point, we do not differentiate 2090 * between pSeries SMP and pSeries LPAR 2091 */ 2092 RELOC(of_platform) = prom_find_machine_type(); 2093 2094 /* Bail if this is a kdump kernel. */ 2095 if (PHYSICAL_START > 0) 2096 prom_panic("Error: You can't boot a kdump kernel from OF!\n"); 2097 2098 /* 2099 * Check for an initrd 2100 */ 2101 prom_check_initrd(r3, r4); 2102 2103 #ifdef CONFIG_PPC_PSERIES 2104 /* 2105 * On pSeries, inform the firmware about our capabilities 2106 */ 2107 if (RELOC(of_platform) == PLATFORM_PSERIES || 2108 RELOC(of_platform) == PLATFORM_PSERIES_LPAR) 2109 prom_send_capabilities(); 2110 #endif 2111 2112 /* 2113 * Copy the CPU hold code 2114 */ 2115 if (RELOC(of_platform) != PLATFORM_POWERMAC) 2116 copy_and_flush(0, KERNELBASE + offset, 0x100, 0); 2117 2118 /* 2119 * Do early parsing of command line 2120 */ 2121 early_cmdline_parse(); 2122 2123 /* 2124 * Initialize memory management within prom_init 2125 */ 2126 prom_init_mem(); 2127 2128 #ifdef CONFIG_KEXEC 2129 if (RELOC(prom_crashk_base)) 2130 reserve_mem(RELOC(prom_crashk_base), RELOC(prom_crashk_size)); 2131 #endif 2132 /* 2133 * Determine which cpu is actually running right _now_ 2134 */ 2135 prom_find_boot_cpu(); 2136 2137 /* 2138 * Initialize display devices 2139 */ 2140 prom_check_displays(); 2141 2142 #ifdef CONFIG_PPC64 2143 /* 2144 * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else 2145 * that uses the allocator, we need to make sure we get the top of memory 2146 * available for us here... 2147 */ 2148 if (RELOC(of_platform) == PLATFORM_PSERIES) 2149 prom_initialize_tce_table(); 2150 #endif 2151 2152 /* 2153 * On non-powermacs, try to instantiate RTAS and puts all CPUs 2154 * in spin-loops. PowerMacs don't have a working RTAS and use 2155 * a different way to spin CPUs 2156 */ 2157 if (RELOC(of_platform) != PLATFORM_POWERMAC) { 2158 prom_instantiate_rtas(); 2159 prom_hold_cpus(); 2160 } 2161 2162 /* 2163 * Fill in some infos for use by the kernel later on 2164 */ 2165 if (RELOC(prom_memory_limit)) 2166 prom_setprop(_prom->chosen, "/chosen", "linux,memory-limit", 2167 &RELOC(prom_memory_limit), 2168 sizeof(prom_memory_limit)); 2169 #ifdef CONFIG_PPC64 2170 if (RELOC(ppc64_iommu_off)) 2171 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-off", 2172 NULL, 0); 2173 2174 if (RELOC(iommu_force_on)) 2175 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-force-on", 2176 NULL, 0); 2177 2178 if (RELOC(prom_tce_alloc_start)) { 2179 prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-start", 2180 &RELOC(prom_tce_alloc_start), 2181 sizeof(prom_tce_alloc_start)); 2182 prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-end", 2183 &RELOC(prom_tce_alloc_end), 2184 sizeof(prom_tce_alloc_end)); 2185 } 2186 #endif 2187 2188 #ifdef CONFIG_KEXEC 2189 if (RELOC(prom_crashk_base)) { 2190 prom_setprop(_prom->chosen, "/chosen", "linux,crashkernel-base", 2191 PTRRELOC(&prom_crashk_base), 2192 sizeof(RELOC(prom_crashk_base))); 2193 prom_setprop(_prom->chosen, "/chosen", "linux,crashkernel-size", 2194 PTRRELOC(&prom_crashk_size), 2195 sizeof(RELOC(prom_crashk_size))); 2196 } 2197 #endif 2198 /* 2199 * Fixup any known bugs in the device-tree 2200 */ 2201 fixup_device_tree(); 2202 2203 /* 2204 * Now finally create the flattened device-tree 2205 */ 2206 prom_printf("copying OF device tree ...\n"); 2207 flatten_device_tree(); 2208 2209 /* 2210 * in case stdin is USB and still active on IBM machines... 2211 * Unfortunately quiesce crashes on some powermacs if we have 2212 * closed stdin already (in particular the powerbook 101). 2213 */ 2214 if (RELOC(of_platform) != PLATFORM_POWERMAC) 2215 prom_close_stdin(); 2216 2217 /* 2218 * Call OF "quiesce" method to shut down pending DMA's from 2219 * devices etc... 2220 */ 2221 prom_printf("Calling quiesce ...\n"); 2222 call_prom("quiesce", 0, 0); 2223 2224 /* 2225 * And finally, call the kernel passing it the flattened device 2226 * tree and NULL as r5, thus triggering the new entry point which 2227 * is common to us and kexec 2228 */ 2229 hdr = RELOC(dt_header_start); 2230 prom_printf("returning from prom_init\n"); 2231 prom_debug("->dt_header_start=0x%x\n", hdr); 2232 2233 #ifdef CONFIG_PPC32 2234 reloc_got2(-offset); 2235 #endif 2236 2237 __start(hdr, KERNELBASE + offset, 0); 2238 2239 return 0; 2240 } 2241