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