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, unsigned long *mem_start,
1538                                          unsigned long *mem_end)
1539 {
1540         unsigned long offset = reloc_offset();
1541         char *prev_name, *namep, *sstart;
1542         unsigned long soff;
1543         phandle child;
1544
1545         sstart =  (char *)RELOC(dt_string_start);
1546
1547         /* get and store all property names */
1548         prev_name = RELOC("");
1549         for (;;) {
1550                 int rc;
1551
1552                 /* 64 is max len of name including nul. */
1553                 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1);
1554                 rc = call_prom("nextprop", 3, 1, node, prev_name, namep);
1555                 if (rc != 1) {
1556                         /* No more nodes: unwind alloc */
1557                         *mem_start = (unsigned long)namep;
1558                         break;
1559                 }
1560                 soff = dt_find_string(namep);
1561                 if (soff != 0) {
1562                         *mem_start = (unsigned long)namep;
1563                         namep = sstart + soff;
1564                 } else {
1565                         /* Trim off some if we can */
1566                         *mem_start = (unsigned long)namep + strlen(namep) + 1;
1567                         RELOC(dt_string_end) = *mem_start;
1568                 }
1569                 prev_name = namep;
1570         }
1571
1572         /* do all our children */
1573         child = call_prom("child", 1, 1, node);
1574         while (child != (phandle)0) {
1575                 scan_dt_build_strings(child, mem_start, mem_end);
1576                 child = call_prom("peer", 1, 1, child);
1577         }
1578 }
1579
1580 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
1581                                         unsigned long *mem_end)
1582 {
1583         int l, align;
1584         phandle child;
1585         char *namep, *prev_name, *sstart, *p, *ep;
1586         unsigned long soff;
1587         unsigned char *valp;
1588         unsigned long offset = reloc_offset();
1589         char pname[MAX_PROPERTY_NAME];
1590         char *path;
1591
1592         path = RELOC(prom_scratch);
1593
1594         dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end);
1595
1596         /* get the node's full name */
1597         namep = (char *)*mem_start;
1598         l = call_prom("package-to-path", 3, 1, node,
1599                       namep, *mem_end - *mem_start);
1600         if (l >= 0) {
1601                 /* Didn't fit?  Get more room. */
1602                 if (l+1 > *mem_end - *mem_start) {
1603                         namep = make_room(mem_start, mem_end, l+1, 1);
1604                         call_prom("package-to-path", 3, 1, node, namep, l);
1605                 }
1606                 namep[l] = '\0';
1607                 /* Fixup an Apple bug where they have bogus \0 chars in the
1608                  * middle of the path in some properties
1609                  */
1610                 for (p = namep, ep = namep + l; p < ep; p++)
1611                         if (*p == '\0') {
1612                                 memmove(p, p+1, ep - p);
1613                                 ep--; l--;
1614                         }
1615                 *mem_start = _ALIGN(((unsigned long) namep) + strlen(namep) + 1, 4);
1616         }
1617
1618         /* get it again for debugging */
1619         memset(path, 0, PROM_SCRATCH_SIZE);
1620         call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
1621
1622         /* get and store all properties */
1623         prev_name = RELOC("");
1624         sstart = (char *)RELOC(dt_string_start);
1625         for (;;) {
1626                 int rc;
1627
1628                 rc = call_prom("nextprop", 3, 1, node, prev_name, pname);
1629                 if (rc != 1)
1630                         break;
1631
1632                 /* find string offset */
1633                 soff = dt_find_string(pname);
1634                 if (soff == 0) {
1635                         prom_printf("WARNING: Can't find string index for <%s>, node %s\n",
1636                                     pname, path);
1637                         break;
1638                 }
1639                 prev_name = sstart + soff;
1640
1641                 /* get length */
1642                 l = call_prom("getproplen", 2, 1, node, pname);
1643
1644                 /* sanity checks */
1645                 if (l == PROM_ERROR)
1646                         continue;
1647                 if (l > MAX_PROPERTY_LENGTH) {
1648                         prom_printf("WARNING: ignoring large property ");
1649                         /* It seems OF doesn't null-terminate the path :-( */
1650                         prom_printf("[%s] ", path);
1651                         prom_printf("%s length 0x%x\n", pname, l);
1652                         continue;
1653                 }
1654
1655                 /* push property head */
1656                 dt_push_token(OF_DT_PROP, mem_start, mem_end);
1657                 dt_push_token(l, mem_start, mem_end);
1658                 dt_push_token(soff, mem_start, mem_end);
1659
1660                 /* push property content */
1661                 align = (l >= 8) ? 8 : 4;
1662                 valp = make_room(mem_start, mem_end, l, align);
1663                 call_prom("getprop", 4, 1, node, pname, valp, l);
1664                 *mem_start = _ALIGN(*mem_start, 4);
1665         }
1666
1667         /* Add a "linux,phandle" property. */
1668         soff = dt_find_string(RELOC("linux,phandle"));
1669         if (soff == 0)
1670                 prom_printf("WARNING: Can't find string index for <linux-phandle>"
1671                             " node %s\n", path);
1672         else {
1673                 dt_push_token(OF_DT_PROP, mem_start, mem_end);
1674                 dt_push_token(4, mem_start, mem_end);
1675                 dt_push_token(soff, mem_start, mem_end);
1676                 valp = make_room(mem_start, mem_end, 4, 4);
1677                 *(u32 *)valp = node;
1678         }
1679
1680         /* do all our children */
1681         child = call_prom("child", 1, 1, node);
1682         while (child != (phandle)0) {
1683                 scan_dt_build_struct(child, mem_start, mem_end);
1684                 child = call_prom("peer", 1, 1, child);
1685         }
1686
1687         dt_push_token(OF_DT_END_NODE, mem_start, mem_end);
1688 }
1689
1690 static void __init flatten_device_tree(void)
1691 {
1692         phandle root;
1693         unsigned long offset = reloc_offset();
1694         unsigned long mem_start, mem_end, room;
1695         struct boot_param_header *hdr;
1696         char *namep;
1697         u64 *rsvmap;
1698
1699         /*
1700          * Check how much room we have between alloc top & bottom (+/- a
1701          * few pages), crop to 4Mb, as this is our "chuck" size
1702          */
1703         room = RELOC(alloc_top) - RELOC(alloc_bottom) - 0x4000;
1704         if (room > DEVTREE_CHUNK_SIZE)
1705                 room = DEVTREE_CHUNK_SIZE;
1706         prom_debug("starting device tree allocs at %x\n", RELOC(alloc_bottom));
1707
1708         /* Now try to claim that */
1709         mem_start = (unsigned long)alloc_up(room, PAGE_SIZE);
1710         if (mem_start == 0)
1711                 prom_panic("Can't allocate initial device-tree chunk\n");
1712         mem_end = RELOC(alloc_top);
1713
1714         /* Get root of tree */
1715         root = call_prom("peer", 1, 1, (phandle)0);
1716         if (root == (phandle)0)
1717                 prom_panic ("couldn't get device tree root\n");
1718
1719         /* Build header and make room for mem rsv map */
1720         mem_start = _ALIGN(mem_start, 4);
1721         hdr = make_room(&mem_start, &mem_end, sizeof(struct boot_param_header), 4);
1722         RELOC(dt_header_start) = (unsigned long)hdr;
1723         rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8);
1724
1725         /* Start of strings */
1726         mem_start = PAGE_ALIGN(mem_start);
1727         RELOC(dt_string_start) = mem_start;
1728         mem_start += 4; /* hole */
1729
1730         /* Add "linux,phandle" in there, we'll need it */
1731         namep = make_room(&mem_start, &mem_end, 16, 1);
1732         strcpy(namep, RELOC("linux,phandle"));
1733         mem_start = (unsigned long)namep + strlen(namep) + 1;
1734         RELOC(dt_string_end) = mem_start;
1735
1736         /* Build string array */
1737         prom_printf("Building dt strings...\n");
1738         scan_dt_build_strings(root, &mem_start, &mem_end);
1739
1740         /* Build structure */
1741         mem_start = PAGE_ALIGN(mem_start);
1742         RELOC(dt_struct_start) = mem_start;
1743         prom_printf("Building dt structure...\n");
1744         scan_dt_build_struct(root, &mem_start, &mem_end);
1745         dt_push_token(OF_DT_END, &mem_start, &mem_end);
1746         RELOC(dt_struct_end) = PAGE_ALIGN(mem_start);
1747
1748         /* Finish header */
1749         hdr->magic = OF_DT_HEADER;
1750         hdr->totalsize = RELOC(dt_struct_end) - RELOC(dt_header_start);
1751         hdr->off_dt_struct = RELOC(dt_struct_start) - RELOC(dt_header_start);
1752         hdr->off_dt_strings = RELOC(dt_string_start) - RELOC(dt_header_start);
1753         hdr->off_mem_rsvmap = ((unsigned long)rsvmap) - RELOC(dt_header_start);
1754         hdr->version = OF_DT_VERSION;
1755         hdr->last_comp_version = 1;
1756
1757         /* Reserve the whole thing and copy the reserve map in, we
1758          * also bump mem_reserve_cnt to cause further reservations to
1759          * fail since it's too late.
1760          */
1761         reserve_mem(RELOC(dt_header_start), hdr->totalsize);
1762         memcpy(rsvmap, RELOC(mem_reserve_map), sizeof(mem_reserve_map));
1763
1764 #ifdef DEBUG_PROM
1765         {
1766                 int i;
1767                 prom_printf("reserved memory map:\n");
1768                 for (i = 0; i < RELOC(mem_reserve_cnt); i++)
1769                         prom_printf("  %x - %x\n", RELOC(mem_reserve_map)[i].base,
1770                                     RELOC(mem_reserve_map)[i].size);
1771         }
1772 #endif
1773         RELOC(mem_reserve_cnt) = MEM_RESERVE_MAP_SIZE;
1774
1775         prom_printf("Device tree strings 0x%x -> 0x%x\n",
1776                     RELOC(dt_string_start), RELOC(dt_string_end));
1777         prom_printf("Device tree struct  0x%x -> 0x%x\n",
1778                     RELOC(dt_struct_start), RELOC(dt_struct_end));
1779
1780 }
1781
1782
1783 static void __init fixup_device_tree(void)
1784 {
1785         unsigned long offset = reloc_offset();
1786         phandle u3, i2c, mpic;
1787         u32 u3_rev;
1788         u32 interrupts[2];
1789         u32 parent;
1790
1791         /* Some G5s have a missing interrupt definition, fix it up here */
1792         u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000"));
1793         if (!PHANDLE_VALID(u3))
1794                 return;
1795         i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000"));
1796         if (!PHANDLE_VALID(i2c))
1797                 return;
1798         mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000"));
1799         if (!PHANDLE_VALID(mpic))
1800                 return;
1801
1802         /* check if proper rev of u3 */
1803         if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev))
1804             == PROM_ERROR)
1805                 return;
1806         if (u3_rev != 0x35)
1807                 return;
1808         /* does it need fixup ? */
1809         if (prom_getproplen(i2c, "interrupts") > 0)
1810                 return;
1811         /* interrupt on this revision of u3 is number 0 and level */
1812         interrupts[0] = 0;
1813         interrupts[1] = 1;
1814         prom_setprop(i2c, "interrupts", &interrupts, sizeof(interrupts));
1815         parent = (u32)mpic;
1816         prom_setprop(i2c, "interrupt-parent", &parent, sizeof(parent));
1817 }
1818
1819
1820 static void __init prom_find_boot_cpu(void)
1821 {
1822         unsigned long offset = reloc_offset();
1823         struct prom_t *_prom = PTRRELOC(&prom);
1824         u32 getprop_rval;
1825         ihandle prom_cpu;
1826         phandle cpu_pkg;
1827
1828         if (prom_getprop(_prom->chosen, "cpu", &prom_cpu, sizeof(prom_cpu)) <= 0)
1829                 prom_panic("cannot find boot cpu");
1830
1831         cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
1832
1833         prom_setprop(cpu_pkg, "linux,boot-cpu", NULL, 0);
1834         prom_getprop(cpu_pkg, "reg", &getprop_rval, sizeof(getprop_rval));
1835         _prom->cpu = getprop_rval;
1836
1837         prom_debug("Booting CPU hw index = 0x%x\n", _prom->cpu);
1838 }
1839
1840 static void __init prom_check_initrd(unsigned long r3, unsigned long r4)
1841 {
1842 #ifdef CONFIG_BLK_DEV_INITRD
1843         unsigned long offset = reloc_offset();
1844         struct prom_t *_prom = PTRRELOC(&prom);
1845
1846         if ( r3 && r4 && r4 != 0xdeadbeef) {
1847                 u64 val;
1848
1849                 RELOC(prom_initrd_start) = (r3 >= KERNELBASE) ? __pa(r3) : r3;
1850                 RELOC(prom_initrd_end) = RELOC(prom_initrd_start) + r4;
1851
1852                 val = (u64)RELOC(prom_initrd_start);
1853                 prom_setprop(_prom->chosen, "linux,initrd-start", &val, sizeof(val));
1854                 val = (u64)RELOC(prom_initrd_end);
1855                 prom_setprop(_prom->chosen, "linux,initrd-end", &val, sizeof(val));
1856
1857                 reserve_mem(RELOC(prom_initrd_start),
1858                             RELOC(prom_initrd_end) - RELOC(prom_initrd_start));
1859
1860                 prom_debug("initrd_start=0x%x\n", RELOC(prom_initrd_start));
1861                 prom_debug("initrd_end=0x%x\n", RELOC(prom_initrd_end));
1862         }
1863 #endif /* CONFIG_BLK_DEV_INITRD */
1864 }
1865
1866 /*
1867  * We enter here early on, when the Open Firmware prom is still
1868  * handling exceptions and the MMU hash table for us.
1869  */
1870
1871 unsigned long __init prom_init(unsigned long r3, unsigned long r4, unsigned long pp,
1872                                unsigned long r6, unsigned long r7)
1873 {
1874         unsigned long offset = reloc_offset();
1875         struct prom_t *_prom = PTRRELOC(&prom);
1876         unsigned long phys = KERNELBASE - offset;
1877         u32 getprop_rval;
1878
1879         /*
1880          * First zero the BSS
1881          */
1882         memset(PTRRELOC(&__bss_start), 0, __bss_stop - __bss_start);
1883
1884         /*
1885          * Init interface to Open Firmware, get some node references,
1886          * like /chosen
1887          */
1888         prom_init_client_services(pp);
1889
1890         /*
1891          * Init prom stdout device
1892          */
1893         prom_init_stdout();
1894         prom_debug("klimit=0x%x\n", RELOC(klimit));
1895         prom_debug("offset=0x%x\n", offset);
1896
1897         /*
1898          * Check for an initrd
1899          */
1900         prom_check_initrd(r3, r4);
1901
1902         /*
1903          * Get default machine type. At this point, we do not differenciate
1904          * between pSeries SMP and pSeries LPAR
1905          */
1906         RELOC(of_platform) = prom_find_machine_type();
1907         getprop_rval = RELOC(of_platform);
1908         prom_setprop(_prom->chosen, "linux,platform",
1909                      &getprop_rval, sizeof(getprop_rval));
1910
1911         /*
1912          * On pSeries, inform the firmware about our capabilities
1913          */
1914         if (RELOC(of_platform) & PLATFORM_PSERIES)
1915                 prom_send_capabilities();
1916
1917         /*
1918          * On pSeries, copy the CPU hold code
1919          */
1920         if (RELOC(of_platform) & PLATFORM_PSERIES)
1921                 copy_and_flush(0, KERNELBASE - offset, 0x100, 0);
1922
1923         /*
1924          * Get memory cells format
1925          */
1926         getprop_rval = 1;
1927         prom_getprop(_prom->root, "#size-cells",
1928                      &getprop_rval, sizeof(getprop_rval));
1929         _prom->root_size_cells = getprop_rval;
1930         getprop_rval = 2;
1931         prom_getprop(_prom->root, "#address-cells",
1932                      &getprop_rval, sizeof(getprop_rval));
1933         _prom->root_addr_cells = getprop_rval;
1934
1935         /*
1936          * Do early parsing of command line
1937          */
1938         early_cmdline_parse();
1939
1940         /*
1941          * Initialize memory management within prom_init
1942          */
1943         prom_init_mem();
1944
1945         /*
1946          * Determine which cpu is actually running right _now_
1947          */
1948         prom_find_boot_cpu();
1949
1950         /*
1951          * Initialize display devices
1952          */
1953         prom_check_displays();
1954
1955         /*
1956          * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else
1957          * that uses the allocator, we need to make sure we get the top of memory
1958          * available for us here...
1959          */
1960         if (RELOC(of_platform) == PLATFORM_PSERIES)
1961                 prom_initialize_tce_table();
1962
1963         /*
1964          * On non-powermacs, try to instantiate RTAS and puts all CPUs
1965          * in spin-loops. PowerMacs don't have a working RTAS and use
1966          * a different way to spin CPUs
1967          */
1968         if (RELOC(of_platform) != PLATFORM_POWERMAC) {
1969                 prom_instantiate_rtas();
1970                 prom_hold_cpus();
1971         }
1972
1973         /*
1974          * Fill in some infos for use by the kernel later on
1975          */
1976         if (RELOC(ppc64_iommu_off))
1977                 prom_setprop(_prom->chosen, "linux,iommu-off", NULL, 0);
1978
1979         if (RELOC(iommu_force_on))
1980                 prom_setprop(_prom->chosen, "linux,iommu-force-on", NULL, 0);
1981
1982         if (RELOC(prom_memory_limit))
1983                 prom_setprop(_prom->chosen, "linux,memory-limit",
1984                         PTRRELOC(&prom_memory_limit), sizeof(RELOC(prom_memory_limit)));
1985
1986         if (RELOC(prom_tce_alloc_start)) {
1987                 prom_setprop(_prom->chosen, "linux,tce-alloc-start",
1988                         PTRRELOC(&prom_tce_alloc_start), sizeof(RELOC(prom_tce_alloc_start)));
1989                 prom_setprop(_prom->chosen, "linux,tce-alloc-end",
1990                         PTRRELOC(&prom_tce_alloc_end), sizeof(RELOC(prom_tce_alloc_end)));
1991         }
1992
1993         /*
1994          * Fixup any known bugs in the device-tree
1995          */
1996         fixup_device_tree();
1997
1998         /*
1999          * Now finally create the flattened device-tree
2000          */
2001         prom_printf("copying OF device tree ...\n");
2002         flatten_device_tree();
2003
2004         /* in case stdin is USB and still active on IBM machines... */
2005         prom_close_stdin();
2006
2007         /*
2008          * Call OF "quiesce" method to shut down pending DMA's from
2009          * devices etc...
2010          */
2011         prom_printf("Calling quiesce ...\n");
2012         call_prom("quiesce", 0, 0);
2013
2014         /*
2015          * And finally, call the kernel passing it the flattened device
2016          * tree and NULL as r5, thus triggering the new entry point which
2017          * is common to us and kexec
2018          */
2019         prom_printf("returning from prom_init\n");
2020         prom_debug("->dt_header_start=0x%x\n", RELOC(dt_header_start));
2021         prom_debug("->phys=0x%x\n", phys);
2022
2023         __start(RELOC(dt_header_start), phys, 0);
2024
2025         return 0;
2026 }
2027