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