kernel/arch/powerpc/kernel/prom_init.c

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