X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fjtag.c;h=5696fa0b130700e57f6912df4b98f734db3103e9;hp=a3e8cff8dba11eb9703b0995979e7d69935dfc15;hb=81184adfb0bf71e25674f827ef92a48092b88d6b;hpb=4102c784321e68d8d82174148a51d4bcd8f14c82 diff --git a/src/jtag/jtag.c b/src/jtag/jtag.c index a3e8cff8db..5696fa0b13 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] = { @@ -160,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, @@ -181,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, }; @@ -188,14 +204,11 @@ jtag_interface_t *jtag_interfaces[] = { jtag_interface_t *jtag = NULL; /* configuration */ -char* jtag_interface = NULL; -int jtag_speed = -1; +jtag_interface_t *jtag_interface = NULL; +int jtag_speed = 0; + /* forward declarations */ -int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); -int jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); -int jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); -int jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); 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); @@ -318,8 +331,9 @@ jtag_device_t* jtag_get_device(int num) device = device->next; i++; } - - return NULL; + + ERROR("jtag device number %d not defined", num); + exit(-1); } void* cmd_queue_alloc(size_t size) @@ -346,7 +360,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() @@ -370,7 +385,6 @@ int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) jtag_device_t *device; int i, j; int scan_size = 0; - /* int changed = 0; */ if (jtag_trst == 1) { @@ -378,26 +392,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 */ @@ -412,7 +406,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; @@ -424,7 +418,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); @@ -432,27 +426,30 @@ 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) - { - (*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 - { - (*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 = NULL; /* disable verification by default */ /* search the list */ - for (j=0; j < num_fields; j++) + for (j = 0; j < num_fields; j++) { if (i == fields[j].device) { found = 1; (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(fields[j].out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); (*last_cmd)->cmd.scan->fields[i].out_mask = buf_cpy(fields[j].out_mask, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); + + if (jtag_verify_capture_ir) + { + if (fields[j].in_handler==NULL) + { + jtag_set_check_value((*last_cmd)->cmd.scan->fields+i, device->expected, device->expected_mask, NULL); + } else + { + (*last_cmd)->cmd.scan->fields[i].in_handler = fields[j].in_handler; + (*last_cmd)->cmd.scan->fields[i].in_handler_priv = fields[j].in_handler_priv; + (*last_cmd)->cmd.scan->fields[i].in_check_value = device->expected; + (*last_cmd)->cmd.scan->fields[i].in_check_mask = device->expected_mask; + } + } device->bypass = 0; break; @@ -521,8 +518,8 @@ 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; } @@ -564,7 +561,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; @@ -576,12 +573,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) { @@ -591,8 +588,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; } @@ -628,6 +625,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 i; @@ -651,7 +649,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; @@ -672,8 +670,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; } @@ -731,52 +729,18 @@ int jtag_add_pathmove(int num_states, enum tap_state *path) return ERROR_JTAG_NOT_IMPLEMENTED; } - if (jtag->support_pathmove) - { - /* 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; + /* 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; + + (*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t)); + (*last_cmd)->cmd.pathmove->num_states = num_states; + (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(enum tap_state) * num_states); - (*last_cmd)->cmd.pathmove = cmd_queue_alloc(sizeof(pathmove_command_t)); - (*last_cmd)->cmd.pathmove->num_states = num_states; - (*last_cmd)->cmd.pathmove->path = cmd_queue_alloc(sizeof(enum tap_state) * num_states); - - for (i = 0; i < num_states; i++) - (*last_cmd)->cmd.pathmove->path[i] = path[i]; - } - else - { - /* validate the desired path, and see if it fits a default path */ - int begin = 0; - int end = 0; - int j; - - for (i = 0; i < num_states; i++) - { - for (j = i; j < num_states; j++) - { - if (tap_move_map[path[j]] != -1) - { - end = j; - break; - } - } - - if (begin - end <= 7) /* a default path spans no more than 7 states */ - { - jtag_add_statemove(path[end]); - } - else - { - ERROR("encountered a TAP path that can't be fulfilled by default paths"); - return ERROR_JTAG_NOT_IMPLEMENTED; - } - - i = end; - } - } + for (i = 0; i < num_states; i++) + (*last_cmd)->cmd.pathmove->path[i] = path[i]; if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR) jtag_call_event_callbacks(JTAG_TRST_RELEASED); @@ -966,7 +930,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; } @@ -1009,25 +973,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) { @@ -1035,9 +1002,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; } @@ -1047,31 +1013,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; @@ -1080,14 +1031,74 @@ 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); + + retval = ERROR_JTAG_QUEUE_FAILED; + } + + } + return retval; +} + +/* + set up checking of this field using the in_handler. The values passed in must be valid until + after jtag_execute() has completed. + */ +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; @@ -1110,20 +1121,11 @@ int jtag_execute_queue(void) return retval; } -int jtag_cancel_queue(void) -{ - cmd_queue_free(); - jtag_command_queue = NULL; - last_comand_pointer = &jtag_command_queue; - - return ERROR_OK; -} - int jtag_reset_callback(enum jtag_event event, void *priv) { jtag_device_t *device = priv; - DEBUG(""); + DEBUG("-"); if (event == JTAG_TRST_ASSERTED) { @@ -1143,6 +1145,7 @@ 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; @@ -1163,7 +1166,7 @@ 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); @@ -1179,7 +1182,7 @@ int jtag_examine_chain() 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;) @@ -1204,13 +1207,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; @@ -1222,7 +1230,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; @@ -1267,7 +1276,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; @@ -1278,7 +1288,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); @@ -1293,7 +1304,7 @@ int jtag_register_commands(struct command_context_s *cmd_ctx) register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command, COMMAND_ANY, "set jtag speed (if supported) "); register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command, - COMMAND_CONFIG, NULL); + COMMAND_CONFIG, "jtag_device "); register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command, COMMAND_CONFIG, NULL); register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command, @@ -1322,28 +1333,33 @@ int jtag_register_commands(struct command_context_s *cmd_ctx) return ERROR_OK; } -int jtag_init(struct command_context_s *cmd_ctx) +int jtag_interface_init(struct command_context_s *cmd_ctx) { - int i; + if (!jtag_interface) + { + /* nothing was previously specified by "interface" command */ + ERROR("JTAG interface has to be specified, see \"interface\" command"); + return ERROR_JTAG_INVALID_INTERFACE; + } - DEBUG(""); + if (jtag_interface->init() != ERROR_OK) + return ERROR_JTAG_INIT_FAILED; - if (jtag_speed == -1) - jtag_speed = 0; + jtag = jtag_interface; + return ERROR_OK; +} - if (jtag_interface && (jtag_interface[0] != 0)) - /* configuration var 'jtag_interface' is set, and not empty */ - for (i = 0; jtag_interfaces[i]; i++) - { - if (strcmp(jtag_interface, jtag_interfaces[i]->name) == 0) - { +int jtag_init(struct command_context_s *cmd_ctx) +{ + int i, validate_tries = 0; jtag_device_t *device; - device = jtag_devices; - if (jtag_interfaces[i]->init() != ERROR_OK) + DEBUG("-"); + + if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK) return ERROR_JTAG_INIT_FAILED; - jtag = jtag_interfaces[i]; + device = jtag_devices; jtag_ir_scan_size = 0; jtag_num_devices = 0; while (device != NULL) @@ -1355,38 +1371,45 @@ 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; - } - } - - /* no valid interface was found (i.e. the configuration option, - * didn't match one of the compiled-in interfaces - */ - ERROR("No valid jtag interface found (%s)", jtag_interface); - ERROR("compiled-in jtag interfaces:"); - for (i = 0; jtag_interfaces[i]; i++) - { - ERROR("%i: %s", i, jtag_interfaces[i]->name); - } - - jtag = NULL; - return ERROR_JTAG_INVALID_INTERFACE; } int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { int i; - /* only if the configuration var isn't overwritten from cmdline */ - if (!jtag_interface) + /* check whether the interface is already configured */ + if (jtag_interface) { - if (args[0] && (args[0][0] != 0)) + WARNING("Interface already configured, ignoring"); + return ERROR_OK; + } + + /* interface name is a mandatory argument */ + if (argc < 1 || args[0][0] == '\0') { + return ERROR_COMMAND_SYNTAX_ERROR; + } + for (i=0; jtag_interfaces[i]; i++) { if (strcmp(args[0], jtag_interfaces[i]->name) == 0) @@ -1394,19 +1417,22 @@ int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char if (jtag_interfaces[i]->register_commands(cmd_ctx) != ERROR_OK) exit(-1); - jtag_interface = jtag_interfaces[i]->name; - + jtag_interface = jtag_interfaces[i]; return ERROR_OK; } } - } - /* remember the requested interface name, so we can complain about it later */ - jtag_interface = strdup(args[0]); - DEBUG("'interface' command didn't specify a valid interface"); + /* no valid interface was found (i.e. the configuration option, + * didn't match one of the compiled-in interfaces + */ + ERROR("No valid jtag interface found (%s)", args[0]); + ERROR("compiled-in jtag interfaces:"); + for (i = 0; jtag_interfaces[i]; i++) + { + ERROR("%i: %s", i, jtag_interfaces[i]->name); } - return ERROR_OK; + return ERROR_JTAG_INVALID_INTERFACE; } int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) @@ -1477,8 +1503,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; } } @@ -1494,8 +1521,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; } } @@ -1507,8 +1535,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; } } @@ -1520,8 +1549,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; } } @@ -1582,18 +1612,20 @@ 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; + return ERROR_COMMAND_SYNTAX_ERROR; } - - 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; } @@ -1602,13 +1634,12 @@ int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char { int trst = -1; int srst = -1; - char *usage = "usage: jtag_reset "; int retval; - if (argc < 1) + if (argc < 2) { - command_print(cmd_ctx, usage); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; + } if (args[0][0] == '1') @@ -1617,8 +1648,7 @@ int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char trst = 0; else { - command_print(cmd_ctx, usage); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } if (args[1][0] == '1') @@ -1627,10 +1657,12 @@ int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char srst = 0; else { - command_print(cmd_ctx, usage); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } + if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK) + return ERROR_JTAG_INIT_FAILED; + if ((retval = jtag_add_reset(trst, srst)) != ERROR_OK) { switch (retval) @@ -1654,8 +1686,7 @@ int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char ** { if (argc < 1) { - command_print(cmd_ctx, "usage: runtest "); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } jtag_add_runtest(strtol(args[0], NULL, 0), -1); @@ -1695,8 +1726,7 @@ int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **a if ((argc < 2) || (argc % 2)) { - command_print(cmd_ctx, "usage: irscan [dev2] [instr2] ..."); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } fields = malloc(sizeof(scan_field_t) * argc / 2); @@ -1736,8 +1766,7 @@ int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **a if ((argc < 2) || (argc % 2)) { - command_print(cmd_ctx, "usage: drscan [dev2] [var2]"); - return ERROR_OK; + return ERROR_COMMAND_SYNTAX_ERROR; } for (i = 0; i < argc; i+=2) @@ -1788,20 +1817,25 @@ int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **a int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - if (argc == 0) - { - command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled"); - return ERROR_OK; - } - - if (strcmp(args[0], "enable") == 0) + if (argc == 1) { - jtag_verify_capture_ir = 1; - } - else if (strcmp(args[0], "disable") == 0) + if (strcmp(args[0], "enable") == 0) + { + jtag_verify_capture_ir = 1; + } + else if (strcmp(args[0], "disable") == 0) + { + jtag_verify_capture_ir = 0; + } else + { + return ERROR_COMMAND_SYNTAX_ERROR; + } + } else if (argc != 0) { - jtag_verify_capture_ir = 0; + return ERROR_COMMAND_SYNTAX_ERROR; } + command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled"); + return ERROR_OK; }