arch/powerpc/kernel/prom_init.c

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