X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fjtag.c;h=bf8e039d8ec87955e3dd33f05fca1691529138da;hp=24a8217d41736ac3e35fcd3f347f49e6864e7eb1;hb=26526a80ea45894aa9041e19f52dcc3ad6dedebc;hpb=d35a4b005e661f6a5428463fc41987300c1bc533 diff --git a/src/jtag/jtag.c b/src/jtag/jtag.c index 24a8217d41..bf8e039d8e 100644 --- a/src/jtag/jtag.c +++ b/src/jtag/jtag.c @@ -35,9 +35,16 @@ #include "command.h" #include "log.h" -#include "stdlib.h" -#include "string.h" +#include +#include #include +#ifdef HAVE_STRINGS_H +#include +#endif +#include + +int jtag_flush_queue_count; /* count # of flushes for profiling / debugging purposes */ + /* 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,6 +76,24 @@ 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; + +}; + + +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; static jtag_tap_t *jtag_all_taps = NULL; @@ -237,6 +262,7 @@ static int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cm 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); @@ -516,15 +542,69 @@ 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 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; + if (fields[j].in_value!=NULL) + { + /* we verify max 32 bit long irlens. */ + 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, tap_state_t state) @@ -563,11 +643,13 @@ int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, break; } nth_tap++; + + assert(nth_tap < x ); + 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 */ + (*last_cmd)->cmd.scan->fields[nth_tap].in_value = NULL; /* do not collect input for tap's in bypass */ /* search the list */ for (j = 0; j < num_fields; j++) @@ -575,22 +657,8 @@ int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, if (tap == fields[j].tap) { found = 1; + (*last_cmd)->cmd.scan->fields[nth_tap].in_value = fields[j].in_value; (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); - (*last_cmd)->cmd.scan->fields[nth_tap].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); - - if (jtag_verify_capture_ir) - { - if (fields[j].in_handler==NULL) - { - jtag_set_check_value((*last_cmd)->cmd.scan->fields+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; - } - } tap->bypass = 0; break; @@ -601,13 +669,13 @@ int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, { /* if a tap isn't listed, set it to BYPASS */ (*last_cmd)->cmd.scan->fields[nth_tap].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); - (*last_cmd)->cmd.scan->fields[nth_tap].out_mask = NULL; tap->bypass = 1; } /* update device information */ buf_cpy((*last_cmd)->cmd.scan->fields[nth_tap].out_value, tap->cur_instr, scan_size); } + assert(nth_tap == (x-1)); return ERROR_OK; } @@ -649,12 +717,7 @@ int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *f (*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; } @@ -670,6 +733,12 @@ void jtag_add_dr_scan(int num_fields, scan_field_t *fields, tap_state_t state) jtag_error=retval; } +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 j; @@ -726,12 +795,8 @@ int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, 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; + field_count++; } } if (!found) @@ -747,12 +812,8 @@ 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; - (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL; - (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL; + field_count++; } else { @@ -837,12 +898,8 @@ void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap, 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_count++; } } else { @@ -857,12 +914,8 @@ void MINIDRIVER(interface_jtag_add_dr_out)(jtag_tap_t *target_tap, /* 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_count++; } } } @@ -903,12 +956,7 @@ int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *f (*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; } return ERROR_OK; @@ -943,7 +991,7 @@ int MINIDRIVER(interface_jtag_add_tlr)(void) void jtag_add_pathmove(int num_states, 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 +1009,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,7 +1021,7 @@ 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; @@ -1245,7 +1294,7 @@ int jtag_build_buffer(scan_command_t *cmd, u8 **buffer) 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,10 +1310,20 @@ 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; } @@ -1282,7 +1341,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 +1355,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); @@ -1333,17 +1370,17 @@ static const char *jtag_tap_name(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, scan_field_t *field, u8 *in_check_value, u8 *in_check_mask) { 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 @@ -1355,12 +1392,12 @@ int jtag_check_value(u8 *captured, void *priv, scan_field_t *field) 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,21 +1418,24 @@ 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, field, value, mask); + jtag_set_error(retval); } + + enum scan_type jtag_scan_type(scan_command_t *cmd) { int i; @@ -1403,7 +1443,7 @@ enum scan_type jtag_scan_type(scan_command_t *cmd) 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 +1452,46 @@ 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_callback3(jtag_callback_t callback, u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2) +{ + 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; + + 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_callback3(u8 *in, jtag_callback_data_t data1, jtag_callback_data_t data2) +{ + ((jtag_callback1_t)data1)(in); + return ERROR_OK; +} + +void jtag_add_callback(jtag_callback1_t callback, u8 *in) +{ + jtag_add_callback3(jtag_convert_to_callback3, in, (jtag_callback_data_t)callback, 0); +} +#endif + +#ifndef HAVE_JTAG_MINIDRIVER_H + +int interface_jtag_execute_queue(void) { int retval; @@ -1424,21 +1503,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); + 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; 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 +1586,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 +1637,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 +1656,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 +1763,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(); @@ -2163,6 +2267,7 @@ 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 "); @@ -2777,11 +2882,7 @@ static int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, c 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, TAP_INVALID); @@ -2893,12 +2994,8 @@ static 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); @@ -2936,6 +3033,15 @@ static int Jim_Command_drscan(Jim_Interp *interp, int argc, Jim_Obj *const *args return JIM_OK; } + +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) @@ -3051,14 +3157,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 +3175,117 @@ 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 + */ +static struct { - /* 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; + +} 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 */ - }; +/* + * 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) + */ - if( !tap_is_state_stable(from) ) - { - LOG_ERROR( "fatal: tap_state \"from\" (=%s) is not stable", tap_state_name(from) ); - exit(1); - } + /* 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 */ - if( !tap_is_state_stable(to) ) - { - LOG_ERROR( "fatal: tap_state \"to\" (=%s) is not stable", tap_state_name(to) ); - exit(1); - } +#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 +}; - /* @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 +3418,7 @@ const char* tap_state_name(tap_state_t state) switch( state ) { case TAP_RESET: ret = "RESET"; break; - case TAP_IDLE: ret = "RUN/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; @@ -3283,4 +3453,89 @@ static tap_state_t 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_ + /*-------------------------------------------*/