arch/powerpc/kernel/prom_init.c

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