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"
23 extern char __bss_start
[];
25 extern char _vmlinux_start
[];
26 extern char _vmlinux_end
[];
27 extern char _initrd_start
[];
28 extern char _initrd_end
[];
29 extern char _dtb_start
[];
30 extern char _dtb_end
[];
32 static struct gunzip_state gzstate
;
40 unsigned long loadsize
;
41 unsigned long memsize
;
42 unsigned long elfoffset
;
45 typedef void (*kernel_entry_t
)(unsigned long, unsigned long, void *);
49 static int parse_elf64(void *hdr
, struct elf_info
*info
)
51 Elf64_Ehdr
*elf64
= hdr
;
55 if (!(elf64
->e_ident
[EI_MAG0
] == ELFMAG0
&&
56 elf64
->e_ident
[EI_MAG1
] == ELFMAG1
&&
57 elf64
->e_ident
[EI_MAG2
] == ELFMAG2
&&
58 elf64
->e_ident
[EI_MAG3
] == ELFMAG3
&&
59 elf64
->e_ident
[EI_CLASS
] == ELFCLASS64
&&
60 elf64
->e_ident
[EI_DATA
] == ELFDATA2MSB
&&
61 elf64
->e_type
== ET_EXEC
&&
62 elf64
->e_machine
== EM_PPC64
))
65 elf64ph
= (Elf64_Phdr
*)((unsigned long)elf64
+
66 (unsigned long)elf64
->e_phoff
);
67 for (i
= 0; i
< (unsigned int)elf64
->e_phnum
; i
++, elf64ph
++)
68 if (elf64ph
->p_type
== PT_LOAD
)
70 if (i
>= (unsigned int)elf64
->e_phnum
)
73 info
->loadsize
= (unsigned long)elf64ph
->p_filesz
;
74 info
->memsize
= (unsigned long)elf64ph
->p_memsz
;
75 info
->elfoffset
= (unsigned long)elf64ph
->p_offset
;
80 static int parse_elf32(void *hdr
, struct elf_info
*info
)
82 Elf32_Ehdr
*elf32
= hdr
;
86 if (!(elf32
->e_ident
[EI_MAG0
] == ELFMAG0
&&
87 elf32
->e_ident
[EI_MAG1
] == ELFMAG1
&&
88 elf32
->e_ident
[EI_MAG2
] == ELFMAG2
&&
89 elf32
->e_ident
[EI_MAG3
] == ELFMAG3
&&
90 elf32
->e_ident
[EI_CLASS
] == ELFCLASS32
&&
91 elf32
->e_ident
[EI_DATA
] == ELFDATA2MSB
&&
92 elf32
->e_type
== ET_EXEC
&&
93 elf32
->e_machine
== EM_PPC
))
96 elf32ph
= (Elf32_Phdr
*) ((unsigned long)elf32
+ elf32
->e_phoff
);
97 for (i
= 0; i
< elf32
->e_phnum
; i
++, elf32ph
++)
98 if (elf32ph
->p_type
== PT_LOAD
)
100 if (i
>= elf32
->e_phnum
)
103 info
->loadsize
= elf32ph
->p_filesz
;
104 info
->memsize
= elf32ph
->p_memsz
;
105 info
->elfoffset
= elf32ph
->p_offset
;
109 static struct addr_range
prep_kernel(void)
112 void *vmlinuz_addr
= _vmlinux_start
;
113 unsigned long vmlinuz_size
= _vmlinux_end
- _vmlinux_start
;
118 /* gunzip the ELF header of the kernel */
119 gunzip_start(&gzstate
, vmlinuz_addr
, vmlinuz_size
);
120 gunzip_exactly(&gzstate
, elfheader
, sizeof(elfheader
));
122 if (!parse_elf64(elfheader
, &ei
) && !parse_elf32(elfheader
, &ei
))
123 fatal("Error: not a valid PPC32 or PPC64 ELF file!\n\r");
125 if (platform_ops
.image_hdr
)
126 platform_ops
.image_hdr(elfheader
);
128 /* We need to alloc the memsize: gzip will expand the kernel
129 * text/data, then possible rubbish we don't care about. But
130 * the kernel bss must be claimed (it will be zero'd by the
133 printf("Allocating 0x%lx bytes for kernel ...\n\r", ei
.memsize
);
135 if (platform_ops
.vmlinux_alloc
) {
136 addr
= platform_ops
.vmlinux_alloc(ei
.memsize
);
138 if ((unsigned long)_start
< ei
.memsize
)
139 fatal("Insufficient memory for kernel at address 0!"
140 " (_start=%p)\n\r", _start
);
143 /* Finally, gunzip the kernel */
144 printf("gunzipping (0x%p <- 0x%p:0x%p)...", addr
,
145 vmlinuz_addr
, vmlinuz_addr
+vmlinuz_size
);
146 /* discard up to the actual load data */
147 gunzip_discard(&gzstate
, ei
.elfoffset
- sizeof(elfheader
));
148 len
= gunzip_finish(&gzstate
, addr
, ei
.memsize
);
149 printf("done 0x%x bytes\n\r", len
);
151 flush_cache(addr
, ei
.loadsize
);
153 return (struct addr_range
){addr
, ei
.memsize
};
156 static struct addr_range
prep_initrd(struct addr_range vmlinux
,
157 unsigned long initrd_addr
,
158 unsigned long initrd_size
)
161 u32 initrd_start
, initrd_end
;
163 /* If we have an image attached to us, it overrides anything
164 * supplied by the loader. */
165 if (_initrd_end
> _initrd_start
) {
166 printf("Attached initrd image at 0x%p-0x%p\n\r",
167 _initrd_start
, _initrd_end
);
168 initrd_addr
= (unsigned long)_initrd_start
;
169 initrd_size
= _initrd_end
- _initrd_start
;
170 } else if (initrd_size
> 0) {
171 printf("Using loader supplied ramdisk at 0x%lx-0x%lx\n\r",
172 initrd_addr
, initrd_addr
+ initrd_size
);
175 /* If there's no initrd at all, we're done */
177 return (struct addr_range
){0, 0};
180 * If the initrd is too low it will be clobbered when the
181 * kernel relocates to its final location. In this case,
182 * allocate a safer place and move it.
184 if (initrd_addr
< vmlinux
.size
) {
185 void *old_addr
= (void *)initrd_addr
;
187 printf("Allocating 0x%lx bytes for initrd ...\n\r",
189 initrd_addr
= (unsigned long)malloc(initrd_size
);
191 fatal("Can't allocate memory for initial "
193 printf("Relocating initrd 0x%lx <- 0x%p (0x%lx bytes)\n\r",
194 initrd_addr
, old_addr
, initrd_size
);
195 memmove((void *)initrd_addr
, old_addr
, initrd_size
);
198 printf("initrd head: 0x%lx\n\r", *((unsigned long *)initrd_addr
));
200 /* Tell the kernel initrd address via device tree */
201 devp
= finddevice("/chosen");
203 fatal("Device tree has no chosen node!\n\r");
205 initrd_start
= (u32
)initrd_addr
;
206 initrd_end
= (u32
)initrd_addr
+ initrd_size
;
208 setprop(devp
, "linux,initrd-start", &initrd_start
,
209 sizeof(initrd_start
));
210 setprop(devp
, "linux,initrd-end", &initrd_end
, sizeof(initrd_end
));
212 return (struct addr_range
){(void *)initrd_addr
, initrd_size
};
215 /* A buffer that may be edited by tools operating on a zImage binary so as to
216 * edit the command line passed to vmlinux (by setting /chosen/bootargs).
217 * The buffer is put in it's own section so that tools may locate it easier.
219 static char builtin_cmdline
[COMMAND_LINE_SIZE
]
220 __attribute__((__section__("__builtin_cmdline")));
222 static void get_cmdline(char *buf
, int size
)
225 int len
= strlen(builtin_cmdline
);
229 if (len
> 0) { /* builtin_cmdline overrides dt's /chosen/bootargs */
230 len
= min(len
, size
-1);
231 strncpy(buf
, builtin_cmdline
, len
);
234 else if ((devp
= finddevice("/chosen")))
235 getprop(devp
, "bootargs", buf
, size
);
238 static void set_cmdline(char *buf
)
242 if ((devp
= finddevice("/chosen")))
243 setprop(devp
, "bootargs", buf
, strlen(buf
) + 1);
246 struct platform_ops platform_ops
;
247 struct dt_ops dt_ops
;
248 struct console_ops console_ops
;
249 struct loader_info loader_info
;
253 struct addr_range vmlinux
, initrd
;
254 kernel_entry_t kentry
;
255 char cmdline
[COMMAND_LINE_SIZE
];
256 unsigned long ft_addr
= 0;
258 if (console_ops
.open
&& (console_ops
.open() < 0))
260 if (platform_ops
.fixups
)
261 platform_ops
.fixups();
263 printf("\n\rzImage starting: loaded at 0x%p (sp: 0x%p)\n\r",
266 vmlinux
= prep_kernel();
267 initrd
= prep_initrd(vmlinux
, loader_info
.initrd_addr
,
268 loader_info
.initrd_size
);
270 /* If cmdline came from zimage wrapper or if we can edit the one
271 * in the dt, print it out and edit it, if possible.
273 if ((strlen(builtin_cmdline
) > 0) || console_ops
.edit_cmdline
) {
274 get_cmdline(cmdline
, COMMAND_LINE_SIZE
);
275 printf("\n\rLinux/PowerPC load: %s", cmdline
);
276 if (console_ops
.edit_cmdline
)
277 console_ops
.edit_cmdline(cmdline
, COMMAND_LINE_SIZE
);
279 set_cmdline(cmdline
);
282 printf("Finalizing device tree...");
284 ft_addr
= dt_ops
.finalize();
286 printf(" flat tree at 0x%lx\n\r", ft_addr
);
288 printf(" using OF tree (promptr=%p)\n\r", loader_info
.promptr
);
290 if (console_ops
.close
)
293 kentry
= (kernel_entry_t
) vmlinux
.addr
;
295 kentry(ft_addr
, 0, NULL
);
297 kentry((unsigned long)initrd
.addr
, initrd
.size
,
298 loader_info
.promptr
);
300 /* console closed so printf in fatal below may not work */
301 fatal("Error: Linux kernel returned to zImage boot wrapper!\n\r");