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