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