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