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