arch/powerpc/kernel/prom_init.c

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