kernel/arch/powerpc/kernel/prom_init.c

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