Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | */ |
Olaf Hering | decd300 | 2005-08-08 13:24:38 +1000 | [diff] [blame] | 11 | #include <stdarg.h> |
| 12 | #include <stddef.h> |
| 13 | #include "elf.h" |
| 14 | #include "page.h" |
| 15 | #include "string.h" |
| 16 | #include "stdio.h" |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 17 | #include "ops.h" |
David Gibson | ad9d271 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 18 | #include "gunzip_util.h" |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 19 | #include "flatdevtree.h" |
David Gibson | e5a2072b | 2007-03-22 17:02:21 +1100 | [diff] [blame] | 20 | #include "reg.h" |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 21 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 22 | extern char _start[]; |
Olaf Hering | 9b0cbe9 | 2005-10-28 17:46:45 -0700 | [diff] [blame] | 23 | extern char __bss_start[]; |
Mark Bellon | 3cc747e | 2005-09-06 15:50:02 -0700 | [diff] [blame] | 24 | extern char _end[]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 25 | extern char _vmlinux_start[]; |
| 26 | extern char _vmlinux_end[]; |
| 27 | extern char _initrd_start[]; |
| 28 | extern char _initrd_end[]; |
Mark A. Greer | c888554 | 2006-10-16 13:49:27 -0700 | [diff] [blame] | 29 | extern char _dtb_start[]; |
| 30 | extern char _dtb_end[]; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 31 | |
David Gibson | ad9d271 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 32 | static struct gunzip_state gzstate; |
| 33 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 34 | struct addr_range { |
David Gibson | 79c8541 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 35 | void *addr; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 36 | unsigned long size; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 37 | }; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 38 | |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 39 | typedef void (*kernel_entry_t)(unsigned long, unsigned long, void *); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 40 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 41 | #undef DEBUG |
| 42 | |
David Gibson | 79c8541 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 43 | static struct addr_range prep_kernel(void) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 44 | { |
David Gibson | 79c8541 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 45 | char elfheader[256]; |
| 46 | void *vmlinuz_addr = _vmlinux_start; |
| 47 | unsigned long vmlinuz_size = _vmlinux_end - _vmlinux_start; |
| 48 | void *addr = 0; |
| 49 | struct elf_info ei; |
Olaf Hering | 8a76baf | 2005-10-28 17:46:40 -0700 | [diff] [blame] | 50 | int len; |
Paul Mackerras | 66a45dd | 2006-01-14 15:04:06 +1100 | [diff] [blame] | 51 | |
Paul Mackerras | 94b212c | 2005-11-16 13:38:21 +1100 | [diff] [blame] | 52 | /* gunzip the ELF header of the kernel */ |
David Gibson | 79c8541 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 53 | gunzip_start(&gzstate, vmlinuz_addr, vmlinuz_size); |
David Gibson | ad9d271 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 54 | gunzip_exactly(&gzstate, elfheader, sizeof(elfheader)); |
Paul Mackerras | 94b212c | 2005-11-16 13:38:21 +1100 | [diff] [blame] | 55 | |
Milton Miller | 6a92321 | 2007-03-21 09:02:44 -0600 | [diff] [blame] | 56 | if (!parse_elf64(elfheader, &ei) && !parse_elf32(elfheader, &ei)) |
| 57 | fatal("Error: not a valid PPC32 or PPC64 ELF file!\n\r"); |
| 58 | |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 59 | if (platform_ops.image_hdr) |
| 60 | platform_ops.image_hdr(elfheader); |
Paul Mackerras | 94b212c | 2005-11-16 13:38:21 +1100 | [diff] [blame] | 61 | |
David Gibson | ad9d271 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 62 | /* We need to alloc the memsize: gzip will expand the kernel |
| 63 | * text/data, then possible rubbish we don't care about. But |
| 64 | * the kernel bss must be claimed (it will be zero'd by the |
| 65 | * kernel itself) |
Benjamin Herrenschmidt | c8e3c8b | 2005-11-07 00:57:58 -0800 | [diff] [blame] | 66 | */ |
David Gibson | 79c8541 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 67 | printf("Allocating 0x%lx bytes for kernel ...\n\r", ei.memsize); |
| 68 | |
| 69 | if (platform_ops.vmlinux_alloc) { |
| 70 | addr = platform_ops.vmlinux_alloc(ei.memsize); |
| 71 | } else { |
Milton Miller | 6a92321 | 2007-03-21 09:02:44 -0600 | [diff] [blame] | 72 | if ((unsigned long)_start < ei.memsize) |
| 73 | fatal("Insufficient memory for kernel at address 0!" |
David Gibson | fae59c3 | 2007-03-22 16:59:13 +1100 | [diff] [blame] | 74 | " (_start=%p)\n\r", _start); |
David Gibson | 79c8541 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 75 | } |
| 76 | |
| 77 | /* Finally, gunzip the kernel */ |
| 78 | printf("gunzipping (0x%p <- 0x%p:0x%p)...", addr, |
| 79 | vmlinuz_addr, vmlinuz_addr+vmlinuz_size); |
| 80 | /* discard up to the actual load data */ |
| 81 | gunzip_discard(&gzstate, ei.elfoffset - sizeof(elfheader)); |
Milton Miller | 02cc511 | 2007-03-29 07:31:41 -0600 | [diff] [blame] | 82 | len = gunzip_finish(&gzstate, addr, ei.loadsize); |
| 83 | if (len != ei.loadsize) |
| 84 | fatal("ran out of data! only got 0x%x of 0x%lx bytes.\n\r", |
| 85 | len, ei.loadsize); |
David Gibson | fae59c3 | 2007-03-22 16:59:13 +1100 | [diff] [blame] | 86 | printf("done 0x%x bytes\n\r", len); |
David Gibson | 79c8541 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 87 | |
| 88 | flush_cache(addr, ei.loadsize); |
| 89 | |
| 90 | return (struct addr_range){addr, ei.memsize}; |
| 91 | } |
| 92 | |
David Gibson | 27fbaa9 | 2007-03-22 17:02:21 +1100 | [diff] [blame] | 93 | static struct addr_range prep_initrd(struct addr_range vmlinux, void *chosen, |
David Gibson | 79c8541 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 94 | unsigned long initrd_addr, |
| 95 | unsigned long initrd_size) |
| 96 | { |
David Gibson | 79c8541 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 97 | /* If we have an image attached to us, it overrides anything |
| 98 | * supplied by the loader. */ |
| 99 | if (_initrd_end > _initrd_start) { |
| 100 | printf("Attached initrd image at 0x%p-0x%p\n\r", |
| 101 | _initrd_start, _initrd_end); |
| 102 | initrd_addr = (unsigned long)_initrd_start; |
| 103 | initrd_size = _initrd_end - _initrd_start; |
| 104 | } else if (initrd_size > 0) { |
| 105 | printf("Using loader supplied ramdisk at 0x%lx-0x%lx\n\r", |
| 106 | initrd_addr, initrd_addr + initrd_size); |
| 107 | } |
| 108 | |
| 109 | /* If there's no initrd at all, we're done */ |
| 110 | if (! initrd_size) |
| 111 | return (struct addr_range){0, 0}; |
| 112 | |
| 113 | /* |
| 114 | * If the initrd is too low it will be clobbered when the |
| 115 | * kernel relocates to its final location. In this case, |
| 116 | * allocate a safer place and move it. |
| 117 | */ |
| 118 | if (initrd_addr < vmlinux.size) { |
| 119 | void *old_addr = (void *)initrd_addr; |
| 120 | |
| 121 | printf("Allocating 0x%lx bytes for initrd ...\n\r", |
| 122 | initrd_size); |
| 123 | initrd_addr = (unsigned long)malloc(initrd_size); |
Milton Miller | 6a92321 | 2007-03-21 09:02:44 -0600 | [diff] [blame] | 124 | if (! initrd_addr) |
| 125 | fatal("Can't allocate memory for initial " |
David Gibson | 79c8541 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 126 | "ramdisk !\n\r"); |
David Gibson | fae59c3 | 2007-03-22 16:59:13 +1100 | [diff] [blame] | 127 | printf("Relocating initrd 0x%lx <- 0x%p (0x%lx bytes)\n\r", |
David Gibson | 79c8541 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 128 | initrd_addr, old_addr, initrd_size); |
| 129 | memmove((void *)initrd_addr, old_addr, initrd_size); |
| 130 | } |
| 131 | |
| 132 | printf("initrd head: 0x%lx\n\r", *((unsigned long *)initrd_addr)); |
| 133 | |
| 134 | /* Tell the kernel initrd address via device tree */ |
David Gibson | 27fbaa9 | 2007-03-22 17:02:21 +1100 | [diff] [blame] | 135 | setprop_val(chosen, "linux,initrd-start", (u32)(initrd_addr)); |
| 136 | setprop_val(chosen, "linux,initrd-end", (u32)(initrd_addr+initrd_size)); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 137 | |
David Gibson | 79c8541 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 138 | return (struct addr_range){(void *)initrd_addr, initrd_size}; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 139 | } |
| 140 | |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 141 | /* A buffer that may be edited by tools operating on a zImage binary so as to |
| 142 | * edit the command line passed to vmlinux (by setting /chosen/bootargs). |
| 143 | * The buffer is put in it's own section so that tools may locate it easier. |
| 144 | */ |
David Gibson | 3af82a8 | 2007-03-22 17:02:21 +1100 | [diff] [blame] | 145 | static char cmdline[COMMAND_LINE_SIZE] |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 146 | __attribute__((__section__("__builtin_cmdline"))); |
| 147 | |
David Gibson | 3af82a8 | 2007-03-22 17:02:21 +1100 | [diff] [blame] | 148 | static void prep_cmdline(void *chosen) |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 149 | { |
David Gibson | 3af82a8 | 2007-03-22 17:02:21 +1100 | [diff] [blame] | 150 | if (cmdline[0] == '\0') |
| 151 | getprop(chosen, "bootargs", cmdline, COMMAND_LINE_SIZE-1); |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 152 | |
David Gibson | 3af82a8 | 2007-03-22 17:02:21 +1100 | [diff] [blame] | 153 | printf("\n\rLinux/PowerPC load: %s", cmdline); |
| 154 | /* If possible, edit the command line */ |
| 155 | if (console_ops.edit_cmdline) |
| 156 | console_ops.edit_cmdline(cmdline, COMMAND_LINE_SIZE); |
| 157 | printf("\n\r"); |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 158 | |
David Gibson | 3af82a8 | 2007-03-22 17:02:21 +1100 | [diff] [blame] | 159 | /* Put the command line back into the devtree for the kernel */ |
| 160 | setprop_str(chosen, "bootargs", cmdline); |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 161 | } |
| 162 | |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 163 | struct platform_ops platform_ops; |
| 164 | struct dt_ops dt_ops; |
| 165 | struct console_ops console_ops; |
David Gibson | cd197ff | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 166 | struct loader_info loader_info; |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 167 | |
David Gibson | e5a2072b | 2007-03-22 17:02:21 +1100 | [diff] [blame] | 168 | void start(void) |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 169 | { |
David Gibson | 79c8541 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 170 | struct addr_range vmlinux, initrd; |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 171 | kernel_entry_t kentry; |
David Gibson | 35af89e | 2006-11-21 11:37:37 +1100 | [diff] [blame] | 172 | unsigned long ft_addr = 0; |
David Gibson | 27fbaa9 | 2007-03-22 17:02:21 +1100 | [diff] [blame] | 173 | void *chosen; |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 174 | |
David Gibson | 3af82a8 | 2007-03-22 17:02:21 +1100 | [diff] [blame] | 175 | /* Do this first, because malloc() could clobber the loader's |
| 176 | * command line. Only use the loader command line if a |
| 177 | * built-in command line wasn't set by an external tool */ |
| 178 | if ((loader_info.cmdline_len > 0) && (cmdline[0] == '\0')) |
| 179 | memmove(cmdline, loader_info.cmdline, |
| 180 | min(loader_info.cmdline_len, COMMAND_LINE_SIZE-1)); |
| 181 | |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 182 | if (console_ops.open && (console_ops.open() < 0)) |
| 183 | exit(); |
| 184 | if (platform_ops.fixups) |
| 185 | platform_ops.fixups(); |
| 186 | |
| 187 | printf("\n\rzImage starting: loaded at 0x%p (sp: 0x%p)\n\r", |
David Gibson | e5a2072b | 2007-03-22 17:02:21 +1100 | [diff] [blame] | 188 | _start, get_sp()); |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 189 | |
David Gibson | 27fbaa9 | 2007-03-22 17:02:21 +1100 | [diff] [blame] | 190 | /* Ensure that the device tree has a /chosen node */ |
| 191 | chosen = finddevice("/chosen"); |
| 192 | if (!chosen) |
| 193 | chosen = create_node(NULL, "chosen"); |
| 194 | |
David Gibson | 79c8541 | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 195 | vmlinux = prep_kernel(); |
David Gibson | 27fbaa9 | 2007-03-22 17:02:21 +1100 | [diff] [blame] | 196 | initrd = prep_initrd(vmlinux, chosen, |
| 197 | loader_info.initrd_addr, loader_info.initrd_size); |
David Gibson | 3af82a8 | 2007-03-22 17:02:21 +1100 | [diff] [blame] | 198 | prep_cmdline(chosen); |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 199 | |
David Gibson | 35af89e | 2006-11-21 11:37:37 +1100 | [diff] [blame] | 200 | printf("Finalizing device tree..."); |
| 201 | if (dt_ops.finalize) |
| 202 | ft_addr = dt_ops.finalize(); |
| 203 | if (ft_addr) |
| 204 | printf(" flat tree at 0x%lx\n\r", ft_addr); |
| 205 | else |
David Gibson | cd197ff | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 206 | printf(" using OF tree (promptr=%p)\n\r", loader_info.promptr); |
David Gibson | 35af89e | 2006-11-21 11:37:37 +1100 | [diff] [blame] | 207 | |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 208 | if (console_ops.close) |
| 209 | console_ops.close(); |
| 210 | |
| 211 | kentry = (kernel_entry_t) vmlinux.addr; |
David Gibson | 35af89e | 2006-11-21 11:37:37 +1100 | [diff] [blame] | 212 | if (ft_addr) |
| 213 | kentry(ft_addr, 0, NULL); |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 214 | else |
David Gibson | cd197ff | 2007-03-05 14:24:52 +1100 | [diff] [blame] | 215 | kentry((unsigned long)initrd.addr, initrd.size, |
| 216 | loader_info.promptr); |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 217 | |
Milton Miller | 6a92321 | 2007-03-21 09:02:44 -0600 | [diff] [blame] | 218 | /* console closed so printf in fatal below may not work */ |
| 219 | fatal("Error: Linux kernel returned to zImage boot wrapper!\n\r"); |
Mark A. Greer | b2c5f61 | 2006-09-19 14:05:08 +1000 | [diff] [blame] | 220 | } |