X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fjtag%2Fjtag.c;h=4b2e85c1d5b51749ba59a1416fd0e81002efa931;hb=0ce234491acc59480fb85a92c58a83d3392223e7;hp=2f6ab776a7b5cff68258422f438e39c3d9749c55;hpb=0bba832713cca8e5931d5d21f37f526d0a3979cf;p=openocd.git diff --git a/src/jtag/jtag.c b/src/jtag/jtag.c index 2f6ab776a7..4b2e85c1d5 100644 --- a/src/jtag/jtag.c +++ b/src/jtag/jtag.c @@ -28,16 +28,17 @@ #include "config.h" #endif -#include "replacements.h" - #include "jtag.h" -#include "command.h" -#include "log.h" +#ifdef HAVE_STRINGS_H +#include +#endif + + +int jtag_flush_queue_count; /* count # of flushes for profiling / debugging purposes */ -#include "stdlib.h" -#include "string.h" -#include +static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state), + int in_num_fields, scan_field_t *in_fields, tap_state_t state); /* note that this is not marked as static as it must be available from outside jtag.c for those that implement the jtag_xxx() minidriver layer @@ -69,8 +70,26 @@ const Jim_Nvp nvp_jtag_tap_event[] = { int jtag_trst = 0; int jtag_srst = 0; +#ifndef HAVE_JTAG_MINIDRIVER_H +struct jtag_callback_entry +{ + struct jtag_callback_entry *next; + + jtag_callback_t callback; + u8 *in; + jtag_callback_data_t data1; + jtag_callback_data_t data2; + jtag_callback_data_t data3; +}; + + +static struct jtag_callback_entry *jtag_callback_queue_head = NULL; +static struct jtag_callback_entry *jtag_callback_queue_tail = NULL; +#endif + + jtag_command_t *jtag_command_queue = NULL; -jtag_command_t **last_comand_pointer = &jtag_command_queue; +jtag_command_t **last_command_pointer = &jtag_command_queue; static jtag_tap_t *jtag_all_taps = NULL; enum reset_types jtag_reset_config = RESET_NONE; @@ -78,10 +97,11 @@ tap_state_t cmd_queue_end_state = TAP_RESET; tap_state_t cmd_queue_cur_state = TAP_RESET; int jtag_verify_capture_ir = 1; +int jtag_verify = 1; /* 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 */ @@ -210,35 +230,38 @@ 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); -int tap_state_by_name(const char *name); +//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 */ -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); - -int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); - -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); - -int handle_verify_ircapture_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); +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); + +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 Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args); + +static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); jtag_tap_t *jtag_AllTaps(void) { @@ -414,9 +437,24 @@ jtag_command_t** jtag_get_last_command_p(void) return &cmd->next;*/ - return last_comand_pointer; + return last_command_pointer; } + +void jtag_queue_command(jtag_command_t * cmd) +{ + jtag_command_t **last_cmd; + + last_cmd = jtag_get_last_command_p(); + + *last_cmd = cmd; + + (*last_cmd)->next = NULL; + + last_command_pointer = &((*last_cmd)->next); +} + + void* cmd_queue_alloc(size_t size) { cmd_queue_page_t **p_page = &cmd_queue_pages; @@ -493,6 +531,20 @@ void cmd_queue_free(void) cmd_queue_pages = NULL; } +/** + * Copy a scan_field_t for insertion into the queue. + * + * This allocates a new copy of out_value using cmd_queue_alloc. + */ +static void cmd_queue_scan_field_clone(scan_field_t * dst, const scan_field_t * src) +{ + dst->tap = src->tap; + dst->num_bits = src->num_bits; + dst->out_value = buf_cpy(src->out_value, cmd_queue_alloc(CEIL(src->num_bits, 8)), src->num_bits); + dst->in_value = src->in_value; +} + + static void jtag_prelude1(void) { if (jtag_trst == 1) @@ -516,404 +568,475 @@ static void jtag_prelude(tap_state_t state) cmd_queue_cur_state = cmd_queue_end_state; } -void jtag_add_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state) +void jtag_add_ir_scan_noverify(int in_num_fields, const scan_field_t *in_fields, tap_state_t state) { int retval; - jtag_prelude(state); - retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_state); + retval=interface_jtag_add_ir_scan(in_num_fields, in_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, tap_state_t state) + +/** + * Generate an IR SCAN with a list of scan fields with one entry for each enabled TAP. + * + * If the input field list contains an instruction value for a TAP then that is used + * otherwise the TAP is set to bypass. + * + * TAPs for which no fields are passed are marked as bypassed for subsequent DR SCANs. + * + */ +void jtag_add_ir_scan(int in_num_fields, scan_field_t *in_fields, tap_state_t state) { - jtag_command_t **last_cmd; - jtag_tap_t *tap; - int j; - int x; - int nth_tap; - int scan_size = 0; + if (jtag_verify&&jtag_verify_capture_ir) + { + /* 8 x 32 bit id's is enough for all invoations */ - last_cmd = jtag_get_last_command_p(); + for (int j = 0; j < in_num_fields; j++) + { + in_fields[j].check_value=NULL; + in_fields[j].check_mask=NULL; + /* if we are to run a verification of the ir scan, we need to get the input back. + * We may have to allocate space if the caller didn't ask for the input back. + */ + in_fields[j].check_value=in_fields[j].tap->expected; + in_fields[j].check_mask=in_fields[j].tap->expected_mask; + } + jtag_add_scan_check(jtag_add_ir_scan_noverify, in_num_fields, in_fields, state); + } else + { + jtag_add_ir_scan_noverify(in_num_fields, in_fields, state); + } +} - /* 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_SCAN; - - /* allocate memory for ir scan command */ - (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t)); - (*last_cmd)->cmd.scan->ir_scan = 1; - 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; - - nth_tap = -1; - tap = NULL; - for(;;){ - int found = 0; +/** + * see jtag_add_ir_scan() + * + */ +int MINIDRIVER(interface_jtag_add_ir_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state) +{ + size_t num_taps = jtag_NumEnabledTaps(); - /* 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 */ + jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); + scan_command_t * scan = cmd_queue_alloc(sizeof(scan_command_t)); + scan_field_t * out_fields = cmd_queue_alloc(num_taps * sizeof(scan_field_t)); + + jtag_queue_command(cmd); - /* search the list */ - for (j = 0; j < num_fields; j++) + cmd->type = JTAG_SCAN; + cmd->cmd.scan = scan; + + scan->ir_scan = true; + scan->num_fields = num_taps; /* one field per device */ + scan->fields = out_fields; + scan->end_state = state; + + + scan_field_t * field = out_fields; /* keep track where we insert data */ + + /* loop over all enabled TAPs */ + + for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap)) + { + /* search the input field list for fields for the current TAP */ + + bool found = false; + + for (int j = 0; j < in_num_fields; j++) { - if (tap == fields[j].tap) - { - found = 1; - (*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 (tap != in_fields[j].tap) + continue; - if (jtag_verify_capture_ir) - { - if (fields[j].in_handler==NULL) - { - jtag_set_check_value((*last_cmd)->cmd.scan->fields+nth_tap, tap->expected, tap->expected_mask, NULL); - } else - { - (*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; - } - } + /* if TAP is listed in input fields, copy the value */ - tap->bypass = 0; - break; - } + found = true; + + tap->bypass = 0; + + assert(in_fields[j].num_bits == tap->ir_length); /* input fields must have the same length as the TAP's IR */ + + cmd_queue_scan_field_clone(field, in_fields + j); + + break; } if (!found) { - /* 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; + /* if a TAP isn't listed in input fields, set it to BYPASS */ + tap->bypass = 1; + + field->tap = tap; + field->num_bits = tap->ir_length; + field->out_value = buf_set_ones(cmd_queue_alloc(CEIL(tap->ir_length, 8)), tap->ir_length); + field->in_value = NULL; /* do not collect input for tap's in bypass */ } /* update device information */ - buf_cpy((*last_cmd)->cmd.scan->fields[nth_tap].out_value, tap->cur_instr, scan_size); + buf_cpy(field->out_value, tap->cur_instr, tap->ir_length); + + field++; } + assert(field == out_fields + num_taps); /* paranoia: jtag_NumEnabledTaps() and jtag_NextEnabledTap() not in sync */ + return ERROR_OK; } -void jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, tap_state_t state) +/** + * Duplicate the scan fields passed into the function into an IR SCAN command + * + * This function assumes that the caller handles extra fields for bypassed TAPs + * + */ +void jtag_add_plain_ir_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state) { int retval; jtag_prelude(state); - retval=interface_jtag_add_plain_ir_scan(num_fields, fields, cmd_queue_end_state); + retval=interface_jtag_add_plain_ir_scan(in_num_fields, in_fields, cmd_queue_end_state); if (retval!=ERROR_OK) jtag_error=retval; } -int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, tap_state_t state) + +/** + * see jtag_add_plain_ir_scan() + * + */ +int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state) { - int i; - jtag_command_t **last_cmd; - last_cmd = jtag_get_last_command_p(); + jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); + scan_command_t * scan = cmd_queue_alloc(sizeof(scan_command_t)); + scan_field_t * out_fields = cmd_queue_alloc(in_num_fields * sizeof(scan_field_t)); + + jtag_queue_command(cmd); + + cmd->type = JTAG_SCAN; + cmd->cmd.scan = scan; + + scan->ir_scan = true; + scan->num_fields = in_num_fields; + scan->fields = out_fields; + scan->end_state = state; + + for (int i = 0; i < in_num_fields; i++) + cmd_queue_scan_field_clone(out_fields + i, in_fields + i); - /* 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_SCAN; - - /* 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 = 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].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; - (*last_cmd)->cmd.scan->fields[i].in_handler = NULL; - (*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL; - } return ERROR_OK; } -void jtag_add_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state) + + +int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits); + +static int jtag_check_value_mask_callback(u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3) +{ + return jtag_check_value_inner(in, (u8 *)data1, (u8 *)data2, (int)data3); +} + +static void jtag_add_scan_check(void (*jtag_add_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state), + int in_num_fields, scan_field_t *in_fields, tap_state_t state) +{ + for (int i = 0; i < in_num_fields; i++) + { + in_fields[i].allocated = 0; + in_fields[i].modified = 0; + if ((in_fields[i].check_value != NULL) && (in_fields[i].in_value == NULL)) + { + in_fields[i].modified = 1; + /* we need storage space... */ +#ifdef HAVE_JTAG_MINIDRIVER_H + if (in_fields[i].num_bits <= 32) + { + /* This is enough space and we're executing this synchronously */ + in_fields[i].in_value = in_fields[i].intmp; + } else + { + in_fields[i].in_value = (u8 *)malloc(CEIL(in_fields[i].num_bits, 8)); + in_fields[i].allocated = 1; + } +#else + in_fields[i].in_value = (u8 *)cmd_queue_alloc(CEIL(in_fields[i].num_bits, 8)); +#endif + } + } + + jtag_add_scan(in_num_fields, in_fields, state); + + for (int i = 0; i < in_num_fields; i++) + { + if ((in_fields[i].check_value != NULL) && (in_fields[i].in_value != NULL)) + { + /* this is synchronous for a minidriver */ + jtag_add_callback4(jtag_check_value_mask_callback, in_fields[i].in_value, + (jtag_callback_data_t)in_fields[i].check_value, + (jtag_callback_data_t)in_fields[i].check_mask, + (jtag_callback_data_t)in_fields[i].num_bits); + } + if (in_fields[i].allocated) + { + free(in_fields[i].in_value); + } + if (in_fields[i].modified) + { + in_fields[i].in_value = NULL; + } + } +} + +void jtag_add_dr_scan_check(int in_num_fields, scan_field_t *in_fields, tap_state_t state) +{ + if (jtag_verify) + { + jtag_add_scan_check(jtag_add_dr_scan, in_num_fields, in_fields, state); + } else + { + jtag_add_dr_scan(in_num_fields, in_fields, state); + } +} + + +/** + * Generate a DR SCAN using the fields passed to the function + * + * For not bypassed TAPs the function checks in_fields and uses fields specified there. + * For bypassed TAPs the function generates a dummy 1bit field. + * + * The bypass status of TAPs is set by jtag_add_ir_scan(). + * + */ +void jtag_add_dr_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state) { int retval; jtag_prelude(state); - retval=interface_jtag_add_dr_scan(num_fields, fields, cmd_queue_end_state); + retval=interface_jtag_add_dr_scan(in_num_fields, in_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, tap_state_t state) + +/** + * see jtag_add_dr_scan() + * + */ +int MINIDRIVER(interface_jtag_add_dr_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state) { - int j; - int nth_tap; - int bypass_devices = 0; - int field_count = 0; - int scan_size; + /* count devices in bypass */ - jtag_command_t **last_cmd = jtag_get_last_command_p(); - jtag_tap_t *tap; + size_t bypass_devices = 0; - /* count devices in bypass */ - tap = NULL; - bypass_devices = 0; - for(;;){ - tap = jtag_NextEnabledTap(tap); - if( tap == NULL ){ - break; - } - if( tap->bypass ){ + for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap)) + { + if (tap->bypass) bypass_devices++; - } } - /* allocate memory for a new list member */ - *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - last_comand_pointer = &((*last_cmd)->next); - (*last_cmd)->next = NULL; - (*last_cmd)->type = JTAG_SCAN; + jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); + scan_command_t * scan = cmd_queue_alloc(sizeof(scan_command_t)); + scan_field_t * out_fields = cmd_queue_alloc((in_num_fields + bypass_devices) * sizeof(scan_field_t)); + + jtag_queue_command(cmd); + + cmd->type = JTAG_SCAN; + cmd->cmd.scan = scan; - /* allocate memory for dr scan command */ - (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t)); - (*last_cmd)->cmd.scan->ir_scan = 0; - (*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; + scan->ir_scan = false; + scan->num_fields = in_num_fields + bypass_devices; + scan->fields = out_fields; + scan->end_state = state; - 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].tap = tap; - for (j = 0; j < num_fields; j++) - { - 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; - (*last_cmd)->cmd.scan->fields[field_count].in_handler = fields[j].in_handler; - (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = fields[j].in_handler_priv; - } - } - if (!found) + scan_field_t * field = out_fields; /* keep track where we insert data */ + + /* loop over all enabled TAPs */ + + for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap)) + { + /* if TAP is not bypassed insert matching input fields */ + + if (!tap->bypass) { -#ifdef _DEBUG_JTAG_IO_ - /* if a device isn't listed, the BYPASS register should be selected */ - if (! tap->bypass) + scan_field_t * start_field = field; /* keep initial position for assert() */ + + for (int j = 0; j < in_num_fields; j++) { - LOG_ERROR("BUG: no scan data for a device not in BYPASS"); - exit(-1); + if (tap != in_fields[j].tap) + continue; + + cmd_queue_scan_field_clone(field, in_fields + j); + + field++; } -#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; - (*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; - (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL; - (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL; + + assert(field > start_field); /* must have at least one input field per not bypassed TAP */ } + + /* if a TAP is bypassed, generated a dummy bit*/ else { -#ifdef _DEBUG_JTAG_IO_ - /* if a device is listed, the BYPASS register must not be selected */ - if (tap->bypass) - { - LOG_ERROR("BUG: scan data for a device in BYPASS"); - exit(-1); - } -#endif + field->tap = tap; + field->num_bits = 1; + field->out_value = NULL; + field->in_value = NULL; + + field++; } } + + assert(field == out_fields + scan->num_fields); /* no superfluous input fields permitted */ + return ERROR_OK; } + + +/** + * Generate a DR SCAN using the array of output values passed to the function + * + * This function assumes that the parameter target_tap specifies the one TAP + * that is not bypassed. All other TAPs must be bypassed and the function will + * generate a dummy 1bit field for them. + * + * For the target_tap a sequence of output-only fields will be generated where + * each field has the size num_bits and the field's values are taken from + * the array value. + * + * The bypass status of TAPs is set by jtag_add_ir_scan(). + * + */ void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap, - int num_fields, + int in_num_fields, const int *num_bits, const u32 *value, tap_state_t end_state) { - int nth_tap; - int field_count = 0; - int scan_size; - int bypass_devices = 0; + /* count devices in bypass */ - jtag_command_t **last_cmd = jtag_get_last_command_p(); - jtag_tap_t *tap; + size_t bypass_devices = 0; - /* count devices in bypass */ - tap = NULL; - bypass_devices = 0; - for(;;){ - tap = jtag_NextEnabledTap(tap); - if( tap == NULL ){ - break; - } - if( tap->bypass ){ + for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap)) + { + if (tap->bypass) bypass_devices++; - } } - /* allocate memory for a new list member */ - *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - last_comand_pointer = &((*last_cmd)->next); - (*last_cmd)->next = NULL; - (*last_cmd)->type = JTAG_SCAN; - /* allocate memory for dr scan command */ - (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t)); - (*last_cmd)->cmd.scan->ir_scan = 0; - (*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; + jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); + scan_command_t * scan = cmd_queue_alloc(sizeof(scan_command_t)); + scan_field_t * out_fields = cmd_queue_alloc((in_num_fields + bypass_devices) * sizeof(scan_field_t)); - 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; + jtag_queue_command(cmd); + + cmd->type = JTAG_SCAN; + cmd->cmd.scan = scan; + + scan->ir_scan = false; + scan->num_fields = in_num_fields + bypass_devices; + scan->fields = out_fields; + scan->end_state = end_state; + + + bool target_tap_match = false; + + scan_field_t * field = out_fields; /* keep track where we insert data */ - if (tap == target_tap) + /* loop over all enabled TAPs */ + + for (jtag_tap_t * tap = jtag_NextEnabledTap(NULL); tap != NULL; tap = jtag_NextEnabledTap(tap)) + { + /* if TAP is not bypassed insert matching input fields */ + + if (!tap->bypass) { - int j; -#ifdef _DEBUG_JTAG_IO_ - /* if a device is listed, the BYPASS register must not be selected */ - if (tap->bypass) - { - LOG_ERROR("BUG: scan data for a device in BYPASS"); - exit(-1); - } -#endif - for (j = 0; j < num_fields; j++) + assert(tap == target_tap); /* target_tap must match the one not bypassed TAP */ + + target_tap_match = true; + + for (int j = 0; j < in_num_fields; j++) { u8 out_value[4]; - scan_size = num_bits[j]; + size_t scan_size = num_bits[j]; 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; - (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL; - (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL; + + field->tap = tap; + field->num_bits = scan_size; + field->out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); + field->in_value = NULL; + + field++; } - } else + } + + /* if a TAP is bypassed, generated a dummy bit*/ + else { -#ifdef _DEBUG_JTAG_IO_ - /* if a device isn't listed, the BYPASS register should be selected */ - if (! tap->bypass) - { - LOG_ERROR("BUG: no scan data for a device not in BYPASS"); - exit(-1); - } -#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; - (*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; - (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL; - (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL; + + field->tap = tap; + field->num_bits = 1; + field->out_value = NULL; + field->in_value = NULL; + + field++; } } + + assert(target_tap_match); /* target_tap should be enabled and not bypassed */ } -void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state) + +/** + * Duplicate the scan fields passed into the function into a DR SCAN command + * + * This function assumes that the caller handles extra fields for bypassed TAPs + * + */ +void jtag_add_plain_dr_scan(int in_num_fields, const scan_field_t *in_fields, tap_state_t state) { int retval; jtag_prelude(state); - retval=interface_jtag_add_plain_dr_scan(num_fields, fields, cmd_queue_end_state); + retval=interface_jtag_add_plain_dr_scan(in_num_fields, in_fields, cmd_queue_end_state); if (retval!=ERROR_OK) jtag_error=retval; } -int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, tap_state_t state) + +/** + * see jtag_add_plain_dr_scan() + * + */ +int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int in_num_fields, const scan_field_t *in_fields, tap_state_t state) { - int i; - jtag_command_t **last_cmd = jtag_get_last_command_p(); + jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); + scan_command_t * scan = cmd_queue_alloc(sizeof(scan_command_t)); + scan_field_t * out_fields = cmd_queue_alloc(in_num_fields * sizeof(scan_field_t)); - /* allocate memory for a new list member */ - *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - last_comand_pointer = &((*last_cmd)->next); - (*last_cmd)->next = NULL; - (*last_cmd)->type = JTAG_SCAN; + jtag_queue_command(cmd); - /* allocate memory for scan command */ - (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t)); - (*last_cmd)->cmd.scan->ir_scan = 0; - (*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; + cmd->type = JTAG_SCAN; + cmd->cmd.scan = scan; - 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].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; - (*last_cmd)->cmd.scan->fields[i].in_handler = fields[i].in_handler; - (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[i].in_handler_priv; - } + scan->ir_scan = false; + scan->num_fields = in_num_fields; + scan->fields = out_fields; + scan->end_state = state; + + for (int i = 0; i < in_num_fields; i++) + cmd_queue_scan_field_clone(out_fields + i, in_fields + i); return ERROR_OK; } + void jtag_add_tlr(void) { jtag_prelude(TAP_RESET); @@ -927,23 +1050,23 @@ void jtag_add_tlr(void) int MINIDRIVER(interface_jtag_add_tlr)(void) { tap_state_t 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); - (*last_cmd)->next = NULL; - (*last_cmd)->type = JTAG_STATEMOVE; + jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t)); - (*last_cmd)->cmd.statemove->end_state = state; + jtag_queue_command(cmd); + + cmd->type = JTAG_STATEMOVE; + + cmd->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t)); + cmd->cmd.statemove->end_state = state; return ERROR_OK; } -void jtag_add_pathmove(int num_states, tap_state_t *path) +void jtag_add_pathmove(int num_states, const tap_state_t *path) { - tap_state_t cur_state=cmd_queue_cur_state; + tap_state_t cur_state = cmd_queue_cur_state; int i; int retval; @@ -961,6 +1084,7 @@ void jtag_add_pathmove(int num_states, tap_state_t *path) LOG_ERROR("BUG: TAP_RESET is not a valid state for pathmove sequences"); exit(-1); } + if ( tap_state_transition(cur_state, true) != path[i] && tap_state_transition(cur_state, false) != path[i]) { @@ -972,46 +1096,43 @@ void jtag_add_pathmove(int num_states, tap_state_t *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, tap_state_t *path) +int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, const tap_state_t *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); - (*last_cmd)->next = NULL; - (*last_cmd)->type = JTAG_PATHMOVE; + jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); + + jtag_queue_command(cmd); - (*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(tap_state_t) * num_states); + cmd->type = JTAG_PATHMOVE; - for (i = 0; i < num_states; i++) - (*last_cmd)->cmd.pathmove->path[i] = path[i]; + cmd->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t)); + cmd->cmd.pathmove->num_states = num_states; + cmd->cmd.pathmove->path = cmd_queue_alloc(sizeof(tap_state_t) * num_states); + + for (int i = 0; i < num_states; i++) + cmd->cmd.pathmove->path[i] = path[i]; return ERROR_OK; } int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, tap_state_t 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; - last_comand_pointer = &((*last_cmd)->next); - (*last_cmd)->type = JTAG_RUNTEST; + jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); + + jtag_queue_command(cmd); - (*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; + cmd->type = JTAG_RUNTEST; + + cmd->cmd.runtest = cmd_queue_alloc(sizeof(runtest_command_t)); + cmd->cmd.runtest->num_cycles = num_cycles; + cmd->cmd.runtest->end_state = state; return ERROR_OK; } @@ -1031,16 +1152,16 @@ void jtag_add_runtest(int num_cycles, tap_state_t state) 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; + jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); + + jtag_queue_command(cmd); + + cmd->type = JTAG_STABLECLOCKS; + + cmd->cmd.stableclocks = cmd_queue_alloc(sizeof(stableclocks_command_t)); + cmd->cmd.stableclocks->num_cycles = num_cycles; - (*last_cmd)->cmd.stableclocks = cmd_queue_alloc(sizeof(stableclocks_command_t)); - (*last_cmd)->cmd.stableclocks->num_cycles = num_cycles; return ERROR_OK; } @@ -1171,17 +1292,16 @@ void jtag_add_reset(int req_tlr_or_trst, int req_srst) int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst) { - 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_RESET; + jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t)); - (*last_cmd)->cmd.reset->trst = req_trst; - (*last_cmd)->cmd.reset->srst = req_srst; + jtag_queue_command(cmd); + + cmd->type = JTAG_RESET; + + cmd->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t)); + cmd->cmd.reset->trst = req_trst; + cmd->cmd.reset->srst = req_srst; return ERROR_OK; } @@ -1197,16 +1317,15 @@ void jtag_add_end_state(tap_state_t state) 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; - last_comand_pointer = &((*last_cmd)->next); - (*last_cmd)->type = JTAG_SLEEP; + jtag_command_t * cmd = cmd_queue_alloc(sizeof(jtag_command_t)); + + jtag_queue_command(cmd); - (*last_cmd)->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t)); - (*last_cmd)->cmd.sleep->us = us; + cmd->type = JTAG_SLEEP; + + cmd->cmd.sleep = cmd_queue_alloc(sizeof(sleep_command_t)); + cmd->cmd.sleep->us = us; return ERROR_OK; } @@ -1220,7 +1339,7 @@ void jtag_add_sleep(u32 us) return; } -int jtag_scan_size(scan_command_t *cmd) +int jtag_scan_size(const scan_command_t *cmd) { int bit_count = 0; int i; @@ -1234,18 +1353,18 @@ int jtag_scan_size(scan_command_t *cmd) return bit_count; } -int jtag_build_buffer(scan_command_t *cmd, u8 **buffer) +int jtag_build_buffer(const scan_command_t *cmd, u8 **buffer) { int bit_count = 0; int i; bit_count = jtag_scan_size(cmd); - *buffer = malloc(CEIL(bit_count, 8)); + *buffer = calloc(1,CEIL(bit_count, 8)); bit_count = 0; #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("num_fields: %i",cmd->num_fields); + LOG_DEBUG("%s num_fields: %i", cmd->ir_scan ? "IRSCAN" : "DRSCAN", cmd->num_fields); #endif for (i = 0; i < cmd->num_fields; i++) @@ -1261,14 +1380,24 @@ int jtag_build_buffer(scan_command_t *cmd, u8 **buffer) 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; } -int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) +int jtag_read_buffer(u8 *buffer, const scan_command_t *cmd) { int i; int bit_count = 0; @@ -1282,7 +1411,7 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) /* if neither in_value nor in_handler * are specified we don't have to examine this field */ - if (cmd->fields[i].in_value || cmd->fields[i].in_handler) + if (cmd->fields[i].in_value) { int num_bits = cmd->fields[i].num_bits; u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits); @@ -1296,28 +1425,6 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) 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: 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)) - { - if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK) - { - /* 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: w/o \"in_value\", mismatch in %s", cmd->ir_scan ? "SIR" : "SDR" ); - retval = ERROR_JTAG_QUEUE_FAILED; - } } free(captured); @@ -1328,39 +1435,40 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) return retval; } -static const char *jtag_tap_name(jtag_tap_t *tap) +static const char *jtag_tap_name(const jtag_tap_t *tap) { return (tap == NULL) ? "(unknown)" : tap->dotted_name; } -int jtag_check_value(u8 *captured, void *priv, scan_field_t *field) +int jtag_check_value_inner(u8 *captured, u8 *in_check_value, u8 *in_check_mask, int num_bits) { 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); + if (in_check_mask) + 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){ /* 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 > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16); - char *in_check_value_char = buf_to_str(field->in_check_value, (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 > DEBUG_JTAG_IOZ) ? DEBUG_JTAG_IOZ : num_bits, 16); + 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); @@ -1381,29 +1489,32 @@ int jtag_check_value(u8 *captured, void *priv, scan_field_t *field) 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. - */ -void jtag_set_check_value(scan_field_t *field, u8 *value, u8 *mask, error_handler_t *in_error_handler) +void jtag_check_value_mask(scan_field_t *field, u8 *value, u8 *mask) { - if (value) - 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; - field->in_check_value = value; - field->in_check_mask = 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, value, mask, field->num_bits); + jtag_set_error(retval); } -enum scan_type jtag_scan_type(scan_command_t *cmd) + + +enum scan_type jtag_scan_type(const 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) + if (cmd->fields[i].in_value) type |= SCAN_IN; if (cmd->fields[i].out_value) type |= SCAN_OUT; @@ -1412,7 +1523,47 @@ enum scan_type jtag_scan_type(scan_command_t *cmd) return type; } -int MINIDRIVER(interface_jtag_execute_queue)(void) + +#ifndef HAVE_JTAG_MINIDRIVER_H +/* add callback to end of queue */ +void jtag_add_callback4(jtag_callback_t callback, u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3) +{ + struct jtag_callback_entry *entry=cmd_queue_alloc(sizeof(struct jtag_callback_entry)); + + entry->next=NULL; + entry->callback=callback; + entry->in=in; + entry->data1=data1; + entry->data2=data2; + entry->data3=data3; + + if (jtag_callback_queue_head==NULL) + { + jtag_callback_queue_head=entry; + jtag_callback_queue_tail=entry; + } else + { + jtag_callback_queue_tail->next=entry; + jtag_callback_queue_tail=entry; + } +} + + +static int jtag_convert_to_callback4(u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2, jtag_callback_data_t data3) +{ + ((jtag_callback1_t)data1)(in); + return ERROR_OK; +} + +void jtag_add_callback(jtag_callback1_t callback, u8 *in) +{ + jtag_add_callback4(jtag_convert_to_callback4, in, (jtag_callback_data_t)callback, 0, 0); +} +#endif + +#ifndef HAVE_JTAG_MINIDRIVER_H + +int interface_jtag_execute_queue(void) { int retval; @@ -1424,21 +1575,49 @@ int MINIDRIVER(interface_jtag_execute_queue)(void) retval = jtag->execute_queue(); + if (retval == ERROR_OK) + { + struct jtag_callback_entry *entry; + for (entry=jtag_callback_queue_head; entry!=NULL; entry=entry->next) + { + retval=entry->callback(entry->in, entry->data1, entry->data2, entry->data3); + if (retval!=ERROR_OK) + break; + } + } + cmd_queue_free(); + jtag_callback_queue_head = NULL; + jtag_callback_queue_tail = NULL; + jtag_command_queue = NULL; - last_comand_pointer = &jtag_command_queue; + last_command_pointer = &jtag_command_queue; return retval; } +#endif -int jtag_execute_queue(void) +void jtag_execute_queue_noclear(void) { + /* each flush can take as much as 1-2ms on high bandwidth low latency interfaces. + * E.g. a JTAG over TCP/IP or USB.... + */ + jtag_flush_queue_count++; + 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; } @@ -1479,12 +1658,11 @@ int jtag_examine_chain(void) 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++) { @@ -1531,7 +1709,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) @@ -1548,7 +1728,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; @@ -1655,12 +1835,8 @@ int jtag_validate_chain(void) 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_RESET); jtag_execute_queue(); @@ -1758,7 +1934,7 @@ static int jtag_tap_configure_cmd( Jim_GetOptInfo *goi, jtag_tap_t * tap) jteap = tap->event_action; /* replace existing? */ while (jteap) { - if (jteap->event == n->value) { + if (jteap->event == (enum jtag_tap_event)n->value) { break; } jteap = jteap->next; @@ -2163,9 +2339,14 @@ int jtag_register_commands(struct command_context_s *cmd_ctx) register_command(cmd_ctx, NULL, "irscan", handle_irscan_command, COMMAND_EXEC, "execute IR scan [dev2] [instr2] ..."); register_jim(cmd_ctx, "drscan", Jim_Command_drscan, "execute DR scan ..."); + register_jim(cmd_ctx, "flush_count", Jim_Command_flush_count, "returns number of times the JTAG queue has been flushed"); register_command(cmd_ctx, NULL, "verify_ircapture", handle_verify_ircapture_command, COMMAND_ANY, "verify value captured during Capture-IR "); + register_command(cmd_ctx, NULL, "verify_jtag", handle_verify_jtag_command, + COMMAND_ANY, "verify value capture "); + register_command(cmd_ctx, NULL, "tms_sequence", handle_tms_sequence_command, + COMMAND_ANY, "choose short(default) or long tms_sequence "); return ERROR_OK; } @@ -2305,7 +2486,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; @@ -2368,7 +2549,7 @@ 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) { int e; char buf[1024]; @@ -2429,7 +2610,7 @@ int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, cha return e; } -int handle_scan_chain_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) { jtag_tap_t *tap; @@ -2466,7 +2647,7 @@ int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char 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; @@ -2542,7 +2723,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) { @@ -2557,7 +2738,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) { @@ -2572,7 +2753,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; @@ -2600,7 +2781,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"); @@ -2650,9 +2831,9 @@ int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char * } -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) { - int state; + tap_state_t state; if (argc < 1) { @@ -2665,7 +2846,7 @@ int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char * command_print( cmd_ctx, "Invalid state name: %s\n", args[0] ); return ERROR_COMMAND_SYNTAX_ERROR; } - jtag_add_end_state( (tap_state_t)(state)); + jtag_add_end_state(state); jtag_execute_queue(); } command_print(cmd_ctx, "current endstate: %s", tap_state_name(cmd_queue_end_state)); @@ -2673,7 +2854,7 @@ int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char * 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; @@ -2710,7 +2891,7 @@ 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) { @@ -2724,12 +2905,12 @@ 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) +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; - int endstate; + tap_state_t endstate; if ((argc < 2) || (argc % 2)) { @@ -2740,7 +2921,7 @@ int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **a /* "statename" */ /* at the end of the arguments. */ /* assume none. */ - endstate = TAP_INVALID; + endstate = cmd_queue_end_state; if( argc >= 4 ){ /* have at least one pair of numbers. */ /* is last pair the magic text? */ @@ -2763,9 +2944,11 @@ int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **a } } - fields = malloc(sizeof(scan_field_t) * argc / 2); + int num_fields = argc / 2; - for (i = 0; i < argc / 2; i++) + fields = malloc(sizeof(scan_field_t) * num_fields); + + for (i = 0; i < num_fields; i++) { tap = jtag_TapByString( args[i*2] ); if (tap==NULL) @@ -2775,31 +2958,26 @@ int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **a } int field_size = tap->ir_length; fields[i].tap = tap; + fields[i].num_bits = field_size; 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, TAP_INVALID); /* did we have an endstate? */ - if (endstate != TAP_INVALID) - jtag_add_end_state(endstate); + jtag_add_ir_scan(num_fields, fields, endstate); - jtag_execute_queue(); + int retval=jtag_execute_queue(); - for (i = 0; i < argc / 2; i++) + for (i = 0; i < num_fields; i++) free(fields[i].out_value); free (fields); - return ERROR_OK; + return retval; } -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; @@ -2807,7 +2985,7 @@ int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args) int field_count = 0; int i, e; jtag_tap_t *tap; - int endstate; + tap_state_t endstate; /* args[1] = device * args[2] = num_bits @@ -2825,7 +3003,7 @@ int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args) } /* assume no endstate */ - endstate = TAP_INVALID; + endstate = cmd_queue_end_state; /* validate arguments as numbers */ e = JIM_OK; for (i = 2; i < argc; i+=2) @@ -2893,18 +3071,11 @@ int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args) 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; + field_count++; } - jtag_add_dr_scan(num_fields, fields, TAP_INVALID); - /* did we get an end state? */ - if (endstate != TAP_INVALID) - jtag_add_end_state(endstate); + jtag_add_dr_scan(num_fields, fields, endstate); retval = jtag_execute_queue(); if (retval != ERROR_OK) @@ -2936,7 +3107,16 @@ 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 Jim_Command_flush_count(Jim_Interp *interp, int argc, Jim_Obj *const *args) +{ + Jim_SetResult(interp, Jim_NewIntObj(interp, jtag_flush_queue_count)); + + return JIM_OK; +} + + +static int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { if (argc == 1) { @@ -2961,6 +3141,32 @@ int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd return ERROR_OK; } +static int handle_verify_jtag_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +{ + if (argc == 1) + { + if (strcmp(args[0], "enable") == 0) + { + jtag_verify = 1; + } + else if (strcmp(args[0], "disable") == 0) + { + jtag_verify = 0; + } else + { + return ERROR_COMMAND_SYNTAX_ERROR; + } + } else if (argc != 0) + { + return ERROR_COMMAND_SYNTAX_ERROR; + } + + command_print(cmd_ctx, "verify jtag capture is %s", (jtag_verify) ? "enabled": "disabled"); + + return ERROR_OK; +} + + int jtag_power_dropout(int *dropout) { return jtag->power_dropout(dropout); @@ -3051,14 +3257,6 @@ 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() */ - /* old version - const static int move_map[16] = - { - 0, -1, -1, 2, -1, 3, -1, -1, - 1, -1, -1, 4, -1, 5, -1, -1 - }; - */ - int ndx; switch( astate ) @@ -3077,45 +3275,115 @@ int tap_move_ndx( tap_state_t astate ) return ndx; } -int tap_get_tms_path( tap_state_t from, tap_state_t to ) + +/* 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 + */ +struct tms_sequences { - /* 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 + u8 bits; + u8 bit_count; + +}; + +/* + * 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) } + +static const struct tms_sequences old_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. */ - static const u8 tms_seqs[6][6] = - { - /* value clocked to TMS to move from one of six stable states to another */ - /* 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 */ - }; - if( !tap_is_state_stable(from) ) - { - LOG_ERROR( "fatal: tap_state \"from\" (=%s) is not stable", tap_state_name(from) ); - exit(1); - } - if( !tap_is_state_stable(to) ) - { - LOG_ERROR( "fatal: tap_state \"to\" (=%s) is not stable", tap_state_name(to) ); - exit(1); - } + /* 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(0011110,7), B8(0101111,7) }, /* IRPAUSE */ +}; + + + +static const struct tms_sequences short_tms_seqs[6][6] = /* [from_state_ndx][to_state_ndx] */ +{ + /* 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(0000000,7), B8(0010111,7), B8(0001010,7), B8(0011011,7), B8(0010110,7) }, /* RESET */ + { B8(1111111,7), B8(0000000,7), 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 */ + +}; + +typedef const struct tms_sequences tms_table[6][6]; + +static tms_table *tms_seqs=&short_tms_seqs; - /* @todo: support other than 7 clocks ? */ - return tms_seqs[tap_move_ndx(from)][tap_move_ndx(to)]; +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; } @@ -3248,7 +3516,7 @@ const char* tap_state_name(tap_state_t state) switch( state ) { case TAP_RESET: ret = "RESET"; break; - case TAP_IDLE: ret = "IDLE"; 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; @@ -3269,9 +3537,9 @@ const char* tap_state_name(tap_state_t state) return ret; } -int tap_state_by_name( const char *name ) +static tap_state_t tap_state_by_name( const char *name ) { - int x; + tap_state_t x; for( x = 0 ; x < TAP_NUM_STATES ; x++ ){ /* be nice to the human */ @@ -3283,4 +3551,121 @@ int tap_state_by_name( const char *name ) 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_ + +#ifndef HAVE_JTAG_MINIDRIVER_H +void jtag_alloc_in_value32(scan_field_t *field) +{ + field->in_value=(u8 *)cmd_queue_alloc(4); +} +#endif + +static int handle_tms_sequence_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +{ + if (argc == 1) + { + if (strcmp(args[0], "short") == 0) + { + tms_seqs=&short_tms_seqs; + } + else if (strcmp(args[0], "long") == 0) + { + tms_seqs=&old_tms_seqs; + } else + { + return ERROR_COMMAND_SYNTAX_ERROR; + } + } else if (argc != 0) + { + return ERROR_COMMAND_SYNTAX_ERROR; + } + + command_print(cmd_ctx, "tms sequence is %s", (tms_seqs==&short_tms_seqs) ? "short": "long"); + + return ERROR_OK; +} + /*-------------------------------------------*/