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