blob: dcc93c19bd5b7139c4de6181cf2f2a5bba87cc57 [file] [log] [blame]
wdenka68d3ed2002-10-11 08:38:32 +00001/*
Wolfgang Denkea882ba2010-06-20 23:33:59 +02002 * (C) Copyright 2000-2010
wdenka68d3ed2002-10-11 08:38:32 +00003 * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
4 *
5 * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
6 * Andreas Heppel <aheppel@sysgo.de>
7
8 * See file CREDITS for list of people who contributed to this
9 * project.
10 *
11 * This program is free software; you can redistribute it and/or
12 * modify it under the terms of the GNU General Public License as
13 * published by the Free Software Foundation; either version 2 of
14 * the License, or (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
24 * MA 02111-1307 USA
25 */
26
Wolfgang Denkea882ba2010-06-20 23:33:59 +020027/*
wdenka68d3ed2002-10-11 08:38:32 +000028 * Support for persistent environment data
29 *
Wolfgang Denkea882ba2010-06-20 23:33:59 +020030 * The "environment" is stored on external storage as a list of '\0'
31 * terminated "name=value" strings. The end of the list is marked by
32 * a double '\0'. The environment is preceeded by a 32 bit CRC over
33 * the data part and, in case of redundant environment, a byte of
34 * flags.
wdenka68d3ed2002-10-11 08:38:32 +000035 *
Wolfgang Denkea882ba2010-06-20 23:33:59 +020036 * This linearized representation will also be used before
37 * relocation, i. e. as long as we don't have a full C runtime
38 * environment. After that, we use a hash table.
wdenka68d3ed2002-10-11 08:38:32 +000039 */
40
41#include <common.h>
42#include <command.h>
43#include <environment.h>
Wolfgang Denkea882ba2010-06-20 23:33:59 +020044#include <search.h>
45#include <errno.h>
Peter Tyser246c6922009-10-25 15:12:56 -050046#include <malloc.h>
wdenk2a3cb022002-11-05 21:01:48 +000047#include <watchdog.h>
wdenk281e00a2004-08-01 22:48:16 +000048#include <serial.h>
wdenka68d3ed2002-10-11 08:38:32 +000049#include <linux/stddef.h>
50#include <asm/byteorder.h>
Jon Loeligerc76fe472007-07-08 18:02:23 -050051#if defined(CONFIG_CMD_NET)
wdenka68d3ed2002-10-11 08:38:32 +000052#include <net.h>
53#endif
54
Wolfgang Denkd87080b2006-03-31 18:32:53 +020055DECLARE_GLOBAL_DATA_PTR;
56
unsik Kim75eb82e2009-02-25 11:31:24 +090057#if !defined(CONFIG_ENV_IS_IN_EEPROM) && \
Jean-Christophe PLAGNIOL-VILLARD5a1aceb2008-09-10 22:48:04 +020058 !defined(CONFIG_ENV_IS_IN_FLASH) && \
Jean-Christophe PLAGNIOL-VILLARD057c8492008-09-10 22:47:58 +020059 !defined(CONFIG_ENV_IS_IN_DATAFLASH) && \
unsik Kim75eb82e2009-02-25 11:31:24 +090060 !defined(CONFIG_ENV_IS_IN_MG_DISK) && \
Terry Lva8060352010-05-17 10:57:01 +080061 !defined(CONFIG_ENV_IS_IN_MMC) && \
Jean-Christophe PLAGNIOL-VILLARD51bfee12008-09-10 22:47:58 +020062 !defined(CONFIG_ENV_IS_IN_NAND) && \
unsik Kim75eb82e2009-02-25 11:31:24 +090063 !defined(CONFIG_ENV_IS_IN_NVRAM) && \
Jean-Christophe PLAGNIOL-VILLARD96561382008-09-10 22:47:59 +020064 !defined(CONFIG_ENV_IS_IN_ONENAND) && \
Jean-Christophe PLAGNIOL-VILLARD0b5099a2008-09-10 22:48:00 +020065 !defined(CONFIG_ENV_IS_IN_SPI_FLASH) && \
Jean-Christophe PLAGNIOL-VILLARD93f6d722008-09-10 22:48:00 +020066 !defined(CONFIG_ENV_IS_NOWHERE)
unsik Kim75eb82e2009-02-25 11:31:24 +090067# error Define one of CONFIG_ENV_IS_IN_{EEPROM|FLASH|DATAFLASH|ONENAND|\
Terry Lva8060352010-05-17 10:57:01 +080068SPI_FLASH|MG_DISK|NVRAM|MMC|NOWHERE}
wdenka68d3ed2002-10-11 08:38:32 +000069#endif
70
71#define XMK_STR(x) #x
72#define MK_STR(x) XMK_STR(x)
73
Wolfgang Denkea882ba2010-06-20 23:33:59 +020074/*
75 * Maximum expected input data size for import command
76 */
77#define MAX_ENV_SIZE (1 << 20) /* 1 MiB */
wdenka68d3ed2002-10-11 08:38:32 +000078
wdenka68d3ed2002-10-11 08:38:32 +000079/*
80 * Table with supported baudrates (defined in config_xyz.h)
81 */
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +020082static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE;
wdenka68d3ed2002-10-11 08:38:32 +000083#define N_BAUDRATES (sizeof(baudrate_table) / sizeof(baudrate_table[0]))
84
Heiko Schocherda954272009-04-28 08:36:11 +020085/*
Wolfgang Denkea882ba2010-06-20 23:33:59 +020086 * This variable is incremented on each do_env_set(), so it can
Heiko Schocherda954272009-04-28 08:36:11 +020087 * be used via get_env_id() as an indication, if the environment
88 * has changed or not. So it is possible to reread an environment
89 * variable only if the environment was changed ... done so for
90 * example in NetInitLoop()
91 */
Heiko Schocher2f70c492009-02-10 09:38:52 +010092static int env_id = 1;
wdenka68d3ed2002-10-11 08:38:32 +000093
Heiko Schocher2f70c492009-02-10 09:38:52 +010094int get_env_id (void)
95{
96 return env_id;
97}
wdenka68d3ed2002-10-11 08:38:32 +000098
Mike Frysinger4c94f6c2009-05-24 02:26:19 -040099/*
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200100 * Command interface: print one or all environment variables
101 *
102 * Returns 0 in case of error, or length of printed string
Mike Frysinger4c94f6c2009-05-24 02:26:19 -0400103 */
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200104static int env_print(char *name)
wdenka68d3ed2002-10-11 08:38:32 +0000105{
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200106 char *res = NULL;
107 size_t len;
wdenka68d3ed2002-10-11 08:38:32 +0000108
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200109 if (name) { /* print a single name */
110 ENTRY e, *ep;
wdenka68d3ed2002-10-11 08:38:32 +0000111
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200112 e.key = name;
113 e.data = NULL;
114 ep = hsearch (e, FIND);
115 if (ep == NULL)
116 return 0;
117 len = printf ("%s=%s\n", ep->key, ep->data);
118 return len;
Mike Frysinger4c94f6c2009-05-24 02:26:19 -0400119 }
wdenka68d3ed2002-10-11 08:38:32 +0000120
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200121 /* print whole list */
122 len = hexport('\n', &res, 0);
123
124 if (len > 0) {
125 puts(res);
126 free(res);
127 return len;
128 }
129
130 /* should never happen */
131 return 0;
Mike Frysinger4c94f6c2009-05-24 02:26:19 -0400132}
133
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200134int do_env_print (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
Mike Frysinger4c94f6c2009-05-24 02:26:19 -0400135{
136 int i;
137 int rcode = 0;
138
139 if (argc == 1) {
140 /* print all env vars */
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200141 rcode = env_print(NULL);
142 if (!rcode)
Mike Frysinger4c94f6c2009-05-24 02:26:19 -0400143 return 1;
144 printf("\nEnvironment size: %d/%ld bytes\n",
145 rcode, (ulong)ENV_SIZE);
wdenka68d3ed2002-10-11 08:38:32 +0000146 return 0;
147 }
148
Mike Frysinger4c94f6c2009-05-24 02:26:19 -0400149 /* print selected env vars */
150 for (i = 1; i < argc; ++i) {
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200151 int rc = env_print(argv[i]);
152 if (!rc) {
153 printf("## Error: \"%s\" not defined\n", argv[i]);
Mike Frysinger4c94f6c2009-05-24 02:26:19 -0400154 ++rcode;
wdenka68d3ed2002-10-11 08:38:32 +0000155 }
156 }
Mike Frysinger4c94f6c2009-05-24 02:26:19 -0400157
wdenka68d3ed2002-10-11 08:38:32 +0000158 return rcode;
159}
160
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200161/*
wdenka68d3ed2002-10-11 08:38:32 +0000162 * Set a new environment variable,
163 * or replace or delete an existing one.
wdenka68d3ed2002-10-11 08:38:32 +0000164 */
165
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200166int _do_env_set (int flag, int argc, char * const argv[])
wdenka68d3ed2002-10-11 08:38:32 +0000167{
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200168 bd_t *bd = gd->bd;
169 int i, len;
wdenka68d3ed2002-10-11 08:38:32 +0000170 int console = -1;
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200171 char *name, *value, *s;
172 ENTRY e, *ep;
wdenka68d3ed2002-10-11 08:38:32 +0000173
174 name = argv[1];
175
Wolfgang Denk471a7be2006-10-28 01:14:32 +0200176 if (strchr(name, '=')) {
177 printf ("## Error: illegal character '=' in variable name \"%s\"\n", name);
178 return 1;
179 }
180
Heiko Schocher2f70c492009-02-10 09:38:52 +0100181 env_id++;
wdenka68d3ed2002-10-11 08:38:32 +0000182 /*
183 * search if variable with this name already exists
184 */
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200185 e.key = name;
186 e.data = NULL;
187 ep = hsearch (e, FIND);
wdenka68d3ed2002-10-11 08:38:32 +0000188
Alessandro Rubini9c5586a2009-10-08 14:29:14 +0200189 /* Check for console redirection */
190 if (strcmp(name,"stdin") == 0) {
191 console = stdin;
192 } else if (strcmp(name,"stdout") == 0) {
193 console = stdout;
194 } else if (strcmp(name,"stderr") == 0) {
195 console = stderr;
196 }
197
198 if (console != -1) {
199 if (argc < 3) { /* Cannot delete it! */
200 printf("Can't delete \"%s\"\n", name);
201 return 1;
202 }
203
204#ifdef CONFIG_CONSOLE_MUX
205 i = iomux_doenv(console, argv[2]);
206 if (i)
207 return i;
208#else
209 /* Try assigning specified device */
210 if (console_assign (console, argv[2]) < 0)
211 return 1;
212
213#ifdef CONFIG_SERIAL_MULTI
214 if (serial_assign (argv[2]) < 0)
215 return 1;
216#endif
217#endif /* CONFIG_CONSOLE_MUX */
218 }
219
wdenka68d3ed2002-10-11 08:38:32 +0000220 /*
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200221 * Some variables like "ethaddr" and "serial#" can be set only
222 * once and cannot be deleted; also, "ver" is readonly.
wdenka68d3ed2002-10-11 08:38:32 +0000223 */
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200224 if (ep) { /* variable exists */
wdenka68d3ed2002-10-11 08:38:32 +0000225#ifndef CONFIG_ENV_OVERWRITE
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200226 if ((strcmp (name, "serial#") == 0) ||
wdenka68d3ed2002-10-11 08:38:32 +0000227 ((strcmp (name, "ethaddr") == 0)
228#if defined(CONFIG_OVERWRITE_ETHADDR_ONCE) && defined(CONFIG_ETHADDR)
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200229 && (strcmp (ep->data,MK_STR(CONFIG_ETHADDR)) != 0)
wdenka68d3ed2002-10-11 08:38:32 +0000230#endif /* CONFIG_OVERWRITE_ETHADDR_ONCE && CONFIG_ETHADDR */
231 ) ) {
232 printf ("Can't overwrite \"%s\"\n", name);
233 return 1;
234 }
235#endif
wdenka68d3ed2002-10-11 08:38:32 +0000236 /*
237 * Switch to new baudrate if new baudrate is supported
238 */
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200239 if (strcmp(name,"baudrate") == 0) {
wdenka68d3ed2002-10-11 08:38:32 +0000240 int baudrate = simple_strtoul(argv[2], NULL, 10);
241 int i;
242 for (i=0; i<N_BAUDRATES; ++i) {
243 if (baudrate == baudrate_table[i])
244 break;
245 }
246 if (i == N_BAUDRATES) {
247 printf ("## Baudrate %d bps not supported\n",
248 baudrate);
249 return 1;
250 }
251 printf ("## Switch baudrate to %d bps and press ENTER ...\n",
252 baudrate);
253 udelay(50000);
254 gd->baudrate = baudrate;
Bartlomiej Siekac84bad02006-12-20 00:29:43 +0100255#if defined(CONFIG_PPC) || defined(CONFIG_MCF52x2)
wdenkd0fb80c2003-01-11 09:48:40 +0000256 gd->bd->bi_baudrate = baudrate;
257#endif
258
wdenka68d3ed2002-10-11 08:38:32 +0000259 serial_setbrg ();
260 udelay(50000);
261 for (;;) {
262 if (getc() == '\r')
263 break;
264 }
265 }
wdenka68d3ed2002-10-11 08:38:32 +0000266 }
267
wdenka68d3ed2002-10-11 08:38:32 +0000268 /* Delete only ? */
269 if ((argc < 3) || argv[2] == NULL) {
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200270 int rc = hdelete(name);
271 return !rc;
wdenka68d3ed2002-10-11 08:38:32 +0000272 }
273
274 /*
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200275 * Insert / replace new value
wdenka68d3ed2002-10-11 08:38:32 +0000276 */
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200277 for (i=2,len=0; i<argc; ++i) {
wdenka68d3ed2002-10-11 08:38:32 +0000278 len += strlen(argv[i]) + 1;
279 }
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200280 if ((value = malloc(len)) == NULL) {
281 printf("## Can't malloc %d bytes\n", len);
wdenka68d3ed2002-10-11 08:38:32 +0000282 return 1;
283 }
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200284 for (i=2,s=value; i<argc; ++i) {
285 char *v = argv[i];
wdenka68d3ed2002-10-11 08:38:32 +0000286
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200287 while ((*s++ = *v++) != '\0')
wdenka68d3ed2002-10-11 08:38:32 +0000288 ;
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200289 *(s-1) = ' ';
wdenka68d3ed2002-10-11 08:38:32 +0000290 }
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200291 if (s != value)
292 *--s = '\0';
wdenka68d3ed2002-10-11 08:38:32 +0000293
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200294 e.key = name;
295 e.data = value;
296 ep = hsearch(e, ENTER);
297 free(value);
298 if (!ep) {
299 printf("## Error inserting \"%s\" variable, errno=%d\n",
300 name, errno);
301 return 1;
302 }
wdenka68d3ed2002-10-11 08:38:32 +0000303
304 /*
305 * Some variables should be updated when the corresponding
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200306 * entry in the environment is changed
wdenka68d3ed2002-10-11 08:38:32 +0000307 */
308
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200309 if (strcmp(name,"ipaddr") == 0) {
wdenka68d3ed2002-10-11 08:38:32 +0000310 char *s = argv[2]; /* always use only one arg */
311 char *e;
312 unsigned long addr;
313 bd->bi_ip_addr = 0;
314 for (addr=0, i=0; i<4; ++i) {
315 ulong val = s ? simple_strtoul(s, &e, 10) : 0;
316 addr <<= 8;
317 addr |= (val & 0xFF);
318 if (s) s = (*e) ? e+1 : e;
319 }
320 bd->bi_ip_addr = htonl(addr);
321 return 0;
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200322 } else if (strcmp(argv[1],"loadaddr") == 0) {
wdenka68d3ed2002-10-11 08:38:32 +0000323 load_addr = simple_strtoul(argv[2], NULL, 16);
324 return 0;
325 }
Jon Loeligerc76fe472007-07-08 18:02:23 -0500326#if defined(CONFIG_CMD_NET)
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200327 else if (strcmp(argv[1],"bootfile") == 0) {
wdenka68d3ed2002-10-11 08:38:32 +0000328 copy_filename (BootFile, argv[2], sizeof(BootFile));
329 return 0;
330 }
Jon Loeliger90253172007-07-10 11:02:44 -0500331#endif
wdenka68d3ed2002-10-11 08:38:32 +0000332 return 0;
333}
334
Steven A. Falco75678c82008-06-12 13:22:12 -0400335int setenv (char *varname, char *varvalue)
wdenka68d3ed2002-10-11 08:38:32 +0000336{
Wolfgang Denk54841ab2010-06-28 22:00:46 +0200337 char * const argv[4] = { "setenv", varname, varvalue, NULL };
Peter Tyserb0fa8e52009-10-25 15:12:55 -0500338 if ((varvalue == NULL) || (varvalue[0] == '\0'))
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200339 return _do_env_set(0, 2, argv);
Jeffrey Mann9ffd4512007-04-23 14:00:11 +0200340 else
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200341 return _do_env_set(0, 3, argv);
wdenka68d3ed2002-10-11 08:38:32 +0000342}
343
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200344int do_env_set (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenka68d3ed2002-10-11 08:38:32 +0000345{
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200346 if (argc < 2)
347 return cmd_usage(cmdtp);
wdenka68d3ed2002-10-11 08:38:32 +0000348
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200349 return _do_env_set(flag, argc, argv);
wdenka68d3ed2002-10-11 08:38:32 +0000350}
351
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200352/*
wdenka68d3ed2002-10-11 08:38:32 +0000353 * Prompt for environment variable
354 */
Jon Loeligerc76fe472007-07-08 18:02:23 -0500355#if defined(CONFIG_CMD_ASKENV)
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200356int do_env_ask ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenka68d3ed2002-10-11 08:38:32 +0000357{
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200358 extern char console_buffer[CONFIG_SYS_CBSIZE];
359 char message[CONFIG_SYS_CBSIZE];
360 int size = CONFIG_SYS_CBSIZE - 1;
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200361 int i, len, pos;
wdenka68d3ed2002-10-11 08:38:32 +0000362 char *local_args[4];
363
364 local_args[0] = argv[0];
365 local_args[1] = argv[1];
366 local_args[2] = NULL;
367 local_args[3] = NULL;
368
wdenka68d3ed2002-10-11 08:38:32 +0000369 /* Check the syntax */
370 switch (argc) {
371 case 1:
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200372 return cmd_usage(cmdtp);
wdenka68d3ed2002-10-11 08:38:32 +0000373
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200374 case 2: /* env_ask envname */
375 sprintf(message, "Please enter '%s':", argv[1]);
wdenka68d3ed2002-10-11 08:38:32 +0000376 break;
377
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200378 case 3: /* env_ask envname size */
379 sprintf(message, "Please enter '%s':", argv[1]);
380 size = simple_strtoul(argv[2], NULL, 10);
wdenka68d3ed2002-10-11 08:38:32 +0000381 break;
382
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200383 default: /* env_ask envname message1 ... messagen size */
384 for (i=2,pos=0; i < argc - 1; i++) {
wdenka68d3ed2002-10-11 08:38:32 +0000385 if (pos) {
386 message[pos++] = ' ';
387 }
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200388 strcpy(message+pos, argv[i]);
wdenka68d3ed2002-10-11 08:38:32 +0000389 pos += strlen(argv[i]);
390 }
391 message[pos] = '\0';
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200392 size = simple_strtoul(argv[argc - 1], NULL, 10);
wdenka68d3ed2002-10-11 08:38:32 +0000393 break;
394 }
395
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200396 if (size >= CONFIG_SYS_CBSIZE)
397 size = CONFIG_SYS_CBSIZE - 1;
wdenka68d3ed2002-10-11 08:38:32 +0000398
399 if (size <= 0)
400 return 1;
401
402 /* prompt for input */
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200403 len = readline(message);
wdenka68d3ed2002-10-11 08:38:32 +0000404
405 if (size < len)
406 console_buffer[size] = '\0';
407
408 len = 2;
409 if (console_buffer[0] != '\0') {
410 local_args[2] = console_buffer;
411 len = 3;
412 }
413
414 /* Continue calling setenv code */
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200415 return _do_env_set(flag, len, local_args);
wdenka68d3ed2002-10-11 08:38:32 +0000416}
Jon Loeliger90253172007-07-10 11:02:44 -0500417#endif
wdenka68d3ed2002-10-11 08:38:32 +0000418
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200419/*
Peter Tyser246c6922009-10-25 15:12:56 -0500420 * Interactively edit an environment variable
421 */
422#if defined(CONFIG_CMD_EDITENV)
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200423int do_env_edit(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
Peter Tyser246c6922009-10-25 15:12:56 -0500424{
425 char buffer[CONFIG_SYS_CBSIZE];
426 char *init_val;
427 int len;
428
Wolfgang Denk47e26b12010-07-17 01:06:04 +0200429 if (argc < 2)
430 return cmd_usage(cmdtp);
Peter Tyser246c6922009-10-25 15:12:56 -0500431
432 /* Set read buffer to initial value or empty sting */
433 init_val = getenv(argv[1]);
434 if (init_val)
435 len = sprintf(buffer, "%s", init_val);
436 else
437 buffer[0] = '\0';
438
439 readline_into_buffer("edit: ", buffer);
440
441 return setenv(argv[1], buffer);
442}
443#endif /* CONFIG_CMD_EDITENV */
444
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200445/*
wdenka68d3ed2002-10-11 08:38:32 +0000446 * Look up variable from environment,
447 * return address of storage for that variable,
448 * or NULL if not found
449 */
Wolfgang Denk77ddac92005-10-13 16:45:02 +0200450char *getenv (char *name)
wdenka68d3ed2002-10-11 08:38:32 +0000451{
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200452 if (gd->flags & GD_FLG_ENV_READY) { /* after import into hashtable */
453 ENTRY e, *ep;
wdenka68d3ed2002-10-11 08:38:32 +0000454
Wolfgang Denk91a76752010-07-24 20:22:02 +0200455 WATCHDOG_RESET();
wdenk2a3cb022002-11-05 21:01:48 +0000456
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200457 e.key = name;
458 e.data = NULL;
459 ep = hsearch (e, FIND);
wdenka68d3ed2002-10-11 08:38:32 +0000460
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200461 return (ep ? ep->data : NULL);
wdenka68d3ed2002-10-11 08:38:32 +0000462 }
463
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200464 /* restricted capabilities before import */
Wolfgang Denk91a76752010-07-24 20:22:02 +0200465
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200466 if (getenv_f(name, (char *)(gd->env_buf), sizeof(gd->env_buf)) > 0)
467 return (char *)(gd->env_buf);
468
469 return NULL;
wdenka68d3ed2002-10-11 08:38:32 +0000470}
471
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200472/*
473 * Look up variable from environment for restricted C runtime env.
474 */
475int getenv_f (char *name, char *buf, unsigned len)
wdenka68d3ed2002-10-11 08:38:32 +0000476{
477 int i, nxt;
478
479 for (i=0; env_get_char(i) != '\0'; i=nxt+1) {
480 int val, n;
481
482 for (nxt=i; env_get_char(nxt) != '\0'; ++nxt) {
Jean-Christophe PLAGNIOL-VILLARD0e8d1582008-09-10 22:48:06 +0200483 if (nxt >= CONFIG_ENV_SIZE) {
wdenka68d3ed2002-10-11 08:38:32 +0000484 return (-1);
485 }
486 }
Wolfgang Denk77ddac92005-10-13 16:45:02 +0200487 if ((val=envmatch((uchar *)name, i)) < 0)
wdenka68d3ed2002-10-11 08:38:32 +0000488 continue;
Wolfgang Denk9ed4a952010-07-24 22:16:20 +0200489
wdenka68d3ed2002-10-11 08:38:32 +0000490 /* found; copy out */
Wolfgang Denk9ed4a952010-07-24 22:16:20 +0200491 for (n=0; n<len; ++n, ++buf) {
492 if ((*buf = env_get_char(val++)) == '\0')
493 return n;
494 }
495
496 if (n)
497 *--buf = '\0';
498
499 printf("env_buf too small [%d]\n", len);
500
501 return n;
wdenka68d3ed2002-10-11 08:38:32 +0000502 }
503 return (-1);
504}
505
Mike Frysingerbdab39d2009-01-28 19:08:14 -0500506#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE)
Mike Frysingerba69dc22008-12-30 02:59:25 -0500507
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200508int do_env_save (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
wdenka68d3ed2002-10-11 08:38:32 +0000509{
510 extern char * env_name_spec;
511
512 printf ("Saving Environment to %s...\n", env_name_spec);
513
514 return (saveenv() ? 1 : 0);
515}
wdenk8bde7f72003-06-27 21:31:46 +0000516
Mike Frysingerba69dc22008-12-30 02:59:25 -0500517U_BOOT_CMD(
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200518 saveenv, 1, 0, do_env_save,
Peter Tyser2fb26042009-01-27 18:03:12 -0600519 "save environment variables to persistent storage",
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200520 ""
Mike Frysingerba69dc22008-12-30 02:59:25 -0500521);
522
wdenka68d3ed2002-10-11 08:38:32 +0000523#endif
524
525
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200526/*
wdenka68d3ed2002-10-11 08:38:32 +0000527 * Match a name / name=value pair
528 *
529 * s1 is either a simple 'name', or a 'name=value' pair.
530 * i2 is the environment index for a 'name2=value2' pair.
531 * If the names match, return the index for the value2, else NULL.
532 */
533
Rafal Jaworowski26a41792008-01-09 18:05:27 +0100534int envmatch (uchar *s1, int i2)
wdenka68d3ed2002-10-11 08:38:32 +0000535{
536
537 while (*s1 == env_get_char(i2++))
538 if (*s1++ == '=')
539 return(i2);
540 if (*s1 == '\0' && env_get_char(i2-1) == '=')
541 return(i2);
542 return(-1);
543}
wdenk8bde7f72003-06-27 21:31:46 +0000544
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200545static int do_env_default(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
546{
547 if ((argc != 2) || (strcmp(argv[1], "-f") != 0)) {
Thomas Weber0d302af2010-11-25 08:05:28 +0100548 return cmd_usage(cmdtp);
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200549 }
550 set_default_env("## Resetting to default environment\n");
551 return 0;
552}
wdenk8bde7f72003-06-27 21:31:46 +0000553
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200554static int do_env_delete(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
555{
556 printf("Not implemented yet\n");
557 return 0;
558}
559
560/*
561 * env export [-t | -b | -c] addr [size]
562 * -t: export as text format; if size is given, data will be
563 * padded with '\0' bytes; if not, one terminating '\0'
564 * will be added (which is included in the "filesize"
565 * setting so you can for exmple copy this to flash and
566 * keep the termination).
567 * -b: export as binary format (name=value pairs separated by
568 * '\0', list end marked by double "\0\0")
569 * -c: export as checksum protected environment format as
570 * used for example by "saveenv" command
571 * addr: memory address where environment gets stored
572 * size: size of output buffer
573 *
574 * With "-c" and size is NOT given, then the export command will
575 * format the data as currently used for the persistent storage,
576 * i. e. it will use CONFIG_ENV_SECT_SIZE as output block size and
577 * prepend a valid CRC32 checksum and, in case of resundant
578 * environment, a "current" redundancy flag. If size is given, this
579 * value will be used instead of CONFIG_ENV_SECT_SIZE; again, CRC32
580 * checksum and redundancy flag will be inserted.
581 *
582 * With "-b" and "-t", always only the real data (including a
583 * terminating '\0' byte) will be written; here the optional size
584 * argument will be used to make sure not to overflow the user
585 * provided buffer; the command will abort if the size is not
586 * sufficient. Any remainign space will be '\0' padded.
587 *
588 * On successful return, the variable "filesize" will be set.
589 * Note that filesize includes the trailing/terminating '\0' byte(s).
590 *
591 * Usage szenario: create a text snapshot/backup of the current settings:
592 *
593 * => env export -t 100000
594 * => era ${backup_addr} +${filesize}
595 * => cp.b 100000 ${backup_addr} ${filesize}
596 *
597 * Re-import this snapshot, deleting all other settings:
598 *
599 * => env import -d -t ${backup_addr}
600 */
601static int do_env_export(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
602{
603 char buf[32];
604 char *addr, *cmd, *res;
605 size_t size;
606 ssize_t len;
607 env_t *envp;
608 char sep = '\n';
609 int chk = 0;
610 int fmt = 0;
611
612 cmd = *argv;
613
614 while (--argc > 0 && **++argv == '-') {
615 char *arg = *argv;
616 while (*++arg) {
617 switch (*arg) {
618 case 'b': /* raw binary format */
619 if (fmt++)
620 goto sep_err;
621 sep = '\0';
622 break;
623 case 'c': /* external checksum format */
624 if (fmt++)
625 goto sep_err;
626 sep = '\0';
627 chk = 1;
628 break;
629 case 't': /* text format */
630 if (fmt++)
631 goto sep_err;
632 sep = '\n';
633 break;
634 default:
Thomas Weber0d302af2010-11-25 08:05:28 +0100635 return cmd_usage(cmdtp);
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200636 }
637 }
638 }
639
640 if (argc < 1) {
Thomas Weber0d302af2010-11-25 08:05:28 +0100641 return cmd_usage(cmdtp);
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200642 }
643
644 addr = (char *)simple_strtoul(argv[0], NULL, 16);
645
646 if (argc == 2) {
647 size = simple_strtoul(argv[1], NULL, 16);
648 memset(addr, '\0', size);
649 } else {
650 size = 0;
651 }
652
653 if (sep) { /* export as text file */
654 len = hexport(sep, &addr, size);
655 if (len < 0) {
656 error("Cannot export environment: errno = %d\n",
657 errno);
658 return 1;
659 }
660 sprintf(buf, "%zX", len);
661 setenv("filesize", buf);
662
663 return 0;
664 }
665
666 envp = (env_t *)addr;
667
668 if (chk) /* export as checksum protected block */
669 res = (char *)envp->data;
670 else /* export as raw binary data */
671 res = addr;
672
673 len = hexport('\0', &res, ENV_SIZE);
674 if (len < 0) {
675 error("Cannot export environment: errno = %d\n",
676 errno);
677 return 1;
678 }
679
680 if (chk) {
681 envp->crc = crc32(0, envp->data, ENV_SIZE);
682#ifdef CONFIG_ENV_ADDR_REDUND
683 envp->flags = ACTIVE_FLAG;
684#endif
685 }
686 sprintf(buf, "%zX", len + offsetof(env_t,data));
687 setenv("filesize", buf);
688
689 return 0;
690
691sep_err:
692 printf("## %s: only one of \"-b\", \"-c\" or \"-t\" allowed\n",
693 cmd);
694 return 1;
695}
696
697/*
698 * env import [-d] [-t | -b | -c] addr [size]
699 * -d: delete existing environment before importing;
700 * otherwise overwrite / append to existion definitions
701 * -t: assume text format; either "size" must be given or the
702 * text data must be '\0' terminated
703 * -b: assume binary format ('\0' separated, "\0\0" terminated)
704 * -c: assume checksum protected environment format
705 * addr: memory address to read from
706 * size: length of input data; if missing, proper '\0'
707 * termination is mandatory
708 */
709static int do_env_import(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
710{
711 char *cmd, *addr;
712 char sep = '\n';
713 int chk = 0;
714 int fmt = 0;
715 int del = 0;
716 size_t size;
717
718 cmd = *argv;
719
720 while (--argc > 0 && **++argv == '-') {
721 char *arg = *argv;
722 while (*++arg) {
723 switch (*arg) {
724 case 'b': /* raw binary format */
725 if (fmt++)
726 goto sep_err;
727 sep = '\0';
728 break;
729 case 'c': /* external checksum format */
730 if (fmt++)
731 goto sep_err;
732 sep = '\0';
733 chk = 1;
734 break;
735 case 't': /* text format */
736 if (fmt++)
737 goto sep_err;
738 sep = '\n';
739 break;
740 case 'd':
741 del = 1;
742 break;
743 default:
Thomas Weber0d302af2010-11-25 08:05:28 +0100744 return cmd_usage(cmdtp);
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200745 }
746 }
747 }
748
749 if (argc < 1) {
Thomas Weber0d302af2010-11-25 08:05:28 +0100750 return cmd_usage(cmdtp);
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200751 }
752
753 if (!fmt)
754 printf("## Warning: defaulting to text format\n");
755
756 addr = (char *)simple_strtoul(argv[0], NULL, 16);
757
758 if (argc == 2) {
759 size = simple_strtoul(argv[1], NULL, 16);
760 } else {
761 char *s = addr;
762
763 size = 0;
764
765 while (size < MAX_ENV_SIZE) {
766 if ((*s == sep) && (*(s+1) == '\0'))
767 break;
768 ++s;
769 ++size;
770 }
771 if (size == MAX_ENV_SIZE) {
772 printf("## Warning: Input data exceeds %d bytes"
773 " - truncated\n", MAX_ENV_SIZE);
774 }
775 ++size;
776 printf("## Info: input data size = %zd = 0x%zX\n", size, size);
777 }
778
779 if (chk) {
780 uint32_t crc;
781 env_t *ep = (env_t *)addr;
782
783 size -= offsetof(env_t, data);
784 memcpy(&crc, &ep->crc, sizeof(crc));
785
786 if (crc32(0, ep->data, size) != crc) {
787 puts("## Error: bad CRC, import failed\n");
788 return 1;
789 }
790 addr = (char *)ep->data;
791 }
792
793 if (himport(addr, size, sep, del ? 0 : H_NOCLEAR) == 0) {
794 error("Environment import failed: errno = %d\n", errno);
795 return 1;
796 }
797 gd->flags |= GD_FLG_ENV_READY;
798
799 return 0;
800
801sep_err:
802 printf("## %s: only one of \"-b\", \"-c\" or \"-t\" allowed\n",
803 cmd);
804 return 1;
805}
806
807#if defined(CONFIG_CMD_RUN)
808extern int do_run (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
809#endif
810
811/*
812 * New command line interface: "env" command with subcommands
813 */
814static cmd_tbl_t cmd_env_sub[] = {
815#if defined(CONFIG_CMD_ASKENV)
816 U_BOOT_CMD_MKENT(ask, CONFIG_SYS_MAXARGS, 1, do_env_ask, "", ""),
817#endif
818 U_BOOT_CMD_MKENT(default, 1, 0, do_env_default, "", ""),
819 U_BOOT_CMD_MKENT(delete, 2, 0, do_env_delete, "", ""),
820#if defined(CONFIG_CMD_EDITENV)
821 U_BOOT_CMD_MKENT(edit, 2, 0, do_env_edit, "", ""),
822#endif
823 U_BOOT_CMD_MKENT(export, 4, 0, do_env_export, "", ""),
824 U_BOOT_CMD_MKENT(import, 5, 0, do_env_import, "", ""),
825 U_BOOT_CMD_MKENT(print, CONFIG_SYS_MAXARGS, 1, do_env_print, "", ""),
826#if defined(CONFIG_CMD_RUN)
827 U_BOOT_CMD_MKENT(run, CONFIG_SYS_MAXARGS, 1, do_run, "", ""),
828#endif
829#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE)
830 U_BOOT_CMD_MKENT(save, 1, 0, do_env_save, "", ""),
831#endif
832 U_BOOT_CMD_MKENT(set, CONFIG_SYS_MAXARGS, 0, do_env_set, "", ""),
833};
834
Wolfgang Denk2e5167c2010-10-28 20:00:11 +0200835#if defined(CONFIG_NEEDS_MANUAL_RELOC)
Heiko Schocher60f7da12010-10-05 14:17:00 +0200836void env_reloc(void)
837{
838 fixup_cmdtable(cmd_env_sub, ARRAY_SIZE(cmd_env_sub));
839}
840#endif
841
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200842static int do_env (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
843{
844 cmd_tbl_t *cp;
845
Thomas Weber5904da02010-11-24 13:07:52 +0100846 if (argc < 2)
847 return cmd_usage(cmdtp);
848
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200849 /* drop initial "env" arg */
850 argc--;
851 argv++;
852
853 cp = find_cmd_tbl(argv[0], cmd_env_sub, ARRAY_SIZE(cmd_env_sub));
854
855 if (cp)
856 return cp->cmd(cmdtp, flag, argc, argv);
857
Thomas Weber0d302af2010-11-25 08:05:28 +0100858 return cmd_usage(cmdtp);
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200859}
860
861U_BOOT_CMD(
862 env, CONFIG_SYS_MAXARGS, 1, do_env,
863 "environment handling commands",
864#if defined(CONFIG_CMD_ASKENV)
865 "ask name [message] [size] - ask for environment variable\nenv "
866#endif
867 "default -f - reset default environment\n"
868#if defined(CONFIG_CMD_EDITENV)
869 "env edit name - edit environment variable\n"
870#endif
871 "env export [-t | -b | -c] addr [size] - export environmnt\n"
872 "env import [-d] [-t | -b | -c] addr [size] - import environmnt\n"
873 "env print [name ...] - print environment\n"
874#if defined(CONFIG_CMD_RUN)
875 "env run var [...] - run commands in an environment variable\n"
876#endif
877 "env save - save environment\n"
878 "env set [-f] name [arg ...]\n"
879);
880
881/*
882 * Old command line interface, kept for compatibility
883 */
wdenk8bde7f72003-06-27 21:31:46 +0000884
Peter Tyser246c6922009-10-25 15:12:56 -0500885#if defined(CONFIG_CMD_EDITENV)
886U_BOOT_CMD(
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200887 editenv, 2, 0, do_env_edit,
Peter Tyser246c6922009-10-25 15:12:56 -0500888 "edit environment variable",
889 "name\n"
890 " - edit environment variable 'name'"
891);
892#endif
893
wdenk0d498392003-07-01 21:06:45 +0000894U_BOOT_CMD(
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200895 printenv, CONFIG_SYS_MAXARGS, 1, do_env_print,
Peter Tyser2fb26042009-01-27 18:03:12 -0600896 "print environment variables",
wdenk8bde7f72003-06-27 21:31:46 +0000897 "\n - print values of all environment variables\n"
898 "printenv name ...\n"
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200899 " - print value of environment variable 'name'"
wdenk8bde7f72003-06-27 21:31:46 +0000900);
901
wdenk0d498392003-07-01 21:06:45 +0000902U_BOOT_CMD(
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200903 setenv, CONFIG_SYS_MAXARGS, 0, do_env_set,
Peter Tyser2fb26042009-01-27 18:03:12 -0600904 "set environment variables",
wdenk8bde7f72003-06-27 21:31:46 +0000905 "name value ...\n"
906 " - set environment variable 'name' to 'value ...'\n"
907 "setenv name\n"
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200908 " - delete environment variable 'name'"
wdenk8bde7f72003-06-27 21:31:46 +0000909);
910
Jon Loeligerc76fe472007-07-08 18:02:23 -0500911#if defined(CONFIG_CMD_ASKENV)
wdenk8bde7f72003-06-27 21:31:46 +0000912
wdenk0d498392003-07-01 21:06:45 +0000913U_BOOT_CMD(
Wolfgang Denkea882ba2010-06-20 23:33:59 +0200914 askenv, CONFIG_SYS_MAXARGS, 1, do_env_ask,
Peter Tyser2fb26042009-01-27 18:03:12 -0600915 "get environment variables from stdin",
wdenk8bde7f72003-06-27 21:31:46 +0000916 "name [message] [size]\n"
917 " - get environment variable 'name' from stdin (max 'size' chars)\n"
918 "askenv name\n"
919 " - get environment variable 'name' from stdin\n"
920 "askenv name size\n"
921 " - get environment variable 'name' from stdin (max 'size' chars)\n"
922 "askenv name [message] size\n"
923 " - display 'message' string and get environment variable 'name'"
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200924 "from stdin (max 'size' chars)"
wdenk8bde7f72003-06-27 21:31:46 +0000925);
Jon Loeliger90253172007-07-10 11:02:44 -0500926#endif
wdenk8bde7f72003-06-27 21:31:46 +0000927
Jon Loeligerc76fe472007-07-08 18:02:23 -0500928#if defined(CONFIG_CMD_RUN)
wdenk0d498392003-07-01 21:06:45 +0000929U_BOOT_CMD(
Jean-Christophe PLAGNIOL-VILLARD6d0f6bc2008-10-16 15:01:15 +0200930 run, CONFIG_SYS_MAXARGS, 1, do_run,
Peter Tyser2fb26042009-01-27 18:03:12 -0600931 "run commands in an environment variable",
wdenk8bde7f72003-06-27 21:31:46 +0000932 "var [...]\n"
Wolfgang Denka89c33d2009-05-24 17:06:54 +0200933 " - run the commands in the environment variable(s) 'var'"
wdenk8bde7f72003-06-27 21:31:46 +0000934);
Jon Loeliger90253172007-07-10 11:02:44 -0500935#endif