X-Git-Url: https://git.gag.com/?a=blobdiff_plain;f=src%2Fjtag%2Fjtag.c;h=2d3d8c54bda904abd83d206da95b3e2d4bb05780;hb=167ce32a7cb99962e6ae8f8c6d36b0999c16888c;hp=cc9f8dc4502368b3e68cc964c033f44ae01738fc;hpb=4fc97d3f2726efa147cfdb0c456eace51550e1e3;p=fw%2Fopenocd diff --git a/src/jtag/jtag.c b/src/jtag/jtag.c index cc9f8dc45..2d3d8c54b 100644 --- a/src/jtag/jtag.c +++ b/src/jtag/jtag.c @@ -58,6 +58,8 @@ static cmd_queue_page_t *cmd_queue_pages = NULL; * 3: Pause-DR * 4: Shift-IR * 5: Pause-IR + * + * SD->SD and SI->SI have to be caught in interface specific code */ u8 tap_move[6][6] = { @@ -95,6 +97,14 @@ tap_transition_t tap_transitions[16] = {TAP_SDS, TAP_RTI} /* UI */ }; +char* jtag_event_strings[] = +{ + "SRST asserted", + "TRST asserted", + "SRST released", + "TRST released" +}; + enum tap_state end_state = TAP_TLR; enum tap_state cur_state = TAP_TLR; int jtag_trst = 0; @@ -152,6 +162,14 @@ jtag_event_callback_t *jtag_event_callbacks; extern jtag_interface_t gw16012_interface; #endif +#if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1 + extern jtag_interface_t presto_interface; +#endif + +#if BUILD_USBPROG == 1 + extern jtag_interface_t usbprog_interface; +#endif + jtag_interface_t *jtag_interfaces[] = { #if BUILD_PARPORT == 1 &parport_interface, @@ -173,6 +191,12 @@ jtag_interface_t *jtag_interfaces[] = { #endif #if BUILD_GW16012 == 1 &gw16012_interface, +#endif +#if BUILD_PRESTO_LIBFTDI == 1 || BUILD_PRESTO_FTD2XX == 1 + &presto_interface, +#endif +#if BUILD_USBPROG == 1 + &usbprog_interface, #endif NULL, }; @@ -183,7 +207,16 @@ jtag_interface_t *jtag = NULL; char* jtag_interface = NULL; int jtag_speed = -1; + /* forward declarations */ +int jtag_add_statemove(enum tap_state endstate); +int jtag_add_pathmove(int num_states, enum tap_state *path); +int jtag_add_runtest(int num_cycles, enum tap_state endstate); +int jtag_add_reset(int trst, int srst); +int jtag_add_end_state(enum tap_state endstate); +int jtag_add_sleep(u32 us); +int jtag_execute_queue(void); +int jtag_cancel_queue(void); /* jtag commands */ int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); @@ -255,7 +288,7 @@ int jtag_call_event_callbacks(enum jtag_event event) { jtag_event_callback_t *callback = jtag_event_callbacks; - DEBUG("jtag event: %i", event); + DEBUG("jtag event: %s", jtag_event_strings[event]); while (callback) { @@ -326,7 +359,8 @@ void* cmd_queue_alloc(size_t size) offset = (*p_page)->used; (*p_page)->used += size; - return ((*p_page)->address) + offset; + u8 *t=(u8 *)((*p_page)->address); + return t + offset; } void cmd_queue_free() @@ -344,13 +378,12 @@ void cmd_queue_free() cmd_queue_pages = NULL; } -int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) +int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state, void *dummy_anachronism) { jtag_command_t **last_cmd; jtag_device_t *device; int i, j; int scan_size = 0; - /* int changed = 0; */ if (jtag_trst == 1) { @@ -358,26 +391,6 @@ int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) return ERROR_JTAG_TRST_ASSERTED; } - /* - for (i=0; icur_instr, fields[i].out_value, device->ir_length)) - changed = 1; - } - else - { - ERROR("inexistant device specified for ir scan"); - return ERROR_INVALID_ARGUMENTS; - } - } - - if (!changed) - return ERROR_OK; - */ - last_cmd = jtag_get_last_command_p(); /* allocate memory for a new list member */ @@ -392,7 +405,7 @@ int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) (*last_cmd)->cmd.scan->num_fields = jtag_num_devices; /* one field per device */ (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(jtag_num_devices * sizeof(scan_field_t)); (*last_cmd)->cmd.scan->end_state = state; - + if (state != -1) cmd_queue_end_state = state; @@ -404,7 +417,7 @@ int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) cmd_queue_cur_state = cmd_queue_end_state; - for (i=0; i < jtag_num_devices; i++) + for (i = 0; i < jtag_num_devices; i++) { int found = 0; device = jtag_get_device(i); @@ -412,21 +425,19 @@ int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) (*last_cmd)->cmd.scan->fields[i].device = i; (*last_cmd)->cmd.scan->fields[i].num_bits = scan_size; (*last_cmd)->cmd.scan->fields[i].in_value = NULL; - if (jtag_verify_capture_ir) + if ((jtag_verify_capture_ir)&&(fields[i].in_handler==NULL)) { - (*last_cmd)->cmd.scan->fields[i].in_check_value = buf_cpy(device->expected, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); - (*last_cmd)->cmd.scan->fields[i].in_check_mask = buf_cpy(device->expected_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); - } - else + jtag_set_check_value((*last_cmd)->cmd.scan->fields+i, device->expected, device->expected_mask, NULL); + } else if (jtag_verify_capture_ir) { - (*last_cmd)->cmd.scan->fields[i].in_check_value = NULL; - (*last_cmd)->cmd.scan->fields[i].in_check_mask = NULL; - } - (*last_cmd)->cmd.scan->fields[i].in_handler = NULL; - (*last_cmd)->cmd.scan->fields[i].in_handler_priv = NULL; + (*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; + (*last_cmd)->cmd.scan->fields[i].in_check_value = device->expected; + (*last_cmd)->cmd.scan->fields[i].in_check_mask = device->expected_mask; + } /* search the list */ - for (j=0; j < num_fields; j++) + for (j = 0; j < num_fields; j++) { if (i == fields[j].device) { @@ -455,7 +466,7 @@ int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) return ERROR_OK; } -int jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) +int jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state, void *dummy_anachronism) { jtag_command_t **last_cmd; int i; @@ -501,15 +512,15 @@ int jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state (*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 = buf_cpy(fields[i].in_check_value, cmd_queue_alloc(num_bytes), num_bits); - (*last_cmd)->cmd.scan->fields[i].in_check_mask = buf_cpy(fields[i].in_check_mask, cmd_queue_alloc(num_bytes), num_bits); + (*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; } -int jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) +int jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state, void *dummy_anachronism) { int i, j; int bypass_devices = 0; @@ -544,7 +555,7 @@ int jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) (*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; - + if (state != -1) cmd_queue_end_state = state; @@ -556,12 +567,12 @@ int jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) cmd_queue_cur_state = cmd_queue_end_state; - for (i=0; i < jtag_num_devices; i++) + for (i = 0; i < jtag_num_devices; i++) { int found = 0; (*last_cmd)->cmd.scan->fields[field_count].device = i; - for (j=0; j < num_fields; j++) + for (j = 0; j < num_fields; j++) { if (i == fields[j].device) { @@ -571,8 +582,8 @@ int jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) (*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 = buf_cpy(fields[j].in_check_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); - (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = buf_cpy(fields[j].in_check_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); + (*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; } @@ -608,7 +619,7 @@ int jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) return ERROR_OK; } -int jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) +int jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state, void *dummy_anachronism) { int i; jtag_command_t **last_cmd = jtag_get_last_command_p(); @@ -631,7 +642,7 @@ int jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state (*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; - + if (state != -1) cmd_queue_end_state = state; @@ -652,8 +663,8 @@ int jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state (*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 = buf_cpy(fields[i].in_check_value, cmd_queue_alloc(num_bytes), num_bits); - (*last_cmd)->cmd.scan->fields[i].in_check_mask = buf_cpy(fields[i].in_check_mask, cmd_queue_alloc(num_bytes), num_bits); + (*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; } @@ -946,7 +957,7 @@ int jtag_scan_size(scan_command_t *cmd) int i; /* count bits in scan command */ - for (i=0; inum_fields; i++) + for (i = 0; i < cmd->num_fields; i++) { bit_count += cmd->fields[i].num_bits; } @@ -989,25 +1000,28 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) { int i; int bit_count = 0; - int retval = ERROR_OK; - - for (i=0; i < cmd->num_fields; i++) + int retval; + + /* we return ERROR_OK, unless a check fails, or a handler reports a problem */ + retval = ERROR_OK; + + for (i = 0; i < cmd->num_fields; i++) { - /* if neither in_value, in_check_value nor in_handler + /* 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_check_value || cmd->fields[i].in_handler) + if (cmd->fields[i].in_value || cmd->fields[i].in_handler) { int num_bits = cmd->fields[i].num_bits; u8 *captured = buf_set_buf(buffer, bit_count, malloc(CEIL(num_bits, 8)), 0, num_bits); - #ifdef _DEBUG_JTAG_IO_ - char *char_buf; - - char_buf = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16); - DEBUG("fields[%i].in_value: 0x%s", i, char_buf); - free(char_buf); - #endif + +#ifdef _DEBUG_JTAG_IO_ + char *char_buf; + char_buf = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16); + DEBUG("fields[%i].in_value: 0x%s", i, char_buf); + free(char_buf); +#endif if (cmd->fields[i].in_value) { @@ -1015,9 +1029,8 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) if (cmd->fields[i].in_handler) { - if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv) != ERROR_OK) + if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK) { - /* TODO: error reporting */ WARNING("in_handler reported a failed check"); retval = ERROR_JTAG_QUEUE_FAILED; } @@ -1027,31 +1040,16 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) /* 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) != ERROR_OK) + if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv, cmd->fields+i) != ERROR_OK) { - /* TODO: error reporting */ + /* We're going to call the error:handler later, but if the in_handler + * reported an error we report this failure upstream + */ WARNING("in_handler reported a failed check"); retval = ERROR_JTAG_QUEUE_FAILED; } - } - if (cmd->fields[i].in_check_value) - { - if ((cmd->fields[i].in_check_mask && buf_cmp_mask(captured, cmd->fields[i].in_check_value, cmd->fields[i].in_check_mask, num_bits)) - || (!cmd->fields[i].in_check_mask && buf_cmp(captured, cmd->fields[i].in_check_mask, num_bits))) - { - char *captured_char = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16); - char *in_check_value_char = buf_to_str(cmd->fields[i].in_check_value, (num_bits > 64) ? 64 : num_bits, 16); - char *in_check_mask_char = buf_to_str(cmd->fields[i].in_check_mask, (num_bits > 64) ? 64 : num_bits, 16); - /* TODO: error reporting */ - WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s check_mask: 0x%s", captured_char, in_check_value_char, in_check_mask_char); - retval = ERROR_JTAG_QUEUE_FAILED; - free(captured_char); - free(in_check_value_char); - free(in_check_mask_char); - } - } free(captured); } bit_count += cmd->fields[i].num_bits; @@ -1060,14 +1058,72 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) return retval; } +int jtag_check_value(u8 *captured, void *priv, scan_field_t *field) +{ + int retval = ERROR_OK; + int num_bits = field->num_bits; + + int compare_failed = 0; + + if (field->in_check_mask) + compare_failed = buf_cmp_mask(captured, field->in_check_value, field->in_check_mask, num_bits); + else + compare_failed = buf_cmp(captured, field->in_check_value, num_bits); + + if (compare_failed) + { + /* 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 + */ + if (compare_failed) + { + char *captured_char = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16); + char *in_check_value_char = buf_to_str(field->in_check_value, (num_bits > 64) ? 64 : num_bits, 16); + + if (field->in_check_mask) + { + char *in_check_mask_char; + in_check_mask_char = buf_to_str(field->in_check_mask, (num_bits > 64) ? 64 : num_bits, 16); + WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s check_mask: 0x%s", captured_char, in_check_value_char, in_check_mask_char); + free(in_check_mask_char); + } + else + { + WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s", captured_char, in_check_value_char); + } + + free(captured_char); + free(in_check_value_char); + } + + } + 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) +{ + 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; /* this will be filled in at the invocation site to point to the field duplicate */ + field->in_check_value = value; + field->in_check_mask = mask; +} + enum scan_type jtag_scan_type(scan_command_t *cmd) { int i; int type = 0; - for (i=0; i < cmd->num_fields; i++) + for (i = 0; i < cmd->num_fields; i++) { - if (cmd->fields[i].in_check_value || cmd->fields[i].in_value || cmd->fields[i].in_handler) + if (cmd->fields[i].in_value || cmd->fields[i].in_handler) type |= SCAN_IN; if (cmd->fields[i].out_value) type |= SCAN_OUT; @@ -1103,7 +1159,7 @@ int jtag_reset_callback(enum jtag_event event, void *priv) { jtag_device_t *device = priv; - DEBUG(""); + DEBUG("-"); if (event == JTAG_TRST_ASSERTED) { @@ -1123,12 +1179,14 @@ void jtag_sleep(u32 us) */ int jtag_examine_chain() { + jtag_device_t *device = jtag_devices; scan_field_t field; u8 idcode_buffer[JTAG_MAX_CHAIN_SIZE * 4]; int i; int bit_count; int device_count = 0; - u8 valid = 0x0; + u8 zero_check = 0x0; + u8 one_check = 0xff; field.device = 0; field.num_bits = sizeof(idcode_buffer) * 8; @@ -1142,22 +1200,23 @@ int jtag_examine_chain() for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++) { - buf_set_u32(idcode_buffer, 0, 32, 0x000000FF); + buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF); } - jtag_add_plain_dr_scan(1, &field, TAP_TLR); + jtag_add_plain_dr_scan(1, &field, TAP_TLR, NULL); jtag_execute_queue(); for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++) { - valid |= idcode_buffer[i]; + zero_check |= idcode_buffer[i]; + one_check &= idcode_buffer[i]; } - /* if there wasn't a single non-zero bit, the scan isn't valid */ - if (!valid) + /* if there wasn't a single non-zero bit or if all bits were one, the scan isn't valid */ + if ((zero_check == 0x00) || (one_check == 0xff)) { ERROR("JTAG communication failure, check connection, JTAG interface, target power etc."); - exit(-1); + return ERROR_JTAG_INIT_FAILED; } for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;) @@ -1182,13 +1241,18 @@ int jtag_examine_chain() break; } + if (device) + { + device->idcode = idcode; + device = device->next; + } device_count++; manufacturer = (idcode & 0xffe) >> 1; part = (idcode & 0xffff000) >> 12; version = (idcode & 0xf0000000) >> 28; - DEBUG("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x", + INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)", idcode, manufacturer, part, version); bit_count += 32; @@ -1200,7 +1264,8 @@ int jtag_examine_chain() { ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)", device_count, jtag_num_devices); - exit(-1); + ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)"); + return ERROR_JTAG_INIT_FAILED; } return ERROR_OK; @@ -1234,7 +1299,7 @@ int jtag_validate_chain() field.in_handler = NULL; field.in_handler_priv = NULL; - jtag_add_plain_ir_scan(1, &field, TAP_TLR); + jtag_add_plain_ir_scan(1, &field, TAP_TLR, NULL); jtag_execute_queue(); device = jtag_devices; @@ -1245,7 +1310,8 @@ int jtag_validate_chain() char *cbuf = buf_to_str(ir_test, total_ir_length, 16); ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf); free(cbuf); - exit(-1); + free(ir_test); + return ERROR_JTAG_INIT_FAILED; } chain_pos += device->ir_length; device = device->next; @@ -1256,7 +1322,8 @@ int jtag_validate_chain() char *cbuf = buf_to_str(ir_test, total_ir_length, 16); ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf); free(cbuf); - exit(-1); + free(ir_test); + return ERROR_JTAG_INIT_FAILED; } free(ir_test); @@ -1302,9 +1369,9 @@ int jtag_register_commands(struct command_context_s *cmd_ctx) int jtag_init(struct command_context_s *cmd_ctx) { - int i; + int i, validate_tries = 0; - DEBUG(""); + DEBUG("-"); if (jtag_speed == -1) jtag_speed = 0; @@ -1333,11 +1400,25 @@ int jtag_init(struct command_context_s *cmd_ctx) jtag_add_statemove(TAP_TLR); jtag_execute_queue(); + + /* examine chain first, as this could discover the real chain layout */ + if (jtag_examine_chain() != ERROR_OK) + { + ERROR("trying to validate configured JTAG chain anyway..."); + } - jtag_examine_chain(); - - jtag_validate_chain(); - + while (jtag_validate_chain() != ERROR_OK) + { + validate_tries++; + if (validate_tries > 5) + { + ERROR("Could not validate JTAG chain, exit"); + jtag = NULL; + return ERROR_JTAG_INVALID_INTERFACE; + } + usleep(10000); + } + return ERROR_OK; } } @@ -1455,8 +1536,9 @@ int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, ch jtag_reset_config = RESET_TRST_AND_SRST; else { - ERROR("invalid reset_config argument"); - exit(-1); + ERROR("invalid reset_config argument, defaulting to none"); + jtag_reset_config = RESET_NONE; + return ERROR_INVALID_ARGUMENTS; } } @@ -1472,8 +1554,9 @@ int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, ch jtag_reset_config &= ~(RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST); else { - ERROR("invalid reset_config argument"); - exit(-1); + ERROR("invalid reset_config argument, defaulting to none"); + jtag_reset_config = RESET_NONE; + return ERROR_INVALID_ARGUMENTS; } } @@ -1485,8 +1568,9 @@ int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, ch jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN; else { - ERROR("invalid reset_config argument"); - exit(-1); + ERROR("invalid reset_config argument, defaulting to none"); + jtag_reset_config = RESET_NONE; + return ERROR_INVALID_ARGUMENTS; } } @@ -1498,8 +1582,9 @@ int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, ch jtag_reset_config &= ~RESET_SRST_PUSH_PULL; else { - ERROR("invalid reset_config argument"); - exit(-1); + ERROR("invalid reset_config argument, defaulting to none"); + jtag_reset_config = RESET_NONE; + return ERROR_INVALID_ARGUMENTS; } } @@ -1561,17 +1646,19 @@ int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char * if (argc < 1) { command_print(cmd_ctx, "usage: endstate "); - return ERROR_OK; } - - for (state = 0; state < 16; state++) + else { - if (strcmp(args[0], tap_state_strings[state]) == 0) + for (state = 0; state < 16; state++) { - jtag_add_end_state(state); - jtag_execute_queue(); + if (strcmp(args[0], tap_state_strings[state]) == 0) + { + jtag_add_end_state(state); + jtag_execute_queue(); + } } } + command_print(cmd_ctx, "current endstate: %s", tap_state_strings[end_state]); return ERROR_OK; } @@ -1693,7 +1780,7 @@ int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **a fields[i].in_handler_priv = NULL; } - jtag_add_ir_scan(argc / 2, fields, -1); + jtag_add_ir_scan(argc / 2, fields, -1, NULL); jtag_execute_queue(); for (i = 0; i < argc / 2; i++) @@ -1753,7 +1840,7 @@ int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **a } } - jtag_add_dr_scan(num_fields, fields, -1); + jtag_add_dr_scan(num_fields, fields, -1, NULL); jtag_execute_queue(); for (i = 0; i < argc / 2; i++)