X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fjtag.c;h=48921ebc4c67f8830925da7fad1931c8e5a3d0c0;hp=9a95de42b9ea152e02dd4178ea1b925ffa31c1a9;hb=21eff7095c50bcdc74000e6cda0c76aa3d16b854;hpb=7abe97565e77d5a9c34099ea15ad1608567b1581 diff --git a/src/jtag/jtag.c b/src/jtag/jtag.c index 9a95de42b9..48921ebc4c 100644 --- a/src/jtag/jtag.c +++ b/src/jtag/jtag.c @@ -2,6 +2,9 @@ * Copyright (C) 2005 by Dominic Rath * * Dominic.Rath@gmx.de * * * + * Copyright (C) 2007,2008 Øyvind Harboe * + * oyvind.harboe@zylin.com * + * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * @@ -27,27 +30,17 @@ #include "command.h" #include "log.h" -#include "interpreter.h" #include "stdlib.h" #include "string.h" #include - -/* 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 +/* 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; +int jtag_error=ERROR_OK; -char* tap_state_strings[16] = -{ - "tlr", - "sds", "cd", "sd", "e1d", "pd", "e2d", "ud", - "rti", - "sis", "ci", "si", "e1i", "pi", "e2i", "ui" -}; - typedef struct cmd_queue_page_s { void *address; @@ -65,18 +58,18 @@ static cmd_queue_page_t *cmd_queue_pages = NULL; * 3: Pause-DR * 4: Shift-IR * 5: Pause-IR - * - * SD->SD and SI->SI have to be caught in interface specific code + * + * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code */ u8 tap_move[6][6] = { -/* TLR RTI SD PD SI PI */ - {0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16}, /* TLR */ - {0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b}, /* RTI */ - {0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f}, /* SD */ - {0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f}, /* PD */ - {0x7f, 0x31, 0x07, 0x17, 0x00, 0x01}, /* SI */ - {0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f} /* PI */ +/* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ + { 0x7f, 0x00, 0x17, 0x0a, 0x1b, 0x16}, /* RESET */ + { 0x7f, 0x00, 0x25, 0x05, 0x2b, 0x0b}, /* IDLE */ + { 0x7f, 0x31, 0x00, 0x01, 0x0f, 0x2f}, /* DRSHIFT */ + { 0x7f, 0x30, 0x20, 0x17, 0x1e, 0x2f}, /* DRPAUSE */ + { 0x7f, 0x31, 0x07, 0x17, 0x00, 0x01}, /* IRSHIFT */ + { 0x7f, 0x30, 0x1c, 0x17, 0x20, 0x2f} /* IRPAUSE */ }; int tap_move_map[16] = { @@ -86,72 +79,87 @@ int tap_move_map[16] = { tap_transition_t tap_transitions[16] = { - {TAP_TLR, TAP_RTI}, /* TLR */ - {TAP_SIS, TAP_CD}, /* SDS */ - {TAP_E1D, TAP_SD}, /* CD */ - {TAP_E1D, TAP_SD}, /* SD */ - {TAP_UD, TAP_PD}, /* E1D */ - {TAP_E2D, TAP_PD}, /* PD */ - {TAP_UD, TAP_SD}, /* E2D */ - {TAP_SDS, TAP_RTI}, /* UD */ - {TAP_SDS, TAP_RTI}, /* RTI */ - {TAP_TLR, TAP_CI}, /* SIS */ - {TAP_E1I, TAP_SI}, /* CI */ - {TAP_E1I, TAP_SI}, /* SI */ - {TAP_UI, TAP_PI}, /* E1I */ - {TAP_E2I, TAP_PI}, /* PI */ - {TAP_UI, TAP_SI}, /* E2I */ - {TAP_SDS, TAP_RTI} /* UI */ + {TAP_RESET, TAP_IDLE}, /* RESET */ + {TAP_IRSELECT, TAP_DRCAPTURE}, /* DRSELECT */ + {TAP_DREXIT1, TAP_DRSHIFT}, /* DRCAPTURE */ + {TAP_DREXIT1, TAP_DRSHIFT}, /* DRSHIFT */ + {TAP_DRUPDATE, TAP_DRPAUSE}, /* DREXIT1 */ + {TAP_DREXIT2, TAP_DRPAUSE}, /* DRPAUSE */ + {TAP_DRUPDATE, TAP_DRSHIFT}, /* DREXIT2 */ + {TAP_DRSELECT, TAP_IDLE}, /* DRUPDATE */ + {TAP_DRSELECT, TAP_IDLE}, /* IDLE */ + {TAP_RESET, TAP_IRCAPTURE}, /* IRSELECT */ + {TAP_IREXIT1, TAP_IRSHIFT}, /* IRCAPTURE */ + {TAP_IREXIT1, TAP_IRSHIFT}, /* IRSHIFT */ + {TAP_IRUPDATE, TAP_IRPAUSE}, /* IREXIT1 */ + {TAP_IREXIT2, TAP_IRPAUSE}, /* IRPAUSE */ + {TAP_IRUPDATE, TAP_IRSHIFT}, /* IREXIT2 */ + {TAP_DRSELECT, TAP_IDLE} /* IRUPDATE */ }; char* jtag_event_strings[] = { - "JTAG controller reset(tms or TRST)" + "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 } }; -enum tap_state end_state = TAP_TLR; -enum tap_state cur_state = TAP_TLR; +/* kludge!!!! these are just global variables that the + * interface use internally. They really belong + * inside the drivers, but we don't want to break + * linking the drivers!!!! + */ +enum tap_state end_state = TAP_RESET; +enum tap_state cur_state = TAP_RESET; int jtag_trst = 0; int jtag_srst = 0; jtag_command_t *jtag_command_queue = NULL; jtag_command_t **last_comand_pointer = &jtag_command_queue; -jtag_device_t *jtag_devices = NULL; -int jtag_num_devices = 0; -int jtag_ir_scan_size = 0; +static jtag_tap_t *jtag_all_taps = NULL; + enum reset_types jtag_reset_config = RESET_NONE; -enum tap_state cmd_queue_end_state = TAP_TLR; -enum tap_state cmd_queue_cur_state = TAP_TLR; +enum tap_state cmd_queue_end_state = TAP_RESET; +enum tap_state cmd_queue_cur_state = TAP_RESET; int jtag_verify_capture_ir = 1; /* how long the OpenOCD should wait before attempting JTAG communication after reset lines deasserted (in ms) */ int jtag_nsrst_delay = 0; /* default to no nSRST delay */ -int jtag_ntrst_delay = 0; /* default to no nTRST delay */ +int jtag_ntrst_delay = 0; /* default to no nTRST delay */ /* maximum number of JTAG devices expected in the chain */ -#define JTAG_MAX_CHAIN_SIZE 20 +#define JTAG_MAX_CHAIN_SIZE 20 /* callbacks to inform high-level handlers about JTAG state changes */ jtag_event_callback_t *jtag_event_callbacks; /* speed in kHz*/ -static int speed1 = 0, speed2 = 0; +static int speed_khz = 0; /* flag if the kHz speed was defined */ static int hasKHz = 0; /* jtag interfaces (parport, FTDI-USB, TI-USB, ...) */ - + #if BUILD_ECOSBOARD == 1 - extern jtag_interface_t eCosBoard_interface; + extern jtag_interface_t zy1000_interface; #endif - + #if BUILD_PARPORT == 1 extern jtag_interface_t parport_interface; #endif +#if BUILD_DUMMY == 1 + extern jtag_interface_t dummy_interface; +#endif + #if BUILD_FT2232_FTD2XX == 1 extern jtag_interface_t ft2232_interface; #endif @@ -184,13 +192,28 @@ static int hasKHz = 0; extern jtag_interface_t usbprog_interface; #endif +#if BUILD_JLINK == 1 + extern jtag_interface_t jlink_interface; +#endif + +#if BUILD_VSLLINK == 1 + extern jtag_interface_t vsllink_interface; +#endif + +#if BUILD_RLINK == 1 + extern jtag_interface_t rlink_interface; +#endif + jtag_interface_t *jtag_interfaces[] = { #if BUILD_ECOSBOARD == 1 - &eCosBoard_interface, + &zy1000_interface, #endif #if BUILD_PARPORT == 1 &parport_interface, #endif +#if BUILD_DUMMY == 1 + &dummy_interface, +#endif #if BUILD_FT2232_FTD2XX == 1 &ft2232_interface, #endif @@ -214,6 +237,15 @@ jtag_interface_t *jtag_interfaces[] = { #endif #if BUILD_USBPROG == 1 &usbprog_interface, +#endif +#if BUILD_JLINK == 1 + &jlink_interface, +#endif +#if BUILD_VSLLINK == 1 + &vsllink_interface, +#endif +#if BUILD_RLINK == 1 + &rlink_interface, #endif NULL, }; @@ -223,8 +255,6 @@ jtag_interface_t *jtag = NULL; /* configuration */ jtag_interface_t *jtag_interface = NULL; int jtag_speed = 0; -int jtag_speed_post_reset = 0; - /* forward declarations */ void jtag_add_pathmove(int num_states, enum tap_state *path); @@ -232,7 +262,7 @@ void jtag_add_runtest(int num_cycles, enum tap_state endstate); void jtag_add_end_state(enum tap_state endstate); void jtag_add_sleep(u32 us); int jtag_execute_queue(void); -int jtag_cancel_queue(void); + /* jtag commands */ int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); @@ -249,43 +279,140 @@ int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char * int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv); int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +jtag_tap_t *jtag_AllTaps(void) +{ + return jtag_all_taps; +}; + +int jtag_NumTotalTaps(void) +{ + jtag_tap_t *t; + int n; + + n = 0; + t = jtag_AllTaps(); + while(t){ + n++; + t = t->next_tap; + } + return n; +} + +int jtag_NumEnabledTaps(void) +{ + jtag_tap_t *t; + int n; + + n = 0; + t = jtag_AllTaps(); + while(t){ + if( t->enabled ){ + n++; + } + t = t->next_tap; + } + return n; +} + + +jtag_tap_t *jtag_TapByString( const char *s ) +{ + jtag_tap_t *t; + char *cp; + + t = jtag_AllTaps(); + // try name first + while(t){ + if( 0 == strcmp( t->dotted_name, s ) ){ + break; + } else { + t = t->next_tap; + } + } + // backup plan is by number + if( t == NULL ){ + /* ok - is "s" a number? */ + int n; + n = strtol( s, &cp, 0 ); + if( (s != cp) && (*cp == 0) ){ + /* Then it is... */ + t = jtag_TapByAbsPosition(n); + } + } + return t; +} + +jtag_tap_t * jtag_TapByJimObj( Jim_Interp *interp, Jim_Obj *o ) +{ + jtag_tap_t *t; + const char *cp; + + cp = Jim_GetString( o, NULL ); + if(cp == NULL){ + cp = "(unknown)"; + t = NULL; + } else { + t = jtag_TapByString( cp ); + } + if( t == NULL ){ + Jim_SetResult_sprintf(interp,"Tap: %s is unknown", cp ); + } + return t; +} + +/* returns a pointer to the n-th device in the scan chain */ +jtag_tap_t * jtag_TapByAbsPosition( int n ) +{ + int orig_n; + jtag_tap_t *t; + + orig_n = n; + t = jtag_AllTaps(); + + while( t && (n > 0)) { + n--; + t = t->next_tap; + } + return t; +} + int jtag_register_event_callback(int (*callback)(enum jtag_event event, void *priv), void *priv) { jtag_event_callback_t **callbacks_p = &jtag_event_callbacks; - + if (callback == NULL) { return ERROR_INVALID_ARGUMENTS; } - + if (*callbacks_p) { while ((*callbacks_p)->next) callbacks_p = &((*callbacks_p)->next); callbacks_p = &((*callbacks_p)->next); } - + (*callbacks_p) = malloc(sizeof(jtag_event_callback_t)); (*callbacks_p)->callback = callback; (*callbacks_p)->priv = priv; (*callbacks_p)->next = NULL; - + return ERROR_OK; } int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void *priv)) { jtag_event_callback_t **callbacks_p = &jtag_event_callbacks; - + if (callback == NULL) { return ERROR_INVALID_ARGUMENTS; } - + while (*callbacks_p) { jtag_event_callback_t **next = &((*callbacks_p)->next); @@ -296,22 +423,22 @@ int jtag_unregister_event_callback(int (*callback)(enum jtag_event event, void * } callbacks_p = next; } - + return ERROR_OK; } int jtag_call_event_callbacks(enum jtag_event event) { jtag_event_callback_t *callback = jtag_event_callbacks; - + LOG_DEBUG("jtag event: %s", jtag_event_strings[event]); - + while (callback) { callback->callback(event, callback->priv); callback = callback->next; } - + return ERROR_OK; } @@ -322,40 +449,55 @@ int jtag_call_event_callbacks(enum jtag_event event) jtag_command_t** jtag_get_last_command_p(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_comand_pointer; -} -/* returns a pointer to the n-th device in the scan chain */ -jtag_device_t* jtag_get_device(int num) -{ - jtag_device_t *device = jtag_devices; - int i = 0; + return &cmd->next;*/ - while (device) - { - if (num == i) - return device; - device = device->next; - i++; - } - - LOG_ERROR("jtag device number %d not defined", num); - exit(-1); + return last_comand_pointer; } 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) { @@ -375,12 +517,12 @@ void* cmd_queue_alloc(size_t size) offset = (*p_page)->used; (*p_page)->used += size; - - u8 *t=(u8 *)((*p_page)->address); + + t=(u8 *)((*p_page)->address); return t + offset; } -void cmd_queue_free() +void cmd_queue_free(void) { cmd_queue_page_t *page = cmd_queue_pages; @@ -395,7 +537,7 @@ void cmd_queue_free() cmd_queue_pages = NULL; } -static void jtag_prelude1() +static void jtag_prelude1(void) { if (jtag_trst == 1) { @@ -404,14 +546,14 @@ static void jtag_prelude1() return; } - if (cmd_queue_end_state == TAP_TLR) + if (cmd_queue_end_state == TAP_RESET) jtag_call_event_callbacks(JTAG_TRST_ASSERTED); } static void jtag_prelude(enum tap_state state) { jtag_prelude1(); - + if (state != -1) jtag_add_end_state(state); @@ -420,23 +562,27 @@ static void jtag_prelude(enum tap_state state) void jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) { + int retval; + jtag_prelude(state); - - int retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_state); + + retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_state); if (retval!=ERROR_OK) jtag_error=retval; } int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state) -{ +{ jtag_command_t **last_cmd; - jtag_device_t *device; - int i, j; + jtag_tap_t *tap; + int j; + int x; + int nth_tap; int scan_size = 0; last_cmd = jtag_get_last_command_p(); - + /* allocate memory for a new list member */ *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); (*last_cmd)->next = NULL; @@ -446,69 +592,78 @@ int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, /* allocate memory for ir scan command */ (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t)); (*last_cmd)->cmd.scan->ir_scan = 1; - (*last_cmd)->cmd.scan->num_fields = jtag_num_devices; /* one field per device */ - (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(jtag_num_devices * sizeof(scan_field_t)); + x = jtag_NumEnabledTaps(); + (*last_cmd)->cmd.scan->num_fields = x; /* one field per device */ + (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(x * sizeof(scan_field_t)); (*last_cmd)->cmd.scan->end_state = state; - for (i = 0; i < jtag_num_devices; i++) - { + nth_tap = -1; + tap = NULL; + for(;;){ int found = 0; - device = jtag_get_device(i); - scan_size = device->ir_length; - (*last_cmd)->cmd.scan->fields[i].device = i; - (*last_cmd)->cmd.scan->fields[i].num_bits = scan_size; - (*last_cmd)->cmd.scan->fields[i].in_value = NULL; - (*last_cmd)->cmd.scan->fields[i].in_handler = NULL; /* disable verification by default */ + + // do this here so it is not forgotten + tap = jtag_NextEnabledTap(tap); + if( tap == NULL ){ + break; + } + nth_tap++; + scan_size = tap->ir_length; + (*last_cmd)->cmd.scan->fields[nth_tap].tap = tap; + (*last_cmd)->cmd.scan->fields[nth_tap].num_bits = scan_size; + (*last_cmd)->cmd.scan->fields[nth_tap].in_value = NULL; + (*last_cmd)->cmd.scan->fields[nth_tap].in_handler = NULL; /* disable verification by default */ /* search the list */ for (j = 0; j < num_fields; j++) { - if (i == fields[j].device) + if (tap == fields[j].tap) { found = 1; - (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); - (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); - + (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); + (*last_cmd)->cmd.scan->fields[nth_tap].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); + if (jtag_verify_capture_ir) { if (fields[j].in_handler==NULL) { - jtag_set_check_value((*last_cmd)->cmd.scan->fields+i, device->expected, device->expected_mask, NULL); + jtag_set_check_value((*last_cmd)->cmd.scan->fields+nth_tap, tap->expected, tap->expected_mask, NULL); } else { - (*last_cmd)->cmd.scan->fields[i].in_handler = fields[j].in_handler; - (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[j].in_handler_priv; - (*last_cmd)->cmd.scan->fields[i].in_check_value = device->expected; - (*last_cmd)->cmd.scan->fields[i].in_check_mask = device->expected_mask; + (*last_cmd)->cmd.scan->fields[nth_tap].in_handler = fields[j].in_handler; + (*last_cmd)->cmd.scan->fields[nth_tap].in_handler_priv = fields[j].in_handler_priv; + (*last_cmd)->cmd.scan->fields[nth_tap].in_check_value = tap->expected; + (*last_cmd)->cmd.scan->fields[nth_tap].in_check_mask = tap->expected_mask; } } - - device->bypass = 0; + + tap->bypass = 0; break; } } - + if (!found) { - /* if a device isn't listed, set it to BYPASS */ - (*last_cmd)->cmd.scan->fields[i].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); - (*last_cmd)->cmd.scan->fields[i].out_mask = NULL; - device->bypass = 1; - + /* if a tap isn't listed, set it to BYPASS */ + (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); + (*last_cmd)->cmd.scan->fields[nth_tap].out_mask = NULL; + tap->bypass = 1; } - + /* update device information */ - buf_cpy((*last_cmd)->cmd.scan->fields[i].out_value, jtag_get_device(i)->cur_instr, scan_size); + buf_cpy((*last_cmd)->cmd.scan->fields[nth_tap].out_value, tap->cur_instr, scan_size); } - + return ERROR_OK; } void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) { + int retval; + jtag_prelude(state); - - int retval=interface_jtag_add_plain_ir_scan(num_fields, fields, cmd_queue_end_state); + + retval=interface_jtag_add_plain_ir_scan(num_fields, fields, cmd_queue_end_state); if (retval!=ERROR_OK) jtag_error=retval; } @@ -517,9 +672,9 @@ int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *f { int i; jtag_command_t **last_cmd; - + last_cmd = jtag_get_last_command_p(); - + /* allocate memory for a new list member */ *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); (*last_cmd)->next = NULL; @@ -533,11 +688,10 @@ int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *f (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t)); (*last_cmd)->cmd.scan->end_state = state; - for (i = 0; i < num_fields; i++) - { + for( i = 0 ; i < num_fields ; i++ ){ int num_bits = fields[i].num_bits; int num_bytes = CEIL(fields[i].num_bits, 8); - (*last_cmd)->cmd.scan->fields[i].device = fields[i].device; + (*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap; (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits; (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits); (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits); @@ -552,31 +706,39 @@ int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *f void jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) { + int retval; + jtag_prelude(state); - int retval=interface_jtag_add_dr_scan(num_fields, fields, cmd_queue_end_state); + retval=interface_jtag_add_dr_scan(num_fields, fields, cmd_queue_end_state); if (retval!=ERROR_OK) jtag_error=retval; } int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state) { - int i, j; + int j; + int nth_tap; int bypass_devices = 0; int field_count = 0; int scan_size; jtag_command_t **last_cmd = jtag_get_last_command_p(); - jtag_device_t *device = jtag_devices; + jtag_tap_t *tap; /* count devices in bypass */ - while (device) - { - if (device->bypass) + tap = NULL; + bypass_devices = 0; + for(;;){ + tap = jtag_NextEnabledTap(tap); + if( tap == NULL ){ + break; + } + if( tap->bypass ){ bypass_devices++; - device = device->next; + } } - + /* allocate memory for a new list member */ *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); last_comand_pointer = &((*last_cmd)->next); @@ -589,15 +751,21 @@ int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices; (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t)); (*last_cmd)->cmd.scan->end_state = state; - - for (i = 0; i < jtag_num_devices; i++) - { + + tap = NULL; + nth_tap = -1; + for(;;){ + nth_tap++; + tap = jtag_NextEnabledTap(tap); + if( tap == NULL ){ + break; + } int found = 0; - (*last_cmd)->cmd.scan->fields[field_count].device = i; - + (*last_cmd)->cmd.scan->fields[field_count].tap = tap; + for (j = 0; j < num_fields; j++) { - if (i == fields[j].device) + if (tap == fields[j].tap) { found = 1; scan_size = fields[j].num_bits; @@ -615,12 +783,12 @@ int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, { #ifdef _DEBUG_JTAG_IO_ /* if a device isn't listed, the BYPASS register should be selected */ - if (!jtag_get_device(i)->bypass) + if (! tap->bypass) { LOG_ERROR("BUG: no scan data for a device not in BYPASS"); exit(-1); } -#endif +#endif /* program the scan field to 1 bit length, and ignore it's value */ (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1; (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL; @@ -635,7 +803,7 @@ int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, { #ifdef _DEBUG_JTAG_IO_ /* if a device is listed, the BYPASS register must not be selected */ - if (jtag_get_device(i)->bypass) + if (tap->bypass) { LOG_ERROR("BUG: scan data for a device in BYPASS"); exit(-1); @@ -646,27 +814,33 @@ int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, return ERROR_OK; } -void MINIDRIVER(interface_jtag_add_dr_out)(int device_num, +void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap, int num_fields, - int *num_bits, - u32 *value, + const int *num_bits, + const u32 *value, enum tap_state end_state) { - int i; + int nth_tap; int field_count = 0; int scan_size; int bypass_devices = 0; jtag_command_t **last_cmd = jtag_get_last_command_p(); - jtag_device_t *device = jtag_devices; + jtag_tap_t *tap; + /* count devices in bypass */ - while (device) - { - if (device->bypass) + tap = NULL; + bypass_devices = 0; + for(;;){ + tap = jtag_NextEnabledTap(tap); + if( tap == NULL ){ + break; + } + if( tap->bypass ){ bypass_devices++; - device = device->next; + } } - + /* allocate memory for a new list member */ *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); last_comand_pointer = &((*last_cmd)->next); @@ -679,17 +853,23 @@ void MINIDRIVER(interface_jtag_add_dr_out)(int device_num, (*last_cmd)->cmd.scan->num_fields = num_fields + bypass_devices; (*last_cmd)->cmd.scan->fields = cmd_queue_alloc((num_fields + bypass_devices) * sizeof(scan_field_t)); (*last_cmd)->cmd.scan->end_state = end_state; - - for (i = 0; i < jtag_num_devices; i++) - { - (*last_cmd)->cmd.scan->fields[field_count].device = i; - - if (i == device_num) + + tap = NULL; + nth_tap = -1; + for(;;){ + tap = jtag_NextEnabledTap(tap); + if( tap == NULL ){ + break; + } + nth_tap++; + (*last_cmd)->cmd.scan->fields[field_count].tap = tap; + + if (tap == target_tap) { int j; #ifdef _DEBUG_JTAG_IO_ /* if a device is listed, the BYPASS register must not be selected */ - if (jtag_get_device(i)->bypass) + if (tap->bypass) { LOG_ERROR("BUG: scan data for a device in BYPASS"); exit(-1); @@ -713,12 +893,12 @@ void MINIDRIVER(interface_jtag_add_dr_out)(int device_num, { #ifdef _DEBUG_JTAG_IO_ /* if a device isn't listed, the BYPASS register should be selected */ - if (!jtag_get_device(i)->bypass) + if (! tap->bypass) { LOG_ERROR("BUG: no scan data for a device not in BYPASS"); exit(-1); } -#endif +#endif /* program the scan field to 1 bit length, and ignore it's value */ (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1; (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL; @@ -732,14 +912,13 @@ void MINIDRIVER(interface_jtag_add_dr_out)(int device_num, } } - - - void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) { + int retval; + jtag_prelude(state); - int retval=interface_jtag_add_plain_dr_scan(num_fields, fields, cmd_queue_end_state); + retval=interface_jtag_add_plain_dr_scan(num_fields, fields, cmd_queue_end_state); if (retval!=ERROR_OK) jtag_error=retval; } @@ -748,7 +927,7 @@ int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *f { int i; jtag_command_t **last_cmd = jtag_get_last_command_p(); - + /* allocate memory for a new list member */ *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); last_comand_pointer = &((*last_cmd)->next); @@ -761,12 +940,12 @@ int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *f (*last_cmd)->cmd.scan->num_fields = num_fields; (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(num_fields * sizeof(scan_field_t)); (*last_cmd)->cmd.scan->end_state = state; - + for (i = 0; i < num_fields; i++) { int num_bits = fields[i].num_bits; int num_bytes = CEIL(fields[i].num_bits, 8); - (*last_cmd)->cmd.scan->fields[i].device = fields[i].device; + (*last_cmd)->cmd.scan->fields[i].tap = fields[i].tap; (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits; (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[i].out_value, cmd_queue_alloc(num_bytes), num_bits); (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[i].out_mask, cmd_queue_alloc(num_bytes), num_bits); @@ -780,21 +959,21 @@ int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *f return ERROR_OK; } -void jtag_add_tms() +void jtag_add_tlr(void) { - jtag_prelude(TAP_TLR); - + jtag_prelude(TAP_RESET); + int retval; - retval=interface_jtag_add_tms(); + retval=interface_jtag_add_tlr(); if (retval!=ERROR_OK) jtag_error=retval; } -int MINIDRIVER(interface_jtag_add_tms)() +int MINIDRIVER(interface_jtag_add_tlr)() { - enum tap_state state = TAP_TLR; + enum tap_state state = TAP_RESET; jtag_command_t **last_cmd = jtag_get_last_command_p(); - + /* allocate memory for a new list member */ *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); last_comand_pointer = &((*last_cmd)->next); @@ -803,13 +982,17 @@ int MINIDRIVER(interface_jtag_add_tms)() (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t)); (*last_cmd)->cmd.statemove->end_state = state; - - + + return ERROR_OK; } void jtag_add_pathmove(int num_states, enum tap_state *path) { + enum tap_state cur_state=cmd_queue_cur_state; + int i; + int retval; + /* the last state has to be a stable state */ if (tap_move_map[path[num_states - 1]] == -1) { @@ -817,34 +1000,35 @@ void jtag_add_pathmove(int num_states, enum tap_state *path) exit(-1); } - enum tap_state cur_state=cmd_queue_cur_state; - int i; for (i=0; i %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[path[i]]); + LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", jtag_state_name(cur_state), jtag_state_name(path[i])); exit(-1); } cur_state = path[i]; } - + jtag_prelude1(); - - cmd_queue_cur_state = path[num_states - 1]; - int retval=interface_jtag_add_pathmove(num_states, path); + retval=interface_jtag_add_pathmove(num_states, path); + cmd_queue_cur_state = path[num_states - 1]; if (retval!=ERROR_OK) jtag_error=retval; } - int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, enum tap_state *path) { jtag_command_t **last_cmd = jtag_get_last_command_p(); int i; - + /* allocate memory for a new list member */ *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); last_comand_pointer = &((*last_cmd)->next); @@ -854,17 +1038,17 @@ int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, enum tap_state *path (*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t)); (*last_cmd)->cmd.pathmove->num_states = num_states; (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(enum tap_state) * num_states); - + for (i = 0; i < num_states; i++) (*last_cmd)->cmd.pathmove->path[i] = path[i]; - + return ERROR_OK; } int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, enum tap_state state) { jtag_command_t **last_cmd = jtag_get_last_command_p(); - + /* allocate memory for a new list member */ *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); (*last_cmd)->next = NULL; @@ -874,61 +1058,80 @@ int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, enum tap_state state) (*last_cmd)->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t)); (*last_cmd)->cmd.runtest->num_cycles = num_cycles; (*last_cmd)->cmd.runtest->end_state = state; - + return ERROR_OK; } void jtag_add_runtest(int num_cycles, enum tap_state state) { + int retval; + jtag_prelude(state); - + /* executed by sw or hw fifo */ - int retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state); + retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state); if (retval!=ERROR_OK) jtag_error=retval; } -void jtag_add_reset(int req_tms_or_trst, int req_srst) +void jtag_add_reset(int req_tlr_or_trst, int req_srst) { - int trst_with_tms = 0; + int trst_with_tlr = 0; int retval; - + + /* FIX!!! there are *many* different cases here. A better + * approach is needed for legal combinations of transitions... + */ + 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"); + } + } + /* 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_tms_or_trst)) + if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst)) { LOG_ERROR("BUG: requested reset would assert trst"); jtag_error=ERROR_FAIL; return; } - + /* if TRST pulls SRST, we reset with TAP T-L-R */ - if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tms_or_trst)) && (req_srst == 0)) + if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0)) { - trst_with_tms = 1; + trst_with_tlr = 1; } - + if (req_srst && !(jtag_reset_config & RESET_HAS_SRST)) { LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this"); jtag_error=ERROR_FAIL; return; } - - if (req_tms_or_trst) + + if (req_tlr_or_trst) { - if (!trst_with_tms && (jtag_reset_config & RESET_HAS_TRST)) + if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST)) { jtag_trst = 1; } else { - trst_with_tms = 1; + trst_with_tlr = 1; } } else { jtag_trst = 0; } - + jtag_srst = req_srst; retval = interface_jtag_add_reset(jtag_trst, jtag_srst); @@ -948,23 +1151,23 @@ void jtag_add_reset(int req_tms_or_trst, int req_srst) if (jtag_nsrst_delay) jtag_add_sleep(jtag_nsrst_delay * 1000); } - - if (trst_with_tms) + + if (trst_with_tlr) { - LOG_DEBUG("JTAG reset with tms instead of TRST"); - jtag_add_end_state(TAP_TLR); - jtag_add_tms(); + LOG_DEBUG("JTAG reset with RESET instead of TRST"); + jtag_add_end_state(TAP_RESET); + jtag_add_tlr(); jtag_call_event_callbacks(JTAG_TRST_ASSERTED); 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"); - cmd_queue_cur_state = TAP_TLR; + cmd_queue_cur_state = TAP_RESET; jtag_call_event_callbacks(JTAG_TRST_ASSERTED); } else @@ -988,23 +1191,22 @@ int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst) (*last_cmd)->cmd.reset->trst = req_trst; (*last_cmd)->cmd.reset->srst = req_srst; - return ERROR_OK; } void jtag_add_end_state(enum tap_state state) { cmd_queue_end_state = state; - if ((cmd_queue_end_state == TAP_SD)||(cmd_queue_end_state == TAP_SD)) + if ((cmd_queue_end_state == TAP_DRSHIFT)||(cmd_queue_end_state == TAP_IRSHIFT)) { - LOG_ERROR("BUG: TAP_SD/SI can't be end state. Calling code should use a larger scan field"); + 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) { jtag_command_t **last_cmd = jtag_get_last_command_p(); - + /* allocate memory for a new list member */ *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); (*last_cmd)->next = NULL; @@ -1013,12 +1215,13 @@ int MINIDRIVER(interface_jtag_add_sleep)(u32 us) (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t)); (*last_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; @@ -1043,10 +1246,10 @@ int jtag_build_buffer(scan_command_t *cmd, u8 **buffer) { int bit_count = 0; int i; - + bit_count = jtag_scan_size(cmd); *buffer = malloc(CEIL(bit_count, 8)); - + bit_count = 0; for (i = 0; i < cmd->num_fields; i++) @@ -1062,12 +1265,11 @@ int jtag_build_buffer(scan_command_t *cmd, u8 **buffer) free(char_buf); #endif } - + bit_count += cmd->fields[i].num_bits; } return bit_count; - } int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) @@ -1075,10 +1277,10 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) 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 neither in_value nor in_handler @@ -1088,7 +1290,7 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) { 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; @@ -1096,21 +1298,21 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) LOG_DEBUG("fields[%i].in_value: 0x%s", i, char_buf); free(char_buf); #endif - + if (cmd->fields[i].in_value) { buf_cpy(captured, cmd->fields[i].in_value, num_bits); - + if (cmd->fields[i].in_handler) { if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK) { - LOG_WARNING("in_handler reported a failed check"); + LOG_WARNING("in_handler: with \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" ); retval = ERROR_JTAG_QUEUE_FAILED; } } } - + /* no in_value specified, but a handler takes care of the scanned data */ if (cmd->fields[i].in_handler && (!cmd->fields[i].in_value)) { @@ -1119,7 +1321,7 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) /* We're going to call the error:handler later, but if the in_handler * reported an error we report this failure upstream */ - LOG_WARNING("in_handler reported a failed check"); + LOG_WARNING("in_handler: w/o \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" ); retval = ERROR_JTAG_QUEUE_FAILED; } } @@ -1136,20 +1338,21 @@ int jtag_check_value(u8 *captured, void *priv, scan_field_t *field) { int retval = ERROR_OK; int num_bits = field->num_bits; - + int compare_failed = 0; - + if (field->in_check_mask) compare_failed = buf_cmp_mask(captured, field->in_check_value, field->in_check_mask, num_bits); else compare_failed = buf_cmp(captured, field->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 - */ + */ + LOG_WARNING("TAP %s:", + (field->tap == NULL) ? "(unknown)" : field->tap->dotted_name ); if (compare_failed) { char *captured_char = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16); @@ -1159,7 +1362,9 @@ int jtag_check_value(u8 *captured, void *priv, scan_field_t *field) { char *in_check_mask_char; in_check_mask_char = buf_to_str(field->in_check_mask, (num_bits > 64) ? 64 : num_bits, 16); - LOG_WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s check_mask: 0x%s", captured_char, in_check_value_char, in_check_mask_char); + LOG_WARNING("value captured during scan didn't pass the requested check:"); + LOG_WARNING("captured: 0x%s check_value: 0x%s check_mask: 0x%s", + captured_char, in_check_value_char, in_check_mask_char); free(in_check_mask_char); } else @@ -1169,15 +1374,15 @@ int jtag_check_value(u8 *captured, void *priv, scan_field_t *field) free(captured_char); free(in_check_value_char); - + retval = ERROR_JTAG_QUEUE_FAILED; } - + } return retval; } -/* +/* set up checking of this field using the in_handler. The values passed in must be valid until after jtag_execute() has completed. */ @@ -1187,7 +1392,7 @@ void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, error_handle field->in_handler = jtag_check_value; else field->in_handler = NULL; /* No check, e.g. embeddedice uses value==NULL to indicate no check */ - field->in_handler_priv = NULL; /* this will be filled in at the invocation site to point to the field duplicate */ + field->in_handler_priv = NULL; field->in_check_value = value; field->in_check_mask = mask; } @@ -1196,7 +1401,7 @@ enum scan_type jtag_scan_type(scan_command_t *cmd) { int i; int type = 0; - + for (i = 0; i < cmd->num_fields; i++) { if (cmd->fields[i].in_value || cmd->fields[i].in_handler) @@ -1212,8 +1417,14 @@ int MINIDRIVER(interface_jtag_execute_queue)(void) { int retval; + if (jtag==NULL) + { + LOG_ERROR("No JTAG interface configured yet. Issue 'init' command in startup scripts before communicating with targets."); + return ERROR_FAIL; + } + retval = jtag->execute_queue(); - + cmd_queue_free(); jtag_command_queue = NULL; @@ -1235,29 +1446,29 @@ int jtag_execute_queue(void) int jtag_reset_callback(enum jtag_event event, void *priv) { - jtag_device_t *device = priv; + jtag_tap_t *tap = priv; LOG_DEBUG("-"); - + if (event == JTAG_TRST_ASSERTED) { - buf_set_ones(device->cur_instr, device->ir_length); - device->bypass = 1; + buf_set_ones(tap->cur_instr, tap->ir_length); + tap->bypass = 1; } - + return ERROR_OK; } void jtag_sleep(u32 us) { - usleep(us); + alive_sleep(us/1000); } /* Try to examine chain layout according to IEEE 1149.1 §12 */ -int jtag_examine_chain() +int jtag_examine_chain(void) { - jtag_device_t *device = jtag_devices; + jtag_tap_t *tap; scan_field_t field; u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4]; int i; @@ -1265,8 +1476,8 @@ int jtag_examine_chain() int device_count = 0; u8 zero_check = 0x0; u8 one_check = 0xff; - - field.device = 0; + + field.tap = NULL; field.num_bits = sizeof(idcode_buffer) * 8; field.out_value = idcode_buffer; field.out_mask = NULL; @@ -1275,36 +1486,44 @@ int jtag_examine_chain() field.in_check_mask = NULL; field.in_handler = NULL; field.in_handler_priv = NULL; - + for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++) { buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF); } - - jtag_add_plain_dr_scan(1, &field, TAP_TLR); + + jtag_add_plain_dr_scan(1, &field, TAP_RESET); jtag_execute_queue(); - + for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++) { zero_check |= idcode_buffer[i]; one_check &= idcode_buffer[i]; } - + /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */ if ((zero_check == 0x00) || (one_check == 0xff)) { LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc."); return ERROR_JTAG_INIT_FAILED; } - + + // point at the 1st tap + tap = jtag_NextEnabledTap(NULL); + if( tap == NULL ){ + LOG_ERROR("JTAG: No taps enabled?"); + return ERROR_JTAG_INIT_FAILED; + } + for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;) { u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32); if ((idcode & 1) == 0) { /* LSB must not be 0, this indicates a device in bypass */ - device_count++; - + LOG_WARNING("Tap/Device does not have IDCODE"); + idcode=0; + bit_count += 1; } else @@ -1312,62 +1531,129 @@ int jtag_examine_chain() u32 manufacturer; u32 part; u32 version; - + if (idcode == 0x000000FF) { - /* End of chain (invalid manufacturer ID) */ + int unexpected=0; + /* End of chain (invalid manufacturer ID) + * + * The JTAG examine is the very first thing that happens + * + * A single JTAG device requires only 64 bits to be read back correctly. + * + * The code below adds a check that the rest of the data scanned (640 bits) + * are all as expected. This helps diagnose/catch problems with the JTAG chain + * + * earlier and gives more helpful/explicit error messages. + */ + for (bit_count += 32; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;bit_count += 32) + { + idcode = buf_get_u32(idcode_buffer, bit_count, 32); + if (unexpected||(idcode != 0x000000FF)) + { + LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count, idcode); + unexpected = 1; + } + } + break; } - - if (device) - { - device->idcode = idcode; - device = device->next; - } - device_count++; - - manufacturer = (idcode & 0xffe) >> 1; - part = (idcode & 0xffff000) >> 12; - version = (idcode & 0xf0000000) >> 28; - LOG_INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)", +#define EXTRACT_MFG(X) (((X) & 0xffe) >> 1) + manufacturer = EXTRACT_MFG(idcode); +#define EXTRACT_PART(X) (((X) & 0xffff000) >> 12) + part = EXTRACT_PART(idcode); +#define EXTRACT_VER(X) (((X) & 0xf0000000) >> 28) + version = EXTRACT_VER(idcode); + + LOG_INFO("JTAG tap: %s tap/device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)", + ((tap != NULL) ? (tap->dotted_name) : "(not-named)"), idcode, manufacturer, part, version); - + bit_count += 32; } + if (tap) + { + tap->idcode = idcode; + + if (tap->expected_ids_cnt > 0) { + /* Loop over the expected identification codes and test for a match */ + u8 ii; + for (ii = 0; ii < tap->expected_ids_cnt; ii++) { + if( tap->idcode == tap->expected_ids[ii] ){ + break; + } + } + + /* If none of the expected ids matched, log an error */ + if (ii == tap->expected_ids_cnt) { + LOG_ERROR("JTAG tap: %s got: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)", + tap->dotted_name, + idcode, + EXTRACT_MFG( tap->idcode ), + EXTRACT_PART( tap->idcode ), + EXTRACT_VER( tap->idcode ) ); + for (ii = 0; ii < tap->expected_ids_cnt; ii++) { + LOG_ERROR("JTAG tap: %s expected %hhu of %hhu: 0x%08x (mfg: 0x%3.3x, part: 0x%4.4x, ver: 0x%1.1x)", + tap->dotted_name, + ii + 1, + tap->expected_ids_cnt, + tap->expected_ids[ii], + EXTRACT_MFG( tap->expected_ids[ii] ), + EXTRACT_PART( tap->expected_ids[ii] ), + EXTRACT_VER( tap->expected_ids[ii] ) ); + } + + return ERROR_JTAG_INIT_FAILED; + } else { + LOG_INFO("JTAG Tap/device matched"); + } + } else { +#if 0 + LOG_INFO("JTAG TAP ID: 0x%08x - Unknown - please report (A) chipname and (B) idcode to the openocd project", + tap->idcode); +#endif + } + tap = jtag_NextEnabledTap(tap); + } + device_count++; } - + /* see if number of discovered devices matches configuration */ - if (device_count != jtag_num_devices) + if (device_count != jtag_NumEnabledTaps()) { - LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)", - device_count, jtag_num_devices); + LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match (enabled) configuration (%i), total taps: %d", + device_count, jtag_NumEnabledTaps(), jtag_NumTotalTaps()); LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)"); return ERROR_JTAG_INIT_FAILED; } - + return ERROR_OK; } -int jtag_validate_chain() +int jtag_validate_chain(void) { - jtag_device_t *device = jtag_devices; + jtag_tap_t *tap; int total_ir_length = 0; u8 *ir_test = NULL; scan_field_t field; int chain_pos = 0; - - while (device) - { - total_ir_length += device->ir_length; - device = device->next; + + tap = NULL; + total_ir_length = 0; + for(;;){ + tap = jtag_NextEnabledTap(tap); + if( tap == NULL ){ + break; + } + total_ir_length += tap->ir_length; } - + total_ir_length += 2; ir_test = malloc(CEIL(total_ir_length, 8)); buf_set_ones(ir_test, total_ir_length); - - field.device = 0; + + field.tap = NULL; field.num_bits = total_ir_length; field.out_value = ir_test; field.out_mask = NULL; @@ -1376,13 +1662,19 @@ int jtag_validate_chain() field.in_check_mask = NULL; field.in_handler = NULL; field.in_handler_priv = NULL; - - jtag_add_plain_ir_scan(1, &field, TAP_TLR); + + jtag_add_plain_ir_scan(1, &field, TAP_RESET); jtag_execute_queue(); - - device = jtag_devices; - while (device) - { + + tap = NULL; + chain_pos = 0; + for(;;){ + tap = jtag_NextEnabledTap(tap); + if( tap == NULL ){ + break; + } + + if (buf_get_u32(ir_test, chain_pos, 2) != 0x1) { char *cbuf = buf_to_str(ir_test, total_ir_length, 16); @@ -1391,10 +1683,9 @@ int jtag_validate_chain() free(ir_test); return ERROR_JTAG_INIT_FAILED; } - chain_pos += device->ir_length; - device = device->next; + chain_pos += tap->ir_length; } - + if (buf_get_u32(ir_test, chain_pos, 2) != 0x3) { char *cbuf = buf_to_str(ir_test, total_ir_length, 16); @@ -1403,18 +1694,452 @@ int jtag_validate_chain() free(ir_test); return ERROR_JTAG_INIT_FAILED; } - + free(ir_test); - + + return ERROR_OK; +} + +enum jtag_tap_cfg_param { + JCFG_EVENT +}; + +static Jim_Nvp nvp_config_opts[] = { + { .name = "-event", .value = JCFG_EVENT }, + + { .name = NULL, .value = -1 } +}; + +static int +jtag_tap_configure_cmd( Jim_GetOptInfo *goi, + jtag_tap_t * tap) +{ + Jim_Nvp *n; + Jim_Obj *o; + int e; + + /* parse config or cget options */ + while (goi->argc > 0) { + Jim_SetEmptyResult (goi->interp); + + e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n); + if (e != JIM_OK) { + Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0); + return e; + } + + switch (n->value) { + case JCFG_EVENT: + if (goi->argc == 0) { + Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ..." ); + return JIM_ERR; + } + + e = Jim_GetOpt_Nvp( goi, nvp_jtag_tap_event, &n ); + if (e != JIM_OK) { + Jim_GetOpt_NvpUnknown(goi, nvp_jtag_tap_event, 1); + return e; + } + + if (goi->isconfigure) { + if (goi->argc != 1) { + Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name? ?EVENT-BODY?"); + return JIM_ERR; + } + } else { + if (goi->argc != 0) { + Jim_WrongNumArgs(goi->interp, goi->argc, goi->argv, "-event ?event-name?"); + return JIM_ERR; + } + } + + { + jtag_tap_event_action_t *jteap; + + jteap = tap->event_action; + /* replace existing? */ + while (jteap) { + if (jteap->event == n->value) { + break; + } + jteap = jteap->next; + } + + if (goi->isconfigure) { + if (jteap == NULL) { + /* create new */ + jteap = calloc(1, sizeof (*jteap)); + } + jteap->event = n->value; + Jim_GetOpt_Obj( goi, &o); + if (jteap->body) { + Jim_DecrRefCount(interp, jteap->body); + } + jteap->body = Jim_DuplicateObj(goi->interp, o); + Jim_IncrRefCount(jteap->body); + + /* add to head of event list */ + jteap->next = tap->event_action; + tap->event_action = jteap; + Jim_SetEmptyResult(goi->interp); + } else { + /* get */ + if (jteap == NULL) { + Jim_SetEmptyResult(goi->interp); + } else { + Jim_SetResult(goi->interp, Jim_DuplicateObj(goi->interp, jteap->body)); + } + } + } + /* loop for more */ + break; + } + } /* while (goi->argc) */ + + return JIM_OK; +} + +static int jim_newtap_cmd( Jim_GetOptInfo *goi ) +{ + jtag_tap_t *pTap; + jtag_tap_t **ppTap; + jim_wide w; + int x; + int e; + int reqbits; + Jim_Nvp *n; + char *cp; + const Jim_Nvp opts[] = { +#define NTAP_OPT_IRLEN 0 + { .name = "-irlen" , .value = NTAP_OPT_IRLEN }, +#define NTAP_OPT_IRMASK 1 + { .name = "-irmask" , .value = NTAP_OPT_IRMASK }, +#define NTAP_OPT_IRCAPTURE 2 + { .name = "-ircapture" , .value = NTAP_OPT_IRCAPTURE }, +#define NTAP_OPT_ENABLED 3 + { .name = "-enable" , .value = NTAP_OPT_ENABLED }, +#define NTAP_OPT_DISABLED 4 + { .name = "-disable" , .value = NTAP_OPT_DISABLED }, +#define NTAP_OPT_EXPECTED_ID 5 + { .name = "-expected-id" , .value = NTAP_OPT_EXPECTED_ID }, + { .name = NULL , .value = -1 }, + }; + + pTap = malloc( sizeof(jtag_tap_t) ); + memset( pTap, 0, sizeof(*pTap) ); + if( !pTap ){ + Jim_SetResult_sprintf( goi->interp, "no memory"); + return JIM_ERR; + } + /* + * we expect CHIP + TAP + OPTIONS + * */ + if( goi->argc < 3 ){ + Jim_SetResult_sprintf(goi->interp, "Missing CHIP TAP OPTIONS ...."); + return JIM_ERR; + } + Jim_GetOpt_String( goi, &cp, NULL ); + pTap->chip = strdup(cp); + + Jim_GetOpt_String( goi, &cp, NULL ); + pTap->tapname = strdup(cp); + + /* name + dot + name + null */ + x = strlen(pTap->chip) + 1 + strlen(pTap->tapname) + 1; + cp = malloc( x ); + sprintf( cp, "%s.%s", pTap->chip, pTap->tapname ); + pTap->dotted_name = cp; + + LOG_DEBUG("Creating New Tap, Chip: %s, Tap: %s, Dotted: %s, %d params", + pTap->chip, pTap->tapname, pTap->dotted_name, goi->argc); + + /* default is enabled */ + pTap->enabled = 1; + + /* deal with options */ +#define NTREQ_IRLEN 1 +#define NTREQ_IRCAPTURE 2 +#define NTREQ_IRMASK 4 + + /* clear them as we find them */ + reqbits = (NTREQ_IRLEN | NTREQ_IRCAPTURE | NTREQ_IRMASK); + + while( goi->argc ){ + e = Jim_GetOpt_Nvp( goi, opts, &n ); + if( e != JIM_OK ){ + Jim_GetOpt_NvpUnknown( goi, opts, 0 ); + return e; + } + LOG_DEBUG("Processing option: %s", n->name ); + switch( n->value ){ + case NTAP_OPT_ENABLED: + pTap->enabled = 1; + break; + case NTAP_OPT_DISABLED: + pTap->enabled = 0; + break; + case NTAP_OPT_EXPECTED_ID: + { + u32 *new_expected_ids; + + e = Jim_GetOpt_Wide( goi, &w ); + if( e != JIM_OK) { + Jim_SetResult_sprintf(goi->interp, "option: %s bad parameter", n->name); + return e; + } + + new_expected_ids = malloc(sizeof(u32) * (pTap->expected_ids_cnt + 1)); + if (new_expected_ids == NULL) { + Jim_SetResult_sprintf( goi->interp, "no memory"); + return JIM_ERR; + } + + memcpy(new_expected_ids, pTap->expected_ids, sizeof(u32) * pTap->expected_ids_cnt); + + new_expected_ids[pTap->expected_ids_cnt] = w; + + free(pTap->expected_ids); + pTap->expected_ids = new_expected_ids; + pTap->expected_ids_cnt++; + break; + } + case NTAP_OPT_IRLEN: + case NTAP_OPT_IRMASK: + case NTAP_OPT_IRCAPTURE: + e = Jim_GetOpt_Wide( goi, &w ); + if( e != JIM_OK ){ + Jim_SetResult_sprintf( goi->interp, "option: %s bad parameter", n->name ); + return e; + } + if( (w < 0) || (w > 0xffff) ){ + /* wacky value */ + Jim_SetResult_sprintf( goi->interp, "option: %s - wacky value: %d (0x%x)", + n->name, (int)(w), (int)(w)); + return JIM_ERR; + } + switch(n->value){ + case NTAP_OPT_IRLEN: + pTap->ir_length = w; + reqbits &= (~(NTREQ_IRLEN)); + break; + case NTAP_OPT_IRMASK: + pTap->ir_capture_mask = w; + reqbits &= (~(NTREQ_IRMASK)); + break; + case NTAP_OPT_IRCAPTURE: + pTap->ir_capture_value = w; + reqbits &= (~(NTREQ_IRCAPTURE)); + break; + } + } /* switch(n->value) */ + } /* while( goi->argc ) */ + + /* Did we get all the options? */ + if( reqbits ){ + // no + Jim_SetResult_sprintf( goi->interp, + "newtap: %s missing required parameters", + pTap->dotted_name); + /* TODO: Tell user what is missing :-( */ + /* no memory leaks pelase */ + free(((void *)(pTap->expected_ids))); + free(((void *)(pTap->chip))); + free(((void *)(pTap->tapname))); + free(((void *)(pTap->dotted_name))); + free(((void *)(pTap))); + return JIM_ERR; + } + + pTap->expected = malloc( pTap->ir_length ); + pTap->expected_mask = malloc( pTap->ir_length ); + pTap->cur_instr = malloc( pTap->ir_length ); + + buf_set_u32( pTap->expected, + 0, + pTap->ir_length, + pTap->ir_capture_value ); + buf_set_u32( pTap->expected_mask, + 0, + pTap->ir_length, + pTap->ir_capture_mask ); + buf_set_ones( pTap->cur_instr, + pTap->ir_length ); + + pTap->bypass = 1; + + jtag_register_event_callback(jtag_reset_callback, pTap ); + + ppTap = &(jtag_all_taps); + while( (*ppTap) != NULL ){ + ppTap = &((*ppTap)->next_tap); + } + *ppTap = pTap; + { + static int n_taps = 0; + pTap->abs_chain_position = n_taps++; + } + LOG_DEBUG( "Created Tap: %s @ abs position %d, irlen %d, capture: 0x%x mask: 0x%x", + (*ppTap)->dotted_name, + (*ppTap)->abs_chain_position, + (*ppTap)->ir_length, + (*ppTap)->ir_capture_value, + (*ppTap)->ir_capture_mask ); + return ERROR_OK; } +static int jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv ) +{ + Jim_GetOptInfo goi; + int e; + Jim_Nvp *n; + Jim_Obj *o; + struct command_context_s *context; + + enum { + JTAG_CMD_INTERFACE, + JTAG_CMD_INIT_RESET, + JTAG_CMD_NEWTAP, + JTAG_CMD_TAPENABLE, + JTAG_CMD_TAPDISABLE, + JTAG_CMD_TAPISENABLED, + JTAG_CMD_CONFIGURE, + JTAG_CMD_CGET + }; + + const Jim_Nvp jtag_cmds[] = { + { .name = "interface" , .value = JTAG_CMD_INTERFACE }, + { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET }, + { .name = "newtap" , .value = JTAG_CMD_NEWTAP }, + { .name = "tapisenabled" , .value = JTAG_CMD_TAPISENABLED }, + { .name = "tapenable" , .value = JTAG_CMD_TAPENABLE }, + { .name = "tapdisable" , .value = JTAG_CMD_TAPDISABLE }, + { .name = "configure" , .value = JTAG_CMD_CONFIGURE }, + { .name = "cget" , .value = JTAG_CMD_CGET }, + + { .name = NULL, .value = -1 }, + }; + + context = Jim_GetAssocData(interp, "context"); + /* go past the command */ + Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 ); + + e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n ); + if( e != JIM_OK ){ + Jim_GetOpt_NvpUnknown( &goi, jtag_cmds, 0 ); + return e; + } + Jim_SetEmptyResult( goi.interp ); + switch( n->value ){ + case JTAG_CMD_INTERFACE: + /* return the name of the interface */ + /* TCL code might need to know the exact type... */ + /* FUTURE: we allow this as a means to "set" the interface. */ + if( goi.argc != 0 ){ + Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)"); + return JIM_ERR; + } + Jim_SetResultString( goi.interp, jtag_interface->name, -1 ); + return JIM_OK; + case JTAG_CMD_INIT_RESET: + if( goi.argc != 0 ){ + Jim_WrongNumArgs( goi.interp, 1, goi.argv-1, "(no params)"); + return JIM_ERR; + } + e = jtag_init_reset(context); + if( e != ERROR_OK ){ + Jim_SetResult_sprintf( goi.interp, "error: %d", e); + return JIM_ERR; + } + return JIM_OK; + case JTAG_CMD_NEWTAP: + return jim_newtap_cmd( &goi ); + break; + case JTAG_CMD_TAPISENABLED: + case JTAG_CMD_TAPENABLE: + case JTAG_CMD_TAPDISABLE: + if( goi.argc != 1 ){ + Jim_SetResultString( goi.interp, "Too many parameters",-1 ); + return JIM_ERR; + } + + { + jtag_tap_t *t; + t = jtag_TapByJimObj( goi.interp, goi.argv[0] ); + if( t == NULL ){ + return JIM_ERR; + } + switch( n->value ){ + case JTAG_CMD_TAPISENABLED: + // below + break; + case JTAG_CMD_TAPENABLE: + jtag_tap_handle_event( t, JTAG_TAP_EVENT_ENABLE); + e = 1; + t->enabled = e; + break; + case JTAG_CMD_TAPDISABLE: + jtag_tap_handle_event( t, JTAG_TAP_EVENT_DISABLE); + e = 0; + t->enabled = e; + break; + } + Jim_SetResult( goi.interp, Jim_NewIntObj( goi.interp, e ) ); + return JIM_OK; + } + break; + + case JTAG_CMD_CGET: + if( goi.argc < 2 ){ + Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ..."); + return JIM_ERR; + } + + { + jtag_tap_t *t; + + Jim_GetOpt_Obj(&goi, &o); + t = jtag_TapByJimObj( goi.interp, o ); + if( t == NULL ){ + return JIM_ERR; + } + + goi.isconfigure = 0; + return jtag_tap_configure_cmd( &goi, t); + } + break; + + case JTAG_CMD_CONFIGURE: + if( goi.argc < 3 ){ + Jim_WrongNumArgs( goi.interp, 0, NULL, "?tap-name? -option ?VALUE? ..."); + return JIM_ERR; + } + + { + jtag_tap_t *t; + + Jim_GetOpt_Obj(&goi, &o); + t = jtag_TapByJimObj( goi.interp, o ); + if( t == NULL ){ + return JIM_ERR; + } + + goi.isconfigure = 1; + return jtag_tap_configure_cmd( &goi, t); + } + } + + return JIM_ERR; +} + int jtag_register_commands(struct command_context_s *cmd_ctx) { + register_jim( cmd_ctx, "jtag", jim_jtag_command, "perform jtag tap actions"); + register_command(cmd_ctx, NULL, "interface", handle_interface_command, - COMMAND_CONFIG, NULL); + COMMAND_CONFIG, "try to configure interface"); register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command, - COMMAND_ANY, "set jtag speed (if supported) []"); + COMMAND_ANY, "set jtag speed (if supported)"); register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command, COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK."); register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command, @@ -1422,10 +2147,10 @@ int jtag_register_commands(struct command_context_s *cmd_ctx) register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command, COMMAND_CONFIG, NULL); register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command, - COMMAND_CONFIG, NULL); + COMMAND_ANY, "jtag_nsrst_delay - delay after deasserting srst in ms"); register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command, - COMMAND_CONFIG, NULL); - + COMMAND_ANY, "jtag_ntrst_delay - delay after deasserting trst in ms"); + register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command, COMMAND_EXEC, "print current scan chain configuration"); @@ -1437,8 +2162,7 @@ int jtag_register_commands(struct command_context_s *cmd_ctx) COMMAND_EXEC, "move to Run-Test/Idle, and execute "); register_command(cmd_ctx, NULL, "irscan", handle_irscan_command, COMMAND_EXEC, "execute IR scan [dev2] [instr2] ..."); - register_command(cmd_ctx, NULL, "drscan", handle_drscan_command, - COMMAND_EXEC, "execute DR scan [dev2] [var2] ..."); + register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan ..."); register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command, COMMAND_ANY, "verify value captured during Capture-IR "); @@ -1447,6 +2171,9 @@ int jtag_register_commands(struct command_context_s *cmd_ctx) int jtag_interface_init(struct command_context_s *cmd_ctx) { + if (jtag) + return ERROR_OK; + if (!jtag_interface) { /* nothing was previously specified by "interface" command */ @@ -1455,67 +2182,104 @@ int jtag_interface_init(struct command_context_s *cmd_ctx) } if(hasKHz) { - /*stay on "reset speed"*/ - if (jtag_interface->khz(speed1, &speed1) == ERROR_OK) - jtag_speed = speed1; - if (jtag_interface->khz(speed2, &speed2) == ERROR_OK) - jtag_speed_post_reset = speed2; + jtag_interface->khz(speed_khz, &jtag_speed); hasKHz = 0; } if (jtag_interface->init() != ERROR_OK) return ERROR_JTAG_INIT_FAILED; - - jtag = jtag_interface; return ERROR_OK; } -int jtag_init(struct command_context_s *cmd_ctx) +static int jtag_init_inner(struct command_context_s *cmd_ctx) { - int validate_tries = 0; - jtag_device_t *device; + jtag_tap_t *tap; + int retval; - LOG_DEBUG("-"); - - if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK) - return ERROR_JTAG_INIT_FAILED; + LOG_DEBUG("Init JTAG chain"); - device = jtag_devices; - jtag_ir_scan_size = 0; - jtag_num_devices = 0; - while (device != NULL) - { - jtag_ir_scan_size += device->ir_length; - jtag_num_devices++; - device = device->next; + tap = jtag_NextEnabledTap(NULL); + if( tap == NULL ){ + LOG_ERROR("There are no enabled taps?"); + return ERROR_JTAG_INIT_FAILED; } - - jtag_add_tms(); - jtag_execute_queue(); + + jtag_add_tlr(); + if ((retval=jtag_execute_queue())!=ERROR_OK) + return retval; /* examine chain first, as this could discover the real chain layout */ if (jtag_examine_chain() != ERROR_OK) { LOG_ERROR("trying to validate configured JTAG chain anyway..."); } - - while (jtag_validate_chain() != ERROR_OK) + + if (jtag_validate_chain() != ERROR_OK) { - validate_tries++; - - if (validate_tries > 5) - { - LOG_ERROR("Could not validate JTAG chain, exit"); - return ERROR_JTAG_INVALID_INTERFACE; - } - usleep(10000); + LOG_ERROR("Could not validate JTAG chain, continuing anyway..."); } - + return ERROR_OK; } +int jtag_init_reset(struct command_context_s *cmd_ctx) +{ + int retval; + + 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"); + + /* Reset can happen after a power cycle. + * + * Ideally we would only assert TRST or run RESET before the target reset. + * + * However w/srst_pulls_trst, trst is asserted together with the target + * reset whether we want it or not. + * + * NB! Some targets have JTAG circuitry disabled until a + * trst & srst has been asserted. + * + * NB! here we assume nsrst/ntrst delay are sufficient! + * + * NB! order matters!!!! srst *can* disconnect JTAG circuitry + * + */ + jtag_add_reset(1, 0); /* RESET 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) + return retval; + + /* Check that we can communication on the JTAG chain + eventually we want to + * be able to perform enumeration only after OpenOCD has started + * telnet and GDB server + * + * That would allow users to more easily perform any magic they need to before + * reset happens. + */ + return jtag_init_inner(cmd_ctx); +} + +int jtag_init(struct command_context_s *cmd_ctx) +{ + int retval; + if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK) + return retval; + if (jtag_init_inner(cmd_ctx)==ERROR_OK) + { + return ERROR_OK; + } + return jtag_init_reset(cmd_ctx); +} static int default_khz(int khz, int *jtag_speed) { @@ -1523,9 +2287,28 @@ static int default_khz(int khz, int *jtag_speed) return ERROR_FAIL; } +static int default_speed_div(int speed, int *khz) +{ + LOG_ERROR("Translation from jtag_speed to khz not implemented"); + return ERROR_FAIL; +} + +static int default_power_dropout(int *dropout) +{ + *dropout=0; /* by default we can't detect power dropout */ + return ERROR_OK; +} + +static int default_srst_asserted(int *srst_asserted) +{ + *srst_asserted=0; /* by default we can't detect srst asserted */ + return ERROR_OK; +} + int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { int i; + int retval; /* check whether the interface is already configured */ if (jtag_interface) @@ -1544,15 +2327,30 @@ int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char { if (strcmp(args[0], jtag_interfaces[i]->name) == 0) { - if (jtag_interfaces[i]->register_commands(cmd_ctx) != ERROR_OK) - exit(-1); + if ((retval = jtag_interfaces[i]->register_commands(cmd_ctx)) != ERROR_OK) + { + return retval; + } jtag_interface = jtag_interfaces[i]; - + if (jtag_interface->khz == NULL) { jtag_interface->khz = default_khz; } + if (jtag_interface->speed_div == NULL) + { + jtag_interface->speed_div = default_speed_div; + } + if (jtag_interface->power_dropout == NULL) + { + jtag_interface->power_dropout = default_power_dropout; + } + if (jtag_interface->srst_asserted == NULL) + { + jtag_interface->srst_asserted = default_srst_asserted; + } + return ERROR_OK; } } @@ -1572,53 +2370,97 @@ int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - jtag_device_t **last_device_p = &jtag_devices; - - if (*last_device_p) - { - while ((*last_device_p)->next) - last_device_p = &((*last_device_p)->next); - last_device_p = &((*last_device_p)->next); - } + int e; + char buf[1024]; + Jim_Obj *newargs[ 10 ]; + /* + * CONVERT SYNTAX + * argv[-1] = command + * argv[ 0] = ir length + * argv[ 1] = ir capture + * argv[ 2] = ir mask + * argv[ 3] = not actually used by anything but in the docs + */ - if (argc < 3) + if( argc < 4 ){ + command_print( cmd_ctx, "OLD DEPRECATED SYNTAX: Please use the NEW syntax"); return ERROR_OK; - - *last_device_p = malloc(sizeof(jtag_device_t)); - (*last_device_p)->ir_length = strtoul(args[0], NULL, 0); - - (*last_device_p)->expected = malloc((*last_device_p)->ir_length); - buf_set_u32((*last_device_p)->expected, 0, (*last_device_p)->ir_length, strtoul(args[1], NULL, 0)); - (*last_device_p)->expected_mask = malloc((*last_device_p)->ir_length); - buf_set_u32((*last_device_p)->expected_mask, 0, (*last_device_p)->ir_length, strtoul(args[2], NULL, 0)); - - (*last_device_p)->cur_instr = malloc((*last_device_p)->ir_length); - (*last_device_p)->bypass = 1; - buf_set_ones((*last_device_p)->cur_instr, (*last_device_p)->ir_length); - - (*last_device_p)->next = NULL; - - jtag_register_event_callback(jtag_reset_callback, (*last_device_p)); - - jtag_num_devices++; - - return ERROR_OK; + } + command_print( cmd_ctx, "OLD SYNTAX: DEPRECATED - translating to new syntax"); + command_print( cmd_ctx, "jtag newtap CHIP TAP -irlen %s -ircapture %s -irvalue %s", + args[0], + args[1], + args[2] ); + command_print( cmd_ctx, "Example: STM32 has 2 taps, the cortexM3(len4) + boundryscan(len5)"); + command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\""); + command_print( cmd_ctx, "jtag newtap stm32 boundry ....., and the tap: \"stm32.boundery\""); + command_print( cmd_ctx, "And then refer to the taps by the dotted name."); + + newargs[0] = Jim_NewStringObj( interp, "jtag", -1 ); + newargs[1] = Jim_NewStringObj( interp, "newtap", -1 ); + sprintf( buf, "chip%d", jtag_NumTotalTaps() ); + newargs[2] = Jim_NewStringObj( interp, buf, -1 ); + sprintf( buf, "tap%d", jtag_NumTotalTaps() ); + newargs[3] = Jim_NewStringObj( interp, buf, -1 ); + newargs[4] = Jim_NewStringObj( interp, "-irlen", -1 ); + newargs[5] = Jim_NewStringObj( interp, args[0], -1 ); + newargs[6] = Jim_NewStringObj( interp, "-ircapture", -1 ); + newargs[7] = Jim_NewStringObj( interp, args[1], -1 ); + newargs[8] = Jim_NewStringObj( interp, "-irmask", -1 ); + newargs[9] = Jim_NewStringObj( interp, args[2], -1 ); + + command_print( cmd_ctx, "NEW COMMAND:"); + sprintf( buf, "%s %s %s %s %s %s %s %s %s %s", + Jim_GetString( newargs[0], NULL ), + Jim_GetString( newargs[1], NULL ), + Jim_GetString( newargs[2], NULL ), + Jim_GetString( newargs[3], NULL ), + Jim_GetString( newargs[4], NULL ), + Jim_GetString( newargs[5], NULL ), + Jim_GetString( newargs[6], NULL ), + Jim_GetString( newargs[7], NULL ), + Jim_GetString( newargs[8], NULL ), + Jim_GetString( newargs[9], NULL ) ); + + e = jim_jtag_command( interp, 10, newargs ); + if( e != JIM_OK ){ + command_print( cmd_ctx, "%s", Jim_GetString( Jim_GetResult(interp), NULL ) ); + } + return e; } int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - jtag_device_t *device = jtag_devices; - int device_count = 0; - - while (device) - { - u32 expected, expected_mask, cur_instr; - expected = buf_get_u32(device->expected, 0, device->ir_length); - expected_mask = buf_get_u32(device->expected_mask, 0, device->ir_length); - cur_instr = buf_get_u32(device->cur_instr, 0, device->ir_length); - command_print(cmd_ctx, "%i: idcode: 0x%8.8x ir length %i, ir capture 0x%x, ir mask 0x%x, current instruction 0x%x", device_count, device->idcode, device->ir_length, expected, expected_mask, cur_instr); - device = device->next; - device_count++; + jtag_tap_t *tap; + + tap = jtag_all_taps; + command_print(cmd_ctx, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr "); + command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------"); + + while( tap ){ + u32 expected, expected_mask, cur_instr, ii; + expected = buf_get_u32(tap->expected, 0, tap->ir_length); + expected_mask = buf_get_u32(tap->expected_mask, 0, tap->ir_length); + cur_instr = buf_get_u32(tap->cur_instr, 0, tap->ir_length); + + command_print(cmd_ctx, + "%2d | %-18s | %c | 0x%08x | 0x%08x | 0x%02x | 0x%02x | 0x%02x | 0x%02x", + tap->abs_chain_position, + tap->dotted_name, + tap->enabled ? 'Y' : 'n', + tap->idcode, + (tap->expected_ids_cnt > 0 ? tap->expected_ids[0] : 0), + tap->ir_length, + expected, + expected_mask, + cur_instr); + + for (ii = 1; ii < tap->expected_ids_cnt; ii++) { + command_print(cmd_ctx, " | | | | 0x%08x | | | | ", + tap->expected_ids[ii]); + } + + tap = tap->next_tap; } return ERROR_OK; @@ -1628,7 +2470,7 @@ int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, ch { if (argc < 1) return ERROR_COMMAND_SYNTAX_ERROR; - + if (argc >= 1) { if (strcmp(args[0], "none") == 0) @@ -1641,12 +2483,12 @@ int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, ch jtag_reset_config = RESET_TRST_AND_SRST; else { - LOG_ERROR("invalid reset_config argument, defaulting to none"); + LOG_ERROR("(1) invalid reset_config argument (%s), defaulting to none", args[0]); jtag_reset_config = RESET_NONE; return ERROR_INVALID_ARGUMENTS; } } - + if (argc >= 2) { if (strcmp(args[1], "separate") == 0) @@ -1662,13 +2504,13 @@ int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, ch jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST; else { - LOG_ERROR("invalid reset_config argument, defaulting to none"); + LOG_ERROR("(2) invalid reset_config argument (%s), defaulting to none", args[1]); jtag_reset_config = RESET_NONE; return ERROR_INVALID_ARGUMENTS; } } } - + if (argc >= 3) { if (strcmp(args[2], "trst_open_drain") == 0) @@ -1677,7 +2519,7 @@ int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, ch jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN; else { - LOG_ERROR("invalid reset_config argument, defaulting to none"); + LOG_ERROR("(3) invalid reset_config argument (%s) defaulting to none", args[2] ); jtag_reset_config = RESET_NONE; return ERROR_INVALID_ARGUMENTS; } @@ -1691,12 +2533,12 @@ int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, ch jtag_reset_config &= ~RESET_SRST_PUSH_PULL; else { - LOG_ERROR("invalid reset_config argument, defaulting to none"); + LOG_ERROR("(4) invalid reset_config argument (%s), defaulting to none", args[3]); jtag_reset_config = RESET_NONE; return ERROR_INVALID_ARGUMENTS; } } - + return ERROR_OK; } @@ -1711,7 +2553,7 @@ int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd { jtag_nsrst_delay = strtoul(args[0], NULL, 0); } - + return ERROR_OK; } @@ -1726,72 +2568,87 @@ int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd { jtag_ntrst_delay = strtoul(args[0], NULL, 0); } - + return ERROR_OK; } int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - int cur_speed = 0; - - if (argc != 0) + int retval=ERROR_OK; + + if (argc == 1) { - if ((argc<1) || (argc>2)) - return ERROR_COMMAND_SYNTAX_ERROR; - LOG_DEBUG("handle jtag speed"); - - if (argc >= 1) - cur_speed = jtag_speed = jtag_speed_post_reset = strtoul(args[0], NULL, 0); - if (argc == 2) - cur_speed = jtag_speed_post_reset = strtoul(args[1], NULL, 0); - - /* this command can be called during CONFIG, + + int cur_speed = 0; + cur_speed = jtag_speed = strtoul(args[0], NULL, 0); + + /* this command can be called during CONFIG, * in which case jtag isn't initialized */ if (jtag) - jtag->speed(cur_speed); - } - command_print(cmd_ctx, "jtag_speed: %d, %d", jtag_speed, jtag_speed_post_reset); - - return ERROR_OK; + { + retval=jtag->speed(cur_speed); + } + } else if (argc == 0) + { + } else + { + return ERROR_COMMAND_SYNTAX_ERROR; + } + command_print(cmd_ctx, "jtag_speed: %d", jtag_speed); + + return retval; } int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { + int retval=ERROR_OK; LOG_DEBUG("handle jtag khz"); - - if ((argc<1) || (argc>2)) - return ERROR_COMMAND_SYNTAX_ERROR; - if (argc >= 1) - speed1 = speed2 = strtoul(args[0], NULL, 0); - if (argc == 2) - speed2 = strtoul(args[1], NULL, 0); + if(argc == 1) + { + speed_khz = strtoul(args[0], NULL, 0); + if (jtag != NULL) + { + int cur_speed = 0; + LOG_DEBUG("have interface set up"); + int speed_div1; + if ((retval=jtag->khz(speed_khz, &speed_div1))!=ERROR_OK) + { + speed_khz = 0; + return retval; + } + + cur_speed = jtag_speed = speed_div1; - if (jtag != NULL) + retval=jtag->speed(cur_speed); + } else + { + hasKHz = 1; + } + } else if (argc==0) { - int cur_speed = 0; - LOG_DEBUG("have interface set up"); - int speed_div1, speed_div2; - if (jtag->khz(speed1, &speed_div1)!=ERROR_OK) - return ERROR_OK; - if (jtag->khz(speed2, &speed_div2)!=ERROR_OK) - return ERROR_OK; + } else + { + return ERROR_COMMAND_SYNTAX_ERROR; + } - if (argc >= 1) - cur_speed = jtag_speed = jtag_speed_post_reset = speed_div1; - if (argc == 2) - cur_speed = jtag_speed_post_reset = speed_div2; + if (jtag!=NULL) + { + if ((retval=jtag->speed_div(jtag_speed, &speed_khz))!=ERROR_OK) + return retval; + } - jtag->speed(cur_speed); + if (speed_khz==0) + { + command_print(cmd_ctx, "RCLK - adaptive"); } else { - hasKHz = 1; + command_print(cmd_ctx, "%d kHz", speed_khz); } - - return ERROR_OK; -} + return retval; +} int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { @@ -1805,15 +2662,15 @@ int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char * { for (state = 0; state < 16; state++) { - if (strcmp(args[0], tap_state_strings[state]) == 0) + if (strcmp(args[0], jtag_state_name(state)) == 0) { jtag_add_end_state(state); jtag_execute_queue(); } } } - command_print(cmd_ctx, "current endstate: %s", tap_state_strings[end_state]); - + command_print(cmd_ctx, "current endstate: %s", jtag_state_name(cmd_queue_end_state)); + return ERROR_OK; } @@ -1821,7 +2678,7 @@ int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char { int trst = -1; int srst = -1; - + if (argc < 2) { return ERROR_COMMAND_SYNTAX_ERROR; @@ -1845,7 +2702,7 @@ int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char return ERROR_COMMAND_SYNTAX_ERROR; } - if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK) + if (jtag_interface_init(cmd_ctx) != ERROR_OK) return ERROR_JTAG_INIT_FAILED; jtag_add_reset(trst, srst); @@ -1868,24 +2725,29 @@ int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char ** } - int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { int i; scan_field_t *fields; - + jtag_tap_t *tap; + if ((argc < 2) || (argc % 2)) { return ERROR_COMMAND_SYNTAX_ERROR; } fields = malloc(sizeof(scan_field_t) * argc / 2); - + for (i = 0; i < argc / 2; i++) { - int device = strtoul(args[i*2], NULL, 0); - int field_size = jtag_get_device(device)->ir_length; - fields[i].device = device; + tap = jtag_TapByString( args[i*2] ); + if (tap==NULL) + { + command_print( cmd_ctx, "Tap: %s unknown", args[i*2] ); + return ERROR_FAIL; + } + int field_size = tap->ir_length; + fields[i].tap = tap; fields[i].out_value = malloc(CEIL(field_size, 8)); buf_set_u32(fields[i].out_value, 0, field_size, strtoul(args[i*2+1], NULL, 0)); fields[i].out_mask = NULL; @@ -1906,63 +2768,92 @@ int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **a return ERROR_OK; } -int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args) { + int retval; scan_field_t *fields; - int num_fields = 0; + int num_fields; int field_count = 0; - var_t *var; - int i, j; - - if ((argc < 2) || (argc % 2)) + int i, e; + jtag_tap_t *tap; + + /* args[1] = device + * args[2] = num_bits + * args[3] = hex string + * ... repeat num bits and hex string ... + */ + if ((argc < 4) || ((argc % 2)!=0)) { - return ERROR_COMMAND_SYNTAX_ERROR; + Jim_WrongNumArgs(interp, 1, args, "wrong arguments"); + return JIM_ERR; } - for (i = 0; i < argc; i+=2) + for (i = 2; i < argc; i+=2) { - var = get_var_by_namenum(args[i+1]); - if (var) - { - num_fields += var->num_fields; - } - else - { - command_print(cmd_ctx, "variable %s doesn't exist", args[i+1]); - return ERROR_OK; - } + long bits; + + e = Jim_GetLong(interp, args[i], &bits); + if (e != JIM_OK) + return e; } - fields = malloc(sizeof(scan_field_t) * num_fields); + tap = jtag_TapByJimObj( interp, args[1] ); + if( tap == NULL ){ + return JIM_ERR; + } - for (i = 0; i < argc; i+=2) + num_fields=(argc-2)/2; + fields = malloc(sizeof(scan_field_t) * num_fields); + for (i = 2; i < argc; i+=2) { - var = get_var_by_namenum(args[i+1]); - - for (j = 0; j < var->num_fields; j++) - { - fields[field_count].device = strtol(args[i], NULL, 0); - fields[field_count].num_bits = var->fields[j].num_bits; - fields[field_count].out_value = malloc(CEIL(var->fields[j].num_bits, 8)); - buf_set_u32(fields[field_count].out_value, 0, var->fields[j].num_bits, var->fields[j].value); - fields[field_count].out_mask = NULL; - fields[field_count].in_value = fields[field_count].out_value; - fields[field_count].in_check_mask = NULL; - fields[field_count].in_check_value = NULL; - fields[field_count].in_handler = field_le_to_host; - fields[field_count++].in_handler_priv = &(var->fields[j]); - } + long bits; + int len; + const char *str; + + Jim_GetLong(interp, args[i], &bits); + str = Jim_GetString(args[i+1], &len); + + fields[field_count].tap = tap; + fields[field_count].num_bits = bits; + fields[field_count].out_value = malloc(CEIL(bits, 8)); + str_to_buf(str, len, fields[field_count].out_value, bits, 0); + fields[field_count].out_mask = NULL; + fields[field_count].in_value = fields[field_count].out_value; + fields[field_count].in_check_mask = NULL; + fields[field_count].in_check_value = NULL; + fields[field_count].in_handler = NULL; + fields[field_count++].in_handler_priv = NULL; } jtag_add_dr_scan(num_fields, fields, -1); - jtag_execute_queue(); - - for (i = 0; i < argc / 2; i++) - free(fields[i].out_value); + retval = jtag_execute_queue(); + if (retval != ERROR_OK) + { + Jim_SetResultString(interp, "drscan: jtag execute failed",-1); + return JIM_ERR; + } + + field_count=0; + Jim_Obj *list = Jim_NewListObj(interp, NULL, 0); + for (i = 2; i < argc; i+=2) + { + long bits; + char *str; + + Jim_GetLong(interp, args[i], &bits); + str = buf_to_str(fields[field_count].in_value, bits, 16); + free(fields[field_count].out_value); + + Jim_ListAppendElement(interp, list, Jim_NewStringObj(interp, str, strlen(str))); + free(str); + field_count++; + } + + Jim_SetResult(interp, list); free(fields); - return ERROR_OK; + return JIM_OK; } int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) @@ -1984,8 +2875,80 @@ int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd { return ERROR_COMMAND_SYNTAX_ERROR; } - + command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled"); - + return ERROR_OK; } + +int jtag_power_dropout(int *dropout) +{ + return jtag->power_dropout(dropout); +} + +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) +{ + 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); + } +} + + +/* map state number to SVF state string */ +const char* jtag_state_name(enum tap_state state) +{ + const char* ret; + + switch( state ) + { + case TAP_RESET: ret = "RESET"; break; + case TAP_IDLE: ret = "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; +} +