arch/powerpc/kernel/prom_init.c

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