[people/ms/u-boot.git] / board / hymod / eeprom.c

/*
 * (C) Copyright 2001
 * Murray Jensen, CSIRO-MIT, <Murray.Jensen@csiro.au>
 *
 * See file CREDITS for list of people who contributed to this
 * project.
 *
 * 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.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * 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., 59 Temple Place, Suite 330, Boston,
 * MA 02111-1307 USA
 */

#include <common.h>
#include <mpc8260.h>

/* imports from fetch.c */
extern int fetch_and_parse (char *, ulong, int (*)(uchar *, uchar *));

/* imports from input.c */
extern int hymod_get_serno (const char *);

/* this is relative to the root of the server's tftp directory */
static char *def_bddb_cfgdir = "/hymod/bddb";

static int
hymod_eeprom_load (int which, hymod_eeprom_t *ep)
{
	unsigned dev_addr = CFG_I2C_EEPROM_ADDR | \
		(which ? HYMOD_EEOFF_MEZZ : HYMOD_EEOFF_MAIN);
	unsigned offset = 0;
	uchar data[HYMOD_EEPROM_MAXLEN], *dp, *edp;
	hymod_eehdr_t hdr;
	ulong len, crc;

	memset (ep, 0, sizeof *ep);

	eeprom_read (dev_addr, offset, (uchar *)&hdr, sizeof (hdr));
	offset += sizeof (hdr);

	if (hdr.id != HYMOD_EEPROM_ID || hdr.ver > HYMOD_EEPROM_VER ||
	  (len = hdr.len) > HYMOD_EEPROM_MAXLEN)
	    return (0);

	eeprom_read (dev_addr, offset, data, len);
	offset += len;

	eeprom_read (dev_addr, offset, (uchar *)&crc, sizeof (ulong));
	offset += sizeof (ulong);

	if (crc32 (crc32 (0, (uchar *)&hdr, sizeof hdr), data, len) != crc)
		return (0);

	ep->ver = hdr.ver;
	dp = data; edp = dp + len;

	for (;;) {
		ulong rtyp;
		uchar rlen, *rdat;

		rtyp = *dp++;
		if ((rtyp & 0x80) == 0)
			rlen = *dp++;
		else {
			uchar islarge = rtyp & 0x40;

			rtyp = ((rtyp & 0x3f) << 8) | *dp++;
			if (islarge) {
				rtyp = (rtyp << 8) | *dp++;
				rtyp = (rtyp << 8) | *dp++;
			}

			rlen = *dp++;
			rlen = (rlen << 8) | *dp++;
			if (islarge) {
				rlen = (rlen << 8) | *dp++;
				rlen = (rlen << 8) | *dp++;
			}
		}

		if (rtyp == 0)
			break;

		rdat = dp;
		dp += rlen;

		if (dp > edp)	/* error? */
			break;

		switch (rtyp) {

		case HYMOD_EEREC_SERNO:		/* serial number */
			if (rlen == sizeof (ulong))
				ep->serno = \
					((ulong)rdat[0] << 24) | \
					((ulong)rdat[1] << 16) | \
					((ulong)rdat[2] << 8) | \
					(ulong)rdat[3];
			break;

		case HYMOD_EEREC_DATE:		/* date */
			if (rlen == sizeof (hymod_date_t)) {
				ep->date.year = ((ushort)rdat[0] << 8) | \
					(ushort)rdat[1];
				ep->date.month = rdat[2];
				ep->date.day = rdat[3];
			}
			break;

		case HYMOD_EEREC_BATCH:		/* batch */
			if (rlen <= HYMOD_MAX_BATCH)
				memcpy (ep->batch, rdat, ep->batchlen = rlen);
			break;

		case HYMOD_EEREC_TYPE:		/* board type */
			if (rlen == 1)
				ep->bdtype = *rdat;
			break;

		case HYMOD_EEREC_REV:		/* board revision */
			if (rlen == 1)
				ep->bdrev = *rdat;
			break;

		case HYMOD_EEREC_SDRAM:		/* sdram size(s) */
			if (rlen > 0 && rlen <= HYMOD_MAX_SDRAM) {
				int i;

				for (i = 0; i < rlen; i++)
					ep->sdramsz[i] = rdat[i];
				ep->nsdram = rlen;
			}
			break;

		case HYMOD_EEREC_FLASH:		/* flash size(s) */
			if (rlen > 0 && rlen <= HYMOD_MAX_FLASH) {
				int i;

				for (i = 0; i < rlen; i++)
					ep->flashsz[i] = rdat[i];
				ep->nflash = rlen;
			}
			break;

		case HYMOD_EEREC_ZBT:		/* zbt ram size(s) */
			if (rlen > 0 && rlen <= HYMOD_MAX_ZBT) {
				int i;

				for (i = 0; i < rlen; i++)
					ep->zbtsz[i] = rdat[i];
				ep->nzbt = rlen;
			}
			break;

		case HYMOD_EEREC_XLXTYP:	/* xilinx fpga type(s) */
			if (rlen > 0 && rlen <= HYMOD_MAX_XLX) {
				int i;

				for (i = 0; i < rlen; i++)
					ep->xlx[i].type = rdat[i];
				ep->nxlx = rlen;
			}
			break;

		case HYMOD_EEREC_XLXSPD:	/* xilinx fpga speed(s) */
			if (rlen > 0 && rlen <= HYMOD_MAX_XLX) {
				int i;

				for (i = 0; i < rlen; i++)
					ep->xlx[i].speed = rdat[i];
			}
			break;

		case HYMOD_EEREC_XLXTMP:	/* xilinx fpga temperature(s) */
			if (rlen > 0 && rlen <= HYMOD_MAX_XLX) {
				int i;

				for (i = 0; i < rlen; i++)
					ep->xlx[i].temp = rdat[i];
			}
			break;

		case HYMOD_EEREC_XLXGRD:	/* xilinx fpga grade(s) */
			if (rlen > 0 && rlen <= HYMOD_MAX_XLX) {
				int i;

				for (i = 0; i < rlen; i++)
					ep->xlx[i].grade = rdat[i];
			}
			break;

		case HYMOD_EEREC_CPUTYP:	/* CPU type */
			if (rlen == 1)
				ep->mpc.type = *rdat;
			break;

		case HYMOD_EEREC_CPUSPD:	/* CPU speed */
			if (rlen == 1)
				ep->mpc.cpuspd = *rdat;
			break;

		case HYMOD_EEREC_CPMSPD:	/* CPM speed */
			if (rlen == 1)
				ep->mpc.cpmspd = *rdat;
			break;

		case HYMOD_EEREC_BUSSPD:	/* bus speed */
			if (rlen == 1)
				ep->mpc.busspd = *rdat;
			break;

		case HYMOD_EEREC_HSTYPE:	/* hs-serial chip type */
			if (rlen == 1)
				ep->hss.type = *rdat;
			break;

		case HYMOD_EEREC_HSCHIN:	/* num hs-serial input chans */
			if (rlen == 1)
				ep->hss.nchin = *rdat;
			break;

		case HYMOD_EEREC_HSCHOUT:	/* num hs-serial output chans */
			if (rlen == 1)
				ep->hss.nchout = *rdat;
			break;

		default:	/* ignore */
			break;
		}
	}

	return (1);
}

/* maps an ascii "name=value" into a binary eeprom data record */
typedef
	struct _eerec_map {
		char *name;
		uint type;
		uchar *(*handler) \
			(struct _eerec_map *, uchar *, uchar *, uchar *);
		uint length;
		uint maxlen;
	}
eerec_map_t;

static uchar *
uint_handler (eerec_map_t *rp, uchar *val, uchar *dp, uchar *edp)
{
	char *eval;
	ulong lval;

	lval = simple_strtol ((char *)val, &eval, 10);

	if ((uchar *)eval == val || *eval != '\0') {
		printf ("%s rec (%s) is not a valid uint\n", rp->name, val);
		return (NULL);
	}

	if (dp + 2 + rp->length > edp) {
		printf ("can't fit %s rec into eeprom\n", rp->name);
		return (NULL);
	}

	*dp++ = rp->type;
	*dp++ = rp->length;

	switch (rp->length) {

	case 1:
		if (lval >= 256) {
			printf ("%s rec value (%lu) out of range (0-255)\n",
				rp->name, lval);
			return (NULL);
		}
		*dp++ = lval;
		break;

	case 2:
		if (lval >= 65536) {
			printf ("%s rec value (%lu) out of range (0-65535)\n",
				rp->name, lval);
			return (NULL);
		}
		*dp++ = lval >> 8;
		*dp++ = lval;
		break;

	case 4:
		*dp++ = lval >> 24;
		*dp++ = lval >> 16;
		*dp++ = lval >> 8;
		*dp++ = lval;
		break;

	default:
		printf ("huh? rp->length not 1, 2 or 4! (%d)\n", rp->length);
		return (NULL);
	}

	return (dp);
}

static uchar *
date_handler (eerec_map_t *rp, uchar *val, uchar *dp, uchar *edp)
{
	hymod_date_t date;
	char *p = (char *)val;
	char *ep;
	ulong lval;

	lval = simple_strtol (p, &ep, 10);
	if (ep == p || *ep++ != '-') {
bad_date:
		printf ("%s rec (%s) is not a valid date\n", rp->name, val);
		return (NULL);
	}
	if (lval >= 65536)
		goto bad_date;
	date.year = lval;

	lval = simple_strtol (p = ep, &ep, 10);
	if (ep == p || *ep++ != '-' || lval == 0 || lval > 12)
		goto bad_date;
	date.month = lval;

	lval = simple_strtol (p = ep, &ep, 10);
	if (ep == p || *ep != '\0' || lval == 0 || lval > 31)
		goto bad_date;
	date.day = lval;

	if (dp + 2 + rp->length > edp) {
		printf ("can't fit %s rec into eeprom\n", rp->name);
		return (NULL);
	}

	*dp++ = rp->type;
	*dp++ = rp->length;
	*dp++ = date.year >> 8;
	*dp++ = date.year;
	*dp++ = date.month;
	*dp++ = date.day;

	return (dp);
}

static uchar *
string_handler (eerec_map_t *rp, uchar *val, uchar *dp, uchar *edp)
{
	uint len;

	if ((len = strlen ((char *)val)) > rp->maxlen) {
		printf ("%s rec (%s) string is too long (%d>%d)\n",
			rp->name, val, len, rp->maxlen);
		return (NULL);
	}

	if (dp + 2 + len > edp) {
		printf ("can't fit %s rec into eeprom\n", rp->name);
		return (NULL);
	}

	*dp++ = rp->type;
	*dp++ = len;
	memcpy (dp, val, len);
	dp += len;

	return (dp);
}

static uchar *
bytes_handler (eerec_map_t *rp, uchar *val, uchar *dp, uchar *edp)
{
	uchar bytes[HYMOD_MAX_BYTES], nbytes, *p;
	char *ep;

	for (nbytes = 0, p = val; *p != '\0'; p = (uchar *)ep) {
		ulong lval;

		lval = simple_strtol ((char *)p, &ep, 10);
		if ((uchar *)ep == p || (*ep != '\0' && *ep != ',') || \
		    lval >= 256) {
			printf ("%s rec (%s) byte array has invalid uint\n",
				rp->name, val);
			return (NULL);
		}
		if (nbytes >= HYMOD_MAX_BYTES) {
			printf ("%s rec (%s) byte array too long\n",
				rp->name, val);
			return (NULL);
		}
		bytes[nbytes++] = lval;

		if (*ep != '\0')
			ep++;
	}

	if (dp + 2 + nbytes > edp) {
		printf ("can't fit %s rec into eeprom\n", rp->name);
		return (NULL);
	}

	*dp++ = rp->type;
	*dp++ = nbytes;
	memcpy (dp, bytes, nbytes);
	dp += nbytes;

	return (dp);
}

static eerec_map_t eerec_map[] = {
	/* name      type                 handler         len max             */
	{ "serno",   HYMOD_EEREC_SERNO,   uint_handler,   4,  0               },
	{ "date",    HYMOD_EEREC_DATE,    date_handler,   4,  0               },
	{ "batch",   HYMOD_EEREC_BATCH,   string_handler, 0,  HYMOD_MAX_BATCH },
	{ "type",    HYMOD_EEREC_TYPE,    uint_handler,   1,  0               },
	{ "rev",     HYMOD_EEREC_REV,     uint_handler,   1,  0               },
	{ "sdram",   HYMOD_EEREC_SDRAM,   bytes_handler,  0,  HYMOD_MAX_SDRAM },
	{ "flash",   HYMOD_EEREC_FLASH,   bytes_handler,  0,  HYMOD_MAX_FLASH },
	{ "zbt",     HYMOD_EEREC_ZBT,     bytes_handler,  0,  HYMOD_MAX_ZBT   },
	{ "xlxtyp",  HYMOD_EEREC_XLXTYP,  bytes_handler,  0,  HYMOD_MAX_XLX   },
	{ "xlxspd",  HYMOD_EEREC_XLXSPD,  bytes_handler,  0,  HYMOD_MAX_XLX   },
	{ "xlxtmp",  HYMOD_EEREC_XLXTMP,  bytes_handler,  0,  HYMOD_MAX_XLX   },
	{ "xlxgrd",  HYMOD_EEREC_XLXGRD,  bytes_handler,  0,  HYMOD_MAX_XLX   },
	{ "cputyp",  HYMOD_EEREC_CPUTYP,  uint_handler,   1,  0               },
	{ "cpuspd",  HYMOD_EEREC_CPUSPD,  uint_handler,   1,  0               },
	{ "cpmspd",  HYMOD_EEREC_CPMSPD,  uint_handler,   1,  0               },
	{ "busspd",  HYMOD_EEREC_BUSSPD,  uint_handler,   1,  0               },
	{ "hstype",  HYMOD_EEREC_HSTYPE,  uint_handler,   1,  0               },
	{ "hschin",  HYMOD_EEREC_HSCHIN,  uint_handler,   1,  0               },
	{ "hschout", HYMOD_EEREC_HSCHOUT, uint_handler,   1,  0               },
};

static int neerecs = sizeof eerec_map / sizeof eerec_map[0];

static uchar data[HYMOD_EEPROM_SIZE], *sdp, *dp, *edp;

static int
eerec_callback (uchar *name, uchar *val)
{
	eerec_map_t *rp;

	for (rp = eerec_map; rp < &eerec_map[neerecs]; rp++)
		if (strcmp ((char *)name, rp->name) == 0)
			break;

	if (rp >= &eerec_map[neerecs])
		return (0);

	if ((dp = (*rp->handler) (rp, val, dp, edp)) == NULL)
		return (0);

	return (1);
}

static int
hymod_eeprom_fetch(int which, char *filename, ulong addr)
{
	unsigned dev_addr = CFG_I2C_EEPROM_ADDR | \
		(which ? HYMOD_EEOFF_MEZZ : HYMOD_EEOFF_MAIN);
	hymod_eehdr_t *hp = (hymod_eehdr_t *)&data[0];
	ulong crc;

	memset (hp, 0, sizeof *hp);
	hp->id = HYMOD_EEPROM_ID;
	hp->ver = HYMOD_EEPROM_VER;

	dp = sdp = (uchar *)(hp + 1);
	edp = dp + HYMOD_EEPROM_MAXLEN;

	if (fetch_and_parse (filename, addr, eerec_callback) == 0)
		return (0);

	hp->len = dp - sdp;

	crc = crc32 (0, data, dp - data);
	memcpy (dp, &crc, sizeof (ulong));
	dp += sizeof (ulong);

	eeprom_write (dev_addr, 0, data, dp - data);

	return (1);
}

static char *type_vals[] = {
	"NONE", "IO", "CLP", "DSP", "INPUT", "ALT-INPUT", "DISPLAY"
};

static char *xlxtyp_vals[] = {
	"NONE", "XCV300E", "XCV400E", "XCV600E"
};

static char *xlxspd_vals[] = {
	"NONE", "6", "7", "8"
};

static char *xlxtmp_vals[] = {
	"NONE", "COM", "IND"
};

static char *xlxgrd_vals[] = {
	"NONE", "NORMAL", "ENGSAMP"
};

static char *cputyp_vals[] = {
	"NONE", "MPC8260"
};

static char *clk_vals[] = {
	"NONE", "33", "66", "100", "133", "166", "200"
};

static char *hstype_vals[] = {
	"NONE", "AMCC-S2064A"
};

static void
print_mem (char *l, char *s, uchar n, uchar a[])
{
	if (n > 0) {
		if (n == 1)
			printf ("%s%dMB %s", s, 1 << (a[0] - 20), l);
		else {
			ulong t = 0;
			int i;

			for (i = 0; i < n; i++)
				t += 1 << (a[i] - 20);

			printf ("%s%luMB %s (%d banks:", s, t, l, n);

			for (i = 0; i < n; i++)
				printf ("%dMB%s",
					1 << (a[i] - 20),
					(i == n - 1) ? ")" : ",");
		}
	}
	else
		printf ("%sNO %s", s, l);
}

void
hymod_eeprom_print (hymod_eeprom_t *ep)
{
	int i;

	printf ("         Hymod %s board, rev %03d\n",
		type_vals[ep->bdtype], ep->bdrev);

	printf ("         serial #: %010lu, date %04d-%02d-%02d",
		ep->serno, ep->date.year, ep->date.month, ep->date.day);
	if (ep->batchlen > 0)
		printf (", batch \"%.*s\"", ep->batchlen, ep->batch);
	puts ("\n");

	switch (ep->bdtype) {

	case HYMOD_BDTYPE_IO:
	case HYMOD_BDTYPE_CLP:
	case HYMOD_BDTYPE_DSP:
		printf ("         Motorola %s CPU, speeds: %s/%s/%s",
		    cputyp_vals[ep->mpc.type], clk_vals[ep->mpc.cpuspd],
		    clk_vals[ep->mpc.cpmspd], clk_vals[ep->mpc.busspd]);

		print_mem ("SDRAM", ", ", ep->nsdram, ep->sdramsz);

		print_mem ("FLASH", ", ", ep->nflash, ep->flashsz);

		puts ("\n");

		print_mem ("ZBT", "         ", ep->nzbt, ep->zbtsz);

		if (ep->nxlx > 0) {
			hymod_xlx_t *xp;

			if (ep->nxlx == 1) {
				xp = &ep->xlx[0];
				printf (", Xilinx %s FPGA (%s/%s/%s)",
					xlxtyp_vals[xp->type],
					xlxspd_vals[xp->speed],
					xlxtmp_vals[xp->temp],
					xlxgrd_vals[xp->grade]);
			}
			else {
				printf (", %d Xilinx FPGAs (", ep->nxlx);
				for (i = 0; i < ep->nxlx; i++) {
					xp = &ep->xlx[i];
					printf ("%s[%s/%s/%s]%s",
					    xlxtyp_vals[xp->type],
					    xlxspd_vals[xp->speed],
					    xlxtmp_vals[xp->temp],
					    xlxgrd_vals[xp->grade],
					    (i == ep->nxlx - 1) ? ")" : ", ");
				}
			}
		}
		else
			puts(", NO FPGAs");

		puts ("\n");

		if (ep->hss.type > 0)
			printf ("         High Speed Serial: "
				"%s, %d input%s, %d output%s\n",
				hstype_vals[ep->hss.type],
				ep->hss.nchin,
				(ep->hss.nchin == 1 ? "" : "s"),
				ep->hss.nchout,
				(ep->hss.nchout == 1 ? "" : "s"));
		break;

	case HYMOD_BDTYPE_INPUT:
	case HYMOD_BDTYPE_ALTINPUT:
	case HYMOD_BDTYPE_DISPLAY:
		break;

	default:
		/* crap! */
		printf ("         UNKNOWN BOARD TYPE: %d\n", ep->bdtype);
		break;
	}
}

int
hymod_eeprom_read (int which, hymod_eeprom_t *ep)
{
	char *label = which ? "mezzanine" : "main";
	unsigned dev_addr = CFG_I2C_EEPROM_ADDR | \
		(which ? HYMOD_EEOFF_MEZZ : HYMOD_EEOFF_MAIN);
	char filename[50], prompt[50], *dir;
	int serno, count = 0, rc;

	rc = eeprom_probe (dev_addr, 0);

	if (rc > 0) {
		printf ("*** probe for eeprom failed with code %d\n", rc);
		return (0);
	}

	if (rc < 0)
		return (rc);

	sprintf (prompt, "Enter %s board serial number: ", label);

	if ((dir = getenv ("bddb_cfgdir")) == NULL)
		dir = def_bddb_cfgdir;

	for (;;) {
		int rc;

		if (hymod_eeprom_load (which, ep))
			return (1);

		printf ("*** %s board EEPROM contents are %sinvalid\n",
			label, count == 0 ? "" : "STILL ");

		puts ("*** will fetch from server (Ctrl-C to abort)\n");

		serno = hymod_get_serno (prompt);

		if (serno < 0) {
			if (serno == -1)
				puts ("\n*** interrupted!");
			else
				puts ("\n*** timeout!");
			puts (" - ignoring eeprom contents\n");
			return (0);
		}

		sprintf (filename, "%s/%010d.cfg", dir, serno);

		printf ("*** fetching %s board EEPROM contents from server\n",
			label);

		rc = hymod_eeprom_fetch (which, filename, CFG_LOAD_ADDR);

		if (rc == 0) {
			puts ("*** fetch failed - ignoring eeprom contents\n");
			return (0);
		}

		count++;
	}
}
Commit	Line	Data
affae2bf WD	1	/*
affae2bf WD	2	* (C) Copyright 2001
6dd652fa	3	* Murray Jensen, CSIRO-MIT, <Murray.Jensen@csiro.au>
affae2bf WD	4	*
	5	* See file CREDITS for list of people who contributed to this
	6	* project.
	7	*
	8	* This program is free software; you can redistribute it and/or
	9	* modify it under the terms of the GNU General Public License as
	10	* published by the Free Software Foundation; either version 2 of
	11	* the License, or (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program; if not, write to the Free Software
	20	* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
	21	* MA 02111-1307 USA
	22	*/
	23
	24	#include <common.h>
	25	#include <mpc8260.h>
	26
	27	/* imports from fetch.c */
6dd652fa	28	extern int fetch_and_parse (char , ulong, int ()(uchar , uchar ));
affae2bf	29
6dd652fa WD	30	/* imports from input.c */
6dd652fa WD	31	extern int hymod_get_serno (const char *);
affae2bf	32
6dd652fa WD	33	/* this is relative to the root of the server's tftp directory */
6dd652fa WD	34	static char *def_bddb_cfgdir = "/hymod/bddb";
affae2bf	35
6dd652fa WD	36	static int
	37	hymod_eeprom_load (int which, hymod_eeprom_t *ep)
	38	{
	39	unsigned dev_addr = CFG_I2C_EEPROM_ADDR \| \
	40	(which ? HYMOD_EEOFF_MEZZ : HYMOD_EEOFF_MAIN);
	41	unsigned offset = 0;
592c5cab WD	42	uchar data[HYMOD_EEPROM_MAXLEN], dp, edp;
592c5cab WD	43	hymod_eehdr_t hdr;
6dd652fa WD	44	ulong len, crc;
	45
	46	memset (ep, 0, sizeof *ep);
6dd652fa	47
592c5cab WD	48	eeprom_read (dev_addr, offset, (uchar *)&hdr, sizeof (hdr));
592c5cab WD	49	offset += sizeof (hdr);
6dd652fa	50
592c5cab WD	51	if (hdr.id != HYMOD_EEPROM_ID \|\| hdr.ver > HYMOD_EEPROM_VER \|\|
592c5cab WD	52	(len = hdr.len) > HYMOD_EEPROM_MAXLEN)
6dd652fa WD	53	return (0);
6dd652fa WD	54
592c5cab	55	eeprom_read (dev_addr, offset, data, len);
6dd652fa WD	56	offset += len;
	57
	58	eeprom_read (dev_addr, offset, (uchar *)&crc, sizeof (ulong));
592c5cab	59	offset += sizeof (ulong);
6dd652fa	60
77ddac94	61	if (crc32 (crc32 (0, (uchar *)&hdr, sizeof hdr), data, len) != crc)
6dd652fa WD	62	return (0);
6dd652fa WD	63
592c5cab WD	64	ep->ver = hdr.ver;
592c5cab WD	65	dp = data; edp = dp + len;
6dd652fa WD	66
6dd652fa WD	67	for (;;) {
6dd652fa WD	68	ulong rtyp;
6dd652fa WD	69	uchar rlen, *rdat;
6dd652fa	70
592c5cab WD	71	rtyp = *dp++;
	72	if ((rtyp & 0x80) == 0)
	73	rlen = *dp++;
6dd652fa	74	else {
592c5cab WD	75	uchar islarge = rtyp & 0x40;
	76
	77	rtyp = ((rtyp & 0x3f) << 8) \| *dp++;
	78	if (islarge) {
	79	rtyp = (rtyp << 8) \| *dp++;
	80	rtyp = (rtyp << 8) \| *dp++;
	81	}
	82
	83	rlen = *dp++;
	84	rlen = (rlen << 8) \| *dp++;
	85	if (islarge) {
	86	rlen = (rlen << 8) \| *dp++;
	87	rlen = (rlen << 8) \| *dp++;
	88	}
6dd652fa	89	}
affae2bf	90
6dd652fa WD	91	if (rtyp == 0)
	92	break;
	93
592c5cab WD	94	rdat = dp;
	95	dp += rlen;
	96
6dd652fa WD	97	if (dp > edp) /* error? */
	98	break;
	99
	100	switch (rtyp) {
	101
	102	case HYMOD_EEREC_SERNO: /* serial number */
	103	if (rlen == sizeof (ulong))
592c5cab WD	104	ep->serno = \
	105	((ulong)rdat[0] << 24) \| \
	106	((ulong)rdat[1] << 16) \| \
	107	((ulong)rdat[2] << 8) \| \
	108	(ulong)rdat[3];
6dd652fa WD	109	break;
	110
	111	case HYMOD_EEREC_DATE: /* date */
592c5cab WD	112	if (rlen == sizeof (hymod_date_t)) {
	113	ep->date.year = ((ushort)rdat[0] << 8) \| \
	114	(ushort)rdat[1];
	115	ep->date.month = rdat[2];
	116	ep->date.day = rdat[3];
	117	}
6dd652fa WD	118	break;
	119
	120	case HYMOD_EEREC_BATCH: /* batch */
	121	if (rlen <= HYMOD_MAX_BATCH)
	122	memcpy (ep->batch, rdat, ep->batchlen = rlen);
	123	break;
	124
	125	case HYMOD_EEREC_TYPE: /* board type */
	126	if (rlen == 1)
	127	ep->bdtype = *rdat;
	128	break;
	129
	130	case HYMOD_EEREC_REV: /* board revision */
	131	if (rlen == 1)
	132	ep->bdrev = *rdat;
	133	break;
	134
	135	case HYMOD_EEREC_SDRAM: /* sdram size(s) */
	136	if (rlen > 0 && rlen <= HYMOD_MAX_SDRAM) {
	137	int i;
	138
	139	for (i = 0; i < rlen; i++)
	140	ep->sdramsz[i] = rdat[i];
	141	ep->nsdram = rlen;
	142	}
	143	break;
	144
	145	case HYMOD_EEREC_FLASH: /* flash size(s) */
	146	if (rlen > 0 && rlen <= HYMOD_MAX_FLASH) {
	147	int i;
	148
	149	for (i = 0; i < rlen; i++)
	150	ep->flashsz[i] = rdat[i];
	151	ep->nflash = rlen;
	152	}
	153	break;
	154
	155	case HYMOD_EEREC_ZBT: /* zbt ram size(s) */
	156	if (rlen > 0 && rlen <= HYMOD_MAX_ZBT) {
	157	int i;
	158
	159	for (i = 0; i < rlen; i++)
	160	ep->zbtsz[i] = rdat[i];
	161	ep->nzbt = rlen;
	162	}
	163	break;
	164
	165	case HYMOD_EEREC_XLXTYP: /* xilinx fpga type(s) */
	166	if (rlen > 0 && rlen <= HYMOD_MAX_XLX) {
	167	int i;
	168
	169	for (i = 0; i < rlen; i++)
	170	ep->xlx[i].type = rdat[i];
	171	ep->nxlx = rlen;
	172	}
	173	break;
	174
	175	case HYMOD_EEREC_XLXSPD: /* xilinx fpga speed(s) */
	176	if (rlen > 0 && rlen <= HYMOD_MAX_XLX) {
	177	int i;
	178
	179	for (i = 0; i < rlen; i++)
	180	ep->xlx[i].speed = rdat[i];
	181	}
182	break;
183
184	case HYMOD_EEREC_XLXTMP: /* xilinx fpga temperature(s) */
185	if (rlen > 0 && rlen <= HYMOD_MAX_XLX) {
186	int i;
187
188	for (i = 0; i < rlen; i++)
189	ep->xlx[i].temp = rdat[i];
190	}
191	break;
192
193	case HYMOD_EEREC_XLXGRD: /* xilinx fpga grade(s) */
194	if (rlen > 0 && rlen <= HYMOD_MAX_XLX) {
195	int i;
196
197	for (i = 0; i < rlen; i++)
198	ep->xlx[i].grade = rdat[i];
199	}
200	break;
201
202	case HYMOD_EEREC_CPUTYP: /* CPU type */
203	if (rlen == 1)
204	ep->mpc.type = *rdat;
205	break;
206
207	case HYMOD_EEREC_CPUSPD: /* CPU speed */
208	if (rlen == 1)
209	ep->mpc.cpuspd = *rdat;
210	break;
211
212	case HYMOD_EEREC_CPMSPD: /* CPM speed */
213	if (rlen == 1)
214	ep->mpc.cpmspd = *rdat;
215	break;
216
217	case HYMOD_EEREC_BUSSPD: /* bus speed */
218	if (rlen == 1)
219	ep->mpc.busspd = *rdat;
220	break;
221
222	case HYMOD_EEREC_HSTYPE: /* hs-serial chip type */
223	if (rlen == 1)
224	ep->hss.type = *rdat;
225	break;
226
227	case HYMOD_EEREC_HSCHIN: /* num hs-serial input chans */
228	if (rlen == 1)
229	ep->hss.nchin = *rdat;
230	break;
231
232	case HYMOD_EEREC_HSCHOUT: /* num hs-serial output chans */
233	if (rlen == 1)
234	ep->hss.nchout = *rdat;
235	break;
236
237	default: /* ignore */
238	break;
239	}
affae2bf	240	}
affae2bf	241
6dd652fa	242	return (1);
affae2bf WD	243	}
	244
	245	/* maps an ascii "name=value" into a binary eeprom data record */
	246	typedef
6dd652fa WD	247	struct _eerec_map {
	248	char *name;
	249	uint type;
	250	uchar (handler) \
	251	(struct _eerec_map , uchar , uchar , uchar );
	252	uint length;
	253	uint maxlen;
	254	}
affae2bf WD	255	eerec_map_t;
	256
	257	static uchar *
6dd652fa	258	uint_handler (eerec_map_t rp, uchar val, uchar dp, uchar edp)
affae2bf	259	{
592c5cab WD	260	char *eval;
592c5cab WD	261	ulong lval;
6dd652fa	262
77ddac94	263	lval = simple_strtol ((char *)val, &eval, 10);
6dd652fa	264
592c5cab WD	265	if ((uchar )eval == val \|\| eval != '\0') {
592c5cab WD	266	printf ("%s rec (%s) is not a valid uint\n", rp->name, val);
6dd652fa	267	return (NULL);
affae2bf	268	}
6dd652fa WD	269
	270	if (dp + 2 + rp->length > edp) {
	271	printf ("can't fit %s rec into eeprom\n", rp->name);
	272	return (NULL);
affae2bf	273	}
affae2bf	274
6dd652fa WD	275	*dp++ = rp->type;
	276	*dp++ = rp->length;
	277
	278	switch (rp->length) {
affae2bf	279
6dd652fa	280	case 1:
592c5cab	281	if (lval >= 256) {
6dd652fa	282	printf ("%s rec value (%lu) out of range (0-255)\n",
592c5cab	283	rp->name, lval);
6dd652fa WD	284	return (NULL);
6dd652fa WD	285	}
592c5cab	286	*dp++ = lval;
6dd652fa WD	287	break;
	288
	289	case 2:
592c5cab	290	if (lval >= 65536) {
6dd652fa	291	printf ("%s rec value (%lu) out of range (0-65535)\n",
592c5cab	292	rp->name, lval);
6dd652fa WD	293	return (NULL);
6dd652fa WD	294	}
592c5cab WD	295	*dp++ = lval >> 8;
592c5cab WD	296	*dp++ = lval;
6dd652fa WD	297	break;
	298
	299	case 4:
592c5cab WD	300	*dp++ = lval >> 24;
	301	*dp++ = lval >> 16;
	302	*dp++ = lval >> 8;
	303	*dp++ = lval;
6dd652fa WD	304	break;
	305
	306	default:
	307	printf ("huh? rp->length not 1, 2 or 4! (%d)\n", rp->length);
	308	return (NULL);
	309	}
affae2bf	310
6dd652fa	311	return (dp);
affae2bf WD	312	}
	313
	314	static uchar *
6dd652fa	315	date_handler (eerec_map_t rp, uchar val, uchar dp, uchar edp)
affae2bf	316	{
6dd652fa	317	hymod_date_t date;
77ddac94	318	char p = (char )val;
592c5cab WD	319	char *ep;
592c5cab WD	320	ulong lval;
affae2bf	321
592c5cab	322	lval = simple_strtol (p, &ep, 10);
77ddac94	323	if (ep == p \|\| *ep++ != '-') {
affae2bf	324	bad_date:
6dd652fa WD	325	printf ("%s rec (%s) is not a valid date\n", rp->name, val);
	326	return (NULL);
	327	}
592c5cab WD	328	if (lval >= 65536)
	329	goto bad_date;
	330	date.year = lval;
affae2bf	331
592c5cab	332	lval = simple_strtol (p = ep, &ep, 10);
77ddac94	333	if (ep == p \|\| *ep++ != '-' \|\| lval == 0 \|\| lval > 12)
6dd652fa	334	goto bad_date;
592c5cab	335	date.month = lval;
affae2bf	336
592c5cab	337	lval = simple_strtol (p = ep, &ep, 10);
77ddac94	338	if (ep == p \|\| *ep != '\0' \|\| lval == 0 \|\| lval > 31)
6dd652fa	339	goto bad_date;
592c5cab	340	date.day = lval;
affae2bf	341
592c5cab	342	if (dp + 2 + rp->length > edp) {
6dd652fa WD	343	printf ("can't fit %s rec into eeprom\n", rp->name);
	344	return (NULL);
	345	}
affae2bf	346
6dd652fa	347	*dp++ = rp->type;
592c5cab WD	348	*dp++ = rp->length;
	349	*dp++ = date.year >> 8;
	350	*dp++ = date.year;
	351	*dp++ = date.month;
	352	*dp++ = date.day;
affae2bf	353
6dd652fa	354	return (dp);
affae2bf WD	355	}
	356
	357	static uchar *
6dd652fa	358	string_handler (eerec_map_t rp, uchar val, uchar dp, uchar edp)
affae2bf	359	{
6dd652fa	360	uint len;
affae2bf	361
77ddac94	362	if ((len = strlen ((char *)val)) > rp->maxlen) {
6dd652fa WD	363	printf ("%s rec (%s) string is too long (%d>%d)\n",
	364	rp->name, val, len, rp->maxlen);
	365	return (NULL);
	366	}
affae2bf	367
6dd652fa WD	368	if (dp + 2 + len > edp) {
	369	printf ("can't fit %s rec into eeprom\n", rp->name);
	370	return (NULL);
	371	}
affae2bf	372
6dd652fa WD	373	*dp++ = rp->type;
	374	*dp++ = len;
	375	memcpy (dp, val, len);
	376	dp += len;
affae2bf	377
6dd652fa	378	return (dp);
affae2bf WD	379	}
	380
	381	static uchar *
6dd652fa	382	bytes_handler (eerec_map_t rp, uchar val, uchar dp, uchar edp)
affae2bf	383	{
592c5cab WD	384	uchar bytes[HYMOD_MAX_BYTES], nbytes, *p;
592c5cab WD	385	char *ep;
affae2bf	386
592c5cab WD	387	for (nbytes = 0, p = val; p != '\0'; p = (uchar )ep) {
592c5cab WD	388	ulong lval;
affae2bf	389
77ddac94	390	lval = simple_strtol ((char *)p, &ep, 10);
592c5cab WD	391	if ((uchar )ep == p \|\| (ep != '\0' && *ep != ',') \|\| \
	392	lval >= 256) {
	393	printf ("%s rec (%s) byte array has invalid uint\n",
6dd652fa WD	394	rp->name, val);
	395	return (NULL);
	396	}
592c5cab WD	397	if (nbytes >= HYMOD_MAX_BYTES) {
592c5cab WD	398	printf ("%s rec (%s) byte array too long\n",
6dd652fa WD	399	rp->name, val);
	400	return (NULL);
	401	}
592c5cab	402	bytes[nbytes++] = lval;
affae2bf	403
592c5cab WD	404	if (*ep != '\0')
592c5cab WD	405	ep++;
6dd652fa	406	}
affae2bf	407
6dd652fa WD	408	if (dp + 2 + nbytes > edp) {
	409	printf ("can't fit %s rec into eeprom\n", rp->name);
	410	return (NULL);
	411	}
affae2bf	412
6dd652fa WD	413	*dp++ = rp->type;
	414	*dp++ = nbytes;
	415	memcpy (dp, bytes, nbytes);
	416	dp += nbytes;
affae2bf	417
6dd652fa	418	return (dp);
affae2bf WD	419	}
	420
	421	static eerec_map_t eerec_map[] = {
6dd652fa WD	422	/* name type handler len max */
	423	{ "serno", HYMOD_EEREC_SERNO, uint_handler, 4, 0 },
	424	{ "date", HYMOD_EEREC_DATE, date_handler, 4, 0 },
	425	{ "batch", HYMOD_EEREC_BATCH, string_handler, 0, HYMOD_MAX_BATCH },
	426	{ "type", HYMOD_EEREC_TYPE, uint_handler, 1, 0 },
	427	{ "rev", HYMOD_EEREC_REV, uint_handler, 1, 0 },
	428	{ "sdram", HYMOD_EEREC_SDRAM, bytes_handler, 0, HYMOD_MAX_SDRAM },
	429	{ "flash", HYMOD_EEREC_FLASH, bytes_handler, 0, HYMOD_MAX_FLASH },
	430	{ "zbt", HYMOD_EEREC_ZBT, bytes_handler, 0, HYMOD_MAX_ZBT },
	431	{ "xlxtyp", HYMOD_EEREC_XLXTYP, bytes_handler, 0, HYMOD_MAX_XLX },
	432	{ "xlxspd", HYMOD_EEREC_XLXSPD, bytes_handler, 0, HYMOD_MAX_XLX },
	433	{ "xlxtmp", HYMOD_EEREC_XLXTMP, bytes_handler, 0, HYMOD_MAX_XLX },
	434	{ "xlxgrd", HYMOD_EEREC_XLXGRD, bytes_handler, 0, HYMOD_MAX_XLX },
	435	{ "cputyp", HYMOD_EEREC_CPUTYP, uint_handler, 1, 0 },
	436	{ "cpuspd", HYMOD_EEREC_CPUSPD, uint_handler, 1, 0 },
	437	{ "cpmspd", HYMOD_EEREC_CPMSPD, uint_handler, 1, 0 },
	438	{ "busspd", HYMOD_EEREC_BUSSPD, uint_handler, 1, 0 },
	439	{ "hstype", HYMOD_EEREC_HSTYPE, uint_handler, 1, 0 },
	440	{ "hschin", HYMOD_EEREC_HSCHIN, uint_handler, 1, 0 },
	441	{ "hschout", HYMOD_EEREC_HSCHOUT, uint_handler, 1, 0 },
affae2bf WD	442	};
	443
	444	static int neerecs = sizeof eerec_map / sizeof eerec_map[0];
	445
	446	static uchar data[HYMOD_EEPROM_SIZE], sdp, dp, *edp;
	447
	448	static int
6dd652fa	449	eerec_callback (uchar name, uchar val)
affae2bf	450	{
6dd652fa	451	eerec_map_t *rp;
affae2bf	452
6dd652fa	453	for (rp = eerec_map; rp < &eerec_map[neerecs]; rp++)
77ddac94	454	if (strcmp ((char *)name, rp->name) == 0)
6dd652fa	455	break;
affae2bf	456
6dd652fa WD	457	if (rp >= &eerec_map[neerecs])
6dd652fa WD	458	return (0);
affae2bf	459
6dd652fa WD	460	if ((dp = (*rp->handler) (rp, val, dp, edp)) == NULL)
6dd652fa WD	461	return (0);
affae2bf	462
6dd652fa	463	return (1);
affae2bf WD	464	}
affae2bf WD	465
6dd652fa WD	466	static int
6dd652fa WD	467	hymod_eeprom_fetch(int which, char *filename, ulong addr)
affae2bf	468	{
6dd652fa WD	469	unsigned dev_addr = CFG_I2C_EEPROM_ADDR \| \
	470	(which ? HYMOD_EEOFF_MEZZ : HYMOD_EEOFF_MAIN);
	471	hymod_eehdr_t hp = (hymod_eehdr_t )&data[0];
	472	ulong crc;
affae2bf	473
592c5cab	474	memset (hp, 0, sizeof *hp);
6dd652fa WD	475	hp->id = HYMOD_EEPROM_ID;
6dd652fa WD	476	hp->ver = HYMOD_EEPROM_VER;
affae2bf	477
6dd652fa WD	478	dp = sdp = (uchar *)(hp + 1);
6dd652fa WD	479	edp = dp + HYMOD_EEPROM_MAXLEN;
affae2bf	480
6dd652fa WD	481	if (fetch_and_parse (filename, addr, eerec_callback) == 0)
6dd652fa WD	482	return (0);
affae2bf	483
6dd652fa	484	hp->len = dp - sdp;
affae2bf	485
6dd652fa WD	486	crc = crc32 (0, data, dp - data);
	487	memcpy (dp, &crc, sizeof (ulong));
	488	dp += sizeof (ulong);
affae2bf	489
6dd652fa	490	eeprom_write (dev_addr, 0, data, dp - data);
affae2bf	491
6dd652fa	492	return (1);
affae2bf WD	493	}
	494
	495	static char *type_vals[] = {
6dd652fa	496	"NONE", "IO", "CLP", "DSP", "INPUT", "ALT-INPUT", "DISPLAY"
affae2bf WD	497	};
	498
	499	static char *xlxtyp_vals[] = {
6dd652fa	500	"NONE", "XCV300E", "XCV400E", "XCV600E"
affae2bf WD	501	};
	502
	503	static char *xlxspd_vals[] = {
6dd652fa	504	"NONE", "6", "7", "8"
affae2bf WD	505	};
	506
	507	static char *xlxtmp_vals[] = {
6dd652fa	508	"NONE", "COM", "IND"
affae2bf WD	509	};
	510
	511	static char *xlxgrd_vals[] = {
6dd652fa	512	"NONE", "NORMAL", "ENGSAMP"
affae2bf WD	513	};
	514
	515	static char *cputyp_vals[] = {
6dd652fa	516	"NONE", "MPC8260"
affae2bf WD	517	};
	518
	519	static char *clk_vals[] = {
6dd652fa	520	"NONE", "33", "66", "100", "133", "166", "200"
affae2bf WD	521	};
	522
	523	static char *hstype_vals[] = {
6dd652fa	524	"NONE", "AMCC-S2064A"
affae2bf WD	525	};
	526
	527	static void
6dd652fa	528	print_mem (char l, char s, uchar n, uchar a[])
affae2bf	529	{
6dd652fa WD	530	if (n > 0) {
	531	if (n == 1)
	532	printf ("%s%dMB %s", s, 1 << (a[0] - 20), l);
	533	else {
	534	ulong t = 0;
	535	int i;
	536
	537	for (i = 0; i < n; i++)
	538	t += 1 << (a[i] - 20);
	539
	540	printf ("%s%luMB %s (%d banks:", s, t, l, n);
	541
	542	for (i = 0; i < n; i++)
	543	printf ("%dMB%s",
	544	1 << (a[i] - 20),
	545	(i == n - 1) ? ")" : ",");
	546	}
affae2bf	547	}
6dd652fa WD	548	else
6dd652fa WD	549	printf ("%sNO %s", s, l);
affae2bf WD	550	}
	551
	552	void
6dd652fa	553	hymod_eeprom_print (hymod_eeprom_t *ep)
affae2bf	554	{
6dd652fa WD	555	int i;
	556
	557	printf (" Hymod %s board, rev %03d\n",
	558	type_vals[ep->bdtype], ep->bdrev);
	559
	560	printf (" serial #: %010lu, date %04d-%02d-%02d",
	561	ep->serno, ep->date.year, ep->date.month, ep->date.day);
	562	if (ep->batchlen > 0)
	563	printf (", batch \"%.*s\"", ep->batchlen, ep->batch);
	564	puts ("\n");
	565
	566	switch (ep->bdtype) {
	567
	568	case HYMOD_BDTYPE_IO:
	569	case HYMOD_BDTYPE_CLP:
	570	case HYMOD_BDTYPE_DSP:
	571	printf (" Motorola %s CPU, speeds: %s/%s/%s",
	572	cputyp_vals[ep->mpc.type], clk_vals[ep->mpc.cpuspd],
	573	clk_vals[ep->mpc.cpmspd], clk_vals[ep->mpc.busspd]);
	574
	575	print_mem ("SDRAM", ", ", ep->nsdram, ep->sdramsz);
	576
	577	print_mem ("FLASH", ", ", ep->nflash, ep->flashsz);
	578
	579	puts ("\n");
	580
	581	print_mem ("ZBT", " ", ep->nzbt, ep->zbtsz);
	582
	583	if (ep->nxlx > 0) {
	584	hymod_xlx_t *xp;
	585
	586	if (ep->nxlx == 1) {
	587	xp = &ep->xlx[0];
	588	printf (", Xilinx %s FPGA (%s/%s/%s)",
	589	xlxtyp_vals[xp->type],
	590	xlxspd_vals[xp->speed],
	591	xlxtmp_vals[xp->temp],
	592	xlxgrd_vals[xp->grade]);
	593	}
	594	else {
	595	printf (", %d Xilinx FPGAs (", ep->nxlx);
	596	for (i = 0; i < ep->nxlx; i++) {
	597	xp = &ep->xlx[i];
	598	printf ("%s[%s/%s/%s]%s",
	599	xlxtyp_vals[xp->type],
	600	xlxspd_vals[xp->speed],
	601	xlxtmp_vals[xp->temp],
	602	xlxgrd_vals[xp->grade],
	603	(i == ep->nxlx - 1) ? ")" : ", ");
	604	}
	605	}
affae2bf	606	}
6dd652fa WD	607	else
	608	puts(", NO FPGAs");
	609
	610	puts ("\n");
	611
	612	if (ep->hss.type > 0)
	613	printf (" High Speed Serial: "
	614	"%s, %d input%s, %d output%s\n",
	615	hstype_vals[ep->hss.type],
	616	ep->hss.nchin,
	617	(ep->hss.nchin == 1 ? "" : "s"),
	618	ep->hss.nchout,
	619	(ep->hss.nchout == 1 ? "" : "s"));
	620	break;
	621
	622	case HYMOD_BDTYPE_INPUT:
	623	case HYMOD_BDTYPE_ALTINPUT:
	624	case HYMOD_BDTYPE_DISPLAY:
	625	break;
	626
	627	default:
	628	/* crap! */
	629	printf (" UNKNOWN BOARD TYPE: %d\n", ep->bdtype);
	630	break;
	631	}
	632	}
	633
	634	int
	635	hymod_eeprom_read (int which, hymod_eeprom_t *ep)
	636	{
	637	char *label = which ? "mezzanine" : "main";
	638	unsigned dev_addr = CFG_I2C_EEPROM_ADDR \| \
	639	(which ? HYMOD_EEOFF_MEZZ : HYMOD_EEOFF_MAIN);
	640	char filename[50], prompt[50], *dir;
	641	int serno, count = 0, rc;
	642
	643	rc = eeprom_probe (dev_addr, 0);
	644
	645	if (rc > 0) {
	646	printf ("*** probe for eeprom failed with code %d\n", rc);
	647	return (0);
	648	}
	649
	650	if (rc < 0)
	651	return (rc);
	652
	653	sprintf (prompt, "Enter %s board serial number: ", label);
	654
	655	if ((dir = getenv ("bddb_cfgdir")) == NULL)
	656	dir = def_bddb_cfgdir;
	657
	658	for (;;) {
	659	int rc;
	660
	661	if (hymod_eeprom_load (which, ep))
	662	return (1);
	663
	664	printf ("*** %s board EEPROM contents are %sinvalid\n",
	665	label, count == 0 ? "" : "STILL ");
	666
	667	puts ("*** will fetch from server (Ctrl-C to abort)\n");
	668
	669	serno = hymod_get_serno (prompt);
	670
671	if (serno < 0) {
672	if (serno == -1)
673	puts ("\n*** interrupted!");
674	else
675	puts ("\n*** timeout!");
676	puts (" - ignoring eeprom contents\n");
677	return (0);
678	}
679
680	sprintf (filename, "%s/%010d.cfg", dir, serno);
681
682	printf ("*** fetching %s board EEPROM contents from server\n",
683	label);
684
685	rc = hymod_eeprom_fetch (which, filename, CFG_LOAD_ADDR);
686
687	if (rc == 0) {
688	puts ("*** fetch failed - ignoring eeprom contents\n");
689	return (0);
690	}
691
692	count++;
affae2bf	693	}
affae2bf	694	}