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