[people/ms/u-boot.git] / common / env_eeprom.c

/*
 * (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>
 *
 * SPDX-License-Identifier:	GPL-2.0+
 */

#include <common.h>
#include <command.h>
#include <environment.h>
#include <linux/stddef.h>
#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;

char *env_name_spec = "EEPROM";

static int eeprom_bus_read(unsigned dev_addr, unsigned offset,
			   uchar *buffer, unsigned cnt)
{
	int rcode;
#if defined(CONFIG_I2C_ENV_EEPROM_BUS)
	int old_bus = i2c_get_bus_num();

	if (old_bus != CONFIG_I2C_ENV_EEPROM_BUS)
		i2c_set_bus_num(CONFIG_I2C_ENV_EEPROM_BUS);
#endif

	rcode = eeprom_read(dev_addr, offset, buffer, cnt);

#if defined(CONFIG_I2C_ENV_EEPROM_BUS)
	i2c_set_bus_num(old_bus);
#endif

	return rcode;
}

static int eeprom_bus_write(unsigned dev_addr, unsigned offset,
			    uchar *buffer, unsigned cnt)
{
	int rcode;
#if defined(CONFIG_I2C_ENV_EEPROM_BUS)
	int old_bus = i2c_get_bus_num();

	if (old_bus != CONFIG_I2C_ENV_EEPROM_BUS)
		i2c_set_bus_num(CONFIG_I2C_ENV_EEPROM_BUS);
#endif

	rcode = eeprom_write(dev_addr, offset, buffer, cnt);

#if defined(CONFIG_I2C_ENV_EEPROM_BUS)
	i2c_set_bus_num(old_bus);
#endif

	return rcode;
}

uchar env_get_char_spec(int index)
{
	uchar c;
	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,
			off + index + offsetof(env_t, data), &c, 1);

	return c;
}

void env_relocate_spec(void)
{
	char buf_env[CONFIG_ENV_SIZE];
	unsigned int off = CONFIG_ENV_OFFSET;

#ifdef CONFIG_ENV_OFFSET_REDUND
	ulong len, crc[2], crc_tmp;
	unsigned int off_env[2];
	uchar rdbuf[64], flags[2];
	int i, crc_ok[2] = {0, 0};

	eeprom_init(-1);	/* 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,
				off_env[i] + offsetof(env_t, crc),
				(uchar *)&crc[i], sizeof(ulong));
		/* read FLAGS */
		eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
				off_env[i] + offsetof(env_t, flags),
				(uchar *)&flags[i], sizeof(uchar));

		crc_tmp = 0;
		len = ENV_SIZE;
		off = off_env[i] + offsetof(env_t, data);
		while (len > 0) {
			int n = (len > sizeof(rdbuf)) ? sizeof(rdbuf) : len;

			eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR, off,
					rdbuf, n);

			crc_tmp = crc32(crc_tmp, rdbuf, n);
			len -= n;
			off += n;
		}

		if (crc_tmp == crc[i])
			crc_ok[i] = 1;
	}

	if (!crc_ok[0] && !crc_ok[1]) {
		gd->env_addr	= 0;
		gd->env_valid	= 0;
	} else if (crc_ok[0] && !crc_ok[1]) {
		gd->env_valid = 1;
	} else if (!crc_ok[0] && crc_ok[1]) {
		gd->env_valid = 2;
	} else {
		/* both ok - check serial */
		if (flags[0] == ACTIVE_FLAG && flags[1] == OBSOLETE_FLAG)
			gd->env_valid = 1;
		else if (flags[0] == OBSOLETE_FLAG && flags[1] == ACTIVE_FLAG)
			gd->env_valid = 2;
		else if (flags[0] == 0xFF && flags[1] == 0)
			gd->env_valid = 2;
		else if (flags[1] == 0xFF && flags[0] == 0)
			gd->env_valid = 1;
		else /* flags are equal - almost impossible */
			gd->env_valid = 1;
	}

	if (gd->env_valid == 2)
		gd->env_addr = off_env[1] + offsetof(env_t, data);
	else if (gd->env_valid == 1)
		gd->env_addr = off_env[0] + offsetof(env_t, data);

#else /* CONFIG_ENV_OFFSET_REDUND */
	ulong crc, len, new;
	uchar rdbuf[64];

	eeprom_init(-1);	/* prepare for EEPROM read/write */

	/* read old CRC */
	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(rdbuf)) ? sizeof(rdbuf) : len;

		eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
				CONFIG_ENV_OFFSET + off, rdbuf, n);
		new = crc32(new, rdbuf, n);
		len -= n;
		off += n;
	}

	if (crc == new) {
		gd->env_addr	= offsetof(env_t, data);
		gd->env_valid	= 1;
	} else {
		gd->env_addr	= 0;
		gd->env_valid	= 0;
	}
#endif /* CONFIG_ENV_OFFSET_REDUND */

	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,
		off, (uchar *)buf_env, CONFIG_ENV_SIZE);

	env_import(buf_env, 1);
}

int saveenv(void)
{
	env_t	env_new;
	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);

	rc = env_export(&env_new);
	if (rc)
		return rc;

#ifdef CONFIG_ENV_OFFSET_REDUND
	if (gd->env_valid == 1) {
		off	= CONFIG_ENV_OFFSET_REDUND;
		off_red	= CONFIG_ENV_OFFSET;
	}

	env_new.flags = ACTIVE_FLAG;
#endif

	rc = eeprom_bus_write(CONFIG_SYS_DEF_EEPROM_ADDR,
			      off, (uchar *)&env_new, CONFIG_ENV_SIZE);

#ifdef CONFIG_ENV_OFFSET_REDUND
	if (rc == 0) {
		eeprom_bus_write(CONFIG_SYS_DEF_EEPROM_ADDR,
				 off_red + offsetof(env_t, flags),
				 (uchar *)&flag_obsolete, 1);

		if (gd->env_valid == 1)
			gd->env_valid = 2;
		else
			gd->env_valid = 1;
	}
#endif
	return rc;
}

/*
 * Initialize Environment use
 *
 * We are still running from ROM, so data use is limited.
 * Use a (moderately small) buffer on the stack
 */
int env_init(void)
{
	gd->env_addr = (ulong)&default_environment[0];
	gd->env_valid = 1;
	return 0;
}
Commit	Line	Data
0bc4a1ac	1	/*
ea882baf	2	* (C) Copyright 2000-2010
0bc4a1ac WD	3	* Wolfgang Denk, DENX Software Engineering, wd@denx.de.
	4	*
	5	* (C) Copyright 2001 Sysgo Real-Time Solutions, GmbH <www.elinos.com>
	6	* Andreas Heppel <aheppel@sysgo.de>
ea882baf	7	*
3765b3e7	8	* SPDX-License-Identifier: GPL-2.0+
0bc4a1ac WD	9	*/
	10
	11	#include <common.h>
0bc4a1ac WD	12	#include <command.h>
0bc4a1ac WD	13	#include <environment.h>
0bc4a1ac	14	#include <linux/stddef.h>
548738b4 HS	15	#if defined(CONFIG_I2C_ENV_EEPROM_BUS)
	16	#include <i2c.h>
	17	#endif
ea882baf WD	18	#include <search.h>
	19	#include <errno.h>
	20	#include <linux/compiler.h> /* for BUG_ON */
0bc4a1ac	21
d87080b7 WD	22	DECLARE_GLOBAL_DATA_PTR;
d87080b7 WD	23
dd2a233c	24	env_t *env_ptr;
0bc4a1ac	25
ea882baf	26	char *env_name_spec = "EEPROM";
548738b4	27
ea882baf	28	static int eeprom_bus_read(unsigned dev_addr, unsigned offset,
dd2a233c	29	uchar *buffer, unsigned cnt)
548738b4 HS	30	{
	31	int rcode;
	32	#if defined(CONFIG_I2C_ENV_EEPROM_BUS)
	33	int old_bus = i2c_get_bus_num();
	34
3f4978c7 HS	35	if (old_bus != CONFIG_I2C_ENV_EEPROM_BUS)
3f4978c7 HS	36	i2c_set_bus_num(CONFIG_I2C_ENV_EEPROM_BUS);
548738b4 HS	37	#endif
548738b4 HS	38
dd2a233c	39	rcode = eeprom_read(dev_addr, offset, buffer, cnt);
ea882baf	40
548738b4	41	#if defined(CONFIG_I2C_ENV_EEPROM_BUS)
6d001e7d	42	i2c_set_bus_num(old_bus);
548738b4	43	#endif
9a2accb4	44
548738b4 HS	45	return rcode;
	46	}
	47
ea882baf	48	static int eeprom_bus_write(unsigned dev_addr, unsigned offset,
dd2a233c	49	uchar *buffer, unsigned cnt)
548738b4 HS	50	{
	51	int rcode;
	52	#if defined(CONFIG_I2C_ENV_EEPROM_BUS)
	53	int old_bus = i2c_get_bus_num();
	54
3f4978c7 HS	55	if (old_bus != CONFIG_I2C_ENV_EEPROM_BUS)
3f4978c7 HS	56	i2c_set_bus_num(CONFIG_I2C_ENV_EEPROM_BUS);
548738b4	57	#endif
9a2accb4	58
ea882baf	59	rcode = eeprom_write(dev_addr, offset, buffer, cnt);
9a2accb4	60
548738b4 HS	61	#if defined(CONFIG_I2C_ENV_EEPROM_BUS)
	62	i2c_set_bus_num(old_bus);
	63	#endif
6d001e7d	64
548738b4 HS	65	return rcode;
548738b4 HS	66	}
0bc4a1ac	67
dd2a233c	68	uchar env_get_char_spec(int index)
0bc4a1ac WD	69	{
0bc4a1ac WD	70	uchar c;
dd2a233c	71	unsigned int off = CONFIG_ENV_OFFSET;
ea882baf	72
1567b596 HS	73	#ifdef CONFIG_ENV_OFFSET_REDUND
	74	if (gd->env_valid == 2)
	75	off = CONFIG_ENV_OFFSET_REDUND;
	76	#endif
ea882baf	77	eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
dd2a233c	78	off + index + offsetof(env_t, data), &c, 1);
0bc4a1ac	79
dd2a233c	80	return c;
0bc4a1ac WD	81	}
0bc4a1ac WD	82
dd2a233c	83	void env_relocate_spec(void)
0bc4a1ac	84	{
e3cc5bc5	85	char buf_env[CONFIG_ENV_SIZE];
1567b596	86	unsigned int off = CONFIG_ENV_OFFSET;
ea882baf	87
1567b596	88	#ifdef CONFIG_ENV_OFFSET_REDUND
dd2a233c	89	ulong len, crc[2], crc_tmp;
e3cc5bc5 LD	90	unsigned int off_env[2];
e3cc5bc5 LD	91	uchar rdbuf[64], flags[2];
dd2a233c	92	int i, crc_ok[2] = {0, 0};
1567b596	93
354e3ed7	94	eeprom_init(-1); /* prepare for EEPROM read/write */
1567b596 HS	95
	96	off_env[0] = CONFIG_ENV_OFFSET;
	97	off_env[1] = CONFIG_ENV_OFFSET_REDUND;
	98
	99	for (i = 0; i < 2; i++) {
	100	/* read CRC */
ea882baf	101	eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
dd2a233c IG	102	off_env[i] + offsetof(env_t, crc),
dd2a233c IG	103	(uchar *)&crc[i], sizeof(ulong));
1567b596	104	/* read FLAGS */
ea882baf	105	eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
dd2a233c IG	106	off_env[i] + offsetof(env_t, flags),
dd2a233c IG	107	(uchar *)&flags[i], sizeof(uchar));
1567b596	108
ea882baf	109	crc_tmp = 0;
1567b596	110	len = ENV_SIZE;
dd2a233c	111	off = off_env[i] + offsetof(env_t, data);
1567b596	112	while (len > 0) {
e3cc5bc5	113	int n = (len > sizeof(rdbuf)) ? sizeof(rdbuf) : len;
1567b596	114
ea882baf	115	eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR, off,
e3cc5bc5	116	rdbuf, n);
1567b596	117
e3cc5bc5	118	crc_tmp = crc32(crc_tmp, rdbuf, n);
1567b596 HS	119	len -= n;
	120	off += n;
	121	}
dd2a233c	122
1567b596 HS	123	if (crc_tmp == crc[i])
	124	crc_ok[i] = 1;
	125	}
	126
	127	if (!crc_ok[0] && !crc_ok[1]) {
dd2a233c IG	128	gd->env_addr = 0;
dd2a233c IG	129	gd->env_valid = 0;
1567b596 HS	130	} else if (crc_ok[0] && !crc_ok[1]) {
1567b596 HS	131	gd->env_valid = 1;
dd2a233c	132	} else if (!crc_ok[0] && crc_ok[1]) {
1567b596 HS	133	gd->env_valid = 2;
	134	} else {
	135	/* both ok - check serial */
	136	if (flags[0] == ACTIVE_FLAG && flags[1] == OBSOLETE_FLAG)
	137	gd->env_valid = 1;
	138	else if (flags[0] == OBSOLETE_FLAG && flags[1] == ACTIVE_FLAG)
	139	gd->env_valid = 2;
	140	else if (flags[0] == 0xFF && flags[1] == 0)
	141	gd->env_valid = 2;
dd2a233c	142	else if (flags[1] == 0xFF && flags[0] == 0)
1567b596 HS	143	gd->env_valid = 1;
	144	else /* flags are equal - almost impossible */
	145	gd->env_valid = 1;
	146	}
	147
	148	if (gd->env_valid == 2)
dd2a233c	149	gd->env_addr = off_env[1] + offsetof(env_t, data);
1567b596	150	else if (gd->env_valid == 1)
dd2a233c	151	gd->env_addr = off_env[0] + offsetof(env_t, data);
e3cc5bc5 LD	152
e3cc5bc5 LD	153	#else /* CONFIG_ENV_OFFSET_REDUND */
0bc4a1ac	154	ulong crc, len, new;
e3cc5bc5	155	uchar rdbuf[64];
0bc4a1ac	156
354e3ed7	157	eeprom_init(-1); /* prepare for EEPROM read/write */
0bc4a1ac WD	158
0bc4a1ac WD	159	/* read old CRC */
ea882baf	160	eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
dd2a233c IG	161	CONFIG_ENV_OFFSET + offsetof(env_t, crc),
dd2a233c IG	162	(uchar *)&crc, sizeof(ulong));
0bc4a1ac WD	163
	164	new = 0;
	165	len = ENV_SIZE;
dd2a233c	166	off = offsetof(env_t, data);
0bc4a1ac	167	while (len > 0) {
e3cc5bc5	168	int n = (len > sizeof(rdbuf)) ? sizeof(rdbuf) : len;
0bc4a1ac	169
ea882baf	170	eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
e3cc5bc5 LD	171	CONFIG_ENV_OFFSET + off, rdbuf, n);
e3cc5bc5 LD	172	new = crc32(new, rdbuf, n);
0bc4a1ac WD	173	len -= n;
	174	off += n;
	175	}
	176
	177	if (crc == new) {
dd2a233c IG	178	gd->env_addr = offsetof(env_t, data);
dd2a233c IG	179	gd->env_valid = 1;
0bc4a1ac	180	} else {
dd2a233c IG	181	gd->env_addr = 0;
dd2a233c IG	182	gd->env_valid = 0;
0bc4a1ac	183	}
e3cc5bc5 LD	184	#endif /* CONFIG_ENV_OFFSET_REDUND */
	185
	186	off = CONFIG_ENV_OFFSET;
	187	#ifdef CONFIG_ENV_OFFSET_REDUND
	188	if (gd->env_valid == 2)
	189	off = CONFIG_ENV_OFFSET_REDUND;
	190	#endif
	191
	192	eeprom_bus_read(CONFIG_SYS_DEF_EEPROM_ADDR,
	193	off, (uchar *)buf_env, CONFIG_ENV_SIZE);
	194
	195	env_import(buf_env, 1);
	196	}
	197
	198	int saveenv(void)
	199	{
	200	env_t env_new;
	201	int rc;
	202	unsigned int off = CONFIG_ENV_OFFSET;
	203	#ifdef CONFIG_ENV_OFFSET_REDUND
	204	unsigned int off_red = CONFIG_ENV_OFFSET_REDUND;
	205	char flag_obsolete = OBSOLETE_FLAG;
	206	#endif
	207
	208	BUG_ON(env_ptr != NULL);
	209
	210	rc = env_export(&env_new);
	211	if (rc)
	212	return rc;
	213
	214	#ifdef CONFIG_ENV_OFFSET_REDUND
	215	if (gd->env_valid == 1) {
	216	off = CONFIG_ENV_OFFSET_REDUND;
	217	off_red = CONFIG_ENV_OFFSET;
	218	}
	219
	220	env_new.flags = ACTIVE_FLAG;
	221	#endif
	222
	223	rc = eeprom_bus_write(CONFIG_SYS_DEF_EEPROM_ADDR,
	224	off, (uchar *)&env_new, CONFIG_ENV_SIZE);
	225
	226	#ifdef CONFIG_ENV_OFFSET_REDUND
	227	if (rc == 0) {
	228	eeprom_bus_write(CONFIG_SYS_DEF_EEPROM_ADDR,
	229	off_red + offsetof(env_t, flags),
	230	(uchar *)&flag_obsolete, 1);
	231
	232	if (gd->env_valid == 1)
	233	gd->env_valid = 2;
	234	else
	235	gd->env_valid = 1;
	236	}
	237	#endif
	238	return rc;
	239	}
	240
	241	/*
	242	* Initialize Environment use
	243	*
	244	* We are still running from ROM, so data use is limited.
	245	* Use a (moderately small) buffer on the stack
	246	*/
	247	int env_init(void)
248	{
ed6a5d4f SDPP	249	gd->env_addr = (ulong)&default_environment[0];
ed6a5d4f SDPP	250	gd->env_valid = 1;
dd2a233c	251	return 0;
0bc4a1ac	252	}