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