arch/powerpc/kernel/prom_init.c

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