uboot/arch/sandbox/cpu/start.c
<<
>>
Prefs
   1/*
   2 * Copyright (c) 2011-2012 The Chromium OS Authors.
   3 * SPDX-License-Identifier:     GPL-2.0+
   4 */
   5
   6#include <common.h>
   7#include <errno.h>
   8#include <os.h>
   9#include <cli.h>
  10#include <malloc.h>
  11#include <asm/getopt.h>
  12#include <asm/io.h>
  13#include <asm/sections.h>
  14#include <asm/state.h>
  15
  16DECLARE_GLOBAL_DATA_PTR;
  17
  18int sandbox_early_getopt_check(void)
  19{
  20        struct sandbox_state *state = state_get_current();
  21        struct sandbox_cmdline_option **sb_opt = __u_boot_sandbox_option_start;
  22        size_t num_options = __u_boot_sandbox_option_count();
  23        size_t i;
  24        int max_arg_len, max_noarg_len;
  25
  26        /* parse_err will be a string of the faulting option */
  27        if (!state->parse_err)
  28                return 0;
  29
  30        if (strcmp(state->parse_err, "help")) {
  31                printf("u-boot: error: failed while parsing option: %s\n"
  32                        "\ttry running with --help for more information.\n",
  33                        state->parse_err);
  34                os_exit(1);
  35        }
  36
  37        printf(
  38                "u-boot, a command line test interface to U-Boot\n\n"
  39                "Usage: u-boot [options]\n"
  40                "Options:\n");
  41
  42        max_arg_len = 0;
  43        for (i = 0; i < num_options; ++i)
  44                max_arg_len = max((int)strlen(sb_opt[i]->flag), max_arg_len);
  45        max_noarg_len = max_arg_len + 7;
  46
  47        for (i = 0; i < num_options; ++i) {
  48                struct sandbox_cmdline_option *opt = sb_opt[i];
  49
  50                /* first output the short flag if it has one */
  51                if (opt->flag_short >= 0x100)
  52                        printf("      ");
  53                else
  54                        printf("  -%c, ", opt->flag_short);
  55
  56                /* then the long flag */
  57                if (opt->has_arg)
  58                        printf("--%-*s <arg> ", max_arg_len, opt->flag);
  59                else
  60                        printf("--%-*s", max_noarg_len, opt->flag);
  61
  62                /* finally the help text */
  63                printf("  %s\n", opt->help);
  64        }
  65
  66        os_exit(0);
  67}
  68
  69int misc_init_f(void)
  70{
  71        return sandbox_early_getopt_check();
  72}
  73
  74static int sandbox_cmdline_cb_help(struct sandbox_state *state, const char *arg)
  75{
  76        /* just flag to sandbox_early_getopt_check to show usage */
  77        return 1;
  78}
  79SANDBOX_CMDLINE_OPT_SHORT(help, 'h', 0, "Display help");
  80
  81#ifndef CONFIG_SPL_BUILD
  82int sandbox_main_loop_init(void)
  83{
  84        struct sandbox_state *state = state_get_current();
  85
  86        /* Execute command if required */
  87        if (state->cmd || state->run_distro_boot) {
  88                int retval = 0;
  89
  90                cli_init();
  91
  92#ifdef CONFIG_CMDLINE
  93                if (state->cmd)
  94                        retval = run_command_list(state->cmd, -1, 0);
  95
  96                if (state->run_distro_boot)
  97                        retval = cli_simple_run_command("run distro_bootcmd",
  98                                                        0);
  99#endif
 100                if (!state->interactive)
 101                        os_exit(retval);
 102        }
 103
 104        return 0;
 105}
 106#endif
 107
 108static int sandbox_cmdline_cb_boot(struct sandbox_state *state,
 109                                      const char *arg)
 110{
 111        state->run_distro_boot = true;
 112        return 0;
 113}
 114SANDBOX_CMDLINE_OPT_SHORT(boot, 'b', 0, "Run distro boot commands");
 115
 116static int sandbox_cmdline_cb_command(struct sandbox_state *state,
 117                                      const char *arg)
 118{
 119        state->cmd = arg;
 120        return 0;
 121}
 122SANDBOX_CMDLINE_OPT_SHORT(command, 'c', 1, "Execute U-Boot command");
 123
 124static int sandbox_cmdline_cb_fdt(struct sandbox_state *state, const char *arg)
 125{
 126        state->fdt_fname = arg;
 127        return 0;
 128}
 129SANDBOX_CMDLINE_OPT_SHORT(fdt, 'd', 1, "Specify U-Boot's control FDT");
 130
 131static int sandbox_cmdline_cb_default_fdt(struct sandbox_state *state,
 132                                          const char *arg)
 133{
 134        const char *fmt = "%s.dtb";
 135        char *fname;
 136        int len;
 137
 138        len = strlen(state->argv[0]) + strlen(fmt) + 1;
 139        fname = os_malloc(len);
 140        if (!fname)
 141                return -ENOMEM;
 142        snprintf(fname, len, fmt, state->argv[0]);
 143        state->fdt_fname = fname;
 144
 145        return 0;
 146}
 147SANDBOX_CMDLINE_OPT_SHORT(default_fdt, 'D', 0,
 148                "Use the default u-boot.dtb control FDT in U-Boot directory");
 149
 150static int sandbox_cmdline_cb_interactive(struct sandbox_state *state,
 151                                          const char *arg)
 152{
 153        state->interactive = true;
 154        return 0;
 155}
 156
 157SANDBOX_CMDLINE_OPT_SHORT(interactive, 'i', 0, "Enter interactive mode");
 158
 159static int sandbox_cmdline_cb_jump(struct sandbox_state *state,
 160                                   const char *arg)
 161{
 162        /* Remember to delete this U-Boot image later */
 163        state->jumped_fname = arg;
 164
 165        return 0;
 166}
 167SANDBOX_CMDLINE_OPT_SHORT(jump, 'j', 1, "Jumped from previous U-Boot");
 168
 169static int sandbox_cmdline_cb_memory(struct sandbox_state *state,
 170                                     const char *arg)
 171{
 172        int err;
 173
 174        /* For now assume we always want to write it */
 175        state->write_ram_buf = true;
 176        state->ram_buf_fname = arg;
 177
 178        err = os_read_ram_buf(arg);
 179        if (err) {
 180                printf("Failed to read RAM buffer\n");
 181                return err;
 182        }
 183
 184        return 0;
 185}
 186SANDBOX_CMDLINE_OPT_SHORT(memory, 'm', 1,
 187                          "Read/write ram_buf memory contents from file");
 188
 189static int sandbox_cmdline_cb_rm_memory(struct sandbox_state *state,
 190                                        const char *arg)
 191{
 192        state->ram_buf_rm = true;
 193
 194        return 0;
 195}
 196SANDBOX_CMDLINE_OPT(rm_memory, 0, "Remove memory file after reading");
 197
 198static int sandbox_cmdline_cb_state(struct sandbox_state *state,
 199                                    const char *arg)
 200{
 201        state->state_fname = arg;
 202        return 0;
 203}
 204SANDBOX_CMDLINE_OPT_SHORT(state, 's', 1, "Specify the sandbox state FDT");
 205
 206static int sandbox_cmdline_cb_read(struct sandbox_state *state,
 207                                   const char *arg)
 208{
 209        state->read_state = true;
 210        return 0;
 211}
 212SANDBOX_CMDLINE_OPT_SHORT(read, 'r', 0, "Read the state FDT on startup");
 213
 214static int sandbox_cmdline_cb_write(struct sandbox_state *state,
 215                                    const char *arg)
 216{
 217        state->write_state = true;
 218        return 0;
 219}
 220SANDBOX_CMDLINE_OPT_SHORT(write, 'w', 0, "Write state FDT on exit");
 221
 222static int sandbox_cmdline_cb_ignore_missing(struct sandbox_state *state,
 223                                             const char *arg)
 224{
 225        state->ignore_missing_state_on_read = true;
 226        return 0;
 227}
 228SANDBOX_CMDLINE_OPT_SHORT(ignore_missing, 'n', 0,
 229                          "Ignore missing state on read");
 230
 231static int sandbox_cmdline_cb_show_lcd(struct sandbox_state *state,
 232                                       const char *arg)
 233{
 234        state->show_lcd = true;
 235        return 0;
 236}
 237SANDBOX_CMDLINE_OPT_SHORT(show_lcd, 'l', 0,
 238                          "Show the sandbox LCD display");
 239
 240static const char *term_args[STATE_TERM_COUNT] = {
 241        "raw-with-sigs",
 242        "raw",
 243        "cooked",
 244};
 245
 246static int sandbox_cmdline_cb_terminal(struct sandbox_state *state,
 247                                       const char *arg)
 248{
 249        int i;
 250
 251        for (i = 0; i < STATE_TERM_COUNT; i++) {
 252                if (!strcmp(arg, term_args[i])) {
 253                        state->term_raw = i;
 254                        return 0;
 255                }
 256        }
 257
 258        printf("Unknown terminal setting '%s' (", arg);
 259        for (i = 0; i < STATE_TERM_COUNT; i++)
 260                printf("%s%s", i ? ", " : "", term_args[i]);
 261        puts(")\n");
 262
 263        return 1;
 264}
 265SANDBOX_CMDLINE_OPT_SHORT(terminal, 't', 1,
 266                          "Set terminal to raw/cooked mode");
 267
 268static int sandbox_cmdline_cb_verbose(struct sandbox_state *state,
 269                                      const char *arg)
 270{
 271        state->show_test_output = true;
 272        return 0;
 273}
 274SANDBOX_CMDLINE_OPT_SHORT(verbose, 'v', 0, "Show test output");
 275
 276int board_run_command(const char *cmdline)
 277{
 278        printf("## Commands are disabled. Please enable CONFIG_CMDLINE.\n");
 279
 280        return 1;
 281}
 282
 283static void setup_ram_buf(struct sandbox_state *state)
 284{
 285        gd->arch.ram_buf = state->ram_buf;
 286        gd->ram_size = state->ram_size;
 287}
 288
 289int main(int argc, char *argv[])
 290{
 291        struct sandbox_state *state;
 292        gd_t data;
 293        int ret;
 294
 295        ret = state_init();
 296        if (ret)
 297                goto err;
 298
 299        state = state_get_current();
 300        if (os_parse_args(state, argc, argv))
 301                return 1;
 302
 303        ret = sandbox_read_state(state, state->state_fname);
 304        if (ret)
 305                goto err;
 306
 307        /* Remove old memory file if required */
 308        if (state->ram_buf_rm && state->ram_buf_fname)
 309                os_unlink(state->ram_buf_fname);
 310
 311        memset(&data, '\0', sizeof(data));
 312        gd = &data;
 313#ifdef CONFIG_SYS_MALLOC_F_LEN
 314        gd->malloc_base = CONFIG_MALLOC_F_ADDR;
 315#endif
 316        setup_ram_buf(state);
 317
 318        /* Do pre- and post-relocation init */
 319        board_init_f(0);
 320
 321        board_init_r(gd->new_gd, 0);
 322
 323        /* NOTREACHED - board_init_r() does not return */
 324        return 0;
 325
 326err:
 327        printf("Error %d\n", ret);
 328        return 1;
 329}
 330