summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorJames <git@panaceas.org>2014-05-05 17:54:12 +0100
committerJames <git@panaceas.org>2014-05-05 17:54:12 +0100
commit0dd7af76f012e9a02182ed37b7cb0be3dcd55fed (patch)
treeedd0bcc8c90a630a0c72eb561fad07df95e55af9
parentd00119c905bccaa796a885e17f945f5644404772 (diff)
downloadkmd_usb-0dd7af76f012e9a02182ed37b7cb0be3dcd55fed.tar.gz
kmd_usb-0dd7af76f012e9a02182ed37b7cb0be3dcd55fed.tar.bz2
kmd_usb-0dd7af76f012e9a02182ed37b7cb0be3dcd55fed.zip
indent
-rw-r--r--dispatch.c2
-rw-r--r--layout.c8
-rw-r--r--libdpf/bootload.c634
-rw-r--r--libdpf/dpf.h189
-rw-r--r--libdpf/dpflib.c640
-rw-r--r--libdpf/flash.h27
-rw-r--r--libdpf/fwload.c201
-rw-r--r--libdpf/rawusb.c317
-rw-r--r--libdpf/scsi.c629
-rw-r--r--libdpf/sglib.h6
-rw-r--r--libdpf/spiflash.h34
-rw-r--r--libdpf/usbuser.h20
-rw-r--r--map.c1
-rw-r--r--output_map.h8
-rw-r--r--prototypes.h85
15 files changed, 1510 insertions, 1291 deletions
diff --git a/dispatch.c b/dispatch.c
index ec8da7b..230d430 100644
--- a/dispatch.c
+++ b/dispatch.c
@@ -32,7 +32,7 @@ dispatch_key (int key, int ud)
if (ud && keys[KEY_RIGHTALT] && (key == KEY_RIGHTMETA))
{
- lcd_off();
+ lcd_off ();
output_reset ();
status_reset ();
}
diff --git a/layout.c b/layout.c
index 32f1cdf..d01f0f9 100644
--- a/layout.c
+++ b/layout.c
@@ -35,7 +35,7 @@ layout_possible (int console, int computer)
if (console_locked[console])
return 0;
-return 1;
+ return 1;
}
#elif defined(LAYOUT_HOME)
int
@@ -77,6 +77,8 @@ layout_map (int console, int computer)
{
int oc;
+ printf ("layout_map %d %d\n", console, computer);
+
if ((console < 1) || (console > N_CONSOLE))
return;
if ((computer < 1) || (computer > N_COMPUTER))
@@ -143,11 +145,15 @@ layout_toggle_lock (int computer)
int
layout_init (void)
{
+#ifdef LAYOUT_HOME
mm = MM_open ();
layout_map (1, 3);
layout_map (2, 4);
layout_map (3, 5);
+#elif defined(LAYOUT_BROMIUM)
+ layout_map (1, 1);
+#endif
layout_status (3);
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:
diff --git a/map.c b/map.c
index d3bd341..305380f 100644
--- a/map.c
+++ b/map.c
@@ -5,6 +5,7 @@
void
map_output (int *computer, int *x, int *y)
{
+ (*computer)--;
}
#elif defined(MAP_HOME)
diff --git a/output_map.h b/output_map.h
index 978a17c..646f28b 100644
--- a/output_map.h
+++ b/output_map.h
@@ -36,13 +36,13 @@ static struct map_ent map[] = {
#ifdef APPLE_KEYBOARD
{
- HACK_NONE, 0x29, KEY_102ND },
+ HACK_NONE, 0x29, KEY_102ND},
{
- HACK_NONE, 0x65, KEY_ESC},
+ HACK_NONE, 0x65, KEY_ESC},
{
- HACK_NONE, 0x48, KEY_F19},
+ HACK_NONE, 0x48, KEY_F19},
{
- HACK_NONE, 0x64, KEY_GRAVE},
+ HACK_NONE, 0x64, KEY_GRAVE},
#endif
#if 0
diff --git a/prototypes.h b/prototypes.h
index 695315d..69ff720 100644
--- a/prototypes.h
+++ b/prototypes.h
@@ -1,52 +1,55 @@
/* kmd.c */
-extern int main(int argc, char *argv[]);
+extern int main (int argc, char *argv[]);
/* status.c */
-extern void status_draw_computer(int computer, int locked, int console, int active, int force);
-extern void status_draw_console(int console, int locked, int computer, int active, int force);
-extern void status_init(void);
-extern void status_reset(void);
+extern void status_draw_computer (int computer, int locked, int console,
+ int active, int force);
+extern void status_draw_console (int console, int locked, int computer,
+ int active, int force);
+extern void status_init (void);
+extern void status_reset (void);
/* lcd.c */
-extern void lcd_on(void);
-extern void lcd_off(void);
-extern void lcd_close(void);
-extern void lcd_vline(int x, int y1, int y2, int r, int g, int b);
-extern void lcd_hline(int y, int x1, int x2, int r, int g, int b);
-extern void lcd_box(int x1, int y1, int x2, int y2, int r, int g, int b);
-extern void lcd_ss(int v, int x1, int y1, int w, int h);
-extern int lcd_open(void);
+extern void lcd_on (void);
+extern void lcd_off (void);
+extern void lcd_close (void);
+extern void lcd_vline (int x, int y1, int y2, int r, int g, int b);
+extern void lcd_hline (int y, int x1, int x2, int r, int g, int b);
+extern void lcd_box (int x1, int y1, int x2, int y2, int r, int g, int b);
+extern void lcd_ss (int v, int x1, int y1, int w, int h);
+extern int lcd_open (void);
/* input.c */
extern input_dev_t *input_devs;
-extern void scan_input_devs(void);
+extern void scan_input_devs (void);
/* dispatch.c */
-extern void dispatch_key(int key, int ud);
-extern void dispatch_mouse_button(int button, int ud);
-extern void dispatch_mouse_wheel(int d);
-extern void dispatch_mouse_motion(int rx, int ry);
-extern void dispatch_event(struct input_event *ev);
-extern void dispatch_init(void);
+extern void dispatch_key (int key, int ud);
+extern void dispatch_mouse_button (int button, int ud);
+extern void dispatch_mouse_wheel (int d);
+extern void dispatch_mouse_motion (int rx, int ry);
+extern void dispatch_event (struct input_event *ev);
+extern void dispatch_init (void);
/* output.c */
extern output_dev_t *output_devs;
-extern struct map_ent *lookup_map_ent(int keycode, uint8_t modifiers);
-extern void send_keyboard_event(int computer, int k, int ud);
-extern void send_mouse_event(int computer, int x, int y, int s, int l, int m, int r);
-extern void scan_output_devs(int init);
-extern void output_reset(void);
+extern struct map_ent *lookup_map_ent (int keycode, uint8_t modifiers);
+extern void send_keyboard_event (int computer, int k, int ud);
+extern void send_mouse_event (int computer, int x, int y, int s, int l, int m,
+ int r);
+extern void scan_output_devs (int init);
+extern void output_reset (void);
/* map.c */
-extern void map_output(int *computer, int *x, int *y);
-extern int map_grace_left(int computer);
-extern int map_grace_right(int computer);
-extern int map_switch_left(int *cc);
-extern int map_switch_right(int *cc);
-extern int map_init(void);
+extern void map_output (int *computer, int *x, int *y);
+extern int map_grace_left (int computer);
+extern int map_grace_right (int computer);
+extern int map_switch_left (int *cc);
+extern int map_switch_right (int *cc);
+extern int map_init (void);
/* layout.c */
-extern int layout_computer_to_console(int computer);
-extern int layout_console_to_computer(int console);
-extern int layout_possible(int console, int computer);
-extern void layout_map(int console, int computer);
-extern void layout_status(int active_computer);
-extern void layout_toggle_lock(int computer);
-extern int layout_init(void);
+extern int layout_computer_to_console (int computer);
+extern int layout_console_to_computer (int console);
+extern int layout_possible (int console, int computer);
+extern void layout_map (int console, int computer);
+extern void layout_status (int active_computer);
+extern void layout_toggle_lock (int computer);
+extern int layout_init (void);
/* video_switch.c */
-extern MM *MM_open(void);
-extern int MM_set(MM *m, int a, int b);
-extern int VS_set(MM *m, int v);
+extern MM *MM_open (void);
+extern int MM_set (MM * m, int a, int b);
+extern int VS_set (MM * m, int v);