Eric Lee / smarc-uboot | Embedian Git Server

Commit 9c3483113de1204118a1b252bf4c81b899dd12b4

Authored by Heiko Schocher 2012-01-17 05:13:05 +0800

Committed by Albert ARIBAUD 2012-02-12 17:11:23 +0800

Exists in master and in 54 other branches

common: add possibility for readline_into_buffer timeout

add possibility to add a timeout when reading a line
into a buffer.

Signed-off-by: Heiko Schocher <hs@denx.de>
Cc: Mike Frysinger <vapier@gentoo.org>
Acked-by: Mike Frysinger <vapier@gentoo.org>

Showing 4 changed files with 21 additions and 7 deletions Inline Diff

common/cmd_nvedit.c
common/main.c
common/menu.c
include/common.h

common/cmd_nvedit.c

Diff comments View file @ 9c34831

1	/*	1	/*
2	* (C) Copyright 2000-2010	2	* (C) Copyright 2000-2010
3	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.	3	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4	*	4	*
5	* (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>	5	* (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
6	* Andreas Heppel <aheppel@sysgo.de>	6	* Andreas Heppel <aheppel@sysgo.de>
7	*	7	*
8	* Copyright 2011 Freescale Semiconductor, Inc.	8	* Copyright 2011 Freescale Semiconductor, Inc.
9	*	9	*
10	* See file CREDITS for list of people who contributed to this	10	* See file CREDITS for list of people who contributed to this
11	* project.	11	* project.
12	*	12	*
13	* This program is free software; you can redistribute it and/or	13	* This program is free software; you can redistribute it and/or
14	* modify it under the terms of the GNU General Public License as	14	* modify it under the terms of the GNU General Public License as
15	* published by the Free Software Foundation; either version 2 of	15	* published by the Free Software Foundation; either version 2 of
16	* the License, or (at your option) any later version.	16	* the License, or (at your option) any later version.
17	*	17	*
18	* This program is distributed in the hope that it will be useful,	18	* This program is distributed in the hope that it will be useful,
19	* but WITHOUT ANY WARRANTY; without even the implied warranty of	19	* but WITHOUT ANY WARRANTY; without even the implied warranty of
20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	20	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21	* GNU General Public License for more details.	21	* GNU General Public License for more details.
22	*	22	*
23	* You should have received a copy of the GNU General Public License	23	* You should have received a copy of the GNU General Public License
24	* along with this program; if not, write to the Free Software	24	* along with this program; if not, write to the Free Software
25	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,	25	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
26	* MA 02111-1307 USA	26	* MA 02111-1307 USA
27	*/	27	*/
28		28
29	/*	29	/*
30	* Support for persistent environment data	30	* Support for persistent environment data
31	*	31	*
32	* The "environment" is stored on external storage as a list of '\0'	32	* The "environment" is stored on external storage as a list of '\0'
33	* terminated "name=value" strings. The end of the list is marked by	33	* terminated "name=value" strings. The end of the list is marked by
34	* a double '\0'. The environment is preceeded by a 32 bit CRC over	34	* a double '\0'. The environment is preceeded by a 32 bit CRC over
35	* the data part and, in case of redundant environment, a byte of	35	* the data part and, in case of redundant environment, a byte of
36	* flags.	36	* flags.
37	*	37	*
38	* This linearized representation will also be used before	38	* This linearized representation will also be used before
39	* relocation, i. e. as long as we don't have a full C runtime	39	* relocation, i. e. as long as we don't have a full C runtime
40	* environment. After that, we use a hash table.	40	* environment. After that, we use a hash table.
41	*/	41	*/
42		42
43	#include <common.h>	43	#include <common.h>
44	#include <command.h>	44	#include <command.h>
45	#include <environment.h>	45	#include <environment.h>
46	#include <search.h>	46	#include <search.h>
47	#include <errno.h>	47	#include <errno.h>
48	#include <malloc.h>	48	#include <malloc.h>
49	#include <watchdog.h>	49	#include <watchdog.h>
50	#include <serial.h>	50	#include <serial.h>
51	#include <linux/stddef.h>	51	#include <linux/stddef.h>
52	#include <asm/byteorder.h>	52	#include <asm/byteorder.h>
53	#if defined(CONFIG_CMD_NET)	53	#if defined(CONFIG_CMD_NET)
54	#include <net.h>	54	#include <net.h>
55	#endif	55	#endif
56		56
57	DECLARE_GLOBAL_DATA_PTR;	57	DECLARE_GLOBAL_DATA_PTR;
58		58
59	#if !defined(CONFIG_ENV_IS_IN_EEPROM) && \	59	#if !defined(CONFIG_ENV_IS_IN_EEPROM) && \
60	!defined(CONFIG_ENV_IS_IN_FLASH) && \	60	!defined(CONFIG_ENV_IS_IN_FLASH) && \
61	!defined(CONFIG_ENV_IS_IN_DATAFLASH) && \	61	!defined(CONFIG_ENV_IS_IN_DATAFLASH) && \
62	!defined(CONFIG_ENV_IS_IN_MG_DISK) && \	62	!defined(CONFIG_ENV_IS_IN_MG_DISK) && \
63	!defined(CONFIG_ENV_IS_IN_MMC) && \	63	!defined(CONFIG_ENV_IS_IN_MMC) && \
64	!defined(CONFIG_ENV_IS_IN_NAND) && \	64	!defined(CONFIG_ENV_IS_IN_NAND) && \
65	!defined(CONFIG_ENV_IS_IN_NVRAM) && \	65	!defined(CONFIG_ENV_IS_IN_NVRAM) && \
66	!defined(CONFIG_ENV_IS_IN_ONENAND) && \	66	!defined(CONFIG_ENV_IS_IN_ONENAND) && \
67	!defined(CONFIG_ENV_IS_IN_SPI_FLASH) && \	67	!defined(CONFIG_ENV_IS_IN_SPI_FLASH) && \
68	!defined(CONFIG_ENV_IS_NOWHERE)	68	!defined(CONFIG_ENV_IS_NOWHERE)
69	# error Define one of CONFIG_ENV_IS_IN_{EEPROM\|FLASH\|DATAFLASH\|ONENAND\|\	69	# error Define one of CONFIG_ENV_IS_IN_{EEPROM\|FLASH\|DATAFLASH\|ONENAND\|\
70	SPI_FLASH\|MG_DISK\|NVRAM\|MMC} or CONFIG_ENV_IS_NOWHERE	70	SPI_FLASH\|MG_DISK\|NVRAM\|MMC} or CONFIG_ENV_IS_NOWHERE
71	#endif	71	#endif
72		72
73	#define XMK_STR(x) #x	73	#define XMK_STR(x) #x
74	#define MK_STR(x) XMK_STR(x)	74	#define MK_STR(x) XMK_STR(x)
75		75
76	/*	76	/*
77	* Maximum expected input data size for import command	77	* Maximum expected input data size for import command
78	*/	78	*/
79	#define MAX_ENV_SIZE (1 << 20) /* 1 MiB */	79	#define MAX_ENV_SIZE (1 << 20) /* 1 MiB */
80		80
81	ulong load_addr = CONFIG_SYS_LOAD_ADDR; /* Default Load Address */	81	ulong load_addr = CONFIG_SYS_LOAD_ADDR; /* Default Load Address */
82	ulong save_addr; /* Default Save Address */	82	ulong save_addr; /* Default Save Address */
83	ulong save_size; /* Default Save Size (in bytes) */	83	ulong save_size; /* Default Save Size (in bytes) */
84		84
85	/*	85	/*
86	* Table with supported baudrates (defined in config_xyz.h)	86	* Table with supported baudrates (defined in config_xyz.h)
87	*/	87	*/
88	static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE;	88	static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE;
89	#define N_BAUDRATES (sizeof(baudrate_table) / sizeof(baudrate_table[0]))	89	#define N_BAUDRATES (sizeof(baudrate_table) / sizeof(baudrate_table[0]))
90		90
91	/*	91	/*
92	* This variable is incremented on each do_env_set(), so it can	92	* This variable is incremented on each do_env_set(), so it can
93	* be used via get_env_id() as an indication, if the environment	93	* be used via get_env_id() as an indication, if the environment
94	* has changed or not. So it is possible to reread an environment	94	* has changed or not. So it is possible to reread an environment
95	* variable only if the environment was changed ... done so for	95	* variable only if the environment was changed ... done so for
96	* example in NetInitLoop()	96	* example in NetInitLoop()
97	*/	97	*/
98	static int env_id = 1;	98	static int env_id = 1;
99		99
100	int get_env_id(void)	100	int get_env_id(void)
101	{	101	{
102	return env_id;	102	return env_id;
103	}	103	}
104		104
105	/*	105	/*
106	* Command interface: print one or all environment variables	106	* Command interface: print one or all environment variables
107	*	107	*
108	* Returns 0 in case of error, or length of printed string	108	* Returns 0 in case of error, or length of printed string
109	*/	109	*/
110	static int env_print(char *name)	110	static int env_print(char *name)
111	{	111	{
112	char *res = NULL;	112	char *res = NULL;
113	size_t len;	113	size_t len;
114		114
115	if (name) { /* print a single name */	115	if (name) { /* print a single name */
116	ENTRY e, *ep;	116	ENTRY e, *ep;
117		117
118	e.key = name;	118	e.key = name;
119	e.data = NULL;	119	e.data = NULL;
120	hsearch_r(e, FIND, &ep, &env_htab);	120	hsearch_r(e, FIND, &ep, &env_htab);
121	if (ep == NULL)	121	if (ep == NULL)
122	return 0;	122	return 0;
123	len = printf("%s=%s\n", ep->key, ep->data);	123	len = printf("%s=%s\n", ep->key, ep->data);
124	return len;	124	return len;
125	}	125	}
126		126
127	/* print whole list */	127	/* print whole list */
128	len = hexport_r(&env_htab, '\n', &res, 0, 0, NULL);	128	len = hexport_r(&env_htab, '\n', &res, 0, 0, NULL);
129		129
130	if (len > 0) {	130	if (len > 0) {
131	puts(res);	131	puts(res);
132	free(res);	132	free(res);
133	return len;	133	return len;
134	}	134	}
135		135
136	/* should never happen */	136	/* should never happen */
137	return 0;	137	return 0;
138	}	138	}
139		139
140	int do_env_print (cmd_tbl_t cmdtp, int flag, int argc, char const argv[])	140	int do_env_print (cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
141	{	141	{
142	int i;	142	int i;
143	int rcode = 0;	143	int rcode = 0;
144		144
145	if (argc == 1) {	145	if (argc == 1) {
146	/* print all env vars */	146	/* print all env vars */
147	rcode = env_print(NULL);	147	rcode = env_print(NULL);
148	if (!rcode)	148	if (!rcode)
149	return 1;	149	return 1;
150	printf("\nEnvironment size: %d/%ld bytes\n",	150	printf("\nEnvironment size: %d/%ld bytes\n",
151	rcode, (ulong)ENV_SIZE);	151	rcode, (ulong)ENV_SIZE);
152	return 0;	152	return 0;
153	}	153	}
154		154
155	/* print selected env vars */	155	/* print selected env vars */
156	for (i = 1; i < argc; ++i) {	156	for (i = 1; i < argc; ++i) {
157	int rc = env_print(argv[i]);	157	int rc = env_print(argv[i]);
158	if (!rc) {	158	if (!rc) {
159	printf("## Error: \"%s\" not defined\n", argv[i]);	159	printf("## Error: \"%s\" not defined\n", argv[i]);
160	++rcode;	160	++rcode;
161	}	161	}
162	}	162	}
163		163
164	return rcode;	164	return rcode;
165	}	165	}
166		166
167	#ifdef CONFIG_CMD_GREPENV	167	#ifdef CONFIG_CMD_GREPENV
168	static int do_env_grep(cmd_tbl_t *cmdtp, int flag,	168	static int do_env_grep(cmd_tbl_t *cmdtp, int flag,
169	int argc, char * const argv[])	169	int argc, char * const argv[])
170	{	170	{
171	ENTRY *match;	171	ENTRY *match;
172	unsigned char matched[env_htab.size / 8];	172	unsigned char matched[env_htab.size / 8];
173	int rcode = 1, arg = 1, idx;	173	int rcode = 1, arg = 1, idx;
174		174
175	if (argc < 2)	175	if (argc < 2)
176	return cmd_usage(cmdtp);	176	return cmd_usage(cmdtp);
177		177
178	memset(matched, 0, env_htab.size / 8);	178	memset(matched, 0, env_htab.size / 8);
179		179
180	while (arg <= argc) {	180	while (arg <= argc) {
181	idx = 0;	181	idx = 0;
182	while ((idx = hstrstr_r(argv[arg], idx, &match, &env_htab))) {	182	while ((idx = hstrstr_r(argv[arg], idx, &match, &env_htab))) {
183	if (!(matched[idx / 8] & (1 << (idx & 7)))) {	183	if (!(matched[idx / 8] & (1 << (idx & 7)))) {
184	puts(match->key);	184	puts(match->key);
185	puts("=");	185	puts("=");
186	puts(match->data);	186	puts(match->data);
187	puts("\n");	187	puts("\n");
188	}	188	}
189	matched[idx / 8] \|= 1 << (idx & 7);	189	matched[idx / 8] \|= 1 << (idx & 7);
190	rcode = 0;	190	rcode = 0;
191	}	191	}
192	arg++;	192	arg++;
193	}	193	}
194		194
195	return rcode;	195	return rcode;
196	}	196	}
197	#endif	197	#endif
198		198
199	/*	199	/*
200	* Set a new environment variable,	200	* Set a new environment variable,
201	* or replace or delete an existing one.	201	* or replace or delete an existing one.
202	*/	202	*/
203	int _do_env_set(int flag, int argc, char * const argv[])	203	int _do_env_set(int flag, int argc, char * const argv[])
204	{	204	{
205	bd_t *bd = gd->bd;	205	bd_t *bd = gd->bd;
206	int i, len;	206	int i, len;
207	int console = -1;	207	int console = -1;
208	char name, value, *s;	208	char name, value, *s;
209	ENTRY e, *ep;	209	ENTRY e, *ep;
210		210
211	name = argv[1];	211	name = argv[1];
212		212
213	if (strchr(name, '=')) {	213	if (strchr(name, '=')) {
214	printf("## Error: illegal character '=' in variable name"	214	printf("## Error: illegal character '=' in variable name"
215	"\"%s\"\n", name);	215	"\"%s\"\n", name);
216	return 1;	216	return 1;
217	}	217	}
218		218
219	env_id++;	219	env_id++;
220	/*	220	/*
221	* search if variable with this name already exists	221	* search if variable with this name already exists
222	*/	222	*/
223	e.key = name;	223	e.key = name;
224	e.data = NULL;	224	e.data = NULL;
225	hsearch_r(e, FIND, &ep, &env_htab);	225	hsearch_r(e, FIND, &ep, &env_htab);
226		226
227	/* Check for console redirection */	227	/* Check for console redirection */
228	if (strcmp(name, "stdin") == 0)	228	if (strcmp(name, "stdin") == 0)
229	console = stdin;	229	console = stdin;
230	else if (strcmp(name, "stdout") == 0)	230	else if (strcmp(name, "stdout") == 0)
231	console = stdout;	231	console = stdout;
232	else if (strcmp(name, "stderr") == 0)	232	else if (strcmp(name, "stderr") == 0)
233	console = stderr;	233	console = stderr;
234		234
235	if (console != -1) {	235	if (console != -1) {
236	if (argc < 3) { /* Cannot delete it! */	236	if (argc < 3) { /* Cannot delete it! */
237	printf("Can't delete \"%s\"\n", name);	237	printf("Can't delete \"%s\"\n", name);
238	return 1;	238	return 1;
239	}	239	}
240		240
241	#ifdef CONFIG_CONSOLE_MUX	241	#ifdef CONFIG_CONSOLE_MUX
242	i = iomux_doenv(console, argv[2]);	242	i = iomux_doenv(console, argv[2]);
243	if (i)	243	if (i)
244	return i;	244	return i;
245	#else	245	#else
246	/* Try assigning specified device */	246	/* Try assigning specified device */
247	if (console_assign(console, argv[2]) < 0)	247	if (console_assign(console, argv[2]) < 0)
248	return 1;	248	return 1;
249		249
250	#ifdef CONFIG_SERIAL_MULTI	250	#ifdef CONFIG_SERIAL_MULTI
251	if (serial_assign(argv[2]) < 0)	251	if (serial_assign(argv[2]) < 0)
252	return 1;	252	return 1;
253	#endif	253	#endif
254	#endif /* CONFIG_CONSOLE_MUX */	254	#endif /* CONFIG_CONSOLE_MUX */
255	}	255	}
256		256
257	/*	257	/*
258	* Some variables like "ethaddr" and "serial#" can be set only	258	* Some variables like "ethaddr" and "serial#" can be set only
259	* once and cannot be deleted; also, "ver" is readonly.	259	* once and cannot be deleted; also, "ver" is readonly.
260	*/	260	*/
261	if (ep) { /* variable exists */	261	if (ep) { /* variable exists */
262	#ifndef CONFIG_ENV_OVERWRITE	262	#ifndef CONFIG_ENV_OVERWRITE
263	if (strcmp(name, "serial#") == 0 \|\|	263	if (strcmp(name, "serial#") == 0 \|\|
264	(strcmp(name, "ethaddr") == 0	264	(strcmp(name, "ethaddr") == 0
265	#if defined(CONFIG_OVERWRITE_ETHADDR_ONCE) && defined(CONFIG_ETHADDR)	265	#if defined(CONFIG_OVERWRITE_ETHADDR_ONCE) && defined(CONFIG_ETHADDR)
266	&& strcmp(ep->data, MK_STR(CONFIG_ETHADDR)) != 0	266	&& strcmp(ep->data, MK_STR(CONFIG_ETHADDR)) != 0
267	#endif /* CONFIG_OVERWRITE_ETHADDR_ONCE && CONFIG_ETHADDR */	267	#endif /* CONFIG_OVERWRITE_ETHADDR_ONCE && CONFIG_ETHADDR */
268	)) {	268	)) {
269	printf("Can't overwrite \"%s\"\n", name);	269	printf("Can't overwrite \"%s\"\n", name);
270	return 1;	270	return 1;
271	}	271	}
272	#endif	272	#endif
273	/*	273	/*
274	* Switch to new baudrate if new baudrate is supported	274	* Switch to new baudrate if new baudrate is supported
275	*/	275	*/
276	if (strcmp(name, "baudrate") == 0) {	276	if (strcmp(name, "baudrate") == 0) {
277	int baudrate = simple_strtoul(argv[2], NULL, 10);	277	int baudrate = simple_strtoul(argv[2], NULL, 10);
278	int i;	278	int i;
279	for (i = 0; i < N_BAUDRATES; ++i) {	279	for (i = 0; i < N_BAUDRATES; ++i) {
280	if (baudrate == baudrate_table[i])	280	if (baudrate == baudrate_table[i])
281	break;	281	break;
282	}	282	}
283	if (i == N_BAUDRATES) {	283	if (i == N_BAUDRATES) {
284	printf("## Baudrate %d bps not supported\n",	284	printf("## Baudrate %d bps not supported\n",
285	baudrate);	285	baudrate);
286	return 1;	286	return 1;
287	}	287	}
288	printf("## Switch baudrate to %d bps and"	288	printf("## Switch baudrate to %d bps and"
289	"press ENTER ...\n", baudrate);	289	"press ENTER ...\n", baudrate);
290	udelay(50000);	290	udelay(50000);
291	gd->baudrate = baudrate;	291	gd->baudrate = baudrate;
292	#if defined(CONFIG_PPC) \|\| defined(CONFIG_MCF52x2)	292	#if defined(CONFIG_PPC) \|\| defined(CONFIG_MCF52x2)
293	gd->bd->bi_baudrate = baudrate;	293	gd->bd->bi_baudrate = baudrate;
294	#endif	294	#endif
295		295
296	serial_setbrg();	296	serial_setbrg();
297	udelay(50000);	297	udelay(50000);
298	while (getc() != '\r')	298	while (getc() != '\r')
299	;	299	;
300	}	300	}
301	}	301	}
302		302
303	/* Delete only ? */	303	/* Delete only ? */
304	if (argc < 3 \|\| argv[2] == NULL) {	304	if (argc < 3 \|\| argv[2] == NULL) {
305	int rc = hdelete_r(name, &env_htab);	305	int rc = hdelete_r(name, &env_htab);
306	return !rc;	306	return !rc;
307	}	307	}
308		308
309	/*	309	/*
310	* Insert / replace new value	310	* Insert / replace new value
311	*/	311	*/
312	for (i = 2, len = 0; i < argc; ++i)	312	for (i = 2, len = 0; i < argc; ++i)
313	len += strlen(argv[i]) + 1;	313	len += strlen(argv[i]) + 1;
314		314
315	value = malloc(len);	315	value = malloc(len);
316	if (value == NULL) {	316	if (value == NULL) {
317	printf("## Can't malloc %d bytes\n", len);	317	printf("## Can't malloc %d bytes\n", len);
318	return 1;	318	return 1;
319	}	319	}
320	for (i = 2, s = value; i < argc; ++i) {	320	for (i = 2, s = value; i < argc; ++i) {
321	char *v = argv[i];	321	char *v = argv[i];
322		322
323	while ((s++ = v++) != '\0')	323	while ((s++ = v++) != '\0')
324	;	324	;
325	*(s - 1) = ' ';	325	*(s - 1) = ' ';
326	}	326	}
327	if (s != value)	327	if (s != value)
328	*--s = '\0';	328	*--s = '\0';
329		329
330	e.key = name;	330	e.key = name;
331	e.data = value;	331	e.data = value;
332	hsearch_r(e, ENTER, &ep, &env_htab);	332	hsearch_r(e, ENTER, &ep, &env_htab);
333	free(value);	333	free(value);
334	if (!ep) {	334	if (!ep) {
335	printf("## Error inserting \"%s\" variable, errno=%d\n",	335	printf("## Error inserting \"%s\" variable, errno=%d\n",
336	name, errno);	336	name, errno);
337	return 1;	337	return 1;
338	}	338	}
339		339
340	/*	340	/*
341	* Some variables should be updated when the corresponding	341	* Some variables should be updated when the corresponding
342	* entry in the environment is changed	342	* entry in the environment is changed
343	*/	343	*/
344	if (strcmp(name, "ipaddr") == 0) {	344	if (strcmp(name, "ipaddr") == 0) {
345	char s = argv[2]; / always use only one arg */	345	char s = argv[2]; / always use only one arg */
346	char *e;	346	char *e;
347	unsigned long addr;	347	unsigned long addr;
348	bd->bi_ip_addr = 0;	348	bd->bi_ip_addr = 0;
349	for (addr = 0, i = 0; i < 4; ++i) {	349	for (addr = 0, i = 0; i < 4; ++i) {
350	ulong val = s ? simple_strtoul(s, &e, 10) : 0;	350	ulong val = s ? simple_strtoul(s, &e, 10) : 0;
351	addr <<= 8;	351	addr <<= 8;
352	addr \|= val & 0xFF;	352	addr \|= val & 0xFF;
353	if (s)	353	if (s)
354	s = *e ? e + 1 : e;	354	s = *e ? e + 1 : e;
355	}	355	}
356	bd->bi_ip_addr = htonl(addr);	356	bd->bi_ip_addr = htonl(addr);
357	return 0;	357	return 0;
358	} else if (strcmp(argv[1], "loadaddr") == 0) {	358	} else if (strcmp(argv[1], "loadaddr") == 0) {
359	load_addr = simple_strtoul(argv[2], NULL, 16);	359	load_addr = simple_strtoul(argv[2], NULL, 16);
360	return 0;	360	return 0;
361	}	361	}
362	#if defined(CONFIG_CMD_NET)	362	#if defined(CONFIG_CMD_NET)
363	else if (strcmp(argv[1], "bootfile") == 0) {	363	else if (strcmp(argv[1], "bootfile") == 0) {
364	copy_filename(BootFile, argv[2], sizeof(BootFile));	364	copy_filename(BootFile, argv[2], sizeof(BootFile));
365	return 0;	365	return 0;
366	}	366	}
367	#endif	367	#endif
368	return 0;	368	return 0;
369	}	369	}
370		370
371	int setenv(const char varname, const char varvalue)	371	int setenv(const char varname, const char varvalue)
372	{	372	{
373	const char * const argv[4] = { "setenv", varname, varvalue, NULL };	373	const char * const argv[4] = { "setenv", varname, varvalue, NULL };
374		374
375	if (varvalue == NULL \|\| varvalue[0] == '\0')	375	if (varvalue == NULL \|\| varvalue[0] == '\0')
376	return _do_env_set(0, 2, (char * const *)argv);	376	return _do_env_set(0, 2, (char * const *)argv);
377	else	377	else
378	return _do_env_set(0, 3, (char * const *)argv);	378	return _do_env_set(0, 3, (char * const *)argv);
379	}	379	}
380		380
381	/**	381	/**
382	* Set an environment variable to an integer value	382	* Set an environment variable to an integer value
383	*	383	*
384	* @param varname Environmet variable to set	384	* @param varname Environmet variable to set
385	* @param value Value to set it to	385	* @param value Value to set it to
386	* @return 0 if ok, 1 on error	386	* @return 0 if ok, 1 on error
387	*/	387	*/
388	int setenv_ulong(const char *varname, ulong value)	388	int setenv_ulong(const char *varname, ulong value)
389	{	389	{
390	/* TODO: this should be unsigned */	390	/* TODO: this should be unsigned */
391	char *str = simple_itoa(value);	391	char *str = simple_itoa(value);
392		392
393	return setenv(varname, str);	393	return setenv(varname, str);
394	}	394	}
395		395
396	/**	396	/**
397	* Set an environment variable to an address in hex	397	* Set an environment variable to an address in hex
398	*	398	*
399	* @param varname Environmet variable to set	399	* @param varname Environmet variable to set
400	* @param addr Value to set it to	400	* @param addr Value to set it to
401	* @return 0 if ok, 1 on error	401	* @return 0 if ok, 1 on error
402	*/	402	*/
403	int setenv_addr(const char varname, const void addr)	403	int setenv_addr(const char varname, const void addr)
404	{	404	{
405	char str[17];	405	char str[17];
406		406
407	sprintf(str, "%lx", (uintptr_t)addr);	407	sprintf(str, "%lx", (uintptr_t)addr);
408	return setenv(varname, str);	408	return setenv(varname, str);
409	}	409	}
410		410
411	int do_env_set(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])	411	int do_env_set(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
412	{	412	{
413	if (argc < 2)	413	if (argc < 2)
414	return cmd_usage(cmdtp);	414	return cmd_usage(cmdtp);
415		415
416	return _do_env_set(flag, argc, argv);	416	return _do_env_set(flag, argc, argv);
417	}	417	}
418		418
419	/*	419	/*
420	* Prompt for environment variable	420	* Prompt for environment variable
421	*/	421	*/
422	#if defined(CONFIG_CMD_ASKENV)	422	#if defined(CONFIG_CMD_ASKENV)
423	int do_env_ask(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])	423	int do_env_ask(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
424	{	424	{
425	char message[CONFIG_SYS_CBSIZE];	425	char message[CONFIG_SYS_CBSIZE];
426	int size = CONFIG_SYS_CBSIZE - 1;	426	int size = CONFIG_SYS_CBSIZE - 1;
427	int i, len, pos;	427	int i, len, pos;
428	char *local_args[4];	428	char *local_args[4];
429		429
430	local_args[0] = argv[0];	430	local_args[0] = argv[0];
431	local_args[1] = argv[1];	431	local_args[1] = argv[1];
432	local_args[2] = NULL;	432	local_args[2] = NULL;
433	local_args[3] = NULL;	433	local_args[3] = NULL;
434		434
435	/* Check the syntax */	435	/* Check the syntax */
436	switch (argc) {	436	switch (argc) {
437	case 1:	437	case 1:
438	return cmd_usage(cmdtp);	438	return cmd_usage(cmdtp);
439		439
440	case 2: /* env_ask envname */	440	case 2: /* env_ask envname */
441	sprintf(message, "Please enter '%s':", argv[1]);	441	sprintf(message, "Please enter '%s':", argv[1]);
442	break;	442	break;
443		443
444	case 3: /* env_ask envname size */	444	case 3: /* env_ask envname size */
445	sprintf(message, "Please enter '%s':", argv[1]);	445	sprintf(message, "Please enter '%s':", argv[1]);
446	size = simple_strtoul(argv[2], NULL, 10);	446	size = simple_strtoul(argv[2], NULL, 10);
447	break;	447	break;
448		448
449	default: /* env_ask envname message1 ... messagen size */	449	default: /* env_ask envname message1 ... messagen size */
450	for (i = 2, pos = 0; i < argc - 1; i++) {	450	for (i = 2, pos = 0; i < argc - 1; i++) {
451	if (pos)	451	if (pos)
452	message[pos++] = ' ';	452	message[pos++] = ' ';
453		453
454	strcpy(message + pos, argv[i]);	454	strcpy(message + pos, argv[i]);
455	pos += strlen(argv[i]);	455	pos += strlen(argv[i]);
456	}	456	}
457		457
458	message[pos] = '\0';	458	message[pos] = '\0';
459	size = simple_strtoul(argv[argc - 1], NULL, 10);	459	size = simple_strtoul(argv[argc - 1], NULL, 10);
460	break;	460	break;
461	}	461	}
462		462
463	if (size >= CONFIG_SYS_CBSIZE)	463	if (size >= CONFIG_SYS_CBSIZE)
464	size = CONFIG_SYS_CBSIZE - 1;	464	size = CONFIG_SYS_CBSIZE - 1;
465		465
466	if (size <= 0)	466	if (size <= 0)
467	return 1;	467	return 1;
468		468
469	/* prompt for input */	469	/* prompt for input */
470	len = readline(message);	470	len = readline(message);
471		471
472	if (size < len)	472	if (size < len)
473	console_buffer[size] = '\0';	473	console_buffer[size] = '\0';
474		474
475	len = 2;	475	len = 2;
476	if (console_buffer[0] != '\0') {	476	if (console_buffer[0] != '\0') {
477	local_args[2] = console_buffer;	477	local_args[2] = console_buffer;
478	len = 3;	478	len = 3;
479	}	479	}
480		480
481	/* Continue calling setenv code */	481	/* Continue calling setenv code */
482	return _do_env_set(flag, len, local_args);	482	return _do_env_set(flag, len, local_args);
483	}	483	}
484	#endif	484	#endif
485		485
486	/*	486	/*
487	* Interactively edit an environment variable	487	* Interactively edit an environment variable
488	*/	488	*/
489	#if defined(CONFIG_CMD_EDITENV)	489	#if defined(CONFIG_CMD_EDITENV)
490	int do_env_edit(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])	490	int do_env_edit(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
491	{	491	{
492	char buffer[CONFIG_SYS_CBSIZE];	492	char buffer[CONFIG_SYS_CBSIZE];
493	char *init_val;	493	char *init_val;
494		494
495	if (argc < 2)	495	if (argc < 2)
496	return cmd_usage(cmdtp);	496	return cmd_usage(cmdtp);
497		497
498	/* Set read buffer to initial value or empty sting */	498	/* Set read buffer to initial value or empty sting */
499	init_val = getenv(argv[1]);	499	init_val = getenv(argv[1]);
500	if (init_val)	500	if (init_val)
501	sprintf(buffer, "%s", init_val);	501	sprintf(buffer, "%s", init_val);
502	else	502	else
503	buffer[0] = '\0';	503	buffer[0] = '\0';
504		504
505	readline_into_buffer("edit: ", buffer);	505	readline_into_buffer("edit: ", buffer, 0);
506		506
507	return setenv(argv[1], buffer);	507	return setenv(argv[1], buffer);
508	}	508	}
509	#endif /* CONFIG_CMD_EDITENV */	509	#endif /* CONFIG_CMD_EDITENV */
510		510
511	/*	511	/*
512	* Look up variable from environment,	512	* Look up variable from environment,
513	* return address of storage for that variable,	513	* return address of storage for that variable,
514	* or NULL if not found	514	* or NULL if not found
515	*/	515	*/
516	char getenv(const char name)	516	char getenv(const char name)
517	{	517	{
518	if (gd->flags & GD_FLG_ENV_READY) { /* after import into hashtable */	518	if (gd->flags & GD_FLG_ENV_READY) { /* after import into hashtable */
519	ENTRY e, *ep;	519	ENTRY e, *ep;
520		520
521	WATCHDOG_RESET();	521	WATCHDOG_RESET();
522		522
523	e.key = name;	523	e.key = name;
524	e.data = NULL;	524	e.data = NULL;
525	hsearch_r(e, FIND, &ep, &env_htab);	525	hsearch_r(e, FIND, &ep, &env_htab);
526		526
527	return ep ? ep->data : NULL;	527	return ep ? ep->data : NULL;
528	}	528	}
529		529
530	/* restricted capabilities before import */	530	/* restricted capabilities before import */
531	if (getenv_f(name, (char *)(gd->env_buf), sizeof(gd->env_buf)) > 0)	531	if (getenv_f(name, (char *)(gd->env_buf), sizeof(gd->env_buf)) > 0)
532	return (char *)(gd->env_buf);	532	return (char *)(gd->env_buf);
533		533
534	return NULL;	534	return NULL;
535	}	535	}
536		536
537	/*	537	/*
538	* Look up variable from environment for restricted C runtime env.	538	* Look up variable from environment for restricted C runtime env.
539	*/	539	*/
540	int getenv_f(const char name, char buf, unsigned len)	540	int getenv_f(const char name, char buf, unsigned len)
541	{	541	{
542	int i, nxt;	542	int i, nxt;
543		543
544	for (i = 0; env_get_char(i) != '\0'; i = nxt + 1) {	544	for (i = 0; env_get_char(i) != '\0'; i = nxt + 1) {
545	int val, n;	545	int val, n;
546		546
547	for (nxt = i; env_get_char(nxt) != '\0'; ++nxt) {	547	for (nxt = i; env_get_char(nxt) != '\0'; ++nxt) {
548	if (nxt >= CONFIG_ENV_SIZE)	548	if (nxt >= CONFIG_ENV_SIZE)
549	return -1;	549	return -1;
550	}	550	}
551		551
552	val = envmatch((uchar *)name, i);	552	val = envmatch((uchar *)name, i);
553	if (val < 0)	553	if (val < 0)
554	continue;	554	continue;
555		555
556	/* found; copy out */	556	/* found; copy out */
557	for (n = 0; n < len; ++n, ++buf) {	557	for (n = 0; n < len; ++n, ++buf) {
558	*buf = env_get_char(val++);	558	*buf = env_get_char(val++);
559	if (*buf == '\0')	559	if (*buf == '\0')
560	return n;	560	return n;
561	}	561	}
562		562
563	if (n)	563	if (n)
564	*--buf = '\0';	564	*--buf = '\0';
565		565
566	printf("env_buf [%d bytes] too small for value of \"%s\"\n",	566	printf("env_buf [%d bytes] too small for value of \"%s\"\n",
567	len, name);	567	len, name);
568		568
569	return n;	569	return n;
570	}	570	}
571		571
572	return -1;	572	return -1;
573	}	573	}
574		574
575	/**	575	/**
576	* Decode the integer value of an environment variable and return it.	576	* Decode the integer value of an environment variable and return it.
577	*	577	*
578	* @param name Name of environemnt variable	578	* @param name Name of environemnt variable
579	* @param base Number base to use (normally 10, or 16 for hex)	579	* @param base Number base to use (normally 10, or 16 for hex)
580	* @param default_val Default value to return if the variable is not	580	* @param default_val Default value to return if the variable is not
581	* found	581	* found
582	* @return the decoded value, or default_val if not found	582	* @return the decoded value, or default_val if not found
583	*/	583	*/
584	ulong getenv_ulong(const char *name, int base, ulong default_val)	584	ulong getenv_ulong(const char *name, int base, ulong default_val)
585	{	585	{
586	/*	586	/*
587	* We can use getenv() here, even before relocation, since the	587	* We can use getenv() here, even before relocation, since the
588	* environment variable value is an integer and thus short.	588	* environment variable value is an integer and thus short.
589	*/	589	*/
590	const char *str = getenv(name);	590	const char *str = getenv(name);
591		591
592	return str ? simple_strtoul(str, NULL, base) : default_val;	592	return str ? simple_strtoul(str, NULL, base) : default_val;
593	}	593	}
594		594
595	#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE)	595	#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE)
596	int do_env_save(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])	596	int do_env_save(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
597	{	597	{
598	printf("Saving Environment to %s...\n", env_name_spec);	598	printf("Saving Environment to %s...\n", env_name_spec);
599		599
600	return saveenv() ? 1 : 0;	600	return saveenv() ? 1 : 0;
601	}	601	}
602		602
603	U_BOOT_CMD(	603	U_BOOT_CMD(
604	saveenv, 1, 0, do_env_save,	604	saveenv, 1, 0, do_env_save,
605	"save environment variables to persistent storage",	605	"save environment variables to persistent storage",
606	""	606	""
607	);	607	);
608	#endif	608	#endif
609		609
610		610
611	/*	611	/*
612	* Match a name / name=value pair	612	* Match a name / name=value pair
613	*	613	*
614	* s1 is either a simple 'name', or a 'name=value' pair.	614	* s1 is either a simple 'name', or a 'name=value' pair.
615	* i2 is the environment index for a 'name2=value2' pair.	615	* i2 is the environment index for a 'name2=value2' pair.
616	* If the names match, return the index for the value2, else -1.	616	* If the names match, return the index for the value2, else -1.
617	*/	617	*/
618	int envmatch(uchar *s1, int i2)	618	int envmatch(uchar *s1, int i2)
619	{	619	{
620	while (*s1 == env_get_char(i2++))	620	while (*s1 == env_get_char(i2++))
621	if (*s1++ == '=')	621	if (*s1++ == '=')
622	return i2;	622	return i2;
623		623
624	if (*s1 == '\0' && env_get_char(i2-1) == '=')	624	if (*s1 == '\0' && env_get_char(i2-1) == '=')
625	return i2;	625	return i2;
626		626
627	return -1;	627	return -1;
628	}	628	}
629		629
630	static int do_env_default(cmd_tbl_t *cmdtp, int flag,	630	static int do_env_default(cmd_tbl_t *cmdtp, int flag,
631	int argc, char * const argv[])	631	int argc, char * const argv[])
632	{	632	{
633	if (argc != 2 \|\| strcmp(argv[1], "-f") != 0)	633	if (argc != 2 \|\| strcmp(argv[1], "-f") != 0)
634	return cmd_usage(cmdtp);	634	return cmd_usage(cmdtp);
635		635
636	set_default_env("## Resetting to default environment\n");	636	set_default_env("## Resetting to default environment\n");
637	return 0;	637	return 0;
638	}	638	}
639		639
640	static int do_env_delete(cmd_tbl_t *cmdtp, int flag,	640	static int do_env_delete(cmd_tbl_t *cmdtp, int flag,
641	int argc, char * const argv[])	641	int argc, char * const argv[])
642	{	642	{
643	printf("Not implemented yet\n");	643	printf("Not implemented yet\n");
644	return 0;	644	return 0;
645	}	645	}
646		646
647	#ifdef CONFIG_CMD_EXPORTENV	647	#ifdef CONFIG_CMD_EXPORTENV
648	/*	648	/*
649	* env export [-t \| -b \| -c] [-s size] addr [var ...]	649	* env export [-t \| -b \| -c] [-s size] addr [var ...]
650	* -t: export as text format; if size is given, data will be	650	* -t: export as text format; if size is given, data will be
651	* padded with '\0' bytes; if not, one terminating '\0'	651	* padded with '\0' bytes; if not, one terminating '\0'
652	* will be added (which is included in the "filesize"	652	* will be added (which is included in the "filesize"
653	* setting so you can for exmple copy this to flash and	653	* setting so you can for exmple copy this to flash and
654	* keep the termination).	654	* keep the termination).
655	* -b: export as binary format (name=value pairs separated by	655	* -b: export as binary format (name=value pairs separated by
656	* '\0', list end marked by double "\0\0")	656	* '\0', list end marked by double "\0\0")
657	* -c: export as checksum protected environment format as	657	* -c: export as checksum protected environment format as
658	* used for example by "saveenv" command	658	* used for example by "saveenv" command
659	* -s size:	659	* -s size:
660	* size of output buffer	660	* size of output buffer
661	* addr: memory address where environment gets stored	661	* addr: memory address where environment gets stored
662	* var... List of variable names that get included into the	662	* var... List of variable names that get included into the
663	* export. Without arguments, the whole environment gets	663	* export. Without arguments, the whole environment gets
664	* exported.	664	* exported.
665	*	665	*
666	* With "-c" and size is NOT given, then the export command will	666	* With "-c" and size is NOT given, then the export command will
667	* format the data as currently used for the persistent storage,	667	* format the data as currently used for the persistent storage,
668	* i. e. it will use CONFIG_ENV_SECT_SIZE as output block size and	668	* i. e. it will use CONFIG_ENV_SECT_SIZE as output block size and
669	* prepend a valid CRC32 checksum and, in case of resundant	669	* prepend a valid CRC32 checksum and, in case of resundant
670	* environment, a "current" redundancy flag. If size is given, this	670	* environment, a "current" redundancy flag. If size is given, this
671	* value will be used instead of CONFIG_ENV_SECT_SIZE; again, CRC32	671	* value will be used instead of CONFIG_ENV_SECT_SIZE; again, CRC32
672	* checksum and redundancy flag will be inserted.	672	* checksum and redundancy flag will be inserted.
673	*	673	*
674	* With "-b" and "-t", always only the real data (including a	674	* With "-b" and "-t", always only the real data (including a
675	* terminating '\0' byte) will be written; here the optional size	675	* terminating '\0' byte) will be written; here the optional size
676	* argument will be used to make sure not to overflow the user	676	* argument will be used to make sure not to overflow the user
677	* provided buffer; the command will abort if the size is not	677	* provided buffer; the command will abort if the size is not
678	* sufficient. Any remainign space will be '\0' padded.	678	* sufficient. Any remainign space will be '\0' padded.
679	*	679	*
680	* On successful return, the variable "filesize" will be set.	680	* On successful return, the variable "filesize" will be set.
681	* Note that filesize includes the trailing/terminating '\0' byte(s).	681	* Note that filesize includes the trailing/terminating '\0' byte(s).
682	*	682	*
683	* Usage szenario: create a text snapshot/backup of the current settings:	683	* Usage szenario: create a text snapshot/backup of the current settings:
684	*	684	*
685	* => env export -t 100000	685	* => env export -t 100000
686	* => era ${backup_addr} +${filesize}	686	* => era ${backup_addr} +${filesize}
687	* => cp.b 100000 ${backup_addr} ${filesize}	687	* => cp.b 100000 ${backup_addr} ${filesize}
688	*	688	*
689	* Re-import this snapshot, deleting all other settings:	689	* Re-import this snapshot, deleting all other settings:
690	*	690	*
691	* => env import -d -t ${backup_addr}	691	* => env import -d -t ${backup_addr}
692	*/	692	*/
693	static int do_env_export(cmd_tbl_t *cmdtp, int flag,	693	static int do_env_export(cmd_tbl_t *cmdtp, int flag,
694	int argc, char * const argv[])	694	int argc, char * const argv[])
695	{	695	{
696	char buf[32];	696	char buf[32];
697	char addr, cmd, *res;	697	char addr, cmd, *res;
698	size_t size = 0;	698	size_t size = 0;
699	ssize_t len;	699	ssize_t len;
700	env_t *envp;	700	env_t *envp;
701	char sep = '\n';	701	char sep = '\n';
702	int chk = 0;	702	int chk = 0;
703	int fmt = 0;	703	int fmt = 0;
704		704
705	cmd = *argv;	705	cmd = *argv;
706		706
707	while (--argc > 0 && **++argv == '-') {	707	while (--argc > 0 && **++argv == '-') {
708	char arg = argv;	708	char arg = argv;
709	while (*++arg) {	709	while (*++arg) {
710	switch (*arg) {	710	switch (*arg) {
711	case 'b': /* raw binary format */	711	case 'b': /* raw binary format */
712	if (fmt++)	712	if (fmt++)
713	goto sep_err;	713	goto sep_err;
714	sep = '\0';	714	sep = '\0';
715	break;	715	break;
716	case 'c': /* external checksum format */	716	case 'c': /* external checksum format */
717	if (fmt++)	717	if (fmt++)
718	goto sep_err;	718	goto sep_err;
719	sep = '\0';	719	sep = '\0';
720	chk = 1;	720	chk = 1;
721	break;	721	break;
722	case 's': /* size given */	722	case 's': /* size given */
723	if (--argc <= 0)	723	if (--argc <= 0)
724	return cmd_usage(cmdtp);	724	return cmd_usage(cmdtp);
725	size = simple_strtoul(*++argv, NULL, 16);	725	size = simple_strtoul(*++argv, NULL, 16);
726	goto NXTARG;	726	goto NXTARG;
727	case 't': /* text format */	727	case 't': /* text format */
728	if (fmt++)	728	if (fmt++)
729	goto sep_err;	729	goto sep_err;
730	sep = '\n';	730	sep = '\n';
731	break;	731	break;
732	default:	732	default:
733	return cmd_usage(cmdtp);	733	return cmd_usage(cmdtp);
734	}	734	}
735	}	735	}
736	NXTARG: ;	736	NXTARG: ;
737	}	737	}
738		738
739	if (argc < 1)	739	if (argc < 1)
740	return cmd_usage(cmdtp);	740	return cmd_usage(cmdtp);
741		741
742	addr = (char *)simple_strtoul(argv[0], NULL, 16);	742	addr = (char *)simple_strtoul(argv[0], NULL, 16);
743		743
744	if (size)	744	if (size)
745	memset(addr, '\0', size);	745	memset(addr, '\0', size);
746		746
747	argc--;	747	argc--;
748	argv++;	748	argv++;
749		749
750	if (sep) { /* export as text file */	750	if (sep) { /* export as text file */
751	len = hexport_r(&env_htab, sep, &addr, size, argc, argv);	751	len = hexport_r(&env_htab, sep, &addr, size, argc, argv);
752	if (len < 0) {	752	if (len < 0) {
753	error("Cannot export environment: errno = %d\n", errno);	753	error("Cannot export environment: errno = %d\n", errno);
754	return 1;	754	return 1;
755	}	755	}
756	sprintf(buf, "%zX", (size_t)len);	756	sprintf(buf, "%zX", (size_t)len);
757	setenv("filesize", buf);	757	setenv("filesize", buf);
758		758
759	return 0;	759	return 0;
760	}	760	}
761		761
762	envp = (env_t *)addr;	762	envp = (env_t *)addr;
763		763
764	if (chk) /* export as checksum protected block */	764	if (chk) /* export as checksum protected block */
765	res = (char *)envp->data;	765	res = (char *)envp->data;
766	else /* export as raw binary data */	766	else /* export as raw binary data */
767	res = addr;	767	res = addr;
768		768
769	len = hexport_r(&env_htab, '\0', &res, ENV_SIZE, argc, argv);	769	len = hexport_r(&env_htab, '\0', &res, ENV_SIZE, argc, argv);
770	if (len < 0) {	770	if (len < 0) {
771	error("Cannot export environment: errno = %d\n", errno);	771	error("Cannot export environment: errno = %d\n", errno);
772	return 1;	772	return 1;
773	}	773	}
774		774
775	if (chk) {	775	if (chk) {
776	envp->crc = crc32(0, envp->data, ENV_SIZE);	776	envp->crc = crc32(0, envp->data, ENV_SIZE);
777	#ifdef CONFIG_ENV_ADDR_REDUND	777	#ifdef CONFIG_ENV_ADDR_REDUND
778	envp->flags = ACTIVE_FLAG;	778	envp->flags = ACTIVE_FLAG;
779	#endif	779	#endif
780	}	780	}
781	sprintf(buf, "%zX", (size_t)(len + offsetof(env_t, data)));	781	sprintf(buf, "%zX", (size_t)(len + offsetof(env_t, data)));
782	setenv("filesize", buf);	782	setenv("filesize", buf);
783		783
784	return 0;	784	return 0;
785		785
786	sep_err:	786	sep_err:
787	printf("## %s: only one of \"-b\", \"-c\" or \"-t\" allowed\n", cmd);	787	printf("## %s: only one of \"-b\", \"-c\" or \"-t\" allowed\n", cmd);
788	return 1;	788	return 1;
789	}	789	}
790	#endif	790	#endif
791		791
792	#ifdef CONFIG_CMD_IMPORTENV	792	#ifdef CONFIG_CMD_IMPORTENV
793	/*	793	/*
794	* env import [-d] [-t \| -b \| -c] addr [size]	794	* env import [-d] [-t \| -b \| -c] addr [size]
795	* -d: delete existing environment before importing;	795	* -d: delete existing environment before importing;
796	* otherwise overwrite / append to existion definitions	796	* otherwise overwrite / append to existion definitions
797	* -t: assume text format; either "size" must be given or the	797	* -t: assume text format; either "size" must be given or the
798	* text data must be '\0' terminated	798	* text data must be '\0' terminated
799	* -b: assume binary format ('\0' separated, "\0\0" terminated)	799	* -b: assume binary format ('\0' separated, "\0\0" terminated)
800	* -c: assume checksum protected environment format	800	* -c: assume checksum protected environment format
801	* addr: memory address to read from	801	* addr: memory address to read from
802	* size: length of input data; if missing, proper '\0'	802	* size: length of input data; if missing, proper '\0'
803	* termination is mandatory	803	* termination is mandatory
804	*/	804	*/
805	static int do_env_import(cmd_tbl_t *cmdtp, int flag,	805	static int do_env_import(cmd_tbl_t *cmdtp, int flag,
806	int argc, char * const argv[])	806	int argc, char * const argv[])
807	{	807	{
808	char cmd, addr;	808	char cmd, addr;
809	char sep = '\n';	809	char sep = '\n';
810	int chk = 0;	810	int chk = 0;
811	int fmt = 0;	811	int fmt = 0;
812	int del = 0;	812	int del = 0;
813	size_t size;	813	size_t size;
814		814
815	cmd = *argv;	815	cmd = *argv;
816		816
817	while (--argc > 0 && **++argv == '-') {	817	while (--argc > 0 && **++argv == '-') {
818	char arg = argv;	818	char arg = argv;
819	while (*++arg) {	819	while (*++arg) {
820	switch (*arg) {	820	switch (*arg) {
821	case 'b': /* raw binary format */	821	case 'b': /* raw binary format */
822	if (fmt++)	822	if (fmt++)
823	goto sep_err;	823	goto sep_err;
824	sep = '\0';	824	sep = '\0';
825	break;	825	break;
826	case 'c': /* external checksum format */	826	case 'c': /* external checksum format */
827	if (fmt++)	827	if (fmt++)
828	goto sep_err;	828	goto sep_err;
829	sep = '\0';	829	sep = '\0';
830	chk = 1;	830	chk = 1;
831	break;	831	break;
832	case 't': /* text format */	832	case 't': /* text format */
833	if (fmt++)	833	if (fmt++)
834	goto sep_err;	834	goto sep_err;
835	sep = '\n';	835	sep = '\n';
836	break;	836	break;
837	case 'd':	837	case 'd':
838	del = 1;	838	del = 1;
839	break;	839	break;
840	default:	840	default:
841	return cmd_usage(cmdtp);	841	return cmd_usage(cmdtp);
842	}	842	}
843	}	843	}
844	}	844	}
845		845
846	if (argc < 1)	846	if (argc < 1)
847	return cmd_usage(cmdtp);	847	return cmd_usage(cmdtp);
848		848
849	if (!fmt)	849	if (!fmt)
850	printf("## Warning: defaulting to text format\n");	850	printf("## Warning: defaulting to text format\n");
851		851
852	addr = (char *)simple_strtoul(argv[0], NULL, 16);	852	addr = (char *)simple_strtoul(argv[0], NULL, 16);
853		853
854	if (argc == 2) {	854	if (argc == 2) {
855	size = simple_strtoul(argv[1], NULL, 16);	855	size = simple_strtoul(argv[1], NULL, 16);
856	} else {	856	} else {
857	char *s = addr;	857	char *s = addr;
858		858
859	size = 0;	859	size = 0;
860		860
861	while (size < MAX_ENV_SIZE) {	861	while (size < MAX_ENV_SIZE) {
862	if ((s == sep) && ((s+1) == '\0'))	862	if ((s == sep) && ((s+1) == '\0'))
863	break;	863	break;
864	++s;	864	++s;
865	++size;	865	++size;
866	}	866	}
867	if (size == MAX_ENV_SIZE) {	867	if (size == MAX_ENV_SIZE) {
868	printf("## Warning: Input data exceeds %d bytes"	868	printf("## Warning: Input data exceeds %d bytes"
869	" - truncated\n", MAX_ENV_SIZE);	869	" - truncated\n", MAX_ENV_SIZE);
870	}	870	}
871	size += 2;	871	size += 2;
872	printf("## Info: input data size = %zu = 0x%zX\n", size, size);	872	printf("## Info: input data size = %zu = 0x%zX\n", size, size);
873	}	873	}
874		874
875	if (chk) {	875	if (chk) {
876	uint32_t crc;	876	uint32_t crc;
877	env_t ep = (env_t )addr;	877	env_t ep = (env_t )addr;
878		878
879	size -= offsetof(env_t, data);	879	size -= offsetof(env_t, data);
880	memcpy(&crc, &ep->crc, sizeof(crc));	880	memcpy(&crc, &ep->crc, sizeof(crc));
881		881
882	if (crc32(0, ep->data, size) != crc) {	882	if (crc32(0, ep->data, size) != crc) {
883	puts("## Error: bad CRC, import failed\n");	883	puts("## Error: bad CRC, import failed\n");
884	return 1;	884	return 1;
885	}	885	}
886	addr = (char *)ep->data;	886	addr = (char *)ep->data;
887	}	887	}
888		888
889	if (himport_r(&env_htab, addr, size, sep, del ? 0 : H_NOCLEAR) == 0) {	889	if (himport_r(&env_htab, addr, size, sep, del ? 0 : H_NOCLEAR) == 0) {
890	error("Environment import failed: errno = %d\n", errno);	890	error("Environment import failed: errno = %d\n", errno);
891	return 1;	891	return 1;
892	}	892	}
893	gd->flags \|= GD_FLG_ENV_READY;	893	gd->flags \|= GD_FLG_ENV_READY;
894		894
895	return 0;	895	return 0;
896		896
897	sep_err:	897	sep_err:
898	printf("## %s: only one of \"-b\", \"-c\" or \"-t\" allowed\n",	898	printf("## %s: only one of \"-b\", \"-c\" or \"-t\" allowed\n",
899	cmd);	899	cmd);
900	return 1;	900	return 1;
901	}	901	}
902	#endif	902	#endif
903		903
904	/*	904	/*
905	* New command line interface: "env" command with subcommands	905	* New command line interface: "env" command with subcommands
906	*/	906	*/
907	static cmd_tbl_t cmd_env_sub[] = {	907	static cmd_tbl_t cmd_env_sub[] = {
908	#if defined(CONFIG_CMD_ASKENV)	908	#if defined(CONFIG_CMD_ASKENV)
909	U_BOOT_CMD_MKENT(ask, CONFIG_SYS_MAXARGS, 1, do_env_ask, "", ""),	909	U_BOOT_CMD_MKENT(ask, CONFIG_SYS_MAXARGS, 1, do_env_ask, "", ""),
910	#endif	910	#endif
911	U_BOOT_CMD_MKENT(default, 1, 0, do_env_default, "", ""),	911	U_BOOT_CMD_MKENT(default, 1, 0, do_env_default, "", ""),
912	U_BOOT_CMD_MKENT(delete, 2, 0, do_env_delete, "", ""),	912	U_BOOT_CMD_MKENT(delete, 2, 0, do_env_delete, "", ""),
913	#if defined(CONFIG_CMD_EDITENV)	913	#if defined(CONFIG_CMD_EDITENV)
914	U_BOOT_CMD_MKENT(edit, 2, 0, do_env_edit, "", ""),	914	U_BOOT_CMD_MKENT(edit, 2, 0, do_env_edit, "", ""),
915	#endif	915	#endif
916	#if defined(CONFIG_CMD_EXPORTENV)	916	#if defined(CONFIG_CMD_EXPORTENV)
917	U_BOOT_CMD_MKENT(export, 4, 0, do_env_export, "", ""),	917	U_BOOT_CMD_MKENT(export, 4, 0, do_env_export, "", ""),
918	#endif	918	#endif
919	#if defined(CONFIG_CMD_GREPENV)	919	#if defined(CONFIG_CMD_GREPENV)
920	U_BOOT_CMD_MKENT(grep, CONFIG_SYS_MAXARGS, 1, do_env_grep, "", ""),	920	U_BOOT_CMD_MKENT(grep, CONFIG_SYS_MAXARGS, 1, do_env_grep, "", ""),
921	#endif	921	#endif
922	#if defined(CONFIG_CMD_IMPORTENV)	922	#if defined(CONFIG_CMD_IMPORTENV)
923	U_BOOT_CMD_MKENT(import, 5, 0, do_env_import, "", ""),	923	U_BOOT_CMD_MKENT(import, 5, 0, do_env_import, "", ""),
924	#endif	924	#endif
925	U_BOOT_CMD_MKENT(print, CONFIG_SYS_MAXARGS, 1, do_env_print, "", ""),	925	U_BOOT_CMD_MKENT(print, CONFIG_SYS_MAXARGS, 1, do_env_print, "", ""),
926	#if defined(CONFIG_CMD_RUN)	926	#if defined(CONFIG_CMD_RUN)
927	U_BOOT_CMD_MKENT(run, CONFIG_SYS_MAXARGS, 1, do_run, "", ""),	927	U_BOOT_CMD_MKENT(run, CONFIG_SYS_MAXARGS, 1, do_run, "", ""),
928	#endif	928	#endif
929	#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE)	929	#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE)
930	U_BOOT_CMD_MKENT(save, 1, 0, do_env_save, "", ""),	930	U_BOOT_CMD_MKENT(save, 1, 0, do_env_save, "", ""),
931	#endif	931	#endif
932	U_BOOT_CMD_MKENT(set, CONFIG_SYS_MAXARGS, 0, do_env_set, "", ""),	932	U_BOOT_CMD_MKENT(set, CONFIG_SYS_MAXARGS, 0, do_env_set, "", ""),
933	};	933	};
934		934
935	#if defined(CONFIG_NEEDS_MANUAL_RELOC)	935	#if defined(CONFIG_NEEDS_MANUAL_RELOC)
936	void env_reloc(void)	936	void env_reloc(void)
937	{	937	{
938	fixup_cmdtable(cmd_env_sub, ARRAY_SIZE(cmd_env_sub));	938	fixup_cmdtable(cmd_env_sub, ARRAY_SIZE(cmd_env_sub));
939	}	939	}
940	#endif	940	#endif
941		941
942	static int do_env(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])	942	static int do_env(cmd_tbl_t cmdtp, int flag, int argc, char const argv[])
943	{	943	{
944	cmd_tbl_t *cp;	944	cmd_tbl_t *cp;
945		945
946	if (argc < 2)	946	if (argc < 2)
947	return cmd_usage(cmdtp);	947	return cmd_usage(cmdtp);
948		948
949	/* drop initial "env" arg */	949	/* drop initial "env" arg */
950	argc--;	950	argc--;
951	argv++;	951	argv++;
952		952
953	cp = find_cmd_tbl(argv[0], cmd_env_sub, ARRAY_SIZE(cmd_env_sub));	953	cp = find_cmd_tbl(argv[0], cmd_env_sub, ARRAY_SIZE(cmd_env_sub));
954		954
955	if (cp)	955	if (cp)
956	return cp->cmd(cmdtp, flag, argc, argv);	956	return cp->cmd(cmdtp, flag, argc, argv);
957		957
958	return cmd_usage(cmdtp);	958	return cmd_usage(cmdtp);
959	}	959	}
960		960
961	U_BOOT_CMD(	961	U_BOOT_CMD(
962	env, CONFIG_SYS_MAXARGS, 1, do_env,	962	env, CONFIG_SYS_MAXARGS, 1, do_env,
963	"environment handling commands",	963	"environment handling commands",
964	#if defined(CONFIG_CMD_ASKENV)	964	#if defined(CONFIG_CMD_ASKENV)
965	"ask name [message] [size] - ask for environment variable\nenv "	965	"ask name [message] [size] - ask for environment variable\nenv "
966	#endif	966	#endif
967	"default -f - reset default environment\n"	967	"default -f - reset default environment\n"
968	#if defined(CONFIG_CMD_EDITENV)	968	#if defined(CONFIG_CMD_EDITENV)
969	"env edit name - edit environment variable\n"	969	"env edit name - edit environment variable\n"
970	#endif	970	#endif
971	"env export [-t \| -b \| -c] [-s size] addr [var ...] - export environment\n"	971	"env export [-t \| -b \| -c] [-s size] addr [var ...] - export environment\n"
972	#if defined(CONFIG_CMD_GREPENV)	972	#if defined(CONFIG_CMD_GREPENV)
973	"env grep string [...] - search environment\n"	973	"env grep string [...] - search environment\n"
974	#endif	974	#endif
975	"env import [-d] [-t \| -b \| -c] addr [size] - import environment\n"	975	"env import [-d] [-t \| -b \| -c] addr [size] - import environment\n"
976	"env print [name ...] - print environment\n"	976	"env print [name ...] - print environment\n"
977	#if defined(CONFIG_CMD_RUN)	977	#if defined(CONFIG_CMD_RUN)
978	"env run var [...] - run commands in an environment variable\n"	978	"env run var [...] - run commands in an environment variable\n"
979	#endif	979	#endif
980	#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE)	980	#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE)
981	"env save - save environment\n"	981	"env save - save environment\n"
982	#endif	982	#endif
983	"env set [-f] name [arg ...]\n"	983	"env set [-f] name [arg ...]\n"
984	);	984	);
985		985
986	/*	986	/*
987	* Old command line interface, kept for compatibility	987	* Old command line interface, kept for compatibility
988	*/	988	*/
989		989
990	#if defined(CONFIG_CMD_EDITENV)	990	#if defined(CONFIG_CMD_EDITENV)
991	U_BOOT_CMD_COMPLETE(	991	U_BOOT_CMD_COMPLETE(
992	editenv, 2, 0, do_env_edit,	992	editenv, 2, 0, do_env_edit,
993	"edit environment variable",	993	"edit environment variable",
994	"name\n"	994	"name\n"
995	" - edit environment variable 'name'",	995	" - edit environment variable 'name'",
996	var_complete	996	var_complete
997	);	997	);
998	#endif	998	#endif
999		999
1000	U_BOOT_CMD_COMPLETE(	1000	U_BOOT_CMD_COMPLETE(
1001	printenv, CONFIG_SYS_MAXARGS, 1, do_env_print,	1001	printenv, CONFIG_SYS_MAXARGS, 1, do_env_print,
1002	"print environment variables",	1002	"print environment variables",
1003	"\n - print values of all environment variables\n"	1003	"\n - print values of all environment variables\n"
1004	"printenv name ...\n"	1004	"printenv name ...\n"
1005	" - print value of environment variable 'name'",	1005	" - print value of environment variable 'name'",
1006	var_complete	1006	var_complete
1007	);	1007	);
1008		1008
1009	#ifdef CONFIG_CMD_GREPENV	1009	#ifdef CONFIG_CMD_GREPENV
1010	U_BOOT_CMD_COMPLETE(	1010	U_BOOT_CMD_COMPLETE(
1011	grepenv, CONFIG_SYS_MAXARGS, 0, do_env_grep,	1011	grepenv, CONFIG_SYS_MAXARGS, 0, do_env_grep,
1012	"search environment variables",	1012	"search environment variables",
1013	"string ...\n"	1013	"string ...\n"
1014	" - list environment name=value pairs matching 'string'",	1014	" - list environment name=value pairs matching 'string'",
1015	var_complete	1015	var_complete
1016	);	1016	);
1017	#endif	1017	#endif
1018		1018
1019	U_BOOT_CMD_COMPLETE(	1019	U_BOOT_CMD_COMPLETE(
1020	setenv, CONFIG_SYS_MAXARGS, 0, do_env_set,	1020	setenv, CONFIG_SYS_MAXARGS, 0, do_env_set,
1021	"set environment variables",	1021	"set environment variables",
1022	"name value ...\n"	1022	"name value ...\n"
1023	" - set environment variable 'name' to 'value ...'\n"	1023	" - set environment variable 'name' to 'value ...'\n"
1024	"setenv name\n"	1024	"setenv name\n"
1025	" - delete environment variable 'name'",	1025	" - delete environment variable 'name'",
1026	var_complete	1026	var_complete
1027	);	1027	);
1028		1028
1029	#if defined(CONFIG_CMD_ASKENV)	1029	#if defined(CONFIG_CMD_ASKENV)
1030		1030
1031	U_BOOT_CMD(	1031	U_BOOT_CMD(
1032	askenv, CONFIG_SYS_MAXARGS, 1, do_env_ask,	1032	askenv, CONFIG_SYS_MAXARGS, 1, do_env_ask,
1033	"get environment variables from stdin",	1033	"get environment variables from stdin",
1034	"name [message] [size]\n"	1034	"name [message] [size]\n"
1035	" - get environment variable 'name' from stdin (max 'size' chars)\n"	1035	" - get environment variable 'name' from stdin (max 'size' chars)\n"
1036	"askenv name\n"	1036	"askenv name\n"
1037	" - get environment variable 'name' from stdin\n"	1037	" - get environment variable 'name' from stdin\n"
1038	"askenv name size\n"	1038	"askenv name size\n"
1039	" - get environment variable 'name' from stdin (max 'size' chars)\n"	1039	" - get environment variable 'name' from stdin (max 'size' chars)\n"
1040	"askenv name [message] size\n"	1040	"askenv name [message] size\n"
1041	" - display 'message' string and get environment variable 'name'"	1041	" - display 'message' string and get environment variable 'name'"
1042	"from stdin (max 'size' chars)"	1042	"from stdin (max 'size' chars)"
1043	);	1043	);
1044	#endif	1044	#endif
1045		1045
1046	#if defined(CONFIG_CMD_RUN)	1046	#if defined(CONFIG_CMD_RUN)
1047	U_BOOT_CMD_COMPLETE(	1047	U_BOOT_CMD_COMPLETE(
1048	run, CONFIG_SYS_MAXARGS, 1, do_run,	1048	run, CONFIG_SYS_MAXARGS, 1, do_run,
1049	"run commands in an environment variable",	1049	"run commands in an environment variable",
1050	"var [...]\n"	1050	"var [...]\n"
1051	" - run the commands in the environment variable(s) 'var'",	1051	" - run the commands in the environment variable(s) 'var'",
1052	var_complete	1052	var_complete
1053	);	1053	);
1054	#endif	1054	#endif
1055		1055

common/main.c

Diff comments View file @ 9c34831

 /*
  * (C) Copyright 2000
  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  *
  * Add to readline cmdline-editing by
  * (C) Copyright 2005
  * JinHua Luo, GuangDong Linux Center, <luo.jinhua@gd-linux.com>
  *
  * See file CREDITS for list of people who contributed to this
  * project.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  * MA 02111-1307 USA
  */
 /* #define	DEBUG	*/
 #include <common.h>
 #include <watchdog.h>
 #include <command.h>
 #include <version.h>
 #ifdef CONFIG_MODEM_SUPPORT
 #include <malloc.h>		/* for free() prototype */
 #endif
 #ifdef CONFIG_SYS_HUSH_PARSER
 #include <hush.h>
 #endif
 #include <post.h>
 #include <linux/ctype.h>
 #if defined(CONFIG_SILENT_CONSOLE) || defined(CONFIG_POST) || defined(CONFIG_CMDLINE_EDITING)
 DECLARE_GLOBAL_DATA_PTR;
 #endif
 /*
  * Board-specific Platform code can reimplement show_boot_progress () if needed
  */
 void inline __show_boot_progress (int val) {}
 void show_boot_progress (int val) __attribute__((weak, alias("__show_boot_progress")));
 #if defined(CONFIG_UPDATE_TFTP)
 int update_tftp (ulong addr);
 #endif /* CONFIG_UPDATE_TFTP */
 #define MAX_DELAY_STOP_STR 32
 #undef DEBUG_PARSER
 char        console_buffer[CONFIG_SYS_CBSIZE + 1];	/* console I/O buffer	*/
 static char * delete_char (char *buffer, char *p, int *colp, int *np, int plen);
 static const char erase_seq[] = "\b \b";		/* erase sequence	*/
 static const char   tab_seq[] = "        ";		/* used to expand TABs	*/
 #ifdef CONFIG_BOOT_RETRY_TIME
 static uint64_t endtime = 0;  /* must be set, default is instant timeout */
 static int      retry_time = -1; /* -1 so can call readline before main_loop */
 #endif
 #define	endtick(seconds) (get_ticks() + (uint64_t)(seconds) * get_tbclk())
 #ifndef CONFIG_BOOT_RETRY_MIN
 #define CONFIG_BOOT_RETRY_MIN CONFIG_BOOT_RETRY_TIME
 #endif
 #ifdef CONFIG_MODEM_SUPPORT
 int do_mdm_init = 0;
 extern void mdm_init(void); /* defined in board.c */
 #endif
 /***************************************************************************
  * Watch for 'delay' seconds for autoboot stop or autoboot delay string.
  * returns: 0 -  no key string, allow autoboot 1 - got key string, abort
  */
 #if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
 # if defined(CONFIG_AUTOBOOT_KEYED)
 #ifndef CONFIG_MENU
 static inline
 #endif
 int abortboot(int bootdelay)
 {
 	int abort = 0;
 	uint64_t etime = endtick(bootdelay);
 	struct {
 		char* str;
 		u_int len;
 		int retry;
 	}
 	delaykey [] = {
 		{ str: getenv ("bootdelaykey"),  retry: 1 },
 		{ str: getenv ("bootdelaykey2"), retry: 1 },
 		{ str: getenv ("bootstopkey"),   retry: 0 },
 		{ str: getenv ("bootstopkey2"),  retry: 0 },
 	};
 	char presskey [MAX_DELAY_STOP_STR];
 	u_int presskey_len = 0;
 	u_int presskey_max = 0;
 	u_int i;
 #  ifdef CONFIG_AUTOBOOT_PROMPT
 	printf(CONFIG_AUTOBOOT_PROMPT);
 #  endif
 #  ifdef CONFIG_AUTOBOOT_DELAY_STR
 	if (delaykey[0].str == NULL)
 		delaykey[0].str = CONFIG_AUTOBOOT_DELAY_STR;
 #  endif
 #  ifdef CONFIG_AUTOBOOT_DELAY_STR2
 	if (delaykey[1].str == NULL)
 		delaykey[1].str = CONFIG_AUTOBOOT_DELAY_STR2;
 #  endif
 #  ifdef CONFIG_AUTOBOOT_STOP_STR
 	if (delaykey[2].str == NULL)
 		delaykey[2].str = CONFIG_AUTOBOOT_STOP_STR;
 #  endif
 #  ifdef CONFIG_AUTOBOOT_STOP_STR2
 	if (delaykey[3].str == NULL)
 		delaykey[3].str = CONFIG_AUTOBOOT_STOP_STR2;
 #  endif
 	for (i = 0; i < sizeof(delaykey) / sizeof(delaykey[0]); i ++) {
 		delaykey[i].len = delaykey[i].str == NULL ?
 				    0 : strlen (delaykey[i].str);
 		delaykey[i].len = delaykey[i].len > MAX_DELAY_STOP_STR ?
 				    MAX_DELAY_STOP_STR : delaykey[i].len;
 		presskey_max = presskey_max > delaykey[i].len ?
 				    presskey_max : delaykey[i].len;
 #  if DEBUG_BOOTKEYS
 		printf("%s key:<%s>\n",
 		       delaykey[i].retry ? "delay" : "stop",
 		       delaykey[i].str ? delaykey[i].str : "NULL");
 #  endif
 	}
 	/* In order to keep up with incoming data, check timeout only
 	 * when catch up.
 	 */
 	do {
 		if (tstc()) {
 			if (presskey_len < presskey_max) {
 				presskey [presskey_len ++] = getc();
 			}
 			else {
 				for (i = 0; i < presskey_max - 1; i ++)
 					presskey [i] = presskey [i + 1];
 				presskey [i] = getc();
 			}
 		}
 		for (i = 0; i < sizeof(delaykey) / sizeof(delaykey[0]); i ++) {
 			if (delaykey[i].len > 0 &&
 			    presskey_len >= delaykey[i].len &&
 			    memcmp (presskey + presskey_len - delaykey[i].len,
 				    delaykey[i].str,
 				    delaykey[i].len) == 0) {
 #  if DEBUG_BOOTKEYS
 				printf("got %skey\n",
 				       delaykey[i].retry ? "delay" : "stop");
 #  endif
 #  ifdef CONFIG_BOOT_RETRY_TIME
 				/* don't retry auto boot */
 				if (! delaykey[i].retry)
 					retry_time = -1;
 #  endif
 				abort = 1;
 			}
 		}
 	} while (!abort && get_ticks() <= etime);
 #  if DEBUG_BOOTKEYS
 	if (!abort)
 		puts("key timeout\n");
 #  endif
 #ifdef CONFIG_SILENT_CONSOLE
 	if (abort)
 		gd->flags &= ~GD_FLG_SILENT;
 #endif
 	return abort;
 }
 # else	/* !defined(CONFIG_AUTOBOOT_KEYED) */
 #ifdef CONFIG_MENUKEY
 static int menukey = 0;
 #endif
 #ifndef CONFIG_MENU
 static inline
 #endif
 int abortboot(int bootdelay)
 {
 	int abort = 0;
 #ifdef CONFIG_MENUPROMPT
 	printf(CONFIG_MENUPROMPT);
 #else
 	printf("Hit any key to stop autoboot: %2d ", bootdelay);
 #endif
 #if defined CONFIG_ZERO_BOOTDELAY_CHECK
 	/*
 	 * Check if key already pressed
 	 * Don't check if bootdelay < 0
 	 */
 	if (bootdelay >= 0) {
 		if (tstc()) {	/* we got a key press	*/
 			(void) getc();  /* consume input	*/
 			puts ("\b\b\b 0");
 			abort = 1;	/* don't auto boot	*/
 		}
 	}
 #endif
 	while ((bootdelay > 0) && (!abort)) {
 		int i;
 		--bootdelay;
 		/* delay 100 * 10ms */
 		for (i=0; !abort && i<100; ++i) {
 			if (tstc()) {	/* we got a key press	*/
 				abort  = 1;	/* don't auto boot	*/
 				bootdelay = 0;	/* no more delay	*/
 # ifdef CONFIG_MENUKEY
 				menukey = getc();
 # else
 				(void) getc();  /* consume input	*/
 # endif
 				break;
 			}
 			udelay(10000);
 		}
 		printf("\b\b\b%2d ", bootdelay);
 	}
 	putc('\n');
 #ifdef CONFIG_SILENT_CONSOLE
 	if (abort)
 		gd->flags &= ~GD_FLG_SILENT;
 #endif
 	return abort;
 }
 # endif	/* CONFIG_AUTOBOOT_KEYED */
 #endif	/* CONFIG_BOOTDELAY >= 0  */
 /*
  * Return 0 on success, or != 0 on error.
  */
 #ifndef CONFIG_CMD_PXE
 static inline
 #endif
 int run_command2(const char *cmd, int flag)
 {
 #ifndef CONFIG_SYS_HUSH_PARSER
 	/*
 	 * run_command can return 0 or 1 for success, so clean up its result.
 	 */
 	if (run_command(cmd, flag) == -1)
 		return 1;
 	return 0;
 #else
 	return parse_string_outer(cmd,
 			FLAG_PARSE_SEMICOLON | FLAG_EXIT_FROM_LOOP);
 #endif
 }
 /****************************************************************************/
 void main_loop (void)
 {
 #ifndef CONFIG_SYS_HUSH_PARSER
 	static char lastcommand[CONFIG_SYS_CBSIZE] = { 0, };
 	int len;
 	int rc = 1;
 	int flag;
 #endif
 #if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
 	char *s;
 	int bootdelay;
 #endif
 #ifdef CONFIG_PREBOOT
 	char *p;
 #endif
 #ifdef CONFIG_BOOTCOUNT_LIMIT
 	unsigned long bootcount = 0;
 	unsigned long bootlimit = 0;
 	char *bcs;
 	char bcs_set[16];
 #endif /* CONFIG_BOOTCOUNT_LIMIT */
 #ifdef CONFIG_BOOTCOUNT_LIMIT
 	bootcount = bootcount_load();
 	bootcount++;
 	bootcount_store (bootcount);
 	sprintf (bcs_set, "%lu", bootcount);
 	setenv ("bootcount", bcs_set);
 	bcs = getenv ("bootlimit");
 	bootlimit = bcs ? simple_strtoul (bcs, NULL, 10) : 0;
 #endif /* CONFIG_BOOTCOUNT_LIMIT */
 #ifdef CONFIG_MODEM_SUPPORT
 	debug ("DEBUG: main_loop:   do_mdm_init=%d\n", do_mdm_init);
 	if (do_mdm_init) {
 		char *str = strdup(getenv("mdm_cmd"));
 		setenv ("preboot", str);  /* set or delete definition */
 		if (str != NULL)
 			free (str);
 		mdm_init(); /* wait for modem connection */
 	}
 #endif  /* CONFIG_MODEM_SUPPORT */
 #ifdef CONFIG_VERSION_VARIABLE
 	{
 		setenv ("ver", version_string);  /* set version variable */
 	}
 #endif /* CONFIG_VERSION_VARIABLE */
 #ifdef CONFIG_SYS_HUSH_PARSER
 	u_boot_hush_start ();
 #endif
 #if defined(CONFIG_HUSH_INIT_VAR)
 	hush_init_var ();
 #endif
 #ifdef CONFIG_PREBOOT
 	if ((p = getenv ("preboot")) != NULL) {
 # ifdef CONFIG_AUTOBOOT_KEYED
 		int prev = disable_ctrlc(1);	/* disable Control C checking */
 # endif
 		run_command2(p, 0);
 # ifdef CONFIG_AUTOBOOT_KEYED
 		disable_ctrlc(prev);	/* restore Control C checking */
 # endif
 	}
 #endif /* CONFIG_PREBOOT */
 #if defined(CONFIG_UPDATE_TFTP)
 	update_tftp (0UL);
 #endif /* CONFIG_UPDATE_TFTP */
 #if defined(CONFIG_BOOTDELAY) && (CONFIG_BOOTDELAY >= 0)
 	s = getenv ("bootdelay");
 	bootdelay = s ? (int)simple_strtol(s, NULL, 10) : CONFIG_BOOTDELAY;
 	debug ("### main_loop entered: bootdelay=%d\n\n", bootdelay);
 # ifdef CONFIG_BOOT_RETRY_TIME
 	init_cmd_timeout ();
 # endif	/* CONFIG_BOOT_RETRY_TIME */
 #ifdef CONFIG_POST
 	if (gd->flags & GD_FLG_POSTFAIL) {
 		s = getenv("failbootcmd");
 	}
 	else
 #endif /* CONFIG_POST */
 #ifdef CONFIG_BOOTCOUNT_LIMIT
 	if (bootlimit && (bootcount > bootlimit)) {
 		printf ("Warning: Bootlimit (%u) exceeded. Using altbootcmd.\n",
 		        (unsigned)bootlimit);
 		s = getenv ("altbootcmd");
 	}
 	else
 #endif /* CONFIG_BOOTCOUNT_LIMIT */
 		s = getenv ("bootcmd");
 	debug ("### main_loop: bootcmd=\"%s\"\n", s ? s : "<UNDEFINED>");
 	if (bootdelay >= 0 && s && !abortboot (bootdelay)) {
 # ifdef CONFIG_AUTOBOOT_KEYED
 		int prev = disable_ctrlc(1);	/* disable Control C checking */
 # endif
 		run_command2(s, 0);
 # ifdef CONFIG_AUTOBOOT_KEYED
 		disable_ctrlc(prev);	/* restore Control C checking */
 # endif
 	}
 # ifdef CONFIG_MENUKEY
 	if (menukey == CONFIG_MENUKEY) {
 		s = getenv("menucmd");
 		if (s)
 			run_command2(s, 0);
 	}
 #endif /* CONFIG_MENUKEY */
 #endif /* CONFIG_BOOTDELAY */
 	/*
 	 * Main Loop for Monitor Command Processing
 	 */
 #ifdef CONFIG_SYS_HUSH_PARSER
 	parse_file_outer();
 	/* This point is never reached */
 	for (;;);
 #else
 	for (;;) {
 #ifdef CONFIG_BOOT_RETRY_TIME
 		if (rc >= 0) {
 			/* Saw enough of a valid command to
 			 * restart the timeout.
 			 */
 			reset_cmd_timeout();
 		}
 #endif
 		len = readline (CONFIG_SYS_PROMPT);
 		flag = 0;	/* assume no special flags for now */
 		if (len > 0)
 			strcpy (lastcommand, console_buffer);
 		else if (len == 0)
 			flag |= CMD_FLAG_REPEAT;
 #ifdef CONFIG_BOOT_RETRY_TIME
 		else if (len == -2) {
 			/* -2 means timed out, retry autoboot
 			 */
 			puts ("\nTimed out waiting for command\n");
 # ifdef CONFIG_RESET_TO_RETRY
 			/* Reinit board to run initialization code again */
 			do_reset (NULL, 0, 0, NULL);
 # else
 			return;		/* retry autoboot */
 # endif
 		}
 #endif
 		if (len == -1)
 			puts ("<INTERRUPT>\n");
 		else
 			rc = run_command (lastcommand, flag);
 		if (rc <= 0) {
 			/* invalid command or not repeatable, forget it */
 			lastcommand[0] = 0;
 		}
 	}
 #endif /*CONFIG_SYS_HUSH_PARSER*/
 }
 #ifdef CONFIG_BOOT_RETRY_TIME
 /***************************************************************************
  * initialize command line timeout
  */
 void init_cmd_timeout(void)
 {
 	char *s = getenv ("bootretry");
 	if (s != NULL)
 		retry_time = (int)simple_strtol(s, NULL, 10);
 	else
 		retry_time =  CONFIG_BOOT_RETRY_TIME;
 	if (retry_time >= 0 && retry_time < CONFIG_BOOT_RETRY_MIN)
 		retry_time = CONFIG_BOOT_RETRY_MIN;
 }
 /***************************************************************************
  * reset command line timeout to retry_time seconds
  */
 void reset_cmd_timeout(void)
 {
 	endtime = endtick(retry_time);
 }
 #endif
 #ifdef CONFIG_CMDLINE_EDITING
 /*
  * cmdline-editing related codes from vivi.
  * Author: Janghoon Lyu <nandy@mizi.com>
  */
 #define putnstr(str,n)	do {			\
 		printf ("%.*s", (int)n, str);	\
 	} while (0)
 #define CTL_CH(c)		((c) - 'a' + 1)
 #define CTL_BACKSPACE		('\b')
 #define DEL			((char)255)
 #define DEL7			((char)127)
 #define CREAD_HIST_CHAR		('!')
 #define getcmd_putch(ch)	putc(ch)
 #define getcmd_getch()		getc()
 #define getcmd_cbeep()		getcmd_putch('\a')
 #define HIST_MAX		20
 #define HIST_SIZE		CONFIG_SYS_CBSIZE
 static int hist_max = 0;
 static int hist_add_idx = 0;
 static int hist_cur = -1;
 unsigned hist_num = 0;
 char* hist_list[HIST_MAX];
 char hist_lines[HIST_MAX][HIST_SIZE + 1];	 /* Save room for NULL */
 #define add_idx_minus_one() ((hist_add_idx == 0) ? hist_max : hist_add_idx-1)
 static void hist_init(void)
 {
 	int i;
 	hist_max = 0;
 	hist_add_idx = 0;
 	hist_cur = -1;
 	hist_num = 0;
 	for (i = 0; i < HIST_MAX; i++) {
 		hist_list[i] = hist_lines[i];
 		hist_list[i][0] = '\0';
 	}
 }
 static void cread_add_to_hist(char *line)
 {
 	strcpy(hist_list[hist_add_idx], line);
 	if (++hist_add_idx >= HIST_MAX)
 		hist_add_idx = 0;
 	if (hist_add_idx > hist_max)
 		hist_max = hist_add_idx;
 	hist_num++;
 }
 static char* hist_prev(void)
 {
 	char *ret;
 	int old_cur;
 	if (hist_cur < 0)
 		return NULL;
 	old_cur = hist_cur;
 	if (--hist_cur < 0)
 		hist_cur = hist_max;
 	if (hist_cur == hist_add_idx) {
 		hist_cur = old_cur;
 		ret = NULL;
 	} else
 		ret = hist_list[hist_cur];
 	return (ret);
 }
 static char* hist_next(void)
 {
 	char *ret;
 	if (hist_cur < 0)
 		return NULL;
 	if (hist_cur == hist_add_idx)
 		return NULL;
 	if (++hist_cur > hist_max)
 		hist_cur = 0;
 	if (hist_cur == hist_add_idx) {
 		ret = "";
 	} else
 		ret = hist_list[hist_cur];
 	return (ret);
 }
 #ifndef CONFIG_CMDLINE_EDITING
 static void cread_print_hist_list(void)
 {
 	int i;
 	unsigned long n;
 	n = hist_num - hist_max;
 	i = hist_add_idx + 1;
 	while (1) {
 		if (i > hist_max)
 			i = 0;
 		if (i == hist_add_idx)
 			break;
 		printf("%s\n", hist_list[i]);
 		n++;
 		i++;
 	}
 }
 #endif /* CONFIG_CMDLINE_EDITING */
 #define BEGINNING_OF_LINE() {			\
 	while (num) {				\
 		getcmd_putch(CTL_BACKSPACE);	\
 		num--;				\
 	}					\
 }
 #define ERASE_TO_EOL() {				\
 	if (num < eol_num) {				\
 		printf("%*s", (int)(eol_num - num), ""); \
 		do {					\
 			getcmd_putch(CTL_BACKSPACE);	\
 		} while (--eol_num > num);		\
 	}						\
 }
 #define REFRESH_TO_EOL() {			\
 	if (num < eol_num) {			\
 		wlen = eol_num - num;		\
 		putnstr(buf + num, wlen);	\
 		num = eol_num;			\
 	}					\
 }
 static void cread_add_char(char ichar, int insert, unsigned long *num,
 	       unsigned long *eol_num, char *buf, unsigned long len)
 {
 	unsigned long wlen;
 	/* room ??? */
 	if (insert || *num == *eol_num) {
 		if (*eol_num > len - 1) {
 			getcmd_cbeep();
 			return;
 		}
 		(*eol_num)++;
 	}
 	if (insert) {
 		wlen = *eol_num - *num;
 		if (wlen > 1) {
 			memmove(&buf[*num+1], &buf[*num], wlen-1);
 		}
 		buf[*num] = ichar;
 		putnstr(buf + *num, wlen);
 		(*num)++;
 		while (--wlen) {
 			getcmd_putch(CTL_BACKSPACE);
 		}
 	} else {
 		/* echo the character */
 		wlen = 1;
 		buf[*num] = ichar;
 		putnstr(buf + *num, wlen);
 		(*num)++;
 	}
 }
 static void cread_add_str(char *str, int strsize, int insert, unsigned long *num,
 	      unsigned long *eol_num, char *buf, unsigned long len)
 {
 	while (strsize--) {
 		cread_add_char(*str, insert, num, eol_num, buf, len);
 		str++;
 	}
 }
-static int cread_line(const char *const prompt, char *buf, unsigned int *len)
+static int cread_line(const char *const prompt, char *buf, unsigned int *len,
+		int timeout)
 {
 	unsigned long num = 0;
 	unsigned long eol_num = 0;
 	unsigned long wlen;
 	char ichar;
 	int insert = 1;
 	int esc_len = 0;
 	char esc_save[8];
 	int init_len = strlen(buf);
+	int first = 1;
 	if (init_len)
 		cread_add_str(buf, init_len, 1, &num, &eol_num, buf, *len);
 	while (1) {
 #ifdef CONFIG_BOOT_RETRY_TIME
 		while (!tstc()) {	/* while no incoming data */
 			if (retry_time >= 0 && get_ticks() > endtime)
 				return (-2);	/* timed out */
 			WATCHDOG_RESET();
 		}
 #endif
+		if (first && timeout) {
+			uint64_t etime = endtick(timeout);
+			while (!tstc()) {	/* while no incoming data */
+				if (get_ticks() >= etime)
+					return -2;	/* timed out */
+				WATCHDOG_RESET();
+			}
+			first = 0;
+		}
 		ichar = getcmd_getch();
 		if ((ichar == '\n') || (ichar == '\r')) {
 			putc('\n');
 			break;
 		}
 		/*
 		 * handle standard linux xterm esc sequences for arrow key, etc.
 		 */
 		if (esc_len != 0) {
 			if (esc_len == 1) {
 				if (ichar == '[') {
 					esc_save[esc_len] = ichar;
 					esc_len = 2;
 				} else {
 					cread_add_str(esc_save, esc_len, insert,
 						      &num, &eol_num, buf, *len);
 					esc_len = 0;
 				}
 				continue;
 			}
 			switch (ichar) {
 			case 'D':	/* <- key */
 				ichar = CTL_CH('b');
 				esc_len = 0;
 				break;
 			case 'C':	/* -> key */
 				ichar = CTL_CH('f');
 				esc_len = 0;
 				break;	/* pass off to ^F handler */
 			case 'H':	/* Home key */
 				ichar = CTL_CH('a');
 				esc_len = 0;
 				break;	/* pass off to ^A handler */
 			case 'A':	/* up arrow */
 				ichar = CTL_CH('p');
 				esc_len = 0;
 				break;	/* pass off to ^P handler */
 			case 'B':	/* down arrow */
 				ichar = CTL_CH('n');
 				esc_len = 0;
 				break;	/* pass off to ^N handler */
 			default:
 				esc_save[esc_len++] = ichar;
 				cread_add_str(esc_save, esc_len, insert,
 					      &num, &eol_num, buf, *len);
 				esc_len = 0;
 				continue;
 			}
 		}
 		switch (ichar) {
 		case 0x1b:
 			if (esc_len == 0) {
 				esc_save[esc_len] = ichar;
 				esc_len = 1;
 			} else {
 				puts("impossible condition #876\n");
 				esc_len = 0;
 			}
 			break;
 		case CTL_CH('a'):
 			BEGINNING_OF_LINE();
 			break;
 		case CTL_CH('c'):	/* ^C - break */
 			*buf = '\0';	/* discard input */
 			return (-1);
 		case CTL_CH('f'):
 			if (num < eol_num) {
 				getcmd_putch(buf[num]);
 				num++;
 			}
 			break;
 		case CTL_CH('b'):
 			if (num) {
 				getcmd_putch(CTL_BACKSPACE);
 				num--;
 			}
 			break;
 		case CTL_CH('d'):
 			if (num < eol_num) {
 				wlen = eol_num - num - 1;
 				if (wlen) {
 					memmove(&buf[num], &buf[num+1], wlen);
 					putnstr(buf + num, wlen);
 				}
 				getcmd_putch(' ');
 				do {
 					getcmd_putch(CTL_BACKSPACE);
 				} while (wlen--);
 				eol_num--;
 			}
 			break;
 		case CTL_CH('k'):
 			ERASE_TO_EOL();
 			break;
 		case CTL_CH('e'):
 			REFRESH_TO_EOL();
 			break;
 		case CTL_CH('o'):
 			insert = !insert;
 			break;
 		case CTL_CH('x'):
 		case CTL_CH('u'):
 			BEGINNING_OF_LINE();
 			ERASE_TO_EOL();
 			break;
 		case DEL:
 		case DEL7:
 		case 8:
 			if (num) {
 				wlen = eol_num - num;
 				num--;
 				memmove(&buf[num], &buf[num+1], wlen);
 				getcmd_putch(CTL_BACKSPACE);
 				putnstr(buf + num, wlen);
 				getcmd_putch(' ');
 				do {
 					getcmd_putch(CTL_BACKSPACE);
 				} while (wlen--);
 				eol_num--;
 			}
 			break;
 		case CTL_CH('p'):
 		case CTL_CH('n'):
 		{
 			char * hline;
 			esc_len = 0;
 			if (ichar == CTL_CH('p'))
 				hline = hist_prev();
 			else
 				hline = hist_next();
 			if (!hline) {
 				getcmd_cbeep();
 				continue;
 			}
 			/* nuke the current line */
 			/* first, go home */
 			BEGINNING_OF_LINE();
 			/* erase to end of line */
 			ERASE_TO_EOL();
 			/* copy new line into place and display */
 			strcpy(buf, hline);
 			eol_num = strlen(buf);
 			REFRESH_TO_EOL();
 			continue;
 		}
 #ifdef CONFIG_AUTO_COMPLETE
 		case '\t': {
 			int num2, col;
 			/* do not autocomplete when in the middle */
 			if (num < eol_num) {
 				getcmd_cbeep();
 				break;
 			}
 			buf[num] = '\0';
 			col = strlen(prompt) + eol_num;
 			num2 = num;
 			if (cmd_auto_complete(prompt, buf, &num2, &col)) {
 				col = num2 - num;
 				num += col;
 				eol_num += col;
 			}
 			break;
 		}
 #endif
 		default:
 			cread_add_char(ichar, insert, &num, &eol_num, buf, *len);
 			break;
 		}
 	}
 	*len = eol_num;
 	buf[eol_num] = '\0';	/* lose the newline */
 	if (buf[0] && buf[0] != CREAD_HIST_CHAR)
 		cread_add_to_hist(buf);
 	hist_cur = hist_add_idx;
 	return 0;
 }
 #endif /* CONFIG_CMDLINE_EDITING */
 /****************************************************************************/
 /*
  * Prompt for input and read a line.
  * If  CONFIG_BOOT_RETRY_TIME is defined and retry_time >= 0,
  * time out when time goes past endtime (timebase time in ticks).
  * Return:	number of read characters
  *		-1 if break
  *		-2 if timed out
  */
 int readline (const char *const prompt)
 {
 	/*
 	 * If console_buffer isn't 0-length the user will be prompted to modify
 	 * it instead of entering it from scratch as desired.
 	 */
 	console_buffer[0] = '\0';
-	return readline_into_buffer(prompt, console_buffer);
+	return readline_into_buffer(prompt, console_buffer, 0);
 }
-int readline_into_buffer (const char *const prompt, char * buffer)
+int readline_into_buffer(const char *const prompt, char *buffer, int timeout)
 {
 	char *p = buffer;
 #ifdef CONFIG_CMDLINE_EDITING
 	unsigned int len = CONFIG_SYS_CBSIZE;
 	int rc;
 	static int initted = 0;
 	/*
 	 * History uses a global array which is not
 	 * writable until after relocation to RAM.
 	 * Revert to non-history version if still
 	 * running from flash.
 	 */
 	if (gd->flags & GD_FLG_RELOC) {
 		if (!initted) {
 			hist_init();
 			initted = 1;
 		}
 		if (prompt)
 			puts (prompt);
-		rc = cread_line(prompt, p, &len);
+		rc = cread_line(prompt, p, &len, timeout);
 		return rc < 0 ? rc : len;
 	} else {
 #endif	/* CONFIG_CMDLINE_EDITING */
 	char * p_buf = p;
 	int	n = 0;				/* buffer index		*/
 	int	plen = 0;			/* prompt length	*/
 	int	col;				/* output column cnt	*/
 	char	c;
 	/* print prompt */
 	if (prompt) {
 		plen = strlen (prompt);
 		puts (prompt);
 	}
 	col = plen;
 	for (;;) {
 #ifdef CONFIG_BOOT_RETRY_TIME
 		while (!tstc()) {	/* while no incoming data */
 			if (retry_time >= 0 && get_ticks() > endtime)
 				return (-2);	/* timed out */
 			WATCHDOG_RESET();
 		}
 #endif
 		WATCHDOG_RESET();		/* Trigger watchdog, if needed */
 #ifdef CONFIG_SHOW_ACTIVITY
 		while (!tstc()) {
 			extern void show_activity(int arg);
 			show_activity(0);
 			WATCHDOG_RESET();
 		}
 #endif
 		c = getc();
 		/*
 		 * Special character handling
 		 */
 		switch (c) {
 		case '\r':				/* Enter		*/
 		case '\n':
 			*p = '\0';
 			puts ("\r\n");
 			return (p - p_buf);
 		case '\0':				/* nul			*/
 			continue;
 		case 0x03:				/* ^C - break		*/
 			p_buf[0] = '\0';	/* discard input */
 			return (-1);
 		case 0x15:				/* ^U - erase line	*/
 			while (col > plen) {
 				puts (erase_seq);
 				--col;
 			}
 			p = p_buf;
 			n = 0;
 			continue;
 		case 0x17:				/* ^W - erase word	*/
 			p=delete_char(p_buf, p, &col, &n, plen);
 			while ((n > 0) && (*p != ' ')) {
 				p=delete_char(p_buf, p, &col, &n, plen);
 			}
 			continue;
 		case 0x08:				/* ^H  - backspace	*/
 		case 0x7F:				/* DEL - backspace	*/
 			p=delete_char(p_buf, p, &col, &n, plen);
 			continue;
 		default:
 			/*
 			 * Must be a normal character then
 			 */
 			if (n < CONFIG_SYS_CBSIZE-2) {
 				if (c == '\t') {	/* expand TABs		*/
 #ifdef CONFIG_AUTO_COMPLETE
 					/* if auto completion triggered just continue */
 					*p = '\0';
 					if (cmd_auto_complete(prompt, console_buffer, &n, &col)) {
 						p = p_buf + n;	/* reset */
 						continue;
 					}
 #endif
 					puts (tab_seq+(col&07));
 					col += 8 - (col&07);
 				} else {
 					++col;		/* echo input		*/
 					putc (c);
 				}
 				*p++ = c;
 				++n;
 			} else {			/* Buffer full		*/
 				putc ('\a');
 			}
 		}
 	}
 #ifdef CONFIG_CMDLINE_EDITING
 	}
 #endif
 }
 /****************************************************************************/
 static char * delete_char (char *buffer, char *p, int *colp, int *np, int plen)
 {
 	char *s;
 	if (*np == 0) {
 		return (p);
 	}
 	if (*(--p) == '\t') {			/* will retype the whole line	*/
 		while (*colp > plen) {
 			puts (erase_seq);
 			(*colp)--;
 		}
 		for (s=buffer; s<p; ++s) {
 			if (*s == '\t') {
 				puts (tab_seq+((*colp) & 07));
 				*colp += 8 - ((*colp) & 07);
 			} else {
 				++(*colp);
 				putc (*s);
 			}
 		}
 	} else {
 		puts (erase_seq);
 		(*colp)--;
 	}
 	(*np)--;
 	return (p);
 }
 /****************************************************************************/
 int parse_line (char *line, char *argv[])
 {
 	int nargs = 0;
 #ifdef DEBUG_PARSER
 	printf ("parse_line: \"%s\"\n", line);
 #endif
 	while (nargs < CONFIG_SYS_MAXARGS) {
 		/* skip any white space */
 		while (isblank(*line))
 			++line;
 		if (*line == '\0') {	/* end of line, no more args	*/
 			argv[nargs] = NULL;
 #ifdef DEBUG_PARSER
 		printf ("parse_line: nargs=%d\n", nargs);
 #endif
 			return (nargs);
 		}
 		argv[nargs++] = line;	/* begin of argument string	*/
 		/* find end of string */
 		while (*line && !isblank(*line))
 			++line;
 		if (*line == '\0') {	/* end of line, no more args	*/
 			argv[nargs] = NULL;
 #ifdef DEBUG_PARSER
 		printf ("parse_line: nargs=%d\n", nargs);
 #endif
 			return (nargs);
 		}
 		*line++ = '\0';		/* terminate current arg	 */
 	}
 	printf ("** Too many args (max. %d) **\n", CONFIG_SYS_MAXARGS);
 #ifdef DEBUG_PARSER
 	printf ("parse_line: nargs=%d\n", nargs);
 #endif
 	return (nargs);
 }
 /****************************************************************************/
 static void process_macros (const char *input, char *output)
 {
 	char c, prev;
 	const char *varname_start = NULL;
 	int inputcnt = strlen (input);
 	int outputcnt = CONFIG_SYS_CBSIZE;
 	int state = 0;		/* 0 = waiting for '$'  */
 	/* 1 = waiting for '(' or '{' */
 	/* 2 = waiting for ')' or '}' */
 	/* 3 = waiting for '''  */
 #ifdef DEBUG_PARSER
 	char *output_start = output;
 	printf ("[PROCESS_MACROS] INPUT len %d: \"%s\"\n", strlen (input),
 		input);
 #endif
 	prev = '\0';		/* previous character   */
 	while (inputcnt && outputcnt) {
 		c = *input++;
 		inputcnt--;
 		if (state != 3) {
 			/* remove one level of escape characters */
 			if ((c == '\\') && (prev != '\\')) {
 				if (inputcnt-- == 0)
 					break;
 				prev = c;
 				c = *input++;
 			}
 		}
 		switch (state) {
 		case 0:	/* Waiting for (unescaped) $    */
 			if ((c == '\'') && (prev != '\\')) {
 				state = 3;
 				break;
 			}
 			if ((c == '$') && (prev != '\\')) {
 				state++;
 			} else {
 				*(output++) = c;
 				outputcnt--;
 			}
 			break;
 		case 1:	/* Waiting for (        */
 			if (c == '(' || c == '{') {
 				state++;
 				varname_start = input;
 			} else {
 				state = 0;
 				*(output++) = '$';
 				outputcnt--;
 				if (outputcnt) {
 					*(output++) = c;
 					outputcnt--;
 				}
 			}
 			break;
 		case 2:	/* Waiting for )        */
 			if (c == ')' || c == '}') {
 				int i;
 				char envname[CONFIG_SYS_CBSIZE], *envval;
 				int envcnt = input - varname_start - 1;	/* Varname # of chars */
 				/* Get the varname */
 				for (i = 0; i < envcnt; i++) {
 					envname[i] = varname_start[i];
 				}
 				envname[i] = 0;
 				/* Get its value */
 				envval = getenv (envname);
 				/* Copy into the line if it exists */
 				if (envval != NULL)
 					while ((*envval) && outputcnt) {
 						*(output++) = *(envval++);
 						outputcnt--;
 					}
 				/* Look for another '$' */
 				state = 0;
 			}
 			break;
 		case 3:	/* Waiting for '        */
 			if ((c == '\'') && (prev != '\\')) {
 				state = 0;
 			} else {
 				*(output++) = c;
 				outputcnt--;
 			}
 			break;
 		}
 		prev = c;
 	}
 	if (outputcnt)
 		*output = 0;
 	else
 		*(output - 1) = 0;
 #ifdef DEBUG_PARSER
 	printf ("[PROCESS_MACROS] OUTPUT len %d: \"%s\"\n",
 		strlen (output_start), output_start);
 #endif
 }
 /****************************************************************************
  * returns:
  *	1  - command executed, repeatable
  *	0  - command executed but not repeatable, interrupted commands are
  *	     always considered not repeatable
  *	-1 - not executed (unrecognized, bootd recursion or too many args)
  *           (If cmd is NULL or "" or longer than CONFIG_SYS_CBSIZE-1 it is
  *           considered unrecognized)
  *
  * WARNING:
  *
  * We must create a temporary copy of the command since the command we get
  * may be the result from getenv(), which returns a pointer directly to
  * the environment data, which may change magicly when the command we run
  * creates or modifies environment variables (like "bootp" does).
  */
 int run_command (const char *cmd, int flag)
 {
 	cmd_tbl_t *cmdtp;
 	char cmdbuf[CONFIG_SYS_CBSIZE];	/* working copy of cmd		*/
 	char *token;			/* start of token in cmdbuf	*/
 	char *sep;			/* end of token (separator) in cmdbuf */
 	char finaltoken[CONFIG_SYS_CBSIZE];
 	char *str = cmdbuf;
 	char *argv[CONFIG_SYS_MAXARGS + 1];	/* NULL terminated	*/
 	int argc, inquotes;
 	int repeatable = 1;
 	int rc = 0;
 #ifdef DEBUG_PARSER
 	printf ("[RUN_COMMAND] cmd[%p]=\"", cmd);
 	puts (cmd ? cmd : "NULL");	/* use puts - string may be loooong */
 	puts ("\"\n");
 #endif
 	clear_ctrlc();		/* forget any previous Control C */
 	if (!cmd || !*cmd) {
 		return -1;	/* empty command */
 	}
 	if (strlen(cmd) >= CONFIG_SYS_CBSIZE) {
 		puts ("## Command too long!\n");
 		return -1;
 	}
 	strcpy (cmdbuf, cmd);
 	/* Process separators and check for invalid
 	 * repeatable commands
 	 */
 #ifdef DEBUG_PARSER
 	printf ("[PROCESS_SEPARATORS] %s\n", cmd);
 #endif
 	while (*str) {
 		/*
 		 * Find separator, or string end
 		 * Allow simple escape of ';' by writing "\;"
 		 */
 		for (inquotes = 0, sep = str; *sep; sep++) {
 			if ((*sep=='\'') &&
 			    (*(sep-1) != '\\'))
 				inquotes=!inquotes;
 			if (!inquotes &&
 			    (*sep == ';') &&	/* separator		*/
 			    ( sep != str) &&	/* past string start	*/
 			    (*(sep-1) != '\\'))	/* and NOT escaped	*/
 				break;
 		}
 		/*
 		 * Limit the token to data between separators
 		 */
 		token = str;
 		if (*sep) {
 			str = sep + 1;	/* start of command for next pass */
 			*sep = '\0';
 		}
 		else
 			str = sep;	/* no more commands for next pass */
 #ifdef DEBUG_PARSER
 		printf ("token: \"%s\"\n", token);
 #endif
 		/* find macros in this token and replace them */
 		process_macros (token, finaltoken);
 		/* Extract arguments */
 		if ((argc = parse_line (finaltoken, argv)) == 0) {
 			rc = -1;	/* no command at all */
 			continue;
 		}
 		/* Look up command in command table */
 		if ((cmdtp = find_cmd(argv[0])) == NULL) {
 			printf ("Unknown command '%s' - try 'help'\n", argv[0]);
 			rc = -1;	/* give up after bad command */
 			continue;
 		}
 		/* found - check max args */
 		if (argc > cmdtp->maxargs) {
 			cmd_usage(cmdtp);
 			rc = -1;
 			continue;
 		}
 #if defined(CONFIG_CMD_BOOTD)
 		/* avoid "bootd" recursion */
 		if (cmdtp->cmd == do_bootd) {
 #ifdef DEBUG_PARSER
 			printf ("[%s]\n", finaltoken);
 #endif
 			if (flag & CMD_FLAG_BOOTD) {
 				puts ("'bootd' recursion detected\n");
 				rc = -1;
 				continue;
 			} else {
 				flag |= CMD_FLAG_BOOTD;
 			}
 		}
 #endif
 		/* OK - call function to do the command */
 		if ((cmdtp->cmd) (cmdtp, flag, argc, argv) != 0) {
 			rc = -1;
 		}
 		repeatable &= cmdtp->repeatable;
 		/* Did the user stop this? */
 		if (had_ctrlc ())
 			return -1;	/* if stopped then not repeatable */
 	}
 	return rc ? rc : repeatable;
 }
 /****************************************************************************/
 #if defined(CONFIG_CMD_RUN)
 int do_run (cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
 {
 	int i;
 	if (argc < 2)
 		return cmd_usage(cmdtp);
 	for (i=1; i<argc; ++i) {
 		char *arg;
 		if ((arg = getenv (argv[i])) == NULL) {
 			printf ("## Error: \"%s\" not defined\n", argv[i]);
 			return 1;
 		}
 		if (run_command2(arg, flag) != 0)
 			return 1;
 	}
 	return 0;
 }
 #endif

common/menu.c

Diff comments View file @ 9c34831

 /*
  * Copyright 2010-2011 Calxeda, Inc.
  *
  * This program is free software; you can redistribute it and/or modify it
  * under the terms of the GNU General Public License as published by the Free
  * Software Foundation; either version 2 of the License, or (at your option)
  * any later version.
  *
  * This program is distributed in the hope it will be useful, but WITHOUT
  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  * more details.
  *
  * You should have received a copy of the GNU General Public License along with
  * this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 #include <common.h>
 #include <malloc.h>
 #include <errno.h>
 #include <linux/list.h>
 #include "menu.h"
 /*
  * Internally, each item in a menu is represented by a struct menu_item.
  *
  * These items will be alloc'd and initialized by menu_item_add and destroyed
  * by menu_item_destroy, and the consumer of the interface never sees that
  * this struct is used at all.
  */
 struct menu_item {
 	char *key;
 	void *data;
 	struct list_head list;
 };
 /*
  * The menu is composed of a list of items along with settings and callbacks
  * provided by the user. An incomplete definition of this struct is available
  * in menu.h, but the full definition is here to prevent consumers from
  * relying on its contents.
  */
 struct menu {
 	struct menu_item *default_item;
 	int timeout;
 	char *title;
 	int prompt;
 	void (*item_data_print)(void *);
 	struct list_head items;
 };
 /*
  * An iterator function for menu items. callback will be called for each item
  * in m, with m, a pointer to the item, and extra being passed to callback. If
  * callback returns a value other than NULL, iteration stops and the value
  * return by callback is returned from menu_items_iter.  This allows it to be
  * used for search type operations. It is also safe for callback to remove the
  * item from the list of items.
  */
 static inline void *menu_items_iter(struct menu *m,
 		void *(*callback)(struct menu *, struct menu_item *, void *),
 		void *extra)
 {
 	struct list_head *pos, *n;
 	struct menu_item *item;
 	void *ret;
 	list_for_each_safe(pos, n, &m->items) {
 		item = list_entry(pos, struct menu_item, list);
 		ret = callback(m, item, extra);
 		if (ret)
 			return ret;
 	}
 	return NULL;
 }
 /*
  * Print a menu_item. If the consumer provided an item_data_print function
  * when creating the menu, call it with a pointer to the item's private data.
  * Otherwise, print the key of the item.
  */
 static inline void *menu_item_print(struct menu *m,
 				struct menu_item *item,
 				void *extra)
 {
 	if (!m->item_data_print) {
 		puts(item->key);
 		putc('\n');
 	} else {
 		m->item_data_print(item->data);
 	}
 	return NULL;
 }
 /*
  * Free the memory used by a menu item. This includes the memory used by its
  * key.
  */
 static inline void *menu_item_destroy(struct menu *m,
 				struct menu_item *item,
 				void *extra)
 {
 	if (item->key)
 		free(item->key);
 	free(item);
 	return NULL;
 }
 /*
  * Display a menu so the user can make a choice of an item. First display its
  * title, if any, and then each item in the menu.
  */
 static inline void menu_display(struct menu *m)
 {
 	if (m->title) {
 		puts(m->title);
 		putc('\n');
 	}
 	menu_items_iter(m, menu_item_print, NULL);
 }
 /*
  * Check if an item's key matches a provided string, pointed to by extra. If
  * extra is NULL, an item with a NULL key will match. Otherwise, the item's
  * key has to match according to strcmp.
  *
  * This is called via menu_items_iter, so it returns a pointer to the item if
  * the key matches, and returns NULL otherwise.
  */
 static inline void *menu_item_key_match(struct menu *m,
 			struct menu_item *item, void *extra)
 {
 	char *item_key = extra;
 	if (!item_key || !item->key) {
 		if (item_key == item->key)
 			return item;
 		return NULL;
 	}
 	if (strcmp(item->key, item_key) == 0)
 		return item;
 	return NULL;
 }
 /*
  * Find the first item with a key matching item_key, if any exists.
  */
 static inline struct menu_item *menu_item_by_key(struct menu *m,
 							char *item_key)
 {
 	return menu_items_iter(m, menu_item_key_match, item_key);
 }
 /*
  * Wait for the user to hit a key according to the timeout set for the menu.
  * Returns 1 if the user hit a key, or 0 if the timeout expired.
  */
 static inline int menu_interrupted(struct menu *m)
 {
 	if (!m->timeout)
 		return 0;
 	if (abortboot(m->timeout/10))
 		return 1;
 	return 0;
 }
 /*
  * Checks whether or not the default menu item should be used without
  * prompting for a user choice. If the menu is set to always prompt, or the
  * user hits a key during the timeout period, return 0. Otherwise, return 1 to
  * indicate we should use the default menu item.
  */
 static inline int menu_use_default(struct menu *m)
 {
 	return !m->prompt && !menu_interrupted(m);
 }
 /*
  * Set *choice to point to the default item's data, if any default item was
  * set, and returns 1. If no default item was set, returns -ENOENT.
  */
 static inline int menu_default_choice(struct menu *m, void **choice)
 {
 	if (m->default_item) {
 		*choice = m->default_item->data;
 		return 1;
 	}
 	return -ENOENT;
 }
 /*
  * Displays the menu and asks the user to choose an item. *choice will point
  * to the private data of the item the user chooses. The user makes a choice
  * by inputting a string matching the key of an item. Invalid choices will
  * cause the user to be prompted again, repeatedly, until the user makes a
  * valid choice. The user can exit the menu without making a choice via ^c.
  *
  * Returns 1 if the user made a choice, or -EINTR if they bail via ^c.
  */
 static inline int menu_interactive_choice(struct menu *m, void **choice)
 {
 	char cbuf[CONFIG_SYS_CBSIZE];
 	struct menu_item *choice_item = NULL;
 	int readret;
 	while (!choice_item) {
 		cbuf[0] = '\0';
 		menu_display(m);
-		readret = readline_into_buffer("Enter choice: ", cbuf);
+		readret = readline_into_buffer("Enter choice: ", cbuf,
+				m->timeout);
 		if (readret >= 0) {
 			choice_item = menu_item_by_key(m, cbuf);
 			if (!choice_item)
 				printf("%s not found\n", cbuf);
 		} else {
 			puts("^C\n");
 			return -EINTR;
 		}
 	}
 	*choice = choice_item->data;
 	return 1;
 }
 /*
  * menu_default_set() - Sets the default choice for the menu. This is safe to
  * call more than once on a menu.
  *
  * m - Points to a menu created by menu_create().
  *
  * item_key - Points to a string that, when compared using strcmp, matches the
  * key for an existing item in the menu.
  *
  * Returns 1 if successful, -EINVAL if m is NULL, or -ENOENT if no item with a
  * key matching item_key is found.
  */
 int menu_default_set(struct menu *m, char *item_key)
 {
 	struct menu_item *item;
 	if (!m)
 		return -EINVAL;
 	item = menu_item_by_key(m, item_key);
 	if (!item)
 		return -ENOENT;
 	m->default_item = item;
 	return 1;
 }
 /*
  * menu_get_choice() - Returns the user's selected menu entry, or the default
  * if the menu is set to not prompt or the timeout expires. This is safe to
  * call more than once.
  *
  * m - Points to a menu created by menu_create().
  *
  * choice - Points to a location that will store a pointer to the selected
  * menu item. If no item is selected or there is an error, no value will be
  * written at the location it points to.
  *
  * Returns 1 if successful, -EINVAL if m or choice is NULL, -ENOENT if no
  * default has been set and the menu is set to not prompt or the timeout
  * expires, or -EINTR if the user exits the menu via ^c.
  */
 int menu_get_choice(struct menu *m, void **choice)
 {
 	if (!m || !choice)
 		return -EINVAL;
 	if (menu_use_default(m))
 		return menu_default_choice(m, choice);
 	return menu_interactive_choice(m, choice);
 }
 /*
  * menu_item_add() - Adds or replaces a menu item. Note that this replaces the
  * data of an item if it already exists, but doesn't change the order of the
  * item.
  *
  * m - Points to a menu created by menu_create().
  *
  * item_key - Points to a string that will uniquely identify the item.  The
  * string will be copied to internal storage, and is safe to discard after
  * passing to menu_item_add.
  *
  * item_data - An opaque pointer associated with an item. It is never
  * dereferenced internally, but will be passed to the item_data_print, and
  * will be returned from menu_get_choice if the menu item is selected.
  *
  * Returns 1 if successful, -EINVAL if m is NULL, or -ENOMEM if there is
  * insufficient memory to add the menu item.
  */
 int menu_item_add(struct menu *m, char *item_key, void *item_data)
 {
 	struct menu_item *item;
 	if (!m)
 		return -EINVAL;
 	item = menu_item_by_key(m, item_key);
 	if (item) {
 		item->data = item_data;
 		return 1;
 	}
 	item = malloc(sizeof *item);
 	if (!item)
 		return -ENOMEM;
 	item->key = strdup(item_key);
 	if (!item->key) {
 		free(item);
 		return -ENOMEM;
 	}
 	item->data = item_data;
 	list_add_tail(&item->list, &m->items);
 	return 1;
 }
 /*
  * menu_create() - Creates a menu handle with default settings
  *
  * title - If not NULL, points to a string that will be displayed before the
  * list of menu items. It will be copied to internal storage, and is safe to
  * discard after passing to menu_create().
  *
  * timeout - A delay in seconds to wait for user input. If 0, timeout is
  * disabled, and the default choice will be returned unless prompt is 1.
  *
  * prompt - If 0, don't ask for user input unless there is an interrupted
  * timeout. If 1, the user will be prompted for input regardless of the value
  * of timeout.
  *
  * item_data_print - If not NULL, will be called for each item when the menu
  * is displayed, with the pointer to the item's data passed as the argument.
  * If NULL, each item's key will be printed instead.  Since an item's key is
  * what must be entered to select an item, the item_data_print function should
  * make it obvious what the key for each entry is.
  *
  * Returns a pointer to the menu if successful, or NULL if there is
  * insufficient memory available to create the menu.
  */
 struct menu *menu_create(char *title, int timeout, int prompt,
 				void (*item_data_print)(void *))
 {
 	struct menu *m;
 	m = malloc(sizeof *m);
 	if (!m)
 		return NULL;
 	m->default_item = NULL;
 	m->prompt = prompt;
 	m->timeout = timeout;
 	m->item_data_print = item_data_print;
 	if (title) {
 		m->title = strdup(title);
 		if (!m->title) {
 			free(m);
 			return NULL;
 		}
 	} else
 		m->title = NULL;
 	INIT_LIST_HEAD(&m->items);
 	return m;
 }
 /*
  * menu_destroy() - frees the memory used by a menu and its items.
  *
  * m - Points to a menu created by menu_create().
  *
  * Returns 1 if successful, or -EINVAL if m is NULL.
  */
 int menu_destroy(struct menu *m)
 {
 	if (!m)
 		return -EINVAL;
 	menu_items_iter(m, menu_item_destroy, NULL);
 	if (m->title)
 		free(m->title);
 	free(m);
 	return 1;
 }

include/common.h

Diff comments View file @ 9c34831

 /*
  * (C) Copyright 2000-2009
  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  *
  * See file CREDITS for list of people who contributed to this
  * project.
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU General Public License as
  * published by the Free Software Foundation; either version 2 of
  * the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.	 See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  * MA 02111-1307 USA
  */
 #ifndef __COMMON_H_
 #define __COMMON_H_	1
 #undef	_LINUX_CONFIG_H
 #define _LINUX_CONFIG_H 1	/* avoid reading Linux autoconf.h file	*/
 #ifndef __ASSEMBLY__		/* put C only stuff in this section */
 typedef unsigned char		uchar;
 typedef volatile unsigned long	vu_long;
 typedef volatile unsigned short vu_short;
 typedef volatile unsigned char	vu_char;
 #include <config.h>
 #include <asm-offsets.h>
 #include <linux/bitops.h>
 #include <linux/types.h>
 #include <linux/string.h>
 #include <asm/ptrace.h>
 #include <stdarg.h>
 #if defined(CONFIG_PCI) && (defined(CONFIG_4xx) && !defined(CONFIG_AP1000))
 #include <pci.h>
 #endif
 #if defined(CONFIG_8xx)
 #include <asm/8xx_immap.h>
 #if defined(CONFIG_MPC852)	|| defined(CONFIG_MPC852T)	|| \
     defined(CONFIG_MPC859)	|| defined(CONFIG_MPC859T)	|| \
     defined(CONFIG_MPC859DSL)	|| \
     defined(CONFIG_MPC866)	|| defined(CONFIG_MPC866T)	|| \
     defined(CONFIG_MPC866P)
 # define CONFIG_MPC866_FAMILY 1
 #elif defined(CONFIG_MPC870) \
    || defined(CONFIG_MPC875) \
    || defined(CONFIG_MPC880) \
    || defined(CONFIG_MPC885)
 # define CONFIG_MPC885_FAMILY   1
 #endif
 #if   defined(CONFIG_MPC860)	   \
    || defined(CONFIG_MPC860T)	   \
    || defined(CONFIG_MPC866_FAMILY) \
    || defined(CONFIG_MPC885_FAMILY)
 # define CONFIG_MPC86x 1
 #endif
 #elif defined(CONFIG_5xx)
 #include <asm/5xx_immap.h>
 #elif defined(CONFIG_MPC5xxx)
 #include <mpc5xxx.h>
 #elif defined(CONFIG_MPC512X)
 #include <asm/immap_512x.h>
 #elif defined(CONFIG_MPC8220)
 #include <asm/immap_8220.h>
 #elif defined(CONFIG_8260)
 #if   defined(CONFIG_MPC8247) \
    || defined(CONFIG_MPC8248) \
    || defined(CONFIG_MPC8271) \
    || defined(CONFIG_MPC8272)
 #define CONFIG_MPC8272_FAMILY	1
 #endif
 #if defined(CONFIG_MPC8272_FAMILY)
 #define CONFIG_MPC8260	1
 #endif
 #include <asm/immap_8260.h>
 #endif
 #ifdef CONFIG_MPC86xx
 #include <mpc86xx.h>
 #include <asm/immap_86xx.h>
 #endif
 #ifdef CONFIG_MPC85xx
 #include <mpc85xx.h>
 #include <asm/immap_85xx.h>
 #endif
 #ifdef CONFIG_MPC83xx
 #include <mpc83xx.h>
 #include <asm/immap_83xx.h>
 #endif
 #ifdef	CONFIG_4xx
 #include <asm/ppc4xx.h>
 #endif
 #ifdef CONFIG_HYMOD
 #include <board/hymod/hymod.h>
 #endif
 #ifdef CONFIG_ARM
 #define asmlinkage	/* nothing */
 #endif
 #ifdef CONFIG_BLACKFIN
 #include <asm/blackfin.h>
 #endif
 #ifdef CONFIG_SOC_DA8XX
 #include <asm/arch/hardware.h>
 #endif
 #include <part.h>
 #include <flash.h>
 #include <image.h>
 #ifdef DEBUG
 #define _DEBUG	1
 #else
 #define _DEBUG	0
 #endif
 /*
  * Output a debug text when condition "cond" is met. The "cond" should be
  * computed by a preprocessor in the best case, allowing for the best
  * optimization.
  */
 #define debug_cond(cond, fmt, args...)		\
 	do {					\
 		if (cond)			\
 			printf(fmt, ##args);	\
 	} while (0)
 #define debug(fmt, args...)			\
 	debug_cond(_DEBUG, fmt, ##args)
 /*
  * An assertion is run-time check done in debug mode only. If DEBUG is not
  * defined then it is skipped. If DEBUG is defined and the assertion fails,
  * then it calls panic*( which may or may not reset/halt U-Boot (see
  * CONFIG_PANIC_HANG), It is hoped that all failing assertions are found
  * before release, and after release it is hoped that they don't matter. But
  * in any case these failing assertions cannot be fixed with a reset (which
  * may just do the same assertion again).
  */
 void __assert_fail(const char *assertion, const char *file, unsigned line,
 		   const char *function);
 #define assert(x) \
 	({ if (!(x) && _DEBUG) \
 		__assert_fail(#x, __FILE__, __LINE__, __func__); })
 #define error(fmt, args...) do {					\
 		printf("ERROR: " fmt "\nat %s:%d/%s()\n",		\
 			##args, __FILE__, __LINE__, __func__);		\
 } while (0)
 #ifndef BUG
 #define BUG() do { \
 	printf("BUG: failure at %s:%d/%s()!\n", __FILE__, __LINE__, __FUNCTION__); \
 	panic("BUG!"); \
 } while (0)
 #define BUG_ON(condition) do { if (unlikely((condition)!=0)) BUG(); } while(0)
 #endif /* BUG */
 /* Force a compilation error if condition is true */
 #define BUILD_BUG_ON(condition) ((void)sizeof(char[1 - 2*!!(condition)]))
 typedef void (interrupt_handler_t)(void *);
 #include <asm/u-boot.h> /* boot information for Linux kernel */
 #include <asm/global_data.h>	/* global data used for startup functions */
 /*
  * enable common handling for all TQM8xxL/M boards:
  * - CONFIG_TQM8xxM will be defined for all TQM8xxM boards
  * - CONFIG_TQM8xxL will be defined for all TQM8xxL _and_ TQM8xxM boards
  *                  and for the TQM885D board
  */
 #if defined(CONFIG_TQM823M) || defined(CONFIG_TQM850M) || \
     defined(CONFIG_TQM855M) || defined(CONFIG_TQM860M) || \
     defined(CONFIG_TQM862M) || defined(CONFIG_TQM866M)
 # ifndef CONFIG_TQM8xxM
 #  define CONFIG_TQM8xxM
 # endif
 #endif
 #if defined(CONFIG_TQM823L) || defined(CONFIG_TQM850L) || \
     defined(CONFIG_TQM855L) || defined(CONFIG_TQM860L) || \
     defined(CONFIG_TQM862L) || defined(CONFIG_TQM8xxM) || \
     defined(CONFIG_TQM885D)
 # ifndef CONFIG_TQM8xxL
 #  define CONFIG_TQM8xxL
 # endif
 #endif
 #ifndef CONFIG_SERIAL_MULTI
 #if defined(CONFIG_8xx_CONS_SMC1) || defined(CONFIG_8xx_CONS_SMC2) \
  || defined(CONFIG_8xx_CONS_SCC1) || defined(CONFIG_8xx_CONS_SCC2) \
  || defined(CONFIG_8xx_CONS_SCC3) || defined(CONFIG_8xx_CONS_SCC4)
 #define CONFIG_SERIAL_MULTI	1
 #endif
 #endif /* CONFIG_SERIAL_MULTI */
 /*
  * General Purpose Utilities
  */
 #define min(X, Y)				\
 	({ typeof (X) __x = (X);		\
 		typeof (Y) __y = (Y);		\
 		(__x < __y) ? __x : __y; })
 #define max(X, Y)				\
 	({ typeof (X) __x = (X);		\
 		typeof (Y) __y = (Y);		\
 		(__x > __y) ? __x : __y; })
 #define MIN(x, y)  min(x, y)
 #define MAX(x, y)  max(x, y)
 #if defined(CONFIG_ENV_IS_EMBEDDED)
 #define TOTAL_MALLOC_LEN	CONFIG_SYS_MALLOC_LEN
 #elif ( ((CONFIG_ENV_ADDR+CONFIG_ENV_SIZE) < CONFIG_SYS_MONITOR_BASE) || \
 	(CONFIG_ENV_ADDR >= (CONFIG_SYS_MONITOR_BASE + CONFIG_SYS_MONITOR_LEN)) ) || \
       defined(CONFIG_ENV_IS_IN_NVRAM)
 #define	TOTAL_MALLOC_LEN	(CONFIG_SYS_MALLOC_LEN + CONFIG_ENV_SIZE)
 #else
 #define	TOTAL_MALLOC_LEN	CONFIG_SYS_MALLOC_LEN
 #endif
 /**
  * container_of - cast a member of a structure out to the containing structure
  * @ptr:	the pointer to the member.
  * @type:	the type of the container struct this is embedded in.
  * @member:	the name of the member within the struct.
  *
  */
 #define container_of(ptr, type, member) ({			\
 	const typeof( ((type *)0)->member ) *__mptr = (ptr);	\
 	(type *)( (char *)__mptr - offsetof(type,member) );})
 /*
  * Function Prototypes
  */
 void	hang		(void) __attribute__ ((noreturn));
 int	timer_init(void);
 int	cpu_init(void);
 /* */
 phys_size_t initdram (int);
 int	display_options (void);
 void	print_size(unsigned long long, const char *);
 int	print_buffer (ulong addr, void* data, uint width, uint count, uint linelen);
 /* common/main.c */
 void	main_loop	(void);
 int	run_command	(const char *cmd, int flag);
 #ifdef CONFIG_CMD_PXE
 int run_command2(const char *cmd, int flag);
 #endif
 int	readline	(const char *const prompt);
-int	readline_into_buffer	(const char *const prompt, char * buffer);
+int	readline_into_buffer(const char *const prompt, char *buffer,
+			int timeout);
 int	parse_line (char *, char *[]);
 void	init_cmd_timeout(void);
 void	reset_cmd_timeout(void);
 #ifdef CONFIG_MENU
 int	abortboot(int bootdelay);
 #endif
 extern char console_buffer[];
 /* arch/$(ARCH)/lib/board.c */
 void	board_init_f  (ulong) __attribute__ ((noreturn));
 void	board_init_r  (gd_t *, ulong) __attribute__ ((noreturn));
 int	checkboard    (void);
 int	checkflash    (void);
 int	checkdram     (void);
 int	last_stage_init(void);
 extern ulong monitor_flash_len;
 int mac_read_from_eeprom(void);
 extern u8 _binary_dt_dtb_start[];	/* embedded device tree blob */
 /*
  * Called when console output is requested before the console is available.
  * The board should do its best to get the character out to the user any way
  * it can.
  */
 void board_pre_console_putc(int ch);
 /* common/flash.c */
 void flash_perror (int);
 /* common/cmd_source.c */
 int	source (ulong addr, const char *fit_uname);
 extern ulong load_addr;		/* Default Load Address */
 extern ulong save_addr;		/* Default Save Address */
 extern ulong save_size;		/* Default Save Size */
 /* common/cmd_doc.c */
 void	doc_probe(unsigned long physadr);
 /* common/cmd_net.c */
 int do_tftpb(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
 /* common/cmd_nvedit.c */
 int	env_init     (void);
 void	env_relocate (void);
 int	envmatch     (uchar *, int);
 char	*getenv	     (const char *);
 int	getenv_f     (const char *name, char *buf, unsigned len);
 ulong getenv_ulong(const char *name, int base, ulong default_val);
 int	saveenv	     (void);
 #ifdef CONFIG_PPC		/* ARM version to be fixed! */
 int inline setenv    (const char *, const char *);
 #else
 int	setenv	     (const char *, const char *);
 int setenv_ulong(const char *varname, ulong value);
 int setenv_addr(const char *varname, const void *addr);
 #endif /* CONFIG_PPC */
 #ifdef CONFIG_ARM
 # include <asm/mach-types.h>
 # include <asm/setup.h>
 # include <asm/u-boot-arm.h>	/* ARM version to be fixed! */
 #endif /* CONFIG_ARM */
 #ifdef CONFIG_X86		/* x86 version to be fixed! */
 # include <asm/u-boot-x86.h>
 #endif /* CONFIG_X86 */
 #ifdef CONFIG_SANDBOX
 # include <asm/u-boot-sandbox.h>	/* TODO(sjg) what needs to be fixed? */
 #endif
 #ifdef CONFIG_NDS32
 # include <asm/mach-types.h>
 # include <asm/u-boot-nds32.h>
 #endif /* CONFIG_NDS32 */
 #ifdef CONFIG_AUTO_COMPLETE
 int env_complete(char *var, int maxv, char *cmdv[], int maxsz, char *buf);
 #endif
 int get_env_id (void);
 void	pci_init      (void);
 void	pci_init_board(void);
 void	pciinfo	      (int, int);
 #if defined(CONFIG_PCI) && (defined(CONFIG_4xx) && !defined(CONFIG_AP1000))
     int	   pci_pre_init	       (struct pci_controller *);
     int	   is_pci_host	       (struct pci_controller *);
 #endif
 #if defined(CONFIG_PCI) && (defined(CONFIG_440) || defined(CONFIG_405EX))
 #   if defined(CONFIG_SYS_PCI_TARGET_INIT)
 	void	pci_target_init	     (struct pci_controller *);
 #   endif
 #   if defined(CONFIG_SYS_PCI_MASTER_INIT)
 	void	pci_master_init	     (struct pci_controller *);
 #   endif
 #if defined(CONFIG_440SPE) || \
     defined(CONFIG_460EX) || defined(CONFIG_460GT) || \
     defined(CONFIG_405EX)
    void pcie_setup_hoses(int busno);
 #endif
 #endif
 int	misc_init_f   (void);
 int	misc_init_r   (void);
 /* common/exports.c */
 void	jumptable_init(void);
 /* common/kallsysm.c */
 const char *symbol_lookup(unsigned long addr, unsigned long *caddr);
 /* api/api.c */
 void	api_init (void);
 /* common/memsize.c */
 long	get_ram_size  (long *, long);
 /* $(BOARD)/$(BOARD).c */
 void	reset_phy     (void);
 void	fdc_hw_init   (void);
 /* $(BOARD)/eeprom.c */
 void eeprom_init  (void);
 #ifndef CONFIG_SPI
 int  eeprom_probe (unsigned dev_addr, unsigned offset);
 #endif
 int  eeprom_read  (unsigned dev_addr, unsigned offset, uchar *buffer, unsigned cnt);
 int  eeprom_write (unsigned dev_addr, unsigned offset, uchar *buffer, unsigned cnt);
 #ifdef CONFIG_LWMON
 extern uchar pic_read  (uchar reg);
 extern void  pic_write (uchar reg, uchar val);
 #endif
 /*
  * Set this up regardless of board
  * type, to prevent errors.
  */
 #if defined(CONFIG_SPI) || !defined(CONFIG_SYS_I2C_EEPROM_ADDR)
 # define CONFIG_SYS_DEF_EEPROM_ADDR 0
 #else
 #if !defined(CONFIG_ENV_EEPROM_IS_ON_I2C)
 # define CONFIG_SYS_DEF_EEPROM_ADDR CONFIG_SYS_I2C_EEPROM_ADDR
 #endif
 #endif /* CONFIG_SPI || !defined(CONFIG_SYS_I2C_EEPROM_ADDR) */
 #if defined(CONFIG_SPI)
 extern void spi_init_f (void);
 extern void spi_init_r (void);
 extern ssize_t spi_read	 (uchar *, int, uchar *, int);
 extern ssize_t spi_write (uchar *, int, uchar *, int);
 #endif
 #ifdef CONFIG_RPXCLASSIC
 void rpxclassic_init (void);
 #endif
 void rpxlite_init (void);
 #ifdef CONFIG_MBX
 /* $(BOARD)/mbx8xx.c */
 void	mbx_init (void);
 void	board_serial_init (void);
 void	board_ether_init (void);
 #endif
 #ifdef CONFIG_HERMES
 /* $(BOARD)/hermes.c */
 void hermes_start_lxt980 (int speed);
 #endif
 #ifdef CONFIG_EVB64260
 void  evb64260_init(void);
 void  debug_led(int, int);
 void  display_mem_map(void);
 void  perform_soft_reset(void);
 #endif
 /* $(BOARD)/$(BOARD).c */
 int board_early_init_f (void);
 int board_late_init (void);
 int board_postclk_init (void); /* after clocks/timebase, before env/serial */
 int board_early_init_r (void);
 void board_poweroff (void);
 #if defined(CONFIG_SYS_DRAM_TEST)
 int testdram(void);
 #endif /* CONFIG_SYS_DRAM_TEST */
 /* $(CPU)/start.S */
 #if defined(CONFIG_5xx) || \
     defined(CONFIG_8xx)
 uint	get_immr      (uint);
 #endif
 uint	get_pir	      (void);
 #if defined(CONFIG_MPC5xxx)
 uint	get_svr       (void);
 #endif
 uint	get_pvr	      (void);
 uint	get_svr	      (void);
 uint	rd_ic_cst     (void);
 void	wr_ic_cst     (uint);
 void	wr_ic_adr     (uint);
 uint	rd_dc_cst     (void);
 void	wr_dc_cst     (uint);
 void	wr_dc_adr     (uint);
 int	icache_status (void);
 void	icache_enable (void);
 void	icache_disable(void);
 int	dcache_status (void);
 void	dcache_enable (void);
 void	dcache_disable(void);
 void	mmu_disable(void);
 void	relocate_code (ulong, gd_t *, ulong) __attribute__ ((noreturn));
 ulong	get_endaddr   (void);
 void	trap_init     (ulong);
 #if defined (CONFIG_4xx)	|| \
     defined (CONFIG_MPC5xxx)	|| \
     defined (CONFIG_74xx_7xx)	|| \
     defined (CONFIG_74x)	|| \
     defined (CONFIG_75x)	|| \
     defined (CONFIG_74xx)	|| \
     defined (CONFIG_MPC8220)	|| \
     defined (CONFIG_MPC85xx)	|| \
     defined (CONFIG_MPC86xx)	|| \
     defined (CONFIG_MPC83xx)
 unsigned char	in8(unsigned int);
 void		out8(unsigned int, unsigned char);
 unsigned short	in16(unsigned int);
 unsigned short	in16r(unsigned int);
 void		out16(unsigned int, unsigned short value);
 void		out16r(unsigned int, unsigned short value);
 unsigned long	in32(unsigned int);
 unsigned long	in32r(unsigned int);
 void		out32(unsigned int, unsigned long value);
 void		out32r(unsigned int, unsigned long value);
 void		ppcDcbf(unsigned long value);
 void		ppcDcbi(unsigned long value);
 void		ppcSync(void);
 void		ppcDcbz(unsigned long value);
 #endif
 #if defined (CONFIG_MICROBLAZE)
 unsigned short	in16(unsigned int);
 void		out16(unsigned int, unsigned short value);
 #endif
 #if defined (CONFIG_MPC83xx)
 void		ppcDWload(unsigned int *addr, unsigned int *ret);
 void		ppcDWstore(unsigned int *addr, unsigned int *value);
 void disable_addr_trans(void);
 void enable_addr_trans(void);
 #if defined(CONFIG_DDR_ECC) && !defined(CONFIG_ECC_INIT_VIA_DDRCONTROLLER)
 void ddr_enable_ecc(unsigned int dram_size);
 #endif
 #endif
 /* $(CPU)/cpu.c */
 static inline int cpumask_next(int cpu, unsigned int mask)
 {
 	for (cpu++; !((1 << cpu) & mask); cpu++)
 		;
 	return cpu;
 }
 #define for_each_cpu(iter, cpu, num_cpus, mask) \
 	for (iter = 0, cpu = cpumask_next(-1, mask); \
 		iter < num_cpus; \
 		iter++, cpu = cpumask_next(cpu, mask)) \
 int	cpu_numcores  (void);
 u32	cpu_mask      (void);
 int	is_core_valid (unsigned int);
 int	probecpu      (void);
 int	checkcpu      (void);
 int	checkicache   (void);
 int	checkdcache   (void);
 void	upmconfig     (unsigned int, unsigned int *, unsigned int);
 ulong	get_tbclk     (void);
 void	reset_cpu     (ulong addr);
 #if defined (CONFIG_OF_LIBFDT) && defined (CONFIG_OF_BOARD_SETUP)
 void ft_cpu_setup(void *blob, bd_t *bd);
 #ifdef CONFIG_PCI
 void ft_pci_setup(void *blob, bd_t *bd);
 #endif
 #endif
 /* $(CPU)/serial.c */
 int	serial_init   (void);
 void	serial_setbrg (void);
 void	serial_putc   (const char);
 void	serial_putc_raw(const char);
 void	serial_puts   (const char *);
 int	serial_getc   (void);
 int	serial_tstc   (void);
 void	_serial_setbrg (const int);
 void	_serial_putc   (const char, const int);
 void	_serial_putc_raw(const char, const int);
 void	_serial_puts   (const char *, const int);
 int	_serial_getc   (const int);
 int	_serial_tstc   (const int);
 /* $(CPU)/speed.c */
 int	get_clocks (void);
 int	get_clocks_866 (void);
 int	sdram_adjust_866 (void);
 int	adjust_sdram_tbs_8xx (void);
 #if defined(CONFIG_8260)
 int	prt_8260_clks (void);
 #elif defined(CONFIG_MPC5xxx)
 int	prt_mpc5xxx_clks (void);
 #endif
 #if defined(CONFIG_MPC512X)
 int	prt_mpc512xxx_clks (void);
 #endif
 #if defined(CONFIG_MPC8220)
 int	prt_mpc8220_clks (void);
 #endif
 #ifdef CONFIG_4xx
 ulong	get_OPB_freq (void);
 ulong	get_PCI_freq (void);
 #endif
 #if defined(CONFIG_S3C24X0) || \
     defined(CONFIG_LH7A40X) || \
     defined(CONFIG_S3C6400) || \
     defined(CONFIG_EP93XX)
 ulong	get_FCLK (void);
 ulong	get_HCLK (void);
 ulong	get_PCLK (void);
 ulong	get_UCLK (void);
 #endif
 #if defined(CONFIG_LH7A40X)
 ulong	get_PLLCLK (void);
 #endif
 #if defined CONFIG_INCA_IP
 uint	incaip_get_cpuclk (void);
 #endif
 #if defined(CONFIG_IMX)
 ulong get_systemPLLCLK(void);
 ulong get_FCLK(void);
 ulong get_HCLK(void);
 ulong get_BCLK(void);
 ulong get_PERCLK1(void);
 ulong get_PERCLK2(void);
 ulong get_PERCLK3(void);
 #endif
 ulong	get_bus_freq  (ulong);
 int get_serial_clock(void);
 #if defined(CONFIG_MPC83xx) || defined(CONFIG_MPC85xx)
 ulong get_ddr_freq(ulong);
 #endif
 #if defined(CONFIG_MPC85xx)
 typedef MPC85xx_SYS_INFO sys_info_t;
 void	get_sys_info  ( sys_info_t * );
 #endif
 #if defined(CONFIG_MPC86xx)
 typedef MPC86xx_SYS_INFO sys_info_t;
 void   get_sys_info  ( sys_info_t * );
 static inline ulong get_ddr_freq(ulong dummy)
 {
 	return get_bus_freq(dummy);
 }
 #endif
 #if defined(CONFIG_4xx) || defined(CONFIG_IOP480)
 #  if defined(CONFIG_440)
 #	if defined(CONFIG_440SPE)
 	 unsigned long determine_sysper(void);
 	 unsigned long determine_pci_clock_per(void);
 #	endif
 #  endif
 typedef PPC4xx_SYS_INFO sys_info_t;
 int	ppc440spe_revB(void);
 void	get_sys_info  ( sys_info_t * );
 #endif
 /* $(CPU)/cpu_init.c */
 #if defined(CONFIG_8xx) || defined(CONFIG_8260)
 void	cpu_init_f    (volatile immap_t *immr);
 #endif
 #if defined(CONFIG_4xx) || defined(CONFIG_MPC85xx) || defined(CONFIG_MCF52x2) ||defined(CONFIG_MPC86xx)
 void	cpu_init_f    (void);
 #endif
 int	cpu_init_r    (void);
 #if defined(CONFIG_8260)
 int	prt_8260_rsr  (void);
 #elif defined(CONFIG_MPC83xx)
 int	prt_83xx_rsr  (void);
 #endif
 /* $(CPU)/interrupts.c */
 int	interrupt_init	   (void);
 void	timer_interrupt	   (struct pt_regs *);
 void	external_interrupt (struct pt_regs *);
 void	irq_install_handler(int, interrupt_handler_t *, void *);
 void	irq_free_handler   (int);
 void	reset_timer	   (void);
 ulong	get_timer	   (ulong base);
 void	enable_interrupts  (void);
 int	disable_interrupts (void);
 /* $(CPU)/.../commproc.c */
 int	dpram_init (void);
 uint	dpram_base(void);
 uint	dpram_base_align(uint align);
 uint	dpram_alloc(uint size);
 uint	dpram_alloc_align(uint size,uint align);
 void	bootcount_store (ulong);
 ulong	bootcount_load (void);
 #define BOOTCOUNT_MAGIC		0xB001C041
 /* $(CPU)/.../<eth> */
 void mii_init (void);
 /* $(CPU)/.../lcd.c */
 ulong	lcd_setmem (ulong);
 /* $(CPU)/.../video.c */
 ulong	video_setmem (ulong);
 /* arch/$(ARCH)/lib/cache.c */
 void	enable_caches(void);
 void	flush_cache   (unsigned long, unsigned long);
 void	flush_dcache_all(void);
 void	flush_dcache_range(unsigned long start, unsigned long stop);
 void	invalidate_dcache_range(unsigned long start, unsigned long stop);
 void	invalidate_dcache_all(void);
 void	invalidate_icache_all(void);
 /* arch/$(ARCH)/lib/ticks.S */
 unsigned long long get_ticks(void);
 void	wait_ticks    (unsigned long);
 /* arch/$(ARCH)/lib/time.c */
 void	__udelay      (unsigned long);
 ulong	usec2ticks    (unsigned long usec);
 ulong	ticks2usec    (unsigned long ticks);
 int	init_timebase (void);
 /* lib/gunzip.c */
 int gunzip(void *, int, unsigned char *, unsigned long *);
 int zunzip(void *dst, int dstlen, unsigned char *src, unsigned long *lenp,
 						int stoponerr, int offset);
 /* lib/net_utils.c */
 #include <net.h>
 static inline IPaddr_t getenv_IPaddr (char *var)
 {
 	return (string_to_ip(getenv(var)));
 }
 /* lib/qsort.c */
 void qsort(void *base, size_t nmemb, size_t size,
 	   int(*compar)(const void *, const void *));
 int strcmp_compar(const void *, const void *);
 /* lib/time.c */
 void	udelay        (unsigned long);
 void mdelay(unsigned long);
 /* lib/uuid.c */
 void uuid_str_to_bin(const char *uuid, unsigned char *out);
 int uuid_str_valid(const char *uuid);
 /* lib/vsprintf.c */
 #include <vsprintf.h>
 /* lib/strmhz.c */
 char *	strmhz(char *buf, unsigned long hz);
 /* lib/crc32.c */
 #include <u-boot/crc.h>
 /* common/console.c */
 int	console_init_f(void);	/* Before relocation; uses the serial  stuff	*/
 int	console_init_r(void);	/* After  relocation; uses the console stuff	*/
 int	console_assign(int file, const char *devname);	/* Assign the console	*/
 int	ctrlc (void);
 int	had_ctrlc (void);	/* have we had a Control-C since last clear? */
 void	clear_ctrlc (void);	/* clear the Control-C condition */
 int	disable_ctrlc (int);	/* 1 to disable, 0 to enable Control-C detect */
 /*
  * STDIO based functions (can always be used)
  */
 /* serial stuff */
 int	serial_printf (const char *fmt, ...)
 		__attribute__ ((format (__printf__, 1, 2)));
 /* stdin */
 int	getc(void);
 int	tstc(void);
 /* stdout */
 void	putc(const char c);
 void	puts(const char *s);
 int	printf(const char *fmt, ...)
 		__attribute__ ((format (__printf__, 1, 2)));
 int	vprintf(const char *fmt, va_list args);
 /* stderr */
 #define eputc(c)		fputc(stderr, c)
 #define eputs(s)		fputs(stderr, s)
 #define eprintf(fmt,args...)	fprintf(stderr,fmt ,##args)
 /*
  * FILE based functions (can only be used AFTER relocation!)
  */
 #define stdin		0
 #define stdout		1
 #define stderr		2
 #define MAX_FILES	3
 int	fprintf(int file, const char *fmt, ...)
 		__attribute__ ((format (__printf__, 2, 3)));
 void	fputs(int file, const char *s);
 void	fputc(int file, const char c);
 int	ftstc(int file);
 int	fgetc(int file);
 /*
  * CONSOLE multiplexing.
  */
 #ifdef CONFIG_CONSOLE_MUX
 #include <iomux.h>
 #endif
 int	pcmcia_init (void);
 #ifdef CONFIG_STATUS_LED
 # include <status_led.h>
 #endif
 /*
  * Board-specific Platform code can reimplement show_boot_progress () if needed
  */
 void show_boot_progress(int val);
 /* Multicore arch functions */
 #ifdef CONFIG_MP
 int cpu_status(int nr);
 int cpu_reset(int nr);
 int cpu_disable(int nr);
 int cpu_release(int nr, int argc, char * const argv[]);
 #endif
 #endif /* __ASSEMBLY__ */
 #ifdef CONFIG_PPC
 /*
  * Has to be included outside of the #ifndef __ASSEMBLY__ section.
  * Otherwise might lead to compilation errors in assembler files.
  */
 #include <asm/cache.h>
 #endif
 /* Put only stuff here that the assembler can digest */
 #ifdef CONFIG_POST
 #define CONFIG_HAS_POST
 #ifndef CONFIG_POST_ALT_LIST
 #define CONFIG_POST_STD_LIST
 #endif
 #endif
 #ifdef CONFIG_INIT_CRITICAL
 #error CONFIG_INIT_CRITICAL is deprecated!
 #error Read section CONFIG_SKIP_LOWLEVEL_INIT in README.
 #endif
 #define ARRAY_SIZE(x) (sizeof(x) / sizeof((x)[0]))
 #define ROUND(a,b)		(((a) + (b) - 1) & ~((b) - 1))
 #define DIV_ROUND(n,d)		(((n) + ((d)/2)) / (d))
 #define DIV_ROUND_UP(n,d)	(((n) + (d) - 1) / (d))
 #define roundup(x, y)		((((x) + ((y) - 1)) / (y)) * (y))
 #define ALIGN(x,a)		__ALIGN_MASK((x),(typeof(x))(a)-1)
 #define __ALIGN_MASK(x,mask)	(((x)+(mask))&~(mask))
 /*
  * ARCH_DMA_MINALIGN is defined in asm/cache.h for each architecture.  It
  * is used to align DMA buffers.
  */
 #ifndef __ASSEMBLY__
 #include <asm/cache.h>
 #endif
 /*
  * The ALLOC_CACHE_ALIGN_BUFFER macro is used to allocate a buffer on the
  * stack that meets the minimum architecture alignment requirements for DMA.
  * Such a buffer is useful for DMA operations where flushing and invalidating
  * the cache before and after a read and/or write operation is required for
  * correct operations.
  *
  * When called the macro creates an array on the stack that is sized such
  * that:
  *
  * 1) The beginning of the array can be advanced enough to be aligned.
  *
  * 2) The size of the aligned portion of the array is a multiple of the minimum
  *    architecture alignment required for DMA.
  *
  * 3) The aligned portion contains enough space for the original number of
  *    elements requested.
  *
  * The macro then creates a pointer to the aligned portion of this array and
  * assigns to the pointer the address of the first element in the aligned
  * portion of the array.
  *
  * Calling the macro as:
  *
  *     ALLOC_CACHE_ALIGN_BUFFER(uint32_t, buffer, 1024);
  *
  * Will result in something similar to saying:
  *
  *     uint32_t    buffer[1024];
  *
  * The following differences exist:
  *
  * 1) The resulting buffer is guaranteed to be aligned to the value of
  *    ARCH_DMA_MINALIGN.
  *
  * 2) The buffer variable created by the macro is a pointer to the specified
  *    type, and NOT an array of the specified type.  This can be very important
  *    if you want the address of the buffer, which you probably do, to pass it
  *    to the DMA hardware.  The value of &buffer is different in the two cases.
  *    In the macro case it will be the address of the pointer, not the address
  *    of the space reserved for the buffer.  However, in the second case it
  *    would be the address of the buffer.  So if you are replacing hard coded
  *    stack buffers with this macro you need to make sure you remove the & from
  *    the locations where you are taking the address of the buffer.
  *
  * Note that the size parameter is the number of array elements to allocate,
  * not the number of bytes.
  *
  * This macro can not be used outside of function scope, or for the creation
  * of a function scoped static buffer.  It can not be used to create a cache
  * line aligned global buffer.
  */
 #define ALLOC_CACHE_ALIGN_BUFFER(type, name, size)			\
 	char __##name[ROUND(size * sizeof(type), ARCH_DMA_MINALIGN) +	\
 		      ARCH_DMA_MINALIGN - 1];				\
 									\
 	type *name = (type *) ALIGN((uintptr_t)__##name, ARCH_DMA_MINALIGN)
 /* Pull in stuff for the build system */
 #ifdef DO_DEPS_ONLY
 # include <environment.h>
 #endif
 #endif	/* __COMMON_H_ */