projects / deliverable / linux.git / blob
? search:


e96f5d0d2c78917a525500c8fd80ddf81c1fd46d
[deliverable/linux.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(64), /* 64MB 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 /* Check if we have an initrd after the kernel, if we do move our bottom
1228 * point to after it
1229 */
1230 if (RELOC(prom_initrd_start)) {
1231 if (RELOC(prom_initrd_end) > RELOC(alloc_bottom))
1232 RELOC(alloc_bottom) = PAGE_ALIGN(RELOC(prom_initrd_end));
1233 }
1234
1235 /*
1236 * If prom_memory_limit is set we reduce the upper limits *except* for
1237 * alloc_top_high. This must be the real top of RAM so we can put
1238 * TCE's up there.
1239 */
1240
1241 RELOC(alloc_top_high) = RELOC(ram_top);
1242
1243 if (RELOC(prom_memory_limit)) {
1244 if (RELOC(prom_memory_limit) <= RELOC(alloc_bottom)) {
1245 prom_printf("Ignoring mem=%x <= alloc_bottom.\n",
1246 RELOC(prom_memory_limit));
1247 RELOC(prom_memory_limit) = 0;
1248 } else if (RELOC(prom_memory_limit) >= RELOC(ram_top)) {
1249 prom_printf("Ignoring mem=%x >= ram_top.\n",
1250 RELOC(prom_memory_limit));
1251 RELOC(prom_memory_limit) = 0;
1252 } else {
1253 RELOC(ram_top) = RELOC(prom_memory_limit);
1254 RELOC(rmo_top) = min(RELOC(rmo_top), RELOC(prom_memory_limit));
1255 }
1256 }
1257
1258 /*
1259 * Setup our top alloc point, that is top of RMO or top of
1260 * segment 0 when running non-LPAR.
1261 * Some RS64 machines have buggy firmware where claims up at
1262 * 1GB fail. Cap at 768MB as a workaround.
1263 * Since 768MB is plenty of room, and we need to cap to something
1264 * reasonable on 32-bit, cap at 768MB on all machines.
1265 */
1266 if (!RELOC(rmo_top))
1267 RELOC(rmo_top) = RELOC(ram_top);
1268 RELOC(rmo_top) = min(0x30000000ul, RELOC(rmo_top));
1269 RELOC(alloc_top) = RELOC(rmo_top);
1270 RELOC(alloc_top_high) = RELOC(ram_top);
1271
1272 prom_printf("memory layout at init:\n");
1273 prom_printf(" memory_limit : %x (16 MB aligned)\n", RELOC(prom_memory_limit));
1274 prom_printf(" alloc_bottom : %x\n", RELOC(alloc_bottom));
1275 prom_printf(" alloc_top : %x\n", RELOC(alloc_top));
1276 prom_printf(" alloc_top_hi : %x\n", RELOC(alloc_top_high));
1277 prom_printf(" rmo_top : %x\n", RELOC(rmo_top));
1278 prom_printf(" ram_top : %x\n", RELOC(ram_top));
1279 }
1280
1281 static void __init prom_close_stdin(void)
1282 {
1283 struct prom_t *_prom = &RELOC(prom);
1284 ihandle val;
1285
1286 if (prom_getprop(_prom->chosen, "stdin", &val, sizeof(val)) > 0)
1287 call_prom("close", 1, 0, val);
1288 }
1289
1290 #ifdef CONFIG_PPC_POWERNV
1291
1292 static u64 __initdata prom_opal_size;
1293 static u64 __initdata prom_opal_align;
1294 static int __initdata prom_rtas_start_cpu;
1295 static u64 __initdata prom_rtas_data;
1296 static u64 __initdata prom_rtas_entry;
1297
1298 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
1299 static u64 __initdata prom_opal_base;
1300 static u64 __initdata prom_opal_entry;
1301 #endif
1302
1303 /* XXX Don't change this structure without updating opal-takeover.S */
1304 static struct opal_secondary_data {
1305 s64 ack; /* 0 */
1306 u64 go; /* 8 */
1307 struct opal_takeover_args args; /* 16 */
1308 } opal_secondary_data;
1309
1310 extern char opal_secondary_entry;
1311
1312 static void prom_query_opal(void)
1313 {
1314 long rc;
1315
1316 prom_printf("Querying for OPAL presence... ");
1317 rc = opal_query_takeover(&RELOC(prom_opal_size),
1318 &RELOC(prom_opal_align));
1319 prom_debug("(rc = %ld) ", rc);
1320 if (rc != 0) {
1321 prom_printf("not there.\n");
1322 return;
1323 }
1324 RELOC(of_platform) = PLATFORM_OPAL;
1325 prom_printf(" there !\n");
1326 prom_debug(" opal_size = 0x%lx\n", RELOC(prom_opal_size));
1327 prom_debug(" opal_align = 0x%lx\n", RELOC(prom_opal_align));
1328 if (RELOC(prom_opal_align) < 0x10000)
1329 RELOC(prom_opal_align) = 0x10000;
1330 }
1331
1332 static int prom_rtas_call(int token, int nargs, int nret, int *outputs, ...)
1333 {
1334 struct rtas_args rtas_args;
1335 va_list list;
1336 int i;
1337
1338 rtas_args.token = token;
1339 rtas_args.nargs = nargs;
1340 rtas_args.nret = nret;
1341 rtas_args.rets = (rtas_arg_t *)&(rtas_args.args[nargs]);
1342 va_start(list, outputs);
1343 for (i = 0; i < nargs; ++i)
1344 rtas_args.args[i] = va_arg(list, rtas_arg_t);
1345 va_end(list);
1346
1347 for (i = 0; i < nret; ++i)
1348 rtas_args.rets[i] = 0;
1349
1350 opal_enter_rtas(&rtas_args, RELOC(prom_rtas_data),
1351 RELOC(prom_rtas_entry));
1352
1353 if (nret > 1 && outputs != NULL)
1354 for (i = 0; i < nret-1; ++i)
1355 outputs[i] = rtas_args.rets[i+1];
1356 return (nret > 0)? rtas_args.rets[0]: 0;
1357 }
1358
1359 static void __init prom_opal_hold_cpus(void)
1360 {
1361 int i, cnt, cpu, rc;
1362 long j;
1363 phandle node;
1364 char type[64];
1365 u32 servers[8];
1366 struct prom_t *_prom = &RELOC(prom);
1367 void *entry = (unsigned long *)&RELOC(opal_secondary_entry);
1368 struct opal_secondary_data *data = &RELOC(opal_secondary_data);
1369
1370 prom_debug("prom_opal_hold_cpus: start...\n");
1371 prom_debug(" - entry = 0x%x\n", entry);
1372 prom_debug(" - data = 0x%x\n", data);
1373
1374 data->ack = -1;
1375 data->go = 0;
1376
1377 /* look for cpus */
1378 for (node = 0; prom_next_node(&node); ) {
1379 type[0] = 0;
1380 prom_getprop(node, "device_type", type, sizeof(type));
1381 if (strcmp(type, RELOC("cpu")) != 0)
1382 continue;
1383
1384 /* Skip non-configured cpus. */
1385 if (prom_getprop(node, "status", type, sizeof(type)) > 0)
1386 if (strcmp(type, RELOC("okay")) != 0)
1387 continue;
1388
1389 cnt = prom_getprop(node, "ibm,ppc-interrupt-server#s", servers,
1390 sizeof(servers));
1391 if (cnt == PROM_ERROR)
1392 break;
1393 cnt >>= 2;
1394 for (i = 0; i < cnt; i++) {
1395 cpu = servers[i];
1396 prom_debug("CPU %d ... ", cpu);
1397 if (cpu == _prom->cpu) {
1398 prom_debug("booted !\n");
1399 continue;
1400 }
1401 prom_debug("starting ... ");
1402
1403 /* Init the acknowledge var which will be reset by
1404 * the secondary cpu when it awakens from its OF
1405 * spinloop.
1406 */
1407 data->ack = -1;
1408 rc = prom_rtas_call(RELOC(prom_rtas_start_cpu), 3, 1,
1409 NULL, cpu, entry, data);
1410 prom_debug("rtas rc=%d ...", rc);
1411
1412 for (j = 0; j < 100000000 && data->ack == -1; j++) {
1413 HMT_low();
1414 mb();
1415 }
1416 HMT_medium();
1417 if (data->ack != -1)
1418 prom_debug("done, PIR=0x%x\n", data->ack);
1419 else
1420 prom_debug("timeout !\n");
1421 }
1422 }
1423 prom_debug("prom_opal_hold_cpus: end...\n");
1424 }
1425
1426 static void prom_opal_takeover(void)
1427 {
1428 struct opal_secondary_data *data = &RELOC(opal_secondary_data);
1429 struct opal_takeover_args *args = &data->args;
1430 u64 align = RELOC(prom_opal_align);
1431 u64 top_addr, opal_addr;
1432
1433 args->k_image = (u64)RELOC(_stext);
1434 args->k_size = _end - _stext;
1435 args->k_entry = 0;
1436 args->k_entry2 = 0x60;
1437
1438 top_addr = _ALIGN_UP(args->k_size, align);
1439
1440 if (RELOC(prom_initrd_start) != 0) {
1441 args->rd_image = RELOC(prom_initrd_start);
1442 args->rd_size = RELOC(prom_initrd_end) - args->rd_image;
1443 args->rd_loc = top_addr;
1444 top_addr = _ALIGN_UP(args->rd_loc + args->rd_size, align);
1445 }
1446
1447 /* Pickup an address for the HAL. We want to go really high
1448 * up to avoid problem with future kexecs. On the other hand
1449 * we don't want to be all over the TCEs on P5IOC2 machines
1450 * which are going to be up there too. We assume the machine
1451 * has plenty of memory, and we ask for the HAL for now to
1452 * be just below the 1G point, or above the initrd
1453 */
1454 opal_addr = _ALIGN_DOWN(0x40000000 - RELOC(prom_opal_size), align);
1455 if (opal_addr < top_addr)
1456 opal_addr = top_addr;
1457 args->hal_addr = opal_addr;
1458
1459 /* Copy the command line to the kernel image */
1460 strlcpy(RELOC(boot_command_line), RELOC(prom_cmd_line),
1461 COMMAND_LINE_SIZE);
1462
1463 prom_debug(" k_image = 0x%lx\n", args->k_image);
1464 prom_debug(" k_size = 0x%lx\n", args->k_size);
1465 prom_debug(" k_entry = 0x%lx\n", args->k_entry);
1466 prom_debug(" k_entry2 = 0x%lx\n", args->k_entry2);
1467 prom_debug(" hal_addr = 0x%lx\n", args->hal_addr);
1468 prom_debug(" rd_image = 0x%lx\n", args->rd_image);
1469 prom_debug(" rd_size = 0x%lx\n", args->rd_size);
1470 prom_debug(" rd_loc = 0x%lx\n", args->rd_loc);
1471 prom_printf("Performing OPAL takeover,this can take a few minutes..\n");
1472 prom_close_stdin();
1473 mb();
1474 data->go = 1;
1475 for (;;)
1476 opal_do_takeover(args);
1477 }
1478
1479 /*
1480 * Allocate room for and instantiate OPAL
1481 */
1482 static void __init prom_instantiate_opal(void)
1483 {
1484 phandle opal_node;
1485 ihandle opal_inst;
1486 u64 base, entry;
1487 u64 size = 0, align = 0x10000;
1488 u32 rets[2];
1489
1490 prom_debug("prom_instantiate_opal: start...\n");
1491
1492 opal_node = call_prom("finddevice", 1, 1, ADDR("/ibm,opal"));
1493 prom_debug("opal_node: %x\n", opal_node);
1494 if (!PHANDLE_VALID(opal_node))
1495 return;
1496
1497 prom_getprop(opal_node, "opal-runtime-size", &size, sizeof(size));
1498 if (size == 0)
1499 return;
1500 prom_getprop(opal_node, "opal-runtime-alignment", &align,
1501 sizeof(align));
1502
1503 base = alloc_down(size, align, 0);
1504 if (base == 0) {
1505 prom_printf("OPAL allocation failed !\n");
1506 return;
1507 }
1508
1509 opal_inst = call_prom("open", 1, 1, ADDR("/ibm,opal"));
1510 if (!IHANDLE_VALID(opal_inst)) {
1511 prom_printf("opening opal package failed (%x)\n", opal_inst);
1512 return;
1513 }
1514
1515 prom_printf("instantiating opal at 0x%x...", base);
1516
1517 if (call_prom_ret("call-method", 4, 3, rets,
1518 ADDR("load-opal-runtime"),
1519 opal_inst,
1520 base >> 32, base & 0xffffffff) != 0
1521 || (rets[0] == 0 && rets[1] == 0)) {
1522 prom_printf(" failed\n");
1523 return;
1524 }
1525 entry = (((u64)rets[0]) << 32) | rets[1];
1526
1527 prom_printf(" done\n");
1528
1529 reserve_mem(base, size);
1530
1531 prom_debug("opal base = 0x%x\n", base);
1532 prom_debug("opal align = 0x%x\n", align);
1533 prom_debug("opal entry = 0x%x\n", entry);
1534 prom_debug("opal size = 0x%x\n", (long)size);
1535
1536 prom_setprop(opal_node, "/ibm,opal", "opal-base-address",
1537 &base, sizeof(base));
1538 prom_setprop(opal_node, "/ibm,opal", "opal-entry-address",
1539 &entry, sizeof(entry));
1540
1541 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
1542 RELOC(prom_opal_base) = base;
1543 RELOC(prom_opal_entry) = entry;
1544 #endif
1545 prom_debug("prom_instantiate_opal: end...\n");
1546 }
1547
1548 #endif /* CONFIG_PPC_POWERNV */
1549
1550 /*
1551 * Allocate room for and instantiate RTAS
1552 */
1553 static void __init prom_instantiate_rtas(void)
1554 {
1555 phandle rtas_node;
1556 ihandle rtas_inst;
1557 u32 base, entry = 0;
1558 u32 size = 0;
1559
1560 prom_debug("prom_instantiate_rtas: start...\n");
1561
1562 rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1563 prom_debug("rtas_node: %x\n", rtas_node);
1564 if (!PHANDLE_VALID(rtas_node))
1565 return;
1566
1567 prom_getprop(rtas_node, "rtas-size", &size, sizeof(size));
1568 if (size == 0)
1569 return;
1570
1571 base = alloc_down(size, PAGE_SIZE, 0);
1572 if (base == 0) {
1573 prom_printf("RTAS allocation failed !\n");
1574 return;
1575 }
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 < 32; 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 if (l > MAX_PROPERTY_LENGTH) {
2268 prom_printf("WARNING: ignoring large property ");
2269 /* It seems OF doesn't null-terminate the path :-( */
2270 prom_printf("[%s] ", path);
2271 prom_printf("%s length 0x%x\n", RELOC(pname), l);
2272 continue;
2273 }
2274
2275 /* push property head */
2276 dt_push_token(OF_DT_PROP, mem_start, mem_end);
2277 dt_push_token(l, mem_start, mem_end);
2278 dt_push_token(soff, mem_start, mem_end);
2279
2280 /* push property content */
2281 valp = make_room(mem_start, mem_end, l, 4);
2282 call_prom("getprop", 4, 1, node, RELOC(pname), valp, l);
2283 *mem_start = _ALIGN(*mem_start, 4);
2284
2285 if (!strcmp(RELOC(pname), RELOC("phandle")))
2286 has_phandle = 1;
2287 }
2288
2289 /* Add a "linux,phandle" property if no "phandle" property already
2290 * existed (can happen with OPAL)
2291 */
2292 if (!has_phandle) {
2293 soff = dt_find_string(RELOC("linux,phandle"));
2294 if (soff == 0)
2295 prom_printf("WARNING: Can't find string index for"
2296 " <linux-phandle> node %s\n", path);
2297 else {
2298 dt_push_token(OF_DT_PROP, mem_start, mem_end);
2299 dt_push_token(4, mem_start, mem_end);
2300 dt_push_token(soff, mem_start, mem_end);
2301 valp = make_room(mem_start, mem_end, 4, 4);
2302 *(u32 *)valp = node;
2303 }
2304 }
2305
2306 /* do all our children */
2307 child = call_prom("child", 1, 1, node);
2308 while (child != 0) {
2309 scan_dt_build_struct(child, mem_start, mem_end);
2310 child = call_prom("peer", 1, 1, child);
2311 }
2312
2313 dt_push_token(OF_DT_END_NODE, mem_start, mem_end);
2314 }
2315
2316 static void __init flatten_device_tree(void)
2317 {
2318 phandle root;
2319 unsigned long mem_start, mem_end, room;
2320 struct boot_param_header *hdr;
2321 struct prom_t *_prom = &RELOC(prom);
2322 char *namep;
2323 u64 *rsvmap;
2324
2325 /*
2326 * Check how much room we have between alloc top & bottom (+/- a
2327 * few pages), crop to 1MB, as this is our "chunk" size
2328 */
2329 room = RELOC(alloc_top) - RELOC(alloc_bottom) - 0x4000;
2330 if (room > DEVTREE_CHUNK_SIZE)
2331 room = DEVTREE_CHUNK_SIZE;
2332 prom_debug("starting device tree allocs at %x\n", RELOC(alloc_bottom));
2333
2334 /* Now try to claim that */
2335 mem_start = (unsigned long)alloc_up(room, PAGE_SIZE);
2336 if (mem_start == 0)
2337 prom_panic("Can't allocate initial device-tree chunk\n");
2338 mem_end = mem_start + room;
2339
2340 /* Get root of tree */
2341 root = call_prom("peer", 1, 1, (phandle)0);
2342 if (root == (phandle)0)
2343 prom_panic ("couldn't get device tree root\n");
2344
2345 /* Build header and make room for mem rsv map */
2346 mem_start = _ALIGN(mem_start, 4);
2347 hdr = make_room(&mem_start, &mem_end,
2348 sizeof(struct boot_param_header), 4);
2349 RELOC(dt_header_start) = (unsigned long)hdr;
2350 rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8);
2351
2352 /* Start of strings */
2353 mem_start = PAGE_ALIGN(mem_start);
2354 RELOC(dt_string_start) = mem_start;
2355 mem_start += 4; /* hole */
2356
2357 /* Add "linux,phandle" in there, we'll need it */
2358 namep = make_room(&mem_start, &mem_end, 16, 1);
2359 strcpy(namep, RELOC("linux,phandle"));
2360 mem_start = (unsigned long)namep + strlen(namep) + 1;
2361
2362 /* Build string array */
2363 prom_printf("Building dt strings...\n");
2364 scan_dt_build_strings(root, &mem_start, &mem_end);
2365 RELOC(dt_string_end) = mem_start;
2366
2367 /* Build structure */
2368 mem_start = PAGE_ALIGN(mem_start);
2369 RELOC(dt_struct_start) = mem_start;
2370 prom_printf("Building dt structure...\n");
2371 scan_dt_build_struct(root, &mem_start, &mem_end);
2372 dt_push_token(OF_DT_END, &mem_start, &mem_end);
2373 RELOC(dt_struct_end) = PAGE_ALIGN(mem_start);
2374
2375 /* Finish header */
2376 hdr->boot_cpuid_phys = _prom->cpu;
2377 hdr->magic = OF_DT_HEADER;
2378 hdr->totalsize = RELOC(dt_struct_end) - RELOC(dt_header_start);
2379 hdr->off_dt_struct = RELOC(dt_struct_start) - RELOC(dt_header_start);
2380 hdr->off_dt_strings = RELOC(dt_string_start) - RELOC(dt_header_start);
2381 hdr->dt_strings_size = RELOC(dt_string_end) - RELOC(dt_string_start);
2382 hdr->off_mem_rsvmap = ((unsigned long)rsvmap) - RELOC(dt_header_start);
2383 hdr->version = OF_DT_VERSION;
2384 /* Version 16 is not backward compatible */
2385 hdr->last_comp_version = 0x10;
2386
2387 /* Copy the reserve map in */
2388 memcpy(rsvmap, RELOC(mem_reserve_map), sizeof(mem_reserve_map));
2389
2390 #ifdef DEBUG_PROM
2391 {
2392 int i;
2393 prom_printf("reserved memory map:\n");
2394 for (i = 0; i < RELOC(mem_reserve_cnt); i++)
2395 prom_printf(" %x - %x\n",
2396 RELOC(mem_reserve_map)[i].base,
2397 RELOC(mem_reserve_map)[i].size);
2398 }
2399 #endif
2400 /* Bump mem_reserve_cnt to cause further reservations to fail
2401 * since it's too late.
2402 */
2403 RELOC(mem_reserve_cnt) = MEM_RESERVE_MAP_SIZE;
2404
2405 prom_printf("Device tree strings 0x%x -> 0x%x\n",
2406 RELOC(dt_string_start), RELOC(dt_string_end));
2407 prom_printf("Device tree struct 0x%x -> 0x%x\n",
2408 RELOC(dt_struct_start), RELOC(dt_struct_end));
2409
2410 }
2411
2412 #ifdef CONFIG_PPC_MAPLE
2413 /* PIBS Version 1.05.0000 04/26/2005 has an incorrect /ht/isa/ranges property.
2414 * The values are bad, and it doesn't even have the right number of cells. */
2415 static void __init fixup_device_tree_maple(void)
2416 {
2417 phandle isa;
2418 u32 rloc = 0x01002000; /* IO space; PCI device = 4 */
2419 u32 isa_ranges[6];
2420 char *name;
2421
2422 name = "/ht@0/isa@4";
2423 isa = call_prom("finddevice", 1, 1, ADDR(name));
2424 if (!PHANDLE_VALID(isa)) {
2425 name = "/ht@0/isa@6";
2426 isa = call_prom("finddevice", 1, 1, ADDR(name));
2427 rloc = 0x01003000; /* IO space; PCI device = 6 */
2428 }
2429 if (!PHANDLE_VALID(isa))
2430 return;
2431
2432 if (prom_getproplen(isa, "ranges") != 12)
2433 return;
2434 if (prom_getprop(isa, "ranges", isa_ranges, sizeof(isa_ranges))
2435 == PROM_ERROR)
2436 return;
2437
2438 if (isa_ranges[0] != 0x1 ||
2439 isa_ranges[1] != 0xf4000000 ||
2440 isa_ranges[2] != 0x00010000)
2441 return;
2442
2443 prom_printf("Fixing up bogus ISA range on Maple/Apache...\n");
2444
2445 isa_ranges[0] = 0x1;
2446 isa_ranges[1] = 0x0;
2447 isa_ranges[2] = rloc;
2448 isa_ranges[3] = 0x0;
2449 isa_ranges[4] = 0x0;
2450 isa_ranges[5] = 0x00010000;
2451 prom_setprop(isa, name, "ranges",
2452 isa_ranges, sizeof(isa_ranges));
2453 }
2454
2455 #define CPC925_MC_START 0xf8000000
2456 #define CPC925_MC_LENGTH 0x1000000
2457 /* The values for memory-controller don't have right number of cells */
2458 static void __init fixup_device_tree_maple_memory_controller(void)
2459 {
2460 phandle mc;
2461 u32 mc_reg[4];
2462 char *name = "/hostbridge@f8000000";
2463 struct prom_t *_prom = &RELOC(prom);
2464 u32 ac, sc;
2465
2466 mc = call_prom("finddevice", 1, 1, ADDR(name));
2467 if (!PHANDLE_VALID(mc))
2468 return;
2469
2470 if (prom_getproplen(mc, "reg") != 8)
2471 return;
2472
2473 prom_getprop(_prom->root, "#address-cells", &ac, sizeof(ac));
2474 prom_getprop(_prom->root, "#size-cells", &sc, sizeof(sc));
2475 if ((ac != 2) || (sc != 2))
2476 return;
2477
2478 if (prom_getprop(mc, "reg", mc_reg, sizeof(mc_reg)) == PROM_ERROR)
2479 return;
2480
2481 if (mc_reg[0] != CPC925_MC_START || mc_reg[1] != CPC925_MC_LENGTH)
2482 return;
2483
2484 prom_printf("Fixing up bogus hostbridge on Maple...\n");
2485
2486 mc_reg[0] = 0x0;
2487 mc_reg[1] = CPC925_MC_START;
2488 mc_reg[2] = 0x0;
2489 mc_reg[3] = CPC925_MC_LENGTH;
2490 prom_setprop(mc, name, "reg", mc_reg, sizeof(mc_reg));
2491 }
2492 #else
2493 #define fixup_device_tree_maple()
2494 #define fixup_device_tree_maple_memory_controller()
2495 #endif
2496
2497 #ifdef CONFIG_PPC_CHRP
2498 /*
2499 * Pegasos and BriQ lacks the "ranges" property in the isa node
2500 * Pegasos needs decimal IRQ 14/15, not hexadecimal
2501 * Pegasos has the IDE configured in legacy mode, but advertised as native
2502 */
2503 static void __init fixup_device_tree_chrp(void)
2504 {
2505 phandle ph;
2506 u32 prop[6];
2507 u32 rloc = 0x01006000; /* IO space; PCI device = 12 */
2508 char *name;
2509 int rc;
2510
2511 name = "/pci@80000000/isa@c";
2512 ph = call_prom("finddevice", 1, 1, ADDR(name));
2513 if (!PHANDLE_VALID(ph)) {
2514 name = "/pci@ff500000/isa@6";
2515 ph = call_prom("finddevice", 1, 1, ADDR(name));
2516 rloc = 0x01003000; /* IO space; PCI device = 6 */
2517 }
2518 if (PHANDLE_VALID(ph)) {
2519 rc = prom_getproplen(ph, "ranges");
2520 if (rc == 0 || rc == PROM_ERROR) {
2521 prom_printf("Fixing up missing ISA range on Pegasos...\n");
2522
2523 prop[0] = 0x1;
2524 prop[1] = 0x0;
2525 prop[2] = rloc;
2526 prop[3] = 0x0;
2527 prop[4] = 0x0;
2528 prop[5] = 0x00010000;
2529 prom_setprop(ph, name, "ranges", prop, sizeof(prop));
2530 }
2531 }
2532
2533 name = "/pci@80000000/ide@C,1";
2534 ph = call_prom("finddevice", 1, 1, ADDR(name));
2535 if (PHANDLE_VALID(ph)) {
2536 prom_printf("Fixing up IDE interrupt on Pegasos...\n");
2537 prop[0] = 14;
2538 prop[1] = 0x0;
2539 prom_setprop(ph, name, "interrupts", prop, 2*sizeof(u32));
2540 prom_printf("Fixing up IDE class-code on Pegasos...\n");
2541 rc = prom_getprop(ph, "class-code", prop, sizeof(u32));
2542 if (rc == sizeof(u32)) {
2543 prop[0] &= ~0x5;
2544 prom_setprop(ph, name, "class-code", prop, sizeof(u32));
2545 }
2546 }
2547 }
2548 #else
2549 #define fixup_device_tree_chrp()
2550 #endif
2551
2552 #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC)
2553 static void __init fixup_device_tree_pmac(void)
2554 {
2555 phandle u3, i2c, mpic;
2556 u32 u3_rev;
2557 u32 interrupts[2];
2558 u32 parent;
2559
2560 /* Some G5s have a missing interrupt definition, fix it up here */
2561 u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000"));
2562 if (!PHANDLE_VALID(u3))
2563 return;
2564 i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000"));
2565 if (!PHANDLE_VALID(i2c))
2566 return;
2567 mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000"));
2568 if (!PHANDLE_VALID(mpic))
2569 return;
2570
2571 /* check if proper rev of u3 */
2572 if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev))
2573 == PROM_ERROR)
2574 return;
2575 if (u3_rev < 0x35 || u3_rev > 0x39)
2576 return;
2577 /* does it need fixup ? */
2578 if (prom_getproplen(i2c, "interrupts") > 0)
2579 return;
2580
2581 prom_printf("fixing up bogus interrupts for u3 i2c...\n");
2582
2583 /* interrupt on this revision of u3 is number 0 and level */
2584 interrupts[0] = 0;
2585 interrupts[1] = 1;
2586 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts",
2587 &interrupts, sizeof(interrupts));
2588 parent = (u32)mpic;
2589 prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent",
2590 &parent, sizeof(parent));
2591 }
2592 #else
2593 #define fixup_device_tree_pmac()
2594 #endif
2595
2596 #ifdef CONFIG_PPC_EFIKA
2597 /*
2598 * The MPC5200 FEC driver requires an phy-handle property to tell it how
2599 * to talk to the phy. If the phy-handle property is missing, then this
2600 * function is called to add the appropriate nodes and link it to the
2601 * ethernet node.
2602 */
2603 static void __init fixup_device_tree_efika_add_phy(void)
2604 {
2605 u32 node;
2606 char prop[64];
2607 int rv;
2608
2609 /* Check if /builtin/ethernet exists - bail if it doesn't */
2610 node = call_prom("finddevice", 1, 1, ADDR("/builtin/ethernet"));
2611 if (!PHANDLE_VALID(node))
2612 return;
2613
2614 /* Check if the phy-handle property exists - bail if it does */
2615 rv = prom_getprop(node, "phy-handle", prop, sizeof(prop));
2616 if (!rv)
2617 return;
2618
2619 /*
2620 * At this point the ethernet device doesn't have a phy described.
2621 * Now we need to add the missing phy node and linkage
2622 */
2623
2624 /* Check for an MDIO bus node - if missing then create one */
2625 node = call_prom("finddevice", 1, 1, ADDR("/builtin/mdio"));
2626 if (!PHANDLE_VALID(node)) {
2627 prom_printf("Adding Ethernet MDIO node\n");
2628 call_prom("interpret", 1, 1,
2629 " s\" /builtin\" find-device"
2630 " new-device"
2631 " 1 encode-int s\" #address-cells\" property"
2632 " 0 encode-int s\" #size-cells\" property"
2633 " s\" mdio\" device-name"
2634 " s\" fsl,mpc5200b-mdio\" encode-string"
2635 " s\" compatible\" property"
2636 " 0xf0003000 0x400 reg"
2637 " 0x2 encode-int"
2638 " 0x5 encode-int encode+"
2639 " 0x3 encode-int encode+"
2640 " s\" interrupts\" property"
2641 " finish-device");
2642 };
2643
2644 /* Check for a PHY device node - if missing then create one and
2645 * give it's phandle to the ethernet node */
2646 node = call_prom("finddevice", 1, 1,
2647 ADDR("/builtin/mdio/ethernet-phy"));
2648 if (!PHANDLE_VALID(node)) {
2649 prom_printf("Adding Ethernet PHY node\n");
2650 call_prom("interpret", 1, 1,
2651 " s\" /builtin/mdio\" find-device"
2652 " new-device"
2653 " s\" ethernet-phy\" device-name"
2654 " 0x10 encode-int s\" reg\" property"
2655 " my-self"
2656 " ihandle>phandle"
2657 " finish-device"
2658 " s\" /builtin/ethernet\" find-device"
2659 " encode-int"
2660 " s\" phy-handle\" property"
2661 " device-end");
2662 }
2663 }
2664
2665 static void __init fixup_device_tree_efika(void)
2666 {
2667 int sound_irq[3] = { 2, 2, 0 };
2668 int bcomm_irq[3*16] = { 3,0,0, 3,1,0, 3,2,0, 3,3,0,
2669 3,4,0, 3,5,0, 3,6,0, 3,7,0,
2670 3,8,0, 3,9,0, 3,10,0, 3,11,0,
2671 3,12,0, 3,13,0, 3,14,0, 3,15,0 };
2672 u32 node;
2673 char prop[64];
2674 int rv, len;
2675
2676 /* Check if we're really running on a EFIKA */
2677 node = call_prom("finddevice", 1, 1, ADDR("/"));
2678 if (!PHANDLE_VALID(node))
2679 return;
2680
2681 rv = prom_getprop(node, "model", prop, sizeof(prop));
2682 if (rv == PROM_ERROR)
2683 return;
2684 if (strcmp(prop, "EFIKA5K2"))
2685 return;
2686
2687 prom_printf("Applying EFIKA device tree fixups\n");
2688
2689 /* Claiming to be 'chrp' is death */
2690 node = call_prom("finddevice", 1, 1, ADDR("/"));
2691 rv = prom_getprop(node, "device_type", prop, sizeof(prop));
2692 if (rv != PROM_ERROR && (strcmp(prop, "chrp") == 0))
2693 prom_setprop(node, "/", "device_type", "efika", sizeof("efika"));
2694
2695 /* CODEGEN,description is exposed in /proc/cpuinfo so
2696 fix that too */
2697 rv = prom_getprop(node, "CODEGEN,description", prop, sizeof(prop));
2698 if (rv != PROM_ERROR && (strstr(prop, "CHRP")))
2699 prom_setprop(node, "/", "CODEGEN,description",
2700 "Efika 5200B PowerPC System",
2701 sizeof("Efika 5200B PowerPC System"));
2702
2703 /* Fixup bestcomm interrupts property */
2704 node = call_prom("finddevice", 1, 1, ADDR("/builtin/bestcomm"));
2705 if (PHANDLE_VALID(node)) {
2706 len = prom_getproplen(node, "interrupts");
2707 if (len == 12) {
2708 prom_printf("Fixing bestcomm interrupts property\n");
2709 prom_setprop(node, "/builtin/bestcom", "interrupts",
2710 bcomm_irq, sizeof(bcomm_irq));
2711 }
2712 }
2713
2714 /* Fixup sound interrupts property */
2715 node = call_prom("finddevice", 1, 1, ADDR("/builtin/sound"));
2716 if (PHANDLE_VALID(node)) {
2717 rv = prom_getprop(node, "interrupts", prop, sizeof(prop));
2718 if (rv == PROM_ERROR) {
2719 prom_printf("Adding sound interrupts property\n");
2720 prom_setprop(node, "/builtin/sound", "interrupts",
2721 sound_irq, sizeof(sound_irq));
2722 }
2723 }
2724
2725 /* Make sure ethernet phy-handle property exists */
2726 fixup_device_tree_efika_add_phy();
2727 }
2728 #else
2729 #define fixup_device_tree_efika()
2730 #endif
2731
2732 static void __init fixup_device_tree(void)
2733 {
2734 fixup_device_tree_maple();
2735 fixup_device_tree_maple_memory_controller();
2736 fixup_device_tree_chrp();
2737 fixup_device_tree_pmac();
2738 fixup_device_tree_efika();
2739 }
2740
2741 static void __init prom_find_boot_cpu(void)
2742 {
2743 struct prom_t *_prom = &RELOC(prom);
2744 u32 getprop_rval;
2745 ihandle prom_cpu;
2746 phandle cpu_pkg;
2747
2748 _prom->cpu = 0;
2749 if (prom_getprop(_prom->chosen, "cpu", &prom_cpu, sizeof(prom_cpu)) <= 0)
2750 return;
2751
2752 cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
2753
2754 prom_getprop(cpu_pkg, "reg", &getprop_rval, sizeof(getprop_rval));
2755 _prom->cpu = getprop_rval;
2756
2757 prom_debug("Booting CPU hw index = %lu\n", _prom->cpu);
2758 }
2759
2760 static void __init prom_check_initrd(unsigned long r3, unsigned long r4)
2761 {
2762 #ifdef CONFIG_BLK_DEV_INITRD
2763 struct prom_t *_prom = &RELOC(prom);
2764
2765 if (r3 && r4 && r4 != 0xdeadbeef) {
2766 unsigned long val;
2767
2768 RELOC(prom_initrd_start) = is_kernel_addr(r3) ? __pa(r3) : r3;
2769 RELOC(prom_initrd_end) = RELOC(prom_initrd_start) + r4;
2770
2771 val = RELOC(prom_initrd_start);
2772 prom_setprop(_prom->chosen, "/chosen", "linux,initrd-start",
2773 &val, sizeof(val));
2774 val = RELOC(prom_initrd_end);
2775 prom_setprop(_prom->chosen, "/chosen", "linux,initrd-end",
2776 &val, sizeof(val));
2777
2778 reserve_mem(RELOC(prom_initrd_start),
2779 RELOC(prom_initrd_end) - RELOC(prom_initrd_start));
2780
2781 prom_debug("initrd_start=0x%x\n", RELOC(prom_initrd_start));
2782 prom_debug("initrd_end=0x%x\n", RELOC(prom_initrd_end));
2783 }
2784 #endif /* CONFIG_BLK_DEV_INITRD */
2785 }
2786
2787
2788 /*
2789 * We enter here early on, when the Open Firmware prom is still
2790 * handling exceptions and the MMU hash table for us.
2791 */
2792
2793 unsigned long __init prom_init(unsigned long r3, unsigned long r4,
2794 unsigned long pp,
2795 unsigned long r6, unsigned long r7,
2796 unsigned long kbase)
2797 {
2798 struct prom_t *_prom;
2799 unsigned long hdr;
2800
2801 #ifdef CONFIG_PPC32
2802 unsigned long offset = reloc_offset();
2803 reloc_got2(offset);
2804 #endif
2805
2806 _prom = &RELOC(prom);
2807
2808 /*
2809 * First zero the BSS
2810 */
2811 memset(&RELOC(__bss_start), 0, __bss_stop - __bss_start);
2812
2813 /*
2814 * Init interface to Open Firmware, get some node references,
2815 * like /chosen
2816 */
2817 prom_init_client_services(pp);
2818
2819 /*
2820 * See if this OF is old enough that we need to do explicit maps
2821 * and other workarounds
2822 */
2823 prom_find_mmu();
2824
2825 /*
2826 * Init prom stdout device
2827 */
2828 prom_init_stdout();
2829
2830 prom_printf("Preparing to boot %s", RELOC(linux_banner));
2831
2832 /*
2833 * Get default machine type. At this point, we do not differentiate
2834 * between pSeries SMP and pSeries LPAR
2835 */
2836 RELOC(of_platform) = prom_find_machine_type();
2837 prom_printf("Detected machine type: %x\n", RELOC(of_platform));
2838
2839 #ifndef CONFIG_RELOCATABLE
2840 /* Bail if this is a kdump kernel. */
2841 if (PHYSICAL_START > 0)
2842 prom_panic("Error: You can't boot a kdump kernel from OF!\n");
2843 #endif
2844
2845 /*
2846 * Check for an initrd
2847 */
2848 prom_check_initrd(r3, r4);
2849
2850 #if defined(CONFIG_PPC_PSERIES) || defined(CONFIG_PPC_POWERNV)
2851 /*
2852 * On pSeries, inform the firmware about our capabilities
2853 */
2854 if (RELOC(of_platform) == PLATFORM_PSERIES ||
2855 RELOC(of_platform) == PLATFORM_PSERIES_LPAR)
2856 prom_send_capabilities();
2857 #endif
2858
2859 /*
2860 * Copy the CPU hold code
2861 */
2862 if (RELOC(of_platform) != PLATFORM_POWERMAC)
2863 copy_and_flush(0, kbase, 0x100, 0);
2864
2865 /*
2866 * Do early parsing of command line
2867 */
2868 early_cmdline_parse();
2869
2870 /*
2871 * Initialize memory management within prom_init
2872 */
2873 prom_init_mem();
2874
2875 /*
2876 * Determine which cpu is actually running right _now_
2877 */
2878 prom_find_boot_cpu();
2879
2880 /*
2881 * Initialize display devices
2882 */
2883 prom_check_displays();
2884
2885 #ifdef CONFIG_PPC64
2886 /*
2887 * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else
2888 * that uses the allocator, we need to make sure we get the top of memory
2889 * available for us here...
2890 */
2891 if (RELOC(of_platform) == PLATFORM_PSERIES)
2892 prom_initialize_tce_table();
2893 #endif
2894
2895 /*
2896 * On non-powermacs, try to instantiate RTAS. PowerMacs don't
2897 * have a usable RTAS implementation.
2898 */
2899 if (RELOC(of_platform) != PLATFORM_POWERMAC &&
2900 RELOC(of_platform) != PLATFORM_OPAL)
2901 prom_instantiate_rtas();
2902
2903 #ifdef CONFIG_PPC_POWERNV
2904 /* Detect HAL and try instanciating it & doing takeover */
2905 if (RELOC(of_platform) == PLATFORM_PSERIES_LPAR) {
2906 prom_query_opal();
2907 if (RELOC(of_platform) == PLATFORM_OPAL) {
2908 prom_opal_hold_cpus();
2909 prom_opal_takeover();
2910 }
2911 } else if (RELOC(of_platform) == PLATFORM_OPAL)
2912 prom_instantiate_opal();
2913 #endif
2914
2915 /*
2916 * On non-powermacs, put all CPUs in spin-loops.
2917 *
2918 * PowerMacs use a different mechanism to spin CPUs
2919 */
2920 if (RELOC(of_platform) != PLATFORM_POWERMAC &&
2921 RELOC(of_platform) != PLATFORM_OPAL)
2922 prom_hold_cpus();
2923
2924 /*
2925 * Fill in some infos for use by the kernel later on
2926 */
2927 if (RELOC(prom_memory_limit))
2928 prom_setprop(_prom->chosen, "/chosen", "linux,memory-limit",
2929 &RELOC(prom_memory_limit),
2930 sizeof(prom_memory_limit));
2931 #ifdef CONFIG_PPC64
2932 if (RELOC(prom_iommu_off))
2933 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-off",
2934 NULL, 0);
2935
2936 if (RELOC(prom_iommu_force_on))
2937 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-force-on",
2938 NULL, 0);
2939
2940 if (RELOC(prom_tce_alloc_start)) {
2941 prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-start",
2942 &RELOC(prom_tce_alloc_start),
2943 sizeof(prom_tce_alloc_start));
2944 prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-end",
2945 &RELOC(prom_tce_alloc_end),
2946 sizeof(prom_tce_alloc_end));
2947 }
2948 #endif
2949
2950 /*
2951 * Fixup any known bugs in the device-tree
2952 */
2953 fixup_device_tree();
2954
2955 /*
2956 * Now finally create the flattened device-tree
2957 */
2958 prom_printf("copying OF device tree...\n");
2959 flatten_device_tree();
2960
2961 /*
2962 * in case stdin is USB and still active on IBM machines...
2963 * Unfortunately quiesce crashes on some powermacs if we have
2964 * closed stdin already (in particular the powerbook 101).
2965 */
2966 if (RELOC(of_platform) != PLATFORM_POWERMAC)
2967 prom_close_stdin();
2968
2969 /*
2970 * Call OF "quiesce" method to shut down pending DMA's from
2971 * devices etc...
2972 */
2973 prom_printf("Calling quiesce...\n");
2974 call_prom("quiesce", 0, 0);
2975
2976 /*
2977 * And finally, call the kernel passing it the flattened device
2978 * tree and NULL as r5, thus triggering the new entry point which
2979 * is common to us and kexec
2980 */
2981 hdr = RELOC(dt_header_start);
2982 prom_printf("returning from prom_init\n");
2983 prom_debug("->dt_header_start=0x%x\n", hdr);
2984
2985 #ifdef CONFIG_PPC32
2986 reloc_got2(-offset);
2987 #endif
2988
2989 #ifdef CONFIG_PPC_EARLY_DEBUG_OPAL
2990 /* OPAL early debug gets the OPAL base & entry in r8 and r9 */
2991 __start(hdr, kbase, 0, 0, 0,
2992 RELOC(prom_opal_base), RELOC(prom_opal_entry));
2993 #else
2994 __start(hdr, kbase, 0, 0, 0, 0, 0);
2995 #endif
2996
2997 return 0;
2998 }
Linux kernel - Deliverables
This page took 0.091729 seconds and 4 git commands to generate.