path: root/libdpf/bootload.c

// Bootstream generator for Buildwin firmware loader
//
// (c) 2011, <hackfin@section5.ch>
//
//

#include "dpf.h"
#include "usbuser.h" // our user defined flash commands
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <stdint.h>

// Jump offsets for USB command:
#define JMP_LOAD     0x0dae
#define JMP_SPILIB   0x11bf
#define JMP_USER     0x1000

#define PAGESIZE 256
#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;
} UsbMsg;

#define OPCODE_SPISEL  0x01  // assert SELECT
#define OPCODE_CRYPT0  0x02
#define OPCODE_CRYPT1  0x04
#define OPCODE_SPIDES  0x10  // assert DESELECT

int validate(UsbMsg *msg)
{
	unsigned short c = 0;
	unsigned char *b = (unsigned char *) msg;
	unsigned short l = msg->len;

	if (l < 6 || l > 64) return -1;

	while (l--) {
		c += *b++;
	}

	msg->chk -= c;

	return 0;
}

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

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;
}
/* Flash stuff, HID wrapped */

static unsigned char s_rbuf[64];

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

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

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

static
int chunk_read(DPFContext *h, unsigned char *buf, ADDR offset, int len)
{
	int error;
	UsbMsg umsg;

	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;

	error = spilib_process(h, &umsg, buf);
	if (error < 0) return error;

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

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

int blk_write(DPFContext *h, ADDR dst, const unsigned char *src,
	unsigned short len)
{
	static UsbMsg umsg;

	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;

	validate(&umsg);
	transmit(h, &umsg);
	return len;
}

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


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)
{
	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