You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 

936 lines
25 KiB

#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <termios.h>
#include <sys/time.h>
#include "multiboot.h"
#include "optarg.h"
#define ARRAY_SIZE(x) (sizeof(x) / sizeof(*x))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
#define MEMTYPE_EPROM 1
#define SERIAL_BAUDRATE B115200
#define SERIAL_TIMEOUT 1000
#define SERIAL_TIMEOUT_SYNC 5
#define MSGTYPE_SYNC 0x00 /* trigger { MSGTYPE_ERROR_RSP, 1, ERROR_UNKNOWN_COMMAND } */
#define MSGTYPE_VERSION_REQ 0x01 /* no payload */
#define MSGTYPE_PAGESIZE_REQ 0x02 /* no payload */
#define MSGTYPE_CONFIG_REQ 0x03 /* eprom_type(1), pagesize(1), reset_polarity(1) */
#define MSGTYPE_PROGMODE_REQ 0x04 /* progmode(1) */
#define MSGTYPE_SETADDRESS_REQ 0x05 /* address(3) msb first */
#define MSGTYPE_WRITE_REQ 0x06 /* data(0-pagesize) */
#define MSGTYPE_READ_REQ 0x07 /* length(1) */
#define MSGTYPE_ERROR_RSP 0x80 /* error_code(1) */
#define MSGTYPE_VERSION_RSP 0x81 /* version(?) */
#define MSGTYPE_PAGESIZE_RSP 0x82 /* pagesize(1) */
#define MSGTYPE_CONFIG_RSP 0x83 /* no payload */
#define MSGTYPE_PROGMODE_RSP 0x84 /* no payload */
#define MSGTYPE_SETADDRESS_RSP 0x85 /* no payload */
#define MSGTYPE_WRITE_RSP 0x86 /* no payload */
#define MSGTYPE_READ_RSP 0x87 /* data(0-pagesize) */
#define SUCCESS 0x00
#define ERROR_UNKNOWN_COMMAND 0x01 /* unknown message type */
#define ERROR_NOT_SUPPORTED 0x02 /* command not supported */
#define ERROR_INVALID_MODE 0x03 /* invalid progmode */
#define ERROR_INVALID_PARAMETER 0x04 /* invalid parameter in request */
#define ERROR_INVALID_ADDRESS 0x05 /* write outside of configured region */
#define RESET_POLARITY_LOW 0x00 /* low active reset */
#define RESET_POLARITY_HIGH 0x01 /* high active reset */
#define EPROM_TYPE_2K 0x02 /* 2716 */
#define EPROM_TYPE_4K 0x04 /* 2732 */
#define EPROM_TYPE_8K 0x08 /* 2764 */
#define EPROM_TYPE_16K 0x10 /* 27128 */
#define EPROM_TYPE_32K 0x20 /* 27256 */
#define EPROM_TYPE_64K 0x40 /* 27512 */
#define EPROM_TYPE_128K 0x80 /* 27010 */
#define PROGMODE_DISABLED 0x00 /* target running, no write access to RAM */
#define PROGMODE_ENABLED 0x01 /* target reset, write access to RAM */
struct multiboot_ops eprog_ops;
struct eprog_privdata
{
char * device;
struct termios oldtio;
int fd;
uint8_t version[32];
uint8_t pagesize_max;
uint8_t eprom_type;
uint8_t pagesize;
int reset_polarity;
uint8_t progmode;
};
struct eprog_type
{
const char name[8];
uint8_t eprom_type;
uint8_t pagesize;
};
static struct eprog_type eprom_types[] =
{
{ "2716", EPROM_TYPE_2K, 0xFF },
{ "2732", EPROM_TYPE_4K, 0xFF },
{ "2764", EPROM_TYPE_8K, 0xFF },
{ "2864", EPROM_TYPE_8K, 0x40 },
{ "27128", EPROM_TYPE_16K, 0xFF },
{ "27256", EPROM_TYPE_32K, 0xFF },
{ "27512", EPROM_TYPE_64K, 0xFF },
{ "27010", EPROM_TYPE_128K, 0xFF },
};
static struct option eprog_optargs[] =
{
{ "device", 1, 0, 'd' }, /* [ -d <device> ] */
{ "reset", 1, 0, 'x' }, /* [ -x <reset polarity> ] */
{ "type", 1, 0, 't' }, /* [ -t <type> ] */
};
/* *************************************************************************
* eprog_optarg_cb
* ************************************************************************* */
static int eprog_optarg_cb(int val, const char *arg, void *privdata)
{
struct eprog_privdata *p_prog = (struct eprog_privdata *)privdata;
switch (val)
{
case 'd': /* device */
if (p_prog->device != NULL)
{
fprintf(stderr, "invalid device: '%s'\n", arg);
return -1;
}
p_prog->device = strdup(optarg);
if (p_prog->device == NULL)
{
perror("strdup()");
return -1;
}
break;
case 'x':
if (strcasecmp(arg, "high") == 0)
{
p_prog->reset_polarity = RESET_POLARITY_HIGH;
}
else if (strcasecmp(arg, "low") == 0)
{
p_prog->reset_polarity = RESET_POLARITY_LOW;
}
else
{
fprintf(stderr, "invalid reset polarity: '%s'\n", arg);
return -1;
}
break;
case 't':
{
unsigned int i;
if (p_prog->eprom_type != 0)
{
fprintf(stderr, "invalid EPROM type: '%s'\n", arg);
return -1;
}
for (i = 0; i < ARRAY_SIZE(eprom_types); i++)
{
if (strcmp(arg, eprom_types[i].name) == 0)
{
p_prog->eprom_type = eprom_types[i].eprom_type;
p_prog->pagesize = eprom_types[i].pagesize;
}
}
if (p_prog->eprom_type == 0)
{
fprintf(stderr, "invalid EPROM type: '%s'\n", arg);
return -1;
}
}
break;
case 'h':
case '?': /* error */
fprintf(stderr, "Usage: eprom_sim [options]\n"
" -d <device> - selects eprom_sim device\n"
" -x <reset polarity> - select 'high' or 'low' active reset\n"
" -t <type> - selects EPROM type (2716 - 27010)\n"
" -r eprom:<file> - reads EPROM to file (.bin | .hex | -)\n"
" -w eprom:<file> - write EPROM from file (.bin | .hex)\n"
" -p <0|1|2> - progress bar mode\n"
"\n"
"Example: eprom_sim -d /dev/ttyUSB0 -t 2764 -r high -w eprom:data.hex\n"
"\n");
return -1;
default:
return 1;
}
return 0;
} /* eprog_optarg_cb */
/* *************************************************************************
* eprog_alloc
* ************************************************************************* */
static struct multiboot * eprog_alloc(void)
{
struct multiboot * mboot = malloc(sizeof(struct multiboot));
if (mboot == NULL)
{
return NULL;
}
memset(mboot, 0x00, sizeof(struct multiboot));
mboot->ops= &eprog_ops;
struct eprog_privdata *p_prog = malloc(sizeof(struct eprog_privdata));
if (p_prog == NULL)
{
free(mboot);
return NULL;
}
memset(p_prog, 0x00, sizeof(struct eprog_privdata));
p_prog->device = NULL;
optarg_register(eprog_optargs, ARRAY_SIZE(eprog_optargs),
eprog_optarg_cb, (void *)p_prog);
mboot->privdata = p_prog;
return mboot;
} /* eprog_alloc */
/* *************************************************************************
* eprog_free
* ************************************************************************* */
static void eprog_free(struct multiboot *mboot)
{
struct eprog_privdata *p_prog = (struct eprog_privdata *)mboot->privdata;
if (p_prog->device != NULL)
{
free(p_prog->device);
}
free(p_prog);
free(mboot);
} /* eprog_free */
/* *************************************************************************
* eprog_get_memtype
* ************************************************************************* */
static int eprog_get_memtype(struct multiboot *mboot,
const char *memname)
{
/* unused parameter */
(void)mboot;
if (strcmp(memname, "eprom") == 0)
{
return MEMTYPE_EPROM;
}
return -1;
} /* eprog_get_memtype */
/* *************************************************************************
* eprog_get_memsize
* ************************************************************************* */
static uint32_t eprog_get_memsize(struct multiboot *mboot,
int memtype)
{
struct eprog_privdata *p_prog = (struct eprog_privdata *)mboot->privdata;
if (memtype != MEMTYPE_EPROM)
{
return 0;
}
return p_prog->eprom_type * 1024;
} /* eprog_get_memsize */
/* *************************************************************************
* eprog_close_device
* ************************************************************************* */
static void eprog_close_device(struct eprog_privdata *p_prog)
{
/* delay close() / tcsetattr() */
usleep(100000);
tcsetattr(p_prog->fd, TCSANOW, &p_prog->oldtio);
close(p_prog->fd);
} /* eprog_close_device */
/* *************************************************************************
* eprog_open_device
* ************************************************************************* */
static int eprog_open_device(struct eprog_privdata *p_prog)
{
p_prog->fd = open(p_prog->device, O_RDWR | O_NOCTTY | O_CLOEXEC);
if (p_prog->fd < 0)
{
perror("open()");
return -1;
}
if (tcgetattr(p_prog->fd, &p_prog->oldtio) < 0)
{
perror("tcgetattr(oldtio)");
close(p_prog->fd);
return -1;
}
struct termios newtio;
memset(&newtio, 0, sizeof(newtio));
newtio.c_iflag |= IGNBRK;
newtio.c_cflag |= SERIAL_BAUDRATE | CS8 | CLOCAL | CREAD;
newtio.c_cc[VMIN] = 1;
newtio.c_cc[VTIME] = 0;
int err = tcsetattr(p_prog->fd, TCSANOW, &newtio);
if (err < 0)
{
perror("tcsetattr(newtio)");
close(p_prog->fd);
return -1;
}
return 0;
} /* eprog_open_device */
/* *************************************************************************
* eprog_serial_read
* ************************************************************************* */
static int eprog_serial_read(int fd, void * data, int size, unsigned int timeout_ms)
{
int pos = 0;
while (1)
{
fd_set fdset;
struct timeval timeout;
struct timeval * p_timeout = NULL;
FD_ZERO(&fdset);
FD_SET(fd, &fdset);
if (timeout_ms != 0)
{
p_timeout = &timeout;
timeout.tv_sec = timeout_ms / 1000;
timeout.tv_usec = (timeout_ms % 1000) * 1000;
}
int ret = select(fd +1, &fdset, NULL, NULL, p_timeout);
if (ret == -1)
{
perror("select");
return -1;
}
else if (ret == 0)
{
break;
}
else if (FD_ISSET(fd, &fdset))
{
int len = read(fd, data + pos, size - pos);
if (len < 0)
{
return -1;
}
else
{
pos += len;
if (pos == size)
{
break;
}
}
}
}
return pos;
} /* eprog_serial_read */
/* *************************************************************************
* eprog_recv
* ************************************************************************* */
static int eprog_recv(int fd, uint8_t msgtype, uint8_t * data, uint8_t length)
{
uint8_t header[2];
uint8_t dummy[64];
int ret = eprog_serial_read(fd, header, sizeof(header), SERIAL_TIMEOUT);
if (ret < (int)sizeof(header))
{
fprintf(stderr, "short read from device (header)\n");
return -1;
}
uint8_t pos = 0;
uint8_t msgsize = header[1];
while (msgsize > 0)
{
if ((data != NULL) && (pos < length))
{
uint8_t readsize = MIN(msgsize, length - pos);
ret = eprog_serial_read(fd, &data[pos], readsize, SERIAL_TIMEOUT);
if (ret <= 0)
{
fprintf(stderr, "short read from device (payload)\n");
return -1;
}
pos += ret;
}
else
{
uint8_t readsize = MIN(msgsize, sizeof(dummy));
ret = eprog_serial_read(fd, &dummy, readsize, SERIAL_TIMEOUT);
if (ret <= 0)
{
fprintf(stderr, "short read from device (dummy)\n");
return -1;
}
}
msgsize -= ret;
}
if (header[0] != msgtype)
{
if ((header[0] == MSGTYPE_ERROR_RSP) && (header[1] == 1))
{
uint8_t error_code = (data != NULL) ? data[0] : dummy[0];
fprintf(stderr, "expected msgtype 0x%x received ERROR_RSP error_code 0x%x\n",
msgtype, error_code);
}
else
{
fprintf(stderr, "wrong msgtype received (0x%x != 0x%x)\n",
header[0], msgtype);
}
return -1;
}
return pos;
} /* eprog_recv */
/* *************************************************************************
* eprog_sync
* ************************************************************************* */
static int eprog_sync(struct eprog_privdata *p_prog)
{
int sync_count = 255;
while (sync_count > 0)
{
/* send only MSGTYPE, no request length! */
uint8_t request[] = { MSGTYPE_SYNC };
uint8_t response[3];
int ret = write(p_prog->fd, request, sizeof(request));
if (ret <= 0)
{
return ret;
}
ret = eprog_serial_read(p_prog->fd, response, sizeof(response), SERIAL_TIMEOUT_SYNC);
if ((ret == sizeof(response)) &&
(response[0] == MSGTYPE_ERROR_RSP) &&
(response[1] == 1) &&
(response[2] == ERROR_UNKNOWN_COMMAND)
)
{
return 0;
}
sync_count--;
}
return -1;
} /* eprog_sync */
/* *************************************************************************
* eprog_get_version
* ************************************************************************* */
static int eprog_get_version(struct eprog_privdata *p_prog,
uint8_t *version, uint8_t length)
{
uint8_t request[] = { MSGTYPE_VERSION_REQ, 0 };
int ret = write(p_prog->fd, request, sizeof(request));
if (ret <= 0)
{
return ret;
}
ret = eprog_recv(p_prog->fd, MSGTYPE_VERSION_RSP, version, length);
if (ret <= 0)
{
return -1;
}
if (ret < length)
{
version[ret] = '\0';
}
else
{
version[length -1] = '\0';
}
return 0;
} /* eprog_get_version */
/* *************************************************************************
* eprog_get_pagesize
* ************************************************************************* */
static int eprog_get_pagesize(struct eprog_privdata *p_prog,
uint8_t *pagesize)
{
uint8_t request[] = { MSGTYPE_PAGESIZE_REQ, 0 };
uint8_t response[1];
int ret = write(p_prog->fd, request, sizeof(request));
if (ret <= 0)
{
return ret;
}
ret = eprog_recv(p_prog->fd, MSGTYPE_PAGESIZE_RSP, response, sizeof(response));
if (ret != sizeof(response))
{
return -1;
}
*pagesize = response[0];
return 0;
} /* eprog_get_pagesize */
/* *************************************************************************
* eprog_set_config
* ************************************************************************* */
static int eprog_set_config(struct eprog_privdata *p_prog,
uint8_t eprom_type,
uint8_t pagesize,
uint8_t reset_polarity)
{
uint8_t request[] = { MSGTYPE_CONFIG_REQ, 3, eprom_type, pagesize, reset_polarity };
int ret = write(p_prog->fd, request, sizeof(request));
if (ret <= 0)
{
return ret;
}
ret = eprog_recv(p_prog->fd, MSGTYPE_CONFIG_RSP, NULL, 0);
if (ret < 0)
{
return ret;
}
return 0;
} /* eprog_set_config */
/* *************************************************************************
* eprog_set_progmode
* ************************************************************************* */
static int eprog_set_progmode(struct eprog_privdata *p_prog,
uint8_t progmode)
{
uint8_t request[] = { MSGTYPE_PROGMODE_REQ, 1, progmode };
int ret = write(p_prog->fd, request, sizeof(request));
if (ret <= 0)
{
return ret;
}
ret = eprog_recv(p_prog->fd, MSGTYPE_PROGMODE_RSP, NULL, 0);
if (ret < 0)
{
return ret;
}
return 0;
} /* eprog_set_progmode */
/* *************************************************************************
* eprog_set_address
* ************************************************************************* */
static int eprog_set_address(struct eprog_privdata *p_prog,
uint32_t address)
{
uint8_t request[] = { MSGTYPE_SETADDRESS_REQ, 3,
(address >> 16) & 0xFF,
(address >> 8) & 0xFF,
(address >> 0) & 0xFF };
int ret = write(p_prog->fd, request, sizeof(request));
if (ret <= 0)
{
return ret;
}
ret = eprog_recv(p_prog->fd, MSGTYPE_SETADDRESS_RSP, NULL, 0);
if (ret < 0)
{
return ret;
}
return 0;
} /* eprog_set_address */
/* *************************************************************************
* eprog_read_data
* ************************************************************************* */
static int eprog_read_data(struct eprog_privdata *p_prog,
uint8_t * data,
uint8_t length)
{
uint8_t request[] = { MSGTYPE_READ_REQ, 1, length };
int ret = write(p_prog->fd, request, sizeof(request));
if (ret <= 0)
{
return ret;
}
ret = eprog_recv(p_prog->fd, MSGTYPE_READ_RSP, data, length);
if (ret < 0)
{
return ret;
}
return 0;
} /* eprog_read_data */
/* *************************************************************************
* eprog_write_data
* ************************************************************************* */
static int eprog_write_data(struct eprog_privdata *p_prog,
const uint8_t * data,
uint8_t length)
{
uint8_t request[] = { MSGTYPE_WRITE_REQ, length };
int ret = write(p_prog->fd, request, sizeof(request));
if (ret <= 0)
{
return ret;
}
ret = write(p_prog->fd, data, length);
if (ret <= 0)
{
return ret;
}
ret = eprog_recv(p_prog->fd, MSGTYPE_WRITE_RSP, NULL, 0);
if (ret < 0)
{
return ret;
}
return 0;
} /* eprog_write_data */
/* *************************************************************************
* eprog_close
* ************************************************************************* */
static int eprog_close(struct multiboot *mboot)
{
struct eprog_privdata *p_prog = (struct eprog_privdata *)mboot->privdata;
if (p_prog->progmode == PROGMODE_ENABLED)
{
eprog_set_progmode(p_prog, PROGMODE_DISABLED);
}
eprog_close_device(p_prog);
return 0;
} /* eprog_close */
/* *************************************************************************
* eprog_open
* ************************************************************************* */
static int eprog_open(struct multiboot *mboot)
{
struct eprog_privdata *p_prog = (struct eprog_privdata *)mboot->privdata;
if (p_prog->device == NULL)
{
fprintf(stderr, "abort: no device given\n");
return -1;
}
if (p_prog->eprom_type == 0)
{
fprintf(stderr, "abort: no EPROM type given\n");
return -1;
}
if (eprog_open_device(p_prog) < 0)
{
return -1;
}
if (eprog_sync(p_prog) < 0)
{
fprintf(stderr, "failed to sync\n");
eprog_close_device(p_prog);
return -1;
}
if (eprog_get_version(p_prog, p_prog->version, sizeof(p_prog->version)) < 0)
{
fprintf(stderr, "failed to get version\n");
eprog_close_device(p_prog);
return -1;
}
if ((eprog_get_pagesize(p_prog, &p_prog->pagesize_max) < 0) ||
(p_prog->pagesize_max == 0)
)
{
fprintf(stderr, "failed to get pagesize\n");
eprog_close_device(p_prog);
return -1;
}
p_prog->pagesize = MIN(p_prog->pagesize, p_prog->pagesize_max);
if (eprog_set_config(p_prog, p_prog->eprom_type, p_prog->pagesize, p_prog->reset_polarity) < 0)
{
fprintf(stderr, "failed to set configuration\n");
eprog_close_device(p_prog);
return -1;
}
if (eprog_set_progmode(p_prog, PROGMODE_ENABLED) < 0)
{
fprintf(stderr, "failed to enter progmode\n");
eprog_close_device(p_prog);
return -1;
}
p_prog->progmode = PROGMODE_ENABLED;
printf("device : %-16s\n",
p_prog->device);
printf("version : %-32s\n",
p_prog->version);
printf("reset polarity : %-4s\n",
p_prog->reset_polarity ? "high" : "low");
printf("EPROM size : 0x%05x (%d)\n",
p_prog->eprom_type * 1024,
p_prog->eprom_type * 1024);
return 0;
} /* eprog_open */
/* *************************************************************************
* eprog_read
* ************************************************************************* */
static int eprog_read(struct multiboot *mboot,
struct databuf *dbuf, int memtype)
{
struct eprog_privdata *p_prog = (struct eprog_privdata *)mboot->privdata;
char *progress_msg = "reading EPROM";
/* unused parameter */
(void)memtype;
uint32_t pos = 0;
uint32_t size = p_prog->eprom_type * 1024;
if (eprog_set_address(p_prog, pos) < 0)
{
fprintf(stderr, "failed to set address\n");
return -1;
}
while (pos < size)
{
mboot->progress_cb(progress_msg, pos, size);
uint8_t len = MIN(p_prog->pagesize_max, size - pos);
if (eprog_read_data(p_prog, dbuf->data + pos, len))
{
mboot->progress_cb(progress_msg, -1, -1);
return -1;
}
pos += len;
}
dbuf->length = pos;
mboot->progress_cb(progress_msg, pos, size);
return 0;
} /* eprog_read */
/* *************************************************************************
* eprog_write
* ************************************************************************* */
static int eprog_write(struct multiboot *mboot,
struct databuf *dbuf,
int memtype)
{
struct eprog_privdata *p_prog = (struct eprog_privdata *)mboot->privdata;
char *progress_msg = "writing EPROM";
/* unused parameter */
(void)memtype;
uint32_t pos = 0;
if (eprog_set_address(p_prog, pos) < 0)
{
fprintf(stderr, "failed to set address\n");
return -1;
}
while (pos < dbuf->length)
{
mboot->progress_cb(progress_msg, pos, dbuf->length);
uint8_t len = MIN(p_prog->pagesize, dbuf->length - pos);
if (eprog_write_data(p_prog, dbuf->data + pos, len))
{
mboot->progress_cb(progress_msg, -1, -1);
return -1;
}
pos += len;
}
mboot->progress_cb(progress_msg, pos, dbuf->length);
return 0;
} /* eprog_write */
/* *************************************************************************
* eprog_verify
* ************************************************************************* */
static int eprog_verify(struct multiboot *mboot,
struct databuf *dbuf, int memtype)
{
struct eprog_privdata *p_prog = (struct eprog_privdata *)mboot->privdata;
char *progress_msg = "verifing EPROM";
/* unused parameter */
(void)memtype;
uint32_t pos = 0;
uint8_t comp[256];
if (eprog_set_address(p_prog, pos) < 0)
{
fprintf(stderr, "failed to set address\n");
return -1;
}
while (pos < dbuf->length)
{
mboot->progress_cb(progress_msg, pos, dbuf->length);
uint8_t len = MIN(p_prog->pagesize, dbuf->length - pos);
if (eprog_read_data(p_prog, comp, len))
{
mboot->progress_cb(progress_msg, -1, -1);
return -1;
}
if (memcmp(comp, dbuf->data + pos, len) != 0x00)
{
mboot->progress_cb(progress_msg, -1, -1);
fprintf(stderr, "verify failed at pos 0x%04x!!\n", pos);
return -1;
}
pos += len;
}
dbuf->length = pos;
mboot->progress_cb(progress_msg, pos, dbuf->length);
return 0;
} /* eprog_verify */
struct multiboot_ops eprog_ops =
{
.exec_name = "eprom_prog",
.alloc = eprog_alloc,
.free = eprog_free,
.get_memtype = eprog_get_memtype,
.get_memsize = eprog_get_memsize,
.open = eprog_open,
.close = eprog_close,
.read = eprog_read,
.write = eprog_write,
.verify = eprog_verify,
};