on high Ethernet traffic.
Defaults to 4 if not defined.
+- CONFIG_ENV_MAX_ENTRIES
+
+ Maximum number of entries in the hash table that is used
+ internally to store the environment settings. The default
+ setting is supposed to be generous and should work in most
+ cases. This setting can be used to tune behaviour; see
+ lib/hashtable.c for details.
+
The following definitions that deal with the placement and management
of environment data (variable area); in general, we support the
following configurations:
/*
* Global Data Flags
*/
-#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
-#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
-#define GD_FLG_SILENT 0x00004 /* Silent mode */
-#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
-#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
-#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
+#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
+#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
+#define GD_FLG_SILENT 0x00004 /* Silent mode */
+#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
+#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
+#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
#define GD_FLG_DISABLE_CONSOLE 0x00040 /* Disable console (in & out) */
+#define GD_FLG_ENV_READY 0x00080 /* Environment imported into hash table */
#define DECLARE_GLOBAL_DATA_PTR register volatile gd_t *gd asm ("r8")
/*
* Global Data Flags
*/
-#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
-#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
-#define GD_FLG_SILENT 0x00004 /* Silent mode */
-#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
-#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
-#define GD_FLG_LOGINIT 0x00020 /* Log Buf has been initialized */
-#define GD_FLG_DISABLE_CONSOLE 0x00040 /* Disable console (in & out) */
+#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
+#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
+#define GD_FLG_SILENT 0x00004 /* Silent mode */
+#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
+#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
+#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
+#define GD_FLG_DISABLE_CONSOLE 0x00040 /* Disable console (in & out) */
+#define GD_FLG_ENV_READY 0x00080 /* Environment imported into hash table */
#define DECLARE_GLOBAL_DATA_PTR register gd_t *gd asm("r5")
/*
* Global Data Flags
*/
-#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
-#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
-#define GD_FLG_SILENT 0x00004 /* Silent mode */
-#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
-#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
-#define GD_FLG_LOGINIT 0x00020 /* Log Buf has been initialized */
-#define GD_FLG_DISABLE_CONSOLE 0x00040 /* Disable console (in & out) */
+#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
+#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
+#define GD_FLG_SILENT 0x00004 /* Silent mode */
+#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
+#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
+#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
+#define GD_FLG_DISABLE_CONSOLE 0x00040 /* Disable console (in & out) */
+#define GD_FLG_ENV_READY 0x00080 /* Environment imported into hash table */
#define DECLARE_GLOBAL_DATA_PTR register gd_t * volatile gd asm ("P3")
/*
* Global Data Flags
*/
-#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
-#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
-#define GD_FLG_SILENT 0x00004 /* Silent mode */
-#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
-#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
-#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
+#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
+#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
+#define GD_FLG_SILENT 0x00004 /* Silent mode */
+#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
+#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
+#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
#define GD_FLG_DISABLE_CONSOLE 0x00040 /* Disable console (in & out) */
+#define GD_FLG_ENV_READY 0x00080 /* Environment imported into hash table */
extern gd_t *gd;
/*
* Global Data Flags
*/
-#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
-#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
-#define GD_FLG_SILENT 0x00004 /* Silent mode */
-#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
-#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
-#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
+#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
+#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
+#define GD_FLG_SILENT 0x00004 /* Silent mode */
+#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
+#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
+#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
#define GD_FLG_DISABLE_CONSOLE 0x00040 /* Disable console (in & out) */
+#define GD_FLG_ENV_READY 0x00080 /* Environment imported into hash table */
#if 0
extern gd_t *global_data;
/*
* Global Data Flags
*/
-#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
-#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
-#define GD_FLG_SILENT 0x00004 /* Silent mode */
-#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
-#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
-#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
+#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
+#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
+#define GD_FLG_SILENT 0x00004 /* Silent mode */
+#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
+#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
+#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
#define GD_FLG_DISABLE_CONSOLE 0x00040 /* Disable console (in & out) */
+#define GD_FLG_ENV_READY 0x00080 /* Environment imported into hash table */
#define DECLARE_GLOBAL_DATA_PTR register volatile gd_t *gd asm ("r31")
/*
* Global Data Flags
*/
-#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
-#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
-#define GD_FLG_SILENT 0x00004 /* Silent mode */
-#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
-#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
-#define GD_FLG_LOGINIT 0x00020 /* Log Buf has been initialized */
+#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
+#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
+#define GD_FLG_SILENT 0x00004 /* Silent mode */
+#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
+#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
+#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
#define GD_FLG_DISABLE_CONSOLE 0x00040 /* Disable console (in & out) */
+#define GD_FLG_ENV_READY 0x00080 /* Environment imported into hash table */
#define DECLARE_GLOBAL_DATA_PTR register volatile gd_t *gd asm ("k0")
} gd_t;
/* flags */
-#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
-#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
-#define GD_FLG_SILENT 0x00004 /* Silent mode */
-#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
-#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
-#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
+#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
+#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
+#define GD_FLG_SILENT 0x00004 /* Silent mode */
+#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
+#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
+#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
#define GD_FLG_DISABLE_CONSOLE 0x00040 /* Disable console (in & out) */
+#define GD_FLG_ENV_READY 0x00080 /* Environment imported into hash table */
#define DECLARE_GLOBAL_DATA_PTR register gd_t *gd asm ("gp")
/*
* Global Data Flags
*/
-#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
-#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
-#define GD_FLG_SILENT 0x00004 /* Silent mode */
-#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
-#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
-#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
+#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
+#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
+#define GD_FLG_SILENT 0x00004 /* Silent mode */
+#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
+#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
+#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
#define GD_FLG_DISABLE_CONSOLE 0x00040 /* Disable console (in & out) */
+#define GD_FLG_ENV_READY 0x00080 /* Environment imported into hash table */
#if 1
#define DECLARE_GLOBAL_DATA_PTR register volatile gd_t *gd asm ("r2")
char env_buf[32]; /* buffer for getenv() before reloc. */
} gd_t;
-#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
-#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
-#define GD_FLG_SILENT 0x00004 /* Silent mode */
-#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
-#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
-#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
+#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
+#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
+#define GD_FLG_SILENT 0x00004 /* Silent mode */
+#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
+#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
+#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
#define GD_FLG_DISABLE_CONSOLE 0x00040 /* Disable console (in & out) */
+#define GD_FLG_ENV_READY 0x00080 /* Environment imported into hash table */
#define DECLARE_GLOBAL_DATA_PTR register gd_t *gd asm ("r13")
/*
* Global Data Flags
*/
-#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
-#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
-#define GD_FLG_SILENT 0x00004 /* Silent mode */
-#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
-#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
-#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
-#define GD_FLG_DISABLE_CONSOLE 0x00040 /* Disable console (in & out) */
+#define GD_FLG_RELOC 0x00001 /* Code was relocated to RAM */
+#define GD_FLG_DEVINIT 0x00002 /* Devices have been initialized */
+#define GD_FLG_SILENT 0x00004 /* Silent mode */
+#define GD_FLG_POSTFAIL 0x00008 /* Critical POST test failed */
+#define GD_FLG_POSTSTOP 0x00010 /* POST seqeunce aborted */
+#define GD_FLG_LOGINIT 0x00020 /* Log Buffer has been initialized */
+#define GD_FLG_DISABLE_CONSOLE 0x00040 /* Disable console (in & out) */
+#define GD_FLG_ENV_READY 0x00080 /* Environment imported into hash table */
#define DECLARE_GLOBAL_DATA_PTR register volatile gd_t *gd asm ("%g7")
char *buf_save;
u32 crc;
- /*
- * Unprotect and erase environment area
- */
- flash_protect(FLAG_PROTECT_CLEAR,
- CONFIG_ENV_ADDR_REDUND,
- CONFIG_ENV_ADDR_REDUND + 2*CONFIG_ENV_SECT_SIZE - 1,
- &flash_info[0]);
+ set_default_env("");
- flash_sect_erase(CONFIG_ENV_ADDR_REDUND,
- CONFIG_ENV_ADDR_REDUND + 2*CONFIG_ENV_SECT_SIZE - 1);
-
- /*
- * Now restore default environment from U-Boot image
- * -> ipaddr, serverip...
- */
- memset(env_ptr, 0, sizeof(env_t));
- memcpy(env_ptr->data, default_environment, ENV_SIZE);
-#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
- env_ptr->flags = 0xFF;
-#endif
- env_crc_update();
gd->env_valid = 1;
/*
* -> ethaddr, eth1addr, serial#
*/
buf = buf_save = malloc(FACTORY_RESET_ENV_SIZE);
+ if (buf == NULL) {
+ printf("ERROR: malloc() failed\n");
+ return -1;
+ }
if (eeprom_read(FACTORY_RESET_I2C_EEPROM, FACTORY_RESET_ENV_OFFS,
(u8 *)buf, FACTORY_RESET_ENV_SIZE)) {
puts("\nError reading EEPROM!\n");
/*
- * (C) Copyright 2000-2002
+ * (C) Copyright 2000-2010
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
*
* (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
* MA 02111-1307 USA
*/
-/**************************************************************************
- *
+/*
* Support for persistent environment data
*
- * The "environment" is stored as a list of '\0' terminated
- * "name=value" strings. The end of the list is marked by a double
- * '\0'. New entries are always added at the end. Deleting an entry
- * shifts the remaining entries to the front. Replacing an entry is a
- * combination of deleting the old value and adding the new one.
- *
- * The environment is preceeded by a 32 bit CRC over the data part.
+ * 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.
*
- **************************************************************************
+ * 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.
*/
#include <common.h>
#include <command.h>
#include <environment.h>
-#if defined(CONFIG_CMD_EDITENV)
+#include <search.h>
+#include <errno.h>
#include <malloc.h>
-#endif
#include <watchdog.h>
#include <serial.h>
#include <linux/stddef.h>
#define XMK_STR(x) #x
#define MK_STR(x) XMK_STR(x)
-/************************************************************************
-************************************************************************/
+/*
+ * Maximum expected input data size for import command
+ */
+#define MAX_ENV_SIZE (1 << 20) /* 1 MiB */
/*
* Table with supported baudrates (defined in config_xyz.h)
#define N_BAUDRATES (sizeof(baudrate_table) / sizeof(baudrate_table[0]))
/*
- * This variable is incremented on each do_setenv (), so it can
+ * This variable is incremented on each do_env_set(), so it can
* 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
{
return env_id;
}
-/************************************************************************
- * Command interface: print one or all environment variables
- */
/*
- * state 0: finish printing this string and return (matched!)
- * state 1: no matching to be done; print everything
- * state 2: continue searching for matched name
+ * Command interface: print one or all environment variables
+ *
+ * Returns 0 in case of error, or length of printed string
*/
-static int printenv(char *name, int state)
+static int env_print(char *name)
{
- int i, j;
- char c, buf[17];
-
- i = 0;
- buf[16] = '\0';
-
- while (state && env_get_char(i) != '\0') {
- if (state == 2 && envmatch((uchar *)name, i) >= 0)
- state = 0;
-
- j = 0;
- do {
- buf[j++] = c = env_get_char(i++);
- if (j == sizeof(buf) - 1) {
- if (state <= 1)
- puts(buf);
- j = 0;
- }
- } while (c != '\0');
+ char *res = NULL;
+ size_t len;
+
+ if (name) { /* print a single name */
+ ENTRY e, *ep;
+
+ e.key = name;
+ e.data = NULL;
+ ep = hsearch (e, FIND);
+ if (ep == NULL)
+ return 0;
+ len = printf ("%s=%s\n", ep->key, ep->data);
+ return len;
+ }
- if (state <= 1) {
- if (j)
- puts(buf);
- putc('\n');
- }
+ /* print whole list */
+ len = hexport('\n', &res, 0);
- if (ctrlc())
- return -1;
+ if (len > 0) {
+ puts(res);
+ free(res);
+ return len;
}
- if (state == 0)
- i = 0;
- return i;
+ /* should never happen */
+ return 0;
}
-int do_printenv (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_env_print (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
int i;
int rcode = 0;
if (argc == 1) {
/* print all env vars */
- rcode = printenv(NULL, 1);
- if (rcode < 0)
+ rcode = env_print(NULL);
+ if (!rcode)
return 1;
printf("\nEnvironment size: %d/%ld bytes\n",
rcode, (ulong)ENV_SIZE);
/* print selected env vars */
for (i = 1; i < argc; ++i) {
- char *name = argv[i];
- if (printenv(name, 2)) {
- printf("## Error: \"%s\" not defined\n", name);
+ int rc = env_print(argv[i]);
+ if (!rc) {
+ printf("## Error: \"%s\" not defined\n", argv[i]);
++rcode;
}
}
return rcode;
}
-/************************************************************************
+/*
* Set a new environment variable,
* or replace or delete an existing one.
- *
- * This function will ONLY work with a in-RAM copy of the environment
*/
-int _do_setenv (int flag, int argc, char * const argv[])
+int _do_env_set (int flag, int argc, char * const argv[])
{
- int i, len, oldval;
+ bd_t *bd = gd->bd;
+ int i, len;
int console = -1;
- uchar *env, *nxt = NULL;
- char *name;
- bd_t *bd = gd->bd;
-
- uchar *env_data = env_get_addr(0);
-
- if (!env_data) /* need copy in RAM */
- return 1;
+ char *name, *value, *s;
+ ENTRY e, *ep;
name = argv[1];
/*
* search if variable with this name already exists
*/
- oldval = -1;
- for (env=env_data; *env; env=nxt+1) {
- for (nxt=env; *nxt; ++nxt)
- ;
- if ((oldval = envmatch((uchar *)name, env-env_data)) >= 0)
- break;
- }
+ e.key = name;
+ e.data = NULL;
+ ep = hsearch (e, FIND);
/* Check for console redirection */
if (strcmp(name,"stdin") == 0) {
}
/*
- * Delete any existing definition
+ * Some variables like "ethaddr" and "serial#" can be set only
+ * once and cannot be deleted; also, "ver" is readonly.
*/
- if (oldval >= 0) {
+ if (ep) { /* variable exists */
#ifndef CONFIG_ENV_OVERWRITE
-
- /*
- * Ethernet Address and serial# can be set only once,
- * ver is readonly.
- */
- if (
- (strcmp (name, "serial#") == 0) ||
+ if ((strcmp (name, "serial#") == 0) ||
((strcmp (name, "ethaddr") == 0)
#if defined(CONFIG_OVERWRITE_ETHADDR_ONCE) && defined(CONFIG_ETHADDR)
- && (strcmp ((char *)env_get_addr(oldval),MK_STR(CONFIG_ETHADDR)) != 0)
+ && (strcmp (ep->data,MK_STR(CONFIG_ETHADDR)) != 0)
#endif /* CONFIG_OVERWRITE_ETHADDR_ONCE && CONFIG_ETHADDR */
) ) {
printf ("Can't overwrite \"%s\"\n", name);
return 1;
}
#endif
-
/*
* Switch to new baudrate if new baudrate is supported
*/
- if (strcmp(argv[1],"baudrate") == 0) {
+ if (strcmp(name,"baudrate") == 0) {
int baudrate = simple_strtoul(argv[2], NULL, 10);
int i;
for (i=0; i<N_BAUDRATES; ++i) {
break;
}
}
-
- if (*++nxt == '\0') {
- if (env > env_data) {
- env--;
- } else {
- *env = '\0';
- }
- } else {
- for (;;) {
- *env = *nxt++;
- if ((*env == '\0') && (*nxt == '\0'))
- break;
- ++env;
- }
- }
- *++env = '\0';
}
/* Delete only ? */
if ((argc < 3) || argv[2] == NULL) {
- env_crc_update ();
- return 0;
+ int rc = hdelete(name);
+ return !rc;
}
/*
- * Append new definition at the end
+ * Insert / replace new value
*/
- for (env=env_data; *env || *(env+1); ++env)
- ;
- if (env > env_data)
- ++env;
- /*
- * Overflow when:
- * "name" + "=" + "val" +"\0\0" > ENV_SIZE - (env-env_data)
- */
- len = strlen(name) + 2;
- /* add '=' for first arg, ' ' for all others */
- for (i=2; i<argc; ++i) {
+ for (i=2,len=0; i<argc; ++i) {
len += strlen(argv[i]) + 1;
}
- if (len > (&env_data[ENV_SIZE]-env)) {
- printf ("## Error: environment overflow, \"%s\" deleted\n", name);
+ if ((value = malloc(len)) == NULL) {
+ printf("## Can't malloc %d bytes\n", len);
return 1;
}
- while ((*env = *name++) != '\0')
- env++;
- for (i=2; i<argc; ++i) {
- char *val = argv[i];
+ for (i=2,s=value; i<argc; ++i) {
+ char *v = argv[i];
- *env = (i==2) ? '=' : ' ';
- while ((*++env = *val++) != '\0')
+ while ((*s++ = *v++) != '\0')
;
+ *(s-1) = ' ';
+ }
+ if (s != value)
+ *--s = '\0';
+
+ e.key = name;
+ e.data = value;
+ ep = hsearch(e, ENTER);
+ free(value);
+ if (!ep) {
+ printf("## Error inserting \"%s\" variable, errno=%d\n",
+ name, errno);
+ return 1;
}
-
- /* end is marked with double '\0' */
- *++env = '\0';
-
- /* Update CRC */
- env_crc_update ();
/*
* Some variables should be updated when the corresponding
- * entry in the enviornment is changed
+ * entry in the environment is changed
*/
- if (strcmp(argv[1],"ethaddr") == 0)
- return 0;
-
- if (strcmp(argv[1],"ipaddr") == 0) {
+ if (strcmp(name,"ipaddr") == 0) {
char *s = argv[2]; /* always use only one arg */
char *e;
unsigned long addr;
}
bd->bi_ip_addr = htonl(addr);
return 0;
- }
- if (strcmp(argv[1],"loadaddr") == 0) {
+ } else if (strcmp(argv[1],"loadaddr") == 0) {
load_addr = simple_strtoul(argv[2], NULL, 16);
return 0;
}
#if defined(CONFIG_CMD_NET)
- if (strcmp(argv[1],"bootfile") == 0) {
+ else if (strcmp(argv[1],"bootfile") == 0) {
copy_filename (BootFile, argv[2], sizeof(BootFile));
return 0;
}
{
char * const argv[4] = { "setenv", varname, varvalue, NULL };
if ((varvalue == NULL) || (varvalue[0] == '\0'))
- return _do_setenv (0, 2, argv);
+ return _do_env_set(0, 2, argv);
else
- return _do_setenv (0, 3, argv);
+ return _do_env_set(0, 3, argv);
}
-int do_setenv (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_env_set (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
if (argc < 2)
return cmd_usage(cmdtp);
- return _do_setenv (flag, argc, argv);
+ return _do_env_set(flag, argc, argv);
}
-/************************************************************************
+/*
* Prompt for environment variable
*/
-
#if defined(CONFIG_CMD_ASKENV)
-int do_askenv ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_env_ask ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
extern char console_buffer[CONFIG_SYS_CBSIZE];
char message[CONFIG_SYS_CBSIZE];
int size = CONFIG_SYS_CBSIZE - 1;
- int len;
+ int i, len, pos;
char *local_args[4];
local_args[0] = argv[0];
local_args[2] = NULL;
local_args[3] = NULL;
- if (argc < 2)
- return cmd_usage(cmdtp);
-
/* Check the syntax */
switch (argc) {
case 1:
return cmd_usage(cmdtp);
- case 2: /* askenv envname */
- sprintf (message, "Please enter '%s':", argv[1]);
+ case 2: /* env_ask envname */
+ sprintf(message, "Please enter '%s':", argv[1]);
break;
- case 3: /* askenv envname size */
- sprintf (message, "Please enter '%s':", argv[1]);
- size = simple_strtoul (argv[2], NULL, 10);
+ case 3: /* env_ask envname size */
+ sprintf(message, "Please enter '%s':", argv[1]);
+ size = simple_strtoul(argv[2], NULL, 10);
break;
- default: /* askenv envname message1 ... messagen size */
- {
- int i;
- int pos = 0;
-
- for (i = 2; i < argc - 1; i++) {
+ default: /* env_ask envname message1 ... messagen size */
+ for (i=2,pos=0; i < argc - 1; i++) {
if (pos) {
message[pos++] = ' ';
}
- strcpy (message+pos, argv[i]);
+ strcpy(message+pos, argv[i]);
pos += strlen(argv[i]);
}
message[pos] = '\0';
- size = simple_strtoul (argv[argc - 1], NULL, 10);
- }
+ size = simple_strtoul(argv[argc - 1], NULL, 10);
break;
}
return 1;
/* prompt for input */
- len = readline (message);
+ len = readline(message);
if (size < len)
console_buffer[size] = '\0';
}
/* Continue calling setenv code */
- return _do_setenv (flag, len, local_args);
+ return _do_env_set(flag, len, local_args);
}
#endif
-/************************************************************************
+/*
* Interactively edit an environment variable
*/
#if defined(CONFIG_CMD_EDITENV)
-int do_editenv(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_env_edit(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
char buffer[CONFIG_SYS_CBSIZE];
char *init_val;
}
#endif /* CONFIG_CMD_EDITENV */
-/************************************************************************
+/*
* Look up variable from environment,
* return address of storage for that variable,
* or NULL if not found
*/
-
char *getenv (char *name)
{
- if (gd->flags & GD_FLG_RELOC) { /* full C runtime after reloc */
- int i, nxt;
+ if (gd->flags & GD_FLG_ENV_READY) { /* after import into hashtable */
+ ENTRY e, *ep;
WATCHDOG_RESET();
- for (i=0; env_get_char(i) != '\0'; i=nxt+1) {
- int val;
-
- for (nxt=i; env_get_char(nxt) != '\0'; ++nxt) {
- if (nxt >= CONFIG_ENV_SIZE) {
- return (NULL);
- }
- }
- if ((val=envmatch((uchar *)name, i)) < 0)
- continue;
- return ((char *)env_get_addr(val));
- }
+ e.key = name;
+ e.data = NULL;
+ ep = hsearch (e, FIND);
- return (NULL);
+ return (ep ? ep->data : NULL);
}
- /* restricted C runtime before reloc */
+ /* restricted capabilities before import */
+
+ if (getenv_f(name, (char *)(gd->env_buf), sizeof(gd->env_buf)) > 0)
+ return (char *)(gd->env_buf);
- return ((getenv_f(name,gd->env_buf,sizeof(gd->env_buf)) > 0) ?
- gd->env_buf : NULL);
+ return NULL;
}
-int getenv_f(char *name, char *buf, unsigned len)
+/*
+ * Look up variable from environment for restricted C runtime env.
+ */
+int getenv_f (char *name, char *buf, unsigned len)
{
int i, nxt;
#if defined(CONFIG_CMD_SAVEENV) && !defined(CONFIG_ENV_IS_NOWHERE)
-int do_saveenv (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+int do_env_save (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
{
extern char * env_name_spec;
}
U_BOOT_CMD(
- saveenv, 1, 0, do_saveenv,
+ saveenv, 1, 0, do_env_save,
"save environment variables to persistent storage",
""
);
#endif
-/************************************************************************
+/*
* Match a name / name=value pair
*
* s1 is either a simple 'name', or a 'name=value' pair.
return(-1);
}
+static int do_env_default(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+{
+ if ((argc != 2) || (strcmp(argv[1], "-f") != 0)) {
+ cmd_usage(cmdtp);
+ return 1;
+ }
+ set_default_env("## Resetting to default environment\n");
+ return 0;
+}
+
+static int do_env_delete(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+{
+ printf("Not implemented yet\n");
+ return 0;
+}
+
+/*
+ * env export [-t | -b | -c] addr [size]
+ * -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
+ * addr: memory address where environment gets stored
+ * size: size of output buffer
+ *
+ * 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}
+ */
+static int do_env_export(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+{
+ char buf[32];
+ char *addr, *cmd, *res;
+ size_t size;
+ ssize_t len;
+ env_t *envp;
+ char sep = '\n';
+ 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;
+ case 't': /* text format */
+ if (fmt++)
+ goto sep_err;
+ sep = '\n';
+ break;
+ default:
+ cmd_usage(cmdtp);
+ return 1;
+ }
+ }
+ }
+
+ if (argc < 1) {
+ cmd_usage(cmdtp);
+ return 1;
+ }
-/**************************************************/
+ addr = (char *)simple_strtoul(argv[0], NULL, 16);
+
+ if (argc == 2) {
+ size = simple_strtoul(argv[1], NULL, 16);
+ memset(addr, '\0', size);
+ } else {
+ size = 0;
+ }
+
+ if (sep) { /* export as text file */
+ len = hexport(sep, &addr, size);
+ if (len < 0) {
+ error("Cannot export environment: errno = %d\n",
+ errno);
+ return 1;
+ }
+ sprintf(buf, "%zX", len);
+ setenv("filesize", buf);
+
+ return 0;
+ }
+
+ envp = (env_t *)addr;
+
+ if (chk) /* export as checksum protected block */
+ res = (char *)envp->data;
+ else /* export as raw binary data */
+ res = addr;
+
+ len = hexport('\0', &res, ENV_SIZE);
+ if (len < 0) {
+ error("Cannot export environment: errno = %d\n",
+ errno);
+ return 1;
+ }
+
+ if (chk) {
+ envp->crc = crc32(0, envp->data, ENV_SIZE);
+#ifdef CONFIG_ENV_ADDR_REDUND
+ envp->flags = ACTIVE_FLAG;
+#endif
+ }
+ sprintf(buf, "%zX", len + offsetof(env_t,data));
+ setenv("filesize", buf);
+
+ return 0;
+
+sep_err:
+ printf("## %s: only one of \"-b\", \"-c\" or \"-t\" allowed\n",
+ cmd);
+ return 1;
+}
+
+/*
+ * env import [-d] [-t | -b | -c] addr [size]
+ * -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
+ * -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
+ */
+static int do_env_import(cmd_tbl_t * cmdtp, int flag, int argc, char * const argv[])
+{
+ char *cmd, *addr;
+ char sep = '\n';
+ int chk = 0;
+ int fmt = 0;
+ int del = 0;
+ 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 = '\n';
+ break;
+ case 'd':
+ del = 1;
+ break;
+ default:
+ cmd_usage(cmdtp);
+ return 1;
+ }
+ }
+ }
+
+ if (argc < 1) {
+ cmd_usage(cmdtp);
+ return 1;
+ }
+
+ if (!fmt)
+ printf("## Warning: defaulting to text format\n");
+
+ addr = (char *)simple_strtoul(argv[0], NULL, 16);
+
+ if (argc == 2) {
+ size = simple_strtoul(argv[1], NULL, 16);
+ } else {
+ char *s = addr;
+
+ 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\n", MAX_ENV_SIZE);
+ }
+ ++size;
+ printf("## Info: input data size = %zd = 0x%zX\n", size, size);
+ }
+
+ if (chk) {
+ uint32_t crc;
+ env_t *ep = (env_t *)addr;
+
+ size -= offsetof(env_t, data);
+ memcpy(&crc, &ep->crc, sizeof(crc));
+
+ if (crc32(0, ep->data, size) != crc) {
+ puts("## Error: bad CRC, import failed\n");
+ return 1;
+ }
+ addr = (char *)ep->data;
+ }
+
+ if (himport(addr, size, sep, del ? 0 : H_NOCLEAR) == 0) {
+ error("Environment import failed: errno = %d\n", errno);
+ return 1;
+ }
+ gd->flags |= GD_FLG_ENV_READY;
+
+ return 0;
+
+sep_err:
+ printf("## %s: only one of \"-b\", \"-c\" or \"-t\" allowed\n",
+ cmd);
+ return 1;
+}
+
+#if defined(CONFIG_CMD_RUN)
+extern int do_run (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
+#endif
+
+/*
+ * 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, "", ""),
+ U_BOOT_CMD_MKENT(delete, 2, 0, do_env_delete, "", ""),
+#if defined(CONFIG_CMD_EDITENV)
+ U_BOOT_CMD_MKENT(edit, 2, 0, do_env_edit, "", ""),
+#endif
+ U_BOOT_CMD_MKENT(export, 4, 0, do_env_export, "", ""),
+ U_BOOT_CMD_MKENT(import, 5, 0, do_env_import, "", ""),
+ 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, "", ""),
+};
+
+static int do_env (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
+{
+ cmd_tbl_t *cp;
+
+ /* 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);
+
+ cmd_usage(cmdtp);
+ return 1;
+}
+
+U_BOOT_CMD(
+ env, CONFIG_SYS_MAXARGS, 1, do_env,
+ "environment handling commands",
+#if defined(CONFIG_CMD_ASKENV)
+ "ask name [message] [size] - ask for environment variable\nenv "
+#endif
+ "default -f - reset default environment\n"
+#if defined(CONFIG_CMD_EDITENV)
+ "env edit name - edit environment variable\n"
+#endif
+ "env export [-t | -b | -c] addr [size] - export environmnt\n"
+ "env import [-d] [-t | -b | -c] addr [size] - import environmnt\n"
+ "env print [name ...] - print environment\n"
+#if defined(CONFIG_CMD_RUN)
+ "env run var [...] - run commands in an environment variable\n"
+#endif
+ "env save - save environment\n"
+ "env set [-f] name [arg ...]\n"
+);
+
+/*
+ * Old command line interface, kept for compatibility
+ */
#if defined(CONFIG_CMD_EDITENV)
U_BOOT_CMD(
- editenv, 2, 0, do_editenv,
+ editenv, 2, 0, do_env_edit,
"edit environment variable",
"name\n"
" - edit environment variable 'name'"
#endif
U_BOOT_CMD(
- printenv, CONFIG_SYS_MAXARGS, 1, do_printenv,
+ printenv, CONFIG_SYS_MAXARGS, 1, do_env_print,
"print environment variables",
"\n - print values of all environment variables\n"
"printenv name ...\n"
);
U_BOOT_CMD(
- setenv, CONFIG_SYS_MAXARGS, 0, do_setenv,
+ setenv, CONFIG_SYS_MAXARGS, 0, do_env_set,
"set environment variables",
"name value ...\n"
" - set environment variable 'name' to 'value ...'\n"
#if defined(CONFIG_CMD_ASKENV)
U_BOOT_CMD(
- askenv, CONFIG_SYS_MAXARGS, 1, do_askenv,
+ askenv, CONFIG_SYS_MAXARGS, 1, do_env_ask,
"get environment variables from stdin",
"name [message] [size]\n"
" - get environment variable 'name' from stdin (max 'size' chars)\n"
#endif
#if defined(CONFIG_CMD_RUN)
-int do_run (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[]);
U_BOOT_CMD(
run, CONFIG_SYS_MAXARGS, 1, do_run,
"run commands in an environment variable",
int var_complete(int argc, char * const argv[], char last_char, int maxv, char *cmdv[])
{
+#if 0 /* need to reimplement */
static char tmp_buf[512];
int space;
if (!space && argc == 2)
return env_complete(argv[1], maxv, cmdv, sizeof(tmp_buf), tmp_buf);
-
+#endif
return 0;
}
\f
-
/* Preliminaries */
#ifndef __STD_C
#endif
/* ---------- To make a malloc.h, end cutting here ------------ */
-#else /* Moved to malloc.h */
+#endif /* 0 */ /* Moved to malloc.h */
#include <malloc.h>
-#if 0
+#ifdef DEBUG
#if __STD_C
static void malloc_update_mallinfo (void);
void malloc_stats (void);
static void malloc_update_mallinfo ();
void malloc_stats();
#endif
-#endif /* 0 */
-
-#endif /* 0 */ /* Moved to malloc.h */
+#endif /* DEBUG */
DECLARE_GLOBAL_DATA_PTR;
/* Tracking mmaps */
-#if 0
+#ifdef DEBUG
static unsigned int n_mmaps = 0;
-#endif /* 0 */
+#endif /* DEBUG */
static unsigned long mmapped_mem = 0;
#if HAVE_MMAP
static unsigned int max_n_mmaps = 0;
/* Utility to update current_mallinfo for malloc_stats and mallinfo() */
-#if 0
+#ifdef DEBUG
static void malloc_update_mallinfo()
{
int i;
current_mallinfo.keepcost = chunksize(top);
}
-#endif /* 0 */
+#endif /* DEBUG */
\f
*/
-#if 0
+#ifdef DEBUG
void malloc_stats()
{
malloc_update_mallinfo();
(unsigned int)max_n_mmaps);
#endif
}
-#endif /* 0 */
+#endif /* DEBUG */
/*
mallinfo returns a copy of updated current mallinfo.
*/
-#if 0
+#ifdef DEBUG
struct mallinfo mALLINFo()
{
malloc_update_mallinfo();
return current_mallinfo;
}
-#endif /* 0 */
+#endif /* DEBUG */
\f
/*
- * (C) Copyright 2000-2002
+ * (C) Copyright 2000-2010
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
*
* (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
* Andreas Heppel <aheppel@sysgo.de>
-
+ *
* See file CREDITS for list of people who contributed to this
* project.
*
#include <command.h>
#include <environment.h>
#include <linux/stddef.h>
+#include <search.h>
+#include <errno.h>
#include <malloc.h>
DECLARE_GLOBAL_DATA_PTR;
-#undef DEBUG_ENV
-#ifdef DEBUG_ENV
-#define DEBUGF(fmt,args...) printf(fmt ,##args)
-#else
-#define DEBUGF(fmt,args...)
-#endif
-
extern env_t *env_ptr;
extern void env_relocate_spec (void);
"\0"
};
-void env_crc_update (void)
-{
- env_ptr->crc = crc32(0, env_ptr->data, ENV_SIZE);
-}
-
static uchar env_get_char_init (int index)
{
uchar c;
/* if crc was bad, use the default environment */
if (gd->env_valid)
- {
c = env_get_char_spec(index);
- } else {
+ else
c = default_environment[index];
- }
return (c);
}
uchar env_get_char_memory (int index)
{
- if (gd->env_valid) {
- return ( *((uchar *)(gd->env_addr + index)) );
- } else {
- return ( default_environment[index] );
- }
+ return *env_get_addr(index);
}
uchar env_get_char (int index)
uchar *env_get_addr (int index)
{
- if (gd->env_valid) {
- return ( ((uchar *)(gd->env_addr + index)) );
- } else {
- return (&default_environment[index]);
- }
+ if (gd->env_valid)
+ return (uchar *)(gd->env_addr + index);
+ else
+ return &default_environment[index];
}
-void set_default_env(void)
+void set_default_env(const char *s)
{
if (sizeof(default_environment) > ENV_SIZE) {
- puts ("*** Error - default environment is too large\n\n");
+ puts("*** Error - default environment is too large\n\n");
return;
}
- memset(env_ptr, 0, sizeof(env_t));
- memcpy(env_ptr->data, default_environment,
- sizeof(default_environment));
-#ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
- env_ptr->flags = 0xFF;
-#endif
- env_crc_update ();
- gd->env_valid = 1;
+ if (s) {
+ if (*s == '!') {
+ printf("*** Warning - %s, "
+ "using default environment\n\n",
+ s+1);
+ } else {
+ puts(s);
+ }
+ } else {
+ puts("Using default environment\n\n");
+ }
+
+ if (himport((char *)default_environment,
+ sizeof(default_environment), '\0', 0) == 0) {
+ error("Environment import failed: errno = %d\n", errno);
+ }
+ gd->flags |= GD_FLG_ENV_READY;
}
-void env_relocate (void)
+/*
+ * Check if CRC is valid and (if yes) import the environment.
+ * Note that "buf" may or may not be aligned.
+ */
+int env_import(const char *buf, int check)
{
-#ifndef CONFIG_RELOC_FIXUP_WORKS
- DEBUGF ("%s[%d] offset = 0x%lx\n", __FUNCTION__,__LINE__,
- gd->reloc_off);
-#endif
+ env_t *ep = (env_t *)buf;
-#ifdef ENV_IS_EMBEDDED
- /*
- * The environment buffer is embedded with the text segment,
- * just relocate the environment pointer
- */
-#ifndef CONFIG_RELOC_FIXUP_WORKS
- env_ptr = (env_t *)((ulong)env_ptr + gd->reloc_off);
-#endif
- DEBUGF ("%s[%d] embedded ENV at %p\n", __FUNCTION__,__LINE__,env_ptr);
-#else
- /*
- * We must allocate a buffer for the environment
- */
- env_ptr = (env_t *)malloc (CONFIG_ENV_SIZE);
- DEBUGF ("%s[%d] malloced ENV at %p\n", __FUNCTION__,__LINE__,env_ptr);
-#endif
+ if (check) {
+ uint32_t crc;
+
+ memcpy(&crc, &ep->crc, sizeof(crc));
+
+ if (crc32(0, ep->data, ENV_SIZE) != crc) {
+ set_default_env("!bad CRC");
+ return 0;
+ }
+ }
+
+ if (himport((char *)ep->data, ENV_SIZE, '\0', 0)) {
+ gd->flags |= GD_FLG_ENV_READY;
+ return 1;
+ }
+ error("Cannot import environment: errno = %d\n", errno);
+
+ set_default_env("!import failed");
+
+ return 0;
+}
+
+void env_relocate (void)
+{
if (gd->env_valid == 0) {
#if defined(CONFIG_ENV_IS_NOWHERE) /* Environment not changable */
- puts ("Using default environment\n\n");
+ set_default_env(NULL);
#else
- puts ("*** Warning - bad CRC, using default environment\n\n");
show_boot_progress (-60);
#endif
- set_default_env();
- }
- else {
+ set_default_env("!bad CRC");
+ } else {
env_relocate_spec ();
}
- gd->env_addr = (ulong)&(env_ptr->data);
}
-#ifdef CONFIG_AUTO_COMPLETE
+#if 0 /* need to reimplement - def CONFIG_AUTO_COMPLETE */
int env_complete(char *var, int maxv, char *cmdv[], int bufsz, char *buf)
{
int i, nxt, len, vallen, found;
-/* LowLevel function for DataFlash environment support
+/*
+ * LowLevel function for DataFlash environment support
* Author : Gilles Gastaldi (Atmel)
*
* This program is free software; you can redistribute it and/or
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
* MA 02111-1307 USA
- *
*/
#include <common.h>
#include <command.h>
#include <environment.h>
#include <linux/stddef.h>
#include <dataflash.h>
+#include <search.h>
+#include <errno.h>
DECLARE_GLOBAL_DATA_PTR;
char * env_name_spec = "dataflash";
-extern int read_dataflash (unsigned long addr, unsigned long size, char
-*result);
-extern int write_dataflash (unsigned long addr_dest, unsigned long addr_src,
- unsigned long size);
-extern int AT91F_DataflashInit (void);
-extern uchar default_environment[];
+extern int read_dataflash(unsigned long addr, unsigned long size,
+ char *result);
+extern int write_dataflash(unsigned long addr_dest,
+ unsigned long addr_src, unsigned long size);
+extern int AT91F_DataflashInit(void);
+extern uchar default_environment[];
-uchar env_get_char_spec (int index)
+uchar env_get_char_spec(int index)
{
uchar c;
+
read_dataflash(CONFIG_ENV_ADDR + index + offsetof(env_t,data),
- 1, (char *)&c);
+ 1, (char *)&c);
return (c);
}
-void env_relocate_spec (void)
+void env_relocate_spec(void)
{
- read_dataflash(CONFIG_ENV_ADDR, CONFIG_ENV_SIZE, (char *)env_ptr);
+ char buf[CONFIG_ENV_SIZE];
+
+ read_dataflash(CONFIG_ENV_ADDR, CONFIG_ENV_SIZE, buf);
+
+ env_import(buf, 1);
}
+#ifdef CONFIG_ENV_OFFSET_REDUND
+#error No support for redundant environment on dataflash yet!
+#endif
+
int saveenv(void)
{
- /* env must be copied to do not alter env structure in memory*/
- unsigned char temp[CONFIG_ENV_SIZE];
- memcpy(temp, env_ptr, CONFIG_ENV_SIZE);
- return write_dataflash(CONFIG_ENV_ADDR, (unsigned long)temp, CONFIG_ENV_SIZE);
+ env_t env_new;
+ ssize_t len;
+ char *res;
+
+ res = (char *)&env_new.data;
+ len = hexport('\0', &res, ENV_SIZE);
+ if (len < 0) {
+ error("Cannot export environment: errno = %d\n", errno);
+ return 1;
+ }
+ env_new.crc = crc32(0, env_new.data, ENV_SIZE);
+
+ return write_dataflash(CONFIG_ENV_ADDR,
+ (unsigned long)&env_new,
+ CONFIG_ENV_SIZE);
}
-/************************************************************************
- * Initialize Environment use
+/*
+ * Initialize environment use
*
- * We are still running from ROM, so data use is limited
+ * We are still running from ROM, so data use is limited.
* Use a (moderately small) buffer on the stack
*/
int env_init(void)
ulong crc, len, new;
unsigned off;
uchar buf[64];
- if (gd->env_valid == 0){
- AT91F_DataflashInit(); /* prepare for DATAFLASH read/write */
-
- /* read old CRC */
- read_dataflash(CONFIG_ENV_ADDR + offsetof(env_t, crc),
- sizeof(ulong), (char *)&crc);
- new = 0;
- len = ENV_SIZE;
- off = offsetof(env_t,data);
- while (len > 0) {
- int n = (len > sizeof(buf)) ? sizeof(buf) : len;
- read_dataflash(CONFIG_ENV_ADDR + off, n, (char *)buf);
- new = crc32 (new, buf, n);
- len -= n;
- off += n;
- }
- if (crc == new) {
- gd->env_addr = offsetof(env_t,data);
- gd->env_valid = 1;
- } else {
- gd->env_addr = (ulong)&default_environment[0];
- gd->env_valid = 0;
- }
+
+ if (gd->env_valid)
+ return 0;
+
+ AT91F_DataflashInit(); /* prepare for DATAFLASH read/write */
+
+ /* read old CRC */
+ read_dataflash(CONFIG_ENV_ADDR + offsetof(env_t, crc),
+ sizeof(ulong), (char *)&crc);
+
+ new = 0;
+ len = ENV_SIZE;
+ off = offsetof(env_t,data);
+ while (len > 0) {
+ int n = (len > sizeof(buf)) ? sizeof(buf) : len;
+
+ read_dataflash(CONFIG_ENV_ADDR + off, n, (char *)buf);
+
+ new = crc32 (new, buf, n);
+ len -= n;
+ off += n;
+ }
+
+ if (crc == new) {
+ gd->env_addr = offsetof(env_t,data);
+ gd->env_valid = 1;
+ } else {
+ gd->env_addr = (ulong)&default_environment[0];
+ gd->env_valid = 0;
}
- return (0);
+ return 0;
}
/*
- * (C) Copyright 2000-2002
+ * (C) Copyright 2000-2010
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
*
* (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
* Andreas Heppel <aheppel@sysgo.de>
-
+ *
* See file CREDITS for list of people who contributed to this
* project.
*
#if defined(CONFIG_I2C_ENV_EEPROM_BUS)
#include <i2c.h>
#endif
+#include <search.h>
+#include <errno.h>
+#include <linux/compiler.h> /* for BUG_ON */
DECLARE_GLOBAL_DATA_PTR;
env_t *env_ptr = NULL;
-char * env_name_spec = "EEPROM";
+char *env_name_spec = "EEPROM";
int env_eeprom_bus = -1;
-static int eeprom_bus_read (unsigned dev_addr, unsigned offset, uchar *buffer,
- unsigned cnt)
+static int eeprom_bus_read(unsigned dev_addr, unsigned offset,
+ uchar *buffer, unsigned cnt)
{
int rcode;
#if defined(CONFIG_I2C_ENV_EEPROM_BUS)
I2C_MUX_DEVICE *dev = NULL;
dev = i2c_mux_ident_muxstring(
(uchar *)CONFIG_I2C_ENV_EEPROM_BUS);
- if (dev != NULL) {
+ if (dev != NULL)
env_eeprom_bus = dev->busid;
- } else
+ else
printf ("error adding env eeprom bus.\n");
}
if (old_bus != env_eeprom_bus) {
#endif
rcode = eeprom_read (dev_addr, offset, buffer, cnt);
+
#if defined(CONFIG_I2C_ENV_EEPROM_BUS)
if (old_bus != env_eeprom_bus)
i2c_set_bus_num(old_bus);
return rcode;
}
-static int eeprom_bus_write (unsigned dev_addr, unsigned offset, uchar *buffer,
- unsigned cnt)
+static int eeprom_bus_write(unsigned dev_addr, unsigned offset,
+ uchar *buffer, unsigned cnt)
{
int rcode;
#if defined(CONFIG_I2C_ENV_EEPROM_BUS)
rcode = i2c_mux_ident_muxstring_f((uchar *)CONFIG_I2C_ENV_EEPROM_BUS);
#endif
- rcode = eeprom_write (dev_addr, offset, buffer, cnt);
+ rcode = eeprom_write(dev_addr, offset, buffer, cnt);
#if defined(CONFIG_I2C_ENV_EEPROM_BUS)
i2c_set_bus_num(old_bus);
#endif
uchar c;
unsigned int off;
off = CONFIG_ENV_OFFSET;
+
#ifdef CONFIG_ENV_OFFSET_REDUND
if (gd->env_valid == 2)
off = CONFIG_ENV_OFFSET_REDUND;
#endif
-
- eeprom_bus_read (CONFIG_SYS_DEF_EEPROM_ADDR,
+ eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
off + index + offsetof(env_t,data),
&c, 1);
void env_relocate_spec (void)
{
+ char buf[CONFIG_ENV_SIZE];
unsigned int off = CONFIG_ENV_OFFSET;
+
#ifdef CONFIG_ENV_OFFSET_REDUND
if (gd->env_valid == 2)
off = CONFIG_ENV_OFFSET_REDUND;
#endif
- eeprom_bus_read (CONFIG_SYS_DEF_EEPROM_ADDR,
+ eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
off,
- (uchar*)env_ptr,
+ (uchar *)buf,
CONFIG_ENV_SIZE);
+
+ env_import(buf, 1);
}
int saveenv(void)
{
+ env_t env_new;
+ ssize_t len;
+ char *res;
int rc;
unsigned int off = CONFIG_ENV_OFFSET;
#ifdef CONFIG_ENV_OFFSET_REDUND
unsigned int off_red = CONFIG_ENV_OFFSET_REDUND;
char flag_obsolete = OBSOLETE_FLAG;
+#endif
+
+ BUG_ON(env_ptr != NULL);
+
+ res = (char *)&env_new.data;
+ len = hexport('\0', &res, ENV_SIZE);
+ if (len < 0) {
+ error("Cannot export environment: errno = %d\n", errno);
+ return 1;
+ }
+ env_new.crc = crc32(0, env_new.data, ENV_SIZE);
+
+#ifdef CONFIG_ENV_OFFSET_REDUND
if (gd->env_valid == 1) {
off = CONFIG_ENV_OFFSET_REDUND;
off_red = CONFIG_ENV_OFFSET;
}
- env_ptr->flags = ACTIVE_FLAG;
+ env_new.flags = ACTIVE_FLAG;
#endif
- rc = eeprom_bus_write (CONFIG_SYS_DEF_EEPROM_ADDR,
+ rc = eeprom_bus_write(CONFIG_SYS_DEF_EEPROM_ADDR,
off,
- (uchar *)env_ptr,
+ (uchar *)&env_new,
CONFIG_ENV_SIZE);
#ifdef CONFIG_ENV_OFFSET_REDUND
if (rc == 0) {
- eeprom_bus_write (CONFIG_SYS_DEF_EEPROM_ADDR,
+ eeprom_bus_write(CONFIG_SYS_DEF_EEPROM_ADDR,
off_red + offsetof(env_t,flags),
(uchar *)&flag_obsolete,
1);
return rc;
}
-/************************************************************************
+/*
* Initialize Environment use
*
- * We are still running from ROM, so data use is limited
+ * We are still running from ROM, so data use is limited.
* Use a (moderately small) buffer on the stack
*/
unsigned char flags[2];
int i;
- eeprom_init (); /* prepare for EEPROM read/write */
+ eeprom_init(); /* prepare for EEPROM read/write */
off_env[0] = CONFIG_ENV_OFFSET;
off_env[1] = CONFIG_ENV_OFFSET_REDUND;
for (i = 0; i < 2; i++) {
/* read CRC */
- eeprom_bus_read (CONFIG_SYS_DEF_EEPROM_ADDR,
+ eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
off_env[i] + offsetof(env_t,crc),
(uchar *)&crc[i], sizeof(ulong));
/* read FLAGS */
- eeprom_bus_read (CONFIG_SYS_DEF_EEPROM_ADDR,
+ eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
off_env[i] + offsetof(env_t,flags),
(uchar *)&flags[i], sizeof(uchar));
- crc_tmp= 0;
+ crc_tmp = 0;
len = ENV_SIZE;
off = off_env[i] + offsetof(env_t,data);
while (len > 0) {
int n = (len > sizeof(buf)) ? sizeof(buf) : len;
- eeprom_bus_read (CONFIG_SYS_DEF_EEPROM_ADDR, off,
+ eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR, off,
buf, n);
- crc_tmp = crc32 (crc_tmp, buf, n);
+ crc_tmp = crc32(crc_tmp, buf, n);
len -= n;
off += n;
}
unsigned off;
uchar buf[64];
- eeprom_init (); /* prepare for EEPROM read/write */
+ eeprom_init(); /* prepare for EEPROM read/write */
/* read old CRC */
- eeprom_bus_read (CONFIG_SYS_DEF_EEPROM_ADDR,
+ eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
CONFIG_ENV_OFFSET+offsetof(env_t,crc),
(uchar *)&crc, sizeof(ulong));
new = 0;
len = ENV_SIZE;
off = offsetof(env_t,data);
+
while (len > 0) {
int n = (len > sizeof(buf)) ? sizeof(buf) : len;
- eeprom_bus_read (CONFIG_SYS_DEF_EEPROM_ADDR,
+ eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
CONFIG_ENV_OFFSET + off, buf, n);
- new = crc32 (new, buf, n);
+ new = crc32(new, buf, n);
len -= n;
off += n;
}
/*
- * (C) Copyright 2000-2002
+ * (C) Copyright 2000-2010
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
*
* (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
#include <environment.h>
#include <linux/stddef.h>
#include <malloc.h>
+#include <search.h>
+#include <errno.h>
DECLARE_GLOBAL_DATA_PTR;
extern uchar environment[];
env_t *env_ptr = (env_t *)(&environment[0]);
-#ifdef CMD_SAVEENV
-/* static env_t *flash_addr = (env_t *)(&environment[0]);-broken on ARM-wd-*/
static env_t *flash_addr = (env_t *)CONFIG_ENV_ADDR;
-#endif
#else /* ! ENV_IS_EMBEDDED */
env_t *env_ptr = (env_t *)CONFIG_ENV_ADDR;
-#ifdef CMD_SAVEENV
static env_t *flash_addr = (env_t *)CONFIG_ENV_ADDR;
-#endif
#endif /* ENV_IS_EMBEDDED */
+#if defined(CMD_SAVEENV) || defined(CONFIG_ENV_ADDR_REDUND)
+/* CONFIG_ENV_ADDR is supposed to be on sector boundary */
+static ulong end_addr = CONFIG_ENV_ADDR + CONFIG_ENV_SECT_SIZE - 1;
+#endif
+
#ifdef CONFIG_ENV_ADDR_REDUND
static env_t *flash_addr_new = (env_t *)CONFIG_ENV_ADDR_REDUND;
-/* CONFIG_ENV_ADDR is supposed to be on sector boundary */
-static ulong end_addr = CONFIG_ENV_ADDR + CONFIG_ENV_SECT_SIZE - 1;
+/* CONFIG_ENV_ADDR_REDUND is supposed to be on sector boundary */
static ulong end_addr_new = CONFIG_ENV_ADDR_REDUND + CONFIG_ENV_SECT_SIZE - 1;
#endif /* CONFIG_ENV_ADDR_REDUND */
extern uchar default_environment[];
-uchar env_get_char_spec (int index)
+uchar env_get_char_spec(int index)
{
- return ( *((uchar *)(gd->env_addr + index)) );
+ return (*((uchar *)(gd->env_addr + index)));
}
+#undef debug
+#define debug printf
+
#ifdef CONFIG_ENV_ADDR_REDUND
int env_init(void)
gd->env_valid = 2;
}
- return (0);
+ return 0;
}
#ifdef CMD_SAVEENV
int saveenv(void)
{
- char *saved_data = NULL;
- int rc = 1;
- char flag = OBSOLETE_FLAG, new_flag = ACTIVE_FLAG;
+ env_t env_new;
+ ssize_t len;
+ char *saved_data = NULL;
+ char *res;
+ int rc = 1;
+ char flag = OBSOLETE_FLAG, new_flag = ACTIVE_FLAG;
#if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE
- ulong up_data = 0;
+ ulong up_data = 0;
#endif
- debug ("Protect off %08lX ... %08lX\n",
+ debug("Protect off %08lX ... %08lX\n",
(ulong)flash_addr, end_addr);
- if (flash_sect_protect (0, (ulong)flash_addr, end_addr)) {
- goto Done;
+ if (flash_sect_protect(0, (ulong)flash_addr, end_addr)) {
+ goto done;
}
- debug ("Protect off %08lX ... %08lX\n",
+ debug("Protect off %08lX ... %08lX\n",
(ulong)flash_addr_new, end_addr_new);
- if (flash_sect_protect (0, (ulong)flash_addr_new, end_addr_new)) {
- goto Done;
+ if (flash_sect_protect(0, (ulong)flash_addr_new, end_addr_new)) {
+ goto done;
+ }
+
+ res = (char *)&env_new.data;
+ len = hexport('\0', &res, ENV_SIZE);
+ if (len < 0) {
+ error("Cannot export environment: errno = %d\n", errno);
+ goto done;
}
+ env_new.crc = crc32(0, env_new.data, ENV_SIZE);
+ env_new.flags = new_flag;
#if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE
up_data = (end_addr_new + 1 - ((long)flash_addr_new + CONFIG_ENV_SIZE));
- debug ("Data to save 0x%x\n", up_data);
+ debug("Data to save 0x%lX\n", up_data);
if (up_data) {
if ((saved_data = malloc(up_data)) == NULL) {
printf("Unable to save the rest of sector (%ld)\n",
up_data);
- goto Done;
+ goto done;
}
memcpy(saved_data,
(void *)((long)flash_addr_new + CONFIG_ENV_SIZE), up_data);
- debug ("Data (start 0x%x, len 0x%x) saved at 0x%x\n",
- (long)flash_addr_new + CONFIG_ENV_SIZE,
- up_data, saved_data);
+ debug("Data (start 0x%lX, len 0x%lX) saved at 0x%p\n",
+ (long)flash_addr_new + CONFIG_ENV_SIZE,
+ up_data, saved_data);
}
#endif
- puts ("Erasing Flash...");
- debug (" %08lX ... %08lX ...",
+ puts("Erasing Flash...");
+ debug(" %08lX ... %08lX ...",
(ulong)flash_addr_new, end_addr_new);
- if (flash_sect_erase ((ulong)flash_addr_new, end_addr_new)) {
- goto Done;
+ if (flash_sect_erase((ulong)flash_addr_new, end_addr_new)) {
+ goto done;
}
- puts ("Writing to Flash... ");
- debug (" %08lX ... %08lX ...",
+ puts("Writing to Flash... ");
+ debug(" %08lX ... %08lX ...",
(ulong)&(flash_addr_new->data),
sizeof(env_ptr->data)+(ulong)&(flash_addr_new->data));
- if ((rc = flash_write((char *)env_ptr->data,
- (ulong)&(flash_addr_new->data),
- sizeof(env_ptr->data))) ||
- (rc = flash_write((char *)&(env_ptr->crc),
- (ulong)&(flash_addr_new->crc),
- sizeof(env_ptr->crc))) ||
+ if ((rc = flash_write((char *)&env_new,
+ (ulong)flash_addr_new,
+ sizeof(env_new))) ||
(rc = flash_write(&flag,
(ulong)&(flash_addr->flags),
- sizeof(flash_addr->flags))) ||
- (rc = flash_write(&new_flag,
- (ulong)&(flash_addr_new->flags),
- sizeof(flash_addr_new->flags))))
- {
- flash_perror (rc);
- goto Done;
+ sizeof(flash_addr->flags))) ) {
+ flash_perror(rc);
+ goto done;
}
- puts ("done\n");
#if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE
if (up_data) { /* restore the rest of sector */
- debug ("Restoring the rest of data to 0x%x len 0x%x\n",
- (long)flash_addr_new + CONFIG_ENV_SIZE, up_data);
+ debug("Restoring the rest of data to 0x%lX len 0x%lX\n",
+ (long)flash_addr_new + CONFIG_ENV_SIZE, up_data);
if (flash_write(saved_data,
(long)flash_addr_new + CONFIG_ENV_SIZE,
up_data)) {
flash_perror(rc);
- goto Done;
+ goto done;
}
}
#endif
+ puts("done\n");
+
{
env_t * etmp = flash_addr;
ulong ltmp = end_addr;
}
rc = 0;
-Done:
-
+done:
if (saved_data)
- free (saved_data);
+ free(saved_data);
/* try to re-protect */
- (void) flash_sect_protect (1, (ulong)flash_addr, end_addr);
- (void) flash_sect_protect (1, (ulong)flash_addr_new, end_addr_new);
+ (void) flash_sect_protect(1, (ulong)flash_addr, end_addr);
+ (void) flash_sect_protect(1, (ulong)flash_addr_new, end_addr_new);
return rc;
}
gd->env_addr = (ulong)&default_environment[0];
gd->env_valid = 0;
- return (0);
+ return 0;
}
#ifdef CMD_SAVEENV
int saveenv(void)
{
- int len, rc;
- ulong end_addr;
- ulong flash_sect_addr;
-#if defined(CONFIG_ENV_SECT_SIZE) && (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE)
- ulong flash_offset;
- uchar env_buffer[CONFIG_ENV_SECT_SIZE];
-#else
- uchar *env_buffer = (uchar *)env_ptr;
-#endif /* CONFIG_ENV_SECT_SIZE */
- int rcode = 0;
-
-#if defined(CONFIG_ENV_SECT_SIZE) && (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE)
-
- flash_offset = ((ulong)flash_addr) & (CONFIG_ENV_SECT_SIZE-1);
- flash_sect_addr = ((ulong)flash_addr) & ~(CONFIG_ENV_SECT_SIZE-1);
-
- debug ( "copy old content: "
- "sect_addr: %08lX env_addr: %08lX offset: %08lX\n",
- flash_sect_addr, (ulong)flash_addr, flash_offset);
-
- /* copy old contents to temporary buffer */
- memcpy (env_buffer, (void *)flash_sect_addr, CONFIG_ENV_SECT_SIZE);
-
- /* copy current environment to temporary buffer */
- memcpy ((uchar *)((unsigned long)env_buffer + flash_offset),
- env_ptr,
- CONFIG_ENV_SIZE);
+ env_t env_new;
+ ssize_t len;
+ int rc = 1;
+ char *res;
+ char *saved_data = NULL;
+#if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE
+ ulong up_data = 0;
- len = CONFIG_ENV_SECT_SIZE;
-#else
- flash_sect_addr = (ulong)flash_addr;
- len = CONFIG_ENV_SIZE;
+ up_data = (end_addr + 1 - ((long)flash_addr + CONFIG_ENV_SIZE));
+ debug("Data to save 0x%lx\n", up_data);
+ if (up_data) {
+ if ((saved_data = malloc(up_data)) == NULL) {
+ printf("Unable to save the rest of sector (%ld)\n",
+ up_data);
+ goto done;
+ }
+ memcpy(saved_data,
+ (void *)((long)flash_addr + CONFIG_ENV_SIZE), up_data);
+ debug("Data (start 0x%lx, len 0x%lx) saved at 0x%lx\n",
+ (ulong)flash_addr + CONFIG_ENV_SIZE,
+ up_data,
+ (ulong)saved_data);
+ }
#endif /* CONFIG_ENV_SECT_SIZE */
- end_addr = flash_sect_addr + len - 1;
+ debug("Protect off %08lX ... %08lX\n",
+ (ulong)flash_addr, end_addr);
- debug ("Protect off %08lX ... %08lX\n",
- (ulong)flash_sect_addr, end_addr);
+ if (flash_sect_protect(0, (long)flash_addr, end_addr))
+ goto done;
- if (flash_sect_protect (0, flash_sect_addr, end_addr))
- return 1;
+ res = (char *)&env_new.data;
+ len = hexport('\0', &res, ENV_SIZE);
+ if (len < 0) {
+ error("Cannot export environment: errno = %d\n", errno);
+ goto done;
+ }
+ env_new.crc = crc32(0, env_new.data, ENV_SIZE);
- puts ("Erasing Flash...");
- if (flash_sect_erase (flash_sect_addr, end_addr))
- return 1;
+ puts("Erasing Flash...");
+ if (flash_sect_erase((long)flash_addr, end_addr))
+ goto done;
- puts ("Writing to Flash... ");
- rc = flash_write((char *)env_buffer, flash_sect_addr, len);
+ puts("Writing to Flash... ");
+ rc = flash_write((char *)&env_new, (long)flash_addr, CONFIG_ENV_SIZE);
if (rc != 0) {
- flash_perror (rc);
- rcode = 1;
- } else {
- puts ("done\n");
+ flash_perror(rc);
+ goto done;
}
-
+#if CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE
+ if (up_data) { /* restore the rest of sector */
+ debug("Restoring the rest of data to 0x%lx len 0x%lx\n",
+ (ulong)flash_addr + CONFIG_ENV_SIZE, up_data);
+ if (flash_write(saved_data,
+ (long)flash_addr + CONFIG_ENV_SIZE,
+ up_data)) {
+ flash_perror(rc);
+ goto done;
+ }
+ }
+#endif
+ puts("done\n");
+ rc = 0;
+done:
+ if (saved_data)
+ free(saved_data);
/* try to re-protect */
- (void) flash_sect_protect (1, flash_sect_addr, end_addr);
- return rcode;
+ (void) flash_sect_protect(1, (long)flash_addr, end_addr);
+ return rc;
}
#endif /* CMD_SAVEENV */
#endif /* CONFIG_ENV_ADDR_REDUND */
-void env_relocate_spec (void)
+void env_relocate_spec(void)
{
-#if !defined(ENV_IS_EMBEDDED) || defined(CONFIG_ENV_ADDR_REDUND)
#ifdef CONFIG_ENV_ADDR_REDUND
if (gd->env_addr != (ulong)&(flash_addr->data)) {
- env_t * etmp = flash_addr;
+ env_t *etmp = flash_addr;
ulong ltmp = end_addr;
flash_addr = flash_addr_new;
char flag = OBSOLETE_FLAG;
gd->env_valid = 2;
- flash_sect_protect (0, (ulong)flash_addr_new, end_addr_new);
+ flash_sect_protect(0, (ulong)flash_addr_new, end_addr_new);
flash_write(&flag,
(ulong)&(flash_addr_new->flags),
sizeof(flash_addr_new->flags));
- flash_sect_protect (1, (ulong)flash_addr_new, end_addr_new);
+ flash_sect_protect(1, (ulong)flash_addr_new, end_addr_new);
}
if (flash_addr->flags != ACTIVE_FLAG &&
char flag = ACTIVE_FLAG;
gd->env_valid = 2;
- flash_sect_protect (0, (ulong)flash_addr, end_addr);
+ flash_sect_protect(0, (ulong)flash_addr, end_addr);
flash_write(&flag,
(ulong)&(flash_addr->flags),
sizeof(flash_addr->flags));
- flash_sect_protect (1, (ulong)flash_addr, end_addr);
+ flash_sect_protect(1, (ulong)flash_addr, end_addr);
}
if (gd->env_valid == 2)
puts ("*** Warning - some problems detected "
"reading environment; recovered successfully\n\n");
#endif /* CONFIG_ENV_ADDR_REDUND */
-#ifdef CMD_SAVEENV
- memcpy (env_ptr, (void*)flash_addr, CONFIG_ENV_SIZE);
-#endif
-#endif /* ! ENV_IS_EMBEDDED || CONFIG_ENV_ADDR_REDUND */
+
+ env_import((char *)flash_addr, 1);
}
/* references to names in env_common.c */
extern uchar default_environment[];
-char * env_name_spec = "MG_DISK";
+char *env_name_spec = "MG_DISK";
env_t *env_ptr = 0;
uchar env_get_char_spec(int index)
{
- return (*((uchar *) (gd->env_addr + index)));
+ return (*((uchar *)(gd->env_addr + index)));
}
void env_relocate_spec(void)
{
- unsigned int err;
+ char buf[CONFIG_ENV_SIZE];
+ unsigned int err, rc;
err = mg_disk_init();
if (err) {
- puts ("*** Warning - mg_disk_init error");
- goto OUT;
- }
- err = mg_disk_read(CONFIG_ENV_ADDR, (u_char *)env_ptr, CONFIG_ENV_SIZE);
- if (err) {
- puts ("*** Warning - mg_disk_read error");
- goto OUT;
+ set_default_env("!mg_disk_init error");
+ return;
}
- if (crc32(0, env_ptr->data, ENV_SIZE) != env_ptr->crc) {
- puts ("*** Warning - CRC error");
- goto OUT;
+ err = mg_disk_read(CONFIG_ENV_ADDR, buf, CONFIG_ENV_SIZE);
+ if (err) {
+ set_default_env("!mg_disk_read error");
+ return;
}
- return;
-
-OUT:
- printf (", using default environment\n\n");
- set_default_env();
+ env_import(buf, 1);
}
int saveenv(void)
err = mg_disk_write(CONFIG_ENV_ADDR, (u_char *)env_ptr,
CONFIG_ENV_SIZE);
if (err)
- puts ("*** Warning - mg_disk_write error\n\n");
+ puts("*** Warning - mg_disk_write error\n\n");
return err;
}
int env_init(void)
{
/* use default */
- gd->env_addr = (ulong) & default_environment[0];
+ gd->env_addr = (ulong)&default_environment[0];
gd->env_valid = 1;
return 0;
/*
+ * (C) Copyright 2000-2010
+ * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
+ *
* (C) Copyright 2008
* Stuart Wood, Lab X Technologies <stuart.wood@labxtechnologies.com>
*
* (C) Copyright 2004
* Jian Zhang, Texas Instruments, jzhang@ti.com.
-
- * (C) Copyright 2000-2006
- * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
*
* (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
* Andreas Heppel <aheppel@sysgo.de>
-
+ *
* See file CREDITS for list of people who contributed to this
* project.
*
* MA 02111-1307 USA
*/
-/* #define DEBUG */
+#define DEBUG
#include <common.h>
#include <command.h>
#include <linux/stddef.h>
#include <malloc.h>
#include <nand.h>
-#include <asm/errno.h>
+#include <search.h>
+#include <errno.h>
#if defined(CONFIG_CMD_SAVEENV) && defined(CONFIG_CMD_NAND)
#define CMD_SAVEENV
/* references to names in env_common.c */
extern uchar default_environment[];
-char * env_name_spec = "NAND";
+char *env_name_spec = "NAND";
#if defined(ENV_IS_EMBEDDED)
env_t *env_ptr = 0;
#endif /* ENV_IS_EMBEDDED */
-
-/* local functions */
-#if !defined(ENV_IS_EMBEDDED)
-static void use_default(void);
-#endif
-
DECLARE_GLOBAL_DATA_PTR;
uchar env_get_char_spec (int index)
return ( *((uchar *)(gd->env_addr + index)) );
}
-
-/* this is called before nand_init()
- * so we can't read Nand to validate env data.
- * Mark it OK for now. env_relocate() in env_common.c
- * will call our relocate function which does the real
- * validation.
+/*
+ * This is called before nand_init() so we can't read NAND to
+ * validate env data.
+ *
+ * Mark it OK for now. env_relocate() in env_common.c will call our
+ * relocate function which does the real validation.
*
* When using a NAND boot image (like sequoia_nand), the environment
- * can be embedded or attached to the U-Boot image in NAND flash. This way
- * the SPL loads not only the U-Boot image from NAND but also the
- * environment.
+ * can be embedded or attached to the U-Boot image in NAND flash.
+ * This way the SPL loads not only the U-Boot image from NAND but
+ * also the environment.
*/
int env_init(void)
{
#ifdef CONFIG_ENV_OFFSET_REDUND
int saveenv(void)
{
- int ret = 0;
+ env_t env_new;
+ ssize_t len;
+ char *res;
+ int ret = 0;
nand_erase_options_t nand_erase_options;
- env_ptr->flags++;
-
nand_erase_options.length = CONFIG_ENV_RANGE;
nand_erase_options.quiet = 0;
nand_erase_options.jffs2 = 0;
if (CONFIG_ENV_RANGE < CONFIG_ENV_SIZE)
return 1;
+
+ res = (char *)&env_new.data;
+ len = hexport('\0', &res, ENV_SIZE);
+ if (len < 0) {
+ error("Cannot export environment: errno = %d\n", errno);
+ return 1;
+ }
+ env_new.crc = crc32(0, env_new.data, ENV_SIZE);
+ env_new.flags = ACTIVE_FLAG;
+
if(gd->env_valid == 1) {
- puts ("Erasing redundant Nand...\n");
+ puts("Erasing redundant NAND...\n");
nand_erase_options.offset = CONFIG_ENV_OFFSET_REDUND;
if (nand_erase_opts(&nand_info[0], &nand_erase_options))
return 1;
- puts ("Writing to redundant Nand... ");
- ret = writeenv(CONFIG_ENV_OFFSET_REDUND, (u_char *) env_ptr);
+ puts("Writing to redundant NAND... ");
+ ret = writeenv(CONFIG_ENV_OFFSET_REDUND,
+ (u_char *)&env_new);
} else {
- puts ("Erasing Nand...\n");
+ puts("Erasing NAND...\n");
nand_erase_options.offset = CONFIG_ENV_OFFSET;
if (nand_erase_opts(&nand_info[0], &nand_erase_options))
return 1;
- puts ("Writing to Nand... ");
- ret = writeenv(CONFIG_ENV_OFFSET, (u_char *) env_ptr);
+ puts("Writing to NAND... ");
+ ret = writeenv(CONFIG_ENV_OFFSET,
+ (u_char *)&env_new);
}
if (ret) {
puts("FAILED!\n");
return 1;
}
- puts ("done\n");
+ puts("done\n");
+
gd->env_valid = (gd->env_valid == 2 ? 1 : 2);
+
return ret;
}
#else /* ! CONFIG_ENV_OFFSET_REDUND */
int saveenv(void)
{
int ret = 0;
+ env_t env_new;
+ ssize_t len;
+ char *res;
nand_erase_options_t nand_erase_options;
nand_erase_options.length = CONFIG_ENV_RANGE;
if (CONFIG_ENV_RANGE < CONFIG_ENV_SIZE)
return 1;
- puts ("Erasing Nand...\n");
+
+ res = (char *)&env_new.data;
+ len = hexport('\0', &res, ENV_SIZE);
+ if (len < 0) {
+ error("Cannot export environment: errno = %d\n", errno);
+ return 1;
+ }
+ env_new.crc = crc32(0, env_new.data, ENV_SIZE);
+
+ puts("Erasing Nand...\n");
if (nand_erase_opts(&nand_info[0], &nand_erase_options))
return 1;
- puts ("Writing to Nand... ");
- if (writeenv(CONFIG_ENV_OFFSET, (u_char *) env_ptr)) {
+ puts("Writing to Nand... ");
+ if (writeenv(CONFIG_ENV_OFFSET, (u_char *)&env_new)) {
puts("FAILED!\n");
return 1;
}
- puts ("done\n");
+ puts("done\n");
return ret;
}
#endif /* CONFIG_ENV_OFFSET_REDUND */
#endif /* CMD_SAVEENV */
-int readenv (size_t offset, u_char * buf)
+int readenv(size_t offset, u_char * buf)
{
size_t end = offset + CONFIG_ENV_RANGE;
size_t amount_loaded = 0;
#endif
#ifdef CONFIG_ENV_OFFSET_REDUND
-void env_relocate_spec (void)
+void env_relocate_spec(void)
{
#if !defined(ENV_IS_EMBEDDED)
int crc1_ok = 0, crc2_ok = 0;
- env_t *tmp_env1, *tmp_env2;
+ env_t *ep, *tmp_env1, *tmp_env2;
- tmp_env1 = (env_t *) malloc(CONFIG_ENV_SIZE);
- tmp_env2 = (env_t *) malloc(CONFIG_ENV_SIZE);
+ tmp_env1 = (env_t *)malloc(CONFIG_ENV_SIZE);
+ tmp_env2 = (env_t *)malloc(CONFIG_ENV_SIZE);
if ((tmp_env1 == NULL) || (tmp_env2 == NULL)) {
puts("Can't allocate buffers for environment\n");
- free (tmp_env1);
- free (tmp_env2);
- return use_default();
+ free(tmp_env1);
+ free(tmp_env2);
+ set_default_env("!malloc() failed");
+ return;
}
if (readenv(CONFIG_ENV_OFFSET, (u_char *) tmp_env1))
- puts("No Valid Environment Area Found\n");
+ puts("No Valid Environment Area found\n");
+
if (readenv(CONFIG_ENV_OFFSET_REDUND, (u_char *) tmp_env2))
- puts("No Valid Reundant Environment Area Found\n");
+ puts("No Valid Redundant Environment Area found\n");
crc1_ok = (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc);
crc2_ok = (crc32(0, tmp_env2->data, ENV_SIZE) == tmp_env2->crc);
- if(!crc1_ok && !crc2_ok) {
+ if (!crc1_ok && !crc2_ok) {
free(tmp_env1);
free(tmp_env2);
- return use_default();
- } else if(crc1_ok && !crc2_ok)
+ set_default_env("!bad CRC");
+ return;
+ } else if (crc1_ok && !crc2_ok) {
gd->env_valid = 1;
- else if(!crc1_ok && crc2_ok)
+ } else if (!crc1_ok && crc2_ok) {
gd->env_valid = 2;
- else {
+ } else {
/* both ok - check serial */
- if(tmp_env1->flags == 255 && tmp_env2->flags == 0)
+ if (tmp_env1->flags == 255 && tmp_env2->flags == 0)
gd->env_valid = 2;
- else if(tmp_env2->flags == 255 && tmp_env1->flags == 0)
+ else if (tmp_env2->flags == 255 && tmp_env1->flags == 0)
gd->env_valid = 1;
- else if(tmp_env1->flags > tmp_env2->flags)
+ else if (tmp_env1->flags > tmp_env2->flags)
gd->env_valid = 1;
- else if(tmp_env2->flags > tmp_env1->flags)
+ else if (tmp_env2->flags > tmp_env1->flags)
gd->env_valid = 2;
else /* flags are equal - almost impossible */
gd->env_valid = 1;
}
free(env_ptr);
- if(gd->env_valid == 1) {
- env_ptr = tmp_env1;
- free(tmp_env2);
- } else {
- env_ptr = tmp_env2;
- free(tmp_env1);
- }
+
+ if (gd->env_valid == 1)
+ ep = tmp_env1;
+ else
+ ep = tmp_env2;
+
+ env_import((char *)ep, 0);
+
+ free(tmp_env1);
+ free(tmp_env2);
#endif /* ! ENV_IS_EMBEDDED */
}
#else /* ! CONFIG_ENV_OFFSET_REDUND */
/*
- * The legacy NAND code saved the environment in the first NAND device i.e.,
- * nand_dev_desc + 0. This is also the behaviour using the new NAND code.
+ * The legacy NAND code saved the environment in the first NAND
+ * device i.e., nand_dev_desc + 0. This is also the behaviour using
+ * the new NAND code.
*/
void env_relocate_spec (void)
{
#if !defined(ENV_IS_EMBEDDED)
int ret;
+ char buf[CONFIG_ENV_SIZE];
#if defined(CONFIG_ENV_OFFSET_OOB)
ret = get_nand_env_oob(&nand_info[0], &nand_env_oob_offset);
- /* If unable to read environment offset from NAND OOB then fall through
+ /*
+ * If unable to read environment offset from NAND OOB then fall through
* to the normal environment reading code below
*/
- if (!ret)
+ if (!ret) {
printf("Found Environment offset in OOB..\n");
- else
- return use_default();
+ } else {
+ set_default_env("!no env offset in OOB");
+ return;
+ }
#endif
- ret = readenv(CONFIG_ENV_OFFSET, (u_char *) env_ptr);
- if (ret)
- return use_default();
+ ret = readenv(CONFIG_ENV_OFFSET, (u_char *)buf);
+ if (ret) {
+ set_default_env("!readenv() failed");
+ return;
+ }
- if (crc32(0, env_ptr->data, ENV_SIZE) != env_ptr->crc)
- return use_default();
+ env_import(buf, 1);
#endif /* ! ENV_IS_EMBEDDED */
}
#endif /* CONFIG_ENV_OFFSET_REDUND */
-
-#if !defined(ENV_IS_EMBEDDED)
-static void use_default()
-{
- puts ("*** Warning - bad CRC or NAND, using default environment\n\n");
- set_default_env();
-}
-#endif
/*
- * (C) Copyright 2000-2002
+ * (C) Copyright 2000-2010
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
*
* (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
extern uchar default_environment[];
-
-void env_relocate_spec (void)
+void env_relocate_spec(void)
{
}
-uchar env_get_char_spec (int index)
+uchar env_get_char_spec(int index)
{
return ( *((uchar *)(gd->env_addr + index)) );
}
-/************************************************************************
+/*
* Initialize Environment use
*
* We are still running from ROM, so data use is limited
*/
-int env_init(void)
+int env_init(void)
{
gd->env_addr = (ulong)&default_environment[0];
gd->env_valid = 0;
/*
- * (C) Copyright 2000-2002
+ * (C) Copyright 2000-2010
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
*
* (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
#include <command.h>
#include <environment.h>
#include <linux/stddef.h>
+#include <search.h>
+#include <errno.h>
DECLARE_GLOBAL_DATA_PTR;
extern uchar default_environment[];
-uchar env_get_char_spec (int index)
+uchar env_get_char_spec(int index)
{
#ifdef CONFIG_SYS_NVRAM_ACCESS_ROUTINE
uchar c;
#endif
}
-void env_relocate_spec (void)
+void env_relocate_spec(void)
{
+ char buf[CONFIG_ENV_SIZE];
+
#if defined(CONFIG_SYS_NVRAM_ACCESS_ROUTINE)
- nvram_read(env_ptr, CONFIG_ENV_ADDR, CONFIG_ENV_SIZE);
+ nvram_read(buf, CONFIG_ENV_ADDR, CONFIG_ENV_SIZE);
#else
- memcpy (env_ptr, (void*)CONFIG_ENV_ADDR, CONFIG_ENV_SIZE);
+ memcpy(buf, (void*)CONFIG_ENV_ADDR, CONFIG_ENV_SIZE);
#endif
+ env_import(buf, 1);
}
-int saveenv (void)
+int saveenv(void)
{
- int rcode = 0;
+ env_t env_new;
+ ssize_t len;
+ char *res;
+ int rcode = 0;
+
+ res = (char *)&env_new.data;
+ len = hexport('\0', &res, ENV_SIZE);
+ if (len < 0) {
+ error("Cannot export environment: errno = %d\n", errno);
+ return 1;
+ }
+ env_new.crc = crc32(0, env_new.data, ENV_SIZE);
+
#ifdef CONFIG_SYS_NVRAM_ACCESS_ROUTINE
- nvram_write(CONFIG_ENV_ADDR, env_ptr, CONFIG_ENV_SIZE);
+ nvram_write(CONFIG_ENV_ADDR, &env_new, CONFIG_ENV_SIZE);
#else
- if (memcpy ((char *)CONFIG_ENV_ADDR, env_ptr, CONFIG_ENV_SIZE) == NULL)
- rcode = 1 ;
+ if (memcpy((char *)CONFIG_ENV_ADDR, &env_new, CONFIG_ENV_SIZE) == NULL)
+ rcode = 1;
#endif
return rcode;
}
-/************************************************************************
+/*
* Initialize Environment use
*
* We are still running from ROM, so data use is limited
*/
-int env_init (void)
+int env_init(void)
{
#if defined(CONFIG_SYS_NVRAM_ACCESS_ROUTINE)
ulong crc;
uchar data[ENV_SIZE];
- nvram_read (&crc, CONFIG_ENV_ADDR, sizeof(ulong));
- nvram_read (data, CONFIG_ENV_ADDR+sizeof(ulong), ENV_SIZE);
+
+ nvram_read(&crc, CONFIG_ENV_ADDR, sizeof(ulong));
+ nvram_read(data, CONFIG_ENV_ADDR+sizeof(ulong), ENV_SIZE);
if (crc32(0, data, ENV_SIZE) == crc) {
gd->env_addr = (ulong)CONFIG_ENV_ADDR + sizeof(long);
/*
+ * (C) Copyright 2010 DENX Software Engineering
+ * Wolfgang Denk <wd@denx.de>
+ *
* (C) Copyright 2005-2009 Samsung Electronics
* Kyungmin Park <kyungmin.park@samsung.com>
*
#include <environment.h>
#include <linux/stddef.h>
#include <malloc.h>
+#include <search.h>
+#include <errno.h>
#include <linux/mtd/compat.h>
#include <linux/mtd/mtd.h>
#ifdef ENV_IS_EMBEDDED
extern uchar environment[];
-env_t *env_ptr = (env_t *) (&environment[0]);
-#else /* ! ENV_IS_EMBEDDED */
-static unsigned char onenand_env[ONENAND_MAX_ENV_SIZE];
-env_t *env_ptr = (env_t *) onenand_env;
#endif /* ENV_IS_EMBEDDED */
DECLARE_GLOBAL_DATA_PTR;
uchar env_get_char_spec(int index)
{
- return (*((uchar *) (gd->env_addr + index)));
+ return (*((uchar *)(gd->env_addr + index)));
}
void env_relocate_spec(void)
#ifdef CONFIG_ENV_ADDR_FLEX
struct onenand_chip *this = &onenand_chip;
#endif
- loff_t env_addr;
- int use_default = 0;
+ int rc;
size_t retlen;
+#ifdef ENV_IS_EMBEDDED
+ char *buf = (char *)&environment[0];
+#else
+ loff_t env_addr = CONFIG_ENV_ADDR;
+ char onenand_env[ONENAND_MAX_ENV_SIZE];
+ char *buf = (char *)&onenand_env[0];
+#endif /* ENV_IS_EMBEDDED */
- env_addr = CONFIG_ENV_ADDR;
-#ifdef CONFIG_ENV_ADDR_FLEX
+#ifndef ENV_IS_EMBEDDED
+# ifdef CONFIG_ENV_ADDR_FLEX
if (FLEXONENAND(this))
env_addr = CONFIG_ENV_ADDR_FLEX;
-#endif
+# endif
/* Check OneNAND exist */
if (mtd->writesize)
/* Ignore read fail */
mtd->read(mtd, env_addr, ONENAND_MAX_ENV_SIZE,
- &retlen, (u_char *) env_ptr);
+ &retlen, (u_char *)buf);
else
mtd->writesize = MAX_ONENAND_PAGESIZE;
+#endif /* !ENV_IS_EMBEDDED */
- if (crc32(0, env_ptr->data, ONENAND_ENV_SIZE(mtd)) != env_ptr->crc)
- use_default = 1;
-
- if (use_default) {
- memcpy(env_ptr->data, default_environment,
- ONENAND_ENV_SIZE(mtd));
- env_ptr->crc =
- crc32(0, env_ptr->data, ONENAND_ENV_SIZE(mtd));
- }
-
- gd->env_addr = (ulong) & env_ptr->data;
- gd->env_valid = 1;
+ rc = env_import(buf, 1);
+ if (rc)
+ gd->env_valid = 1;
}
int saveenv(void)
{
+ env_t env_new;
+ ssize_t len;
+ char *res;
struct mtd_info *mtd = &onenand_mtd;
#ifdef CONFIG_ENV_ADDR_FLEX
struct onenand_chip *this = &onenand_chip;
#endif
- loff_t env_addr = CONFIG_ENV_ADDR;
+ loff_t env_addr = CONFIG_ENV_ADDR;
+ size_t retlen;
struct erase_info instr = {
.callback = NULL,
};
- size_t retlen;
+
+ res = (char *)&env_new.data;
+ len = hexport('\0', &res, ENV_SIZE);
+ if (len < 0) {
+ error("Cannot export environment: errno = %d\n", errno);
+ return 1;
+ }
+ env_new.crc = crc32(0, env_new.data, ENV_SIZE);
instr.len = CONFIG_ENV_SIZE;
#ifdef CONFIG_ENV_ADDR_FLEX
return 1;
}
- /* update crc */
- env_ptr->crc = crc32(0, env_ptr->data, ONENAND_ENV_SIZE(mtd));
-
if (mtd->write(mtd, env_addr, ONENAND_MAX_ENV_SIZE, &retlen,
- (u_char *) env_ptr)) {
+ (u_char *)&env_new)) {
printf("OneNAND: write failed at 0x%llx\n", instr.addr);
return 2;
}
/*
- * (C) Copyright 2000-2002
+ * (C) Copyright 2000-2010
* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
*
* (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
#include <environment.h>
#include <malloc.h>
#include <spi_flash.h>
+#include <search.h>
+#include <errno.h>
#ifndef CONFIG_ENV_SPI_BUS
# define CONFIG_ENV_SPI_BUS 0
int saveenv(void)
{
- u32 saved_size, saved_offset;
- char *saved_buffer = NULL;
- u32 sector = 1;
- int ret;
- char flag = OBSOLETE_FLAG, new_flag = ACTIVE_FLAG;
+ env_t env_new;
+ ssize_t len;
+ char *res;
+ u32 saved_size, saved_offset;
+ char *saved_buffer = NULL;
+ u32 sector = 1;
+ int ret;
+ char flag = OBSOLETE_FLAG, new_flag = ACTIVE_FLAG;
if (!env_flash) {
puts("Environment SPI flash not initialized\n");
return 1;
}
+ res = (char *)&env_new.data;
+ len = hexport('\0', &res, ENV_SIZE);
+ if (len < 0) {
+ error("Cannot export environment: errno = %d\n", errno);
+ return 1;
+ }
+ env_new.crc = crc32(0, env_new.data, ENV_SIZE);
+ env_new.flags = ACTIVE_FLAG;
+
/* Is the sector larger than the env (i.e. embedded) */
if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
puts("Writing to SPI flash...");
ret = spi_flash_write(env_flash,
env_new_offset + offsetof(env_t, data),
- sizeof(env_ptr->data), env_ptr->data);
+ sizeof(env_new.data), env_new.data);
if (ret)
goto done;
ret = spi_flash_write(env_flash,
env_new_offset + offsetof(env_t, crc),
- sizeof(env_ptr->crc), &env_ptr->crc);
+ sizeof(env_new.crc), &env_new.crc);
if (ret)
goto done;
ret = spi_flash_write(env_flash,
env_offset + offsetof(env_t, flags),
- sizeof(env_ptr->flags), &flag);
+ sizeof(env_new.flags), &flag);
if (ret)
goto done;
ret = spi_flash_write(env_flash,
env_new_offset + offsetof(env_t, flags),
- sizeof(env_ptr->flags), &new_flag);
+ sizeof(env_new.flags), &new_flag);
if (ret)
goto done;
int crc1_ok = 0, crc2_ok = 0;
env_t *tmp_env1 = NULL;
env_t *tmp_env2 = NULL;
+ env_t ep;
uchar flag1, flag2;
/* current_env is set only in case both areas are valid! */
int current_env = 0;
tmp_env1 = (env_t *)malloc(CONFIG_ENV_SIZE);
- if (!tmp_env1) {
- puts("*** Warning: could not init environment,"
- " using defaults\n\n");
- goto out;
- }
-
tmp_env2 = (env_t *)malloc(CONFIG_ENV_SIZE);
- if (!tmp_env2) {
- puts("*** Warning: could not init environment,"
- " using defaults\n\n");
- goto out;
+
+ if (!tmp_env1 || !tmp_env2) {
+ free(tmp_env1);
+ free(tmp_env2);
+ set_default_env("!malloc() failed");
+ return;
}
env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
- if (!env_flash)
- goto err_probe;
+ if (!env_flash) {
+ set_default_env("!spi_flash_probe() failed");
+ return;
+ }
ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET,
CONFIG_ENV_SIZE, tmp_env1);
- if (ret)
+ if (ret) {
+ set_default_env("!spi_flash_read() failed");
goto err_read;
+ }
if (crc32(0, tmp_env1->data, ENV_SIZE) == tmp_env1->crc)
crc1_ok = 1;
goto err_crc;
else if (crc1_ok && !crc2_ok) {
gd->env_valid = 1;
- memcpy(env_ptr, tmp_env1, CONFIG_ENV_SIZE);
+ ep = tmp_env1;
} else if (!crc1_ok && crc2_ok) {
gd->env_valid = 1;
- memcpy(env_ptr, tmp_env2, CONFIG_ENV_SIZE);
+ ep = tmp_env2;
swap_env();
} else if (flag1 == ACTIVE_FLAG && flag2 == OBSOLETE_FLAG) {
gd->env_valid = 1;
- memcpy(env_ptr, tmp_env1, CONFIG_ENV_SIZE);
+ ep = tmp_env1;
} else if (flag1 == OBSOLETE_FLAG && flag2 == ACTIVE_FLAG) {
gd->env_valid = 1;
- memcpy(env_ptr, tmp_env2, CONFIG_ENV_SIZE);
+ ep = tmp_env2;
swap_env();
} else if (flag1 == flag2) {
gd->env_valid = 2;
- memcpy(env_ptr, tmp_env1, CONFIG_ENV_SIZE);
+ ep = tmp_env1;
current_env = 1;
} else if (flag1 == 0xFF) {
gd->env_valid = 2;
- memcpy(env_ptr, tmp_env1, CONFIG_ENV_SIZE);
+ ep = tmp_env1;
current_env = 1;
} else {
/*
* default path is desirable.
*/
gd->env_valid = 2;
- memcpy(env_ptr, tmp_env2, CONFIG_ENV_SIZE);
+ ep = tmp_env2;
swap_env();
current_env = 2;
}
+
+ rc = env_import((char *)ep, 0);
+ if (!rc) {
+ error("Cannot import environment: errno = %d\n", errno);
+ goto out;
+ }
+
if (current_env == 1) {
if (flag2 != OBSOLETE_FLAG) {
flag2 = OBSOLETE_FLAG;
spi_flash_write(env_flash,
env_new_offset + offsetof(env_t, flags),
- sizeof(env_ptr->flags), &flag2);
+ sizeof(env_new.flags), &flag2);
}
if (flag1 != ACTIVE_FLAG) {
flag1 = ACTIVE_FLAG;
spi_flash_write(env_flash,
env_offset + offsetof(env_t, flags),
- sizeof(env_ptr->flags), &flag1);
+ sizeof(env_new.flags), &flag1);
}
} else if (current_env == 2) {
if (flag1 != OBSOLETE_FLAG) {
flag1 = OBSOLETE_FLAG;
spi_flash_write(env_flash,
env_new_offset + offsetof(env_t, flags),
- sizeof(env_ptr->flags), &flag1);
+ sizeof(env_new.flags), &flag1);
}
if (flag2 != ACTIVE_FLAG) {
flag2 = ACTIVE_FLAG;
spi_flash_write(env_flash,
env_offset + offsetof(env_t, flags),
- sizeof(env_ptr->flags), &flag2);
+ sizeof(env_new.flags), &flag2);
}
}
if (gd->env_valid == 2) {
err_read:
spi_flash_free(env_flash);
env_flash = NULL;
-err_probe:
-err_crc:
- puts("*** Warning - bad CRC, using default environment\n\n");
out:
- if (tmp_env1)
- free(tmp_env1);
- if (tmp_env2)
- free(tmp_env2);
- set_default_env();
+ free(tmp_env1);
+ free(tmp_env2);
}
#else
int saveenv(void)
void env_relocate_spec(void)
{
+ char buf[CONFIG_ENV_SIZE];
int ret;
env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
- if (!env_flash)
- goto err_probe;
-
- ret = spi_flash_read(env_flash, CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, env_ptr);
- if (ret)
- goto err_read;
-
- if (crc32(0, env_ptr->data, ENV_SIZE) != env_ptr->crc)
- goto err_crc;
+ if (!env_flash) {
+ set_default_env("!spi_flash_probe() failed");
+ return;
+ }
- gd->env_valid = 1;
+ ret = spi_flash_read(env_flash,
+ CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE, buf);
+ if (ret) {
+ set_default_env("!spi_flash_read() failed");
+ goto out;
+ }
- return;
+ ret = env_import(buf, 1);
-err_read:
+ if (ret)
+ gd->env_valid = 1;
+out:
spi_flash_free(env_flash);
env_flash = NULL;
-err_probe:
-err_crc:
- puts("*** Warning - bad CRC, using default environment\n\n");
-
- set_default_env();
}
#endif
void env_crc_update (void);
/* [re]set to the default environment */
-void set_default_env(void);
+void set_default_env(const char *s);
+
+/* Import from binary representation into hash table */
+int env_import(const char *buf, int check);
#endif /* _ENVIRONMENT_H_ */
# include <linux/string.h>
#endif
+#ifndef CONFIG_ENV_MAX_ENTRIES /* maximum number of entries */
+#define CONFIG_ENV_MAX_ENTRIES 512
+#endif
+
#include "search.h"
/*
* table size is based on heuristics: in a sample of some 70+
* existing systems we found an average size of 39+ bytes per entry
* in the environment (for the whole key=value pair). Assuming a
- * size of 7 per entry (= safety factor of >5) should provide enough
- * safety margin for any existing environment definitons and still
+ * size of 8 per entry (= safety factor of ~5) should provide enough
+ * safety margin for any existing environment definitions and still
* allow for more than enough dynamic additions. Note that the
* "size" argument is supposed to give the maximum enviroment size
- * (CONFIG_ENV_SIZE).
+ * (CONFIG_ENV_SIZE). This heuristics will result in
+ * unreasonably large numbers (and thus memory footprint) for
+ * big flash environments (>8,000 entries for 64 KB
+ * envrionment size), so we clip it to a reasonable value
+ * (which can be overwritten in the board config file if
+ * needed).
*/
if (!htab->table) {
- int nent = size / 7;
+ int nent = size / 8;
+
+ if (nent > CONFIG_ENV_MAX_ENTRIES)
+ nent = CONFIG_ENV_MAX_ENTRIES;
debug("Create Hash Table: N=%d\n", nent);
hsearch_r(e, ENTER, &rv, htab);
if (rv == NULL) {
- printf("himport_r: can't insert \"%s=%s\" into hash table\n", name, value);
+ printf("himport_r: can't insert \"%s=%s\" into hash table\n",
+ name, value);
return 0;
}
- debug("INSERT: %p ==> name=\"%s\" value=\"%s\"\n", rv, name,
- value);
- debug(" table = %p, size = %d, filled = %d\n", htab,
- htab->size, htab->filled);
+ debug("INSERT: table %p, filled %d/%d rv %p ==> name=\"%s\" value=\"%s\"\n",
+ htab, htab->filled, htab->size,
+ rv, name, value);
} while ((dp < data + size) && *dp); /* size check needed for text */
/* without '\0' termination */
+ debug("INSERT: free(data = %p)\n", data);
free(data);
+ debug("INSERT: done\n");
return 1; /* everything OK */
}
projects / oweals / u-boot.git / commitdiff