main.c revision fae59c39e885148acf42320fe0d4ebf4cb3e9231 
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 "ops.h"
18#include "gunzip_util.h"
19#include "flatdevtree.h"
20
21extern char _start[];
22extern char __bss_start[];
23extern char _end[];
24extern char _vmlinux_start[];
25extern char _vmlinux_end[];
26extern char _initrd_start[];
27extern char _initrd_end[];
28extern char _dtb_start[];
29extern char _dtb_end[];
30
31static struct gunzip_state gzstate;
32
33struct addr_range {
34	void *addr;
35	unsigned long size;
36};
37
38struct elf_info {
39	unsigned long loadsize;
40	unsigned long memsize;
41	unsigned long elfoffset;
42};
43
44typedef void (*kernel_entry_t)(unsigned long, unsigned long, void *);
45
46#undef DEBUG
47
48static int parse_elf64(void *hdr, struct elf_info *info)
49{
50	Elf64_Ehdr *elf64 = hdr;
51	Elf64_Phdr *elf64ph;
52	unsigned int i;
53
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))
62		return 0;
63
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)
68			break;
69	if (i >= (unsigned int)elf64->e_phnum)
70		return 0;
71
72	info->loadsize = (unsigned long)elf64ph->p_filesz;
73	info->memsize = (unsigned long)elf64ph->p_memsz;
74	info->elfoffset = (unsigned long)elf64ph->p_offset;
75
76	return 1;
77}
78
79static int parse_elf32(void *hdr, struct elf_info *info)
80{
81	Elf32_Ehdr *elf32 = hdr;
82	Elf32_Phdr *elf32ph;
83	unsigned int i;
84
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))
93		return 0;
94
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)
98			break;
99	if (i >= elf32->e_phnum)
100		return 0;
101
102	info->loadsize = elf32ph->p_filesz;
103	info->memsize = elf32ph->p_memsz;
104	info->elfoffset = elf32ph->p_offset;
105	return 1;
106}
107
108static struct addr_range prep_kernel(void)
109{
110	char elfheader[256];
111	void *vmlinuz_addr = _vmlinux_start;
112	unsigned long vmlinuz_size = _vmlinux_end - _vmlinux_start;
113	void *addr = 0;
114	struct elf_info ei;
115	int len;
116
117	/* gunzip the ELF header of the kernel */
118	gunzip_start(&gzstate, vmlinuz_addr, vmlinuz_size);
119	gunzip_exactly(&gzstate, elfheader, sizeof(elfheader));
120
121	if (!parse_elf64(elfheader, &ei) && !parse_elf32(elfheader, &ei))
122		fatal("Error: not a valid PPC32 or PPC64 ELF file!\n\r");
123
124	if (platform_ops.image_hdr)
125		platform_ops.image_hdr(elfheader);
126
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
130	 * kernel itself)
131	 */
132	printf("Allocating 0x%lx bytes for kernel ...\n\r", ei.memsize);
133
134	if (platform_ops.vmlinux_alloc) {
135		addr = platform_ops.vmlinux_alloc(ei.memsize);
136	} else {
137		if ((unsigned long)_start < ei.memsize)
138			fatal("Insufficient memory for kernel at address 0!"
139			       " (_start=%p)\n\r", _start);
140	}
141
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%x bytes\n\r", len);
149
150	flush_cache(addr, ei.loadsize);
151
152	return (struct addr_range){addr, ei.memsize};
153}
154
155static struct addr_range prep_initrd(struct addr_range vmlinux,
156				     unsigned long initrd_addr,
157				     unsigned long initrd_size)
158{
159	void *devp;
160	u32 initrd_start, initrd_end;
161
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);
172	}
173
174	/* If there's no initrd at all, we're done */
175	if (! initrd_size)
176		return (struct addr_range){0, 0};
177
178	/*
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.
182	 */
183	if (initrd_addr < vmlinux.size) {
184		void *old_addr = (void *)initrd_addr;
185
186		printf("Allocating 0x%lx bytes for initrd ...\n\r",
187		       initrd_size);
188		initrd_addr = (unsigned long)malloc(initrd_size);
189		if (! initrd_addr)
190			fatal("Can't allocate memory for initial "
191			       "ramdisk !\n\r");
192		printf("Relocating initrd 0x%lx <- 0x%p (0x%lx bytes)\n\r",
193		       initrd_addr, old_addr, initrd_size);
194		memmove((void *)initrd_addr, old_addr, initrd_size);
195	}
196
197	printf("initrd head: 0x%lx\n\r", *((unsigned long *)initrd_addr));
198
199	/* Tell the kernel initrd address via device tree */
200	devp = finddevice("/chosen");
201	if (! devp)
202		fatal("Device tree has no chosen node!\n\r");
203
204	initrd_start = (u32)initrd_addr;
205	initrd_end = (u32)initrd_addr + initrd_size;
206
207	setprop(devp, "linux,initrd-start", &initrd_start,
208		sizeof(initrd_start));
209	setprop(devp, "linux,initrd-end", &initrd_end, sizeof(initrd_end));
210
211	return (struct addr_range){(void *)initrd_addr, initrd_size};
212}
213
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.
217 */
218static char builtin_cmdline[COMMAND_LINE_SIZE]
219	__attribute__((__section__("__builtin_cmdline")));
220
221static void get_cmdline(char *buf, int size)
222{
223	void *devp;
224	int len = strlen(builtin_cmdline);
225
226	buf[0] = '\0';
227
228	if (len > 0) { /* builtin_cmdline overrides dt's /chosen/bootargs */
229		len = min(len, size-1);
230		strncpy(buf, builtin_cmdline, len);
231		buf[len] = '\0';
232	}
233	else if ((devp = finddevice("/chosen")))
234		getprop(devp, "bootargs", buf, size);
235}
236
237static void set_cmdline(char *buf)
238{
239	void *devp;
240
241	if ((devp = finddevice("/chosen")))
242		setprop(devp, "bootargs", buf, strlen(buf) + 1);
243}
244
245struct platform_ops platform_ops;
246struct dt_ops dt_ops;
247struct console_ops console_ops;
248struct loader_info loader_info;
249
250void start(void *sp)
251{
252	struct addr_range vmlinux, initrd;
253	kernel_entry_t kentry;
254	char cmdline[COMMAND_LINE_SIZE];
255	unsigned long ft_addr = 0;
256
257	if (console_ops.open && (console_ops.open() < 0))
258		exit();
259	if (platform_ops.fixups)
260		platform_ops.fixups();
261
262	printf("\n\rzImage starting: loaded at 0x%p (sp: 0x%p)\n\r",
263	       _start, sp);
264
265	vmlinux = prep_kernel();
266	initrd = prep_initrd(vmlinux, loader_info.initrd_addr,
267			     loader_info.initrd_size);
268
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.
271	 */
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);
277		printf("\n\r");
278		set_cmdline(cmdline);
279	}
280
281	printf("Finalizing device tree...");
282	if (dt_ops.finalize)
283		ft_addr = dt_ops.finalize();
284	if (ft_addr)
285		printf(" flat tree at 0x%lx\n\r", ft_addr);
286	else
287		printf(" using OF tree (promptr=%p)\n\r", loader_info.promptr);
288
289	if (console_ops.close)
290		console_ops.close();
291
292	kentry = (kernel_entry_t) vmlinux.addr;
293	if (ft_addr)
294		kentry(ft_addr, 0, NULL);
295	else
296		kentry((unsigned long)initrd.addr, initrd.size,
297		       loader_info.promptr);
298
299	/* console closed so printf in fatal below may not work */
300	fatal("Error: Linux kernel returned to zImage boot wrapper!\n\r");
301}
302