[thirdparty/u-boot.git] / env / sf.c

// SPDX-License-Identifier: GPL-2.0+
/*
 * (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>
 *
 * (C) Copyright 2008 Atmel Corporation
 */
#include <common.h>
#include <dm.h>
#include <environment.h>
#include <malloc.h>
#include <spi.h>
#include <spi_flash.h>
#include <search.h>
#include <errno.h>
#include <dm/device-internal.h>

#ifndef CONFIG_ENV_SPI_BUS
# define CONFIG_ENV_SPI_BUS	CONFIG_SF_DEFAULT_BUS
#endif
#ifndef CONFIG_ENV_SPI_CS
# define CONFIG_ENV_SPI_CS	CONFIG_SF_DEFAULT_CS
#endif
#ifndef CONFIG_ENV_SPI_MAX_HZ
# define CONFIG_ENV_SPI_MAX_HZ	CONFIG_SF_DEFAULT_SPEED
#endif
#ifndef CONFIG_ENV_SPI_MODE
# define CONFIG_ENV_SPI_MODE	CONFIG_SF_DEFAULT_MODE
#endif

#ifndef CONFIG_SPL_BUILD
#define CMD_SAVEENV
#define INITENV
#endif

#ifdef CONFIG_ENV_OFFSET_REDUND
#ifdef CMD_SAVEENV
static ulong env_offset		= CONFIG_ENV_OFFSET;
static ulong env_new_offset	= CONFIG_ENV_OFFSET_REDUND;
#endif

#define ACTIVE_FLAG	1
#define OBSOLETE_FLAG	0
#endif /* CONFIG_ENV_OFFSET_REDUND */

DECLARE_GLOBAL_DATA_PTR;

static struct spi_flash *env_flash;

static int setup_flash_device(void)
{
#ifdef CONFIG_DM_SPI_FLASH
	struct udevice *new;
	int	ret;

	/* speed and mode will be read from DT */
	ret = spi_flash_probe_bus_cs(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
				     CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE,
				     &new);
	if (ret) {
		set_default_env("spi_flash_probe_bus_cs() failed", 0);
		return ret;
	}

	env_flash = dev_get_uclass_priv(new);
#else

	if (!env_flash) {
		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) {
			set_default_env("spi_flash_probe() failed", 0);
			return -EIO;
		}
	}
#endif
	return 0;
}

static int is_end(const char *addr, size_t size)
{
	/* The end of env variables is marked by '\0\0' */
	int i = 0;

	for (i = 0; i < size - 1; ++i)
		if (addr[i] == 0x0 && addr[i + 1] == 0x0)
			return 1;
	return 0;
}

static int spi_flash_read_env(struct spi_flash *flash, u32 offset, size_t len,
			      void *buf)
{
	u32 addr = 0;
	u32 page_size = flash->page_size;

	memset(buf, 0x0, len);
	for (int i = 0; i < len / page_size; ++i) {
		int ret = spi_flash_read(flash, offset, page_size,
					 &((char *)buf)[addr]);

		if (ret < 0)
			return ret;

		if (is_end(&((char *)buf)[addr], page_size))
			return 0;

		addr += page_size;
		offset += page_size;
	}
	return 0;
}

#if defined(CONFIG_ENV_OFFSET_REDUND)
#ifdef CMD_SAVEENV
static int env_sf_save(void)
{
	env_t	env_new;
	char	*saved_buffer = NULL, flag = OBSOLETE_FLAG;
	u32	saved_size, saved_offset, sector;
	int	ret;

	ret = setup_flash_device();
	if (ret)
		return ret;

	ret = env_export(&env_new);
	if (ret)
		return -EIO;
	env_new.flags	= ACTIVE_FLAG;

	if (gd->env_valid == ENV_VALID) {
		env_new_offset = CONFIG_ENV_OFFSET_REDUND;
		env_offset = CONFIG_ENV_OFFSET;
	} else {
		env_new_offset = CONFIG_ENV_OFFSET;
		env_offset = CONFIG_ENV_OFFSET_REDUND;
	}

	/* 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;
		saved_offset = env_new_offset + CONFIG_ENV_SIZE;
		saved_buffer = memalign(ARCH_DMA_MINALIGN, saved_size);
		if (!saved_buffer) {
			ret = -ENOMEM;
			goto done;
		}
		ret = spi_flash_read_env(env_flash, saved_offset,
					 saved_size, saved_buffer);
		if (ret)
			goto done;
	}

	sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE);

	puts("Erasing SPI flash...");
	ret = spi_flash_erase(env_flash, env_new_offset,
				sector * CONFIG_ENV_SECT_SIZE);
	if (ret)
		goto done;

	puts("Writing to SPI flash...");

	ret = spi_flash_write(env_flash, env_new_offset,
		CONFIG_ENV_SIZE, &env_new);
	if (ret)
		goto done;

	if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
		ret = spi_flash_write(env_flash, saved_offset,
					saved_size, saved_buffer);
		if (ret)
			goto done;
	}

	ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags),
				sizeof(env_new.flags), &flag);
	if (ret)
		goto done;

	puts("done\n");

	gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;

	printf("Valid environment: %d\n", (int)gd->env_valid);

 done:
	if (saved_buffer)
		free(saved_buffer);

	return ret;
}
#endif /* CMD_SAVEENV */

static int env_sf_load(void)
{
	int ret;
	int read1_fail, read2_fail;
	env_t *tmp_env1, *tmp_env2;

	tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
			CONFIG_ENV_SIZE);
	tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
			CONFIG_ENV_SIZE);
	if (!tmp_env1 || !tmp_env2) {
		set_default_env("malloc() failed", 0);
		ret = -EIO;
		goto out;
	}

	ret = setup_flash_device();
	if (ret)
		goto out;

	read1_fail = spi_flash_read_env(env_flash, CONFIG_ENV_OFFSET,
					CONFIG_ENV_SIZE, tmp_env1);
	read2_fail = spi_flash_read_env(env_flash, CONFIG_ENV_OFFSET_REDUND,
					CONFIG_ENV_SIZE, tmp_env2);

	ret = env_import_redund((char *)tmp_env1, read1_fail, (char *)tmp_env2,
				read2_fail);

	spi_flash_free(env_flash);
	env_flash = NULL;
out:
	free(tmp_env1);
	free(tmp_env2);

	return ret;
}
#else
#ifdef CMD_SAVEENV
static int env_sf_save(void)
{
	u32	saved_size, saved_offset, sector;
	char	*saved_buffer = NULL;
	int	ret = 1;
	env_t	env_new;

	ret = setup_flash_device();
	if (ret)
		return ret;

	/* 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;
		saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
		saved_buffer = malloc(saved_size);
		if (!saved_buffer)
			goto done;

		ret = spi_flash_read_env(env_flash, saved_offset,
					 saved_size, saved_buffer);
		if (ret)
			goto done;
	}

	ret = env_export(&env_new);
	if (ret)
		goto done;

	sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE);

	puts("Erasing SPI flash...");
	ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET,
		sector * CONFIG_ENV_SECT_SIZE);
	if (ret)
		goto done;

	puts("Writing to SPI flash...");
	ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET,
		CONFIG_ENV_SIZE, &env_new);
	if (ret)
		goto done;

	if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
		ret = spi_flash_write(env_flash, saved_offset,
			saved_size, saved_buffer);
		if (ret)
			goto done;
	}

	ret = 0;
	puts("done\n");

 done:
	if (saved_buffer)
		free(saved_buffer);

	return ret;
}
#endif /* CMD_SAVEENV */

static int env_sf_load(void)
{
	int ret;
	char *buf = NULL;

	buf = (char *)memalign(ARCH_DMA_MINALIGN, CONFIG_ENV_SIZE);
	if (!buf) {
		set_default_env("malloc() failed", 0);
		return -EIO;
	}

	ret = setup_flash_device();
	if (ret)
		goto out;

	ret = spi_flash_read_env(env_flash, CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE,
				 buf);
	if (ret) {
		set_default_env("spi_flash_read_env() failed", 0);
		goto err_read;
	}

	ret = env_import(buf, 1);
	if (!ret)
		gd->env_valid = ENV_VALID;

err_read:
	spi_flash_free(env_flash);
	env_flash = NULL;
out:
	free(buf);

	return ret;
}
#endif

#ifdef CONFIG_ENV_ADDR
__weak void *env_sf_get_env_addr(void)
{
	return (void *)CONFIG_ENV_ADDR;
}
#endif

#if defined(INITENV) && defined(CONFIG_ENV_ADDR)
static int env_sf_init(void)
{
	env_t *env_ptr = (env_t *)env_sf_get_env_addr();

	if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
		gd->env_addr	= (ulong)&(env_ptr->data);
		gd->env_valid	= 1;
	} else {
		gd->env_addr = (ulong)&default_environment[0];
		gd->env_valid = 1;
	}

	return 0;
}
#endif

U_BOOT_ENV_LOCATION(sf) = {
	.location	= ENVL_SPI_FLASH,
	ENV_NAME("SPI Flash")
	.load		= env_sf_load,
#ifdef CMD_SAVEENV
	.save		= env_save_ptr(env_sf_save),
#endif
#if defined(INITENV) && defined(CONFIG_ENV_ADDR)
	.init		= env_sf_init,
#endif
};
Commit	Line	Data
83d290c5	1	// SPDX-License-Identifier: GPL-2.0+
8c66497e	2	/*
ea882baf	3	* (C) Copyright 2000-2010
8c66497e HS	4	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
	5	*
	6	* (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
	7	* Andreas Heppel <aheppel@sysgo.de>
	8	*
	9	* (C) Copyright 2008 Atmel Corporation
8c66497e HS	10	*/
8c66497e HS	11	#include <common.h>
9d922450	12	#include <dm.h>
8c66497e	13	#include <environment.h>
5b3375ac	14	#include <malloc.h>
843c9e87	15	#include <spi.h>
8c66497e	16	#include <spi_flash.h>
ea882baf WD	17	#include <search.h>
ea882baf WD	18	#include <errno.h>
19c31285	19	#include <dm/device-internal.h>
8c66497e	20
0e8d1586	21	#ifndef CONFIG_ENV_SPI_BUS
2e4e5ad4	22	# define CONFIG_ENV_SPI_BUS CONFIG_SF_DEFAULT_BUS
8c66497e	23	#endif
0e8d1586	24	#ifndef CONFIG_ENV_SPI_CS
2e4e5ad4	25	# define CONFIG_ENV_SPI_CS CONFIG_SF_DEFAULT_CS
8c66497e	26	#endif
0e8d1586	27	#ifndef CONFIG_ENV_SPI_MAX_HZ
2e4e5ad4	28	# define CONFIG_ENV_SPI_MAX_HZ CONFIG_SF_DEFAULT_SPEED
8c66497e	29	#endif
0e8d1586	30	#ifndef CONFIG_ENV_SPI_MODE
2e4e5ad4	31	# define CONFIG_ENV_SPI_MODE CONFIG_SF_DEFAULT_MODE
8c66497e HS	32	#endif
8c66497e HS	33
4415f1d1 SG	34	#ifndef CONFIG_SPL_BUILD
4415f1d1 SG	35	#define CMD_SAVEENV
b500c92b	36	#define INITENV
4415f1d1 SG	37	#endif
4415f1d1 SG	38
7319bcaf	39	#ifdef CONFIG_ENV_OFFSET_REDUND
4415f1d1	40	#ifdef CMD_SAVEENV
eb58a7fc IG	41	static ulong env_offset = CONFIG_ENV_OFFSET;
eb58a7fc IG	42	static ulong env_new_offset = CONFIG_ENV_OFFSET_REDUND;
4415f1d1	43	#endif
7319bcaf	44
eb58a7fc IG	45	#define ACTIVE_FLAG 1
eb58a7fc IG	46	#define OBSOLETE_FLAG 0
a3110f01	47	#endif /* CONFIG_ENV_OFFSET_REDUND */
7319bcaf	48
8c66497e HS	49	DECLARE_GLOBAL_DATA_PTR;
8c66497e HS	50
8c66497e HS	51	static struct spi_flash *env_flash;
8c66497e HS	52
afa81a77	53	static int setup_flash_device(void)
7319bcaf	54	{
19c31285 GQ	55	#ifdef CONFIG_DM_SPI_FLASH
19c31285 GQ	56	struct udevice *new;
afa81a77	57	int ret;
19c31285	58
96907c0f	59	/* speed and mode will be read from DT */
19c31285	60	ret = spi_flash_probe_bus_cs(CONFIG_ENV_SPI_BUS, CONFIG_ENV_SPI_CS,
25a17652 KP	61	CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE,
25a17652 KP	62	&new);
19c31285	63	if (ret) {
c5d548a9	64	set_default_env("spi_flash_probe_bus_cs() failed", 0);
c5951991	65	return ret;
19c31285 GQ	66	}
	67
	68	env_flash = dev_get_uclass_priv(new);
	69	#else
7319bcaf WW	70
7319bcaf WW	71	if (!env_flash) {
a3110f01 SB	72	env_flash = spi_flash_probe(CONFIG_ENV_SPI_BUS,
	73	CONFIG_ENV_SPI_CS,
	74	CONFIG_ENV_SPI_MAX_HZ, CONFIG_ENV_SPI_MODE);
	75	if (!env_flash) {
c5d548a9	76	set_default_env("spi_flash_probe() failed", 0);
c5951991	77	return -EIO;
a3110f01	78	}
7319bcaf	79	}
19c31285	80	#endif
afa81a77 AF	81	return 0;
	82	}
	83
9a9d66f5 HV	84	static int is_end(const char *addr, size_t size)
	85	{
	86	/* The end of env variables is marked by '\0\0' */
	87	int i = 0;
	88
	89	for (i = 0; i < size - 1; ++i)
	90	if (addr[i] == 0x0 && addr[i + 1] == 0x0)
	91	return 1;
	92	return 0;
	93	}
	94
	95	static int spi_flash_read_env(struct spi_flash *flash, u32 offset, size_t len,
	96	void *buf)
	97	{
	98	u32 addr = 0;
	99	u32 page_size = flash->page_size;
	100
	101	memset(buf, 0x0, len);
	102	for (int i = 0; i < len / page_size; ++i) {
	103	int ret = spi_flash_read(flash, offset, page_size,
	104	&((char *)buf)[addr]);
	105
	106	if (ret < 0)
	107	return ret;
	108
	109	if (is_end(&((char *)buf)[addr], page_size))
	110	return 0;
	111
	112	addr += page_size;
	113	offset += page_size;
	114	}
	115	return 0;
	116	}
	117
afa81a77	118	#if defined(CONFIG_ENV_OFFSET_REDUND)
4415f1d1	119	#ifdef CMD_SAVEENV
e5bce247	120	static int env_sf_save(void)
afa81a77 AF	121	{
	122	env_t env_new;
	123	char *saved_buffer = NULL, flag = OBSOLETE_FLAG;
0b2e5bbe	124	u32 saved_size, saved_offset, sector;
afa81a77 AF	125	int ret;
	126
	127	ret = setup_flash_device();
	128	if (ret)
	129	return ret;
7319bcaf	130
7ce1526e MV	131	ret = env_export(&env_new);
7ce1526e MV	132	if (ret)
c5951991	133	return -EIO;
cd0f4fa1	134	env_new.flags = ACTIVE_FLAG;
ea882baf	135
203e94f6	136	if (gd->env_valid == ENV_VALID) {
a3110f01 SB	137	env_new_offset = CONFIG_ENV_OFFSET_REDUND;
	138	env_offset = CONFIG_ENV_OFFSET;
	139	} else {
	140	env_new_offset = CONFIG_ENV_OFFSET;
	141	env_offset = CONFIG_ENV_OFFSET_REDUND;
	142	}
	143
7319bcaf WW	144	/* Is the sector larger than the env (i.e. embedded) */
	145	if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
	146	saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
	147	saved_offset = env_new_offset + CONFIG_ENV_SIZE;
7dd01744	148	saved_buffer = memalign(ARCH_DMA_MINALIGN, saved_size);
7319bcaf	149	if (!saved_buffer) {
c5951991	150	ret = -ENOMEM;
7319bcaf WW	151	goto done;
7319bcaf WW	152	}
9a9d66f5 HV	153	ret = spi_flash_read_env(env_flash, saved_offset,
9a9d66f5 HV	154	saved_size, saved_buffer);
7319bcaf WW	155	if (ret)
	156	goto done;
	157	}
	158
0b2e5bbe	159	sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE);
7319bcaf WW	160
	161	puts("Erasing SPI flash...");
	162	ret = spi_flash_erase(env_flash, env_new_offset,
	163	sector * CONFIG_ENV_SECT_SIZE);
	164	if (ret)
	165	goto done;
	166
	167	puts("Writing to SPI flash...");
7319bcaf	168
a3110f01	169	ret = spi_flash_write(env_flash, env_new_offset,
cd0f4fa1	170	CONFIG_ENV_SIZE, &env_new);
7319bcaf WW	171	if (ret)
	172	goto done;
	173
	174	if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
	175	ret = spi_flash_write(env_flash, saved_offset,
	176	saved_size, saved_buffer);
	177	if (ret)
	178	goto done;
	179	}
	180
eb58a7fc	181	ret = spi_flash_write(env_flash, env_offset + offsetof(env_t, flags),
cd0f4fa1	182	sizeof(env_new.flags), &flag);
a3110f01 SB	183	if (ret)
a3110f01 SB	184	goto done;
7319bcaf	185
7319bcaf WW	186	puts("done\n");
7319bcaf WW	187
203e94f6	188	gd->env_valid = gd->env_valid == ENV_REDUND ? ENV_VALID : ENV_REDUND;
a3110f01	189
2dc55d9e	190	printf("Valid environment: %d\n", (int)gd->env_valid);
a3110f01	191
7319bcaf WW	192	done:
	193	if (saved_buffer)
	194	free(saved_buffer);
eb58a7fc	195
7319bcaf WW	196	return ret;
7319bcaf WW	197	}
4415f1d1	198	#endif /* CMD_SAVEENV */
7319bcaf	199
c5951991	200	static int env_sf_load(void)
7319bcaf WW	201	{
7319bcaf WW	202	int ret;
80719938 SG	203	int read1_fail, read2_fail;
80719938 SG	204	env_t tmp_env1, tmp_env2;
7319bcaf	205
7dd01744 RB	206	tmp_env1 = (env_t *)memalign(ARCH_DMA_MINALIGN,
	207	CONFIG_ENV_SIZE);
	208	tmp_env2 = (env_t *)memalign(ARCH_DMA_MINALIGN,
	209	CONFIG_ENV_SIZE);
ea882baf	210	if (!tmp_env1 \|\| !tmp_env2) {
c5d548a9	211	set_default_env("malloc() failed", 0);
c5951991	212	ret = -EIO;
2dc55d9e	213	goto out;
7319bcaf WW	214	}
7319bcaf WW	215
8fee8845 AF	216	ret = setup_flash_device();
8fee8845 AF	217	if (ret)
2dc55d9e	218	goto out;
7319bcaf	219
9a9d66f5 HV	220	read1_fail = spi_flash_read_env(env_flash, CONFIG_ENV_OFFSET,
	221	CONFIG_ENV_SIZE, tmp_env1);
	222	read2_fail = spi_flash_read_env(env_flash, CONFIG_ENV_OFFSET_REDUND,
	223	CONFIG_ENV_SIZE, tmp_env2);
ea882baf	224
80719938 SG	225	ret = env_import_redund((char )tmp_env1, read1_fail, (char )tmp_env2,
80719938 SG	226	read2_fail);
7319bcaf	227
7319bcaf WW	228	spi_flash_free(env_flash);
7319bcaf WW	229	env_flash = NULL;
7319bcaf	230	out:
ea882baf WD	231	free(tmp_env1);
ea882baf WD	232	free(tmp_env2);
c5951991 SG	233
c5951991 SG	234	return ret;
7319bcaf WW	235	}
7319bcaf WW	236	#else
4415f1d1	237	#ifdef CMD_SAVEENV
e5bce247	238	static int env_sf_save(void)
8c66497e	239	{
0b2e5bbe	240	u32 saved_size, saved_offset, sector;
7ce1526e	241	char *saved_buffer = NULL;
eb58a7fc	242	int ret = 1;
cd0f4fa1	243	env_t env_new;
19c31285	244
afa81a77 AF	245	ret = setup_flash_device();
	246	if (ret)
	247	return ret;
8c66497e	248
5b3375ac MF	249	/* Is the sector larger than the env (i.e. embedded) */
	250	if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
	251	saved_size = CONFIG_ENV_SECT_SIZE - CONFIG_ENV_SIZE;
	252	saved_offset = CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE;
	253	saved_buffer = malloc(saved_size);
eb58a7fc	254	if (!saved_buffer)
5b3375ac	255	goto done;
eb58a7fc	256
9a9d66f5 HV	257	ret = spi_flash_read_env(env_flash, saved_offset,
9a9d66f5 HV	258	saved_size, saved_buffer);
5b3375ac MF	259	if (ret)
	260	goto done;
	261	}
	262
7ce1526e MV	263	ret = env_export(&env_new);
7ce1526e MV	264	if (ret)
a3110f01	265	goto done;
a3110f01	266
0b2e5bbe AF	267	sector = DIV_ROUND_UP(CONFIG_ENV_SIZE, CONFIG_ENV_SECT_SIZE);
0b2e5bbe AF	268
8c66497e	269	puts("Erasing SPI flash...");
a3110f01 SB	270	ret = spi_flash_erase(env_flash, CONFIG_ENV_OFFSET,
a3110f01 SB	271	sector * CONFIG_ENV_SECT_SIZE);
5b3375ac MF	272	if (ret)
5b3375ac MF	273	goto done;
8c66497e HS	274
8c66497e HS	275	puts("Writing to SPI flash...");
a3110f01	276	ret = spi_flash_write(env_flash, CONFIG_ENV_OFFSET,
cd0f4fa1	277	CONFIG_ENV_SIZE, &env_new);
5b3375ac MF	278	if (ret)
5b3375ac MF	279	goto done;
8c66497e	280
5b3375ac	281	if (CONFIG_ENV_SECT_SIZE > CONFIG_ENV_SIZE) {
a3110f01 SB	282	ret = spi_flash_write(env_flash, saved_offset,
a3110f01 SB	283	saved_size, saved_buffer);
5b3375ac MF	284	if (ret)
	285	goto done;
	286	}
	287
	288	ret = 0;
8c66497e	289	puts("done\n");
5b3375ac MF	290
	291	done:
	292	if (saved_buffer)
	293	free(saved_buffer);
eb58a7fc	294
5b3375ac	295	return ret;
8c66497e	296	}
4415f1d1	297	#endif /* CMD_SAVEENV */
8c66497e	298
c5951991	299	static int env_sf_load(void)
8c66497e HS	300	{
8c66497e HS	301	int ret;
5a89fa92	302	char *buf = NULL;
8c66497e	303
7dd01744	304	buf = (char *)memalign(ARCH_DMA_MINALIGN, CONFIG_ENV_SIZE);
c041c60c	305	if (!buf) {
c5d548a9	306	set_default_env("malloc() failed", 0);
c5951991	307	return -EIO;
ea882baf	308	}
8c66497e	309
c041c60c AF	310	ret = setup_flash_device();
	311	if (ret)
	312	goto out;
	313
9a9d66f5 HV	314	ret = spi_flash_read_env(env_flash, CONFIG_ENV_OFFSET, CONFIG_ENV_SIZE,
9a9d66f5 HV	315	buf);
ea882baf	316	if (ret) {
9a9d66f5	317	set_default_env("spi_flash_read_env() failed", 0);
c041c60c	318	goto err_read;
ea882baf	319	}
8c66497e	320
ea882baf	321	ret = env_import(buf, 1);
42a1820b	322	if (!ret)
203e94f6	323	gd->env_valid = ENV_VALID;
c041c60c AF	324
c041c60c AF	325	err_read:
8c66497e HS	326	spi_flash_free(env_flash);
8c66497e HS	327	env_flash = NULL;
c041c60c AF	328	out:
c041c60c AF	329	free(buf);
c5951991 SG	330
c5951991 SG	331	return ret;
8c66497e	332	}
7319bcaf	333	#endif
8c66497e	334
119c01c2 RB	335	#ifdef CONFIG_ENV_ADDR
	336	__weak void *env_sf_get_env_addr(void)
	337	{
	338	return (void *)CONFIG_ENV_ADDR;
	339	}
	340	#endif
	341
b500c92b AK	342	#if defined(INITENV) && defined(CONFIG_ENV_ADDR)
	343	static int env_sf_init(void)
	344	{
119c01c2	345	env_t env_ptr = (env_t )env_sf_get_env_addr();
b500c92b AK	346
	347	if (crc32(0, env_ptr->data, ENV_SIZE) == env_ptr->crc) {
	348	gd->env_addr = (ulong)&(env_ptr->data);
	349	gd->env_valid = 1;
	350	} else {
	351	gd->env_addr = (ulong)&default_environment[0];
	352	gd->env_valid = 1;
	353	}
	354
	355	return 0;
	356	}
	357	#endif
	358
4415f1d1 SG	359	U_BOOT_ENV_LOCATION(sf) = {
4415f1d1 SG	360	.location = ENVL_SPI_FLASH,
ac358beb	361	ENV_NAME("SPI Flash")
e5bce247	362	.load = env_sf_load,
4415f1d1	363	#ifdef CMD_SAVEENV
e5bce247	364	.save = env_save_ptr(env_sf_save),
4415f1d1	365	#endif
b500c92b AK	366	#if defined(INITENV) && defined(CONFIG_ENV_ADDR)
	367	.init = env_sf_init,
	368	#endif
4415f1d1	369	};