?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gro: Allow tunnel stacking in the case of FOU/GUE
[linux/fpc-iii.git] / arch / powerpc / kernel / prom_init.c
blobae97ba211d8e4a962576123ca1b07f06e4ed0067
1 /*
2 * Procedures for interfacing to Open Firmware.
3 *
4 * Paul Mackerras August 1996.
5 * Copyright (C) 1996-2005 Paul Mackerras.
6 *
7 * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
8 * {engebret|bergner}@us.ibm.com
9 *
10 * This program is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU General Public License
12 * as published by the Free Software Foundation; either version
13 * 2 of the License, or (at your option) any later version.
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 * Eventually bump that one up
51 */
52 #define DEVTREE_CHUNK_SIZE 0x100000
53
54 /*
55 * This is the size of the local memory reserve map that gets copied
56 * into the boot params passed to the kernel. That size is totally
57 * flexible as the kernel just reads the list until it encounters an
58 * entry with size 0, so it can be changed without breaking binary
59 * compatibility
60 */
61 #define MEM_RESERVE_MAP_SIZE 8
62
63 /*
64 * prom_init() is called very early on, before the kernel text
65 * and data have been mapped to KERNELBASE. At this point the code
66 * is running at whatever address it has been loaded at.
67 * On ppc32 we compile with -mrelocatable, which means that references
68 * to extern and static variables get relocated automatically.
69 * ppc64 objects are always relocatable, we just need to relocate the
70 * TOC.
71 *
72 * Because OF may have mapped I/O devices into the area starting at
73 * KERNELBASE, particularly on CHRP machines, we can't safely call
74 * OF once the kernel has been mapped to KERNELBASE. Therefore all
75 * OF calls must be done within prom_init().
76 *
77 * ADDR is used in calls to call_prom. The 4th and following
78 * arguments to call_prom should be 32-bit values.
79 * On ppc64, 64 bit values are truncated to 32 bits (and
80 * fortunately don't get interpreted as two arguments).
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
88 int of_workarounds;
89 #endif
90
91 #define OF_WA_CLAIM 1 /* do phys/virt claim separately, then map */
92 #define OF_WA_LONGTRAIL 2 /* work around longtrail bugs */
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
107 typedef u32 prom_arg_t;
108
109 struct prom_args {
110 __be32 service;
111 __be32 nargs;
112 __be32 nret;
113 __be32 args[10];
114 };
115
116 struct prom_t {
117 ihandle root;
118 phandle chosen;
119 int cpu;
120 ihandle stdout;
121 ihandle mmumap;
122 ihandle memory;
123 };
124
125 struct mem_map_entry {
126 __be64 base;
127 __be64 size;
128 };
129
130 typedef __be32 cell_t;
131
132 extern 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
137 extern int enter_prom(struct prom_args *args, unsigned long entry);
138 #else
139 static inline int enter_prom(struct prom_args *args, unsigned long entry)
140 {
141 return ((int (*)(struct prom_args *))entry)(args);
142 }
143 #endif
144
145 extern void copy_and_flush(unsigned long dest, unsigned long src,
146 unsigned long size, unsigned long offset);
147
148 /* prom structure */
149 static struct prom_t __initdata prom;
150
151 static unsigned long prom_entry __initdata;
152
153 #define PROM_SCRATCH_SIZE 256
154
155 static char __initdata of_stdout_device[256];
156 static char __initdata prom_scratch[PROM_SCRATCH_SIZE];
157
158 static unsigned long __initdata dt_header_start;
159 static unsigned long __initdata dt_struct_start, dt_struct_end;
160 static unsigned long __initdata dt_string_start, dt_string_end;
161
162 static unsigned long __initdata prom_initrd_start, prom_initrd_end;
163
164 #ifdef CONFIG_PPC64
165 static int __initdata prom_iommu_force_on;
166 static int __initdata prom_iommu_off;
167 static unsigned long __initdata prom_tce_alloc_start;
168 static unsigned long __initdata prom_tce_alloc_end;
169 #endif
170
171 /* Platforms codes are now obsolete in the kernel. Now only used within this
172 * file and ultimately gone too. Feel free to change them if you need, they
173 * are not shared with anything outside of this file anymore
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
182 static int __initdata of_platform;
183
184 static char __initdata prom_cmd_line[COMMAND_LINE_SIZE];
185
186 static unsigned long __initdata prom_memory_limit;
187
188 static unsigned long __initdata alloc_top;
189 static unsigned long __initdata alloc_top_high;
190 static unsigned long __initdata alloc_bottom;
191 static unsigned long __initdata rmo_top;
192 static unsigned long __initdata ram_top;
193
194 static struct mem_map_entry __initdata mem_reserve_map[MEM_RESERVE_MAP_SIZE];
195 static int __initdata mem_reserve_cnt;
196
197 static cell_t __initdata regbuf[1024];
198
199 static bool rtas_has_query_cpu_stopped;
200
201
202 /*
203 * Error results ... some OF calls will return "-1" on error, some
204 * will return 0, some will return either. To simplify, here are
205 * macros to use with any ihandle or phandle return value to check if
206 * it is valid
207 */
208
209 #define PROM_ERROR (-1u)
210 #define PHANDLE_VALID(p) ((p) != 0 && (p) != PROM_ERROR)
211 #define IHANDLE_VALID(i) ((i) != 0 && (i) != PROM_ERROR)
212
213
214 /* This is the one and *ONLY* place where we actually call open
215 * firmware.
216 */
217
218 static int __init call_prom(const char *service, int nargs, int nret, ...)
219 {
220 int i;
221 struct prom_args args;
222 va_list list;
223
224 args.service = cpu_to_be32(ADDR(service));
225 args.nargs = cpu_to_be32(nargs);
226 args.nret = cpu_to_be32(nret);
227
228 va_start(list, nret);
229 for (i = 0; i < nargs; i++)
230 args.args[i] = cpu_to_be32(va_arg(list, prom_arg_t));
231 va_end(list);
232
233 for (i = 0; i < nret; i++)
234 args.args[nargs+i] = 0;
235
236 if (enter_prom(&args, prom_entry) < 0)
237 return PROM_ERROR;
238
239 return (nret > 0) ? be32_to_cpu(args.args[nargs]) : 0;
240 }
241
242 static int __init call_prom_ret(const char *service, int nargs, int nret,
243 prom_arg_t *rets, ...)
244 {
245 int i;
246 struct prom_args args;
247 va_list list;
248
249 args.service = cpu_to_be32(ADDR(service));
250 args.nargs = cpu_to_be32(nargs);
251 args.nret = cpu_to_be32(nret);
252
253 va_start(list, rets);
254 for (i = 0; i < nargs; i++)
255 args.args[i] = cpu_to_be32(va_arg(list, prom_arg_t));
256 va_end(list);
257
258 for (i = 0; i < nret; i++)
259 args.args[nargs+i] = 0;
260
261 if (enter_prom(&args, prom_entry) < 0)
262 return PROM_ERROR;
263
264 if (rets != NULL)
265 for (i = 1; i < nret; ++i)
266 rets[i-1] = be32_to_cpu(args.args[nargs+i]);
267
268 return (nret > 0) ? be32_to_cpu(args.args[nargs]) : 0;
269 }
270
271
272 static void __init prom_print(const char *msg)
273 {
274 const char *p, *q;
275
276 if (prom.stdout == 0)
277 return;
278
279 for (p = msg; *p != 0; p = q) {
280 for (q = p; *q != 0 && *q != '\n'; ++q)
281 ;
282 if (q > p)
283 call_prom("write", 3, 1, prom.stdout, p, q - p);
284 if (*q == 0)
285 break;
286 ++q;
287 call_prom("write", 3, 1, prom.stdout, ADDR("\r\n"), 2);
288 }
289 }
290
291
292 static void __init prom_print_hex(unsigned long val)
293 {
294 int i, nibbles = sizeof(val)*2;
295 char buf[sizeof(val)*2+1];
296
297 for (i = nibbles-1; i >= 0; i--) {
298 buf[i] = (val & 0xf) + '0';
299 if (buf[i] > '9')
300 buf[i] += ('a'-'0'-10);
301 val >>= 4;
302 }
303 buf[nibbles] = '\0';
304 call_prom("write", 3, 1, prom.stdout, buf, nibbles);
305 }
306
307 /* max number of decimal digits in an unsigned long */
308 #define UL_DIGITS 21
309 static void __init prom_print_dec(unsigned long val)
310 {
311 int i, size;
312 char buf[UL_DIGITS+1];
313
314 for (i = UL_DIGITS-1; i >= 0; i--) {
315 buf[i] = (val % 10) + '0';
316 val = val/10;
317 if (val == 0)
318 break;
319 }
320 /* shift stuff down */
321 size = UL_DIGITS - i;
322 call_prom("write", 3, 1, prom.stdout, buf+i, size);
323 }
324
325 static void __init prom_printf(const char *format, ...)
326 {
327 const char *p, *q, *s;
328 va_list args;
329 unsigned long v;
330 long vs;
331
332 va_start(args, format);
333 for (p = format; *p != 0; p = q) {
334 for (q = p; *q != 0 && *q != '\n' && *q != '%'; ++q)
335 ;
336 if (q > p)
337 call_prom("write", 3, 1, prom.stdout, p, q - p);
338 if (*q == 0)
339 break;
340 if (*q == '\n') {
341 ++q;
342 call_prom("write", 3, 1, prom.stdout,
343 ADDR("\r\n"), 2);
344 continue;
345 }
346 ++q;
347 if (*q == 0)
348 break;
349 switch (*q) {
350 case 's':
351 ++q;
352 s = va_arg(args, const char *);
353 prom_print(s);
354 break;
355 case 'x':
356 ++q;
357 v = va_arg(args, unsigned long);
358 prom_print_hex(v);
359 break;
360 case 'd':
361 ++q;
362 vs = va_arg(args, int);
363 if (vs < 0) {
364 prom_print("-");
365 vs = -vs;
366 }
367 prom_print_dec(vs);
368 break;
369 case 'l':
370 ++q;
371 if (*q == 0)
372 break;
373 else if (*q == 'x') {
374 ++q;
375 v = va_arg(args, unsigned long);
376 prom_print_hex(v);
377 } else if (*q == 'u') { /* '%lu' */
378 ++q;
379 v = va_arg(args, unsigned long);
380 prom_print_dec(v);
381 } else if (*q == 'd') { /* %ld */
382 ++q;
383 vs = va_arg(args, long);
384 if (vs < 0) {
385 prom_print("-");
386 vs = -vs;
387 }
388 prom_print_dec(vs);
389 }
390 break;
391 }
392 }
393 }
394
395
396 static 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 * Old OF requires we claim physical and virtual separately
403 * and then map explicitly (assuming virtual mode)
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 /* the 0x12 is M (coherence) + PP == read/write */
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
430 static void __init __attribute__((noreturn)) prom_panic(const char *reason)
431 {
432 prom_print(reason);
433 /* Do not call exit because it clears the screen on pmac
434 * it also causes some sort of double-fault on early pmacs */
435 if (of_platform == PLATFORM_POWERMAC)
436 asm("trap\n");
437
438 /* ToDo: should put up an SRC here on pSeries */
439 call_prom("exit", 0, 0);
440
441 for (;;) /* should never get here */
442 ;
443 }
444
445
446 static 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
463 static 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
470 static int inline prom_getproplen(phandle node, const char *pname)
471 {
472 return call_prom("getproplen", 2, 1, node, ADDR(pname));
473 }
474
475 static 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
485 static 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
501 static 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 /* gah... setprop doesn't work on longtrail, have to use interpret */
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 /* We can't use the standard versions because of relocation headaches. */
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
532 static 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
557 static 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 * We can't use a switch here because GCC *may* generate a
564 * jump table which won't work, because we're not running at
565 * the address we're linked at.
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 * Early parsing of the command line passed to the kernel, used for
586 * "mem=x" and the options that affect the iommu
587 */
588 static 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') /* dbl check */
601 strlcpy(prom_cmd_line,
602 CONFIG_CMDLINE, sizeof(prom_cmd_line));
603 #endif /* CONFIG_CMDLINE */
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 /* Align to 16 MB == size of ppc64 large page */
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 * The architecture vector has an array of PVR mask/value pairs,
633 * followed by # option vectors - 1, followed by the option vectors.
634 *
635 * See prom.h for the definition of the bits specified in the
636 * architecture vector.
637 *
638 * Because the description vector contains a mix of byte and word
639 * values, we declare it as an unsigned char array, and use this
640 * macro to put word values in.
641 */
642 #define W(x) ((x) >> 24) & 0xff, ((x) >> 16) & 0xff, \
643 ((x) >> 8) & 0xff, (x) & 0xff
644
645 unsigned char ibm_architecture_vec[] = {
646 W(0xfffe0000), W(0x003a0000), /* POWER5/POWER5+ */
647 W(0xffff0000), W(0x003e0000), /* POWER6 */
648 W(0xffff0000), W(0x003f0000), /* POWER7 */
649 W(0xffff0000), W(0x004b0000), /* POWER8E */
650 W(0xffff0000), W(0x004c0000), /* POWER8NVL */
651 W(0xffff0000), W(0x004d0000), /* POWER8 */
652 W(0xffffffff), W(0x0f000004), /* all 2.07-compliant */
653 W(0xffffffff), W(0x0f000003), /* all 2.06-compliant */
654 W(0xffffffff), W(0x0f000002), /* all 2.05-compliant */
655 W(0xfffffffe), W(0x0f000001), /* all 2.04-compliant and earlier */
656 6 - 1, /* 6 option vectors */
657
658 /* option vector 1: processor architectures supported */
659 3 - 2, /* length */
660 0, /* don't ignore, don't halt */
661 OV1_PPC_2_00 | OV1_PPC_2_01 | OV1_PPC_2_02 | OV1_PPC_2_03 |
662 OV1_PPC_2_04 | OV1_PPC_2_05 | OV1_PPC_2_06 | OV1_PPC_2_07,
663
664 /* option vector 2: Open Firmware options supported */
665 34 - 2, /* length */
666 OV2_REAL_MODE,
667 0, 0,
668 W(0xffffffff), /* real_base */
669 W(0xffffffff), /* real_size */
670 W(0xffffffff), /* virt_base */
671 W(0xffffffff), /* virt_size */
672 W(0xffffffff), /* load_base */
673 W(256), /* 256MB min RMA */
674 W(0xffffffff), /* full client load */
675 0, /* min RMA percentage of total RAM */
676 48, /* max log_2(hash table size) */
677
678 /* option vector 3: processor options supported */
679 3 - 2, /* length */
680 0, /* don't ignore, don't halt */
681 OV3_FP | OV3_VMX | OV3_DFP,
682
683 /* option vector 4: IBM PAPR implementation */
684 3 - 2, /* length */
685 0, /* don't halt */
686 OV4_MIN_ENT_CAP, /* minimum VP entitled capacity */
687
688 /* option vector 5: PAPR/OF options */
689 19 - 2, /* length */
690 0, /* don't ignore, don't halt */
691 OV5_FEAT(OV5_LPAR) | OV5_FEAT(OV5_SPLPAR) | OV5_FEAT(OV5_LARGE_PAGES) |
692 OV5_FEAT(OV5_DRCONF_MEMORY) | OV5_FEAT(OV5_DONATE_DEDICATE_CPU) |
693 #ifdef CONFIG_PCI_MSI
694 /* PCIe/MSI support. Without MSI full PCIe is not supported */
695 OV5_FEAT(OV5_MSI),
696 #else
697 0,
698 #endif
699 0,
700 #ifdef CONFIG_PPC_SMLPAR
701 OV5_FEAT(OV5_CMO) | OV5_FEAT(OV5_XCMO),
702 #else
703 0,
704 #endif
705 OV5_FEAT(OV5_TYPE1_AFFINITY) | OV5_FEAT(OV5_PRRN),
706 0,
707 0,
708 0,
709 /* WARNING: The offset of the "number of cores" field below
710 * must match by the macro below. Update the definition if
711 * the structure layout changes.
712 */
713 #define IBM_ARCH_VEC_NRCORES_OFFSET 133
714 W(NR_CPUS), /* number of cores supported */
715 0,
716 0,
717 0,
718 0,
719 OV5_FEAT(OV5_PFO_HW_RNG) | OV5_FEAT(OV5_PFO_HW_ENCR) |
720 OV5_FEAT(OV5_PFO_HW_842),
721 OV5_FEAT(OV5_SUB_PROCESSORS),
722 /* option vector 6: IBM PAPR hints */
723 4 - 2, /* length */
724 0,
725 0,
726 OV6_LINUX,
727
728 };
729
730 /* Old method - ELF header with PT_NOTE sections only works on BE */
731 #ifdef __BIG_ENDIAN__
732 static struct fake_elf {
733 Elf32_Ehdr elfhdr;
734 Elf32_Phdr phdr[2];
735 struct chrpnote {
736 u32 namesz;
737 u32 descsz;
738 u32 type;
739 char name[8]; /* "PowerPC" */
740 struct chrpdesc {
741 u32 real_mode;
742 u32 real_base;
743 u32 real_size;
744 u32 virt_base;
745 u32 virt_size;
746 u32 load_base;
747 } chrpdesc;
748 } chrpnote;
749 struct rpanote {
750 u32 namesz;
751 u32 descsz;
752 u32 type;
753 char name[24]; /* "IBM,RPA-Client-Config" */
754 struct rpadesc {
755 u32 lpar_affinity;
756 u32 min_rmo_size;
757 u32 min_rmo_percent;
758 u32 max_pft_size;
759 u32 splpar;
760 u32 min_load;
761 u32 new_mem_def;
762 u32 ignore_me;
763 } rpadesc;
764 } rpanote;
765 } fake_elf = {
766 .elfhdr = {
767 .e_ident = { 0x7f, 'E', 'L', 'F',
768 ELFCLASS32, ELFDATA2MSB, EV_CURRENT },
769 .e_type = ET_EXEC, /* yeah right */
770 .e_machine = EM_PPC,
771 .e_version = EV_CURRENT,
772 .e_phoff = offsetof(struct fake_elf, phdr),
773 .e_phentsize = sizeof(Elf32_Phdr),
774 .e_phnum = 2
775 },
776 .phdr = {
777 [0] = {
778 .p_type = PT_NOTE,
779 .p_offset = offsetof(struct fake_elf, chrpnote),
780 .p_filesz = sizeof(struct chrpnote)
781 }, [1] = {
782 .p_type = PT_NOTE,
783 .p_offset = offsetof(struct fake_elf, rpanote),
784 .p_filesz = sizeof(struct rpanote)
785 }
786 },
787 .chrpnote = {
788 .namesz = sizeof("PowerPC"),
789 .descsz = sizeof(struct chrpdesc),
790 .type = 0x1275,
791 .name = "PowerPC",
792 .chrpdesc = {
793 .real_mode = ~0U, /* ~0 means "don't care" */
794 .real_base = ~0U,
795 .real_size = ~0U,
796 .virt_base = ~0U,
797 .virt_size = ~0U,
798 .load_base = ~0U
799 },
800 },
801 .rpanote = {
802 .namesz = sizeof("IBM,RPA-Client-Config"),
803 .descsz = sizeof(struct rpadesc),
804 .type = 0x12759999,
805 .name = "IBM,RPA-Client-Config",
806 .rpadesc = {
807 .lpar_affinity = 0,
808 .min_rmo_size = 64, /* in megabytes */
809 .min_rmo_percent = 0,
810 .max_pft_size = 48, /* 2^48 bytes max PFT size */
811 .splpar = 1,
812 .min_load = ~0U,
813 .new_mem_def = 0
814 }
815 }
816 };
817 #endif /* __BIG_ENDIAN__ */
818
819 static int __init prom_count_smt_threads(void)
820 {
821 phandle node;
822 char type[64];
823 unsigned int plen;
824
825 /* Pick up th first CPU node we can find */
826 for (node = 0; prom_next_node(&node); ) {
827 type[0] = 0;
828 prom_getprop(node, "device_type", type, sizeof(type));
829
830 if (strcmp(type, "cpu"))
831 continue;
832 /*
833 * There is an entry for each smt thread, each entry being
834 * 4 bytes long. All cpus should have the same number of
835 * smt threads, so return after finding the first.
836 */
837 plen = prom_getproplen(node, "ibm,ppc-interrupt-server#s");
838 if (plen == PROM_ERROR)
839 break;
840 plen >>= 2;
841 prom_debug("Found %lu smt threads per core\n", (unsigned long)plen);
842
843 /* Sanity check */
844 if (plen < 1 || plen > 64) {
845 prom_printf("Threads per core %lu out of bounds, assuming 1\n",
846 (unsigned long)plen);
847 return 1;
848 }
849 return plen;
850 }
851 prom_debug("No threads found, assuming 1 per core\n");
852
853 return 1;
854
855 }
856
857
858 static void __init prom_send_capabilities(void)
859 {
860 ihandle root;
861 prom_arg_t ret;
862 u32 cores;
863 unsigned char *ptcores;
864
865 root = call_prom("open", 1, 1, ADDR("/"));
866 if (root != 0) {
867 /* We need to tell the FW about the number of cores we support.
868 *
869 * To do that, we count the number of threads on the first core
870 * (we assume this is the same for all cores) and use it to
871 * divide NR_CPUS.
872 */
873
874 /* The core value may start at an odd address. If such a word
875 * access is made at a cache line boundary, this leads to an
876 * exception which may not be handled at this time.
877 * Forcing a per byte access to avoid exception.
878 */
879 ptcores = &ibm_architecture_vec[IBM_ARCH_VEC_NRCORES_OFFSET];
880 cores = 0;
881 cores |= ptcores[0] << 24;
882 cores |= ptcores[1] << 16;
883 cores |= ptcores[2] << 8;
884 cores |= ptcores[3];
885 if (cores != NR_CPUS) {
886 prom_printf("WARNING ! "
887 "ibm_architecture_vec structure inconsistent: %lu!\n",
888 cores);
889 } else {
890 cores = DIV_ROUND_UP(NR_CPUS, prom_count_smt_threads());
891 prom_printf("Max number of cores passed to firmware: %lu (NR_CPUS = %lu)\n",
892 cores, NR_CPUS);
893 ptcores[0] = (cores >> 24) & 0xff;
894 ptcores[1] = (cores >> 16) & 0xff;
895 ptcores[2] = (cores >> 8) & 0xff;
896 ptcores[3] = cores & 0xff;
897 }
898
899 /* try calling the ibm,client-architecture-support method */
900 prom_printf("Calling ibm,client-architecture-support...");
901 if (call_prom_ret("call-method", 3, 2, &ret,
902 ADDR("ibm,client-architecture-support"),
903 root,
904 ADDR(ibm_architecture_vec)) == 0) {
905 /* the call exists... */
906 if (ret)
907 prom_printf("\nWARNING: ibm,client-architecture"
908 "-support call FAILED!\n");
909 call_prom("close", 1, 0, root);
910 prom_printf(" done\n");
911 return;
912 }
913 call_prom("close", 1, 0, root);
914 prom_printf(" not implemented\n");
915 }
916
917 #ifdef __BIG_ENDIAN__
918 {
919 ihandle elfloader;
920
921 /* no ibm,client-architecture-support call, try the old way */
922 elfloader = call_prom("open", 1, 1,
923 ADDR("/packages/elf-loader"));
924 if (elfloader == 0) {
925 prom_printf("couldn't open /packages/elf-loader\n");
926 return;
927 }
928 call_prom("call-method", 3, 1, ADDR("process-elf-header"),
929 elfloader, ADDR(&fake_elf));
930 call_prom("close", 1, 0, elfloader);
931 }
932 #endif /* __BIG_ENDIAN__ */
933 }
934 #endif /* #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV) */
935
936 /*
937 * Memory allocation strategy... our layout is normally:
938 *
939 * at 14Mb or more we have vmlinux, then a gap and initrd. In some
940 * rare cases, initrd might end up being before the kernel though.
941 * We assume this won't override the final kernel at 0, we have no
942 * provision to handle that in this version, but it should hopefully
943 * never happen.
944 *
945 * alloc_top is set to the top of RMO, eventually shrink down if the
946 * TCEs overlap
947 *
948 * alloc_bottom is set to the top of kernel/initrd
949 *
950 * from there, allocations are done this way : rtas is allocated
951 * topmost, and the device-tree is allocated from the bottom. We try
952 * to grow the device-tree allocation as we progress. If we can't,
953 * then we fail, we don't currently have a facility to restart
954 * elsewhere, but that shouldn't be necessary.
955 *
956 * Note that calls to reserve_mem have to be done explicitly, memory
957 * allocated with either alloc_up or alloc_down isn't automatically
958 * reserved.
959 */
960
961
962 /*
963 * Allocates memory in the RMO upward from the kernel/initrd
964 *
965 * When align is 0, this is a special case, it means to allocate in place
966 * at the current location of alloc_bottom or fail (that is basically
967 * extending the previous allocation). Used for the device-tree flattening
968 */
969 static unsigned long __init alloc_up(unsigned long size, unsigned long align)
970 {
971 unsigned long base = alloc_bottom;
972 unsigned long addr = 0;
973
974 if (align)
975 base = _ALIGN_UP(base, align);
976 prom_debug("alloc_up(%x, %x)\n", size, align);
977 if (ram_top == 0)
978 prom_panic("alloc_up() called with mem not initialized\n");
979
980 if (align)
981 base = _ALIGN_UP(alloc_bottom, align);
982 else
983 base = alloc_bottom;
984
985 for(; (base + size) <= alloc_top;
986 base = _ALIGN_UP(base + 0x100000, align)) {
987 prom_debug(" trying: 0x%x\n\r", base);
988 addr = (unsigned long)prom_claim(base, size, 0);
989 if (addr != PROM_ERROR && addr != 0)
990 break;
991 addr = 0;
992 if (align == 0)
993 break;
994 }
995 if (addr == 0)
996 return 0;
997 alloc_bottom = addr + size;
998
999 prom_debug(" -> %x\n", addr);
1000 prom_debug(" alloc_bottom : %x\n", alloc_bottom);
1001 prom_debug(" alloc_top : %x\n", alloc_top);
1002 prom_debug(" alloc_top_hi : %x\n", alloc_top_high);
1003 prom_debug(" rmo_top : %x\n", rmo_top);
1004 prom_debug(" ram_top : %x\n", ram_top);
1005
1006 return addr;
1007 }
1008
1009 /*
1010 * Allocates memory downward, either from top of RMO, or if highmem
1011 * is set, from the top of RAM. Note that this one doesn't handle
1012 * failures. It does claim memory if highmem is not set.
1013 */
1014 static unsigned long __init alloc_down(unsigned long size, unsigned long align,
1015 int highmem)
1016 {
1017 unsigned long base, addr = 0;
1018
1019 prom_debug("alloc_down(%x, %x, %s)\n", size, align,
1020 highmem ? "(high)" : "(low)");
1021 if (ram_top == 0)
1022 prom_panic("alloc_down() called with mem not initialized\n");
1023
1024 if (highmem) {
1025 /* Carve out storage for the TCE table. */
1026 addr = _ALIGN_DOWN(alloc_top_high - size, align);
1027 if (addr <= alloc_bottom)
1028 return 0;
1029 /* Will we bump into the RMO ? If yes, check out that we
1030 * didn't overlap existing allocations there, if we did,
1031 * we are dead, we must be the first in town !
1032 */
1033 if (addr < rmo_top) {
1034 /* Good, we are first */
1035 if (alloc_top == rmo_top)
1036 alloc_top = rmo_top = addr;
1037 else
1038 return 0;
1039 }
1040 alloc_top_high = addr;
1041 goto bail;
1042 }
1043
1044 base = _ALIGN_DOWN(alloc_top - size, align);
1045 for (; base > alloc_bottom;
1046 base = _ALIGN_DOWN(base - 0x100000, align)) {
1047 prom_debug(" trying: 0x%x\n\r", base);
1048 addr = (unsigned long)prom_claim(base, size, 0);
1049 if (addr != PROM_ERROR && addr != 0)
1050 break;
1051 addr = 0;
1052 }
1053 if (addr == 0)
1054 return 0;
1055 alloc_top = addr;
1056
1057 bail:
1058 prom_debug(" -> %x\n", addr);
1059 prom_debug(" alloc_bottom : %x\n", alloc_bottom);
1060 prom_debug(" alloc_top : %x\n", alloc_top);
1061 prom_debug(" alloc_top_hi : %x\n", alloc_top_high);
1062 prom_debug(" rmo_top : %x\n", rmo_top);
1063 prom_debug(" ram_top : %x\n", ram_top);
1064
1065 return addr;
1066 }
1067
1068 /*
1069 * Parse a "reg" cell
1070 */
1071 static unsigned long __init prom_next_cell(int s, cell_t **cellp)
1072 {
1073 cell_t *p = *cellp;
1074 unsigned long r = 0;
1075
1076 /* Ignore more than 2 cells */
1077 while (s > sizeof(unsigned long) / 4) {
1078 p++;
1079 s--;
1080 }
1081 r = be32_to_cpu(*p++);
1082 #ifdef CONFIG_PPC64
1083 if (s > 1) {
1084 r <<= 32;
1085 r |= be32_to_cpu(*(p++));
1086 }
1087 #endif
1088 *cellp = p;
1089 return r;
1090 }
1091
1092 /*
1093 * Very dumb function for adding to the memory reserve list, but
1094 * we don't need anything smarter at this point
1095 *
1096 * XXX Eventually check for collisions. They should NEVER happen.
1097 * If problems seem to show up, it would be a good start to track
1098 * them down.
1099 */
1100 static void __init reserve_mem(u64 base, u64 size)
1101 {
1102 u64 top = base + size;
1103 unsigned long cnt = mem_reserve_cnt;
1104
1105 if (size == 0)
1106 return;
1107
1108 /* We need to always keep one empty entry so that we
1109 * have our terminator with "size" set to 0 since we are
1110 * dumb and just copy this entire array to the boot params
1111 */
1112 base = _ALIGN_DOWN(base, PAGE_SIZE);
1113 top = _ALIGN_UP(top, PAGE_SIZE);
1114 size = top - base;
1115
1116 if (cnt >= (MEM_RESERVE_MAP_SIZE - 1))
1117 prom_panic("Memory reserve map exhausted !\n");
1118 mem_reserve_map[cnt].base = cpu_to_be64(base);
1119 mem_reserve_map[cnt].size = cpu_to_be64(size);
1120 mem_reserve_cnt = cnt + 1;
1121 }
1122
1123 /*
1124 * Initialize memory allocation mechanism, parse "memory" nodes and
1125 * obtain that way the top of memory and RMO to setup out local allocator
1126 */
1127 static void __init prom_init_mem(void)
1128 {
1129 phandle node;
1130 char *path, type[64];
1131 unsigned int plen;
1132 cell_t *p, *endp;
1133 __be32 val;
1134 u32 rac, rsc;
1135
1136 /*
1137 * We iterate the memory nodes to find
1138 * 1) top of RMO (first node)
1139 * 2) top of memory
1140 */
1141 val = cpu_to_be32(2);
1142 prom_getprop(prom.root, "#address-cells", &val, sizeof(val));
1143 rac = be32_to_cpu(val);
1144 val = cpu_to_be32(1);
1145 prom_getprop(prom.root, "#size-cells", &val, sizeof(rsc));
1146 rsc = be32_to_cpu(val);
1147 prom_debug("root_addr_cells: %x\n", rac);
1148 prom_debug("root_size_cells: %x\n", rsc);
1149
1150 prom_debug("scanning memory:\n");
1151 path = prom_scratch;
1152
1153 for (node = 0; prom_next_node(&node); ) {
1154 type[0] = 0;
1155 prom_getprop(node, "device_type", type, sizeof(type));
1156
1157 if (type[0] == 0) {
1158 /*
1159 * CHRP Longtrail machines have no device_type
1160 * on the memory node, so check the name instead...
1161 */
1162 prom_getprop(node, "name", type, sizeof(type));
1163 }
1164 if (strcmp(type, "memory"))
1165 continue;
1166
1167 plen = prom_getprop(node, "reg", regbuf, sizeof(regbuf));
1168 if (plen > sizeof(regbuf)) {
1169 prom_printf("memory node too large for buffer !\n");
1170 plen = sizeof(regbuf);
1171 }
1172 p = regbuf;
1173 endp = p + (plen / sizeof(cell_t));
1174
1175 #ifdef DEBUG_PROM
1176 memset(path, 0, PROM_SCRATCH_SIZE);
1177 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
1178 prom_debug(" node %s :\n", path);
1179 #endif /* DEBUG_PROM */
1180
1181 while ((endp - p) >= (rac + rsc)) {
1182 unsigned long base, size;
1183
1184 base = prom_next_cell(rac, &p);
1185 size = prom_next_cell(rsc, &p);
1186
1187 if (size == 0)
1188 continue;
1189 prom_debug(" %x %x\n", base, size);
1190 if (base == 0 && (of_platform & PLATFORM_LPAR))
1191 rmo_top = size;
1192 if ((base + size) > ram_top)
1193 ram_top = base + size;
1194 }
1195 }
1196
1197 alloc_bottom = PAGE_ALIGN((unsigned long)&_end + 0x4000);
1198
1199 /*
1200 * If prom_memory_limit is set we reduce the upper limits *except* for
1201 * alloc_top_high. This must be the real top of RAM so we can put
1202 * TCE's up there.
1203 */
1204
1205 alloc_top_high = ram_top;
1206
1207 if (prom_memory_limit) {
1208 if (prom_memory_limit <= alloc_bottom) {
1209 prom_printf("Ignoring mem=%x <= alloc_bottom.\n",
1210 prom_memory_limit);
1211 prom_memory_limit = 0;
1212 } else if (prom_memory_limit >= ram_top) {
1213 prom_printf("Ignoring mem=%x >= ram_top.\n",
1214 prom_memory_limit);
1215 prom_memory_limit = 0;
1216 } else {
1217 ram_top = prom_memory_limit;
1218 rmo_top = min(rmo_top, prom_memory_limit);
1219 }
1220 }
1221
1222 /*
1223 * Setup our top alloc point, that is top of RMO or top of
1224 * segment 0 when running non-LPAR.
1225 * Some RS64 machines have buggy firmware where claims up at
1226 * 1GB fail. Cap at 768MB as a workaround.
1227 * Since 768MB is plenty of room, and we need to cap to something
1228 * reasonable on 32-bit, cap at 768MB on all machines.
1229 */
1230 if (!rmo_top)
1231 rmo_top = ram_top;
1232 rmo_top = min(0x30000000ul, rmo_top);
1233 alloc_top = rmo_top;
1234 alloc_top_high = ram_top;
1235
1236 /*
1237 * Check if we have an initrd after the kernel but still inside
1238 * the RMO. If we do move our bottom point to after it.
1239 */
1240 if (prom_initrd_start &&
1241 prom_initrd_start < rmo_top &&
1242 prom_initrd_end > alloc_bottom)
1243 alloc_bottom = PAGE_ALIGN(prom_initrd_end);
1244
1245 prom_printf("memory layout at init:\n");
1246 prom_printf(" memory_limit : %x (16 MB aligned)\n", prom_memory_limit);
1247 prom_printf(" alloc_bottom : %x\n", alloc_bottom);
1248 prom_printf(" alloc_top : %x\n", alloc_top);
1249 prom_printf(" alloc_top_hi : %x\n", alloc_top_high);
1250 prom_printf(" rmo_top : %x\n", rmo_top);
1251 prom_printf(" ram_top : %x\n", ram_top);
1252 }
1253
1254 static void __init prom_close_stdin(void)
1255 {
1256 __be32 val;
1257 ihandle stdin;
1258
1259 if (prom_getprop(prom.chosen, "stdin", &val, sizeof(val)) > 0) {
1260 stdin = be32_to_cpu(val);
1261 call_prom("close", 1, 0, stdin);
1262 }
1263 }
1264
1265 #ifdef CONFIG_PPC_POWERNV
1266
1267 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
1268 static u64 __initdata prom_opal_base;
1269 static u64 __initdata prom_opal_entry;
1270 #endif
1271
1272 /*
1273 * Allocate room for and instantiate OPAL
1274 */
1275 static void __init prom_instantiate_opal(void)
1276 {
1277 phandle opal_node;
1278 ihandle opal_inst;
1279 u64 base, entry;
1280 u64 size = 0, align = 0x10000;
1281 __be64 val64;
1282 u32 rets[2];
1283
1284 prom_debug("prom_instantiate_opal: start...\n");
1285
1286 opal_node = call_prom("finddevice", 1, 1, ADDR("/ibm,opal"));
1287 prom_debug("opal_node: %x\n", opal_node);
1288 if (!PHANDLE_VALID(opal_node))
1289 return;
1290
1291 val64 = 0;
1292 prom_getprop(opal_node, "opal-runtime-size", &val64, sizeof(val64));
1293 size = be64_to_cpu(val64);
1294 if (size == 0)
1295 return;
1296 val64 = 0;
1297 prom_getprop(opal_node, "opal-runtime-alignment", &val64,sizeof(val64));
1298 align = be64_to_cpu(val64);
1299
1300 base = alloc_down(size, align, 0);
1301 if (base == 0) {
1302 prom_printf("OPAL allocation failed !\n");
1303 return;
1304 }
1305
1306 opal_inst = call_prom("open", 1, 1, ADDR("/ibm,opal"));
1307 if (!IHANDLE_VALID(opal_inst)) {
1308 prom_printf("opening opal package failed (%x)\n", opal_inst);
1309 return;
1310 }
1311
1312 prom_printf("instantiating opal at 0x%x...", base);
1313
1314 if (call_prom_ret("call-method", 4, 3, rets,
1315 ADDR("load-opal-runtime"),
1316 opal_inst,
1317 base >> 32, base & 0xffffffff) != 0
1318 || (rets[0] == 0 && rets[1] == 0)) {
1319 prom_printf(" failed\n");
1320 return;
1321 }
1322 entry = (((u64)rets[0]) << 32) | rets[1];
1323
1324 prom_printf(" done\n");
1325
1326 reserve_mem(base, size);
1327
1328 prom_debug("opal base = 0x%x\n", base);
1329 prom_debug("opal align = 0x%x\n", align);
1330 prom_debug("opal entry = 0x%x\n", entry);
1331 prom_debug("opal size = 0x%x\n", (long)size);
1332
1333 prom_setprop(opal_node, "/ibm,opal", "opal-base-address",
1334 &base, sizeof(base));
1335 prom_setprop(opal_node, "/ibm,opal", "opal-entry-address",
1336 &entry, sizeof(entry));
1337
1338 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
1339 prom_opal_base = base;
1340 prom_opal_entry = entry;
1341 #endif
1342 prom_debug("prom_instantiate_opal: end...\n");
1343 }
1344
1345 #endif /* CONFIG_PPC_POWERNV */
1346
1347 /*
1348 * Allocate room for and instantiate RTAS
1349 */
1350 static void __init prom_instantiate_rtas(void)
1351 {
1352 phandle rtas_node;
1353 ihandle rtas_inst;
1354 u32 base, entry = 0;
1355 __be32 val;
1356 u32 size = 0;
1357
1358 prom_debug("prom_instantiate_rtas: start...\n");
1359
1360 rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1361 prom_debug("rtas_node: %x\n", rtas_node);
1362 if (!PHANDLE_VALID(rtas_node))
1363 return;
1364
1365 val = 0;
1366 prom_getprop(rtas_node, "rtas-size", &val, sizeof(size));
1367 size = be32_to_cpu(val);
1368 if (size == 0)
1369 return;
1370
1371 base = alloc_down(size, PAGE_SIZE, 0);
1372 if (base == 0)
1373 prom_panic("Could not allocate memory for RTAS\n");
1374
1375 rtas_inst = call_prom("open", 1, 1, ADDR("/rtas"));
1376 if (!IHANDLE_VALID(rtas_inst)) {
1377 prom_printf("opening rtas package failed (%x)\n", rtas_inst);
1378 return;
1379 }
1380
1381 prom_printf("instantiating rtas at 0x%x...", base);
1382
1383 if (call_prom_ret("call-method", 3, 2, &entry,
1384 ADDR("instantiate-rtas"),
1385 rtas_inst, base) != 0
1386 || entry == 0) {
1387 prom_printf(" failed\n");
1388 return;
1389 }
1390 prom_printf(" done\n");
1391
1392 reserve_mem(base, size);
1393
1394 val = cpu_to_be32(base);
1395 prom_setprop(rtas_node, "/rtas", "linux,rtas-base",
1396 &val, sizeof(val));
1397 val = cpu_to_be32(entry);
1398 prom_setprop(rtas_node, "/rtas", "linux,rtas-entry",
1399 &val, sizeof(val));
1400
1401 /* Check if it supports "query-cpu-stopped-state" */
1402 if (prom_getprop(rtas_node, "query-cpu-stopped-state",
1403 &val, sizeof(val)) != PROM_ERROR)
1404 rtas_has_query_cpu_stopped = true;
1405
1406 prom_debug("rtas base = 0x%x\n", base);
1407 prom_debug("rtas entry = 0x%x\n", entry);
1408 prom_debug("rtas size = 0x%x\n", (long)size);
1409
1410 prom_debug("prom_instantiate_rtas: end...\n");
1411 }
1412
1413 #ifdef CONFIG_PPC64
1414 /*
1415 * Allocate room for and instantiate Stored Measurement Log (SML)
1416 */
1417 static void __init prom_instantiate_sml(void)
1418 {
1419 phandle ibmvtpm_node;
1420 ihandle ibmvtpm_inst;
1421 u32 entry = 0, size = 0;
1422 u64 base;
1423
1424 prom_debug("prom_instantiate_sml: start...\n");
1425
1426 ibmvtpm_node = call_prom("finddevice", 1, 1, ADDR("/ibm,vtpm"));
1427 prom_debug("ibmvtpm_node: %x\n", ibmvtpm_node);
1428 if (!PHANDLE_VALID(ibmvtpm_node))
1429 return;
1430
1431 ibmvtpm_inst = call_prom("open", 1, 1, ADDR("/ibm,vtpm"));
1432 if (!IHANDLE_VALID(ibmvtpm_inst)) {
1433 prom_printf("opening vtpm package failed (%x)\n", ibmvtpm_inst);
1434 return;
1435 }
1436
1437 if (call_prom_ret("call-method", 2, 2, &size,
1438 ADDR("sml-get-handover-size"),
1439 ibmvtpm_inst) != 0 || size == 0) {
1440 prom_printf("SML get handover size failed\n");
1441 return;
1442 }
1443
1444 base = alloc_down(size, PAGE_SIZE, 0);
1445 if (base == 0)
1446 prom_panic("Could not allocate memory for sml\n");
1447
1448 prom_printf("instantiating sml at 0x%x...", base);
1449
1450 if (call_prom_ret("call-method", 4, 2, &entry,
1451 ADDR("sml-handover"),
1452 ibmvtpm_inst, size, base) != 0 || entry == 0) {
1453 prom_printf("SML handover failed\n");
1454 return;
1455 }
1456 prom_printf(" done\n");
1457
1458 reserve_mem(base, size);
1459
1460 prom_setprop(ibmvtpm_node, "/ibm,vtpm", "linux,sml-base",
1461 &base, sizeof(base));
1462 prom_setprop(ibmvtpm_node, "/ibm,vtpm", "linux,sml-size",
1463 &size, sizeof(size));
1464
1465 prom_debug("sml base = 0x%x\n", base);
1466 prom_debug("sml size = 0x%x\n", (long)size);
1467
1468 prom_debug("prom_instantiate_sml: end...\n");
1469 }
1470
1471 /*
1472 * Allocate room for and initialize TCE tables
1473 */
1474 #ifdef __BIG_ENDIAN__
1475 static void __init prom_initialize_tce_table(void)
1476 {
1477 phandle node;
1478 ihandle phb_node;
1479 char compatible[64], type[64], model[64];
1480 char *path = prom_scratch;
1481 u64 base, align;
1482 u32 minalign, minsize;
1483 u64 tce_entry, *tce_entryp;
1484 u64 local_alloc_top, local_alloc_bottom;
1485 u64 i;
1486
1487 if (prom_iommu_off)
1488 return;
1489
1490 prom_debug("starting prom_initialize_tce_table\n");
1491
1492 /* Cache current top of allocs so we reserve a single block */
1493 local_alloc_top = alloc_top_high;
1494 local_alloc_bottom = local_alloc_top;
1495
1496 /* Search all nodes looking for PHBs. */
1497 for (node = 0; prom_next_node(&node); ) {
1498 compatible[0] = 0;
1499 type[0] = 0;
1500 model[0] = 0;
1501 prom_getprop(node, "compatible",
1502 compatible, sizeof(compatible));
1503 prom_getprop(node, "device_type", type, sizeof(type));
1504 prom_getprop(node, "model", model, sizeof(model));
1505
1506 if ((type[0] == 0) || (strstr(type, "pci") == NULL))
1507 continue;
1508
1509 /* Keep the old logic intact to avoid regression. */
1510 if (compatible[0] != 0) {
1511 if ((strstr(compatible, "python") == NULL) &&
1512 (strstr(compatible, "Speedwagon") == NULL) &&
1513 (strstr(compatible, "Winnipeg") == NULL))
1514 continue;
1515 } else if (model[0] != 0) {
1516 if ((strstr(model, "ython") == NULL) &&
1517 (strstr(model, "peedwagon") == NULL) &&
1518 (strstr(model, "innipeg") == NULL))
1519 continue;
1520 }
1521
1522 if (prom_getprop(node, "tce-table-minalign", &minalign,
1523 sizeof(minalign)) == PROM_ERROR)
1524 minalign = 0;
1525 if (prom_getprop(node, "tce-table-minsize", &minsize,
1526 sizeof(minsize)) == PROM_ERROR)
1527 minsize = 4UL << 20;
1528
1529 /*
1530 * Even though we read what OF wants, we just set the table
1531 * size to 4 MB. This is enough to map 2GB of PCI DMA space.
1532 * By doing this, we avoid the pitfalls of trying to DMA to
1533 * MMIO space and the DMA alias hole.
1534 *
1535 * On POWER4, firmware sets the TCE region by assuming
1536 * each TCE table is 8MB. Using this memory for anything
1537 * else will impact performance, so we always allocate 8MB.
1538 * Anton
1539 */
1540 if (pvr_version_is(PVR_POWER4) || pvr_version_is(PVR_POWER4p))
1541 minsize = 8UL << 20;
1542 else
1543 minsize = 4UL << 20;
1544
1545 /* Align to the greater of the align or size */
1546 align = max(minalign, minsize);
1547 base = alloc_down(minsize, align, 1);
1548 if (base == 0)
1549 prom_panic("ERROR, cannot find space for TCE table.\n");
1550 if (base < local_alloc_bottom)
1551 local_alloc_bottom = base;
1552
1553 /* It seems OF doesn't null-terminate the path :-( */
1554 memset(path, 0, PROM_SCRATCH_SIZE);
1555 /* Call OF to setup the TCE hardware */
1556 if (call_prom("package-to-path", 3, 1, node,
1557 path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) {
1558 prom_printf("package-to-path failed\n");
1559 }
1560
1561 /* Save away the TCE table attributes for later use. */
1562 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base));
1563 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize));
1564
1565 prom_debug("TCE table: %s\n", path);
1566 prom_debug("\tnode = 0x%x\n", node);
1567 prom_debug("\tbase = 0x%x\n", base);
1568 prom_debug("\tsize = 0x%x\n", minsize);
1569
1570 /* Initialize the table to have a one-to-one mapping
1571 * over the allocated size.
1572 */
1573 tce_entryp = (u64 *)base;
1574 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) {
1575 tce_entry = (i << PAGE_SHIFT);
1576 tce_entry |= 0x3;
1577 *tce_entryp = tce_entry;
1578 }
1579
1580 prom_printf("opening PHB %s", path);
1581 phb_node = call_prom("open", 1, 1, path);
1582 if (phb_node == 0)
1583 prom_printf("... failed\n");
1584 else
1585 prom_printf("... done\n");
1586
1587 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"),
1588 phb_node, -1, minsize,
1589 (u32) base, (u32) (base >> 32));
1590 call_prom("close", 1, 0, phb_node);
1591 }
1592
1593 reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom);
1594
1595 /* These are only really needed if there is a memory limit in
1596 * effect, but we don't know so export them always. */
1597 prom_tce_alloc_start = local_alloc_bottom;
1598 prom_tce_alloc_end = local_alloc_top;
1599
1600 /* Flag the first invalid entry */
1601 prom_debug("ending prom_initialize_tce_table\n");
1602 }
1603 #endif /* __BIG_ENDIAN__ */
1604 #endif /* CONFIG_PPC64 */
1605
1606 /*
1607 * With CHRP SMP we need to use the OF to start the other processors.
1608 * We can't wait until smp_boot_cpus (the OF is trashed by then)
1609 * so we have to put the processors into a holding pattern controlled
1610 * by the kernel (not OF) before we destroy the OF.
1611 *
1612 * This uses a chunk of low memory, puts some holding pattern
1613 * code there and sends the other processors off to there until
1614 * smp_boot_cpus tells them to do something. The holding pattern
1615 * checks that address until its cpu # is there, when it is that
1616 * cpu jumps to __secondary_start(). smp_boot_cpus() takes care
1617 * of setting those values.
1618 *
1619 * We also use physical address 0x4 here to tell when a cpu
1620 * is in its holding pattern code.
1621 *
1622 * -- Cort
1623 */
1624 /*
1625 * We want to reference the copy of __secondary_hold_* in the
1626 * 0 - 0x100 address range
1627 */
1628 #define LOW_ADDR(x) (((unsigned long) &(x)) & 0xff)
1629
1630 static void __init prom_hold_cpus(void)
1631 {
1632 unsigned long i;
1633 phandle node;
1634 char type[64];
1635 unsigned long *spinloop
1636 = (void *) LOW_ADDR(__secondary_hold_spinloop);
1637 unsigned long *acknowledge
1638 = (void *) LOW_ADDR(__secondary_hold_acknowledge);
1639 unsigned long secondary_hold = LOW_ADDR(__secondary_hold);
1640
1641 /*
1642 * On pseries, if RTAS supports "query-cpu-stopped-state",
1643 * we skip this stage, the CPUs will be started by the
1644 * kernel using RTAS.
1645 */
1646 if ((of_platform == PLATFORM_PSERIES ||
1647 of_platform == PLATFORM_PSERIES_LPAR) &&
1648 rtas_has_query_cpu_stopped) {
1649 prom_printf("prom_hold_cpus: skipped\n");
1650 return;
1651 }
1652
1653 prom_debug("prom_hold_cpus: start...\n");
1654 prom_debug(" 1) spinloop = 0x%x\n", (unsigned long)spinloop);
1655 prom_debug(" 1) *spinloop = 0x%x\n", *spinloop);
1656 prom_debug(" 1) acknowledge = 0x%x\n",
1657 (unsigned long)acknowledge);
1658 prom_debug(" 1) *acknowledge = 0x%x\n", *acknowledge);
1659 prom_debug(" 1) secondary_hold = 0x%x\n", secondary_hold);
1660
1661 /* Set the common spinloop variable, so all of the secondary cpus
1662 * will block when they are awakened from their OF spinloop.
1663 * This must occur for both SMP and non SMP kernels, since OF will
1664 * be trashed when we move the kernel.
1665 */
1666 *spinloop = 0;
1667
1668 /* look for cpus */
1669 for (node = 0; prom_next_node(&node); ) {
1670 unsigned int cpu_no;
1671 __be32 reg;
1672
1673 type[0] = 0;
1674 prom_getprop(node, "device_type", type, sizeof(type));
1675 if (strcmp(type, "cpu") != 0)
1676 continue;
1677
1678 /* Skip non-configured cpus. */
1679 if (prom_getprop(node, "status", type, sizeof(type)) > 0)
1680 if (strcmp(type, "okay") != 0)
1681 continue;
1682
1683 reg = cpu_to_be32(-1); /* make sparse happy */
1684 prom_getprop(node, "reg", &reg, sizeof(reg));
1685 cpu_no = be32_to_cpu(reg);
1686
1687 prom_debug("cpu hw idx = %lu\n", cpu_no);
1688
1689 /* Init the acknowledge var which will be reset by
1690 * the secondary cpu when it awakens from its OF
1691 * spinloop.
1692 */
1693 *acknowledge = (unsigned long)-1;
1694
1695 if (cpu_no != prom.cpu) {
1696 /* Primary Thread of non-boot cpu or any thread */
1697 prom_printf("starting cpu hw idx %lu... ", cpu_no);
1698 call_prom("start-cpu", 3, 0, node,
1699 secondary_hold, cpu_no);
1700
1701 for (i = 0; (i < 100000000) &&
1702 (*acknowledge == ((unsigned long)-1)); i++ )
1703 mb();
1704
1705 if (*acknowledge == cpu_no)
1706 prom_printf("done\n");
1707 else
1708 prom_printf("failed: %x\n", *acknowledge);
1709 }
1710 #ifdef CONFIG_SMP
1711 else
1712 prom_printf("boot cpu hw idx %lu\n", cpu_no);
1713 #endif /* CONFIG_SMP */
1714 }
1715
1716 prom_debug("prom_hold_cpus: end...\n");
1717 }
1718
1719
1720 static void __init prom_init_client_services(unsigned long pp)
1721 {
1722 /* Get a handle to the prom entry point before anything else */
1723 prom_entry = pp;
1724
1725 /* get a handle for the stdout device */
1726 prom.chosen = call_prom("finddevice", 1, 1, ADDR("/chosen"));
1727 if (!PHANDLE_VALID(prom.chosen))
1728 prom_panic("cannot find chosen"); /* msg won't be printed :( */
1729
1730 /* get device tree root */
1731 prom.root = call_prom("finddevice", 1, 1, ADDR("/"));
1732 if (!PHANDLE_VALID(prom.root))
1733 prom_panic("cannot find device tree root"); /* msg won't be printed :( */
1734
1735 prom.mmumap = 0;
1736 }
1737
1738 #ifdef CONFIG_PPC32
1739 /*
1740 * For really old powermacs, we need to map things we claim.
1741 * For that, we need the ihandle of the mmu.
1742 * Also, on the longtrail, we need to work around other bugs.
1743 */
1744 static void __init prom_find_mmu(void)
1745 {
1746 phandle oprom;
1747 char version[64];
1748
1749 oprom = call_prom("finddevice", 1, 1, ADDR("/openprom"));
1750 if (!PHANDLE_VALID(oprom))
1751 return;
1752 if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0)
1753 return;
1754 version[sizeof(version) - 1] = 0;
1755 /* XXX might need to add other versions here */
1756 if (strcmp(version, "Open Firmware, 1.0.5") == 0)
1757 of_workarounds = OF_WA_CLAIM;
1758 else if (strncmp(version, "FirmWorks,3.", 12) == 0) {
1759 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL;
1760 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim");
1761 } else
1762 return;
1763 prom.memory = call_prom("open", 1, 1, ADDR("/memory"));
1764 prom_getprop(prom.chosen, "mmu", &prom.mmumap,
1765 sizeof(prom.mmumap));
1766 prom.mmumap = be32_to_cpu(prom.mmumap);
1767 if (!IHANDLE_VALID(prom.memory) || !IHANDLE_VALID(prom.mmumap))
1768 of_workarounds &= ~OF_WA_CLAIM; /* hmmm */
1769 }
1770 #else
1771 #define prom_find_mmu()
1772 #endif
1773
1774 static void __init prom_init_stdout(void)
1775 {
1776 char *path = of_stdout_device;
1777 char type[16];
1778 phandle stdout_node;
1779 __be32 val;
1780
1781 if (prom_getprop(prom.chosen, "stdout", &val, sizeof(val)) <= 0)
1782 prom_panic("cannot find stdout");
1783
1784 prom.stdout = be32_to_cpu(val);
1785
1786 /* Get the full OF pathname of the stdout device */
1787 memset(path, 0, 256);
1788 call_prom("instance-to-path", 3, 1, prom.stdout, path, 255);
1789 prom_printf("OF stdout device is: %s\n", of_stdout_device);
1790 prom_setprop(prom.chosen, "/chosen", "linux,stdout-path",
1791 path, strlen(path) + 1);
1792
1793 /* instance-to-package fails on PA-Semi */
1794 stdout_node = call_prom("instance-to-package", 1, 1, prom.stdout);
1795 if (stdout_node != PROM_ERROR) {
1796 val = cpu_to_be32(stdout_node);
1797 prom_setprop(prom.chosen, "/chosen", "linux,stdout-package",
1798 &val, sizeof(val));
1799
1800 /* If it's a display, note it */
1801 memset(type, 0, sizeof(type));
1802 prom_getprop(stdout_node, "device_type", type, sizeof(type));
1803 if (strcmp(type, "display") == 0)
1804 prom_setprop(stdout_node, path, "linux,boot-display", NULL, 0);
1805 }
1806 }
1807
1808 static int __init prom_find_machine_type(void)
1809 {
1810 char compat[256];
1811 int len, i = 0;
1812 #ifdef CONFIG_PPC64
1813 phandle rtas;
1814 int x;
1815 #endif
1816
1817 /* Look for a PowerMac or a Cell */
1818 len = prom_getprop(prom.root, "compatible",
1819 compat, sizeof(compat)-1);
1820 if (len > 0) {
1821 compat[len] = 0;
1822 while (i < len) {
1823 char *p = &compat[i];
1824 int sl = strlen(p);
1825 if (sl == 0)
1826 break;
1827 if (strstr(p, "Power Macintosh") ||
1828 strstr(p, "MacRISC"))
1829 return PLATFORM_POWERMAC;
1830 #ifdef CONFIG_PPC64
1831 /* We must make sure we don't detect the IBM Cell
1832 * blades as pSeries due to some firmware issues,
1833 * so we do it here.
1834 */
1835 if (strstr(p, "IBM,CBEA") ||
1836 strstr(p, "IBM,CPBW-1.0"))
1837 return PLATFORM_GENERIC;
1838 #endif /* CONFIG_PPC64 */
1839 i += sl + 1;
1840 }
1841 }
1842 #ifdef CONFIG_PPC64
1843 /* Try to detect OPAL */
1844 if (PHANDLE_VALID(call_prom("finddevice", 1, 1, ADDR("/ibm,opal"))))
1845 return PLATFORM_OPAL;
1846
1847 /* Try to figure out if it's an IBM pSeries or any other
1848 * PAPR compliant platform. We assume it is if :
1849 * - /device_type is "chrp" (please, do NOT use that for future
1850 * non-IBM designs !
1851 * - it has /rtas
1852 */
1853 len = prom_getprop(prom.root, "device_type",
1854 compat, sizeof(compat)-1);
1855 if (len <= 0)
1856 return PLATFORM_GENERIC;
1857 if (strcmp(compat, "chrp"))
1858 return PLATFORM_GENERIC;
1859
1860 /* Default to pSeries. We need to know if we are running LPAR */
1861 rtas = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1862 if (!PHANDLE_VALID(rtas))
1863 return PLATFORM_GENERIC;
1864 x = prom_getproplen(rtas, "ibm,hypertas-functions");
1865 if (x != PROM_ERROR) {
1866 prom_debug("Hypertas detected, assuming LPAR !\n");
1867 return PLATFORM_PSERIES_LPAR;
1868 }
1869 return PLATFORM_PSERIES;
1870 #else
1871 return PLATFORM_GENERIC;
1872 #endif
1873 }
1874
1875 static int __init prom_set_color(ihandle ih, int i, int r, int g, int b)
1876 {
1877 return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r);
1878 }
1879
1880 /*
1881 * If we have a display that we don't know how to drive,
1882 * we will want to try to execute OF's open method for it
1883 * later. However, OF will probably fall over if we do that
1884 * we've taken over the MMU.
1885 * So we check whether we will need to open the display,
1886 * and if so, open it now.
1887 */
1888 static void __init prom_check_displays(void)
1889 {
1890 char type[16], *path;
1891 phandle node;
1892 ihandle ih;
1893 int i;
1894
1895 static unsigned char default_colors[] = {
1896 0x00, 0x00, 0x00,
1897 0x00, 0x00, 0xaa,
1898 0x00, 0xaa, 0x00,
1899 0x00, 0xaa, 0xaa,
1900 0xaa, 0x00, 0x00,
1901 0xaa, 0x00, 0xaa,
1902 0xaa, 0xaa, 0x00,
1903 0xaa, 0xaa, 0xaa,
1904 0x55, 0x55, 0x55,
1905 0x55, 0x55, 0xff,
1906 0x55, 0xff, 0x55,
1907 0x55, 0xff, 0xff,
1908 0xff, 0x55, 0x55,
1909 0xff, 0x55, 0xff,
1910 0xff, 0xff, 0x55,
1911 0xff, 0xff, 0xff
1912 };
1913 const unsigned char *clut;
1914
1915 prom_debug("Looking for displays\n");
1916 for (node = 0; prom_next_node(&node); ) {
1917 memset(type, 0, sizeof(type));
1918 prom_getprop(node, "device_type", type, sizeof(type));
1919 if (strcmp(type, "display") != 0)
1920 continue;
1921
1922 /* It seems OF doesn't null-terminate the path :-( */
1923 path = prom_scratch;
1924 memset(path, 0, PROM_SCRATCH_SIZE);
1925
1926 /*
1927 * leave some room at the end of the path for appending extra
1928 * arguments
1929 */
1930 if (call_prom("package-to-path", 3, 1, node, path,
1931 PROM_SCRATCH_SIZE-10) == PROM_ERROR)
1932 continue;
1933 prom_printf("found display : %s, opening... ", path);
1934
1935 ih = call_prom("open", 1, 1, path);
1936 if (ih == 0) {
1937 prom_printf("failed\n");
1938 continue;
1939 }
1940
1941 /* Success */
1942 prom_printf("done\n");
1943 prom_setprop(node, path, "linux,opened", NULL, 0);
1944
1945 /* Setup a usable color table when the appropriate
1946 * method is available. Should update this to set-colors */
1947 clut = default_colors;
1948 for (i = 0; i < 16; i++, clut += 3)
1949 if (prom_set_color(ih, i, clut[0], clut[1],
1950 clut[2]) != 0)
1951 break;
1952
1953 #ifdef CONFIG_LOGO_LINUX_CLUT224
1954 clut = PTRRELOC(logo_linux_clut224.clut);
1955 for (i = 0; i < logo_linux_clut224.clutsize; i++, clut += 3)
1956 if (prom_set_color(ih, i + 32, clut[0], clut[1],
1957 clut[2]) != 0)
1958 break;
1959 #endif /* CONFIG_LOGO_LINUX_CLUT224 */
1960
1961 #ifdef CONFIG_PPC_EARLY_DEBUG_BOOTX
1962 if (prom_getprop(node, "linux,boot-display", NULL, 0) !=
1963 PROM_ERROR) {
1964 u32 width, height, pitch, addr;
1965
1966 prom_printf("Setting btext !\n");
1967 prom_getprop(node, "width", &width, 4);
1968 prom_getprop(node, "height", &height, 4);
1969 prom_getprop(node, "linebytes", &pitch, 4);
1970 prom_getprop(node, "address", &addr, 4);
1971 prom_printf("W=%d H=%d LB=%d addr=0x%x\n",
1972 width, height, pitch, addr);
1973 btext_setup_display(width, height, 8, pitch, addr);
1974 }
1975 #endif /* CONFIG_PPC_EARLY_DEBUG_BOOTX */
1976 }
1977 }
1978
1979
1980 /* Return (relocated) pointer to this much memory: moves initrd if reqd. */
1981 static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end,
1982 unsigned long needed, unsigned long align)
1983 {
1984 void *ret;
1985
1986 *mem_start = _ALIGN(*mem_start, align);
1987 while ((*mem_start + needed) > *mem_end) {
1988 unsigned long room, chunk;
1989
1990 prom_debug("Chunk exhausted, claiming more at %x...\n",
1991 alloc_bottom);
1992 room = alloc_top - alloc_bottom;
1993 if (room > DEVTREE_CHUNK_SIZE)
1994 room = DEVTREE_CHUNK_SIZE;
1995 if (room < PAGE_SIZE)
1996 prom_panic("No memory for flatten_device_tree "
1997 "(no room)\n");
1998 chunk = alloc_up(room, 0);
1999 if (chunk == 0)
2000 prom_panic("No memory for flatten_device_tree "
2001 "(claim failed)\n");
2002 *mem_end = chunk + room;
2003 }
2004
2005 ret = (void *)*mem_start;
2006 *mem_start += needed;
2007
2008 return ret;
2009 }
2010
2011 #define dt_push_token(token, mem_start, mem_end) do { \
2012 void *room = make_room(mem_start, mem_end, 4, 4); \
2013 *(__be32 *)room = cpu_to_be32(token); \
2014 } while(0)
2015
2016 static unsigned long __init dt_find_string(char *str)
2017 {
2018 char *s, *os;
2019
2020 s = os = (char *)dt_string_start;
2021 s += 4;
2022 while (s < (char *)dt_string_end) {
2023 if (strcmp(s, str) == 0)
2024 return s - os;
2025 s += strlen(s) + 1;
2026 }
2027 return 0;
2028 }
2029
2030 /*
2031 * The Open Firmware 1275 specification states properties must be 31 bytes or
2032 * less, however not all firmwares obey this. Make it 64 bytes to be safe.
2033 */
2034 #define MAX_PROPERTY_NAME 64
2035
2036 static void __init scan_dt_build_strings(phandle node,
2037 unsigned long *mem_start,
2038 unsigned long *mem_end)
2039 {
2040 char *prev_name, *namep, *sstart;
2041 unsigned long soff;
2042 phandle child;
2043
2044 sstart = (char *)dt_string_start;
2045
2046 /* get and store all property names */
2047 prev_name = "";
2048 for (;;) {
2049 /* 64 is max len of name including nul. */
2050 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1);
2051 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) {
2052 /* No more nodes: unwind alloc */
2053 *mem_start = (unsigned long)namep;
2054 break;
2055 }
2056
2057 /* skip "name" */
2058 if (strcmp(namep, "name") == 0) {
2059 *mem_start = (unsigned long)namep;
2060 prev_name = "name";
2061 continue;
2062 }
2063 /* get/create string entry */
2064 soff = dt_find_string(namep);
2065 if (soff != 0) {
2066 *mem_start = (unsigned long)namep;
2067 namep = sstart + soff;
2068 } else {
2069 /* Trim off some if we can */
2070 *mem_start = (unsigned long)namep + strlen(namep) + 1;
2071 dt_string_end = *mem_start;
2072 }
2073 prev_name = namep;
2074 }
2075
2076 /* do all our children */
2077 child = call_prom("child", 1, 1, node);
2078 while (child != 0) {
2079 scan_dt_build_strings(child, mem_start, mem_end);
2080 child = call_prom("peer", 1, 1, child);
2081 }
2082 }
2083
2084 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
2085 unsigned long *mem_end)
2086 {
2087 phandle child;
2088 char *namep, *prev_name, *sstart, *p, *ep, *lp, *path;
2089 unsigned long soff;
2090 unsigned char *valp;
2091 static char pname[MAX_PROPERTY_NAME];
2092 int l, room, has_phandle = 0;
2093
2094 dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end);
2095
2096 /* get the node's full name */
2097 namep = (char *)*mem_start;
2098 room = *mem_end - *mem_start;
2099 if (room > 255)
2100 room = 255;
2101 l = call_prom("package-to-path", 3, 1, node, namep, room);
2102 if (l >= 0) {
2103 /* Didn't fit? Get more room. */
2104 if (l >= room) {
2105 if (l >= *mem_end - *mem_start)
2106 namep = make_room(mem_start, mem_end, l+1, 1);
2107 call_prom("package-to-path", 3, 1, node, namep, l);
2108 }
2109 namep[l] = '\0';
2110
2111 /* Fixup an Apple bug where they have bogus \0 chars in the
2112 * middle of the path in some properties, and extract
2113 * the unit name (everything after the last '/').
2114 */
2115 for (lp = p = namep, ep = namep + l; p < ep; p++) {
2116 if (*p == '/')
2117 lp = namep;
2118 else if (*p != 0)
2119 *lp++ = *p;
2120 }
2121 *lp = 0;
2122 *mem_start = _ALIGN((unsigned long)lp + 1, 4);
2123 }
2124
2125 /* get it again for debugging */
2126 path = prom_scratch;
2127 memset(path, 0, PROM_SCRATCH_SIZE);
2128 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
2129
2130 /* get and store all properties */
2131 prev_name = "";
2132 sstart = (char *)dt_string_start;
2133 for (;;) {
2134 if (call_prom("nextprop", 3, 1, node, prev_name,
2135 pname) != 1)
2136 break;
2137
2138 /* skip "name" */
2139 if (strcmp(pname, "name") == 0) {
2140 prev_name = "name";
2141 continue;
2142 }
2143
2144 /* find string offset */
2145 soff = dt_find_string(pname);
2146 if (soff == 0) {
2147 prom_printf("WARNING: Can't find string index for"
2148 " <%s>, node %s\n", pname, path);
2149 break;
2150 }
2151 prev_name = sstart + soff;
2152
2153 /* get length */
2154 l = call_prom("getproplen", 2, 1, node, pname);
2155
2156 /* sanity checks */
2157 if (l == PROM_ERROR)
2158 continue;
2159
2160 /* push property head */
2161 dt_push_token(OF_DT_PROP, mem_start, mem_end);
2162 dt_push_token(l, mem_start, mem_end);
2163 dt_push_token(soff, mem_start, mem_end);
2164
2165 /* push property content */
2166 valp = make_room(mem_start, mem_end, l, 4);
2167 call_prom("getprop", 4, 1, node, pname, valp, l);
2168 *mem_start = _ALIGN(*mem_start, 4);
2169
2170 if (!strcmp(pname, "phandle"))
2171 has_phandle = 1;
2172 }
2173
2174 /* Add a "linux,phandle" property if no "phandle" property already
2175 * existed (can happen with OPAL)
2176 */
2177 if (!has_phandle) {
2178 soff = dt_find_string("linux,phandle");
2179 if (soff == 0)
2180 prom_printf("WARNING: Can't find string index for"
2181 " <linux-phandle> node %s\n", path);
2182 else {
2183 dt_push_token(OF_DT_PROP, mem_start, mem_end);
2184 dt_push_token(4, mem_start, mem_end);
2185 dt_push_token(soff, mem_start, mem_end);
2186 valp = make_room(mem_start, mem_end, 4, 4);
2187 *(__be32 *)valp = cpu_to_be32(node);
2188 }
2189 }
2190
2191 /* do all our children */
2192 child = call_prom("child", 1, 1, node);
2193 while (child != 0) {
2194 scan_dt_build_struct(child, mem_start, mem_end);
2195 child = call_prom("peer", 1, 1, child);
2196 }
2197
2198 dt_push_token(OF_DT_END_NODE, mem_start, mem_end);
2199 }
2200
2201 static void __init flatten_device_tree(void)
2202 {
2203 phandle root;
2204 unsigned long mem_start, mem_end, room;
2205 struct boot_param_header *hdr;
2206 char *namep;
2207 u64 *rsvmap;
2208
2209 /*
2210 * Check how much room we have between alloc top & bottom (+/- a
2211 * few pages), crop to 1MB, as this is our "chunk" size
2212 */
2213 room = alloc_top - alloc_bottom - 0x4000;
2214 if (room > DEVTREE_CHUNK_SIZE)
2215 room = DEVTREE_CHUNK_SIZE;
2216 prom_debug("starting device tree allocs at %x\n", alloc_bottom);
2217
2218 /* Now try to claim that */
2219 mem_start = (unsigned long)alloc_up(room, PAGE_SIZE);
2220 if (mem_start == 0)
2221 prom_panic("Can't allocate initial device-tree chunk\n");
2222 mem_end = mem_start + room;
2223
2224 /* Get root of tree */
2225 root = call_prom("peer", 1, 1, (phandle)0);
2226 if (root == (phandle)0)
2227 prom_panic ("couldn't get device tree root\n");
2228
2229 /* Build header and make room for mem rsv map */
2230 mem_start = _ALIGN(mem_start, 4);
2231 hdr = make_room(&mem_start, &mem_end,
2232 sizeof(struct boot_param_header), 4);
2233 dt_header_start = (unsigned long)hdr;
2234 rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8);
2235
2236 /* Start of strings */
2237 mem_start = PAGE_ALIGN(mem_start);
2238 dt_string_start = mem_start;
2239 mem_start += 4; /* hole */
2240
2241 /* Add "linux,phandle" in there, we'll need it */
2242 namep = make_room(&mem_start, &mem_end, 16, 1);
2243 strcpy(namep, "linux,phandle");
2244 mem_start = (unsigned long)namep + strlen(namep) + 1;
2245
2246 /* Build string array */
2247 prom_printf("Building dt strings...\n");
2248 scan_dt_build_strings(root, &mem_start, &mem_end);
2249 dt_string_end = mem_start;
2250
2251 /* Build structure */
2252 mem_start = PAGE_ALIGN(mem_start);
2253 dt_struct_start = mem_start;
2254 prom_printf("Building dt structure...\n");
2255 scan_dt_build_struct(root, &mem_start, &mem_end);
2256 dt_push_token(OF_DT_END, &mem_start, &mem_end);
2257 dt_struct_end = PAGE_ALIGN(mem_start);
2258
2259 /* Finish header */
2260 hdr->boot_cpuid_phys = cpu_to_be32(prom.cpu);
2261 hdr->magic = cpu_to_be32(OF_DT_HEADER);
2262 hdr->totalsize = cpu_to_be32(dt_struct_end - dt_header_start);
2263 hdr->off_dt_struct = cpu_to_be32(dt_struct_start - dt_header_start);
2264 hdr->off_dt_strings = cpu_to_be32(dt_string_start - dt_header_start);
2265 hdr->dt_strings_size = cpu_to_be32(dt_string_end - dt_string_start);
2266 hdr->off_mem_rsvmap = cpu_to_be32(((unsigned long)rsvmap) - dt_header_start);
2267 hdr->version = cpu_to_be32(OF_DT_VERSION);
2268 /* Version 16 is not backward compatible */
2269 hdr->last_comp_version = cpu_to_be32(0x10);
2270
2271 /* Copy the reserve map in */
2272 memcpy(rsvmap, mem_reserve_map, sizeof(mem_reserve_map));
2273
2274 #ifdef DEBUG_PROM
2275 {
2276 int i;
2277 prom_printf("reserved memory map:\n");
2278 for (i = 0; i < mem_reserve_cnt; i++)
2279 prom_printf(" %x - %x\n",
2280 be64_to_cpu(mem_reserve_map[i].base),
2281 be64_to_cpu(mem_reserve_map[i].size));
2282 }
2283 #endif
2284 /* Bump mem_reserve_cnt to cause further reservations to fail
2285 * since it's too late.
2286 */
2287 mem_reserve_cnt = MEM_RESERVE_MAP_SIZE;
2288
2289 prom_printf("Device tree strings 0x%x -> 0x%x\n",
2290 dt_string_start, dt_string_end);
2291 prom_printf("Device tree struct 0x%x -> 0x%x\n",
2292 dt_struct_start, dt_struct_end);
2293 }
2294
2295 #ifdef CONFIG_PPC_MAPLE
2296 /* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property.
2297 * The values are bad, and it doesn't even have the right number of cells. */
2298 static void __init fixup_device_tree_maple(void)
2299 {
2300 phandle isa;
2301 u32 rloc = 0x01002000; /* IO space; PCI device = 4 */
2302 u32 isa_ranges[6];
2303 char *name;
2304
2305 name = "/ht@0/isa@4";
2306 isa = call_prom("finddevice", 1, 1, ADDR(name));
2307 if (!PHANDLE_VALID(isa)) {
2308 name = "/ht@0/isa@6";
2309 isa = call_prom("finddevice", 1, 1, ADDR(name));
2310 rloc = 0x01003000; /* IO space; PCI device = 6 */
2311 }
2312 if (!PHANDLE_VALID(isa))
2313 return;
2314
2315 if (prom_getproplen(isa, "ranges") != 12)
2316 return;
2317 if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges))
2318 == PROM_ERROR)
2319 return;
2320
2321 if (isa_ranges[0] != 0x1 ||
2322 isa_ranges[1] != 0xf4000000 ||
2323 isa_ranges[2] != 0x00010000)
2324 return;
2325
2326 prom_printf("Fixing up bogus ISA range on Maple/Apache...\n");
2327
2328 isa_ranges[0] = 0x1;
2329 isa_ranges[1] = 0x0;
2330 isa_ranges[2] = rloc;
2331 isa_ranges[3] = 0x0;
2332 isa_ranges[4] = 0x0;
2333 isa_ranges[5] = 0x00010000;
2334 prom_setprop(isa, name, "ranges",
2335 isa_ranges, sizeof(isa_ranges));
2336 }
2337
2338 #define CPC925_MC_START 0xf8000000
2339 #define CPC925_MC_LENGTH 0x1000000
2340 /* The values for memory-controller don't have right number of cells */
2341 static void __init fixup_device_tree_maple_memory_controller(void)
2342 {
2343 phandle mc;
2344 u32 mc_reg[4];
2345 char *name = "/hostbridge@f8000000";
2346 u32 ac, sc;
2347
2348 mc = call_prom("finddevice", 1, 1, ADDR(name));
2349 if (!PHANDLE_VALID(mc))
2350 return;
2351
2352 if (prom_getproplen(mc, "reg") != 8)
2353 return;
2354
2355 prom_getprop(prom.root, "#address-cells", &ac, sizeof(ac));
2356 prom_getprop(prom.root, "#size-cells", &sc, sizeof(sc));
2357 if ((ac != 2) || (sc != 2))
2358 return;
2359
2360 if (prom_getprop(mc, "reg", mc_reg, sizeof(mc_reg)) == PROM_ERROR)
2361 return;
2362
2363 if (mc_reg[0] != CPC925_MC_START || mc_reg[1] != CPC925_MC_LENGTH)
2364 return;
2365
2366 prom_printf("Fixing up bogus hostbridge on Maple...\n");
2367
2368 mc_reg[0] = 0x0;
2369 mc_reg[1] = CPC925_MC_START;
2370 mc_reg[2] = 0x0;
2371 mc_reg[3] = CPC925_MC_LENGTH;
2372 prom_setprop(mc, name, "reg", mc_reg, sizeof(mc_reg));
2373 }
2374 #else
2375 #define fixup_device_tree_maple()
2376 #define fixup_device_tree_maple_memory_controller()
2377 #endif
2378
2379 #ifdef CONFIG_PPC_CHRP
2380 /*
2381 * Pegasos and BriQ lacks the "ranges" property in the isa node
2382 * Pegasos needs decimal IRQ 14/15, not hexadecimal
2383 * Pegasos has the IDE configured in legacy mode, but advertised as native
2384 */
2385 static void __init fixup_device_tree_chrp(void)
2386 {
2387 phandle ph;
2388 u32 prop[6];
2389 u32 rloc = 0x01006000; /* IO space; PCI device = 12 */
2390 char *name;
2391 int rc;
2392
2393 name = "/pci@80000000/isa@c";
2394 ph = call_prom("finddevice", 1, 1, ADDR(name));
2395 if (!PHANDLE_VALID(ph)) {
2396 name = "/pci@ff500000/isa@6";
2397 ph = call_prom("finddevice", 1, 1, ADDR(name));
2398 rloc = 0x01003000; /* IO space; PCI device = 6 */
2399 }
2400 if (PHANDLE_VALID(ph)) {
2401 rc = prom_getproplen(ph, "ranges");
2402 if (rc == 0 || rc == PROM_ERROR) {
2403 prom_printf("Fixing up missing ISA range on Pegasos...\n");
2404
2405 prop[0] = 0x1;
2406 prop[1] = 0x0;
2407 prop[2] = rloc;
2408 prop[3] = 0x0;
2409 prop[4] = 0x0;
2410 prop[5] = 0x00010000;
2411 prom_setprop(ph, name, "ranges", prop, sizeof(prop));
2412 }
2413 }
2414
2415 name = "/pci@80000000/ide@C,1";
2416 ph = call_prom("finddevice", 1, 1, ADDR(name));
2417 if (PHANDLE_VALID(ph)) {
2418 prom_printf("Fixing up IDE interrupt on Pegasos...\n");
2419 prop[0] = 14;
2420 prop[1] = 0x0;
2421 prom_setprop(ph, name, "interrupts", prop, 2*sizeof(u32));
2422 prom_printf("Fixing up IDE class-code on Pegasos...\n");
2423 rc = prom_getprop(ph, "class-code", prop, sizeof(u32));
2424 if (rc == sizeof(u32)) {
2425 prop[0] &= ~0x5;
2426 prom_setprop(ph, name, "class-code", prop, sizeof(u32));
2427 }
2428 }
2429 }
2430 #else
2431 #define fixup_device_tree_chrp()
2432 #endif
2433
2434 #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC)
2435 static void __init fixup_device_tree_pmac(void)
2436 {
2437 phandle u3, i2c, mpic;
2438 u32 u3_rev;
2439 u32 interrupts[2];
2440 u32 parent;
2441
2442 /* Some G5s have a missing interrupt definition, fix it up here */
2443 u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000"));
2444 if (!PHANDLE_VALID(u3))
2445 return;
2446 i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000"));
2447 if (!PHANDLE_VALID(i2c))
2448 return;
2449 mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000"));
2450 if (!PHANDLE_VALID(mpic))
2451 return;
2452
2453 /* check if proper rev of u3 */
2454 if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev))
2455 == PROM_ERROR)
2456 return;
2457 if (u3_rev < 0x35 || u3_rev > 0x39)
2458 return;
2459 /* does it need fixup ? */
2460 if (prom_getproplen(i2c, "interrupts") > 0)
2461 return;
2462
2463 prom_printf("fixing up bogus interrupts for u3 i2c...\n");
2464
2465 /* interrupt on this revision of u3 is number 0 and level */
2466 interrupts[0] = 0;
2467 interrupts[1] = 1;
2468 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts",
2469 &interrupts, sizeof(interrupts));
2470 parent = (u32)mpic;
2471 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent",
2472 &parent, sizeof(parent));
2473 }
2474 #else
2475 #define fixup_device_tree_pmac()
2476 #endif
2477
2478 #ifdef CONFIG_PPC_EFIKA
2479 /*
2480 * The MPC5200 FEC driver requires an phy-handle property to tell it how
2481 * to talk to the phy. If the phy-handle property is missing, then this
2482 * function is called to add the appropriate nodes and link it to the
2483 * ethernet node.
2484 */
2485 static void __init fixup_device_tree_efika_add_phy(void)
2486 {
2487 u32 node;
2488 char prop[64];
2489 int rv;
2490
2491 /* Check if /builtin/ethernet exists - bail if it doesn't */
2492 node = call_prom("finddevice", 1, 1, ADDR("/builtin/ethernet"));
2493 if (!PHANDLE_VALID(node))
2494 return;
2495
2496 /* Check if the phy-handle property exists - bail if it does */
2497 rv = prom_getprop(node, "phy-handle", prop, sizeof(prop));
2498 if (!rv)
2499 return;
2500
2501 /*
2502 * At this point the ethernet device doesn't have a phy described.
2503 * Now we need to add the missing phy node and linkage
2504 */
2505
2506 /* Check for an MDIO bus node - if missing then create one */
2507 node = call_prom("finddevice", 1, 1, ADDR("/builtin/mdio"));
2508 if (!PHANDLE_VALID(node)) {
2509 prom_printf("Adding Ethernet MDIO node\n");
2510 call_prom("interpret", 1, 1,
2511 " s\" /builtin\" find-device"
2512 " new-device"
2513 " 1 encode-int s\" #address-cells\" property"
2514 " 0 encode-int s\" #size-cells\" property"
2515 " s\" mdio\" device-name"
2516 " s\" fsl,mpc5200b-mdio\" encode-string"
2517 " s\" compatible\" property"
2518 " 0xf0003000 0x400 reg"
2519 " 0x2 encode-int"
2520 " 0x5 encode-int encode+"
2521 " 0x3 encode-int encode+"
2522 " s\" interrupts\" property"
2523 " finish-device");
2524 };
2525
2526 /* Check for a PHY device node - if missing then create one and
2527 * give it's phandle to the ethernet node */
2528 node = call_prom("finddevice", 1, 1,
2529 ADDR("/builtin/mdio/ethernet-phy"));
2530 if (!PHANDLE_VALID(node)) {
2531 prom_printf("Adding Ethernet PHY node\n");
2532 call_prom("interpret", 1, 1,
2533 " s\" /builtin/mdio\" find-device"
2534 " new-device"
2535 " s\" ethernet-phy\" device-name"
2536 " 0x10 encode-int s\" reg\" property"
2537 " my-self"
2538 " ihandle>phandle"
2539 " finish-device"
2540 " s\" /builtin/ethernet\" find-device"
2541 " encode-int"
2542 " s\" phy-handle\" property"
2543 " device-end");
2544 }
2545 }
2546
2547 static void __init fixup_device_tree_efika(void)
2548 {
2549 int sound_irq[3] = { 2, 2, 0 };
2550 int bcomm_irq[3*16] = { 3,0,0, 3,1,0, 3,2,0, 3,3,0,
2551 3,4,0, 3,5,0, 3,6,0, 3,7,0,
2552 3,8,0, 3,9,0, 3,10,0, 3,11,0,
2553 3,12,0, 3,13,0, 3,14,0, 3,15,0 };
2554 u32 node;
2555 char prop[64];
2556 int rv, len;
2557
2558 /* Check if we're really running on a EFIKA */
2559 node = call_prom("finddevice", 1, 1, ADDR("/"));
2560 if (!PHANDLE_VALID(node))
2561 return;
2562
2563 rv = prom_getprop(node, "model", prop, sizeof(prop));
2564 if (rv == PROM_ERROR)
2565 return;
2566 if (strcmp(prop, "EFIKA5K2"))
2567 return;
2568
2569 prom_printf("Applying EFIKA device tree fixups\n");
2570
2571 /* Claiming to be 'chrp' is death */
2572 node = call_prom("finddevice", 1, 1, ADDR("/"));
2573 rv = prom_getprop(node, "device_type", prop, sizeof(prop));
2574 if (rv != PROM_ERROR && (strcmp(prop, "chrp") == 0))
2575 prom_setprop(node, "/", "device_type", "efika", sizeof("efika"));
2576
2577 /* CODEGEN,description is exposed in /proc/cpuinfo so
2578 fix that too */
2579 rv = prom_getprop(node, "CODEGEN,description", prop, sizeof(prop));
2580 if (rv != PROM_ERROR && (strstr(prop, "CHRP")))
2581 prom_setprop(node, "/", "CODEGEN,description",
2582 "Efika 5200B PowerPC System",
2583 sizeof("Efika 5200B PowerPC System"));
2584
2585 /* Fixup bestcomm interrupts property */
2586 node = call_prom("finddevice", 1, 1, ADDR("/builtin/bestcomm"));
2587 if (PHANDLE_VALID(node)) {
2588 len = prom_getproplen(node, "interrupts");
2589 if (len == 12) {
2590 prom_printf("Fixing bestcomm interrupts property\n");
2591 prom_setprop(node, "/builtin/bestcom", "interrupts",
2592 bcomm_irq, sizeof(bcomm_irq));
2593 }
2594 }
2595
2596 /* Fixup sound interrupts property */
2597 node = call_prom("finddevice", 1, 1, ADDR("/builtin/sound"));
2598 if (PHANDLE_VALID(node)) {
2599 rv = prom_getprop(node, "interrupts", prop, sizeof(prop));
2600 if (rv == PROM_ERROR) {
2601 prom_printf("Adding sound interrupts property\n");
2602 prom_setprop(node, "/builtin/sound", "interrupts",
2603 sound_irq, sizeof(sound_irq));
2604 }
2605 }
2606
2607 /* Make sure ethernet phy-handle property exists */
2608 fixup_device_tree_efika_add_phy();
2609 }
2610 #else
2611 #define fixup_device_tree_efika()
2612 #endif
2613
2614 static void __init fixup_device_tree(void)
2615 {
2616 fixup_device_tree_maple();
2617 fixup_device_tree_maple_memory_controller();
2618 fixup_device_tree_chrp();
2619 fixup_device_tree_pmac();
2620 fixup_device_tree_efika();
2621 }
2622
2623 static void __init prom_find_boot_cpu(void)
2624 {
2625 __be32 rval;
2626 ihandle prom_cpu;
2627 phandle cpu_pkg;
2628
2629 rval = 0;
2630 if (prom_getprop(prom.chosen, "cpu", &rval, sizeof(rval)) <= 0)
2631 return;
2632 prom_cpu = be32_to_cpu(rval);
2633
2634 cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
2635
2636 prom_getprop(cpu_pkg, "reg", &rval, sizeof(rval));
2637 prom.cpu = be32_to_cpu(rval);
2638
2639 prom_debug("Booting CPU hw index = %lu\n", prom.cpu);
2640 }
2641
2642 static void __init prom_check_initrd(unsigned long r3, unsigned long r4)
2643 {
2644 #ifdef CONFIG_BLK_DEV_INITRD
2645 if (r3 && r4 && r4 != 0xdeadbeef) {
2646 __be64 val;
2647
2648 prom_initrd_start = is_kernel_addr(r3) ? __pa(r3) : r3;
2649 prom_initrd_end = prom_initrd_start + r4;
2650
2651 val = cpu_to_be64(prom_initrd_start);
2652 prom_setprop(prom.chosen, "/chosen", "linux,initrd-start",
2653 &val, sizeof(val));
2654 val = cpu_to_be64(prom_initrd_end);
2655 prom_setprop(prom.chosen, "/chosen", "linux,initrd-end",
2656 &val, sizeof(val));
2657
2658 reserve_mem(prom_initrd_start,
2659 prom_initrd_end - prom_initrd_start);
2660
2661 prom_debug("initrd_start=0x%x\n", prom_initrd_start);
2662 prom_debug("initrd_end=0x%x\n", prom_initrd_end);
2663 }
2664 #endif /* CONFIG_BLK_DEV_INITRD */
2665 }
2666
2667 #ifdef CONFIG_PPC64
2668 #ifdef CONFIG_RELOCATABLE
2669 static void reloc_toc(void)
2670 {
2671 }
2672
2673 static void unreloc_toc(void)
2674 {
2675 }
2676 #else
2677 static void __reloc_toc(unsigned long offset, unsigned long nr_entries)
2678 {
2679 unsigned long i;
2680 unsigned long *toc_entry;
2681
2682 /* Get the start of the TOC by using r2 directly. */
2683 asm volatile("addi %0,2,-0x8000" : "=b" (toc_entry));
2684
2685 for (i = 0; i < nr_entries; i++) {
2686 *toc_entry = *toc_entry + offset;
2687 toc_entry++;
2688 }
2689 }
2690
2691 static void reloc_toc(void)
2692 {
2693 unsigned long offset = reloc_offset();
2694 unsigned long nr_entries =
2695 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long);
2696
2697 __reloc_toc(offset, nr_entries);
2698
2699 mb();
2700 }
2701
2702 static void unreloc_toc(void)
2703 {
2704 unsigned long offset = reloc_offset();
2705 unsigned long nr_entries =
2706 (__prom_init_toc_end - __prom_init_toc_start) / sizeof(long);
2707
2708 mb();
2709
2710 __reloc_toc(-offset, nr_entries);
2711 }
2712 #endif
2713 #endif
2714
2715 /*
2716 * We enter here early on, when the Open Firmware prom is still
2717 * handling exceptions and the MMU hash table for us.
2718 */
2719
2720 unsigned long __init prom_init(unsigned long r3, unsigned long r4,
2721 unsigned long pp,
2722 unsigned long r6, unsigned long r7,
2723 unsigned long kbase)
2724 {
2725 unsigned long hdr;
2726
2727 #ifdef CONFIG_PPC32
2728 unsigned long offset = reloc_offset();
2729 reloc_got2(offset);
2730 #else
2731 reloc_toc();
2732 #endif
2733
2734 /*
2735 * First zero the BSS
2736 */
2737 memset(&__bss_start, 0, __bss_stop - __bss_start);
2738
2739 /*
2740 * Init interface to Open Firmware, get some node references,
2741 * like /chosen
2742 */
2743 prom_init_client_services(pp);
2744
2745 /*
2746 * See if this OF is old enough that we need to do explicit maps
2747 * and other workarounds
2748 */
2749 prom_find_mmu();
2750
2751 /*
2752 * Init prom stdout device
2753 */
2754 prom_init_stdout();
2755
2756 prom_printf("Preparing to boot %s", linux_banner);
2757
2758 /*
2759 * Get default machine type. At this point, we do not differentiate
2760 * between pSeries SMP and pSeries LPAR
2761 */
2762 of_platform = prom_find_machine_type();
2763 prom_printf("Detected machine type: %x\n", of_platform);
2764
2765 #ifndef CONFIG_NONSTATIC_KERNEL
2766 /* Bail if this is a kdump kernel. */
2767 if (PHYSICAL_START > 0)
2768 prom_panic("Error: You can't boot a kdump kernel from OF!\n");
2769 #endif
2770
2771 /*
2772 * Check for an initrd
2773 */
2774 prom_check_initrd(r3, r4);
2775
2776 #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
2777 /*
2778 * On pSeries, inform the firmware about our capabilities
2779 */
2780 if (of_platform == PLATFORM_PSERIES ||
2781 of_platform == PLATFORM_PSERIES_LPAR)
2782 prom_send_capabilities();
2783 #endif
2784
2785 /*
2786 * Copy the CPU hold code
2787 */
2788 if (of_platform != PLATFORM_POWERMAC)
2789 copy_and_flush(0, kbase, 0x100, 0);
2790
2791 /*
2792 * Do early parsing of command line
2793 */
2794 early_cmdline_parse();
2795
2796 /*
2797 * Initialize memory management within prom_init
2798 */
2799 prom_init_mem();
2800
2801 /*
2802 * Determine which cpu is actually running right _now_
2803 */
2804 prom_find_boot_cpu();
2805
2806 /*
2807 * Initialize display devices
2808 */
2809 prom_check_displays();
2810
2811 #if defined(CONFIG_PPC64) && defined(__BIG_ENDIAN__)
2812 /*
2813 * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else
2814 * that uses the allocator, we need to make sure we get the top of memory
2815 * available for us here...
2816 */
2817 if (of_platform == PLATFORM_PSERIES)
2818 prom_initialize_tce_table();
2819 #endif
2820
2821 /*
2822 * On non-powermacs, try to instantiate RTAS. PowerMacs don't
2823 * have a usable RTAS implementation.
2824 */
2825 if (of_platform != PLATFORM_POWERMAC &&
2826 of_platform != PLATFORM_OPAL)
2827 prom_instantiate_rtas();
2828
2829 #ifdef CONFIG_PPC_POWERNV
2830 if (of_platform == PLATFORM_OPAL)
2831 prom_instantiate_opal();
2832 #endif /* CONFIG_PPC_POWERNV */
2833
2834 #ifdef CONFIG_PPC64
2835 /* instantiate sml */
2836 prom_instantiate_sml();
2837 #endif
2838
2839 /*
2840 * On non-powermacs, put all CPUs in spin-loops.
2841 *
2842 * PowerMacs use a different mechanism to spin CPUs
2843 *
2844 * (This must be done after instanciating RTAS)
2845 */
2846 if (of_platform != PLATFORM_POWERMAC &&
2847 of_platform != PLATFORM_OPAL)
2848 prom_hold_cpus();
2849
2850 /*
2851 * Fill in some infos for use by the kernel later on
2852 */
2853 if (prom_memory_limit) {
2854 __be64 val = cpu_to_be64(prom_memory_limit);
2855 prom_setprop(prom.chosen, "/chosen", "linux,memory-limit",
2856 &val, sizeof(val));
2857 }
2858 #ifdef CONFIG_PPC64
2859 if (prom_iommu_off)
2860 prom_setprop(prom.chosen, "/chosen", "linux,iommu-off",
2861 NULL, 0);
2862
2863 if (prom_iommu_force_on)
2864 prom_setprop(prom.chosen, "/chosen", "linux,iommu-force-on",
2865 NULL, 0);
2866
2867 if (prom_tce_alloc_start) {
2868 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-start",
2869 &prom_tce_alloc_start,
2870 sizeof(prom_tce_alloc_start));
2871 prom_setprop(prom.chosen, "/chosen", "linux,tce-alloc-end",
2872 &prom_tce_alloc_end,
2873 sizeof(prom_tce_alloc_end));
2874 }
2875 #endif
2876
2877 /*
2878 * Fixup any known bugs in the device-tree
2879 */
2880 fixup_device_tree();
2881
2882 /*
2883 * Now finally create the flattened device-tree
2884 */
2885 prom_printf("copying OF device tree...\n");
2886 flatten_device_tree();
2887
2888 /*
2889 * in case stdin is USB and still active on IBM machines...
2890 * Unfortunately quiesce crashes on some powermacs if we have
2891 * closed stdin already (in particular the powerbook 101). It
2892 * appears that the OPAL version of OFW doesn't like it either.
2893 */
2894 if (of_platform != PLATFORM_POWERMAC &&
2895 of_platform != PLATFORM_OPAL)
2896 prom_close_stdin();
2897
2898 /*
2899 * Call OF "quiesce" method to shut down pending DMA's from
2900 * devices etc...
2901 */
2902 prom_printf("Quiescing Open Firmware ...\n");
2903 call_prom("quiesce", 0, 0);
2904
2905 /*
2906 * And finally, call the kernel passing it the flattened device
2907 * tree and NULL as r5, thus triggering the new entry point which
2908 * is common to us and kexec
2909 */
2910 hdr = dt_header_start;
2911
2912 /* Don't print anything after quiesce under OPAL, it crashes OFW */
2913 if (of_platform != PLATFORM_OPAL) {
2914 prom_printf("Booting Linux via __start() ...\n");
2915 prom_debug("->dt_header_start=0x%x\n", hdr);
2916 }
2917
2918 #ifdef CONFIG_PPC32
2919 reloc_got2(-offset);
2920 #else
2921 unreloc_toc();
2922 #endif
2923
2924 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
2925 /* OPAL early debug gets the OPAL base & entry in r8 and r9 */
2926 __start(hdr, kbase, 0, 0, 0,
2927 prom_opal_base, prom_opal_entry);
2928 #else
2929 __start(hdr, kbase, 0, 0, 0, 0, 0);
2930 #endif
2931
2932 return 0;
2933 }
Linux with added FPC-III support