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