Merge master.kernel.org:/pub/scm/linux/kernel/git/wim/linux-2.6-watchdog
[linux-2.6] / arch / powerpc / kernel / prom_init.c
1 /*
2  * Procedures for interfacing to Open Firmware.
3  *
4  * Paul Mackerras       August 1996.
5  * Copyright (C) 1996-2005 Paul Mackerras.
6  * 
7  *  Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
8  *    {engebret|bergner}@us.ibm.com 
9  *
10  *      This program is free software; you can redistribute it and/or
11  *      modify it under the terms of the GNU General Public License
12  *      as published by the Free Software Foundation; either version
13  *      2 of the License, or (at your option) any later version.
14  */
15
16 #undef DEBUG_PROM
17
18 #include <stdarg.h>
19 #include <linux/config.h>
20 #include <linux/kernel.h>
21 #include <linux/string.h>
22 #include <linux/init.h>
23 #include <linux/threads.h>
24 #include <linux/spinlock.h>
25 #include <linux/types.h>
26 #include <linux/pci.h>
27 #include <linux/proc_fs.h>
28 #include <linux/stringify.h>
29 #include <linux/delay.h>
30 #include <linux/initrd.h>
31 #include <linux/bitops.h>
32 #include <asm/prom.h>
33 #include <asm/rtas.h>
34 #include <asm/page.h>
35 #include <asm/processor.h>
36 #include <asm/irq.h>
37 #include <asm/io.h>
38 #include <asm/smp.h>
39 #include <asm/system.h>
40 #include <asm/mmu.h>
41 #include <asm/pgtable.h>
42 #include <asm/pci.h>
43 #include <asm/iommu.h>
44 #include <asm/btext.h>
45 #include <asm/sections.h>
46 #include <asm/machdep.h>
47
48 #ifdef CONFIG_LOGO_LINUX_CLUT224
49 #include <linux/linux_logo.h>
50 extern const struct linux_logo logo_linux_clut224;
51 #endif
52
53 /*
54  * Properties whose value is longer than this get excluded from our
55  * copy of the device tree. This value does need to be big enough to
56  * ensure that we don't lose things like the interrupt-map property
57  * on a PCI-PCI bridge.
58  */
59 #define MAX_PROPERTY_LENGTH     (1UL * 1024 * 1024)
60
61 /*
62  * Eventually bump that one up
63  */
64 #define DEVTREE_CHUNK_SIZE      0x100000
65
66 /*
67  * This is the size of the local memory reserve map that gets copied
68  * into the boot params passed to the kernel. That size is totally
69  * flexible as the kernel just reads the list until it encounters an
70  * entry with size 0, so it can be changed without breaking binary
71  * compatibility
72  */
73 #define MEM_RESERVE_MAP_SIZE    8
74
75 /*
76  * prom_init() is called very early on, before the kernel text
77  * and data have been mapped to KERNELBASE.  At this point the code
78  * is running at whatever address it has been loaded at.
79  * On ppc32 we compile with -mrelocatable, which means that references
80  * to extern and static variables get relocated automatically.
81  * On ppc64 we have to relocate the references explicitly with
82  * RELOC.  (Note that strings count as static variables.)
83  *
84  * Because OF may have mapped I/O devices into the area starting at
85  * KERNELBASE, particularly on CHRP machines, we can't safely call
86  * OF once the kernel has been mapped to KERNELBASE.  Therefore all
87  * OF calls must be done within prom_init().
88  *
89  * ADDR is used in calls to call_prom.  The 4th and following
90  * arguments to call_prom should be 32-bit values.
91  * On ppc64, 64 bit values are truncated to 32 bits (and
92  * fortunately don't get interpreted as two arguments).
93  */
94 #ifdef CONFIG_PPC64
95 #define RELOC(x)        (*PTRRELOC(&(x)))
96 #define ADDR(x)         (u32) add_reloc_offset((unsigned long)(x))
97 #define OF_WORKAROUNDS  0
98 #else
99 #define RELOC(x)        (x)
100 #define ADDR(x)         (u32) (x)
101 #define OF_WORKAROUNDS  of_workarounds
102 int of_workarounds;
103 #endif
104
105 #define OF_WA_CLAIM     1       /* do phys/virt claim separately, then map */
106 #define OF_WA_LONGTRAIL 2       /* work around longtrail bugs */
107
108 #define PROM_BUG() do {                                         \
109         prom_printf("kernel BUG at %s line 0x%x!\n",            \
110                     RELOC(__FILE__), __LINE__);                 \
111         __asm__ __volatile__(".long " BUG_ILLEGAL_INSTR);       \
112 } while (0)
113
114 #ifdef DEBUG_PROM
115 #define prom_debug(x...)        prom_printf(x)
116 #else
117 #define prom_debug(x...)
118 #endif
119
120
121 typedef u32 prom_arg_t;
122
123 struct prom_args {
124         u32 service;
125         u32 nargs;
126         u32 nret;
127         prom_arg_t args[10];
128 };
129
130 struct prom_t {
131         ihandle root;
132         phandle chosen;
133         int cpu;
134         ihandle stdout;
135         ihandle mmumap;
136         ihandle memory;
137 };
138
139 struct mem_map_entry {
140         u64     base;
141         u64     size;
142 };
143
144 typedef u32 cell_t;
145
146 extern void __start(unsigned long r3, unsigned long r4, unsigned long r5);
147
148 #ifdef CONFIG_PPC64
149 extern int enter_prom(struct prom_args *args, unsigned long entry);
150 #else
151 static inline int enter_prom(struct prom_args *args, unsigned long entry)
152 {
153         return ((int (*)(struct prom_args *))entry)(args);
154 }
155 #endif
156
157 extern void copy_and_flush(unsigned long dest, unsigned long src,
158                            unsigned long size, unsigned long offset);
159
160 /* prom structure */
161 static struct prom_t __initdata prom;
162
163 static unsigned long prom_entry __initdata;
164
165 #define PROM_SCRATCH_SIZE 256
166
167 static char __initdata of_stdout_device[256];
168 static char __initdata prom_scratch[PROM_SCRATCH_SIZE];
169
170 static unsigned long __initdata dt_header_start;
171 static unsigned long __initdata dt_struct_start, dt_struct_end;
172 static unsigned long __initdata dt_string_start, dt_string_end;
173
174 static unsigned long __initdata prom_initrd_start, prom_initrd_end;
175
176 #ifdef CONFIG_PPC64
177 static int __initdata iommu_force_on;
178 static int __initdata ppc64_iommu_off;
179 static unsigned long __initdata prom_tce_alloc_start;
180 static unsigned long __initdata prom_tce_alloc_end;
181 #endif
182
183 /* Platforms codes are now obsolete in the kernel. Now only used within this
184  * file and ultimately gone too. Feel free to change them if you need, they
185  * are not shared with anything outside of this file anymore
186  */
187 #define PLATFORM_PSERIES        0x0100
188 #define PLATFORM_PSERIES_LPAR   0x0101
189 #define PLATFORM_LPAR           0x0001
190 #define PLATFORM_POWERMAC       0x0400
191 #define PLATFORM_GENERIC        0x0500
192
193 static int __initdata of_platform;
194
195 static char __initdata prom_cmd_line[COMMAND_LINE_SIZE];
196
197 static unsigned long __initdata prom_memory_limit;
198
199 static unsigned long __initdata alloc_top;
200 static unsigned long __initdata alloc_top_high;
201 static unsigned long __initdata alloc_bottom;
202 static unsigned long __initdata rmo_top;
203 static unsigned long __initdata ram_top;
204
205 #ifdef CONFIG_KEXEC
206 static unsigned long __initdata prom_crashk_base;
207 static unsigned long __initdata prom_crashk_size;
208 #endif
209
210 static struct mem_map_entry __initdata mem_reserve_map[MEM_RESERVE_MAP_SIZE];
211 static int __initdata mem_reserve_cnt;
212
213 static cell_t __initdata regbuf[1024];
214
215
216 #define MAX_CPU_THREADS 2
217
218 /*
219  * Error results ... some OF calls will return "-1" on error, some
220  * will return 0, some will return either. To simplify, here are
221  * macros to use with any ihandle or phandle return value to check if
222  * it is valid
223  */
224
225 #define PROM_ERROR              (-1u)
226 #define PHANDLE_VALID(p)        ((p) != 0 && (p) != PROM_ERROR)
227 #define IHANDLE_VALID(i)        ((i) != 0 && (i) != PROM_ERROR)
228
229
230 /* This is the one and *ONLY* place where we actually call open
231  * firmware.
232  */
233
234 static int __init call_prom(const char *service, int nargs, int nret, ...)
235 {
236         int i;
237         struct prom_args args;
238         va_list list;
239
240         args.service = ADDR(service);
241         args.nargs = nargs;
242         args.nret = nret;
243
244         va_start(list, nret);
245         for (i = 0; i < nargs; i++)
246                 args.args[i] = va_arg(list, prom_arg_t);
247         va_end(list);
248
249         for (i = 0; i < nret; i++)
250                 args.args[nargs+i] = 0;
251
252         if (enter_prom(&args, RELOC(prom_entry)) < 0)
253                 return PROM_ERROR;
254
255         return (nret > 0) ? args.args[nargs] : 0;
256 }
257
258 static int __init call_prom_ret(const char *service, int nargs, int nret,
259                                 prom_arg_t *rets, ...)
260 {
261         int i;
262         struct prom_args args;
263         va_list list;
264
265         args.service = ADDR(service);
266         args.nargs = nargs;
267         args.nret = nret;
268
269         va_start(list, rets);
270         for (i = 0; i < nargs; i++)
271                 args.args[i] = va_arg(list, prom_arg_t);
272         va_end(list);
273
274         for (i = 0; i < nret; i++)
275                 args.args[nargs+i] = 0;
276
277         if (enter_prom(&args, RELOC(prom_entry)) < 0)
278                 return PROM_ERROR;
279
280         if (rets != NULL)
281                 for (i = 1; i < nret; ++i)
282                         rets[i-1] = args.args[nargs+i];
283
284         return (nret > 0) ? args.args[nargs] : 0;
285 }
286
287
288 static void __init prom_print(const char *msg)
289 {
290         const char *p, *q;
291         struct prom_t *_prom = &RELOC(prom);
292
293         if (_prom->stdout == 0)
294                 return;
295
296         for (p = msg; *p != 0; p = q) {
297                 for (q = p; *q != 0 && *q != '\n'; ++q)
298                         ;
299                 if (q > p)
300                         call_prom("write", 3, 1, _prom->stdout, p, q - p);
301                 if (*q == 0)
302                         break;
303                 ++q;
304                 call_prom("write", 3, 1, _prom->stdout, ADDR("\r\n"), 2);
305         }
306 }
307
308
309 static void __init prom_print_hex(unsigned long val)
310 {
311         int i, nibbles = sizeof(val)*2;
312         char buf[sizeof(val)*2+1];
313         struct prom_t *_prom = &RELOC(prom);
314
315         for (i = nibbles-1;  i >= 0;  i--) {
316                 buf[i] = (val & 0xf) + '0';
317                 if (buf[i] > '9')
318                         buf[i] += ('a'-'0'-10);
319                 val >>= 4;
320         }
321         buf[nibbles] = '\0';
322         call_prom("write", 3, 1, _prom->stdout, buf, nibbles);
323 }
324
325
326 static void __init prom_printf(const char *format, ...)
327 {
328         const char *p, *q, *s;
329         va_list args;
330         unsigned long v;
331         struct prom_t *_prom = &RELOC(prom);
332
333         va_start(args, format);
334 #ifdef CONFIG_PPC64
335         format = PTRRELOC(format);
336 #endif
337         for (p = format; *p != 0; p = q) {
338                 for (q = p; *q != 0 && *q != '\n' && *q != '%'; ++q)
339                         ;
340                 if (q > p)
341                         call_prom("write", 3, 1, _prom->stdout, p, q - p);
342                 if (*q == 0)
343                         break;
344                 if (*q == '\n') {
345                         ++q;
346                         call_prom("write", 3, 1, _prom->stdout,
347                                   ADDR("\r\n"), 2);
348                         continue;
349                 }
350                 ++q;
351                 if (*q == 0)
352                         break;
353                 switch (*q) {
354                 case 's':
355                         ++q;
356                         s = va_arg(args, const char *);
357                         prom_print(s);
358                         break;
359                 case 'x':
360                         ++q;
361                         v = va_arg(args, unsigned long);
362                         prom_print_hex(v);
363                         break;
364                 }
365         }
366 }
367
368
369 static unsigned int __init prom_claim(unsigned long virt, unsigned long size,
370                                 unsigned long align)
371 {
372         struct prom_t *_prom = &RELOC(prom);
373
374         if (align == 0 && (OF_WORKAROUNDS & OF_WA_CLAIM)) {
375                 /*
376                  * Old OF requires we claim physical and virtual separately
377                  * and then map explicitly (assuming virtual mode)
378                  */
379                 int ret;
380                 prom_arg_t result;
381
382                 ret = call_prom_ret("call-method", 5, 2, &result,
383                                     ADDR("claim"), _prom->memory,
384                                     align, size, virt);
385                 if (ret != 0 || result == -1)
386                         return -1;
387                 ret = call_prom_ret("call-method", 5, 2, &result,
388                                     ADDR("claim"), _prom->mmumap,
389                                     align, size, virt);
390                 if (ret != 0) {
391                         call_prom("call-method", 4, 1, ADDR("release"),
392                                   _prom->memory, size, virt);
393                         return -1;
394                 }
395                 /* the 0x12 is M (coherence) + PP == read/write */
396                 call_prom("call-method", 6, 1,
397                           ADDR("map"), _prom->mmumap, 0x12, size, virt, virt);
398                 return virt;
399         }
400         return call_prom("claim", 3, 1, (prom_arg_t)virt, (prom_arg_t)size,
401                          (prom_arg_t)align);
402 }
403
404 static void __init __attribute__((noreturn)) prom_panic(const char *reason)
405 {
406 #ifdef CONFIG_PPC64
407         reason = PTRRELOC(reason);
408 #endif
409         prom_print(reason);
410         /* Do not call exit because it clears the screen on pmac
411          * it also causes some sort of double-fault on early pmacs */
412         if (RELOC(of_platform) == PLATFORM_POWERMAC)
413                 asm("trap\n");
414
415         /* ToDo: should put up an SRC here on p/iSeries */
416         call_prom("exit", 0, 0);
417
418         for (;;)                        /* should never get here */
419                 ;
420 }
421
422
423 static int __init prom_next_node(phandle *nodep)
424 {
425         phandle node;
426
427         if ((node = *nodep) != 0
428             && (*nodep = call_prom("child", 1, 1, node)) != 0)
429                 return 1;
430         if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
431                 return 1;
432         for (;;) {
433                 if ((node = call_prom("parent", 1, 1, node)) == 0)
434                         return 0;
435                 if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
436                         return 1;
437         }
438 }
439
440 static int inline prom_getprop(phandle node, const char *pname,
441                                void *value, size_t valuelen)
442 {
443         return call_prom("getprop", 4, 1, node, ADDR(pname),
444                          (u32)(unsigned long) value, (u32) valuelen);
445 }
446
447 static int inline prom_getproplen(phandle node, const char *pname)
448 {
449         return call_prom("getproplen", 2, 1, node, ADDR(pname));
450 }
451
452 static void add_string(char **str, const char *q)
453 {
454         char *p = *str;
455
456         while (*q)
457                 *p++ = *q++;
458         *p++ = ' ';
459         *str = p;
460 }
461
462 static char *tohex(unsigned int x)
463 {
464         static char digits[] = "0123456789abcdef";
465         static char result[9];
466         int i;
467
468         result[8] = 0;
469         i = 8;
470         do {
471                 --i;
472                 result[i] = digits[x & 0xf];
473                 x >>= 4;
474         } while (x != 0 && i > 0);
475         return &result[i];
476 }
477
478 static int __init prom_setprop(phandle node, const char *nodename,
479                                const char *pname, void *value, size_t valuelen)
480 {
481         char cmd[256], *p;
482
483         if (!(OF_WORKAROUNDS & OF_WA_LONGTRAIL))
484                 return call_prom("setprop", 4, 1, node, ADDR(pname),
485                                  (u32)(unsigned long) value, (u32) valuelen);
486
487         /* gah... setprop doesn't work on longtrail, have to use interpret */
488         p = cmd;
489         add_string(&p, "dev");
490         add_string(&p, nodename);
491         add_string(&p, tohex((u32)(unsigned long) value));
492         add_string(&p, tohex(valuelen));
493         add_string(&p, tohex(ADDR(pname)));
494         add_string(&p, tohex(strlen(RELOC(pname))));
495         add_string(&p, "property");
496         *p = 0;
497         return call_prom("interpret", 1, 1, (u32)(unsigned long) cmd);
498 }
499
500 /* We can't use the standard versions because of RELOC headaches. */
501 #define isxdigit(c)     (('0' <= (c) && (c) <= '9') \
502                          || ('a' <= (c) && (c) <= 'f') \
503                          || ('A' <= (c) && (c) <= 'F'))
504
505 #define isdigit(c)      ('0' <= (c) && (c) <= '9')
506 #define islower(c)      ('a' <= (c) && (c) <= 'z')
507 #define toupper(c)      (islower(c) ? ((c) - 'a' + 'A') : (c))
508
509 unsigned long prom_strtoul(const char *cp, const char **endp)
510 {
511         unsigned long result = 0, base = 10, value;
512
513         if (*cp == '0') {
514                 base = 8;
515                 cp++;
516                 if (toupper(*cp) == 'X') {
517                         cp++;
518                         base = 16;
519                 }
520         }
521
522         while (isxdigit(*cp) &&
523                (value = isdigit(*cp) ? *cp - '0' : toupper(*cp) - 'A' + 10) < base) {
524                 result = result * base + value;
525                 cp++;
526         }
527
528         if (endp)
529                 *endp = cp;
530
531         return result;
532 }
533
534 unsigned long prom_memparse(const char *ptr, const char **retptr)
535 {
536         unsigned long ret = prom_strtoul(ptr, retptr);
537         int shift = 0;
538
539         /*
540          * We can't use a switch here because GCC *may* generate a
541          * jump table which won't work, because we're not running at
542          * the address we're linked at.
543          */
544         if ('G' == **retptr || 'g' == **retptr)
545                 shift = 30;
546
547         if ('M' == **retptr || 'm' == **retptr)
548                 shift = 20;
549
550         if ('K' == **retptr || 'k' == **retptr)
551                 shift = 10;
552
553         if (shift) {
554                 ret <<= shift;
555                 (*retptr)++;
556         }
557
558         return ret;
559 }
560
561 /*
562  * Early parsing of the command line passed to the kernel, used for
563  * "mem=x" and the options that affect the iommu
564  */
565 static void __init early_cmdline_parse(void)
566 {
567         struct prom_t *_prom = &RELOC(prom);
568         const char *opt;
569         char *p;
570         int l = 0;
571
572         RELOC(prom_cmd_line[0]) = 0;
573         p = RELOC(prom_cmd_line);
574         if ((long)_prom->chosen > 0)
575                 l = prom_getprop(_prom->chosen, "bootargs", p, COMMAND_LINE_SIZE-1);
576 #ifdef CONFIG_CMDLINE
577         if (l == 0) /* dbl check */
578                 strlcpy(RELOC(prom_cmd_line),
579                         RELOC(CONFIG_CMDLINE), sizeof(prom_cmd_line));
580 #endif /* CONFIG_CMDLINE */
581         prom_printf("command line: %s\n", RELOC(prom_cmd_line));
582
583 #ifdef CONFIG_PPC64
584         opt = strstr(RELOC(prom_cmd_line), RELOC("iommu="));
585         if (opt) {
586                 prom_printf("iommu opt is: %s\n", opt);
587                 opt += 6;
588                 while (*opt && *opt == ' ')
589                         opt++;
590                 if (!strncmp(opt, RELOC("off"), 3))
591                         RELOC(ppc64_iommu_off) = 1;
592                 else if (!strncmp(opt, RELOC("force"), 5))
593                         RELOC(iommu_force_on) = 1;
594         }
595 #endif
596
597         opt = strstr(RELOC(prom_cmd_line), RELOC("mem="));
598         if (opt) {
599                 opt += 4;
600                 RELOC(prom_memory_limit) = prom_memparse(opt, (const char **)&opt);
601 #ifdef CONFIG_PPC64
602                 /* Align to 16 MB == size of ppc64 large page */
603                 RELOC(prom_memory_limit) = ALIGN(RELOC(prom_memory_limit), 0x1000000);
604 #endif
605         }
606
607 #ifdef CONFIG_KEXEC
608         /*
609          * crashkernel=size@addr specifies the location to reserve for
610          * crash kernel.
611          */
612         opt = strstr(RELOC(prom_cmd_line), RELOC("crashkernel="));
613         if (opt) {
614                 opt += 12;
615                 RELOC(prom_crashk_size) = 
616                         prom_memparse(opt, (const char **)&opt);
617
618                 if (ALIGN(RELOC(prom_crashk_size), 0x1000000) !=
619                         RELOC(prom_crashk_size)) {
620                         prom_printf("Warning: crashkernel size is not "
621                                         "aligned to 16MB\n");
622                 }
623
624                 /*
625                  * At present, the crash kernel always run at 32MB.
626                  * Just ignore whatever user passed.
627                  */
628                 RELOC(prom_crashk_base) = 0x2000000;
629                 if (*opt == '@') {
630                         prom_printf("Warning: PPC64 kdump kernel always runs "
631                                         "at 32 MB\n");
632                 }
633         }
634 #endif
635 }
636
637 #ifdef CONFIG_PPC_PSERIES
638 /*
639  * There are two methods for telling firmware what our capabilities are.
640  * Newer machines have an "ibm,client-architecture-support" method on the
641  * root node.  For older machines, we have to call the "process-elf-header"
642  * method in the /packages/elf-loader node, passing it a fake 32-bit
643  * ELF header containing a couple of PT_NOTE sections that contain
644  * structures that contain various information.
645  */
646
647 /*
648  * New method - extensible architecture description vector.
649  *
650  * Because the description vector contains a mix of byte and word
651  * values, we declare it as an unsigned char array, and use this
652  * macro to put word values in.
653  */
654 #define W(x)    ((x) >> 24) & 0xff, ((x) >> 16) & 0xff, \
655                 ((x) >> 8) & 0xff, (x) & 0xff
656
657 /* Option vector bits - generic bits in byte 1 */
658 #define OV_IGNORE               0x80    /* ignore this vector */
659 #define OV_CESSATION_POLICY     0x40    /* halt if unsupported option present*/
660
661 /* Option vector 1: processor architectures supported */
662 #define OV1_PPC_2_00            0x80    /* set if we support PowerPC 2.00 */
663 #define OV1_PPC_2_01            0x40    /* set if we support PowerPC 2.01 */
664 #define OV1_PPC_2_02            0x20    /* set if we support PowerPC 2.02 */
665 #define OV1_PPC_2_03            0x10    /* set if we support PowerPC 2.03 */
666 #define OV1_PPC_2_04            0x08    /* set if we support PowerPC 2.04 */
667 #define OV1_PPC_2_05            0x04    /* set if we support PowerPC 2.05 */
668
669 /* Option vector 2: Open Firmware options supported */
670 #define OV2_REAL_MODE           0x20    /* set if we want OF in real mode */
671
672 /* Option vector 3: processor options supported */
673 #define OV3_FP                  0x80    /* floating point */
674 #define OV3_VMX                 0x40    /* VMX/Altivec */
675
676 /* Option vector 5: PAPR/OF options supported */
677 #define OV5_LPAR                0x80    /* logical partitioning supported */
678 #define OV5_SPLPAR              0x40    /* shared-processor LPAR supported */
679 /* ibm,dynamic-reconfiguration-memory property supported */
680 #define OV5_DRCONF_MEMORY       0x20
681 #define OV5_LARGE_PAGES         0x10    /* large pages supported */
682
683 /*
684  * The architecture vector has an array of PVR mask/value pairs,
685  * followed by # option vectors - 1, followed by the option vectors.
686  */
687 static unsigned char ibm_architecture_vec[] = {
688         W(0xfffe0000), W(0x003a0000),   /* POWER5/POWER5+ */
689         W(0xffff0000), W(0x003e0000),   /* POWER6 */
690         W(0xfffffffe), W(0x0f000001),   /* all 2.04-compliant and earlier */
691         5 - 1,                          /* 5 option vectors */
692
693         /* option vector 1: processor architectures supported */
694         3 - 1,                          /* length */
695         0,                              /* don't ignore, don't halt */
696         OV1_PPC_2_00 | OV1_PPC_2_01 | OV1_PPC_2_02 | OV1_PPC_2_03 |
697         OV1_PPC_2_04 | OV1_PPC_2_05,
698
699         /* option vector 2: Open Firmware options supported */
700         34 - 1,                         /* length */
701         OV2_REAL_MODE,
702         0, 0,
703         W(0xffffffff),                  /* real_base */
704         W(0xffffffff),                  /* real_size */
705         W(0xffffffff),                  /* virt_base */
706         W(0xffffffff),                  /* virt_size */
707         W(0xffffffff),                  /* load_base */
708         W(64),                          /* 128MB min RMA */
709         W(0xffffffff),                  /* full client load */
710         0,                              /* min RMA percentage of total RAM */
711         48,                             /* max log_2(hash table size) */
712
713         /* option vector 3: processor options supported */
714         3 - 1,                          /* length */
715         0,                              /* don't ignore, don't halt */
716         OV3_FP | OV3_VMX,
717
718         /* option vector 4: IBM PAPR implementation */
719         2 - 1,                          /* length */
720         0,                              /* don't halt */
721
722         /* option vector 5: PAPR/OF options */
723         3 - 1,                          /* length */
724         0,                              /* don't ignore, don't halt */
725         OV5_LPAR | OV5_SPLPAR | OV5_LARGE_PAGES,
726 };
727
728 /* Old method - ELF header with PT_NOTE sections */
729 static struct fake_elf {
730         Elf32_Ehdr      elfhdr;
731         Elf32_Phdr      phdr[2];
732         struct chrpnote {
733                 u32     namesz;
734                 u32     descsz;
735                 u32     type;
736                 char    name[8];        /* "PowerPC" */
737                 struct chrpdesc {
738                         u32     real_mode;
739                         u32     real_base;
740                         u32     real_size;
741                         u32     virt_base;
742                         u32     virt_size;
743                         u32     load_base;
744                 } chrpdesc;
745         } chrpnote;
746         struct rpanote {
747                 u32     namesz;
748                 u32     descsz;
749                 u32     type;
750                 char    name[24];       /* "IBM,RPA-Client-Config" */
751                 struct rpadesc {
752                         u32     lpar_affinity;
753                         u32     min_rmo_size;
754                         u32     min_rmo_percent;
755                         u32     max_pft_size;
756                         u32     splpar;
757                         u32     min_load;
758                         u32     new_mem_def;
759                         u32     ignore_me;
760                 } rpadesc;
761         } rpanote;
762 } fake_elf = {
763         .elfhdr = {
764                 .e_ident = { 0x7f, 'E', 'L', 'F',
765                              ELFCLASS32, ELFDATA2MSB, EV_CURRENT },
766                 .e_type = ET_EXEC,      /* yeah right */
767                 .e_machine = EM_PPC,
768                 .e_version = EV_CURRENT,
769                 .e_phoff = offsetof(struct fake_elf, phdr),
770                 .e_phentsize = sizeof(Elf32_Phdr),
771                 .e_phnum = 2
772         },
773         .phdr = {
774                 [0] = {
775                         .p_type = PT_NOTE,
776                         .p_offset = offsetof(struct fake_elf, chrpnote),
777                         .p_filesz = sizeof(struct chrpnote)
778                 }, [1] = {
779                         .p_type = PT_NOTE,
780                         .p_offset = offsetof(struct fake_elf, rpanote),
781                         .p_filesz = sizeof(struct rpanote)
782                 }
783         },
784         .chrpnote = {
785                 .namesz = sizeof("PowerPC"),
786                 .descsz = sizeof(struct chrpdesc),
787                 .type = 0x1275,
788                 .name = "PowerPC",
789                 .chrpdesc = {
790                         .real_mode = ~0U,       /* ~0 means "don't care" */
791                         .real_base = ~0U,
792                         .real_size = ~0U,
793                         .virt_base = ~0U,
794                         .virt_size = ~0U,
795                         .load_base = ~0U
796                 },
797         },
798         .rpanote = {
799                 .namesz = sizeof("IBM,RPA-Client-Config"),
800                 .descsz = sizeof(struct rpadesc),
801                 .type = 0x12759999,
802                 .name = "IBM,RPA-Client-Config",
803                 .rpadesc = {
804                         .lpar_affinity = 0,
805                         .min_rmo_size = 64,     /* in megabytes */
806                         .min_rmo_percent = 0,
807                         .max_pft_size = 48,     /* 2^48 bytes max PFT size */
808                         .splpar = 1,
809                         .min_load = ~0U,
810                         .new_mem_def = 0
811                 }
812         }
813 };
814
815 static void __init prom_send_capabilities(void)
816 {
817         ihandle elfloader, root;
818         prom_arg_t ret;
819
820         root = call_prom("open", 1, 1, ADDR("/"));
821         if (root != 0) {
822                 /* try calling the ibm,client-architecture-support method */
823                 if (call_prom_ret("call-method", 3, 2, &ret,
824                                   ADDR("ibm,client-architecture-support"),
825                                   ADDR(ibm_architecture_vec)) == 0) {
826                         /* the call exists... */
827                         if (ret)
828                                 prom_printf("WARNING: ibm,client-architecture"
829                                             "-support call FAILED!\n");
830                         call_prom("close", 1, 0, root);
831                         return;
832                 }
833                 call_prom("close", 1, 0, root);
834         }
835
836         /* no ibm,client-architecture-support call, try the old way */
837         elfloader = call_prom("open", 1, 1, ADDR("/packages/elf-loader"));
838         if (elfloader == 0) {
839                 prom_printf("couldn't open /packages/elf-loader\n");
840                 return;
841         }
842         call_prom("call-method", 3, 1, ADDR("process-elf-header"),
843                         elfloader, ADDR(&fake_elf));
844         call_prom("close", 1, 0, elfloader);
845 }
846 #endif
847
848 /*
849  * Memory allocation strategy... our layout is normally:
850  *
851  *  at 14Mb or more we have vmlinux, then a gap and initrd.  In some
852  *  rare cases, initrd might end up being before the kernel though.
853  *  We assume this won't override the final kernel at 0, we have no
854  *  provision to handle that in this version, but it should hopefully
855  *  never happen.
856  *
857  *  alloc_top is set to the top of RMO, eventually shrink down if the
858  *  TCEs overlap
859  *
860  *  alloc_bottom is set to the top of kernel/initrd
861  *
862  *  from there, allocations are done this way : rtas is allocated
863  *  topmost, and the device-tree is allocated from the bottom. We try
864  *  to grow the device-tree allocation as we progress. If we can't,
865  *  then we fail, we don't currently have a facility to restart
866  *  elsewhere, but that shouldn't be necessary.
867  *
868  *  Note that calls to reserve_mem have to be done explicitly, memory
869  *  allocated with either alloc_up or alloc_down isn't automatically
870  *  reserved.
871  */
872
873
874 /*
875  * Allocates memory in the RMO upward from the kernel/initrd
876  *
877  * When align is 0, this is a special case, it means to allocate in place
878  * at the current location of alloc_bottom or fail (that is basically
879  * extending the previous allocation). Used for the device-tree flattening
880  */
881 static unsigned long __init alloc_up(unsigned long size, unsigned long align)
882 {
883         unsigned long base = RELOC(alloc_bottom);
884         unsigned long addr = 0;
885
886         if (align)
887                 base = _ALIGN_UP(base, align);
888         prom_debug("alloc_up(%x, %x)\n", size, align);
889         if (RELOC(ram_top) == 0)
890                 prom_panic("alloc_up() called with mem not initialized\n");
891
892         if (align)
893                 base = _ALIGN_UP(RELOC(alloc_bottom), align);
894         else
895                 base = RELOC(alloc_bottom);
896
897         for(; (base + size) <= RELOC(alloc_top); 
898             base = _ALIGN_UP(base + 0x100000, align)) {
899                 prom_debug("    trying: 0x%x\n\r", base);
900                 addr = (unsigned long)prom_claim(base, size, 0);
901                 if (addr != PROM_ERROR && addr != 0)
902                         break;
903                 addr = 0;
904                 if (align == 0)
905                         break;
906         }
907         if (addr == 0)
908                 return 0;
909         RELOC(alloc_bottom) = addr;
910
911         prom_debug(" -> %x\n", addr);
912         prom_debug("  alloc_bottom : %x\n", RELOC(alloc_bottom));
913         prom_debug("  alloc_top    : %x\n", RELOC(alloc_top));
914         prom_debug("  alloc_top_hi : %x\n", RELOC(alloc_top_high));
915         prom_debug("  rmo_top      : %x\n", RELOC(rmo_top));
916         prom_debug("  ram_top      : %x\n", RELOC(ram_top));
917
918         return addr;
919 }
920
921 /*
922  * Allocates memory downward, either from top of RMO, or if highmem
923  * is set, from the top of RAM.  Note that this one doesn't handle
924  * failures.  It does claim memory if highmem is not set.
925  */
926 static unsigned long __init alloc_down(unsigned long size, unsigned long align,
927                                        int highmem)
928 {
929         unsigned long base, addr = 0;
930
931         prom_debug("alloc_down(%x, %x, %s)\n", size, align,
932                    highmem ? RELOC("(high)") : RELOC("(low)"));
933         if (RELOC(ram_top) == 0)
934                 prom_panic("alloc_down() called with mem not initialized\n");
935
936         if (highmem) {
937                 /* Carve out storage for the TCE table. */
938                 addr = _ALIGN_DOWN(RELOC(alloc_top_high) - size, align);
939                 if (addr <= RELOC(alloc_bottom))
940                         return 0;
941                 /* Will we bump into the RMO ? If yes, check out that we
942                  * didn't overlap existing allocations there, if we did,
943                  * we are dead, we must be the first in town !
944                  */
945                 if (addr < RELOC(rmo_top)) {
946                         /* Good, we are first */
947                         if (RELOC(alloc_top) == RELOC(rmo_top))
948                                 RELOC(alloc_top) = RELOC(rmo_top) = addr;
949                         else
950                                 return 0;
951                 }
952                 RELOC(alloc_top_high) = addr;
953                 goto bail;
954         }
955
956         base = _ALIGN_DOWN(RELOC(alloc_top) - size, align);
957         for (; base > RELOC(alloc_bottom);
958              base = _ALIGN_DOWN(base - 0x100000, align))  {
959                 prom_debug("    trying: 0x%x\n\r", base);
960                 addr = (unsigned long)prom_claim(base, size, 0);
961                 if (addr != PROM_ERROR && addr != 0)
962                         break;
963                 addr = 0;
964         }
965         if (addr == 0)
966                 return 0;
967         RELOC(alloc_top) = addr;
968
969  bail:
970         prom_debug(" -> %x\n", addr);
971         prom_debug("  alloc_bottom : %x\n", RELOC(alloc_bottom));
972         prom_debug("  alloc_top    : %x\n", RELOC(alloc_top));
973         prom_debug("  alloc_top_hi : %x\n", RELOC(alloc_top_high));
974         prom_debug("  rmo_top      : %x\n", RELOC(rmo_top));
975         prom_debug("  ram_top      : %x\n", RELOC(ram_top));
976
977         return addr;
978 }
979
980 /*
981  * Parse a "reg" cell
982  */
983 static unsigned long __init prom_next_cell(int s, cell_t **cellp)
984 {
985         cell_t *p = *cellp;
986         unsigned long r = 0;
987
988         /* Ignore more than 2 cells */
989         while (s > sizeof(unsigned long) / 4) {
990                 p++;
991                 s--;
992         }
993         r = *p++;
994 #ifdef CONFIG_PPC64
995         if (s > 1) {
996                 r <<= 32;
997                 r |= *(p++);
998         }
999 #endif
1000         *cellp = p;
1001         return r;
1002 }
1003
1004 /*
1005  * Very dumb function for adding to the memory reserve list, but
1006  * we don't need anything smarter at this point
1007  *
1008  * XXX Eventually check for collisions.  They should NEVER happen.
1009  * If problems seem to show up, it would be a good start to track
1010  * them down.
1011  */
1012 static void reserve_mem(u64 base, u64 size)
1013 {
1014         u64 top = base + size;
1015         unsigned long cnt = RELOC(mem_reserve_cnt);
1016
1017         if (size == 0)
1018                 return;
1019
1020         /* We need to always keep one empty entry so that we
1021          * have our terminator with "size" set to 0 since we are
1022          * dumb and just copy this entire array to the boot params
1023          */
1024         base = _ALIGN_DOWN(base, PAGE_SIZE);
1025         top = _ALIGN_UP(top, PAGE_SIZE);
1026         size = top - base;
1027
1028         if (cnt >= (MEM_RESERVE_MAP_SIZE - 1))
1029                 prom_panic("Memory reserve map exhausted !\n");
1030         RELOC(mem_reserve_map)[cnt].base = base;
1031         RELOC(mem_reserve_map)[cnt].size = size;
1032         RELOC(mem_reserve_cnt) = cnt + 1;
1033 }
1034
1035 /*
1036  * Initialize memory allocation mecanism, parse "memory" nodes and
1037  * obtain that way the top of memory and RMO to setup out local allocator
1038  */
1039 static void __init prom_init_mem(void)
1040 {
1041         phandle node;
1042         char *path, type[64];
1043         unsigned int plen;
1044         cell_t *p, *endp;
1045         struct prom_t *_prom = &RELOC(prom);
1046         u32 rac, rsc;
1047
1048         /*
1049          * We iterate the memory nodes to find
1050          * 1) top of RMO (first node)
1051          * 2) top of memory
1052          */
1053         rac = 2;
1054         prom_getprop(_prom->root, "#address-cells", &rac, sizeof(rac));
1055         rsc = 1;
1056         prom_getprop(_prom->root, "#size-cells", &rsc, sizeof(rsc));
1057         prom_debug("root_addr_cells: %x\n", (unsigned long) rac);
1058         prom_debug("root_size_cells: %x\n", (unsigned long) rsc);
1059
1060         prom_debug("scanning memory:\n");
1061         path = RELOC(prom_scratch);
1062
1063         for (node = 0; prom_next_node(&node); ) {
1064                 type[0] = 0;
1065                 prom_getprop(node, "device_type", type, sizeof(type));
1066
1067                 if (type[0] == 0) {
1068                         /*
1069                          * CHRP Longtrail machines have no device_type
1070                          * on the memory node, so check the name instead...
1071                          */
1072                         prom_getprop(node, "name", type, sizeof(type));
1073                 }
1074                 if (strcmp(type, RELOC("memory")))
1075                         continue;
1076
1077                 plen = prom_getprop(node, "reg", RELOC(regbuf), sizeof(regbuf));
1078                 if (plen > sizeof(regbuf)) {
1079                         prom_printf("memory node too large for buffer !\n");
1080                         plen = sizeof(regbuf);
1081                 }
1082                 p = RELOC(regbuf);
1083                 endp = p + (plen / sizeof(cell_t));
1084
1085 #ifdef DEBUG_PROM
1086                 memset(path, 0, PROM_SCRATCH_SIZE);
1087                 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
1088                 prom_debug("  node %s :\n", path);
1089 #endif /* DEBUG_PROM */
1090
1091                 while ((endp - p) >= (rac + rsc)) {
1092                         unsigned long base, size;
1093
1094                         base = prom_next_cell(rac, &p);
1095                         size = prom_next_cell(rsc, &p);
1096
1097                         if (size == 0)
1098                                 continue;
1099                         prom_debug("    %x %x\n", base, size);
1100                         if (base == 0 && (RELOC(of_platform) & PLATFORM_LPAR))
1101                                 RELOC(rmo_top) = size;
1102                         if ((base + size) > RELOC(ram_top))
1103                                 RELOC(ram_top) = base + size;
1104                 }
1105         }
1106
1107         RELOC(alloc_bottom) = PAGE_ALIGN((unsigned long)&RELOC(_end) + 0x4000);
1108
1109         /* Check if we have an initrd after the kernel, if we do move our bottom
1110          * point to after it
1111          */
1112         if (RELOC(prom_initrd_start)) {
1113                 if (RELOC(prom_initrd_end) > RELOC(alloc_bottom))
1114                         RELOC(alloc_bottom) = PAGE_ALIGN(RELOC(prom_initrd_end));
1115         }
1116
1117         /*
1118          * If prom_memory_limit is set we reduce the upper limits *except* for
1119          * alloc_top_high. This must be the real top of RAM so we can put
1120          * TCE's up there.
1121          */
1122
1123         RELOC(alloc_top_high) = RELOC(ram_top);
1124
1125         if (RELOC(prom_memory_limit)) {
1126                 if (RELOC(prom_memory_limit) <= RELOC(alloc_bottom)) {
1127                         prom_printf("Ignoring mem=%x <= alloc_bottom.\n",
1128                                 RELOC(prom_memory_limit));
1129                         RELOC(prom_memory_limit) = 0;
1130                 } else if (RELOC(prom_memory_limit) >= RELOC(ram_top)) {
1131                         prom_printf("Ignoring mem=%x >= ram_top.\n",
1132                                 RELOC(prom_memory_limit));
1133                         RELOC(prom_memory_limit) = 0;
1134                 } else {
1135                         RELOC(ram_top) = RELOC(prom_memory_limit);
1136                         RELOC(rmo_top) = min(RELOC(rmo_top), RELOC(prom_memory_limit));
1137                 }
1138         }
1139
1140         /*
1141          * Setup our top alloc point, that is top of RMO or top of
1142          * segment 0 when running non-LPAR.
1143          * Some RS64 machines have buggy firmware where claims up at
1144          * 1GB fail.  Cap at 768MB as a workaround.
1145          * Since 768MB is plenty of room, and we need to cap to something
1146          * reasonable on 32-bit, cap at 768MB on all machines.
1147          */
1148         if (!RELOC(rmo_top))
1149                 RELOC(rmo_top) = RELOC(ram_top);
1150         RELOC(rmo_top) = min(0x30000000ul, RELOC(rmo_top));
1151         RELOC(alloc_top) = RELOC(rmo_top);
1152
1153         prom_printf("memory layout at init:\n");
1154         prom_printf("  memory_limit : %x (16 MB aligned)\n", RELOC(prom_memory_limit));
1155         prom_printf("  alloc_bottom : %x\n", RELOC(alloc_bottom));
1156         prom_printf("  alloc_top    : %x\n", RELOC(alloc_top));
1157         prom_printf("  alloc_top_hi : %x\n", RELOC(alloc_top_high));
1158         prom_printf("  rmo_top      : %x\n", RELOC(rmo_top));
1159         prom_printf("  ram_top      : %x\n", RELOC(ram_top));
1160 #ifdef CONFIG_KEXEC
1161         if (RELOC(prom_crashk_base)) {
1162                 prom_printf("  crashk_base  : %x\n",  RELOC(prom_crashk_base));
1163                 prom_printf("  crashk_size  : %x\n", RELOC(prom_crashk_size));
1164         }
1165 #endif
1166 }
1167
1168
1169 /*
1170  * Allocate room for and instantiate RTAS
1171  */
1172 static void __init prom_instantiate_rtas(void)
1173 {
1174         phandle rtas_node;
1175         ihandle rtas_inst;
1176         u32 base, entry = 0;
1177         u32 size = 0;
1178
1179         prom_debug("prom_instantiate_rtas: start...\n");
1180
1181         rtas_node = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1182         prom_debug("rtas_node: %x\n", rtas_node);
1183         if (!PHANDLE_VALID(rtas_node))
1184                 return;
1185
1186         prom_getprop(rtas_node, "rtas-size", &size, sizeof(size));
1187         if (size == 0)
1188                 return;
1189
1190         base = alloc_down(size, PAGE_SIZE, 0);
1191         if (base == 0) {
1192                 prom_printf("RTAS allocation failed !\n");
1193                 return;
1194         }
1195
1196         rtas_inst = call_prom("open", 1, 1, ADDR("/rtas"));
1197         if (!IHANDLE_VALID(rtas_inst)) {
1198                 prom_printf("opening rtas package failed (%x)\n", rtas_inst);
1199                 return;
1200         }
1201
1202         prom_printf("instantiating rtas at 0x%x ...", base);
1203
1204         if (call_prom_ret("call-method", 3, 2, &entry,
1205                           ADDR("instantiate-rtas"),
1206                           rtas_inst, base) != 0
1207             || entry == 0) {
1208                 prom_printf(" failed\n");
1209                 return;
1210         }
1211         prom_printf(" done\n");
1212
1213         reserve_mem(base, size);
1214
1215         prom_setprop(rtas_node, "/rtas", "linux,rtas-base",
1216                      &base, sizeof(base));
1217         prom_setprop(rtas_node, "/rtas", "linux,rtas-entry",
1218                      &entry, sizeof(entry));
1219
1220         prom_debug("rtas base     = 0x%x\n", base);
1221         prom_debug("rtas entry    = 0x%x\n", entry);
1222         prom_debug("rtas size     = 0x%x\n", (long)size);
1223
1224         prom_debug("prom_instantiate_rtas: end...\n");
1225 }
1226
1227 #ifdef CONFIG_PPC64
1228 /*
1229  * Allocate room for and initialize TCE tables
1230  */
1231 static void __init prom_initialize_tce_table(void)
1232 {
1233         phandle node;
1234         ihandle phb_node;
1235         char compatible[64], type[64], model[64];
1236         char *path = RELOC(prom_scratch);
1237         u64 base, align;
1238         u32 minalign, minsize;
1239         u64 tce_entry, *tce_entryp;
1240         u64 local_alloc_top, local_alloc_bottom;
1241         u64 i;
1242
1243         if (RELOC(ppc64_iommu_off))
1244                 return;
1245
1246         prom_debug("starting prom_initialize_tce_table\n");
1247
1248         /* Cache current top of allocs so we reserve a single block */
1249         local_alloc_top = RELOC(alloc_top_high);
1250         local_alloc_bottom = local_alloc_top;
1251
1252         /* Search all nodes looking for PHBs. */
1253         for (node = 0; prom_next_node(&node); ) {
1254                 compatible[0] = 0;
1255                 type[0] = 0;
1256                 model[0] = 0;
1257                 prom_getprop(node, "compatible",
1258                              compatible, sizeof(compatible));
1259                 prom_getprop(node, "device_type", type, sizeof(type));
1260                 prom_getprop(node, "model", model, sizeof(model));
1261
1262                 if ((type[0] == 0) || (strstr(type, RELOC("pci")) == NULL))
1263                         continue;
1264
1265                 /* Keep the old logic in tack to avoid regression. */
1266                 if (compatible[0] != 0) {
1267                         if ((strstr(compatible, RELOC("python")) == NULL) &&
1268                             (strstr(compatible, RELOC("Speedwagon")) == NULL) &&
1269                             (strstr(compatible, RELOC("Winnipeg")) == NULL))
1270                                 continue;
1271                 } else if (model[0] != 0) {
1272                         if ((strstr(model, RELOC("ython")) == NULL) &&
1273                             (strstr(model, RELOC("peedwagon")) == NULL) &&
1274                             (strstr(model, RELOC("innipeg")) == NULL))
1275                                 continue;
1276                 }
1277
1278                 if (prom_getprop(node, "tce-table-minalign", &minalign,
1279                                  sizeof(minalign)) == PROM_ERROR)
1280                         minalign = 0;
1281                 if (prom_getprop(node, "tce-table-minsize", &minsize,
1282                                  sizeof(minsize)) == PROM_ERROR)
1283                         minsize = 4UL << 20;
1284
1285                 /*
1286                  * Even though we read what OF wants, we just set the table
1287                  * size to 4 MB.  This is enough to map 2GB of PCI DMA space.
1288                  * By doing this, we avoid the pitfalls of trying to DMA to
1289                  * MMIO space and the DMA alias hole.
1290                  *
1291                  * On POWER4, firmware sets the TCE region by assuming
1292                  * each TCE table is 8MB. Using this memory for anything
1293                  * else will impact performance, so we always allocate 8MB.
1294                  * Anton
1295                  */
1296                 if (__is_processor(PV_POWER4) || __is_processor(PV_POWER4p))
1297                         minsize = 8UL << 20;
1298                 else
1299                         minsize = 4UL << 20;
1300
1301                 /* Align to the greater of the align or size */
1302                 align = max(minalign, minsize);
1303                 base = alloc_down(minsize, align, 1);
1304                 if (base == 0)
1305                         prom_panic("ERROR, cannot find space for TCE table.\n");
1306                 if (base < local_alloc_bottom)
1307                         local_alloc_bottom = base;
1308
1309                 /* It seems OF doesn't null-terminate the path :-( */
1310                 memset(path, 0, sizeof(path));
1311                 /* Call OF to setup the TCE hardware */
1312                 if (call_prom("package-to-path", 3, 1, node,
1313                               path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) {
1314                         prom_printf("package-to-path failed\n");
1315                 }
1316
1317                 /* Save away the TCE table attributes for later use. */
1318                 prom_setprop(node, path, "linux,tce-base", &base, sizeof(base));
1319                 prom_setprop(node, path, "linux,tce-size", &minsize, sizeof(minsize));
1320
1321                 prom_debug("TCE table: %s\n", path);
1322                 prom_debug("\tnode = 0x%x\n", node);
1323                 prom_debug("\tbase = 0x%x\n", base);
1324                 prom_debug("\tsize = 0x%x\n", minsize);
1325
1326                 /* Initialize the table to have a one-to-one mapping
1327                  * over the allocated size.
1328                  */
1329                 tce_entryp = (unsigned long *)base;
1330                 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) {
1331                         tce_entry = (i << PAGE_SHIFT);
1332                         tce_entry |= 0x3;
1333                         *tce_entryp = tce_entry;
1334                 }
1335
1336                 prom_printf("opening PHB %s", path);
1337                 phb_node = call_prom("open", 1, 1, path);
1338                 if (phb_node == 0)
1339                         prom_printf("... failed\n");
1340                 else
1341                         prom_printf("... done\n");
1342
1343                 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"),
1344                           phb_node, -1, minsize,
1345                           (u32) base, (u32) (base >> 32));
1346                 call_prom("close", 1, 0, phb_node);
1347         }
1348
1349         reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom);
1350
1351         if (RELOC(prom_memory_limit)) {
1352                 /*
1353                  * We align the start to a 16MB boundary so we can map
1354                  * the TCE area using large pages if possible.
1355                  * The end should be the top of RAM so no need to align it.
1356                  */
1357                 RELOC(prom_tce_alloc_start) = _ALIGN_DOWN(local_alloc_bottom,
1358                                                           0x1000000);
1359                 RELOC(prom_tce_alloc_end) = local_alloc_top;
1360         }
1361
1362         /* Flag the first invalid entry */
1363         prom_debug("ending prom_initialize_tce_table\n");
1364 }
1365 #endif
1366
1367 /*
1368  * With CHRP SMP we need to use the OF to start the other processors.
1369  * We can't wait until smp_boot_cpus (the OF is trashed by then)
1370  * so we have to put the processors into a holding pattern controlled
1371  * by the kernel (not OF) before we destroy the OF.
1372  *
1373  * This uses a chunk of low memory, puts some holding pattern
1374  * code there and sends the other processors off to there until
1375  * smp_boot_cpus tells them to do something.  The holding pattern
1376  * checks that address until its cpu # is there, when it is that
1377  * cpu jumps to __secondary_start().  smp_boot_cpus() takes care
1378  * of setting those values.
1379  *
1380  * We also use physical address 0x4 here to tell when a cpu
1381  * is in its holding pattern code.
1382  *
1383  * -- Cort
1384  */
1385 extern void __secondary_hold(void);
1386 extern unsigned long __secondary_hold_spinloop;
1387 extern unsigned long __secondary_hold_acknowledge;
1388
1389 /*
1390  * We want to reference the copy of __secondary_hold_* in the
1391  * 0 - 0x100 address range
1392  */
1393 #define LOW_ADDR(x)     (((unsigned long) &(x)) & 0xff)
1394
1395 static void __init prom_hold_cpus(void)
1396 {
1397         unsigned long i;
1398         unsigned int reg;
1399         phandle node;
1400         char type[64];
1401         int cpuid = 0;
1402         unsigned int interrupt_server[MAX_CPU_THREADS];
1403         unsigned int cpu_threads, hw_cpu_num;
1404         int propsize;
1405         struct prom_t *_prom = &RELOC(prom);
1406         unsigned long *spinloop
1407                 = (void *) LOW_ADDR(__secondary_hold_spinloop);
1408         unsigned long *acknowledge
1409                 = (void *) LOW_ADDR(__secondary_hold_acknowledge);
1410 #ifdef CONFIG_PPC64
1411         /* __secondary_hold is actually a descriptor, not the text address */
1412         unsigned long secondary_hold
1413                 = __pa(*PTRRELOC((unsigned long *)__secondary_hold));
1414 #else
1415         unsigned long secondary_hold = LOW_ADDR(__secondary_hold);
1416 #endif
1417
1418         prom_debug("prom_hold_cpus: start...\n");
1419         prom_debug("    1) spinloop       = 0x%x\n", (unsigned long)spinloop);
1420         prom_debug("    1) *spinloop      = 0x%x\n", *spinloop);
1421         prom_debug("    1) acknowledge    = 0x%x\n",
1422                    (unsigned long)acknowledge);
1423         prom_debug("    1) *acknowledge   = 0x%x\n", *acknowledge);
1424         prom_debug("    1) secondary_hold = 0x%x\n", secondary_hold);
1425
1426         /* Set the common spinloop variable, so all of the secondary cpus
1427          * will block when they are awakened from their OF spinloop.
1428          * This must occur for both SMP and non SMP kernels, since OF will
1429          * be trashed when we move the kernel.
1430          */
1431         *spinloop = 0;
1432
1433         /* look for cpus */
1434         for (node = 0; prom_next_node(&node); ) {
1435                 type[0] = 0;
1436                 prom_getprop(node, "device_type", type, sizeof(type));
1437                 if (strcmp(type, RELOC("cpu")) != 0)
1438                         continue;
1439
1440                 /* Skip non-configured cpus. */
1441                 if (prom_getprop(node, "status", type, sizeof(type)) > 0)
1442                         if (strcmp(type, RELOC("okay")) != 0)
1443                                 continue;
1444
1445                 reg = -1;
1446                 prom_getprop(node, "reg", &reg, sizeof(reg));
1447
1448                 prom_debug("\ncpuid        = 0x%x\n", cpuid);
1449                 prom_debug("cpu hw idx   = 0x%x\n", reg);
1450
1451                 /* Init the acknowledge var which will be reset by
1452                  * the secondary cpu when it awakens from its OF
1453                  * spinloop.
1454                  */
1455                 *acknowledge = (unsigned long)-1;
1456
1457                 propsize = prom_getprop(node, "ibm,ppc-interrupt-server#s",
1458                                         &interrupt_server,
1459                                         sizeof(interrupt_server));
1460                 if (propsize < 0) {
1461                         /* no property.  old hardware has no SMT */
1462                         cpu_threads = 1;
1463                         interrupt_server[0] = reg; /* fake it with phys id */
1464                 } else {
1465                         /* We have a threaded processor */
1466                         cpu_threads = propsize / sizeof(u32);
1467                         if (cpu_threads > MAX_CPU_THREADS) {
1468                                 prom_printf("SMT: too many threads!\n"
1469                                             "SMT: found %x, max is %x\n",
1470                                             cpu_threads, MAX_CPU_THREADS);
1471                                 cpu_threads = 1; /* ToDo: panic? */
1472                         }
1473                 }
1474
1475                 hw_cpu_num = interrupt_server[0];
1476                 if (hw_cpu_num != _prom->cpu) {
1477                         /* Primary Thread of non-boot cpu */
1478                         prom_printf("%x : starting cpu hw idx %x... ", cpuid, reg);
1479                         call_prom("start-cpu", 3, 0, node,
1480                                   secondary_hold, reg);
1481
1482                         for (i = 0; (i < 100000000) && 
1483                              (*acknowledge == ((unsigned long)-1)); i++ )
1484                                 mb();
1485
1486                         if (*acknowledge == reg)
1487                                 prom_printf("done\n");
1488                         else
1489                                 prom_printf("failed: %x\n", *acknowledge);
1490                 }
1491 #ifdef CONFIG_SMP
1492                 else
1493                         prom_printf("%x : boot cpu     %x\n", cpuid, reg);
1494 #endif /* CONFIG_SMP */
1495
1496                 /* Reserve cpu #s for secondary threads.   They start later. */
1497                 cpuid += cpu_threads;
1498         }
1499
1500         if (cpuid > NR_CPUS)
1501                 prom_printf("WARNING: maximum CPUs (" __stringify(NR_CPUS)
1502                             ") exceeded: ignoring extras\n");
1503
1504         prom_debug("prom_hold_cpus: end...\n");
1505 }
1506
1507
1508 static void __init prom_init_client_services(unsigned long pp)
1509 {
1510         struct prom_t *_prom = &RELOC(prom);
1511
1512         /* Get a handle to the prom entry point before anything else */
1513         RELOC(prom_entry) = pp;
1514
1515         /* get a handle for the stdout device */
1516         _prom->chosen = call_prom("finddevice", 1, 1, ADDR("/chosen"));
1517         if (!PHANDLE_VALID(_prom->chosen))
1518                 prom_panic("cannot find chosen"); /* msg won't be printed :( */
1519
1520         /* get device tree root */
1521         _prom->root = call_prom("finddevice", 1, 1, ADDR("/"));
1522         if (!PHANDLE_VALID(_prom->root))
1523                 prom_panic("cannot find device tree root"); /* msg won't be printed :( */
1524
1525         _prom->mmumap = 0;
1526 }
1527
1528 #ifdef CONFIG_PPC32
1529 /*
1530  * For really old powermacs, we need to map things we claim.
1531  * For that, we need the ihandle of the mmu.
1532  * Also, on the longtrail, we need to work around other bugs.
1533  */
1534 static void __init prom_find_mmu(void)
1535 {
1536         struct prom_t *_prom = &RELOC(prom);
1537         phandle oprom;
1538         char version[64];
1539
1540         oprom = call_prom("finddevice", 1, 1, ADDR("/openprom"));
1541         if (!PHANDLE_VALID(oprom))
1542                 return;
1543         if (prom_getprop(oprom, "model", version, sizeof(version)) <= 0)
1544                 return;
1545         version[sizeof(version) - 1] = 0;
1546         /* XXX might need to add other versions here */
1547         if (strcmp(version, "Open Firmware, 1.0.5") == 0)
1548                 of_workarounds = OF_WA_CLAIM;
1549         else if (strncmp(version, "FirmWorks,3.", 12) == 0) {
1550                 of_workarounds = OF_WA_CLAIM | OF_WA_LONGTRAIL;
1551                 call_prom("interpret", 1, 1, "dev /memory 0 to allow-reclaim");
1552         } else
1553                 return;
1554         _prom->memory = call_prom("open", 1, 1, ADDR("/memory"));
1555         prom_getprop(_prom->chosen, "mmu", &_prom->mmumap,
1556                      sizeof(_prom->mmumap));
1557         if (!IHANDLE_VALID(_prom->memory) || !IHANDLE_VALID(_prom->mmumap))
1558                 of_workarounds &= ~OF_WA_CLAIM;         /* hmmm */
1559 }
1560 #else
1561 #define prom_find_mmu()
1562 #endif
1563
1564 static void __init prom_init_stdout(void)
1565 {
1566         struct prom_t *_prom = &RELOC(prom);
1567         char *path = RELOC(of_stdout_device);
1568         char type[16];
1569         u32 val;
1570
1571         if (prom_getprop(_prom->chosen, "stdout", &val, sizeof(val)) <= 0)
1572                 prom_panic("cannot find stdout");
1573
1574         _prom->stdout = val;
1575
1576         /* Get the full OF pathname of the stdout device */
1577         memset(path, 0, 256);
1578         call_prom("instance-to-path", 3, 1, _prom->stdout, path, 255);
1579         val = call_prom("instance-to-package", 1, 1, _prom->stdout);
1580         prom_setprop(_prom->chosen, "/chosen", "linux,stdout-package",
1581                      &val, sizeof(val));
1582         prom_printf("OF stdout device is: %s\n", RELOC(of_stdout_device));
1583         prom_setprop(_prom->chosen, "/chosen", "linux,stdout-path",
1584                      path, strlen(path) + 1);
1585
1586         /* If it's a display, note it */
1587         memset(type, 0, sizeof(type));
1588         prom_getprop(val, "device_type", type, sizeof(type));
1589         if (strcmp(type, RELOC("display")) == 0)
1590                 prom_setprop(val, path, "linux,boot-display", NULL, 0);
1591 }
1592
1593 static void __init prom_close_stdin(void)
1594 {
1595         struct prom_t *_prom = &RELOC(prom);
1596         ihandle val;
1597
1598         if (prom_getprop(_prom->chosen, "stdin", &val, sizeof(val)) > 0)
1599                 call_prom("close", 1, 0, val);
1600 }
1601
1602 static int __init prom_find_machine_type(void)
1603 {
1604         struct prom_t *_prom = &RELOC(prom);
1605         char compat[256];
1606         int len, i = 0;
1607 #ifdef CONFIG_PPC64
1608         phandle rtas;
1609         int x;
1610 #endif
1611
1612         /* Look for a PowerMac */
1613         len = prom_getprop(_prom->root, "compatible",
1614                            compat, sizeof(compat)-1);
1615         if (len > 0) {
1616                 compat[len] = 0;
1617                 while (i < len) {
1618                         char *p = &compat[i];
1619                         int sl = strlen(p);
1620                         if (sl == 0)
1621                                 break;
1622                         if (strstr(p, RELOC("Power Macintosh")) ||
1623                             strstr(p, RELOC("MacRISC")))
1624                                 return PLATFORM_POWERMAC;
1625                         i += sl + 1;
1626                 }
1627         }
1628 #ifdef CONFIG_PPC64
1629         /* If not a mac, try to figure out if it's an IBM pSeries or any other
1630          * PAPR compliant platform. We assume it is if :
1631          *  - /device_type is "chrp" (please, do NOT use that for future
1632          *    non-IBM designs !
1633          *  - it has /rtas
1634          */
1635         len = prom_getprop(_prom->root, "device_type",
1636                            compat, sizeof(compat)-1);
1637         if (len <= 0)
1638                 return PLATFORM_GENERIC;
1639         if (strcmp(compat, RELOC("chrp")))
1640                 return PLATFORM_GENERIC;
1641
1642         /* Default to pSeries. We need to know if we are running LPAR */
1643         rtas = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1644         if (!PHANDLE_VALID(rtas))
1645                 return PLATFORM_GENERIC;
1646         x = prom_getproplen(rtas, "ibm,hypertas-functions");
1647         if (x != PROM_ERROR) {
1648                 prom_printf("Hypertas detected, assuming LPAR !\n");
1649                 return PLATFORM_PSERIES_LPAR;
1650         }
1651         return PLATFORM_PSERIES;
1652 #else
1653         return PLATFORM_GENERIC;
1654 #endif
1655 }
1656
1657 static int __init prom_set_color(ihandle ih, int i, int r, int g, int b)
1658 {
1659         return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r);
1660 }
1661
1662 /*
1663  * If we have a display that we don't know how to drive,
1664  * we will want to try to execute OF's open method for it
1665  * later.  However, OF will probably fall over if we do that
1666  * we've taken over the MMU.
1667  * So we check whether we will need to open the display,
1668  * and if so, open it now.
1669  */
1670 static void __init prom_check_displays(void)
1671 {
1672         char type[16], *path;
1673         phandle node;
1674         ihandle ih;
1675         int i;
1676
1677         static unsigned char default_colors[] = {
1678                 0x00, 0x00, 0x00,
1679                 0x00, 0x00, 0xaa,
1680                 0x00, 0xaa, 0x00,
1681                 0x00, 0xaa, 0xaa,
1682                 0xaa, 0x00, 0x00,
1683                 0xaa, 0x00, 0xaa,
1684                 0xaa, 0xaa, 0x00,
1685                 0xaa, 0xaa, 0xaa,
1686                 0x55, 0x55, 0x55,
1687                 0x55, 0x55, 0xff,
1688                 0x55, 0xff, 0x55,
1689                 0x55, 0xff, 0xff,
1690                 0xff, 0x55, 0x55,
1691                 0xff, 0x55, 0xff,
1692                 0xff, 0xff, 0x55,
1693                 0xff, 0xff, 0xff
1694         };
1695         const unsigned char *clut;
1696
1697         prom_printf("Looking for displays\n");
1698         for (node = 0; prom_next_node(&node); ) {
1699                 memset(type, 0, sizeof(type));
1700                 prom_getprop(node, "device_type", type, sizeof(type));
1701                 if (strcmp(type, RELOC("display")) != 0)
1702                         continue;
1703
1704                 /* It seems OF doesn't null-terminate the path :-( */
1705                 path = RELOC(prom_scratch);
1706                 memset(path, 0, PROM_SCRATCH_SIZE);
1707
1708                 /*
1709                  * leave some room at the end of the path for appending extra
1710                  * arguments
1711                  */
1712                 if (call_prom("package-to-path", 3, 1, node, path,
1713                               PROM_SCRATCH_SIZE-10) == PROM_ERROR)
1714                         continue;
1715                 prom_printf("found display   : %s, opening ... ", path);
1716                 
1717                 ih = call_prom("open", 1, 1, path);
1718                 if (ih == 0) {
1719                         prom_printf("failed\n");
1720                         continue;
1721                 }
1722
1723                 /* Success */
1724                 prom_printf("done\n");
1725                 prom_setprop(node, path, "linux,opened", NULL, 0);
1726
1727                 /* Setup a usable color table when the appropriate
1728                  * method is available. Should update this to set-colors */
1729                 clut = RELOC(default_colors);
1730                 for (i = 0; i < 32; i++, clut += 3)
1731                         if (prom_set_color(ih, i, clut[0], clut[1],
1732                                            clut[2]) != 0)
1733                                 break;
1734
1735 #ifdef CONFIG_LOGO_LINUX_CLUT224
1736                 clut = PTRRELOC(RELOC(logo_linux_clut224.clut));
1737                 for (i = 0; i < RELOC(logo_linux_clut224.clutsize); i++, clut += 3)
1738                         if (prom_set_color(ih, i + 32, clut[0], clut[1],
1739                                            clut[2]) != 0)
1740                                 break;
1741 #endif /* CONFIG_LOGO_LINUX_CLUT224 */
1742         }
1743 }
1744
1745
1746 /* Return (relocated) pointer to this much memory: moves initrd if reqd. */
1747 static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end,
1748                               unsigned long needed, unsigned long align)
1749 {
1750         void *ret;
1751
1752         *mem_start = _ALIGN(*mem_start, align);
1753         while ((*mem_start + needed) > *mem_end) {
1754                 unsigned long room, chunk;
1755
1756                 prom_debug("Chunk exhausted, claiming more at %x...\n",
1757                            RELOC(alloc_bottom));
1758                 room = RELOC(alloc_top) - RELOC(alloc_bottom);
1759                 if (room > DEVTREE_CHUNK_SIZE)
1760                         room = DEVTREE_CHUNK_SIZE;
1761                 if (room < PAGE_SIZE)
1762                         prom_panic("No memory for flatten_device_tree (no room)");
1763                 chunk = alloc_up(room, 0);
1764                 if (chunk == 0)
1765                         prom_panic("No memory for flatten_device_tree (claim failed)");
1766                 *mem_end = RELOC(alloc_top);
1767         }
1768
1769         ret = (void *)*mem_start;
1770         *mem_start += needed;
1771
1772         return ret;
1773 }
1774
1775 #define dt_push_token(token, mem_start, mem_end) \
1776         do { *((u32 *)make_room(mem_start, mem_end, 4, 4)) = token; } while(0)
1777
1778 static unsigned long __init dt_find_string(char *str)
1779 {
1780         char *s, *os;
1781
1782         s = os = (char *)RELOC(dt_string_start);
1783         s += 4;
1784         while (s <  (char *)RELOC(dt_string_end)) {
1785                 if (strcmp(s, str) == 0)
1786                         return s - os;
1787                 s += strlen(s) + 1;
1788         }
1789         return 0;
1790 }
1791
1792 /*
1793  * The Open Firmware 1275 specification states properties must be 31 bytes or
1794  * less, however not all firmwares obey this. Make it 64 bytes to be safe.
1795  */
1796 #define MAX_PROPERTY_NAME 64
1797
1798 static void __init scan_dt_build_strings(phandle node,
1799                                          unsigned long *mem_start,
1800                                          unsigned long *mem_end)
1801 {
1802         char *prev_name, *namep, *sstart;
1803         unsigned long soff;
1804         phandle child;
1805
1806         sstart =  (char *)RELOC(dt_string_start);
1807
1808         /* get and store all property names */
1809         prev_name = RELOC("");
1810         for (;;) {
1811                 /* 64 is max len of name including nul. */
1812                 namep = make_room(mem_start, mem_end, MAX_PROPERTY_NAME, 1);
1813                 if (call_prom("nextprop", 3, 1, node, prev_name, namep) != 1) {
1814                         /* No more nodes: unwind alloc */
1815                         *mem_start = (unsigned long)namep;
1816                         break;
1817                 }
1818
1819                 /* skip "name" */
1820                 if (strcmp(namep, RELOC("name")) == 0) {
1821                         *mem_start = (unsigned long)namep;
1822                         prev_name = RELOC("name");
1823                         continue;
1824                 }
1825                 /* get/create string entry */
1826                 soff = dt_find_string(namep);
1827                 if (soff != 0) {
1828                         *mem_start = (unsigned long)namep;
1829                         namep = sstart + soff;
1830                 } else {
1831                         /* Trim off some if we can */
1832                         *mem_start = (unsigned long)namep + strlen(namep) + 1;
1833                         RELOC(dt_string_end) = *mem_start;
1834                 }
1835                 prev_name = namep;
1836         }
1837
1838         /* do all our children */
1839         child = call_prom("child", 1, 1, node);
1840         while (child != 0) {
1841                 scan_dt_build_strings(child, mem_start, mem_end);
1842                 child = call_prom("peer", 1, 1, child);
1843         }
1844 }
1845
1846 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
1847                                         unsigned long *mem_end)
1848 {
1849         phandle child;
1850         char *namep, *prev_name, *sstart, *p, *ep, *lp, *path;
1851         unsigned long soff;
1852         unsigned char *valp;
1853         static char pname[MAX_PROPERTY_NAME];
1854         int l, room;
1855
1856         dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end);
1857
1858         /* get the node's full name */
1859         namep = (char *)*mem_start;
1860         room = *mem_end - *mem_start;
1861         if (room > 255)
1862                 room = 255;
1863         l = call_prom("package-to-path", 3, 1, node, namep, room);
1864         if (l >= 0) {
1865                 /* Didn't fit?  Get more room. */
1866                 if (l >= room) {
1867                         if (l >= *mem_end - *mem_start)
1868                                 namep = make_room(mem_start, mem_end, l+1, 1);
1869                         call_prom("package-to-path", 3, 1, node, namep, l);
1870                 }
1871                 namep[l] = '\0';
1872
1873                 /* Fixup an Apple bug where they have bogus \0 chars in the
1874                  * middle of the path in some properties, and extract
1875                  * the unit name (everything after the last '/').
1876                  */
1877                 for (lp = p = namep, ep = namep + l; p < ep; p++) {
1878                         if (*p == '/')
1879                                 lp = namep;
1880                         else if (*p != 0)
1881                                 *lp++ = *p;
1882                 }
1883                 *lp = 0;
1884                 *mem_start = _ALIGN((unsigned long)lp + 1, 4);
1885         }
1886
1887         /* get it again for debugging */
1888         path = RELOC(prom_scratch);
1889         memset(path, 0, PROM_SCRATCH_SIZE);
1890         call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
1891
1892         /* get and store all properties */
1893         prev_name = RELOC("");
1894         sstart = (char *)RELOC(dt_string_start);
1895         for (;;) {
1896                 if (call_prom("nextprop", 3, 1, node, prev_name,
1897                               RELOC(pname)) != 1)
1898                         break;
1899
1900                 /* skip "name" */
1901                 if (strcmp(RELOC(pname), RELOC("name")) == 0) {
1902                         prev_name = RELOC("name");
1903                         continue;
1904                 }
1905
1906                 /* find string offset */
1907                 soff = dt_find_string(RELOC(pname));
1908                 if (soff == 0) {
1909                         prom_printf("WARNING: Can't find string index for"
1910                                     " <%s>, node %s\n", RELOC(pname), path);
1911                         break;
1912                 }
1913                 prev_name = sstart + soff;
1914
1915                 /* get length */
1916                 l = call_prom("getproplen", 2, 1, node, RELOC(pname));
1917
1918                 /* sanity checks */
1919                 if (l == PROM_ERROR)
1920                         continue;
1921                 if (l > MAX_PROPERTY_LENGTH) {
1922                         prom_printf("WARNING: ignoring large property ");
1923                         /* It seems OF doesn't null-terminate the path :-( */
1924                         prom_printf("[%s] ", path);
1925                         prom_printf("%s length 0x%x\n", RELOC(pname), l);
1926                         continue;
1927                 }
1928
1929                 /* push property head */
1930                 dt_push_token(OF_DT_PROP, mem_start, mem_end);
1931                 dt_push_token(l, mem_start, mem_end);
1932                 dt_push_token(soff, mem_start, mem_end);
1933
1934                 /* push property content */
1935                 valp = make_room(mem_start, mem_end, l, 4);
1936                 call_prom("getprop", 4, 1, node, RELOC(pname), valp, l);
1937                 *mem_start = _ALIGN(*mem_start, 4);
1938         }
1939
1940         /* Add a "linux,phandle" property. */
1941         soff = dt_find_string(RELOC("linux,phandle"));
1942         if (soff == 0)
1943                 prom_printf("WARNING: Can't find string index for"
1944                             " <linux-phandle> node %s\n", path);
1945         else {
1946                 dt_push_token(OF_DT_PROP, mem_start, mem_end);
1947                 dt_push_token(4, mem_start, mem_end);
1948                 dt_push_token(soff, mem_start, mem_end);
1949                 valp = make_room(mem_start, mem_end, 4, 4);
1950                 *(u32 *)valp = node;
1951         }
1952
1953         /* do all our children */
1954         child = call_prom("child", 1, 1, node);
1955         while (child != 0) {
1956                 scan_dt_build_struct(child, mem_start, mem_end);
1957                 child = call_prom("peer", 1, 1, child);
1958         }
1959
1960         dt_push_token(OF_DT_END_NODE, mem_start, mem_end);
1961 }
1962
1963 static void __init flatten_device_tree(void)
1964 {
1965         phandle root;
1966         unsigned long mem_start, mem_end, room;
1967         struct boot_param_header *hdr;
1968         struct prom_t *_prom = &RELOC(prom);
1969         char *namep;
1970         u64 *rsvmap;
1971
1972         /*
1973          * Check how much room we have between alloc top & bottom (+/- a
1974          * few pages), crop to 4Mb, as this is our "chuck" size
1975          */
1976         room = RELOC(alloc_top) - RELOC(alloc_bottom) - 0x4000;
1977         if (room > DEVTREE_CHUNK_SIZE)
1978                 room = DEVTREE_CHUNK_SIZE;
1979         prom_debug("starting device tree allocs at %x\n", RELOC(alloc_bottom));
1980
1981         /* Now try to claim that */
1982         mem_start = (unsigned long)alloc_up(room, PAGE_SIZE);
1983         if (mem_start == 0)
1984                 prom_panic("Can't allocate initial device-tree chunk\n");
1985         mem_end = RELOC(alloc_top);
1986
1987         /* Get root of tree */
1988         root = call_prom("peer", 1, 1, (phandle)0);
1989         if (root == (phandle)0)
1990                 prom_panic ("couldn't get device tree root\n");
1991
1992         /* Build header and make room for mem rsv map */ 
1993         mem_start = _ALIGN(mem_start, 4);
1994         hdr = make_room(&mem_start, &mem_end,
1995                         sizeof(struct boot_param_header), 4);
1996         RELOC(dt_header_start) = (unsigned long)hdr;
1997         rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8);
1998
1999         /* Start of strings */
2000         mem_start = PAGE_ALIGN(mem_start);
2001         RELOC(dt_string_start) = mem_start;
2002         mem_start += 4; /* hole */
2003
2004         /* Add "linux,phandle" in there, we'll need it */
2005         namep = make_room(&mem_start, &mem_end, 16, 1);
2006         strcpy(namep, RELOC("linux,phandle"));
2007         mem_start = (unsigned long)namep + strlen(namep) + 1;
2008
2009         /* Build string array */
2010         prom_printf("Building dt strings...\n"); 
2011         scan_dt_build_strings(root, &mem_start, &mem_end);
2012         RELOC(dt_string_end) = mem_start;
2013
2014         /* Build structure */
2015         mem_start = PAGE_ALIGN(mem_start);
2016         RELOC(dt_struct_start) = mem_start;
2017         prom_printf("Building dt structure...\n"); 
2018         scan_dt_build_struct(root, &mem_start, &mem_end);
2019         dt_push_token(OF_DT_END, &mem_start, &mem_end);
2020         RELOC(dt_struct_end) = PAGE_ALIGN(mem_start);
2021
2022         /* Finish header */
2023         hdr->boot_cpuid_phys = _prom->cpu;
2024         hdr->magic = OF_DT_HEADER;
2025         hdr->totalsize = RELOC(dt_struct_end) - RELOC(dt_header_start);
2026         hdr->off_dt_struct = RELOC(dt_struct_start) - RELOC(dt_header_start);
2027         hdr->off_dt_strings = RELOC(dt_string_start) - RELOC(dt_header_start);
2028         hdr->dt_strings_size = RELOC(dt_string_end) - RELOC(dt_string_start);
2029         hdr->off_mem_rsvmap = ((unsigned long)rsvmap) - RELOC(dt_header_start);
2030         hdr->version = OF_DT_VERSION;
2031         /* Version 16 is not backward compatible */
2032         hdr->last_comp_version = 0x10;
2033
2034         /* Reserve the whole thing and copy the reserve map in, we
2035          * also bump mem_reserve_cnt to cause further reservations to
2036          * fail since it's too late.
2037          */
2038         reserve_mem(RELOC(dt_header_start), hdr->totalsize);
2039         memcpy(rsvmap, RELOC(mem_reserve_map), sizeof(mem_reserve_map));
2040
2041 #ifdef DEBUG_PROM
2042         {
2043                 int i;
2044                 prom_printf("reserved memory map:\n");
2045                 for (i = 0; i < RELOC(mem_reserve_cnt); i++)
2046                         prom_printf("  %x - %x\n",
2047                                     RELOC(mem_reserve_map)[i].base,
2048                                     RELOC(mem_reserve_map)[i].size);
2049         }
2050 #endif
2051         RELOC(mem_reserve_cnt) = MEM_RESERVE_MAP_SIZE;
2052
2053         prom_printf("Device tree strings 0x%x -> 0x%x\n",
2054                     RELOC(dt_string_start), RELOC(dt_string_end)); 
2055         prom_printf("Device tree struct  0x%x -> 0x%x\n",
2056                     RELOC(dt_struct_start), RELOC(dt_struct_end));
2057
2058 }
2059
2060
2061 static void __init fixup_device_tree(void)
2062 {
2063 #if defined(CONFIG_PPC64) && defined(CONFIG_PPC_PMAC)
2064         phandle u3, i2c, mpic;
2065         u32 u3_rev;
2066         u32 interrupts[2];
2067         u32 parent;
2068
2069         /* Some G5s have a missing interrupt definition, fix it up here */
2070         u3 = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000"));
2071         if (!PHANDLE_VALID(u3))
2072                 return;
2073         i2c = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/i2c@f8001000"));
2074         if (!PHANDLE_VALID(i2c))
2075                 return;
2076         mpic = call_prom("finddevice", 1, 1, ADDR("/u3@0,f8000000/mpic@f8040000"));
2077         if (!PHANDLE_VALID(mpic))
2078                 return;
2079
2080         /* check if proper rev of u3 */
2081         if (prom_getprop(u3, "device-rev", &u3_rev, sizeof(u3_rev))
2082             == PROM_ERROR)
2083                 return;
2084         if (u3_rev < 0x35 || u3_rev > 0x39)
2085                 return;
2086         /* does it need fixup ? */
2087         if (prom_getproplen(i2c, "interrupts") > 0)
2088                 return;
2089
2090         prom_printf("fixing up bogus interrupts for u3 i2c...\n");
2091
2092         /* interrupt on this revision of u3 is number 0 and level */
2093         interrupts[0] = 0;
2094         interrupts[1] = 1;
2095         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupts",
2096                      &interrupts, sizeof(interrupts));
2097         parent = (u32)mpic;
2098         prom_setprop(i2c, "/u3@0,f8000000/i2c@f8001000", "interrupt-parent",
2099                      &parent, sizeof(parent));
2100 #endif
2101 }
2102
2103
2104 static void __init prom_find_boot_cpu(void)
2105 {
2106         struct prom_t *_prom = &RELOC(prom);
2107         u32 getprop_rval;
2108         ihandle prom_cpu;
2109         phandle cpu_pkg;
2110
2111         _prom->cpu = 0;
2112         if (prom_getprop(_prom->chosen, "cpu", &prom_cpu, sizeof(prom_cpu)) <= 0)
2113                 return;
2114
2115         cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
2116
2117         prom_getprop(cpu_pkg, "reg", &getprop_rval, sizeof(getprop_rval));
2118         _prom->cpu = getprop_rval;
2119
2120         prom_debug("Booting CPU hw index = 0x%x\n", _prom->cpu);
2121 }
2122
2123 static void __init prom_check_initrd(unsigned long r3, unsigned long r4)
2124 {
2125 #ifdef CONFIG_BLK_DEV_INITRD
2126         struct prom_t *_prom = &RELOC(prom);
2127
2128         if (r3 && r4 && r4 != 0xdeadbeef) {
2129                 unsigned long val;
2130
2131                 RELOC(prom_initrd_start) = is_kernel_addr(r3) ? __pa(r3) : r3;
2132                 RELOC(prom_initrd_end) = RELOC(prom_initrd_start) + r4;
2133
2134                 val = RELOC(prom_initrd_start);
2135                 prom_setprop(_prom->chosen, "/chosen", "linux,initrd-start",
2136                              &val, sizeof(val));
2137                 val = RELOC(prom_initrd_end);
2138                 prom_setprop(_prom->chosen, "/chosen", "linux,initrd-end",
2139                              &val, sizeof(val));
2140
2141                 reserve_mem(RELOC(prom_initrd_start),
2142                             RELOC(prom_initrd_end) - RELOC(prom_initrd_start));
2143
2144                 prom_debug("initrd_start=0x%x\n", RELOC(prom_initrd_start));
2145                 prom_debug("initrd_end=0x%x\n", RELOC(prom_initrd_end));
2146         }
2147 #endif /* CONFIG_BLK_DEV_INITRD */
2148 }
2149
2150 /*
2151  * We enter here early on, when the Open Firmware prom is still
2152  * handling exceptions and the MMU hash table for us.
2153  */
2154
2155 unsigned long __init prom_init(unsigned long r3, unsigned long r4,
2156                                unsigned long pp,
2157                                unsigned long r6, unsigned long r7)
2158 {       
2159         struct prom_t *_prom;
2160         unsigned long hdr;
2161         unsigned long offset = reloc_offset();
2162
2163 #ifdef CONFIG_PPC32
2164         reloc_got2(offset);
2165 #endif
2166
2167         _prom = &RELOC(prom);
2168
2169         /*
2170          * First zero the BSS
2171          */
2172         memset(&RELOC(__bss_start), 0, __bss_stop - __bss_start);
2173
2174         /*
2175          * Init interface to Open Firmware, get some node references,
2176          * like /chosen
2177          */
2178         prom_init_client_services(pp);
2179
2180         /*
2181          * See if this OF is old enough that we need to do explicit maps
2182          * and other workarounds
2183          */
2184         prom_find_mmu();
2185
2186         /*
2187          * Init prom stdout device
2188          */
2189         prom_init_stdout();
2190
2191         /*
2192          * Get default machine type. At this point, we do not differentiate
2193          * between pSeries SMP and pSeries LPAR
2194          */
2195         RELOC(of_platform) = prom_find_machine_type();
2196
2197         /* Bail if this is a kdump kernel. */
2198         if (PHYSICAL_START > 0)
2199                 prom_panic("Error: You can't boot a kdump kernel from OF!\n");
2200
2201         /*
2202          * Check for an initrd
2203          */
2204         prom_check_initrd(r3, r4);
2205
2206 #ifdef CONFIG_PPC_PSERIES
2207         /*
2208          * On pSeries, inform the firmware about our capabilities
2209          */
2210         if (RELOC(of_platform) == PLATFORM_PSERIES ||
2211             RELOC(of_platform) == PLATFORM_PSERIES_LPAR)
2212                 prom_send_capabilities();
2213 #endif
2214
2215         /*
2216          * Copy the CPU hold code
2217          */
2218         if (RELOC(of_platform) != PLATFORM_POWERMAC)
2219                 copy_and_flush(0, KERNELBASE + offset, 0x100, 0);
2220
2221         /*
2222          * Do early parsing of command line
2223          */
2224         early_cmdline_parse();
2225
2226         /*
2227          * Initialize memory management within prom_init
2228          */
2229         prom_init_mem();
2230
2231 #ifdef CONFIG_KEXEC
2232         if (RELOC(prom_crashk_base))
2233                 reserve_mem(RELOC(prom_crashk_base), RELOC(prom_crashk_size));
2234 #endif
2235         /*
2236          * Determine which cpu is actually running right _now_
2237          */
2238         prom_find_boot_cpu();
2239
2240         /* 
2241          * Initialize display devices
2242          */
2243         prom_check_displays();
2244
2245 #ifdef CONFIG_PPC64
2246         /*
2247          * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else
2248          * that uses the allocator, we need to make sure we get the top of memory
2249          * available for us here...
2250          */
2251         if (RELOC(of_platform) == PLATFORM_PSERIES)
2252                 prom_initialize_tce_table();
2253 #endif
2254
2255         /*
2256          * On non-powermacs, try to instantiate RTAS and puts all CPUs
2257          * in spin-loops. PowerMacs don't have a working RTAS and use
2258          * a different way to spin CPUs
2259          */
2260         if (RELOC(of_platform) != PLATFORM_POWERMAC) {
2261                 prom_instantiate_rtas();
2262                 prom_hold_cpus();
2263         }
2264
2265         /*
2266          * Fill in some infos for use by the kernel later on
2267          */
2268         if (RELOC(prom_memory_limit))
2269                 prom_setprop(_prom->chosen, "/chosen", "linux,memory-limit",
2270                              &RELOC(prom_memory_limit),
2271                              sizeof(prom_memory_limit));
2272 #ifdef CONFIG_PPC64
2273         if (RELOC(ppc64_iommu_off))
2274                 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-off",
2275                              NULL, 0);
2276
2277         if (RELOC(iommu_force_on))
2278                 prom_setprop(_prom->chosen, "/chosen", "linux,iommu-force-on",
2279                              NULL, 0);
2280
2281         if (RELOC(prom_tce_alloc_start)) {
2282                 prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-start",
2283                              &RELOC(prom_tce_alloc_start),
2284                              sizeof(prom_tce_alloc_start));
2285                 prom_setprop(_prom->chosen, "/chosen", "linux,tce-alloc-end",
2286                              &RELOC(prom_tce_alloc_end),
2287                              sizeof(prom_tce_alloc_end));
2288         }
2289 #endif
2290
2291 #ifdef CONFIG_KEXEC
2292         if (RELOC(prom_crashk_base)) {
2293                 prom_setprop(_prom->chosen, "/chosen", "linux,crashkernel-base",
2294                         PTRRELOC(&prom_crashk_base),
2295                         sizeof(RELOC(prom_crashk_base)));
2296                 prom_setprop(_prom->chosen, "/chosen", "linux,crashkernel-size",
2297                         PTRRELOC(&prom_crashk_size),
2298                         sizeof(RELOC(prom_crashk_size)));
2299         }
2300 #endif
2301         /*
2302          * Fixup any known bugs in the device-tree
2303          */
2304         fixup_device_tree();
2305
2306         /*
2307          * Now finally create the flattened device-tree
2308          */
2309         prom_printf("copying OF device tree ...\n");
2310         flatten_device_tree();
2311
2312         /*
2313          * in case stdin is USB and still active on IBM machines...
2314          * Unfortunately quiesce crashes on some powermacs if we have
2315          * closed stdin already (in particular the powerbook 101).
2316          */
2317         if (RELOC(of_platform) != PLATFORM_POWERMAC)
2318                 prom_close_stdin();
2319
2320         /*
2321          * Call OF "quiesce" method to shut down pending DMA's from
2322          * devices etc...
2323          */
2324         prom_printf("Calling quiesce ...\n");
2325         call_prom("quiesce", 0, 0);
2326
2327         /*
2328          * And finally, call the kernel passing it the flattened device
2329          * tree and NULL as r5, thus triggering the new entry point which
2330          * is common to us and kexec
2331          */
2332         hdr = RELOC(dt_header_start);
2333         prom_printf("returning from prom_init\n");
2334         prom_debug("->dt_header_start=0x%x\n", hdr);
2335
2336 #ifdef CONFIG_PPC32
2337         reloc_got2(-offset);
2338 #endif
2339
2340         __start(hdr, KERNELBASE + offset, 0);
2341
2342         return 0;
2343 }