X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fft2232.c;h=a288b4a21372a1c15bc4d925d314c49be4ce7851;hp=52e9df17f4d05e8bca970076bc18a9d5c365c4fb;hb=f876d5e9c769a288faa7fd14b7bf373363542aab;hpb=623100d59d520fb1eb54d3a8f4c5d6933905025e diff --git a/src/jtag/ft2232.c b/src/jtag/ft2232.c index 52e9df17f4..a288b4a213 100644 --- a/src/jtag/ft2232.c +++ b/src/jtag/ft2232.c @@ -5,6 +5,9 @@ * Copyright (C) 2008 by Spencer Oliver * * spen@spen-soft.co.uk * * * +* Copyright (C) 2009 by SoftPLC Corporation. http://softplc.com * +* Dick Hollenbeck * +* * * 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 * @@ -26,6 +29,9 @@ * 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 */ @@ -33,23 +39,22 @@ #include "config.h" #endif +/* project specific includes */ +#include "interface.h" +#include "commands.h" +#include "time_support.h" + #if IS_CYGWIN == 1 -#include "windows.h" +#include #endif -#include "replacements.h" +#include -/* project specific includes */ -#include "log.h" -#include "types.h" -#include "jtag.h" -#include "configuration.h" -#include "time_support.h" - -/* system includes */ -#include -#include -#include +#if (BUILD_FT2232_FTD2XX==1 && BUILD_FT2232_LIBFTDI==1) +#error "BUILD_FT2232_FTD2XX && BUILD_FT2232_LIBFTDI are mutually exclusive" +#elif (BUILD_FT2232_FTD2XX!=1 && BUILD_FT2232_LIBFTDI!=1) +#error "BUILD_FT2232_FTD2XX || BUILD_FT2232_LIBFTDI must be chosen" +#endif /* FT2232 access library includes */ #if BUILD_FT2232_FTD2XX == 1 @@ -58,54 +63,52 @@ #include #endif -/* enable this to debug io latency - */ -#if 0 -#define _DEBUG_USB_IO_ -#endif +/* max TCK for the high speed devices 30000 kHz */ +#define FTDI_2232H_4232H_MAX_TCK 30000 -/* enable this to debug communication - */ -#if 0 -#define _DEBUG_USB_COMMS_ -#endif +static int ft2232_execute_queue(void); -int ft2232_execute_queue(void); +static int ft2232_speed(int speed); +static int ft2232_speed_div(int speed, int* khz); +static int ft2232_khz(int khz, int* jtag_speed); +static int ft2232_register_commands(struct command_context_s* cmd_ctx); +static int ft2232_init(void); +static int ft2232_quit(void); -int ft2232_speed(int speed); -int ft2232_speed_div(int speed, int* khz); -int ft2232_khz(int khz, int* jtag_speed); -int ft2232_register_commands(struct command_context_s* cmd_ctx); -int ft2232_init(void); -int ft2232_quit(void); - -int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc); -int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc); -int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc); -int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc); -int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc); +static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc); +static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc); +static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc); +static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc); +static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc); /** - * Function ft2232_stableclocks - * will send out \a num_cycles on the TCK line while the TAP(s) - * are in a stable state. Calling code must ensure that current state is - * stable, that verification is not done in here. - * @param num_cycles is the count of clocks cycles to send. - * @return int - ERROR_OK or ERROR_JTAG_QUEUE_FAILED + * Send out \a num_cycles on the TCK line while the TAP(s) are in a + * stable state. Calling code must ensure that current state is stable, + * that verification is not done in here. + * + * @param num_cycles The number of clocks cycles to send. + * @param cmd The command to send. + * + * @returns ERROR_OK on success, or ERROR_JTAG_QUEUE_FAILED on failure. */ static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd); +/* max TCK for the high speed devices 30000 kHz */ +#define FTDI_2232H_4232H_MAX_TCK 30000 + +static char * ft2232_device_desc_A = NULL; +static char* ft2232_device_desc = NULL; +static char* ft2232_serial = NULL; +static char* ft2232_layout = NULL; +static uint8_t ft2232_latency = 2; +static unsigned ft2232_max_tck = 6000; -char* ft2232_device_desc = NULL; -char* ft2232_serial = NULL; -char* ft2232_layout = NULL; -unsigned char ft2232_latency = 2; #define MAX_USB_IDS 8 /* vid = pid = 0 marks the end of the list */ -static u16 ft2232_vid[MAX_USB_IDS + 1] = { 0x0403, 0 }; -static u16 ft2232_pid[MAX_USB_IDS + 1] = { 0x6010, 0 }; +static uint16_t ft2232_vid[MAX_USB_IDS + 1] = { 0x0403, 0 }; +static uint16_t ft2232_pid[MAX_USB_IDS + 1] = { 0x6010, 0 }; typedef struct ft2232_layout_s { @@ -116,33 +119,36 @@ typedef struct ft2232_layout_s } ft2232_layout_t; /* init procedures for supported layouts */ -int usbjtag_init(void); -int jtagkey_init(void); -int olimex_jtag_init(void); -int flyswatter_init(void); -int turtle_init(void); -int comstick_init(void); -int stm32stick_init(void); -int axm0432_jtag_init(void); -int sheevaplug_init(void); +static int usbjtag_init(void); +static int jtagkey_init(void); +static int olimex_jtag_init(void); +static int flyswatter_init(void); +static int turtle_init(void); +static int comstick_init(void); +static int stm32stick_init(void); +static int axm0432_jtag_init(void); +static int sheevaplug_init(void); +static int icebear_jtag_init(void); +static int cortino_jtag_init(void); /* reset procedures for supported layouts */ -void usbjtag_reset(int trst, int srst); -void jtagkey_reset(int trst, int srst); -void olimex_jtag_reset(int trst, int srst); -void flyswatter_reset(int trst, int srst); -void turtle_reset(int trst, int srst); -void comstick_reset(int trst, int srst); -void stm32stick_reset(int trst, int srst); -void axm0432_jtag_reset(int trst, int srst); -void sheevaplug_reset(int trst, int srst); +static void usbjtag_reset(int trst, int srst); +static void jtagkey_reset(int trst, int srst); +static void olimex_jtag_reset(int trst, int srst); +static void flyswatter_reset(int trst, int srst); +static void turtle_reset(int trst, int srst); +static void comstick_reset(int trst, int srst); +static void stm32stick_reset(int trst, int srst); +static void axm0432_jtag_reset(int trst, int srst); +static void sheevaplug_reset(int trst, int srst); +static void icebear_jtag_reset(int trst, int srst); /* blink procedures for layouts that support a blinking led */ -void olimex_jtag_blink(void); -void flyswatter_jtag_blink(void); -void turtle_jtag_blink(void); +static void olimex_jtag_blink(void); +static void flyswatter_jtag_blink(void); +static void turtle_jtag_blink(void); -ft2232_layout_t ft2232_layouts[] = +static const ft2232_layout_t ft2232_layouts[] = { { "usbjtag", usbjtag_init, usbjtag_reset, NULL }, { "jtagkey", jtagkey_init, jtagkey_reset, NULL }, @@ -156,20 +162,23 @@ ft2232_layout_t ft2232_layouts[] = { "comstick", comstick_init, comstick_reset, NULL }, { "stm32stick", stm32stick_init, stm32stick_reset, NULL }, { "axm0432_jtag", axm0432_jtag_init, axm0432_jtag_reset, NULL }, - {"sheevaplug", sheevaplug_init, sheevaplug_reset, NULL }, - { NULL, NULL, NULL }, + { "sheevaplug", sheevaplug_init, sheevaplug_reset, NULL }, + { "icebear", icebear_jtag_init, icebear_jtag_reset, NULL }, + { "cortino", cortino_jtag_init, comstick_reset, NULL }, + { NULL, NULL, NULL, NULL }, }; -static u8 nTRST, nTRSTnOE, nSRST, nSRSTnOE; +static uint8_t nTRST, nTRSTnOE, nSRST, nSRSTnOE; -static ft2232_layout_t* layout; -static u8 low_output = 0x0; -static u8 low_direction = 0x0; -static u8 high_output = 0x0; -static u8 high_direction = 0x0; +static const ft2232_layout_t *layout; +static uint8_t low_output = 0x0; +static uint8_t low_direction = 0x0; +static uint8_t high_output = 0x0; +static uint8_t high_direction = 0x0; #if BUILD_FT2232_FTD2XX == 1 -static FT_HANDLE ftdih = NULL; +static FT_HANDLE ftdih = NULL; +static FT_DEVICE ftdi_device = 0; #elif BUILD_FT2232_LIBFTDI == 1 static struct ftdi_context ftdic; #endif @@ -178,33 +187,163 @@ static struct ftdi_context ftdic; static jtag_command_t* first_unsent; /* next command that has to be sent */ static int require_send; -static u8* ft2232_buffer = NULL; + +/* http://urjtag.wiki.sourceforge.net/Cable+FT2232 says: + + "There is a significant difference between libftdi and libftd2xx. The latter + one allows to schedule up to 64*64 bytes of result data while libftdi fails + with more than 4*64. As a consequence, the FT2232 driver is forced to + perform around 16x more USB transactions for long command streams with TDO + capture when running with libftdi." + + No idea how we get + #define FT2232_BUFFER_SIZE 131072 + a comment would have been nice. +*/ + +#define FT2232_BUFFER_SIZE 131072 + +static uint8_t* ft2232_buffer = NULL; static int ft2232_buffer_size = 0; static int ft2232_read_pointer = 0; static int ft2232_expect_read = 0; -#define FT2232_BUFFER_SIZE 131072 -#define BUFFER_ADD ft2232_buffer[ft2232_buffer_size++] -#define BUFFER_READ ft2232_buffer[ft2232_read_pointer++] +/** + * Function buffer_write + * writes a byte into the byte buffer, "ft2232_buffer", which must be sent later. + * @param val is the byte to send. + */ +static inline void buffer_write(uint8_t val) +{ + assert(ft2232_buffer); + assert((unsigned) ft2232_buffer_size < (unsigned) FT2232_BUFFER_SIZE); + ft2232_buffer[ft2232_buffer_size++] = val; +} + +/** + * Function buffer_read + * returns a byte from the byte buffer. + */ +static inline uint8_t buffer_read(void) +{ + assert(ft2232_buffer); + assert(ft2232_read_pointer < ft2232_buffer_size); + return ft2232_buffer[ft2232_read_pointer++]; +} + + +/** + * Clocks out \a bit_count bits on the TMS line, starting with the least + * significant bit of tms_bits and progressing to more significant bits. + * Rigorous state transition logging is done here via tap_set_state(). + * + * @param mpsse_cmd One of the MPSSE TMS oriented commands such as + * 0x4b or 0x6b. See the MPSSE spec referenced above for their + * functionality. The MPSSE command "Clock Data to TMS/CS Pin (no Read)" + * is often used for this, 0x4b. + * + * @param tms_bits Holds the sequence of bits to send. + * @param tms_count Tells how many bits in the sequence. + * @param tdi_bit A single bit to pass on to TDI before the first TCK + * cycle and held static for the duration of TMS clocking. + * + * See the MPSSE spec referenced above. + */ +static void clock_tms(uint8_t mpsse_cmd, int tms_bits, int tms_count, bool tdi_bit) +{ + uint8_t tms_byte; + int i; + int tms_ndx; /* bit index into tms_byte */ + + assert(tms_count > 0); + +// LOG_DEBUG("mpsse cmd=%02x, tms_bits=0x%08x, bit_count=%d", mpsse_cmd, tms_bits, tms_count); + + for (tms_byte = tms_ndx = i = 0; i < tms_count; ++i, tms_bits>>=1) + { + bool bit = tms_bits & 1; + + if (bit) + tms_byte |= (1<> 8) & 0xff; /* valueH */ LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( retval = ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if (((retval = ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { LOG_ERROR("couldn't set FT2232 TCK speed"); return retval; @@ -301,24 +482,31 @@ int ft2232_speed(int speed) } -int ft2232_speed_div(int speed, int* khz) +static int ft2232_speed_div(int speed, int* khz) { /* Take a look in the FT2232 manual, * AN2232C-01 Command Processor for * MPSSE and MCU Host Bus. Chapter 3.8 */ - *khz = 6000 / (1 + speed); + *khz = ft2232_max_tck / (1 + speed); return ERROR_OK; } -int ft2232_khz(int khz, int* jtag_speed) +static int ft2232_khz(int khz, int* jtag_speed) { if (khz==0) { - LOG_ERROR("RCLK not supported"); +#ifdef BUILD_FTD2XX_HIGHSPEED + *jtag_speed = 0; + return ERROR_OK; +#else + LOG_DEBUG("RCLK not supported"); + LOG_DEBUG("If you have a high-speed FTDI device, then " + "OpenOCD may be built with --enable-ftd2xx-highspeed."); return ERROR_FAIL; +#endif } /* Take a look in the FT2232 manual, @@ -328,9 +516,9 @@ int ft2232_khz(int khz, int* jtag_speed) * We will calc here with a multiplier * of 10 for better rounding later. */ - /* Calc speed, (6000 / khz) - 1 */ + /* Calc speed, (ft2232_max_tck / khz) - 1 */ /* Use 65000 for better rounding */ - *jtag_speed = (60000 / khz) - 10; + *jtag_speed = ((ft2232_max_tck*10) / khz) - 10; /* Add 0.9 for rounding */ *jtag_speed += 9; @@ -354,7 +542,7 @@ int ft2232_khz(int khz, int* jtag_speed) } -int ft2232_register_commands(struct command_context_s* cmd_ctx) +static int ft2232_register_commands(struct command_context_s* cmd_ctx) { register_command(cmd_ctx, NULL, "ft2232_device_desc", ft2232_handle_device_desc_command, COMMAND_CONFIG, "the USB device description of the FTDI FT2232 device"); @@ -370,19 +558,18 @@ int ft2232_register_commands(struct command_context_s* cmd_ctx) } -void ft2232_end_state(tap_state_t state) +static void ft2232_end_state(tap_state_t state) { if (tap_is_state_stable(state)) tap_set_end_state(state); else { - LOG_ERROR("BUG: %i is not a valid end state", state); + LOG_ERROR("BUG: %s is not a stable end state", tap_state_name(state)); exit(-1); } } - -void ft2232_read_scan(enum scan_type type, u8* buffer, int scan_size) +static void ft2232_read_scan(enum scan_type type, uint8_t* buffer, int scan_size) { int num_bytes = (scan_size + 7) / 8; int bits_left = scan_size; @@ -390,23 +577,23 @@ void ft2232_read_scan(enum scan_type type, u8* buffer, int scan_size) while (num_bytes-- > 1) { - buffer[cur_byte] = BUFFER_READ; - cur_byte++; + buffer[cur_byte++] = buffer_read(); bits_left -= 8; } buffer[cur_byte] = 0x0; + /* There is one more partial byte left from the clock data in/out instructions */ if (bits_left > 1) { - buffer[cur_byte] = BUFFER_READ >> 1; + buffer[cur_byte] = buffer_read() >> 1; } - - buffer[cur_byte] = ( buffer[cur_byte] | ( (BUFFER_READ & 0x02) << 6 ) ) >> (8 - bits_left); + /* This shift depends on the length of the clock data to tms instruction, insterted at end of the scan, now fixed to a two step transition in ft2232_add_scan */ + buffer[cur_byte] = (buffer[cur_byte] | (((buffer_read()) << 1) & 0x80)) >> (8 - bits_left); } -void ft2232_debug_dump_buffer(void) +static void ft2232_debug_dump_buffer(void) { int i; char line[256]; @@ -427,15 +614,15 @@ void ft2232_debug_dump_buffer(void) } -int ft2232_send_and_recv(jtag_command_t* first, jtag_command_t* last) +static int ft2232_send_and_recv(jtag_command_t* first, jtag_command_t* last) { jtag_command_t* cmd; - u8* buffer; + uint8_t* buffer; int scan_size; enum scan_type type; int retval; - u32 bytes_written; - u32 bytes_read; + u32 bytes_written=0; + u32 bytes_read=0; #ifdef _DEBUG_USB_IO_ struct timeval start, inter, inter2, end; @@ -451,7 +638,7 @@ int ft2232_send_and_recv(jtag_command_t* first, jtag_command_t* last) gettimeofday(&start, NULL); #endif - if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK ) + if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK) { LOG_ERROR("couldn't write MPSSE commands to FT2232"); return retval; @@ -470,7 +657,7 @@ int ft2232_send_and_recv(jtag_command_t* first, jtag_command_t* last) gettimeofday(&inter2, NULL); #endif - if ( ( retval = ft2232_read(ft2232_buffer, ft2232_expect_read, &bytes_read) ) != ERROR_OK ) + if ((retval = ft2232_read(ft2232_buffer, ft2232_expect_read, &bytes_read)) != ERROR_OK) { LOG_ERROR("couldn't read from FT2232"); return retval; @@ -483,9 +670,10 @@ int ft2232_send_and_recv(jtag_command_t* first, jtag_command_t* last) timeval_subtract(&d_inter2, &inter2, &start); timeval_subtract(&d_end, &end, &start); - LOG_INFO("inter: %i.%06i, inter2: %i.%06i end: %i.%06i", d_inter.tv_sec, d_inter.tv_usec, d_inter2.tv_sec, - d_inter2.tv_usec, d_end.tv_sec, - d_end.tv_usec); + LOG_INFO("inter: %u.%06u, inter2: %u.%06u end: %u.%06u", + (unsigned)d_inter.tv_sec, (unsigned)d_inter.tv_usec, + (unsigned)d_inter2.tv_sec, (unsigned)d_inter2.tv_usec, + (unsigned)d_end.tv_sec, (unsigned)d_end.tv_usec); #endif ft2232_buffer_size = bytes_read; @@ -545,77 +733,68 @@ int ft2232_send_and_recv(jtag_command_t* first, jtag_command_t* last) } -void ft2232_add_pathmove(pathmove_command_t* cmd) +/** + * Function ft2232_add_pathmove + * moves the TAP controller from the current state to a new state through the + * given path, where path is an array of tap_state_t's. + * + * @param path is an array of tap_stat_t which gives the states to traverse through + * ending with the last state at path[num_states-1] + * @param num_states is the count of state steps to move through + */ +static void ft2232_add_pathmove(tap_state_t* path, int num_states) { - int num_states = cmd->num_states; - int state_count = 0; - - while (num_states) - { - u8 tms_byte = 0; /* zero this on each MPSSE batch */ - - int bit_count = 0; + int tms_bits = 0; + int state_ndx; + tap_state_t walker = tap_get_state(); - int num_states_batch = num_states > 7 ? 7 : num_states; + assert((unsigned) num_states <= 32u); /* tms_bits only holds 32 bits */ - /* command "Clock Data to TMS/CS Pin (no Read)" */ - BUFFER_ADD = 0x4b; - - /* number of states remaining */ - BUFFER_ADD = num_states_batch - 1; + /* this loop verifies that the path is legal and logs each state in the path */ + for (state_ndx = 0; state_ndx < num_states; ++state_ndx) + { + tap_state_t desired_next_state = path[state_ndx]; - while (num_states_batch--) + if (tap_state_transition(walker, false) == desired_next_state) + ; /* bit within tms_bits at index state_ndx is already zero */ + else if (tap_state_transition(walker, true) == desired_next_state) + tms_bits |= (1<path[state_count]) - buf_set_u32(&tms_byte, bit_count++, 1, 0x0); - else if (tap_state_transition(tap_get_state(), true) == cmd->path[state_count]) - buf_set_u32(&tms_byte, bit_count++, 1, 0x1); - else - { - LOG_ERROR( "BUG: %s -> %s isn't a valid TAP transition", tap_state_name( - tap_get_state() ), tap_state_name(cmd->path[state_count]) ); - exit(-1); - } - - tap_set_state(cmd->path[state_count]); - state_count++; - num_states--; + LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", + tap_state_name(walker), tap_state_name(desired_next_state)); + exit(-1); } - BUFFER_ADD = tms_byte; + walker = desired_next_state; } - + + clock_tms(0x4b, tms_bits, num_states, 0); + tap_set_end_state(tap_get_state()); } -void ft2232_add_scan(int ir_scan, enum scan_type type, u8* buffer, int scan_size) +static void ft2232_add_scan(bool ir_scan, enum scan_type type, uint8_t* buffer, int scan_size) { int num_bytes = (scan_size + 7) / 8; int bits_left = scan_size; int cur_byte = 0; int last_bit; - if ( !( ( !ir_scan && (tap_get_state() == TAP_DRSHIFT) ) - || ( ir_scan && (tap_get_state() == TAP_IRSHIFT) ) ) ) + if (!ir_scan) { - /* command "Clock Data to TMS/CS Pin (no Read)" */ - BUFFER_ADD = 0x4b; - - BUFFER_ADD = 0x6; /* scan 7 bits */ - - /* TMS data bits */ - if (ir_scan) + if (tap_get_state() != TAP_DRSHIFT) { - BUFFER_ADD = tap_get_tms_path(tap_get_state(), TAP_IRSHIFT); - tap_set_state(TAP_IRSHIFT); + move_to_state(TAP_DRSHIFT); } - else + } + else + { + if (tap_get_state() != TAP_IRSHIFT) { - BUFFER_ADD = tap_get_tms_path(tap_get_state(), TAP_DRSHIFT); - tap_set_state(TAP_DRSHIFT); + move_to_state(TAP_IRSHIFT); } - /* LOG_DEBUG("added TMS scan (no read)"); */ } /* add command for complete bytes */ @@ -625,34 +804,34 @@ void ft2232_add_scan(int ir_scan, enum scan_type type, u8* buffer, int scan_size if (type == SCAN_IO) { /* Clock Data Bytes In and Out LSB First */ - BUFFER_ADD = 0x39; + buffer_write(0x39); /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */ } else if (type == SCAN_OUT) { /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */ - BUFFER_ADD = 0x19; + buffer_write(0x19); /* LOG_DEBUG("added TDI bytes (o)"); */ } else if (type == SCAN_IN) { /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */ - BUFFER_ADD = 0x28; + buffer_write(0x28); /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */ } thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1); num_bytes -= thisrun_bytes; - BUFFER_ADD = (thisrun_bytes - 1) & 0xff; - BUFFER_ADD = ( (thisrun_bytes - 1) >> 8 ) & 0xff; + + buffer_write((uint8_t) (thisrun_bytes - 1)); + buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8)); if (type != SCAN_IN) { /* add complete bytes */ while (thisrun_bytes-- > 0) { - BUFFER_ADD = buffer[cur_byte]; - cur_byte++; + buffer_write(buffer[cur_byte++]); bits_left -= 8; } } @@ -664,7 +843,7 @@ void ft2232_add_scan(int ir_scan, enum scan_type type, u8* buffer, int scan_size /* the most signifcant bit is scanned during TAP movement */ if (type != SCAN_IN) - last_bit = ( buffer[cur_byte] >> (bits_left - 1) ) & 0x1; + last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1; else last_bit = 0; @@ -674,81 +853,95 @@ void ft2232_add_scan(int ir_scan, enum scan_type type, u8* buffer, int scan_size if (type == SCAN_IO) { /* Clock Data Bits In and Out LSB First */ - BUFFER_ADD = 0x3b; + buffer_write(0x3b); /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */ } else if (type == SCAN_OUT) { /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */ - BUFFER_ADD = 0x1b; + buffer_write(0x1b); /* LOG_DEBUG("added TDI bits (o)"); */ } else if (type == SCAN_IN) { /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */ - BUFFER_ADD = 0x2a; + buffer_write(0x2a); /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */ } - BUFFER_ADD = bits_left - 2; + + buffer_write(bits_left - 2); if (type != SCAN_IN) - BUFFER_ADD = buffer[cur_byte]; + buffer_write(buffer[cur_byte]); } - if ( ( ir_scan && (tap_get_end_state() == TAP_IRSHIFT) ) - || ( !ir_scan && (tap_get_end_state() == TAP_DRSHIFT) ) ) + if (( ir_scan && (tap_get_end_state() == TAP_IRSHIFT)) + || (!ir_scan && (tap_get_end_state() == TAP_DRSHIFT))) { if (type == SCAN_IO) { /* Clock Data Bits In and Out LSB First */ - BUFFER_ADD = 0x3b; + buffer_write(0x3b); /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */ } else if (type == SCAN_OUT) { /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */ - BUFFER_ADD = 0x1b; + buffer_write(0x1b); /* LOG_DEBUG("added TDI bits (o)"); */ } else if (type == SCAN_IN) { /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */ - BUFFER_ADD = 0x2a; + buffer_write(0x2a); /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */ } - BUFFER_ADD = 0x0; - BUFFER_ADD = last_bit; + buffer_write(0x0); + buffer_write(last_bit); } else { + int tms_bits; + int tms_count; + uint8_t mpsse_cmd; + /* move from Shift-IR/DR to end state */ if (type != SCAN_OUT) { + /* We always go to the PAUSE state in two step at the end of an IN or IO scan */ + /* This must be coordinated with the bit shifts in ft2232_read_scan */ + tms_bits = 0x01; + tms_count = 2; /* Clock Data to TMS/CS Pin with Read */ - BUFFER_ADD = 0x6b; + mpsse_cmd = 0x6b; /* LOG_DEBUG("added TMS scan (read)"); */ } else { + tms_bits = tap_get_tms_path(tap_get_state(), tap_get_end_state()); + tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state()); /* Clock Data to TMS/CS Pin (no Read) */ - BUFFER_ADD = 0x4b; + mpsse_cmd = 0x4b; /* LOG_DEBUG("added TMS scan (no read)"); */ } - BUFFER_ADD = 0x6; /* scan 7 bits */ - BUFFER_ADD = tap_get_tms_path( tap_get_state(), tap_get_end_state() ) | (last_bit << 7); - tap_set_state( tap_get_end_state() ); + clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit); + } + + if (tap_get_state() != tap_get_end_state()) + { + move_to_state(tap_get_end_state()); } } -int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, u8* buffer, int scan_size) +static int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, uint8_t* buffer, int scan_size) { int num_bytes = (scan_size + 7) / 8; int bits_left = scan_size; int cur_byte = 0; int last_bit; - u8* receive_buffer = malloc( CEIL(scan_size, 8) ); - u8* receive_pointer = receive_buffer; + uint8_t* receive_buffer = malloc(CEIL(scan_size, 8)); + uint8_t* receive_pointer = receive_buffer; u32 bytes_written; u32 bytes_read; int retval; @@ -762,17 +955,10 @@ int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, u8* buffer, int if (tap_get_state() != TAP_DRSHIFT) { - /* command "Clock Data to TMS/CS Pin (no Read)" */ - BUFFER_ADD = 0x4b; - - BUFFER_ADD = 0x6; /* scan 7 bits */ - - /* TMS data bits */ - BUFFER_ADD = tap_get_tms_path(tap_get_state(), TAP_DRSHIFT); - tap_set_state(TAP_DRSHIFT); + move_to_state(TAP_DRSHIFT); } - if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK ) + if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK) { LOG_ERROR("couldn't write MPSSE commands to FT2232"); exit(-1); @@ -788,34 +974,34 @@ int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, u8* buffer, int if (type == SCAN_IO) { /* Clock Data Bytes In and Out LSB First */ - BUFFER_ADD = 0x39; + buffer_write(0x39); /* LOG_DEBUG("added TDI bytes (io %i)", num_bytes); */ } else if (type == SCAN_OUT) { /* Clock Data Bytes Out on -ve Clock Edge LSB First (no Read) */ - BUFFER_ADD = 0x19; + buffer_write(0x19); /* LOG_DEBUG("added TDI bytes (o)"); */ } else if (type == SCAN_IN) { /* Clock Data Bytes In on +ve Clock Edge LSB First (no Write) */ - BUFFER_ADD = 0x28; + buffer_write(0x28); /* LOG_DEBUG("added TDI bytes (i %i)", num_bytes); */ } thisrun_bytes = (num_bytes > 65537) ? 65536 : (num_bytes - 1); thisrun_read = thisrun_bytes; num_bytes -= thisrun_bytes; - BUFFER_ADD = (thisrun_bytes - 1) & 0xff; - BUFFER_ADD = ( (thisrun_bytes - 1) >> 8 ) & 0xff; + buffer_write((uint8_t) (thisrun_bytes - 1)); + buffer_write((uint8_t) ((thisrun_bytes - 1) >> 8)); if (type != SCAN_IN) { /* add complete bytes */ while (thisrun_bytes-- > 0) { - BUFFER_ADD = buffer[cur_byte]; + buffer_write(buffer[cur_byte]); cur_byte++; bits_left -= 8; } @@ -825,7 +1011,7 @@ int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, u8* buffer, int bits_left -= 8 * (thisrun_bytes); } - if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK ) + if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK) { LOG_ERROR("couldn't write MPSSE commands to FT2232"); exit(-1); @@ -835,7 +1021,7 @@ int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, u8* buffer, int if (type != SCAN_OUT) { - if ( ( retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read) ) != ERROR_OK ) + if ((retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read)) != ERROR_OK) { LOG_ERROR("couldn't read from FT2232"); exit(-1); @@ -849,7 +1035,7 @@ int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, u8* buffer, int /* the most signifcant bit is scanned during TAP movement */ if (type != SCAN_IN) - last_bit = ( buffer[cur_byte] >> (bits_left - 1) ) & 0x1; + last_bit = (buffer[cur_byte] >> (bits_left - 1)) & 0x1; else last_bit = 0; @@ -859,24 +1045,24 @@ int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, u8* buffer, int if (type == SCAN_IO) { /* Clock Data Bits In and Out LSB First */ - BUFFER_ADD = 0x3b; + buffer_write(0x3b); /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */ } else if (type == SCAN_OUT) { /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */ - BUFFER_ADD = 0x1b; + buffer_write(0x1b); /* LOG_DEBUG("added TDI bits (o)"); */ } else if (type == SCAN_IN) { /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */ - BUFFER_ADD = 0x2a; + buffer_write(0x2a); /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */ } - BUFFER_ADD = bits_left - 2; + buffer_write(bits_left - 2); if (type != SCAN_IN) - BUFFER_ADD = buffer[cur_byte]; + buffer_write(buffer[cur_byte]); if (type != SCAN_OUT) thisrun_read += 2; @@ -887,48 +1073,51 @@ int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, u8* buffer, int if (type == SCAN_IO) { /* Clock Data Bits In and Out LSB First */ - BUFFER_ADD = 0x3b; + buffer_write(0x3b); /* LOG_DEBUG("added TDI bits (io) %i", bits_left - 1); */ } else if (type == SCAN_OUT) { /* Clock Data Bits Out on -ve Clock Edge LSB First (no Read) */ - BUFFER_ADD = 0x1b; + buffer_write(0x1b); /* LOG_DEBUG("added TDI bits (o)"); */ } else if (type == SCAN_IN) { /* Clock Data Bits In on +ve Clock Edge LSB First (no Write) */ - BUFFER_ADD = 0x2a; + buffer_write(0x2a); /* LOG_DEBUG("added TDI bits (i %i)", bits_left - 1); */ } - BUFFER_ADD = 0x0; - BUFFER_ADD = last_bit; + buffer_write(0x0); + buffer_write(last_bit); } else { + int tms_bits = tap_get_tms_path(tap_get_state(), tap_get_end_state()); + int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state()); + uint8_t mpsse_cmd; + /* move from Shift-IR/DR to end state */ if (type != SCAN_OUT) { /* Clock Data to TMS/CS Pin with Read */ - BUFFER_ADD = 0x6b; + mpsse_cmd = 0x6b; /* LOG_DEBUG("added TMS scan (read)"); */ } else { /* Clock Data to TMS/CS Pin (no Read) */ - BUFFER_ADD = 0x4b; + mpsse_cmd = 0x4b; /* LOG_DEBUG("added TMS scan (no read)"); */ } - BUFFER_ADD = 0x6; - BUFFER_ADD = tap_get_tms_path( tap_get_state(), tap_get_end_state() ) | (last_bit << 7); - tap_set_state( tap_get_end_state() ); + + clock_tms(mpsse_cmd, tms_bits, tms_count, last_bit); } if (type != SCAN_OUT) thisrun_read += 1; - if ( ( retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written) ) != ERROR_OK ) + if ((retval = ft2232_write(ft2232_buffer, ft2232_buffer_size, &bytes_written)) != ERROR_OK) { LOG_ERROR("couldn't write MPSSE commands to FT2232"); exit(-1); @@ -938,7 +1127,7 @@ int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, u8* buffer, int if (type != SCAN_OUT) { - if ( ( retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read) ) != ERROR_OK ) + if ((retval = ft2232_read(receive_pointer, thisrun_read, &bytes_read)) != ERROR_OK) { LOG_ERROR("couldn't read from FT2232"); exit(-1); @@ -951,34 +1140,36 @@ int ft2232_large_scan(scan_command_t* cmd, enum scan_type type, u8* buffer, int } -int ft2232_predict_scan_out(int scan_size, enum scan_type type) +static int ft2232_predict_scan_out(int scan_size, enum scan_type type) { int predicted_size = 3; int num_bytes = (scan_size - 1) / 8; if (tap_get_state() != TAP_DRSHIFT) - predicted_size += 3; + predicted_size += get_tms_buffer_requirements(tap_get_tms_path_len(tap_get_state(), TAP_DRSHIFT)); if (type == SCAN_IN) /* only from device to host */ { /* complete bytes */ predicted_size += CEIL(num_bytes, 65536) * 3; + /* remaining bits - 1 (up to 7) */ - predicted_size += ( (scan_size - 1) % 8 ) ? 2 : 0; + predicted_size += ((scan_size - 1) % 8) ? 2 : 0; } else /* host to device, or bidirectional */ { /* complete bytes */ predicted_size += num_bytes + CEIL(num_bytes, 65536) * 3; + /* remaining bits -1 (up to 7) */ - predicted_size += ( (scan_size - 1) % 8 ) ? 3 : 0; + predicted_size += ((scan_size - 1) % 8) ? 3 : 0; } return predicted_size; } -int ft2232_predict_scan_in(int scan_size, enum scan_type type) +static int ft2232_predict_scan_in(int scan_size, enum scan_type type) { int predicted_size = 0; @@ -988,7 +1179,7 @@ int ft2232_predict_scan_in(int scan_size, enum scan_type type) predicted_size += (CEIL(scan_size, 8) > 1) ? (CEIL(scan_size, 8) - 1) : 0; /* remaining bits - 1 */ - predicted_size += ( (scan_size - 1) % 8 ) ? 1 : 0; + predicted_size += ((scan_size - 1) % 8) ? 1 : 0; /* last bit (from TMS scan) */ predicted_size += 1; @@ -1000,8 +1191,9 @@ int ft2232_predict_scan_in(int scan_size, enum scan_type type) } -void usbjtag_reset(int trst, int srst) +static void usbjtag_reset(int trst, int srst) { + enum reset_types jtag_reset_config = jtag_get_reset_config(); if (trst == 1) { if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) @@ -1033,14 +1225,15 @@ void usbjtag_reset(int trst, int srst) } /* command "set data bits low byte" */ - BUFFER_ADD = 0x80; - BUFFER_ADD = low_output; - BUFFER_ADD = low_direction; + buffer_write(0x80); + buffer_write(low_output); + buffer_write(low_direction); } -void jtagkey_reset(int trst, int srst) +static void jtagkey_reset(int trst, int srst) { + enum reset_types jtag_reset_config = jtag_get_reset_config(); if (trst == 1) { if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) @@ -1072,16 +1265,17 @@ void jtagkey_reset(int trst, int srst) } /* command "set data bits high byte" */ - BUFFER_ADD = 0x82; - BUFFER_ADD = high_output; - BUFFER_ADD = high_direction; + buffer_write(0x82); + buffer_write(high_output); + buffer_write(high_direction); LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction); } -void olimex_jtag_reset(int trst, int srst) +static void olimex_jtag_reset(int trst, int srst) { + enum reset_types jtag_reset_config = jtag_get_reset_config(); if (trst == 1) { if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) @@ -1107,15 +1301,15 @@ void olimex_jtag_reset(int trst, int srst) } /* command "set data bits high byte" */ - BUFFER_ADD = 0x82; - BUFFER_ADD = high_output; - BUFFER_ADD = high_direction; + buffer_write(0x82); + buffer_write(high_output); + buffer_write(high_direction); LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction); } -void axm0432_jtag_reset(int trst, int srst) +static void axm0432_jtag_reset(int trst, int srst) { if (trst == 1) { @@ -1137,15 +1331,15 @@ void axm0432_jtag_reset(int trst, int srst) } /* command "set data bits low byte" */ - BUFFER_ADD = 0x82; - BUFFER_ADD = high_output; - BUFFER_ADD = high_direction; + buffer_write(0x82); + buffer_write(high_output); + buffer_write(high_direction); LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction); } -void flyswatter_reset(int trst, int srst) +static void flyswatter_reset(int trst, int srst) { if (trst == 1) { @@ -1166,14 +1360,14 @@ void flyswatter_reset(int trst, int srst) } /* command "set data bits low byte" */ - BUFFER_ADD = 0x80; - BUFFER_ADD = low_output; - BUFFER_ADD = low_direction; + buffer_write(0x80); + buffer_write(low_output); + buffer_write(low_direction); LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction); } -void turtle_reset(int trst, int srst) +static void turtle_reset(int trst, int srst) { trst = trst; @@ -1187,14 +1381,14 @@ void turtle_reset(int trst, int srst) } /* command "set data bits low byte" */ - BUFFER_ADD = 0x80; - BUFFER_ADD = low_output; - BUFFER_ADD = low_direction; + buffer_write(0x80); + buffer_write(low_output); + buffer_write(low_direction); LOG_DEBUG("srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", srst, low_output, low_direction); } -void comstick_reset(int trst, int srst) +static void comstick_reset(int trst, int srst) { if (trst == 1) { @@ -1215,15 +1409,15 @@ void comstick_reset(int trst, int srst) } /* command "set data bits high byte" */ - BUFFER_ADD = 0x82; - BUFFER_ADD = high_output; - BUFFER_ADD = high_direction; + buffer_write(0x82); + buffer_write(high_output); + buffer_write(high_direction); LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction); } -void stm32stick_reset(int trst, int srst) +static void stm32stick_reset(int trst, int srst) { if (trst == 1) { @@ -1244,21 +1438,21 @@ void stm32stick_reset(int trst, int srst) } /* command "set data bits low byte" */ - BUFFER_ADD = 0x80; - BUFFER_ADD = low_output; - BUFFER_ADD = low_direction; + buffer_write(0x80); + buffer_write(low_output); + buffer_write(low_direction); /* command "set data bits high byte" */ - BUFFER_ADD = 0x82; - BUFFER_ADD = high_output; - BUFFER_ADD = high_direction; + buffer_write(0x82); + buffer_write(high_output); + buffer_write(high_direction); LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction); } -void sheevaplug_reset(int trst, int srst) +static void sheevaplug_reset(int trst, int srst) { if (trst == 1) high_output &= ~nTRST; @@ -1271,253 +1465,310 @@ void sheevaplug_reset(int trst, int srst) high_output |= nSRSTnOE; /* command "set data bits high byte" */ - BUFFER_ADD = 0x82; - BUFFER_ADD = high_output; - BUFFER_ADD = high_direction; + buffer_write(0x82); + buffer_write(high_output); + buffer_write(high_direction); LOG_DEBUG("trst: %i, srst: %i, high_output: 0x%2.2x, high_direction: 0x%2.2x", trst, srst, high_output, high_direction); } -int ft2232_execute_queue() +static int ft2232_execute_runtest(jtag_command_t *cmd) { - jtag_command_t* cmd = jtag_command_queue; /* currently processed command */ - u8* buffer; - int scan_size; /* size of IR or DR scan */ - enum scan_type type; + int retval; int i; - int predicted_size = 0; - int retval; + int predicted_size = 0; + retval = ERROR_OK; - first_unsent = cmd; /* next command that has to be sent */ - require_send = 0; + DEBUG_JTAG_IO("runtest %i cycles, end in %s", + cmd->cmd.runtest->num_cycles, + tap_state_name(cmd->cmd.runtest->end_state)); - /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check - * that wasn't handled by a caller-provided error handler - */ - retval = ERROR_OK; + /* only send the maximum buffer size that FT2232C can handle */ + predicted_size = 0; + if (tap_get_state() != TAP_IDLE) + predicted_size += 3; + predicted_size += 3 * CEIL(cmd->cmd.runtest->num_cycles, 7); + if (cmd->cmd.runtest->end_state != TAP_IDLE) + predicted_size += 3; + if (tap_get_end_state() != TAP_IDLE) + predicted_size += 3; + if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) + { + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; + require_send = 0; + first_unsent = cmd; + } + if (tap_get_state() != TAP_IDLE) + { + move_to_state(TAP_IDLE); + require_send = 1; + } + i = cmd->cmd.runtest->num_cycles; + while (i > 0) + { + /* there are no state transitions in this code, so omit state tracking */ - ft2232_buffer_size = 0; - ft2232_expect_read = 0; + /* command "Clock Data to TMS/CS Pin (no Read)" */ + buffer_write(0x4b); - /* blink, if the current layout has that feature */ - if (layout->blink) - layout->blink(); + /* scan 7 bits */ + buffer_write((i > 7) ? 6 : (i - 1)); - while (cmd) - { - switch (cmd->type) - { - case JTAG_END_STATE: - if (cmd->cmd.end_state->end_state != -1) - ft2232_end_state(cmd->cmd.end_state->end_state); - break; + /* TMS data bits */ + buffer_write(0x0); + tap_set_state(TAP_IDLE); - case JTAG_RESET: - /* only send the maximum buffer size that FT2232C can handle */ - predicted_size = 3; - if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) - { - if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) - retval = ERROR_JTAG_QUEUE_FAILED; - require_send = 0; - first_unsent = cmd; - } + i -= (i > 7) ? 7 : i; + /* LOG_DEBUG("added TMS scan (no read)"); */ + } - if ( (cmd->cmd.reset->trst == 1) || ( cmd->cmd.reset->srst && (jtag_reset_config & RESET_SRST_PULLS_TRST) ) ) - { - tap_set_state(TAP_RESET); - } - layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); - require_send = 1; + ft2232_end_state(cmd->cmd.runtest->end_state); + + if (tap_get_state() != tap_get_end_state()) + { + move_to_state(tap_get_end_state()); + } + require_send = 1; #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("trst: %i, srst: %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); + LOG_DEBUG("runtest: %i, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name(tap_get_end_state())); #endif - break; - case JTAG_RUNTEST: - /* only send the maximum buffer size that FT2232C can handle */ - predicted_size = 0; - if (tap_get_state() != TAP_IDLE) - predicted_size += 3; - predicted_size += 3 * CEIL(cmd->cmd.runtest->num_cycles, 7); - if ( (cmd->cmd.runtest->end_state != -1) && (cmd->cmd.runtest->end_state != TAP_IDLE) ) - predicted_size += 3; - if ( (cmd->cmd.runtest->end_state == -1) && (tap_get_end_state() != TAP_IDLE) ) - predicted_size += 3; - if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) - { - if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) - retval = ERROR_JTAG_QUEUE_FAILED; - require_send = 0; - first_unsent = cmd; - } - if (tap_get_state() != TAP_IDLE) - { - /* command "Clock Data to TMS/CS Pin (no Read)" */ - BUFFER_ADD = 0x4b; - BUFFER_ADD = 0x6; /* scan 7 bits */ - - /* TMS data bits */ - BUFFER_ADD = tap_get_tms_path(tap_get_state(), TAP_IDLE); - tap_set_state(TAP_IDLE); - require_send = 1; - } - i = cmd->cmd.runtest->num_cycles; - while (i > 0) - { - /* command "Clock Data to TMS/CS Pin (no Read)" */ - BUFFER_ADD = 0x4b; + return retval; +} - /* scan 7 bits */ - BUFFER_ADD = (i > 7) ? 6 : (i - 1); - /* TMS data bits */ - BUFFER_ADD = 0x0; - tap_set_state(TAP_IDLE); - i -= (i > 7) ? 7 : i; - /* LOG_DEBUG("added TMS scan (no read)"); */ - } +static int ft2232_execute_statemove(jtag_command_t *cmd) +{ + int predicted_size = 0; + int retval = ERROR_OK; - if (cmd->cmd.runtest->end_state != -1) - ft2232_end_state(cmd->cmd.runtest->end_state); + DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state); - if ( tap_get_state() != tap_get_end_state() ) - { - /* command "Clock Data to TMS/CS Pin (no Read)" */ - BUFFER_ADD = 0x4b; - /* scan 7 bit */ - BUFFER_ADD = 0x6; - /* TMS data bits */ - BUFFER_ADD = tap_get_tms_path( tap_get_state(), tap_get_end_state() ); - tap_set_state( tap_get_end_state() ); - /* LOG_DEBUG("added TMS scan (no read)"); */ - } - require_send = 1; -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG( "runtest: %i, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name( tap_get_end_state() ) ); -#endif - break; + /* only send the maximum buffer size that FT2232C can handle */ + predicted_size = 3; + if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) + { + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; + require_send = 0; + first_unsent = cmd; + } + ft2232_end_state(cmd->cmd.statemove->end_state); - case JTAG_STATEMOVE: - /* only send the maximum buffer size that FT2232C can handle */ - predicted_size = 3; - if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) - { - if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) - retval = ERROR_JTAG_QUEUE_FAILED; - require_send = 0; - first_unsent = cmd; - } - if (cmd->cmd.statemove->end_state != -1) - ft2232_end_state(cmd->cmd.statemove->end_state); + /* move to end state */ + if (tap_get_state() != tap_get_end_state()) + { + move_to_state(tap_get_end_state()); + require_send = 1; + } - /* command "Clock Data to TMS/CS Pin (no Read)" */ - BUFFER_ADD = 0x4b; + return retval; +} - BUFFER_ADD = 0x6; /* scan 7 bits */ +static int ft2232_execute_pathmove(jtag_command_t *cmd) +{ + int predicted_size = 0; + int retval = ERROR_OK; - /* TMS data bits */ - BUFFER_ADD = tap_get_tms_path( tap_get_state(), tap_get_end_state() ); - /* LOG_DEBUG("added TMS scan (no read)"); */ - tap_set_state( tap_get_end_state() ); - require_send = 1; -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG( "statemove: %s", tap_state_name( tap_get_end_state() ) ); -#endif - break; + tap_state_t* path = cmd->cmd.pathmove->path; + int num_states = cmd->cmd.pathmove->num_states; - case JTAG_PATHMOVE: - /* only send the maximum buffer size that FT2232C can handle */ - predicted_size = 3 * CEIL(cmd->cmd.pathmove->num_states, 7); - if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) - { - if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) - retval = ERROR_JTAG_QUEUE_FAILED; - require_send = 0; - first_unsent = cmd; - } - ft2232_add_pathmove(cmd->cmd.pathmove); - require_send = 1; + 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]) + ); + + /* only send the maximum buffer size that FT2232C can handle */ + predicted_size = 3 * CEIL(num_states, 7); + if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) + { + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; + + require_send = 0; + first_unsent = cmd; + } + + ft2232_add_pathmove(path, num_states); + require_send = 1; + + return retval; +} + + +static int ft2232_execute_scan(jtag_command_t *cmd) +{ + uint8_t* buffer; + int scan_size; /* size of IR or DR scan */ + int predicted_size = 0; + int retval = ERROR_OK; + + enum scan_type type = jtag_scan_type(cmd->cmd.scan); + + DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN", type); + + scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); + + predicted_size = ft2232_predict_scan_out(scan_size, type); + if ((predicted_size + 1) > FT2232_BUFFER_SIZE) + { + LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)"); + /* unsent commands before this */ + if (first_unsent != cmd) + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; + + /* current command */ + ft2232_end_state(cmd->cmd.scan->end_state); + ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size); + require_send = 0; + first_unsent = cmd->next; + if (buffer) + free(buffer); + return retval; + } + else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) + { + LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)", + first_unsent, + cmd); + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; + require_send = 0; + first_unsent = cmd; + } + ft2232_expect_read += ft2232_predict_scan_in(scan_size, type); + /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */ + ft2232_end_state(cmd->cmd.scan->end_state); + ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size); + require_send = 1; + if (buffer) + free(buffer); #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG( "pathmove: %i states, end in %s", cmd->cmd.pathmove->num_states, - tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]) ); + LOG_DEBUG("%s scan, %i bits, end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size, + tap_state_name(tap_get_end_state())); #endif - break; + return retval; + +} + +static int ft2232_execute_reset(jtag_command_t *cmd) +{ + int retval; + int predicted_size = 0; + retval = ERROR_OK; + + DEBUG_JTAG_IO("reset trst: %i srst %i", + cmd->cmd.reset->trst, cmd->cmd.reset->srst); + + /* only send the maximum buffer size that FT2232C can handle */ + predicted_size = 3; + if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) + { + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; + require_send = 0; + first_unsent = cmd; + } + + layout->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); + require_send = 1; - case JTAG_SCAN: - scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); - type = jtag_scan_type(cmd->cmd.scan); - predicted_size = ft2232_predict_scan_out(scan_size, type); - if ( (predicted_size + 1) > FT2232_BUFFER_SIZE ) - { - LOG_DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)"); - /* unsent commands before this */ - if (first_unsent != cmd) - if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) - retval = ERROR_JTAG_QUEUE_FAILED; - - /* current command */ - if (cmd->cmd.scan->end_state != -1) - ft2232_end_state(cmd->cmd.scan->end_state); - ft2232_large_scan(cmd->cmd.scan, type, buffer, scan_size); - require_send = 0; - first_unsent = cmd->next; - if (buffer) - free(buffer); - break; - } - else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) - { - LOG_DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)", - first_unsent, - cmd); - if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) - retval = ERROR_JTAG_QUEUE_FAILED; - require_send = 0; - first_unsent = cmd; - } - ft2232_expect_read += ft2232_predict_scan_in(scan_size, type); - /* LOG_DEBUG("new read size: %i", ft2232_expect_read); */ - if (cmd->cmd.scan->end_state != -1) - ft2232_end_state(cmd->cmd.scan->end_state); - ft2232_add_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size); - require_send = 1; - if (buffer) - free(buffer); #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG( "%s scan, %i bits, end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size, - tap_state_name( tap_get_end_state() ) ); + LOG_DEBUG("trst: %i, srst: %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); #endif - break; + return retval; +} - case JTAG_SLEEP: - if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) +static int ft2232_execute_sleep(jtag_command_t *cmd) +{ + int retval; + retval = ERROR_OK; + + DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us); + + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) retval = ERROR_JTAG_QUEUE_FAILED; - first_unsent = cmd->next; - jtag_sleep(cmd->cmd.sleep->us); + first_unsent = cmd->next; + jtag_sleep(cmd->cmd.sleep->us); #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG( "sleep %i usec while in %s", cmd->cmd.sleep->us, tap_state_name( tap_get_state() ) ); + LOG_DEBUG("sleep %i usec while in %s", cmd->cmd.sleep->us, tap_state_name(tap_get_state())); #endif - break; - case JTAG_STABLECLOCKS: + return retval; +} - /* this is only allowed while in a stable state. A check for a stable - * state was done in jtag_add_clocks() - */ - if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK) - retval = ERROR_JTAG_QUEUE_FAILED; +static int ft2232_execute_stableclocks(jtag_command_t *cmd) +{ + int retval; + retval = ERROR_OK; + + /* this is only allowed while in a stable state. A check for a stable + * state was done in jtag_add_clocks() + */ + if (ft2232_stableclocks(cmd->cmd.stableclocks->num_cycles, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG( "clocks %i while in %s", cmd->cmd.stableclocks->num_cycles, tap_state_name( tap_get_state() ) ); + LOG_DEBUG("clocks %i while in %s", cmd->cmd.stableclocks->num_cycles, tap_state_name(tap_get_state())); #endif - break; - default: - LOG_ERROR("BUG: unknown JTAG command type encountered"); - exit(-1); - } + return retval; +} +static int ft2232_execute_command(jtag_command_t *cmd) +{ + int retval; + retval = ERROR_OK; + + switch (cmd->type) + { + case JTAG_RESET: retval = ft2232_execute_reset(cmd); break; + case JTAG_RUNTEST: retval = ft2232_execute_runtest(cmd); break; + case JTAG_STATEMOVE: retval = ft2232_execute_statemove(cmd); break; + case JTAG_PATHMOVE: retval = ft2232_execute_pathmove(cmd); break; + case JTAG_SCAN: retval = ft2232_execute_scan(cmd); break; + case JTAG_SLEEP: retval = ft2232_execute_sleep(cmd); break; + case JTAG_STABLECLOCKS: retval = ft2232_execute_stableclocks(cmd); break; + default: + LOG_ERROR("BUG: unknown JTAG command type encountered"); + exit(-1); + } + return retval; +} + +static int ft2232_execute_queue() +{ + jtag_command_t* cmd = jtag_command_queue; /* currently processed command */ + int retval; + + first_unsent = cmd; /* next command that has to be sent */ + require_send = 0; + + /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check + * that wasn't handled by a caller-provided error handler + */ + retval = ERROR_OK; + + ft2232_buffer_size = 0; + ft2232_expect_read = 0; + + /* blink, if the current layout has that feature */ + if (layout->blink) + layout->blink(); + + while (cmd) + { + if (ft2232_execute_command(cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; + /* Start reading input before FT2232 TX buffer fills up */ cmd = cmd->next; + if (ft2232_expect_read > 256) + { + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; + first_unsent = cmd; + } } if (require_send > 0) @@ -1529,18 +1780,21 @@ int ft2232_execute_queue() #if BUILD_FT2232_FTD2XX == 1 -static int ft2232_init_ftd2xx(u16 vid, u16 pid, int more, int* try_more) +static int ft2232_init_ftd2xx(uint16_t vid, uint16_t pid, int more, int* try_more) { - FT_STATUS status; - DWORD openex_flags = 0; - char* openex_string = NULL; - u8 latency_timer; + FT_STATUS status; + DWORD deviceID; + char SerialNumber[16]; + char Description[64]; + DWORD openex_flags = 0; + char* openex_string = NULL; + uint8_t latency_timer; LOG_DEBUG("'ft2232' interface using FTD2XX with '%s' layout (%4.4x:%4.4x)", ft2232_layout, vid, pid); #if IS_WIN32 == 0 /* Add non-standard Vid/Pid to the linux driver */ - if ( ( status = FT_SetVIDPID(vid, pid) ) != FT_OK ) + if ((status = FT_SetVIDPID(vid, pid)) != FT_OK) { LOG_WARNING("couldn't add %4.4x:%4.4x", vid, pid); } @@ -1570,7 +1824,28 @@ static int ft2232_init_ftd2xx(u16 vid, u16 pid, int more, int* try_more) return ERROR_JTAG_INIT_FAILED; } - if ( ( status = FT_OpenEx(openex_string, openex_flags, &ftdih) ) != FT_OK ) + status = FT_OpenEx(openex_string, openex_flags, &ftdih); + if (status != FT_OK) { + // under Win32, the FTD2XX driver appends an "A" to the end + // of the description, if we tried by the desc, then + // try by the alternate "A" description. + if (openex_string == ft2232_device_desc) { + // Try the alternate method. + openex_string = ft2232_device_desc_A; + status = FT_OpenEx(openex_string, openex_flags, &ftdih); + if (status == FT_OK) { + // yea, the "alternate" method worked! + } else { + // drat, give the user a meaningfull message. + // telling the use we tried *BOTH* methods. + LOG_WARNING("Unable to open FTDI Device tried: '%s' and '%s'\n", + ft2232_device_desc, + ft2232_device_desc_A); + } + } + } + + if (status != FT_OK) { DWORD num_devices; @@ -1584,8 +1859,8 @@ static int ft2232_init_ftd2xx(u16 vid, u16 pid, int more, int* try_more) status = FT_ListDevices(&num_devices, NULL, FT_LIST_NUMBER_ONLY); if (status == FT_OK) { - char** desc_array = malloc( sizeof(char*) * (num_devices + 1) ); - int i; + char** desc_array = malloc(sizeof(char*) * (num_devices + 1)); + u32 i; for (i = 0; i < num_devices; i++) desc_array[i] = malloc(64); @@ -1613,13 +1888,13 @@ static int ft2232_init_ftd2xx(u16 vid, u16 pid, int more, int* try_more) return ERROR_JTAG_INIT_FAILED; } - if ( ( status = FT_SetLatencyTimer(ftdih, ft2232_latency) ) != FT_OK ) + if ((status = FT_SetLatencyTimer(ftdih, ft2232_latency)) != FT_OK) { LOG_ERROR("unable to set latency timer: %lu", status); return ERROR_JTAG_INIT_FAILED; } - if ( ( status = FT_GetLatencyTimer(ftdih, &latency_timer) ) != FT_OK ) + if ((status = FT_GetLatencyTimer(ftdih, &latency_timer)) != FT_OK) { LOG_ERROR("unable to get latency timer: %lu", status); return ERROR_JTAG_INIT_FAILED; @@ -1629,18 +1904,39 @@ static int ft2232_init_ftd2xx(u16 vid, u16 pid, int more, int* try_more) LOG_DEBUG("current latency timer: %i", latency_timer); } - if ( ( status = FT_SetTimeouts(ftdih, 5000, 5000) ) != FT_OK ) + if ((status = FT_SetTimeouts(ftdih, 5000, 5000)) != FT_OK) { LOG_ERROR("unable to set timeouts: %lu", status); return ERROR_JTAG_INIT_FAILED; } - if ( ( status = FT_SetBitMode(ftdih, 0x0b, 2) ) != FT_OK ) + if ((status = FT_SetBitMode(ftdih, 0x0b, 2)) != FT_OK) { LOG_ERROR("unable to enable bit i/o mode: %lu", status); return ERROR_JTAG_INIT_FAILED; } + if ((status = FT_GetDeviceInfo(ftdih, &ftdi_device, &deviceID, SerialNumber, Description, NULL)) != FT_OK) + { + LOG_ERROR("unable to get FT_GetDeviceInfo: %lu", status); + return ERROR_JTAG_INIT_FAILED; + } + else + { + LOG_INFO("device: %lu", ftdi_device); + LOG_INFO("deviceID: %lu", deviceID); + LOG_INFO("SerialNumber: %s", SerialNumber); + LOG_INFO("Description: %s", Description); + +#ifdef BUILD_FTD2XX_HIGHSPEED + if (ft2232_device_is_highspeed()) + { + ft2232_max_tck = FTDI_2232H_4232H_MAX_TCK; + LOG_INFO("max TCK change to: %u kHz", ft2232_max_tck); + } +#endif + } + return ERROR_OK; } @@ -1649,7 +1945,7 @@ static int ft2232_purge_ftd2xx(void) { FT_STATUS status; - if ( ( status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX) ) != FT_OK ) + if ((status = FT_Purge(ftdih, FT_PURGE_RX | FT_PURGE_TX)) != FT_OK) { LOG_ERROR("error purging ftd2xx device: %lu", status); return ERROR_JTAG_INIT_FAILED; @@ -1662,9 +1958,9 @@ static int ft2232_purge_ftd2xx(void) #endif /* BUILD_FT2232_FTD2XX == 1 */ #if BUILD_FT2232_LIBFTDI == 1 -static int ft2232_init_libftdi(u16 vid, u16 pid, int more, int* try_more) +static int ft2232_init_libftdi(uint16_t vid, uint16_t pid, int more, int* try_more) { - u8 latency_timer; + uint8_t latency_timer; LOG_DEBUG("'ft2232' interface using libftdi with '%s' layout (%4.4x:%4.4x)", ft2232_layout, vid, pid); @@ -1672,6 +1968,12 @@ static int ft2232_init_libftdi(u16 vid, u16 pid, int more, int* try_more) if (ftdi_init(&ftdic) < 0) return ERROR_JTAG_INIT_FAILED; + if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0) + { + LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str); + return ERROR_JTAG_INIT_FAILED; + } + /* context, vendor id, product id */ if (ftdi_usb_open_desc(&ftdic, vid, pid, ft2232_device_desc, ft2232_serial) < 0) @@ -1685,12 +1987,7 @@ static int ft2232_init_libftdi(u16 vid, u16 pid, int more, int* try_more) return ERROR_JTAG_INIT_FAILED; } - if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0) - { - LOG_ERROR("unable to select FT2232 channel A: %s", ftdic.error_str); - return ERROR_JTAG_INIT_FAILED; - } - + /* There is already a reset in ftdi_usb_open_desc, this should be redundant */ if (ftdi_usb_reset(&ftdic) < 0) { LOG_ERROR("unable to reset ftdi device"); @@ -1733,15 +2030,24 @@ static int ft2232_purge_libftdi(void) #endif /* BUILD_FT2232_LIBFTDI == 1 */ -int ft2232_init(void) +static int ft2232_init(void) { - u8 buf[1]; + uint8_t buf[1]; int retval; u32 bytes_written; - ft2232_layout_t* cur_layout = ft2232_layouts; + const ft2232_layout_t* cur_layout = ft2232_layouts; int i; - if ( (ft2232_layout == NULL) || (ft2232_layout[0] == 0) ) + if (tap_get_tms_path_len(TAP_IRPAUSE,TAP_IRPAUSE)==7) + { + LOG_DEBUG("ft2232 interface using 7 step jtag state transitions"); + } + else + { + LOG_DEBUG("ft2232 interface using shortest path jtag state transitions"); + + } + if ((ft2232_layout == NULL) || (ft2232_layout[0] == 0)) { ft2232_layout = "usbjtag"; LOG_WARNING("No ft2232 layout specified, using default 'usbjtag'"); @@ -1796,10 +2102,10 @@ int ft2232_init(void) if (layout->init() != ERROR_OK) return ERROR_JTAG_INIT_FAILED; - ft2232_speed(jtag_speed); + ft2232_speed(jtag_get_speed()); buf[0] = 0x85; /* Disconnect TDI/DO to TDO/DI for Loopback */ - if ( ( ( retval = ft2232_write(buf, 1, &bytes_written) ) != ERROR_OK ) || (bytes_written != 1) ) + if (((retval = ft2232_write(buf, 1, &bytes_written)) != ERROR_OK) || (bytes_written != 1)) { LOG_ERROR("couldn't write to FT2232 to disable loopback"); return ERROR_JTAG_INIT_FAILED; @@ -1815,9 +2121,9 @@ int ft2232_init(void) } -int usbjtag_init(void) +static int usbjtag_init(void) { - u8 buf[3]; + uint8_t buf[3]; u32 bytes_written; low_output = 0x08; @@ -1852,6 +2158,7 @@ int usbjtag_init(void) return ERROR_JTAG_INIT_FAILED; } + enum reset_types jtag_reset_config = jtag_get_reset_config(); if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) { low_direction &= ~nTRSTnOE; /* nTRST input */ @@ -1880,7 +2187,7 @@ int usbjtag_init(void) buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in */ LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { LOG_ERROR("couldn't initialize FT2232 with 'USBJTAG' layout"); return ERROR_JTAG_INIT_FAILED; @@ -1890,9 +2197,9 @@ int usbjtag_init(void) } -int axm0432_jtag_init(void) +static int axm0432_jtag_init(void) { - u8 buf[3]; + uint8_t buf[3]; u32 bytes_written; low_output = 0x08; @@ -1904,7 +2211,7 @@ int axm0432_jtag_init(void) buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */ LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout"); return ERROR_JTAG_INIT_FAILED; @@ -1926,6 +2233,7 @@ int axm0432_jtag_init(void) high_output = 0x0; high_direction = 0x0c; + enum reset_types jtag_reset_config = jtag_get_reset_config(); if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) { LOG_ERROR("can't set nTRSTOE to push-pull on the Dicarlo jtag"); @@ -1950,7 +2258,7 @@ int axm0432_jtag_init(void) buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */ LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { LOG_ERROR("couldn't initialize FT2232 with 'Dicarlo' layout"); return ERROR_JTAG_INIT_FAILED; @@ -1960,9 +2268,9 @@ int axm0432_jtag_init(void) } -int jtagkey_init(void) +static int jtagkey_init(void) { - u8 buf[3]; + uint8_t buf[3]; u32 bytes_written; low_output = 0x08; @@ -1974,7 +2282,7 @@ int jtagkey_init(void) buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */ LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout"); return ERROR_JTAG_INIT_FAILED; @@ -1987,8 +2295,8 @@ int jtagkey_init(void) nSRST = 0x02; nSRSTnOE = 0x08; } - else if ( (strcmp(layout->name, "jtagkey_prototype_v1") == 0) - || (strcmp(layout->name, "oocdlink") == 0) ) + else if ((strcmp(layout->name, "jtagkey_prototype_v1") == 0) + || (strcmp(layout->name, "oocdlink") == 0)) { nTRST = 0x02; nTRSTnOE = 0x1; @@ -2004,6 +2312,7 @@ int jtagkey_init(void) high_output = 0x0; high_direction = 0x0f; + enum reset_types jtag_reset_config = jtag_get_reset_config(); if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) { high_output |= nTRSTnOE; @@ -2032,7 +2341,7 @@ int jtagkey_init(void) buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */ LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout"); return ERROR_JTAG_INIT_FAILED; @@ -2042,9 +2351,9 @@ int jtagkey_init(void) } -int olimex_jtag_init(void) +static int olimex_jtag_init(void) { - u8 buf[3]; + uint8_t buf[3]; u32 bytes_written; low_output = 0x08; @@ -2056,9 +2365,9 @@ int olimex_jtag_init(void) buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */ LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { - LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout"); + LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout"); return ERROR_JTAG_INIT_FAILED; } @@ -2070,6 +2379,7 @@ int olimex_jtag_init(void) high_output = 0x0; high_direction = 0x0f; + enum reset_types jtag_reset_config = jtag_get_reset_config(); if (jtag_reset_config & RESET_TRST_OPEN_DRAIN) { high_output |= nTRSTnOE; @@ -2099,9 +2409,9 @@ int olimex_jtag_init(void) buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */ LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if ((ft2232_write(buf, 3, &bytes_written) != ERROR_OK) || (bytes_written != 3)) { - LOG_ERROR("couldn't initialize FT2232 with 'JTAGkey' layout"); + LOG_ERROR("couldn't initialize FT2232 with 'Olimex' layout"); return ERROR_JTAG_INIT_FAILED; } @@ -2109,9 +2419,9 @@ int olimex_jtag_init(void) } -int flyswatter_init(void) +static int flyswatter_init(void) { - u8 buf[3]; + uint8_t buf[3]; u32 bytes_written; low_output = 0x18; @@ -2123,7 +2433,7 @@ int flyswatter_init(void) buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE[12]=out, n[ST]srst=out */ LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout"); return ERROR_JTAG_INIT_FAILED; @@ -2146,7 +2456,7 @@ int flyswatter_init(void) buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */ LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { LOG_ERROR("couldn't initialize FT2232 with 'flyswatter' layout"); return ERROR_JTAG_INIT_FAILED; @@ -2156,9 +2466,9 @@ int flyswatter_init(void) } -int turtle_init(void) +static int turtle_init(void) { - u8 buf[3]; + uint8_t buf[3]; u32 bytes_written; low_output = 0x08; @@ -2170,7 +2480,7 @@ int turtle_init(void) buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */ LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout"); return ERROR_JTAG_INIT_FAILED; @@ -2187,7 +2497,7 @@ int turtle_init(void) buf[2] = high_direction; LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { LOG_ERROR("couldn't initialize FT2232 with 'turtelizer2' layout"); return ERROR_JTAG_INIT_FAILED; @@ -2197,9 +2507,9 @@ int turtle_init(void) } -int comstick_init(void) +static int comstick_init(void) { - u8 buf[3]; + uint8_t buf[3]; u32 bytes_written; low_output = 0x08; @@ -2211,7 +2521,7 @@ int comstick_init(void) buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */ LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout"); return ERROR_JTAG_INIT_FAILED; @@ -2231,7 +2541,7 @@ int comstick_init(void) buf[2] = high_direction; LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { LOG_ERROR("couldn't initialize FT2232 with 'comstick' layout"); return ERROR_JTAG_INIT_FAILED; @@ -2241,9 +2551,9 @@ int comstick_init(void) } -int stm32stick_init(void) +static int stm32stick_init(void) { - u8 buf[3]; + uint8_t buf[3]; u32 bytes_written; low_output = 0x88; @@ -2255,7 +2565,7 @@ int stm32stick_init(void) buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */ LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout"); return ERROR_JTAG_INIT_FAILED; @@ -2275,7 +2585,7 @@ int stm32stick_init(void) buf[2] = high_direction; LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); - if ( ( ( ft2232_write(buf, 3, &bytes_written) ) != ERROR_OK ) || (bytes_written != 3) ) + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout"); return ERROR_JTAG_INIT_FAILED; @@ -2285,9 +2595,9 @@ int stm32stick_init(void) } -int sheevaplug_init(void) +static int sheevaplug_init(void) { - u8 buf[3]; + uint8_t buf[3]; u32 bytes_written; low_output = 0x08; @@ -2301,7 +2611,7 @@ int sheevaplug_init(void) if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { - LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout"); + LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout"); return ERROR_JTAG_INIT_FAILED; } @@ -2329,14 +2639,57 @@ int sheevaplug_init(void) if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { - LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout"); + LOG_ERROR("couldn't initialize FT2232 with 'sheevaplug' layout"); + return ERROR_JTAG_INIT_FAILED; + } + + return ERROR_OK; +} + +static int cortino_jtag_init(void) +{ + uint8_t buf[3]; + u32 bytes_written; + + low_output = 0x08; + low_direction = 0x1b; + + /* initialize low byte for jtag */ + buf[0] = 0x80; /* command "set data bits low byte" */ + buf[1] = low_output; /* value (TMS=1,TCK=0, TDI=0, nOE=0) */ + buf[2] = low_direction; /* dir (output=1), TCK/TDI/TMS=out, TDO=in, nOE=out */ + LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); + + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) + { + LOG_ERROR("couldn't initialize FT2232 with 'cortino' layout"); + return ERROR_JTAG_INIT_FAILED; + } + + nTRST = 0x01; + nTRSTnOE = 0x00; /* no output enable for nTRST */ + nSRST = 0x02; + nSRSTnOE = 0x00; /* no output enable for nSRST */ + + high_output = 0x03; + high_direction = 0x03; + + /* initialize high port */ + buf[0] = 0x82; /* command "set data bits high byte" */ + buf[1] = high_output; + buf[2] = high_direction; + LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); + + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) + { + LOG_ERROR("couldn't initialize FT2232 with 'stm32stick' layout"); return ERROR_JTAG_INIT_FAILED; } return ERROR_OK; } -void olimex_jtag_blink(void) +static void olimex_jtag_blink(void) { /* Olimex ARM-USB-OCD has a LED connected to ACBUS3 * ACBUS3 is bit 3 of the GPIOH port @@ -2352,26 +2705,26 @@ void olimex_jtag_blink(void) high_output |= 0x08; } - BUFFER_ADD = 0x82; - BUFFER_ADD = high_output; - BUFFER_ADD = high_direction; + buffer_write(0x82); + buffer_write(high_output); + buffer_write(high_direction); } -void flyswatter_jtag_blink(void) +static void flyswatter_jtag_blink(void) { /* * Flyswatter has two LEDs connected to ACBUS2 and ACBUS3 */ high_output ^= 0x0c; - BUFFER_ADD = 0x82; - BUFFER_ADD = high_output; - BUFFER_ADD = high_direction; + buffer_write(0x82); + buffer_write(high_output); + buffer_write(high_direction); } -void turtle_jtag_blink(void) +static void turtle_jtag_blink(void) { /* * Turtelizer2 has two LEDs connected to ACBUS2 and ACBUS3 @@ -2385,21 +2738,19 @@ void turtle_jtag_blink(void) high_output = 0x08; } - BUFFER_ADD = 0x82; - BUFFER_ADD = high_output; - BUFFER_ADD = high_direction; + buffer_write(0x82); + buffer_write(high_output); + buffer_write(high_direction); } -int ft2232_quit(void) +static int ft2232_quit(void) { #if BUILD_FT2232_FTD2XX == 1 FT_STATUS status; status = FT_Close(ftdih); #elif BUILD_FT2232_LIBFTDI == 1 - ftdi_disable_bitbang(&ftdic); - ftdi_usb_close(&ftdic); ftdi_deinit(&ftdic); @@ -2412,11 +2763,31 @@ int ft2232_quit(void) } -int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc) +static int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc) { + char *cp; + char buf[200]; if (argc == 1) { ft2232_device_desc = strdup(args[0]); + cp = strchr(ft2232_device_desc, 0); + // under Win32, the FTD2XX driver appends an "A" to the end + // of the description, this examines the given desc + // and creates the 'missing' _A or non_A variable. + if ((cp[-1] == 'A') && (cp[-2]==' ')) { + // it was, so make this the "A" version. + ft2232_device_desc_A = ft2232_device_desc; + // and *CREATE* the non-A version. + strcpy(buf, ft2232_device_desc); + cp = strchr(buf, 0); + cp[-2] = 0; + ft2232_device_desc = strdup(buf); + } else { + // A not defined + // so create it + sprintf(buf, "%s A", ft2232_device_desc); + ft2232_device_desc_A = strdup(buf); + } } else { @@ -2427,7 +2798,7 @@ int ft2232_handle_device_desc_command(struct command_context_s* cmd_ctx, char* c } -int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc) +static int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc) { if (argc == 1) { @@ -2442,7 +2813,7 @@ int ft2232_handle_serial_command(struct command_context_s* cmd_ctx, char* cmd, c } -int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc) +static int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc) { if (argc == 0) return ERROR_OK; @@ -2454,27 +2825,33 @@ int ft2232_handle_layout_command(struct command_context_s* cmd_ctx, char* cmd, c } -int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc) +static int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc) { - int i; - if (argc > MAX_USB_IDS * 2) { LOG_WARNING("ignoring extra IDs in ft2232_vid_pid " "(maximum is %d pairs)", MAX_USB_IDS); argc = MAX_USB_IDS * 2; } - if ( argc < 2 || (argc & 1) ) + if (argc < 2 || (argc & 1)) { LOG_WARNING("incomplete ft2232_vid_pid configuration directive"); if (argc < 2) - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; + // remove the incomplete trailing id + argc -= 1; } - for (i = 0; i + 1 < argc; i += 2) + int i; + int retval = ERROR_OK; + for (i = 0; i < argc; i += 2) { - ft2232_vid[i >> 1] = strtol(args[i], NULL, 0); - ft2232_pid[i >> 1] = strtol(args[i + 1], NULL, 0); + retval = parse_u16(args[i], &ft2232_vid[i >> 1]); + if (ERROR_OK != retval) + break; + retval = parse_u16(args[i + 1], &ft2232_pid[i >> 1]); + if (ERROR_OK != retval) + break; } /* @@ -2483,11 +2860,11 @@ int ft2232_handle_vid_pid_command(struct command_context_s* cmd_ctx, char* cmd, */ ft2232_vid[i >> 1] = ft2232_pid[i >> 1] = 0; - return ERROR_OK; + return retval; } -int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc) +static int ft2232_handle_latency_command(struct command_context_s* cmd_ctx, char* cmd, char** args, int argc) { if (argc == 1) { @@ -2507,7 +2884,7 @@ static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd) int retval = 0; /* 7 bits of either ones or zeros. */ - u8 tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00); + uint8_t tms = (tap_get_state() == TAP_RESET ? 0x7F : 0x00); while (num_cycles > 0) { @@ -2525,14 +2902,16 @@ static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd) first_unsent = cmd; } + /* there are no state transitions in this code, so omit state tracking */ + /* command "Clock Data to TMS/CS Pin (no Read)" */ - BUFFER_ADD = 0x4b; + buffer_write(0x4b); /* scan 7 bit */ - BUFFER_ADD = bitcount_per_command - 1; + buffer_write(bitcount_per_command - 1); /* TMS data bits are either all zeros or ones to stay in the current stable state */ - BUFFER_ADD = tms; + buffer_write(tms); require_send = 1; @@ -2541,3 +2920,109 @@ static int ft2232_stableclocks(int num_cycles, jtag_command_t* cmd) return retval; } + + +/* --------------------------------------------------------------------- + * Support for IceBear JTAG adapter from Section5: + * http://section5.ch/icebear + * + * Author: Sten, debian@sansys-electronic.com + */ + +/* Icebear pin layout + * + * ADBUS5 (nEMU) nSRST | 2 1| GND (10k->VCC) + * GND GND | 4 3| n.c. + * ADBUS3 TMS | 6 5| ADBUS6 VCC + * ADBUS0 TCK | 8 7| ADBUS7 (GND) + * ADBUS4 nTRST |10 9| ACBUS0 (GND) + * ADBUS1 TDI |12 11| ACBUS1 (GND) + * ADBUS2 TDO |14 13| GND GND + * + * ADBUS0 O L TCK ACBUS0 GND + * ADBUS1 O L TDI ACBUS1 GND + * ADBUS2 I TDO ACBUS2 n.c. + * ADBUS3 O H TMS ACBUS3 n.c. + * ADBUS4 O H nTRST + * ADBUS5 O H nSRST + * ADBUS6 - VCC + * ADBUS7 - GND + */ +static int icebear_jtag_init(void) { + uint8_t buf[3]; + u32 bytes_written; + + low_direction = 0x0b; /* output: TCK TDI TMS; input: TDO */ + low_output = 0x08; /* high: TMS; low: TCK TDI */ + nTRST = 0x10; + nSRST = 0x20; + + enum reset_types jtag_reset_config = jtag_get_reset_config(); + if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0) { + low_direction &= ~nTRST; /* nTRST high impedance */ + } + else { + low_direction |= nTRST; + low_output |= nTRST; + } + + low_direction |= nSRST; + low_output |= nSRST; + + /* initialize low byte for jtag */ + buf[0] = 0x80; /* command "set data bits low byte" */ + buf[1] = low_output; + buf[2] = low_direction; + LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); + + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { + LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (low)"); + return ERROR_JTAG_INIT_FAILED; + } + + high_output = 0x0; + high_direction = 0x00; + + + /* initialize high port */ + buf[0] = 0x82; /* command "set data bits high byte" */ + buf[1] = high_output; /* value */ + buf[2] = high_direction; /* all outputs (xRST and xRSTnOE) */ + LOG_DEBUG("%2.2x %2.2x %2.2x", buf[0], buf[1], buf[2]); + + if (((ft2232_write(buf, 3, &bytes_written)) != ERROR_OK) || (bytes_written != 3)) { + LOG_ERROR("couldn't initialize FT2232 with 'IceBear' layout (high)"); + return ERROR_JTAG_INIT_FAILED; + } + + return ERROR_OK; +} + +static void icebear_jtag_reset(int trst, int srst) { + + if (trst == 1) { + low_direction |= nTRST; + low_output &= ~nTRST; + } + else if (trst == 0) { + enum reset_types jtag_reset_config = jtag_get_reset_config(); + if ((jtag_reset_config & RESET_TRST_OPEN_DRAIN) != 0) + low_direction &= ~nTRST; + else + low_output |= nTRST; + } + + if (srst == 1) { + low_output &= ~nSRST; + } + else if (srst == 0) { + low_output |= nSRST; + } + + /* command "set data bits low byte" */ + buffer_write(0x80); + buffer_write(low_output); + buffer_write(low_direction); + + LOG_DEBUG("trst: %i, srst: %i, low_output: 0x%2.2x, low_direction: 0x%2.2x", trst, srst, low_output, low_direction); +}