From 22bc5194ae101282cf5c30d681d7f4720bec2534 Mon Sep 17 00:00:00 2001 From: drath Date: Wed, 25 Apr 2007 20:15:59 +0000 Subject: - added support for error handlers to JTAG scan commands (jtag_[plain_][ir|dr]_scan) - catch apparently broken JTAG IR scan after ARM926EJ-S CP15 operations - added "arm7_9 dump_etb" command git-svn-id: svn://svn.berlios.de/openocd/trunk@142 b42882b7-edfa-0310-969c-e2dbd0fdcd60 --- src/helper/command.c | 4 ++ src/jtag/amt_jtagaccel.c | 10 ++- src/jtag/bitbang.c | 12 +++- src/jtag/ft2232.c | 44 ++++++++---- src/jtag/gw16012.c | 10 ++- src/jtag/jtag.c | 167 ++++++++++++++++++++++++++++++--------------- src/jtag/jtag.h | 15 ++-- src/openocd.c | 2 +- src/pld/virtex2.c | 8 +-- src/target/arm720t.c | 4 +- src/target/arm7_9_common.c | 9 ++- src/target/arm7_9_common.h | 1 + src/target/arm7tdmi.c | 18 ++--- src/target/arm920t.c | 14 ++-- src/target/arm926ejs.c | 64 ++++++++++++----- src/target/arm966e.c | 10 +-- src/target/arm9tdmi.c | 47 ++++++++++--- src/target/arm_jtag.c | 38 +++++++++-- src/target/arm_jtag.h | 3 +- src/target/embeddedice.c | 29 ++++++-- src/target/etb.c | 74 ++++++++++++++++++-- src/target/etb.h | 7 ++ src/target/etm.c | 14 ++-- src/target/xscale.c | 24 +++---- src/xsvf/xsvf.c | 16 ++--- 25 files changed, 462 insertions(+), 182 deletions(-) diff --git a/src/helper/command.c b/src/helper/command.c index b4b2164e..11284a1c 100644 --- a/src/helper/command.c +++ b/src/helper/command.c @@ -357,6 +357,10 @@ int command_run_line(command_context_t *context, char *line) if (!*line) return ERROR_OK; + /* ignore comments */ + if (*line && (line[0] == '#')) + return ERROR_OK; + if (context->echo) { command_print(context, "%s", line); diff --git a/src/jtag/amt_jtagaccel.c b/src/jtag/amt_jtagaccel.c index ac263520..0eed9460 100644 --- a/src/jtag/amt_jtagaccel.c +++ b/src/jtag/amt_jtagaccel.c @@ -331,6 +331,12 @@ int amt_jtagaccel_execute_queue(void) int scan_size; enum scan_type type; u8 *buffer; + int retval; + + /* return ERROR_OK, unless a jtag_read_buffer returns a failed check + * that wasn't handled by a caller-provided error handler + */ + retval = ERROR_OK; while (cmd) { @@ -379,7 +385,7 @@ int amt_jtagaccel_execute_queue(void) type = jtag_scan_type(cmd->cmd.scan); amt_jtagaccel_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size); if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK) - return ERROR_JTAG_QUEUE_FAILED; + retval = ERROR_JTAG_QUEUE_FAILED; if (buffer) free(buffer); break; @@ -396,7 +402,7 @@ int amt_jtagaccel_execute_queue(void) cmd = cmd->next; } - return ERROR_OK; + return retval; } #if PARPORT_USE_GIVEIO == 1 diff --git a/src/jtag/bitbang.c b/src/jtag/bitbang.c index 61248364..82e92a21 100644 --- a/src/jtag/bitbang.c +++ b/src/jtag/bitbang.c @@ -182,12 +182,18 @@ int bitbang_execute_queue(void) int scan_size; enum scan_type type; u8 *buffer; + int retval; if (!bitbang_interface) { ERROR("BUG: Bitbang interface called, but not yet initialized"); exit(-1); } + + /* return ERROR_OK, unless a jtag_read_buffer returns a failed check + * that wasn't handled by a caller-provided error handler + */ + retval = ERROR_OK; while (cmd) { @@ -234,7 +240,7 @@ int bitbang_execute_queue(void) break; case JTAG_SCAN: #ifdef _DEBUG_JTAG_IO_ - DEBUG("scan end in %i", cmd->cmd.scan->end_state); + DEBUG("%s scan end in %i", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", cmd->cmd.scan->end_state); #endif if (cmd->cmd.scan->end_state != -1) bitbang_end_state(cmd->cmd.scan->end_state); @@ -242,7 +248,7 @@ int bitbang_execute_queue(void) type = jtag_scan_type(cmd->cmd.scan); bitbang_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size); if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK) - return ERROR_JTAG_QUEUE_FAILED; + retval = ERROR_JTAG_QUEUE_FAILED; if (buffer) free(buffer); break; @@ -259,6 +265,6 @@ int bitbang_execute_queue(void) cmd = cmd->next; } - return ERROR_OK; + return retval; } diff --git a/src/jtag/ft2232.c b/src/jtag/ft2232.c index 32b4c927..75faf38d 100644 --- a/src/jtag/ft2232.c +++ b/src/jtag/ft2232.c @@ -402,7 +402,12 @@ int ft2232_send_and_recv(jtag_command_t *first, jtag_command_t *last) ft2232_expect_read = 0; ft2232_read_pointer = 0; - + + /* return ERROR_OK, unless a jtag_read_buffer returns a failed check + * that wasn't handled by a caller-provided error handler + */ + retval = ERROR_OK; + cmd = first; while (cmd != last) { @@ -415,7 +420,8 @@ int ft2232_send_and_recv(jtag_command_t *first, jtag_command_t *last) scan_size = jtag_scan_size(cmd->cmd.scan); buffer = calloc(CEIL(scan_size, 8), 1); ft2232_read_scan(type, buffer, scan_size); - jtag_read_buffer(buffer, cmd->cmd.scan); + if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; free(buffer); } break; @@ -427,7 +433,7 @@ int ft2232_send_and_recv(jtag_command_t *first, jtag_command_t *last) ft2232_buffer_size = 0; - return ERROR_OK; + return retval; } void ft2232_add_pathmove(pathmove_command_t *cmd) @@ -1039,6 +1045,12 @@ int ft2232_execute_queue() int i; int predicted_size = 0; int require_send = 0; + int retval; + + /* return ERROR_OK, unless ft2232_send_and_recv reports a failed check + * that wasn't handled by a caller-provided error handler + */ + retval = ERROR_OK; ft2232_buffer_size = 0; ft2232_expect_read = 0; @@ -1060,7 +1072,8 @@ int ft2232_execute_queue() predicted_size = 3; if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) { - ft2232_send_and_recv(first_unsent, cmd); + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; require_send = 0; first_unsent = cmd; } @@ -1084,7 +1097,8 @@ int ft2232_execute_queue() predicted_size += 3; if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) { - ft2232_send_and_recv(first_unsent, cmd); + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; require_send = 0; first_unsent = cmd; } @@ -1135,7 +1149,8 @@ int ft2232_execute_queue() predicted_size = 3; if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) { - ft2232_send_and_recv(first_unsent, cmd); + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; require_send = 0; first_unsent = cmd; } @@ -1159,7 +1174,8 @@ int ft2232_execute_queue() predicted_size = 3 * CEIL(cmd->cmd.pathmove->num_states, 7); if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) { - ft2232_send_and_recv(first_unsent, cmd); + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; require_send = 0; first_unsent = cmd; } @@ -1178,7 +1194,8 @@ int ft2232_execute_queue() DEBUG("oversized ft2232 scan (predicted_size > FT2232_BUFFER_SIZE)"); /* unsent commands before this */ if (first_unsent != cmd) - ft2232_send_and_recv(first_unsent, cmd); + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; /* current command */ if (cmd->cmd.scan->end_state != -1) @@ -1193,7 +1210,8 @@ int ft2232_execute_queue() else if (ft2232_buffer_size + predicted_size + 1 > FT2232_BUFFER_SIZE) { DEBUG("ft2232 buffer size reached, sending queued commands (first_unsent: %p, cmd: %p)", first_unsent, cmd); - ft2232_send_and_recv(first_unsent, cmd); + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; require_send = 0; first_unsent = cmd; } @@ -1210,7 +1228,8 @@ int ft2232_execute_queue() #endif break; case JTAG_SLEEP: - ft2232_send_and_recv(first_unsent, cmd); + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; first_unsent = cmd->next; jtag_sleep(cmd->cmd.sleep->us); #ifdef _DEBUG_JTAG_IO_ @@ -1225,9 +1244,10 @@ int ft2232_execute_queue() } if (require_send > 0) - ft2232_send_and_recv(first_unsent, cmd); + if (ft2232_send_and_recv(first_unsent, cmd) != ERROR_OK) + retval = ERROR_JTAG_QUEUE_FAILED; - return ERROR_OK; + return retval; } #if BUILD_FT2232_FTD2XX == 1 diff --git a/src/jtag/gw16012.c b/src/jtag/gw16012.c index 1f1f6086..8c73590b 100644 --- a/src/jtag/gw16012.c +++ b/src/jtag/gw16012.c @@ -360,6 +360,12 @@ int gw16012_execute_queue(void) int scan_size; enum scan_type type; u8 *buffer; + int retval; + + /* return ERROR_OK, unless a jtag_read_buffer returns a failed check + * that wasn't handled by a caller-provided error handler + */ + retval = ERROR_OK; while (cmd) { @@ -415,7 +421,7 @@ int gw16012_execute_queue(void) #endif gw16012_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size); if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK) - return ERROR_JTAG_QUEUE_FAILED; + retval = ERROR_JTAG_QUEUE_FAILED; if (buffer) free(buffer); break; @@ -432,7 +438,7 @@ int gw16012_execute_queue(void) cmd = cmd->next; } - return ERROR_OK; + return retval; } #if PARPORT_USE_GIVEIO == 1 diff --git a/src/jtag/jtag.c b/src/jtag/jtag.c index 13041fc1..7ea40edb 100644 --- a/src/jtag/jtag.c +++ b/src/jtag/jtag.c @@ -191,11 +191,12 @@ 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); -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_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); @@ -364,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) { @@ -378,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 */ @@ -412,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; @@ -441,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; @@ -475,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; @@ -500,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; @@ -529,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; @@ -564,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; @@ -628,7 +635,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, error_handler_t *error_handler) { int i; jtag_command_t **last_cmd = jtag_get_last_command_p(); @@ -651,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; @@ -1009,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 @@ -1027,7 +1046,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) { @@ -1037,7 +1055,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; } @@ -1049,27 +1066,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); @@ -1167,7 +1220,7 @@ int jtag_examine_chain() buf_set_u32(idcode_buffer, 0, 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++) @@ -1262,7 +1315,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; @@ -1589,17 +1642,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; } @@ -1721,7 +1776,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++) @@ -1781,7 +1836,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++) diff --git a/src/jtag/jtag.h b/src/jtag/jtag.h index 29e3da60..1464a080 100644 --- a/src/jtag/jtag.h +++ b/src/jtag/jtag.h @@ -61,6 +61,12 @@ extern enum tap_state cur_state; /* current TAP state */ #define TAP_MOVE(from, to) tap_move[tap_move_map[from]][tap_move_map[to]] +typedef struct error_handler_s +{ + int (*error_handler)(u8 *in_value, void *priv); /* handle failed checks */ + void *error_handler_priv; /* additional information for the check_handler */ +} error_handler_t; + typedef struct scan_field_s { int device; /* ordinal device number this instruction refers to */ @@ -86,6 +92,7 @@ typedef struct scan_command_s int num_fields; /* number of fields in *fields array */ scan_field_t *fields; /* pointer to an array of data scan fields */ enum tap_state end_state; /* TAP state in which JTAG commands should finish */ + error_handler_t *error_handler; } scan_command_t; typedef struct statemove_command_s @@ -239,10 +246,10 @@ extern int jtag_init(struct command_context_s *cmd_ctx); extern int jtag_register_commands(struct command_context_s *cmd_ctx); /* JTAG interface */ -extern int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); -extern int jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); -extern int jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); -extern int jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state endstate); +extern int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state endstate, error_handler_t *error_handler); +extern int jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state endstate, error_handler_t *error_handler); +extern int jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state endstate, error_handler_t *error_handler); +extern int jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state endstate, error_handler_t *error_handler); extern int jtag_add_statemove(enum tap_state endstate); extern int jtag_add_pathmove(int num_states, enum tap_state *path); extern int jtag_add_runtest(int num_cycles, enum tap_state endstate); diff --git a/src/openocd.c b/src/openocd.c index 63ce65c1..decbe131 100644 --- a/src/openocd.c +++ b/src/openocd.c @@ -18,7 +18,7 @@ * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * ***************************************************************************/ -#define OPENOCD_VERSION "Open On-Chip Debugger (2007-04-11 16:20 CEST)" +#define OPENOCD_VERSION "Open On-Chip Debugger (2007-04-25 22:15 CEST)" #ifdef HAVE_CONFIG_H #include "config.h" diff --git a/src/pld/virtex2.c b/src/pld/virtex2.c index 8624367f..ab715d92 100644 --- a/src/pld/virtex2.c +++ b/src/pld/virtex2.c @@ -62,7 +62,7 @@ int virtex2_set_instr(int chain_pos, u32 new_instr) field.in_handler = NULL; field.in_handler_priv = NULL; - jtag_add_ir_scan(1, &field, TAP_RTI); + jtag_add_ir_scan(1, &field, TAP_RTI, NULL); free(field.out_value); } @@ -94,7 +94,7 @@ int virtex2_send_32(struct pld_device_s *pld_device, int num_words, u32 *words) virtex2_set_instr(virtex2_info->chain_pos, 0x5); /* CFG_IN */ - jtag_add_dr_scan(1, &scan_field, TAP_PD); + jtag_add_dr_scan(1, &scan_field, TAP_PD, NULL); free(values); @@ -127,7 +127,7 @@ int virtex2_receive_32(struct pld_device_s *pld_device, int num_words, u32 *word while (num_words--) { scan_field.in_handler_priv = words++; - jtag_add_dr_scan(1, &scan_field, TAP_PD); + jtag_add_dr_scan(1, &scan_field, TAP_PD, NULL); } return ERROR_OK; @@ -189,7 +189,7 @@ int virtex2_load(struct pld_device_s *pld_device, char *filename) field.num_bits = bit_file.length * 8; field.out_value = bit_file.data; - jtag_add_dr_scan(1, &field, TAP_PD); + jtag_add_dr_scan(1, &field, TAP_PD, NULL); jtag_execute_queue(); jtag_add_statemove(TAP_TLR); diff --git a/src/target/arm720t.c b/src/target/arm720t.c index 7aff8a7e..1fa5ef11 100644 --- a/src/target/arm720t.c +++ b/src/target/arm720t.c @@ -97,7 +97,7 @@ int arm720t_scan_cp15(target_t *target, u32 out, u32 *in, int instruction, int c jtag_add_end_state(TAP_PD); arm_jtag_scann(jtag_info, 0xf); - arm_jtag_set_instr(jtag_info, jtag_info->intest_instr); + arm_jtag_set_instr(jtag_info, jtag_info->intest_instr, NULL); fields[0].device = jtag_info->chain_pos; fields[0].num_bits = 1; @@ -126,7 +126,7 @@ int arm720t_scan_cp15(target_t *target, u32 out, u32 *in, int instruction, int c fields[1].in_check_value = NULL; fields[1].in_check_mask = NULL; - jtag_add_dr_scan(2, fields, -1); + jtag_add_dr_scan(2, fields, -1, NULL); if (clock) jtag_add_runtest(0, -1); diff --git a/src/target/arm7_9_common.c b/src/target/arm7_9_common.c index 3a7c80a1..9cf38c3e 100644 --- a/src/target/arm7_9_common.c +++ b/src/target/arm7_9_common.c @@ -55,7 +55,6 @@ int handle_arm7_9_dbgrq_command(struct command_context_s *cmd_ctx, char *cmd, ch int handle_arm7_9_fast_memory_access_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_arm7_9_dcc_downloads_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_arm7_9_etm_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_arm7_9_etb_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int arm7_9_reinit_embeddedice(target_t *target) { @@ -545,7 +544,7 @@ int arm7_9_execute_sys_speed(struct target_s *target) /* set RESTART instruction */ jtag_add_end_state(TAP_RTI); - arm_jtag_set_instr(jtag_info, 0x4); + arm_jtag_set_instr(jtag_info, 0x4, NULL); for (timeout=0; timeout<50; timeout++) { @@ -578,7 +577,7 @@ int arm7_9_execute_fast_sys_speed(struct target_s *target) /* set RESTART instruction */ jtag_add_end_state(TAP_RTI); - arm_jtag_set_instr(jtag_info, 0x4); + arm_jtag_set_instr(jtag_info, 0x4, NULL); /* check for DBGACK and SYSCOMP set (others don't care) */ buf_set_u32(check_value, 0, 32, 0x9); @@ -1308,7 +1307,7 @@ int arm7_9_restart_core(struct target_s *target) /* set RESTART instruction */ jtag_add_end_state(TAP_RTI); - arm_jtag_set_instr(jtag_info, 0x4); + arm_jtag_set_instr(jtag_info, 0x4, NULL); jtag_add_runtest(1, TAP_RTI); if ((jtag_execute_queue()) != ERROR_OK) @@ -2098,7 +2097,6 @@ int arm7_9_register_commands(struct command_context_s *cmd_ctx) arm7_9_cmd = register_command(cmd_ctx, NULL, "arm7_9", NULL, COMMAND_ANY, "arm7/9 specific commands"); register_command(cmd_ctx, arm7_9_cmd, "etm", handle_arm7_9_etm_command, COMMAND_CONFIG, NULL); - register_command(cmd_ctx, arm7_9_cmd, "etb", handle_arm7_9_etb_command, COMMAND_CONFIG, NULL); register_command(cmd_ctx, arm7_9_cmd, "write_xpsr", handle_arm7_9_write_xpsr_command, COMMAND_EXEC, "write program status register "); register_command(cmd_ctx, arm7_9_cmd, "write_xpsr_im8", handle_arm7_9_write_xpsr_im8_command, COMMAND_EXEC, "write program status register <8bit immediate> "); @@ -2117,6 +2115,7 @@ int arm7_9_register_commands(struct command_context_s *cmd_ctx) COMMAND_ANY, "use DCC downloads for larger memory writes "); armv4_5_register_commands(cmd_ctx); + etb_register_commands(cmd_ctx, arm7_9_cmd); return ERROR_OK; } diff --git a/src/target/arm7_9_common.h b/src/target/arm7_9_common.h index 5e7d54a9..e77bedac 100644 --- a/src/target/arm7_9_common.h +++ b/src/target/arm7_9_common.h @@ -134,6 +134,7 @@ void arm7_9_disable_eice_step(target_t *target); int arm7_9_execute_sys_speed(struct target_s *target); int arm7_9_init_arch_info(target_t *target, arm7_9_common_t *arm7_9); +int arm7_9_get_arch_pointers(target_t *target, armv4_5_common_t **armv4_5_p, arm7_9_common_t **arm7_9_p); #endif /* ARM7_9_COMMON_H */ diff --git a/src/target/arm7tdmi.c b/src/target/arm7tdmi.c index 38917ded..5dc2f207 100644 --- a/src/target/arm7tdmi.c +++ b/src/target/arm7tdmi.c @@ -124,9 +124,9 @@ int arm7tdmi_examine_debug_reason(target_t *target) fields[1].in_handler_priv = NULL; arm_jtag_scann(&arm7_9->jtag_info, 0x1); - arm_jtag_set_instr(&arm7_9->jtag_info, arm7_9->jtag_info.intest_instr); + arm_jtag_set_instr(&arm7_9->jtag_info, arm7_9->jtag_info.intest_instr, NULL); - jtag_add_dr_scan(2, fields, TAP_PD); + jtag_add_dr_scan(2, fields, TAP_PD, NULL); jtag_execute_queue(); fields[0].in_value = NULL; @@ -134,7 +134,7 @@ int arm7tdmi_examine_debug_reason(target_t *target) fields[1].in_value = NULL; fields[1].out_value = databus; - jtag_add_dr_scan(2, fields, TAP_PD); + jtag_add_dr_scan(2, fields, TAP_PD, NULL); if (breakpoint & 1) target->debug_reason = DBG_REASON_WATCHPOINT; @@ -157,7 +157,7 @@ int arm7tdmi_clock_out(arm_jtag_t *jtag_info, u32 out, u32 *in, int breakpoint) jtag_add_end_state(TAP_PD); arm_jtag_scann(jtag_info, 0x1); - arm_jtag_set_instr(jtag_info, jtag_info->intest_instr); + arm_jtag_set_instr(jtag_info, jtag_info->intest_instr, NULL); fields[0].device = jtag_info->chain_pos; fields[0].num_bits = 1; @@ -187,7 +187,7 @@ int arm7tdmi_clock_out(arm_jtag_t *jtag_info, u32 out, u32 *in, int breakpoint) fields[1].in_check_value = NULL; fields[1].in_check_mask = NULL; - jtag_add_dr_scan(2, fields, -1); + jtag_add_dr_scan(2, fields, -1, NULL); jtag_add_runtest(0, -1); @@ -214,7 +214,7 @@ int arm7tdmi_clock_data_in(arm_jtag_t *jtag_info, u32 *in) jtag_add_end_state(TAP_PD); arm_jtag_scann(jtag_info, 0x1); - arm_jtag_set_instr(jtag_info, jtag_info->intest_instr); + arm_jtag_set_instr(jtag_info, jtag_info->intest_instr, NULL); fields[0].device = jtag_info->chain_pos; fields[0].num_bits = 1; @@ -236,7 +236,7 @@ int arm7tdmi_clock_data_in(arm_jtag_t *jtag_info, u32 *in) fields[1].in_check_value = NULL; fields[1].in_check_mask = NULL; - jtag_add_dr_scan(2, fields, -1); + jtag_add_dr_scan(2, fields, -1, NULL); jtag_add_runtest(0, -1); @@ -268,7 +268,7 @@ int arm7tdmi_clock_data_in_endianness(arm_jtag_t *jtag_info, void *in, int size, jtag_add_end_state(TAP_PD); arm_jtag_scann(jtag_info, 0x1); - arm_jtag_set_instr(jtag_info, jtag_info->intest_instr); + arm_jtag_set_instr(jtag_info, jtag_info->intest_instr, NULL); fields[0].device = jtag_info->chain_pos; fields[0].num_bits = 1; @@ -301,7 +301,7 @@ int arm7tdmi_clock_data_in_endianness(arm_jtag_t *jtag_info, void *in, int size, fields[1].in_check_value = NULL; fields[1].in_check_mask = NULL; - jtag_add_dr_scan(2, fields, -1); + jtag_add_dr_scan(2, fields, -1, NULL); jtag_add_runtest(0, -1); diff --git a/src/target/arm920t.c b/src/target/arm920t.c index d7fb8e11..805624ee 100644 --- a/src/target/arm920t.c +++ b/src/target/arm920t.c @@ -103,7 +103,7 @@ int arm920t_read_cp15_physical(target_t *target, int reg_addr, u32 *value) jtag_add_end_state(TAP_RTI); arm_jtag_scann(jtag_info, 0xf); - arm_jtag_set_instr(jtag_info, jtag_info->intest_instr); + arm_jtag_set_instr(jtag_info, jtag_info->intest_instr, NULL); fields[0].device = jtag_info->chain_pos; fields[0].num_bits = 1; @@ -145,12 +145,12 @@ int arm920t_read_cp15_physical(target_t *target, int reg_addr, u32 *value) fields[3].in_handler = NULL; fields[3].in_handler_priv = NULL; - jtag_add_dr_scan(4, fields, -1); + jtag_add_dr_scan(4, fields, -1, NULL); fields[1].in_handler_priv = value; fields[1].in_handler = arm_jtag_buf_to_u32; - jtag_add_dr_scan(4, fields, -1); + jtag_add_dr_scan(4, fields, -1, NULL); #ifdef _DEBUG_INSTRUCTION_EXECUTION_ jtag_execute_queue(); @@ -175,7 +175,7 @@ int arm920t_write_cp15_physical(target_t *target, int reg_addr, u32 value) jtag_add_end_state(TAP_RTI); arm_jtag_scann(jtag_info, 0xf); - arm_jtag_set_instr(jtag_info, jtag_info->intest_instr); + arm_jtag_set_instr(jtag_info, jtag_info->intest_instr, NULL); fields[0].device = jtag_info->chain_pos; fields[0].num_bits = 1; @@ -217,7 +217,7 @@ int arm920t_write_cp15_physical(target_t *target, int reg_addr, u32 value) fields[3].in_handler = NULL; fields[3].in_handler_priv = NULL; - jtag_add_dr_scan(4, fields, -1); + jtag_add_dr_scan(4, fields, -1, NULL); #ifdef _DEBUG_INSTRUCTION_EXECUTION_ DEBUG("addr: 0x%x value: %8.8x", reg_addr, value); @@ -239,7 +239,7 @@ int arm920t_execute_cp15(target_t *target, u32 cp15_opcode, u32 arm_opcode) jtag_add_end_state(TAP_RTI); arm_jtag_scann(jtag_info, 0xf); - arm_jtag_set_instr(jtag_info, jtag_info->intest_instr); + arm_jtag_set_instr(jtag_info, jtag_info->intest_instr, NULL); buf_set_u32(cp15_opcode_buf, 0, 32, cp15_opcode); @@ -283,7 +283,7 @@ int arm920t_execute_cp15(target_t *target, u32 cp15_opcode, u32 arm_opcode) fields[3].in_handler = NULL; fields[3].in_handler_priv = NULL; - jtag_add_dr_scan(4, fields, -1); + jtag_add_dr_scan(4, fields, -1, NULL); arm9tdmi_clock_out(jtag_info, arm_opcode, 0, NULL, 0); arm9tdmi_clock_out(jtag_info, ARMV4_5_NOP, 0, NULL, 1); diff --git a/src/target/arm926ejs.c b/src/target/arm926ejs.c index 3931e898..8907e113 100644 --- a/src/target/arm926ejs.c +++ b/src/target/arm926ejs.c @@ -28,7 +28,7 @@ #include #include -#if 0 +#if 1 #define _DEBUG_INSTRUCTION_EXECUTION_ #endif @@ -91,6 +91,22 @@ target_type_t arm926ejs_target = .quit = arm926ejs_quit }; +int arm926ejs_catch_broken_irscan(u8 *in_value, void *priv) +{ + /* The ARM926EJ-S' instruction register is 4 bits wide */ + *in_value &= 0xf; + + if ((*in_value == 0x0f) || (*in_value == 0x00)) + { + DEBUG("caught ARM926EJ-S invalid Capture-IR result after CP15 access"); + return ERROR_OK; + } + else + { + return ERROR_JTAG_QUEUE_FAILED; + } +} + int arm926ejs_read_cp15(target_t *target, u32 address, u32 *value) { armv4_5_common_t *armv4_5 = target->arch_info; @@ -100,12 +116,13 @@ int arm926ejs_read_cp15(target_t *target, u32 address, u32 *value) u8 address_buf[2]; u8 nr_w_buf = 0; u8 access = 1; + error_handler_t error_handler; buf_set_u32(address_buf, 0, 14, address); jtag_add_end_state(TAP_RTI); arm_jtag_scann(jtag_info, 0xf); - arm_jtag_set_instr(jtag_info, jtag_info->intest_instr); + arm_jtag_set_instr(jtag_info, jtag_info->intest_instr, NULL); fields[0].device = jtag_info->chain_pos; fields[0].num_bits = 32; @@ -147,17 +164,17 @@ int arm926ejs_read_cp15(target_t *target, u32 address, u32 *value) fields[3].in_handler = NULL; fields[3].in_handler_priv = NULL; - jtag_add_dr_scan(4, fields, -1); + jtag_add_dr_scan(4, fields, -1, NULL); - /* rescan with NOP, to wait for the access to complete */ - access = 0; - fields[0].in_handler_priv = value; fields[0].in_handler = arm_jtag_buf_to_u32; do { - jtag_add_dr_scan(4, fields, -1); + /* rescan with NOP, to wait for the access to complete */ + access = 0; + nr_w_buf = 0; + jtag_add_dr_scan(4, fields, -1, NULL); jtag_execute_queue(); } while (buf_get_u32(&access, 0, 1) != 1); @@ -165,6 +182,11 @@ int arm926ejs_read_cp15(target_t *target, u32 address, u32 *value) DEBUG("addr: 0x%x value: %8.8x", address, *value); #endif + error_handler.error_handler = arm926ejs_catch_broken_irscan; + error_handler.error_handler_priv = NULL; + + arm_jtag_set_instr(jtag_info, 0xc, &error_handler); + return ERROR_OK; } @@ -178,13 +200,14 @@ int arm926ejs_write_cp15(target_t *target, u32 address, u32 value) u8 address_buf[2]; u8 nr_w_buf = 1; u8 access = 1; + error_handler_t error_handler; buf_set_u32(address_buf, 0, 14, address); buf_set_u32(value_buf, 0, 32, value); jtag_add_end_state(TAP_RTI); arm_jtag_scann(jtag_info, 0xf); - arm_jtag_set_instr(jtag_info, jtag_info->intest_instr); + arm_jtag_set_instr(jtag_info, jtag_info->intest_instr, NULL); fields[0].device = jtag_info->chain_pos; fields[0].num_bits = 32; @@ -226,14 +249,14 @@ int arm926ejs_write_cp15(target_t *target, u32 address, u32 value) fields[3].in_handler = NULL; fields[3].in_handler_priv = NULL; - jtag_add_dr_scan(4, fields, -1); + jtag_add_dr_scan(4, fields, -1, NULL); - /* rescan with NOP, to wait for the access to complete */ - access = 0; - do { - jtag_add_dr_scan(4, fields, -1); + /* rescan with NOP, to wait for the access to complete */ + access = 0; + nr_w_buf = 0; + jtag_add_dr_scan(4, fields, -1, NULL); jtag_execute_queue(); } while (buf_get_u32(&access, 0, 1) != 1); @@ -241,6 +264,11 @@ int arm926ejs_write_cp15(target_t *target, u32 address, u32 value) DEBUG("addr: 0x%x value: %8.8x", address, value); #endif + error_handler.error_handler = arm926ejs_catch_broken_irscan; + error_handler.error_handler_priv = NULL; + + arm_jtag_set_instr(jtag_info, 0xf, &error_handler); + return ERROR_OK; } @@ -395,7 +423,7 @@ void arm926ejs_post_debug_entry(target_t *target) arm7_9_common_t *arm7_9 = armv4_5->arch_info; arm9tdmi_common_t *arm9tdmi = arm7_9->arch_info; arm926ejs_common_t *arm926ejs = arm9tdmi->arch_info; - + /* examine cp15 control reg */ arm926ejs_read_cp15(target, ARM926EJS_CP15_ADDR(0, 0, 1, 0), &arm926ejs->cp15_control_reg); jtag_execute_queue(); @@ -430,7 +458,6 @@ void arm926ejs_post_debug_entry(target_t *target) arm926ejs_read_cp15(target, ARM926EJS_CP15_ADDR(7, 0, 15, 0), &cache_dbg_ctrl); cache_dbg_ctrl |= 0x7; arm926ejs_write_cp15(target, ARM926EJS_CP15_ADDR(7, 0, 15, 0), cache_dbg_ctrl); - } void arm926ejs_pre_restore_context(target_t *target) @@ -439,7 +466,7 @@ void arm926ejs_pre_restore_context(target_t *target) arm7_9_common_t *arm7_9 = armv4_5->arch_info; arm9tdmi_common_t *arm9tdmi = arm7_9->arch_info; arm926ejs_common_t *arm926ejs = arm9tdmi->arch_info; - + /* restore i/d fault status and address register */ arm926ejs_write_cp15(target, ARM926EJS_CP15_ADDR(0, 0, 5, 0), arm926ejs->d_fsr); arm926ejs_write_cp15(target, ARM926EJS_CP15_ADDR(0, 1, 5, 0), arm926ejs->i_fsr); @@ -641,6 +668,11 @@ int arm926ejs_init_arch_info(target_t *target, arm926ejs_common_t *arm926ejs, in arm7_9->examine_debug_reason = arm926ejs_examine_debug_reason; + /* The ARM926EJ-S implements the ARMv5TE architecture which + * has the BKPT instruction, so we don't have to use a watchpoint comparator + */ + arm7_9->sw_bkpts_enabled = 1; + return ERROR_OK; } diff --git a/src/target/arm966e.c b/src/target/arm966e.c index 8b3414ca..917fc4a4 100644 --- a/src/target/arm966e.c +++ b/src/target/arm966e.c @@ -253,7 +253,7 @@ int arm966e_read_cp15(target_t *target, int reg_addr, u32 *value) jtag_add_end_state(TAP_RTI); arm_jtag_scann(jtag_info, 0xf); - arm_jtag_set_instr(jtag_info, jtag_info->intest_instr); + arm_jtag_set_instr(jtag_info, jtag_info->intest_instr, NULL); fields[0].device = jtag_info->chain_pos; fields[0].num_bits = 32; @@ -285,11 +285,11 @@ int arm966e_read_cp15(target_t *target, int reg_addr, u32 *value) fields[2].in_handler = NULL; fields[2].in_handler_priv = NULL; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); fields[0].in_value = (u8*)value; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); return ERROR_OK; } @@ -305,7 +305,7 @@ int arm966e_write_cp15(target_t *target, int reg_addr, u32 value) jtag_add_end_state(TAP_RTI); arm_jtag_scann(jtag_info, 0xf); - arm_jtag_set_instr(jtag_info, jtag_info->intest_instr); + arm_jtag_set_instr(jtag_info, jtag_info->intest_instr, NULL); fields[0].device = jtag_info->chain_pos; fields[0].num_bits = 32; @@ -337,7 +337,7 @@ int arm966e_write_cp15(target_t *target, int reg_addr, u32 value) fields[2].in_handler = NULL; fields[2].in_handler_priv = NULL; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); return ERROR_OK; } diff --git a/src/target/arm9tdmi.c b/src/target/arm9tdmi.c index d21dff73..1a53d0d0 100644 --- a/src/target/arm9tdmi.c +++ b/src/target/arm9tdmi.c @@ -98,6 +98,15 @@ arm9tdmi_vector_t arm9tdmi_vectors[] = {0, 0}, }; +int arm9tdmi_jtag_error_handler(u8 *in_value, void *priv) +{ + char *caller = priv; + + DEBUG("caller: %s", caller); + + return ERROR_OK; +} + int arm9tdmi_examine_debug_reason(target_t *target) { /* get pointers to arch-specific information */ @@ -108,6 +117,7 @@ int arm9tdmi_examine_debug_reason(target_t *target) if ((target->debug_reason != DBG_REASON_DBGRQ) && (target->debug_reason != DBG_REASON_SINGLESTEP)) { + error_handler_t error_handler; scan_field_t fields[3]; u8 databus[4]; u8 instructionbus[4]; @@ -146,9 +156,11 @@ int arm9tdmi_examine_debug_reason(target_t *target) fields[2].in_handler_priv = NULL; arm_jtag_scann(&arm7_9->jtag_info, 0x1); - arm_jtag_set_instr(&arm7_9->jtag_info, arm7_9->jtag_info.intest_instr); + error_handler.error_handler = arm9tdmi_jtag_error_handler; + error_handler.error_handler_priv = "arm9tdmi_examine_debug_reason"; + arm_jtag_set_instr(&arm7_9->jtag_info, arm7_9->jtag_info.intest_instr, &error_handler); - jtag_add_dr_scan(3, fields, TAP_PD); + jtag_add_dr_scan(3, fields, TAP_PD, NULL); jtag_execute_queue(); fields[0].in_value = NULL; @@ -158,7 +170,7 @@ int arm9tdmi_examine_debug_reason(target_t *target) fields[2].in_value = NULL; fields[2].out_value = instructionbus; - jtag_add_dr_scan(3, fields, TAP_PD); + jtag_add_dr_scan(3, fields, TAP_PD, NULL); if (debug_reason & 0x4) if (debug_reason & 0x2) @@ -175,6 +187,7 @@ int arm9tdmi_examine_debug_reason(target_t *target) /* put an instruction in the ARM9TDMI pipeline or write the data bus, and optionally read data */ int arm9tdmi_clock_out(arm_jtag_t *jtag_info, u32 instr, u32 out, u32 *in, int sysspeed) { + error_handler_t error_handler; scan_field_t fields[3]; u8 out_buf[4]; u8 instr_buf[4]; @@ -190,7 +203,11 @@ int arm9tdmi_clock_out(arm_jtag_t *jtag_info, u32 instr, u32 out, u32 *in, int s jtag_add_end_state(TAP_PD); arm_jtag_scann(jtag_info, 0x1); - arm_jtag_set_instr(jtag_info, jtag_info->intest_instr); + + error_handler.error_handler = arm9tdmi_jtag_error_handler; + error_handler.error_handler_priv = "arm9tdmi_clock_out"; + + arm_jtag_set_instr(jtag_info, jtag_info->intest_instr, &error_handler); fields[0].device = jtag_info->chain_pos; fields[0].num_bits = 32; @@ -230,7 +247,7 @@ int arm9tdmi_clock_out(arm_jtag_t *jtag_info, u32 instr, u32 out, u32 *in, int s fields[2].in_handler = NULL; fields[2].in_handler_priv = NULL; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); jtag_add_runtest(0, -1); @@ -254,10 +271,15 @@ int arm9tdmi_clock_out(arm_jtag_t *jtag_info, u32 instr, u32 out, u32 *in, int s int arm9tdmi_clock_data_in(arm_jtag_t *jtag_info, u32 *in) { scan_field_t fields[3]; + error_handler_t error_handler; jtag_add_end_state(TAP_PD); arm_jtag_scann(jtag_info, 0x1); - arm_jtag_set_instr(jtag_info, jtag_info->intest_instr); + + error_handler.error_handler = arm9tdmi_jtag_error_handler; + error_handler.error_handler_priv = "arm9tdmi_clock_data_in_endianness"; + + arm_jtag_set_instr(jtag_info, jtag_info->intest_instr, &error_handler); fields[0].device = jtag_info->chain_pos; fields[0].num_bits = 32; @@ -289,7 +311,7 @@ int arm9tdmi_clock_data_in(arm_jtag_t *jtag_info, u32 *in) fields[2].in_handler = NULL; fields[2].in_handler_priv = NULL; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); jtag_add_runtest(0, -1); @@ -318,10 +340,15 @@ int arm9tdmi_clock_data_in(arm_jtag_t *jtag_info, u32 *in) int arm9tdmi_clock_data_in_endianness(arm_jtag_t *jtag_info, void *in, int size, int be) { scan_field_t fields[3]; - + error_handler_t error_handler; + jtag_add_end_state(TAP_PD); arm_jtag_scann(jtag_info, 0x1); - arm_jtag_set_instr(jtag_info, jtag_info->intest_instr); + + error_handler.error_handler = arm9tdmi_jtag_error_handler; + error_handler.error_handler_priv = "arm9tdmi_clock_data_in_endianness"; + + arm_jtag_set_instr(jtag_info, jtag_info->intest_instr, &error_handler); fields[0].device = jtag_info->chain_pos; fields[0].num_bits = 32; @@ -364,7 +391,7 @@ int arm9tdmi_clock_data_in_endianness(arm_jtag_t *jtag_info, void *in, int size, fields[2].in_handler = NULL; fields[2].in_handler_priv = NULL; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); jtag_add_runtest(0, -1); diff --git a/src/target/arm_jtag.c b/src/target/arm_jtag.c index 3bb8a32f..305590c8 100644 --- a/src/target/arm_jtag.c +++ b/src/target/arm_jtag.c @@ -29,7 +29,18 @@ #include -int arm_jtag_set_instr(arm_jtag_t *jtag_info, u32 new_instr) +#if 0 +#define _ARM_JTAG_SCAN_N_CHECK_ +#endif + +int arm_jtag_set_instr_error_handler(u8 *in_value, void *priv) +{ + ERROR("setting the new JTAG instruction failed, debugging is likely to be broken"); + + return ERROR_OK; +} + +int arm_jtag_set_instr(arm_jtag_t *jtag_info, u32 new_instr, error_handler_t *caller_error_handler) { jtag_device_t *device = jtag_get_device(jtag_info->chain_pos); @@ -48,7 +59,18 @@ int arm_jtag_set_instr(arm_jtag_t *jtag_info, u32 new_instr) field.in_handler = NULL; field.in_handler_priv = NULL; - jtag_add_ir_scan(1, &field, -1); + if (caller_error_handler) + { + jtag_add_ir_scan(1, &field, -1, caller_error_handler); + } + else + { + error_handler_t error_handler; + error_handler.error_handler = arm_jtag_set_instr_error_handler; + error_handler.error_handler_priv = NULL; + jtag_add_ir_scan(1, &field, -1, &error_handler); + } + free(field.out_value); } @@ -60,6 +82,9 @@ int arm_jtag_scann(arm_jtag_t *jtag_info, u32 new_scan_chain) { if(jtag_info->cur_scan_chain != new_scan_chain) { +#ifdef _ARM_JTAG_SCAN_N_CHECK_ + u8 scan_n_check_value = 0x10; +#endif scan_field_t field; field.device = jtag_info->chain_pos; @@ -67,15 +92,18 @@ int arm_jtag_scann(arm_jtag_t *jtag_info, u32 new_scan_chain) field.out_value = calloc(CEIL(field.num_bits, 8), 1); buf_set_u32(field.out_value, 0, field.num_bits, new_scan_chain); field.out_mask = NULL; - //field.in_value = &scan_n_capture; field.in_value = NULL; +#ifdef _ARM_JTAG_SCAN_N_CHECK_ + field.in_check_value = &scan_n_check_value; +#else field.in_check_value = NULL; +#endif field.in_check_mask = NULL; field.in_handler = NULL; field.in_handler_priv = NULL; - arm_jtag_set_instr(jtag_info, jtag_info->scann_instr); - jtag_add_dr_scan(1, &field, -1); + arm_jtag_set_instr(jtag_info, jtag_info->scann_instr, NULL); + jtag_add_dr_scan(1, &field, -1, NULL); jtag_info->cur_scan_chain = new_scan_chain; diff --git a/src/target/arm_jtag.h b/src/target/arm_jtag.h index 6e523fba..f2f55878 100644 --- a/src/target/arm_jtag.h +++ b/src/target/arm_jtag.h @@ -21,6 +21,7 @@ #define ARM_JTAG #include "types.h" +#include "jtag.h" typedef struct arm_jtag_s { @@ -33,7 +34,7 @@ typedef struct arm_jtag_s u32 intest_instr; } arm_jtag_t; -extern int arm_jtag_set_instr(arm_jtag_t *jtag_info, u32 new_instr); +extern int arm_jtag_set_instr(arm_jtag_t *jtag_info, u32 new_instr, error_handler_t *error_handler); extern int arm_jtag_scann(arm_jtag_t *jtag_info, u32 new_scan_chain); extern int arm_jtag_setup_connection(arm_jtag_t *jtag_info); diff --git a/src/target/embeddedice.c b/src/target/embeddedice.c index 76f87410..ef38e136 100644 --- a/src/target/embeddedice.c +++ b/src/target/embeddedice.c @@ -86,6 +86,15 @@ int embeddedice_set_reg_w_exec(reg_t *reg, u8 *buf); int embeddedice_write_reg(reg_t *reg, u32 value); int embeddedice_read_reg(reg_t *reg); +int embeddedice_jtag_error_handler(u8 *in_value, void *priv) +{ + char *caller = priv; + + DEBUG("caller: %s", caller); + + return ERROR_OK; +} + reg_cache_t* embeddedice_build_reg_cache(target_t *target, arm7_9_common_t *arm7_9) { reg_cache_t *reg_cache = malloc(sizeof(reg_cache_t)); @@ -214,12 +223,17 @@ int embeddedice_read_reg_w_check(reg_t *reg, u8* check_value, u8* check_mask) embeddedice_reg_t *ice_reg = reg->arch_info; u8 reg_addr = ice_reg->addr & 0x1f; scan_field_t fields[3]; + error_handler_t error_handler; DEBUG("%i", ice_reg->addr); jtag_add_end_state(TAP_RTI); arm_jtag_scann(ice_reg->jtag_info, 0x2); - arm_jtag_set_instr(ice_reg->jtag_info, ice_reg->jtag_info->intest_instr); + + error_handler.error_handler = embeddedice_jtag_error_handler; + error_handler.error_handler_priv = "embeddedice_read_reg_w_check"; + + arm_jtag_set_instr(ice_reg->jtag_info, ice_reg->jtag_info->intest_instr, &error_handler); fields[0].device = ice_reg->jtag_info->chain_pos; fields[0].num_bits = 32; @@ -253,7 +267,7 @@ int embeddedice_read_reg_w_check(reg_t *reg, u8* check_value, u8* check_mask) fields[2].in_handler = NULL; fields[2].in_handler_priv = NULL; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); fields[0].in_value = reg->value; fields[0].in_check_value = check_value; @@ -265,7 +279,7 @@ int embeddedice_read_reg_w_check(reg_t *reg, u8* check_value, u8* check_mask) */ buf_set_u32(fields[1].out_value, 0, 5, embeddedice_reg_arch_info[EICE_COMMS_CTRL]); - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); free(fields[1].out_value); free(fields[2].out_value); @@ -310,12 +324,17 @@ int embeddedice_write_reg(reg_t *reg, u32 value) embeddedice_reg_t *ice_reg = reg->arch_info; u8 reg_addr = ice_reg->addr & 0x1f; scan_field_t fields[3]; + error_handler_t error_handler; DEBUG("%i: 0x%8.8x", ice_reg->addr, value); jtag_add_end_state(TAP_RTI); arm_jtag_scann(ice_reg->jtag_info, 0x2); - arm_jtag_set_instr(ice_reg->jtag_info, ice_reg->jtag_info->intest_instr); + + error_handler.error_handler = embeddedice_jtag_error_handler; + error_handler.error_handler_priv = "embeddedice_write_reg"; + + arm_jtag_set_instr(ice_reg->jtag_info, ice_reg->jtag_info->intest_instr, NULL); fields[0].device = ice_reg->jtag_info->chain_pos; fields[0].num_bits = 32; @@ -350,7 +369,7 @@ int embeddedice_write_reg(reg_t *reg, u32 value) fields[2].in_handler = NULL; fields[2].in_handler_priv = NULL; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); free(fields[0].out_value); free(fields[1].out_value); diff --git a/src/target/etb.c b/src/target/etb.c index 3ac1adf4..0b480e39 100644 --- a/src/target/etb.c +++ b/src/target/etb.c @@ -21,6 +21,7 @@ #include "config.h" #endif +#include "arm7_9_common.h" #include "etb.h" #include "log.h" @@ -54,6 +55,9 @@ int etb_set_reg_w_exec(reg_t *reg, u8 *buf); int etb_write_reg(reg_t *reg, u32 value); int etb_read_reg(reg_t *reg); +int handle_arm7_9_etb_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +int handle_arm7_9_etb_dump_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); + int etb_set_instr(etb_t *etb, u32 new_instr) { jtag_device_t *device = jtag_get_device(etb->chain_pos); @@ -72,8 +76,8 @@ int etb_set_instr(etb_t *etb, u32 new_instr) field.in_check_mask = NULL; field.in_handler = NULL; field.in_handler_priv = NULL; - - jtag_add_ir_scan(1, &field, -1); + + jtag_add_ir_scan(1, &field, -1, NULL); free(field.out_value); } @@ -100,7 +104,7 @@ int etb_scann(etb_t *etb, u32 new_scan_chain) /* select INTEST instruction */ etb_set_instr(etb, 0x2); - jtag_add_dr_scan(1, &field, -1); + jtag_add_dr_scan(1, &field, -1, NULL); etb->cur_scan_chain = new_scan_chain; @@ -212,13 +216,17 @@ int etb_read_reg_w_check(reg_t *reg, u8* check_value, u8* check_mask) fields[2].in_handler = NULL; fields[2].in_handler_priv = NULL; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); + /* read the identification register in the second run, to make sure we + * don't read the ETB data register twice, skipping every second entry + */ + buf_set_u32(fields[1].out_value, 0, 7, 0x0); fields[0].in_value = reg->value; fields[0].in_check_value = check_value; fields[0].in_check_mask = check_mask; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); free(fields[1].out_value); free(fields[2].out_value); @@ -303,7 +311,7 @@ int etb_write_reg(reg_t *reg, u32 value) fields[2].in_handler = NULL; fields[2].in_handler_priv = NULL; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); free(fields[0].out_value); free(fields[1].out_value); @@ -317,3 +325,57 @@ int etb_store_reg(reg_t *reg) return etb_write_reg(reg, buf_get_u32(reg->value, 0, reg->size)); } +int etb_register_commands(struct command_context_s *cmd_ctx, command_t *arm7_9_cmd) +{ + register_command(cmd_ctx, arm7_9_cmd, "etb", handle_arm7_9_etb_command, COMMAND_CONFIG, NULL); + + register_command(cmd_ctx, arm7_9_cmd, "etb_dump", handle_arm7_9_etb_dump_command, COMMAND_EXEC, "dump current ETB content"); + + return ERROR_OK; +} + +int handle_arm7_9_etb_dump_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +{ + int retval; + target_t *target = get_current_target(cmd_ctx); + armv4_5_common_t *armv4_5; + arm7_9_common_t *arm7_9; + int i; + + if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK) + { + command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target"); + return ERROR_OK; + } + + if (!arm7_9->etb) + { + command_print(cmd_ctx, "no ETB configured for current target"); + return ERROR_OK; + } + + if (!(arm7_9->etb->RAM_depth && arm7_9->etb->RAM_width)) + { + /* identify ETB RAM depth and width */ + etb_read_reg(&arm7_9->etb->reg_cache->reg_list[ETB_RAM_DEPTH]); + etb_read_reg(&arm7_9->etb->reg_cache->reg_list[ETB_RAM_WIDTH]); + jtag_execute_queue(); + + arm7_9->etb->RAM_depth = buf_get_u32(arm7_9->etb->reg_cache->reg_list[ETB_RAM_DEPTH].value, 0, 32); + arm7_9->etb->RAM_width = buf_get_u32(arm7_9->etb->reg_cache->reg_list[ETB_RAM_WIDTH].value, 0, 32); + } + + /* always start reading from the beginning of the buffer */ + etb_write_reg(&arm7_9->etb->reg_cache->reg_list[ETB_RAM_READ_POINTER], 0x0); + for (i = 0; i < arm7_9->etb->RAM_depth; i++) + { + u32 trace_data; + etb_read_reg(&arm7_9->etb->reg_cache->reg_list[ETB_RAM_DATA]); + jtag_execute_queue(); + trace_data = buf_get_u32(arm7_9->etb->reg_cache->reg_list[ETB_RAM_DATA].value, 0, 32); + command_print(cmd_ctx, "%8.8i: %i %2.2x %2.2x %2.2x (0x%8.8x)", + i, (trace_data >> 19) & 1, (trace_data >> 11) & 0xff, (trace_data >> 3) & 0xff, trace_data & 0x7, trace_data); + } + + return ERROR_OK; +} diff --git a/src/target/etb.h b/src/target/etb.h index 55b7857b..12e613ff 100644 --- a/src/target/etb.h +++ b/src/target/etb.h @@ -20,6 +20,7 @@ #ifndef ETB_H #define ETB_H +#include "command.h" #include "target.h" #include "register.h" #include "arm_jtag.h" @@ -43,6 +44,10 @@ typedef struct etb_s int chain_pos; int cur_scan_chain; reg_cache_t *reg_cache; + + /* ETB parameters */ + int RAM_depth; + int RAM_width; } etb_t; typedef struct etb_reg_s @@ -59,4 +64,6 @@ extern int etb_store_reg(reg_t *reg); extern int etb_set_reg(reg_t *reg, u32 value); extern int etb_set_reg_w_exec(reg_t *reg, u8 *buf); +extern int etb_register_commands(struct command_context_s *cmd_ctx, command_t *arm7_9_cmd); + #endif /* ETB_H */ diff --git a/src/target/etm.c b/src/target/etm.c index 9c82acc9..016130d5 100644 --- a/src/target/etm.c +++ b/src/target/etm.c @@ -64,8 +64,8 @@ int etm_reg_arch_info[] = int etm_reg_arch_size_info[] = { - 32, 32, 17, 8, 3, 9, 32, 17, - 26, 16, 25, 8, 17, 32, 32, 17, + 32, 32, 17, 8, 3, 9, 32, 16, + 17, 26, 25, 8, 17, 32, 32, 17, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 32, 7, 7, 7, 7, 7, 7, 7, 7, @@ -271,7 +271,7 @@ int etm_read_reg_w_check(reg_t *reg, u8* check_value, u8* check_mask) jtag_add_end_state(TAP_RTI); arm_jtag_scann(etm_reg->jtag_info, 0x6); - arm_jtag_set_instr(etm_reg->jtag_info, etm_reg->jtag_info->intest_instr); + arm_jtag_set_instr(etm_reg->jtag_info, etm_reg->jtag_info->intest_instr, NULL); fields[0].device = etm_reg->jtag_info->chain_pos; fields[0].num_bits = 32; @@ -305,13 +305,13 @@ int etm_read_reg_w_check(reg_t *reg, u8* check_value, u8* check_mask) fields[2].in_handler = NULL; fields[2].in_handler_priv = NULL; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); fields[0].in_value = reg->value; fields[0].in_check_value = check_value; fields[0].in_check_mask = check_mask; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); free(fields[1].out_value); free(fields[2].out_value); @@ -361,7 +361,7 @@ int etm_write_reg(reg_t *reg, u32 value) jtag_add_end_state(TAP_RTI); arm_jtag_scann(etm_reg->jtag_info, 0x6); - arm_jtag_set_instr(etm_reg->jtag_info, etm_reg->jtag_info->intest_instr); + arm_jtag_set_instr(etm_reg->jtag_info, etm_reg->jtag_info->intest_instr, NULL); fields[0].device = etm_reg->jtag_info->chain_pos; fields[0].num_bits = 32; @@ -396,7 +396,7 @@ int etm_write_reg(reg_t *reg, u32 value) fields[2].in_handler = NULL; fields[2].in_handler_priv = NULL; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); free(fields[0].out_value); free(fields[1].out_value); diff --git a/src/target/xscale.c b/src/target/xscale.c index 9bb3ca75..334924f3 100644 --- a/src/target/xscale.c +++ b/src/target/xscale.c @@ -210,7 +210,7 @@ int xscale_jtag_set_instr(int chain_pos, u32 new_instr) field.in_handler = NULL; field.in_handler_priv = NULL; - jtag_add_ir_scan(1, &field, -1); + jtag_add_ir_scan(1, &field, -1, NULL); free(field.out_value); } @@ -288,7 +288,7 @@ int xscale_read_dcsr(target_t *target) fields[2].in_handler = NULL; fields[2].in_handler_priv = NULL; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); if ((retval = jtag_execute_queue()) != ERROR_OK) { @@ -308,7 +308,7 @@ int xscale_read_dcsr(target_t *target) jtag_add_end_state(TAP_RTI); - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); return ERROR_OK; } @@ -383,7 +383,7 @@ int xscale_receive(target_t *target, u32 *buffer, int num_words) fields[1].in_handler_priv = (u8*)&field1[i]; jtag_add_pathmove(3, path); - jtag_add_dr_scan(3, fields, TAP_RTI); + jtag_add_dr_scan(3, fields, TAP_RTI, NULL); words_scheduled++; } @@ -487,7 +487,7 @@ int xscale_read_tx(target_t *target, int consume) else jtag_add_statemove(TAP_PD); - jtag_add_dr_scan(3, fields, TAP_RTI); + jtag_add_dr_scan(3, fields, TAP_RTI, NULL); if ((retval = jtag_execute_queue()) != ERROR_OK) { @@ -567,7 +567,7 @@ int xscale_write_rx(target_t *target) do { DEBUG("polling RX"); - jtag_add_dr_scan(3, fields, TAP_RTI); + jtag_add_dr_scan(3, fields, TAP_RTI, NULL); if ((retval = jtag_execute_queue()) != ERROR_OK) { @@ -585,7 +585,7 @@ int xscale_write_rx(target_t *target) /* set rx_valid */ field2 = 0x1; - jtag_add_dr_scan(3, fields, TAP_RTI); + jtag_add_dr_scan(3, fields, TAP_RTI, NULL); if ((retval = jtag_execute_queue()) != ERROR_OK) { @@ -671,7 +671,7 @@ int xscale_send(target_t *target, u8 *buffer, int count, int size) exit(-1); } - jtag_add_dr_scan(3, fields, TAP_RTI); + jtag_add_dr_scan(3, fields, TAP_RTI, NULL); buffer += size; } @@ -750,7 +750,7 @@ int xscale_write_dcsr(target_t *target, int hold_rst, int ext_dbg_brk) fields[2].in_handler = NULL; fields[2].in_handler_priv = NULL; - jtag_add_dr_scan(3, fields, -1); + jtag_add_dr_scan(3, fields, -1, NULL); if ((retval = jtag_execute_queue()) != ERROR_OK) { @@ -822,7 +822,7 @@ int xscale_load_ic(target_t *target, int mini, u32 va, u32 buffer[8]) fields[1].in_handler = NULL; fields[1].in_handler_priv = NULL; - jtag_add_dr_scan(2, fields, -1); + jtag_add_dr_scan(2, fields, -1, NULL); fields[0].num_bits = 32; fields[0].out_value = packet; @@ -834,7 +834,7 @@ int xscale_load_ic(target_t *target, int mini, u32 va, u32 buffer[8]) { buf_set_u32(packet, 0, 32, buffer[word]); cmd = parity(*((u32*)packet)); - jtag_add_dr_scan(2, fields, -1); + jtag_add_dr_scan(2, fields, -1, NULL); } jtag_execute_queue(); @@ -880,7 +880,7 @@ int xscale_invalidate_ic_line(target_t *target, u32 va) fields[1].in_handler = NULL; fields[1].in_handler_priv = NULL; - jtag_add_dr_scan(2, fields, -1); + jtag_add_dr_scan(2, fields, -1, NULL); return ERROR_OK; } diff --git a/src/xsvf/xsvf.c b/src/xsvf/xsvf.c index 3a15e2b7..fd9e364e 100644 --- a/src/xsvf/xsvf.c +++ b/src/xsvf/xsvf.c @@ -188,9 +188,9 @@ int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, char **arg field.in_handler = NULL; field.in_handler_priv = NULL; if (device == -1) - jtag_add_plain_ir_scan(1, &field, TAP_PI); + jtag_add_plain_ir_scan(1, &field, TAP_PI, NULL); else - jtag_add_ir_scan(1, &field, TAP_PI); + jtag_add_ir_scan(1, &field, TAP_PI, NULL); if (jtag_execute_queue() != ERROR_OK) { tdo_mismatch = 1; @@ -231,9 +231,9 @@ int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, char **arg field.in_handler = NULL; field.in_handler_priv = NULL; if (device == -1) - jtag_add_plain_dr_scan(1, &field, TAP_PD); + jtag_add_plain_dr_scan(1, &field, TAP_PD, NULL); else - jtag_add_dr_scan(1, &field, TAP_PD); + jtag_add_dr_scan(1, &field, TAP_PD, NULL); if (jtag_execute_queue() != ERROR_OK) { tdo_mismatch = 1; @@ -308,9 +308,9 @@ int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, char **arg field.in_handler = NULL; field.in_handler_priv = NULL; if (device == -1) - jtag_add_plain_dr_scan(1, &field, TAP_PD); + jtag_add_plain_dr_scan(1, &field, TAP_PD, NULL); else - jtag_add_dr_scan(1, &field, TAP_PD); + jtag_add_dr_scan(1, &field, TAP_PD, NULL); if (jtag_execute_queue() != ERROR_OK) { tdo_mismatch = 1; @@ -434,9 +434,9 @@ int handle_xsvf_command(struct command_context_s *cmd_ctx, char *cmd, char **arg field.in_handler = NULL; field.in_handler_priv = NULL; if (device == -1) - jtag_add_plain_ir_scan(1, &field, xsvf_to_tap[xendir]); + jtag_add_plain_ir_scan(1, &field, xsvf_to_tap[xendir], NULL); else - jtag_add_ir_scan(1, &field, xsvf_to_tap[xendir]); + jtag_add_ir_scan(1, &field, xsvf_to_tap[xendir], NULL); } free(ir_buf); } -- cgit v1.2.3