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 __printf(1, 2)
 338 static void __init prom_printf(const char *format, ...)
 339 {
 340         const char *p, *q, *s;
 341         va_list args;
 342         unsigned long v;
 343         long vs;
 344
 345         va_start(args, format);
 346         for (p = format; *p != 0; p = q) {
 347                 for (q = p; *q != 0 && *q != '\n' && *q != '%'; ++q)
 348                         ;
 349                 if (q > p)
 350                         call_prom("write", 3, 1, prom.stdout, p, q - p);
 351                 if (*q == 0)
 352                         break;
 353                 if (*q == '\n') {
 354                         ++q;
 355                         call_prom("write", 3, 1, prom.stdout,
 356                                   ADDR("\r\n"), 2);
 357                         continue;
 358                 }
 359                 ++q;
 360                 if (*q == 0)
 361                         break;
 362                 switch (*q) {
 363                 case 's':
 364                         ++q;
 365                         s = va_arg(args, const char *);
 366                         prom_print(s);
 367                         break;
 368                 case 'x':
 369                         ++q;
 370                         v = va_arg(args, unsigned long);
 371                         prom_print_hex(v);
 372                         break;
 373                 case 'd':
 374                         ++q;
 375                         vs = va_arg(args, int);
 376                         if (vs < 0) {
 377                                 prom_print("-");
 378                                 vs = -vs;
 379                         }
 380                         prom_print_dec(vs);
 381                         break;
 382                 case 'l':
 383                         ++q;
 384                         if (*q == 0)
 385                                 break;
 386                         else if (*q == 'x') {
 387                                 ++q;
 388                                 v = va_arg(args, unsigned long);
 389                                 prom_print_hex(v);
 390                         } else if (*q == 'u') { /* '%lu' */
 391                                 ++q;
 392                                 v = va_arg(args, unsigned long);
 393                                 prom_print_dec(v);
 394                         } else if (*q == 'd') { /* %ld */
 395                                 ++q;
 396                                 vs = va_arg(args, long);
 397                                 if (vs < 0) {
 398                                         prom_print("-");
 399                                         vs = -vs;
 400                                 }
 401                                 prom_print_dec(vs);
 402                         }
 403                         break;
 404                 }
 405         }
 406         va_end(args);
 407 }
 408
 409
 410 static unsigned int __init prom_claim(unsigned long virt, unsigned long size,
 411                                 unsigned long align)
 412 {
 413
 414         if (align == 0 && (OF_WORKAROUNDS & OF_WA_CLAIM)) {
 415                 /*
 416                  * Old OF requires we claim physical and virtual separately
 417                  * and then map explicitly (assuming virtual mode)
 418                  */
 419                 int ret;
 420                 prom_arg_t result;
 421
 422                 ret = call_prom_ret("call-method", 5, 2, &result,
 423                                     ADDR("claim"), prom.memory,
 424                                     align, size, virt);
 425                 if (ret != 0 || result == -1)
 426                         return -1;
 427                 ret = call_prom_ret("call-method", 5, 2, &result,
 428                                     ADDR("claim"), prom.mmumap,
 429                                     align, size, virt);
 430                 if (ret != 0) {
 431                         call_prom("call-method", 4, 1, ADDR("release"),
 432                                   prom.memory, size, virt);
 433                         return -1;
 434                 }
 435                 /* the 0x12 is M (coherence) + PP == read/write */
 436                 call_prom("call-method", 6, 1,
 437                           ADDR("map"), prom.mmumap, 0x12, size, virt, virt);
 438                 return virt;
 439         }
 440         return call_prom("claim", 3, 1, (prom_arg_t)virt, (prom_arg_t)size,
 441                          (prom_arg_t)align);
 442 }
 443
 444 static void __init __attribute__((noreturn)) prom_panic(const char *reason)
 445 {
 446         prom_print(reason);
 447         /* Do not call exit because it clears the screen on pmac
 448          * it also causes some sort of double-fault on early pmacs */
 449         if (of_platform == PLATFORM_POWERMAC)
 450                 asm("trap\n");
 451
 452         /* ToDo: should put up an SRC here on pSeries */
 453         call_prom("exit", 0, 0);
 454
 455         for (;;)                        /* should never get here */
 456                 ;
 457 }
 458
 459
 460 static int __init prom_next_node(phandle *nodep)
 461 {
 462         phandle node;
 463
 464         if ((node = *nodep) != 0
 465             && (*nodep = call_prom("child", 1, 1, node)) != 0)
 466                 return 1;
 467         if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
 468                 return 1;
 469         for (;;) {
 470                 if ((node = call_prom("parent", 1, 1, node)) == 0)
 471                         return 0;
 472                 if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
 473                         return 1;
 474         }
 475 }
 476
 477 static inline int prom_getprop(phandle node, const char *pname,
 478                                void *value, size_t valuelen)
 479 {
 480         return call_prom("getprop", 4, 1, node, ADDR(pname),
 481                          (u32)(unsigned long) value, (u32) valuelen);
 482 }
 483
 484 static inline int prom_getproplen(phandle node, const char *pname)
 485 {
 486         return call_prom("getproplen", 2, 1, node, ADDR(pname));
 487 }
 488
 489 static void add_string(char **str, const char *q)
 490 {
 491         char *p = *str;
 492
 493         while (*q)
 494                 *p++ = *q++;
 495         *p++ = ' ';
 496         *str = p;
 497 }
 498
 499 static char *tohex(unsigned int x)
 500 {
 501         static char digits[] = "0123456789abcdef";
 502         static char result[9];
 503         int i;
 504
 505         result[8] = 0;
 506         i = 8;
 507         do {
 508                 --i;
 509                 result[i] = digits[x & 0xf];
 510                 x >>= 4;
 511         } while (x != 0 && i > 0);
 512         return &result[i];
 513 }
 514
 515 static int __init prom_setprop(phandle node, const char *nodename,
 516                                const char *pname, void *value, size_t valuelen)
 517 {
 518         char cmd[256], *p;
 519
 520         if (!(OF_WORKAROUNDS & OF_WA_LONGTRAIL))
 521                 return call_prom("setprop", 4, 1, node, ADDR(pname),
 522                                  (u32)(unsigned long) value, (u32) valuelen);
 523
 524         /* gah... setprop doesn't work on longtrail, have to use interpret */
 525         p = cmd;
 526         add_string(&p, "dev");
 527         add_string(&p, nodename);
 528         add_string(&p, tohex((u32)(unsigned long) value));
 529         add_string(&p, tohex(valuelen));
 530         add_string(&p, tohex(ADDR(pname)));
 531         add_string(&p, tohex(strlen(pname)));
 532         add_string(&p, "property");
 533         *p = 0;
 534         return call_prom("interpret", 1, 1, (u32)(unsigned long) cmd);
 535 }
 536
 537 /* We can't use the standard versions because of relocation headaches. */
 538 #define isxdigit(c)     (('0' <= (c) && (c) <= '9') \
 539                          || ('a' <= (c) && (c) <= 'f') \
 540                          || ('A' <= (c) && (c) <= 'F'))
 541
 542 #define isdigit(c)      ('0' <= (c) && (c) <= '9')
 543 #define islower(c)      ('a' <= (c) && (c) <= 'z')
 544 #define toupper(c)      (islower(c) ? ((c) - 'a' + 'A') : (c))
 545
 546 static unsigned long prom_strtoul(const char *cp, const char **endp)
 547 {
 548         unsigned long result = 0, base = 10, value;
 549
 550         if (*cp == '0') {
 551                 base = 8;
 552                 cp++;
 553                 if (toupper(*cp) == 'X') {
 554                         cp++;
 555                         base = 16;
 556                 }
 557         }
 558
 559         while (isxdigit(*cp) &&
 560                (value = isdigit(*cp) ? *cp - '0' : toupper(*cp) - 'A' + 10) < base) {
 561                 result = result * base + value;
 562                 cp++;
 563         }
 564
 565         if (endp)
 566                 *endp = cp;
 567
 568         return result;
 569 }
 570
 571 static unsigned long prom_memparse(const char *ptr, const char **retptr)
 572 {
 573         unsigned long ret = prom_strtoul(ptr, retptr);
 574         int shift = 0;
 575
 576         /*
 577          * We can't use a switch here because GCC *may* generate a
 578          * jump table which won't work, because we're not running at
 579          * the address we're linked at.
 580          */
 581         if ('G' == **retptr || 'g' == **retptr)
 582                 shift = 30;
 583
 584         if ('M' == **retptr || 'm' == **retptr)
 585                 shift = 20;
 586
 587         if ('K' == **retptr || 'k' == **retptr)
 588                 shift = 10;
 589
 590         if (shift) {
 591                 ret <<= shift;
 592                 (*retptr)++;
 593         }
 594
 595         return ret;
 596 }
 597
 598 /*
 599  * Early parsing of the command line passed to the kernel, used for
 600  * "mem=x" and the options that affect the iommu
 601  */
 602 static void __init early_cmdline_parse(void)
 603 {
 604         const char *opt;
 605
 606         char *p;
 607         int l = 0;
 608
 609         prom_cmd_line[0] = 0;
 610         p = prom_cmd_line;
 611         if ((long)prom.chosen > 0)
 612                 l = prom_getprop(prom.chosen, "bootargs", p, COMMAND_LINE_SIZE-1);
 613 #ifdef CONFIG_CMDLINE
 614         if (l <= 0 || p[0] == '\0') /* dbl check */
 615                 strlcpy(prom_cmd_line,
 616                         CONFIG_CMDLINE, sizeof(prom_cmd_line));
 617 #endif /* CONFIG_CMDLINE */
 618         prom_printf("command line: %s\n", prom_cmd_line);
 619
 620 #ifdef CONFIG_PPC64
 621         opt = strstr(prom_cmd_line, "iommu=");
 622         if (opt) {
 623                 prom_printf("iommu opt is: %s\n", opt);
 624                 opt += 6;
 625                 while (*opt && *opt == ' ')
 626                         opt++;
 627                 if (!strncmp(opt, "off", 3))
 628                         prom_iommu_off = 1;
 629                 else if (!strncmp(opt, "force", 5))
 630                         prom_iommu_force_on = 1;
 631         }
 632 #endif
 633         opt = strstr(prom_cmd_line, "mem=");
 634         if (opt) {
 635                 opt += 4;
 636                 prom_memory_limit = prom_memparse(opt, (const char **)&opt);
 637 #ifdef CONFIG_PPC64
 638                 /* Align to 16 MB == size of ppc64 large page */
 639                 prom_memory_limit = ALIGN(prom_memory_limit, 0x1000000);
 640 #endif
 641         }
 642
 643         opt = strstr(prom_cmd_line, "disable_radix");
 644         if (opt) {
 645                 prom_debug("Radix disabled from cmdline\n");
 646                 prom_radix_disable = true;
 647         }
 648 }
 649
 650 #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
 651 /*
 652  * The architecture vector has an array of PVR mask/value pairs,
 653  * followed by # option vectors - 1, followed by the option vectors.
 654  *
 655  * See prom.h for the definition of the bits specified in the
 656  * architecture vector.
 657  */
 658
 659 /* Firmware expects the value to be n - 1, where n is the # of vectors */
 660 #define NUM_VECTORS(n)          ((n) - 1)
 661
 662 /*
 663  * Firmware expects 1 + n - 2, where n is the length of the option vector in
 664  * bytes. The 1 accounts for the length byte itself, the - 2 .. ?
 665  */
 666 #define VECTOR_LENGTH(n)        (1 + (n) - 2)
 667
 668 struct option_vector1 {
 669         u8 byte1;
 670         u8 arch_versions;
 671         u8 arch_versions3;
 672 } __packed;
 673
 674 struct option_vector2 {
 675         u8 byte1;
 676         __be16 reserved;
 677         __be32 real_base;
 678         __be32 real_size;
 679         __be32 virt_base;
 680         __be32 virt_size;
 681         __be32 load_base;
 682         __be32 min_rma;
 683         __be32 min_load;
 684         u8 min_rma_percent;
 685         u8 max_pft_size;
 686 } __packed;
 687
 688 struct option_vector3 {
 689         u8 byte1;
 690         u8 byte2;
 691 } __packed;
 692
 693 struct option_vector4 {
 694         u8 byte1;
 695         u8 min_vp_cap;
 696 } __packed;
 697
 698 struct option_vector5 {
 699         u8 byte1;
 700         u8 byte2;
 701         u8 byte3;
 702         u8 cmo;
 703         u8 associativity;
 704         u8 bin_opts;
 705         u8 micro_checkpoint;
 706         u8 reserved0;
 707         __be32 max_cpus;
 708         __be16 papr_level;
 709         __be16 reserved1;
 710         u8 platform_facilities;
 711         u8 reserved2;
 712         __be16 reserved3;
 713         u8 subprocessors;
 714         u8 byte22;
 715         u8 intarch;
 716         u8 mmu;
 717         u8 hash_ext;
 718         u8 radix_ext;
 719 } __packed;
 720
 721 struct option_vector6 {
 722         u8 reserved;
 723         u8 secondary_pteg;
 724         u8 os_name;
 725 } __packed;
 726
 727 struct ibm_arch_vec {
 728         struct { u32 mask, val; } pvrs[12];
 729
 730         u8 num_vectors;
 731
 732         u8 vec1_len;
 733         struct option_vector1 vec1;
 734
 735         u8 vec2_len;
 736         struct option_vector2 vec2;
 737
 738         u8 vec3_len;
 739         struct option_vector3 vec3;
 740
 741         u8 vec4_len;
 742         struct option_vector4 vec4;
 743
 744         u8 vec5_len;
 745         struct option_vector5 vec5;
 746
 747         u8 vec6_len;
 748         struct option_vector6 vec6;
 749 } __packed;
 750
 751 struct ibm_arch_vec __cacheline_aligned ibm_architecture_vec = {
 752         .pvrs = {
 753                 {
 754                         .mask = cpu_to_be32(0xfffe0000), /* POWER5/POWER5+ */
 755                         .val  = cpu_to_be32(0x003a0000),
 756                 },
 757                 {
 758                         .mask = cpu_to_be32(0xffff0000), /* POWER6 */
 759                         .val  = cpu_to_be32(0x003e0000),
 760                 },
 761                 {
 762                         .mask = cpu_to_be32(0xffff0000), /* POWER7 */
 763                         .val  = cpu_to_be32(0x003f0000),
 764                 },
 765                 {
 766                         .mask = cpu_to_be32(0xffff0000), /* POWER8E */
 767                         .val  = cpu_to_be32(0x004b0000),
 768                 },
 769                 {
 770                         .mask = cpu_to_be32(0xffff0000), /* POWER8NVL */
 771                         .val  = cpu_to_be32(0x004c0000),
 772                 },
 773                 {
 774                         .mask = cpu_to_be32(0xffff0000), /* POWER8 */
 775                         .val  = cpu_to_be32(0x004d0000),
 776                 },
 777                 {
 778                         .mask = cpu_to_be32(0xffff0000), /* POWER9 */
 779                         .val  = cpu_to_be32(0x004e0000),
 780                 },
 781                 {
 782                         .mask = cpu_to_be32(0xffffffff), /* all 3.00-compliant */
 783                         .val  = cpu_to_be32(0x0f000005),
 784                 },
 785                 {
 786                         .mask = cpu_to_be32(0xffffffff), /* all 2.07-compliant */
 787                         .val  = cpu_to_be32(0x0f000004),
 788                 },
 789                 {
 790                         .mask = cpu_to_be32(0xffffffff), /* all 2.06-compliant */
 791                         .val  = cpu_to_be32(0x0f000003),
 792                 },
 793                 {
 794                         .mask = cpu_to_be32(0xffffffff), /* all 2.05-compliant */
 795                         .val  = cpu_to_be32(0x0f000002),
 796                 },
 797                 {
 798                         .mask = cpu_to_be32(0xfffffffe), /* all 2.04-compliant and earlier */
 799                         .val  = cpu_to_be32(0x0f000001),
 800                 },
 801         },
 802
 803         .num_vectors = NUM_VECTORS(6),
 804
 805         .vec1_len = VECTOR_LENGTH(sizeof(struct option_vector1)),
 806         .vec1 = {
 807                 .byte1 = 0,
 808                 .arch_versions = OV1_PPC_2_00 | OV1_PPC_2_01 | OV1_PPC_2_02 | OV1_PPC_2_03 |
 809                                  OV1_PPC_2_04 | OV1_PPC_2_05 | OV1_PPC_2_06 | OV1_PPC_2_07,
 810                 .arch_versions3 = OV1_PPC_3_00,
 811         },
 812
 813         .vec2_len = VECTOR_LENGTH(sizeof(struct option_vector2)),
 814         /* option vector 2: Open Firmware options supported */
 815         .vec2 = {
 816                 .byte1 = OV2_REAL_MODE,
 817                 .reserved = 0,
 818                 .real_base = cpu_to_be32(0xffffffff),
 819                 .real_size = cpu_to_be32(0xffffffff),
 820                 .virt_base = cpu_to_be32(0xffffffff),
 821                 .virt_size = cpu_to_be32(0xffffffff),
 822                 .load_base = cpu_to_be32(0xffffffff),
 823                 .min_rma = cpu_to_be32(512),            /* 512MB min RMA */
 824                 .min_load = cpu_to_be32(0xffffffff),    /* full client load */
 825                 .min_rma_percent = 0,   /* min RMA percentage of total RAM */
 826                 .max_pft_size = 48,     /* max log_2(hash table size) */
 827         },
 828
 829         .vec3_len = VECTOR_LENGTH(sizeof(struct option_vector3)),
 830         /* option vector 3: processor options supported */
 831         .vec3 = {
 832                 .byte1 = 0,                     /* don't ignore, don't halt */
 833                 .byte2 = OV3_FP | OV3_VMX | OV3_DFP,
 834         },
 835
 836         .vec4_len = VECTOR_LENGTH(sizeof(struct option_vector4)),
 837         /* option vector 4: IBM PAPR implementation */
 838         .vec4 = {
 839                 .byte1 = 0,                     /* don't halt */
 840                 .min_vp_cap = OV4_MIN_ENT_CAP,  /* minimum VP entitled capacity */
 841         },
 842
 843         .vec5_len = VECTOR_LENGTH(sizeof(struct option_vector5)),
 844         /* option vector 5: PAPR/OF options */
 845         .vec5 = {
 846                 .byte1 = 0,                             /* don't ignore, don't halt */
 847                 .byte2 = OV5_FEAT(OV5_LPAR) | OV5_FEAT(OV5_SPLPAR) | OV5_FEAT(OV5_LARGE_PAGES) |
 848                 OV5_FEAT(OV5_DRCONF_MEMORY) | OV5_FEAT(OV5_DONATE_DEDICATE_CPU) |
 849 #ifdef CONFIG_PCI_MSI
 850                 /* PCIe/MSI support.  Without MSI full PCIe is not supported */
 851                 OV5_FEAT(OV5_MSI),
 852 #else
 853                 0,
 854 #endif
 855                 .byte3 = 0,
 856                 .cmo =
 857 #ifdef CONFIG_PPC_SMLPAR
 858                 OV5_FEAT(OV5_CMO) | OV5_FEAT(OV5_XCMO),
 859 #else
 860                 0,
 861 #endif
 862                 .associativity = OV5_FEAT(OV5_TYPE1_AFFINITY) | OV5_FEAT(OV5_PRRN),
 863                 .bin_opts = OV5_FEAT(OV5_RESIZE_HPT) | OV5_FEAT(OV5_HP_EVT),
 864                 .micro_checkpoint = 0,
 865                 .reserved0 = 0,
 866                 .max_cpus = cpu_to_be32(NR_CPUS),       /* number of cores supported */
 867                 .papr_level = 0,
 868                 .reserved1 = 0,
 869                 .platform_facilities = OV5_FEAT(OV5_PFO_HW_RNG) | OV5_FEAT(OV5_PFO_HW_ENCR) | OV5_FEAT(OV5_PFO_HW_842),
 870                 .reserved2 = 0,
 871                 .reserved3 = 0,
 872                 .subprocessors = 1,
 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: %u (NR_CPUS = %d)\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("%s(%lx, %lx)\n", __func__, 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%lx\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(" -> %lx\n", addr);
1258         prom_debug("  alloc_bottom : %lx\n", alloc_bottom);
1259         prom_debug("  alloc_top    : %lx\n", alloc_top);
1260         prom_debug("  alloc_top_hi : %lx\n", alloc_top_high);
1261         prom_debug("  rmo_top      : %lx\n", rmo_top);
1262         prom_debug("  ram_top      : %lx\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("%s(%lx, %lx, %s)\n", __func__, 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%lx\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(" -> %lx\n", addr);
1317         prom_debug("  alloc_bottom : %lx\n", alloc_bottom);
1318         prom_debug("  alloc_top    : %lx\n", alloc_top);
1319         prom_debug("  alloc_top_hi : %lx\n", alloc_top_high);
1320         prom_debug("  rmo_top      : %lx\n", rmo_top);
1321         prom_debug("  ram_top      : %lx\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("    %lx %lx\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=%lx <= 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=%lx >= 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 : %lx (16 MB aligned)\n",
1505                     prom_memory_limit);
1506         prom_printf("  alloc_bottom : %lx\n", alloc_bottom);
1507         prom_printf("  alloc_top    : %lx\n", alloc_top);
1508         prom_printf("  alloc_top_hi : %lx\n", alloc_top_high);
1509         prom_printf("  rmo_top      : %lx\n", rmo_top);
1510         prom_printf("  ram_top      : %lx\n", ram_top);
1511 }
1512
1513 static void __init prom_close_stdin(void)
1514 {
1515         __be32 val;
1516         ihandle stdin;
1517
1518         if (prom_getprop(prom.chosen, "stdin", &val, sizeof(val)) > 0) {
1519                 stdin = be32_to_cpu(val);
1520                 call_prom("close", 1, 0, stdin);
1521         }
1522 }
1523
1524 #ifdef CONFIG_PPC_POWERNV
1525
1526 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
1527 static u64 __initdata prom_opal_base;
1528 static u64 __initdata prom_opal_entry;
1529 #endif
1530
1531 /*
1532  * Allocate room for and instantiate OPAL
1533  */
1534 static void __init prom_instantiate_opal(void)
1535 {
1536         phandle opal_node;
1537         ihandle opal_inst;
1538         u64 base, entry;
1539         u64 size = 0, align = 0x10000;
1540         __be64 val64;
1541         u32 rets[2];
1542
1543         prom_debug("prom_instantiate_opal: start...\n");
1544
1545         opal_node = call_prom("finddevice", 1, 1, ADDR("/ibm,opal"));
1546         prom_debug("opal_node: %x\n", opal_node);
1547         if (!PHANDLE_VALID(opal_node))
1548                 return;
1549
1550         val64 = 0;
1551         prom_getprop(opal_node, "opal-runtime-size", &val64, sizeof(val64));
1552         size = be64_to_cpu(val64);
1553         if (size == 0)
1554                 return;
1555         val64 = 0;
1556         prom_getprop(opal_node, "opal-runtime-alignment", &val64,sizeof(val64));
1557         align = be64_to_cpu(val64);
1558
1559         base = alloc_down(size, align, 0);
1560         if (base == 0) {
1561                 prom_printf("OPAL allocation failed !\n");
1562                 return;
1563         }
1564
1565         opal_inst = call_prom("open", 1, 1, ADDR("/ibm,opal"));
1566         if (!IHANDLE_VALID(opal_inst)) {
1567                 prom_printf("opening opal package failed (%x)\n", opal_inst);
1568                 return;
1569         }
1570
1571         prom_printf("instantiating opal at 0x%llx...", base);
1572
1573         if (call_prom_ret("call-method", 4, 3, rets,
1574                           ADDR("load-opal-runtime"),
1575                           opal_inst,
1576                           base >> 32, base & 0xffffffff) != 0
1577             || (rets[0] == 0 && rets[1] == 0)) {
1578                 prom_printf(" failed\n");
1579                 return;
1580         }
1581         entry = (((u64)rets[0]) << 32) | rets[1];
1582
1583         prom_printf(" done\n");
1584
1585         reserve_mem(base, size);
1586
1587         prom_debug("opal base     = 0x%llx\n", base);
1588         prom_debug("opal align    = 0x%llx\n", align);
1589         prom_debug("opal entry    = 0x%llx\n", entry);
1590         prom_debug("opal size     = 0x%llx\n", size);
1591
1592         prom_setprop(opal_node, "/ibm,opal", "opal-base-address",
1593                      &base, sizeof(base));
1594         prom_setprop(opal_node, "/ibm,opal", "opal-entry-address",
1595                      &entry, sizeof(entry));
1596
1597 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
1598         prom_opal_base = base;
1599         prom_opal_entry = entry;
1600 #endif
1601         prom_debug("prom_instantiate_opal: end...\n");
1602 }
1603
1604 #endif /* CONFIG_PPC_POWERNV */
1605
1606 /*
1607  * Allocate room for and instantiate RTAS
1608  */
1609 static void __init prom_instantiate_rtas(void)
1610 {
1611         phandle rtas_node;
1612         ihandle rtas_inst;
1613         u32 base, entry = 0;
1614         __be32 val;
1615         u32 size = 0;
1616
1617         prom_debug("prom_instantiate_rtas: start...\n");
1618
1619         rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1620         prom_debug("rtas_node: %x\n", rtas_node);
1621         if (!PHANDLE_VALID(rtas_node))
1622                 return;
1623
1624         val = 0;
1625         prom_getprop(rtas_node, "rtas-size", &val, sizeof(size));
1626         size = be32_to_cpu(val);
1627         if (size == 0)
1628                 return;
1629
1630         base = alloc_down(size, PAGE_SIZE, 0);
1631         if (base == 0)
1632                 prom_panic("Could not allocate memory for RTAS\n");
1633
1634         rtas_inst = call_prom("open", 1, 1, ADDR("/rtas"));
1635         if (!IHANDLE_VALID(rtas_inst)) {
1636                 prom_printf("opening rtas package failed (%x)\n", rtas_inst);
1637                 return;
1638         }
1639
1640         prom_printf("instantiating rtas at 0x%x...", base);
1641
1642         if (call_prom_ret("call-method", 3, 2, &entry,
1643                           ADDR("instantiate-rtas"),
1644                           rtas_inst, base) != 0
1645             || entry == 0) {
1646                 prom_printf(" failed\n");
1647                 return;
1648         }
1649         prom_printf(" done\n");
1650
1651         reserve_mem(base, size);
1652
1653         val = cpu_to_be32(base);
1654         prom_setprop(rtas_node, "/rtas", "linux,rtas-base",
1655                      &val, sizeof(val));
1656         val = cpu_to_be32(entry);
1657         prom_setprop(rtas_node, "/rtas", "linux,rtas-entry",
1658                      &val, sizeof(val));
1659
1660         /* Check if it supports "query-cpu-stopped-state" */
1661         if (prom_getprop(rtas_node, "query-cpu-stopped-state",
1662                          &val, sizeof(val)) != PROM_ERROR)
1663                 rtas_has_query_cpu_stopped = true;
1664
1665         prom_debug("rtas base     = 0x%x\n", base);
1666         prom_debug("rtas entry    = 0x%x\n", entry);
1667         prom_debug("rtas size     = 0x%x\n", size);
1668
1669         prom_debug("prom_instantiate_rtas: end...\n");
1670 }
1671
1672 #ifdef CONFIG_PPC64
1673 /*
1674  * Allocate room for and instantiate Stored Measurement Log (SML)
1675  */
1676 static void __init prom_instantiate_sml(void)
1677 {
1678         phandle ibmvtpm_node;
1679         ihandle ibmvtpm_inst;
1680         u32 entry = 0, size = 0, succ = 0;
1681         u64 base;
1682         __be32 val;
1683
1684         prom_debug("prom_instantiate_sml: start...\n");
1685
1686         ibmvtpm_node = call_prom("finddevice", 1, 1, ADDR("/vdevice/vtpm"));
1687         prom_debug("ibmvtpm_node: %x\n", ibmvtpm_node);
1688         if (!PHANDLE_VALID(ibmvtpm_node))
1689                 return;
1690
1691         ibmvtpm_inst = call_prom("open", 1, 1, ADDR("/vdevice/vtpm"));
1692         if (!IHANDLE_VALID(ibmvtpm_inst)) {
1693                 prom_printf("opening vtpm package failed (%x)\n", ibmvtpm_inst);
1694                 return;
1695         }
1696
1697         if (prom_getprop(ibmvtpm_node, "ibm,sml-efi-reformat-supported",
1698                          &val, sizeof(val)) != PROM_ERROR) {
1699                 if (call_prom_ret("call-method", 2, 2, &succ,
1700                                   ADDR("reformat-sml-to-efi-alignment"),
1701                                   ibmvtpm_inst) != 0 || succ == 0) {
1702                         prom_printf("Reformat SML to EFI alignment failed\n");
1703                         return;
1704                 }
1705
1706                 if (call_prom_ret("call-method", 2, 2, &size,
1707                                   ADDR("sml-get-allocated-size"),
1708                                   ibmvtpm_inst) != 0 || size == 0) {
1709                         prom_printf("SML get allocated size failed\n");
1710                         return;
1711                 }
1712         } else {
1713                 if (call_prom_ret("call-method", 2, 2, &size,
1714                                   ADDR("sml-get-handover-size"),
1715                                   ibmvtpm_inst) != 0 || size == 0) {
1716                         prom_printf("SML get handover size failed\n");
1717                         return;
1718                 }
1719         }
1720
1721         base = alloc_down(size, PAGE_SIZE, 0);
1722         if (base == 0)
1723                 prom_panic("Could not allocate memory for sml\n");
1724
1725         prom_printf("instantiating sml at 0x%llx...", base);
1726
1727         memset((void *)base, 0, size);
1728
1729         if (call_prom_ret("call-method", 4, 2, &entry,
1730                           ADDR("sml-handover"),
1731                           ibmvtpm_inst, size, base) != 0 || entry == 0) {
1732                 prom_printf("SML handover failed\n");
1733                 return;
1734         }
1735         prom_printf(" done\n");
1736
1737         reserve_mem(base, size);
1738
1739         prom_setprop(ibmvtpm_node, "/vdevice/vtpm", "linux,sml-base",
1740                      &base, sizeof(base));
1741         prom_setprop(ibmvtpm_node, "/vdevice/vtpm", "linux,sml-size",
1742                      &size, sizeof(size));
1743
1744         prom_debug("sml base     = 0x%llx\n", base);
1745         prom_debug("sml size     = 0x%x\n", size);
1746
1747         prom_debug("prom_instantiate_sml: end...\n");
1748 }
1749
1750 /*
1751  * Allocate room for and initialize TCE tables
1752  */
1753 #ifdef __BIG_ENDIAN__
1754 static void __init prom_initialize_tce_table(void)
1755 {
1756         phandle node;
1757         ihandle phb_node;
1758         char compatible[64], type[64], model[64];
1759         char *path = prom_scratch;
1760         u64 base, align;
1761         u32 minalign, minsize;
1762         u64 tce_entry, *tce_entryp;
1763         u64 local_alloc_top, local_alloc_bottom;
1764         u64 i;
1765
1766         if (prom_iommu_off)
1767                 return;
1768
1769         prom_debug("starting prom_initialize_tce_table\n");
1770
1771         /* Cache current top of allocs so we reserve a single block */
1772         local_alloc_top = alloc_top_high;
1773         local_alloc_bottom = local_alloc_top;
1774
1775         /* Search all nodes looking for PHBs. */
1776         for (node = 0; prom_next_node(&node); ) {
1777                 compatible[0] = 0;
1778                 type[0] = 0;
1779                 model[0] = 0;
1780                 prom_getprop(node, "compatible",
1781                              compatible, sizeof(compatible));
1782                 prom_getprop(node, "device_type", type, sizeof(type));
1783                 prom_getprop(node, "model", model, sizeof(model));
1784
1785                 if ((type[0] == 0) || (strstr(type, "pci") == NULL))
1786                         continue;
1787
1788                 /* Keep the old logic intact to avoid regression. */
1789                 if (compatible[0] != 0) {
1790                         if ((strstr(compatible, "python") == NULL) &&
1791                             (strstr(compatible, "Speedwagon") == NULL) &&
1792                             (strstr(compatible, "Winnipeg") == NULL))
1793                                 continue;
1794                 } else if (model[0] != 0) {
1795                         if ((strstr(model, "ython") == NULL) &&
1796                             (strstr(model, "peedwagon") == NULL) &&
1797                             (strstr(model, "innipeg") == NULL))
1798                                 continue;
1799                 }
1800
1801                 if (prom_getprop(node, "tce-table-minalign", &minalign,
1802                                  sizeof(minalign)) == PROM_ERROR)
1803                         minalign = 0;
1804                 if (prom_getprop(node, "tce-table-minsize", &minsize,
1805                                  sizeof(minsize)) == PROM_ERROR)
1806                         minsize = 4UL << 20;
1807
1808                 /*
1809                  * Even though we read what OF wants, we just set the table
1810                  * size to 4 MB.  This is enough to map 2GB of PCI DMA space.
1811                  * By doing this, we avoid the pitfalls of trying to DMA to
1812                  * MMIO space and the DMA alias hole.
1813                  *
1814                  * On POWER4, firmware sets the TCE region by assuming
1815                  * each TCE table is 8MB. Using this memory for anything
1816                  * else will impact performance, so we always allocate 8MB.
1817                  * Anton
1818                  */
1819                 if (pvr_version_is(PVR_POWER4) || pvr_version_is(PVR_POWER4p))
1820                         minsize = 8UL << 20;
1821                 else
1822                         minsize = 4UL << 20;
1823
1824                 /* Align to the greater of the align or size */
1825                 align = max(minalign, minsize);
1826                 base = alloc_down(minsize, align, 1);
1827                 if (base == 0)
1828                         prom_panic("ERROR, cannot find space for TCE table.\n");
1829                 if (base < local_alloc_bottom)
1830                         local_alloc_bottom = base;
1831
1832                 /* It seems OF doesn't null-terminate the path :-( */
1833                 memset(path, 0, PROM_SCRATCH_SIZE);
1834                 /* Call OF to setup the TCE hardware */
1835                 if (call_prom("package-to-path", 3, 1, node,
1836                               path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) {
1837                         prom_printf("package-to-path failed\n");
1838                 }
1839
1840                 /* Save away the TCE table attributes for later use. */
1841                 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base));
1842                 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize));
1843
1844                 prom_debug("TCE table: %s\n", path);
1845                 prom_debug("\tnode = 0x%x\n", node);
1846                 prom_debug("\tbase = 0x%llx\n", base);
1847                 prom_debug("\tsize = 0x%x\n", minsize);
1848
1849                 /* Initialize the table to have a one-to-one mapping
1850                  * over the allocated size.
1851                  */
1852                 tce_entryp = (u64 *)base;
1853                 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) {
1854                         tce_entry = (i << PAGE_SHIFT);
1855                         tce_entry |= 0x3;
1856                         *tce_entryp = tce_entry;
1857                 }
1858
1859                 prom_printf("opening PHB %s", path);
1860                 phb_node = call_prom("open", 1, 1, path);
1861                 if (phb_node == 0)
1862                         prom_printf("... failed\n");
1863                 else
1864                         prom_printf("... done\n");
1865
1866                 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"),
1867                           phb_node, -1, minsize,
1868                           (u32) base, (u32) (base >> 32));
1869                 call_prom("close", 1, 0, phb_node);
1870         }
1871
1872         reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom);
1873
1874         /* These are only really needed if there is a memory limit in
1875          * effect, but we don't know so export them always. */
1876         prom_tce_alloc_start = local_alloc_bottom;
1877         prom_tce_alloc_end = local_alloc_top;
1878
1879         /* Flag the first invalid entry */
1880         prom_debug("ending prom_initialize_tce_table\n");
1881 }
1882 #endif /* __BIG_ENDIAN__ */
1883 #endif /* CONFIG_PPC64 */
1884
1885 /*
1886  * With CHRP SMP we need to use the OF to start the other processors.
1887  * We can't wait until smp_boot_cpus (the OF is trashed by then)
1888  * so we have to put the processors into a holding pattern controlled
1889  * by the kernel (not OF) before we destroy the OF.
1890  *
1891  * This uses a chunk of low memory, puts some holding pattern
1892  * code there and sends the other processors off to there until
1893  * smp_boot_cpus tells them to do something.  The holding pattern
1894  * checks that address until its cpu # is there, when it is that
1895  * cpu jumps to __secondary_start().  smp_boot_cpus() takes care
1896  * of setting those values.
1897  *
1898  * We also use physical address 0x4 here to tell when a cpu
1899  * is in its holding pattern code.
1900  *
1901  * -- Cort
1902  */
1903 /*
1904  * We want to reference the copy of __secondary_hold_* in the
1905  * 0 - 0x100 address range
1906  */
1907 #define LOW_ADDR(x)     (((unsigned long) &(x)) & 0xff)
1908
1909 static void __init prom_hold_cpus(void)
1910 {
1911         unsigned long i;
1912         phandle node;
1913         char type[64];
1914         unsigned long *spinloop
1915                 = (void *) LOW_ADDR(__secondary_hold_spinloop);
1916         unsigned long *acknowledge
1917                 = (void *) LOW_ADDR(__secondary_hold_acknowledge);
1918         unsigned long secondary_hold = LOW_ADDR(__secondary_hold);
1919
1920         /*
1921          * On pseries, if RTAS supports "query-cpu-stopped-state",
1922          * we skip this stage, the CPUs will be started by the
1923          * kernel using RTAS.
1924          */
1925         if ((of_platform == PLATFORM_PSERIES ||
1926              of_platform == PLATFORM_PSERIES_LPAR) &&
1927             rtas_has_query_cpu_stopped) {
1928                 prom_printf("prom_hold_cpus: skipped\n");
1929                 return;
1930         }
1931
1932         prom_debug("prom_hold_cpus: start...\n");
1933         prom_debug("    1) spinloop       = 0x%lx\n", (unsigned long)spinloop);
1934         prom_debug("    1) *spinloop      = 0x%lx\n", *spinloop);
1935         prom_debug("    1) acknowledge    = 0x%lx\n",
1936                    (unsigned long)acknowledge);
1937         prom_debug("    1) *acknowledge   = 0x%lx\n", *acknowledge);
1938         prom_debug("    1) secondary_hold = 0x%lx\n", secondary_hold);
1939
1940         /* Set the common spinloop variable, so all of the secondary cpus
1941          * will block when they are awakened from their OF spinloop.
1942          * This must occur for both SMP and non SMP kernels, since OF will
1943          * be trashed when we move the kernel.
1944          */
1945         *spinloop = 0;
1946
1947         /* look for cpus */
1948         for (node = 0; prom_next_node(&node); ) {
1949                 unsigned int cpu_no;
1950                 __be32 reg;
1951
1952                 type[0] = 0;
1953                 prom_getprop(node, "device_type", type, sizeof(type));
1954                 if (strcmp(type, "cpu") != 0)
1955                         continue;
1956
1957                 /* Skip non-configured cpus. */
1958                 if (prom_getprop(node, "status", type, sizeof(type)) > 0)
1959                         if (strcmp(type, "okay") != 0)
1960                                 continue;
1961
1962                 reg = cpu_to_be32(-1); /* make sparse happy */
1963                 prom_getprop(node, "reg", &reg, sizeof(reg));
1964                 cpu_no = be32_to_cpu(reg);
1965
1966                 prom_debug("cpu hw idx   = %u\n", cpu_no);
1967
1968                 /* Init the acknowledge var which will be reset by
1969                  * the secondary cpu when it awakens from its OF
1970                  * spinloop.
1971                  */
1972                 *acknowledge = (unsigned long)-1;
1973
1974                 if (cpu_no != prom.cpu) {
1975                         /* Primary Thread of non-boot cpu or any thread */
1976                         prom_printf("starting cpu hw idx %u... ", cpu_no);
1977                         call_prom("start-cpu", 3, 0, node,
1978                                   secondary_hold, cpu_no);
1979
1980                         for (i = 0; (i < 100000000) &&
1981                              (*acknowledge == ((unsigned long)-1)); i++ )
1982                                 mb();
1983
1984                         if (*acknowledge == cpu_no)
1985                                 prom_printf("done\n");
1986                         else
1987                                 prom_printf("failed: %lx\n", *acknowledge);
1988                 }
1989 #ifdef CONFIG_SMP
1990                 else
1991                         prom_printf("boot cpu hw idx %u\n", cpu_no);
1992 #endif /* CONFIG_SMP */
1993         }
1994
1995         prom_debug("prom_hold_cpus: end...\n");
1996 }
1997
1998
1999 static void __init prom_init_client_services(unsigned long pp)
2000 {
2001         /* Get a handle to the prom entry point before anything else */
2002         prom_entry = pp;
2003
2004         /* get a handle for the stdout device */
2005         prom.chosen = call_prom("finddevice", 1, 1, ADDR("/chosen"));
2006         if (!PHANDLE_VALID(prom.chosen))
2007                 prom_panic("cannot find chosen"); /* msg won't be printed :( */
2008
2009         /* get device tree root */
2010         prom.root = call_prom("finddevice", 1, 1, ADDR("/"));
2011         if (!PHANDLE_VALID(prom.root))
2012                 prom_panic("cannot find device tree root"); /* msg won't be printed :( */
2013
2014         prom.mmumap = 0;
2015 }
2016
2017 #ifdef CONFIG_PPC32
2018 /*
2019  * For really old powermacs, we need to map things we claim.
2020  * For that, we need the ihandle of the mmu.
2021  * Also, on the longtrail, we need to work around other bugs.
2022  */
2023 static void __init prom_find_mmu(void)
2024 {
2025         phandle oprom;
2026         char version[64];
2027
2028         oprom = call_prom("finddevice", 1, 1, ADDR("/openprom"));
2029         if (!PHANDLE_VALID(oprom))
2030                 return;
2031         if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0)
2032                 return;
2033         version[sizeof(version) - 1] = 0;
2034         /* XXX might need to add other versions here */
2035         if (strcmp(version, "Open Firmware, 1.0.5") == 0)
2036                 of_workarounds = OF_WA_CLAIM;
2037         else if (strncmp(version, "FirmWorks,3.", 12) == 0) {
2038                 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL;
2039                 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim");
2040         } else
2041                 return;
2042         prom.memory = call_prom("open", 1, 1, ADDR("/memory"));
2043         prom_getprop(prom.chosen, "mmu", &prom.mmumap,
2044                      sizeof(prom.mmumap));
2045         prom.mmumap = be32_to_cpu(prom.mmumap);
2046         if (!IHANDLE_VALID(prom.memory) || !IHANDLE_VALID(prom.mmumap))
2047                 of_workarounds &= ~OF_WA_CLAIM;         /* hmmm */
2048 }
2049 #else
2050 #define prom_find_mmu()
2051 #endif
2052
2053 static void __init prom_init_stdout(void)
2054 {
2055         char *path = of_stdout_device;
2056         char type[16];
2057         phandle stdout_node;
2058         __be32 val;
2059
2060         if (prom_getprop(prom.chosen, "stdout", &val, sizeof(val)) <= 0)
2061                 prom_panic("cannot find stdout");
2062
2063         prom.stdout = be32_to_cpu(val);
2064
2065         /* Get the full OF pathname of the stdout device */
2066         memset(path, 0, 256);
2067         call_prom("instance-to-path", 3, 1, prom.stdout, path, 255);
2068         prom_printf("OF stdout device is: %s\n", of_stdout_device);
2069         prom_setprop(prom.chosen, "/chosen", "linux,stdout-path",
2070                      path, strlen(path) + 1);
2071
2072         /* instance-to-package fails on PA-Semi */
2073         stdout_node = call_prom("instance-to-package", 1, 1, prom.stdout);
2074         if (stdout_node != PROM_ERROR) {
2075                 val = cpu_to_be32(stdout_node);
2076                 prom_setprop(prom.chosen, "/chosen", "linux,stdout-package",
2077                              &val, sizeof(val));
2078
2079                 /* If it's a display, note it */
2080                 memset(type, 0, sizeof(type));
2081                 prom_getprop(stdout_node, "device_type", type, sizeof(type));
2082                 if (strcmp(type, "display") == 0)
2083                         prom_setprop(stdout_node, path, "linux,boot-display", NULL, 0);
2084         }
2085 }
2086
2087 static int __init prom_find_machine_type(void)
2088 {
2089         char compat[256];
2090         int len, i = 0;
2091 #ifdef CONFIG_PPC64
2092         phandle rtas;
2093         int x;
2094 #endif
2095
2096         /* Look for a PowerMac or a Cell */
2097         len = prom_getprop(prom.root, "compatible",
2098                            compat, sizeof(compat)-1);
2099         if (len > 0) {
2100                 compat[len] = 0;
2101                 while (i < len) {
2102                         char *p = &compat[i];
2103                         int sl = strlen(p);
2104                         if (sl == 0)
2105                                 break;
2106                         if (strstr(p, "Power Macintosh") ||
2107                             strstr(p, "MacRISC"))
2108                                 return PLATFORM_POWERMAC;
2109 #ifdef CONFIG_PPC64
2110                         /* We must make sure we don't detect the IBM Cell
2111                          * blades as pSeries due to some firmware issues,
2112                          * so we do it here.
2113                          */
2114                         if (strstr(p, "IBM,CBEA") ||
2115                             strstr(p, "IBM,CPBW-1.0"))
2116                                 return PLATFORM_GENERIC;
2117 #endif /* CONFIG_PPC64 */
2118                         i += sl + 1;
2119                 }
2120         }
2121 #ifdef CONFIG_PPC64
2122         /* Try to detect OPAL */
2123         if (PHANDLE_VALID(call_prom("finddevice", 1, 1, ADDR("/ibm,opal"))))
2124                 return PLATFORM_OPAL;
2125
2126         /* Try to figure out if it's an IBM pSeries or any other
2127          * PAPR compliant platform. We assume it is if :
2128          *  - /device_type is "chrp" (please, do NOT use that for future
2129          *    non-IBM designs !
2130          *  - it has /rtas
2131          */
2132         len = prom_getprop(prom.root, "device_type",
2133                            compat, sizeof(compat)-1);
2134         if (len <= 0)
2135                 return PLATFORM_GENERIC;
2136         if (strcmp(compat, "chrp"))
2137                 return PLATFORM_GENERIC;
2138
2139         /* Default to pSeries. We need to know if we are running LPAR */
2140         rtas = call_prom("finddevice", 1, 1, ADDR("/rtas"));
2141         if (!PHANDLE_VALID(rtas))
2142                 return PLATFORM_GENERIC;
2143         x = prom_getproplen(rtas, "ibm,hypertas-functions");
2144         if (x != PROM_ERROR) {
2145                 prom_debug("Hypertas detected, assuming LPAR !\n");
2146                 return PLATFORM_PSERIES_LPAR;
2147         }
2148         return PLATFORM_PSERIES;
2149 #else
2150         return PLATFORM_GENERIC;
2151 #endif
2152 }
2153
2154 static int __init prom_set_color(ihandle ih, int i, int r, int g, int b)
2155 {
2156         return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r);
2157 }
2158
2159 /*
2160  * If we have a display that we don't know how to drive,
2161  * we will want to try to execute OF's open method for it
2162  * later.  However, OF will probably fall over if we do that
2163  * we've taken over the MMU.
2164  * So we check whether we will need to open the display,
2165  * and if so, open it now.
2166  */
2167 static void __init prom_check_displays(void)
2168 {
2169         char type[16], *path;
2170         phandle node;
2171         ihandle ih;
2172         int i;
2173
2174         static unsigned char default_colors[] = {
2175                 0x00, 0x00, 0x00,
2176                 0x00, 0x00, 0xaa,
2177                 0x00, 0xaa, 0x00,
2178                 0x00, 0xaa, 0xaa,
2179                 0xaa, 0x00, 0x00,
2180                 0xaa, 0x00, 0xaa,
2181                 0xaa, 0xaa, 0x00,
2182                 0xaa, 0xaa, 0xaa,
2183                 0x55, 0x55, 0x55,
2184                 0x55, 0x55, 0xff,
2185                 0x55, 0xff, 0x55,
2186                 0x55, 0xff, 0xff,
2187                 0xff, 0x55, 0x55,
2188                 0xff, 0x55, 0xff,
2189                 0xff, 0xff, 0x55,
2190                 0xff, 0xff, 0xff
2191         };
2192         const unsigned char *clut;
2193
2194         prom_debug("Looking for displays\n");
2195         for (node = 0; prom_next_node(&node); ) {
2196                 memset(type, 0, sizeof(type));
2197                 prom_getprop(node, "device_type", type, sizeof(type));
2198                 if (strcmp(type, "display") != 0)
2199                         continue;
2200
2201                 /* It seems OF doesn't null-terminate the path :-( */
2202                 path = prom_scratch;
2203                 memset(path, 0, PROM_SCRATCH_SIZE);
2204
2205                 /*
2206                  * leave some room at the end of the path for appending extra
2207                  * arguments
2208                  */
2209                 if (call_prom("package-to-path", 3, 1, node, path,
2210                               PROM_SCRATCH_SIZE-10) == PROM_ERROR)
2211                         continue;
2212                 prom_printf("found display   : %s, opening... ", path);
2213
2214                 ih = call_prom("open", 1, 1, path);
2215                 if (ih == 0) {
2216                         prom_printf("failed\n");
2217                         continue;
2218                 }
2219
2220                 /* Success */
2221                 prom_printf("done\n");
2222                 prom_setprop(node, path, "linux,opened", NULL, 0);
2223
2224                 /* Setup a usable color table when the appropriate
2225                  * method is available. Should update this to set-colors */
2226                 clut = default_colors;
2227                 for (i = 0; i < 16; i++, clut += 3)
2228                         if (prom_set_color(ih, i, clut[0], clut[1],
2229                                            clut[2]) != 0)
2230                                 break;
2231
2232 #ifdef CONFIG_LOGO_LINUX_CLUT224
2233                 clut = PTRRELOC(logo_linux_clut224.clut);
2234                 for (i = 0; i < logo_linux_clut224.clutsize; i++, clut += 3)
2235                         if (prom_set_color(ih, i + 32, clut[0], clut[1],
2236                                            clut[2]) != 0)
2237                                 break;
2238 #endif /* CONFIG_LOGO_LINUX_CLUT224 */
2239
2240 #ifdef CONFIG_PPC_EARLY_DEBUG_BOOTX
2241                 if (prom_getprop(node, "linux,boot-display", NULL, 0) !=
2242                     PROM_ERROR) {
2243                         u32 width, height, pitch, addr;
2244
2245                         prom_printf("Setting btext !\n");
2246                         prom_getprop(node, "width", &width, 4);
2247                         prom_getprop(node, "height", &height, 4);
2248                         prom_getprop(node, "linebytes", &pitch, 4);
2249                         prom_getprop(node, "address", &addr, 4);
2250                         prom_printf("W=%d H=%d LB=%d addr=0x%x\n",
2251                                     width, height, pitch, addr);
2252                         btext_setup_display(width, height, 8, pitch, addr);
2253                 }
2254 #endif /* CONFIG_PPC_EARLY_DEBUG_BOOTX */
2255         }
2256 }
2257
2258
2259 /* Return (relocated) pointer to this much memory: moves initrd if reqd. */
2260 static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end,
2261                               unsigned long needed, unsigned long align)
2262 {
2263         void *ret;
2264
2265         *mem_start = _ALIGN(*mem_start, align);
2266         while ((*mem_start + needed) > *mem_end) {
2267                 unsigned long room, chunk;
2268
2269                 prom_debug("Chunk exhausted, claiming more at %lx...\n",
2270                            alloc_bottom);
2271                 room = alloc_top - alloc_bottom;
2272                 if (room > DEVTREE_CHUNK_SIZE)
2273                         room = DEVTREE_CHUNK_SIZE;
2274                 if (room < PAGE_SIZE)
2275                         prom_panic("No memory for flatten_device_tree "
2276                                    "(no room)\n");
2277                 chunk = alloc_up(room, 0);
2278                 if (chunk == 0)
2279                         prom_panic("No memory for flatten_device_tree "
2280                                    "(claim failed)\n");
2281                 *mem_end = chunk + room;
2282         }
2283
2284         ret = (void *)*mem_start;
2285         *mem_start += needed;
2286
2287         return ret;
2288 }
2289
2290 #define dt_push_token(token, mem_start, mem_end) do {                   \
2291                 void *room = make_room(mem_start, mem_end, 4, 4);       \
2292                 *(__be32 *)room = cpu_to_be32(token);                   \
2293         } while(0)
2294
2295 static unsigned long __init dt_find_string(char *str)
2296 {
2297         char *s, *os;
2298
2299         s = os = (char *)dt_string_start;
2300         s += 4;
2301         while (s <  (char *)dt_string_end) {
2302                 if (strcmp(s, str) == 0)
2303                         return s - os;
2304                 s += strlen(s) + 1;
2305         }
2306         return 0;
2307 }
2308
2309 /*
2310  * The Open Firmware 1275 specification states properties must be 31 bytes or
2311  * less, however not all firmwares obey this. Make it 64 bytes to be safe.
2312  */
2313 #define MAX_PROPERTY_NAME 64
2314
2315 static void __init scan_dt_build_strings(phandle node,
2316                                          unsigned long *mem_start,
2317                                          unsigned long *mem_end)
2318 {
2319         char *prev_name, *namep, *sstart;
2320         unsigned long soff;
2321         phandle child;
2322
2323         sstart =  (char *)dt_string_start;
2324
2325         /* get and store all property names */
2326         prev_name = "";
2327         for (;;) {
2328                 /* 64 is max len of name including nul. */
2329                 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1);
2330                 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) {
2331                         /* No more nodes: unwind alloc */
2332                         *mem_start = (unsigned long)namep;
2333                         break;
2334                 }
2335
2336                 /* skip "name" */
2337                 if (strcmp(namep, "name") == 0) {
2338                         *mem_start = (unsigned long)namep;
2339                         prev_name = "name";
2340                         continue;
2341                 }
2342                 /* get/create string entry */
2343                 soff = dt_find_string(namep);
2344                 if (soff != 0) {
2345                         *mem_start = (unsigned long)namep;
2346                         namep = sstart + soff;
2347                 } else {
2348                         /* Trim off some if we can */
2349                         *mem_start = (unsigned long)namep + strlen(namep) + 1;
2350                         dt_string_end = *mem_start;
2351                 }
2352                 prev_name = namep;
2353         }
2354
2355         /* do all our children */
2356         child = call_prom("child", 1, 1, node);
2357         while (child != 0) {
2358                 scan_dt_build_strings(child, mem_start, mem_end);
2359                 child = call_prom("peer", 1, 1, child);
2360         }
2361 }
2362
2363 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
2364                                         unsigned long *mem_end)
2365 {
2366         phandle child;
2367         char *namep, *prev_name, *sstart, *p, *ep, *lp, *path;
2368         unsigned long soff;
2369         unsigned char *valp;
2370         static char pname[MAX_PROPERTY_NAME];
2371         int l, room, has_phandle = 0;
2372
2373         dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end);
2374
2375         /* get the node's full name */
2376         namep = (char *)*mem_start;
2377         room = *mem_end - *mem_start;
2378         if (room > 255)
2379                 room = 255;
2380         l = call_prom("package-to-path", 3, 1, node, namep, room);
2381         if (l >= 0) {
2382                 /* Didn't fit?  Get more room. */
2383                 if (l >= room) {
2384                         if (l >= *mem_end - *mem_start)
2385                                 namep = make_room(mem_start, mem_end, l+1, 1);
2386                         call_prom("package-to-path", 3, 1, node, namep, l);
2387                 }
2388                 namep[l] = '\0';
2389
2390                 /* Fixup an Apple bug where they have bogus \0 chars in the
2391                  * middle of the path in some properties, and extract
2392                  * the unit name (everything after the last '/').
2393                  */
2394                 for (lp = p = namep, ep = namep + l; p < ep; p++) {
2395                         if (*p == '/')
2396                                 lp = namep;
2397                         else if (*p != 0)
2398                                 *lp++ = *p;
2399                 }
2400                 *lp = 0;
2401                 *mem_start = _ALIGN((unsigned long)lp + 1, 4);
2402         }
2403
2404         /* get it again for debugging */
2405         path = prom_scratch;
2406         memset(path, 0, PROM_SCRATCH_SIZE);
2407         call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
2408
2409         /* get and store all properties */
2410         prev_name = "";
2411         sstart = (char *)dt_string_start;
2412         for (;;) {
2413                 if (call_prom("nextprop", 3, 1, node, prev_name,
2414                               pname) != 1)
2415                         break;
2416
2417                 /* skip "name" */
2418                 if (strcmp(pname, "name") == 0) {
2419                         prev_name = "name";
2420                         continue;
2421                 }
2422
2423                 /* find string offset */
2424                 soff = dt_find_string(pname);
2425                 if (soff == 0) {
2426                         prom_printf("WARNING: Can't find string index for"
2427                                     " <%s>, node %s\n", pname, path);
2428                         break;
2429                 }
2430                 prev_name = sstart + soff;
2431
2432                 /* get length */
2433                 l = call_prom("getproplen", 2, 1, node, pname);
2434
2435                 /* sanity checks */
2436                 if (l == PROM_ERROR)
2437                         continue;
2438
2439                 /* push property head */
2440                 dt_push_token(OF_DT_PROP, mem_start, mem_end);
2441                 dt_push_token(l, mem_start, mem_end);
2442                 dt_push_token(soff, mem_start, mem_end);
2443
2444                 /* push property content */
2445                 valp = make_room(mem_start, mem_end, l, 4);
2446                 call_prom("getprop", 4, 1, node, pname, valp, l);
2447                 *mem_start = _ALIGN(*mem_start, 4);
2448
2449                 if (!strcmp(pname, "phandle"))
2450                         has_phandle = 1;
2451         }
2452
2453         /* Add a "linux,phandle" property if no "phandle" property already
2454          * existed (can happen with OPAL)
2455          */
2456         if (!has_phandle) {
2457                 soff = dt_find_string("linux,phandle");
2458                 if (soff == 0)
2459                         prom_printf("WARNING: Can't find string index for"
2460                                     " <linux-phandle> node %s\n", path);
2461                 else {
2462                         dt_push_token(OF_DT_PROP, mem_start, mem_end);
2463                         dt_push_token(4, mem_start, mem_end);
2464                         dt_push_token(soff, mem_start, mem_end);
2465                         valp = make_room(mem_start, mem_end, 4, 4);
2466                         *(__be32 *)valp = cpu_to_be32(node);
2467                 }
2468         }
2469
2470         /* do all our children */
2471         child = call_prom("child", 1, 1, node);
2472         while (child != 0) {
2473                 scan_dt_build_struct(child, mem_start, mem_end);
2474                 child = call_prom("peer", 1, 1, child);
2475         }
2476
2477         dt_push_token(OF_DT_END_NODE, mem_start, mem_end);
2478 }
2479
2480 static void __init flatten_device_tree(void)
2481 {
2482         phandle root;
2483         unsigned long mem_start, mem_end, room;
2484         struct boot_param_header *hdr;
2485         char *namep;
2486         u64 *rsvmap;
2487
2488         /*
2489          * Check how much room we have between alloc top & bottom (+/- a
2490          * few pages), crop to 1MB, as this is our "chunk" size
2491          */
2492         room = alloc_top - alloc_bottom - 0x4000;
2493         if (room > DEVTREE_CHUNK_SIZE)
2494                 room = DEVTREE_CHUNK_SIZE;
2495         prom_debug("starting device tree allocs at %lx\n", alloc_bottom);
2496
2497         /* Now try to claim that */
2498         mem_start = (unsigned long)alloc_up(room, PAGE_SIZE);
2499         if (mem_start == 0)
2500                 prom_panic("Can't allocate initial device-tree chunk\n");
2501         mem_end = mem_start + room;
2502
2503         /* Get root of tree */
2504         root = call_prom("peer", 1, 1, (phandle)0);
2505         if (root == (phandle)0)
2506                 prom_panic ("couldn't get device tree root\n");
2507
2508         /* Build header and make room for mem rsv map */
2509         mem_start = _ALIGN(mem_start, 4);
2510         hdr = make_room(&mem_start, &mem_end,
2511                         sizeof(struct boot_param_header), 4);
2512         dt_header_start = (unsigned long)hdr;
2513         rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8);
2514
2515         /* Start of strings */
2516         mem_start = PAGE_ALIGN(mem_start);
2517         dt_string_start = mem_start;
2518         mem_start += 4; /* hole */
2519
2520         /* Add "linux,phandle" in there, we'll need it */
2521         namep = make_room(&mem_start, &mem_end, 16, 1);
2522         strcpy(namep, "linux,phandle");
2523         mem_start = (unsigned long)namep + strlen(namep) + 1;
2524
2525         /* Build string array */
2526         prom_printf("Building dt strings...\n");
2527         scan_dt_build_strings(root, &mem_start, &mem_end);
2528         dt_string_end = mem_start;
2529
2530         /* Build structure */
2531         mem_start = PAGE_ALIGN(mem_start);
2532         dt_struct_start = mem_start;
2533         prom_printf("Building dt structure...\n");
2534         scan_dt_build_struct(root, &mem_start, &mem_end);
2535         dt_push_token(OF_DT_END, &mem_start, &mem_end);
2536         dt_struct_end = PAGE_ALIGN(mem_start);
2537
2538         /* Finish header */
2539         hdr->boot_cpuid_phys = cpu_to_be32(prom.cpu);
2540         hdr->magic = cpu_to_be32(OF_DT_HEADER);
2541         hdr->totalsize = cpu_to_be32(dt_struct_end - dt_header_start);
2542         hdr->off_dt_struct = cpu_to_be32(dt_struct_start - dt_header_start);
2543         hdr->off_dt_strings = cpu_to_be32(dt_string_start - dt_header_start);
2544         hdr->dt_strings_size = cpu_to_be32(dt_string_end - dt_string_start);
2545         hdr->off_mem_rsvmap = cpu_to_be32(((unsigned long)rsvmap) - dt_header_start);
2546         hdr->version = cpu_to_be32(OF_DT_VERSION);
2547         /* Version 16 is not backward compatible */
2548         hdr->last_comp_version = cpu_to_be32(0x10);
2549
2550         /* Copy the reserve map in */
2551         memcpy(rsvmap, mem_reserve_map, sizeof(mem_reserve_map));
2552
2553 #ifdef DEBUG_PROM
2554         {
2555                 int i;
2556                 prom_printf("reserved memory map:\n");
2557                 for (i = 0; i < mem_reserve_cnt; i++)
2558                         prom_printf("  %llx - %llx\n",
2559                                     be64_to_cpu(mem_reserve_map[i].base),
2560                                     be64_to_cpu(mem_reserve_map[i].size));
2561         }
2562 #endif
2563         /* Bump mem_reserve_cnt to cause further reservations to fail
2564          * since it's too late.
2565          */
2566         mem_reserve_cnt = MEM_RESERVE_MAP_SIZE;
2567
2568         prom_printf("Device tree strings 0x%lx -> 0x%lx\n",
2569                     dt_string_start, dt_string_end);
2570         prom_printf("Device tree struct  0x%lx -> 0x%lx\n",
2571                     dt_struct_start, dt_struct_end);
2572 }
2573
2574 #ifdef CONFIG_PPC_MAPLE
2575 /* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property.
2576  * The values are bad, and it doesn't even have the right number of cells. */
2577 static void __init fixup_device_tree_maple(void)
2578 {
2579         phandle isa;
2580         u32 rloc = 0x01002000; /* IO space; PCI device = 4 */
2581         u32 isa_ranges[6];
2582         char *name;
2583
2584         name = "/ht@0/isa@4";
2585         isa = call_prom("finddevice", 1, 1, ADDR(name));
2586         if (!PHANDLE_VALID(isa)) {
2587                 name = "/ht@0/isa@6";
2588                 isa = call_prom("finddevice", 1, 1, ADDR(name));
2589                 rloc = 0x01003000; /* IO space; PCI device = 6 */
2590         }
2591         if (!PHANDLE_VALID(isa))
2592                 return;
2593
2594         if (prom_getproplen(isa, "ranges") != 12)
2595                 return;
2596         if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges))
2597                 == PROM_ERROR)
2598                 return;
2599
2600         if (isa_ranges[0] != 0x1 ||
2601                 isa_ranges[1] != 0xf4000000 ||
2602                 isa_ranges[2] != 0x00010000)
2603                 return;
2604
2605         prom_printf("Fixing up bogus ISA range on Maple/Apache...\n");
2606
2607         isa_ranges[0] = 0x1;
2608         isa_ranges[1] = 0x0;
2609         isa_ranges[2] = rloc;
2610         isa_ranges[3] = 0x0;
2611         isa_ranges[4] = 0x0;
2612         isa_ranges[5] = 0x00010000;
2613         prom_setprop(isa, name, "ranges",
2614                         isa_ranges, sizeof(isa_ranges));
2615 }
2616
2617 #define CPC925_MC_START         0xf8000000
2618 #define CPC925_MC_LENGTH        0x1000000
2619 /* The values for memory-controller don't have right number of cells */
2620 static void __init fixup_device_tree_maple_memory_controller(void)
2621 {
2622         phandle mc;
2623         u32 mc_reg[4];
2624         char *name = "/hostbridge@f8000000";
2625         u32 ac, sc;
2626
2627         mc = call_prom("finddevice", 1, 1, ADDR(name));
2628         if (!PHANDLE_VALID(mc))
2629                 return;
2630
2631         if (prom_getproplen(mc, "reg") != 8)
2632                 return;
2633
2634         prom_getprop(prom.root, "#address-cells", &ac, sizeof(ac));
2635         prom_getprop(prom.root, "#size-cells", &sc, sizeof(sc));
2636         if ((ac != 2) || (sc != 2))
2637                 return;
2638
2639         if (prom_getprop(mc, "reg", mc_reg, sizeof(mc_reg)) == PROM_ERROR)
2640                 return;
2641
2642         if (mc_reg[0] != CPC925_MC_START || mc_reg[1] != CPC925_MC_LENGTH)
2643                 return;
2644
2645         prom_printf("Fixing up bogus hostbridge on Maple...\n");
2646
2647         mc_reg[0] = 0x0;
2648         mc_reg[1] = CPC925_MC_START;
2649         mc_reg[2] = 0x0;
2650         mc_reg[3] = CPC925_MC_LENGTH;
2651         prom_setprop(mc, name, "reg", mc_reg, sizeof(mc_reg));
2652 }
2653 #else
2654 #define fixup_device_tree_maple()
2655 #define fixup_device_tree_maple_memory_controller()
2656 #endif
2657
2658 #ifdef CONFIG_PPC_CHRP
2659 /*
2660  * Pegasos and BriQ lacks the "ranges" property in the isa node
2661  * Pegasos needs decimal IRQ 14/15, not hexadecimal
2662  * Pegasos has the IDE configured in legacy mode, but advertised as native
2663  */
2664 static void __init fixup_device_tree_chrp(void)
2665 {
2666         phandle ph;
2667         u32 prop[6];
2668         u32 rloc = 0x01006000; /* IO space; PCI device = 12 */
2669         char *name;
2670         int rc;
2671
2672         name = "/pci@80000000/isa@c";
2673         ph = call_prom("finddevice", 1, 1, ADDR(name));
2674         if (!PHANDLE_VALID(ph)) {
2675                 name = "/pci@ff500000/isa@6";
2676                 ph = call_prom("finddevice", 1, 1, ADDR(name));
2677                 rloc = 0x01003000; /* IO space; PCI device = 6 */
2678         }
2679         if (PHANDLE_VALID(ph)) {
2680                 rc = prom_getproplen(ph, "ranges");
2681                 if (rc == 0 || rc == PROM_ERROR) {
2682                         prom_printf("Fixing up missing ISA range on Pegasos...\n");
2683
2684                         prop[0] = 0x1;
2685                         prop[1] = 0x0;
2686                         prop[2] = rloc;
2687                         prop[3] = 0x0;
2688                         prop[4] = 0x0;
2689                         prop[5] = 0x00010000;
2690                         prom_setprop(ph, name, "ranges", prop, sizeof(prop));
2691                 }
2692         }
2693
2694         name = "/pci@80000000/ide@C,1";
2695         ph = call_prom("finddevice", 1, 1, ADDR(name));
2696         if (PHANDLE_VALID(ph)) {
2697                 prom_printf("Fixing up IDE interrupt on Pegasos...\n");
2698                 prop[0] = 14;
2699                 prop[1] = 0x0;
2700                 prom_setprop(ph, name, "interrupts", prop, 2*sizeof(u32));
2701                 prom_printf("Fixing up IDE class-code on Pegasos...\n");
2702                 rc = prom_getprop(ph, "class-code", prop, sizeof(u32));
2703                 if (rc == sizeof(u32)) {
2704                         prop[0] &= ~0x5;
2705                         prom_setprop(ph, name, "class-code", prop, sizeof(u32));
2706                 }
2707         }
2708 }
2709 #else
2710 #define fixup_device_tree_chrp()
2711 #endif
2712
2713 #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC)
2714 static void __init fixup_device_tree_pmac(void)
2715 {
2716         phandle u3, i2c, mpic;
2717         u32 u3_rev;
2718         u32 interrupts[2];
2719         u32 parent;
2720
2721         /* Some G5s have a missing interrupt definition, fix it up here */
2722         u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000"));
2723         if (!PHANDLE_VALID(u3))
2724                 return;
2725         i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000"));
2726         if (!PHANDLE_VALID(i2c))
2727                 return;
2728         mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000"));
2729         if (!PHANDLE_VALID(mpic))
2730                 return;
2731
2732         /* check if proper rev of u3 */
2733         if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev))
2734             == PROM_ERROR)
2735                 return;
2736         if (u3_rev < 0x35 || u3_rev > 0x39)
2737                 return;
2738         /* does it need fixup ? */
2739         if (prom_getproplen(i2c, "interrupts") > 0)
2740                 return;
2741
2742         prom_printf("fixing up bogus interrupts for u3 i2c...\n");
2743
2744         /* interrupt on this revision of u3 is number 0 and level */
2745         interrupts[0] = 0;
2746         interrupts[1] = 1;
2747         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts",
2748                      &interrupts, sizeof(interrupts));
2749         parent = (u32)mpic;
2750         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent",
2751                      &parent, sizeof(parent));
2752 }
2753 #else
2754 #define fixup_device_tree_pmac()
2755 #endif
2756
2757 #ifdef CONFIG_PPC_EFIKA
2758 /*
2759  * The MPC5200 FEC driver requires an phy-handle property to tell it how
2760  * to talk to the phy.  If the phy-handle property is missing, then this
2761  * function is called to add the appropriate nodes and link it to the
2762  * ethernet node.
2763  */
2764 static void __init fixup_device_tree_efika_add_phy(void)
2765 {
2766         u32 node;
2767         char prop[64];
2768         int rv;
2769
2770         /* Check if /builtin/ethernet exists - bail if it doesn't */
2771         node = call_prom("finddevice", 1, 1, ADDR("/builtin/ethernet"));
2772         if (!PHANDLE_VALID(node))
2773                 return;
2774
2775         /* Check if the phy-handle property exists - bail if it does */
2776         rv = prom_getprop(node, "phy-handle", prop, sizeof(prop));
2777         if (rv <= 0)
2778                 return;
2779
2780         /*
2781          * At this point the ethernet device doesn't have a phy described.
2782          * Now we need to add the missing phy node and linkage
2783          */
2784
2785         /* Check for an MDIO bus node - if missing then create one */
2786         node = call_prom("finddevice", 1, 1, ADDR("/builtin/mdio"));
2787         if (!PHANDLE_VALID(node)) {
2788                 prom_printf("Adding Ethernet MDIO node\n");
2789                 call_prom("interpret", 1, 1,
2790                         " s\" /builtin\" find-device"
2791                         " new-device"
2792                                 " 1 encode-int s\" #address-cells\" property"
2793                                 " 0 encode-int s\" #size-cells\" property"
2794                                 " s\" mdio\" device-name"
2795                                 " s\" fsl,mpc5200b-mdio\" encode-string"
2796                                 " s\" compatible\" property"
2797                                 " 0xf0003000 0x400 reg"
2798                                 " 0x2 encode-int"
2799                                 " 0x5 encode-int encode+"
2800                                 " 0x3 encode-int encode+"
2801                                 " s\" interrupts\" property"
2802                         " finish-device");
2803         };
2804
2805         /* Check for a PHY device node - if missing then create one and
2806          * give it's phandle to the ethernet node */
2807         node = call_prom("finddevice", 1, 1,
2808                          ADDR("/builtin/mdio/ethernet-phy"));
2809         if (!PHANDLE_VALID(node)) {
2810                 prom_printf("Adding Ethernet PHY node\n");
2811                 call_prom("interpret", 1, 1,
2812                         " s\" /builtin/mdio\" find-device"
2813                         " new-device"
2814                                 " s\" ethernet-phy\" device-name"
2815                                 " 0x10 encode-int s\" reg\" property"
2816                                 " my-self"
2817                                 " ihandle>phandle"
2818                         " finish-device"
2819                         " s\" /builtin/ethernet\" find-device"
2820                                 " encode-int"
2821                                 " s\" phy-handle\" property"
2822                         " device-end");
2823         }
2824 }
2825
2826 static void __init fixup_device_tree_efika(void)
2827 {
2828         int sound_irq[3] = { 2, 2, 0 };
2829         int bcomm_irq[3*16] = { 3,0,0, 3,1,0, 3,2,0, 3,3,0,
2830                                 3,4,0, 3,5,0, 3,6,0, 3,7,0,
2831                                 3,8,0, 3,9,0, 3,10,0, 3,11,0,
2832                                 3,12,0, 3,13,0, 3,14,0, 3,15,0 };
2833         u32 node;
2834         char prop[64];
2835         int rv, len;
2836
2837         /* Check if we're really running on a EFIKA */
2838         node = call_prom("finddevice", 1, 1, ADDR("/"));
2839         if (!PHANDLE_VALID(node))
2840                 return;
2841
2842         rv = prom_getprop(node, "model", prop, sizeof(prop));
2843         if (rv == PROM_ERROR)
2844                 return;
2845         if (strcmp(prop, "EFIKA5K2"))
2846                 return;
2847
2848         prom_printf("Applying EFIKA device tree fixups\n");
2849
2850         /* Claiming to be 'chrp' is death */
2851         node = call_prom("finddevice", 1, 1, ADDR("/"));
2852         rv = prom_getprop(node, "device_type", prop, sizeof(prop));
2853         if (rv != PROM_ERROR && (strcmp(prop, "chrp") == 0))
2854                 prom_setprop(node, "/", "device_type", "efika", sizeof("efika"));
2855
2856         /* CODEGEN,description is exposed in /proc/cpuinfo so
2857            fix that too */
2858         rv = prom_getprop(node, "CODEGEN,description", prop, sizeof(prop));
2859         if (rv != PROM_ERROR && (strstr(prop, "CHRP")))
2860                 prom_setprop(node, "/", "CODEGEN,description",
2861                              "Efika 5200B PowerPC System",
2862                              sizeof("Efika 5200B PowerPC System"));
2863
2864         /* Fixup bestcomm interrupts property */
2865         node = call_prom("finddevice", 1, 1, ADDR("/builtin/bestcomm"));
2866         if (PHANDLE_VALID(node)) {
2867                 len = prom_getproplen(node, "interrupts");
2868                 if (len == 12) {
2869                         prom_printf("Fixing bestcomm interrupts property\n");
2870                         prom_setprop(node, "/builtin/bestcom", "interrupts",
2871                                      bcomm_irq, sizeof(bcomm_irq));
2872                 }
2873         }
2874
2875         /* Fixup sound interrupts property */
2876         node = call_prom("finddevice", 1, 1, ADDR("/builtin/sound"));
2877         if (PHANDLE_VALID(node)) {
2878                 rv = prom_getprop(node, "interrupts", prop, sizeof(prop));
2879                 if (rv == PROM_ERROR) {
2880                         prom_printf("Adding sound interrupts property\n");
2881                         prom_setprop(node, "/builtin/sound", "interrupts",
2882                                      sound_irq, sizeof(sound_irq));
2883                 }
2884         }
2885
2886         /* Make sure ethernet phy-handle property exists */
2887         fixup_device_tree_efika_add_phy();
2888 }
2889 #else
2890 #define fixup_device_tree_efika()
2891 #endif
2892
2893 #ifdef CONFIG_PPC_PASEMI_NEMO
2894 /*
2895  * CFE supplied on Nemo is broken in several ways, biggest
2896  * problem is that it reassigns ISA interrupts to unused mpic ints.
2897  * Add an interrupt-controller property for the io-bridge to use
2898  * and correct the ints so we can attach them to an irq_domain
2899  */
2900 static void __init fixup_device_tree_pasemi(void)
2901 {
2902         u32 interrupts[2], parent, rval, val = 0;
2903         char *name, *pci_name;
2904         phandle iob, node;
2905
2906         /* Find the root pci node */
2907         name = "/pxp@0,e0000000";
2908         iob = call_prom("finddevice", 1, 1, ADDR(name));
2909         if (!PHANDLE_VALID(iob))
2910                 return;
2911
2912         /* check if interrupt-controller node set yet */
2913         if (prom_getproplen(iob, "interrupt-controller") !=PROM_ERROR)
2914                 return;
2915
2916         prom_printf("adding interrupt-controller property for SB600...\n");
2917
2918         prom_setprop(iob, name, "interrupt-controller", &val, 0);
2919
2920         pci_name = "/pxp@0,e0000000/pci@11";
2921         node = call_prom("finddevice", 1, 1, ADDR(pci_name));
2922         parent = ADDR(iob);
2923
2924         for( ; prom_next_node(&node); ) {
2925                 /* scan each node for one with an interrupt */
2926                 if (!PHANDLE_VALID(node))
2927                         continue;
2928
2929                 rval = prom_getproplen(node, "interrupts");
2930                 if (rval == 0 || rval == PROM_ERROR)
2931                         continue;
2932
2933                 prom_getprop(node, "interrupts", &interrupts, sizeof(interrupts));
2934                 if ((interrupts[0] < 212) || (interrupts[0] > 222))
2935                         continue;
2936
2937                 /* found a node, update both interrupts and interrupt-parent */
2938                 if ((interrupts[0] >= 212) && (interrupts[0] <= 215))
2939                         interrupts[0] -= 203;
2940                 if ((interrupts[0] >= 216) && (interrupts[0] <= 220))
2941                         interrupts[0] -= 213;
2942                 if (interrupts[0] == 221)
2943                         interrupts[0] = 14;
2944                 if (interrupts[0] == 222)
2945                         interrupts[0] = 8;
2946
2947                 prom_setprop(node, pci_name, "interrupts", interrupts,
2948                                         sizeof(interrupts));
2949                 prom_setprop(node, pci_name, "interrupt-parent", &parent,
2950                                         sizeof(parent));
2951         }
2952
2953         /*
2954          * The io-bridge has device_type set to 'io-bridge' change it to 'isa'
2955          * so that generic isa-bridge code can add the SB600 and its on-board
2956          * peripherals.
2957          */
2958         name = "/pxp@0,e0000000/io-bridge@0";
2959         iob = call_prom("finddevice", 1, 1, ADDR(name));
2960         if (!PHANDLE_VALID(iob))
2961                 return;
2962
2963         /* device_type is already set, just change it. */
2964
2965         prom_printf("Changing device_type of SB600 node...\n");
2966
2967         prom_setprop(iob, name, "device_type", "isa", sizeof("isa"));
2968 }
2969 #else   /* !CONFIG_PPC_PASEMI_NEMO */
2970 static inline void fixup_device_tree_pasemi(void) { }
2971 #endif
2972
2973 static void __init fixup_device_tree(void)
2974 {
2975         fixup_device_tree_maple();
2976         fixup_device_tree_maple_memory_controller();
2977         fixup_device_tree_chrp();
2978         fixup_device_tree_pmac();
2979         fixup_device_tree_efika();
2980         fixup_device_tree_pasemi();
2981 }
2982
2983 static void __init prom_find_boot_cpu(void)
2984 {
2985         __be32 rval;
2986         ihandle prom_cpu;
2987         phandle cpu_pkg;
2988
2989         rval = 0;
2990         if (prom_getprop(prom.chosen, "cpu", &rval, sizeof(rval)) <= 0)
2991                 return;
2992         prom_cpu = be32_to_cpu(rval);
2993
2994         cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
2995
2996         if (!PHANDLE_VALID(cpu_pkg))
2997                 return;
2998
2999         prom_getprop(cpu_pkg, "reg", &rval, sizeof(rval));
3000         prom.cpu = be32_to_cpu(rval);
3001
3002         prom_debug("Booting CPU hw index = %d\n", prom.cpu);
3003 }
3004
3005 static void __init prom_check_initrd(unsigned long r3, unsigned long r4)
3006 {
3007 #ifdef CONFIG_BLK_DEV_INITRD
3008         if (r3 && r4 && r4 != 0xdeadbeef) {
3009                 __be64 val;
3010
3011                 prom_initrd_start = is_kernel_addr(r3) ? __pa(r3) : r3;
3012                 prom_initrd_end = prom_initrd_start + r4;
3013
3014                 val = cpu_to_be64(prom_initrd_start);
3015                 prom_setprop(prom.chosen, "/chosen", "linux,initrd-start",
3016                              &val, sizeof(val));
3017                 val = cpu_to_be64(prom_initrd_end);
3018                 prom_setprop(prom.chosen, "/chosen", "linux,initrd-end",
3019                              &val, sizeof(val));
3020
3021                 reserve_mem(prom_initrd_start,
3022                             prom_initrd_end - prom_initrd_start);
3023
3024                 prom_debug("initrd_start=0x%lx\n", prom_initrd_start);
3025                 prom_debug("initrd_end=0x%lx\n", prom_initrd_end);
3026         }
3027 #endif /* CONFIG_BLK_DEV_INITRD */
3028 }
3029
3030 #ifdef CONFIG_PPC64
3031 #ifdef CONFIG_RELOCATABLE
3032 static void reloc_toc(void)
3033 {
3034 }
3035
3036 static void unreloc_toc(void)
3037 {
3038 }
3039 #else
3040 static void __reloc_toc(unsigned long offset, unsigned long nr_entries)
3041 {
3042         unsigned long i;
3043         unsigned long *toc_entry;
3044
3045         /* Get the start of the TOC by using r2 directly. */
3046         asm volatile("addi %0,2,-0x8000" : "=b" (toc_entry));
3047
3048         for (i = 0; i < nr_entries; i++) {
3049                 *toc_entry = *toc_entry + offset;
3050                 toc_entry++;
3051         }
3052 }
3053
3054 static void reloc_toc(void)
3055 {
3056         unsigned long offset = reloc_offset();
3057         unsigned long nr_entries =
3058                 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long);
3059
3060         __reloc_toc(offset, nr_entries);
3061
3062         mb();
3063 }
3064
3065 static void unreloc_toc(void)
3066 {
3067         unsigned long offset = reloc_offset();
3068         unsigned long nr_entries =
3069                 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long);
3070
3071         mb();
3072
3073         __reloc_toc(-offset, nr_entries);
3074 }
3075 #endif
3076 #endif
3077
3078 /*
3079  * We enter here early on, when the Open Firmware prom is still
3080  * handling exceptions and the MMU hash table for us.
3081  */
3082
3083 unsigned long __init prom_init(unsigned long r3, unsigned long r4,
3084                                unsigned long pp,
3085                                unsigned long r6, unsigned long r7,
3086                                unsigned long kbase)
3087 {
3088         unsigned long hdr;
3089
3090 #ifdef CONFIG_PPC32
3091         unsigned long offset = reloc_offset();
3092         reloc_got2(offset);
3093 #else
3094         reloc_toc();
3095 #endif
3096
3097         /*
3098          * First zero the BSS
3099          */
3100         memset(&__bss_start, 0, __bss_stop - __bss_start);
3101
3102         /*
3103          * Init interface to Open Firmware, get some node references,
3104          * like /chosen
3105          */
3106         prom_init_client_services(pp);
3107
3108         /*
3109          * See if this OF is old enough that we need to do explicit maps
3110          * and other workarounds
3111          */
3112         prom_find_mmu();
3113
3114         /*
3115          * Init prom stdout device
3116          */
3117         prom_init_stdout();
3118
3119         prom_printf("Preparing to boot %s", linux_banner);
3120
3121         /*
3122          * Get default machine type. At this point, we do not differentiate
3123          * between pSeries SMP and pSeries LPAR
3124          */
3125         of_platform = prom_find_machine_type();
3126         prom_printf("Detected machine type: %x\n", of_platform);
3127
3128 #ifndef CONFIG_NONSTATIC_KERNEL
3129         /* Bail if this is a kdump kernel. */
3130         if (PHYSICAL_START > 0)
3131                 prom_panic("Error: You can't boot a kdump kernel from OF!\n");
3132 #endif
3133
3134         /*
3135          * Check for an initrd
3136          */
3137         prom_check_initrd(r3, r4);
3138
3139         /*
3140          * Do early parsing of command line
3141          */
3142         early_cmdline_parse();
3143
3144 #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
3145         /*
3146          * On pSeries, inform the firmware about our capabilities
3147          */
3148         if (of_platform == PLATFORM_PSERIES ||
3149             of_platform == PLATFORM_PSERIES_LPAR)
3150                 prom_send_capabilities();
3151 #endif
3152
3153         /*
3154          * Copy the CPU hold code
3155          */
3156         if (of_platform != PLATFORM_POWERMAC)
3157                 copy_and_flush(0, kbase, 0x100, 0);
3158
3159         /*
3160          * Initialize memory management within prom_init
3161          */
3162         prom_init_mem();
3163
3164         /*
3165          * Determine which cpu is actually running right _now_
3166          */
3167         prom_find_boot_cpu();
3168
3169         /*
3170          * Initialize display devices
3171          */
3172         prom_check_displays();
3173
3174 #if defined(CONFIG_PPC64) && defined(__BIG_ENDIAN__)
3175         /*
3176          * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else
3177          * that uses the allocator, we need to make sure we get the top of memory
3178          * available for us here...
3179          */
3180         if (of_platform == PLATFORM_PSERIES)
3181                 prom_initialize_tce_table();
3182 #endif
3183
3184         /*
3185          * On non-powermacs, try to instantiate RTAS. PowerMacs don't
3186          * have a usable RTAS implementation.
3187          */
3188         if (of_platform != PLATFORM_POWERMAC &&
3189             of_platform != PLATFORM_OPAL)
3190                 prom_instantiate_rtas();
3191
3192 #ifdef CONFIG_PPC_POWERNV
3193         if (of_platform == PLATFORM_OPAL)
3194                 prom_instantiate_opal();
3195 #endif /* CONFIG_PPC_POWERNV */
3196
3197 #ifdef CONFIG_PPC64
3198         /* instantiate sml */
3199         prom_instantiate_sml();
3200 #endif
3201
3202         /*
3203          * On non-powermacs, put all CPUs in spin-loops.
3204          *
3205          * PowerMacs use a different mechanism to spin CPUs
3206          *
3207          * (This must be done after instanciating RTAS)
3208          */
3209         if (of_platform != PLATFORM_POWERMAC &&
3210             of_platform != PLATFORM_OPAL)
3211                 prom_hold_cpus();
3212
3213         /*
3214          * Fill in some infos for use by the kernel later on
3215          */
3216         if (prom_memory_limit) {
3217                 __be64 val = cpu_to_be64(prom_memory_limit);
3218                 prom_setprop(prom.chosen, "/chosen", "linux,memory-limit",
3219                              &val, sizeof(val));
3220         }
3221 #ifdef CONFIG_PPC64
3222         if (prom_iommu_off)
3223                 prom_setprop(prom.chosen, "/chosen", "linux,iommu-off",
3224                              NULL, 0);
3225
3226         if (prom_iommu_force_on)
3227                 prom_setprop(prom.chosen, "/chosen", "linux,iommu-force-on",
3228                              NULL, 0);
3229
3230         if (prom_tce_alloc_start) {
3231                 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-start",
3232                              &prom_tce_alloc_start,
3233                              sizeof(prom_tce_alloc_start));
3234                 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-end",
3235                              &prom_tce_alloc_end,
3236                              sizeof(prom_tce_alloc_end));
3237         }
3238 #endif
3239
3240         /*
3241          * Fixup any known bugs in the device-tree
3242          */
3243         fixup_device_tree();
3244
3245         /*
3246          * Now finally create the flattened device-tree
3247          */
3248         prom_printf("copying OF device tree...\n");
3249         flatten_device_tree();
3250
3251         /*
3252          * in case stdin is USB and still active on IBM machines...
3253          * Unfortunately quiesce crashes on some powermacs if we have
3254          * closed stdin already (in particular the powerbook 101). It
3255          * appears that the OPAL version of OFW doesn't like it either.
3256          */
3257         if (of_platform != PLATFORM_POWERMAC &&
3258             of_platform != PLATFORM_OPAL)
3259                 prom_close_stdin();
3260
3261         /*
3262          * Call OF "quiesce" method to shut down pending DMA's from
3263          * devices etc...
3264          */
3265         prom_printf("Quiescing Open Firmware ...\n");
3266         call_prom("quiesce", 0, 0);
3267
3268         /*
3269          * And finally, call the kernel passing it the flattened device
3270          * tree and NULL as r5, thus triggering the new entry point which
3271          * is common to us and kexec
3272          */
3273         hdr = dt_header_start;
3274
3275         /* Don't print anything after quiesce under OPAL, it crashes OFW */
3276         if (of_platform != PLATFORM_OPAL) {
3277                 prom_printf("Booting Linux via __start() @ 0x%lx ...\n", kbase);
3278                 prom_debug("->dt_header_start=0x%lx\n", hdr);
3279         }
3280
3281 #ifdef CONFIG_PPC32
3282         reloc_got2(-offset);
3283 #else
3284         unreloc_toc();
3285 #endif
3286
3287 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
3288         /* OPAL early debug gets the OPAL base & entry in r8 and r9 */
3289         __start(hdr, kbase, 0, 0, 0,
3290                 prom_opal_base, prom_opal_entry);
3291 #else
3292         __start(hdr, kbase, 0, 0, 0, 0, 0);
3293 #endif
3294
3295         return 0;
3296 }