File GoldenCheetah-libusb1.patch of Package GoldenCheetah

Overview Repositories Revisions Requests Users Attributes Meta

File GoldenCheetah-libusb1.patch of Package GoldenCheetah (Revision ec7fddc6064c82eefc8a8a19679f2b40)

Currently displaying revision ec7fddc6064c82eefc8a8a19679f2b40 , Show latest

commit 7ca1ea5b5d5fb32cfce51ee114646d8ff087b309
Author: Antonius Riha <antoniusriha@gmail.com>
Date:   Tue Aug 28 09:44:53 2018 +0200

Add libusb 1.0 support

diff --git a/src/Gui/GcCrashDialog.cpp b/src/Gui/GcCrashDialog.cpp
index f413d4312..2401abb99 100644
--- a/src/Gui/GcCrashDialog.cpp
+++ b/src/Gui/GcCrashDialog.cpp
@@ -245,8 +245,12 @@ QString GcCrashDialog::versionHTML()
     // -- LIBUSB ----
     QString libusb = "none";
     #ifdef GC_HAVE_LIBUSB
+    #ifdef LIBUSB_V_1
+    libusb = "yes (1.0)";
+    #else
     libusb = "yes";
     #endif
+    #endif
 
     // -- VLC ----
     QString vlc = "none";
diff --git a/src/Train/EzUsb-1.0.c b/src/Train/EzUsb-1.0.c
new file mode 100644
index 000000000..ae8e91f69
--- /dev/null
+++ b/src/Train/EzUsb-1.0.c
@@ -0,0 +1,973 @@
+/*
+ * Copyright © 2001 Stephen Williams (steve@icarus.com)
+ * Copyright © 2001-2002 David Brownell (dbrownell@users.sourceforge.net)
+ * Copyright © 2008 Roger Williams (rawqux@users.sourceforge.net)
+ * Copyright © 2012 Pete Batard (pete@akeo.ie)
+ * Copyright © 2013 Federico Manzan (f.manzan@gmail.com)
+ *
+ *    This source code is free software; you can redistribute it
+ *    and/or modify it in source code form under the terms of the GNU
+ *    General Public License as published by the Free Software
+ *    Foundation; either version 2 of the License, or (at your option)
+ *    any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+#include <stdio.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <string.h>
+#include <stdint.h>
+
+#include "EzUsb-1.0.h"
+
+/*
+ * This file contains functions for uploading firmware into Cypress
+ * EZ-USB microcontrollers. These chips use control endpoint 0 and vendor
+ * specific commands to support writing into the on-chip SRAM. They also
+ * support writing into the CPUCS register, which is how we reset the
+ * processor after loading firmware (including the reset vector).
+ *
+ * These Cypress devices are 8-bit 8051 based microcontrollers with
+ * special support for USB I/O.  They come in several packages, and
+ * some can be set up with external memory when device costs allow.
+ * Note that the design was originally by AnchorChips, so you may find
+ * references to that vendor (which was later merged into Cypress).
+ * The Cypress FX parts are largely compatible with the Anchorhip ones.
+ */
+
+int verbose = 1;
+
+// For explicit runtime linking to libusb functions
+Prototype_EzUsb_control_msg ezusb_usb_control_msg = NULL;
+
+/*
+ * return true if [addr,addr+len] includes external RAM
+ * for Anchorchips EZ-USB or Cypress EZ-USB FX
+ */
+static bool fx_is_external(uint32_t addr, size_t len)
+{
+	/* with 8KB RAM, 0x0000-0x1b3f can be written
+	 * we can't tell if it's a 4KB device here
+	 */
+	if (addr <= 0x1b3f)
+		return ((addr + len) > 0x1b40);
+
+	/* there may be more RAM; unclear if we can write it.
+	 * some bulk buffers may be unused, 0x1b3f-0x1f3f
+	 * firmware can set ISODISAB for 2KB at 0x2000-0x27ff
+	 */
+	return true;
+}
+
+/*
+ * return true if [addr,addr+len] includes external RAM
+ * for Cypress EZ-USB FX2
+ */
+static bool fx2_is_external(uint32_t addr, size_t len)
+{
+	/* 1st 8KB for data/code, 0x0000-0x1fff */
+	if (addr <= 0x1fff)
+		return ((addr + len) > 0x2000);
+
+	/* and 512 for data, 0xe000-0xe1ff */
+	else if (addr >= 0xe000 && addr <= 0xe1ff)
+		return ((addr + len) > 0xe200);
+
+	/* otherwise, it's certainly external */
+	else
+		return true;
+}
+
+/*
+ * return true if [addr,addr+len] includes external RAM
+ * for Cypress EZ-USB FX2LP
+ */
+static bool fx2lp_is_external(uint32_t addr, size_t len)
+{
+	/* 1st 16KB for data/code, 0x0000-0x3fff */
+	if (addr <= 0x3fff)
+		return ((addr + len) > 0x4000);
+
+	/* and 512 for data, 0xe000-0xe1ff */
+	else if (addr >= 0xe000 && addr <= 0xe1ff)
+		return ((addr + len) > 0xe200);
+
+	/* otherwise, it's certainly external */
+	else
+		return true;
+}
+
+
+/*****************************************************************************/
+
+/*
+ * These are the requests (bRequest) that the bootstrap loader is expected
+ * to recognize.  The codes are reserved by Cypress, and these values match
+ * what EZ-USB hardware, or "Vend_Ax" firmware (2nd stage loader) uses.
+ * Cypress' "a3load" is nice because it supports both FX and FX2, although
+ * it doesn't have the EEPROM support (subset of "Vend_Ax").
+ */
+#define RW_INTERNAL     0xA0	/* hardware implements this one */
+#define RW_MEMORY       0xA3
+
+/*
+ * Issues the specified vendor-specific write request.
+ */
+static int ezusb_write(libusb_device_handle *device, const char *label,
+	uint8_t opcode, uint32_t addr, const unsigned char *data, size_t len)
+{
+	int status;
+
+	if (verbose > 1)
+		printf("%s, addr 0x%08x len %4u (0x%04x)\n", label, addr, (unsigned)len, (unsigned)len);
+	status = libusb_control_transfer(device,
+		LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
+		opcode, addr & 0xFFFF, addr >> 16,
+		(unsigned char*)data, (uint16_t)len, 1000);
+    if (status < 0)
+        printf("%s: %s\n", label, libusb_error_name(status));
+    else if ((unsigned)status != len)
+        printf("%s ==> %d\n", label, status);
+	return (status < 0) ? -EIO : 0;
+}
+
+/*
+ * Issues the specified vendor-specific read request.
+ */
+static int ezusb_read(libusb_device_handle *device, const char *label,
+	uint8_t opcode, uint32_t addr, const unsigned char *data, size_t len)
+{
+	int status;
+
+	if (verbose > 1)
+		printf("%s, addr 0x%08x len %4u (0x%04x)\n", label, addr, (unsigned)len, (unsigned)len);
+	status = libusb_control_transfer(device,
+		LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
+		opcode, addr & 0xFFFF, addr >> 16,
+		(unsigned char*)data, (uint16_t)len, 1000);
+    if (status < 0)
+        printf("%s: %s\n", label, libusb_error_name(status));
+    else if ((unsigned)status != len)
+        printf("%s ==> %d\n", label, status);
+	return (status < 0) ? -EIO : 0;
+}
+
+/*
+ * Modifies the CPUCS register to stop or reset the CPU.
+ * Returns false on error.
+ */
+static bool ezusb_cpucs(libusb_device_handle *device, uint32_t addr, bool doRun)
+{
+	int status;
+	uint8_t data = doRun ? 0x00 : 0x01;
+
+	if (verbose)
+		printf("%s\n", data ? "stop CPU" : "reset CPU");
+	status = libusb_control_transfer(device,
+		LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
+		RW_INTERNAL, addr & 0xFFFF, addr >> 16,
+		&data, 1, 1000);
+	if ((status != 1) &&
+		/* We may get an I/O error from libusb as the device disappears */
+		((!doRun) || (status != LIBUSB_ERROR_IO)))
+	{
+		const char *mesg = "can't modify CPUCS";
+		if (status < 0)
+			printf("%s: %s\n", mesg, libusb_error_name(status));
+		else
+			printf("%s\n", mesg);
+		return false;
+	} else
+		return true;
+}
+
+/*
+ * Send an FX3 jumpt to address command
+ * Returns false on error.
+ */
+static bool ezusb_fx3_jump(libusb_device_handle *device, uint32_t addr)
+{
+	int status;
+
+	if (verbose)
+		printf("transfer execution to Program Entry at 0x%08x\n", addr);
+	status = libusb_control_transfer(device,
+		LIBUSB_ENDPOINT_OUT | LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE,
+		RW_INTERNAL, addr & 0xFFFF, addr >> 16,
+		NULL, 0, 1000);
+	/* We may get an I/O error from libusb as the device disappears */
+	if ((status != 0) && (status != LIBUSB_ERROR_IO))
+	{
+		const char *mesg = "failed to send jump command";
+		if (status < 0)
+			printf("%s: %s\n", mesg, libusb_error_name(status));
+		else
+			printf("%s\n", mesg);
+		return false;
+	} else
+		return true;
+}
+
+/*****************************************************************************/
+
+/*
+ * Parse an Intel HEX image file and invoke the poke() function on the
+ * various segments to implement policies such as writing to RAM (with
+ * a one or two stage loader setup, depending on the firmware) or to
+ * EEPROM (two stages required).
+ *
+ * image       - the hex image file
+ * context     - for use by poke()
+ * is_external - if non-null, used to check which segments go into
+ *               external memory (writable only by software loader)
+ * poke        - called with each memory segment; errors indicated
+ *               by returning negative values.
+ *
+ * Caller is responsible for halting CPU as needed, such as when
+ * overwriting a second stage loader.
+ */
+static int parse_ihex(FILE *image, void *context,
+	bool (*is_external)(uint32_t addr, size_t len),
+	int (*poke) (void *context, uint32_t addr, bool external,
+	const unsigned char *data, size_t len))
+{
+	unsigned char data[1023];
+	uint32_t data_addr = 0;
+	size_t data_len = 0;
+	int rc;
+	int first_line = 1;
+	bool external = false;
+
+	/* Read the input file as an IHEX file, and report the memory segments
+	 * as we go.  Each line holds a max of 16 bytes, but uploading is
+	 * faster (and EEPROM space smaller) if we merge those lines into larger
+	 * chunks.  Most hex files keep memory segments together, which makes
+	 * such merging all but free.  (But it may still be worth sorting the
+	 * hex files to make up for undesirable behavior from tools.)
+	 *
+	 * Note that EEPROM segments max out at 1023 bytes; the upload protocol
+	 * allows segments of up to 64 KBytes (more than a loader could handle).
+	 */
+	for (;;) {
+		char buf[512], *cp;
+		char tmp, type;
+		size_t len;
+		unsigned idx, off;
+
+		cp = fgets(buf, sizeof(buf), image);
+		if (cp == NULL) {
+			printf("EOF without EOF record!\n");
+			break;
+		}
+
+		/* EXTENSION: "# comment-till-end-of-line", for copyrights etc */
+		if (buf[0] == '#')
+			continue;
+
+		if (buf[0] != ':') {
+			printf("not an ihex record: %s", buf);
+			return -2;
+		}
+
+		/* ignore any newline */
+		cp = strchr(buf, '\n');
+		if (cp)
+			*cp = 0;
+
+		if (verbose >= 3)
+			printf("** LINE: %s\n", buf);
+
+		/* Read the length field (up to 16 bytes) */
+		tmp = buf[3];
+		buf[3] = 0;
+		len = strtoul(buf+1, NULL, 16);
+		buf[3] = tmp;
+
+		/* Read the target offset (address up to 64KB) */
+		tmp = buf[7];
+		buf[7] = 0;
+		off = (int)strtoul(buf+3, NULL, 16);
+		buf[7] = tmp;
+
+		/* Initialize data_addr */
+		if (first_line) {
+			data_addr = off;
+			first_line = 0;
+		}
+
+		/* Read the record type */
+		tmp = buf[9];
+		buf[9] = 0;
+		type = (char)strtoul(buf+7, NULL, 16);
+		buf[9] = tmp;
+
+		/* If this is an EOF record, then make it so. */
+		if (type == 1) {
+			if (verbose >= 2)
+				printf("EOF on hexfile\n");
+			break;
+		}
+
+		if (type != 0) {
+			printf("unsupported record type: %u\n", type);
+			return -3;
+		}
+
+		if ((len * 2) + 11 > strlen(buf)) {
+			printf("record too short?\n");
+			return -4;
+		}
+
+		/* FIXME check for _physically_ contiguous not just virtually
+		 * e.g. on FX2 0x1f00-0x2100 includes both on-chip and external
+		 * memory so it's not really contiguous */
+
+		/* flush the saved data if it's not contiguous,
+		* or when we've buffered as much as we can.
+		*/
+		if (data_len != 0
+			&& (off != (data_addr + data_len)
+			/* || !merge */
+			|| (data_len + len) > sizeof(data))) {
+				if (is_external)
+					external = is_external(data_addr, data_len);
+				rc = poke(context, data_addr, external, data, data_len);
+				if (rc < 0)
+					return -1;
+				data_addr = off;
+				data_len = 0;
+		}
+
+		/* append to saved data, flush later */
+		for (idx = 0, cp = buf+9 ;  idx < len ;  idx += 1, cp += 2) {
+			tmp = cp[2];
+			cp[2] = 0;
+			data[data_len + idx] = (uint8_t)strtoul(cp, NULL, 16);
+			cp[2] = tmp;
+		}
+		data_len += len;
+	}
+
+
+	/* flush any data remaining */
+	if (data_len != 0) {
+		if (is_external)
+			external = is_external(data_addr, data_len);
+		rc = poke(context, data_addr, external, data, data_len);
+		if (rc < 0)
+			return -1;
+	}
+	return 0;
+}
+
+/*
+ * Parse a binary image file and write it as is to the target.
+ * Applies to Cypress BIX images for RAM or Cypress IIC images
+ * for EEPROM.
+ *
+ * image       - the BIX image file
+ * context     - for use by poke()
+ * is_external - if non-null, used to check which segments go into
+ *               external memory (writable only by software loader)
+ * poke        - called with each memory segment; errors indicated
+ *               by returning negative values.
+ *
+ * Caller is responsible for halting CPU as needed, such as when
+ * overwriting a second stage loader.
+ */
+static int parse_bin(FILE *image, void *context,
+	bool (*is_external)(uint32_t addr, size_t len), int (*poke)(void *context,
+	uint32_t addr, bool external, const unsigned char *data, size_t len))
+{
+	unsigned char data[4096];
+	uint32_t data_addr = 0;
+	size_t data_len = 0;
+	int rc;
+	bool external = false;
+
+	for (;;) {
+		data_len = fread(data, 1, 4096, image);
+		if (data_len == 0)
+			break;
+		if (is_external)
+			external = is_external(data_addr, data_len);
+		rc = poke(context, data_addr, external, data, data_len);
+		if (rc < 0)
+			return -1;
+		data_addr += (uint32_t)data_len;
+	}
+	return feof(image)?0:-1;
+}
+
+/*
+ * Parse a Cypress IIC image file and invoke the poke() function on the
+ * various segments for writing to RAM
+ *
+ * image       - the IIC image file
+ * context     - for use by poke()
+ * is_external - if non-null, used to check which segments go into
+ *               external memory (writable only by software loader)
+ * poke        - called with each memory segment; errors indicated
+ *               by returning negative values.
+ *
+ * Caller is responsible for halting CPU as needed, such as when
+ * overwriting a second stage loader.
+ */
+static int parse_iic(FILE *image, void *context,
+	bool (*is_external)(uint32_t addr, size_t len),
+	int (*poke)(void *context, uint32_t addr, bool external, const unsigned char *data, size_t len))
+{
+	unsigned char data[4096];
+	uint32_t data_addr = 0;
+	size_t data_len = 0, read_len;
+	uint8_t block_header[4];
+	int rc;
+	bool external = false;
+	long file_size, initial_pos;
+
+	initial_pos = ftell(image);
+	if (initial_pos < 0)
+		return -1;
+
+	if (fseek(image, 0L, SEEK_END) != 0)
+		return -1;
+	file_size = ftell(image);
+	if (fseek(image, initial_pos, SEEK_SET) != 0)
+		return -1;
+	for (;;) {
+		/* Ignore the trailing reset IIC data (5 bytes) */
+		if (ftell(image) >= (file_size - 5))
+			break;
+		if (fread(&block_header, 1, sizeof(block_header), image) != 4) {
+			printf("unable to read IIC block header\n");
+			return -1;
+		}
+		data_len = (block_header[0] << 8) + block_header[1];
+		data_addr = (block_header[2] << 8) + block_header[3];
+		if (data_len > sizeof(data)) {
+			/* If this is ever reported as an error, switch to using malloc/realloc */
+			printf("IIC data block too small - please report this error to libusb.info\n");
+			return -1;
+		}
+		read_len = fread(data, 1, data_len, image);
+		if (read_len != data_len) {
+			printf("read error\n");
+			return -1;
+		}
+		if (is_external)
+			external = is_external(data_addr, data_len);
+		rc = poke(context, data_addr, external, data, data_len);
+		if (rc < 0)
+			return -1;
+	}
+	return 0;
+}
+
+
+
+/*
+ * Scan an Imagic.sys driver file and invoke the poke() function on the
+ * various segments of firmware to be loaded
+ *
+ * image	- the hex image file
+ * context	- for use by poke()
+ * is_external	- always 0 for imagic (internal memory only
+ * poke		- called with each memory segment; errors indicated
+ *	     	  by returning negative values.
+ *
+ */
+int parse_imagic (
+    FILE	*image,
+    void	*context,
+    int 	(*poke) (void *context, unsigned short addr, int external,
+              const unsigned char *data, size_t len),
+    libusb_device_handle *device
+)
+{
+    unsigned short cpucs_addr = 0x7f92;
+    long block1_offset = 0x3bb0;
+    long block2_offset = 0x2420;
+    long expected_filesize = 26356;
+    int	 rc;
+
+    struct imagic_firmware_array_element {
+        unsigned short length;
+        unsigned short load_addr;
+        unsigned char  flag1;
+        unsigned char  data[16];
+        unsigned char  flag2;
+
+    } imagic_firmware_element;
+
+    // First check that the file is the size we expect
+    rc = fseek(image, 0, SEEK_END);
+    if (rc != 0 || ftell(image) != expected_filesize) {
+        printf("Unexpected format for imagic driver file\n");
+        return -2;
+    }
+
+    /* don't let CPU run while we overwrite its code/data */
+    if (!ezusb_cpucs (device, cpucs_addr, 0))
+        return -1;
+
+    // Seek to first firmware block
+    rc = fseek(image, block1_offset, SEEK_SET);
+    if (rc != 0) {
+        printf("Error locating firmware array 1 in imagic driver file\n");
+        return -2;
+    }
+
+    while (1) {
+        rc = fread(&imagic_firmware_element, 1, sizeof(imagic_firmware_element), image);
+        if (rc != sizeof(imagic_firmware_element)) {
+            printf("Error reading imagic driver file\n");
+            return -2;
+        }
+        if (imagic_firmware_element.length <= 0)
+            break;
+
+        rc = poke (context, imagic_firmware_element.load_addr, 0, imagic_firmware_element.data, imagic_firmware_element.length);
+        if (rc < 0)
+            return -1;
+    }
+
+    /* Enable / disable CPU */
+    if (!ezusb_cpucs (device, cpucs_addr, 1))
+        return -1;
+    if (!ezusb_cpucs (device, cpucs_addr, 0))
+        return -1;
+
+    // Seek to second firmware block
+    rc = fseek(image, block2_offset, SEEK_SET);
+    if (rc != 0) {
+        printf("Error locating firmware array 2 in imagic driver file\n");
+        return -2;
+    }
+    while (1) {
+        rc = fread(&imagic_firmware_element, 1, sizeof(imagic_firmware_element), image);
+        if (rc != sizeof(imagic_firmware_element)) {
+            printf("Error reading imagic driver file\n");
+            return -2;
+        }
+        if (imagic_firmware_element.length <= 0)
+            break;
+
+        rc = poke (context, imagic_firmware_element.load_addr, 0, imagic_firmware_element.data, imagic_firmware_element.length);
+        if (rc < 0)
+            return -1;
+    }
+
+    /* Enable  CPU */
+    if (!ezusb_cpucs (device, cpucs_addr, 1))
+        return -1;
+
+    return 0;
+}
+
+/* the parse call will be selected according to the image type */
+static int (*parse[IMG_TYPE_MAX])(FILE *image, void *context, bool (*is_external)(uint32_t addr, size_t len),
+           int (*poke)(void *context, uint32_t addr, bool external, const unsigned char *data, size_t len))
+           = { parse_ihex, parse_iic, parse_bin };
+
+/*****************************************************************************/
+
+/*
+ * For writing to RAM using a first (hardware) or second (software)
+ * stage loader and 0xA0 or 0xA3 vendor requests
+ */
+typedef enum {
+	_undef = 0,
+	internal_only,		/* hardware first-stage loader */
+	skip_internal,		/* first phase, second-stage loader */
+	skip_external		/* second phase, second-stage loader */
+} ram_mode;
+
+struct ram_poke_context {
+	libusb_device_handle *device;
+	ram_mode mode;
+	size_t total, count;
+};
+
+#define RETRY_LIMIT 5
+
+static int ram_poke(void *context, uint32_t addr, bool external,
+	const unsigned char *data, size_t len)
+{
+	struct ram_poke_context *ctx = (struct ram_poke_context*)context;
+	int rc;
+	unsigned retry = 0;
+
+	switch (ctx->mode) {
+	case internal_only:		/* CPU should be stopped */
+		if (external) {
+			printf("can't write %u bytes external memory at 0x%08x\n",
+				(unsigned)len, addr);
+			return -EINVAL;
+		}
+		break;
+	case skip_internal:		/* CPU must be running */
+		if (!external) {
+			if (verbose >= 2) {
+				printf("SKIP on-chip RAM, %u bytes at 0x%08x\n",
+					(unsigned)len, addr);
+			}
+			return 0;
+		}
+		break;
+	case skip_external:		/* CPU should be stopped */
+		if (external) {
+			if (verbose >= 2) {
+				printf("SKIP external RAM, %u bytes at 0x%08x\n",
+					(unsigned)len, addr);
+			}
+			return 0;
+		}
+		break;
+	case _undef:
+	default:
+		printf("bug\n");
+		return -EDOM;
+	}
+
+	ctx->total += len;
+	ctx->count++;
+
+	/* Retry this till we get a real error. Control messages are not
+	 * NAKed (just dropped) so time out means is a real problem.
+	 */
+	while ((rc = ezusb_write(ctx->device,
+		external ? "write external" : "write on-chip",
+		external ? RW_MEMORY : RW_INTERNAL,
+		addr, data, len)) < 0
+		&& retry < RETRY_LIMIT) {
+		if (rc != LIBUSB_ERROR_TIMEOUT)
+			break;
+		retry += 1;
+	}
+	return rc;
+}
+
+/*
+ * Load a Cypress Image file into target RAM.
+ * See http://www.cypress.com/?docID=41351 (AN76405 PDF) for more info.
+ */
+static int fx3_load_ram(libusb_device_handle *device, const char *path)
+{
+	uint32_t dCheckSum, dExpectedCheckSum, dAddress, i, dLen, dLength;
+	uint32_t* dImageBuf;
+	unsigned char *bBuf, hBuf[4], blBuf[4], rBuf[4096];
+	FILE *image;
+	int ret = 0;
+
+	image = fopen(path, "rb");
+	if (image == NULL) {
+		printf("unable to open '%s' for input\n", path);
+		return -2;
+	} else if (verbose)
+		printf("open firmware image %s for RAM upload\n", path);
+
+	// Read header
+	if (fread(hBuf, sizeof(char), sizeof(hBuf), image) != sizeof(hBuf)) {
+		printf("could not read image header");
+		ret = -3;
+		goto exit;
+	}
+
+	// check "CY" signature byte and format
+	if ((hBuf[0] != 'C') || (hBuf[1] != 'Y')) {
+		printf("image doesn't have a CYpress signature\n");
+		ret = -3;
+		goto exit;
+	}
+
+	// Check bImageType
+	switch(hBuf[3]) {
+	case 0xB0:
+		if (verbose)
+			printf("normal FW binary %s image with checksum\n", (hBuf[2]&0x01)?"data":"executable");
+		break;
+	case 0xB1:
+		printf("security binary image is not currently supported\n");
+		ret = -3;
+		goto exit;
+	case 0xB2:
+		printf("VID:PID image is not currently supported\n");
+		ret = -3;
+		goto exit;
+	default:
+		printf("invalid image type 0x%02X\n", hBuf[3]);
+		ret = -3;
+		goto exit;
+	}
+
+	// Read the bootloader version
+	if (verbose) {
+		if ((ezusb_read(device, "read bootloader version", RW_INTERNAL, 0xFFFF0020, blBuf, 4) < 0)) {
+			printf("Could not read bootloader version\n");
+			ret = -8;
+			goto exit;
+		}
+		printf("FX3 bootloader version: 0x%02X%02X%02X%02X\n", blBuf[3], blBuf[2], blBuf[1], blBuf[0]);
+	}
+
+	dCheckSum = 0;
+	if (verbose)
+		printf("writing image...\n");
+	while (1) {
+		if ((fread(&dLength, sizeof(uint32_t), 1, image) != 1) ||  // read dLength
+			(fread(&dAddress, sizeof(uint32_t), 1, image) != 1)) { // read dAddress
+			printf("could not read image");
+			ret = -3;
+			goto exit;
+		}
+		if (dLength == 0)
+			break; // done
+
+		// coverity[tainted_data]
+		dImageBuf = (uint32_t*)calloc(dLength, sizeof(uint32_t));
+		if (dImageBuf == NULL) {
+			printf("could not allocate buffer for image chunk\n");
+			ret = -4;
+			goto exit;
+		}
+
+		// read sections
+		if (fread(dImageBuf, sizeof(uint32_t), dLength, image) != dLength) {
+			printf("could not read image");
+			free(dImageBuf);
+			ret = -3;
+			goto exit;
+		}
+		for (i = 0; i < dLength; i++)
+			dCheckSum += dImageBuf[i];
+		dLength <<= 2; // convert to Byte length
+		bBuf = (unsigned char*) dImageBuf;
+
+		while (dLength > 0) {
+			dLen = 4096; // 4K max
+			if (dLen > dLength)
+				dLen = dLength;
+			if ((ezusb_write(device, "write firmware", RW_INTERNAL, dAddress, bBuf, dLen) < 0) ||
+				(ezusb_read(device, "read firmware", RW_INTERNAL, dAddress, rBuf, dLen) < 0)) {
+				printf("R/W error\n");
+				free(dImageBuf);
+				ret = -5;
+				goto exit;
+			}
+			// Verify data: rBuf with bBuf
+			for (i = 0; i < dLen; i++) {
+				if (rBuf[i] != bBuf[i]) {
+					printf("verify error");
+					free(dImageBuf);
+					ret = -6;
+					goto exit;
+				}
+			}
+
+			dLength -= dLen;
+			bBuf += dLen;
+			dAddress += dLen;
+		}
+		free(dImageBuf);
+	}
+
+	// read pre-computed checksum data
+	if ((fread(&dExpectedCheckSum, sizeof(uint32_t), 1, image) != 1) ||
+		(dCheckSum != dExpectedCheckSum)) {
+		printf("checksum error\n");
+		ret = -7;
+		goto exit;
+	}
+
+	// transfer execution to Program Entry
+	if (!ezusb_fx3_jump(device, dAddress)) {
+		ret = -6;
+	}
+
+exit:
+	fclose(image);
+	return ret;
+}
+
+/*
+ * Load a firmware file into target RAM. device is the open libusb
+ * device, and the path is the name of the source file. Open the file,
+ * parse the bytes, and write them in one or two phases.
+ *
+ * If stage == 0, this uses the first stage loader, built into EZ-USB
+ * hardware but limited to writing on-chip memory or CPUCS.  Everything
+ * is written during one stage, unless there's an error such as the image
+ * holding data that needs to be written to external memory.
+ *
+ * Otherwise, things are written in two stages.  First the external
+ * memory is written, expecting a second stage loader to have already
+ * been loaded.  Then file is re-parsed and on-chip memory is written.
+ */
+int libezusb_load_ram(libusb_device_handle *device, const char *path, int fx_type, int img_type, int stage, Prototype_EzUsb_control_msg uptr)
+{
+	FILE *image;
+	uint32_t cpucs_addr;
+	bool (*is_external)(uint32_t off, size_t len);
+	struct ram_poke_context ctx;
+	int status;
+	uint8_t iic_header[8] = { 0 };
+	int ret = 0;
+
+    //Load the runtime library reference
+    ezusb_usb_control_msg = uptr;
+
+	if (fx_type == FX_TYPE_FX3)
+		return fx3_load_ram(device, path);
+
+	image = fopen(path, "rb");
+	if (image == NULL) {
+		printf("%s: unable to open for input.\n", path);
+		return -2;
+	} else if (verbose > 1)
+		printf("open firmware image %s for RAM upload\n", path);
+
+	if (img_type == IMG_TYPE_IIC) {
+		if ( (fread(iic_header, 1, sizeof(iic_header), image) != sizeof(iic_header))
+		  || (((fx_type == FX_TYPE_FX2LP) || (fx_type == FX_TYPE_FX2)) && (iic_header[0] != 0xC2))
+		  || ((fx_type == FX_TYPE_AN21) && (iic_header[0] != 0xB2))
+		  || ((fx_type == FX_TYPE_FX1) && (iic_header[0] != 0xB6)) ) {
+			printf("IIC image does not contain executable code - cannot load to RAM.\n");
+			ret = -1;
+			goto exit;
+		}
+	}
+
+	/* EZ-USB original/FX and FX2 devices differ, apart from the 8051 core */
+	switch(fx_type) {
+	case FX_TYPE_FX2LP:
+		cpucs_addr = 0xe600;
+		is_external = fx2lp_is_external;
+		break;
+	case FX_TYPE_FX2:
+		cpucs_addr = 0xe600;
+		is_external = fx2_is_external;
+		break;
+	default:
+		cpucs_addr = 0x7f92;
+		is_external = fx_is_external;
+		break;
+	}
+
+	/* use only first stage loader? */
+	if (stage == 0) {
+		ctx.mode = internal_only;
+
+		/* if required, halt the CPU while we overwrite its code/data */
+		if (cpucs_addr && !ezusb_cpucs(device, cpucs_addr, false))
+		{
+			ret = -1;
+			goto exit;
+		}
+
+		/* 2nd stage, first part? loader was already uploaded */
+	} else {
+		ctx.mode = skip_internal;
+
+		/* let CPU run; overwrite the 2nd stage loader later */
+		if (verbose)
+			printf("2nd stage: write external memory\n");
+	}
+
+	/* scan the image, first (maybe only) time */
+	ctx.device = device;
+	ctx.total = ctx.count = 0;
+	status = parse[img_type](image, &ctx, is_external, ram_poke);
+	if (status < 0) {
+		printf("unable to upload %s\n", path);
+		ret = status;
+		goto exit;
+	}
+
+	/* second part of 2nd stage: rescan */
+	// TODO: what should we do for non HEX images there?
+	if (stage) {
+		ctx.mode = skip_external;
+
+		/* if needed, halt the CPU while we overwrite the 1st stage loader */
+		if (cpucs_addr && !ezusb_cpucs(device, cpucs_addr, false))
+		{
+			ret = -1;
+			goto exit;
+		}
+
+		/* at least write the interrupt vectors (at 0x0000) for reset! */
+		rewind(image);
+		if (verbose)
+			printf("2nd stage: write on-chip memory\n");
+		status = parse_ihex(image, &ctx, is_external, ram_poke);
+		if (status < 0) {
+			printf("unable to completely upload %s\n", path);
+			ret = status;
+			goto exit;
+		}
+	}
+
+	if (verbose && (ctx.count != 0)) {
+		printf("... WROTE: %d bytes, %d segments, avg %d\n",
+			(int)ctx.total, (int)ctx.count, (int)(ctx.total/ctx.count));
+	}
+
+	/* if required, reset the CPU so it runs what we just uploaded */
+	if (cpucs_addr && !ezusb_cpucs(device, cpucs_addr, true))
+		ret = -1;
+
+exit:
+	fclose(image);
+	return ret;
+}
+
+/* Write firmware to a Tacx Imagic controller
+ * The fd is the open "usbfs" device, and the path is the name
+ * of the source imagic.sys file. We open the file and try to find
+ * the array within it that contains the firmware.
+ *
+ * Unlike some later fortius devices, that imagic has only
+ * internal memory
+ */
+int libezusb_load_ram_imagic (libusb_device_handle *device, const char *path, Prototype_EzUsb_control_msg uptr)
+{
+    FILE			*image;
+    struct ram_poke_context	ctx;
+    int				status;
+
+    //Load the runtime library reference
+    ezusb_usb_control_msg = uptr;
+
+    image = fopen (path, "rb");
+    if (image == 0) {
+    printf("%s: unable to open for input.\n", path);
+    return -2;
+    } else if (verbose)
+    printf("open Imagic driver file %s\n", path);
+
+    // Always internal memory for imagic
+    ctx.mode = internal_only;
+
+    /* scan the driver for its firmware array */
+    ctx.device = device;
+    ctx.total = ctx.count = 0;
+    status = parse_imagic (image, &ctx, ram_poke, device);
+    if (status < 0) {
+    printf("unable to download %s\n", path);
+    return status;
+    }
+
+    if (verbose)
+    printf("... WROTE: %d bytes, %d segments, avg %d\n",
+        ctx.total, ctx.count, ctx.total / ctx.count);
+
+    return 0;
+}
diff --git a/src/Train/EzUsb-1.0.h b/src/Train/EzUsb-1.0.h
new file mode 100644
index 000000000..992100037
--- /dev/null
+++ b/src/Train/EzUsb-1.0.h
@@ -0,0 +1,132 @@
+#ifndef __ezusb_H
+#define __ezusb_H
+/*
+ * Copyright © 2001 Stephen Williams (steve@icarus.com)
+ * Copyright © 2002 David Brownell (dbrownell@users.sourceforge.net)
+ * Copyright © 2013 Federico Manzan (f.manzan@gmail.com)
+ *
+ *    This source code is free software; you can redistribute it
+ *    and/or modify it in source code form under the terms of the GNU
+ *    General Public License as published by the Free Software
+ *    Foundation; either version 2 of the License, or (at your option)
+ *    any later version.
+ *
+ *    This program is distributed in the hope that it will be useful,
+ *    but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *    GNU General Public License for more details.
+ *
+ *    You should have received a copy of the GNU General Public License
+ *    along with this program; if not, write to the Free Software
+ *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
+ */
+#if !defined(_MSC_VER)
+#include <stdbool.h>
+#else
+#define __attribute__(x)
+#if !defined(bool)
+#define bool int
+#endif
+#if !defined(true)
+#define true (1 == 1)
+#endif
+#if !defined(false)
+#define false (!true)
+#endif
+#if defined(_PREFAST_)
+#pragma warning(disable:28193)
+#endif
+#endif
+
+#include <libusb-1.0/libusb.h>
+
+#define FX_TYPE_UNDEFINED  -1
+#define FX_TYPE_AN21       0	/* Original AnchorChips parts */
+#define FX_TYPE_FX1        1	/* Updated Cypress versions */
+#define FX_TYPE_FX2        2	/* USB 2.0 versions */
+#define FX_TYPE_FX2LP      3	/* Updated FX2 */
+#define FX_TYPE_FX3        4	/* USB 3.0 versions */
+#define FX_TYPE_MAX        5
+#define FX_TYPE_NAMES      { "an21", "fx", "fx2", "fx2lp", "fx3" }
+
+#define IMG_TYPE_UNDEFINED -1
+#define IMG_TYPE_HEX       0	/* Intel HEX */
+#define IMG_TYPE_IIC       1	/* Cypress 8051 IIC */
+#define IMG_TYPE_BIX       2	/* Cypress 8051 BIX */
+#define IMG_TYPE_IMG       3	/* Cypress IMG format */
+#define IMG_TYPE_MAX       4
+#define IMG_TYPE_NAMES     { "Intel HEX", "Cypress 8051 IIC", "Cypress 8051 BIX", "Cypress IMG format" }
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* 
+ * Automatically identified devices (VID, PID, type, designation).
+ * TODO: Could use some validation. Also where's the FX2?
+ */
+typedef struct {
+	uint16_t vid;
+	uint16_t pid;
+	int type;
+	const char* designation;
+} fx_known_device;
+
+#define FX_KNOWN_DEVICES { \
+	{ 0x0547, 0x2122, FX_TYPE_AN21, "Cypress EZ-USB (2122S)" },\
+	{ 0x0547, 0x2125, FX_TYPE_AN21, "Cypress EZ-USB (2121S/2125S)" },\
+	{ 0x0547, 0x2126, FX_TYPE_AN21, "Cypress EZ-USB (2126S)" },\
+	{ 0x0547, 0x2131, FX_TYPE_AN21, "Cypress EZ-USB (2131Q/2131S/2135S)" },\
+	{ 0x0547, 0x2136, FX_TYPE_AN21, "Cypress EZ-USB (2136S)" },\
+	{ 0x0547, 0x2225, FX_TYPE_AN21, "Cypress EZ-USB (2225)" },\
+	{ 0x0547, 0x2226, FX_TYPE_AN21, "Cypress EZ-USB (2226)" },\
+	{ 0x0547, 0x2235, FX_TYPE_AN21, "Cypress EZ-USB (2235)" },\
+	{ 0x0547, 0x2236, FX_TYPE_AN21, "Cypress EZ-USB (2236)" },\
+	{ 0x04b4, 0x6473, FX_TYPE_FX1, "Cypress EZ-USB FX1" },\
+	{ 0x04b4, 0x8613, FX_TYPE_FX2LP, "Cypress EZ-USB FX2LP (68013A/68014A/68015A/68016A)" }, \
+	{ 0x04b4, 0x00f3, FX_TYPE_FX3, "Cypress FX3" },\
+}
+
+// For explicit runtime linking to libusb functions
+typedef int (*Prototype_EzUsb_control_msg)(libusb_device_handle *, int, int, int, int, char *, int, int);
+
+/*
+ * This function uploads the firmware from the given file into RAM.
+ * Stage == 0 means this is a single stage load (or the first of
+ * two stages).  Otherwise it's the second of two stages; the 
+ * caller having preloaded the second stage loader.
+ *
+ * The target processor is reset at the end of this upload.
+ */
+extern int libezusb_load_ram(libusb_device_handle *device,
+    const char *path, int fx_type, int img_type, int stage, Prototype_EzUsb_control_msg uptr);
+
+/*
+ * This function performs a specialized firmware load for the
+ * earlier 1902 model as used by the Tacx Imagic
+ */
+extern int libezusb_load_ram_imagic (libusb_device_handle *device,
+    const char *path, Prototype_EzUsb_control_msg uptr);
+
+/*
+ * This function uploads the firmware from the given file into EEPROM.
+ * This uses the right CPUCS address to terminate the EEPROM load with
+ * a reset command where FX parts behave differently than FX2 ones.
+ * The configuration byte is as provided here (zero for an21xx parts)
+ * and the EEPROM type is set so that the microcontroller will boot
+ * from it.
+ *
+ * The caller must have preloaded a second stage loader that knows
+ * how to respond to the EEPROM write request.
+ */
+extern int ezusb_load_eeprom(libusb_device_handle *device,
+	const char *path, int fx_type, int img_type, int config);
+
+/* Verbosity level (default 1). Can be increased or decreased with options v/q  */
+extern int verbose;
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/src/Train/Fortius.cpp b/src/Train/Fortius.cpp
index 5c0261f95..d3f72bc73 100644
--- a/src/Train/Fortius.cpp
+++ b/src/Train/Fortius.cpp
@@ -79,6 +79,7 @@ Fortius::Fortius(QObject *parent) : QThread(parent)
 
 Fortius::~Fortius()
 {
+    delete usb2;
 }
 
 /* ----------------------------------------------------------------------
diff --git a/src/Train/Imagic.cpp b/src/Train/Imagic.cpp
index cc9a290b6..f3dd2dd18 100644
--- a/src/Train/Imagic.cpp
+++ b/src/Train/Imagic.cpp
@@ -47,6 +47,7 @@ Imagic::Imagic(QObject *parent) : QThread(parent)
 
 Imagic::~Imagic()
 {
+    delete usb2;
 }
 
 /* ----------------------------------------------------------------------
diff --git a/src/Train/LibUsb.cpp b/src/Train/LibUsb.cpp
index ec9b8137c..3bb3f219c 100644
--- a/src/Train/LibUsb.cpp
+++ b/src/Train/LibUsb.cpp
@@ -28,12 +28,24 @@
 #include "Settings.h"
 #include "Context.h"
 
+#ifdef LIBUSB_V_1
+#define USB_ENDPOINT_DIR_MASK LIBUSB_ENDPOINT_DIR_MASK
+
+int (&usb_clear_halt)(usb_dev_handle*, unsigned char) = libusb_clear_halt;
+int (&usb_set_configuration)(usb_dev_handle*, int) = libusb_set_configuration;
+int (&usb_claim_interface)(usb_dev_handle*, int) = libusb_claim_interface;
+int (&usb_release_interface)(usb_dev_handle*, int) = libusb_release_interface;
+int (&usb_reset)(usb_dev_handle*) = libusb_reset_device;
+void (&usb_close)(usb_dev_handle*) = libusb_close;
+#endif
+
 LibUsb::LibUsb(int type) : type(type)
 {
 
     intf = NULL;
     readBufIndex = 0;
     readBufSize = 0;
+    rc = 0;
 
 #ifdef WIN32
     QLibrary lib("libusb0");
@@ -76,6 +88,13 @@ LibUsb::LibUsb(int type) : type(type)
 
 }
 
+LibUsb::~LibUsb()
+{
+#ifdef LIBUSB_V_1
+    libusb_exit(ctx);
+#endif
+}
+
 int LibUsb::open()
 {
 
@@ -266,7 +285,7 @@ bool LibUsb::findFortius()
 #ifdef WIN32
     if (libNotInstalled) return false;
 #endif
-    struct usb_bus* bus;
+    struct usb_bus* bus, *firstBus;
     struct usb_device* dev;
 
     bool found = false;
@@ -274,7 +293,8 @@ bool LibUsb::findFortius()
     //
     // Search for an UN-INITIALISED Fortius device
     //
-    for (bus = usb_get_busses(); bus; bus = bus->next) {
+    firstBus = usb_get_busses();
+    for (bus = firstBus; bus; bus = bus->next) {
 
 
         for (dev = bus->devices; dev; dev = dev->next) {
@@ -291,6 +311,11 @@ bool LibUsb::findFortius()
             }
         }
     }
+
+#ifdef LIBUSB_V_1
+    delete firstBus;
+#endif
+
     return found;
 }
 
@@ -322,23 +347,24 @@ bool LibUsb::findFortius()
 //      path is the filename of the firmware file
 //      fx2 is non-zero to indicate an fx2 device (we pass 0, since the Fortius is fx)
 //      stage is to control two stage loading, we load in a single stage
-struct usb_dev_handle* LibUsb::OpenFortius()
+usb_dev_handle* LibUsb::OpenFortius()
 {
     Prototype_EzUsb_control_msg usb_control_msg_ptr = 0;
 #ifdef WIN32
     if (libNotInstalled) return NULL;
     usb_control_msg_ptr = usb_control_msg;
 #endif
-    struct usb_bus* bus;
+    struct usb_bus* bus, *firstBus;
     struct usb_device* dev;
-    struct usb_dev_handle* udev;
+    usb_dev_handle* udev;
 
     bool programmed = false;
 
     //
     // Search for an UN-INITIALISED Fortius device
     //
-    for (bus = usb_get_busses(); bus; bus = bus->next) {
+    firstBus = usb_get_busses();
+    for (bus = firstBus; bus; bus = bus->next) {
 
 
         for (dev = bus->devices; dev; dev = dev->next) {
@@ -360,6 +386,10 @@ struct usb_dev_handle* LibUsb::OpenFortius()
         }
     }
 
+#ifdef LIBUSB_V_1
+    delete firstBus;
+#endif
+
     // We need to rescan devices, since once the Fortius has
     // been programmed it will present itself again with a
     // different PID. But it takes its time, so we sleep for
@@ -383,7 +413,8 @@ struct usb_dev_handle* LibUsb::OpenFortius()
     //
     // Now search for an INITIALISED Fortius device
     //
-    for (bus = usb_get_busses(); bus; bus = bus->next) {
+    firstBus = usb_get_busses();
+    for (bus = firstBus; bus; bus = bus->next) {
 
         for (dev = bus->devices; dev; dev = dev->next) {
 
@@ -419,6 +450,9 @@ struct usb_dev_handle* LibUsb::OpenFortius()
                                         if (rc < 0) qDebug()<<"usb_set_altinterface Error: "<< usb_strerror();
                                     }
 
+#ifdef LIBUSB_V_1
+                                    delete firstBus;
+#endif
                                     return udev;
                                 }
                             }
@@ -430,6 +464,11 @@ struct usb_dev_handle* LibUsb::OpenFortius()
             }
         }
     }
+
+#ifdef LIBUSB_V_1
+    delete firstBus;
+#endif
+
     return NULL;
 }
 
@@ -438,7 +477,7 @@ bool LibUsb::findImagic()
 #ifdef WIN32
     if (libNotInstalled) return false;
 #endif
-    struct usb_bus* bus;
+    struct usb_bus* bus, *firstBus;
     struct usb_device* dev;
 
     bool found = false;
@@ -446,7 +485,8 @@ bool LibUsb::findImagic()
     //
     // Search for an Imagic device
     //
-    for (bus = usb_get_busses(); bus; bus = bus->next) {
+    firstBus = usb_get_busses();
+    for (bus = firstBus; bus; bus = bus->next) {
 
         for (dev = bus->devices; dev; dev = dev->next) {
 
@@ -455,6 +495,11 @@ bool LibUsb::findImagic()
             }
         }
     }
+
+#ifdef LIBUSB_V_1
+    delete firstBus;
+#endif
+
     return found;
 }
 
@@ -481,7 +526,7 @@ bool LibUsb::findImagic()
 // The same ezusb.c module is used to load the imagic firmware as is used
 // for Fortius (see above comments), although some new procedures have been
 // added specific to imagic
-struct usb_dev_handle* LibUsb::OpenImagic()
+usb_dev_handle* LibUsb::OpenImagic()
 {
     Prototype_EzUsb_control_msg usb_control_msg_ptr = 0;
 
@@ -493,14 +538,15 @@ struct usb_dev_handle* LibUsb::OpenImagic()
 #define IMAGIC_SLEEP sleep(3)
 #endif
 
-    struct usb_bus* bus;
+    struct usb_bus* bus, *firstBus;
     struct usb_device* dev;
-    struct usb_dev_handle* udev;
+    usb_dev_handle* udev;
 
     //
     // Search for an Imagic device
     //
-    for (bus = usb_get_busses(); bus; bus = bus->next) {
+    firstBus = usb_get_busses();
+    for (bus = firstBus; bus; bus = bus->next) {
         for (dev = bus->devices; dev; dev = dev->next) {
             if (dev->descriptor.idVendor == FORTIUS_VID && dev->descriptor.idProduct == IMAGIC_PID) {
 
@@ -538,6 +584,9 @@ struct usb_dev_handle* LibUsb::OpenImagic()
                                                 rc = usb_set_altinterface(udev, alternate);
                                                 if (rc < 0) qDebug()<<"usb_set_altinterface Error: "<< usb_strerror();
                                             }
+#ifdef LIBUSB_V_1
+                                            delete firstBus;
+#endif
                                         return udev;
                                         }
                                      }
@@ -550,6 +599,11 @@ struct usb_dev_handle* LibUsb::OpenImagic()
             }
         }
     }
+
+#ifdef LIBUSB_V_1
+    delete firstBus;
+#endif
+
     return NULL;
 }
 
@@ -560,10 +614,11 @@ bool LibUsb::findAntStick()
     if (libNotInstalled) return false;
 #endif
 
-    struct usb_bus* bus;
+    struct usb_bus* bus, *firstBus;
     struct usb_device* dev;
     bool found = false;
-    for (bus = usb_get_busses(); bus; bus = bus->next) {
+    firstBus = usb_get_busses();
+    for (bus = firstBus; bus; bus = bus->next) {
 
         for (dev = bus->devices; dev; dev = dev->next) {
 
@@ -573,21 +628,27 @@ bool LibUsb::findAntStick()
             }
         }
     }
+
+#ifdef LIBUSB_V_1
+    delete firstBus;
+#endif
+
     return found;
 }
 
-struct usb_dev_handle* LibUsb::OpenAntStick()
+usb_dev_handle* LibUsb::OpenAntStick()
 {
 #ifdef WIN32
     if (libNotInstalled) return NULL;
 #endif
-    struct usb_bus* bus;
+    struct usb_bus* bus, *firstBus;
     struct usb_device* dev;
-    struct usb_dev_handle* udev;
+    usb_dev_handle* udev;
 
 // for Mac and Linux we do a bus reset on it first...
 #ifndef WIN32
-    for (bus = usb_get_busses(); bus; bus = bus->next) {
+    firstBus = usb_get_busses();
+    for (bus = firstBus; bus; bus = bus->next) {
 
         for (dev = bus->devices; dev; dev = dev->next) {
 
@@ -601,9 +662,14 @@ struct usb_dev_handle* LibUsb::OpenAntStick()
             }
         }
     }
+
+#ifdef LIBUSB_V_1
+    delete firstBus;
+#endif
 #endif
 
-    for (bus = usb_get_busses(); bus; bus = bus->next) {
+    firstBus = usb_get_busses();
+    for (bus = firstBus; bus; bus = bus->next) {
 
         for (dev = bus->devices; dev; dev = dev->next) {
 
@@ -623,7 +689,7 @@ struct usb_dev_handle* LibUsb::OpenAntStick()
                             usb_detach_kernel_driver_np(udev, interface);
 #endif
 
-                            int rc = usb_set_configuration(udev, 1);
+                            rc = usb_set_configuration(udev, 1);
                             if (rc < 0) {
                                 qDebug()<<"usb_set_configuration Error: "<< usb_strerror();
                                 if (OperatingSystem == LINUX) {
@@ -642,6 +708,9 @@ struct usb_dev_handle* LibUsb::OpenAntStick()
                                         if (rc < 0) qDebug()<<"usb_set_altinterface Error: "<< usb_strerror();
                                     }
 
+#ifdef LIBUSB_V_1
+                                    delete firstBus;
+#endif
                                     return udev;
                                 }
                             }
@@ -653,16 +722,21 @@ struct usb_dev_handle* LibUsb::OpenAntStick()
             }
         }
     }
+
+#ifdef LIBUSB_V_1
+    delete firstBus;
+#endif
+
     return NULL;
 }
 
-struct usb_interface_descriptor* LibUsb::usb_find_interface(struct usb_config_descriptor* config_descriptor)
+usb_interface_descriptor* LibUsb::usb_find_interface(usb_config_descriptor* config_descriptor)
 {
 #ifdef WIN32
     if (libNotInstalled) return NULL;
 #endif
 
-    struct usb_interface_descriptor* intf;
+    usb_interface_descriptor* intf;
 
     readEndpoint = -1;
     writeEndpoint = -1;
@@ -696,13 +770,13 @@ struct usb_interface_descriptor* LibUsb::usb_find_interface(struct usb_config_de
     return intf;
 }
 
-struct usb_interface_descriptor* LibUsb::usb_find_imagic_interface(struct usb_config_descriptor* config_descriptor)
+usb_interface_descriptor* LibUsb::usb_find_imagic_interface(usb_config_descriptor* config_descriptor)
 {
 #ifdef WIN32
     if (libNotInstalled) return NULL;
 #endif
 
-    struct usb_interface_descriptor* intf;
+    usb_interface_descriptor* intf;
 
     readEndpoint = -1;
     writeEndpoint = -1;
@@ -736,6 +810,220 @@ struct usb_interface_descriptor* LibUsb::usb_find_imagic_interface(struct usb_co
     return intf;
 }
 
+#ifdef LIBUSB_V_1
+
+usb_device::usb_device()
+    : descriptor()
+{
+}
+
+usb_device::~usb_device()
+{
+    libusb_free_config_descriptor(config);
+    libusb_unref_device(rawDev);
+
+    if (prev)
+    {
+        prev->next = NULL;
+        delete prev;
+    }
+
+    if (next)
+    {
+        next->prev = NULL;
+        delete next;
+    }
+}
+
+usb_bus::~usb_bus()
+{
+    if (devices)
+        delete devices;
+
+    if (prev)
+    {
+        prev->next = NULL;
+        delete prev;
+    }
+
+    if (next)
+    {
+        next->prev = NULL;
+        delete next;
+    }
+}
+
+void LibUsb::usb_init()
+{
+    rc = libusb_init(&ctx);
+    if (rc < 0)
+    {
+        qCritical() << "libusb_init failed with rc=" << rc;
+    }
+}
+
+void LibUsb::usb_set_debug(int logLevel)
+{
+    libusb_set_debug(ctx, logLevel);
+}
+
+usb_bus *LibUsb::usb_get_busses()
+{
+    libusb_device **list;
+    ssize_t listCount = libusb_get_device_list(ctx, &list);
+    if (listCount < 0)
+    {
+        qInfo() << "libusb_get_device_list returned rc=" << listCount;
+        return NULL;
+    }
+
+    usb_bus *firstBus;
+    usb_bus *bus = NULL;
+    usb_bus *lastBus = NULL;
+    int lastBusNumber = -1;
+    usb_device *lastDev = NULL;
+    for (int i = 0; i < listCount; i++)
+    {
+        libusb_device *rawDev = list[i];
+        libusb_device_descriptor deviceDescriptor;
+
+        rc = libusb_get_device_descriptor(rawDev, &deviceDescriptor);
+        if (rc < 0)
+        {
+            qDebug() << "libusb_get_device_descriptor returned rc=" << rc << " for dev no " << i;
+            libusb_unref_device(rawDev);
+            continue;
+        }
+
+        libusb_config_descriptor *configDescriptor;
+        rc = libusb_get_config_descriptor(rawDev, 0, &configDescriptor);
+        if (rc < 0)
+        {
+            qDebug() << "libusb_get_config_descriptor returned rc=" << rc << " for dev no " << i;
+            libusb_unref_device(rawDev);
+            continue;
+        }
+
+        int busNumber = libusb_get_bus_number(rawDev);
+        if (busNumber != lastBusNumber)
+        {
+            bus = new usb_bus;
+            bus->dirname = QString("%1").arg(busNumber, 3, 10, QChar('0')).toLatin1();
+
+            if (lastBus)
+            {
+                lastBus->next = bus;
+                bus->prev = lastBus;
+            }
+            else
+            {
+                firstBus = bus;
+            }
+
+            lastBusNumber = busNumber;
+            lastBus = bus;
+        }
+
+        usb_device *dev = new usb_device;
+        if (!lastDev)
+        {
+            bus->devices = dev;
+        }
+        else
+        {
+            lastDev->next = dev;
+            dev->prev = lastDev;
+        }
+
+        lastDev = dev;
+
+        int deviceAddress = libusb_get_device_address(rawDev);
+        dev->filename = QString("%1").arg(deviceAddress, 3, 10, QChar('0')).toLatin1();
+
+        dev->descriptor.idVendor = deviceDescriptor.idVendor;
+        dev->descriptor.idProduct = deviceDescriptor.idProduct;
+        dev->rawDev = rawDev;
+        dev->config = configDescriptor;
+    }
+
+    libusb_free_device_list(list, 0);
+    return firstBus;
+}
+
+usb_dev_handle *LibUsb::usb_open(usb_device *dev)
+{
+    usb_dev_handle *handle;
+    rc = libusb_open(dev->rawDev, &handle);
+    if (rc < 0)
+    {
+        qCritical() << "libusb_open failed with rc=" << rc;
+        return NULL;
+    }
+
+    return handle;
+}
+
+void LibUsb::usb_detach_kernel_driver_np(usb_dev_handle *udev, int interfaceNumber)
+{
+    rc = libusb_detach_kernel_driver(udev, interfaceNumber);
+
+    // LIBUSB_ERROR_NOT_FOUND means no kernel driver was attached
+    if (rc != LIBUSB_ERROR_NOT_FOUND && rc < 0)
+    {
+        qCritical() << "libusb_detach_kernel_driver failed with rc=" << rc;
+    }
+}
+
+int LibUsb::usb_set_altinterface(usb_dev_handle *udev, int alternate)
+{
+    return libusb_set_interface_alt_setting(udev, interface, alternate);
+}
+
+const char *LibUsb::usb_strerror()
+{
+    return libusb_strerror((libusb_error)rc);
+}
+
+int LibUsb::usb_bulk_read(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout)
+{
+    int actualSize;
+    rc = libusb_bulk_transfer(dev, ep, (unsigned char*) bytes, size, &actualSize, timeout);
+
+    // don't report timeouts
+    if (rc < 0 && rc != LIBUSB_ERROR_TIMEOUT)
+    {
+        qWarning() << "libusb_bulk_transfer failed with rc=" << rc;
+        return rc;
+    }
+
+    return actualSize;
+}
+
+int LibUsb::usb_bulk_write(usb_dev_handle *dev, int ep, const char *bytes, int size, int timeout)
+{
+    int actualSize;
+    rc = libusb_bulk_transfer(dev, ep, (unsigned char*) bytes, size, &actualSize, timeout);
+    return rc < 0 ? rc : actualSize;
+}
+
+int LibUsb::usb_interrupt_write(usb_dev_handle *dev, int ep, const char *bytes, int size, int timeout)
+{
+    int actualSize;
+    rc = libusb_interrupt_transfer(dev, ep, (unsigned char*) bytes, size, &actualSize, timeout);
+    return rc < 0 ? rc : actualSize;
+}
+
+int LibUsb::ezusb_load_ram(usb_dev_handle *device, const char *path, int fx2, int stage, Prototype_EzUsb_control_msg uptr)
+{
+    return ezusb_load_ram(device, path, fx2, stage, uptr);
+}
+
+int LibUsb::ezusb_load_ram_imagic(usb_dev_handle *device, const char *path, Prototype_EzUsb_control_msg uptr)
+{
+    return ezusb_load_ram_imagic(device, path, uptr);
+}
+#endif
+
 #else
 
 // if we don't have libusb use stubs
diff --git a/src/Train/LibUsb.h b/src/Train/LibUsb.h
index ba0867006..94f9d686e 100644
--- a/src/Train/LibUsb.h
+++ b/src/Train/LibUsb.h
@@ -26,12 +26,17 @@
 #include <windows.h>
 #endif
 
+#ifdef LIBUSB_V_1
+#include <libusb-1.0/libusb.h>
+#include "EzUsb-1.0.h"
+#else
 #include <usb.h> // for the constants etc
 
 // EZ-USB firmware loader for Fortius
 extern "C" {
 #include "EzUsb.h"
 }
+#endif
 
 #ifdef WIN32
 #include <QLibrary> // for dynamically loading libusb0.dll
@@ -51,12 +56,49 @@ extern "C" {
 #define TYPE_FORTIUS 1
 #define TYPE_IMAGIC  2
 
+#ifdef LIBUSB_V_1
+typedef libusb_device_handle usb_dev_handle;
+typedef libusb_config_descriptor usb_config_descriptor;
+typedef const libusb_interface_descriptor usb_interface_descriptor;
+
+struct usb_device_descriptor
+{
+    uint16_t idVendor;
+    uint16_t idProduct;
+    uint8_t  bNumConfigurations = 1;
+};
+
+struct usb_device
+{
+    usb_device();
+    ~usb_device();
+
+    usb_device *next = nullptr, *prev = nullptr;
+    usb_device_descriptor descriptor;
+    libusb_device *rawDev = nullptr;
+    usb_config_descriptor *config = nullptr;
+
+    const char *filename;
+};
+
+struct usb_bus
+{
+    ~usb_bus();
+
+    usb_bus *next = nullptr, *prev = nullptr;
+    usb_device *devices = nullptr;
+
+    const char *dirname;
+};
+#endif
+
 class Context;
 
 class LibUsb {
 
 public:
     LibUsb(int type);
+    ~LibUsb();
     int open();
     void close();
     int read(char *buf, int bytes);
@@ -66,18 +108,38 @@ public:
     bool find();
 private:
 
-    struct usb_dev_handle* OpenAntStick();
-    struct usb_dev_handle* OpenFortius();
-    struct usb_dev_handle* OpenImagic();
+    usb_dev_handle* OpenAntStick();
+    usb_dev_handle* OpenFortius();
+    usb_dev_handle* OpenImagic();
     bool findAntStick();
     bool findFortius();
     bool findImagic();
 
 
-    struct usb_interface_descriptor* usb_find_interface(struct usb_config_descriptor* config_descriptor);
-    struct usb_interface_descriptor* usb_find_imagic_interface(struct usb_config_descriptor* config_descriptor);
-    struct usb_dev_handle* device;
-    struct usb_interface_descriptor* intf;
+    usb_interface_descriptor* usb_find_interface(usb_config_descriptor* config_descriptor);
+    usb_interface_descriptor* usb_find_imagic_interface(usb_config_descriptor* config_descriptor);
+    usb_dev_handle* device;
+    usb_interface_descriptor* intf;
+
+#if LIBUSB_V_1
+    void usb_init();
+    void usb_set_debug(int logLevel);
+    void usb_find_busses() { /* no-op */ }
+    void usb_find_devices() { /* no-op */ }
+    usb_bus *usb_get_busses();
+    usb_dev_handle *usb_open(usb_device *dev);
+    void usb_detach_kernel_driver_np(usb_dev_handle *udev, int interfaceNumber);
+    int usb_set_altinterface(usb_dev_handle *udev, int alternate);
+    const char *usb_strerror();
+    int usb_bulk_read(usb_dev_handle *dev, int ep, char *bytes, int size, int timeout);
+    int usb_bulk_write(usb_dev_handle *dev, int ep, const char *bytes, int size, int timeout);
+    int usb_interrupt_write(usb_dev_handle *dev, int ep, const char *bytes, int size, int timeout);
+
+    int ezusb_load_ram(usb_dev_handle *device, const char *path, int fx2, int stage, Prototype_EzUsb_control_msg uptr);
+    int ezusb_load_ram_imagic(usb_dev_handle *device, const char *path, Prototype_EzUsb_control_msg uptr);
+
+    libusb_context *ctx = nullptr;
+#endif
 
     int readEndpoint, writeEndpoint;
     int interface;
@@ -88,6 +150,7 @@ private:
     int readBufSize;
 
     int type;
+    int rc;
 
 #ifdef WIN32
     bool libNotInstalled;
diff --git a/src/gcconfig.pri.in b/src/gcconfig.pri.in
index 2dfd9aee2..df636b895 100644
--- a/src/gcconfig.pri.in
+++ b/src/gcconfig.pri.in
@@ -162,6 +162,7 @@
 #LIBUSB_INSTALL = /usr/local
 #LIBUSB_INCLUDE = 
 #LIBUSB_LIBS    = 
+#LIBUSB_USE_V_1 = true # don't use on Windows
 
 # if you want video playback on training mode then
 # download and install vlc (videolan) from
diff --git a/src/src.pro b/src/src.pro
index 49b08d670..6ca147564 100644
--- a/src/src.pro
+++ b/src/src.pro
@@ -424,8 +424,11 @@ contains(DEFINES, "GC_WANT_R") {
     isEmpty(LIBUSB_INCLUDE) { LIBUSB_INCLUDE = $${LIBUSB_INSTALL}/include }
     isEmpty(LIBUSB_LIBS)    {
         # needs fixing for msvc toolchain
-        unix  { LIBUSB_LIBS = -L$${LIBUSB_INSTALL}/lib -lusb }
-        win32 { LIBUSB_LIBS = -L$${LIBUSB_INSTALL}/lib/gcc -lusb }
+        _LIBUSB_GCC_LIBNAME = usb
+        isEqual(LIBUSB_USE_V_1, true) _LIBUSB_GCC_LIBNAME = usb-1.0
+
+        unix  { LIBUSB_LIBS = -L$${LIBUSB_INSTALL}/lib -l$${_LIBUSB_GCC_LIBNAME} }
+        win32 { LIBUSB_LIBS = -L$${LIBUSB_INSTALL}/lib/gcc -l$${_LIBUSB_GCC_LIBNAME} }
     }
 
     DEFINES     += GC_HAVE_LIBUSB
@@ -433,10 +436,21 @@ contains(DEFINES, "GC_WANT_R") {
     LIBS        += $${LIBUSB_LIBS}
 
     # lots of dependents
-    SOURCES     += Train/LibUsb.cpp Train/EzUsb.c Train/Fortius.cpp Train/FortiusController.cpp \
+    SOURCES     += Train/LibUsb.cpp Train/Fortius.cpp Train/FortiusController.cpp \
                    Train/Imagic.cpp Train/ImagicController.cpp
-    HEADERS     += Train/LibUsb.h Train/EzUsb.h Train/Fortius.cpp Train/FortiusController.h \
+    HEADERS     += Train/LibUsb.h Train/Fortius.cpp Train/FortiusController.h \
                    Train/Imagic.h Train/ImagicController.h
+
+    !isEqual(LIBUSB_USE_V_1, true) {
+        SOURCES += Train/EzUsb.c
+        HEADERS += Train/EzUsb.h
+    }
+
+    isEqual(LIBUSB_USE_V_1, true) {
+        DEFINES += LIBUSB_V_1
+        SOURCES += Train/EzUsb-1.0.c
+        HEADERS += Train/EzUsb-1.0.h
+    }
 }

Places

File GoldenCheetah-libusb1.patch of Package GoldenCheetah (Revision ec7fddc6064c82eefc8a8a19679f2b40)

Places