/* * (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++; } }