openwrt/flashrom
1
0
Fork 0
mirror of https://review.coreboot.org/flashrom.git synced 2025-04-27 07:02:34 +02:00
Code Issues Releases Wiki Activity

Support for an external serial flasher protocol

Browse Source 
Supports RS-232, USB serial converters (untested) and TCP streams.

The protocol specification is in serprog-protocol.txt

There will be tweaks to the code and maybe the protocol in the future,
so the API is not set in stone yet.

Corresponding to flashrom svn r656.

Signed-off-by: Urja Rannikko <urjaman@gmail.com>
Acked-by: Carl-Daniel Hailfinger <c-d.hailfinger.devel.2006@gmx.net>
This commit is contained in:
Urja Rannikko 2009-07-21 13:02:59 +00:00 committed by Carl-Daniel Hailfinger
parent 1179377060
commit f3196df7f0
2 changed files with 840 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

101
serprog-protocol.txt Normal file
View File

@ -0,0 +1,101 @@
Serial Flasher Protocol Specification - version 1 (0x01 return value == 1)
Command And Answer Sequence - all commands give an answer.
PC: COMMAND(8bit) <parameters determined by opcode>
DEV: ACK/NAK(8bit) <OPTIONAL RETURN BYTES (only if ACK)> / nothing
Command 0x10 (SYNCNOP) has a special return of NAK+ACK for synchronization.
ACK = 0x06
NAK = 0x15
All multibyte values are little-endian. Addresses and lengths are 24-bit.
COMMAND Description Parameters Return Value
0x00 NOP none ACK
0x01 Query programmer iface version none ACK + 16bit version (nonzero)
0x02 Query supported commands bitmap none ACK + 32 bytes (256 bits) of supported cmds flags
0x03 Query programmer name none ACK + 16 bytes string (null padding) / NAK
0x04 Query serial buffer size none ACK + 16bit size / NAK
0x05 Query supported bustypes none ACK + 8-bit flags (as per flashrom) / NAK
0x06 Query connected address lines none ACK + 8bit line count / NAK
0x07 Query operation buffer size none ACK + 16bit size / NAK
0x08 Query write-n maximum data len none ACK + 24bit maximum length / NAK
0x09 Read byte 24-bit addr ACK + BYTE / NAK
0x0A Read n bytes 24-bit addr + 24-bit length ACK + length bytes / NAK
0x0B Initialize operation buffer none ACK / NAK
0x0C Write to opbuf: Write byte 24-bit addr + 8-bit byte ACK / NAK (NOTE: takes 5 bytes in opbuf)
0x0D Write to opbuf: Write n 24-bit length + 24-bit addr + ACK / NAK (NOTE: takes 7+n bytes in opbuf)
+ length bytes of data
0x0E Write to opbuf: delay 32-bit usecs ACK / NAK (NOTE: takes 5 bytes in opbuf)
0x0F Execute operation buffer none ACK / NAK
0x10 Sync NOP none NAK + ACK (for synchronization)
0x11 Query maximum read-n length none ACK + 24-bit length (0==2^24) / NAK
0x12 Set used bustype 8-bit flags (as with 0x05) ACK / NAK
0x?? unimplemented command - invalid.
Additional information of the above commands:
About unimplemented commands / startup sequence:
Only commands allowed to be used without checking anything are 0x00,0x10 and 0x01 (NOP,SYNCNOP,Q_IFACE).
If 0x01 doesn't return 1, dont do anything if you dont support a newer protocol.
Then, check support for any other opcode (except 0x02) by using 0x02 (Q_CMDMAP).
0x02 (Q_CMDMAP):
The map's bits are mapped as follows:
cmd 0 support: byte 0 bit 0
cmd 1 support: byte 0 bit 1
cmd 7 support: byte 0 bit 7
cmd 8 support: byte 1 bit 0, and so on.
0x04 (Q_SERBUF):
If the programmer has guaranteedly working flow control,
it should return a big bogus value - eg 0xFFFF.
0x05 (Q_BUSTYPE):
The bit's are defined as follows:
bit 0: PARALLEL, bit 1: LPC, bit 2: FWH, bit 3: SPI (if ever supported).
0x06 (Q_CHIPSIZE):
Only applicable to parallel programmers.
An LPC/FHW/SPI-programmer can report this as not supported in the command bitmap.
0x08 (Q_WRNMAXLEN):
If a programmer reports a bigger maximum write-n length than the serial buffer size,
it is assumed that the programmer can process the data fast enough to take in the
reported maximum write-n without problems.
0x0F (O_EXEC):
Execute operation buffer will also clear it, regardless of the return value.
0x11 (Q_RDNMAXLEN):
If this command is not supported, assume return of 0 (2^24).
0x12 (S_BUSTYPE):
Set's the used bustype if the programmer can support more than one flash protocol.
Sending a byte with more than 1 bit set will make the programmer decide among them
on it's own. Bit values as with Q_BUSTYPE.
About mandatory commands:
The only truly mandatory commands for any device are 0x00, 0x01, 0x02 and 0x10,
but one can't really do anything with these commands.
Support for the following commands is necessary for flashrom to operate properly:
S_CMD_Q_SERBUF, S_CMD_Q_OPBUF, S_CMD_Q_WRNMAXLEN, S_CMD_R_BYTE,
S_CMD_R_NBYTES, S_CMD_O_INIT, S_CMD_O_WRITEB, S_CMD_O_WRITEN,
S_CMD_O_DELAY, S_CMD_O_EXEC.
In addition, support for these commands is recommended:
S_CMD_Q_PGMNAME, S_CMD_Q_BUSTYPE, S_CMD_Q_CHIPSIZE (if parallel).
This define listing should help C coders - (it's here to be the single source for copying - will be a .h someday i think)
#define S_ACK 0x06
#define S_NAK 0x15
#define S_CMD_NOP 0x00 /* No operation */
#define S_CMD_Q_IFACE 0x01 /* Query interface version */
#define S_CMD_Q_CMDMAP 0x02 /* Query supported commands bitmap */
#define S_CMD_Q_PGMNAME 0x03 /* Query programmer name */
#define S_CMD_Q_SERBUF 0x04 /* Query Serial Buffer Size */
#define S_CMD_Q_BUSTYPE 0x05 /* Query supported bustypes */
#define S_CMD_Q_CHIPSIZE 0x06 /* Query supported chipsize (2^n format) */
#define S_CMD_Q_OPBUF 0x07 /* Query operation buffer size */
#define S_CMD_Q_WRNMAXLEN 0x08 /* Query Write to opbuf: Write-N maximum lenght */
#define S_CMD_R_BYTE 0x09 /* Read a single byte */
#define S_CMD_R_NBYTES 0x0A /* Read n bytes */
#define S_CMD_O_INIT 0x0B /* Initialize operation buffer */
#define S_CMD_O_WRITEB 0x0C /* Write opbuf: Write byte with address */
#define S_CMD_O_WRITEN 0x0D /* Write to opbuf: Write-N */
#define S_CMD_O_DELAY 0x0E /* Write opbuf: udelay */
#define S_CMD_O_EXEC 0x0F /* Execute operation buffer */
#define S_CMD_SYNCNOP 0x10 /* Special no-operation that returns NAK+ACK */
#define S_CMD_Q_RDNMAXLEN 0x11 /* Query read-n maximum length */
#define S_CMD_S_BUSTYPE 0x12 /* Set used bustype(s). */

740
serprog.c
View File

@ -39,9 +39,747 @@
char *serprog_param = NULL;
#define SERPROG_SUPPORT 0
#define SERPROG_SUPPORT 1
#if SERPROG_SUPPORT == 1
#define MSGHEADER "serprog:"
#define S_ACK 0x06
#define S_NAK 0x15
#define S_CMD_NOP 0x00 /* No operation */
#define S_CMD_Q_IFACE 0x01 /* Query interface version */
#define S_CMD_Q_CMDMAP 0x02 /* Query supported commands bitmap */
#define S_CMD_Q_PGMNAME 0x03 /* Query programmer name */
#define S_CMD_Q_SERBUF 0x04 /* Query Serial Buffer Size */
#define S_CMD_Q_BUSTYPE 0x05 /* Query supported bustypes */
#define S_CMD_Q_CHIPSIZE 0x06 /* Query supported chipsize (2^n format) */
#define S_CMD_Q_OPBUF 0x07 /* Query operation buffer size */
#define S_CMD_Q_WRNMAXLEN 0x08 /* Query opbuf-write-N maximum lenght */
#define S_CMD_R_BYTE 0x09 /* Read a single byte */
#define S_CMD_R_NBYTES 0x0A /* Read n bytes */
#define S_CMD_O_INIT 0x0B /* Initialize operation buffer */
#define S_CMD_O_WRITEB 0x0C /* Write opbuf: Write byte with address */
#define S_CMD_O_WRITEN 0x0D /* Write to opbuf: Write-N */
#define S_CMD_O_DELAY 0x0E /* Write opbuf: udelay */
#define S_CMD_O_EXEC 0x0F /* Execute operation buffer */
#define S_CMD_SYNCNOP 0x10 /* Special no-operation that returns NAK+ACK */
#define S_CMD_Q_RDNMAXLEN 0x11 /* Query read-n maximum length */
#define S_CMD_S_BUSTYPE 0x12 /* Set used bustype(s). */
static int sp_fd;
static uint16_t sp_device_serbuf_size = 16;
static uint16_t sp_device_opbuf_size = 300;
/* Bitmap of supported commands */
static uint8_t sp_cmdmap[32];
/* sp_prev_was_write used to detect writes with continouous addresses
and combine them to write-n's */
static int sp_prev_was_write = 0;
/* sp_write_n_addr used as the starting addr of the currently
combined write-n operation */
static uint32_t sp_write_n_addr;
/* The maximum length of an write_n operation; 0 = write-n not supported */
static uint32_t sp_max_write_n = 0;
/* The maximum length of a read_n operation; 0 = 2^24 */
static uint32_t sp_max_read_n = 0;
/* A malloc'd buffer for combining the operation's data
and a counter that tells how much data is there. */
static uint8_t *sp_write_n_buf;
static uint32_t sp_write_n_bytes = 0;
/* sp_streamed_* used for flow control checking */
static int sp_streamed_transmit_ops = 0;
static int sp_streamed_transmit_bytes = 0;
/* sp_opbuf_usage used for counting the amount of
on-device operation buffer used */
static int sp_opbuf_usage = 0;
/* if true causes sp_docommand to automatically check
whether the command is supported before doing it */
static int sp_check_avail_automatic = 0;
static void sp_die(char *msg)
{
perror(msg);
exit(1);
}
static int sp_opensocket(char *ip, unsigned int port)
{
int flag = 1;
struct hostent *hostPtr = NULL;
struct sockaddr_in sp;
int sock;
printf_debug(MSGHEADER "IP %s port %d\n", ip, port);
sock = socket(PF_INET, SOCK_STREAM, IPPROTO_TCP);
if (sock < 0)
sp_die("Error: serprog cannot open socket");
hostPtr = gethostbyname(ip);
if (NULL == hostPtr) {
hostPtr = gethostbyaddr(ip, strlen(ip), AF_INET);
if (NULL == hostPtr)
sp_die("Error: cannot resolve");
}
memset(&sp, 0, sizeof(sp));
sp.sin_family = AF_INET;
sp.sin_port = htons(port);
(void)memcpy(&sp.sin_addr, hostPtr->h_addr, hostPtr->h_length);
if (connect(sock, (struct sockaddr *)&sp, sizeof(sp)) < 0) {
close(sock);
sp_die("Error: serprog cannot connect");
}
/* We are latency limited, and sometimes do write-write-read *
* (write-n) - so enable TCP_NODELAY. */
setsockopt(sock, IPPROTO_TCP, TCP_NODELAY, &flag, sizeof(int));
return sock;
}
struct baudentry {
int flag;
unsigned int baud;
};
/* I'd like if the C preprocessor could have directives in macros */
#define BAUDENTRY(baud) { B##baud, baud },
static const struct baudentry sp_baudtable[] = {
BAUDENTRY(9600)
BAUDENTRY(19200)
BAUDENTRY(38400)
BAUDENTRY(57600)
BAUDENTRY(115200)
#ifdef B230400
BAUDENTRY(230400)
#endif
#ifdef B460800
BAUDENTRY(460800)
#endif
#ifdef B500000
BAUDENTRY(500000)
#endif
#ifdef B576000
BAUDENTRY(576000)
#endif
#ifdef B921600
BAUDENTRY(921600)
#endif
#ifdef B1000000
BAUDENTRY(1000000)
#endif
#ifdef B1152000
BAUDENTRY(1152000)
#endif
#ifdef B1500000
BAUDENTRY(1500000)
#endif
#ifdef B2000000
BAUDENTRY(2000000)
#endif
#ifdef B2500000
BAUDENTRY(2500000)
#endif
#ifdef B3000000
BAUDENTRY(3000000)
#endif
#ifdef B3500000
BAUDENTRY(3500000)
#endif
#ifdef B4000000
BAUDENTRY(4000000)
#endif
{0, 0} /* Terminator */
};
static int sp_openserport(char *dev, unsigned int baud)
{
struct termios options;
int fd, i;
fd = open(dev, O_RDWR | O_NOCTTY | O_NDELAY);
if (fd < 0)
sp_die("Error: cannot open serial port");
fcntl(fd, F_SETFL, 0);
tcgetattr(fd, &options);
for (i = 0;; i++) {
if (sp_baudtable[i].baud == 0) {
close(fd);
fprintf(stderr,
"Error: cannot configure for baudrate %d\n",
baud);
exit(1);
}
if (sp_baudtable[i].baud == baud) {
cfsetispeed(&options, sp_baudtable[i].flag);
cfsetospeed(&options, sp_baudtable[i].flag);
break;
}
}
options.c_cflag &= ~PARENB;
options.c_cflag &= ~CSTOPB;
options.c_cflag &= ~CSIZE;
options.c_cflag |= CS8;
options.c_cflag &= ~CRTSCTS;
options.c_lflag &= ~(ICANON | ECHO | ECHOE | ISIG);
options.c_iflag &= ~(IXON | IXOFF | IXANY | ICRNL | IGNCR | INLCR);
options.c_oflag &= ~OPOST;
options.c_cflag |= (CLOCAL | CREAD);
tcsetattr(fd, TCSANOW, &options);
return fd;
}
static void sp_flush_incoming(void)
{
int i;
for (i=0;i<100;i++) { /* In case the device doesnt do EAGAIN, just read 0 */
unsigned char flush[16];
ssize_t rv;
rv = read(sp_fd, flush, sizeof(flush));
if ((rv == -1) && (errno == EAGAIN))
break;
if (rv == -1)
sp_die("flush read");
}
return;
}
static int sp_sync_read_timeout(int loops)
{
int i;
unsigned char c;
for (i = 0; i < loops; i++) {
ssize_t rv;
rv = read(sp_fd, &c, 1);
if (rv == 1)
return c;
if ((rv == -1) && (errno != EAGAIN))
sp_die("read");
usleep(10 * 1000); /* 10ms units */
}
return -1;
}
/* Synchronize: a bit tricky algorhytm that tries to (and in my tests has *
* always succeeded in) bring the serial protocol to known waiting-for- *
* command state - uses nonblocking read - rest of the driver uses *
* blocking read - TODO: add an alarm() timer for the rest of the app on *
* serial operations, though not such a big issue as the first thing to *
* do is synchronize (eg. check that device is alive). */
static void sp_synchronize(void)
{
int i;
int flags = fcntl(sp_fd, F_GETFL);
unsigned char buf[8];
flags |= O_NONBLOCK;
fcntl(sp_fd, F_SETFL, flags);
/* First sends 8 NOPs, then flushes the return data - should cause *
* the device serial parser to get to a sane state, unless if it *
* is waiting for a real long write-n. */
memset(buf, S_CMD_NOP, 8);
if (write(sp_fd, buf, 8) != 8)
sp_die("flush write");
/* A second should be enough to get all the answers to the buffer */
usleep(1000 * 1000);
sp_flush_incoming();
/* Then try upto 8 times to send syncnop and get the correct special *
* return of NAK+ACK. Timing note: upto 10 characters, 10*50ms = *
* upto 500ms per try, 8*0.5s = 4s; +1s (above) = upto 5s sync *
* attempt, ~1s if immediate success. */
for (i = 0; i < 8; i++) {
int n;
unsigned char c = S_CMD_SYNCNOP;
if (write(sp_fd, &c, 1) != 1)
sp_die("sync write");
printf_debug(".");
fflush(stdout);
for (n = 0; n < 10; n++) {
c = sp_sync_read_timeout(5); /* wait upto 50ms */
if (c != S_NAK)
continue;
c = sp_sync_read_timeout(2);
if (c != S_ACK)
continue;
c = S_CMD_SYNCNOP;
if (write(sp_fd, &c, 1) != 1)
sp_die("sync write");
c = sp_sync_read_timeout(50);
if (c != S_NAK)
break; /* fail */
c = sp_sync_read_timeout(10);
if (c != S_ACK)
break; /* fail */
/* Ok, synchronized; back to blocking reads and return. */
flags &= ~O_NONBLOCK;
fcntl(sp_fd, F_SETFL, flags);
printf_debug("\n");
return;
}
}
fprintf(stderr,
"Error: cannot synchronize protocol\n"
"- check communications and reset device?\n");
exit(1);
}
static int sp_check_commandavail(uint8_t command)
{
int byteoffs, bitoffs;
byteoffs = command / 8;
bitoffs = command % 8;
return (sp_cmdmap[byteoffs] & (1 << bitoffs)) ? 1 : 0;
}
static int sp_automatic_cmdcheck(uint8_t cmd)
{
if ((sp_check_avail_automatic) && (sp_check_commandavail(cmd) == 0)) {
printf_debug ("Warning: Automatic command availability check"
" failed for cmd %d - wont execute cmd\n",cmd);
return 1;
}
return 0;
}
static int sp_docommand(uint8_t command, uint32_t parmlen,
uint8_t * params, uint32_t retlen, void *retparms)
{
unsigned char *sendpacket;
unsigned char c;
if (sp_automatic_cmdcheck(command))
return 1;
sendpacket = malloc(1 + parmlen);
if (!sendpacket)
sp_die("Error: cannot malloc command buffer");
sendpacket[0] = command;
memcpy(&(sendpacket[1]), params, parmlen);
if (write(sp_fd, sendpacket, 1 + parmlen) != (1 + parmlen)) {
sp_die("Error: cannot write command");
}
free(sendpacket);
if (read(sp_fd, &c, 1) != 1)
sp_die("Error: cannot read from device");
if (c == S_NAK) return 1;
if (c != S_ACK) {
fprintf(stderr,
"Error: invalid response 0x%02X from device\n",c);
exit(1);
}
if (retlen) {
int rd_bytes = 0;
do {
int r;
r = read(sp_fd, retparms + rd_bytes,
retlen - rd_bytes);
if (r <= 0) sp_die
("Error: cannot read return parameters");
rd_bytes += r;
} while (rd_bytes != retlen);
}
return 0;
}
static void sp_flush_stream(void)
{
if (sp_streamed_transmit_ops)
do {
unsigned char c;
if (read(sp_fd, &c, 1) != 1) {
sp_die
("Error: cannot read from device (flushing stream)");
}
if (c == S_NAK) {
fprintf(stderr,
"Error: NAK to a stream buffer operation\n");
exit(1);
}
if (c != S_ACK) {
fprintf(stderr,
"Error: Invalid reply 0x%02X from device\n",
c);
exit(1);
}
} while (--sp_streamed_transmit_ops);
sp_streamed_transmit_ops = 0;
sp_streamed_transmit_bytes = 0;
}
static int sp_stream_buffer_op(uint8_t cmd, uint32_t parmlen, uint8_t * parms)
{
uint8_t *sp;
if (sp_automatic_cmdcheck(cmd))
return 1;
sp = malloc(1 + parmlen);
if (!sp) sp_die("Error: cannot malloc command buffer");
sp[0] = cmd;
memcpy(&(sp[1]), parms, parmlen);
if (sp_streamed_transmit_bytes >= (1 + parmlen + sp_device_serbuf_size))
sp_flush_stream();
if (write(sp_fd, sp, 1 + parmlen) != (1 + parmlen))
sp_die("Error: cannot write command");
free(sp);
sp_streamed_transmit_ops += 1;
sp_streamed_transmit_bytes += 1 + parmlen;
return 0;
}
int serprog_init(void)
{
uint16_t iface;
int len;
unsigned char pgmname[17];
unsigned char rbuf[3];
unsigned char c;
char *num;
char *dev;
printf_debug("%s\n", __func__);
/* the parameter is either of format "/dev/device:baud" or "ip:port" */
if ((!serprog_param) || (!strlen(serprog_param))) {
nodevice:
fprintf(stderr,
"Error: No device/host given for the serial programmer driver.\n"
"Use flashrom -p serprog=/dev/device:baud or flashrom -p serprog=ip:port\n");
exit(1);
}
num = strstr(serprog_param, ":");
len = num - serprog_param;
if (!len) goto nodevice;
if (!num) {
fprintf(stderr,
"Error: No port or baudrate specified to serial programmer driver.\n"
"Use flashrom -p serprog=/dev/device:baud or flashrom -p serprog=ip:port\n");
exit(1);
}
len = num - serprog_param;
dev = malloc(len + 1);
if (!dev) sp_die("Error: memory allocation failure");
memcpy(dev, serprog_param, len);
dev[len] = 0;
num = strdup(num + 1);
if (!num) sp_die("Error: memory allocation failure");
free(serprog_param);
serprog_param = NULL;
if (dev[0] == '/') sp_fd = sp_openserport(dev, atoi(num));
else sp_fd = sp_opensocket(dev, atoi(num));
free(dev); dev = NULL;
free(num); num = NULL;
printf_debug(MSGHEADER "connected - attempting to synchronize\n");
sp_check_avail_automatic = 0;
sp_synchronize();
printf_debug(MSGHEADER "Synchronized\n");
if (sp_docommand(S_CMD_Q_IFACE, 0, NULL, 2, &iface)) {
fprintf(stderr, "Error: NAK to Query Interface version\n");
exit(1);
}
if (iface != 1) {
fprintf(stderr, "Error: Unknown interface version %d\n", iface);
exit(1);
}
printf_debug(MSGHEADER "Interface version ok.\n");
if (sp_docommand(S_CMD_Q_CMDMAP, 0, NULL, 32, sp_cmdmap)) {
fprintf(stderr, "Error: query command map not supported\n");
exit(1);
}
sp_check_avail_automatic = 1;
/* Check for the minimum operational set of commands */
if (sp_check_commandavail(S_CMD_R_BYTE) == 0) {
fprintf(stderr, "Error: Single byte read not supported\n");
exit(1);
}
/* This could be translated to single byte reads (if missing), *
* but now we dont support that. */
if (sp_check_commandavail(S_CMD_R_NBYTES) == 0) {
fprintf(stderr, "Error: Read n bytes not supported\n");
exit(1);
}
/* In the future one could switch to read-only mode if these *
* are not available. */
if (sp_check_commandavail(S_CMD_O_INIT) == 0) {
fprintf(stderr,
"Error: Initialize operation buffer not supported\n");
exit(1);
}
if (sp_check_commandavail(S_CMD_O_WRITEB) == 0) {
fprintf(stderr,
"Error: Write to opbuf: write byte not supported\n");
exit(1);
}
if (sp_check_commandavail(S_CMD_O_DELAY) == 0) {
fprintf(stderr, "Error: Write to opbuf: delay not supported\n");
exit(1);
}
if (sp_check_commandavail(S_CMD_O_EXEC) == 0) {
fprintf(stderr,
"Error: Execute operation buffer not supported\n");
exit(1);
}
if (sp_docommand(S_CMD_Q_PGMNAME, 0, NULL, 16, pgmname)) {
fprintf(stderr, "Warning: NAK to query programmer name\n");
strcpy((char *)pgmname, "(unknown)");
}
pgmname[16] = 0;
printf(MSGHEADER "Programmer name \"%s\"\n", pgmname);
if (sp_docommand(S_CMD_Q_SERBUF, 0, NULL, 2, &sp_device_serbuf_size)) {
fprintf(stderr, "Warning: NAK to query serial buffer size\n");
}
printf_debug(MSGHEADER "serial buffer size %d\n",
sp_device_serbuf_size);
if (sp_docommand(S_CMD_Q_OPBUF, 0, NULL, 2, &sp_device_opbuf_size)) {
fprintf(stderr,
"Warning: NAK to query operation buffer size\n");
}
printf_debug(MSGHEADER "operation buffer size %d\n",
sp_device_opbuf_size);
if (sp_docommand(S_CMD_Q_BUSTYPE, 0, NULL, 1, &c)) {
fprintf(stderr, "Warning: NAK to query supported buses\n");
c = CHIP_BUSTYPE_NONSPI; /* A reasonable default for now. */
}
buses_supported = c;
if (sp_docommand(S_CMD_O_INIT, 0, NULL, 0, NULL)) {
fprintf(stderr, "Error: NAK to initialize operation buffer\n");
exit(1);
}
if (sp_docommand(S_CMD_Q_WRNMAXLEN, 0, NULL, 3, rbuf)) {
printf_debug(MSGHEADER "Write-n not supported");
sp_max_write_n = 0;
} else {
sp_max_write_n = ((unsigned int)(rbuf[0]) << 0);
sp_max_write_n |= ((unsigned int)(rbuf[1]) << 8);
sp_max_write_n |= ((unsigned int)(rbuf[2]) << 16);
printf_debug(MSGHEADER "Maximum write-n length %d\n",
sp_max_write_n);
sp_write_n_buf = malloc(sp_max_write_n);
if (!sp_write_n_buf) {
fprintf(stderr,
"Error: cannot allocate memory for Write-n buffer\n");
exit(1);
}
sp_write_n_bytes = 0;
}
if ((sp_check_commandavail(S_CMD_Q_RDNMAXLEN))
&&((sp_docommand(S_CMD_Q_RDNMAXLEN,0,NULL, 3, rbuf) == 0))) {
sp_max_read_n = ((unsigned int)(rbuf[0]) << 0);
sp_max_read_n |= ((unsigned int)(rbuf[1]) << 8);
sp_max_read_n |= ((unsigned int)(rbuf[2]) << 16);
printf_debug(MSGHEADER "Maximum read-n length %d\n",
sp_max_read_n ? sp_max_read_n : (1<<24));
} else {
printf_debug(MSGHEADER "Maximum read-n length not reported\n");
sp_max_read_n = 0;
}
sp_prev_was_write = 0;
sp_streamed_transmit_ops = 0;
sp_streamed_transmit_bytes = 0;
sp_opbuf_usage = 0;
return 0;
}
/* Move an in flashrom buffer existing write-n operation to *
* the on-device operation buffer. */
static void sp_pass_writen(void)
{
unsigned char header[7];
printf_debug(MSGHEADER "Passing write-n bytes=%d addr=0x%x\n",
sp_write_n_bytes, sp_write_n_addr);
if (sp_streamed_transmit_bytes >=
(7 + sp_write_n_bytes + sp_device_serbuf_size))
sp_flush_stream();
/* In case it's just a single byte send it as a single write. */
if (sp_write_n_bytes == 1) {
sp_write_n_bytes = 0;
header[0] = (sp_write_n_addr >> 0) & 0xFF;
header[1] = (sp_write_n_addr >> 8) & 0xFF;
header[2] = (sp_write_n_addr >> 16) & 0xFF;
header[3] = sp_write_n_buf[0];
sp_stream_buffer_op(S_CMD_O_WRITEB, 4, header);
sp_opbuf_usage += 5;
return;
}
header[0] = S_CMD_O_WRITEN;
header[1] = (sp_write_n_bytes >> 0) & 0xFF;
header[2] = (sp_write_n_bytes >> 8) & 0xFF;
header[3] = (sp_write_n_bytes >> 16) & 0xFF;
header[4] = (sp_write_n_addr >> 0) & 0xFF;
header[5] = (sp_write_n_addr >> 8) & 0xFF;
header[6] = (sp_write_n_addr >> 16) & 0xFF;
if (write(sp_fd, header, 7) != 7)
sp_die("Error: cannot write write-n command\n");
if (write(sp_fd, sp_write_n_buf, sp_write_n_bytes) !=
sp_write_n_bytes)
sp_die("Error: cannot write write-n data");
sp_streamed_transmit_bytes += 7 + sp_write_n_bytes;
sp_streamed_transmit_ops += 1;
sp_opbuf_usage += 7 + sp_write_n_bytes;
sp_write_n_bytes = 0;
sp_prev_was_write = 0;
}
static void sp_execute_opbuf_noflush(void)
{
if ((sp_max_write_n) && (sp_write_n_bytes))
sp_pass_writen();
sp_stream_buffer_op(S_CMD_O_EXEC, 0, 0);
printf_debug(MSGHEADER "Executed operation buffer of %d bytes\n",
sp_opbuf_usage);
sp_opbuf_usage = 0;
sp_prev_was_write = 0;
return;
}
static void sp_execute_opbuf(void)
{
sp_execute_opbuf_noflush();
sp_flush_stream();
}
int serprog_shutdown(void)
{
printf_debug("%s\n", __func__);
if ((sp_opbuf_usage) || (sp_max_write_n && sp_write_n_bytes))
sp_execute_opbuf();
close(sp_fd);
if (sp_max_write_n)
free(sp_write_n_buf);
return 0;
}
static void sp_check_opbuf_usage(int bytes_to_be_added)
{
if (sp_device_opbuf_size <= (sp_opbuf_usage + bytes_to_be_added)) {
sp_execute_opbuf();
/* If this happens in the mid of an page load the page load *
* will propably fail. */
printf_debug(MSGHEADER
"Warning: executed operation buffer due to size reasons\n");
}
}
void serprog_chip_writeb(uint8_t val, chipaddr addr)
{
printf_debug("%s\n", __func__);
if (sp_max_write_n) {
if ((sp_prev_was_write)
&& (addr == (sp_write_n_addr + sp_write_n_bytes))) {
sp_write_n_buf[sp_write_n_bytes++] = val;
} else {
if ((sp_prev_was_write) && (sp_write_n_bytes))
sp_pass_writen();
sp_prev_was_write = 1;
sp_write_n_addr = addr;
sp_write_n_bytes = 1;
sp_write_n_buf[0] = val;
}
sp_check_opbuf_usage(7 + sp_write_n_bytes);
if (sp_write_n_bytes >= sp_max_write_n)
sp_pass_writen();
} else {
/* We will have to do single writeb ops. */
unsigned char writeb_parm[4];
sp_check_opbuf_usage(6);
writeb_parm[0] = (addr >> 0) & 0xFF;
writeb_parm[1] = (addr >> 8) & 0xFF;
writeb_parm[2] = (addr >> 16) & 0xFF;
writeb_parm[3] = val;
sp_stream_buffer_op(S_CMD_O_WRITEB, 4, writeb_parm);
sp_opbuf_usage += 5;
}
}
uint8_t serprog_chip_readb(const chipaddr addr)
{
unsigned char c;
unsigned char buf[3];
/* Will stream the read operation - eg. add it to the stream buffer, *
* then flush the buffer, then read the read answer. */
if ((sp_opbuf_usage) || (sp_max_write_n && sp_write_n_bytes))
sp_execute_opbuf_noflush();
buf[0] = ((addr >> 0) & 0xFF);
buf[1] = ((addr >> 8) & 0xFF);
buf[2] = ((addr >> 16) & 0xFF);
sp_stream_buffer_op(S_CMD_R_BYTE, 3, buf);
sp_flush_stream();
if (read(sp_fd, &c, 1) != 1)
sp_die("readb byteread");
printf_debug("%s addr=0x%lx returning 0x%02X\n", __func__, addr, c);
return c;
}
/* Local version that really does the job, doesnt care of max_read_n. */
static void sp_do_read_n(uint8_t * buf, const chipaddr addr, size_t len)
{
int rd_bytes = 0;
unsigned char sbuf[6];
printf_debug("%s: addr=0x%lx len=%lu\n", __func__, addr, (unsigned long)len);
/* Stream the read-n -- as above. */
if ((sp_opbuf_usage) || (sp_max_write_n && sp_write_n_bytes))
sp_execute_opbuf_noflush();
sbuf[0] = ((addr >> 0) & 0xFF);
sbuf[1] = ((addr >> 8) & 0xFF);
sbuf[2] = ((addr >> 16) & 0xFF);
sbuf[3] = ((len >> 0) & 0xFF);
sbuf[4] = ((len >> 8) & 0xFF);
sbuf[5] = ((len >> 16) & 0xFF);
sp_stream_buffer_op(S_CMD_R_NBYTES, 6, sbuf);
sp_flush_stream();
do {
int r = read(sp_fd, buf + rd_bytes, len - rd_bytes);
if (r <= 0)
sp_die("Error: cannot read read-n data");
rd_bytes += r;
} while (rd_bytes != len);
return;
}
/* The externally called version that makes sure that max_read_n is obeyed. */
void serprog_chip_readn(uint8_t * buf, const chipaddr addr, size_t len)
{
size_t lenm = len;
chipaddr addrm = addr;
while ((sp_max_read_n)&&(lenm > sp_max_read_n)) {
sp_do_read_n(&(buf[addrm-addr]),addrm,sp_max_read_n);
addrm += sp_max_read_n;
lenm -= sp_max_read_n;
}
if (lenm) sp_do_read_n(&(buf[addrm-addr]),addrm,lenm);
}
void serprog_delay(int delay)
{
unsigned char buf[4];
printf_debug("%s\n", __func__);
if ((sp_max_write_n) && (sp_write_n_bytes))
sp_pass_writen();
sp_check_opbuf_usage(5);
buf[0] = ((delay >> 0) & 0xFF);
buf[1] = ((delay >> 8) & 0xFF);
buf[2] = ((delay >> 16) & 0xFF);
buf[3] = ((delay >> 24) & 0xFF);
sp_stream_buffer_op(S_CMD_O_DELAY, 4, buf);
sp_opbuf_usage += 5;
sp_prev_was_write = 0;
}
#else
int serprog_init(void)
{
fprintf(stderr, "Serial programmer support was not compiled in\n");