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 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 = 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 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[prop_len];
1135                 prom_debug("Found ibm,arch-vec-5-platform-support, len: %d\n",
1136                            prop_len);
1137                 prom_getprop(prom.chosen, "ibm,arch-vec-5-platform-support",
1138                              &vec, sizeof(vec));
1139                 for (i = 0; i < prop_len; i += 2) {
1140                         prom_debug("%d: index = 0x%x val = 0x%x\n", i / 2
1141                                                                   , vec[i]
1142                                                                   , vec[i + 1]);
1143                         prom_parse_platform_support(vec[i], vec[i + 1],
1144                                                     &supported);
1145                 }
1146         }
1147
1148         if (supported.radix_mmu && supported.radix_gtse &&
1149             IS_ENABLED(CONFIG_PPC_RADIX_MMU)) {
1150                 /* Radix preferred - but we require GTSE for now */
1151                 prom_debug("Asking for radix with GTSE\n");
1152                 ibm_architecture_vec.vec5.mmu = OV5_FEAT(OV5_MMU_RADIX);
1153                 ibm_architecture_vec.vec5.radix_ext = OV5_FEAT(OV5_RADIX_GTSE);
1154         } else if (supported.hash_mmu) {
1155                 /* Default to hash mmu (if we can) */
1156                 prom_debug("Asking for hash\n");
1157                 ibm_architecture_vec.vec5.mmu = OV5_FEAT(OV5_MMU_HASH);
1158         } else {
1159                 /* We're probably on a legacy hypervisor */
1160                 prom_debug("Assuming legacy hash support\n");
1161         }
1162
1163         if (supported.xive) {
1164                 prom_debug("Asking for XIVE\n");
1165                 ibm_architecture_vec.vec5.intarch = OV5_FEAT(OV5_XIVE_EXPLOIT);
1166         }
1167 }
1168
1169 static void __init prom_send_capabilities(void)
1170 {
1171         ihandle root;
1172         prom_arg_t ret;
1173         u32 cores;
1174
1175         /* Check ibm,arch-vec-5-platform-support and fixup vec5 if required */
1176         prom_check_platform_support();
1177
1178         root = call_prom("open", 1, 1, ADDR("/"));
1179         if (root != 0) {
1180                 /* We need to tell the FW about the number of cores we support.
1181                  *
1182                  * To do that, we count the number of threads on the first core
1183                  * (we assume this is the same for all cores) and use it to
1184                  * divide NR_CPUS.
1185                  */
1186
1187                 cores = DIV_ROUND_UP(NR_CPUS, prom_count_smt_threads());
1188                 prom_printf("Max number of cores passed to firmware: %u (NR_CPUS = %d)\n",
1189                             cores, NR_CPUS);
1190
1191                 ibm_architecture_vec.vec5.max_cpus = cpu_to_be32(cores);
1192
1193                 /* try calling the ibm,client-architecture-support method */
1194                 prom_printf("Calling ibm,client-architecture-support...");
1195                 if (call_prom_ret("call-method", 3, 2, &ret,
1196                                   ADDR("ibm,client-architecture-support"),
1197                                   root,
1198                                   ADDR(&ibm_architecture_vec)) == 0) {
1199                         /* the call exists... */
1200                         if (ret)
1201                                 prom_printf("\nWARNING: ibm,client-architecture"
1202                                             "-support call FAILED!\n");
1203                         call_prom("close", 1, 0, root);
1204                         prom_printf(" done\n");
1205                         return;
1206                 }
1207                 call_prom("close", 1, 0, root);
1208                 prom_printf(" not implemented\n");
1209         }
1210
1211 #ifdef __BIG_ENDIAN__
1212         {
1213                 ihandle elfloader;
1214
1215                 /* no ibm,client-architecture-support call, try the old way */
1216                 elfloader = call_prom("open", 1, 1,
1217                                       ADDR("/packages/elf-loader"));
1218                 if (elfloader == 0) {
1219                         prom_printf("couldn't open /packages/elf-loader\n");
1220                         return;
1221                 }
1222                 call_prom("call-method", 3, 1, ADDR("process-elf-header"),
1223                           elfloader, ADDR(&fake_elf));
1224                 call_prom("close", 1, 0, elfloader);
1225         }
1226 #endif /* __BIG_ENDIAN__ */
1227 }
1228 #endif /* #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV) */
1229
1230 /*
1231  * Memory allocation strategy... our layout is normally:
1232  *
1233  *  at 14Mb or more we have vmlinux, then a gap and initrd.  In some
1234  *  rare cases, initrd might end up being before the kernel though.
1235  *  We assume this won't override the final kernel at 0, we have no
1236  *  provision to handle that in this version, but it should hopefully
1237  *  never happen.
1238  *
1239  *  alloc_top is set to the top of RMO, eventually shrink down if the
1240  *  TCEs overlap
1241  *
1242  *  alloc_bottom is set to the top of kernel/initrd
1243  *
1244  *  from there, allocations are done this way : rtas is allocated
1245  *  topmost, and the device-tree is allocated from the bottom. We try
1246  *  to grow the device-tree allocation as we progress. If we can't,
1247  *  then we fail, we don't currently have a facility to restart
1248  *  elsewhere, but that shouldn't be necessary.
1249  *
1250  *  Note that calls to reserve_mem have to be done explicitly, memory
1251  *  allocated with either alloc_up or alloc_down isn't automatically
1252  *  reserved.
1253  */
1254
1255
1256 /*
1257  * Allocates memory in the RMO upward from the kernel/initrd
1258  *
1259  * When align is 0, this is a special case, it means to allocate in place
1260  * at the current location of alloc_bottom or fail (that is basically
1261  * extending the previous allocation). Used for the device-tree flattening
1262  */
1263 static unsigned long __init alloc_up(unsigned long size, unsigned long align)
1264 {
1265         unsigned long base = alloc_bottom;
1266         unsigned long addr = 0;
1267
1268         if (align)
1269                 base = _ALIGN_UP(base, align);
1270         prom_debug("%s(%lx, %lx)\n", __func__, size, align);
1271         if (ram_top == 0)
1272                 prom_panic("alloc_up() called with mem not initialized\n");
1273
1274         if (align)
1275                 base = _ALIGN_UP(alloc_bottom, align);
1276         else
1277                 base = alloc_bottom;
1278
1279         for(; (base + size) <= alloc_top;
1280             base = _ALIGN_UP(base + 0x100000, align)) {
1281                 prom_debug("    trying: 0x%lx\n\r", base);
1282                 addr = (unsigned long)prom_claim(base, size, 0);
1283                 if (addr != PROM_ERROR && addr != 0)
1284                         break;
1285                 addr = 0;
1286                 if (align == 0)
1287                         break;
1288         }
1289         if (addr == 0)
1290                 return 0;
1291         alloc_bottom = addr + size;
1292
1293         prom_debug(" -> %lx\n", addr);
1294         prom_debug("  alloc_bottom : %lx\n", alloc_bottom);
1295         prom_debug("  alloc_top    : %lx\n", alloc_top);
1296         prom_debug("  alloc_top_hi : %lx\n", alloc_top_high);
1297         prom_debug("  rmo_top      : %lx\n", rmo_top);
1298         prom_debug("  ram_top      : %lx\n", ram_top);
1299
1300         return addr;
1301 }
1302
1303 /*
1304  * Allocates memory downward, either from top of RMO, or if highmem
1305  * is set, from the top of RAM.  Note that this one doesn't handle
1306  * failures.  It does claim memory if highmem is not set.
1307  */
1308 static unsigned long __init alloc_down(unsigned long size, unsigned long align,
1309                                        int highmem)
1310 {
1311         unsigned long base, addr = 0;
1312
1313         prom_debug("%s(%lx, %lx, %s)\n", __func__, size, align,
1314                    highmem ? "(high)" : "(low)");
1315         if (ram_top == 0)
1316                 prom_panic("alloc_down() called with mem not initialized\n");
1317
1318         if (highmem) {
1319                 /* Carve out storage for the TCE table. */
1320                 addr = _ALIGN_DOWN(alloc_top_high - size, align);
1321                 if (addr <= alloc_bottom)
1322                         return 0;
1323                 /* Will we bump into the RMO ? If yes, check out that we
1324                  * didn't overlap existing allocations there, if we did,
1325                  * we are dead, we must be the first in town !
1326                  */
1327                 if (addr < rmo_top) {
1328                         /* Good, we are first */
1329                         if (alloc_top == rmo_top)
1330                                 alloc_top = rmo_top = addr;
1331                         else
1332                                 return 0;
1333                 }
1334                 alloc_top_high = addr;
1335                 goto bail;
1336         }
1337
1338         base = _ALIGN_DOWN(alloc_top - size, align);
1339         for (; base > alloc_bottom;
1340              base = _ALIGN_DOWN(base - 0x100000, align))  {
1341                 prom_debug("    trying: 0x%lx\n\r", base);
1342                 addr = (unsigned long)prom_claim(base, size, 0);
1343                 if (addr != PROM_ERROR && addr != 0)
1344                         break;
1345                 addr = 0;
1346         }
1347         if (addr == 0)
1348                 return 0;
1349         alloc_top = addr;
1350
1351  bail:
1352         prom_debug(" -> %lx\n", addr);
1353         prom_debug("  alloc_bottom : %lx\n", alloc_bottom);
1354         prom_debug("  alloc_top    : %lx\n", alloc_top);
1355         prom_debug("  alloc_top_hi : %lx\n", alloc_top_high);
1356         prom_debug("  rmo_top      : %lx\n", rmo_top);
1357         prom_debug("  ram_top      : %lx\n", ram_top);
1358
1359         return addr;
1360 }
1361
1362 /*
1363  * Parse a "reg" cell
1364  */
1365 static unsigned long __init prom_next_cell(int s, cell_t **cellp)
1366 {
1367         cell_t *p = *cellp;
1368         unsigned long r = 0;
1369
1370         /* Ignore more than 2 cells */
1371         while (s > sizeof(unsigned long) / 4) {
1372                 p++;
1373                 s--;
1374         }
1375         r = be32_to_cpu(*p++);
1376 #ifdef CONFIG_PPC64
1377         if (s > 1) {
1378                 r <<= 32;
1379                 r |= be32_to_cpu(*(p++));
1380         }
1381 #endif
1382         *cellp = p;
1383         return r;
1384 }
1385
1386 /*
1387  * Very dumb function for adding to the memory reserve list, but
1388  * we don't need anything smarter at this point
1389  *
1390  * XXX Eventually check for collisions.  They should NEVER happen.
1391  * If problems seem to show up, it would be a good start to track
1392  * them down.
1393  */
1394 static void __init reserve_mem(u64 base, u64 size)
1395 {
1396         u64 top = base + size;
1397         unsigned long cnt = mem_reserve_cnt;
1398
1399         if (size == 0)
1400                 return;
1401
1402         /* We need to always keep one empty entry so that we
1403          * have our terminator with "size" set to 0 since we are
1404          * dumb and just copy this entire array to the boot params
1405          */
1406         base = _ALIGN_DOWN(base, PAGE_SIZE);
1407         top = _ALIGN_UP(top, PAGE_SIZE);
1408         size = top - base;
1409
1410         if (cnt >= (MEM_RESERVE_MAP_SIZE - 1))
1411                 prom_panic("Memory reserve map exhausted !\n");
1412         mem_reserve_map[cnt].base = cpu_to_be64(base);
1413         mem_reserve_map[cnt].size = cpu_to_be64(size);
1414         mem_reserve_cnt = cnt + 1;
1415 }
1416
1417 /*
1418  * Initialize memory allocation mechanism, parse "memory" nodes and
1419  * obtain that way the top of memory and RMO to setup out local allocator
1420  */
1421 static void __init prom_init_mem(void)
1422 {
1423         phandle node;
1424         char *path, type[64];
1425         unsigned int plen;
1426         cell_t *p, *endp;
1427         __be32 val;
1428         u32 rac, rsc;
1429
1430         /*
1431          * We iterate the memory nodes to find
1432          * 1) top of RMO (first node)
1433          * 2) top of memory
1434          */
1435         val = cpu_to_be32(2);
1436         prom_getprop(prom.root, "#address-cells", &val, sizeof(val));
1437         rac = be32_to_cpu(val);
1438         val = cpu_to_be32(1);
1439         prom_getprop(prom.root, "#size-cells", &val, sizeof(rsc));
1440         rsc = be32_to_cpu(val);
1441         prom_debug("root_addr_cells: %x\n", rac);
1442         prom_debug("root_size_cells: %x\n", rsc);
1443
1444         prom_debug("scanning memory:\n");
1445         path = prom_scratch;
1446
1447         for (node = 0; prom_next_node(&node); ) {
1448                 type[0] = 0;
1449                 prom_getprop(node, "device_type", type, sizeof(type));
1450
1451                 if (type[0] == 0) {
1452                         /*
1453                          * CHRP Longtrail machines have no device_type
1454                          * on the memory node, so check the name instead...
1455                          */
1456                         prom_getprop(node, "name", type, sizeof(type));
1457                 }
1458                 if (strcmp(type, "memory"))
1459                         continue;
1460
1461                 plen = prom_getprop(node, "reg", regbuf, sizeof(regbuf));
1462                 if (plen > sizeof(regbuf)) {
1463                         prom_printf("memory node too large for buffer !\n");
1464                         plen = sizeof(regbuf);
1465                 }
1466                 p = regbuf;
1467                 endp = p + (plen / sizeof(cell_t));
1468
1469 #ifdef DEBUG_PROM
1470                 memset(path, 0, PROM_SCRATCH_SIZE);
1471                 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
1472                 prom_debug("  node %s :\n", path);
1473 #endif /* DEBUG_PROM */
1474
1475                 while ((endp - p) >= (rac + rsc)) {
1476                         unsigned long base, size;
1477
1478                         base = prom_next_cell(rac, &p);
1479                         size = prom_next_cell(rsc, &p);
1480
1481                         if (size == 0)
1482                                 continue;
1483                         prom_debug("    %lx %lx\n", base, size);
1484                         if (base == 0 && (of_platform & PLATFORM_LPAR))
1485                                 rmo_top = size;
1486                         if ((base + size) > ram_top)
1487                                 ram_top = base + size;
1488                 }
1489         }
1490
1491         alloc_bottom = PAGE_ALIGN((unsigned long)&_end + 0x4000);
1492
1493         /*
1494          * If prom_memory_limit is set we reduce the upper limits *except* for
1495          * alloc_top_high. This must be the real top of RAM so we can put
1496          * TCE's up there.
1497          */
1498
1499         alloc_top_high = ram_top;
1500
1501         if (prom_memory_limit) {
1502                 if (prom_memory_limit <= alloc_bottom) {
1503                         prom_printf("Ignoring mem=%lx <= alloc_bottom.\n",
1504                                     prom_memory_limit);
1505                         prom_memory_limit = 0;
1506                 } else if (prom_memory_limit >= ram_top) {
1507                         prom_printf("Ignoring mem=%lx >= ram_top.\n",
1508                                     prom_memory_limit);
1509                         prom_memory_limit = 0;
1510                 } else {
1511                         ram_top = prom_memory_limit;
1512                         rmo_top = min(rmo_top, prom_memory_limit);
1513                 }
1514         }
1515
1516         /*
1517          * Setup our top alloc point, that is top of RMO or top of
1518          * segment 0 when running non-LPAR.
1519          * Some RS64 machines have buggy firmware where claims up at
1520          * 1GB fail.  Cap at 768MB as a workaround.
1521          * Since 768MB is plenty of room, and we need to cap to something
1522          * reasonable on 32-bit, cap at 768MB on all machines.
1523          */
1524         if (!rmo_top)
1525                 rmo_top = ram_top;
1526         rmo_top = min(0x30000000ul, rmo_top);
1527         alloc_top = rmo_top;
1528         alloc_top_high = ram_top;
1529
1530         /*
1531          * Check if we have an initrd after the kernel but still inside
1532          * the RMO.  If we do move our bottom point to after it.
1533          */
1534         if (prom_initrd_start &&
1535             prom_initrd_start < rmo_top &&
1536             prom_initrd_end > alloc_bottom)
1537                 alloc_bottom = PAGE_ALIGN(prom_initrd_end);
1538
1539         prom_printf("memory layout at init:\n");
1540         prom_printf("  memory_limit : %lx (16 MB aligned)\n",
1541                     prom_memory_limit);
1542         prom_printf("  alloc_bottom : %lx\n", alloc_bottom);
1543         prom_printf("  alloc_top    : %lx\n", alloc_top);
1544         prom_printf("  alloc_top_hi : %lx\n", alloc_top_high);
1545         prom_printf("  rmo_top      : %lx\n", rmo_top);
1546         prom_printf("  ram_top      : %lx\n", ram_top);
1547 }
1548
1549 static void __init prom_close_stdin(void)
1550 {
1551         __be32 val;
1552         ihandle stdin;
1553
1554         if (prom_getprop(prom.chosen, "stdin", &val, sizeof(val)) > 0) {
1555                 stdin = be32_to_cpu(val);
1556                 call_prom("close", 1, 0, stdin);
1557         }
1558 }
1559
1560 #ifdef CONFIG_PPC_POWERNV
1561
1562 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
1563 static u64 __initdata prom_opal_base;
1564 static u64 __initdata prom_opal_entry;
1565 #endif
1566
1567 /*
1568  * Allocate room for and instantiate OPAL
1569  */
1570 static void __init prom_instantiate_opal(void)
1571 {
1572         phandle opal_node;
1573         ihandle opal_inst;
1574         u64 base, entry;
1575         u64 size = 0, align = 0x10000;
1576         __be64 val64;
1577         u32 rets[2];
1578
1579         prom_debug("prom_instantiate_opal: start...\n");
1580
1581         opal_node = call_prom("finddevice", 1, 1, ADDR("/ibm,opal"));
1582         prom_debug("opal_node: %x\n", opal_node);
1583         if (!PHANDLE_VALID(opal_node))
1584                 return;
1585
1586         val64 = 0;
1587         prom_getprop(opal_node, "opal-runtime-size", &val64, sizeof(val64));
1588         size = be64_to_cpu(val64);
1589         if (size == 0)
1590                 return;
1591         val64 = 0;
1592         prom_getprop(opal_node, "opal-runtime-alignment", &val64,sizeof(val64));
1593         align = be64_to_cpu(val64);
1594
1595         base = alloc_down(size, align, 0);
1596         if (base == 0) {
1597                 prom_printf("OPAL allocation failed !\n");
1598                 return;
1599         }
1600
1601         opal_inst = call_prom("open", 1, 1, ADDR("/ibm,opal"));
1602         if (!IHANDLE_VALID(opal_inst)) {
1603                 prom_printf("opening opal package failed (%x)\n", opal_inst);
1604                 return;
1605         }
1606
1607         prom_printf("instantiating opal at 0x%llx...", base);
1608
1609         if (call_prom_ret("call-method", 4, 3, rets,
1610                           ADDR("load-opal-runtime"),
1611                           opal_inst,
1612                           base >> 32, base & 0xffffffff) != 0
1613             || (rets[0] == 0 && rets[1] == 0)) {
1614                 prom_printf(" failed\n");
1615                 return;
1616         }
1617         entry = (((u64)rets[0]) << 32) | rets[1];
1618
1619         prom_printf(" done\n");
1620
1621         reserve_mem(base, size);
1622
1623         prom_debug("opal base     = 0x%llx\n", base);
1624         prom_debug("opal align    = 0x%llx\n", align);
1625         prom_debug("opal entry    = 0x%llx\n", entry);
1626         prom_debug("opal size     = 0x%llx\n", size);
1627
1628         prom_setprop(opal_node, "/ibm,opal", "opal-base-address",
1629                      &base, sizeof(base));
1630         prom_setprop(opal_node, "/ibm,opal", "opal-entry-address",
1631                      &entry, sizeof(entry));
1632
1633 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
1634         prom_opal_base = base;
1635         prom_opal_entry = entry;
1636 #endif
1637         prom_debug("prom_instantiate_opal: end...\n");
1638 }
1639
1640 #endif /* CONFIG_PPC_POWERNV */
1641
1642 /*
1643  * Allocate room for and instantiate RTAS
1644  */
1645 static void __init prom_instantiate_rtas(void)
1646 {
1647         phandle rtas_node;
1648         ihandle rtas_inst;
1649         u32 base, entry = 0;
1650         __be32 val;
1651         u32 size = 0;
1652
1653         prom_debug("prom_instantiate_rtas: start...\n");
1654
1655         rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1656         prom_debug("rtas_node: %x\n", rtas_node);
1657         if (!PHANDLE_VALID(rtas_node))
1658                 return;
1659
1660         val = 0;
1661         prom_getprop(rtas_node, "rtas-size", &val, sizeof(size));
1662         size = be32_to_cpu(val);
1663         if (size == 0)
1664                 return;
1665
1666         base = alloc_down(size, PAGE_SIZE, 0);
1667         if (base == 0)
1668                 prom_panic("Could not allocate memory for RTAS\n");
1669
1670         rtas_inst = call_prom("open", 1, 1, ADDR("/rtas"));
1671         if (!IHANDLE_VALID(rtas_inst)) {
1672                 prom_printf("opening rtas package failed (%x)\n", rtas_inst);
1673                 return;
1674         }
1675
1676         prom_printf("instantiating rtas at 0x%x...", base);
1677
1678         if (call_prom_ret("call-method", 3, 2, &entry,
1679                           ADDR("instantiate-rtas"),
1680                           rtas_inst, base) != 0
1681             || entry == 0) {
1682                 prom_printf(" failed\n");
1683                 return;
1684         }
1685         prom_printf(" done\n");
1686
1687         reserve_mem(base, size);
1688
1689         val = cpu_to_be32(base);
1690         prom_setprop(rtas_node, "/rtas", "linux,rtas-base",
1691                      &val, sizeof(val));
1692         val = cpu_to_be32(entry);
1693         prom_setprop(rtas_node, "/rtas", "linux,rtas-entry",
1694                      &val, sizeof(val));
1695
1696         /* Check if it supports "query-cpu-stopped-state" */
1697         if (prom_getprop(rtas_node, "query-cpu-stopped-state",
1698                          &val, sizeof(val)) != PROM_ERROR)
1699                 rtas_has_query_cpu_stopped = true;
1700
1701         prom_debug("rtas base     = 0x%x\n", base);
1702         prom_debug("rtas entry    = 0x%x\n", entry);
1703         prom_debug("rtas size     = 0x%x\n", size);
1704
1705         prom_debug("prom_instantiate_rtas: end...\n");
1706 }
1707
1708 #ifdef CONFIG_PPC64
1709 /*
1710  * Allocate room for and instantiate Stored Measurement Log (SML)
1711  */
1712 static void __init prom_instantiate_sml(void)
1713 {
1714         phandle ibmvtpm_node;
1715         ihandle ibmvtpm_inst;
1716         u32 entry = 0, size = 0, succ = 0;
1717         u64 base;
1718         __be32 val;
1719
1720         prom_debug("prom_instantiate_sml: start...\n");
1721
1722         ibmvtpm_node = call_prom("finddevice", 1, 1, ADDR("/vdevice/vtpm"));
1723         prom_debug("ibmvtpm_node: %x\n", ibmvtpm_node);
1724         if (!PHANDLE_VALID(ibmvtpm_node))
1725                 return;
1726
1727         ibmvtpm_inst = call_prom("open", 1, 1, ADDR("/vdevice/vtpm"));
1728         if (!IHANDLE_VALID(ibmvtpm_inst)) {
1729                 prom_printf("opening vtpm package failed (%x)\n", ibmvtpm_inst);
1730                 return;
1731         }
1732
1733         if (prom_getprop(ibmvtpm_node, "ibm,sml-efi-reformat-supported",
1734                          &val, sizeof(val)) != PROM_ERROR) {
1735                 if (call_prom_ret("call-method", 2, 2, &succ,
1736                                   ADDR("reformat-sml-to-efi-alignment"),
1737                                   ibmvtpm_inst) != 0 || succ == 0) {
1738                         prom_printf("Reformat SML to EFI alignment failed\n");
1739                         return;
1740                 }
1741
1742                 if (call_prom_ret("call-method", 2, 2, &size,
1743                                   ADDR("sml-get-allocated-size"),
1744                                   ibmvtpm_inst) != 0 || size == 0) {
1745                         prom_printf("SML get allocated size failed\n");
1746                         return;
1747                 }
1748         } else {
1749                 if (call_prom_ret("call-method", 2, 2, &size,
1750                                   ADDR("sml-get-handover-size"),
1751                                   ibmvtpm_inst) != 0 || size == 0) {
1752                         prom_printf("SML get handover size failed\n");
1753                         return;
1754                 }
1755         }
1756
1757         base = alloc_down(size, PAGE_SIZE, 0);
1758         if (base == 0)
1759                 prom_panic("Could not allocate memory for sml\n");
1760
1761         prom_printf("instantiating sml at 0x%llx...", base);
1762
1763         memset((void *)base, 0, size);
1764
1765         if (call_prom_ret("call-method", 4, 2, &entry,
1766                           ADDR("sml-handover"),
1767                           ibmvtpm_inst, size, base) != 0 || entry == 0) {
1768                 prom_printf("SML handover failed\n");
1769                 return;
1770         }
1771         prom_printf(" done\n");
1772
1773         reserve_mem(base, size);
1774
1775         prom_setprop(ibmvtpm_node, "/vdevice/vtpm", "linux,sml-base",
1776                      &base, sizeof(base));
1777         prom_setprop(ibmvtpm_node, "/vdevice/vtpm", "linux,sml-size",
1778                      &size, sizeof(size));
1779
1780         prom_debug("sml base     = 0x%llx\n", base);
1781         prom_debug("sml size     = 0x%x\n", size);
1782
1783         prom_debug("prom_instantiate_sml: end...\n");
1784 }
1785
1786 /*
1787  * Allocate room for and initialize TCE tables
1788  */
1789 #ifdef __BIG_ENDIAN__
1790 static void __init prom_initialize_tce_table(void)
1791 {
1792         phandle node;
1793         ihandle phb_node;
1794         char compatible[64], type[64], model[64];
1795         char *path = prom_scratch;
1796         u64 base, align;
1797         u32 minalign, minsize;
1798         u64 tce_entry, *tce_entryp;
1799         u64 local_alloc_top, local_alloc_bottom;
1800         u64 i;
1801
1802         if (prom_iommu_off)
1803                 return;
1804
1805         prom_debug("starting prom_initialize_tce_table\n");
1806
1807         /* Cache current top of allocs so we reserve a single block */
1808         local_alloc_top = alloc_top_high;
1809         local_alloc_bottom = local_alloc_top;
1810
1811         /* Search all nodes looking for PHBs. */
1812         for (node = 0; prom_next_node(&node); ) {
1813                 compatible[0] = 0;
1814                 type[0] = 0;
1815                 model[0] = 0;
1816                 prom_getprop(node, "compatible",
1817                              compatible, sizeof(compatible));
1818                 prom_getprop(node, "device_type", type, sizeof(type));
1819                 prom_getprop(node, "model", model, sizeof(model));
1820
1821                 if ((type[0] == 0) || (strstr(type, "pci") == NULL))
1822                         continue;
1823
1824                 /* Keep the old logic intact to avoid regression. */
1825                 if (compatible[0] != 0) {
1826                         if ((strstr(compatible, "python") == NULL) &&
1827                             (strstr(compatible, "Speedwagon") == NULL) &&
1828                             (strstr(compatible, "Winnipeg") == NULL))
1829                                 continue;
1830                 } else if (model[0] != 0) {
1831                         if ((strstr(model, "ython") == NULL) &&
1832                             (strstr(model, "peedwagon") == NULL) &&
1833                             (strstr(model, "innipeg") == NULL))
1834                                 continue;
1835                 }
1836
1837                 if (prom_getprop(node, "tce-table-minalign", &minalign,
1838                                  sizeof(minalign)) == PROM_ERROR)
1839                         minalign = 0;
1840                 if (prom_getprop(node, "tce-table-minsize", &minsize,
1841                                  sizeof(minsize)) == PROM_ERROR)
1842                         minsize = 4UL << 20;
1843
1844                 /*
1845                  * Even though we read what OF wants, we just set the table
1846                  * size to 4 MB.  This is enough to map 2GB of PCI DMA space.
1847                  * By doing this, we avoid the pitfalls of trying to DMA to
1848                  * MMIO space and the DMA alias hole.
1849                  */
1850                 minsize = 4UL << 20;
1851
1852                 /* Align to the greater of the align or size */
1853                 align = max(minalign, minsize);
1854                 base = alloc_down(minsize, align, 1);
1855                 if (base == 0)
1856                         prom_panic("ERROR, cannot find space for TCE table.\n");
1857                 if (base < local_alloc_bottom)
1858                         local_alloc_bottom = base;
1859
1860                 /* It seems OF doesn't null-terminate the path :-( */
1861                 memset(path, 0, PROM_SCRATCH_SIZE);
1862                 /* Call OF to setup the TCE hardware */
1863                 if (call_prom("package-to-path", 3, 1, node,
1864                               path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) {
1865                         prom_printf("package-to-path failed\n");
1866                 }
1867
1868                 /* Save away the TCE table attributes for later use. */
1869                 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base));
1870                 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize));
1871
1872                 prom_debug("TCE table: %s\n", path);
1873                 prom_debug("\tnode = 0x%x\n", node);
1874                 prom_debug("\tbase = 0x%llx\n", base);
1875                 prom_debug("\tsize = 0x%x\n", minsize);
1876
1877                 /* Initialize the table to have a one-to-one mapping
1878                  * over the allocated size.
1879                  */
1880                 tce_entryp = (u64 *)base;
1881                 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) {
1882                         tce_entry = (i << PAGE_SHIFT);
1883                         tce_entry |= 0x3;
1884                         *tce_entryp = tce_entry;
1885                 }
1886
1887                 prom_printf("opening PHB %s", path);
1888                 phb_node = call_prom("open", 1, 1, path);
1889                 if (phb_node == 0)
1890                         prom_printf("... failed\n");
1891                 else
1892                         prom_printf("... done\n");
1893
1894                 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"),
1895                           phb_node, -1, minsize,
1896                           (u32) base, (u32) (base >> 32));
1897                 call_prom("close", 1, 0, phb_node);
1898         }
1899
1900         reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom);
1901
1902         /* These are only really needed if there is a memory limit in
1903          * effect, but we don't know so export them always. */
1904         prom_tce_alloc_start = local_alloc_bottom;
1905         prom_tce_alloc_end = local_alloc_top;
1906
1907         /* Flag the first invalid entry */
1908         prom_debug("ending prom_initialize_tce_table\n");
1909 }
1910 #endif /* __BIG_ENDIAN__ */
1911 #endif /* CONFIG_PPC64 */
1912
1913 /*
1914  * With CHRP SMP we need to use the OF to start the other processors.
1915  * We can't wait until smp_boot_cpus (the OF is trashed by then)
1916  * so we have to put the processors into a holding pattern controlled
1917  * by the kernel (not OF) before we destroy the OF.
1918  *
1919  * This uses a chunk of low memory, puts some holding pattern
1920  * code there and sends the other processors off to there until
1921  * smp_boot_cpus tells them to do something.  The holding pattern
1922  * checks that address until its cpu # is there, when it is that
1923  * cpu jumps to __secondary_start().  smp_boot_cpus() takes care
1924  * of setting those values.
1925  *
1926  * We also use physical address 0x4 here to tell when a cpu
1927  * is in its holding pattern code.
1928  *
1929  * -- Cort
1930  */
1931 /*
1932  * We want to reference the copy of __secondary_hold_* in the
1933  * 0 - 0x100 address range
1934  */
1935 #define LOW_ADDR(x)     (((unsigned long) &(x)) & 0xff)
1936
1937 static void __init prom_hold_cpus(void)
1938 {
1939         unsigned long i;
1940         phandle node;
1941         char type[64];
1942         unsigned long *spinloop
1943                 = (void *) LOW_ADDR(__secondary_hold_spinloop);
1944         unsigned long *acknowledge
1945                 = (void *) LOW_ADDR(__secondary_hold_acknowledge);
1946         unsigned long secondary_hold = LOW_ADDR(__secondary_hold);
1947
1948         /*
1949          * On pseries, if RTAS supports "query-cpu-stopped-state",
1950          * we skip this stage, the CPUs will be started by the
1951          * kernel using RTAS.
1952          */
1953         if ((of_platform == PLATFORM_PSERIES ||
1954              of_platform == PLATFORM_PSERIES_LPAR) &&
1955             rtas_has_query_cpu_stopped) {
1956                 prom_printf("prom_hold_cpus: skipped\n");
1957                 return;
1958         }
1959
1960         prom_debug("prom_hold_cpus: start...\n");
1961         prom_debug("    1) spinloop       = 0x%lx\n", (unsigned long)spinloop);
1962         prom_debug("    1) *spinloop      = 0x%lx\n", *spinloop);
1963         prom_debug("    1) acknowledge    = 0x%lx\n",
1964                    (unsigned long)acknowledge);
1965         prom_debug("    1) *acknowledge   = 0x%lx\n", *acknowledge);
1966         prom_debug("    1) secondary_hold = 0x%lx\n", secondary_hold);
1967
1968         /* Set the common spinloop variable, so all of the secondary cpus
1969          * will block when they are awakened from their OF spinloop.
1970          * This must occur for both SMP and non SMP kernels, since OF will
1971          * be trashed when we move the kernel.
1972          */
1973         *spinloop = 0;
1974
1975         /* look for cpus */
1976         for (node = 0; prom_next_node(&node); ) {
1977                 unsigned int cpu_no;
1978                 __be32 reg;
1979
1980                 type[0] = 0;
1981                 prom_getprop(node, "device_type", type, sizeof(type));
1982                 if (strcmp(type, "cpu") != 0)
1983                         continue;
1984
1985                 /* Skip non-configured cpus. */
1986                 if (prom_getprop(node, "status", type, sizeof(type)) > 0)
1987                         if (strcmp(type, "okay") != 0)
1988                                 continue;
1989
1990                 reg = cpu_to_be32(-1); /* make sparse happy */
1991                 prom_getprop(node, "reg", &reg, sizeof(reg));
1992                 cpu_no = be32_to_cpu(reg);
1993
1994                 prom_debug("cpu hw idx   = %u\n", cpu_no);
1995
1996                 /* Init the acknowledge var which will be reset by
1997                  * the secondary cpu when it awakens from its OF
1998                  * spinloop.
1999                  */
2000                 *acknowledge = (unsigned long)-1;
2001
2002                 if (cpu_no != prom.cpu) {
2003                         /* Primary Thread of non-boot cpu or any thread */
2004                         prom_printf("starting cpu hw idx %u... ", cpu_no);
2005                         call_prom("start-cpu", 3, 0, node,
2006                                   secondary_hold, cpu_no);
2007
2008                         for (i = 0; (i < 100000000) &&
2009                              (*acknowledge == ((unsigned long)-1)); i++ )
2010                                 mb();
2011
2012                         if (*acknowledge == cpu_no)
2013                                 prom_printf("done\n");
2014                         else
2015                                 prom_printf("failed: %lx\n", *acknowledge);
2016                 }
2017 #ifdef CONFIG_SMP
2018                 else
2019                         prom_printf("boot cpu hw idx %u\n", cpu_no);
2020 #endif /* CONFIG_SMP */
2021         }
2022
2023         prom_debug("prom_hold_cpus: end...\n");
2024 }
2025
2026
2027 static void __init prom_init_client_services(unsigned long pp)
2028 {
2029         /* Get a handle to the prom entry point before anything else */
2030         prom_entry = pp;
2031
2032         /* get a handle for the stdout device */
2033         prom.chosen = call_prom("finddevice", 1, 1, ADDR("/chosen"));
2034         if (!PHANDLE_VALID(prom.chosen))
2035                 prom_panic("cannot find chosen"); /* msg won't be printed :( */
2036
2037         /* get device tree root */
2038         prom.root = call_prom("finddevice", 1, 1, ADDR("/"));
2039         if (!PHANDLE_VALID(prom.root))
2040                 prom_panic("cannot find device tree root"); /* msg won't be printed :( */
2041
2042         prom.mmumap = 0;
2043 }
2044
2045 #ifdef CONFIG_PPC32
2046 /*
2047  * For really old powermacs, we need to map things we claim.
2048  * For that, we need the ihandle of the mmu.
2049  * Also, on the longtrail, we need to work around other bugs.
2050  */
2051 static void __init prom_find_mmu(void)
2052 {
2053         phandle oprom;
2054         char version[64];
2055
2056         oprom = call_prom("finddevice", 1, 1, ADDR("/openprom"));
2057         if (!PHANDLE_VALID(oprom))
2058                 return;
2059         if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0)
2060                 return;
2061         version[sizeof(version) - 1] = 0;
2062         /* XXX might need to add other versions here */
2063         if (strcmp(version, "Open Firmware, 1.0.5") == 0)
2064                 of_workarounds = OF_WA_CLAIM;
2065         else if (strncmp(version, "FirmWorks,3.", 12) == 0) {
2066                 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL;
2067                 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim");
2068         } else
2069                 return;
2070         prom.memory = call_prom("open", 1, 1, ADDR("/memory"));
2071         prom_getprop(prom.chosen, "mmu", &prom.mmumap,
2072                      sizeof(prom.mmumap));
2073         prom.mmumap = be32_to_cpu(prom.mmumap);
2074         if (!IHANDLE_VALID(prom.memory) || !IHANDLE_VALID(prom.mmumap))
2075                 of_workarounds &= ~OF_WA_CLAIM;         /* hmmm */
2076 }
2077 #else
2078 #define prom_find_mmu()
2079 #endif
2080
2081 static void __init prom_init_stdout(void)
2082 {
2083         char *path = of_stdout_device;
2084         char type[16];
2085         phandle stdout_node;
2086         __be32 val;
2087
2088         if (prom_getprop(prom.chosen, "stdout", &val, sizeof(val)) <= 0)
2089                 prom_panic("cannot find stdout");
2090
2091         prom.stdout = be32_to_cpu(val);
2092
2093         /* Get the full OF pathname of the stdout device */
2094         memset(path, 0, 256);
2095         call_prom("instance-to-path", 3, 1, prom.stdout, path, 255);
2096         prom_printf("OF stdout device is: %s\n", of_stdout_device);
2097         prom_setprop(prom.chosen, "/chosen", "linux,stdout-path",
2098                      path, strlen(path) + 1);
2099
2100         /* instance-to-package fails on PA-Semi */
2101         stdout_node = call_prom("instance-to-package", 1, 1, prom.stdout);
2102         if (stdout_node != PROM_ERROR) {
2103                 val = cpu_to_be32(stdout_node);
2104
2105                 /* If it's a display, note it */
2106                 memset(type, 0, sizeof(type));
2107                 prom_getprop(stdout_node, "device_type", type, sizeof(type));
2108                 if (strcmp(type, "display") == 0)
2109                         prom_setprop(stdout_node, path, "linux,boot-display", NULL, 0);
2110         }
2111 }
2112
2113 static int __init prom_find_machine_type(void)
2114 {
2115         char compat[256];
2116         int len, i = 0;
2117 #ifdef CONFIG_PPC64
2118         phandle rtas;
2119         int x;
2120 #endif
2121
2122         /* Look for a PowerMac or a Cell */
2123         len = prom_getprop(prom.root, "compatible",
2124                            compat, sizeof(compat)-1);
2125         if (len > 0) {
2126                 compat[len] = 0;
2127                 while (i < len) {
2128                         char *p = &compat[i];
2129                         int sl = strlen(p);
2130                         if (sl == 0)
2131                                 break;
2132                         if (strstr(p, "Power Macintosh") ||
2133                             strstr(p, "MacRISC"))
2134                                 return PLATFORM_POWERMAC;
2135 #ifdef CONFIG_PPC64
2136                         /* We must make sure we don't detect the IBM Cell
2137                          * blades as pSeries due to some firmware issues,
2138                          * so we do it here.
2139                          */
2140                         if (strstr(p, "IBM,CBEA") ||
2141                             strstr(p, "IBM,CPBW-1.0"))
2142                                 return PLATFORM_GENERIC;
2143 #endif /* CONFIG_PPC64 */
2144                         i += sl + 1;
2145                 }
2146         }
2147 #ifdef CONFIG_PPC64
2148         /* Try to detect OPAL */
2149         if (PHANDLE_VALID(call_prom("finddevice", 1, 1, ADDR("/ibm,opal"))))
2150                 return PLATFORM_OPAL;
2151
2152         /* Try to figure out if it's an IBM pSeries or any other
2153          * PAPR compliant platform. We assume it is if :
2154          *  - /device_type is "chrp" (please, do NOT use that for future
2155          *    non-IBM designs !
2156          *  - it has /rtas
2157          */
2158         len = prom_getprop(prom.root, "device_type",
2159                            compat, sizeof(compat)-1);
2160         if (len <= 0)
2161                 return PLATFORM_GENERIC;
2162         if (strcmp(compat, "chrp"))
2163                 return PLATFORM_GENERIC;
2164
2165         /* Default to pSeries. We need to know if we are running LPAR */
2166         rtas = call_prom("finddevice", 1, 1, ADDR("/rtas"));
2167         if (!PHANDLE_VALID(rtas))
2168                 return PLATFORM_GENERIC;
2169         x = prom_getproplen(rtas, "ibm,hypertas-functions");
2170         if (x != PROM_ERROR) {
2171                 prom_debug("Hypertas detected, assuming LPAR !\n");
2172                 return PLATFORM_PSERIES_LPAR;
2173         }
2174         return PLATFORM_PSERIES;
2175 #else
2176         return PLATFORM_GENERIC;
2177 #endif
2178 }
2179
2180 static int __init prom_set_color(ihandle ih, int i, int r, int g, int b)
2181 {
2182         return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r);
2183 }
2184
2185 /*
2186  * If we have a display that we don't know how to drive,
2187  * we will want to try to execute OF's open method for it
2188  * later.  However, OF will probably fall over if we do that
2189  * we've taken over the MMU.
2190  * So we check whether we will need to open the display,
2191  * and if so, open it now.
2192  */
2193 static void __init prom_check_displays(void)
2194 {
2195         char type[16], *path;
2196         phandle node;
2197         ihandle ih;
2198         int i;
2199
2200         static unsigned char default_colors[] = {
2201                 0x00, 0x00, 0x00,
2202                 0x00, 0x00, 0xaa,
2203                 0x00, 0xaa, 0x00,
2204                 0x00, 0xaa, 0xaa,
2205                 0xaa, 0x00, 0x00,
2206                 0xaa, 0x00, 0xaa,
2207                 0xaa, 0xaa, 0x00,
2208                 0xaa, 0xaa, 0xaa,
2209                 0x55, 0x55, 0x55,
2210                 0x55, 0x55, 0xff,
2211                 0x55, 0xff, 0x55,
2212                 0x55, 0xff, 0xff,
2213                 0xff, 0x55, 0x55,
2214                 0xff, 0x55, 0xff,
2215                 0xff, 0xff, 0x55,
2216                 0xff, 0xff, 0xff
2217         };
2218         const unsigned char *clut;
2219
2220         prom_debug("Looking for displays\n");
2221         for (node = 0; prom_next_node(&node); ) {
2222                 memset(type, 0, sizeof(type));
2223                 prom_getprop(node, "device_type", type, sizeof(type));
2224                 if (strcmp(type, "display") != 0)
2225                         continue;
2226
2227                 /* It seems OF doesn't null-terminate the path :-( */
2228                 path = prom_scratch;
2229                 memset(path, 0, PROM_SCRATCH_SIZE);
2230
2231                 /*
2232                  * leave some room at the end of the path for appending extra
2233                  * arguments
2234                  */
2235                 if (call_prom("package-to-path", 3, 1, node, path,
2236                               PROM_SCRATCH_SIZE-10) == PROM_ERROR)
2237                         continue;
2238                 prom_printf("found display   : %s, opening... ", path);
2239
2240                 ih = call_prom("open", 1, 1, path);
2241                 if (ih == 0) {
2242                         prom_printf("failed\n");
2243                         continue;
2244                 }
2245
2246                 /* Success */
2247                 prom_printf("done\n");
2248                 prom_setprop(node, path, "linux,opened", NULL, 0);
2249
2250                 /* Setup a usable color table when the appropriate
2251                  * method is available. Should update this to set-colors */
2252                 clut = default_colors;
2253                 for (i = 0; i < 16; i++, clut += 3)
2254                         if (prom_set_color(ih, i, clut[0], clut[1],
2255                                            clut[2]) != 0)
2256                                 break;
2257
2258 #ifdef CONFIG_LOGO_LINUX_CLUT224
2259                 clut = PTRRELOC(logo_linux_clut224.clut);
2260                 for (i = 0; i < logo_linux_clut224.clutsize; i++, clut += 3)
2261                         if (prom_set_color(ih, i + 32, clut[0], clut[1],
2262                                            clut[2]) != 0)
2263                                 break;
2264 #endif /* CONFIG_LOGO_LINUX_CLUT224 */
2265
2266 #ifdef CONFIG_PPC_EARLY_DEBUG_BOOTX
2267                 if (prom_getprop(node, "linux,boot-display", NULL, 0) !=
2268                     PROM_ERROR) {
2269                         u32 width, height, pitch, addr;
2270
2271                         prom_printf("Setting btext !\n");
2272                         prom_getprop(node, "width", &width, 4);
2273                         prom_getprop(node, "height", &height, 4);
2274                         prom_getprop(node, "linebytes", &pitch, 4);
2275                         prom_getprop(node, "address", &addr, 4);
2276                         prom_printf("W=%d H=%d LB=%d addr=0x%x\n",
2277                                     width, height, pitch, addr);
2278                         btext_setup_display(width, height, 8, pitch, addr);
2279                 }
2280 #endif /* CONFIG_PPC_EARLY_DEBUG_BOOTX */
2281         }
2282 }
2283
2284
2285 /* Return (relocated) pointer to this much memory: moves initrd if reqd. */
2286 static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end,
2287                               unsigned long needed, unsigned long align)
2288 {
2289         void *ret;
2290
2291         *mem_start = _ALIGN(*mem_start, align);
2292         while ((*mem_start + needed) > *mem_end) {
2293                 unsigned long room, chunk;
2294
2295                 prom_debug("Chunk exhausted, claiming more at %lx...\n",
2296                            alloc_bottom);
2297                 room = alloc_top - alloc_bottom;
2298                 if (room > DEVTREE_CHUNK_SIZE)
2299                         room = DEVTREE_CHUNK_SIZE;
2300                 if (room < PAGE_SIZE)
2301                         prom_panic("No memory for flatten_device_tree "
2302                                    "(no room)\n");
2303                 chunk = alloc_up(room, 0);
2304                 if (chunk == 0)
2305                         prom_panic("No memory for flatten_device_tree "
2306                                    "(claim failed)\n");
2307                 *mem_end = chunk + room;
2308         }
2309
2310         ret = (void *)*mem_start;
2311         *mem_start += needed;
2312
2313         return ret;
2314 }
2315
2316 #define dt_push_token(token, mem_start, mem_end) do {                   \
2317                 void *room = make_room(mem_start, mem_end, 4, 4);       \
2318                 *(__be32 *)room = cpu_to_be32(token);                   \
2319         } while(0)
2320
2321 static unsigned long __init dt_find_string(char *str)
2322 {
2323         char *s, *os;
2324
2325         s = os = (char *)dt_string_start;
2326         s += 4;
2327         while (s <  (char *)dt_string_end) {
2328                 if (strcmp(s, str) == 0)
2329                         return s - os;
2330                 s += strlen(s) + 1;
2331         }
2332         return 0;
2333 }
2334
2335 /*
2336  * The Open Firmware 1275 specification states properties must be 31 bytes or
2337  * less, however not all firmwares obey this. Make it 64 bytes to be safe.
2338  */
2339 #define MAX_PROPERTY_NAME 64
2340
2341 static void __init scan_dt_build_strings(phandle node,
2342                                          unsigned long *mem_start,
2343                                          unsigned long *mem_end)
2344 {
2345         char *prev_name, *namep, *sstart;
2346         unsigned long soff;
2347         phandle child;
2348
2349         sstart =  (char *)dt_string_start;
2350
2351         /* get and store all property names */
2352         prev_name = "";
2353         for (;;) {
2354                 /* 64 is max len of name including nul. */
2355                 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1);
2356                 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) {
2357                         /* No more nodes: unwind alloc */
2358                         *mem_start = (unsigned long)namep;
2359                         break;
2360                 }
2361
2362                 /* skip "name" */
2363                 if (strcmp(namep, "name") == 0) {
2364                         *mem_start = (unsigned long)namep;
2365                         prev_name = "name";
2366                         continue;
2367                 }
2368                 /* get/create string entry */
2369                 soff = dt_find_string(namep);
2370                 if (soff != 0) {
2371                         *mem_start = (unsigned long)namep;
2372                         namep = sstart + soff;
2373                 } else {
2374                         /* Trim off some if we can */
2375                         *mem_start = (unsigned long)namep + strlen(namep) + 1;
2376                         dt_string_end = *mem_start;
2377                 }
2378                 prev_name = namep;
2379         }
2380
2381         /* do all our children */
2382         child = call_prom("child", 1, 1, node);
2383         while (child != 0) {
2384                 scan_dt_build_strings(child, mem_start, mem_end);
2385                 child = call_prom("peer", 1, 1, child);
2386         }
2387 }
2388
2389 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
2390                                         unsigned long *mem_end)
2391 {
2392         phandle child;
2393         char *namep, *prev_name, *sstart, *p, *ep, *lp, *path;
2394         unsigned long soff;
2395         unsigned char *valp;
2396         static char pname[MAX_PROPERTY_NAME];
2397         int l, room, has_phandle = 0;
2398
2399         dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end);
2400
2401         /* get the node's full name */
2402         namep = (char *)*mem_start;
2403         room = *mem_end - *mem_start;
2404         if (room > 255)
2405                 room = 255;
2406         l = call_prom("package-to-path", 3, 1, node, namep, room);
2407         if (l >= 0) {
2408                 /* Didn't fit?  Get more room. */
2409                 if (l >= room) {
2410                         if (l >= *mem_end - *mem_start)
2411                                 namep = make_room(mem_start, mem_end, l+1, 1);
2412                         call_prom("package-to-path", 3, 1, node, namep, l);
2413                 }
2414                 namep[l] = '\0';
2415
2416                 /* Fixup an Apple bug where they have bogus \0 chars in the
2417                  * middle of the path in some properties, and extract
2418                  * the unit name (everything after the last '/').
2419                  */
2420                 for (lp = p = namep, ep = namep + l; p < ep; p++) {
2421                         if (*p == '/')
2422                                 lp = namep;
2423                         else if (*p != 0)
2424                                 *lp++ = *p;
2425                 }
2426                 *lp = 0;
2427                 *mem_start = _ALIGN((unsigned long)lp + 1, 4);
2428         }
2429
2430         /* get it again for debugging */
2431         path = prom_scratch;
2432         memset(path, 0, PROM_SCRATCH_SIZE);
2433         call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
2434
2435         /* get and store all properties */
2436         prev_name = "";
2437         sstart = (char *)dt_string_start;
2438         for (;;) {
2439                 if (call_prom("nextprop", 3, 1, node, prev_name,
2440                               pname) != 1)
2441                         break;
2442
2443                 /* skip "name" */
2444                 if (strcmp(pname, "name") == 0) {
2445                         prev_name = "name";
2446                         continue;
2447                 }
2448
2449                 /* find string offset */
2450                 soff = dt_find_string(pname);
2451                 if (soff == 0) {
2452                         prom_printf("WARNING: Can't find string index for"
2453                                     " <%s>, node %s\n", pname, path);
2454                         break;
2455                 }
2456                 prev_name = sstart + soff;
2457
2458                 /* get length */
2459                 l = call_prom("getproplen", 2, 1, node, pname);
2460
2461                 /* sanity checks */
2462                 if (l == PROM_ERROR)
2463                         continue;
2464
2465                 /* push property head */
2466                 dt_push_token(OF_DT_PROP, mem_start, mem_end);
2467                 dt_push_token(l, mem_start, mem_end);
2468                 dt_push_token(soff, mem_start, mem_end);
2469
2470                 /* push property content */
2471                 valp = make_room(mem_start, mem_end, l, 4);
2472                 call_prom("getprop", 4, 1, node, pname, valp, l);
2473                 *mem_start = _ALIGN(*mem_start, 4);
2474
2475                 if (!strcmp(pname, "phandle"))
2476                         has_phandle = 1;
2477         }
2478
2479         /* Add a "linux,phandle" property if no "phandle" property already
2480          * existed (can happen with OPAL)
2481          */
2482         if (!has_phandle) {
2483                 soff = dt_find_string("linux,phandle");
2484                 if (soff == 0)
2485                         prom_printf("WARNING: Can't find string index for"
2486                                     " <linux-phandle> node %s\n", path);
2487                 else {
2488                         dt_push_token(OF_DT_PROP, mem_start, mem_end);
2489                         dt_push_token(4, mem_start, mem_end);
2490                         dt_push_token(soff, mem_start, mem_end);
2491                         valp = make_room(mem_start, mem_end, 4, 4);
2492                         *(__be32 *)valp = cpu_to_be32(node);
2493                 }
2494         }
2495
2496         /* do all our children */
2497         child = call_prom("child", 1, 1, node);
2498         while (child != 0) {
2499                 scan_dt_build_struct(child, mem_start, mem_end);
2500                 child = call_prom("peer", 1, 1, child);
2501         }
2502
2503         dt_push_token(OF_DT_END_NODE, mem_start, mem_end);
2504 }
2505
2506 static void __init flatten_device_tree(void)
2507 {
2508         phandle root;
2509         unsigned long mem_start, mem_end, room;
2510         struct boot_param_header *hdr;
2511         char *namep;
2512         u64 *rsvmap;
2513
2514         /*
2515          * Check how much room we have between alloc top & bottom (+/- a
2516          * few pages), crop to 1MB, as this is our "chunk" size
2517          */
2518         room = alloc_top - alloc_bottom - 0x4000;
2519         if (room > DEVTREE_CHUNK_SIZE)
2520                 room = DEVTREE_CHUNK_SIZE;
2521         prom_debug("starting device tree allocs at %lx\n", alloc_bottom);
2522
2523         /* Now try to claim that */
2524         mem_start = (unsigned long)alloc_up(room, PAGE_SIZE);
2525         if (mem_start == 0)
2526                 prom_panic("Can't allocate initial device-tree chunk\n");
2527         mem_end = mem_start + room;
2528
2529         /* Get root of tree */
2530         root = call_prom("peer", 1, 1, (phandle)0);
2531         if (root == (phandle)0)
2532                 prom_panic ("couldn't get device tree root\n");
2533
2534         /* Build header and make room for mem rsv map */
2535         mem_start = _ALIGN(mem_start, 4);
2536         hdr = make_room(&mem_start, &mem_end,
2537                         sizeof(struct boot_param_header), 4);
2538         dt_header_start = (unsigned long)hdr;
2539         rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8);
2540
2541         /* Start of strings */
2542         mem_start = PAGE_ALIGN(mem_start);
2543         dt_string_start = mem_start;
2544         mem_start += 4; /* hole */
2545
2546         /* Add "linux,phandle" in there, we'll need it */
2547         namep = make_room(&mem_start, &mem_end, 16, 1);
2548         strcpy(namep, "linux,phandle");
2549         mem_start = (unsigned long)namep + strlen(namep) + 1;
2550
2551         /* Build string array */
2552         prom_printf("Building dt strings...\n");
2553         scan_dt_build_strings(root, &mem_start, &mem_end);
2554         dt_string_end = mem_start;
2555
2556         /* Build structure */
2557         mem_start = PAGE_ALIGN(mem_start);
2558         dt_struct_start = mem_start;
2559         prom_printf("Building dt structure...\n");
2560         scan_dt_build_struct(root, &mem_start, &mem_end);
2561         dt_push_token(OF_DT_END, &mem_start, &mem_end);
2562         dt_struct_end = PAGE_ALIGN(mem_start);
2563
2564         /* Finish header */
2565         hdr->boot_cpuid_phys = cpu_to_be32(prom.cpu);
2566         hdr->magic = cpu_to_be32(OF_DT_HEADER);
2567         hdr->totalsize = cpu_to_be32(dt_struct_end - dt_header_start);
2568         hdr->off_dt_struct = cpu_to_be32(dt_struct_start - dt_header_start);
2569         hdr->off_dt_strings = cpu_to_be32(dt_string_start - dt_header_start);
2570         hdr->dt_strings_size = cpu_to_be32(dt_string_end - dt_string_start);
2571         hdr->off_mem_rsvmap = cpu_to_be32(((unsigned long)rsvmap) - dt_header_start);
2572         hdr->version = cpu_to_be32(OF_DT_VERSION);
2573         /* Version 16 is not backward compatible */
2574         hdr->last_comp_version = cpu_to_be32(0x10);
2575
2576         /* Copy the reserve map in */
2577         memcpy(rsvmap, mem_reserve_map, sizeof(mem_reserve_map));
2578
2579 #ifdef DEBUG_PROM
2580         {
2581                 int i;
2582                 prom_printf("reserved memory map:\n");
2583                 for (i = 0; i < mem_reserve_cnt; i++)
2584                         prom_printf("  %llx - %llx\n",
2585                                     be64_to_cpu(mem_reserve_map[i].base),
2586                                     be64_to_cpu(mem_reserve_map[i].size));
2587         }
2588 #endif
2589         /* Bump mem_reserve_cnt to cause further reservations to fail
2590          * since it's too late.
2591          */
2592         mem_reserve_cnt = MEM_RESERVE_MAP_SIZE;
2593
2594         prom_printf("Device tree strings 0x%lx -> 0x%lx\n",
2595                     dt_string_start, dt_string_end);
2596         prom_printf("Device tree struct  0x%lx -> 0x%lx\n",
2597                     dt_struct_start, dt_struct_end);
2598 }
2599
2600 #ifdef CONFIG_PPC_MAPLE
2601 /* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property.
2602  * The values are bad, and it doesn't even have the right number of cells. */
2603 static void __init fixup_device_tree_maple(void)
2604 {
2605         phandle isa;
2606         u32 rloc = 0x01002000; /* IO space; PCI device = 4 */
2607         u32 isa_ranges[6];
2608         char *name;
2609
2610         name = "/ht@0/isa@4";
2611         isa = call_prom("finddevice", 1, 1, ADDR(name));
2612         if (!PHANDLE_VALID(isa)) {
2613                 name = "/ht@0/isa@6";
2614                 isa = call_prom("finddevice", 1, 1, ADDR(name));
2615                 rloc = 0x01003000; /* IO space; PCI device = 6 */
2616         }
2617         if (!PHANDLE_VALID(isa))
2618                 return;
2619
2620         if (prom_getproplen(isa, "ranges") != 12)
2621                 return;
2622         if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges))
2623                 == PROM_ERROR)
2624                 return;
2625
2626         if (isa_ranges[0] != 0x1 ||
2627                 isa_ranges[1] != 0xf4000000 ||
2628                 isa_ranges[2] != 0x00010000)
2629                 return;
2630
2631         prom_printf("Fixing up bogus ISA range on Maple/Apache...\n");
2632
2633         isa_ranges[0] = 0x1;
2634         isa_ranges[1] = 0x0;
2635         isa_ranges[2] = rloc;
2636         isa_ranges[3] = 0x0;
2637         isa_ranges[4] = 0x0;
2638         isa_ranges[5] = 0x00010000;
2639         prom_setprop(isa, name, "ranges",
2640                         isa_ranges, sizeof(isa_ranges));
2641 }
2642
2643 #define CPC925_MC_START         0xf8000000
2644 #define CPC925_MC_LENGTH        0x1000000
2645 /* The values for memory-controller don't have right number of cells */
2646 static void __init fixup_device_tree_maple_memory_controller(void)
2647 {
2648         phandle mc;
2649         u32 mc_reg[4];
2650         char *name = "/hostbridge@f8000000";
2651         u32 ac, sc;
2652
2653         mc = call_prom("finddevice", 1, 1, ADDR(name));
2654         if (!PHANDLE_VALID(mc))
2655                 return;
2656
2657         if (prom_getproplen(mc, "reg") != 8)
2658                 return;
2659
2660         prom_getprop(prom.root, "#address-cells", &ac, sizeof(ac));
2661         prom_getprop(prom.root, "#size-cells", &sc, sizeof(sc));
2662         if ((ac != 2) || (sc != 2))
2663                 return;
2664
2665         if (prom_getprop(mc, "reg", mc_reg, sizeof(mc_reg)) == PROM_ERROR)
2666                 return;
2667
2668         if (mc_reg[0] != CPC925_MC_START || mc_reg[1] != CPC925_MC_LENGTH)
2669                 return;
2670
2671         prom_printf("Fixing up bogus hostbridge on Maple...\n");
2672
2673         mc_reg[0] = 0x0;
2674         mc_reg[1] = CPC925_MC_START;
2675         mc_reg[2] = 0x0;
2676         mc_reg[3] = CPC925_MC_LENGTH;
2677         prom_setprop(mc, name, "reg", mc_reg, sizeof(mc_reg));
2678 }
2679 #else
2680 #define fixup_device_tree_maple()
2681 #define fixup_device_tree_maple_memory_controller()
2682 #endif
2683
2684 #ifdef CONFIG_PPC_CHRP
2685 /*
2686  * Pegasos and BriQ lacks the "ranges" property in the isa node
2687  * Pegasos needs decimal IRQ 14/15, not hexadecimal
2688  * Pegasos has the IDE configured in legacy mode, but advertised as native
2689  */
2690 static void __init fixup_device_tree_chrp(void)
2691 {
2692         phandle ph;
2693         u32 prop[6];
2694         u32 rloc = 0x01006000; /* IO space; PCI device = 12 */
2695         char *name;
2696         int rc;
2697
2698         name = "/pci@80000000/isa@c";
2699         ph = call_prom("finddevice", 1, 1, ADDR(name));
2700         if (!PHANDLE_VALID(ph)) {
2701                 name = "/pci@ff500000/isa@6";
2702                 ph = call_prom("finddevice", 1, 1, ADDR(name));
2703                 rloc = 0x01003000; /* IO space; PCI device = 6 */
2704         }
2705         if (PHANDLE_VALID(ph)) {
2706                 rc = prom_getproplen(ph, "ranges");
2707                 if (rc == 0 || rc == PROM_ERROR) {
2708                         prom_printf("Fixing up missing ISA range on Pegasos...\n");
2709
2710                         prop[0] = 0x1;
2711                         prop[1] = 0x0;
2712                         prop[2] = rloc;
2713                         prop[3] = 0x0;
2714                         prop[4] = 0x0;
2715                         prop[5] = 0x00010000;
2716                         prom_setprop(ph, name, "ranges", prop, sizeof(prop));
2717                 }
2718         }
2719
2720         name = "/pci@80000000/ide@C,1";
2721         ph = call_prom("finddevice", 1, 1, ADDR(name));
2722         if (PHANDLE_VALID(ph)) {
2723                 prom_printf("Fixing up IDE interrupt on Pegasos...\n");
2724                 prop[0] = 14;
2725                 prop[1] = 0x0;
2726                 prom_setprop(ph, name, "interrupts", prop, 2*sizeof(u32));
2727                 prom_printf("Fixing up IDE class-code on Pegasos...\n");
2728                 rc = prom_getprop(ph, "class-code", prop, sizeof(u32));
2729                 if (rc == sizeof(u32)) {
2730                         prop[0] &= ~0x5;
2731                         prom_setprop(ph, name, "class-code", prop, sizeof(u32));
2732                 }
2733         }
2734 }
2735 #else
2736 #define fixup_device_tree_chrp()
2737 #endif
2738
2739 #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC)
2740 static void __init fixup_device_tree_pmac(void)
2741 {
2742         phandle u3, i2c, mpic;
2743         u32 u3_rev;
2744         u32 interrupts[2];
2745         u32 parent;
2746
2747         /* Some G5s have a missing interrupt definition, fix it up here */
2748         u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000"));
2749         if (!PHANDLE_VALID(u3))
2750                 return;
2751         i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000"));
2752         if (!PHANDLE_VALID(i2c))
2753                 return;
2754         mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000"));
2755         if (!PHANDLE_VALID(mpic))
2756                 return;
2757
2758         /* check if proper rev of u3 */
2759         if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev))
2760             == PROM_ERROR)
2761                 return;
2762         if (u3_rev < 0x35 || u3_rev > 0x39)
2763                 return;
2764         /* does it need fixup ? */
2765         if (prom_getproplen(i2c, "interrupts") > 0)
2766                 return;
2767
2768         prom_printf("fixing up bogus interrupts for u3 i2c...\n");
2769
2770         /* interrupt on this revision of u3 is number 0 and level */
2771         interrupts[0] = 0;
2772         interrupts[1] = 1;
2773         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts",
2774                      &interrupts, sizeof(interrupts));
2775         parent = (u32)mpic;
2776         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent",
2777                      &parent, sizeof(parent));
2778 }
2779 #else
2780 #define fixup_device_tree_pmac()
2781 #endif
2782
2783 #ifdef CONFIG_PPC_EFIKA
2784 /*
2785  * The MPC5200 FEC driver requires an phy-handle property to tell it how
2786  * to talk to the phy.  If the phy-handle property is missing, then this
2787  * function is called to add the appropriate nodes and link it to the
2788  * ethernet node.
2789  */
2790 static void __init fixup_device_tree_efika_add_phy(void)
2791 {
2792         u32 node;
2793         char prop[64];
2794         int rv;
2795
2796         /* Check if /builtin/ethernet exists - bail if it doesn't */
2797         node = call_prom("finddevice", 1, 1, ADDR("/builtin/ethernet"));
2798         if (!PHANDLE_VALID(node))
2799                 return;
2800
2801         /* Check if the phy-handle property exists - bail if it does */
2802         rv = prom_getprop(node, "phy-handle", prop, sizeof(prop));
2803         if (!rv)
2804                 return;
2805
2806         /*
2807          * At this point the ethernet device doesn't have a phy described.
2808          * Now we need to add the missing phy node and linkage
2809          */
2810
2811         /* Check for an MDIO bus node - if missing then create one */
2812         node = call_prom("finddevice", 1, 1, ADDR("/builtin/mdio"));
2813         if (!PHANDLE_VALID(node)) {
2814                 prom_printf("Adding Ethernet MDIO node\n");
2815                 call_prom("interpret", 1, 1,
2816                         " s\" /builtin\" find-device"
2817                         " new-device"
2818                                 " 1 encode-int s\" #address-cells\" property"
2819                                 " 0 encode-int s\" #size-cells\" property"
2820                                 " s\" mdio\" device-name"
2821                                 " s\" fsl,mpc5200b-mdio\" encode-string"
2822                                 " s\" compatible\" property"
2823                                 " 0xf0003000 0x400 reg"
2824                                 " 0x2 encode-int"
2825                                 " 0x5 encode-int encode+"
2826                                 " 0x3 encode-int encode+"
2827                                 " s\" interrupts\" property"
2828                         " finish-device");
2829         };
2830
2831         /* Check for a PHY device node - if missing then create one and
2832          * give it's phandle to the ethernet node */
2833         node = call_prom("finddevice", 1, 1,
2834                          ADDR("/builtin/mdio/ethernet-phy"));
2835         if (!PHANDLE_VALID(node)) {
2836                 prom_printf("Adding Ethernet PHY node\n");
2837                 call_prom("interpret", 1, 1,
2838                         " s\" /builtin/mdio\" find-device"
2839                         " new-device"
2840                                 " s\" ethernet-phy\" device-name"
2841                                 " 0x10 encode-int s\" reg\" property"
2842                                 " my-self"
2843                                 " ihandle>phandle"
2844                         " finish-device"
2845                         " s\" /builtin/ethernet\" find-device"
2846                                 " encode-int"
2847                                 " s\" phy-handle\" property"
2848                         " device-end");
2849         }
2850 }
2851
2852 static void __init fixup_device_tree_efika(void)
2853 {
2854         int sound_irq[3] = { 2, 2, 0 };
2855         int bcomm_irq[3*16] = { 3,0,0, 3,1,0, 3,2,0, 3,3,0,
2856                                 3,4,0, 3,5,0, 3,6,0, 3,7,0,
2857                                 3,8,0, 3,9,0, 3,10,0, 3,11,0,
2858                                 3,12,0, 3,13,0, 3,14,0, 3,15,0 };
2859         u32 node;
2860         char prop[64];
2861         int rv, len;
2862
2863         /* Check if we're really running on a EFIKA */
2864         node = call_prom("finddevice", 1, 1, ADDR("/"));
2865         if (!PHANDLE_VALID(node))
2866                 return;
2867
2868         rv = prom_getprop(node, "model", prop, sizeof(prop));
2869         if (rv == PROM_ERROR)
2870                 return;
2871         if (strcmp(prop, "EFIKA5K2"))
2872                 return;
2873
2874         prom_printf("Applying EFIKA device tree fixups\n");
2875
2876         /* Claiming to be 'chrp' is death */
2877         node = call_prom("finddevice", 1, 1, ADDR("/"));
2878         rv = prom_getprop(node, "device_type", prop, sizeof(prop));
2879         if (rv != PROM_ERROR && (strcmp(prop, "chrp") == 0))
2880                 prom_setprop(node, "/", "device_type", "efika", sizeof("efika"));
2881
2882         /* CODEGEN,description is exposed in /proc/cpuinfo so
2883            fix that too */
2884         rv = prom_getprop(node, "CODEGEN,description", prop, sizeof(prop));
2885         if (rv != PROM_ERROR && (strstr(prop, "CHRP")))
2886                 prom_setprop(node, "/", "CODEGEN,description",
2887                              "Efika 5200B PowerPC System",
2888                              sizeof("Efika 5200B PowerPC System"));
2889
2890         /* Fixup bestcomm interrupts property */
2891         node = call_prom("finddevice", 1, 1, ADDR("/builtin/bestcomm"));
2892         if (PHANDLE_VALID(node)) {
2893                 len = prom_getproplen(node, "interrupts");
2894                 if (len == 12) {
2895                         prom_printf("Fixing bestcomm interrupts property\n");
2896                         prom_setprop(node, "/builtin/bestcom", "interrupts",
2897                                      bcomm_irq, sizeof(bcomm_irq));
2898                 }
2899         }
2900
2901         /* Fixup sound interrupts property */
2902         node = call_prom("finddevice", 1, 1, ADDR("/builtin/sound"));
2903         if (PHANDLE_VALID(node)) {
2904                 rv = prom_getprop(node, "interrupts", prop, sizeof(prop));
2905                 if (rv == PROM_ERROR) {
2906                         prom_printf("Adding sound interrupts property\n");
2907                         prom_setprop(node, "/builtin/sound", "interrupts",
2908                                      sound_irq, sizeof(sound_irq));
2909                 }
2910         }
2911
2912         /* Make sure ethernet phy-handle property exists */
2913         fixup_device_tree_efika_add_phy();
2914 }
2915 #else
2916 #define fixup_device_tree_efika()
2917 #endif
2918
2919 #ifdef CONFIG_PPC_PASEMI_NEMO
2920 /*
2921  * CFE supplied on Nemo is broken in several ways, biggest
2922  * problem is that it reassigns ISA interrupts to unused mpic ints.
2923  * Add an interrupt-controller property for the io-bridge to use
2924  * and correct the ints so we can attach them to an irq_domain
2925  */
2926 static void __init fixup_device_tree_pasemi(void)
2927 {
2928         u32 interrupts[2], parent, rval, val = 0;
2929         char *name, *pci_name;
2930         phandle iob, node;
2931
2932         /* Find the root pci node */
2933         name = "/pxp@0,e0000000";
2934         iob = call_prom("finddevice", 1, 1, ADDR(name));
2935         if (!PHANDLE_VALID(iob))
2936                 return;
2937
2938         /* check if interrupt-controller node set yet */
2939         if (prom_getproplen(iob, "interrupt-controller") !=PROM_ERROR)
2940                 return;
2941
2942         prom_printf("adding interrupt-controller property for SB600...\n");
2943
2944         prom_setprop(iob, name, "interrupt-controller", &val, 0);
2945
2946         pci_name = "/pxp@0,e0000000/pci@11";
2947         node = call_prom("finddevice", 1, 1, ADDR(pci_name));
2948         parent = ADDR(iob);
2949
2950         for( ; prom_next_node(&node); ) {
2951                 /* scan each node for one with an interrupt */
2952                 if (!PHANDLE_VALID(node))
2953                         continue;
2954
2955                 rval = prom_getproplen(node, "interrupts");
2956                 if (rval == 0 || rval == PROM_ERROR)
2957                         continue;
2958
2959                 prom_getprop(node, "interrupts", &interrupts, sizeof(interrupts));
2960                 if ((interrupts[0] < 212) || (interrupts[0] > 222))
2961                         continue;
2962
2963                 /* found a node, update both interrupts and interrupt-parent */
2964                 if ((interrupts[0] >= 212) && (interrupts[0] <= 215))
2965                         interrupts[0] -= 203;
2966                 if ((interrupts[0] >= 216) && (interrupts[0] <= 220))
2967                         interrupts[0] -= 213;
2968                 if (interrupts[0] == 221)
2969                         interrupts[0] = 14;
2970                 if (interrupts[0] == 222)
2971                         interrupts[0] = 8;
2972
2973                 prom_setprop(node, pci_name, "interrupts", interrupts,
2974                                         sizeof(interrupts));
2975                 prom_setprop(node, pci_name, "interrupt-parent", &parent,
2976                                         sizeof(parent));
2977         }
2978
2979         /*
2980          * The io-bridge has device_type set to 'io-bridge' change it to 'isa'
2981          * so that generic isa-bridge code can add the SB600 and its on-board
2982          * peripherals.
2983          */
2984         name = "/pxp@0,e0000000/io-bridge@0";
2985         iob = call_prom("finddevice", 1, 1, ADDR(name));
2986         if (!PHANDLE_VALID(iob))
2987                 return;
2988
2989         /* device_type is already set, just change it. */
2990
2991         prom_printf("Changing device_type of SB600 node...\n");
2992
2993         prom_setprop(iob, name, "device_type", "isa", sizeof("isa"));
2994 }
2995 #else   /* !CONFIG_PPC_PASEMI_NEMO */
2996 static inline void fixup_device_tree_pasemi(void) { }
2997 #endif
2998
2999 static void __init fixup_device_tree(void)
3000 {
3001         fixup_device_tree_maple();
3002         fixup_device_tree_maple_memory_controller();
3003         fixup_device_tree_chrp();
3004         fixup_device_tree_pmac();
3005         fixup_device_tree_efika();
3006         fixup_device_tree_pasemi();
3007 }
3008
3009 static void __init prom_find_boot_cpu(void)
3010 {
3011         __be32 rval;
3012         ihandle prom_cpu;
3013         phandle cpu_pkg;
3014
3015         rval = 0;
3016         if (prom_getprop(prom.chosen, "cpu", &rval, sizeof(rval)) <= 0)
3017                 return;
3018         prom_cpu = be32_to_cpu(rval);
3019
3020         cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
3021
3022         if (!PHANDLE_VALID(cpu_pkg))
3023                 return;
3024
3025         prom_getprop(cpu_pkg, "reg", &rval, sizeof(rval));
3026         prom.cpu = be32_to_cpu(rval);
3027
3028         prom_debug("Booting CPU hw index = %d\n", prom.cpu);
3029 }
3030
3031 static void __init prom_check_initrd(unsigned long r3, unsigned long r4)
3032 {
3033 #ifdef CONFIG_BLK_DEV_INITRD
3034         if (r3 && r4 && r4 != 0xdeadbeef) {
3035                 __be64 val;
3036
3037                 prom_initrd_start = is_kernel_addr(r3) ? __pa(r3) : r3;
3038                 prom_initrd_end = prom_initrd_start + r4;
3039
3040                 val = cpu_to_be64(prom_initrd_start);
3041                 prom_setprop(prom.chosen, "/chosen", "linux,initrd-start",
3042                              &val, sizeof(val));
3043                 val = cpu_to_be64(prom_initrd_end);
3044                 prom_setprop(prom.chosen, "/chosen", "linux,initrd-end",
3045                              &val, sizeof(val));
3046
3047                 reserve_mem(prom_initrd_start,
3048                             prom_initrd_end - prom_initrd_start);
3049
3050                 prom_debug("initrd_start=0x%lx\n", prom_initrd_start);
3051                 prom_debug("initrd_end=0x%lx\n", prom_initrd_end);
3052         }
3053 #endif /* CONFIG_BLK_DEV_INITRD */
3054 }
3055
3056 #ifdef CONFIG_PPC64
3057 #ifdef CONFIG_RELOCATABLE
3058 static void reloc_toc(void)
3059 {
3060 }
3061
3062 static void unreloc_toc(void)
3063 {
3064 }
3065 #else
3066 static void __reloc_toc(unsigned long offset, unsigned long nr_entries)
3067 {
3068         unsigned long i;
3069         unsigned long *toc_entry;
3070
3071         /* Get the start of the TOC by using r2 directly. */
3072         asm volatile("addi %0,2,-0x8000" : "=b" (toc_entry));
3073
3074         for (i = 0; i < nr_entries; i++) {
3075                 *toc_entry = *toc_entry + offset;
3076                 toc_entry++;
3077         }
3078 }
3079
3080 static void reloc_toc(void)
3081 {
3082         unsigned long offset = reloc_offset();
3083         unsigned long nr_entries =
3084                 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long);
3085
3086         __reloc_toc(offset, nr_entries);
3087
3088         mb();
3089 }
3090
3091 static void unreloc_toc(void)
3092 {
3093         unsigned long offset = reloc_offset();
3094         unsigned long nr_entries =
3095                 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long);
3096
3097         mb();
3098
3099         __reloc_toc(-offset, nr_entries);
3100 }
3101 #endif
3102 #endif
3103
3104 /*
3105  * We enter here early on, when the Open Firmware prom is still
3106  * handling exceptions and the MMU hash table for us.
3107  */
3108
3109 unsigned long __init prom_init(unsigned long r3, unsigned long r4,
3110                                unsigned long pp,
3111                                unsigned long r6, unsigned long r7,
3112                                unsigned long kbase)
3113 {
3114         unsigned long hdr;
3115
3116 #ifdef CONFIG_PPC32
3117         unsigned long offset = reloc_offset();
3118         reloc_got2(offset);
3119 #else
3120         reloc_toc();
3121 #endif
3122
3123         /*
3124          * First zero the BSS
3125          */
3126         memset(&__bss_start, 0, __bss_stop - __bss_start);
3127
3128         /*
3129          * Init interface to Open Firmware, get some node references,
3130          * like /chosen
3131          */
3132         prom_init_client_services(pp);
3133
3134         /*
3135          * See if this OF is old enough that we need to do explicit maps
3136          * and other workarounds
3137          */
3138         prom_find_mmu();
3139
3140         /*
3141          * Init prom stdout device
3142          */
3143         prom_init_stdout();
3144
3145         prom_printf("Preparing to boot %s", linux_banner);
3146
3147         /*
3148          * Get default machine type. At this point, we do not differentiate
3149          * between pSeries SMP and pSeries LPAR
3150          */
3151         of_platform = prom_find_machine_type();
3152         prom_printf("Detected machine type: %x\n", of_platform);
3153
3154 #ifndef CONFIG_NONSTATIC_KERNEL
3155         /* Bail if this is a kdump kernel. */
3156         if (PHYSICAL_START > 0)
3157                 prom_panic("Error: You can't boot a kdump kernel from OF!\n");
3158 #endif
3159
3160         /*
3161          * Check for an initrd
3162          */
3163         prom_check_initrd(r3, r4);
3164
3165         /*
3166          * Do early parsing of command line
3167          */
3168         early_cmdline_parse();
3169
3170 #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
3171         /*
3172          * On pSeries, inform the firmware about our capabilities
3173          */
3174         if (of_platform == PLATFORM_PSERIES ||
3175             of_platform == PLATFORM_PSERIES_LPAR)
3176                 prom_send_capabilities();
3177 #endif
3178
3179         /*
3180          * Copy the CPU hold code
3181          */
3182         if (of_platform != PLATFORM_POWERMAC)
3183                 copy_and_flush(0, kbase, 0x100, 0);
3184
3185         /*
3186          * Initialize memory management within prom_init
3187          */
3188         prom_init_mem();
3189
3190         /*
3191          * Determine which cpu is actually running right _now_
3192          */
3193         prom_find_boot_cpu();
3194
3195         /*
3196          * Initialize display devices
3197          */
3198         prom_check_displays();
3199
3200 #if defined(CONFIG_PPC64) && defined(__BIG_ENDIAN__)
3201         /*
3202          * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else
3203          * that uses the allocator, we need to make sure we get the top of memory
3204          * available for us here...
3205          */
3206         if (of_platform == PLATFORM_PSERIES)
3207                 prom_initialize_tce_table();
3208 #endif
3209
3210         /*
3211          * On non-powermacs, try to instantiate RTAS. PowerMacs don't
3212          * have a usable RTAS implementation.
3213          */
3214         if (of_platform != PLATFORM_POWERMAC &&
3215             of_platform != PLATFORM_OPAL)
3216                 prom_instantiate_rtas();
3217
3218 #ifdef CONFIG_PPC_POWERNV
3219         if (of_platform == PLATFORM_OPAL)
3220                 prom_instantiate_opal();
3221 #endif /* CONFIG_PPC_POWERNV */
3222
3223 #ifdef CONFIG_PPC64
3224         /* instantiate sml */
3225         prom_instantiate_sml();
3226 #endif
3227
3228         /*
3229          * On non-powermacs, put all CPUs in spin-loops.
3230          *
3231          * PowerMacs use a different mechanism to spin CPUs
3232          *
3233          * (This must be done after instanciating RTAS)
3234          */
3235         if (of_platform != PLATFORM_POWERMAC &&
3236             of_platform != PLATFORM_OPAL)
3237                 prom_hold_cpus();
3238
3239         /*
3240          * Fill in some infos for use by the kernel later on
3241          */
3242         if (prom_memory_limit) {
3243                 __be64 val = cpu_to_be64(prom_memory_limit);
3244                 prom_setprop(prom.chosen, "/chosen", "linux,memory-limit",
3245                              &val, sizeof(val));
3246         }
3247 #ifdef CONFIG_PPC64
3248         if (prom_iommu_off)
3249                 prom_setprop(prom.chosen, "/chosen", "linux,iommu-off",
3250                              NULL, 0);
3251
3252         if (prom_iommu_force_on)
3253                 prom_setprop(prom.chosen, "/chosen", "linux,iommu-force-on",
3254                              NULL, 0);
3255
3256         if (prom_tce_alloc_start) {
3257                 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-start",
3258                              &prom_tce_alloc_start,
3259                              sizeof(prom_tce_alloc_start));
3260                 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-end",
3261                              &prom_tce_alloc_end,
3262                              sizeof(prom_tce_alloc_end));
3263         }
3264 #endif
3265
3266         /*
3267          * Fixup any known bugs in the device-tree
3268          */
3269         fixup_device_tree();
3270
3271         /*
3272          * Now finally create the flattened device-tree
3273          */
3274         prom_printf("copying OF device tree...\n");
3275         flatten_device_tree();
3276
3277         /*
3278          * in case stdin is USB and still active on IBM machines...
3279          * Unfortunately quiesce crashes on some powermacs if we have
3280          * closed stdin already (in particular the powerbook 101). It
3281          * appears that the OPAL version of OFW doesn't like it either.
3282          */
3283         if (of_platform != PLATFORM_POWERMAC &&
3284             of_platform != PLATFORM_OPAL)
3285                 prom_close_stdin();
3286
3287         /*
3288          * Call OF "quiesce" method to shut down pending DMA's from
3289          * devices etc...
3290          */
3291         prom_printf("Quiescing Open Firmware ...\n");
3292         call_prom("quiesce", 0, 0);
3293
3294         /*
3295          * And finally, call the kernel passing it the flattened device
3296          * tree and NULL as r5, thus triggering the new entry point which
3297          * is common to us and kexec
3298          */
3299         hdr = dt_header_start;
3300
3301         /* Don't print anything after quiesce under OPAL, it crashes OFW */
3302         if (of_platform != PLATFORM_OPAL) {
3303                 prom_printf("Booting Linux via __start() @ 0x%lx ...\n", kbase);
3304                 prom_debug("->dt_header_start=0x%lx\n", hdr);
3305         }
3306
3307 #ifdef CONFIG_PPC32
3308         reloc_got2(-offset);
3309 #else
3310         unreloc_toc();
3311 #endif
3312
3313 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
3314         /* OPAL early debug gets the OPAL base & entry in r8 and r9 */
3315         __start(hdr, kbase, 0, 0, 0,
3316                 prom_opal_base, prom_opal_entry);
3317 #else
3318         __start(hdr, kbase, 0, 0, 0, 0, 0);
3319 #endif
3320
3321         return 0;
3322 }