arch/powerpc/kernel/prom_init.c

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