183d290c5STom Rini // SPDX-License-Identifier: GPL-2.0+
22e192b24SSimon Glass /*
32e192b24SSimon Glass * (C) Copyright 2000-2013
42e192b24SSimon Glass * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
52e192b24SSimon Glass *
62e192b24SSimon Glass * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
72e192b24SSimon Glass * Andreas Heppel <aheppel@sysgo.de>
82e192b24SSimon Glass *
92e192b24SSimon Glass * Copyright 2011 Freescale Semiconductor, Inc.
102e192b24SSimon Glass */
112e192b24SSimon Glass
122e192b24SSimon Glass /*
132e192b24SSimon Glass * Support for persistent environment data
142e192b24SSimon Glass *
152e192b24SSimon Glass * The "environment" is stored on external storage as a list of '\0'
162e192b24SSimon Glass * terminated "name=value" strings. The end of the list is marked by
17fc0b5948SRobert P. J. Day * a double '\0'. The environment is preceded by a 32 bit CRC over
182e192b24SSimon Glass * the data part and, in case of redundant environment, a byte of
192e192b24SSimon Glass * flags.
202e192b24SSimon Glass *
212e192b24SSimon Glass * This linearized representation will also be used before
222e192b24SSimon Glass * relocation, i. e. as long as we don't have a full C runtime
232e192b24SSimon Glass * environment. After that, we use a hash table.
242e192b24SSimon Glass */
252e192b24SSimon Glass
262e192b24SSimon Glass #include <common.h>
272e192b24SSimon Glass #include <cli.h>
282e192b24SSimon Glass #include <command.h>
292e192b24SSimon Glass #include <console.h>
302e192b24SSimon Glass #include <environment.h>
312e192b24SSimon Glass #include <search.h>
322e192b24SSimon Glass #include <errno.h>
332e192b24SSimon Glass #include <malloc.h>
342e192b24SSimon Glass #include <mapmem.h>
352e192b24SSimon Glass #include <watchdog.h>
362e192b24SSimon Glass #include <linux/stddef.h>
372e192b24SSimon Glass #include <asm/byteorder.h>
382e192b24SSimon Glass #include <asm/io.h>
392e192b24SSimon Glass
402e192b24SSimon Glass DECLARE_GLOBAL_DATA_PTR;
412e192b24SSimon Glass
422e192b24SSimon Glass #if !defined(CONFIG_ENV_IS_IN_EEPROM) && \
432e192b24SSimon Glass !defined(CONFIG_ENV_IS_IN_FLASH) && \
442e192b24SSimon Glass !defined(CONFIG_ENV_IS_IN_MMC) && \
452e192b24SSimon Glass !defined(CONFIG_ENV_IS_IN_FAT) && \
46fd1000b9SStuart Longland !defined(CONFIG_ENV_IS_IN_EXT4) && \
472e192b24SSimon Glass !defined(CONFIG_ENV_IS_IN_NAND) && \
482e192b24SSimon Glass !defined(CONFIG_ENV_IS_IN_NVRAM) && \
492e192b24SSimon Glass !defined(CONFIG_ENV_IS_IN_ONENAND) && \
50125d193cSPeng Fan !defined(CONFIG_ENV_IS_IN_SATA) && \
512e192b24SSimon Glass !defined(CONFIG_ENV_IS_IN_SPI_FLASH) && \
522e192b24SSimon Glass !defined(CONFIG_ENV_IS_IN_REMOTE) && \
532e192b24SSimon Glass !defined(CONFIG_ENV_IS_IN_UBI) && \
542e192b24SSimon Glass !defined(CONFIG_ENV_IS_NOWHERE)
557b7341d7STuomas Tynkkynen # error Define one of CONFIG_ENV_IS_IN_{EEPROM|FLASH|MMC|FAT|EXT4|\
56d1b88cd3SLothar Waßmann NAND|NVRAM|ONENAND|SATA|SPI_FLASH|REMOTE|UBI} or CONFIG_ENV_IS_NOWHERE
572e192b24SSimon Glass #endif
582e192b24SSimon Glass
592e192b24SSimon Glass /*
602e192b24SSimon Glass * Maximum expected input data size for import command
612e192b24SSimon Glass */
622e192b24SSimon Glass #define MAX_ENV_SIZE (1 << 20) /* 1 MiB */
632e192b24SSimon Glass
642e192b24SSimon Glass /*
652e192b24SSimon Glass * This variable is incremented on each do_env_set(), so it can
662e192b24SSimon Glass * be used via get_env_id() as an indication, if the environment
672e192b24SSimon Glass * has changed or not. So it is possible to reread an environment
682e192b24SSimon Glass * variable only if the environment was changed ... done so for
692e192b24SSimon Glass * example in NetInitLoop()
702e192b24SSimon Glass */
712e192b24SSimon Glass static int env_id = 1;
722e192b24SSimon Glass
get_env_id(void)732e192b24SSimon Glass int get_env_id(void)
742e192b24SSimon Glass {
752e192b24SSimon Glass return env_id;
762e192b24SSimon Glass }
772e192b24SSimon Glass
782e192b24SSimon Glass #ifndef CONFIG_SPL_BUILD
792e192b24SSimon Glass /*
802e192b24SSimon Glass * Command interface: print one or all environment variables
812e192b24SSimon Glass *
822e192b24SSimon Glass * Returns 0 in case of error, or length of printed string
832e192b24SSimon Glass */
env_print(char * name,int flag)842e192b24SSimon Glass static int env_print(char *name, int flag)
852e192b24SSimon Glass {
862e192b24SSimon Glass char *res = NULL;
872e192b24SSimon Glass ssize_t len;
882e192b24SSimon Glass
892e192b24SSimon Glass if (name) { /* print a single name */
902e192b24SSimon Glass ENTRY e, *ep;
912e192b24SSimon Glass
922e192b24SSimon Glass e.key = name;
932e192b24SSimon Glass e.data = NULL;
942e192b24SSimon Glass hsearch_r(e, FIND, &ep, &env_htab, flag);
952e192b24SSimon Glass if (ep == NULL)
962e192b24SSimon Glass return 0;
972e192b24SSimon Glass len = printf("%s=%s\n", ep->key, ep->data);
982e192b24SSimon Glass return len;
992e192b24SSimon Glass }
1002e192b24SSimon Glass
1012e192b24SSimon Glass /* print whole list */
1022e192b24SSimon Glass len = hexport_r(&env_htab, '\n', flag, &res, 0, 0, NULL);
1032e192b24SSimon Glass
1042e192b24SSimon Glass if (len > 0) {
1052e192b24SSimon Glass puts(res);
1062e192b24SSimon Glass free(res);
1072e192b24SSimon Glass return len;
1082e192b24SSimon Glass }
1092e192b24SSimon Glass
1102e192b24SSimon Glass /* should never happen */
1112e192b24SSimon Glass printf("## Error: cannot export environment\n");
1122e192b24SSimon Glass return 0;
1132e192b24SSimon Glass }
1142e192b24SSimon Glass
do_env_print(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])1152e192b24SSimon Glass static int do_env_print(cmd_tbl_t *cmdtp, int flag, int argc,
1162e192b24SSimon Glass char * const argv[])
1172e192b24SSimon Glass {
1182e192b24SSimon Glass int i;
1192e192b24SSimon Glass int rcode = 0;
1202e192b24SSimon Glass int env_flag = H_HIDE_DOT;
1212e192b24SSimon Glass
122*49d81fdfSAKASHI Takahiro #if defined(CONFIG_CMD_NVEDIT_EFI)
123*49d81fdfSAKASHI Takahiro if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'e')
124*49d81fdfSAKASHI Takahiro return do_env_print_efi(cmdtp, flag, --argc, ++argv);
125*49d81fdfSAKASHI Takahiro #endif
126*49d81fdfSAKASHI Takahiro
1272e192b24SSimon Glass if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'a') {
1282e192b24SSimon Glass argc--;
1292e192b24SSimon Glass argv++;
1302e192b24SSimon Glass env_flag &= ~H_HIDE_DOT;
1312e192b24SSimon Glass }
1322e192b24SSimon Glass
1332e192b24SSimon Glass if (argc == 1) {
1342e192b24SSimon Glass /* print all env vars */
1352e192b24SSimon Glass rcode = env_print(NULL, env_flag);
1362e192b24SSimon Glass if (!rcode)
1372e192b24SSimon Glass return 1;
1382e192b24SSimon Glass printf("\nEnvironment size: %d/%ld bytes\n",
1392e192b24SSimon Glass rcode, (ulong)ENV_SIZE);
1402e192b24SSimon Glass return 0;
1412e192b24SSimon Glass }
1422e192b24SSimon Glass
1432e192b24SSimon Glass /* print selected env vars */
1442e192b24SSimon Glass env_flag &= ~H_HIDE_DOT;
1452e192b24SSimon Glass for (i = 1; i < argc; ++i) {
1462e192b24SSimon Glass int rc = env_print(argv[i], env_flag);
1472e192b24SSimon Glass if (!rc) {
1482e192b24SSimon Glass printf("## Error: \"%s\" not defined\n", argv[i]);
1492e192b24SSimon Glass ++rcode;
1502e192b24SSimon Glass }
1512e192b24SSimon Glass }
1522e192b24SSimon Glass
1532e192b24SSimon Glass return rcode;
1542e192b24SSimon Glass }
1552e192b24SSimon Glass
1562e192b24SSimon Glass #ifdef CONFIG_CMD_GREPENV
do_env_grep(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])1572e192b24SSimon Glass static int do_env_grep(cmd_tbl_t *cmdtp, int flag,
1582e192b24SSimon Glass int argc, char * const argv[])
1592e192b24SSimon Glass {
1602e192b24SSimon Glass char *res = NULL;
1612e192b24SSimon Glass int len, grep_how, grep_what;
1622e192b24SSimon Glass
1632e192b24SSimon Glass if (argc < 2)
1642e192b24SSimon Glass return CMD_RET_USAGE;
1652e192b24SSimon Glass
1662e192b24SSimon Glass grep_how = H_MATCH_SUBSTR; /* default: substring search */
1672e192b24SSimon Glass grep_what = H_MATCH_BOTH; /* default: grep names and values */
1682e192b24SSimon Glass
1692e192b24SSimon Glass while (--argc > 0 && **++argv == '-') {
1702e192b24SSimon Glass char *arg = *argv;
1712e192b24SSimon Glass while (*++arg) {
1722e192b24SSimon Glass switch (*arg) {
1732e192b24SSimon Glass #ifdef CONFIG_REGEX
1742e192b24SSimon Glass case 'e': /* use regex matching */
1752e192b24SSimon Glass grep_how = H_MATCH_REGEX;
1762e192b24SSimon Glass break;
1772e192b24SSimon Glass #endif
1782e192b24SSimon Glass case 'n': /* grep for name */
1792e192b24SSimon Glass grep_what = H_MATCH_KEY;
1802e192b24SSimon Glass break;
1812e192b24SSimon Glass case 'v': /* grep for value */
1822e192b24SSimon Glass grep_what = H_MATCH_DATA;
1832e192b24SSimon Glass break;
1842e192b24SSimon Glass case 'b': /* grep for both */
1852e192b24SSimon Glass grep_what = H_MATCH_BOTH;
1862e192b24SSimon Glass break;
1872e192b24SSimon Glass case '-':
1882e192b24SSimon Glass goto DONE;
1892e192b24SSimon Glass default:
1902e192b24SSimon Glass return CMD_RET_USAGE;
1912e192b24SSimon Glass }
1922e192b24SSimon Glass }
1932e192b24SSimon Glass }
1942e192b24SSimon Glass
1952e192b24SSimon Glass DONE:
1962e192b24SSimon Glass len = hexport_r(&env_htab, '\n',
1972e192b24SSimon Glass flag | grep_what | grep_how,
1982e192b24SSimon Glass &res, 0, argc, argv);
1992e192b24SSimon Glass
2002e192b24SSimon Glass if (len > 0) {
2012e192b24SSimon Glass puts(res);
2022e192b24SSimon Glass free(res);
2032e192b24SSimon Glass }
2042e192b24SSimon Glass
2052e192b24SSimon Glass if (len < 2)
2062e192b24SSimon Glass return 1;
2072e192b24SSimon Glass
2082e192b24SSimon Glass return 0;
2092e192b24SSimon Glass }
2102e192b24SSimon Glass #endif
2112e192b24SSimon Glass #endif /* CONFIG_SPL_BUILD */
2122e192b24SSimon Glass
2132e192b24SSimon Glass /*
2142e192b24SSimon Glass * Set a new environment variable,
2152e192b24SSimon Glass * or replace or delete an existing one.
2162e192b24SSimon Glass */
_do_env_set(int flag,int argc,char * const argv[],int env_flag)2172e192b24SSimon Glass static int _do_env_set(int flag, int argc, char * const argv[], int env_flag)
2182e192b24SSimon Glass {
2192e192b24SSimon Glass int i, len;
2202e192b24SSimon Glass char *name, *value, *s;
2212e192b24SSimon Glass ENTRY e, *ep;
2222e192b24SSimon Glass
2232e192b24SSimon Glass debug("Initial value for argc=%d\n", argc);
224*49d81fdfSAKASHI Takahiro
225*49d81fdfSAKASHI Takahiro #if CONFIG_IS_ENABLED(CMD_NVEDIT_EFI)
226*49d81fdfSAKASHI Takahiro if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'e')
227*49d81fdfSAKASHI Takahiro return do_env_set_efi(NULL, flag, --argc, ++argv);
228*49d81fdfSAKASHI Takahiro #endif
229*49d81fdfSAKASHI Takahiro
2302e192b24SSimon Glass while (argc > 1 && **(argv + 1) == '-') {
2312e192b24SSimon Glass char *arg = *++argv;
2322e192b24SSimon Glass
2332e192b24SSimon Glass --argc;
2342e192b24SSimon Glass while (*++arg) {
2352e192b24SSimon Glass switch (*arg) {
2362e192b24SSimon Glass case 'f': /* force */
2372e192b24SSimon Glass env_flag |= H_FORCE;
2382e192b24SSimon Glass break;
2392e192b24SSimon Glass default:
2402e192b24SSimon Glass return CMD_RET_USAGE;
2412e192b24SSimon Glass }
2422e192b24SSimon Glass }
2432e192b24SSimon Glass }
2442e192b24SSimon Glass debug("Final value for argc=%d\n", argc);
2452e192b24SSimon Glass name = argv[1];
2462e192b24SSimon Glass
2472e192b24SSimon Glass if (strchr(name, '=')) {
2482e192b24SSimon Glass printf("## Error: illegal character '='"
2492e192b24SSimon Glass "in variable name \"%s\"\n", name);
2502e192b24SSimon Glass return 1;
2512e192b24SSimon Glass }
2522e192b24SSimon Glass
2532e192b24SSimon Glass env_id++;
2542e192b24SSimon Glass
2552e192b24SSimon Glass /* Delete only ? */
2562e192b24SSimon Glass if (argc < 3 || argv[2] == NULL) {
2572e192b24SSimon Glass int rc = hdelete_r(name, &env_htab, env_flag);
2582e192b24SSimon Glass return !rc;
2592e192b24SSimon Glass }
2602e192b24SSimon Glass
2612e192b24SSimon Glass /*
2622e192b24SSimon Glass * Insert / replace new value
2632e192b24SSimon Glass */
2642e192b24SSimon Glass for (i = 2, len = 0; i < argc; ++i)
2652e192b24SSimon Glass len += strlen(argv[i]) + 1;
2662e192b24SSimon Glass
2672e192b24SSimon Glass value = malloc(len);
2682e192b24SSimon Glass if (value == NULL) {
2692e192b24SSimon Glass printf("## Can't malloc %d bytes\n", len);
2702e192b24SSimon Glass return 1;
2712e192b24SSimon Glass }
2722e192b24SSimon Glass for (i = 2, s = value; i < argc; ++i) {
2732e192b24SSimon Glass char *v = argv[i];
2742e192b24SSimon Glass
2752e192b24SSimon Glass while ((*s++ = *v++) != '\0')
2762e192b24SSimon Glass ;
2772e192b24SSimon Glass *(s - 1) = ' ';
2782e192b24SSimon Glass }
2792e192b24SSimon Glass if (s != value)
2802e192b24SSimon Glass *--s = '\0';
2812e192b24SSimon Glass
2822e192b24SSimon Glass e.key = name;
2832e192b24SSimon Glass e.data = value;
2842e192b24SSimon Glass hsearch_r(e, ENTER, &ep, &env_htab, env_flag);
2852e192b24SSimon Glass free(value);
2862e192b24SSimon Glass if (!ep) {
2872e192b24SSimon Glass printf("## Error inserting \"%s\" variable, errno=%d\n",
2882e192b24SSimon Glass name, errno);
2892e192b24SSimon Glass return 1;
2902e192b24SSimon Glass }
2912e192b24SSimon Glass
2922e192b24SSimon Glass return 0;
2932e192b24SSimon Glass }
2942e192b24SSimon Glass
env_set(const char * varname,const char * varvalue)295382bee57SSimon Glass int env_set(const char *varname, const char *varvalue)
2962e192b24SSimon Glass {
2972e192b24SSimon Glass const char * const argv[4] = { "setenv", varname, varvalue, NULL };
2982e192b24SSimon Glass
2992e192b24SSimon Glass /* before import into hashtable */
3002e192b24SSimon Glass if (!(gd->flags & GD_FLG_ENV_READY))
3012e192b24SSimon Glass return 1;
3022e192b24SSimon Glass
3032e192b24SSimon Glass if (varvalue == NULL || varvalue[0] == '\0')
3042e192b24SSimon Glass return _do_env_set(0, 2, (char * const *)argv, H_PROGRAMMATIC);
3052e192b24SSimon Glass else
3062e192b24SSimon Glass return _do_env_set(0, 3, (char * const *)argv, H_PROGRAMMATIC);
3072e192b24SSimon Glass }
3082e192b24SSimon Glass
3092e192b24SSimon Glass /**
3102e192b24SSimon Glass * Set an environment variable to an integer value
3112e192b24SSimon Glass *
3122e192b24SSimon Glass * @param varname Environment variable to set
3132e192b24SSimon Glass * @param value Value to set it to
3142e192b24SSimon Glass * @return 0 if ok, 1 on error
3152e192b24SSimon Glass */
env_set_ulong(const char * varname,ulong value)316018f5303SSimon Glass int env_set_ulong(const char *varname, ulong value)
3172e192b24SSimon Glass {
3182e192b24SSimon Glass /* TODO: this should be unsigned */
3192e192b24SSimon Glass char *str = simple_itoa(value);
3202e192b24SSimon Glass
321382bee57SSimon Glass return env_set(varname, str);
3222e192b24SSimon Glass }
3232e192b24SSimon Glass
3242e192b24SSimon Glass /**
3252e192b24SSimon Glass * Set an environment variable to an value in hex
3262e192b24SSimon Glass *
3272e192b24SSimon Glass * @param varname Environment variable to set
3282e192b24SSimon Glass * @param value Value to set it to
3292e192b24SSimon Glass * @return 0 if ok, 1 on error
3302e192b24SSimon Glass */
env_set_hex(const char * varname,ulong value)331018f5303SSimon Glass int env_set_hex(const char *varname, ulong value)
3322e192b24SSimon Glass {
3332e192b24SSimon Glass char str[17];
3342e192b24SSimon Glass
3352e192b24SSimon Glass sprintf(str, "%lx", value);
336382bee57SSimon Glass return env_set(varname, str);
3372e192b24SSimon Glass }
3382e192b24SSimon Glass
env_get_hex(const char * varname,ulong default_val)339bfebc8c9SSimon Glass ulong env_get_hex(const char *varname, ulong default_val)
3402e192b24SSimon Glass {
3412e192b24SSimon Glass const char *s;
3422e192b24SSimon Glass ulong value;
3432e192b24SSimon Glass char *endp;
3442e192b24SSimon Glass
34500caae6dSSimon Glass s = env_get(varname);
3462e192b24SSimon Glass if (s)
3472e192b24SSimon Glass value = simple_strtoul(s, &endp, 16);
3482e192b24SSimon Glass if (!s || endp == s)
3492e192b24SSimon Glass return default_val;
3502e192b24SSimon Glass
3512e192b24SSimon Glass return value;
3522e192b24SSimon Glass }
3532e192b24SSimon Glass
eth_parse_enetaddr(const char * addr,uint8_t * enetaddr)3549925f1dbSAlex Kiernan void eth_parse_enetaddr(const char *addr, uint8_t *enetaddr)
3559925f1dbSAlex Kiernan {
3569925f1dbSAlex Kiernan char *end;
3579925f1dbSAlex Kiernan int i;
3589925f1dbSAlex Kiernan
3599925f1dbSAlex Kiernan for (i = 0; i < 6; ++i) {
3609925f1dbSAlex Kiernan enetaddr[i] = addr ? simple_strtoul(addr, &end, 16) : 0;
3619925f1dbSAlex Kiernan if (addr)
3629925f1dbSAlex Kiernan addr = (*end) ? end + 1 : end;
3639925f1dbSAlex Kiernan }
3649925f1dbSAlex Kiernan }
3659925f1dbSAlex Kiernan
eth_env_get_enetaddr(const char * name,uint8_t * enetaddr)3669925f1dbSAlex Kiernan int eth_env_get_enetaddr(const char *name, uint8_t *enetaddr)
3679925f1dbSAlex Kiernan {
3689925f1dbSAlex Kiernan eth_parse_enetaddr(env_get(name), enetaddr);
3699925f1dbSAlex Kiernan return is_valid_ethaddr(enetaddr);
3709925f1dbSAlex Kiernan }
3719925f1dbSAlex Kiernan
eth_env_set_enetaddr(const char * name,const uint8_t * enetaddr)3729925f1dbSAlex Kiernan int eth_env_set_enetaddr(const char *name, const uint8_t *enetaddr)
3739925f1dbSAlex Kiernan {
3749925f1dbSAlex Kiernan char buf[ARP_HLEN_ASCII + 1];
3759925f1dbSAlex Kiernan
3769925f1dbSAlex Kiernan if (eth_env_get_enetaddr(name, (uint8_t *)buf))
3779925f1dbSAlex Kiernan return -EEXIST;
3789925f1dbSAlex Kiernan
3799925f1dbSAlex Kiernan sprintf(buf, "%pM", enetaddr);
3809925f1dbSAlex Kiernan
3819925f1dbSAlex Kiernan return env_set(name, buf);
3829925f1dbSAlex Kiernan }
3839925f1dbSAlex Kiernan
3842e192b24SSimon Glass #ifndef CONFIG_SPL_BUILD
do_env_set(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])3852e192b24SSimon Glass static int do_env_set(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
3862e192b24SSimon Glass {
3872e192b24SSimon Glass if (argc < 2)
3882e192b24SSimon Glass return CMD_RET_USAGE;
3892e192b24SSimon Glass
3902e192b24SSimon Glass return _do_env_set(flag, argc, argv, H_INTERACTIVE);
3912e192b24SSimon Glass }
3922e192b24SSimon Glass
3932e192b24SSimon Glass /*
3942e192b24SSimon Glass * Prompt for environment variable
3952e192b24SSimon Glass */
3962e192b24SSimon Glass #if defined(CONFIG_CMD_ASKENV)
do_env_ask(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])3972e192b24SSimon Glass int do_env_ask(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
3982e192b24SSimon Glass {
3992e192b24SSimon Glass char message[CONFIG_SYS_CBSIZE];
4002e192b24SSimon Glass int i, len, pos, size;
4012e192b24SSimon Glass char *local_args[4];
4022e192b24SSimon Glass char *endptr;
4032e192b24SSimon Glass
4042e192b24SSimon Glass local_args[0] = argv[0];
4052e192b24SSimon Glass local_args[1] = argv[1];
4062e192b24SSimon Glass local_args[2] = NULL;
4072e192b24SSimon Glass local_args[3] = NULL;
4082e192b24SSimon Glass
4092e192b24SSimon Glass /*
4102e192b24SSimon Glass * Check the syntax:
4112e192b24SSimon Glass *
4122e192b24SSimon Glass * env_ask envname [message1 ...] [size]
4132e192b24SSimon Glass */
4142e192b24SSimon Glass if (argc == 1)
4152e192b24SSimon Glass return CMD_RET_USAGE;
4162e192b24SSimon Glass
4172e192b24SSimon Glass /*
4182e192b24SSimon Glass * We test the last argument if it can be converted
4192e192b24SSimon Glass * into a decimal number. If yes, we assume it's
4202e192b24SSimon Glass * the size. Otherwise we echo it as part of the
4212e192b24SSimon Glass * message.
4222e192b24SSimon Glass */
4232e192b24SSimon Glass i = simple_strtoul(argv[argc - 1], &endptr, 10);
4242e192b24SSimon Glass if (*endptr != '\0') { /* no size */
4252e192b24SSimon Glass size = CONFIG_SYS_CBSIZE - 1;
4262e192b24SSimon Glass } else { /* size given */
4272e192b24SSimon Glass size = i;
4282e192b24SSimon Glass --argc;
4292e192b24SSimon Glass }
4302e192b24SSimon Glass
4312e192b24SSimon Glass if (argc <= 2) {
4322e192b24SSimon Glass sprintf(message, "Please enter '%s': ", argv[1]);
4332e192b24SSimon Glass } else {
4342e192b24SSimon Glass /* env_ask envname message1 ... messagen [size] */
435bf52fcdeSTom Rini for (i = 2, pos = 0; i < argc && pos+1 < sizeof(message); i++) {
4362e192b24SSimon Glass if (pos)
4372e192b24SSimon Glass message[pos++] = ' ';
4382e192b24SSimon Glass
439c667723fSTom Rini strncpy(message + pos, argv[i], sizeof(message) - pos);
4402e192b24SSimon Glass pos += strlen(argv[i]);
4412e192b24SSimon Glass }
442c667723fSTom Rini if (pos < sizeof(message) - 1) {
4432e192b24SSimon Glass message[pos++] = ' ';
4442e192b24SSimon Glass message[pos] = '\0';
445c667723fSTom Rini } else
446c667723fSTom Rini message[CONFIG_SYS_CBSIZE - 1] = '\0';
4472e192b24SSimon Glass }
4482e192b24SSimon Glass
4492e192b24SSimon Glass if (size >= CONFIG_SYS_CBSIZE)
4502e192b24SSimon Glass size = CONFIG_SYS_CBSIZE - 1;
4512e192b24SSimon Glass
4522e192b24SSimon Glass if (size <= 0)
4532e192b24SSimon Glass return 1;
4542e192b24SSimon Glass
4552e192b24SSimon Glass /* prompt for input */
4562e192b24SSimon Glass len = cli_readline(message);
4572e192b24SSimon Glass
4582e192b24SSimon Glass if (size < len)
4592e192b24SSimon Glass console_buffer[size] = '\0';
4602e192b24SSimon Glass
4612e192b24SSimon Glass len = 2;
4622e192b24SSimon Glass if (console_buffer[0] != '\0') {
4632e192b24SSimon Glass local_args[2] = console_buffer;
4642e192b24SSimon Glass len = 3;
4652e192b24SSimon Glass }
4662e192b24SSimon Glass
4672e192b24SSimon Glass /* Continue calling setenv code */
4682e192b24SSimon Glass return _do_env_set(flag, len, local_args, H_INTERACTIVE);
4692e192b24SSimon Glass }
4702e192b24SSimon Glass #endif
4712e192b24SSimon Glass
4722e192b24SSimon Glass #if defined(CONFIG_CMD_ENV_CALLBACK)
print_static_binding(const char * var_name,const char * callback_name,void * priv)4732e192b24SSimon Glass static int print_static_binding(const char *var_name, const char *callback_name,
4742e192b24SSimon Glass void *priv)
4752e192b24SSimon Glass {
4762e192b24SSimon Glass printf("\t%-20s %-20s\n", var_name, callback_name);
4772e192b24SSimon Glass
4782e192b24SSimon Glass return 0;
4792e192b24SSimon Glass }
4802e192b24SSimon Glass
print_active_callback(ENTRY * entry)4812e192b24SSimon Glass static int print_active_callback(ENTRY *entry)
4822e192b24SSimon Glass {
4832e192b24SSimon Glass struct env_clbk_tbl *clbkp;
4842e192b24SSimon Glass int i;
4852e192b24SSimon Glass int num_callbacks;
4862e192b24SSimon Glass
4872e192b24SSimon Glass if (entry->callback == NULL)
4882e192b24SSimon Glass return 0;
4892e192b24SSimon Glass
4902e192b24SSimon Glass /* look up the callback in the linker-list */
4912e192b24SSimon Glass num_callbacks = ll_entry_count(struct env_clbk_tbl, env_clbk);
4922e192b24SSimon Glass for (i = 0, clbkp = ll_entry_start(struct env_clbk_tbl, env_clbk);
4932e192b24SSimon Glass i < num_callbacks;
4942e192b24SSimon Glass i++, clbkp++) {
4952e192b24SSimon Glass #if defined(CONFIG_NEEDS_MANUAL_RELOC)
4962e192b24SSimon Glass if (entry->callback == clbkp->callback + gd->reloc_off)
4972e192b24SSimon Glass #else
4982e192b24SSimon Glass if (entry->callback == clbkp->callback)
4992e192b24SSimon Glass #endif
5002e192b24SSimon Glass break;
5012e192b24SSimon Glass }
5022e192b24SSimon Glass
5032e192b24SSimon Glass if (i == num_callbacks)
5042e192b24SSimon Glass /* this should probably never happen, but just in case... */
5052e192b24SSimon Glass printf("\t%-20s %p\n", entry->key, entry->callback);
5062e192b24SSimon Glass else
5072e192b24SSimon Glass printf("\t%-20s %-20s\n", entry->key, clbkp->name);
5082e192b24SSimon Glass
5092e192b24SSimon Glass return 0;
5102e192b24SSimon Glass }
5112e192b24SSimon Glass
5122e192b24SSimon Glass /*
5132e192b24SSimon Glass * Print the callbacks available and what they are bound to
5142e192b24SSimon Glass */
do_env_callback(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])5152e192b24SSimon Glass int do_env_callback(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
5162e192b24SSimon Glass {
5172e192b24SSimon Glass struct env_clbk_tbl *clbkp;
5182e192b24SSimon Glass int i;
5192e192b24SSimon Glass int num_callbacks;
5202e192b24SSimon Glass
5212e192b24SSimon Glass /* Print the available callbacks */
5222e192b24SSimon Glass puts("Available callbacks:\n");
5232e192b24SSimon Glass puts("\tCallback Name\n");
5242e192b24SSimon Glass puts("\t-------------\n");
5252e192b24SSimon Glass num_callbacks = ll_entry_count(struct env_clbk_tbl, env_clbk);
5262e192b24SSimon Glass for (i = 0, clbkp = ll_entry_start(struct env_clbk_tbl, env_clbk);
5272e192b24SSimon Glass i < num_callbacks;
5282e192b24SSimon Glass i++, clbkp++)
5292e192b24SSimon Glass printf("\t%s\n", clbkp->name);
5302e192b24SSimon Glass puts("\n");
5312e192b24SSimon Glass
5322e192b24SSimon Glass /* Print the static bindings that may exist */
5332e192b24SSimon Glass puts("Static callback bindings:\n");
5342e192b24SSimon Glass printf("\t%-20s %-20s\n", "Variable Name", "Callback Name");
5352e192b24SSimon Glass printf("\t%-20s %-20s\n", "-------------", "-------------");
5362e192b24SSimon Glass env_attr_walk(ENV_CALLBACK_LIST_STATIC, print_static_binding, NULL);
5372e192b24SSimon Glass puts("\n");
5382e192b24SSimon Glass
5392e192b24SSimon Glass /* walk through each variable and print the callback if it has one */
5402e192b24SSimon Glass puts("Active callback bindings:\n");
5412e192b24SSimon Glass printf("\t%-20s %-20s\n", "Variable Name", "Callback Name");
5422e192b24SSimon Glass printf("\t%-20s %-20s\n", "-------------", "-------------");
5432e192b24SSimon Glass hwalk_r(&env_htab, print_active_callback);
5442e192b24SSimon Glass return 0;
5452e192b24SSimon Glass }
5462e192b24SSimon Glass #endif
5472e192b24SSimon Glass
5482e192b24SSimon Glass #if defined(CONFIG_CMD_ENV_FLAGS)
print_static_flags(const char * var_name,const char * flags,void * priv)5492e192b24SSimon Glass static int print_static_flags(const char *var_name, const char *flags,
5502e192b24SSimon Glass void *priv)
5512e192b24SSimon Glass {
5522e192b24SSimon Glass enum env_flags_vartype type = env_flags_parse_vartype(flags);
5532e192b24SSimon Glass enum env_flags_varaccess access = env_flags_parse_varaccess(flags);
5542e192b24SSimon Glass
5552e192b24SSimon Glass printf("\t%-20s %-20s %-20s\n", var_name,
5562e192b24SSimon Glass env_flags_get_vartype_name(type),
5572e192b24SSimon Glass env_flags_get_varaccess_name(access));
5582e192b24SSimon Glass
5592e192b24SSimon Glass return 0;
5602e192b24SSimon Glass }
5612e192b24SSimon Glass
print_active_flags(ENTRY * entry)5622e192b24SSimon Glass static int print_active_flags(ENTRY *entry)
5632e192b24SSimon Glass {
5642e192b24SSimon Glass enum env_flags_vartype type;
5652e192b24SSimon Glass enum env_flags_varaccess access;
5662e192b24SSimon Glass
5672e192b24SSimon Glass if (entry->flags == 0)
5682e192b24SSimon Glass return 0;
5692e192b24SSimon Glass
5702e192b24SSimon Glass type = (enum env_flags_vartype)
5712e192b24SSimon Glass (entry->flags & ENV_FLAGS_VARTYPE_BIN_MASK);
5722e192b24SSimon Glass access = env_flags_parse_varaccess_from_binflags(entry->flags);
5732e192b24SSimon Glass printf("\t%-20s %-20s %-20s\n", entry->key,
5742e192b24SSimon Glass env_flags_get_vartype_name(type),
5752e192b24SSimon Glass env_flags_get_varaccess_name(access));
5762e192b24SSimon Glass
5772e192b24SSimon Glass return 0;
5782e192b24SSimon Glass }
5792e192b24SSimon Glass
5802e192b24SSimon Glass /*
5812e192b24SSimon Glass * Print the flags available and what variables have flags
5822e192b24SSimon Glass */
do_env_flags(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])5832e192b24SSimon Glass int do_env_flags(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
5842e192b24SSimon Glass {
5852e192b24SSimon Glass /* Print the available variable types */
5862e192b24SSimon Glass printf("Available variable type flags (position %d):\n",
5872e192b24SSimon Glass ENV_FLAGS_VARTYPE_LOC);
5882e192b24SSimon Glass puts("\tFlag\tVariable Type Name\n");
5892e192b24SSimon Glass puts("\t----\t------------------\n");
5902e192b24SSimon Glass env_flags_print_vartypes();
5912e192b24SSimon Glass puts("\n");
5922e192b24SSimon Glass
5932e192b24SSimon Glass /* Print the available variable access types */
5942e192b24SSimon Glass printf("Available variable access flags (position %d):\n",
5952e192b24SSimon Glass ENV_FLAGS_VARACCESS_LOC);
5962e192b24SSimon Glass puts("\tFlag\tVariable Access Name\n");
5972e192b24SSimon Glass puts("\t----\t--------------------\n");
5982e192b24SSimon Glass env_flags_print_varaccess();
5992e192b24SSimon Glass puts("\n");
6002e192b24SSimon Glass
6012e192b24SSimon Glass /* Print the static flags that may exist */
6022e192b24SSimon Glass puts("Static flags:\n");
6032e192b24SSimon Glass printf("\t%-20s %-20s %-20s\n", "Variable Name", "Variable Type",
6042e192b24SSimon Glass "Variable Access");
6052e192b24SSimon Glass printf("\t%-20s %-20s %-20s\n", "-------------", "-------------",
6062e192b24SSimon Glass "---------------");
6072e192b24SSimon Glass env_attr_walk(ENV_FLAGS_LIST_STATIC, print_static_flags, NULL);
6082e192b24SSimon Glass puts("\n");
6092e192b24SSimon Glass
6102e192b24SSimon Glass /* walk through each variable and print the flags if non-default */
6112e192b24SSimon Glass puts("Active flags:\n");
6122e192b24SSimon Glass printf("\t%-20s %-20s %-20s\n", "Variable Name", "Variable Type",
6132e192b24SSimon Glass "Variable Access");
6142e192b24SSimon Glass printf("\t%-20s %-20s %-20s\n", "-------------", "-------------",
6152e192b24SSimon Glass "---------------");
6162e192b24SSimon Glass hwalk_r(&env_htab, print_active_flags);
6172e192b24SSimon Glass return 0;
6182e192b24SSimon Glass }
6192e192b24SSimon Glass #endif
6202e192b24SSimon Glass
6212e192b24SSimon Glass /*
6222e192b24SSimon Glass * Interactively edit an environment variable
6232e192b24SSimon Glass */
6242e192b24SSimon Glass #if defined(CONFIG_CMD_EDITENV)
do_env_edit(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])6252e192b24SSimon Glass static int do_env_edit(cmd_tbl_t *cmdtp, int flag, int argc,
6262e192b24SSimon Glass char * const argv[])
6272e192b24SSimon Glass {
6282e192b24SSimon Glass char buffer[CONFIG_SYS_CBSIZE];
6292e192b24SSimon Glass char *init_val;
6302e192b24SSimon Glass
6312e192b24SSimon Glass if (argc < 2)
6322e192b24SSimon Glass return CMD_RET_USAGE;
6332e192b24SSimon Glass
6342e192b24SSimon Glass /* before import into hashtable */
6352e192b24SSimon Glass if (!(gd->flags & GD_FLG_ENV_READY))
6362e192b24SSimon Glass return 1;
6372e192b24SSimon Glass
6382e192b24SSimon Glass /* Set read buffer to initial value or empty sting */
63900caae6dSSimon Glass init_val = env_get(argv[1]);
6402e192b24SSimon Glass if (init_val)
6412e192b24SSimon Glass snprintf(buffer, CONFIG_SYS_CBSIZE, "%s", init_val);
6422e192b24SSimon Glass else
6432e192b24SSimon Glass buffer[0] = '\0';
6442e192b24SSimon Glass
6452e192b24SSimon Glass if (cli_readline_into_buffer("edit: ", buffer, 0) < 0)
6462e192b24SSimon Glass return 1;
6472e192b24SSimon Glass
6482e192b24SSimon Glass if (buffer[0] == '\0') {
6492e192b24SSimon Glass const char * const _argv[3] = { "setenv", argv[1], NULL };
6502e192b24SSimon Glass
6512e192b24SSimon Glass return _do_env_set(0, 2, (char * const *)_argv, H_INTERACTIVE);
6522e192b24SSimon Glass } else {
6532e192b24SSimon Glass const char * const _argv[4] = { "setenv", argv[1], buffer,
6542e192b24SSimon Glass NULL };
6552e192b24SSimon Glass
6562e192b24SSimon Glass return _do_env_set(0, 3, (char * const *)_argv, H_INTERACTIVE);
6572e192b24SSimon Glass }
6582e192b24SSimon Glass }
6592e192b24SSimon Glass #endif /* CONFIG_CMD_EDITENV */
6602e192b24SSimon Glass #endif /* CONFIG_SPL_BUILD */
6612e192b24SSimon Glass
6622e192b24SSimon Glass /*
6632e192b24SSimon Glass * Look up variable from environment,
6642e192b24SSimon Glass * return address of storage for that variable,
6652e192b24SSimon Glass * or NULL if not found
6662e192b24SSimon Glass */
env_get(const char * name)66700caae6dSSimon Glass char *env_get(const char *name)
6682e192b24SSimon Glass {
6692e192b24SSimon Glass if (gd->flags & GD_FLG_ENV_READY) { /* after import into hashtable */
6702e192b24SSimon Glass ENTRY e, *ep;
6712e192b24SSimon Glass
6722e192b24SSimon Glass WATCHDOG_RESET();
6732e192b24SSimon Glass
6742e192b24SSimon Glass e.key = name;
6752e192b24SSimon Glass e.data = NULL;
6762e192b24SSimon Glass hsearch_r(e, FIND, &ep, &env_htab, 0);
6772e192b24SSimon Glass
6782e192b24SSimon Glass return ep ? ep->data : NULL;
6792e192b24SSimon Glass }
6802e192b24SSimon Glass
6812e192b24SSimon Glass /* restricted capabilities before import */
68200caae6dSSimon Glass if (env_get_f(name, (char *)(gd->env_buf), sizeof(gd->env_buf)) > 0)
6832e192b24SSimon Glass return (char *)(gd->env_buf);
6842e192b24SSimon Glass
6852e192b24SSimon Glass return NULL;
6862e192b24SSimon Glass }
6872e192b24SSimon Glass
6882e192b24SSimon Glass /*
6892e192b24SSimon Glass * Look up variable from environment for restricted C runtime env.
6902e192b24SSimon Glass */
env_get_f(const char * name,char * buf,unsigned len)69100caae6dSSimon Glass int env_get_f(const char *name, char *buf, unsigned len)
6922e192b24SSimon Glass {
69387c7fb39SSimon Goldschmidt int i, nxt, c;
6942e192b24SSimon Glass
6952e192b24SSimon Glass for (i = 0; env_get_char(i) != '\0'; i = nxt + 1) {
6962e192b24SSimon Glass int val, n;
6972e192b24SSimon Glass
69887c7fb39SSimon Goldschmidt for (nxt = i; (c = env_get_char(nxt)) != '\0'; ++nxt) {
69987c7fb39SSimon Goldschmidt if (c < 0)
70087c7fb39SSimon Goldschmidt return c;
7012e192b24SSimon Glass if (nxt >= CONFIG_ENV_SIZE)
7022e192b24SSimon Glass return -1;
7032e192b24SSimon Glass }
7042e192b24SSimon Glass
7052e192b24SSimon Glass val = envmatch((uchar *)name, i);
7062e192b24SSimon Glass if (val < 0)
7072e192b24SSimon Glass continue;
7082e192b24SSimon Glass
7092e192b24SSimon Glass /* found; copy out */
7102e192b24SSimon Glass for (n = 0; n < len; ++n, ++buf) {
71187c7fb39SSimon Goldschmidt c = env_get_char(val++);
71287c7fb39SSimon Goldschmidt if (c < 0)
71387c7fb39SSimon Goldschmidt return c;
71487c7fb39SSimon Goldschmidt *buf = c;
7152e192b24SSimon Glass if (*buf == '\0')
7162e192b24SSimon Glass return n;
7172e192b24SSimon Glass }
7182e192b24SSimon Glass
7192e192b24SSimon Glass if (n)
7202e192b24SSimon Glass *--buf = '\0';
7212e192b24SSimon Glass
72282919517SHeinrich Schuchardt printf("env_buf [%u bytes] too small for value of \"%s\"\n",
7232e192b24SSimon Glass len, name);
7242e192b24SSimon Glass
7252e192b24SSimon Glass return n;
7262e192b24SSimon Glass }
7272e192b24SSimon Glass
7282e192b24SSimon Glass return -1;
7292e192b24SSimon Glass }
7302e192b24SSimon Glass
7312e192b24SSimon Glass /**
7322e192b24SSimon Glass * Decode the integer value of an environment variable and return it.
7332e192b24SSimon Glass *
734919d25c9SShyam Saini * @param name Name of environment variable
7352e192b24SSimon Glass * @param base Number base to use (normally 10, or 16 for hex)
7362e192b24SSimon Glass * @param default_val Default value to return if the variable is not
7372e192b24SSimon Glass * found
7382e192b24SSimon Glass * @return the decoded value, or default_val if not found
7392e192b24SSimon Glass */
env_get_ulong(const char * name,int base,ulong default_val)740bfebc8c9SSimon Glass ulong env_get_ulong(const char *name, int base, ulong default_val)
7412e192b24SSimon Glass {
7422e192b24SSimon Glass /*
74300caae6dSSimon Glass * We can use env_get() here, even before relocation, since the
7442e192b24SSimon Glass * environment variable value is an integer and thus short.
7452e192b24SSimon Glass */
74600caae6dSSimon Glass const char *str = env_get(name);
7472e192b24SSimon Glass
7482e192b24SSimon Glass return str ? simple_strtoul(str, NULL, base) : default_val;
7492e192b24SSimon Glass }
7502e192b24SSimon Glass
7512e192b24SSimon Glass #ifndef CONFIG_SPL_BUILD
7522e192b24SSimon Glass #if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE)
do_env_save(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])7532e192b24SSimon Glass static int do_env_save(cmd_tbl_t *cmdtp, int flag, int argc,
7542e192b24SSimon Glass char * const argv[])
7552e192b24SSimon Glass {
75601510091SSimon Glass return env_save() ? 1 : 0;
7572e192b24SSimon Glass }
7582e192b24SSimon Glass
7592e192b24SSimon Glass U_BOOT_CMD(
7602e192b24SSimon Glass saveenv, 1, 0, do_env_save,
7612e192b24SSimon Glass "save environment variables to persistent storage",
7622e192b24SSimon Glass ""
7632e192b24SSimon Glass );
7642e192b24SSimon Glass #endif
7652e192b24SSimon Glass #endif /* CONFIG_SPL_BUILD */
7662e192b24SSimon Glass
7672e192b24SSimon Glass
7682e192b24SSimon Glass /*
7692e192b24SSimon Glass * Match a name / name=value pair
7702e192b24SSimon Glass *
7712e192b24SSimon Glass * s1 is either a simple 'name', or a 'name=value' pair.
7722e192b24SSimon Glass * i2 is the environment index for a 'name2=value2' pair.
7732e192b24SSimon Glass * If the names match, return the index for the value2, else -1.
7742e192b24SSimon Glass */
envmatch(uchar * s1,int i2)7752e192b24SSimon Glass int envmatch(uchar *s1, int i2)
7762e192b24SSimon Glass {
7772e192b24SSimon Glass if (s1 == NULL)
7782e192b24SSimon Glass return -1;
7792e192b24SSimon Glass
7802e192b24SSimon Glass while (*s1 == env_get_char(i2++))
7812e192b24SSimon Glass if (*s1++ == '=')
7822e192b24SSimon Glass return i2;
7832e192b24SSimon Glass
7842e192b24SSimon Glass if (*s1 == '\0' && env_get_char(i2-1) == '=')
7852e192b24SSimon Glass return i2;
7862e192b24SSimon Glass
7872e192b24SSimon Glass return -1;
7882e192b24SSimon Glass }
7892e192b24SSimon Glass
7902e192b24SSimon Glass #ifndef CONFIG_SPL_BUILD
do_env_default(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])79130091494SYaniv Levinsky static int do_env_default(cmd_tbl_t *cmdtp, int flag,
7922e192b24SSimon Glass int argc, char * const argv[])
7932e192b24SSimon Glass {
7945a04264eSYaniv Levinsky int all = 0, env_flag = H_INTERACTIVE;
7952e192b24SSimon Glass
7962e192b24SSimon Glass debug("Initial value for argc=%d\n", argc);
7972e192b24SSimon Glass while (--argc > 0 && **++argv == '-') {
7982e192b24SSimon Glass char *arg = *argv;
7992e192b24SSimon Glass
8002e192b24SSimon Glass while (*++arg) {
8012e192b24SSimon Glass switch (*arg) {
8022e192b24SSimon Glass case 'a': /* default all */
8032e192b24SSimon Glass all = 1;
8042e192b24SSimon Glass break;
8052e192b24SSimon Glass case 'f': /* force */
80630091494SYaniv Levinsky env_flag |= H_FORCE;
8072e192b24SSimon Glass break;
8082e192b24SSimon Glass default:
8092e192b24SSimon Glass return cmd_usage(cmdtp);
8102e192b24SSimon Glass }
8112e192b24SSimon Glass }
8122e192b24SSimon Glass }
8132e192b24SSimon Glass debug("Final value for argc=%d\n", argc);
8142e192b24SSimon Glass if (all && (argc == 0)) {
8152e192b24SSimon Glass /* Reset the whole environment */
816c5d548a9SYaniv Levinsky set_default_env("## Resetting to default environment\n",
817c5d548a9SYaniv Levinsky env_flag);
8182e192b24SSimon Glass return 0;
8192e192b24SSimon Glass }
8202e192b24SSimon Glass if (!all && (argc > 0)) {
8212e192b24SSimon Glass /* Reset individual variables */
822477f8116SYaniv Levinsky set_default_vars(argc, argv, env_flag);
8232e192b24SSimon Glass return 0;
8242e192b24SSimon Glass }
8252e192b24SSimon Glass
8262e192b24SSimon Glass return cmd_usage(cmdtp);
8272e192b24SSimon Glass }
8282e192b24SSimon Glass
do_env_delete(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])8292e192b24SSimon Glass static int do_env_delete(cmd_tbl_t *cmdtp, int flag,
8302e192b24SSimon Glass int argc, char * const argv[])
8312e192b24SSimon Glass {
8322e192b24SSimon Glass int env_flag = H_INTERACTIVE;
8332e192b24SSimon Glass int ret = 0;
8342e192b24SSimon Glass
8352e192b24SSimon Glass debug("Initial value for argc=%d\n", argc);
8362e192b24SSimon Glass while (argc > 1 && **(argv + 1) == '-') {
8372e192b24SSimon Glass char *arg = *++argv;
8382e192b24SSimon Glass
8392e192b24SSimon Glass --argc;
8402e192b24SSimon Glass while (*++arg) {
8412e192b24SSimon Glass switch (*arg) {
8422e192b24SSimon Glass case 'f': /* force */
8432e192b24SSimon Glass env_flag |= H_FORCE;
8442e192b24SSimon Glass break;
8452e192b24SSimon Glass default:
8462e192b24SSimon Glass return CMD_RET_USAGE;
8472e192b24SSimon Glass }
8482e192b24SSimon Glass }
8492e192b24SSimon Glass }
8502e192b24SSimon Glass debug("Final value for argc=%d\n", argc);
8512e192b24SSimon Glass
8522e192b24SSimon Glass env_id++;
8532e192b24SSimon Glass
8542e192b24SSimon Glass while (--argc > 0) {
8552e192b24SSimon Glass char *name = *++argv;
8562e192b24SSimon Glass
8572e192b24SSimon Glass if (!hdelete_r(name, &env_htab, env_flag))
8582e192b24SSimon Glass ret = 1;
8592e192b24SSimon Glass }
8602e192b24SSimon Glass
8612e192b24SSimon Glass return ret;
8622e192b24SSimon Glass }
8632e192b24SSimon Glass
8642e192b24SSimon Glass #ifdef CONFIG_CMD_EXPORTENV
8652e192b24SSimon Glass /*
8662e192b24SSimon Glass * env export [-t | -b | -c] [-s size] addr [var ...]
8672e192b24SSimon Glass * -t: export as text format; if size is given, data will be
8682e192b24SSimon Glass * padded with '\0' bytes; if not, one terminating '\0'
8692e192b24SSimon Glass * will be added (which is included in the "filesize"
8702e192b24SSimon Glass * setting so you can for exmple copy this to flash and
8712e192b24SSimon Glass * keep the termination).
8722e192b24SSimon Glass * -b: export as binary format (name=value pairs separated by
8732e192b24SSimon Glass * '\0', list end marked by double "\0\0")
8742e192b24SSimon Glass * -c: export as checksum protected environment format as
8752e192b24SSimon Glass * used for example by "saveenv" command
8762e192b24SSimon Glass * -s size:
8772e192b24SSimon Glass * size of output buffer
8782e192b24SSimon Glass * addr: memory address where environment gets stored
8792e192b24SSimon Glass * var... List of variable names that get included into the
8802e192b24SSimon Glass * export. Without arguments, the whole environment gets
8812e192b24SSimon Glass * exported.
8822e192b24SSimon Glass *
8832e192b24SSimon Glass * With "-c" and size is NOT given, then the export command will
8842e192b24SSimon Glass * format the data as currently used for the persistent storage,
8852e192b24SSimon Glass * i. e. it will use CONFIG_ENV_SECT_SIZE as output block size and
886fc0b5948SRobert P. J. Day * prepend a valid CRC32 checksum and, in case of redundant
8872e192b24SSimon Glass * environment, a "current" redundancy flag. If size is given, this
8882e192b24SSimon Glass * value will be used instead of CONFIG_ENV_SECT_SIZE; again, CRC32
8892e192b24SSimon Glass * checksum and redundancy flag will be inserted.
8902e192b24SSimon Glass *
8912e192b24SSimon Glass * With "-b" and "-t", always only the real data (including a
8922e192b24SSimon Glass * terminating '\0' byte) will be written; here the optional size
8932e192b24SSimon Glass * argument will be used to make sure not to overflow the user
8942e192b24SSimon Glass * provided buffer; the command will abort if the size is not
895fc0b5948SRobert P. J. Day * sufficient. Any remaining space will be '\0' padded.
8962e192b24SSimon Glass *
8972e192b24SSimon Glass * On successful return, the variable "filesize" will be set.
8982e192b24SSimon Glass * Note that filesize includes the trailing/terminating '\0' byte(s).
8992e192b24SSimon Glass *
900fc0b5948SRobert P. J. Day * Usage scenario: create a text snapshot/backup of the current settings:
9012e192b24SSimon Glass *
9022e192b24SSimon Glass * => env export -t 100000
9032e192b24SSimon Glass * => era ${backup_addr} +${filesize}
9042e192b24SSimon Glass * => cp.b 100000 ${backup_addr} ${filesize}
9052e192b24SSimon Glass *
9062e192b24SSimon Glass * Re-import this snapshot, deleting all other settings:
9072e192b24SSimon Glass *
9082e192b24SSimon Glass * => env import -d -t ${backup_addr}
9092e192b24SSimon Glass */
do_env_export(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])9102e192b24SSimon Glass static int do_env_export(cmd_tbl_t *cmdtp, int flag,
9112e192b24SSimon Glass int argc, char * const argv[])
9122e192b24SSimon Glass {
9132e192b24SSimon Glass char buf[32];
9142e192b24SSimon Glass ulong addr;
9152e192b24SSimon Glass char *ptr, *cmd, *res;
9162e192b24SSimon Glass size_t size = 0;
9172e192b24SSimon Glass ssize_t len;
9182e192b24SSimon Glass env_t *envp;
9192e192b24SSimon Glass char sep = '\n';
9202e192b24SSimon Glass int chk = 0;
9212e192b24SSimon Glass int fmt = 0;
9222e192b24SSimon Glass
9232e192b24SSimon Glass cmd = *argv;
9242e192b24SSimon Glass
9252e192b24SSimon Glass while (--argc > 0 && **++argv == '-') {
9262e192b24SSimon Glass char *arg = *argv;
9272e192b24SSimon Glass while (*++arg) {
9282e192b24SSimon Glass switch (*arg) {
9292e192b24SSimon Glass case 'b': /* raw binary format */
9302e192b24SSimon Glass if (fmt++)
9312e192b24SSimon Glass goto sep_err;
9322e192b24SSimon Glass sep = '\0';
9332e192b24SSimon Glass break;
9342e192b24SSimon Glass case 'c': /* external checksum format */
9352e192b24SSimon Glass if (fmt++)
9362e192b24SSimon Glass goto sep_err;
9372e192b24SSimon Glass sep = '\0';
9382e192b24SSimon Glass chk = 1;
9392e192b24SSimon Glass break;
9402e192b24SSimon Glass case 's': /* size given */
9412e192b24SSimon Glass if (--argc <= 0)
9422e192b24SSimon Glass return cmd_usage(cmdtp);
9432e192b24SSimon Glass size = simple_strtoul(*++argv, NULL, 16);
9442e192b24SSimon Glass goto NXTARG;
9452e192b24SSimon Glass case 't': /* text format */
9462e192b24SSimon Glass if (fmt++)
9472e192b24SSimon Glass goto sep_err;
9482e192b24SSimon Glass sep = '\n';
9492e192b24SSimon Glass break;
9502e192b24SSimon Glass default:
9512e192b24SSimon Glass return CMD_RET_USAGE;
9522e192b24SSimon Glass }
9532e192b24SSimon Glass }
9542e192b24SSimon Glass NXTARG: ;
9552e192b24SSimon Glass }
9562e192b24SSimon Glass
9572e192b24SSimon Glass if (argc < 1)
9582e192b24SSimon Glass return CMD_RET_USAGE;
9592e192b24SSimon Glass
9602e192b24SSimon Glass addr = simple_strtoul(argv[0], NULL, 16);
9612e192b24SSimon Glass ptr = map_sysmem(addr, size);
9622e192b24SSimon Glass
9632e192b24SSimon Glass if (size)
9642e192b24SSimon Glass memset(ptr, '\0', size);
9652e192b24SSimon Glass
9662e192b24SSimon Glass argc--;
9672e192b24SSimon Glass argv++;
9682e192b24SSimon Glass
9692e192b24SSimon Glass if (sep) { /* export as text file */
9702e192b24SSimon Glass len = hexport_r(&env_htab, sep,
9712e192b24SSimon Glass H_MATCH_KEY | H_MATCH_IDENT,
9722e192b24SSimon Glass &ptr, size, argc, argv);
9732e192b24SSimon Glass if (len < 0) {
9746c90f623SQuentin Schulz pr_err("## Error: Cannot export environment: errno = %d\n",
9756c90f623SQuentin Schulz errno);
9762e192b24SSimon Glass return 1;
9772e192b24SSimon Glass }
9782e192b24SSimon Glass sprintf(buf, "%zX", (size_t)len);
979382bee57SSimon Glass env_set("filesize", buf);
9802e192b24SSimon Glass
9812e192b24SSimon Glass return 0;
9822e192b24SSimon Glass }
9832e192b24SSimon Glass
9842e192b24SSimon Glass envp = (env_t *)ptr;
9852e192b24SSimon Glass
9862e192b24SSimon Glass if (chk) /* export as checksum protected block */
9872e192b24SSimon Glass res = (char *)envp->data;
9882e192b24SSimon Glass else /* export as raw binary data */
9892e192b24SSimon Glass res = ptr;
9902e192b24SSimon Glass
9912e192b24SSimon Glass len = hexport_r(&env_htab, '\0',
9922e192b24SSimon Glass H_MATCH_KEY | H_MATCH_IDENT,
9932e192b24SSimon Glass &res, ENV_SIZE, argc, argv);
9942e192b24SSimon Glass if (len < 0) {
9956c90f623SQuentin Schulz pr_err("## Error: Cannot export environment: errno = %d\n",
9966c90f623SQuentin Schulz errno);
9972e192b24SSimon Glass return 1;
9982e192b24SSimon Glass }
9992e192b24SSimon Glass
10002e192b24SSimon Glass if (chk) {
1001d71b029dSNeil Stainton envp->crc = crc32(0, envp->data,
1002d71b029dSNeil Stainton size ? size - offsetof(env_t, data) : ENV_SIZE);
10032e192b24SSimon Glass #ifdef CONFIG_ENV_ADDR_REDUND
10042e192b24SSimon Glass envp->flags = ACTIVE_FLAG;
10052e192b24SSimon Glass #endif
10062e192b24SSimon Glass }
1007018f5303SSimon Glass env_set_hex("filesize", len + offsetof(env_t, data));
10082e192b24SSimon Glass
10092e192b24SSimon Glass return 0;
10102e192b24SSimon Glass
10112e192b24SSimon Glass sep_err:
10126c90f623SQuentin Schulz printf("## Error: %s: only one of \"-b\", \"-c\" or \"-t\" allowed\n",
10136c90f623SQuentin Schulz cmd);
10142e192b24SSimon Glass return 1;
10152e192b24SSimon Glass }
10162e192b24SSimon Glass #endif
10172e192b24SSimon Glass
10182e192b24SSimon Glass #ifdef CONFIG_CMD_IMPORTENV
10192e192b24SSimon Glass /*
1020eaf73472SQuentin Schulz * env import [-d] [-t [-r] | -b | -c] addr [size] [var ...]
1021eaf73472SQuentin Schulz * -d: delete existing environment before importing if no var is
1022eaf73472SQuentin Schulz * passed; if vars are passed, if one var is in the current
1023eaf73472SQuentin Schulz * environment but not in the environment at addr, delete var from
1024eaf73472SQuentin Schulz * current environment;
1025fc0b5948SRobert P. J. Day * otherwise overwrite / append to existing definitions
10262e192b24SSimon Glass * -t: assume text format; either "size" must be given or the
10272e192b24SSimon Glass * text data must be '\0' terminated
10282e192b24SSimon Glass * -r: handle CRLF like LF, that means exported variables with
10292e192b24SSimon Glass * a content which ends with \r won't get imported. Used
10302e192b24SSimon Glass * to import text files created with editors which are using CRLF
10312e192b24SSimon Glass * for line endings. Only effective in addition to -t.
10322e192b24SSimon Glass * -b: assume binary format ('\0' separated, "\0\0" terminated)
10332e192b24SSimon Glass * -c: assume checksum protected environment format
10342e192b24SSimon Glass * addr: memory address to read from
10352e192b24SSimon Glass * size: length of input data; if missing, proper '\0'
10362e192b24SSimon Glass * termination is mandatory
1037eaf73472SQuentin Schulz * if var is set and size should be missing (i.e. '\0'
1038eaf73472SQuentin Schulz * termination), set size to '-'
1039eaf73472SQuentin Schulz * var... List of the names of the only variables that get imported from
1040eaf73472SQuentin Schulz * the environment at address 'addr'. Without arguments, the whole
1041eaf73472SQuentin Schulz * environment gets imported.
10422e192b24SSimon Glass */
do_env_import(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])10432e192b24SSimon Glass static int do_env_import(cmd_tbl_t *cmdtp, int flag,
10442e192b24SSimon Glass int argc, char * const argv[])
10452e192b24SSimon Glass {
10462e192b24SSimon Glass ulong addr;
10472e192b24SSimon Glass char *cmd, *ptr;
10482e192b24SSimon Glass char sep = '\n';
10492e192b24SSimon Glass int chk = 0;
10502e192b24SSimon Glass int fmt = 0;
10512e192b24SSimon Glass int del = 0;
10522e192b24SSimon Glass int crlf_is_lf = 0;
1053eaf73472SQuentin Schulz int wl = 0;
10542e192b24SSimon Glass size_t size;
10552e192b24SSimon Glass
10562e192b24SSimon Glass cmd = *argv;
10572e192b24SSimon Glass
10582e192b24SSimon Glass while (--argc > 0 && **++argv == '-') {
10592e192b24SSimon Glass char *arg = *argv;
10602e192b24SSimon Glass while (*++arg) {
10612e192b24SSimon Glass switch (*arg) {
10622e192b24SSimon Glass case 'b': /* raw binary format */
10632e192b24SSimon Glass if (fmt++)
10642e192b24SSimon Glass goto sep_err;
10652e192b24SSimon Glass sep = '\0';
10662e192b24SSimon Glass break;
10672e192b24SSimon Glass case 'c': /* external checksum format */
10682e192b24SSimon Glass if (fmt++)
10692e192b24SSimon Glass goto sep_err;
10702e192b24SSimon Glass sep = '\0';
10712e192b24SSimon Glass chk = 1;
10722e192b24SSimon Glass break;
10732e192b24SSimon Glass case 't': /* text format */
10742e192b24SSimon Glass if (fmt++)
10752e192b24SSimon Glass goto sep_err;
10762e192b24SSimon Glass sep = '\n';
10772e192b24SSimon Glass break;
10782e192b24SSimon Glass case 'r': /* handle CRLF like LF */
10792e192b24SSimon Glass crlf_is_lf = 1;
10802e192b24SSimon Glass break;
10812e192b24SSimon Glass case 'd':
10822e192b24SSimon Glass del = 1;
10832e192b24SSimon Glass break;
10842e192b24SSimon Glass default:
10852e192b24SSimon Glass return CMD_RET_USAGE;
10862e192b24SSimon Glass }
10872e192b24SSimon Glass }
10882e192b24SSimon Glass }
10892e192b24SSimon Glass
10902e192b24SSimon Glass if (argc < 1)
10912e192b24SSimon Glass return CMD_RET_USAGE;
10922e192b24SSimon Glass
10932e192b24SSimon Glass if (!fmt)
10942e192b24SSimon Glass printf("## Warning: defaulting to text format\n");
10952e192b24SSimon Glass
10962e192b24SSimon Glass if (sep != '\n' && crlf_is_lf )
10972e192b24SSimon Glass crlf_is_lf = 0;
10982e192b24SSimon Glass
10992e192b24SSimon Glass addr = simple_strtoul(argv[0], NULL, 16);
11002e192b24SSimon Glass ptr = map_sysmem(addr, 0);
11012e192b24SSimon Glass
1102eaf73472SQuentin Schulz if (argc >= 2 && strcmp(argv[1], "-")) {
11032e192b24SSimon Glass size = simple_strtoul(argv[1], NULL, 16);
1104eaf73472SQuentin Schulz } else if (chk) {
11052e192b24SSimon Glass puts("## Error: external checksum format must pass size\n");
11062e192b24SSimon Glass return CMD_RET_FAILURE;
11072e192b24SSimon Glass } else {
11082e192b24SSimon Glass char *s = ptr;
11092e192b24SSimon Glass
11102e192b24SSimon Glass size = 0;
11112e192b24SSimon Glass
11122e192b24SSimon Glass while (size < MAX_ENV_SIZE) {
11132e192b24SSimon Glass if ((*s == sep) && (*(s+1) == '\0'))
11142e192b24SSimon Glass break;
11152e192b24SSimon Glass ++s;
11162e192b24SSimon Glass ++size;
11172e192b24SSimon Glass }
11182e192b24SSimon Glass if (size == MAX_ENV_SIZE) {
11192e192b24SSimon Glass printf("## Warning: Input data exceeds %d bytes"
11202e192b24SSimon Glass " - truncated\n", MAX_ENV_SIZE);
11212e192b24SSimon Glass }
11222e192b24SSimon Glass size += 2;
11232e192b24SSimon Glass printf("## Info: input data size = %zu = 0x%zX\n", size, size);
11242e192b24SSimon Glass }
11252e192b24SSimon Glass
1126eaf73472SQuentin Schulz if (argc > 2)
1127eaf73472SQuentin Schulz wl = 1;
1128eaf73472SQuentin Schulz
11292e192b24SSimon Glass if (chk) {
11302e192b24SSimon Glass uint32_t crc;
11312e192b24SSimon Glass env_t *ep = (env_t *)ptr;
11322e192b24SSimon Glass
11332e192b24SSimon Glass size -= offsetof(env_t, data);
11342e192b24SSimon Glass memcpy(&crc, &ep->crc, sizeof(crc));
11352e192b24SSimon Glass
11362e192b24SSimon Glass if (crc32(0, ep->data, size) != crc) {
11372e192b24SSimon Glass puts("## Error: bad CRC, import failed\n");
11382e192b24SSimon Glass return 1;
11392e192b24SSimon Glass }
11402e192b24SSimon Glass ptr = (char *)ep->data;
11412e192b24SSimon Glass }
11422e192b24SSimon Glass
1143eaf73472SQuentin Schulz if (!himport_r(&env_htab, ptr, size, sep, del ? 0 : H_NOCLEAR,
1144eaf73472SQuentin Schulz crlf_is_lf, wl ? argc - 2 : 0, wl ? &argv[2] : NULL)) {
11456c90f623SQuentin Schulz pr_err("## Error: Environment import failed: errno = %d\n",
11466c90f623SQuentin Schulz errno);
11472e192b24SSimon Glass return 1;
11482e192b24SSimon Glass }
11492e192b24SSimon Glass gd->flags |= GD_FLG_ENV_READY;
11502e192b24SSimon Glass
11512e192b24SSimon Glass return 0;
11522e192b24SSimon Glass
11532e192b24SSimon Glass sep_err:
11542e192b24SSimon Glass printf("## %s: only one of \"-b\", \"-c\" or \"-t\" allowed\n",
11552e192b24SSimon Glass cmd);
11562e192b24SSimon Glass return 1;
11572e192b24SSimon Glass }
11582e192b24SSimon Glass #endif
11592e192b24SSimon Glass
11602e192b24SSimon Glass #if defined(CONFIG_CMD_ENV_EXISTS)
do_env_exists(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])11612e192b24SSimon Glass static int do_env_exists(cmd_tbl_t *cmdtp, int flag, int argc,
11622e192b24SSimon Glass char * const argv[])
11632e192b24SSimon Glass {
11642e192b24SSimon Glass ENTRY e, *ep;
11652e192b24SSimon Glass
11662e192b24SSimon Glass if (argc < 2)
11672e192b24SSimon Glass return CMD_RET_USAGE;
11682e192b24SSimon Glass
11692e192b24SSimon Glass e.key = argv[1];
11702e192b24SSimon Glass e.data = NULL;
11712e192b24SSimon Glass hsearch_r(e, FIND, &ep, &env_htab, 0);
11722e192b24SSimon Glass
11732e192b24SSimon Glass return (ep == NULL) ? 1 : 0;
11742e192b24SSimon Glass }
11752e192b24SSimon Glass #endif
11762e192b24SSimon Glass
11772e192b24SSimon Glass /*
11782e192b24SSimon Glass * New command line interface: "env" command with subcommands
11792e192b24SSimon Glass */
11802e192b24SSimon Glass static cmd_tbl_t cmd_env_sub[] = {
11812e192b24SSimon Glass #if defined(CONFIG_CMD_ASKENV)
11822e192b24SSimon Glass U_BOOT_CMD_MKENT(ask, CONFIG_SYS_MAXARGS, 1, do_env_ask, "", ""),
11832e192b24SSimon Glass #endif
11842e192b24SSimon Glass U_BOOT_CMD_MKENT(default, 1, 0, do_env_default, "", ""),
11852e192b24SSimon Glass U_BOOT_CMD_MKENT(delete, CONFIG_SYS_MAXARGS, 0, do_env_delete, "", ""),
11862e192b24SSimon Glass #if defined(CONFIG_CMD_EDITENV)
11872e192b24SSimon Glass U_BOOT_CMD_MKENT(edit, 2, 0, do_env_edit, "", ""),
11882e192b24SSimon Glass #endif
11892e192b24SSimon Glass #if defined(CONFIG_CMD_ENV_CALLBACK)
11902e192b24SSimon Glass U_BOOT_CMD_MKENT(callbacks, 1, 0, do_env_callback, "", ""),
11912e192b24SSimon Glass #endif
11922e192b24SSimon Glass #if defined(CONFIG_CMD_ENV_FLAGS)
11932e192b24SSimon Glass U_BOOT_CMD_MKENT(flags, 1, 0, do_env_flags, "", ""),
11942e192b24SSimon Glass #endif
11952e192b24SSimon Glass #if defined(CONFIG_CMD_EXPORTENV)
11962e192b24SSimon Glass U_BOOT_CMD_MKENT(export, 4, 0, do_env_export, "", ""),
11972e192b24SSimon Glass #endif
11982e192b24SSimon Glass #if defined(CONFIG_CMD_GREPENV)
11992e192b24SSimon Glass U_BOOT_CMD_MKENT(grep, CONFIG_SYS_MAXARGS, 1, do_env_grep, "", ""),
12002e192b24SSimon Glass #endif
12012e192b24SSimon Glass #if defined(CONFIG_CMD_IMPORTENV)
12022e192b24SSimon Glass U_BOOT_CMD_MKENT(import, 5, 0, do_env_import, "", ""),
12032e192b24SSimon Glass #endif
12042e192b24SSimon Glass U_BOOT_CMD_MKENT(print, CONFIG_SYS_MAXARGS, 1, do_env_print, "", ""),
12052e192b24SSimon Glass #if defined(CONFIG_CMD_RUN)
12062e192b24SSimon Glass U_BOOT_CMD_MKENT(run, CONFIG_SYS_MAXARGS, 1, do_run, "", ""),
12072e192b24SSimon Glass #endif
12082e192b24SSimon Glass #if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE)
12092e192b24SSimon Glass U_BOOT_CMD_MKENT(save, 1, 0, do_env_save, "", ""),
12102e192b24SSimon Glass #endif
12112e192b24SSimon Glass U_BOOT_CMD_MKENT(set, CONFIG_SYS_MAXARGS, 0, do_env_set, "", ""),
12122e192b24SSimon Glass #if defined(CONFIG_CMD_ENV_EXISTS)
12132e192b24SSimon Glass U_BOOT_CMD_MKENT(exists, 2, 0, do_env_exists, "", ""),
12142e192b24SSimon Glass #endif
12152e192b24SSimon Glass };
12162e192b24SSimon Glass
12172e192b24SSimon Glass #if defined(CONFIG_NEEDS_MANUAL_RELOC)
env_reloc(void)12182e192b24SSimon Glass void env_reloc(void)
12192e192b24SSimon Glass {
12202e192b24SSimon Glass fixup_cmdtable(cmd_env_sub, ARRAY_SIZE(cmd_env_sub));
12212e192b24SSimon Glass }
12222e192b24SSimon Glass #endif
12232e192b24SSimon Glass
do_env(cmd_tbl_t * cmdtp,int flag,int argc,char * const argv[])12242e192b24SSimon Glass static int do_env(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
12252e192b24SSimon Glass {
12262e192b24SSimon Glass cmd_tbl_t *cp;
12272e192b24SSimon Glass
12282e192b24SSimon Glass if (argc < 2)
12292e192b24SSimon Glass return CMD_RET_USAGE;
12302e192b24SSimon Glass
12312e192b24SSimon Glass /* drop initial "env" arg */
12322e192b24SSimon Glass argc--;
12332e192b24SSimon Glass argv++;
12342e192b24SSimon Glass
12352e192b24SSimon Glass cp = find_cmd_tbl(argv[0], cmd_env_sub, ARRAY_SIZE(cmd_env_sub));
12362e192b24SSimon Glass
12372e192b24SSimon Glass if (cp)
12382e192b24SSimon Glass return cp->cmd(cmdtp, flag, argc, argv);
12392e192b24SSimon Glass
12402e192b24SSimon Glass return CMD_RET_USAGE;
12412e192b24SSimon Glass }
12422e192b24SSimon Glass
12432e192b24SSimon Glass #ifdef CONFIG_SYS_LONGHELP
12442e192b24SSimon Glass static char env_help_text[] =
12452e192b24SSimon Glass #if defined(CONFIG_CMD_ASKENV)
12462e192b24SSimon Glass "ask name [message] [size] - ask for environment variable\nenv "
12472e192b24SSimon Glass #endif
12482e192b24SSimon Glass #if defined(CONFIG_CMD_ENV_CALLBACK)
12492e192b24SSimon Glass "callbacks - print callbacks and their associated variables\nenv "
12502e192b24SSimon Glass #endif
12512e192b24SSimon Glass "default [-f] -a - [forcibly] reset default environment\n"
12522e192b24SSimon Glass "env default [-f] var [...] - [forcibly] reset variable(s) to their default values\n"
12532e192b24SSimon Glass "env delete [-f] var [...] - [forcibly] delete variable(s)\n"
12542e192b24SSimon Glass #if defined(CONFIG_CMD_EDITENV)
12552e192b24SSimon Glass "env edit name - edit environment variable\n"
12562e192b24SSimon Glass #endif
12572e192b24SSimon Glass #if defined(CONFIG_CMD_ENV_EXISTS)
12582e192b24SSimon Glass "env exists name - tests for existence of variable\n"
12592e192b24SSimon Glass #endif
12602e192b24SSimon Glass #if defined(CONFIG_CMD_EXPORTENV)
12612e192b24SSimon Glass "env export [-t | -b | -c] [-s size] addr [var ...] - export environment\n"
12622e192b24SSimon Glass #endif
12632e192b24SSimon Glass #if defined(CONFIG_CMD_ENV_FLAGS)
12642e192b24SSimon Glass "env flags - print variables that have non-default flags\n"
12652e192b24SSimon Glass #endif
12662e192b24SSimon Glass #if defined(CONFIG_CMD_GREPENV)
12672e192b24SSimon Glass #ifdef CONFIG_REGEX
12682e192b24SSimon Glass "env grep [-e] [-n | -v | -b] string [...] - search environment\n"
12692e192b24SSimon Glass #else
12702e192b24SSimon Glass "env grep [-n | -v | -b] string [...] - search environment\n"
12712e192b24SSimon Glass #endif
12722e192b24SSimon Glass #endif
12732e192b24SSimon Glass #if defined(CONFIG_CMD_IMPORTENV)
1274eaf73472SQuentin Schulz "env import [-d] [-t [-r] | -b | -c] addr [size] [var ...] - import environment\n"
12752e192b24SSimon Glass #endif
12762e192b24SSimon Glass "env print [-a | name ...] - print environment\n"
1277*49d81fdfSAKASHI Takahiro #if defined(CONFIG_CMD_NVEDIT_EFI)
1278*49d81fdfSAKASHI Takahiro "env print -e [name ...] - print UEFI environment\n"
1279*49d81fdfSAKASHI Takahiro #endif
12802e192b24SSimon Glass #if defined(CONFIG_CMD_RUN)
12812e192b24SSimon Glass "env run var [...] - run commands in an environment variable\n"
12822e192b24SSimon Glass #endif
12832e192b24SSimon Glass #if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE)
12842e192b24SSimon Glass "env save - save environment\n"
12852e192b24SSimon Glass #endif
1286*49d81fdfSAKASHI Takahiro #if defined(CONFIG_CMD_NVEDIT_EFI)
1287*49d81fdfSAKASHI Takahiro "env set -e name [arg ...] - set UEFI variable; unset if 'arg' not specified\n"
1288*49d81fdfSAKASHI Takahiro #endif
12892e192b24SSimon Glass "env set [-f] name [arg ...]\n";
12902e192b24SSimon Glass #endif
12912e192b24SSimon Glass
12922e192b24SSimon Glass U_BOOT_CMD(
12932e192b24SSimon Glass env, CONFIG_SYS_MAXARGS, 1, do_env,
12942e192b24SSimon Glass "environment handling commands", env_help_text
12952e192b24SSimon Glass );
12962e192b24SSimon Glass
12972e192b24SSimon Glass /*
12982e192b24SSimon Glass * Old command line interface, kept for compatibility
12992e192b24SSimon Glass */
13002e192b24SSimon Glass
13012e192b24SSimon Glass #if defined(CONFIG_CMD_EDITENV)
13022e192b24SSimon Glass U_BOOT_CMD_COMPLETE(
13032e192b24SSimon Glass editenv, 2, 0, do_env_edit,
13042e192b24SSimon Glass "edit environment variable",
13052e192b24SSimon Glass "name\n"
13062e192b24SSimon Glass " - edit environment variable 'name'",
13072e192b24SSimon Glass var_complete
13082e192b24SSimon Glass );
13092e192b24SSimon Glass #endif
13102e192b24SSimon Glass
13112e192b24SSimon Glass U_BOOT_CMD_COMPLETE(
13122e192b24SSimon Glass printenv, CONFIG_SYS_MAXARGS, 1, do_env_print,
13132e192b24SSimon Glass "print environment variables",
13142e192b24SSimon Glass "[-a]\n - print [all] values of all environment variables\n"
1315*49d81fdfSAKASHI Takahiro #if defined(CONFIG_CMD_NVEDIT_EFI)
1316*49d81fdfSAKASHI Takahiro "printenv -e [name ...]\n"
1317*49d81fdfSAKASHI Takahiro " - print UEFI variable 'name' or all the variables\n"
1318*49d81fdfSAKASHI Takahiro #endif
13192e192b24SSimon Glass "printenv name ...\n"
13202e192b24SSimon Glass " - print value of environment variable 'name'",
13212e192b24SSimon Glass var_complete
13222e192b24SSimon Glass );
13232e192b24SSimon Glass
13242e192b24SSimon Glass #ifdef CONFIG_CMD_GREPENV
13252e192b24SSimon Glass U_BOOT_CMD_COMPLETE(
13262e192b24SSimon Glass grepenv, CONFIG_SYS_MAXARGS, 0, do_env_grep,
13272e192b24SSimon Glass "search environment variables",
13282e192b24SSimon Glass #ifdef CONFIG_REGEX
13292e192b24SSimon Glass "[-e] [-n | -v | -b] string ...\n"
13302e192b24SSimon Glass #else
13312e192b24SSimon Glass "[-n | -v | -b] string ...\n"
13322e192b24SSimon Glass #endif
13332e192b24SSimon Glass " - list environment name=value pairs matching 'string'\n"
13342e192b24SSimon Glass #ifdef CONFIG_REGEX
13352e192b24SSimon Glass " \"-e\": enable regular expressions;\n"
13362e192b24SSimon Glass #endif
13372e192b24SSimon Glass " \"-n\": search variable names; \"-v\": search values;\n"
13382e192b24SSimon Glass " \"-b\": search both names and values (default)",
13392e192b24SSimon Glass var_complete
13402e192b24SSimon Glass );
13412e192b24SSimon Glass #endif
13422e192b24SSimon Glass
13432e192b24SSimon Glass U_BOOT_CMD_COMPLETE(
13442e192b24SSimon Glass setenv, CONFIG_SYS_MAXARGS, 0, do_env_set,
13452e192b24SSimon Glass "set environment variables",
1346*49d81fdfSAKASHI Takahiro #if defined(CONFIG_CMD_NVEDIT_EFI)
1347*49d81fdfSAKASHI Takahiro "-e name [value ...]\n"
1348*49d81fdfSAKASHI Takahiro " - set UEFI variable 'name' to 'value' ...'\n"
1349*49d81fdfSAKASHI Takahiro " - delete UEFI variable 'name' if 'value' not specified\n"
1350*49d81fdfSAKASHI Takahiro #endif
1351*49d81fdfSAKASHI Takahiro "setenv [-f] name value ...\n"
13522e192b24SSimon Glass " - [forcibly] set environment variable 'name' to 'value ...'\n"
13532e192b24SSimon Glass "setenv [-f] name\n"
13542e192b24SSimon Glass " - [forcibly] delete environment variable 'name'",
13552e192b24SSimon Glass var_complete
13562e192b24SSimon Glass );
13572e192b24SSimon Glass
13582e192b24SSimon Glass #if defined(CONFIG_CMD_ASKENV)
13592e192b24SSimon Glass
13602e192b24SSimon Glass U_BOOT_CMD(
13612e192b24SSimon Glass askenv, CONFIG_SYS_MAXARGS, 1, do_env_ask,
13622e192b24SSimon Glass "get environment variables from stdin",
13632e192b24SSimon Glass "name [message] [size]\n"
13642e192b24SSimon Glass " - get environment variable 'name' from stdin (max 'size' chars)"
13652e192b24SSimon Glass );
13662e192b24SSimon Glass #endif
13672e192b24SSimon Glass
13682e192b24SSimon Glass #if defined(CONFIG_CMD_RUN)
13692e192b24SSimon Glass U_BOOT_CMD_COMPLETE(
13702e192b24SSimon Glass run, CONFIG_SYS_MAXARGS, 1, do_run,
13712e192b24SSimon Glass "run commands in an environment variable",
13722e192b24SSimon Glass "var [...]\n"
13732e192b24SSimon Glass " - run the commands in the environment variable(s) 'var'",
13742e192b24SSimon Glass var_complete
13752e192b24SSimon Glass );
13762e192b24SSimon Glass #endif
13772e192b24SSimon Glass #endif /* CONFIG_SPL_BUILD */
1378