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