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