blob: 5362781f18700ee7e98547e07a5f673635b52666 [file] [log] [blame]
wdenkc6097192002-11-03 00:24:07 +00001/*
2 * (C) Copyright 2000
3 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
Wolfgang Denk501090a2006-07-21 11:33:45 +02005 * Add to readline cmdline-editing by
6 * (C) Copyright 2005
7 * JinHua Luo, GuangDong Linux Center, <luo.jinhua@gd-linux.com>
8 *
wdenkc6097192002-11-03 00:24:07 +00009 * See file CREDITS for list of people who contributed to this
10 * project.
11 *
12 * This program is free software; you can redistribute it and/or
13 * modify it under the terms of the GNU General Public License as
14 * published by the Free Software Foundation; either version 2 of
15 * the License, or (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program; if not, write to the Free Software
24 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
25 * MA 02111-1307 USA
26 */
27
wdenka6c7ad22002-12-03 21:28:10 +000028/* #define DEBUG */
29
wdenkc6097192002-11-03 00:24:07 +000030#include <common.h>
31#include <watchdog.h>
32#include <command.h>
Che-Liang Chiou224b72e2012-10-25 16:31:07 +000033#include <fdtdec.h>
Simon Glassd51004a2012-03-30 21:30:55 +000034#include <malloc.h>
Andreas Bießmann09c2e902011-07-18 20:24:04 +020035#include <version.h>
Wolfgang Denkd9631ec2005-09-30 15:18:23 +020036#ifdef CONFIG_MODEM_SUPPORT
37#include <malloc.h> /* for free() prototype */
38#endif
wdenkc6097192002-11-03 00:24:07 +000039
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020040#ifdef CONFIG_SYS_HUSH_PARSER
wdenkc6097192002-11-03 00:24:07 +000041#include <hush.h>
42#endif
43
Che-Liang Chiou224b72e2012-10-25 16:31:07 +000044#ifdef CONFIG_OF_CONTROL
45#include <fdtdec.h>
46#endif
47
Gabe Black3b734592012-10-25 16:31:08 +000048#ifdef CONFIG_OF_LIBFDT
49#include <fdt_support.h>
50#endif /* CONFIG_OF_LIBFDT */
51
wdenkbdccc4f2003-08-05 17:43:17 +000052#include <post.h>
Jason Hobbs4d91a6e2011-08-23 11:06:54 +000053#include <linux/ctype.h>
Heiko Schocher317d6c52012-01-16 21:13:35 +000054#include <menu.h>
wdenkbdccc4f2003-08-05 17:43:17 +000055
Wolfgang Denkd87080b2006-03-31 18:32:53 +020056DECLARE_GLOBAL_DATA_PTR;
Wolfgang Denkd87080b2006-03-31 18:32:53 +020057
Heiko Schocherfad63402007-07-13 09:54:17 +020058/*
59 * Board-specific Platform code can reimplement show_boot_progress () if needed
60 */
61void inline __show_boot_progress (int val) {}
Emil Medve5e2c08c2009-05-12 13:48:32 -050062void show_boot_progress (int val) __attribute__((weak, alias("__show_boot_progress")));
Heiko Schocherfad63402007-07-13 09:54:17 +020063
Bartlomiej Sieka4bae9092008-10-01 15:26:31 +020064#if defined(CONFIG_UPDATE_TFTP)
Andreas Pretzsch8d6b7322011-07-16 05:50:59 +000065int update_tftp (ulong addr);
Bartlomiej Sieka4bae9092008-10-01 15:26:31 +020066#endif /* CONFIG_UPDATE_TFTP */
wdenk8bde7f72003-06-27 21:31:46 +000067
wdenkc6097192002-11-03 00:24:07 +000068#define MAX_DELAY_STOP_STR 32
69
wdenkc6097192002-11-03 00:24:07 +000070#undef DEBUG_PARSER
71
John Schmoller6475b9f2010-03-12 09:49:23 -060072char console_buffer[CONFIG_SYS_CBSIZE + 1]; /* console I/O buffer */
wdenkc6097192002-11-03 00:24:07 +000073
Stefan Roese3ca91222006-07-27 16:11:19 +020074static char * delete_char (char *buffer, char *p, int *colp, int *np, int plen);
Mike Frysinger82359ae2010-12-22 09:40:45 -050075static const char erase_seq[] = "\b \b"; /* erase sequence */
76static const char tab_seq[] = " "; /* used to expand TABs */
wdenkc6097192002-11-03 00:24:07 +000077
78#ifdef CONFIG_BOOT_RETRY_TIME
79static uint64_t endtime = 0; /* must be set, default is instant timeout */
80static int retry_time = -1; /* -1 so can call readline before main_loop */
81#endif
82
83#define endtick(seconds) (get_ticks() + (uint64_t)(seconds) * get_tbclk())
84
85#ifndef CONFIG_BOOT_RETRY_MIN
86#define CONFIG_BOOT_RETRY_MIN CONFIG_BOOT_RETRY_TIME
87#endif
88
89#ifdef CONFIG_MODEM_SUPPORT
90int do_mdm_init = 0;
91extern void mdm_init(void); /* defined in board.c */
92#endif
93
94/***************************************************************************
95 * Watch for 'delay' seconds for autoboot stop or autoboot delay string.
Jason Hobbsc8a20792011-08-31 05:37:24 +000096 * returns: 0 - no key string, allow autoboot 1 - got key string, abort
wdenkc6097192002-11-03 00:24:07 +000097 */
98#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
99# if defined(CONFIG_AUTOBOOT_KEYED)
Jason Hobbsb41bc5a2011-08-23 11:06:50 +0000100#ifndef CONFIG_MENU
101static inline
102#endif
103int abortboot(int bootdelay)
wdenkc6097192002-11-03 00:24:07 +0000104{
105 int abort = 0;
106 uint64_t etime = endtick(bootdelay);
Wolfgang Denk19973b62006-10-28 00:38:39 +0200107 struct {
wdenkc6097192002-11-03 00:24:07 +0000108 char* str;
109 u_int len;
110 int retry;
111 }
Wolfgang Denk19973b62006-10-28 00:38:39 +0200112 delaykey [] = {
wdenkc6097192002-11-03 00:24:07 +0000113 { str: getenv ("bootdelaykey"), retry: 1 },
114 { str: getenv ("bootdelaykey2"), retry: 1 },
115 { str: getenv ("bootstopkey"), retry: 0 },
116 { str: getenv ("bootstopkey2"), retry: 0 },
117 };
118
119 char presskey [MAX_DELAY_STOP_STR];
120 u_int presskey_len = 0;
121 u_int presskey_max = 0;
122 u_int i;
123
Dirk Eibacha5aae0a2012-04-26 01:49:33 +0000124#ifndef CONFIG_ZERO_BOOTDELAY_CHECK
125 if (bootdelay == 0)
126 return 0;
127#endif
128
wdenkc6097192002-11-03 00:24:07 +0000129# ifdef CONFIG_AUTOBOOT_PROMPT
Stefan Roesef2302d42008-08-06 14:05:38 +0200130 printf(CONFIG_AUTOBOOT_PROMPT);
wdenkc6097192002-11-03 00:24:07 +0000131# endif
132
133# ifdef CONFIG_AUTOBOOT_DELAY_STR
134 if (delaykey[0].str == NULL)
135 delaykey[0].str = CONFIG_AUTOBOOT_DELAY_STR;
136# endif
137# ifdef CONFIG_AUTOBOOT_DELAY_STR2
138 if (delaykey[1].str == NULL)
139 delaykey[1].str = CONFIG_AUTOBOOT_DELAY_STR2;
140# endif
141# ifdef CONFIG_AUTOBOOT_STOP_STR
142 if (delaykey[2].str == NULL)
143 delaykey[2].str = CONFIG_AUTOBOOT_STOP_STR;
144# endif
145# ifdef CONFIG_AUTOBOOT_STOP_STR2
146 if (delaykey[3].str == NULL)
147 delaykey[3].str = CONFIG_AUTOBOOT_STOP_STR2;
148# endif
149
150 for (i = 0; i < sizeof(delaykey) / sizeof(delaykey[0]); i ++) {
151 delaykey[i].len = delaykey[i].str == NULL ?
152 0 : strlen (delaykey[i].str);
153 delaykey[i].len = delaykey[i].len > MAX_DELAY_STOP_STR ?
154 MAX_DELAY_STOP_STR : delaykey[i].len;
155
156 presskey_max = presskey_max > delaykey[i].len ?
157 presskey_max : delaykey[i].len;
158
159# if DEBUG_BOOTKEYS
160 printf("%s key:<%s>\n",
161 delaykey[i].retry ? "delay" : "stop",
162 delaykey[i].str ? delaykey[i].str : "NULL");
163# endif
164 }
165
166 /* In order to keep up with incoming data, check timeout only
167 * when catch up.
168 */
Peter Korsgaardc3284b02008-12-10 16:24:16 +0100169 do {
170 if (tstc()) {
171 if (presskey_len < presskey_max) {
172 presskey [presskey_len ++] = getc();
173 }
174 else {
175 for (i = 0; i < presskey_max - 1; i ++)
176 presskey [i] = presskey [i + 1];
177
178 presskey [i] = getc();
179 }
180 }
181
wdenkc6097192002-11-03 00:24:07 +0000182 for (i = 0; i < sizeof(delaykey) / sizeof(delaykey[0]); i ++) {
183 if (delaykey[i].len > 0 &&
184 presskey_len >= delaykey[i].len &&
185 memcmp (presskey + presskey_len - delaykey[i].len,
wdenk8bde7f72003-06-27 21:31:46 +0000186 delaykey[i].str,
wdenkc6097192002-11-03 00:24:07 +0000187 delaykey[i].len) == 0) {
188# if DEBUG_BOOTKEYS
189 printf("got %skey\n",
190 delaykey[i].retry ? "delay" : "stop");
191# endif
192
193# ifdef CONFIG_BOOT_RETRY_TIME
194 /* don't retry auto boot */
195 if (! delaykey[i].retry)
196 retry_time = -1;
197# endif
198 abort = 1;
199 }
200 }
Peter Korsgaardc3284b02008-12-10 16:24:16 +0100201 } while (!abort && get_ticks() <= etime);
wdenkc6097192002-11-03 00:24:07 +0000202
wdenkc6097192002-11-03 00:24:07 +0000203# if DEBUG_BOOTKEYS
204 if (!abort)
Ladislav Michlada4d402007-04-25 16:01:26 +0200205 puts("key timeout\n");
wdenkc6097192002-11-03 00:24:07 +0000206# endif
207
dzu8cb81432003-10-24 13:14:45 +0000208#ifdef CONFIG_SILENT_CONSOLE
Ladislav Michl4ec5bd52007-04-25 16:01:26 +0200209 if (abort)
210 gd->flags &= ~GD_FLG_SILENT;
dzu8cb81432003-10-24 13:14:45 +0000211#endif
212
wdenkc6097192002-11-03 00:24:07 +0000213 return abort;
214}
215
216# else /* !defined(CONFIG_AUTOBOOT_KEYED) */
217
wdenkc7de8292002-11-19 11:04:11 +0000218#ifdef CONFIG_MENUKEY
219static int menukey = 0;
220#endif
221
Jason Hobbsb41bc5a2011-08-23 11:06:50 +0000222#ifndef CONFIG_MENU
223static inline
224#endif
225int abortboot(int bootdelay)
wdenkc6097192002-11-03 00:24:07 +0000226{
227 int abort = 0;
228
wdenkc7de8292002-11-19 11:04:11 +0000229#ifdef CONFIG_MENUPROMPT
Stefan Roesef2302d42008-08-06 14:05:38 +0200230 printf(CONFIG_MENUPROMPT);
wdenkc7de8292002-11-19 11:04:11 +0000231#else
Joe Hershberger93d72122012-08-17 10:53:12 +0000232 if (bootdelay >= 0)
233 printf("Hit any key to stop autoboot: %2d ", bootdelay);
wdenkc7de8292002-11-19 11:04:11 +0000234#endif
wdenkc6097192002-11-03 00:24:07 +0000235
236#if defined CONFIG_ZERO_BOOTDELAY_CHECK
wdenk8bde7f72003-06-27 21:31:46 +0000237 /*
238 * Check if key already pressed
239 * Don't check if bootdelay < 0
240 */
wdenkc6097192002-11-03 00:24:07 +0000241 if (bootdelay >= 0) {
242 if (tstc()) { /* we got a key press */
243 (void) getc(); /* consume input */
wdenk4b9206e2004-03-23 22:14:11 +0000244 puts ("\b\b\b 0");
Ladislav Michl4ec5bd52007-04-25 16:01:26 +0200245 abort = 1; /* don't auto boot */
wdenkc6097192002-11-03 00:24:07 +0000246 }
wdenk8bde7f72003-06-27 21:31:46 +0000247 }
wdenkc6097192002-11-03 00:24:07 +0000248#endif
249
wdenkf72da342003-10-10 10:05:42 +0000250 while ((bootdelay > 0) && (!abort)) {
wdenkc6097192002-11-03 00:24:07 +0000251 int i;
252
253 --bootdelay;
254 /* delay 100 * 10ms */
255 for (i=0; !abort && i<100; ++i) {
256 if (tstc()) { /* we got a key press */
257 abort = 1; /* don't auto boot */
258 bootdelay = 0; /* no more delay */
wdenkc7de8292002-11-19 11:04:11 +0000259# ifdef CONFIG_MENUKEY
260 menukey = getc();
261# else
wdenkc6097192002-11-03 00:24:07 +0000262 (void) getc(); /* consume input */
wdenkc7de8292002-11-19 11:04:11 +0000263# endif
wdenkc6097192002-11-03 00:24:07 +0000264 break;
265 }
Ladislav Michlada4d402007-04-25 16:01:26 +0200266 udelay(10000);
wdenkc6097192002-11-03 00:24:07 +0000267 }
268
Ladislav Michlada4d402007-04-25 16:01:26 +0200269 printf("\b\b\b%2d ", bootdelay);
wdenkc6097192002-11-03 00:24:07 +0000270 }
271
Ladislav Michlada4d402007-04-25 16:01:26 +0200272 putc('\n');
wdenkc6097192002-11-03 00:24:07 +0000273
wdenkf72da342003-10-10 10:05:42 +0000274#ifdef CONFIG_SILENT_CONSOLE
Ladislav Michl4ec5bd52007-04-25 16:01:26 +0200275 if (abort)
276 gd->flags &= ~GD_FLG_SILENT;
wdenkf72da342003-10-10 10:05:42 +0000277#endif
278
wdenkc6097192002-11-03 00:24:07 +0000279 return abort;
280}
281# endif /* CONFIG_AUTOBOOT_KEYED */
282#endif /* CONFIG_BOOTDELAY >= 0 */
283
Doug Anderson67e1ea22012-10-25 16:31:09 +0000284/*
285 * Runs the given boot command securely. Specifically:
286 * - Doesn't run the command with the shell (run_command or parse_string_outer),
287 * since that's a lot of code surface that an attacker might exploit.
288 * Because of this, we don't do any argument parsing--the secure boot command
289 * has to be a full-fledged u-boot command.
290 * - Doesn't check for keypresses before booting, since that could be a
291 * security hole; also disables Ctrl-C.
292 * - Doesn't allow the command to return.
293 *
294 * Upon any failures, this function will drop into an infinite loop after
295 * printing the error message to console.
296 */
297
298#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0) && \
299 defined(CONFIG_OF_CONTROL)
300static void secure_boot_cmd(char *cmd)
301{
302 cmd_tbl_t *cmdtp;
303 int rc;
304
305 if (!cmd) {
306 printf("## Error: Secure boot command not specified\n");
307 goto err;
308 }
309
310 /* Disable Ctrl-C just in case some command is used that checks it. */
311 disable_ctrlc(1);
312
313 /* Find the command directly. */
314 cmdtp = find_cmd(cmd);
315 if (!cmdtp) {
316 printf("## Error: \"%s\" not defined\n", cmd);
317 goto err;
318 }
319
320 /* Run the command, forcing no flags and faking argc and argv. */
321 rc = (cmdtp->cmd)(cmdtp, 0, 1, &cmd);
322
323 /* Shouldn't ever return from boot command. */
324 printf("## Error: \"%s\" returned (code %d)\n", cmd, rc);
325
326err:
327 /*
328 * Not a whole lot to do here. Rebooting won't help much, since we'll
329 * just end up right back here. Just loop.
330 */
331 hang();
332}
333
Simon Glassfcabc242012-10-25 16:31:11 +0000334static void process_fdt_options(const void *blob)
335{
336 ulong addr;
337
338 /* Add an env variable to point to a kernel payload, if available */
339 addr = fdtdec_get_config_int(gd->fdt_blob, "kernel-offset", 0);
340 if (addr)
341 setenv_addr("kernaddr", (void *)(CONFIG_SYS_TEXT_BASE + addr));
342
343 /* Add an env variable to point to a root disk, if available */
344 addr = fdtdec_get_config_int(gd->fdt_blob, "rootdisk-offset", 0);
345 if (addr)
346 setenv_addr("rootaddr", (void *)(CONFIG_SYS_TEXT_BASE + addr));
347}
Doug Anderson67e1ea22012-10-25 16:31:09 +0000348#endif /* CONFIG_OF_CONTROL */
349
350
wdenkc6097192002-11-03 00:24:07 +0000351/****************************************************************************/
352
353void main_loop (void)
354{
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200355#ifndef CONFIG_SYS_HUSH_PARSER
356 static char lastcommand[CONFIG_SYS_CBSIZE] = { 0, };
wdenkc6097192002-11-03 00:24:07 +0000357 int len;
358 int rc = 1;
359 int flag;
360#endif
Che-Liang Chiou224b72e2012-10-25 16:31:07 +0000361#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0) && \
362 defined(CONFIG_OF_CONTROL)
363 char *env;
364#endif
wdenkc6097192002-11-03 00:24:07 +0000365#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
366 char *s;
367 int bootdelay;
368#endif
369#ifdef CONFIG_PREBOOT
370 char *p;
371#endif
wdenkbdccc4f2003-08-05 17:43:17 +0000372#ifdef CONFIG_BOOTCOUNT_LIMIT
373 unsigned long bootcount = 0;
374 unsigned long bootlimit = 0;
375 char *bcs;
376 char bcs_set[16];
377#endif /* CONFIG_BOOTCOUNT_LIMIT */
wdenkc6097192002-11-03 00:24:07 +0000378
wdenkbdccc4f2003-08-05 17:43:17 +0000379#ifdef CONFIG_BOOTCOUNT_LIMIT
380 bootcount = bootcount_load();
381 bootcount++;
382 bootcount_store (bootcount);
383 sprintf (bcs_set, "%lu", bootcount);
384 setenv ("bootcount", bcs_set);
385 bcs = getenv ("bootlimit");
386 bootlimit = bcs ? simple_strtoul (bcs, NULL, 10) : 0;
387#endif /* CONFIG_BOOTCOUNT_LIMIT */
388
wdenkc6097192002-11-03 00:24:07 +0000389#ifdef CONFIG_MODEM_SUPPORT
390 debug ("DEBUG: main_loop: do_mdm_init=%d\n", do_mdm_init);
391 if (do_mdm_init) {
Wolfgang Denk77ddac92005-10-13 16:45:02 +0200392 char *str = strdup(getenv("mdm_cmd"));
wdenkc6097192002-11-03 00:24:07 +0000393 setenv ("preboot", str); /* set or delete definition */
394 if (str != NULL)
395 free (str);
396 mdm_init(); /* wait for modem connection */
397 }
398#endif /* CONFIG_MODEM_SUPPORT */
399
stroese05875972003-04-04 15:44:49 +0000400#ifdef CONFIG_VERSION_VARIABLE
401 {
stroese155cb012003-07-11 08:00:33 +0000402 setenv ("ver", version_string); /* set version variable */
stroese05875972003-04-04 15:44:49 +0000403 }
404#endif /* CONFIG_VERSION_VARIABLE */
405
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200406#ifdef CONFIG_SYS_HUSH_PARSER
wdenkc6097192002-11-03 00:24:07 +0000407 u_boot_hush_start ();
408#endif
409
Heiko Schocher81473f62008-10-15 09:40:28 +0200410#if defined(CONFIG_HUSH_INIT_VAR)
411 hush_init_var ();
412#endif
413
wdenkc6097192002-11-03 00:24:07 +0000414#ifdef CONFIG_PREBOOT
415 if ((p = getenv ("preboot")) != NULL) {
416# ifdef CONFIG_AUTOBOOT_KEYED
417 int prev = disable_ctrlc(1); /* disable Control C checking */
418# endif
419
Simon Glass3a8a02b2012-03-30 21:30:56 +0000420 run_command_list(p, -1, 0);
wdenkc6097192002-11-03 00:24:07 +0000421
422# ifdef CONFIG_AUTOBOOT_KEYED
423 disable_ctrlc(prev); /* restore Control C checking */
424# endif
425 }
426#endif /* CONFIG_PREBOOT */
427
Wolfgang Denk143cd212010-03-11 23:56:03 +0100428#if defined(CONFIG_UPDATE_TFTP)
Andreas Pretzsch8d6b7322011-07-16 05:50:59 +0000429 update_tftp (0UL);
Wolfgang Denk143cd212010-03-11 23:56:03 +0100430#endif /* CONFIG_UPDATE_TFTP */
431
wdenkc6097192002-11-03 00:24:07 +0000432#if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
433 s = getenv ("bootdelay");
434 bootdelay = s ? (int)simple_strtol(s, NULL, 10) : CONFIG_BOOTDELAY;
435
wdenka6c7ad22002-12-03 21:28:10 +0000436 debug ("### main_loop entered: bootdelay=%d\n\n", bootdelay);
wdenkc6097192002-11-03 00:24:07 +0000437
Heiko Schocher317d6c52012-01-16 21:13:35 +0000438#if defined(CONFIG_MENU_SHOW)
439 bootdelay = menu_show(bootdelay);
440#endif
wdenkc6097192002-11-03 00:24:07 +0000441# ifdef CONFIG_BOOT_RETRY_TIME
wdenk6dd652f2003-06-19 23:40:20 +0000442 init_cmd_timeout ();
wdenkc6097192002-11-03 00:24:07 +0000443# endif /* CONFIG_BOOT_RETRY_TIME */
444
Yuri Tikhonovb428f6a2008-02-04 14:11:03 +0100445#ifdef CONFIG_POST
446 if (gd->flags & GD_FLG_POSTFAIL) {
447 s = getenv("failbootcmd");
448 }
449 else
450#endif /* CONFIG_POST */
wdenkbdccc4f2003-08-05 17:43:17 +0000451#ifdef CONFIG_BOOTCOUNT_LIMIT
452 if (bootlimit && (bootcount > bootlimit)) {
453 printf ("Warning: Bootlimit (%u) exceeded. Using altbootcmd.\n",
454 (unsigned)bootlimit);
455 s = getenv ("altbootcmd");
456 }
457 else
458#endif /* CONFIG_BOOTCOUNT_LIMIT */
459 s = getenv ("bootcmd");
Che-Liang Chiou224b72e2012-10-25 16:31:07 +0000460#ifdef CONFIG_OF_CONTROL
461 /* Allow the fdt to override the boot command */
462 env = fdtdec_get_config_string(gd->fdt_blob, "bootcmd");
463 if (env)
464 s = env;
Doug Anderson67e1ea22012-10-25 16:31:09 +0000465
Simon Glassfcabc242012-10-25 16:31:11 +0000466 process_fdt_options(gd->fdt_blob);
467
Doug Anderson67e1ea22012-10-25 16:31:09 +0000468 /*
469 * If the bootsecure option was chosen, use secure_boot_cmd().
470 * Always use 'env' in this case, since bootsecure requres that the
471 * bootcmd was specified in the FDT too.
472 */
473 if (fdtdec_get_config_int(gd->fdt_blob, "bootsecure", 0))
474 secure_boot_cmd(env);
475
Che-Liang Chiou224b72e2012-10-25 16:31:07 +0000476#endif /* CONFIG_OF_CONTROL */
wdenka6c7ad22002-12-03 21:28:10 +0000477
478 debug ("### main_loop: bootcmd=\"%s\"\n", s ? s : "<UNDEFINED>");
479
Joe Hershberger93d72122012-08-17 10:53:12 +0000480 if (bootdelay != -1 && s && !abortboot(bootdelay)) {
wdenkc6097192002-11-03 00:24:07 +0000481# ifdef CONFIG_AUTOBOOT_KEYED
482 int prev = disable_ctrlc(1); /* disable Control C checking */
483# endif
484
Simon Glass3a8a02b2012-03-30 21:30:56 +0000485 run_command_list(s, -1, 0);
wdenkc6097192002-11-03 00:24:07 +0000486
487# ifdef CONFIG_AUTOBOOT_KEYED
488 disable_ctrlc(prev); /* restore Control C checking */
489# endif
490 }
wdenkc7de8292002-11-19 11:04:11 +0000491
492# ifdef CONFIG_MENUKEY
wdenka6c7ad22002-12-03 21:28:10 +0000493 if (menukey == CONFIG_MENUKEY) {
Jason Hobbs370d1e32011-06-23 08:27:30 +0000494 s = getenv("menucmd");
Jason Hobbsc8a20792011-08-31 05:37:24 +0000495 if (s)
Simon Glass3a8a02b2012-03-30 21:30:56 +0000496 run_command_list(s, -1, 0);
wdenkc7de8292002-11-19 11:04:11 +0000497 }
498#endif /* CONFIG_MENUKEY */
Wolfgang Denk953b7e62010-06-13 18:28:54 +0200499#endif /* CONFIG_BOOTDELAY */
wdenkc7de8292002-11-19 11:04:11 +0000500
Gabe Black3b734592012-10-25 16:31:08 +0000501#if defined CONFIG_OF_CONTROL
502 set_working_fdt_addr((void *)gd->fdt_blob);
503#endif /* CONFIG_OF_CONTROL */
504
wdenkc6097192002-11-03 00:24:07 +0000505 /*
506 * Main Loop for Monitor Command Processing
507 */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200508#ifdef CONFIG_SYS_HUSH_PARSER
wdenkc6097192002-11-03 00:24:07 +0000509 parse_file_outer();
510 /* This point is never reached */
511 for (;;);
512#else
513 for (;;) {
514#ifdef CONFIG_BOOT_RETRY_TIME
515 if (rc >= 0) {
516 /* Saw enough of a valid command to
517 * restart the timeout.
518 */
519 reset_cmd_timeout();
520 }
521#endif
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200522 len = readline (CONFIG_SYS_PROMPT);
wdenkc6097192002-11-03 00:24:07 +0000523
524 flag = 0; /* assume no special flags for now */
525 if (len > 0)
526 strcpy (lastcommand, console_buffer);
527 else if (len == 0)
528 flag |= CMD_FLAG_REPEAT;
529#ifdef CONFIG_BOOT_RETRY_TIME
530 else if (len == -2) {
531 /* -2 means timed out, retry autoboot
532 */
wdenk4b9206e2004-03-23 22:14:11 +0000533 puts ("\nTimed out waiting for command\n");
wdenkc6097192002-11-03 00:24:07 +0000534# ifdef CONFIG_RESET_TO_RETRY
535 /* Reinit board to run initialization code again */
536 do_reset (NULL, 0, 0, NULL);
537# else
538 return; /* retry autoboot */
539# endif
540 }
541#endif
542
543 if (len == -1)
wdenk4b9206e2004-03-23 22:14:11 +0000544 puts ("<INTERRUPT>\n");
wdenkc6097192002-11-03 00:24:07 +0000545 else
Simon Glass53071532012-02-14 19:59:21 +0000546 rc = run_command(lastcommand, flag);
wdenkc6097192002-11-03 00:24:07 +0000547
548 if (rc <= 0) {
549 /* invalid command or not repeatable, forget it */
550 lastcommand[0] = 0;
551 }
552 }
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200553#endif /*CONFIG_SYS_HUSH_PARSER*/
wdenkc6097192002-11-03 00:24:07 +0000554}
555
wdenk6dd652f2003-06-19 23:40:20 +0000556#ifdef CONFIG_BOOT_RETRY_TIME
557/***************************************************************************
Wolfgang Denk19973b62006-10-28 00:38:39 +0200558 * initialize command line timeout
wdenk6dd652f2003-06-19 23:40:20 +0000559 */
560void init_cmd_timeout(void)
561{
562 char *s = getenv ("bootretry");
563
564 if (s != NULL)
wdenkb028f712003-12-07 21:39:28 +0000565 retry_time = (int)simple_strtol(s, NULL, 10);
wdenk6dd652f2003-06-19 23:40:20 +0000566 else
567 retry_time = CONFIG_BOOT_RETRY_TIME;
568
569 if (retry_time >= 0 && retry_time < CONFIG_BOOT_RETRY_MIN)
570 retry_time = CONFIG_BOOT_RETRY_MIN;
571}
572
wdenkc6097192002-11-03 00:24:07 +0000573/***************************************************************************
574 * reset command line timeout to retry_time seconds
575 */
wdenkc6097192002-11-03 00:24:07 +0000576void reset_cmd_timeout(void)
577{
578 endtime = endtick(retry_time);
579}
580#endif
581
Wolfgang Denk501090a2006-07-21 11:33:45 +0200582#ifdef CONFIG_CMDLINE_EDITING
583
584/*
585 * cmdline-editing related codes from vivi.
586 * Author: Janghoon Lyu <nandy@mizi.com>
587 */
588
Wolfgang Denk501090a2006-07-21 11:33:45 +0200589#define putnstr(str,n) do { \
Andrew Klossnerdc4b0b32008-07-07 06:41:14 -0700590 printf ("%.*s", (int)n, str); \
Wolfgang Denk501090a2006-07-21 11:33:45 +0200591 } while (0)
Wolfgang Denk501090a2006-07-21 11:33:45 +0200592
593#define CTL_CH(c) ((c) - 'a' + 1)
Wolfgang Denk501090a2006-07-21 11:33:45 +0200594#define CTL_BACKSPACE ('\b')
595#define DEL ((char)255)
596#define DEL7 ((char)127)
597#define CREAD_HIST_CHAR ('!')
598
599#define getcmd_putch(ch) putc(ch)
600#define getcmd_getch() getc()
601#define getcmd_cbeep() getcmd_putch('\a')
602
603#define HIST_MAX 20
Peter Tyser8804ae32010-09-29 13:30:56 -0500604#define HIST_SIZE CONFIG_SYS_CBSIZE
Wolfgang Denk501090a2006-07-21 11:33:45 +0200605
Kim Phillips199adb62012-10-29 13:34:32 +0000606static int hist_max;
607static int hist_add_idx;
Wolfgang Denk501090a2006-07-21 11:33:45 +0200608static int hist_cur = -1;
Kim Phillips199adb62012-10-29 13:34:32 +0000609static unsigned hist_num;
Wolfgang Denk501090a2006-07-21 11:33:45 +0200610
Kim Phillips199adb62012-10-29 13:34:32 +0000611static char *hist_list[HIST_MAX];
612static char hist_lines[HIST_MAX][HIST_SIZE + 1]; /* Save room for NULL */
Wolfgang Denk501090a2006-07-21 11:33:45 +0200613
614#define add_idx_minus_one() ((hist_add_idx == 0) ? hist_max : hist_add_idx-1)
615
616static void hist_init(void)
617{
618 int i;
619
620 hist_max = 0;
621 hist_add_idx = 0;
622 hist_cur = -1;
623 hist_num = 0;
624
625 for (i = 0; i < HIST_MAX; i++) {
626 hist_list[i] = hist_lines[i];
627 hist_list[i][0] = '\0';
628 }
629}
630
631static void cread_add_to_hist(char *line)
632{
633 strcpy(hist_list[hist_add_idx], line);
634
635 if (++hist_add_idx >= HIST_MAX)
636 hist_add_idx = 0;
637
638 if (hist_add_idx > hist_max)
639 hist_max = hist_add_idx;
640
641 hist_num++;
642}
643
644static char* hist_prev(void)
645{
646 char *ret;
647 int old_cur;
648
649 if (hist_cur < 0)
650 return NULL;
651
652 old_cur = hist_cur;
653 if (--hist_cur < 0)
654 hist_cur = hist_max;
655
656 if (hist_cur == hist_add_idx) {
657 hist_cur = old_cur;
658 ret = NULL;
659 } else
660 ret = hist_list[hist_cur];
661
662 return (ret);
663}
664
665static char* hist_next(void)
666{
667 char *ret;
668
669 if (hist_cur < 0)
670 return NULL;
671
672 if (hist_cur == hist_add_idx)
673 return NULL;
674
675 if (++hist_cur > hist_max)
676 hist_cur = 0;
677
678 if (hist_cur == hist_add_idx) {
679 ret = "";
680 } else
681 ret = hist_list[hist_cur];
682
683 return (ret);
684}
685
Stefan Roese3ca91222006-07-27 16:11:19 +0200686#ifndef CONFIG_CMDLINE_EDITING
Wolfgang Denk501090a2006-07-21 11:33:45 +0200687static void cread_print_hist_list(void)
688{
689 int i;
690 unsigned long n;
691
692 n = hist_num - hist_max;
693
694 i = hist_add_idx + 1;
695 while (1) {
696 if (i > hist_max)
697 i = 0;
698 if (i == hist_add_idx)
699 break;
700 printf("%s\n", hist_list[i]);
701 n++;
702 i++;
703 }
704}
Stefan Roese3ca91222006-07-27 16:11:19 +0200705#endif /* CONFIG_CMDLINE_EDITING */
Wolfgang Denk501090a2006-07-21 11:33:45 +0200706
707#define BEGINNING_OF_LINE() { \
708 while (num) { \
709 getcmd_putch(CTL_BACKSPACE); \
710 num--; \
711 } \
712}
713
714#define ERASE_TO_EOL() { \
715 if (num < eol_num) { \
Mike Frysinger8faba482010-07-23 05:28:15 -0400716 printf("%*s", (int)(eol_num - num), ""); \
717 do { \
Wolfgang Denk501090a2006-07-21 11:33:45 +0200718 getcmd_putch(CTL_BACKSPACE); \
Mike Frysinger8faba482010-07-23 05:28:15 -0400719 } while (--eol_num > num); \
Wolfgang Denk501090a2006-07-21 11:33:45 +0200720 } \
721}
722
723#define REFRESH_TO_EOL() { \
724 if (num < eol_num) { \
725 wlen = eol_num - num; \
726 putnstr(buf + num, wlen); \
727 num = eol_num; \
728 } \
729}
730
731static void cread_add_char(char ichar, int insert, unsigned long *num,
732 unsigned long *eol_num, char *buf, unsigned long len)
733{
734 unsigned long wlen;
735
736 /* room ??? */
737 if (insert || *num == *eol_num) {
738 if (*eol_num > len - 1) {
739 getcmd_cbeep();
740 return;
741 }
742 (*eol_num)++;
743 }
744
745 if (insert) {
746 wlen = *eol_num - *num;
747 if (wlen > 1) {
748 memmove(&buf[*num+1], &buf[*num], wlen-1);
749 }
750
751 buf[*num] = ichar;
752 putnstr(buf + *num, wlen);
753 (*num)++;
754 while (--wlen) {
755 getcmd_putch(CTL_BACKSPACE);
756 }
757 } else {
758 /* echo the character */
759 wlen = 1;
760 buf[*num] = ichar;
761 putnstr(buf + *num, wlen);
762 (*num)++;
763 }
764}
765
766static void cread_add_str(char *str, int strsize, int insert, unsigned long *num,
767 unsigned long *eol_num, char *buf, unsigned long len)
768{
769 while (strsize--) {
770 cread_add_char(*str, insert, num, eol_num, buf, len);
771 str++;
772 }
773}
774
Heiko Schocher9c348312012-01-16 21:13:05 +0000775static int cread_line(const char *const prompt, char *buf, unsigned int *len,
776 int timeout)
Wolfgang Denk501090a2006-07-21 11:33:45 +0200777{
778 unsigned long num = 0;
779 unsigned long eol_num = 0;
Wolfgang Denk501090a2006-07-21 11:33:45 +0200780 unsigned long wlen;
781 char ichar;
782 int insert = 1;
783 int esc_len = 0;
Wolfgang Denk501090a2006-07-21 11:33:45 +0200784 char esc_save[8];
Peter Tyserecc55002009-10-25 15:12:54 -0500785 int init_len = strlen(buf);
Heiko Schocher9c348312012-01-16 21:13:05 +0000786 int first = 1;
Peter Tyserecc55002009-10-25 15:12:54 -0500787
788 if (init_len)
789 cread_add_str(buf, init_len, 1, &num, &eol_num, buf, *len);
Wolfgang Denk501090a2006-07-21 11:33:45 +0200790
791 while (1) {
Andreas Engel00ac50e2008-01-09 17:10:56 +0100792#ifdef CONFIG_BOOT_RETRY_TIME
793 while (!tstc()) { /* while no incoming data */
794 if (retry_time >= 0 && get_ticks() > endtime)
795 return (-2); /* timed out */
Jens Scharsig30dc1652010-04-09 19:02:38 +0200796 WATCHDOG_RESET();
Andreas Engel00ac50e2008-01-09 17:10:56 +0100797 }
798#endif
Heiko Schocher9c348312012-01-16 21:13:05 +0000799 if (first && timeout) {
800 uint64_t etime = endtick(timeout);
801
802 while (!tstc()) { /* while no incoming data */
803 if (get_ticks() >= etime)
804 return -2; /* timed out */
805 WATCHDOG_RESET();
806 }
807 first = 0;
808 }
Andreas Engel00ac50e2008-01-09 17:10:56 +0100809
Wolfgang Denk501090a2006-07-21 11:33:45 +0200810 ichar = getcmd_getch();
811
812 if ((ichar == '\n') || (ichar == '\r')) {
Wolfgang Denkdd9f06f2006-07-21 11:34:34 +0200813 putc('\n');
Wolfgang Denk501090a2006-07-21 11:33:45 +0200814 break;
815 }
816
817 /*
818 * handle standard linux xterm esc sequences for arrow key, etc.
819 */
820 if (esc_len != 0) {
821 if (esc_len == 1) {
822 if (ichar == '[') {
823 esc_save[esc_len] = ichar;
824 esc_len = 2;
825 } else {
826 cread_add_str(esc_save, esc_len, insert,
827 &num, &eol_num, buf, *len);
828 esc_len = 0;
829 }
830 continue;
831 }
832
833 switch (ichar) {
834
835 case 'D': /* <- key */
836 ichar = CTL_CH('b');
837 esc_len = 0;
838 break;
839 case 'C': /* -> key */
840 ichar = CTL_CH('f');
841 esc_len = 0;
842 break; /* pass off to ^F handler */
843 case 'H': /* Home key */
844 ichar = CTL_CH('a');
845 esc_len = 0;
846 break; /* pass off to ^A handler */
847 case 'A': /* up arrow */
848 ichar = CTL_CH('p');
849 esc_len = 0;
850 break; /* pass off to ^P handler */
851 case 'B': /* down arrow */
852 ichar = CTL_CH('n');
853 esc_len = 0;
854 break; /* pass off to ^N handler */
855 default:
856 esc_save[esc_len++] = ichar;
857 cread_add_str(esc_save, esc_len, insert,
858 &num, &eol_num, buf, *len);
859 esc_len = 0;
860 continue;
861 }
862 }
863
864 switch (ichar) {
865 case 0x1b:
866 if (esc_len == 0) {
867 esc_save[esc_len] = ichar;
868 esc_len = 1;
869 } else {
Wolfgang Denkdd9f06f2006-07-21 11:34:34 +0200870 puts("impossible condition #876\n");
Wolfgang Denk501090a2006-07-21 11:33:45 +0200871 esc_len = 0;
872 }
873 break;
874
875 case CTL_CH('a'):
876 BEGINNING_OF_LINE();
877 break;
878 case CTL_CH('c'): /* ^C - break */
879 *buf = '\0'; /* discard input */
880 return (-1);
881 case CTL_CH('f'):
882 if (num < eol_num) {
883 getcmd_putch(buf[num]);
884 num++;
885 }
886 break;
887 case CTL_CH('b'):
888 if (num) {
889 getcmd_putch(CTL_BACKSPACE);
890 num--;
891 }
892 break;
893 case CTL_CH('d'):
894 if (num < eol_num) {
895 wlen = eol_num - num - 1;
896 if (wlen) {
897 memmove(&buf[num], &buf[num+1], wlen);
898 putnstr(buf + num, wlen);
899 }
900
901 getcmd_putch(' ');
902 do {
903 getcmd_putch(CTL_BACKSPACE);
904 } while (wlen--);
905 eol_num--;
906 }
907 break;
908 case CTL_CH('k'):
909 ERASE_TO_EOL();
910 break;
911 case CTL_CH('e'):
912 REFRESH_TO_EOL();
913 break;
914 case CTL_CH('o'):
915 insert = !insert;
916 break;
917 case CTL_CH('x'):
Jean-Christophe PLAGNIOL-VILLARD23d0baf2007-12-22 15:52:58 +0100918 case CTL_CH('u'):
Wolfgang Denk501090a2006-07-21 11:33:45 +0200919 BEGINNING_OF_LINE();
920 ERASE_TO_EOL();
921 break;
922 case DEL:
923 case DEL7:
924 case 8:
925 if (num) {
926 wlen = eol_num - num;
927 num--;
928 memmove(&buf[num], &buf[num+1], wlen);
929 getcmd_putch(CTL_BACKSPACE);
930 putnstr(buf + num, wlen);
931 getcmd_putch(' ');
932 do {
933 getcmd_putch(CTL_BACKSPACE);
934 } while (wlen--);
935 eol_num--;
936 }
937 break;
938 case CTL_CH('p'):
939 case CTL_CH('n'):
940 {
941 char * hline;
942
943 esc_len = 0;
944
945 if (ichar == CTL_CH('p'))
946 hline = hist_prev();
947 else
948 hline = hist_next();
949
950 if (!hline) {
951 getcmd_cbeep();
952 continue;
953 }
954
955 /* nuke the current line */
956 /* first, go home */
957 BEGINNING_OF_LINE();
958
959 /* erase to end of line */
960 ERASE_TO_EOL();
961
962 /* copy new line into place and display */
963 strcpy(buf, hline);
964 eol_num = strlen(buf);
965 REFRESH_TO_EOL();
966 continue;
967 }
Jean-Christophe PLAGNIOL-VILLARD23d0baf2007-12-22 15:52:58 +0100968#ifdef CONFIG_AUTO_COMPLETE
969 case '\t': {
970 int num2, col;
971
972 /* do not autocomplete when in the middle */
973 if (num < eol_num) {
974 getcmd_cbeep();
975 break;
976 }
977
978 buf[num] = '\0';
979 col = strlen(prompt) + eol_num;
980 num2 = num;
981 if (cmd_auto_complete(prompt, buf, &num2, &col)) {
982 col = num2 - num;
983 num += col;
984 eol_num += col;
985 }
986 break;
987 }
988#endif
Wolfgang Denk501090a2006-07-21 11:33:45 +0200989 default:
990 cread_add_char(ichar, insert, &num, &eol_num, buf, *len);
991 break;
992 }
993 }
994 *len = eol_num;
995 buf[eol_num] = '\0'; /* lose the newline */
996
997 if (buf[0] && buf[0] != CREAD_HIST_CHAR)
998 cread_add_to_hist(buf);
999 hist_cur = hist_add_idx;
1000
Peter Tyserf9239432009-10-25 15:12:53 -05001001 return 0;
Wolfgang Denk501090a2006-07-21 11:33:45 +02001002}
1003
1004#endif /* CONFIG_CMDLINE_EDITING */
1005
wdenkc6097192002-11-03 00:24:07 +00001006/****************************************************************************/
1007
1008/*
1009 * Prompt for input and read a line.
1010 * If CONFIG_BOOT_RETRY_TIME is defined and retry_time >= 0,
1011 * time out when time goes past endtime (timebase time in ticks).
1012 * Return: number of read characters
1013 * -1 if break
1014 * -2 if timed out
1015 */
1016int readline (const char *const prompt)
1017{
Peter Tyserecc55002009-10-25 15:12:54 -05001018 /*
1019 * If console_buffer isn't 0-length the user will be prompted to modify
1020 * it instead of entering it from scratch as desired.
1021 */
1022 console_buffer[0] = '\0';
1023
Heiko Schocher9c348312012-01-16 21:13:05 +00001024 return readline_into_buffer(prompt, console_buffer, 0);
James Yang6636b622008-01-09 11:17:49 -06001025}
1026
1027
Heiko Schocher9c348312012-01-16 21:13:05 +00001028int readline_into_buffer(const char *const prompt, char *buffer, int timeout)
James Yang6636b622008-01-09 11:17:49 -06001029{
1030 char *p = buffer;
Wolfgang Denk501090a2006-07-21 11:33:45 +02001031#ifdef CONFIG_CMDLINE_EDITING
Peter Tyser8804ae32010-09-29 13:30:56 -05001032 unsigned int len = CONFIG_SYS_CBSIZE;
Stefan Roesed8f961b2006-08-07 15:08:44 +02001033 int rc;
Wolfgang Denk501090a2006-07-21 11:33:45 +02001034 static int initted = 0;
1035
James Yang597f6c22008-05-05 10:22:53 -05001036 /*
1037 * History uses a global array which is not
1038 * writable until after relocation to RAM.
1039 * Revert to non-history version if still
1040 * running from flash.
1041 */
1042 if (gd->flags & GD_FLG_RELOC) {
1043 if (!initted) {
1044 hist_init();
1045 initted = 1;
1046 }
1047
Peter Tysere491a712009-10-25 15:12:52 -05001048 if (prompt)
1049 puts (prompt);
James Yang597f6c22008-05-05 10:22:53 -05001050
Heiko Schocher9c348312012-01-16 21:13:05 +00001051 rc = cread_line(prompt, p, &len, timeout);
James Yang597f6c22008-05-05 10:22:53 -05001052 return rc < 0 ? rc : len;
1053
1054 } else {
1055#endif /* CONFIG_CMDLINE_EDITING */
Kumar Gala0ec59522008-01-10 02:22:05 -06001056 char * p_buf = p;
wdenkc6097192002-11-03 00:24:07 +00001057 int n = 0; /* buffer index */
1058 int plen = 0; /* prompt length */
1059 int col; /* output column cnt */
1060 char c;
1061
1062 /* print prompt */
1063 if (prompt) {
1064 plen = strlen (prompt);
1065 puts (prompt);
1066 }
1067 col = plen;
1068
1069 for (;;) {
1070#ifdef CONFIG_BOOT_RETRY_TIME
1071 while (!tstc()) { /* while no incoming data */
1072 if (retry_time >= 0 && get_ticks() > endtime)
1073 return (-2); /* timed out */
Jens Scharsig30dc1652010-04-09 19:02:38 +02001074 WATCHDOG_RESET();
wdenkc6097192002-11-03 00:24:07 +00001075 }
1076#endif
1077 WATCHDOG_RESET(); /* Trigger watchdog, if needed */
1078
1079#ifdef CONFIG_SHOW_ACTIVITY
1080 while (!tstc()) {
wdenkc6097192002-11-03 00:24:07 +00001081 show_activity(0);
Jens Scharsig30dc1652010-04-09 19:02:38 +02001082 WATCHDOG_RESET();
wdenkc6097192002-11-03 00:24:07 +00001083 }
1084#endif
1085 c = getc();
1086
1087 /*
1088 * Special character handling
1089 */
1090 switch (c) {
1091 case '\r': /* Enter */
1092 case '\n':
1093 *p = '\0';
1094 puts ("\r\n");
James Yang6636b622008-01-09 11:17:49 -06001095 return (p - p_buf);
wdenkc6097192002-11-03 00:24:07 +00001096
wdenk27aa8182004-03-23 22:37:33 +00001097 case '\0': /* nul */
1098 continue;
1099
wdenkc6097192002-11-03 00:24:07 +00001100 case 0x03: /* ^C - break */
James Yang6636b622008-01-09 11:17:49 -06001101 p_buf[0] = '\0'; /* discard input */
wdenkc6097192002-11-03 00:24:07 +00001102 return (-1);
1103
1104 case 0x15: /* ^U - erase line */
1105 while (col > plen) {
1106 puts (erase_seq);
1107 --col;
1108 }
James Yang6636b622008-01-09 11:17:49 -06001109 p = p_buf;
wdenkc6097192002-11-03 00:24:07 +00001110 n = 0;
1111 continue;
1112
Wolfgang Denk1636d1c2007-06-22 23:59:00 +02001113 case 0x17: /* ^W - erase word */
James Yang6636b622008-01-09 11:17:49 -06001114 p=delete_char(p_buf, p, &col, &n, plen);
wdenkc6097192002-11-03 00:24:07 +00001115 while ((n > 0) && (*p != ' ')) {
James Yang6636b622008-01-09 11:17:49 -06001116 p=delete_char(p_buf, p, &col, &n, plen);
wdenkc6097192002-11-03 00:24:07 +00001117 }
1118 continue;
1119
1120 case 0x08: /* ^H - backspace */
1121 case 0x7F: /* DEL - backspace */
James Yang6636b622008-01-09 11:17:49 -06001122 p=delete_char(p_buf, p, &col, &n, plen);
wdenkc6097192002-11-03 00:24:07 +00001123 continue;
1124
1125 default:
1126 /*
1127 * Must be a normal character then
1128 */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001129 if (n < CONFIG_SYS_CBSIZE-2) {
wdenkc6097192002-11-03 00:24:07 +00001130 if (c == '\t') { /* expand TABs */
wdenk04a85b32004-04-15 18:22:41 +00001131#ifdef CONFIG_AUTO_COMPLETE
1132 /* if auto completion triggered just continue */
1133 *p = '\0';
1134 if (cmd_auto_complete(prompt, console_buffer, &n, &col)) {
James Yang6636b622008-01-09 11:17:49 -06001135 p = p_buf + n; /* reset */
wdenk04a85b32004-04-15 18:22:41 +00001136 continue;
1137 }
1138#endif
wdenkc6097192002-11-03 00:24:07 +00001139 puts (tab_seq+(col&07));
1140 col += 8 - (col&07);
1141 } else {
1142 ++col; /* echo input */
1143 putc (c);
1144 }
1145 *p++ = c;
1146 ++n;
1147 } else { /* Buffer full */
1148 putc ('\a');
1149 }
1150 }
1151 }
James Yang597f6c22008-05-05 10:22:53 -05001152#ifdef CONFIG_CMDLINE_EDITING
1153 }
1154#endif
wdenkc6097192002-11-03 00:24:07 +00001155}
1156
1157/****************************************************************************/
1158
1159static char * delete_char (char *buffer, char *p, int *colp, int *np, int plen)
1160{
1161 char *s;
1162
1163 if (*np == 0) {
1164 return (p);
1165 }
1166
1167 if (*(--p) == '\t') { /* will retype the whole line */
1168 while (*colp > plen) {
1169 puts (erase_seq);
1170 (*colp)--;
1171 }
1172 for (s=buffer; s<p; ++s) {
1173 if (*s == '\t') {
1174 puts (tab_seq+((*colp) & 07));
1175 *colp += 8 - ((*colp) & 07);
1176 } else {
1177 ++(*colp);
1178 putc (*s);
1179 }
1180 }
1181 } else {
1182 puts (erase_seq);
1183 (*colp)--;
1184 }
1185 (*np)--;
1186 return (p);
1187}
1188
1189/****************************************************************************/
1190
1191int parse_line (char *line, char *argv[])
1192{
1193 int nargs = 0;
1194
1195#ifdef DEBUG_PARSER
1196 printf ("parse_line: \"%s\"\n", line);
1197#endif
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001198 while (nargs < CONFIG_SYS_MAXARGS) {
wdenkc6097192002-11-03 00:24:07 +00001199
1200 /* skip any white space */
Jason Hobbs4d91a6e2011-08-23 11:06:54 +00001201 while (isblank(*line))
wdenkc6097192002-11-03 00:24:07 +00001202 ++line;
wdenkc6097192002-11-03 00:24:07 +00001203
1204 if (*line == '\0') { /* end of line, no more args */
1205 argv[nargs] = NULL;
1206#ifdef DEBUG_PARSER
1207 printf ("parse_line: nargs=%d\n", nargs);
1208#endif
1209 return (nargs);
1210 }
1211
1212 argv[nargs++] = line; /* begin of argument string */
1213
1214 /* find end of string */
Jason Hobbs4d91a6e2011-08-23 11:06:54 +00001215 while (*line && !isblank(*line))
wdenkc6097192002-11-03 00:24:07 +00001216 ++line;
wdenkc6097192002-11-03 00:24:07 +00001217
1218 if (*line == '\0') { /* end of line, no more args */
1219 argv[nargs] = NULL;
1220#ifdef DEBUG_PARSER
1221 printf ("parse_line: nargs=%d\n", nargs);
1222#endif
1223 return (nargs);
1224 }
1225
1226 *line++ = '\0'; /* terminate current arg */
1227 }
1228
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001229 printf ("** Too many args (max. %d) **\n", CONFIG_SYS_MAXARGS);
wdenkc6097192002-11-03 00:24:07 +00001230
1231#ifdef DEBUG_PARSER
1232 printf ("parse_line: nargs=%d\n", nargs);
1233#endif
1234 return (nargs);
1235}
1236
1237/****************************************************************************/
1238
Simon Glass7fed89e2012-02-14 19:59:22 +00001239#ifndef CONFIG_SYS_HUSH_PARSER
wdenkc6097192002-11-03 00:24:07 +00001240static void process_macros (const char *input, char *output)
1241{
1242 char c, prev;
1243 const char *varname_start = NULL;
Wolfgang Denk19973b62006-10-28 00:38:39 +02001244 int inputcnt = strlen (input);
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001245 int outputcnt = CONFIG_SYS_CBSIZE;
Wolfgang Denk19973b62006-10-28 00:38:39 +02001246 int state = 0; /* 0 = waiting for '$' */
1247
1248 /* 1 = waiting for '(' or '{' */
1249 /* 2 = waiting for ')' or '}' */
1250 /* 3 = waiting for ''' */
wdenkc6097192002-11-03 00:24:07 +00001251#ifdef DEBUG_PARSER
1252 char *output_start = output;
1253
Wolfgang Denk19973b62006-10-28 00:38:39 +02001254 printf ("[PROCESS_MACROS] INPUT len %d: \"%s\"\n", strlen (input),
1255 input);
wdenkc6097192002-11-03 00:24:07 +00001256#endif
1257
Wolfgang Denk19973b62006-10-28 00:38:39 +02001258 prev = '\0'; /* previous character */
wdenkc6097192002-11-03 00:24:07 +00001259
1260 while (inputcnt && outputcnt) {
wdenk8bde7f72003-06-27 21:31:46 +00001261 c = *input++;
Wolfgang Denk19973b62006-10-28 00:38:39 +02001262 inputcnt--;
wdenkc6097192002-11-03 00:24:07 +00001263
Wolfgang Denk19973b62006-10-28 00:38:39 +02001264 if (state != 3) {
1265 /* remove one level of escape characters */
1266 if ((c == '\\') && (prev != '\\')) {
1267 if (inputcnt-- == 0)
1268 break;
1269 prev = c;
1270 c = *input++;
1271 }
wdenka25f8622003-01-02 23:57:29 +00001272 }
wdenkc6097192002-11-03 00:24:07 +00001273
Wolfgang Denk19973b62006-10-28 00:38:39 +02001274 switch (state) {
1275 case 0: /* Waiting for (unescaped) $ */
1276 if ((c == '\'') && (prev != '\\')) {
1277 state = 3;
1278 break;
1279 }
1280 if ((c == '$') && (prev != '\\')) {
1281 state++;
1282 } else {
wdenkc6097192002-11-03 00:24:07 +00001283 *(output++) = c;
1284 outputcnt--;
1285 }
Wolfgang Denk19973b62006-10-28 00:38:39 +02001286 break;
1287 case 1: /* Waiting for ( */
1288 if (c == '(' || c == '{') {
1289 state++;
1290 varname_start = input;
1291 } else {
1292 state = 0;
1293 *(output++) = '$';
1294 outputcnt--;
wdenkc6097192002-11-03 00:24:07 +00001295
Wolfgang Denk19973b62006-10-28 00:38:39 +02001296 if (outputcnt) {
1297 *(output++) = c;
wdenkc6097192002-11-03 00:24:07 +00001298 outputcnt--;
1299 }
Wolfgang Denk19973b62006-10-28 00:38:39 +02001300 }
1301 break;
1302 case 2: /* Waiting for ) */
1303 if (c == ')' || c == '}') {
1304 int i;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001305 char envname[CONFIG_SYS_CBSIZE], *envval;
Wolfgang Denk19973b62006-10-28 00:38:39 +02001306 int envcnt = input - varname_start - 1; /* Varname # of chars */
1307
1308 /* Get the varname */
1309 for (i = 0; i < envcnt; i++) {
1310 envname[i] = varname_start[i];
1311 }
1312 envname[i] = 0;
1313
1314 /* Get its value */
1315 envval = getenv (envname);
1316
1317 /* Copy into the line if it exists */
1318 if (envval != NULL)
1319 while ((*envval) && outputcnt) {
1320 *(output++) = *(envval++);
1321 outputcnt--;
1322 }
1323 /* Look for another '$' */
1324 state = 0;
1325 }
1326 break;
1327 case 3: /* Waiting for ' */
1328 if ((c == '\'') && (prev != '\\')) {
1329 state = 0;
1330 } else {
1331 *(output++) = c;
1332 outputcnt--;
1333 }
1334 break;
wdenkc6097192002-11-03 00:24:07 +00001335 }
Wolfgang Denk19973b62006-10-28 00:38:39 +02001336 prev = c;
wdenkc6097192002-11-03 00:24:07 +00001337 }
1338
1339 if (outputcnt)
1340 *output = 0;
Bartlomiej Sieka9160b962007-05-27 17:04:18 +02001341 else
1342 *(output - 1) = 0;
wdenkc6097192002-11-03 00:24:07 +00001343
1344#ifdef DEBUG_PARSER
1345 printf ("[PROCESS_MACROS] OUTPUT len %d: \"%s\"\n",
Wolfgang Denk19973b62006-10-28 00:38:39 +02001346 strlen (output_start), output_start);
wdenkc6097192002-11-03 00:24:07 +00001347#endif
1348}
1349
1350/****************************************************************************
1351 * returns:
1352 * 1 - command executed, repeatable
1353 * 0 - command executed but not repeatable, interrupted commands are
1354 * always considered not repeatable
1355 * -1 - not executed (unrecognized, bootd recursion or too many args)
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001356 * (If cmd is NULL or "" or longer than CONFIG_SYS_CBSIZE-1 it is
wdenkc6097192002-11-03 00:24:07 +00001357 * considered unrecognized)
1358 *
1359 * WARNING:
1360 *
1361 * We must create a temporary copy of the command since the command we get
1362 * may be the result from getenv(), which returns a pointer directly to
1363 * the environment data, which may change magicly when the command we run
1364 * creates or modifies environment variables (like "bootp" does).
1365 */
Simon Glass53071532012-02-14 19:59:21 +00001366static int builtin_run_command(const char *cmd, int flag)
wdenkc6097192002-11-03 00:24:07 +00001367{
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001368 char cmdbuf[CONFIG_SYS_CBSIZE]; /* working copy of cmd */
wdenkc6097192002-11-03 00:24:07 +00001369 char *token; /* start of token in cmdbuf */
1370 char *sep; /* end of token (separator) in cmdbuf */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001371 char finaltoken[CONFIG_SYS_CBSIZE];
wdenkc6097192002-11-03 00:24:07 +00001372 char *str = cmdbuf;
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001373 char *argv[CONFIG_SYS_MAXARGS + 1]; /* NULL terminated */
wdenkf07771c2003-05-28 08:06:31 +00001374 int argc, inquotes;
wdenkc6097192002-11-03 00:24:07 +00001375 int repeatable = 1;
wdenkf07771c2003-05-28 08:06:31 +00001376 int rc = 0;
wdenkc6097192002-11-03 00:24:07 +00001377
1378#ifdef DEBUG_PARSER
1379 printf ("[RUN_COMMAND] cmd[%p]=\"", cmd);
1380 puts (cmd ? cmd : "NULL"); /* use puts - string may be loooong */
1381 puts ("\"\n");
1382#endif
1383
1384 clear_ctrlc(); /* forget any previous Control C */
1385
1386 if (!cmd || !*cmd) {
1387 return -1; /* empty command */
1388 }
1389
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +02001390 if (strlen(cmd) >= CONFIG_SYS_CBSIZE) {
wdenkc6097192002-11-03 00:24:07 +00001391 puts ("## Command too long!\n");
1392 return -1;
1393 }
1394
1395 strcpy (cmdbuf, cmd);
1396
1397 /* Process separators and check for invalid
1398 * repeatable commands
1399 */
1400
1401#ifdef DEBUG_PARSER
1402 printf ("[PROCESS_SEPARATORS] %s\n", cmd);
1403#endif
1404 while (*str) {
1405
1406 /*
1407 * Find separator, or string end
1408 * Allow simple escape of ';' by writing "\;"
1409 */
wdenka25f8622003-01-02 23:57:29 +00001410 for (inquotes = 0, sep = str; *sep; sep++) {
1411 if ((*sep=='\'') &&
1412 (*(sep-1) != '\\'))
1413 inquotes=!inquotes;
1414
1415 if (!inquotes &&
1416 (*sep == ';') && /* separator */
wdenkc6097192002-11-03 00:24:07 +00001417 ( sep != str) && /* past string start */
1418 (*(sep-1) != '\\')) /* and NOT escaped */
1419 break;
1420 }
1421
1422 /*
1423 * Limit the token to data between separators
1424 */
1425 token = str;
1426 if (*sep) {
1427 str = sep + 1; /* start of command for next pass */
1428 *sep = '\0';
1429 }
1430 else
1431 str = sep; /* no more commands for next pass */
1432#ifdef DEBUG_PARSER
1433 printf ("token: \"%s\"\n", token);
1434#endif
1435
1436 /* find macros in this token and replace them */
1437 process_macros (token, finaltoken);
1438
1439 /* Extract arguments */
Wolfgang Denk1264b402006-03-12 02:20:55 +01001440 if ((argc = parse_line (finaltoken, argv)) == 0) {
1441 rc = -1; /* no command at all */
1442 continue;
1443 }
wdenkc6097192002-11-03 00:24:07 +00001444
Timo Ketola030fca52012-04-22 23:57:27 +00001445 if (cmd_process(flag, argc, argv, &repeatable))
1446 rc = -1;
wdenkc6097192002-11-03 00:24:07 +00001447
1448 /* Did the user stop this? */
1449 if (had_ctrlc ())
Detlev Zundel5afb2022007-05-23 18:47:48 +02001450 return -1; /* if stopped then not repeatable */
wdenkc6097192002-11-03 00:24:07 +00001451 }
1452
wdenkf07771c2003-05-28 08:06:31 +00001453 return rc ? rc : repeatable;
wdenkc6097192002-11-03 00:24:07 +00001454}
Simon Glass7fed89e2012-02-14 19:59:22 +00001455#endif
wdenkc6097192002-11-03 00:24:07 +00001456
Simon Glass53071532012-02-14 19:59:21 +00001457/*
1458 * Run a command using the selected parser.
1459 *
1460 * @param cmd Command to run
1461 * @param flag Execution flags (CMD_FLAG_...)
1462 * @return 0 on success, or != 0 on error.
1463 */
1464int run_command(const char *cmd, int flag)
1465{
1466#ifndef CONFIG_SYS_HUSH_PARSER
1467 /*
1468 * builtin_run_command can return 0 or 1 for success, so clean up
1469 * its result.
1470 */
1471 if (builtin_run_command(cmd, flag) == -1)
1472 return 1;
1473
1474 return 0;
1475#else
1476 return parse_string_outer(cmd,
1477 FLAG_PARSE_SEMICOLON | FLAG_EXIT_FROM_LOOP);
1478#endif
1479}
1480
Simon Glassd51004a2012-03-30 21:30:55 +00001481#ifndef CONFIG_SYS_HUSH_PARSER
1482/**
1483 * Execute a list of command separated by ; or \n using the built-in parser.
1484 *
1485 * This function cannot take a const char * for the command, since if it
1486 * finds newlines in the string, it replaces them with \0.
1487 *
1488 * @param cmd String containing list of commands
1489 * @param flag Execution flags (CMD_FLAG_...)
1490 * @return 0 on success, or != 0 on error.
1491 */
1492static int builtin_run_command_list(char *cmd, int flag)
1493{
1494 char *line, *next;
1495 int rcode = 0;
1496
1497 /*
1498 * Break into individual lines, and execute each line; terminate on
1499 * error.
1500 */
1501 line = next = cmd;
1502 while (*next) {
1503 if (*next == '\n') {
1504 *next = '\0';
1505 /* run only non-empty commands */
1506 if (*line) {
1507 debug("** exec: \"%s\"\n", line);
1508 if (builtin_run_command(line, 0) < 0) {
1509 rcode = 1;
1510 break;
1511 }
1512 }
1513 line = next + 1;
1514 }
1515 ++next;
1516 }
1517 if (rcode == 0 && *line)
1518 rcode = (builtin_run_command(line, 0) >= 0);
1519
1520 return rcode;
1521}
1522#endif
1523
1524int run_command_list(const char *cmd, int len, int flag)
1525{
1526 int need_buff = 1;
1527 char *buff = (char *)cmd; /* cast away const */
1528 int rcode = 0;
1529
1530 if (len == -1) {
1531 len = strlen(cmd);
1532#ifdef CONFIG_SYS_HUSH_PARSER
1533 /* hush will never change our string */
1534 need_buff = 0;
1535#else
1536 /* the built-in parser will change our string if it sees \n */
1537 need_buff = strchr(cmd, '\n') != NULL;
1538#endif
1539 }
1540 if (need_buff) {
1541 buff = malloc(len + 1);
1542 if (!buff)
1543 return 1;
1544 memcpy(buff, cmd, len);
1545 buff[len] = '\0';
1546 }
1547#ifdef CONFIG_SYS_HUSH_PARSER
1548 rcode = parse_string_outer(buff, FLAG_PARSE_SEMICOLON);
1549#else
1550 /*
1551 * This function will overwrite any \n it sees with a \0, which
1552 * is why it can't work with a const char *. Here we are making
1553 * using of internal knowledge of this function, to avoid always
1554 * doing a malloc() which is actually required only in a case that
1555 * is pretty rare.
1556 */
1557 rcode = builtin_run_command_list(buff, flag);
1558 if (need_buff)
1559 free(buff);
1560#endif
1561
1562 return rcode;
1563}
1564
wdenkc6097192002-11-03 00:24:07 +00001565/****************************************************************************/
1566
Jon Loeligerc3517f92007-07-08 18:10:08 -05001567#if defined(CONFIG_CMD_RUN)
Wolfgang Denk54841ab2010-06-28 22:00:46 +02001568int do_run (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
wdenkc6097192002-11-03 00:24:07 +00001569{
1570 int i;
wdenkc6097192002-11-03 00:24:07 +00001571
Wolfgang Denk47e26b12010-07-17 01:06:04 +02001572 if (argc < 2)
Simon Glass4c12eeb2011-12-10 08:44:01 +00001573 return CMD_RET_USAGE;
wdenkc6097192002-11-03 00:24:07 +00001574
1575 for (i=1; i<argc; ++i) {
wdenk3e386912003-04-05 00:53:31 +00001576 char *arg;
1577
1578 if ((arg = getenv (argv[i])) == NULL) {
1579 printf ("## Error: \"%s\" not defined\n", argv[i]);
1580 return 1;
1581 }
Jason Hobbsc8a20792011-08-31 05:37:24 +00001582
Simon Glass009dde12012-02-14 19:59:20 +00001583 if (run_command(arg, flag) != 0)
wdenk3e386912003-04-05 00:53:31 +00001584 return 1;
wdenkc6097192002-11-03 00:24:07 +00001585 }
wdenk3e386912003-04-05 00:53:31 +00001586 return 0;
wdenkc6097192002-11-03 00:24:07 +00001587}
Jon Loeliger90253172007-07-10 11:02:44 -05001588#endif