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