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