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/config.h>
  20 #include <linux/kernel.h>
  21 #include <linux/string.h>
  22 #include <linux/init.h>
  23 #include <linux/threads.h>
  24 #include <linux/spinlock.h>
  25 #include <linux/types.h>
  26 #include <linux/pci.h>
  27 #include <linux/proc_fs.h>
  28 #include <linux/stringify.h>
  29 #include <linux/delay.h>
  30 #include <linux/initrd.h>
  31 #include <linux/bitops.h>
  32 #include <asm/prom.h>
  33 #include <asm/rtas.h>
  34 #include <asm/page.h>
  35 #include <asm/processor.h>
  36 #include <asm/irq.h>
  37 #include <asm/io.h>
  38 #include <asm/smp.h>
  39 #include <asm/system.h>
  40 #include <asm/mmu.h>
  41 #include <asm/pgtable.h>
  42 #include <asm/pci.h>
  43 #include <asm/iommu.h>
  44 #include <asm/btext.h>
  45 #include <asm/sections.h>
  46 #include <asm/machdep.h>
  47
  48 #ifdef CONFIG_LOGO_LINUX_CLUT224
  49 #include <linux/linux_logo.h>
  50 extern const struct linux_logo logo_linux_clut224;
  51 #endif
  52
  53 /*
  54  * Properties whose value is longer than this get excluded from our
  55  * copy of the device tree. This value does need to be big enough to
  56  * ensure that we don't lose things like the interrupt-map property
  57  * on a PCI-PCI bridge.
  58  */
  59 #define MAX_PROPERTY_LENGTH     (1UL * 1024 * 1024)
  60
  61 /*
  62  * Eventually bump that one up
  63  */
  64 #define DEVTREE_CHUNK_SIZE      0x100000
  65
  66 /*
  67  * This is the size of the local memory reserve map that gets copied
  68  * into the boot params passed to the kernel. That size is totally
  69  * flexible as the kernel just reads the list until it encounters an
  70  * entry with size 0, so it can be changed without breaking binary
  71  * compatibility
  72  */
  73 #define MEM_RESERVE_MAP_SIZE    8
  74
  75 /*
  76  * prom_init() is called very early on, before the kernel text
  77  * and data have been mapped to KERNELBASE.  At this point the code
  78  * is running at whatever address it has been loaded at.
  79  * On ppc32 we compile with -mrelocatable, which means that references
  80  * to extern and static variables get relocated automatically.
  81  * On ppc64 we have to relocate the references explicitly with
  82  * RELOC.  (Note that strings count as static variables.)
  83  *
  84  * Because OF may have mapped I/O devices into the area starting at
  85  * KERNELBASE, particularly on CHRP machines, we can't safely call
  86  * OF once the kernel has been mapped to KERNELBASE.  Therefore all
  87  * OF calls must be done within prom_init().
  88  *
  89  * ADDR is used in calls to call_prom.  The 4th and following
  90  * arguments to call_prom should be 32-bit values.
  91  * On ppc64, 64 bit values are truncated to 32 bits (and
  92  * fortunately don't get interpreted as two arguments).
  93  */
  94 #ifdef CONFIG_PPC64
  95 #define RELOC(x)        (*PTRRELOC(&(x)))
  96 #define ADDR(x)         (u32) add_reloc_offset((unsigned long)(x))
  97 #define OF_WORKAROUNDS  0
  98 #else
  99 #define RELOC(x)        (x)
 100 #define ADDR(x)         (u32) (x)
 101 #define OF_WORKAROUNDS  of_workarounds
 102 int of_workarounds;
 103 #endif
 104
 105 #define OF_WA_CLAIM     1       /* do phys/virt claim separately, then map */
 106 #define OF_WA_LONGTRAIL 2       /* work around longtrail bugs */
 107
 108 #define PROM_BUG() do {                                         \
 109         prom_printf("kernel BUG at %s line 0x%x!\n",            \
 110                     RELOC(__FILE__), __LINE__);                 \
 111         __asm__ __volatile__(".long " BUG_ILLEGAL_INSTR);       \
 112 } while (0)
 113
 114 #ifdef DEBUG_PROM
 115 #define prom_debug(x...)        prom_printf(x)
 116 #else
 117 #define prom_debug(x...)
 118 #endif
 119
 120
 121 typedef u32 prom_arg_t;
 122
 123 struct prom_args {
 124         u32 service;
 125         u32 nargs;
 126         u32 nret;
 127         prom_arg_t args[10];
 128 };
 129
 130 struct prom_t {
 131         ihandle root;
 132         phandle chosen;
 133         int cpu;
 134         ihandle stdout;
 135         ihandle mmumap;
 136         ihandle memory;
 137 };
 138
 139 struct mem_map_entry {
 140         u64     base;
 141         u64     size;
 142 };
 143
 144 typedef u32 cell_t;
 145
 146 extern void __start(unsigned long r3, unsigned long r4, unsigned long r5);
 147
 148 #ifdef CONFIG_PPC64
 149 extern int enter_prom(struct prom_args *args, unsigned long entry);
 150 #else
 151 static inline int enter_prom(struct prom_args *args, unsigned long entry)
 152 {
 153         return ((int (*)(struct prom_args *))entry)(args);
 154 }
 155 #endif
 156
 157 extern void copy_and_flush(unsigned long dest, unsigned long src,
 158                            unsigned long size, unsigned long offset);
 159
 160 /* prom structure */
 161 static struct prom_t __initdata prom;
 162
 163 static unsigned long prom_entry __initdata;
 164
 165 #define PROM_SCRATCH_SIZE 256
 166
 167 static char __initdata of_stdout_device[256];
 168 static char __initdata prom_scratch[PROM_SCRATCH_SIZE];
 169
 170 static unsigned long __initdata dt_header_start;
 171 static unsigned long __initdata dt_struct_start, dt_struct_end;
 172 static unsigned long __initdata dt_string_start, dt_string_end;
 173
 174 static unsigned long __initdata prom_initrd_start, prom_initrd_end;
 175
 176 #ifdef CONFIG_PPC64
 177 static int __initdata iommu_force_on;
 178 static int __initdata ppc64_iommu_off;
 179 static unsigned long __initdata prom_tce_alloc_start;
 180 static unsigned long __initdata prom_tce_alloc_end;
 181 #endif
 182
 183 /* Platforms codes are now obsolete in the kernel. Now only used within this
 184  * file and ultimately gone too. Feel free to change them if you need, they
 185  * are not shared with anything outside of this file anymore
 186  */
 187 #define PLATFORM_PSERIES        0x0100
 188 #define PLATFORM_PSERIES_LPAR   0x0101
 189 #define PLATFORM_LPAR           0x0001
 190 #define PLATFORM_POWERMAC       0x0400
 191 #define PLATFORM_GENERIC        0x0500
 192
 193 static int __initdata of_platform;
 194
 195 static char __initdata prom_cmd_line[COMMAND_LINE_SIZE];
 196
 197 static unsigned long __initdata prom_memory_limit;
 198
 199 static unsigned long __initdata alloc_top;
 200 static unsigned long __initdata alloc_top_high;
 201 static unsigned long __initdata alloc_bottom;
 202 static unsigned long __initdata rmo_top;
 203 static unsigned long __initdata ram_top;
 204
 205 #ifdef CONFIG_KEXEC
 206 static unsigned long __initdata prom_crashk_base;
 207 static unsigned long __initdata prom_crashk_size;
 208 #endif
 209
 210 static struct mem_map_entry __initdata mem_reserve_map[MEM_RESERVE_MAP_SIZE];
 211 static int __initdata mem_reserve_cnt;
 212
 213 static cell_t __initdata regbuf[1024];
 214
 215
 216 #define MAX_CPU_THREADS 2
 217
 218 /*
 219  * Error results ... some OF calls will return "-1" on error, some
 220  * will return 0, some will return either. To simplify, here are
 221  * macros to use with any ihandle or phandle return value to check if
 222  * it is valid
 223  */
 224
 225 #define PROM_ERROR              (-1u)
 226 #define PHANDLE_VALID(p)        ((p) != 0 && (p) != PROM_ERROR)
 227 #define IHANDLE_VALID(i)        ((i) != 0 && (i) != PROM_ERROR)
 228
 229
 230 /* This is the one and *ONLY* place where we actually call open
 231  * firmware.
 232  */
 233
 234 static int __init call_prom(const char *service, int nargs, int nret, ...)
 235 {
 236         int i;
 237         struct prom_args args;
 238         va_list list;
 239
 240         args.service = ADDR(service);
 241         args.nargs = nargs;
 242         args.nret = nret;
 243
 244         va_start(list, nret);
 245         for (i = 0; i < nargs; i++)
 246                 args.args[i] = va_arg(list, prom_arg_t);
 247         va_end(list);
 248
 249         for (i = 0; i < nret; i++)
 250                 args.args[nargs+i] = 0;
 251
 252         if (enter_prom(&args, RELOC(prom_entry)) < 0)
 253                 return PROM_ERROR;
 254
 255         return (nret > 0) ? args.args[nargs] : 0;
 256 }
 257
 258 static int __init call_prom_ret(const char *service, int nargs, int nret,
 259                                 prom_arg_t *rets, ...)
 260 {
 261         int i;
 262         struct prom_args args;
 263         va_list list;
 264
 265         args.service = ADDR(service);
 266         args.nargs = nargs;
 267         args.nret = nret;
 268
 269         va_start(list, rets);
 270         for (i = 0; i < nargs; i++)
 271                 args.args[i] = va_arg(list, prom_arg_t);
 272         va_end(list);
 273
 274         for (i = 0; i < nret; i++)
 275                 args.args[nargs+i] = 0;
 276
 277         if (enter_prom(&args, RELOC(prom_entry)) < 0)
 278                 return PROM_ERROR;
 279
 280         if (rets != NULL)
 281                 for (i = 1; i < nret; ++i)
 282                         rets[i-1] = args.args[nargs+i];
 283
 284         return (nret > 0) ? args.args[nargs] : 0;
 285 }
 286
 287
 288 static void __init prom_print(const char *msg)
 289 {
 290         const char *p, *q;
 291         struct prom_t *_prom = &RELOC(prom);
 292
 293         if (_prom->stdout == 0)
 294                 return;
 295
 296         for (p = msg; *p != 0; p = q) {
 297                 for (q = p; *q != 0 && *q != '\n'; ++q)
 298                         ;
 299                 if (q > p)
 300                         call_prom("write", 3, 1, _prom->stdout, p, q - p);
 301                 if (*q == 0)
 302                         break;
 303                 ++q;
 304                 call_prom("write", 3, 1, _prom->stdout, ADDR("\r\n"), 2);
 305         }
 306 }
 307
 308
 309 static void __init prom_print_hex(unsigned long val)
 310 {
 311         int i, nibbles = sizeof(val)*2;
 312         char buf[sizeof(val)*2+1];
 313         struct prom_t *_prom = &RELOC(prom);
 314
 315         for (i = nibbles-1;  i >= 0;  i--) {
 316                 buf[i] = (val & 0xf) + '0';
 317                 if (buf[i] > '9')
 318                         buf[i] += ('a'-'0'-10);
 319                 val >>= 4;
 320         }
 321         buf[nibbles] = '\0';
 322         call_prom("write", 3, 1, _prom->stdout, buf, nibbles);
 323 }
 324
 325
 326 static void __init prom_printf(const char *format, ...)
 327 {
 328         const char *p, *q, *s;
 329         va_list args;
 330         unsigned long v;
 331         struct prom_t *_prom = &RELOC(prom);
 332
 333         va_start(args, format);
 334 #ifdef CONFIG_PPC64
 335         format = PTRRELOC(format);
 336 #endif
 337         for (p = format; *p != 0; p = q) {
 338                 for (q = p; *q != 0 && *q != '\n' && *q != '%'; ++q)
 339                         ;
 340                 if (q > p)
 341                         call_prom("write", 3, 1, _prom->stdout, p, q - p);
 342                 if (*q == 0)
 343                         break;
 344                 if (*q == '\n') {
 345                         ++q;
 346                         call_prom("write", 3, 1, _prom->stdout,
 347                                   ADDR("\r\n"), 2);
 348                         continue;
 349                 }
 350                 ++q;
 351                 if (*q == 0)
 352                         break;
 353                 switch (*q) {
 354                 case 's':
 355                         ++q;
 356                         s = va_arg(args, const char *);
 357                         prom_print(s);
 358                         break;
 359                 case 'x':
 360                         ++q;
 361                         v = va_arg(args, unsigned long);
 362                         prom_print_hex(v);
 363                         break;
 364                 }
 365         }
 366 }
 367
 368
 369 static unsigned int __init prom_claim(unsigned long virt, unsigned long size,
 370                                 unsigned long align)
 371 {
 372         struct prom_t *_prom = &RELOC(prom);
 373
 374         if (align == 0 && (OF_WORKAROUNDS & OF_WA_CLAIM)) {
 375                 /*
 376                  * Old OF requires we claim physical and virtual separately
 377                  * and then map explicitly (assuming virtual mode)
 378                  */
 379                 int ret;
 380                 prom_arg_t result;
 381
 382                 ret = call_prom_ret("call-method", 5, 2, &result,
 383                                     ADDR("claim"), _prom->memory,
 384                                     align, size, virt);
 385                 if (ret != 0 || result == -1)
 386                         return -1;
 387                 ret = call_prom_ret("call-method", 5, 2, &result,
 388                                     ADDR("claim"), _prom->mmumap,
 389                                     align, size, virt);
 390                 if (ret != 0) {
 391                         call_prom("call-method", 4, 1, ADDR("release"),
 392                                   _prom->memory, size, virt);
 393                         return -1;
 394                 }
 395                 /* the 0x12 is M (coherence) + PP == read/write */
 396                 call_prom("call-method", 6, 1,
 397                           ADDR("map"), _prom->mmumap, 0x12, size, virt, virt);
 398                 return virt;
 399         }
 400         return call_prom("claim", 3, 1, (prom_arg_t)virt, (prom_arg_t)size,
 401                          (prom_arg_t)align);
 402 }
 403
 404 static void __init __attribute__((noreturn)) prom_panic(const char *reason)
 405 {
 406 #ifdef CONFIG_PPC64
 407         reason = PTRRELOC(reason);
 408 #endif
 409         prom_print(reason);
 410         /* Do not call exit because it clears the screen on pmac
 411          * it also causes some sort of double-fault on early pmacs */
 412         if (RELOC(of_platform) == PLATFORM_POWERMAC)
 413                 asm("trap\n");
 414
 415         /* ToDo: should put up an SRC here on p/iSeries */
 416         call_prom("exit", 0, 0);
 417
 418         for (;;)                        /* should never get here */
 419                 ;
 420 }
 421
 422
 423 static int __init prom_next_node(phandle *nodep)
 424 {
 425         phandle node;
 426
 427         if ((node = *nodep) != 0
 428             && (*nodep = call_prom("child", 1, 1, node)) != 0)
 429                 return 1;
 430         if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
 431                 return 1;
 432         for (;;) {
 433                 if ((node = call_prom("parent", 1, 1, node)) == 0)
 434                         return 0;
 435                 if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
 436                         return 1;
 437         }
 438 }
 439
 440 static int inline prom_getprop(phandle node, const char *pname,
 441                                void *value, size_t valuelen)
 442 {
 443         return call_prom("getprop", 4, 1, node, ADDR(pname),
 444                          (u32)(unsigned long) value, (u32) valuelen);
 445 }
 446
 447 static int inline prom_getproplen(phandle node, const char *pname)
 448 {
 449         return call_prom("getproplen", 2, 1, node, ADDR(pname));
 450 }
 451
 452 static void add_string(char **str, const char *q)
 453 {
 454         char *p = *str;
 455
 456         while (*q)
 457                 *p++ = *q++;
 458         *p++ = ' ';
 459         *str = p;
 460 }
 461
 462 static char *tohex(unsigned int x)
 463 {
 464         static char digits[] = "0123456789abcdef";
 465         static char result[9];
 466         int i;
 467
 468         result[8] = 0;
 469         i = 8;
 470         do {
 471                 --i;
 472                 result[i] = digits[x & 0xf];
 473                 x >>= 4;
 474         } while (x != 0 && i > 0);
 475         return &result[i];
 476 }
 477
 478 static int __init prom_setprop(phandle node, const char *nodename,
 479                                const char *pname, void *value, size_t valuelen)
 480 {
 481         char cmd[256], *p;
 482
 483         if (!(OF_WORKAROUNDS & OF_WA_LONGTRAIL))
 484                 return call_prom("setprop", 4, 1, node, ADDR(pname),
 485                                  (u32)(unsigned long) value, (u32) valuelen);
 486
 487         /* gah... setprop doesn't work on longtrail, have to use interpret */
 488         p = cmd;
 489         add_string(&p, "dev");
 490         add_string(&p, nodename);
 491         add_string(&p, tohex((u32)(unsigned long) value));
 492         add_string(&p, tohex(valuelen));
 493         add_string(&p, tohex(ADDR(pname)));
 494         add_string(&p, tohex(strlen(RELOC(pname))));
 495         add_string(&p, "property");
 496         *p = 0;
 497         return call_prom("interpret", 1, 1, (u32)(unsigned long) cmd);
 498 }
 499
 500 /* We can't use the standard versions because of RELOC headaches. */
 501 #define isxdigit(c)     (('0' <= (c) && (c) <= '9') \
 502                          || ('a' <= (c) && (c) <= 'f') \
 503                          || ('A' <= (c) && (c) <= 'F'))
 504
 505 #define isdigit(c)      ('0' <= (c) && (c) <= '9')
 506 #define islower(c)      ('a' <= (c) && (c) <= 'z')
 507 #define toupper(c)      (islower(c) ? ((c) - 'a' + 'A') : (c))
 508
 509 unsigned long prom_strtoul(const char *cp, const char **endp)
 510 {
 511         unsigned long result = 0, base = 10, value;
 512
 513         if (*cp == '0') {
 514                 base = 8;
 515                 cp++;
 516                 if (toupper(*cp) == 'X') {
 517                         cp++;
 518                         base = 16;
 519                 }
 520         }
 521
 522         while (isxdigit(*cp) &&
 523                (value = isdigit(*cp) ? *cp - '0' : toupper(*cp) - 'A' + 10) < base) {
 524                 result = result * base + value;
 525                 cp++;
 526         }
 527
 528         if (endp)
 529                 *endp = cp;
 530
 531         return result;
 532 }
 533
 534 unsigned long prom_memparse(const char *ptr, const char **retptr)
 535 {
 536         unsigned long ret = prom_strtoul(ptr, retptr);
 537         int shift = 0;
 538
 539         /*
 540          * We can't use a switch here because GCC *may* generate a
 541          * jump table which won't work, because we're not running at
 542          * the address we're linked at.
 543          */
 544         if ('G' == **retptr || 'g' == **retptr)
 545                 shift = 30;
 546
 547         if ('M' == **retptr || 'm' == **retptr)
 548                 shift = 20;
 549
 550         if ('K' == **retptr || 'k' == **retptr)
 551                 shift = 10;
 552
 553         if (shift) {
 554                 ret <<= shift;
 555                 (*retptr)++;
 556         }
 557
 558         return ret;
 559 }
 560
 561 /*
 562  * Early parsing of the command line passed to the kernel, used for
 563  * "mem=x" and the options that affect the iommu
 564  */
 565 static void __init early_cmdline_parse(void)
 566 {
 567         struct prom_t *_prom = &RELOC(prom);
 568         const char *opt;
 569         char *p;
 570         int l = 0;
 571
 572         RELOC(prom_cmd_line[0]) = 0;
 573         p = RELOC(prom_cmd_line);
 574         if ((long)_prom->chosen > 0)
 575                 l = prom_getprop(_prom->chosen, "bootargs", p, COMMAND_LINE_SIZE-1);
 576 #ifdef CONFIG_CMDLINE
 577         if (l == 0) /* dbl check */
 578                 strlcpy(RELOC(prom_cmd_line),
 579                         RELOC(CONFIG_CMDLINE), sizeof(prom_cmd_line));
 580 #endif /* CONFIG_CMDLINE */
 581         prom_printf("command line: %s\n", RELOC(prom_cmd_line));
 582
 583 #ifdef CONFIG_PPC64
 584         opt = strstr(RELOC(prom_cmd_line), RELOC("iommu="));
 585         if (opt) {
 586                 prom_printf("iommu opt is: %s\n", opt);
 587                 opt += 6;
 588                 while (*opt && *opt == ' ')
 589                         opt++;
 590                 if (!strncmp(opt, RELOC("off"), 3))
 591                         RELOC(ppc64_iommu_off) = 1;
 592                 else if (!strncmp(opt, RELOC("force"), 5))
 593                         RELOC(iommu_force_on) = 1;
 594         }
 595 #endif
 596
 597         opt = strstr(RELOC(prom_cmd_line), RELOC("mem="));
 598         if (opt) {
 599                 opt += 4;
 600                 RELOC(prom_memory_limit) = prom_memparse(opt, (const char **)&opt);
 601 #ifdef CONFIG_PPC64
 602                 /* Align to 16 MB == size of ppc64 large page */
 603                 RELOC(prom_memory_limit) = ALIGN(RELOC(prom_memory_limit), 0x1000000);
 604 #endif
 605         }
 606
 607 #ifdef CONFIG_KEXEC
 608         /*
 609          * crashkernel=size@addr specifies the location to reserve for
 610          * crash kernel.
 611          */
 612         opt = strstr(RELOC(prom_cmd_line), RELOC("crashkernel="));
 613         if (opt) {
 614                 opt += 12;
 615                 RELOC(prom_crashk_size) =
 616                         prom_memparse(opt, (const char **)&opt);
 617
 618                 if (ALIGN(RELOC(prom_crashk_size), 0x1000000) !=
 619                         RELOC(prom_crashk_size)) {
 620                         prom_printf("Warning: crashkernel size is not "
 621                                         "aligned to 16MB\n");
 622                 }
 623
 624                 /*
 625                  * At present, the crash kernel always run at 32MB.
 626                  * Just ignore whatever user passed.
 627                  */
 628                 RELOC(prom_crashk_base) = 0x2000000;
 629                 if (*opt == '@') {
 630                         prom_printf("Warning: PPC64 kdump kernel always runs "
 631                                         "at 32 MB\n");
 632                 }
 633         }
 634 #endif
 635 }
 636
 637 #ifdef CONFIG_PPC_PSERIES
 638 /*
 639  * There are two methods for telling firmware what our capabilities are.
 640  * Newer machines have an "ibm,client-architecture-support" method on the
 641  * root node.  For older machines, we have to call the "process-elf-header"
 642  * method in the /packages/elf-loader node, passing it a fake 32-bit
 643  * ELF header containing a couple of PT_NOTE sections that contain
 644  * structures that contain various information.
 645  */
 646
 647 /*
 648  * New method - extensible architecture description vector.
 649  *
 650  * Because the description vector contains a mix of byte and word
 651  * values, we declare it as an unsigned char array, and use this
 652  * macro to put word values in.
 653  */
 654 #define W(x)    ((x) >> 24) & 0xff, ((x) >> 16) & 0xff, \
 655                 ((x) >> 8) & 0xff, (x) & 0xff
 656
 657 /* Option vector bits - generic bits in byte 1 */
 658 #define OV_IGNORE               0x80    /* ignore this vector */
 659 #define OV_CESSATION_POLICY     0x40    /* halt if unsupported option present*/
 660
 661 /* Option vector 1: processor architectures supported */
 662 #define OV1_PPC_2_00            0x80    /* set if we support PowerPC 2.00 */
 663 #define OV1_PPC_2_01            0x40    /* set if we support PowerPC 2.01 */
 664 #define OV1_PPC_2_02            0x20    /* set if we support PowerPC 2.02 */
 665 #define OV1_PPC_2_03            0x10    /* set if we support PowerPC 2.03 */
 666 #define OV1_PPC_2_04            0x08    /* set if we support PowerPC 2.04 */
 667 #define OV1_PPC_2_05            0x04    /* set if we support PowerPC 2.05 */
 668
 669 /* Option vector 2: Open Firmware options supported */
 670 #define OV2_REAL_MODE           0x20    /* set if we want OF in real mode */
 671
 672 /* Option vector 3: processor options supported */
 673 #define OV3_FP                  0x80    /* floating point */
 674 #define OV3_VMX                 0x40    /* VMX/Altivec */
 675
 676 /* Option vector 5: PAPR/OF options supported */
 677 #define OV5_LPAR                0x80    /* logical partitioning supported */
 678 #define OV5_SPLPAR              0x40    /* shared-processor LPAR supported */
 679 /* ibm,dynamic-reconfiguration-memory property supported */
 680 #define OV5_DRCONF_MEMORY       0x20
 681 #define OV5_LARGE_PAGES         0x10    /* large pages supported */
 682
 683 /*
 684  * The architecture vector has an array of PVR mask/value pairs,
 685  * followed by # option vectors - 1, followed by the option vectors.
 686  */
 687 static unsigned char ibm_architecture_vec[] = {
 688         W(0xfffe0000), W(0x003a0000),   /* POWER5/POWER5+ */
 689         W(0xffff0000), W(0x003e0000),   /* POWER6 */
 690         W(0xfffffffe), W(0x0f000001),   /* all 2.04-compliant and earlier */
 691         5 - 1,                          /* 5 option vectors */
 692
 693         /* option vector 1: processor architectures supported */
 694         3 - 1,                          /* length */
 695         0,                              /* don't ignore, don't halt */
 696         OV1_PPC_2_00 | OV1_PPC_2_01 | OV1_PPC_2_02 | OV1_PPC_2_03 |
 697         OV1_PPC_2_04 | OV1_PPC_2_05,
 698
 699         /* option vector 2: Open Firmware options supported */
 700         34 - 1,                         /* length */
 701         OV2_REAL_MODE,
 702         0, 0,
 703         W(0xffffffff),                  /* real_base */
 704         W(0xffffffff),                  /* real_size */
 705         W(0xffffffff),                  /* virt_base */
 706         W(0xffffffff),                  /* virt_size */
 707         W(0xffffffff),                  /* load_base */
 708         W(64),                          /* 128MB min RMA */
 709         W(0xffffffff),                  /* full client load */
 710         0,                              /* min RMA percentage of total RAM */
 711         48,                             /* max log_2(hash table size) */
 712
 713         /* option vector 3: processor options supported */
 714         3 - 1,                          /* length */
 715         0,                              /* don't ignore, don't halt */
 716         OV3_FP | OV3_VMX,
 717
 718         /* option vector 4: IBM PAPR implementation */
 719         2 - 1,                          /* length */
 720         0,                              /* don't halt */
 721
 722         /* option vector 5: PAPR/OF options */
 723         3 - 1,                          /* length */
 724         0,                              /* don't ignore, don't halt */
 725         OV5_LPAR | OV5_SPLPAR | OV5_LARGE_PAGES,
 726 };
 727
 728 /* Old method - ELF header with PT_NOTE sections */
 729 static struct fake_elf {
 730         Elf32_Ehdr      elfhdr;
 731         Elf32_Phdr      phdr[2];
 732         struct chrpnote {
 733                 u32     namesz;
 734                 u32     descsz;
 735                 u32     type;
 736                 char    name[8];        /* "PowerPC" */
 737                 struct chrpdesc {
 738                         u32     real_mode;
 739                         u32     real_base;
 740                         u32     real_size;
 741                         u32     virt_base;
 742                         u32     virt_size;
 743                         u32     load_base;
 744                 } chrpdesc;
 745         } chrpnote;
 746         struct rpanote {
 747                 u32     namesz;
 748                 u32     descsz;
 749                 u32     type;
 750                 char    name[24];       /* "IBM,RPA-Client-Config" */
 751                 struct rpadesc {
 752                         u32     lpar_affinity;
 753                         u32     min_rmo_size;
 754                         u32     min_rmo_percent;
 755                         u32     max_pft_size;
 756                         u32     splpar;
 757                         u32     min_load;
 758                         u32     new_mem_def;
 759                         u32     ignore_me;
 760                 } rpadesc;
 761         } rpanote;
 762 } fake_elf = {
 763         .elfhdr = {
 764                 .e_ident = { 0x7f, 'E', 'L', 'F',
 765                              ELFCLASS32, ELFDATA2MSB, EV_CURRENT },
 766                 .e_type = ET_EXEC,      /* yeah right */
 767                 .e_machine = EM_PPC,
 768                 .e_version = EV_CURRENT,
 769                 .e_phoff = offsetof(struct fake_elf, phdr),
 770                 .e_phentsize = sizeof(Elf32_Phdr),
 771                 .e_phnum = 2
 772         },
 773         .phdr = {
 774                 [0] = {
 775                         .p_type = PT_NOTE,
 776                         .p_offset = offsetof(struct fake_elf, chrpnote),
 777                         .p_filesz = sizeof(struct chrpnote)
 778                 }, [1] = {
 779                         .p_type = PT_NOTE,
 780                         .p_offset = offsetof(struct fake_elf, rpanote),
 781                         .p_filesz = sizeof(struct rpanote)
 782                 }
 783         },
 784         .chrpnote = {
 785                 .namesz = sizeof("PowerPC"),
 786                 .descsz = sizeof(struct chrpdesc),
 787                 .type = 0x1275,
 788                 .name = "PowerPC",
 789                 .chrpdesc = {
 790                         .real_mode = ~0U,       /* ~0 means "don't care" */
 791                         .real_base = ~0U,
 792                         .real_size = ~0U,
 793                         .virt_base = ~0U,
 794                         .virt_size = ~0U,
 795                         .load_base = ~0U
 796                 },
 797         },
 798         .rpanote = {
 799                 .namesz = sizeof("IBM,RPA-Client-Config"),
 800                 .descsz = sizeof(struct rpadesc),
 801                 .type = 0x12759999,
 802                 .name = "IBM,RPA-Client-Config",
 803                 .rpadesc = {
 804                         .lpar_affinity = 0,
 805                         .min_rmo_size = 64,     /* in megabytes */
 806                         .min_rmo_percent = 0,
 807                         .max_pft_size = 48,     /* 2^48 bytes max PFT size */
 808                         .splpar = 1,
 809                         .min_load = ~0U,
 810                         .new_mem_def = 0
 811                 }
 812         }
 813 };
 814
 815 static void __init prom_send_capabilities(void)
 816 {
 817         ihandle elfloader, root;
 818         prom_arg_t ret;
 819
 820         root = call_prom("open", 1, 1, ADDR("/"));
 821         if (root != 0) {
 822                 /* try calling the ibm,client-architecture-support method */
 823                 if (call_prom_ret("call-method", 3, 2, &ret,
 824                                   ADDR("ibm,client-architecture-support"),
 825                                   root,
 826                                   ADDR(ibm_architecture_vec)) == 0) {
 827                         /* the call exists... */
 828                         if (ret)
 829                                 prom_printf("WARNING: ibm,client-architecture"
 830                                             "-support call FAILED!\n");
 831                         call_prom("close", 1, 0, root);
 832                         return;
 833                 }
 834                 call_prom("close", 1, 0, root);
 835         }
 836
 837         /* no ibm,client-architecture-support call, try the old way */
 838         elfloader = call_prom("open", 1, 1, ADDR("/packages/elf-loader"));
 839         if (elfloader == 0) {
 840                 prom_printf("couldn't open /packages/elf-loader\n");
 841                 return;
 842         }
 843         call_prom("call-method", 3, 1, ADDR("process-elf-header"),
 844                         elfloader, ADDR(&fake_elf));
 845         call_prom("close", 1, 0, elfloader);
 846 }
 847 #endif
 848
 849 /*
 850  * Memory allocation strategy... our layout is normally:
 851  *
 852  *  at 14Mb or more we have vmlinux, then a gap and initrd.  In some
 853  *  rare cases, initrd might end up being before the kernel though.
 854  *  We assume this won't override the final kernel at 0, we have no
 855  *  provision to handle that in this version, but it should hopefully
 856  *  never happen.
 857  *
 858  *  alloc_top is set to the top of RMO, eventually shrink down if the
 859  *  TCEs overlap
 860  *
 861  *  alloc_bottom is set to the top of kernel/initrd
 862  *
 863  *  from there, allocations are done this way : rtas is allocated
 864  *  topmost, and the device-tree is allocated from the bottom. We try
 865  *  to grow the device-tree allocation as we progress. If we can't,
 866  *  then we fail, we don't currently have a facility to restart
 867  *  elsewhere, but that shouldn't be necessary.
 868  *
 869  *  Note that calls to reserve_mem have to be done explicitly, memory
 870  *  allocated with either alloc_up or alloc_down isn't automatically
 871  *  reserved.
 872  */
 873
 874
 875 /*
 876  * Allocates memory in the RMO upward from the kernel/initrd
 877  *
 878  * When align is 0, this is a special case, it means to allocate in place
 879  * at the current location of alloc_bottom or fail (that is basically
 880  * extending the previous allocation). Used for the device-tree flattening
 881  */
 882 static unsigned long __init alloc_up(unsigned long size, unsigned long align)
 883 {
 884         unsigned long base = RELOC(alloc_bottom);
 885         unsigned long addr = 0;
 886
 887         if (align)
 888                 base = _ALIGN_UP(base, align);
 889         prom_debug("alloc_up(%x, %x)\n", size, align);
 890         if (RELOC(ram_top) == 0)
 891                 prom_panic("alloc_up() called with mem not initialized\n");
 892
 893         if (align)
 894                 base = _ALIGN_UP(RELOC(alloc_bottom), align);
 895         else
 896                 base = RELOC(alloc_bottom);
 897
 898         for(; (base + size) <= RELOC(alloc_top);
 899             base = _ALIGN_UP(base + 0x100000, align)) {
 900                 prom_debug("    trying: 0x%x\n\r", base);
 901                 addr = (unsigned long)prom_claim(base, size, 0);
 902                 if (addr != PROM_ERROR && addr != 0)
 903                         break;
 904                 addr = 0;
 905                 if (align == 0)
 906                         break;
 907         }
 908         if (addr == 0)
 909                 return 0;
 910         RELOC(alloc_bottom) = addr;
 911
 912         prom_debug(" -> %x\n", addr);
 913         prom_debug("  alloc_bottom : %x\n", RELOC(alloc_bottom));
 914         prom_debug("  alloc_top    : %x\n", RELOC(alloc_top));
 915         prom_debug("  alloc_top_hi : %x\n", RELOC(alloc_top_high));
 916         prom_debug("  rmo_top      : %x\n", RELOC(rmo_top));
 917         prom_debug("  ram_top      : %x\n", RELOC(ram_top));
 918
 919         return addr;
 920 }
 921
 922 /*
 923  * Allocates memory downward, either from top of RMO, or if highmem
 924  * is set, from the top of RAM.  Note that this one doesn't handle
 925  * failures.  It does claim memory if highmem is not set.
 926  */
 927 static unsigned long __init alloc_down(unsigned long size, unsigned long align,
 928                                        int highmem)
 929 {
 930         unsigned long base, addr = 0;
 931
 932         prom_debug("alloc_down(%x, %x, %s)\n", size, align,
 933                    highmem ? RELOC("(high)") : RELOC("(low)"));
 934         if (RELOC(ram_top) == 0)
 935                 prom_panic("alloc_down() called with mem not initialized\n");
 936
 937         if (highmem) {
 938                 /* Carve out storage for the TCE table. */
 939                 addr = _ALIGN_DOWN(RELOC(alloc_top_high) - size, align);
 940                 if (addr <= RELOC(alloc_bottom))
 941                         return 0;
 942                 /* Will we bump into the RMO ? If yes, check out that we
 943                  * didn't overlap existing allocations there, if we did,
 944                  * we are dead, we must be the first in town !
 945                  */
 946                 if (addr < RELOC(rmo_top)) {
 947                         /* Good, we are first */
 948                         if (RELOC(alloc_top) == RELOC(rmo_top))
 949                                 RELOC(alloc_top) = RELOC(rmo_top) = addr;
 950                         else
 951                                 return 0;
 952                 }
 953                 RELOC(alloc_top_high) = addr;
 954                 goto bail;
 955         }
 956
 957         base = _ALIGN_DOWN(RELOC(alloc_top) - size, align);
 958         for (; base > RELOC(alloc_bottom);
 959              base = _ALIGN_DOWN(base - 0x100000, align))  {
 960                 prom_debug("    trying: 0x%x\n\r", base);
 961                 addr = (unsigned long)prom_claim(base, size, 0);
 962                 if (addr != PROM_ERROR && addr != 0)
 963                         break;
 964                 addr = 0;
 965         }
 966         if (addr == 0)
 967                 return 0;
 968         RELOC(alloc_top) = addr;
 969
 970  bail:
 971         prom_debug(" -> %x\n", addr);
 972         prom_debug("  alloc_bottom : %x\n", RELOC(alloc_bottom));
 973         prom_debug("  alloc_top    : %x\n", RELOC(alloc_top));
 974         prom_debug("  alloc_top_hi : %x\n", RELOC(alloc_top_high));
 975         prom_debug("  rmo_top      : %x\n", RELOC(rmo_top));
 976         prom_debug("  ram_top      : %x\n", RELOC(ram_top));
 977
 978         return addr;
 979 }
 980
 981 /*
 982  * Parse a "reg" cell
 983  */
 984 static unsigned long __init prom_next_cell(int s, cell_t **cellp)
 985 {
 986         cell_t *p = *cellp;
 987         unsigned long r = 0;
 988
 989         /* Ignore more than 2 cells */
 990         while (s > sizeof(unsigned long) / 4) {
 991                 p++;
 992                 s--;
 993         }
 994         r = *p++;
 995 #ifdef CONFIG_PPC64
 996         if (s > 1) {
 997                 r <<= 32;
 998                 r |= *(p++);
 999         }
1000 #endif
1001         *cellp = p;
1002         return r;
1003 }
1004
1005 /*
1006  * Very dumb function for adding to the memory reserve list, but
1007  * we don't need anything smarter at this point
1008  *
1009  * XXX Eventually check for collisions.  They should NEVER happen.
1010  * If problems seem to show up, it would be a good start to track
1011  * them down.
1012  */
1013 static void reserve_mem(u64 base, u64 size)
1014 {
1015         u64 top = base + size;
1016         unsigned long cnt = RELOC(mem_reserve_cnt);
1017
1018         if (size == 0)
1019                 return;
1020
1021         /* We need to always keep one empty entry so that we
1022          * have our terminator with "size" set to 0 since we are
1023          * dumb and just copy this entire array to the boot params
1024          */
1025         base = _ALIGN_DOWN(base, PAGE_SIZE);
1026         top = _ALIGN_UP(top, PAGE_SIZE);
1027         size = top - base;
1028
1029         if (cnt >= (MEM_RESERVE_MAP_SIZE - 1))
1030                 prom_panic("Memory reserve map exhausted !\n");
1031         RELOC(mem_reserve_map)[cnt].base = base;
1032         RELOC(mem_reserve_map)[cnt].size = size;
1033         RELOC(mem_reserve_cnt) = cnt + 1;
1034 }
1035
1036 /*
1037  * Initialize memory allocation mecanism, parse "memory" nodes and
1038  * obtain that way the top of memory and RMO to setup out local allocator
1039  */
1040 static void __init prom_init_mem(void)
1041 {
1042         phandle node;
1043         char *path, type[64];
1044         unsigned int plen;
1045         cell_t *p, *endp;
1046         struct prom_t *_prom = &RELOC(prom);
1047         u32 rac, rsc;
1048
1049         /*
1050          * We iterate the memory nodes to find
1051          * 1) top of RMO (first node)
1052          * 2) top of memory
1053          */
1054         rac = 2;
1055         prom_getprop(_prom->root, "#address-cells", &rac, sizeof(rac));
1056         rsc = 1;
1057         prom_getprop(_prom->root, "#size-cells", &rsc, sizeof(rsc));
1058         prom_debug("root_addr_cells: %x\n", (unsigned long) rac);
1059         prom_debug("root_size_cells: %x\n", (unsigned long) rsc);
1060
1061         prom_debug("scanning memory:\n");
1062         path = RELOC(prom_scratch);
1063
1064         for (node = 0; prom_next_node(&node); ) {
1065                 type[0] = 0;
1066                 prom_getprop(node, "device_type", type, sizeof(type));
1067
1068                 if (type[0] == 0) {
1069                         /*
1070                          * CHRP Longtrail machines have no device_type
1071                          * on the memory node, so check the name instead...
1072                          */
1073                         prom_getprop(node, "name", type, sizeof(type));
1074                 }
1075                 if (strcmp(type, RELOC("memory")))
1076                         continue;
1077
1078                 plen = prom_getprop(node, "reg", RELOC(regbuf), sizeof(regbuf));
1079                 if (plen > sizeof(regbuf)) {
1080                         prom_printf("memory node too large for buffer !\n");
1081                         plen = sizeof(regbuf);
1082                 }
1083                 p = RELOC(regbuf);
1084                 endp = p + (plen / sizeof(cell_t));
1085
1086 #ifdef DEBUG_PROM
1087                 memset(path, 0, PROM_SCRATCH_SIZE);
1088                 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
1089                 prom_debug("  node %s :\n", path);
1090 #endif /* DEBUG_PROM */
1091
1092                 while ((endp - p) >= (rac + rsc)) {
1093                         unsigned long base, size;
1094
1095                         base = prom_next_cell(rac, &p);
1096                         size = prom_next_cell(rsc, &p);
1097
1098                         if (size == 0)
1099                                 continue;
1100                         prom_debug("    %x %x\n", base, size);
1101                         if (base == 0 && (RELOC(of_platform) & PLATFORM_LPAR))
1102                                 RELOC(rmo_top) = size;
1103                         if ((base + size) > RELOC(ram_top))
1104                                 RELOC(ram_top) = base + size;
1105                 }
1106         }
1107
1108         RELOC(alloc_bottom) = PAGE_ALIGN((unsigned long)&RELOC(_end) + 0x4000);
1109
1110         /* Check if we have an initrd after the kernel, if we do move our bottom
1111          * point to after it
1112          */
1113         if (RELOC(prom_initrd_start)) {
1114                 if (RELOC(prom_initrd_end) > RELOC(alloc_bottom))
1115                         RELOC(alloc_bottom) = PAGE_ALIGN(RELOC(prom_initrd_end));
1116         }
1117
1118         /*
1119          * If prom_memory_limit is set we reduce the upper limits *except* for
1120          * alloc_top_high. This must be the real top of RAM so we can put
1121          * TCE's up there.
1122          */
1123
1124         RELOC(alloc_top_high) = RELOC(ram_top);
1125
1126         if (RELOC(prom_memory_limit)) {
1127                 if (RELOC(prom_memory_limit) <= RELOC(alloc_bottom)) {
1128                         prom_printf("Ignoring mem=%x <= alloc_bottom.\n",
1129                                 RELOC(prom_memory_limit));
1130                         RELOC(prom_memory_limit) = 0;
1131                 } else if (RELOC(prom_memory_limit) >= RELOC(ram_top)) {
1132                         prom_printf("Ignoring mem=%x >= ram_top.\n",
1133                                 RELOC(prom_memory_limit));
1134                         RELOC(prom_memory_limit) = 0;
1135                 } else {
1136                         RELOC(ram_top) = RELOC(prom_memory_limit);
1137                         RELOC(rmo_top) = min(RELOC(rmo_top), RELOC(prom_memory_limit));
1138                 }
1139         }
1140
1141         /*
1142          * Setup our top alloc point, that is top of RMO or top of
1143          * segment 0 when running non-LPAR.
1144          * Some RS64 machines have buggy firmware where claims up at
1145          * 1GB fail.  Cap at 768MB as a workaround.
1146          * Since 768MB is plenty of room, and we need to cap to something
1147          * reasonable on 32-bit, cap at 768MB on all machines.
1148          */
1149         if (!RELOC(rmo_top))
1150                 RELOC(rmo_top) = RELOC(ram_top);
1151         RELOC(rmo_top) = min(0x30000000ul, RELOC(rmo_top));
1152         RELOC(alloc_top) = RELOC(rmo_top);
1153
1154         prom_printf("memory layout at init:\n");
1155         prom_printf("  memory_limit : %x (16 MB aligned)\n", RELOC(prom_memory_limit));
1156         prom_printf("  alloc_bottom : %x\n", RELOC(alloc_bottom));
1157         prom_printf("  alloc_top    : %x\n", RELOC(alloc_top));
1158         prom_printf("  alloc_top_hi : %x\n", RELOC(alloc_top_high));
1159         prom_printf("  rmo_top      : %x\n", RELOC(rmo_top));
1160         prom_printf("  ram_top      : %x\n", RELOC(ram_top));
1161 #ifdef CONFIG_KEXEC
1162         if (RELOC(prom_crashk_base)) {
1163                 prom_printf("  crashk_base  : %x\n",  RELOC(prom_crashk_base));
1164                 prom_printf("  crashk_size  : %x\n", RELOC(prom_crashk_size));
1165         }
1166 #endif
1167 }
1168
1169
1170 /*
1171  * Allocate room for and instantiate RTAS
1172  */
1173 static void __init prom_instantiate_rtas(void)
1174 {
1175         phandle rtas_node;
1176         ihandle rtas_inst;
1177         u32 base, entry = 0;
1178         u32 size = 0;
1179
1180         prom_debug("prom_instantiate_rtas: start...\n");
1181
1182         rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1183         prom_debug("rtas_node: %x\n", rtas_node);
1184         if (!PHANDLE_VALID(rtas_node))
1185                 return;
1186
1187         prom_getprop(rtas_node, "rtas-size", &size, sizeof(size));
1188         if (size == 0)
1189                 return;
1190
1191         base = alloc_down(size, PAGE_SIZE, 0);
1192         if (base == 0) {
1193                 prom_printf("RTAS allocation failed !\n");
1194                 return;
1195         }
1196
1197         rtas_inst = call_prom("open", 1, 1, ADDR("/rtas"));
1198         if (!IHANDLE_VALID(rtas_inst)) {
1199                 prom_printf("opening rtas package failed (%x)\n", rtas_inst);
1200                 return;
1201         }
1202
1203         prom_printf("instantiating rtas at 0x%x ...", base);
1204
1205         if (call_prom_ret("call-method", 3, 2, &entry,
1206                           ADDR("instantiate-rtas"),
1207                           rtas_inst, base) != 0
1208             || entry == 0) {
1209                 prom_printf(" failed\n");
1210                 return;
1211         }
1212         prom_printf(" done\n");
1213
1214         reserve_mem(base, size);
1215
1216         prom_setprop(rtas_node, "/rtas", "linux,rtas-base",
1217                      &base, sizeof(base));
1218         prom_setprop(rtas_node, "/rtas", "linux,rtas-entry",
1219                      &entry, sizeof(entry));
1220
1221         prom_debug("rtas base     = 0x%x\n", base);
1222         prom_debug("rtas entry    = 0x%x\n", entry);
1223         prom_debug("rtas size     = 0x%x\n", (long)size);
1224
1225         prom_debug("prom_instantiate_rtas: end...\n");
1226 }
1227
1228 #ifdef CONFIG_PPC64
1229 /*
1230  * Allocate room for and initialize TCE tables
1231  */
1232 static void __init prom_initialize_tce_table(void)
1233 {
1234         phandle node;
1235         ihandle phb_node;
1236         char compatible[64], type[64], model[64];
1237         char *path = RELOC(prom_scratch);
1238         u64 base, align;
1239         u32 minalign, minsize;
1240         u64 tce_entry, *tce_entryp;
1241         u64 local_alloc_top, local_alloc_bottom;
1242         u64 i;
1243
1244         if (RELOC(ppc64_iommu_off))
1245                 return;
1246
1247         prom_debug("starting prom_initialize_tce_table\n");
1248
1249         /* Cache current top of allocs so we reserve a single block */
1250         local_alloc_top = RELOC(alloc_top_high);
1251         local_alloc_bottom = local_alloc_top;
1252
1253         /* Search all nodes looking for PHBs. */
1254         for (node = 0; prom_next_node(&node); ) {
1255                 compatible[0] = 0;
1256                 type[0] = 0;
1257                 model[0] = 0;
1258                 prom_getprop(node, "compatible",
1259                              compatible, sizeof(compatible));
1260                 prom_getprop(node, "device_type", type, sizeof(type));
1261                 prom_getprop(node, "model", model, sizeof(model));
1262
1263                 if ((type[0] == 0) || (strstr(type, RELOC("pci")) == NULL))
1264                         continue;
1265
1266                 /* Keep the old logic in tack to avoid regression. */
1267                 if (compatible[0] != 0) {
1268                         if ((strstr(compatible, RELOC("python")) == NULL) &&
1269                             (strstr(compatible, RELOC("Speedwagon")) == NULL) &&
1270                             (strstr(compatible, RELOC("Winnipeg")) == NULL))
1271                                 continue;
1272                 } else if (model[0] != 0) {
1273                         if ((strstr(model, RELOC("ython")) == NULL) &&
1274                             (strstr(model, RELOC("peedwagon")) == NULL) &&
1275                             (strstr(model, RELOC("innipeg")) == NULL))
1276                                 continue;
1277                 }
1278
1279                 if (prom_getprop(node, "tce-table-minalign", &minalign,
1280                                  sizeof(minalign)) == PROM_ERROR)
1281                         minalign = 0;
1282                 if (prom_getprop(node, "tce-table-minsize", &minsize,
1283                                  sizeof(minsize)) == PROM_ERROR)
1284                         minsize = 4UL << 20;
1285
1286                 /*
1287                  * Even though we read what OF wants, we just set the table
1288                  * size to 4 MB.  This is enough to map 2GB of PCI DMA space.
1289                  * By doing this, we avoid the pitfalls of trying to DMA to
1290                  * MMIO space and the DMA alias hole.
1291                  *
1292                  * On POWER4, firmware sets the TCE region by assuming
1293                  * each TCE table is 8MB. Using this memory for anything
1294                  * else will impact performance, so we always allocate 8MB.
1295                  * Anton
1296                  */
1297                 if (__is_processor(PV_POWER4) || __is_processor(PV_POWER4p))
1298                         minsize = 8UL << 20;
1299                 else
1300                         minsize = 4UL << 20;
1301
1302                 /* Align to the greater of the align or size */
1303                 align = max(minalign, minsize);
1304                 base = alloc_down(minsize, align, 1);
1305                 if (base == 0)
1306                         prom_panic("ERROR, cannot find space for TCE table.\n");
1307                 if (base < local_alloc_bottom)
1308                         local_alloc_bottom = base;
1309
1310                 /* It seems OF doesn't null-terminate the path :-( */
1311                 memset(path, 0, sizeof(path));
1312                 /* Call OF to setup the TCE hardware */
1313                 if (call_prom("package-to-path", 3, 1, node,
1314                               path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) {
1315                         prom_printf("package-to-path failed\n");
1316                 }
1317
1318                 /* Save away the TCE table attributes for later use. */
1319                 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base));
1320                 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize));
1321
1322                 prom_debug("TCE table: %s\n", path);
1323                 prom_debug("\tnode = 0x%x\n", node);
1324                 prom_debug("\tbase = 0x%x\n", base);
1325                 prom_debug("\tsize = 0x%x\n", minsize);
1326
1327                 /* Initialize the table to have a one-to-one mapping
1328                  * over the allocated size.
1329                  */
1330                 tce_entryp = (unsigned long *)base;
1331                 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) {
1332                         tce_entry = (i << PAGE_SHIFT);
1333                         tce_entry |= 0x3;
1334                         *tce_entryp = tce_entry;
1335                 }
1336
1337                 prom_printf("opening PHB %s", path);
1338                 phb_node = call_prom("open", 1, 1, path);
1339                 if (phb_node == 0)
1340                         prom_printf("... failed\n");
1341                 else
1342                         prom_printf("... done\n");
1343
1344                 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"),
1345                           phb_node, -1, minsize,
1346                           (u32) base, (u32) (base >> 32));
1347                 call_prom("close", 1, 0, phb_node);
1348         }
1349
1350         reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom);
1351
1352         if (RELOC(prom_memory_limit)) {
1353                 /*
1354                  * We align the start to a 16MB boundary so we can map
1355                  * the TCE area using large pages if possible.
1356                  * The end should be the top of RAM so no need to align it.
1357                  */
1358                 RELOC(prom_tce_alloc_start) = _ALIGN_DOWN(local_alloc_bottom,
1359                                                           0x1000000);
1360                 RELOC(prom_tce_alloc_end) = local_alloc_top;
1361         }
1362
1363         /* Flag the first invalid entry */
1364         prom_debug("ending prom_initialize_tce_table\n");
1365 }
1366 #endif
1367
1368 /*
1369  * With CHRP SMP we need to use the OF to start the other processors.
1370  * We can't wait until smp_boot_cpus (the OF is trashed by then)
1371  * so we have to put the processors into a holding pattern controlled
1372  * by the kernel (not OF) before we destroy the OF.
1373  *
1374  * This uses a chunk of low memory, puts some holding pattern
1375  * code there and sends the other processors off to there until
1376  * smp_boot_cpus tells them to do something.  The holding pattern
1377  * checks that address until its cpu # is there, when it is that
1378  * cpu jumps to __secondary_start().  smp_boot_cpus() takes care
1379  * of setting those values.
1380  *
1381  * We also use physical address 0x4 here to tell when a cpu
1382  * is in its holding pattern code.
1383  *
1384  * -- Cort
1385  */
1386 extern void __secondary_hold(void);
1387 extern unsigned long __secondary_hold_spinloop;
1388 extern unsigned long __secondary_hold_acknowledge;
1389
1390 /*
1391  * We want to reference the copy of __secondary_hold_* in the
1392  * 0 - 0x100 address range
1393  */
1394 #define LOW_ADDR(x)     (((unsigned long) &(x)) & 0xff)
1395
1396 static void __init prom_hold_cpus(void)
1397 {
1398         unsigned long i;
1399         unsigned int reg;
1400         phandle node;
1401         char type[64];
1402         int cpuid = 0;
1403         unsigned int interrupt_server[MAX_CPU_THREADS];
1404         unsigned int cpu_threads, hw_cpu_num;
1405         int propsize;
1406         struct prom_t *_prom = &RELOC(prom);
1407         unsigned long *spinloop
1408                 = (void *) LOW_ADDR(__secondary_hold_spinloop);
1409         unsigned long *acknowledge
1410                 = (void *) LOW_ADDR(__secondary_hold_acknowledge);
1411 #ifdef CONFIG_PPC64
1412         /* __secondary_hold is actually a descriptor, not the text address */
1413         unsigned long secondary_hold
1414                 = __pa(*PTRRELOC((unsigned long *)__secondary_hold));
1415 #else
1416         unsigned long secondary_hold = LOW_ADDR(__secondary_hold);
1417 #endif
1418
1419         prom_debug("prom_hold_cpus: start...\n");
1420         prom_debug("    1) spinloop       = 0x%x\n", (unsigned long)spinloop);
1421         prom_debug("    1) *spinloop      = 0x%x\n", *spinloop);
1422         prom_debug("    1) acknowledge    = 0x%x\n",
1423                    (unsigned long)acknowledge);
1424         prom_debug("    1) *acknowledge   = 0x%x\n", *acknowledge);
1425         prom_debug("    1) secondary_hold = 0x%x\n", secondary_hold);
1426
1427         /* Set the common spinloop variable, so all of the secondary cpus
1428          * will block when they are awakened from their OF spinloop.
1429          * This must occur for both SMP and non SMP kernels, since OF will
1430          * be trashed when we move the kernel.
1431          */
1432         *spinloop = 0;
1433
1434         /* look for cpus */
1435         for (node = 0; prom_next_node(&node); ) {
1436                 type[0] = 0;
1437                 prom_getprop(node, "device_type", type, sizeof(type));
1438                 if (strcmp(type, RELOC("cpu")) != 0)
1439                         continue;
1440
1441                 /* Skip non-configured cpus. */
1442                 if (prom_getprop(node, "status", type, sizeof(type)) > 0)
1443                         if (strcmp(type, RELOC("okay")) != 0)
1444                                 continue;
1445
1446                 reg = -1;
1447                 prom_getprop(node, "reg", &reg, sizeof(reg));
1448
1449                 prom_debug("\ncpuid        = 0x%x\n", cpuid);
1450                 prom_debug("cpu hw idx   = 0x%x\n", reg);
1451
1452                 /* Init the acknowledge var which will be reset by
1453                  * the secondary cpu when it awakens from its OF
1454                  * spinloop.
1455                  */
1456                 *acknowledge = (unsigned long)-1;
1457
1458                 propsize = prom_getprop(node, "ibm,ppc-interrupt-server#s",
1459                                         &interrupt_server,
1460                                         sizeof(interrupt_server));
1461                 if (propsize < 0) {
1462                         /* no property.  old hardware has no SMT */
1463                         cpu_threads = 1;
1464                         interrupt_server[0] = reg; /* fake it with phys id */
1465                 } else {
1466                         /* We have a threaded processor */
1467                         cpu_threads = propsize / sizeof(u32);
1468                         if (cpu_threads > MAX_CPU_THREADS) {
1469                                 prom_printf("SMT: too many threads!\n"
1470                                             "SMT: found %x, max is %x\n",
1471                                             cpu_threads, MAX_CPU_THREADS);
1472                                 cpu_threads = 1; /* ToDo: panic? */
1473                         }
1474                 }
1475
1476                 hw_cpu_num = interrupt_server[0];
1477                 if (hw_cpu_num != _prom->cpu) {
1478                         /* Primary Thread of non-boot cpu */
1479                         prom_printf("%x : starting cpu hw idx %x... ", cpuid, reg);
1480                         call_prom("start-cpu", 3, 0, node,
1481                                   secondary_hold, reg);
1482
1483                         for (i = 0; (i < 100000000) &&
1484                              (*acknowledge == ((unsigned long)-1)); i++ )
1485                                 mb();
1486
1487                         if (*acknowledge == reg)
1488                                 prom_printf("done\n");
1489                         else
1490                                 prom_printf("failed: %x\n", *acknowledge);
1491                 }
1492 #ifdef CONFIG_SMP
1493                 else
1494                         prom_printf("%x : boot cpu     %x\n", cpuid, reg);
1495 #endif /* CONFIG_SMP */
1496
1497                 /* Reserve cpu #s for secondary threads.   They start later. */
1498                 cpuid += cpu_threads;
1499         }
1500
1501         if (cpuid > NR_CPUS)
1502                 prom_printf("WARNING: maximum CPUs (" __stringify(NR_CPUS)
1503                             ") exceeded: ignoring extras\n");
1504
1505         prom_debug("prom_hold_cpus: end...\n");
1506 }
1507
1508
1509 static void __init prom_init_client_services(unsigned long pp)
1510 {
1511         struct prom_t *_prom = &RELOC(prom);
1512
1513         /* Get a handle to the prom entry point before anything else */
1514         RELOC(prom_entry) = pp;
1515
1516         /* get a handle for the stdout device */
1517         _prom->chosen = call_prom("finddevice", 1, 1, ADDR("/chosen"));
1518         if (!PHANDLE_VALID(_prom->chosen))
1519                 prom_panic("cannot find chosen"); /* msg won't be printed :( */
1520
1521         /* get device tree root */
1522         _prom->root = call_prom("finddevice", 1, 1, ADDR("/"));
1523         if (!PHANDLE_VALID(_prom->root))
1524                 prom_panic("cannot find device tree root"); /* msg won't be printed :( */
1525
1526         _prom->mmumap = 0;
1527 }
1528
1529 #ifdef CONFIG_PPC32
1530 /*
1531  * For really old powermacs, we need to map things we claim.
1532  * For that, we need the ihandle of the mmu.
1533  * Also, on the longtrail, we need to work around other bugs.
1534  */
1535 static void __init prom_find_mmu(void)
1536 {
1537         struct prom_t *_prom = &RELOC(prom);
1538         phandle oprom;
1539         char version[64];
1540
1541         oprom = call_prom("finddevice", 1, 1, ADDR("/openprom"));
1542         if (!PHANDLE_VALID(oprom))
1543                 return;
1544         if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0)
1545                 return;
1546         version[sizeof(version) - 1] = 0;
1547         /* XXX might need to add other versions here */
1548         if (strcmp(version, "Open Firmware, 1.0.5") == 0)
1549                 of_workarounds = OF_WA_CLAIM;
1550         else if (strncmp(version, "FirmWorks,3.", 12) == 0) {
1551                 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL;
1552                 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim");
1553         } else
1554                 return;
1555         _prom->memory = call_prom("open", 1, 1, ADDR("/memory"));
1556         prom_getprop(_prom->chosen, "mmu", &_prom->mmumap,
1557                      sizeof(_prom->mmumap));
1558         if (!IHANDLE_VALID(_prom->memory) || !IHANDLE_VALID(_prom->mmumap))
1559                 of_workarounds &= ~OF_WA_CLAIM;         /* hmmm */
1560 }
1561 #else
1562 #define prom_find_mmu()
1563 #endif
1564
1565 static void __init prom_init_stdout(void)
1566 {
1567         struct prom_t *_prom = &RELOC(prom);
1568         char *path = RELOC(of_stdout_device);
1569         char type[16];
1570         u32 val;
1571
1572         if (prom_getprop(_prom->chosen, "stdout", &val, sizeof(val)) <= 0)
1573                 prom_panic("cannot find stdout");
1574
1575         _prom->stdout = val;
1576
1577         /* Get the full OF pathname of the stdout device */
1578         memset(path, 0, 256);
1579         call_prom("instance-to-path", 3, 1, _prom->stdout, path, 255);
1580         val = call_prom("instance-to-package", 1, 1, _prom->stdout);
1581         prom_setprop(_prom->chosen, "/chosen", "linux,stdout-package",
1582                      &val, sizeof(val));
1583         prom_printf("OF stdout device is: %s\n", RELOC(of_stdout_device));
1584         prom_setprop(_prom->chosen, "/chosen", "linux,stdout-path",
1585                      path, strlen(path) + 1);
1586
1587         /* If it's a display, note it */
1588         memset(type, 0, sizeof(type));
1589         prom_getprop(val, "device_type", type, sizeof(type));
1590         if (strcmp(type, RELOC("display")) == 0)
1591                 prom_setprop(val, path, "linux,boot-display", NULL, 0);
1592 }
1593
1594 static void __init prom_close_stdin(void)
1595 {
1596         struct prom_t *_prom = &RELOC(prom);
1597         ihandle val;
1598
1599         if (prom_getprop(_prom->chosen, "stdin", &val, sizeof(val)) > 0)
1600                 call_prom("close", 1, 0, val);
1601 }
1602
1603 static int __init prom_find_machine_type(void)
1604 {
1605         struct prom_t *_prom = &RELOC(prom);
1606         char compat[256];
1607         int len, i = 0;
1608 #ifdef CONFIG_PPC64
1609         phandle rtas;
1610         int x;
1611 #endif
1612
1613         /* Look for a PowerMac */
1614         len = prom_getprop(_prom->root, "compatible",
1615                            compat, sizeof(compat)-1);
1616         if (len > 0) {
1617                 compat[len] = 0;
1618                 while (i < len) {
1619                         char *p = &compat[i];
1620                         int sl = strlen(p);
1621                         if (sl == 0)
1622                                 break;
1623                         if (strstr(p, RELOC("Power Macintosh")) ||
1624                             strstr(p, RELOC("MacRISC")))
1625                                 return PLATFORM_POWERMAC;
1626 #ifdef CONFIG_PPC64
1627                         /* We must make sure we don't detect the IBM Cell
1628                          * blades as pSeries due to some firmware issues,
1629                          * so we do it here.
1630                          */
1631                         if (strstr(p, RELOC("IBM,CBEA")) ||
1632                             strstr(p, RELOC("IBM,CPBW-1.0")))
1633                                 return PLATFORM_GENERIC;
1634 #endif /* CONFIG_PPC64 */
1635                         i += sl + 1;
1636                 }
1637         }
1638 #ifdef CONFIG_PPC64
1639         /* If not a mac, try to figure out if it's an IBM pSeries or any other
1640          * PAPR compliant platform. We assume it is if :
1641          *  - /device_type is "chrp" (please, do NOT use that for future
1642          *    non-IBM designs !
1643          *  - it has /rtas
1644          */
1645         len = prom_getprop(_prom->root, "device_type",
1646                            compat, sizeof(compat)-1);
1647         if (len <= 0)
1648                 return PLATFORM_GENERIC;
1649         if (strcmp(compat, RELOC("chrp")))
1650                 return PLATFORM_GENERIC;
1651
1652         /* Default to pSeries. We need to know if we are running LPAR */
1653         rtas = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1654         if (!PHANDLE_VALID(rtas))
1655                 return PLATFORM_GENERIC;
1656         x = prom_getproplen(rtas, "ibm,hypertas-functions");
1657         if (x != PROM_ERROR) {
1658                 prom_printf("Hypertas detected, assuming LPAR !\n");
1659                 return PLATFORM_PSERIES_LPAR;
1660         }
1661         return PLATFORM_PSERIES;
1662 #else
1663         return PLATFORM_GENERIC;
1664 #endif
1665 }
1666
1667 static int __init prom_set_color(ihandle ih, int i, int r, int g, int b)
1668 {
1669         return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r);
1670 }
1671
1672 /*
1673  * If we have a display that we don't know how to drive,
1674  * we will want to try to execute OF's open method for it
1675  * later.  However, OF will probably fall over if we do that
1676  * we've taken over the MMU.
1677  * So we check whether we will need to open the display,
1678  * and if so, open it now.
1679  */
1680 static void __init prom_check_displays(void)
1681 {
1682         char type[16], *path;
1683         phandle node;
1684         ihandle ih;
1685         int i;
1686
1687         static unsigned char default_colors[] = {
1688                 0x00, 0x00, 0x00,
1689                 0x00, 0x00, 0xaa,
1690                 0x00, 0xaa, 0x00,
1691                 0x00, 0xaa, 0xaa,
1692                 0xaa, 0x00, 0x00,
1693                 0xaa, 0x00, 0xaa,
1694                 0xaa, 0xaa, 0x00,
1695                 0xaa, 0xaa, 0xaa,
1696                 0x55, 0x55, 0x55,
1697                 0x55, 0x55, 0xff,
1698                 0x55, 0xff, 0x55,
1699                 0x55, 0xff, 0xff,
1700                 0xff, 0x55, 0x55,
1701                 0xff, 0x55, 0xff,
1702                 0xff, 0xff, 0x55,
1703                 0xff, 0xff, 0xff
1704         };
1705         const unsigned char *clut;
1706
1707         prom_printf("Looking for displays\n");
1708         for (node = 0; prom_next_node(&node); ) {
1709                 memset(type, 0, sizeof(type));
1710                 prom_getprop(node, "device_type", type, sizeof(type));
1711                 if (strcmp(type, RELOC("display")) != 0)
1712                         continue;
1713
1714                 /* It seems OF doesn't null-terminate the path :-( */
1715                 path = RELOC(prom_scratch);
1716                 memset(path, 0, PROM_SCRATCH_SIZE);
1717
1718                 /*
1719                  * leave some room at the end of the path for appending extra
1720                  * arguments
1721                  */
1722                 if (call_prom("package-to-path", 3, 1, node, path,
1723                               PROM_SCRATCH_SIZE-10) == PROM_ERROR)
1724                         continue;
1725                 prom_printf("found display   : %s, opening ... ", path);
1726
1727                 ih = call_prom("open", 1, 1, path);
1728                 if (ih == 0) {
1729                         prom_printf("failed\n");
1730                         continue;
1731                 }
1732
1733                 /* Success */
1734                 prom_printf("done\n");
1735                 prom_setprop(node, path, "linux,opened", NULL, 0);
1736
1737                 /* Setup a usable color table when the appropriate
1738                  * method is available. Should update this to set-colors */
1739                 clut = RELOC(default_colors);
1740                 for (i = 0; i < 32; i++, clut += 3)
1741                         if (prom_set_color(ih, i, clut[0], clut[1],
1742                                            clut[2]) != 0)
1743                                 break;
1744
1745 #ifdef CONFIG_LOGO_LINUX_CLUT224
1746                 clut = PTRRELOC(RELOC(logo_linux_clut224.clut));
1747                 for (i = 0; i < RELOC(logo_linux_clut224.clutsize); i++, clut += 3)
1748                         if (prom_set_color(ih, i + 32, clut[0], clut[1],
1749                                            clut[2]) != 0)
1750                                 break;
1751 #endif /* CONFIG_LOGO_LINUX_CLUT224 */
1752         }
1753 }
1754
1755
1756 /* Return (relocated) pointer to this much memory: moves initrd if reqd. */
1757 static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end,
1758                               unsigned long needed, unsigned long align)
1759 {
1760         void *ret;
1761
1762         *mem_start = _ALIGN(*mem_start, align);
1763         while ((*mem_start + needed) > *mem_end) {
1764                 unsigned long room, chunk;
1765
1766                 prom_debug("Chunk exhausted, claiming more at %x...\n",
1767                            RELOC(alloc_bottom));
1768                 room = RELOC(alloc_top) - RELOC(alloc_bottom);
1769                 if (room > DEVTREE_CHUNK_SIZE)
1770                         room = DEVTREE_CHUNK_SIZE;
1771                 if (room < PAGE_SIZE)
1772                         prom_panic("No memory for flatten_device_tree (no room)");
1773                 chunk = alloc_up(room, 0);
1774                 if (chunk == 0)
1775                         prom_panic("No memory for flatten_device_tree (claim failed)");
1776                 *mem_end = RELOC(alloc_top);
1777         }
1778
1779         ret = (void *)*mem_start;
1780         *mem_start += needed;
1781
1782         return ret;
1783 }
1784
1785 #define dt_push_token(token, mem_start, mem_end) \
1786         do { *((u32 *)make_room(mem_start, mem_end, 4, 4)) = token; } while(0)
1787
1788 static unsigned long __init dt_find_string(char *str)
1789 {
1790         char *s, *os;
1791
1792         s = os = (char *)RELOC(dt_string_start);
1793         s += 4;
1794         while (s <  (char *)RELOC(dt_string_end)) {
1795                 if (strcmp(s, str) == 0)
1796                         return s - os;
1797                 s += strlen(s) + 1;
1798         }
1799         return 0;
1800 }
1801
1802 /*
1803  * The Open Firmware 1275 specification states properties must be 31 bytes or
1804  * less, however not all firmwares obey this. Make it 64 bytes to be safe.
1805  */
1806 #define MAX_PROPERTY_NAME 64
1807
1808 static void __init scan_dt_build_strings(phandle node,
1809                                          unsigned long *mem_start,
1810                                          unsigned long *mem_end)
1811 {
1812         char *prev_name, *namep, *sstart;
1813         unsigned long soff;
1814         phandle child;
1815
1816         sstart =  (char *)RELOC(dt_string_start);
1817
1818         /* get and store all property names */
1819         prev_name = RELOC("");
1820         for (;;) {
1821                 /* 64 is max len of name including nul. */
1822                 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1);
1823                 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) {
1824                         /* No more nodes: unwind alloc */
1825                         *mem_start = (unsigned long)namep;
1826                         break;
1827                 }
1828
1829                 /* skip "name" */
1830                 if (strcmp(namep, RELOC("name")) == 0) {
1831                         *mem_start = (unsigned long)namep;
1832                         prev_name = RELOC("name");
1833                         continue;
1834                 }
1835                 /* get/create string entry */
1836                 soff = dt_find_string(namep);
1837                 if (soff != 0) {
1838                         *mem_start = (unsigned long)namep;
1839                         namep = sstart + soff;
1840                 } else {
1841                         /* Trim off some if we can */
1842                         *mem_start = (unsigned long)namep + strlen(namep) + 1;
1843                         RELOC(dt_string_end) = *mem_start;
1844                 }
1845                 prev_name = namep;
1846         }
1847
1848         /* do all our children */
1849         child = call_prom("child", 1, 1, node);
1850         while (child != 0) {
1851                 scan_dt_build_strings(child, mem_start, mem_end);
1852                 child = call_prom("peer", 1, 1, child);
1853         }
1854 }
1855
1856 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
1857                                         unsigned long *mem_end)
1858 {
1859         phandle child;
1860         char *namep, *prev_name, *sstart, *p, *ep, *lp, *path;
1861         unsigned long soff;
1862         unsigned char *valp;
1863         static char pname[MAX_PROPERTY_NAME];
1864         int l, room;
1865
1866         dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end);
1867
1868         /* get the node's full name */
1869         namep = (char *)*mem_start;
1870         room = *mem_end - *mem_start;
1871         if (room > 255)
1872                 room = 255;
1873         l = call_prom("package-to-path", 3, 1, node, namep, room);
1874         if (l >= 0) {
1875                 /* Didn't fit?  Get more room. */
1876                 if (l >= room) {
1877                         if (l >= *mem_end - *mem_start)
1878                                 namep = make_room(mem_start, mem_end, l+1, 1);
1879                         call_prom("package-to-path", 3, 1, node, namep, l);
1880                 }
1881                 namep[l] = '\0';
1882
1883                 /* Fixup an Apple bug where they have bogus \0 chars in the
1884                  * middle of the path in some properties, and extract
1885                  * the unit name (everything after the last '/').
1886                  */
1887                 for (lp = p = namep, ep = namep + l; p < ep; p++) {
1888                         if (*p == '/')
1889                                 lp = namep;
1890                         else if (*p != 0)
1891                                 *lp++ = *p;
1892                 }
1893                 *lp = 0;
1894                 *mem_start = _ALIGN((unsigned long)lp + 1, 4);
1895         }
1896
1897         /* get it again for debugging */
1898         path = RELOC(prom_scratch);
1899         memset(path, 0, PROM_SCRATCH_SIZE);
1900         call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
1901
1902         /* get and store all properties */
1903         prev_name = RELOC("");
1904         sstart = (char *)RELOC(dt_string_start);
1905         for (;;) {
1906                 if (call_prom("nextprop", 3, 1, node, prev_name,
1907                               RELOC(pname)) != 1)
1908                         break;
1909
1910                 /* skip "name" */
1911                 if (strcmp(RELOC(pname), RELOC("name")) == 0) {
1912                         prev_name = RELOC("name");
1913                         continue;
1914                 }
1915
1916                 /* find string offset */
1917                 soff = dt_find_string(RELOC(pname));
1918                 if (soff == 0) {
1919                         prom_printf("WARNING: Can't find string index for"
1920                                     " <%s>, node %s\n", RELOC(pname), path);
1921                         break;
1922                 }
1923                 prev_name = sstart + soff;
1924
1925                 /* get length */
1926                 l = call_prom("getproplen", 2, 1, node, RELOC(pname));
1927
1928                 /* sanity checks */
1929                 if (l == PROM_ERROR)
1930                         continue;
1931                 if (l > MAX_PROPERTY_LENGTH) {
1932                         prom_printf("WARNING: ignoring large property ");
1933                         /* It seems OF doesn't null-terminate the path :-( */
1934                         prom_printf("[%s] ", path);
1935                         prom_printf("%s length 0x%x\n", RELOC(pname), l);
1936                         continue;
1937                 }
1938
1939                 /* push property head */
1940                 dt_push_token(OF_DT_PROP, mem_start, mem_end);
1941                 dt_push_token(l, mem_start, mem_end);
1942                 dt_push_token(soff, mem_start, mem_end);
1943
1944                 /* push property content */
1945                 valp = make_room(mem_start, mem_end, l, 4);
1946                 call_prom("getprop", 4, 1, node, RELOC(pname), valp, l);
1947                 *mem_start = _ALIGN(*mem_start, 4);
1948         }
1949
1950         /* Add a "linux,phandle" property. */
1951         soff = dt_find_string(RELOC("linux,phandle"));
1952         if (soff == 0)
1953                 prom_printf("WARNING: Can't find string index for"
1954                             " <linux-phandle> node %s\n", path);
1955         else {
1956                 dt_push_token(OF_DT_PROP, mem_start, mem_end);
1957                 dt_push_token(4, mem_start, mem_end);
1958                 dt_push_token(soff, mem_start, mem_end);
1959                 valp = make_room(mem_start, mem_end, 4, 4);
1960                 *(u32 *)valp = node;
1961         }
1962
1963         /* do all our children */
1964         child = call_prom("child", 1, 1, node);
1965         while (child != 0) {
1966                 scan_dt_build_struct(child, mem_start, mem_end);
1967                 child = call_prom("peer", 1, 1, child);
1968         }
1969
1970         dt_push_token(OF_DT_END_NODE, mem_start, mem_end);
1971 }
1972
1973 static void __init flatten_device_tree(void)
1974 {
1975         phandle root;
1976         unsigned long mem_start, mem_end, room;
1977         struct boot_param_header *hdr;
1978         struct prom_t *_prom = &RELOC(prom);
1979         char *namep;
1980         u64 *rsvmap;
1981
1982         /*
1983          * Check how much room we have between alloc top & bottom (+/- a
1984          * few pages), crop to 4Mb, as this is our "chuck" size
1985          */
1986         room = RELOC(alloc_top) - RELOC(alloc_bottom) - 0x4000;
1987         if (room > DEVTREE_CHUNK_SIZE)
1988                 room = DEVTREE_CHUNK_SIZE;
1989         prom_debug("starting device tree allocs at %x\n", RELOC(alloc_bottom));
1990
1991         /* Now try to claim that */
1992         mem_start = (unsigned long)alloc_up(room, PAGE_SIZE);
1993         if (mem_start == 0)
1994                 prom_panic("Can't allocate initial device-tree chunk\n");
1995         mem_end = RELOC(alloc_top);
1996
1997         /* Get root of tree */
1998         root = call_prom("peer", 1, 1, (phandle)0);
1999         if (root == (phandle)0)
2000                 prom_panic ("couldn't get device tree root\n");
2001
2002         /* Build header and make room for mem rsv map */
2003         mem_start = _ALIGN(mem_start, 4);
2004         hdr = make_room(&mem_start, &mem_end,
2005                         sizeof(struct boot_param_header), 4);
2006         RELOC(dt_header_start) = (unsigned long)hdr;
2007         rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8);
2008
2009         /* Start of strings */
2010         mem_start = PAGE_ALIGN(mem_start);
2011         RELOC(dt_string_start) = mem_start;
2012         mem_start += 4; /* hole */
2013
2014         /* Add "linux,phandle" in there, we'll need it */
2015         namep = make_room(&mem_start, &mem_end, 16, 1);
2016         strcpy(namep, RELOC("linux,phandle"));
2017         mem_start = (unsigned long)namep + strlen(namep) + 1;
2018
2019         /* Build string array */
2020         prom_printf("Building dt strings...\n");
2021         scan_dt_build_strings(root, &mem_start, &mem_end);
2022         RELOC(dt_string_end) = mem_start;
2023
2024         /* Build structure */
2025         mem_start = PAGE_ALIGN(mem_start);
2026         RELOC(dt_struct_start) = mem_start;
2027         prom_printf("Building dt structure...\n");
2028         scan_dt_build_struct(root, &mem_start, &mem_end);
2029         dt_push_token(OF_DT_END, &mem_start, &mem_end);
2030         RELOC(dt_struct_end) = PAGE_ALIGN(mem_start);
2031
2032         /* Finish header */
2033         hdr->boot_cpuid_phys = _prom->cpu;
2034         hdr->magic = OF_DT_HEADER;
2035         hdr->totalsize = RELOC(dt_struct_end) - RELOC(dt_header_start);
2036         hdr->off_dt_struct = RELOC(dt_struct_start) - RELOC(dt_header_start);
2037         hdr->off_dt_strings = RELOC(dt_string_start) - RELOC(dt_header_start);
2038         hdr->dt_strings_size = RELOC(dt_string_end) - RELOC(dt_string_start);
2039         hdr->off_mem_rsvmap = ((unsigned long)rsvmap) - RELOC(dt_header_start);
2040         hdr->version = OF_DT_VERSION;
2041         /* Version 16 is not backward compatible */
2042         hdr->last_comp_version = 0x10;
2043
2044         /* Reserve the whole thing and copy the reserve map in, we
2045          * also bump mem_reserve_cnt to cause further reservations to
2046          * fail since it's too late.
2047          */
2048         reserve_mem(RELOC(dt_header_start), hdr->totalsize);
2049         memcpy(rsvmap, RELOC(mem_reserve_map), sizeof(mem_reserve_map));
2050
2051 #ifdef DEBUG_PROM
2052         {
2053                 int i;
2054                 prom_printf("reserved memory map:\n");
2055                 for (i = 0; i < RELOC(mem_reserve_cnt); i++)
2056                         prom_printf("  %x - %x\n",
2057                                     RELOC(mem_reserve_map)[i].base,
2058                                     RELOC(mem_reserve_map)[i].size);
2059         }
2060 #endif
2061         RELOC(mem_reserve_cnt) = MEM_RESERVE_MAP_SIZE;
2062
2063         prom_printf("Device tree strings 0x%x -> 0x%x\n",
2064                     RELOC(dt_string_start), RELOC(dt_string_end));
2065         prom_printf("Device tree struct  0x%x -> 0x%x\n",
2066                     RELOC(dt_struct_start), RELOC(dt_struct_end));
2067
2068 }
2069
2070 #ifdef CONFIG_PPC_MAPLE
2071 /* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property.
2072  * The values are bad, and it doesn't even have the right number of cells. */
2073 static void __init fixup_device_tree_maple(void)
2074 {
2075         phandle isa;
2076         u32 isa_ranges[6];
2077
2078         isa = call_prom("finddevice", 1, 1, ADDR("/ht@0/isa@4"));
2079         if (!PHANDLE_VALID(isa))
2080                 return;
2081
2082         if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges))
2083                 == PROM_ERROR)
2084                 return;
2085
2086         if (isa_ranges[0] != 0x1 ||
2087                 isa_ranges[1] != 0xf4000000 ||
2088                 isa_ranges[2] != 0x00010000)
2089                 return;
2090
2091         prom_printf("fixing up bogus ISA range on Maple...\n");
2092
2093         isa_ranges[0] = 0x1;
2094         isa_ranges[1] = 0x0;
2095         isa_ranges[2] = 0x01002000; /* IO space; PCI device = 4 */
2096         isa_ranges[3] = 0x0;
2097         isa_ranges[4] = 0x0;
2098         isa_ranges[5] = 0x00010000;
2099         prom_setprop(isa, "/ht@0/isa@4", "ranges",
2100                         isa_ranges, sizeof(isa_ranges));
2101 }
2102 #else
2103 #define fixup_device_tree_maple()
2104 #endif
2105
2106 #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC)
2107 static void __init fixup_device_tree_pmac(void)
2108 {
2109         phandle u3, i2c, mpic;
2110         u32 u3_rev;
2111         u32 interrupts[2];
2112         u32 parent;
2113
2114         /* Some G5s have a missing interrupt definition, fix it up here */
2115         u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000"));
2116         if (!PHANDLE_VALID(u3))
2117                 return;
2118         i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000"));
2119         if (!PHANDLE_VALID(i2c))
2120                 return;
2121         mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000"));
2122         if (!PHANDLE_VALID(mpic))
2123                 return;
2124
2125         /* check if proper rev of u3 */
2126         if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev))
2127             == PROM_ERROR)
2128                 return;
2129         if (u3_rev < 0x35 || u3_rev > 0x39)
2130                 return;
2131         /* does it need fixup ? */
2132         if (prom_getproplen(i2c, "interrupts") > 0)
2133                 return;
2134
2135         prom_printf("fixing up bogus interrupts for u3 i2c...\n");
2136
2137         /* interrupt on this revision of u3 is number 0 and level */
2138         interrupts[0] = 0;
2139         interrupts[1] = 1;
2140         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts",
2141                      &interrupts, sizeof(interrupts));
2142         parent = (u32)mpic;
2143         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent",
2144                      &parent, sizeof(parent));
2145 }
2146 #else
2147 #define fixup_device_tree_pmac()
2148 #endif
2149
2150 static void __init fixup_device_tree(void)
2151 {
2152         fixup_device_tree_maple();
2153         fixup_device_tree_pmac();
2154 }
2155
2156 static void __init prom_find_boot_cpu(void)
2157 {
2158         struct prom_t *_prom = &RELOC(prom);
2159         u32 getprop_rval;
2160         ihandle prom_cpu;
2161         phandle cpu_pkg;
2162
2163         _prom->cpu = 0;
2164         if (prom_getprop(_prom->chosen, "cpu", &prom_cpu, sizeof(prom_cpu)) <= 0)
2165                 return;
2166
2167         cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
2168
2169         prom_getprop(cpu_pkg, "reg", &getprop_rval, sizeof(getprop_rval));
2170         _prom->cpu = getprop_rval;
2171
2172         prom_debug("Booting CPU hw index = 0x%x\n", _prom->cpu);
2173 }
2174
2175 static void __init prom_check_initrd(unsigned long r3, unsigned long r4)
2176 {
2177 #ifdef CONFIG_BLK_DEV_INITRD
2178         struct prom_t *_prom = &RELOC(prom);
2179
2180         if (r3 && r4 && r4 != 0xdeadbeef) {
2181                 unsigned long val;
2182
2183                 RELOC(prom_initrd_start) = is_kernel_addr(r3) ? __pa(r3) : r3;
2184                 RELOC(prom_initrd_end) = RELOC(prom_initrd_start) + r4;
2185
2186                 val = RELOC(prom_initrd_start);
2187                 prom_setprop(_prom->chosen, "/chosen", "linux,initrd-start",
2188                              &val, sizeof(val));
2189                 val = RELOC(prom_initrd_end);
2190                 prom_setprop(_prom->chosen, "/chosen", "linux,initrd-end",
2191                              &val, sizeof(val));
2192
2193                 reserve_mem(RELOC(prom_initrd_start),
2194                             RELOC(prom_initrd_end) - RELOC(prom_initrd_start));
2195
2196                 prom_debug("initrd_start=0x%x\n", RELOC(prom_initrd_start));
2197                 prom_debug("initrd_end=0x%x\n", RELOC(prom_initrd_end));
2198         }
2199 #endif /* CONFIG_BLK_DEV_INITRD */
2200 }
2201
2202 /*
2203  * We enter here early on, when the Open Firmware prom is still
2204  * handling exceptions and the MMU hash table for us.
2205  */
2206
2207 unsigned long __init prom_init(unsigned long r3, unsigned long r4,
2208                                unsigned long pp,
2209                                unsigned long r6, unsigned long r7)
2210 {
2211         struct prom_t *_prom;
2212         unsigned long hdr;
2213         unsigned long offset = reloc_offset();
2214
2215 #ifdef CONFIG_PPC32
2216         reloc_got2(offset);
2217 #endif
2218
2219         _prom = &RELOC(prom);
2220
2221         /*
2222          * First zero the BSS
2223          */
2224         memset(&RELOC(__bss_start), 0, __bss_stop - __bss_start);
2225
2226         /*
2227          * Init interface to Open Firmware, get some node references,
2228          * like /chosen
2229          */
2230         prom_init_client_services(pp);
2231
2232         /*
2233          * See if this OF is old enough that we need to do explicit maps
2234          * and other workarounds
2235          */
2236         prom_find_mmu();
2237
2238         /*
2239          * Init prom stdout device
2240          */
2241         prom_init_stdout();
2242
2243         /*
2244          * Get default machine type. At this point, we do not differentiate
2245          * between pSeries SMP and pSeries LPAR
2246          */
2247         RELOC(of_platform) = prom_find_machine_type();
2248
2249         /* Bail if this is a kdump kernel. */
2250         if (PHYSICAL_START > 0)
2251                 prom_panic("Error: You can't boot a kdump kernel from OF!\n");
2252
2253         /*
2254          * Check for an initrd
2255          */
2256         prom_check_initrd(r3, r4);
2257
2258 #ifdef CONFIG_PPC_PSERIES
2259         /*
2260          * On pSeries, inform the firmware about our capabilities
2261          */
2262         if (RELOC(of_platform) == PLATFORM_PSERIES ||
2263             RELOC(of_platform) == PLATFORM_PSERIES_LPAR)
2264                 prom_send_capabilities();
2265 #endif
2266
2267         /*
2268          * Copy the CPU hold code
2269          */
2270         if (RELOC(of_platform) != PLATFORM_POWERMAC)
2271                 copy_and_flush(0, KERNELBASE + offset, 0x100, 0);
2272
2273         /*
2274          * Do early parsing of command line
2275          */
2276         early_cmdline_parse();
2277
2278         /*
2279          * Initialize memory management within prom_init
2280          */
2281         prom_init_mem();
2282
2283 #ifdef CONFIG_KEXEC
2284         if (RELOC(prom_crashk_base))
2285                 reserve_mem(RELOC(prom_crashk_base), RELOC(prom_crashk_size));
2286 #endif
2287         /*
2288          * Determine which cpu is actually running right _now_
2289          */
2290         prom_find_boot_cpu();
2291
2292         /*
2293          * Initialize display devices
2294          */
2295         prom_check_displays();
2296
2297 #ifdef CONFIG_PPC64
2298         /*
2299          * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else
2300          * that uses the allocator, we need to make sure we get the top of memory
2301          * available for us here...
2302          */
2303         if (RELOC(of_platform) == PLATFORM_PSERIES)
2304                 prom_initialize_tce_table();
2305 #endif
2306
2307         /*
2308          * On non-powermacs, try to instantiate RTAS and puts all CPUs
2309          * in spin-loops. PowerMacs don't have a working RTAS and use
2310          * a different way to spin CPUs
2311          */
2312         if (RELOC(of_platform) != PLATFORM_POWERMAC) {
2313                 prom_instantiate_rtas();
2314                 prom_hold_cpus();
2315         }
2316
2317         /*
2318          * Fill in some infos for use by the kernel later on
2319          */
2320         if (RELOC(prom_memory_limit))
2321                 prom_setprop(_prom->chosen, "/chosen", "linux,memory-limit",
2322                              &RELOC(prom_memory_limit),
2323                              sizeof(prom_memory_limit));
2324 #ifdef CONFIG_PPC64
2325         if (RELOC(ppc64_iommu_off))
2326                 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-off",
2327                              NULL, 0);
2328
2329         if (RELOC(iommu_force_on))
2330                 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-force-on",
2331                              NULL, 0);
2332
2333         if (RELOC(prom_tce_alloc_start)) {
2334                 prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-start",
2335                              &RELOC(prom_tce_alloc_start),
2336                              sizeof(prom_tce_alloc_start));
2337                 prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-end",
2338                              &RELOC(prom_tce_alloc_end),
2339                              sizeof(prom_tce_alloc_end));
2340         }
2341 #endif
2342
2343 #ifdef CONFIG_KEXEC
2344         if (RELOC(prom_crashk_base)) {
2345                 prom_setprop(_prom->chosen, "/chosen", "linux,crashkernel-base",
2346                         PTRRELOC(&prom_crashk_base),
2347                         sizeof(RELOC(prom_crashk_base)));
2348                 prom_setprop(_prom->chosen, "/chosen", "linux,crashkernel-size",
2349                         PTRRELOC(&prom_crashk_size),
2350                         sizeof(RELOC(prom_crashk_size)));
2351         }
2352 #endif
2353         /*
2354          * Fixup any known bugs in the device-tree
2355          */
2356         fixup_device_tree();
2357
2358         /*
2359          * Now finally create the flattened device-tree
2360          */
2361         prom_printf("copying OF device tree ...\n");
2362         flatten_device_tree();
2363
2364         /*
2365          * in case stdin is USB and still active on IBM machines...
2366          * Unfortunately quiesce crashes on some powermacs if we have
2367          * closed stdin already (in particular the powerbook 101).
2368          */
2369         if (RELOC(of_platform) != PLATFORM_POWERMAC)
2370                 prom_close_stdin();
2371
2372         /*
2373          * Call OF "quiesce" method to shut down pending DMA's from
2374          * devices etc...
2375          */
2376         prom_printf("Calling quiesce ...\n");
2377         call_prom("quiesce", 0, 0);
2378
2379         /*
2380          * And finally, call the kernel passing it the flattened device
2381          * tree and NULL as r5, thus triggering the new entry point which
2382          * is common to us and kexec
2383          */
2384         hdr = RELOC(dt_header_start);
2385         prom_printf("returning from prom_init\n");
2386         prom_debug("->dt_header_start=0x%x\n", hdr);
2387
2388 #ifdef CONFIG_PPC32
2389         reloc_got2(-offset);
2390 #endif
2391
2392         __start(hdr, KERNELBASE + offset, 0);
2393
2394         return 0;
2395 }