static void 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);
}
static void ftdi_execute_runtest(struct jtag_command *cmd)
{
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) {
/* there are no state transitions in this code, so omit state tracking */
unsigned this_len = i > 7 ? 7 : i;
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()));
}
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_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_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;
}
/**
* 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 void 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));
mpsse_clock_tms_cs_out(mpsse_ctx,
(uint8_t *)&tms_bits,
0,
tms_count,
false,
JTAG_MODE);
}
static void jlink_execute_statemove(struct jtag_command *cmd)
{
DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state);
jlink_end_state(cmd->cmd.statemove->end_state);
jlink_state_move();
}
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 void jlink_execute_pathmove(struct jtag_command *cmd)
{
DEBUG_JTAG_IO("pathmove: %i states, end in %i",
cmd->cmd.pathmove->num_states,
cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
jlink_path_move(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path);
}
static void jlink_execute_runtest(struct jtag_command *cmd)
{
DEBUG_JTAG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles,
cmd->cmd.runtest->end_state);
jlink_end_state(cmd->cmd.runtest->end_state);
jlink_runtest(cmd->cmd.runtest->num_cycles);
}
static void jlink_execute_reset(struct jtag_command *cmd)
{
DEBUG_JTAG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst,
cmd->cmd.reset->srst);
jlink_flush();
jlink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
jlink_flush();
}
int jtag_build_buffer(const struct scan_command *cmd, uint8_t **buffer)
{
int bit_count = 0;
int i;
bit_count = jtag_scan_size(cmd);
*buffer = calloc(1,DIV_ROUND_UP(bit_count, 8));
bit_count = 0;
DEBUG_JTAG_IO("%s num_fields: %i",
cmd->ir_scan ? "IRSCAN" : "DRSCAN",
cmd->num_fields);
for (i = 0; i < cmd->num_fields; i++)
{
if (cmd->fields[i].out_value)
{
#ifdef _DEBUG_JTAG_IO_
char *char_buf = buf_to_str(cmd->fields[i].out_value,
(cmd->fields[i].num_bits > DEBUG_JTAG_IOZ)
? DEBUG_JTAG_IOZ
: cmd->fields[i].num_bits, 16);
LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i,
cmd->fields[i].num_bits, char_buf);
free(char_buf);
#endif
buf_set_buf(cmd->fields[i].out_value, 0, *buffer,
bit_count, cmd->fields[i].num_bits);
}
else
{
DEBUG_JTAG_IO("fields[%i].out_value[%i]: NULL",
i, cmd->fields[i].num_bits);
}
bit_count += cmd->fields[i].num_bits;
}
//DEBUG_JTAG_IO("bit_count totalling: %i", bit_count);
return bit_count;
}
static int vsllink_jtag_execute(void)
{
int i;
int result;
if (tap_length <= 0)
return ERROR_OK;
versaloon_interface.adaptors.jtag_raw.execute(0, tdi_buffer, tms_buffer,
tdo_buffer, tap_length);
result = versaloon_interface.adaptors.peripheral_commit();
if (result == ERROR_OK) {
for (i = 0; i < pending_scan_results_length; i++) {
struct pending_scan_result *pending_scan_result =
&pending_scan_results_buffer[i];
uint8_t *buffer = pending_scan_result->buffer;
int length = pending_scan_result->length;
int src_first = pending_scan_result->src_offset;
int dest_first = pending_scan_result->dest_offset;
bool last = pending_scan_result->last;
struct scan_command *command;
command = pending_scan_result->command;
buf_set_buf(tdo_buffer, src_first, buffer, dest_first, length);
#ifdef _DEBUG_JTAG_IO_
DEBUG_JTAG_IO(
"JTAG scan read(%d bits, from src %d bits to dest %d bits):",
length, src_first, dest_first);
vsllink_debug_buffer(buffer + dest_first / 8,
DIV_ROUND_UP(length, 7));
#endif
if (last) {
if (jtag_read_buffer(buffer, command)
!= ERROR_OK) {
vsllink_tap_init();
return ERROR_JTAG_QUEUE_FAILED;
}
if (pending_scan_result->buffer != NULL)
free(pending_scan_result->buffer);
}
}
} else {
LOG_ERROR("vsllink_jtag_execute failure");
return ERROR_JTAG_QUEUE_FAILED;
}
vsllink_tap_init();
return ERROR_OK;
}
static void ftdi_execute_statemove(struct jtag_command *cmd)
{
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());
}
/**
* Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
* (or SWD) state machine. REVISIT: Not the best method, perhaps.
*/
static void 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! */
mpsse_clock_tms_cs_out(mpsse_ctx,
cmd->cmd.tms->bits,
0,
cmd->cmd.tms->num_bits,
false,
JTAG_MODE);
}
static int ftdi_execute_swd_seq(struct jtag_command *cmd)
{
struct signal *swdoe = find_signal_by_name("SWDOE");
int retval = 0;
DEBUG_JTAG_IO("SWD sending raw sequence, length %d bits",
cmd->cmd.swd_seq->num_bits);
retval |= ftdi_set_signal(swdoe, '1');
retval |= mpsse_clock_data_out(mpsse_ctx,
cmd->cmd.swd_seq->bits, 0,
cmd->cmd.swd_seq->num_bits,
SWD_MODE);
return (retval);
}
static void jlink_execute_scan(struct jtag_command *cmd)
{
DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN",
jtag_scan_type(cmd->cmd.scan));
/* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
while (cmd->cmd.scan->num_fields > 0
&& cmd->cmd.scan->fields[cmd->cmd.scan->num_fields - 1].num_bits == 0) {
cmd->cmd.scan->num_fields--;
LOG_DEBUG("discarding trailing empty field");
}
if (cmd->cmd.scan->num_fields == 0) {
LOG_DEBUG("empty scan, doing nothing");
return;
}
if (cmd->cmd.scan->ir_scan) {
if (tap_get_state() != TAP_IRSHIFT) {
jlink_end_state(TAP_IRSHIFT);
jlink_state_move();
}
} else {
if (tap_get_state() != TAP_DRSHIFT) {
jlink_end_state(TAP_DRSHIFT);
jlink_state_move();
}
}
jlink_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. This last field can't have length zero, it was checked above. */
jlink_clock_data(field->out_value,
0,
NULL,
0,
field->in_value,
0,
field->num_bits - 1);
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;
jlink_clock_data(&last_bit,
0,
&tms_bits,
0,
field->in_value,
field->num_bits - 1,
1);
tap_set_state(tap_state_transition(tap_get_state(), 1));
jlink_clock_data(&last_bit,
0,
&tms_bits,
1,
NULL,
0,
1);
tap_set_state(tap_state_transition(tap_get_state(), 0));
} else
jlink_clock_data(field->out_value,
0,
NULL,
0,
field->in_value,
0,
field->num_bits);
}
if (tap_get_state() != tap_get_end_state()) {
jlink_end_state(tap_get_end_state());
jlink_state_move();
}
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()));
}
static int vsllink_execute_queue(void)
{
struct jtag_command *cmd = jtag_command_queue;
int scan_size;
enum scan_type type;
uint8_t *buffer;
DEBUG_JTAG_IO("-------------------------------------"
" vsllink "
"-------------------------------------");
while (cmd != NULL) {
switch (cmd->type) {
case JTAG_RUNTEST:
DEBUG_JTAG_IO("runtest %i cycles, end in %s",
cmd->cmd.runtest->num_cycles,
tap_state_name(cmd->cmd.runtest->end_state));
vsllink_end_state(cmd->cmd.runtest->end_state);
vsllink_runtest(cmd->cmd.runtest->num_cycles);
break;
case JTAG_TLR_RESET:
DEBUG_JTAG_IO("statemove end in %s",
tap_state_name(cmd->cmd.statemove->end_state));
vsllink_end_state(cmd->cmd.statemove->end_state);
vsllink_state_move();
break;
case JTAG_PATHMOVE:
DEBUG_JTAG_IO("pathmove: %i states, end in %s",
cmd->cmd.pathmove->num_states,
tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]));
vsllink_path_move(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path);
break;
case JTAG_SCAN:
DEBUG_JTAG_IO("JTAG Scan...");
vsllink_end_state(cmd->cmd.scan->end_state);
scan_size = jtag_build_buffer(
cmd->cmd.scan, &buffer);
if (cmd->cmd.scan->ir_scan)
DEBUG_JTAG_IO(
"JTAG Scan write IR(%d bits), "
"end in %s:",
scan_size,
tap_state_name(cmd->cmd.scan->end_state));
else
DEBUG_JTAG_IO(
"JTAG Scan write DR(%d bits), "
"end in %s:",
scan_size,
tap_state_name(cmd->cmd.scan->end_state));
#ifdef _DEBUG_JTAG_IO_
vsllink_debug_buffer(buffer,
DIV_ROUND_UP(scan_size, 8));
#endif
type = jtag_scan_type(cmd->cmd.scan);
vsllink_scan(cmd->cmd.scan->ir_scan,
type, buffer, scan_size,
cmd->cmd.scan);
break;
case JTAG_RESET:
DEBUG_JTAG_IO("reset trst: %i srst %i",
cmd->cmd.reset->trst,
cmd->cmd.reset->srst);
vsllink_tap_execute();
if (cmd->cmd.reset->trst == 1)
tap_set_state(TAP_RESET);
vsllink_reset(cmd->cmd.reset->trst,
cmd->cmd.reset->srst);
break;
case JTAG_SLEEP:
DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us);
vsllink_tap_execute();
jtag_sleep(cmd->cmd.sleep->us);
break;
case JTAG_STABLECLOCKS:
DEBUG_JTAG_IO("add %d clocks",
cmd->cmd.stableclocks->num_cycles);
switch (tap_get_state()) {
case TAP_RESET:
/* tms must be '1' to stay
* n TAP_RESET mode
*/
scan_size = 1;
break;
case TAP_DRSHIFT:
case TAP_IDLE:
case TAP_DRPAUSE:
case TAP_IRSHIFT:
case TAP_IRPAUSE:
/* else, tms should be '0' */
scan_size = 0;
break;
/* above stable states are OK */
default:
LOG_ERROR("jtag_add_clocks() "
"in non-stable state \"%s\"",
tap_state_name(tap_get_state())
);
exit(-1);
}
vsllink_stableclocks(cmd->cmd.stableclocks->num_cycles, scan_size);
break;
case JTAG_TMS:
DEBUG_JTAG_IO("add %d jtag tms",
cmd->cmd.tms->num_bits);
vsllink_tms(cmd->cmd.tms->num_bits, cmd->cmd.tms->bits);
break;
default:
LOG_ERROR("BUG: unknown JTAG command type "
"encountered: %d", cmd->type);
exit(-1);
}
cmd = cmd->next;
}
return vsllink_tap_execute();
}
static void jlink_execute_stableclocks(struct jtag_command *cmd)
{
DEBUG_JTAG_IO("stableclocks %i cycles", cmd->cmd.runtest->num_cycles);
jlink_stableclocks(cmd->cmd.runtest->num_cycles);
}
static void jlink_execute_sleep(struct jtag_command *cmd)
{
DEBUG_JTAG_IO("sleep %" PRIi32 "", cmd->cmd.sleep->us);
jlink_flush();
jtag_sleep(cmd->cmd.sleep->us);
}
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;
}
