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@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);