arch/powerpc/kernel/prom_init.c

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