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