Staging branch

Added staging branch, which is meant to be used to develop basically working software, with support to at leas LPC111x family. After reaching usable state (i.e. ability to write to flash memory), the tree will be moved to the
master branch and the staging branch will be dropped.

.gitignore

@@ -0,0 +1 @@
+*~

Makefile

@@ -0,0 +1,21 @@
+PROGRAM=sprog
+VERSION=0.0-alpha
+OBJS=main.o version.o sprog.o serial.o lpc.o
+CFLAGS=-Wall -Wextra -I./
+LDFLAGS=
+CC=gcc
+LD=gcc
+
+all: $(PROGRAM)
+
+$(PROGRAM): $(OBJS)
+	$(LD) $(LDFLAGS) $^ -o $@
+
+version.o: version.c
+	$(CC) -c $(CFLAGS) -DVERSION="$(VERSION)" $< -o $@
+
+%.o: %.c
+	$(CC) -c $(CFLAGS) $< -o $@
+
+clean:
+	rm -f $(OBJS) $(PROGRAM)

lpc.c

@@ -0,0 +1,82 @@
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <serial.h>
+#include <lpc.h>
+
+const struct lpc_part lpc_parts[] = {
+  {"LPC1111/101", 0x041e502b, 2, 8},
+  {"LPC1111/101 or 102", 0x2516d02b, 2, 8},
+  {"LPC1111/201", 0x0416502b, 4, 8},
+  {"LPC1111/201 or 202", 0x2516902b, 4, 8},
+  
+  {"LPC1112/101", 0x042d502b, 2, 16},
+  {"LPC1112/101 or 102", 0x2524d02b, 2, 16},
+  {"LPC1112/201", 0x0425502b, 4, 16},
+  {"LPC1112/201 or 202", 0x2524902b, 4, 16},
+  
+  {"LPC1113/201", 0x0434502b, 4, 24},
+  {"LPC1113/201 or 202", 0x2532902b, 4, 24},
+  {"LPC1113/301", 0x0434102b, 8, 24},
+  {"LPC1113/301 or 302", 0x2532102b, 8, 24},
+  
+  {"LPC1114/201", 0x0444502b, 4, 32},
+  {"LPC1114/201 or 202", 0x2540902b, 4, 32},
+  {"LPC1114/301", 0x0444102b, 8, 32},
+  {"LPC1114/301 or 302", 0x2540102b, 8, 32},
+  
+  {"LPC11C12/301", 0x1421102b, 8, 16},
+  {"LPC11C14/301", 0x1440102b, 8, 32},
+  {"LPC11C22/301", 0x1431102b, 8, 16},
+  {"LPC11C24/301", 0x1430102b, 8, 32},
+  {NULL, 0, 0, 0}
+};
+
+const struct sprog_family lpc_family = {
+  .setup = (void*(*)(struct serial_device*)) lpc_setup,
+  .init = (void(*)(void*)) lpc_init,
+  .close = (void(*)(void*)) lpc_close
+};
+  
+  
+
+void lpc_ispmode(struct lpc_device *dev, int state);
+void lpc_reset(struct lpc_device *dev);
+
+struct lpc_device *lpc_setup(struct serial_device *port) {
+  struct lpc_device *dev;
+  dev = malloc(sizeof(struct lpc_device));
+  dev->port = port;
+  dev->part = NULL;
+  lpc_ispmode(dev, 1);
+  lpc_reset(dev);
+  return dev;
+}
+
+void lpc_init(struct lpc_device *dev) {
+  char buf[4096];
+  printf("?");
+  fflush(stdout);
+  fgets(buf, sizeof(buf), stdin);
+  if(strcmp(buf, "Synchronized\r\n")==0)
+    sprog_error("Synchronization successful\n");
+  else
+    sprog_error("Synchronization error - received '%s'\n", buf);
+}
+
+void lpc_ispmode(struct lpc_device *dev, int state) {
+  serial_setline(dev->port, SERIAL_DTR, state);
+}
+
+void lpc_reset(struct lpc_device *dev) {
+  /* TODO: configure the control lines */
+  serial_setline(dev->port, SERIAL_RTS, 1);
+  sprog_sleep(50);
+  serial_setline(dev->port, SERIAL_RTS, 0);
+  sprog_sleep(10);
+}
+
+void lpc_close(struct lpc_device *dev) {
+  serial_close(dev->port);
+  free(dev);
+}

lpc.h

@@ -0,0 +1,27 @@
+#ifndef __LPC_H__
+#define __LPC_H__
+
+#include <serial.h>
+#include <sprog.h>
+
+struct lpc_device {
+  struct serial_device *port;
+  const struct lpc_part *part;
+};
+
+struct lpc_device *lpc_setup(struct serial_device *port);
+void lpc_init(struct lpc_device *dev);
+void lpc_close(struct lpc_device *dev);
+
+
+struct lpc_part {
+  const char *name;
+  unsigned int part_id;
+  int ram;
+  int flash;
+};
+
+extern const struct lpc_part lpc_parts[];
+extern const struct sprog_family lpc_family;
+
+#endif

main.c

@@ -0,0 +1,91 @@
+#include <stdio.h>
+#include <string.h>
+#include <getopt.h>
+#include <sprog.h>
+#include <serial.h>
+#include <lpc.h>
+
+struct option sprog_options[] = {
+  {"port", required_argument, NULL, 'p'},
+  {"family", required_argument, NULL, 'f'},
+  {"baud", required_argument, NULL, 'b'},
+  {"version", no_argument, NULL, 'v'},
+  {"help", no_argument, NULL, 'h'},
+  {NULL, 0, NULL, 0}
+};
+
+void usage(const char *name);
+void print_version(void);
+  
+
+int main(int argc, char *argv[]) {
+  const struct sprog_family *fam;
+  int opt;
+  int option_index;
+  int baud;
+  char port[128];
+  port[0] = 0;
+  fam = NULL;
+  
+  while((opt = getopt_long(argc, argv, "p:b:f:h", sprog_options, &option_index))!=-1) {
+    switch(opt) {
+      case 'p':
+	strncpy(port, optarg, sizeof(port));
+	break;
+      case 'f':
+	if(strcmp(optarg, "lpc")==0)
+	  fam = &lpc_family;
+	else
+	  sprog_error("Family '%s' not recognized\n", optarg);
+	break;
+      case 'b':
+	if(sscanf(optarg, "%d", &baud)!=1) {
+	  sprog_error("Invalid value for baud rate: '%s'\n", optarg);
+	  return 1;
+	}
+	break;
+      case 'v':
+	print_version();
+	return 0;
+	break;
+      case 'h':
+	usage(argv[0]);
+	return 0;
+	break;
+      default:
+	usage(argv[0]);
+	return 1;
+    }
+  }
+  
+  if(!port[0]) {
+    sprog_error("Serial port not specified!\n");
+    usage(argv[0]);
+    return 1;
+  }
+  
+  if(!fam) {
+    sprog_error("Family not specified!\n");
+    usage(argv[0]);
+    return 1;
+  }
+  
+  sprog_communicate(fam, port, baud);
+  
+  return 0;
+  
+}
+
+void usage(const char *name) {
+  printf("%s -p <port> -f <family> [options]\n", name);
+  printf("Following options are supported:\n");
+  printf("  -p <port>, --port <port>		specify the serial port, eg. /dev/ttyS0\n");
+  printf("  -f <family>, --family <family>	specify the serial port, eg. /dev/ttyS0\n");
+  printf("  -b <baud>, --baud <baud>		specify the baud rate\n");
+  printf("  -h, --help				display this help\n");
+  printf("  --version				print version and exit\n");
+}
+
+void print_version(void) {
+  printf("SProg v%s (built on " __DATE__ ")\n", sprog_version);
+}

serial.c

@@ -0,0 +1,341 @@
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <unistd.h>
+#include <termios.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/time.h>
+#include <sys/select.h>
+#include <serial.h>
+#include <sprog.h>
+
+int serial_setbaud_termios(struct termios *t, int baud);
+int serial_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout);
+int ringbuf_append(struct ring_buf *buf, const char *data, unsigned int len);
+int ringbuf_getline(struct ring_buf *buf, char *data, unsigned int len);
+int ringbuf_getdata(struct ring_buf *buf, char *data, unsigned int len);
+void ringbuf_move(struct ring_buf *buf, unsigned int bytes);
+void ringbuf_reset(struct ring_buf *buf);
+
+
+/* supported baud codes to use with cfsetispeed, cfsetospeed - keep sorted! */
+
+const struct baud_code baud_codes[] = {
+  {50, B50},
+  {75, B75},
+  {110, B110},
+  {134, B134},
+  {150, B150},
+  {200, B200},
+  {300, B300},
+  {600, B600},
+  {1200, B1200},
+  {1800, B1800},
+  {2400, B2400},
+  {4800, B4800},
+  {9600, B9600},
+  {19200, B19200},
+  {38400, B38400},
+  {57600, B57600},
+  {115200, B115200},
+  {230400, B230400},
+  {-1, 0}
+};
+
+int serial_open(struct serial_device *port, const char *path, int baud) {
+  struct termios attr;
+  int fd;
+  fd = open(path, O_RDWR);
+  if(fd<0) {
+    sprog_error("Unable to open serial port %s: %s\n", path, strerror(errno));
+    exit(1);
+  }
+  
+  tcgetattr(fd, &attr);
+  /* 8 data bits, 1 stop bit, no parity */
+  attr.c_iflag = IGNBRK;
+  attr.c_oflag &= ~(OPOST | OLCUC | ONOCR | ONLRET | ONLCR); 
+  attr.c_cflag = CS8 | CREAD | CLOCAL;
+  attr.c_lflag = ICANON;
+  serial_setbaud_termios(&attr, baud);
+  tcsetattr(fd, TCSANOW, &attr);
+  port->fd = fd;
+  return fd;
+}
+
+void serial_close(struct serial_device *port) {
+  close(port->fd);
+}
+
+int serial_setbaud(struct serial_device *port, int baud) {
+  struct termios attr;
+  tcgetattr(port->fd, &attr);
+  baud = serial_setbaud_termios(&attr, baud);
+  tcsetattr(port->fd, TCSANOW, &attr);
+  return baud;
+}
+
+int serial_setbaud_termios(struct termios *t, int baud) {
+  int i;
+  int baudcode;
+  
+  /* find the corresponding baud code */
+  
+  for(i=0; baud_codes[i].baud>0; i++) {
+    if(baud_codes[i].baud == baud)
+      break;
+    if(baud_codes[i].baud > baud) {
+      if(i>0) i--;
+      break;
+    }
+  }
+  
+  /* if the selected baud rate is greater than any of available rates, set the highest one */
+  if(baud_codes[i].baud<=0) i--;
+  
+  if(baud_codes[i].baud != baud)
+    sprog_error("Unsupported baud rate %d, using the nearest value %d\n", baud, baud_codes[i].baud);
+  
+  baudcode = baud_codes[i].code;
+  cfsetispeed(t, baudcode);
+  cfsetospeed(t, baudcode);
+  return baud_codes[i].baud;
+}
+
+void serial_setline(struct serial_device *port, int line, int state) {
+  int bits;
+  int mask;
+  if(line==SERIAL_DTR)
+    mask = TIOCM_DTR;
+  else
+    mask = TIOCM_RTS;
+  
+  ioctl(port->fd, TIOCMGET, &bits);
+  if(state)
+    bits |= mask;
+  else
+    bits &= ~mask;
+  ioctl(port->fd, TIOCMSET, &bits);
+}
+
+void serial_write(struct serial_device *port, const char *text) {
+  int i;
+  int b;
+  int bytes;
+  bytes = strlen(text);
+  i = 0;
+  
+  while(bytes-i>0) {
+    b = write(port->fd, &text[i], bytes-i);
+    if(b<0) {
+      sprog_error("Error while writing to the serial port: %s\n", strerror(errno));
+      break;
+    }
+    i += b;
+  }
+}
+
+int serial_read(struct serial_device *port, char *buf, int len, int timeout) {
+  int bytes;
+  fd_set readset;
+  struct timeval tval;
+  FD_ZERO(&readset);
+  FD_SET(port->fd, &readset);
+  
+  tval.tv_sec = timeout/1000;
+  tval.tv_usec = (timeout % 1000) * 1000;
+  
+  bytes = 0;
+  while((serial_select(port->fd+1, &readset, NULL, NULL, &tval)>0) && (len-bytes)>0) {
+    if(FD_ISSET(port->fd, &readset))
+      bytes += read(port->fd, &buf[bytes], len-bytes);
+  }
+  return bytes;
+}
+
+int serial_select(int nfds, fd_set *readfds, fd_set *writefds, fd_set *exceptfds, struct timeval *timeout) {
+  int res;
+  
+   /* Linux automatically subtracts the time elapsed on awaiting
+   * for an event when calling select(), The following code unifices
+   * the behaviour under different implementations of UNIX.
+   */
+#ifndef __linux__
+  struct timeval start_time
+  struct timeval cur_time;
+  long int remaining;
+  
+  gettimeofday(&start_time, NULL);
+  res = pselect(nfds, readfds, writefds, exceptfds, timeout, NULL)
+  gettimeofday(&cur_time, NULL);
+  remaining = (timeout->tv_sec - (cur_time.tv_sec - start_time.tv_sec))*1000000 + timeout->tv_usec - (cur_time.tv_usec - start_time.tv_usec);
+  if(remaining<0) remaining = 0;
+  
+  timeout.tv_sec = remaining/1000000;
+  timeout.tv_usec = remmaining%1000000;
+#else
+  res = select(nfds, readfds, writefds, exceptfds, timeout);
+#endif
+ 
+  return res;
+}
+
+void serial_communicate(struct serial_device *port, int infd, int outfd) {
+  char buf[4096];
+  int n;
+  int bytes;
+  int nfds;
+  fd_set read_set;
+  fd_set write_set;
+  fd_set except_set;
+  
+  ringbuf_reset(&port->in_buf);
+  ringbuf_reset(&port->out_buf);
+  
+  FD_ZERO(&read_set);
+  FD_ZERO(&write_set);
+  FD_ZERO(&except_set);
+  FD_SET(port->fd, &read_set);
+  FD_SET(infd, &read_set);;
+  FD_SET(port->fd, &except_set);
+  FD_SET(infd, &except_set);
+  FD_SET(outfd, &except_set);
+  
+  nfds = port->fd;
+  if(infd>nfds)
+    nfds = infd;
+  if(outfd>nfds)
+    nfds = outfd;
+  nfds++;
+  
+  while(select(nfds, &read_set, &write_set, &except_set, NULL)>0) {
+    if(FD_ISSET(outfd, &write_set)) {
+      n = ringbuf_getdata(&port->in_buf, buf, sizeof(buf));
+      n = write(outfd, buf, n);
+      ringbuf_move(&port->in_buf, n);
+    }
+    
+    if(FD_ISSET(port->fd, &write_set)) {
+      n = ringbuf_getdata(&port->out_buf, buf, sizeof(buf));
+      n = write(port->fd, buf, n);
+      ringbuf_move(&port->out_buf, n);
+    }
+    
+    FD_ZERO(&read_set);
+    FD_ZERO(&write_set);
+    FD_ZERO(&except_set);
+    FD_SET(port->fd, &read_set);
+    FD_SET(infd, &read_set);
+    FD_SET(port->fd, &except_set);
+    FD_SET(infd, &except_set);
+    FD_SET(outfd, &except_set);
+    
+    if(FD_ISSET(infd, &read_set)) {
+      bytes = sizeof(port->out_buf.data) - port->out_buf.size;
+      if(bytes>0) {
+	n = read(infd, buf, bytes);
+	ringbuf_append(&port->out_buf, buf, n);
+      } else
+	FD_CLR(infd, &read_set);
+      FD_SET(port->fd, &write_set);
+    }
+    
+    if(FD_ISSET(port->fd, &read_set)) {
+      bytes = sizeof(port->in_buf.data) - port->out_buf.size;
+      if(bytes>0) {
+	n = read(infd, buf, bytes);
+	ringbuf_append(&port->out_buf, buf, n);
+      } else
+	FD_CLR(port->fd, &read_set);
+      FD_SET(outfd, &write_set);
+    }
+      
+  }
+}
+
+int ringbuf_append(struct ring_buf *buf, const char *data, unsigned int len) {
+  unsigned int p;
+  unsigned int i;
+  
+  if((buf->size + len)>sizeof(buf->data))
+    return 1;
+  
+  p = buf->start + buf->size;
+  
+  for(i=0; i<len; i++) {
+    if(p>=sizeof(buf->data))
+      p -= sizeof(buf->data);
+    buf->data[p] = data[i];
+  }
+  buf->size += len;
+  return 0;
+}
+
+int ringbuf_getline(struct ring_buf *buf, char *data, unsigned int len) {
+  unsigned int datap;
+  unsigned int p;
+  unsigned int i;
+  datap = strlen(data);
+  
+  p = buf->start;
+  for(i=0; i<buf->size; i++) {
+    if(p>=sizeof(buf->data))
+      p -= sizeof(buf->data);
+    if(buf->data[p]=='\r' || buf->data[p]=='\n') break;
+  }
+  
+  if((len-datap-1)<i) return -1;
+  len = ringbuf_getdata(buf, &data[datap], i);
+  data[datap+len] = 0;
+  
+  if(i<buf->size)
+    i++;
+  if(buf->data[p]=='\r') {
+    if((i+1)<buf->size) {
+      p++;
+      if(p>=sizeof(buf->data))
+	p -= sizeof(buf->data);
+      if(buf->data[p]=='\n')
+	i++;
+    }
+  }
+  ringbuf_move(buf, i);
+  if(buf->data[p]!='\n')
+    return 0;
+  
+  return datap+len;
+}
+
+int ringbuf_getdata(struct ring_buf *buf, char *data, unsigned int len) {
+  unsigned int p;
+  unsigned int i;
+  
+  if(len>buf->size) len = buf->size;
+  p = buf->start;
+  for(i=0; i<len; i++) {
+    if(p>=sizeof(buf->data))
+      p -= sizeof(buf->data);
+    data[i] = buf->data[p];
+  }
+  return len;
+}
+
+void ringbuf_move(struct ring_buf *buf, unsigned int bytes) {
+  unsigned int p;
+  
+  if(buf->size<bytes) {
+    buf->start = 0;
+    buf->size = 0;
+  } else {
+    p = buf->start + bytes;
+    if(p>=sizeof(buf->data))
+      p -= sizeof(buf->data);
+    buf->start = p;
+  }
+}
+
+void ringbuf_reset(struct ring_buf *buf) {
+  buf->start = 0;
+  buf->size = 0;
+}

serial.h

@@ -0,0 +1,35 @@
+#ifndef __SERIAL_H__
+#define __SERIAL_H__
+
+#define SERIAL_DTR 0
+#define SERIAL_RTS 1
+
+struct baud_code {
+  int baud;
+  int code;
+};
+
+struct ring_buf {
+  char data[4096];
+  unsigned int start;
+  unsigned int size;
+};
+
+struct serial_device {
+  int fd;
+  struct ring_buf in_buf;
+  struct ring_buf out_buf;
+};
+
+extern const struct baud_code baud_codes[];
+
+int serial_open(struct serial_device *port, const char *path, int baud);
+void serial_close(struct serial_device *port);
+int serial_setbaud(struct serial_device *port, int baud);
+void serial_setline(struct serial_device *port, int line, int state);
+int serial_read(struct serial_device *port, char *buf, int len, int timeout);
+void serial_write(struct serial_device *port, const char *text);
+void serial_communicate(struct serial_device *port, int infd, int outfd);
+
+
+#endif

sprog.c

@@ -0,0 +1,50 @@
+#include <stdarg.h>
+#include <stdlib.h>
+#include <string.h>
+#include <errno.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sprog.h>
+
+void sprog_process(const struct sprog_family *fam, void *arg, int nstdin, int nstdout);
+
+void sprog_error(const char *text, ...) {
+  va_list l;
+  va_start(l, text);
+  vfprintf(stderr, text, l);
+  va_end(l);
+}
+
+void sprog_sleep(int msec) {
+  usleep(msec * 1000);
+}
+
+void sprog_communicate(const struct sprog_family *fam, const char *port, int baud) {
+  int pstdin[2];
+  int pstdout[2];
+  int pid;
+  void *arg;
+  struct serial_device dev;
+  
+  serial_open(&dev, port, baud);
+  arg = fam->setup(&dev);
+  pipe(pstdin);
+  pipe(pstdout);
+  pid = fork();
+  if(pid<0)
+    sprog_error("Unable to fork: %s\n", strerror(errno));
+  else {
+    if(pid==0) {
+      serial_communicate(&dev, pstdout[0], pstdin[1]);
+      fam->close(arg);
+    } else
+      sprog_process(fam, arg, pstdin[0], pstdout[1]);
+  }
+}
+
+void sprog_process(const struct sprog_family *fam, void *arg, int nstdin, int nstdout) {
+  dup2(nstdin, 0);
+  dup2(nstdout, 1);
+  fam->init(arg);
+  exit(0);
+}

sprog.h

@@ -0,0 +1,21 @@
+#ifndef __SPROG_H__
+#define __SPROG_H__
+#include <serial.h>
+
+#define array_size(x) (sizeof(x)/sizeof(*x))
+
+struct sprog_family {
+  void *(*setup)(struct serial_device *dev);
+  void (*init)(void *arg);
+  void (*close)(void *arg);
+};
+  
+
+extern const char sprog_version[];
+void sprog_communicate(const struct sprog_family *fam, const char *port, int baud);
+void sprog_process(const struct sprog_family *fam, void *arg, int nstdin, int nstdout);
+int sprog_getline(char *buf, int len, int timeout);
+void sprog_error(const char *text, ...);
+void sprog_sleep(int msec);
+
+#endif

version.c

@@ -0,0 +1,11 @@
+#ifndef VERSION
+#error "VERSION not defined!"
+#endif
+
+
+/* Transform VERSION macro into C string */
+#define ___MACROSTR(x) #x
+#define __MACROSTR(x) ___MACROSTR(x)
+#define _VERSION __MACROSTR(VERSION)
+
+const char sprog_version[] = _VERSION;