interesting
/
riscv-openocd
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

src/jtag: add ftdi/libusb driver support for windows 

Change-Id: Ibadb41463bbe16c453ab6de19f49643e18514e28
This commit is contained in:
wangyanwen 2023-10-09 12:11:53 +08:00 committed by Huaqi Fang
parent 2c2e861b34
commit aa75e393d2
6 changed files with 1895 additions and 10 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

33
configure.ac
View File

@ -406,6 +406,21 @@ AC_ARG_ENABLE([remote-bitbang],
AS_HELP_STRING([--enable-remote-bitbang], [Enable building support for the Remote Bitbang driver]),
[build_remote_bitbang=$enableval], [build_remote_bitbang=yes])
AC_MSG_CHECKING([whether to enable ftd2xx driver])
AS_CASE([$host_os],
[cygwin*|mingw*], [
AC_ARG_ENABLE([ftd2xx],
AS_HELP_STRING([--disable-ftd2xx], [Enable building support for native FTDI D2xx JTAG interface support (without libusb) on Windows.]),
[build_ftd2xx=$enableval], [build_ftd2xx=yes])
LDFLAGS="$LDFLAGS -l:ftd2xx.lib"
],
[
AS_IF([test "x$build_ftd2xx" = "xyes"], [
AC_MSG_ERROR([ftd2xx is only available on Windows])
])
])
AS_CASE(["${host_cpu}"],
[i?86|x86*], [],
[
@ -633,6 +648,19 @@ AS_IF([test "x$build_sysfsgpio" = "xyes"], [
AC_DEFINE([BUILD_SYSFSGPIO], [0], [0 if you don't want SysfsGPIO driver.])
])
AS_IF([test "x$build_xlnx_pcie_xvc" = "xyes"], [
build_xlnx_pcie_xvc=yes
AC_DEFINE([BUILD_XLNX_PCIE_XVC], [1], [1 if you want the Xilinx XVC/PCIe driver.])
], [
AC_DEFINE([BUILD_XLNX_PCIE_XVC], [0], [0 if you don't want Xilinx XVC/PCIe driver.])
])
AS_IF([test "x$build_ftd2xx" = "xyes"], [
AC_DEFINE([BUILD_FTD2XX], [1], [1 if you want the FTD2xx driver support.])
], [
AC_DEFINE([BUILD_FTD2XX], [0], [0 if you don't want FTD2xx driver support.])
])
PKG_CHECK_MODULES([LIBUSB1], [libusb-1.0], [
use_libusb1=yes
AC_DEFINE([HAVE_LIBUSB1], [1], [Define if you have libusb-1.x])
@ -796,6 +824,7 @@ AM_CONDITIONAL([USE_LIBJAYLINK], [test "x$use_libjaylink" = "xyes"])
AM_CONDITIONAL([RSHIM], [test "x$build_rshim" = "xyes"])
AM_CONDITIONAL([DMEM], [test "x$build_dmem" = "xyes"])
AM_CONDITIONAL([HAVE_CAPSTONE], [test "x$enable_capstone" != "xno"])
AM_CONDITIONAL([USE_FTD2XX], [test "x$build_ftd2xx" = "xyes"])
AM_CONDITIONAL([INTERNAL_JIMTCL], [test "x$use_internal_jimtcl" = "xyes"])
AM_CONDITIONAL([HAVE_JIMTCL_PKG_CONFIG], [test "x$have_jimtcl_pkg_config" = "xyes"])
@ -898,3 +927,7 @@ m4_foreach([adapter], [USB1_ADAPTERS,
])
])
echo
AS_IF([test "x$build_ftd2xx" = "xyes"], [
echo "FTD2xx driver support enabled."
])

3
src/helper/replacements.h
View File

@ -14,6 +14,9 @@
#ifndef OPENOCD_HELPER_REPLACEMENTS_H
#define OPENOCD_HELPER_REPLACEMENTS_H
#define HAVE_GETTIMEOFDAY 1
#define HAVE_USLEEP 1
#include <stdint.h>
#include <helper/system.h>

87
src/jtag/drivers/ftd2xx/WinTypes.h Normal file
View File

@ -0,0 +1,87 @@
#ifndef __WINDOWS_TYPES__
#define __WINDOWS_TYPES__
#define MAX_NUM_DEVICES 50
#include <sys/time.h>
typedef unsigned long DWORD;
typedef unsigned long ULONG;
typedef unsigned short USHORT;
typedef short SHORT;
typedef unsigned char UCHAR;
typedef unsigned short WORD;
typedef unsigned char BYTE;
typedef unsigned char *LPBYTE;
typedef int BOOL;
typedef char BOOLEAN;
typedef char CHAR;
typedef int *LPBOOL;
typedef unsigned char *PUCHAR;
typedef const char *LPCSTR;
typedef char *PCHAR;
typedef void *PVOID;
typedef void *HANDLE;
typedef long LONG;
typedef int INT;
typedef unsigned int UINT;
typedef char *LPSTR;
typedef char *LPTSTR;
typedef DWORD *LPDWORD;
typedef WORD *LPWORD;
typedef ULONG *PULONG;
typedef PVOID LPVOID;
typedef void VOID;
typedef unsigned long long int ULONGLONG;
typedef struct _OVERLAPPED {
DWORD Internal;
DWORD InternalHigh;
DWORD Offset;
DWORD OffsetHigh;
HANDLE hEvent;
} OVERLAPPED, *LPOVERLAPPED;
typedef struct _SECURITY_ATTRIBUTES {
DWORD nLength;
LPVOID lpSecurityDescriptor;
BOOL bInheritHandle;
} SECURITY_ATTRIBUTES , *LPSECURITY_ATTRIBUTES;
typedef struct timeval SYSTEMTIME;
typedef struct timeval FILETIME;
#ifndef TRUE
#define TRUE 1
#endif
#ifndef FALSE
#define FALSE 0
#endif
//
// Modem Status Flags
//
#define MS_CTS_ON ((DWORD)0x0010)
#define MS_DSR_ON ((DWORD)0x0020)
#define MS_RING_ON ((DWORD)0x0040)
#define MS_RLSD_ON ((DWORD)0x0080)
//
// Error Flags
//
#define CE_RXOVER 0x0001 // Receive Queue overflow
#define CE_OVERRUN 0x0002 // Receive Overrun Error
#define CE_RXPARITY 0x0004 // Receive Parity Error
#define CE_FRAME 0x0008 // Receive Framing error
#define CE_BREAK 0x0010 // Break Detected
#define CE_TXFULL 0x0100 // TX Queue is full
#define CE_PTO 0x0200 // LPTx Timeout
#define CE_IOE 0x0400 // LPTx I/O Error
#define CE_DNS 0x0800 // LPTx Device not selected
#define CE_OOP 0x1000 // LPTx Out-Of-Paper
#define CE_MODE 0x8000 // Requested mode unsupported
#ifndef INVALID_HANDLE_VALUE
#define INVALID_HANDLE_VALUE 0xFFFFFFFF
#endif
#endif

1446
src/jtag/drivers/ftd2xx/ftd2xx.h Normal file
View File

File diff suppressed because it is too large Load Diff

330
src/jtag/drivers/mpsse.c
View File

@ -16,6 +16,29 @@
#include "libusb_helper.h"
#include <libusb.h>
#if defined(_WIN32) && BUILD_FTD2XX == 1
#define BUILD_BACKEND_FTD2XX
#endif
#ifdef BUILD_BACKEND_FTD2XX
#include "ftd2xx/ftd2xx.h"
#define FTD2XX_CHANNEL_MIN 0
#define FTD2XX_CHANNEL_MAX 3
char *ftd2xx_channel_names[] = {
"A",
"B",
"C",
"D",
};
#endif // BUILD_BACKEND_FTD2XX
// FTD2XX and libusb compatibility
#define BACKEND_DIVERGENCE_START switch (ctx->backend) { default:;
#define BACKEND_DIVERGENCE_LIBUSB break; case MPSSE_BACKEND_TYPE_LIBUSB:;
#define BACKEND_DIVERGENCE_FTD2XX break; case MPSSE_BACKEND_TYPE_FTD2XX:;
#define BACKEND_DIVERGENCE_END break; }
/* Compatibility define for older libusb-1.0 */
#ifndef LIBUSB_CALL
#define LIBUSB_CALL
@ -53,22 +76,30 @@
#define SIO_RESET_PURGE_TX 2
struct mpsse_ctx {
enum mpsse_backend_type backend;
#ifdef BUILD_BACKEND_FTD2XX
// ftd2xx backend
FT_HANDLE usb_ft_handle;
#endif
// libusb backend
struct libusb_context *usb_ctx;
struct libusb_device_handle *usb_dev;
unsigned int usb_write_timeout;
unsigned int usb_read_timeout;
uint8_t in_ep;
uint8_t out_ep;
uint16_t max_packet_size;
uint16_t index;
uint8_t interface;
uint8_t interface; // channel
enum ftdi_chip_type type;
uint8_t *write_buffer;
unsigned int write_size;
unsigned int write_count;
unsigned write_size; // size of write_buffer
unsigned write_count; // size of data being written
uint8_t *read_buffer;
unsigned int read_size;
unsigned int read_count;
unsigned read_size; // size of read_buffer
unsigned read_count; // size of data needed to be read
uint8_t *read_chunk;
unsigned int read_chunk_size;
struct bit_copy_queue read_queue;
@ -159,6 +190,8 @@ static bool open_matching_device(struct mpsse_ctx *ctx, const uint16_t vids[], c
struct libusb_config_descriptor *config0;
int err;
bool found = false;
// try libusb first
ssize_t cnt = libusb_get_device_list(ctx->usb_ctx, &list);
if (cnt < 0)
LOG_ERROR("libusb_get_device_list() failed with %s", libusb_error_name(cnt));
@ -177,7 +210,7 @@ static bool open_matching_device(struct mpsse_ctx *ctx, const uint16_t vids[], c
err = libusb_open(device, &ctx->usb_dev);
if (err != LIBUSB_SUCCESS) {
LOG_ERROR("libusb_open() failed with %s",
LOG_INFO("libusb_open() failed with %s",
libusb_error_name(err));
continue;
}
@ -204,10 +237,14 @@ static bool open_matching_device(struct mpsse_ctx *ctx, const uint16_t vids[], c
libusb_free_device_list(list, 1);
if (!found) {
/* The caller reports detailed error desc */
return false;
LOG_INFO("no device found, trying D2xx driver");
goto libusb_abort;
} else {
LOG_INFO("Using libusb driver");
}
ctx -> backend = MPSSE_BACKEND_TYPE_LIBUSB;
err = libusb_get_config_descriptor(libusb_get_device(ctx->usb_dev), 0, &config0);
if (err != LIBUSB_SUCCESS) {
LOG_ERROR("libusb_get_config_descriptor() failed with %s", libusb_error_name(err));
@ -289,7 +326,7 @@ static bool open_matching_device(struct mpsse_ctx *ctx, const uint16_t vids[], c
ctx->type = TYPE_FT4232HA;
break;
default:
LOG_ERROR("unsupported FTDI chip type: 0x%04x", desc.bcdDevice);
LOG_ERROR("unsupported FTDI chip type (libusb): 0x%04x", desc.bcdDevice);
goto error;
}
@ -321,11 +358,151 @@ static bool open_matching_device(struct mpsse_ctx *ctx, const uint16_t vids[], c
libusb_free_config_descriptor(config0);
return true;
libusb_abort:
#ifdef BUILD_BACKEND_FTD2XX
// try FTD2XX
LOG_DEBUG("open_matching_device() FTD2xx init start");
FT_STATUS ft_status;
DWORD ft_cnt;
ft_status = FT_CreateDeviceInfoList(&ft_cnt);
if (ft_status != FT_OK) {
LOG_ERROR("FT_CreateDeviceInfoList() error %lu", ft_status);
goto open_matching_device_fallback_libusb;
}
LOG_INFO("D2xx device count: %lu", ft_cnt);
// FTD2xx (except single-channel chips like FT232H) descriptor is "USB <-> JTAG-DEBUGGER A"
// libusb descriptor is "USB <-> JTAG-DEBUGGER"
// so the suffix is mapped to libusb channels for compatibility
char product_with_suffix[256];
if (product && ctx->interface >= FTD2XX_CHANNEL_MIN && ctx->interface <= FTD2XX_CHANNEL_MAX) {
snprintf(product_with_suffix, sizeof(product_with_suffix), "%s %s", product, ftd2xx_channel_names[ctx->interface]);
} else {
snprintf(product_with_suffix, sizeof(product_with_suffix), "%s", product);
}
FT_DEVICE_LIST_INFO_NODE *devInfo;
devInfo = (FT_DEVICE_LIST_INFO_NODE*)malloc(sizeof(FT_DEVICE_LIST_INFO_NODE) * ft_cnt);
DWORD ft_matched_device_id;
char *ft_matched_device_description = NULL;
if (ft_cnt > 0) {
ft_status = FT_GetDeviceInfoList(devInfo, &ft_cnt);
if (ft_status == FT_OK) {
for (int i = 0; i < ft_cnt; i++) {
DWORD device_vid = devInfo[i].ID >> 16; // higher 16 bits
DWORD device_pid = devInfo[i].ID & 65535; // lower 16 bits
// LOG_DEBUG("FTD2xx Device #%d:", i);
// LOG_DEBUG(" Flags=0x%lx", devInfo[i].Flags);
// LOG_DEBUG(" Type=0x%lx", devInfo[i].Type);
// LOG_DEBUG(" ID=0x%lx (VID=0x%04lx, PID=0x%04lx)", devInfo[i].ID, device_vid, device_pid);
// LOG_DEBUG(" LocId=0x%lx", devInfo[i].LocId);
// LOG_DEBUG(" SerialNumber=%s", devInfo[i].SerialNumber);
// LOG_DEBUG(" Description=%s", devInfo[i].Description);
// LOG_DEBUG(" ftHandle=0x%p", devInfo[i].ftHandle);
if (vids && *vids != device_vid) continue;
if (pids && *pids != device_pid) continue;
// FIXME: check location does not work for now since libusb use a different location identifier from FTD2xx
if (product) {
if (!strcmp(devInfo[i].Description, product)) { // whole string match -- for FT232H with only one channel
ft_matched_device_description = product;
}
else if (!strcmp(devInfo[i].Description, product_with_suffix)) { // for FT2232H, etc. with multiple channels
ft_matched_device_description = product_with_suffix;
} else {
continue;
}
}
if (serial && strcmp(devInfo[i].SerialNumber, serial)) continue;
found = true;
ft_matched_device_id = i;
break;
}
} else {
LOG_ERROR("FT_GetDeviceInfoList() error %lu", ft_status);
}
}
if (!found) {
LOG_WARNING("D2xx driver found nothing, falling back to libusb...");
goto open_matching_device_fallback_libusb;
} else {
LOG_INFO("Connecting to \"%s\" using D2xx mode...", ft_matched_device_description);
}
ctx -> backend = MPSSE_BACKEND_TYPE_FTD2XX;
switch (devInfo[ft_matched_device_id].Type) {
case FT_DEVICE_2232C:
ctx->type = TYPE_FT2232C;
break;
case FT_DEVICE_2232H:
ctx->type = TYPE_FT2232H;
break;
case FT_DEVICE_4232H:
ctx->type = TYPE_FT4232H;
break;
case FT_DEVICE_232H:
ctx->type = TYPE_FT232H;
break;
default:
LOG_ERROR("unsupported FTDI chip type (D2xx): 0x%04x", devInfo[ft_matched_device_id].Type);
goto error;
}
ft_status = FT_Open(ft_matched_device_id, &(ctx->usb_ft_handle));
if (ft_status != FT_OK)
{
LOG_ERROR("FT_Open() Failed with error %lu\n", ft_status);
goto error;
}
// Reset USB device
ft_status |= FT_ResetDevice(ctx->usb_ft_handle);
// Set parameters
ft_status |= FT_SetUSBParameters(ctx->usb_ft_handle, ctx->max_packet_size, ctx->max_packet_size); // Set USB request transfer sizes
ft_status |= FT_SetChars(ctx->usb_ft_handle, false, 0, false, 0); // Disable event and error characters
// ft_status |= FT_SetFlowControl(ctx->usb_ft_handle, FT_FLOW_RTS_CTS, 0x00, 0x00); // Turn on flow control to synchronize IN requests
// ft_status |= FT_SetBaudRate(ctx->usb_ft_handle, 1000000);
// NOTE: this assumes usb timeouts does not change across the lifetime of the process;
// on the libusb side, timeouts are set per request.
ft_status |= FT_SetTimeouts(ctx->usb_ft_handle, ctx->usb_read_timeout, ctx->usb_write_timeout); // Sets the read and write timeouts in milliseconds
if (ft_status != FT_OK)
{
LOG_ERROR("Error in initializing the MPSSE %lu\n", ft_status);
FT_Close(ctx->usb_ft_handle);
goto open_matching_device_fallback_libusb;
}
return true;
open_matching_device_fallback_libusb:
LOG_DEBUG("open_matching_device() FTD2xx init end");
#endif // BUILD_BACKEND_FTD2XX
desc_error:
LOG_ERROR("unrecognized USB device descriptor");
error:
BACKEND_DIVERGENCE_START
#ifdef BUILD_BACKEND_FTD2XX
BACKEND_DIVERGENCE_FTD2XX
FT_SetBitMode(ctx->usb_ft_handle, 0x0, 0x00);
FT_Close(ctx->usb_ft_handle);
#endif // BUILD_BACKEND_FTD2XX
BACKEND_DIVERGENCE_LIBUSB
libusb_free_config_descriptor(config0);
libusb_close(ctx->usb_dev);
BACKEND_DIVERGENCE_END
return false;
}
@ -334,6 +511,9 @@ struct mpsse_ctx *mpsse_open(const uint16_t vids[], const uint16_t pids[], const
{
struct mpsse_ctx *ctx = calloc(1, sizeof(*ctx));
int err;
#ifdef BUILD_BACKEND_FTD2XX
FT_STATUS ft_status;
#endif // BUILD_BACKEND_FTD2XX
if (!ctx)
return NULL;
@ -375,6 +555,9 @@ struct mpsse_ctx *mpsse_open(const uint16_t vids[], const uint16_t pids[], const
goto error;
}
// Set the latency timer (default is 16ms)
BACKEND_DIVERGENCE_START
BACKEND_DIVERGENCE_LIBUSB
err = libusb_control_transfer(ctx->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
SIO_SET_LATENCY_TIMER_REQUEST, 255, ctx->index, NULL, 0,
ctx->usb_write_timeout);
@ -382,7 +565,19 @@ struct mpsse_ctx *mpsse_open(const uint16_t vids[], const uint16_t pids[], const
LOG_ERROR("unable to set latency timer: %s", libusb_error_name(err));
goto error;
}
#ifdef BUILD_BACKEND_FTD2XX
BACKEND_DIVERGENCE_FTD2XX
ft_status = FT_SetLatencyTimer(ctx->usb_ft_handle, 255);
if (ft_status != FT_OK) {
LOG_ERROR("unable to set latency timer: %lu", ft_status);
goto error;
}
#endif // BUILD_BACKEND_FTD2XX
BACKEND_DIVERGENCE_END
// set MPSSE bitmode
BACKEND_DIVERGENCE_START
BACKEND_DIVERGENCE_LIBUSB
err = libusb_control_transfer(ctx->usb_dev,
FTDI_DEVICE_OUT_REQTYPE,
SIO_SET_BITMODE_REQUEST,
@ -395,6 +590,19 @@ struct mpsse_ctx *mpsse_open(const uint16_t vids[], const uint16_t pids[], const
LOG_ERROR("unable to set MPSSE bitmode: %s", libusb_error_name(err));
goto error;
}
#ifdef BUILD_BACKEND_FTD2XX
BACKEND_DIVERGENCE_FTD2XX
ft_status |= FT_SetBitMode(ctx->usb_ft_handle, 0x0, 0x00); // reset controller mode
ft_status |= FT_SetBitMode(ctx->usb_ft_handle, 0x0, BITMODE_MPSSE); // enter MPSSE mode
if (ft_status != FT_OK) {
LOG_ERROR("unable to set MPSSE bitmode: %lu", ft_status);
goto error;
}
// documentation (https://www.ftdichip.com/Support/Documents/AppNotes/AN_135_MPSSE_Basics.pdf) said to hardcode a delay here
Sleep(50);
#endif // BUILD_BACKEND_FTD2XX
BACKEND_DIVERGENCE_END
mpsse_purge(ctx);
@ -406,10 +614,19 @@ error:
void mpsse_close(struct mpsse_ctx *ctx)
{
BACKEND_DIVERGENCE_START
BACKEND_DIVERGENCE_LIBUSB
if (ctx->usb_dev)
libusb_close(ctx->usb_dev);
if (ctx->usb_ctx)
libusb_exit(ctx->usb_ctx);
#ifdef BUILD_BACKEND_FTD2XX
BACKEND_DIVERGENCE_FTD2XX
FT_SetBitMode(ctx->usb_ft_handle, 0x0, 0x00); // reset controller mode
FT_Close(ctx->usb_ft_handle);
#endif // BUILD_BACKEND_FTD2XX
BACKEND_DIVERGENCE_END
bit_copy_discard(&ctx->read_queue);
free(ctx->write_buffer);
@ -431,6 +648,10 @@ static void mpsse_purge(struct mpsse_ctx *ctx)
ctx->read_count = 0;
ctx->retval = ERROR_OK;
bit_copy_discard(&ctx->read_queue);
// purge RX & TX buffer
BACKEND_DIVERGENCE_START
BACKEND_DIVERGENCE_LIBUSB
err = libusb_control_transfer(ctx->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_RESET_REQUEST,
SIO_RESET_PURGE_RX, ctx->index, NULL, 0, ctx->usb_write_timeout);
if (err < 0) {
@ -444,6 +665,15 @@ static void mpsse_purge(struct mpsse_ctx *ctx)
LOG_ERROR("unable to purge ftdi tx buffers: %s", libusb_error_name(err));
return;
}
#ifdef BUILD_BACKEND_FTD2XX
BACKEND_DIVERGENCE_FTD2XX
FT_STATUS ft_status = FT_Purge(ctx->usb_ft_handle, FT_PURGE_TX | FT_PURGE_RX);
if (ft_status != FT_OK) {
LOG_ERROR("unable to purge ftdi tx&rx buffers: %ul", ft_status);
return;
}
#endif // BUILD_BACKEND_FTD2XX
BACKEND_DIVERGENCE_END
}
static unsigned int buffer_write_space(struct mpsse_ctx *ctx)
@ -865,7 +1095,82 @@ int mpsse_flush(struct mpsse_ctx *ctx)
if (ctx->write_count == 0)
return retval;
struct libusb_transfer *read_transfer = NULL;
BACKEND_DIVERGENCE_START
#ifdef BUILD_BACKEND_FTD2XX
BACKEND_DIVERGENCE_FTD2XX
FT_STATUS ft_status;
DWORD read_bytes_done, write_bytes_done;
if (ctx->read_count) {
buffer_write_byte(ctx, 0x87); /* SEND_IMMEDIATE */
}
DWORD rx_queue_len, tx_queue_len, ft_event_status; // temporary, for FT_GetStatus calls
// write
if (ctx->write_count) {
assert(ctx->write_count <= ctx->write_size); // assume write_buffer can be sent in one request
ft_status = FT_Write(ctx->usb_ft_handle, ctx->write_buffer, ctx->write_count, &write_bytes_done);
LOG_DEBUG_IO("FT_Write(): returned %lu, written bytes %lu/%u", ft_status, write_bytes_done, ctx->write_count);
// wait for queue to clear
do {
ft_status = FT_GetStatus(ctx->usb_ft_handle, &rx_queue_len, &tx_queue_len, &ft_event_status);
if (ft_status != FT_OK) {
LOG_ERROR("FT_GetStatus() returned %lu", ft_status);
}
keep_alive();
} while (tx_queue_len);
}
// read
if (ctx->read_count) {
assert(ctx->read_count <= ctx->read_size); // assume read_buffer can be read in one request
// read
// BTW, read_chunk* is not needed since FT_Read removes the 2 status bytes (reference: read_cb()) for us
ft_status = FT_Read(ctx->usb_ft_handle, ctx->read_buffer, ctx->read_count, &read_bytes_done);
LOG_DEBUG_IO("FT_Read(): returned %lu, read bytes %lu/%u", ft_status, read_bytes_done, ctx->read_count);
// wait for queue to clear
do {
ft_status = FT_GetStatus(ctx->usb_ft_handle, &rx_queue_len, &tx_queue_len, &ft_event_status);
if (ft_status != FT_OK) {
LOG_ERROR("FT_GetStatus() returned %lu", ft_status);
}
keep_alive();
} while (rx_queue_len);
}
if (ft_status != FT_OK) {
// LOG_ERROR("FTD2xx failed with %lu", ft_status);
retval = ERROR_FAIL;
} else if (write_bytes_done < ctx->write_count) {
LOG_ERROR("ftdi device did not accept all data: %d, tried %d",
write_bytes_done,
ctx->write_count);
retval = ERROR_FAIL;
} else if (read_bytes_done < ctx->read_count) {
LOG_ERROR("ftdi device did not return all data: %d, expected %d",
read_bytes_done,
ctx->read_count);
retval = ERROR_FAIL;
} else if (ctx->read_count) {
ctx->write_count = 0;
ctx->read_count = 0;
bit_copy_execute(&ctx->read_queue);
retval = ERROR_OK;
} else {
ctx->write_count = 0;
bit_copy_discard(&ctx->read_queue);
retval = ERROR_OK;
}
#endif // BUILD_BACKEND_FTD2XX
BACKEND_DIVERGENCE_LIBUSB
// the original libusb data transfer
struct libusb_transfer *read_transfer = 0;
struct transfer_result read_result = { .ctx = ctx, .done = true };
if (ctx->read_count) {
buffer_write_byte(ctx, 0x87); /* SEND_IMMEDIATE */
@ -953,5 +1258,10 @@ error_check:
if (read_transfer)
libusb_free_transfer(read_transfer);
if (retval != ERROR_OK)
mpsse_purge(ctx);
BACKEND_DIVERGENCE_END
return retval;
}

6
src/jtag/drivers/mpsse.h
View File

@ -33,6 +33,12 @@ enum ftdi_chip_type {
TYPE_FT4232HA,
};
enum mpsse_backend_type {
MPSSE_BACKEND_TYPE_UNKNOWN,
MPSSE_BACKEND_TYPE_LIBUSB,
MPSSE_BACKEND_TYPE_FTD2XX,
};
struct mpsse_ctx;
/* Device handling */