Eric Lee / smarc-uboot | Embedian Git Server

Commit e1caa5841e8a9bc0ee658bdacae0519fa28e1e6a

Authored by York Sun 2018-02-08 06:17:11 +0800

Committed by Tom Rini 2018-02-17 00:12:41 +0800

Exists in smarc_8mq_lf_v2020.04 and in 17 other branches

env: Fix env_load_location

Commit 7d714a24d725 ("env: Support multiple environments") added
static variable env_load_location. When saving environmental
variables, this variable is presumed to have the value set before.
In case the value was set before relocation and U-Boot runs from a
NOR flash, this variable wasn't writable. This causes failure when
saving the environment. To save this location, global data must be
used instead.

Signed-off-by: York Sun <york.sun@nxp.com>
CC: Maxime Ripard <maxime.ripard@free-electrons.com>

Showing 3 changed files with 5 additions and 6 deletions Inline Diff

env/env.c
include/asm-generic/global_data.h
include/environment.h

env/env.c

Diff comments View file @ e1caa58

 /*
  * Copyright (C) 2017 Google, Inc
  * Written by Simon Glass <sjg@chromium.org>
  *
  * SPDX-License-Identifier:     GPL-2.0+
  */
 #include <common.h>
 #include <environment.h>
 DECLARE_GLOBAL_DATA_PTR;
 static struct env_driver *_env_driver_lookup(enum env_location loc)
 {
 	struct env_driver *drv;
 	const int n_ents = ll_entry_count(struct env_driver, env_driver);
 	struct env_driver *entry;
 	drv = ll_entry_start(struct env_driver, env_driver);
 	for (entry = drv; entry != drv + n_ents; entry++) {
 		if (loc == entry->location)
 			return entry;
 	}
 	/* Not found */
 	return NULL;
 }
 static enum env_location env_locations[] = {
 #ifdef CONFIG_ENV_IS_IN_EEPROM
 	ENVL_EEPROM,
 #endif
 #ifdef CONFIG_ENV_IS_IN_EXT4
 	ENVL_EXT4,
 #endif
 #ifdef CONFIG_ENV_IS_IN_FAT
 	ENVL_FAT,
 #endif
 #ifdef CONFIG_ENV_IS_IN_FLASH
 	ENVL_FLASH,
 #endif
 #ifdef CONFIG_ENV_IS_IN_MMC
 	ENVL_MMC,
 #endif
 #ifdef CONFIG_ENV_IS_IN_NAND
 	ENVL_NAND,
 #endif
 #ifdef CONFIG_ENV_IS_IN_NVRAM
 	ENVL_NVRAM,
 #endif
 #ifdef CONFIG_ENV_IS_IN_REMOTE
 	ENVL_REMOTE,
 #endif
 #ifdef CONFIG_ENV_IS_IN_SPI_FLASH
 	ENVL_SPI_FLASH,
 #endif
 #ifdef CONFIG_ENV_IS_IN_UBI
 	ENVL_UBI,
 #endif
 #ifdef CONFIG_ENV_IS_NOWHERE
 	ENVL_NOWHERE,
 #endif
 };
-static enum env_location env_load_location = ENVL_UNKNOWN;
 static bool env_has_inited(enum env_location location)
 {
 	return gd->env_has_init & BIT(location);
 }
 static void env_set_inited(enum env_location location)
 {
 	/*
 	 * We're using a 32-bits bitmask stored in gd (env_has_init)
 	 * using the above enum value as the bit index. We need to
 	 * make sure that we're not overflowing it.
 	 */
 	BUILD_BUG_ON(ARRAY_SIZE(env_locations) > BITS_PER_LONG);
 	gd->env_has_init |= BIT(location);
 }
 /**
  * env_get_location() - Returns the best env location for a board
  * @op: operations performed on the environment
  * @prio: priority between the multiple environments, 0 being the
  *        highest priority
  *
  * This will return the preferred environment for the given priority.
  * This is overridable by boards if they need to.
  *
  * All implementations are free to use the operation, the priority and
  * any other data relevant to their choice, but must take into account
  * the fact that the lowest prority (0) is the most important location
  * in the system. The following locations should be returned by order
  * of descending priorities, from the highest to the lowest priority.
  *
  * Returns:
  * an enum env_location value on success, a negative error code otherwise
  */
 __weak enum env_location env_get_location(enum env_operation op, int prio)
 {
 	switch (op) {
 	case ENVOP_GET_CHAR:
 	case ENVOP_INIT:
 	case ENVOP_LOAD:
 		if (prio >= ARRAY_SIZE(env_locations))
 			return ENVL_UNKNOWN;
-		env_load_location = env_locations[prio];
+		gd->env_load_location = env_locations[prio];
-		return env_load_location;
+		return gd->env_load_location;
 	case ENVOP_SAVE:
-		return env_load_location;
+		return gd->env_load_location;
 	}
 	return ENVL_UNKNOWN;
 }
 /**
  * env_driver_lookup() - Finds the most suited environment location
  * @op: operations performed on the environment
  * @prio: priority between the multiple environments, 0 being the
  *        highest priority
  *
  * This will try to find the available environment with the highest
  * priority in the system.
  *
  * Returns:
  * NULL on error, a pointer to a struct env_driver otherwise
  */
 static struct env_driver *env_driver_lookup(enum env_operation op, int prio)
 {
 	enum env_location loc = env_get_location(op, prio);
 	struct env_driver *drv;
 	if (loc == ENVL_UNKNOWN)
 		return NULL;
 	drv = _env_driver_lookup(loc);
 	if (!drv) {
 		debug("%s: No environment driver for location %d\n", __func__,
 		      loc);
 		return NULL;
 	}
 	return drv;
 }
 int env_get_char(int index)
 {
 	struct env_driver *drv;
 	int prio;
 	if (gd->env_valid == ENV_INVALID)
 		return default_environment[index];
 	for (prio = 0; (drv = env_driver_lookup(ENVOP_GET_CHAR, prio)); prio++) {
 		int ret;
 		if (!drv->get_char)
 			continue;
 		if (!env_has_inited(drv->location))
 			continue;
 		ret = drv->get_char(index);
 		if (!ret)
 			return 0;
 		debug("%s: Environment %s failed to load (err=%d)\n", __func__,
 		      drv->name, ret);
 	}
 	return -ENODEV;
 }
 int env_load(void)
 {
 	struct env_driver *drv;
 	int prio;
 	for (prio = 0; (drv = env_driver_lookup(ENVOP_LOAD, prio)); prio++) {
 		int ret;
 		if (!drv->load)
 			continue;
 		if (!env_has_inited(drv->location))
 			continue;
 		printf("Loading Environment from %s... ", drv->name);
 		ret = drv->load();
 		if (ret)
 			printf("Failed (%d)\n", ret);
 		else
 			printf("OK\n");
 		if (!ret)
 			return 0;
 	}
 	return -ENODEV;
 }
 int env_save(void)
 {
 	struct env_driver *drv;
 	int prio;
 	for (prio = 0; (drv = env_driver_lookup(ENVOP_SAVE, prio)); prio++) {
 		int ret;
 		if (!drv->save)
 			continue;
 		if (!env_has_inited(drv->location))
 			continue;
 		printf("Saving Environment to %s... ", drv->name);
 		ret = drv->save();
 		if (ret)
 			printf("Failed (%d)\n", ret);
 		else
 			printf("OK\n");
 		if (!ret)
 			return 0;
 	}
 	return -ENODEV;
 }
 int env_init(void)
 {
 	struct env_driver *drv;
 	int ret = -ENOENT;
 	int prio;
 	for (prio = 0; (drv = env_driver_lookup(ENVOP_INIT, prio)); prio++) {
 		if (!drv->init || !(ret = drv->init()))
 			env_set_inited(drv->location);
 		debug("%s: Environment %s init done (ret=%d)\n", __func__,
 		      drv->name, ret);
 	}
 	if (!prio)
 		return -ENODEV;
 	if (ret == -ENOENT) {
 		gd->env_addr = (ulong)&default_environment[0];
 		gd->env_valid = ENV_VALID;
 		return 0;
 	}
 	return ret;
 }

include/asm-generic/global_data.h

Diff comments View file @ e1caa58

 /*
  * Copyright (c) 2012 The Chromium OS Authors.
  * (C) Copyright 2002-2010
  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #ifndef __ASM_GENERIC_GBL_DATA_H
 #define __ASM_GENERIC_GBL_DATA_H
 /*
  * The following data structure is placed in some memory which is
  * available very early after boot (like DPRAM on MPC8xx/MPC82xx, or
  * some locked parts of the data cache) to allow for a minimum set of
  * global variables during system initialization (until we have set
  * up the memory controller so that we can use RAM).
  *
  * Keep it *SMALL* and remember to set GENERATED_GBL_DATA_SIZE > sizeof(gd_t)
  *
  * Each architecture has its own private fields. For now all are private
  */
 #ifndef __ASSEMBLY__
 #include <membuff.h>
 #include <linux/list.h>
 typedef struct global_data {
 	bd_t *bd;
 	unsigned long flags;
 	unsigned int baudrate;
 	unsigned long cpu_clk;		/* CPU clock in Hz!		*/
 	unsigned long bus_clk;
 	/* We cannot bracket this with CONFIG_PCI due to mpc5xxx */
 	unsigned long pci_clk;
 	unsigned long mem_clk;
 #if defined(CONFIG_LCD) || defined(CONFIG_VIDEO)
 	unsigned long fb_base;		/* Base address of framebuffer mem */
 #endif
 #if defined(CONFIG_POST)
 	unsigned long post_log_word;	/* Record POST activities */
 	unsigned long post_log_res;	/* success of POST test */
 	unsigned long post_init_f_time;	/* When post_init_f started */
 #endif
 #ifdef CONFIG_BOARD_TYPES
 	unsigned long board_type;
 #endif
 	unsigned long have_console;	/* serial_init() was called */
 #if CONFIG_IS_ENABLED(PRE_CONSOLE_BUFFER)
 	unsigned long precon_buf_idx;	/* Pre-Console buffer index */
 #endif
 	unsigned long env_addr;		/* Address  of Environment struct */
 	unsigned long env_valid;	/* Environment valid? enum env_valid */
 	unsigned long env_has_init;	/* Bitmask of boolean of struct env_location offsets */
+	int env_load_location;
 	unsigned long ram_top;		/* Top address of RAM used by U-Boot */
 	unsigned long relocaddr;	/* Start address of U-Boot in RAM */
 	phys_size_t ram_size;		/* RAM size */
 	unsigned long mon_len;		/* monitor len */
 	unsigned long irq_sp;		/* irq stack pointer */
 	unsigned long start_addr_sp;	/* start_addr_stackpointer */
 	unsigned long reloc_off;
 	struct global_data *new_gd;	/* relocated global data */
 #ifdef CONFIG_DM
 	struct udevice	*dm_root;	/* Root instance for Driver Model */
 	struct udevice	*dm_root_f;	/* Pre-relocation root instance */
 	struct list_head uclass_root;	/* Head of core tree */
 #endif
 #ifdef CONFIG_TIMER
 	struct udevice	*timer;		/* Timer instance for Driver Model */
 #endif
 	const void *fdt_blob;		/* Our device tree, NULL if none */
 	void *new_fdt;			/* Relocated FDT */
 	unsigned long fdt_size;		/* Space reserved for relocated FDT */
 #ifdef CONFIG_OF_LIVE
 	struct device_node *of_root;
 #endif
 	struct jt_funcs *jt;		/* jump table */
 	char env_buf[32];		/* buffer for env_get() before reloc. */
 #ifdef CONFIG_TRACE
 	void		*trace_buff;	/* The trace buffer */
 #endif
 #if defined(CONFIG_SYS_I2C)
 	int		cur_i2c_bus;	/* current used i2c bus */
 #endif
 #ifdef CONFIG_SYS_I2C_MXC
 	void *srdata[10];
 #endif
 	unsigned int timebase_h;
 	unsigned int timebase_l;
 #if CONFIG_VAL(SYS_MALLOC_F_LEN)
 	unsigned long malloc_base;	/* base address of early malloc() */
 	unsigned long malloc_limit;	/* limit address */
 	unsigned long malloc_ptr;	/* current address */
 #endif
 #ifdef CONFIG_PCI
 	struct pci_controller *hose;	/* PCI hose for early use */
 	phys_addr_t pci_ram_top;	/* top of region accessible to PCI */
 #endif
 #ifdef CONFIG_PCI_BOOTDELAY
 	int pcidelay_done;
 #endif
 	struct udevice *cur_serial_dev;	/* current serial device */
 	struct arch_global_data arch;	/* architecture-specific data */
 #ifdef CONFIG_CONSOLE_RECORD
 	struct membuff console_out;	/* console output */
 	struct membuff console_in;	/* console input */
 #endif
 #ifdef CONFIG_DM_VIDEO
 	ulong video_top;		/* Top of video frame buffer area */
 	ulong video_bottom;		/* Bottom of video frame buffer area */
 #endif
 #ifdef CONFIG_BOOTSTAGE
 	struct bootstage_data *bootstage;	/* Bootstage information */
 	struct bootstage_data *new_bootstage;	/* Relocated bootstage info */
 #endif
 #ifdef CONFIG_LOG
 	int log_drop_count;		/* Number of dropped log messages */
 	int default_log_level;		/* For devices with no filters */
 	struct list_head log_head;	/* List of struct log_device */
 	int log_fmt;			/* Mask containing log format info */
 #endif
 } gd_t;
 #endif
 #ifdef CONFIG_BOARD_TYPES
 #define gd_board_type()		gd->board_type
 #else
 #define gd_board_type()		0
 #endif
 /*
  * Global Data Flags - the top 16 bits are reserved for arch-specific 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_ENV_READY	0x00080	/* Env. imported into hash table   */
 #define GD_FLG_SERIAL_READY	0x00100	/* Pre-reloc serial console ready  */
 #define GD_FLG_FULL_MALLOC_INIT	0x00200	/* Full malloc() is ready	   */
 #define GD_FLG_SPL_INIT		0x00400	/* spl_init() has been called	   */
 #define GD_FLG_SKIP_RELOC	0x00800	/* Don't relocate		   */
 #define GD_FLG_RECORD		0x01000	/* Record console		   */
 #define GD_FLG_ENV_DEFAULT	0x02000 /* Default variable flag	   */
 #define GD_FLG_SPL_EARLY_INIT	0x04000 /* Early SPL init is done	   */
 #define GD_FLG_LOG_READY	0x08000 /* Log system is ready for use	   */
 #endif /* __ASM_GENERIC_GBL_DATA_H */

include/environment.h

Diff comments View file @ e1caa58

 /*
  * (C) Copyright 2002
  * Wolfgang Denk, DENX Software Engineering, wd@denx.de.
  *
  * SPDX-License-Identifier:	GPL-2.0+
  */
 #ifndef _ENVIRONMENT_H_
 #define _ENVIRONMENT_H_
 #include <linux/kconfig.h>
 /**************************************************************************
  *
  * 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 preceded by a 32 bit CRC over the data part.
  *
  *************************************************************************/
 #if defined(CONFIG_ENV_IS_IN_FLASH)
 # ifndef	CONFIG_ENV_ADDR
 #  define	CONFIG_ENV_ADDR	(CONFIG_SYS_FLASH_BASE + CONFIG_ENV_OFFSET)
 # endif
 # ifndef	CONFIG_ENV_OFFSET
 #  define	CONFIG_ENV_OFFSET (CONFIG_ENV_ADDR - CONFIG_SYS_FLASH_BASE)
 # endif
 # if !defined(CONFIG_ENV_ADDR_REDUND) && defined(CONFIG_ENV_OFFSET_REDUND)
 #  define	CONFIG_ENV_ADDR_REDUND	\
 		(CONFIG_SYS_FLASH_BASE + CONFIG_ENV_OFFSET_REDUND)
 # endif
 # if defined(CONFIG_ENV_SECT_SIZE) || defined(CONFIG_ENV_SIZE)
 #  ifndef	CONFIG_ENV_SECT_SIZE
 #   define	CONFIG_ENV_SECT_SIZE	CONFIG_ENV_SIZE
 #  endif
 #  ifndef	CONFIG_ENV_SIZE
 #   define	CONFIG_ENV_SIZE	CONFIG_ENV_SECT_SIZE
 #  endif
 # else
 #  error "Both CONFIG_ENV_SECT_SIZE and CONFIG_ENV_SIZE undefined"
 # endif
 # if defined(CONFIG_ENV_ADDR_REDUND) && !defined(CONFIG_ENV_SIZE_REDUND)
 #  define CONFIG_ENV_SIZE_REDUND	CONFIG_ENV_SIZE
 # endif
 # if	(CONFIG_ENV_ADDR >= CONFIG_SYS_MONITOR_BASE) &&		\
 	(CONFIG_ENV_ADDR + CONFIG_ENV_SIZE) <=			\
 	(CONFIG_SYS_MONITOR_BASE + CONFIG_SYS_MONITOR_LEN)
 #  define ENV_IS_EMBEDDED
 # endif
 # if defined(CONFIG_ENV_ADDR_REDUND) || defined(CONFIG_ENV_OFFSET_REDUND)
 #  define CONFIG_SYS_REDUNDAND_ENVIRONMENT
 # endif
 # ifdef CONFIG_ENV_IS_EMBEDDED
 #  error "do not define CONFIG_ENV_IS_EMBEDDED in your board config"
 #  error "it is calculated automatically for you"
 # endif
 #endif	/* CONFIG_ENV_IS_IN_FLASH */
 #if defined(CONFIG_ENV_IS_IN_MMC)
 # ifdef CONFIG_ENV_OFFSET_REDUND
 #  define CONFIG_SYS_REDUNDAND_ENVIRONMENT
 # endif
 #endif
 #if defined(CONFIG_ENV_IS_IN_NAND)
 # if defined(CONFIG_ENV_OFFSET_OOB)
 #  ifdef CONFIG_ENV_OFFSET_REDUND
 #   error "CONFIG_ENV_OFFSET_REDUND is not supported when CONFIG_ENV_OFFSET_OOB"
 #   error "is set"
 #  endif
 extern unsigned long nand_env_oob_offset;
 #  define CONFIG_ENV_OFFSET nand_env_oob_offset
 # else
 #  ifndef CONFIG_ENV_OFFSET
 #   error "Need to define CONFIG_ENV_OFFSET when using CONFIG_ENV_IS_IN_NAND"
 #  endif
 #  ifdef CONFIG_ENV_OFFSET_REDUND
 #   define CONFIG_SYS_REDUNDAND_ENVIRONMENT
 #  endif
 # endif /* CONFIG_ENV_OFFSET_OOB */
 # ifndef CONFIG_ENV_SIZE
 #  error "Need to define CONFIG_ENV_SIZE when using CONFIG_ENV_IS_IN_NAND"
 # endif
 #endif /* CONFIG_ENV_IS_IN_NAND */
 #if defined(CONFIG_ENV_IS_IN_UBI)
 # ifndef CONFIG_ENV_UBI_PART
 #  error "Need to define CONFIG_ENV_UBI_PART when using CONFIG_ENV_IS_IN_UBI"
 # endif
 # ifndef CONFIG_ENV_UBI_VOLUME
 #  error "Need to define CONFIG_ENV_UBI_VOLUME when using CONFIG_ENV_IS_IN_UBI"
 # endif
 # if defined(CONFIG_ENV_UBI_VOLUME_REDUND)
 #  define CONFIG_SYS_REDUNDAND_ENVIRONMENT
 # endif
 # ifndef CONFIG_ENV_SIZE
 #  error "Need to define CONFIG_ENV_SIZE when using CONFIG_ENV_IS_IN_UBI"
 # endif
 # ifndef CONFIG_CMD_UBI
 #  error "Need to define CONFIG_CMD_UBI when using CONFIG_ENV_IS_IN_UBI"
 # endif
 #endif /* CONFIG_ENV_IS_IN_UBI */
 /* Embedded env is only supported for some flash types */
 #ifdef CONFIG_ENV_IS_EMBEDDED
 # if	!defined(CONFIG_ENV_IS_IN_FLASH)	&& \
 	!defined(CONFIG_ENV_IS_IN_NAND)		&& \
 	!defined(CONFIG_ENV_IS_IN_ONENAND)	&& \
 	!defined(CONFIG_ENV_IS_IN_SPI_FLASH)
 #  error "CONFIG_ENV_IS_EMBEDDED not supported for your flash type"
 # endif
 #endif
 /*
  * For the flash types where embedded env is supported, but it cannot be
  * calculated automatically (i.e. NAND), take the board opt-in.
  */
 #if defined(CONFIG_ENV_IS_EMBEDDED) && !defined(ENV_IS_EMBEDDED)
 # define ENV_IS_EMBEDDED
 #endif
 /* The build system likes to know if the env is embedded */
 #ifdef DO_DEPS_ONLY
 # ifdef ENV_IS_EMBEDDED
 #  ifndef CONFIG_ENV_IS_EMBEDDED
 #   define CONFIG_ENV_IS_EMBEDDED
 #  endif
 # endif
 #endif
 #include "compiler.h"
 #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
 # define ENV_HEADER_SIZE	(sizeof(uint32_t) + 1)
 # define ACTIVE_FLAG   1
 # define OBSOLETE_FLAG 0
 #else
 # define ENV_HEADER_SIZE	(sizeof(uint32_t))
 #endif
 #define ENV_SIZE (CONFIG_ENV_SIZE - ENV_HEADER_SIZE)
 typedef struct environment_s {
 	uint32_t	crc;		/* CRC32 over data bytes	*/
 #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
 	unsigned char	flags;		/* active/obsolete flags	*/
 #endif
 	unsigned char	data[ENV_SIZE]; /* Environment data		*/
 } env_t;
 #ifdef ENV_IS_EMBEDDED
 extern env_t environment;
 #endif /* ENV_IS_EMBEDDED */
 extern const unsigned char default_environment[];
 extern env_t *env_ptr;
 #if defined(CONFIG_NEEDS_MANUAL_RELOC)
 extern void env_reloc(void);
 #endif
 #ifdef CONFIG_ENV_IS_IN_MMC
 #include <mmc.h>
 extern int mmc_get_env_addr(struct mmc *mmc, int copy, u32 *env_addr);
 # ifdef CONFIG_SYS_MMC_ENV_PART
 extern uint mmc_get_env_part(struct mmc *mmc);
 # endif
 #endif
 #ifndef DO_DEPS_ONLY
 #include <env_attr.h>
 #include <env_callback.h>
 #include <env_flags.h>
 #include <search.h>
 /* Value for environment validity */
 enum env_valid {
 	ENV_INVALID,	/* No valid environment */
 	ENV_VALID,	/* First or only environment is valid */
 	ENV_REDUND,	/* Redundant environment is valid */
 };
 enum env_location {
+	ENVL_UNKNOWN,
 	ENVL_EEPROM,
 	ENVL_EXT4,
 	ENVL_FAT,
 	ENVL_FLASH,
 	ENVL_MMC,
 	ENVL_NAND,
 	ENVL_NVRAM,
 	ENVL_ONENAND,
 	ENVL_REMOTE,
 	ENVL_SPI_FLASH,
 	ENVL_UBI,
 	ENVL_NOWHERE,
 	ENVL_COUNT,
-	ENVL_UNKNOWN,
 };
 /* value for the various operations we want to perform on the env */
 enum env_operation {
 	ENVOP_GET_CHAR,	/* we want to call the get_char function */
 	ENVOP_INIT,	/* we want to call the init function */
 	ENVOP_LOAD,	/* we want to call the load function */
 	ENVOP_SAVE,	/* we want to call the save function */
 };
 struct env_driver {
 	const char *name;
 	enum env_location location;
 	/**
 	 * get_char() - Read a character from the environment
 	 *
 	 * This method is optional. If not provided, a default implementation
 	 * will read from gd->env_addr.
 	 *
 	 * @index: Index of character to read (0=first)
 	 * @return character read, or -ve on error
 	 */
 	int (*get_char)(int index);
 	/**
 	 * load() - Load the environment from storage
 	 *
 	 * This method is optional. If not provided, no environment will be
 	 * loaded.
 	 *
 	 * @return 0 if OK, -ve on error
 	 */
 	int (*load)(void);
 	/**
 	 * save() - Save the environment to storage
 	 *
 	 * This method is required for 'saveenv' to work.
 	 *
 	 * @return 0 if OK, -ve on error
 	 */
 	int (*save)(void);
 	/**
 	 * init() - Set up the initial pre-relocation environment
 	 *
 	 * This method is optional.
 	 *
 	 * @return 0 if OK, -ENOENT if no initial environment could be found,
 	 * other -ve on error
 	 */
 	int (*init)(void);
 };
 /* Declare a new environment location driver */
 #define U_BOOT_ENV_LOCATION(__name)					\
 	ll_entry_declare(struct env_driver, __name, env_driver)
 /* Declare the name of a location */
 #ifdef CONFIG_CMD_SAVEENV
 #define ENV_NAME(_name) .name = _name,
 #else
 #define ENV_NAME(_name)
 #endif
 #ifdef CONFIG_CMD_SAVEENV
 #define env_save_ptr(x) x
 #else
 #define env_save_ptr(x) NULL
 #endif
 extern struct hsearch_data env_htab;
 /* Function that updates CRC of the enironment */
 void env_crc_update(void);
 /* Look up the variable from the default environment */
 char *env_get_default(const char *name);
 /* [re]set to the default environment */
 void set_default_env(const char *s);
 /* [re]set individual variables to their value in the default environment */
 int set_default_vars(int nvars, char * const vars[]);
 /* Import from binary representation into hash table */
 int env_import(const char *buf, int check);
 /* Export from hash table into binary representation */
 int env_export(env_t *env_out);
 #ifdef CONFIG_SYS_REDUNDAND_ENVIRONMENT
 /* Select and import one of two redundant environments */
 int env_import_redund(const char *buf1, int buf1_status,
 		      const char *buf2, int buf2_status);
 #endif
 /**
  * env_get_char() - Get a character from the early environment
  *
  * This reads from the pre-relocation environemnt
  *
  * @index: Index of character to read (0 = first)
  * @return character read, or -ve on error
  */
 int env_get_char(int index);
 /**
  * env_load() - Load the environment from storage
  *
  * @return 0 if OK, -ve on error
  */
 int env_load(void);
 /**
  * env_save() - Save the environment to storage
  *
  * @return 0 if OK, -ve on error
  */
 int env_save(void);
 #endif /* DO_DEPS_ONLY */
 #endif /* _ENVIRONMENT_H_ */