zcy
/
tinyriscv-openocd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Remove support for the GPL incompatible FTDI D2XX library 

Convert Presto, OpenJTAG and USB-Blaster (I) adapter drivers to libftdi
only.

Change-Id: Ib28887620a3dcbb754b9dbf87b9731acca3ac600
Signed-off-by: Andreas Fritiofson <andreas.fritiofson@gmail.com>
Reviewed-on: http://openocd.zylin.com/3237
Tested-by: jenkins
Reviewed-by: Ricardo Ribalda Delgado <ricardo.ribalda@gmail.com>
Reviewed-by: Freddie Chopin <freddie.chopin@gmail.com>
gitignore-build
Andreas Fritiofson 2016-02-15 23:17:24 +01:00
parent cc2d4f015f
commit bcaf775fc1
14 changed files with 44 additions and 1031 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

42
README
View File

@ -181,10 +181,6 @@ suggestions:
particular hardware; particular hardware;
- Use "ftdi" interface adapter driver for the FTDI-based devices. - Use "ftdi" interface adapter driver for the FTDI-based devices.
As a PACKAGER, never link against the FTD2XX library, as the resulting
binaries can't be legally distributed, due to the restrictions of the
GPL.
================ ================
Building OpenOCD Building OpenOCD
@ -226,10 +222,8 @@ libusb-0.1 or libusb-compat-0.1. A compatible implementation, such as
FreeBSD's, additionally needs the corresponding .pc files. FreeBSD's, additionally needs the corresponding .pc files.
USB-Blaster, ASIX Presto and OpenJTAG interface adapter USB-Blaster, ASIX Presto and OpenJTAG interface adapter
drivers need either one of: drivers need:
- libftdi: http://www.intra2net.com/en/developer/libftdi/index.php - libftdi: http://www.intra2net.com/en/developer/libftdi/index.php
- ftd2xx: http://www.ftdichip.com/Drivers/D2XX.htm (proprietary,
GPL-incompatible)
CMSIS-DAP support needs HIDAPI library. CMSIS-DAP support needs HIDAPI library.
@ -301,40 +295,6 @@ use both the --enable-parport AND the --enable-parport-giveio option
if you want to use giveio instead of ioperm parallel port access if you want to use giveio instead of ioperm parallel port access
method. method.
Using FTDI's FTD2XX
-------------------
The (closed source) FTDICHIP.COM solution is faster than libftdi on
Windows. That is the motivation for supporting it even though its
licensing restricts it to non-redistributable OpenOCD binaries, and it
is not available for all operating systems used with OpenOCD. You may,
however, build such copies for personal use.
The FTDICHIP drivers come as either a (win32) ZIP file, or a (Linux)
TAR.GZ file. You must unpack them ``some where'' convenient. As of this
writing FTDICHIP does not supply means to install these files "in an
appropriate place."
You should use the following ./configure options to make use of
FTD2XX:
--with-ftd2xx-win32-zipdir
Where (CYGWIN/MINGW) the zip file from ftdichip.com
was unpacked <default=search>
--with-ftd2xx-linux-tardir
Where (Linux/Unix) the tar file from ftdichip.com
was unpacked <default=search>
--with-ftd2xx-lib=(static|shared)
Use static or shared ftd2xx libs (default is static)
Remember, this library is binary-only, while OpenOCD is licenced
according to GNU GPLv2 without any exceptions. That means that
_distributing_ copies of OpenOCD built with the FTDI code would
violate the OpenOCD licensing terms.
Note that on Linux there is no good reason to use these FTDI binaries;
they are no faster (on Linux) than libftdi, and cause licensing issues.
========================== ==========================
Obtaining OpenOCD From GIT Obtaining OpenOCD From GIT

364
configure.ac
View File

@ -159,36 +159,6 @@ else
fi fi
AC_MSG_RESULT([$build_release]) AC_MSG_RESULT([$build_release])
AC_ARG_WITH(ftd2xx,
AS_HELP_STRING([--with-ftd2xx=<PATH>],[This option has been removed.]),
[
# Option Given.
cat << __EOF__
The option: --with-ftd2xx=<PATH> has been removed.
On Linux, the new option is:
--with-ftd2xx-linux-tardir=/path/to/files
Where <path> is the path the the directory where the "tar.gz" file
from FTDICHIP.COM was unpacked, for example:
--with-ftd2xx-linux-tardir=${HOME}/libftd2xx0.4.16
On Cygwin/MingW32, the new option is:
--with-ftd2xx-win32-zipdir=/path/to/files
Where <path> is the path to the directory where the "zip" file from
FTDICHIP.COM was unpacked, for example:
--with-ftd2xx-win32-zipdir=${HOME}/ftd2xx.cdm.files
__EOF__
AC_MSG_ERROR([Sorry Cannot continue])
], [true])
# Adapter drivers # Adapter drivers
# 1st column -- configure option # 1st column -- configure option
# 2nd column -- description # 2nd column -- description
@ -223,63 +193,6 @@ m4_define([HIDAPI_ADAPTERS],
m4_define([LIBJAYLINK_ADAPTERS], m4_define([LIBJAYLINK_ADAPTERS],
[[[jlink], [SEGGER J-Link Programmer], [JLINK]]]) [[[jlink], [SEGGER J-Link Programmer], [JLINK]]])
#========================================
# FTD2XXX support comes in 4 forms.
# (1) win32 - via a zip file
# (2) linux - via a tar file
# (3) linux/cygwin/mingw - via libftdi
# (4) darwin - installed under /usr/local
#
# In case (1) and (2) we need to know where the package was unpacked.
AC_ARG_WITH(ftd2xx-win32-zipdir,
AS_HELP_STRING([--with-ftd2xx-win32-zipdir],[Where (CYGWIN/MINGW) the zip file from ftdichip.com was unpacked (default=search)]),
[
# option present
if test -d $with_ftd2xx_win32_zipdir
then
with_ftd2xx_win32_zipdir=`cd $with_ftd2xx_win32_zipdir && pwd`
AC_MSG_NOTICE([Using: ftdichip.com library: $with_ftd2xx_win32_zipdir])
else
AC_MSG_ERROR([Parameter to --with-ftd2xx-win32-zipdir is not a dir: $with_ftd2xx_win32_zipdir])
fi
], [true])
AC_ARG_WITH(ftd2xx-linux-tardir,
AS_HELP_STRING([--with-ftd2xx-linux-tardir], [Where (Linux/Unix) the tar file from ftdichip.com was unpacked (default=search)]),
[
# Option present
if test $is_win32 = yes ; then
AC_MSG_ERROR([The option: --with-ftd2xx-linux-tardir is only usable on linux])
fi
if test -d $with_ftd2xx_linux_tardir
then
with_ftd2xx_linux_tardir=`cd $with_ftd2xx_linux_tardir && pwd`
AC_MSG_NOTICE([Using: ftdichip.com library: $with_ftd2xx_linux_tardir])
else
AC_MSG_ERROR([Parameter to --with-ftd2xx-linux-tardir is not a dir: $with_ftd2xx_linux_tardir])
fi
], [true])
AC_ARG_WITH(ftd2xx-lib,
AS_HELP_STRING([--with-ftd2xx-lib],
[Use static or shared ftd2xx libs (default=static)]),
[
case "$withval" in
static)
with_ftd2xx_lib=$withval
;;
shared)
with_ftd2xx_lib=$withval
;;
*)
AC_MSG_ERROR([Option: --with-ftd2xx-lib=static or --with-ftd2xx-lib=shared not, $withval])
;;
esac
], [
# Default is static - it is simpler :-(
with_ftd2xx_lib=static
])
AC_ARG_ENABLE([doxygen-html], AC_ARG_ENABLE([doxygen-html],
AS_HELP_STRING([--disable-doxygen-html], AS_HELP_STRING([--disable-doxygen-html],
@ -402,12 +315,8 @@ AC_ARG_ENABLE([jtag_vpi],
[build_jtag_vpi=$enableval], [build_jtag_vpi=no]) [build_jtag_vpi=$enableval], [build_jtag_vpi=no])
AC_ARG_ENABLE([usb_blaster_libftdi], AC_ARG_ENABLE([usb_blaster_libftdi],
AS_HELP_STRING([--enable-usb_blaster_libftdi], [Enable building support for the Altera USB-Blaster using the libftdi driver, opensource alternate of FTD2XX]), AS_HELP_STRING([--enable-usb_blaster_libftdi], [Enable building support for the Altera USB-Blaster using the libftdi driver]),
[build_usb_blaster_libftdi=$enableval], [build_usb_blaster_libftdi=no]) [build_usb_blaster=$enableval], [build_usb_blaster=no])
AC_ARG_ENABLE([usb_blaster_ftd2xx],
AS_HELP_STRING([--enable-usb_blaster_ftd2xx], [Enable building support for the Altera USB-Blaster using the FTD2XX driver from ftdichip.com]),
[build_usb_blaster_ftd2xx=$enableval], [build_usb_blaster_ftd2xx=no])
AC_ARG_ENABLE([amtjtagaccel], AC_ARG_ENABLE([amtjtagaccel],
AS_HELP_STRING([--enable-amtjtagaccel], [Enable building the Amontec JTAG-Accelerator driver]), AS_HELP_STRING([--enable-amtjtagaccel], [Enable building the Amontec JTAG-Accelerator driver]),
@ -452,20 +361,12 @@ AC_ARG_ENABLE([gw16012],
[build_gw16012=$enableval], [build_gw16012=no]) [build_gw16012=$enableval], [build_gw16012=no])
AC_ARG_ENABLE([presto_libftdi], AC_ARG_ENABLE([presto_libftdi],
AS_HELP_STRING([--enable-presto_libftdi], [Enable building support for ASIX Presto Programmer using the libftdi driver]), AS_HELP_STRING([--enable-presto_libftdi], [Enable building support for ASIX Presto Programmer using the libftdi library]),
[build_presto_libftdi=$enableval], [build_presto_libftdi=no]) [build_presto=$enableval], [build_presto=no])
AC_ARG_ENABLE([presto_ftd2xx],
AS_HELP_STRING([--enable-presto_ftd2xx], [Enable building support for ASIX Presto Programmer using the FTD2XX driver]),
[build_presto_ftd2xx=$enableval], [build_presto_ftd2xx=no])
AC_ARG_ENABLE([openjtag_ftd2xx],
AS_HELP_STRING([--enable-openjtag_ftd2xx], [Enable building support for the OpenJTAG Programmer with ftd2xx driver]),
[build_openjtag_ftd2xx=$enableval], [build_openjtag_ftd2xx=no])
AC_ARG_ENABLE([openjtag_ftdi], AC_ARG_ENABLE([openjtag_ftdi],
AS_HELP_STRING([--enable-openjtag_ftdi], [Enable building support for the OpenJTAG Programmer with ftdi driver]), AS_HELP_STRING([--enable-openjtag_ftdi], [Enable building support for the OpenJTAG Programmer with libftdi library]),
[build_openjtag_ftdi=$enableval], [build_openjtag_ftdi=no]) [build_openjtag=$enableval], [build_openjtag=no])
AC_ARG_ENABLE([oocd_trace], AC_ARG_ENABLE([oocd_trace],
AS_HELP_STRING([--enable-oocd_trace], AS_HELP_STRING([--enable-oocd_trace],
@ -679,10 +580,10 @@ else
AC_DEFINE([BUILD_BITBANG], [0], [0 if you don't want a bitbang interface.]) AC_DEFINE([BUILD_BITBANG], [0], [0 if you don't want a bitbang interface.])
fi fi
if test $build_usb_blaster_libftdi = yes; then if test $build_usb_blaster = yes; then
AC_DEFINE([BUILD_USB_BLASTER_LIBFTDI], [1], [1 if you want libftdi usb_blaster.]) AC_DEFINE([BUILD_USB_BLASTER], [1], [1 if you want libftdi usb_blaster.])
else else
AC_DEFINE([BUILD_USB_BLASTER_LIBFTDI], [0], [0 if you don't want libftdi usb_blaster.]) AC_DEFINE([BUILD_USB_BLASTER], [0], [0 if you don't want libftdi usb_blaster.])
fi fi
if test $build_jtag_vpi = yes; then if test $build_jtag_vpi = yes; then
@ -691,12 +592,6 @@ else
AC_DEFINE([BUILD_JTAG_VPI], [0], [0 if you don't want JTAG VPI.]) AC_DEFINE([BUILD_JTAG_VPI], [0], [0 if you don't want JTAG VPI.])
fi fi
if test $build_usb_blaster_ftd2xx = yes; then
AC_DEFINE([BUILD_USB_BLASTER_FTD2XX], [1], [1 if you want ftd2xx usb_blaster.])
else
AC_DEFINE([BUILD_USB_BLASTER_FTD2XX], [0], [0 if you don't want ftd2xx usb_blaster.])
fi
if test $build_amtjtagaccel = yes; then if test $build_amtjtagaccel = yes; then
AC_DEFINE([BUILD_AMTJTAGACCEL], [1], [1 if you want the Amontec JTAG-Accelerator driver.]) AC_DEFINE([BUILD_AMTJTAGACCEL], [1], [1 if you want the Amontec JTAG-Accelerator driver.])
else else
@ -709,18 +604,11 @@ else
AC_DEFINE([BUILD_GW16012], [0], [0 if you don't want the Gateworks GW16012 driver.]) AC_DEFINE([BUILD_GW16012], [0], [0 if you don't want the Gateworks GW16012 driver.])
fi fi
if test $build_presto_libftdi = yes; then if test $build_presto = yes; then
build_bitq=yes build_bitq=yes
AC_DEFINE([BUILD_PRESTO_LIBFTDI], [1], [1 if you want the ASIX PRESTO driver using libftdi.]) AC_DEFINE([BUILD_PRESTO], [1], [1 if you want the ASIX PRESTO driver using libftdi.])
else else
AC_DEFINE([BUILD_PRESTO_LIBFTDI], [0], [0 if you don't want the ASIX PRESTO driver using libftdi.]) AC_DEFINE([BUILD_PRESTO], [0], [0 if you don't want the ASIX PRESTO driver using libftdi.])
fi
if test $build_presto_ftd2xx = yes; then
build_bitq=yes
AC_DEFINE([BUILD_PRESTO_FTD2XX], [1], [1 if you want the ASIX PRESTO driver using FTD2XX.])
else
AC_DEFINE([BUILD_PRESTO_FTD2XX], [0], [0 if you don't want the ASIX PRESTO driver using FTD2XX.])
fi fi
if test $build_bitq = yes; then if test $build_bitq = yes; then
@ -729,17 +617,11 @@ else
AC_DEFINE([BUILD_BITQ], [0], [0 if you don't want a bitq interface.]) AC_DEFINE([BUILD_BITQ], [0], [0 if you don't want a bitq interface.])
fi fi
AC_DEFINE([BUILD_OPENJTAG], [0], [0 if you don't want the OpenJTAG driver.])
AC_DEFINE([BUILD_OPENJTAG_FTD2XX], [0], [0 if you don't want the OpenJTAG driver with FTD2XX driver.])
AC_DEFINE([BUILD_OPENJTAG_LIBFTDI], [0], [0 if you don't want to build OpenJTAG driver with libftdi.])
if test $build_openjtag_ftd2xx = yes; then if test $build_openjtag = yes; then
AC_DEFINE([BUILD_OPENJTAG], [1], [1 if you want the OpenJTAG driver.]) AC_DEFINE([BUILD_OPENJTAG], [1], [1 if you want the OpenJTAG driver.])
AC_DEFINE([BUILD_OPENJTAG_FTD2XX], [1], [1 if you want the OpenJTAG driver with FTD2XX driver.]) else
fi AC_DEFINE([BUILD_OPENJTAG], [0], [0 if you don't want the OpenJTAG driver.])
if test $build_openjtag_ftdi = yes; then
AC_DEFINE([BUILD_OPENJTAG], [1], [1 if you want the OpenJTAG drvier.])
AC_DEFINE([BUILD_OPENJTAG_LIBFTDI], [1], [1 if you want to build OpenJTAG with FTDI driver.])
fi fi
if test $build_oocd_trace = yes; then if test $build_oocd_trace = yes; then
@ -775,210 +657,8 @@ if test $build_sysfsgpio = yes; then
else else
AC_DEFINE([BUILD_SYSFSGPIO], [0], [0 if you don't want SysfsGPIO driver.]) AC_DEFINE([BUILD_SYSFSGPIO], [0], [0 if you don't want SysfsGPIO driver.])
fi fi
#-- Deal with MingW/Cygwin FTD2XX issues
if test $is_win32 = yes; then if test $build_usb_blaster = yes -o $build_openjtag = yes -o $build_presto = yes; then
if test "${with_ftd2xx_linux_tardir+set}" = set
then
AC_MSG_ERROR([The option: with_ftd2xx_linux_tardir is for LINUX only.])
fi
if test $build_presto_ftd2xx = yes -o $build_usb_blaster_ftd2xx = yes -o $build_openjtag_ftd2xx = yes; then
AC_MSG_CHECKING([for ftd2xx.lib exists (win32)])
# if we are given a zipdir...
if test "${with_ftd2xx_win32_zipdir+set}" = set
then
# Set the CFLAGS for "ftd2xx.h"
f=$with_ftd2xx_win32_zipdir/ftd2xx.h
if test ! -f $f ; then
AC_MSG_ERROR([File: $f cannot be found])
fi
CFLAGS="$CFLAGS -I$with_ftd2xx_win32_zipdir"
# And calculate the LDFLAGS for the machine
case "$host_cpu" in
i?86|x86_32)
LDFLAGS="$LDFLAGS -L$with_ftd2xx_win32_zipdir/i386"
LIBS="$LIBS -lftd2xx"
f=$with_ftd2xx_win32_zipdir/i386/ftd2xx.lib
;;
amd64|x86_64)
LDFLAGS="$LDFLAGS -L$with_ftd2xx_win32_zipdir/amd64"
LIBS="$LIBS -lftd2xx"
f=$with_ftd2xx_win32_zipdir/amd64/ftd2xx.lib
;;
*)
AC_MSG_ERROR([Unknown Win32 host cpu: $host_cpu])
;;
esac
if test ! -f $f ; then
AC_MSG_ERROR([Library: $f not found])
fi
else
LIBS="$LIBS -lftd2xx"
AC_MSG_WARN([ASSUMPTION: The (win32) FTDICHIP.COM files: ftd2xx.h and ftd2xx.lib are in a proper place])
fi
fi
fi # win32
if test $is_darwin = yes ; then
if test "${with_ftd2xx_win32_zipdir+set}" = set
then
AC_MSG_ERROR([The option: --with-ftd2xx-win32-zipdir is for win32 only])
fi
if test "${with_ftd2xx_linux_tardir+set}" = set
then
AC_MSG_ERROR([The option: with_ftd2xx_linux_tardir is for LINUX only.])
fi
if test $build_presto_ftd2xx = yes -o $build_usb_blaster_ftd2xx = yes ; then
AC_MSG_CHECKING([for libftd2xx.a (darwin)])
if test ! -f /usr/local/include/ftd2xx.h ; then
AC_MSG_ERROR([ftd2xx library from FTDICHIP.com seems to be missing, cannot find: /usr/local/include/ftd2xx.h])
fi
CFLAGS="$CFLAGS -I/usr/local/include"
LDFLAGS="$LDFLAGS -L/usr/local/lib"
LIBS="$LIBS -lftd2xx"
AC_MSG_RESULT([-L/usr/local/lib -lftd2xx])
fi
fi # darwin
if test $is_win32 = no && test $is_darwin = no ; then
if test "${with_ftd2xx_win32_zipdir+set}" = set
then
AC_MSG_ERROR([The option: --with-ftd2xx-win32-zipdir is for win32 only])
fi
if test $build_presto_ftd2xx = yes -o $build_usb_blaster_ftd2xx = yes -o $build_openjtag_ftd2xx = yes; then
# Must be linux
if test $host_os != linux-gnu && test $host_os != linux ; then
AC_MSG_ERROR([The (linux) ftd2xx library from FTDICHIP.com is linux only. Try --enable-*-libftdi instead])
fi
# Are we given a TAR directory?
if test "${with_ftd2xx_linux_tardir+set}" = set
then
AC_MSG_CHECKING([uninstalled ftd2xx distribution])
# The .H file is simple..
FTD2XX_H=$with_ftd2xx_linux_tardir/ftd2xx.h
if test ! -f "${FTD2XX_H}"; then
AC_MSG_ERROR([Option: --with-ftd2xx-linux-tardir appears wrong, cannot find: ${FTD2XX_H}])
fi
CFLAGS="$CFLAGS -I$with_ftd2xx_linux_tardir"
if test $with_ftd2xx_lib = shared; then
FTD2XX_LDFLAGS="-L$with_ftd2xx_linux_tardir"
FTD2XX_LIB="-lftd2xx"
else
# Test #1 - v1.0.x
case "$host_cpu" in
i?86|x86_32)
dir=build/i386;;
amd64|x86_64)
dir=build/x86_64;;
*)
dir=none;;
esac
if test -f "$with_ftd2xx_linux_tardir/$dir/libftd2xx.a"; then
FTD2XX_LDFLAGS="-L$with_ftd2xx_linux_tardir/$dir"
# Also needs -lrt
FTD2XX_LIB="-lftd2xx -lrt"
else
# Test Number2.
# Grr.. perhaps it exists as a version number?
FTD2XX_LIB="$with_ftd2xx_linux_tardir/static_lib/libftd2xx.a.*.*.*"
count=`ls ${FTD2XX_LIB} | wc -l`
if test $count -gt 1 ; then
AC_MSG_ERROR([Multiple libftd2xx.a files found in: $with_ftd2xx_linux_tardir/static_lib sorry cannot handle this yet])
fi
if test $count -ne 1 ; then
AC_MSG_ERROR([Not found: $f, option: --with-ftd2xx-linux-tardir appears to be wrong])
fi
# Because the "-l" rules do not understand version numbers...
# we will just stuff the absolute path onto the LIBS variable
FTD2XX_LIB="`ls ${FTD2XX_LIB}` -lpthread"
FTD2XX_LDFLAGS=""
fi
fi
LDFLAGS="${LDFLAGS} ${FTD2XX_LDFLAGS}"
LIBS="${FTD2XX_LIB} ${LIBS}"
AC_MSG_RESULT([${FTD2XX_LDFLAGS} ${FTD2XX_LIB}])
else
AC_CHECK_HEADER([ftd2xx.h],[],[
AC_MSG_ERROR([You seem to be missing the FTD2xx driver header file.])
])
AC_SEARCH_LIBS([FT_GetLibraryVersion],[ftd2xx],,[
AC_MSG_ERROR([You appear to be missing the FTD2xx driver library.])
],[-lrt -lusb-1.0])
fi
fi
fi # linux
if test $build_presto_ftd2xx = yes -o $build_usb_blaster_ftd2xx = yes ; then
# Before we go any further - make sure we can *BUILD* and *RUN*
# a simple app with the "ftd2xx.lib" file - in what ever form we where given
# We should be able to compile, link and run this test program now
AC_MSG_CHECKING([whether ftd2xx library works])
#
# Save the LDFLAGS for later..
LDFLAGS_SAVE=$LDFLAGS
CFLAGS_SAVE=$CFLAGS
_LDFLAGS=`eval echo $LDFLAGS`
_CFLAGS=`eval echo $CFLAGS`
LDFLAGS=$_LDFLAGS
CFLAGS=$_CFLAGS
AC_RUN_IFELSE([AC_LANG_PROGRAM([[
#include "confdefs.h"
#if IS_WIN32
#include "windows.h"
#endif
#include <stdio.h>
#include <ftd2xx.h>
]], [[
DWORD x;
FT_GetLibraryVersion( &x );
]])], [
AC_MSG_RESULT([Success!])
], [
AC_MSG_ERROR([Cannot build & run test program using ftd2xx.lib])
], [
AC_MSG_RESULT([Skipping as we are cross-compiling])
])
AC_MSG_CHECKING([for ftd2xx FT232H device support])
AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
#include "confdefs.h"
#if IS_WIN32
#include "windows.h"
#endif
#include <stdio.h>
#include <ftd2xx.h>
DWORD x = FT_DEVICE_232H;
]], [])], [
AC_DEFINE([HAS_ENUM_FT232H], [1],
[Support FT232H with FTD2XX or libftdi.])
has_enum_ft232h=yes
], [
has_enum_ft232h=no
])
AC_MSG_RESULT([$has_enum_ft232h])
if test $has_enum_ft232h = no; then
AC_MSG_WARN([You need a newer FTD2XX driver (version 2.08.12 or later).])
fi
LDFLAGS=$LDFLAGS_SAVE
CFLAGS=$CFLAGS_SAVE
fi
if test $build_usb_blaster_libftdi = yes -o \
$build_openjtag_ftdi = yes -o $build_presto_libftdi = yes; then
# we can have libftdi or libftdi1, so check it and use the latest one # we can have libftdi or libftdi1, so check it and use the latest one
PKG_CHECK_MODULES([LIBFTDI], [libftdi1], [use_libftdi=yes], [use_libftdi=no]) PKG_CHECK_MODULES([LIBFTDI], [libftdi1], [use_libftdi=yes], [use_libftdi=no])
@ -1032,7 +712,7 @@ AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[
enum ftdi_chip_type x = TYPE_232H; enum ftdi_chip_type x = TYPE_232H;
]])], [ ]])], [
AC_DEFINE([HAS_ENUM_FT232H], [1], AC_DEFINE([HAS_ENUM_FT232H], [1],
[Support FT232H with FTD2XX or libftdi.]) [Support FT232H with libftdi.])
has_enum_ft232h=yes has_enum_ft232h=yes
], [ ], [
has_enum_ft232h=no has_enum_ft232h=no
@ -1131,15 +811,13 @@ AM_CONDITIONAL([IOUTIL], [test $build_ioutil = yes])
AM_CONDITIONAL([AT91RM9200], [test $build_at91rm9200 = yes]) AM_CONDITIONAL([AT91RM9200], [test $build_at91rm9200 = yes])
AM_CONDITIONAL([BCM2835GPIO], [test $build_bcm2835gpio = yes]) AM_CONDITIONAL([BCM2835GPIO], [test $build_bcm2835gpio = yes])
AM_CONDITIONAL([BITBANG], [test $build_bitbang = yes]) AM_CONDITIONAL([BITBANG], [test $build_bitbang = yes])
AM_CONDITIONAL([USB_BLASTER_LIBFTDI], [test $build_usb_blaster_libftdi = yes])
AM_CONDITIONAL([USB_BLASTER_FTD2XX], [test $build_usb_blaster_ftd2xx = yes])
AM_CONDITIONAL([JTAG_VPI], [test $build_jtag_vpi = yes -o $build_jtag_vpi = yes]) AM_CONDITIONAL([JTAG_VPI], [test $build_jtag_vpi = yes -o $build_jtag_vpi = yes])
AM_CONDITIONAL([USB_BLASTER_DRIVER], [test $build_usb_blaster_ftd2xx = yes -o $build_usb_blaster_libftdi = yes -o $enable_usb_blaster_2 != no]) AM_CONDITIONAL([USB_BLASTER_DRIVER], [test $build_usb_blaster = yes -o $enable_usb_blaster_2 != no])
AM_CONDITIONAL([USB_BLASTER], [test $build_usb_blaster = yes])
AM_CONDITIONAL([AMTJTAGACCEL], [test $build_amtjtagaccel = yes]) AM_CONDITIONAL([AMTJTAGACCEL], [test $build_amtjtagaccel = yes])
AM_CONDITIONAL([GW16012], [test $build_gw16012 = yes]) AM_CONDITIONAL([GW16012], [test $build_gw16012 = yes])
AM_CONDITIONAL([PRESTO_LIBFTDI], [test $build_presto_libftdi = yes]) AM_CONDITIONAL([PRESTO], [test $build_presto = yes])
AM_CONDITIONAL([PRESTO_DRIVER], [test $build_presto_ftd2xx = yes -o $build_presto_libftdi = yes]) AM_CONDITIONAL([OPENJTAG], [test $build_openjtag = yes])
AM_CONDITIONAL([OPENJTAG], [test $build_openjtag_ftd2xx = yes -o $build_openjtag_ftdi = yes])
AM_CONDITIONAL([OOCD_TRACE], [test $build_oocd_trace = yes]) AM_CONDITIONAL([OOCD_TRACE], [test $build_oocd_trace = yes])
AM_CONDITIONAL([REMOTE_BITBANG], [test $build_remote_bitbang = yes]) AM_CONDITIONAL([REMOTE_BITBANG], [test $build_remote_bitbang = yes])
AM_CONDITIONAL([BUSPIRATE], [test $build_buspirate = yes]) AM_CONDITIONAL([BUSPIRATE], [test $build_buspirate = yes])

2
doc/openocd.texi
View File

@ -2624,7 +2624,7 @@ reset_config srst_only
@end example @end example
@end deffn @end deffn
@deffn {Command} {usb_blaster_lowlevel_driver} (@option{ftdi}|@option{ftd2xx}|@option{ublast2}) @deffn {Command} {usb_blaster_lowlevel_driver} (@option{ftdi}|@option{ublast2})
Chooses the low level access method for the adapter. If not specified, Chooses the low level access method for the adapter. If not specified,
@option{ftdi} is selected unless it wasn't enabled during the @option{ftdi} is selected unless it wasn't enabled during the
configure stage. USB-Blaster II needs @option{ublast2}. configure stage. USB-Blaster II needs @option{ublast2}.

3
src/jtag/drivers/Makefile.am
View File

@ -85,7 +85,7 @@ endif
if BITQ if BITQ
DRIVERFILES += bitq.c DRIVERFILES += bitq.c
endif endif
if PRESTO_DRIVER if PRESTO
DRIVERFILES += presto.c DRIVERFILES += presto.c
endif endif
if USBPROG if USBPROG
@ -145,7 +145,6 @@ endif
noinst_HEADERS = \ noinst_HEADERS = \
bitbang.h \ bitbang.h \
bitq.h \ bitq.h \
ftd2xx_common.h \
libusb0_common.h \ libusb0_common.h \
libusb1_common.h \ libusb1_common.h \
libusb_common.h \ libusb_common.h \

55
src/jtag/drivers/ftd2xx_common.h
View File

@ -1,55 +0,0 @@
/***************************************************************************
* Copyright (C) 2011 by Spencer Oliver <spen@spen-soft.co.uk> *
* *
* Written by Arnim Laeuger, 2008 (from urjtag) *
* *
* This program is free software; you can redistribute it and/or modify *
* it 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, see <http://www.gnu.org/licenses/>. *
***************************************************************************/
#ifndef OPENOCD_JTAG_DRIVERS_FTD2XX_COMMON_H
#define OPENOCD_JTAG_DRIVERS_FTD2XX_COMMON_H
#if ((BUILD_PRESTO_FTD2XX == 1) || (BUILD_USB_BLASTER_FTD2XX == 1))
#include <ftd2xx.h>
static const char *ftd2xx_status_string(FT_STATUS status)
{
switch (status) {
case FT_OK: return "OK";
case FT_INVALID_HANDLE: return "invalid handle";
case FT_DEVICE_NOT_FOUND: return "device not found";
case FT_DEVICE_NOT_OPENED: return "device not opened";
case FT_IO_ERROR: return "io error";
case FT_INSUFFICIENT_RESOURCES: return "insufficient resources";
case FT_INVALID_PARAMETER: return "invalid parameter";
case FT_INVALID_BAUD_RATE: return "invalid baud rate";
case FT_DEVICE_NOT_OPENED_FOR_ERASE: return "device not opened for erase";
case FT_DEVICE_NOT_OPENED_FOR_WRITE: return "device not opened for write";
case FT_FAILED_TO_WRITE_DEVICE: return "failed to write device";
case FT_EEPROM_READ_FAILED: return "eeprom read failed";
case FT_EEPROM_WRITE_FAILED: return "eeprom write failed";
case FT_EEPROM_ERASE_FAILED: return "eeprom erase failed";
case FT_EEPROM_NOT_PRESENT: return "eeprom not present";
case FT_EEPROM_NOT_PROGRAMMED: return "eeprom not programmed";
case FT_INVALID_ARGS: return "invalid args";
case FT_NOT_SUPPORTED: return "not supported";
case FT_OTHER_ERROR: return "other error";
}
return "undefined FTD2xx error";
}
#endif
#endif /* OPENOCD_JTAG_DRIVERS_FTD2XX_COMMON_H */

173
src/jtag/drivers/openjtag.c
View File

@ -1,6 +1,6 @@
/******************************************************************************* /*******************************************************************************
* Driver for OpenJTAG Project (www.openjtag.org) * * Driver for OpenJTAG Project (www.openjtag.org) *
* Compatible with libftdi and ftd2xx drivers. * * Compatible with libftdi driver. *
* * * *
* Copyright (C) 2010 by Ivan Meleca <mileca@gmail.com> * * Copyright (C) 2010 by Ivan Meleca <mileca@gmail.com> *
* * * *
@ -66,19 +66,8 @@ typedef enum openjtag_tap_state {
OPENJTAG_TAP_UPDATE_IR = 15, OPENJTAG_TAP_UPDATE_IR = 15,
} openjtag_tap_state_t; } openjtag_tap_state_t;
#if (BUILD_OPENJTAG_FTD2XX == 1 && BUILD_OPENJTAG_LIBFTDI == 1)
#error "BUILD_OPENJTAG_FTD2XX && BUILD_OPENJTAG_LIBFTDI "
"are mutually exclusive"
#elif (BUILD_OPENJTAG_FTD2XX != 1 && BUILD_OPENJTAG_LIBFTDI != 1)
#error "BUILD_OPENJTAG_FTD2XX || BUILD_OPENJTAG_LIBFTDI must be chosen"
#endif
/* OPENJTAG access library includes */ /* OPENJTAG access library includes */
#if BUILD_OPENJTAG_FTD2XX == 1
#include <ftd2xx.h>
#elif BUILD_OPENJTAG_LIBFTDI == 1
#include <ftdi.h> #include <ftdi.h>
#endif
/* OpenJTAG vid/pid */ /* OpenJTAG vid/pid */
static uint16_t openjtag_vid = 0x0403; static uint16_t openjtag_vid = 0x0403;
@ -86,12 +75,7 @@ static uint16_t openjtag_pid = 0x6001;
static char *openjtag_device_desc; static char *openjtag_device_desc;
#if BUILD_OPENJTAG_FTD2XX == 1
static FT_HANDLE ftdih;
#elif BUILD_OPENJTAG_LIBFTDI == 1
static struct ftdi_context ftdic; static struct ftdi_context ftdic;
#endif
#define OPENJTAG_BUFFER_SIZE 504 #define OPENJTAG_BUFFER_SIZE 504
#define OPENJTAG_MAX_PENDING_RESULTS 256 #define OPENJTAG_MAX_PENDING_RESULTS 256
@ -204,23 +188,6 @@ static int8_t openjtag_get_tap_state(int8_t state)
static int openjtag_buf_write( static int openjtag_buf_write(
uint8_t *buf, int size, uint32_t *bytes_written) uint8_t *buf, int size, uint32_t *bytes_written)
{ {
#if BUILD_OPENJTAG_FTD2XX == 1
FT_STATUS status;
DWORD dw_bytes_written;
#ifdef _DEBUG_USB_COMMS_
openjtag_debug_buffer(buf, size, DEBUG_TYPE_WRITE);
#endif
status = FT_Write(ftdih, buf, size, &dw_bytes_written);
if (status != FT_OK) {
*bytes_written = dw_bytes_written;
LOG_ERROR("FT_Write returned: %u", status);
return ERROR_JTAG_DEVICE_ERROR;
}
*bytes_written = dw_bytes_written;
return ERROR_OK;
#elif BUILD_OPENJTAG_LIBFTDI == 1
int retval; int retval;
#ifdef _DEBUG_USB_COMMS_ #ifdef _DEBUG_USB_COMMS_
openjtag_debug_buffer(buf, size, DEBUG_TYPE_WRITE); openjtag_debug_buffer(buf, size, DEBUG_TYPE_WRITE);
@ -236,36 +203,10 @@ static int openjtag_buf_write(
*bytes_written += retval; *bytes_written += retval;
return ERROR_OK; return ERROR_OK;
#endif
} }
static int openjtag_buf_read(uint8_t *buf, uint32_t qty, uint32_t *bytes_read) static int openjtag_buf_read(uint8_t *buf, uint32_t qty, uint32_t *bytes_read)
{ {
#if BUILD_OPENJTAG_FTD2XX == 1
DWORD dw_bytes_read;
FT_STATUS status;
int timeout = 50;
*bytes_read = 0;
while (qty && (*bytes_read < qty) && timeout--) {
status = FT_Read(ftdih, buf + *bytes_read,
qty - *bytes_read, &dw_bytes_read);
if (status != FT_OK) {
*bytes_read = dw_bytes_read;
LOG_ERROR("FT_Read returned: %u", status);
return ERROR_JTAG_DEVICE_ERROR;
}
*bytes_read += dw_bytes_read;
}
#ifdef _DEBUG_USB_COMMS_
openjtag_debug_buffer(buf, *bytes_read, DEBUG_TYPE_READ);
#endif
return ERROR_OK;
#elif BUILD_OPENJTAG_LIBFTDI == 1
int retval; int retval;
int timeout = 5; int timeout = 5;
@ -287,7 +228,6 @@ static int openjtag_buf_read(uint8_t *buf, uint32_t qty, uint32_t *bytes_read)
openjtag_debug_buffer(buf, *bytes_read, DEBUG_TYPE_READ); openjtag_debug_buffer(buf, *bytes_read, DEBUG_TYPE_READ);
#endif #endif
#endif
return ERROR_OK; return ERROR_OK;
} }
@ -339,105 +279,19 @@ static int openjtag_init(void)
{ {
uint8_t latency_timer; uint8_t latency_timer;
#if BUILD_OPENJTAG_FTD2XX == 1 usb_tx_buf_offs = 0;
FT_STATUS status; usb_rx_buf_len = 0;
#endif openjtag_scan_result_count = 0;
usb_tx_buf_offs = 0;
usb_rx_buf_len = 0;
openjtag_scan_result_count = 0;
#if BUILD_OPENJTAG_FTD2XX == 1
LOG_DEBUG("'openjtag' interface using FTD2XX");
#elif BUILD_OPENJTAG_LIBFTDI == 1
LOG_DEBUG("'openjtag' interface using libftdi"); LOG_DEBUG("'openjtag' interface using libftdi");
#endif
/* Open by device description */ /* Open by device description */
if (openjtag_device_desc == NULL) { if (openjtag_device_desc == NULL) {
LOG_WARNING("no openjtag device description specified, " LOG_WARNING("no openjtag device description specified, "
"using default 'Open JTAG Project'"); "using default 'Open JTAG Project'");
openjtag_device_desc = "Open JTAG Project"; openjtag_device_desc = "Open JTAG Project";
}
#if BUILD_OPENJTAG_FTD2XX == 1
#if IS_WIN32 == 0
/* Add non-standard Vid/Pid to the linux driver */
status = FT_SetVIDPID(openjtag_vid, openjtag_pid);
if (status != FT_OK) {
LOG_WARNING("couldn't add %4.4x:%4.4x",
openjtag_vid, openjtag_pid);
}
#endif
status = FT_OpenEx(openjtag_device_desc, FT_OPEN_BY_DESCRIPTION,
&ftdih);
if (status != FT_OK) {
DWORD num_devices;
LOG_ERROR("unable to open ftdi device: %u", status);
status = FT_ListDevices(&num_devices, NULL,
FT_LIST_NUMBER_ONLY);
if (status == FT_OK) {
char **desc_array = malloc(sizeof(char *)
* (num_devices + 1));
unsigned int i;
for (i = 0; i < num_devices; i++)
desc_array[i] = malloc(64);
desc_array[num_devices] = NULL;
status = FT_ListDevices(desc_array, &num_devices,
FT_LIST_ALL | FT_OPEN_BY_DESCRIPTION);
if (status == FT_OK) {
LOG_ERROR("ListDevices: %u\n", num_devices);
for (i = 0; i < num_devices; i++)
LOG_ERROR("%i: %s", i, desc_array[i]);
}
for (i = 0; i < num_devices; i++)
free(desc_array[i]);
free(desc_array);
} else {
LOG_ERROR("ListDevices: NONE\n");
}
return ERROR_JTAG_INIT_FAILED;
} }
status = FT_SetLatencyTimer(ftdih, 2);
if (status != FT_OK) {
LOG_ERROR("unable to set latency timer: %u", status);
return ERROR_JTAG_INIT_FAILED;
}
status = FT_GetLatencyTimer(ftdih, &latency_timer);
if (status != FT_OK) {
LOG_ERROR("unable to get latency timer: %u", status);
return ERROR_JTAG_INIT_FAILED;
}
LOG_DEBUG("current latency timer: %i", latency_timer);
status = FT_SetBitMode(ftdih, 0x00, 0x40);
if (status != FT_OK) {
LOG_ERROR("unable to disable bit i/o mode: %u", status);
return ERROR_JTAG_INIT_FAILED;
}
status = FT_SetTimeouts(ftdih, 50, 0);
if (status != FT_OK) {
LOG_ERROR("unable to set timeouts: %u", status);
return ERROR_JTAG_INIT_FAILED;
}
status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX);
if (status != FT_OK) {
LOG_ERROR("unable to FT_Purge() %u", status);
return ERROR_JTAG_INIT_FAILED;
}
#elif BUILD_OPENJTAG_LIBFTDI == 1
if (ftdi_init(&ftdic) < 0) if (ftdi_init(&ftdic) < 0)
return ERROR_JTAG_INIT_FAILED; return ERROR_JTAG_INIT_FAILED;
@ -470,18 +324,11 @@ if (openjtag_device_desc == NULL) {
ftdi_get_error_string(&ftdic)); ftdi_get_error_string(&ftdic));
return ERROR_JTAG_DEVICE_ERROR; return ERROR_JTAG_DEVICE_ERROR;
} }
#endif
#if BUILD_OPENJTAG_FTD2XX == 1
status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX);
if (status != FT_OK)
return ERROR_JTAG_INIT_FAILED;
#elif BUILD_OPENJTAG_LIBFTDI == 1
if (ftdi_usb_purge_buffers(&ftdic) < 0) { if (ftdi_usb_purge_buffers(&ftdic) < 0) {
LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str); LOG_ERROR("ftdi_purge_buffers: %s", ftdic.error_str);
return ERROR_JTAG_INIT_FAILED; return ERROR_JTAG_INIT_FAILED;
} }
#endif
/* OpenJTAG speed */ /* OpenJTAG speed */
openjtag_sendcommand(0xE0); /*Start at slowest adapter speed*/ openjtag_sendcommand(0xE0); /*Start at slowest adapter speed*/
@ -494,12 +341,8 @@ if (openjtag_device_desc == NULL) {
static int openjtag_quit(void) static int openjtag_quit(void)
{ {
#if BUILD_OPENJTAG_FTD2XX == 1
FT_Close(ftdih);
#elif BUILD_OPENJTAG_LIBFTDI == 1
ftdi_usb_close(&ftdic); ftdi_usb_close(&ftdic);
ftdi_deinit(&ftdic); ftdi_deinit(&ftdic);
#endif
return ERROR_OK; return ERROR_OK;
} }

219
src/jtag/drivers/presto.c
View File

@ -34,14 +34,7 @@
#include "bitq.h" #include "bitq.h"
/* PRESTO access library includes */ /* PRESTO access library includes */
#if BUILD_PRESTO_FTD2XX == 1
#include <ftd2xx.h>
#include "ftd2xx_common.h"
#elif BUILD_PRESTO_LIBFTDI == 1
#include <ftdi.h> #include <ftdi.h>
#else
#error "BUG: either FTD2XX and LIBFTDI has to be used"
#endif
/* -------------------------------------------------------------------------- */ /* -------------------------------------------------------------------------- */
@ -55,13 +48,8 @@
#define BUFFER_SIZE (64*62) #define BUFFER_SIZE (64*62)
struct presto { struct presto {
#if BUILD_PRESTO_FTD2XX == 1
FT_HANDLE handle;
FT_STATUS status;
#elif BUILD_PRESTO_LIBFTDI == 1
struct ftdi_context ftdic; struct ftdi_context ftdic;
int retval; int retval;
#endif
char serial[FT_DEVICE_SERNUM_LEN]; char serial[FT_DEVICE_SERNUM_LEN];
@ -95,15 +83,6 @@ static uint8_t presto_init_seq[] = {
static int presto_write(uint8_t *buf, uint32_t size) static int presto_write(uint8_t *buf, uint32_t size)
{ {
#if BUILD_PRESTO_FTD2XX == 1
DWORD ftbytes;
presto->status = FT_Write(presto->handle, buf, size, &ftbytes);
if (presto->status != FT_OK) {
LOG_ERROR("FT_Write returned: %s", ftd2xx_status_string(presto->status));
return ERROR_JTAG_DEVICE_ERROR;
}
#elif BUILD_PRESTO_LIBFTDI == 1
uint32_t ftbytes; uint32_t ftbytes;
presto->retval = ftdi_write_data(&presto->ftdic, buf, size); presto->retval = ftdi_write_data(&presto->ftdic, buf, size);
if (presto->retval < 0) { if (presto->retval < 0) {
@ -111,7 +90,6 @@ static int presto_write(uint8_t *buf, uint32_t size)
return ERROR_JTAG_DEVICE_ERROR; return ERROR_JTAG_DEVICE_ERROR;
} }
ftbytes = presto->retval; ftbytes = presto->retval;
#endif
if (ftbytes != size) { if (ftbytes != size) {
LOG_ERROR("couldn't write the requested number of bytes to PRESTO (%u < %u)", LOG_ERROR("couldn't write the requested number of bytes to PRESTO (%u < %u)",
@ -124,15 +102,6 @@ static int presto_write(uint8_t *buf, uint32_t size)
static int presto_read(uint8_t *buf, uint32_t size) static int presto_read(uint8_t *buf, uint32_t size)
{ {
#if BUILD_PRESTO_FTD2XX == 1
DWORD ftbytes;
presto->status = FT_Read(presto->handle, buf, size, &ftbytes);
if (presto->status != FT_OK) {
LOG_ERROR("FT_Read returned: %s", ftd2xx_status_string(presto->status));
return ERROR_JTAG_DEVICE_ERROR;
}
#elif BUILD_PRESTO_LIBFTDI == 1
uint32_t ftbytes = 0; uint32_t ftbytes = 0;
struct timeval timeout, now; struct timeval timeout, now;
@ -152,7 +121,6 @@ static int presto_read(uint8_t *buf, uint32_t size)
((now.tv_sec == timeout.tv_sec) && (now.tv_usec > timeout.tv_usec))) ((now.tv_sec == timeout.tv_sec) && (now.tv_usec > timeout.tv_usec)))
break; break;
} }
#endif
if (ftbytes != size) { if (ftbytes != size) {
/* this is just a warning, there might have been timeout when detecting PRESTO, /* this is just a warning, there might have been timeout when detecting PRESTO,
@ -165,150 +133,6 @@ static int presto_read(uint8_t *buf, uint32_t size)
return ERROR_OK; return ERROR_OK;
} }
#if BUILD_PRESTO_FTD2XX == 1
static int presto_open_ftd2xx(char *req_serial)
{
uint32_t i;
DWORD numdevs;
DWORD vidpid;
char devname[FT_DEVICE_NAME_LEN];
FT_DEVICE device;
BYTE presto_data;
DWORD ftbytes;
presto->handle = (FT_HANDLE)INVALID_HANDLE_VALUE;
#if IS_WIN32 == 0
/* Add non-standard Vid/Pid to the linux driver */
presto->status = FT_SetVIDPID(PRESTO_VID, PRESTO_PID);
if (presto->status != FT_OK) {
LOG_ERROR("couldn't add PRESTO VID/PID");
exit(-1);
}
#endif
presto->status = FT_ListDevices(&numdevs, NULL, FT_LIST_NUMBER_ONLY);
if (presto->status != FT_OK) {
LOG_ERROR("FT_ListDevices failed: %s", ftd2xx_status_string(presto->status));
return ERROR_JTAG_DEVICE_ERROR;
}
LOG_DEBUG("FTDI devices available: %" PRIu32, (uint32_t)numdevs);
for (i = 0; i < numdevs; i++) {
presto->status = FT_Open(i, &(presto->handle));
if (presto->status != FT_OK) {
/* this is not fatal, the device may be legitimately open by other process,
*hence debug message only */
LOG_DEBUG("FT_Open failed: %s", ftd2xx_status_string(presto->status));
continue;
}
LOG_DEBUG("FTDI device %i open", (int)i);
presto->status = FT_GetDeviceInfo(presto->handle, &device,
&vidpid, presto->serial, devname, NULL);
if (presto->status == FT_OK) {
if (vidpid == PRESTO_VID_PID && (req_serial == NULL ||
!strcmp(presto->serial, req_serial)))
break;
} else
LOG_DEBUG("FT_GetDeviceInfo failed: %s", ftd2xx_status_string(
presto->status));
LOG_DEBUG("FTDI device %i does not match, closing", (int)i);
FT_Close(presto->handle);
presto->handle = (FT_HANDLE)INVALID_HANDLE_VALUE;
}
if (presto->handle == (FT_HANDLE)INVALID_HANDLE_VALUE)
return ERROR_JTAG_DEVICE_ERROR; /* presto not open, return */
presto->status = FT_SetLatencyTimer(presto->handle, 1);
if (presto->status != FT_OK)
return ERROR_JTAG_DEVICE_ERROR;
presto->status = FT_SetTimeouts(presto->handle, 100, 0);
if (presto->status != FT_OK)
return ERROR_JTAG_DEVICE_ERROR;
presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX);
if (presto->status != FT_OK)
return ERROR_JTAG_DEVICE_ERROR;
presto_data = 0xD0;
presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes);
if (presto->status != FT_OK)
return ERROR_JTAG_DEVICE_ERROR;
/* delay between first write/read turnaround (after purge?) necessary
* under Linux for unknown reason,
* probably a bug in library threading */
usleep(100000);
presto->status = FT_Read(presto->handle, &presto_data, 1, &ftbytes);
if (presto->status != FT_OK)
return ERROR_JTAG_DEVICE_ERROR;
if (ftbytes != 1) {
LOG_DEBUG("PRESTO reset");
presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX);
if (presto->status != FT_OK)
return ERROR_JTAG_DEVICE_ERROR;
presto->status = FT_SetBitMode(presto->handle, 0x80, 1);
if (presto->status != FT_OK)
return ERROR_JTAG_DEVICE_ERROR;
presto->status = FT_SetBaudRate(presto->handle, 9600);
if (presto->status != FT_OK)
return ERROR_JTAG_DEVICE_ERROR;
presto_data = 0;
for (i = 0; i < 4 * 62; i++) {
presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes);
if (presto->status != FT_OK)
return ERROR_JTAG_DEVICE_ERROR;
}
usleep(100000);
presto->status = FT_SetBitMode(presto->handle, 0x00, 0);
if (presto->status != FT_OK)
return ERROR_JTAG_DEVICE_ERROR;
presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX);
if (presto->status != FT_OK)
return ERROR_JTAG_DEVICE_ERROR;
presto_data = 0xD0;
presto->status = FT_Write(presto->handle, &presto_data, 1, &ftbytes);
if (presto->status != FT_OK)
return ERROR_JTAG_DEVICE_ERROR;
/* delay between first write/read turnaround (after purge?) necessary under Linux for unknown reason,
probably a bug in library threading */
usleep(100000);
presto->status = FT_Read(presto->handle, &presto_data, 1, &ftbytes);
if (presto->status != FT_OK)
return ERROR_JTAG_DEVICE_ERROR;
if (ftbytes != 1) {
LOG_DEBUG("PRESTO not responding");
return ERROR_JTAG_DEVICE_ERROR;
}
}
presto->status = FT_SetTimeouts(presto->handle, 0, 0);
if (presto->status != FT_OK)
return ERROR_JTAG_DEVICE_ERROR;
presto->status = FT_Write(presto->handle, &presto_init_seq,
sizeof(presto_init_seq), &ftbytes);
if (presto->status != FT_OK || ftbytes != sizeof(presto_init_seq))
return ERROR_JTAG_DEVICE_ERROR;
return ERROR_OK;
}
#elif BUILD_PRESTO_LIBFTDI == 1
static int presto_open_libftdi(char *req_serial) static int presto_open_libftdi(char *req_serial)
{ {
uint8_t presto_data; uint8_t presto_data;
@ -371,7 +195,6 @@ static int presto_open_libftdi(char *req_serial)
return ERROR_OK; return ERROR_OK;
} }
#endif /* BUILD_PRESTO_LIBFTDI == 1 */
static int presto_open(char *req_serial) static int presto_open(char *req_serial)
{ {
@ -391,11 +214,7 @@ static int presto_open(char *req_serial)
presto->jtag_speed = 0; presto->jtag_speed = 0;
#if BUILD_PRESTO_FTD2XX == 1
return presto_open_ftd2xx(req_serial);
#elif BUILD_PRESTO_LIBFTDI == 1
return presto_open_libftdi(req_serial); return presto_open_libftdi(req_serial);
#endif
} }
static int presto_close(void) static int presto_close(void)
@ -403,35 +222,6 @@ static int presto_close(void)
int result = ERROR_OK; int result = ERROR_OK;
#if BUILD_PRESTO_FTD2XX == 1
DWORD ftbytes;
if (presto->handle == (FT_HANDLE)INVALID_HANDLE_VALUE)
return result;
presto->status = FT_Purge(presto->handle, FT_PURGE_TX | FT_PURGE_RX);
if (presto->status != FT_OK)
result = ERROR_JTAG_DEVICE_ERROR;
presto->status = FT_Write(presto->handle,
&presto_init_seq,
sizeof(presto_init_seq),
&ftbytes);
if (presto->status != FT_OK || ftbytes != sizeof(presto_init_seq))
result = ERROR_JTAG_DEVICE_ERROR;
presto->status = FT_SetLatencyTimer(presto->handle, 16);
if (presto->status != FT_OK)
result = ERROR_JTAG_DEVICE_ERROR;
presto->status = FT_Close(presto->handle);
if (presto->status != FT_OK)
result = ERROR_JTAG_DEVICE_ERROR;
else
presto->handle = (FT_HANDLE)INVALID_HANDLE_VALUE;
#elif BUILD_PRESTO_LIBFTDI == 1
presto->retval = ftdi_write_data(&presto->ftdic, presto_init_seq, sizeof(presto_init_seq)); presto->retval = ftdi_write_data(&presto->ftdic, presto_init_seq, sizeof(presto_init_seq));
if (presto->retval != sizeof(presto_init_seq)) if (presto->retval != sizeof(presto_init_seq))
result = ERROR_JTAG_DEVICE_ERROR; result = ERROR_JTAG_DEVICE_ERROR;
@ -445,7 +235,6 @@ static int presto_close(void)
result = ERROR_JTAG_DEVICE_ERROR; result = ERROR_JTAG_DEVICE_ERROR;
else else
ftdi_deinit(&presto->ftdic); ftdi_deinit(&presto->ftdic);
#endif
return result; return result;
} }
@ -455,11 +244,7 @@ static int presto_flush(void)
if (presto->buff_out_pos == 0) if (presto->buff_out_pos == 0)
return ERROR_OK; return ERROR_OK;
#if BUILD_PRESTO_FTD2XX == 1
if (presto->status != FT_OK) {
#elif BUILD_PRESTO_LIBFTDI == 1
if (presto->retval < 0) { if (presto->retval < 0) {
#endif
LOG_DEBUG("error in previous communication, canceling I/O operation"); LOG_DEBUG("error in previous communication, canceling I/O operation");
return ERROR_JTAG_DEVICE_ERROR; return ERROR_JTAG_DEVICE_ERROR;
} }
@ -502,13 +287,9 @@ static int presto_sendbyte(int data)
} else } else
return ERROR_JTAG_DEVICE_ERROR; return ERROR_JTAG_DEVICE_ERROR;
#if BUILD_PRESTO_FTD2XX == 1
if (presto->buff_out_pos >= BUFFER_SIZE)
#elif BUILD_PRESTO_LIBFTDI == 1
/* libftdi does not do background read, be sure that USB IN buffer does not overflow (128 /* libftdi does not do background read, be sure that USB IN buffer does not overflow (128
*bytes only!) */ *bytes only!) */
if (presto->buff_out_pos >= BUFFER_SIZE || presto->buff_in_exp == 128) if (presto->buff_out_pos >= BUFFER_SIZE || presto->buff_in_exp == 128)
#endif
return presto_flush(); return presto_flush();
return ERROR_OK; return ERROR_OK;

6
src/jtag/drivers/usb_blaster/Makefile.am
View File

@ -7,14 +7,10 @@ libocdusbblaster_la_SOURCES = $(USB_BLASTER_SRC)
USB_BLASTER_SRC = usb_blaster.c USB_BLASTER_SRC = usb_blaster.c
if USB_BLASTER_LIBFTDI if USB_BLASTER
USB_BLASTER_SRC += ublast_access_ftdi.c USB_BLASTER_SRC += ublast_access_ftdi.c
endif endif
if USB_BLASTER_FTD2XX
USB_BLASTER_SRC += ublast_access_ftd2xx.c
endif
if USB_BLASTER_2 if USB_BLASTER_2
USB_BLASTER_SRC += ublast2_access_libusb.c USB_BLASTER_SRC += ublast2_access_libusb.c
endif endif

7
src/jtag/drivers/usb_blaster/ublast_access.h
View File

@ -56,19 +56,16 @@ struct ublast_lowlevel {
/** /**
* ublast_register_ftdi - get a lowlevel USB Blaster driver * ublast_register_ftdi - get a lowlevel USB Blaster driver
* ublast_register_ftd2xx - get a lowlevel USB Blaster driver
* ublast2_register_libusb - get a lowlevel USB Blaster II driver * ublast2_register_libusb - get a lowlevel USB Blaster II driver
* *
* Get a lowlevel USB-Blaster driver. In the current implementation, there are 3 * Get a lowlevel USB-Blaster driver. In the current implementation, there are 2
* possible lowlevel drivers : * possible lowlevel drivers :
* - one based on libftdi from ftdichip.com * - one based on libftdi,
* - one based on libftdxx, the free alternative
* - one based on libusb, specific to the USB-Blaster II * - one based on libusb, specific to the USB-Blaster II
* *
* Returns the lowlevel driver structure. * Returns the lowlevel driver structure.
*/ */
extern struct ublast_lowlevel *ublast_register_ftdi(void); extern struct ublast_lowlevel *ublast_register_ftdi(void);
extern struct ublast_lowlevel *ublast_register_ftd2xx(void);
extern struct ublast_lowlevel *ublast2_register_libusb(void); extern struct ublast_lowlevel *ublast2_register_libusb(void);
#endif /* OPENOCD_JTAG_DRIVERS_USB_BLASTER_UBLAST_ACCESS_H */ #endif /* OPENOCD_JTAG_DRIVERS_USB_BLASTER_UBLAST_ACCESS_H */

180
src/jtag/drivers/usb_blaster/ublast_access_ftd2xx.c
View File

@ -1,180 +0,0 @@
/*
* Driver for USB-JTAG, Altera USB-Blaster and compatibles
*
* Inspired from original code from Kolja Waschk's USB-JTAG project
* (http://www.ixo.de/info/usb_jtag/), and from openocd project.
*
* Copyright (C) 2012 Robert Jarzmik robert.jarzmik@free.fr
* Copyright (C) 2011 Ali Lown ali@lown.me.uk
* Copyright (C) 2009 Catalin Patulea cat@vv.carleton.ca
* Copyright (C) 2006 Kolja Waschk usbjtag@ixo.de
*
* This program is free software; you can redistribute it and/or modify
* it 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, see <http://www.gnu.org/licenses/>.
*
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <jtag/interface.h>
#include <jtag/commands.h>
#include "ublast_access.h"
#include <ftd2xx.h>
#include "jtag/drivers/ftd2xx_common.h"
static FT_HANDLE *ublast_getftdih(struct ublast_lowlevel *low)
{
return low->priv;
}
static int ublast_ftd2xx_write(struct ublast_lowlevel *low, uint8_t *buf, int size,
uint32_t *bytes_written)
{
FT_STATUS status;
DWORD dw_bytes_written;
FT_HANDLE *ftdih = ublast_getftdih(low);
status = FT_Write(*ftdih, buf, size, &dw_bytes_written);
if (status != FT_OK) {
*bytes_written = dw_bytes_written;
LOG_ERROR("FT_Write returned: %s", ftd2xx_status_string(status));
return ERROR_JTAG_DEVICE_ERROR;
}
*bytes_written = dw_bytes_written;
return ERROR_OK;
}
static int ublast_ftd2xx_read(struct ublast_lowlevel *low, uint8_t *buf,
unsigned size, uint32_t *bytes_read)
{
DWORD dw_bytes_read;
FT_STATUS status;
FT_HANDLE *ftdih = ublast_getftdih(low);
status = FT_Read(*ftdih, buf, size, &dw_bytes_read);
if (status != FT_OK) {
*bytes_read = dw_bytes_read;
LOG_ERROR("FT_Read returned: %s", ftd2xx_status_string(status));
return ERROR_JTAG_DEVICE_ERROR;
}
*bytes_read = dw_bytes_read;
return ERROR_OK;
}
static int ublast_ftd2xx_init(struct ublast_lowlevel *low)
{
FT_STATUS status;
FT_HANDLE *ftdih = ublast_getftdih(low);
uint8_t latency_timer;
LOG_INFO("usb blaster interface using FTD2XX");
/* Open by device description */
if (low->ublast_device_desc == NULL) {
LOG_WARNING("no usb blaster device description specified, "
"using default 'USB-Blaster'");
low->ublast_device_desc = "USB-Blaster";
}
#if IS_WIN32 == 0
/* Add non-standard Vid/Pid to the linux driver */
status = FT_SetVIDPID(low->ublast_vid, low->ublast_pid);
if (status != FT_OK) {
LOG_WARNING("couldn't add %4.4x:%4.4x",
low->ublast_vid, low->ublast_pid);
}
#endif
status = FT_OpenEx(low->ublast_device_desc, FT_OPEN_BY_DESCRIPTION,
ftdih);
if (status != FT_OK) {
DWORD num_devices;
LOG_ERROR("unable to open ftdi device: %s",
ftd2xx_status_string(status));
status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY);
if (status == FT_OK) {
char **desc_array =
malloc(sizeof(char *) * (num_devices + 1));
unsigned int i;
for (i = 0; i < num_devices; i++)
desc_array[i] = malloc(64);
desc_array[num_devices] = NULL;
status = FT_ListDevices(desc_array, &num_devices,
FT_LIST_ALL | FT_OPEN_BY_DESCRIPTION);
if (status == FT_OK) {
LOG_ERROR("ListDevices: %" PRIu32, (uint32_t)num_devices);
for (i = 0; i < num_devices; i++)
LOG_ERROR("%i: %s", i, desc_array[i]);
}
for (i = 0; i < num_devices; i++)
free(desc_array[i]);
free(desc_array);
} else {
printf("ListDevices: NONE\n");
}
return ERROR_JTAG_INIT_FAILED;
}
status = FT_SetLatencyTimer(*ftdih, 2);
if (status != FT_OK) {
LOG_ERROR("unable to set latency timer: %s",
ftd2xx_status_string(status));
return ERROR_JTAG_INIT_FAILED;
}
status = FT_GetLatencyTimer(*ftdih, &latency_timer);
if (status != FT_OK)
LOG_ERROR("unable to get latency timer: %s",
ftd2xx_status_string(status));
else
LOG_DEBUG("current latency timer: %i", latency_timer);
status = FT_SetBitMode(*ftdih, 0x00, 0);
if (status != FT_OK) {
LOG_ERROR("unable to disable bit i/o mode: %s",
ftd2xx_status_string(status));
return ERROR_JTAG_INIT_FAILED;
}
return ERROR_OK;
}
static int ublast_ftd2xx_quit(struct ublast_lowlevel *low)
{
FT_HANDLE *ftdih = ublast_getftdih(low);
FT_Close(*ftdih);
return ERROR_OK;
}
static struct ublast_lowlevel_priv {
FT_HANDLE ftdih;
} info;
static struct ublast_lowlevel low = {
.open = ublast_ftd2xx_init,
.close = ublast_ftd2xx_quit,
.read = ublast_ftd2xx_read,
.write = ublast_ftd2xx_write,
.priv = &info,
};
struct ublast_lowlevel *ublast_register_ftd2xx(void)
{
return &low;
}

9
src/jtag/drivers/usb_blaster/usb_blaster.c
View File

@ -147,12 +147,9 @@ struct drvs_map {
}; };
static struct drvs_map lowlevel_drivers_map[] = { static struct drvs_map lowlevel_drivers_map[] = {
#if BUILD_USB_BLASTER_LIBFTDI #if BUILD_USB_BLASTER
{ .name = "ftdi", .drv_register = ublast_register_ftdi }, { .name = "ftdi", .drv_register = ublast_register_ftdi },
#endif #endif
#if BUILD_USB_BLASTER_FTD2XX
{ .name = "ftd2xx", .drv_register = ublast_register_ftd2xx },
#endif
#if BUILD_USB_BLASTER_2 #if BUILD_USB_BLASTER_2
{ .name = "ublast2", .drv_register = ublast2_register_libusb }, { .name = "ublast2", .drv_register = ublast2_register_libusb },
#endif #endif
@ -1048,8 +1045,8 @@ static const struct command_registration ublast_command_handlers[] = {
.name = "usb_blaster_lowlevel_driver", .name = "usb_blaster_lowlevel_driver",
.handler = ublast_handle_lowlevel_drv_command, .handler = ublast_handle_lowlevel_drv_command,
.mode = COMMAND_CONFIG, .mode = COMMAND_CONFIG,
.help = "set the lowlevel access for the USB Blaster (ftdi, ftd2xx, ublast2)", .help = "set the lowlevel access for the USB Blaster (ftdi, ublast2)",
.usage = "(ftdi|ftd2xx|ublast2)", .usage = "(ftdi|ublast2)",
}, },
{ {
.name = "usb_blaster_pin", .name = "usb_blaster_pin",

8
src/jtag/interfaces.c
View File

@ -54,7 +54,7 @@ extern struct jtag_interface dummy_interface;
#if BUILD_FTDI == 1 #if BUILD_FTDI == 1
extern struct jtag_interface ftdi_interface; extern struct jtag_interface ftdi_interface;
#endif #endif
#if BUILD_USB_BLASTER_LIBFTDI == 1 || BUILD_USB_BLASTER_FTD2XX == 1 || BUILD_USB_BLASTER_2 == 1 #if BUILD_USB_BLASTER == 1 || BUILD_USB_BLASTER_2 == 1
extern struct jtag_interface usb_blaster_interface; extern struct jtag_interface usb_blaster_interface;
#endif #endif
#if BUILD_JTAG_VPI == 1 #if BUILD_JTAG_VPI == 1
@ -72,7 +72,7 @@ extern struct jtag_interface at91rm9200_interface;
#if BUILD_GW16012 == 1 #if BUILD_GW16012 == 1
extern struct jtag_interface gw16012_interface; extern struct jtag_interface gw16012_interface;
#endif #endif
#if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1 #if BUILD_PRESTO
extern struct jtag_interface presto_interface; extern struct jtag_interface presto_interface;
#endif #endif
#if BUILD_USBPROG == 1 #if BUILD_USBPROG == 1
@ -147,7 +147,7 @@ struct jtag_interface *jtag_interfaces[] = {
#if BUILD_FTDI == 1 #if BUILD_FTDI == 1
&ftdi_interface, &ftdi_interface,
#endif #endif
#if BUILD_USB_BLASTER_LIBFTDI == 1 || BUILD_USB_BLASTER_FTD2XX == 1 || BUILD_USB_BLASTER_2 == 1 #if BUILD_USB_BLASTER || BUILD_USB_BLASTER_2 == 1
&usb_blaster_interface, &usb_blaster_interface,
#endif #endif
#if BUILD_JTAG_VPI == 1 #if BUILD_JTAG_VPI == 1
@ -165,7 +165,7 @@ struct jtag_interface *jtag_interfaces[] = {
#if BUILD_GW16012 == 1 #if BUILD_GW16012 == 1
&gw16012_interface, &gw16012_interface,
#endif #endif
#if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1 #if BUILD_PRESTO
&presto_interface, &presto_interface,
#endif #endif
#if BUILD_USBPROG == 1 #if BUILD_USBPROG == 1

3
tcl/board/telo.cfg
View File

@ -8,9 +8,6 @@ source [find target/c100helper.tcl]
# Telo board & C100 support trst and srst # Telo board & C100 support trst and srst
# Note that libftd2xx.so tries to assert srst
# which break this script
# use libftdi.so library instead with this script
# make the reset asserted to # make the reset asserted to
# allow RC circuit to discharge for: [ms] # allow RC circuit to discharge for: [ms]
adapter_nsrst_assert_width 100 adapter_nsrst_assert_width 100

4
tcl/interface/usb-jtag.cfg
View File

@ -27,11 +27,11 @@
# #
# TODO: Refactor the usb_blaster driver to allow loading firmware using any low # TODO: Refactor the usb_blaster driver to allow loading firmware using any low
# level driver. Loading firmware is currently only supported on the ublast2 # level driver. Loading firmware is currently only supported on the ublast2
# driver but ixo-usb-jtag requires the ftdi or ftd2xx driver. # driver but ixo-usb-jtag requires the ftdi driver.
interface usb_blaster interface usb_blaster
usb_blaster_vid_pid 0x16C0 0x06AD usb_blaster_vid_pid 0x16C0 0x06AD
usb_blaster_device_desc "Van Ooijen Technische Informatica" usb_blaster_device_desc "Van Ooijen Technische Informatica"
# ixo-usb-jtag is only compatible with the ublast1 protocol implemented via the # ixo-usb-jtag is only compatible with the ublast1 protocol implemented via the
# ftdi or ftd2xx modes, using ublast2 will cause openocd to hang. # ftdi modes, using ublast2 will cause openocd to hang.
usb_blaster_lowlevel_driver ftdi usb_blaster_lowlevel_driver ftdi