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