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