sprog/lpc.c

#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <stdarg.h>
#include <serial.h>
#include <uucode.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,
  .exec = (void(*)(void*, const struct sprog_data*)) lpc_exec,
  .close = (void(*)(void*)) lpc_close
};
  
  

void lpc_ispmode(struct lpc_device *dev, int state);
void lpc_reset(struct lpc_device *dev);
void lpc_vprintf(const char *text, va_list l);
void lpc_printf(const char *text, ...);
int lpc_getline(char *buf);
int lpc_command(const char *text, ...);
int lpc_read_partid(struct lpc_device *dev);
void lpc_write_ram(struct lpc_device *dev, const struct sprog_data *d, unsigned int addr);


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);
  if(lpc_getline(buf)) {
    if(strcmp(buf, "Synchronized\r\n")==0)
      sprog_error("Synchronization successful\n");
    lpc_printf("Synchronized\r\n");
    lpc_getline(buf);
    if(strcmp(buf, "OK\r\n")!=0)
      sprog_error("Expected OK, received '%s'\n", buf);
    sprog_error("Sending clock frequency\n");
    lpc_printf("12000\r\n");
    lpc_getline(buf);
    if(strcmp(buf, "OK\r\n")!=0)
      sprog_error("Expected OK, received '%s'\n", buf);
  } else {
    printf("\r\n");
    if(lpc_getline(buf))
      if(strcmp(buf, "?\r\n")==0)
	sprog_error("The device appears to be already synchronized\n");
    lpc_getline(buf); /* deny invalid command reply */
  }
  sprog_error("Reading part ID\n");
  if(lpc_read_partid(dev)==0)
    sprog_error("Found device: %s, %dkB Flash, %dkB RAM\n", dev->part->name, dev->part->flash, dev->part->ram);
}

void lpc_exec(struct lpc_device *dev, const struct sprog_data *d) {
  lpc_write_ram(dev, d, 0x10000400);
  lpc_command("U 23130\r\n");
  sprog_error("Executing code... ");
  if(lpc_command("G %u T\r\n", 0x10000400))
    sprog_error("Error\n");
  else
    sprog_error("OK\n");
}

void lpc_write_ram(struct lpc_device *dev, const struct sprog_data *d, unsigned int addr) {
  char reply_buf[4096];
  int last_offset;
  int last_i;
  int offset;
  int checksum;
  char buf[64];
  int i;
  int j;
  
  if(d->size & 3)
    sprog_error("Invalid data size - should be aligned to 4\n");
  
  lpc_command("W %u %u\r\n", addr, d->size);
  sprog_error("Writing %d bytes\n", d->size);
  
  last_i = 0;
  last_offset = 0;
  offset = 0;
  sprog_progress((offset*100)/d->size);
  checksum = 0;
  
  for(i=0; (j = uuencode_line(d, buf, &offset, &checksum)); i++) {
    if(j==1) lpc_printf("%s\r\n", buf);
    if(j==2 || (i % 20)==19) {
      lpc_printf("%u\r\n", checksum);
      checksum = 0;
      
      if(lpc_getline(reply_buf)) {
	if(strcmp(reply_buf, "OK\r\n")==0) {
	  last_offset = offset;
	  last_i = i;
	  if(j==2)
	    offset = -1;
	} else {
	  offset = last_offset;
	  i = last_i;
	}
      } else
	break;
    }
    if(offset!=-1)
      sprog_progress((offset*100)/d->size);
    else
      sprog_progress(100);
  }
  
  if(offset!=-1)
    sprog_error("Error while writing to RAM\n");
}
  

int lpc_getline(char *buf) {
  if(sprog_waitdata(500)==0)
    return 0;
  fgets(buf, 4096, stdin);
  return 1;
}

void lpc_vprintf(const char *text, va_list l) {
  char buf[4096];
  vprintf(text, l);
  lpc_getline(buf);
}

void lpc_printf(const char *text, ...) {
  va_list l;
  va_start(l, text);
  lpc_vprintf(text, l);
  va_end(l);
}

int lpc_command(const char *text, ...) {
  char buf[4096];
  int res;
  va_list l;
  va_start(l, text);
  lpc_vprintf(text, l);
  va_end(l);
  lpc_getline(buf);
  if(sscanf(buf, "%d", &res)<1)
    return -1;
  return res;
}

int lpc_read_partid(struct lpc_device *dev) {
  char buf[4096];
  int i;
  int res;
  unsigned int partid;
  res = lpc_command("J\r\n");
  if(res!=0)
    return res;
  lpc_getline(buf);
  sscanf(buf, "%u", &partid);
  for(i=0; lpc_parts[i].name; i++)
    if(lpc_parts[i].part_id==partid)
      break;
  if(lpc_parts[i].name)
    dev->part = &lpc_parts[i];
  else
    return -1;
  return 0;
}

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