[coreboot] [flashrom] [PATCH] external serial flasher protocol support

Urja Rannikko urjaman at gmail.com
Sun Jun 14 20:23:33 CEST 2009


Support for an external serial flasher protocol.
Supports RS-232, USB serial converters (untested) and TCP streams.

Signed-off-by: Urja Rannikko <urjaman at gmail.com>

---
I'm repeating myself, but:
Please commit my jedec.c chip_readb to chip_readn patch (or carldani's version
that i've only heard of in IRC) before this
 - they're not dependent but without that patch this protocol is awfully slow.

Also attached is a simple specification of the protocol this code
implements, changed values for ACK and NAK, changed SYNCNOP to NOP,
added 0x10 = SYNCNOP.

Again, also attached the AVR parser code. Same disclaimers as previously.

Remember to svn add serprog.c if going to commit.

also, patch inlined:
Index: flash.h
===================================================================
--- flash.h	(revision 589)
+++ flash.h	(working copy)
@@ -85,6 +85,7 @@
 #define PROGRAMMER_NIC3COM	0x02
 #define PROGRAMMER_SATASII	0x03
 #define PROGRAMMER_IT87SPI	0x04
+#define PROGRAMMER_SERPROG	0x05

 struct programmer_entry {
 	const char *vendor;
@@ -918,4 +919,12 @@
 int erase_stm50flw0x0x(struct flashchip *flash);
 int write_stm50flw0x0x(struct flashchip *flash, uint8_t *buf);

+/* serprog.c */
+extern char* serprog_param;
+int serprog_init(void);
+int serprog_shutdown(void);
+void serprog_chip_writeb(uint8_t val, chipaddr addr);
+uint8_t serprog_chip_readb(const chipaddr addr);
+void serprog_chip_readn(uint8_t *buf, const chipaddr addr, size_t len);
+void serprog_delay(int delay);
 #endif				/* !__FLASH_H__ */
Index: serprog.c
===================================================================
--- serprog.c	(revision 0)
+++ serprog.c	(revision 0)
@@ -0,0 +1,646 @@
+/*
+ * This file is part of the flashrom project.
+ *
+ * Copyright (C) 2009 Urja Rannikko <urjaman at gmail.com>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
+ */
+
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <arpa/inet.h>
+#include <netinet/in.h>
+#include <netinet/tcp.h>
+#include <netdb.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <inttypes.h>
+#include <termios.h>
+#include "flash.h"
+
+#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 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	*/
+
+int serprog_fd;
+char *serprog_param = NULL;
+
+uint16_t sp_device_serbuf_size = 16;
+uint16_t sp_device_opbuf_size = 300;
+/* a bit map of supported commands */
+uint8_t sp_cmdmap[32];
+
+/* sp_prev_was_write used to detect writes with continouous addresses
and combine them to write-n's */
+int sp_prev_was_write = 0;
+/* sp_write_n_addr used as the starting addr of the currently
combined write-n operation */
+uint32_t sp_write_n_addr;
+/* The maximum length of an write_n operation on the device - 0 = not
supported at all */
+uint32_t sp_write_n_support = 0;
+/* A malloc'd buffer for combining the operation's data and a counter
that tells how much data is there */
+uint8_t* sp_write_n_buf;
+uint32_t sp_write_n_bytes = 0;
+
+/* sp_streamed_* used for flow control checking */
+int sp_streamed_transmit_ops = 0;
+int sp_streamed_transmit_bytes = 0;
+/* sp_opbuf_usage used for counting the amount of on-device operation
buffer used */
+int sp_opbuf_usage = 0;
+/* if true causes serprog_docommand to automatically check whether
the command is supported before doing it */
+int sp_check_avail_automatic = 0;
+
+
+static void serprog_die(char* msg) {
+	perror(msg);
+	exit(1);
+}
+
+static int serprog_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) serprog_die("Error: serprog cannot open socket");
+	hostPtr = gethostbyname(ip);
+	if (NULL == hostPtr) {
+		hostPtr = gethostbyaddr(ip,strlen(ip),AF_INET);
+		if (NULL == hostPtr) serprog_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);
+		serprog_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 },
+const struct baudentry 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 serprog_openserport(char* dev, unsigned int baud) {
+	struct termios options;
+	int fd,i;
+	fd = open(dev,O_RDWR|O_NOCTTY|O_NDELAY);
+	if (fd<0) serprog_die("Error: cannot open serial port");
+	fcntl(fd, F_SETFL, 0);
+	tcgetattr(fd,&options);
+	for(i=0;;i++) {
+		if (baudtable[i].baud == 0) {
+			close(fd);
+			fprintf(stderr,"Error: cannot configure for baudrate %d\n",baud);
+			exit(1);
+		}
+		if (baudtable[i].baud == baud) {
+			cfsetispeed(&options, baudtable[i].flag);
+			cfsetospeed(&options, 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);
+	options.c_oflag &= ~OPOST;
+	options.c_cflag |= (CLOCAL | CREAD);
+	tcsetattr(fd, TCSANOW, &options);
+	return fd;
+}
+
+static void serprog_flush_incoming(void) {
+	for(;;) {
+		unsigned char flush[16];
+		ssize_t rv;
+		rv = read(serprog_fd,flush,sizeof(flush));
+		if ((rv == -1)&&(errno == EAGAIN)) break;
+		if (rv == -1) serprog_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(serprog_fd,&c,1);
+		if (rv == 1) return c;
+		if ((rv == -1)&&(errno != EAGAIN)) serprog_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 serprog_synchronize(void) {
+	int i;
+	int flags = fcntl(serprog_fd,F_GETFL);
+	unsigned char buf[8];
+	flags |= O_NONBLOCK;
+	fcntl(serprog_fd,F_SETFL,flags);
+	serprog_flush_incoming();
+	printf_debug("Flushed incoming data - now syncing\n");
+	/* 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(serprog_fd,buf,8) != 8) serprog_die("flush write");
+	usleep(1000 * 1000); /* A second should be enough to get all the
answers to the buffer */
+	serprog_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(serprog_fd,&c,1) != 1) serprog_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(serprog_fd,&c,1) != 1) serprog_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(serprog_fd,F_SETFL,flags);
+			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;
+	if (sp_cmdmap[byteoffs] & (1<<bitoffs)) return 1;
+	return 0;
+}
+
+static int sp_automatic_cmdcheck(uint8_t cmd) {
+	if (sp_check_avail_automatic) if (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 serprog_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) serprog_die("Error: cannot malloc command buffer");
+	sendpacket[0] = command;
+	memcpy(&(sendpacket[1]),params,parmlen);
+	if (write(serprog_fd,sendpacket,1+parmlen) != (1+parmlen))
serprog_die("Error: cannot write command");
+	free(sendpacket);
+	if (read(serprog_fd,&c,1) != 1) serprog_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 = read(serprog_fd,retparms+rd_bytes,retlen-rd_bytes);
+			if (r <= 0) serprog_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(serprog_fd,&c,1) != 1) serprog_die("Error: cannot read
from device (flushing stream)");
+		if (c == S_NAK) {
+			fprintf(stderr,"Error: NAK to some 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) serprog_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(serprog_fd,sp,1+parmlen) != (1+parmlen))
serprog_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) serprog_die("Error: memory allocation failure");
+	memcpy(dev,serprog_param,len);
+	dev[len] = 0;
+	num = strdup(num+1);
+	if (!num) serprog_die("Error: memory allocation failure");
+	free (serprog_param);
+	serprog_param = NULL;
+		
+	if (dev[0] == '/') serprog_fd = serprog_openserport(dev,atoi(num));
+	else serprog_fd = serprog_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;
+
+	serprog_synchronize();
+
+	printf_debug(MSGHEADER "Synchronized\n");
+
+	if (serprog_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 (serprog_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 (serprog_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 (serprog_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 (serprog_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 (serprog_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 (serprog_docommand(S_CMD_O_INIT,0,NULL,0,NULL)) {
+		fprintf(stderr,"Error: NAK to initialize operation buffer\n");
+		exit(1);
+	}
+
+	if (serprog_docommand(S_CMD_Q_WRNMAXLEN,0,NULL,3,rbuf)) {
+		printf_debug(MSGHEADER "Write-n not supported");
+		sp_write_n_support = 0;
+	} else {
+		sp_write_n_support = ((unsigned int)(rbuf[0]) << 0);
+		sp_write_n_support |= ((unsigned int)(rbuf[1]) << 8);
+		sp_write_n_support |= ((unsigned int)(rbuf[2]) << 16);
+		printf_debug(MSGHEADER "Maximum write-n length %d\n",sp_write_n_support);
+		sp_write_n_buf = malloc(sp_write_n_support);
+		if (!sp_write_n_buf) {
+			fprintf(stderr,"Error: cannot allocate memory for Write-n buffer\n");
+			exit(1);
+		}
+		sp_write_n_bytes = 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 on-device
operation buffer */
+static void serprog_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();
+	if (sp_write_n_bytes == 1) { /* In case it's just a single byte send
it as a single write */
+		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 += 6;
+		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(serprog_fd,header,7) != 7) serprog_die("Error: cannot
write write-n command\n");
+	if (write(serprog_fd,sp_write_n_buf,sp_write_n_bytes) !=
sp_write_n_bytes) serprog_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 serprog_execute_opbuf_noflush(void) {
+	if ((sp_write_n_support)&&(sp_write_n_bytes)) serprog_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 serprog_execute_opbuf(void) {
+	serprog_execute_opbuf_noflush();
+	sp_flush_stream();
+}
+
+int serprog_shutdown(void) {
+	printf_debug("%s\n", __func__);
+	if ((sp_opbuf_usage)||(sp_write_n_support&&sp_write_n_bytes))
serprog_execute_opbuf();
+	close(serprog_fd);
+	if (sp_write_n_support) 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)) {
+		serprog_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_write_n_support) {
+		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)) serprog_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_write_n_support) serprog_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 += 6;	
+	}
+}
+
+
+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_write_n_support&&sp_write_n_bytes))
serprog_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(serprog_fd,&c,1) != 1) serprog_die("readb byteread");
+	printf_debug("%s addr=0x%lx returning 0x%02X\n", __func__,addr,c);
+	return c;
+}
+
+
+void serprog_chip_readn(uint8_t *buf, const chipaddr addr, size_t len) {
+	int rd_bytes = 0;
+	unsigned char sbuf[6];
+	printf_debug("%s: addr=0x%lx len=%d\n", __func__,addr,len);
+	/* Stream the read-n -- as above. */
+	if ((sp_opbuf_usage)||(sp_write_n_support&&sp_write_n_bytes))
serprog_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(serprog_fd,buf+rd_bytes,len-rd_bytes);
+		if (r <= 0) serprog_die("Error: cannot read read-n data");
+		rd_bytes += r;
+	} while(rd_bytes != len);
+	return;
+}
+
+void serprog_delay(int delay) {
+	unsigned char buf[4];
+	printf_debug("%s\n", __func__);
+	if ((sp_write_n_support)&&(sp_write_n_bytes)) serprog_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;
+}

Property changes on: serprog.c
___________________________________________________________________
Name: svn:eol-style
   + native

Index: Makefile
===================================================================
--- Makefile	(revision 589)
+++ Makefile	(working copy)
@@ -48,7 +48,7 @@
 	sst49lfxxxc.o sst_fwhub.o layout.o cbtable.o flashchips.o physmap.o \
 	flashrom.o w39v080fa.o sharplhf00l04.o w29ee011.o spi.o it87spi.o \
 	ichspi.o w39v040c.o sb600spi.o wbsio_spi.o m29f002.o internal.o \
-	dummyflasher.o pcidev.o nic3com.o satasii.o
+	dummyflasher.o pcidev.o nic3com.o satasii.o serprog.o

 all: pciutils dep $(PROGRAM)

Index: flashrom.c
===================================================================
--- flashrom.c	(revision 589)
+++ flashrom.c	(working copy)
@@ -114,6 +114,21 @@
 		.chip_writen		= fallback_chip_writen,
 		.delay			= internal_delay,
 	},
+	{
+		.init			= serprog_init,
+		.shutdown		= serprog_shutdown,
+		.map_flash_region	= fallback_map,
+		.unmap_flash_region	= fallback_unmap,
+		.chip_readb		= serprog_chip_readb,
+		.chip_readw		= fallback_chip_readw,
+		.chip_readl		= fallback_chip_readl,
+		.chip_readn		= serprog_chip_readn,
+		.chip_writeb		= serprog_chip_writeb,
+		.chip_writew		= fallback_chip_writew,
+		.chip_writel		= fallback_chip_writel,
+		.chip_writen		= fallback_chip_writen,
+		.delay			= serprog_delay,
+	},

 	{},
 };
@@ -500,7 +515,7 @@
 	     "   -i | --image <name>:              only flash image name
from flash layout\n"
 	     "   -L | --list-supported:            print supported devices\n"
 	     "   -p | --programmer <name>:         specify the programmer device\n"
-	     "                                     (internal, dummy,
nic3com, satasii, it87spi)\n"
+	     "                                     (internal, dummy,
nic3com, satasii, it87spi, serprog)\n"
 	     "   -h | --help:                      print this help text\n"
 	     "   -R | --version:                   print the version (release)\n"
 	     "\nYou can specify one of -E, -r, -w, -v or no operation.\n"
@@ -658,6 +673,10 @@
 					pcidev_bdf = strdup(optarg + 8);
 			} else if (strncmp(optarg, "it87spi", 7) == 0) {
 				programmer = PROGRAMMER_IT87SPI;
+			} else if (strncmp(optarg, "serprog", 7) == 0) {
+				programmer = PROGRAMMER_SERPROG;
+				if (optarg[7] == '=')
+					serprog_param = strdup(optarg + 8);
 			} else {
 				printf("Error: Unknown programmer.\n");
 				exit(1);


-- 
urjaman
-------------- next part --------------
Serial Flasher Protocol Specification - version 1 (0x01 return value == 1)

Command And Answer Sequence - not all commands give an answer
PC: COMMAND(8bit) <parameters determined by opcode>
DEV: ACK/NAK(8bit) <OPTIONAL RETURN BYTES (only if ACK)> or nothing

ACK = 0x06
NAK = 0x15

All multibyte values are little-endian.

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
									eg. 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
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
									bit 0: PARALLEL
									bit 1: LPC
									bit 2: FWH
									bit 3: SPI if ever supported
0x06	Query supported chip size	none				ACK + 8bit power of two / NAK
0x07	Query operation buffer size	none				ACK + 16bit size / NAK
0x08	Query write-n maximum data len	none				ACK + 24bit maximum length / NAK
0x00	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 6 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
		- Execute operation buffer will also clear it, regardless of the return value
0x10	Sync NOP			none				NAK + ACK (for synchronization)

0x??	unimplemented command - dont do, dangerous, check for support with 0x02 before using any opcode exept 0x10, 0x00, 0x01 and 0x02.
				if 0x01 doesn't return 1, dont do anything if you dont support a newer protocol.


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	*/
-------------- next part --------------
A non-text attachment was scrubbed...
Name: serprog_v2.patch
Type: application/octet-stream
Size: 25006 bytes
Desc: not available
URL: <http://www.coreboot.org/pipermail/coreboot/attachments/20090614/f45faa69/attachment.obj>
-------------- next part --------------
A non-text attachment was scrubbed...
Name: frser-avr.tar.bz2
Type: application/x-bzip2
Size: 12321 bytes
Desc: not available
URL: <http://www.coreboot.org/pipermail/coreboot/attachments/20090614/f45faa69/attachment.bin>


More information about the coreboot mailing list