arch/powerpc/kernel/prom_init.c

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