git.oblomov.eu Git - linux-2.6/blob - arch/powerpc/kernel/prom_init.c

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