X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fjtag.c;h=e02b91f088d5d6a818232c7e2cc3a9de8ec2a1be;hp=d093ee26c30511063e141321d8ef58eb20202dc2;hb=84dfdd4de680d2f16275dee2445c5bfcaa363538;hpb=bbafcb3758ac315b94ac54e88ab2dafe8377e062 diff --git a/src/jtag/jtag.c b/src/jtag/jtag.c index d093ee26c3..e02b91f088 100644 --- a/src/jtag/jtag.c +++ b/src/jtag/jtag.c @@ -5,6 +5,10 @@ * Copyright (C) 2007,2008 Øyvind Harboe * * oyvind.harboe@zylin.com * * * + * Copyright (C) 2009 SoftPLC Corporation * + * http://softplc.com * + * dick@softplc.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 * @@ -31,24 +35,21 @@ #include "command.h" #include "log.h" -#include "stdlib.h" -#include "string.h" +#include +#include #include +#ifdef HAVE_STRINGS_H +#include +#endif +#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 */ 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; @@ -59,81 +60,34 @@ typedef struct cmd_queue_page_s #define CMD_QUEUE_PAGE_SIZE (1024 * 1024) static cmd_queue_page_t *cmd_queue_pages = NULL; -/* tap_move[i][j]: tap movement command to go from state i to state j - * 0: Test-Logic-Reset - * 1: Run-Test/Idle - * 2: Shift-DR - * 3: Pause-DR - * 4: Shift-IR - * 5: Pause-IR - * - * SD->SD and SI->SI 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 */ -}; - -int tap_move_map[16] = { - 0, -1, -1, 2, -1, 3, -1, -1, - 1, -1, -1, 4, -1, 5, -1, -1 +char* jtag_event_strings[] = +{ + "JTAG controller reset (RESET or TRST)" }; -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 */ -}; +const Jim_Nvp nvp_jtag_tap_event[] = { + { .value = JTAG_TAP_EVENT_ENABLE, .name = "tap-enable" }, + { .value = JTAG_TAP_EVENT_DISABLE, .name = "tap-disable" }, -char* jtag_event_strings[] = -{ - "JTAG controller reset (TLR or TRST)" + { .name = NULL, .value = -1 } }; -/* 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_TLR; -enum tap_state cur_state = TAP_TLR; 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; +tap_state_t cmd_queue_end_state = TAP_RESET; +tap_state_t 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 */ +static int jtag_nsrst_delay = 0; /* default to no nSRST delay */ +static int jtag_ntrst_delay = 0; /* default to no nTRST delay */ /* maximum number of JTAG devices expected in the chain */ @@ -198,6 +152,18 @@ static int hasKHz = 0; 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 + +#if BUILD_ARMJTAGEW == 1 + extern jtag_interface_t armjtagew_interface; +#endif + jtag_interface_t *jtag_interfaces[] = { #if BUILD_ECOSBOARD == 1 &zy1000_interface, @@ -234,6 +200,15 @@ jtag_interface_t *jtag_interfaces[] = { #endif #if BUILD_JLINK == 1 &jlink_interface, +#endif +#if BUILD_VSLLINK == 1 + &vsllink_interface, +#endif +#if BUILD_RLINK == 1 + &rlink_interface, +#endif +#if BUILD_ARMJTAGEW == 1 + &armjtagew_interface, #endif NULL, }; @@ -241,37 +216,131 @@ jtag_interface_t *jtag_interfaces[] = { jtag_interface_t *jtag = NULL; /* configuration */ -jtag_interface_t *jtag_interface = NULL; +static jtag_interface_t *jtag_interface = NULL; int jtag_speed = 0; +/* forward declarations */ +//void jtag_add_pathmove(int num_states, tap_state_t *path); +//void jtag_add_runtest(int num_cycles, tap_state_t endstate); +//void jtag_add_end_state(tap_state_t endstate); +//void jtag_add_sleep(u32 us); +//int jtag_execute_queue(void); +static tap_state_t tap_state_by_name(const char *name); + +/* jtag commands */ +static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -/* forward declarations */ -void jtag_add_pathmove(int num_states, enum tap_state *path); -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); +static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv); +static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -/* jtag commands */ -int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_jtag_ntrst_delay_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; +} -int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +/* 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; -int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -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 Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *argv); + orig_n = n; + t = jtag_AllTaps(); -int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); + 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) { @@ -354,30 +423,44 @@ jtag_command_t** jtag_get_last_command_p(void) 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; - - while (device) - { - if (num == i) - return device; - device = device->next; - i++; - } - - LOG_ERROR("jtag device number %d not defined", num); - exit(-1); -} - void* cmd_queue_alloc(size_t size) { cmd_queue_page_t **p_page = &cmd_queue_pages; int offset; u8 *t; + /* + * WARNING: + * We align/round the *SIZE* per below + * so that all pointers returned by + * this function are reasonably well + * aligned. + * + * If we did not, then an "odd-length" request would cause the + * *next* allocation to be at an *odd* address, and because + * this function has the same type of api as malloc() - we + * must also return pointers that have the same type of + * alignment. + * + * What I do not/have is a reasonable portable means + * to align by... + * + * The solution here, is based on these suggestions. + * http://gcc.gnu.org/ml/gcc-help/2008-12/msg00041.html + * + */ + union worse_case_align { + int i; + long l; + float f; + void *v; + }; +#define ALIGN_SIZE (sizeof(union worse_case_align)) + + /* The alignment process. */ + size = (size + ALIGN_SIZE -1) & (~(ALIGN_SIZE-1)); + /* Done... */ + if (*p_page) { while ((*p_page)->next) @@ -425,39 +508,90 @@ static void jtag_prelude1(void) 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) +static void jtag_prelude(tap_state_t state) { jtag_prelude1(); - if (state != -1) + if (state != TAP_INVALID) jtag_add_end_state(state); cmd_queue_cur_state = cmd_queue_end_state; } -void jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) +void jtag_add_ir_scan_noverify(int num_fields, scan_field_t *fields, tap_state_t state) { int retval; - jtag_prelude(state); retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_state); if (retval!=ERROR_OK) jtag_error=retval; + +} + + +void jtag_add_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state) +{ + /* 8 x 32 bit id's is enough for all invoations */ + u32 id[8]; + int modified[8]; + + /* if we are to run a verification of the ir scan, we need to get the input back. + * We may have to allocate space if the caller didn't ask for the input back. + * + */ + if (jtag_verify_capture_ir) + { + int j; + for (j = 0; j < num_fields; j++) + { + modified[j]=0; + if ((fields[j].in_value==NULL)&&(fields[j].num_bits<=32)) + { + if (j<8) + { + modified[j]=1; + fields[j].in_value=(u8 *)(id+j); + } else + { + LOG_DEBUG("caller must provide in_value space for verify_capture_ir to work"); + } + } + } + } + + jtag_add_ir_scan_noverify(num_fields, fields, state); + + if (jtag_verify_capture_ir) + { + int j; + for (j = 0; j < num_fields; j++) + { + jtag_tap_t *tap=fields[j].tap; + jtag_check_value_mask(fields+j, tap->expected, tap->expected_mask); + + if (modified[j]) + { + fields[j].in_value=NULL; + } + } + } + } -int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state) +int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, tap_state_t 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 */ @@ -469,65 +603,56 @@ 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); - - 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); - } 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].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); - 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); + 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) +void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state) { int retval; @@ -538,7 +663,7 @@ void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state jtag_error=retval; } -int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state) +int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, tap_state_t state) { int i; jtag_command_t **last_cmd; @@ -558,14 +683,12 @@ 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); (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value; (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value; (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask; @@ -575,7 +698,7 @@ int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *f return ERROR_OK; } -void jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) +void jtag_add_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state) { int retval; @@ -586,27 +709,34 @@ void jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state jtag_error=retval; } -int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state) +void jtag_add_dr_scan_now(int num_fields, scan_field_t *fields, tap_state_t state) +{ + jtag_add_dr_scan(num_fields, fields, state); + jtag_execute_queue_noclear(); +} + +int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, tap_state_t 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; - } - if (bypass_devices >= jtag_num_devices) - { - LOG_ERROR("all devices in bypass"); - return ERROR_JTAG_DEVICE_ERROR; + } } /* allocate memory for a new list member */ @@ -622,20 +752,25 @@ int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, (*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; (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size; (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); - (*last_cmd)->cmd.scan->fields[field_count].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); (*last_cmd)->cmd.scan->fields[field_count].in_value = fields[j].in_value; (*last_cmd)->cmd.scan->fields[field_count].in_check_value = fields[j].in_check_value; (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = fields[j].in_check_mask; @@ -647,7 +782,7 @@ 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); @@ -656,7 +791,6 @@ int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, /* 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; - (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL; (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL; (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL; (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL; @@ -667,7 +801,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); @@ -678,25 +812,31 @@ 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, const int *num_bits, const u32 *value, - enum tap_state end_state) + tap_state_t 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 */ @@ -712,16 +852,22 @@ void MINIDRIVER(interface_jtag_add_dr_out)(int device_num, (*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; + 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 (i == device_num) + 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); @@ -734,7 +880,6 @@ void MINIDRIVER(interface_jtag_add_dr_out)(int device_num, buf_set_u32(out_value, 0, scan_size, value[j]); (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size; (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); - (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL; (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL; (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL; (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL; @@ -745,7 +890,7 @@ 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); @@ -754,7 +899,6 @@ void MINIDRIVER(interface_jtag_add_dr_out)(int device_num, /* 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; - (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL; (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL; (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL; (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL; @@ -764,7 +908,7 @@ 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) +void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state) { int retval; @@ -775,7 +919,7 @@ void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state jtag_error=retval; } -int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state) +int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, tap_state_t state) { int i; jtag_command_t **last_cmd = jtag_get_last_command_p(); @@ -797,10 +941,9 @@ int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *f { 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); (*last_cmd)->cmd.scan->fields[i].in_value = fields[i].in_value; (*last_cmd)->cmd.scan->fields[i].in_check_value = fields[i].in_check_value; (*last_cmd)->cmd.scan->fields[i].in_check_mask = fields[i].in_check_mask; @@ -813,7 +956,7 @@ int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *f void jtag_add_tlr(void) { - jtag_prelude(TAP_TLR); + jtag_prelude(TAP_RESET); int retval; retval=interface_jtag_add_tlr(); @@ -821,9 +964,9 @@ void jtag_add_tlr(void) jtag_error=retval; } -int MINIDRIVER(interface_jtag_add_tlr)() +int MINIDRIVER(interface_jtag_add_tlr)(void) { - enum tap_state state = TAP_TLR; + tap_state_t state = TAP_RESET; jtag_command_t **last_cmd = jtag_get_last_command_p(); /* allocate memory for a new list member */ @@ -835,18 +978,17 @@ int MINIDRIVER(interface_jtag_add_tlr)() (*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) +void jtag_add_pathmove(int num_states, tap_state_t *path) { - enum tap_state cur_state=cmd_queue_cur_state; + tap_state_t 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) + if (!tap_is_state_stable(path[num_states - 1])) { LOG_ERROR("BUG: TAP path doesn't finish in a stable state"); exit(-1); @@ -854,15 +996,16 @@ void jtag_add_pathmove(int num_states, enum tap_state *path) 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", tap_state_name(cur_state), tap_state_name(path[i])); exit(-1); } cur_state = path[i]; @@ -870,14 +1013,13 @@ void jtag_add_pathmove(int num_states, enum tap_state *path) jtag_prelude1(); - - 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) +int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, tap_state_t *path) { jtag_command_t **last_cmd = jtag_get_last_command_p(); int i; @@ -890,7 +1032,7 @@ 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); + (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(tap_state_t) * num_states); for (i = 0; i < num_states; i++) (*last_cmd)->cmd.pathmove->path[i] = path[i]; @@ -898,7 +1040,7 @@ int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, enum tap_state *path return ERROR_OK; } -int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, enum tap_state state) +int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, tap_state_t state) { jtag_command_t **last_cmd = jtag_get_last_command_p(); @@ -915,7 +1057,7 @@ int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, enum tap_state state) return ERROR_OK; } -void jtag_add_runtest(int num_cycles, enum tap_state state) +void jtag_add_runtest(int num_cycles, tap_state_t state) { int retval; @@ -927,6 +1069,44 @@ void jtag_add_runtest(int num_cycles, enum tap_state state) jtag_error=retval; } + +int MINIDRIVER(interface_jtag_add_clocks)( int num_cycles ) +{ + 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; + last_comand_pointer = &((*last_cmd)->next); + (*last_cmd)->type = JTAG_STABLECLOCKS; + + (*last_cmd)->cmd.stableclocks = cmd_queue_alloc(sizeof(stableclocks_command_t)); + (*last_cmd)->cmd.stableclocks->num_cycles = num_cycles; + return ERROR_OK; +} + +void jtag_add_clocks( int num_cycles ) +{ + int retval; + + if( !tap_is_state_stable(cmd_queue_cur_state) ) + { + LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"", + tap_state_name(cmd_queue_cur_state) ); + jtag_error = ERROR_JTAG_NOT_STABLE_STATE; + return; + } + + if( num_cycles > 0 ) + { + jtag_prelude1(); + + retval = interface_jtag_add_clocks(num_cycles); + if (retval != ERROR_OK) + jtag_error=retval; + } +} + void jtag_add_reset(int req_tlr_or_trst, int req_srst) { int trst_with_tlr = 0; @@ -1007,8 +1187,8 @@ void jtag_add_reset(int req_tlr_or_trst, int req_srst) if (trst_with_tlr) { - LOG_DEBUG("JTAG reset with TLR instead of TRST"); - jtag_add_end_state(TAP_TLR); + 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; @@ -1020,7 +1200,7 @@ void jtag_add_reset(int req_tlr_or_trst, int req_srst) * 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 @@ -1047,12 +1227,12 @@ int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst) return ERROR_OK; } -void jtag_add_end_state(enum tap_state state) +void jtag_add_end_state(tap_state_t state) { cmd_queue_end_state = state; - if ((cmd_queue_end_state == TAP_SD)||(cmd_queue_end_state == TAP_SI)) + 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"); } } @@ -1105,23 +1285,37 @@ int jtag_build_buffer(scan_command_t *cmd, u8 **buffer) bit_count = 0; +#ifdef _DEBUG_JTAG_IO_ + LOG_DEBUG("%s num_fields: %i", cmd->ir_scan ? "IRSCAN" : "DRSCAN", cmd->num_fields); +#endif + for (i = 0; i < cmd->num_fields; i++) { if (cmd->fields[i].out_value) { #ifdef _DEBUG_JTAG_IO_ - char* char_buf = buf_to_str(cmd->fields[i].out_value, (cmd->fields[i].num_bits > 64) ? 64 : cmd->fields[i].num_bits, 16); + char* char_buf = buf_to_str(cmd->fields[i].out_value, (cmd->fields[i].num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : cmd->fields[i].num_bits, 16); #endif buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits); #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("fields[%i].out_value: 0x%s", i, char_buf); + LOG_DEBUG("fields[%i].out_value[%i]: 0x%s", i, cmd->fields[i].num_bits, char_buf); free(char_buf); #endif } + else + { +#ifdef _DEBUG_JTAG_IO_ + LOG_DEBUG("fields[%i].out_value[%i]: NULL", i, cmd->fields[i].num_bits); +#endif + } bit_count += cmd->fields[i].num_bits; } +#ifdef _DEBUG_JTAG_IO_ + //LOG_DEBUG("bit_count totalling: %i", bit_count ); +#endif + return bit_count; } @@ -1145,10 +1339,8 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits); #ifdef _DEBUG_JTAG_IO_ - char *char_buf; - - char_buf = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16); - LOG_DEBUG("fields[%i].in_value: 0x%s", i, char_buf); + char *char_buf = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16); + LOG_DEBUG("fields[%i].in_value[%i]: 0x%s", i, num_bits, char_buf); free(char_buf); #endif @@ -1160,7 +1352,7 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) { 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; } } @@ -1174,7 +1366,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; } } @@ -1187,7 +1379,12 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) return retval; } -int jtag_check_value(u8 *captured, void *priv, scan_field_t *field) +static const char *jtag_tap_name(jtag_tap_t *tap) +{ + return (tap == NULL) ? "(unknown)" : tap->dotted_name; +} + +int jtag_check_value_inner(u8 *captured, scan_field_t *field, u8 *in_check_value, u8 *in_check_mask) { int retval = ERROR_OK; int num_bits = field->num_bits; @@ -1195,26 +1392,29 @@ int jtag_check_value(u8 *captured, void *priv, scan_field_t *field) 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); + compare_failed = buf_cmp_mask(captured, in_check_value, in_check_mask, num_bits); else - compare_failed = buf_cmp(captured, field->in_check_value, num_bits); + compare_failed = buf_cmp(captured, in_check_value, num_bits); - if (compare_failed) - { + if (compare_failed){ /* An error handler could have caught the failing check * only report a problem when there wasn't a handler, or if the handler * acknowledged the error */ + LOG_WARNING("TAP %s:", + jtag_tap_name(field->tap)); if (compare_failed) { - char *captured_char = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16); - char *in_check_value_char = buf_to_str(field->in_check_value, (num_bits > 64) ? 64 : num_bits, 16); + char *captured_char = buf_to_str(captured, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16); + char *in_check_value_char = buf_to_str(in_check_value, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16); - if (field->in_check_mask) + if (in_check_mask) { 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); + in_check_mask_char = buf_to_str(in_check_mask, (num_bits > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16); + 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 @@ -1232,11 +1432,16 @@ int jtag_check_value(u8 *captured, void *priv, scan_field_t *field) return retval; } +int jtag_check_value(u8 *captured, void *priv, scan_field_t *field) +{ + return jtag_check_value_inner(captured, field, field->in_check_value, field->in_check_mask); +} + /* set up checking of this field using the in_handler. The values passed in must be valid until after jtag_execute() has completed. */ -void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, error_handler_t *in_error_handler) +void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, struct invalidstruct *obsolete) { if (value) field->in_handler = jtag_check_value; @@ -1247,6 +1452,25 @@ void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, error_handle field->in_check_mask = mask; } +void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask) +{ + assert(field->in_value != NULL); + + if (value==NULL) + { + /* no checking to do */ + return; + } + + jtag_execute_queue_noclear(); + + int retval=jtag_check_value_inner(field->in_value, field, value, mask); + jtag_set_error(retval); + +} + + + enum scan_type jtag_scan_type(scan_command_t *cmd) { int i; @@ -1283,27 +1507,35 @@ int MINIDRIVER(interface_jtag_execute_queue)(void) return retval; } -int jtag_execute_queue(void) +void jtag_execute_queue_noclear(void) { int retval=interface_jtag_execute_queue(); - if (retval==ERROR_OK) + /* we keep the first error */ + if ((jtag_error==ERROR_OK)&&(retval!=ERROR_OK)) { - retval=jtag_error; + jtag_error=retval; } +} + +int jtag_execute_queue(void) +{ + int retval; + jtag_execute_queue_noclear(); + retval=jtag_error; jtag_error=ERROR_OK; return retval; } 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; @@ -1318,7 +1550,7 @@ void jtag_sleep(u32 us) */ 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; @@ -1327,22 +1559,21 @@ int jtag_examine_chain(void) 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; + field.in_value = idcode_buffer; - field.in_check_value = NULL; - 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++) @@ -1358,13 +1589,20 @@ int jtag_examine_chain(void) 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 */ - LOG_WARNING("Device does not have IDCODE"); + LOG_WARNING("Tap/Device does not have IDCODE"); idcode=0; bit_count += 1; @@ -1375,7 +1613,9 @@ int jtag_examine_chain(void) u32 part; u32 version; - if (idcode == 0x000000FF) + /* some devices, such as AVR will output all 1's instead of TDI + input value at end of chain. */ + if ((idcode == 0x000000FF)||(idcode == 0xFFFFFFFF)) { int unexpected=0; /* End of chain (invalid manufacturer ID) @@ -1392,7 +1632,7 @@ int jtag_examine_chain(void) 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)) + if (unexpected||((idcode != 0x000000FF)&&(idcode != 0xFFFFFFFF))) { LOG_WARNING("Unexpected idcode after end of chain! %d 0x%08x", bit_count, idcode); unexpected = 1; @@ -1402,28 +1642,71 @@ int jtag_examine_chain(void) break; } - manufacturer = (idcode & 0xffe) >> 1; - part = (idcode & 0xffff000) >> 12; - version = (idcode & 0xf0000000) >> 28; +#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 device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)", + 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 (device) + if (tap) { - device->idcode = idcode; - device = device->next; + 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; } @@ -1433,54 +1716,61 @@ int jtag_examine_chain(void) 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; field.in_value = ir_test; - field.in_check_value = NULL; - 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) - { - if (buf_get_u32(ir_test, chain_pos, 2) != 0x1) + tap = NULL; + chain_pos = 0; + int val; + for(;;){ + tap = jtag_NextEnabledTap(tap); + if( tap == NULL ){ + break; + } + + val = buf_get_u32(ir_test, chain_pos, 2); + if (val != 0x1) { char *cbuf = buf_to_str(ir_test, total_ir_length, 16); - LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf); + LOG_ERROR("Could not validate JTAG scan chain, IR mismatch, scan returned 0x%s. tap=%s pos=%d expected 0x1 got %0x", cbuf, jtag_tap_name(tap), chain_pos, val); free(cbuf); 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) + val = buf_get_u32(ir_test, chain_pos, 2); + if (val != 0x3) { char *cbuf = buf_to_str(ir_test, total_ir_length, 16); - LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf); + LOG_ERROR("Could not validate end of JTAG scan chain, IR mismatch, scan returned 0x%s. pos=%d expected 0x3 got %0x", cbuf, chain_pos, val); free(cbuf); free(ir_test); return ERROR_JTAG_INIT_FAILED; @@ -1491,32 +1781,329 @@ int jtag_validate_chain(void) 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 -jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv ) +static int jtag_tap_configure_cmd( Jim_GetOptInfo *goi, jtag_tap_t * tap) { - Jim_GetOptInfo goi; - int e; Jim_Nvp *n; - struct command_context_s *context; + Jim_Obj *o; + int e; - enum { - JTAG_CMD_INTERFACE, - JTAG_CMD_INIT_RESET, - }; + /* parse config or cget options */ + while (goi->argc > 0) { + Jim_SetEmptyResult (goi->interp); - const Jim_Nvp jtag_cmds[] = { - { .name = "interface" , .value = JTAG_CMD_INTERFACE }, - { .name = "arp_init-reset", .value = JTAG_CMD_INIT_RESET }, + e = Jim_GetOpt_Nvp(goi, nvp_config_opts, &n); + if (e != JIM_OK) { + Jim_GetOpt_NvpUnknown(goi, nvp_config_opts, 0); + return e; + } - { .name = NULL, .value = -1 }, - }; + switch (n->value) { + case JCFG_EVENT: + if (goi->argc == 0) { + Jim_WrongNumArgs( goi->interp, goi->argc, goi->argv, "-event ?event-name? ..." ); + return JIM_ERR; + } - context = Jim_GetAssocData(interp, "context"); - // go past the command - Jim_GetOpt_Setup( &goi, interp, argc-1, argv+1 ); + 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; + } - e = Jim_GetOpt_Nvp( &goi, jtag_cmds, &n ); + 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 == (enum jtag_tap_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; @@ -1524,9 +2111,9 @@ jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv ) 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. + /* 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; @@ -1544,8 +2131,82 @@ jim_jtag_command( Jim_Interp *interp, int argc, Jim_Obj *const *argv ) 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: + e = t->enabled; + 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; } @@ -1563,7 +2224,8 @@ int jtag_register_commands(struct command_context_s *cmd_ctx) register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command, COMMAND_CONFIG, "jtag_device "); register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command, - COMMAND_CONFIG, NULL); + COMMAND_ANY, + "[none/trst_only/srst_only/trst_and_srst] [srst_pulls_trst/trst_pulls_srst] [combined/separate] [trst_push_pull/trst_open_drain] [srst_push_pull/srst_open_drain]"); register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command, COMMAND_ANY, "jtag_nsrst_delay - delay after deasserting srst in ms"); register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command, @@ -1607,27 +2269,21 @@ int jtag_interface_init(struct command_context_s *cmd_ctx) if (jtag_interface->init() != ERROR_OK) return ERROR_JTAG_INIT_FAILED; - - jtag = jtag_interface; return ERROR_OK; } static int jtag_init_inner(struct command_context_s *cmd_ctx) { - jtag_device_t *device; + jtag_tap_t *tap; int retval; 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_tlr(); @@ -1642,7 +2298,7 @@ static int jtag_init_inner(struct command_context_s *cmd_ctx) if (jtag_validate_chain() != ERROR_OK) { - LOG_ERROR("Could not validate JTAG chain, continuing anyway..."); + LOG_WARNING("Could not validate JTAG chain, continuing anyway..."); } return ERROR_OK; @@ -1655,11 +2311,11 @@ int jtag_init_reset(struct command_context_s *cmd_ctx) if ((retval=jtag_interface_init(cmd_ctx)) != ERROR_OK) return retval; - LOG_DEBUG("Trying to bring the JTAG controller to life by asserting TRST / TLR"); + 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 TLR before the target reset. + * 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. @@ -1672,7 +2328,7 @@ int jtag_init_reset(struct command_context_s *cmd_ctx) * NB! order matters!!!! srst *can* disconnect JTAG circuitry * */ - jtag_add_reset(1, 0); /* TLR or TRST */ + jtag_add_reset(1, 0); /* RESET or TRST */ if (jtag_reset_config & RESET_HAS_SRST) { jtag_add_reset(1, 1); @@ -1729,7 +2385,7 @@ static int default_srst_asserted(int *srst_asserted) return ERROR_OK; } -int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { int i; int retval; @@ -1792,61 +2448,105 @@ int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char return ERROR_JTAG_INVALID_INTERFACE; } -int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static 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; + } + 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) + boundaryscan(len5)"); + command_print( cmd_ctx, "jtag newtap stm32 cortexm3 ....., thus creating the tap: \"stm32.cortexm3\""); + command_print( cmd_ctx, "jtag newtap stm32 boundary ....., and the tap: \"stm32.boundary\""); + 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; +} - *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; +static int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +{ + jtag_tap_t *tap; - jtag_register_event_callback(jtag_reset_callback, (*last_device_p)); + tap = jtag_all_taps; + command_print(cmd_ctx, " TapName | Enabled | IdCode Expected IrLen IrCap IrMask Instr "); + command_print(cmd_ctx, "---|--------------------|---------|------------|------------|------|------|------|---------"); - jtag_num_devices++; + 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); - return ERROR_OK; -} + 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); -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; + for (ii = 1; ii < tap->expected_ids_cnt; ii++) { + command_print(cmd_ctx, " | | | | 0x%08x | | | | ", + tap->expected_ids[ii]); + } - 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++; + tap = tap->next_tap; } return ERROR_OK; } -int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { if (argc < 1) return ERROR_COMMAND_SYNTAX_ERROR; @@ -1863,7 +2563,7 @@ 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; } @@ -1884,7 +2584,7 @@ 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; } @@ -1899,7 +2599,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; } @@ -1913,7 +2613,7 @@ 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; } @@ -1922,7 +2622,7 @@ int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, ch return ERROR_OK; } -int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { if (argc < 1) { @@ -1937,7 +2637,7 @@ int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd return ERROR_OK; } -int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { if (argc < 1) { @@ -1952,7 +2652,7 @@ int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd return ERROR_OK; } -int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { int retval=ERROR_OK; @@ -1980,7 +2680,7 @@ int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char return retval; } -int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static 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"); @@ -2019,14 +2719,20 @@ int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char * return retval; } - command_print(cmd_ctx, "jtag_khz: %d", speed_khz); + if (speed_khz==0) + { + command_print(cmd_ctx, "RCLK - adaptive"); + } else + { + command_print(cmd_ctx, "%d kHz", speed_khz); + } return retval; } -int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - enum tap_state state; + tap_state_t state; if (argc < 1) { @@ -2034,21 +2740,20 @@ int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char * } else { - for (state = 0; state < 16; state++) - { - if (strcmp(args[0], tap_state_strings[state]) == 0) - { - jtag_add_end_state(state); - jtag_execute_queue(); - } + state = tap_state_by_name( args[0] ); + if( state < 0 ){ + command_print( cmd_ctx, "Invalid state name: %s\n", args[0] ); + return ERROR_COMMAND_SYNTAX_ERROR; } + jtag_add_end_state(state); + jtag_execute_queue(); } - command_print(cmd_ctx, "current endstate: %s", tap_state_strings[cmd_queue_end_state]); + command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state)); return ERROR_OK; } -int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { int trst = -1; int srst = -1; @@ -2085,47 +2790,84 @@ int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char return ERROR_OK; } -int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { if (argc < 1) { return ERROR_COMMAND_SYNTAX_ERROR; } - jtag_add_runtest(strtol(args[0], NULL, 0), -1); + jtag_add_runtest(strtol(args[0], NULL, 0), TAP_INVALID); jtag_execute_queue(); return ERROR_OK; } -int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static 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; + tap_state_t endstate; if ((argc < 2) || (argc % 2)) { return ERROR_COMMAND_SYNTAX_ERROR; } + /* optional "-endstate" */ + /* "statename" */ + /* at the end of the arguments. */ + /* assume none. */ + endstate = TAP_INVALID; + if( argc >= 4 ){ + /* have at least one pair of numbers. */ + /* is last pair the magic text? */ + if( 0 == strcmp( "-endstate", args[ argc - 2 ] ) ){ + const char *cpA; + const char *cpS; + cpA = args[ argc-1 ]; + for( endstate = 0 ; endstate < TAP_NUM_STATES ; endstate++ ){ + cpS = tap_state_name( endstate ); + if( 0 == strcmp( cpA, cpS ) ){ + break; + } + } + if( endstate >= TAP_NUM_STATES ){ + return ERROR_COMMAND_SYNTAX_ERROR; + } else { + /* found - remove the last 2 args */ + argc -= 2; + } + } + } + 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; fields[i].in_value = NULL; fields[i].in_check_mask = NULL; fields[i].in_handler = NULL; fields[i].in_handler_priv = NULL; } - jtag_add_ir_scan(argc / 2, fields, -1); + jtag_add_ir_scan(argc / 2, fields, TAP_INVALID); + /* did we have an endstate? */ + if (endstate != TAP_INVALID) + jtag_add_end_state(endstate); + jtag_execute_queue(); for (i = 0; i < argc / 2; i++) @@ -2136,19 +2878,24 @@ int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **a return ERROR_OK; } -int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args) +static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args) { int retval; scan_field_t *fields; int num_fields; int field_count = 0; int i, e; - long device; + jtag_tap_t *tap; + tap_state_t endstate; /* args[1] = device * args[2] = num_bits * args[3] = hex string * ... repeat num bits and hex string ... + * + * .. optionally: + * args[N-2] = "-endstate" + * args[N-1] = statename */ if ((argc < 4) || ((argc % 2)!=0)) { @@ -2156,18 +2903,59 @@ int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args) return JIM_ERR; } + /* assume no endstate */ + endstate = TAP_INVALID; + /* validate arguments as numbers */ + e = JIM_OK; for (i = 2; i < argc; i+=2) { long bits; + const char *cp; e = Jim_GetLong(interp, args[i], &bits); - if (e != JIM_OK) + /* If valid - try next arg */ + if( e == JIM_OK ){ + continue; + } + + /* Not valid.. are we at the end? */ + if ( ((i+2) != argc) ){ + /* nope, then error */ return e; - } + } - e = Jim_GetLong(interp, args[1], &device); - if (e != JIM_OK) - return e; + /* it could be: "-endstate FOO" */ + + /* get arg as a string. */ + cp = Jim_GetString( args[i], NULL ); + /* is it the magic? */ + if( 0 == strcmp( "-endstate", cp ) ){ + /* is the statename valid? */ + cp = Jim_GetString( args[i+1], NULL ); + + /* see if it is a valid state name */ + endstate = tap_state_by_name(cp); + if( endstate < 0 ){ + /* update the error message */ + Jim_SetResult_sprintf(interp,"endstate: %s invalid", cp ); + } else { + /* valid - so clear the error */ + e = JIM_OK; + /* and remove the last 2 args */ + argc -= 2; + } + } + + /* Still an error? */ + if( e != JIM_OK ){ + return e; /* too bad */ + } + } /* validate args */ + + tap = jtag_TapByJimObj( interp, args[1] ); + if( tap == NULL ){ + return JIM_ERR; + } num_fields=(argc-2)/2; fields = malloc(sizeof(scan_field_t) * num_fields); @@ -2180,11 +2968,10 @@ int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args) Jim_GetLong(interp, args[i], &bits); str = Jim_GetString(args[i+1], &len); - fields[field_count].device = device; + 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; @@ -2192,12 +2979,15 @@ int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args) fields[field_count++].in_handler_priv = NULL; } - jtag_add_dr_scan(num_fields, fields, -1); + jtag_add_dr_scan(num_fields, fields, TAP_INVALID); + /* did we get an end state? */ + if (endstate != TAP_INVALID) + jtag_add_end_state(endstate); + retval = jtag_execute_queue(); if (retval != ERROR_OK) { - Jim_SetResult(interp, Jim_NewEmptyStringObj(interp)); - Jim_AppendStrings(interp, Jim_GetResult(interp), "drscan: jtag execute failed", NULL); + Jim_SetResultString(interp, "drscan: jtag execute failed",-1); return JIM_ERR; } @@ -2224,7 +3014,7 @@ int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args) return JIM_OK; } -int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { if (argc == 1) { @@ -2249,7 +3039,6 @@ int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd return ERROR_OK; } - int jtag_power_dropout(int *dropout) { return jtag->power_dropout(dropout); @@ -2259,3 +3048,466 @@ 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); + } +} + +/*--------------------------------------------*/ + +/* these Cable Helper API functions are all documented in the jtag.h header file, + using a Doxygen format. And since Doxygen's configuration file "Doxyfile", + is setup to prefer its docs in the header file, no documentation is here, for + if it were, it would have to be doubly maintained. +*/ + +/** + * @see tap_set_state() and tap_get_state() accessors. + * Actual name is not important since accessors hide it. + */ +static tap_state_t state_follower = TAP_RESET; + +void tap_set_state_impl( tap_state_t new_state ) +{ + /* this is the state we think the TAPs are in now, was cur_state */ + state_follower = new_state; +} + +tap_state_t tap_get_state() +{ + return state_follower; +} + +/** + * @see tap_set_end_state() and tap_get_end_state() accessors. + * Actual name is not important because accessors hide it. + */ +static tap_state_t end_state_follower = TAP_RESET; + +void tap_set_end_state( tap_state_t new_end_state ) +{ + /* this is the state we think the TAPs will be in at completion of the + current TAP operation, was end_state + */ + end_state_follower = new_end_state; +} + +tap_state_t tap_get_end_state() +{ + return end_state_follower; +} + + +int tap_move_ndx( tap_state_t astate ) +{ + /* given a stable state, return the index into the tms_seqs[] array within tap_get_tms_path() */ + + int ndx; + + switch( astate ) + { + case TAP_RESET: ndx = 0; break; + case TAP_DRSHIFT: ndx = 2; break; + case TAP_DRPAUSE: ndx = 3; break; + case TAP_IDLE: ndx = 1; break; + case TAP_IRSHIFT: ndx = 4; break; + case TAP_IRPAUSE: ndx = 5; break; + default: + LOG_ERROR( "fatal: unstable state \"%s\" used in tap_move_ndx()", tap_state_name(astate) ); + exit(1); + } + + return ndx; +} + + +/* tap_move[i][j]: tap movement command to go from state i to state j + * 0: Test-Logic-Reset + * 1: Run-Test/Idle + * 2: Shift-DR + * 3: Pause-DR + * 4: Shift-IR + * 5: Pause-IR + * + * DRSHIFT->DRSHIFT and IRSHIFT->IRSHIFT have to be caught in interface specific code + */ +static struct +{ + u8 bits; + u8 bit_count; + +} tms_seqs[6][6] = /* [from_state_ndx][to_state_ndx] */ +{ + /* value clocked to TMS to move from one of six stable states to another. + * N.B. OOCD clocks TMS from LSB first, so read these right-to-left. + * N.B. These values are tightly bound to the table in tap_get_tms_path_len(). + * N.B. Reset only needs to be 0b11111, but in JLink an even byte of 1's is more stable. + * These extra ones cause no TAP state problem, because we go into reset and stay in reset. + */ + +/* + * These macros allow us to specify TMS state transitions by bits rather than hex bytes. + * Read the bits from LSBit first to MSBit last (right-to-left). + */ +#define HEX__(n) 0x##n##LU + +#define B8__(x) \ + (((x) & 0x0000000FLU)?(1<<0):0) \ + +(((x) & 0x000000F0LU)?(1<<1):0) \ + +(((x) & 0x00000F00LU)?(1<<2):0) \ + +(((x) & 0x0000F000LU)?(1<<3):0) \ + +(((x) & 0x000F0000LU)?(1<<4):0) \ + +(((x) & 0x00F00000LU)?(1<<5):0) \ + +(((x) & 0x0F000000LU)?(1<<6):0) \ + +(((x) & 0xF0000000LU)?(1<<7):0) + +#define B8(bits,count) { ((u8)B8__(HEX__(bits))), (count) } + +#if 0 && ((BUILD_FT2232_FTD2XX==1) || (BUILD_FT2232_LIBFTDI==1) || (BUILD_JLINK==1)) + /* this is the table submitted by Jeff Williams on 3/30/2009 with this comment: + + OK, I added Peter's version of the state table, and it works OK for + me on MC1322x. I've recreated the jlink portion of patch with this + new state table. His changes to my state table are pretty minor in + terms of total transitions, but Peter feels that his version fixes + some long-standing problems. + Jeff + + I added the bit count into the table, reduced RESET column to 7 bits from 8. + Dick + + state specific comments: + ------------------------ + *->RESET tried the 5 bit reset and it gave me problems, 7 bits seems to + work better on ARM9 with ft2232 driver. (Dick) + + RESET->DRSHIFT add 1 extra clock cycles in the RESET state before advancing. + needed on ARM9 with ft2232 driver. (Dick) + + RESET->IRSHIFT add 1 extra clock cycles in the RESET state before advancing. + needed on ARM9 with ft2232 driver. (Dick) + */ + + /* to state: */ + /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */ + { B8(1111111,7), B8(0,1), B8(00101,5), B8(01010,5), B8(001101,6), B8(010110,6) }, /* RESET */ + { B8(1111111,7), B8(0,1), B8(001,3), B8(0101,4), B8(0011,4), B8(01011,5) }, /* IDLE */ + { B8(1111111,7), B8(011,3), B8(00111,5), B8(01,2), B8(001111,6), B8(0101111,7) }, /* DRSHIFT */ + { B8(1111111,7), B8(011,3), B8(01,2), B8(0,1), B8(001111,6), B8(0101111,7) }, /* DRPAUSE */ + { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(001111,6), B8(01,2) }, /* IRSHIFT */ + { B8(1111111,7), B8(011,3), B8(00111,5), B8(010111,6), B8(01,2), B8(0,1) } /* IRPAUSE */ + +#else /* this is the old table, converted from hex and with the bit_count set to 7 for each combo, like before */ + + /* to state: */ + /* RESET IDLE DRSHIFT DRPAUSE IRSHIFT IRPAUSE */ /* from state: */ + { B8(1111111,7), B8(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */ + { B8(1111111,7), B8(0000000,7), B8(0100101,7), B8(0000101,7), B8(0101011,7), B8(0001011,7) }, /* IDLE */ + { B8(1111111,7), B8(0110001,7), B8(0000000,7), B8(0000001,7), B8(0001111,7), B8(0101111,7) }, /* DRSHIFT */ + { B8(1111111,7), B8(0110000,7), B8(0100000,7), B8(0010111,7), B8(0011110,7), B8(0101111,7) }, /* DRPAUSE */ + { B8(1111111,7), B8(0110001,7), B8(0000111,7), B8(0010111,7), B8(0000000,7), B8(0000001,7) }, /* IRSHIFT */ + { B8(1111111,7), B8(0110000,7), B8(0011100,7), B8(0010111,7), B8(0100000,7), B8(0101111,7) } /* IRPAUSE */ + +#endif + +#if 0 /* keeping old hex stuff for awhile, for reference */ + /* 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 */ +#endif +}; + + +int tap_get_tms_path( tap_state_t from, tap_state_t to ) +{ + return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)].bits; +} + + +int tap_get_tms_path_len( tap_state_t from, tap_state_t to ) +{ + return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)].bit_count; +} + + +bool tap_is_state_stable(tap_state_t astate) +{ + bool is_stable; + + /* A switch() is used because it is symbol dependent + (not value dependent like an array), and can also check bounds. + */ + switch( astate ) + { + case TAP_RESET: + case TAP_IDLE: + case TAP_DRSHIFT: + case TAP_DRPAUSE: + case TAP_IRSHIFT: + case TAP_IRPAUSE: + is_stable = true; + break; + default: + is_stable = false; + } + + return is_stable; +} + +tap_state_t tap_state_transition(tap_state_t cur_state, bool tms) +{ + tap_state_t new_state; + + /* A switch is used because it is symbol dependent and not value dependent + like an array. Also it can check for out of range conditions. + */ + + if (tms) + { + switch (cur_state) + { + case TAP_RESET: + new_state = cur_state; + break; + case TAP_IDLE: + case TAP_DRUPDATE: + case TAP_IRUPDATE: + new_state = TAP_DRSELECT; + break; + case TAP_DRSELECT: + new_state = TAP_IRSELECT; + break; + case TAP_DRCAPTURE: + case TAP_DRSHIFT: + new_state = TAP_DREXIT1; + break; + case TAP_DREXIT1: + case TAP_DREXIT2: + new_state = TAP_DRUPDATE; + break; + case TAP_DRPAUSE: + new_state = TAP_DREXIT2; + break; + case TAP_IRSELECT: + new_state = TAP_RESET; + break; + case TAP_IRCAPTURE: + case TAP_IRSHIFT: + new_state = TAP_IREXIT1; + break; + case TAP_IREXIT1: + case TAP_IREXIT2: + new_state = TAP_IRUPDATE; + break; + case TAP_IRPAUSE: + new_state = TAP_IREXIT2; + break; + default: + LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state ); + exit(1); + break; + } + } + else + { + switch (cur_state) + { + case TAP_RESET: + case TAP_IDLE: + case TAP_DRUPDATE: + case TAP_IRUPDATE: + new_state = TAP_IDLE; + break; + case TAP_DRSELECT: + new_state = TAP_DRCAPTURE; + break; + case TAP_DRCAPTURE: + case TAP_DRSHIFT: + case TAP_DREXIT2: + new_state = TAP_DRSHIFT; + break; + case TAP_DREXIT1: + case TAP_DRPAUSE: + new_state = TAP_DRPAUSE; + break; + case TAP_IRSELECT: + new_state = TAP_IRCAPTURE; + break; + case TAP_IRCAPTURE: + case TAP_IRSHIFT: + case TAP_IREXIT2: + new_state = TAP_IRSHIFT; + break; + case TAP_IREXIT1: + case TAP_IRPAUSE: + new_state = TAP_IRPAUSE; + break; + default: + LOG_ERROR( "fatal: invalid argument cur_state=%d", cur_state ); + exit(1); + break; + } + } + + return new_state; +} + +const char* tap_state_name(tap_state_t state) +{ + const char* ret; + + switch( state ) + { + case TAP_RESET: ret = "RESET"; break; + case TAP_IDLE: ret = "RUN/IDLE"; break; + case TAP_DRSELECT: ret = "DRSELECT"; break; + case TAP_DRCAPTURE: ret = "DRCAPTURE"; break; + case TAP_DRSHIFT: ret = "DRSHIFT"; break; + case TAP_DREXIT1: ret = "DREXIT1"; break; + case TAP_DRPAUSE: ret = "DRPAUSE"; break; + case TAP_DREXIT2: ret = "DREXIT2"; break; + case TAP_DRUPDATE: ret = "DRUPDATE"; break; + case TAP_IRSELECT: ret = "IRSELECT"; break; + case TAP_IRCAPTURE: ret = "IRCAPTURE"; break; + case TAP_IRSHIFT: ret = "IRSHIFT"; break; + case TAP_IREXIT1: ret = "IREXIT1"; break; + case TAP_IRPAUSE: ret = "IRPAUSE"; break; + case TAP_IREXIT2: ret = "IREXIT2"; break; + case TAP_IRUPDATE: ret = "IRUPDATE"; break; + default: ret = "???"; + } + + return ret; +} + +static tap_state_t tap_state_by_name( const char *name ) +{ + tap_state_t x; + + for( x = 0 ; x < TAP_NUM_STATES ; x++ ){ + /* be nice to the human */ + if( 0 == strcasecmp( name, tap_state_name(x) ) ){ + return x; + } + } + /* not found */ + return TAP_INVALID; +} + +#ifdef _DEBUG_JTAG_IO_ + +#define JTAG_DEBUG_STATE_APPEND(buf, len, bit) \ + do { buf[len] = bit ? '1' : '0'; } while(0) +#define JTAG_DEBUG_STATE_PRINT(a, b, astr, bstr) \ + DEBUG_JTAG_IO("TAP/SM: %9s -> %5s\tTMS: %s\tTDI: %s", \ + tap_state_name(a), tap_state_name(b), astr, bstr) + +tap_state_t jtag_debug_state_machine(const void *tms_buf, const void *tdi_buf, + unsigned tap_bits, tap_state_t next_state) +{ + const u8 *tms_buffer; + const u8 *tdi_buffer; + unsigned tap_bytes; + unsigned cur_byte; + unsigned cur_bit; + + unsigned tap_out_bits; + char tms_str[33]; + char tdi_str[33]; + + tap_state_t last_state; + + // set startstate (and possibly last, if tap_bits == 0) + last_state = next_state; + DEBUG_JTAG_IO("TAP/SM: START state: %s", tap_state_name(next_state)); + + tms_buffer = (const u8 *)tms_buf; + tdi_buffer = (const u8 *)tdi_buf; + + tap_bytes = TAP_SCAN_BYTES(tap_bits); + DEBUG_JTAG_IO("TAP/SM: TMS bits: %u (bytes: %u)", tap_bits, tap_bytes); + + tap_out_bits = 0; + for(cur_byte = 0; cur_byte < tap_bytes; cur_byte++) + { + for(cur_bit = 0; cur_bit < 8; cur_bit++) + { + // make sure we do not run off the end of the buffers + unsigned tap_bit = cur_byte * 8 + cur_bit; + if (tap_bit == tap_bits) + break; + + // check and save TMS bit + tap_bit = !!(tms_buffer[cur_byte] & (1 << cur_bit)); + JTAG_DEBUG_STATE_APPEND(tms_str, tap_out_bits, tap_bit); + + // use TMS bit to find the next TAP state + next_state = tap_state_transition(last_state, tap_bit); + + // check and store TDI bit + tap_bit = !!(tdi_buffer[cur_byte] & (1 << cur_bit)); + JTAG_DEBUG_STATE_APPEND(tdi_str, tap_out_bits, tap_bit); + + // increment TAP bits + tap_out_bits++; + + // Only show TDO bits on state transitions, or + // after some number of bits in the same state. + if ((next_state == last_state) && (tap_out_bits < 32)) + continue; + + // terminate strings and display state transition + tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0; + JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str); + + // reset state + last_state = next_state; + tap_out_bits = 0; + } + } + + if (tap_out_bits) + { + // terminate strings and display state transition + tms_str[tap_out_bits] = tdi_str[tap_out_bits] = 0; + JTAG_DEBUG_STATE_PRINT(last_state, next_state, tms_str, tdi_str); + } + + DEBUG_JTAG_IO("TAP/SM: FINAL state: %s", tap_state_name(next_state)); + + return next_state; +} +#endif // _DEBUG_JTAG_IO_ + +/*-------------------------------------------*/