Pull platform-drivers into test branch
[linux-2.6] / arch / powerpc / boot / main.c
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  */
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 "zlib.h"
18 #include "ops.h"
19 #include "flatdevtree.h"
20
21 extern void flush_cache(void *, unsigned long);
22
23 extern char _start[];
24 extern char __bss_start[];
25 extern char _end[];
26 extern char _vmlinux_start[];
27 extern char _vmlinux_end[];
28 extern char _initrd_start[];
29 extern char _initrd_end[];
30 extern char _dtb_start[];
31 extern char _dtb_end[];
32
33 struct addr_range {
34         unsigned long addr;
35         unsigned long size;
36         unsigned long memsize;
37 };
38 static struct addr_range vmlinux;
39 static struct addr_range vmlinuz;
40 static struct addr_range initrd;
41
42 static unsigned long elfoffset;
43 static int is_64bit;
44
45 /* scratch space for gunzip; 46912 is from zlib_inflate_workspacesize() */
46 static char scratch[46912];
47 static char elfheader[256];
48
49 typedef void (*kernel_entry_t)(unsigned long, unsigned long, void *);
50
51 #undef DEBUG
52
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
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++)
129                 if (elf64ph->p_type == PT_LOAD)
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;
137
138         is_64bit = 1;
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++)
161                 if (elf32ph->p_type == PT_LOAD)
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
172 static void prep_kernel(unsigned long a1, unsigned long a2)
173 {
174         int len;
175
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
185                 memcpy(elfheader, (const void *)vmlinuz.addr,
186                        sizeof(elfheader));
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         }
192         if (platform_ops.image_hdr)
193                 platform_ops.image_hdr(elfheader);
194
195         /* We need to alloc the memsize plus the file offset since gzip
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          */
200         printf("Allocating 0x%lx bytes for kernel ...\n\r", vmlinux.memsize);
201         vmlinux.addr = (unsigned long)malloc(vmlinux.memsize);
202         if (vmlinux.addr == 0) {
203                 printf("Can't allocate memory for kernel image !\n\r");
204                 exit();
205         }
206
207         /*
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.
212          */
213         initrd.size = (unsigned long)(_initrd_end - _initrd_start);
214         initrd.memsize = initrd.size;
215         if (initrd.size > 0) {
216                 printf("Allocating 0x%lx bytes for initrd ...\n\r",
217                        initrd.size);
218                 initrd.addr = (unsigned long)malloc((u32)initrd.size);
219                 if (initrd.addr == 0) {
220                         printf("Can't allocate memory for initial "
221                                         "ramdisk !\n\r");
222                         exit();
223                 }
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));
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);
237         }
238
239         /* Eventually gunzip the kernel */
240         if (*(unsigned short *)vmlinuz.addr == 0x1f8b) {
241                 printf("gunzipping (0x%lx <- 0x%lx:0x%0lx)...",
242                        vmlinux.addr, vmlinuz.addr, vmlinuz.addr+vmlinuz.size);
243                 len = vmlinuz.size;
244                 gunzip((void *)vmlinux.addr, vmlinux.memsize,
245                         (unsigned char *)vmlinuz.addr, &len);
246                 printf("done 0x%lx bytes\n\r", len);
247         } else {
248                 memmove((void *)vmlinux.addr,(void *)vmlinuz.addr,
249                         vmlinuz.size);
250         }
251
252         /* Skip over the ELF header */
253 #ifdef DEBUG
254         printf("... skipping 0x%lx bytes of ELF header\n\r",
255                         elfoffset);
256 #endif
257         vmlinux.addr += elfoffset;
258
259         flush_cache((void *)vmlinux.addr, vmlinux.size);
260 }
261
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")));
268
269 static void get_cmdline(char *buf, int size)
270 {
271         void *devp;
272         int len = strlen(builtin_cmdline);
273
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);
291 }
292
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 {
299         kernel_entry_t kentry;
300         char cmdline[COMMAND_LINE_SIZE];
301         unsigned long ft_addr = 0;
302
303         memset(__bss_start, 0, _end - __bss_start);
304         memset(&platform_ops, 0, sizeof(platform_ops));
305         memset(&dt_ops, 0, sizeof(dt_ops));
306         memset(&console_ops, 0, sizeof(console_ops));
307
308         if (platform_init(promptr, _dtb_start, _dtb_end))
309                 exit();
310         if (console_ops.open && (console_ops.open() < 0))
311                 exit();
312         if (platform_ops.fixups)
313                 platform_ops.fixups();
314
315         printf("\n\rzImage starting: loaded at 0x%p (sp: 0x%p)\n\r",
316                _start, sp);
317
318         prep_kernel(a1, a2);
319
320         /* If cmdline came from zimage wrapper or if we can edit the one
321          * in the dt, print it out and edit it, if possible.
322          */
323         if ((strlen(builtin_cmdline) > 0) || console_ops.edit_cmdline) {
324                 get_cmdline(cmdline, COMMAND_LINE_SIZE);
325                 printf("\n\rLinux/PowerPC load: %s", cmdline);
326                 if (console_ops.edit_cmdline)
327                         console_ops.edit_cmdline(cmdline, COMMAND_LINE_SIZE);
328                 printf("\n\r");
329                 set_cmdline(cmdline);
330         }
331
332         printf("Finalizing device tree...");
333         if (dt_ops.finalize)
334                 ft_addr = dt_ops.finalize();
335         if (ft_addr)
336                 printf(" flat tree at 0x%lx\n\r", ft_addr);
337         else
338                 printf(" using OF tree (promptr=%p)\n\r", promptr);
339
340         if (console_ops.close)
341                 console_ops.close();
342
343         kentry = (kernel_entry_t) vmlinux.addr;
344         if (ft_addr)
345                 kentry(ft_addr, 0, NULL);
346         else
347                 /* XXX initrd addr/size should be passed in properties */
348                 kentry(initrd.addr, initrd.size, promptr);
349
350         /* console closed so printf below may not work */
351         printf("Error: Linux kernel returned to zImage boot wrapper!\n\r");
352         exit();
353 }