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