indent

10 files changed, 1453 insertions, 1244 deletions

diff --git a/libdpf/bootload.c b/libdpf/bootload.c
index 2d882cf..342ec2b 100644
--- a/libdpf/bootload.c
+++ b/libdpf/bootload.c
@@ -5,7 +5,7 @@
 //
 
 #include "dpf.h"
-#include "usbuser.h" // our user defined flash commands
+#include "usbuser.h"            // our user defined flash commands
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
@@ -20,360 +20,422 @@
 #define BUFSIZE (64 - 6)
 #define PKTSIZE (64 - 7)
 
-typedef struct {
-	unsigned char len;
-	unsigned char chk;
-	unsigned char jmp[2];
-	union {
-		// Structures for various backends
-		// The default memory loader:
-		struct {
-			unsigned char offset[2];    // XDATA memory dest address
-			unsigned char buf[BUFSIZE]; // Binary data to write
-		} loader;
-		struct {
-			unsigned char opcode;   // SPI operation opcode
-			unsigned char wnum;     // Number of bytes to send (Host -> DPF)
-			unsigned char rnum;     // Number of bytes to recv (DPF -> Host)
-			unsigned char seq[PKTSIZE];  // SPI cmd sequence
-		} spi;
-	} u;
+typedef struct
+{
+  unsigned char len;
+  unsigned char chk;
+  unsigned char jmp[2];
+  union
+  {
+    // Structures for various backends
+    // The default memory loader:
+    struct
+    {
+      unsigned char offset[2];  // XDATA memory dest address
+      unsigned char buf[BUFSIZE]; // Binary data to write
+    } loader;
+    struct
+    {
+      unsigned char opcode;     // SPI operation opcode
+      unsigned char wnum;       // Number of bytes to send (Host -> DPF)
+      unsigned char rnum;       // Number of bytes to recv (DPF -> Host)
+      unsigned char seq[PKTSIZE]; // SPI cmd sequence
+    } spi;
+  } u;
 } UsbMsg;
 
-#define OPCODE_SPISEL  0x01  // assert SELECT
+#define OPCODE_SPISEL  0x01     // assert SELECT
 #define OPCODE_CRYPT0  0x02
 #define OPCODE_CRYPT1  0x04
-#define OPCODE_SPIDES  0x10  // assert DESELECT
+#define OPCODE_SPIDES  0x10     // assert DESELECT
 
-int validate(UsbMsg *msg)
+int
+validate (UsbMsg * msg)
 {
-	unsigned short c = 0;
-	unsigned char *b = (unsigned char *) msg;
-	unsigned short l = msg->len;
+  unsigned short c = 0;
+  unsigned char *b = (unsigned char *) msg;
+  unsigned short l = msg->len;
 
-	if (l < 6 || l > 64) return -1;
+  if (l < 6 || l > 64)
+    return -1;
 
-	while (l--) {
-		c += *b++;
-	}
+  while (l--)
+    {
+      c += *b++;
+    }
 
-	msg->chk -= c;
+  msg->chk -= c;
 
-	return 0;
+  return 0;
 }
 
-void hexdump(unsigned char *buf, unsigned long n)
+void
+hexdump (unsigned char *buf, unsigned long n)
 {
-	int i = 0;
-	int c = 0;
-
-	while (i < n) {
-		printf("%02x ", buf[i]);
-		c++;
-		if (c == 16) { c = 0; printf("\n"); }
-		i++;
-	}
-	if (c)
-		printf("\n");
+  int i = 0;
+  int c = 0;
+
+  while (i < n)
+    {
+      printf ("%02x ", buf[i]);
+      c++;
+      if (c == 16)
+        {
+          c = 0;
+          printf ("\n");
+        }
+      i++;
+    }
+  if (c)
+    printf ("\n");
 }
 
-int transmit(DPFContext *dpf, UsbMsg *m)
+int
+transmit (DPFContext * dpf, UsbMsg * m)
 {
-	int error;
-	unsigned char *s = (unsigned char *) m;
-	// hexdump(s, m->len);
-	error = usb_rawwrite(dpf->dev.udev, s, m->len);
-	if (error < 0) {
-		perror("Writing to USB");
-	}
-	return error;
+  int error;
+  unsigned char *s = (unsigned char *) m;
+  // hexdump(s, m->len);
+  error = usb_rawwrite (dpf->dev.udev, s, m->len);
+  if (error < 0)
+    {
+      perror ("Writing to USB");
+    }
+  return error;
 }
 
-int spilib_process(DPFContext *h, UsbMsg *umsg, unsigned char *out)
+int
+spilib_process (DPFContext * h, UsbMsg * umsg, unsigned char *out)
 {
-	int error;
-	umsg->jmp[0] = JMP_SPILIB & 0xff; umsg->jmp[1] = JMP_SPILIB >> 8;
-	umsg->len = 7 + umsg->u.spi.wnum;
-
-	validate(umsg);
-	error = transmit(h, umsg);
-	if (umsg->u.spi.rnum > 0 && error >= 0) {
-		error = usb_rawread(h->dev.udev, out, 64);
-	}
-	if (error < 0) perror("Reading USB");
-	else error = 0;
-	return error;
+  int error;
+  umsg->jmp[0] = JMP_SPILIB & 0xff;
+  umsg->jmp[1] = JMP_SPILIB >> 8;
+  umsg->len = 7 + umsg->u.spi.wnum;
+
+  validate (umsg);
+  error = transmit (h, umsg);
+  if (umsg->u.spi.rnum > 0 && error >= 0)
+    {
+      error = usb_rawread (h->dev.udev, out, 64);
+    }
+  if (error < 0)
+    perror ("Reading USB");
+  else
+    error = 0;
+  return error;
 }
 
-int go_hid(DPFContext *dpf, ADDR jmpoffset)
+int
+go_hid (DPFContext * dpf, ADDR jmpoffset)
 {
-	UsbMsg umsg;
-	umsg.jmp[0] = jmpoffset; umsg.jmp[1] = jmpoffset >> 8;
-	umsg.len = 8;
-	validate(&umsg);
-	return transmit(dpf, &umsg);
+  UsbMsg umsg;
+  umsg.jmp[0] = jmpoffset;
+  umsg.jmp[1] = jmpoffset >> 8;
+  umsg.len = 8;
+  validate (&umsg);
+  return transmit (dpf, &umsg);
 }
 
-int load(DPFContext *dpf, FILE *f, uint16_t jmpoffset)
+int
+load (DPFContext * dpf, FILE * f, uint16_t jmpoffset)
 {
-	int size;
-	UsbMsg umsg;
-
-	unsigned short offset = jmpoffset - 0x800;
-
-	umsg.jmp[0] = JMP_LOAD & 0xff; umsg.jmp[1] = JMP_LOAD >> 8;
-	umsg.chk = 0xce;
-	size = fread(umsg.u.loader.buf, 1, BUFSIZE, f);
-	if (size < 0) return size;
-
-	while (size > 0) {
-		umsg.u.loader.offset[0] = offset;
-		umsg.u.loader.offset[1] = offset >> 8;
-		umsg.len = sizeof(UsbMsg) - BUFSIZE + size;
-		offset += size;
-		validate(&umsg);
-		transmit(dpf, &umsg);
-		size = fread(umsg.u.loader.buf, 1, BUFSIZE, f);
-	} 
-
-	// And jump into the code:
-	if (jmpoffset != 0x0000) {
-		go_hid(dpf, jmpoffset);
-	}
-	return size;
+  int size;
+  UsbMsg umsg;
+
+  unsigned short offset = jmpoffset - 0x800;
+
+  umsg.jmp[0] = JMP_LOAD & 0xff;
+  umsg.jmp[1] = JMP_LOAD >> 8;
+  umsg.chk = 0xce;
+  size = fread (umsg.u.loader.buf, 1, BUFSIZE, f);
+  if (size < 0)
+    return size;
+
+  while (size > 0)
+    {
+      umsg.u.loader.offset[0] = offset;
+      umsg.u.loader.offset[1] = offset >> 8;
+      umsg.len = sizeof (UsbMsg) - BUFSIZE + size;
+      offset += size;
+      validate (&umsg);
+      transmit (dpf, &umsg);
+      size = fread (umsg.u.loader.buf, 1, BUFSIZE, f);
+    }
+
+  // And jump into the code:
+  if (jmpoffset != 0x0000)
+    {
+      go_hid (dpf, jmpoffset);
+    }
+  return size;
 }
+
 /* Flash stuff, HID wrapped */
 
 static unsigned char s_rbuf[64];
 
-static
-int flash_probe_hid(DPFContext *h, unsigned char *id)
+static int
+flash_probe_hid (DPFContext * h, unsigned char *id)
 {
-	int error;
-	UsbMsg umsg;
-	FILE *f;
-
-	// First, load spilib.bin
-	f = fopen("spilib.bin", "rb");
-
-	if (!f) {
-		printf("failed to open flash driver\n");
-		return -1;
-	}
-	umsg.u.spi.opcode = OPCODE_SPISEL | OPCODE_SPIDES;
-
-	error = load(h, f, 0x0000); // Load, but do not execute
-	fclose(f);
-	usleep(500000);
-	if (error == 0) {
-		umsg.u.spi.wnum = 1;
-		umsg.u.spi.rnum = 4;
-		umsg.u.spi.seq[0] = SPM_RDID;
-		error = spilib_process(h, &umsg, s_rbuf);
-		id[0] = s_rbuf[0]; id[1] = s_rbuf[1]; id[2] = s_rbuf[2];
-	}
-	return error;
+  int error;
+  UsbMsg umsg;
+  FILE *f;
+
+  // First, load spilib.bin
+  f = fopen ("spilib.bin", "rb");
+
+  if (!f)
+    {
+      printf ("failed to open flash driver\n");
+      return -1;
+    }
+  umsg.u.spi.opcode = OPCODE_SPISEL | OPCODE_SPIDES;
+
+  error = load (h, f, 0x0000);  // Load, but do not execute
+  fclose (f);
+  usleep (500000);
+  if (error == 0)
+    {
+      umsg.u.spi.wnum = 1;
+      umsg.u.spi.rnum = 4;
+      umsg.u.spi.seq[0] = SPM_RDID;
+      error = spilib_process (h, &umsg, s_rbuf);
+      id[0] = s_rbuf[0];
+      id[1] = s_rbuf[1];
+      id[2] = s_rbuf[2];
+    }
+  return error;
 }
 
-static
-int flash_cmd_hid(DPFContext *h, int command, int cmdlen, ADDR addr)
+static int
+flash_cmd_hid (DPFContext * h, int command, int cmdlen, ADDR addr)
 {
-	UsbMsg umsg;
-	umsg.u.spi.opcode = OPCODE_SPISEL | OPCODE_SPIDES;
-	umsg.u.spi.wnum = cmdlen;
-	umsg.u.spi.rnum = 0;
-	umsg.u.spi.seq[0] = command;
-	umsg.u.spi.seq[1] = addr >> 16;
-	umsg.u.spi.seq[2] = addr >> 8;
-	umsg.u.spi.seq[3] = addr;
-
-	return spilib_process(h, &umsg, 0);
+  UsbMsg umsg;
+  umsg.u.spi.opcode = OPCODE_SPISEL | OPCODE_SPIDES;
+  umsg.u.spi.wnum = cmdlen;
+  umsg.u.spi.rnum = 0;
+  umsg.u.spi.seq[0] = command;
+  umsg.u.spi.seq[1] = addr >> 16;
+  umsg.u.spi.seq[2] = addr >> 8;
+  umsg.u.spi.seq[3] = addr;
+
+  return spilib_process (h, &umsg, 0);
 }
 
-int flash_status_hid(DPFHANDLE h, uint8_t *status)
+int
+flash_status_hid (DPFHANDLE h, uint8_t * status)
 {
-	int error;
-	UsbMsg umsg;
-	umsg.u.spi.opcode = OPCODE_SPISEL | OPCODE_SPIDES;
-	umsg.u.spi.wnum = 1;
-	umsg.u.spi.rnum = 1;
-	umsg.u.spi.seq[0] = SPM_RDSR;
-
-	error = spilib_process(h, &umsg, s_rbuf);
-	*status = s_rbuf[0];
-	return error;
+  int error;
+  UsbMsg umsg;
+  umsg.u.spi.opcode = OPCODE_SPISEL | OPCODE_SPIDES;
+  umsg.u.spi.wnum = 1;
+  umsg.u.spi.rnum = 1;
+  umsg.u.spi.seq[0] = SPM_RDSR;
+
+  error = spilib_process (h, &umsg, s_rbuf);
+  *status = s_rbuf[0];
+  return error;
 }
 
-static
-int chunk_read(DPFContext *h, unsigned char *buf, ADDR offset, int len)
+static int
+chunk_read (DPFContext * h, unsigned char *buf, ADDR offset, int len)
 {
-	int error;
-	UsbMsg umsg;
+  int error;
+  UsbMsg umsg;
 
-	if (len > PKTSIZE) len = PKTSIZE;
+  if (len > PKTSIZE)
+    len = PKTSIZE;
 
-	umsg.u.spi.opcode = OPCODE_SPISEL | OPCODE_SPIDES;
-	umsg.u.spi.wnum = 4;
-	umsg.u.spi.rnum = PKTSIZE;
-	umsg.u.spi.seq[0] = SPM_READ;
-	umsg.u.spi.seq[1] = offset >> 16;
-	umsg.u.spi.seq[2] = offset >> 8;
-	umsg.u.spi.seq[3] = offset;
+  umsg.u.spi.opcode = OPCODE_SPISEL | OPCODE_SPIDES;
+  umsg.u.spi.wnum = 4;
+  umsg.u.spi.rnum = PKTSIZE;
+  umsg.u.spi.seq[0] = SPM_READ;
+  umsg.u.spi.seq[1] = offset >> 16;
+  umsg.u.spi.seq[2] = offset >> 8;
+  umsg.u.spi.seq[3] = offset;
 
-	error = spilib_process(h, &umsg, buf);
-	if (error < 0) return error;
+  error = spilib_process (h, &umsg, buf);
+  if (error < 0)
+    return error;
 
-	return len;
+  return len;
 }
 
 
-static
-int flash_read_hid(DPFContext *h, unsigned char *buf, ADDR offset, int len)
+static int
+flash_read_hid (DPFContext * h, unsigned char *buf, ADDR offset, int len)
 {
-	int n;
-
-	while (len > 0) {
-		n = chunk_read(h, buf, offset, len);
-		if (n < 0) return n;
-		len -= n; offset += n; buf += n;
-	}
-	return 0;
+  int n;
+
+  while (len > 0)
+    {
+      n = chunk_read (h, buf, offset, len);
+      if (n < 0)
+        return n;
+      len -= n;
+      offset += n;
+      buf += n;
+    }
+  return 0;
 }
 
-int fill_spimsg(UsbMsg *umsg, const unsigned char *buf,
-	unsigned short offset, int len)
+int
+fill_spimsg (UsbMsg * umsg, const unsigned char *buf,
+             unsigned short offset, int len)
 {
-	int n = PKTSIZE - offset;
-	if (len > n) len = n;
-	memcpy(&umsg->u.spi.seq[offset], buf, len);
-	umsg->u.spi.wnum = offset + len;
-	return len;
+  int n = PKTSIZE - offset;
+  if (len > n)
+    len = n;
+  memcpy (&umsg->u.spi.seq[offset], buf, len);
+  umsg->u.spi.wnum = offset + len;
+  return len;
 }
 
-static
-int flash_writechunk_hid(DPFContext *h,
-	const unsigned char *buf, ADDR offset, int len)
+static int
+flash_writechunk_hid (DPFContext * h,
+                      const unsigned char *buf, ADDR offset, int len)
 {
-	UsbMsg umsg;
-	int error;
-	int n;
-
-	if (len > PAGESIZE) len = PAGESIZE;
-
-	umsg.u.spi.rnum = 0;
-	umsg.u.spi.seq[0] = SPM_PP;
-	umsg.u.spi.seq[1] = offset >> 16;
-	umsg.u.spi.seq[2] = offset >> 8;
-	umsg.u.spi.seq[3] = offset;
-
-	n = fill_spimsg(&umsg, buf, 4, len);
-	len -= n; buf += n; offset += n;
-
-	umsg.u.spi.opcode = OPCODE_SPISEL;
-	error = spilib_process(h, &umsg, 0);
-	if (error < 0) return error;
-
-	umsg.u.spi.opcode = 0;
-	while (len > PKTSIZE) {
-		n = fill_spimsg(&umsg, buf, 0, PKTSIZE);
-		error = spilib_process(h, &umsg, 0);
-		if (error < 0) return error;
-		len -= n; buf += n; offset += n;
-	}
-
-	umsg.u.spi.opcode = OPCODE_SPIDES;
-	fill_spimsg(&umsg, buf, 0, len);
-	error = spilib_process(h, &umsg, 0);
-	if (error < 0) return error;
-
-	return PAGESIZE;
+  UsbMsg umsg;
+  int error;
+  int n;
+
+  if (len > PAGESIZE)
+    len = PAGESIZE;
+
+  umsg.u.spi.rnum = 0;
+  umsg.u.spi.seq[0] = SPM_PP;
+  umsg.u.spi.seq[1] = offset >> 16;
+  umsg.u.spi.seq[2] = offset >> 8;
+  umsg.u.spi.seq[3] = offset;
+
+  n = fill_spimsg (&umsg, buf, 4, len);
+  len -= n;
+  buf += n;
+  offset += n;
+
+  umsg.u.spi.opcode = OPCODE_SPISEL;
+  error = spilib_process (h, &umsg, 0);
+  if (error < 0)
+    return error;
+
+  umsg.u.spi.opcode = 0;
+  while (len > PKTSIZE)
+    {
+      n = fill_spimsg (&umsg, buf, 0, PKTSIZE);
+      error = spilib_process (h, &umsg, 0);
+      if (error < 0)
+        return error;
+      len -= n;
+      buf += n;
+      offset += n;
+    }
+
+  umsg.u.spi.opcode = OPCODE_SPIDES;
+  fill_spimsg (&umsg, buf, 0, len);
+  error = spilib_process (h, &umsg, 0);
+  if (error < 0)
+    return error;
+
+  return PAGESIZE;
 }
 
-int blk_write(DPFContext *h, ADDR dst, const unsigned char *src,
-	unsigned short len)
+int
+blk_write (DPFContext * h, ADDR dst, const unsigned char *src,
+           unsigned short len)
 {
-	static UsbMsg umsg;
+  static UsbMsg umsg;
 
-	if (len > BUFSIZE) len = BUFSIZE;
+  if (len > BUFSIZE)
+    len = BUFSIZE;
 
-	umsg.jmp[0] = JMP_LOAD & 0xff; umsg.jmp[1] = JMP_LOAD >> 8;
-	memcpy(umsg.u.loader.buf, src, len);
-	umsg.u.loader.offset[0] = dst;
-	umsg.u.loader.offset[1] = dst >> 8;
-	umsg.len = sizeof(UsbMsg) - BUFSIZE + len;
+  umsg.jmp[0] = JMP_LOAD & 0xff;
+  umsg.jmp[1] = JMP_LOAD >> 8;
+  memcpy (umsg.u.loader.buf, src, len);
+  umsg.u.loader.offset[0] = dst;
+  umsg.u.loader.offset[1] = dst >> 8;
+  umsg.len = sizeof (UsbMsg) - BUFSIZE + len;
 
-	validate(&umsg);
-	transmit(h, &umsg);
-	return len;
+  validate (&umsg);
+  transmit (h, &umsg);
+  return len;
 }
 
-int mem_write_hid(DPFContext *h,
-	ADDR dst, const unsigned char *src, unsigned short n)
+int
+mem_write_hid (DPFContext * h,
+               ADDR dst, const unsigned char *src, unsigned short n)
 {
-	int len;
-
-	while (n > 0) {
-		len = blk_write(h, dst, src, n);
-		n -= len; src += len; dst += len;
-	}
-	return n;
+  int len;
+
+  while (n > 0)
+    {
+      len = blk_write (h, dst, src, n);
+      n -= len;
+      src += len;
+      dst += len;
+    }
+  return n;
 }
 
 
-AccessMethods
-hid_methods = {
-	.mem_read  = NULL,
-	.mem_write = mem_write_hid,
-	.go        = go_hid,
-	.bootstrap = NULL,
-	.flash_probe     = flash_probe_hid,
-	.flash_cmd = flash_cmd_hid,
-	.flash_status = flash_status_hid,
-	.flash_read = flash_read_hid,
-	.flash_writechunk = flash_writechunk_hid,
-	.flash_lock = NULL,
-};
+AccessMethods hid_methods =
+{
+.mem_read = NULL,.mem_write = mem_write_hid,.go = go_hid,.bootstrap =
+    NULL,.flash_probe = flash_probe_hid,.flash_cmd =
+    flash_cmd_hid,.flash_status = flash_status_hid,.flash_read =
+    flash_read_hid,.flash_writechunk = flash_writechunk_hid,.flash_lock =
+    NULL,};
 
 
 #ifdef TEST
-int main(int argc, char **argv)
+int
+main (int argc, char **argv)
 {
-	FILE *f;
-	int error;
-	DPFHANDLE dpf;
-	uint16_t startaddr = 0x1000;
-
-	if (argc >= 2) {
-
-		f = fopen(argv[1], "rb");
-
-		if (!f) {
-			printf("failed to open file\n");
-			return -1;
-		}
-		if (argc == 3) {
-			startaddr = strtol(argv[2], NULL, 16);
-			printf("Starting at %04x\n", startaddr);
-		}
-	
-		error = dpf_open("usb0", &dpf);
-		if (error < 0) {
-			printf("Failed to open DPF\n");
-			return error;
-		}
-		if (dpf->mode == MODE_USBHID) {
-			error = load(dpf, f, startaddr);
-		} else {
-			printf("Not in BOOTLOAD mode! Press Reset and hold MENU\n");
-		}
-		dpf_close(dpf);
- 	} else {
-		printf("Needs boot image argument\n");
-	}
-
-	if (error < 0) {
-		printf("Error\n");
-	}
-	return error;
+  FILE *f;
+  int error;
+  DPFHANDLE dpf;
+  uint16_t startaddr = 0x1000;
+
+  if (argc >= 2)
+    {
+
+      f = fopen (argv[1], "rb");
+
+      if (!f)
+        {
+          printf ("failed to open file\n");
+          return -1;
+        }
+      if (argc == 3)
+        {
+          startaddr = strtol (argv[2], NULL, 16);
+          printf ("Starting at %04x\n", startaddr);
+        }
+
+      error = dpf_open ("usb0", &dpf);
+      if (error < 0)
+        {
+          printf ("Failed to open DPF\n");
+          return error;
+        }
+      if (dpf->mode == MODE_USBHID)
+        {
+          error = load (dpf, f, startaddr);
+        }
+      else
+        {
+          printf ("Not in BOOTLOAD mode! Press Reset and hold MENU\n");
+        }
+      dpf_close (dpf);
+    }
+  else
+    {
+      printf ("Needs boot image argument\n");
+    }
+
+  if (error < 0)
+    {
+      printf ("Error\n");
+    }
+  return error;
 }
 #endif
diff --git a/libdpf/dpf.h b/libdpf/dpf.h
index d8d698d..c234b34 100644
--- a/libdpf/dpf.h
+++ b/libdpf/dpf.h
@@ -11,89 +11,96 @@
 
 #define ADDR unsigned int
 
-#define MODE_SG     0x00  ///< generic device mode (original)
-#define MODE_USB    0x01  ///< libusb operation mode (hacked)
-#define MODE_USBHID 0x02  ///< libusb HID boot mode
-
-#define FLAG_CAN_LOCK 0x80  ///< Has the locking feature (new firmware)
-
-enum {
-	DEVERR_FILE = -16,
-	DEVERR_OPEN,
-	DEVERR_HEX,
-	DEVERR_CHK,
-	DEVERR_IO,
-	DEVERR_MALLOC,
-	DEVERR_TIMEOUT,
-	DEVERR_UNSUPP,
+#define MODE_SG     0x00        ///< generic device mode (original)
+#define MODE_USB    0x01        ///< libusb operation mode (hacked)
+#define MODE_USBHID 0x02        ///< libusb HID boot mode
+
+#define FLAG_CAN_LOCK 0x80      ///< Has the locking feature (new firmware)
+
+enum
+{
+  DEVERR_FILE = -16,
+  DEVERR_OPEN,
+  DEVERR_HEX,
+  DEVERR_CHK,
+  DEVERR_IO,
+  DEVERR_MALLOC,
+  DEVERR_TIMEOUT,
+  DEVERR_UNSUPP,
 };
 
 /** The DPF context structure */
 struct dpf_context;
 #define DPFHANDLE struct dpf_context *
 
-typedef struct {
-	int (*mem_read)(DPFHANDLE h, unsigned char *buf, ADDR offset, int len);
-	int (*mem_write)(DPFHANDLE h,
-		ADDR dst, const unsigned char *buf, unsigned short n);
-	int (*go)(DPFHANDLE h, ADDR start);
-	int (*bootstrap)(DPFHANDLE h,
-		ADDR dest, unsigned char *src, unsigned short n, ADDR start);
-	int (*flash_probe)(DPFHANDLE h, unsigned char *id);
-	int (*flash_cmd)(DPFHANDLE h, int command, int cmdlen, ADDR addr);
-	int (*flash_status)(DPFHANDLE h, uint8_t *status);
-	int (*flash_read)(DPFHANDLE h, uint8_t *buf, ADDR offset, int len);
-	int (*flash_writechunk)(DPFHANDLE h,
-		const uint8_t *buf, ADDR offset, int len);
-	int (*flash_lock)(DPFHANDLE h, char enable);
+typedef struct
+{
+  int (*mem_read) (DPFHANDLE h, unsigned char *buf, ADDR offset, int len);
+  int (*mem_write) (DPFHANDLE h,
+                    ADDR dst, const unsigned char *buf, unsigned short n);
+  int (*go) (DPFHANDLE h, ADDR start);
+  int (*bootstrap) (DPFHANDLE h,
+                    ADDR dest, unsigned char *src, unsigned short n,
+                    ADDR start);
+  int (*flash_probe) (DPFHANDLE h, unsigned char *id);
+  int (*flash_cmd) (DPFHANDLE h, int command, int cmdlen, ADDR addr);
+  int (*flash_status) (DPFHANDLE h, uint8_t * status);
+  int (*flash_read) (DPFHANDLE h, uint8_t * buf, ADDR offset, int len);
+  int (*flash_writechunk) (DPFHANDLE h,
+                           const uint8_t * buf, ADDR offset, int len);
+  int (*flash_lock) (DPFHANDLE h, char enable);
 } AccessMethods;
 
-typedef
-struct dpf_context {
-	unsigned char mode;
-	unsigned char flags;
-	union {
-		usb_dev_handle *udev;
-		int fd;
-	} dev;
-	AccessMethods methods;
-	unsigned int width;
-	unsigned int height;
-	int bpp;
-	int proto;
-	char* buff;
-	unsigned char* oldpix;
-	int offx;
-	int offy;
+typedef struct dpf_context
+{
+  unsigned char mode;
+  unsigned char flags;
+  union
+  {
+    usb_dev_handle *udev;
+    int fd;
+  } dev;
+  AccessMethods methods;
+  unsigned int width;
+  unsigned int height;
+  int bpp;
+  int proto;
+  char *buff;
+  unsigned char *oldpix;
+  int offx;
+  int offy;
 } DPFContext;
 
 
 /** A value proxy for the property API */
-typedef struct dpf_proxy {
-	union {
-		short	integer;
-		char   *sequence;
-	} value;
-	char type;
+typedef struct dpf_proxy
+{
+  union
+  {
+    short integer;
+    char *sequence;
+  } value;
+  char type;
 } DPFValue;
 
-enum {
-	TYPE_INTEGER,
-	TYPE_STRING,
-}; 
+enum
+{
+  TYPE_INTEGER,
+  TYPE_STRING,
+};
 
 /**
  Opens the DPF device. if dev is not NULL, open device, otherwise, look for
  USB device.
  */
-int dpf_open(const char *dev, DPFHANDLE *h);
+int dpf_open (const char *dev, DPFHANDLE * h);
 
 /** Close DPF device */
-void dpf_close(DPFHANDLE h);
+void dpf_close (DPFHANDLE h);
 
 /** Set color register
  * \param rgb     RGB tuple */
-int dpf_setcol(DPFHANDLE h, const unsigned char *rgb);
+int dpf_setcol (DPFHANDLE h, const unsigned char *rgb);
 
 /** Blit data to screen
  *
@@ -101,32 +108,32 @@ int dpf_setcol(DPFHANDLE h, const unsigned char *rgb);
  * \param rect    rectangle tuple: [x0, y0, x1, y1]
  */
 
-int dpf_screen_blit(DPFHANDLE h, const unsigned char *buf, short rect[4]);
+int dpf_screen_blit (DPFHANDLE h, const unsigned char *buf, short rect[4]);
 
 /** Set property on DPF
  * \param token       Property token
  * \param value       Pointer to value
  */
-int dpf_setproperty(DPFHANDLE h, int token, const DPFValue *value);
+int dpf_setproperty (DPFHANDLE h, int token, const DPFValue * value);
 
 /* USB raw */
 
-int emulate_scsi(usb_dev_handle *d, unsigned char *cmd, int cmdlen, char out,
-	unsigned char *data, unsigned long block_len);
+int emulate_scsi (usb_dev_handle * d, unsigned char *cmd, int cmdlen,
+                  char out, unsigned char *data, unsigned long block_len);
 
-const char *dev_errstr(int err);
+const char *dev_errstr (int err);
 
 // Private stuff:
-int dpf_usb_open(int index, usb_dev_handle **u);
-int sgdev_open(const char *portname, int *fd);
-int usb_rawread(usb_dev_handle *dev, unsigned char *buf, int len);
-int usb_rawwrite(usb_dev_handle *dev, const unsigned char *buf, int len);
-int probe(DPFHANDLE h);
+int dpf_usb_open (int index, usb_dev_handle ** u);
+int sgdev_open (const char *portname, int *fd);
+int usb_rawread (usb_dev_handle * dev, unsigned char *buf, int len);
+int usb_rawwrite (usb_dev_handle * dev, const unsigned char *buf, int len);
+int probe (DPFHANDLE h);
 
 ////////////////////////////////////////////////////////////////////////////
 // Bootloader functionality
 
-int bl_go(DPFContext *dpf, uint16_t jmpoffset);
+int bl_go (DPFContext * dpf, uint16_t jmpoffset);
 
 ////////////////////////////////////////////////////////////////////////////
 // FLASH stuff
@@ -134,28 +141,29 @@ int bl_go(DPFContext *dpf, uint16_t jmpoffset);
 // Maximum size for flash_read
 #define MAX_CHUNKSIZE 0x10000
 
-int read_mem(DPFHANDLE h, unsigned char *buf, ADDR src, unsigned short len);
-int write_mem(DPFHANDLE h,
-	ADDR dst, const unsigned char *buf, unsigned short len);
+int read_mem (DPFHANDLE h, unsigned char *buf, ADDR src, unsigned short len);
+int write_mem (DPFHANDLE h,
+               ADDR dst, const unsigned char *buf, unsigned short len);
 
-int load_hexfile(DPFHANDLE h, const char *hexfile);
-int code_go(DPFHANDLE h, ADDR start);
+int load_hexfile (DPFHANDLE h, const char *hexfile);
+int code_go (DPFHANDLE h, ADDR start);
 
-int dpf_bootstrap(DPFHANDLE h,
-	ADDR dst, unsigned char *src, unsigned short n, ADDR start);
+int dpf_bootstrap (DPFHANDLE h,
+                   ADDR dst, unsigned char *src, unsigned short n,
+                   ADDR start);
 
-int flash_cmd(DPFHANDLE h, int command, int cmdlen, ADDR addr);
-int flash_probe(DPFContext *h, unsigned char *id);
-int flash_erase(DPFHANDLE h, ADDR offset);
-int flash_erase_full(DPFHANDLE h);
-int flash_write(DPFHANDLE h, const unsigned char *buf, ADDR offset, int len);
-int flash_read(DPFHANDLE h, unsigned char *buf, ADDR offset, int len);
+int flash_cmd (DPFHANDLE h, int command, int cmdlen, ADDR addr);
+int flash_probe (DPFContext * h, unsigned char *id);
+int flash_erase (DPFHANDLE h, ADDR offset);
+int flash_erase_full (DPFHANDLE h);
+int flash_write (DPFHANDLE h, const unsigned char *buf, ADDR offset, int len);
+int flash_read (DPFHANDLE h, unsigned char *buf, ADDR offset, int len);
 
-int load_ihx(DPFHANDLE h, const char *fname, unsigned char *data, 
-	unsigned int *buflen, unsigned int reloc);
+int load_ihx (DPFHANDLE h, const char *fname, unsigned char *data,
+              unsigned int *buflen, unsigned int reloc);
 
-int patch_sector(DPFHANDLE h,
-	ADDR reloc, unsigned long addr, const char *hexfile);
+int patch_sector (DPFHANDLE h,
+                  ADDR reloc, unsigned long addr, const char *hexfile);
 
 ////////////////////////////////////////////////////////////////////////////
 /* DPF specific stuff: */
@@ -169,10 +177,10 @@ int patch_sector(DPFHANDLE h,
 
 #define RGB565_S(r, g, b) ((RGB565_0(r, g, b) << 8) | RGB565_1(r, g, b))
 
-int dpfcpy(ADDR dst, unsigned char *src, unsigned short n);
+int dpfcpy (ADDR dst, unsigned char *src, unsigned short n);
 
 // int clr_screen(DPFHANDLE h, const unsigned char *col);
-int write_screen(DPFHANDLE h, const unsigned char *buf, unsigned int len);
+int write_screen (DPFHANDLE h, const unsigned char *buf, unsigned int len);
 
 
 // Some internal address offsets. They may change, but so far all types
@@ -184,6 +192,3 @@ int write_screen(DPFHANDLE h, const unsigned char *buf, unsigned int len);
 
 // FIXME: Should be 0x0020, once we have the firmware replaced
 #define OFFSET_PROPS 0x3f0020   ///< w[2]:LE : Resolution X, Y
-
-
-
diff --git a/libdpf/dpflib.c b/libdpf/dpflib.c
index cfda55b..3af8ebb 100644
--- a/libdpf/dpflib.c
+++ b/libdpf/dpflib.c
@@ -8,7 +8,7 @@
  * One day we might use a proper protocol like netpp.
  *
  */
-	
+
 // FIXME: Put all those SCSI commands in one (wrapped) place.
 
 #include "dpf.h"
@@ -49,326 +49,401 @@ int dpf_query(DPFHANDLE h)
 
 
 
-int dpf_open(const char *dev, DPFHANDLE *h)
+int
+dpf_open (const char *dev, DPFHANDLE * h)
 {
-	int error = 0;
-	DPFContext *dpf;
-	int i;
-	usb_dev_handle *u;
-
-	int fd;
-
-	if (!dev) {
-		fprintf(stderr, "Please specify a string like 'usb0' or a sg device\n");
-		return DEVERR_OPEN;
-	}
-
-	if (strncmp(dev, "usb", 3) == 0) {
-		i = dev[3] - '0';
-		error = dpf_usb_open(i, &u);
-		if (error < 0) return error;
-		if (!u) return DEVERR_OPEN;
-		i = error; // USB mode
-		error = 0;
-	} else {
-		fprintf(stderr, "Opening generic SCSI device '%s'\n", dev);
-		if (sgdev_open(dev, &fd) < 0) return DEVERR_OPEN;
-		i = MODE_SG;
-	}
-
-	dpf = (DPFHANDLE) malloc(sizeof(DPFContext));
-	if (!dpf) return DEVERR_MALLOC;
-
-	dpf->flags = 0;
-	dpf->mode = i;
-
-	switch (dpf->mode) {
-		case MODE_USB:
-			dpf->dev.udev = u;
-			error = probe(dpf);
-			fprintf(stderr, "Got LCD dimensions: %dx%d\n",
-				dpf->width, dpf->height);
-			dpf->methods = scsi_methods;
-			break;
-		case MODE_USBHID:
-			dpf->dev.udev = u;
-			dpf->methods = hid_methods;
-			break;
-		case MODE_SG:
-			dpf->dev.fd = fd;
-			dpf->methods = scsi_methods;
-			break;
-		default:
-			fprintf(stderr, "Unknown interface mode\n");
-			error = -1;
-	}
-
-	*h = dpf;
-	return error;
+  int error = 0;
+  DPFContext *dpf;
+  int i;
+  usb_dev_handle *u;
+
+  int fd;
+
+  if (!dev)
+    {
+      fprintf (stderr,
+               "Please specify a string like 'usb0' or a sg device\n");
+      return DEVERR_OPEN;
+    }
+
+  if (strncmp (dev, "usb", 3) == 0)
+    {
+      i = dev[3] - '0';
+      error = dpf_usb_open (i, &u);
+      if (error < 0)
+        return error;
+      if (!u)
+        return DEVERR_OPEN;
+      i = error;                // USB mode
+      error = 0;
+    }
+  else
+    {
+      fprintf (stderr, "Opening generic SCSI device '%s'\n", dev);
+      if (sgdev_open (dev, &fd) < 0)
+        return DEVERR_OPEN;
+      i = MODE_SG;
+    }
+
+  dpf = (DPFHANDLE) malloc (sizeof (DPFContext));
+  if (!dpf)
+    return DEVERR_MALLOC;
+
+  dpf->flags = 0;
+  dpf->mode = i;
+
+  switch (dpf->mode)
+    {
+    case MODE_USB:
+      dpf->dev.udev = u;
+      error = probe (dpf);
+      fprintf (stderr, "Got LCD dimensions: %dx%d\n",
+               dpf->width, dpf->height);
+      dpf->methods = scsi_methods;
+      break;
+    case MODE_USBHID:
+      dpf->dev.udev = u;
+      dpf->methods = hid_methods;
+      break;
+    case MODE_SG:
+      dpf->dev.fd = fd;
+      dpf->methods = scsi_methods;
+      break;
+    default:
+      fprintf (stderr, "Unknown interface mode\n");
+      error = -1;
+    }
+
+  *h = dpf;
+  return error;
 }
 
-void dpf_close(DPFContext *h)
+void
+dpf_close (DPFContext * h)
 {
-	switch (h->mode) {
-		case MODE_USBHID:
-		case MODE_SG:
-			close(h->dev.fd);
-			break;
-		case MODE_USB:
-			usb_release_interface(h->dev.udev, 0);
-			usb_close(h->dev.udev);
-			break;
-	}
-	free(h);
+  switch (h->mode)
+    {
+    case MODE_USBHID:
+    case MODE_SG:
+      close (h->dev.fd);
+      break;
+    case MODE_USB:
+      usb_release_interface (h->dev.udev, 0);
+      usb_close (h->dev.udev);
+      break;
+    }
+  free (h);
 }
 
-const char *dev_errstr(int err)
+const char *
+dev_errstr (int err)
 {
-	switch (err) {
-	case DEVERR_FILE: return "File I/O error";
-	case DEVERR_OPEN: return "File open error";
-	case DEVERR_HEX: return "Hex file error";
-	case DEVERR_CHK: return "Checksum error";
-	case DEVERR_IO: return "Common I/O error";
-	case DEVERR_UNSUPP: return "Unsupported feature";
-	default: return "Unknown error";
-	}
+  switch (err)
+    {
+    case DEVERR_FILE:
+      return "File I/O error";
+    case DEVERR_OPEN:
+      return "File open error";
+    case DEVERR_HEX:
+      return "Hex file error";
+    case DEVERR_CHK:
+      return "Checksum error";
+    case DEVERR_IO:
+      return "Common I/O error";
+    case DEVERR_UNSUPP:
+      return "Unsupported feature";
+    default:
+      return "Unknown error";
+    }
 }
 
 
-int flash_probe(DPFContext *h, unsigned char *id)
+int
+flash_probe (DPFContext * h, unsigned char *id)
 {
-	return h->methods.flash_probe(h, id);
+  return h->methods.flash_probe (h, id);
 }
 
-int flash_cmd(DPFContext *h, int command, int cmdlen, ADDR addr)
+int
+flash_cmd (DPFContext * h, int command, int cmdlen, ADDR addr)
 {
-	return h->methods.flash_cmd(h, command, cmdlen, addr);
+  return h->methods.flash_cmd (h, command, cmdlen, addr);
 }
 
 
 /* Flash functions, API */
 
-int flash_read(DPFContext *h, unsigned char *buf, ADDR offset, int len)
+int
+flash_read (DPFContext * h, unsigned char *buf, ADDR offset, int len)
 {
-	return h->methods.flash_read(h, buf, offset, len);
+  return h->methods.flash_read (h, buf, offset, len);
 }
 
-int flash_status_wait(DPFContext *h, uint8_t mask)
+int
+flash_status_wait (DPFContext * h, uint8_t mask)
 {
-	int error;
-	uint8_t status;
-	
-	do {
-		error = h->methods.flash_status(h, &status);
-	} while ((status & mask) && !error);
-
-	return error;
+  int error;
+  uint8_t status;
+
+  do
+    {
+      error = h->methods.flash_status (h, &status);
+    }
+  while ((status & mask) && !error);
+
+  return error;
 }
 
 
-int flash_write(DPFContext *h, const unsigned char *buf, ADDR offset, int len)
+int
+flash_write (DPFContext * h, const unsigned char *buf, ADDR offset, int len)
 {
-	int n;
-	int error = 0;
-
-	while (len > 0) {
-		error = h->methods.flash_cmd(h, SPM_WREN, 1, 0);
-		DEB(printf("Write pages at %06x\n", offset));
-		n = h->methods.flash_writechunk(h, buf, offset, len);
-		error = flash_status_wait(h, SPS_WIP);
-
-		if (n < 0) break;
-		len -= n; buf += n; offset += n;
-	}
-	return error;
+  int n;
+  int error = 0;
+
+  while (len > 0)
+    {
+      error = h->methods.flash_cmd (h, SPM_WREN, 1, 0);
+      DEB (printf ("Write pages at %06x\n", offset));
+      n = h->methods.flash_writechunk (h, buf, offset, len);
+      error = flash_status_wait (h, SPS_WIP);
+
+      if (n < 0)
+        break;
+      len -= n;
+      buf += n;
+      offset += n;
+    }
+  return error;
 }
 
 /* Mid level flash */
 
-int load_ihx(DPFContext *h, const char *fname, unsigned char *data, 
-	unsigned int *buflen, unsigned int reloc)
+int
+load_ihx (DPFContext * h, const char *fname, unsigned char *data,
+          unsigned int *buflen, unsigned int reloc)
 {
-	unsigned char csum_is, csum_need;
-	int ret;
-	FILE *f;
-
-	static char line[512];
-	static unsigned char buf[0x100];
-	int count;
-	unsigned int addr, len, type;
-	unsigned short b;
-	unsigned int total = 0;
-
-	DEB(printf("Opening %s...\n", fname));
-    f = fopen(fname, "r");
-    if (f == NULL) {
-        return DEVERR_OPEN; 
+  unsigned char csum_is, csum_need;
+  int ret;
+  FILE *f;
+
+  static char line[512];
+  static unsigned char buf[0x100];
+  int count;
+  unsigned int addr, len, type;
+  unsigned short b;
+  unsigned int total = 0;
+
+  DEB (printf ("Opening %s...\n", fname));
+  f = fopen (fname, "r");
+  if (f == NULL)
+    {
+      return DEVERR_OPEN;
     }
 
-    while(1) {
-        fgets(line, sizeof(line), f);
+  while (1)
+    {
+      fgets (line, sizeof (line), f);
 
-        if (feof(f) || ferror(f)) break;
+      if (feof (f) || ferror (f))
+        break;
 
-        if ((line[0] != ':') || (strlen(line) < 9)) {
-            fprintf(stderr, "invalid line in ihx\n");
-            break;
+      if ((line[0] != ':') || (strlen (line) < 9))
+        {
+          fprintf (stderr, "invalid line in ihx\n");
+          break;
         }
 
-        ret = sscanf(&line[1], "%02x", &len);
-        if (ret != 1) { ret = DEVERR_HEX; break; }
+      ret = sscanf (&line[1], "%02x", &len);
+      if (ret != 1)
+        {
+          ret = DEVERR_HEX;
+          break;
+        }
 
-        ret = sscanf(&line[3], "%04x", &addr);
-        if (ret != 1) { ret = DEVERR_HEX; break; }
+      ret = sscanf (&line[3], "%04x", &addr);
+      if (ret != 1)
+        {
+          ret = DEVERR_HEX;
+          break;
+        }
 
-        ret = sscanf(&line[7], "%02x", &type);
-        if (ret != 1) { ret = DEVERR_HEX; break; }
+      ret = sscanf (&line[7], "%02x", &type);
+      if (ret != 1)
+        {
+          ret = DEVERR_HEX;
+          break;
+        }
 
 #ifdef DEBUG
-        printf("len %u addr %04x type %u\n", len, addr, type);
+      printf ("len %u addr %04x type %u\n", len, addr, type);
 #endif
 
-        if (type == 1) break;
+      if (type == 1)
+        break;
+
+      if (type != 0)
+        {
+          fprintf (stderr, "ihx: unknown type %u\n", type);
+          continue;
+        }
+
+      csum_need = len + (addr & 0xff) + (addr >> 8) + type;
+
+      total += len;
+      if (total > *buflen)
+        {
+          fprintf (stderr, "Buffer length exceeded. IHX file too big.\n");
+          ret = DEVERR_HEX;
+          break;
+        }
 
-        if (type != 0) {
-            fprintf(stderr, "ihx: unknown type %u\n", type);
-            continue;
+      if (len > sizeof (buf))
+        {
+          fprintf (stderr, "Buffer length exceeded. Too long lines.\n");
+          ret = DEVERR_HEX;
+          break;
         }
 
-        csum_need = len + (addr & 0xff) + (addr >> 8) + type;
-
-		total += len;
-		if (total > *buflen) {
-			fprintf(stderr, "Buffer length exceeded. IHX file too big.\n");
-			ret = DEVERR_HEX;
-			break;
-		}
-
-		if (len > sizeof(buf)) {
-			fprintf(stderr, "Buffer length exceeded. Too long lines.\n");
-			ret = DEVERR_HEX;
-			break;
-		}
-
-        for(count = 0; count < len; count++) {
-            ret = sscanf(&line[9 + count * 2], "%02hx", &b);
-            if (ret != 1) {
-                fprintf(stderr, "hex file: could not parse data!\n");
-                break;
+      for (count = 0; count < len; count++)
+        {
+          ret = sscanf (&line[9 + count * 2], "%02hx", &b);
+          if (ret != 1)
+            {
+              fprintf (stderr, "hex file: could not parse data!\n");
+              break;
             }
 
-            buf[count] = b;
-            csum_need += buf[count];
+          buf[count] = b;
+          csum_need += buf[count];
         }
 
-        if (ret != 1) { ret = DEVERR_HEX; break; }
+      if (ret != 1)
+        {
+          ret = DEVERR_HEX;
+          break;
+        }
 
-        ret = sscanf(&line[9 + len * 2], "%02hx", &b);
-        if (ret != 1) { ret = DEVERR_HEX; break; }
+      ret = sscanf (&line[9 + len * 2], "%02hx", &b);
+      if (ret != 1)
+        {
+          ret = DEVERR_HEX;
+          break;
+        }
 
-        csum_is = b;
-        if (((csum_need+csum_is) & 0xff) != 0x00) {
-            fprintf(stderr, "ihx: checksum failure! is: %02x should be:%02x\n",
+      csum_is = b;
+      if (((csum_need + csum_is) & 0xff) != 0x00)
+        {
+          fprintf (stderr, "ihx: checksum failure! is: %02x should be:%02x\n",
                    csum_is, csum_need);
-            ret = DEVERR_CHK;
-			break;
+          ret = DEVERR_CHK;
+          break;
         }
 
-		if (addr < reloc) {
-			fprintf(stderr, "Bad relocation value\n");
-			ret = DEVERR_HEX;
-			break;
-		}
-		// Copy to data buffer at relocated address
-		if (data) {
-			DEB(printf("Patching at offset %08x, chunk size %d\n",
-				addr - reloc, len));
-			memcpy(&data[addr - reloc], buf, len);
-		} else {
-			DEB(printf("Writing to %04x (CODE: %04x), chunk size %d\n",
-				addr - reloc, addr, len));
-			h->methods.mem_write(h, addr - reloc, buf, len);
-		}
+      if (addr < reloc)
+        {
+          fprintf (stderr, "Bad relocation value\n");
+          ret = DEVERR_HEX;
+          break;
+        }
+      // Copy to data buffer at relocated address
+      if (data)
+        {
+          DEB (printf ("Patching at offset %08x, chunk size %d\n",
+                       addr - reloc, len));
+          memcpy (&data[addr - reloc], buf, len);
+        }
+      else
+        {
+          DEB (printf ("Writing to %04x (CODE: %04x), chunk size %d\n",
+                       addr - reloc, addr, len));
+          h->methods.mem_write (h, addr - reloc, buf, len);
+        }
     }
-	*buflen = total;
-    fclose(f);
-	return ret;
+  *buflen = total;
+  fclose (f);
+  return ret;
 }
 
-int flash_erase_full(DPFContext *h)
+int
+flash_erase_full (DPFContext * h)
 {
-	flash_cmd(h, SPM_RES, 1, 0);
-	flash_cmd(h, SPM_WRSR, 2, 0); // clr status
-	flash_cmd(h, SPM_WREN, 1, 0);
-	flash_cmd(h, SPM_FLASH_BE, 1, 0);
-	printf("Erase full flash...\n");
+  flash_cmd (h, SPM_RES, 1, 0);
+  flash_cmd (h, SPM_WRSR, 2, 0); // clr status
+  flash_cmd (h, SPM_WREN, 1, 0);
+  flash_cmd (h, SPM_FLASH_BE, 1, 0);
+  printf ("Erase full flash...\n");
 
-	return flash_status_wait(h, SPS_WIP);
+  return flash_status_wait (h, SPS_WIP);
 }
 
-int flash_erase(DPFContext *h, ADDR addr)
+int
+flash_erase (DPFContext * h, ADDR addr)
 {
-	int error;
-	flash_cmd(h, SPM_RES, 1, 0);
-	flash_cmd(h, SPM_WREN, 1, 0);
-	flash_cmd(h, SPM_WRSR, 2, 0); // clr status
+  int error;
+  flash_cmd (h, SPM_RES, 1, 0);
+  flash_cmd (h, SPM_WREN, 1, 0);
+  flash_cmd (h, SPM_WRSR, 2, 0); // clr status
 
-	// now erase flash sector:
-	flash_cmd(h, SPM_WREN, 1, 0);
-	flash_cmd(h, SPM_FLASH_SE, 4, addr);
+  // now erase flash sector:
+  flash_cmd (h, SPM_WREN, 1, 0);
+  flash_cmd (h, SPM_FLASH_SE, 4, addr);
 
-	error = flash_status_wait(h, SPS_WIP);
-	flash_cmd(h, SPM_WRDI, 1, 0);
+  error = flash_status_wait (h, SPS_WIP);
+  flash_cmd (h, SPM_WRDI, 1, 0);
 
-	return error;
+  return error;
 }
 
-int dpf_flash_lock(DPFContext *h, char enable)
+int
+dpf_flash_lock (DPFContext * h, char enable)
 {
-	if (h->methods.flash_lock) 
-		return h->methods.flash_lock(h, enable);
-	else
-		return DEVERR_UNSUPP;
+  if (h->methods.flash_lock)
+    return h->methods.flash_lock (h, enable);
+  else
+    return DEVERR_UNSUPP;
 }
 
 
-int patch_sector(DPFContext *h,
-	ADDR reloc, unsigned long addr, const char *hexfile)
+int
+patch_sector (DPFContext * h,
+              ADDR reloc, unsigned long addr, const char *hexfile)
 {
-	int error;
-	unsigned short offset;
-	static
-	unsigned char readbuf[0x10000];
-	unsigned int len = sizeof(readbuf);
-
-	offset = addr & 0xffff;
-	addr -= offset;
-
-	error = flash_read(h, readbuf, addr, 0x10000);
-	if (error < 0) {
-		perror("Reading flash");
-		return error;
-	}
-
-	error = load_ihx(h, hexfile, &readbuf[offset], &len, reloc);
-	if (error < 0) {
-		fprintf(stderr, "Failed to load HEX file\n");
-		return error;
-	}
- // Lock DPF handler so nothing can interfere with the flashing (in case
- // we flash ourselves)
-	dpf_flash_lock(h, 1);
-	error = flash_cmd(h, SPM_WREN, 1, 0);
-	error = flash_cmd(h, SPM_WRSR, 2, 0); // clr status
-
-	error = flash_erase(h, addr);
-	if (error < 0) return error;
-
-	error = flash_write(h, readbuf, addr, 0x10000); // clr status
-	dpf_flash_lock(h, 0);
-
-	return error;
+  int error;
+  unsigned short offset;
+  static unsigned char readbuf[0x10000];
+  unsigned int len = sizeof (readbuf);
+
+  offset = addr & 0xffff;
+  addr -= offset;
+
+  error = flash_read (h, readbuf, addr, 0x10000);
+  if (error < 0)
+    {
+      perror ("Reading flash");
+      return error;
+    }
+
+  error = load_ihx (h, hexfile, &readbuf[offset], &len, reloc);
+  if (error < 0)
+    {
+      fprintf (stderr, "Failed to load HEX file\n");
+      return error;
+    }
+  // Lock DPF handler so nothing can interfere with the flashing (in case
+  // we flash ourselves)
+  dpf_flash_lock (h, 1);
+  error = flash_cmd (h, SPM_WREN, 1, 0);
+  error = flash_cmd (h, SPM_WRSR, 2, 0); // clr status
+
+  error = flash_erase (h, addr);
+  if (error < 0)
+    return error;
+
+  error = flash_write (h, readbuf, addr, 0x10000); // clr status
+  dpf_flash_lock (h, 0);
+
+  return error;
 }
 
 ////////////////////////////////////////////////////////////////////////////
@@ -376,42 +451,51 @@ int patch_sector(DPFContext *h,
 // These require a hacked command handler with extended command set.
 
 
-int load_hexfile(DPFContext *h, const char *hexfile)
+int
+load_hexfile (DPFContext * h, const char *hexfile)
 {
-	unsigned int len = 0xc000;
-	int error;
+  unsigned int len = 0xc000;
+  int error;
 
-	error = load_ihx(h, hexfile, 0, &len, 0x800);
-	return error;
+  error = load_ihx (h, hexfile, 0, &len, 0x800);
+  return error;
 }
 
 #define CHUNK_SIZE 1024
 
-int read_mem(DPFContext *h, unsigned char *buf, ADDR src, unsigned short len)
+int
+read_mem (DPFContext * h, unsigned char *buf, ADDR src, unsigned short len)
 {
-	int error = 0;
-	if (!h->methods.mem_read) return DEVERR_UNSUPP;
-
-	while (len > CHUNK_SIZE && error >= 0) {
-		error = h->methods.mem_read(h, buf, src, CHUNK_SIZE);
-		src += CHUNK_SIZE; len -= CHUNK_SIZE; buf += CHUNK_SIZE;
-	}
-	error = h->methods.mem_read(h, buf, src, len);
-	
-	return error;
+  int error = 0;
+  if (!h->methods.mem_read)
+    return DEVERR_UNSUPP;
+
+  while (len > CHUNK_SIZE && error >= 0)
+    {
+      error = h->methods.mem_read (h, buf, src, CHUNK_SIZE);
+      src += CHUNK_SIZE;
+      len -= CHUNK_SIZE;
+      buf += CHUNK_SIZE;
+    }
+  error = h->methods.mem_read (h, buf, src, len);
+
+  return error;
 }
 
-int write_mem(DPFContext *h, ADDR dst, const unsigned char *buf, unsigned short len)
+int
+write_mem (DPFContext * h, ADDR dst, const unsigned char *buf,
+           unsigned short len)
 {
-	return h->methods.mem_write(h, dst, buf, len);
+  return h->methods.mem_write (h, dst, buf, len);
 }
 
-int code_go(DPFContext *h, ADDR start)
+int
+code_go (DPFContext * h, ADDR start)
 {
-	printf("Executing applet..\n");
-	if (h->methods.go)
-		return h->methods.go(h, start);
-	return DEVERR_UNSUPP;
+  printf ("Executing applet..\n");
+  if (h->methods.go)
+    return h->methods.go (h, start);
+  return DEVERR_UNSUPP;
 }
 
 
@@ -423,14 +507,12 @@ int code_go(DPFContext *h, ADDR start)
  * into start address
  */
 
-int dpf_bootstrap(DPFContext *h,
-	ADDR dest, unsigned char *src, unsigned short n, ADDR start)
+int
+dpf_bootstrap (DPFContext * h,
+               ADDR dest, unsigned char *src, unsigned short n, ADDR start)
 {
-	if (h->methods.bootstrap)
-		return h->methods.bootstrap(h, dest, src, n, start);
-	else
-		return DEVERR_UNSUPP;
+  if (h->methods.bootstrap)
+    return h->methods.bootstrap (h, dest, src, n, start);
+  else
+    return DEVERR_UNSUPP;
 }
-
-
-
diff --git a/libdpf/flash.h b/libdpf/flash.h
index f753bd5..a7fce2a 100644
--- a/libdpf/flash.h
+++ b/libdpf/flash.h
@@ -1,19 +1,18 @@
 // SPI STM flash commands:
 // stolen from BFloader
 
-#define SPM_RDID              0x9f    // Read ID
-#define SPM_WREN              0x06    // Write enable
-#define SPM_WRDI              0x04    // Write disable
-#define SPM_RDSR              0x05    // Read status register
-#define SPM_WRSR              0x01    // Write status register
-#define SPM_READ              0x03    // Read data bytes
-#define SPM_PP                0x02    // Page program
-#define SPM_DP                0xb9    // Deep power down
-#define SPM_RES               0xab    // Release from deep power down
+#define SPM_RDID              0x9f // Read ID
+#define SPM_WREN              0x06 // Write enable
+#define SPM_WRDI              0x04 // Write disable
+#define SPM_RDSR              0x05 // Read status register
+#define SPM_WRSR              0x01 // Write status register
+#define SPM_READ              0x03 // Read data bytes
+#define SPM_PP                0x02 // Page program
+#define SPM_DP                0xb9 // Deep power down
+#define SPM_RES               0xab // Release from deep power down
                                       // and read signature
-#define SPM_FLASH_SE          0xd8    // Sector erase
-#define SPM_FLASH_BE          0xc7    // Bulk erase
-#define SPM_FLASH_FAST_READ   0x0B    // Read data bytes fast
-
-#define SPM_SR_SRWD           0x80    // SR write protection (HW)
+#define SPM_FLASH_SE          0xd8 // Sector erase
+#define SPM_FLASH_BE          0xc7 // Bulk erase
+#define SPM_FLASH_FAST_READ   0x0B // Read data bytes fast
 
+#define SPM_SR_SRWD           0x80 // SR write protection (HW)
diff --git a/libdpf/fwload.c b/libdpf/fwload.c
index 2b98762..90ec961 100644
--- a/libdpf/fwload.c
+++ b/libdpf/fwload.c
@@ -13,19 +13,25 @@
 
 // Demo stuff:
 
-void memory_dump(unsigned char *buf, unsigned int n)
+void
+memory_dump (unsigned char *buf, unsigned int n)
 {
-	int i = 0;
-	int c = 0;
-
-	while (i < n) {
-		printf("%02x ", buf[i]);
-		c++;
-		if (c == 16) { c = 0; printf("\n"); }
-			i++;
-	}
-	if (c)
-		printf("\n");
+  int i = 0;
+  int c = 0;
+
+  while (i < n)
+    {
+      printf ("%02x ", buf[i]);
+      c++;
+      if (c == 16)
+        {
+          c = 0;
+          printf ("\n");
+        }
+      i++;
+    }
+  if (c)
+    printf ("\n");
 }
 
 ////////////////////////////////////////////////////////////////////////////
@@ -33,89 +39,102 @@ void memory_dump(unsigned char *buf, unsigned int n)
 
 #if EXPERIMENTAL
 
-int xmain(int argc, char **argv)
+int
+xmain (int argc, char **argv)
 {
-	int ret;
-	int i;
-	struct banktable *bt;
-
-	// flash offset, offset after jump table
-	unsigned int offset = 0x80000 + 0x200;
-
-
-	static unsigned char buf[0x10000];
-	unsigned int len = sizeof(buf);
-	ret = load_ihx(argv[1], buf, &len, 0x127c, g_banktab);
-	if (ret < 0) {
-		fprintf(stderr, "Failed to load HEX file\n");
-		return ret;
-	} else {
-		printf("Read %d banks\n", ret);
-		for (i = 0; i < ret; i++) {
-			bt = &g_banktab[i];
-			printf("	{ XADDR(0x%04x), XADDR(0x%04x), FOFFS(0x%06x) },\n",
-				bt->reloc, bt->reloc + bt->len, offset + bt->offset);
-
-		}
-	}
-	return 0;
+  int ret;
+  int i;
+  struct banktable *bt;
+
+  // flash offset, offset after jump table
+  unsigned int offset = 0x80000 + 0x200;
+
+
+  static unsigned char buf[0x10000];
+  unsigned int len = sizeof (buf);
+  ret = load_ihx (argv[1], buf, &len, 0x127c, g_banktab);
+  if (ret < 0)
+    {
+      fprintf (stderr, "Failed to load HEX file\n");
+      return ret;
+    }
+  else
+    {
+      printf ("Read %d banks\n", ret);
+      for (i = 0; i < ret; i++)
+        {
+          bt = &g_banktab[i];
+          printf ("	{ XADDR(0x%04x), XADDR(0x%04x), FOFFS(0x%06x) },\n",
+                  bt->reloc, bt->reloc + bt->len, offset + bt->offset);
+
+        }
+    }
+  return 0;
 }
 
 #endif
 
-int main(int argc, char **argv)
+int
+main (int argc, char **argv)
 {
-	int ret;
-	DPFHANDLE h;
-
-	int i = 2;
-
-	if (argc < 2 || argc > 3) {
-		fprintf(stderr, "Usage:\n"
-				"%s <generic scsi dev> <.ihx file>\n"
-		        "or in USB mode:\n"
-		        "%s <.ihx file>\n",
-		argv[0], argv[0]);
-		return -1;
-	}
-
-	if (argc == 2) {
-		ret = dpf_open(NULL, &h);
-		i--;
-	} else
-	if (argc == 3) {
-		ret = dpf_open(argv[1], &h);
-	}
-
-	if (ret < 0) {
-		perror("opening DPF device:");
-		return ret;
-	}
-
-// 	This patches a module to init the relocated jump table on a certain
-// 	menu action:
-// 	ret = patch_sector(h, 0x1330, 0x4af7a, "hack2.ihx");
-
-
-// 	patch_sector(h,          0x0,    0x100000, "jumptbl.ihx");
-
-	if (0) {
-		patch_sector(h,          0x0,    0x100000, "jumptbl.ihx");
-		ret = patch_sector(h,       0x1330,    0x110000, "hack.ihx");
-		ret = patch_sector(h, 0x132a,    0x120000, "main.ihx");
-		if (ret < 0) printf("Failed.\n");
-	} else {
-	 // demo0(h);
-
-	}
-	ret = load_hexfile(h, argv[i]);
-	code_go(h, 0x18a0);
-	if (ret < 0) printf("Failed.\n");
-
-	// unsigned char buf[256];
-	// ret = read_mem(h, buf, 0x18a0, 64);
-	// memory_dump(buf, 64);
-
-	dpf_close(h);
-	return ret;
+  int ret;
+  DPFHANDLE h;
+
+  int i = 2;
+
+  if (argc < 2 || argc > 3)
+    {
+      fprintf (stderr, "Usage:\n"
+               "%s <generic scsi dev> <.ihx file>\n"
+               "or in USB mode:\n" "%s <.ihx file>\n", argv[0], argv[0]);
+      return -1;
+    }
+
+  if (argc == 2)
+    {
+      ret = dpf_open (NULL, &h);
+      i--;
+    }
+  else if (argc == 3)
+    {
+      ret = dpf_open (argv[1], &h);
+    }
+
+  if (ret < 0)
+    {
+      perror ("opening DPF device:");
+      return ret;
+    }
+
+//  This patches a module to init the relocated jump table on a certain
+//  menu action:
+//  ret = patch_sector(h, 0x1330, 0x4af7a, "hack2.ihx");
+
+
+//  patch_sector(h,          0x0,    0x100000, "jumptbl.ihx");
+
+  if (0)
+    {
+      patch_sector (h, 0x0, 0x100000, "jumptbl.ihx");
+      ret = patch_sector (h, 0x1330, 0x110000, "hack.ihx");
+      ret = patch_sector (h, 0x132a, 0x120000, "main.ihx");
+      if (ret < 0)
+        printf ("Failed.\n");
+    }
+  else
+    {
+      // demo0(h);
+
+    }
+  ret = load_hexfile (h, argv[i]);
+  code_go (h, 0x18a0);
+  if (ret < 0)
+    printf ("Failed.\n");
+
+  // unsigned char buf[256];
+  // ret = read_mem(h, buf, 0x18a0, 64);
+  // memory_dump(buf, 64);
+
+  dpf_close (h);
+  return ret;
 }
diff --git a/libdpf/rawusb.c b/libdpf/rawusb.c
index cbd344c..9015bb2 100644
--- a/libdpf/rawusb.c
+++ b/libdpf/rawusb.c
@@ -20,176 +20,209 @@
 #define ENDPT_OUT 1
 #define ENDPT_IN 0x81
 
-struct known_device {
-	char *desc;
-	unsigned short vid;
-	unsigned short pid;
-} g_known_devices[] = {
-	{ "AX206 DPF", 0x1908, 0x0102 },
-	{ "AX206 DPF (bootloader)", 0x1908, 0x3318 },
-	{ 0 , 0, 0 } /* NEVER REMOVE THIS */
+struct known_device
+{
+  char *desc;
+  unsigned short vid;
+  unsigned short pid;
+} g_known_devices[] =
+{
+  {
+  "AX206 DPF", 0x1908, 0x0102},
+  {
+  "AX206 DPF (bootloader)", 0x1908, 0x3318},
+  {
+  0, 0, 0}                      /* NEVER REMOVE THIS */
 };
 
-int handle_error(char *txt)
+int
+handle_error (char *txt)
 {
-	fprintf(stderr, "Error: %s\n", txt);
-	return -1;
+  fprintf (stderr, "Error: %s\n", txt);
+  return -1;
 }
 
-void usb_flush(usb_dev_handle *dev)
+void
+usb_flush (usb_dev_handle * dev)
 {
-	char buf[20];
-	usb_bulk_read(dev, ENDPT_IN, buf, 3, 1000);
+  char buf[20];
+  usb_bulk_read (dev, ENDPT_IN, buf, 3, 1000);
 }
 
-int check_known_device(struct usb_device *d)
+int
+check_known_device (struct usb_device *d)
 {
-	struct known_device *dev = g_known_devices;
-
-	while (dev->desc) {
-		if ((d->descriptor.idVendor == dev->vid) &&
-			(d->descriptor.idProduct == dev->pid)) { 
-				fprintf(stderr, "Found %s\n", dev->desc);
-				return 1;
-		}
-		dev++;
-	}
-	return 0;
+  struct known_device *dev = g_known_devices;
+
+  while (dev->desc)
+    {
+      if ((d->descriptor.idVendor == dev->vid) &&
+          (d->descriptor.idProduct == dev->pid))
+        {
+          fprintf (stderr, "Found %s\n", dev->desc);
+          return 1;
+        }
+      dev++;
+    }
+  return 0;
 }
 
-static struct usb_device *find_dev(int index)
+static struct usb_device *
+find_dev (int index)
 {
-	struct usb_bus *b;
-	struct usb_device *d;
-	int enumeration = 0;
-
-	b = usb_get_busses();
-
-	while (b) {
-		d = b->devices;
-		while (d) {
-			if (check_known_device(d)) {
-				if (enumeration == index) return d;
-				else enumeration++;
-			}
+  struct usb_bus *b;
+  struct usb_device *d;
+  int enumeration = 0;
+
+  b = usb_get_busses ();
+
+  while (b)
+    {
+      d = b->devices;
+      while (d)
+        {
+          if (check_known_device (d))
+            {
+              if (enumeration == index)
+                return d;
+              else
+                enumeration++;
+            }
 
 #ifdef DEBUG
-			printf("enum: %d index: %d\n", enumeration, index);
-			printf("%04x %04x\n",
-				   d->descriptor.idVendor,
-				   d->descriptor.idProduct);
+          printf ("enum: %d index: %d\n", enumeration, index);
+          printf ("%04x %04x\n",
+                  d->descriptor.idVendor, d->descriptor.idProduct);
 #endif
-			d = d->next;
-		}
-		b = b->next;
-	}
-	return NULL;
+          d = d->next;
+        }
+      b = b->next;
+    }
+  return NULL;
 }
 
 char g_buf[] = {
-	0x55, 0x53, 0x42, 0x43, // dCBWSignature
-	0xde, 0xad, 0xbe, 0xef, // dCBWTag
-	0x00, 0x80, 0x00, 0x00, // dCBWLength
-	0x00, // bmCBWFlags: 0x80: data in (dev to host), 0x00: Data out
-	0x00, // bCBWLUN
-	0x10, // bCBWCBLength
-
-	// SCSI cmd:
-	0xcd, 0x00, 0x00, 0x00,
-	0x00, 0x06, 0x11, 0xf8,
-	0x70, 0x00, 0x40, 0x00,
-	0x00, 0x00, 0x00, 0x00,
+  0x55, 0x53, 0x42, 0x43,       // dCBWSignature
+  0xde, 0xad, 0xbe, 0xef,       // dCBWTag
+  0x00, 0x80, 0x00, 0x00,       // dCBWLength
+  0x00,                         // bmCBWFlags: 0x80: data in (dev to host), 0x00: Data out
+  0x00,                         // bCBWLUN
+  0x10,                         // bCBWCBLength
+
+  // SCSI cmd:
+  0xcd, 0x00, 0x00, 0x00,
+  0x00, 0x06, 0x11, 0xf8,
+  0x70, 0x00, 0x40, 0x00,
+  0x00, 0x00, 0x00, 0x00,
 };
 
-int emulate_scsi(usb_dev_handle *dev, unsigned char *cmd, int cmdlen, char out,
-	unsigned char *data, unsigned long block_len)
+int
+emulate_scsi (usb_dev_handle * dev, unsigned char *cmd, int cmdlen, char out,
+              unsigned char *data, unsigned long block_len)
 {
-	int len;
-	int ret;
-	static unsigned char ansbuf[13]; // Do not change size.
-
-	g_buf[14] = cmdlen;
-	memcpy(&g_buf[15], cmd, cmdlen);
-
-	g_buf[8] = block_len;
-	g_buf[9] = block_len >> 8;
-	g_buf[10] = block_len >> 16;
-	g_buf[11] = block_len >> 24;
-
-	ret = usb_bulk_write(dev, ENDPT_OUT, g_buf, sizeof(g_buf), 1000);
-	if (ret < 0) return ret;
-
-	if (out == DIR_OUT) {
-		if (data) {
-			ret = usb_bulk_write(dev, ENDPT_OUT, (char* )data,
-					block_len, 3000);
-			if (ret != block_len) {
-				perror("bulk write");
-				return ret;
-			}
-		}
-	} else if (data) {
-		ret = usb_bulk_read(dev, ENDPT_IN, (char *) data, block_len, 4000);
-		if (ret != block_len) {
-			perror("bulk data read");
-		}
-	}
-	// get ACK:
-	len = sizeof(ansbuf);
-	int retry = 0;
-	do {
-		ret = usb_bulk_read(dev, ENDPT_IN, (char *) ansbuf, len, 5000);
-		if (ret != len) {
-			perror("bulk ACK read");
-			ret = DEVERR_TIMEOUT;
-		}
-		retry++;
-	} while (ret == DEVERR_TIMEOUT && retry < 5);
-	if (strncmp((char *) ansbuf, "USBS", 4)) {
-		return handle_error("Got invalid reply\n");
-	}
-	// pass back return code set by peer:
-	return ansbuf[12];
+  int len;
+  int ret;
+  static unsigned char ansbuf[13]; // Do not change size.
+
+  g_buf[14] = cmdlen;
+  memcpy (&g_buf[15], cmd, cmdlen);
+
+  g_buf[8] = block_len;
+  g_buf[9] = block_len >> 8;
+  g_buf[10] = block_len >> 16;
+  g_buf[11] = block_len >> 24;
+
+  ret = usb_bulk_write (dev, ENDPT_OUT, g_buf, sizeof (g_buf), 1000);
+  if (ret < 0)
+    return ret;
+
+  if (out == DIR_OUT)
+    {
+      if (data)
+        {
+          ret = usb_bulk_write (dev, ENDPT_OUT, (char *) data,
+                                block_len, 3000);
+          if (ret != block_len)
+            {
+              perror ("bulk write");
+              return ret;
+            }
+        }
+    }
+  else if (data)
+    {
+      ret = usb_bulk_read (dev, ENDPT_IN, (char *) data, block_len, 4000);
+      if (ret != block_len)
+        {
+          perror ("bulk data read");
+        }
+    }
+  // get ACK:
+  len = sizeof (ansbuf);
+  int retry = 0;
+  do
+    {
+      ret = usb_bulk_read (dev, ENDPT_IN, (char *) ansbuf, len, 5000);
+      if (ret != len)
+        {
+          perror ("bulk ACK read");
+          ret = DEVERR_TIMEOUT;
+        }
+      retry++;
+    }
+  while (ret == DEVERR_TIMEOUT && retry < 5);
+  if (strncmp ((char *) ansbuf, "USBS", 4))
+    {
+      return handle_error ("Got invalid reply\n");
+    }
+  // pass back return code set by peer:
+  return ansbuf[12];
 }
 
-int dpf_usb_open(int index, usb_dev_handle **u)
+int
+dpf_usb_open (int index, usb_dev_handle ** u)
 {
-	struct usb_device *d;
-	usb_dev_handle *usb_dev;
-
-	usb_find_busses();
-	usb_find_devices();
-
-	d = find_dev(index);
-	if (!d) {
-		handle_error("No matching USB device found!");
-		return -1;
-	}
-
-	usb_dev = usb_open(d);
-	if (usb_dev == NULL) {
-		handle_error("Failed to open usb device!");
-		return -1;
-	}
-	if (usb_claim_interface(usb_dev, 0) < 0) {
-		handle_error("Failed to claim usb device!");
-		printf("Possibly you have to 'sudo libhid-detach-device 1908:3318'\n");
-		return -1;
-	}
-	*u = usb_dev;
-
-	if (d->descriptor.idProduct == 0x3318)
-		return MODE_USBHID;
-	else
-		return MODE_USB;
+  struct usb_device *d;
+  usb_dev_handle *usb_dev;
+
+  usb_find_busses ();
+  usb_find_devices ();
+
+  d = find_dev (index);
+  if (!d)
+    {
+      handle_error ("No matching USB device found!");
+      return -1;
+    }
+
+  usb_dev = usb_open (d);
+  if (usb_dev == NULL)
+    {
+      handle_error ("Failed to open usb device!");
+      return -1;
+    }
+  if (usb_claim_interface (usb_dev, 0) < 0)
+    {
+      handle_error ("Failed to claim usb device!");
+      printf ("Possibly you have to 'sudo libhid-detach-device 1908:3318'\n");
+      return -1;
+    }
+  *u = usb_dev;
+
+  if (d->descriptor.idProduct == 0x3318)
+    return MODE_USBHID;
+  else
+    return MODE_USB;
 }
 
-int usb_rawwrite(usb_dev_handle *dev, const unsigned char *buf, int len)
+int
+usb_rawwrite (usb_dev_handle * dev, const unsigned char *buf, int len)
 {
-	return usb_interrupt_write(dev, ENDPT_OUT, (char *) buf, len, 1000);
+  return usb_interrupt_write (dev, ENDPT_OUT, (char *) buf, len, 1000);
 }
 
-int usb_rawread(usb_dev_handle *dev, unsigned char *buf, int len)
+int
+usb_rawread (usb_dev_handle * dev, unsigned char *buf, int len)
 {
-	return usb_interrupt_read(dev, ENDPT_IN, (char *) buf, len, 4000);
+  return usb_interrupt_read (dev, ENDPT_IN, (char *) buf, len, 4000);
 }
diff --git a/libdpf/scsi.c b/libdpf/scsi.c
index 3f82fc7..e761299 100644
--- a/libdpf/scsi.c
+++ b/libdpf/scsi.c
@@ -4,7 +4,7 @@
  */
 
 #include "sglib.h"
-#include "usbuser.h" // our user defined flash commands
+#include "usbuser.h"            // our user defined flash commands
 #include "dpf.h"
 
 #include <scsi/scsi.h>
@@ -16,64 +16,72 @@
 #include <fcntl.h>
 
 
-int do_scsi(int fd, unsigned char *cmd, int cmdlen, char out,
-	unsigned char *data, unsigned long block_len)
+int
+do_scsi (int fd, unsigned char *cmd, int cmdlen, char out,
+         unsigned char *data, unsigned long block_len)
 {
-	int error;
-	unsigned char sensebuf[32];
-	sg_io_hdr_t io_hdr;
-    memset(&io_hdr, 0, sizeof(sg_io_hdr_t));
-
-    io_hdr.interface_id = 'S';
-    io_hdr.sbp = sensebuf;
-    io_hdr.mx_sb_len = sizeof(sensebuf);
-	if (data == 0) {
-		io_hdr.dxfer_direction = SG_DXFER_NONE;
-	} else {
-		if (out) {
-			io_hdr.dxfer_direction = SG_DXFER_TO_DEV;
-		} else {
-			io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
-		}
-	}
-    io_hdr.dxferp = data;
-    io_hdr.dxfer_len = block_len;
-    io_hdr.cmdp = cmd;
-    io_hdr.cmd_len = cmdlen;
-    io_hdr.timeout = 5000; // in ms
-	error = ioctl(fd, SG_IO, &io_hdr);
-	if (error < 0) perror("calling SCSI ioctl()");
-	return error;
+  int error;
+  unsigned char sensebuf[32];
+  sg_io_hdr_t io_hdr;
+  memset (&io_hdr, 0, sizeof (sg_io_hdr_t));
+
+  io_hdr.interface_id = 'S';
+  io_hdr.sbp = sensebuf;
+  io_hdr.mx_sb_len = sizeof (sensebuf);
+  if (data == 0)
+    {
+      io_hdr.dxfer_direction = SG_DXFER_NONE;
+    }
+  else
+    {
+      if (out)
+        {
+          io_hdr.dxfer_direction = SG_DXFER_TO_DEV;
+        }
+      else
+        {
+          io_hdr.dxfer_direction = SG_DXFER_FROM_DEV;
+        }
+    }
+  io_hdr.dxferp = data;
+  io_hdr.dxfer_len = block_len;
+  io_hdr.cmdp = cmd;
+  io_hdr.cmd_len = cmdlen;
+  io_hdr.timeout = 5000;        // in ms
+  error = ioctl (fd, SG_IO, &io_hdr);
+  if (error < 0)
+    perror ("calling SCSI ioctl()");
+  return error;
 }
 
 
-int wrap_scsi(DPFContext *h, unsigned char *cmd, int cmdlen, char out,
-	unsigned char *data, unsigned long block_len)
+int
+wrap_scsi (DPFContext * h, unsigned char *cmd, int cmdlen, char out,
+           unsigned char *data, unsigned long block_len)
 {
-	int error;
-	switch (h->mode) {
-		case MODE_USB:
-			error = emulate_scsi(h->dev.udev,
-				cmd, cmdlen, out, data, block_len);
-			break;
-		case MODE_SG:
-			error = do_scsi(h->dev.fd, cmd, cmdlen, out, data, block_len);
-			break;
-		case MODE_USBHID:
-			fprintf(stderr, "USBHID mode not (yet) supported\n");
-			error = -1;
-	}
-	return error;
+  int error;
+  switch (h->mode)
+    {
+    case MODE_USB:
+      error = emulate_scsi (h->dev.udev, cmd, cmdlen, out, data, block_len);
+      break;
+    case MODE_SG:
+      error = do_scsi (h->dev.fd, cmd, cmdlen, out, data, block_len);
+      break;
+    case MODE_USBHID:
+      fprintf (stderr, "USBHID mode not (yet) supported\n");
+      error = -1;
+    }
+  return error;
 }
 
 
 /** Vendor command for our hacks */
-static
-unsigned char g_excmd[16] = {
-	0xcd, 0, 0, 0,
-	   0, 6, 0, 0,
-	   0, 0, 0, 0,
-	   0, 0, 0, 0
+static unsigned char g_excmd[16] = {
+  0xcd, 0, 0, 0,
+  0, 6, 0, 0,
+  0, 0, 0, 0,
+  0, 0, 0, 0
 };
 
 
@@ -83,330 +91,337 @@ const char idstring[] = "buildwin Photo Frame    1.01";
 
 #define INQ_REPLY_LEN 96
 
-int sgdev_open(const char *portname, int *fd)
+int
+sgdev_open (const char *portname, int *fd)
 {
-	int error;
-
-	static
-	unsigned char inquiry[] = {
-		INQUIRY, 0, 0, 0,
-		INQ_REPLY_LEN, 0
-	};
-
-	static unsigned char inqbuf[INQ_REPLY_LEN + 2];
-
-	*fd = open(portname, O_RDONLY | O_NONBLOCK );
-	error = do_scsi(*fd, inquiry, sizeof(inquiry), DIR_IN, inqbuf,
-		INQ_REPLY_LEN);
-	
-	if (error < 0) {
-		fprintf(stderr, "SCSI inquiry failed\n");
-		close(*fd); error = DEVERR_OPEN;
-	} else 
-	if (memcmp(idstring, &inqbuf[8], sizeof(idstring) - 1) != 0) {
-		close(*fd); error = DEVERR_OPEN;
-		fprintf(stderr, "Not a photo frame. Refuse to open device.\n");
-	}
-	return error;
+  int error;
+
+  static unsigned char inquiry[] = {
+    INQUIRY, 0, 0, 0,
+    INQ_REPLY_LEN, 0
+  };
+
+  static unsigned char inqbuf[INQ_REPLY_LEN + 2];
+
+  *fd = open (portname, O_RDONLY | O_NONBLOCK);
+  error = do_scsi (*fd, inquiry, sizeof (inquiry), DIR_IN, inqbuf,
+                   INQ_REPLY_LEN);
+
+  if (error < 0)
+    {
+      fprintf (stderr, "SCSI inquiry failed\n");
+      close (*fd);
+      error = DEVERR_OPEN;
+    }
+  else if (memcmp (idstring, &inqbuf[8], sizeof (idstring) - 1) != 0)
+    {
+      close (*fd);
+      error = DEVERR_OPEN;
+      fprintf (stderr, "Not a photo frame. Refuse to open device.\n");
+    }
+  return error;
 }
 
-int probe(DPFHANDLE h)
+int
+probe (DPFHANDLE h)
 {
-	int ret;
-
-	// We abuse a command that just responds with a '0' status in the
-	// original firmware.
-	static unsigned char buf[5];
-
-
-	static
-	unsigned char cmd[16] = {
-		0xcd, 0, 0, 0,
-		   0, 3, 0, 0,
-		   0, 0, 0, 0,
-		   0, 0, 0, 0
-	};
-
-	cmd[5] = 3;
-	ret = wrap_scsi(h, cmd, sizeof(cmd), DIR_IN, 0, 0);
-
-	switch (ret) {
-		case 0:
-			// The original protocol.
-			fprintf(stderr,
-				"Warning: This firmware can not lock the flash\n");
-			break;
-		case 1:
-			// The improved hack
-			h->flags |= FLAG_CAN_LOCK;
-			break;
-	}
-
-	cmd[5] = 2; // get LCD parameters
-	ret = wrap_scsi(h, cmd, sizeof(cmd), DIR_IN, buf, 5);
-	h->width = (buf[0]) | (buf[1] << 8);
-	h->height = (buf[2]) | (buf[3] << 8);
-	h->bpp = 2;
-
-	return ret;
+  int ret;
+
+  // We abuse a command that just responds with a '0' status in the
+  // original firmware.
+  static unsigned char buf[5];
+
+
+  static unsigned char cmd[16] = {
+    0xcd, 0, 0, 0,
+    0, 3, 0, 0,
+    0, 0, 0, 0,
+    0, 0, 0, 0
+  };
+
+  cmd[5] = 3;
+  ret = wrap_scsi (h, cmd, sizeof (cmd), DIR_IN, 0, 0);
+
+  switch (ret)
+    {
+    case 0:
+      // The original protocol.
+      fprintf (stderr, "Warning: This firmware can not lock the flash\n");
+      break;
+    case 1:
+      // The improved hack
+      h->flags |= FLAG_CAN_LOCK;
+      break;
+    }
+
+  cmd[5] = 2;                   // get LCD parameters
+  ret = wrap_scsi (h, cmd, sizeof (cmd), DIR_IN, buf, 5);
+  h->width = (buf[0]) | (buf[1] << 8);
+  h->height = (buf[2]) | (buf[3] << 8);
+  h->bpp = 2;
+
+  return ret;
 }
 
 /* Memory stuff */
 
-static
-int mem_read_scsi(DPFContext *h, unsigned char *buf, ADDR offset, int len)
+static int
+mem_read_scsi (DPFContext * h, unsigned char *buf, ADDR offset, int len)
 {
-	unsigned char *cmd = g_excmd;
+  unsigned char *cmd = g_excmd;
 
-	if (h->mode == MODE_USBHID) return DEVERR_UNSUPP;
+  if (h->mode == MODE_USBHID)
+    return DEVERR_UNSUPP;
 
-	cmd[6] = USBCMD_MEMREAD; // memory_read
-	cmd[7] = offset;
-	cmd[8] = offset >> 8;
-	cmd[9] = len;
-	cmd[10] = len >> 8;
+  cmd[6] = USBCMD_MEMREAD;      // memory_read
+  cmd[7] = offset;
+  cmd[8] = offset >> 8;
+  cmd[9] = len;
+  cmd[10] = len >> 8;
 
-	return wrap_scsi(h, cmd, sizeof(g_excmd), DIR_IN, buf, len);
+  return wrap_scsi (h, cmd, sizeof (g_excmd), DIR_IN, buf, len);
 }
 
-int mem_write_scsi(DPFContext *h,
-	ADDR dst, const unsigned char *src, unsigned short n)
+int
+mem_write_scsi (DPFContext * h,
+                ADDR dst, const unsigned char *src, unsigned short n)
 {
-	unsigned char *cmd = g_excmd;
+  unsigned char *cmd = g_excmd;
 
-	cmd[6] = 0x01; // memory_write
-	cmd[7] = dst;
-	cmd[8] = dst >> 8;
-	cmd[9] = n;
-	cmd[10] = n >> 8;
+  cmd[6] = 0x01;                // memory_write
+  cmd[7] = dst;
+  cmd[8] = dst >> 8;
+  cmd[9] = n;
+  cmd[10] = n >> 8;
 
-	return wrap_scsi(h, cmd, sizeof(g_excmd), DIR_OUT, (unsigned char *) src, n);
+  return wrap_scsi (h, cmd, sizeof (g_excmd), DIR_OUT, (unsigned char *) src,
+                    n);
 }
 
 
 
 /* Flash stuff, SCSI wrapped */
 
-static
-int flash_cmd_scsi(DPFContext *h, int command, int cmdlen, ADDR addr)
+static int
+flash_cmd_scsi (DPFContext * h, int command, int cmdlen, ADDR addr)
 {
-	static
-	unsigned char cmd[16] = {
-		0xcb, 0, 0, 0, 0, 0,
-		1, 0, 0, 0,
-		0, 0, 0, 0,
-		0, 0
-	};
-
-	cmd[10] = command;
-	cmd[6] = cmdlen;
-
-	// Sector number or addr:
-	cmd[13] = addr;
-	cmd[12] = addr >> 8;
-	cmd[11] = addr >> 16;
-
-	return wrap_scsi(h, cmd, sizeof(cmd), DIR_IN, 0, 0);
+  static unsigned char cmd[16] = {
+    0xcb, 0, 0, 0, 0, 0,
+    1, 0, 0, 0,
+    0, 0, 0, 0,
+    0, 0
+  };
+
+  cmd[10] = command;
+  cmd[6] = cmdlen;
+
+  // Sector number or addr:
+  cmd[13] = addr;
+  cmd[12] = addr >> 8;
+  cmd[11] = addr >> 16;
+
+  return wrap_scsi (h, cmd, sizeof (cmd), DIR_IN, 0, 0);
 }
 
-int flash_status_scsi(DPFHANDLE h, uint8_t *status)
+int
+flash_status_scsi (DPFHANDLE h, uint8_t * status)
 {
-	*status = 0;
-	// FIXME : Really get status
-	return 0;
+  *status = 0;
+  // FIXME : Really get status
+  return 0;
 }
 
-static
-int flash_read_scsi(DPFContext *h, unsigned char *buf, ADDR offset, int len)
+static int
+flash_read_scsi (DPFContext * h, unsigned char *buf, ADDR offset, int len)
 {
-	static
-	unsigned char cmd[16] = {
-		0xcd, 0, 0, 0, 0, 0,
-		0x04, /* num of bytes: */ 0, 0, 0,
-		SPM_READ, /* SPI offset: */ 0, 0, 0,
-		0, 0
-	};
-
-	cmd[9] = len >> 0;
-	cmd[8] = len >> 8;
-	cmd[7] = len >> 16;
-
-	cmd[13] = offset >> 0;
-	cmd[12] = offset >> 8;
-	cmd[11] = offset >> 16;
-
-	return wrap_scsi(h, cmd, sizeof(cmd), DIR_IN, buf, len);
+  static unsigned char cmd[16] = {
+    0xcd, 0, 0, 0, 0, 0,
+    0x04, /* num of bytes: */ 0, 0, 0,
+    SPM_READ, /* SPI offset: */ 0, 0, 0,
+    0, 0
+  };
+
+  cmd[9] = len >> 0;
+  cmd[8] = len >> 8;
+  cmd[7] = len >> 16;
+
+  cmd[13] = offset >> 0;
+  cmd[12] = offset >> 8;
+  cmd[11] = offset >> 16;
+
+  return wrap_scsi (h, cmd, sizeof (cmd), DIR_IN, buf, len);
 }
 
-static
-int flash_writechunk_scsi(DPFContext *h,
-	const unsigned char *buf, ADDR offset, int len)
+static int
+flash_writechunk_scsi (DPFContext * h,
+                       const unsigned char *buf, ADDR offset, int len)
 {
-	int error;
-	static
-	unsigned char cmd[16] = {
-		0xcb, 0, 0, 0, 0, 0,
-		4, /* num of bytes: */ 0, 0, 0,
-		SPM_PP, /* SPI offset: */ 0, 0, 0,
-		0, 0
-	};
-
-	if (len > MAX_CHUNKSIZE) len = MAX_CHUNKSIZE;
-
-	cmd[9] = len >> 0;
-	cmd[8] = len >> 8;
-	cmd[7] = len >> 16;
-
-	cmd[13] = offset >> 0;
-	cmd[12] = offset >> 8;
-	cmd[11] = offset >> 16;
-
-	error = wrap_scsi(h, cmd, sizeof(cmd), DIR_OUT,
-		(unsigned char*) buf, len);
-	if (error < 0) return error;
-	return len;
+  int error;
+  static unsigned char cmd[16] = {
+    0xcb, 0, 0, 0, 0, 0,
+    4, /* num of bytes: */ 0, 0, 0,
+    SPM_PP, /* SPI offset: */ 0, 0, 0,
+    0, 0
+  };
+
+  if (len > MAX_CHUNKSIZE)
+    len = MAX_CHUNKSIZE;
+
+  cmd[9] = len >> 0;
+  cmd[8] = len >> 8;
+  cmd[7] = len >> 16;
+
+  cmd[13] = offset >> 0;
+  cmd[12] = offset >> 8;
+  cmd[11] = offset >> 16;
+
+  error = wrap_scsi (h, cmd, sizeof (cmd), DIR_OUT,
+                     (unsigned char *) buf, len);
+  if (error < 0)
+    return error;
+  return len;
 }
 
-int flash_lock_usb(DPFContext *h, char enable)
+int
+flash_lock_usb (DPFContext * h, char enable)
 {
-	unsigned char *cmd = g_excmd;
+  unsigned char *cmd = g_excmd;
 
-	if (!(h->flags & FLAG_CAN_LOCK)) return DEVERR_UNSUPP;
+  if (!(h->flags & FLAG_CAN_LOCK))
+    return DEVERR_UNSUPP;
 
-	printf("Lock flash %d\n", enable);
-	cmd[6] = USBCMD_FLASHLOCK; // flash lock
-	cmd[7] = enable;
+  printf ("Lock flash %d\n", enable);
+  cmd[6] = USBCMD_FLASHLOCK;    // flash lock
+  cmd[7] = enable;
 
-	wrap_scsi(h, cmd, sizeof(g_excmd), DIR_IN, 0, 0);
-	return 0;
+  wrap_scsi (h, cmd, sizeof (g_excmd), DIR_IN, 0, 0);
+  return 0;
 }
 
-static
-int flash_probe_scsi(DPFContext *h, unsigned char *id)
+static int
+flash_probe_scsi (DPFContext * h, unsigned char *id)
 {
-	int error;
-	static
-	unsigned char buf[64];
-	static
-	unsigned char cmd[16] = {
-		0xcd, 0, 0, 0, 0, 0,
-		1, sizeof(buf) >> 16, sizeof(buf) >> 8, sizeof(buf) >> 0,
-		// flash command sequence:
-		SPM_RDID, 0, 0, 0,
-		0, 0
-	};
-
-	error = wrap_scsi(h, cmd, sizeof(cmd), DIR_IN, buf, sizeof(buf));
-	id[0] = buf[0]; id[1] = buf[1]; id[2] = buf[2];
-	return error;
+  int error;
+  static unsigned char buf[64];
+  static unsigned char cmd[16] = {
+    0xcd, 0, 0, 0, 0, 0,
+    1, sizeof (buf) >> 16, sizeof (buf) >> 8, sizeof (buf) >> 0,
+    // flash command sequence:
+    SPM_RDID, 0, 0, 0,
+    0, 0
+  };
+
+  error = wrap_scsi (h, cmd, sizeof (cmd), DIR_IN, buf, sizeof (buf));
+  id[0] = buf[0];
+  id[1] = buf[1];
+  id[2] = buf[2];
+  return error;
 }
 
 
-static
-int go_scsi(DPFContext *h, ADDR start)
+static int
+go_scsi (DPFContext * h, ADDR start)
 {
-	unsigned char *cmd = g_excmd;
-	cmd[6] = 0x02;   // execute
-	cmd[7] = start;
-	cmd[8] = start >> 8;
+  unsigned char *cmd = g_excmd;
+  cmd[6] = 0x02;                // execute
+  cmd[7] = start;
+  cmd[8] = start >> 8;
 
-	return wrap_scsi(h, cmd, sizeof(g_excmd), DIR_IN, 0, 0);
+  return wrap_scsi (h, cmd, sizeof (g_excmd), DIR_IN, 0, 0);
 }
 
-static
-int bootstrap_scsi(DPFContext *h,
-	ADDR dest, unsigned char *src, unsigned short n, ADDR start)
+static int
+bootstrap_scsi (DPFContext * h,
+                ADDR dest, unsigned char *src, unsigned short n, ADDR start)
 {
-	unsigned char *cmd = g_excmd;
+  unsigned char *cmd = g_excmd;
 
-	cmd[6] = USBCMD_APPLOAD;   // Enter bootstrap mode
-	cmd[7] = dest;
-	cmd[8] = dest >> 8;
-	cmd[9] = n;
-	cmd[10] = n >> 8;
-	cmd[11] = start;
-	cmd[12] = start >> 8;
+  cmd[6] = USBCMD_APPLOAD;      // Enter bootstrap mode
+  cmd[7] = dest;
+  cmd[8] = dest >> 8;
+  cmd[9] = n;
+  cmd[10] = n >> 8;
+  cmd[11] = start;
+  cmd[12] = start >> 8;
 
-	return wrap_scsi(h, cmd, sizeof(g_excmd), DIR_OUT, src, n);
+  return wrap_scsi (h, cmd, sizeof (g_excmd), DIR_OUT, src, n);
 }
 
-AccessMethods
-scsi_methods = {
-	.mem_read         = mem_read_scsi,
-	.mem_write        = mem_write_scsi,
-	.go               = go_scsi,
-	.bootstrap        = bootstrap_scsi,
-	.flash_probe      = flash_probe_scsi,
-	.flash_cmd        = flash_cmd_scsi,
-	.flash_status     = flash_status_scsi,
-	.flash_read       = flash_read_scsi,
-	.flash_writechunk = flash_writechunk_scsi,
-	.flash_lock       = flash_lock_usb,
-};
+AccessMethods scsi_methods =
+{
+.mem_read = mem_read_scsi,.mem_write = mem_write_scsi,.go =
+    go_scsi,.bootstrap = bootstrap_scsi,.flash_probe =
+    flash_probe_scsi,.flash_cmd = flash_cmd_scsi,.flash_status =
+    flash_status_scsi,.flash_read = flash_read_scsi,.flash_writechunk =
+    flash_writechunk_scsi,.flash_lock = flash_lock_usb,};
 
 ////////////////////////////////////////////////////////////////////////////
 // SCSI only high level commands:
 
-int dpf_setcol(DPFContext *h, const unsigned char *rgb)
+int
+dpf_setcol (DPFContext * h, const unsigned char *rgb)
 {
-	unsigned char *cmd = g_excmd;
+  unsigned char *cmd = g_excmd;
 
-	if (h->mode == MODE_USBHID) return DEVERR_UNSUPP;
+  if (h->mode == MODE_USBHID)
+    return DEVERR_UNSUPP;
 
-	cmd[6] = USBCMD_SETPROPERTY;
-	cmd[7] = PROPERTY_FGCOLOR;
-	cmd[8] = PROPERTY_FGCOLOR >> 8;
+  cmd[6] = USBCMD_SETPROPERTY;
+  cmd[7] = PROPERTY_FGCOLOR;
+  cmd[8] = PROPERTY_FGCOLOR >> 8;
 
-	cmd[9] = RGB565_0(rgb[0], rgb[1], rgb[2]);
-	cmd[10] = RGB565_1(rgb[0], rgb[1], rgb[2]);
+  cmd[9] = RGB565_0 (rgb[0], rgb[1], rgb[2]);
+  cmd[10] = RGB565_1 (rgb[0], rgb[1], rgb[2]);
 
-	return wrap_scsi(h, cmd, sizeof(g_excmd), DIR_OUT, NULL, 0);
+  return wrap_scsi (h, cmd, sizeof (g_excmd), DIR_OUT, NULL, 0);
 }
 
-int dpf_screen_blit(DPFContext *h,
-	const unsigned char *buf, short rect[4])
+int
+dpf_screen_blit (DPFContext * h, const unsigned char *buf, short rect[4])
 {
-	unsigned long len = (rect[2] - rect[0]) * (rect[3] - rect[1]);
-	len <<= 1;
-	unsigned char *cmd = g_excmd;
-
-	if (h->mode == MODE_USBHID) return DEVERR_UNSUPP;
-
-	cmd[6] = USBCMD_BLIT;
-	cmd[7] = rect[0];
-	cmd[8] = rect[0] >> 8;
-	cmd[9] = rect[1];
-	cmd[10] = rect[1] >> 8;
-	cmd[11] = rect[2] - 1;
-	cmd[12] = (rect[2] - 1) >> 8;
-	cmd[13] = rect[3] - 1;
-	cmd[14] = (rect[3] - 1) >> 8;
-	cmd[15] = 0;
-
-	return wrap_scsi(h, cmd, sizeof(g_excmd), DIR_OUT,
-		(unsigned char*) buf, len);
+  unsigned long len = (rect[2] - rect[0]) * (rect[3] - rect[1]);
+  len <<= 1;
+  unsigned char *cmd = g_excmd;
+
+  if (h->mode == MODE_USBHID)
+    return DEVERR_UNSUPP;
+
+  cmd[6] = USBCMD_BLIT;
+  cmd[7] = rect[0];
+  cmd[8] = rect[0] >> 8;
+  cmd[9] = rect[1];
+  cmd[10] = rect[1] >> 8;
+  cmd[11] = rect[2] - 1;
+  cmd[12] = (rect[2] - 1) >> 8;
+  cmd[13] = rect[3] - 1;
+  cmd[14] = (rect[3] - 1) >> 8;
+  cmd[15] = 0;
+
+  return wrap_scsi (h, cmd, sizeof (g_excmd), DIR_OUT,
+                    (unsigned char *) buf, len);
 }
 
-int dpf_setproperty(DPFContext *h, int token, const DPFValue *value)
+int
+dpf_setproperty (DPFContext * h, int token, const DPFValue * value)
 {
-	unsigned char *cmd = g_excmd;
-
-	if (h->mode == MODE_USBHID) return DEVERR_UNSUPP;
-
-	cmd[6] = USBCMD_SETPROPERTY;
-	cmd[7] = token;
-	cmd[8] = token >> 8;
-
-	switch (value->type) {
-		case TYPE_INTEGER:
-			cmd[9] = value->value.integer;
-			cmd[10] = value->value.integer >> 8;
-			break;
-		default:
-			break;
-	}
-
-	return wrap_scsi(h, cmd, sizeof(g_excmd), DIR_OUT, NULL, 0);
+  unsigned char *cmd = g_excmd;
+
+  if (h->mode == MODE_USBHID)
+    return DEVERR_UNSUPP;
+
+  cmd[6] = USBCMD_SETPROPERTY;
+  cmd[7] = token;
+  cmd[8] = token >> 8;
+
+  switch (value->type)
+    {
+    case TYPE_INTEGER:
+      cmd[9] = value->value.integer;
+      cmd[10] = value->value.integer >> 8;
+      break;
+    default:
+      break;
+    }
+
+  return wrap_scsi (h, cmd, sizeof (g_excmd), DIR_OUT, NULL, 0);
 }
-
-
diff --git a/libdpf/sglib.h b/libdpf/sglib.h
index a2bc232..075fc1e 100644
--- a/libdpf/sglib.h
+++ b/libdpf/sglib.h
@@ -3,7 +3,7 @@
 
 /* generic device wrapper: */
 
-const char* dev_errstr(int error);
+const char *dev_errstr (int error);
 
 
 /* generic SCSI device stuff: */
@@ -13,7 +13,3 @@ const char* dev_errstr(int error);
 
 
 /* Special functions */
-
-
-
-
diff --git a/libdpf/spiflash.h b/libdpf/spiflash.h
index fe7a8fd..5ee90d6 100644
--- a/libdpf/spiflash.h
+++ b/libdpf/spiflash.h
@@ -5,26 +5,24 @@
  */
 
 
-#define SPM_RDID              0x9f    // Read Id
-#define SPM_NO_CMD            0x00    // No command
+#define SPM_RDID              0x9f // Read Id
+#define SPM_NO_CMD            0x00 // No command
 
-#define SPM_WREN              0x06    // Write enable
-#define SPM_WRDI              0x04    // Write disable
-#define SPM_RDSR              0x05    // Read status register
-#define SPM_WRSR              0x01    // Write status register
-#define SPM_READ              0x03    // Read data bytes
-#define SPM_PP                0x02    // Page program
-#define SPM_DP                0xb9    // Deep power down
-#define SPM_RES               0xab    // Release from deep power down
+#define SPM_WREN              0x06 // Write enable
+#define SPM_WRDI              0x04 // Write disable
+#define SPM_RDSR              0x05 // Read status register
+#define SPM_WRSR              0x01 // Write status register
+#define SPM_READ              0x03 // Read data bytes
+#define SPM_PP                0x02 // Page program
+#define SPM_DP                0xb9 // Deep power down
+#define SPM_RES               0xab // Release from deep power down
                                       // and read signature
-#define SPM_FLASH_SE          0xd8    // Sector erase
-#define SPM_FLASH_BE          0xc7    // Bulk erase
-#define SPM_FLASH_FAST_READ   0x0B    // Read data bytes fast
+#define SPM_FLASH_SE          0xd8 // Sector erase
+#define SPM_FLASH_BE          0xc7 // Bulk erase
+#define SPM_FLASH_FAST_READ   0x0B // Read data bytes fast
 
-#define SPM_SR_SRWD           0x80    // SR write protection (HW)
+#define SPM_SR_SRWD           0x80 // SR write protection (HW)
 
 // Status register bit definitions
-#define SPS_WIP 0x01       // write in progress
-#define SPS_WEL 0x02       // write enable latch
-
-
+#define SPS_WIP 0x01            // write in progress
+#define SPS_WEL 0x02            // write enable latch
diff --git a/libdpf/usbuser.h b/libdpf/usbuser.h
index 37fb705..d90b2ad 100644
--- a/libdpf/usbuser.h
+++ b/libdpf/usbuser.h
@@ -8,18 +8,18 @@
 
 /** Our vendor specific USB commands to do stuff on the DPF */
 
-#define USBCMD_GETPROPERTY  0x00    ///< Get property
-#define USBCMD_SETPROPERTY  0x01    ///< Set property
-#define USBCMD_MEMREAD      0x04    ///< Memory read
-#define USBCMD_APPLOAD      0x05    ///< Load and run applet
-#define USBCMD_FILLRECT     0x11    ///< Fill screen rectangle
-#define USBCMD_BLIT         0x12    ///< Blit to screen
-#define USBCMD_COPYRECT     0x13    ///< Copy screen rectangle
-#define USBCMD_FLASHLOCK    0x20    ///< Lock USB for flash access
-#define USBCMD_PROBE        0xff    ///< Get version code (probe)
+#define USBCMD_GETPROPERTY  0x00 ///< Get property
+#define USBCMD_SETPROPERTY  0x01 ///< Set property
+#define USBCMD_MEMREAD      0x04 ///< Memory read
+#define USBCMD_APPLOAD      0x05 ///< Load and run applet
+#define USBCMD_FILLRECT     0x11 ///< Fill screen rectangle
+#define USBCMD_BLIT         0x12 ///< Blit to screen
+#define USBCMD_COPYRECT     0x13 ///< Copy screen rectangle
+#define USBCMD_FLASHLOCK    0x20 ///< Lock USB for flash access
+#define USBCMD_PROBE        0xff ///< Get version code (probe)
 
 /* Some special return codes */
-#define USB_IN_SEQUENCE     0x7f    ///< We're inside a command sequence
+#define USB_IN_SEQUENCE     0x7f ///< We're inside a command sequence
 
 // Property handling: