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