arch/powerpc/kernel/prom_init.c

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