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