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