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 prom_iommu_force_on;
 177 static int __initdata prom_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(prom_iommu_off) = 1;
 586                 else if (!strncmp(opt, RELOC("force"), 5))
 587                         RELOC(prom_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 #define OV3_DFP                 0x20    /* decimal FP */
 631
 632 /* Option vector 5: PAPR/OF options supported */
 633 #define OV5_LPAR                0x80    /* logical partitioning supported */
 634 #define OV5_SPLPAR              0x40    /* shared-processor LPAR supported */
 635 /* ibm,dynamic-reconfiguration-memory property supported */
 636 #define OV5_DRCONF_MEMORY       0x20
 637 #define OV5_LARGE_PAGES         0x10    /* large pages supported */
 638
 639 /*
 640  * The architecture vector has an array of PVR mask/value pairs,
 641  * followed by # option vectors - 1, followed by the option vectors.
 642  */
 643 static unsigned char ibm_architecture_vec[] = {
 644         W(0xfffe0000), W(0x003a0000),   /* POWER5/POWER5+ */
 645         W(0xffff0000), W(0x003e0000),   /* POWER6 */
 646         W(0xffffffff), W(0x0f000002),   /* all 2.05-compliant */
 647         W(0xfffffffe), W(0x0f000001),   /* all 2.04-compliant and earlier */
 648         5 - 1,                          /* 5 option vectors */
 649
 650         /* option vector 1: processor architectures supported */
 651         3 - 2,                          /* length */
 652         0,                              /* don't ignore, don't halt */
 653         OV1_PPC_2_00 | OV1_PPC_2_01 | OV1_PPC_2_02 | OV1_PPC_2_03 |
 654         OV1_PPC_2_04 | OV1_PPC_2_05,
 655
 656         /* option vector 2: Open Firmware options supported */
 657         34 - 2,                         /* length */
 658         OV2_REAL_MODE,
 659         0, 0,
 660         W(0xffffffff),                  /* real_base */
 661         W(0xffffffff),                  /* real_size */
 662         W(0xffffffff),                  /* virt_base */
 663         W(0xffffffff),                  /* virt_size */
 664         W(0xffffffff),                  /* load_base */
 665         W(64),                          /* 128MB min RMA */
 666         W(0xffffffff),                  /* full client load */
 667         0,                              /* min RMA percentage of total RAM */
 668         48,                             /* max log_2(hash table size) */
 669
 670         /* option vector 3: processor options supported */
 671         3 - 2,                          /* length */
 672         0,                              /* don't ignore, don't halt */
 673         OV3_FP | OV3_VMX | OV3_DFP,
 674
 675         /* option vector 4: IBM PAPR implementation */
 676         2 - 2,                          /* length */
 677         0,                              /* don't halt */
 678
 679         /* option vector 5: PAPR/OF options */
 680         3 - 2,                          /* length */
 681         0,                              /* don't ignore, don't halt */
 682         OV5_LPAR | OV5_SPLPAR | OV5_LARGE_PAGES | OV5_DRCONF_MEMORY,
 683 };
 684
 685 /* Old method - ELF header with PT_NOTE sections */
 686 static struct fake_elf {
 687         Elf32_Ehdr      elfhdr;
 688         Elf32_Phdr      phdr[2];
 689         struct chrpnote {
 690                 u32     namesz;
 691                 u32     descsz;
 692                 u32     type;
 693                 char    name[8];        /* "PowerPC" */
 694                 struct chrpdesc {
 695                         u32     real_mode;
 696                         u32     real_base;
 697                         u32     real_size;
 698                         u32     virt_base;
 699                         u32     virt_size;
 700                         u32     load_base;
 701                 } chrpdesc;
 702         } chrpnote;
 703         struct rpanote {
 704                 u32     namesz;
 705                 u32     descsz;
 706                 u32     type;
 707                 char    name[24];       /* "IBM,RPA-Client-Config" */
 708                 struct rpadesc {
 709                         u32     lpar_affinity;
 710                         u32     min_rmo_size;
 711                         u32     min_rmo_percent;
 712                         u32     max_pft_size;
 713                         u32     splpar;
 714                         u32     min_load;
 715                         u32     new_mem_def;
 716                         u32     ignore_me;
 717                 } rpadesc;
 718         } rpanote;
 719 } fake_elf = {
 720         .elfhdr = {
 721                 .e_ident = { 0x7f, 'E', 'L', 'F',
 722                              ELFCLASS32, ELFDATA2MSB, EV_CURRENT },
 723                 .e_type = ET_EXEC,      /* yeah right */
 724                 .e_machine = EM_PPC,
 725                 .e_version = EV_CURRENT,
 726                 .e_phoff = offsetof(struct fake_elf, phdr),
 727                 .e_phentsize = sizeof(Elf32_Phdr),
 728                 .e_phnum = 2
 729         },
 730         .phdr = {
 731                 [0] = {
 732                         .p_type = PT_NOTE,
 733                         .p_offset = offsetof(struct fake_elf, chrpnote),
 734                         .p_filesz = sizeof(struct chrpnote)
 735                 }, [1] = {
 736                         .p_type = PT_NOTE,
 737                         .p_offset = offsetof(struct fake_elf, rpanote),
 738                         .p_filesz = sizeof(struct rpanote)
 739                 }
 740         },
 741         .chrpnote = {
 742                 .namesz = sizeof("PowerPC"),
 743                 .descsz = sizeof(struct chrpdesc),
 744                 .type = 0x1275,
 745                 .name = "PowerPC",
 746                 .chrpdesc = {
 747                         .real_mode = ~0U,       /* ~0 means "don't care" */
 748                         .real_base = ~0U,
 749                         .real_size = ~0U,
 750                         .virt_base = ~0U,
 751                         .virt_size = ~0U,
 752                         .load_base = ~0U
 753                 },
 754         },
 755         .rpanote = {
 756                 .namesz = sizeof("IBM,RPA-Client-Config"),
 757                 .descsz = sizeof(struct rpadesc),
 758                 .type = 0x12759999,
 759                 .name = "IBM,RPA-Client-Config",
 760                 .rpadesc = {
 761                         .lpar_affinity = 0,
 762                         .min_rmo_size = 64,     /* in megabytes */
 763                         .min_rmo_percent = 0,
 764                         .max_pft_size = 48,     /* 2^48 bytes max PFT size */
 765                         .splpar = 1,
 766                         .min_load = ~0U,
 767                         .new_mem_def = 0
 768                 }
 769         }
 770 };
 771
 772 static void __init prom_send_capabilities(void)
 773 {
 774         ihandle elfloader, root;
 775         prom_arg_t ret;
 776
 777         root = call_prom("open", 1, 1, ADDR("/"));
 778         if (root != 0) {
 779                 /* try calling the ibm,client-architecture-support method */
 780                 if (call_prom_ret("call-method", 3, 2, &ret,
 781                                   ADDR("ibm,client-architecture-support"),
 782                                   root,
 783                                   ADDR(ibm_architecture_vec)) == 0) {
 784                         /* the call exists... */
 785                         if (ret)
 786                                 prom_printf("WARNING: ibm,client-architecture"
 787                                             "-support call FAILED!\n");
 788                         call_prom("close", 1, 0, root);
 789                         return;
 790                 }
 791                 call_prom("close", 1, 0, root);
 792         }
 793
 794         /* no ibm,client-architecture-support call, try the old way */
 795         elfloader = call_prom("open", 1, 1, ADDR("/packages/elf-loader"));
 796         if (elfloader == 0) {
 797                 prom_printf("couldn't open /packages/elf-loader\n");
 798                 return;
 799         }
 800         call_prom("call-method", 3, 1, ADDR("process-elf-header"),
 801                         elfloader, ADDR(&fake_elf));
 802         call_prom("close", 1, 0, elfloader);
 803 }
 804 #endif
 805
 806 /*
 807  * Memory allocation strategy... our layout is normally:
 808  *
 809  *  at 14Mb or more we have vmlinux, then a gap and initrd.  In some
 810  *  rare cases, initrd might end up being before the kernel though.
 811  *  We assume this won't override the final kernel at 0, we have no
 812  *  provision to handle that in this version, but it should hopefully
 813  *  never happen.
 814  *
 815  *  alloc_top is set to the top of RMO, eventually shrink down if the
 816  *  TCEs overlap
 817  *
 818  *  alloc_bottom is set to the top of kernel/initrd
 819  *
 820  *  from there, allocations are done this way : rtas is allocated
 821  *  topmost, and the device-tree is allocated from the bottom. We try
 822  *  to grow the device-tree allocation as we progress. If we can't,
 823  *  then we fail, we don't currently have a facility to restart
 824  *  elsewhere, but that shouldn't be necessary.
 825  *
 826  *  Note that calls to reserve_mem have to be done explicitly, memory
 827  *  allocated with either alloc_up or alloc_down isn't automatically
 828  *  reserved.
 829  */
 830
 831
 832 /*
 833  * Allocates memory in the RMO upward from the kernel/initrd
 834  *
 835  * When align is 0, this is a special case, it means to allocate in place
 836  * at the current location of alloc_bottom or fail (that is basically
 837  * extending the previous allocation). Used for the device-tree flattening
 838  */
 839 static unsigned long __init alloc_up(unsigned long size, unsigned long align)
 840 {
 841         unsigned long base = RELOC(alloc_bottom);
 842         unsigned long addr = 0;
 843
 844         if (align)
 845                 base = _ALIGN_UP(base, align);
 846         prom_debug("alloc_up(%x, %x)\n", size, align);
 847         if (RELOC(ram_top) == 0)
 848                 prom_panic("alloc_up() called with mem not initialized\n");
 849
 850         if (align)
 851                 base = _ALIGN_UP(RELOC(alloc_bottom), align);
 852         else
 853                 base = RELOC(alloc_bottom);
 854
 855         for(; (base + size) <= RELOC(alloc_top);
 856             base = _ALIGN_UP(base + 0x100000, align)) {
 857                 prom_debug("    trying: 0x%x\n\r", base);
 858                 addr = (unsigned long)prom_claim(base, size, 0);
 859                 if (addr != PROM_ERROR && addr != 0)
 860                         break;
 861                 addr = 0;
 862                 if (align == 0)
 863                         break;
 864         }
 865         if (addr == 0)
 866                 return 0;
 867         RELOC(alloc_bottom) = addr;
 868
 869         prom_debug(" -> %x\n", addr);
 870         prom_debug("  alloc_bottom : %x\n", RELOC(alloc_bottom));
 871         prom_debug("  alloc_top    : %x\n", RELOC(alloc_top));
 872         prom_debug("  alloc_top_hi : %x\n", RELOC(alloc_top_high));
 873         prom_debug("  rmo_top      : %x\n", RELOC(rmo_top));
 874         prom_debug("  ram_top      : %x\n", RELOC(ram_top));
 875
 876         return addr;
 877 }
 878
 879 /*
 880  * Allocates memory downward, either from top of RMO, or if highmem
 881  * is set, from the top of RAM.  Note that this one doesn't handle
 882  * failures.  It does claim memory if highmem is not set.
 883  */
 884 static unsigned long __init alloc_down(unsigned long size, unsigned long align,
 885                                        int highmem)
 886 {
 887         unsigned long base, addr = 0;
 888
 889         prom_debug("alloc_down(%x, %x, %s)\n", size, align,
 890                    highmem ? RELOC("(high)") : RELOC("(low)"));
 891         if (RELOC(ram_top) == 0)
 892                 prom_panic("alloc_down() called with mem not initialized\n");
 893
 894         if (highmem) {
 895                 /* Carve out storage for the TCE table. */
 896                 addr = _ALIGN_DOWN(RELOC(alloc_top_high) - size, align);
 897                 if (addr <= RELOC(alloc_bottom))
 898                         return 0;
 899                 /* Will we bump into the RMO ? If yes, check out that we
 900                  * didn't overlap existing allocations there, if we did,
 901                  * we are dead, we must be the first in town !
 902                  */
 903                 if (addr < RELOC(rmo_top)) {
 904                         /* Good, we are first */
 905                         if (RELOC(alloc_top) == RELOC(rmo_top))
 906                                 RELOC(alloc_top) = RELOC(rmo_top) = addr;
 907                         else
 908                                 return 0;
 909                 }
 910                 RELOC(alloc_top_high) = addr;
 911                 goto bail;
 912         }
 913
 914         base = _ALIGN_DOWN(RELOC(alloc_top) - size, align);
 915         for (; base > RELOC(alloc_bottom);
 916              base = _ALIGN_DOWN(base - 0x100000, align))  {
 917                 prom_debug("    trying: 0x%x\n\r", base);
 918                 addr = (unsigned long)prom_claim(base, size, 0);
 919                 if (addr != PROM_ERROR && addr != 0)
 920                         break;
 921                 addr = 0;
 922         }
 923         if (addr == 0)
 924                 return 0;
 925         RELOC(alloc_top) = addr;
 926
 927  bail:
 928         prom_debug(" -> %x\n", addr);
 929         prom_debug("  alloc_bottom : %x\n", RELOC(alloc_bottom));
 930         prom_debug("  alloc_top    : %x\n", RELOC(alloc_top));
 931         prom_debug("  alloc_top_hi : %x\n", RELOC(alloc_top_high));
 932         prom_debug("  rmo_top      : %x\n", RELOC(rmo_top));
 933         prom_debug("  ram_top      : %x\n", RELOC(ram_top));
 934
 935         return addr;
 936 }
 937
 938 /*
 939  * Parse a "reg" cell
 940  */
 941 static unsigned long __init prom_next_cell(int s, cell_t **cellp)
 942 {
 943         cell_t *p = *cellp;
 944         unsigned long r = 0;
 945
 946         /* Ignore more than 2 cells */
 947         while (s > sizeof(unsigned long) / 4) {
 948                 p++;
 949                 s--;
 950         }
 951         r = *p++;
 952 #ifdef CONFIG_PPC64
 953         if (s > 1) {
 954                 r <<= 32;
 955                 r |= *(p++);
 956         }
 957 #endif
 958         *cellp = p;
 959         return r;
 960 }
 961
 962 /*
 963  * Very dumb function for adding to the memory reserve list, but
 964  * we don't need anything smarter at this point
 965  *
 966  * XXX Eventually check for collisions.  They should NEVER happen.
 967  * If problems seem to show up, it would be a good start to track
 968  * them down.
 969  */
 970 static void reserve_mem(u64 base, u64 size)
 971 {
 972         u64 top = base + size;
 973         unsigned long cnt = RELOC(mem_reserve_cnt);
 974
 975         if (size == 0)
 976                 return;
 977
 978         /* We need to always keep one empty entry so that we
 979          * have our terminator with "size" set to 0 since we are
 980          * dumb and just copy this entire array to the boot params
 981          */
 982         base = _ALIGN_DOWN(base, PAGE_SIZE);
 983         top = _ALIGN_UP(top, PAGE_SIZE);
 984         size = top - base;
 985
 986         if (cnt >= (MEM_RESERVE_MAP_SIZE - 1))
 987                 prom_panic("Memory reserve map exhausted !\n");
 988         RELOC(mem_reserve_map)[cnt].base = base;
 989         RELOC(mem_reserve_map)[cnt].size = size;
 990         RELOC(mem_reserve_cnt) = cnt + 1;
 991 }
 992
 993 /*
 994  * Initialize memory allocation mechanism, parse "memory" nodes and
 995  * obtain that way the top of memory and RMO to setup out local allocator
 996  */
 997 static void __init prom_init_mem(void)
 998 {
 999         phandle node;
1000         char *path, type[64];
1001         unsigned int plen;
1002         cell_t *p, *endp;
1003         struct prom_t *_prom = &RELOC(prom);
1004         u32 rac, rsc;
1005
1006         /*
1007          * We iterate the memory nodes to find
1008          * 1) top of RMO (first node)
1009          * 2) top of memory
1010          */
1011         rac = 2;
1012         prom_getprop(_prom->root, "#address-cells", &rac, sizeof(rac));
1013         rsc = 1;
1014         prom_getprop(_prom->root, "#size-cells", &rsc, sizeof(rsc));
1015         prom_debug("root_addr_cells: %x\n", (unsigned long) rac);
1016         prom_debug("root_size_cells: %x\n", (unsigned long) rsc);
1017
1018         prom_debug("scanning memory:\n");
1019         path = RELOC(prom_scratch);
1020
1021         for (node = 0; prom_next_node(&node); ) {
1022                 type[0] = 0;
1023                 prom_getprop(node, "device_type", type, sizeof(type));
1024
1025                 if (type[0] == 0) {
1026                         /*
1027                          * CHRP Longtrail machines have no device_type
1028                          * on the memory node, so check the name instead...
1029                          */
1030                         prom_getprop(node, "name", type, sizeof(type));
1031                 }
1032                 if (strcmp(type, RELOC("memory")))
1033                         continue;
1034
1035                 plen = prom_getprop(node, "reg", RELOC(regbuf), sizeof(regbuf));
1036                 if (plen > sizeof(regbuf)) {
1037                         prom_printf("memory node too large for buffer !\n");
1038                         plen = sizeof(regbuf);
1039                 }
1040                 p = RELOC(regbuf);
1041                 endp = p + (plen / sizeof(cell_t));
1042
1043 #ifdef DEBUG_PROM
1044                 memset(path, 0, PROM_SCRATCH_SIZE);
1045                 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
1046                 prom_debug("  node %s :\n", path);
1047 #endif /* DEBUG_PROM */
1048
1049                 while ((endp - p) >= (rac + rsc)) {
1050                         unsigned long base, size;
1051
1052                         base = prom_next_cell(rac, &p);
1053                         size = prom_next_cell(rsc, &p);
1054
1055                         if (size == 0)
1056                                 continue;
1057                         prom_debug("    %x %x\n", base, size);
1058                         if (base == 0 && (RELOC(of_platform) & PLATFORM_LPAR))
1059                                 RELOC(rmo_top) = size;
1060                         if ((base + size) > RELOC(ram_top))
1061                                 RELOC(ram_top) = base + size;
1062                 }
1063         }
1064
1065         RELOC(alloc_bottom) = PAGE_ALIGN((unsigned long)&RELOC(_end) + 0x4000);
1066
1067         /* Check if we have an initrd after the kernel, if we do move our bottom
1068          * point to after it
1069          */
1070         if (RELOC(prom_initrd_start)) {
1071                 if (RELOC(prom_initrd_end) > RELOC(alloc_bottom))
1072                         RELOC(alloc_bottom) = PAGE_ALIGN(RELOC(prom_initrd_end));
1073         }
1074
1075         /*
1076          * Setup our top alloc point, that is top of RMO or top of
1077          * segment 0 when running non-LPAR.
1078          * Some RS64 machines have buggy firmware where claims up at
1079          * 1GB fail.  Cap at 768MB as a workaround.
1080          * Since 768MB is plenty of room, and we need to cap to something
1081          * reasonable on 32-bit, cap at 768MB on all machines.
1082          */
1083         if (!RELOC(rmo_top))
1084                 RELOC(rmo_top) = RELOC(ram_top);
1085         RELOC(rmo_top) = min(0x30000000ul, RELOC(rmo_top));
1086         RELOC(alloc_top) = RELOC(rmo_top);
1087         RELOC(alloc_top_high) = RELOC(ram_top);
1088
1089         prom_printf("memory layout at init:\n");
1090         prom_printf("  alloc_bottom : %x\n", RELOC(alloc_bottom));
1091         prom_printf("  alloc_top    : %x\n", RELOC(alloc_top));
1092         prom_printf("  alloc_top_hi : %x\n", RELOC(alloc_top_high));
1093         prom_printf("  rmo_top      : %x\n", RELOC(rmo_top));
1094         prom_printf("  ram_top      : %x\n", RELOC(ram_top));
1095 }
1096
1097
1098 /*
1099  * Allocate room for and instantiate RTAS
1100  */
1101 static void __init prom_instantiate_rtas(void)
1102 {
1103         phandle rtas_node;
1104         ihandle rtas_inst;
1105         u32 base, entry = 0;
1106         u32 size = 0;
1107
1108         prom_debug("prom_instantiate_rtas: start...\n");
1109
1110         rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1111         prom_debug("rtas_node: %x\n", rtas_node);
1112         if (!PHANDLE_VALID(rtas_node))
1113                 return;
1114
1115         prom_getprop(rtas_node, "rtas-size", &size, sizeof(size));
1116         if (size == 0)
1117                 return;
1118
1119         base = alloc_down(size, PAGE_SIZE, 0);
1120         if (base == 0) {
1121                 prom_printf("RTAS allocation failed !\n");
1122                 return;
1123         }
1124
1125         rtas_inst = call_prom("open", 1, 1, ADDR("/rtas"));
1126         if (!IHANDLE_VALID(rtas_inst)) {
1127                 prom_printf("opening rtas package failed (%x)\n", rtas_inst);
1128                 return;
1129         }
1130
1131         prom_printf("instantiating rtas at 0x%x ...", base);
1132
1133         if (call_prom_ret("call-method", 3, 2, &entry,
1134                           ADDR("instantiate-rtas"),
1135                           rtas_inst, base) != 0
1136             || entry == 0) {
1137                 prom_printf(" failed\n");
1138                 return;
1139         }
1140         prom_printf(" done\n");
1141
1142         reserve_mem(base, size);
1143
1144         prom_setprop(rtas_node, "/rtas", "linux,rtas-base",
1145                      &base, sizeof(base));
1146         prom_setprop(rtas_node, "/rtas", "linux,rtas-entry",
1147                      &entry, sizeof(entry));
1148
1149         prom_debug("rtas base     = 0x%x\n", base);
1150         prom_debug("rtas entry    = 0x%x\n", entry);
1151         prom_debug("rtas size     = 0x%x\n", (long)size);
1152
1153         prom_debug("prom_instantiate_rtas: end...\n");
1154 }
1155
1156 #ifdef CONFIG_PPC64
1157 /*
1158  * Allocate room for and initialize TCE tables
1159  */
1160 static void __init prom_initialize_tce_table(void)
1161 {
1162         phandle node;
1163         ihandle phb_node;
1164         char compatible[64], type[64], model[64];
1165         char *path = RELOC(prom_scratch);
1166         u64 base, align;
1167         u32 minalign, minsize;
1168         u64 tce_entry, *tce_entryp;
1169         u64 local_alloc_top, local_alloc_bottom;
1170         u64 i;
1171
1172         if (RELOC(prom_iommu_off))
1173                 return;
1174
1175         prom_debug("starting prom_initialize_tce_table\n");
1176
1177         /* Cache current top of allocs so we reserve a single block */
1178         local_alloc_top = RELOC(alloc_top_high);
1179         local_alloc_bottom = local_alloc_top;
1180
1181         /* Search all nodes looking for PHBs. */
1182         for (node = 0; prom_next_node(&node); ) {
1183                 compatible[0] = 0;
1184                 type[0] = 0;
1185                 model[0] = 0;
1186                 prom_getprop(node, "compatible",
1187                              compatible, sizeof(compatible));
1188                 prom_getprop(node, "device_type", type, sizeof(type));
1189                 prom_getprop(node, "model", model, sizeof(model));
1190
1191                 if ((type[0] == 0) || (strstr(type, RELOC("pci")) == NULL))
1192                         continue;
1193
1194                 /* Keep the old logic in tack to avoid regression. */
1195                 if (compatible[0] != 0) {
1196                         if ((strstr(compatible, RELOC("python")) == NULL) &&
1197                             (strstr(compatible, RELOC("Speedwagon")) == NULL) &&
1198                             (strstr(compatible, RELOC("Winnipeg")) == NULL))
1199                                 continue;
1200                 } else if (model[0] != 0) {
1201                         if ((strstr(model, RELOC("ython")) == NULL) &&
1202                             (strstr(model, RELOC("peedwagon")) == NULL) &&
1203                             (strstr(model, RELOC("innipeg")) == NULL))
1204                                 continue;
1205                 }
1206
1207                 if (prom_getprop(node, "tce-table-minalign", &minalign,
1208                                  sizeof(minalign)) == PROM_ERROR)
1209                         minalign = 0;
1210                 if (prom_getprop(node, "tce-table-minsize", &minsize,
1211                                  sizeof(minsize)) == PROM_ERROR)
1212                         minsize = 4UL << 20;
1213
1214                 /*
1215                  * Even though we read what OF wants, we just set the table
1216                  * size to 4 MB.  This is enough to map 2GB of PCI DMA space.
1217                  * By doing this, we avoid the pitfalls of trying to DMA to
1218                  * MMIO space and the DMA alias hole.
1219                  *
1220                  * On POWER4, firmware sets the TCE region by assuming
1221                  * each TCE table is 8MB. Using this memory for anything
1222                  * else will impact performance, so we always allocate 8MB.
1223                  * Anton
1224                  */
1225                 if (__is_processor(PV_POWER4) || __is_processor(PV_POWER4p))
1226                         minsize = 8UL << 20;
1227                 else
1228                         minsize = 4UL << 20;
1229
1230                 /* Align to the greater of the align or size */
1231                 align = max(minalign, minsize);
1232                 base = alloc_down(minsize, align, 1);
1233                 if (base == 0)
1234                         prom_panic("ERROR, cannot find space for TCE table.\n");
1235                 if (base < local_alloc_bottom)
1236                         local_alloc_bottom = base;
1237
1238                 /* It seems OF doesn't null-terminate the path :-( */
1239                 memset(path, 0, sizeof(path));
1240                 /* Call OF to setup the TCE hardware */
1241                 if (call_prom("package-to-path", 3, 1, node,
1242                               path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) {
1243                         prom_printf("package-to-path failed\n");
1244                 }
1245
1246                 /* Save away the TCE table attributes for later use. */
1247                 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base));
1248                 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize));
1249
1250                 prom_debug("TCE table: %s\n", path);
1251                 prom_debug("\tnode = 0x%x\n", node);
1252                 prom_debug("\tbase = 0x%x\n", base);
1253                 prom_debug("\tsize = 0x%x\n", minsize);
1254
1255                 /* Initialize the table to have a one-to-one mapping
1256                  * over the allocated size.
1257                  */
1258                 tce_entryp = (unsigned long *)base;
1259                 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) {
1260                         tce_entry = (i << PAGE_SHIFT);
1261                         tce_entry |= 0x3;
1262                         *tce_entryp = tce_entry;
1263                 }
1264
1265                 prom_printf("opening PHB %s", path);
1266                 phb_node = call_prom("open", 1, 1, path);
1267                 if (phb_node == 0)
1268                         prom_printf("... failed\n");
1269                 else
1270                         prom_printf("... done\n");
1271
1272                 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"),
1273                           phb_node, -1, minsize,
1274                           (u32) base, (u32) (base >> 32));
1275                 call_prom("close", 1, 0, phb_node);
1276         }
1277
1278         reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom);
1279
1280         /* These are only really needed if there is a memory limit in
1281          * effect, but we don't know so export them always. */
1282         RELOC(prom_tce_alloc_start) = local_alloc_bottom;
1283         RELOC(prom_tce_alloc_end) = local_alloc_top;
1284
1285         /* Flag the first invalid entry */
1286         prom_debug("ending prom_initialize_tce_table\n");
1287 }
1288 #endif
1289
1290 /*
1291  * With CHRP SMP we need to use the OF to start the other processors.
1292  * We can't wait until smp_boot_cpus (the OF is trashed by then)
1293  * so we have to put the processors into a holding pattern controlled
1294  * by the kernel (not OF) before we destroy the OF.
1295  *
1296  * This uses a chunk of low memory, puts some holding pattern
1297  * code there and sends the other processors off to there until
1298  * smp_boot_cpus tells them to do something.  The holding pattern
1299  * checks that address until its cpu # is there, when it is that
1300  * cpu jumps to __secondary_start().  smp_boot_cpus() takes care
1301  * of setting those values.
1302  *
1303  * We also use physical address 0x4 here to tell when a cpu
1304  * is in its holding pattern code.
1305  *
1306  * -- Cort
1307  */
1308 extern void __secondary_hold(void);
1309 extern unsigned long __secondary_hold_spinloop;
1310 extern unsigned long __secondary_hold_acknowledge;
1311
1312 /*
1313  * We want to reference the copy of __secondary_hold_* in the
1314  * 0 - 0x100 address range
1315  */
1316 #define LOW_ADDR(x)     (((unsigned long) &(x)) & 0xff)
1317
1318 static void __init prom_hold_cpus(void)
1319 {
1320         unsigned long i;
1321         unsigned int reg;
1322         phandle node;
1323         char type[64];
1324         int cpuid = 0;
1325         unsigned int interrupt_server[MAX_CPU_THREADS];
1326         unsigned int cpu_threads, hw_cpu_num;
1327         int propsize;
1328         struct prom_t *_prom = &RELOC(prom);
1329         unsigned long *spinloop
1330                 = (void *) LOW_ADDR(__secondary_hold_spinloop);
1331         unsigned long *acknowledge
1332                 = (void *) LOW_ADDR(__secondary_hold_acknowledge);
1333 #ifdef CONFIG_PPC64
1334         /* __secondary_hold is actually a descriptor, not the text address */
1335         unsigned long secondary_hold
1336                 = __pa(*PTRRELOC((unsigned long *)__secondary_hold));
1337 #else
1338         unsigned long secondary_hold = LOW_ADDR(__secondary_hold);
1339 #endif
1340
1341         prom_debug("prom_hold_cpus: start...\n");
1342         prom_debug("    1) spinloop       = 0x%x\n", (unsigned long)spinloop);
1343         prom_debug("    1) *spinloop      = 0x%x\n", *spinloop);
1344         prom_debug("    1) acknowledge    = 0x%x\n",
1345                    (unsigned long)acknowledge);
1346         prom_debug("    1) *acknowledge   = 0x%x\n", *acknowledge);
1347         prom_debug("    1) secondary_hold = 0x%x\n", secondary_hold);
1348
1349         /* Set the common spinloop variable, so all of the secondary cpus
1350          * will block when they are awakened from their OF spinloop.
1351          * This must occur for both SMP and non SMP kernels, since OF will
1352          * be trashed when we move the kernel.
1353          */
1354         *spinloop = 0;
1355
1356         /* look for cpus */
1357         for (node = 0; prom_next_node(&node); ) {
1358                 type[0] = 0;
1359                 prom_getprop(node, "device_type", type, sizeof(type));
1360                 if (strcmp(type, RELOC("cpu")) != 0)
1361                         continue;
1362
1363                 /* Skip non-configured cpus. */
1364                 if (prom_getprop(node, "status", type, sizeof(type)) > 0)
1365                         if (strcmp(type, RELOC("okay")) != 0)
1366                                 continue;
1367
1368                 reg = -1;
1369                 prom_getprop(node, "reg", &reg, sizeof(reg));
1370
1371                 prom_debug("\ncpuid        = 0x%x\n", cpuid);
1372                 prom_debug("cpu hw idx   = 0x%x\n", reg);
1373
1374                 /* Init the acknowledge var which will be reset by
1375                  * the secondary cpu when it awakens from its OF
1376                  * spinloop.
1377                  */
1378                 *acknowledge = (unsigned long)-1;
1379
1380                 propsize = prom_getprop(node, "ibm,ppc-interrupt-server#s",
1381                                         &interrupt_server,
1382                                         sizeof(interrupt_server));
1383                 if (propsize < 0) {
1384                         /* no property.  old hardware has no SMT */
1385                         cpu_threads = 1;
1386                         interrupt_server[0] = reg; /* fake it with phys id */
1387                 } else {
1388                         /* We have a threaded processor */
1389                         cpu_threads = propsize / sizeof(u32);
1390                         if (cpu_threads > MAX_CPU_THREADS) {
1391                                 prom_printf("SMT: too many threads!\n"
1392                                             "SMT: found %x, max is %x\n",
1393                                             cpu_threads, MAX_CPU_THREADS);
1394                                 cpu_threads = 1; /* ToDo: panic? */
1395                         }
1396                 }
1397
1398                 hw_cpu_num = interrupt_server[0];
1399                 if (hw_cpu_num != _prom->cpu) {
1400                         /* Primary Thread of non-boot cpu */
1401                         prom_printf("%x : starting cpu hw idx %x... ", cpuid, reg);
1402                         call_prom("start-cpu", 3, 0, node,
1403                                   secondary_hold, reg);
1404
1405                         for (i = 0; (i < 100000000) &&
1406                              (*acknowledge == ((unsigned long)-1)); i++ )
1407                                 mb();
1408
1409                         if (*acknowledge == reg)
1410                                 prom_printf("done\n");
1411                         else
1412                                 prom_printf("failed: %x\n", *acknowledge);
1413                 }
1414 #ifdef CONFIG_SMP
1415                 else
1416                         prom_printf("%x : boot cpu     %x\n", cpuid, reg);
1417 #endif /* CONFIG_SMP */
1418
1419                 /* Reserve cpu #s for secondary threads.   They start later. */
1420                 cpuid += cpu_threads;
1421         }
1422
1423         if (cpuid > NR_CPUS)
1424                 prom_printf("WARNING: maximum CPUs (" __stringify(NR_CPUS)
1425                             ") exceeded: ignoring extras\n");
1426
1427         prom_debug("prom_hold_cpus: end...\n");
1428 }
1429
1430
1431 static void __init prom_init_client_services(unsigned long pp)
1432 {
1433         struct prom_t *_prom = &RELOC(prom);
1434
1435         /* Get a handle to the prom entry point before anything else */
1436         RELOC(prom_entry) = pp;
1437
1438         /* get a handle for the stdout device */
1439         _prom->chosen = call_prom("finddevice", 1, 1, ADDR("/chosen"));
1440         if (!PHANDLE_VALID(_prom->chosen))
1441                 prom_panic("cannot find chosen"); /* msg won't be printed :( */
1442
1443         /* get device tree root */
1444         _prom->root = call_prom("finddevice", 1, 1, ADDR("/"));
1445         if (!PHANDLE_VALID(_prom->root))
1446                 prom_panic("cannot find device tree root"); /* msg won't be printed :( */
1447
1448         _prom->mmumap = 0;
1449 }
1450
1451 #ifdef CONFIG_PPC32
1452 /*
1453  * For really old powermacs, we need to map things we claim.
1454  * For that, we need the ihandle of the mmu.
1455  * Also, on the longtrail, we need to work around other bugs.
1456  */
1457 static void __init prom_find_mmu(void)
1458 {
1459         struct prom_t *_prom = &RELOC(prom);
1460         phandle oprom;
1461         char version[64];
1462
1463         oprom = call_prom("finddevice", 1, 1, ADDR("/openprom"));
1464         if (!PHANDLE_VALID(oprom))
1465                 return;
1466         if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0)
1467                 return;
1468         version[sizeof(version) - 1] = 0;
1469         /* XXX might need to add other versions here */
1470         if (strcmp(version, "Open Firmware, 1.0.5") == 0)
1471                 of_workarounds = OF_WA_CLAIM;
1472         else if (strncmp(version, "FirmWorks,3.", 12) == 0) {
1473                 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL;
1474                 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim");
1475         } else
1476                 return;
1477         _prom->memory = call_prom("open", 1, 1, ADDR("/memory"));
1478         prom_getprop(_prom->chosen, "mmu", &_prom->mmumap,
1479                      sizeof(_prom->mmumap));
1480         if (!IHANDLE_VALID(_prom->memory) || !IHANDLE_VALID(_prom->mmumap))
1481                 of_workarounds &= ~OF_WA_CLAIM;         /* hmmm */
1482 }
1483 #else
1484 #define prom_find_mmu()
1485 #endif
1486
1487 static void __init prom_init_stdout(void)
1488 {
1489         struct prom_t *_prom = &RELOC(prom);
1490         char *path = RELOC(of_stdout_device);
1491         char type[16];
1492         u32 val;
1493
1494         if (prom_getprop(_prom->chosen, "stdout", &val, sizeof(val)) <= 0)
1495                 prom_panic("cannot find stdout");
1496
1497         _prom->stdout = val;
1498
1499         /* Get the full OF pathname of the stdout device */
1500         memset(path, 0, 256);
1501         call_prom("instance-to-path", 3, 1, _prom->stdout, path, 255);
1502         val = call_prom("instance-to-package", 1, 1, _prom->stdout);
1503         prom_setprop(_prom->chosen, "/chosen", "linux,stdout-package",
1504                      &val, sizeof(val));
1505         prom_printf("OF stdout device is: %s\n", RELOC(of_stdout_device));
1506         prom_setprop(_prom->chosen, "/chosen", "linux,stdout-path",
1507                      path, strlen(path) + 1);
1508
1509         /* If it's a display, note it */
1510         memset(type, 0, sizeof(type));
1511         prom_getprop(val, "device_type", type, sizeof(type));
1512         if (strcmp(type, RELOC("display")) == 0)
1513                 prom_setprop(val, path, "linux,boot-display", NULL, 0);
1514 }
1515
1516 static void __init prom_close_stdin(void)
1517 {
1518         struct prom_t *_prom = &RELOC(prom);
1519         ihandle val;
1520
1521         if (prom_getprop(_prom->chosen, "stdin", &val, sizeof(val)) > 0)
1522                 call_prom("close", 1, 0, val);
1523 }
1524
1525 static int __init prom_find_machine_type(void)
1526 {
1527         struct prom_t *_prom = &RELOC(prom);
1528         char compat[256];
1529         int len, i = 0;
1530 #ifdef CONFIG_PPC64
1531         phandle rtas;
1532         int x;
1533 #endif
1534
1535         /* Look for a PowerMac */
1536         len = prom_getprop(_prom->root, "compatible",
1537                            compat, sizeof(compat)-1);
1538         if (len > 0) {
1539                 compat[len] = 0;
1540                 while (i < len) {
1541                         char *p = &compat[i];
1542                         int sl = strlen(p);
1543                         if (sl == 0)
1544                                 break;
1545                         if (strstr(p, RELOC("Power Macintosh")) ||
1546                             strstr(p, RELOC("MacRISC")))
1547                                 return PLATFORM_POWERMAC;
1548 #ifdef CONFIG_PPC64
1549                         /* We must make sure we don't detect the IBM Cell
1550                          * blades as pSeries due to some firmware issues,
1551                          * so we do it here.
1552                          */
1553                         if (strstr(p, RELOC("IBM,CBEA")) ||
1554                             strstr(p, RELOC("IBM,CPBW-1.0")))
1555                                 return PLATFORM_GENERIC;
1556 #endif /* CONFIG_PPC64 */
1557                         i += sl + 1;
1558                 }
1559         }
1560 #ifdef CONFIG_PPC64
1561         /* If not a mac, try to figure out if it's an IBM pSeries or any other
1562          * PAPR compliant platform. We assume it is if :
1563          *  - /device_type is "chrp" (please, do NOT use that for future
1564          *    non-IBM designs !
1565          *  - it has /rtas
1566          */
1567         len = prom_getprop(_prom->root, "device_type",
1568                            compat, sizeof(compat)-1);
1569         if (len <= 0)
1570                 return PLATFORM_GENERIC;
1571         if (strcmp(compat, RELOC("chrp")))
1572                 return PLATFORM_GENERIC;
1573
1574         /* Default to pSeries. We need to know if we are running LPAR */
1575         rtas = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1576         if (!PHANDLE_VALID(rtas))
1577                 return PLATFORM_GENERIC;
1578         x = prom_getproplen(rtas, "ibm,hypertas-functions");
1579         if (x != PROM_ERROR) {
1580                 prom_printf("Hypertas detected, assuming LPAR !\n");
1581                 return PLATFORM_PSERIES_LPAR;
1582         }
1583         return PLATFORM_PSERIES;
1584 #else
1585         return PLATFORM_GENERIC;
1586 #endif
1587 }
1588
1589 static int __init prom_set_color(ihandle ih, int i, int r, int g, int b)
1590 {
1591         return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r);
1592 }
1593
1594 /*
1595  * If we have a display that we don't know how to drive,
1596  * we will want to try to execute OF's open method for it
1597  * later.  However, OF will probably fall over if we do that
1598  * we've taken over the MMU.
1599  * So we check whether we will need to open the display,
1600  * and if so, open it now.
1601  */
1602 static void __init prom_check_displays(void)
1603 {
1604         char type[16], *path;
1605         phandle node;
1606         ihandle ih;
1607         int i;
1608
1609         static unsigned char default_colors[] = {
1610                 0x00, 0x00, 0x00,
1611                 0x00, 0x00, 0xaa,
1612                 0x00, 0xaa, 0x00,
1613                 0x00, 0xaa, 0xaa,
1614                 0xaa, 0x00, 0x00,
1615                 0xaa, 0x00, 0xaa,
1616                 0xaa, 0xaa, 0x00,
1617                 0xaa, 0xaa, 0xaa,
1618                 0x55, 0x55, 0x55,
1619                 0x55, 0x55, 0xff,
1620                 0x55, 0xff, 0x55,
1621                 0x55, 0xff, 0xff,
1622                 0xff, 0x55, 0x55,
1623                 0xff, 0x55, 0xff,
1624                 0xff, 0xff, 0x55,
1625                 0xff, 0xff, 0xff
1626         };
1627         const unsigned char *clut;
1628
1629         prom_printf("Looking for displays\n");
1630         for (node = 0; prom_next_node(&node); ) {
1631                 memset(type, 0, sizeof(type));
1632                 prom_getprop(node, "device_type", type, sizeof(type));
1633                 if (strcmp(type, RELOC("display")) != 0)
1634                         continue;
1635
1636                 /* It seems OF doesn't null-terminate the path :-( */
1637                 path = RELOC(prom_scratch);
1638                 memset(path, 0, PROM_SCRATCH_SIZE);
1639
1640                 /*
1641                  * leave some room at the end of the path for appending extra
1642                  * arguments
1643                  */
1644                 if (call_prom("package-to-path", 3, 1, node, path,
1645                               PROM_SCRATCH_SIZE-10) == PROM_ERROR)
1646                         continue;
1647                 prom_printf("found display   : %s, opening ... ", path);
1648
1649                 ih = call_prom("open", 1, 1, path);
1650                 if (ih == 0) {
1651                         prom_printf("failed\n");
1652                         continue;
1653                 }
1654
1655                 /* Success */
1656                 prom_printf("done\n");
1657                 prom_setprop(node, path, "linux,opened", NULL, 0);
1658
1659                 /* Setup a usable color table when the appropriate
1660                  * method is available. Should update this to set-colors */
1661                 clut = RELOC(default_colors);
1662                 for (i = 0; i < 32; i++, clut += 3)
1663                         if (prom_set_color(ih, i, clut[0], clut[1],
1664                                            clut[2]) != 0)
1665                                 break;
1666
1667 #ifdef CONFIG_LOGO_LINUX_CLUT224
1668                 clut = PTRRELOC(RELOC(logo_linux_clut224.clut));
1669                 for (i = 0; i < RELOC(logo_linux_clut224.clutsize); i++, clut += 3)
1670                         if (prom_set_color(ih, i + 32, clut[0], clut[1],
1671                                            clut[2]) != 0)
1672                                 break;
1673 #endif /* CONFIG_LOGO_LINUX_CLUT224 */
1674         }
1675 }
1676
1677
1678 /* Return (relocated) pointer to this much memory: moves initrd if reqd. */
1679 static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end,
1680                               unsigned long needed, unsigned long align)
1681 {
1682         void *ret;
1683
1684         *mem_start = _ALIGN(*mem_start, align);
1685         while ((*mem_start + needed) > *mem_end) {
1686                 unsigned long room, chunk;
1687
1688                 prom_debug("Chunk exhausted, claiming more at %x...\n",
1689                            RELOC(alloc_bottom));
1690                 room = RELOC(alloc_top) - RELOC(alloc_bottom);
1691                 if (room > DEVTREE_CHUNK_SIZE)
1692                         room = DEVTREE_CHUNK_SIZE;
1693                 if (room < PAGE_SIZE)
1694                         prom_panic("No memory for flatten_device_tree (no room)");
1695                 chunk = alloc_up(room, 0);
1696                 if (chunk == 0)
1697                         prom_panic("No memory for flatten_device_tree (claim failed)");
1698                 *mem_end = RELOC(alloc_top);
1699         }
1700
1701         ret = (void *)*mem_start;
1702         *mem_start += needed;
1703
1704         return ret;
1705 }
1706
1707 #define dt_push_token(token, mem_start, mem_end) \
1708         do { *((u32 *)make_room(mem_start, mem_end, 4, 4)) = token; } while(0)
1709
1710 static unsigned long __init dt_find_string(char *str)
1711 {
1712         char *s, *os;
1713
1714         s = os = (char *)RELOC(dt_string_start);
1715         s += 4;
1716         while (s <  (char *)RELOC(dt_string_end)) {
1717                 if (strcmp(s, str) == 0)
1718                         return s - os;
1719                 s += strlen(s) + 1;
1720         }
1721         return 0;
1722 }
1723
1724 /*
1725  * The Open Firmware 1275 specification states properties must be 31 bytes or
1726  * less, however not all firmwares obey this. Make it 64 bytes to be safe.
1727  */
1728 #define MAX_PROPERTY_NAME 64
1729
1730 static void __init scan_dt_build_strings(phandle node,
1731                                          unsigned long *mem_start,
1732                                          unsigned long *mem_end)
1733 {
1734         char *prev_name, *namep, *sstart;
1735         unsigned long soff;
1736         phandle child;
1737
1738         sstart =  (char *)RELOC(dt_string_start);
1739
1740         /* get and store all property names */
1741         prev_name = RELOC("");
1742         for (;;) {
1743                 /* 64 is max len of name including nul. */
1744                 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1);
1745                 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) {
1746                         /* No more nodes: unwind alloc */
1747                         *mem_start = (unsigned long)namep;
1748                         break;
1749                 }
1750
1751                 /* skip "name" */
1752                 if (strcmp(namep, RELOC("name")) == 0) {
1753                         *mem_start = (unsigned long)namep;
1754                         prev_name = RELOC("name");
1755                         continue;
1756                 }
1757                 /* get/create string entry */
1758                 soff = dt_find_string(namep);
1759                 if (soff != 0) {
1760                         *mem_start = (unsigned long)namep;
1761                         namep = sstart + soff;
1762                 } else {
1763                         /* Trim off some if we can */
1764                         *mem_start = (unsigned long)namep + strlen(namep) + 1;
1765                         RELOC(dt_string_end) = *mem_start;
1766                 }
1767                 prev_name = namep;
1768         }
1769
1770         /* do all our children */
1771         child = call_prom("child", 1, 1, node);
1772         while (child != 0) {
1773                 scan_dt_build_strings(child, mem_start, mem_end);
1774                 child = call_prom("peer", 1, 1, child);
1775         }
1776 }
1777
1778 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
1779                                         unsigned long *mem_end)
1780 {
1781         phandle child;
1782         char *namep, *prev_name, *sstart, *p, *ep, *lp, *path;
1783         unsigned long soff;
1784         unsigned char *valp;
1785         static char pname[MAX_PROPERTY_NAME];
1786         int l, room;
1787
1788         dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end);
1789
1790         /* get the node's full name */
1791         namep = (char *)*mem_start;
1792         room = *mem_end - *mem_start;
1793         if (room > 255)
1794                 room = 255;
1795         l = call_prom("package-to-path", 3, 1, node, namep, room);
1796         if (l >= 0) {
1797                 /* Didn't fit?  Get more room. */
1798                 if (l >= room) {
1799                         if (l >= *mem_end - *mem_start)
1800                                 namep = make_room(mem_start, mem_end, l+1, 1);
1801                         call_prom("package-to-path", 3, 1, node, namep, l);
1802                 }
1803                 namep[l] = '\0';
1804
1805                 /* Fixup an Apple bug where they have bogus \0 chars in the
1806                  * middle of the path in some properties, and extract
1807                  * the unit name (everything after the last '/').
1808                  */
1809                 for (lp = p = namep, ep = namep + l; p < ep; p++) {
1810                         if (*p == '/')
1811                                 lp = namep;
1812                         else if (*p != 0)
1813                                 *lp++ = *p;
1814                 }
1815                 *lp = 0;
1816                 *mem_start = _ALIGN((unsigned long)lp + 1, 4);
1817         }
1818
1819         /* get it again for debugging */
1820         path = RELOC(prom_scratch);
1821         memset(path, 0, PROM_SCRATCH_SIZE);
1822         call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
1823
1824         /* get and store all properties */
1825         prev_name = RELOC("");
1826         sstart = (char *)RELOC(dt_string_start);
1827         for (;;) {
1828                 if (call_prom("nextprop", 3, 1, node, prev_name,
1829                               RELOC(pname)) != 1)
1830                         break;
1831
1832                 /* skip "name" */
1833                 if (strcmp(RELOC(pname), RELOC("name")) == 0) {
1834                         prev_name = RELOC("name");
1835                         continue;
1836                 }
1837
1838                 /* find string offset */
1839                 soff = dt_find_string(RELOC(pname));
1840                 if (soff == 0) {
1841                         prom_printf("WARNING: Can't find string index for"
1842                                     " <%s>, node %s\n", RELOC(pname), path);
1843                         break;
1844                 }
1845                 prev_name = sstart + soff;
1846
1847                 /* get length */
1848                 l = call_prom("getproplen", 2, 1, node, RELOC(pname));
1849
1850                 /* sanity checks */
1851                 if (l == PROM_ERROR)
1852                         continue;
1853                 if (l > MAX_PROPERTY_LENGTH) {
1854                         prom_printf("WARNING: ignoring large property ");
1855                         /* It seems OF doesn't null-terminate the path :-( */
1856                         prom_printf("[%s] ", path);
1857                         prom_printf("%s length 0x%x\n", RELOC(pname), l);
1858                         continue;
1859                 }
1860
1861                 /* push property head */
1862                 dt_push_token(OF_DT_PROP, mem_start, mem_end);
1863                 dt_push_token(l, mem_start, mem_end);
1864                 dt_push_token(soff, mem_start, mem_end);
1865
1866                 /* push property content */
1867                 valp = make_room(mem_start, mem_end, l, 4);
1868                 call_prom("getprop", 4, 1, node, RELOC(pname), valp, l);
1869                 *mem_start = _ALIGN(*mem_start, 4);
1870         }
1871
1872         /* Add a "linux,phandle" property. */
1873         soff = dt_find_string(RELOC("linux,phandle"));
1874         if (soff == 0)
1875                 prom_printf("WARNING: Can't find string index for"
1876                             " <linux-phandle> node %s\n", path);
1877         else {
1878                 dt_push_token(OF_DT_PROP, mem_start, mem_end);
1879                 dt_push_token(4, mem_start, mem_end);
1880                 dt_push_token(soff, mem_start, mem_end);
1881                 valp = make_room(mem_start, mem_end, 4, 4);
1882                 *(u32 *)valp = node;
1883         }
1884
1885         /* do all our children */
1886         child = call_prom("child", 1, 1, node);
1887         while (child != 0) {
1888                 scan_dt_build_struct(child, mem_start, mem_end);
1889                 child = call_prom("peer", 1, 1, child);
1890         }
1891
1892         dt_push_token(OF_DT_END_NODE, mem_start, mem_end);
1893 }
1894
1895 static void __init flatten_device_tree(void)
1896 {
1897         phandle root;
1898         unsigned long mem_start, mem_end, room;
1899         struct boot_param_header *hdr;
1900         struct prom_t *_prom = &RELOC(prom);
1901         char *namep;
1902         u64 *rsvmap;
1903
1904         /*
1905          * Check how much room we have between alloc top & bottom (+/- a
1906          * few pages), crop to 4Mb, as this is our "chuck" size
1907          */
1908         room = RELOC(alloc_top) - RELOC(alloc_bottom) - 0x4000;
1909         if (room > DEVTREE_CHUNK_SIZE)
1910                 room = DEVTREE_CHUNK_SIZE;
1911         prom_debug("starting device tree allocs at %x\n", RELOC(alloc_bottom));
1912
1913         /* Now try to claim that */
1914         mem_start = (unsigned long)alloc_up(room, PAGE_SIZE);
1915         if (mem_start == 0)
1916                 prom_panic("Can't allocate initial device-tree chunk\n");
1917         mem_end = RELOC(alloc_top);
1918
1919         /* Get root of tree */
1920         root = call_prom("peer", 1, 1, (phandle)0);
1921         if (root == (phandle)0)
1922                 prom_panic ("couldn't get device tree root\n");
1923
1924         /* Build header and make room for mem rsv map */
1925         mem_start = _ALIGN(mem_start, 4);
1926         hdr = make_room(&mem_start, &mem_end,
1927                         sizeof(struct boot_param_header), 4);
1928         RELOC(dt_header_start) = (unsigned long)hdr;
1929         rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8);
1930
1931         /* Start of strings */
1932         mem_start = PAGE_ALIGN(mem_start);
1933         RELOC(dt_string_start) = mem_start;
1934         mem_start += 4; /* hole */
1935
1936         /* Add "linux,phandle" in there, we'll need it */
1937         namep = make_room(&mem_start, &mem_end, 16, 1);
1938         strcpy(namep, RELOC("linux,phandle"));
1939         mem_start = (unsigned long)namep + strlen(namep) + 1;
1940
1941         /* Build string array */
1942         prom_printf("Building dt strings...\n");
1943         scan_dt_build_strings(root, &mem_start, &mem_end);
1944         RELOC(dt_string_end) = mem_start;
1945
1946         /* Build structure */
1947         mem_start = PAGE_ALIGN(mem_start);
1948         RELOC(dt_struct_start) = mem_start;
1949         prom_printf("Building dt structure...\n");
1950         scan_dt_build_struct(root, &mem_start, &mem_end);
1951         dt_push_token(OF_DT_END, &mem_start, &mem_end);
1952         RELOC(dt_struct_end) = PAGE_ALIGN(mem_start);
1953
1954         /* Finish header */
1955         hdr->boot_cpuid_phys = _prom->cpu;
1956         hdr->magic = OF_DT_HEADER;
1957         hdr->totalsize = RELOC(dt_struct_end) - RELOC(dt_header_start);
1958         hdr->off_dt_struct = RELOC(dt_struct_start) - RELOC(dt_header_start);
1959         hdr->off_dt_strings = RELOC(dt_string_start) - RELOC(dt_header_start);
1960         hdr->dt_strings_size = RELOC(dt_string_end) - RELOC(dt_string_start);
1961         hdr->off_mem_rsvmap = ((unsigned long)rsvmap) - RELOC(dt_header_start);
1962         hdr->version = OF_DT_VERSION;
1963         /* Version 16 is not backward compatible */
1964         hdr->last_comp_version = 0x10;
1965
1966         /* Copy the reserve map in */
1967         memcpy(rsvmap, RELOC(mem_reserve_map), sizeof(mem_reserve_map));
1968
1969 #ifdef DEBUG_PROM
1970         {
1971                 int i;
1972                 prom_printf("reserved memory map:\n");
1973                 for (i = 0; i < RELOC(mem_reserve_cnt); i++)
1974                         prom_printf("  %x - %x\n",
1975                                     RELOC(mem_reserve_map)[i].base,
1976                                     RELOC(mem_reserve_map)[i].size);
1977         }
1978 #endif
1979         /* Bump mem_reserve_cnt to cause further reservations to fail
1980          * since it's too late.
1981          */
1982         RELOC(mem_reserve_cnt) = MEM_RESERVE_MAP_SIZE;
1983
1984         prom_printf("Device tree strings 0x%x -> 0x%x\n",
1985                     RELOC(dt_string_start), RELOC(dt_string_end));
1986         prom_printf("Device tree struct  0x%x -> 0x%x\n",
1987                     RELOC(dt_struct_start), RELOC(dt_struct_end));
1988
1989 }
1990
1991 #ifdef CONFIG_PPC_MAPLE
1992 /* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property.
1993  * The values are bad, and it doesn't even have the right number of cells. */
1994 static void __init fixup_device_tree_maple(void)
1995 {
1996         phandle isa;
1997         u32 rloc = 0x01002000; /* IO space; PCI device = 4 */
1998         u32 isa_ranges[6];
1999         char *name;
2000
2001         name = "/ht@0/isa@4";
2002         isa = call_prom("finddevice", 1, 1, ADDR(name));
2003         if (!PHANDLE_VALID(isa)) {
2004                 name = "/ht@0/isa@6";
2005                 isa = call_prom("finddevice", 1, 1, ADDR(name));
2006                 rloc = 0x01003000; /* IO space; PCI device = 6 */
2007         }
2008         if (!PHANDLE_VALID(isa))
2009                 return;
2010
2011         if (prom_getproplen(isa, "ranges") != 12)
2012                 return;
2013         if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges))
2014                 == PROM_ERROR)
2015                 return;
2016
2017         if (isa_ranges[0] != 0x1 ||
2018                 isa_ranges[1] != 0xf4000000 ||
2019                 isa_ranges[2] != 0x00010000)
2020                 return;
2021
2022         prom_printf("Fixing up bogus ISA range on Maple/Apache...\n");
2023
2024         isa_ranges[0] = 0x1;
2025         isa_ranges[1] = 0x0;
2026         isa_ranges[2] = rloc;
2027         isa_ranges[3] = 0x0;
2028         isa_ranges[4] = 0x0;
2029         isa_ranges[5] = 0x00010000;
2030         prom_setprop(isa, name, "ranges",
2031                         isa_ranges, sizeof(isa_ranges));
2032 }
2033 #else
2034 #define fixup_device_tree_maple()
2035 #endif
2036
2037 #ifdef CONFIG_PPC_CHRP
2038 /* Pegasos and BriQ lacks the "ranges" property in the isa node */
2039 static void __init fixup_device_tree_chrp(void)
2040 {
2041         phandle isa;
2042         u32 isa_ranges[6];
2043         u32 rloc = 0x01006000; /* IO space; PCI device = 12 */
2044         char *name;
2045         int rc;
2046
2047         name = "/pci@80000000/isa@c";
2048         isa = call_prom("finddevice", 1, 1, ADDR(name));
2049         if (!PHANDLE_VALID(isa)) {
2050                 name = "/pci@ff500000/isa@6";
2051                 isa = call_prom("finddevice", 1, 1, ADDR(name));
2052                 rloc = 0x01003000; /* IO space; PCI device = 6 */
2053         }
2054         if (!PHANDLE_VALID(isa))
2055                 return;
2056
2057         rc = prom_getproplen(isa, "ranges");
2058         if (rc != 0 && rc != PROM_ERROR)
2059                 return;
2060
2061         prom_printf("Fixing up missing ISA range on Pegasos...\n");
2062
2063         isa_ranges[0] = 0x1;
2064         isa_ranges[1] = 0x0;
2065         isa_ranges[2] = rloc;
2066         isa_ranges[3] = 0x0;
2067         isa_ranges[4] = 0x0;
2068         isa_ranges[5] = 0x00010000;
2069         prom_setprop(isa, name, "ranges",
2070                         isa_ranges, sizeof(isa_ranges));
2071 }
2072 #else
2073 #define fixup_device_tree_chrp()
2074 #endif
2075
2076 #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC)
2077 static void __init fixup_device_tree_pmac(void)
2078 {
2079         phandle u3, i2c, mpic;
2080         u32 u3_rev;
2081         u32 interrupts[2];
2082         u32 parent;
2083
2084         /* Some G5s have a missing interrupt definition, fix it up here */
2085         u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000"));
2086         if (!PHANDLE_VALID(u3))
2087                 return;
2088         i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000"));
2089         if (!PHANDLE_VALID(i2c))
2090                 return;
2091         mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000"));
2092         if (!PHANDLE_VALID(mpic))
2093                 return;
2094
2095         /* check if proper rev of u3 */
2096         if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev))
2097             == PROM_ERROR)
2098                 return;
2099         if (u3_rev < 0x35 || u3_rev > 0x39)
2100                 return;
2101         /* does it need fixup ? */
2102         if (prom_getproplen(i2c, "interrupts") > 0)
2103                 return;
2104
2105         prom_printf("fixing up bogus interrupts for u3 i2c...\n");
2106
2107         /* interrupt on this revision of u3 is number 0 and level */
2108         interrupts[0] = 0;
2109         interrupts[1] = 1;
2110         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts",
2111                      &interrupts, sizeof(interrupts));
2112         parent = (u32)mpic;
2113         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent",
2114                      &parent, sizeof(parent));
2115 }
2116 #else
2117 #define fixup_device_tree_pmac()
2118 #endif
2119
2120 #ifdef CONFIG_PPC_EFIKA
2121 /* The current fw of the Efika has a device tree needs quite a few
2122  * fixups to be compliant with the mpc52xx bindings. It's currently
2123  * unknown if it will ever be compliant (come on bPlan ...) so we do fixups.
2124  * NOTE that we (barely) tolerate it because the EFIKA was out before
2125  * the bindings were finished, for any new boards -> RTFM ! */
2126
2127 struct subst_entry {
2128         char *path;
2129         char *property;
2130         void *value;
2131         int value_len;
2132 };
2133
2134 static void __init fixup_device_tree_efika(void)
2135 {
2136         /* Substitution table */
2137         #define prop_cstr(x) x, sizeof(x)
2138         int prop_sound_irq[3] = { 2, 2, 0 };
2139         int prop_bcomm_irq[3*16] = { 3,0,0, 3,1,0, 3,2,0, 3,3,0,
2140                                      3,4,0, 3,5,0, 3,6,0, 3,7,0,
2141                                      3,8,0, 3,9,0, 3,10,0, 3,11,0,
2142                                      3,12,0, 3,13,0, 3,14,0, 3,15,0 };
2143         struct subst_entry efika_subst_table[] = {
2144                 { "/",                  "device_type",  prop_cstr("efika") },
2145                 { "/builtin",           "compatible",   prop_cstr("soc") },
2146                 { "/builtin/ata",       "compatible",   prop_cstr("mpc5200b-ata\0mpc5200-ata"), },
2147                 { "/builtin/bestcomm",  "compatible",   prop_cstr("mpc5200b-bestcomm\0mpc5200-bestcomm") },
2148                 { "/builtin/bestcomm",  "interrupts",   prop_bcomm_irq, sizeof(prop_bcomm_irq) },
2149                 { "/builtin/ethernet",  "compatible",   prop_cstr("mpc5200b-fec\0mpc5200-fec") },
2150                 { "/builtin/pic",       "compatible",   prop_cstr("mpc5200b-pic\0mpc5200-pic") },
2151                 { "/builtin/serial",    "compatible",   prop_cstr("mpc5200b-psc-uart\0mpc5200-psc-uart") },
2152                 { "/builtin/sound",     "compatible",   prop_cstr("mpc5200b-psc-ac97\0mpc5200-psc-ac97") },
2153                 { "/builtin/sound",     "interrupts",   prop_sound_irq, sizeof(prop_sound_irq) },
2154                 { "/builtin/sram",      "compatible",   prop_cstr("mpc5200b-sram\0mpc5200-sram") },
2155                 { "/builtin/sram",      "device_type",  prop_cstr("sram") },
2156                 {}
2157         };
2158         #undef prop_cstr
2159
2160         /* Vars */
2161         u32 node;
2162         char prop[64];
2163         int rv, i;
2164
2165         /* Check if we're really running on a EFIKA */
2166         node = call_prom("finddevice", 1, 1, ADDR("/"));
2167         if (!PHANDLE_VALID(node))
2168                 return;
2169
2170         rv = prom_getprop(node, "model", prop, sizeof(prop));
2171         if (rv == PROM_ERROR)
2172                 return;
2173         if (strcmp(prop, "EFIKA5K2"))
2174                 return;
2175
2176         prom_printf("Applying EFIKA device tree fixups\n");
2177
2178         /* Process substitution table */
2179         for (i=0; efika_subst_table[i].path; i++) {
2180                 struct subst_entry *se = &efika_subst_table[i];
2181
2182                 node = call_prom("finddevice", 1, 1, ADDR(se->path));
2183                 if (!PHANDLE_VALID(node)) {
2184                         prom_printf("fixup_device_tree_efika: ",
2185                                 "skipped entry %x - not found\n", i);
2186                         continue;
2187                 }
2188
2189                 rv = prom_setprop(node, se->path, se->property,
2190                                         se->value, se->value_len );
2191                 if (rv == PROM_ERROR)
2192                         prom_printf("fixup_device_tree_efika: ",
2193                                 "skipped entry %x - setprop error\n", i);
2194         }
2195 }
2196 #else
2197 #define fixup_device_tree_efika()
2198 #endif
2199
2200 static void __init fixup_device_tree(void)
2201 {
2202         fixup_device_tree_maple();
2203         fixup_device_tree_chrp();
2204         fixup_device_tree_pmac();
2205         fixup_device_tree_efika();
2206 }
2207
2208 static void __init prom_find_boot_cpu(void)
2209 {
2210         struct prom_t *_prom = &RELOC(prom);
2211         u32 getprop_rval;
2212         ihandle prom_cpu;
2213         phandle cpu_pkg;
2214
2215         _prom->cpu = 0;
2216         if (prom_getprop(_prom->chosen, "cpu", &prom_cpu, sizeof(prom_cpu)) <= 0)
2217                 return;
2218
2219         cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
2220
2221         prom_getprop(cpu_pkg, "reg", &getprop_rval, sizeof(getprop_rval));
2222         _prom->cpu = getprop_rval;
2223
2224         prom_debug("Booting CPU hw index = 0x%x\n", _prom->cpu);
2225 }
2226
2227 static void __init prom_check_initrd(unsigned long r3, unsigned long r4)
2228 {
2229 #ifdef CONFIG_BLK_DEV_INITRD
2230         struct prom_t *_prom = &RELOC(prom);
2231
2232         if (r3 && r4 && r4 != 0xdeadbeef) {
2233                 unsigned long val;
2234
2235                 RELOC(prom_initrd_start) = is_kernel_addr(r3) ? __pa(r3) : r3;
2236                 RELOC(prom_initrd_end) = RELOC(prom_initrd_start) + r4;
2237
2238                 val = RELOC(prom_initrd_start);
2239                 prom_setprop(_prom->chosen, "/chosen", "linux,initrd-start",
2240                              &val, sizeof(val));
2241                 val = RELOC(prom_initrd_end);
2242                 prom_setprop(_prom->chosen, "/chosen", "linux,initrd-end",
2243                              &val, sizeof(val));
2244
2245                 reserve_mem(RELOC(prom_initrd_start),
2246                             RELOC(prom_initrd_end) - RELOC(prom_initrd_start));
2247
2248                 prom_debug("initrd_start=0x%x\n", RELOC(prom_initrd_start));
2249                 prom_debug("initrd_end=0x%x\n", RELOC(prom_initrd_end));
2250         }
2251 #endif /* CONFIG_BLK_DEV_INITRD */
2252 }
2253
2254 /*
2255  * We enter here early on, when the Open Firmware prom is still
2256  * handling exceptions and the MMU hash table for us.
2257  */
2258
2259 unsigned long __init prom_init(unsigned long r3, unsigned long r4,
2260                                unsigned long pp,
2261                                unsigned long r6, unsigned long r7)
2262 {
2263         struct prom_t *_prom;
2264         unsigned long hdr;
2265         unsigned long offset = reloc_offset();
2266
2267 #ifdef CONFIG_PPC32
2268         reloc_got2(offset);
2269 #endif
2270
2271         _prom = &RELOC(prom);
2272
2273         /*
2274          * First zero the BSS
2275          */
2276         memset(&RELOC(__bss_start), 0, __bss_stop - __bss_start);
2277
2278         /*
2279          * Init interface to Open Firmware, get some node references,
2280          * like /chosen
2281          */
2282         prom_init_client_services(pp);
2283
2284         /*
2285          * See if this OF is old enough that we need to do explicit maps
2286          * and other workarounds
2287          */
2288         prom_find_mmu();
2289
2290         /*
2291          * Init prom stdout device
2292          */
2293         prom_init_stdout();
2294
2295         /*
2296          * Get default machine type. At this point, we do not differentiate
2297          * between pSeries SMP and pSeries LPAR
2298          */
2299         RELOC(of_platform) = prom_find_machine_type();
2300
2301         /* Bail if this is a kdump kernel. */
2302         if (PHYSICAL_START > 0)
2303                 prom_panic("Error: You can't boot a kdump kernel from OF!\n");
2304
2305         /*
2306          * Check for an initrd
2307          */
2308         prom_check_initrd(r3, r4);
2309
2310 #ifdef CONFIG_PPC_PSERIES
2311         /*
2312          * On pSeries, inform the firmware about our capabilities
2313          */
2314         if (RELOC(of_platform) == PLATFORM_PSERIES ||
2315             RELOC(of_platform) == PLATFORM_PSERIES_LPAR)
2316                 prom_send_capabilities();
2317 #endif
2318
2319         /*
2320          * Copy the CPU hold code
2321          */
2322         if (RELOC(of_platform) != PLATFORM_POWERMAC)
2323                 copy_and_flush(0, KERNELBASE + offset, 0x100, 0);
2324
2325         /*
2326          * Do early parsing of command line
2327          */
2328         early_cmdline_parse();
2329
2330         /*
2331          * Initialize memory management within prom_init
2332          */
2333         prom_init_mem();
2334
2335         /*
2336          * Determine which cpu is actually running right _now_
2337          */
2338         prom_find_boot_cpu();
2339
2340         /*
2341          * Initialize display devices
2342          */
2343         prom_check_displays();
2344
2345 #ifdef CONFIG_PPC64
2346         /*
2347          * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else
2348          * that uses the allocator, we need to make sure we get the top of memory
2349          * available for us here...
2350          */
2351         if (RELOC(of_platform) == PLATFORM_PSERIES)
2352                 prom_initialize_tce_table();
2353 #endif
2354
2355         /*
2356          * On non-powermacs, try to instantiate RTAS and puts all CPUs
2357          * in spin-loops. PowerMacs don't have a working RTAS and use
2358          * a different way to spin CPUs
2359          */
2360         if (RELOC(of_platform) != PLATFORM_POWERMAC) {
2361                 prom_instantiate_rtas();
2362                 prom_hold_cpus();
2363         }
2364
2365         /*
2366          * Fill in some infos for use by the kernel later on
2367          */
2368 #ifdef CONFIG_PPC64
2369         if (RELOC(prom_iommu_off))
2370                 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-off",
2371                              NULL, 0);
2372
2373         if (RELOC(prom_iommu_force_on))
2374                 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-force-on",
2375                              NULL, 0);
2376
2377         if (RELOC(prom_tce_alloc_start)) {
2378                 prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-start",
2379                              &RELOC(prom_tce_alloc_start),
2380                              sizeof(prom_tce_alloc_start));
2381                 prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-end",
2382                              &RELOC(prom_tce_alloc_end),
2383                              sizeof(prom_tce_alloc_end));
2384         }
2385 #endif
2386
2387         /*
2388          * Fixup any known bugs in the device-tree
2389          */
2390         fixup_device_tree();
2391
2392         /*
2393          * Now finally create the flattened device-tree
2394          */
2395         prom_printf("copying OF device tree ...\n");
2396         flatten_device_tree();
2397
2398         /*
2399          * in case stdin is USB and still active on IBM machines...
2400          * Unfortunately quiesce crashes on some powermacs if we have
2401          * closed stdin already (in particular the powerbook 101).
2402          */
2403         if (RELOC(of_platform) != PLATFORM_POWERMAC)
2404                 prom_close_stdin();
2405
2406         /*
2407          * Call OF "quiesce" method to shut down pending DMA's from
2408          * devices etc...
2409          */
2410         prom_printf("Calling quiesce ...\n");
2411         call_prom("quiesce", 0, 0);
2412
2413         /*
2414          * And finally, call the kernel passing it the flattened device
2415          * tree and NULL as r5, thus triggering the new entry point which
2416          * is common to us and kexec
2417          */
2418         hdr = RELOC(dt_header_start);
2419         prom_printf("returning from prom_init\n");
2420         prom_debug("->dt_header_start=0x%x\n", hdr);
2421
2422 #ifdef CONFIG_PPC32
2423         reloc_got2(-offset);
2424 #endif
2425
2426         __start(hdr, KERNELBASE + offset, 0);
2427
2428         return 0;
2429 }