X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fjtag.c;h=985cf8c2df6337040f1930da5749dd9544284cb4;hp=c4015118ca96f2543d578b790a56993518eee24e;hb=7cdb05b7d6fce73c96e5e7cff3838d6e9c2a07f4;hpb=e482118106c63edd3c9f6647e4232e90b4c16066 diff --git a/src/jtag/jtag.c b/src/jtag/jtag.c index c4015118ca..985cf8c2df 100644 --- a/src/jtag/jtag.c +++ b/src/jtag/jtag.c @@ -33,6 +33,18 @@ #include "string.h" #include +#ifndef MINIDRIVER +/* this allows JTAG devices to implement the entire jtag_xxx() layer in hw/sw */ +#define MINIDRIVER(a) a +#endif + + +/* note that this is not marked as static as it must be available from outside jtag.c for those + that implement the jtag_xxx() minidriver layer +*/ +int jtag_error=ERROR_OK; + + char* tap_state_strings[16] = { "tlr", @@ -204,8 +216,8 @@ 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 */ @@ -379,19 +391,40 @@ void cmd_queue_free() cmd_queue_pages = NULL; } -int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state, void *dummy_anachronism) +int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) { - jtag_command_t **last_cmd; - jtag_device_t *device; - int i, j; - int scan_size = 0; - if (jtag_trst == 1) { WARNING("JTAG command queued, while TRST is low (TAP in reset)"); + jtag_error=ERROR_JTAG_TRST_ASSERTED; return ERROR_JTAG_TRST_ASSERTED; } + if (state != -1) + cmd_queue_end_state = state; + + if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR) + jtag_call_event_callbacks(JTAG_TRST_RELEASED); + + if (cmd_queue_end_state == TAP_TLR) + jtag_call_event_callbacks(JTAG_TRST_ASSERTED); + + cmd_queue_cur_state = cmd_queue_end_state; + + int retval=interface_jtag_add_ir_scan(num_fields, fields, state); + if (retval!=ERROR_OK) + jtag_error=retval; + return retval; +} + +int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state) +{ + jtag_command_t **last_cmd; + jtag_device_t *device; + int i, j; + int scan_size = 0; + + last_cmd = jtag_get_last_command_p(); /* allocate memory for a new list member */ @@ -406,18 +439,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; - if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR) - jtag_call_event_callbacks(JTAG_TRST_RELEASED); - - if (cmd_queue_end_state == TAP_TLR) - jtag_call_event_callbacks(JTAG_TRST_ASSERTED); - - cmd_queue_cur_state = cmd_queue_end_state; - for (i = 0; i < jtag_num_devices; i++) { int found = 0; @@ -472,17 +494,33 @@ 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, void *dummy_anachronism) +int jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) { - jtag_command_t **last_cmd; - int i; - if (jtag_trst == 1) { WARNING("JTAG command queued, while TRST is low (TAP in reset)"); - return ERROR_JTAG_TRST_ASSERTED; + return jtag_error=ERROR_JTAG_TRST_ASSERTED; } + if (state != -1) + cmd_queue_end_state = state; + + if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR) + jtag_call_event_callbacks(JTAG_TRST_RELEASED); + + if (cmd_queue_end_state == TAP_TLR) + jtag_call_event_callbacks(JTAG_TRST_ASSERTED); + + cmd_queue_cur_state = cmd_queue_end_state; + + return interface_jtag_add_plain_ir_scan(num_fields, fields, state); +} + +int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state) +{ + int i; + jtag_command_t **last_cmd; + last_cmd = jtag_get_last_command_p(); /* allocate memory for a new list member */ @@ -498,17 +536,6 @@ int jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state (*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; - - if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR) - jtag_call_event_callbacks(JTAG_TRST_RELEASED); - - if (cmd_queue_end_state == TAP_TLR) - jtag_call_event_callbacks(JTAG_TRST_ASSERTED); - - cmd_queue_cur_state = cmd_queue_end_state; - for (i = 0; i < num_fields; i++) { int num_bits = fields[i].num_bits; @@ -526,20 +553,37 @@ 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, void *dummy_anachronism) +int jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) +{ + if (jtag_trst == 1) + { + WARNING("JTAG command queued, while TRST is low (TAP in reset)"); + return jtag_error=ERROR_JTAG_TRST_ASSERTED; + } + + if (state != -1) + cmd_queue_end_state = state; + + if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR) + jtag_call_event_callbacks(JTAG_TRST_RELEASED); + + if (cmd_queue_end_state == TAP_TLR) + jtag_call_event_callbacks(JTAG_TRST_ASSERTED); + + cmd_queue_cur_state = cmd_queue_end_state; + + return interface_jtag_add_dr_scan(num_fields, fields, state); +} + +int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state) { int i, j; int bypass_devices = 0; int field_count = 0; - jtag_command_t **last_cmd = jtag_get_last_command_p(); - jtag_device_t *device = jtag_devices; int scan_size; - if (jtag_trst == 1) - { - WARNING("JTAG command queued, while TRST is low (TAP in reset)"); - return ERROR_JTAG_TRST_ASSERTED; - } + jtag_command_t **last_cmd = jtag_get_last_command_p(); + jtag_device_t *device = jtag_devices; /* count devices in bypass */ while (device) @@ -562,17 +606,6 @@ int jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state, (*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; - - if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR) - jtag_call_event_callbacks(JTAG_TRST_RELEASED); - - if (cmd_queue_end_state == TAP_TLR) - jtag_call_event_callbacks(JTAG_TRST_ASSERTED); - - cmd_queue_cur_state = cmd_queue_end_state; - for (i = 0; i < jtag_num_devices; i++) { int found = 0; @@ -625,17 +658,34 @@ 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, void *dummy_anachronism) + +int jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) { - int i; - jtag_command_t **last_cmd = jtag_get_last_command_p(); - if (jtag_trst == 1) { WARNING("JTAG command queued, while TRST is low (TAP in reset)"); - return ERROR_JTAG_TRST_ASSERTED; + return jtag_error=ERROR_JTAG_TRST_ASSERTED; } + if (state != -1) + cmd_queue_end_state = state; + + if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR) + jtag_call_event_callbacks(JTAG_TRST_RELEASED); + + if (cmd_queue_end_state == TAP_TLR) + jtag_call_event_callbacks(JTAG_TRST_ASSERTED); + + cmd_queue_cur_state = cmd_queue_end_state; + + return interface_jtag_add_plain_dr_scan(num_fields, fields, state); +} + +int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state) +{ + int i; + jtag_command_t **last_cmd = jtag_get_last_command_p(); + /* allocate memory for a new list member */ *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); last_comand_pointer = &((*last_cmd)->next); @@ -648,17 +698,6 @@ 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; - - if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR) - jtag_call_event_callbacks(JTAG_TRST_RELEASED); - - if (cmd_queue_end_state == TAP_TLR) - jtag_call_event_callbacks(JTAG_TRST_ASSERTED); - - cmd_queue_cur_state = cmd_queue_end_state; for (i = 0; i < num_fields; i++) { @@ -679,23 +718,12 @@ int jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state } int jtag_add_statemove(enum tap_state state) { - jtag_command_t **last_cmd = jtag_get_last_command_p(); - if (jtag_trst == 1) { WARNING("JTAG command queued, while TRST is low (TAP in reset)"); - return ERROR_JTAG_TRST_ASSERTED; + return jtag_error=ERROR_JTAG_TRST_ASSERTED; } - /* 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_STATEMOVE; - - (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t)); - (*last_cmd)->cmd.statemove->end_state = state; - if (state != -1) cmd_queue_end_state = state; @@ -706,28 +734,59 @@ int jtag_add_statemove(enum tap_state state) jtag_call_event_callbacks(JTAG_TRST_ASSERTED); cmd_queue_cur_state = cmd_queue_end_state; + + return interface_jtag_add_statemove(state); +} + +int MINIDRIVER(interface_jtag_add_statemove)(enum tap_state state) +{ + jtag_command_t **last_cmd = jtag_get_last_command_p(); + + /* 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_STATEMOVE; + + (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t)); + (*last_cmd)->cmd.statemove->end_state = state; + return ERROR_OK; } int jtag_add_pathmove(int num_states, enum tap_state *path) { - jtag_command_t **last_cmd = jtag_get_last_command_p(); - int i; - if (jtag_trst == 1) { WARNING("JTAG command queued, while TRST is low (TAP in reset)"); - return ERROR_JTAG_TRST_ASSERTED; + return jtag_error=ERROR_JTAG_TRST_ASSERTED; } /* the last state has to be a stable state */ if (tap_move_map[path[num_states - 1]] == -1) { ERROR("TAP path doesn't finish in a stable state"); - return ERROR_JTAG_NOT_IMPLEMENTED; + return jtag_error=ERROR_JTAG_NOT_IMPLEMENTED; } + if (cmd_queue_cur_state == TAP_TLR && cmd_queue_end_state != TAP_TLR) + jtag_call_event_callbacks(JTAG_TRST_RELEASED); + + if (cmd_queue_end_state == TAP_TLR) + jtag_call_event_callbacks(JTAG_TRST_ASSERTED); + + cmd_queue_cur_state = path[num_states - 1]; + + return interface_jtag_add_pathmove(num_states, path); +} + + +int MINIDRIVER(interface_jtag_add_pathmove)(int num_states, enum tap_state *path) +{ + jtag_command_t **last_cmd = jtag_get_last_command_p(); + int i; + /* allocate memory for a new list member */ *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); last_comand_pointer = &((*last_cmd)->next); @@ -740,28 +799,14 @@ int jtag_add_pathmove(int num_states, enum tap_state *path) 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); - - if (cmd_queue_end_state == TAP_TLR) - jtag_call_event_callbacks(JTAG_TRST_ASSERTED); - - cmd_queue_cur_state = path[num_states - 1]; return ERROR_OK; } -int jtag_add_runtest(int num_cycles, enum tap_state state) +int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, enum tap_state state) { jtag_command_t **last_cmd = jtag_get_last_command_p(); - if (jtag_trst == 1) - { - WARNING("JTAG command queued, while TRST is low (TAP in reset)"); - return ERROR_JTAG_TRST_ASSERTED; - } - /* allocate memory for a new list member */ *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); (*last_cmd)->next = NULL; @@ -772,6 +817,18 @@ int jtag_add_runtest(int num_cycles, enum tap_state state) (*last_cmd)->cmd.runtest->num_cycles = num_cycles; (*last_cmd)->cmd.runtest->end_state = state; + return ERROR_OK; +} + +int jtag_add_runtest(int num_cycles, enum tap_state state) +{ + if (jtag_trst == 1) + { + jtag_error=ERROR_JTAG_QUEUE_FAILED; + WARNING("JTAG command queued, while TRST is low (TAP in reset)"); + return ERROR_JTAG_TRST_ASSERTED; + } + if (state != -1) cmd_queue_end_state = state; @@ -783,14 +840,14 @@ int jtag_add_runtest(int num_cycles, enum tap_state state) cmd_queue_cur_state = cmd_queue_end_state; - return ERROR_OK; + /* executed by sw or hw fifo */ + return interface_jtag_add_runtest(num_cycles, state); } int jtag_add_reset(int req_trst, int req_srst) { int trst_with_tms = 0; - - jtag_command_t **last_cmd = jtag_get_last_command_p(); + int retval; if (req_trst == -1) req_trst = jtag_trst; @@ -801,7 +858,9 @@ int jtag_add_reset(int req_trst, int req_srst) /* Make sure that jtag_reset_config allows the requested reset */ /* if SRST pulls TRST, we can't fulfill srst == 1 with trst == 0 */ if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (req_trst == 0)) - return ERROR_JTAG_RESET_WOULD_ASSERT_TRST; + { + return jtag_error=ERROR_JTAG_RESET_WOULD_ASSERT_TRST; + } /* if TRST pulls SRST, we reset with TAP T-L-R */ if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_trst == 1)) && (req_srst == 0)) @@ -813,7 +872,7 @@ int jtag_add_reset(int req_trst, int req_srst) if (req_srst && !(jtag_reset_config & RESET_HAS_SRST)) { ERROR("requested nSRST assertion, but the current configuration doesn't support this"); - return ERROR_JTAG_RESET_CANT_SRST; + return jtag_error=ERROR_JTAG_RESET_CANT_SRST; } if (req_trst && !(jtag_reset_config & RESET_HAS_TRST)) @@ -821,20 +880,17 @@ int jtag_add_reset(int req_trst, int req_srst) req_trst = 0; trst_with_tms = 1; } - - /* allocate memory for a new list member */ - *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - (*last_cmd)->next = NULL; - last_comand_pointer = &((*last_cmd)->next); - (*last_cmd)->type = JTAG_RESET; - - (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t)); - (*last_cmd)->cmd.reset->trst = req_trst; - (*last_cmd)->cmd.reset->srst = req_srst; jtag_trst = req_trst; jtag_srst = req_srst; + retval = interface_jtag_add_reset(req_trst, req_srst); + if (retval!=ERROR_OK) + { + jtag_error=retval; + return retval; + } + if (jtag_srst) { jtag_call_event_callbacks(JTAG_SRST_ASSERTED); @@ -848,47 +904,53 @@ int jtag_add_reset(int req_trst, int req_srst) if (trst_with_tms) { - last_cmd = &((*last_cmd)->next); - - /* allocate memory for a new list member */ - *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); - (*last_cmd)->next = NULL; - last_comand_pointer = &((*last_cmd)->next); - (*last_cmd)->type = JTAG_STATEMOVE; - - (*last_cmd)->cmd.statemove = cmd_queue_alloc(sizeof(statemove_command_t)); - (*last_cmd)->cmd.statemove->end_state = TAP_TLR; - jtag_call_event_callbacks(JTAG_TRST_ASSERTED); - cmd_queue_cur_state = TAP_TLR; - cmd_queue_end_state = TAP_TLR; + jtag_add_end_state(TAP_TLR); + jtag_add_statemove(TAP_TLR); return ERROR_OK; } + + if (jtag_trst) + { + /* we just asserted nTRST, so we're now in Test-Logic-Reset, + * and inform possible listeners about this + */ + cmd_queue_cur_state = TAP_TLR; + jtag_call_event_callbacks(JTAG_TRST_ASSERTED); + } else { - if (jtag_trst) - { - /* we just asserted nTRST, so we're now in Test-Logic-Reset, - * and inform possible listeners about this - */ - cmd_queue_cur_state = TAP_TLR; - jtag_call_event_callbacks(JTAG_TRST_ASSERTED); - } - else - { - /* the nTRST line got deasserted, so we're still in Test-Logic-Reset, - * but we might want to add a delay to give the TAP time to settle - */ - if (jtag_ntrst_delay) - jtag_add_sleep(jtag_ntrst_delay * 1000); - } + /* the nTRST line got deasserted, so we're still in Test-Logic-Reset, + * but we might want to add a delay to give the TAP time to settle + */ + if (jtag_ntrst_delay) + jtag_add_sleep(jtag_ntrst_delay * 1000); } + + return retval; + +} + +int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst) +{ + jtag_command_t **last_cmd = jtag_get_last_command_p(); + + /* allocate memory for a new list member */ + *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); + (*last_cmd)->next = NULL; + last_comand_pointer = &((*last_cmd)->next); + (*last_cmd)->type = JTAG_RESET; + (*last_cmd)->cmd.reset = cmd_queue_alloc(sizeof(reset_command_t)); + (*last_cmd)->cmd.reset->trst = req_trst; + (*last_cmd)->cmd.reset->srst = req_srst; + + return ERROR_OK; } -int jtag_add_end_state(enum tap_state state) +int MINIDRIVER(interface_jtag_add_end_state)(enum tap_state state) { jtag_command_t **last_cmd = jtag_get_last_command_p(); @@ -901,13 +963,18 @@ int jtag_add_end_state(enum tap_state state) (*last_cmd)->cmd.end_state = cmd_queue_alloc(sizeof(end_state_command_t)); (*last_cmd)->cmd.end_state->end_state = state; + return ERROR_OK; +} + +int jtag_add_end_state(enum tap_state state) +{ + int retval = interface_jtag_add_end_state(state); if (state != -1) cmd_queue_end_state = state; - - return ERROR_OK; + return retval; } -int jtag_add_sleep(u32 us) +int MINIDRIVER(interface_jtag_add_sleep)(u32 us) { jtag_command_t **last_cmd = jtag_get_last_command_p(); @@ -923,6 +990,11 @@ int jtag_add_sleep(u32 us) return ERROR_OK; } +int jtag_add_sleep(u32 us) +{ + return interface_jtag_add_sleep(us); +} + int jtag_scan_size(scan_command_t *cmd) { int bit_count = 0; @@ -1106,7 +1178,7 @@ enum scan_type jtag_scan_type(scan_command_t *cmd) return type; } -int jtag_execute_queue(void) +int MINIDRIVER(interface_jtag_execute_queue)(void) { int retval; @@ -1117,6 +1189,18 @@ int jtag_execute_queue(void) jtag_command_queue = NULL; last_comand_pointer = &jtag_command_queue; + jtag_error=ERROR_OK; + + return retval; +} + +int jtag_execute_queue(void) +{ + int retval=interface_jtag_execute_queue(); + if (retval!=ERROR_OK) + return retval; + retval=jtag_error; + jtag_error=ERROR_OK; return retval; } @@ -1168,7 +1252,7 @@ int jtag_examine_chain() buf_set_u32(idcode_buffer, i * 32, 32, 0x000000FF); } - jtag_add_plain_dr_scan(1, &field, TAP_TLR, NULL); + jtag_add_plain_dr_scan(1, &field, TAP_TLR); jtag_execute_queue(); for (i = 0; i < JTAG_MAX_CHAIN_SIZE * 4; i++) @@ -1264,7 +1348,7 @@ int jtag_validate_chain() field.in_handler = NULL; field.in_handler_priv = NULL; - jtag_add_plain_ir_scan(1, &field, TAP_TLR, NULL); + jtag_add_plain_ir_scan(1, &field, TAP_TLR); jtag_execute_queue(); device = jtag_devices; @@ -1332,105 +1416,106 @@ int jtag_register_commands(struct command_context_s *cmd_ctx) return ERROR_OK; } +int jtag_interface_init(struct command_context_s *cmd_ctx) +{ + 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; + } + + if (jtag_interface->init() != ERROR_OK) + return ERROR_JTAG_INIT_FAILED; + + jtag = jtag_interface; + return ERROR_OK; +} + int jtag_init(struct command_context_s *cmd_ctx) { - int i, validate_tries = 0; - + int validate_tries = 0; + jtag_device_t *device; + DEBUG("-"); + + if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK) + return ERROR_JTAG_INIT_FAILED; - if (jtag_speed == -1) - jtag_speed = 0; + device = jtag_devices; + jtag_ir_scan_size = 0; + jtag_num_devices = 0; + while (device != NULL) + { + jtag_ir_scan_size += device->ir_length; + jtag_num_devices++; + device = device->next; + } - 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) - { - jtag_device_t *device; - device = jtag_devices; + 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..."); + } - if (jtag_interfaces[i]->init() != ERROR_OK) - return ERROR_JTAG_INIT_FAILED; - jtag = jtag_interfaces[i]; + 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); + } - jtag_ir_scan_size = 0; - jtag_num_devices = 0; - while (device != NULL) - { - jtag_ir_scan_size += device->ir_length; - jtag_num_devices++; - device = device->next; - } - - jtag_add_statemove(TAP_TLR); - jtag_execute_queue(); + return ERROR_OK; +} - /* 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..."); - } - - 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); - } +int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +{ + int i; - return ERROR_OK; - } + /* check whether the interface is already configured */ + if (jtag_interface) + { + 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) + { + if (jtag_interfaces[i]->register_commands(cmd_ctx) != ERROR_OK) + exit(-1); + + jtag_interface = jtag_interfaces[i]; + 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("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); } - - 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) - { - if (args[0] && (args[0][0] != 0)) - { - for (i=0; jtag_interfaces[i]; i++) - { - if (strcmp(args[0], jtag_interfaces[i]->name) == 0) - { - if (jtag_interfaces[i]->register_commands(cmd_ctx) != ERROR_OK) - exit(-1); - - jtag_interface = jtag_interfaces[i]->name; - - 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"); - } - - 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) @@ -1610,7 +1695,7 @@ int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char * if (argc < 1) { - return ERROR_COMMAND_SYNTAX_ERROR; + return ERROR_COMMAND_SYNTAX_ERROR; } else { @@ -1634,10 +1719,10 @@ int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char int srst = -1; int retval; - if (argc < 1) + if (argc < 2) { - return ERROR_COMMAND_SYNTAX_ERROR; - + return ERROR_COMMAND_SYNTAX_ERROR; + } if (args[0][0] == '1') @@ -1646,7 +1731,7 @@ int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char trst = 0; else { - return ERROR_COMMAND_SYNTAX_ERROR; + return ERROR_COMMAND_SYNTAX_ERROR; } if (args[1][0] == '1') @@ -1655,9 +1740,12 @@ int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char srst = 0; else { - return ERROR_COMMAND_SYNTAX_ERROR; + 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) @@ -1681,7 +1769,7 @@ int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char ** { if (argc < 1) { - return ERROR_COMMAND_SYNTAX_ERROR; + return ERROR_COMMAND_SYNTAX_ERROR; } jtag_add_runtest(strtol(args[0], NULL, 0), -1); @@ -1721,7 +1809,7 @@ int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **a if ((argc < 2) || (argc % 2)) { - return ERROR_COMMAND_SYNTAX_ERROR; + return ERROR_COMMAND_SYNTAX_ERROR; } fields = malloc(sizeof(scan_field_t) * argc / 2); @@ -1740,7 +1828,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, NULL); + jtag_add_ir_scan(argc / 2, fields, -1); jtag_execute_queue(); for (i = 0; i < argc / 2; i++) @@ -1761,7 +1849,7 @@ int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **a if ((argc < 2) || (argc % 2)) { - return ERROR_COMMAND_SYNTAX_ERROR; + return ERROR_COMMAND_SYNTAX_ERROR; } for (i = 0; i < argc; i+=2) @@ -1799,7 +1887,7 @@ int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **a } } - jtag_add_dr_scan(num_fields, fields, -1, NULL); + jtag_add_dr_scan(num_fields, fields, -1); jtag_execute_queue(); for (i = 0; i < argc / 2; i++) @@ -1810,9 +1898,46 @@ int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **a return ERROR_OK; } + + +int MINIDRIVER(interface_jtag_add_shift)(const enum tap_state shift_state, const enum tap_state end_state, int num_bits, u32 value) +{ + u8 out_buf[4]; + buf_set_u32(out_buf, 0, 32, flip_u32(value, 32)); + + /* allocate memory for a new list member */ + jtag_command_t **last_cmd; + last_cmd = jtag_get_last_command_p(); + *last_cmd = cmd_queue_alloc(sizeof(jtag_command_t)); + last_comand_pointer = &((*last_cmd)->next); + (*last_cmd)->next = NULL; + (*last_cmd)->type = JTAG_SCAN; + + /* allocate memory for scan command */ + (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t)); + (*last_cmd)->cmd.scan->ir_scan = (shift_state==TAP_SI); + (*last_cmd)->cmd.scan->num_fields = 1; + (*last_cmd)->cmd.scan->fields = cmd_queue_alloc(1 * sizeof(scan_field_t)); + (*last_cmd)->cmd.scan->end_state = end_state; + + int num_bytes = CEIL(num_bits, 8); + int i=0; + (*last_cmd)->cmd.scan->fields[i].device = 0; /* not used by any drivers */ + (*last_cmd)->cmd.scan->fields[i].num_bits = num_bits; + (*last_cmd)->cmd.scan->fields[i].out_value = buf_cpy(out_buf, cmd_queue_alloc(num_bytes), num_bits); + (*last_cmd)->cmd.scan->fields[i].out_mask = NULL; + (*last_cmd)->cmd.scan->fields[i].in_value = NULL; + (*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; + + return ERROR_OK; +} + int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - if (argc == 1) + if (argc == 1) { if (strcmp(args[0], "enable") == 0) { @@ -1821,16 +1946,16 @@ int handle_verify_ircapture_command(struct command_context_s *cmd_ctx, char *cmd else if (strcmp(args[0], "disable") == 0) { jtag_verify_capture_ir = 0; - } else - { - return ERROR_COMMAND_SYNTAX_ERROR; + } else + { + return ERROR_COMMAND_SYNTAX_ERROR; } - } else if (argc != 0) - { - return ERROR_COMMAND_SYNTAX_ERROR; - } - - command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled"); + } else if (argc != 0) + { + return ERROR_COMMAND_SYNTAX_ERROR; + } + + command_print(cmd_ctx, "verify Capture-IR is %s", (jtag_verify_capture_ir) ? "enabled": "disabled"); return ERROR_OK; }