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