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" | |
17 | #include "prom.h" | |
1da177e4 | 18 | #include "zlib.h" |
decd300b | 19 | |
decd300b OH |
20 | extern void flush_cache(void *, unsigned long); |
21 | ||
1da177e4 LT |
22 | |
23 | /* Value picked to match that used by yaboot */ | |
24 | #define PROG_START 0x01400000 | |
3cc747e9 MB |
25 | #define RAM_END (512<<20) // Fixme: use OF */ |
26 | #define ONE_MB 0x100000 | |
1da177e4 | 27 | |
1da177e4 | 28 | extern char _start[]; |
9b0cbe97 | 29 | extern char __bss_start[]; |
3cc747e9 | 30 | extern char _end[]; |
1da177e4 LT |
31 | extern char _vmlinux_start[]; |
32 | extern char _vmlinux_end[]; | |
33 | extern char _initrd_start[]; | |
34 | extern char _initrd_end[]; | |
1da177e4 LT |
35 | |
36 | struct addr_range { | |
37 | unsigned long addr; | |
38 | unsigned long size; | |
39 | unsigned long memsize; | |
40 | }; | |
decd300b OH |
41 | static struct addr_range vmlinux = {0, 0, 0}; |
42 | static struct addr_range vmlinuz = {0, 0, 0}; | |
43 | static struct addr_range initrd = {0, 0, 0}; | |
1da177e4 | 44 | |
7054036f | 45 | static char scratch[46912]; /* scratch space for gunzip, from zlib_inflate_workspacesize() */ |
8a76baf0 | 46 | static char elfheader[256]; |
7054036f | 47 | |
1da177e4 LT |
48 | |
49 | typedef void (*kernel_entry_t)( unsigned long, | |
50 | unsigned long, | |
51 | void *, | |
52 | void *); | |
53 | ||
54 | ||
1da177e4 LT |
55 | #undef DEBUG |
56 | ||
3cc747e9 | 57 | static unsigned long claim_base; |
1da177e4 | 58 | |
6bcc20b5 OH |
59 | #define HEAD_CRC 2 |
60 | #define EXTRA_FIELD 4 | |
61 | #define ORIG_NAME 8 | |
62 | #define COMMENT 0x10 | |
63 | #define RESERVED 0xe0 | |
64 | ||
65 | static void gunzip(void *dst, int dstlen, unsigned char *src, int *lenp) | |
66 | { | |
67 | z_stream s; | |
68 | int r, i, flags; | |
69 | ||
70 | /* skip header */ | |
71 | i = 10; | |
72 | flags = src[3]; | |
73 | if (src[2] != Z_DEFLATED || (flags & RESERVED) != 0) { | |
74 | printf("bad gzipped data\n\r"); | |
75 | exit(); | |
76 | } | |
77 | if ((flags & EXTRA_FIELD) != 0) | |
78 | i = 12 + src[10] + (src[11] << 8); | |
79 | if ((flags & ORIG_NAME) != 0) | |
80 | while (src[i++] != 0) | |
81 | ; | |
82 | if ((flags & COMMENT) != 0) | |
83 | while (src[i++] != 0) | |
84 | ; | |
85 | if ((flags & HEAD_CRC) != 0) | |
86 | i += 2; | |
87 | if (i >= *lenp) { | |
88 | printf("gunzip: ran out of data in header\n\r"); | |
89 | exit(); | |
90 | } | |
91 | ||
92 | if (zlib_inflate_workspacesize() > sizeof(scratch)) { | |
93 | printf("gunzip needs more mem\n"); | |
94 | exit(); | |
95 | } | |
96 | memset(&s, 0, sizeof(s)); | |
97 | s.workspace = scratch; | |
98 | r = zlib_inflateInit2(&s, -MAX_WBITS); | |
99 | if (r != Z_OK) { | |
100 | printf("inflateInit2 returned %d\n\r", r); | |
101 | exit(); | |
102 | } | |
103 | s.next_in = src + i; | |
104 | s.avail_in = *lenp - i; | |
105 | s.next_out = dst; | |
106 | s.avail_out = dstlen; | |
107 | r = zlib_inflate(&s, Z_FULL_FLUSH); | |
108 | if (r != Z_OK && r != Z_STREAM_END) { | |
109 | printf("inflate returned %d msg: %s\n\r", r, s.msg); | |
110 | exit(); | |
111 | } | |
112 | *lenp = s.next_out - (unsigned char *) dst; | |
113 | zlib_inflateEnd(&s); | |
114 | } | |
115 | ||
1da177e4 LT |
116 | static unsigned long try_claim(unsigned long size) |
117 | { | |
118 | unsigned long addr = 0; | |
119 | ||
3cc747e9 | 120 | for(; claim_base < RAM_END; claim_base += ONE_MB) { |
1da177e4 LT |
121 | #ifdef DEBUG |
122 | printf(" trying: 0x%08lx\n\r", claim_base); | |
123 | #endif | |
124 | addr = (unsigned long)claim(claim_base, size, 0); | |
125 | if ((void *)addr != (void *)-1) | |
126 | break; | |
127 | } | |
128 | if (addr == 0) | |
129 | return 0; | |
130 | claim_base = PAGE_ALIGN(claim_base + size); | |
131 | return addr; | |
132 | } | |
133 | ||
134 | void start(unsigned long a1, unsigned long a2, void *promptr) | |
135 | { | |
136 | unsigned long i; | |
8a76baf0 | 137 | int len; |
1da177e4 LT |
138 | kernel_entry_t kernel_entry; |
139 | Elf64_Ehdr *elf64; | |
140 | Elf64_Phdr *elf64ph; | |
141 | ||
9b0cbe97 OH |
142 | memset(__bss_start, 0, _end - __bss_start); |
143 | ||
1da177e4 LT |
144 | prom = (int (*)(void *)) promptr; |
145 | chosen_handle = finddevice("/chosen"); | |
146 | if (chosen_handle == (void *) -1) | |
147 | exit(); | |
148 | if (getprop(chosen_handle, "stdout", &stdout, sizeof(stdout)) != 4) | |
149 | exit(); | |
150 | stderr = stdout; | |
151 | if (getprop(chosen_handle, "stdin", &stdin, sizeof(stdin)) != 4) | |
152 | exit(); | |
153 | ||
3cc747e9 MB |
154 | printf("\n\rzImage starting: loaded at 0x%lx\n\r", (unsigned long) _start); |
155 | ||
156 | /* | |
157 | * The first available claim_base must be above the end of the | |
158 | * the loaded kernel wrapper file (_start to _end includes the | |
159 | * initrd image if it is present) and rounded up to a nice | |
160 | * 1 MB boundary for good measure. | |
161 | */ | |
162 | ||
163 | claim_base = _ALIGN_UP((unsigned long)_end, ONE_MB); | |
164 | ||
165 | #if defined(PROG_START) | |
166 | /* | |
167 | * Maintain a "magic" minimum address. This keeps some older | |
168 | * firmware platforms running. | |
169 | */ | |
170 | ||
171 | if (claim_base < PROG_START) | |
172 | claim_base = PROG_START; | |
173 | #endif | |
1da177e4 | 174 | |
8a76baf0 OH |
175 | vmlinuz.addr = (unsigned long)_vmlinux_start; |
176 | vmlinuz.size = (unsigned long)(_vmlinux_end - _vmlinux_start); | |
177 | ||
178 | /* gunzip the ELF header of the kernel */ | |
179 | if (*(unsigned short *)vmlinuz.addr == 0x1f8b) { | |
180 | len = vmlinuz.size; | |
181 | gunzip(elfheader, sizeof(elfheader), | |
182 | (unsigned char *)vmlinuz.addr, &len); | |
183 | } else | |
184 | memcpy(elfheader, (const void *)vmlinuz.addr, sizeof(elfheader)); | |
185 | ||
186 | elf64 = (Elf64_Ehdr *)elfheader; | |
187 | if ( elf64->e_ident[EI_MAG0] != ELFMAG0 || | |
188 | elf64->e_ident[EI_MAG1] != ELFMAG1 || | |
189 | elf64->e_ident[EI_MAG2] != ELFMAG2 || | |
190 | elf64->e_ident[EI_MAG3] != ELFMAG3 || | |
191 | elf64->e_ident[EI_CLASS] != ELFCLASS64 || | |
192 | elf64->e_ident[EI_DATA] != ELFDATA2MSB || | |
193 | elf64->e_type != ET_EXEC || | |
194 | elf64->e_machine != EM_PPC64 ) | |
195 | { | |
196 | printf("Error: not a valid PPC64 ELF file!\n\r"); | |
197 | exit(); | |
198 | } | |
199 | ||
200 | elf64ph = (Elf64_Phdr *)((unsigned long)elf64 + | |
201 | (unsigned long)elf64->e_phoff); | |
202 | for(i=0; i < (unsigned int)elf64->e_phnum ;i++,elf64ph++) { | |
203 | if (elf64ph->p_type == PT_LOAD && elf64ph->p_offset != 0) | |
204 | break; | |
205 | } | |
206 | vmlinux.size = (unsigned long)elf64ph->p_filesz; | |
207 | vmlinux.memsize = (unsigned long)elf64ph->p_memsz; | |
208 | printf("Allocating 0x%lx bytes for kernel ...\n\r", vmlinux.memsize); | |
209 | vmlinux.addr = try_claim(vmlinux.memsize); | |
1da177e4 LT |
210 | if (vmlinux.addr == 0) { |
211 | printf("Can't allocate memory for kernel image !\n\r"); | |
212 | exit(); | |
213 | } | |
1da177e4 LT |
214 | |
215 | /* | |
216 | * Now we try to claim memory for the initrd (and copy it there) | |
217 | */ | |
218 | initrd.size = (unsigned long)(_initrd_end - _initrd_start); | |
219 | initrd.memsize = initrd.size; | |
220 | if ( initrd.size > 0 ) { | |
221 | printf("Allocating 0x%lx bytes for initrd ...\n\r", initrd.size); | |
222 | initrd.addr = try_claim(initrd.size); | |
223 | if (initrd.addr == 0) { | |
224 | printf("Can't allocate memory for initial ramdisk !\n\r"); | |
225 | exit(); | |
226 | } | |
227 | a1 = initrd.addr; | |
228 | a2 = initrd.size; | |
b1bdfbd0 | 229 | printf("initial ramdisk moving 0x%lx <- 0x%lx (0x%lx bytes)\n\r", |
1da177e4 LT |
230 | initrd.addr, (unsigned long)_initrd_start, initrd.size); |
231 | memmove((void *)initrd.addr, (void *)_initrd_start, initrd.size); | |
b1bdfbd0 | 232 | printf("initrd head: 0x%lx\n\r", *((unsigned long *)initrd.addr)); |
1da177e4 LT |
233 | } |
234 | ||
235 | /* Eventually gunzip the kernel */ | |
236 | if (*(unsigned short *)vmlinuz.addr == 0x1f8b) { | |
1da177e4 LT |
237 | printf("gunzipping (0x%lx <- 0x%lx:0x%0lx)...", |
238 | vmlinux.addr, vmlinuz.addr, vmlinuz.addr+vmlinuz.size); | |
239 | len = vmlinuz.size; | |
8a76baf0 | 240 | gunzip((void *)vmlinux.addr, vmlinux.memsize, |
1da177e4 LT |
241 | (unsigned char *)vmlinuz.addr, &len); |
242 | printf("done 0x%lx bytes\n\r", len); | |
1da177e4 LT |
243 | } else { |
244 | memmove((void *)vmlinux.addr,(void *)vmlinuz.addr,vmlinuz.size); | |
245 | } | |
246 | ||
247 | /* Skip over the ELF header */ | |
1da177e4 LT |
248 | #ifdef DEBUG |
249 | printf("... skipping 0x%lx bytes of ELF header\n\r", | |
250 | (unsigned long)elf64ph->p_offset); | |
251 | #endif | |
252 | vmlinux.addr += (unsigned long)elf64ph->p_offset; | |
1da177e4 LT |
253 | |
254 | flush_cache((void *)vmlinux.addr, vmlinux.size); | |
255 | ||
1da177e4 LT |
256 | kernel_entry = (kernel_entry_t)vmlinux.addr; |
257 | #ifdef DEBUG | |
258 | printf( "kernel:\n\r" | |
259 | " entry addr = 0x%lx\n\r" | |
260 | " a1 = 0x%lx,\n\r" | |
261 | " a2 = 0x%lx,\n\r" | |
262 | " prom = 0x%lx,\n\r" | |
263 | " bi_recs = 0x%lx,\n\r", | |
264 | (unsigned long)kernel_entry, a1, a2, | |
265 | (unsigned long)prom, NULL); | |
266 | #endif | |
267 | ||
268 | kernel_entry( a1, a2, prom, NULL ); | |
269 | ||
270 | printf("Error: Linux kernel returned to zImage bootloader!\n\r"); | |
271 | ||
272 | exit(); | |
273 | } | |
274 |