X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fjtag.c;h=6dfde760112f3b9fc66b9d472319949e0d5236f7;hp=263eed1a931d9ed47b799cfacad79abd75d3ccef;hb=237e894805dd757cc24029af1b4b1e824c51712b;hpb=a4f2e1eaaca40dbcc7916755efb094cacafbb65c diff --git a/src/jtag/jtag.c b/src/jtag/jtag.c index 263eed1a93..6dfde76011 100644 --- a/src/jtag/jtag.c +++ b/src/jtag/jtag.c @@ -95,6 +95,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; @@ -115,6 +123,10 @@ int jtag_verify_capture_ir = 1; int jtag_nsrst_delay = 0; /* default to no nSRST delay */ int jtag_ntrst_delay = 0; /* default to no nTRST delay */ +/* maximum number of JTAG devices expected in the chain + */ +#define JTAG_MAX_CHAIN_SIZE 20 + /* callbacks to inform high-level handlers about JTAG state changes */ jtag_event_callback_t *jtag_event_callbacks; @@ -179,7 +191,20 @@ jtag_interface_t *jtag = NULL; char* jtag_interface = NULL; int jtag_speed = -1; + /* forward declarations */ +int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state endstate, error_handler_t *error_handler); +int jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state endstate, error_handler_t *error_handler); +int jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state endstate, error_handler_t *error_handler); +int jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state endstate, error_handler_t *error_handler); +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); @@ -251,7 +276,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) { @@ -340,13 +365,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, error_handler_t *error_handler) { jtag_command_t **last_cmd; jtag_device_t *device; int i, j; int scan_size = 0; - /* int changed = 0; */ if (jtag_trst == 1) { @@ -354,26 +378,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 */ @@ -388,7 +392,16 @@ 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 (error_handler) + { + (*last_cmd)->cmd.scan->error_handler = cmd_queue_alloc(sizeof(error_handler_t)); + *(*last_cmd)->cmd.scan->error_handler = *error_handler; + } + else + { + (*last_cmd)->cmd.scan->error_handler = NULL; + } + if (state != -1) cmd_queue_end_state = state; @@ -417,7 +430,7 @@ int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) { (*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; @@ -451,7 +464,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, error_handler_t *error_handler) { jtag_command_t **last_cmd; int i; @@ -476,6 +489,15 @@ int jtag_add_plain_ir_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 (error_handler) + { + (*last_cmd)->cmd.scan->error_handler = cmd_queue_alloc(sizeof(error_handler_t)); + *(*last_cmd)->cmd.scan->error_handler = *error_handler; + } + else + { + (*last_cmd)->cmd.scan->error_handler = NULL; + } if (state != -1) cmd_queue_end_state = state; @@ -505,7 +527,7 @@ int jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state 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, error_handler_t *error_handler) { int i, j; int bypass_devices = 0; @@ -540,7 +562,16 @@ 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 (error_handler) + { + (*last_cmd)->cmd.scan->error_handler = cmd_queue_alloc(sizeof(error_handler_t)); + *(*last_cmd)->cmd.scan->error_handler = *error_handler; + } + else + { + (*last_cmd)->cmd.scan->error_handler = NULL; + } + if (state != -1) cmd_queue_end_state = state; @@ -597,15 +628,14 @@ int jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) /* if a device is listed, the BYPASS register must not be selected */ if (jtag_get_device(i)->bypass) { - ERROR("BUG: scan data for a device in BYPASS"); - exit(-1); + WARNING("scan data for a device in BYPASS"); } } } 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, error_handler_t *error_handler) { int i; jtag_command_t **last_cmd = jtag_get_last_command_p(); @@ -628,7 +658,16 @@ 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 (error_handler) + { + (*last_cmd)->cmd.scan->error_handler = cmd_queue_alloc(sizeof(error_handler_t)); + *(*last_cmd)->cmd.scan->error_handler = *error_handler; + } + else + { + (*last_cmd)->cmd.scan->error_handler = NULL; + } + if (state != -1) cmd_queue_end_state = state; @@ -986,8 +1025,11 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) { int i; int bit_count = 0; - int retval = ERROR_OK; - + 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 @@ -997,6 +1039,7 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) { 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; @@ -1004,7 +1047,6 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) DEBUG("fields[%i].in_value: 0x%s", i, char_buf); free(char_buf); #endif - if (cmd->fields[i].in_value) { @@ -1014,7 +1056,6 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) { if (cmd->fields[i].in_handler(cmd->fields[i].in_value, cmd->fields[i].in_handler_priv) != ERROR_OK) { - /* TODO: error reporting */ WARNING("in_handler reported a failed check"); retval = ERROR_JTAG_QUEUE_FAILED; } @@ -1026,27 +1067,63 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) { if (cmd->fields[i].in_handler(captured, cmd->fields[i].in_handler_priv) != 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))) + int compare_failed = 0; + + if (cmd->fields[i].in_check_mask) + compare_failed = buf_cmp_mask(captured, cmd->fields[i].in_check_value, cmd->fields[i].in_check_mask, num_bits); + else + compare_failed = buf_cmp(captured, cmd->fields[i].in_check_value, num_bits); + + 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(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; + + if (cmd->error_handler) + { + /* ask the error handler if once has been specified if this is a real problem */ + if (cmd->error_handler->error_handler(captured, cmd->error_handler->error_handler_priv) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; + else + compare_failed = 0; + } + else + { + /* if there wasn't a handler specified, we report a failure */ + retval = ERROR_JTAG_QUEUE_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) + { + if (cmd->fields[i].in_check_mask) + { + char *in_check_mask_char; + in_check_mask_char = buf_to_str(cmd->fields[i].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); - free(in_check_mask_char); } } free(captured); @@ -1100,7 +1177,7 @@ int jtag_reset_callback(enum jtag_event event, void *priv) { jtag_device_t *device = priv; - DEBUG(""); + DEBUG("-"); if (event == JTAG_TRST_ASSERTED) { @@ -1116,6 +1193,102 @@ void jtag_sleep(u32 us) usleep(us); } +/* Try to examine chain layout according to IEEE 1149.1 §12 + */ +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 zero_check = 0x0; + u8 one_check = 0xff; + + field.device = 0; + field.num_bits = sizeof(idcode_buffer) * 8; + field.out_value = idcode_buffer; + field.out_mask = NULL; + field.in_value = idcode_buffer; + field.in_check_value = NULL; + field.in_check_mask = NULL; + field.in_handler = NULL; + field.in_handler_priv = NULL; + + for (i = 0; i < JTAG_MAX_CHAIN_SIZE; i++) + { + buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF); + } + + jtag_add_plain_dr_scan(1, &field, TAP_TLR, NULL); + jtag_execute_queue(); + + for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++) + { + zero_check |= idcode_buffer[i]; + one_check &= idcode_buffer[i]; + } + + /* 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); + } + + for (bit_count = 0; bit_count < (JTAG_MAX_CHAIN_SIZE * 32) - 31;) + { + u32 idcode = buf_get_u32(idcode_buffer, bit_count, 32); + if ((idcode & 1) == 0) + { + /* LSB must not be 0, this indicates a device in bypass */ + device_count++; + + bit_count += 1; + } + else + { + u32 manufacturer; + u32 part; + u32 version; + + if (idcode == 0x000000FF) + { + /* End of chain (invalid manufacturer ID) */ + 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", + idcode, manufacturer, part, version); + + bit_count += 32; + } + } + + /* see if number of discovered devices matches configuration */ + if (device_count != jtag_num_devices) + { + ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)", + device_count, jtag_num_devices); + ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)"); + exit(-1); + } + + return ERROR_OK; +} + int jtag_validate_chain() { jtag_device_t *device = jtag_devices; @@ -1144,7 +1317,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; @@ -1214,7 +1387,7 @@ int jtag_init(struct command_context_s *cmd_ctx) { int i; - DEBUG(""); + DEBUG("-"); if (jtag_speed == -1) jtag_speed = 0; @@ -1244,6 +1417,8 @@ int jtag_init(struct command_context_s *cmd_ctx) jtag_add_statemove(TAP_TLR); jtag_execute_queue(); + jtag_examine_chain(); + jtag_validate_chain(); return ERROR_OK; @@ -1469,17 +1644,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; } @@ -1601,7 +1778,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++) @@ -1661,7 +1838,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++)