upstream u-boot with additional patches for our devices/boards: https://lists.denx.de/pipermail/u-boot/2017-March/282789.html (AXP crashes) ; Gbit ethernet patch for some LIME2 revisions ; with SPI flash support
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 
u-boot/arch/sandbox/cpu/start.c

338 lines
7.5 KiB

// SPDX-License-Identifier: GPL-2.0+
/*
* Copyright (c) 2011-2012 The Chromium OS Authors.
*/
#include <common.h>
#include <errno.h>
#include <os.h>
#include <cli.h>
#include <malloc.h>
#include <asm/getopt.h>
#include <asm/io.h>
#include <asm/sections.h>
#include <asm/state.h>
DECLARE_GLOBAL_DATA_PTR;
int sandbox_early_getopt_check(void)
{
struct sandbox_state *state = state_get_current();
struct sandbox_cmdline_option **sb_opt = __u_boot_sandbox_option_start;
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)
max_arg_len = max((int)strlen(sb_opt[i]->flag), max_arg_len);
max_noarg_len = max_arg_len + 7;
for (i = 0; i < num_options; ++i) {
struct sandbox_cmdline_option *opt = sb_opt[i];
/* 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);
else
printf("--%-*s", max_noarg_len, opt->flag);
/* finally the help text */
printf(" %s\n", opt->help);
}
os_exit(0);
}
int misc_init_f(void)
{
return sandbox_early_getopt_check();
}
static int sandbox_cmdline_cb_help(struct sandbox_state *state, const char *arg)
{
/* just flag to sandbox_early_getopt_check to show usage */
return 1;
}
SANDBOX_CMDLINE_OPT_SHORT(help, 'h', 0, "Display help");
#ifndef CONFIG_SPL_BUILD
int sandbox_main_loop_init(void)
{
struct sandbox_state *state = state_get_current();
/* Execute command if required */
if (state->cmd || state->run_distro_boot) {
int retval = 0;
cli_init();
#ifdef CONFIG_CMDLINE
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);
#endif
if (!state->interactive)
os_exit(retval);
}
return 0;
}
#endif
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");
static int sandbox_cmdline_cb_command(struct sandbox_state *state,
const char *arg)
{
state->cmd = arg;
return 0;
}
SANDBOX_CMDLINE_OPT_SHORT(command, 'c', 1, "Execute U-Boot command");
static int sandbox_cmdline_cb_fdt(struct sandbox_state *state, const char *arg)
{
state->fdt_fname = arg;
return 0;
}
SANDBOX_CMDLINE_OPT_SHORT(fdt, 'd', 1, "Specify U-Boot's control FDT");
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");
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");
static int sandbox_cmdline_cb_jump(struct sandbox_state *state,
const char *arg)
{
/* Remember to delete this U-Boot image later */
state->jumped_fname = arg;
return 0;
}
SANDBOX_CMDLINE_OPT_SHORT(jump, 'j', 1, "Jumped from previous U-Boot");
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;
err = os_read_ram_buf(arg);
if (err) {
printf("Failed to read RAM buffer '%s': %d\n", arg, err);
return err;
}
return 0;
}
SANDBOX_CMDLINE_OPT_SHORT(memory, 'm', 1,
"Read/write ram_buf memory contents from file");
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");
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");
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");
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");
static int sandbox_cmdline_cb_verbose(struct sandbox_state *state,
const char *arg)
{
state->show_test_output = true;
return 0;
}
SANDBOX_CMDLINE_OPT_SHORT(verbose, 'v', 0, "Show test output");
static int sandbox_cmdline_cb_log_level(struct sandbox_state *state,
const char *arg)
{
state->default_log_level = simple_strtol(arg, NULL, 10);
return 0;
}
SANDBOX_CMDLINE_OPT_SHORT(log_level, 'L', 1,
"Set log level (0=panic, 7=debug)");
int board_run_command(const char *cmdline)
{
printf("## Commands are disabled. Please enable CONFIG_CMDLINE.\n");
return 1;
}
static void setup_ram_buf(struct sandbox_state *state)
{
gd->arch.ram_buf = state->ram_buf;
gd->ram_size = state->ram_size;
}
int main(int argc, char *argv[])
{
struct sandbox_state *state;
gd_t data;
int ret;
ret = state_init();
if (ret)
goto err;
state = state_get_current();
if (os_parse_args(state, argc, argv))
return 1;
ret = sandbox_read_state(state, state->state_fname);
if (ret)
goto err;
memset(&data, '\0', sizeof(data));
gd = &data;
#if CONFIG_VAL(SYS_MALLOC_F_LEN)
gd->malloc_base = CONFIG_MALLOC_F_ADDR;
#endif
#if CONFIG_IS_ENABLED(LOG)
gd->default_log_level = state->default_log_level;
#endif
setup_ram_buf(state);
/* Do pre- and post-relocation init */
board_init_f(0);
board_init_r(gd->new_gd, 0);
/* NOTREACHED - board_init_r() does not return */
return 0;
err:
printf("Error %d\n", ret);
return 1;
}