board/hymod/eeprom.c

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