arch/powerpc/kernel/prom_init.c

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