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