arch/powerpc/kernel/prom_init.c

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