arch/powerpc/kernel/prom_init.c

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