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