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