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