|
@@ -1,529 +0,0 @@
|
|
-/******************************************************************************
|
|
|
|
-*
|
|
|
|
-* 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
|
|
|