[people/ms/u-boot.git] / board / xilinx / xilinx_iic / iic_adapter.c

/******************************************************************************
*
*     Author: Xilinx, Inc.
*
*
*     This program is free software; you can redistribute it and/or modify it
*     under the terms of the GNU General Public License as published by the
*     Free Software Foundation; either version 2 of the License, or (at your
*     option) any later version.
*
*
*     XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS" AS A
*     COURTESY TO YOU. BY PROVIDING THIS DESIGN, CODE, OR INFORMATION AS
*     ONE POSSIBLE IMPLEMENTATION OF THIS FEATURE, APPLICATION OR STANDARD,
*     XILINX IS MAKING NO REPRESENTATION THAT THIS IMPLEMENTATION IS FREE
*     FROM ANY CLAIMS OF INFRINGEMENT, AND YOU ARE RESPONSIBLE FOR OBTAINING
*     ANY THIRD PARTY RIGHTS YOU MAY REQUIRE FOR YOUR IMPLEMENTATION.
*     XILINX EXPRESSLY DISCLAIMS ANY WARRANTY WHATSOEVER WITH RESPECT TO
*     THE ADEQUACY OF THE IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY
*     WARRANTIES OR REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM
*     CLAIMS OF INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND
*     FITNESS FOR A PARTICULAR PURPOSE.
*
*
*     Xilinx hardware products are not intended for use in life support
*     appliances, devices, or systems. Use in such applications is
*     expressly prohibited.
*
*
*     (c) Copyright 2002-2004 Xilinx Inc.
*     All rights reserved.
*
*
*     You should have received a copy of the GNU General Public License along
*     with this program; if not, write to the Free Software Foundation, Inc.,
*     675 Mass Ave, Cambridge, MA 02139, USA.
*
******************************************************************************/

#include <config.h>
#include <common.h>
#include <environment.h>
#include <net.h>

#ifdef CONFIG_ENV_IS_IN_EEPROM
#include <i2c.h>
#include "xiic_l.h"

#define IIC_DELAY     5000

static u8 envStep = 0;		/* 0 means crc has not been read */
const u8 hex[] = "0123456789ABCDEF"; /* lookup table for ML300 CRC */

/************************************************************************
 * Use Xilinx provided driver to send data to EEPROM using iic bus.
 */
static void
send(u32 adr, u8 * data, u32 len)
{
	u8 sendBuf[34];		/* first 2-bit is address and others are data */
	u32 pos, wlen;
	u32 ret;

	wlen = 32;
	for (pos = 0; pos < len; pos += 32) {
		if ((len - pos) < 32)
			wlen = len - pos;

		/* Put address and data bits together */
		sendBuf[0] = (u8) ((adr + pos) >> 8);
		sendBuf[1] = (u8) (adr + pos);
		memcpy(&sendBuf[2], &data[pos], wlen);

		/* Send to EEPROM through iic bus */
		ret = XIic_Send(XPAR_IIC_0_BASEADDR, CONFIG_SYS_I2C_EEPROM_ADDR >> 1,
				sendBuf, wlen + 2);

		udelay(IIC_DELAY);
	}
}

/************************************************************************
 * Use Xilinx provided driver to read data from EEPROM using the iic bus.
 */
static void
receive(u32 adr, u8 * data, u32 len)
{
	u8 address[2];
	u32 ret;

	address[0] = (u8) (adr >> 8);
	address[1] = (u8) adr;

	/* Provide EEPROM address */
	ret =
	    XIic_Send(XPAR_IIC_0_BASEADDR, CONFIG_SYS_I2C_EEPROM_ADDR >> 1, address,
		      2);
	/* Receive data from EEPROM */
	ret =
	    XIic_Recv(XPAR_IIC_0_BASEADDR, CONFIG_SYS_I2C_EEPROM_ADDR >> 1, data, len);
}

/************************************************************************
 * Convert a hexadecimal string to its equivalent integer value.
 */
static u8
axtoi(u8 * hexStg)
{
	u8 n;			/* position in string */
	u8 m;			/* position in digit[] to shift */
	u8 count;		/* loop index */
	u8 intValue;		/* integer value of hex string */
	u8 digit[2];		/* hold values to convert */

	for (n = 0; n < 2; n++) {
		if (hexStg[n] == '\0')
			break;
		if (hexStg[n] > 0x29 && hexStg[n] < 0x40)
			digit[n] = hexStg[n] & 0x0f;
		else if (hexStg[n] >= 'a' && hexStg[n] <= 'f')
			digit[n] = (hexStg[n] & 0x0f) + 9;
		else if (hexStg[n] >= 'A' && hexStg[n] <= 'F')
			digit[n] = (hexStg[n] & 0x0f) + 9;
		else
			break;
	}

	intValue = 0;
	count = n;
	m = n - 1;
	n = 0;
	while (n < count) {
		intValue = intValue | (digit[n] << (m << 2));
		m--;		/* adjust the position to set */
		n++;		/* next digit to process */
	}

	return (intValue);
}

/************************************************************************
 * Convert an integer string to its equivalent value.
 */
static u8
atoi(uchar * string)
{
	u8 res = 0;
	while (*string >= '0' && *string <= '9') {
		res *= 10;
		res += *string - '0';
		string++;
	}

	return res;
}

/************************************************************************
 * Key-value pairs are separated by "=" sign.
 */
static void
findKey(uchar * buffer, int *loc, u8 len)
{
	u32 i;

	for (i = 0; i < len; i++)
		if (buffer[i] == '=') {
			*loc = i;
			return;
		}

	/* return -1 is no "=" sign found */
	*loc = -1;
}

/************************************************************************
 * Compute a new ML300 CRC when user calls the saveenv command.
 * Also update EEPROM with new CRC value.
 */
static u8
update_crc(u32 len, uchar * data)
{
	uchar temp[6] = { 'C', '=', 0x00, 0x00, 0x00, 0x00 };
	u32 crc;		/* new crc value */
	u32 i;

	crc = 0;

	/* calculate new CRC */
	for (i = 0; i < len; i++)
		crc += data[i];

	/* CRC includes key for check sum */
	crc += 'C' + '=';

	/* compose new CRC to be updated */
	temp[2] = hex[(crc >> 4) & 0xf];
	temp[3] = hex[crc & 0xf];

	/* check to see if env size exceeded */
	if (len + 6 > ENV_SIZE) {
		printf("ERROR: not enough space to store CRC on EEPROM");
		return 1;
	}

	memcpy(data + len, temp, 6);
	return 0;
}

/************************************************************************
 * Read out ML300 CRC and compare it with a runtime calculated ML300 CRC.
 * If equal, then pass back a u-boot CRC value, otherwise pass back
 * junk to indicate CRC error.
*/
static void
read_crc(uchar * buffer, int len)
{
	u32 addr, n;
	u32 crc;		/* runtime crc */
	u8 old[2] = { 0xff, 0xff };	/* current CRC in EEPROM */
	u8 stop;		/* indication of end of env data */
	u8 pre;			/* previous EEPROM data bit */
	int i, loc;

	addr = CONFIG_ENV_OFFSET;	/* start from first env address */
	n = 0;
	pre = 1;
	stop = 1;
	crc = 0;

	/* calculate runtime CRC according to ML300 and read back
	   old CRC stored in the EEPROM */
	while (n < CONFIG_ENV_SIZE) {
		receive(addr, buffer, len);

		/* found two null chars, end of env */
		if ((pre || buffer[0]) == 0)
			break;

		findKey(buffer, &loc, len);

		/* found old check sum, read and store old CRC */
		if ((loc == 0 && pre == 'C')
		    || (loc > 0 && buffer[loc - 1] == 'C'))
			receive(addr + loc + 1, old, 2);

		pre = buffer[len - 1];

		/* calculate runtime ML300 CRC */
		crc += buffer[0];
		i = 1;
		do {
			crc += buffer[i];
			stop = buffer[i] || buffer[i - 1];
			i++;
		} while (stop && (i < len));

		if (stop == 0)
			break;

		n += len;
		addr += len;
	}

	/* exclude old CRC from runtime calculation */
	crc -= (old[0] + old[1]);

	/* match CRC values, send back u-boot CRC */
	if ((old[0] == hex[(crc >> 4) & 0xf])
	    && (old[1] == hex[crc & 0xf])) {
		crc = 0;
		n = 0;
		addr =
		    CONFIG_ENV_OFFSET - offsetof(env_t, crc) + offsetof(env_t,
								     data);
		/* calculate u-boot crc */
		while (n < ENV_SIZE) {
			receive(addr, buffer, len);
			crc = crc32(crc, buffer, len);
			n += len;
			addr += len;
		}

		memcpy(buffer, &crc, 4);
	}
}

/************************************************************************
 * Convert IP address to hexadecimals.
 */
static void
ip_ml300(uchar * s, uchar * res)
{
	char temp[2];
	u8 i;

	res[0] = 0x00;

	for (i = 0; i < 4; i++) {
		sprintf(temp, "%02x", atoi(s));
		s = (uchar *)strchr((char *)s, '.') + 1;
		strcat((char *)res, temp);
	}
}

/************************************************************************
 * Change 0xff (255), a dummy null char to 0x00.
 */
static void
change_null(uchar * s)
{
	if (s != NULL) {
		change_null((uchar *)strchr((char *)s + 1, 255));
		*(strchr((char *)s, 255)) = '\0';
	}
}

/************************************************************************
 * Update environment variable name and values to u-boot standard.
 */
void
convert_env(void)
{
	char *s;		/* pointer to env value */
	char temp[20];		/* temp storage for addresses */

	/* E -> ethaddr */
	s = getenv("E");
	if (s != NULL) {
		sprintf(temp, "%c%c.%c%c.%c%c.%c%c.%c%c.%c%c",
			s[0], s[1],  s[ 2], s[ 3],
			s[4], s[5],  s[ 6], s[ 7],
			s[8], s[9],  s[10], s[11] );
		setenv("ethaddr", temp);
		setenv("E", NULL);
	}

	/* L -> serial# */
	s = getenv("L");
	if (s != NULL) {
		setenv("serial#", s);
		setenv("L", NULL);
	}

	/* I -> ipaddr */
	s = getenv("I");
	if (s != NULL) {
		sprintf(temp, "%d.%d.%d.%d", axtoi((u8 *)s), axtoi((u8 *)(s + 2)),
			axtoi((u8 *)(s + 4)), axtoi((u8 *)(s + 6)));
		setenv("ipaddr", temp);
		setenv("I", NULL);
	}

	/* S -> serverip */
	s = getenv("S");
	if (s != NULL) {
		sprintf(temp, "%d.%d.%d.%d", axtoi((u8 *)s), axtoi((u8 *)(s + 2)),
			axtoi((u8 *)(s + 4)), axtoi((u8 *)(s + 6)));
		setenv("serverip", temp);
		setenv("S", NULL);
	}

	/* A -> bootargs */
	s = getenv("A");
	if (s != NULL) {
		setenv("bootargs", s);
		setenv("A", NULL);
	}

	/* F -> bootfile */
	s = getenv("F");
	if (s != NULL) {
		setenv("bootfile", s);
		setenv("F", NULL);
	}

	/* M -> bootcmd */
	s = getenv("M");
	if (s != NULL) {
		setenv("bootcmd", s);
		setenv("M", NULL);
	}

	/* Don't include C (CRC) */
	setenv("C", NULL);
}

/************************************************************************
 * Save user modified environment values back to EEPROM.
 */
static void
save_env(void)
{
	char eprom[ENV_SIZE];	/* buffer to be written back to EEPROM */
	char *s, temp[20];
	char ff[] = { 0xff, 0x00 };	/* dummy null value */
	u32 len;		/* length of env to be written to EEPROM */

	eprom[0] = 0x00;

	/* ethaddr -> E */
	s = getenv("ethaddr");
	if (s != NULL) {
		strcat(eprom, "E=");
		sprintf(temp, "%c%c%c%c%c%c%c%c%c%c%c%c",
			*s, *(s + 1), *(s + 3), *(s + 4), *(s + 6), *(s + 7),
			*(s + 9), *(s + 10), *(s + 12), *(s + 13), *(s + 15),
			*(s + 16));
		strcat(eprom, temp);
		strcat(eprom, ff);
	}

	/* serial# -> L */
	s = getenv("serial#");
	if (s != NULL) {
		strcat(eprom, "L=");
		strcat(eprom, s);
		strcat(eprom, ff);
	}

	/* ipaddr -> I */
	s = getenv("ipaddr");
	if (s != NULL) {
		strcat(eprom, "I=");
		ip_ml300((uchar *)s, (uchar *)temp);
		strcat(eprom, temp);
		strcat(eprom, ff);
	}

	/* serverip -> S */
	s = getenv("serverip");
	if (s != NULL) {
		strcat(eprom, "S=");
		ip_ml300((uchar *)s, (uchar *)temp);
		strcat(eprom, temp);
		strcat(eprom, ff);
	}

	/* bootargs -> A */
	s = getenv("bootargs");
	if (s != NULL) {
		strcat(eprom, "A=");
		strcat(eprom, s);
		strcat(eprom, ff);
	}

	/* bootfile -> F */
	s = getenv("bootfile");
	if (s != NULL) {
		strcat(eprom, "F=");
		strcat(eprom, s);
		strcat(eprom, ff);
	}

	/* bootcmd -> M */
	s = getenv("bootcmd");
	if (s != NULL) {
		strcat(eprom, "M=");
		strcat(eprom, s);
		strcat(eprom, ff);
	}

	len = strlen(eprom);	/* find env length without crc */
	change_null((uchar *)eprom);	/* change 0xff to 0x00 */

	/* update EEPROM env values if there is enough space */
	if (update_crc(len, (uchar *)eprom) == 0)
		send(CONFIG_ENV_OFFSET, (uchar *)eprom, len + 6);
}

/************************************************************************
 * U-boot call for EEPROM read associated activities.
 */
int
i2c_read(uchar chip, uint addr, int alen, uchar * buffer, int len)
{

	if (envStep == 0) {
		/* first read call is for crc */
		read_crc(buffer, len);
		++envStep;
		return 0;
	} else if (envStep == 1) {
		/* then read out EEPROM content for runtime u-boot CRC calculation */
		receive(addr, buffer, len);

		if (addr + len - CONFIG_ENV_OFFSET == CONFIG_ENV_SIZE)
			/* end of runtime crc read */
			++envStep;
		return 0;
	}

	if (len < 2) {
		/* when call getenv_r */
		receive(addr, buffer, len);
	} else if (addr + len < CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE) {
		/* calling env_relocate(), but don't read out
		   crc value from EEPROM */
		receive(addr, buffer + 4, len);
	} else {
		receive(addr, buffer + 4, len - 4);
	}

	return 0;

}

/************************************************************************
 * U-boot call for EEPROM write acativities.
 */
int
i2c_write(uchar chip, uint addr, int alen, uchar * buffer, int len)
{
	/* save env on last page write called by u-boot */
	if (addr + len >= CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE)
		save_env();

	return 0;
}

/************************************************************************
 * Dummy function.
 */
int
i2c_probe(uchar chip)
{
	return 1;
}

#endif
Commit	Line	Data
a06752e3 WD	1	/******************************************************************************
	2	*
	3	* Author: Xilinx, Inc.
	4	*
	5	*
	6	* This program is free software; you can redistribute it and/or modify it
	7	* under the terms of the GNU General Public License as published by the
	8	* Free Software Foundation; either version 2 of the License, or (at your
	9	* option) any later version.
	10	*
	11	*
	12	* XILINX IS PROVIDING THIS DESIGN, CODE, OR INFORMATION "AS IS" AS A
	13	* COURTESY TO YOU. BY PROVIDING THIS DESIGN, CODE, OR INFORMATION AS
	14	* ONE POSSIBLE IMPLEMENTATION OF THIS FEATURE, APPLICATION OR STANDARD,
	15	* XILINX IS MAKING NO REPRESENTATION THAT THIS IMPLEMENTATION IS FREE
	16	* FROM ANY CLAIMS OF INFRINGEMENT, AND YOU ARE RESPONSIBLE FOR OBTAINING
	17	* ANY THIRD PARTY RIGHTS YOU MAY REQUIRE FOR YOUR IMPLEMENTATION.
	18	* XILINX EXPRESSLY DISCLAIMS ANY WARRANTY WHATSOEVER WITH RESPECT TO
	19	* THE ADEQUACY OF THE IMPLEMENTATION, INCLUDING BUT NOT LIMITED TO ANY
	20	* WARRANTIES OR REPRESENTATIONS THAT THIS IMPLEMENTATION IS FREE FROM
	21	* CLAIMS OF INFRINGEMENT, IMPLIED WARRANTIES OF MERCHANTABILITY AND
	22	* FITNESS FOR A PARTICULAR PURPOSE.
	23	*
	24	*
	25	* Xilinx hardware products are not intended for use in life support
	26	* appliances, devices, or systems. Use in such applications is
	27	* expressly prohibited.
	28	*
	29	*
	30	* (c) Copyright 2002-2004 Xilinx Inc.
	31	* All rights reserved.
	32	*
	33	*
	34	* You should have received a copy of the GNU General Public License along
	35	* with this program; if not, write to the Free Software Foundation, Inc.,
	36	* 675 Mass Ave, Cambridge, MA 02139, USA.
	37	*
	38	******************************************************************************/
	39
99b0f0fd	40	#include <config.h>
a06752e3 WD	41	#include <common.h>
	42	#include <environment.h>
	43	#include <net.h>
a06752e3	44
bb1f8b4f	45	#ifdef CONFIG_ENV_IS_IN_EEPROM
a06752e3 WD	46	#include <i2c.h>
	47	#include "xiic_l.h"
	48
	49	#define IIC_DELAY 5000
	50
	51	static u8 envStep = 0; /* 0 means crc has not been read */
	52	const u8 hex[] = "0123456789ABCDEF"; /* lookup table for ML300 CRC */
	53
	54	/************************************************************************
	55	* Use Xilinx provided driver to send data to EEPROM using iic bus.
	56	*/
	57	static void
	58	send(u32 adr, u8 * data, u32 len)
	59	{
	60	u8 sendBuf[34]; /* first 2-bit is address and others are data */
	61	u32 pos, wlen;
	62	u32 ret;
	63
	64	wlen = 32;
	65	for (pos = 0; pos < len; pos += 32) {
	66	if ((len - pos) < 32)
	67	wlen = len - pos;
	68
	69	/* Put address and data bits together */
	70	sendBuf[0] = (u8) ((adr + pos) >> 8);
	71	sendBuf[1] = (u8) (adr + pos);
	72	memcpy(&sendBuf[2], &data[pos], wlen);
	73
	74	/* Send to EEPROM through iic bus */
6d0f6bcf	75	ret = XIic_Send(XPAR_IIC_0_BASEADDR, CONFIG_SYS_I2C_EEPROM_ADDR >> 1,
a06752e3 WD	76	sendBuf, wlen + 2);
	77
	78	udelay(IIC_DELAY);
	79	}
	80	}
	81
	82	/************************************************************************
	83	* Use Xilinx provided driver to read data from EEPROM using the iic bus.
	84	*/
	85	static void
	86	receive(u32 adr, u8 * data, u32 len)
	87	{
	88	u8 address[2];
	89	u32 ret;
	90
	91	address[0] = (u8) (adr >> 8);
	92	address[1] = (u8) adr;
	93
	94	/* Provide EEPROM address */
	95	ret =
6d0f6bcf	96	XIic_Send(XPAR_IIC_0_BASEADDR, CONFIG_SYS_I2C_EEPROM_ADDR >> 1, address,
a06752e3 WD	97	2);
	98	/* Receive data from EEPROM */
	99	ret =
6d0f6bcf	100	XIic_Recv(XPAR_IIC_0_BASEADDR, CONFIG_SYS_I2C_EEPROM_ADDR >> 1, data, len);
a06752e3 WD	101	}
	102
	103	/************************************************************************
	104	* Convert a hexadecimal string to its equivalent integer value.
	105	*/
	106	static u8
	107	axtoi(u8 * hexStg)
	108	{
	109	u8 n; /* position in string */
	110	u8 m; /* position in digit[] to shift */
	111	u8 count; /* loop index */
	112	u8 intValue; /* integer value of hex string */
	113	u8 digit[2]; /* hold values to convert */
	114
	115	for (n = 0; n < 2; n++) {
	116	if (hexStg[n] == '\0')
	117	break;
	118	if (hexStg[n] > 0x29 && hexStg[n] < 0x40)
	119	digit[n] = hexStg[n] & 0x0f;
	120	else if (hexStg[n] >= 'a' && hexStg[n] <= 'f')
	121	digit[n] = (hexStg[n] & 0x0f) + 9;
	122	else if (hexStg[n] >= 'A' && hexStg[n] <= 'F')
	123	digit[n] = (hexStg[n] & 0x0f) + 9;
	124	else
	125	break;
	126	}
	127
	128	intValue = 0;
	129	count = n;
	130	m = n - 1;
	131	n = 0;
	132	while (n < count) {
	133	intValue = intValue \| (digit[n] << (m << 2));
	134	m--; /* adjust the position to set */
	135	n++; /* next digit to process */
	136	}
	137
	138	return (intValue);
	139	}
	140
	141	/************************************************************************
	142	* Convert an integer string to its equivalent value.
	143	*/
	144	static u8
	145	atoi(uchar * string)
	146	{
	147	u8 res = 0;
	148	while (string >= '0' && string <= '9') {
	149	res *= 10;
	150	res += *string - '0';
	151	string++;
	152	}
	153
	154	return res;
	155	}
	156
	157	/************************************************************************
	158	* Key-value pairs are separated by "=" sign.
	159	*/
	160	static void
	161	findKey(uchar * buffer, int *loc, u8 len)
	162	{
	163	u32 i;
	164
165	for (i = 0; i < len; i++)
166	if (buffer[i] == '=') {
167	*loc = i;
168	return;
169	}
170
171	/* return -1 is no "=" sign found */
172	*loc = -1;
173	}
174
175	/************************************************************************
176	* Compute a new ML300 CRC when user calls the saveenv command.
177	* Also update EEPROM with new CRC value.
178	*/
179	static u8
180	update_crc(u32 len, uchar * data)
181	{
182	uchar temp[6] = { 'C', '=', 0x00, 0x00, 0x00, 0x00 };
183	u32 crc; /* new crc value */
184	u32 i;
185
186	crc = 0;
187
188	/* calculate new CRC */
189	for (i = 0; i < len; i++)
190	crc += data[i];
191
192	/* CRC includes key for check sum */
193	crc += 'C' + '=';
194
195	/* compose new CRC to be updated */
196	temp[2] = hex[(crc >> 4) & 0xf];
197	temp[3] = hex[crc & 0xf];
198
199	/* check to see if env size exceeded */
200	if (len + 6 > ENV_SIZE) {
201	printf("ERROR: not enough space to store CRC on EEPROM");
202	return 1;
203	}
204
205	memcpy(data + len, temp, 6);
206	return 0;
207	}
208
209	/************************************************************************
210	* Read out ML300 CRC and compare it with a runtime calculated ML300 CRC.
211	* If equal, then pass back a u-boot CRC value, otherwise pass back
212	* junk to indicate CRC error.
213	*/
214	static void
215	read_crc(uchar * buffer, int len)
216	{
217	u32 addr, n;
218	u32 crc; /* runtime crc */
219	u8 old[2] = { 0xff, 0xff }; /* current CRC in EEPROM */
220	u8 stop; /* indication of end of env data */
221	u8 pre; /* previous EEPROM data bit */
222	int i, loc;
223
0e8d1586	224	addr = CONFIG_ENV_OFFSET; /* start from first env address */
a06752e3 WD	225	n = 0;
	226	pre = 1;
	227	stop = 1;
	228	crc = 0;
	229
	230	/* calculate runtime CRC according to ML300 and read back
	231	old CRC stored in the EEPROM */
0e8d1586	232	while (n < CONFIG_ENV_SIZE) {
a06752e3 WD	233	receive(addr, buffer, len);
	234
	235	/* found two null chars, end of env */
	236	if ((pre \|\| buffer[0]) == 0)
	237	break;
	238
	239	findKey(buffer, &loc, len);
	240
	241	/* found old check sum, read and store old CRC */
	242	if ((loc == 0 && pre == 'C')
	243	\|\| (loc > 0 && buffer[loc - 1] == 'C'))
	244	receive(addr + loc + 1, old, 2);
	245
	246	pre = buffer[len - 1];
	247
	248	/* calculate runtime ML300 CRC */
	249	crc += buffer[0];
	250	i = 1;
	251	do {
	252	crc += buffer[i];
	253	stop = buffer[i] \|\| buffer[i - 1];
	254	i++;
	255	} while (stop && (i < len));
	256
	257	if (stop == 0)
	258	break;
	259
	260	n += len;
	261	addr += len;
	262	}
	263
	264	/* exclude old CRC from runtime calculation */
	265	crc -= (old[0] + old[1]);
	266
	267	/* match CRC values, send back u-boot CRC */
	268	if ((old[0] == hex[(crc >> 4) & 0xf])
	269	&& (old[1] == hex[crc & 0xf])) {
	270	crc = 0;
	271	n = 0;
	272	addr =
0e8d1586	273	CONFIG_ENV_OFFSET - offsetof(env_t, crc) + offsetof(env_t,
a06752e3 WD	274	data);
	275	/* calculate u-boot crc */
	276	while (n < ENV_SIZE) {
	277	receive(addr, buffer, len);
	278	crc = crc32(crc, buffer, len);
	279	n += len;
	280	addr += len;
	281	}
	282
	283	memcpy(buffer, &crc, 4);
	284	}
	285	}
	286
	287	/************************************************************************
	288	* Convert IP address to hexadecimals.
	289	*/
	290	static void
	291	ip_ml300(uchar * s, uchar * res)
	292	{
77ddac94	293	char temp[2];
a06752e3 WD	294	u8 i;
	295
	296	res[0] = 0x00;
	297
	298	for (i = 0; i < 4; i++) {
	299	sprintf(temp, "%02x", atoi(s));
77ddac94 WD	300	s = (uchar )strchr((char )s, '.') + 1;
77ddac94 WD	301	strcat((char *)res, temp);
a06752e3 WD	302	}
	303	}
	304
	305	/************************************************************************
	306	* Change 0xff (255), a dummy null char to 0x00.
	307	*/
	308	static void
	309	change_null(uchar * s)
	310	{
	311	if (s != NULL) {
77ddac94 WD	312	change_null((uchar )strchr((char )s + 1, 255));
77ddac94 WD	313	(strchr((char )s, 255)) = '\0';
a06752e3 WD	314	}
	315	}
	316
	317	/************************************************************************
	318	* Update environment variable name and values to u-boot standard.
	319	*/
	320	void
	321	convert_env(void)
	322	{
77ddac94 WD	323	char s; / pointer to env value */
77ddac94 WD	324	char temp[20]; /* temp storage for addresses */
a06752e3 WD	325
	326	/* E -> ethaddr */
	327	s = getenv("E");
	328	if (s != NULL) {
	329	sprintf(temp, "%c%c.%c%c.%c%c.%c%c.%c%c.%c%c",
e2ffd59b	330	s[0], s[1], s[ 2], s[ 3],
a1191902	331	s[4], s[5], s[ 6], s[ 7],
e2ffd59b	332	s[8], s[9], s[10], s[11] );
a06752e3 WD	333	setenv("ethaddr", temp);
	334	setenv("E", NULL);
	335	}
	336
	337	/* L -> serial# */
	338	s = getenv("L");
	339	if (s != NULL) {
	340	setenv("serial#", s);
	341	setenv("L", NULL);
	342	}
	343
	344	/* I -> ipaddr */
	345	s = getenv("I");
	346	if (s != NULL) {
77ddac94 WD	347	sprintf(temp, "%d.%d.%d.%d", axtoi((u8 )s), axtoi((u8 )(s + 2)),
77ddac94 WD	348	axtoi((u8 )(s + 4)), axtoi((u8 )(s + 6)));
a06752e3 WD	349	setenv("ipaddr", temp);
	350	setenv("I", NULL);
	351	}
	352
	353	/* S -> serverip */
	354	s = getenv("S");
	355	if (s != NULL) {
77ddac94 WD	356	sprintf(temp, "%d.%d.%d.%d", axtoi((u8 )s), axtoi((u8 )(s + 2)),
77ddac94 WD	357	axtoi((u8 )(s + 4)), axtoi((u8 )(s + 6)));
a06752e3 WD	358	setenv("serverip", temp);
	359	setenv("S", NULL);
	360	}
	361
	362	/* A -> bootargs */
	363	s = getenv("A");
	364	if (s != NULL) {
	365	setenv("bootargs", s);
	366	setenv("A", NULL);
	367	}
	368
	369	/* F -> bootfile */
	370	s = getenv("F");
	371	if (s != NULL) {
	372	setenv("bootfile", s);
	373	setenv("F", NULL);
	374	}
	375
	376	/* M -> bootcmd */
	377	s = getenv("M");
	378	if (s != NULL) {
	379	setenv("bootcmd", s);
	380	setenv("M", NULL);
	381	}
	382
	383	/* Don't include C (CRC) */
	384	setenv("C", NULL);
	385	}
	386
	387	/************************************************************************
	388	* Save user modified environment values back to EEPROM.
	389	*/
	390	static void
	391	save_env(void)
	392	{
77ddac94 WD	393	char eprom[ENV_SIZE]; /* buffer to be written back to EEPROM */
	394	char *s, temp[20];
	395	char ff[] = { 0xff, 0x00 }; /* dummy null value */
a06752e3 WD	396	u32 len; /* length of env to be written to EEPROM */
	397
	398	eprom[0] = 0x00;
	399
	400	/* ethaddr -> E */
	401	s = getenv("ethaddr");
	402	if (s != NULL) {
	403	strcat(eprom, "E=");
	404	sprintf(temp, "%c%c%c%c%c%c%c%c%c%c%c%c",
	405	s, (s + 1), (s + 3), (s + 4), (s + 6), (s + 7),
	406	(s + 9), (s + 10), (s + 12), (s + 13), *(s + 15),
	407	*(s + 16));
	408	strcat(eprom, temp);
	409	strcat(eprom, ff);
	410	}
	411
	412	/* serial# -> L */
	413	s = getenv("serial#");
	414	if (s != NULL) {
	415	strcat(eprom, "L=");
	416	strcat(eprom, s);
	417	strcat(eprom, ff);
	418	}
	419
	420	/* ipaddr -> I */
	421	s = getenv("ipaddr");
	422	if (s != NULL) {
	423	strcat(eprom, "I=");
77ddac94	424	ip_ml300((uchar )s, (uchar )temp);
a06752e3 WD	425	strcat(eprom, temp);
	426	strcat(eprom, ff);
	427	}
	428
	429	/* serverip -> S */
	430	s = getenv("serverip");
	431	if (s != NULL) {
	432	strcat(eprom, "S=");
77ddac94	433	ip_ml300((uchar )s, (uchar )temp);
a06752e3 WD	434	strcat(eprom, temp);
	435	strcat(eprom, ff);
	436	}
	437
	438	/* bootargs -> A */
	439	s = getenv("bootargs");
	440	if (s != NULL) {
	441	strcat(eprom, "A=");
	442	strcat(eprom, s);
	443	strcat(eprom, ff);
	444	}
	445
	446	/* bootfile -> F */
	447	s = getenv("bootfile");
	448	if (s != NULL) {
	449	strcat(eprom, "F=");
	450	strcat(eprom, s);
	451	strcat(eprom, ff);
	452	}
	453
	454	/* bootcmd -> M */
	455	s = getenv("bootcmd");
	456	if (s != NULL) {
	457	strcat(eprom, "M=");
	458	strcat(eprom, s);
	459	strcat(eprom, ff);
	460	}
	461
	462	len = strlen(eprom); /* find env length without crc */
77ddac94	463	change_null((uchar )eprom); / change 0xff to 0x00 */
a06752e3 WD	464
a06752e3 WD	465	/* update EEPROM env values if there is enough space */
77ddac94	466	if (update_crc(len, (uchar *)eprom) == 0)
0e8d1586	467	send(CONFIG_ENV_OFFSET, (uchar *)eprom, len + 6);
a06752e3 WD	468	}
	469
	470	/************************************************************************
	471	* U-boot call for EEPROM read associated activities.
	472	*/
	473	int
	474	i2c_read(uchar chip, uint addr, int alen, uchar * buffer, int len)
	475	{
	476
	477	if (envStep == 0) {
	478	/* first read call is for crc */
	479	read_crc(buffer, len);
	480	++envStep;
	481	return 0;
	482	} else if (envStep == 1) {
	483	/* then read out EEPROM content for runtime u-boot CRC calculation */
	484	receive(addr, buffer, len);
	485
0e8d1586	486	if (addr + len - CONFIG_ENV_OFFSET == CONFIG_ENV_SIZE)
a06752e3 WD	487	/* end of runtime crc read */
	488	++envStep;
	489	return 0;
	490	}
	491
	492	if (len < 2) {
	493	/* when call getenv_r */
	494	receive(addr, buffer, len);
0e8d1586	495	} else if (addr + len < CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE) {
a06752e3 WD	496	/* calling env_relocate(), but don't read out
	497	crc value from EEPROM */
	498	receive(addr, buffer + 4, len);
	499	} else {
	500	receive(addr, buffer + 4, len - 4);
	501	}
	502
	503	return 0;
	504
	505	}
	506
	507	/************************************************************************
	508	* U-boot call for EEPROM write acativities.
	509	*/
	510	int
	511	i2c_write(uchar chip, uint addr, int alen, uchar * buffer, int len)
	512	{
	513	/* save env on last page write called by u-boot */
0e8d1586	514	if (addr + len >= CONFIG_ENV_OFFSET + CONFIG_ENV_SIZE)
a06752e3 WD	515	save_env();
	516
	517	return 0;
	518	}
	519
	520	/************************************************************************
	521	* Dummy function.
	522	*/
	523	int
	524	i2c_probe(uchar chip)
	525	{
	526	return 1;
	527	}
	528
	529	#endif