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