[coreboot] [flashrom] [PATCH] external serial flasher protocol support
Urja Rannikko
urjaman at gmail.com
Wed Jun 10 00:16:57 CEST 2009
Excuse me, i forgot to inline the patch, and also do remember to svn
add serprog.c:
the patch:
Index: flash.h
===================================================================
--- flash.h (revision 580)
+++ 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;
@@ -906,4 +907,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,576 @@
+/*
+ * 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 0x10
+#define S_NAK 0xBA
+#define S_CMD_SYNCNOP 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 */
+
+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;
+};
+
+const struct baudentry baudtable[] = {
+ { B9600, 9600 },
+ { B19200, 19200 },
+ { B38400, 38400 },
+ { B57600, 57600 },
+ { B115200, 115200 },
+ { 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;
+}
+
+/* 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,0,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 nop and get the correct special
return of NAK+ACK */
+ for(i=0;i<8;i++) {
+ int n;
+ unsigned char c = 0;
+ if (write(serprog_fd,&c,1) != 1) serprog_die("sync write");
+ printf_debug(".")
+ fflush(stdout);
+ for(n=0;n<50;n++) { // wait upto 500ms
+ ssize_t rv;
+ usleep(10 * 1000); // sleep 10 ms
+ rv = read(serprog_fd,&c,1);
+ if ((rv == 1)&&(c == S_NAK)) {
+ usleep(10 * 1000); /* a careful 10ms to make sure the second byte
arrived too */
+ rv = read(serprog_fd,&c,1);
+ if ((rv == 1)&&(c == S_ACK)) {
+ flags &= ~O_NONBLOCK;
+ fcntl(serprog_fd,F_SETFL,flags);
+ return; // our task is done
+ }
+ }
+ }
+ }
+
+ 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(void) {
+ if ((sp_write_n_support)&&(sp_write_n_bytes)) serprog_pass_writen();
+ sp_stream_buffer_op(S_CMD_O_EXEC,0,0);
+ sp_flush_stream();
+ printf_debug(MSGHEADER "Executed operation buffer of %d
bytes\n",sp_opbuf_usage);
+ sp_opbuf_usage = 0;
+ sp_prev_was_write = 0;
+ return;
+}
+
+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];
+ if ((sp_opbuf_usage)||(sp_write_n_support&&sp_write_n_bytes))
serprog_execute_opbuf();
+ buf[0] = ((addr >> 0) & 0xFF);
+ buf[1] = ((addr >> 8) & 0xFF);
+ buf[2] = ((addr >> 16) & 0xFF);
+ if (serprog_docommand(S_CMD_R_BYTE,3,buf,1,&c)) {
+ fprintf(stderr,"Error: NAK to Read byte command\n");
+ exit(1);
+ }
+ 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) {
+ unsigned char sbuf[6];
+ printf_debug("%s: addr=0x%lx len=%d\n", __func__,addr,len);
+ if ((sp_opbuf_usage)||(sp_write_n_support&&sp_write_n_bytes))
serprog_execute_opbuf();
+ 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);
+ if (serprog_docommand(S_CMD_R_NBYTES,6,sbuf,len,buf)) {
+ fprintf(stderr,"Error: NAK to Read N bytes command\n");
+ exit(1);
+ }
+ 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 580)
+++ Makefile (working copy)
@@ -34,7 +34,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 580)
+++ 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,
+ },
{},
};
@@ -631,6 +646,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
More information about the coreboot
mailing list