arch/powerpc/kernel/prom_init.c

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