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