X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fcore.c;h=b61280cc0ce2bb349a1d23f3bb041b4aba62516c;hp=dfedc172df342d8d8e9fac199ff6fa3e69cf5239;hb=refs%2Fchanges%2F32%2F832%2F6;hpb=b8c42b985d725ed92b97f8c6cb871a90425b9fa8 diff --git a/src/jtag/core.c b/src/jtag/core.c index dfedc172df..b61280cc0c 100644 --- a/src/jtag/core.c +++ b/src/jtag/core.c @@ -25,15 +25,17 @@ * You should have received a copy of the GNU General Public License * * along with this program; if not, write to the * * Free Software Foundation, Inc., * - * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * ***************************************************************************/ + #ifdef HAVE_CONFIG_H #include "config.h" #endif #include "jtag.h" +#include "swd.h" #include "interface.h" -#include "transport.h" +#include #ifdef HAVE_STRINGS_H #include @@ -43,14 +45,17 @@ #include "svf/svf.h" #include "xsvf/xsvf.h" -/// The number of JTAG queue flushes (for profiling and debugging purposes). +/** The number of JTAG queue flushes (for profiling and debugging purposes). */ static int jtag_flush_queue_count; -// Sleep this # of ms after flushing the queue -static int jtag_flush_queue_sleep = 0; +/* Sleep this # of ms after flushing the queue */ +static int jtag_flush_queue_sleep; static void jtag_add_scan_check(struct jtag_tap *active, - void (*jtag_add_scan)(struct jtag_tap *active, int in_num_fields, const struct scan_field *in_fields, tap_state_t state), + void (*jtag_add_scan)(struct jtag_tap *active, + int in_num_fields, + const struct scan_field *in_fields, + tap_state_t state), int in_num_fields, struct scan_field *in_fields, tap_state_t state); /** @@ -65,8 +70,7 @@ static void jtag_add_scan_check(struct jtag_tap *active, */ static int jtag_error = ERROR_OK; -static const char *jtag_event_strings[] = -{ +static const char *jtag_event_strings[] = { [JTAG_TRST_ASSERTED] = "TAP reset", [JTAG_TAP_EVENT_SETUP] = "TAP setup", [JTAG_TAP_EVENT_ENABLE] = "TAP enabled", @@ -85,12 +89,12 @@ static int jtag_srst = -1; /** * List all TAPs that have been created. */ -static struct jtag_tap *__jtag_all_taps = NULL; +static struct jtag_tap *__jtag_all_taps; /** * The number of TAPs in the __jtag_all_taps list, used to track the * assigned chain position to new TAPs */ -static unsigned jtag_num_taps = 0; +static unsigned jtag_num_taps; static enum reset_types jtag_reset_config = RESET_NONE; tap_state_t cmd_queue_cur_state = TAP_RESET; @@ -98,39 +102,42 @@ tap_state_t cmd_queue_cur_state = TAP_RESET; 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 adapter_nsrst_delay = 0; /* default to no nSRST delay */ -static int jtag_ntrst_delay = 0; /* default to no nTRST delay */ -static int adapter_nsrst_assert_width = 0; /* width of assertion */ -static int jtag_ntrst_assert_width = 0; /* width of assertion */ +/* how long the OpenOCD should wait before attempting JTAG communication after reset lines + *deasserted (in ms) */ +static int adapter_nsrst_delay; /* default to no nSRST delay */ +static int jtag_ntrst_delay;/* default to no nTRST delay */ +static int adapter_nsrst_assert_width; /* width of assertion */ +static int jtag_ntrst_assert_width; /* width of assertion */ /** * Contains a single callback along with a pointer that will be passed * when an event occurs. */ struct jtag_event_callback { - /// a event callback + /** a event callback */ jtag_event_handler_t callback; - /// the private data to pass to the callback - void* priv; - /// the next callback - struct jtag_event_callback* next; + /** the private data to pass to the callback */ + void *priv; + /** the next callback */ + struct jtag_event_callback *next; }; /* callbacks to inform high-level handlers about JTAG state changes */ static struct jtag_event_callback *jtag_event_callbacks; /* speed in kHz*/ -static int speed_khz = 0; +static int speed_khz; /* 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 int rclk_fallback_speed_khz; +static enum {CLOCK_MODE_UNSELECTED, CLOCK_MODE_KHZ, CLOCK_MODE_RCLK} clock_mode; +static int jtag_speed; + +static struct jtag_interface *jtag; -static struct jtag_interface *jtag = NULL; +const struct swd_driver *swd; /* configuration */ -struct jtag_interface *jtag_interface = NULL; +struct jtag_interface *jtag_interface; void jtag_set_flush_queue_sleep(int ms) { @@ -192,8 +199,7 @@ unsigned jtag_tap_count_enabled(void) { struct jtag_tap *t = jtag_all_taps(); unsigned n = 0; - while (t) - { + while (t) { if (t->enabled) n++; t = t->next_tap; @@ -201,7 +207,7 @@ unsigned jtag_tap_count_enabled(void) return n; } -/// Append a new TAP to the chain of all taps. +/** Append a new TAP to the chain of all taps. */ void jtag_tap_add(struct jtag_tap *t) { t->abs_chain_position = jtag_num_taps++; @@ -213,7 +219,7 @@ void jtag_tap_add(struct jtag_tap *t) } /* returns a pointer to the n-th device in the scan chain */ -static inline struct jtag_tap *jtag_tap_by_position(unsigned n) +struct jtag_tap *jtag_tap_by_position(unsigned n) { struct jtag_tap *t = jtag_all_taps(); @@ -228,8 +234,7 @@ struct jtag_tap *jtag_tap_by_string(const char *s) /* try by name first */ struct jtag_tap *t = jtag_all_taps(); - while (t) - { + while (t) { if (0 == strcmp(t->dotted_name, s)) return t; t = t->next_tap; @@ -252,11 +257,10 @@ struct jtag_tap *jtag_tap_by_string(const char *s) return t; } -struct jtag_tap* jtag_tap_next_enabled(struct jtag_tap* p) +struct jtag_tap *jtag_tap_next_enabled(struct jtag_tap *p) { p = p ? p->next_tap : jtag_all_taps(); - while (p) - { + while (p) { if (p->enabled) return p; p = p->next_tap; @@ -275,12 +279,9 @@ int jtag_register_event_callback(jtag_event_handler_t callback, void *priv) struct jtag_event_callback **callbacks_p = &jtag_event_callbacks; if (callback == NULL) - { - return ERROR_INVALID_ARGUMENTS; - } + return ERROR_COMMAND_SYNTAX_ERROR; - if (*callbacks_p) - { + if (*callbacks_p) { while ((*callbacks_p)->next) callbacks_p = &((*callbacks_p)->next); callbacks_p = &((*callbacks_p)->next); @@ -299,14 +300,10 @@ int jtag_unregister_event_callback(jtag_event_handler_t callback, void *priv) struct jtag_event_callback **p = &jtag_event_callbacks, *temp; if (callback == NULL) - { - return ERROR_INVALID_ARGUMENTS; - } + return ERROR_COMMAND_SYNTAX_ERROR; - while (*p) - { - if (((*p)->priv != priv) || ((*p)->callback != callback)) - { + while (*p) { + if (((*p)->priv != priv) || ((*p)->callback != callback)) { p = &(*p)->next; continue; } @@ -325,8 +322,7 @@ int jtag_call_event_callbacks(enum jtag_event event) LOG_DEBUG("jtag event: %s", jtag_event_strings[event]); - while (callback) - { + while (callback) { struct jtag_event_callback *next; /* callback may remove itself */ @@ -352,13 +348,8 @@ static void jtag_prelude(tap_state_t state) cmd_queue_cur_state = state; } -void jtag_alloc_in_value32(struct scan_field *field) -{ - interface_jtag_alloc_in_value32(field); -} - void jtag_add_ir_scan_noverify(struct jtag_tap *active, const struct scan_field *in_fields, - tap_state_t state) + tap_state_t state) { jtag_prelude(state); @@ -366,18 +357,20 @@ void jtag_add_ir_scan_noverify(struct jtag_tap *active, const struct scan_field jtag_set_error(retval); } -static void jtag_add_ir_scan_noverify_callback(struct jtag_tap *active, int dummy, const struct scan_field *in_fields, - tap_state_t state) +static void jtag_add_ir_scan_noverify_callback(struct jtag_tap *active, + int dummy, + const struct scan_field *in_fields, + tap_state_t state) { jtag_add_ir_scan_noverify(active, in_fields, state); } +/* If fields->in_value is filled out, then the captured IR value will be checked */ void jtag_add_ir_scan(struct jtag_tap *active, struct scan_field *in_fields, tap_state_t state) { assert(state != TAP_RESET); - 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 */ /* if we are to run a verification of the ir scan, we need to get the input back. @@ -385,15 +378,14 @@ void jtag_add_ir_scan(struct jtag_tap *active, struct scan_field *in_fields, tap */ in_fields->check_value = active->expected; in_fields->check_mask = active->expected_mask; - jtag_add_scan_check(active, jtag_add_ir_scan_noverify_callback, 1, in_fields, state); + jtag_add_scan_check(active, jtag_add_ir_scan_noverify_callback, 1, in_fields, + state); } else - { jtag_add_ir_scan_noverify(active, in_fields, state); - } } void jtag_add_plain_ir_scan(int num_bits, const uint8_t *out_bits, uint8_t *in_bits, - tap_state_t state) + tap_state_t state) { assert(out_bits != NULL); assert(state != TAP_RESET); @@ -406,64 +398,56 @@ void jtag_add_plain_ir_scan(int num_bits, const uint8_t *out_bits, uint8_t *in_b } static int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value, - uint8_t *in_check_mask, int num_bits); + uint8_t *in_check_mask, int num_bits); -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) +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((uint8_t *)data0, (uint8_t *)data1, (uint8_t *)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(struct jtag_tap *active, void (*jtag_add_scan)(struct jtag_tap *active, int in_num_fields, const struct scan_field *in_fields, tap_state_t state), - int in_num_fields, struct scan_field *in_fields, tap_state_t state) +static void jtag_add_scan_check(struct jtag_tap *active, void (*jtag_add_scan)( + struct jtag_tap *active, + int in_num_fields, + const struct scan_field *in_fields, + tap_state_t state), + int in_num_fields, struct scan_field *in_fields, tap_state_t state) { - for (int i = 0; i < in_num_fields; i++) - { - struct scan_field *field = &in_fields[i]; - field->allocated = 0; - field->modified = 0; - if (field->check_value || field->in_value) - continue; - interface_jtag_add_scan_check_alloc(field); - field->modified = 1; - } - jtag_add_scan(active, in_num_fields, in_fields, state); - for (int i = 0; i < in_num_fields; i++) - { - if ((in_fields[i].check_value != NULL) && (in_fields[i].in_value != NULL)) - { + for (int i = 0; i < in_num_fields; i++) { + 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, (jtag_callback_data_t)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); } - if (in_fields[i].allocated) - { - free(in_fields[i].in_value); - } - if (in_fields[i].modified) - { - in_fields[i].in_value = NULL; - } } } -void jtag_add_dr_scan_check(struct jtag_tap *active, int in_num_fields, struct scan_field *in_fields, tap_state_t state) +void jtag_add_dr_scan_check(struct jtag_tap *active, + int in_num_fields, + struct scan_field *in_fields, + tap_state_t state) { if (jtag_verify) - { jtag_add_scan_check(active, jtag_add_dr_scan, in_num_fields, in_fields, state); - } else - { + else jtag_add_dr_scan(active, in_num_fields, in_fields, state); - } } -void jtag_add_dr_scan(struct jtag_tap *active, int in_num_fields, const struct scan_field *in_fields, - tap_state_t state) +void jtag_add_dr_scan(struct jtag_tap *active, + int in_num_fields, + const struct scan_field *in_fields, + tap_state_t state) { assert(state != TAP_RESET); @@ -475,7 +459,7 @@ void jtag_add_dr_scan(struct jtag_tap *active, int in_num_fields, const struct s } void jtag_add_plain_dr_scan(int num_bits, const uint8_t *out_bits, uint8_t *in_bits, - tap_state_t state) + tap_state_t state) { assert(out_bits != NULL); assert(state != TAP_RESET); @@ -531,27 +515,23 @@ void jtag_add_pathmove(int num_states, const tap_state_t *path) tap_state_t cur_state = cmd_queue_cur_state; /* the last state has to be a stable state */ - if (!tap_is_state_stable(path[num_states - 1])) - { + if (!tap_is_state_stable(path[num_states - 1])) { LOG_ERROR("BUG: TAP path doesn't finish in a stable state"); jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE); return; } - for (int i = 0; i < num_states; i++) - { - if (path[i] == TAP_RESET) - { + for (int i = 0; i < num_states; i++) { + if (path[i] == TAP_RESET) { LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences"); jtag_set_error(ERROR_JTAG_STATE_INVALID); return; } - if (tap_state_transition(cur_state, true) != path[i] - && tap_state_transition(cur_state, false) != 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", - tap_state_name(cur_state), tap_state_name(path[i])); + tap_state_name(cur_state), tap_state_name(path[i])); jtag_set_error(ERROR_JTAG_TRANSITION_INVALID); return; } @@ -568,8 +548,7 @@ int jtag_add_statemove(tap_state_t goal_state) { tap_state_t cur_state = cmd_queue_cur_state; - if (goal_state != cur_state) - { + if (goal_state != cur_state) { LOG_DEBUG("cur_state=%s goal_state=%s", tap_state_name(cur_state), tap_state_name(goal_state)); @@ -581,17 +560,15 @@ int jtag_add_statemove(tap_state_t goal_state) if (goal_state == TAP_RESET) jtag_add_tlr(); else if (goal_state == cur_state) - /* nothing to do */ ; + /* nothing to do */; - 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); tap_state_t moves[8]; assert(tms_count < ARRAY_SIZE(moves)); - for (unsigned i = 0; i < tms_count; i++, tms_bits >>= 1) - { + for (unsigned i = 0; i < tms_count; i++, tms_bits >>= 1) { bool bit = tms_bits & 1; cur_state = tap_state_transition(cur_state, bit); @@ -599,13 +576,9 @@ 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); - } - else return ERROR_FAIL; @@ -621,21 +594,59 @@ void jtag_add_runtest(int num_cycles, tap_state_t state) void jtag_add_clocks(int num_cycles) { - if (!tap_is_state_stable(cmd_queue_cur_state)) - { - LOG_ERROR("jtag_add_clocks() called with TAP in unstable state \"%s\"", - tap_state_name(cmd_queue_cur_state)); - jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE); - return; + if (!tap_is_state_stable(cmd_queue_cur_state)) { + LOG_ERROR("jtag_add_clocks() called with TAP in unstable state \"%s\"", + tap_state_name(cmd_queue_cur_state)); + jtag_set_error(ERROR_JTAG_NOT_STABLE_STATE); + return; } - if (num_cycles > 0) - { + if (num_cycles > 0) { jtag_checks(); jtag_set_error(interface_jtag_add_clocks(num_cycles)); } } +void swd_add_reset(int req_srst) +{ + if (req_srst) { + if (!(jtag_reset_config & RESET_HAS_SRST)) { + LOG_ERROR("BUG: can't assert SRST"); + jtag_set_error(ERROR_FAIL); + return; + } + req_srst = 1; + } + + /* Maybe change SRST signal state */ + if (jtag_srst != req_srst) { + int retval; + + retval = interface_jtag_add_reset(0, req_srst); + if (retval != ERROR_OK) + jtag_set_error(retval); + else + retval = jtag_execute_queue(); + + if (retval != ERROR_OK) { + LOG_ERROR("TRST/SRST error"); + return; + } + + /* SRST resets everything hooked up to that signal */ + jtag_srst = req_srst; + if (jtag_srst) { + LOG_DEBUG("SRST line asserted"); + if (adapter_nsrst_assert_width) + jtag_add_sleep(adapter_nsrst_assert_width * 1000); + } else { + LOG_DEBUG("SRST line released"); + if (adapter_nsrst_delay) + jtag_add_sleep(adapter_nsrst_delay * 1000); + } + } +} + void jtag_add_reset(int req_tlr_or_trst, int req_srst) { int trst_with_tlr = 0; @@ -675,7 +686,7 @@ void jtag_add_reset(int req_tlr_or_trst, int req_srst) if (!(jtag_reset_config & RESET_HAS_TRST)) trst_with_tlr = 1; else if ((jtag_reset_config & RESET_TRST_PULLS_SRST) != 0 - && !req_srst) + && !req_srst) trst_with_tlr = 1; else new_trst = 1; @@ -692,7 +703,7 @@ void jtag_add_reset(int req_tlr_or_trst, int req_srst) retval = jtag_execute_queue(); if (retval != ERROR_OK) { - LOG_ERROR("TRST/SRST error %d", retval); + LOG_ERROR("TRST/SRST error"); return; } } @@ -700,13 +711,11 @@ void jtag_add_reset(int req_tlr_or_trst, int req_srst) /* SRST resets everything hooked up to that signal */ if (jtag_srst != new_srst) { jtag_srst = new_srst; - if (jtag_srst) - { + if (jtag_srst) { LOG_DEBUG("SRST line asserted"); if (adapter_nsrst_assert_width) jtag_add_sleep(adapter_nsrst_assert_width * 1000); - } - else { + } else { LOG_DEBUG("SRST line released"); if (adapter_nsrst_delay) jtag_add_sleep(adapter_nsrst_delay * 1000); @@ -748,13 +757,13 @@ void jtag_add_reset(int req_tlr_or_trst, int req_srst) void jtag_add_sleep(uint32_t us) { - /// @todo Here, keep_alive() appears to be a layering violation!!! + /** @todo Here, keep_alive() appears to be a layering violation!!! */ keep_alive(); jtag_set_error(interface_jtag_add_sleep(us)); } static int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value, - uint8_t *in_check_mask, int num_bits) + uint8_t *in_check_mask, int num_bits) { int retval = ERROR_OK; int compare_failed; @@ -766,9 +775,7 @@ static int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value, if (compare_failed) { char *captured_str, *in_check_value_str; - int bits = (num_bits > DEBUG_JTAG_IOZ) - ? DEBUG_JTAG_IOZ - : num_bits; + int bits = (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits; /* NOTE: we've lost diagnostic context here -- 'which tap' */ @@ -776,7 +783,7 @@ static int jtag_check_value_inner(uint8_t *captured, uint8_t *in_check_value, in_check_value_str = buf_to_str(in_check_value, bits, 16); LOG_WARNING("Bad value '%s' captured during DR or IR scan:", - captured_str); + captured_str); LOG_WARNING(" check_value: 0x%s", in_check_value_str); free(captured_str); @@ -799,8 +806,7 @@ void jtag_check_value_mask(struct scan_field *field, uint8_t *value, uint8_t *ma { assert(field->in_value != NULL); - if (value == NULL) - { + if (value == NULL) { /* no checking to do */ return; } @@ -811,12 +817,9 @@ void jtag_check_value_mask(struct scan_field *field, uint8_t *value, uint8_t *ma jtag_set_error(retval); } - - int default_interface_jtag_execute_queue(void) { - if (NULL == jtag) - { + if (NULL == jtag) { LOG_ERROR("No JTAG interface configured yet. " "Issue 'init' command in startup scripts " "before communicating with targets."); @@ -831,8 +834,7 @@ void jtag_execute_queue_noclear(void) jtag_flush_queue_count++; jtag_set_error(interface_jtag_execute_queue()); - if (jtag_flush_queue_sleep > 0) - { + if (jtag_flush_queue_sleep > 0) { /* For debug purposes it can be useful to test performance * or behavior when delaying after flushing the queue, * e.g. to simulate long roundtrip times. @@ -856,8 +858,7 @@ static int jtag_reset_callback(enum jtag_event event, void *priv) { struct jtag_tap *tap = priv; - if (event == JTAG_TRST_ASSERTED) - { + if (event == JTAG_TRST_ASSERTED) { tap->enabled = !tap->disabled_after_reset; /* current instruction is either BYPASS or IDCODE */ @@ -868,9 +869,16 @@ static int jtag_reset_callback(enum jtag_event event, void *priv) return ERROR_OK; } +/* sleep at least us microseconds. When we sleep more than 1000ms we + * do an alive sleep, i.e. keep GDB alive. Note that we could starve + * GDB if we slept for <1000ms many times. + */ void jtag_sleep(uint32_t us) { - alive_sleep(us/1000); + if (us < 1000) + usleep(us); + else + alive_sleep((us+999)/1000); } /* Maximum number of enabled JTAG devices we expect in the scan chain, @@ -886,20 +894,20 @@ void jtag_sleep(uint32_t us) /* A reserved manufacturer ID is used in END_OF_CHAIN_FLAG, so we * know that no valid TAP will have it as an IDCODE value. */ -#define END_OF_CHAIN_FLAG 0x000000ff +#define END_OF_CHAIN_FLAG 0xffffffff /* a larger IR length than we ever expect to autoprobe */ -#define JTAG_IRLEN_MAX 60 +#define JTAG_IRLEN_MAX 60 static int jtag_examine_chain_execute(uint8_t *idcode_buffer, unsigned num_idcode) { struct scan_field field = { - .num_bits = num_idcode * 32, - .out_value = idcode_buffer, - .in_value = idcode_buffer, - }; + .num_bits = num_idcode * 32, + .out_value = idcode_buffer, + .in_value = idcode_buffer, + }; - // initialize to the end of chain ID value + /* initialize to the end of chain ID value */ for (unsigned i = 0; i < JTAG_MAX_CHAIN_SIZE; i++) buf_set_u32(idcode_buffer, i * 32, 32, END_OF_CHAIN_FLAG); @@ -913,8 +921,7 @@ static bool jtag_examine_chain_check(uint8_t *idcodes, unsigned count) uint8_t zero_check = 0x0; uint8_t one_check = 0xff; - for (unsigned i = 0; i < count * 4; i++) - { + for (unsigned i = 0; i < count * 4; i++) { zero_check |= idcodes[i]; one_check &= idcodes[i]; } @@ -929,10 +936,9 @@ static bool jtag_examine_chain_check(uint8_t *idcodes, unsigned count) * + there are several hundreds of TAPs in bypass, or * + at least a few dozen TAPs all have an all-ones IDCODE */ - if (zero_check == 0x00 || one_check == 0xff) - { + if (zero_check == 0x00 || one_check == 0xff) { LOG_ERROR("JTAG scan chain interrogation failed: all %s", - (zero_check == 0x00) ? "zeroes" : "ones"); + (zero_check == 0x00) ? "zeroes" : "ones"); LOG_ERROR("Check JTAG interface, timings, target power, etc."); return false; } @@ -940,26 +946,26 @@ static bool jtag_examine_chain_check(uint8_t *idcodes, unsigned count) } static void jtag_examine_chain_display(enum log_levels level, const char *msg, - const char *name, uint32_t 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, - (unsigned int)idcode, - (unsigned int)EXTRACT_MFG(idcode), - (unsigned int)EXTRACT_PART(idcode), - (unsigned int)EXTRACT_VER(idcode)); + log_printf_lf(level, __FILE__, __LINE__, __func__, + "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(uint32_t idcode) { /* * Some devices, such as AVR8, will output all 1's instead - * of TDI input value at end of chain. Allow those values + * of TDI input value at end of chain. Allow those values * instead of failing. */ - return idcode == END_OF_CHAIN_FLAG || idcode == 0xFFFFFFFF; + return idcode == END_OF_CHAIN_FLAG; } /** @@ -972,15 +978,14 @@ static bool jtag_idcode_is_final(uint32_t idcode) static bool 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) { uint32_t idcode = buf_get_u32(idcodes, count, 32); /* do not trigger the warning if the data looks good */ if (jtag_idcode_is_final(idcode)) continue; LOG_WARNING("Unexpected idcode after end of chain: %d 0x%08x", - count, (unsigned int)idcode); + count, (unsigned int)idcode); triggered = true; } return triggered; @@ -994,16 +999,15 @@ static bool jtag_examine_chain_match_tap(const struct jtag_tap *tap) if (0 == tap->expected_ids_cnt && !idcode) return true; - /* optionally ignore the JTAG version field */ - uint32_t mask = tap->ignore_version ? ~(0xff << 24) : ~0; + /* optionally ignore the JTAG version field - bits 28-31 of IDCODE */ + uint32_t mask = tap->ignore_version ? ~(0xf << 28) : ~0; idcode &= mask; /* Loop over the expected identification codes and test for a match */ unsigned ii, limit = tap->expected_ids_cnt; - for (ii = 0; ii < limit; ii++) - { + for (ii = 0; ii < limit; ii++) { uint32_t expected = tap->expected_ids[ii] & mask; if (idcode == expected) @@ -1016,14 +1020,13 @@ static bool jtag_examine_chain_match_tap(const struct jtag_tap *tap) /* If none of the expected ids matched, warn */ jtag_examine_chain_display(LOG_LVL_WARNING, "UNEXPECTED", - tap->dotted_name, tap->idcode); - for (ii = 0; ii < limit; ii++) - { + tap->dotted_name, tap->idcode); + for (ii = 0; ii < limit; ii++) { char msg[32]; snprintf(msg, sizeof(msg), "expected %u of %u", ii + 1, limit); jtag_examine_chain_display(LOG_LVL_ERROR, msg, - tap->dotted_name, tap->expected_ids[ii]); + tap->dotted_name, tap->expected_ids[ii]); } return false; } @@ -1056,28 +1059,24 @@ static int jtag_examine_chain(void) autoprobe = true; for (bit_count = 0; - tap && bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31; - tap = jtag_tap_next_enabled(tap)) - { + tap && bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31; + tap = jtag_tap_next_enabled(tap)) { uint32_t idcode = buf_get_u32(idcode_buffer, bit_count, 32); - if ((idcode & 1) == 0) - { + if ((idcode & 1) == 0) { /* Zero for LSB indicates a device in bypass */ LOG_INFO("TAP %s does not have IDCODE", - tap->dotted_name); + tap->dotted_name); idcode = 0; tap->hasidcode = false; bit_count += 1; - } - else - { + } else { /* Friendly devices support IDCODE */ tap->hasidcode = true; jtag_examine_chain_display(LOG_LVL_INFO, - "tap/device found", - tap->dotted_name, idcode); + "tap/device found", + tap->dotted_name, idcode); bit_count += 32; } @@ -1091,7 +1090,7 @@ static int jtag_examine_chain(void) /* Fail if too many TAPs were enabled for us to verify them all. */ if (tap) { LOG_ERROR("Too many TAPs enabled; '%s' ignored.", - tap->dotted_name); + tap->dotted_name); return ERROR_JTAG_INIT_FAILED; } @@ -1141,9 +1140,9 @@ static int jtag_examine_chain(void) } LOG_WARNING("AUTO %s - use \"jtag newtap " - "%s %s -expected-id 0x%8.8" PRIx32 " ...\"", - tap->dotted_name, tap->chip, tap->tapname, - tap->idcode); + "%s %s -expected-id 0x%8.8" PRIx32 " ...\"", + tap->dotted_name, tap->chip, tap->tapname, + tap->idcode); jtag_tap_init(tap); } @@ -1152,9 +1151,9 @@ static int jtag_examine_chain(void) * only the data we fed into the scan chain. */ if (jtag_examine_chain_end(idcode_buffer, bit_count, - 8 * sizeof(idcode_buffer))) { + 8 * sizeof(idcode_buffer))) { LOG_ERROR("double-check your JTAG setup (interface, " - "speed, missing TAPs, ...)"); + "speed, missing TAPs, ...)"); return ERROR_JTAG_INIT_FAILED; } @@ -1178,7 +1177,7 @@ static int jtag_validate_ircapture(void) int total_ir_length = 0; uint8_t *ir_test = NULL; struct scan_field field; - int val; + uint64_t val; int chain_pos = 0; int retval; @@ -1214,11 +1213,10 @@ static int jtag_validate_ircapture(void) tap = NULL; chain_pos = 0; - for (;;) { + for (;; ) { tap = jtag_tap_next_enabled(tap); - if (tap == NULL) { + if (tap == NULL) break; - } /* If we're autoprobing, guess IR lengths. They must be at * least two bits. Guessing will fail if (a) any TAP does @@ -1238,13 +1236,12 @@ static int jtag_validate_ircapture(void) */ if (tap->ir_length == 0) { tap->ir_length = 2; - while ((val = buf_get_u32(ir_test, chain_pos, - tap->ir_length + 1)) == 1 - && tap->ir_length <= 32) { + while ((val = buf_get_u64(ir_test, chain_pos, tap->ir_length + 1)) == 1 + && tap->ir_length <= 64) { tap->ir_length++; } LOG_WARNING("AUTO %s - use \"... -irlen %d\"", - jtag_tap_name(tap), tap->ir_length); + jtag_tap_name(tap), tap->ir_length); } /* Validate the two LSBs, which must be 01 per JTAG spec. @@ -1254,31 +1251,28 @@ static int jtag_validate_ircapture(void) * this part of the JTAG spec, so their capture mask/value * attributes might disable this test. */ - val = buf_get_u32(ir_test, chain_pos, tap->ir_length); + val = buf_get_u64(ir_test, chain_pos, tap->ir_length); if ((val & tap->ir_capture_mask) != tap->ir_capture_value) { - LOG_ERROR("%s: IR capture error; saw 0x%0*x not 0x%0*x", - jtag_tap_name(tap), - (tap->ir_length + 7) / tap->ir_length, - val, - (tap->ir_length + 7) / tap->ir_length, - (unsigned) tap->ir_capture_value); + LOG_ERROR("%s: IR capture error; saw 0x%0*" PRIx64 " not 0x%0*" PRIx32, + jtag_tap_name(tap), + (tap->ir_length + 7) / tap->ir_length, val, + (tap->ir_length + 7) / tap->ir_length, tap->ir_capture_value); retval = ERROR_JTAG_INIT_FAILED; goto done; } - LOG_DEBUG("%s: IR capture 0x%0*x", jtag_tap_name(tap), - (tap->ir_length + 7) / tap->ir_length, val); + LOG_DEBUG("%s: IR capture 0x%0*" PRIx64, jtag_tap_name(tap), + (tap->ir_length + 7) / tap->ir_length, val); chain_pos += tap->ir_length; } /* verify the '11' sentinel we wrote is returned at the end */ - val = buf_get_u32(ir_test, chain_pos, 2); - if (val != 0x3) - { + val = buf_get_u64(ir_test, chain_pos, 2); + if (val != 0x3) { char *cbuf = buf_to_str(ir_test, total_ir_length, 16); LOG_ERROR("IR capture error at bit %d, saw 0x%s not 0x...3", - chain_pos, cbuf); + chain_pos, cbuf); free(cbuf); retval = ERROR_JTAG_INIT_FAILED; } @@ -1292,7 +1286,6 @@ done: return retval; } - void jtag_tap_init(struct jtag_tap *tap) { unsigned ir_len_bits; @@ -1306,33 +1299,33 @@ void jtag_tap_init(struct jtag_tap *tap) tap->expected_mask = calloc(1, ir_len_bytes); tap->cur_instr = malloc(ir_len_bytes); - /// @todo cope better with ir_length bigger than 32 bits + /** @todo cope better with ir_length bigger than 32 bits */ if (ir_len_bits > 32) ir_len_bits = 32; buf_set_u32(tap->expected, 0, ir_len_bits, tap->ir_capture_value); buf_set_u32(tap->expected_mask, 0, ir_len_bits, tap->ir_capture_mask); - // TAP will be in bypass mode after jtag_validate_ircapture() + /* TAP will be in bypass mode after jtag_validate_ircapture() */ tap->bypass = 1; buf_set_ones(tap->cur_instr, tap->ir_length); - // register the reset callback for the TAP + /* register the reset callback for the TAP */ jtag_register_event_callback(&jtag_reset_callback, tap); + jtag_tap_add(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, - (unsigned) tap->ir_capture_value, - (unsigned) tap->ir_capture_mask); - jtag_tap_add(tap); + tap->abs_chain_position, tap->ir_length, + (unsigned) tap->ir_capture_value, + (unsigned) tap->ir_capture_mask); } void jtag_tap_free(struct jtag_tap *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); free((void *)tap->expected_ids); free((void *)tap->chip); @@ -1350,20 +1343,18 @@ int adapter_init(struct command_context *cmd_ctx) if (jtag) return ERROR_OK; - if (!jtag_interface) - { + if (!jtag_interface) { /* nothing was previously specified by "interface" command */ LOG_ERROR("Debug Adapter has to be specified, " "see \"interface\" command"); return ERROR_JTAG_INVALID_INTERFACE; } + int retval; + retval = jtag_interface->init(); + if (retval != ERROR_OK) + return retval; jtag = jtag_interface; - if (jtag_interface->init() != ERROR_OK) - { - jtag = NULL; - return ERROR_JTAG_INIT_FAILED; - } /* LEGACY SUPPORT ... adapter drivers must declare what * transports they allow. Until they all do so, assume @@ -1373,33 +1364,43 @@ int adapter_init(struct command_context *cmd_ctx) LOG_ERROR("Adapter driver '%s' did not declare " "which transports it allows; assuming " "JTAG-only", jtag->name); - int retval = allow_transports(cmd_ctx, jtag_only); + retval = allow_transports(cmd_ctx, jtag_only); if (retval != ERROR_OK) return retval; } + if (jtag->speed == NULL) { + LOG_INFO("This adapter doesn't support configurable speed"); + return ERROR_OK; + } + + if (CLOCK_MODE_UNSELECTED == clock_mode) { + LOG_ERROR("An adapter speed is not selected in the init script." + " Insert a call to adapter_khz or jtag_rclk to proceed."); + return ERROR_JTAG_INIT_FAILED; + } + int requested_khz = jtag_get_speed_khz(); int actual_khz = requested_khz; - int jtag_speed_var; - int retval = jtag_get_speed(&jtag_speed_var); + int jtag_speed_var = 0; + retval = jtag_get_speed(&jtag_speed_var); + if (retval != ERROR_OK) + return retval; + retval = jtag->speed(jtag_speed_var); if (retval != ERROR_OK) return retval; retval = jtag_get_speed_readable(&actual_khz); if (ERROR_OK != retval) LOG_INFO("adapter-specific clock speed value %d", jtag_speed_var); - else if (actual_khz) - { + else if (actual_khz) { /* Adaptive clocking -- JTAG-specific */ if ((CLOCK_MODE_RCLK == clock_mode) - || ((CLOCK_MODE_KHZ == clock_mode) && !requested_khz)) - { + || ((CLOCK_MODE_KHZ == clock_mode) && !requested_khz)) { LOG_INFO("RCLK (adaptive clock speed) not supported - fallback to %d kHz" - , actual_khz); - } - else + , actual_khz); + } else LOG_INFO("clock speed %d kHz", actual_khz); - } - else + } else LOG_INFO("RCLK (adaptive clock speed)"); return ERROR_OK; @@ -1427,13 +1428,14 @@ int jtag_init_inner(struct command_context *cmd_ctx) * the TAP's IDCODE values. */ LOG_WARNING("There are no enabled taps. " - "AUTO PROBING MIGHT NOT WORK!!"); + "AUTO PROBING MIGHT NOT WORK!!"); /* REVISIT default clock will often be too fast ... */ } jtag_add_tlr(); - if ((retval = jtag_execute_queue()) != ERROR_OK) + retval = jtag_execute_queue(); + if (retval != ERROR_OK) return retval; /* Examine DR values first. This discovers problems which will @@ -1442,22 +1444,22 @@ int jtag_init_inner(struct command_context *cmd_ctx) */ retval = jtag_examine_chain(); switch (retval) { - case ERROR_OK: - /* complete success */ - break; - default: - /* For backward compatibility reasons, try coping with - * configuration errors involving only ID mismatches. - * We might be able to talk to the devices. - * - * Also the device might be powered down during startup. - * - * After OpenOCD starts, we can try to power on the device - * and run a reset. - */ - LOG_ERROR("Trying to use configured scan chain anyway..."); - issue_setup = false; - break; + case ERROR_OK: + /* complete success */ + break; + default: + /* For backward compatibility reasons, try coping with + * configuration errors involving only ID mismatches. + * We might be able to talk to the devices. + * + * Also the device might be powered down during startup. + * + * After OpenOCD starts, we can try to power on the device + * and run a reset. + */ + LOG_ERROR("Trying to use configured scan chain anyway..."); + issue_setup = false; + break; } /* Now look at IR values. Problems here will prevent real @@ -1467,8 +1469,7 @@ int jtag_init_inner(struct command_context *cmd_ctx) * ircapture/irmask values during TAP setup.) */ retval = jtag_validate_ircapture(); - if (retval != ERROR_OK) - { + if (retval != ERROR_OK) { /* The target might be powered down. The user * can power it up and reset it after firing * up OpenOCD. @@ -1490,7 +1491,7 @@ int adapter_quit(void) if (!jtag || !jtag->quit) return ERROR_OK; - // close the JTAG interface + /* close the JTAG interface */ int result = jtag->quit(); if (ERROR_OK != result) LOG_ERROR("failed: %d", result); @@ -1498,12 +1499,25 @@ int adapter_quit(void) return ERROR_OK; } +int swd_init_reset(struct command_context *cmd_ctx) +{ + int retval = adapter_init(cmd_ctx); + if (retval != ERROR_OK) + return retval; + + LOG_DEBUG("Initializing with hard SRST reset"); + + if (jtag_reset_config & RESET_HAS_SRST) + swd_add_reset(1); + swd_add_reset(0); + retval = jtag_execute_queue(); + return retval; +} int jtag_init_reset(struct command_context *cmd_ctx) { - int retval; - - if ((retval = adapter_init(cmd_ctx)) != ERROR_OK) + int retval = adapter_init(cmd_ctx); + if (retval != ERROR_OK) return retval; LOG_DEBUG("Initializing with hard TRST+SRST reset"); @@ -1532,15 +1546,25 @@ int jtag_init_reset(struct command_context *cmd_ctx) * REVISIT once Tcl code can read the reset_config modes, this won't * need to be a C routine at all... */ - jtag_add_reset(1, 0); /* TAP_RESET, using TMS+TCK or TRST */ - if (jtag_reset_config & RESET_HAS_SRST) - { + 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) jtag_add_reset(0, 1); } - jtag_add_reset(0, 0); - if ((retval = jtag_execute_queue()) != ERROR_OK) + + /* some targets enable us to connect with srst asserted */ + if (jtag_reset_config & RESET_CNCT_UNDER_SRST) { + if (jtag_reset_config & RESET_SRST_NO_GATING) + jtag_add_reset(0, 1); + else { + LOG_WARNING("\'srst_nogate\' reset_config option is required"); + jtag_add_reset(0, 0); + } + } else + jtag_add_reset(0, 0); + retval = jtag_execute_queue(); + if (retval != ERROR_OK) return retval; /* Check that we can communication on the JTAG chain + eventually we want to @@ -1555,14 +1579,22 @@ int jtag_init_reset(struct command_context *cmd_ctx) int jtag_init(struct command_context *cmd_ctx) { - int retval; - - if ((retval = adapter_init(cmd_ctx)) != ERROR_OK) + int retval = adapter_init(cmd_ctx); + if (retval != ERROR_OK) return retval; /* guard against oddball hardware: force resets to be inactive */ jtag_add_reset(0, 0); - if ((retval = jtag_execute_queue()) != ERROR_OK) + + /* some targets enable us to connect with srst asserted */ + if (jtag_reset_config & RESET_CNCT_UNDER_SRST) { + if (jtag_reset_config & RESET_SRST_NO_GATING) + jtag_add_reset(0, 1); + else + LOG_WARNING("\'srst_nogate\' reset_config option is required"); + } + retval = jtag_execute_queue(); + if (retval != ERROR_OK) return retval; if (Jim_Eval_Named(cmd_ctx->interp, "jtag_init", __FILE__, __LINE__) != JIM_OK) @@ -1576,29 +1608,25 @@ unsigned jtag_get_speed_khz(void) return speed_khz; } -static int adapter_khz_to_speed(unsigned khz, int* speed) +static int adapter_khz_to_speed(unsigned khz, int *speed) { LOG_DEBUG("convert khz to interface specific speed value"); speed_khz = khz; - if (jtag != NULL) - { + 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) - { return retval; - } *speed = speed_div1; } return ERROR_OK; } -static int jtag_rclk_to_speed(unsigned fallback_speed_khz, int* speed) +static int jtag_rclk_to_speed(unsigned fallback_speed_khz, int *speed) { int retval = adapter_khz_to_speed(0, speed); - if ((ERROR_OK != retval) && fallback_speed_khz) - { + if ((ERROR_OK != retval) && fallback_speed_khz) { LOG_DEBUG("trying fallback speed..."); retval = adapter_khz_to_speed(fallback_speed_khz, speed); } @@ -1634,11 +1662,7 @@ int jtag_config_rclk(unsigned fallback_speed_khz) int jtag_get_speed(int *speed) { - switch(clock_mode) - { - case CLOCK_MODE_SPEED: - *speed = jtag_speed; - break; + switch (clock_mode) { case CLOCK_MODE_KHZ: adapter_khz_to_speed(jtag_get_speed_khz(), speed); break; @@ -1654,7 +1678,7 @@ int jtag_get_speed(int *speed) int jtag_get_speed_readable(int *khz) { - int jtag_speed_var; + int jtag_speed_var = 0; int retval = jtag_get_speed(&jtag_speed_var); if (retval != ERROR_OK) return retval; @@ -1683,8 +1707,7 @@ bool jtag_will_verify_capture_ir() int jtag_power_dropout(int *dropout) { - if (jtag == NULL) - { + if (jtag == NULL) { /* TODO: as the jtag interface is not valid all * we can do at the moment is exit OpenOCD */ LOG_ERROR("No Valid JTAG Interface Configured."); @@ -1791,3 +1814,32 @@ bool transport_is_jtag(void) { return get_current_transport() == &jtag_transport; } + +void adapter_assert_reset(void) +{ + if (transport_is_jtag()) { + if (jtag_reset_config & RESET_SRST_PULLS_TRST) + jtag_add_reset(1, 1); + else + jtag_add_reset(0, 1); + } else if (transport_is_swd()) + swd_add_reset(1); + else if (get_current_transport() != NULL) + LOG_ERROR("reset is not supported on %s", + get_current_transport()->name); + else + LOG_ERROR("transport is not selected"); +} + +void adapter_deassert_reset(void) +{ + if (transport_is_jtag()) + jtag_add_reset(0, 0); + else if (transport_is_swd()) + swd_add_reset(0); + else if (get_current_transport() != NULL) + LOG_ERROR("reset is not supported on %s", + get_current_transport()->name); + else + LOG_ERROR("transport is not selected"); +}