4 * Procedures for interfacing to Open Firmware.
6 * Paul Mackerras August 1996.
7 * Copyright (C) 1996 Paul Mackerras.
9 * Adapted for 64bit PowerPC by Dave Engebretsen and Peter Bergner.
10 * {engebret|bergner}@us.ibm.com
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License
14 * as published by the Free Software Foundation; either version
15 * 2 of the License, or (at your option) any later version.
21 #include <linux/config.h>
22 #include <linux/kernel.h>
23 #include <linux/string.h>
24 #include <linux/init.h>
25 #include <linux/version.h>
26 #include <linux/threads.h>
27 #include <linux/spinlock.h>
28 #include <linux/types.h>
29 #include <linux/pci.h>
30 #include <linux/proc_fs.h>
31 #include <linux/stringify.h>
32 #include <linux/delay.h>
33 #include <linux/initrd.h>
34 #include <linux/bitops.h>
37 #include <asm/abs_addr.h>
39 #include <asm/processor.h>
43 #include <asm/system.h>
45 #include <asm/pgtable.h>
47 #include <asm/iommu.h>
48 #include <asm/bootinfo.h>
49 #include <asm/ppcdebug.h>
50 #include <asm/btext.h>
51 #include <asm/sections.h>
52 #include <asm/machdep.h>
54 #ifdef CONFIG_LOGO_LINUX_CLUT224
55 #include <linux/linux_logo.h>
56 extern const struct linux_logo logo_linux_clut224;
60 * Properties whose value is longer than this get excluded from our
61 * copy of the device tree. This value does need to be big enough to
62 * ensure that we don't lose things like the interrupt-map property
63 * on a PCI-PCI bridge.
65 #define MAX_PROPERTY_LENGTH (1UL * 1024 * 1024)
68 * Eventually bump that one up
70 #define DEVTREE_CHUNK_SIZE 0x100000
73 * This is the size of the local memory reserve map that gets copied
74 * into the boot params passed to the kernel. That size is totally
75 * flexible as the kernel just reads the list until it encounters an
76 * entry with size 0, so it can be changed without breaking binary
79 #define MEM_RESERVE_MAP_SIZE 8
82 * prom_init() is called very early on, before the kernel text
83 * and data have been mapped to KERNELBASE. At this point the code
84 * is running at whatever address it has been loaded at, so
85 * references to extern and static variables must be relocated
86 * explicitly. The procedure reloc_offset() returns the address
87 * we're currently running at minus the address we were linked at.
88 * (Note that strings count as static variables.)
90 * Because OF may have mapped I/O devices into the area starting at
91 * KERNELBASE, particularly on CHRP machines, we can't safely call
92 * OF once the kernel has been mapped to KERNELBASE. Therefore all
93 * OF calls should be done within prom_init(), and prom_init()
94 * and all routines called within it must be careful to relocate
95 * references as necessary.
97 * Note that the bss is cleared *after* prom_init runs, so we have
98 * to make sure that any static or extern variables it accesses
99 * are put in the data segment.
103 #define PROM_BUG() do { \
104 prom_printf("kernel BUG at %s line 0x%x!\n", \
105 RELOC(__FILE__), __LINE__); \
106 __asm__ __volatile__(".long " BUG_ILLEGAL_INSTR); \
110 #define prom_debug(x...) prom_printf(x)
112 #define prom_debug(x...)
116 typedef u32 prom_arg_t;
123 prom_arg_t *rets; /* Pointer to return values in args[16]. */
133 struct prom_args args;
134 unsigned long version;
135 unsigned long root_size_cells;
136 unsigned long root_addr_cells;
139 struct pci_reg_property {
140 struct pci_address addr;
145 struct mem_map_entry {
152 extern void __start(unsigned long r3, unsigned long r4, unsigned long r5);
154 extern void enter_prom(struct prom_args *args, unsigned long entry);
155 extern void copy_and_flush(unsigned long dest, unsigned long src,
156 unsigned long size, unsigned long offset);
158 extern unsigned long klimit;
161 static struct prom_t __initdata prom;
163 #define PROM_SCRATCH_SIZE 256
165 static char __initdata of_stdout_device[256];
166 static char __initdata prom_scratch[PROM_SCRATCH_SIZE];
168 static unsigned long __initdata dt_header_start;
169 static unsigned long __initdata dt_struct_start, dt_struct_end;
170 static unsigned long __initdata dt_string_start, dt_string_end;
172 static unsigned long __initdata prom_initrd_start, prom_initrd_end;
174 static int __initdata iommu_force_on;
175 static int __initdata ppc64_iommu_off;
176 static int __initdata of_platform;
178 static char __initdata prom_cmd_line[COMMAND_LINE_SIZE];
180 static unsigned long __initdata prom_memory_limit;
181 static unsigned long __initdata prom_tce_alloc_start;
182 static unsigned long __initdata prom_tce_alloc_end;
184 static unsigned long __initdata alloc_top;
185 static unsigned long __initdata alloc_top_high;
186 static unsigned long __initdata alloc_bottom;
187 static unsigned long __initdata rmo_top;
188 static unsigned long __initdata ram_top;
190 static struct mem_map_entry __initdata mem_reserve_map[MEM_RESERVE_MAP_SIZE];
191 static int __initdata mem_reserve_cnt;
193 static cell_t __initdata regbuf[1024];
196 #define MAX_CPU_THREADS 2
202 unsigned int threadid;
203 } hmt_thread_data[NR_CPUS];
204 #endif /* CONFIG_HMT */
207 * This are used in calls to call_prom. The 4th and following
208 * arguments to call_prom should be 32-bit values. 64 bit values
209 * are truncated to 32 bits (and fortunately don't get interpreted
212 #define ADDR(x) (u32) ((unsigned long)(x) - offset)
214 /* This is the one and *ONLY* place where we actually call open
215 * firmware from, since we need to make sure we're running in 32b
216 * mode when we do. We switch back to 64b mode upon return.
219 #define PROM_ERROR (-1)
221 static int __init call_prom(const char *service, int nargs, int nret, ...)
224 unsigned long offset = reloc_offset();
225 struct prom_t *_prom = PTRRELOC(&prom);
228 _prom->args.service = ADDR(service);
229 _prom->args.nargs = nargs;
230 _prom->args.nret = nret;
231 _prom->args.rets = (prom_arg_t *)&(_prom->args.args[nargs]);
233 va_start(list, nret);
234 for (i=0; i < nargs; i++)
235 _prom->args.args[i] = va_arg(list, prom_arg_t);
238 for (i=0; i < nret ;i++)
239 _prom->args.rets[i] = 0;
241 enter_prom(&_prom->args, _prom->entry);
243 return (nret > 0) ? _prom->args.rets[0] : 0;
247 static unsigned int __init prom_claim(unsigned long virt, unsigned long size,
250 return (unsigned int)call_prom("claim", 3, 1,
251 (prom_arg_t)virt, (prom_arg_t)size,
255 static void __init prom_print(const char *msg)
258 unsigned long offset = reloc_offset();
259 struct prom_t *_prom = PTRRELOC(&prom);
261 if (_prom->stdout == 0)
264 for (p = msg; *p != 0; p = q) {
265 for (q = p; *q != 0 && *q != '\n'; ++q)
268 call_prom("write", 3, 1, _prom->stdout, p, q - p);
272 call_prom("write", 3, 1, _prom->stdout, ADDR("\r\n"), 2);
277 static void __init prom_print_hex(unsigned long val)
279 unsigned long offset = reloc_offset();
280 int i, nibbles = sizeof(val)*2;
281 char buf[sizeof(val)*2+1];
282 struct prom_t *_prom = PTRRELOC(&prom);
284 for (i = nibbles-1; i >= 0; i--) {
285 buf[i] = (val & 0xf) + '0';
287 buf[i] += ('a'-'0'-10);
291 call_prom("write", 3, 1, _prom->stdout, buf, nibbles);
295 static void __init prom_printf(const char *format, ...)
297 unsigned long offset = reloc_offset();
298 const char *p, *q, *s;
301 struct prom_t *_prom = PTRRELOC(&prom);
303 va_start(args, format);
304 for (p = PTRRELOC(format); *p != 0; p = q) {
305 for (q = p; *q != 0 && *q != '\n' && *q != '%'; ++q)
308 call_prom("write", 3, 1, _prom->stdout, p, q - p);
313 call_prom("write", 3, 1, _prom->stdout,
323 s = va_arg(args, const char *);
328 v = va_arg(args, unsigned long);
336 static void __init __attribute__((noreturn)) prom_panic(const char *reason)
338 unsigned long offset = reloc_offset();
340 prom_print(PTRRELOC(reason));
341 /* ToDo: should put up an SRC here */
342 call_prom("exit", 0, 0);
344 for (;;) /* should never get here */
349 static int __init prom_next_node(phandle *nodep)
353 if ((node = *nodep) != 0
354 && (*nodep = call_prom("child", 1, 1, node)) != 0)
356 if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
359 if ((node = call_prom("parent", 1, 1, node)) == 0)
361 if ((*nodep = call_prom("peer", 1, 1, node)) != 0)
366 static int __init prom_getprop(phandle node, const char *pname,
367 void *value, size_t valuelen)
369 unsigned long offset = reloc_offset();
371 return call_prom("getprop", 4, 1, node, ADDR(pname),
372 (u32)(unsigned long) value, (u32) valuelen);
375 static int __init prom_getproplen(phandle node, const char *pname)
377 unsigned long offset = reloc_offset();
379 return call_prom("getproplen", 2, 1, node, ADDR(pname));
382 static int __init prom_setprop(phandle node, const char *pname,
383 void *value, size_t valuelen)
385 unsigned long offset = reloc_offset();
387 return call_prom("setprop", 4, 1, node, ADDR(pname),
388 (u32)(unsigned long) value, (u32) valuelen);
391 /* We can't use the standard versions because of RELOC headaches. */
392 #define isxdigit(c) (('0' <= (c) && (c) <= '9') \
393 || ('a' <= (c) && (c) <= 'f') \
394 || ('A' <= (c) && (c) <= 'F'))
396 #define isdigit(c) ('0' <= (c) && (c) <= '9')
397 #define islower(c) ('a' <= (c) && (c) <= 'z')
398 #define toupper(c) (islower(c) ? ((c) - 'a' + 'A') : (c))
400 unsigned long prom_strtoul(const char *cp, const char **endp)
402 unsigned long result = 0, base = 10, value;
407 if (toupper(*cp) == 'X') {
413 while (isxdigit(*cp) &&
414 (value = isdigit(*cp) ? *cp - '0' : toupper(*cp) - 'A' + 10) < base) {
415 result = result * base + value;
425 unsigned long prom_memparse(const char *ptr, const char **retptr)
427 unsigned long ret = prom_strtoul(ptr, retptr);
431 * We can't use a switch here because GCC *may* generate a
432 * jump table which won't work, because we're not running at
433 * the address we're linked at.
435 if ('G' == **retptr || 'g' == **retptr)
438 if ('M' == **retptr || 'm' == **retptr)
441 if ('K' == **retptr || 'k' == **retptr)
453 * Early parsing of the command line passed to the kernel, used for
454 * "mem=x" and the options that affect the iommu
456 static void __init early_cmdline_parse(void)
458 unsigned long offset = reloc_offset();
459 struct prom_t *_prom = PTRRELOC(&prom);
463 RELOC(prom_cmd_line[0]) = 0;
464 p = RELOC(prom_cmd_line);
465 if ((long)_prom->chosen > 0)
466 l = prom_getprop(_prom->chosen, "bootargs", p, COMMAND_LINE_SIZE-1);
467 #ifdef CONFIG_CMDLINE
468 if (l == 0) /* dbl check */
469 strlcpy(RELOC(prom_cmd_line),
470 RELOC(CONFIG_CMDLINE), sizeof(prom_cmd_line));
471 #endif /* CONFIG_CMDLINE */
472 prom_printf("command line: %s\n", RELOC(prom_cmd_line));
474 opt = strstr(RELOC(prom_cmd_line), RELOC("iommu="));
476 prom_printf("iommu opt is: %s\n", opt);
478 while (*opt && *opt == ' ')
480 if (!strncmp(opt, RELOC("off"), 3))
481 RELOC(ppc64_iommu_off) = 1;
482 else if (!strncmp(opt, RELOC("force"), 5))
483 RELOC(iommu_force_on) = 1;
486 opt = strstr(RELOC(prom_cmd_line), RELOC("mem="));
489 RELOC(prom_memory_limit) = prom_memparse(opt, (const char **)&opt);
490 /* Align to 16 MB == size of large page */
491 RELOC(prom_memory_limit) = ALIGN(RELOC(prom_memory_limit), 0x1000000);
496 * Memory allocation strategy... our layout is normally:
498 * at 14Mb or more we vmlinux, then a gap and initrd. In some rare cases, initrd
499 * might end up beeing before the kernel though. We assume this won't override
500 * the final kernel at 0, we have no provision to handle that in this version,
501 * but it should hopefully never happen.
503 * alloc_top is set to the top of RMO, eventually shrink down if the TCEs overlap
504 * alloc_bottom is set to the top of kernel/initrd
506 * from there, allocations are done that way : rtas is allocated topmost, and
507 * the device-tree is allocated from the bottom. We try to grow the device-tree
508 * allocation as we progress. If we can't, then we fail, we don't currently have
509 * a facility to restart elsewhere, but that shouldn't be necessary neither
511 * Note that calls to reserve_mem have to be done explicitely, memory allocated
512 * with either alloc_up or alloc_down isn't automatically reserved.
517 * Allocates memory in the RMO upward from the kernel/initrd
519 * When align is 0, this is a special case, it means to allocate in place
520 * at the current location of alloc_bottom or fail (that is basically
521 * extending the previous allocation). Used for the device-tree flattening
523 static unsigned long __init alloc_up(unsigned long size, unsigned long align)
525 unsigned long offset = reloc_offset();
526 unsigned long base = _ALIGN_UP(RELOC(alloc_bottom), align);
527 unsigned long addr = 0;
529 prom_debug("alloc_up(%x, %x)\n", size, align);
530 if (RELOC(ram_top) == 0)
531 prom_panic("alloc_up() called with mem not initialized\n");
534 base = _ALIGN_UP(RELOC(alloc_bottom), align);
536 base = RELOC(alloc_bottom);
538 for(; (base + size) <= RELOC(alloc_top);
539 base = _ALIGN_UP(base + 0x100000, align)) {
540 prom_debug(" trying: 0x%x\n\r", base);
541 addr = (unsigned long)prom_claim(base, size, 0);
542 if ((int)addr != PROM_ERROR)
550 RELOC(alloc_bottom) = addr;
552 prom_debug(" -> %x\n", addr);
553 prom_debug(" alloc_bottom : %x\n", RELOC(alloc_bottom));
554 prom_debug(" alloc_top : %x\n", RELOC(alloc_top));
555 prom_debug(" alloc_top_hi : %x\n", RELOC(alloc_top_high));
556 prom_debug(" rmo_top : %x\n", RELOC(rmo_top));
557 prom_debug(" ram_top : %x\n", RELOC(ram_top));
563 * Allocates memory downard, either from top of RMO, or if highmem
564 * is set, from the top of RAM. Note that this one doesn't handle
565 * failures. In does claim memory if highmem is not set.
567 static unsigned long __init alloc_down(unsigned long size, unsigned long align,
570 unsigned long offset = reloc_offset();
571 unsigned long base, addr = 0;
573 prom_debug("alloc_down(%x, %x, %s)\n", size, align,
574 highmem ? RELOC("(high)") : RELOC("(low)"));
575 if (RELOC(ram_top) == 0)
576 prom_panic("alloc_down() called with mem not initialized\n");
579 /* Carve out storage for the TCE table. */
580 addr = _ALIGN_DOWN(RELOC(alloc_top_high) - size, align);
581 if (addr <= RELOC(alloc_bottom))
584 /* Will we bump into the RMO ? If yes, check out that we
585 * didn't overlap existing allocations there, if we did,
586 * we are dead, we must be the first in town !
588 if (addr < RELOC(rmo_top)) {
589 /* Good, we are first */
590 if (RELOC(alloc_top) == RELOC(rmo_top))
591 RELOC(alloc_top) = RELOC(rmo_top) = addr;
595 RELOC(alloc_top_high) = addr;
600 base = _ALIGN_DOWN(RELOC(alloc_top) - size, align);
601 for(; base > RELOC(alloc_bottom); base = _ALIGN_DOWN(base - 0x100000, align)) {
602 prom_debug(" trying: 0x%x\n\r", base);
603 addr = (unsigned long)prom_claim(base, size, 0);
604 if ((int)addr != PROM_ERROR)
610 RELOC(alloc_top) = addr;
613 prom_debug(" -> %x\n", addr);
614 prom_debug(" alloc_bottom : %x\n", RELOC(alloc_bottom));
615 prom_debug(" alloc_top : %x\n", RELOC(alloc_top));
616 prom_debug(" alloc_top_hi : %x\n", RELOC(alloc_top_high));
617 prom_debug(" rmo_top : %x\n", RELOC(rmo_top));
618 prom_debug(" ram_top : %x\n", RELOC(ram_top));
626 static unsigned long __init prom_next_cell(int s, cell_t **cellp)
631 /* Ignore more than 2 cells */
647 * Very dumb function for adding to the memory reserve list, but
648 * we don't need anything smarter at this point
650 * XXX Eventually check for collisions. They should NEVER happen
651 * if problems seem to show up, it would be a good start to track
654 static void reserve_mem(unsigned long base, unsigned long size)
656 unsigned long offset = reloc_offset();
657 unsigned long top = base + size;
658 unsigned long cnt = RELOC(mem_reserve_cnt);
663 /* We need to always keep one empty entry so that we
664 * have our terminator with "size" set to 0 since we are
665 * dumb and just copy this entire array to the boot params
667 base = _ALIGN_DOWN(base, PAGE_SIZE);
668 top = _ALIGN_UP(top, PAGE_SIZE);
671 if (cnt >= (MEM_RESERVE_MAP_SIZE - 1))
672 prom_panic("Memory reserve map exhausted !\n");
673 RELOC(mem_reserve_map)[cnt].base = base;
674 RELOC(mem_reserve_map)[cnt].size = size;
675 RELOC(mem_reserve_cnt) = cnt + 1;
679 * Initialize memory allocation mecanism, parse "memory" nodes and
680 * obtain that way the top of memory and RMO to setup out local allocator
682 static void __init prom_init_mem(void)
685 char *path, type[64];
688 unsigned long offset = reloc_offset();
689 struct prom_t *_prom = PTRRELOC(&prom);
692 * We iterate the memory nodes to find
693 * 1) top of RMO (first node)
696 prom_debug("root_addr_cells: %x\n", (long)_prom->root_addr_cells);
697 prom_debug("root_size_cells: %x\n", (long)_prom->root_size_cells);
699 prom_debug("scanning memory:\n");
700 path = RELOC(prom_scratch);
702 for (node = 0; prom_next_node(&node); ) {
704 prom_getprop(node, "device_type", type, sizeof(type));
706 if (strcmp(type, RELOC("memory")))
709 plen = prom_getprop(node, "reg", RELOC(regbuf), sizeof(regbuf));
710 if (plen > sizeof(regbuf)) {
711 prom_printf("memory node too large for buffer !\n");
712 plen = sizeof(regbuf);
715 endp = p + (plen / sizeof(cell_t));
718 memset(path, 0, PROM_SCRATCH_SIZE);
719 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
720 prom_debug(" node %s :\n", path);
721 #endif /* DEBUG_PROM */
723 while ((endp - p) >= (_prom->root_addr_cells + _prom->root_size_cells)) {
724 unsigned long base, size;
726 base = prom_next_cell(_prom->root_addr_cells, &p);
727 size = prom_next_cell(_prom->root_size_cells, &p);
731 prom_debug(" %x %x\n", base, size);
733 RELOC(rmo_top) = size;
734 if ((base + size) > RELOC(ram_top))
735 RELOC(ram_top) = base + size;
739 RELOC(alloc_bottom) = PAGE_ALIGN(RELOC(klimit) - offset + 0x4000);
741 /* Check if we have an initrd after the kernel, if we do move our bottom
744 if (RELOC(prom_initrd_start)) {
745 if (RELOC(prom_initrd_end) > RELOC(alloc_bottom))
746 RELOC(alloc_bottom) = PAGE_ALIGN(RELOC(prom_initrd_end));
750 * If prom_memory_limit is set we reduce the upper limits *except* for
751 * alloc_top_high. This must be the real top of RAM so we can put
755 RELOC(alloc_top_high) = RELOC(ram_top);
757 if (RELOC(prom_memory_limit)) {
758 if (RELOC(prom_memory_limit) <= RELOC(alloc_bottom)) {
759 prom_printf("Ignoring mem=%x <= alloc_bottom.\n",
760 RELOC(prom_memory_limit));
761 RELOC(prom_memory_limit) = 0;
762 } else if (RELOC(prom_memory_limit) >= RELOC(ram_top)) {
763 prom_printf("Ignoring mem=%x >= ram_top.\n",
764 RELOC(prom_memory_limit));
765 RELOC(prom_memory_limit) = 0;
767 RELOC(ram_top) = RELOC(prom_memory_limit);
768 RELOC(rmo_top) = min(RELOC(rmo_top), RELOC(prom_memory_limit));
773 * Setup our top alloc point, that is top of RMO or top of
774 * segment 0 when running non-LPAR.
776 if ( RELOC(of_platform) == PLATFORM_PSERIES_LPAR )
777 RELOC(alloc_top) = RELOC(rmo_top);
779 RELOC(alloc_top) = RELOC(rmo_top) = min(0x40000000ul, RELOC(ram_top));
781 prom_printf("memory layout at init:\n");
782 prom_printf(" memory_limit : %x (16 MB aligned)\n", RELOC(prom_memory_limit));
783 prom_printf(" alloc_bottom : %x\n", RELOC(alloc_bottom));
784 prom_printf(" alloc_top : %x\n", RELOC(alloc_top));
785 prom_printf(" alloc_top_hi : %x\n", RELOC(alloc_top_high));
786 prom_printf(" rmo_top : %x\n", RELOC(rmo_top));
787 prom_printf(" ram_top : %x\n", RELOC(ram_top));
792 * Allocate room for and instanciate RTAS
794 static void __init prom_instantiate_rtas(void)
796 unsigned long offset = reloc_offset();
797 struct prom_t *_prom = PTRRELOC(&prom);
798 phandle prom_rtas, rtas_node;
802 prom_debug("prom_instantiate_rtas: start...\n");
804 prom_rtas = call_prom("finddevice", 1, 1, ADDR("/rtas"));
805 prom_debug("prom_rtas: %x\n", prom_rtas);
806 if (prom_rtas == (phandle) -1)
809 prom_getprop(prom_rtas, "rtas-size", &size, sizeof(size));
813 base = alloc_down(size, PAGE_SIZE, 0);
815 prom_printf("RTAS allocation failed !\n");
818 prom_printf("instantiating rtas at 0x%x", base);
820 rtas_node = call_prom("open", 1, 1, ADDR("/rtas"));
823 if (call_prom("call-method", 3, 2,
824 ADDR("instantiate-rtas"),
825 rtas_node, base) != PROM_ERROR) {
826 entry = (long)_prom->args.rets[1];
829 prom_printf(" failed\n");
832 prom_printf(" done\n");
834 reserve_mem(base, size);
836 prom_setprop(prom_rtas, "linux,rtas-base", &base, sizeof(base));
837 prom_setprop(prom_rtas, "linux,rtas-entry", &entry, sizeof(entry));
839 prom_debug("rtas base = 0x%x\n", base);
840 prom_debug("rtas entry = 0x%x\n", entry);
841 prom_debug("rtas size = 0x%x\n", (long)size);
843 prom_debug("prom_instantiate_rtas: end...\n");
848 * Allocate room for and initialize TCE tables
850 static void __init prom_initialize_tce_table(void)
854 unsigned long offset = reloc_offset();
855 char compatible[64], type[64], model[64];
856 char *path = RELOC(prom_scratch);
858 u32 minalign, minsize;
859 u64 tce_entry, *tce_entryp;
860 u64 local_alloc_top, local_alloc_bottom;
863 if (RELOC(ppc64_iommu_off))
866 prom_debug("starting prom_initialize_tce_table\n");
868 /* Cache current top of allocs so we reserve a single block */
869 local_alloc_top = RELOC(alloc_top_high);
870 local_alloc_bottom = local_alloc_top;
872 /* Search all nodes looking for PHBs. */
873 for (node = 0; prom_next_node(&node); ) {
877 prom_getprop(node, "compatible",
878 compatible, sizeof(compatible));
879 prom_getprop(node, "device_type", type, sizeof(type));
880 prom_getprop(node, "model", model, sizeof(model));
882 if ((type[0] == 0) || (strstr(type, RELOC("pci")) == NULL))
885 /* Keep the old logic in tack to avoid regression. */
886 if (compatible[0] != 0) {
887 if ((strstr(compatible, RELOC("python")) == NULL) &&
888 (strstr(compatible, RELOC("Speedwagon")) == NULL) &&
889 (strstr(compatible, RELOC("Winnipeg")) == NULL))
891 } else if (model[0] != 0) {
892 if ((strstr(model, RELOC("ython")) == NULL) &&
893 (strstr(model, RELOC("peedwagon")) == NULL) &&
894 (strstr(model, RELOC("innipeg")) == NULL))
898 if (prom_getprop(node, "tce-table-minalign", &minalign,
899 sizeof(minalign)) == PROM_ERROR)
901 if (prom_getprop(node, "tce-table-minsize", &minsize,
902 sizeof(minsize)) == PROM_ERROR)
906 * Even though we read what OF wants, we just set the table
907 * size to 4 MB. This is enough to map 2GB of PCI DMA space.
908 * By doing this, we avoid the pitfalls of trying to DMA to
909 * MMIO space and the DMA alias hole.
911 * On POWER4, firmware sets the TCE region by assuming
912 * each TCE table is 8MB. Using this memory for anything
913 * else will impact performance, so we always allocate 8MB.
916 if (__is_processor(PV_POWER4) || __is_processor(PV_POWER4p))
921 /* Align to the greater of the align or size */
922 align = max(minalign, minsize);
923 base = alloc_down(minsize, align, 1);
925 prom_panic("ERROR, cannot find space for TCE table.\n");
926 if (base < local_alloc_bottom)
927 local_alloc_bottom = base;
929 /* Save away the TCE table attributes for later use. */
930 prom_setprop(node, "linux,tce-base", &base, sizeof(base));
931 prom_setprop(node, "linux,tce-size", &minsize, sizeof(minsize));
933 /* It seems OF doesn't null-terminate the path :-( */
934 memset(path, 0, sizeof(path));
935 /* Call OF to setup the TCE hardware */
936 if (call_prom("package-to-path", 3, 1, node,
937 path, PROM_SCRATCH_SIZE-1) == PROM_ERROR) {
938 prom_printf("package-to-path failed\n");
941 prom_debug("TCE table: %s\n", path);
942 prom_debug("\tnode = 0x%x\n", node);
943 prom_debug("\tbase = 0x%x\n", base);
944 prom_debug("\tsize = 0x%x\n", minsize);
946 /* Initialize the table to have a one-to-one mapping
947 * over the allocated size.
949 tce_entryp = (unsigned long *)base;
950 for (i = 0; i < (minsize >> 3) ;tce_entryp++, i++) {
951 tce_entry = (i << PAGE_SHIFT);
953 *tce_entryp = tce_entry;
956 prom_printf("opening PHB %s", path);
957 phb_node = call_prom("open", 1, 1, path);
958 if ( (long)phb_node <= 0)
959 prom_printf("... failed\n");
961 prom_printf("... done\n");
963 call_prom("call-method", 6, 0, ADDR("set-64-bit-addressing"),
964 phb_node, -1, minsize,
965 (u32) base, (u32) (base >> 32));
966 call_prom("close", 1, 0, phb_node);
969 reserve_mem(local_alloc_bottom, local_alloc_top - local_alloc_bottom);
971 if (RELOC(prom_memory_limit)) {
973 * We align the start to a 16MB boundary so we can map the TCE area
974 * using large pages if possible. The end should be the top of RAM
975 * so no need to align it.
977 RELOC(prom_tce_alloc_start) = _ALIGN_DOWN(local_alloc_bottom, 0x1000000);
978 RELOC(prom_tce_alloc_end) = local_alloc_top;
981 /* Flag the first invalid entry */
982 prom_debug("ending prom_initialize_tce_table\n");
986 * With CHRP SMP we need to use the OF to start the other
987 * processors so we can't wait until smp_boot_cpus (the OF is
988 * trashed by then) so we have to put the processors into
989 * a holding pattern controlled by the kernel (not OF) before
992 * This uses a chunk of low memory, puts some holding pattern
993 * code there and sends the other processors off to there until
994 * smp_boot_cpus tells them to do something. The holding pattern
995 * checks that address until its cpu # is there, when it is that
996 * cpu jumps to __secondary_start(). smp_boot_cpus() takes care
997 * of setting those values.
999 * We also use physical address 0x4 here to tell when a cpu
1000 * is in its holding pattern code.
1002 * Fixup comment... DRENG / PPPBBB - Peter
1006 static void __init prom_hold_cpus(void)
1011 unsigned long offset = reloc_offset();
1014 unsigned int interrupt_server[MAX_CPU_THREADS];
1015 unsigned int cpu_threads, hw_cpu_num;
1017 extern void __secondary_hold(void);
1018 extern unsigned long __secondary_hold_spinloop;
1019 extern unsigned long __secondary_hold_acknowledge;
1020 unsigned long *spinloop
1021 = (void *)virt_to_abs(&__secondary_hold_spinloop);
1022 unsigned long *acknowledge
1023 = (void *)virt_to_abs(&__secondary_hold_acknowledge);
1024 unsigned long secondary_hold
1025 = virt_to_abs(*PTRRELOC((unsigned long *)__secondary_hold));
1026 struct prom_t *_prom = PTRRELOC(&prom);
1028 prom_debug("prom_hold_cpus: start...\n");
1029 prom_debug(" 1) spinloop = 0x%x\n", (unsigned long)spinloop);
1030 prom_debug(" 1) *spinloop = 0x%x\n", *spinloop);
1031 prom_debug(" 1) acknowledge = 0x%x\n",
1032 (unsigned long)acknowledge);
1033 prom_debug(" 1) *acknowledge = 0x%x\n", *acknowledge);
1034 prom_debug(" 1) secondary_hold = 0x%x\n", secondary_hold);
1036 /* Set the common spinloop variable, so all of the secondary cpus
1037 * will block when they are awakened from their OF spinloop.
1038 * This must occur for both SMP and non SMP kernels, since OF will
1039 * be trashed when we move the kernel.
1044 for (i=0; i < NR_CPUS; i++) {
1045 RELOC(hmt_thread_data)[i].pir = 0xdeadbeef;
1049 for (node = 0; prom_next_node(&node); ) {
1051 prom_getprop(node, "device_type", type, sizeof(type));
1052 if (strcmp(type, RELOC("cpu")) != 0)
1055 /* Skip non-configured cpus. */
1056 if (prom_getprop(node, "status", type, sizeof(type)) > 0)
1057 if (strcmp(type, RELOC("okay")) != 0)
1061 prom_getprop(node, "reg", ®, sizeof(reg));
1063 prom_debug("\ncpuid = 0x%x\n", cpuid);
1064 prom_debug("cpu hw idx = 0x%x\n", reg);
1066 /* Init the acknowledge var which will be reset by
1067 * the secondary cpu when it awakens from its OF
1070 *acknowledge = (unsigned long)-1;
1072 propsize = prom_getprop(node, "ibm,ppc-interrupt-server#s",
1074 sizeof(interrupt_server));
1076 /* no property. old hardware has no SMT */
1078 interrupt_server[0] = reg; /* fake it with phys id */
1080 /* We have a threaded processor */
1081 cpu_threads = propsize / sizeof(u32);
1082 if (cpu_threads > MAX_CPU_THREADS) {
1083 prom_printf("SMT: too many threads!\n"
1084 "SMT: found %x, max is %x\n",
1085 cpu_threads, MAX_CPU_THREADS);
1086 cpu_threads = 1; /* ToDo: panic? */
1090 hw_cpu_num = interrupt_server[0];
1091 if (hw_cpu_num != _prom->cpu) {
1092 /* Primary Thread of non-boot cpu */
1093 prom_printf("%x : starting cpu hw idx %x... ", cpuid, reg);
1094 call_prom("start-cpu", 3, 0, node,
1095 secondary_hold, reg);
1097 for ( i = 0 ; (i < 100000000) &&
1098 (*acknowledge == ((unsigned long)-1)); i++ )
1101 if (*acknowledge == reg) {
1102 prom_printf("done\n");
1103 /* We have to get every CPU out of OF,
1104 * even if we never start it. */
1105 if (cpuid >= NR_CPUS)
1108 prom_printf("failed: %x\n", *acknowledge);
1113 prom_printf("%x : boot cpu %x\n", cpuid, reg);
1117 /* Init paca for secondary threads. They start later. */
1118 for (i=1; i < cpu_threads; i++) {
1120 if (cpuid >= NR_CPUS)
1123 #endif /* CONFIG_SMP */
1127 /* Only enable HMT on processors that provide support. */
1128 if (__is_processor(PV_PULSAR) ||
1129 __is_processor(PV_ICESTAR) ||
1130 __is_processor(PV_SSTAR)) {
1131 prom_printf(" starting secondary threads\n");
1133 for (i = 0; i < NR_CPUS; i += 2) {
1138 unsigned long pir = mfspr(SPRN_PIR);
1139 if (__is_processor(PV_PULSAR)) {
1140 RELOC(hmt_thread_data)[i].pir =
1143 RELOC(hmt_thread_data)[i].pir =
1149 prom_printf("Processor is not HMT capable\n");
1153 if (cpuid > NR_CPUS)
1154 prom_printf("WARNING: maximum CPUs (" __stringify(NR_CPUS)
1155 ") exceeded: ignoring extras\n");
1157 prom_debug("prom_hold_cpus: end...\n");
1161 static void __init prom_init_client_services(unsigned long pp)
1163 unsigned long offset = reloc_offset();
1164 struct prom_t *_prom = PTRRELOC(&prom);
1166 /* Get a handle to the prom entry point before anything else */
1169 /* Init default value for phys size */
1170 _prom->root_size_cells = 1;
1171 _prom->root_addr_cells = 2;
1173 /* get a handle for the stdout device */
1174 _prom->chosen = call_prom("finddevice", 1, 1, ADDR("/chosen"));
1175 if ((long)_prom->chosen <= 0)
1176 prom_panic("cannot find chosen"); /* msg won't be printed :( */
1178 /* get device tree root */
1179 _prom->root = call_prom("finddevice", 1, 1, ADDR("/"));
1180 if ((long)_prom->root <= 0)
1181 prom_panic("cannot find device tree root"); /* msg won't be printed :( */
1184 static void __init prom_init_stdout(void)
1186 unsigned long offset = reloc_offset();
1187 struct prom_t *_prom = PTRRELOC(&prom);
1188 char *path = RELOC(of_stdout_device);
1192 if (prom_getprop(_prom->chosen, "stdout", &val, sizeof(val)) <= 0)
1193 prom_panic("cannot find stdout");
1195 _prom->stdout = val;
1197 /* Get the full OF pathname of the stdout device */
1198 memset(path, 0, 256);
1199 call_prom("instance-to-path", 3, 1, _prom->stdout, path, 255);
1200 val = call_prom("instance-to-package", 1, 1, _prom->stdout);
1201 prom_setprop(_prom->chosen, "linux,stdout-package", &val, sizeof(val));
1202 prom_printf("OF stdout device is: %s\n", RELOC(of_stdout_device));
1203 prom_setprop(_prom->chosen, "linux,stdout-path",
1204 RELOC(of_stdout_device), strlen(RELOC(of_stdout_device))+1);
1206 /* If it's a display, note it */
1207 memset(type, 0, sizeof(type));
1208 prom_getprop(val, "device_type", type, sizeof(type));
1209 if (strcmp(type, RELOC("display")) == 0) {
1210 _prom->disp_node = val;
1211 prom_setprop(val, "linux,boot-display", NULL, 0);
1215 static void __init prom_close_stdin(void)
1217 unsigned long offset = reloc_offset();
1218 struct prom_t *_prom = PTRRELOC(&prom);
1221 if (prom_getprop(_prom->chosen, "stdin", &val, sizeof(val)) > 0)
1222 call_prom("close", 1, 0, val);
1225 static int __init prom_find_machine_type(void)
1227 unsigned long offset = reloc_offset();
1228 struct prom_t *_prom = PTRRELOC(&prom);
1233 len = prom_getprop(_prom->root, "compatible",
1234 compat, sizeof(compat)-1);
1238 char *p = &compat[i];
1242 if (strstr(p, RELOC("Power Macintosh")) ||
1243 strstr(p, RELOC("MacRISC4")))
1244 return PLATFORM_POWERMAC;
1245 if (strstr(p, RELOC("Momentum,Maple")))
1246 return PLATFORM_MAPLE;
1250 /* Default to pSeries. We need to know if we are running LPAR */
1251 rtas = call_prom("finddevice", 1, 1, ADDR("/rtas"));
1252 if (rtas != (phandle) -1) {
1254 x = prom_getproplen(rtas, "ibm,hypertas-functions");
1255 if (x != PROM_ERROR) {
1256 prom_printf("Hypertas detected, assuming LPAR !\n");
1257 return PLATFORM_PSERIES_LPAR;
1260 return PLATFORM_PSERIES;
1263 static int __init prom_set_color(ihandle ih, int i, int r, int g, int b)
1265 unsigned long offset = reloc_offset();
1267 return call_prom("call-method", 6, 1, ADDR("color!"), ih, i, b, g, r);
1271 * If we have a display that we don't know how to drive,
1272 * we will want to try to execute OF's open method for it
1273 * later. However, OF will probably fall over if we do that
1274 * we've taken over the MMU.
1275 * So we check whether we will need to open the display,
1276 * and if so, open it now.
1278 static void __init prom_check_displays(void)
1280 unsigned long offset = reloc_offset();
1281 struct prom_t *_prom = PTRRELOC(&prom);
1282 char type[16], *path;
1287 static unsigned char default_colors[] = {
1305 const unsigned char *clut;
1307 prom_printf("Looking for displays\n");
1308 for (node = 0; prom_next_node(&node); ) {
1309 memset(type, 0, sizeof(type));
1310 prom_getprop(node, "device_type", type, sizeof(type));
1311 if (strcmp(type, RELOC("display")) != 0)
1314 /* It seems OF doesn't null-terminate the path :-( */
1315 path = RELOC(prom_scratch);
1316 memset(path, 0, PROM_SCRATCH_SIZE);
1319 * leave some room at the end of the path for appending extra
1322 if (call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-10) < 0)
1324 prom_printf("found display : %s, opening ... ", path);
1326 ih = call_prom("open", 1, 1, path);
1327 if (ih == (ihandle)0 || ih == (ihandle)-1) {
1328 prom_printf("failed\n");
1333 prom_printf("done\n");
1334 prom_setprop(node, "linux,opened", NULL, 0);
1337 * stdout wasn't a display node, pick the first we can find
1340 if (_prom->disp_node == 0)
1341 _prom->disp_node = node;
1343 /* Setup a useable color table when the appropriate
1344 * method is available. Should update this to set-colors */
1345 clut = RELOC(default_colors);
1346 for (i = 0; i < 32; i++, clut += 3)
1347 if (prom_set_color(ih, i, clut[0], clut[1],
1351 #ifdef CONFIG_LOGO_LINUX_CLUT224
1352 clut = PTRRELOC(RELOC(logo_linux_clut224.clut));
1353 for (i = 0; i < RELOC(logo_linux_clut224.clutsize); i++, clut += 3)
1354 if (prom_set_color(ih, i + 32, clut[0], clut[1],
1357 #endif /* CONFIG_LOGO_LINUX_CLUT224 */
1362 /* Return (relocated) pointer to this much memory: moves initrd if reqd. */
1363 static void __init *make_room(unsigned long *mem_start, unsigned long *mem_end,
1364 unsigned long needed, unsigned long align)
1366 unsigned long offset = reloc_offset();
1369 *mem_start = _ALIGN(*mem_start, align);
1370 while ((*mem_start + needed) > *mem_end) {
1371 unsigned long room, chunk;
1373 prom_debug("Chunk exhausted, claiming more at %x...\n",
1374 RELOC(alloc_bottom));
1375 room = RELOC(alloc_top) - RELOC(alloc_bottom);
1376 if (room > DEVTREE_CHUNK_SIZE)
1377 room = DEVTREE_CHUNK_SIZE;
1378 if (room < PAGE_SIZE)
1379 prom_panic("No memory for flatten_device_tree (no room)");
1380 chunk = alloc_up(room, 0);
1382 prom_panic("No memory for flatten_device_tree (claim failed)");
1383 *mem_end = RELOC(alloc_top);
1386 ret = (void *)*mem_start;
1387 *mem_start += needed;
1392 #define dt_push_token(token, mem_start, mem_end) \
1393 do { *((u32 *)make_room(mem_start, mem_end, 4, 4)) = token; } while(0)
1395 static unsigned long __init dt_find_string(char *str)
1397 unsigned long offset = reloc_offset();
1400 s = os = (char *)RELOC(dt_string_start);
1402 while (s < (char *)RELOC(dt_string_end)) {
1403 if (strcmp(s, str) == 0)
1410 static void __init scan_dt_build_strings(phandle node, unsigned long *mem_start,
1411 unsigned long *mem_end)
1413 unsigned long offset = reloc_offset();
1414 char *prev_name, *namep, *sstart;
1418 sstart = (char *)RELOC(dt_string_start);
1420 /* get and store all property names */
1421 prev_name = RELOC("");
1424 /* 32 is max len of name including nul. */
1425 namep = make_room(mem_start, mem_end, 32, 1);
1426 if (call_prom("nextprop", 3, 1, node, prev_name, namep) <= 0) {
1427 /* No more nodes: unwind alloc */
1428 *mem_start = (unsigned long)namep;
1431 soff = dt_find_string(namep);
1433 *mem_start = (unsigned long)namep;
1434 namep = sstart + soff;
1436 /* Trim off some if we can */
1437 *mem_start = (unsigned long)namep + strlen(namep) + 1;
1438 RELOC(dt_string_end) = *mem_start;
1443 /* do all our children */
1444 child = call_prom("child", 1, 1, node);
1445 while (child != (phandle)0) {
1446 scan_dt_build_strings(child, mem_start, mem_end);
1447 child = call_prom("peer", 1, 1, child);
1451 static void __init scan_dt_build_struct(phandle node, unsigned long *mem_start,
1452 unsigned long *mem_end)
1456 char *namep, *prev_name, *sstart;
1458 unsigned char *valp;
1459 unsigned long offset = reloc_offset();
1463 path = RELOC(prom_scratch);
1465 dt_push_token(OF_DT_BEGIN_NODE, mem_start, mem_end);
1467 /* get the node's full name */
1468 namep = (char *)*mem_start;
1469 l = call_prom("package-to-path", 3, 1, node,
1470 namep, *mem_end - *mem_start);
1472 /* Didn't fit? Get more room. */
1473 if (l+1 > *mem_end - *mem_start) {
1474 namep = make_room(mem_start, mem_end, l+1, 1);
1475 call_prom("package-to-path", 3, 1, node, namep, l);
1478 *mem_start = _ALIGN(((unsigned long) namep) + strlen(namep) + 1, 4);
1481 /* get it again for debugging */
1482 memset(path, 0, PROM_SCRATCH_SIZE);
1483 call_prom("package-to-path", 3, 1, node, path, PROM_SCRATCH_SIZE-1);
1485 /* get and store all properties */
1486 prev_name = RELOC("");
1487 sstart = (char *)RELOC(dt_string_start);
1489 if (call_prom("nextprop", 3, 1, node, prev_name, pname) <= 0)
1492 /* find string offset */
1493 soff = dt_find_string(pname);
1495 prom_printf("WARNING: Can't find string index for <%s>, node %s\n",
1499 prev_name = sstart + soff;
1502 l = call_prom("getproplen", 2, 1, node, pname);
1507 if (l > MAX_PROPERTY_LENGTH) {
1508 prom_printf("WARNING: ignoring large property ");
1509 /* It seems OF doesn't null-terminate the path :-( */
1510 prom_printf("[%s] ", path);
1511 prom_printf("%s length 0x%x\n", pname, l);
1515 /* push property head */
1516 dt_push_token(OF_DT_PROP, mem_start, mem_end);
1517 dt_push_token(l, mem_start, mem_end);
1518 dt_push_token(soff, mem_start, mem_end);
1520 /* push property content */
1521 align = (l >= 8) ? 8 : 4;
1522 valp = make_room(mem_start, mem_end, l, align);
1523 call_prom("getprop", 4, 1, node, pname, valp, l);
1524 *mem_start = _ALIGN(*mem_start, 4);
1527 /* Add a "linux,phandle" property. */
1528 soff = dt_find_string(RELOC("linux,phandle"));
1530 prom_printf("WARNING: Can't find string index for <linux-phandle>"
1531 " node %s\n", path);
1533 dt_push_token(OF_DT_PROP, mem_start, mem_end);
1534 dt_push_token(4, mem_start, mem_end);
1535 dt_push_token(soff, mem_start, mem_end);
1536 valp = make_room(mem_start, mem_end, 4, 4);
1537 *(u32 *)valp = node;
1540 /* do all our children */
1541 child = call_prom("child", 1, 1, node);
1542 while (child != (phandle)0) {
1543 scan_dt_build_struct(child, mem_start, mem_end);
1544 child = call_prom("peer", 1, 1, child);
1547 dt_push_token(OF_DT_END_NODE, mem_start, mem_end);
1550 static void __init flatten_device_tree(void)
1553 unsigned long offset = reloc_offset();
1554 unsigned long mem_start, mem_end, room;
1555 struct boot_param_header *hdr;
1560 * Check how much room we have between alloc top & bottom (+/- a
1561 * few pages), crop to 4Mb, as this is our "chuck" size
1563 room = RELOC(alloc_top) - RELOC(alloc_bottom) - 0x4000;
1564 if (room > DEVTREE_CHUNK_SIZE)
1565 room = DEVTREE_CHUNK_SIZE;
1566 prom_debug("starting device tree allocs at %x\n", RELOC(alloc_bottom));
1568 /* Now try to claim that */
1569 mem_start = (unsigned long)alloc_up(room, PAGE_SIZE);
1571 prom_panic("Can't allocate initial device-tree chunk\n");
1572 mem_end = RELOC(alloc_top);
1574 /* Get root of tree */
1575 root = call_prom("peer", 1, 1, (phandle)0);
1576 if (root == (phandle)0)
1577 prom_panic ("couldn't get device tree root\n");
1579 /* Build header and make room for mem rsv map */
1580 mem_start = _ALIGN(mem_start, 4);
1581 hdr = make_room(&mem_start, &mem_end, sizeof(struct boot_param_header), 4);
1582 RELOC(dt_header_start) = (unsigned long)hdr;
1583 rsvmap = make_room(&mem_start, &mem_end, sizeof(mem_reserve_map), 8);
1585 /* Start of strings */
1586 mem_start = PAGE_ALIGN(mem_start);
1587 RELOC(dt_string_start) = mem_start;
1588 mem_start += 4; /* hole */
1590 /* Add "linux,phandle" in there, we'll need it */
1591 namep = make_room(&mem_start, &mem_end, 16, 1);
1592 strcpy(namep, RELOC("linux,phandle"));
1593 mem_start = (unsigned long)namep + strlen(namep) + 1;
1594 RELOC(dt_string_end) = mem_start;
1596 /* Build string array */
1597 prom_printf("Building dt strings...\n");
1598 scan_dt_build_strings(root, &mem_start, &mem_end);
1600 /* Build structure */
1601 mem_start = PAGE_ALIGN(mem_start);
1602 RELOC(dt_struct_start) = mem_start;
1603 prom_printf("Building dt structure...\n");
1604 scan_dt_build_struct(root, &mem_start, &mem_end);
1605 dt_push_token(OF_DT_END, &mem_start, &mem_end);
1606 RELOC(dt_struct_end) = PAGE_ALIGN(mem_start);
1609 hdr->magic = OF_DT_HEADER;
1610 hdr->totalsize = RELOC(dt_struct_end) - RELOC(dt_header_start);
1611 hdr->off_dt_struct = RELOC(dt_struct_start) - RELOC(dt_header_start);
1612 hdr->off_dt_strings = RELOC(dt_string_start) - RELOC(dt_header_start);
1613 hdr->off_mem_rsvmap = ((unsigned long)rsvmap) - RELOC(dt_header_start);
1614 hdr->version = OF_DT_VERSION;
1615 hdr->last_comp_version = 1;
1617 /* Reserve the whole thing and copy the reserve map in, we
1618 * also bump mem_reserve_cnt to cause further reservations to
1619 * fail since it's too late.
1621 reserve_mem(RELOC(dt_header_start), hdr->totalsize);
1622 memcpy(rsvmap, RELOC(mem_reserve_map), sizeof(mem_reserve_map));
1627 prom_printf("reserved memory map:\n");
1628 for (i = 0; i < RELOC(mem_reserve_cnt); i++)
1629 prom_printf(" %x - %x\n", RELOC(mem_reserve_map)[i].base,
1630 RELOC(mem_reserve_map)[i].size);
1633 RELOC(mem_reserve_cnt) = MEM_RESERVE_MAP_SIZE;
1635 prom_printf("Device tree strings 0x%x -> 0x%x\n",
1636 RELOC(dt_string_start), RELOC(dt_string_end));
1637 prom_printf("Device tree struct 0x%x -> 0x%x\n",
1638 RELOC(dt_struct_start), RELOC(dt_struct_end));
1642 static void __init prom_find_boot_cpu(void)
1644 unsigned long offset = reloc_offset();
1645 struct prom_t *_prom = PTRRELOC(&prom);
1650 if (prom_getprop(_prom->chosen, "cpu", &prom_cpu, sizeof(prom_cpu)) <= 0)
1651 prom_panic("cannot find boot cpu");
1653 cpu_pkg = call_prom("instance-to-package", 1, 1, prom_cpu);
1655 prom_setprop(cpu_pkg, "linux,boot-cpu", NULL, 0);
1656 prom_getprop(cpu_pkg, "reg", &getprop_rval, sizeof(getprop_rval));
1657 _prom->cpu = getprop_rval;
1659 prom_debug("Booting CPU hw index = 0x%x\n", _prom->cpu);
1662 static void __init prom_check_initrd(unsigned long r3, unsigned long r4)
1664 #ifdef CONFIG_BLK_DEV_INITRD
1665 unsigned long offset = reloc_offset();
1666 struct prom_t *_prom = PTRRELOC(&prom);
1668 if ( r3 && r4 && r4 != 0xdeadbeef) {
1671 RELOC(prom_initrd_start) = (r3 >= KERNELBASE) ? __pa(r3) : r3;
1672 RELOC(prom_initrd_end) = RELOC(prom_initrd_start) + r4;
1674 val = (u64)RELOC(prom_initrd_start);
1675 prom_setprop(_prom->chosen, "linux,initrd-start", &val, sizeof(val));
1676 val = (u64)RELOC(prom_initrd_end);
1677 prom_setprop(_prom->chosen, "linux,initrd-end", &val, sizeof(val));
1679 reserve_mem(RELOC(prom_initrd_start),
1680 RELOC(prom_initrd_end) - RELOC(prom_initrd_start));
1682 prom_debug("initrd_start=0x%x\n", RELOC(prom_initrd_start));
1683 prom_debug("initrd_end=0x%x\n", RELOC(prom_initrd_end));
1685 #endif /* CONFIG_BLK_DEV_INITRD */
1689 * We enter here early on, when the Open Firmware prom is still
1690 * handling exceptions and the MMU hash table for us.
1693 unsigned long __init prom_init(unsigned long r3, unsigned long r4, unsigned long pp,
1694 unsigned long r6, unsigned long r7)
1696 unsigned long offset = reloc_offset();
1697 struct prom_t *_prom = PTRRELOC(&prom);
1698 unsigned long phys = KERNELBASE - offset;
1702 * First zero the BSS
1704 memset(PTRRELOC(&__bss_start), 0, __bss_stop - __bss_start);
1707 * Init interface to Open Firmware, get some node references,
1710 prom_init_client_services(pp);
1713 * Init prom stdout device
1716 prom_debug("klimit=0x%x\n", RELOC(klimit));
1717 prom_debug("offset=0x%x\n", offset);
1720 * Check for an initrd
1722 prom_check_initrd(r3, r4);
1725 * Get default machine type. At this point, we do not differenciate
1726 * between pSeries SMP and pSeries LPAR
1728 RELOC(of_platform) = prom_find_machine_type();
1729 getprop_rval = RELOC(of_platform);
1730 prom_setprop(_prom->chosen, "linux,platform",
1731 &getprop_rval, sizeof(getprop_rval));
1734 * On pSeries, copy the CPU hold code
1736 if (RELOC(of_platform) & PLATFORM_PSERIES)
1737 copy_and_flush(0, KERNELBASE - offset, 0x100, 0);
1740 * Get memory cells format
1743 prom_getprop(_prom->root, "#size-cells",
1744 &getprop_rval, sizeof(getprop_rval));
1745 _prom->root_size_cells = getprop_rval;
1747 prom_getprop(_prom->root, "#address-cells",
1748 &getprop_rval, sizeof(getprop_rval));
1749 _prom->root_addr_cells = getprop_rval;
1752 * Do early parsing of command line
1754 early_cmdline_parse();
1757 * Initialize memory management within prom_init
1762 * Determine which cpu is actually running right _now_
1764 prom_find_boot_cpu();
1767 * Initialize display devices
1769 prom_check_displays();
1772 * Initialize IOMMU (TCE tables) on pSeries. Do that before anything else
1773 * that uses the allocator, we need to make sure we get the top of memory
1774 * available for us here...
1776 if (RELOC(of_platform) == PLATFORM_PSERIES)
1777 prom_initialize_tce_table();
1780 * On non-powermacs, try to instantiate RTAS and puts all CPUs
1781 * in spin-loops. PowerMacs don't have a working RTAS and use
1782 * a different way to spin CPUs
1784 if (RELOC(of_platform) != PLATFORM_POWERMAC) {
1785 prom_instantiate_rtas();
1790 * Fill in some infos for use by the kernel later on
1792 if (RELOC(ppc64_iommu_off))
1793 prom_setprop(_prom->chosen, "linux,iommu-off", NULL, 0);
1795 if (RELOC(iommu_force_on))
1796 prom_setprop(_prom->chosen, "linux,iommu-force-on", NULL, 0);
1798 if (RELOC(prom_memory_limit))
1799 prom_setprop(_prom->chosen, "linux,memory-limit",
1800 PTRRELOC(&prom_memory_limit), sizeof(RELOC(prom_memory_limit)));
1802 if (RELOC(prom_tce_alloc_start)) {
1803 prom_setprop(_prom->chosen, "linux,tce-alloc-start",
1804 PTRRELOC(&prom_tce_alloc_start), sizeof(RELOC(prom_tce_alloc_start)));
1805 prom_setprop(_prom->chosen, "linux,tce-alloc-end",
1806 PTRRELOC(&prom_tce_alloc_end), sizeof(RELOC(prom_tce_alloc_end)));
1810 * Now finally create the flattened device-tree
1812 prom_printf("copying OF device tree ...\n");
1813 flatten_device_tree();
1815 /* in case stdin is USB and still active on IBM machines... */
1819 * Call OF "quiesce" method to shut down pending DMA's from
1822 prom_printf("Calling quiesce ...\n");
1823 call_prom("quiesce", 0, 0);
1826 * And finally, call the kernel passing it the flattened device
1827 * tree and NULL as r5, thus triggering the new entry point which
1828 * is common to us and kexec
1830 prom_printf("returning from prom_init\n");
1831 prom_debug("->dt_header_start=0x%x\n", RELOC(dt_header_start));
1832 prom_debug("->phys=0x%x\n", phys);
1834 __start(RELOC(dt_header_start), phys, 0);