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