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

Add FTDI JTAG driver using MPSSE layer 

Based on ft2232.c but uses the MPSSE layer for low-level access, greatly
simplifying the JTAG logic. Remove all libftdi/FTD2XX code and all layout
specific code. Layout specifications are instead handled in Tcl.

Use a signal abstraction to enable Tcl configuration files to define
outputs for one or several FTDI GPIO. These outputs can then be
controlled using the ftdi_set_signal command. Special signal names are
reserved for nTRST, nSRST and LED (for blink) so that they, if defined,
will be used for their customary purpose.

Depending on the type of buffer attached to the FTDI GPIO, the outputs
have to be controlled differently. In order to support tristateable
signals such as nSRST, both a data GPIO and an output-enable GPIO can be
specified for each signal. The following output buffer configurations are
supported:

* Push-pull with one FTDI output as (non-)inverted data line
* Open drain with one FTDI output as (non-)inverted output-enable
* Tristate with one FTDI output as (non-)inverted data line and another
  FTDI output as (non-)inverted output-enable
* Unbuffered, using the FTDI GPIO as a tristate output directly by
  switching data and direction as necessary

The data and output-enables are specified as 16-bit bitmasks,
corresponding to the concatenation of the high and low FTDI GPIO
registers. To specify an unbuffered output, use the same bitmask
for both data and output-enable.

The adapter configuration file must also specify default values for the
FTDI data and direction GPIO registers, and the channel being used (if
different from 0).

Change-Id: I287a41d4c696cf5fc74eb10d5e63578b0dc7f826
Signed-off-by: Andreas Fritiofson <andreas.fritiofson@gmail.com>
Reviewed-on: http://openocd.zylin.com/452
Tested-by: jenkins
Reviewed-by: Peter Stuge <peter@stuge.se>
__archive__
Andreas Fritiofson 2012-01-30 00:45:18 +01:00 committed by Peter Stuge
parent b598efb613
commit f5e97b5e1b
4 changed files with 889 additions and 1 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
configure.ac
View File

@ -385,6 +385,10 @@ AC_ARG_ENABLE([ft2232_ftd2xx],
AS_HELP_STRING([--enable-ft2232_ftd2xx], [Enable building support for FT2232 based devices using the FTD2XX driver from ftdichip.com]),
[build_ft2232_ftd2xx=$enableval], [build_ft2232_ftd2xx=no])
AC_ARG_ENABLE([ftdi],
AS_HELP_STRING([--enable-ftdi], [Enable building support for the MPSSE mode of FTDI based devices, using libusb-1.0 in asynchronous mode]),
[build_ftdi=$enableval], [build_ftdi=no])
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]),
[build_usb_blaster_libftdi=$enableval], [build_usb_blaster_libftdi=no])
@ -682,6 +686,12 @@ else
AC_DEFINE([BUILD_FT2232_FTD2XX], [0], [0 if you don't want ftd2xx ft2232.])
fi
if test $build_ftdi = yes; then
AC_DEFINE([BUILD_FTDI], [1], [1 if you want ftdi.])
else
AC_DEFINE([BUILD_FTDI], [0], [0 if you don't want ftdi.])
fi
if test $build_usb_blaster_libftdi = yes; then
build_bitbang=yes
AC_DEFINE([BUILD_USB_BLASTER_LIBFTDI], [1], [1 if you want libftdi usb_blaster.])
@ -1081,7 +1091,7 @@ fi
# Check for libusb1 ported drivers.
build_usb_ng=no
if test $build_jlink = yes -o $build_stlink = yes -o $build_osbdm = yes -o \
$build_opendous = yes
$build_opendous = yes -o $build_ftdi = yes
then
build_usb_ng=yes
fi
@ -1114,6 +1124,7 @@ AM_CONDITIONAL([AT91RM9200], [test $build_at91rm9200 = yes])
AM_CONDITIONAL([BITBANG], [test $build_bitbang = yes])
AM_CONDITIONAL([FT2232_LIBFTDI], [test $build_ft2232_libftdi = yes])
AM_CONDITIONAL([FT2232_DRIVER], [test $build_ft2232_ftd2xx = yes -o $build_ft2232_libftdi = yes])
AM_CONDITIONAL([FTDI_DRIVER], [test $build_ftdi = yes])
AM_CONDITIONAL([USB_BLASTER_LIBFTDI], [test $build_usb_blaster_libftdi = yes])
AM_CONDITIONAL([USB_BLASTER_DRIVER], [test $build_usb_blaster_ftd2xx = yes -o $build_usb_blaster_libftdi = yes])
AM_CONDITIONAL([AMTJTAGACCEL], [test $build_amtjtagaccel = yes])

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

@ -43,6 +43,9 @@ endif
if FT2232_DRIVER
DRIVERFILES += ft2232.c
endif
if FTDI_DRIVER
DRIVERFILES += ftdi.c mpsse.c
endif
if USB_BLASTER_DRIVER
DRIVERFILES += usb_blaster.c
endif

868
src/jtag/drivers/ftdi.c Normal file
View File

@ -0,0 +1,868 @@
/**************************************************************************
* Copyright (C) 2012 by Andreas Fritiofson *
* andreas.fritiofson@gmail.com *
* *
* 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, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
/**
* @file
* JTAG adapters based on the FT2232 full and high speed USB parts are
* popular low cost JTAG debug solutions. Many FT2232 based JTAG adapters
* are discrete, but development boards may integrate them as alternatives
* to more capable (and expensive) third party JTAG pods.
*
* JTAG uses only one of the two communications channels ("MPSSE engines")
* on these devices. Adapters based on FT4232 parts have four ports/channels
* (A/B/C/D), instead of just two (A/B).
*
* Especially on development boards integrating one of these chips (as
* opposed to discrete pods/dongles), the additional channels can be used
* for a variety of purposes, but OpenOCD only uses one channel at a time.
*
* - As a USB-to-serial adapter for the target's console UART ...
* which may be able to support ROM boot loaders that load initial
* firmware images to flash (or SRAM).
*
* - On systems which support ARM's SWD in addition to JTAG, or instead
* of it, that second port can be used for reading SWV/SWO trace data.
*
* - Additional JTAG links, e.g. to a CPLD or * FPGA.
*
* FT2232 based JTAG adapters are "dumb" not "smart", because most JTAG
* request/response interactions involve round trips over the USB link.
* A "smart" JTAG adapter has intelligence close to the scan chain, so it
* can for example poll quickly for a status change (usually taking on the
* order of microseconds not milliseconds) before beginning a queued
* transaction which require the previous one to have completed.
*
* There are dozens of adapters of this type, differing in details which
* this driver needs to understand. Those "layout" details are required
* as part of FT2232 driver configuration.
*
* This code uses information contained in the MPSSE specification which was
* found here:
* http://www.ftdichip.com/Documents/AppNotes/AN2232C-01_MPSSE_Cmnd.pdf
* Hereafter this is called the "MPSSE Spec".
*
* The datasheet for the ftdichip.com's FT2232D part is here:
* http://www.ftdichip.com/Documents/DataSheets/DS_FT2232D.pdf
*
* Also note the issue with code 0x4b (clock data to TMS) noted in
* http://developer.intra2net.com/mailarchive/html/libftdi/2009/msg00292.html
* which can affect longer JTAG state paths.
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
/* project specific includes */
#include <jtag/interface.h>
#include <transport/transport.h>
#include <helper/time_support.h>
#if IS_CYGWIN == 1
#include <windows.h>
#endif
#include <assert.h>
/* FTDI access library includes */
#include "mpsse.h"
#define JTAG_MODE (LSB_FIRST | POS_EDGE_IN | NEG_EDGE_OUT)
static char *ftdi_device_desc;
static char *ftdi_serial;
static uint8_t ftdi_channel;
#define MAX_USB_IDS 8
/* vid = pid = 0 marks the end of the list */
static uint16_t ftdi_vid[MAX_USB_IDS + 1] = { 0 };
static uint16_t ftdi_pid[MAX_USB_IDS + 1] = { 0 };
static struct mpsse_ctx *mpsse_ctx;
struct signal {
const char *name;
uint16_t data_mask;
uint16_t oe_mask;
bool invert_data;
bool invert_oe;
struct signal *next;
};
static struct signal *signals;
static uint16_t output;
static uint16_t direction;
static struct signal *find_signal_by_name(const char *name)
{
for (struct signal *sig = signals; sig; sig = sig->next) {
if (strcmp(name, sig->name) == 0)
return sig;
}
return NULL;
}
static struct signal *create_signal(const char *name)
{
struct signal **psig = &signals;
while (*psig)
psig = &(*psig)->next;
*psig = calloc(1, sizeof(**psig));
if (*psig)
(*psig)->name = strdup(name);
if ((*psig)->name == NULL) {
free(*psig);
*psig = NULL;
}
return *psig;
}
static int ftdi_set_signal(const struct signal *s, char value)
{
int retval;
bool data;
bool oe;
if (s->data_mask == 0 && s->oe_mask == 0) {
LOG_ERROR("interface doesn't provide signal '%s'", s->name);
return ERROR_FAIL;
}
switch (value) {
case '0':
data = s->invert_data;
oe = !s->invert_oe;
break;
case '1':
if (s->data_mask == 0) {
LOG_ERROR("interface can't drive '%s' high", s->name);
return ERROR_FAIL;
}
data = !s->invert_data;
oe = !s->invert_oe;
break;
case 'z':
case 'Z':
if (s->oe_mask == 0) {
LOG_ERROR("interface can't tri-state '%s'", s->name);
return ERROR_FAIL;
}
data = s->invert_data;
oe = s->invert_oe;
break;
default:
assert(0 && "invalid signal level specifier");
return ERROR_FAIL;
}
output = data ? output | s->data_mask : output & ~s->data_mask;
if (s->oe_mask == s->data_mask)
direction = oe ? output | s->oe_mask : output & ~s->oe_mask;
else
output = oe ? output | s->oe_mask : output & ~s->oe_mask;
retval = mpsse_set_data_bits_low_byte(mpsse_ctx, output & 0xff, direction & 0xff);
if (retval == ERROR_OK)
retval = mpsse_set_data_bits_high_byte(mpsse_ctx, output >> 8, direction >> 8);
if (retval != ERROR_OK) {
LOG_ERROR("couldn't initialize FTDI GPIO");
return ERROR_JTAG_INIT_FAILED;
}
return ERROR_OK;
}
/**
* Function move_to_state
* moves the TAP controller from the current state to a
* \a goal_state through a path given by tap_get_tms_path(). State transition
* logging is performed by delegation to clock_tms().
*
* @param goal_state is the destination state for the move.
*/
static int move_to_state(tap_state_t goal_state)
{
tap_state_t start_state = tap_get_state();
/* goal_state is 1/2 of a tuple/pair of states which allow convenient
lookup of the required TMS pattern to move to this state from the
start state.
*/
/* do the 2 lookups */
int tms_bits = tap_get_tms_path(start_state, goal_state);
int tms_count = tap_get_tms_path_len(start_state, goal_state);
DEBUG_JTAG_IO("start=%s goal=%s", tap_state_name(start_state), tap_state_name(goal_state));
/* Track state transitions step by step */
for (int i = 0; i < tms_count; i++)
tap_set_state(tap_state_transition(tap_get_state(), (tms_bits >> i) & 1));
return mpsse_clock_tms_cs_out(mpsse_ctx,
(uint8_t *)&tms_bits,
0,
tms_count,
false,
JTAG_MODE);
}
static int ftdi_speed(int speed)
{
int retval;
retval = mpsse_set_frequency(mpsse_ctx, speed);
if (retval < 0) {
LOG_ERROR("couldn't set FTDI TCK speed");
return retval;
}
return ERROR_OK;
}
static int ftdi_speed_div(int speed, int *khz)
{
*khz = speed / 1000;
return ERROR_OK;
}
static int ftdi_khz(int khz, int *jtag_speed)
{
*jtag_speed = khz * 1000;
return ERROR_OK;
}
static void ftdi_end_state(tap_state_t state)
{
if (tap_is_state_stable(state))
tap_set_end_state(state);
else {
LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state));
exit(-1);
}
}
static int ftdi_execute_runtest(struct jtag_command *cmd)
{
int retval = ERROR_OK;
int i;
uint8_t zero = 0;
DEBUG_JTAG_IO("runtest %i cycles, end in %s",
cmd->cmd.runtest->num_cycles,
tap_state_name(cmd->cmd.runtest->end_state));
if (tap_get_state() != TAP_IDLE)
move_to_state(TAP_IDLE);
/* TODO: Reuse ftdi_execute_stableclocks */
i = cmd->cmd.runtest->num_cycles;
while (i > 0 && retval == ERROR_OK) {
/* there are no state transitions in this code, so omit state tracking */
unsigned this_len = i > 7 ? 7 : i;
retval = mpsse_clock_tms_cs_out(mpsse_ctx, &zero, 0, this_len, false, JTAG_MODE);
i -= this_len;
}
ftdi_end_state(cmd->cmd.runtest->end_state);
if (tap_get_state() != tap_get_end_state())
move_to_state(tap_get_end_state());
DEBUG_JTAG_IO("runtest: %i, end in %s",
cmd->cmd.runtest->num_cycles,
tap_state_name(tap_get_end_state()));
return retval;
}
static int ftdi_execute_statemove(struct jtag_command *cmd)
{
int retval = ERROR_OK;
DEBUG_JTAG_IO("statemove end in %s",
tap_state_name(cmd->cmd.statemove->end_state));
ftdi_end_state(cmd->cmd.statemove->end_state);
/* shortest-path move to desired end state */
if (tap_get_state() != tap_get_end_state() || tap_get_end_state() == TAP_RESET)
move_to_state(tap_get_end_state());
return retval;
}
/**
* Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
* (or SWD) state machine. REVISIT: Not the best method, perhaps.
*/
static int ftdi_execute_tms(struct jtag_command *cmd)
{
DEBUG_JTAG_IO("TMS: %d bits", cmd->cmd.tms->num_bits);
/* TODO: Missing tap state tracking, also missing from ft2232.c! */
return mpsse_clock_tms_cs_out(mpsse_ctx,
cmd->cmd.tms->bits,
0,
cmd->cmd.tms->num_bits,
false,
JTAG_MODE);
}
static int ftdi_execute_pathmove(struct jtag_command *cmd)
{
int retval = ERROR_OK;
tap_state_t *path = cmd->cmd.pathmove->path;
int num_states = cmd->cmd.pathmove->num_states;
DEBUG_JTAG_IO("pathmove: %i states, current: %s end: %s", num_states,
tap_state_name(tap_get_state()),
tap_state_name(path[num_states-1]));
int state_count = 0;
unsigned bit_count = 0;
uint8_t tms_byte = 0;
DEBUG_JTAG_IO("-");
/* this loop verifies that the path is legal and logs each state in the path */
while (num_states-- && retval == ERROR_OK) {
/* either TMS=0 or TMS=1 must work ... */
if (tap_state_transition(tap_get_state(), false)
== path[state_count])
buf_set_u32(&tms_byte, bit_count++, 1, 0x0);
else if (tap_state_transition(tap_get_state(), true)
== path[state_count]) {
buf_set_u32(&tms_byte, bit_count++, 1, 0x1);
/* ... or else the caller goofed BADLY */
} else {
LOG_ERROR("BUG: %s -> %s isn't a valid "
"TAP state transition",
tap_state_name(tap_get_state()),
tap_state_name(path[state_count]));
exit(-1);
}
tap_set_state(path[state_count]);
state_count++;
if (bit_count == 7 || num_states == 0) {
retval = mpsse_clock_tms_cs_out(mpsse_ctx,
&tms_byte,
0,
bit_count,
false,
JTAG_MODE);
bit_count = 0;
}
}
tap_set_end_state(tap_get_state());
return retval;
}
static int ftdi_execute_scan(struct jtag_command *cmd)
{
int retval = ERROR_OK;
DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN",
jtag_scan_type(cmd->cmd.scan));
if (cmd->cmd.scan->ir_scan) {
if (tap_get_state() != TAP_IRSHIFT)
move_to_state(TAP_IRSHIFT);
} else {
if (tap_get_state() != TAP_DRSHIFT)
move_to_state(TAP_DRSHIFT);
}
ftdi_end_state(cmd->cmd.scan->end_state);
struct scan_field *field = cmd->cmd.scan->fields;
unsigned scan_size = 0;
for (int i = 0; i < cmd->cmd.scan->num_fields; i++, field++) {
scan_size += field->num_bits;
DEBUG_JTAG_IO("%s%s field %d/%d %d bits",
field->in_value ? "in" : "",
field->out_value ? "out" : "",
i,
cmd->cmd.scan->num_fields,
field->num_bits);
if (i == cmd->cmd.scan->num_fields - 1 && tap_get_state() != tap_get_end_state()) {
/* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
*movement */
mpsse_clock_data(mpsse_ctx,
field->out_value,
0,
field->in_value,
0,
field->num_bits - 1,
JTAG_MODE);
uint8_t last_bit = 0;
if (field->out_value)
bit_copy(&last_bit, 0, field->out_value, field->num_bits - 1, 1);
uint8_t tms_bits = 0x01;
retval = mpsse_clock_tms_cs(mpsse_ctx,
&tms_bits,
0,
field->in_value,
field->num_bits - 1,
1,
last_bit,
JTAG_MODE);
tap_set_state(tap_state_transition(tap_get_state(), 1));
retval = mpsse_clock_tms_cs_out(mpsse_ctx,
&tms_bits,
1,
1,
last_bit,
JTAG_MODE);
tap_set_state(tap_state_transition(tap_get_state(), 0));
} else
mpsse_clock_data(mpsse_ctx,
field->out_value,
0,
field->in_value,
0,
field->num_bits,
JTAG_MODE);
if (retval != ERROR_OK) {
LOG_ERROR("failed to add field %d in scan", i);
return retval;
}
}
if (tap_get_state() != tap_get_end_state())
move_to_state(tap_get_end_state());
DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
(cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
tap_state_name(tap_get_end_state()));
return retval;
}
static int ftdi_execute_reset(struct jtag_command *cmd)
{
DEBUG_JTAG_IO("reset trst: %i srst %i",
cmd->cmd.reset->trst, cmd->cmd.reset->srst);
if (cmd->cmd.reset->trst == 1
|| (cmd->cmd.reset->srst
&& (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
tap_set_state(TAP_RESET);
struct signal *trst = find_signal_by_name("nTRST");
if (trst && cmd->cmd.reset->trst == 1) {
ftdi_set_signal(trst, '0');
} else if (trst && cmd->cmd.reset->trst == 0) {
if (jtag_get_reset_config() & RESET_TRST_OPEN_DRAIN)
ftdi_set_signal(trst, 'z');
else
ftdi_set_signal(trst, '1');
}
struct signal *srst = find_signal_by_name("nSRST");
if (srst && cmd->cmd.reset->srst == 1) {
ftdi_set_signal(srst, '0');
} else if (srst && cmd->cmd.reset->srst == 0) {
if (jtag_get_reset_config() & RESET_SRST_PUSH_PULL)
ftdi_set_signal(srst, '1');
else
ftdi_set_signal(srst, 'z');
}
DEBUG_JTAG_IO("trst: %i, srst: %i",
cmd->cmd.reset->trst, cmd->cmd.reset->srst);
return ERROR_OK;
}
static int ftdi_execute_sleep(struct jtag_command *cmd)
{
int retval = ERROR_OK;
DEBUG_JTAG_IO("sleep %" PRIi32, cmd->cmd.sleep->us);
retval = mpsse_flush(mpsse_ctx);
jtag_sleep(cmd->cmd.sleep->us);
DEBUG_JTAG_IO("sleep %" PRIi32 " usec while in %s",
cmd->cmd.sleep->us,
tap_state_name(tap_get_state()));
return retval;
}
static int ftdi_execute_stableclocks(struct jtag_command *cmd)
{
int retval = ERROR_OK;
/* this is only allowed while in a stable state. A check for a stable
* state was done in jtag_add_clocks()
*/
int num_cycles = cmd->cmd.stableclocks->num_cycles;
/* 7 bits of either ones or zeros. */
uint8_t tms = tap_get_state() == TAP_RESET ? 0x7f : 0x00;
/* TODO: Use mpsse_clock_data with in=out=0 for this, if TMS can be set to
* the correct level and remain there during the scan */
while (num_cycles > 0 && retval == ERROR_OK) {
/* there are no state transitions in this code, so omit state tracking */
unsigned this_len = num_cycles > 7 ? 7 : num_cycles;
retval = mpsse_clock_tms_cs_out(mpsse_ctx, &tms, 0, this_len, false, JTAG_MODE);
num_cycles -= this_len;
}
DEBUG_JTAG_IO("clocks %i while in %s",
cmd->cmd.stableclocks->num_cycles,
tap_state_name(tap_get_state()));
return retval;
}
static int ftdi_execute_command(struct jtag_command *cmd)
{
int retval;
switch (cmd->type) {
case JTAG_RESET:
retval = ftdi_execute_reset(cmd);
break;
case JTAG_RUNTEST:
retval = ftdi_execute_runtest(cmd);
break;
case JTAG_TLR_RESET:
retval = ftdi_execute_statemove(cmd);
break;
case JTAG_PATHMOVE:
retval = ftdi_execute_pathmove(cmd);
break;
case JTAG_SCAN:
retval = ftdi_execute_scan(cmd);
break;
case JTAG_SLEEP:
retval = ftdi_execute_sleep(cmd);
break;
case JTAG_STABLECLOCKS:
retval = ftdi_execute_stableclocks(cmd);
break;
case JTAG_TMS:
retval = ftdi_execute_tms(cmd);
break;
default:
LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd->type);
retval = ERROR_JTAG_QUEUE_FAILED;
break;
}
return retval;
}
static int ftdi_execute_queue(void)
{
int retval = ERROR_OK;
/* blink, if the current layout has that feature */
struct signal *led = find_signal_by_name("LED");
if (led)
ftdi_set_signal(led, '1');
for (struct jtag_command *cmd = jtag_command_queue; cmd; cmd = cmd->next) {
/* fill the write buffer with the desired command */
if (ftdi_execute_command(cmd) != ERROR_OK)
retval = ERROR_JTAG_QUEUE_FAILED;
}
if (led)
ftdi_set_signal(led, '0');
retval = mpsse_flush(mpsse_ctx);
if (retval != ERROR_OK)
LOG_ERROR("error while flushing MPSSE queue: %d", retval);
return retval;
}
static int ftdi_initialize(void)
{
int retval;
if (tap_get_tms_path_len(TAP_IRPAUSE, TAP_IRPAUSE) == 7)
LOG_DEBUG("ftdi interface using 7 step jtag state transitions");
else
LOG_DEBUG("ftdi interface using shortest path jtag state transitions");
for (int i = 0; ftdi_vid[i] || ftdi_pid[i]; i++) {
mpsse_ctx = mpsse_open(&ftdi_vid[i], &ftdi_pid[i], ftdi_device_desc,
ftdi_serial, ftdi_channel);
if (mpsse_ctx)
break;
}
if (!mpsse_ctx)
return ERROR_JTAG_INIT_FAILED;
retval = mpsse_set_data_bits_low_byte(mpsse_ctx, output & 0xff, direction & 0xff);
if (retval == ERROR_OK)
retval = mpsse_set_data_bits_high_byte(mpsse_ctx, output >> 8, direction >> 8);
if (retval != ERROR_OK) {
LOG_ERROR("couldn't initialize FTDI with 'JTAGkey' layout");
return ERROR_JTAG_INIT_FAILED;
}
retval = mpsse_loopback_config(mpsse_ctx, false);
if (retval != ERROR_OK) {
LOG_ERROR("couldn't write to FTDI to disable loopback");
return ERROR_JTAG_INIT_FAILED;
}
return mpsse_flush(mpsse_ctx);
}
static int ftdi_quit(void)
{
mpsse_close(mpsse_ctx);
return ERROR_OK;
}
COMMAND_HANDLER(ftdi_handle_device_desc_command)
{
if (CMD_ARGC == 1) {
if (ftdi_device_desc)
free(ftdi_device_desc);
ftdi_device_desc = strdup(CMD_ARGV[0]);
} else {
LOG_ERROR("expected exactly one argument to ftdi_device_desc <description>");
}
return ERROR_OK;
}
COMMAND_HANDLER(ftdi_handle_serial_command)
{
if (CMD_ARGC == 1) {
if (ftdi_serial)
free(ftdi_serial);
ftdi_serial = strdup(CMD_ARGV[0]);
} else {
return ERROR_COMMAND_SYNTAX_ERROR;
}
return ERROR_OK;
}
COMMAND_HANDLER(ftdi_handle_channel_command)
{
if (CMD_ARGC == 1)
COMMAND_PARSE_NUMBER(u8, CMD_ARGV[0], ftdi_channel);
else
return ERROR_COMMAND_SYNTAX_ERROR;
return ERROR_OK;
}
COMMAND_HANDLER(ftdi_handle_layout_init_command)
{
if (CMD_ARGC != 2)
return ERROR_COMMAND_SYNTAX_ERROR;
COMMAND_PARSE_NUMBER(u16, CMD_ARGV[0], output);
COMMAND_PARSE_NUMBER(u16, CMD_ARGV[1], direction);
return ERROR_OK;
}
COMMAND_HANDLER(ftdi_handle_layout_signal_command)
{
if (CMD_ARGC < 1)
return ERROR_COMMAND_SYNTAX_ERROR;
bool invert_data = false;
uint16_t data_mask = 0;
bool invert_oe = false;
uint16_t oe_mask = 0;
for (unsigned i = 1; i < CMD_ARGC; i += 2) {
if (strcmp("-data", CMD_ARGV[i]) == 0) {
invert_data = false;
COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], data_mask);
} else if (strcmp("-ndata", CMD_ARGV[i]) == 0) {
invert_data = true;
COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], data_mask);
} else if (strcmp("-oe", CMD_ARGV[i]) == 0) {
invert_oe = false;
COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], oe_mask);
} else if (strcmp("-noe", CMD_ARGV[i]) == 0) {
invert_oe = true;
COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], oe_mask);
} else {
LOG_ERROR("unknown option '%s'", CMD_ARGV[i]);
return ERROR_COMMAND_SYNTAX_ERROR;
}
}
struct signal *sig;
sig = find_signal_by_name(CMD_ARGV[0]);
if (!sig)
sig = create_signal(CMD_ARGV[0]);
if (!sig) {
LOG_ERROR("failed to create signal %s", CMD_ARGV[0]);
return ERROR_FAIL;
}
sig->invert_data = invert_data;
sig->data_mask = data_mask;
sig->invert_oe = invert_oe;
sig->oe_mask = oe_mask;
return ERROR_OK;
}
COMMAND_HANDLER(ftdi_handle_set_signal_command)
{
if (CMD_ARGC < 2)
return ERROR_COMMAND_SYNTAX_ERROR;
struct signal *sig;
sig = find_signal_by_name(CMD_ARGV[0]);
if (!sig) {
LOG_ERROR("interface configuration doesn't define signal '%s'", CMD_ARGV[0]);
return ERROR_FAIL;
}
switch (*CMD_ARGV[1]) {
case '0':
case '1':
case 'z':
case 'Z':
/* single character level specifier only */
if (CMD_ARGV[1][1] == '\0') {
ftdi_set_signal(sig, *CMD_ARGV[1]);
break;
}
default:
LOG_ERROR("unknown signal level '%s', use 0, 1 or z", CMD_ARGV[1]);
return ERROR_COMMAND_SYNTAX_ERROR;
}
return mpsse_flush(mpsse_ctx);
}
COMMAND_HANDLER(ftdi_handle_vid_pid_command)
{
if (CMD_ARGC > MAX_USB_IDS * 2) {
LOG_WARNING("ignoring extra IDs in ftdi_vid_pid "
"(maximum is %d pairs)", MAX_USB_IDS);
CMD_ARGC = MAX_USB_IDS * 2;
}
if (CMD_ARGC < 2 || (CMD_ARGC & 1)) {
LOG_WARNING("incomplete ftdi_vid_pid configuration directive");
if (CMD_ARGC < 2)
return ERROR_COMMAND_SYNTAX_ERROR;
/* remove the incomplete trailing id */
CMD_ARGC -= 1;
}
unsigned i;
for (i = 0; i < CMD_ARGC; i += 2) {
COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i], ftdi_vid[i >> 1]);
COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], ftdi_pid[i >> 1]);
}
/*
* Explicitly terminate, in case there are multiples instances of
* ftdi_vid_pid.
*/
ftdi_vid[i >> 1] = ftdi_pid[i >> 1] = 0;
return ERROR_OK;
}
static const struct command_registration ftdi_command_handlers[] = {
{
.name = "ftdi_device_desc",
.handler = &ftdi_handle_device_desc_command,
.mode = COMMAND_CONFIG,
.help = "set the USB device description of the FTDI device",
.usage = "description_string",
},
{
.name = "ftdi_serial",
.handler = &ftdi_handle_serial_command,
.mode = COMMAND_CONFIG,
.help = "set the serial number of the FTDI device",
.usage = "serial_string",
},
{
.name = "ftdi_channel",
.handler = &ftdi_handle_channel_command,
.mode = COMMAND_CONFIG,
.help = "set the channel of the FTDI device that is used as JTAG",
.usage = "(0-3)",
},
{
.name = "ftdi_layout_init",
.handler = &ftdi_handle_layout_init_command,
.mode = COMMAND_CONFIG,
.help = "initialize the FTDI GPIO signals used "
"to control output-enables and reset signals",
.usage = "data direction",
},
{
.name = "ftdi_layout_signal",
.handler = &ftdi_handle_layout_signal_command,
.mode = COMMAND_ANY,
.help = "define a signal controlled by one or more FTDI GPIO as data "
"and/or output enable",
.usage = "name [-data mask|-ndata mask] [-oe mask|-noe mask]",
},
{
.name = "ftdi_set_signal",
.handler = &ftdi_handle_set_signal_command,
.mode = COMMAND_EXEC,
.help = "control a layout-specific signal",
.usage = "name (1|0|z)",
},
{
.name = "ftdi_vid_pid",
.handler = &ftdi_handle_vid_pid_command,
.mode = COMMAND_CONFIG,
.help = "the vendor ID and product ID of the FTDI device",
.usage = "(vid pid)* ",
},
COMMAND_REGISTRATION_DONE
};
struct jtag_interface ftdi_interface = {
.name = "ftdi",
.supported = DEBUG_CAP_TMS_SEQ,
.commands = ftdi_command_handlers,
.transports = jtag_only,
.init = ftdi_initialize,
.quit = ftdi_quit,
.speed = ftdi_speed,
.speed_div = ftdi_speed_div,
.khz = ftdi_khz,
.execute_queue = ftdi_execute_queue,
};

6
src/jtag/interfaces.c
View File

@ -59,6 +59,9 @@ extern struct jtag_interface ft2232_interface;
#if BUILD_FT2232_LIBFTDI == 1
extern struct jtag_interface ft2232_interface;
#endif
#if BUILD_FTDI == 1
extern struct jtag_interface ftdi_interface;
#endif
#if BUILD_USB_BLASTER_LIBFTDI == 1 || BUILD_USB_BLASTER_FTD2XX == 1
extern struct jtag_interface usb_blaster_interface;
#endif
@ -137,6 +140,9 @@ struct jtag_interface *jtag_interfaces[] = {
#if BUILD_FT2232_LIBFTDI == 1
&ft2232_interface,
#endif
#if BUILD_FTDI == 1
&ftdi_interface,
#endif
#if BUILD_USB_BLASTER_LIBFTDI == 1 || BUILD_USB_BLASTER_FTD2XX == 1
&usb_blaster_interface,
#endif