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