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