arch/powerpc/kernel/prom_init.c

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