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 void ftdi_execute_sleep(struct jtag_command *cmd)
{
DEBUG_JTAG_IO("sleep %" PRIi32, cmd->cmd.sleep->us);
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()));
}
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_queue(void)
{
/* 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 */
ftdi_execute_command(cmd);
}
if (led)
ftdi_set_signal(led, '0');
int retval = mpsse_flush(mpsse_ctx);
if (retval != ERROR_OK)
LOG_ERROR("error while flushing MPSSE queue: %d", retval);
return retval;
}
void mpsse_clock_data(struct mpsse_ctx *ctx, const uint8_t *out, unsigned out_offset, uint8_t *in,
unsigned in_offset, unsigned length, uint8_t mode)
{
/* TODO: Fix MSB first modes */
DEBUG_IO("%s%s %d bits", in ? "in" : "", out ? "out" : "", length);
if (ctx->retval != ERROR_OK) {
DEBUG_IO("Ignoring command due to previous error");
return;
}
/* TODO: On H chips, use command 0x8E/0x8F if in and out are both 0 */
if (out || (!out && !in))
mode |= 0x10;
if (in)
mode |= 0x20;
while (length > 0) {
/* Guarantee buffer space enough for a minimum size transfer */
if (buffer_write_space(ctx) + (length < 8) < (out || (!out && !in) ? 4 : 3)
|| (in && buffer_read_space(ctx) < 1))
ctx->retval = mpsse_flush(ctx);
if (length < 8) {
/* Transfer remaining bits in bit mode */
buffer_write_byte(ctx, 0x02 | mode);
buffer_write_byte(ctx, length - 1);
if (out)
out_offset += buffer_write(ctx, out, out_offset, length);
if (in)
in_offset += buffer_add_read(ctx, in, in_offset, length, 8 - length);
if (!out && !in)
buffer_write_byte(ctx, 0x00);
length = 0;
} else {
/* Byte transfer */
unsigned this_bytes = length / 8;
/* MPSSE command limit */
if (this_bytes > 65536)
this_bytes = 65536;
/* Buffer space limit. We already made sure there's space for the minimum
* transfer. */
if ((out || (!out && !in)) && this_bytes + 3 > buffer_write_space(ctx))
this_bytes = buffer_write_space(ctx) - 3;
if (in && this_bytes > buffer_read_space(ctx))
this_bytes = buffer_read_space(ctx);
if (this_bytes > 0) {
buffer_write_byte(ctx, mode);
buffer_write_byte(ctx, (this_bytes - 1) & 0xff);
buffer_write_byte(ctx, (this_bytes - 1) >> 8);
if (out)
out_offset += buffer_write(ctx,
out,
out_offset,
this_bytes * 8);
if (in)
in_offset += buffer_add_read(ctx,
in,
in_offset,
this_bytes * 8,
0);
if (!out && !in)
for (unsigned n = 0; n < this_bytes; n++)
buffer_write_byte(ctx, 0x00);
length -= this_bytes * 8;
}
}
}
