X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fjtag%2Fcore.c;h=3021a10306a5edb62e15061f63799db51fa93b4a;hb=0de530067f2a524bc483d958a105b1efb1ab6a86;hp=a8d65f1e59000ddf21d42a1f9a0fad55a41cf706;hpb=a0c10dd29b84e7e9238fa6652c8f7cea3c14fc14;p=openocd.git diff --git a/src/jtag/core.c b/src/jtag/core.c index a8d65f1e59..3021a10306 100644 --- a/src/jtag/core.c +++ b/src/jtag/core.c @@ -2,7 +2,7 @@ * Copyright (C) 2005 by Dominic Rath * * Dominic.Rath@gmx.de * * * - * Copyright (C) 2007,2008 Øyvind Harboe * + * Copyright (C) 2007,2008 Øyvind Harboe * * oyvind.harboe@zylin.com * * * * Copyright (C) 2009 SoftPLC Corporation * @@ -60,11 +60,15 @@ static int jtag_error = ERROR_OK; static const char *jtag_event_strings[] = { - [JTAG_TRST_ASSERTED] = "JTAG controller reset (RESET or TRST)", + [JTAG_TRST_ASSERTED] = "JTAG controller reset (TLR or TRST)", [JTAG_TAP_EVENT_ENABLE] = "TAP enabled", [JTAG_TAP_EVENT_DISABLE] = "TAP disabled", }; +/* + * JTAG adapters must initialize with TRST and SRST de-asserted + * (they're negative logic, so that means *high*) + */ static int jtag_trst = 0; static int jtag_srst = 0; @@ -101,8 +105,9 @@ 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; +/* speed to fallback to when RCLK is requested but not supported */ +static int rclk_fallback_speed_khz = 0; +static enum {CLOCK_MODE_SPEED, CLOCK_MODE_KHZ, CLOCK_MODE_RCLK} clock_mode; static int jtag_speed = 0; static struct jtag_interface_s *jtag = NULL; @@ -142,7 +147,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++; @@ -157,15 +162,27 @@ 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; } +/* returns a pointer to the n-th device in the scan chain */ +static inline jtag_tap_t *jtag_tap_by_position(unsigned n) +{ + jtag_tap_t *t = jtag_all_taps(); + + while (t && n-- > 0) + t = t->next_tap; + + return t; +} + jtag_tap_t *jtag_tap_by_string(const char *s) { /* try by name first */ jtag_tap_t *t = jtag_all_taps(); + while (t) { if (0 == strcmp(t->dotted_name, s)) @@ -178,7 +195,16 @@ jtag_tap_t *jtag_tap_by_string(const char *s) if (parse_uint(s, &n) != ERROR_OK) return NULL; - return jtag_tap_by_position(n); + /* FIXME remove this numeric fallback code late June 2010, along + * with all info in the User's Guide that TAPs have numeric IDs. + * Also update "scan_chain" output to not display the numbers. + */ + t = jtag_tap_by_position(n); + if (t) + LOG_WARNING("Specify TAP '%s' by name, not number %u", + t->dotted_name, n); + + return t; } jtag_tap_t *jtag_tap_by_jim_obj(Jim_Interp *interp, Jim_Obj *o) @@ -192,17 +218,6 @@ jtag_tap_t *jtag_tap_by_jim_obj(Jim_Interp *interp, Jim_Obj *o) return t; } -/* returns a pointer to the n-th device in the scan chain */ -jtag_tap_t *jtag_tap_by_position(unsigned n) -{ - jtag_tap_t *t = jtag_all_taps(); - - while (t && n-- > 0) - t = t->next_tap; - - return t; -} - jtag_tap_t* jtag_tap_next_enabled(jtag_tap_t* p) { p = p ? p->next_tap : jtag_all_taps(); @@ -282,8 +297,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; @@ -298,7 +317,7 @@ static void jtag_prelude(tap_state_t state) { jtag_checks(); - assert(state!=TAP_INVALID); + assert(state != TAP_INVALID); cmd_queue_cur_state = state; } @@ -320,7 +339,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 */ @@ -329,8 +348,8 @@ void jtag_add_ir_scan(int in_num_fields, scan_field_t *in_fields, tap_state_t st /* if we are to run a verification of the ir scan, we need to get the input back. * We may have to allocate space if the caller didn't ask for the input back. */ - in_fields[j].check_value=in_fields[j].tap->expected; - in_fields[j].check_mask=in_fields[j].tap->expected_mask; + in_fields[j].check_value = in_fields[j].tap->expected; + in_fields[j].check_mask = in_fields[j].tap->expected_mask; } jtag_add_scan_check(jtag_add_ir_scan_noverify, in_num_fields, in_fields, state); } else @@ -349,23 +368,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), @@ -389,7 +408,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); @@ -438,7 +457,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); @@ -478,7 +497,7 @@ void jtag_add_pathmove(int num_states, const tap_state_t *path) return; } - if ( tap_state_transition(cur_state, true) != path[i] + if (tap_state_transition(cur_state, true) != path[i] && tap_state_transition(cur_state, false) != path[i]) { LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", @@ -499,18 +518,18 @@ 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", + LOG_DEBUG("cur_state=%s goal_state=%s", tap_state_name(cur_state), - tap_state_name(goal_state) ); + tap_state_name(goal_state)); - if (goal_state==cur_state ) + if (goal_state == cur_state) ; /* nothing to do */ - else if( goal_state==TAP_RESET ) + else if (goal_state == TAP_RESET) { jtag_add_tlr(); } - else if( tap_is_state_stable(cur_state) && tap_is_state_stable(goal_state) ) + 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); @@ -527,8 +546,8 @@ int jtag_add_statemove(tap_state_t goal_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 ) + else if (tap_state_transition(cur_state, true) == goal_state + || tap_state_transition(cur_state, false) == goal_state) { jtag_add_pathmove(1, &goal_state); } @@ -566,102 +585,105 @@ void jtag_add_clocks(int num_cycles) void jtag_add_reset(int req_tlr_or_trst, int req_srst) { int trst_with_tlr = 0; + int new_srst = 0; + int new_trst = 0; - /* FIX!!! there are *many* different cases here. A better - * approach is needed for legal combinations of transitions... + /* Without SRST, we must use target-specific JTAG operations + * on each target; callers should not be requesting SRST when + * that signal doesn't exist. + * + * RESET_SRST_PULLS_TRST is a board or chip level quirk, which + * can kick in even if the JTAG adapter can't drive TRST. */ - if ((jtag_reset_config & RESET_HAS_SRST)&& - (jtag_reset_config & RESET_HAS_TRST)&& - ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0)) - { - if (((req_tlr_or_trst&&!jtag_trst)|| - (!req_tlr_or_trst&&jtag_trst))&& - ((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"); + if (req_srst) { + if (!(jtag_reset_config & RESET_HAS_SRST)) { + LOG_ERROR("BUG: can't assert SRST"); + jtag_set_error(ERROR_FAIL); + return; } + if ((jtag_reset_config & RESET_SRST_PULLS_TRST) != 0 + && !req_tlr_or_trst) { + LOG_ERROR("BUG: can't assert only SRST"); + jtag_set_error(ERROR_FAIL); + return; + } + new_srst = 1; } - /* Make sure that jtag_reset_config allows the requested reset */ - /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */ - if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst)) - { - LOG_ERROR("BUG: requested reset would assert trst"); - jtag_set_error(ERROR_FAIL); - return; + /* JTAG reset (entry to TAP_RESET state) can always be achieved + * using TCK and TMS; that may go through a TAP_{IR,DR}UPDATE + * state first. TRST accelerates it, and bypasses those states. + * + * RESET_TRST_PULLS_SRST is a board or chip level quirk, which + * can kick in even if the JTAG adapter can't drive SRST. + */ + if (req_tlr_or_trst) { + if (!(jtag_reset_config & RESET_HAS_TRST)) + trst_with_tlr = 1; + else if ((jtag_reset_config & RESET_TRST_PULLS_SRST) != 0 + && !req_srst) + trst_with_tlr = 1; + else + new_trst = 1; } - /* if TRST pulls SRST, we reset with TAP T-L-R */ - if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0)) - { - trst_with_tlr = 1; - } + /* Maybe change TRST and/or SRST signal state */ + if (jtag_srst != new_srst || jtag_trst != new_trst) { + int retval; - if (req_srst && !(jtag_reset_config & RESET_HAS_SRST)) - { - LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this"); - jtag_set_error(ERROR_FAIL); - return; - } + retval = interface_jtag_add_reset(new_trst, new_srst); + if (retval != ERROR_OK) + jtag_set_error(retval); + else + retval = jtag_execute_queue(); - if (req_tlr_or_trst) - { - if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST)) - { - jtag_trst = 1; - } else - { - trst_with_tlr = 1; + if (retval != ERROR_OK) { + LOG_ERROR("TRST/SRST error %d", retval); + return; } - } else - { - jtag_trst = 0; } - jtag_srst = req_srst; - - int retval = interface_jtag_add_reset(jtag_trst, jtag_srst); - if (retval != ERROR_OK) - { - jtag_set_error(retval); - return; - } - jtag_execute_queue(); - - if (jtag_srst) - { - LOG_DEBUG("SRST line asserted"); - } - else - { - LOG_DEBUG("SRST line released"); - if (jtag_nsrst_delay) - jtag_add_sleep(jtag_nsrst_delay * 1000); + /* SRST resets everything hooked up to that signal */ + if (jtag_srst != new_srst) { + jtag_srst = new_srst; + if (jtag_srst) + LOG_DEBUG("SRST line asserted"); + else { + LOG_DEBUG("SRST line released"); + if (jtag_nsrst_delay) + jtag_add_sleep(jtag_nsrst_delay * 1000); + } } - if (trst_with_tlr) - { - LOG_DEBUG("JTAG reset with RESET instead of TRST"); + /* Maybe enter the JTAG TAP_RESET state ... + * - using only TMS, TCK, and the JTAG state machine + * - or else more directly, using TRST + * + * TAP_RESET should be invisible to non-debug parts of the system. + */ + if (trst_with_tlr) { + LOG_DEBUG("JTAG reset with TLR instead of TRST"); jtag_set_end_state(TAP_RESET); jtag_add_tlr(); - return; - } - if (jtag_trst) - { - /* we just asserted nTRST, so we're now in Test-Logic-Reset, - * and inform possible listeners about this - */ - 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); + } else if (jtag_trst != new_trst) { + jtag_trst = new_trst; + if (jtag_trst) { + /* we just asserted nTRST, so we're now in TAP_RESET; + * inform possible listeners about this + * + * REVISIT asserting TRST is less significant than + * being in TAP_RESET ... both entries (TRST, TLR) + * should trigger a callback. + */ + LOG_DEBUG("TRST line asserted"); + tap_set_state(TAP_RESET); + jtag_call_event_callbacks(JTAG_TRST_ASSERTED); + } else { + LOG_DEBUG("TRST line released"); + if (jtag_ntrst_delay) + jtag_add_sleep(jtag_ntrst_delay * 1000); + } } } @@ -672,7 +694,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; } @@ -682,14 +704,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; @@ -700,7 +722,7 @@ int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, else compare_failed = buf_cmp(captured, in_check_value, num_bits); - if (compare_failed){ + if (compare_failed) { /* An error handler could have caught the failing check * only report a problem when there wasn't a handler, or if the handler * acknowledged the error @@ -738,11 +760,11 @@ 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); - if (value==NULL) + if (value == NULL) { /* no checking to do */ return; @@ -750,7 +772,7 @@ void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask) jtag_execute_queue_noclear(); - int retval=jtag_check_value_inner(field->in_value, value, mask, field->num_bits); + int retval = jtag_check_value_inner(field->in_value, value, mask, field->num_bits); jtag_set_error(retval); } @@ -796,6 +818,7 @@ static int jtag_reset_callback(enum jtag_event event, void *priv) { tap->enabled = !tap->disabled_after_reset; + /* current instruction is either BYPASS or IDCODE */ buf_set_ones(tap->cur_instr, tap->ir_length); tap->bypass = 1; } @@ -803,7 +826,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); } @@ -815,7 +838,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, @@ -832,10 +855,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++) { @@ -855,16 +878,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; } @@ -875,17 +901,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) + 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; } } @@ -903,7 +929,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]) @@ -913,7 +939,7 @@ static bool jtag_examine_chain_match_tap(const struct jtag_tap_s *tap) /* If none of the expected ids matched, log an error */ if (ii != tap->expected_ids_cnt) { - LOG_INFO("JTAG Tap/device matched"); + LOG_DEBUG("JTAG Tap/device matched"); return true; } jtag_examine_chain_display(LOG_LVL_ERROR, "got", @@ -933,7 +959,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); @@ -951,12 +977,14 @@ 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); + tap->hasidcode = true; if ((idcode & 1) == 0) { /* LSB must not be 0, this indicates a device in bypass */ LOG_WARNING("Tap/Device does not have IDCODE"); idcode = 0; + tap->hasidcode = false; bit_count += 1; } @@ -1011,15 +1039,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; @@ -1036,19 +1064,23 @@ int jtag_validate_chain(void) jtag_add_plain_ir_scan(1, &field, TAP_RESET); - jtag_execute_queue(); + int retval; + retval = jtag_execute_queue(); + if (retval != ERROR_OK) + return retval; tap = NULL; chain_pos = 0; int val; - for(;;){ + for (;;) { tap = jtag_tap_next_enabled(tap); - if( tap == NULL ){ + if (tap == NULL) { break; } val = buf_get_u32(ir_test, chain_pos, 2); - if (val != 0x1) + /* Only fail this check if we have IDCODE for this device */ + if ((val != 0x1)&&(tap->hasidcode)) { char *cbuf = buf_to_str(ir_test, total_ir_length, 16); LOG_ERROR("Could not validate JTAG scan chain, IR mismatch, scan returned 0x%s. tap=%s pos=%d expected 0x1 got %0x", cbuf, jtag_tap_name(tap), chain_pos, val); @@ -1096,7 +1128,7 @@ 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); } @@ -1104,7 +1136,7 @@ void jtag_tap_free(jtag_tap_t *tap) { jtag_unregister_event_callback(&jtag_reset_callback, tap); - /// @todo is anything missing? no memory leaks please + /// @todo is anything missing? no memory leaks please free((void *)tap->expected_ids); free((void *)tap->chip); free((void *)tap->tapname); @@ -1123,16 +1155,33 @@ 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) - { - jtag_interface->khz(jtag_get_speed_khz(), &jtag_speed); - hasKHz = false; - } + jtag = jtag_interface; if (jtag_interface->init() != ERROR_OK) + { + jtag = NULL; return ERROR_JTAG_INIT_FAILED; + } + + int requested_khz = jtag_get_speed_khz(); + int actual_khz = requested_khz; + int retval = jtag_get_speed_readable(&actual_khz); + if (ERROR_OK != retval) + LOG_INFO("interface specific clock speed value %d", jtag_get_speed()); + else if (actual_khz) + { + if ((CLOCK_MODE_RCLK == clock_mode) + || ((CLOCK_MODE_KHZ == clock_mode) && !requested_khz)) + { + LOG_INFO("RCLK (adaptive clock speed) not supported - fallback to %d kHz" + , actual_khz); + } + else + LOG_INFO("clock speed %d kHz", actual_khz); + } + else + LOG_INFO("RCLK (adaptive clock speed)"); - jtag = jtag_interface; return ERROR_OK; } @@ -1144,13 +1193,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 */ @@ -1185,14 +1234,14 @@ int jtag_init_reset(struct command_context_s *cmd_ctx) { int retval; - if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK) + if ((retval = jtag_interface_init(cmd_ctx)) != ERROR_OK) return retval; - LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / RESET"); + LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / TLR"); /* Reset can happen after a power cycle. * - * Ideally we would only assert TRST or run RESET before the target reset. + * Ideally we would only assert TRST or run TLR before the target reset. * * However w/srst_pulls_trst, trst is asserted together with the target * reset whether we want it or not. @@ -1205,11 +1254,11 @@ int jtag_init_reset(struct command_context_s *cmd_ctx) * NB! order matters!!!! srst *can* disconnect JTAG circuitry * */ - jtag_add_reset(1, 0); /* RESET or TRST */ + jtag_add_reset(1, 0); /* TAP_RESET, using TMS+TCK or TRST */ if (jtag_reset_config & RESET_HAS_SRST) { jtag_add_reset(1, 1); - if ((jtag_reset_config & RESET_SRST_PULLS_TRST)==0) + if ((jtag_reset_config & RESET_SRST_PULLS_TRST) == 0) jtag_add_reset(0, 1); } jtag_add_reset(0, 0); @@ -1229,29 +1278,24 @@ int jtag_init_reset(struct command_context_s *cmd_ctx) int jtag_init(struct command_context_s *cmd_ctx) { int retval; - if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK) + if ((retval = jtag_interface_init(cmd_ctx)) != ERROR_OK) return retval; - if (jtag_init_inner(cmd_ctx)==ERROR_OK) + if (jtag_init_inner(cmd_ctx) == ERROR_OK) { return ERROR_OK; } return jtag_init_reset(cmd_ctx); } -void jtag_set_speed_khz(unsigned khz) -{ - speed_khz = khz; -} 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; +static int jtag_khz_to_speed(unsigned khz, int* speed) +{ + LOG_DEBUG("convert khz to interface specific speed value"); + speed_khz = khz; if (jtag != NULL) { LOG_DEBUG("have interface set up"); @@ -1259,33 +1303,84 @@ int jtag_config_khz(unsigned khz) 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; + *speed = speed_div1; } - return jtag_set_speed(cur_speed); + return ERROR_OK; } -int jtag_get_speed(void) +static int jtag_rclk_to_speed(unsigned fallback_speed_khz, int* speed) { - return jtag_speed; + int retval = jtag_khz_to_speed(0, speed); + if ((ERROR_OK != retval) && fallback_speed_khz) + { + LOG_DEBUG("trying fallback speed..."); + retval = jtag_khz_to_speed(fallback_speed_khz, speed); + } + return retval; } -int jtag_set_speed(int speed) +static 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) +int jtag_config_speed(int speed) +{ + LOG_DEBUG("handle jtag speed"); + clock_mode = CLOCK_MODE_SPEED; + return jtag_set_speed(speed); +} + +int jtag_config_khz(unsigned khz) { - return jtag ? jtag->speed_div(jtag_get_speed(), speed) : ERROR_OK; + LOG_DEBUG("handle jtag khz"); + clock_mode = CLOCK_MODE_KHZ; + int speed = 0; + int retval = jtag_khz_to_speed(khz, &speed); + return (ERROR_OK != retval) ? retval : jtag_set_speed(speed); } +int jtag_config_rclk(unsigned fallback_speed_khz) +{ + LOG_DEBUG("handle jtag rclk"); + clock_mode = CLOCK_MODE_RCLK; + rclk_fallback_speed_khz = fallback_speed_khz; + int speed = 0; + int retval = jtag_rclk_to_speed(fallback_speed_khz, &speed); + return (ERROR_OK != retval) ? retval : jtag_set_speed(speed); +} + +int jtag_get_speed(void) +{ + int speed; + switch(clock_mode) + { + case CLOCK_MODE_SPEED: + speed = jtag_speed; + break; + case CLOCK_MODE_KHZ: + jtag_khz_to_speed(jtag_get_speed_khz(), &speed); + break; + case CLOCK_MODE_RCLK: + jtag_rclk_to_speed(rclk_fallback_speed_khz, &speed); + break; + default: + LOG_ERROR("BUG: unknown jtag clock mode"); + speed = 0; + break; + } + return speed; +} + +int jtag_get_speed_readable(int *khz) +{ + return jtag ? jtag->speed_div(jtag_get_speed(), khz) : ERROR_OK; +} void jtag_set_verify(bool enable) {