cmd_nvedit.c 24 KB

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