arch/powerpc/kernel/prom_init.c

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