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"
21 extern void flush_cache(void *, unsigned long);
24 extern char __bss_start
[];
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
[];
33 static struct gunzip_state gzstate
;
41 unsigned long loadsize
;
42 unsigned long memsize
;
43 unsigned long elfoffset
;
46 typedef void (*kernel_entry_t
)(unsigned long, unsigned long, void *);
50 static int parse_elf64(void *hdr
, struct elf_info
*info
)
52 Elf64_Ehdr
*elf64
= hdr
;
56 if (!(elf64
->e_ident
[EI_MAG0
] == ELFMAG0
&&
57 elf64
->e_ident
[EI_MAG1
] == ELFMAG1
&&
58 elf64
->e_ident
[EI_MAG2
] == ELFMAG2
&&
59 elf64
->e_ident
[EI_MAG3
] == ELFMAG3
&&
60 elf64
->e_ident
[EI_CLASS
] == ELFCLASS64
&&
61 elf64
->e_ident
[EI_DATA
] == ELFDATA2MSB
&&
62 elf64
->e_type
== ET_EXEC
&&
63 elf64
->e_machine
== EM_PPC64
))
66 elf64ph
= (Elf64_Phdr
*)((unsigned long)elf64
+
67 (unsigned long)elf64
->e_phoff
);
68 for (i
= 0; i
< (unsigned int)elf64
->e_phnum
; i
++, elf64ph
++)
69 if (elf64ph
->p_type
== PT_LOAD
)
71 if (i
>= (unsigned int)elf64
->e_phnum
)
74 info
->loadsize
= (unsigned long)elf64ph
->p_filesz
;
75 info
->memsize
= (unsigned long)elf64ph
->p_memsz
;
76 info
->elfoffset
= (unsigned long)elf64ph
->p_offset
;
81 static int parse_elf32(void *hdr
, struct elf_info
*info
)
83 Elf32_Ehdr
*elf32
= hdr
;
87 if (!(elf32
->e_ident
[EI_MAG0
] == ELFMAG0
&&
88 elf32
->e_ident
[EI_MAG1
] == ELFMAG1
&&
89 elf32
->e_ident
[EI_MAG2
] == ELFMAG2
&&
90 elf32
->e_ident
[EI_MAG3
] == ELFMAG3
&&
91 elf32
->e_ident
[EI_CLASS
] == ELFCLASS32
&&
92 elf32
->e_ident
[EI_DATA
] == ELFDATA2MSB
&&
93 elf32
->e_type
== ET_EXEC
&&
94 elf32
->e_machine
== EM_PPC
))
97 elf32ph
= (Elf32_Phdr
*) ((unsigned long)elf32
+ elf32
->e_phoff
);
98 for (i
= 0; i
< elf32
->e_phnum
; i
++, elf32ph
++)
99 if (elf32ph
->p_type
== PT_LOAD
)
101 if (i
>= elf32
->e_phnum
)
104 info
->loadsize
= elf32ph
->p_filesz
;
105 info
->memsize
= elf32ph
->p_memsz
;
106 info
->elfoffset
= elf32ph
->p_offset
;
110 static struct addr_range
prep_kernel(void)
113 void *vmlinuz_addr
= _vmlinux_start
;
114 unsigned long vmlinuz_size
= _vmlinux_end
- _vmlinux_start
;
119 /* gunzip the ELF header of the kernel */
120 gunzip_start(&gzstate
, vmlinuz_addr
, vmlinuz_size
);
121 gunzip_exactly(&gzstate
, elfheader
, sizeof(elfheader
));
123 if (!parse_elf64(elfheader
, &ei
) && !parse_elf32(elfheader
, &ei
)) {
124 printf("Error: not a valid PPC32 or PPC64 ELF file!\n\r");
127 if (platform_ops
.image_hdr
)
128 platform_ops
.image_hdr(elfheader
);
130 /* We need to alloc the memsize: gzip will expand the kernel
131 * text/data, then possible rubbish we don't care about. But
132 * the kernel bss must be claimed (it will be zero'd by the
135 printf("Allocating 0x%lx bytes for kernel ...\n\r", ei
.memsize
);
137 if (platform_ops
.vmlinux_alloc
) {
138 addr
= platform_ops
.vmlinux_alloc(ei
.memsize
);
140 if ((unsigned long)_start
< ei
.memsize
) {
141 printf("Insufficient memory for kernel at address 0!"
142 " (_start=%lx)\n\r", _start
);
147 /* Finally, gunzip the kernel */
148 printf("gunzipping (0x%p <- 0x%p:0x%p)...", addr
,
149 vmlinuz_addr
, vmlinuz_addr
+vmlinuz_size
);
150 /* discard up to the actual load data */
151 gunzip_discard(&gzstate
, ei
.elfoffset
- sizeof(elfheader
));
152 len
= gunzip_finish(&gzstate
, addr
, ei
.memsize
);
153 printf("done 0x%lx bytes\n\r", len
);
155 flush_cache(addr
, ei
.loadsize
);
157 return (struct addr_range
){addr
, ei
.memsize
};
160 static struct addr_range
prep_initrd(struct addr_range vmlinux
,
161 unsigned long initrd_addr
,
162 unsigned long initrd_size
)
165 u32 initrd_start
, initrd_end
;
167 /* If we have an image attached to us, it overrides anything
168 * supplied by the loader. */
169 if (_initrd_end
> _initrd_start
) {
170 printf("Attached initrd image at 0x%p-0x%p\n\r",
171 _initrd_start
, _initrd_end
);
172 initrd_addr
= (unsigned long)_initrd_start
;
173 initrd_size
= _initrd_end
- _initrd_start
;
174 } else if (initrd_size
> 0) {
175 printf("Using loader supplied ramdisk at 0x%lx-0x%lx\n\r",
176 initrd_addr
, initrd_addr
+ initrd_size
);
179 /* If there's no initrd at all, we're done */
181 return (struct addr_range
){0, 0};
184 * If the initrd is too low it will be clobbered when the
185 * kernel relocates to its final location. In this case,
186 * allocate a safer place and move it.
188 if (initrd_addr
< vmlinux
.size
) {
189 void *old_addr
= (void *)initrd_addr
;
191 printf("Allocating 0x%lx bytes for initrd ...\n\r",
193 initrd_addr
= (unsigned long)malloc(initrd_size
);
195 printf("Can't allocate memory for initial "
199 printf("Relocating initrd 0x%p <- 0x%p (0x%lx bytes)\n\r",
200 initrd_addr
, old_addr
, initrd_size
);
201 memmove((void *)initrd_addr
, old_addr
, initrd_size
);
204 printf("initrd head: 0x%lx\n\r", *((unsigned long *)initrd_addr
));
206 /* Tell the kernel initrd address via device tree */
207 devp
= finddevice("/chosen");
209 printf("Device tree has no chosen node!\n\r");
213 initrd_start
= (u32
)initrd_addr
;
214 initrd_end
= (u32
)initrd_addr
+ initrd_size
;
216 setprop(devp
, "linux,initrd-start", &initrd_start
,
217 sizeof(initrd_start
));
218 setprop(devp
, "linux,initrd-end", &initrd_end
, sizeof(initrd_end
));
220 return (struct addr_range
){(void *)initrd_addr
, initrd_size
};
223 /* A buffer that may be edited by tools operating on a zImage binary so as to
224 * edit the command line passed to vmlinux (by setting /chosen/bootargs).
225 * The buffer is put in it's own section so that tools may locate it easier.
227 static char builtin_cmdline
[COMMAND_LINE_SIZE
]
228 __attribute__((__section__("__builtin_cmdline")));
230 static void get_cmdline(char *buf
, int size
)
233 int len
= strlen(builtin_cmdline
);
237 if (len
> 0) { /* builtin_cmdline overrides dt's /chosen/bootargs */
238 len
= min(len
, size
-1);
239 strncpy(buf
, builtin_cmdline
, len
);
242 else if ((devp
= finddevice("/chosen")))
243 getprop(devp
, "bootargs", buf
, size
);
246 static void set_cmdline(char *buf
)
250 if ((devp
= finddevice("/chosen")))
251 setprop(devp
, "bootargs", buf
, strlen(buf
) + 1);
254 struct platform_ops platform_ops
;
255 struct dt_ops dt_ops
;
256 struct console_ops console_ops
;
257 struct loader_info loader_info
;
261 struct addr_range vmlinux
, initrd
;
262 kernel_entry_t kentry
;
263 char cmdline
[COMMAND_LINE_SIZE
];
264 unsigned long ft_addr
= 0;
266 if (console_ops
.open
&& (console_ops
.open() < 0))
268 if (platform_ops
.fixups
)
269 platform_ops
.fixups();
271 printf("\n\rzImage starting: loaded at 0x%p (sp: 0x%p)\n\r",
274 vmlinux
= prep_kernel();
275 initrd
= prep_initrd(vmlinux
, loader_info
.initrd_addr
,
276 loader_info
.initrd_size
);
278 /* If cmdline came from zimage wrapper or if we can edit the one
279 * in the dt, print it out and edit it, if possible.
281 if ((strlen(builtin_cmdline
) > 0) || console_ops
.edit_cmdline
) {
282 get_cmdline(cmdline
, COMMAND_LINE_SIZE
);
283 printf("\n\rLinux/PowerPC load: %s", cmdline
);
284 if (console_ops
.edit_cmdline
)
285 console_ops
.edit_cmdline(cmdline
, COMMAND_LINE_SIZE
);
287 set_cmdline(cmdline
);
290 printf("Finalizing device tree...");
292 ft_addr
= dt_ops
.finalize();
294 printf(" flat tree at 0x%lx\n\r", ft_addr
);
296 printf(" using OF tree (promptr=%p)\n\r", loader_info
.promptr
);
298 if (console_ops
.close
)
301 kentry
= (kernel_entry_t
) vmlinux
.addr
;
303 kentry(ft_addr
, 0, NULL
);
305 kentry((unsigned long)initrd
.addr
, initrd
.size
,
306 loader_info
.promptr
);
308 /* console closed so printf below may not work */
309 printf("Error: Linux kernel returned to zImage boot wrapper!\n\r");