New implementation for internal handling of environment variables.
authorWolfgang Denk <wd@denx.de>
Sun, 20 Jun 2010 21:33:59 +0000 (23:33 +0200)
committerWolfgang Denk <wd@denx.de>
Sun, 19 Sep 2010 17:29:48 +0000 (19:29 +0200)
Motivation:

* Old environment code used a pessimizing implementation:
  - variable lookup used linear search => slow
  - changed/added variables were added at the end, i. e. most
    frequently used variables had the slowest access times => slow
  - each setenv() would calculate the CRC32 checksum over the whole
    environment block => slow
* "redundant" envrionment was locked down to two copies
* No easy way to implement features like "reset to factory defaults",
  or to select one out of several pre-defined (previously saved) sets
  of environment settings ("profiles")
* No easy way to import or export environment settings

======================================================================

API Changes:

- Variable names starting with '#' are no longer allowed

  I didn't find any such variable names being used; it is highly
  recommended to follow standard conventions and start variable names
  with an alphanumeric character

- "printenv" will now print a backslash at the end of all but the last
  lines of a multi-line variable value.

  Multi-line variables have never been formally defined, allthough
  there is no reason not to use them. Now we define rules how to deal
  with them, allowing for import and export.

- Function forceenv() and the related code in saveenv() was removed.
  At the moment this is causing build problems for the only user of
  this code (schmoogie - which has no entry in MAINTAINERS); may be
  fixed later by implementing the "env set -f" feature.

Inconsistencies:

- "printenv" will '\\'-escape the '\n' in multi-line variables, while
  "printenv var" will not do that.

======================================================================

Advantages:

- "printenv" output much better readable (sorted)
- faster!
- extendable (additional variable properties can be added)
- new, powerful features like "factory reset" or easy switching
  between several different environment settings ("profiles")

Disadvantages:

- Image size grows by typically 5...7 KiB (might shrink a bit again on
  systems with redundant environment with a following patch series)

======================================================================

Implemented:

- env command with subcommands:

  - env print [arg ...]

    same as "printenv": print environment

  - env set [-f] name [arg ...]

    same as "setenv": set (and delete) environment variables

    ["-f" - force setting even for read-only variables - not
    implemented yet.]

  - end delete [-f] name

    not implemented yet

    ["-f" - force delete even for read-only variables]

  - env save

    same as "saveenv": save environment

  - env export [-t | -b | -c] addr [size]

    export internal representation (hash table) in formats usable for
    persistent storage or processing:

-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}

  - env import [-d] [-t | -b | -c] addr [size]

    import external format (text or binary) into hash table,
    optionally deleting existing values:

-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

  - env default -f

    reset default environment: drop all environment settings and load
    default environment

  - env ask name [message] [size]

    same as "askenv": ask for environment variable

  - env edit name

    same as "editenv": edit environment variable

  - env run

    same as "run": run commands in an environment variable

======================================================================

TODO:

- drop default env as implemented now; provide a text file based
  initialization instead (eventually using several text files to
  incrementally build it from common blocks) and a tool to convert it
  into a binary blob / object file.

- It would be nice if we could add wildcard support for environment
  variables; this is needed for variable name auto-completion,
  but it would also be nice to be able to say "printenv ip*" or
  "printenv *addr*"

- Some boards don't link any more due to the grown code size:
  DU405, canyonlands, sequoia, socrates.

=> cc: Matthias Fuchs <matthias.fuchs@esd-electronics.com>,
       Stefan Roese <sr@denx.de>,
       Heiko Schocher <hs@denx.de>

- Dropping forceenv() causes build problems on schmoogie

=> cc: Sergey Kubushyn <ksi@koi8.net>

- Build tested on PPC and ARM only; runtime tested with NOR and NAND
  flash only => needs testing!!

Signed-off-by: Wolfgang Denk <wd@denx.de>
Cc: Matthias Fuchs <matthias.fuchs@esd-electronics.com>,
Cc: Stefan Roese <sr@denx.de>,
Cc: Heiko Schocher <hs@denx.de>
Cc: Sergey Kubushyn <ksi@koi8.net>
28 files changed:
README
arch/arm/include/asm/global_data.h
arch/avr32/include/asm/global_data.h
arch/blackfin/include/asm/global_data.h
arch/i386/include/asm/global_data.h
arch/m68k/include/asm/global_data.h
arch/microblaze/include/asm/global_data.h
arch/mips/include/asm/global_data.h
arch/nios2/include/asm/global_data.h
arch/powerpc/include/asm/global_data.h
arch/sh/include/asm/global_data.h
arch/sparc/include/asm/global_data.h
board/zeus/zeus.c
common/cmd_nvedit.c
common/command.c
common/dlmalloc.c
common/env_common.c
common/env_dataflash.c
common/env_eeprom.c
common/env_flash.c
common/env_mgdisk.c
common/env_nand.c
common/env_nowhere.c
common/env_nvram.c
common/env_onenand.c
common/env_sf.c
include/environment.h
lib/hashtable.c

diff --git a/README b/README
index ccaace797f125f6b971451f5797684a510e44db3..aa11c377452ed099db45f6f0315f262ec27cda7e 100644 (file)
--- a/README
+++ b/README
@@ -2364,6 +2364,14 @@ Configuration Settings:
                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:
index bd3c3eaf421f5161f50295202ecc0f56e8b71d94..0bc464a3f6e885cd869fbf3a3882d5469602e523 100644 (file)
@@ -54,13 +54,14 @@ typedef     struct  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 ("r8")
 
index 521a6a2f6e1f2a78b81ac856e0bd68885e4f375d..5a7aed94e1460d34b0fafb2a7bdf90588bb6ef56 100644 (file)
@@ -52,13 +52,14 @@ typedef     struct  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 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")
 
index 3cfd00e6655247a68fa5ed25feccc6d82d3e8d16..d5514b0dffb17737fa67ccd6545df3bf36bcf8d1 100644 (file)
@@ -60,13 +60,14 @@ typedef struct 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 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")
 
index adf62915e431731e50e6498c3206c58109e32a0b..3a9adc9c669c5197e1df3255a2425d04f9bc382e 100644 (file)
@@ -52,13 +52,14 @@ typedef     struct {
 /*
  * 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;
 
index a8578d8a83e29c7bf3c7c70cc79985ab5d3bf1c2..3a36f8225486ba992dad65a4ea2399e567b7d12b 100644 (file)
@@ -70,13 +70,14 @@ typedef     struct  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 */
 
 #if 0
 extern gd_t *global_data;
index c7c1472b2d6abe6525f607a719dc8aa0d17a16c6..03444ef339d707511b67f68a76cb3e94180233f2 100644 (file)
@@ -49,13 +49,14 @@ typedef     struct  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")
 
index 994e7702e7dd215135b76c910ec898c8de26b917..bf1bfc390f82bc267de60f85e8d8ff8c7ab81608 100644 (file)
@@ -52,13 +52,14 @@ typedef     struct  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 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")
 
index c292a527e4c4ce66f3818b4286f314064da53be5..2c4a719409d41f99206c31aae815239499708503 100644 (file)
@@ -41,13 +41,14 @@ typedef     struct  global_data {
 } 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")
 
index 3e97f7661a80ac8d87f1f9579f0e202443c298fe..2a323e13d08b798eee6f4dfb52449f4150f4abdc 100644 (file)
@@ -182,13 +182,14 @@ typedef   struct  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 */
 
 #if 1
 #define DECLARE_GLOBAL_DATA_PTR     register volatile gd_t *gd asm ("r2")
index 7fda1e1b62a1e905b8ac0a70c1979921d60c8d4a..0c09ba9bad7db563d684d4fda45495eb297f49f4 100644 (file)
@@ -41,13 +41,14 @@ typedef     struct global_data
        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")
 
index de6482f51202feb72873941acb0d9a42476ff7b2..7c1ac0dddd4dcede288656fee2cfa64e95c92e04 100644 (file)
@@ -77,13 +77,14 @@ typedef struct 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_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")
 
index e2951512f88f8677e8c3cba5d1e093cb92b130b0..4e6878a266623132b84cd6a05c46c2152f370eb0 100644 (file)
@@ -222,27 +222,8 @@ static int restore_default(void)
        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;
 
        /*
@@ -251,6 +232,10 @@ static int restore_default(void)
         * -> 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");
index 74a506979d6f8bd914aab57651f5631c3598f588..c3d63b8a4329b11ad113b985772809a9c1b437b9 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * (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>
@@ -72,8 +71,10 @@ SPI_FLASH|MG_DISK|NVRAM|MMC|NOWHERE}
 #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)
@@ -82,7 +83,7 @@ static const unsigned long baudrate_table[] = CONFIG_SYS_BAUDRATE_TABLE;
 #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
@@ -94,61 +95,51 @@ int get_env_id (void)
 {
        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);
@@ -157,9 +148,9 @@ int do_printenv (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 
        /* 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;
                }
        }
@@ -167,25 +158,18 @@ int do_printenv (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
        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];
 
@@ -198,13 +182,9 @@ int _do_setenv (int flag, int argc, char * const argv[])
        /*
         * 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) {
@@ -238,31 +218,25 @@ int _do_setenv (int flag, int argc, char * const argv[])
        }
 
        /*
-        * 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) {
@@ -289,75 +263,50 @@ int _do_setenv (int flag, int argc, char * const argv[])
                                      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;
@@ -370,13 +319,12 @@ int _do_setenv (int flag, int argc, char * const argv[])
                }
                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;
        }
@@ -388,30 +336,29 @@ int setenv (char *varname, char *varvalue)
 {
        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];
@@ -419,38 +366,30 @@ int do_askenv ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
        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;
        }
 
@@ -461,7 +400,7 @@ int do_askenv ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
                return 1;
 
        /* prompt for input */
-       len = readline (message);
+       len = readline(message);
 
        if (size < len)
                console_buffer[size] = '\0';
@@ -473,15 +412,15 @@ int do_askenv ( cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
        }
 
        /* 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;
@@ -503,42 +442,37 @@ int do_editenv(cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 }
 #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;
 
@@ -571,7 +505,7 @@ int getenv_f(char *name, char *buf, unsigned len)
 
 #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;
 
@@ -581,7 +515,7 @@ int do_saveenv (cmd_tbl_t *cmdtp, int flag, int argc, char * const argv[])
 }
 
 U_BOOT_CMD(
-       saveenv, 1, 0,  do_saveenv,
+       saveenv, 1, 0,  do_env_save,
        "save environment variables to persistent storage",
        ""
 );
@@ -589,7 +523,7 @@ U_BOOT_CMD(
 #endif
 
 
-/************************************************************************
+/*
  * Match a name / name=value pair
  *
  * s1 is either a simple 'name', or a 'name=value' pair.
@@ -608,12 +542,345 @@ int envmatch (uchar *s1, int i2)
        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'"
@@ -621,7 +888,7 @@ U_BOOT_CMD(
 #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"
@@ -629,7 +896,7 @@ U_BOOT_CMD(
 );
 
 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"
@@ -640,7 +907,7 @@ U_BOOT_CMD(
 #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"
@@ -655,7 +922,6 @@ U_BOOT_CMD(
 #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",
index 30a9801d9f5e7aca5c64a1fab0ed2a4623499ca7..72266c326edd16232dad6f6353d9d252f7674052 100644 (file)
@@ -160,6 +160,7 @@ int cmd_usage(cmd_tbl_t *cmdtp)
 
 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;
 
@@ -170,7 +171,7 @@ int var_complete(int argc, char * const argv[], char last_char, int maxv, char *
 
        if (!space && argc == 2)
                return env_complete(argv[1], maxv, cmdv, sizeof(tmp_buf), tmp_buf);
-
+#endif
        return 0;
 }
 
index 2276532da7a8441c500c39b1716e23a2806a8c21..ae5702dd52ae178d0e0e16d46a173dbdd927d75c 100644 (file)
 
 \f
 
-
 /* Preliminaries */
 
 #ifndef __STD_C
@@ -935,10 +934,10 @@ struct mallinfo mALLINFo();
 #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);
@@ -946,9 +945,7 @@ 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;
 
@@ -1618,9 +1615,9 @@ static struct mallinfo current_mallinfo = {  0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
 
 /* 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;
@@ -3101,7 +3098,7 @@ size_t malloc_usable_size(mem) Void_t* mem;
 
 /* Utility to update current_mallinfo for malloc_stats and mallinfo() */
 
-#if 0
+#ifdef DEBUG
 static void malloc_update_mallinfo()
 {
   int i;
@@ -3139,7 +3136,7 @@ static void malloc_update_mallinfo()
   current_mallinfo.keepcost = chunksize(top);
 
 }
-#endif /* 0 */
+#endif /* DEBUG */
 
 \f
 
@@ -3158,7 +3155,7 @@ static void malloc_update_mallinfo()
 
 */
 
-#if 0
+#ifdef DEBUG
 void malloc_stats()
 {
   malloc_update_mallinfo();
@@ -3173,19 +3170,19 @@ void malloc_stats()
          (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
index 460309beed3b15438f3c9a08955e95166f03e16d..a415ef8efe5d9ba19e2eff4b5c1a990cae08f3fb 100644 (file)
@@ -1,10 +1,10 @@
 /*
- * (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);
@@ -134,33 +129,22 @@ uchar default_environment[] = {
        "\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)
@@ -178,70 +162,84 @@ 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;
index 27a3bbcca03fba009cdcc3357ab0940e7af43b72..270f2b3272766e8a3117155071b20dfe5de77813 100644 (file)
@@ -1,4 +1,5 @@
-/* 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;
 
@@ -29,39 +31,59 @@ env_t *env_ptr = NULL;
 
 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)
@@ -69,30 +91,36 @@ 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;
 }
index 8fe59f8224b99c34cd738b1ad218f592cc335ec2..792b44ffabb898f85cb15ec8ecb25656cc3efcd6 100644 (file)
@@ -1,10 +1,10 @@
 /*
- * (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)
@@ -51,9 +54,9 @@ static int eeprom_bus_read (unsigned dev_addr, unsigned offset, uchar *buffer,
                        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) {
@@ -67,6 +70,7 @@ static int eeprom_bus_read (unsigned dev_addr, unsigned offset, uchar *buffer,
 #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);
@@ -74,8 +78,8 @@ static int eeprom_bus_read (unsigned dev_addr, unsigned offset, uchar *buffer,
        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)
@@ -83,7 +87,7 @@ static int eeprom_bus_write (unsigned dev_addr, unsigned offset, uchar *buffer,
 
        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
@@ -95,12 +99,12 @@ uchar env_get_char_spec (int index)
        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);
 
@@ -109,40 +113,60 @@ uchar env_get_char_spec (int index)
 
 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);
@@ -157,10 +181,10 @@ int saveenv(void)
        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
  */
 
@@ -175,31 +199,31 @@ int env_init(void)
        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;
                }
@@ -245,22 +269,23 @@ int env_init(void)
        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;
        }
index 925c5a02dfb32b1fd6c8b8a1c9b12761ac99b172..1da78b7102e4c13b3589abb9a18e04d71bd4a927 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * (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>
@@ -31,6 +31,8 @@
 #include <environment.h>
 #include <linux/stddef.h>
 #include <malloc.h>
+#include <search.h>
+#include <errno.h>
 
 DECLARE_GLOBAL_DATA_PTR;
 
@@ -51,36 +53,38 @@ char * env_name_spec = "Flash";
 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)
@@ -123,91 +127,97 @@ 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;
@@ -220,13 +230,12 @@ int saveenv(void)
        }
 
        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;
 }
@@ -244,83 +253,93 @@ int  env_init(void)
 
        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;
@@ -336,11 +355,11 @@ void env_relocate_spec (void)
                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 &&
@@ -348,19 +367,17 @@ void env_relocate_spec (void)
                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);
 }
index b9de1ed0d38d0b117ddfb050109f5c2ce04e555c..a69923b700f69a35be87ed3c3d5b3baf227cb559 100644 (file)
@@ -30,7 +30,7 @@
 /* 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;
 
@@ -38,34 +38,27 @@ 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)
 {
-       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)
@@ -76,7 +69,7 @@ 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;
 }
@@ -84,7 +77,7 @@ int saveenv(void)
 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;
index d38bcca1b81119c482ab49b119fb8ca2aff1b40a..4e8307aa3332d67cc43dfd178ef5451e3d711377 100644 (file)
@@ -1,16 +1,16 @@
 /*
+ * (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.
  *
@@ -30,7 +30,7 @@
  * MA 02111-1307 USA
  */
 
-/* #define DEBUG */
+#define DEBUG
 
 #include <common.h>
 #include <command.h>
@@ -38,7 +38,8 @@
 #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
@@ -57,7 +58,7 @@
 /* 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)
@@ -69,12 +70,6 @@ env_t *env_ptr = (env_t *)CONFIG_NAND_ENV_DST;
 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)
@@ -82,17 +77,17 @@ 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)
 {
@@ -189,11 +184,12 @@ int writeenv(size_t offset, u_char *buf)
 #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;
@@ -201,36 +197,53 @@ int saveenv(void)
 
        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;
@@ -241,23 +254,32 @@ int saveenv(void)
 
        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;
@@ -320,47 +342,50 @@ int get_nand_env_oob(nand_info_t *nand, unsigned long *result)
 #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;
@@ -368,51 +393,52 @@ void env_relocate_spec (void)
        }
 
        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
index ccc068b8e8427c4fd8b4fbdd995d6a75b7ed3e4d..75ef78de87753e36bf314eaf6ae1784ec79d27e0 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * (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>
@@ -35,22 +35,21 @@ env_t *env_ptr = NULL;
 
 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;
index 7c7cf9850aa8a214011e80bc5de57d7f264736a5..6e90f2bcb53d82c30422beff96933794444ea001 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * (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>
@@ -44,6 +44,8 @@
 #include <command.h>
 #include <environment.h>
 #include <linux/stddef.h>
+#include <search.h>
+#include <errno.h>
 
 DECLARE_GLOBAL_DATA_PTR;
 
@@ -59,7 +61,7 @@ char * env_name_spec = "NVRAM";
 
 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;
@@ -72,40 +74,56 @@ uchar env_get_char_spec (int index)
 #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);
index cf997bf7e507bbda71d3f839fcfcbf3cd004fcc7..02cb5354f182bceb933aed745ae768eed1e33118 100644 (file)
@@ -1,4 +1,7 @@
 /*
+ * (C) Copyright 2010 DENX Software Engineering
+ * Wolfgang Denk <wd@denx.de>
+ *
  * (C) Copyright 2005-2009 Samsung Electronics
  * Kyungmin Park <kyungmin.park@samsung.com>
  *
@@ -26,6 +29,8 @@
 #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>
@@ -44,17 +49,13 @@ char *env_name_spec = "OneNAND";
 
 #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)
@@ -63,48 +64,57 @@ 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
@@ -122,11 +132,8 @@ int saveenv(void)
                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;
        }
index 4391d61fc1c45277867280003f94caab985726cb..fb0c39b3ce8d654ea42a62acb4e8ced6d5af5f32 100644 (file)
@@ -1,5 +1,5 @@
 /*
- * (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>
@@ -29,6 +29,8 @@
 #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
@@ -77,17 +79,29 @@ void swap_env(void)
 
 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;
@@ -118,25 +132,25 @@ int saveenv(void)
        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;
 
@@ -164,33 +178,34 @@ void env_relocate_spec(void)
        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;
@@ -208,25 +223,25 @@ void env_relocate_spec(void)
                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 {
                /*
@@ -234,35 +249,42 @@ void env_relocate_spec(void)
                 * 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) {
@@ -278,15 +300,9 @@ void env_relocate_spec(void)
 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)
@@ -348,32 +364,30 @@ 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
 
index fbccf6ab0c442745ed194a18d62bcbeb70693ad7..bedbc5424202595c81d10db310de39906c3d93b9 100644 (file)
@@ -160,6 +160,9 @@ unsigned char env_get_char_memory (int index);
 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_ */
index 2f3b5c8d1026eaa7cc9edd0864e505fcd9056d40..b747f1f799c16f791b20aa4a529c80917d0a10e4 100644 (file)
 # include <linux/string.h>
 #endif
 
+#ifndef        CONFIG_ENV_MAX_ENTRIES  /* maximum number of entries */
+#define        CONFIG_ENV_MAX_ENTRIES 512
+#endif
+
 #include "search.h"
 
 /*
@@ -636,15 +640,23 @@ int himport_r(struct hsearch_data *htab,
         * 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);
 
@@ -705,17 +717,19 @@ int himport_r(struct hsearch_data *htab,
 
                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 */
 }