arch/powerpc/kernel/prom_init.c

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