arch/powerpc/kernel/prom_init.c

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