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