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