2 * Copyright (C) Paul Mackerras 1997.
4 * Updates for PPC64 by Todd Inglett, Dave Engebretsen & Peter Bergner.
6 * This program is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU General Public License
8 * as published by the Free Software Foundation; either version
9 * 2 of the License, or (at your option) any later version.
18 #include "gunzip_util.h"
19 #include "flatdevtree.h"
22 extern char __bss_start
[];
24 extern char _vmlinux_start
[];
25 extern char _vmlinux_end
[];
26 extern char _initrd_start
[];
27 extern char _initrd_end
[];
28 extern char _dtb_start
[];
29 extern char _dtb_end
[];
31 static struct gunzip_state gzstate
;
39 unsigned long loadsize
;
40 unsigned long memsize
;
41 unsigned long elfoffset
;
44 typedef void (*kernel_entry_t
)(unsigned long, unsigned long, void *);
48 static int parse_elf64(void *hdr
, struct elf_info
*info
)
50 Elf64_Ehdr
*elf64
= hdr
;
54 if (!(elf64
->e_ident
[EI_MAG0
] == ELFMAG0
&&
55 elf64
->e_ident
[EI_MAG1
] == ELFMAG1
&&
56 elf64
->e_ident
[EI_MAG2
] == ELFMAG2
&&
57 elf64
->e_ident
[EI_MAG3
] == ELFMAG3
&&
58 elf64
->e_ident
[EI_CLASS
] == ELFCLASS64
&&
59 elf64
->e_ident
[EI_DATA
] == ELFDATA2MSB
&&
60 elf64
->e_type
== ET_EXEC
&&
61 elf64
->e_machine
== EM_PPC64
))
64 elf64ph
= (Elf64_Phdr
*)((unsigned long)elf64
+
65 (unsigned long)elf64
->e_phoff
);
66 for (i
= 0; i
< (unsigned int)elf64
->e_phnum
; i
++, elf64ph
++)
67 if (elf64ph
->p_type
== PT_LOAD
)
69 if (i
>= (unsigned int)elf64
->e_phnum
)
72 info
->loadsize
= (unsigned long)elf64ph
->p_filesz
;
73 info
->memsize
= (unsigned long)elf64ph
->p_memsz
;
74 info
->elfoffset
= (unsigned long)elf64ph
->p_offset
;
79 static int parse_elf32(void *hdr
, struct elf_info
*info
)
81 Elf32_Ehdr
*elf32
= hdr
;
85 if (!(elf32
->e_ident
[EI_MAG0
] == ELFMAG0
&&
86 elf32
->e_ident
[EI_MAG1
] == ELFMAG1
&&
87 elf32
->e_ident
[EI_MAG2
] == ELFMAG2
&&
88 elf32
->e_ident
[EI_MAG3
] == ELFMAG3
&&
89 elf32
->e_ident
[EI_CLASS
] == ELFCLASS32
&&
90 elf32
->e_ident
[EI_DATA
] == ELFDATA2MSB
&&
91 elf32
->e_type
== ET_EXEC
&&
92 elf32
->e_machine
== EM_PPC
))
95 elf32ph
= (Elf32_Phdr
*) ((unsigned long)elf32
+ elf32
->e_phoff
);
96 for (i
= 0; i
< elf32
->e_phnum
; i
++, elf32ph
++)
97 if (elf32ph
->p_type
== PT_LOAD
)
99 if (i
>= elf32
->e_phnum
)
102 info
->loadsize
= elf32ph
->p_filesz
;
103 info
->memsize
= elf32ph
->p_memsz
;
104 info
->elfoffset
= elf32ph
->p_offset
;
108 static struct addr_range
prep_kernel(void)
111 void *vmlinuz_addr
= _vmlinux_start
;
112 unsigned long vmlinuz_size
= _vmlinux_end
- _vmlinux_start
;
117 /* gunzip the ELF header of the kernel */
118 gunzip_start(&gzstate
, vmlinuz_addr
, vmlinuz_size
);
119 gunzip_exactly(&gzstate
, elfheader
, sizeof(elfheader
));
121 if (!parse_elf64(elfheader
, &ei
) && !parse_elf32(elfheader
, &ei
))
122 fatal("Error: not a valid PPC32 or PPC64 ELF file!\n\r");
124 if (platform_ops
.image_hdr
)
125 platform_ops
.image_hdr(elfheader
);
127 /* We need to alloc the memsize: gzip will expand the kernel
128 * text/data, then possible rubbish we don't care about. But
129 * the kernel bss must be claimed (it will be zero'd by the
132 printf("Allocating 0x%lx bytes for kernel ...\n\r", ei
.memsize
);
134 if (platform_ops
.vmlinux_alloc
) {
135 addr
= platform_ops
.vmlinux_alloc(ei
.memsize
);
137 if ((unsigned long)_start
< ei
.memsize
)
138 fatal("Insufficient memory for kernel at address 0!"
139 " (_start=%lx)\n\r", _start
);
142 /* Finally, gunzip the kernel */
143 printf("gunzipping (0x%p <- 0x%p:0x%p)...", addr
,
144 vmlinuz_addr
, vmlinuz_addr
+vmlinuz_size
);
145 /* discard up to the actual load data */
146 gunzip_discard(&gzstate
, ei
.elfoffset
- sizeof(elfheader
));
147 len
= gunzip_finish(&gzstate
, addr
, ei
.memsize
);
148 printf("done 0x%lx bytes\n\r", len
);
150 flush_cache(addr
, ei
.loadsize
);
152 return (struct addr_range
){addr
, ei
.memsize
};
155 static struct addr_range
prep_initrd(struct addr_range vmlinux
,
156 unsigned long initrd_addr
,
157 unsigned long initrd_size
)
160 u32 initrd_start
, initrd_end
;
162 /* If we have an image attached to us, it overrides anything
163 * supplied by the loader. */
164 if (_initrd_end
> _initrd_start
) {
165 printf("Attached initrd image at 0x%p-0x%p\n\r",
166 _initrd_start
, _initrd_end
);
167 initrd_addr
= (unsigned long)_initrd_start
;
168 initrd_size
= _initrd_end
- _initrd_start
;
169 } else if (initrd_size
> 0) {
170 printf("Using loader supplied ramdisk at 0x%lx-0x%lx\n\r",
171 initrd_addr
, initrd_addr
+ initrd_size
);
174 /* If there's no initrd at all, we're done */
176 return (struct addr_range
){0, 0};
179 * If the initrd is too low it will be clobbered when the
180 * kernel relocates to its final location. In this case,
181 * allocate a safer place and move it.
183 if (initrd_addr
< vmlinux
.size
) {
184 void *old_addr
= (void *)initrd_addr
;
186 printf("Allocating 0x%lx bytes for initrd ...\n\r",
188 initrd_addr
= (unsigned long)malloc(initrd_size
);
190 fatal("Can't allocate memory for initial "
192 printf("Relocating initrd 0x%p <- 0x%p (0x%lx bytes)\n\r",
193 initrd_addr
, old_addr
, initrd_size
);
194 memmove((void *)initrd_addr
, old_addr
, initrd_size
);
197 printf("initrd head: 0x%lx\n\r", *((unsigned long *)initrd_addr
));
199 /* Tell the kernel initrd address via device tree */
200 devp
= finddevice("/chosen");
202 fatal("Device tree has no chosen node!\n\r");
204 initrd_start
= (u32
)initrd_addr
;
205 initrd_end
= (u32
)initrd_addr
+ initrd_size
;
207 setprop(devp
, "linux,initrd-start", &initrd_start
,
208 sizeof(initrd_start
));
209 setprop(devp
, "linux,initrd-end", &initrd_end
, sizeof(initrd_end
));
211 return (struct addr_range
){(void *)initrd_addr
, initrd_size
};
214 /* A buffer that may be edited by tools operating on a zImage binary so as to
215 * edit the command line passed to vmlinux (by setting /chosen/bootargs).
216 * The buffer is put in it's own section so that tools may locate it easier.
218 static char builtin_cmdline
[COMMAND_LINE_SIZE
]
219 __attribute__((__section__("__builtin_cmdline")));
221 static void get_cmdline(char *buf
, int size
)
224 int len
= strlen(builtin_cmdline
);
228 if (len
> 0) { /* builtin_cmdline overrides dt's /chosen/bootargs */
229 len
= min(len
, size
-1);
230 strncpy(buf
, builtin_cmdline
, len
);
233 else if ((devp
= finddevice("/chosen")))
234 getprop(devp
, "bootargs", buf
, size
);
237 static void set_cmdline(char *buf
)
241 if ((devp
= finddevice("/chosen")))
242 setprop(devp
, "bootargs", buf
, strlen(buf
) + 1);
245 struct platform_ops platform_ops
;
246 struct dt_ops dt_ops
;
247 struct console_ops console_ops
;
248 struct loader_info loader_info
;
252 struct addr_range vmlinux
, initrd
;
253 kernel_entry_t kentry
;
254 char cmdline
[COMMAND_LINE_SIZE
];
255 unsigned long ft_addr
= 0;
257 if (console_ops
.open
&& (console_ops
.open() < 0))
259 if (platform_ops
.fixups
)
260 platform_ops
.fixups();
262 printf("\n\rzImage starting: loaded at 0x%p (sp: 0x%p)\n\r",
265 vmlinux
= prep_kernel();
266 initrd
= prep_initrd(vmlinux
, loader_info
.initrd_addr
,
267 loader_info
.initrd_size
);
269 /* If cmdline came from zimage wrapper or if we can edit the one
270 * in the dt, print it out and edit it, if possible.
272 if ((strlen(builtin_cmdline
) > 0) || console_ops
.edit_cmdline
) {
273 get_cmdline(cmdline
, COMMAND_LINE_SIZE
);
274 printf("\n\rLinux/PowerPC load: %s", cmdline
);
275 if (console_ops
.edit_cmdline
)
276 console_ops
.edit_cmdline(cmdline
, COMMAND_LINE_SIZE
);
278 set_cmdline(cmdline
);
281 printf("Finalizing device tree...");
283 ft_addr
= dt_ops
.finalize();
285 printf(" flat tree at 0x%lx\n\r", ft_addr
);
287 printf(" using OF tree (promptr=%p)\n\r", loader_info
.promptr
);
289 if (console_ops
.close
)
292 kentry
= (kernel_entry_t
) vmlinux
.addr
;
294 kentry(ft_addr
, 0, NULL
);
296 kentry((unsigned long)initrd
.addr
, initrd
.size
,
297 loader_info
.promptr
);
299 /* console closed so printf in fatal below may not work */
300 fatal("Error: Linux kernel returned to zImage boot wrapper!\n\r");