X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fcore.c;h=09f62c3052920b511d6e3f315f903225421c9bac;hp=eee20119ae102236850c0764b60e684f5a543837;hb=128a73342856217e98a5da64b2805e062fd4e00d;hpb=66707c94d7a34e99d77a032223e42909005a563e diff --git a/src/jtag/core.c b/src/jtag/core.c index eee20119ae..09f62c3052 100644 --- a/src/jtag/core.c +++ b/src/jtag/core.c @@ -46,25 +46,27 @@ static int jtag_flush_queue_count; 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); -/* note that this is not marked as static as it must be available from outside jtag.c for those - that implement the jtag_xxx() minidriver layer -*/ -int jtag_error=ERROR_OK; +/** + * The jtag_error variable is set when an error occurs while executing + * the queue. Application code may set this using jtag_set_error(), + * when an error occurs during processing that should be reported during + * jtag_execute_queue(). + * + * Tts value may be checked with jtag_get_error() and cleared with + * jtag_error_clear(). This value is returned (and cleared) by + * jtag_execute_queue(). + */ +static int jtag_error = ERROR_OK; -char* jtag_event_strings[] = +static const char *jtag_event_strings[] = { - "JTAG controller reset (RESET or TRST)" -}; - -const Jim_Nvp nvp_jtag_tap_event[] = { - { .value = JTAG_TAP_EVENT_ENABLE, .name = "tap-enable" }, - { .value = JTAG_TAP_EVENT_DISABLE, .name = "tap-disable" }, - - { .name = NULL, .value = -1 } + [JTAG_TRST_ASSERTED] = "JTAG controller reset (RESET or TRST)", + [JTAG_TAP_EVENT_ENABLE] = "TAP enabled", + [JTAG_TAP_EVENT_DISABLE] = "TAP disabled", }; -int jtag_trst = 0; -int jtag_srst = 0; +static int jtag_trst = 0; +static int jtag_srst = 0; /** * List all TAPs that have been created. @@ -76,30 +78,55 @@ static jtag_tap_t *__jtag_all_taps = NULL; */ static unsigned jtag_num_taps = 0; -enum reset_types jtag_reset_config = RESET_NONE; -tap_state_t cmd_queue_end_state = TAP_RESET; +static enum reset_types jtag_reset_config = RESET_NONE; +static tap_state_t cmd_queue_end_state = TAP_RESET; tap_state_t cmd_queue_cur_state = TAP_RESET; -int jtag_verify_capture_ir = 1; -int jtag_verify = 1; +static bool jtag_verify_capture_ir = true; +static int jtag_verify = 1; /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */ static int jtag_nsrst_delay = 0; /* default to no nSRST delay */ static int jtag_ntrst_delay = 0; /* default to no nTRST delay */ +typedef struct jtag_event_callback_s +{ + jtag_event_handler_t callback; + void* priv; + struct jtag_event_callback_s* next; +} jtag_event_callback_t; + /* callbacks to inform high-level handlers about JTAG state changes */ -jtag_event_callback_t *jtag_event_callbacks; +static jtag_event_callback_t *jtag_event_callbacks; /* speed in kHz*/ static int speed_khz = 0; /* flag if the kHz speed was defined */ static bool hasKHz = false; +static int jtag_speed = 0; -struct jtag_interface_s *jtag = NULL; +static struct jtag_interface_s *jtag = NULL; /* configuration */ jtag_interface_t *jtag_interface = NULL; -int jtag_speed = 0; + +void jtag_set_error(int error) +{ + if ((error == ERROR_OK) || (jtag_error != ERROR_OK)) + return; + jtag_error = error; +} +int jtag_get_error(void) +{ + return jtag_error; +} +int jtag_error_clear(void) +{ + int temp = jtag_error; + jtag_error = ERROR_OK; + return temp; +} + jtag_tap_t *jtag_all_taps(void) { @@ -115,7 +142,7 @@ unsigned jtag_tap_count_enabled(void) { jtag_tap_t *t = jtag_all_taps(); unsigned n = 0; - while(t) + while (t) { if (t->enabled) n++; @@ -130,7 +157,7 @@ void jtag_tap_add(struct jtag_tap_s *t) t->abs_chain_position = jtag_num_taps++; jtag_tap_t **tap = &__jtag_all_taps; - while(*tap != NULL) + while (*tap != NULL) tap = &(*tap)->next_tap; *tap = t; } @@ -147,9 +174,8 @@ jtag_tap_t *jtag_tap_by_string(const char *s) } /* no tap found by name, so try to parse the name as a number */ - char *cp; - unsigned n = strtoul(s, &cp, 0); - if ((s == cp) || (*cp != 0)) + unsigned n; + if (parse_uint(s, &n) != ERROR_OK) return NULL; return jtag_tap_by_position(n); @@ -177,13 +203,25 @@ jtag_tap_t *jtag_tap_by_position(unsigned n) return t; } +jtag_tap_t* jtag_tap_next_enabled(jtag_tap_t* p) +{ + p = p ? p->next_tap : jtag_all_taps(); + while (p) + { + if (p->enabled) + return p; + p = p->next_tap; + } + return NULL; +} + const char *jtag_tap_name(const jtag_tap_t *tap) { return (tap == NULL) ? "(unknown)" : tap->dotted_name; } -int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv) +int jtag_register_event_callback(jtag_event_handler_t callback, void *priv) { jtag_event_callback_t **callbacks_p = &jtag_event_callbacks; @@ -207,24 +245,30 @@ int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *pr return ERROR_OK; } -int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv)) +int jtag_unregister_event_callback(jtag_event_handler_t callback, void *priv) { - jtag_event_callback_t **callbacks_p = &jtag_event_callbacks; + jtag_event_callback_t **callbacks_p; + jtag_event_callback_t **next; if (callback == NULL) { return ERROR_INVALID_ARGUMENTS; } - while (*callbacks_p) + for (callbacks_p = &jtag_event_callbacks; + *callbacks_p != NULL; + callbacks_p = next) { - jtag_event_callback_t **next = &((*callbacks_p)->next); + next = &((*callbacks_p)->next); + + if ((*callbacks_p)->priv != priv) + continue; + if ((*callbacks_p)->callback == callback) { free(*callbacks_p); *callbacks_p = *next; } - callbacks_p = next; } return ERROR_OK; @@ -238,8 +282,12 @@ int jtag_call_event_callbacks(enum jtag_event event) while (callback) { + jtag_event_callback_t *next; + + /* callback may remove itself */ + next = callback->next; callback->callback(event, callback->priv); - callback = callback->next; + callback = next; } return ERROR_OK; @@ -254,7 +302,7 @@ static void jtag_prelude(tap_state_t state) { jtag_checks(); - assert(state!=TAP_INVALID); + assert(state != TAP_INVALID); cmd_queue_cur_state = state; } @@ -276,7 +324,7 @@ void jtag_add_ir_scan_noverify(int in_count, const scan_field_t *in_fields, void jtag_add_ir_scan(int in_num_fields, scan_field_t *in_fields, tap_state_t state) { - if (jtag_verify&&jtag_verify_capture_ir) + if (jtag_verify && jtag_verify_capture_ir) { /* 8 x 32 bit id's is enough for all invocations */ @@ -305,23 +353,23 @@ void jtag_add_plain_ir_scan(int in_num_fields, const scan_field_t *in_fields, jtag_set_error(retval); } -void jtag_add_callback(jtag_callback1_t f, u8 *in) +void jtag_add_callback(jtag_callback1_t f, jtag_callback_data_t data0) { - interface_jtag_add_callback(f, in); + interface_jtag_add_callback(f, data0); } -void jtag_add_callback4(jtag_callback_t f, u8 *in, +void jtag_add_callback4(jtag_callback_t f, jtag_callback_data_t data0, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3) { - interface_jtag_add_callback4(f, in, data1, data2, data3); + interface_jtag_add_callback4(f, data0, data1, data2, data3); } -int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits); +int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value, uint8_t *in_check_mask, int num_bits); -static int jtag_check_value_mask_callback(u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3) +static int jtag_check_value_mask_callback(jtag_callback_data_t data0, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3) { - return jtag_check_value_inner(in, (u8 *)data1, (u8 *)data2, (int)data3); + return jtag_check_value_inner((uint8_t *)data0, (uint8_t *)data1, (uint8_t *)data2, (int)data3); } static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state), @@ -345,7 +393,7 @@ static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const s if ((in_fields[i].check_value != NULL) && (in_fields[i].in_value != NULL)) { /* this is synchronous for a minidriver */ - jtag_add_callback4(jtag_check_value_mask_callback, in_fields[i].in_value, + jtag_add_callback4(jtag_check_value_mask_callback, (jtag_callback_data_t)in_fields[i].in_value, (jtag_callback_data_t)in_fields[i].check_value, (jtag_callback_data_t)in_fields[i].check_mask, (jtag_callback_data_t)in_fields[i].num_bits); @@ -394,7 +442,7 @@ void jtag_add_plain_dr_scan(int in_num_fields, const scan_field_t *in_fields, } void jtag_add_dr_out(jtag_tap_t* tap, - int num_fields, const int* num_bits, const u32* value, + int num_fields, const int* num_bits, const uint32_t* value, tap_state_t end_state) { assert(end_state != TAP_INVALID); @@ -451,6 +499,50 @@ void jtag_add_pathmove(int num_states, const tap_state_t *path) cmd_queue_cur_state = path[num_states - 1]; } +int jtag_add_statemove(tap_state_t goal_state) +{ + tap_state_t cur_state = cmd_queue_cur_state; + + LOG_DEBUG( "cur_state=%s goal_state=%s", + tap_state_name(cur_state), + tap_state_name(goal_state) ); + + + if (goal_state==cur_state ) + ; /* nothing to do */ + else if ( goal_state==TAP_RESET ) + { + jtag_add_tlr(); + } + else if ( tap_is_state_stable(cur_state) && tap_is_state_stable(goal_state) ) + { + unsigned tms_bits = tap_get_tms_path(cur_state, goal_state); + unsigned tms_count = tap_get_tms_path_len(cur_state, goal_state); + tap_state_t moves[8]; + assert(tms_count < DIM(moves)); + + for (unsigned i = 0; i < tms_count; i++, tms_bits >>= 1) + { + bool bit = tms_bits & 1; + + cur_state = tap_state_transition(cur_state, bit); + moves[i] = cur_state; + } + + jtag_add_pathmove(tms_count, moves); + } + else if ( tap_state_transition(cur_state, true) == goal_state + || tap_state_transition(cur_state, false) == goal_state ) + { + jtag_add_pathmove(1, &goal_state); + } + + else + return ERROR_FAIL; + + return ERROR_OK; +} + void jtag_add_runtest(int num_cycles, tap_state_t state) { jtag_prelude(state); @@ -487,9 +579,9 @@ void jtag_add_reset(int req_tlr_or_trst, int req_srst) ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)) { if (((req_tlr_or_trst&&!jtag_trst)|| - (!req_tlr_or_trst&&jtag_trst))&& + (!req_tlr_or_trst && jtag_trst))&& ((req_srst&&!jtag_srst)|| - (!req_srst&&jtag_srst))) + (!req_srst && jtag_srst))) { /* FIX!!! srst_pulls_trst allows 1,1 => 0,0 transition.... */ //LOG_ERROR("BUG: transition of req_tlr_or_trst and req_srst in the same jtag_add_reset() call is undefined"); @@ -584,7 +676,7 @@ tap_state_t jtag_set_end_state(tap_state_t state) LOG_ERROR("BUG: TAP_DRSHIFT/IRSHIFT can't be end state. Calling code should use a larger scan field"); } - if (state!=TAP_INVALID) + if (state != TAP_INVALID) cmd_queue_end_state = state; return cmd_queue_end_state; } @@ -594,14 +686,14 @@ tap_state_t jtag_get_end_state(void) return cmd_queue_end_state; } -void jtag_add_sleep(u32 us) +void jtag_add_sleep(uint32_t us) { /// @todo Here, keep_alive() appears to be a layering violation!!! keep_alive(); jtag_set_error(interface_jtag_add_sleep(us)); } -int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits) +int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value, uint8_t *in_check_mask, int num_bits) { int retval = ERROR_OK; @@ -650,7 +742,7 @@ int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, return retval; } -void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask) +void jtag_check_value_mask(scan_field_t *field, uint8_t *value, uint8_t *mask) { assert(field->in_value != NULL); @@ -706,6 +798,8 @@ static int jtag_reset_callback(enum jtag_event event, void *priv) if (event == JTAG_TRST_ASSERTED) { + tap->enabled = !tap->disabled_after_reset; + buf_set_ones(tap->cur_instr, tap->ir_length); tap->bypass = 1; } @@ -713,7 +807,7 @@ static int jtag_reset_callback(enum jtag_event event, void *priv) return ERROR_OK; } -void jtag_sleep(u32 us) +void jtag_sleep(uint32_t us) { alive_sleep(us/1000); } @@ -725,7 +819,7 @@ void jtag_sleep(u32 us) #define EXTRACT_PART(X) (((X) & 0xffff000) >> 12) #define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28) -static int jtag_examine_chain_execute(u8 *idcode_buffer, unsigned num_idcode) +static int jtag_examine_chain_execute(uint8_t *idcode_buffer, unsigned num_idcode) { scan_field_t field = { .tap = NULL, @@ -742,10 +836,10 @@ static int jtag_examine_chain_execute(u8 *idcode_buffer, unsigned num_idcode) return jtag_execute_queue(); } -static bool jtag_examine_chain_check(u8 *idcodes, unsigned count) +static bool jtag_examine_chain_check(uint8_t *idcodes, unsigned count) { - u8 zero_check = 0x0; - u8 one_check = 0xff; + uint8_t zero_check = 0x0; + uint8_t one_check = 0xff; for (unsigned i = 0; i < count * 4; i++) { @@ -765,16 +859,19 @@ static bool jtag_examine_chain_check(u8 *idcodes, unsigned count) } static void jtag_examine_chain_display(enum log_levels level, const char *msg, - const char *name, u32 idcode) + const char *name, uint32_t idcode) { log_printf_lf(level, __FILE__, __LINE__, __FUNCTION__, - "JTAG tap: %s %16.16s: 0x%08x " - "(mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)", - name, msg, idcode, - EXTRACT_MFG(idcode), EXTRACT_PART(idcode), EXTRACT_VER(idcode) ); + "JTAG tap: %s %16.16s: 0x%08x " + "(mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)", + name, msg, + (unsigned int)idcode, + (unsigned int)EXTRACT_MFG(idcode), + (unsigned int)EXTRACT_PART(idcode), + (unsigned int)EXTRACT_VER(idcode) ); } -static bool jtag_idcode_is_final(u32 idcode) +static bool jtag_idcode_is_final(uint32_t idcode) { return idcode == 0x000000FF || idcode == 0xFFFFFFFF; } @@ -785,17 +882,17 @@ static bool jtag_idcode_is_final(u32 idcode) * read back correctly. This can help identify and diagnose problems * with the JTAG chain earlier, gives more helpful/explicit error messages. */ -static void jtag_examine_chain_end(u8 *idcodes, unsigned count, unsigned max) +static void jtag_examine_chain_end(uint8_t *idcodes, unsigned count, unsigned max) { bool triggered = false; for ( ; count < max - 31; count += 32) { - u32 idcode = buf_get_u32(idcodes, count, 32); + uint32_t idcode = buf_get_u32(idcodes, count, 32); // do not trigger the warning if the data looks good if (!triggered && jtag_idcode_is_final(idcode)) continue; LOG_WARNING("Unexpected idcode after end of chain: %d 0x%08x", - count, idcode); + count, (unsigned int)idcode); triggered = true; } } @@ -813,7 +910,7 @@ static bool jtag_examine_chain_match_tap(const struct jtag_tap_s *tap) } /* Loop over the expected identification codes and test for a match */ - u8 ii; + uint8_t ii; for (ii = 0; ii < tap->expected_ids_cnt; ii++) { if (tap->idcode == tap->expected_ids[ii]) @@ -843,7 +940,7 @@ static bool jtag_examine_chain_match_tap(const struct jtag_tap_s *tap) */ int jtag_examine_chain(void) { - u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4]; + uint8_t idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4]; unsigned device_count = 0; jtag_examine_chain_execute(idcode_buffer, JTAG_MAX_CHAIN_SIZE); @@ -861,7 +958,7 @@ int jtag_examine_chain(void) for (unsigned bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;) { - u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32); + uint32_t idcode = buf_get_u32(idcode_buffer, bit_count, 32); if ((idcode & 1) == 0) { /* LSB must not be 0, this indicates a device in bypass */ @@ -921,15 +1018,15 @@ int jtag_validate_chain(void) { jtag_tap_t *tap; int total_ir_length = 0; - u8 *ir_test = NULL; + uint8_t *ir_test = NULL; scan_field_t field; int chain_pos = 0; tap = NULL; total_ir_length = 0; - for(;;){ + for (;;){ tap = jtag_tap_next_enabled(tap); - if( tap == NULL ){ + if ( tap == NULL ){ break; } total_ir_length += tap->ir_length; @@ -951,9 +1048,9 @@ int jtag_validate_chain(void) tap = NULL; chain_pos = 0; int val; - for(;;){ + for (;;){ tap = jtag_tap_next_enabled(tap); - if( tap == NULL ){ + if ( tap == NULL ){ break; } @@ -993,6 +1090,7 @@ void jtag_tap_init(jtag_tap_t *tap) tap->expected_mask = malloc(tap->ir_length); tap->cur_instr = malloc(tap->ir_length); + /// @todo cope sanely with ir_length bigger than 32 bits buf_set_u32(tap->expected, 0, tap->ir_length, tap->ir_capture_value); buf_set_u32(tap->expected_mask, 0, tap->ir_length, tap->ir_capture_mask); buf_set_ones(tap->cur_instr, tap->ir_length); @@ -1005,12 +1103,14 @@ void jtag_tap_init(jtag_tap_t *tap) LOG_DEBUG("Created Tap: %s @ abs position %d, " "irlen %d, capture: 0x%x mask: 0x%x", tap->dotted_name, tap->abs_chain_position, tap->ir_length, - tap->ir_capture_value, tap->ir_capture_mask); + (unsigned int)(tap->ir_capture_value), (unsigned int)(tap->ir_capture_mask)); jtag_tap_add(tap); } void jtag_tap_free(jtag_tap_t *tap) { + jtag_unregister_event_callback(&jtag_reset_callback, tap); + /// @todo is anything missing? no memory leaks please free((void *)tap->expected_ids); free((void *)tap->chip); @@ -1030,7 +1130,7 @@ int jtag_interface_init(struct command_context_s *cmd_ctx) LOG_ERROR("JTAG interface has to be specified, see \"interface\" command"); return ERROR_JTAG_INVALID_INTERFACE; } - if(hasKHz) + if (hasKHz) { jtag_interface->khz(jtag_get_speed_khz(), &jtag_speed); hasKHz = false; @@ -1051,13 +1151,13 @@ static int jtag_init_inner(struct command_context_s *cmd_ctx) LOG_DEBUG("Init JTAG chain"); tap = jtag_tap_next_enabled(NULL); - if( tap == NULL ){ + if ( tap == NULL ){ LOG_ERROR("There are no enabled taps?"); return ERROR_JTAG_INIT_FAILED; } jtag_add_tlr(); - if ((retval=jtag_execute_queue())!=ERROR_OK) + if ((retval=jtag_execute_queue()) != ERROR_OK) return retval; /* examine chain first, as this could discover the real chain layout */ @@ -1153,6 +1253,46 @@ unsigned jtag_get_speed_khz(void) { return speed_khz; } +int jtag_config_khz(unsigned khz) +{ + LOG_DEBUG("handle jtag khz"); + jtag_set_speed_khz(khz); + + int cur_speed = 0; + if (jtag != NULL) + { + LOG_DEBUG("have interface set up"); + int speed_div1; + int retval = jtag->khz(jtag_get_speed_khz(), &speed_div1); + if (ERROR_OK != retval) + { + jtag_set_speed_khz(0); + return retval; + } + cur_speed = speed_div1; + } + return jtag_set_speed(cur_speed); +} + +int jtag_get_speed(void) +{ + return jtag_speed; +} + +int jtag_set_speed(int speed) +{ + jtag_speed = speed; + /* this command can be called during CONFIG, + * in which case jtag isn't initialized */ + hasKHz = !jtag; + return jtag ? jtag->speed(speed) : ERROR_OK; +} + +int jtag_get_speed_readable(int *speed) +{ + return jtag ? jtag->speed_div(jtag_get_speed(), speed) : ERROR_OK; +} + void jtag_set_verify(bool enable) { @@ -1164,6 +1304,15 @@ bool jtag_will_verify() return jtag_verify; } +void jtag_set_verify_capture_ir(bool enable) +{ + jtag_verify_capture_ir = enable; +} + +bool jtag_will_verify_capture_ir() +{ + return jtag_verify_capture_ir; +} int jtag_power_dropout(int *dropout) { @@ -1175,79 +1324,22 @@ int jtag_srst_asserted(int *srst_asserted) return jtag->srst_asserted(srst_asserted); } -void jtag_tap_handle_event( jtag_tap_t * tap, enum jtag_tap_event e) +enum reset_types jtag_get_reset_config(void) { - jtag_tap_event_action_t * jteap; - int done; - - jteap = tap->event_action; - - done = 0; - while (jteap) { - if (jteap->event == e) { - done = 1; - LOG_DEBUG( "JTAG tap: %s event: %d (%s) action: %s\n", - tap->dotted_name, - e, - Jim_Nvp_value2name_simple(nvp_jtag_tap_event, e)->name, - Jim_GetString(jteap->body, NULL) ); - if (Jim_EvalObj(interp, jteap->body) != JIM_OK) { - Jim_PrintErrorMessage(interp); - } - } - - jteap = jteap->next; - } - - if (!done) { - LOG_DEBUG( "event %d %s - no action", - e, - Jim_Nvp_value2name_simple( nvp_jtag_tap_event, e)->name); - } + return jtag_reset_config; } - -int jtag_add_statemove(tap_state_t goal_state) +void jtag_set_reset_config(enum reset_types type) { - tap_state_t cur_state = cmd_queue_cur_state; - - LOG_DEBUG( "cur_state=%s goal_state=%s", - tap_state_name(cur_state), - tap_state_name(goal_state) ); - - - if (goal_state==cur_state ) - ; /* nothing to do */ - else if( goal_state==TAP_RESET ) - { - jtag_add_tlr(); - } - else if( tap_is_state_stable(cur_state) && tap_is_state_stable(goal_state) ) - { - unsigned tms_bits = tap_get_tms_path(cur_state, goal_state); - unsigned tms_count = tap_get_tms_path_len(cur_state, goal_state); - tap_state_t moves[8]; - assert(tms_count < DIM(moves)); - - for (unsigned i = 0; i < tms_count; i++, tms_bits >>= 1) - { - bool bit = tms_bits & 1; - - cur_state = tap_state_transition(cur_state, bit); - moves[i] = cur_state; - } - - jtag_add_pathmove(tms_count, moves); - } - else if( tap_state_transition(cur_state, true) == goal_state - || tap_state_transition(cur_state, false) == goal_state ) - { - jtag_add_pathmove(1, &goal_state); - } - - else - return ERROR_FAIL; + jtag_reset_config = type; +} - return ERROR_OK; +int jtag_get_trst(void) +{ + return jtag_trst; +} +int jtag_get_srst(void) +{ + return jtag_srst; } void jtag_set_nsrst_delay(unsigned delay)