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