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