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