X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fjtag%2Fjtag.c;h=dd0d27f3b66fc85f849914fd215fbc432a984639;hb=d86100261252805215282b17d214c48021ef7f79;hp=64a168cbbc70c4bf8ccc5245fd33960c3825b3b8;hpb=deed7fb56c1067b84d5805df5ead428e09e8325e;p=openocd.git diff --git a/src/jtag/jtag.c b/src/jtag/jtag.c index 64a168cbbc..dd0d27f3b6 100644 --- a/src/jtag/jtag.c +++ b/src/jtag/jtag.c @@ -28,9 +28,9 @@ #include "config.h" #endif -#define INCLUDE_JTAG_MINIDRIVER_H -#define INCLUDE_JTAG_INTERFACE_H #include "jtag.h" +#include "minidriver.h" +#include "interface.h" #ifdef HAVE_STRINGS_H #include @@ -47,16 +47,6 @@ static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const s */ int jtag_error=ERROR_OK; -typedef struct cmd_queue_page_s -{ - void *address; - size_t used; - struct cmd_queue_page_s *next; -} cmd_queue_page_t; - -#define CMD_QUEUE_PAGE_SIZE (1024 * 1024) -static cmd_queue_page_t *cmd_queue_pages = NULL; - char* jtag_event_strings[] = { "JTAG controller reset (RESET or TRST)" @@ -72,26 +62,6 @@ const Jim_Nvp nvp_jtag_tap_event[] = { int jtag_trst = 0; int jtag_srst = 0; -#ifndef HAVE_JTAG_MINIDRIVER_H -struct jtag_callback_entry -{ - struct jtag_callback_entry *next; - - jtag_callback_t callback; - u8 *in; - jtag_callback_data_t data1; - jtag_callback_data_t data2; - jtag_callback_data_t data3; -}; - - -static struct jtag_callback_entry *jtag_callback_queue_head = NULL; -static struct jtag_callback_entry *jtag_callback_queue_tail = NULL; -#endif - - -jtag_command_t *jtag_command_queue = NULL; -jtag_command_t **last_command_pointer = &jtag_command_queue; static jtag_tap_t *jtag_all_taps = NULL; enum reset_types jtag_reset_config = RESET_NONE; @@ -229,20 +199,12 @@ jtag_interface_t *jtag_interfaces[] = { NULL, }; -static jtag_interface_t *jtag = NULL; +struct jtag_interface_s *jtag = NULL; /* configuration */ static jtag_interface_t *jtag_interface = NULL; int jtag_speed = 0; -/* forward declarations */ -//void jtag_add_pathmove(int num_states, tap_state_t *path); -//void jtag_add_runtest(int num_cycles, tap_state_t endstate); -//void jtag_add_end_state(tap_state_t endstate); -//void jtag_add_sleep(u32 us); -//int jtag_execute_queue(void); -static tap_state_t tap_state_by_name(const char *name); - /* jtag commands */ static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); @@ -423,151 +385,23 @@ int jtag_call_event_callbacks(enum jtag_event event) return ERROR_OK; } -/* returns a pointer to the pointer of the last command in queue - * this may be a pointer to the root pointer (jtag_command_queue) - * or to the next member of the last but one command - */ -jtag_command_t** jtag_get_last_command_p(void) +static void jtag_checks(void) { -/* jtag_command_t *cmd = jtag_command_queue; - - if (cmd) - while (cmd->next) - cmd = cmd->next; - else - return &jtag_command_queue; - - return &cmd->next;*/ - - return last_command_pointer; + assert(jtag_trst == 0); } - -void jtag_queue_command(jtag_command_t * cmd) -{ - jtag_command_t **last_cmd; - - last_cmd = jtag_get_last_command_p(); - - *last_cmd = cmd; - - (*last_cmd)->next = NULL; - - last_command_pointer = &((*last_cmd)->next); -} - - -void* cmd_queue_alloc(size_t size) -{ - cmd_queue_page_t **p_page = &cmd_queue_pages; - int offset; - u8 *t; - - /* - * WARNING: - * We align/round the *SIZE* per below - * so that all pointers returned by - * this function are reasonably well - * aligned. - * - * If we did not, then an "odd-length" request would cause the - * *next* allocation to be at an *odd* address, and because - * this function has the same type of api as malloc() - we - * must also return pointers that have the same type of - * alignment. - * - * What I do not/have is a reasonable portable means - * to align by... - * - * The solution here, is based on these suggestions. - * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html - * - */ - union worse_case_align { - int i; - long l; - float f; - void *v; - }; -#define ALIGN_SIZE (sizeof(union worse_case_align)) - - /* The alignment process. */ - size = (size + ALIGN_SIZE -1) & (~(ALIGN_SIZE-1)); - /* Done... */ - - if (*p_page) - { - while ((*p_page)->next) - p_page = &((*p_page)->next); - if (CMD_QUEUE_PAGE_SIZE - (*p_page)->used < size) - p_page = &((*p_page)->next); - } - - if (!*p_page) - { - *p_page = malloc(sizeof(cmd_queue_page_t)); - (*p_page)->used = 0; - (*p_page)->address = malloc(CMD_QUEUE_PAGE_SIZE); - (*p_page)->next = NULL; - } - - offset = (*p_page)->used; - (*p_page)->used += size; - - t=(u8 *)((*p_page)->address); - return t + offset; -} - -void cmd_queue_free(void) -{ - cmd_queue_page_t *page = cmd_queue_pages; - - while (page) - { - cmd_queue_page_t *last = page; - free(page->address); - page = page->next; - free(last); - } - - cmd_queue_pages = NULL; -} - -/** - * Copy a scan_field_t for insertion into the queue. - * - * This allocates a new copy of out_value using cmd_queue_alloc. - */ -static void cmd_queue_scan_field_clone(scan_field_t * dst, const scan_field_t * src) +static void jtag_prelude(tap_state_t state) { - dst->tap = src->tap; - dst->num_bits = src->num_bits; - dst->out_value = buf_cpy(src->out_value, cmd_queue_alloc(CEIL(src->num_bits, 8)), src->num_bits); - dst->in_value = src->in_value; -} - + jtag_checks(); -static void jtag_prelude1(void) -{ - if (jtag_trst == 1) - { - LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)"); - jtag_error=ERROR_JTAG_TRST_ASSERTED; - return; - } + assert(state!=TAP_INVALID); - if (cmd_queue_end_state == TAP_RESET) - jtag_call_event_callbacks(JTAG_TRST_ASSERTED); + cmd_queue_cur_state = state; } -static void jtag_prelude(tap_state_t state) +void jtag_alloc_in_value32(scan_field_t *field) { - jtag_prelude1(); - - if (state != TAP_INVALID) - jtag_add_end_state(state); - - cmd_queue_cur_state = cmd_queue_end_state; + interface_jtag_alloc_in_value32(field); } void jtag_add_ir_scan_noverify(int in_num_fields, const scan_field_t *in_fields, tap_state_t state) @@ -575,7 +409,7 @@ void jtag_add_ir_scan_noverify(int in_num_fields, const scan_field_t *in_fields, int retval; jtag_prelude(state); - retval=interface_jtag_add_ir_scan(in_num_fields, in_fields, cmd_queue_end_state); + retval=interface_jtag_add_ir_scan(in_num_fields, in_fields, state); if (retval!=ERROR_OK) jtag_error=retval; @@ -612,80 +446,6 @@ void jtag_add_ir_scan(int in_num_fields, scan_field_t *in_fields, tap_state_t st } } -/** - * see jtag_add_ir_scan() - * - */ -int MINIDRIVER(interface_jtag_add_ir_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state) -{ - size_t num_taps = jtag_NumEnabledTaps(); - - jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - scan_command_t * scan = cmd_queue_alloc(sizeof(scan_command_t)); - scan_field_t * out_fields = cmd_queue_alloc(num_taps * sizeof(scan_field_t)); - - jtag_queue_command(cmd); - - cmd->type = JTAG_SCAN; - cmd->cmd.scan = scan; - - scan->ir_scan = true; - scan->num_fields = num_taps; /* one field per device */ - scan->fields = out_fields; - scan->end_state = state; - - - scan_field_t * field = out_fields; /* keep track where we insert data */ - - /* loop over all enabled TAPs */ - - for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap)) - { - /* search the input field list for fields for the current TAP */ - - bool found = false; - - for (int j = 0; j < in_num_fields; j++) - { - if (tap != in_fields[j].tap) - continue; - - /* if TAP is listed in input fields, copy the value */ - - found = true; - - tap->bypass = 0; - - assert(in_fields[j].num_bits == tap->ir_length); /* input fields must have the same length as the TAP's IR */ - - cmd_queue_scan_field_clone(field, in_fields + j); - - break; - } - - if (!found) - { - /* if a TAP isn't listed in input fields, set it to BYPASS */ - - tap->bypass = 1; - - field->tap = tap; - field->num_bits = tap->ir_length; - field->out_value = buf_set_ones(cmd_queue_alloc(CEIL(tap->ir_length, 8)), tap->ir_length); - field->in_value = NULL; /* do not collect input for tap's in bypass */ - } - - /* update device information */ - buf_cpy(field->out_value, tap->cur_instr, tap->ir_length); - - field++; - } - - assert(field == out_fields + num_taps); /* paranoia: jtag_NumEnabledTaps() and jtag_NextEnabledTap() not in sync */ - - return ERROR_OK; -} - /** * Duplicate the scan fields passed into the function into an IR SCAN command * @@ -698,40 +458,22 @@ void jtag_add_plain_ir_scan(int in_num_fields, const scan_field_t *in_fields, ta jtag_prelude(state); - retval=interface_jtag_add_plain_ir_scan(in_num_fields, in_fields, cmd_queue_end_state); + retval=interface_jtag_add_plain_ir_scan(in_num_fields, in_fields, state); if (retval!=ERROR_OK) jtag_error=retval; } - -/** - * see jtag_add_plain_ir_scan() - * - */ -int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state) +void jtag_add_callback(jtag_callback1_t f, u8 *in) { - - jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - scan_command_t * scan = cmd_queue_alloc(sizeof(scan_command_t)); - scan_field_t * out_fields = cmd_queue_alloc(in_num_fields * sizeof(scan_field_t)); - - jtag_queue_command(cmd); - - cmd->type = JTAG_SCAN; - cmd->cmd.scan = scan; - - scan->ir_scan = true; - scan->num_fields = in_num_fields; - scan->fields = out_fields; - scan->end_state = state; - - for (int i = 0; i < in_num_fields; i++) - cmd_queue_scan_field_clone(out_fields + i, in_fields + i); - - return ERROR_OK; + interface_jtag_add_callback(f, in); } - +void jtag_add_callback4(jtag_callback_t f, u8 *in, + jtag_callback_data_t data1, jtag_callback_data_t data2, + jtag_callback_data_t data3) +{ + interface_jtag_add_callback4(f, in, data1, data2, data3); +} int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits); @@ -740,27 +482,6 @@ static int jtag_check_value_mask_callback(u8 *in, jtag_callback_data_t data1, jt return jtag_check_value_inner(in, (u8 *)data1, (u8 *)data2, (int)data3); } -#ifdef HAVE_JTAG_MINIDRIVER_H -void interface_jtag_add_scan_check_alloc(scan_field_t *field) -{ - /* We're executing this synchronously, so try to use local storage. */ - if (field->num_bits > 32) - { - unsigned num_bytes = TAP_SCAN_BYTES(field->num_bits); - field->in_value = (u8 *)malloc(num_bytes); - field->allocated = 1; - } - else - field->in_value = field->intmp; -} -#else -void interface_jtag_add_scan_check_alloc(scan_field_t *field) -{ - unsigned num_bytes = TAP_SCAN_BYTES(field->num_bits); - field->in_value = (u8 *)cmd_queue_alloc(num_bytes); -} -#endif - static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state), int in_num_fields, scan_field_t *in_fields, tap_state_t state) { @@ -825,180 +546,12 @@ void jtag_add_dr_scan(int in_num_fields, const scan_field_t *in_fields, tap_stat jtag_prelude(state); - retval=interface_jtag_add_dr_scan(in_num_fields, in_fields, cmd_queue_end_state); + retval=interface_jtag_add_dr_scan(in_num_fields, in_fields, state); if (retval!=ERROR_OK) jtag_error=retval; } -/** - * see jtag_add_dr_scan() - * - */ -int MINIDRIVER(interface_jtag_add_dr_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state) -{ - /* count devices in bypass */ - - size_t bypass_devices = 0; - - for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap)) - { - if (tap->bypass) - bypass_devices++; - } - - jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - scan_command_t * scan = cmd_queue_alloc(sizeof(scan_command_t)); - scan_field_t * out_fields = cmd_queue_alloc((in_num_fields + bypass_devices) * sizeof(scan_field_t)); - - jtag_queue_command(cmd); - - cmd->type = JTAG_SCAN; - cmd->cmd.scan = scan; - - scan->ir_scan = false; - scan->num_fields = in_num_fields + bypass_devices; - scan->fields = out_fields; - scan->end_state = state; - - - scan_field_t * field = out_fields; /* keep track where we insert data */ - - /* loop over all enabled TAPs */ - - for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap)) - { - /* if TAP is not bypassed insert matching input fields */ - - if (!tap->bypass) - { - scan_field_t * start_field = field; /* keep initial position for assert() */ - - for (int j = 0; j < in_num_fields; j++) - { - if (tap != in_fields[j].tap) - continue; - - cmd_queue_scan_field_clone(field, in_fields + j); - - field++; - } - - assert(field > start_field); /* must have at least one input field per not bypassed TAP */ - } - - /* if a TAP is bypassed, generated a dummy bit*/ - else - { - field->tap = tap; - field->num_bits = 1; - field->out_value = NULL; - field->in_value = NULL; - - field++; - } - } - - assert(field == out_fields + scan->num_fields); /* no superfluous input fields permitted */ - - return ERROR_OK; -} - - - -/** - * Generate a DR SCAN using the array of output values passed to the function - * - * This function assumes that the parameter target_tap specifies the one TAP - * that is not bypassed. All other TAPs must be bypassed and the function will - * generate a dummy 1bit field for them. - * - * For the target_tap a sequence of output-only fields will be generated where - * each field has the size num_bits and the field's values are taken from - * the array value. - * - * The bypass status of TAPs is set by jtag_add_ir_scan(). - * - */ -void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap, - int in_num_fields, - const int *num_bits, - const u32 *value, - tap_state_t end_state) -{ - /* count devices in bypass */ - - size_t bypass_devices = 0; - - for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap)) - { - if (tap->bypass) - bypass_devices++; - } - - - jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - scan_command_t * scan = cmd_queue_alloc(sizeof(scan_command_t)); - scan_field_t * out_fields = cmd_queue_alloc((in_num_fields + bypass_devices) * sizeof(scan_field_t)); - - jtag_queue_command(cmd); - - cmd->type = JTAG_SCAN; - cmd->cmd.scan = scan; - - scan->ir_scan = false; - scan->num_fields = in_num_fields + bypass_devices; - scan->fields = out_fields; - scan->end_state = end_state; - - - bool target_tap_match = false; - - scan_field_t * field = out_fields; /* keep track where we insert data */ - - /* loop over all enabled TAPs */ - - for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap)) - { - /* if TAP is not bypassed insert matching input fields */ - - if (!tap->bypass) - { - assert(tap == target_tap); /* target_tap must match the one not bypassed TAP */ - - target_tap_match = true; - - for (int j = 0; j < in_num_fields; j++) - { - u8 out_value[4]; - size_t scan_size = num_bits[j]; - buf_set_u32(out_value, 0, scan_size, value[j]); - - field->tap = tap; - field->num_bits = scan_size; - field->out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); - field->in_value = NULL; - - field++; - } - } - - /* if a TAP is bypassed, generated a dummy bit*/ - else - { - - field->tap = tap; - field->num_bits = 1; - field->out_value = NULL; - field->in_value = NULL; - - field++; - } - } - - assert(target_tap_match); /* target_tap should be enabled and not bypassed */ -} - /** * Duplicate the scan fields passed into the function into a DR SCAN command @@ -1012,39 +565,24 @@ void jtag_add_plain_dr_scan(int in_num_fields, const scan_field_t *in_fields, ta jtag_prelude(state); - retval=interface_jtag_add_plain_dr_scan(in_num_fields, in_fields, cmd_queue_end_state); + retval=interface_jtag_add_plain_dr_scan(in_num_fields, in_fields, state); if (retval!=ERROR_OK) jtag_error=retval; } - -/** - * see jtag_add_plain_dr_scan() - * - */ -int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state) +void jtag_add_dr_out(jtag_tap_t* tap, + int num_fields, const int* num_bits, const u32* value, + tap_state_t end_state) { - jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - scan_command_t * scan = cmd_queue_alloc(sizeof(scan_command_t)); - scan_field_t * out_fields = cmd_queue_alloc(in_num_fields * sizeof(scan_field_t)); - - jtag_queue_command(cmd); + assert(end_state != TAP_INVALID); - cmd->type = JTAG_SCAN; - cmd->cmd.scan = scan; + cmd_queue_cur_state = end_state; - scan->ir_scan = false; - scan->num_fields = in_num_fields; - scan->fields = out_fields; - scan->end_state = state; - - for (int i = 0; i < in_num_fields; i++) - cmd_queue_scan_field_clone(out_fields + i, in_fields + i); - - return ERROR_OK; + interface_jtag_add_dr_out(tap, + num_fields, num_bits, value, + end_state); } - void jtag_add_tlr(void) { jtag_prelude(TAP_RESET); @@ -1053,23 +591,8 @@ void jtag_add_tlr(void) retval=interface_jtag_add_tlr(); if (retval!=ERROR_OK) jtag_error=retval; -} - -int MINIDRIVER(interface_jtag_add_tlr)(void) -{ - tap_state_t state = TAP_RESET; - - /* allocate memory for a new list member */ - jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - - jtag_queue_command(cmd); - - cmd->type = JTAG_STATEMOVE; - - cmd->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t)); - cmd->cmd.statemove->end_state = state; - - return ERROR_OK; + + jtag_call_event_callbacks(JTAG_TRST_ASSERTED); } void jtag_add_pathmove(int num_states, const tap_state_t *path) @@ -1102,7 +625,7 @@ void jtag_add_pathmove(int num_states, const tap_state_t *path) cur_state = path[i]; } - jtag_prelude1(); + jtag_checks(); retval = interface_jtag_add_pathmove(num_states, path); cmd_queue_cur_state = path[num_states - 1]; @@ -1110,41 +633,6 @@ void jtag_add_pathmove(int num_states, const tap_state_t *path) jtag_error=retval; } -int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, const tap_state_t *path) -{ - /* allocate memory for a new list member */ - jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - - jtag_queue_command(cmd); - - cmd->type = JTAG_PATHMOVE; - - cmd->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t)); - cmd->cmd.pathmove->num_states = num_states; - cmd->cmd.pathmove->path = cmd_queue_alloc(sizeof(tap_state_t) * num_states); - - for (int i = 0; i < num_states; i++) - cmd->cmd.pathmove->path[i] = path[i]; - - return ERROR_OK; -} - -int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, tap_state_t state) -{ - /* allocate memory for a new list member */ - jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - - jtag_queue_command(cmd); - - cmd->type = JTAG_RUNTEST; - - cmd->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t)); - cmd->cmd.runtest->num_cycles = num_cycles; - cmd->cmd.runtest->end_state = state; - - return ERROR_OK; -} - void jtag_add_runtest(int num_cycles, tap_state_t state) { int retval; @@ -1152,27 +640,12 @@ void jtag_add_runtest(int num_cycles, tap_state_t state) jtag_prelude(state); /* executed by sw or hw fifo */ - retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state); + retval=interface_jtag_add_runtest(num_cycles, state); if (retval!=ERROR_OK) jtag_error=retval; } -int MINIDRIVER(interface_jtag_add_clocks)( int num_cycles ) -{ - /* allocate memory for a new list member */ - jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - - jtag_queue_command(cmd); - - cmd->type = JTAG_STABLECLOCKS; - - cmd->cmd.stableclocks = cmd_queue_alloc(sizeof(stableclocks_command_t)); - cmd->cmd.stableclocks->num_cycles = num_cycles; - - return ERROR_OK; -} - void jtag_add_clocks( int num_cycles ) { int retval; @@ -1187,7 +660,7 @@ void jtag_add_clocks( int num_cycles ) if( num_cycles > 0 ) { - jtag_prelude1(); + jtag_checks(); retval = interface_jtag_add_clocks(num_cycles); if (retval != ERROR_OK) @@ -1277,9 +750,8 @@ void jtag_add_reset(int req_tlr_or_trst, int req_srst) if (trst_with_tlr) { LOG_DEBUG("JTAG reset with RESET instead of TRST"); - jtag_add_end_state(TAP_RESET); + jtag_set_end_state(TAP_RESET); jtag_add_tlr(); - jtag_call_event_callbacks(JTAG_TRST_ASSERTED); return; } @@ -1290,158 +762,39 @@ void jtag_add_reset(int req_tlr_or_trst, int req_srst) */ LOG_DEBUG("TRST line asserted"); tap_set_state(TAP_RESET); - jtag_call_event_callbacks(JTAG_TRST_ASSERTED); - } - else - { - if (jtag_ntrst_delay) - jtag_add_sleep(jtag_ntrst_delay * 1000); - } -} - -int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst) -{ - /* allocate memory for a new list member */ - jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - - jtag_queue_command(cmd); - - cmd->type = JTAG_RESET; - - cmd->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t)); - cmd->cmd.reset->trst = req_trst; - cmd->cmd.reset->srst = req_srst; - - return ERROR_OK; -} - -void jtag_add_end_state(tap_state_t state) -{ - cmd_queue_end_state = state; - if ((cmd_queue_end_state == TAP_DRSHIFT)||(cmd_queue_end_state == TAP_IRSHIFT)) - { - LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field"); - } -} - -int MINIDRIVER(interface_jtag_add_sleep)(u32 us) -{ - /* allocate memory for a new list member */ - jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - - jtag_queue_command(cmd); - - cmd->type = JTAG_SLEEP; - - cmd->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t)); - cmd->cmd.sleep->us = us; - - return ERROR_OK; -} - -void jtag_add_sleep(u32 us) -{ - keep_alive(); /* we might be running on a very slow JTAG clk */ - int retval=interface_jtag_add_sleep(us); - if (retval!=ERROR_OK) - jtag_error=retval; - return; -} - -int jtag_scan_size(const scan_command_t *cmd) -{ - int bit_count = 0; - int i; - - /* count bits in scan command */ - for (i = 0; i < cmd->num_fields; i++) - { - bit_count += cmd->fields[i].num_bits; - } - - return bit_count; -} - -int jtag_build_buffer(const scan_command_t *cmd, u8 **buffer) -{ - int bit_count = 0; - int i; - - bit_count = jtag_scan_size(cmd); - *buffer = calloc(1,CEIL(bit_count, 8)); - - bit_count = 0; - -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("%s num_fields: %i", cmd->ir_scan ? "IRSCAN" : "DRSCAN", cmd->num_fields); -#endif - - 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); -#endif - buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits); -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, cmd->fields[i].num_bits, char_buf); - free(char_buf); -#endif - } - else - { -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("fields[%i].out_value[%i]: NULL", i, cmd->fields[i].num_bits); -#endif - } - - bit_count += cmd->fields[i].num_bits; + jtag_call_event_callbacks(JTAG_TRST_ASSERTED); + } + else + { + if (jtag_ntrst_delay) + jtag_add_sleep(jtag_ntrst_delay * 1000); } - -#ifdef _DEBUG_JTAG_IO_ - //LOG_DEBUG("bit_count totalling: %i", bit_count ); -#endif - - return bit_count; } -int jtag_read_buffer(u8 *buffer, const scan_command_t *cmd) +tap_state_t jtag_set_end_state(tap_state_t state) { - int i; - int bit_count = 0; - int retval; - - /* we return ERROR_OK, unless a check fails, or a handler reports a problem */ - retval = ERROR_OK; - - for (i = 0; i < cmd->num_fields; i++) + if ((state == TAP_DRSHIFT)||(state == TAP_IRSHIFT)) { - /* if neither in_value nor in_handler - * are specified we don't have to examine this field - */ - if (cmd->fields[i].in_value) - { - int num_bits = cmd->fields[i].num_bits; - u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits); - -#ifdef _DEBUG_JTAG_IO_ - char *char_buf = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16); - LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i, num_bits, char_buf); - free(char_buf); -#endif + LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field"); + } - if (cmd->fields[i].in_value) - { - buf_cpy(captured, cmd->fields[i].in_value, num_bits); - } + if (state!=TAP_INVALID) + cmd_queue_end_state = state; + return cmd_queue_end_state; +} - free(captured); - } - bit_count += cmd->fields[i].num_bits; - } +tap_state_t jtag_get_end_state(void) +{ + return cmd_queue_end_state; +} - return retval; +void jtag_add_sleep(u32 us) +{ + keep_alive(); /* we might be running on a very slow JTAG clk */ + int retval=interface_jtag_add_sleep(us); + if (retval!=ERROR_OK) + jtag_error=retval; + return; } static const char *jtag_tap_name(const jtag_tap_t *tap) @@ -1516,96 +869,18 @@ void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask) -enum scan_type jtag_scan_type(const scan_command_t *cmd) -{ - int i; - int type = 0; - - for (i = 0; i < cmd->num_fields; i++) - { - if (cmd->fields[i].in_value) - type |= SCAN_IN; - if (cmd->fields[i].out_value) - type |= SCAN_OUT; - } - - return type; -} - - -#ifndef HAVE_JTAG_MINIDRIVER_H -/* add callback to end of queue */ -void jtag_add_callback4(jtag_callback_t callback, u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3) -{ - struct jtag_callback_entry *entry=cmd_queue_alloc(sizeof(struct jtag_callback_entry)); - - entry->next=NULL; - entry->callback=callback; - entry->in=in; - entry->data1=data1; - entry->data2=data2; - entry->data3=data3; - - if (jtag_callback_queue_head==NULL) - { - jtag_callback_queue_head=entry; - jtag_callback_queue_tail=entry; - } else - { - jtag_callback_queue_tail->next=entry; - jtag_callback_queue_tail=entry; - } -} - - -static int jtag_convert_to_callback4(u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3) -{ - ((jtag_callback1_t)data1)(in); - return ERROR_OK; -} - -void jtag_add_callback(jtag_callback1_t callback, u8 *in) -{ - jtag_add_callback4(jtag_convert_to_callback4, in, (jtag_callback_data_t)callback, 0, 0); -} -#endif - -#ifndef HAVE_JTAG_MINIDRIVER_H - -int interface_jtag_execute_queue(void) +int default_interface_jtag_execute_queue(void) { - int retval; - - if (jtag==NULL) + if (NULL == jtag) { - LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets."); + LOG_ERROR("No JTAG interface configured yet. " + "Issue 'init' command in startup scripts " + "before communicating with targets."); return ERROR_FAIL; } - retval = jtag->execute_queue(); - - if (retval == ERROR_OK) - { - struct jtag_callback_entry *entry; - for (entry=jtag_callback_queue_head; entry!=NULL; entry=entry->next) - { - retval=entry->callback(entry->in, entry->data1, entry->data2, entry->data3); - if (retval!=ERROR_OK) - break; - } - } - - cmd_queue_free(); - - jtag_callback_queue_head = NULL; - jtag_callback_queue_tail = NULL; - - jtag_command_queue = NULL; - last_command_pointer = &jtag_command_queue; - - return retval; + return jtag->execute_queue(); } -#endif void jtag_execute_queue_noclear(void) { @@ -2904,7 +2179,7 @@ static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, command_print( cmd_ctx, "Invalid state name: %s\n", args[0] ); return ERROR_COMMAND_SYNTAX_ERROR; } - jtag_add_end_state(state); + jtag_set_end_state(state); jtag_execute_queue(); } command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state)); @@ -2956,7 +2231,7 @@ static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, return ERROR_COMMAND_SYNTAX_ERROR; } - jtag_add_runtest(strtol(args[0], NULL, 0), TAP_INVALID); + jtag_add_runtest(strtol(args[0], NULL, 0), jtag_get_end_state()); jtag_execute_queue(); return ERROR_OK; @@ -3297,469 +2572,30 @@ void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e) } } -/*--------------------------------------------*/ - -/* these Cable Helper API functions are all documented in the jtag.h header file, - using a Doxygen format. And since Doxygen's configuration file "Doxyfile", - is setup to prefer its docs in the header file, no documentation is here, for - if it were, it would have to be doubly maintained. -*/ - -/** - * @see tap_set_state() and tap_get_state() accessors. - * Actual name is not important since accessors hide it. - */ -static tap_state_t state_follower = TAP_RESET; - -void tap_set_state_impl( tap_state_t new_state ) -{ - /* this is the state we think the TAPs are in now, was cur_state */ - state_follower = new_state; -} - -tap_state_t tap_get_state() -{ - return state_follower; -} - -/** - * @see tap_set_end_state() and tap_get_end_state() accessors. - * Actual name is not important because accessors hide it. - */ -static tap_state_t end_state_follower = TAP_RESET; - -void tap_set_end_state( tap_state_t new_end_state ) -{ - /* this is the state we think the TAPs will be in at completion of the - current TAP operation, was end_state - */ - end_state_follower = new_end_state; -} - -tap_state_t tap_get_end_state() -{ - return end_state_follower; -} - - -int tap_move_ndx( tap_state_t astate ) -{ - /* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */ - - int ndx; - - switch( astate ) - { - case TAP_RESET: ndx = 0; break; - case TAP_DRSHIFT: ndx = 2; break; - case TAP_DRPAUSE: ndx = 3; break; - case TAP_IDLE: ndx = 1; break; - case TAP_IRSHIFT: ndx = 4; break; - case TAP_IRPAUSE: ndx = 5; break; - default: - LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate) ); - exit(1); - } - - return ndx; -} - - -/* tap_move[i][j]: tap movement command to go from state i to state j - * 0: Test-Logic-Reset - * 1: Run-Test/Idle - * 2: Shift-DR - * 3: Pause-DR - * 4: Shift-IR - * 5: Pause-IR - * - * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code - */ -struct tms_sequences -{ - u8 bits; - u8 bit_count; - -}; - -/* - * These macros allow us to specify TMS state transitions by bits rather than hex bytes. - * Read the bits from LSBit first to MSBit last (right-to-left). - */ -#define HEX__(n) 0x##n##LU - -#define B8__(x) \ - (((x) & 0x0000000FLU)?(1<<0):0) \ - +(((x) & 0x000000F0LU)?(1<<1):0) \ - +(((x) & 0x00000F00LU)?(1<<2):0) \ - +(((x) & 0x0000F000LU)?(1<<3):0) \ - +(((x) & 0x000F0000LU)?(1<<4):0) \ - +(((x) & 0x00F00000LU)?(1<<5):0) \ - +(((x) & 0x0F000000LU)?(1<<6):0) \ - +(((x) & 0xF0000000LU)?(1<<7):0) - -#define B8(bits,count) { ((u8)B8__(HEX__(bits))), (count) } - -static const struct tms_sequences old_tms_seqs[6][6] = /* [from_state_ndx][to_state_ndx] */ -{ - /* value clocked to TMS to move from one of six stable states to another. - * N.B. OOCD clocks TMS from LSB first, so read these right-to-left. - * N.B. These values are tightly bound to the table in tap_get_tms_path_len(). - * N.B. Reset only needs to be 0b11111, but in JLink an even byte of 1's is more stable. - * These extra ones cause no TAP state problem, because we go into reset and stay in reset. - */ - - - - /* to state: */ - /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */ - { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */ - { B8(1111111,7), B8(0000000,7), B8(0100101,7), B8(0000101,7), B8(0101011,7), B8(0001011,7) }, /* IDLE */ - { B8(1111111,7), B8(0110001,7), B8(0000000,7), B8(0000001,7), B8(0001111,7), B8(0101111,7) }, /* DRSHIFT */ - { B8(1111111,7), B8(0110000,7), B8(0100000,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* DRPAUSE */ - { B8(1111111,7), B8(0110001,7), B8(0000111,7), B8(0010111,7), B8(0000000,7), B8(0000001,7) }, /* IRSHIFT */ - { B8(1111111,7), B8(0110000,7), B8(0011100,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* IRPAUSE */ -}; - - - -static const struct tms_sequences short_tms_seqs[6][6] = /* [from_state_ndx][to_state_ndx] */ -{ - /* this is the table submitted by Jeff Williams on 3/30/2009 with this comment: - - OK, I added Peter's version of the state table, and it works OK for - me on MC1322x. I've recreated the jlink portion of patch with this - new state table. His changes to my state table are pretty minor in - terms of total transitions, but Peter feels that his version fixes - some long-standing problems. - Jeff - - I added the bit count into the table, reduced RESET column to 7 bits from 8. - Dick - - state specific comments: - ------------------------ - *->RESET tried the 5 bit reset and it gave me problems, 7 bits seems to - work better on ARM9 with ft2232 driver. (Dick) - - RESET->DRSHIFT add 1 extra clock cycles in the RESET state before advancing. - needed on ARM9 with ft2232 driver. (Dick) - - RESET->IRSHIFT add 1 extra clock cycles in the RESET state before advancing. - needed on ARM9 with ft2232 driver. (Dick) - */ - - /* to state: */ - /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */ - { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */ - { B8(1111111,7), B8(0000000,7), B8(001,3), B8(0101,4), B8(0011,4), B8(01011,5) }, /* IDLE */ - { B8(1111111,7), B8(011,3), B8(00111,5), B8(01,2), B8(001111,6), B8(0101111,7) }, /* DRSHIFT */ - { B8(1111111,7), B8(011,3), B8(01,2), B8(0,1), B8(001111,6), B8(0101111,7) }, /* DRPAUSE */ - { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(001111,6), B8(01,2) }, /* IRSHIFT */ - { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(01,2), B8(0,1) } /* IRPAUSE */ - -}; - -typedef const struct tms_sequences tms_table[6][6]; - -static tms_table *tms_seqs=&short_tms_seqs; - -int tap_get_tms_path( tap_state_t from, tap_state_t to ) -{ - return (*tms_seqs)[tap_move_ndx(from)][tap_move_ndx(to)].bits; -} - - -int tap_get_tms_path_len( tap_state_t from, tap_state_t to ) -{ - return (*tms_seqs)[tap_move_ndx(from)][tap_move_ndx(to)].bit_count; -} - - -bool tap_is_state_stable(tap_state_t astate) -{ - bool is_stable; - - /* A switch() is used because it is symbol dependent - (not value dependent like an array), and can also check bounds. - */ - switch( astate ) - { - case TAP_RESET: - case TAP_IDLE: - case TAP_DRSHIFT: - case TAP_DRPAUSE: - case TAP_IRSHIFT: - case TAP_IRPAUSE: - is_stable = true; - break; - default: - is_stable = false; - } - - return is_stable; -} - -tap_state_t tap_state_transition(tap_state_t cur_state, bool tms) -{ - tap_state_t new_state; - - /* A switch is used because it is symbol dependent and not value dependent - like an array. Also it can check for out of range conditions. - */ - - if (tms) - { - switch (cur_state) - { - case TAP_RESET: - new_state = cur_state; - break; - case TAP_IDLE: - case TAP_DRUPDATE: - case TAP_IRUPDATE: - new_state = TAP_DRSELECT; - break; - case TAP_DRSELECT: - new_state = TAP_IRSELECT; - break; - case TAP_DRCAPTURE: - case TAP_DRSHIFT: - new_state = TAP_DREXIT1; - break; - case TAP_DREXIT1: - case TAP_DREXIT2: - new_state = TAP_DRUPDATE; - break; - case TAP_DRPAUSE: - new_state = TAP_DREXIT2; - break; - case TAP_IRSELECT: - new_state = TAP_RESET; - break; - case TAP_IRCAPTURE: - case TAP_IRSHIFT: - new_state = TAP_IREXIT1; - break; - case TAP_IREXIT1: - case TAP_IREXIT2: - new_state = TAP_IRUPDATE; - break; - case TAP_IRPAUSE: - new_state = TAP_IREXIT2; - break; - default: - LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state ); - exit(1); - break; - } - } - else - { - switch (cur_state) - { - case TAP_RESET: - case TAP_IDLE: - case TAP_DRUPDATE: - case TAP_IRUPDATE: - new_state = TAP_IDLE; - break; - case TAP_DRSELECT: - new_state = TAP_DRCAPTURE; - break; - case TAP_DRCAPTURE: - case TAP_DRSHIFT: - case TAP_DREXIT2: - new_state = TAP_DRSHIFT; - break; - case TAP_DREXIT1: - case TAP_DRPAUSE: - new_state = TAP_DRPAUSE; - break; - case TAP_IRSELECT: - new_state = TAP_IRCAPTURE; - break; - case TAP_IRCAPTURE: - case TAP_IRSHIFT: - case TAP_IREXIT2: - new_state = TAP_IRSHIFT; - break; - case TAP_IREXIT1: - case TAP_IRPAUSE: - new_state = TAP_IRPAUSE; - break; - default: - LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state ); - exit(1); - break; - } - } - - return new_state; -} - -const char* tap_state_name(tap_state_t state) -{ - const char* ret; - - switch( state ) - { - case TAP_RESET: ret = "RESET"; break; - case TAP_IDLE: ret = "RUN/IDLE"; break; - case TAP_DRSELECT: ret = "DRSELECT"; break; - case TAP_DRCAPTURE: ret = "DRCAPTURE"; break; - case TAP_DRSHIFT: ret = "DRSHIFT"; break; - case TAP_DREXIT1: ret = "DREXIT1"; break; - case TAP_DRPAUSE: ret = "DRPAUSE"; break; - case TAP_DREXIT2: ret = "DREXIT2"; break; - case TAP_DRUPDATE: ret = "DRUPDATE"; break; - case TAP_IRSELECT: ret = "IRSELECT"; break; - case TAP_IRCAPTURE: ret = "IRCAPTURE"; break; - case TAP_IRSHIFT: ret = "IRSHIFT"; break; - case TAP_IREXIT1: ret = "IREXIT1"; break; - case TAP_IRPAUSE: ret = "IRPAUSE"; break; - case TAP_IREXIT2: ret = "IREXIT2"; break; - case TAP_IRUPDATE: ret = "IRUPDATE"; break; - default: ret = "???"; - } - - return ret; -} - -static tap_state_t tap_state_by_name( const char *name ) -{ - tap_state_t x; - - for( x = 0 ; x < TAP_NUM_STATES ; x++ ){ - /* be nice to the human */ - if( 0 == strcasecmp( name, tap_state_name(x) ) ){ - return x; - } - } - /* not found */ - return TAP_INVALID; -} - -#ifdef _DEBUG_JTAG_IO_ - -#define JTAG_DEBUG_STATE_APPEND(buf, len, bit) \ - do { buf[len] = bit ? '1' : '0'; } while(0) -#define JTAG_DEBUG_STATE_PRINT(a, b, astr, bstr) \ - DEBUG_JTAG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \ - tap_state_name(a), tap_state_name(b), astr, bstr) - -tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf, - unsigned tap_bits, tap_state_t next_state) -{ - const u8 *tms_buffer; - const u8 *tdi_buffer; - unsigned tap_bytes; - unsigned cur_byte; - unsigned cur_bit; - - unsigned tap_out_bits; - char tms_str[33]; - char tdi_str[33]; - - tap_state_t last_state; - - // set startstate (and possibly last, if tap_bits == 0) - last_state = next_state; - DEBUG_JTAG_IO("TAP/SM: START state: %s", tap_state_name(next_state)); - - tms_buffer = (const u8 *)tms_buf; - tdi_buffer = (const u8 *)tdi_buf; - - tap_bytes = TAP_SCAN_BYTES(tap_bits); - DEBUG_JTAG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits, tap_bytes); - - tap_out_bits = 0; - for(cur_byte = 0; cur_byte < tap_bytes; cur_byte++) - { - for(cur_bit = 0; cur_bit < 8; cur_bit++) - { - // make sure we do not run off the end of the buffers - unsigned tap_bit = cur_byte * 8 + cur_bit; - if (tap_bit == tap_bits) - break; - - // check and save TMS bit - tap_bit = !!(tms_buffer[cur_byte] & (1 << cur_bit)); - JTAG_DEBUG_STATE_APPEND(tms_str, tap_out_bits, tap_bit); - - // use TMS bit to find the next TAP state - next_state = tap_state_transition(last_state, tap_bit); - - // check and store TDI bit - tap_bit = !!(tdi_buffer[cur_byte] & (1 << cur_bit)); - JTAG_DEBUG_STATE_APPEND(tdi_str, tap_out_bits, tap_bit); - - // increment TAP bits - tap_out_bits++; - - // Only show TDO bits on state transitions, or - // after some number of bits in the same state. - if ((next_state == last_state) && (tap_out_bits < 32)) - continue; - - // terminate strings and display state transition - tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0; - JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str); - - // reset state - last_state = next_state; - tap_out_bits = 0; - } - } - - if (tap_out_bits) - { - // terminate strings and display state transition - tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0; - JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str); - } - - DEBUG_JTAG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state)); - - return next_state; -} -#endif // _DEBUG_JTAG_IO_ - -#ifndef HAVE_JTAG_MINIDRIVER_H -void jtag_alloc_in_value32(scan_field_t *field) -{ - field->in_value=(u8 *)cmd_queue_alloc(4); -} -#endif - static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { + if (argc > 1) + return ERROR_COMMAND_SYNTAX_ERROR; + if (argc == 1) { + bool use_new_table; if (strcmp(args[0], "short") == 0) - { - tms_seqs=&short_tms_seqs; - } + use_new_table = true; else if (strcmp(args[0], "long") == 0) - { - tms_seqs=&old_tms_seqs; - } else - { + use_new_table = false; + else return ERROR_COMMAND_SYNTAX_ERROR; - } - } else if (argc != 0) - { - return ERROR_COMMAND_SYNTAX_ERROR; + + tap_use_new_tms_table(use_new_table); } - command_print(cmd_ctx, "tms sequence is %s", (tms_seqs==&short_tms_seqs) ? "short": "long"); + command_print(cmd_ctx, "tms sequence is %s", + tap_uses_new_tms_table() ? "short": "long"); return ERROR_OK; } -/*-------------------------------------------*/ - - /** * Function jtag_add_statemove * moves from the current state to the goal \a state. This needs @@ -3826,7 +2662,7 @@ int jtag_add_statemove(tap_state_t goal_state) jtag_add_pathmove(tms_count, moves); } - /* else state must be immediately reachable in one clock cycle, and does not + /* else state must be immediately reachable in one clock cycle, and does not need to be a stable state. */ else if( tap_state_transition(cur_state, true) == goal_state