From bade0ac04b96d92642b3d433734cde2f00ab7fc5 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 3 Dec 2023 17:29:27 -0700 Subject: x86: zboot: Move command code into its own file Much of the code in zimage.c deals with the zboot command. Move it into a sepatate zboot.c file within the cmd/ directory. This will eventually allow use of the zimage logic without the command being enabled. Signed-off-by: Simon Glass --- cmd/x86/Makefile | 1 + cmd/x86/zboot.c | 203 +++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 204 insertions(+) create mode 100644 cmd/x86/zboot.c (limited to 'cmd') diff --git a/cmd/x86/Makefile b/cmd/x86/Makefile index 5f82204c87e..b1f39d3bfde 100644 --- a/cmd/x86/Makefile +++ b/cmd/x86/Makefile @@ -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 diff --git a/cmd/x86/zboot.c b/cmd/x86/zboot.c new file mode 100644 index 00000000000..c9375fb417c --- /dev/null +++ b/cmd/x86/zboot.c @@ -0,0 +1,203 @@ +// SPDX-License-Identifier: GPL-2.0+ +/* + * Copyright (c) 2011 The Chromium OS Authors. + * (C) Copyright 2002 + * Daniel Engström, Omicron Ceti AB, + */ + +#include +#include +#include +#include + +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 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; + + 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 do_zboot_go(struct cmd_tbl *cmdtp, int flag, int argc, + char *const argv[]) +{ + int ret; + + ret = zboot_go(); + printf("Kernel returned! (err=%d)\n", ret); + + return CMD_RET_FAILURE; +} + +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 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; +} + +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 +); -- cgit v1.2.3 From 80d4c987576070082ed27da88aed732d42396135 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 3 Dec 2023 17:29:28 -0700 Subject: x86: zboot: Create a separate ZBOOT option for zboot logic Most of the functionality of zboot is contained in the logic which handles a zimage. Create a separate Kconfig for the logic so that it can (later) be used without the command itself being enabled. Enable ZBOOT by default on x86, with the command depending on that. The existing 'imply' can therefore be removed. Signed-off-by: Simon Glass Reviewed-by: Tom Rini --- cmd/Kconfig | 2 ++ 1 file changed, 2 insertions(+) (limited to 'cmd') diff --git a/cmd/Kconfig b/cmd/Kconfig index 9ebea76c2ce..584ffd03968 100644 --- a/cmd/Kconfig +++ b/cmd/Kconfig @@ -538,6 +538,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 -- cgit v1.2.3 From 228c6722d4468d8cd9a3688e657976968ee3cdb8 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 3 Dec 2023 17:29:29 -0700 Subject: x86: zboot: Avoid iteration in do_zboot_states() Drop the iteration and write out each state in full. This will allow the arguments to be reduced and adjusted in future patches. Signed-off-by: Simon Glass --- cmd/x86/zboot.c | 27 ++++++++++++++------------- 1 file changed, 14 insertions(+), 13 deletions(-) (limited to 'cmd') diff --git a/cmd/x86/zboot.c b/cmd/x86/zboot.c index c9375fb417c..03cab1d67eb 100644 --- a/cmd/x86/zboot.c +++ b/cmd/x86/zboot.c @@ -136,19 +136,20 @@ U_BOOT_SUBCMDS(zboot, int do_zboot_states(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[], int state_mask) { - 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; - } - } + 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; } -- cgit v1.2.3 From 42a99d0df66d3092dfc1c922de9143448a863118 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 3 Dec 2023 17:29:30 -0700 Subject: x86: zboot: Create separate functions for the logic Separate out the commands from the logic. This will eventually allow the logic to be used when CONFIG_CMDLINE is not enabled. Signed-off-by: Simon Glass --- cmd/x86/zboot.c | 66 +++++++++++++++++++++++++++++++++++++++++++++------------ 1 file changed, 52 insertions(+), 14 deletions(-) (limited to 'cmd') diff --git a/cmd/x86/zboot.c b/cmd/x86/zboot.c index 03cab1d67eb..f5c90a8ba89 100644 --- a/cmd/x86/zboot.c +++ b/cmd/x86/zboot.c @@ -10,8 +10,7 @@ #include #include -static int do_zboot_start(struct cmd_tbl *cmdtp, int flag, int argc, - char *const argv[]) +static void zboot_start(int argc, char *const argv[]) { const char *s; @@ -53,6 +52,27 @@ static int do_zboot_start(struct cmd_tbl *cmdtp, int flag, int argc, } if (argc >= 7) state.cmdline = env_get(argv[6]); +} + +static int do_zboot_start(struct cmd_tbl *cmdtp, int flag, int argc, + char *const argv[]) +{ + zboot_start(argc, argv); + + return 0; +} + +static int _zboot_load(void) +{ + int ret; + + ret = zboot_load(); + if (!ret) + 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; } @@ -60,18 +80,13 @@ static int do_zboot_start(struct cmd_tbl *cmdtp, int flag, int argc, 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)) + if (_zboot_load()) return CMD_RET_FAILURE; return 0; } -static int do_zboot_setup(struct cmd_tbl *cmdtp, int flag, int argc, - char *const argv[]) +static int _zboot_setup(void) { struct boot_params *base_ptr = state.base_ptr; @@ -87,24 +102,47 @@ static int do_zboot_setup(struct cmd_tbl *cmdtp, int flag, int argc, return 0; } -static int do_zboot_info(struct cmd_tbl *cmdtp, int flag, int argc, - char *const argv[]) +static int do_zboot_setup(struct cmd_tbl *cmdtp, int flag, int argc, + char *const argv[]) +{ + return _zboot_setup(); +} + +static void zboot_info(void) { printf("Kernel loaded at %08lx, setup_base=%p\n", state.load_address, state.base_ptr); +} + +static int do_zboot_info(struct cmd_tbl *cmdtp, int flag, int argc, + char *const argv[]) +{ + zboot_info(); return 0; } +static int _zboot_go(void) +{ + int ret; + + ret = zboot_go(); + + return ret; +} + static int do_zboot_go(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) { int ret; - ret = zboot_go(); - printf("Kernel returned! (err=%d)\n", ret); + ret = _zboot_go(); + if (ret) { + printf("Kernel returned! (err=%d)\n", ret); + return CMD_RET_FAILURE; + } - return CMD_RET_FAILURE; + return 0; } static int do_zboot_dump(struct cmd_tbl *cmdtp, int flag, int argc, -- cgit v1.2.3 From db0c6f47c37f91db5a0caf27ebc870b8fe72c6aa Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 3 Dec 2023 17:29:31 -0700 Subject: x86: zboot: Move environment setting into zboot_load() The only difference between the command and the underlying logic is the setting of envrionment variables. Move this out of the command processing since it needs to be done in any case. Signed-off-by: Simon Glass --- cmd/x86/zboot.c | 16 ++-------------- 1 file changed, 2 insertions(+), 14 deletions(-) (limited to 'cmd') diff --git a/cmd/x86/zboot.c b/cmd/x86/zboot.c index f5c90a8ba89..d39ab6a9698 100644 --- a/cmd/x86/zboot.c +++ b/cmd/x86/zboot.c @@ -62,30 +62,18 @@ static int do_zboot_start(struct cmd_tbl *cmdtp, int flag, int argc, return 0; } -static int _zboot_load(void) +static int do_zboot_load(struct cmd_tbl *cmdtp, int flag, int argc, + char *const argv[]) { int ret; ret = zboot_load(); - if (!ret) - 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 do_zboot_load(struct cmd_tbl *cmdtp, int flag, int argc, - char *const argv[]) -{ - if (_zboot_load()) - return CMD_RET_FAILURE; - - return 0; -} - static int _zboot_setup(void) { struct boot_params *base_ptr = state.base_ptr; -- cgit v1.2.3 From cb19931ee56f52779d6dba97a0934afe97167840 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 3 Dec 2023 17:29:32 -0700 Subject: x86: zboot: Drop intermediate zboot_setup() function Move error checking into the caller so that do_zboot_setup() can call zboot_setup() directly. Signed-off-by: Simon Glass --- cmd/x86/zboot.c | 16 ++++++---------- 1 file changed, 6 insertions(+), 10 deletions(-) (limited to 'cmd') diff --git a/cmd/x86/zboot.c b/cmd/x86/zboot.c index d39ab6a9698..f392b6b3e49 100644 --- a/cmd/x86/zboot.c +++ b/cmd/x86/zboot.c @@ -74,11 +74,10 @@ static int do_zboot_load(struct cmd_tbl *cmdtp, int flag, int argc, return 0; } -static int _zboot_setup(void) +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) { + if (!state.base_ptr) { printf("base is not set: use 'zboot load' first\n"); return CMD_RET_FAILURE; } @@ -87,13 +86,10 @@ static int _zboot_setup(void) return CMD_RET_FAILURE; } - return 0; -} + if (zboot_setup()) + return CMD_RET_FAILURE; -static int do_zboot_setup(struct cmd_tbl *cmdtp, int flag, int argc, - char *const argv[]) -{ - return _zboot_setup(); + return 0; } static void zboot_info(void) -- cgit v1.2.3 From d531499749e7069a49995f3215c783dc1c2abb68 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 3 Dec 2023 17:29:33 -0700 Subject: x86: zboot: Drop intermediate zboot_go() function This function only calls zboot_go() so drop it. Signed-off-by: Simon Glass --- cmd/x86/zboot.c | 11 +---------- 1 file changed, 1 insertion(+), 10 deletions(-) (limited to 'cmd') diff --git a/cmd/x86/zboot.c b/cmd/x86/zboot.c index f392b6b3e49..f49cdd91a1f 100644 --- a/cmd/x86/zboot.c +++ b/cmd/x86/zboot.c @@ -106,21 +106,12 @@ static int do_zboot_info(struct cmd_tbl *cmdtp, int flag, int argc, return 0; } -static int _zboot_go(void) -{ - int ret; - - ret = zboot_go(); - - return ret; -} - static int do_zboot_go(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) { int ret; - ret = _zboot_go(); + ret = zboot_go(); if (ret) { printf("Kernel returned! (err=%d)\n", ret); return CMD_RET_FAILURE; -- cgit v1.2.3 From 02ed6c333ec480e2b36485bfcf804e9b12984266 Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 3 Dec 2023 17:29:34 -0700 Subject: x86: zboot: Move argument processing outside zboot_start() Process the arguments before calling zboot_start() so that we can separate the command line from the internal logic. Signed-off-by: Simon Glass --- cmd/x86/zboot.c | 67 ++++++++++++++++++++++++--------------------------------- 1 file changed, 28 insertions(+), 39 deletions(-) (limited to 'cmd') diff --git a/cmd/x86/zboot.c b/cmd/x86/zboot.c index f49cdd91a1f..572b58a5537 100644 --- a/cmd/x86/zboot.c +++ b/cmd/x86/zboot.c @@ -10,56 +10,45 @@ #include #include -static void zboot_start(int argc, char *const argv[]) +static int zboot_start(ulong bzimage_addr, ulong bzimage_size, + ulong initrd_addr, ulong initrd_size, ulong base_addr, + const char *cmdline) { - 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); + 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; } + state.cmdline = cmdline; - 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 do_zboot_start(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) { - zboot_start(argc, argv); + ulong bzimage_addr = 0, bzimage_size, initrd_addr, initrd_size; + ulong base_addr; + const char *s, *cmdline; - return 0; + /* 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; + + return zboot_start(bzimage_addr, bzimage_size, initrd_addr, initrd_size, + base_addr, cmdline); } static int do_zboot_load(struct cmd_tbl *cmdtp, int flag, int argc, -- cgit v1.2.3 From 9ad5fdf1a8a10d2c3daad33ba69cd88b7f7ea86b Mon Sep 17 00:00:00 2001 From: Simon Glass Date: Sun, 3 Dec 2023 17:29:36 -0700 Subject: x86: zboot: Separate logic functions from commands Move zboot_start() and zboot_info() in with the other logic functions. Signed-off-by: Simon Glass Reviewed-by: Tom Rini --- cmd/x86/zboot.c | 32 ++++---------------------------- 1 file changed, 4 insertions(+), 28 deletions(-) (limited to 'cmd') diff --git a/cmd/x86/zboot.c b/cmd/x86/zboot.c index 572b58a5537..addf28cb4aa 100644 --- a/cmd/x86/zboot.c +++ b/cmd/x86/zboot.c @@ -10,26 +10,6 @@ #include #include -static int zboot_start(ulong bzimage_addr, ulong bzimage_size, - ulong initrd_addr, ulong initrd_size, ulong base_addr, - const char *cmdline) -{ - memset(&state, '\0', sizeof(state)); - - 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; - } - state.cmdline = cmdline; - - return 0; -} - static int do_zboot_start(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) { @@ -47,8 +27,10 @@ static int do_zboot_start(struct cmd_tbl *cmdtp, int flag, int argc, base_addr = argc > 5 ? hextoul(argv[5], NULL) : 0; cmdline = argc > 6 ? env_get(argv[6]) : NULL; - return zboot_start(bzimage_addr, bzimage_size, initrd_addr, initrd_size, - base_addr, cmdline); + 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, @@ -81,12 +63,6 @@ static int do_zboot_setup(struct cmd_tbl *cmdtp, int flag, int argc, return 0; } -static void zboot_info(void) -{ - printf("Kernel loaded at %08lx, setup_base=%p\n", - state.load_address, state.base_ptr); -} - static int do_zboot_info(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[]) { -- cgit v1.2.3