2011-10-04 04:26:45 +09:00
|
|
|
/*
|
2012-02-16 08:51:15 +09:00
|
|
|
* Copyright (c) 2011-2012 The Chromium OS Authors.
|
2013-07-08 16:37:19 +09:00
|
|
|
* SPDX-License-Identifier: GPL-2.0+
|
2011-10-04 04:26:45 +09:00
|
|
|
*/
|
|
|
|
|
|
|
|
#include <common.h>
|
2013-11-11 02:27:03 +09:00
|
|
|
#include <os.h>
|
2014-10-30 07:21:38 +09:00
|
|
|
#include <cli.h>
|
2015-01-20 12:21:34 +09:00
|
|
|
#include <malloc.h>
|
2012-02-16 08:51:16 +09:00
|
|
|
#include <asm/getopt.h>
|
2014-07-11 13:23:27 +09:00
|
|
|
#include <asm/io.h>
|
2012-02-16 08:51:16 +09:00
|
|
|
#include <asm/sections.h>
|
2012-02-16 08:51:15 +09:00
|
|
|
#include <asm/state.h>
|
2011-10-04 04:26:45 +09:00
|
|
|
|
2013-11-11 02:26:59 +09:00
|
|
|
DECLARE_GLOBAL_DATA_PTR;
|
|
|
|
|
2012-02-16 08:51:16 +09:00
|
|
|
int sandbox_early_getopt_check(void)
|
|
|
|
{
|
|
|
|
struct sandbox_state *state = state_get_current();
|
2013-12-04 08:43:23 +09:00
|
|
|
struct sandbox_cmdline_option **sb_opt = __u_boot_sandbox_option_start;
|
2012-02-16 08:51:16 +09:00
|
|
|
size_t num_options = __u_boot_sandbox_option_count();
|
|
|
|
size_t i;
|
|
|
|
int max_arg_len, max_noarg_len;
|
|
|
|
|
|
|
|
/* parse_err will be a string of the faulting option */
|
|
|
|
if (!state->parse_err)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
if (strcmp(state->parse_err, "help")) {
|
|
|
|
printf("u-boot: error: failed while parsing option: %s\n"
|
|
|
|
"\ttry running with --help for more information.\n",
|
|
|
|
state->parse_err);
|
|
|
|
os_exit(1);
|
|
|
|
}
|
|
|
|
|
|
|
|
printf(
|
|
|
|
"u-boot, a command line test interface to U-Boot\n\n"
|
|
|
|
"Usage: u-boot [options]\n"
|
|
|
|
"Options:\n");
|
|
|
|
|
|
|
|
max_arg_len = 0;
|
|
|
|
for (i = 0; i < num_options; ++i)
|
linux/kernel.h: sync min, max, min3, max3 macros with Linux
U-Boot has never cared about the type when we get max/min of two
values, but Linux Kernel does. This commit gets min, max, min3, max3
macros synced with the kernel introducing type checks.
Many of references of those macros must be fixed to suppress warnings.
We have two options:
- Use min, max, min3, max3 only when the arguments have the same type
(or add casts to the arguments)
- Use min_t/max_t instead with the appropriate type for the first
argument
Signed-off-by: Masahiro Yamada <yamada.m@jp.panasonic.com>
Acked-by: Pavel Machek <pavel@denx.de>
Acked-by: Lukasz Majewski <l.majewski@samsung.com>
Tested-by: Lukasz Majewski <l.majewski@samsung.com>
[trini: Fixup arch/blackfin/lib/string.c]
Signed-off-by: Tom Rini <trini@ti.com>
2014-11-07 03:03:31 +09:00
|
|
|
max_arg_len = max((int)strlen(sb_opt[i]->flag), max_arg_len);
|
2012-02-16 08:51:16 +09:00
|
|
|
max_noarg_len = max_arg_len + 7;
|
|
|
|
|
|
|
|
for (i = 0; i < num_options; ++i) {
|
2013-12-04 08:43:23 +09:00
|
|
|
struct sandbox_cmdline_option *opt = sb_opt[i];
|
2012-02-16 08:51:16 +09:00
|
|
|
|
|
|
|
/* first output the short flag if it has one */
|
|
|
|
if (opt->flag_short >= 0x100)
|
|
|
|
printf(" ");
|
|
|
|
else
|
|
|
|
printf(" -%c, ", opt->flag_short);
|
|
|
|
|
|
|
|
/* then the long flag */
|
|
|
|
if (opt->has_arg)
|
|
|
|
printf("--%-*s <arg> ", max_arg_len, opt->flag);
|
2013-11-11 02:26:58 +09:00
|
|
|
else
|
|
|
|
printf("--%-*s", max_noarg_len, opt->flag);
|
2012-02-16 08:51:16 +09:00
|
|
|
|
|
|
|
/* finally the help text */
|
|
|
|
printf(" %s\n", opt->help);
|
|
|
|
}
|
|
|
|
|
|
|
|
os_exit(0);
|
|
|
|
}
|
|
|
|
|
2013-12-04 08:43:23 +09:00
|
|
|
static int sandbox_cmdline_cb_help(struct sandbox_state *state, const char *arg)
|
2012-02-16 08:51:16 +09:00
|
|
|
{
|
|
|
|
/* just flag to sandbox_early_getopt_check to show usage */
|
|
|
|
return 1;
|
|
|
|
}
|
2013-12-04 08:43:23 +09:00
|
|
|
SANDBOX_CMDLINE_OPT_SHORT(help, 'h', 0, "Display help");
|
2012-02-16 08:51:16 +09:00
|
|
|
|
2012-02-27 07:38:50 +09:00
|
|
|
int sandbox_main_loop_init(void)
|
|
|
|
{
|
2012-02-16 08:51:16 +09:00
|
|
|
struct sandbox_state *state = state_get_current();
|
|
|
|
|
|
|
|
/* Execute command if required */
|
2015-05-01 05:16:09 +09:00
|
|
|
if (state->cmd || state->run_distro_boot) {
|
|
|
|
int retval = 0;
|
2015-02-07 06:37:31 +09:00
|
|
|
|
2014-10-30 07:21:38 +09:00
|
|
|
cli_init();
|
|
|
|
|
2015-05-01 05:16:09 +09:00
|
|
|
if (state->cmd)
|
|
|
|
retval = run_command_list(state->cmd, -1, 0);
|
|
|
|
|
|
|
|
if (state->run_distro_boot)
|
|
|
|
retval = cli_simple_run_command("run distro_bootcmd",
|
|
|
|
0);
|
|
|
|
|
2013-11-11 02:27:02 +09:00
|
|
|
if (!state->interactive)
|
2015-02-07 06:37:31 +09:00
|
|
|
os_exit(retval);
|
2012-02-16 08:51:16 +09:00
|
|
|
}
|
|
|
|
|
2012-02-27 07:38:50 +09:00
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2015-05-01 05:16:09 +09:00
|
|
|
static int sandbox_cmdline_cb_boot(struct sandbox_state *state,
|
|
|
|
const char *arg)
|
|
|
|
{
|
|
|
|
state->run_distro_boot = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
SANDBOX_CMDLINE_OPT_SHORT(boot, 'b', 0, "Run distro boot commands");
|
|
|
|
|
2013-12-04 08:43:23 +09:00
|
|
|
static int sandbox_cmdline_cb_command(struct sandbox_state *state,
|
|
|
|
const char *arg)
|
2012-02-16 08:51:16 +09:00
|
|
|
{
|
|
|
|
state->cmd = arg;
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-04 08:43:23 +09:00
|
|
|
SANDBOX_CMDLINE_OPT_SHORT(command, 'c', 1, "Execute U-Boot command");
|
2012-02-16 08:51:16 +09:00
|
|
|
|
2013-12-04 08:43:23 +09:00
|
|
|
static int sandbox_cmdline_cb_fdt(struct sandbox_state *state, const char *arg)
|
2013-04-20 17:42:41 +09:00
|
|
|
{
|
|
|
|
state->fdt_fname = arg;
|
|
|
|
return 0;
|
|
|
|
}
|
2013-12-04 08:43:23 +09:00
|
|
|
SANDBOX_CMDLINE_OPT_SHORT(fdt, 'd', 1, "Specify U-Boot's control FDT");
|
2013-04-20 17:42:41 +09:00
|
|
|
|
2015-01-20 12:21:34 +09:00
|
|
|
static int sandbox_cmdline_cb_default_fdt(struct sandbox_state *state,
|
|
|
|
const char *arg)
|
|
|
|
{
|
|
|
|
const char *fmt = "%s.dtb";
|
|
|
|
char *fname;
|
|
|
|
int len;
|
|
|
|
|
|
|
|
len = strlen(state->argv[0]) + strlen(fmt) + 1;
|
|
|
|
fname = os_malloc(len);
|
|
|
|
if (!fname)
|
|
|
|
return -ENOMEM;
|
|
|
|
snprintf(fname, len, fmt, state->argv[0]);
|
|
|
|
state->fdt_fname = fname;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
SANDBOX_CMDLINE_OPT_SHORT(default_fdt, 'D', 0,
|
|
|
|
"Use the default u-boot.dtb control FDT in U-Boot directory");
|
|
|
|
|
2013-11-11 02:27:02 +09:00
|
|
|
static int sandbox_cmdline_cb_interactive(struct sandbox_state *state,
|
|
|
|
const char *arg)
|
|
|
|
{
|
|
|
|
state->interactive = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
SANDBOX_CMDLINE_OPT_SHORT(interactive, 'i', 0, "Enter interactive mode");
|
|
|
|
|
2014-02-28 05:26:16 +09:00
|
|
|
static int sandbox_cmdline_cb_jump(struct sandbox_state *state,
|
|
|
|
const char *arg)
|
|
|
|
{
|
2014-02-28 05:26:23 +09:00
|
|
|
/* Remember to delete this U-Boot image later */
|
|
|
|
state->jumped_fname = arg;
|
2014-02-28 05:26:16 +09:00
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
SANDBOX_CMDLINE_OPT_SHORT(jump, 'j', 1, "Jumped from previous U-Boot");
|
|
|
|
|
2013-11-11 02:27:03 +09:00
|
|
|
static int sandbox_cmdline_cb_memory(struct sandbox_state *state,
|
|
|
|
const char *arg)
|
|
|
|
{
|
|
|
|
int err;
|
|
|
|
|
|
|
|
/* For now assume we always want to write it */
|
|
|
|
state->write_ram_buf = true;
|
|
|
|
state->ram_buf_fname = arg;
|
|
|
|
|
2014-11-12 04:47:08 +09:00
|
|
|
err = os_read_ram_buf(arg);
|
|
|
|
if (err) {
|
2013-11-11 02:27:03 +09:00
|
|
|
printf("Failed to read RAM buffer\n");
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
SANDBOX_CMDLINE_OPT_SHORT(memory, 'm', 1,
|
|
|
|
"Read/write ram_buf memory contents from file");
|
|
|
|
|
2014-02-28 05:26:23 +09:00
|
|
|
static int sandbox_cmdline_cb_rm_memory(struct sandbox_state *state,
|
|
|
|
const char *arg)
|
|
|
|
{
|
|
|
|
state->ram_buf_rm = true;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
SANDBOX_CMDLINE_OPT(rm_memory, 0, "Remove memory file after reading");
|
|
|
|
|
2013-11-11 02:27:04 +09:00
|
|
|
static int sandbox_cmdline_cb_state(struct sandbox_state *state,
|
|
|
|
const char *arg)
|
|
|
|
{
|
|
|
|
state->state_fname = arg;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
SANDBOX_CMDLINE_OPT_SHORT(state, 's', 1, "Specify the sandbox state FDT");
|
|
|
|
|
|
|
|
static int sandbox_cmdline_cb_read(struct sandbox_state *state,
|
|
|
|
const char *arg)
|
|
|
|
{
|
|
|
|
state->read_state = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
SANDBOX_CMDLINE_OPT_SHORT(read, 'r', 0, "Read the state FDT on startup");
|
|
|
|
|
|
|
|
static int sandbox_cmdline_cb_write(struct sandbox_state *state,
|
|
|
|
const char *arg)
|
|
|
|
{
|
|
|
|
state->write_state = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
SANDBOX_CMDLINE_OPT_SHORT(write, 'w', 0, "Write state FDT on exit");
|
|
|
|
|
|
|
|
static int sandbox_cmdline_cb_ignore_missing(struct sandbox_state *state,
|
|
|
|
const char *arg)
|
|
|
|
{
|
|
|
|
state->ignore_missing_state_on_read = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
SANDBOX_CMDLINE_OPT_SHORT(ignore_missing, 'n', 0,
|
|
|
|
"Ignore missing state on read");
|
|
|
|
|
2014-02-28 05:26:19 +09:00
|
|
|
static int sandbox_cmdline_cb_show_lcd(struct sandbox_state *state,
|
|
|
|
const char *arg)
|
|
|
|
{
|
|
|
|
state->show_lcd = true;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
SANDBOX_CMDLINE_OPT_SHORT(show_lcd, 'l', 0,
|
|
|
|
"Show the sandbox LCD display");
|
|
|
|
|
2014-02-28 05:26:22 +09:00
|
|
|
static const char *term_args[STATE_TERM_COUNT] = {
|
|
|
|
"raw-with-sigs",
|
|
|
|
"raw",
|
|
|
|
"cooked",
|
|
|
|
};
|
|
|
|
|
|
|
|
static int sandbox_cmdline_cb_terminal(struct sandbox_state *state,
|
|
|
|
const char *arg)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < STATE_TERM_COUNT; i++) {
|
|
|
|
if (!strcmp(arg, term_args[i])) {
|
|
|
|
state->term_raw = i;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
printf("Unknown terminal setting '%s' (", arg);
|
|
|
|
for (i = 0; i < STATE_TERM_COUNT; i++)
|
|
|
|
printf("%s%s", i ? ", " : "", term_args[i]);
|
|
|
|
puts(")\n");
|
|
|
|
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
SANDBOX_CMDLINE_OPT_SHORT(terminal, 't', 1,
|
|
|
|
"Set terminal to raw/cooked mode");
|
|
|
|
|
2011-10-04 04:26:45 +09:00
|
|
|
int main(int argc, char *argv[])
|
|
|
|
{
|
2012-02-16 08:51:16 +09:00
|
|
|
struct sandbox_state *state;
|
2014-07-11 13:23:27 +09:00
|
|
|
gd_t data;
|
2013-11-11 02:27:04 +09:00
|
|
|
int ret;
|
2012-02-16 08:51:15 +09:00
|
|
|
|
2013-11-11 02:27:04 +09:00
|
|
|
ret = state_init();
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
2012-02-16 08:51:15 +09:00
|
|
|
|
2012-02-16 08:51:16 +09:00
|
|
|
state = state_get_current();
|
|
|
|
if (os_parse_args(state, argc, argv))
|
|
|
|
return 1;
|
|
|
|
|
2013-11-11 02:27:04 +09:00
|
|
|
ret = sandbox_read_state(state, state->state_fname);
|
|
|
|
if (ret)
|
|
|
|
goto err;
|
|
|
|
|
2014-02-28 05:26:23 +09:00
|
|
|
/* Remove old memory file if required */
|
|
|
|
if (state->ram_buf_rm && state->ram_buf_fname)
|
|
|
|
os_unlink(state->ram_buf_fname);
|
|
|
|
|
2014-07-11 13:23:27 +09:00
|
|
|
memset(&data, '\0', sizeof(data));
|
|
|
|
gd = &data;
|
2014-07-11 13:23:31 +09:00
|
|
|
#ifdef CONFIG_SYS_MALLOC_F_LEN
|
|
|
|
gd->malloc_base = CONFIG_MALLOC_F_ADDR;
|
|
|
|
#endif
|
2014-07-11 13:23:27 +09:00
|
|
|
|
2013-11-11 02:26:59 +09:00
|
|
|
/* Do pre- and post-relocation init */
|
2011-10-04 04:26:45 +09:00
|
|
|
board_init_f(0);
|
2013-01-22 22:11:21 +09:00
|
|
|
|
2013-11-11 02:26:59 +09:00
|
|
|
board_init_r(gd->new_gd, 0);
|
|
|
|
|
|
|
|
/* NOTREACHED - board_init_r() does not return */
|
2013-01-22 22:11:21 +09:00
|
|
|
return 0;
|
2013-11-11 02:27:04 +09:00
|
|
|
|
|
|
|
err:
|
|
|
|
printf("Error %d\n", ret);
|
|
|
|
return 1;
|
2011-10-04 04:26:45 +09:00
|
|
|
}
|