Tom Rini | 83d290c | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 2 | /* |
Gabe Black | d3a2bc3 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 3 | * Copyright (c) 2011 The Chromium OS Authors. |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 4 | * (C) Copyright 2002 |
Albert ARIBAUD | fa82f87 | 2011-08-04 18:45:45 +0200 | [diff] [blame] | 5 | * Daniel Engström, Omicron Ceti AB, <daniel@omicron.se> |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 6 | */ |
| 7 | |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 8 | /* |
Graeme Russ | dbf7115 | 2011-04-13 19:43:26 +1000 | [diff] [blame] | 9 | * Linux x86 zImage and bzImage loading |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 10 | * |
| 11 | * based on the procdure described in |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 12 | * linux/Documentation/i386/boot.txt |
| 13 | */ |
| 14 | |
| 15 | #include <common.h> |
Simon Glass | 0914011 | 2020-05-10 11:40:03 -0600 | [diff] [blame] | 16 | #include <command.h> |
Simon Glass | cdbff9f | 2019-08-01 09:46:50 -0600 | [diff] [blame] | 17 | #include <env.h> |
Simon Glass | 36bf446 | 2019-11-14 12:57:42 -0700 | [diff] [blame] | 18 | #include <irq_func.h> |
Ivan Gorinov | 5d73292 | 2018-03-26 18:06:54 -0700 | [diff] [blame] | 19 | #include <malloc.h> |
Simon Glass | 776cc20 | 2020-04-08 16:57:36 -0600 | [diff] [blame] | 20 | #include <acpi/acpi_table.h> |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 21 | #include <asm/io.h> |
| 22 | #include <asm/ptrace.h> |
| 23 | #include <asm/zimage.h> |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 24 | #include <asm/byteorder.h> |
Simon Glass | 0d0ba59 | 2014-10-19 21:11:20 -0600 | [diff] [blame] | 25 | #include <asm/bootm.h> |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 26 | #include <asm/bootparam.h> |
Vadim Bendebury | 3cdc18a | 2012-10-23 18:04:34 +0000 | [diff] [blame] | 27 | #ifdef CONFIG_SYS_COREBOOT |
| 28 | #include <asm/arch/timestamp.h> |
| 29 | #endif |
Stefan Reinauer | 61e0ea9 | 2012-10-23 18:04:37 +0000 | [diff] [blame] | 30 | #include <linux/compiler.h> |
Ivan Gorinov | 5d73292 | 2018-03-26 18:06:54 -0700 | [diff] [blame] | 31 | #include <linux/libfdt.h> |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 32 | |
| 33 | /* |
| 34 | * Memory lay-out: |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 35 | * |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 36 | * relative to setup_base (which is 0x90000 currently) |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 37 | * |
| 38 | * 0x0000-0x7FFF Real mode kernel |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 39 | * 0x8000-0x8FFF Stack and heap |
| 40 | * 0x9000-0x90FF Kernel command line |
| 41 | */ |
Graeme Russ | 83088af | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 42 | #define DEFAULT_SETUP_BASE 0x90000 |
| 43 | #define COMMAND_LINE_OFFSET 0x9000 |
| 44 | #define HEAP_END_OFFSET 0x8e00 |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 45 | |
Graeme Russ | 83088af | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 46 | #define COMMAND_LINE_SIZE 2048 |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 47 | |
Simon Glass | e814837 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 48 | /** |
| 49 | * struct zboot_state - Current state of the boot |
| 50 | * |
| 51 | * @bzimage_addr: Address of the bzImage to boot |
| 52 | * @bzimage_size: Size of the bzImage, or 0 to detect this |
| 53 | * @initrd_addr: Address of the initial ramdisk, or 0 if none |
| 54 | * @initrd_size: Size of the initial ramdisk, or 0 if none |
| 55 | * @load_address: Address where the bzImage is moved before booting, either |
| 56 | * BZIMAGE_LOAD_ADDR or ZIMAGE_LOAD_ADDR |
Simon Glass | 88f1cd6 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 57 | * @base_ptr: Pointer to the boot parameters, typically at address |
| 58 | * DEFAULT_SETUP_BASE |
Simon Glass | e814837 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 59 | */ |
| 60 | struct zboot_state { |
| 61 | ulong bzimage_addr; |
| 62 | ulong bzimage_size; |
| 63 | ulong initrd_addr; |
| 64 | ulong initrd_size; |
| 65 | ulong load_address; |
Simon Glass | 88f1cd6 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 66 | struct boot_params *base_ptr; |
Simon Glass | e814837 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 67 | } state; |
| 68 | |
Simon Glass | 5588e77 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 69 | enum { |
| 70 | ZBOOT_STATE_START = BIT(0), |
Simon Glass | 1d9e4bb | 2020-09-05 14:50:46 -0600 | [diff] [blame] | 71 | ZBOOT_STATE_LOAD = BIT(1), |
Simon Glass | 3e59759 | 2020-09-05 14:50:47 -0600 | [diff] [blame] | 72 | ZBOOT_STATE_SETUP = BIT(2), |
| 73 | ZBOOT_STATE_INFO = BIT(3), |
| 74 | ZBOOT_STATE_GO = BIT(4), |
Simon Glass | 5588e77 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 75 | |
Simon Glass | 3e59759 | 2020-09-05 14:50:47 -0600 | [diff] [blame] | 76 | ZBOOT_STATE_COUNT = 5, |
Simon Glass | 5588e77 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 77 | }; |
| 78 | |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 79 | static void build_command_line(char *command_line, int auto_boot) |
| 80 | { |
| 81 | char *env_command_line; |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 82 | |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 83 | command_line[0] = '\0'; |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 84 | |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 85 | env_command_line = env_get("bootargs"); |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 86 | |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 87 | /* set console= argument if we use a serial console */ |
Graeme Russ | 83088af | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 88 | if (!strstr(env_command_line, "console=")) { |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 89 | if (!strcmp(env_get("stdout"), "serial")) { |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 90 | |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 91 | /* We seem to use serial console */ |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 92 | sprintf(command_line, "console=ttyS0,%s ", |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 93 | env_get("baudrate")); |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 94 | } |
| 95 | } |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 96 | |
Graeme Russ | 83088af | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 97 | if (auto_boot) |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 98 | strcat(command_line, "auto "); |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 99 | |
Graeme Russ | 83088af | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 100 | if (env_command_line) |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 101 | strcat(command_line, env_command_line); |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 102 | |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 103 | printf("Kernel command line: \"%s\"\n", command_line); |
| 104 | } |
| 105 | |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 106 | static int kernel_magic_ok(struct setup_header *hdr) |
| 107 | { |
| 108 | if (KERNEL_MAGIC != hdr->boot_flag) { |
| 109 | printf("Error: Invalid Boot Flag " |
| 110 | "(found 0x%04x, expected 0x%04x)\n", |
| 111 | hdr->boot_flag, KERNEL_MAGIC); |
| 112 | return 0; |
| 113 | } else { |
| 114 | printf("Valid Boot Flag\n"); |
| 115 | return 1; |
| 116 | } |
| 117 | } |
| 118 | |
Simon Glass | c038f3b | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 119 | static int get_boot_protocol(struct setup_header *hdr, bool verbose) |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 120 | { |
| 121 | if (hdr->header == KERNEL_V2_MAGIC) { |
Simon Glass | c038f3b | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 122 | if (verbose) |
| 123 | printf("Magic signature found\n"); |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 124 | return hdr->version; |
| 125 | } else { |
| 126 | /* Very old kernel */ |
Simon Glass | c038f3b | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 127 | if (verbose) |
| 128 | printf("Magic signature not found\n"); |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 129 | return 0x0100; |
| 130 | } |
| 131 | } |
| 132 | |
Ivan Gorinov | 5d73292 | 2018-03-26 18:06:54 -0700 | [diff] [blame] | 133 | static int setup_device_tree(struct setup_header *hdr, const void *fdt_blob) |
| 134 | { |
Simon Glass | c038f3b | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 135 | int bootproto = get_boot_protocol(hdr, false); |
Ivan Gorinov | 5d73292 | 2018-03-26 18:06:54 -0700 | [diff] [blame] | 136 | struct setup_data *sd; |
| 137 | int size; |
| 138 | |
| 139 | if (bootproto < 0x0209) |
| 140 | return -ENOTSUPP; |
| 141 | |
| 142 | if (!fdt_blob) |
| 143 | return 0; |
| 144 | |
| 145 | size = fdt_totalsize(fdt_blob); |
| 146 | if (size < 0) |
| 147 | return -EINVAL; |
| 148 | |
| 149 | size += sizeof(struct setup_data); |
| 150 | sd = (struct setup_data *)malloc(size); |
| 151 | if (!sd) { |
| 152 | printf("Not enough memory for DTB setup data\n"); |
| 153 | return -ENOMEM; |
| 154 | } |
| 155 | |
| 156 | sd->next = hdr->setup_data; |
| 157 | sd->type = SETUP_DTB; |
| 158 | sd->len = fdt_totalsize(fdt_blob); |
| 159 | memcpy(sd->data, fdt_blob, sd->len); |
| 160 | hdr->setup_data = (unsigned long)sd; |
| 161 | |
| 162 | return 0; |
| 163 | } |
| 164 | |
Simon Glass | c038f3b | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 165 | static const char *get_kernel_version(struct boot_params *params, |
| 166 | void *kernel_base) |
| 167 | { |
| 168 | struct setup_header *hdr = ¶ms->hdr; |
| 169 | int bootproto; |
| 170 | |
| 171 | bootproto = get_boot_protocol(hdr, false); |
| 172 | if (bootproto < 0x0200 || hdr->setup_sects < 15) |
| 173 | return NULL; |
| 174 | |
| 175 | return kernel_base + hdr->kernel_version + 0x200; |
| 176 | } |
| 177 | |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 178 | struct boot_params *load_zimage(char *image, unsigned long kernel_size, |
Simon Glass | 7653938 | 2014-10-10 08:21:56 -0600 | [diff] [blame] | 179 | ulong *load_addressp) |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 180 | { |
Gabe Black | d3a2bc3 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 181 | struct boot_params *setup_base; |
Simon Glass | c038f3b | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 182 | const char *version; |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 183 | int setup_size; |
| 184 | int bootproto; |
| 185 | int big_image; |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 186 | |
Gabe Black | d3a2bc3 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 187 | struct boot_params *params = (struct boot_params *)image; |
| 188 | struct setup_header *hdr = ¶ms->hdr; |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 189 | |
Graeme Russ | 83088af | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 190 | /* base address for real-mode segment */ |
Gabe Black | d3a2bc3 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 191 | setup_base = (struct boot_params *)DEFAULT_SETUP_BASE; |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 192 | |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 193 | if (!kernel_magic_ok(hdr)) |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 194 | return 0; |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 195 | |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 196 | /* determine size of setup */ |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 197 | if (0 == hdr->setup_sects) { |
| 198 | printf("Setup Sectors = 0 (defaulting to 4)\n"); |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 199 | setup_size = 5 * 512; |
| 200 | } else { |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 201 | setup_size = (hdr->setup_sects + 1) * 512; |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 202 | } |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 203 | |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 204 | printf("Setup Size = 0x%8.8lx\n", (ulong)setup_size); |
| 205 | |
Graeme Russ | 83088af | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 206 | if (setup_size > SETUP_MAX_SIZE) |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 207 | printf("Error: Setup is too large (%d bytes)\n", setup_size); |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 208 | |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 209 | /* determine boot protocol version */ |
Simon Glass | c038f3b | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 210 | bootproto = get_boot_protocol(hdr, true); |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 211 | |
| 212 | printf("Using boot protocol version %x.%02x\n", |
| 213 | (bootproto & 0xff00) >> 8, bootproto & 0xff); |
| 214 | |
Simon Glass | c038f3b | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 215 | version = get_kernel_version(params, image); |
| 216 | if (version) |
| 217 | printf("Linux kernel version %s\n", version); |
| 218 | else |
| 219 | printf("Setup Sectors < 15 - Cannot print kernel version\n"); |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 220 | |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 221 | /* Determine image type */ |
Graeme Russ | 83088af | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 222 | big_image = (bootproto >= 0x0200) && |
| 223 | (hdr->loadflags & BIG_KERNEL_FLAG); |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 224 | |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 225 | /* Determine load address */ |
Gabe Black | d3a2bc3 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 226 | if (big_image) |
Simon Glass | 7653938 | 2014-10-10 08:21:56 -0600 | [diff] [blame] | 227 | *load_addressp = BZIMAGE_LOAD_ADDR; |
Gabe Black | d3a2bc3 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 228 | else |
Simon Glass | 7653938 | 2014-10-10 08:21:56 -0600 | [diff] [blame] | 229 | *load_addressp = ZIMAGE_LOAD_ADDR; |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 230 | |
Gabe Black | 233dbc1 | 2011-12-05 12:09:24 +0000 | [diff] [blame] | 231 | printf("Building boot_params at 0x%8.8lx\n", (ulong)setup_base); |
| 232 | memset(setup_base, 0, sizeof(*setup_base)); |
| 233 | setup_base->hdr = params->hdr; |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 234 | |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 235 | if (bootproto >= 0x0204) |
| 236 | kernel_size = hdr->syssize * 16; |
| 237 | else |
| 238 | kernel_size -= setup_size; |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 239 | |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 240 | if (bootproto == 0x0100) { |
Graeme Russ | 83088af | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 241 | /* |
| 242 | * A very old kernel MUST have its real-mode code |
| 243 | * loaded at 0x90000 |
| 244 | */ |
Simon Glass | 42fd8c1 | 2017-01-16 07:03:35 -0700 | [diff] [blame] | 245 | if ((ulong)setup_base != 0x90000) { |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 246 | /* Copy the real-mode kernel */ |
Graeme Russ | 83088af | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 247 | memmove((void *)0x90000, setup_base, setup_size); |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 248 | |
Graeme Russ | 83088af | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 249 | /* Copy the command line */ |
| 250 | memmove((void *)0x99000, |
Gabe Black | d3a2bc3 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 251 | (u8 *)setup_base + COMMAND_LINE_OFFSET, |
Graeme Russ | 83088af | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 252 | COMMAND_LINE_SIZE); |
| 253 | |
| 254 | /* Relocated */ |
Gabe Black | d3a2bc3 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 255 | setup_base = (struct boot_params *)0x90000; |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 256 | } |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 257 | |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 258 | /* It is recommended to clear memory up to the 32K mark */ |
Gabe Black | d3a2bc3 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 259 | memset((u8 *)0x90000 + setup_size, 0, |
| 260 | SETUP_MAX_SIZE - setup_size); |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 261 | } |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 262 | |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 263 | if (big_image) { |
| 264 | if (kernel_size > BZIMAGE_MAX_SIZE) { |
| 265 | printf("Error: bzImage kernel too big! " |
| 266 | "(size: %ld, max: %d)\n", |
| 267 | kernel_size, BZIMAGE_MAX_SIZE); |
| 268 | return 0; |
| 269 | } |
| 270 | } else if ((kernel_size) > ZIMAGE_MAX_SIZE) { |
| 271 | printf("Error: zImage kernel too big! (size: %ld, max: %d)\n", |
| 272 | kernel_size, ZIMAGE_MAX_SIZE); |
| 273 | return 0; |
| 274 | } |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 275 | |
Simon Glass | 7653938 | 2014-10-10 08:21:56 -0600 | [diff] [blame] | 276 | printf("Loading %s at address %lx (%ld bytes)\n", |
| 277 | big_image ? "bzImage" : "zImage", *load_addressp, kernel_size); |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 278 | |
Simon Glass | 7653938 | 2014-10-10 08:21:56 -0600 | [diff] [blame] | 279 | memmove((void *)*load_addressp, image + setup_size, kernel_size); |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 280 | |
| 281 | return setup_base; |
| 282 | } |
| 283 | |
| 284 | int setup_zimage(struct boot_params *setup_base, char *cmd_line, int auto_boot, |
| 285 | unsigned long initrd_addr, unsigned long initrd_size) |
| 286 | { |
| 287 | struct setup_header *hdr = &setup_base->hdr; |
Simon Glass | c038f3b | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 288 | int bootproto = get_boot_protocol(hdr, false); |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 289 | |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 290 | setup_base->e820_entries = install_e820_map( |
| 291 | ARRAY_SIZE(setup_base->e820_map), setup_base->e820_map); |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 292 | |
| 293 | if (bootproto == 0x0100) { |
| 294 | setup_base->screen_info.cl_magic = COMMAND_LINE_MAGIC; |
| 295 | setup_base->screen_info.cl_offset = COMMAND_LINE_OFFSET; |
| 296 | } |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 297 | if (bootproto >= 0x0200) { |
Simon Glass | 00630f6 | 2020-09-05 14:50:41 -0600 | [diff] [blame] | 298 | hdr->type_of_loader = 0x80; /* U-Boot version 0 */ |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 299 | if (initrd_addr) { |
Gabe Black | d3a2bc3 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 300 | printf("Initial RAM disk at linear address " |
| 301 | "0x%08lx, size %ld bytes\n", |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 302 | initrd_addr, initrd_size); |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 303 | |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 304 | hdr->ramdisk_image = initrd_addr; |
| 305 | hdr->ramdisk_size = initrd_size; |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 306 | } |
| 307 | } |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 308 | |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 309 | if (bootproto >= 0x0201) { |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 310 | hdr->heap_end_ptr = HEAP_END_OFFSET; |
| 311 | hdr->loadflags |= HEAP_FLAG; |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 312 | } |
wdenk | 8bde7f7 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 313 | |
Simon Glass | 97d1e0c | 2014-10-19 21:11:21 -0600 | [diff] [blame] | 314 | if (cmd_line) { |
| 315 | if (bootproto >= 0x0202) { |
| 316 | hdr->cmd_line_ptr = (uintptr_t)cmd_line; |
| 317 | } else if (bootproto >= 0x0200) { |
| 318 | setup_base->screen_info.cl_magic = COMMAND_LINE_MAGIC; |
| 319 | setup_base->screen_info.cl_offset = |
| 320 | (uintptr_t)cmd_line - (uintptr_t)setup_base; |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 321 | |
Simon Glass | 97d1e0c | 2014-10-19 21:11:21 -0600 | [diff] [blame] | 322 | hdr->setup_move_size = 0x9100; |
| 323 | } |
| 324 | |
| 325 | /* build command line at COMMAND_LINE_OFFSET */ |
| 326 | build_command_line(cmd_line, auto_boot); |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 327 | } |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 328 | |
Simon Glass | 30b372d | 2020-09-05 14:50:39 -0600 | [diff] [blame] | 329 | if (IS_ENABLED(CONFIG_INTEL_MID) && bootproto >= 0x0207) |
Andy Shevchenko | 378960d | 2018-01-10 19:40:14 +0200 | [diff] [blame] | 330 | hdr->hardware_subarch = X86_SUBARCH_INTEL_MID; |
Andy Shevchenko | 378960d | 2018-01-10 19:40:14 +0200 | [diff] [blame] | 331 | |
Simon Glass | 30b372d | 2020-09-05 14:50:39 -0600 | [diff] [blame] | 332 | if (IS_ENABLED(CONFIG_GENERATE_ACPI_TABLE)) |
| 333 | setup_base->acpi_rsdp_addr = acpi_get_rsdp_addr(); |
Andy Shevchenko | d905aa8 | 2019-09-13 18:42:00 +0300 | [diff] [blame] | 334 | |
Ivan Gorinov | 5d73292 | 2018-03-26 18:06:54 -0700 | [diff] [blame] | 335 | setup_device_tree(hdr, (const void *)env_get_hex("fdtaddr", 0)); |
Bin Meng | a452002 | 2015-07-06 16:31:36 +0800 | [diff] [blame] | 336 | setup_video(&setup_base->screen_info); |
| 337 | |
Simon Glass | 30b372d | 2020-09-05 14:50:39 -0600 | [diff] [blame] | 338 | if (IS_ENABLED(CONFIG_EFI_STUB)) |
| 339 | setup_efi_info(&setup_base->efi_info); |
Bin Meng | 1fdeacd | 2018-08-23 08:24:10 -0700 | [diff] [blame] | 340 | |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 341 | return 0; |
wdenk | 2262cfe | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 342 | } |
| 343 | |
Simon Glass | 5588e77 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 344 | static int do_zboot_start(struct cmd_tbl *cmdtp, int flag, int argc, |
| 345 | char *const argv[]) |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 346 | { |
Simon Glass | 5588e77 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 347 | const char *s; |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 348 | |
Simon Glass | e814837 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 349 | memset(&state, '\0', sizeof(state)); |
Gabe Black | d3a2bc3 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 350 | if (argc >= 2) { |
Graeme Russ | abe98f4 | 2010-10-07 20:03:19 +1100 | [diff] [blame] | 351 | /* argv[1] holds the address of the bzImage */ |
| 352 | s = argv[1]; |
Gabe Black | d3a2bc3 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 353 | } else { |
Simon Glass | 00caae6 | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 354 | s = env_get("fileaddr"); |
Gabe Black | d3a2bc3 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 355 | } |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 356 | |
Graeme Russ | abe98f4 | 2010-10-07 20:03:19 +1100 | [diff] [blame] | 357 | if (s) |
Simon Glass | e814837 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 358 | state.bzimage_addr = simple_strtoul(s, NULL, 16); |
Graeme Russ | abe98f4 | 2010-10-07 20:03:19 +1100 | [diff] [blame] | 359 | |
Gabe Black | 6f9d998 | 2011-12-05 12:09:27 +0000 | [diff] [blame] | 360 | if (argc >= 3) { |
Graeme Russ | abe98f4 | 2010-10-07 20:03:19 +1100 | [diff] [blame] | 361 | /* argv[2] holds the size of the bzImage */ |
Simon Glass | e814837 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 362 | state.bzimage_size = simple_strtoul(argv[2], NULL, 16); |
Gabe Black | 6f9d998 | 2011-12-05 12:09:27 +0000 | [diff] [blame] | 363 | } |
| 364 | |
| 365 | if (argc >= 4) |
Simon Glass | e814837 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 366 | state.initrd_addr = simple_strtoul(argv[3], NULL, 16); |
Gabe Black | 6f9d998 | 2011-12-05 12:09:27 +0000 | [diff] [blame] | 367 | if (argc >= 5) |
Simon Glass | e814837 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 368 | state.initrd_size = simple_strtoul(argv[4], NULL, 16); |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 369 | |
Simon Glass | 1d9e4bb | 2020-09-05 14:50:46 -0600 | [diff] [blame] | 370 | return 0; |
| 371 | } |
| 372 | |
| 373 | static int do_zboot_load(struct cmd_tbl *cmdtp, int flag, int argc, |
| 374 | char *const argv[]) |
| 375 | { |
| 376 | struct boot_params *base_ptr; |
| 377 | |
Simon Glass | e814837 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 378 | base_ptr = load_zimage((void *)state.bzimage_addr, state.bzimage_size, |
| 379 | &state.load_address); |
Graeme Russ | 83088af | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 380 | if (!base_ptr) { |
Simon Glass | 2c363cb | 2014-10-10 08:21:59 -0600 | [diff] [blame] | 381 | puts("## Kernel loading failed ...\n"); |
Simon Glass | 1d9e4bb | 2020-09-05 14:50:46 -0600 | [diff] [blame] | 382 | return CMD_RET_FAILURE; |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 383 | } |
Simon Glass | 88f1cd6 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 384 | state.base_ptr = base_ptr; |
Simon Glass | 126f47c | 2020-09-05 14:50:48 -0600 | [diff] [blame^] | 385 | if (env_set_hex("zbootbase", (ulong)base_ptr) || |
| 386 | env_set_hex("zbootaddr", state.load_address)) |
| 387 | return CMD_RET_FAILURE; |
Simon Glass | e814837 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 388 | |
Simon Glass | 3e59759 | 2020-09-05 14:50:47 -0600 | [diff] [blame] | 389 | return 0; |
| 390 | } |
| 391 | |
| 392 | static int do_zboot_setup(struct cmd_tbl *cmdtp, int flag, int argc, |
| 393 | char *const argv[]) |
| 394 | { |
| 395 | struct boot_params *base_ptr = state.base_ptr; |
| 396 | int ret; |
| 397 | |
| 398 | if (!base_ptr) { |
| 399 | printf("base is not set: use 'zboot load' first\n"); |
| 400 | return CMD_RET_FAILURE; |
| 401 | } |
| 402 | ret = setup_zimage(base_ptr, (char *)base_ptr + COMMAND_LINE_OFFSET, |
| 403 | 0, state.initrd_addr, state.initrd_size); |
| 404 | if (ret) { |
Simon Glass | 2c363cb | 2014-10-10 08:21:59 -0600 | [diff] [blame] | 405 | puts("Setting up boot parameters failed ...\n"); |
Simon Glass | 3e59759 | 2020-09-05 14:50:47 -0600 | [diff] [blame] | 406 | return CMD_RET_FAILURE; |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 407 | } |
| 408 | |
Simon Glass | 88f1cd6 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 409 | return 0; |
| 410 | } |
| 411 | |
Simon Glass | 6f873f5 | 2020-09-05 14:50:45 -0600 | [diff] [blame] | 412 | static int do_zboot_info(struct cmd_tbl *cmdtp, int flag, int argc, |
| 413 | char *const argv[]) |
| 414 | { |
| 415 | printf("Kernel loaded at %08lx, setup_base=%p\n", |
| 416 | state.load_address, state.base_ptr); |
| 417 | |
| 418 | return 0; |
| 419 | } |
| 420 | |
Simon Glass | 88f1cd6 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 421 | static int do_zboot_go(struct cmd_tbl *cmdtp, int flag, int argc, |
| 422 | char *const argv[]) |
| 423 | { |
| 424 | int ret; |
| 425 | |
Simon Glass | e9d31b3 | 2020-09-05 14:50:42 -0600 | [diff] [blame] | 426 | disable_interrupts(); |
Simon Glass | 88f1cd6 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 427 | |
Gabe Black | 69370d1 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 428 | /* we assume that the kernel is in place */ |
Simon Glass | 88f1cd6 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 429 | ret = boot_linux_kernel((ulong)state.base_ptr, state.load_address, |
| 430 | false); |
| 431 | printf("Kernel returned! (err=%d)\n", ret); |
| 432 | |
| 433 | return CMD_RET_FAILURE; |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 434 | } |
| 435 | |
Simon Glass | 5588e77 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 436 | /* Note: This defines the complete_zboot() function */ |
| 437 | U_BOOT_SUBCMDS(zboot, |
| 438 | U_BOOT_CMD_MKENT(start, 6, 1, do_zboot_start, "", ""), |
Simon Glass | 1d9e4bb | 2020-09-05 14:50:46 -0600 | [diff] [blame] | 439 | U_BOOT_CMD_MKENT(load, 1, 1, do_zboot_load, "", ""), |
Simon Glass | 3e59759 | 2020-09-05 14:50:47 -0600 | [diff] [blame] | 440 | U_BOOT_CMD_MKENT(setup, 1, 1, do_zboot_setup, "", ""), |
Simon Glass | 6f873f5 | 2020-09-05 14:50:45 -0600 | [diff] [blame] | 441 | U_BOOT_CMD_MKENT(info, 1, 1, do_zboot_info, "", ""), |
Simon Glass | 88f1cd6 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 442 | U_BOOT_CMD_MKENT(go, 1, 1, do_zboot_go, "", ""), |
Simon Glass | 5588e77 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 443 | ) |
| 444 | |
| 445 | int do_zboot_states(struct cmd_tbl *cmdtp, int flag, int argc, |
| 446 | char *const argv[], int state_mask) |
| 447 | { |
| 448 | int i; |
| 449 | |
| 450 | for (i = 0; i < ZBOOT_STATE_COUNT; i++) { |
| 451 | struct cmd_tbl *cmd = &zboot_subcmds[i]; |
| 452 | int mask = 1 << i; |
| 453 | int ret; |
| 454 | |
| 455 | if (mask & state_mask) { |
| 456 | ret = cmd->cmd(cmd, flag, argc, argv); |
| 457 | if (ret) |
| 458 | return ret; |
| 459 | } |
| 460 | } |
| 461 | |
| 462 | return 0; |
| 463 | } |
| 464 | |
| 465 | int do_zboot_parent(struct cmd_tbl *cmdtp, int flag, int argc, |
| 466 | char *const argv[], int *repeatable) |
| 467 | { |
| 468 | /* determine if we have a sub command */ |
| 469 | if (argc > 1) { |
| 470 | char *endp; |
| 471 | |
| 472 | simple_strtoul(argv[1], &endp, 16); |
| 473 | /* |
| 474 | * endp pointing to nul means that argv[1] was just a valid |
| 475 | * number, so pass it along to the normal processing |
| 476 | */ |
| 477 | if (*endp) |
| 478 | return do_zboot(cmdtp, flag, argc, argv, repeatable); |
| 479 | } |
| 480 | |
Simon Glass | 88f1cd6 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 481 | do_zboot_states(cmdtp, flag, argc, argv, ZBOOT_STATE_START | |
Simon Glass | 3e59759 | 2020-09-05 14:50:47 -0600 | [diff] [blame] | 482 | ZBOOT_STATE_LOAD | ZBOOT_STATE_SETUP | |
| 483 | ZBOOT_STATE_INFO | ZBOOT_STATE_GO); |
Simon Glass | 5588e77 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 484 | |
| 485 | return CMD_RET_FAILURE; |
| 486 | } |
| 487 | |
| 488 | U_BOOT_CMDREP_COMPLETE( |
| 489 | zboot, 6, do_zboot_parent, "Boot bzImage", |
Gabe Black | 6f9d998 | 2011-12-05 12:09:27 +0000 | [diff] [blame] | 490 | "[addr] [size] [initrd addr] [initrd size]\n" |
| 491 | " addr - The optional starting address of the bzimage.\n" |
| 492 | " If not set it defaults to the environment\n" |
| 493 | " variable \"fileaddr\".\n" |
| 494 | " size - The optional size of the bzimage. Defaults to\n" |
| 495 | " zero.\n" |
| 496 | " initrd addr - The address of the initrd image to use, if any.\n" |
| 497 | " initrd size - The size of the initrd image to use, if any.\n" |
Simon Glass | 5588e77 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 498 | "\n" |
| 499 | "Sub-commands to do part of the zboot sequence:\n" |
Simon Glass | 88f1cd6 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 500 | "\tstart [addr [arg ...]] - specify arguments\n" |
Simon Glass | 1d9e4bb | 2020-09-05 14:50:46 -0600 | [diff] [blame] | 501 | "\tload - load OS image\n" |
Simon Glass | 3e59759 | 2020-09-05 14:50:47 -0600 | [diff] [blame] | 502 | "\tsetup - set up table\n" |
Simon Glass | 6f873f5 | 2020-09-05 14:50:45 -0600 | [diff] [blame] | 503 | "\tinfo - show summary info\n" |
Simon Glass | 88f1cd6 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 504 | "\tgo - start OS\n", |
Simon Glass | 5588e77 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 505 | complete_zboot |
Graeme Russ | 95ffaba | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 506 | ); |