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