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