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