mirror of
https://github.com/u-boot/u-boot.git
synced 2025-04-17 02:15:02 +00:00
Merge patch series "Complete decoupling of zboot logic from commands"
Simon Glass <sjg@chromium.org> says: This series refactors the zboot code to allow it to be used with CONFIG_COMMAND disabled. A new zboot_run() function is used to boot a zimage.
This commit is contained in:
Tom Rini
commit
ab3453e7b1
10 changed files with 333 additions and 248 deletions
|
|
@ -254,7 +254,6 @@ config X86
|
|||
imply CMD_PCI
|
||||
imply CMD_SF
|
||||
imply CMD_SF_TEST
|
||||
imply CMD_ZBOOT
|
||||
imply DM_GPIO
|
||||
imply DM_KEYBOARD
|
||||
imply DM_MMC
|
||||
|
|
|
|||
|
|
@ -1053,4 +1053,12 @@ config SPL_COREBOOT_SYSINFO
|
|||
display, memory and build information. It is stored in
|
||||
struct sysinfo_t after parsing by get_coreboot_info().
|
||||
|
||||
config ZBOOT
|
||||
bool "Support the zImage format"
|
||||
default y
|
||||
help
|
||||
Enable this to support booting the x86-specific zImage format. This
|
||||
uses a special, binary format containing information about the Linux
|
||||
format to boot.
|
||||
|
||||
endmenu
|
||||
|
|
|
|||
|
|
@ -30,6 +30,78 @@
|
|||
#define BZIMAGE_LOAD_ADDR 0x100000
|
||||
#define ZIMAGE_LOAD_ADDR 0x10000
|
||||
|
||||
enum {
|
||||
ZBOOT_STATE_START = BIT(0),
|
||||
ZBOOT_STATE_LOAD = BIT(1),
|
||||
ZBOOT_STATE_SETUP = BIT(2),
|
||||
ZBOOT_STATE_INFO = BIT(3),
|
||||
ZBOOT_STATE_GO = BIT(4),
|
||||
|
||||
/* This one doesn't execute automatically, so stop the count before 5 */
|
||||
ZBOOT_STATE_DUMP = BIT(5),
|
||||
ZBOOT_STATE_COUNT = 5,
|
||||
};
|
||||
|
||||
/**
|
||||
* struct zboot_state - Current state of the boot
|
||||
*
|
||||
* @bzimage_addr: Address of the bzImage to boot, or 0 if the image has already
|
||||
* been loaded and does not exist (as a cohesive whole) in memory
|
||||
* @bzimage_size: Size of the bzImage, or 0 to detect this
|
||||
* @initrd_addr: Address of the initial ramdisk, or 0 if none
|
||||
* @initrd_size: Size of the initial ramdisk, or 0 if none
|
||||
* @load_address: Address where the bzImage is moved before booting, either
|
||||
* BZIMAGE_LOAD_ADDR or ZIMAGE_LOAD_ADDR
|
||||
* This is set up when loading the zimage
|
||||
* @base_ptr: Pointer to the boot parameters, typically at address
|
||||
* DEFAULT_SETUP_BASE
|
||||
* This is set up when loading the zimage
|
||||
* @cmdline: Environment variable containing the 'override' command line, or
|
||||
* NULL to use the one in the setup block
|
||||
*/
|
||||
struct zboot_state {
|
||||
ulong bzimage_addr;
|
||||
ulong bzimage_size;
|
||||
ulong initrd_addr;
|
||||
ulong initrd_size;
|
||||
ulong load_address;
|
||||
struct boot_params *base_ptr;
|
||||
const char *cmdline;
|
||||
};
|
||||
|
||||
extern struct zboot_state state;
|
||||
|
||||
/**
|
||||
* zimage_dump() - Dump information about a zimage
|
||||
*
|
||||
* @base_ptr: Pointer to the boot parameters
|
||||
* @show_cmdline: true to show the kernel command line
|
||||
*/
|
||||
void zimage_dump(struct boot_params *base_ptr, bool show_cmdline);
|
||||
|
||||
/**
|
||||
* zboot_load() - Load a zimage
|
||||
*
|
||||
* Load the zimage into the correct place
|
||||
*
|
||||
* Return: 0 if OK, -ve on error
|
||||
*/
|
||||
int zboot_load(void);
|
||||
|
||||
/**
|
||||
* zboot_setup() - Set up the zboot image reeady for booting
|
||||
*
|
||||
* Return: 0 if OK, -ve on error
|
||||
*/
|
||||
int zboot_setup(void);
|
||||
|
||||
/**
|
||||
* zboot_go() - Start the image
|
||||
*
|
||||
* Return: 0 if OK, -ve on error
|
||||
*/
|
||||
int zboot_go(void);
|
||||
|
||||
/**
|
||||
* load_zimage() - Load a zImage or bzImage
|
||||
*
|
||||
|
|
@ -62,4 +134,29 @@ struct boot_params *load_zimage(char *image, unsigned long kernel_size,
|
|||
int setup_zimage(struct boot_params *setup_base, char *cmd_line, int auto_boot,
|
||||
ulong initrd_addr, ulong initrd_size, ulong cmdline_force);
|
||||
|
||||
/**
|
||||
* zboot_start() - Prepare to boot a zimage
|
||||
*
|
||||
* Record information about a zimage so it can be booted
|
||||
*
|
||||
* @bzimage_addr: Address of the bzImage to boot
|
||||
* @bzimage_size: Size of the bzImage, or 0 to detect this
|
||||
* @initrd_addr: Address of the initial ramdisk, or 0 if none
|
||||
* @initrd_size: Size of the initial ramdisk, or 0 if none
|
||||
* @base_addr: If non-zero, this indicates that the boot parameters have already
|
||||
* been loaded by the caller to this address, so the load_zimage() call
|
||||
* in zboot_load() will be skipped when booting
|
||||
* @cmdline: Environment variable containing the 'override' command line, or
|
||||
* NULL to use the one in the setup block
|
||||
*/
|
||||
void zboot_start(ulong bzimage_addr, ulong bzimage_size, ulong initrd_addr,
|
||||
ulong initrd_size, ulong base_addr, const char *cmdline);
|
||||
|
||||
/**
|
||||
* zboot_info() - Show simple info about a zimage
|
||||
*
|
||||
* Shows wherer the kernel was loaded and also the setup base
|
||||
*/
|
||||
void zboot_info(void);
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -48,7 +48,7 @@ obj-$(CONFIG_$(SPL_TPL_)GENERATE_ACPI_TABLE) += acpi_table.o
|
|||
endif
|
||||
obj-y += tables.o
|
||||
ifndef CONFIG_SPL_BUILD
|
||||
obj-$(CONFIG_CMD_ZBOOT) += zimage.o
|
||||
obj-$(CONFIG_ZBOOT) += zimage.o
|
||||
endif
|
||||
obj-$(CONFIG_USE_HOB) += hob.o
|
||||
ifndef CONFIG_TPL_BUILD
|
||||
|
|
|
|||
|
|
@ -56,41 +56,8 @@ DECLARE_GLOBAL_DATA_PTR;
|
|||
|
||||
#define COMMAND_LINE_SIZE 2048
|
||||
|
||||
/**
|
||||
* struct zboot_state - Current state of the boot
|
||||
*
|
||||
* @bzimage_addr: Address of the bzImage to boot
|
||||
* @bzimage_size: Size of the bzImage, or 0 to detect this
|
||||
* @initrd_addr: Address of the initial ramdisk, or 0 if none
|
||||
* @initrd_size: Size of the initial ramdisk, or 0 if none
|
||||
* @load_address: Address where the bzImage is moved before booting, either
|
||||
* BZIMAGE_LOAD_ADDR or ZIMAGE_LOAD_ADDR
|
||||
* @base_ptr: Pointer to the boot parameters, typically at address
|
||||
* DEFAULT_SETUP_BASE
|
||||
* @cmdline: Environment variable containing the 'override' command line, or
|
||||
* NULL to use the one in the setup block
|
||||
*/
|
||||
struct zboot_state {
|
||||
ulong bzimage_addr;
|
||||
ulong bzimage_size;
|
||||
ulong initrd_addr;
|
||||
ulong initrd_size;
|
||||
ulong load_address;
|
||||
struct boot_params *base_ptr;
|
||||
char *cmdline;
|
||||
} state;
|
||||
|
||||
enum {
|
||||
ZBOOT_STATE_START = BIT(0),
|
||||
ZBOOT_STATE_LOAD = BIT(1),
|
||||
ZBOOT_STATE_SETUP = BIT(2),
|
||||
ZBOOT_STATE_INFO = BIT(3),
|
||||
ZBOOT_STATE_GO = BIT(4),
|
||||
|
||||
/* This one doesn't execute automatically, so stop the count before 5 */
|
||||
ZBOOT_STATE_DUMP = BIT(5),
|
||||
ZBOOT_STATE_COUNT = 5,
|
||||
};
|
||||
/* Current state of the boot */
|
||||
struct zboot_state state;
|
||||
|
||||
static void build_command_line(char *command_line, int auto_boot)
|
||||
{
|
||||
|
|
@ -400,56 +367,10 @@ int setup_zimage(struct boot_params *setup_base, char *cmd_line, int auto_boot,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int do_zboot_start(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[])
|
||||
{
|
||||
const char *s;
|
||||
|
||||
memset(&state, '\0', sizeof(state));
|
||||
if (argc >= 2) {
|
||||
/* argv[1] holds the address of the bzImage */
|
||||
s = argv[1];
|
||||
} else {
|
||||
s = env_get("fileaddr");
|
||||
}
|
||||
|
||||
if (s)
|
||||
state.bzimage_addr = hextoul(s, NULL);
|
||||
|
||||
if (argc >= 3) {
|
||||
/* argv[2] holds the size of the bzImage */
|
||||
state.bzimage_size = hextoul(argv[2], NULL);
|
||||
}
|
||||
|
||||
if (argc >= 4)
|
||||
state.initrd_addr = hextoul(argv[3], NULL);
|
||||
if (argc >= 5)
|
||||
state.initrd_size = hextoul(argv[4], NULL);
|
||||
if (argc >= 6) {
|
||||
/*
|
||||
* When the base_ptr is passed in, we assume that the image is
|
||||
* already loaded at the address given by argv[1] and therefore
|
||||
* the original bzImage is somewhere else, or not accessible.
|
||||
* In any case, we don't need access to the bzImage since all
|
||||
* the processing is assumed to be done.
|
||||
*
|
||||
* So set the base_ptr to the given address, use this arg as the
|
||||
* load address and set bzimage_addr to 0 so we know that it
|
||||
* cannot be proceesed (or processed again).
|
||||
*/
|
||||
state.base_ptr = (void *)hextoul(argv[5], NULL);
|
||||
state.load_address = state.bzimage_addr;
|
||||
state.bzimage_addr = 0;
|
||||
}
|
||||
if (argc >= 7)
|
||||
state.cmdline = env_get(argv[6]);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int zboot_load(void)
|
||||
int zboot_load(void)
|
||||
{
|
||||
struct boot_params *base_ptr;
|
||||
int ret;
|
||||
|
||||
if (state.base_ptr) {
|
||||
struct boot_params *from = (struct boot_params *)state.base_ptr;
|
||||
|
|
@ -469,23 +390,16 @@ static int zboot_load(void)
|
|||
}
|
||||
state.base_ptr = base_ptr;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_zboot_load(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[])
|
||||
{
|
||||
if (zboot_load())
|
||||
return CMD_RET_FAILURE;
|
||||
|
||||
if (env_set_hex("zbootbase", map_to_sysmem(state.base_ptr)) ||
|
||||
env_set_hex("zbootaddr", state.load_address))
|
||||
return CMD_RET_FAILURE;
|
||||
ret = env_set_hex("zbootbase", map_to_sysmem(state.base_ptr));
|
||||
if (!ret)
|
||||
ret = env_set_hex("zbootaddr", state.load_address);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int zboot_setup(void)
|
||||
int zboot_setup(void)
|
||||
{
|
||||
struct boot_params *base_ptr = state.base_ptr;
|
||||
int ret;
|
||||
|
|
@ -499,33 +413,7 @@ static int zboot_setup(void)
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int do_zboot_setup(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[])
|
||||
{
|
||||
struct boot_params *base_ptr = state.base_ptr;
|
||||
|
||||
if (!base_ptr) {
|
||||
printf("base is not set: use 'zboot load' first\n");
|
||||
return CMD_RET_FAILURE;
|
||||
}
|
||||
if (zboot_setup()) {
|
||||
puts("Setting up boot parameters failed ...\n");
|
||||
return CMD_RET_FAILURE;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_zboot_info(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[])
|
||||
{
|
||||
printf("Kernel loaded at %08lx, setup_base=%p\n",
|
||||
state.load_address, state.base_ptr);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int zboot_go(void)
|
||||
int zboot_go(void)
|
||||
{
|
||||
struct boot_params *params = state.base_ptr;
|
||||
struct setup_header *hdr = ¶ms->hdr;
|
||||
|
|
@ -549,35 +437,12 @@ static int zboot_go(void)
|
|||
return ret;
|
||||
}
|
||||
|
||||
static int do_zboot_go(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[])
|
||||
int zboot_run(ulong addr, ulong size, ulong initrd, ulong initrd_size,
|
||||
ulong base, char *cmdline)
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = zboot_go();
|
||||
printf("Kernel returned! (err=%d)\n", ret);
|
||||
|
||||
return CMD_RET_FAILURE;
|
||||
}
|
||||
|
||||
int zboot_start(ulong addr, ulong size, ulong initrd, ulong initrd_size,
|
||||
ulong base, char *cmdline)
|
||||
{
|
||||
int ret;
|
||||
|
||||
memset(&state, '\0', sizeof(state));
|
||||
|
||||
if (base) {
|
||||
state.base_ptr = map_sysmem(base, 0);
|
||||
state.load_address = addr;
|
||||
} else {
|
||||
state.bzimage_addr = addr;
|
||||
}
|
||||
state.bzimage_size = size;
|
||||
state.initrd_addr = initrd;
|
||||
state.initrd_size = initrd_size;
|
||||
state.cmdline = cmdline;
|
||||
|
||||
zboot_start(addr, size, initrd, initrd_size, base, cmdline);
|
||||
ret = zboot_load();
|
||||
if (ret)
|
||||
return log_msg_ret("ld", ret);
|
||||
|
|
@ -586,7 +451,7 @@ int zboot_start(ulong addr, ulong size, ulong initrd, ulong initrd_size,
|
|||
return log_msg_ret("set", ret);
|
||||
ret = zboot_go();
|
||||
if (ret)
|
||||
return log_msg_ret("set", ret);
|
||||
return log_msg_ret("go", ret);
|
||||
|
||||
return -EFAULT;
|
||||
}
|
||||
|
|
@ -776,97 +641,25 @@ void zimage_dump(struct boot_params *base_ptr, bool show_cmdline)
|
|||
print_num("Kernel info offset", hdr->kernel_info_offset);
|
||||
}
|
||||
|
||||
static int do_zboot_dump(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[])
|
||||
void zboot_start(ulong bzimage_addr, ulong bzimage_size, ulong initrd_addr,
|
||||
ulong initrd_size, ulong base_addr, const char *cmdline)
|
||||
{
|
||||
struct boot_params *base_ptr = state.base_ptr;
|
||||
memset(&state, '\0', sizeof(state));
|
||||
|
||||
if (argc > 1)
|
||||
base_ptr = (void *)hextoul(argv[1], NULL);
|
||||
if (!base_ptr) {
|
||||
printf("No zboot setup_base\n");
|
||||
return CMD_RET_FAILURE;
|
||||
state.bzimage_size = bzimage_size;
|
||||
state.initrd_addr = initrd_addr;
|
||||
state.initrd_size = initrd_size;
|
||||
if (base_addr) {
|
||||
state.base_ptr = map_sysmem(base_addr, 0);
|
||||
state.load_address = bzimage_addr;
|
||||
} else {
|
||||
state.bzimage_addr = bzimage_addr;
|
||||
}
|
||||
zimage_dump(base_ptr, true);
|
||||
|
||||
return 0;
|
||||
state.cmdline = cmdline;
|
||||
}
|
||||
|
||||
/* Note: This defines the complete_zboot() function */
|
||||
U_BOOT_SUBCMDS(zboot,
|
||||
U_BOOT_CMD_MKENT(start, 8, 1, do_zboot_start, "", ""),
|
||||
U_BOOT_CMD_MKENT(load, 1, 1, do_zboot_load, "", ""),
|
||||
U_BOOT_CMD_MKENT(setup, 1, 1, do_zboot_setup, "", ""),
|
||||
U_BOOT_CMD_MKENT(info, 1, 1, do_zboot_info, "", ""),
|
||||
U_BOOT_CMD_MKENT(go, 1, 1, do_zboot_go, "", ""),
|
||||
U_BOOT_CMD_MKENT(dump, 2, 1, do_zboot_dump, "", ""),
|
||||
)
|
||||
|
||||
int do_zboot_states(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[], int state_mask)
|
||||
void zboot_info(void)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ZBOOT_STATE_COUNT; i++) {
|
||||
struct cmd_tbl *cmd = &zboot_subcmds[i];
|
||||
int mask = 1 << i;
|
||||
int ret;
|
||||
|
||||
if (mask & state_mask) {
|
||||
ret = cmd->cmd(cmd, flag, argc, argv);
|
||||
if (ret)
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
printf("Kernel loaded at %08lx, setup_base=%p\n",
|
||||
state.load_address, state.base_ptr);
|
||||
}
|
||||
|
||||
int do_zboot_parent(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[], int *repeatable)
|
||||
{
|
||||
/* determine if we have a sub command */
|
||||
if (argc > 1) {
|
||||
char *endp;
|
||||
|
||||
hextoul(argv[1], &endp);
|
||||
/*
|
||||
* endp pointing to nul means that argv[1] was just a valid
|
||||
* number, so pass it along to the normal processing
|
||||
*/
|
||||
if (*endp)
|
||||
return do_zboot(cmdtp, flag, argc, argv, repeatable);
|
||||
}
|
||||
|
||||
do_zboot_states(cmdtp, flag, argc, argv, ZBOOT_STATE_START |
|
||||
ZBOOT_STATE_LOAD | ZBOOT_STATE_SETUP |
|
||||
ZBOOT_STATE_INFO | ZBOOT_STATE_GO);
|
||||
|
||||
return CMD_RET_FAILURE;
|
||||
}
|
||||
|
||||
U_BOOT_CMDREP_COMPLETE(
|
||||
zboot, 8, do_zboot_parent, "Boot bzImage",
|
||||
"[addr] [size] [initrd addr] [initrd size] [setup] [cmdline]\n"
|
||||
" addr - The optional starting address of the bzimage.\n"
|
||||
" If not set it defaults to the environment\n"
|
||||
" variable \"fileaddr\".\n"
|
||||
" size - The optional size of the bzimage. Defaults to\n"
|
||||
" zero.\n"
|
||||
" initrd addr - The address of the initrd image to use, if any.\n"
|
||||
" initrd size - The size of the initrd image to use, if any.\n"
|
||||
" setup - The address of the kernel setup region, if this\n"
|
||||
" is not at addr\n"
|
||||
" cmdline - Environment variable containing the kernel\n"
|
||||
" command line, to override U-Boot's normal\n"
|
||||
" cmdline generation\n"
|
||||
"\n"
|
||||
"Sub-commands to do part of the zboot sequence:\n"
|
||||
"\tstart [addr [arg ...]] - specify arguments\n"
|
||||
"\tload - load OS image\n"
|
||||
"\tsetup - set up table\n"
|
||||
"\tinfo - show summary info\n"
|
||||
"\tgo - start OS\n"
|
||||
"\tdump [addr] - dump info (optional address of boot params)",
|
||||
complete_zboot
|
||||
);
|
||||
|
|
|
|||
|
|
@ -432,9 +432,9 @@ static int cros_boot(struct udevice *dev, struct bootflow *bflow)
|
|||
}
|
||||
|
||||
if (IS_ENABLED(CONFIG_X86)) {
|
||||
ret = zboot_start(map_to_sysmem(bflow->buf), bflow->size, 0, 0,
|
||||
map_to_sysmem(bflow->x86_setup),
|
||||
bflow->cmdline);
|
||||
ret = zboot_run(map_to_sysmem(bflow->buf), bflow->size, 0, 0,
|
||||
map_to_sysmem(bflow->x86_setup),
|
||||
bflow->cmdline);
|
||||
} else {
|
||||
ret = bootm_boot_start(map_to_sysmem(bflow->buf),
|
||||
bflow->cmdline);
|
||||
|
|
|
|||
|
|
@ -612,6 +612,8 @@ config THOR_RESET_OFF
|
|||
|
||||
config CMD_ZBOOT
|
||||
bool "zboot - x86 boot command"
|
||||
depends on ZBOOT
|
||||
default y
|
||||
help
|
||||
With x86 machines it is common to boot a bzImage file which
|
||||
contains both a kernel and a setup.bin file. The latter includes
|
||||
|
|
|
|||
|
|
@ -5,3 +5,4 @@ obj-y += mtrr.o
|
|||
obj-$(CONFIG_CMD_EXCEPTION) += exception.o
|
||||
obj-$(CONFIG_USE_HOB) += hob.o
|
||||
obj-$(CONFIG_HAVE_FSP) += fsp.o
|
||||
obj-$(CONFIG_CMD_ZBOOT) += zboot.o
|
||||
|
|
|
|||
182
cmd/x86/zboot.c
Normal file
182
cmd/x86/zboot.c
Normal file
|
|
@ -0,0 +1,182 @@
|
|||
// SPDX-License-Identifier: GPL-2.0+
|
||||
/*
|
||||
* Copyright (c) 2011 The Chromium OS Authors.
|
||||
* (C) Copyright 2002
|
||||
* Daniel Engström, Omicron Ceti AB, <daniel@omicron.se>
|
||||
*/
|
||||
|
||||
#include <command.h>
|
||||
#include <mapmem.h>
|
||||
#include <vsprintf.h>
|
||||
#include <asm/zimage.h>
|
||||
|
||||
static int do_zboot_start(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[])
|
||||
{
|
||||
ulong bzimage_addr = 0, bzimage_size, initrd_addr, initrd_size;
|
||||
ulong base_addr;
|
||||
const char *s, *cmdline;
|
||||
|
||||
/* argv[1] holds the address of the bzImage */
|
||||
s = cmd_arg1(argc, argv) ? : env_get("fileaddr");
|
||||
if (s)
|
||||
bzimage_addr = hextoul(s, NULL);
|
||||
bzimage_size = argc > 2 ? hextoul(argv[2], NULL) : 0;
|
||||
initrd_addr = argc > 3 ? hextoul(argv[3], NULL) : 0;
|
||||
initrd_size = argc > 4 ? hextoul(argv[4], NULL) : 0;
|
||||
base_addr = argc > 5 ? hextoul(argv[5], NULL) : 0;
|
||||
cmdline = argc > 6 ? env_get(argv[6]) : NULL;
|
||||
|
||||
zboot_start(bzimage_addr, bzimage_size, initrd_addr, initrd_size,
|
||||
base_addr, cmdline);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_zboot_load(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[])
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = zboot_load();
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_zboot_setup(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[])
|
||||
{
|
||||
if (!state.base_ptr) {
|
||||
printf("base is not set: use 'zboot load' first\n");
|
||||
return CMD_RET_FAILURE;
|
||||
}
|
||||
if (zboot_setup()) {
|
||||
puts("Setting up boot parameters failed ...\n");
|
||||
return CMD_RET_FAILURE;
|
||||
}
|
||||
|
||||
if (zboot_setup())
|
||||
return CMD_RET_FAILURE;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_zboot_info(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[])
|
||||
{
|
||||
zboot_info();
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_zboot_go(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[])
|
||||
{
|
||||
int ret;
|
||||
|
||||
ret = zboot_go();
|
||||
if (ret) {
|
||||
printf("Kernel returned! (err=%d)\n", ret);
|
||||
return CMD_RET_FAILURE;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static int do_zboot_dump(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[])
|
||||
{
|
||||
struct boot_params *base_ptr = state.base_ptr;
|
||||
|
||||
if (argc > 1)
|
||||
base_ptr = (void *)hextoul(argv[1], NULL);
|
||||
if (!base_ptr) {
|
||||
printf("No zboot setup_base\n");
|
||||
return CMD_RET_FAILURE;
|
||||
}
|
||||
zimage_dump(base_ptr, true);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Note: This defines the complete_zboot() function */
|
||||
U_BOOT_SUBCMDS(zboot,
|
||||
U_BOOT_CMD_MKENT(start, 8, 1, do_zboot_start, "", ""),
|
||||
U_BOOT_CMD_MKENT(load, 1, 1, do_zboot_load, "", ""),
|
||||
U_BOOT_CMD_MKENT(setup, 1, 1, do_zboot_setup, "", ""),
|
||||
U_BOOT_CMD_MKENT(info, 1, 1, do_zboot_info, "", ""),
|
||||
U_BOOT_CMD_MKENT(go, 1, 1, do_zboot_go, "", ""),
|
||||
U_BOOT_CMD_MKENT(dump, 2, 1, do_zboot_dump, "", ""),
|
||||
)
|
||||
|
||||
int do_zboot_states(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[], int state_mask)
|
||||
{
|
||||
int ret;
|
||||
|
||||
if (flag & ZBOOT_STATE_START)
|
||||
ret = do_zboot_start(cmdtp, flag, argc, argv);
|
||||
if (!ret && (flag & ZBOOT_STATE_LOAD))
|
||||
ret = do_zboot_load(cmdtp, flag, argc, argv);
|
||||
if (!ret && (flag & ZBOOT_STATE_SETUP))
|
||||
ret = do_zboot_setup(cmdtp, flag, argc, argv);
|
||||
if (!ret && (flag & ZBOOT_STATE_INFO))
|
||||
ret = do_zboot_info(cmdtp, flag, argc, argv);
|
||||
if (!ret && (flag & ZBOOT_STATE_GO))
|
||||
ret = do_zboot_go(cmdtp, flag, argc, argv);
|
||||
if (ret)
|
||||
return ret;
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int do_zboot_parent(struct cmd_tbl *cmdtp, int flag, int argc,
|
||||
char *const argv[], int *repeatable)
|
||||
{
|
||||
/* determine if we have a sub command */
|
||||
if (argc > 1) {
|
||||
char *endp;
|
||||
|
||||
hextoul(argv[1], &endp);
|
||||
/*
|
||||
* endp pointing to nul means that argv[1] was just a valid
|
||||
* number, so pass it along to the normal processing
|
||||
*/
|
||||
if (*endp)
|
||||
return do_zboot(cmdtp, flag, argc, argv, repeatable);
|
||||
}
|
||||
|
||||
do_zboot_states(cmdtp, flag, argc, argv, ZBOOT_STATE_START |
|
||||
ZBOOT_STATE_LOAD | ZBOOT_STATE_SETUP |
|
||||
ZBOOT_STATE_INFO | ZBOOT_STATE_GO);
|
||||
|
||||
return CMD_RET_FAILURE;
|
||||
}
|
||||
|
||||
U_BOOT_CMDREP_COMPLETE(
|
||||
zboot, 8, do_zboot_parent, "Boot bzImage",
|
||||
"[addr] [size] [initrd addr] [initrd size] [setup] [cmdline]\n"
|
||||
" addr - The optional starting address of the bzimage.\n"
|
||||
" If not set it defaults to the environment\n"
|
||||
" variable \"fileaddr\".\n"
|
||||
" size - The optional size of the bzimage. Defaults to\n"
|
||||
" zero.\n"
|
||||
" initrd addr - The address of the initrd image to use, if any.\n"
|
||||
" initrd size - The size of the initrd image to use, if any.\n"
|
||||
" setup - The address of the kernel setup region, if this\n"
|
||||
" is not at addr\n"
|
||||
" cmdline - Environment variable containing the kernel\n"
|
||||
" command line, to override U-Boot's normal\n"
|
||||
" cmdline generation\n"
|
||||
"\n"
|
||||
"Sub-commands to do part of the zboot sequence:\n"
|
||||
"\tstart [addr [arg ...]] - specify arguments\n"
|
||||
"\tload - load OS image\n"
|
||||
"\tsetup - set up table\n"
|
||||
"\tinfo - show summary info\n"
|
||||
"\tgo - start OS\n"
|
||||
"\tdump [addr] - dump info (optional address of boot params)",
|
||||
complete_zboot
|
||||
);
|
||||
|
|
@ -273,21 +273,24 @@ int bootm_process_cmdline(char *buf, int maxlen, int flags);
|
|||
int bootm_process_cmdline_env(int flags);
|
||||
|
||||
/**
|
||||
* zboot_start() - Boot a zimage
|
||||
* zboot_run() - Run through the various steps to boot a zimage
|
||||
*
|
||||
* Boot a zimage, given the component parts
|
||||
*
|
||||
* @addr: Address where the bzImage is moved before booting, either
|
||||
* BZIMAGE_LOAD_ADDR or ZIMAGE_LOAD_ADDR
|
||||
* @base: Pointer to the boot parameters, typically at address
|
||||
* DEFAULT_SETUP_BASE
|
||||
* @size: Size of bzImage, or 0 to detect this
|
||||
* @initrd: Address of the initial ramdisk, or 0 if none
|
||||
* @initrd_size: Size of the initial ramdisk, or 0 if none
|
||||
* @cmdline: Command line to use for booting
|
||||
* @base_addr: If non-zero, this indicates that the boot parameters have already
|
||||
* been loaded by the caller to this address, so the load_zimage() call
|
||||
* in zboot_load() will be skipped when booting
|
||||
* @cmdline: If non-NULL, the environment variable containing the command line
|
||||
* to use for booting
|
||||
* Return: -EFAULT on error (normally it does not return)
|
||||
*/
|
||||
int zboot_start(ulong addr, ulong size, ulong initrd, ulong initrd_size,
|
||||
ulong base, char *cmdline);
|
||||
int zboot_run(ulong addr, ulong size, ulong initrd, ulong initrd_size,
|
||||
ulong base, char *cmdline);
|
||||
|
||||
/*
|
||||
* zimage_get_kernel_version() - Get the version string from a kernel
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue