1 files changed, 511 insertions, 0 deletions
diff --git a/roms/u-boot/arch/sandbox/cpu/start.c b/roms/u-boot/arch/sandbox/cpu/start.c
new file mode 100644
index 000000000..6bb94473f
--- /dev/null
+++ b/roms/u-boot/arch/sandbox/cpu/start.c
@@ -0,0 +1,511 @@
+// SPDX-License-Identifier: GPL-2.0+
+/*
+ * Copyright (c) 2011-2012 The Chromium OS Authors.
+ */
+
+#include <common.h>
+#include <command.h>
+#include <dm/root.h>
+#include <efi_loader.h>
+#include <errno.h>
+#include <init.h>
+#include <log.h>
+#include <os.h>
+#include <cli.h>
+#include <sort.h>
+#include <asm/getopt.h>
+#include <asm/global_data.h>
+#include <asm/io.h>
+#include <asm/malloc.h>
+#include <asm/sections.h>
+#include <asm/state.h>
+#include <linux/ctype.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+static char **os_argv;
+
+/* Compare two options so that they can be sorted into alphabetical order */
+static int h_compare_opt(const void *p1, const void *p2)
+{
+	const struct sandbox_cmdline_option *opt1 = p1;
+	const struct sandbox_cmdline_option *opt2 = p2;
+	const char *str1, *str2;
+	char flag1[2], flag2[2];
+
+	opt1 = *(struct sandbox_cmdline_option **)p1;
+	opt2 = *(struct sandbox_cmdline_option **)p2;
+	flag1[1] = '\0';
+	flag2[1] = '\0';
+
+	*flag1 = opt1->flag_short < 0x100 ? opt1->flag_short : '\0';
+	*flag2 = opt2->flag_short < 0x100 ? opt2->flag_short : '\0';
+
+	str1 = *flag1 ? flag1 : opt1->flag;
+	str2 = *flag2 ? flag2 : opt2->flag;
+
+	/*
+	 * Force lower-case flags to come before upper-case ones. We only
+	 * support upper-case for short flags.
+	 */
+	if (isalpha(*str1) && isalpha(*str2) &&
+	    tolower(*str1) == tolower(*str2))
+		return isupper(*str1) - isupper(*str2);
+
+	return strcasecmp(str1, str2);
+}
+
+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;
+	struct sandbox_cmdline_option **sorted_opt;
+	int size;
+
+	/* 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;
+
+	/* Sort the options */
+	size = sizeof(*sorted_opt) * num_options;
+	sorted_opt = os_malloc(size);
+	if (!sorted_opt) {
+		printf("No memory to sort options\n");
+		os_exit(1);
+	}
+	memcpy(sorted_opt, sb_opt, size);
+	qsort(sorted_opt, num_options, sizeof(*sorted_opt), h_compare_opt);
+
+	for (i = 0; i < num_options; ++i) {
+		struct sandbox_cmdline_option *opt = sorted_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_test_fdt(struct sandbox_state *state,
+				       const char *arg)
+{
+	const char *fmt = "/arch/sandbox/dts/test.dtb";
+	char *p;
+	char *fname;
+	int len;
+
+	len = strlen(state->argv[0]) + strlen(fmt) + 1;
+	fname = os_malloc(len);
+	if (!fname)
+		return -ENOMEM;
+	strcpy(fname, state->argv[0]);
+	p = strrchr(fname, '/');
+	if (!p)
+		p = fname + strlen(fname);
+	len -= p - fname;
+	snprintf(p, len, fmt);
+	state->fdt_fname = fname;
+
+	return 0;
+}
+SANDBOX_CMDLINE_OPT_SHORT(test_fdt, 'T', 0,
+			  "Use the test.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;
+	}
+	state->ram_buf_read = true;
+
+	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 int sandbox_cmdline_cb_double_lcd(struct sandbox_state *state,
+					 const char *arg)
+{
+	state->double_lcd = true;
+
+	return 0;
+}
+SANDBOX_CMDLINE_OPT_SHORT(double_lcd, 'K', 0,
+			  "Double the LCD display size in each direction");
+
+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)");
+
+static int sandbox_cmdline_cb_unittests(struct sandbox_state *state,
+					const char *arg)
+{
+	state->run_unittests = true;
+
+	return 0;
+}
+SANDBOX_CMDLINE_OPT_SHORT(unittests, 'u', 0, "Run unit tests");
+
+static int sandbox_cmdline_cb_select_unittests(struct sandbox_state *state,
+					       const char *arg)
+{
+	state->select_unittests = arg;
+
+	return 0;
+}
+SANDBOX_CMDLINE_OPT_SHORT(select_unittests, 'k', 1, "Select unit tests to run");
+
+static void setup_ram_buf(struct sandbox_state *state)
+{
+	/* Zero the RAM buffer if we didn't read it, to keep valgrind happy */
+	if (!state->ram_buf_read)
+		memset(state->ram_buf, '\0', state->ram_size);
+
+	gd->arch.ram_buf = state->ram_buf;
+	gd->ram_size = state->ram_size;
+}
+
+void state_show(struct sandbox_state *state)
+{
+	char **p;
+
+	printf("Arguments:\n");
+	for (p = state->argv; *p; p++)
+		printf("%s ", *p);
+	printf("\n");
+}
+
+void __efi_runtime EFIAPI efi_reset_system(
+		enum efi_reset_type reset_type,
+		efi_status_t reset_status,
+		unsigned long data_size, void *reset_data)
+{
+	os_fd_restore();
+	os_relaunch(os_argv);
+}
+
+void sandbox_reset(void)
+{
+	/* Do this here while it still has an effect */
+	os_fd_restore();
+	if (state_uninit())
+		os_exit(2);
+
+	if (dm_uninit())
+		os_exit(2);
+
+	/* Restart U-Boot */
+	os_relaunch(os_argv);
+}
+
+int main(int argc, char *argv[])
+{
+	struct sandbox_state *state;
+	void * text_base;
+	gd_t data;
+	int size;
+	int ret;
+
+	text_base = os_find_text_base();
+
+	/*
+	 * Copy argv[] so that we can pass the arguments in the original
+	 * sequence when resetting the sandbox.
+	 */
+	size = sizeof(char *) * (argc + 1);
+	os_argv = os_malloc(size);
+	if (!os_argv)
+		os_exit(1);
+	memcpy(os_argv, argv, size);
+
+	memset(&data, '\0', sizeof(data));
+	gd = &data;
+	gd->arch.text_base = text_base;
+
+	ret = state_init();
+	if (ret)
+		goto err;
+
+	state = state_get_current();
+	if (os_parse_args(state, argc, argv))
+		return 1;
+
+	/* Remove old memory file if required */
+	if (state->ram_buf_rm && state->ram_buf_fname) {
+		os_unlink(state->ram_buf_fname);
+		state->write_ram_buf = false;
+		state->ram_buf_fname = NULL;
+	}
+
+	ret = sandbox_read_state(state, state->state_fname);
+	if (ret)
+		goto err;
+
+	ret = os_setup_signal_handlers();
+	if (ret)
+		goto err;
+
+#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);
+
+	/*
+	 * Set up the relocation offset here, since sandbox symbols are always
+	 * relocated by the OS before sandbox is entered.
+	 */
+	gd->reloc_off = (ulong)gd->arch.text_base;
+
+	/* sandbox test: log functions called before log_init in board_init_f */
+	log_debug("debug: %s\n", __func__);
+
+	/* 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;
+}