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