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