]>
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" | |
b2c5f619 | 17 | #include "ops.h" |
e5a2072b | 18 | #include "reg.h" |
decd300b | 19 | |
1da177e4 | 20 | struct addr_range { |
79c85419 | 21 | void *addr; |
1da177e4 | 22 | unsigned long size; |
1da177e4 | 23 | }; |
94b212c2 | 24 | |
1da177e4 LT |
25 | #undef DEBUG |
26 | ||
79c85419 | 27 | static struct addr_range prep_kernel(void) |
1da177e4 | 28 | { |
79c85419 | 29 | char elfheader[256]; |
1b7898ee | 30 | unsigned char *vmlinuz_addr = (unsigned char *)_vmlinux_start; |
79c85419 DG |
31 | unsigned long vmlinuz_size = _vmlinux_end - _vmlinux_start; |
32 | void *addr = 0; | |
33 | struct elf_info ei; | |
1b7898ee | 34 | long len; |
65bc3ece | 35 | int uncompressed_image = 0; |
66a45dd3 | 36 | |
65bc3ece | 37 | len = partial_decompress(vmlinuz_addr, vmlinuz_size, |
1b7898ee | 38 | elfheader, sizeof(elfheader), 0); |
65bc3ece HK |
39 | /* assume uncompressed data if -1 is returned */ |
40 | if (len == -1) { | |
41 | uncompressed_image = 1; | |
42 | memcpy(elfheader, vmlinuz_addr, sizeof(elfheader)); | |
43 | printf("No valid compressed data found, assume uncompressed data\n\r"); | |
44 | } | |
94b212c2 | 45 | |
6a923216 MM |
46 | if (!parse_elf64(elfheader, &ei) && !parse_elf32(elfheader, &ei)) |
47 | fatal("Error: not a valid PPC32 or PPC64 ELF file!\n\r"); | |
48 | ||
b2c5f619 MG |
49 | if (platform_ops.image_hdr) |
50 | platform_ops.image_hdr(elfheader); | |
94b212c2 | 51 | |
ad9d2716 DG |
52 | /* We need to alloc the memsize: gzip will expand the kernel |
53 | * text/data, then possible rubbish we don't care about. But | |
54 | * the kernel bss must be claimed (it will be zero'd by the | |
55 | * kernel itself) | |
c8e3c8b2 | 56 | */ |
1b7898ee | 57 | printf("Allocating 0x%lx bytes for kernel...\n\r", ei.memsize); |
79c85419 DG |
58 | |
59 | if (platform_ops.vmlinux_alloc) { | |
60 | addr = platform_ops.vmlinux_alloc(ei.memsize); | |
61 | } else { | |
c10c178a SS |
62 | /* |
63 | * Check if the kernel image (without bss) would overwrite the | |
64 | * bootwrapper. The device tree has been moved in fdt_init() | |
65 | * to an area allocated with malloc() (somewhere past _end). | |
66 | */ | |
67 | if ((unsigned long)_start < ei.loadsize) | |
6a923216 | 68 | fatal("Insufficient memory for kernel at address 0!" |
8ba4773a | 69 | " (_start=%p, uncompressed size=%08lx)\n\r", |
c10c178a SS |
70 | _start, ei.loadsize); |
71 | ||
72 | if ((unsigned long)_end < ei.memsize) | |
73 | fatal("The final kernel image would overwrite the " | |
74 | "device tree\n\r"); | |
1da177e4 | 75 | } |
1da177e4 | 76 | |
65bc3ece HK |
77 | if (uncompressed_image) { |
78 | memcpy(addr, vmlinuz_addr + ei.elfoffset, ei.loadsize); | |
79 | printf("0x%lx bytes of uncompressed data copied\n\r", | |
80 | ei.loadsize); | |
81 | goto out; | |
82 | } | |
83 | ||
1b7898ee OH |
84 | /* Finally, decompress the kernel */ |
85 | printf("Decompressing (0x%p <- 0x%p:0x%p)...\n\r", addr, | |
79c85419 | 86 | vmlinuz_addr, vmlinuz_addr+vmlinuz_size); |
1b7898ee OH |
87 | |
88 | len = partial_decompress(vmlinuz_addr, vmlinuz_size, | |
89 | addr, ei.loadsize, ei.elfoffset); | |
90 | ||
91 | if (len < 0) | |
92 | fatal("Decompression failed with error code %ld\n\r", len); | |
93 | ||
02cc5114 | 94 | if (len != ei.loadsize) |
1b7898ee OH |
95 | fatal("Decompression error: got 0x%lx bytes, expected 0x%lx.\n\r", |
96 | len, ei.loadsize); | |
97 | ||
98 | printf("Done! Decompressed 0x%lx bytes\n\r", len); | |
65bc3ece | 99 | out: |
79c85419 DG |
100 | flush_cache(addr, ei.loadsize); |
101 | ||
102 | return (struct addr_range){addr, ei.memsize}; | |
103 | } | |
104 | ||
27fbaa97 | 105 | static struct addr_range prep_initrd(struct addr_range vmlinux, void *chosen, |
79c85419 DG |
106 | unsigned long initrd_addr, |
107 | unsigned long initrd_size) | |
108 | { | |
79c85419 DG |
109 | /* If we have an image attached to us, it overrides anything |
110 | * supplied by the loader. */ | |
111 | if (_initrd_end > _initrd_start) { | |
112 | printf("Attached initrd image at 0x%p-0x%p\n\r", | |
113 | _initrd_start, _initrd_end); | |
114 | initrd_addr = (unsigned long)_initrd_start; | |
115 | initrd_size = _initrd_end - _initrd_start; | |
116 | } else if (initrd_size > 0) { | |
117 | printf("Using loader supplied ramdisk at 0x%lx-0x%lx\n\r", | |
118 | initrd_addr, initrd_addr + initrd_size); | |
119 | } | |
120 | ||
121 | /* If there's no initrd at all, we're done */ | |
122 | if (! initrd_size) | |
123 | return (struct addr_range){0, 0}; | |
124 | ||
1da177e4 | 125 | /* |
79c85419 DG |
126 | * If the initrd is too low it will be clobbered when the |
127 | * kernel relocates to its final location. In this case, | |
128 | * allocate a safer place and move it. | |
1da177e4 | 129 | */ |
79c85419 DG |
130 | if (initrd_addr < vmlinux.size) { |
131 | void *old_addr = (void *)initrd_addr; | |
132 | ||
b2c5f619 | 133 | printf("Allocating 0x%lx bytes for initrd ...\n\r", |
79c85419 DG |
134 | initrd_size); |
135 | initrd_addr = (unsigned long)malloc(initrd_size); | |
6a923216 MM |
136 | if (! initrd_addr) |
137 | fatal("Can't allocate memory for initial " | |
79c85419 | 138 | "ramdisk !\n\r"); |
fae59c39 | 139 | printf("Relocating initrd 0x%lx <- 0x%p (0x%lx bytes)\n\r", |
79c85419 DG |
140 | initrd_addr, old_addr, initrd_size); |
141 | memmove((void *)initrd_addr, old_addr, initrd_size); | |
1da177e4 LT |
142 | } |
143 | ||
79c85419 DG |
144 | printf("initrd head: 0x%lx\n\r", *((unsigned long *)initrd_addr)); |
145 | ||
146 | /* Tell the kernel initrd address via device tree */ | |
27fbaa97 DG |
147 | setprop_val(chosen, "linux,initrd-start", (u32)(initrd_addr)); |
148 | setprop_val(chosen, "linux,initrd-end", (u32)(initrd_addr+initrd_size)); | |
1da177e4 | 149 | |
79c85419 | 150 | return (struct addr_range){(void *)initrd_addr, initrd_size}; |
b2c5f619 | 151 | } |
1da177e4 | 152 | |
b2c5f619 MG |
153 | /* A buffer that may be edited by tools operating on a zImage binary so as to |
154 | * edit the command line passed to vmlinux (by setting /chosen/bootargs). | |
155 | * The buffer is put in it's own section so that tools may locate it easier. | |
156 | */ | |
a2dd5da7 | 157 | static char cmdline[BOOT_COMMAND_LINE_SIZE] |
b2c5f619 | 158 | __attribute__((__section__("__builtin_cmdline"))); |
1da177e4 | 159 | |
3af82a8b | 160 | static void prep_cmdline(void *chosen) |
b2c5f619 | 161 | { |
4b4b13d5 SK |
162 | unsigned int getline_timeout = 5000; |
163 | int v; | |
164 | int n; | |
165 | ||
166 | /* Wait-for-input time */ | |
167 | n = getprop(chosen, "linux,cmdline-timeout", &v, sizeof(v)); | |
168 | if (n == sizeof(v)) | |
169 | getline_timeout = v; | |
170 | ||
3af82a8b | 171 | if (cmdline[0] == '\0') |
a2dd5da7 | 172 | getprop(chosen, "bootargs", cmdline, BOOT_COMMAND_LINE_SIZE-1); |
1da177e4 | 173 | |
3af82a8b | 174 | printf("\n\rLinux/PowerPC load: %s", cmdline); |
4b4b13d5 | 175 | |
3af82a8b | 176 | /* If possible, edit the command line */ |
4b4b13d5 SK |
177 | if (console_ops.edit_cmdline && getline_timeout) |
178 | console_ops.edit_cmdline(cmdline, BOOT_COMMAND_LINE_SIZE, getline_timeout); | |
179 | ||
3af82a8b | 180 | printf("\n\r"); |
b2c5f619 | 181 | |
3af82a8b DG |
182 | /* Put the command line back into the devtree for the kernel */ |
183 | setprop_str(chosen, "bootargs", cmdline); | |
1da177e4 LT |
184 | } |
185 | ||
b2c5f619 MG |
186 | struct platform_ops platform_ops; |
187 | struct dt_ops dt_ops; | |
188 | struct console_ops console_ops; | |
cd197ffc | 189 | struct loader_info loader_info; |
b2c5f619 | 190 | |
e5a2072b | 191 | void start(void) |
b2c5f619 | 192 | { |
79c85419 | 193 | struct addr_range vmlinux, initrd; |
b2c5f619 | 194 | kernel_entry_t kentry; |
35af89eb | 195 | unsigned long ft_addr = 0; |
27fbaa97 | 196 | void *chosen; |
b2c5f619 | 197 | |
3af82a8b DG |
198 | /* Do this first, because malloc() could clobber the loader's |
199 | * command line. Only use the loader command line if a | |
200 | * built-in command line wasn't set by an external tool */ | |
201 | if ((loader_info.cmdline_len > 0) && (cmdline[0] == '\0')) | |
202 | memmove(cmdline, loader_info.cmdline, | |
a2dd5da7 | 203 | min(loader_info.cmdline_len, BOOT_COMMAND_LINE_SIZE-1)); |
3af82a8b | 204 | |
b2c5f619 MG |
205 | if (console_ops.open && (console_ops.open() < 0)) |
206 | exit(); | |
207 | if (platform_ops.fixups) | |
208 | platform_ops.fixups(); | |
209 | ||
210 | printf("\n\rzImage starting: loaded at 0x%p (sp: 0x%p)\n\r", | |
e5a2072b | 211 | _start, get_sp()); |
b2c5f619 | 212 | |
27fbaa97 DG |
213 | /* Ensure that the device tree has a /chosen node */ |
214 | chosen = finddevice("/chosen"); | |
215 | if (!chosen) | |
216 | chosen = create_node(NULL, "chosen"); | |
217 | ||
79c85419 | 218 | vmlinux = prep_kernel(); |
27fbaa97 DG |
219 | initrd = prep_initrd(vmlinux, chosen, |
220 | loader_info.initrd_addr, loader_info.initrd_size); | |
3af82a8b | 221 | prep_cmdline(chosen); |
b2c5f619 | 222 | |
35af89eb DG |
223 | printf("Finalizing device tree..."); |
224 | if (dt_ops.finalize) | |
225 | ft_addr = dt_ops.finalize(); | |
226 | if (ft_addr) | |
227 | printf(" flat tree at 0x%lx\n\r", ft_addr); | |
228 | else | |
cd197ffc | 229 | printf(" using OF tree (promptr=%p)\n\r", loader_info.promptr); |
35af89eb | 230 | |
b2c5f619 MG |
231 | if (console_ops.close) |
232 | console_ops.close(); | |
233 | ||
234 | kentry = (kernel_entry_t) vmlinux.addr; | |
a1ff5741 OH |
235 | if (ft_addr) { |
236 | if(platform_ops.kentry) | |
237 | platform_ops.kentry(ft_addr, vmlinux.addr); | |
238 | else | |
239 | kentry(ft_addr, 0, NULL); | |
240 | } | |
b2c5f619 | 241 | else |
cd197ffc DG |
242 | kentry((unsigned long)initrd.addr, initrd.size, |
243 | loader_info.promptr); | |
b2c5f619 | 244 | |
6a923216 MM |
245 | /* console closed so printf in fatal below may not work */ |
246 | fatal("Error: Linux kernel returned to zImage boot wrapper!\n\r"); | |
b2c5f619 | 247 | } |