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/kernel.h>
  20 #include <linux/string.h>
  21 #include <linux/init.h>
  22 #include <linux/threads.h>
  23 #include <linux/spinlock.h>
  24 #include <linux/types.h>
  25 #include <linux/pci.h>
  26 #include <linux/proc_fs.h>
  27 #include <linux/stringify.h>
  28 #include <linux/delay.h>
  29 #include <linux/initrd.h>
  30 #include <linux/bitops.h>
  31 #include <asm/prom.h>
  32 #include <asm/rtas.h>
  33 #include <asm/page.h>
  34 #include <asm/processor.h>
  35 #include <asm/irq.h>
  36 #include <asm/io.h>
  37 #include <asm/smp.h>
  38 #include <asm/system.h>
  39 #include <asm/mmu.h>
  40 #include <asm/pgtable.h>
  41 #include <asm/pci.h>
  42 #include <asm/iommu.h>
  43 #include <asm/btext.h>
  44 #include <asm/sections.h>
  45 #include <asm/machdep.h>
  46 #include <asm/opal.h>
  47
  48 #include <linux/linux_logo.h>
  49
  50 /*
  51  * Eventually bump that one up
  52  */
  53 #define DEVTREE_CHUNK_SIZE      0x100000
  54
  55 /*
  56  * This is the size of the local memory reserve map that gets copied
  57  * into the boot params passed to the kernel. That size is totally
  58  * flexible as the kernel just reads the list until it encounters an
  59  * entry with size 0, so it can be changed without breaking binary
  60  * compatibility
  61  */
  62 #define MEM_RESERVE_MAP_SIZE    8
  63
  64 /*
  65  * prom_init() is called very early on, before the kernel text
  66  * and data have been mapped to KERNELBASE.  At this point the code
  67  * is running at whatever address it has been loaded at.
  68  * On ppc32 we compile with -mrelocatable, which means that references
  69  * to extern and static variables get relocated automatically.
  70  * On ppc64 we have to relocate the references explicitly with
  71  * RELOC.  (Note that strings count as static variables.)
  72  *
  73  * Because OF may have mapped I/O devices into the area starting at
  74  * KERNELBASE, particularly on CHRP machines, we can't safely call
  75  * OF once the kernel has been mapped to KERNELBASE.  Therefore all
  76  * OF calls must be done within prom_init().
  77  *
  78  * ADDR is used in calls to call_prom.  The 4th and following
  79  * arguments to call_prom should be 32-bit values.
  80  * On ppc64, 64 bit values are truncated to 32 bits (and
  81  * fortunately don't get interpreted as two arguments).
  82  */
  83 #ifdef CONFIG_PPC64
  84 #define RELOC(x)        (*PTRRELOC(&(x)))
  85 #define ADDR(x)         (u32) add_reloc_offset((unsigned long)(x))
  86 #define OF_WORKAROUNDS  0
  87 #else
  88 #define RELOC(x)        (x)
  89 #define ADDR(x)         (u32) (x)
  90 #define OF_WORKAROUNDS  of_workarounds
  91 int of_workarounds;
  92 #endif
  93
  94 #define OF_WA_CLAIM     1       /* do phys/virt claim separately, then map */
  95 #define OF_WA_LONGTRAIL 2       /* work around longtrail bugs */
  96
  97 #define PROM_BUG() do {                                         \
  98         prom_printf("kernel BUG at %s line 0x%x!\n",            \
  99                     RELOC(__FILE__), __LINE__);                 \
 100         __asm__ __volatile__(".long " BUG_ILLEGAL_INSTR);       \
 101 } while (0)
 102
 103 #ifdef DEBUG_PROM
 104 #define prom_debug(x...)        prom_printf(x)
 105 #else
 106 #define prom_debug(x...)
 107 #endif
 108
 109
 110 typedef u32 prom_arg_t;
 111
 112 struct prom_args {
 113         u32 service;
 114         u32 nargs;
 115         u32 nret;
 116         prom_arg_t args[10];
 117 };
 118
 119 struct prom_t {
 120         ihandle root;
 121         phandle chosen;
 122         int cpu;
 123         ihandle stdout;
 124         ihandle mmumap;
 125         ihandle memory;
 126 };
 127
 128 struct mem_map_entry {
 129         u64     base;
 130         u64     size;
 131 };
 132
 133 typedef u32 cell_t;
 134
 135 extern void __start(unsigned long r3, unsigned long r4, unsigned long r5,
 136                     unsigned long r6, unsigned long r7, unsigned long r8,
 137                     unsigned long r9);
 138
 139 #ifdef CONFIG_PPC64
 140 extern int enter_prom(struct prom_args *args, unsigned long entry);
 141 #else
 142 static inline int enter_prom(struct prom_args *args, unsigned long entry)
 143 {
 144         return ((int (*)(struct prom_args *))entry)(args);
 145 }
 146 #endif
 147
 148 extern void copy_and_flush(unsigned long dest, unsigned long src,
 149                            unsigned long size, unsigned long offset);
 150
 151 /* prom structure */
 152 static struct prom_t __initdata prom;
 153
 154 static unsigned long prom_entry __initdata;
 155
 156 #define PROM_SCRATCH_SIZE 256
 157
 158 static char __initdata of_stdout_device[256];
 159 static char __initdata prom_scratch[PROM_SCRATCH_SIZE];
 160
 161 static unsigned long __initdata dt_header_start;
 162 static unsigned long __initdata dt_struct_start, dt_struct_end;
 163 static unsigned long __initdata dt_string_start, dt_string_end;
 164
 165 static unsigned long __initdata prom_initrd_start, prom_initrd_end;
 166
 167 #ifdef CONFIG_PPC64
 168 static int __initdata prom_iommu_force_on;
 169 static int __initdata prom_iommu_off;
 170 static unsigned long __initdata prom_tce_alloc_start;
 171 static unsigned long __initdata prom_tce_alloc_end;
 172 #endif
 173
 174 /* Platforms codes are now obsolete in the kernel. Now only used within this
 175  * file and ultimately gone too. Feel free to change them if you need, they
 176  * are not shared with anything outside of this file anymore
 177  */
 178 #define PLATFORM_PSERIES        0x0100
 179 #define PLATFORM_PSERIES_LPAR   0x0101
 180 #define PLATFORM_LPAR           0x0001
 181 #define PLATFORM_POWERMAC       0x0400
 182 #define PLATFORM_GENERIC        0x0500
 183 #define PLATFORM_OPAL           0x0600
 184
 185 static int __initdata of_platform;
 186
 187 static char __initdata prom_cmd_line[COMMAND_LINE_SIZE];
 188
 189 static unsigned long __initdata prom_memory_limit;
 190
 191 static unsigned long __initdata alloc_top;
 192 static unsigned long __initdata alloc_top_high;
 193 static unsigned long __initdata alloc_bottom;
 194 static unsigned long __initdata rmo_top;
 195 static unsigned long __initdata ram_top;
 196
 197 static struct mem_map_entry __initdata mem_reserve_map[MEM_RESERVE_MAP_SIZE];
 198 static int __initdata mem_reserve_cnt;
 199
 200 static cell_t __initdata regbuf[1024];
 201
 202
 203 /*
 204  * Error results ... some OF calls will return "-1" on error, some
 205  * will return 0, some will return either. To simplify, here are
 206  * macros to use with any ihandle or phandle return value to check if
 207  * it is valid
 208  */
 209
 210 #define PROM_ERROR              (-1u)
 211 #define PHANDLE_VALID(p)        ((p) != 0 && (p) != PROM_ERROR)
 212 #define IHANDLE_VALID(i)        ((i) != 0 && (i) != PROM_ERROR)
 213
 214
 215 /* This is the one and *ONLY* place where we actually call open
 216  * firmware.
 217  */
 218
 219 static int __init call_prom(const char *service, int nargs, int nret, ...)
 220 {
 221         int i;
 222         struct prom_args args;
 223         va_list list;
 224
 225         args.service = ADDR(service);
 226         args.nargs = nargs;
 227         args.nret = nret;
 228
 229         va_start(list, nret);
 230         for (i = 0; i < nargs; i++)
 231                 args.args[i] = va_arg(list, prom_arg_t);
 232         va_end(list);
 233
 234         for (i = 0; i < nret; i++)
 235                 args.args[nargs+i] = 0;
 236
 237         if (enter_prom(&args, RELOC(prom_entry)) < 0)
 238                 return PROM_ERROR;
 239
 240         return (nret > 0) ? args.args[nargs] : 0;
 241 }
 242
 243 static int __init call_prom_ret(const char *service, int nargs, int nret,
 244                                 prom_arg_t *rets, ...)
 245 {
 246         int i;
 247         struct prom_args args;
 248         va_list list;
 249
 250         args.service = ADDR(service);
 251         args.nargs = nargs;
 252         args.nret = nret;
 253
 254         va_start(list, rets);
 255         for (i = 0; i < nargs; i++)
 256                 args.args[i] = va_arg(list, prom_arg_t);
 257         va_end(list);
 258
 259         for (i = 0; i < nret; i++)
 260                 args.args[nargs+i] = 0;
 261
 262         if (enter_prom(&args, RELOC(prom_entry)) < 0)
 263                 return PROM_ERROR;
 264
 265         if (rets != NULL)
 266                 for (i = 1; i < nret; ++i)
 267                         rets[i-1] = args.args[nargs+i];
 268
 269         return (nret > 0) ? args.args[nargs] : 0;
 270 }
 271
 272
 273 static void __init prom_print(const char *msg)
 274 {
 275         const char *p, *q;
 276         struct prom_t *_prom = &RELOC(prom);
 277
 278         if (_prom->stdout == 0)
 279                 return;
 280
 281         for (p = msg; *p != 0; p = q) {
 282                 for (q = p; *q != 0 && *q != '\n'; ++q)
 283                         ;
 284                 if (q > p)
 285                         call_prom("write", 3, 1, _prom->stdout, p, q - p);
 286                 if (*q == 0)
 287                         break;
 288                 ++q;
 289                 call_prom("write", 3, 1, _prom->stdout, ADDR("\r\n"), 2);
 290         }
 291 }
 292
 293
 294 static void __init prom_print_hex(unsigned long val)
 295 {
 296         int i, nibbles = sizeof(val)*2;
 297         char buf[sizeof(val)*2+1];
 298         struct prom_t *_prom = &RELOC(prom);
 299
 300         for (i = nibbles-1;  i >= 0;  i--) {
 301                 buf[i] = (val & 0xf) + '0';
 302                 if (buf[i] > '9')
 303                         buf[i] += ('a'-'0'-10);
 304                 val >>= 4;
 305         }
 306         buf[nibbles] = '\0';
 307         call_prom("write", 3, 1, _prom->stdout, buf, nibbles);
 308 }
 309
 310 /* max number of decimal digits in an unsigned long */
 311 #define UL_DIGITS 21
 312 static void __init prom_print_dec(unsigned long val)
 313 {
 314         int i, size;
 315         char buf[UL_DIGITS+1];
 316         struct prom_t *_prom = &RELOC(prom);
 317
 318         for (i = UL_DIGITS-1; i >= 0;  i--) {
 319                 buf[i] = (val % 10) + '0';
 320                 val = val/10;
 321                 if (val == 0)
 322                         break;
 323         }
 324         /* shift stuff down */
 325         size = UL_DIGITS - i;
 326         call_prom("write", 3, 1, _prom->stdout, buf+i, size);
 327 }
 328
 329 static void __init prom_printf(const char *format, ...)
 330 {
 331         const char *p, *q, *s;
 332         va_list args;
 333         unsigned long v;
 334         long vs;
 335         struct prom_t *_prom = &RELOC(prom);
 336
 337         va_start(args, format);
 338 #ifdef CONFIG_PPC64
 339         format = PTRRELOC(format);
 340 #endif
 341         for (p = format; *p != 0; p = q) {
 342                 for (q = p; *q != 0 && *q != '\n' && *q != '%'; ++q)
 343                         ;
 344                 if (q > p)
 345                         call_prom("write", 3, 1, _prom->stdout, p, q - p);
 346                 if (*q == 0)
 347                         break;
 348                 if (*q == '\n') {
 349                         ++q;
 350                         call_prom("write", 3, 1, _prom->stdout,
 351                                   ADDR("\r\n"), 2);
 352                         continue;
 353                 }
 354                 ++q;
 355                 if (*q == 0)
 356                         break;
 357                 switch (*q) {
 358                 case 's':
 359                         ++q;
 360                         s = va_arg(args, const char *);
 361                         prom_print(s);
 362                         break;
 363                 case 'x':
 364                         ++q;
 365                         v = va_arg(args, unsigned long);
 366                         prom_print_hex(v);
 367                         break;
 368                 case 'd':
 369                         ++q;
 370                         vs = va_arg(args, int);
 371                         if (vs < 0) {
 372                                 prom_print(RELOC("-"));
 373                                 vs = -vs;
 374                         }
 375                         prom_print_dec(vs);
 376                         break;
 377                 case 'l':
 378                         ++q;
 379                         if (*q == 0)
 380                                 break;
 381                         else if (*q == 'x') {
 382                                 ++q;
 383                                 v = va_arg(args, unsigned long);
 384                                 prom_print_hex(v);
 385                         } else if (*q == 'u') { /* '%lu' */
 386                                 ++q;
 387                                 v = va_arg(args, unsigned long);
 388                                 prom_print_dec(v);
 389                         } else if (*q == 'd') { /* %ld */
 390                                 ++q;
 391                                 vs = va_arg(args, long);
 392                                 if (vs < 0) {
 393                                         prom_print(RELOC("-"));
 394                                         vs = -vs;
 395                                 }
 396                                 prom_print_dec(vs);
 397                         }
 398                         break;
 399                 }
 400         }
 401 }
 402
 403
 404 static unsigned int __init prom_claim(unsigned long virt, unsigned long size,
 405                                 unsigned long align)
 406 {
 407         struct prom_t *_prom = &RELOC(prom);
 408
 409         if (align == 0 && (OF_WORKAROUNDS & OF_WA_CLAIM)) {
 410                 /*
 411                  * Old OF requires we claim physical and virtual separately
 412                  * and then map explicitly (assuming virtual mode)
 413                  */
 414                 int ret;
 415                 prom_arg_t result;
 416
 417                 ret = call_prom_ret("call-method", 5, 2, &result,
 418                                     ADDR("claim"), _prom->memory,
 419                                     align, size, virt);
 420                 if (ret != 0 || result == -1)
 421                         return -1;
 422                 ret = call_prom_ret("call-method", 5, 2, &result,
 423                                     ADDR("claim"), _prom->mmumap,
 424                                     align, size, virt);
 425                 if (ret != 0) {
 426                         call_prom("call-method", 4, 1, ADDR("release"),
 427                                   _prom->memory, size, virt);
 428                         return -1;
 429                 }
 430                 /* the 0x12 is M (coherence) + PP == read/write */
 431                 call_prom("call-method", 6, 1,
 432                           ADDR("map"), _prom->mmumap, 0x12, size, virt, virt);
 433                 return virt;
 434         }
 435         return call_prom("claim", 3, 1, (prom_arg_t)virt, (prom_arg_t)size,
 436                          (prom_arg_t)align);
 437 }
 438
 439 static void __init __attribute__((noreturn)) prom_panic(const char *reason)
 440 {
 441 #ifdef CONFIG_PPC64
 442         reason = PTRRELOC(reason);
 443 #endif
 444         prom_print(reason);
 445         /* Do not call exit because it clears the screen on pmac
 446          * it also causes some sort of double-fault on early pmacs */
 447         if (RELOC(of_platform) == PLATFORM_POWERMAC)
 448                 asm("trap\n");
 449
 450         /* ToDo: should put up an SRC here on pSeries */
 451         call_prom("exit", 0, 0);
 452
 453         for (;;)                        /* should never get here */
 454                 ;
 455 }
 456
 457
 458 static int __init prom_next_node(phandle *nodep)
 459 {
 460         phandle node;
 461
 462         if ((node = *nodep) != 0
 463             && (*nodep = call_prom("child", 1, 1, node)) != 0)
 464                 return 1;
 465         if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
 466                 return 1;
 467         for (;;) {
 468                 if ((node = call_prom("parent", 1, 1, node)) == 0)
 469                         return 0;
 470                 if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
 471                         return 1;
 472         }
 473 }
 474
 475 static int inline prom_getprop(phandle node, const char *pname,
 476                                void *value, size_t valuelen)
 477 {
 478         return call_prom("getprop", 4, 1, node, ADDR(pname),
 479                          (u32)(unsigned long) value, (u32) valuelen);
 480 }
 481
 482 static int inline prom_getproplen(phandle node, const char *pname)
 483 {
 484         return call_prom("getproplen", 2, 1, node, ADDR(pname));
 485 }
 486
 487 static void add_string(char **str, const char *q)
 488 {
 489         char *p = *str;
 490
 491         while (*q)
 492                 *p++ = *q++;
 493         *p++ = ' ';
 494         *str = p;
 495 }
 496
 497 static char *tohex(unsigned int x)
 498 {
 499         static char digits[] = "0123456789abcdef";
 500         static char result[9];
 501         int i;
 502
 503         result[8] = 0;
 504         i = 8;
 505         do {
 506                 --i;
 507                 result[i] = digits[x & 0xf];
 508                 x >>= 4;
 509         } while (x != 0 && i > 0);
 510         return &result[i];
 511 }
 512
 513 static int __init prom_setprop(phandle node, const char *nodename,
 514                                const char *pname, void *value, size_t valuelen)
 515 {
 516         char cmd[256], *p;
 517
 518         if (!(OF_WORKAROUNDS & OF_WA_LONGTRAIL))
 519                 return call_prom("setprop", 4, 1, node, ADDR(pname),
 520                                  (u32)(unsigned long) value, (u32) valuelen);
 521
 522         /* gah... setprop doesn't work on longtrail, have to use interpret */
 523         p = cmd;
 524         add_string(&p, "dev");
 525         add_string(&p, nodename);
 526         add_string(&p, tohex((u32)(unsigned long) value));
 527         add_string(&p, tohex(valuelen));
 528         add_string(&p, tohex(ADDR(pname)));
 529         add_string(&p, tohex(strlen(RELOC(pname))));
 530         add_string(&p, "property");
 531         *p = 0;
 532         return call_prom("interpret", 1, 1, (u32)(unsigned long) cmd);
 533 }
 534
 535 /* We can't use the standard versions because of RELOC headaches. */
 536 #define isxdigit(c)     (('0' <= (c) && (c) <= '9') \
 537                          || ('a' <= (c) && (c) <= 'f') \
 538                          || ('A' <= (c) && (c) <= 'F'))
 539
 540 #define isdigit(c)      ('0' <= (c) && (c) <= '9')
 541 #define islower(c)      ('a' <= (c) && (c) <= 'z')
 542 #define toupper(c)      (islower(c) ? ((c) - 'a' + 'A') : (c))
 543
 544 unsigned long prom_strtoul(const char *cp, const char **endp)
 545 {
 546         unsigned long result = 0, base = 10, value;
 547
 548         if (*cp == '0') {
 549                 base = 8;
 550                 cp++;
 551                 if (toupper(*cp) == 'X') {
 552                         cp++;
 553                         base = 16;
 554                 }
 555         }
 556
 557         while (isxdigit(*cp) &&
 558                (value = isdigit(*cp) ? *cp - '0' : toupper(*cp) - 'A' + 10) < base) {
 559                 result = result * base + value;
 560                 cp++;
 561         }
 562
 563         if (endp)
 564                 *endp = cp;
 565
 566         return result;
 567 }
 568
 569 unsigned long prom_memparse(const char *ptr, const char **retptr)
 570 {
 571         unsigned long ret = prom_strtoul(ptr, retptr);
 572         int shift = 0;
 573
 574         /*
 575          * We can't use a switch here because GCC *may* generate a
 576          * jump table which won't work, because we're not running at
 577          * the address we're linked at.
 578          */
 579         if ('G' == **retptr || 'g' == **retptr)
 580                 shift = 30;
 581
 582         if ('M' == **retptr || 'm' == **retptr)
 583                 shift = 20;
 584
 585         if ('K' == **retptr || 'k' == **retptr)
 586                 shift = 10;
 587
 588         if (shift) {
 589                 ret <<= shift;
 590                 (*retptr)++;
 591         }
 592
 593         return ret;
 594 }
 595
 596 /*
 597  * Early parsing of the command line passed to the kernel, used for
 598  * "mem=x" and the options that affect the iommu
 599  */
 600 static void __init early_cmdline_parse(void)
 601 {
 602         struct prom_t *_prom = &RELOC(prom);
 603         const char *opt;
 604
 605         char *p;
 606         int l = 0;
 607
 608         RELOC(prom_cmd_line[0]) = 0;
 609         p = RELOC(prom_cmd_line);
 610         if ((long)_prom->chosen > 0)
 611                 l = prom_getprop(_prom->chosen, "bootargs", p, COMMAND_LINE_SIZE-1);
 612 #ifdef CONFIG_CMDLINE
 613         if (l <= 0 || p[0] == '\0') /* dbl check */
 614                 strlcpy(RELOC(prom_cmd_line),
 615                         RELOC(CONFIG_CMDLINE), sizeof(prom_cmd_line));
 616 #endif /* CONFIG_CMDLINE */
 617         prom_printf("command line: %s\n", RELOC(prom_cmd_line));
 618
 619 #ifdef CONFIG_PPC64
 620         opt = strstr(RELOC(prom_cmd_line), RELOC("iommu="));
 621         if (opt) {
 622                 prom_printf("iommu opt is: %s\n", opt);
 623                 opt += 6;
 624                 while (*opt && *opt == ' ')
 625                         opt++;
 626                 if (!strncmp(opt, RELOC("off"), 3))
 627                         RELOC(prom_iommu_off) = 1;
 628                 else if (!strncmp(opt, RELOC("force"), 5))
 629                         RELOC(prom_iommu_force_on) = 1;
 630         }
 631 #endif
 632         opt = strstr(RELOC(prom_cmd_line), RELOC("mem="));
 633         if (opt) {
 634                 opt += 4;
 635                 RELOC(prom_memory_limit) = prom_memparse(opt, (const char **)&opt);
 636 #ifdef CONFIG_PPC64
 637                 /* Align to 16 MB == size of ppc64 large page */
 638                 RELOC(prom_memory_limit) = ALIGN(RELOC(prom_memory_limit), 0x1000000);
 639 #endif
 640         }
 641 }
 642
 643 #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
 644 /*
 645  * There are two methods for telling firmware what our capabilities are.
 646  * Newer machines have an "ibm,client-architecture-support" method on the
 647  * root node.  For older machines, we have to call the "process-elf-header"
 648  * method in the /packages/elf-loader node, passing it a fake 32-bit
 649  * ELF header containing a couple of PT_NOTE sections that contain
 650  * structures that contain various information.
 651  */
 652
 653 /*
 654  * New method - extensible architecture description vector.
 655  *
 656  * Because the description vector contains a mix of byte and word
 657  * values, we declare it as an unsigned char array, and use this
 658  * macro to put word values in.
 659  */
 660 #define W(x)    ((x) >> 24) & 0xff, ((x) >> 16) & 0xff, \
 661                 ((x) >> 8) & 0xff, (x) & 0xff
 662
 663 /* Option vector bits - generic bits in byte 1 */
 664 #define OV_IGNORE               0x80    /* ignore this vector */
 665 #define OV_CESSATION_POLICY     0x40    /* halt if unsupported option present*/
 666
 667 /* Option vector 1: processor architectures supported */
 668 #define OV1_PPC_2_00            0x80    /* set if we support PowerPC 2.00 */
 669 #define OV1_PPC_2_01            0x40    /* set if we support PowerPC 2.01 */
 670 #define OV1_PPC_2_02            0x20    /* set if we support PowerPC 2.02 */
 671 #define OV1_PPC_2_03            0x10    /* set if we support PowerPC 2.03 */
 672 #define OV1_PPC_2_04            0x08    /* set if we support PowerPC 2.04 */
 673 #define OV1_PPC_2_05            0x04    /* set if we support PowerPC 2.05 */
 674 #define OV1_PPC_2_06            0x02    /* set if we support PowerPC 2.06 */
 675
 676 /* Option vector 2: Open Firmware options supported */
 677 #define OV2_REAL_MODE           0x20    /* set if we want OF in real mode */
 678
 679 /* Option vector 3: processor options supported */
 680 #define OV3_FP                  0x80    /* floating point */
 681 #define OV3_VMX                 0x40    /* VMX/Altivec */
 682 #define OV3_DFP                 0x20    /* decimal FP */
 683
 684 /* Option vector 5: PAPR/OF options supported */
 685 #define OV5_LPAR                0x80    /* logical partitioning supported */
 686 #define OV5_SPLPAR              0x40    /* shared-processor LPAR supported */
 687 /* ibm,dynamic-reconfiguration-memory property supported */
 688 #define OV5_DRCONF_MEMORY       0x20
 689 #define OV5_LARGE_PAGES         0x10    /* large pages supported */
 690 #define OV5_DONATE_DEDICATE_CPU 0x02    /* donate dedicated CPU support */
 691 /* PCIe/MSI support.  Without MSI full PCIe is not supported */
 692 #ifdef CONFIG_PCI_MSI
 693 #define OV5_MSI                 0x01    /* PCIe/MSI support */
 694 #else
 695 #define OV5_MSI                 0x00
 696 #endif /* CONFIG_PCI_MSI */
 697 #ifdef CONFIG_PPC_SMLPAR
 698 #define OV5_CMO                 0x80    /* Cooperative Memory Overcommitment */
 699 #define OV5_XCMO                        0x40    /* Page Coalescing */
 700 #else
 701 #define OV5_CMO                 0x00
 702 #define OV5_XCMO                        0x00
 703 #endif
 704 #define OV5_TYPE1_AFFINITY      0x80    /* Type 1 NUMA affinity */
 705
 706 /* Option Vector 6: IBM PAPR hints */
 707 #define OV6_LINUX               0x02    /* Linux is our OS */
 708
 709 /*
 710  * The architecture vector has an array of PVR mask/value pairs,
 711  * followed by # option vectors - 1, followed by the option vectors.
 712  */
 713 static unsigned char ibm_architecture_vec[] = {
 714         W(0xfffe0000), W(0x003a0000),   /* POWER5/POWER5+ */
 715         W(0xffff0000), W(0x003e0000),   /* POWER6 */
 716         W(0xffff0000), W(0x003f0000),   /* POWER7 */
 717         W(0xffffffff), W(0x0f000003),   /* all 2.06-compliant */
 718         W(0xffffffff), W(0x0f000002),   /* all 2.05-compliant */
 719         W(0xfffffffe), W(0x0f000001),   /* all 2.04-compliant and earlier */
 720         6 - 1,                          /* 6 option vectors */
 721
 722         /* option vector 1: processor architectures supported */
 723         3 - 2,                          /* length */
 724         0,                              /* don't ignore, don't halt */
 725         OV1_PPC_2_00 | OV1_PPC_2_01 | OV1_PPC_2_02 | OV1_PPC_2_03 |
 726         OV1_PPC_2_04 | OV1_PPC_2_05 | OV1_PPC_2_06,
 727
 728         /* option vector 2: Open Firmware options supported */
 729         34 - 2,                         /* length */
 730         OV2_REAL_MODE,
 731         0, 0,
 732         W(0xffffffff),                  /* real_base */
 733         W(0xffffffff),                  /* real_size */
 734         W(0xffffffff),                  /* virt_base */
 735         W(0xffffffff),                  /* virt_size */
 736         W(0xffffffff),                  /* load_base */
 737         W(256),                         /* 256MB min RMA */
 738         W(0xffffffff),                  /* full client load */
 739         0,                              /* min RMA percentage of total RAM */
 740         48,                             /* max log_2(hash table size) */
 741
 742         /* option vector 3: processor options supported */
 743         3 - 2,                          /* length */
 744         0,                              /* don't ignore, don't halt */
 745         OV3_FP | OV3_VMX | OV3_DFP,
 746
 747         /* option vector 4: IBM PAPR implementation */
 748         2 - 2,                          /* length */
 749         0,                              /* don't halt */
 750
 751         /* option vector 5: PAPR/OF options */
 752         13 - 2,                         /* length */
 753         0,                              /* don't ignore, don't halt */
 754         OV5_LPAR | OV5_SPLPAR | OV5_LARGE_PAGES | OV5_DRCONF_MEMORY |
 755         OV5_DONATE_DEDICATE_CPU | OV5_MSI,
 756         0,
 757         OV5_CMO | OV5_XCMO,
 758         OV5_TYPE1_AFFINITY,
 759         0,
 760         0,
 761         0,
 762         /* WARNING: The offset of the "number of cores" field below
 763          * must match by the macro below. Update the definition if
 764          * the structure layout changes.
 765          */
 766 #define IBM_ARCH_VEC_NRCORES_OFFSET     100
 767         W(NR_CPUS),                     /* number of cores supported */
 768
 769         /* option vector 6: IBM PAPR hints */
 770         4 - 2,                          /* length */
 771         0,
 772         0,
 773         OV6_LINUX,
 774
 775 };
 776
 777 /* Old method - ELF header with PT_NOTE sections */
 778 static struct fake_elf {
 779         Elf32_Ehdr      elfhdr;
 780         Elf32_Phdr      phdr[2];
 781         struct chrpnote {
 782                 u32     namesz;
 783                 u32     descsz;
 784                 u32     type;
 785                 char    name[8];        /* "PowerPC" */
 786                 struct chrpdesc {
 787                         u32     real_mode;
 788                         u32     real_base;
 789                         u32     real_size;
 790                         u32     virt_base;
 791                         u32     virt_size;
 792                         u32     load_base;
 793                 } chrpdesc;
 794         } chrpnote;
 795         struct rpanote {
 796                 u32     namesz;
 797                 u32     descsz;
 798                 u32     type;
 799                 char    name[24];       /* "IBM,RPA-Client-Config" */
 800                 struct rpadesc {
 801                         u32     lpar_affinity;
 802                         u32     min_rmo_size;
 803                         u32     min_rmo_percent;
 804                         u32     max_pft_size;
 805                         u32     splpar;
 806                         u32     min_load;
 807                         u32     new_mem_def;
 808                         u32     ignore_me;
 809                 } rpadesc;
 810         } rpanote;
 811 } fake_elf = {
 812         .elfhdr = {
 813                 .e_ident = { 0x7f, 'E', 'L', 'F',
 814                              ELFCLASS32, ELFDATA2MSB, EV_CURRENT },
 815                 .e_type = ET_EXEC,      /* yeah right */
 816                 .e_machine = EM_PPC,
 817                 .e_version = EV_CURRENT,
 818                 .e_phoff = offsetof(struct fake_elf, phdr),
 819                 .e_phentsize = sizeof(Elf32_Phdr),
 820                 .e_phnum = 2
 821         },
 822         .phdr = {
 823                 [0] = {
 824                         .p_type = PT_NOTE,
 825                         .p_offset = offsetof(struct fake_elf, chrpnote),
 826                         .p_filesz = sizeof(struct chrpnote)
 827                 }, [1] = {
 828                         .p_type = PT_NOTE,
 829                         .p_offset = offsetof(struct fake_elf, rpanote),
 830                         .p_filesz = sizeof(struct rpanote)
 831                 }
 832         },
 833         .chrpnote = {
 834                 .namesz = sizeof("PowerPC"),
 835                 .descsz = sizeof(struct chrpdesc),
 836                 .type = 0x1275,
 837                 .name = "PowerPC",
 838                 .chrpdesc = {
 839                         .real_mode = ~0U,       /* ~0 means "don't care" */
 840                         .real_base = ~0U,
 841                         .real_size = ~0U,
 842                         .virt_base = ~0U,
 843                         .virt_size = ~0U,
 844                         .load_base = ~0U
 845                 },
 846         },
 847         .rpanote = {
 848                 .namesz = sizeof("IBM,RPA-Client-Config"),
 849                 .descsz = sizeof(struct rpadesc),
 850                 .type = 0x12759999,
 851                 .name = "IBM,RPA-Client-Config",
 852                 .rpadesc = {
 853                         .lpar_affinity = 0,
 854                         .min_rmo_size = 64,     /* in megabytes */
 855                         .min_rmo_percent = 0,
 856                         .max_pft_size = 48,     /* 2^48 bytes max PFT size */
 857                         .splpar = 1,
 858                         .min_load = ~0U,
 859                         .new_mem_def = 0
 860                 }
 861         }
 862 };
 863
 864 static int __init prom_count_smt_threads(void)
 865 {
 866         phandle node;
 867         char type[64];
 868         unsigned int plen;
 869
 870         /* Pick up th first CPU node we can find */
 871         for (node = 0; prom_next_node(&node); ) {
 872                 type[0] = 0;
 873                 prom_getprop(node, "device_type", type, sizeof(type));
 874
 875                 if (strcmp(type, RELOC("cpu")))
 876                         continue;
 877                 /*
 878                  * There is an entry for each smt thread, each entry being
 879                  * 4 bytes long.  All cpus should have the same number of
 880                  * smt threads, so return after finding the first.
 881                  */
 882                 plen = prom_getproplen(node, "ibm,ppc-interrupt-server#s");
 883                 if (plen == PROM_ERROR)
 884                         break;
 885                 plen >>= 2;
 886                 prom_debug("Found %lu smt threads per core\n", (unsigned long)plen);
 887
 888                 /* Sanity check */
 889                 if (plen < 1 || plen > 64) {
 890                         prom_printf("Threads per core %lu out of bounds, assuming 1\n",
 891                                     (unsigned long)plen);
 892                         return 1;
 893                 }
 894                 return plen;
 895         }
 896         prom_debug("No threads found, assuming 1 per core\n");
 897
 898         return 1;
 899
 900 }
 901
 902
 903 static void __init prom_send_capabilities(void)
 904 {
 905         ihandle elfloader, root;
 906         prom_arg_t ret;
 907         u32 *cores;
 908
 909         root = call_prom("open", 1, 1, ADDR("/"));
 910         if (root != 0) {
 911                 /* We need to tell the FW about the number of cores we support.
 912                  *
 913                  * To do that, we count the number of threads on the first core
 914                  * (we assume this is the same for all cores) and use it to
 915                  * divide NR_CPUS.
 916                  */
 917                 cores = (u32 *)PTRRELOC(&ibm_architecture_vec[IBM_ARCH_VEC_NRCORES_OFFSET]);
 918                 if (*cores != NR_CPUS) {
 919                         prom_printf("WARNING ! "
 920                                     "ibm_architecture_vec structure inconsistent: %lu!\n",
 921                                     *cores);
 922                 } else {
 923                         *cores = DIV_ROUND_UP(NR_CPUS, prom_count_smt_threads());
 924                         prom_printf("Max number of cores passed to firmware: %lu (NR_CPUS = %lu)\n",
 925                                     *cores, NR_CPUS);
 926                 }
 927
 928                 /* try calling the ibm,client-architecture-support method */
 929                 prom_printf("Calling ibm,client-architecture-support...");
 930                 if (call_prom_ret("call-method", 3, 2, &ret,
 931                                   ADDR("ibm,client-architecture-support"),
 932                                   root,
 933                                   ADDR(ibm_architecture_vec)) == 0) {
 934                         /* the call exists... */
 935                         if (ret)
 936                                 prom_printf("\nWARNING: ibm,client-architecture"
 937                                             "-support call FAILED!\n");
 938                         call_prom("close", 1, 0, root);
 939                         prom_printf(" done\n");
 940                         return;
 941                 }
 942                 call_prom("close", 1, 0, root);
 943                 prom_printf(" not implemented\n");
 944         }
 945
 946         /* no ibm,client-architecture-support call, try the old way */
 947         elfloader = call_prom("open", 1, 1, ADDR("/packages/elf-loader"));
 948         if (elfloader == 0) {
 949                 prom_printf("couldn't open /packages/elf-loader\n");
 950                 return;
 951         }
 952         call_prom("call-method", 3, 1, ADDR("process-elf-header"),
 953                         elfloader, ADDR(&fake_elf));
 954         call_prom("close", 1, 0, elfloader);
 955 }
 956 #endif
 957
 958 /*
 959  * Memory allocation strategy... our layout is normally:
 960  *
 961  *  at 14Mb or more we have vmlinux, then a gap and initrd.  In some
 962  *  rare cases, initrd might end up being before the kernel though.
 963  *  We assume this won't override the final kernel at 0, we have no
 964  *  provision to handle that in this version, but it should hopefully
 965  *  never happen.
 966  *
 967  *  alloc_top is set to the top of RMO, eventually shrink down if the
 968  *  TCEs overlap
 969  *
 970  *  alloc_bottom is set to the top of kernel/initrd
 971  *
 972  *  from there, allocations are done this way : rtas is allocated
 973  *  topmost, and the device-tree is allocated from the bottom. We try
 974  *  to grow the device-tree allocation as we progress. If we can't,
 975  *  then we fail, we don't currently have a facility to restart
 976  *  elsewhere, but that shouldn't be necessary.
 977  *
 978  *  Note that calls to reserve_mem have to be done explicitly, memory
 979  *  allocated with either alloc_up or alloc_down isn't automatically
 980  *  reserved.
 981  */
 982
 983
 984 /*
 985  * Allocates memory in the RMO upward from the kernel/initrd
 986  *
 987  * When align is 0, this is a special case, it means to allocate in place
 988  * at the current location of alloc_bottom or fail (that is basically
 989  * extending the previous allocation). Used for the device-tree flattening
 990  */
 991 static unsigned long __init alloc_up(unsigned long size, unsigned long align)
 992 {
 993         unsigned long base = RELOC(alloc_bottom);
 994         unsigned long addr = 0;
 995
 996         if (align)
 997                 base = _ALIGN_UP(base, align);
 998         prom_debug("alloc_up(%x, %x)\n", size, align);
 999         if (RELOC(ram_top) == 0)
1000                 prom_panic("alloc_up() called with mem not initialized\n");
1001
1002         if (align)
1003                 base = _ALIGN_UP(RELOC(alloc_bottom), align);
1004         else
1005                 base = RELOC(alloc_bottom);
1006
1007         for(; (base + size) <= RELOC(alloc_top);
1008             base = _ALIGN_UP(base + 0x100000, align)) {
1009                 prom_debug("    trying: 0x%x\n\r", base);
1010                 addr = (unsigned long)prom_claim(base, size, 0);
1011                 if (addr != PROM_ERROR && addr != 0)
1012                         break;
1013                 addr = 0;
1014                 if (align == 0)
1015                         break;
1016         }
1017         if (addr == 0)
1018                 return 0;
1019         RELOC(alloc_bottom) = addr + size;
1020
1021         prom_debug(" -> %x\n", addr);
1022         prom_debug("  alloc_bottom : %x\n", RELOC(alloc_bottom));
1023         prom_debug("  alloc_top    : %x\n", RELOC(alloc_top));
1024         prom_debug("  alloc_top_hi : %x\n", RELOC(alloc_top_high));
1025         prom_debug("  rmo_top      : %x\n", RELOC(rmo_top));
1026         prom_debug("  ram_top      : %x\n", RELOC(ram_top));
1027
1028         return addr;
1029 }
1030
1031 /*
1032  * Allocates memory downward, either from top of RMO, or if highmem
1033  * is set, from the top of RAM.  Note that this one doesn't handle
1034  * failures.  It does claim memory if highmem is not set.
1035  */
1036 static unsigned long __init alloc_down(unsigned long size, unsigned long align,
1037                                        int highmem)
1038 {
1039         unsigned long base, addr = 0;
1040
1041         prom_debug("alloc_down(%x, %x, %s)\n", size, align,
1042                    highmem ? RELOC("(high)") : RELOC("(low)"));
1043         if (RELOC(ram_top) == 0)
1044                 prom_panic("alloc_down() called with mem not initialized\n");
1045
1046         if (highmem) {
1047                 /* Carve out storage for the TCE table. */
1048                 addr = _ALIGN_DOWN(RELOC(alloc_top_high) - size, align);
1049                 if (addr <= RELOC(alloc_bottom))
1050                         return 0;
1051                 /* Will we bump into the RMO ? If yes, check out that we
1052                  * didn't overlap existing allocations there, if we did,
1053                  * we are dead, we must be the first in town !
1054                  */
1055                 if (addr < RELOC(rmo_top)) {
1056                         /* Good, we are first */
1057                         if (RELOC(alloc_top) == RELOC(rmo_top))
1058                                 RELOC(alloc_top) = RELOC(rmo_top) = addr;
1059                         else
1060                                 return 0;
1061                 }
1062                 RELOC(alloc_top_high) = addr;
1063                 goto bail;
1064         }
1065
1066         base = _ALIGN_DOWN(RELOC(alloc_top) - size, align);
1067         for (; base > RELOC(alloc_bottom);
1068              base = _ALIGN_DOWN(base - 0x100000, align))  {
1069                 prom_debug("    trying: 0x%x\n\r", base);
1070                 addr = (unsigned long)prom_claim(base, size, 0);
1071                 if (addr != PROM_ERROR && addr != 0)
1072                         break;
1073                 addr = 0;
1074         }
1075         if (addr == 0)
1076                 return 0;
1077         RELOC(alloc_top) = addr;
1078
1079  bail:
1080         prom_debug(" -> %x\n", addr);
1081         prom_debug("  alloc_bottom : %x\n", RELOC(alloc_bottom));
1082         prom_debug("  alloc_top    : %x\n", RELOC(alloc_top));
1083         prom_debug("  alloc_top_hi : %x\n", RELOC(alloc_top_high));
1084         prom_debug("  rmo_top      : %x\n", RELOC(rmo_top));
1085         prom_debug("  ram_top      : %x\n", RELOC(ram_top));
1086
1087         return addr;
1088 }
1089
1090 /*
1091  * Parse a "reg" cell
1092  */
1093 static unsigned long __init prom_next_cell(int s, cell_t **cellp)
1094 {
1095         cell_t *p = *cellp;
1096         unsigned long r = 0;
1097
1098         /* Ignore more than 2 cells */
1099         while (s > sizeof(unsigned long) / 4) {
1100                 p++;
1101                 s--;
1102         }
1103         r = *p++;
1104 #ifdef CONFIG_PPC64
1105         if (s > 1) {
1106                 r <<= 32;
1107                 r |= *(p++);
1108         }
1109 #endif
1110         *cellp = p;
1111         return r;
1112 }
1113
1114 /*
1115  * Very dumb function for adding to the memory reserve list, but
1116  * we don't need anything smarter at this point
1117  *
1118  * XXX Eventually check for collisions.  They should NEVER happen.
1119  * If problems seem to show up, it would be a good start to track
1120  * them down.
1121  */
1122 static void __init reserve_mem(u64 base, u64 size)
1123 {
1124         u64 top = base + size;
1125         unsigned long cnt = RELOC(mem_reserve_cnt);
1126
1127         if (size == 0)
1128                 return;
1129
1130         /* We need to always keep one empty entry so that we
1131          * have our terminator with "size" set to 0 since we are
1132          * dumb and just copy this entire array to the boot params
1133          */
1134         base = _ALIGN_DOWN(base, PAGE_SIZE);
1135         top = _ALIGN_UP(top, PAGE_SIZE);
1136         size = top - base;
1137
1138         if (cnt >= (MEM_RESERVE_MAP_SIZE - 1))
1139                 prom_panic("Memory reserve map exhausted !\n");
1140         RELOC(mem_reserve_map)[cnt].base = base;
1141         RELOC(mem_reserve_map)[cnt].size = size;
1142         RELOC(mem_reserve_cnt) = cnt + 1;
1143 }
1144
1145 /*
1146  * Initialize memory allocation mechanism, parse "memory" nodes and
1147  * obtain that way the top of memory and RMO to setup out local allocator
1148  */
1149 static void __init prom_init_mem(void)
1150 {
1151         phandle node;
1152         char *path, type[64];
1153         unsigned int plen;
1154         cell_t *p, *endp;
1155         struct prom_t *_prom = &RELOC(prom);
1156         u32 rac, rsc;
1157
1158         /*
1159          * We iterate the memory nodes to find
1160          * 1) top of RMO (first node)
1161          * 2) top of memory
1162          */
1163         rac = 2;
1164         prom_getprop(_prom->root, "#address-cells", &rac, sizeof(rac));
1165         rsc = 1;
1166         prom_getprop(_prom->root, "#size-cells", &rsc, sizeof(rsc));
1167         prom_debug("root_addr_cells: %x\n", (unsigned long) rac);
1168         prom_debug("root_size_cells: %x\n", (unsigned long) rsc);
1169
1170         prom_debug("scanning memory:\n");
1171         path = RELOC(prom_scratch);
1172
1173         for (node = 0; prom_next_node(&node); ) {
1174                 type[0] = 0;
1175                 prom_getprop(node, "device_type", type, sizeof(type));
1176
1177                 if (type[0] == 0) {
1178                         /*
1179                          * CHRP Longtrail machines have no device_type
1180                          * on the memory node, so check the name instead...
1181                          */
1182                         prom_getprop(node, "name", type, sizeof(type));
1183                 }
1184                 if (strcmp(type, RELOC("memory")))
1185                         continue;
1186
1187                 plen = prom_getprop(node, "reg", RELOC(regbuf), sizeof(regbuf));
1188                 if (plen > sizeof(regbuf)) {
1189                         prom_printf("memory node too large for buffer !\n");
1190                         plen = sizeof(regbuf);
1191                 }
1192                 p = RELOC(regbuf);
1193                 endp = p + (plen / sizeof(cell_t));
1194
1195 #ifdef DEBUG_PROM
1196                 memset(path, 0, PROM_SCRATCH_SIZE);
1197                 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
1198                 prom_debug("  node %s :\n", path);
1199 #endif /* DEBUG_PROM */
1200
1201                 while ((endp - p) >= (rac + rsc)) {
1202                         unsigned long base, size;
1203
1204                         base = prom_next_cell(rac, &p);
1205                         size = prom_next_cell(rsc, &p);
1206
1207                         if (size == 0)
1208                                 continue;
1209                         prom_debug("    %x %x\n", base, size);
1210                         if (base == 0 && (RELOC(of_platform) & PLATFORM_LPAR))
1211                                 RELOC(rmo_top) = size;
1212                         if ((base + size) > RELOC(ram_top))
1213                                 RELOC(ram_top) = base + size;
1214                 }
1215         }
1216
1217         RELOC(alloc_bottom) = PAGE_ALIGN((unsigned long)&RELOC(_end) + 0x4000);
1218
1219         /*
1220          * If prom_memory_limit is set we reduce the upper limits *except* for
1221          * alloc_top_high. This must be the real top of RAM so we can put
1222          * TCE's up there.
1223          */
1224
1225         RELOC(alloc_top_high) = RELOC(ram_top);
1226
1227         if (RELOC(prom_memory_limit)) {
1228                 if (RELOC(prom_memory_limit) <= RELOC(alloc_bottom)) {
1229                         prom_printf("Ignoring mem=%x <= alloc_bottom.\n",
1230                                 RELOC(prom_memory_limit));
1231                         RELOC(prom_memory_limit) = 0;
1232                 } else if (RELOC(prom_memory_limit) >= RELOC(ram_top)) {
1233                         prom_printf("Ignoring mem=%x >= ram_top.\n",
1234                                 RELOC(prom_memory_limit));
1235                         RELOC(prom_memory_limit) = 0;
1236                 } else {
1237                         RELOC(ram_top) = RELOC(prom_memory_limit);
1238                         RELOC(rmo_top) = min(RELOC(rmo_top), RELOC(prom_memory_limit));
1239                 }
1240         }
1241
1242         /*
1243          * Setup our top alloc point, that is top of RMO or top of
1244          * segment 0 when running non-LPAR.
1245          * Some RS64 machines have buggy firmware where claims up at
1246          * 1GB fail.  Cap at 768MB as a workaround.
1247          * Since 768MB is plenty of room, and we need to cap to something
1248          * reasonable on 32-bit, cap at 768MB on all machines.
1249          */
1250         if (!RELOC(rmo_top))
1251                 RELOC(rmo_top) = RELOC(ram_top);
1252         RELOC(rmo_top) = min(0x30000000ul, RELOC(rmo_top));
1253         RELOC(alloc_top) = RELOC(rmo_top);
1254         RELOC(alloc_top_high) = RELOC(ram_top);
1255
1256         /*
1257          * Check if we have an initrd after the kernel but still inside
1258          * the RMO.  If we do move our bottom point to after it.
1259          */
1260         if (RELOC(prom_initrd_start) &&
1261             RELOC(prom_initrd_start) < RELOC(rmo_top) &&
1262             RELOC(prom_initrd_end) > RELOC(alloc_bottom))
1263                 RELOC(alloc_bottom) = PAGE_ALIGN(RELOC(prom_initrd_end));
1264
1265         prom_printf("memory layout at init:\n");
1266         prom_printf("  memory_limit : %x (16 MB aligned)\n", RELOC(prom_memory_limit));
1267         prom_printf("  alloc_bottom : %x\n", RELOC(alloc_bottom));
1268         prom_printf("  alloc_top    : %x\n", RELOC(alloc_top));
1269         prom_printf("  alloc_top_hi : %x\n", RELOC(alloc_top_high));
1270         prom_printf("  rmo_top      : %x\n", RELOC(rmo_top));
1271         prom_printf("  ram_top      : %x\n", RELOC(ram_top));
1272 }
1273
1274 static void __init prom_close_stdin(void)
1275 {
1276         struct prom_t *_prom = &RELOC(prom);
1277         ihandle val;
1278
1279         if (prom_getprop(_prom->chosen, "stdin", &val, sizeof(val)) > 0)
1280                 call_prom("close", 1, 0, val);
1281 }
1282
1283 #ifdef CONFIG_PPC_POWERNV
1284
1285 static u64 __initdata prom_opal_size;
1286 static u64 __initdata prom_opal_align;
1287 static int __initdata prom_rtas_start_cpu;
1288 static u64 __initdata prom_rtas_data;
1289 static u64 __initdata prom_rtas_entry;
1290
1291 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
1292 static u64 __initdata prom_opal_base;
1293 static u64 __initdata prom_opal_entry;
1294 #endif
1295
1296 /* XXX Don't change this structure without updating opal-takeover.S */
1297 static struct opal_secondary_data {
1298         s64                             ack;    /*  0 */
1299         u64                             go;     /*  8 */
1300         struct opal_takeover_args       args;   /* 16 */
1301 } opal_secondary_data;
1302
1303 extern char opal_secondary_entry;
1304
1305 static void prom_query_opal(void)
1306 {
1307         long rc;
1308
1309         /* We must not query for OPAL presence on a machine that
1310          * supports TNK takeover (970 blades), as this uses the same
1311          * h-call with different arguments and will crash
1312          */
1313         if (PHANDLE_VALID(call_prom("finddevice", 1, 1,
1314                                     ADDR("/tnk-memory-map")))) {
1315                 prom_printf("TNK takeover detected, skipping OPAL check\n");
1316                 return;
1317         }
1318
1319         prom_printf("Querying for OPAL presence... ");
1320         rc = opal_query_takeover(&RELOC(prom_opal_size),
1321                                  &RELOC(prom_opal_align));
1322         prom_debug("(rc = %ld) ", rc);
1323         if (rc != 0) {
1324                 prom_printf("not there.\n");
1325                 return;
1326         }
1327         RELOC(of_platform) = PLATFORM_OPAL;
1328         prom_printf(" there !\n");
1329         prom_debug("  opal_size  = 0x%lx\n", RELOC(prom_opal_size));
1330         prom_debug("  opal_align = 0x%lx\n", RELOC(prom_opal_align));
1331         if (RELOC(prom_opal_align) < 0x10000)
1332                 RELOC(prom_opal_align) = 0x10000;
1333 }
1334
1335 static int prom_rtas_call(int token, int nargs, int nret, int *outputs, ...)
1336 {
1337         struct rtas_args rtas_args;
1338         va_list list;
1339         int i;
1340
1341         rtas_args.token = token;
1342         rtas_args.nargs = nargs;
1343         rtas_args.nret  = nret;
1344         rtas_args.rets  = (rtas_arg_t *)&(rtas_args.args[nargs]);
1345         va_start(list, outputs);
1346         for (i = 0; i < nargs; ++i)
1347                 rtas_args.args[i] = va_arg(list, rtas_arg_t);
1348         va_end(list);
1349
1350         for (i = 0; i < nret; ++i)
1351                 rtas_args.rets[i] = 0;
1352
1353         opal_enter_rtas(&rtas_args, RELOC(prom_rtas_data),
1354                         RELOC(prom_rtas_entry));
1355
1356         if (nret > 1 && outputs != NULL)
1357                 for (i = 0; i < nret-1; ++i)
1358                         outputs[i] = rtas_args.rets[i+1];
1359         return (nret > 0)? rtas_args.rets[0]: 0;
1360 }
1361
1362 static void __init prom_opal_hold_cpus(void)
1363 {
1364         int i, cnt, cpu, rc;
1365         long j;
1366         phandle node;
1367         char type[64];
1368         u32 servers[8];
1369         struct prom_t *_prom = &RELOC(prom);
1370         void *entry = (unsigned long *)&RELOC(opal_secondary_entry);
1371         struct opal_secondary_data *data = &RELOC(opal_secondary_data);
1372
1373         prom_debug("prom_opal_hold_cpus: start...\n");
1374         prom_debug("    - entry       = 0x%x\n", entry);
1375         prom_debug("    - data        = 0x%x\n", data);
1376
1377         data->ack = -1;
1378         data->go = 0;
1379
1380         /* look for cpus */
1381         for (node = 0; prom_next_node(&node); ) {
1382                 type[0] = 0;
1383                 prom_getprop(node, "device_type", type, sizeof(type));
1384                 if (strcmp(type, RELOC("cpu")) != 0)
1385                         continue;
1386
1387                 /* Skip non-configured cpus. */
1388                 if (prom_getprop(node, "status", type, sizeof(type)) > 0)
1389                         if (strcmp(type, RELOC("okay")) != 0)
1390                                 continue;
1391
1392                 cnt = prom_getprop(node, "ibm,ppc-interrupt-server#s", servers,
1393                              sizeof(servers));
1394                 if (cnt == PROM_ERROR)
1395                         break;
1396                 cnt >>= 2;
1397                 for (i = 0; i < cnt; i++) {
1398                         cpu = servers[i];
1399                         prom_debug("CPU %d ... ", cpu);
1400                         if (cpu == _prom->cpu) {
1401                                 prom_debug("booted !\n");
1402                                 continue;
1403                         }
1404                         prom_debug("starting ... ");
1405
1406                         /* Init the acknowledge var which will be reset by
1407                          * the secondary cpu when it awakens from its OF
1408                          * spinloop.
1409                          */
1410                         data->ack = -1;
1411                         rc = prom_rtas_call(RELOC(prom_rtas_start_cpu), 3, 1,
1412                                             NULL, cpu, entry, data);
1413                         prom_debug("rtas rc=%d ...", rc);
1414
1415                         for (j = 0; j < 100000000 && data->ack == -1; j++) {
1416                                 HMT_low();
1417                                 mb();
1418                         }
1419                         HMT_medium();
1420                         if (data->ack != -1)
1421                                 prom_debug("done, PIR=0x%x\n", data->ack);
1422                         else
1423                                 prom_debug("timeout !\n");
1424                 }
1425         }
1426         prom_debug("prom_opal_hold_cpus: end...\n");
1427 }
1428
1429 static void prom_opal_takeover(void)
1430 {
1431         struct opal_secondary_data *data = &RELOC(opal_secondary_data);
1432         struct opal_takeover_args *args = &data->args;
1433         u64 align = RELOC(prom_opal_align);
1434         u64 top_addr, opal_addr;
1435
1436         args->k_image   = (u64)RELOC(_stext);
1437         args->k_size    = _end - _stext;
1438         args->k_entry   = 0;
1439         args->k_entry2  = 0x60;
1440
1441         top_addr = _ALIGN_UP(args->k_size, align);
1442
1443         if (RELOC(prom_initrd_start) != 0) {
1444                 args->rd_image = RELOC(prom_initrd_start);
1445                 args->rd_size = RELOC(prom_initrd_end) - args->rd_image;
1446                 args->rd_loc = top_addr;
1447                 top_addr = _ALIGN_UP(args->rd_loc + args->rd_size, align);
1448         }
1449
1450         /* Pickup an address for the HAL. We want to go really high
1451          * up to avoid problem with future kexecs. On the other hand
1452          * we don't want to be all over the TCEs on P5IOC2 machines
1453          * which are going to be up there too. We assume the machine
1454          * has plenty of memory, and we ask for the HAL for now to
1455          * be just below the 1G point, or above the initrd
1456          */
1457         opal_addr = _ALIGN_DOWN(0x40000000 - RELOC(prom_opal_size), align);
1458         if (opal_addr < top_addr)
1459                 opal_addr = top_addr;
1460         args->hal_addr = opal_addr;
1461
1462         /* Copy the command line to the kernel image */
1463         strlcpy(RELOC(boot_command_line), RELOC(prom_cmd_line),
1464                 COMMAND_LINE_SIZE);
1465
1466         prom_debug("  k_image    = 0x%lx\n", args->k_image);
1467         prom_debug("  k_size     = 0x%lx\n", args->k_size);
1468         prom_debug("  k_entry    = 0x%lx\n", args->k_entry);
1469         prom_debug("  k_entry2   = 0x%lx\n", args->k_entry2);
1470         prom_debug("  hal_addr   = 0x%lx\n", args->hal_addr);
1471         prom_debug("  rd_image   = 0x%lx\n", args->rd_image);
1472         prom_debug("  rd_size    = 0x%lx\n", args->rd_size);
1473         prom_debug("  rd_loc     = 0x%lx\n", args->rd_loc);
1474         prom_printf("Performing OPAL takeover,this can take a few minutes..\n");
1475         prom_close_stdin();
1476         mb();
1477         data->go = 1;
1478         for (;;)
1479                 opal_do_takeover(args);
1480 }
1481
1482 /*
1483  * Allocate room for and instantiate OPAL
1484  */
1485 static void __init prom_instantiate_opal(void)
1486 {
1487         phandle opal_node;
1488         ihandle opal_inst;
1489         u64 base, entry;
1490         u64 size = 0, align = 0x10000;
1491         u32 rets[2];
1492
1493         prom_debug("prom_instantiate_opal: start...\n");
1494
1495         opal_node = call_prom("finddevice", 1, 1, ADDR("/ibm,opal"));
1496         prom_debug("opal_node: %x\n", opal_node);
1497         if (!PHANDLE_VALID(opal_node))
1498                 return;
1499
1500         prom_getprop(opal_node, "opal-runtime-size", &size, sizeof(size));
1501         if (size == 0)
1502                 return;
1503         prom_getprop(opal_node, "opal-runtime-alignment", &align,
1504                      sizeof(align));
1505
1506         base = alloc_down(size, align, 0);
1507         if (base == 0) {
1508                 prom_printf("OPAL allocation failed !\n");
1509                 return;
1510         }
1511
1512         opal_inst = call_prom("open", 1, 1, ADDR("/ibm,opal"));
1513         if (!IHANDLE_VALID(opal_inst)) {
1514                 prom_printf("opening opal package failed (%x)\n", opal_inst);
1515                 return;
1516         }
1517
1518         prom_printf("instantiating opal at 0x%x...", base);
1519
1520         if (call_prom_ret("call-method", 4, 3, rets,
1521                           ADDR("load-opal-runtime"),
1522                           opal_inst,
1523                           base >> 32, base & 0xffffffff) != 0
1524             || (rets[0] == 0 && rets[1] == 0)) {
1525                 prom_printf(" failed\n");
1526                 return;
1527         }
1528         entry = (((u64)rets[0]) << 32) | rets[1];
1529
1530         prom_printf(" done\n");
1531
1532         reserve_mem(base, size);
1533
1534         prom_debug("opal base     = 0x%x\n", base);
1535         prom_debug("opal align    = 0x%x\n", align);
1536         prom_debug("opal entry    = 0x%x\n", entry);
1537         prom_debug("opal size     = 0x%x\n", (long)size);
1538
1539         prom_setprop(opal_node, "/ibm,opal", "opal-base-address",
1540                      &base, sizeof(base));
1541         prom_setprop(opal_node, "/ibm,opal", "opal-entry-address",
1542                      &entry, sizeof(entry));
1543
1544 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
1545         RELOC(prom_opal_base) = base;
1546         RELOC(prom_opal_entry) = entry;
1547 #endif
1548         prom_debug("prom_instantiate_opal: end...\n");
1549 }
1550
1551 #endif /* CONFIG_PPC_POWERNV */
1552
1553 /*
1554  * Allocate room for and instantiate RTAS
1555  */
1556 static void __init prom_instantiate_rtas(void)
1557 {
1558         phandle rtas_node;
1559         ihandle rtas_inst;
1560         u32 base, entry = 0;
1561         u32 size = 0;
1562
1563         prom_debug("prom_instantiate_rtas: start...\n");
1564
1565         rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1566         prom_debug("rtas_node: %x\n", rtas_node);
1567         if (!PHANDLE_VALID(rtas_node))
1568                 return;
1569
1570         prom_getprop(rtas_node, "rtas-size", &size, sizeof(size));
1571         if (size == 0)
1572                 return;
1573
1574         base = alloc_down(size, PAGE_SIZE, 0);
1575         if (base == 0)
1576                 prom_panic("Could not allocate memory for RTAS\n");
1577
1578         rtas_inst = call_prom("open", 1, 1, ADDR("/rtas"));
1579         if (!IHANDLE_VALID(rtas_inst)) {
1580                 prom_printf("opening rtas package failed (%x)\n", rtas_inst);
1581                 return;
1582         }
1583
1584         prom_printf("instantiating rtas at 0x%x...", base);
1585
1586         if (call_prom_ret("call-method", 3, 2, &entry,
1587                           ADDR("instantiate-rtas"),
1588                           rtas_inst, base) != 0
1589             || entry == 0) {
1590                 prom_printf(" failed\n");
1591                 return;
1592         }
1593         prom_printf(" done\n");
1594
1595         reserve_mem(base, size);
1596
1597         prom_setprop(rtas_node, "/rtas", "linux,rtas-base",
1598                      &base, sizeof(base));
1599         prom_setprop(rtas_node, "/rtas", "linux,rtas-entry",
1600                      &entry, sizeof(entry));
1601
1602 #ifdef CONFIG_PPC_POWERNV
1603         /* PowerVN takeover hack */
1604         RELOC(prom_rtas_data) = base;
1605         RELOC(prom_rtas_entry) = entry;
1606         prom_getprop(rtas_node, "start-cpu", &RELOC(prom_rtas_start_cpu), 4);
1607 #endif
1608         prom_debug("rtas base     = 0x%x\n", base);
1609         prom_debug("rtas entry    = 0x%x\n", entry);
1610         prom_debug("rtas size     = 0x%x\n", (long)size);
1611
1612         prom_debug("prom_instantiate_rtas: end...\n");
1613 }
1614
1615 #ifdef CONFIG_PPC64
1616 /*
1617  * Allocate room for and initialize TCE tables
1618  */
1619 static void __init prom_initialize_tce_table(void)
1620 {
1621         phandle node;
1622         ihandle phb_node;
1623         char compatible[64], type[64], model[64];
1624         char *path = RELOC(prom_scratch);
1625         u64 base, align;
1626         u32 minalign, minsize;
1627         u64 tce_entry, *tce_entryp;
1628         u64 local_alloc_top, local_alloc_bottom;
1629         u64 i;
1630
1631         if (RELOC(prom_iommu_off))
1632                 return;
1633
1634         prom_debug("starting prom_initialize_tce_table\n");
1635
1636         /* Cache current top of allocs so we reserve a single block */
1637         local_alloc_top = RELOC(alloc_top_high);
1638         local_alloc_bottom = local_alloc_top;
1639
1640         /* Search all nodes looking for PHBs. */
1641         for (node = 0; prom_next_node(&node); ) {
1642                 compatible[0] = 0;
1643                 type[0] = 0;
1644                 model[0] = 0;
1645                 prom_getprop(node, "compatible",
1646                              compatible, sizeof(compatible));
1647                 prom_getprop(node, "device_type", type, sizeof(type));
1648                 prom_getprop(node, "model", model, sizeof(model));
1649
1650                 if ((type[0] == 0) || (strstr(type, RELOC("pci")) == NULL))
1651                         continue;
1652
1653                 /* Keep the old logic intact to avoid regression. */
1654                 if (compatible[0] != 0) {
1655                         if ((strstr(compatible, RELOC("python")) == NULL) &&
1656                             (strstr(compatible, RELOC("Speedwagon")) == NULL) &&
1657                             (strstr(compatible, RELOC("Winnipeg")) == NULL))
1658                                 continue;
1659                 } else if (model[0] != 0) {
1660                         if ((strstr(model, RELOC("ython")) == NULL) &&
1661                             (strstr(model, RELOC("peedwagon")) == NULL) &&
1662                             (strstr(model, RELOC("innipeg")) == NULL))
1663                                 continue;
1664                 }
1665
1666                 if (prom_getprop(node, "tce-table-minalign", &minalign,
1667                                  sizeof(minalign)) == PROM_ERROR)
1668                         minalign = 0;
1669                 if (prom_getprop(node, "tce-table-minsize", &minsize,
1670                                  sizeof(minsize)) == PROM_ERROR)
1671                         minsize = 4UL << 20;
1672
1673                 /*
1674                  * Even though we read what OF wants, we just set the table
1675                  * size to 4 MB.  This is enough to map 2GB of PCI DMA space.
1676                  * By doing this, we avoid the pitfalls of trying to DMA to
1677                  * MMIO space and the DMA alias hole.
1678                  *
1679                  * On POWER4, firmware sets the TCE region by assuming
1680                  * each TCE table is 8MB. Using this memory for anything
1681                  * else will impact performance, so we always allocate 8MB.
1682                  * Anton
1683                  */
1684                 if (__is_processor(PV_POWER4) || __is_processor(PV_POWER4p))
1685                         minsize = 8UL << 20;
1686                 else
1687                         minsize = 4UL << 20;
1688
1689                 /* Align to the greater of the align or size */
1690                 align = max(minalign, minsize);
1691                 base = alloc_down(minsize, align, 1);
1692                 if (base == 0)
1693                         prom_panic("ERROR, cannot find space for TCE table.\n");
1694                 if (base < local_alloc_bottom)
1695                         local_alloc_bottom = base;
1696
1697                 /* It seems OF doesn't null-terminate the path :-( */
1698                 memset(path, 0, PROM_SCRATCH_SIZE);
1699                 /* Call OF to setup the TCE hardware */
1700                 if (call_prom("package-to-path", 3, 1, node,
1701                               path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) {
1702                         prom_printf("package-to-path failed\n");
1703                 }
1704
1705                 /* Save away the TCE table attributes for later use. */
1706                 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base));
1707                 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize));
1708
1709                 prom_debug("TCE table: %s\n", path);
1710                 prom_debug("\tnode = 0x%x\n", node);
1711                 prom_debug("\tbase = 0x%x\n", base);
1712                 prom_debug("\tsize = 0x%x\n", minsize);
1713
1714                 /* Initialize the table to have a one-to-one mapping
1715                  * over the allocated size.
1716                  */
1717                 tce_entryp = (u64 *)base;
1718                 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) {
1719                         tce_entry = (i << PAGE_SHIFT);
1720                         tce_entry |= 0x3;
1721                         *tce_entryp = tce_entry;
1722                 }
1723
1724                 prom_printf("opening PHB %s", path);
1725                 phb_node = call_prom("open", 1, 1, path);
1726                 if (phb_node == 0)
1727                         prom_printf("... failed\n");
1728                 else
1729                         prom_printf("... done\n");
1730
1731                 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"),
1732                           phb_node, -1, minsize,
1733                           (u32) base, (u32) (base >> 32));
1734                 call_prom("close", 1, 0, phb_node);
1735         }
1736
1737         reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom);
1738
1739         /* These are only really needed if there is a memory limit in
1740          * effect, but we don't know so export them always. */
1741         RELOC(prom_tce_alloc_start) = local_alloc_bottom;
1742         RELOC(prom_tce_alloc_end) = local_alloc_top;
1743
1744         /* Flag the first invalid entry */
1745         prom_debug("ending prom_initialize_tce_table\n");
1746 }
1747 #endif
1748
1749 /*
1750  * With CHRP SMP we need to use the OF to start the other processors.
1751  * We can't wait until smp_boot_cpus (the OF is trashed by then)
1752  * so we have to put the processors into a holding pattern controlled
1753  * by the kernel (not OF) before we destroy the OF.
1754  *
1755  * This uses a chunk of low memory, puts some holding pattern
1756  * code there and sends the other processors off to there until
1757  * smp_boot_cpus tells them to do something.  The holding pattern
1758  * checks that address until its cpu # is there, when it is that
1759  * cpu jumps to __secondary_start().  smp_boot_cpus() takes care
1760  * of setting those values.
1761  *
1762  * We also use physical address 0x4 here to tell when a cpu
1763  * is in its holding pattern code.
1764  *
1765  * -- Cort
1766  */
1767 /*
1768  * We want to reference the copy of __secondary_hold_* in the
1769  * 0 - 0x100 address range
1770  */
1771 #define LOW_ADDR(x)     (((unsigned long) &(x)) & 0xff)
1772
1773 static void __init prom_hold_cpus(void)
1774 {
1775         unsigned long i;
1776         unsigned int reg;
1777         phandle node;
1778         char type[64];
1779         struct prom_t *_prom = &RELOC(prom);
1780         unsigned long *spinloop
1781                 = (void *) LOW_ADDR(__secondary_hold_spinloop);
1782         unsigned long *acknowledge
1783                 = (void *) LOW_ADDR(__secondary_hold_acknowledge);
1784         unsigned long secondary_hold = LOW_ADDR(__secondary_hold);
1785
1786         prom_debug("prom_hold_cpus: start...\n");
1787         prom_debug("    1) spinloop       = 0x%x\n", (unsigned long)spinloop);
1788         prom_debug("    1) *spinloop      = 0x%x\n", *spinloop);
1789         prom_debug("    1) acknowledge    = 0x%x\n",
1790                    (unsigned long)acknowledge);
1791         prom_debug("    1) *acknowledge   = 0x%x\n", *acknowledge);
1792         prom_debug("    1) secondary_hold = 0x%x\n", secondary_hold);
1793
1794         /* Set the common spinloop variable, so all of the secondary cpus
1795          * will block when they are awakened from their OF spinloop.
1796          * This must occur for both SMP and non SMP kernels, since OF will
1797          * be trashed when we move the kernel.
1798          */
1799         *spinloop = 0;
1800
1801         /* look for cpus */
1802         for (node = 0; prom_next_node(&node); ) {
1803                 type[0] = 0;
1804                 prom_getprop(node, "device_type", type, sizeof(type));
1805                 if (strcmp(type, RELOC("cpu")) != 0)
1806                         continue;
1807
1808                 /* Skip non-configured cpus. */
1809                 if (prom_getprop(node, "status", type, sizeof(type)) > 0)
1810                         if (strcmp(type, RELOC("okay")) != 0)
1811                                 continue;
1812
1813                 reg = -1;
1814                 prom_getprop(node, "reg", &reg, sizeof(reg));
1815
1816                 prom_debug("cpu hw idx   = %lu\n", reg);
1817
1818                 /* Init the acknowledge var which will be reset by
1819                  * the secondary cpu when it awakens from its OF
1820                  * spinloop.
1821                  */
1822                 *acknowledge = (unsigned long)-1;
1823
1824                 if (reg != _prom->cpu) {
1825                         /* Primary Thread of non-boot cpu or any thread */
1826                         prom_printf("starting cpu hw idx %lu... ", reg);
1827                         call_prom("start-cpu", 3, 0, node,
1828                                   secondary_hold, reg);
1829
1830                         for (i = 0; (i < 100000000) &&
1831                              (*acknowledge == ((unsigned long)-1)); i++ )
1832                                 mb();
1833
1834                         if (*acknowledge == reg)
1835                                 prom_printf("done\n");
1836                         else
1837                                 prom_printf("failed: %x\n", *acknowledge);
1838                 }
1839 #ifdef CONFIG_SMP
1840                 else
1841                         prom_printf("boot cpu hw idx %lu\n", reg);
1842 #endif /* CONFIG_SMP */
1843         }
1844
1845         prom_debug("prom_hold_cpus: end...\n");
1846 }
1847
1848
1849 static void __init prom_init_client_services(unsigned long pp)
1850 {
1851         struct prom_t *_prom = &RELOC(prom);
1852
1853         /* Get a handle to the prom entry point before anything else */
1854         RELOC(prom_entry) = pp;
1855
1856         /* get a handle for the stdout device */
1857         _prom->chosen = call_prom("finddevice", 1, 1, ADDR("/chosen"));
1858         if (!PHANDLE_VALID(_prom->chosen))
1859                 prom_panic("cannot find chosen"); /* msg won't be printed :( */
1860
1861         /* get device tree root */
1862         _prom->root = call_prom("finddevice", 1, 1, ADDR("/"));
1863         if (!PHANDLE_VALID(_prom->root))
1864                 prom_panic("cannot find device tree root"); /* msg won't be printed :( */
1865
1866         _prom->mmumap = 0;
1867 }
1868
1869 #ifdef CONFIG_PPC32
1870 /*
1871  * For really old powermacs, we need to map things we claim.
1872  * For that, we need the ihandle of the mmu.
1873  * Also, on the longtrail, we need to work around other bugs.
1874  */
1875 static void __init prom_find_mmu(void)
1876 {
1877         struct prom_t *_prom = &RELOC(prom);
1878         phandle oprom;
1879         char version[64];
1880
1881         oprom = call_prom("finddevice", 1, 1, ADDR("/openprom"));
1882         if (!PHANDLE_VALID(oprom))
1883                 return;
1884         if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0)
1885                 return;
1886         version[sizeof(version) - 1] = 0;
1887         /* XXX might need to add other versions here */
1888         if (strcmp(version, "Open Firmware, 1.0.5") == 0)
1889                 of_workarounds = OF_WA_CLAIM;
1890         else if (strncmp(version, "FirmWorks,3.", 12) == 0) {
1891                 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL;
1892                 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim");
1893         } else
1894                 return;
1895         _prom->memory = call_prom("open", 1, 1, ADDR("/memory"));
1896         prom_getprop(_prom->chosen, "mmu", &_prom->mmumap,
1897                      sizeof(_prom->mmumap));
1898         if (!IHANDLE_VALID(_prom->memory) || !IHANDLE_VALID(_prom->mmumap))
1899                 of_workarounds &= ~OF_WA_CLAIM;         /* hmmm */
1900 }
1901 #else
1902 #define prom_find_mmu()
1903 #endif
1904
1905 static void __init prom_init_stdout(void)
1906 {
1907         struct prom_t *_prom = &RELOC(prom);
1908         char *path = RELOC(of_stdout_device);
1909         char type[16];
1910         u32 val;
1911
1912         if (prom_getprop(_prom->chosen, "stdout", &val, sizeof(val)) <= 0)
1913                 prom_panic("cannot find stdout");
1914
1915         _prom->stdout = val;
1916
1917         /* Get the full OF pathname of the stdout device */
1918         memset(path, 0, 256);
1919         call_prom("instance-to-path", 3, 1, _prom->stdout, path, 255);
1920         val = call_prom("instance-to-package", 1, 1, _prom->stdout);
1921         prom_setprop(_prom->chosen, "/chosen", "linux,stdout-package",
1922                      &val, sizeof(val));
1923         prom_printf("OF stdout device is: %s\n", RELOC(of_stdout_device));
1924         prom_setprop(_prom->chosen, "/chosen", "linux,stdout-path",
1925                      path, strlen(path) + 1);
1926
1927         /* If it's a display, note it */
1928         memset(type, 0, sizeof(type));
1929         prom_getprop(val, "device_type", type, sizeof(type));
1930         if (strcmp(type, RELOC("display")) == 0)
1931                 prom_setprop(val, path, "linux,boot-display", NULL, 0);
1932 }
1933
1934 static int __init prom_find_machine_type(void)
1935 {
1936         struct prom_t *_prom = &RELOC(prom);
1937         char compat[256];
1938         int len, i = 0;
1939 #ifdef CONFIG_PPC64
1940         phandle rtas;
1941         int x;
1942 #endif
1943
1944         /* Look for a PowerMac or a Cell */
1945         len = prom_getprop(_prom->root, "compatible",
1946                            compat, sizeof(compat)-1);
1947         if (len > 0) {
1948                 compat[len] = 0;
1949                 while (i < len) {
1950                         char *p = &compat[i];
1951                         int sl = strlen(p);
1952                         if (sl == 0)
1953                                 break;
1954                         if (strstr(p, RELOC("Power Macintosh")) ||
1955                             strstr(p, RELOC("MacRISC")))
1956                                 return PLATFORM_POWERMAC;
1957 #ifdef CONFIG_PPC64
1958                         /* We must make sure we don't detect the IBM Cell
1959                          * blades as pSeries due to some firmware issues,
1960                          * so we do it here.
1961                          */
1962                         if (strstr(p, RELOC("IBM,CBEA")) ||
1963                             strstr(p, RELOC("IBM,CPBW-1.0")))
1964                                 return PLATFORM_GENERIC;
1965 #endif /* CONFIG_PPC64 */
1966                         i += sl + 1;
1967                 }
1968         }
1969 #ifdef CONFIG_PPC64
1970         /* Try to detect OPAL */
1971         if (PHANDLE_VALID(call_prom("finddevice", 1, 1, ADDR("/ibm,opal"))))
1972                 return PLATFORM_OPAL;
1973
1974         /* Try to figure out if it's an IBM pSeries or any other
1975          * PAPR compliant platform. We assume it is if :
1976          *  - /device_type is "chrp" (please, do NOT use that for future
1977          *    non-IBM designs !
1978          *  - it has /rtas
1979          */
1980         len = prom_getprop(_prom->root, "device_type",
1981                            compat, sizeof(compat)-1);
1982         if (len <= 0)
1983                 return PLATFORM_GENERIC;
1984         if (strcmp(compat, RELOC("chrp")))
1985                 return PLATFORM_GENERIC;
1986
1987         /* Default to pSeries. We need to know if we are running LPAR */
1988         rtas = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1989         if (!PHANDLE_VALID(rtas))
1990                 return PLATFORM_GENERIC;
1991         x = prom_getproplen(rtas, "ibm,hypertas-functions");
1992         if (x != PROM_ERROR) {
1993                 prom_debug("Hypertas detected, assuming LPAR !\n");
1994                 return PLATFORM_PSERIES_LPAR;
1995         }
1996         return PLATFORM_PSERIES;
1997 #else
1998         return PLATFORM_GENERIC;
1999 #endif
2000 }
2001
2002 static int __init prom_set_color(ihandle ih, int i, int r, int g, int b)
2003 {
2004         return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r);
2005 }
2006
2007 /*
2008  * If we have a display that we don't know how to drive,
2009  * we will want to try to execute OF's open method for it
2010  * later.  However, OF will probably fall over if we do that
2011  * we've taken over the MMU.
2012  * So we check whether we will need to open the display,
2013  * and if so, open it now.
2014  */
2015 static void __init prom_check_displays(void)
2016 {
2017         char type[16], *path;
2018         phandle node;
2019         ihandle ih;
2020         int i;
2021
2022         static unsigned char default_colors[] = {
2023                 0x00, 0x00, 0x00,
2024                 0x00, 0x00, 0xaa,
2025                 0x00, 0xaa, 0x00,
2026                 0x00, 0xaa, 0xaa,
2027                 0xaa, 0x00, 0x00,
2028                 0xaa, 0x00, 0xaa,
2029                 0xaa, 0xaa, 0x00,
2030                 0xaa, 0xaa, 0xaa,
2031                 0x55, 0x55, 0x55,
2032                 0x55, 0x55, 0xff,
2033                 0x55, 0xff, 0x55,
2034                 0x55, 0xff, 0xff,
2035                 0xff, 0x55, 0x55,
2036                 0xff, 0x55, 0xff,
2037                 0xff, 0xff, 0x55,
2038                 0xff, 0xff, 0xff
2039         };
2040         const unsigned char *clut;
2041
2042         prom_debug("Looking for displays\n");
2043         for (node = 0; prom_next_node(&node); ) {
2044                 memset(type, 0, sizeof(type));
2045                 prom_getprop(node, "device_type", type, sizeof(type));
2046                 if (strcmp(type, RELOC("display")) != 0)
2047                         continue;
2048
2049                 /* It seems OF doesn't null-terminate the path :-( */
2050                 path = RELOC(prom_scratch);
2051                 memset(path, 0, PROM_SCRATCH_SIZE);
2052
2053                 /*
2054                  * leave some room at the end of the path for appending extra
2055                  * arguments
2056                  */
2057                 if (call_prom("package-to-path", 3, 1, node, path,
2058                               PROM_SCRATCH_SIZE-10) == PROM_ERROR)
2059                         continue;
2060                 prom_printf("found display   : %s, opening... ", path);
2061
2062                 ih = call_prom("open", 1, 1, path);
2063                 if (ih == 0) {
2064                         prom_printf("failed\n");
2065                         continue;
2066                 }
2067
2068                 /* Success */
2069                 prom_printf("done\n");
2070                 prom_setprop(node, path, "linux,opened", NULL, 0);
2071
2072                 /* Setup a usable color table when the appropriate
2073                  * method is available. Should update this to set-colors */
2074                 clut = RELOC(default_colors);
2075                 for (i = 0; i < 16; i++, clut += 3)
2076                         if (prom_set_color(ih, i, clut[0], clut[1],
2077                                            clut[2]) != 0)
2078                                 break;
2079
2080 #ifdef CONFIG_LOGO_LINUX_CLUT224
2081                 clut = PTRRELOC(RELOC(logo_linux_clut224.clut));
2082                 for (i = 0; i < RELOC(logo_linux_clut224.clutsize); i++, clut += 3)
2083                         if (prom_set_color(ih, i + 32, clut[0], clut[1],
2084                                            clut[2]) != 0)
2085                                 break;
2086 #endif /* CONFIG_LOGO_LINUX_CLUT224 */
2087         }
2088 }
2089
2090
2091 /* Return (relocated) pointer to this much memory: moves initrd if reqd. */
2092 static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end,
2093                               unsigned long needed, unsigned long align)
2094 {
2095         void *ret;
2096
2097         *mem_start = _ALIGN(*mem_start, align);
2098         while ((*mem_start + needed) > *mem_end) {
2099                 unsigned long room, chunk;
2100
2101                 prom_debug("Chunk exhausted, claiming more at %x...\n",
2102                            RELOC(alloc_bottom));
2103                 room = RELOC(alloc_top) - RELOC(alloc_bottom);
2104                 if (room > DEVTREE_CHUNK_SIZE)
2105                         room = DEVTREE_CHUNK_SIZE;
2106                 if (room < PAGE_SIZE)
2107                         prom_panic("No memory for flatten_device_tree "
2108                                    "(no room)\n");
2109                 chunk = alloc_up(room, 0);
2110                 if (chunk == 0)
2111                         prom_panic("No memory for flatten_device_tree "
2112                                    "(claim failed)\n");
2113                 *mem_end = chunk + room;
2114         }
2115
2116         ret = (void *)*mem_start;
2117         *mem_start += needed;
2118
2119         return ret;
2120 }
2121
2122 #define dt_push_token(token, mem_start, mem_end) \
2123         do { *((u32 *)make_room(mem_start, mem_end, 4, 4)) = token; } while(0)
2124
2125 static unsigned long __init dt_find_string(char *str)
2126 {
2127         char *s, *os;
2128
2129         s = os = (char *)RELOC(dt_string_start);
2130         s += 4;
2131         while (s <  (char *)RELOC(dt_string_end)) {
2132                 if (strcmp(s, str) == 0)
2133                         return s - os;
2134                 s += strlen(s) + 1;
2135         }
2136         return 0;
2137 }
2138
2139 /*
2140  * The Open Firmware 1275 specification states properties must be 31 bytes or
2141  * less, however not all firmwares obey this. Make it 64 bytes to be safe.
2142  */
2143 #define MAX_PROPERTY_NAME 64
2144
2145 static void __init scan_dt_build_strings(phandle node,
2146                                          unsigned long *mem_start,
2147                                          unsigned long *mem_end)
2148 {
2149         char *prev_name, *namep, *sstart;
2150         unsigned long soff;
2151         phandle child;
2152
2153         sstart =  (char *)RELOC(dt_string_start);
2154
2155         /* get and store all property names */
2156         prev_name = RELOC("");
2157         for (;;) {
2158                 /* 64 is max len of name including nul. */
2159                 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1);
2160                 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) {
2161                         /* No more nodes: unwind alloc */
2162                         *mem_start = (unsigned long)namep;
2163                         break;
2164                 }
2165
2166                 /* skip "name" */
2167                 if (strcmp(namep, RELOC("name")) == 0) {
2168                         *mem_start = (unsigned long)namep;
2169                         prev_name = RELOC("name");
2170                         continue;
2171                 }
2172                 /* get/create string entry */
2173                 soff = dt_find_string(namep);
2174                 if (soff != 0) {
2175                         *mem_start = (unsigned long)namep;
2176                         namep = sstart + soff;
2177                 } else {
2178                         /* Trim off some if we can */
2179                         *mem_start = (unsigned long)namep + strlen(namep) + 1;
2180                         RELOC(dt_string_end) = *mem_start;
2181                 }
2182                 prev_name = namep;
2183         }
2184
2185         /* do all our children */
2186         child = call_prom("child", 1, 1, node);
2187         while (child != 0) {
2188                 scan_dt_build_strings(child, mem_start, mem_end);
2189                 child = call_prom("peer", 1, 1, child);
2190         }
2191 }
2192
2193 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
2194                                         unsigned long *mem_end)
2195 {
2196         phandle child;
2197         char *namep, *prev_name, *sstart, *p, *ep, *lp, *path;
2198         unsigned long soff;
2199         unsigned char *valp;
2200         static char pname[MAX_PROPERTY_NAME];
2201         int l, room, has_phandle = 0;
2202
2203         dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end);
2204
2205         /* get the node's full name */
2206         namep = (char *)*mem_start;
2207         room = *mem_end - *mem_start;
2208         if (room > 255)
2209                 room = 255;
2210         l = call_prom("package-to-path", 3, 1, node, namep, room);
2211         if (l >= 0) {
2212                 /* Didn't fit?  Get more room. */
2213                 if (l >= room) {
2214                         if (l >= *mem_end - *mem_start)
2215                                 namep = make_room(mem_start, mem_end, l+1, 1);
2216                         call_prom("package-to-path", 3, 1, node, namep, l);
2217                 }
2218                 namep[l] = '\0';
2219
2220                 /* Fixup an Apple bug where they have bogus \0 chars in the
2221                  * middle of the path in some properties, and extract
2222                  * the unit name (everything after the last '/').
2223                  */
2224                 for (lp = p = namep, ep = namep + l; p < ep; p++) {
2225                         if (*p == '/')
2226                                 lp = namep;
2227                         else if (*p != 0)
2228                                 *lp++ = *p;
2229                 }
2230                 *lp = 0;
2231                 *mem_start = _ALIGN((unsigned long)lp + 1, 4);
2232         }
2233
2234         /* get it again for debugging */
2235         path = RELOC(prom_scratch);
2236         memset(path, 0, PROM_SCRATCH_SIZE);
2237         call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
2238
2239         /* get and store all properties */
2240         prev_name = RELOC("");
2241         sstart = (char *)RELOC(dt_string_start);
2242         for (;;) {
2243                 if (call_prom("nextprop", 3, 1, node, prev_name,
2244                               RELOC(pname)) != 1)
2245                         break;
2246
2247                 /* skip "name" */
2248                 if (strcmp(RELOC(pname), RELOC("name")) == 0) {
2249                         prev_name = RELOC("name");
2250                         continue;
2251                 }
2252
2253                 /* find string offset */
2254                 soff = dt_find_string(RELOC(pname));
2255                 if (soff == 0) {
2256                         prom_printf("WARNING: Can't find string index for"
2257                                     " <%s>, node %s\n", RELOC(pname), path);
2258                         break;
2259                 }
2260                 prev_name = sstart + soff;
2261
2262                 /* get length */
2263                 l = call_prom("getproplen", 2, 1, node, RELOC(pname));
2264
2265                 /* sanity checks */
2266                 if (l == PROM_ERROR)
2267                         continue;
2268
2269                 /* push property head */
2270                 dt_push_token(OF_DT_PROP, mem_start, mem_end);
2271                 dt_push_token(l, mem_start, mem_end);
2272                 dt_push_token(soff, mem_start, mem_end);
2273
2274                 /* push property content */
2275                 valp = make_room(mem_start, mem_end, l, 4);
2276                 call_prom("getprop", 4, 1, node, RELOC(pname), valp, l);
2277                 *mem_start = _ALIGN(*mem_start, 4);
2278
2279                 if (!strcmp(RELOC(pname), RELOC("phandle")))
2280                         has_phandle = 1;
2281         }
2282
2283         /* Add a "linux,phandle" property if no "phandle" property already
2284          * existed (can happen with OPAL)
2285          */
2286         if (!has_phandle) {
2287                 soff = dt_find_string(RELOC("linux,phandle"));
2288                 if (soff == 0)
2289                         prom_printf("WARNING: Can't find string index for"
2290                                     " <linux-phandle> node %s\n", path);
2291                 else {
2292                         dt_push_token(OF_DT_PROP, mem_start, mem_end);
2293                         dt_push_token(4, mem_start, mem_end);
2294                         dt_push_token(soff, mem_start, mem_end);
2295                         valp = make_room(mem_start, mem_end, 4, 4);
2296                         *(u32 *)valp = node;
2297                 }
2298         }
2299
2300         /* do all our children */
2301         child = call_prom("child", 1, 1, node);
2302         while (child != 0) {
2303                 scan_dt_build_struct(child, mem_start, mem_end);
2304                 child = call_prom("peer", 1, 1, child);
2305         }
2306
2307         dt_push_token(OF_DT_END_NODE, mem_start, mem_end);
2308 }
2309
2310 static void __init flatten_device_tree(void)
2311 {
2312         phandle root;
2313         unsigned long mem_start, mem_end, room;
2314         struct boot_param_header *hdr;
2315         struct prom_t *_prom = &RELOC(prom);
2316         char *namep;
2317         u64 *rsvmap;
2318
2319         /*
2320          * Check how much room we have between alloc top & bottom (+/- a
2321          * few pages), crop to 1MB, as this is our "chunk" size
2322          */
2323         room = RELOC(alloc_top) - RELOC(alloc_bottom) - 0x4000;
2324         if (room > DEVTREE_CHUNK_SIZE)
2325                 room = DEVTREE_CHUNK_SIZE;
2326         prom_debug("starting device tree allocs at %x\n", RELOC(alloc_bottom));
2327
2328         /* Now try to claim that */
2329         mem_start = (unsigned long)alloc_up(room, PAGE_SIZE);
2330         if (mem_start == 0)
2331                 prom_panic("Can't allocate initial device-tree chunk\n");
2332         mem_end = mem_start + room;
2333
2334         /* Get root of tree */
2335         root = call_prom("peer", 1, 1, (phandle)0);
2336         if (root == (phandle)0)
2337                 prom_panic ("couldn't get device tree root\n");
2338
2339         /* Build header and make room for mem rsv map */
2340         mem_start = _ALIGN(mem_start, 4);
2341         hdr = make_room(&mem_start, &mem_end,
2342                         sizeof(struct boot_param_header), 4);
2343         RELOC(dt_header_start) = (unsigned long)hdr;
2344         rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8);
2345
2346         /* Start of strings */
2347         mem_start = PAGE_ALIGN(mem_start);
2348         RELOC(dt_string_start) = mem_start;
2349         mem_start += 4; /* hole */
2350
2351         /* Add "linux,phandle" in there, we'll need it */
2352         namep = make_room(&mem_start, &mem_end, 16, 1);
2353         strcpy(namep, RELOC("linux,phandle"));
2354         mem_start = (unsigned long)namep + strlen(namep) + 1;
2355
2356         /* Build string array */
2357         prom_printf("Building dt strings...\n");
2358         scan_dt_build_strings(root, &mem_start, &mem_end);
2359         RELOC(dt_string_end) = mem_start;
2360
2361         /* Build structure */
2362         mem_start = PAGE_ALIGN(mem_start);
2363         RELOC(dt_struct_start) = mem_start;
2364         prom_printf("Building dt structure...\n");
2365         scan_dt_build_struct(root, &mem_start, &mem_end);
2366         dt_push_token(OF_DT_END, &mem_start, &mem_end);
2367         RELOC(dt_struct_end) = PAGE_ALIGN(mem_start);
2368
2369         /* Finish header */
2370         hdr->boot_cpuid_phys = _prom->cpu;
2371         hdr->magic = OF_DT_HEADER;
2372         hdr->totalsize = RELOC(dt_struct_end) - RELOC(dt_header_start);
2373         hdr->off_dt_struct = RELOC(dt_struct_start) - RELOC(dt_header_start);
2374         hdr->off_dt_strings = RELOC(dt_string_start) - RELOC(dt_header_start);
2375         hdr->dt_strings_size = RELOC(dt_string_end) - RELOC(dt_string_start);
2376         hdr->off_mem_rsvmap = ((unsigned long)rsvmap) - RELOC(dt_header_start);
2377         hdr->version = OF_DT_VERSION;
2378         /* Version 16 is not backward compatible */
2379         hdr->last_comp_version = 0x10;
2380
2381         /* Copy the reserve map in */
2382         memcpy(rsvmap, RELOC(mem_reserve_map), sizeof(mem_reserve_map));
2383
2384 #ifdef DEBUG_PROM
2385         {
2386                 int i;
2387                 prom_printf("reserved memory map:\n");
2388                 for (i = 0; i < RELOC(mem_reserve_cnt); i++)
2389                         prom_printf("  %x - %x\n",
2390                                     RELOC(mem_reserve_map)[i].base,
2391                                     RELOC(mem_reserve_map)[i].size);
2392         }
2393 #endif
2394         /* Bump mem_reserve_cnt to cause further reservations to fail
2395          * since it's too late.
2396          */
2397         RELOC(mem_reserve_cnt) = MEM_RESERVE_MAP_SIZE;
2398
2399         prom_printf("Device tree strings 0x%x -> 0x%x\n",
2400                     RELOC(dt_string_start), RELOC(dt_string_end));
2401         prom_printf("Device tree struct  0x%x -> 0x%x\n",
2402                     RELOC(dt_struct_start), RELOC(dt_struct_end));
2403
2404 }
2405
2406 #ifdef CONFIG_PPC_MAPLE
2407 /* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property.
2408  * The values are bad, and it doesn't even have the right number of cells. */
2409 static void __init fixup_device_tree_maple(void)
2410 {
2411         phandle isa;
2412         u32 rloc = 0x01002000; /* IO space; PCI device = 4 */
2413         u32 isa_ranges[6];
2414         char *name;
2415
2416         name = "/ht@0/isa@4";
2417         isa = call_prom("finddevice", 1, 1, ADDR(name));
2418         if (!PHANDLE_VALID(isa)) {
2419                 name = "/ht@0/isa@6";
2420                 isa = call_prom("finddevice", 1, 1, ADDR(name));
2421                 rloc = 0x01003000; /* IO space; PCI device = 6 */
2422         }
2423         if (!PHANDLE_VALID(isa))
2424                 return;
2425
2426         if (prom_getproplen(isa, "ranges") != 12)
2427                 return;
2428         if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges))
2429                 == PROM_ERROR)
2430                 return;
2431
2432         if (isa_ranges[0] != 0x1 ||
2433                 isa_ranges[1] != 0xf4000000 ||
2434                 isa_ranges[2] != 0x00010000)
2435                 return;
2436
2437         prom_printf("Fixing up bogus ISA range on Maple/Apache...\n");
2438
2439         isa_ranges[0] = 0x1;
2440         isa_ranges[1] = 0x0;
2441         isa_ranges[2] = rloc;
2442         isa_ranges[3] = 0x0;
2443         isa_ranges[4] = 0x0;
2444         isa_ranges[5] = 0x00010000;
2445         prom_setprop(isa, name, "ranges",
2446                         isa_ranges, sizeof(isa_ranges));
2447 }
2448
2449 #define CPC925_MC_START         0xf8000000
2450 #define CPC925_MC_LENGTH        0x1000000
2451 /* The values for memory-controller don't have right number of cells */
2452 static void __init fixup_device_tree_maple_memory_controller(void)
2453 {
2454         phandle mc;
2455         u32 mc_reg[4];
2456         char *name = "/hostbridge@f8000000";
2457         struct prom_t *_prom = &RELOC(prom);
2458         u32 ac, sc;
2459
2460         mc = call_prom("finddevice", 1, 1, ADDR(name));
2461         if (!PHANDLE_VALID(mc))
2462                 return;
2463
2464         if (prom_getproplen(mc, "reg") != 8)
2465                 return;
2466
2467         prom_getprop(_prom->root, "#address-cells", &ac, sizeof(ac));
2468         prom_getprop(_prom->root, "#size-cells", &sc, sizeof(sc));
2469         if ((ac != 2) || (sc != 2))
2470                 return;
2471
2472         if (prom_getprop(mc, "reg", mc_reg, sizeof(mc_reg)) == PROM_ERROR)
2473                 return;
2474
2475         if (mc_reg[0] != CPC925_MC_START || mc_reg[1] != CPC925_MC_LENGTH)
2476                 return;
2477
2478         prom_printf("Fixing up bogus hostbridge on Maple...\n");
2479
2480         mc_reg[0] = 0x0;
2481         mc_reg[1] = CPC925_MC_START;
2482         mc_reg[2] = 0x0;
2483         mc_reg[3] = CPC925_MC_LENGTH;
2484         prom_setprop(mc, name, "reg", mc_reg, sizeof(mc_reg));
2485 }
2486 #else
2487 #define fixup_device_tree_maple()
2488 #define fixup_device_tree_maple_memory_controller()
2489 #endif
2490
2491 #ifdef CONFIG_PPC_CHRP
2492 /*
2493  * Pegasos and BriQ lacks the "ranges" property in the isa node
2494  * Pegasos needs decimal IRQ 14/15, not hexadecimal
2495  * Pegasos has the IDE configured in legacy mode, but advertised as native
2496  */
2497 static void __init fixup_device_tree_chrp(void)
2498 {
2499         phandle ph;
2500         u32 prop[6];
2501         u32 rloc = 0x01006000; /* IO space; PCI device = 12 */
2502         char *name;
2503         int rc;
2504
2505         name = "/pci@80000000/isa@c";
2506         ph = call_prom("finddevice", 1, 1, ADDR(name));
2507         if (!PHANDLE_VALID(ph)) {
2508                 name = "/pci@ff500000/isa@6";
2509                 ph = call_prom("finddevice", 1, 1, ADDR(name));
2510                 rloc = 0x01003000; /* IO space; PCI device = 6 */
2511         }
2512         if (PHANDLE_VALID(ph)) {
2513                 rc = prom_getproplen(ph, "ranges");
2514                 if (rc == 0 || rc == PROM_ERROR) {
2515                         prom_printf("Fixing up missing ISA range on Pegasos...\n");
2516
2517                         prop[0] = 0x1;
2518                         prop[1] = 0x0;
2519                         prop[2] = rloc;
2520                         prop[3] = 0x0;
2521                         prop[4] = 0x0;
2522                         prop[5] = 0x00010000;
2523                         prom_setprop(ph, name, "ranges", prop, sizeof(prop));
2524                 }
2525         }
2526
2527         name = "/pci@80000000/ide@C,1";
2528         ph = call_prom("finddevice", 1, 1, ADDR(name));
2529         if (PHANDLE_VALID(ph)) {
2530                 prom_printf("Fixing up IDE interrupt on Pegasos...\n");
2531                 prop[0] = 14;
2532                 prop[1] = 0x0;
2533                 prom_setprop(ph, name, "interrupts", prop, 2*sizeof(u32));
2534                 prom_printf("Fixing up IDE class-code on Pegasos...\n");
2535                 rc = prom_getprop(ph, "class-code", prop, sizeof(u32));
2536                 if (rc == sizeof(u32)) {
2537                         prop[0] &= ~0x5;
2538                         prom_setprop(ph, name, "class-code", prop, sizeof(u32));
2539                 }
2540         }
2541 }
2542 #else
2543 #define fixup_device_tree_chrp()
2544 #endif
2545
2546 #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC)
2547 static void __init fixup_device_tree_pmac(void)
2548 {
2549         phandle u3, i2c, mpic;
2550         u32 u3_rev;
2551         u32 interrupts[2];
2552         u32 parent;
2553
2554         /* Some G5s have a missing interrupt definition, fix it up here */
2555         u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000"));
2556         if (!PHANDLE_VALID(u3))
2557                 return;
2558         i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000"));
2559         if (!PHANDLE_VALID(i2c))
2560                 return;
2561         mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000"));
2562         if (!PHANDLE_VALID(mpic))
2563                 return;
2564
2565         /* check if proper rev of u3 */
2566         if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev))
2567             == PROM_ERROR)
2568                 return;
2569         if (u3_rev < 0x35 || u3_rev > 0x39)
2570                 return;
2571         /* does it need fixup ? */
2572         if (prom_getproplen(i2c, "interrupts") > 0)
2573                 return;
2574
2575         prom_printf("fixing up bogus interrupts for u3 i2c...\n");
2576
2577         /* interrupt on this revision of u3 is number 0 and level */
2578         interrupts[0] = 0;
2579         interrupts[1] = 1;
2580         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts",
2581                      &interrupts, sizeof(interrupts));
2582         parent = (u32)mpic;
2583         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent",
2584                      &parent, sizeof(parent));
2585 }
2586 #else
2587 #define fixup_device_tree_pmac()
2588 #endif
2589
2590 #ifdef CONFIG_PPC_EFIKA
2591 /*
2592  * The MPC5200 FEC driver requires an phy-handle property to tell it how
2593  * to talk to the phy.  If the phy-handle property is missing, then this
2594  * function is called to add the appropriate nodes and link it to the
2595  * ethernet node.
2596  */
2597 static void __init fixup_device_tree_efika_add_phy(void)
2598 {
2599         u32 node;
2600         char prop[64];
2601         int rv;
2602
2603         /* Check if /builtin/ethernet exists - bail if it doesn't */
2604         node = call_prom("finddevice", 1, 1, ADDR("/builtin/ethernet"));
2605         if (!PHANDLE_VALID(node))
2606                 return;
2607
2608         /* Check if the phy-handle property exists - bail if it does */
2609         rv = prom_getprop(node, "phy-handle", prop, sizeof(prop));
2610         if (!rv)
2611                 return;
2612
2613         /*
2614          * At this point the ethernet device doesn't have a phy described.
2615          * Now we need to add the missing phy node and linkage
2616          */
2617
2618         /* Check for an MDIO bus node - if missing then create one */
2619         node = call_prom("finddevice", 1, 1, ADDR("/builtin/mdio"));
2620         if (!PHANDLE_VALID(node)) {
2621                 prom_printf("Adding Ethernet MDIO node\n");
2622                 call_prom("interpret", 1, 1,
2623                         " s\" /builtin\" find-device"
2624                         " new-device"
2625                                 " 1 encode-int s\" #address-cells\" property"
2626                                 " 0 encode-int s\" #size-cells\" property"
2627                                 " s\" mdio\" device-name"
2628                                 " s\" fsl,mpc5200b-mdio\" encode-string"
2629                                 " s\" compatible\" property"
2630                                 " 0xf0003000 0x400 reg"
2631                                 " 0x2 encode-int"
2632                                 " 0x5 encode-int encode+"
2633                                 " 0x3 encode-int encode+"
2634                                 " s\" interrupts\" property"
2635                         " finish-device");
2636         };
2637
2638         /* Check for a PHY device node - if missing then create one and
2639          * give it's phandle to the ethernet node */
2640         node = call_prom("finddevice", 1, 1,
2641                          ADDR("/builtin/mdio/ethernet-phy"));
2642         if (!PHANDLE_VALID(node)) {
2643                 prom_printf("Adding Ethernet PHY node\n");
2644                 call_prom("interpret", 1, 1,
2645                         " s\" /builtin/mdio\" find-device"
2646                         " new-device"
2647                                 " s\" ethernet-phy\" device-name"
2648                                 " 0x10 encode-int s\" reg\" property"
2649                                 " my-self"
2650                                 " ihandle>phandle"
2651                         " finish-device"
2652                         " s\" /builtin/ethernet\" find-device"
2653                                 " encode-int"
2654                                 " s\" phy-handle\" property"
2655                         " device-end");
2656         }
2657 }
2658
2659 static void __init fixup_device_tree_efika(void)
2660 {
2661         int sound_irq[3] = { 2, 2, 0 };
2662         int bcomm_irq[3*16] = { 3,0,0, 3,1,0, 3,2,0, 3,3,0,
2663                                 3,4,0, 3,5,0, 3,6,0, 3,7,0,
2664                                 3,8,0, 3,9,0, 3,10,0, 3,11,0,
2665                                 3,12,0, 3,13,0, 3,14,0, 3,15,0 };
2666         u32 node;
2667         char prop[64];
2668         int rv, len;
2669
2670         /* Check if we're really running on a EFIKA */
2671         node = call_prom("finddevice", 1, 1, ADDR("/"));
2672         if (!PHANDLE_VALID(node))
2673                 return;
2674
2675         rv = prom_getprop(node, "model", prop, sizeof(prop));
2676         if (rv == PROM_ERROR)
2677                 return;
2678         if (strcmp(prop, "EFIKA5K2"))
2679                 return;
2680
2681         prom_printf("Applying EFIKA device tree fixups\n");
2682
2683         /* Claiming to be 'chrp' is death */
2684         node = call_prom("finddevice", 1, 1, ADDR("/"));
2685         rv = prom_getprop(node, "device_type", prop, sizeof(prop));
2686         if (rv != PROM_ERROR && (strcmp(prop, "chrp") == 0))
2687                 prom_setprop(node, "/", "device_type", "efika", sizeof("efika"));
2688
2689         /* CODEGEN,description is exposed in /proc/cpuinfo so
2690            fix that too */
2691         rv = prom_getprop(node, "CODEGEN,description", prop, sizeof(prop));
2692         if (rv != PROM_ERROR && (strstr(prop, "CHRP")))
2693                 prom_setprop(node, "/", "CODEGEN,description",
2694                              "Efika 5200B PowerPC System",
2695                              sizeof("Efika 5200B PowerPC System"));
2696
2697         /* Fixup bestcomm interrupts property */
2698         node = call_prom("finddevice", 1, 1, ADDR("/builtin/bestcomm"));
2699         if (PHANDLE_VALID(node)) {
2700                 len = prom_getproplen(node, "interrupts");
2701                 if (len == 12) {
2702                         prom_printf("Fixing bestcomm interrupts property\n");
2703                         prom_setprop(node, "/builtin/bestcom", "interrupts",
2704                                      bcomm_irq, sizeof(bcomm_irq));
2705                 }
2706         }
2707
2708         /* Fixup sound interrupts property */
2709         node = call_prom("finddevice", 1, 1, ADDR("/builtin/sound"));
2710         if (PHANDLE_VALID(node)) {
2711                 rv = prom_getprop(node, "interrupts", prop, sizeof(prop));
2712                 if (rv == PROM_ERROR) {
2713                         prom_printf("Adding sound interrupts property\n");
2714                         prom_setprop(node, "/builtin/sound", "interrupts",
2715                                      sound_irq, sizeof(sound_irq));
2716                 }
2717         }
2718
2719         /* Make sure ethernet phy-handle property exists */
2720         fixup_device_tree_efika_add_phy();
2721 }
2722 #else
2723 #define fixup_device_tree_efika()
2724 #endif
2725
2726 static void __init fixup_device_tree(void)
2727 {
2728         fixup_device_tree_maple();
2729         fixup_device_tree_maple_memory_controller();
2730         fixup_device_tree_chrp();
2731         fixup_device_tree_pmac();
2732         fixup_device_tree_efika();
2733 }
2734
2735 static void __init prom_find_boot_cpu(void)
2736 {
2737         struct prom_t *_prom = &RELOC(prom);
2738         u32 getprop_rval;
2739         ihandle prom_cpu;
2740         phandle cpu_pkg;
2741
2742         _prom->cpu = 0;
2743         if (prom_getprop(_prom->chosen, "cpu", &prom_cpu, sizeof(prom_cpu)) <= 0)
2744                 return;
2745
2746         cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
2747
2748         prom_getprop(cpu_pkg, "reg", &getprop_rval, sizeof(getprop_rval));
2749         _prom->cpu = getprop_rval;
2750
2751         prom_debug("Booting CPU hw index = %lu\n", _prom->cpu);
2752 }
2753
2754 static void __init prom_check_initrd(unsigned long r3, unsigned long r4)
2755 {
2756 #ifdef CONFIG_BLK_DEV_INITRD
2757         struct prom_t *_prom = &RELOC(prom);
2758
2759         if (r3 && r4 && r4 != 0xdeadbeef) {
2760                 unsigned long val;
2761
2762                 RELOC(prom_initrd_start) = is_kernel_addr(r3) ? __pa(r3) : r3;
2763                 RELOC(prom_initrd_end) = RELOC(prom_initrd_start) + r4;
2764
2765                 val = RELOC(prom_initrd_start);
2766                 prom_setprop(_prom->chosen, "/chosen", "linux,initrd-start",
2767                              &val, sizeof(val));
2768                 val = RELOC(prom_initrd_end);
2769                 prom_setprop(_prom->chosen, "/chosen", "linux,initrd-end",
2770                              &val, sizeof(val));
2771
2772                 reserve_mem(RELOC(prom_initrd_start),
2773                             RELOC(prom_initrd_end) - RELOC(prom_initrd_start));
2774
2775                 prom_debug("initrd_start=0x%x\n", RELOC(prom_initrd_start));
2776                 prom_debug("initrd_end=0x%x\n", RELOC(prom_initrd_end));
2777         }
2778 #endif /* CONFIG_BLK_DEV_INITRD */
2779 }
2780
2781
2782 /*
2783  * We enter here early on, when the Open Firmware prom is still
2784  * handling exceptions and the MMU hash table for us.
2785  */
2786
2787 unsigned long __init prom_init(unsigned long r3, unsigned long r4,
2788                                unsigned long pp,
2789                                unsigned long r6, unsigned long r7,
2790                                unsigned long kbase)
2791 {
2792         struct prom_t *_prom;
2793         unsigned long hdr;
2794
2795 #ifdef CONFIG_PPC32
2796         unsigned long offset = reloc_offset();
2797         reloc_got2(offset);
2798 #endif
2799
2800         _prom = &RELOC(prom);
2801
2802         /*
2803          * First zero the BSS
2804          */
2805         memset(&RELOC(__bss_start), 0, __bss_stop - __bss_start);
2806
2807         /*
2808          * Init interface to Open Firmware, get some node references,
2809          * like /chosen
2810          */
2811         prom_init_client_services(pp);
2812
2813         /*
2814          * See if this OF is old enough that we need to do explicit maps
2815          * and other workarounds
2816          */
2817         prom_find_mmu();
2818
2819         /*
2820          * Init prom stdout device
2821          */
2822         prom_init_stdout();
2823
2824         prom_printf("Preparing to boot %s", RELOC(linux_banner));
2825
2826         /*
2827          * Get default machine type. At this point, we do not differentiate
2828          * between pSeries SMP and pSeries LPAR
2829          */
2830         RELOC(of_platform) = prom_find_machine_type();
2831         prom_printf("Detected machine type: %x\n", RELOC(of_platform));
2832
2833 #ifndef CONFIG_NONSTATIC_KERNEL
2834         /* Bail if this is a kdump kernel. */
2835         if (PHYSICAL_START > 0)
2836                 prom_panic("Error: You can't boot a kdump kernel from OF!\n");
2837 #endif
2838
2839         /*
2840          * Check for an initrd
2841          */
2842         prom_check_initrd(r3, r4);
2843
2844 #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
2845         /*
2846          * On pSeries, inform the firmware about our capabilities
2847          */
2848         if (RELOC(of_platform) == PLATFORM_PSERIES ||
2849             RELOC(of_platform) == PLATFORM_PSERIES_LPAR)
2850                 prom_send_capabilities();
2851 #endif
2852
2853         /*
2854          * Copy the CPU hold code
2855          */
2856         if (RELOC(of_platform) != PLATFORM_POWERMAC)
2857                 copy_and_flush(0, kbase, 0x100, 0);
2858
2859         /*
2860          * Do early parsing of command line
2861          */
2862         early_cmdline_parse();
2863
2864         /*
2865          * Initialize memory management within prom_init
2866          */
2867         prom_init_mem();
2868
2869         /*
2870          * Determine which cpu is actually running right _now_
2871          */
2872         prom_find_boot_cpu();
2873
2874         /*
2875          * Initialize display devices
2876          */
2877         prom_check_displays();
2878
2879 #ifdef CONFIG_PPC64
2880         /*
2881          * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else
2882          * that uses the allocator, we need to make sure we get the top of memory
2883          * available for us here...
2884          */
2885         if (RELOC(of_platform) == PLATFORM_PSERIES)
2886                 prom_initialize_tce_table();
2887 #endif
2888
2889         /*
2890          * On non-powermacs, try to instantiate RTAS. PowerMacs don't
2891          * have a usable RTAS implementation.
2892          */
2893         if (RELOC(of_platform) != PLATFORM_POWERMAC &&
2894             RELOC(of_platform) != PLATFORM_OPAL)
2895                 prom_instantiate_rtas();
2896
2897 #ifdef CONFIG_PPC_POWERNV
2898         /* Detect HAL and try instanciating it & doing takeover */
2899         if (RELOC(of_platform) == PLATFORM_PSERIES_LPAR) {
2900                 prom_query_opal();
2901                 if (RELOC(of_platform) == PLATFORM_OPAL) {
2902                         prom_opal_hold_cpus();
2903                         prom_opal_takeover();
2904                 }
2905         } else if (RELOC(of_platform) == PLATFORM_OPAL)
2906                 prom_instantiate_opal();
2907 #endif
2908
2909         /*
2910          * On non-powermacs, put all CPUs in spin-loops.
2911          *
2912          * PowerMacs use a different mechanism to spin CPUs
2913          */
2914         if (RELOC(of_platform) != PLATFORM_POWERMAC &&
2915             RELOC(of_platform) != PLATFORM_OPAL)
2916                 prom_hold_cpus();
2917
2918         /*
2919          * Fill in some infos for use by the kernel later on
2920          */
2921         if (RELOC(prom_memory_limit))
2922                 prom_setprop(_prom->chosen, "/chosen", "linux,memory-limit",
2923                              &RELOC(prom_memory_limit),
2924                              sizeof(prom_memory_limit));
2925 #ifdef CONFIG_PPC64
2926         if (RELOC(prom_iommu_off))
2927                 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-off",
2928                              NULL, 0);
2929
2930         if (RELOC(prom_iommu_force_on))
2931                 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-force-on",
2932                              NULL, 0);
2933
2934         if (RELOC(prom_tce_alloc_start)) {
2935                 prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-start",
2936                              &RELOC(prom_tce_alloc_start),
2937                              sizeof(prom_tce_alloc_start));
2938                 prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-end",
2939                              &RELOC(prom_tce_alloc_end),
2940                              sizeof(prom_tce_alloc_end));
2941         }
2942 #endif
2943
2944         /*
2945          * Fixup any known bugs in the device-tree
2946          */
2947         fixup_device_tree();
2948
2949         /*
2950          * Now finally create the flattened device-tree
2951          */
2952         prom_printf("copying OF device tree...\n");
2953         flatten_device_tree();
2954
2955         /*
2956          * in case stdin is USB and still active on IBM machines...
2957          * Unfortunately quiesce crashes on some powermacs if we have
2958          * closed stdin already (in particular the powerbook 101). It
2959          * appears that the OPAL version of OFW doesn't like it either.
2960          */
2961         if (RELOC(of_platform) != PLATFORM_POWERMAC &&
2962             RELOC(of_platform) != PLATFORM_OPAL)
2963                 prom_close_stdin();
2964
2965         /*
2966          * Call OF "quiesce" method to shut down pending DMA's from
2967          * devices etc...
2968          */
2969         prom_printf("Calling quiesce...\n");
2970         call_prom("quiesce", 0, 0);
2971
2972         /*
2973          * And finally, call the kernel passing it the flattened device
2974          * tree and NULL as r5, thus triggering the new entry point which
2975          * is common to us and kexec
2976          */
2977         hdr = RELOC(dt_header_start);
2978
2979         /* Don't print anything after quiesce under OPAL, it crashes OFW */
2980         if (RELOC(of_platform) != PLATFORM_OPAL) {
2981                 prom_printf("returning from prom_init\n");
2982                 prom_debug("->dt_header_start=0x%x\n", hdr);
2983         }
2984
2985 #ifdef CONFIG_PPC32
2986         reloc_got2(-offset);
2987 #endif
2988
2989 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
2990         /* OPAL early debug gets the OPAL base & entry in r8 and r9 */
2991         __start(hdr, kbase, 0, 0, 0,
2992                 RELOC(prom_opal_base), RELOC(prom_opal_entry));
2993 #else
2994         __start(hdr, kbase, 0, 0, 0, 0, 0);
2995 #endif
2996
2997         return 0;
2998 }