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 /* we cannot use FORTIFY as it brings in new symbols */
  19 #define __NO_FORTIFY
  20
  21 #include <stdarg.h>
  22 #include <linux/kernel.h>
  23 #include <linux/string.h>
  24 #include <linux/init.h>
  25 #include <linux/threads.h>
  26 #include <linux/spinlock.h>
  27 #include <linux/types.h>
  28 #include <linux/pci.h>
  29 #include <linux/proc_fs.h>
  30 #include <linux/stringify.h>
  31 #include <linux/delay.h>
  32 #include <linux/initrd.h>
  33 #include <linux/bitops.h>
  34 #include <asm/prom.h>
  35 #include <asm/rtas.h>
  36 #include <asm/page.h>
  37 #include <asm/processor.h>
  38 #include <asm/irq.h>
  39 #include <asm/io.h>
  40 #include <asm/smp.h>
  41 #include <asm/mmu.h>
  42 #include <asm/pgtable.h>
  43 #include <asm/iommu.h>
  44 #include <asm/btext.h>
  45 #include <asm/sections.h>
  46 #include <asm/machdep.h>
  47 #include <asm/opal.h>
  48 #include <asm/asm-prototypes.h>
  49
  50 #include <linux/linux_logo.h>
  51
  52 /*
  53  * Eventually bump that one up
  54  */
  55 #define DEVTREE_CHUNK_SIZE      0x100000
  56
  57 /*
  58  * This is the size of the local memory reserve map that gets copied
  59  * into the boot params passed to the kernel. That size is totally
  60  * flexible as the kernel just reads the list until it encounters an
  61  * entry with size 0, so it can be changed without breaking binary
  62  * compatibility
  63  */
  64 #define MEM_RESERVE_MAP_SIZE    8
  65
  66 /*
  67  * prom_init() is called very early on, before the kernel text
  68  * and data have been mapped to KERNELBASE.  At this point the code
  69  * is running at whatever address it has been loaded at.
  70  * On ppc32 we compile with -mrelocatable, which means that references
  71  * to extern and static variables get relocated automatically.
  72  * ppc64 objects are always relocatable, we just need to relocate the
  73  * TOC.
  74  *
  75  * Because OF may have mapped I/O devices into the area starting at
  76  * KERNELBASE, particularly on CHRP machines, we can't safely call
  77  * OF once the kernel has been mapped to KERNELBASE.  Therefore all
  78  * OF calls must be done within prom_init().
  79  *
  80  * ADDR is used in calls to call_prom.  The 4th and following
  81  * arguments to call_prom should be 32-bit values.
  82  * On ppc64, 64 bit values are truncated to 32 bits (and
  83  * fortunately don't get interpreted as two arguments).
  84  */
  85 #define ADDR(x)         (u32)(unsigned long)(x)
  86
  87 #ifdef CONFIG_PPC64
  88 #define OF_WORKAROUNDS  0
  89 #else
  90 #define OF_WORKAROUNDS  of_workarounds
  91 int of_workarounds;
  92 #endif
  93
  94 #define OF_WA_CLAIM     1       /* do phys/virt claim separately, then map */
  95 #define OF_WA_LONGTRAIL 2       /* work around longtrail bugs */
  96
  97 #define PROM_BUG() do {                                         \
  98         prom_printf("kernel BUG at %s line 0x%x!\n",            \
  99                     __FILE__, __LINE__);                        \
 100         __asm__ __volatile__(".long " BUG_ILLEGAL_INSTR);       \
 101 } while (0)
 102
 103 #ifdef DEBUG_PROM
 104 #define prom_debug(x...)        prom_printf(x)
 105 #else
 106 #define prom_debug(x...)
 107 #endif
 108
 109
 110 typedef u32 prom_arg_t;
 111
 112 struct prom_args {
 113         __be32 service;
 114         __be32 nargs;
 115         __be32 nret;
 116         __be32 args[10];
 117 };
 118
 119 struct prom_t {
 120         ihandle root;
 121         phandle chosen;
 122         int cpu;
 123         ihandle stdout;
 124         ihandle mmumap;
 125         ihandle memory;
 126 };
 127
 128 struct mem_map_entry {
 129         __be64  base;
 130         __be64  size;
 131 };
 132
 133 typedef __be32 cell_t;
 134
 135 extern void __start(unsigned long r3, unsigned long r4, unsigned long r5,
 136                     unsigned long r6, unsigned long r7, unsigned long r8,
 137                     unsigned long r9);
 138
 139 #ifdef CONFIG_PPC64
 140 extern int enter_prom(struct prom_args *args, unsigned long entry);
 141 #else
 142 static inline int enter_prom(struct prom_args *args, unsigned long entry)
 143 {
 144         return ((int (*)(struct prom_args *))entry)(args);
 145 }
 146 #endif
 147
 148 extern void copy_and_flush(unsigned long dest, unsigned long src,
 149                            unsigned long size, unsigned long offset);
 150
 151 /* prom structure */
 152 static struct prom_t __initdata prom;
 153
 154 static unsigned long prom_entry __initdata;
 155
 156 #define PROM_SCRATCH_SIZE 256
 157
 158 static char __initdata of_stdout_device[256];
 159 static char __initdata prom_scratch[PROM_SCRATCH_SIZE];
 160
 161 static unsigned long __initdata dt_header_start;
 162 static unsigned long __initdata dt_struct_start, dt_struct_end;
 163 static unsigned long __initdata dt_string_start, dt_string_end;
 164
 165 static unsigned long __initdata prom_initrd_start, prom_initrd_end;
 166
 167 #ifdef CONFIG_PPC64
 168 static int __initdata prom_iommu_force_on;
 169 static int __initdata prom_iommu_off;
 170 static unsigned long __initdata prom_tce_alloc_start;
 171 static unsigned long __initdata prom_tce_alloc_end;
 172 #endif
 173
 174 static bool __initdata prom_radix_disable;
 175
 176 struct platform_support {
 177         bool hash_mmu;
 178         bool radix_mmu;
 179         bool radix_gtse;
 180         bool xive;
 181 };
 182
 183 /* Platforms codes are now obsolete in the kernel. Now only used within this
 184  * file and ultimately gone too. Feel free to change them if you need, they
 185  * are not shared with anything outside of this file anymore
 186  */
 187 #define PLATFORM_PSERIES        0x0100
 188 #define PLATFORM_PSERIES_LPAR   0x0101
 189 #define PLATFORM_LPAR           0x0001
 190 #define PLATFORM_POWERMAC       0x0400
 191 #define PLATFORM_GENERIC        0x0500
 192 #define PLATFORM_OPAL           0x0600
 193
 194 static int __initdata of_platform;
 195
 196 static char __initdata prom_cmd_line[COMMAND_LINE_SIZE];
 197
 198 static unsigned long __initdata prom_memory_limit;
 199
 200 static unsigned long __initdata alloc_top;
 201 static unsigned long __initdata alloc_top_high;
 202 static unsigned long __initdata alloc_bottom;
 203 static unsigned long __initdata rmo_top;
 204 static unsigned long __initdata ram_top;
 205
 206 static struct mem_map_entry __initdata mem_reserve_map[MEM_RESERVE_MAP_SIZE];
 207 static int __initdata mem_reserve_cnt;
 208
 209 static cell_t __initdata regbuf[1024];
 210
 211 static bool rtas_has_query_cpu_stopped;
 212
 213
 214 /*
 215  * Error results ... some OF calls will return "-1" on error, some
 216  * will return 0, some will return either. To simplify, here are
 217  * macros to use with any ihandle or phandle return value to check if
 218  * it is valid
 219  */
 220
 221 #define PROM_ERROR              (-1u)
 222 #define PHANDLE_VALID(p)        ((p) != 0 && (p) != PROM_ERROR)
 223 #define IHANDLE_VALID(i)        ((i) != 0 && (i) != PROM_ERROR)
 224
 225
 226 /* This is the one and *ONLY* place where we actually call open
 227  * firmware.
 228  */
 229
 230 static int __init call_prom(const char *service, int nargs, int nret, ...)
 231 {
 232         int i;
 233         struct prom_args args;
 234         va_list list;
 235
 236         args.service = cpu_to_be32(ADDR(service));
 237         args.nargs = cpu_to_be32(nargs);
 238         args.nret = cpu_to_be32(nret);
 239
 240         va_start(list, nret);
 241         for (i = 0; i < nargs; i++)
 242                 args.args[i] = cpu_to_be32(va_arg(list, prom_arg_t));
 243         va_end(list);
 244
 245         for (i = 0; i < nret; i++)
 246                 args.args[nargs+i] = 0;
 247
 248         if (enter_prom(&args, prom_entry) < 0)
 249                 return PROM_ERROR;
 250
 251         return (nret > 0) ? be32_to_cpu(args.args[nargs]) : 0;
 252 }
 253
 254 static int __init call_prom_ret(const char *service, int nargs, int nret,
 255                                 prom_arg_t *rets, ...)
 256 {
 257         int i;
 258         struct prom_args args;
 259         va_list list;
 260
 261         args.service = cpu_to_be32(ADDR(service));
 262         args.nargs = cpu_to_be32(nargs);
 263         args.nret = cpu_to_be32(nret);
 264
 265         va_start(list, rets);
 266         for (i = 0; i < nargs; i++)
 267                 args.args[i] = cpu_to_be32(va_arg(list, prom_arg_t));
 268         va_end(list);
 269
 270         for (i = 0; i < nret; i++)
 271                 args.args[nargs+i] = 0;
 272
 273         if (enter_prom(&args, prom_entry) < 0)
 274                 return PROM_ERROR;
 275
 276         if (rets != NULL)
 277                 for (i = 1; i < nret; ++i)
 278                         rets[i-1] = be32_to_cpu(args.args[nargs+i]);
 279
 280         return (nret > 0) ? be32_to_cpu(args.args[nargs]) : 0;
 281 }
 282
 283
 284 static void __init prom_print(const char *msg)
 285 {
 286         const char *p, *q;
 287
 288         if (prom.stdout == 0)
 289                 return;
 290
 291         for (p = msg; *p != 0; p = q) {
 292                 for (q = p; *q != 0 && *q != '\n'; ++q)
 293                         ;
 294                 if (q > p)
 295                         call_prom("write", 3, 1, prom.stdout, p, q - p);
 296                 if (*q == 0)
 297                         break;
 298                 ++q;
 299                 call_prom("write", 3, 1, prom.stdout, ADDR("\r\n"), 2);
 300         }
 301 }
 302
 303
 304 static void __init prom_print_hex(unsigned long val)
 305 {
 306         int i, nibbles = sizeof(val)*2;
 307         char buf[sizeof(val)*2+1];
 308
 309         for (i = nibbles-1;  i >= 0;  i--) {
 310                 buf[i] = (val & 0xf) + '0';
 311                 if (buf[i] > '9')
 312                         buf[i] += ('a'-'0'-10);
 313                 val >>= 4;
 314         }
 315         buf[nibbles] = '\0';
 316         call_prom("write", 3, 1, prom.stdout, buf, nibbles);
 317 }
 318
 319 /* max number of decimal digits in an unsigned long */
 320 #define UL_DIGITS 21
 321 static void __init prom_print_dec(unsigned long val)
 322 {
 323         int i, size;
 324         char buf[UL_DIGITS+1];
 325
 326         for (i = UL_DIGITS-1; i >= 0;  i--) {
 327                 buf[i] = (val % 10) + '0';
 328                 val = val/10;
 329                 if (val == 0)
 330                         break;
 331         }
 332         /* shift stuff down */
 333         size = UL_DIGITS - i;
 334         call_prom("write", 3, 1, prom.stdout, buf+i, size);
 335 }
 336
 337 static void __init prom_printf(const char *format, ...)
 338 {
 339         const char *p, *q, *s;
 340         va_list args;
 341         unsigned long v;
 342         long vs;
 343
 344         va_start(args, format);
 345         for (p = format; *p != 0; p = q) {
 346                 for (q = p; *q != 0 && *q != '\n' && *q != '%'; ++q)
 347                         ;
 348                 if (q > p)
 349                         call_prom("write", 3, 1, prom.stdout, p, q - p);
 350                 if (*q == 0)
 351                         break;
 352                 if (*q == '\n') {
 353                         ++q;
 354                         call_prom("write", 3, 1, prom.stdout,
 355                                   ADDR("\r\n"), 2);
 356                         continue;
 357                 }
 358                 ++q;
 359                 if (*q == 0)
 360                         break;
 361                 switch (*q) {
 362                 case 's':
 363                         ++q;
 364                         s = va_arg(args, const char *);
 365                         prom_print(s);
 366                         break;
 367                 case 'x':
 368                         ++q;
 369                         v = va_arg(args, unsigned long);
 370                         prom_print_hex(v);
 371                         break;
 372                 case 'd':
 373                         ++q;
 374                         vs = va_arg(args, int);
 375                         if (vs < 0) {
 376                                 prom_print("-");
 377                                 vs = -vs;
 378                         }
 379                         prom_print_dec(vs);
 380                         break;
 381                 case 'l':
 382                         ++q;
 383                         if (*q == 0)
 384                                 break;
 385                         else if (*q == 'x') {
 386                                 ++q;
 387                                 v = va_arg(args, unsigned long);
 388                                 prom_print_hex(v);
 389                         } else if (*q == 'u') { /* '%lu' */
 390                                 ++q;
 391                                 v = va_arg(args, unsigned long);
 392                                 prom_print_dec(v);
 393                         } else if (*q == 'd') { /* %ld */
 394                                 ++q;
 395                                 vs = va_arg(args, long);
 396                                 if (vs < 0) {
 397                                         prom_print("-");
 398                                         vs = -vs;
 399                                 }
 400                                 prom_print_dec(vs);
 401                         }
 402                         break;
 403                 }
 404         }
 405         va_end(args);
 406 }
 407
 408
 409 static unsigned int __init prom_claim(unsigned long virt, unsigned long size,
 410                                 unsigned long align)
 411 {
 412
 413         if (align == 0 && (OF_WORKAROUNDS & OF_WA_CLAIM)) {
 414                 /*
 415                  * Old OF requires we claim physical and virtual separately
 416                  * and then map explicitly (assuming virtual mode)
 417                  */
 418                 int ret;
 419                 prom_arg_t result;
 420
 421                 ret = call_prom_ret("call-method", 5, 2, &result,
 422                                     ADDR("claim"), prom.memory,
 423                                     align, size, virt);
 424                 if (ret != 0 || result == -1)
 425                         return -1;
 426                 ret = call_prom_ret("call-method", 5, 2, &result,
 427                                     ADDR("claim"), prom.mmumap,
 428                                     align, size, virt);
 429                 if (ret != 0) {
 430                         call_prom("call-method", 4, 1, ADDR("release"),
 431                                   prom.memory, size, virt);
 432                         return -1;
 433                 }
 434                 /* the 0x12 is M (coherence) + PP == read/write */
 435                 call_prom("call-method", 6, 1,
 436                           ADDR("map"), prom.mmumap, 0x12, size, virt, virt);
 437                 return virt;
 438         }
 439         return call_prom("claim", 3, 1, (prom_arg_t)virt, (prom_arg_t)size,
 440                          (prom_arg_t)align);
 441 }
 442
 443 static void __init __attribute__((noreturn)) prom_panic(const char *reason)
 444 {
 445         prom_print(reason);
 446         /* Do not call exit because it clears the screen on pmac
 447          * it also causes some sort of double-fault on early pmacs */
 448         if (of_platform == PLATFORM_POWERMAC)
 449                 asm("trap\n");
 450
 451         /* ToDo: should put up an SRC here on pSeries */
 452         call_prom("exit", 0, 0);
 453
 454         for (;;)                        /* should never get here */
 455                 ;
 456 }
 457
 458
 459 static int __init prom_next_node(phandle *nodep)
 460 {
 461         phandle node;
 462
 463         if ((node = *nodep) != 0
 464             && (*nodep = call_prom("child", 1, 1, node)) != 0)
 465                 return 1;
 466         if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
 467                 return 1;
 468         for (;;) {
 469                 if ((node = call_prom("parent", 1, 1, node)) == 0)
 470                         return 0;
 471                 if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
 472                         return 1;
 473         }
 474 }
 475
 476 static inline int prom_getprop(phandle node, const char *pname,
 477                                void *value, size_t valuelen)
 478 {
 479         return call_prom("getprop", 4, 1, node, ADDR(pname),
 480                          (u32)(unsigned long) value, (u32) valuelen);
 481 }
 482
 483 static inline int prom_getproplen(phandle node, const char *pname)
 484 {
 485         return call_prom("getproplen", 2, 1, node, ADDR(pname));
 486 }
 487
 488 static void add_string(char **str, const char *q)
 489 {
 490         char *p = *str;
 491
 492         while (*q)
 493                 *p++ = *q++;
 494         *p++ = ' ';
 495         *str = p;
 496 }
 497
 498 static char *tohex(unsigned int x)
 499 {
 500         static char digits[] = "0123456789abcdef";
 501         static char result[9];
 502         int i;
 503
 504         result[8] = 0;
 505         i = 8;
 506         do {
 507                 --i;
 508                 result[i] = digits[x & 0xf];
 509                 x >>= 4;
 510         } while (x != 0 && i > 0);
 511         return &result[i];
 512 }
 513
 514 static int __init prom_setprop(phandle node, const char *nodename,
 515                                const char *pname, void *value, size_t valuelen)
 516 {
 517         char cmd[256], *p;
 518
 519         if (!(OF_WORKAROUNDS & OF_WA_LONGTRAIL))
 520                 return call_prom("setprop", 4, 1, node, ADDR(pname),
 521                                  (u32)(unsigned long) value, (u32) valuelen);
 522
 523         /* gah... setprop doesn't work on longtrail, have to use interpret */
 524         p = cmd;
 525         add_string(&p, "dev");
 526         add_string(&p, nodename);
 527         add_string(&p, tohex((u32)(unsigned long) value));
 528         add_string(&p, tohex(valuelen));
 529         add_string(&p, tohex(ADDR(pname)));
 530         add_string(&p, tohex(strlen(pname)));
 531         add_string(&p, "property");
 532         *p = 0;
 533         return call_prom("interpret", 1, 1, (u32)(unsigned long) cmd);
 534 }
 535
 536 /* We can't use the standard versions because of relocation headaches. */
 537 #define isxdigit(c)     (('0' <= (c) && (c) <= '9') \
 538                          || ('a' <= (c) && (c) <= 'f') \
 539                          || ('A' <= (c) && (c) <= 'F'))
 540
 541 #define isdigit(c)      ('0' <= (c) && (c) <= '9')
 542 #define islower(c)      ('a' <= (c) && (c) <= 'z')
 543 #define toupper(c)      (islower(c) ? ((c) - 'a' + 'A') : (c))
 544
 545 static unsigned long prom_strtoul(const char *cp, const char **endp)
 546 {
 547         unsigned long result = 0, base = 10, value;
 548
 549         if (*cp == '0') {
 550                 base = 8;
 551                 cp++;
 552                 if (toupper(*cp) == 'X') {
 553                         cp++;
 554                         base = 16;
 555                 }
 556         }
 557
 558         while (isxdigit(*cp) &&
 559                (value = isdigit(*cp) ? *cp - '0' : toupper(*cp) - 'A' + 10) < base) {
 560                 result = result * base + value;
 561                 cp++;
 562         }
 563
 564         if (endp)
 565                 *endp = cp;
 566
 567         return result;
 568 }
 569
 570 static unsigned long prom_memparse(const char *ptr, const char **retptr)
 571 {
 572         unsigned long ret = prom_strtoul(ptr, retptr);
 573         int shift = 0;
 574
 575         /*
 576          * We can't use a switch here because GCC *may* generate a
 577          * jump table which won't work, because we're not running at
 578          * the address we're linked at.
 579          */
 580         if ('G' == **retptr || 'g' == **retptr)
 581                 shift = 30;
 582
 583         if ('M' == **retptr || 'm' == **retptr)
 584                 shift = 20;
 585
 586         if ('K' == **retptr || 'k' == **retptr)
 587                 shift = 10;
 588
 589         if (shift) {
 590                 ret <<= shift;
 591                 (*retptr)++;
 592         }
 593
 594         return ret;
 595 }
 596
 597 /*
 598  * Early parsing of the command line passed to the kernel, used for
 599  * "mem=x" and the options that affect the iommu
 600  */
 601 static void __init early_cmdline_parse(void)
 602 {
 603         const char *opt;
 604
 605         char *p;
 606         int l = 0;
 607
 608         prom_cmd_line[0] = 0;
 609         p = prom_cmd_line;
 610         if ((long)prom.chosen > 0)
 611                 l = prom_getprop(prom.chosen, "bootargs", p, COMMAND_LINE_SIZE-1);
 612 #ifdef CONFIG_CMDLINE
 613         if (l <= 0 || p[0] == '\0') /* dbl check */
 614                 strlcpy(prom_cmd_line,
 615                         CONFIG_CMDLINE, sizeof(prom_cmd_line));
 616 #endif /* CONFIG_CMDLINE */
 617         prom_printf("command line: %s\n", prom_cmd_line);
 618
 619 #ifdef CONFIG_PPC64
 620         opt = strstr(prom_cmd_line, "iommu=");
 621         if (opt) {
 622                 prom_printf("iommu opt is: %s\n", opt);
 623                 opt += 6;
 624                 while (*opt && *opt == ' ')
 625                         opt++;
 626                 if (!strncmp(opt, "off", 3))
 627                         prom_iommu_off = 1;
 628                 else if (!strncmp(opt, "force", 5))
 629                         prom_iommu_force_on = 1;
 630         }
 631 #endif
 632         opt = strstr(prom_cmd_line, "mem=");
 633         if (opt) {
 634                 opt += 4;
 635                 prom_memory_limit = prom_memparse(opt, (const char **)&opt);
 636 #ifdef CONFIG_PPC64
 637                 /* Align to 16 MB == size of ppc64 large page */
 638                 prom_memory_limit = ALIGN(prom_memory_limit, 0x1000000);
 639 #endif
 640         }
 641
 642         opt = strstr(prom_cmd_line, "disable_radix");
 643         if (opt) {
 644                 prom_debug("Radix disabled from cmdline\n");
 645                 prom_radix_disable = true;
 646         }
 647 }
 648
 649 #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
 650 /*
 651  * The architecture vector has an array of PVR mask/value pairs,
 652  * followed by # option vectors - 1, followed by the option vectors.
 653  *
 654  * See prom.h for the definition of the bits specified in the
 655  * architecture vector.
 656  */
 657
 658 /* Firmware expects the value to be n - 1, where n is the # of vectors */
 659 #define NUM_VECTORS(n)          ((n) - 1)
 660
 661 /*
 662  * Firmware expects 1 + n - 2, where n is the length of the option vector in
 663  * bytes. The 1 accounts for the length byte itself, the - 2 .. ?
 664  */
 665 #define VECTOR_LENGTH(n)        (1 + (n) - 2)
 666
 667 struct option_vector1 {
 668         u8 byte1;
 669         u8 arch_versions;
 670         u8 arch_versions3;
 671 } __packed;
 672
 673 struct option_vector2 {
 674         u8 byte1;
 675         __be16 reserved;
 676         __be32 real_base;
 677         __be32 real_size;
 678         __be32 virt_base;
 679         __be32 virt_size;
 680         __be32 load_base;
 681         __be32 min_rma;
 682         __be32 min_load;
 683         u8 min_rma_percent;
 684         u8 max_pft_size;
 685 } __packed;
 686
 687 struct option_vector3 {
 688         u8 byte1;
 689         u8 byte2;
 690 } __packed;
 691
 692 struct option_vector4 {
 693         u8 byte1;
 694         u8 min_vp_cap;
 695 } __packed;
 696
 697 struct option_vector5 {
 698         u8 byte1;
 699         u8 byte2;
 700         u8 byte3;
 701         u8 cmo;
 702         u8 associativity;
 703         u8 bin_opts;
 704         u8 micro_checkpoint;
 705         u8 reserved0;
 706         __be32 max_cpus;
 707         __be16 papr_level;
 708         __be16 reserved1;
 709         u8 platform_facilities;
 710         u8 reserved2;
 711         __be16 reserved3;
 712         u8 subprocessors;
 713         u8 byte22;
 714         u8 intarch;
 715         u8 mmu;
 716         u8 hash_ext;
 717         u8 radix_ext;
 718 } __packed;
 719
 720 struct option_vector6 {
 721         u8 reserved;
 722         u8 secondary_pteg;
 723         u8 os_name;
 724 } __packed;
 725
 726 struct ibm_arch_vec {
 727         struct { u32 mask, val; } pvrs[12];
 728
 729         u8 num_vectors;
 730
 731         u8 vec1_len;
 732         struct option_vector1 vec1;
 733
 734         u8 vec2_len;
 735         struct option_vector2 vec2;
 736
 737         u8 vec3_len;
 738         struct option_vector3 vec3;
 739
 740         u8 vec4_len;
 741         struct option_vector4 vec4;
 742
 743         u8 vec5_len;
 744         struct option_vector5 vec5;
 745
 746         u8 vec6_len;
 747         struct option_vector6 vec6;
 748 } __packed;
 749
 750 struct ibm_arch_vec __cacheline_aligned ibm_architecture_vec = {
 751         .pvrs = {
 752                 {
 753                         .mask = cpu_to_be32(0xfffe0000), /* POWER5/POWER5+ */
 754                         .val  = cpu_to_be32(0x003a0000),
 755                 },
 756                 {
 757                         .mask = cpu_to_be32(0xffff0000), /* POWER6 */
 758                         .val  = cpu_to_be32(0x003e0000),
 759                 },
 760                 {
 761                         .mask = cpu_to_be32(0xffff0000), /* POWER7 */
 762                         .val  = cpu_to_be32(0x003f0000),
 763                 },
 764                 {
 765                         .mask = cpu_to_be32(0xffff0000), /* POWER8E */
 766                         .val  = cpu_to_be32(0x004b0000),
 767                 },
 768                 {
 769                         .mask = cpu_to_be32(0xffff0000), /* POWER8NVL */
 770                         .val  = cpu_to_be32(0x004c0000),
 771                 },
 772                 {
 773                         .mask = cpu_to_be32(0xffff0000), /* POWER8 */
 774                         .val  = cpu_to_be32(0x004d0000),
 775                 },
 776                 {
 777                         .mask = cpu_to_be32(0xffff0000), /* POWER9 */
 778                         .val  = cpu_to_be32(0x004e0000),
 779                 },
 780                 {
 781                         .mask = cpu_to_be32(0xffffffff), /* all 3.00-compliant */
 782                         .val  = cpu_to_be32(0x0f000005),
 783                 },
 784                 {
 785                         .mask = cpu_to_be32(0xffffffff), /* all 2.07-compliant */
 786                         .val  = cpu_to_be32(0x0f000004),
 787                 },
 788                 {
 789                         .mask = cpu_to_be32(0xffffffff), /* all 2.06-compliant */
 790                         .val  = cpu_to_be32(0x0f000003),
 791                 },
 792                 {
 793                         .mask = cpu_to_be32(0xffffffff), /* all 2.05-compliant */
 794                         .val  = cpu_to_be32(0x0f000002),
 795                 },
 796                 {
 797                         .mask = cpu_to_be32(0xfffffffe), /* all 2.04-compliant and earlier */
 798                         .val  = cpu_to_be32(0x0f000001),
 799                 },
 800         },
 801
 802         .num_vectors = NUM_VECTORS(6),
 803
 804         .vec1_len = VECTOR_LENGTH(sizeof(struct option_vector1)),
 805         .vec1 = {
 806                 .byte1 = 0,
 807                 .arch_versions = OV1_PPC_2_00 | OV1_PPC_2_01 | OV1_PPC_2_02 | OV1_PPC_2_03 |
 808                                  OV1_PPC_2_04 | OV1_PPC_2_05 | OV1_PPC_2_06 | OV1_PPC_2_07,
 809                 .arch_versions3 = OV1_PPC_3_00,
 810         },
 811
 812         .vec2_len = VECTOR_LENGTH(sizeof(struct option_vector2)),
 813         /* option vector 2: Open Firmware options supported */
 814         .vec2 = {
 815                 .byte1 = OV2_REAL_MODE,
 816                 .reserved = 0,
 817                 .real_base = cpu_to_be32(0xffffffff),
 818                 .real_size = cpu_to_be32(0xffffffff),
 819                 .virt_base = cpu_to_be32(0xffffffff),
 820                 .virt_size = cpu_to_be32(0xffffffff),
 821                 .load_base = cpu_to_be32(0xffffffff),
 822                 .min_rma = cpu_to_be32(512),            /* 512MB min RMA */
 823                 .min_load = cpu_to_be32(0xffffffff),    /* full client load */
 824                 .min_rma_percent = 0,   /* min RMA percentage of total RAM */
 825                 .max_pft_size = 48,     /* max log_2(hash table size) */
 826         },
 827
 828         .vec3_len = VECTOR_LENGTH(sizeof(struct option_vector3)),
 829         /* option vector 3: processor options supported */
 830         .vec3 = {
 831                 .byte1 = 0,                     /* don't ignore, don't halt */
 832                 .byte2 = OV3_FP | OV3_VMX | OV3_DFP,
 833         },
 834
 835         .vec4_len = VECTOR_LENGTH(sizeof(struct option_vector4)),
 836         /* option vector 4: IBM PAPR implementation */
 837         .vec4 = {
 838                 .byte1 = 0,                     /* don't halt */
 839                 .min_vp_cap = OV4_MIN_ENT_CAP,  /* minimum VP entitled capacity */
 840         },
 841
 842         .vec5_len = VECTOR_LENGTH(sizeof(struct option_vector5)),
 843         /* option vector 5: PAPR/OF options */
 844         .vec5 = {
 845                 .byte1 = 0,                             /* don't ignore, don't halt */
 846                 .byte2 = OV5_FEAT(OV5_LPAR) | OV5_FEAT(OV5_SPLPAR) | OV5_FEAT(OV5_LARGE_PAGES) |
 847                 OV5_FEAT(OV5_DRCONF_MEMORY) | OV5_FEAT(OV5_DONATE_DEDICATE_CPU) |
 848 #ifdef CONFIG_PCI_MSI
 849                 /* PCIe/MSI support.  Without MSI full PCIe is not supported */
 850                 OV5_FEAT(OV5_MSI),
 851 #else
 852                 0,
 853 #endif
 854                 .byte3 = 0,
 855                 .cmo =
 856 #ifdef CONFIG_PPC_SMLPAR
 857                 OV5_FEAT(OV5_CMO) | OV5_FEAT(OV5_XCMO),
 858 #else
 859                 0,
 860 #endif
 861                 .associativity = OV5_FEAT(OV5_TYPE1_AFFINITY) | OV5_FEAT(OV5_PRRN),
 862                 .bin_opts = OV5_FEAT(OV5_RESIZE_HPT) | OV5_FEAT(OV5_HP_EVT),
 863                 .micro_checkpoint = 0,
 864                 .reserved0 = 0,
 865                 .max_cpus = cpu_to_be32(NR_CPUS),       /* number of cores supported */
 866                 .papr_level = 0,
 867                 .reserved1 = 0,
 868                 .platform_facilities = OV5_FEAT(OV5_PFO_HW_RNG) | OV5_FEAT(OV5_PFO_HW_ENCR) | OV5_FEAT(OV5_PFO_HW_842),
 869                 .reserved2 = 0,
 870                 .reserved3 = 0,
 871                 .subprocessors = 1,
 872                 .byte22 = OV5_FEAT(OV5_DRMEM_V2),
 873                 .intarch = 0,
 874                 .mmu = 0,
 875                 .hash_ext = 0,
 876                 .radix_ext = 0,
 877         },
 878
 879         /* option vector 6: IBM PAPR hints */
 880         .vec6_len = VECTOR_LENGTH(sizeof(struct option_vector6)),
 881         .vec6 = {
 882                 .reserved = 0,
 883                 .secondary_pteg = 0,
 884                 .os_name = OV6_LINUX,
 885         },
 886 };
 887
 888 /* Old method - ELF header with PT_NOTE sections only works on BE */
 889 #ifdef __BIG_ENDIAN__
 890 static struct fake_elf {
 891         Elf32_Ehdr      elfhdr;
 892         Elf32_Phdr      phdr[2];
 893         struct chrpnote {
 894                 u32     namesz;
 895                 u32     descsz;
 896                 u32     type;
 897                 char    name[8];        /* "PowerPC" */
 898                 struct chrpdesc {
 899                         u32     real_mode;
 900                         u32     real_base;
 901                         u32     real_size;
 902                         u32     virt_base;
 903                         u32     virt_size;
 904                         u32     load_base;
 905                 } chrpdesc;
 906         } chrpnote;
 907         struct rpanote {
 908                 u32     namesz;
 909                 u32     descsz;
 910                 u32     type;
 911                 char    name[24];       /* "IBM,RPA-Client-Config" */
 912                 struct rpadesc {
 913                         u32     lpar_affinity;
 914                         u32     min_rmo_size;
 915                         u32     min_rmo_percent;
 916                         u32     max_pft_size;
 917                         u32     splpar;
 918                         u32     min_load;
 919                         u32     new_mem_def;
 920                         u32     ignore_me;
 921                 } rpadesc;
 922         } rpanote;
 923 } fake_elf = {
 924         .elfhdr = {
 925                 .e_ident = { 0x7f, 'E', 'L', 'F',
 926                              ELFCLASS32, ELFDATA2MSB, EV_CURRENT },
 927                 .e_type = ET_EXEC,      /* yeah right */
 928                 .e_machine = EM_PPC,
 929                 .e_version = EV_CURRENT,
 930                 .e_phoff = offsetof(struct fake_elf, phdr),
 931                 .e_phentsize = sizeof(Elf32_Phdr),
 932                 .e_phnum = 2
 933         },
 934         .phdr = {
 935                 [0] = {
 936                         .p_type = PT_NOTE,
 937                         .p_offset = offsetof(struct fake_elf, chrpnote),
 938                         .p_filesz = sizeof(struct chrpnote)
 939                 }, [1] = {
 940                         .p_type = PT_NOTE,
 941                         .p_offset = offsetof(struct fake_elf, rpanote),
 942                         .p_filesz = sizeof(struct rpanote)
 943                 }
 944         },
 945         .chrpnote = {
 946                 .namesz = sizeof("PowerPC"),
 947                 .descsz = sizeof(struct chrpdesc),
 948                 .type = 0x1275,
 949                 .name = "PowerPC",
 950                 .chrpdesc = {
 951                         .real_mode = ~0U,       /* ~0 means "don't care" */
 952                         .real_base = ~0U,
 953                         .real_size = ~0U,
 954                         .virt_base = ~0U,
 955                         .virt_size = ~0U,
 956                         .load_base = ~0U
 957                 },
 958         },
 959         .rpanote = {
 960                 .namesz = sizeof("IBM,RPA-Client-Config"),
 961                 .descsz = sizeof(struct rpadesc),
 962                 .type = 0x12759999,
 963                 .name = "IBM,RPA-Client-Config",
 964                 .rpadesc = {
 965                         .lpar_affinity = 0,
 966                         .min_rmo_size = 64,     /* in megabytes */
 967                         .min_rmo_percent = 0,
 968                         .max_pft_size = 48,     /* 2^48 bytes max PFT size */
 969                         .splpar = 1,
 970                         .min_load = ~0U,
 971                         .new_mem_def = 0
 972                 }
 973         }
 974 };
 975 #endif /* __BIG_ENDIAN__ */
 976
 977 static int __init prom_count_smt_threads(void)
 978 {
 979         phandle node;
 980         char type[64];
 981         unsigned int plen;
 982
 983         /* Pick up th first CPU node we can find */
 984         for (node = 0; prom_next_node(&node); ) {
 985                 type[0] = 0;
 986                 prom_getprop(node, "device_type", type, sizeof(type));
 987
 988                 if (strcmp(type, "cpu"))
 989                         continue;
 990                 /*
 991                  * There is an entry for each smt thread, each entry being
 992                  * 4 bytes long.  All cpus should have the same number of
 993                  * smt threads, so return after finding the first.
 994                  */
 995                 plen = prom_getproplen(node, "ibm,ppc-interrupt-server#s");
 996                 if (plen == PROM_ERROR)
 997                         break;
 998                 plen >>= 2;
 999                 prom_debug("Found %lu smt threads per core\n", (unsigned long)plen);
1000
1001                 /* Sanity check */
1002                 if (plen < 1 || plen > 64) {
1003                         prom_printf("Threads per core %lu out of bounds, assuming 1\n",
1004                                     (unsigned long)plen);
1005                         return 1;
1006                 }
1007                 return plen;
1008         }
1009         prom_debug("No threads found, assuming 1 per core\n");
1010
1011         return 1;
1012
1013 }
1014
1015 static void __init prom_parse_mmu_model(u8 val,
1016                                         struct platform_support *support)
1017 {
1018         switch (val) {
1019         case OV5_FEAT(OV5_MMU_DYNAMIC):
1020         case OV5_FEAT(OV5_MMU_EITHER): /* Either Available */
1021                 prom_debug("MMU - either supported\n");
1022                 support->radix_mmu = !prom_radix_disable;
1023                 support->hash_mmu = true;
1024                 break;
1025         case OV5_FEAT(OV5_MMU_RADIX): /* Only Radix */
1026                 prom_debug("MMU - radix only\n");
1027                 if (prom_radix_disable) {
1028                         /*
1029                          * If we __have__ to do radix, we're better off ignoring
1030                          * the command line rather than not booting.
1031                          */
1032                         prom_printf("WARNING: Ignoring cmdline option disable_radix\n");
1033                 }
1034                 support->radix_mmu = true;
1035                 break;
1036         case OV5_FEAT(OV5_MMU_HASH):
1037                 prom_debug("MMU - hash only\n");
1038                 support->hash_mmu = true;
1039                 break;
1040         default:
1041                 prom_debug("Unknown mmu support option: 0x%x\n", val);
1042                 break;
1043         }
1044 }
1045
1046 static void __init prom_parse_xive_model(u8 val,
1047                                          struct platform_support *support)
1048 {
1049         switch (val) {
1050         case OV5_FEAT(OV5_XIVE_EITHER): /* Either Available */
1051                 prom_debug("XIVE - either mode supported\n");
1052                 support->xive = true;
1053                 break;
1054         case OV5_FEAT(OV5_XIVE_EXPLOIT): /* Only Exploitation mode */
1055                 prom_debug("XIVE - exploitation mode supported\n");
1056                 support->xive = true;
1057                 break;
1058         case OV5_FEAT(OV5_XIVE_LEGACY): /* Only Legacy mode */
1059                 prom_debug("XIVE - legacy mode supported\n");
1060                 break;
1061         default:
1062                 prom_debug("Unknown xive support option: 0x%x\n", val);
1063                 break;
1064         }
1065 }
1066
1067 static void __init prom_parse_platform_support(u8 index, u8 val,
1068                                                struct platform_support *support)
1069 {
1070         switch (index) {
1071         case OV5_INDX(OV5_MMU_SUPPORT): /* MMU Model */
1072                 prom_parse_mmu_model(val & OV5_FEAT(OV5_MMU_SUPPORT), support);
1073                 break;
1074         case OV5_INDX(OV5_RADIX_GTSE): /* Radix Extensions */
1075                 if (val & OV5_FEAT(OV5_RADIX_GTSE)) {
1076                         prom_debug("Radix - GTSE supported\n");
1077                         support->radix_gtse = true;
1078                 }
1079                 break;
1080         case OV5_INDX(OV5_XIVE_SUPPORT): /* Interrupt mode */
1081                 prom_parse_xive_model(val & OV5_FEAT(OV5_XIVE_SUPPORT),
1082                                       support);
1083                 break;
1084         }
1085 }
1086
1087 static void __init prom_check_platform_support(void)
1088 {
1089         struct platform_support supported = {
1090                 .hash_mmu = false,
1091                 .radix_mmu = false,
1092                 .radix_gtse = false,
1093                 .xive = false
1094         };
1095         int prop_len = prom_getproplen(prom.chosen,
1096                                        "ibm,arch-vec-5-platform-support");
1097         if (prop_len > 1) {
1098                 int i;
1099                 u8 vec[prop_len];
1100                 prom_debug("Found ibm,arch-vec-5-platform-support, len: %d\n",
1101                            prop_len);
1102                 prom_getprop(prom.chosen, "ibm,arch-vec-5-platform-support",
1103                              &vec, sizeof(vec));
1104                 for (i = 0; i < prop_len; i += 2) {
1105                         prom_debug("%d: index = 0x%x val = 0x%x\n", i / 2
1106                                                                   , vec[i]
1107                                                                   , vec[i + 1]);
1108                         prom_parse_platform_support(vec[i], vec[i + 1],
1109                                                     &supported);
1110                 }
1111         }
1112
1113         if (supported.radix_mmu && supported.radix_gtse) {
1114                 /* Radix preferred - but we require GTSE for now */
1115                 prom_debug("Asking for radix with GTSE\n");
1116                 ibm_architecture_vec.vec5.mmu = OV5_FEAT(OV5_MMU_RADIX);
1117                 ibm_architecture_vec.vec5.radix_ext = OV5_FEAT(OV5_RADIX_GTSE);
1118         } else if (supported.hash_mmu) {
1119                 /* Default to hash mmu (if we can) */
1120                 prom_debug("Asking for hash\n");
1121                 ibm_architecture_vec.vec5.mmu = OV5_FEAT(OV5_MMU_HASH);
1122         } else {
1123                 /* We're probably on a legacy hypervisor */
1124                 prom_debug("Assuming legacy hash support\n");
1125         }
1126
1127         if (supported.xive) {
1128                 prom_debug("Asking for XIVE\n");
1129                 ibm_architecture_vec.vec5.intarch = OV5_FEAT(OV5_XIVE_EXPLOIT);
1130         }
1131 }
1132
1133 static void __init prom_send_capabilities(void)
1134 {
1135         ihandle root;
1136         prom_arg_t ret;
1137         u32 cores;
1138
1139         /* Check ibm,arch-vec-5-platform-support and fixup vec5 if required */
1140         prom_check_platform_support();
1141
1142         root = call_prom("open", 1, 1, ADDR("/"));
1143         if (root != 0) {
1144                 /* We need to tell the FW about the number of cores we support.
1145                  *
1146                  * To do that, we count the number of threads on the first core
1147                  * (we assume this is the same for all cores) and use it to
1148                  * divide NR_CPUS.
1149                  */
1150
1151                 cores = DIV_ROUND_UP(NR_CPUS, prom_count_smt_threads());
1152                 prom_printf("Max number of cores passed to firmware: %lu (NR_CPUS = %lu)\n",
1153                             cores, NR_CPUS);
1154
1155                 ibm_architecture_vec.vec5.max_cpus = cpu_to_be32(cores);
1156
1157                 /* try calling the ibm,client-architecture-support method */
1158                 prom_printf("Calling ibm,client-architecture-support...");
1159                 if (call_prom_ret("call-method", 3, 2, &ret,
1160                                   ADDR("ibm,client-architecture-support"),
1161                                   root,
1162                                   ADDR(&ibm_architecture_vec)) == 0) {
1163                         /* the call exists... */
1164                         if (ret)
1165                                 prom_printf("\nWARNING: ibm,client-architecture"
1166                                             "-support call FAILED!\n");
1167                         call_prom("close", 1, 0, root);
1168                         prom_printf(" done\n");
1169                         return;
1170                 }
1171                 call_prom("close", 1, 0, root);
1172                 prom_printf(" not implemented\n");
1173         }
1174
1175 #ifdef __BIG_ENDIAN__
1176         {
1177                 ihandle elfloader;
1178
1179                 /* no ibm,client-architecture-support call, try the old way */
1180                 elfloader = call_prom("open", 1, 1,
1181                                       ADDR("/packages/elf-loader"));
1182                 if (elfloader == 0) {
1183                         prom_printf("couldn't open /packages/elf-loader\n");
1184                         return;
1185                 }
1186                 call_prom("call-method", 3, 1, ADDR("process-elf-header"),
1187                           elfloader, ADDR(&fake_elf));
1188                 call_prom("close", 1, 0, elfloader);
1189         }
1190 #endif /* __BIG_ENDIAN__ */
1191 }
1192 #endif /* #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV) */
1193
1194 /*
1195  * Memory allocation strategy... our layout is normally:
1196  *
1197  *  at 14Mb or more we have vmlinux, then a gap and initrd.  In some
1198  *  rare cases, initrd might end up being before the kernel though.
1199  *  We assume this won't override the final kernel at 0, we have no
1200  *  provision to handle that in this version, but it should hopefully
1201  *  never happen.
1202  *
1203  *  alloc_top is set to the top of RMO, eventually shrink down if the
1204  *  TCEs overlap
1205  *
1206  *  alloc_bottom is set to the top of kernel/initrd
1207  *
1208  *  from there, allocations are done this way : rtas is allocated
1209  *  topmost, and the device-tree is allocated from the bottom. We try
1210  *  to grow the device-tree allocation as we progress. If we can't,
1211  *  then we fail, we don't currently have a facility to restart
1212  *  elsewhere, but that shouldn't be necessary.
1213  *
1214  *  Note that calls to reserve_mem have to be done explicitly, memory
1215  *  allocated with either alloc_up or alloc_down isn't automatically
1216  *  reserved.
1217  */
1218
1219
1220 /*
1221  * Allocates memory in the RMO upward from the kernel/initrd
1222  *
1223  * When align is 0, this is a special case, it means to allocate in place
1224  * at the current location of alloc_bottom or fail (that is basically
1225  * extending the previous allocation). Used for the device-tree flattening
1226  */
1227 static unsigned long __init alloc_up(unsigned long size, unsigned long align)
1228 {
1229         unsigned long base = alloc_bottom;
1230         unsigned long addr = 0;
1231
1232         if (align)
1233                 base = _ALIGN_UP(base, align);
1234         prom_debug("alloc_up(%x, %x)\n", size, align);
1235         if (ram_top == 0)
1236                 prom_panic("alloc_up() called with mem not initialized\n");
1237
1238         if (align)
1239                 base = _ALIGN_UP(alloc_bottom, align);
1240         else
1241                 base = alloc_bottom;
1242
1243         for(; (base + size) <= alloc_top;
1244             base = _ALIGN_UP(base + 0x100000, align)) {
1245                 prom_debug("    trying: 0x%x\n\r", base);
1246                 addr = (unsigned long)prom_claim(base, size, 0);
1247                 if (addr != PROM_ERROR && addr != 0)
1248                         break;
1249                 addr = 0;
1250                 if (align == 0)
1251                         break;
1252         }
1253         if (addr == 0)
1254                 return 0;
1255         alloc_bottom = addr + size;
1256
1257         prom_debug(" -> %x\n", addr);
1258         prom_debug("  alloc_bottom : %x\n", alloc_bottom);
1259         prom_debug("  alloc_top    : %x\n", alloc_top);
1260         prom_debug("  alloc_top_hi : %x\n", alloc_top_high);
1261         prom_debug("  rmo_top      : %x\n", rmo_top);
1262         prom_debug("  ram_top      : %x\n", ram_top);
1263
1264         return addr;
1265 }
1266
1267 /*
1268  * Allocates memory downward, either from top of RMO, or if highmem
1269  * is set, from the top of RAM.  Note that this one doesn't handle
1270  * failures.  It does claim memory if highmem is not set.
1271  */
1272 static unsigned long __init alloc_down(unsigned long size, unsigned long align,
1273                                        int highmem)
1274 {
1275         unsigned long base, addr = 0;
1276
1277         prom_debug("alloc_down(%x, %x, %s)\n", size, align,
1278                    highmem ? "(high)" : "(low)");
1279         if (ram_top == 0)
1280                 prom_panic("alloc_down() called with mem not initialized\n");
1281
1282         if (highmem) {
1283                 /* Carve out storage for the TCE table. */
1284                 addr = _ALIGN_DOWN(alloc_top_high - size, align);
1285                 if (addr <= alloc_bottom)
1286                         return 0;
1287                 /* Will we bump into the RMO ? If yes, check out that we
1288                  * didn't overlap existing allocations there, if we did,
1289                  * we are dead, we must be the first in town !
1290                  */
1291                 if (addr < rmo_top) {
1292                         /* Good, we are first */
1293                         if (alloc_top == rmo_top)
1294                                 alloc_top = rmo_top = addr;
1295                         else
1296                                 return 0;
1297                 }
1298                 alloc_top_high = addr;
1299                 goto bail;
1300         }
1301
1302         base = _ALIGN_DOWN(alloc_top - size, align);
1303         for (; base > alloc_bottom;
1304              base = _ALIGN_DOWN(base - 0x100000, align))  {
1305                 prom_debug("    trying: 0x%x\n\r", base);
1306                 addr = (unsigned long)prom_claim(base, size, 0);
1307                 if (addr != PROM_ERROR && addr != 0)
1308                         break;
1309                 addr = 0;
1310         }
1311         if (addr == 0)
1312                 return 0;
1313         alloc_top = addr;
1314
1315  bail:
1316         prom_debug(" -> %x\n", addr);
1317         prom_debug("  alloc_bottom : %x\n", alloc_bottom);
1318         prom_debug("  alloc_top    : %x\n", alloc_top);
1319         prom_debug("  alloc_top_hi : %x\n", alloc_top_high);
1320         prom_debug("  rmo_top      : %x\n", rmo_top);
1321         prom_debug("  ram_top      : %x\n", ram_top);
1322
1323         return addr;
1324 }
1325
1326 /*
1327  * Parse a "reg" cell
1328  */
1329 static unsigned long __init prom_next_cell(int s, cell_t **cellp)
1330 {
1331         cell_t *p = *cellp;
1332         unsigned long r = 0;
1333
1334         /* Ignore more than 2 cells */
1335         while (s > sizeof(unsigned long) / 4) {
1336                 p++;
1337                 s--;
1338         }
1339         r = be32_to_cpu(*p++);
1340 #ifdef CONFIG_PPC64
1341         if (s > 1) {
1342                 r <<= 32;
1343                 r |= be32_to_cpu(*(p++));
1344         }
1345 #endif
1346         *cellp = p;
1347         return r;
1348 }
1349
1350 /*
1351  * Very dumb function for adding to the memory reserve list, but
1352  * we don't need anything smarter at this point
1353  *
1354  * XXX Eventually check for collisions.  They should NEVER happen.
1355  * If problems seem to show up, it would be a good start to track
1356  * them down.
1357  */
1358 static void __init reserve_mem(u64 base, u64 size)
1359 {
1360         u64 top = base + size;
1361         unsigned long cnt = mem_reserve_cnt;
1362
1363         if (size == 0)
1364                 return;
1365
1366         /* We need to always keep one empty entry so that we
1367          * have our terminator with "size" set to 0 since we are
1368          * dumb and just copy this entire array to the boot params
1369          */
1370         base = _ALIGN_DOWN(base, PAGE_SIZE);
1371         top = _ALIGN_UP(top, PAGE_SIZE);
1372         size = top - base;
1373
1374         if (cnt >= (MEM_RESERVE_MAP_SIZE - 1))
1375                 prom_panic("Memory reserve map exhausted !\n");
1376         mem_reserve_map[cnt].base = cpu_to_be64(base);
1377         mem_reserve_map[cnt].size = cpu_to_be64(size);
1378         mem_reserve_cnt = cnt + 1;
1379 }
1380
1381 /*
1382  * Initialize memory allocation mechanism, parse "memory" nodes and
1383  * obtain that way the top of memory and RMO to setup out local allocator
1384  */
1385 static void __init prom_init_mem(void)
1386 {
1387         phandle node;
1388         char *path, type[64];
1389         unsigned int plen;
1390         cell_t *p, *endp;
1391         __be32 val;
1392         u32 rac, rsc;
1393
1394         /*
1395          * We iterate the memory nodes to find
1396          * 1) top of RMO (first node)
1397          * 2) top of memory
1398          */
1399         val = cpu_to_be32(2);
1400         prom_getprop(prom.root, "#address-cells", &val, sizeof(val));
1401         rac = be32_to_cpu(val);
1402         val = cpu_to_be32(1);
1403         prom_getprop(prom.root, "#size-cells", &val, sizeof(rsc));
1404         rsc = be32_to_cpu(val);
1405         prom_debug("root_addr_cells: %x\n", rac);
1406         prom_debug("root_size_cells: %x\n", rsc);
1407
1408         prom_debug("scanning memory:\n");
1409         path = prom_scratch;
1410
1411         for (node = 0; prom_next_node(&node); ) {
1412                 type[0] = 0;
1413                 prom_getprop(node, "device_type", type, sizeof(type));
1414
1415                 if (type[0] == 0) {
1416                         /*
1417                          * CHRP Longtrail machines have no device_type
1418                          * on the memory node, so check the name instead...
1419                          */
1420                         prom_getprop(node, "name", type, sizeof(type));
1421                 }
1422                 if (strcmp(type, "memory"))
1423                         continue;
1424
1425                 plen = prom_getprop(node, "reg", regbuf, sizeof(regbuf));
1426                 if (plen > sizeof(regbuf)) {
1427                         prom_printf("memory node too large for buffer !\n");
1428                         plen = sizeof(regbuf);
1429                 }
1430                 p = regbuf;
1431                 endp = p + (plen / sizeof(cell_t));
1432
1433 #ifdef DEBUG_PROM
1434                 memset(path, 0, PROM_SCRATCH_SIZE);
1435                 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
1436                 prom_debug("  node %s :\n", path);
1437 #endif /* DEBUG_PROM */
1438
1439                 while ((endp - p) >= (rac + rsc)) {
1440                         unsigned long base, size;
1441
1442                         base = prom_next_cell(rac, &p);
1443                         size = prom_next_cell(rsc, &p);
1444
1445                         if (size == 0)
1446                                 continue;
1447                         prom_debug("    %x %x\n", base, size);
1448                         if (base == 0 && (of_platform & PLATFORM_LPAR))
1449                                 rmo_top = size;
1450                         if ((base + size) > ram_top)
1451                                 ram_top = base + size;
1452                 }
1453         }
1454
1455         alloc_bottom = PAGE_ALIGN((unsigned long)&_end + 0x4000);
1456
1457         /*
1458          * If prom_memory_limit is set we reduce the upper limits *except* for
1459          * alloc_top_high. This must be the real top of RAM so we can put
1460          * TCE's up there.
1461          */
1462
1463         alloc_top_high = ram_top;
1464
1465         if (prom_memory_limit) {
1466                 if (prom_memory_limit <= alloc_bottom) {
1467                         prom_printf("Ignoring mem=%x <= alloc_bottom.\n",
1468                                 prom_memory_limit);
1469                         prom_memory_limit = 0;
1470                 } else if (prom_memory_limit >= ram_top) {
1471                         prom_printf("Ignoring mem=%x >= ram_top.\n",
1472                                 prom_memory_limit);
1473                         prom_memory_limit = 0;
1474                 } else {
1475                         ram_top = prom_memory_limit;
1476                         rmo_top = min(rmo_top, prom_memory_limit);
1477                 }
1478         }
1479
1480         /*
1481          * Setup our top alloc point, that is top of RMO or top of
1482          * segment 0 when running non-LPAR.
1483          * Some RS64 machines have buggy firmware where claims up at
1484          * 1GB fail.  Cap at 768MB as a workaround.
1485          * Since 768MB is plenty of room, and we need to cap to something
1486          * reasonable on 32-bit, cap at 768MB on all machines.
1487          */
1488         if (!rmo_top)
1489                 rmo_top = ram_top;
1490         rmo_top = min(0x30000000ul, rmo_top);
1491         alloc_top = rmo_top;
1492         alloc_top_high = ram_top;
1493
1494         /*
1495          * Check if we have an initrd after the kernel but still inside
1496          * the RMO.  If we do move our bottom point to after it.
1497          */
1498         if (prom_initrd_start &&
1499             prom_initrd_start < rmo_top &&
1500             prom_initrd_end > alloc_bottom)
1501                 alloc_bottom = PAGE_ALIGN(prom_initrd_end);
1502
1503         prom_printf("memory layout at init:\n");
1504         prom_printf("  memory_limit : %x (16 MB aligned)\n", prom_memory_limit);
1505         prom_printf("  alloc_bottom : %x\n", alloc_bottom);
1506         prom_printf("  alloc_top    : %x\n", alloc_top);
1507         prom_printf("  alloc_top_hi : %x\n", alloc_top_high);
1508         prom_printf("  rmo_top      : %x\n", rmo_top);
1509         prom_printf("  ram_top      : %x\n", ram_top);
1510 }
1511
1512 static void __init prom_close_stdin(void)
1513 {
1514         __be32 val;
1515         ihandle stdin;
1516
1517         if (prom_getprop(prom.chosen, "stdin", &val, sizeof(val)) > 0) {
1518                 stdin = be32_to_cpu(val);
1519                 call_prom("close", 1, 0, stdin);
1520         }
1521 }
1522
1523 #ifdef CONFIG_PPC_POWERNV
1524
1525 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
1526 static u64 __initdata prom_opal_base;
1527 static u64 __initdata prom_opal_entry;
1528 #endif
1529
1530 /*
1531  * Allocate room for and instantiate OPAL
1532  */
1533 static void __init prom_instantiate_opal(void)
1534 {
1535         phandle opal_node;
1536         ihandle opal_inst;
1537         u64 base, entry;
1538         u64 size = 0, align = 0x10000;
1539         __be64 val64;
1540         u32 rets[2];
1541
1542         prom_debug("prom_instantiate_opal: start...\n");
1543
1544         opal_node = call_prom("finddevice", 1, 1, ADDR("/ibm,opal"));
1545         prom_debug("opal_node: %x\n", opal_node);
1546         if (!PHANDLE_VALID(opal_node))
1547                 return;
1548
1549         val64 = 0;
1550         prom_getprop(opal_node, "opal-runtime-size", &val64, sizeof(val64));
1551         size = be64_to_cpu(val64);
1552         if (size == 0)
1553                 return;
1554         val64 = 0;
1555         prom_getprop(opal_node, "opal-runtime-alignment", &val64,sizeof(val64));
1556         align = be64_to_cpu(val64);
1557
1558         base = alloc_down(size, align, 0);
1559         if (base == 0) {
1560                 prom_printf("OPAL allocation failed !\n");
1561                 return;
1562         }
1563
1564         opal_inst = call_prom("open", 1, 1, ADDR("/ibm,opal"));
1565         if (!IHANDLE_VALID(opal_inst)) {
1566                 prom_printf("opening opal package failed (%x)\n", opal_inst);
1567                 return;
1568         }
1569
1570         prom_printf("instantiating opal at 0x%x...", base);
1571
1572         if (call_prom_ret("call-method", 4, 3, rets,
1573                           ADDR("load-opal-runtime"),
1574                           opal_inst,
1575                           base >> 32, base & 0xffffffff) != 0
1576             || (rets[0] == 0 && rets[1] == 0)) {
1577                 prom_printf(" failed\n");
1578                 return;
1579         }
1580         entry = (((u64)rets[0]) << 32) | rets[1];
1581
1582         prom_printf(" done\n");
1583
1584         reserve_mem(base, size);
1585
1586         prom_debug("opal base     = 0x%x\n", base);
1587         prom_debug("opal align    = 0x%x\n", align);
1588         prom_debug("opal entry    = 0x%x\n", entry);
1589         prom_debug("opal size     = 0x%x\n", (long)size);
1590
1591         prom_setprop(opal_node, "/ibm,opal", "opal-base-address",
1592                      &base, sizeof(base));
1593         prom_setprop(opal_node, "/ibm,opal", "opal-entry-address",
1594                      &entry, sizeof(entry));
1595
1596 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
1597         prom_opal_base = base;
1598         prom_opal_entry = entry;
1599 #endif
1600         prom_debug("prom_instantiate_opal: end...\n");
1601 }
1602
1603 #endif /* CONFIG_PPC_POWERNV */
1604
1605 /*
1606  * Allocate room for and instantiate RTAS
1607  */
1608 static void __init prom_instantiate_rtas(void)
1609 {
1610         phandle rtas_node;
1611         ihandle rtas_inst;
1612         u32 base, entry = 0;
1613         __be32 val;
1614         u32 size = 0;
1615
1616         prom_debug("prom_instantiate_rtas: start...\n");
1617
1618         rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1619         prom_debug("rtas_node: %x\n", rtas_node);
1620         if (!PHANDLE_VALID(rtas_node))
1621                 return;
1622
1623         val = 0;
1624         prom_getprop(rtas_node, "rtas-size", &val, sizeof(size));
1625         size = be32_to_cpu(val);
1626         if (size == 0)
1627                 return;
1628
1629         base = alloc_down(size, PAGE_SIZE, 0);
1630         if (base == 0)
1631                 prom_panic("Could not allocate memory for RTAS\n");
1632
1633         rtas_inst = call_prom("open", 1, 1, ADDR("/rtas"));
1634         if (!IHANDLE_VALID(rtas_inst)) {
1635                 prom_printf("opening rtas package failed (%x)\n", rtas_inst);
1636                 return;
1637         }
1638
1639         prom_printf("instantiating rtas at 0x%x...", base);
1640
1641         if (call_prom_ret("call-method", 3, 2, &entry,
1642                           ADDR("instantiate-rtas"),
1643                           rtas_inst, base) != 0
1644             || entry == 0) {
1645                 prom_printf(" failed\n");
1646                 return;
1647         }
1648         prom_printf(" done\n");
1649
1650         reserve_mem(base, size);
1651
1652         val = cpu_to_be32(base);
1653         prom_setprop(rtas_node, "/rtas", "linux,rtas-base",
1654                      &val, sizeof(val));
1655         val = cpu_to_be32(entry);
1656         prom_setprop(rtas_node, "/rtas", "linux,rtas-entry",
1657                      &val, sizeof(val));
1658
1659         /* Check if it supports "query-cpu-stopped-state" */
1660         if (prom_getprop(rtas_node, "query-cpu-stopped-state",
1661                          &val, sizeof(val)) != PROM_ERROR)
1662                 rtas_has_query_cpu_stopped = true;
1663
1664         prom_debug("rtas base     = 0x%x\n", base);
1665         prom_debug("rtas entry    = 0x%x\n", entry);
1666         prom_debug("rtas size     = 0x%x\n", (long)size);
1667
1668         prom_debug("prom_instantiate_rtas: end...\n");
1669 }
1670
1671 #ifdef CONFIG_PPC64
1672 /*
1673  * Allocate room for and instantiate Stored Measurement Log (SML)
1674  */
1675 static void __init prom_instantiate_sml(void)
1676 {
1677         phandle ibmvtpm_node;
1678         ihandle ibmvtpm_inst;
1679         u32 entry = 0, size = 0, succ = 0;
1680         u64 base;
1681         __be32 val;
1682
1683         prom_debug("prom_instantiate_sml: start...\n");
1684
1685         ibmvtpm_node = call_prom("finddevice", 1, 1, ADDR("/vdevice/vtpm"));
1686         prom_debug("ibmvtpm_node: %x\n", ibmvtpm_node);
1687         if (!PHANDLE_VALID(ibmvtpm_node))
1688                 return;
1689
1690         ibmvtpm_inst = call_prom("open", 1, 1, ADDR("/vdevice/vtpm"));
1691         if (!IHANDLE_VALID(ibmvtpm_inst)) {
1692                 prom_printf("opening vtpm package failed (%x)\n", ibmvtpm_inst);
1693                 return;
1694         }
1695
1696         if (prom_getprop(ibmvtpm_node, "ibm,sml-efi-reformat-supported",
1697                          &val, sizeof(val)) != PROM_ERROR) {
1698                 if (call_prom_ret("call-method", 2, 2, &succ,
1699                                   ADDR("reformat-sml-to-efi-alignment"),
1700                                   ibmvtpm_inst) != 0 || succ == 0) {
1701                         prom_printf("Reformat SML to EFI alignment failed\n");
1702                         return;
1703                 }
1704
1705                 if (call_prom_ret("call-method", 2, 2, &size,
1706                                   ADDR("sml-get-allocated-size"),
1707                                   ibmvtpm_inst) != 0 || size == 0) {
1708                         prom_printf("SML get allocated size failed\n");
1709                         return;
1710                 }
1711         } else {
1712                 if (call_prom_ret("call-method", 2, 2, &size,
1713                                   ADDR("sml-get-handover-size"),
1714                                   ibmvtpm_inst) != 0 || size == 0) {
1715                         prom_printf("SML get handover size failed\n");
1716                         return;
1717                 }
1718         }
1719
1720         base = alloc_down(size, PAGE_SIZE, 0);
1721         if (base == 0)
1722                 prom_panic("Could not allocate memory for sml\n");
1723
1724         prom_printf("instantiating sml at 0x%x...", base);
1725
1726         memset((void *)base, 0, size);
1727
1728         if (call_prom_ret("call-method", 4, 2, &entry,
1729                           ADDR("sml-handover"),
1730                           ibmvtpm_inst, size, base) != 0 || entry == 0) {
1731                 prom_printf("SML handover failed\n");
1732                 return;
1733         }
1734         prom_printf(" done\n");
1735
1736         reserve_mem(base, size);
1737
1738         prom_setprop(ibmvtpm_node, "/vdevice/vtpm", "linux,sml-base",
1739                      &base, sizeof(base));
1740         prom_setprop(ibmvtpm_node, "/vdevice/vtpm", "linux,sml-size",
1741                      &size, sizeof(size));
1742
1743         prom_debug("sml base     = 0x%x\n", base);
1744         prom_debug("sml size     = 0x%x\n", (long)size);
1745
1746         prom_debug("prom_instantiate_sml: end...\n");
1747 }
1748
1749 /*
1750  * Allocate room for and initialize TCE tables
1751  */
1752 #ifdef __BIG_ENDIAN__
1753 static void __init prom_initialize_tce_table(void)
1754 {
1755         phandle node;
1756         ihandle phb_node;
1757         char compatible[64], type[64], model[64];
1758         char *path = prom_scratch;
1759         u64 base, align;
1760         u32 minalign, minsize;
1761         u64 tce_entry, *tce_entryp;
1762         u64 local_alloc_top, local_alloc_bottom;
1763         u64 i;
1764
1765         if (prom_iommu_off)
1766                 return;
1767
1768         prom_debug("starting prom_initialize_tce_table\n");
1769
1770         /* Cache current top of allocs so we reserve a single block */
1771         local_alloc_top = alloc_top_high;
1772         local_alloc_bottom = local_alloc_top;
1773
1774         /* Search all nodes looking for PHBs. */
1775         for (node = 0; prom_next_node(&node); ) {
1776                 compatible[0] = 0;
1777                 type[0] = 0;
1778                 model[0] = 0;
1779                 prom_getprop(node, "compatible",
1780                              compatible, sizeof(compatible));
1781                 prom_getprop(node, "device_type", type, sizeof(type));
1782                 prom_getprop(node, "model", model, sizeof(model));
1783
1784                 if ((type[0] == 0) || (strstr(type, "pci") == NULL))
1785                         continue;
1786
1787                 /* Keep the old logic intact to avoid regression. */
1788                 if (compatible[0] != 0) {
1789                         if ((strstr(compatible, "python") == NULL) &&
1790                             (strstr(compatible, "Speedwagon") == NULL) &&
1791                             (strstr(compatible, "Winnipeg") == NULL))
1792                                 continue;
1793                 } else if (model[0] != 0) {
1794                         if ((strstr(model, "ython") == NULL) &&
1795                             (strstr(model, "peedwagon") == NULL) &&
1796                             (strstr(model, "innipeg") == NULL))
1797                                 continue;
1798                 }
1799
1800                 if (prom_getprop(node, "tce-table-minalign", &minalign,
1801                                  sizeof(minalign)) == PROM_ERROR)
1802                         minalign = 0;
1803                 if (prom_getprop(node, "tce-table-minsize", &minsize,
1804                                  sizeof(minsize)) == PROM_ERROR)
1805                         minsize = 4UL << 20;
1806
1807                 /*
1808                  * Even though we read what OF wants, we just set the table
1809                  * size to 4 MB.  This is enough to map 2GB of PCI DMA space.
1810                  * By doing this, we avoid the pitfalls of trying to DMA to
1811                  * MMIO space and the DMA alias hole.
1812                  *
1813                  * On POWER4, firmware sets the TCE region by assuming
1814                  * each TCE table is 8MB. Using this memory for anything
1815                  * else will impact performance, so we always allocate 8MB.
1816                  * Anton
1817                  */
1818                 if (pvr_version_is(PVR_POWER4) || pvr_version_is(PVR_POWER4p))
1819                         minsize = 8UL << 20;
1820                 else
1821                         minsize = 4UL << 20;
1822
1823                 /* Align to the greater of the align or size */
1824                 align = max(minalign, minsize);
1825                 base = alloc_down(minsize, align, 1);
1826                 if (base == 0)
1827                         prom_panic("ERROR, cannot find space for TCE table.\n");
1828                 if (base < local_alloc_bottom)
1829                         local_alloc_bottom = base;
1830
1831                 /* It seems OF doesn't null-terminate the path :-( */
1832                 memset(path, 0, PROM_SCRATCH_SIZE);
1833                 /* Call OF to setup the TCE hardware */
1834                 if (call_prom("package-to-path", 3, 1, node,
1835                               path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) {
1836                         prom_printf("package-to-path failed\n");
1837                 }
1838
1839                 /* Save away the TCE table attributes for later use. */
1840                 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base));
1841                 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize));
1842
1843                 prom_debug("TCE table: %s\n", path);
1844                 prom_debug("\tnode = 0x%x\n", node);
1845                 prom_debug("\tbase = 0x%x\n", base);
1846                 prom_debug("\tsize = 0x%x\n", minsize);
1847
1848                 /* Initialize the table to have a one-to-one mapping
1849                  * over the allocated size.
1850                  */
1851                 tce_entryp = (u64 *)base;
1852                 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) {
1853                         tce_entry = (i << PAGE_SHIFT);
1854                         tce_entry |= 0x3;
1855                         *tce_entryp = tce_entry;
1856                 }
1857
1858                 prom_printf("opening PHB %s", path);
1859                 phb_node = call_prom("open", 1, 1, path);
1860                 if (phb_node == 0)
1861                         prom_printf("... failed\n");
1862                 else
1863                         prom_printf("... done\n");
1864
1865                 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"),
1866                           phb_node, -1, minsize,
1867                           (u32) base, (u32) (base >> 32));
1868                 call_prom("close", 1, 0, phb_node);
1869         }
1870
1871         reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom);
1872
1873         /* These are only really needed if there is a memory limit in
1874          * effect, but we don't know so export them always. */
1875         prom_tce_alloc_start = local_alloc_bottom;
1876         prom_tce_alloc_end = local_alloc_top;
1877
1878         /* Flag the first invalid entry */
1879         prom_debug("ending prom_initialize_tce_table\n");
1880 }
1881 #endif /* __BIG_ENDIAN__ */
1882 #endif /* CONFIG_PPC64 */
1883
1884 /*
1885  * With CHRP SMP we need to use the OF to start the other processors.
1886  * We can't wait until smp_boot_cpus (the OF is trashed by then)
1887  * so we have to put the processors into a holding pattern controlled
1888  * by the kernel (not OF) before we destroy the OF.
1889  *
1890  * This uses a chunk of low memory, puts some holding pattern
1891  * code there and sends the other processors off to there until
1892  * smp_boot_cpus tells them to do something.  The holding pattern
1893  * checks that address until its cpu # is there, when it is that
1894  * cpu jumps to __secondary_start().  smp_boot_cpus() takes care
1895  * of setting those values.
1896  *
1897  * We also use physical address 0x4 here to tell when a cpu
1898  * is in its holding pattern code.
1899  *
1900  * -- Cort
1901  */
1902 /*
1903  * We want to reference the copy of __secondary_hold_* in the
1904  * 0 - 0x100 address range
1905  */
1906 #define LOW_ADDR(x)     (((unsigned long) &(x)) & 0xff)
1907
1908 static void __init prom_hold_cpus(void)
1909 {
1910         unsigned long i;
1911         phandle node;
1912         char type[64];
1913         unsigned long *spinloop
1914                 = (void *) LOW_ADDR(__secondary_hold_spinloop);
1915         unsigned long *acknowledge
1916                 = (void *) LOW_ADDR(__secondary_hold_acknowledge);
1917         unsigned long secondary_hold = LOW_ADDR(__secondary_hold);
1918
1919         /*
1920          * On pseries, if RTAS supports "query-cpu-stopped-state",
1921          * we skip this stage, the CPUs will be started by the
1922          * kernel using RTAS.
1923          */
1924         if ((of_platform == PLATFORM_PSERIES ||
1925              of_platform == PLATFORM_PSERIES_LPAR) &&
1926             rtas_has_query_cpu_stopped) {
1927                 prom_printf("prom_hold_cpus: skipped\n");
1928                 return;
1929         }
1930
1931         prom_debug("prom_hold_cpus: start...\n");
1932         prom_debug("    1) spinloop       = 0x%x\n", (unsigned long)spinloop);
1933         prom_debug("    1) *spinloop      = 0x%x\n", *spinloop);
1934         prom_debug("    1) acknowledge    = 0x%x\n",
1935                    (unsigned long)acknowledge);
1936         prom_debug("    1) *acknowledge   = 0x%x\n", *acknowledge);
1937         prom_debug("    1) secondary_hold = 0x%x\n", secondary_hold);
1938
1939         /* Set the common spinloop variable, so all of the secondary cpus
1940          * will block when they are awakened from their OF spinloop.
1941          * This must occur for both SMP and non SMP kernels, since OF will
1942          * be trashed when we move the kernel.
1943          */
1944         *spinloop = 0;
1945
1946         /* look for cpus */
1947         for (node = 0; prom_next_node(&node); ) {
1948                 unsigned int cpu_no;
1949                 __be32 reg;
1950
1951                 type[0] = 0;
1952                 prom_getprop(node, "device_type", type, sizeof(type));
1953                 if (strcmp(type, "cpu") != 0)
1954                         continue;
1955
1956                 /* Skip non-configured cpus. */
1957                 if (prom_getprop(node, "status", type, sizeof(type)) > 0)
1958                         if (strcmp(type, "okay") != 0)
1959                                 continue;
1960
1961                 reg = cpu_to_be32(-1); /* make sparse happy */
1962                 prom_getprop(node, "reg", &reg, sizeof(reg));
1963                 cpu_no = be32_to_cpu(reg);
1964
1965                 prom_debug("cpu hw idx   = %lu\n", cpu_no);
1966
1967                 /* Init the acknowledge var which will be reset by
1968                  * the secondary cpu when it awakens from its OF
1969                  * spinloop.
1970                  */
1971                 *acknowledge = (unsigned long)-1;
1972
1973                 if (cpu_no != prom.cpu) {
1974                         /* Primary Thread of non-boot cpu or any thread */
1975                         prom_printf("starting cpu hw idx %lu... ", cpu_no);
1976                         call_prom("start-cpu", 3, 0, node,
1977                                   secondary_hold, cpu_no);
1978
1979                         for (i = 0; (i < 100000000) &&
1980                              (*acknowledge == ((unsigned long)-1)); i++ )
1981                                 mb();
1982
1983                         if (*acknowledge == cpu_no)
1984                                 prom_printf("done\n");
1985                         else
1986                                 prom_printf("failed: %x\n", *acknowledge);
1987                 }
1988 #ifdef CONFIG_SMP
1989                 else
1990                         prom_printf("boot cpu hw idx %lu\n", cpu_no);
1991 #endif /* CONFIG_SMP */
1992         }
1993
1994         prom_debug("prom_hold_cpus: end...\n");
1995 }
1996
1997
1998 static void __init prom_init_client_services(unsigned long pp)
1999 {
2000         /* Get a handle to the prom entry point before anything else */
2001         prom_entry = pp;
2002
2003         /* get a handle for the stdout device */
2004         prom.chosen = call_prom("finddevice", 1, 1, ADDR("/chosen"));
2005         if (!PHANDLE_VALID(prom.chosen))
2006                 prom_panic("cannot find chosen"); /* msg won't be printed :( */
2007
2008         /* get device tree root */
2009         prom.root = call_prom("finddevice", 1, 1, ADDR("/"));
2010         if (!PHANDLE_VALID(prom.root))
2011                 prom_panic("cannot find device tree root"); /* msg won't be printed :( */
2012
2013         prom.mmumap = 0;
2014 }
2015
2016 #ifdef CONFIG_PPC32
2017 /*
2018  * For really old powermacs, we need to map things we claim.
2019  * For that, we need the ihandle of the mmu.
2020  * Also, on the longtrail, we need to work around other bugs.
2021  */
2022 static void __init prom_find_mmu(void)
2023 {
2024         phandle oprom;
2025         char version[64];
2026
2027         oprom = call_prom("finddevice", 1, 1, ADDR("/openprom"));
2028         if (!PHANDLE_VALID(oprom))
2029                 return;
2030         if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0)
2031                 return;
2032         version[sizeof(version) - 1] = 0;
2033         /* XXX might need to add other versions here */
2034         if (strcmp(version, "Open Firmware, 1.0.5") == 0)
2035                 of_workarounds = OF_WA_CLAIM;
2036         else if (strncmp(version, "FirmWorks,3.", 12) == 0) {
2037                 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL;
2038                 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim");
2039         } else
2040                 return;
2041         prom.memory = call_prom("open", 1, 1, ADDR("/memory"));
2042         prom_getprop(prom.chosen, "mmu", &prom.mmumap,
2043                      sizeof(prom.mmumap));
2044         prom.mmumap = be32_to_cpu(prom.mmumap);
2045         if (!IHANDLE_VALID(prom.memory) || !IHANDLE_VALID(prom.mmumap))
2046                 of_workarounds &= ~OF_WA_CLAIM;         /* hmmm */
2047 }
2048 #else
2049 #define prom_find_mmu()
2050 #endif
2051
2052 static void __init prom_init_stdout(void)
2053 {
2054         char *path = of_stdout_device;
2055         char type[16];
2056         phandle stdout_node;
2057         __be32 val;
2058
2059         if (prom_getprop(prom.chosen, "stdout", &val, sizeof(val)) <= 0)
2060                 prom_panic("cannot find stdout");
2061
2062         prom.stdout = be32_to_cpu(val);
2063
2064         /* Get the full OF pathname of the stdout device */
2065         memset(path, 0, 256);
2066         call_prom("instance-to-path", 3, 1, prom.stdout, path, 255);
2067         prom_printf("OF stdout device is: %s\n", of_stdout_device);
2068         prom_setprop(prom.chosen, "/chosen", "linux,stdout-path",
2069                      path, strlen(path) + 1);
2070
2071         /* instance-to-package fails on PA-Semi */
2072         stdout_node = call_prom("instance-to-package", 1, 1, prom.stdout);
2073         if (stdout_node != PROM_ERROR) {
2074                 val = cpu_to_be32(stdout_node);
2075                 prom_setprop(prom.chosen, "/chosen", "linux,stdout-package",
2076                              &val, sizeof(val));
2077
2078                 /* If it's a display, note it */
2079                 memset(type, 0, sizeof(type));
2080                 prom_getprop(stdout_node, "device_type", type, sizeof(type));
2081                 if (strcmp(type, "display") == 0)
2082                         prom_setprop(stdout_node, path, "linux,boot-display", NULL, 0);
2083         }
2084 }
2085
2086 static int __init prom_find_machine_type(void)
2087 {
2088         char compat[256];
2089         int len, i = 0;
2090 #ifdef CONFIG_PPC64
2091         phandle rtas;
2092         int x;
2093 #endif
2094
2095         /* Look for a PowerMac or a Cell */
2096         len = prom_getprop(prom.root, "compatible",
2097                            compat, sizeof(compat)-1);
2098         if (len > 0) {
2099                 compat[len] = 0;
2100                 while (i < len) {
2101                         char *p = &compat[i];
2102                         int sl = strlen(p);
2103                         if (sl == 0)
2104                                 break;
2105                         if (strstr(p, "Power Macintosh") ||
2106                             strstr(p, "MacRISC"))
2107                                 return PLATFORM_POWERMAC;
2108 #ifdef CONFIG_PPC64
2109                         /* We must make sure we don't detect the IBM Cell
2110                          * blades as pSeries due to some firmware issues,
2111                          * so we do it here.
2112                          */
2113                         if (strstr(p, "IBM,CBEA") ||
2114                             strstr(p, "IBM,CPBW-1.0"))
2115                                 return PLATFORM_GENERIC;
2116 #endif /* CONFIG_PPC64 */
2117                         i += sl + 1;
2118                 }
2119         }
2120 #ifdef CONFIG_PPC64
2121         /* Try to detect OPAL */
2122         if (PHANDLE_VALID(call_prom("finddevice", 1, 1, ADDR("/ibm,opal"))))
2123                 return PLATFORM_OPAL;
2124
2125         /* Try to figure out if it's an IBM pSeries or any other
2126          * PAPR compliant platform. We assume it is if :
2127          *  - /device_type is "chrp" (please, do NOT use that for future
2128          *    non-IBM designs !
2129          *  - it has /rtas
2130          */
2131         len = prom_getprop(prom.root, "device_type",
2132                            compat, sizeof(compat)-1);
2133         if (len <= 0)
2134                 return PLATFORM_GENERIC;
2135         if (strcmp(compat, "chrp"))
2136                 return PLATFORM_GENERIC;
2137
2138         /* Default to pSeries. We need to know if we are running LPAR */
2139         rtas = call_prom("finddevice", 1, 1, ADDR("/rtas"));
2140         if (!PHANDLE_VALID(rtas))
2141                 return PLATFORM_GENERIC;
2142         x = prom_getproplen(rtas, "ibm,hypertas-functions");
2143         if (x != PROM_ERROR) {
2144                 prom_debug("Hypertas detected, assuming LPAR !\n");
2145                 return PLATFORM_PSERIES_LPAR;
2146         }
2147         return PLATFORM_PSERIES;
2148 #else
2149         return PLATFORM_GENERIC;
2150 #endif
2151 }
2152
2153 static int __init prom_set_color(ihandle ih, int i, int r, int g, int b)
2154 {
2155         return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r);
2156 }
2157
2158 /*
2159  * If we have a display that we don't know how to drive,
2160  * we will want to try to execute OF's open method for it
2161  * later.  However, OF will probably fall over if we do that
2162  * we've taken over the MMU.
2163  * So we check whether we will need to open the display,
2164  * and if so, open it now.
2165  */
2166 static void __init prom_check_displays(void)
2167 {
2168         char type[16], *path;
2169         phandle node;
2170         ihandle ih;
2171         int i;
2172
2173         static unsigned char default_colors[] = {
2174                 0x00, 0x00, 0x00,
2175                 0x00, 0x00, 0xaa,
2176                 0x00, 0xaa, 0x00,
2177                 0x00, 0xaa, 0xaa,
2178                 0xaa, 0x00, 0x00,
2179                 0xaa, 0x00, 0xaa,
2180                 0xaa, 0xaa, 0x00,
2181                 0xaa, 0xaa, 0xaa,
2182                 0x55, 0x55, 0x55,
2183                 0x55, 0x55, 0xff,
2184                 0x55, 0xff, 0x55,
2185                 0x55, 0xff, 0xff,
2186                 0xff, 0x55, 0x55,
2187                 0xff, 0x55, 0xff,
2188                 0xff, 0xff, 0x55,
2189                 0xff, 0xff, 0xff
2190         };
2191         const unsigned char *clut;
2192
2193         prom_debug("Looking for displays\n");
2194         for (node = 0; prom_next_node(&node); ) {
2195                 memset(type, 0, sizeof(type));
2196                 prom_getprop(node, "device_type", type, sizeof(type));
2197                 if (strcmp(type, "display") != 0)
2198                         continue;
2199
2200                 /* It seems OF doesn't null-terminate the path :-( */
2201                 path = prom_scratch;
2202                 memset(path, 0, PROM_SCRATCH_SIZE);
2203
2204                 /*
2205                  * leave some room at the end of the path for appending extra
2206                  * arguments
2207                  */
2208                 if (call_prom("package-to-path", 3, 1, node, path,
2209                               PROM_SCRATCH_SIZE-10) == PROM_ERROR)
2210                         continue;
2211                 prom_printf("found display   : %s, opening... ", path);
2212
2213                 ih = call_prom("open", 1, 1, path);
2214                 if (ih == 0) {
2215                         prom_printf("failed\n");
2216                         continue;
2217                 }
2218
2219                 /* Success */
2220                 prom_printf("done\n");
2221                 prom_setprop(node, path, "linux,opened", NULL, 0);
2222
2223                 /* Setup a usable color table when the appropriate
2224                  * method is available. Should update this to set-colors */
2225                 clut = default_colors;
2226                 for (i = 0; i < 16; i++, clut += 3)
2227                         if (prom_set_color(ih, i, clut[0], clut[1],
2228                                            clut[2]) != 0)
2229                                 break;
2230
2231 #ifdef CONFIG_LOGO_LINUX_CLUT224
2232                 clut = PTRRELOC(logo_linux_clut224.clut);
2233                 for (i = 0; i < logo_linux_clut224.clutsize; i++, clut += 3)
2234                         if (prom_set_color(ih, i + 32, clut[0], clut[1],
2235                                            clut[2]) != 0)
2236                                 break;
2237 #endif /* CONFIG_LOGO_LINUX_CLUT224 */
2238
2239 #ifdef CONFIG_PPC_EARLY_DEBUG_BOOTX
2240                 if (prom_getprop(node, "linux,boot-display", NULL, 0) !=
2241                     PROM_ERROR) {
2242                         u32 width, height, pitch, addr;
2243
2244                         prom_printf("Setting btext !\n");
2245                         prom_getprop(node, "width", &width, 4);
2246                         prom_getprop(node, "height", &height, 4);
2247                         prom_getprop(node, "linebytes", &pitch, 4);
2248                         prom_getprop(node, "address", &addr, 4);
2249                         prom_printf("W=%d H=%d LB=%d addr=0x%x\n",
2250                                     width, height, pitch, addr);
2251                         btext_setup_display(width, height, 8, pitch, addr);
2252                 }
2253 #endif /* CONFIG_PPC_EARLY_DEBUG_BOOTX */
2254         }
2255 }
2256
2257
2258 /* Return (relocated) pointer to this much memory: moves initrd if reqd. */
2259 static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end,
2260                               unsigned long needed, unsigned long align)
2261 {
2262         void *ret;
2263
2264         *mem_start = _ALIGN(*mem_start, align);
2265         while ((*mem_start + needed) > *mem_end) {
2266                 unsigned long room, chunk;
2267
2268                 prom_debug("Chunk exhausted, claiming more at %x...\n",
2269                            alloc_bottom);
2270                 room = alloc_top - alloc_bottom;
2271                 if (room > DEVTREE_CHUNK_SIZE)
2272                         room = DEVTREE_CHUNK_SIZE;
2273                 if (room < PAGE_SIZE)
2274                         prom_panic("No memory for flatten_device_tree "
2275                                    "(no room)\n");
2276                 chunk = alloc_up(room, 0);
2277                 if (chunk == 0)
2278                         prom_panic("No memory for flatten_device_tree "
2279                                    "(claim failed)\n");
2280                 *mem_end = chunk + room;
2281         }
2282
2283         ret = (void *)*mem_start;
2284         *mem_start += needed;
2285
2286         return ret;
2287 }
2288
2289 #define dt_push_token(token, mem_start, mem_end) do {                   \
2290                 void *room = make_room(mem_start, mem_end, 4, 4);       \
2291                 *(__be32 *)room = cpu_to_be32(token);                   \
2292         } while(0)
2293
2294 static unsigned long __init dt_find_string(char *str)
2295 {
2296         char *s, *os;
2297
2298         s = os = (char *)dt_string_start;
2299         s += 4;
2300         while (s <  (char *)dt_string_end) {
2301                 if (strcmp(s, str) == 0)
2302                         return s - os;
2303                 s += strlen(s) + 1;
2304         }
2305         return 0;
2306 }
2307
2308 /*
2309  * The Open Firmware 1275 specification states properties must be 31 bytes or
2310  * less, however not all firmwares obey this. Make it 64 bytes to be safe.
2311  */
2312 #define MAX_PROPERTY_NAME 64
2313
2314 static void __init scan_dt_build_strings(phandle node,
2315                                          unsigned long *mem_start,
2316                                          unsigned long *mem_end)
2317 {
2318         char *prev_name, *namep, *sstart;
2319         unsigned long soff;
2320         phandle child;
2321
2322         sstart =  (char *)dt_string_start;
2323
2324         /* get and store all property names */
2325         prev_name = "";
2326         for (;;) {
2327                 /* 64 is max len of name including nul. */
2328                 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1);
2329                 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) {
2330                         /* No more nodes: unwind alloc */
2331                         *mem_start = (unsigned long)namep;
2332                         break;
2333                 }
2334
2335                 /* skip "name" */
2336                 if (strcmp(namep, "name") == 0) {
2337                         *mem_start = (unsigned long)namep;
2338                         prev_name = "name";
2339                         continue;
2340                 }
2341                 /* get/create string entry */
2342                 soff = dt_find_string(namep);
2343                 if (soff != 0) {
2344                         *mem_start = (unsigned long)namep;
2345                         namep = sstart + soff;
2346                 } else {
2347                         /* Trim off some if we can */
2348                         *mem_start = (unsigned long)namep + strlen(namep) + 1;
2349                         dt_string_end = *mem_start;
2350                 }
2351                 prev_name = namep;
2352         }
2353
2354         /* do all our children */
2355         child = call_prom("child", 1, 1, node);
2356         while (child != 0) {
2357                 scan_dt_build_strings(child, mem_start, mem_end);
2358                 child = call_prom("peer", 1, 1, child);
2359         }
2360 }
2361
2362 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
2363                                         unsigned long *mem_end)
2364 {
2365         phandle child;
2366         char *namep, *prev_name, *sstart, *p, *ep, *lp, *path;
2367         unsigned long soff;
2368         unsigned char *valp;
2369         static char pname[MAX_PROPERTY_NAME];
2370         int l, room, has_phandle = 0;
2371
2372         dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end);
2373
2374         /* get the node's full name */
2375         namep = (char *)*mem_start;
2376         room = *mem_end - *mem_start;
2377         if (room > 255)
2378                 room = 255;
2379         l = call_prom("package-to-path", 3, 1, node, namep, room);
2380         if (l >= 0) {
2381                 /* Didn't fit?  Get more room. */
2382                 if (l >= room) {
2383                         if (l >= *mem_end - *mem_start)
2384                                 namep = make_room(mem_start, mem_end, l+1, 1);
2385                         call_prom("package-to-path", 3, 1, node, namep, l);
2386                 }
2387                 namep[l] = '\0';
2388
2389                 /* Fixup an Apple bug where they have bogus \0 chars in the
2390                  * middle of the path in some properties, and extract
2391                  * the unit name (everything after the last '/').
2392                  */
2393                 for (lp = p = namep, ep = namep + l; p < ep; p++) {
2394                         if (*p == '/')
2395                                 lp = namep;
2396                         else if (*p != 0)
2397                                 *lp++ = *p;
2398                 }
2399                 *lp = 0;
2400                 *mem_start = _ALIGN((unsigned long)lp + 1, 4);
2401         }
2402
2403         /* get it again for debugging */
2404         path = prom_scratch;
2405         memset(path, 0, PROM_SCRATCH_SIZE);
2406         call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
2407
2408         /* get and store all properties */
2409         prev_name = "";
2410         sstart = (char *)dt_string_start;
2411         for (;;) {
2412                 if (call_prom("nextprop", 3, 1, node, prev_name,
2413                               pname) != 1)
2414                         break;
2415
2416                 /* skip "name" */
2417                 if (strcmp(pname, "name") == 0) {
2418                         prev_name = "name";
2419                         continue;
2420                 }
2421
2422                 /* find string offset */
2423                 soff = dt_find_string(pname);
2424                 if (soff == 0) {
2425                         prom_printf("WARNING: Can't find string index for"
2426                                     " <%s>, node %s\n", pname, path);
2427                         break;
2428                 }
2429                 prev_name = sstart + soff;
2430
2431                 /* get length */
2432                 l = call_prom("getproplen", 2, 1, node, pname);
2433
2434                 /* sanity checks */
2435                 if (l == PROM_ERROR)
2436                         continue;
2437
2438                 /* push property head */
2439                 dt_push_token(OF_DT_PROP, mem_start, mem_end);
2440                 dt_push_token(l, mem_start, mem_end);
2441                 dt_push_token(soff, mem_start, mem_end);
2442
2443                 /* push property content */
2444                 valp = make_room(mem_start, mem_end, l, 4);
2445                 call_prom("getprop", 4, 1, node, pname, valp, l);
2446                 *mem_start = _ALIGN(*mem_start, 4);
2447
2448                 if (!strcmp(pname, "phandle"))
2449                         has_phandle = 1;
2450         }
2451
2452         /* Add a "linux,phandle" property if no "phandle" property already
2453          * existed (can happen with OPAL)
2454          */
2455         if (!has_phandle) {
2456                 soff = dt_find_string("linux,phandle");
2457                 if (soff == 0)
2458                         prom_printf("WARNING: Can't find string index for"
2459                                     " <linux-phandle> node %s\n", path);
2460                 else {
2461                         dt_push_token(OF_DT_PROP, mem_start, mem_end);
2462                         dt_push_token(4, mem_start, mem_end);
2463                         dt_push_token(soff, mem_start, mem_end);
2464                         valp = make_room(mem_start, mem_end, 4, 4);
2465                         *(__be32 *)valp = cpu_to_be32(node);
2466                 }
2467         }
2468
2469         /* do all our children */
2470         child = call_prom("child", 1, 1, node);
2471         while (child != 0) {
2472                 scan_dt_build_struct(child, mem_start, mem_end);
2473                 child = call_prom("peer", 1, 1, child);
2474         }
2475
2476         dt_push_token(OF_DT_END_NODE, mem_start, mem_end);
2477 }
2478
2479 static void __init flatten_device_tree(void)
2480 {
2481         phandle root;
2482         unsigned long mem_start, mem_end, room;
2483         struct boot_param_header *hdr;
2484         char *namep;
2485         u64 *rsvmap;
2486
2487         /*
2488          * Check how much room we have between alloc top & bottom (+/- a
2489          * few pages), crop to 1MB, as this is our "chunk" size
2490          */
2491         room = alloc_top - alloc_bottom - 0x4000;
2492         if (room > DEVTREE_CHUNK_SIZE)
2493                 room = DEVTREE_CHUNK_SIZE;
2494         prom_debug("starting device tree allocs at %x\n", alloc_bottom);
2495
2496         /* Now try to claim that */
2497         mem_start = (unsigned long)alloc_up(room, PAGE_SIZE);
2498         if (mem_start == 0)
2499                 prom_panic("Can't allocate initial device-tree chunk\n");
2500         mem_end = mem_start + room;
2501
2502         /* Get root of tree */
2503         root = call_prom("peer", 1, 1, (phandle)0);
2504         if (root == (phandle)0)
2505                 prom_panic ("couldn't get device tree root\n");
2506
2507         /* Build header and make room for mem rsv map */
2508         mem_start = _ALIGN(mem_start, 4);
2509         hdr = make_room(&mem_start, &mem_end,
2510                         sizeof(struct boot_param_header), 4);
2511         dt_header_start = (unsigned long)hdr;
2512         rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8);
2513
2514         /* Start of strings */
2515         mem_start = PAGE_ALIGN(mem_start);
2516         dt_string_start = mem_start;
2517         mem_start += 4; /* hole */
2518
2519         /* Add "linux,phandle" in there, we'll need it */
2520         namep = make_room(&mem_start, &mem_end, 16, 1);
2521         strcpy(namep, "linux,phandle");
2522         mem_start = (unsigned long)namep + strlen(namep) + 1;
2523
2524         /* Build string array */
2525         prom_printf("Building dt strings...\n");
2526         scan_dt_build_strings(root, &mem_start, &mem_end);
2527         dt_string_end = mem_start;
2528
2529         /* Build structure */
2530         mem_start = PAGE_ALIGN(mem_start);
2531         dt_struct_start = mem_start;
2532         prom_printf("Building dt structure...\n");
2533         scan_dt_build_struct(root, &mem_start, &mem_end);
2534         dt_push_token(OF_DT_END, &mem_start, &mem_end);
2535         dt_struct_end = PAGE_ALIGN(mem_start);
2536
2537         /* Finish header */
2538         hdr->boot_cpuid_phys = cpu_to_be32(prom.cpu);
2539         hdr->magic = cpu_to_be32(OF_DT_HEADER);
2540         hdr->totalsize = cpu_to_be32(dt_struct_end - dt_header_start);
2541         hdr->off_dt_struct = cpu_to_be32(dt_struct_start - dt_header_start);
2542         hdr->off_dt_strings = cpu_to_be32(dt_string_start - dt_header_start);
2543         hdr->dt_strings_size = cpu_to_be32(dt_string_end - dt_string_start);
2544         hdr->off_mem_rsvmap = cpu_to_be32(((unsigned long)rsvmap) - dt_header_start);
2545         hdr->version = cpu_to_be32(OF_DT_VERSION);
2546         /* Version 16 is not backward compatible */
2547         hdr->last_comp_version = cpu_to_be32(0x10);
2548
2549         /* Copy the reserve map in */
2550         memcpy(rsvmap, mem_reserve_map, sizeof(mem_reserve_map));
2551
2552 #ifdef DEBUG_PROM
2553         {
2554                 int i;
2555                 prom_printf("reserved memory map:\n");
2556                 for (i = 0; i < mem_reserve_cnt; i++)
2557                         prom_printf("  %x - %x\n",
2558                                     be64_to_cpu(mem_reserve_map[i].base),
2559                                     be64_to_cpu(mem_reserve_map[i].size));
2560         }
2561 #endif
2562         /* Bump mem_reserve_cnt to cause further reservations to fail
2563          * since it's too late.
2564          */
2565         mem_reserve_cnt = MEM_RESERVE_MAP_SIZE;
2566
2567         prom_printf("Device tree strings 0x%x -> 0x%x\n",
2568                     dt_string_start, dt_string_end);
2569         prom_printf("Device tree struct  0x%x -> 0x%x\n",
2570                     dt_struct_start, dt_struct_end);
2571 }
2572
2573 #ifdef CONFIG_PPC_MAPLE
2574 /* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property.
2575  * The values are bad, and it doesn't even have the right number of cells. */
2576 static void __init fixup_device_tree_maple(void)
2577 {
2578         phandle isa;
2579         u32 rloc = 0x01002000; /* IO space; PCI device = 4 */
2580         u32 isa_ranges[6];
2581         char *name;
2582
2583         name = "/ht@0/isa@4";
2584         isa = call_prom("finddevice", 1, 1, ADDR(name));
2585         if (!PHANDLE_VALID(isa)) {
2586                 name = "/ht@0/isa@6";
2587                 isa = call_prom("finddevice", 1, 1, ADDR(name));
2588                 rloc = 0x01003000; /* IO space; PCI device = 6 */
2589         }
2590         if (!PHANDLE_VALID(isa))
2591                 return;
2592
2593         if (prom_getproplen(isa, "ranges") != 12)
2594                 return;
2595         if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges))
2596                 == PROM_ERROR)
2597                 return;
2598
2599         if (isa_ranges[0] != 0x1 ||
2600                 isa_ranges[1] != 0xf4000000 ||
2601                 isa_ranges[2] != 0x00010000)
2602                 return;
2603
2604         prom_printf("Fixing up bogus ISA range on Maple/Apache...\n");
2605
2606         isa_ranges[0] = 0x1;
2607         isa_ranges[1] = 0x0;
2608         isa_ranges[2] = rloc;
2609         isa_ranges[3] = 0x0;
2610         isa_ranges[4] = 0x0;
2611         isa_ranges[5] = 0x00010000;
2612         prom_setprop(isa, name, "ranges",
2613                         isa_ranges, sizeof(isa_ranges));
2614 }
2615
2616 #define CPC925_MC_START         0xf8000000
2617 #define CPC925_MC_LENGTH        0x1000000
2618 /* The values for memory-controller don't have right number of cells */
2619 static void __init fixup_device_tree_maple_memory_controller(void)
2620 {
2621         phandle mc;
2622         u32 mc_reg[4];
2623         char *name = "/hostbridge@f8000000";
2624         u32 ac, sc;
2625
2626         mc = call_prom("finddevice", 1, 1, ADDR(name));
2627         if (!PHANDLE_VALID(mc))
2628                 return;
2629
2630         if (prom_getproplen(mc, "reg") != 8)
2631                 return;
2632
2633         prom_getprop(prom.root, "#address-cells", &ac, sizeof(ac));
2634         prom_getprop(prom.root, "#size-cells", &sc, sizeof(sc));
2635         if ((ac != 2) || (sc != 2))
2636                 return;
2637
2638         if (prom_getprop(mc, "reg", mc_reg, sizeof(mc_reg)) == PROM_ERROR)
2639                 return;
2640
2641         if (mc_reg[0] != CPC925_MC_START || mc_reg[1] != CPC925_MC_LENGTH)
2642                 return;
2643
2644         prom_printf("Fixing up bogus hostbridge on Maple...\n");
2645
2646         mc_reg[0] = 0x0;
2647         mc_reg[1] = CPC925_MC_START;
2648         mc_reg[2] = 0x0;
2649         mc_reg[3] = CPC925_MC_LENGTH;
2650         prom_setprop(mc, name, "reg", mc_reg, sizeof(mc_reg));
2651 }
2652 #else
2653 #define fixup_device_tree_maple()
2654 #define fixup_device_tree_maple_memory_controller()
2655 #endif
2656
2657 #ifdef CONFIG_PPC_CHRP
2658 /*
2659  * Pegasos and BriQ lacks the "ranges" property in the isa node
2660  * Pegasos needs decimal IRQ 14/15, not hexadecimal
2661  * Pegasos has the IDE configured in legacy mode, but advertised as native
2662  */
2663 static void __init fixup_device_tree_chrp(void)
2664 {
2665         phandle ph;
2666         u32 prop[6];
2667         u32 rloc = 0x01006000; /* IO space; PCI device = 12 */
2668         char *name;
2669         int rc;
2670
2671         name = "/pci@80000000/isa@c";
2672         ph = call_prom("finddevice", 1, 1, ADDR(name));
2673         if (!PHANDLE_VALID(ph)) {
2674                 name = "/pci@ff500000/isa@6";
2675                 ph = call_prom("finddevice", 1, 1, ADDR(name));
2676                 rloc = 0x01003000; /* IO space; PCI device = 6 */
2677         }
2678         if (PHANDLE_VALID(ph)) {
2679                 rc = prom_getproplen(ph, "ranges");
2680                 if (rc == 0 || rc == PROM_ERROR) {
2681                         prom_printf("Fixing up missing ISA range on Pegasos...\n");
2682
2683                         prop[0] = 0x1;
2684                         prop[1] = 0x0;
2685                         prop[2] = rloc;
2686                         prop[3] = 0x0;
2687                         prop[4] = 0x0;
2688                         prop[5] = 0x00010000;
2689                         prom_setprop(ph, name, "ranges", prop, sizeof(prop));
2690                 }
2691         }
2692
2693         name = "/pci@80000000/ide@C,1";
2694         ph = call_prom("finddevice", 1, 1, ADDR(name));
2695         if (PHANDLE_VALID(ph)) {
2696                 prom_printf("Fixing up IDE interrupt on Pegasos...\n");
2697                 prop[0] = 14;
2698                 prop[1] = 0x0;
2699                 prom_setprop(ph, name, "interrupts", prop, 2*sizeof(u32));
2700                 prom_printf("Fixing up IDE class-code on Pegasos...\n");
2701                 rc = prom_getprop(ph, "class-code", prop, sizeof(u32));
2702                 if (rc == sizeof(u32)) {
2703                         prop[0] &= ~0x5;
2704                         prom_setprop(ph, name, "class-code", prop, sizeof(u32));
2705                 }
2706         }
2707 }
2708 #else
2709 #define fixup_device_tree_chrp()
2710 #endif
2711
2712 #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC)
2713 static void __init fixup_device_tree_pmac(void)
2714 {
2715         phandle u3, i2c, mpic;
2716         u32 u3_rev;
2717         u32 interrupts[2];
2718         u32 parent;
2719
2720         /* Some G5s have a missing interrupt definition, fix it up here */
2721         u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000"));
2722         if (!PHANDLE_VALID(u3))
2723                 return;
2724         i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000"));
2725         if (!PHANDLE_VALID(i2c))
2726                 return;
2727         mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000"));
2728         if (!PHANDLE_VALID(mpic))
2729                 return;
2730
2731         /* check if proper rev of u3 */
2732         if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev))
2733             == PROM_ERROR)
2734                 return;
2735         if (u3_rev < 0x35 || u3_rev > 0x39)
2736                 return;
2737         /* does it need fixup ? */
2738         if (prom_getproplen(i2c, "interrupts") > 0)
2739                 return;
2740
2741         prom_printf("fixing up bogus interrupts for u3 i2c...\n");
2742
2743         /* interrupt on this revision of u3 is number 0 and level */
2744         interrupts[0] = 0;
2745         interrupts[1] = 1;
2746         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts",
2747                      &interrupts, sizeof(interrupts));
2748         parent = (u32)mpic;
2749         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent",
2750                      &parent, sizeof(parent));
2751 }
2752 #else
2753 #define fixup_device_tree_pmac()
2754 #endif
2755
2756 #ifdef CONFIG_PPC_EFIKA
2757 /*
2758  * The MPC5200 FEC driver requires an phy-handle property to tell it how
2759  * to talk to the phy.  If the phy-handle property is missing, then this
2760  * function is called to add the appropriate nodes and link it to the
2761  * ethernet node.
2762  */
2763 static void __init fixup_device_tree_efika_add_phy(void)
2764 {
2765         u32 node;
2766         char prop[64];
2767         int rv;
2768
2769         /* Check if /builtin/ethernet exists - bail if it doesn't */
2770         node = call_prom("finddevice", 1, 1, ADDR("/builtin/ethernet"));
2771         if (!PHANDLE_VALID(node))
2772                 return;
2773
2774         /* Check if the phy-handle property exists - bail if it does */
2775         rv = prom_getprop(node, "phy-handle", prop, sizeof(prop));
2776         if (!rv)
2777                 return;
2778
2779         /*
2780          * At this point the ethernet device doesn't have a phy described.
2781          * Now we need to add the missing phy node and linkage
2782          */
2783
2784         /* Check for an MDIO bus node - if missing then create one */
2785         node = call_prom("finddevice", 1, 1, ADDR("/builtin/mdio"));
2786         if (!PHANDLE_VALID(node)) {
2787                 prom_printf("Adding Ethernet MDIO node\n");
2788                 call_prom("interpret", 1, 1,
2789                         " s\" /builtin\" find-device"
2790                         " new-device"
2791                                 " 1 encode-int s\" #address-cells\" property"
2792                                 " 0 encode-int s\" #size-cells\" property"
2793                                 " s\" mdio\" device-name"
2794                                 " s\" fsl,mpc5200b-mdio\" encode-string"
2795                                 " s\" compatible\" property"
2796                                 " 0xf0003000 0x400 reg"
2797                                 " 0x2 encode-int"
2798                                 " 0x5 encode-int encode+"
2799                                 " 0x3 encode-int encode+"
2800                                 " s\" interrupts\" property"
2801                         " finish-device");
2802         };
2803
2804         /* Check for a PHY device node - if missing then create one and
2805          * give it's phandle to the ethernet node */
2806         node = call_prom("finddevice", 1, 1,
2807                          ADDR("/builtin/mdio/ethernet-phy"));
2808         if (!PHANDLE_VALID(node)) {
2809                 prom_printf("Adding Ethernet PHY node\n");
2810                 call_prom("interpret", 1, 1,
2811                         " s\" /builtin/mdio\" find-device"
2812                         " new-device"
2813                                 " s\" ethernet-phy\" device-name"
2814                                 " 0x10 encode-int s\" reg\" property"
2815                                 " my-self"
2816                                 " ihandle>phandle"
2817                         " finish-device"
2818                         " s\" /builtin/ethernet\" find-device"
2819                                 " encode-int"
2820                                 " s\" phy-handle\" property"
2821                         " device-end");
2822         }
2823 }
2824
2825 static void __init fixup_device_tree_efika(void)
2826 {
2827         int sound_irq[3] = { 2, 2, 0 };
2828         int bcomm_irq[3*16] = { 3,0,0, 3,1,0, 3,2,0, 3,3,0,
2829                                 3,4,0, 3,5,0, 3,6,0, 3,7,0,
2830                                 3,8,0, 3,9,0, 3,10,0, 3,11,0,
2831                                 3,12,0, 3,13,0, 3,14,0, 3,15,0 };
2832         u32 node;
2833         char prop[64];
2834         int rv, len;
2835
2836         /* Check if we're really running on a EFIKA */
2837         node = call_prom("finddevice", 1, 1, ADDR("/"));
2838         if (!PHANDLE_VALID(node))
2839                 return;
2840
2841         rv = prom_getprop(node, "model", prop, sizeof(prop));
2842         if (rv == PROM_ERROR)
2843                 return;
2844         if (strcmp(prop, "EFIKA5K2"))
2845                 return;
2846
2847         prom_printf("Applying EFIKA device tree fixups\n");
2848
2849         /* Claiming to be 'chrp' is death */
2850         node = call_prom("finddevice", 1, 1, ADDR("/"));
2851         rv = prom_getprop(node, "device_type", prop, sizeof(prop));
2852         if (rv != PROM_ERROR && (strcmp(prop, "chrp") == 0))
2853                 prom_setprop(node, "/", "device_type", "efika", sizeof("efika"));
2854
2855         /* CODEGEN,description is exposed in /proc/cpuinfo so
2856            fix that too */
2857         rv = prom_getprop(node, "CODEGEN,description", prop, sizeof(prop));
2858         if (rv != PROM_ERROR && (strstr(prop, "CHRP")))
2859                 prom_setprop(node, "/", "CODEGEN,description",
2860                              "Efika 5200B PowerPC System",
2861                              sizeof("Efika 5200B PowerPC System"));
2862
2863         /* Fixup bestcomm interrupts property */
2864         node = call_prom("finddevice", 1, 1, ADDR("/builtin/bestcomm"));
2865         if (PHANDLE_VALID(node)) {
2866                 len = prom_getproplen(node, "interrupts");
2867                 if (len == 12) {
2868                         prom_printf("Fixing bestcomm interrupts property\n");
2869                         prom_setprop(node, "/builtin/bestcom", "interrupts",
2870                                      bcomm_irq, sizeof(bcomm_irq));
2871                 }
2872         }
2873
2874         /* Fixup sound interrupts property */
2875         node = call_prom("finddevice", 1, 1, ADDR("/builtin/sound"));
2876         if (PHANDLE_VALID(node)) {
2877                 rv = prom_getprop(node, "interrupts", prop, sizeof(prop));
2878                 if (rv == PROM_ERROR) {
2879                         prom_printf("Adding sound interrupts property\n");
2880                         prom_setprop(node, "/builtin/sound", "interrupts",
2881                                      sound_irq, sizeof(sound_irq));
2882                 }
2883         }
2884
2885         /* Make sure ethernet phy-handle property exists */
2886         fixup_device_tree_efika_add_phy();
2887 }
2888 #else
2889 #define fixup_device_tree_efika()
2890 #endif
2891
2892 #ifdef CONFIG_PPC_PASEMI_NEMO
2893 /*
2894  * CFE supplied on Nemo is broken in several ways, biggest
2895  * problem is that it reassigns ISA interrupts to unused mpic ints.
2896  * Add an interrupt-controller property for the io-bridge to use
2897  * and correct the ints so we can attach them to an irq_domain
2898  */
2899 static void __init fixup_device_tree_pasemi(void)
2900 {
2901         u32 interrupts[2], parent, rval, val = 0;
2902         char *name, *pci_name;
2903         phandle iob, node;
2904
2905         /* Find the root pci node */
2906         name = "/pxp@0,e0000000";
2907         iob = call_prom("finddevice", 1, 1, ADDR(name));
2908         if (!PHANDLE_VALID(iob))
2909                 return;
2910
2911         /* check if interrupt-controller node set yet */
2912         if (prom_getproplen(iob, "interrupt-controller") !=PROM_ERROR)
2913                 return;
2914
2915         prom_printf("adding interrupt-controller property for SB600...\n");
2916
2917         prom_setprop(iob, name, "interrupt-controller", &val, 0);
2918
2919         pci_name = "/pxp@0,e0000000/pci@11";
2920         node = call_prom("finddevice", 1, 1, ADDR(pci_name));
2921         parent = ADDR(iob);
2922
2923         for( ; prom_next_node(&node); ) {
2924                 /* scan each node for one with an interrupt */
2925                 if (!PHANDLE_VALID(node))
2926                         continue;
2927
2928                 rval = prom_getproplen(node, "interrupts");
2929                 if (rval == 0 || rval == PROM_ERROR)
2930                         continue;
2931
2932                 prom_getprop(node, "interrupts", &interrupts, sizeof(interrupts));
2933                 if ((interrupts[0] < 212) || (interrupts[0] > 222))
2934                         continue;
2935
2936                 /* found a node, update both interrupts and interrupt-parent */
2937                 if ((interrupts[0] >= 212) && (interrupts[0] <= 215))
2938                         interrupts[0] -= 203;
2939                 if ((interrupts[0] >= 216) && (interrupts[0] <= 220))
2940                         interrupts[0] -= 213;
2941                 if (interrupts[0] == 221)
2942                         interrupts[0] = 14;
2943                 if (interrupts[0] == 222)
2944                         interrupts[0] = 8;
2945
2946                 prom_setprop(node, pci_name, "interrupts", interrupts,
2947                                         sizeof(interrupts));
2948                 prom_setprop(node, pci_name, "interrupt-parent", &parent,
2949                                         sizeof(parent));
2950         }
2951
2952         /*
2953          * The io-bridge has device_type set to 'io-bridge' change it to 'isa'
2954          * so that generic isa-bridge code can add the SB600 and its on-board
2955          * peripherals.
2956          */
2957         name = "/pxp@0,e0000000/io-bridge@0";
2958         iob = call_prom("finddevice", 1, 1, ADDR(name));
2959         if (!PHANDLE_VALID(iob))
2960                 return;
2961
2962         /* device_type is already set, just change it. */
2963
2964         prom_printf("Changing device_type of SB600 node...\n");
2965
2966         prom_setprop(iob, name, "device_type", "isa", sizeof("isa"));
2967 }
2968 #else   /* !CONFIG_PPC_PASEMI_NEMO */
2969 static inline void fixup_device_tree_pasemi(void) { }
2970 #endif
2971
2972 static void __init fixup_device_tree(void)
2973 {
2974         fixup_device_tree_maple();
2975         fixup_device_tree_maple_memory_controller();
2976         fixup_device_tree_chrp();
2977         fixup_device_tree_pmac();
2978         fixup_device_tree_efika();
2979         fixup_device_tree_pasemi();
2980 }
2981
2982 static void __init prom_find_boot_cpu(void)
2983 {
2984         __be32 rval;
2985         ihandle prom_cpu;
2986         phandle cpu_pkg;
2987
2988         rval = 0;
2989         if (prom_getprop(prom.chosen, "cpu", &rval, sizeof(rval)) <= 0)
2990                 return;
2991         prom_cpu = be32_to_cpu(rval);
2992
2993         cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
2994
2995         if (!PHANDLE_VALID(cpu_pkg))
2996                 return;
2997
2998         prom_getprop(cpu_pkg, "reg", &rval, sizeof(rval));
2999         prom.cpu = be32_to_cpu(rval);
3000
3001         prom_debug("Booting CPU hw index = %lu\n", prom.cpu);
3002 }
3003
3004 static void __init prom_check_initrd(unsigned long r3, unsigned long r4)
3005 {
3006 #ifdef CONFIG_BLK_DEV_INITRD
3007         if (r3 && r4 && r4 != 0xdeadbeef) {
3008                 __be64 val;
3009
3010                 prom_initrd_start = is_kernel_addr(r3) ? __pa(r3) : r3;
3011                 prom_initrd_end = prom_initrd_start + r4;
3012
3013                 val = cpu_to_be64(prom_initrd_start);
3014                 prom_setprop(prom.chosen, "/chosen", "linux,initrd-start",
3015                              &val, sizeof(val));
3016                 val = cpu_to_be64(prom_initrd_end);
3017                 prom_setprop(prom.chosen, "/chosen", "linux,initrd-end",
3018                              &val, sizeof(val));
3019
3020                 reserve_mem(prom_initrd_start,
3021                             prom_initrd_end - prom_initrd_start);
3022
3023                 prom_debug("initrd_start=0x%x\n", prom_initrd_start);
3024                 prom_debug("initrd_end=0x%x\n", prom_initrd_end);
3025         }
3026 #endif /* CONFIG_BLK_DEV_INITRD */
3027 }
3028
3029 #ifdef CONFIG_PPC64
3030 #ifdef CONFIG_RELOCATABLE
3031 static void reloc_toc(void)
3032 {
3033 }
3034
3035 static void unreloc_toc(void)
3036 {
3037 }
3038 #else
3039 static void __reloc_toc(unsigned long offset, unsigned long nr_entries)
3040 {
3041         unsigned long i;
3042         unsigned long *toc_entry;
3043
3044         /* Get the start of the TOC by using r2 directly. */
3045         asm volatile("addi %0,2,-0x8000" : "=b" (toc_entry));
3046
3047         for (i = 0; i < nr_entries; i++) {
3048                 *toc_entry = *toc_entry + offset;
3049                 toc_entry++;
3050         }
3051 }
3052
3053 static void reloc_toc(void)
3054 {
3055         unsigned long offset = reloc_offset();
3056         unsigned long nr_entries =
3057                 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long);
3058
3059         __reloc_toc(offset, nr_entries);
3060
3061         mb();
3062 }
3063
3064 static void unreloc_toc(void)
3065 {
3066         unsigned long offset = reloc_offset();
3067         unsigned long nr_entries =
3068                 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long);
3069
3070         mb();
3071
3072         __reloc_toc(-offset, nr_entries);
3073 }
3074 #endif
3075 #endif
3076
3077 /*
3078  * We enter here early on, when the Open Firmware prom is still
3079  * handling exceptions and the MMU hash table for us.
3080  */
3081
3082 unsigned long __init prom_init(unsigned long r3, unsigned long r4,
3083                                unsigned long pp,
3084                                unsigned long r6, unsigned long r7,
3085                                unsigned long kbase)
3086 {
3087         unsigned long hdr;
3088
3089 #ifdef CONFIG_PPC32
3090         unsigned long offset = reloc_offset();
3091         reloc_got2(offset);
3092 #else
3093         reloc_toc();
3094 #endif
3095
3096         /*
3097          * First zero the BSS
3098          */
3099         memset(&__bss_start, 0, __bss_stop - __bss_start);
3100
3101         /*
3102          * Init interface to Open Firmware, get some node references,
3103          * like /chosen
3104          */
3105         prom_init_client_services(pp);
3106
3107         /*
3108          * See if this OF is old enough that we need to do explicit maps
3109          * and other workarounds
3110          */
3111         prom_find_mmu();
3112
3113         /*
3114          * Init prom stdout device
3115          */
3116         prom_init_stdout();
3117
3118         prom_printf("Preparing to boot %s", linux_banner);
3119
3120         /*
3121          * Get default machine type. At this point, we do not differentiate
3122          * between pSeries SMP and pSeries LPAR
3123          */
3124         of_platform = prom_find_machine_type();
3125         prom_printf("Detected machine type: %x\n", of_platform);
3126
3127 #ifndef CONFIG_NONSTATIC_KERNEL
3128         /* Bail if this is a kdump kernel. */
3129         if (PHYSICAL_START > 0)
3130                 prom_panic("Error: You can't boot a kdump kernel from OF!\n");
3131 #endif
3132
3133         /*
3134          * Check for an initrd
3135          */
3136         prom_check_initrd(r3, r4);
3137
3138         /*
3139          * Do early parsing of command line
3140          */
3141         early_cmdline_parse();
3142
3143 #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
3144         /*
3145          * On pSeries, inform the firmware about our capabilities
3146          */
3147         if (of_platform == PLATFORM_PSERIES ||
3148             of_platform == PLATFORM_PSERIES_LPAR)
3149                 prom_send_capabilities();
3150 #endif
3151
3152         /*
3153          * Copy the CPU hold code
3154          */
3155         if (of_platform != PLATFORM_POWERMAC)
3156                 copy_and_flush(0, kbase, 0x100, 0);
3157
3158         /*
3159          * Initialize memory management within prom_init
3160          */
3161         prom_init_mem();
3162
3163         /*
3164          * Determine which cpu is actually running right _now_
3165          */
3166         prom_find_boot_cpu();
3167
3168         /*
3169          * Initialize display devices
3170          */
3171         prom_check_displays();
3172
3173 #if defined(CONFIG_PPC64) && defined(__BIG_ENDIAN__)
3174         /*
3175          * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else
3176          * that uses the allocator, we need to make sure we get the top of memory
3177          * available for us here...
3178          */
3179         if (of_platform == PLATFORM_PSERIES)
3180                 prom_initialize_tce_table();
3181 #endif
3182
3183         /*
3184          * On non-powermacs, try to instantiate RTAS. PowerMacs don't
3185          * have a usable RTAS implementation.
3186          */
3187         if (of_platform != PLATFORM_POWERMAC &&
3188             of_platform != PLATFORM_OPAL)
3189                 prom_instantiate_rtas();
3190
3191 #ifdef CONFIG_PPC_POWERNV
3192         if (of_platform == PLATFORM_OPAL)
3193                 prom_instantiate_opal();
3194 #endif /* CONFIG_PPC_POWERNV */
3195
3196 #ifdef CONFIG_PPC64
3197         /* instantiate sml */
3198         prom_instantiate_sml();
3199 #endif
3200
3201         /*
3202          * On non-powermacs, put all CPUs in spin-loops.
3203          *
3204          * PowerMacs use a different mechanism to spin CPUs
3205          *
3206          * (This must be done after instanciating RTAS)
3207          */
3208         if (of_platform != PLATFORM_POWERMAC &&
3209             of_platform != PLATFORM_OPAL)
3210                 prom_hold_cpus();
3211
3212         /*
3213          * Fill in some infos for use by the kernel later on
3214          */
3215         if (prom_memory_limit) {
3216                 __be64 val = cpu_to_be64(prom_memory_limit);
3217                 prom_setprop(prom.chosen, "/chosen", "linux,memory-limit",
3218                              &val, sizeof(val));
3219         }
3220 #ifdef CONFIG_PPC64
3221         if (prom_iommu_off)
3222                 prom_setprop(prom.chosen, "/chosen", "linux,iommu-off",
3223                              NULL, 0);
3224
3225         if (prom_iommu_force_on)
3226                 prom_setprop(prom.chosen, "/chosen", "linux,iommu-force-on",
3227                              NULL, 0);
3228
3229         if (prom_tce_alloc_start) {
3230                 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-start",
3231                              &prom_tce_alloc_start,
3232                              sizeof(prom_tce_alloc_start));
3233                 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-end",
3234                              &prom_tce_alloc_end,
3235                              sizeof(prom_tce_alloc_end));
3236         }
3237 #endif
3238
3239         /*
3240          * Fixup any known bugs in the device-tree
3241          */
3242         fixup_device_tree();
3243
3244         /*
3245          * Now finally create the flattened device-tree
3246          */
3247         prom_printf("copying OF device tree...\n");
3248         flatten_device_tree();
3249
3250         /*
3251          * in case stdin is USB and still active on IBM machines...
3252          * Unfortunately quiesce crashes on some powermacs if we have
3253          * closed stdin already (in particular the powerbook 101). It
3254          * appears that the OPAL version of OFW doesn't like it either.
3255          */
3256         if (of_platform != PLATFORM_POWERMAC &&
3257             of_platform != PLATFORM_OPAL)
3258                 prom_close_stdin();
3259
3260         /*
3261          * Call OF "quiesce" method to shut down pending DMA's from
3262          * devices etc...
3263          */
3264         prom_printf("Quiescing Open Firmware ...\n");
3265         call_prom("quiesce", 0, 0);
3266
3267         /*
3268          * And finally, call the kernel passing it the flattened device
3269          * tree and NULL as r5, thus triggering the new entry point which
3270          * is common to us and kexec
3271          */
3272         hdr = dt_header_start;
3273
3274         /* Don't print anything after quiesce under OPAL, it crashes OFW */
3275         if (of_platform != PLATFORM_OPAL) {
3276                 prom_printf("Booting Linux via __start() @ 0x%lx ...\n", kbase);
3277                 prom_debug("->dt_header_start=0x%x\n", hdr);
3278         }
3279
3280 #ifdef CONFIG_PPC32
3281         reloc_got2(-offset);
3282 #else
3283         unreloc_toc();
3284 #endif
3285
3286 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
3287         /* OPAL early debug gets the OPAL base & entry in r8 and r9 */
3288         __start(hdr, kbase, 0, 0, 0,
3289                 prom_opal_base, prom_opal_entry);
3290 #else
3291         __start(hdr, kbase, 0, 0, 0, 0, 0);
3292 #endif
3293
3294         return 0;
3295 }