edt_xilinx.c

/*
* FPGA header read and other utilities
* 
* Originally written it was only Xilinx (hence the name), now encompasses Alterra, may
* include in FPGA types in the future; nevertheless Xilinx will likely be found here
* and there for a long time used generically for all types of FPGAs.   
*/
#include "edtinc.h"
#include "edt_bitload.h"
#include "pciload.h"
#include <stdlib.h>
#include <ctype.h>

#ifdef DOXYGEN_SHOW_UNDOC

#endif

typedef struct {
    u_char fi[8];
    u_char name[MAXPATH];
    u_char id[32];
    u_char date[16];
    u_char time[16];
    u_long dsize; /* get_long_size puts 4-byte dsize here */
} XHEADER;
XHEADER Xh;

u_int ida_4013e(u_long dmy, int sector);
u_int ida_4013xla(u_long dmy, int sector);
u_int ida_4028xla(u_long dmy, int sector); /* and xc2s150 */
u_int ida_xc2s100(u_long dmy, int sector); /* and 200 and 300e */
u_int ida_xc3s1200e(u_long dmy, int sector);
u_int ida_xc2s1200e(u_long dmy, int sector);
u_int ida_xc5vlx30t(u_long edt_p, int dmy); /* and 50t and ep2sgx30d */
u_int edt_get_fpga_info_index(EdtDev *edt_p);

static int xb_get_magic(u_char *buf);
static int xa_get_magic(u_char **ba);
static int xf_get_magic(FILE *fp);

/* Xilinx magic number (first 13 bytes) is always the same ( so far... ) */
#define MGK_SIZE 13
u_char Xmh[MGK_SIZE] = {0x00, 0x09, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x0f, 0xf0, 0x00, 0x00, 0x01 };
#define MGK_X 1

/* EDT magic number used for Alterra parts, different number but same size as Xilinx, for compatability */
u_char Emh[MGK_SIZE] = {0x00, 0x0e, 0x0d, 0x0f, 0x0a, 0x0l, 0x0f, 0x0e, 0x08, 0x08, 0x0a, 0x00, 0x01 };
#define MGK_A 2

/* get from edt_get_prominfo */
/*   name             FPGA                bus     type      magic    sectsize   sectsperseg defaultseg id_addr()  */
Edt_prominfo EPinfo[16] =
{
    {"unknown [0]",  "na",               "na",    0,         0,      0,                0,    0,    NULL},               /*  0 */
    {"4013e",        "AMD 29F010",       "PCI",   XTYPE_X,   MGK_X,  E_SECTOR_SIZE,    8,    0,    ida_4013e},          /*  1 */
    {"4013xla",      "AMD 29F010",       "PCI",   XTYPE_X,   MGK_X,  XLA_SECTOR_SIZE,  1,    1,    ida_4013xla},        /*  2 */
    {"4028xla",      "AMD 29F010",       "PCI",   XTYPE_BT,  MGK_X,  XLA_SECTOR_SIZE,  2,    2,    ida_4028xla},        /*  3 */
    {"xc2s150",      "AMD 29LV040B",     "PCI",   XTYPE_BT,  MGK_X,  XLA_SECTOR_SIZE,  2,    2,    ida_4028xla},        /*  4 */
    {"xc2s200",      "AMD 29LV040B 4MB", "PCI",   XTYPE_BT,  MGK_X,  XLA_SECTOR_SIZE,  4,    2,    ida_xc2s100},        /*  5 */
    {"xc2s200",      "AMD 29LV081B 8MB", "PCI",   XTYPE_BT,  MGK_X,  XLA_SECTOR_SIZE,  4,    2,    ida_xc2s100},        /*  6 */
    {"xc2s100",      "AMD 29LV081B 8MB", "PCI",   XTYPE_BT,  MGK_X,  XLA_SECTOR_SIZE,  4,    2,    ida_xc2s100},        /*  7 */
    {"xc2s300e",     "AMD 29LV081B 8MB", "PCI",   XTYPE_LTX, MGK_X,  XLA_SECTOR_SIZE,  4,    2,    ida_xc2s100},        /*  8 */
    {"xc3s1200e",    "SPI W25P16",       "PCIe",  XTYPE_SPI, MGK_X,  SPI_SECTOR_SIZE,  32,   0,    ida_xc3s1200e},      /*  9 */ 
    {"xc5vlx30t",    "AMD S29GL064N",    "PCIe",  XTYPE_BT2, MGK_X,  XLA_SECTOR_SIZE,  32,   3,    ida_xc5vlx30t},      /* 10 */
    {"xc5vlx50t",    "AMD S29GL064N",    "PCIe",  XTYPE_BT2, MGK_X,  XLA_SECTOR_SIZE,  32,   3,    ida_xc5vlx30t},      /* 11 */
    {"ep2sgx30d",    "AMD S29GL128N",    "PCIe",  XTYPE_BT2, MGK_A,  XLA_SECTOR_SIZE,  32,   3,    ida_xc5vlx30t},      /* 12 */  /* EDT_MAX_PROMCODE */
    {"unknown [13]", "na",               "na",    0,         0,      0,                0,    0,    NULL},
    {"unknown [14]", "na",               "na",    0,         0,      0,                0,    0,    NULL},
    {"unknown [15]", "na",               "na",    0,         0,      0,                0,    0,    NULL},
};

#define EDT_MAX_PROMCODE 12 /* MUST match last promcode defined above */


/* shorthand debug level */
#define DEBUG1 EDTLIB_MSG_INFO_1
#define DEBUG2 EDTLIB_MSG_INFO_2

static int do_fast = 0;
static int force_slow = 0;
static int debug_fast = 0;
static int hubload = 0;

/* SPI DEBUG  FLAGS */
static u_short dbgflg =0;
static u_short spi_verbose = 0;

/* SPI WORKING VARIABLES */
unsigned char  Spi_wbufa[260];          /* Need 3 addr + 256 data for PP */
unsigned char* Spi_wbuf=Spi_wbufa+3;            /* Just the 256 bytes of data */
unsigned char  Spi_rbuf[260];           /* Read buffer, could use 256 Kbytes? */
volatile caddr_t Spi_mapaddr = 0;


static int      spi_block_program(EdtDev *edt_p, int addr0, int size, u_char *spibuf, int verify_only);
static int      spi_write(EdtDev *edt_p, u_int addr, int wcnt);
static void     spi_read(EdtDev *edt_p, int addr, u_char *rbuf, int rcnt);
static int      spi_reset(EdtDev *edt_p);
static int      spi_sector_erase(EdtDev *edt_p, u_int sector);
static void     spi_print16(EdtDev *edt_p, u_int addr);
static void     spiprim(EdtDev *edt_p, int opcode, int wbytes, int rbytes, unsigned char* wbuf, unsigned char* rbuf);
static void     spi_xwr(EdtDev *edt_p, int val);
static int      spi_xrd(EdtDev *edt_p);
static void     spi_xw(EdtDev *edt_p, u_int addr, u_int data);
static u_int    spi_xr(EdtDev *edt_p, u_int addr);

static void   bt_write(EdtDev *edt_p, uint_t desc, u_int addr, u_char val);
static u_char bt_read(EdtDev *edt_p, uint_t desc, u_int addr);
static int    bt_byte_program(EdtDev *edt_p, int xtype, uint_t desc, u_int addr, u_char data);
static void   bt_reset(EdtDev *edt_p, uint_t desc);
static u_char bt_readstat(EdtDev *edt_p, uint_t desc);
static void   bt_print16(EdtDev *edt_p, uint_t desc, u_int addr);
static int    bt_sector_erase(EdtDev *edt_p, u_int sector, u_int sec_size, uint_t desc);

static int    bt2_byte_program(EdtDev *edt_p, int xtype, uint_t desc, u_int addr, u_char data);
static void   bt2_reset(EdtDev *edt_p, uint_t desc);
static int    bt2_sector_erase(EdtDev *edt_p, u_int sector, u_int sec_size, uint_t desc);

static void   xwrite(EdtDev *edt_p, u_int addr, u_char val);
static u_char xread(EdtDev *edt_p, u_int addr);
static int    xbyte_program(EdtDev * edt_p, u_int addr, u_char data);
static void   xreset(EdtDev *edt_p);
static u_char xreadstat(EdtDev *edt_p);
static void   xprint16(EdtDev *edt_p, u_int addr);
static int    xsector_erase(EdtDev * edt_p, u_int sector, u_int sec_size);

static void   tst_write(EdtDev * edt_p, uint_t desc, uint_t val);
#if 0
static int    default_segment(int promcode);
#endif

int
edt_ltx_hub(EdtDev *edt_p)
{
    if (hubload)
        return edt_p->hubidx;
    return -1;
}

void
edt_set_ltx_hub(EdtDev *edt_p, int hub)
{
    hubload = 1;
    edt_p->hubidx = hub;
}

int
edt_get_debug_fast()
{
    return (debug_fast) ;
}
int
edt_set_debug_fast(int val)
{
    (debug_fast = val) ;
    return val;
}
int
edt_get_do_fast()
{
    return (do_fast) ;
}
void
edt_set_do_fast(int val)
{
    do_fast = val ;
}
int
edt_get_force_slow()
{
    return (force_slow) ;
}
void
edt_set_force_slow(int val)
{
    force_slow = val ;
}

char *edt_fmt_pn(char *pn, char *str)
{
    if (strlen(pn) == 10)
        sprintf(str, "%c%c%c-%c%c%c%c%c-%c%c",
        pn[0],pn[1],pn[2],pn[3],pn[4],pn[5],pn[6],pn[7],pn[8],pn[9]);
    else if (strlen(pn) < 10)
        strcpy(str, pn);
    else strcpy(str, "0");
    return str;
}

/*
* xilinx header decoder -- file (see below for array version)
*/
static int
xf_get_magic(FILE *fp)
{
    u_char buf[512];
    int i, j;
    size_t n;

    if ((n = fread(buf, 1, MGK_SIZE, fp)) != MGK_SIZE)
    {
        edt_msg(EDT_MSG_FATAL, "unexpected EOF of xilinx file (%d bytes in)\n", n);
        return -1;
    }

    return xb_get_magic(buf);
}


static int
xf_get_field_id(FILE *fp, u_char *fi)
{
    size_t n;

    if ((n = fread(fi, 1, 1, fp)) != 1)
    {
        edt_msg(DEBUG1, "invalid xilinx field ID\n");
        return -1;
    }

    return 0;
}

static int
xf_get_string(FILE *fp, u_char *str, u_int maxcount)
{
    u_char tmpcount[2];
    u_short count;
    size_t n;

    if ((n = fread(&tmpcount, 1, 2, fp)) != 2)
    {
        edt_msg(DEBUG1, "missing field string count in xilinx header\n");
        return -1;
    }

    count = tmpcount[0] << 8 | tmpcount[1];


    if ((count > maxcount) || ((n = fread(str, sizeof(u_char), count, fp)) != count))
    {
        edt_msg(DEBUG1, "invalid xilinx header string (count %d)\n", count);
        return -1;
    }
    return 0;
}

static int
xf_get_long_size(FILE *fp, u_long *size)
{
    size_t n;
    u_char tmpsize[4];

    if ((n = fread(tmpsize, 1, 4, fp)) != 4)
    {
        edt_msg(DEBUG1, "invalid xilinx header size (%d s/b 4)\n", n);
        return -1;
    }
    *size =  (tmpsize[0] << 24) | (tmpsize[1] << 16) | (tmpsize[2] << 8) | (tmpsize[3]);
    /* printf("size %08x tmpsize %02x %02x %02x %02x\n",
    *size, tmpsize[0], tmpsize[2], tmpsize[1], tmpsize[0]); */

    return 0;
}

/*
* get the xilinx header  (FILE version)
*
* open the file, get the header, and close, and return the # of bytes into
* the file of the first byte of data.
*/
long
edt_get_x_file_header_magic(char *fname, char *header, int *size, int *magic)
{
    FILE *infd = fopen(fname, "rb");
    long start_of_data;
    int ret = 0;

    if (infd == NULL)
    {
        edt_msg_perror(EDT_MSG_FATAL, fname);
        return(-1);
    }

    if ((ret = edt_get_x_header_magic(infd, header, size, magic)) != 0)
        ret = -1;
    else start_of_data = ftell(infd);

    fclose(infd);

    if (ret)
        return ret;

    return start_of_data;
}

/*
 * compat
 */
long 
edt_get_x_file_header(char *fname, char *header, int *size)
{
    int dmy;
    return edt_get_x_file_header_magic(fname, header, size, &dmy);
}

/*
 * get the xilinx header from a FILE -- backwards compat (no magic #)
 *
 * takes as an argument an already open file pointer. for this reason, not to be
 * called directly by an application, ony from within the library. application 
 * programs should instead use edt_get_x_file_header.
 *
 * At the end of this function, the file position will be set to the
 * beginning of the file.
 *
 * Returns 0 on success, -1 on failure.
 */
edt_get_x_header(FILE *fp, char *header, int *size)
{
        int dmy;
        
        return edt_get_x_header_magic(fp, header, size, &dmy);
}

/*
 * get the xilinx header from a FILE, including magic number
 *
 * takes as an argument an already open file pointer. for this reason, not to be
 * called directly by an application, ony from within the library. application 
 * programs should instead use edt_get_x_file_header.
 *
 * At the end of this function, the file position will be set to the
 * beginning of the file.
 *
 * update for 4.1.8.9 (5/5/2008 rwh): look for semicolon & truncate name & id
 *
 * Returns 0 on success, -1 on failure.
 */
int
edt_get_x_header_magic(FILE *fp, char *header, int *size, int *magic)
{
    int     i;
    char   *p;
    long start, end;

    edt_msg(DEBUG2, "edt_get_x_header:\n");

    *size = 0;

    if ((*magic = xf_get_magic(fp)) < 0)
    {
        edt_msg(EDT_MSG_FATAL, "invalid FPGA magic bytes in file\n");
        return  -1;
    }
    else edt_msg(DEBUG1, "magic=%s (%d)\n", (*magic == MGK_X)?"XILINX":(*magic == MGK_A)?"ALTERRA":"UNKNOWN (WTF?)", *magic);

    if ((xf_get_field_id(fp, &Xh.fi[0]) != 0)
        || (xf_get_string(fp, Xh.name, sizeof(Xh.name)) != 0)
        || (xf_get_field_id(fp, &Xh.fi[1]) != 0)
        || (xf_get_string(fp, Xh.id, sizeof(Xh.id)) != 0)
        || (xf_get_field_id(fp, &Xh.fi[2]) != 0)
        || (xf_get_string(fp, Xh.date, sizeof(Xh.date)) != 0)
        || (xf_get_field_id(fp, &Xh.fi[3]) != 0)
        || (xf_get_string(fp, Xh.time, sizeof(Xh.time)) != 0)
        || (xf_get_field_id(fp, &Xh.fi[4]) != 0)
        || (xf_get_long_size(fp, &Xh.dsize) != 0))
    {
        edt_msg(EDT_MSG_FATAL, "Error: bad xilinx header\n");
#if 0
        edt_msg(DEBUG2, "%c) '%s'  %c) '%s'  %c) '%s'  %c) '%s'  %c) %d\n",
            Xh.fi[0], Xh.name,
            Xh.fi[1], Xh.id,
            Xh.fi[2], Xh.date,
            Xh.fi[3], Xh.time,
            Xh.fi[4], Xh.dsize);
        return  -1;
#endif
    }

    for (i=0; i < 5; i++)
    {
        if (Xh.fi[i] != 'a' + i)
        {
            edt_msg(EDT_MSG_FATAL, "invalid xilinx field id: '%c' (0x%02x) s/b '%c' (0x%02x)\n", Xh.fi[i], Xh.fi[i], 'a'+i, 'a'+i);
            return -1;
        }
    }

    /* 
     * work around a new BUG (?) in xilinx tools; they're sticking debug or some such in
     * the #@*&ing xilinx header nowadays (something like EP2SGS30D;DEBUG_HANDLE=2)
     */
    if ((p = strchr(Xh.name, ';')) != NULL)
    {
        edt_msg(DEBUG2, "FIXING: Xh.name %s => ", Xh.name);
        *p = '\0';
        edt_msg(DEBUG2, "%s\n", Xh.name);
    }
    if ((p = strchr(Xh.id, ';')) != NULL)
    {
        edt_msg(DEBUG2, "FIXING: Xh.id %s => ", Xh.id);
        *p = '\0';
        edt_msg(DEBUG2, "%s\n", Xh.id);
    }

    edt_msg(DEBUG2, "%c) '%s'  %c) '%s'  %c) '%s'  %c) '%s'  %c) %d\n",
        Xh.fi[0], Xh.name,
        Xh.fi[1], Xh.id,
        Xh.fi[2], Xh.date,
        Xh.fi[3], Xh.time,
        Xh.fi[4], Xh.dsize);

    /*
    * check remaining size of file against dsize, then rewind file
    * pointer back to start of data 
    */
    start = ftell(fp);
    fseek(fp, Xh.dsize, SEEK_CUR);
    end = ftell(fp);
    if (Xh.dsize < (unsigned long)(end-start))
        edt_msg(EDT_MSG_WARNING, "Warning! dsize/file size mismatch (dsize %u, EOF @ +%u (may work anyway)\n", Xh.dsize, end-start);
    else if (Xh.dsize > (unsigned long)(end-start))
        edt_msg(EDT_MSG_FATAL, "Error! dsize/file size mismatch -- dsize %u but EOF at +%u\n", Xh.dsize, end-start);
    fseek(fp, start, SEEK_SET);

    *size = Xh.dsize;

    sprintf(header, "%s %s %s %s", Xh.name, Xh.id, Xh.date, Xh.time );

    return 0;
}


/*
* get magic number, return 1 if Xilinx, 2 if EDT-Alterra
*/
static int
xa_get_magic(u_char **ba)
{
    u_char buf[512];

    if (*ba == NULL)
    {
        edt_msg(EDT_MSG_FATAL, "unexpected short xilinx array  pointer\n");
        return -1;
    }

    memcpy(buf, *ba, MGK_SIZE);
    *ba += MGK_SIZE;

    return xb_get_magic(buf);

}

/*
 * get magic from buffer (called by xa_get_magic and xf_get_magic, on buf
 * or array 
 * buf has been read in)
 */
static int
xb_get_magic(u_char *buf)
{
    int i;
    int is_xmh = 1;
    int is_emh = 1;

    for (i=0; i<MGK_SIZE; i++)
    {
        if (buf[i] != Xmh[i])
            is_xmh = 0;
        if (buf[i] != Emh[i])
            is_emh = 0;
    }

    if (is_xmh)
        return MGK_X;
    if (is_emh)
        return MGK_A;

    return -1;
}


static int
xa_get_field_id(u_char **ba, u_char *fi)
{
    memcpy(fi, *ba, 1);
    ++(*ba);
    return 0;
}

static int
xa_get_string(u_char **ba, u_char *str, u_int maxcount)
{
    u_char tmpcount[2];
    u_short count;

    memcpy(tmpcount, *ba, 2);
    *ba += 2;

    count = tmpcount[0] << 8 | tmpcount[1];
    if (count > maxcount)
    {
        edt_msg(DEBUG1, "invalid xilinx header string (count %d)\n", count);
        return -1;
    }
    memcpy(str, *ba, count);
    *ba += count;
    return 0;
}

static int
xa_get_long_size(u_char **ba, u_long *size)
{
    u_char tmpsize[4];

    memcpy(tmpsize, *ba, 4);
    *ba += 4;

    *size =  (tmpsize[0] << 24) | (tmpsize[1] << 16) | (tmpsize[2] << 8) | (tmpsize[3]);
    /* printf("size %08x tmpsize %02x %02x %02x %02x\n",
    *size, tmpsize[0], tmpsize[2], tmpsize[1], tmpsize[0]); */

    return 0;
}

/*
 * get the xilinx header (ARRAY version), with magic #
 *
 * open the array, get the header, and close, and return the # of bytes into
 * the file of the first byte of data.
 */
u_char *
edt_get_x_array_header_magic(u_char *ba, char *header, int *size, int *magic)
{
    u_char *start_of_data;

    if ((start_of_data = edt_get_xa_header_magic(ba, header, size, magic)) == NULL)
        start_of_data = ba;

    return start_of_data;
}

/*
 * get the xilinx header (ARRAY version), no magic # (compat)
 *
 * open the array, get the header, and close, and return the # of bytes into
 * the file of the first byte of data.
 */
u_char *
edt_get_x_array_header(u_char *ba, char *header, int *size)
{
    int dmy;

    return edt_get_x_array_header_magic(ba, header, size, &dmy);
}


/*
 * get the xilinx header 
 *
 * extract the xilinx header (OR faked one for alterra, etc.)
 * takes as an argument an array pointer. for this reason, not to be
 * called directly by an application, ony from within the library. application 
 * programs should instead use edt_get_x_file_header.
 */
u_char *
edt_get_xa_header_magic(u_char *ba, char *header, int *size, int *magic)
{
    int     i;
    u_char *ta[1], *start, *end;

    edt_msg(DEBUG1, "edt_get_xa_header_magic:\n");

    *size = 0;
    start = ba;
    *ta = ba;

    if ((*magic = xa_get_magic(ta)) < 0)
    {
        edt_msg(EDT_MSG_FATAL, "invalid FPGA magic bytes in array\n");
        return  NULL;
    }
    else edt_msg(DEBUG1, "magic=%s (%d)\n", (*magic == MGK_X)?"XILINX":(*magic == MGK_A)?"ALTERRA":"UNKNOWN (WTF?)", *magic);

    if ((xa_get_field_id(ta, &Xh.fi[0]) != 0)
        || (xa_get_string(ta, Xh.name, 128) != 0)
        || (xa_get_field_id(ta, &Xh.fi[1]) != 0)
        || (xa_get_string(ta, Xh.id, 32) != 0)
        || (xa_get_field_id(ta, &Xh.fi[2]) != 0)
        || (xa_get_string(ta, Xh.date, 16) != 0)
        || (xa_get_field_id(ta, &Xh.fi[3]) != 0)
        || (xa_get_string(ta, Xh.time, 16) != 0)
        || (xa_get_field_id(ta, &Xh.fi[4]) != 0)
        || (xa_get_long_size(ta, &Xh.dsize) != 0))
    {
        edt_msg(EDT_MSG_FATAL, "Error: bad xilinx header\n");
#if 0
        edt_msg(DEBUG1, "%c) '%s'  %c) '%s'  %c) '%s'  %c) '%s'  %c) %d\n",
            Xh.fi[0], Xh.name,
            Xh.fi[1], Xh.id,
            Xh.fi[2], Xh.date,
            Xh.fi[3], Xh.time,
            Xh.fi[4], Xh.dsize);
        return  -1;
#endif
    }

    for (i=0; i < 5; i++)
    {
        if (Xh.fi[i] != 'a' + i)
        {
            edt_msg(EDT_MSG_FATAL, "invalid xilinx field id: '%c' (0x%02x) s/b '%c' (0x%02x)\n", Xh.fi[i], Xh.fi[i], 'a'+i, 'a'+i);
            return NULL;
        }
    }

    edt_msg(DEBUG1, "%c) '%s'  %c) '%s'  %c) '%s'  %c) '%s'  %c) %d\n",
        Xh.fi[0], Xh.name,
        Xh.fi[1], Xh.id,
        Xh.fi[2], Xh.date,
        Xh.fi[3], Xh.time,
        Xh.fi[4], Xh.dsize);

    /*
    * check remaining size of file against dsize, then rewind file
    * pointer back to start of data 
    */
    start = *ta;
    *ta += Xh.dsize;
    end = *ta;
    if (Xh.dsize < (unsigned long)(end-start))
        edt_msg(EDT_MSG_WARNING, "Warning! dsize/file size mismatch (dsize %u, EOF @ +%u (may work anyway)\n", Xh.dsize, end-start);
    else if (Xh.dsize > (unsigned long)(end-start))
        edt_msg(EDT_MSG_FATAL, "Error! dsize/file size mismatch -- dsize %u but EOF at +%u\n", Xh.dsize, end-start);
    *ta = start;

    *size = Xh.dsize;

    sprintf(header, "%s %s %s %s", Xh.name, Xh.id, Xh.date, Xh.time );

    return start;
}

u_char *
edt_get_xa_header(u_char *ba, char *header, int *size)
{
    int dmy;
    return edt_get_xa_header_magic(ba, header, size, &dmy);
}

/*
 * extract the xilinx header, rcxload-specific
 * derived from edt_get_xa_header (edt_xilinx.c) but instead of returning a
 * string pointer, just returns the status (pass or fail) and skips debug output
 *
 * takes as an argument an array pointer. 
 */
int
edt_get_x_array_header_rstat(u_char *ba, char *header, int *size)
{
    int     i, magic;
    u_char *ta[1], *start, *end;

    edt_msg(DEBUG2, "rcxload_get_xa_header:\n");

    *size = 0;
    start = ba;
    *ta = ba;

    if ((magic = xa_get_magic(ta)) < 0)
    {
        edt_msg(DEBUG2, "invalid FPGA magic bytes\n");
        return  -1;
    }

    if ((xa_get_field_id(ta, &Xh.fi[0]) != 0)
        || (xa_get_string(ta, Xh.name, 128) != 0)
        || (xa_get_field_id(ta, &Xh.fi[1]) != 0)
        || (xa_get_string(ta, Xh.id, 32) != 0)
        || (xa_get_field_id(ta, &Xh.fi[2]) != 0)
        || (xa_get_string(ta, Xh.date, 16) != 0)
        || (xa_get_field_id(ta, &Xh.fi[3]) != 0)
        || (xa_get_string(ta, Xh.time, 16) != 0)
        || (xa_get_field_id(ta, &Xh.fi[4]) != 0)
        || (xa_get_long_size(ta, &Xh.dsize) != 0))
    {
        edt_msg(DEBUG2, "bad xilinx header\n");
        return -1;
#if 0
        edt_msg(DEBUG2, "%c) '%s'  %c) '%s'  %c) '%s'  %c) '%s'  %c) %d\n",
            Xh.fi[0], Xh.name,
            Xh.fi[1], Xh.id,
            Xh.fi[2], Xh.date,
            Xh.fi[3], Xh.time,
            Xh.fi[4], Xh.dsize);
        return  -1;
#endif
    }

    for (i=0; i < 5; i++)
    {
        if (Xh.fi[i] != 'a' + i)
        {
            edt_msg(DEBUG2, "invalid xilinx field id: '%c' (0x%02x) s/b '%c' (0x%02x)\n", Xh.fi[i], Xh.fi[i], 'a'+i, 'a'+i);
            return -1;
        }
    }

    /*
    * check remaining size of file against dsize, then rewind file
    * pointer back to start of data 
    */
    start = *ta;
    *ta += Xh.dsize;
    end = *ta;
    if (Xh.dsize < (unsigned long)(end-start))
        edt_msg(EDT_MSG_WARNING, "Warning! dsize/file size mismatch (dsize %u, EOF @ +%u (may work anyway)\n", Xh.dsize, end-start);
    else if (Xh.dsize > (unsigned long)(end-start))
        edt_msg(EDT_MSG_FATAL, "Error! dsize/file size mismatch -- dsize %u but EOF at +%u\n", Xh.dsize, end-start);
    *ta = start;

    *size = Xh.dsize;

    sprintf(header, "%s %s %s %s", Xh.name, Xh.id, Xh.date, Xh.time );

    return 0;
}

static char *device_name[NUM_DEVICE_TYPES] = {"pcd", "pdv", "p11w", "p16d", "p53b"};
char *read_x_string(EdtDev *edt_p, u_int addr, char *buf, int size, int xtype);


/*
* command bits for the 4028xla boot controller
*/
#define BT_EN_READ      0x8000

/*
* bit to set in all prom addresses to enable the upper 2 bits of prom
* address after we have read the status (jumper and 5/3.3v)
*/
#define EN_HIGH_ADD     0x00800000

/* what are these? */
#define DQ7 0x80
#define DQ5 0x20
#define DQ3 0x08
static int maxloops = 0;

volatile caddr_t dmyaddr = 0;
volatile u_int *cfgaddr ;
volatile u_int *tstaddr ;
int needswap ;

/* not particularly safe -- use at own risk! */
u_char
mmap_intfc_read(volatile u_char * mapaddr, u_int desc)
{
        volatile u_char * off_p ;
        volatile u_char * data_p ;
    u_char val ;
    /* interface must set offset then read data */
    off_p = mapaddr + (EDT_REMOTE_OFFSET & 0xff) ;
    data_p = mapaddr + (EDT_REMOTE_DATA & 0xff) ;
    *off_p = desc & 0xff ;
    /* to flush */
    val = *off_p ;
    val = *data_p ;
    return(val) ;
}

/* not particularly safe -- use at own risk! */
void
mmap_intfc_write(volatile u_char * mapaddr, u_int desc, u_char val)
{
        volatile u_char * off_p ;
        volatile u_char * data_p ;
    u_char tmp ;
    /* interface must set offset then read data */
    off_p = mapaddr + (EDT_REMOTE_OFFSET & 0xff) ;
    data_p = mapaddr + (EDT_REMOTE_DATA & 0xff) ;
    *off_p = desc & 0xff ;
    /* to flush */
    tmp = *off_p ;
    *data_p = val ;
}

int
ltx_tst_init(EdtDev * edt_p)
{

    if ((dmyaddr != 0) && (edt_p->mapaddr != 0))
        return 0;

    dmyaddr = (caddr_t)edt_mapmem(edt_p, 0, 0x10000);
    if (dmyaddr == 0)
    {
        printf("edt_mapmem failed\n");
        return -1;
    }

    if (edt_get_mappable_size(edt_p) > 0)
        edt_p->mapaddr = (caddr_t) edt_mapmem(edt_p, 0x10000, edt_get_mappable_size(edt_p));
    else edt_p->mapaddr = 0;

    (void)tst_write(edt_p, 0xf00004, 0xFF);
    return 0;
}


int 
ltx_check_mmap(EdtDev * edt_p, int space)
{
    if (ltx_tst_init(edt_p) < 0)
        return -1;
    if (space == 0)
    {
        if (dmyaddr == 0)
        {
            fprintf(stderr, "bad mmap for space 0\n");
            return (1);
        }
        else
            return (0);
    }
    else
    {
        if (edt_p->mapaddr == 0)
        {
            fprintf(stderr, "bad mmap for space 1\n");
            return (1);
        }
        else
            return (0);
    }
}

u_int
swap32(u_int val)
{
    /* already set hardware swap if LTX hub */
    if (hubload)
        return val;

    return (
        ((val & 0x000000ff) << 24)
        | ((val & 0x0000ff00) << 8)
        | ((val & 0x00ff0000) >> 8)
        | ((val & 0xff000000) >> 24));
}

#if 0 /* not used anywhere? */
void
prog_write(u_int val)
{
    if(needswap) *cfgaddr = swap32(val) ;
    else *cfgaddr = val ;
}

u_int
prog_read()
{
    if(needswap) return (swap32(*cfgaddr)) ;
    else return (*cfgaddr) ;
}
#endif

void tst_init(EdtDev *edt_p, int verbose)
{
    edt_p->mapaddr = (caddr_t)edt_mapmem(edt_p, 0, 256) ;
    cfgaddr = (volatile u_int *)(edt_p->mapaddr + (EDT_DMA_CFG & 0xff)) ;

    if (hubload)
    {
        printf("HUBLOAD INTERNAL ERROR: should never call tst_init\n");
        exit(1);
    }

    needswap = !edt_little_endian();
#ifdef sgi
    needswap = 0 ;
#endif

    if (verbose )
        printf("  mapaddr %p cfgaddr %p needswap %d\n",edt_p->mapaddr,cfgaddr,needswap) ;
}

void
tst_write(EdtDev * edt_p, uint_t desc, uint_t val)
{
    u_int dmy;

    if (hubload || do_fast)
    {
        if (debug_fast & 0x10)
            edt_msleep(1);

        if (hubload)
            tstaddr = (volatile u_int *)(edt_p->mapaddr + desc);
        else tstaddr = (volatile u_int *)(edt_p->mapaddr + (desc & 0xff)) ;


        if (needswap)
        {
            *tstaddr = swap32(val) ;
            /* printf("DEBUG tst_write desc %x mapaddr %x tstaddr %x val %x (SWAP)\n", desc, edt_p->mapaddr, tstaddr, val); */

            /* debug: try writing a few more times */
            if (debug_fast & 0x1)
            {
                *tstaddr = swap32(val) ;
                *tstaddr = swap32(val) ;
                *tstaddr = swap32(val) ;
                *tstaddr = swap32(val) ;
            }
        }
        else
        {
            *tstaddr = val ;

            /* printf("DEBUG tst_write desc %x mapaddr %x tstaddr %x val %x\n", desc, edt_p->mapaddr, tstaddr, val); */

            /* debug: try writing a few more times */
            if (debug_fast & 0x1)
            {
                *tstaddr = val ;
                *tstaddr = val ;
                *tstaddr = val ;
                *tstaddr = val ;
            }
        }

        dmy = *tstaddr;

        /* okay do a few more reads while things settle down if needed (-F 2) */
        if (debug_fast & 0x2)
        {
            dmy = *tstaddr;
            dmy = *tstaddr;
            dmy = *tstaddr;
            dmy = *tstaddr;
            dmy = *tstaddr;
        }
    }
    else 
    {
        edt_reg_write(edt_p, desc, val) ;
        dmy = edt_reg_read(edt_p, desc) ;
    }
}

uint_t
tst_read(EdtDev * edt_p, uint_t desc)
{
    u_int       ret;

    if (do_fast || hubload)
    {
        if (debug_fast & 0x20)
            edt_msleep(1);
        if (hubload)
            tstaddr = (volatile u_int *)(edt_p->mapaddr + desc) ;
        else tstaddr = (volatile u_int *)(edt_p->mapaddr + (desc & 0xff)) ;

        if (needswap)
        {
            ret = (swap32(*tstaddr)) ;
        }
        else ret =  (*tstaddr) ;


        /* debug: try reading a few more times */
        if (debug_fast & 0x4)
        {
            ret = *tstaddr;
            ret = *tstaddr;
            ret = *tstaddr;
            ret = *tstaddr;
        }

        /* printf("DEBUG tst_read desc %x mapaddr %x tstaddr %x ret %x\n", desc, edt_p->mapaddr, tstaddr, ret); */

        return ret;
    }
    else return(edt_reg_read(edt_p, desc)) ;
}

void tst_pflash(EdtDev *edt_p, uint_t addr, uint_t val)
{
    if (hubload)
    {
        printf("ERROR -- tst_pflash with hubload N/A!\n");
        return;
    }

    tst_write(edt_p, EDT_FLASHROM_DATA, (u_char) 0xaa);
    (void) tst_read(edt_p, EDT_FLASHROM_ADDR);
    tst_write(edt_p, EDT_FLASHROM_ADDR, (u_int) (0x5555 | EDT_WRITECMD));
    (void) tst_read(edt_p, EDT_FLASHROM_ADDR);
    tst_write(edt_p, EDT_FLASHROM_DATA, (u_char) 0x55);
    (void) tst_read(edt_p, EDT_FLASHROM_ADDR);
    tst_write(edt_p, EDT_FLASHROM_ADDR, (u_int) (0x2aaa | EDT_WRITECMD));
    (void) tst_read(edt_p, EDT_FLASHROM_ADDR);
    tst_write(edt_p, EDT_FLASHROM_DATA, (u_char) 0xa0);
    (void) tst_read(edt_p, EDT_FLASHROM_ADDR);
    tst_write(edt_p, EDT_FLASHROM_ADDR, (u_int) (0x5555 | EDT_WRITECMD));
    (void) tst_read(edt_p, EDT_FLASHROM_ADDR);
    tst_write(edt_p, EDT_FLASHROM_DATA, (u_char) val);
    (void) tst_read(edt_p, EDT_FLASHROM_ADDR);
    tst_write(edt_p, EDT_FLASHROM_ADDR, 
        (u_int) (EN_HIGH_ADD | addr | EDT_WRITECMD));
    (void) tst_read(edt_p, EDT_FLASHROM_ADDR);
}

/*
* check ltx hub. return -1 if not an SS4, 0 if is an SS4 but no hub found, 1 if ok
*/
int
edt_check_ltx_hub(EdtDev *edt_p)
{
    if ((!edt_p) || ((edt_p->devid != PSS4_ID) && (edt_p->devid != PCDFOX_ID)))
        return -1;
    if (ltx_tst_init(edt_p) < 0)
        return -1;
    if (tst_read(edt_p, EDT_FLASHROM_LTXHUB(edt_p->hubidx)) == 0xdeaddead)
        return -1;
    return 0;
}

static struct
{
    u_int   mid;
    u_int   devid;
    u_int   prom;
}       older_devices[] =

{
    {
        0x1, 0x20, AMD_4013E
    },
    {
        0x1, 0x4f, AMD_4013XLA
    },
        {
            0x20, 0xe3, AMD_4013XLA
        },
        {
            0x00, 0x00, 0
        }
};


/* write a byte to the PCI interface prom (only 4013E and 4013XLA) */
void
xwrite(EdtDev * edt_p, u_int addr, u_char val)
{
    edt_buf buf;

    if (hubload)
    {
        printf("ERROR -- xwrite with hubload N/A!\n");
        return;
    }

    if (do_fast)
    {
        (void)tst_read(edt_p, EDT_FLASHROM_ADDR);
        tst_write(edt_p, EDT_FLASHROM_DATA, val) ;
        (void)tst_read(edt_p, EDT_FLASHROM_ADDR);
        tst_write(edt_p, EDT_FLASHROM_ADDR, EN_HIGH_ADD | addr | EDT_WRITECMD) ;
    }
    else
    {
        buf.desc = EN_HIGH_ADD | addr;
        buf.value = val;
        edt_ioctl(edt_p, EDTS_FLASH, &buf);
    }
}

/* read a byte from the PCI interface prom (only 4013E and 4013XLA) */
u_char
xread(EdtDev * edt_p, u_int addr)
{
    u_char  val;
    edt_buf buf;

    if (do_fast)
    {
        (void)tst_read(edt_p, EDT_FLASHROM_ADDR);
        tst_write(edt_p, EDT_FLASHROM_ADDR, EN_HIGH_ADD | addr) ;
        (void)tst_read(edt_p, EDT_FLASHROM_ADDR);
        return(tst_read(edt_p, EDT_FLASHROM_DATA));
    }
    else
    {
        buf.desc = EN_HIGH_ADD | addr;
        edt_ioctl(edt_p, EDTG_FLASH, &buf);
        val = (u_char) buf.value;
        return (val);
    }
}

/* ?reset? 4013e or 4013xla */
void 
xreset(EdtDev * edt_p)
{
    xwrite(edt_p, 0x5555, 0xaa);
    xwrite(edt_p, 0x2aaa, 0x55);
    xwrite(edt_p, 0x5555, 0xf0);
}

/*
* write a byte to the PROM thru the boot controller on the 4028xla
*/
static void
bt_write(EdtDev * edt_p, uint_t desc, u_int addr, u_char val)
{
    /* write the address out in three chunks to the boot controller */
    /* first all commands are off */
    tst_write(edt_p, desc, 0);
    /* first byte of address */
    tst_write(edt_p, desc, BT_LD_LO | (addr & 0xff));
    tst_write(edt_p, desc, 0);
    /* second byte of address */
    tst_write(edt_p, desc, BT_LD_MID | ((addr >> 8) & 0xff));
    tst_write(edt_p, desc, 0);

    /* third byte of address */
    tst_write(edt_p, desc, BT_LD_HI | ((addr >> 16) & 0xff));
    tst_write(edt_p, desc, 0);

    tst_write(edt_p, desc, BT_LD_ROM | (val & 0xff));
    tst_write(edt_p, desc, 0);
}


/*
* read a byte from the 4028xla prom through the boot controller.
*/
static u_char
bt_read(EdtDev * edt_p, uint_t desc, u_int addr)
{
    u_char  stat;

    /* write the address out in three chunks to the boot controller */
    /* first all commands are off */
    tst_write(edt_p, desc, 0);
    /* first byte of address */
    tst_write(edt_p, desc, BT_LD_LO | (addr & 0xff));
    /* clear BT_LD_LO */
    tst_write(edt_p, desc, 0);
    /* second byte of address */
    tst_write(edt_p, desc, BT_LD_MID | ((addr >> 8) & 0xff));
    /* clear BT_LD_MID */
    tst_write(edt_p, desc, 0);
    /* third byte of address */
    tst_write(edt_p, desc, BT_LD_HI | ((addr >> 16) & 0xff));
    /* clear BT_LD_HI , set rd command and disable output buffer */
    tst_write(edt_p, desc, BT_RD_ROM);

    /* read the byte */
    stat = (u_char) tst_read(edt_p, desc);
    /* all commands are off */
    tst_write(edt_p, desc, 0);
    return (stat);
}


/* ?reset? the 4028xla */
static void 
bt_reset(EdtDev * edt_p, uint_t desc)
{
    bt_write(edt_p, desc, 0x555, 0xaa);
    bt_write(edt_p, desc, 0x2aa, 0x55);
    bt_write(edt_p, desc, 0x555, 0xf0);
}

/* ?reset? for xc5vlx30t, xc5vlx50t, ep2sgx30d */
static void 
bt2_reset(EdtDev * edt_p, uint_t desc)
{
    bt_write(edt_p, desc, 0x0, 0xf0);
}

/*
* read the jumper position and bus voltage from the boot controller
*/
static u_char
bt_readstat(EdtDev * edt_p, uint_t desc)
{
    u_char  stat;
    uint_t rdval;

    /*
    * read the boot controller status A0 and A1 low with read asserted -
    * enables boot controller on bus
    */
    tst_write(edt_p, desc, 0);
    tst_write(edt_p, desc, BT_EN_READ | BT_READ);
    rdval = tst_read(edt_p, desc);
    stat = (u_char) rdval;
    /* reset all boot command */
    tst_write(edt_p, desc, 0);
    return (stat);
}


u_char
xreadstat(EdtDev * edt_p)
{
    u_char  stat;
    uint_t  rdval;

    if (hubload)
    {
        printf("ERROR -- xreadstat with hubload N/A!\n");
        return 0;
    }


    /*
    * disable the high address drive by writing 0 to bit24 of FPROM address
    * register.
    */
    tst_write(edt_p, EDT_FLASHROM_ADDR, 0);
    rdval = tst_read(edt_p, EDT_FLASHROM_DATA);
    stat = (u_char) (rdval >> 8);
    return (stat);
}

u_char
edt_x_read(EdtDev * edt_p, u_int addr, int xtype)
{
    u_char  val;

    switch(xtype)
    {
    case XTYPE_SPI:
        spi_read(edt_p, addr, &val, 1);
        return val;
        break;
    case XTYPE_BT:
    case XTYPE_BT2:
        return bt_read(edt_p, EDT_FLASHROM_DATA, addr);
        break;
    case XTYPE_X:
        return xread(edt_p, addr);
        break;
    case XTYPE_LTX:
        return bt_read(edt_p, EDT_FLASHROM_LTXHUB(edt_p->hubidx), addr);
        break;
    }

    return 0;
}

void
edt_x_print16(EdtDev * edt_p, u_int addr, int xtype)
{
    switch(xtype)
    {
    case XTYPE_SPI:
        spi_print16(edt_p, (u_int)addr);
        break;
    case XTYPE_BT:
    case XTYPE_BT2:
        bt_print16(edt_p, EDT_FLASHROM_DATA, addr);
        break;
    case XTYPE_X:
        xprint16(edt_p, addr);
        break;
    case XTYPE_LTX:
        bt_print16(edt_p, EDT_FLASHROM_LTXHUB(edt_p->hubidx), addr);
        break;
    }
}

/*
* print 16 bytes at the address passed read from 4028xla boot controller
*/
void
bt_print16(EdtDev * edt_p, uint_t desc, u_int addr)
{
    int     i;

    printf("%08x ", addr);
    for (i = 1; i < 16; i++)
    {
        printf(" %02x", bt_read(edt_p, desc, addr));
        addr++;
    }
    printf("\n");
}

/*
* print 16 bytes at the address passed
*/
void
xprint16(EdtDev * edt_p, u_int addr)
{
    int     i;

    printf("%08x ", addr);
    for (i = 1; i < 16; i++)
    {
        printf(" %02x", xread(edt_p, addr));
        addr++;
    }
    printf("\n");
}

/*
* print 16 bytes at the address passed
*/
void
spi_print16(EdtDev * edt_p, u_int addr)
{
    int     i;
    u_char val;

    printf("%08x ", addr);
    for (i = 1; i < 16; i++)
    {
        spi_read(edt_p, (u_int)addr, &val, 1);
        printf(" %02x", val);
        addr++;
    }
    printf("\n");
}

int
edt_sector_erase(EdtDev * edt_p, u_int sector, u_int sec_size, int xtype)
{
    switch(xtype)
    {
    case XTYPE_SPI:
        spi_sector_erase(edt_p, sector << 16);
        break;
    case XTYPE_BT:
        bt_sector_erase(edt_p, sector, sec_size, EDT_FLASHROM_DATA);
        break;
    case XTYPE_BT2:
        bt2_sector_erase(edt_p, sector, sec_size, EDT_FLASHROM_DATA);
        break;
    case XTYPE_X:
        xsector_erase(edt_p, sector, sec_size);
        break;
    case XTYPE_LTX:
        bt_sector_erase(edt_p, sector, sec_size, EDT_FLASHROM_LTXHUB(edt_p->hubidx));
        break;
    }
    return 0;
}

/*
* sector erase for AMD 29LV0XXX
*/
static int
bt_sector_erase(EdtDev * edt_p, u_int sector, u_int sec_size, uint_t desc)
{
    u_int   addr;
    int     done = 0;
    int     loops = 0;
    u_char  val;

    addr = sector * sec_size;
    bt_write(edt_p, desc, 0x5555, 0xaa);
    bt_write(edt_p, desc, 0x2aaa, 0x55);
    bt_write(edt_p, desc, 0x5555, 0x80);
    bt_write(edt_p, desc, 0x5555, 0xaa);
    bt_write(edt_p, desc, 0x2aaa, 0x55);
    bt_write(edt_p, desc, addr, 0x30);
    done = 0;
    while (!done)
    {
        val = bt_read(edt_p, desc, addr);
        loops++;
        if (val & DQ7)
        {
            done = 1;
        }
    }
    return 0;
}

/*
 * sector erase for AMD S29GL64N, S29GL128N
 */
static int
bt2_sector_erase(EdtDev * edt_p, u_int sector, u_int sec_size, uint_t desc)
{
    u_int   addr;
    int     done = 0;
    int     loops = 0;
    u_char  val;

    addr = sector * sec_size;
    bt_write(edt_p, desc, 0xaaa, 0xaa);
    bt_write(edt_p, desc, 0x555, 0x55);
    bt_write(edt_p, desc, 0xaaa, 0x80);
    bt_write(edt_p, desc, 0xaaa, 0xaa);
    bt_write(edt_p, desc, 0x555, 0x55);
    bt_write(edt_p, desc, addr, 0x30);
    done = 0;
    while (!done)
    {
        val = bt_read(edt_p, desc, addr);
        loops++;
        if (val & DQ7)
        {
            done = 1;
        }
    }
    return 0;
}

static int
xsector_erase(EdtDev * edt_p, u_int sector, u_int sec_size)
{
    u_int   addr;
    int     done = 0;
    int     loops = 0;
    u_char  val;

    addr = sector * sec_size;
    xwrite(edt_p, 0x5555, 0xaa);
    xwrite(edt_p, 0x2aaa, 0x55);
    xwrite(edt_p, 0x5555, 0x80);
    xwrite(edt_p, 0x5555, 0xaa);
    xwrite(edt_p, 0x2aaa, 0x55);
    xwrite(edt_p, addr, 0x30);
    done = 0;
    while (!done)
    {
        val = xread(edt_p, addr);
        loops++;
        if (val & DQ7)
        {
            done = 1;
            break;
        }
    }
    return 0;
}


/*
* for 4028xla, xc2s100, xc2s200
*/
static int
bt_byte_program(EdtDev * edt_p, int xtype, uint_t desc, u_int addr, u_char data)
{
    u_char  val;
    int     done = 0;
    int     loops = 0;

    bt_write(edt_p, desc, 0x5555, 0xaa);
    bt_write(edt_p, desc, 0x2aaa, 0x55);
    bt_write(edt_p, desc, 0x5555, 0xa0);
    bt_write(edt_p, desc, addr, data);
    tst_write(edt_p, desc, BT_RD_ROM);

    while (!done)
    {
        val = (u_char) tst_read(edt_p, desc);

        if (val == data)
            done = 1;
        if (loops > 1000)
        {
            printf("bt_byte_program: failed on %x data %x val %x\n",
                addr, data, val);
            bt_reset(edt_p, desc);
            bt_write(edt_p, desc, 0x555, 0xaa);
            bt_write(edt_p, desc, 0x2aa, 0x55);
            bt_write(edt_p, desc, 0x555, 0xa0);
            bt_write(edt_p, desc, addr, data);
            tst_write(edt_p, desc, BT_RD_ROM);
            loops = 0;
        }
        loops++;
    }
    if (loops > maxloops)
    {
        maxloops = loops;
    }
    if (done)
        return (0);
    else
        return (addr);
}

/*
 * for xc5vlx30t, xc5vlx50t, ep2sgx30d
 */
static int
bt2_byte_program(EdtDev * edt_p, int xtype, uint_t desc, u_int addr, u_char data)
{
    u_char  val;
    int     done = 0;
    int     loops = 0;
    int     failures = 0;

    bt_write(edt_p, desc, 0xaaa, 0xaa);
    bt_write(edt_p, desc, 0x555, 0x55);
    bt_write(edt_p, desc, 0xaaa, 0xa0);
    bt_write(edt_p, desc, addr, data);
    tst_write(edt_p, desc, BT_RD_ROM);

    while (!done)
    {
        val = (u_char) tst_read(edt_p, desc);

        if (val == data)
            done = 1;
        if (loops > 1000)
        {
            bt2_reset(edt_p, desc);
            bt_write(edt_p, desc, 0xaaa, 0xaa);
            bt_write(edt_p, desc, 0x555, 0x55);
            bt_write(edt_p, desc, 0xaaa, 0xa0);
            bt_write(edt_p, desc, addr, data);
            tst_write(edt_p, desc, BT_RD_ROM);
            loops = 0;
            failures++;
        }
        loops++;
        if (failures > 5)
        {
            printf("bt2_byte_program: failed on %x data %x val %x\n", addr, data, val);
            break;
        }
    }
    if (loops > maxloops)
    {
        maxloops = loops;
    }
    if (done)
        return (0);
    else
        return (addr);
}

void
edt_ltx_reboot(EdtDev *edt_p)
{
    tst_write(edt_p, EDT_FLASHROM_LTXHUB(edt_p->hubidx), 0x4000);
}

/*
* for 4013e and others
*/

/* return 0 for success */
int
xbyte_program(EdtDev * edt_p, u_int addr, u_char data)
{
    u_char  val;
    edt_buf buf;
    int     done = 0;
    int     loops = 0;

    if (do_fast)
    {
        tst_pflash(edt_p, addr, data) ;
    }
    else
    {
        buf.desc = EN_HIGH_ADD | addr;
        buf.value = data;
        edt_ioctl(edt_p, EDT_PFLASH, &buf);
    }
    while (!done)
    {
        loops++;
        val = xread(edt_p, addr);
        if (val == data)
            done = 1;
        if (loops > 100)
        {
            printf("xbyte_program: failed on %x data %x val %x\n",
                addr, data, val);
            loops = 0;
        }
    }