Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * Copyright (C) Paul Mackerras 1997. | |
3 | * | |
4 | * Updates for PPC64 by Todd Inglett, Dave Engebretsen & Peter Bergner. | |
5 | * | |
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. | |
10 | */ | |
decd300b OH |
11 | #include <stdarg.h> |
12 | #include <stddef.h> | |
13 | #include "elf.h" | |
14 | #include "page.h" | |
15 | #include "string.h" | |
16 | #include "stdio.h" | |
1da177e4 | 17 | #include "zlib.h" |
b2c5f619 MG |
18 | #include "ops.h" |
19 | #include "flatdevtree.h" | |
decd300b | 20 | |
decd300b OH |
21 | extern void flush_cache(void *, unsigned long); |
22 | ||
1da177e4 | 23 | extern char _start[]; |
9b0cbe97 | 24 | extern char __bss_start[]; |
3cc747e9 | 25 | extern char _end[]; |
1da177e4 LT |
26 | extern char _vmlinux_start[]; |
27 | extern char _vmlinux_end[]; | |
28 | extern char _initrd_start[]; | |
29 | extern char _initrd_end[]; | |
c888554b MG |
30 | extern char _dtb_start[]; |
31 | extern char _dtb_end[]; | |
1da177e4 LT |
32 | |
33 | struct addr_range { | |
34 | unsigned long addr; | |
35 | unsigned long size; | |
36 | unsigned long memsize; | |
37 | }; | |
afbe8c4b OH |
38 | static struct addr_range vmlinux; |
39 | static struct addr_range vmlinuz; | |
40 | static struct addr_range initrd; | |
1da177e4 | 41 | |
94b212c2 | 42 | static unsigned long elfoffset; |
b2c5f619 | 43 | static int is_64bit; |
94b212c2 | 44 | |
b2c5f619 MG |
45 | /* scratch space for gunzip; 46912 is from zlib_inflate_workspacesize() */ |
46 | static char scratch[46912]; | |
8a76baf0 | 47 | static char elfheader[256]; |
7054036f | 48 | |
b2c5f619 | 49 | typedef void (*kernel_entry_t)(unsigned long, unsigned long, void *); |
1da177e4 | 50 | |
1da177e4 LT |
51 | #undef DEBUG |
52 | ||
6bcc20b5 OH |
53 | #define HEAD_CRC 2 |
54 | #define EXTRA_FIELD 4 | |
55 | #define ORIG_NAME 8 | |
56 | #define COMMENT 0x10 | |
57 | #define RESERVED 0xe0 | |
58 | ||
59 | static void gunzip(void *dst, int dstlen, unsigned char *src, int *lenp) | |
60 | { | |
61 | z_stream s; | |
62 | int r, i, flags; | |
63 | ||
64 | /* skip header */ | |
65 | i = 10; | |
66 | flags = src[3]; | |
67 | if (src[2] != Z_DEFLATED || (flags & RESERVED) != 0) { | |
68 | printf("bad gzipped data\n\r"); | |
69 | exit(); | |
70 | } | |
71 | if ((flags & EXTRA_FIELD) != 0) | |
72 | i = 12 + src[10] + (src[11] << 8); | |
73 | if ((flags & ORIG_NAME) != 0) | |
74 | while (src[i++] != 0) | |
75 | ; | |
76 | if ((flags & COMMENT) != 0) | |
77 | while (src[i++] != 0) | |
78 | ; | |
79 | if ((flags & HEAD_CRC) != 0) | |
80 | i += 2; | |
81 | if (i >= *lenp) { | |
82 | printf("gunzip: ran out of data in header\n\r"); | |
83 | exit(); | |
84 | } | |
85 | ||
86 | if (zlib_inflate_workspacesize() > sizeof(scratch)) { | |
87 | printf("gunzip needs more mem\n"); | |
88 | exit(); | |
89 | } | |
90 | memset(&s, 0, sizeof(s)); | |
91 | s.workspace = scratch; | |
92 | r = zlib_inflateInit2(&s, -MAX_WBITS); | |
93 | if (r != Z_OK) { | |
94 | printf("inflateInit2 returned %d\n\r", r); | |
95 | exit(); | |
96 | } | |
97 | s.next_in = src + i; | |
98 | s.avail_in = *lenp - i; | |
99 | s.next_out = dst; | |
100 | s.avail_out = dstlen; | |
101 | r = zlib_inflate(&s, Z_FULL_FLUSH); | |
102 | if (r != Z_OK && r != Z_STREAM_END) { | |
103 | printf("inflate returned %d msg: %s\n\r", r, s.msg); | |
104 | exit(); | |
105 | } | |
106 | *lenp = s.next_out - (unsigned char *) dst; | |
107 | zlib_inflateEnd(&s); | |
108 | } | |
109 | ||
94b212c2 PM |
110 | static int is_elf64(void *hdr) |
111 | { | |
112 | Elf64_Ehdr *elf64 = hdr; | |
113 | Elf64_Phdr *elf64ph; | |
114 | unsigned int i; | |
115 | ||
116 | if (!(elf64->e_ident[EI_MAG0] == ELFMAG0 && | |
117 | elf64->e_ident[EI_MAG1] == ELFMAG1 && | |
118 | elf64->e_ident[EI_MAG2] == ELFMAG2 && | |
119 | elf64->e_ident[EI_MAG3] == ELFMAG3 && | |
120 | elf64->e_ident[EI_CLASS] == ELFCLASS64 && | |
121 | elf64->e_ident[EI_DATA] == ELFDATA2MSB && | |
122 | elf64->e_type == ET_EXEC && | |
123 | elf64->e_machine == EM_PPC64)) | |
124 | return 0; | |
125 | ||
126 | elf64ph = (Elf64_Phdr *)((unsigned long)elf64 + | |
127 | (unsigned long)elf64->e_phoff); | |
128 | for (i = 0; i < (unsigned int)elf64->e_phnum; i++, elf64ph++) | |
158daa4c | 129 | if (elf64ph->p_type == PT_LOAD) |
94b212c2 PM |
130 | break; |
131 | if (i >= (unsigned int)elf64->e_phnum) | |
132 | return 0; | |
133 | ||
134 | elfoffset = (unsigned long)elf64ph->p_offset; | |
135 | vmlinux.size = (unsigned long)elf64ph->p_filesz + elfoffset; | |
136 | vmlinux.memsize = (unsigned long)elf64ph->p_memsz + elfoffset; | |
66a45dd3 | 137 | |
b2c5f619 | 138 | is_64bit = 1; |
94b212c2 PM |
139 | return 1; |
140 | } | |
141 | ||
142 | static int is_elf32(void *hdr) | |
143 | { | |
144 | Elf32_Ehdr *elf32 = hdr; | |
145 | Elf32_Phdr *elf32ph; | |
146 | unsigned int i; | |
147 | ||
148 | if (!(elf32->e_ident[EI_MAG0] == ELFMAG0 && | |
149 | elf32->e_ident[EI_MAG1] == ELFMAG1 && | |
150 | elf32->e_ident[EI_MAG2] == ELFMAG2 && | |
151 | elf32->e_ident[EI_MAG3] == ELFMAG3 && | |
152 | elf32->e_ident[EI_CLASS] == ELFCLASS32 && | |
153 | elf32->e_ident[EI_DATA] == ELFDATA2MSB && | |
154 | elf32->e_type == ET_EXEC && | |
155 | elf32->e_machine == EM_PPC)) | |
156 | return 0; | |
157 | ||
158 | elf32 = (Elf32_Ehdr *)elfheader; | |
159 | elf32ph = (Elf32_Phdr *) ((unsigned long)elf32 + elf32->e_phoff); | |
160 | for (i = 0; i < elf32->e_phnum; i++, elf32ph++) | |
158daa4c | 161 | if (elf32ph->p_type == PT_LOAD) |
94b212c2 PM |
162 | break; |
163 | if (i >= elf32->e_phnum) | |
164 | return 0; | |
165 | ||
166 | elfoffset = elf32ph->p_offset; | |
167 | vmlinux.size = elf32ph->p_filesz + elf32ph->p_offset; | |
168 | vmlinux.memsize = elf32ph->p_memsz + elf32ph->p_offset; | |
169 | return 1; | |
170 | } | |
171 | ||
f79e083c | 172 | static void prep_kernel(unsigned long a1, unsigned long a2) |
1da177e4 | 173 | { |
8a76baf0 | 174 | int len; |
66a45dd3 | 175 | |
94b212c2 PM |
176 | vmlinuz.addr = (unsigned long)_vmlinux_start; |
177 | vmlinuz.size = (unsigned long)(_vmlinux_end - _vmlinux_start); | |
178 | ||
179 | /* gunzip the ELF header of the kernel */ | |
180 | if (*(unsigned short *)vmlinuz.addr == 0x1f8b) { | |
181 | len = vmlinuz.size; | |
182 | gunzip(elfheader, sizeof(elfheader), | |
183 | (unsigned char *)vmlinuz.addr, &len); | |
184 | } else | |
b2c5f619 MG |
185 | memcpy(elfheader, (const void *)vmlinuz.addr, |
186 | sizeof(elfheader)); | |
94b212c2 PM |
187 | |
188 | if (!is_elf64(elfheader) && !is_elf32(elfheader)) { | |
189 | printf("Error: not a valid PPC32 or PPC64 ELF file!\n\r"); | |
190 | exit(); | |
191 | } | |
b2c5f619 MG |
192 | if (platform_ops.image_hdr) |
193 | platform_ops.image_hdr(elfheader); | |
94b212c2 | 194 | |
b2c5f619 | 195 | /* We need to alloc the memsize plus the file offset since gzip |
c8e3c8b2 BH |
196 | * will expand the header (file offset), then the kernel, then |
197 | * possible rubbish we don't care about. But the kernel bss must | |
198 | * be claimed (it will be zero'd by the kernel itself) | |
199 | */ | |
8a76baf0 | 200 | printf("Allocating 0x%lx bytes for kernel ...\n\r", vmlinux.memsize); |
b2c5f619 | 201 | vmlinux.addr = (unsigned long)malloc(vmlinux.memsize); |
1da177e4 LT |
202 | if (vmlinux.addr == 0) { |
203 | printf("Can't allocate memory for kernel image !\n\r"); | |
204 | exit(); | |
205 | } | |
1da177e4 LT |
206 | |
207 | /* | |
f79e083c DG |
208 | * Now find the initrd |
209 | * | |
210 | * First see if we have an image attached to us. If so | |
211 | * allocate memory for it and copy it there. | |
1da177e4 LT |
212 | */ |
213 | initrd.size = (unsigned long)(_initrd_end - _initrd_start); | |
214 | initrd.memsize = initrd.size; | |
f79e083c | 215 | if (initrd.size > 0) { |
b2c5f619 MG |
216 | printf("Allocating 0x%lx bytes for initrd ...\n\r", |
217 | initrd.size); | |
218 | initrd.addr = (unsigned long)malloc((u32)initrd.size); | |
1da177e4 | 219 | if (initrd.addr == 0) { |
b2c5f619 MG |
220 | printf("Can't allocate memory for initial " |
221 | "ramdisk !\n\r"); | |
1da177e4 LT |
222 | exit(); |
223 | } | |
b2c5f619 MG |
224 | printf("initial ramdisk moving 0x%lx <- 0x%lx " |
225 | "(0x%lx bytes)\n\r", initrd.addr, | |
226 | (unsigned long)_initrd_start, initrd.size); | |
227 | memmove((void *)initrd.addr, (void *)_initrd_start, | |
228 | initrd.size); | |
229 | printf("initrd head: 0x%lx\n\r", | |
230 | *((unsigned long *)initrd.addr)); | |
f79e083c DG |
231 | } else if (a2 != 0) { |
232 | /* Otherwise, see if yaboot or another loader gave us an initrd */ | |
233 | initrd.addr = a1; | |
234 | initrd.memsize = initrd.size = a2; | |
235 | printf("Using loader supplied initrd at 0x%lx (0x%lx bytes)\n\r", | |
236 | initrd.addr, initrd.size); | |
1da177e4 LT |
237 | } |
238 | ||
239 | /* Eventually gunzip the kernel */ | |
240 | if (*(unsigned short *)vmlinuz.addr == 0x1f8b) { | |
1da177e4 LT |
241 | printf("gunzipping (0x%lx <- 0x%lx:0x%0lx)...", |
242 | vmlinux.addr, vmlinuz.addr, vmlinuz.addr+vmlinuz.size); | |
243 | len = vmlinuz.size; | |
8a76baf0 | 244 | gunzip((void *)vmlinux.addr, vmlinux.memsize, |
1da177e4 LT |
245 | (unsigned char *)vmlinuz.addr, &len); |
246 | printf("done 0x%lx bytes\n\r", len); | |
1da177e4 | 247 | } else { |
b2c5f619 MG |
248 | memmove((void *)vmlinux.addr,(void *)vmlinuz.addr, |
249 | vmlinuz.size); | |
1da177e4 LT |
250 | } |
251 | ||
252 | /* Skip over the ELF header */ | |
1da177e4 LT |
253 | #ifdef DEBUG |
254 | printf("... skipping 0x%lx bytes of ELF header\n\r", | |
94b212c2 | 255 | elfoffset); |
1da177e4 | 256 | #endif |
94b212c2 | 257 | vmlinux.addr += elfoffset; |
1da177e4 LT |
258 | |
259 | flush_cache((void *)vmlinux.addr, vmlinux.size); | |
b2c5f619 | 260 | } |
1da177e4 | 261 | |
b2c5f619 MG |
262 | /* A buffer that may be edited by tools operating on a zImage binary so as to |
263 | * edit the command line passed to vmlinux (by setting /chosen/bootargs). | |
264 | * The buffer is put in it's own section so that tools may locate it easier. | |
265 | */ | |
266 | static char builtin_cmdline[COMMAND_LINE_SIZE] | |
267 | __attribute__((__section__("__builtin_cmdline"))); | |
1da177e4 | 268 | |
b2c5f619 MG |
269 | static void get_cmdline(char *buf, int size) |
270 | { | |
271 | void *devp; | |
272 | int len = strlen(builtin_cmdline); | |
1da177e4 | 273 | |
b2c5f619 MG |
274 | buf[0] = '\0'; |
275 | ||
276 | if (len > 0) { /* builtin_cmdline overrides dt's /chosen/bootargs */ | |
277 | len = min(len, size-1); | |
278 | strncpy(buf, builtin_cmdline, len); | |
279 | buf[len] = '\0'; | |
280 | } | |
281 | else if ((devp = finddevice("/chosen"))) | |
282 | getprop(devp, "bootargs", buf, size); | |
283 | } | |
284 | ||
285 | static void set_cmdline(char *buf) | |
286 | { | |
287 | void *devp; | |
288 | ||
289 | if ((devp = finddevice("/chosen"))) | |
290 | setprop(devp, "bootargs", buf, strlen(buf) + 1); | |
1da177e4 LT |
291 | } |
292 | ||
b2c5f619 MG |
293 | struct platform_ops platform_ops; |
294 | struct dt_ops dt_ops; | |
295 | struct console_ops console_ops; | |
296 | ||
297 | void start(unsigned long a1, unsigned long a2, void *promptr, void *sp) | |
298 | { | |
b2c5f619 MG |
299 | kernel_entry_t kentry; |
300 | char cmdline[COMMAND_LINE_SIZE]; | |
301 | ||
302 | memset(__bss_start, 0, _end - __bss_start); | |
303 | memset(&platform_ops, 0, sizeof(platform_ops)); | |
304 | memset(&dt_ops, 0, sizeof(dt_ops)); | |
305 | memset(&console_ops, 0, sizeof(console_ops)); | |
306 | ||
c888554b | 307 | if (platform_init(promptr, _dtb_start, _dtb_end)) |
b2c5f619 MG |
308 | exit(); |
309 | if (console_ops.open && (console_ops.open() < 0)) | |
310 | exit(); | |
311 | if (platform_ops.fixups) | |
312 | platform_ops.fixups(); | |
313 | ||
314 | printf("\n\rzImage starting: loaded at 0x%p (sp: 0x%p)\n\r", | |
315 | _start, sp); | |
316 | ||
f79e083c | 317 | prep_kernel(a1, a2); |
b2c5f619 MG |
318 | |
319 | /* If cmdline came from zimage wrapper or if we can edit the one | |
320 | * in the dt, print it out and edit it, if possible. | |
321 | */ | |
322 | if ((strlen(builtin_cmdline) > 0) || console_ops.edit_cmdline) { | |
323 | get_cmdline(cmdline, COMMAND_LINE_SIZE); | |
324 | printf("\n\rLinux/PowerPC load: %s", cmdline); | |
325 | if (console_ops.edit_cmdline) | |
326 | console_ops.edit_cmdline(cmdline, COMMAND_LINE_SIZE); | |
327 | printf("\n\r"); | |
328 | set_cmdline(cmdline); | |
329 | } | |
330 | ||
331 | if (console_ops.close) | |
332 | console_ops.close(); | |
333 | ||
334 | kentry = (kernel_entry_t) vmlinux.addr; | |
c888554b MG |
335 | if (_dtb_end > _dtb_start) { |
336 | dt_ops.ft_pack(); | |
b2c5f619 | 337 | kentry(dt_ops.ft_addr(), 0, NULL); |
c888554b | 338 | } |
b2c5f619 MG |
339 | else |
340 | /* XXX initrd addr/size should be passed in properties */ | |
f79e083c | 341 | kentry(initrd.addr, initrd.size, promptr); |
b2c5f619 MG |
342 | |
343 | /* console closed so printf below may not work */ | |
344 | printf("Error: Linux kernel returned to zImage boot wrapper!\n\r"); | |
345 | exit(); | |
346 | } |