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