X-Git-Url: https://git.zerfleddert.de/cgi-bin/gitweb.cgi/hmcfgusb/blobdiff_plain/9fb0f4d2becd19b6ef278ebe01159a2a3899abea..2cbaa8109fd7bb3668509484b469e6c41f8510f0:/flash-hmcfgusb.c

diff --git a/flash-hmcfgusb.c b/flash-hmcfgusb.c
index 0308442..b1f554c 100644
--- a/flash-hmcfgusb.c
+++ b/flash-hmcfgusb.c
@@ -1,4 +1,4 @@
-/* (not working) flasher for HM-CFG-USB
+/* flasher for HM-CFG-USB
  *
  * Copyright (c) 2013 Michael Gernoth <michael@gernoth.net>
  *
@@ -36,26 +36,24 @@
 #include <libusb-1.0/libusb.h>
 
 #include "hexdump.h"
+#include "version.h"
 #include "hmcfgusb.h"
 
+/* This might be wrong, but it works for current fw */
+#define MAX_BLOCK_LENGTH	512
+
 struct recv_data {
+	int ack;
 };
 
 static int parse_hmcfgusb(uint8_t *buf, int buf_len, void *data)
 {
-	if (buf_len < 1)
+	struct recv_data *rdata = data;
+
+	if (buf_len != 1)
 		return 1;
 
-	switch(buf[0]) {
-		case 'E':
-		case 'H':
-		case 'R':
-		case 'I':
-			break;
-		default:
-			hexdump(buf, buf_len, "Unknown> ");
-			break;
-	}
+	rdata->ack = buf[0];
 
 	return 1;
 }
@@ -75,53 +73,219 @@ static uint8_t ascii_to_nibble(uint8_t a)
 	return c;
 }
 
+static int validate_nibble(uint8_t a)
+{
+	if (((a >= '0') && (a <= '9')) ||
+	    ((a >= 'A') && (a <= 'F')) ||
+	    ((a >= 'a') && (a <= 'f')))
+	    	return 1;
+
+	return 0;
+}
+
 int main(int argc, char **argv)
 {
+	const char twiddlie[] = { '-', '\\', '|', '/' };
 	struct hmcfgusb_dev *dev;
 	struct recv_data rdata;
-	uint8_t out[0x40]; //FIXME!!!
-	uint8_t buf[0x80];
+	struct stat stat_buf;
+	uint8_t buf[4096];
+	uint16_t len;
+	uint8_t **fw = NULL;
+	int fw_blocks = 0;
+	int block;
 	int fd;
+	int pfd;
 	int r;
 	int i;
-	int cnt;
+	int debug = 0;
 
-	hmcfgusb_set_debug(0);
+	printf("HM-CFG-USB flasher version " VERSION "\n\n");
 
-	memset(&rdata, 0, sizeof(rdata));
+	if (argc != 2) {
+		if (argc == 1)
+			fprintf(stderr, "Missing firmware filename!\n\n");
 
-	dev = hmcfgusb_init(parse_hmcfgusb, &rdata);
-	if (!dev) {
-		fprintf(stderr, "Can't initialize HM-CFG-USB\n");
+		fprintf(stderr, "Syntax: %s hmusbif.enc\n\n", argv[0]);
+		exit(EXIT_FAILURE);
+	}
+
+	if (stat(argv[1], &stat_buf) == -1) {
+		fprintf(stderr, "Can't stat %s: %s\n", argv[1], strerror(errno));
 		exit(EXIT_FAILURE);
 	}
-	printf("HM-CFG-USB opened!\n");
 
-	fd = open("hmusbif.enc", O_RDONLY);
+	fd = open(argv[1], O_RDONLY);
 	if (fd < 0) {
-		perror("Can't open hmusbif.enc");
+		fprintf(stderr, "Can't open %s: %s", argv[1], strerror(errno));
 		exit(EXIT_FAILURE);
 	}
 
-	cnt = 0;
+	printf("Reading firmware from %s...\n", argv[1]);
 	do {
 		memset(buf, 0, sizeof(buf));
-		r = read(fd, buf, sizeof(buf));
+		r = read(fd, buf, 4);
 		if (r < 0) {
 			perror("read");
 			exit(EXIT_FAILURE);
 		} else if (r == 0) {
 			break;
+		} else if (r != 4) {
+			printf("can't get length information!\n");
+			exit(EXIT_FAILURE);
+		}
+
+		for (i = 0; i < r; i++) {
+			if (!validate_nibble(buf[i])) {
+				fprintf(stderr, "Firmware file not valid!\n");
+				exit(EXIT_FAILURE);
+			}
+		}
+
+		len = (ascii_to_nibble(buf[0]) & 0xf)<< 4;
+		len |= ascii_to_nibble(buf[1]) & 0xf;
+		len <<= 8;
+		len |= (ascii_to_nibble(buf[2]) & 0xf)<< 4;
+		len |= ascii_to_nibble(buf[3]) & 0xf;
+
+		/* This might be wrong, but it works for current fw */
+		if (len > MAX_BLOCK_LENGTH) {
+			fprintf(stderr, "Invalid block-length %u > %u for block %d!\n", len, MAX_BLOCK_LENGTH, fw_blocks+1);
+			exit(EXIT_FAILURE);
+		}
+
+		fw = realloc(fw, sizeof(uint8_t*) * (fw_blocks + 1));
+		if (fw == NULL) {
+			perror("Can't reallocate fw-blocklist");
+			exit(EXIT_FAILURE);
+		}
+
+		fw[fw_blocks] = malloc(len + 4);
+		if (fw[fw_blocks] == NULL) {
+			perror("Can't allocate memory for fw-block");
+			exit(EXIT_FAILURE);
+		}
+
+		fw[fw_blocks][0] = (fw_blocks >> 8) & 0xff;
+		fw[fw_blocks][1] = fw_blocks & 0xff;
+		fw[fw_blocks][2] = (len >> 8) & 0xff;
+		fw[fw_blocks][3] = len & 0xff;
+
+		r = read(fd, buf, len * 2);
+		if (r < 0) {
+			perror("read");
+			exit(EXIT_FAILURE);
+		} else if (r < len * 2) {
+			fprintf(stderr, "short read, aborting (%d < %d)\n", r, len * 2);
+			exit(EXIT_FAILURE);
 		}
-		memset(out, 0, sizeof(out));
+
 		for (i = 0; i < r; i+=2) {
-			out[i/2] = (ascii_to_nibble(buf[i]) & 0xf)<< 4;
-			out[i/2] |= ascii_to_nibble(buf[i+1]) & 0xf;
+			if ((!validate_nibble(buf[i])) ||
+			    (!validate_nibble(buf[i+1]))) {
+				fprintf(stderr, "Firmware file not valid!\n");
+				exit(EXIT_FAILURE);
+			}
+
+			fw[fw_blocks][(i/2) + 4] = (ascii_to_nibble(buf[i]) & 0xf)<< 4;
+			fw[fw_blocks][(i/2) + 4] |= ascii_to_nibble(buf[i+1]) & 0xf;
 		}
-		cnt += r/2;
-		printf("Flashing %d bytes...\n", cnt);
-		hmcfgusb_send(dev, out, r/2, 1);
-	} while (r > 0);
+
+		fw_blocks++;
+		if (debug)
+			printf("Firmware block %d with length %u read.\n", fw_blocks, len);
+	} while(r > 0);
+
+	if (fw_blocks == 0) {
+		fprintf(stderr, "Firmware file not valid!\n");
+		exit(EXIT_FAILURE);
+	}
+
+	printf("Firmware with %d blocks successfully read.\n", fw_blocks);
+
+	hmcfgusb_set_debug(debug);
+
+	memset(&rdata, 0, sizeof(rdata));
+
+	dev = hmcfgusb_init(parse_hmcfgusb, &rdata);
+	if (!dev) {
+		fprintf(stderr, "Can't initialize HM-CFG-USB\n");
+		exit(EXIT_FAILURE);
+	}
+
+	if (!dev->bootloader) {
+		fprintf(stderr, "\nHM-CFG-USB not in bootloader mode, entering bootloader.\n");
+		hmcfgusb_enter_bootloader(dev);
+		fprintf(stderr, "\nWaiting for device to reappear...\n");
+
+		do {
+			sleep(1);
+		} while ((dev = hmcfgusb_init(parse_hmcfgusb, &rdata)) == NULL);
+
+		if (!dev->bootloader) {
+			fprintf(stderr, "Can't enter bootloader, giving up!\n");
+			exit(EXIT_FAILURE);
+		}
+	}
+
+	printf("\nHM-CFG-USB opened.\n\n");
+
+
+	printf("Flashing %d blocks", fw_blocks);
+	if (debug) {
+		printf("\n");
+	} else {
+		printf(": %c", twiddlie[0]);
+		fflush(stdout);
+	}
+
+	for (block = 0; block < fw_blocks; block++) {
+		len = fw[block][2] << 8;
+		len |= fw[block][3];
+
+		len += 4; /* block nr., length */
+
+		if (debug)
+			hexdump(fw[block], len, "F> ");
+
+		rdata.ack = 0;
+		if (!hmcfgusb_send(dev, fw[block], len, 0)) {
+			perror("\n\nhmcfgusb_send");
+			exit(EXIT_FAILURE);
+		}
+
+		if (debug)
+			printf("Waiting for ack...\n");
+		do {
+			errno = 0;
+			pfd = hmcfgusb_poll(dev, 1);
+			if ((pfd < 0) && errno) {
+				perror("\n\nhmcfgusb_poll");
+				exit(EXIT_FAILURE);
+			}
+			if (rdata.ack) {
+				break;
+			}
+		} while (pfd < 0);
+
+		if (rdata.ack == 2) {
+			printf("\n\nFirmware update successfull!\n");
+			break;
+		}
+
+		if (rdata.ack != 1) {
+			fprintf(stderr, "\n\nError flashing block %d, status: %u\n", block, rdata.ack);
+			exit(EXIT_FAILURE);
+		}
+
+		if (!debug) {
+			printf("\b%c", twiddlie[block % sizeof(twiddlie)]);
+			fflush(stdout);
+		}
+		free(fw[block]);
+	}
+
+	free(fw);
 
 	hmcfgusb_close(dev);