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