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