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