cmd/nvedit.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * (C) Copyright 2000-2013
   4  * Wolfgang Denk, DENX Software Engineering, [email protected].
   5  *
   6  * (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
   7  * Andreas Heppel <[email protected]>
   8  *
   9  * Copyright 2011 Freescale Semiconductor, Inc.
  10  */
  11
  12 /*
  13  * Support for persistent environment data
  14  *
  15  * The "environment" is stored on external storage as a list of '\0'
  16  * terminated "name=value" strings. The end of the list is marked by
  17  * a double '\0'. The environment is preceded by a 32 bit CRC over
  18  * the data part and, in case of redundant environment, a byte of
  19  * flags.
  20  *
  21  * This linearized representation will also be used before
  22  * relocation, i. e. as long as we don't have a full C runtime
  23  * environment. After that, we use a hash table.
  24  */
  25
  26 #include <common.h>
  27 #include <cli.h>
  28 #include <command.h>
  29 #include <console.h>
  30 #include <env.h>
  31 #include <env_internal.h>
  32 #include <log.h>
  33 #include <search.h>
  34 #include <errno.h>
  35 #include <malloc.h>
  36 #include <mapmem.h>
  37 #include <asm/global_data.h>
  38 #include <linux/bitops.h>
  39 #include <linux/printk.h>
  40 #include <u-boot/crc.h>
  41 #include <linux/stddef.h>
  42 #include <asm/byteorder.h>
  43 #include <asm/io.h>
  44
  45 DECLARE_GLOBAL_DATA_PTR;
  46
  47 /*
  48  * Maximum expected input data size for import command
  49  */
  50 #define MAX_ENV_SIZE    (1 << 20)       /* 1 MiB */
  51
  52 /*
  53  * This variable is incremented on each do_env_set(), so it can
  54  * be used via env_get_id() as an indication, if the environment
  55  * has changed or not. So it is possible to reread an environment
  56  * variable only if the environment was changed ... done so for
  57  * example in NetInitLoop()
  58  */
  59 static int env_id = 1;
  60
  61 int env_get_id(void)
  62 {
  63         return env_id;
  64 }
  65
  66 #ifndef CONFIG_SPL_BUILD
  67 /*
  68  * Command interface: print one or all environment variables
  69  *
  70  * Returns 0 in case of error, or length of printed string
  71  */
  72 static int env_print(char *name, int flag)
  73 {
  74         char *res = NULL;
  75         ssize_t len;
  76
  77         if (name) {             /* print a single name */
  78                 struct env_entry e, *ep;
  79
  80                 e.key = name;
  81                 e.data = NULL;
  82                 hsearch_r(e, ENV_FIND, &ep, &env_htab, flag);
  83                 if (ep == NULL)
  84                         return 0;
  85                 len = printf("%s=%s\n", ep->key, ep->data);
  86                 return len;
  87         }
  88
  89         /* print whole list */
  90         len = hexport_r(&env_htab, '\n', flag, &res, 0, 0, NULL);
  91
  92         if (len > 0) {
  93                 puts(res);
  94                 free(res);
  95                 return len;
  96         }
  97
  98         /* should never happen */
  99         printf("## Error: cannot export environment\n");
 100         return 0;
 101 }
 102
 103 static int do_env_print(struct cmd_tbl *cmdtp, int flag, int argc,
 104                         char *const argv[])
 105 {
 106         int i;
 107         int rcode = 0;
 108         int env_flag = H_HIDE_DOT;
 109
 110 #if defined(CONFIG_CMD_NVEDIT_EFI)
 111         if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'e')
 112                 return do_env_print_efi(cmdtp, flag, --argc, ++argv);
 113 #endif
 114
 115         if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'a') {
 116                 argc--;
 117                 argv++;
 118                 env_flag &= ~H_HIDE_DOT;
 119         }
 120
 121         if (argc == 1) {
 122                 /* print all env vars */
 123                 rcode = env_print(NULL, env_flag);
 124                 if (!rcode)
 125                         return 1;
 126                 printf("\nEnvironment size: %d/%ld bytes\n",
 127                         rcode, (ulong)ENV_SIZE);
 128                 return 0;
 129         }
 130
 131         /* print selected env vars */
 132         env_flag &= ~H_HIDE_DOT;
 133         for (i = 1; i < argc; ++i) {
 134                 int rc = env_print(argv[i], env_flag);
 135                 if (!rc) {
 136                         printf("## Error: \"%s\" not defined\n", argv[i]);
 137                         ++rcode;
 138                 }
 139         }
 140
 141         return rcode;
 142 }
 143
 144 #ifdef CONFIG_CMD_GREPENV
 145 static int do_env_grep(struct cmd_tbl *cmdtp, int flag,
 146                        int argc, char *const argv[])
 147 {
 148         char *res = NULL;
 149         int len, grep_how, grep_what;
 150
 151         if (argc < 2)
 152                 return CMD_RET_USAGE;
 153
 154         grep_how  = H_MATCH_SUBSTR;     /* default: substring search    */
 155         grep_what = H_MATCH_BOTH;       /* default: grep names and values */
 156
 157         while (--argc > 0 && **++argv == '-') {
 158                 char *arg = *argv;
 159                 while (*++arg) {
 160                         switch (*arg) {
 161 #ifdef CONFIG_REGEX
 162                         case 'e':               /* use regex matching */
 163                                 grep_how  = H_MATCH_REGEX;
 164                                 break;
 165 #endif
 166                         case 'n':               /* grep for name */
 167                                 grep_what = H_MATCH_KEY;
 168                                 break;
 169                         case 'v':               /* grep for value */
 170                                 grep_what = H_MATCH_DATA;
 171                                 break;
 172                         case 'b':               /* grep for both */
 173                                 grep_what = H_MATCH_BOTH;
 174                                 break;
 175                         case '-':
 176                                 goto DONE;
 177                         default:
 178                                 return CMD_RET_USAGE;
 179                         }
 180                 }
 181         }
 182
 183 DONE:
 184         len = hexport_r(&env_htab, '\n',
 185                         flag | grep_what | grep_how,
 186                         &res, 0, argc, argv);
 187
 188         if (len > 0) {
 189                 puts(res);
 190                 free(res);
 191         }
 192
 193         if (len < 2)
 194                 return 1;
 195
 196         return 0;
 197 }
 198 #endif
 199 #endif /* CONFIG_SPL_BUILD */
 200
 201 /*
 202  * Set a new environment variable,
 203  * or replace or delete an existing one.
 204  */
 205 static int _do_env_set(int flag, int argc, char *const argv[], int env_flag)
 206 {
 207         int   i, len;
 208         char  *name, *value, *s;
 209         struct env_entry e, *ep;
 210
 211         debug("Initial value for argc=%d\n", argc);
 212
 213 #if !IS_ENABLED(CONFIG_SPL_BUILD) && IS_ENABLED(CONFIG_CMD_NVEDIT_EFI)
 214         if (argc > 1 && argv[1][0] == '-' && argv[1][1] == 'e')
 215                 return do_env_set_efi(NULL, flag, --argc, ++argv);
 216 #endif
 217
 218         while (argc > 1 && **(argv + 1) == '-') {
 219                 char *arg = *++argv;
 220
 221                 --argc;
 222                 while (*++arg) {
 223                         switch (*arg) {
 224                         case 'f':               /* force */
 225                                 env_flag |= H_FORCE;
 226                                 break;
 227                         default:
 228                                 return CMD_RET_USAGE;
 229                         }
 230                 }
 231         }
 232         debug("Final value for argc=%d\n", argc);
 233         name = argv[1];
 234
 235         if (strchr(name, '=')) {
 236                 printf("## Error: illegal character '='"
 237                        "in variable name \"%s\"\n", name);
 238                 return 1;
 239         }
 240
 241         env_id++;
 242
 243         /* Delete only ? */
 244         if (argc < 3 || argv[2] == NULL) {
 245                 int rc = hdelete_r(name, &env_htab, env_flag);
 246
 247                 /* If the variable didn't exist, don't report an error */
 248                 return rc && rc != -ENOENT ? 1 : 0;
 249         }
 250
 251         /*
 252          * Insert / replace new value
 253          */
 254         for (i = 2, len = 0; i < argc; ++i)
 255                 len += strlen(argv[i]) + 1;
 256
 257         value = malloc(len);
 258         if (value == NULL) {
 259                 printf("## Can't malloc %d bytes\n", len);
 260                 return 1;
 261         }
 262         for (i = 2, s = value; i < argc; ++i) {
 263                 char *v = argv[i];
 264
 265                 while ((*s++ = *v++) != '\0')
 266                         ;
 267                 *(s - 1) = ' ';
 268         }
 269         if (s != value)
 270                 *--s = '\0';
 271
 272         e.key   = name;
 273         e.data  = value;
 274         hsearch_r(e, ENV_ENTER, &ep, &env_htab, env_flag);
 275         free(value);
 276         if (!ep) {
 277                 printf("## Error inserting \"%s\" variable, errno=%d\n",
 278                         name, errno);
 279                 return 1;
 280         }
 281
 282         return 0;
 283 }
 284
 285 int env_set(const char *varname, const char *varvalue)
 286 {
 287         const char * const argv[4] = { "setenv", varname, varvalue, NULL };
 288
 289         /* before import into hashtable */
 290         if (!(gd->flags & GD_FLG_ENV_READY))
 291                 return 1;
 292
 293         if (varvalue == NULL || varvalue[0] == '\0')
 294                 return _do_env_set(0, 2, (char * const *)argv, H_PROGRAMMATIC);
 295         else
 296                 return _do_env_set(0, 3, (char * const *)argv, H_PROGRAMMATIC);
 297 }
 298
 299 #ifndef CONFIG_SPL_BUILD
 300 static int do_env_set(struct cmd_tbl *cmdtp, int flag, int argc,
 301                       char *const argv[])
 302 {
 303         if (argc < 2)
 304                 return CMD_RET_USAGE;
 305
 306         return _do_env_set(flag, argc, argv, H_INTERACTIVE);
 307 }
 308
 309 /*
 310  * Prompt for environment variable
 311  */
 312 #if defined(CONFIG_CMD_ASKENV)
 313 int do_env_ask(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 314 {
 315         char message[CONFIG_SYS_CBSIZE];
 316         int i, len, pos, size;
 317         char *local_args[4];
 318         char *endptr;
 319
 320         local_args[0] = argv[0];
 321         local_args[1] = argv[1];
 322         local_args[2] = NULL;
 323         local_args[3] = NULL;
 324
 325         /*
 326          * Check the syntax:
 327          *
 328          * env_ask envname [message1 ...] [size]
 329          */
 330         if (argc == 1)
 331                 return CMD_RET_USAGE;
 332
 333         /*
 334          * We test the last argument if it can be converted
 335          * into a decimal number.  If yes, we assume it's
 336          * the size.  Otherwise we echo it as part of the
 337          * message.
 338          */
 339         i = dectoul(argv[argc - 1], &endptr);
 340         if (*endptr != '\0') {                  /* no size */
 341                 size = CONFIG_SYS_CBSIZE - 1;
 342         } else {                                /* size given */
 343                 size = i;
 344                 --argc;
 345         }
 346
 347         if (argc <= 2) {
 348                 sprintf(message, "Please enter '%s': ", argv[1]);
 349         } else {
 350                 /* env_ask envname message1 ... messagen [size] */
 351                 for (i = 2, pos = 0; i < argc && pos+1 < sizeof(message); i++) {
 352                         if (pos)
 353                                 message[pos++] = ' ';
 354
 355                         strncpy(message + pos, argv[i], sizeof(message) - pos);
 356                         pos += strlen(argv[i]);
 357                 }
 358                 if (pos < sizeof(message) - 1) {
 359                         message[pos++] = ' ';
 360                         message[pos] = '\0';
 361                 } else
 362                         message[CONFIG_SYS_CBSIZE - 1] = '\0';
 363         }
 364
 365         if (size >= CONFIG_SYS_CBSIZE)
 366                 size = CONFIG_SYS_CBSIZE - 1;
 367
 368         if (size <= 0)
 369                 return 1;
 370
 371         /* prompt for input */
 372         len = cli_readline(message);
 373
 374         if (size < len)
 375                 console_buffer[size] = '\0';
 376
 377         len = 2;
 378         if (console_buffer[0] != '\0') {
 379                 local_args[2] = console_buffer;
 380                 len = 3;
 381         }
 382
 383         /* Continue calling setenv code */
 384         return _do_env_set(flag, len, local_args, H_INTERACTIVE);
 385 }
 386 #endif
 387
 388 #if defined(CONFIG_CMD_ENV_CALLBACK)
 389 static int print_static_binding(const char *var_name, const char *callback_name,
 390                                 void *priv)
 391 {
 392         printf("\t%-20s %-20s\n", var_name, callback_name);
 393
 394         return 0;
 395 }
 396
 397 static int print_active_callback(struct env_entry *entry)
 398 {
 399         struct env_clbk_tbl *clbkp;
 400         int i;
 401         int num_callbacks;
 402
 403         if (entry->callback == NULL)
 404                 return 0;
 405
 406         /* look up the callback in the linker-list */
 407         num_callbacks = ll_entry_count(struct env_clbk_tbl, env_clbk);
 408         for (i = 0, clbkp = ll_entry_start(struct env_clbk_tbl, env_clbk);
 409              i < num_callbacks;
 410              i++, clbkp++) {
 411                 if (entry->callback == clbkp->callback)
 412                         break;
 413         }
 414
 415         if (i == num_callbacks)
 416                 /* this should probably never happen, but just in case... */
 417                 printf("\t%-20s %p\n", entry->key, entry->callback);
 418         else
 419                 printf("\t%-20s %-20s\n", entry->key, clbkp->name);
 420
 421         return 0;
 422 }
 423
 424 /*
 425  * Print the callbacks available and what they are bound to
 426  */
 427 int do_env_callback(struct cmd_tbl *cmdtp, int flag, int argc,
 428                     char *const argv[])
 429 {
 430         struct env_clbk_tbl *clbkp;
 431         int i;
 432         int num_callbacks;
 433
 434         /* Print the available callbacks */
 435         puts("Available callbacks:\n");
 436         puts("\tCallback Name\n");
 437         puts("\t-------------\n");
 438         num_callbacks = ll_entry_count(struct env_clbk_tbl, env_clbk);
 439         for (i = 0, clbkp = ll_entry_start(struct env_clbk_tbl, env_clbk);
 440              i < num_callbacks;
 441              i++, clbkp++)
 442                 printf("\t%s\n", clbkp->name);
 443         puts("\n");
 444
 445         /* Print the static bindings that may exist */
 446         puts("Static callback bindings:\n");
 447         printf("\t%-20s %-20s\n", "Variable Name", "Callback Name");
 448         printf("\t%-20s %-20s\n", "-------------", "-------------");
 449         env_attr_walk(ENV_CALLBACK_LIST_STATIC, print_static_binding, NULL);
 450         puts("\n");
 451
 452         /* walk through each variable and print the callback if it has one */
 453         puts("Active callback bindings:\n");
 454         printf("\t%-20s %-20s\n", "Variable Name", "Callback Name");
 455         printf("\t%-20s %-20s\n", "-------------", "-------------");
 456         hwalk_r(&env_htab, print_active_callback);
 457         return 0;
 458 }
 459 #endif
 460
 461 #if defined(CONFIG_CMD_ENV_FLAGS)
 462 static int print_static_flags(const char *var_name, const char *flags,
 463                               void *priv)
 464 {
 465         enum env_flags_vartype type = env_flags_parse_vartype(flags);
 466         enum env_flags_varaccess access = env_flags_parse_varaccess(flags);
 467
 468         printf("\t%-20s %-20s %-20s\n", var_name,
 469                 env_flags_get_vartype_name(type),
 470                 env_flags_get_varaccess_name(access));
 471
 472         return 0;
 473 }
 474
 475 static int print_active_flags(struct env_entry *entry)
 476 {
 477         enum env_flags_vartype type;
 478         enum env_flags_varaccess access;
 479
 480         if (entry->flags == 0)
 481                 return 0;
 482
 483         type = (enum env_flags_vartype)
 484                 (entry->flags & ENV_FLAGS_VARTYPE_BIN_MASK);
 485         access = env_flags_parse_varaccess_from_binflags(entry->flags);
 486         printf("\t%-20s %-20s %-20s\n", entry->key,
 487                 env_flags_get_vartype_name(type),
 488                 env_flags_get_varaccess_name(access));
 489
 490         return 0;
 491 }
 492
 493 /*
 494  * Print the flags available and what variables have flags
 495  */
 496 int do_env_flags(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 497 {
 498         /* Print the available variable types */
 499         printf("Available variable type flags (position %d):\n",
 500                 ENV_FLAGS_VARTYPE_LOC);
 501         puts("\tFlag\tVariable Type Name\n");
 502         puts("\t----\t------------------\n");
 503         env_flags_print_vartypes();
 504         puts("\n");
 505
 506         /* Print the available variable access types */
 507         printf("Available variable access flags (position %d):\n",
 508                 ENV_FLAGS_VARACCESS_LOC);
 509         puts("\tFlag\tVariable Access Name\n");
 510         puts("\t----\t--------------------\n");
 511         env_flags_print_varaccess();
 512         puts("\n");
 513
 514         /* Print the static flags that may exist */
 515         puts("Static flags:\n");
 516         printf("\t%-20s %-20s %-20s\n", "Variable Name", "Variable Type",
 517                 "Variable Access");
 518         printf("\t%-20s %-20s %-20s\n", "-------------", "-------------",
 519                 "---------------");
 520         env_attr_walk(ENV_FLAGS_LIST_STATIC, print_static_flags, NULL);
 521         puts("\n");
 522
 523         /* walk through each variable and print the flags if non-default */
 524         puts("Active flags:\n");
 525         printf("\t%-20s %-20s %-20s\n", "Variable Name", "Variable Type",
 526                 "Variable Access");
 527         printf("\t%-20s %-20s %-20s\n", "-------------", "-------------",
 528                 "---------------");
 529         hwalk_r(&env_htab, print_active_flags);
 530         return 0;
 531 }
 532 #endif
 533
 534 /*
 535  * Interactively edit an environment variable
 536  */
 537 #if defined(CONFIG_CMD_EDITENV)
 538 static int do_env_edit(struct cmd_tbl *cmdtp, int flag, int argc,
 539                        char *const argv[])
 540 {
 541         char buffer[CONFIG_SYS_CBSIZE];
 542         char *init_val;
 543
 544         if (argc < 2)
 545                 return CMD_RET_USAGE;
 546
 547         /* before import into hashtable */
 548         if (!(gd->flags & GD_FLG_ENV_READY))
 549                 return 1;
 550
 551         /* Set read buffer to initial value or empty sting */
 552         init_val = env_get(argv[1]);
 553         if (init_val)
 554                 snprintf(buffer, CONFIG_SYS_CBSIZE, "%s", init_val);
 555         else
 556                 buffer[0] = '\0';
 557
 558         if (cli_readline_into_buffer("edit: ", buffer, 0) < 0)
 559                 return 1;
 560
 561         if (buffer[0] == '\0') {
 562                 const char * const _argv[3] = { "setenv", argv[1], NULL };
 563
 564                 return _do_env_set(0, 2, (char * const *)_argv, H_INTERACTIVE);
 565         } else {
 566                 const char * const _argv[4] = { "setenv", argv[1], buffer,
 567                         NULL };
 568
 569                 return _do_env_set(0, 3, (char * const *)_argv, H_INTERACTIVE);
 570         }
 571 }
 572 #endif /* CONFIG_CMD_EDITENV */
 573
 574 #if defined(CONFIG_CMD_SAVEENV) && !IS_ENABLED(CONFIG_ENV_IS_DEFAULT)
 575 static int do_env_save(struct cmd_tbl *cmdtp, int flag, int argc,
 576                        char *const argv[])
 577 {
 578         return env_save() ? 1 : 0;
 579 }
 580
 581 U_BOOT_CMD(
 582         saveenv, 1, 0,  do_env_save,
 583         "save environment variables to persistent storage",
 584         ""
 585 );
 586
 587 #if defined(CONFIG_CMD_ERASEENV)
 588 static int do_env_erase(struct cmd_tbl *cmdtp, int flag, int argc,
 589                         char *const argv[])
 590 {
 591         return env_erase() ? 1 : 0;
 592 }
 593
 594 U_BOOT_CMD(
 595         eraseenv, 1, 0, do_env_erase,
 596         "erase environment variables from persistent storage",
 597         ""
 598 );
 599 #endif
 600 #endif
 601
 602 #if defined(CONFIG_CMD_NVEDIT_LOAD)
 603 static int do_env_load(struct cmd_tbl *cmdtp, int flag, int argc,
 604                        char *const argv[])
 605 {
 606         return env_reload() ? 1 : 0;
 607 }
 608 #endif
 609
 610 #if defined(CONFIG_CMD_NVEDIT_SELECT)
 611 static int do_env_select(struct cmd_tbl *cmdtp, int flag, int argc,
 612                          char *const argv[])
 613 {
 614         return env_select(argv[1]) ? 1 : 0;
 615 }
 616 #endif
 617
 618 #endif /* CONFIG_SPL_BUILD */
 619
 620 #ifndef CONFIG_SPL_BUILD
 621 static int do_env_default(struct cmd_tbl *cmdtp, int flag,
 622                           int argc, char *const argv[])
 623 {
 624         int all = 0, env_flag = H_INTERACTIVE;
 625
 626         debug("Initial value for argc=%d\n", argc);
 627         while (--argc > 0 && **++argv == '-') {
 628                 char *arg = *argv;
 629
 630                 while (*++arg) {
 631                         switch (*arg) {
 632                         case 'a':               /* default all */
 633                                 all = 1;
 634                                 break;
 635                         case 'f':               /* force */
 636                                 env_flag |= H_FORCE;
 637                                 break;
 638                         default:
 639                                 return cmd_usage(cmdtp);
 640                         }
 641                 }
 642         }
 643         debug("Final value for argc=%d\n", argc);
 644         if (all && (argc == 0)) {
 645                 /* Reset the whole environment */
 646                 env_set_default("## Resetting to default environment\n",
 647                                 env_flag);
 648                 return 0;
 649         }
 650         if (!all && (argc > 0)) {
 651                 /* Reset individual variables */
 652                 env_set_default_vars(argc, argv, env_flag);
 653                 return 0;
 654         }
 655
 656         return cmd_usage(cmdtp);
 657 }
 658
 659 static int do_env_delete(struct cmd_tbl *cmdtp, int flag,
 660                          int argc, char *const argv[])
 661 {
 662         int env_flag = H_INTERACTIVE;
 663         int ret = 0;
 664
 665         debug("Initial value for argc=%d\n", argc);
 666         while (argc > 1 && **(argv + 1) == '-') {
 667                 char *arg = *++argv;
 668
 669                 --argc;
 670                 while (*++arg) {
 671                         switch (*arg) {
 672                         case 'f':               /* force */
 673                                 env_flag |= H_FORCE;
 674                                 break;
 675                         default:
 676                                 return CMD_RET_USAGE;
 677                         }
 678                 }
 679         }
 680         debug("Final value for argc=%d\n", argc);
 681
 682         env_id++;
 683
 684         while (--argc > 0) {
 685                 char *name = *++argv;
 686
 687                 if (hdelete_r(name, &env_htab, env_flag))
 688                         ret = 1;
 689         }
 690
 691         return ret;
 692 }
 693
 694 #ifdef CONFIG_CMD_EXPORTENV
 695 /*
 696  * env export [-t | -b | -c] [-s size] addr [var ...]
 697  *      -t:     export as text format; if size is given, data will be
 698  *              padded with '\0' bytes; if not, one terminating '\0'
 699  *              will be added (which is included in the "filesize"
 700  *              setting so you can for exmple copy this to flash and
 701  *              keep the termination).
 702  *      -b:     export as binary format (name=value pairs separated by
 703  *              '\0', list end marked by double "\0\0")
 704  *      -c:     export as checksum protected environment format as
 705  *              used for example by "saveenv" command
 706  *      -s size:
 707  *              size of output buffer
 708  *      addr:   memory address where environment gets stored
 709  *      var...  List of variable names that get included into the
 710  *              export. Without arguments, the whole environment gets
 711  *              exported.
 712  *
 713  * With "-c" and size is NOT given, then the export command will
 714  * format the data as currently used for the persistent storage,
 715  * i. e. it will use CONFIG_ENV_SECT_SIZE as output block size and
 716  * prepend a valid CRC32 checksum and, in case of redundant
 717  * environment, a "current" redundancy flag. If size is given, this
 718  * value will be used instead of CONFIG_ENV_SECT_SIZE; again, CRC32
 719  * checksum and redundancy flag will be inserted.
 720  *
 721  * With "-b" and "-t", always only the real data (including a
 722  * terminating '\0' byte) will be written; here the optional size
 723  * argument will be used to make sure not to overflow the user
 724  * provided buffer; the command will abort if the size is not
 725  * sufficient. Any remaining space will be '\0' padded.
 726  *
 727  * On successful return, the variable "filesize" will be set.
 728  * Note that filesize includes the trailing/terminating '\0' byte(s).
 729  *
 730  * Usage scenario:  create a text snapshot/backup of the current settings:
 731  *
 732  *      => env export -t 100000
 733  *      => era ${backup_addr} +${filesize}
 734  *      => cp.b 100000 ${backup_addr} ${filesize}
 735  *
 736  * Re-import this snapshot, deleting all other settings:
 737  *
 738  *      => env import -d -t ${backup_addr}
 739  */
 740 static int do_env_export(struct cmd_tbl *cmdtp, int flag,
 741                          int argc, char *const argv[])
 742 {
 743         char    buf[32];
 744         ulong   addr;
 745         char    *ptr, *cmd, *res;
 746         size_t  size = 0;
 747         ssize_t len;
 748         env_t   *envp;
 749         char    sep = '\n';
 750         int     chk = 0;
 751         int     fmt = 0;
 752
 753         cmd = *argv;
 754
 755         while (--argc > 0 && **++argv == '-') {
 756                 char *arg = *argv;
 757                 while (*++arg) {
 758                         switch (*arg) {
 759                         case 'b':               /* raw binary format */
 760                                 if (fmt++)
 761                                         goto sep_err;
 762                                 sep = '\0';
 763                                 break;
 764                         case 'c':               /* external checksum format */
 765                                 if (fmt++)
 766                                         goto sep_err;
 767                                 sep = '\0';
 768                                 chk = 1;
 769                                 break;
 770                         case 's':               /* size given */
 771                                 if (--argc <= 0)
 772                                         return cmd_usage(cmdtp);
 773                                 size = hextoul(*++argv, NULL);
 774                                 goto NXTARG;
 775                         case 't':               /* text format */
 776                                 if (fmt++)
 777                                         goto sep_err;
 778                                 sep = '\n';
 779                                 break;
 780                         default:
 781                                 return CMD_RET_USAGE;
 782                         }
 783                 }
 784 NXTARG:         ;
 785         }
 786
 787         if (argc < 1)
 788                 return CMD_RET_USAGE;
 789
 790         addr = hextoul(argv[0], NULL);
 791         ptr = map_sysmem(addr, size);
 792
 793         if (size)
 794                 memset(ptr, '\0', size);
 795
 796         argc--;
 797         argv++;
 798
 799         if (sep) {              /* export as text file */
 800                 len = hexport_r(&env_htab, sep,
 801                                 H_MATCH_KEY | H_MATCH_IDENT,
 802                                 &ptr, size, argc, argv);
 803                 if (len < 0) {
 804                         pr_err("## Error: Cannot export environment: errno = %d\n",
 805                                errno);
 806                         return 1;
 807                 }
 808                 sprintf(buf, "%zX", (size_t)len);
 809                 env_set("filesize", buf);
 810
 811                 return 0;
 812         }
 813
 814         envp = (env_t *)ptr;
 815
 816         if (chk)                /* export as checksum protected block */
 817                 res = (char *)envp->data;
 818         else                    /* export as raw binary data */
 819                 res = ptr;
 820
 821         len = hexport_r(&env_htab, '\0',
 822                         H_MATCH_KEY | H_MATCH_IDENT,
 823                         &res, ENV_SIZE, argc, argv);
 824         if (len < 0) {
 825                 pr_err("## Error: Cannot export environment: errno = %d\n",
 826                        errno);
 827                 return 1;
 828         }
 829
 830         if (chk) {
 831                 envp->crc = crc32(0, envp->data,
 832                                 size ? size - offsetof(env_t, data) : ENV_SIZE);
 833 #ifdef CONFIG_ENV_ADDR_REDUND
 834                 envp->flags = ENV_REDUND_ACTIVE;
 835 #endif
 836         }
 837         env_set_hex("filesize", len + offsetof(env_t, data));
 838
 839         return 0;
 840
 841 sep_err:
 842         printf("## Error: %s: only one of \"-b\", \"-c\" or \"-t\" allowed\n",
 843                cmd);
 844         return 1;
 845 }
 846 #endif
 847
 848 #ifdef CONFIG_CMD_IMPORTENV
 849 /*
 850  * env import [-d] [-t [-r] | -b | -c] addr [size] [var ...]
 851  *      -d:     delete existing environment before importing if no var is
 852  *              passed; if vars are passed, if one var is in the current
 853  *              environment but not in the environment at addr, delete var from
 854  *              current environment;
 855  *              otherwise overwrite / append to existing definitions
 856  *      -t:     assume text format; either "size" must be given or the
 857  *              text data must be '\0' terminated
 858  *      -r:     handle CRLF like LF, that means exported variables with
 859  *              a content which ends with \r won't get imported. Used
 860  *              to import text files created with editors which are using CRLF
 861  *              for line endings. Only effective in addition to -t.
 862  *      -b:     assume binary format ('\0' separated, "\0\0" terminated)
 863  *      -c:     assume checksum protected environment format
 864  *      addr:   memory address to read from
 865  *      size:   length of input data; if missing, proper '\0'
 866  *              termination is mandatory
 867  *              if var is set and size should be missing (i.e. '\0'
 868  *              termination), set size to '-'
 869  *      var...  List of the names of the only variables that get imported from
 870  *              the environment at address 'addr'. Without arguments, the whole
 871  *              environment gets imported.
 872  */
 873 static int do_env_import(struct cmd_tbl *cmdtp, int flag,
 874                          int argc, char *const argv[])
 875 {
 876         ulong   addr;
 877         char    *cmd, *ptr;
 878         char    sep = '\n';
 879         int     chk = 0;
 880         int     fmt = 0;
 881         int     del = 0;
 882         int     crlf_is_lf = 0;
 883         int     wl = 0;
 884         size_t  size;
 885
 886         cmd = *argv;
 887
 888         while (--argc > 0 && **++argv == '-') {
 889                 char *arg = *argv;
 890                 while (*++arg) {
 891                         switch (*arg) {
 892                         case 'b':               /* raw binary format */
 893                                 if (fmt++)
 894                                         goto sep_err;
 895                                 sep = '\0';
 896                                 break;
 897                         case 'c':               /* external checksum format */
 898                                 if (fmt++)
 899                                         goto sep_err;
 900                                 sep = '\0';
 901                                 chk = 1;
 902                                 break;
 903                         case 't':               /* text format */
 904                                 if (fmt++)
 905                                         goto sep_err;
 906                                 sep = '\n';
 907                                 break;
 908                         case 'r':               /* handle CRLF like LF */
 909                                 crlf_is_lf = 1;
 910                                 break;
 911                         case 'd':
 912                                 del = 1;
 913                                 break;
 914                         default:
 915                                 return CMD_RET_USAGE;
 916                         }
 917                 }
 918         }
 919
 920         if (argc < 1)
 921                 return CMD_RET_USAGE;
 922
 923         if (!fmt)
 924                 printf("## Warning: defaulting to text format\n");
 925
 926         if (sep != '\n' && crlf_is_lf )
 927                 crlf_is_lf = 0;
 928
 929         addr = hextoul(argv[0], NULL);
 930         ptr = map_sysmem(addr, 0);
 931
 932         if (argc >= 2 && strcmp(argv[1], "-")) {
 933                 size = hextoul(argv[1], NULL);
 934         } else if (chk) {
 935                 puts("## Error: external checksum format must pass size\n");
 936                 return CMD_RET_FAILURE;
 937         } else {
 938                 char *s = ptr;
 939
 940                 size = 0;
 941
 942                 while (size < MAX_ENV_SIZE) {
 943                         if ((*s == sep) && (*(s+1) == '\0'))
 944                                 break;
 945                         ++s;
 946                         ++size;
 947                 }
 948                 if (size == MAX_ENV_SIZE) {
 949                         printf("## Warning: Input data exceeds %d bytes"
 950                                 " - truncated\n", MAX_ENV_SIZE);
 951                 }
 952                 size += 2;
 953                 printf("## Info: input data size = %zu = 0x%zX\n", size, size);
 954         }
 955
 956         if (argc > 2)
 957                 wl = 1;
 958
 959         if (chk) {
 960                 uint32_t crc;
 961                 env_t *ep = (env_t *)ptr;
 962
 963                 if (size <= offsetof(env_t, data)) {
 964                         printf("## Error: Invalid size 0x%zX\n", size);
 965                         return 1;
 966                 }
 967
 968                 size -= offsetof(env_t, data);
 969                 memcpy(&crc, &ep->crc, sizeof(crc));
 970
 971                 if (crc32(0, ep->data, size) != crc) {
 972                         puts("## Error: bad CRC, import failed\n");
 973                         return 1;
 974                 }
 975                 ptr = (char *)ep->data;
 976         }
 977
 978         if (!himport_r(&env_htab, ptr, size, sep, del ? 0 : H_NOCLEAR,
 979                        crlf_is_lf, wl ? argc - 2 : 0, wl ? &argv[2] : NULL)) {
 980                 pr_err("## Error: Environment import failed: errno = %d\n",
 981                        errno);
 982                 return 1;
 983         }
 984         gd->flags |= GD_FLG_ENV_READY;
 985
 986         return 0;
 987
 988 sep_err:
 989         printf("## %s: only one of \"-b\", \"-c\" or \"-t\" allowed\n",
 990                 cmd);
 991         return 1;
 992 }
 993 #endif
 994
 995 #if defined(CONFIG_CMD_NVEDIT_INDIRECT)
 996 static int do_env_indirect(struct cmd_tbl *cmdtp, int flag,
 997                        int argc, char *const argv[])
 998 {
 999         char *to = argv[1];
1000         char *from = argv[2];
1001         char *default_value = NULL;
1002         int ret = 0;
1003         char *val;
1004
1005         if (argc < 3 || argc > 4) {
1006                 return CMD_RET_USAGE;
1007         }
1008
1009         if (argc == 4) {
1010                 default_value = argv[3];
1011         }
1012
1013         val = env_get(from) ?: default_value;
1014         if (!val) {
1015                 printf("## env indirect: Environment variable for <from> (%s) does not exist.\n", from);
1016
1017                 return CMD_RET_FAILURE;
1018         }
1019
1020         ret = env_set(to, val);
1021
1022         if (ret == 0) {
1023                 return CMD_RET_SUCCESS;
1024         }
1025         else {
1026                 return CMD_RET_FAILURE;
1027         }
1028 }
1029 #endif
1030
1031 #if defined(CONFIG_CMD_NVEDIT_INFO)
1032 /*
1033  * print_env_info - print environment information
1034  */
1035 static int print_env_info(void)
1036 {
1037         const char *value;
1038
1039         /* print environment validity value */
1040         switch (gd->env_valid) {
1041         case ENV_INVALID:
1042                 value = "invalid";
1043                 break;
1044         case ENV_VALID:
1045                 value = "valid";
1046                 break;
1047         case ENV_REDUND:
1048                 value = "redundant";
1049                 break;
1050         default:
1051                 value = "unknown";
1052                 break;
1053         }
1054         printf("env_valid = %s\n", value);
1055
1056         /* print environment ready flag */
1057         value = gd->flags & GD_FLG_ENV_READY ? "true" : "false";
1058         printf("env_ready = %s\n", value);
1059
1060         /* print environment using default flag */
1061         value = gd->flags & GD_FLG_ENV_DEFAULT ? "true" : "false";
1062         printf("env_use_default = %s\n", value);
1063
1064         return CMD_RET_SUCCESS;
1065 }
1066
1067 #define ENV_INFO_IS_DEFAULT     BIT(0) /* default environment bit mask */
1068 #define ENV_INFO_IS_PERSISTED   BIT(1) /* environment persistence bit mask */
1069
1070 /*
1071  * env info - display environment information
1072  * env info [-d] - evaluate whether default environment is used
1073  * env info [-p] - evaluate whether environment can be persisted
1074  *      Add [-q] - quiet mode, use only for command result, for test by example:
1075  *                 test env info -p -d -q
1076  */
1077 static int do_env_info(struct cmd_tbl *cmdtp, int flag,
1078                        int argc, char *const argv[])
1079 {
1080         int eval_flags = 0;
1081         int eval_results = 0;
1082         bool quiet = false;
1083 #if defined(CONFIG_CMD_SAVEENV) && !IS_ENABLED(CONFIG_ENV_IS_DEFAULT)
1084         enum env_location loc;
1085 #endif
1086
1087         /* display environment information */
1088         if (argc <= 1)
1089                 return print_env_info();
1090
1091         /* process options */
1092         while (--argc > 0 && **++argv == '-') {
1093                 char *arg = *argv;
1094
1095                 while (*++arg) {
1096                         switch (*arg) {
1097                         case 'd':
1098                                 eval_flags |= ENV_INFO_IS_DEFAULT;
1099                                 break;
1100                         case 'p':
1101                                 eval_flags |= ENV_INFO_IS_PERSISTED;
1102                                 break;
1103                         case 'q':
1104                                 quiet = true;
1105                                 break;
1106                         default:
1107                                 return CMD_RET_USAGE;
1108                         }
1109                 }
1110         }
1111
1112         /* evaluate whether default environment is used */
1113         if (eval_flags & ENV_INFO_IS_DEFAULT) {
1114                 if (gd->flags & GD_FLG_ENV_DEFAULT) {
1115                         if (!quiet)
1116                                 printf("Default environment is used\n");
1117                         eval_results |= ENV_INFO_IS_DEFAULT;
1118                 } else {
1119                         if (!quiet)
1120                                 printf("Environment was loaded from persistent storage\n");
1121                 }
1122         }
1123
1124         /* evaluate whether environment can be persisted */
1125         if (eval_flags & ENV_INFO_IS_PERSISTED) {
1126 #if defined(CONFIG_CMD_SAVEENV) && !IS_ENABLED(CONFIG_ENV_IS_DEFAULT)
1127                 loc = env_get_location(ENVOP_SAVE, gd->env_load_prio);
1128                 if (ENVL_NOWHERE != loc && ENVL_UNKNOWN != loc) {
1129                         if (!quiet)
1130                                 printf("Environment can be persisted\n");
1131                         eval_results |= ENV_INFO_IS_PERSISTED;
1132                 } else {
1133                         if (!quiet)
1134                                 printf("Environment cannot be persisted\n");
1135                 }
1136 #else
1137                 if (!quiet)
1138                         printf("Environment cannot be persisted\n");
1139 #endif
1140         }
1141
1142         /* The result of evaluations is combined with AND */
1143         if (eval_flags != eval_results)
1144                 return CMD_RET_FAILURE;
1145
1146         return CMD_RET_SUCCESS;
1147 }
1148 #endif
1149
1150 #if defined(CONFIG_CMD_ENV_EXISTS)
1151 static int do_env_exists(struct cmd_tbl *cmdtp, int flag, int argc,
1152                          char *const argv[])
1153 {
1154         struct env_entry e, *ep;
1155
1156         if (argc < 2)
1157                 return CMD_RET_USAGE;
1158
1159         e.key = argv[1];
1160         e.data = NULL;
1161         hsearch_r(e, ENV_FIND, &ep, &env_htab, 0);
1162
1163         return (ep == NULL) ? 1 : 0;
1164 }
1165 #endif
1166
1167 /*
1168  * New command line interface: "env" command with subcommands
1169  */
1170 static struct cmd_tbl cmd_env_sub[] = {
1171 #if defined(CONFIG_CMD_ASKENV)
1172         U_BOOT_CMD_MKENT(ask, CONFIG_SYS_MAXARGS, 1, do_env_ask, "", ""),
1173 #endif
1174         U_BOOT_CMD_MKENT(default, 1, 0, do_env_default, "", ""),
1175         U_BOOT_CMD_MKENT(delete, CONFIG_SYS_MAXARGS, 0, do_env_delete, "", ""),
1176 #if defined(CONFIG_CMD_EDITENV)
1177         U_BOOT_CMD_MKENT(edit, 2, 0, do_env_edit, "", ""),
1178 #endif
1179 #if defined(CONFIG_CMD_ENV_CALLBACK)
1180         U_BOOT_CMD_MKENT(callbacks, 1, 0, do_env_callback, "", ""),
1181 #endif
1182 #if defined(CONFIG_CMD_ENV_FLAGS)
1183         U_BOOT_CMD_MKENT(flags, 1, 0, do_env_flags, "", ""),
1184 #endif
1185 #if defined(CONFIG_CMD_EXPORTENV)
1186         U_BOOT_CMD_MKENT(export, 4, 0, do_env_export, "", ""),
1187 #endif
1188 #if defined(CONFIG_CMD_GREPENV)
1189         U_BOOT_CMD_MKENT(grep, CONFIG_SYS_MAXARGS, 1, do_env_grep, "", ""),
1190 #endif
1191 #if defined(CONFIG_CMD_IMPORTENV)
1192         U_BOOT_CMD_MKENT(import, 5, 0, do_env_import, "", ""),
1193 #endif
1194 #if defined(CONFIG_CMD_NVEDIT_INDIRECT)
1195         U_BOOT_CMD_MKENT(indirect, 3, 0, do_env_indirect, "", ""),
1196 #endif
1197 #if defined(CONFIG_CMD_NVEDIT_INFO)
1198         U_BOOT_CMD_MKENT(info, 3, 0, do_env_info, "", ""),
1199 #endif
1200 #if defined(CONFIG_CMD_NVEDIT_LOAD)
1201         U_BOOT_CMD_MKENT(load, 1, 0, do_env_load, "", ""),
1202 #endif
1203         U_BOOT_CMD_MKENT(print, CONFIG_SYS_MAXARGS, 1, do_env_print, "", ""),
1204 #if defined(CONFIG_CMD_RUN)
1205         U_BOOT_CMD_MKENT(run, CONFIG_SYS_MAXARGS, 1, do_run, "", ""),
1206 #endif
1207 #if defined(CONFIG_CMD_SAVEENV) && !IS_ENABLED(CONFIG_ENV_IS_DEFAULT)
1208         U_BOOT_CMD_MKENT(save, 1, 0, do_env_save, "", ""),
1209 #if defined(CONFIG_CMD_ERASEENV)
1210         U_BOOT_CMD_MKENT(erase, 1, 0, do_env_erase, "", ""),
1211 #endif
1212 #endif
1213 #if defined(CONFIG_CMD_NVEDIT_SELECT)
1214         U_BOOT_CMD_MKENT(select, 2, 0, do_env_select, "", ""),
1215 #endif
1216         U_BOOT_CMD_MKENT(set, CONFIG_SYS_MAXARGS, 0, do_env_set, "", ""),
1217 #if defined(CONFIG_CMD_ENV_EXISTS)
1218         U_BOOT_CMD_MKENT(exists, 2, 0, do_env_exists, "", ""),
1219 #endif
1220 };
1221
1222 static int do_env(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
1223 {
1224         struct cmd_tbl *cp;
1225
1226         if (argc < 2)
1227                 return CMD_RET_USAGE;
1228
1229         /* drop initial "env" arg */
1230         argc--;
1231         argv++;
1232
1233         cp = find_cmd_tbl(argv[0], cmd_env_sub, ARRAY_SIZE(cmd_env_sub));
1234
1235         if (cp)
1236                 return cp->cmd(cmdtp, flag, argc, argv);
1237
1238         return CMD_RET_USAGE;
1239 }
1240
1241 U_BOOT_LONGHELP(env,
1242 #if defined(CONFIG_CMD_ASKENV)
1243         "ask name [message] [size] - ask for environment variable\nenv "
1244 #endif
1245 #if defined(CONFIG_CMD_ENV_CALLBACK)
1246         "callbacks - print callbacks and their associated variables\nenv "
1247 #endif
1248         "default [-f] -a - [forcibly] reset default environment\n"
1249         "env default [-f] var [...] - [forcibly] reset variable(s) to their default values\n"
1250         "env delete [-f] var [...] - [forcibly] delete variable(s)\n"
1251 #if defined(CONFIG_CMD_EDITENV)
1252         "env edit name - edit environment variable\n"
1253 #endif
1254 #if defined(CONFIG_CMD_ENV_EXISTS)
1255         "env exists name - tests for existence of variable\n"
1256 #endif
1257 #if defined(CONFIG_CMD_EXPORTENV)
1258         "env export [-t | -b | -c] [-s size] addr [var ...] - export environment\n"
1259 #endif
1260 #if defined(CONFIG_CMD_ENV_FLAGS)
1261         "env flags - print variables that have non-default flags\n"
1262 #endif
1263 #if defined(CONFIG_CMD_GREPENV)
1264 #ifdef CONFIG_REGEX
1265         "env grep [-e] [-n | -v | -b] string [...] - search environment\n"
1266 #else
1267         "env grep [-n | -v | -b] string [...] - search environment\n"
1268 #endif
1269 #endif
1270 #if defined(CONFIG_CMD_IMPORTENV)
1271         "env import [-d] [-t [-r] | -b | -c] addr [size] [var ...] - import environment\n"
1272 #endif
1273 #if defined(CONFIG_CMD_NVEDIT_INDIRECT)
1274         "env indirect <to> <from> [default] - sets <to> to the value of <from>, using [default] when unset\n"
1275 #endif
1276 #if defined(CONFIG_CMD_NVEDIT_INFO)
1277         "env info - display environment information\n"
1278         "env info [-d] [-p] [-q] - evaluate environment information\n"
1279         "      \"-d\": default environment is used\n"
1280         "      \"-p\": environment can be persisted\n"
1281         "      \"-q\": quiet output\n"
1282 #endif
1283         "env print [-a | name ...] - print environment\n"
1284 #if defined(CONFIG_CMD_NVEDIT_EFI)
1285         "env print -e [-guid guid] [-n] [name ...] - print UEFI environment\n"
1286 #endif
1287 #if defined(CONFIG_CMD_RUN)
1288         "env run var [...] - run commands in an environment variable\n"
1289 #endif
1290 #if defined(CONFIG_CMD_SAVEENV) && !IS_ENABLED(CONFIG_ENV_IS_DEFAULT)
1291         "env save - save environment\n"
1292 #if defined(CONFIG_CMD_ERASEENV)
1293         "env erase - erase environment\n"
1294 #endif
1295 #endif
1296 #if defined(CONFIG_CMD_NVEDIT_LOAD)
1297         "env load - load environment\n"
1298 #endif
1299 #if defined(CONFIG_CMD_NVEDIT_SELECT)
1300         "env select [target] - select environment target\n"
1301 #endif
1302 #if defined(CONFIG_CMD_NVEDIT_EFI)
1303         "env set -e [-nv][-bs][-rt][-at][-a][-i addr:size][-v] name [arg ...]\n"
1304         "    - set UEFI variable; unset if '-i' or 'arg' not specified\n"
1305 #endif
1306         "env set [-f] name [arg ...]\n");
1307
1308 U_BOOT_CMD(
1309         env, CONFIG_SYS_MAXARGS, 1, do_env,
1310         "environment handling commands", env_help_text
1311 );
1312
1313 /*
1314  * Old command line interface, kept for compatibility
1315  */
1316
1317 #if defined(CONFIG_CMD_EDITENV)
1318 U_BOOT_CMD_COMPLETE(
1319         editenv, 2, 0,  do_env_edit,
1320         "edit environment variable",
1321         "name\n"
1322         "    - edit environment variable 'name'",
1323         var_complete
1324 );
1325 #endif
1326
1327 U_BOOT_CMD_COMPLETE(
1328         printenv, CONFIG_SYS_MAXARGS, 1,        do_env_print,
1329         "print environment variables",
1330         "[-a]\n    - print [all] values of all environment variables\n"
1331 #if defined(CONFIG_CMD_NVEDIT_EFI)
1332         "printenv -e [-guid guid][-n] [name ...]\n"
1333         "    - print UEFI variable 'name' or all the variables\n"
1334         "      \"-guid\": GUID xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\n"
1335         "      \"-n\": suppress dumping variable's value\n"
1336 #endif
1337         "printenv name ...\n"
1338         "    - print value of environment variable 'name'",
1339         var_complete
1340 );
1341
1342 #ifdef CONFIG_CMD_GREPENV
1343 U_BOOT_CMD_COMPLETE(
1344         grepenv, CONFIG_SYS_MAXARGS, 0,  do_env_grep,
1345         "search environment variables",
1346 #ifdef CONFIG_REGEX
1347         "[-e] [-n | -v | -b] string ...\n"
1348 #else
1349         "[-n | -v | -b] string ...\n"
1350 #endif
1351         "    - list environment name=value pairs matching 'string'\n"
1352 #ifdef CONFIG_REGEX
1353         "      \"-e\": enable regular expressions;\n"
1354 #endif
1355         "      \"-n\": search variable names; \"-v\": search values;\n"
1356         "      \"-b\": search both names and values (default)",
1357         var_complete
1358 );
1359 #endif
1360
1361 U_BOOT_CMD_COMPLETE(
1362         setenv, CONFIG_SYS_MAXARGS, 0,  do_env_set,
1363         "set environment variables",
1364 #if defined(CONFIG_CMD_NVEDIT_EFI)
1365         "-e [-guid guid][-nv][-bs][-rt][-at][-a][-v]\n"
1366         "        [-i addr:size name], or [name [value ...]]\n"
1367         "    - set UEFI variable 'name' to 'value' ...'\n"
1368         "      \"-guid\": GUID xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\n"
1369         "      \"-nv\": set non-volatile attribute\n"
1370         "      \"-bs\": set boot-service attribute\n"
1371         "      \"-rt\": set runtime attribute\n"
1372         "      \"-at\": set time-based authentication attribute\n"
1373         "      \"-a\": append-write\n"
1374         "      \"-i addr,size\": use <addr,size> as variable's value\n"
1375         "      \"-v\": verbose message\n"
1376         "    - delete UEFI variable 'name' if 'value' not specified\n"
1377 #endif
1378         "setenv [-f] name value ...\n"
1379         "    - [forcibly] set environment variable 'name' to 'value ...'\n"
1380         "setenv [-f] name\n"
1381         "    - [forcibly] delete environment variable 'name'",
1382         var_complete
1383 );
1384
1385 #if defined(CONFIG_CMD_ASKENV)
1386
1387 U_BOOT_CMD(
1388         askenv, CONFIG_SYS_MAXARGS,     1,      do_env_ask,
1389         "get environment variables from stdin",
1390         "name [message] [size]\n"
1391         "    - get environment variable 'name' from stdin (max 'size' chars)"
1392 );
1393 #endif
1394
1395 #if defined(CONFIG_CMD_RUN)
1396 U_BOOT_CMD_COMPLETE(
1397         run,    CONFIG_SYS_MAXARGS,     1,      do_run,
1398         "run commands in an environment variable",
1399         "var [...]\n"
1400         "    - run the commands in the environment variable(s) 'var'",
1401         var_complete
1402 );
1403 #endif
1404 #endif /* CONFIG_SPL_BUILD */