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 __maybe_unused = 0;
 632
 633         prom_cmd_line[0] = 0;
 634         p = prom_cmd_line;
 635         if ((long)prom.chosen > 0)
 636                 l = prom_getprop(prom.chosen, "bootargs", p, COMMAND_LINE_SIZE-1);
 637 #ifdef CONFIG_CMDLINE
 638         if (l <= 0 || p[0] == '\0') /* dbl check */
 639                 strlcpy(prom_cmd_line,
 640                         CONFIG_CMDLINE, sizeof(prom_cmd_line));
 641 #endif /* CONFIG_CMDLINE */
 642         prom_printf("command line: %s\n", prom_cmd_line);
 643
 644 #ifdef CONFIG_PPC64
 645         opt = strstr(prom_cmd_line, "iommu=");
 646         if (opt) {
 647                 prom_printf("iommu opt is: %s\n", opt);
 648                 opt += 6;
 649                 while (*opt && *opt == ' ')
 650                         opt++;
 651                 if (!strncmp(opt, "off", 3))
 652                         prom_iommu_off = 1;
 653                 else if (!strncmp(opt, "force", 5))
 654                         prom_iommu_force_on = 1;
 655         }
 656 #endif
 657         opt = strstr(prom_cmd_line, "mem=");
 658         if (opt) {
 659                 opt += 4;
 660                 prom_memory_limit = prom_memparse(opt, (const char **)&opt);
 661 #ifdef CONFIG_PPC64
 662                 /* Align to 16 MB == size of ppc64 large page */
 663                 prom_memory_limit = ALIGN(prom_memory_limit, 0x1000000);
 664 #endif
 665         }
 666
 667         opt = strstr(prom_cmd_line, "disable_radix");
 668         if (opt) {
 669                 opt += 13;
 670                 if (*opt && *opt == '=') {
 671                         bool val;
 672
 673                         if (kstrtobool(++opt, &val))
 674                                 prom_radix_disable = false;
 675                         else
 676                                 prom_radix_disable = val;
 677                 } else
 678                         prom_radix_disable = true;
 679         }
 680         if (prom_radix_disable)
 681                 prom_debug("Radix disabled from cmdline\n");
 682 }
 683
 684 #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
 685 /*
 686  * The architecture vector has an array of PVR mask/value pairs,
 687  * followed by # option vectors - 1, followed by the option vectors.
 688  *
 689  * See prom.h for the definition of the bits specified in the
 690  * architecture vector.
 691  */
 692
 693 /* Firmware expects the value to be n - 1, where n is the # of vectors */
 694 #define NUM_VECTORS(n)          ((n) - 1)
 695
 696 /*
 697  * Firmware expects 1 + n - 2, where n is the length of the option vector in
 698  * bytes. The 1 accounts for the length byte itself, the - 2 .. ?
 699  */
 700 #define VECTOR_LENGTH(n)        (1 + (n) - 2)
 701
 702 struct option_vector1 {
 703         u8 byte1;
 704         u8 arch_versions;
 705         u8 arch_versions3;
 706 } __packed;
 707
 708 struct option_vector2 {
 709         u8 byte1;
 710         __be16 reserved;
 711         __be32 real_base;
 712         __be32 real_size;
 713         __be32 virt_base;
 714         __be32 virt_size;
 715         __be32 load_base;
 716         __be32 min_rma;
 717         __be32 min_load;
 718         u8 min_rma_percent;
 719         u8 max_pft_size;
 720 } __packed;
 721
 722 struct option_vector3 {
 723         u8 byte1;
 724         u8 byte2;
 725 } __packed;
 726
 727 struct option_vector4 {
 728         u8 byte1;
 729         u8 min_vp_cap;
 730 } __packed;
 731
 732 struct option_vector5 {
 733         u8 byte1;
 734         u8 byte2;
 735         u8 byte3;
 736         u8 cmo;
 737         u8 associativity;
 738         u8 bin_opts;
 739         u8 micro_checkpoint;
 740         u8 reserved0;
 741         __be32 max_cpus;
 742         __be16 papr_level;
 743         __be16 reserved1;
 744         u8 platform_facilities;
 745         u8 reserved2;
 746         __be16 reserved3;
 747         u8 subprocessors;
 748         u8 byte22;
 749         u8 intarch;
 750         u8 mmu;
 751         u8 hash_ext;
 752         u8 radix_ext;
 753 } __packed;
 754
 755 struct option_vector6 {
 756         u8 reserved;
 757         u8 secondary_pteg;
 758         u8 os_name;
 759 } __packed;
 760
 761 struct ibm_arch_vec {
 762         struct { u32 mask, val; } pvrs[12];
 763
 764         u8 num_vectors;
 765
 766         u8 vec1_len;
 767         struct option_vector1 vec1;
 768
 769         u8 vec2_len;
 770         struct option_vector2 vec2;
 771
 772         u8 vec3_len;
 773         struct option_vector3 vec3;
 774
 775         u8 vec4_len;
 776         struct option_vector4 vec4;
 777
 778         u8 vec5_len;
 779         struct option_vector5 vec5;
 780
 781         u8 vec6_len;
 782         struct option_vector6 vec6;
 783 } __packed;
 784
 785 struct ibm_arch_vec __cacheline_aligned ibm_architecture_vec = {
 786         .pvrs = {
 787                 {
 788                         .mask = cpu_to_be32(0xfffe0000), /* POWER5/POWER5+ */
 789                         .val  = cpu_to_be32(0x003a0000),
 790                 },
 791                 {
 792                         .mask = cpu_to_be32(0xffff0000), /* POWER6 */
 793                         .val  = cpu_to_be32(0x003e0000),
 794                 },
 795                 {
 796                         .mask = cpu_to_be32(0xffff0000), /* POWER7 */
 797                         .val  = cpu_to_be32(0x003f0000),
 798                 },
 799                 {
 800                         .mask = cpu_to_be32(0xffff0000), /* POWER8E */
 801                         .val  = cpu_to_be32(0x004b0000),
 802                 },
 803                 {
 804                         .mask = cpu_to_be32(0xffff0000), /* POWER8NVL */
 805                         .val  = cpu_to_be32(0x004c0000),
 806                 },
 807                 {
 808                         .mask = cpu_to_be32(0xffff0000), /* POWER8 */
 809                         .val  = cpu_to_be32(0x004d0000),
 810                 },
 811                 {
 812                         .mask = cpu_to_be32(0xffff0000), /* POWER9 */
 813                         .val  = cpu_to_be32(0x004e0000),
 814                 },
 815                 {
 816                         .mask = cpu_to_be32(0xffffffff), /* all 3.00-compliant */
 817                         .val  = cpu_to_be32(0x0f000005),
 818                 },
 819                 {
 820                         .mask = cpu_to_be32(0xffffffff), /* all 2.07-compliant */
 821                         .val  = cpu_to_be32(0x0f000004),
 822                 },
 823                 {
 824                         .mask = cpu_to_be32(0xffffffff), /* all 2.06-compliant */
 825                         .val  = cpu_to_be32(0x0f000003),
 826                 },
 827                 {
 828                         .mask = cpu_to_be32(0xffffffff), /* all 2.05-compliant */
 829                         .val  = cpu_to_be32(0x0f000002),
 830                 },
 831                 {
 832                         .mask = cpu_to_be32(0xfffffffe), /* all 2.04-compliant and earlier */
 833                         .val  = cpu_to_be32(0x0f000001),
 834                 },
 835         },
 836
 837         .num_vectors = NUM_VECTORS(6),
 838
 839         .vec1_len = VECTOR_LENGTH(sizeof(struct option_vector1)),
 840         .vec1 = {
 841                 .byte1 = 0,
 842                 .arch_versions = OV1_PPC_2_00 | OV1_PPC_2_01 | OV1_PPC_2_02 | OV1_PPC_2_03 |
 843                                  OV1_PPC_2_04 | OV1_PPC_2_05 | OV1_PPC_2_06 | OV1_PPC_2_07,
 844                 .arch_versions3 = OV1_PPC_3_00,
 845         },
 846
 847         .vec2_len = VECTOR_LENGTH(sizeof(struct option_vector2)),
 848         /* option vector 2: Open Firmware options supported */
 849         .vec2 = {
 850                 .byte1 = OV2_REAL_MODE,
 851                 .reserved = 0,
 852                 .real_base = cpu_to_be32(0xffffffff),
 853                 .real_size = cpu_to_be32(0xffffffff),
 854                 .virt_base = cpu_to_be32(0xffffffff),
 855                 .virt_size = cpu_to_be32(0xffffffff),
 856                 .load_base = cpu_to_be32(0xffffffff),
 857                 .min_rma = cpu_to_be32(512),            /* 512MB min RMA */
 858                 .min_load = cpu_to_be32(0xffffffff),    /* full client load */
 859                 .min_rma_percent = 0,   /* min RMA percentage of total RAM */
 860                 .max_pft_size = 48,     /* max log_2(hash table size) */
 861         },
 862
 863         .vec3_len = VECTOR_LENGTH(sizeof(struct option_vector3)),
 864         /* option vector 3: processor options supported */
 865         .vec3 = {
 866                 .byte1 = 0,                     /* don't ignore, don't halt */
 867                 .byte2 = OV3_FP | OV3_VMX | OV3_DFP,
 868         },
 869
 870         .vec4_len = VECTOR_LENGTH(sizeof(struct option_vector4)),
 871         /* option vector 4: IBM PAPR implementation */
 872         .vec4 = {
 873                 .byte1 = 0,                     /* don't halt */
 874                 .min_vp_cap = OV4_MIN_ENT_CAP,  /* minimum VP entitled capacity */
 875         },
 876
 877         .vec5_len = VECTOR_LENGTH(sizeof(struct option_vector5)),
 878         /* option vector 5: PAPR/OF options */
 879         .vec5 = {
 880                 .byte1 = 0,                             /* don't ignore, don't halt */
 881                 .byte2 = OV5_FEAT(OV5_LPAR) | OV5_FEAT(OV5_SPLPAR) | OV5_FEAT(OV5_LARGE_PAGES) |
 882                 OV5_FEAT(OV5_DRCONF_MEMORY) | OV5_FEAT(OV5_DONATE_DEDICATE_CPU) |
 883 #ifdef CONFIG_PCI_MSI
 884                 /* PCIe/MSI support.  Without MSI full PCIe is not supported */
 885                 OV5_FEAT(OV5_MSI),
 886 #else
 887                 0,
 888 #endif
 889                 .byte3 = 0,
 890                 .cmo =
 891 #ifdef CONFIG_PPC_SMLPAR
 892                 OV5_FEAT(OV5_CMO) | OV5_FEAT(OV5_XCMO),
 893 #else
 894                 0,
 895 #endif
 896                 .associativity = OV5_FEAT(OV5_TYPE1_AFFINITY) | OV5_FEAT(OV5_PRRN),
 897                 .bin_opts = OV5_FEAT(OV5_RESIZE_HPT) | OV5_FEAT(OV5_HP_EVT),
 898                 .micro_checkpoint = 0,
 899                 .reserved0 = 0,
 900                 .max_cpus = cpu_to_be32(NR_CPUS),       /* number of cores supported */
 901                 .papr_level = 0,
 902                 .reserved1 = 0,
 903                 .platform_facilities = OV5_FEAT(OV5_PFO_HW_RNG) | OV5_FEAT(OV5_PFO_HW_ENCR) | OV5_FEAT(OV5_PFO_HW_842),
 904                 .reserved2 = 0,
 905                 .reserved3 = 0,
 906                 .subprocessors = 1,
 907                 .byte22 = OV5_FEAT(OV5_DRMEM_V2) | OV5_FEAT(OV5_DRC_INFO),
 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 #ifdef DEBUG_PROM
1425         char *path;
1426 #endif
1427         char type[64];
1428         unsigned int plen;
1429         cell_t *p, *endp;
1430         __be32 val;
1431         u32 rac, rsc;
1432
1433         /*
1434          * We iterate the memory nodes to find
1435          * 1) top of RMO (first node)
1436          * 2) top of memory
1437          */
1438         val = cpu_to_be32(2);
1439         prom_getprop(prom.root, "#address-cells", &val, sizeof(val));
1440         rac = be32_to_cpu(val);
1441         val = cpu_to_be32(1);
1442         prom_getprop(prom.root, "#size-cells", &val, sizeof(rsc));
1443         rsc = be32_to_cpu(val);
1444         prom_debug("root_addr_cells: %x\n", rac);
1445         prom_debug("root_size_cells: %x\n", rsc);
1446
1447         prom_debug("scanning memory:\n");
1448 #ifdef DEBUG_PROM
1449         path = prom_scratch;
1450 #endif
1451
1452         for (node = 0; prom_next_node(&node); ) {
1453                 type[0] = 0;
1454                 prom_getprop(node, "device_type", type, sizeof(type));
1455
1456                 if (type[0] == 0) {
1457                         /*
1458                          * CHRP Longtrail machines have no device_type
1459                          * on the memory node, so check the name instead...
1460                          */
1461                         prom_getprop(node, "name", type, sizeof(type));
1462                 }
1463                 if (strcmp(type, "memory"))
1464                         continue;
1465
1466                 plen = prom_getprop(node, "reg", regbuf, sizeof(regbuf));
1467                 if (plen > sizeof(regbuf)) {
1468                         prom_printf("memory node too large for buffer !\n");
1469                         plen = sizeof(regbuf);
1470                 }
1471                 p = regbuf;
1472                 endp = p + (plen / sizeof(cell_t));
1473
1474 #ifdef DEBUG_PROM
1475                 memset(path, 0, PROM_SCRATCH_SIZE);
1476                 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
1477                 prom_debug("  node %s :\n", path);
1478 #endif /* DEBUG_PROM */
1479
1480                 while ((endp - p) >= (rac + rsc)) {
1481                         unsigned long base, size;
1482
1483                         base = prom_next_cell(rac, &p);
1484                         size = prom_next_cell(rsc, &p);
1485
1486                         if (size == 0)
1487                                 continue;
1488                         prom_debug("    %lx %lx\n", base, size);
1489                         if (base == 0 && (of_platform & PLATFORM_LPAR))
1490                                 rmo_top = size;
1491                         if ((base + size) > ram_top)
1492                                 ram_top = base + size;
1493                 }
1494         }
1495
1496         alloc_bottom = PAGE_ALIGN((unsigned long)&_end + 0x4000);
1497
1498         /*
1499          * If prom_memory_limit is set we reduce the upper limits *except* for
1500          * alloc_top_high. This must be the real top of RAM so we can put
1501          * TCE's up there.
1502          */
1503
1504         alloc_top_high = ram_top;
1505
1506         if (prom_memory_limit) {
1507                 if (prom_memory_limit <= alloc_bottom) {
1508                         prom_printf("Ignoring mem=%lx <= alloc_bottom.\n",
1509                                     prom_memory_limit);
1510                         prom_memory_limit = 0;
1511                 } else if (prom_memory_limit >= ram_top) {
1512                         prom_printf("Ignoring mem=%lx >= ram_top.\n",
1513                                     prom_memory_limit);
1514                         prom_memory_limit = 0;
1515                 } else {
1516                         ram_top = prom_memory_limit;
1517                         rmo_top = min(rmo_top, prom_memory_limit);
1518                 }
1519         }
1520
1521         /*
1522          * Setup our top alloc point, that is top of RMO or top of
1523          * segment 0 when running non-LPAR.
1524          * Some RS64 machines have buggy firmware where claims up at
1525          * 1GB fail.  Cap at 768MB as a workaround.
1526          * Since 768MB is plenty of room, and we need to cap to something
1527          * reasonable on 32-bit, cap at 768MB on all machines.
1528          */
1529         if (!rmo_top)
1530                 rmo_top = ram_top;
1531         rmo_top = min(0x30000000ul, rmo_top);
1532         alloc_top = rmo_top;
1533         alloc_top_high = ram_top;
1534
1535         /*
1536          * Check if we have an initrd after the kernel but still inside
1537          * the RMO.  If we do move our bottom point to after it.
1538          */
1539         if (prom_initrd_start &&
1540             prom_initrd_start < rmo_top &&
1541             prom_initrd_end > alloc_bottom)
1542                 alloc_bottom = PAGE_ALIGN(prom_initrd_end);
1543
1544         prom_printf("memory layout at init:\n");
1545         prom_printf("  memory_limit : %lx (16 MB aligned)\n",
1546                     prom_memory_limit);
1547         prom_printf("  alloc_bottom : %lx\n", alloc_bottom);
1548         prom_printf("  alloc_top    : %lx\n", alloc_top);
1549         prom_printf("  alloc_top_hi : %lx\n", alloc_top_high);
1550         prom_printf("  rmo_top      : %lx\n", rmo_top);
1551         prom_printf("  ram_top      : %lx\n", ram_top);
1552 }
1553
1554 static void __init prom_close_stdin(void)
1555 {
1556         __be32 val;
1557         ihandle stdin;
1558
1559         if (prom_getprop(prom.chosen, "stdin", &val, sizeof(val)) > 0) {
1560                 stdin = be32_to_cpu(val);
1561                 call_prom("close", 1, 0, stdin);
1562         }
1563 }
1564
1565 #ifdef CONFIG_PPC_POWERNV
1566
1567 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
1568 static u64 __initdata prom_opal_base;
1569 static u64 __initdata prom_opal_entry;
1570 #endif
1571
1572 /*
1573  * Allocate room for and instantiate OPAL
1574  */
1575 static void __init prom_instantiate_opal(void)
1576 {
1577         phandle opal_node;
1578         ihandle opal_inst;
1579         u64 base, entry;
1580         u64 size = 0, align = 0x10000;
1581         __be64 val64;
1582         u32 rets[2];
1583
1584         prom_debug("prom_instantiate_opal: start...\n");
1585
1586         opal_node = call_prom("finddevice", 1, 1, ADDR("/ibm,opal"));
1587         prom_debug("opal_node: %x\n", opal_node);
1588         if (!PHANDLE_VALID(opal_node))
1589                 return;
1590
1591         val64 = 0;
1592         prom_getprop(opal_node, "opal-runtime-size", &val64, sizeof(val64));
1593         size = be64_to_cpu(val64);
1594         if (size == 0)
1595                 return;
1596         val64 = 0;
1597         prom_getprop(opal_node, "opal-runtime-alignment", &val64,sizeof(val64));
1598         align = be64_to_cpu(val64);
1599
1600         base = alloc_down(size, align, 0);
1601         if (base == 0) {
1602                 prom_printf("OPAL allocation failed !\n");
1603                 return;
1604         }
1605
1606         opal_inst = call_prom("open", 1, 1, ADDR("/ibm,opal"));
1607         if (!IHANDLE_VALID(opal_inst)) {
1608                 prom_printf("opening opal package failed (%x)\n", opal_inst);
1609                 return;
1610         }
1611
1612         prom_printf("instantiating opal at 0x%llx...", base);
1613
1614         if (call_prom_ret("call-method", 4, 3, rets,
1615                           ADDR("load-opal-runtime"),
1616                           opal_inst,
1617                           base >> 32, base & 0xffffffff) != 0
1618             || (rets[0] == 0 && rets[1] == 0)) {
1619                 prom_printf(" failed\n");
1620                 return;
1621         }
1622         entry = (((u64)rets[0]) << 32) | rets[1];
1623
1624         prom_printf(" done\n");
1625
1626         reserve_mem(base, size);
1627
1628         prom_debug("opal base     = 0x%llx\n", base);
1629         prom_debug("opal align    = 0x%llx\n", align);
1630         prom_debug("opal entry    = 0x%llx\n", entry);
1631         prom_debug("opal size     = 0x%llx\n", size);
1632
1633         prom_setprop(opal_node, "/ibm,opal", "opal-base-address",
1634                      &base, sizeof(base));
1635         prom_setprop(opal_node, "/ibm,opal", "opal-entry-address",
1636                      &entry, sizeof(entry));
1637
1638 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
1639         prom_opal_base = base;
1640         prom_opal_entry = entry;
1641 #endif
1642         prom_debug("prom_instantiate_opal: end...\n");
1643 }
1644
1645 #endif /* CONFIG_PPC_POWERNV */
1646
1647 /*
1648  * Allocate room for and instantiate RTAS
1649  */
1650 static void __init prom_instantiate_rtas(void)
1651 {
1652         phandle rtas_node;
1653         ihandle rtas_inst;
1654         u32 base, entry = 0;
1655         __be32 val;
1656         u32 size = 0;
1657
1658         prom_debug("prom_instantiate_rtas: start...\n");
1659
1660         rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1661         prom_debug("rtas_node: %x\n", rtas_node);
1662         if (!PHANDLE_VALID(rtas_node))
1663                 return;
1664
1665         val = 0;
1666         prom_getprop(rtas_node, "rtas-size", &val, sizeof(size));
1667         size = be32_to_cpu(val);
1668         if (size == 0)
1669                 return;
1670
1671         base = alloc_down(size, PAGE_SIZE, 0);
1672         if (base == 0)
1673                 prom_panic("Could not allocate memory for RTAS\n");
1674
1675         rtas_inst = call_prom("open", 1, 1, ADDR("/rtas"));
1676         if (!IHANDLE_VALID(rtas_inst)) {
1677                 prom_printf("opening rtas package failed (%x)\n", rtas_inst);
1678                 return;
1679         }
1680
1681         prom_printf("instantiating rtas at 0x%x...", base);
1682
1683         if (call_prom_ret("call-method", 3, 2, &entry,
1684                           ADDR("instantiate-rtas"),
1685                           rtas_inst, base) != 0
1686             || entry == 0) {
1687                 prom_printf(" failed\n");
1688                 return;
1689         }
1690         prom_printf(" done\n");
1691
1692         reserve_mem(base, size);
1693
1694         val = cpu_to_be32(base);
1695         prom_setprop(rtas_node, "/rtas", "linux,rtas-base",
1696                      &val, sizeof(val));
1697         val = cpu_to_be32(entry);
1698         prom_setprop(rtas_node, "/rtas", "linux,rtas-entry",
1699                      &val, sizeof(val));
1700
1701         /* Check if it supports "query-cpu-stopped-state" */
1702         if (prom_getprop(rtas_node, "query-cpu-stopped-state",
1703                          &val, sizeof(val)) != PROM_ERROR)
1704                 rtas_has_query_cpu_stopped = true;
1705
1706         prom_debug("rtas base     = 0x%x\n", base);
1707         prom_debug("rtas entry    = 0x%x\n", entry);
1708         prom_debug("rtas size     = 0x%x\n", size);
1709
1710         prom_debug("prom_instantiate_rtas: end...\n");
1711 }
1712
1713 #ifdef CONFIG_PPC64
1714 /*
1715  * Allocate room for and instantiate Stored Measurement Log (SML)
1716  */
1717 static void __init prom_instantiate_sml(void)
1718 {
1719         phandle ibmvtpm_node;
1720         ihandle ibmvtpm_inst;
1721         u32 entry = 0, size = 0, succ = 0;
1722         u64 base;
1723         __be32 val;
1724
1725         prom_debug("prom_instantiate_sml: start...\n");
1726
1727         ibmvtpm_node = call_prom("finddevice", 1, 1, ADDR("/vdevice/vtpm"));
1728         prom_debug("ibmvtpm_node: %x\n", ibmvtpm_node);
1729         if (!PHANDLE_VALID(ibmvtpm_node))
1730                 return;
1731
1732         ibmvtpm_inst = call_prom("open", 1, 1, ADDR("/vdevice/vtpm"));
1733         if (!IHANDLE_VALID(ibmvtpm_inst)) {
1734                 prom_printf("opening vtpm package failed (%x)\n", ibmvtpm_inst);
1735                 return;
1736         }
1737
1738         if (prom_getprop(ibmvtpm_node, "ibm,sml-efi-reformat-supported",
1739                          &val, sizeof(val)) != PROM_ERROR) {
1740                 if (call_prom_ret("call-method", 2, 2, &succ,
1741                                   ADDR("reformat-sml-to-efi-alignment"),
1742                                   ibmvtpm_inst) != 0 || succ == 0) {
1743                         prom_printf("Reformat SML to EFI alignment failed\n");
1744                         return;
1745                 }
1746
1747                 if (call_prom_ret("call-method", 2, 2, &size,
1748                                   ADDR("sml-get-allocated-size"),
1749                                   ibmvtpm_inst) != 0 || size == 0) {
1750                         prom_printf("SML get allocated size failed\n");
1751                         return;
1752                 }
1753         } else {
1754                 if (call_prom_ret("call-method", 2, 2, &size,
1755                                   ADDR("sml-get-handover-size"),
1756                                   ibmvtpm_inst) != 0 || size == 0) {
1757                         prom_printf("SML get handover size failed\n");
1758                         return;
1759                 }
1760         }
1761
1762         base = alloc_down(size, PAGE_SIZE, 0);
1763         if (base == 0)
1764                 prom_panic("Could not allocate memory for sml\n");
1765
1766         prom_printf("instantiating sml at 0x%llx...", base);
1767
1768         memset((void *)base, 0, size);
1769
1770         if (call_prom_ret("call-method", 4, 2, &entry,
1771                           ADDR("sml-handover"),
1772                           ibmvtpm_inst, size, base) != 0 || entry == 0) {
1773                 prom_printf("SML handover failed\n");
1774                 return;
1775         }
1776         prom_printf(" done\n");
1777
1778         reserve_mem(base, size);
1779
1780         prom_setprop(ibmvtpm_node, "/vdevice/vtpm", "linux,sml-base",
1781                      &base, sizeof(base));
1782         prom_setprop(ibmvtpm_node, "/vdevice/vtpm", "linux,sml-size",
1783                      &size, sizeof(size));
1784
1785         prom_debug("sml base     = 0x%llx\n", base);
1786         prom_debug("sml size     = 0x%x\n", size);
1787
1788         prom_debug("prom_instantiate_sml: end...\n");
1789 }
1790
1791 /*
1792  * Allocate room for and initialize TCE tables
1793  */
1794 #ifdef __BIG_ENDIAN__
1795 static void __init prom_initialize_tce_table(void)
1796 {
1797         phandle node;
1798         ihandle phb_node;
1799         char compatible[64], type[64], model[64];
1800         char *path = prom_scratch;
1801         u64 base, align;
1802         u32 minalign, minsize;
1803         u64 tce_entry, *tce_entryp;
1804         u64 local_alloc_top, local_alloc_bottom;
1805         u64 i;
1806
1807         if (prom_iommu_off)
1808                 return;
1809
1810         prom_debug("starting prom_initialize_tce_table\n");
1811
1812         /* Cache current top of allocs so we reserve a single block */
1813         local_alloc_top = alloc_top_high;
1814         local_alloc_bottom = local_alloc_top;
1815
1816         /* Search all nodes looking for PHBs. */
1817         for (node = 0; prom_next_node(&node); ) {
1818                 compatible[0] = 0;
1819                 type[0] = 0;
1820                 model[0] = 0;
1821                 prom_getprop(node, "compatible",
1822                              compatible, sizeof(compatible));
1823                 prom_getprop(node, "device_type", type, sizeof(type));
1824                 prom_getprop(node, "model", model, sizeof(model));
1825
1826                 if ((type[0] == 0) || (strstr(type, "pci") == NULL))
1827                         continue;
1828
1829                 /* Keep the old logic intact to avoid regression. */
1830                 if (compatible[0] != 0) {
1831                         if ((strstr(compatible, "python") == NULL) &&
1832                             (strstr(compatible, "Speedwagon") == NULL) &&
1833                             (strstr(compatible, "Winnipeg") == NULL))
1834                                 continue;
1835                 } else if (model[0] != 0) {
1836                         if ((strstr(model, "ython") == NULL) &&
1837                             (strstr(model, "peedwagon") == NULL) &&
1838                             (strstr(model, "innipeg") == NULL))
1839                                 continue;
1840                 }
1841
1842                 if (prom_getprop(node, "tce-table-minalign", &minalign,
1843                                  sizeof(minalign)) == PROM_ERROR)
1844                         minalign = 0;
1845                 if (prom_getprop(node, "tce-table-minsize", &minsize,
1846                                  sizeof(minsize)) == PROM_ERROR)
1847                         minsize = 4UL << 20;
1848
1849                 /*
1850                  * Even though we read what OF wants, we just set the table
1851                  * size to 4 MB.  This is enough to map 2GB of PCI DMA space.
1852                  * By doing this, we avoid the pitfalls of trying to DMA to
1853                  * MMIO space and the DMA alias hole.
1854                  */
1855                 minsize = 4UL << 20;
1856
1857                 /* Align to the greater of the align or size */
1858                 align = max(minalign, minsize);
1859                 base = alloc_down(minsize, align, 1);
1860                 if (base == 0)
1861                         prom_panic("ERROR, cannot find space for TCE table.\n");
1862                 if (base < local_alloc_bottom)
1863                         local_alloc_bottom = base;
1864
1865                 /* It seems OF doesn't null-terminate the path :-( */
1866                 memset(path, 0, PROM_SCRATCH_SIZE);
1867                 /* Call OF to setup the TCE hardware */
1868                 if (call_prom("package-to-path", 3, 1, node,
1869                               path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) {
1870                         prom_printf("package-to-path failed\n");
1871                 }
1872
1873                 /* Save away the TCE table attributes for later use. */
1874                 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base));
1875                 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize));
1876
1877                 prom_debug("TCE table: %s\n", path);
1878                 prom_debug("\tnode = 0x%x\n", node);
1879                 prom_debug("\tbase = 0x%llx\n", base);
1880                 prom_debug("\tsize = 0x%x\n", minsize);
1881
1882                 /* Initialize the table to have a one-to-one mapping
1883                  * over the allocated size.
1884                  */
1885                 tce_entryp = (u64 *)base;
1886                 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) {
1887                         tce_entry = (i << PAGE_SHIFT);
1888                         tce_entry |= 0x3;
1889                         *tce_entryp = tce_entry;
1890                 }
1891
1892                 prom_printf("opening PHB %s", path);
1893                 phb_node = call_prom("open", 1, 1, path);
1894                 if (phb_node == 0)
1895                         prom_printf("... failed\n");
1896                 else
1897                         prom_printf("... done\n");
1898
1899                 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"),
1900                           phb_node, -1, minsize,
1901                           (u32) base, (u32) (base >> 32));
1902                 call_prom("close", 1, 0, phb_node);
1903         }
1904
1905         reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom);
1906
1907         /* These are only really needed if there is a memory limit in
1908          * effect, but we don't know so export them always. */
1909         prom_tce_alloc_start = local_alloc_bottom;
1910         prom_tce_alloc_end = local_alloc_top;
1911
1912         /* Flag the first invalid entry */
1913         prom_debug("ending prom_initialize_tce_table\n");
1914 }
1915 #endif /* __BIG_ENDIAN__ */
1916 #endif /* CONFIG_PPC64 */
1917
1918 /*
1919  * With CHRP SMP we need to use the OF to start the other processors.
1920  * We can't wait until smp_boot_cpus (the OF is trashed by then)
1921  * so we have to put the processors into a holding pattern controlled
1922  * by the kernel (not OF) before we destroy the OF.
1923  *
1924  * This uses a chunk of low memory, puts some holding pattern
1925  * code there and sends the other processors off to there until
1926  * smp_boot_cpus tells them to do something.  The holding pattern
1927  * checks that address until its cpu # is there, when it is that
1928  * cpu jumps to __secondary_start().  smp_boot_cpus() takes care
1929  * of setting those values.
1930  *
1931  * We also use physical address 0x4 here to tell when a cpu
1932  * is in its holding pattern code.
1933  *
1934  * -- Cort
1935  */
1936 /*
1937  * We want to reference the copy of __secondary_hold_* in the
1938  * 0 - 0x100 address range
1939  */
1940 #define LOW_ADDR(x)     (((unsigned long) &(x)) & 0xff)
1941
1942 static void __init prom_hold_cpus(void)
1943 {
1944         unsigned long i;
1945         phandle node;
1946         char type[64];
1947         unsigned long *spinloop
1948                 = (void *) LOW_ADDR(__secondary_hold_spinloop);
1949         unsigned long *acknowledge
1950                 = (void *) LOW_ADDR(__secondary_hold_acknowledge);
1951         unsigned long secondary_hold = LOW_ADDR(__secondary_hold);
1952
1953         /*
1954          * On pseries, if RTAS supports "query-cpu-stopped-state",
1955          * we skip this stage, the CPUs will be started by the
1956          * kernel using RTAS.
1957          */
1958         if ((of_platform == PLATFORM_PSERIES ||
1959              of_platform == PLATFORM_PSERIES_LPAR) &&
1960             rtas_has_query_cpu_stopped) {
1961                 prom_printf("prom_hold_cpus: skipped\n");
1962                 return;
1963         }
1964
1965         prom_debug("prom_hold_cpus: start...\n");
1966         prom_debug("    1) spinloop       = 0x%lx\n", (unsigned long)spinloop);
1967         prom_debug("    1) *spinloop      = 0x%lx\n", *spinloop);
1968         prom_debug("    1) acknowledge    = 0x%lx\n",
1969                    (unsigned long)acknowledge);
1970         prom_debug("    1) *acknowledge   = 0x%lx\n", *acknowledge);
1971         prom_debug("    1) secondary_hold = 0x%lx\n", secondary_hold);
1972
1973         /* Set the common spinloop variable, so all of the secondary cpus
1974          * will block when they are awakened from their OF spinloop.
1975          * This must occur for both SMP and non SMP kernels, since OF will
1976          * be trashed when we move the kernel.
1977          */
1978         *spinloop = 0;
1979
1980         /* look for cpus */
1981         for (node = 0; prom_next_node(&node); ) {
1982                 unsigned int cpu_no;
1983                 __be32 reg;
1984
1985                 type[0] = 0;
1986                 prom_getprop(node, "device_type", type, sizeof(type));
1987                 if (strcmp(type, "cpu") != 0)
1988                         continue;
1989
1990                 /* Skip non-configured cpus. */
1991                 if (prom_getprop(node, "status", type, sizeof(type)) > 0)
1992                         if (strcmp(type, "okay") != 0)
1993                                 continue;
1994
1995                 reg = cpu_to_be32(-1); /* make sparse happy */
1996                 prom_getprop(node, "reg", &reg, sizeof(reg));
1997                 cpu_no = be32_to_cpu(reg);
1998
1999                 prom_debug("cpu hw idx   = %u\n", cpu_no);
2000
2001                 /* Init the acknowledge var which will be reset by
2002                  * the secondary cpu when it awakens from its OF
2003                  * spinloop.
2004                  */
2005                 *acknowledge = (unsigned long)-1;
2006
2007                 if (cpu_no != prom.cpu) {
2008                         /* Primary Thread of non-boot cpu or any thread */
2009                         prom_printf("starting cpu hw idx %u... ", cpu_no);
2010                         call_prom("start-cpu", 3, 0, node,
2011                                   secondary_hold, cpu_no);
2012
2013                         for (i = 0; (i < 100000000) &&
2014                              (*acknowledge == ((unsigned long)-1)); i++ )
2015                                 mb();
2016
2017                         if (*acknowledge == cpu_no)
2018                                 prom_printf("done\n");
2019                         else
2020                                 prom_printf("failed: %lx\n", *acknowledge);
2021                 }
2022 #ifdef CONFIG_SMP
2023                 else
2024                         prom_printf("boot cpu hw idx %u\n", cpu_no);
2025 #endif /* CONFIG_SMP */
2026         }
2027
2028         prom_debug("prom_hold_cpus: end...\n");
2029 }
2030
2031
2032 static void __init prom_init_client_services(unsigned long pp)
2033 {
2034         /* Get a handle to the prom entry point before anything else */
2035         prom_entry = pp;
2036
2037         /* get a handle for the stdout device */
2038         prom.chosen = call_prom("finddevice", 1, 1, ADDR("/chosen"));
2039         if (!PHANDLE_VALID(prom.chosen))
2040                 prom_panic("cannot find chosen"); /* msg won't be printed :( */
2041
2042         /* get device tree root */
2043         prom.root = call_prom("finddevice", 1, 1, ADDR("/"));
2044         if (!PHANDLE_VALID(prom.root))
2045                 prom_panic("cannot find device tree root"); /* msg won't be printed :( */
2046
2047         prom.mmumap = 0;
2048 }
2049
2050 #ifdef CONFIG_PPC32
2051 /*
2052  * For really old powermacs, we need to map things we claim.
2053  * For that, we need the ihandle of the mmu.
2054  * Also, on the longtrail, we need to work around other bugs.
2055  */
2056 static void __init prom_find_mmu(void)
2057 {
2058         phandle oprom;
2059         char version[64];
2060
2061         oprom = call_prom("finddevice", 1, 1, ADDR("/openprom"));
2062         if (!PHANDLE_VALID(oprom))
2063                 return;
2064         if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0)
2065                 return;
2066         version[sizeof(version) - 1] = 0;
2067         /* XXX might need to add other versions here */
2068         if (strcmp(version, "Open Firmware, 1.0.5") == 0)
2069                 of_workarounds = OF_WA_CLAIM;
2070         else if (strncmp(version, "FirmWorks,3.", 12) == 0) {
2071                 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL;
2072                 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim");
2073         } else
2074                 return;
2075         prom.memory = call_prom("open", 1, 1, ADDR("/memory"));
2076         prom_getprop(prom.chosen, "mmu", &prom.mmumap,
2077                      sizeof(prom.mmumap));
2078         prom.mmumap = be32_to_cpu(prom.mmumap);
2079         if (!IHANDLE_VALID(prom.memory) || !IHANDLE_VALID(prom.mmumap))
2080                 of_workarounds &= ~OF_WA_CLAIM;         /* hmmm */
2081 }
2082 #else
2083 #define prom_find_mmu()
2084 #endif
2085
2086 static void __init prom_init_stdout(void)
2087 {
2088         char *path = of_stdout_device;
2089         char type[16];
2090         phandle stdout_node;
2091         __be32 val;
2092
2093         if (prom_getprop(prom.chosen, "stdout", &val, sizeof(val)) <= 0)
2094                 prom_panic("cannot find stdout");
2095
2096         prom.stdout = be32_to_cpu(val);
2097
2098         /* Get the full OF pathname of the stdout device */
2099         memset(path, 0, 256);
2100         call_prom("instance-to-path", 3, 1, prom.stdout, path, 255);
2101         prom_printf("OF stdout device is: %s\n", of_stdout_device);
2102         prom_setprop(prom.chosen, "/chosen", "linux,stdout-path",
2103                      path, strlen(path) + 1);
2104
2105         /* instance-to-package fails on PA-Semi */
2106         stdout_node = call_prom("instance-to-package", 1, 1, prom.stdout);
2107         if (stdout_node != PROM_ERROR) {
2108                 val = cpu_to_be32(stdout_node);
2109
2110                 /* If it's a display, note it */
2111                 memset(type, 0, sizeof(type));
2112                 prom_getprop(stdout_node, "device_type", type, sizeof(type));
2113                 if (strcmp(type, "display") == 0)
2114                         prom_setprop(stdout_node, path, "linux,boot-display", NULL, 0);
2115         }
2116 }
2117
2118 static int __init prom_find_machine_type(void)
2119 {
2120         char compat[256];
2121         int len, i = 0;
2122 #ifdef CONFIG_PPC64
2123         phandle rtas;
2124         int x;
2125 #endif
2126
2127         /* Look for a PowerMac or a Cell */
2128         len = prom_getprop(prom.root, "compatible",
2129                            compat, sizeof(compat)-1);
2130         if (len > 0) {
2131                 compat[len] = 0;
2132                 while (i < len) {
2133                         char *p = &compat[i];
2134                         int sl = strlen(p);
2135                         if (sl == 0)
2136                                 break;
2137                         if (strstr(p, "Power Macintosh") ||
2138                             strstr(p, "MacRISC"))
2139                                 return PLATFORM_POWERMAC;
2140 #ifdef CONFIG_PPC64
2141                         /* We must make sure we don't detect the IBM Cell
2142                          * blades as pSeries due to some firmware issues,
2143                          * so we do it here.
2144                          */
2145                         if (strstr(p, "IBM,CBEA") ||
2146                             strstr(p, "IBM,CPBW-1.0"))
2147                                 return PLATFORM_GENERIC;
2148 #endif /* CONFIG_PPC64 */
2149                         i += sl + 1;
2150                 }
2151         }
2152 #ifdef CONFIG_PPC64
2153         /* Try to detect OPAL */
2154         if (PHANDLE_VALID(call_prom("finddevice", 1, 1, ADDR("/ibm,opal"))))
2155                 return PLATFORM_OPAL;
2156
2157         /* Try to figure out if it's an IBM pSeries or any other
2158          * PAPR compliant platform. We assume it is if :
2159          *  - /device_type is "chrp" (please, do NOT use that for future
2160          *    non-IBM designs !
2161          *  - it has /rtas
2162          */
2163         len = prom_getprop(prom.root, "device_type",
2164                            compat, sizeof(compat)-1);
2165         if (len <= 0)
2166                 return PLATFORM_GENERIC;
2167         if (strcmp(compat, "chrp"))
2168                 return PLATFORM_GENERIC;
2169
2170         /* Default to pSeries. We need to know if we are running LPAR */
2171         rtas = call_prom("finddevice", 1, 1, ADDR("/rtas"));
2172         if (!PHANDLE_VALID(rtas))
2173                 return PLATFORM_GENERIC;
2174         x = prom_getproplen(rtas, "ibm,hypertas-functions");
2175         if (x != PROM_ERROR) {
2176                 prom_debug("Hypertas detected, assuming LPAR !\n");
2177                 return PLATFORM_PSERIES_LPAR;
2178         }
2179         return PLATFORM_PSERIES;
2180 #else
2181         return PLATFORM_GENERIC;
2182 #endif
2183 }
2184
2185 static int __init prom_set_color(ihandle ih, int i, int r, int g, int b)
2186 {
2187         return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r);
2188 }
2189
2190 /*
2191  * If we have a display that we don't know how to drive,
2192  * we will want to try to execute OF's open method for it
2193  * later.  However, OF will probably fall over if we do that
2194  * we've taken over the MMU.
2195  * So we check whether we will need to open the display,
2196  * and if so, open it now.
2197  */
2198 static void __init prom_check_displays(void)
2199 {
2200         char type[16], *path;
2201         phandle node;
2202         ihandle ih;
2203         int i;
2204
2205         static unsigned char default_colors[] = {
2206                 0x00, 0x00, 0x00,
2207                 0x00, 0x00, 0xaa,
2208                 0x00, 0xaa, 0x00,
2209                 0x00, 0xaa, 0xaa,
2210                 0xaa, 0x00, 0x00,
2211                 0xaa, 0x00, 0xaa,
2212                 0xaa, 0xaa, 0x00,
2213                 0xaa, 0xaa, 0xaa,
2214                 0x55, 0x55, 0x55,
2215                 0x55, 0x55, 0xff,
2216                 0x55, 0xff, 0x55,
2217                 0x55, 0xff, 0xff,
2218                 0xff, 0x55, 0x55,
2219                 0xff, 0x55, 0xff,
2220                 0xff, 0xff, 0x55,
2221                 0xff, 0xff, 0xff
2222         };
2223         const unsigned char *clut;
2224
2225         prom_debug("Looking for displays\n");
2226         for (node = 0; prom_next_node(&node); ) {
2227                 memset(type, 0, sizeof(type));
2228                 prom_getprop(node, "device_type", type, sizeof(type));
2229                 if (strcmp(type, "display") != 0)
2230                         continue;
2231
2232                 /* It seems OF doesn't null-terminate the path :-( */
2233                 path = prom_scratch;
2234                 memset(path, 0, PROM_SCRATCH_SIZE);
2235
2236                 /*
2237                  * leave some room at the end of the path for appending extra
2238                  * arguments
2239                  */
2240                 if (call_prom("package-to-path", 3, 1, node, path,
2241                               PROM_SCRATCH_SIZE-10) == PROM_ERROR)
2242                         continue;
2243                 prom_printf("found display   : %s, opening... ", path);
2244
2245                 ih = call_prom("open", 1, 1, path);
2246                 if (ih == 0) {
2247                         prom_printf("failed\n");
2248                         continue;
2249                 }
2250
2251                 /* Success */
2252                 prom_printf("done\n");
2253                 prom_setprop(node, path, "linux,opened", NULL, 0);
2254
2255                 /* Setup a usable color table when the appropriate
2256                  * method is available. Should update this to set-colors */
2257                 clut = default_colors;
2258                 for (i = 0; i < 16; i++, clut += 3)
2259                         if (prom_set_color(ih, i, clut[0], clut[1],
2260                                            clut[2]) != 0)
2261                                 break;
2262
2263 #ifdef CONFIG_LOGO_LINUX_CLUT224
2264                 clut = PTRRELOC(logo_linux_clut224.clut);
2265                 for (i = 0; i < logo_linux_clut224.clutsize; i++, clut += 3)
2266                         if (prom_set_color(ih, i + 32, clut[0], clut[1],
2267                                            clut[2]) != 0)
2268                                 break;
2269 #endif /* CONFIG_LOGO_LINUX_CLUT224 */
2270
2271 #ifdef CONFIG_PPC_EARLY_DEBUG_BOOTX
2272                 if (prom_getprop(node, "linux,boot-display", NULL, 0) !=
2273                     PROM_ERROR) {
2274                         u32 width, height, pitch, addr;
2275
2276                         prom_printf("Setting btext !\n");
2277                         prom_getprop(node, "width", &width, 4);
2278                         prom_getprop(node, "height", &height, 4);
2279                         prom_getprop(node, "linebytes", &pitch, 4);
2280                         prom_getprop(node, "address", &addr, 4);
2281                         prom_printf("W=%d H=%d LB=%d addr=0x%x\n",
2282                                     width, height, pitch, addr);
2283                         btext_setup_display(width, height, 8, pitch, addr);
2284                 }
2285 #endif /* CONFIG_PPC_EARLY_DEBUG_BOOTX */
2286         }
2287 }
2288
2289
2290 /* Return (relocated) pointer to this much memory: moves initrd if reqd. */
2291 static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end,
2292                               unsigned long needed, unsigned long align)
2293 {
2294         void *ret;
2295
2296         *mem_start = _ALIGN(*mem_start, align);
2297         while ((*mem_start + needed) > *mem_end) {
2298                 unsigned long room, chunk;
2299
2300                 prom_debug("Chunk exhausted, claiming more at %lx...\n",
2301                            alloc_bottom);
2302                 room = alloc_top - alloc_bottom;
2303                 if (room > DEVTREE_CHUNK_SIZE)
2304                         room = DEVTREE_CHUNK_SIZE;
2305                 if (room < PAGE_SIZE)
2306                         prom_panic("No memory for flatten_device_tree "
2307                                    "(no room)\n");
2308                 chunk = alloc_up(room, 0);
2309                 if (chunk == 0)
2310                         prom_panic("No memory for flatten_device_tree "
2311                                    "(claim failed)\n");
2312                 *mem_end = chunk + room;
2313         }
2314
2315         ret = (void *)*mem_start;
2316         *mem_start += needed;
2317
2318         return ret;
2319 }
2320
2321 #define dt_push_token(token, mem_start, mem_end) do {                   \
2322                 void *room = make_room(mem_start, mem_end, 4, 4);       \
2323                 *(__be32 *)room = cpu_to_be32(token);                   \
2324         } while(0)
2325
2326 static unsigned long __init dt_find_string(char *str)
2327 {
2328         char *s, *os;
2329
2330         s = os = (char *)dt_string_start;
2331         s += 4;
2332         while (s <  (char *)dt_string_end) {
2333                 if (strcmp(s, str) == 0)
2334                         return s - os;
2335                 s += strlen(s) + 1;
2336         }
2337         return 0;
2338 }
2339
2340 /*
2341  * The Open Firmware 1275 specification states properties must be 31 bytes or
2342  * less, however not all firmwares obey this. Make it 64 bytes to be safe.
2343  */
2344 #define MAX_PROPERTY_NAME 64
2345
2346 static void __init scan_dt_build_strings(phandle node,
2347                                          unsigned long *mem_start,
2348                                          unsigned long *mem_end)
2349 {
2350         char *prev_name, *namep, *sstart;
2351         unsigned long soff;
2352         phandle child;
2353
2354         sstart =  (char *)dt_string_start;
2355
2356         /* get and store all property names */
2357         prev_name = "";
2358         for (;;) {
2359                 /* 64 is max len of name including nul. */
2360                 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1);
2361                 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) {
2362                         /* No more nodes: unwind alloc */
2363                         *mem_start = (unsigned long)namep;
2364                         break;
2365                 }
2366
2367                 /* skip "name" */
2368                 if (strcmp(namep, "name") == 0) {
2369                         *mem_start = (unsigned long)namep;
2370                         prev_name = "name";
2371                         continue;
2372                 }
2373                 /* get/create string entry */
2374                 soff = dt_find_string(namep);
2375                 if (soff != 0) {
2376                         *mem_start = (unsigned long)namep;
2377                         namep = sstart + soff;
2378                 } else {
2379                         /* Trim off some if we can */
2380                         *mem_start = (unsigned long)namep + strlen(namep) + 1;
2381                         dt_string_end = *mem_start;
2382                 }
2383                 prev_name = namep;
2384         }
2385
2386         /* do all our children */
2387         child = call_prom("child", 1, 1, node);
2388         while (child != 0) {
2389                 scan_dt_build_strings(child, mem_start, mem_end);
2390                 child = call_prom("peer", 1, 1, child);
2391         }
2392 }
2393
2394 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
2395                                         unsigned long *mem_end)
2396 {
2397         phandle child;
2398         char *namep, *prev_name, *sstart, *p, *ep, *lp, *path;
2399         unsigned long soff;
2400         unsigned char *valp;
2401         static char pname[MAX_PROPERTY_NAME];
2402         int l, room, has_phandle = 0;
2403
2404         dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end);
2405
2406         /* get the node's full name */
2407         namep = (char *)*mem_start;
2408         room = *mem_end - *mem_start;
2409         if (room > 255)
2410                 room = 255;
2411         l = call_prom("package-to-path", 3, 1, node, namep, room);
2412         if (l >= 0) {
2413                 /* Didn't fit?  Get more room. */
2414                 if (l >= room) {
2415                         if (l >= *mem_end - *mem_start)
2416                                 namep = make_room(mem_start, mem_end, l+1, 1);
2417                         call_prom("package-to-path", 3, 1, node, namep, l);
2418                 }
2419                 namep[l] = '\0';
2420
2421                 /* Fixup an Apple bug where they have bogus \0 chars in the
2422                  * middle of the path in some properties, and extract
2423                  * the unit name (everything after the last '/').
2424                  */
2425                 for (lp = p = namep, ep = namep + l; p < ep; p++) {
2426                         if (*p == '/')
2427                                 lp = namep;
2428                         else if (*p != 0)
2429                                 *lp++ = *p;
2430                 }
2431                 *lp = 0;
2432                 *mem_start = _ALIGN((unsigned long)lp + 1, 4);
2433         }
2434
2435         /* get it again for debugging */
2436         path = prom_scratch;
2437         memset(path, 0, PROM_SCRATCH_SIZE);
2438         call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
2439
2440         /* get and store all properties */
2441         prev_name = "";
2442         sstart = (char *)dt_string_start;
2443         for (;;) {
2444                 if (call_prom("nextprop", 3, 1, node, prev_name,
2445                               pname) != 1)
2446                         break;
2447
2448                 /* skip "name" */
2449                 if (strcmp(pname, "name") == 0) {
2450                         prev_name = "name";
2451                         continue;
2452                 }
2453
2454                 /* find string offset */
2455                 soff = dt_find_string(pname);
2456                 if (soff == 0) {
2457                         prom_printf("WARNING: Can't find string index for"
2458                                     " <%s>, node %s\n", pname, path);
2459                         break;
2460                 }
2461                 prev_name = sstart + soff;
2462
2463                 /* get length */
2464                 l = call_prom("getproplen", 2, 1, node, pname);
2465
2466                 /* sanity checks */
2467                 if (l == PROM_ERROR)
2468                         continue;
2469
2470                 /* push property head */
2471                 dt_push_token(OF_DT_PROP, mem_start, mem_end);
2472                 dt_push_token(l, mem_start, mem_end);
2473                 dt_push_token(soff, mem_start, mem_end);
2474
2475                 /* push property content */
2476                 valp = make_room(mem_start, mem_end, l, 4);
2477                 call_prom("getprop", 4, 1, node, pname, valp, l);
2478                 *mem_start = _ALIGN(*mem_start, 4);
2479
2480                 if (!strcmp(pname, "phandle"))
2481                         has_phandle = 1;
2482         }
2483
2484         /* Add a "linux,phandle" property if no "phandle" property already
2485          * existed (can happen with OPAL)
2486          */
2487         if (!has_phandle) {
2488                 soff = dt_find_string("linux,phandle");
2489                 if (soff == 0)
2490                         prom_printf("WARNING: Can't find string index for"
2491                                     " <linux-phandle> node %s\n", path);
2492                 else {
2493                         dt_push_token(OF_DT_PROP, mem_start, mem_end);
2494                         dt_push_token(4, mem_start, mem_end);
2495                         dt_push_token(soff, mem_start, mem_end);
2496                         valp = make_room(mem_start, mem_end, 4, 4);
2497                         *(__be32 *)valp = cpu_to_be32(node);
2498                 }
2499         }
2500
2501         /* do all our children */
2502         child = call_prom("child", 1, 1, node);
2503         while (child != 0) {
2504                 scan_dt_build_struct(child, mem_start, mem_end);
2505                 child = call_prom("peer", 1, 1, child);
2506         }
2507
2508         dt_push_token(OF_DT_END_NODE, mem_start, mem_end);
2509 }
2510
2511 static void __init flatten_device_tree(void)
2512 {
2513         phandle root;
2514         unsigned long mem_start, mem_end, room;
2515         struct boot_param_header *hdr;
2516         char *namep;
2517         u64 *rsvmap;
2518
2519         /*
2520          * Check how much room we have between alloc top & bottom (+/- a
2521          * few pages), crop to 1MB, as this is our "chunk" size
2522          */
2523         room = alloc_top - alloc_bottom - 0x4000;
2524         if (room > DEVTREE_CHUNK_SIZE)
2525                 room = DEVTREE_CHUNK_SIZE;
2526         prom_debug("starting device tree allocs at %lx\n", alloc_bottom);
2527
2528         /* Now try to claim that */
2529         mem_start = (unsigned long)alloc_up(room, PAGE_SIZE);
2530         if (mem_start == 0)
2531                 prom_panic("Can't allocate initial device-tree chunk\n");
2532         mem_end = mem_start + room;
2533
2534         /* Get root of tree */
2535         root = call_prom("peer", 1, 1, (phandle)0);
2536         if (root == (phandle)0)
2537                 prom_panic ("couldn't get device tree root\n");
2538
2539         /* Build header and make room for mem rsv map */
2540         mem_start = _ALIGN(mem_start, 4);
2541         hdr = make_room(&mem_start, &mem_end,
2542                         sizeof(struct boot_param_header), 4);
2543         dt_header_start = (unsigned long)hdr;
2544         rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8);
2545
2546         /* Start of strings */
2547         mem_start = PAGE_ALIGN(mem_start);
2548         dt_string_start = mem_start;
2549         mem_start += 4; /* hole */
2550
2551         /* Add "linux,phandle" in there, we'll need it */
2552         namep = make_room(&mem_start, &mem_end, 16, 1);
2553         strcpy(namep, "linux,phandle");
2554         mem_start = (unsigned long)namep + strlen(namep) + 1;
2555
2556         /* Build string array */
2557         prom_printf("Building dt strings...\n");
2558         scan_dt_build_strings(root, &mem_start, &mem_end);
2559         dt_string_end = mem_start;
2560
2561         /* Build structure */
2562         mem_start = PAGE_ALIGN(mem_start);
2563         dt_struct_start = mem_start;
2564         prom_printf("Building dt structure...\n");
2565         scan_dt_build_struct(root, &mem_start, &mem_end);
2566         dt_push_token(OF_DT_END, &mem_start, &mem_end);
2567         dt_struct_end = PAGE_ALIGN(mem_start);
2568
2569         /* Finish header */
2570         hdr->boot_cpuid_phys = cpu_to_be32(prom.cpu);
2571         hdr->magic = cpu_to_be32(OF_DT_HEADER);
2572         hdr->totalsize = cpu_to_be32(dt_struct_end - dt_header_start);
2573         hdr->off_dt_struct = cpu_to_be32(dt_struct_start - dt_header_start);
2574         hdr->off_dt_strings = cpu_to_be32(dt_string_start - dt_header_start);
2575         hdr->dt_strings_size = cpu_to_be32(dt_string_end - dt_string_start);
2576         hdr->off_mem_rsvmap = cpu_to_be32(((unsigned long)rsvmap) - dt_header_start);
2577         hdr->version = cpu_to_be32(OF_DT_VERSION);
2578         /* Version 16 is not backward compatible */
2579         hdr->last_comp_version = cpu_to_be32(0x10);
2580
2581         /* Copy the reserve map in */
2582         memcpy(rsvmap, mem_reserve_map, sizeof(mem_reserve_map));
2583
2584 #ifdef DEBUG_PROM
2585         {
2586                 int i;
2587                 prom_printf("reserved memory map:\n");
2588                 for (i = 0; i < mem_reserve_cnt; i++)
2589                         prom_printf("  %llx - %llx\n",
2590                                     be64_to_cpu(mem_reserve_map[i].base),
2591                                     be64_to_cpu(mem_reserve_map[i].size));
2592         }
2593 #endif
2594         /* Bump mem_reserve_cnt to cause further reservations to fail
2595          * since it's too late.
2596          */
2597         mem_reserve_cnt = MEM_RESERVE_MAP_SIZE;
2598
2599         prom_printf("Device tree strings 0x%lx -> 0x%lx\n",
2600                     dt_string_start, dt_string_end);
2601         prom_printf("Device tree struct  0x%lx -> 0x%lx\n",
2602                     dt_struct_start, dt_struct_end);
2603 }
2604
2605 #ifdef CONFIG_PPC_MAPLE
2606 /* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property.
2607  * The values are bad, and it doesn't even have the right number of cells. */
2608 static void __init fixup_device_tree_maple(void)
2609 {
2610         phandle isa;
2611         u32 rloc = 0x01002000; /* IO space; PCI device = 4 */
2612         u32 isa_ranges[6];
2613         char *name;
2614
2615         name = "/ht@0/isa@4";
2616         isa = call_prom("finddevice", 1, 1, ADDR(name));
2617         if (!PHANDLE_VALID(isa)) {
2618                 name = "/ht@0/isa@6";
2619                 isa = call_prom("finddevice", 1, 1, ADDR(name));
2620                 rloc = 0x01003000; /* IO space; PCI device = 6 */
2621         }
2622         if (!PHANDLE_VALID(isa))
2623                 return;
2624
2625         if (prom_getproplen(isa, "ranges") != 12)
2626                 return;
2627         if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges))
2628                 == PROM_ERROR)
2629                 return;
2630
2631         if (isa_ranges[0] != 0x1 ||
2632                 isa_ranges[1] != 0xf4000000 ||
2633                 isa_ranges[2] != 0x00010000)
2634                 return;
2635
2636         prom_printf("Fixing up bogus ISA range on Maple/Apache...\n");
2637
2638         isa_ranges[0] = 0x1;
2639         isa_ranges[1] = 0x0;
2640         isa_ranges[2] = rloc;
2641         isa_ranges[3] = 0x0;
2642         isa_ranges[4] = 0x0;
2643         isa_ranges[5] = 0x00010000;
2644         prom_setprop(isa, name, "ranges",
2645                         isa_ranges, sizeof(isa_ranges));
2646 }
2647
2648 #define CPC925_MC_START         0xf8000000
2649 #define CPC925_MC_LENGTH        0x1000000
2650 /* The values for memory-controller don't have right number of cells */
2651 static void __init fixup_device_tree_maple_memory_controller(void)
2652 {
2653         phandle mc;
2654         u32 mc_reg[4];
2655         char *name = "/hostbridge@f8000000";
2656         u32 ac, sc;
2657
2658         mc = call_prom("finddevice", 1, 1, ADDR(name));
2659         if (!PHANDLE_VALID(mc))
2660                 return;
2661
2662         if (prom_getproplen(mc, "reg") != 8)
2663                 return;
2664
2665         prom_getprop(prom.root, "#address-cells", &ac, sizeof(ac));
2666         prom_getprop(prom.root, "#size-cells", &sc, sizeof(sc));
2667         if ((ac != 2) || (sc != 2))
2668                 return;
2669
2670         if (prom_getprop(mc, "reg", mc_reg, sizeof(mc_reg)) == PROM_ERROR)
2671                 return;
2672
2673         if (mc_reg[0] != CPC925_MC_START || mc_reg[1] != CPC925_MC_LENGTH)
2674                 return;
2675
2676         prom_printf("Fixing up bogus hostbridge on Maple...\n");
2677
2678         mc_reg[0] = 0x0;
2679         mc_reg[1] = CPC925_MC_START;
2680         mc_reg[2] = 0x0;
2681         mc_reg[3] = CPC925_MC_LENGTH;
2682         prom_setprop(mc, name, "reg", mc_reg, sizeof(mc_reg));
2683 }
2684 #else
2685 #define fixup_device_tree_maple()
2686 #define fixup_device_tree_maple_memory_controller()
2687 #endif
2688
2689 #ifdef CONFIG_PPC_CHRP
2690 /*
2691  * Pegasos and BriQ lacks the "ranges" property in the isa node
2692  * Pegasos needs decimal IRQ 14/15, not hexadecimal
2693  * Pegasos has the IDE configured in legacy mode, but advertised as native
2694  */
2695 static void __init fixup_device_tree_chrp(void)
2696 {
2697         phandle ph;
2698         u32 prop[6];
2699         u32 rloc = 0x01006000; /* IO space; PCI device = 12 */
2700         char *name;
2701         int rc;
2702
2703         name = "/pci@80000000/isa@c";
2704         ph = call_prom("finddevice", 1, 1, ADDR(name));
2705         if (!PHANDLE_VALID(ph)) {
2706                 name = "/pci@ff500000/isa@6";
2707                 ph = call_prom("finddevice", 1, 1, ADDR(name));
2708                 rloc = 0x01003000; /* IO space; PCI device = 6 */
2709         }
2710         if (PHANDLE_VALID(ph)) {
2711                 rc = prom_getproplen(ph, "ranges");
2712                 if (rc == 0 || rc == PROM_ERROR) {
2713                         prom_printf("Fixing up missing ISA range on Pegasos...\n");
2714
2715                         prop[0] = 0x1;
2716                         prop[1] = 0x0;
2717                         prop[2] = rloc;
2718                         prop[3] = 0x0;
2719                         prop[4] = 0x0;
2720                         prop[5] = 0x00010000;
2721                         prom_setprop(ph, name, "ranges", prop, sizeof(prop));
2722                 }
2723         }
2724
2725         name = "/pci@80000000/ide@C,1";
2726         ph = call_prom("finddevice", 1, 1, ADDR(name));
2727         if (PHANDLE_VALID(ph)) {
2728                 prom_printf("Fixing up IDE interrupt on Pegasos...\n");
2729                 prop[0] = 14;
2730                 prop[1] = 0x0;
2731                 prom_setprop(ph, name, "interrupts", prop, 2*sizeof(u32));
2732                 prom_printf("Fixing up IDE class-code on Pegasos...\n");
2733                 rc = prom_getprop(ph, "class-code", prop, sizeof(u32));
2734                 if (rc == sizeof(u32)) {
2735                         prop[0] &= ~0x5;
2736                         prom_setprop(ph, name, "class-code", prop, sizeof(u32));
2737                 }
2738         }
2739 }
2740 #else
2741 #define fixup_device_tree_chrp()
2742 #endif
2743
2744 #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC)
2745 static void __init fixup_device_tree_pmac(void)
2746 {
2747         phandle u3, i2c, mpic;
2748         u32 u3_rev;
2749         u32 interrupts[2];
2750         u32 parent;
2751
2752         /* Some G5s have a missing interrupt definition, fix it up here */
2753         u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000"));
2754         if (!PHANDLE_VALID(u3))
2755                 return;
2756         i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000"));
2757         if (!PHANDLE_VALID(i2c))
2758                 return;
2759         mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000"));
2760         if (!PHANDLE_VALID(mpic))
2761                 return;
2762
2763         /* check if proper rev of u3 */
2764         if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev))
2765             == PROM_ERROR)
2766                 return;
2767         if (u3_rev < 0x35 || u3_rev > 0x39)
2768                 return;
2769         /* does it need fixup ? */
2770         if (prom_getproplen(i2c, "interrupts") > 0)
2771                 return;
2772
2773         prom_printf("fixing up bogus interrupts for u3 i2c...\n");
2774
2775         /* interrupt on this revision of u3 is number 0 and level */
2776         interrupts[0] = 0;
2777         interrupts[1] = 1;
2778         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts",
2779                      &interrupts, sizeof(interrupts));
2780         parent = (u32)mpic;
2781         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent",
2782                      &parent, sizeof(parent));
2783 }
2784 #else
2785 #define fixup_device_tree_pmac()
2786 #endif
2787
2788 #ifdef CONFIG_PPC_EFIKA
2789 /*
2790  * The MPC5200 FEC driver requires an phy-handle property to tell it how
2791  * to talk to the phy.  If the phy-handle property is missing, then this
2792  * function is called to add the appropriate nodes and link it to the
2793  * ethernet node.
2794  */
2795 static void __init fixup_device_tree_efika_add_phy(void)
2796 {
2797         u32 node;
2798         char prop[64];
2799         int rv;
2800
2801         /* Check if /builtin/ethernet exists - bail if it doesn't */
2802         node = call_prom("finddevice", 1, 1, ADDR("/builtin/ethernet"));
2803         if (!PHANDLE_VALID(node))
2804                 return;
2805
2806         /* Check if the phy-handle property exists - bail if it does */
2807         rv = prom_getprop(node, "phy-handle", prop, sizeof(prop));
2808         if (rv <= 0)
2809                 return;
2810
2811         /*
2812          * At this point the ethernet device doesn't have a phy described.
2813          * Now we need to add the missing phy node and linkage
2814          */
2815
2816         /* Check for an MDIO bus node - if missing then create one */
2817         node = call_prom("finddevice", 1, 1, ADDR("/builtin/mdio"));
2818         if (!PHANDLE_VALID(node)) {
2819                 prom_printf("Adding Ethernet MDIO node\n");
2820                 call_prom("interpret", 1, 1,
2821                         " s\" /builtin\" find-device"
2822                         " new-device"
2823                                 " 1 encode-int s\" #address-cells\" property"
2824                                 " 0 encode-int s\" #size-cells\" property"
2825                                 " s\" mdio\" device-name"
2826                                 " s\" fsl,mpc5200b-mdio\" encode-string"
2827                                 " s\" compatible\" property"
2828                                 " 0xf0003000 0x400 reg"
2829                                 " 0x2 encode-int"
2830                                 " 0x5 encode-int encode+"
2831                                 " 0x3 encode-int encode+"
2832                                 " s\" interrupts\" property"
2833                         " finish-device");
2834         };
2835
2836         /* Check for a PHY device node - if missing then create one and
2837          * give it's phandle to the ethernet node */
2838         node = call_prom("finddevice", 1, 1,
2839                          ADDR("/builtin/mdio/ethernet-phy"));
2840         if (!PHANDLE_VALID(node)) {
2841                 prom_printf("Adding Ethernet PHY node\n");
2842                 call_prom("interpret", 1, 1,
2843                         " s\" /builtin/mdio\" find-device"
2844                         " new-device"
2845                                 " s\" ethernet-phy\" device-name"
2846                                 " 0x10 encode-int s\" reg\" property"
2847                                 " my-self"
2848                                 " ihandle>phandle"
2849                         " finish-device"
2850                         " s\" /builtin/ethernet\" find-device"
2851                                 " encode-int"
2852                                 " s\" phy-handle\" property"
2853                         " device-end");
2854         }
2855 }
2856
2857 static void __init fixup_device_tree_efika(void)
2858 {
2859         int sound_irq[3] = { 2, 2, 0 };
2860         int bcomm_irq[3*16] = { 3,0,0, 3,1,0, 3,2,0, 3,3,0,
2861                                 3,4,0, 3,5,0, 3,6,0, 3,7,0,
2862                                 3,8,0, 3,9,0, 3,10,0, 3,11,0,
2863                                 3,12,0, 3,13,0, 3,14,0, 3,15,0 };
2864         u32 node;
2865         char prop[64];
2866         int rv, len;
2867
2868         /* Check if we're really running on a EFIKA */
2869         node = call_prom("finddevice", 1, 1, ADDR("/"));
2870         if (!PHANDLE_VALID(node))
2871                 return;
2872
2873         rv = prom_getprop(node, "model", prop, sizeof(prop));
2874         if (rv == PROM_ERROR)
2875                 return;
2876         if (strcmp(prop, "EFIKA5K2"))
2877                 return;
2878
2879         prom_printf("Applying EFIKA device tree fixups\n");
2880
2881         /* Claiming to be 'chrp' is death */
2882         node = call_prom("finddevice", 1, 1, ADDR("/"));
2883         rv = prom_getprop(node, "device_type", prop, sizeof(prop));
2884         if (rv != PROM_ERROR && (strcmp(prop, "chrp") == 0))
2885                 prom_setprop(node, "/", "device_type", "efika", sizeof("efika"));
2886
2887         /* CODEGEN,description is exposed in /proc/cpuinfo so
2888            fix that too */
2889         rv = prom_getprop(node, "CODEGEN,description", prop, sizeof(prop));
2890         if (rv != PROM_ERROR && (strstr(prop, "CHRP")))
2891                 prom_setprop(node, "/", "CODEGEN,description",
2892                              "Efika 5200B PowerPC System",
2893                              sizeof("Efika 5200B PowerPC System"));
2894
2895         /* Fixup bestcomm interrupts property */
2896         node = call_prom("finddevice", 1, 1, ADDR("/builtin/bestcomm"));
2897         if (PHANDLE_VALID(node)) {
2898                 len = prom_getproplen(node, "interrupts");
2899                 if (len == 12) {
2900                         prom_printf("Fixing bestcomm interrupts property\n");
2901                         prom_setprop(node, "/builtin/bestcom", "interrupts",
2902                                      bcomm_irq, sizeof(bcomm_irq));
2903                 }
2904         }
2905
2906         /* Fixup sound interrupts property */
2907         node = call_prom("finddevice", 1, 1, ADDR("/builtin/sound"));
2908         if (PHANDLE_VALID(node)) {
2909                 rv = prom_getprop(node, "interrupts", prop, sizeof(prop));
2910                 if (rv == PROM_ERROR) {
2911                         prom_printf("Adding sound interrupts property\n");
2912                         prom_setprop(node, "/builtin/sound", "interrupts",
2913                                      sound_irq, sizeof(sound_irq));
2914                 }
2915         }
2916
2917         /* Make sure ethernet phy-handle property exists */
2918         fixup_device_tree_efika_add_phy();
2919 }
2920 #else
2921 #define fixup_device_tree_efika()
2922 #endif
2923
2924 #ifdef CONFIG_PPC_PASEMI_NEMO
2925 /*
2926  * CFE supplied on Nemo is broken in several ways, biggest
2927  * problem is that it reassigns ISA interrupts to unused mpic ints.
2928  * Add an interrupt-controller property for the io-bridge to use
2929  * and correct the ints so we can attach them to an irq_domain
2930  */
2931 static void __init fixup_device_tree_pasemi(void)
2932 {
2933         u32 interrupts[2], parent, rval, val = 0;
2934         char *name, *pci_name;
2935         phandle iob, node;
2936
2937         /* Find the root pci node */
2938         name = "/pxp@0,e0000000";
2939         iob = call_prom("finddevice", 1, 1, ADDR(name));
2940         if (!PHANDLE_VALID(iob))
2941                 return;
2942
2943         /* check if interrupt-controller node set yet */
2944         if (prom_getproplen(iob, "interrupt-controller") !=PROM_ERROR)
2945                 return;
2946
2947         prom_printf("adding interrupt-controller property for SB600...\n");
2948
2949         prom_setprop(iob, name, "interrupt-controller", &val, 0);
2950
2951         pci_name = "/pxp@0,e0000000/pci@11";
2952         node = call_prom("finddevice", 1, 1, ADDR(pci_name));
2953         parent = ADDR(iob);
2954
2955         for( ; prom_next_node(&node); ) {
2956                 /* scan each node for one with an interrupt */
2957                 if (!PHANDLE_VALID(node))
2958                         continue;
2959
2960                 rval = prom_getproplen(node, "interrupts");
2961                 if (rval == 0 || rval == PROM_ERROR)
2962                         continue;
2963
2964                 prom_getprop(node, "interrupts", &interrupts, sizeof(interrupts));
2965                 if ((interrupts[0] < 212) || (interrupts[0] > 222))
2966                         continue;
2967
2968                 /* found a node, update both interrupts and interrupt-parent */
2969                 if ((interrupts[0] >= 212) && (interrupts[0] <= 215))
2970                         interrupts[0] -= 203;
2971                 if ((interrupts[0] >= 216) && (interrupts[0] <= 220))
2972                         interrupts[0] -= 213;
2973                 if (interrupts[0] == 221)
2974                         interrupts[0] = 14;
2975                 if (interrupts[0] == 222)
2976                         interrupts[0] = 8;
2977
2978                 prom_setprop(node, pci_name, "interrupts", interrupts,
2979                                         sizeof(interrupts));
2980                 prom_setprop(node, pci_name, "interrupt-parent", &parent,
2981                                         sizeof(parent));
2982         }
2983
2984         /*
2985          * The io-bridge has device_type set to 'io-bridge' change it to 'isa'
2986          * so that generic isa-bridge code can add the SB600 and its on-board
2987          * peripherals.
2988          */
2989         name = "/pxp@0,e0000000/io-bridge@0";
2990         iob = call_prom("finddevice", 1, 1, ADDR(name));
2991         if (!PHANDLE_VALID(iob))
2992                 return;
2993
2994         /* device_type is already set, just change it. */
2995
2996         prom_printf("Changing device_type of SB600 node...\n");
2997
2998         prom_setprop(iob, name, "device_type", "isa", sizeof("isa"));
2999 }
3000 #else   /* !CONFIG_PPC_PASEMI_NEMO */
3001 static inline void fixup_device_tree_pasemi(void) { }
3002 #endif
3003
3004 static void __init fixup_device_tree(void)
3005 {
3006         fixup_device_tree_maple();
3007         fixup_device_tree_maple_memory_controller();
3008         fixup_device_tree_chrp();
3009         fixup_device_tree_pmac();
3010         fixup_device_tree_efika();
3011         fixup_device_tree_pasemi();
3012 }
3013
3014 static void __init prom_find_boot_cpu(void)
3015 {
3016         __be32 rval;
3017         ihandle prom_cpu;
3018         phandle cpu_pkg;
3019
3020         rval = 0;
3021         if (prom_getprop(prom.chosen, "cpu", &rval, sizeof(rval)) <= 0)
3022                 return;
3023         prom_cpu = be32_to_cpu(rval);
3024
3025         cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
3026
3027         if (!PHANDLE_VALID(cpu_pkg))
3028                 return;
3029
3030         prom_getprop(cpu_pkg, "reg", &rval, sizeof(rval));
3031         prom.cpu = be32_to_cpu(rval);
3032
3033         prom_debug("Booting CPU hw index = %d\n", prom.cpu);
3034 }
3035
3036 static void __init prom_check_initrd(unsigned long r3, unsigned long r4)
3037 {
3038 #ifdef CONFIG_BLK_DEV_INITRD
3039         if (r3 && r4 && r4 != 0xdeadbeef) {
3040                 __be64 val;
3041
3042                 prom_initrd_start = is_kernel_addr(r3) ? __pa(r3) : r3;
3043                 prom_initrd_end = prom_initrd_start + r4;
3044
3045                 val = cpu_to_be64(prom_initrd_start);
3046                 prom_setprop(prom.chosen, "/chosen", "linux,initrd-start",
3047                              &val, sizeof(val));
3048                 val = cpu_to_be64(prom_initrd_end);
3049                 prom_setprop(prom.chosen, "/chosen", "linux,initrd-end",
3050                              &val, sizeof(val));
3051
3052                 reserve_mem(prom_initrd_start,
3053                             prom_initrd_end - prom_initrd_start);
3054
3055                 prom_debug("initrd_start=0x%lx\n", prom_initrd_start);
3056                 prom_debug("initrd_end=0x%lx\n", prom_initrd_end);
3057         }
3058 #endif /* CONFIG_BLK_DEV_INITRD */
3059 }
3060
3061 #ifdef CONFIG_PPC64
3062 #ifdef CONFIG_RELOCATABLE
3063 static void reloc_toc(void)
3064 {
3065 }
3066
3067 static void unreloc_toc(void)
3068 {
3069 }
3070 #else
3071 static void __reloc_toc(unsigned long offset, unsigned long nr_entries)
3072 {
3073         unsigned long i;
3074         unsigned long *toc_entry;
3075
3076         /* Get the start of the TOC by using r2 directly. */
3077         asm volatile("addi %0,2,-0x8000" : "=b" (toc_entry));
3078
3079         for (i = 0; i < nr_entries; i++) {
3080                 *toc_entry = *toc_entry + offset;
3081                 toc_entry++;
3082         }
3083 }
3084
3085 static void reloc_toc(void)
3086 {
3087         unsigned long offset = reloc_offset();
3088         unsigned long nr_entries =
3089                 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long);
3090
3091         __reloc_toc(offset, nr_entries);
3092
3093         mb();
3094 }
3095
3096 static void unreloc_toc(void)
3097 {
3098         unsigned long offset = reloc_offset();
3099         unsigned long nr_entries =
3100                 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long);
3101
3102         mb();
3103
3104         __reloc_toc(-offset, nr_entries);
3105 }
3106 #endif
3107 #endif
3108
3109 /*
3110  * We enter here early on, when the Open Firmware prom is still
3111  * handling exceptions and the MMU hash table for us.
3112  */
3113
3114 unsigned long __init prom_init(unsigned long r3, unsigned long r4,
3115                                unsigned long pp,
3116                                unsigned long r6, unsigned long r7,
3117                                unsigned long kbase)
3118 {
3119         unsigned long hdr;
3120
3121 #ifdef CONFIG_PPC32
3122         unsigned long offset = reloc_offset();
3123         reloc_got2(offset);
3124 #else
3125         reloc_toc();
3126 #endif
3127
3128         /*
3129          * First zero the BSS
3130          */
3131         memset(&__bss_start, 0, __bss_stop - __bss_start);
3132
3133         /*
3134          * Init interface to Open Firmware, get some node references,
3135          * like /chosen
3136          */
3137         prom_init_client_services(pp);
3138
3139         /*
3140          * See if this OF is old enough that we need to do explicit maps
3141          * and other workarounds
3142          */
3143         prom_find_mmu();
3144
3145         /*
3146          * Init prom stdout device
3147          */
3148         prom_init_stdout();
3149
3150         prom_printf("Preparing to boot %s", linux_banner);
3151
3152         /*
3153          * Get default machine type. At this point, we do not differentiate
3154          * between pSeries SMP and pSeries LPAR
3155          */
3156         of_platform = prom_find_machine_type();
3157         prom_printf("Detected machine type: %x\n", of_platform);
3158
3159 #ifndef CONFIG_NONSTATIC_KERNEL
3160         /* Bail if this is a kdump kernel. */
3161         if (PHYSICAL_START > 0)
3162                 prom_panic("Error: You can't boot a kdump kernel from OF!\n");
3163 #endif
3164
3165         /*
3166          * Check for an initrd
3167          */
3168         prom_check_initrd(r3, r4);
3169
3170         /*
3171          * Do early parsing of command line
3172          */
3173         early_cmdline_parse();
3174
3175 #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
3176         /*
3177          * On pSeries, inform the firmware about our capabilities
3178          */
3179         if (of_platform == PLATFORM_PSERIES ||
3180             of_platform == PLATFORM_PSERIES_LPAR)
3181                 prom_send_capabilities();
3182 #endif
3183
3184         /*
3185          * Copy the CPU hold code
3186          */
3187         if (of_platform != PLATFORM_POWERMAC)
3188                 copy_and_flush(0, kbase, 0x100, 0);
3189
3190         /*
3191          * Initialize memory management within prom_init
3192          */
3193         prom_init_mem();
3194
3195         /*
3196          * Determine which cpu is actually running right _now_
3197          */
3198         prom_find_boot_cpu();
3199
3200         /*
3201          * Initialize display devices
3202          */
3203         prom_check_displays();
3204
3205 #if defined(CONFIG_PPC64) && defined(__BIG_ENDIAN__)
3206         /*
3207          * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else
3208          * that uses the allocator, we need to make sure we get the top of memory
3209          * available for us here...
3210          */
3211         if (of_platform == PLATFORM_PSERIES)
3212                 prom_initialize_tce_table();
3213 #endif
3214
3215         /*
3216          * On non-powermacs, try to instantiate RTAS. PowerMacs don't
3217          * have a usable RTAS implementation.
3218          */
3219         if (of_platform != PLATFORM_POWERMAC &&
3220             of_platform != PLATFORM_OPAL)
3221                 prom_instantiate_rtas();
3222
3223 #ifdef CONFIG_PPC_POWERNV
3224         if (of_platform == PLATFORM_OPAL)
3225                 prom_instantiate_opal();
3226 #endif /* CONFIG_PPC_POWERNV */
3227
3228 #ifdef CONFIG_PPC64
3229         /* instantiate sml */
3230         prom_instantiate_sml();
3231 #endif
3232
3233         /*
3234          * On non-powermacs, put all CPUs in spin-loops.
3235          *
3236          * PowerMacs use a different mechanism to spin CPUs
3237          *
3238          * (This must be done after instanciating RTAS)
3239          */
3240         if (of_platform != PLATFORM_POWERMAC &&
3241             of_platform != PLATFORM_OPAL)
3242                 prom_hold_cpus();
3243
3244         /*
3245          * Fill in some infos for use by the kernel later on
3246          */
3247         if (prom_memory_limit) {
3248                 __be64 val = cpu_to_be64(prom_memory_limit);
3249                 prom_setprop(prom.chosen, "/chosen", "linux,memory-limit",
3250                              &val, sizeof(val));
3251         }
3252 #ifdef CONFIG_PPC64
3253         if (prom_iommu_off)
3254                 prom_setprop(prom.chosen, "/chosen", "linux,iommu-off",
3255                              NULL, 0);
3256
3257         if (prom_iommu_force_on)
3258                 prom_setprop(prom.chosen, "/chosen", "linux,iommu-force-on",
3259                              NULL, 0);
3260
3261         if (prom_tce_alloc_start) {
3262                 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-start",
3263                              &prom_tce_alloc_start,
3264                              sizeof(prom_tce_alloc_start));
3265                 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-end",
3266                              &prom_tce_alloc_end,
3267                              sizeof(prom_tce_alloc_end));
3268         }
3269 #endif
3270
3271         /*
3272          * Fixup any known bugs in the device-tree
3273          */
3274         fixup_device_tree();
3275
3276         /*
3277          * Now finally create the flattened device-tree
3278          */
3279         prom_printf("copying OF device tree...\n");
3280         flatten_device_tree();
3281
3282         /*
3283          * in case stdin is USB and still active on IBM machines...
3284          * Unfortunately quiesce crashes on some powermacs if we have
3285          * closed stdin already (in particular the powerbook 101). It
3286          * appears that the OPAL version of OFW doesn't like it either.
3287          */
3288         if (of_platform != PLATFORM_POWERMAC &&
3289             of_platform != PLATFORM_OPAL)
3290                 prom_close_stdin();
3291
3292         /*
3293          * Call OF "quiesce" method to shut down pending DMA's from
3294          * devices etc...
3295          */
3296         prom_printf("Quiescing Open Firmware ...\n");
3297         call_prom("quiesce", 0, 0);
3298
3299         /*
3300          * And finally, call the kernel passing it the flattened device
3301          * tree and NULL as r5, thus triggering the new entry point which
3302          * is common to us and kexec
3303          */
3304         hdr = dt_header_start;
3305
3306         /* Don't print anything after quiesce under OPAL, it crashes OFW */
3307         if (of_platform != PLATFORM_OPAL) {
3308                 prom_printf("Booting Linux via __start() @ 0x%lx ...\n", kbase);
3309                 prom_debug("->dt_header_start=0x%lx\n", hdr);
3310         }
3311
3312 #ifdef CONFIG_PPC32
3313         reloc_got2(-offset);
3314 #else
3315         unreloc_toc();
3316 #endif
3317
3318 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
3319         /* OPAL early debug gets the OPAL base & entry in r8 and r9 */
3320         __start(hdr, kbase, 0, 0, 0,
3321                 prom_opal_base, prom_opal_entry);
3322 #else
3323         __start(hdr, kbase, 0, 0, 0, 0, 0);
3324 #endif
3325
3326         return 0;
3327 }