Tom Rini | 10e4779 | 2018-05-06 17:58:06 -0400 | [diff] [blame] | 1 | // SPDX-License-Identifier: GPL-2.0+ |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 2 | /* |
Gabe Black | 1cf5121 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 3 | * Copyright (c) 2011 The Chromium OS Authors. |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 4 | * (C) Copyright 2002 |
Albert ARIBAUD | 60fbc8d | 2011-08-04 18:45:45 +0200 | [diff] [blame] | 5 | * Daniel Engström, Omicron Ceti AB, <daniel@omicron.se> |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 6 | */ |
| 7 | |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 8 | /* |
Graeme Russ | 45fc1d8 | 2011-04-13 19:43:26 +1000 | [diff] [blame] | 9 | * Linux x86 zImage and bzImage loading |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 10 | * |
| 11 | * based on the procdure described in |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 12 | * linux/Documentation/i386/boot.txt |
| 13 | */ |
| 14 | |
Simon Glass | 842ff44 | 2020-11-04 09:59:13 -0700 | [diff] [blame] | 15 | #define LOG_CATEGORY LOGC_BOOT |
| 16 | |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 17 | #include <common.h> |
Simon Glass | 7b48ce8 | 2020-11-05 10:33:46 -0700 | [diff] [blame] | 18 | #include <bootm.h> |
Simon Glass | ed38aef | 2020-05-10 11:40:03 -0600 | [diff] [blame] | 19 | #include <command.h> |
Simon Glass | 83c2e49 | 2019-08-01 09:46:50 -0600 | [diff] [blame] | 20 | #include <env.h> |
Simon Glass | 02c5120 | 2021-03-15 18:00:23 +1300 | [diff] [blame^] | 21 | #include <init.h> |
Simon Glass | 8f3f761 | 2019-11-14 12:57:42 -0700 | [diff] [blame] | 22 | #include <irq_func.h> |
Simon Glass | 842ff44 | 2020-11-04 09:59:13 -0700 | [diff] [blame] | 23 | #include <log.h> |
Ivan Gorinov | 901bb0b | 2018-03-26 18:06:54 -0700 | [diff] [blame] | 24 | #include <malloc.h> |
Simon Glass | 858fed1 | 2020-04-08 16:57:36 -0600 | [diff] [blame] | 25 | #include <acpi/acpi_table.h> |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 26 | #include <asm/io.h> |
| 27 | #include <asm/ptrace.h> |
| 28 | #include <asm/zimage.h> |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 29 | #include <asm/byteorder.h> |
Simon Glass | aa83f2b | 2014-10-19 21:11:20 -0600 | [diff] [blame] | 30 | #include <asm/bootm.h> |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 31 | #include <asm/bootparam.h> |
Simon Glass | 02c5120 | 2021-03-15 18:00:23 +1300 | [diff] [blame^] | 32 | #include <asm/global_data.h> |
Vadim Bendebury | 8cd22c8 | 2012-10-23 18:04:34 +0000 | [diff] [blame] | 33 | #ifdef CONFIG_SYS_COREBOOT |
| 34 | #include <asm/arch/timestamp.h> |
| 35 | #endif |
Stefan Reinauer | 2e5225e | 2012-10-23 18:04:37 +0000 | [diff] [blame] | 36 | #include <linux/compiler.h> |
Simon Glass | 8ee2854 | 2020-11-04 09:59:14 -0700 | [diff] [blame] | 37 | #include <linux/ctype.h> |
Ivan Gorinov | 901bb0b | 2018-03-26 18:06:54 -0700 | [diff] [blame] | 38 | #include <linux/libfdt.h> |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 39 | |
Simon Glass | 02c5120 | 2021-03-15 18:00:23 +1300 | [diff] [blame^] | 40 | DECLARE_GLOBAL_DATA_PTR; |
| 41 | |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 42 | /* |
| 43 | * Memory lay-out: |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 44 | * |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 45 | * relative to setup_base (which is 0x90000 currently) |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 46 | * |
| 47 | * 0x0000-0x7FFF Real mode kernel |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 48 | * 0x8000-0x8FFF Stack and heap |
| 49 | * 0x9000-0x90FF Kernel command line |
| 50 | */ |
Graeme Russ | 883c603 | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 51 | #define DEFAULT_SETUP_BASE 0x90000 |
| 52 | #define COMMAND_LINE_OFFSET 0x9000 |
| 53 | #define HEAP_END_OFFSET 0x8e00 |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 54 | |
Graeme Russ | 883c603 | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 55 | #define COMMAND_LINE_SIZE 2048 |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 56 | |
Simon Glass | 48800f4 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 57 | /** |
| 58 | * struct zboot_state - Current state of the boot |
| 59 | * |
| 60 | * @bzimage_addr: Address of the bzImage to boot |
| 61 | * @bzimage_size: Size of the bzImage, or 0 to detect this |
| 62 | * @initrd_addr: Address of the initial ramdisk, or 0 if none |
| 63 | * @initrd_size: Size of the initial ramdisk, or 0 if none |
| 64 | * @load_address: Address where the bzImage is moved before booting, either |
| 65 | * BZIMAGE_LOAD_ADDR or ZIMAGE_LOAD_ADDR |
Simon Glass | 1931b19 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 66 | * @base_ptr: Pointer to the boot parameters, typically at address |
| 67 | * DEFAULT_SETUP_BASE |
Simon Glass | 5e956d1 | 2020-11-09 07:12:24 -0700 | [diff] [blame] | 68 | * @cmdline: Environment variable containing the 'override' command line, or |
| 69 | * NULL to use the one in the setup block |
Simon Glass | 48800f4 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 70 | */ |
| 71 | struct zboot_state { |
| 72 | ulong bzimage_addr; |
| 73 | ulong bzimage_size; |
| 74 | ulong initrd_addr; |
| 75 | ulong initrd_size; |
| 76 | ulong load_address; |
Simon Glass | 1931b19 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 77 | struct boot_params *base_ptr; |
Simon Glass | 5e956d1 | 2020-11-09 07:12:24 -0700 | [diff] [blame] | 78 | char *cmdline; |
Simon Glass | 48800f4 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 79 | } state; |
| 80 | |
Simon Glass | d9b3c98 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 81 | enum { |
| 82 | ZBOOT_STATE_START = BIT(0), |
Simon Glass | 24d26f7 | 2020-09-05 14:50:46 -0600 | [diff] [blame] | 83 | ZBOOT_STATE_LOAD = BIT(1), |
Simon Glass | 3063483 | 2020-09-05 14:50:47 -0600 | [diff] [blame] | 84 | ZBOOT_STATE_SETUP = BIT(2), |
| 85 | ZBOOT_STATE_INFO = BIT(3), |
| 86 | ZBOOT_STATE_GO = BIT(4), |
Simon Glass | d9b3c98 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 87 | |
Simon Glass | aad0d76 | 2020-09-05 14:50:50 -0600 | [diff] [blame] | 88 | /* This one doesn't execute automatically, so stop the count before 5 */ |
| 89 | ZBOOT_STATE_DUMP = BIT(5), |
Simon Glass | 3063483 | 2020-09-05 14:50:47 -0600 | [diff] [blame] | 90 | ZBOOT_STATE_COUNT = 5, |
Simon Glass | d9b3c98 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 91 | }; |
| 92 | |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 93 | static void build_command_line(char *command_line, int auto_boot) |
| 94 | { |
| 95 | char *env_command_line; |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 96 | |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 97 | command_line[0] = '\0'; |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 98 | |
Simon Glass | 64b723f | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 99 | env_command_line = env_get("bootargs"); |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 100 | |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 101 | /* set console= argument if we use a serial console */ |
Graeme Russ | 883c603 | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 102 | if (!strstr(env_command_line, "console=")) { |
Simon Glass | 64b723f | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 103 | if (!strcmp(env_get("stdout"), "serial")) { |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 104 | |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 105 | /* We seem to use serial console */ |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 106 | sprintf(command_line, "console=ttyS0,%s ", |
Simon Glass | 64b723f | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 107 | env_get("baudrate")); |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 108 | } |
| 109 | } |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 110 | |
Graeme Russ | 883c603 | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 111 | if (auto_boot) |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 112 | strcat(command_line, "auto "); |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 113 | |
Graeme Russ | 883c603 | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 114 | if (env_command_line) |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 115 | strcat(command_line, env_command_line); |
Simon Glass | eeb0122 | 2021-01-24 10:06:09 -0700 | [diff] [blame] | 116 | #ifdef DEBUG |
| 117 | printf("Kernel command line:"); |
| 118 | puts(command_line); |
| 119 | printf("\n"); |
| 120 | #endif |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 121 | } |
| 122 | |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 123 | static int kernel_magic_ok(struct setup_header *hdr) |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 124 | { |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 125 | if (KERNEL_MAGIC != hdr->boot_flag) { |
Gabe Black | 1cf5121 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 126 | printf("Error: Invalid Boot Flag " |
| 127 | "(found 0x%04x, expected 0x%04x)\n", |
| 128 | hdr->boot_flag, KERNEL_MAGIC); |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 129 | return 0; |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 130 | } else { |
| 131 | printf("Valid Boot Flag\n"); |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 132 | return 1; |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 133 | } |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 134 | } |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 135 | |
Simon Glass | df30d41 | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 136 | static int get_boot_protocol(struct setup_header *hdr, bool verbose) |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 137 | { |
| 138 | if (hdr->header == KERNEL_V2_MAGIC) { |
Simon Glass | df30d41 | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 139 | if (verbose) |
| 140 | printf("Magic signature found\n"); |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 141 | return hdr->version; |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 142 | } else { |
| 143 | /* Very old kernel */ |
Simon Glass | df30d41 | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 144 | if (verbose) |
| 145 | printf("Magic signature not found\n"); |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 146 | return 0x0100; |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 147 | } |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 148 | } |
| 149 | |
Ivan Gorinov | 901bb0b | 2018-03-26 18:06:54 -0700 | [diff] [blame] | 150 | static int setup_device_tree(struct setup_header *hdr, const void *fdt_blob) |
| 151 | { |
Simon Glass | df30d41 | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 152 | int bootproto = get_boot_protocol(hdr, false); |
Ivan Gorinov | 901bb0b | 2018-03-26 18:06:54 -0700 | [diff] [blame] | 153 | struct setup_data *sd; |
| 154 | int size; |
| 155 | |
| 156 | if (bootproto < 0x0209) |
| 157 | return -ENOTSUPP; |
| 158 | |
| 159 | if (!fdt_blob) |
| 160 | return 0; |
| 161 | |
| 162 | size = fdt_totalsize(fdt_blob); |
| 163 | if (size < 0) |
| 164 | return -EINVAL; |
| 165 | |
| 166 | size += sizeof(struct setup_data); |
| 167 | sd = (struct setup_data *)malloc(size); |
| 168 | if (!sd) { |
| 169 | printf("Not enough memory for DTB setup data\n"); |
| 170 | return -ENOMEM; |
| 171 | } |
| 172 | |
| 173 | sd->next = hdr->setup_data; |
| 174 | sd->type = SETUP_DTB; |
| 175 | sd->len = fdt_totalsize(fdt_blob); |
| 176 | memcpy(sd->data, fdt_blob, sd->len); |
| 177 | hdr->setup_data = (unsigned long)sd; |
| 178 | |
| 179 | return 0; |
| 180 | } |
| 181 | |
Simon Glass | df30d41 | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 182 | static const char *get_kernel_version(struct boot_params *params, |
| 183 | void *kernel_base) |
| 184 | { |
| 185 | struct setup_header *hdr = ¶ms->hdr; |
| 186 | int bootproto; |
Simon Glass | 8ee2854 | 2020-11-04 09:59:14 -0700 | [diff] [blame] | 187 | const char *s, *end; |
Simon Glass | df30d41 | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 188 | |
| 189 | bootproto = get_boot_protocol(hdr, false); |
| 190 | if (bootproto < 0x0200 || hdr->setup_sects < 15) |
| 191 | return NULL; |
| 192 | |
Simon Glass | 8ee2854 | 2020-11-04 09:59:14 -0700 | [diff] [blame] | 193 | /* sanity-check the kernel version in case it is missing */ |
| 194 | for (s = kernel_base + hdr->kernel_version + 0x200, end = s + 0x100; *s; |
| 195 | s++) { |
| 196 | if (!isprint(*s)) |
| 197 | return NULL; |
| 198 | } |
| 199 | |
Simon Glass | df30d41 | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 200 | return kernel_base + hdr->kernel_version + 0x200; |
| 201 | } |
| 202 | |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 203 | struct boot_params *load_zimage(char *image, unsigned long kernel_size, |
Simon Glass | d98a5bd | 2014-10-10 08:21:56 -0600 | [diff] [blame] | 204 | ulong *load_addressp) |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 205 | { |
| 206 | struct boot_params *setup_base; |
Simon Glass | df30d41 | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 207 | const char *version; |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 208 | int setup_size; |
| 209 | int bootproto; |
| 210 | int big_image; |
| 211 | |
| 212 | struct boot_params *params = (struct boot_params *)image; |
| 213 | struct setup_header *hdr = ¶ms->hdr; |
| 214 | |
| 215 | /* base address for real-mode segment */ |
| 216 | setup_base = (struct boot_params *)DEFAULT_SETUP_BASE; |
| 217 | |
| 218 | if (!kernel_magic_ok(hdr)) |
| 219 | return 0; |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 220 | |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 221 | /* determine size of setup */ |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 222 | if (0 == hdr->setup_sects) { |
Simon Glass | 9d8ca9f | 2020-11-04 09:59:15 -0700 | [diff] [blame] | 223 | log_warning("Setup Sectors = 0 (defaulting to 4)\n"); |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 224 | setup_size = 5 * 512; |
| 225 | } else { |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 226 | setup_size = (hdr->setup_sects + 1) * 512; |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 227 | } |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 228 | |
Simon Glass | 9d8ca9f | 2020-11-04 09:59:15 -0700 | [diff] [blame] | 229 | log_debug("Setup Size = 0x%8.8lx\n", (ulong)setup_size); |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 230 | |
Graeme Russ | 883c603 | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 231 | if (setup_size > SETUP_MAX_SIZE) |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 232 | printf("Error: Setup is too large (%d bytes)\n", setup_size); |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 233 | |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 234 | /* determine boot protocol version */ |
Simon Glass | df30d41 | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 235 | bootproto = get_boot_protocol(hdr, true); |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 236 | |
Simon Glass | 9d8ca9f | 2020-11-04 09:59:15 -0700 | [diff] [blame] | 237 | log_debug("Using boot protocol version %x.%02x\n", |
| 238 | (bootproto & 0xff00) >> 8, bootproto & 0xff); |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 239 | |
Simon Glass | df30d41 | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 240 | version = get_kernel_version(params, image); |
| 241 | if (version) |
| 242 | printf("Linux kernel version %s\n", version); |
| 243 | else |
| 244 | printf("Setup Sectors < 15 - Cannot print kernel version\n"); |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 245 | |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 246 | /* Determine image type */ |
Graeme Russ | 883c603 | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 247 | big_image = (bootproto >= 0x0200) && |
| 248 | (hdr->loadflags & BIG_KERNEL_FLAG); |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 249 | |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 250 | /* Determine load address */ |
Gabe Black | 1cf5121 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 251 | if (big_image) |
Simon Glass | d98a5bd | 2014-10-10 08:21:56 -0600 | [diff] [blame] | 252 | *load_addressp = BZIMAGE_LOAD_ADDR; |
Gabe Black | 1cf5121 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 253 | else |
Simon Glass | d98a5bd | 2014-10-10 08:21:56 -0600 | [diff] [blame] | 254 | *load_addressp = ZIMAGE_LOAD_ADDR; |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 255 | |
Gabe Black | c67a948 | 2011-12-05 12:09:24 +0000 | [diff] [blame] | 256 | printf("Building boot_params at 0x%8.8lx\n", (ulong)setup_base); |
| 257 | memset(setup_base, 0, sizeof(*setup_base)); |
| 258 | setup_base->hdr = params->hdr; |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 259 | |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 260 | if (bootproto >= 0x0204) |
| 261 | kernel_size = hdr->syssize * 16; |
| 262 | else |
| 263 | kernel_size -= setup_size; |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 264 | |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 265 | if (bootproto == 0x0100) { |
Graeme Russ | 883c603 | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 266 | /* |
| 267 | * A very old kernel MUST have its real-mode code |
| 268 | * loaded at 0x90000 |
| 269 | */ |
Simon Glass | ca37a39 | 2017-01-16 07:03:35 -0700 | [diff] [blame] | 270 | if ((ulong)setup_base != 0x90000) { |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 271 | /* Copy the real-mode kernel */ |
Graeme Russ | 883c603 | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 272 | memmove((void *)0x90000, setup_base, setup_size); |
| 273 | |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 274 | /* Copy the command line */ |
Graeme Russ | 883c603 | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 275 | memmove((void *)0x99000, |
Gabe Black | 1cf5121 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 276 | (u8 *)setup_base + COMMAND_LINE_OFFSET, |
Graeme Russ | 883c603 | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 277 | COMMAND_LINE_SIZE); |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 278 | |
Graeme Russ | 883c603 | 2011-11-08 02:33:15 +0000 | [diff] [blame] | 279 | /* Relocated */ |
Gabe Black | 1cf5121 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 280 | setup_base = (struct boot_params *)0x90000; |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 281 | } |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 282 | |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 283 | /* It is recommended to clear memory up to the 32K mark */ |
Gabe Black | 1cf5121 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 284 | memset((u8 *)0x90000 + setup_size, 0, |
| 285 | SETUP_MAX_SIZE - setup_size); |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 286 | } |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 287 | |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 288 | if (big_image) { |
| 289 | if (kernel_size > BZIMAGE_MAX_SIZE) { |
| 290 | printf("Error: bzImage kernel too big! " |
| 291 | "(size: %ld, max: %d)\n", |
| 292 | kernel_size, BZIMAGE_MAX_SIZE); |
| 293 | return 0; |
| 294 | } |
| 295 | } else if ((kernel_size) > ZIMAGE_MAX_SIZE) { |
| 296 | printf("Error: zImage kernel too big! (size: %ld, max: %d)\n", |
| 297 | kernel_size, ZIMAGE_MAX_SIZE); |
| 298 | return 0; |
| 299 | } |
| 300 | |
Simon Glass | d98a5bd | 2014-10-10 08:21:56 -0600 | [diff] [blame] | 301 | printf("Loading %s at address %lx (%ld bytes)\n", |
| 302 | big_image ? "bzImage" : "zImage", *load_addressp, kernel_size); |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 303 | |
Simon Glass | d98a5bd | 2014-10-10 08:21:56 -0600 | [diff] [blame] | 304 | memmove((void *)*load_addressp, image + setup_size, kernel_size); |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 305 | |
| 306 | return setup_base; |
| 307 | } |
| 308 | |
| 309 | int setup_zimage(struct boot_params *setup_base, char *cmd_line, int auto_boot, |
Simon Glass | 12d93ab | 2020-09-05 14:50:51 -0600 | [diff] [blame] | 310 | ulong initrd_addr, ulong initrd_size, ulong cmdline_force) |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 311 | { |
| 312 | struct setup_header *hdr = &setup_base->hdr; |
Simon Glass | df30d41 | 2020-09-05 14:50:40 -0600 | [diff] [blame] | 313 | int bootproto = get_boot_protocol(hdr, false); |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 314 | |
Simon Glass | 842ff44 | 2020-11-04 09:59:13 -0700 | [diff] [blame] | 315 | log_debug("Setup E820 entries\n"); |
Simon Glass | 02c5120 | 2021-03-15 18:00:23 +1300 | [diff] [blame^] | 316 | if (ll_boot_init()) { |
| 317 | setup_base->e820_entries = install_e820_map( |
| 318 | ARRAY_SIZE(setup_base->e820_map), setup_base->e820_map); |
| 319 | } else if (IS_ENABLED(CONFIG_COREBOOT_SYSINFO)) { |
| 320 | setup_base->e820_entries = cb_install_e820_map( |
| 321 | ARRAY_SIZE(setup_base->e820_map), setup_base->e820_map); |
| 322 | } |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 323 | |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 324 | if (bootproto == 0x0100) { |
| 325 | setup_base->screen_info.cl_magic = COMMAND_LINE_MAGIC; |
| 326 | setup_base->screen_info.cl_offset = COMMAND_LINE_OFFSET; |
| 327 | } |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 328 | if (bootproto >= 0x0200) { |
Simon Glass | d67ff03 | 2020-09-05 14:50:41 -0600 | [diff] [blame] | 329 | hdr->type_of_loader = 0x80; /* U-Boot version 0 */ |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 330 | if (initrd_addr) { |
Gabe Black | 1cf5121 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 331 | printf("Initial RAM disk at linear address " |
| 332 | "0x%08lx, size %ld bytes\n", |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 333 | initrd_addr, initrd_size); |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 334 | |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 335 | hdr->ramdisk_image = initrd_addr; |
| 336 | hdr->ramdisk_size = initrd_size; |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 337 | } |
| 338 | } |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 339 | |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 340 | if (bootproto >= 0x0201) { |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 341 | hdr->heap_end_ptr = HEAP_END_OFFSET; |
| 342 | hdr->loadflags |= HEAP_FLAG; |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 343 | } |
wdenk | 57b2d80 | 2003-06-27 21:31:46 +0000 | [diff] [blame] | 344 | |
Simon Glass | 4b4f273 | 2014-10-19 21:11:21 -0600 | [diff] [blame] | 345 | if (cmd_line) { |
Simon Glass | 7b48ce8 | 2020-11-05 10:33:46 -0700 | [diff] [blame] | 346 | int max_size = 0xff; |
| 347 | int ret; |
| 348 | |
Simon Glass | 842ff44 | 2020-11-04 09:59:13 -0700 | [diff] [blame] | 349 | log_debug("Setup cmdline\n"); |
Simon Glass | 7b48ce8 | 2020-11-05 10:33:46 -0700 | [diff] [blame] | 350 | if (bootproto >= 0x0206) |
| 351 | max_size = hdr->cmdline_size; |
Simon Glass | 4b4f273 | 2014-10-19 21:11:21 -0600 | [diff] [blame] | 352 | if (bootproto >= 0x0202) { |
| 353 | hdr->cmd_line_ptr = (uintptr_t)cmd_line; |
| 354 | } else if (bootproto >= 0x0200) { |
| 355 | setup_base->screen_info.cl_magic = COMMAND_LINE_MAGIC; |
| 356 | setup_base->screen_info.cl_offset = |
| 357 | (uintptr_t)cmd_line - (uintptr_t)setup_base; |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 358 | |
Simon Glass | 4b4f273 | 2014-10-19 21:11:21 -0600 | [diff] [blame] | 359 | hdr->setup_move_size = 0x9100; |
| 360 | } |
| 361 | |
| 362 | /* build command line at COMMAND_LINE_OFFSET */ |
Simon Glass | 12d93ab | 2020-09-05 14:50:51 -0600 | [diff] [blame] | 363 | if (cmdline_force) |
| 364 | strcpy(cmd_line, (char *)cmdline_force); |
| 365 | else |
| 366 | build_command_line(cmd_line, auto_boot); |
Simon Glass | 7b48ce8 | 2020-11-05 10:33:46 -0700 | [diff] [blame] | 367 | ret = bootm_process_cmdline(cmd_line, max_size, BOOTM_CL_ALL); |
| 368 | if (ret) { |
Simon Glass | eeb0122 | 2021-01-24 10:06:09 -0700 | [diff] [blame] | 369 | printf("Cmdline setup failed (max_size=%x, bootproto=%x, err=%d)\n", |
| 370 | max_size, bootproto, ret); |
Simon Glass | 7b48ce8 | 2020-11-05 10:33:46 -0700 | [diff] [blame] | 371 | return ret; |
| 372 | } |
| 373 | printf("Kernel command line: \""); |
| 374 | puts(cmd_line); |
| 375 | printf("\"\n"); |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 376 | } |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 377 | |
Simon Glass | 3a17717 | 2020-09-05 14:50:39 -0600 | [diff] [blame] | 378 | if (IS_ENABLED(CONFIG_INTEL_MID) && bootproto >= 0x0207) |
Andy Shevchenko | 8b7adf8 | 2018-01-10 19:40:14 +0200 | [diff] [blame] | 379 | hdr->hardware_subarch = X86_SUBARCH_INTEL_MID; |
Andy Shevchenko | 8b7adf8 | 2018-01-10 19:40:14 +0200 | [diff] [blame] | 380 | |
Simon Glass | 3a17717 | 2020-09-05 14:50:39 -0600 | [diff] [blame] | 381 | if (IS_ENABLED(CONFIG_GENERATE_ACPI_TABLE)) |
| 382 | setup_base->acpi_rsdp_addr = acpi_get_rsdp_addr(); |
Andy Shevchenko | d87a21d | 2019-09-13 18:42:00 +0300 | [diff] [blame] | 383 | |
Simon Glass | 842ff44 | 2020-11-04 09:59:13 -0700 | [diff] [blame] | 384 | log_debug("Setup devicetree\n"); |
Ivan Gorinov | 901bb0b | 2018-03-26 18:06:54 -0700 | [diff] [blame] | 385 | setup_device_tree(hdr, (const void *)env_get_hex("fdtaddr", 0)); |
Bin Meng | f6d504f | 2015-07-06 16:31:36 +0800 | [diff] [blame] | 386 | setup_video(&setup_base->screen_info); |
| 387 | |
Simon Glass | 3a17717 | 2020-09-05 14:50:39 -0600 | [diff] [blame] | 388 | if (IS_ENABLED(CONFIG_EFI_STUB)) |
| 389 | setup_efi_info(&setup_base->efi_info); |
Bin Meng | 106dcfc | 2018-08-23 08:24:10 -0700 | [diff] [blame] | 390 | |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 391 | return 0; |
wdenk | 591dda5 | 2002-11-18 00:14:45 +0000 | [diff] [blame] | 392 | } |
| 393 | |
Simon Glass | d9b3c98 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 394 | static int do_zboot_start(struct cmd_tbl *cmdtp, int flag, int argc, |
| 395 | char *const argv[]) |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 396 | { |
Simon Glass | d9b3c98 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 397 | const char *s; |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 398 | |
Simon Glass | 48800f4 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 399 | memset(&state, '\0', sizeof(state)); |
Gabe Black | 1cf5121 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 400 | if (argc >= 2) { |
Graeme Russ | 3134be2 | 2010-10-07 20:03:19 +1100 | [diff] [blame] | 401 | /* argv[1] holds the address of the bzImage */ |
| 402 | s = argv[1]; |
Gabe Black | 1cf5121 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 403 | } else { |
Simon Glass | 64b723f | 2017-08-03 12:22:12 -0600 | [diff] [blame] | 404 | s = env_get("fileaddr"); |
Gabe Black | 1cf5121 | 2011-12-05 12:09:23 +0000 | [diff] [blame] | 405 | } |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 406 | |
Graeme Russ | 3134be2 | 2010-10-07 20:03:19 +1100 | [diff] [blame] | 407 | if (s) |
Simon Glass | 48800f4 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 408 | state.bzimage_addr = simple_strtoul(s, NULL, 16); |
Graeme Russ | 3134be2 | 2010-10-07 20:03:19 +1100 | [diff] [blame] | 409 | |
Gabe Black | 69b49ee | 2011-12-05 12:09:27 +0000 | [diff] [blame] | 410 | if (argc >= 3) { |
Graeme Russ | 3134be2 | 2010-10-07 20:03:19 +1100 | [diff] [blame] | 411 | /* argv[2] holds the size of the bzImage */ |
Simon Glass | 48800f4 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 412 | state.bzimage_size = simple_strtoul(argv[2], NULL, 16); |
Gabe Black | 69b49ee | 2011-12-05 12:09:27 +0000 | [diff] [blame] | 413 | } |
| 414 | |
| 415 | if (argc >= 4) |
Simon Glass | 48800f4 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 416 | state.initrd_addr = simple_strtoul(argv[3], NULL, 16); |
Gabe Black | 69b49ee | 2011-12-05 12:09:27 +0000 | [diff] [blame] | 417 | if (argc >= 5) |
Simon Glass | 48800f4 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 418 | state.initrd_size = simple_strtoul(argv[4], NULL, 16); |
Simon Glass | c55ce68 | 2020-09-05 14:50:49 -0600 | [diff] [blame] | 419 | if (argc >= 6) { |
| 420 | /* |
| 421 | * When the base_ptr is passed in, we assume that the image is |
| 422 | * already loaded at the address given by argv[1] and therefore |
| 423 | * the original bzImage is somewhere else, or not accessible. |
| 424 | * In any case, we don't need access to the bzImage since all |
| 425 | * the processing is assumed to be done. |
| 426 | * |
| 427 | * So set the base_ptr to the given address, use this arg as the |
| 428 | * load address and set bzimage_addr to 0 so we know that it |
| 429 | * cannot be proceesed (or processed again). |
| 430 | */ |
| 431 | state.base_ptr = (void *)simple_strtoul(argv[5], NULL, 16); |
| 432 | state.load_address = state.bzimage_addr; |
| 433 | state.bzimage_addr = 0; |
| 434 | } |
Simon Glass | 12d93ab | 2020-09-05 14:50:51 -0600 | [diff] [blame] | 435 | if (argc >= 7) |
Simon Glass | 5e956d1 | 2020-11-09 07:12:24 -0700 | [diff] [blame] | 436 | state.cmdline = env_get(argv[6]); |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 437 | |
Simon Glass | 24d26f7 | 2020-09-05 14:50:46 -0600 | [diff] [blame] | 438 | return 0; |
| 439 | } |
| 440 | |
| 441 | static int do_zboot_load(struct cmd_tbl *cmdtp, int flag, int argc, |
| 442 | char *const argv[]) |
| 443 | { |
| 444 | struct boot_params *base_ptr; |
| 445 | |
Simon Glass | c55ce68 | 2020-09-05 14:50:49 -0600 | [diff] [blame] | 446 | if (state.base_ptr) { |
| 447 | struct boot_params *from = (struct boot_params *)state.base_ptr; |
| 448 | |
| 449 | base_ptr = (struct boot_params *)DEFAULT_SETUP_BASE; |
Simon Glass | 9d8ca9f | 2020-11-04 09:59:15 -0700 | [diff] [blame] | 450 | log_debug("Building boot_params at 0x%8.8lx\n", |
| 451 | (ulong)base_ptr); |
Simon Glass | c55ce68 | 2020-09-05 14:50:49 -0600 | [diff] [blame] | 452 | memset(base_ptr, '\0', sizeof(*base_ptr)); |
| 453 | base_ptr->hdr = from->hdr; |
| 454 | } else { |
| 455 | base_ptr = load_zimage((void *)state.bzimage_addr, state.bzimage_size, |
| 456 | &state.load_address); |
| 457 | if (!base_ptr) { |
| 458 | puts("## Kernel loading failed ...\n"); |
| 459 | return CMD_RET_FAILURE; |
| 460 | } |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 461 | } |
Simon Glass | 1931b19 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 462 | state.base_ptr = base_ptr; |
Simon Glass | 58a9046 | 2020-09-05 14:50:48 -0600 | [diff] [blame] | 463 | if (env_set_hex("zbootbase", (ulong)base_ptr) || |
| 464 | env_set_hex("zbootaddr", state.load_address)) |
| 465 | return CMD_RET_FAILURE; |
Simon Glass | 48800f4 | 2020-09-05 14:50:38 -0600 | [diff] [blame] | 466 | |
Simon Glass | 3063483 | 2020-09-05 14:50:47 -0600 | [diff] [blame] | 467 | return 0; |
| 468 | } |
| 469 | |
| 470 | static int do_zboot_setup(struct cmd_tbl *cmdtp, int flag, int argc, |
| 471 | char *const argv[]) |
| 472 | { |
| 473 | struct boot_params *base_ptr = state.base_ptr; |
| 474 | int ret; |
| 475 | |
| 476 | if (!base_ptr) { |
| 477 | printf("base is not set: use 'zboot load' first\n"); |
| 478 | return CMD_RET_FAILURE; |
| 479 | } |
| 480 | ret = setup_zimage(base_ptr, (char *)base_ptr + COMMAND_LINE_OFFSET, |
Simon Glass | 12d93ab | 2020-09-05 14:50:51 -0600 | [diff] [blame] | 481 | 0, state.initrd_addr, state.initrd_size, |
Simon Glass | 5e956d1 | 2020-11-09 07:12:24 -0700 | [diff] [blame] | 482 | (ulong)state.cmdline); |
Simon Glass | 3063483 | 2020-09-05 14:50:47 -0600 | [diff] [blame] | 483 | if (ret) { |
Simon Glass | ddf446b | 2014-10-10 08:21:59 -0600 | [diff] [blame] | 484 | puts("Setting up boot parameters failed ...\n"); |
Simon Glass | 3063483 | 2020-09-05 14:50:47 -0600 | [diff] [blame] | 485 | return CMD_RET_FAILURE; |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 486 | } |
| 487 | |
Simon Glass | 1931b19 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 488 | return 0; |
| 489 | } |
| 490 | |
Simon Glass | 83dd29e | 2020-09-05 14:50:45 -0600 | [diff] [blame] | 491 | static int do_zboot_info(struct cmd_tbl *cmdtp, int flag, int argc, |
| 492 | char *const argv[]) |
| 493 | { |
| 494 | printf("Kernel loaded at %08lx, setup_base=%p\n", |
| 495 | state.load_address, state.base_ptr); |
| 496 | |
| 497 | return 0; |
| 498 | } |
| 499 | |
Simon Glass | 1931b19 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 500 | static int do_zboot_go(struct cmd_tbl *cmdtp, int flag, int argc, |
| 501 | char *const argv[]) |
| 502 | { |
| 503 | int ret; |
| 504 | |
Simon Glass | 0db800c | 2020-09-05 14:50:42 -0600 | [diff] [blame] | 505 | disable_interrupts(); |
Simon Glass | 1931b19 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 506 | |
Gabe Black | 540c262 | 2011-12-05 12:09:26 +0000 | [diff] [blame] | 507 | /* we assume that the kernel is in place */ |
Simon Glass | 1931b19 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 508 | ret = boot_linux_kernel((ulong)state.base_ptr, state.load_address, |
| 509 | false); |
| 510 | printf("Kernel returned! (err=%d)\n", ret); |
| 511 | |
| 512 | return CMD_RET_FAILURE; |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 513 | } |
| 514 | |
Simon Glass | aad0d76 | 2020-09-05 14:50:50 -0600 | [diff] [blame] | 515 | static void print_num(const char *name, ulong value) |
| 516 | { |
| 517 | printf("%-20s: %lx\n", name, value); |
| 518 | } |
| 519 | |
| 520 | static void print_num64(const char *name, u64 value) |
| 521 | { |
| 522 | printf("%-20s: %llx\n", name, value); |
| 523 | } |
| 524 | |
| 525 | static const char *const e820_type_name[E820_COUNT] = { |
| 526 | [E820_RAM] = "RAM", |
| 527 | [E820_RESERVED] = "Reserved", |
| 528 | [E820_ACPI] = "ACPI", |
| 529 | [E820_NVS] = "ACPI NVS", |
| 530 | [E820_UNUSABLE] = "Unusable", |
| 531 | }; |
| 532 | |
| 533 | static const char *const bootloader_id[] = { |
| 534 | "LILO", |
| 535 | "Loadlin", |
| 536 | "bootsect-loader", |
| 537 | "Syslinux", |
| 538 | "Etherboot/gPXE/iPXE", |
| 539 | "ELILO", |
| 540 | "undefined", |
| 541 | "GRUB", |
| 542 | "U-Boot", |
| 543 | "Xen", |
| 544 | "Gujin", |
| 545 | "Qemu", |
| 546 | "Arcturus Networks uCbootloader", |
| 547 | "kexec-tools", |
| 548 | "Extended", |
| 549 | "Special", |
| 550 | "Reserved", |
| 551 | "Minimal Linux Bootloader", |
| 552 | "OVMF UEFI virtualization stack", |
| 553 | }; |
| 554 | |
| 555 | struct flag_info { |
| 556 | uint bit; |
| 557 | const char *name; |
| 558 | }; |
| 559 | |
| 560 | static struct flag_info load_flags[] = { |
| 561 | { LOADED_HIGH, "loaded-high" }, |
| 562 | { QUIET_FLAG, "quiet" }, |
| 563 | { KEEP_SEGMENTS, "keep-segments" }, |
| 564 | { CAN_USE_HEAP, "can-use-heap" }, |
| 565 | }; |
| 566 | |
| 567 | static struct flag_info xload_flags[] = { |
| 568 | { XLF_KERNEL_64, "64-bit-entry" }, |
| 569 | { XLF_CAN_BE_LOADED_ABOVE_4G, "can-load-above-4gb" }, |
| 570 | { XLF_EFI_HANDOVER_32, "32-efi-handoff" }, |
| 571 | { XLF_EFI_HANDOVER_64, "64-efi-handoff" }, |
| 572 | { XLF_EFI_KEXEC, "kexec-efi-runtime" }, |
| 573 | }; |
| 574 | |
| 575 | static void print_flags(struct flag_info *flags, int count, uint value) |
| 576 | { |
| 577 | int i; |
| 578 | |
| 579 | printf("%-20s:", ""); |
| 580 | for (i = 0; i < count; i++) { |
| 581 | uint mask = flags[i].bit; |
| 582 | |
| 583 | if (value & mask) |
| 584 | printf(" %s", flags[i].name); |
| 585 | } |
| 586 | printf("\n"); |
| 587 | } |
| 588 | |
| 589 | static void show_loader(struct setup_header *hdr) |
| 590 | { |
| 591 | bool version_valid = false; |
| 592 | int type, version; |
| 593 | const char *name; |
| 594 | |
| 595 | type = hdr->type_of_loader >> 4; |
| 596 | version = hdr->type_of_loader & 0xf; |
| 597 | if (type == 0xe) |
| 598 | type = 0x10 + hdr->ext_loader_type; |
| 599 | version |= hdr->ext_loader_ver << 4; |
| 600 | if (!hdr->type_of_loader) { |
| 601 | name = "pre-2.00 bootloader"; |
| 602 | } else if (hdr->type_of_loader == 0xff) { |
| 603 | name = "unknown"; |
| 604 | } else if (type < ARRAY_SIZE(bootloader_id)) { |
| 605 | name = bootloader_id[type]; |
| 606 | version_valid = true; |
| 607 | } else { |
| 608 | name = "undefined"; |
| 609 | } |
| 610 | printf("%20s %s", "", name); |
| 611 | if (version_valid) |
| 612 | printf(", version %x", version); |
| 613 | printf("\n"); |
| 614 | } |
| 615 | |
Simon Glass | ba094bb | 2021-01-24 10:06:08 -0700 | [diff] [blame] | 616 | void zimage_dump(struct boot_params *base_ptr) |
Simon Glass | aad0d76 | 2020-09-05 14:50:50 -0600 | [diff] [blame] | 617 | { |
Simon Glass | aad0d76 | 2020-09-05 14:50:50 -0600 | [diff] [blame] | 618 | struct setup_header *hdr; |
| 619 | const char *version; |
| 620 | int i; |
| 621 | |
Simon Glass | aad0d76 | 2020-09-05 14:50:50 -0600 | [diff] [blame] | 622 | printf("Setup located at %p:\n\n", base_ptr); |
| 623 | print_num64("ACPI RSDP addr", base_ptr->acpi_rsdp_addr); |
| 624 | |
| 625 | printf("E820: %d entries\n", base_ptr->e820_entries); |
| 626 | if (base_ptr->e820_entries) { |
| 627 | printf("%18s %16s %s\n", "Addr", "Size", "Type"); |
| 628 | for (i = 0; i < base_ptr->e820_entries; i++) { |
| 629 | struct e820_entry *entry = &base_ptr->e820_map[i]; |
| 630 | |
| 631 | printf("%12llx %10llx %s\n", entry->addr, entry->size, |
| 632 | entry->type < E820_COUNT ? |
| 633 | e820_type_name[entry->type] : |
| 634 | simple_itoa(entry->type)); |
| 635 | } |
| 636 | } |
| 637 | |
| 638 | hdr = &base_ptr->hdr; |
| 639 | print_num("Setup sectors", hdr->setup_sects); |
| 640 | print_num("Root flags", hdr->root_flags); |
| 641 | print_num("Sys size", hdr->syssize); |
| 642 | print_num("RAM size", hdr->ram_size); |
| 643 | print_num("Video mode", hdr->vid_mode); |
| 644 | print_num("Root dev", hdr->root_dev); |
| 645 | print_num("Boot flag", hdr->boot_flag); |
| 646 | print_num("Jump", hdr->jump); |
| 647 | print_num("Header", hdr->header); |
| 648 | if (hdr->header == KERNEL_V2_MAGIC) |
| 649 | printf("%-20s %s\n", "", "Kernel V2"); |
| 650 | else |
| 651 | printf("%-20s %s\n", "", "Ancient kernel, using version 100"); |
| 652 | print_num("Version", hdr->version); |
| 653 | print_num("Real mode switch", hdr->realmode_swtch); |
| 654 | print_num("Start sys", hdr->start_sys); |
| 655 | print_num("Kernel version", hdr->kernel_version); |
| 656 | version = get_kernel_version(base_ptr, (void *)state.bzimage_addr); |
| 657 | if (version) |
| 658 | printf(" @%p: %s\n", version, version); |
| 659 | print_num("Type of loader", hdr->type_of_loader); |
| 660 | show_loader(hdr); |
| 661 | print_num("Load flags", hdr->loadflags); |
| 662 | print_flags(load_flags, ARRAY_SIZE(load_flags), hdr->loadflags); |
| 663 | print_num("Setup move size", hdr->setup_move_size); |
| 664 | print_num("Code32 start", hdr->code32_start); |
| 665 | print_num("Ramdisk image", hdr->ramdisk_image); |
| 666 | print_num("Ramdisk size", hdr->ramdisk_size); |
| 667 | print_num("Bootsect kludge", hdr->bootsect_kludge); |
| 668 | print_num("Heap end ptr", hdr->heap_end_ptr); |
| 669 | print_num("Ext loader ver", hdr->ext_loader_ver); |
| 670 | print_num("Ext loader type", hdr->ext_loader_type); |
| 671 | print_num("Command line ptr", hdr->cmd_line_ptr); |
| 672 | if (hdr->cmd_line_ptr) { |
| 673 | printf(" "); |
| 674 | /* Use puts() to avoid limits from CONFIG_SYS_PBSIZE */ |
Simon Glass | 12d93ab | 2020-09-05 14:50:51 -0600 | [diff] [blame] | 675 | puts((char *)(ulong)hdr->cmd_line_ptr); |
Simon Glass | aad0d76 | 2020-09-05 14:50:50 -0600 | [diff] [blame] | 676 | printf("\n"); |
| 677 | } |
| 678 | print_num("Initrd addr max", hdr->initrd_addr_max); |
| 679 | print_num("Kernel alignment", hdr->kernel_alignment); |
| 680 | print_num("Relocatable kernel", hdr->relocatable_kernel); |
| 681 | print_num("Min alignment", hdr->min_alignment); |
| 682 | if (hdr->min_alignment) |
| 683 | printf("%-20s: %x\n", "", 1 << hdr->min_alignment); |
| 684 | print_num("Xload flags", hdr->xloadflags); |
| 685 | print_flags(xload_flags, ARRAY_SIZE(xload_flags), hdr->xloadflags); |
| 686 | print_num("Cmdline size", hdr->cmdline_size); |
| 687 | print_num("Hardware subarch", hdr->hardware_subarch); |
| 688 | print_num64("HW subarch data", hdr->hardware_subarch_data); |
| 689 | print_num("Payload offset", hdr->payload_offset); |
| 690 | print_num("Payload length", hdr->payload_length); |
| 691 | print_num64("Setup data", hdr->setup_data); |
| 692 | print_num64("Pref address", hdr->pref_address); |
| 693 | print_num("Init size", hdr->init_size); |
| 694 | print_num("Handover offset", hdr->handover_offset); |
| 695 | if (get_boot_protocol(hdr, false) >= 0x215) |
| 696 | print_num("Kernel info offset", hdr->kernel_info_offset); |
Simon Glass | ba094bb | 2021-01-24 10:06:08 -0700 | [diff] [blame] | 697 | } |
| 698 | |
| 699 | static int do_zboot_dump(struct cmd_tbl *cmdtp, int flag, int argc, |
| 700 | char *const argv[]) |
| 701 | { |
| 702 | struct boot_params *base_ptr = state.base_ptr; |
| 703 | |
| 704 | if (argc > 1) |
| 705 | base_ptr = (void *)simple_strtoul(argv[1], NULL, 16); |
| 706 | if (!base_ptr) { |
| 707 | printf("No zboot setup_base\n"); |
| 708 | return CMD_RET_FAILURE; |
| 709 | } |
| 710 | zimage_dump(base_ptr); |
Simon Glass | aad0d76 | 2020-09-05 14:50:50 -0600 | [diff] [blame] | 711 | |
| 712 | return 0; |
| 713 | } |
| 714 | |
Simon Glass | d9b3c98 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 715 | /* Note: This defines the complete_zboot() function */ |
| 716 | U_BOOT_SUBCMDS(zboot, |
Simon Glass | 12d93ab | 2020-09-05 14:50:51 -0600 | [diff] [blame] | 717 | U_BOOT_CMD_MKENT(start, 8, 1, do_zboot_start, "", ""), |
Simon Glass | 24d26f7 | 2020-09-05 14:50:46 -0600 | [diff] [blame] | 718 | U_BOOT_CMD_MKENT(load, 1, 1, do_zboot_load, "", ""), |
Simon Glass | 3063483 | 2020-09-05 14:50:47 -0600 | [diff] [blame] | 719 | U_BOOT_CMD_MKENT(setup, 1, 1, do_zboot_setup, "", ""), |
Simon Glass | 83dd29e | 2020-09-05 14:50:45 -0600 | [diff] [blame] | 720 | U_BOOT_CMD_MKENT(info, 1, 1, do_zboot_info, "", ""), |
Simon Glass | 1931b19 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 721 | U_BOOT_CMD_MKENT(go, 1, 1, do_zboot_go, "", ""), |
Simon Glass | aad0d76 | 2020-09-05 14:50:50 -0600 | [diff] [blame] | 722 | U_BOOT_CMD_MKENT(dump, 2, 1, do_zboot_dump, "", ""), |
Simon Glass | d9b3c98 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 723 | ) |
| 724 | |
| 725 | int do_zboot_states(struct cmd_tbl *cmdtp, int flag, int argc, |
| 726 | char *const argv[], int state_mask) |
| 727 | { |
| 728 | int i; |
| 729 | |
| 730 | for (i = 0; i < ZBOOT_STATE_COUNT; i++) { |
| 731 | struct cmd_tbl *cmd = &zboot_subcmds[i]; |
| 732 | int mask = 1 << i; |
| 733 | int ret; |
| 734 | |
| 735 | if (mask & state_mask) { |
| 736 | ret = cmd->cmd(cmd, flag, argc, argv); |
| 737 | if (ret) |
| 738 | return ret; |
| 739 | } |
| 740 | } |
| 741 | |
| 742 | return 0; |
| 743 | } |
| 744 | |
| 745 | int do_zboot_parent(struct cmd_tbl *cmdtp, int flag, int argc, |
| 746 | char *const argv[], int *repeatable) |
| 747 | { |
| 748 | /* determine if we have a sub command */ |
| 749 | if (argc > 1) { |
| 750 | char *endp; |
| 751 | |
| 752 | simple_strtoul(argv[1], &endp, 16); |
| 753 | /* |
| 754 | * endp pointing to nul means that argv[1] was just a valid |
| 755 | * number, so pass it along to the normal processing |
| 756 | */ |
| 757 | if (*endp) |
| 758 | return do_zboot(cmdtp, flag, argc, argv, repeatable); |
| 759 | } |
| 760 | |
Simon Glass | 1931b19 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 761 | do_zboot_states(cmdtp, flag, argc, argv, ZBOOT_STATE_START | |
Simon Glass | 3063483 | 2020-09-05 14:50:47 -0600 | [diff] [blame] | 762 | ZBOOT_STATE_LOAD | ZBOOT_STATE_SETUP | |
| 763 | ZBOOT_STATE_INFO | ZBOOT_STATE_GO); |
Simon Glass | d9b3c98 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 764 | |
| 765 | return CMD_RET_FAILURE; |
| 766 | } |
| 767 | |
| 768 | U_BOOT_CMDREP_COMPLETE( |
Simon Glass | 12d93ab | 2020-09-05 14:50:51 -0600 | [diff] [blame] | 769 | zboot, 8, do_zboot_parent, "Boot bzImage", |
| 770 | "[addr] [size] [initrd addr] [initrd size] [setup] [cmdline]\n" |
Gabe Black | 69b49ee | 2011-12-05 12:09:27 +0000 | [diff] [blame] | 771 | " addr - The optional starting address of the bzimage.\n" |
| 772 | " If not set it defaults to the environment\n" |
| 773 | " variable \"fileaddr\".\n" |
| 774 | " size - The optional size of the bzimage. Defaults to\n" |
| 775 | " zero.\n" |
| 776 | " initrd addr - The address of the initrd image to use, if any.\n" |
| 777 | " initrd size - The size of the initrd image to use, if any.\n" |
Simon Glass | c55ce68 | 2020-09-05 14:50:49 -0600 | [diff] [blame] | 778 | " setup - The address of the kernel setup region, if this\n" |
| 779 | " is not at addr\n" |
Simon Glass | 5e956d1 | 2020-11-09 07:12:24 -0700 | [diff] [blame] | 780 | " cmdline - Environment variable containing the kernel\n" |
| 781 | " command line, to override U-Boot's normal\n" |
| 782 | " cmdline generation\n" |
Simon Glass | d9b3c98 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 783 | "\n" |
| 784 | "Sub-commands to do part of the zboot sequence:\n" |
Simon Glass | 1931b19 | 2020-09-05 14:50:44 -0600 | [diff] [blame] | 785 | "\tstart [addr [arg ...]] - specify arguments\n" |
Simon Glass | 24d26f7 | 2020-09-05 14:50:46 -0600 | [diff] [blame] | 786 | "\tload - load OS image\n" |
Simon Glass | 3063483 | 2020-09-05 14:50:47 -0600 | [diff] [blame] | 787 | "\tsetup - set up table\n" |
Simon Glass | 83dd29e | 2020-09-05 14:50:45 -0600 | [diff] [blame] | 788 | "\tinfo - show summary info\n" |
Simon Glass | aad0d76 | 2020-09-05 14:50:50 -0600 | [diff] [blame] | 789 | "\tgo - start OS\n" |
| 790 | "\tdump [addr] - dump info (optional address of boot params)", |
Simon Glass | d9b3c98 | 2020-09-05 14:50:43 -0600 | [diff] [blame] | 791 | complete_zboot |
Graeme Russ | 1bab104 | 2010-04-24 00:05:49 +1000 | [diff] [blame] | 792 | ); |