avionic design with actual uboot and tooling

submodule of avionic design uboot bootloader and with included tools to
get you started , read readme.md and readme-tk1-loader.md

u-boot/board/keymile/common/common.c

@@ -0,0 +1,377 @@
+/*
+ * (C) Copyright 2008
+ * Heiko Schocher, DENX Software Engineering, hs@denx.de.
+ *
+ * (C) Copyright 2011
+ * Holger Brunck, Keymile GmbH Hannover, holger.brunck@keymile.com
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#include <common.h>
+#include <ioports.h>
+#include <command.h>
+#include <malloc.h>
+#include <cli_hush.h>
+#include <net.h>
+#include <netdev.h>
+#include <asm/io.h>
+#include <linux/ctype.h>
+
+#if defined(CONFIG_POST)
+#include "post.h"
+#endif
+#include "common.h"
+#include <i2c.h>
+
+DECLARE_GLOBAL_DATA_PTR;
+
+/*
+ * Set Keymile specific environment variables
+ * Currently only some memory layout variables are calculated here
+ * ... ------------------------------------------------
+ * ... |@rootfsaddr |@pnvramaddr |@varaddr |@reserved |@END_OF_RAM
+ * ... |<------------------- pram ------------------->|
+ * ... ------------------------------------------------
+ * @END_OF_RAM: denotes the RAM size
+ * @pnvramaddr: Startadress of pseudo non volatile RAM in hex
+ * @pram      : preserved ram size in k
+ * @varaddr   : startadress for /var mounted into RAM
+ */
+int set_km_env(void)
+{
+	uchar buf[32];
+	unsigned int pnvramaddr;
+	unsigned int pram;
+	unsigned int varaddr;
+	unsigned int kernelmem;
+	char *p;
+	unsigned long rootfssize = 0;
+
+	pnvramaddr = gd->ram_size - CONFIG_KM_RESERVED_PRAM - CONFIG_KM_PHRAM
+			- CONFIG_KM_PNVRAM;
+	sprintf((char *)buf, "0x%x", pnvramaddr);
+	setenv("pnvramaddr", (char *)buf);
+
+	/* try to read rootfssize (ram image) from envrionment */
+	p = getenv("rootfssize");
+	if (p != NULL)
+		strict_strtoul(p, 16, &rootfssize);
+	pram = (rootfssize + CONFIG_KM_RESERVED_PRAM + CONFIG_KM_PHRAM +
+		CONFIG_KM_PNVRAM) / 0x400;
+	sprintf((char *)buf, "0x%x", pram);
+	setenv("pram", (char *)buf);
+
+	varaddr = gd->ram_size - CONFIG_KM_RESERVED_PRAM - CONFIG_KM_PHRAM;
+	sprintf((char *)buf, "0x%x", varaddr);
+	setenv("varaddr", (char *)buf);
+
+	kernelmem = gd->ram_size - 0x400 * pram;
+	sprintf((char *)buf, "0x%x", kernelmem);
+	setenv("kernelmem", (char *)buf);
+
+	return 0;
+}
+
+#if defined(CONFIG_SYS_I2C_INIT_BOARD)
+static void i2c_write_start_seq(void)
+{
+	set_sda(1);
+	udelay(DELAY_HALF_PERIOD);
+	set_scl(1);
+	udelay(DELAY_HALF_PERIOD);
+	set_sda(0);
+	udelay(DELAY_HALF_PERIOD);
+	set_scl(0);
+	udelay(DELAY_HALF_PERIOD);
+}
+
+/*
+ * I2C is a synchronous protocol and resets of the processor in the middle
+ * of an access can block the I2C Bus until a powerdown of the full unit is
+ * done. This function toggles the SCL until the SCL and SCA line are
+ * released, but max. 16 times, after this a I2C start-sequence is sent.
+ * This I2C Deblocking mechanism was developed by Keymile in association
+ * with Anatech and Atmel in 1998.
+ */
+int i2c_make_abort(void)
+{
+	int	scl_state = 0;
+	int	sda_state = 0;
+	int	i = 0;
+	int	ret = 0;
+
+	if (!get_sda()) {
+		ret = -1;
+		while (i < 16) {
+			i++;
+			set_scl(0);
+			udelay(DELAY_ABORT_SEQ);
+			set_scl(1);
+			udelay(DELAY_ABORT_SEQ);
+			scl_state = get_scl();
+			sda_state = get_sda();
+			if (scl_state && sda_state) {
+				ret = 0;
+				break;
+			}
+		}
+	}
+	if (ret == 0)
+		for (i = 0; i < 5; i++)
+			i2c_write_start_seq();
+
+	/* respect stop setup time */
+	udelay(DELAY_ABORT_SEQ);
+	set_scl(1);
+	udelay(DELAY_ABORT_SEQ);
+	set_sda(1);
+	get_sda();
+
+	return ret;
+}
+
+/**
+ * i2c_init_board - reset i2c bus. When the board is powercycled during a
+ * bus transfer it might hang; for details see doc/I2C_Edge_Conditions.
+ */
+void i2c_init_board(void)
+{
+	/* Now run the AbortSequence() */
+	i2c_make_abort();
+}
+#endif
+
+#if defined(CONFIG_KM_COMMON_ETH_INIT)
+int board_eth_init(bd_t *bis)
+{
+	if (ethernet_present())
+		return cpu_eth_init(bis);
+
+	return -1;
+}
+#endif
+
+/*
+ * do_setboardid command
+ * read out the board id and the hw key from the intventory EEPROM and set
+ * this values as environment variables.
+ */
+static int do_setboardid(cmd_tbl_t *cmdtp, int flag, int argc,
+				char *const argv[])
+{
+	unsigned char buf[32];
+	char *p;
+
+	p = get_local_var("IVM_BoardId");
+	if (p == NULL) {
+		printf("can't get the IVM_Boardid\n");
+		return 1;
+	}
+	strcpy((char *)buf, p);
+	setenv("boardid", (char *)buf);
+	printf("set boardid=%s\n", buf);
+
+	p = get_local_var("IVM_HWKey");
+	if (p == NULL) {
+		printf("can't get the IVM_HWKey\n");
+		return 1;
+	}
+	strcpy((char *)buf, p);
+	setenv("hwkey", (char *)buf);
+	printf("set hwkey=%s\n", buf);
+	printf("Execute manually saveenv for persistent storage.\n");
+
+	return 0;
+}
+
+U_BOOT_CMD(km_setboardid, 1, 0, do_setboardid, "setboardid", "read out bid and "
+				 "hwkey from IVM and set in environment");
+
+/*
+ * command km_checkbidhwk
+ *	if "boardid" and "hwkey" are not already set in the environment, do:
+ *		if a "boardIdListHex" exists in the environment:
+ *			- read ivm data for boardid and hwkey
+ *			- compare each entry of the boardIdListHex with the
+ *				IVM data:
+ *			if match:
+ *				set environment variables boardid, boardId,
+ *				hwkey, hwKey to	the found values
+ *				both (boardid and boardId) are set because
+ *				they might be used differently in the
+ *				application and in the init scripts (?)
+ *	return 0 in case of match, 1 if not match or error
+ */
+static int do_checkboardidhwk(cmd_tbl_t *cmdtp, int flag, int argc,
+			char *const argv[])
+{
+	unsigned long ivmbid = 0, ivmhwkey = 0;
+	unsigned long envbid = 0, envhwkey = 0;
+	char *p;
+	int verbose = argc > 1 && *argv[1] == 'v';
+	int rc = 0;
+
+	/*
+	 * first read out the real inventory values, these values are
+	 * already stored in the local hush variables
+	 */
+	p = get_local_var("IVM_BoardId");
+	if (p == NULL) {
+		printf("can't get the IVM_Boardid\n");
+		return 1;
+	}
+	rc = strict_strtoul(p, 16, &ivmbid);
+
+	p = get_local_var("IVM_HWKey");
+	if (p == NULL) {
+		printf("can't get the IVM_HWKey\n");
+		return 1;
+	}
+	rc = strict_strtoul(p, 16, &ivmhwkey);
+
+	if (!ivmbid || !ivmhwkey) {
+		printf("Error: IVM_BoardId and/or IVM_HWKey not set!\n");
+		return rc;
+	}
+
+	/* now try to read values from environment if available */
+	p = getenv("boardid");
+	if (p != NULL)
+		rc = strict_strtoul(p, 16, &envbid);
+	p = getenv("hwkey");
+	if (p != NULL)
+		rc = strict_strtoul(p, 16, &envhwkey);
+
+	if (rc != 0) {
+		printf("strict_strtoul returns error: %d", rc);
+		return rc;
+	}
+
+	if (!envbid || !envhwkey) {
+		/*
+		 * BoardId/HWkey not available in the environment, so try the
+		 * environment variable for BoardId/HWkey list
+		 */
+		char *bidhwklist = getenv("boardIdListHex");
+
+		if (bidhwklist) {
+			int found = 0;
+			char *rest = bidhwklist;
+			char *endp;
+
+			if (verbose) {
+				printf("IVM_BoardId: %ld, IVM_HWKey=%ld\n",
+					ivmbid, ivmhwkey);
+				printf("boardIdHwKeyList: %s\n",
+					bidhwklist);
+			}
+			while (!found) {
+				/* loop over each bid/hwkey pair in the list */
+				unsigned long bid   = 0;
+				unsigned long hwkey = 0;
+
+				while (*rest && !isxdigit(*rest))
+					rest++;
+				/*
+				 * use simple_strtoul because we need &end and
+				 * we know we got non numeric char at the end
+				 */
+				bid = simple_strtoul(rest, &endp, 16);
+				/* BoardId and HWkey are separated with a "_" */
+				if (*endp == '_') {
+					rest  = endp + 1;
+					/*
+					 * use simple_strtoul because we need
+					 * &end
+					 */
+					hwkey = simple_strtoul(rest, &endp, 16);
+					rest  = endp;
+					while (*rest && !isxdigit(*rest))
+						rest++;
+				}
+				if ((!bid) || (!hwkey)) {
+					/* end of list */
+					break;
+				}
+				if (verbose) {
+					printf("trying bid=0x%lX, hwkey=%ld\n",
+						bid, hwkey);
+				}
+				/*
+				 * Compare the values of the found entry in the
+				 * list with the valid values which are stored
+				 * in the inventory eeprom. If they are equal
+				 * set the values in environment variables.
+				 */
+				if ((bid == ivmbid) && (hwkey == ivmhwkey)) {
+					char buf[10];
+
+					found = 1;
+					envbid   = bid;
+					envhwkey = hwkey;
+					sprintf(buf, "%lx", bid);
+					setenv("boardid", buf);
+					sprintf(buf, "%lx", hwkey);
+					setenv("hwkey", buf);
+				}
+			} /* end while( ! found ) */
+		}
+	}
+
+	/* compare now the values */
+	if ((ivmbid == envbid) && (ivmhwkey == envhwkey)) {
+		printf("boardid=0x%3lX, hwkey=%ld\n", envbid, envhwkey);
+		rc = 0; /* match */
+	} else {
+		printf("Error: env boardid=0x%3lX, hwkey=%ld\n", envbid,
+			envhwkey);
+		printf("       IVM bId=0x%3lX, hwKey=%ld\n", ivmbid, ivmhwkey);
+		rc = 1; /* don't match */
+	}
+	return rc;
+}
+
+U_BOOT_CMD(km_checkbidhwk, 2, 0, do_checkboardidhwk,
+		"check boardid and hwkey",
+		"[v]\n  - check environment parameter "\
+		"\"boardIdListHex\" against stored boardid and hwkey "\
+		"from the IVM\n    v: verbose output"
+);
+
+/*
+ * command km_checktestboot
+ *  if the testpin of the board is asserted, return 1
+ *  *	else return 0
+ */
+static int do_checktestboot(cmd_tbl_t *cmdtp, int flag, int argc,
+			char *const argv[])
+{
+	int testpin = 0;
+	char *s = NULL;
+	int testboot = 0;
+	int verbose = argc > 1 && *argv[1] == 'v';
+
+#if defined(CONFIG_POST)
+	testpin = post_hotkeys_pressed();
+#endif
+#if defined(CONFIG_MGCOGE3NE)
+	testpin = get_testpin();
+#endif
+	s = getenv("test_bank");
+	/* when test_bank is not set, act as if testpin is not asserted */
+	testboot = (testpin != 0) && (s);
+	if (verbose) {
+		printf("testpin   = %d\n", testpin);
+		/* cppcheck-suppress nullPointer */
+		printf("test_bank = %s\n", s ? s : "not set");
+		printf("boot test app : %s\n", (testboot) ? "yes" : "no");
+	}
+	/* return 0 means: testboot, therefore we need the inversion */
+	return !testboot;
+}
+
+U_BOOT_CMD(km_checktestboot, 2, 0, do_checktestboot,
+		"check if testpin is asserted",
+		"[v]\n  v - verbose output"
+);

u-boot/board/keymile/common/common.h

@@ -0,0 +1,155 @@
+/*
+ * (C) Copyright 2008
+ * Heiko Schocher, DENX Software Engineering, hs@denx.de.
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#ifndef __KEYMILE_COMMON_H
+#define __KEYMILE_COMMON_H
+
+#define WRG_RESET	0x80
+#define H_OPORTS_14	0x40
+#define WRG_LED		0x02
+#define WRL_BOOT	0x01
+
+#define OPRTL_XBUFENA	0x20
+
+#define H_OPORTS_SCC4_ENA	0x10
+#define H_OPORTS_SCC4_FD_ENA	0x04
+#define H_OPORTS_FCC1_PW_DWN	0x01
+
+#define PIGGY_PRESENT	0x80
+
+struct km_bec_fpga {
+	unsigned char	id;
+	unsigned char	rev;
+	unsigned char	oprth;
+	unsigned char	oprtl;
+	unsigned char	res1[3];
+	unsigned char	bprth;
+	unsigned char	bprtl;
+	unsigned char	gprt3;
+	unsigned char	gprt2;
+	unsigned char	gprt1;
+	unsigned char	gprt0;
+	unsigned char	res2[2];
+	unsigned char	prst;
+	unsigned char	res3[0xfff0];
+	unsigned char	pgy_id;
+	unsigned char	pgy_rev;
+	unsigned char	pgy_outputs;
+	unsigned char	pgy_eth;
+};
+
+#define BFTICU_DIPSWITCH_MASK   0x0f
+
+/*
+ * BFTICU FPGA iomap
+ * BFTICU is used on mgcoge and mgocge3ne
+ */
+struct bfticu_iomap {
+	u8	xi_ena;		/* General defect enable */
+	u8	pack1[3];
+	u8	en_csn;
+	u8	pack2;
+	u8	safe_mem;
+	u8	pack3;
+	u8	id;
+	u8	pack4;
+	u8	rev;
+	u8	build;
+	u8	p_frc;
+	u8	p_msk;
+	u8	pack5[2];
+	u8	xg_int;
+	u8	pack6[15];
+	u8	s_conf;
+	u8	pack7;
+	u8	dmx_conf12;
+	u8	pack8;
+	u8	s_clkslv;
+	u8	pack9[11];
+	u8	d_conf;
+	u8	d_mask_ca;
+	u8	d_pll_del;
+	u8	pack10[16];
+	u8	t_conf_ca;
+	u8	t_mask_ca;
+	u8	pack11[13];
+	u8	m_def0;
+	u8	m_def1;
+	u8	m_def2;
+	u8	m_def3;
+	u8	m_def4;
+	u8	m_def5;
+	u8	m_def_trap0;
+	u8	m_def_trap1;
+	u8	m_def_trap2;
+	u8	m_def_trap3;
+	u8	m_def_trap4;
+	u8	m_def_trap5;
+	u8	m_mask_def0;
+	u8	m_mask_def1;
+	u8	m_mask_def2;
+	u8	m_mask_def3;
+	u8	m_mask_def4;
+	u8	m_mask_def5;
+	u8	m_def_mask0;
+	u8	m_def_mask1;
+	u8	m_def_mask2;
+	u8	m_def_mask3;
+	u8	m_def_mask4;
+	u8	m_def_mask5;
+	u8	m_def_pri;
+	u8	pack12[11];
+	u8	hw_status;
+	u8	pack13;
+	u8	hw_control1;
+	u8	hw_control2;
+	u8	hw_control3;
+	u8	pack14[7];
+	u8	led_on;		/* Leds */
+	u8	pack15;
+	u8	sfp_control;	/* SFP modules */
+	u8	pack16;
+	u8	alarm_control;	/* Alarm output */
+	u8	pack17;
+	u8	icps;		/* ICN clock pulse shaping */
+	u8	mswitch;	/* Read mode switch */
+	u8	pack18[6];
+	u8	pb_dbug;
+};
+
+#if !defined(CONFIG_PIGGY_MAC_ADRESS_OFFSET)
+#define CONFIG_PIGGY_MAC_ADRESS_OFFSET	0
+#endif
+
+int ethernet_present(void);
+int ivm_read_eeprom(unsigned char *buf, int len);
+int ivm_analyze_eeprom(unsigned char *buf, int len);
+
+int trigger_fpga_config(void);
+int wait_for_fpga_config(void);
+int fpga_reset(void);
+int toggle_eeprom_spi_bus(void);
+
+int get_testpin(void);
+
+int set_km_env(void);
+int fdt_set_node_and_value(void *blob,
+			char *nodename,
+			char *regname,
+			void *var,
+			int size);
+int fdt_get_node_and_value(void *blob,
+				char *nodename,
+				char *propname,
+				void **var);
+
+#define DELAY_ABORT_SEQ		62  /* @200kHz 9 clocks = 44us, 62us is ok */
+#define DELAY_HALF_PERIOD	(500 / (CONFIG_SYS_I2C_SPEED / 1000))
+
+int i2c_soft_read_pin(void);
+int i2c_make_abort(void);
+#endif /* __KEYMILE_COMMON_H */

u-boot/board/keymile/common/ivm.c

@@ -0,0 +1,333 @@
+/*
+ * (C) Copyright 2011
+ * Holger Brunck, Keymile GmbH Hannover, holger.brunck@keymile.com
+ *
+ * SPDX-License-Identifier:	GPL-2.0+
+ */
+
+#include <common.h>
+#include <cli_hush.h>
+#include <i2c.h>
+#include "common.h"
+
+#define MAC_STR_SZ	20
+
+static int ivm_calc_crc(unsigned char *buf, int len)
+{
+	const unsigned short crc_tab[16] = {
+		0x0000, 0xCC01, 0xD801, 0x1400,
+		0xF001, 0x3C00, 0x2800, 0xE401,
+		0xA001, 0x6C00, 0x7800, 0xB401,
+		0x5000, 0x9C01, 0x8801, 0x4400};
+
+	unsigned short crc     = 0;   /* final result */
+	unsigned short r1      = 0;   /* temp */
+	unsigned char  byte    = 0;   /* input buffer */
+	int	i;
+
+	/* calculate CRC from array data */
+	for (i = 0; i < len; i++) {
+		byte = buf[i];
+
+		/* lower 4 bits */
+		r1 = crc_tab[crc & 0xF];
+		crc = ((crc) >> 4) & 0x0FFF;
+		crc = crc ^ r1 ^ crc_tab[byte & 0xF];
+
+		/* upper 4 bits */
+		r1 = crc_tab[crc & 0xF];
+		crc = (crc >> 4) & 0x0FFF;
+		crc = crc ^ r1 ^ crc_tab[(byte >> 4) & 0xF];
+	}
+	return crc;
+}
+
+static int ivm_set_value(char *name, char *value)
+{
+	char tempbuf[256];
+
+	if (value != NULL) {
+		sprintf(tempbuf, "%s=%s", name, value);
+		return set_local_var(tempbuf, 0);
+	} else {
+		unset_local_var(name);
+	}
+	return 0;
+}
+
+static int ivm_get_value(unsigned char *buf, int len, char *name, int off,
+				int check)
+{
+	unsigned short	val;
+	unsigned char	valbuf[30];
+
+	if ((buf[off + 0] != buf[off + 2]) &&
+	    (buf[off + 2] != buf[off + 4])) {
+		printf("%s Error corrupted %s\n", __func__, name);
+		val = -1;
+	} else {
+		val = buf[off + 0] + (buf[off + 1] << 8);
+		if ((val == 0) && (check == 1))
+			val = -1;
+	}
+	sprintf((char *)valbuf, "%x", val);
+	ivm_set_value(name, (char *)valbuf);
+	return val;
+}
+
+#define INV_BLOCKSIZE		0x100
+#define INV_DATAADDRESS		0x21
+#define INVENTORYDATASIZE	(INV_BLOCKSIZE - INV_DATAADDRESS - 3)
+
+#define IVM_POS_SHORT_TEXT		0
+#define IVM_POS_MANU_ID			1
+#define IVM_POS_MANU_SERIAL		2
+#define IVM_POS_PART_NUMBER		3
+#define IVM_POS_BUILD_STATE		4
+#define IVM_POS_SUPPLIER_PART_NUMBER	5
+#define IVM_POS_DELIVERY_DATE		6
+#define IVM_POS_SUPPLIER_BUILD_STATE	7
+#define IVM_POS_CUSTOMER_ID		8
+#define IVM_POS_CUSTOMER_PROD_ID	9
+#define IVM_POS_HISTORY			10
+#define IVM_POS_SYMBOL_ONLY		11
+
+static char convert_char(char c)
+{
+	return (c < ' ' || c > '~') ? '.' : c;
+}
+
+static int ivm_findinventorystring(int type,
+					unsigned char *const string,
+					unsigned long maxlen,
+					unsigned char *buf)
+{
+	int xcode = 0;
+	unsigned long cr = 0;
+	unsigned long addr = INV_DATAADDRESS;
+	unsigned long size = 0;
+	unsigned long nr = type;
+	int stop = 0;	/* stop on semicolon */
+
+	memset(string, '\0', maxlen);
+	switch (type) {
+	case IVM_POS_SYMBOL_ONLY:
+		nr = 0;
+		stop = 1;
+	break;
+	default:
+		nr = type;
+		stop = 0;
+	}
+
+	/* Look for the requested number of CR. */
+	while ((cr != nr) && (addr < INVENTORYDATASIZE)) {
+		if (buf[addr] == '\r')
+			cr++;
+		addr++;
+	}
+
+	/*
+	 * the expected number of CR was found until the end of the IVM
+	 *  content --> fill string
+	 */
+	if (addr < INVENTORYDATASIZE) {
+		/* Copy the IVM string in the corresponding string */
+		for (; (buf[addr] != '\r')			&&
+			((buf[addr] != ';') ||  (!stop))	&&
+			(size < (maxlen - 1)			&&
+			(addr < INVENTORYDATASIZE)); addr++) {
+			size += sprintf((char *)string + size, "%c",
+						convert_char (buf[addr]));
+		}
+
+		/*
+		 * copy phase is done: check if everything is ok. If not,
+		 * the inventory data is most probably corrupted: tell
+		 * the world there is a problem!
+		 */
+		if (addr == INVENTORYDATASIZE) {
+			xcode = -1;
+			printf("Error end of string not found\n");
+		} else if ((size > (maxlen - 1)) &&
+			   (buf[addr] != '\r')) {
+			xcode = -1;
+			printf("string too long till next CR\n");
+		}
+	} else {
+		/*
+		 * some CR are missing...
+		 * the inventory data is most probably corrupted
+		 */
+		xcode = -1;
+		printf("not enough cr found\n");
+	}
+	return xcode;
+}
+
+#define GET_STRING(name, which, len) \
+	if (ivm_findinventorystring(which, valbuf, len, buf) == 0) { \
+		ivm_set_value(name, (char *)valbuf); \
+	}
+
+static int ivm_check_crc(unsigned char *buf, int block)
+{
+	unsigned long	crc;
+	unsigned long	crceeprom;
+
+	crc = ivm_calc_crc(buf, CONFIG_SYS_IVM_EEPROM_PAGE_LEN - 2);
+	crceeprom = (buf[CONFIG_SYS_IVM_EEPROM_PAGE_LEN - 1] + \
+			buf[CONFIG_SYS_IVM_EEPROM_PAGE_LEN - 2] * 256);
+	if (crc != crceeprom) {
+		if (block == 0)
+			printf("Error CRC Block: %d EEprom: calculated: \
+			%lx EEprom: %lx\n", block, crc, crceeprom);
+		return -1;
+	}
+	return 0;
+}
+
+/* take care of the possible MAC address offset and the IVM content offset */
+static int process_mac(unsigned char *valbuf, unsigned char *buf,
+				int offset)
+{
+	unsigned char mac[6];
+	unsigned long val = (buf[4] << 16) + (buf[5] << 8) + buf[6];
+
+	/* use an intermediate buffer, to not change IVM content
+	 * MAC address is at offset 1
+	 */
+	memcpy(mac, buf+1, 6);
+
+	if (offset) {
+		val += offset;
+		mac[3] = (val >> 16) & 0xff;
+		mac[4] = (val >> 8) & 0xff;
+		mac[5] = val & 0xff;
+	}
+
+	sprintf((char *)valbuf, "%pM", mac);
+	return 0;
+}
+
+static int ivm_analyze_block2(unsigned char *buf, int len)
+{
+	unsigned char	valbuf[MAC_STR_SZ];
+	unsigned long	count;
+
+	/* IVM_MAC Adress begins at offset 1 */
+	sprintf((char *)valbuf, "%pM", buf + 1);
+	ivm_set_value("IVM_MacAddress", (char *)valbuf);
+	/* IVM_MacCount */
+	count = (buf[10] << 24) +
+		   (buf[11] << 16) +
+		   (buf[12] << 8)  +
+		    buf[13];
+	if (count == 0xffffffff)
+		count = 1;
+	sprintf((char *)valbuf, "%lx", count);
+	ivm_set_value("IVM_MacCount", (char *)valbuf);
+	return 0;
+}
+
+int ivm_analyze_eeprom(unsigned char *buf, int len)
+{
+	unsigned short	val;
+	unsigned char	valbuf[CONFIG_SYS_IVM_EEPROM_PAGE_LEN];
+	unsigned char	*tmp;
+
+	if (ivm_check_crc(buf, 0) != 0)
+		return -1;
+
+	ivm_get_value(buf, CONFIG_SYS_IVM_EEPROM_PAGE_LEN,
+			"IVM_BoardId", 0, 1);
+	val = ivm_get_value(buf, CONFIG_SYS_IVM_EEPROM_PAGE_LEN,
+			"IVM_HWKey", 6, 1);
+	if (val != 0xffff) {
+		sprintf((char *)valbuf, "%x", ((val / 100) % 10));
+		ivm_set_value("IVM_HWVariant", (char *)valbuf);
+		sprintf((char *)valbuf, "%x", (val % 100));
+		ivm_set_value("IVM_HWVersion", (char *)valbuf);
+	}
+	ivm_get_value(buf, CONFIG_SYS_IVM_EEPROM_PAGE_LEN,
+		"IVM_Functions", 12, 0);
+
+	GET_STRING("IVM_Symbol", IVM_POS_SYMBOL_ONLY, 8)
+	GET_STRING("IVM_DeviceName", IVM_POS_SHORT_TEXT, 64)
+	tmp = (unsigned char *) getenv("IVM_DeviceName");
+	if (tmp) {
+		int	len = strlen((char *)tmp);
+		int	i = 0;
+
+		while (i < len) {
+			if (tmp[i] == ';') {
+				ivm_set_value("IVM_ShortText",
+					(char *)&tmp[i + 1]);
+				break;
+			}
+			i++;
+		}
+		if (i >= len)
+			ivm_set_value("IVM_ShortText", NULL);
+	} else {
+		ivm_set_value("IVM_ShortText", NULL);
+	}
+	GET_STRING("IVM_ManufacturerID", IVM_POS_MANU_ID, 32)
+	GET_STRING("IVM_ManufacturerSerialNumber", IVM_POS_MANU_SERIAL, 20)
+	GET_STRING("IVM_ManufacturerPartNumber", IVM_POS_PART_NUMBER, 32)
+	GET_STRING("IVM_ManufacturerBuildState", IVM_POS_BUILD_STATE, 32)
+	GET_STRING("IVM_SupplierPartNumber", IVM_POS_SUPPLIER_PART_NUMBER, 32)
+	GET_STRING("IVM_DelieveryDate", IVM_POS_DELIVERY_DATE, 32)
+	GET_STRING("IVM_SupplierBuildState", IVM_POS_SUPPLIER_BUILD_STATE, 32)
+	GET_STRING("IVM_CustomerID", IVM_POS_CUSTOMER_ID, 32)
+	GET_STRING("IVM_CustomerProductID", IVM_POS_CUSTOMER_PROD_ID, 32)
+
+	if (ivm_check_crc(&buf[CONFIG_SYS_IVM_EEPROM_PAGE_LEN * 2], 2) != 0)
+		return 0;
+	ivm_analyze_block2(&buf[CONFIG_SYS_IVM_EEPROM_PAGE_LEN * 2],
+		CONFIG_SYS_IVM_EEPROM_PAGE_LEN);
+
+	return 0;
+}
+
+static int ivm_populate_env(unsigned char *buf, int len)
+{
+	unsigned char	*page2;
+	unsigned char	valbuf[MAC_STR_SZ];
+
+	/* do we have the page 2 filled ? if not return */
+	if (ivm_check_crc(buf, 2))
+		return 0;
+	page2 = &buf[CONFIG_SYS_IVM_EEPROM_PAGE_LEN*2];
+
+	/* if an offset is defined, add it */
+	process_mac(valbuf, page2, CONFIG_PIGGY_MAC_ADRESS_OFFSET);
+	if (getenv("ethaddr") == NULL)
+		setenv((char *)"ethaddr", (char *)valbuf);
+#ifdef CONFIG_KMVECT1
+/* KMVECT1 has two ethernet interfaces */
+	if (getenv("eth1addr") == NULL) {
+		process_mac(valbuf, page2, 1);
+		setenv((char *)"eth1addr", (char *)valbuf);
+	}
+#endif
+
+	return 0;
+}
+
+int ivm_read_eeprom(unsigned char *buf, int len)
+{
+	int ret;
+
+	i2c_set_bus_num(CONFIG_KM_IVM_BUS);
+	/* add deblocking here */
+	i2c_make_abort();
+
+	ret = i2c_read(CONFIG_SYS_IVM_EEPROM_ADR, 0, 1, buf, len);
+	if (ret != 0) {
+		printf("Error reading EEprom\n");
+		return -2;
+	}
+
+	return ivm_populate_env(buf, len);
+}