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