arch/ppc64/kernel/prom_init.c

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