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

Carl-Daniel Hailfinger c-d.hailfinger.devel.2006 at gmx.net
Tue Jun 23 13:44:21 CEST 2009


On 17.06.2009 00:32, Urja Rannikko wrote:
> 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>
> ---
> Here we go with the third iteration of this patch - now rebased to r598.
> Also included a version of the AVR "firmware" that can do 746 byte
> operation buffers (with 1K sram and 224 byte UART receive buffer, 16
> byte UART transmit buffer).
>   

Thanks, I have updated the flashrom.c and Makefile changes and comitted
them in r625 together with the flash.h changes and a stubbed
implementation of serprog.c. That part is
Acked-by: Carl-Daniel Hailfinger <c-d.hailfinger.devel.2006 at gmx.net>

That way, you don't have the burden of updating the glue code anymore
and others can check if the include files are available on their platforms.

The remainder of your patch follows (and I hope I can complete my review
of it soon).

Regards,
Carl-Daniel

Index: flashrom-serprog/serprog.c
===================================================================
--- flashrom-serprog/serprog.c	(Revision 625)
+++ flashrom-serprog/serprog.c	(Arbeitskopie)
@@ -39,9 +39,717 @@
 
 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    */
+
+int serprog_fd;
+
+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);
+	/* 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");
+	/* A second should be enough to get all the answers to the buffer */
+	usleep(1000 * 1000);
+	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);
+			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;
+	if (sp_cmdmap[byteoffs] & (1 << bitoffs))
+		return 1;
+	return 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 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;
+			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	*
+ * the 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();
+	/* 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 += 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;
+}
+
 #else
+
 int serprog_init(void)
 {
 	fprintf(stderr, "Serial programmer support was not compiled in\n");


-- 
http://www.hailfinger.org/

-------------- next part --------------
An embedded and charset-unspecified text was scrubbed...
Name: flashrom_serprog.diff
URL: <http://www.coreboot.org/pipermail/coreboot/attachments/20090623/6fb95737/attachment.ksh>


More information about the coreboot mailing list