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