1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
|
/*
* Copyright (c) 2011-2012 The Chromium OS Authors.
* SPDX-License-Identifier: GPL-2.0+
*/
#include <common.h>
#include <os.h>
#include <asm/getopt.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(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);
}
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");
int sandbox_main_loop_init(void)
{
struct sandbox_state *state = state_get_current();
/* Execute command if required */
if (state->cmd) {
run_command_list(state->cmd, -1, 0);
if (!state->interactive)
os_exit(state->exit_type);
}
return 0;
}
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_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)
{
state->jumped = 1;
/*
* TODO(sjg@chromium.org): Note this causes problems for gdb which
* wants to read debug data from the image.
*
* os_unlink(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;
if (os_read_ram_buf(arg)) {
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");
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");
int main(int argc, char *argv[])
{
struct sandbox_state *state;
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;
/* 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;
}
|
