X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fjtag.c;h=c73e0c9aa879663b1056e796215d2b2591c44a78;hp=e9802e17266fda05f55bb19da067d1f781201e4b;hb=eabb49b570290f2bcda80a0c591431b7ef240d43;hpb=076017341dd0428bb6e2c1bf5953851d91c098dd diff --git a/src/jtag/jtag.c b/src/jtag/jtag.c index e9802e1726..c73e0c9aa8 100644 --- a/src/jtag/jtag.c +++ b/src/jtag/jtag.c @@ -33,11 +33,6 @@ #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 @@ -111,12 +106,14 @@ tap_transition_t tap_transitions[16] = char* jtag_event_strings[] = { - "SRST asserted", - "TRST asserted", - "SRST released", - "TRST released" + "JTAG controller reset(tms or TRST)" }; +/* kludge!!!! these are just global variables that the + * interface use internally. They really belong + * inside the drivers, but we don't want to break + * linking the drivers!!!! + */ enum tap_state end_state = TAP_TLR; enum tap_state cur_state = TAP_TLR; int jtag_trst = 0; @@ -144,8 +141,18 @@ int jtag_ntrst_delay = 0; /* default to no nTRST delay */ /* callbacks to inform high-level handlers about JTAG state changes */ jtag_event_callback_t *jtag_event_callbacks; +/* speed in kHz*/ +static int speed1 = 0, speed2 = 0; +/* flag if the kHz speed was defined */ +static int hasKHz = 0; + /* jtag interfaces (parport, FTDI-USB, TI-USB, ...) */ + +#if BUILD_ECOSBOARD == 1 + extern jtag_interface_t eCosBoard_interface; +#endif + #if BUILD_PARPORT == 1 extern jtag_interface_t parport_interface; #endif @@ -183,6 +190,9 @@ jtag_event_callback_t *jtag_event_callbacks; #endif jtag_interface_t *jtag_interfaces[] = { +#if BUILD_ECOSBOARD == 1 + &eCosBoard_interface, +#endif #if BUILD_PARPORT == 1 &parport_interface, #endif @@ -218,21 +228,21 @@ jtag_interface_t *jtag = NULL; /* configuration */ jtag_interface_t *jtag_interface = NULL; int jtag_speed = 0; +int jtag_speed_post_reset = 0; /* forward declarations */ -int jtag_add_statemove(enum tap_state endstate); -int jtag_add_pathmove(int num_states, enum tap_state *path); -int jtag_add_runtest(int num_cycles, enum tap_state endstate); -int jtag_add_reset(int trst, int srst); -int jtag_add_end_state(enum tap_state endstate); -int jtag_add_sleep(u32 us); +void jtag_add_pathmove(int num_states, enum tap_state *path); +void jtag_add_runtest(int num_cycles, enum tap_state endstate); +void jtag_add_end_state(enum tap_state endstate); +void 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); int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); @@ -243,7 +253,6 @@ int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int handle_statemove_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); int handle_drscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); @@ -300,7 +309,7 @@ int jtag_call_event_callbacks(enum jtag_event event) { jtag_event_callback_t *callback = jtag_event_callbacks; - DEBUG("jtag event: %s", jtag_event_strings[event]); + LOG_DEBUG("jtag event: %s", jtag_event_strings[event]); while (callback) { @@ -344,7 +353,7 @@ jtag_device_t* jtag_get_device(int num) i++; } - ERROR("jtag device number %d not defined", num); + LOG_ERROR("jtag device number %d not defined", num); exit(-1); } @@ -391,30 +400,36 @@ void cmd_queue_free() cmd_queue_pages = NULL; } -int jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) +static void jtag_prelude1() { if (jtag_trst == 1) { - WARNING("JTAG command queued, while TRST is low (TAP in reset)"); + LOG_WARNING("JTAG command queued, while TRST is low (TAP in reset)"); jtag_error=ERROR_JTAG_TRST_ASSERTED; - return ERROR_JTAG_TRST_ASSERTED; + return; } - 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); +} + +static void jtag_prelude(enum tap_state state) +{ + jtag_prelude1(); + if (state != -1) + jtag_add_end_state(state); + cmd_queue_cur_state = cmd_queue_end_state; +} + +void jtag_add_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) +{ + jtag_prelude(state); - int retval=interface_jtag_add_ir_scan(num_fields, fields, state); + int retval=interface_jtag_add_ir_scan(num_fields, fields, cmd_queue_end_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) @@ -484,7 +499,7 @@ int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, (*last_cmd)->cmd.scan->fields[i].out_value = buf_set_ones(cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); (*last_cmd)->cmd.scan->fields[i].out_mask = NULL; device->bypass = 1; - + } /* update device information */ @@ -494,26 +509,13 @@ int MINIDRIVER(interface_jtag_add_ir_scan)(int num_fields, scan_field_t *fields, return ERROR_OK; } -int jtag_add_plain_ir_scan(int num_fields, scan_field_t *fields, enum tap_state state) +void jtag_add_plain_ir_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); + jtag_prelude(state); - 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 retval=interface_jtag_add_plain_ir_scan(num_fields, fields, cmd_queue_end_state); + if (retval!=ERROR_OK) + jtag_error=retval; } int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *fields, enum tap_state state) @@ -553,26 +555,13 @@ int MINIDRIVER(interface_jtag_add_plain_ir_scan)(int num_fields, scan_field_t *f return ERROR_OK; } -int jtag_add_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) +void 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; + jtag_prelude(state); - return interface_jtag_add_dr_scan(num_fields, fields, state); + int retval=interface_jtag_add_dr_scan(num_fields, fields, cmd_queue_end_state); + if (retval!=ERROR_OK) + jtag_error=retval; } int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state) @@ -629,13 +618,14 @@ int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, } if (!found) { +#ifdef _DEBUG_JTAG_IO_ /* if a device isn't listed, the BYPASS register should be selected */ if (!jtag_get_device(i)->bypass) { - ERROR("BUG: no scan data for a device not in BYPASS"); + LOG_ERROR("BUG: no scan data for a device not in BYPASS"); exit(-1); } - +#endif /* program the scan field to 1 bit length, and ignore it's value */ (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1; (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL; @@ -648,37 +638,115 @@ int MINIDRIVER(interface_jtag_add_dr_scan)(int num_fields, scan_field_t *fields, } else { +#ifdef _DEBUG_JTAG_IO_ /* if a device is listed, the BYPASS register must not be selected */ if (jtag_get_device(i)->bypass) { - WARNING("scan data for a device in BYPASS"); + LOG_ERROR("BUG: scan data for a device in BYPASS"); + exit(-1); } +#endif } } return ERROR_OK; } - -int jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) +void MINIDRIVER(interface_jtag_add_dr_out)(int device_num, + int num_fields, + int *num_bits, + u32 *value, + enum tap_state end_state) { - if (jtag_trst == 1) + int i; + int field_count = 0; + int scan_size; + int bypass_devices = 0; + + jtag_command_t **last_cmd = jtag_get_last_command_p(); + jtag_device_t *device = jtag_devices; + /* count devices in bypass */ + while (device) { - WARNING("JTAG command queued, while TRST is low (TAP in reset)"); - return jtag_error=ERROR_JTAG_TRST_ASSERTED; + if (device->bypass) + bypass_devices++; + device = device->next; } + + /* 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_SCAN; - 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); + /* allocate memory for dr scan command */ + (*last_cmd)->cmd.scan = cmd_queue_alloc(sizeof(scan_command_t)); + (*last_cmd)->cmd.scan->ir_scan = 0; + (*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 = end_state; - 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++) + { + (*last_cmd)->cmd.scan->fields[field_count].device = i; + + if (i == device_num) + { + int j; +#ifdef _DEBUG_JTAG_IO_ + /* if a device is listed, the BYPASS register must not be selected */ + if (jtag_get_device(i)->bypass) + { + LOG_ERROR("BUG: scan data for a device in BYPASS"); + exit(-1); + } +#endif + for (j = 0; j < num_fields; j++) + { + u8 out_value[4]; + scan_size = num_bits[j]; + buf_set_u32(out_value, 0, scan_size, value[j]); + (*last_cmd)->cmd.scan->fields[field_count].num_bits = scan_size; + (*last_cmd)->cmd.scan->fields[field_count].out_value = buf_cpy(out_value, cmd_queue_alloc(CEIL(scan_size, 8)), scan_size); + (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL; + (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL; + (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL; + (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL; + (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL; + (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL; + } + } else + { +#ifdef _DEBUG_JTAG_IO_ + /* if a device isn't listed, the BYPASS register should be selected */ + if (!jtag_get_device(i)->bypass) + { + LOG_ERROR("BUG: no scan data for a device not in BYPASS"); + exit(-1); + } +#endif + /* program the scan field to 1 bit length, and ignore it's value */ + (*last_cmd)->cmd.scan->fields[field_count].num_bits = 1; + (*last_cmd)->cmd.scan->fields[field_count].out_value = NULL; + (*last_cmd)->cmd.scan->fields[field_count].out_mask = NULL; + (*last_cmd)->cmd.scan->fields[field_count].in_value = NULL; + (*last_cmd)->cmd.scan->fields[field_count].in_check_value = NULL; + (*last_cmd)->cmd.scan->fields[field_count].in_check_mask = NULL; + (*last_cmd)->cmd.scan->fields[field_count].in_handler = NULL; + (*last_cmd)->cmd.scan->fields[field_count++].in_handler_priv = NULL; + } + } +} + + + + +void jtag_add_plain_dr_scan(int num_fields, scan_field_t *fields, enum tap_state state) +{ + jtag_prelude(state); - return interface_jtag_add_plain_dr_scan(num_fields, fields, state); + int retval=interface_jtag_add_plain_dr_scan(num_fields, fields, cmd_queue_end_state); + if (retval!=ERROR_OK) + jtag_error=retval; } int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *fields, enum tap_state state) @@ -716,30 +784,20 @@ int MINIDRIVER(interface_jtag_add_plain_dr_scan)(int num_fields, scan_field_t *f return ERROR_OK; } -int jtag_add_statemove(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); +void jtag_add_tlr() +{ + jtag_prelude(TAP_TLR); - 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_statemove(state); + int retval; + retval=interface_jtag_add_tlr(); + if (retval!=ERROR_OK) + jtag_error=retval; } -int MINIDRIVER(interface_jtag_add_statemove)(enum tap_state state) +int MINIDRIVER(interface_jtag_add_tlr)() { + enum tap_state state = TAP_TLR; jtag_command_t **last_cmd = jtag_get_last_command_p(); /* allocate memory for a new list member */ @@ -755,30 +813,35 @@ int MINIDRIVER(interface_jtag_add_statemove)(enum tap_state state) return ERROR_OK; } -int jtag_add_pathmove(int num_states, enum tap_state *path) +void jtag_add_pathmove(int num_states, enum tap_state *path) { - if (jtag_trst == 1) - { - WARNING("JTAG command queued, while TRST is low (TAP in reset)"); - 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 jtag_error=ERROR_JTAG_NOT_IMPLEMENTED; + LOG_ERROR("BUG: TAP path doesn't finish in a stable state"); + exit(-1); + } + + enum tap_state cur_state=cmd_queue_cur_state; + int i; + for (i=0; i %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[path[i]]); + exit(-1); + } + cur_state = 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); + jtag_prelude1(); cmd_queue_cur_state = path[num_states - 1]; - return interface_jtag_add_pathmove(num_states, path); + int retval=interface_jtag_add_pathmove(num_states, path); + if (retval!=ERROR_OK) + jtag_error=retval; } @@ -820,95 +883,84 @@ int MINIDRIVER(interface_jtag_add_runtest)(int num_cycles, enum tap_state state) return ERROR_OK; } -int jtag_add_runtest(int num_cycles, enum tap_state state) +void 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; - - 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; + jtag_prelude(state); /* executed by sw or hw fifo */ - return interface_jtag_add_runtest(num_cycles, state); + int retval=interface_jtag_add_runtest(num_cycles, cmd_queue_end_state); + if (retval!=ERROR_OK) + jtag_error=retval; } -int jtag_add_reset(int req_trst, int req_srst) +void jtag_add_reset(int req_tlr_or_trst, int req_srst) { - int trst_with_tms = 0; + int trst_with_tlr = 0; int retval; - if (req_trst == -1) - req_trst = jtag_trst; - - if (req_srst == -1) - req_srst = jtag_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)) + if (((jtag_reset_config & RESET_SRST_PULLS_TRST) && (req_srst == 1)) && (!req_tlr_or_trst)) { - return jtag_error=ERROR_JTAG_RESET_WOULD_ASSERT_TRST; + LOG_ERROR("BUG: requested reset would assert trst"); + jtag_error=ERROR_FAIL; + return; } /* 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)) + if (((jtag_reset_config & RESET_TRST_PULLS_SRST) && (req_tlr_or_trst)) && (req_srst == 0)) { - req_trst = 0; - trst_with_tms = 1; + trst_with_tlr = 1; } if (req_srst && !(jtag_reset_config & RESET_HAS_SRST)) { - ERROR("requested nSRST assertion, but the current configuration doesn't support this"); - return jtag_error=ERROR_JTAG_RESET_CANT_SRST; + LOG_ERROR("BUG: requested SRST assertion, but the current configuration doesn't support this"); + jtag_error=ERROR_FAIL; + return; } - if (req_trst && !(jtag_reset_config & RESET_HAS_TRST)) + if (req_tlr_or_trst) + { + if (!trst_with_tlr && (jtag_reset_config & RESET_HAS_TRST)) + { + jtag_trst = 1; + } else + { + trst_with_tlr = 1; + } + } else { - req_trst = 0; - trst_with_tms = 1; + jtag_trst = 0; } - - jtag_trst = req_trst; + jtag_srst = req_srst; - retval = interface_jtag_add_reset(req_trst, req_srst); + retval = interface_jtag_add_reset(jtag_trst, jtag_srst); if (retval!=ERROR_OK) { jtag_error=retval; - return retval; + return; } if (jtag_srst) { - jtag_call_event_callbacks(JTAG_SRST_ASSERTED); + LOG_DEBUG("SRST line asserted"); } else { - jtag_call_event_callbacks(JTAG_SRST_RELEASED); + LOG_DEBUG("SRST line released"); if (jtag_nsrst_delay) jtag_add_sleep(jtag_nsrst_delay * 1000); } - if (trst_with_tms) + if (trst_with_tlr) { - jtag_call_event_callbacks(JTAG_TRST_ASSERTED); + LOG_DEBUG("JTAG reset with tms instead of TRST"); jtag_add_end_state(TAP_TLR); - jtag_add_statemove(TAP_TLR); - - return ERROR_OK; + jtag_add_tlr(); + jtag_call_event_callbacks(JTAG_TRST_ASSERTED); + return; } if (jtag_trst) @@ -916,20 +968,15 @@ int jtag_add_reset(int req_trst, int req_srst) /* we just asserted nTRST, so we're now in Test-Logic-Reset, * and inform possible listeners about this */ + LOG_DEBUG("TRST line asserted"); 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); } - - return retval; - } int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst) @@ -950,28 +997,13 @@ int MINIDRIVER(interface_jtag_add_reset)(int req_trst, int req_srst) return ERROR_OK; } -int MINIDRIVER(interface_jtag_add_end_state)(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_cmd)->next = NULL; - last_comand_pointer = &((*last_cmd)->next); - (*last_cmd)->type = JTAG_END_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) +void 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 retval; + cmd_queue_end_state = state; + if ((cmd_queue_end_state == TAP_SD)||(cmd_queue_end_state == TAP_SD)) + { + LOG_ERROR("BUG: TAP_SD/SI can't be end state. Calling code should use a larger scan field"); + } } int MINIDRIVER(interface_jtag_add_sleep)(u32 us) @@ -990,9 +1022,12 @@ int MINIDRIVER(interface_jtag_add_sleep)(u32 us) return ERROR_OK; } -int jtag_add_sleep(u32 us) +void jtag_add_sleep(u32 us) { - return interface_jtag_add_sleep(us); + int retval=interface_jtag_add_sleep(us); + if (retval!=ERROR_OK) + jtag_error=retval; + return; } int jtag_scan_size(scan_command_t *cmd) @@ -1028,7 +1063,7 @@ int jtag_build_buffer(scan_command_t *cmd, u8 **buffer) #endif buf_set_buf(cmd->fields[i].out_value, 0, *buffer, bit_count, cmd->fields[i].num_bits); #ifdef _DEBUG_JTAG_IO_ - DEBUG("fields[%i].out_value: 0x%s", i, char_buf); + LOG_DEBUG("fields[%i].out_value: 0x%s", i, char_buf); free(char_buf); #endif } @@ -1063,7 +1098,7 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) char *char_buf; char_buf = buf_to_str(captured, (num_bits > 64) ? 64 : num_bits, 16); - DEBUG("fields[%i].in_value: 0x%s", i, char_buf); + LOG_DEBUG("fields[%i].in_value: 0x%s", i, char_buf); free(char_buf); #endif @@ -1075,7 +1110,7 @@ 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, cmd->fields+i) != ERROR_OK) { - WARNING("in_handler reported a failed check"); + LOG_WARNING("in_handler reported a failed check"); retval = ERROR_JTAG_QUEUE_FAILED; } } @@ -1089,7 +1124,7 @@ int jtag_read_buffer(u8 *buffer, scan_command_t *cmd) /* 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"); + LOG_WARNING("in_handler reported a failed check"); retval = ERROR_JTAG_QUEUE_FAILED; } } @@ -1129,12 +1164,12 @@ int jtag_check_value(u8 *captured, void *priv, scan_field_t *field) { char *in_check_mask_char; in_check_mask_char = buf_to_str(field->in_check_mask, (num_bits > 64) ? 64 : num_bits, 16); - WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s check_mask: 0x%s", captured_char, in_check_value_char, in_check_mask_char); + LOG_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); + LOG_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); @@ -1189,17 +1224,16 @@ int MINIDRIVER(interface_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; + if (retval==ERROR_OK) + { + retval=jtag_error; + } jtag_error=ERROR_OK; return retval; } @@ -1208,7 +1242,7 @@ int jtag_reset_callback(enum jtag_event event, void *priv) { jtag_device_t *device = priv; - DEBUG("-"); + LOG_DEBUG("-"); if (event == JTAG_TRST_ASSERTED) { @@ -1264,7 +1298,7 @@ int jtag_examine_chain() /* 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."); + LOG_ERROR("JTAG communication failure, check connection, JTAG interface, target power etc."); return ERROR_JTAG_INIT_FAILED; } @@ -1301,7 +1335,7 @@ int jtag_examine_chain() part = (idcode & 0xffff000) >> 12; version = (idcode & 0xf0000000) >> 28; - INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)", + LOG_INFO("JTAG device found: 0x%8.8x (Manufacturer: 0x%3.3x, Part: 0x%4.4x, Version: 0x%1.1x)", idcode, manufacturer, part, version); bit_count += 32; @@ -1311,9 +1345,9 @@ int jtag_examine_chain() /* 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, ...)"); + LOG_ERROR("number of discovered devices in JTAG chain (%i) doesn't match configuration (%i)", + device_count, jtag_num_devices); + LOG_ERROR("check the config file and ensure proper JTAG communication (connections, speed, ...)"); return ERROR_JTAG_INIT_FAILED; } @@ -1357,7 +1391,7 @@ int jtag_validate_chain() if (buf_get_u32(ir_test, chain_pos, 2) != 0x1) { char *cbuf = buf_to_str(ir_test, total_ir_length, 16); - ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf); + LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf); free(cbuf); free(ir_test); return ERROR_JTAG_INIT_FAILED; @@ -1369,7 +1403,7 @@ int jtag_validate_chain() if (buf_get_u32(ir_test, chain_pos, 2) != 0x3) { char *cbuf = buf_to_str(ir_test, total_ir_length, 16); - ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf); + LOG_ERROR("Error validating JTAG scan chain, IR mismatch, scan returned 0x%s", cbuf); free(cbuf); free(ir_test); return ERROR_JTAG_INIT_FAILED; @@ -1385,15 +1419,17 @@ int jtag_register_commands(struct command_context_s *cmd_ctx) register_command(cmd_ctx, NULL, "interface", handle_interface_command, COMMAND_CONFIG, NULL); register_command(cmd_ctx, NULL, "jtag_speed", handle_jtag_speed_command, - COMMAND_ANY, "set jtag speed (if supported) "); + COMMAND_ANY, "set jtag speed (if supported) []"); + register_command(cmd_ctx, NULL, "jtag_khz", handle_jtag_khz_command, + COMMAND_ANY, "same as jtag_speed, except it takes maximum khz as arguments. 0 KHz = RTCK."); register_command(cmd_ctx, NULL, "jtag_device", handle_jtag_device_command, COMMAND_CONFIG, "jtag_device "); register_command(cmd_ctx, NULL, "reset_config", handle_reset_config_command, COMMAND_CONFIG, NULL); register_command(cmd_ctx, NULL, "jtag_nsrst_delay", handle_jtag_nsrst_delay_command, - COMMAND_CONFIG, NULL); + COMMAND_ANY, "jtag_nsrst_delay - delay after deasserting srst in ms"); register_command(cmd_ctx, NULL, "jtag_ntrst_delay", handle_jtag_ntrst_delay_command, - COMMAND_CONFIG, NULL); + COMMAND_ANY, "jtag_ntrst_delay - delay after deasserting trst in ms"); register_command(cmd_ctx, NULL, "scan_chain", handle_scan_chain_command, COMMAND_EXEC, "print current scan chain configuration"); @@ -1404,8 +1440,6 @@ int jtag_register_commands(struct command_context_s *cmd_ctx) COMMAND_EXEC, "toggle reset lines "); register_command(cmd_ctx, NULL, "runtest", handle_runtest_command, COMMAND_EXEC, "move to Run-Test/Idle, and execute "); - register_command(cmd_ctx, NULL, "statemove", handle_statemove_command, - COMMAND_EXEC, "move to current endstate or [tap_state]"); register_command(cmd_ctx, NULL, "irscan", handle_irscan_command, COMMAND_EXEC, "execute IR scan [dev2] [instr2] ..."); register_command(cmd_ctx, NULL, "drscan", handle_drscan_command, @@ -1421,13 +1455,24 @@ 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"); + LOG_ERROR("JTAG interface has to be specified, see \"interface\" command"); return ERROR_JTAG_INVALID_INTERFACE; } + if(hasKHz) + { + /*stay on "reset speed"*/ + if (jtag_interface->khz(speed1, &speed1) == ERROR_OK) + jtag_speed = speed1; + if (jtag_interface->khz(speed2, &speed2) == ERROR_OK) + jtag_speed_post_reset = speed2; + hasKHz = 0; + } if (jtag_interface->init() != ERROR_OK) return ERROR_JTAG_INIT_FAILED; + + jtag = jtag_interface; return ERROR_OK; } @@ -1437,7 +1482,7 @@ int jtag_init(struct command_context_s *cmd_ctx) int validate_tries = 0; jtag_device_t *device; - DEBUG("-"); + LOG_DEBUG("-"); if (!jtag && jtag_interface_init(cmd_ctx) != ERROR_OK) return ERROR_JTAG_INIT_FAILED; @@ -1452,29 +1497,37 @@ int jtag_init(struct command_context_s *cmd_ctx) device = device->next; } - jtag_add_statemove(TAP_TLR); + jtag_add_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..."); + LOG_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"); + LOG_ERROR("Could not validate JTAG chain, exit"); return ERROR_JTAG_INVALID_INTERFACE; } usleep(10000); } - + return ERROR_OK; } + +static int default_khz(int khz, int *jtag_speed) +{ + LOG_ERROR("Translation from khz to jtag_speed not implemented"); + return ERROR_FAIL; +} + int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { int i; @@ -1482,7 +1535,7 @@ int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char /* check whether the interface is already configured */ if (jtag_interface) { - WARNING("Interface already configured, ignoring"); + LOG_WARNING("Interface already configured, ignoring"); return ERROR_OK; } @@ -1500,6 +1553,11 @@ int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char exit(-1); jtag_interface = jtag_interfaces[i]; + + if (jtag_interface->khz == NULL) + { + jtag_interface->khz = default_khz; + } return ERROR_OK; } } @@ -1507,11 +1565,11 @@ int handle_interface_command(struct command_context_s *cmd_ctx, char *cmd, char /* no valid interface was found (i.e. the configuration option, * didn't match one of the compiled-in interfaces */ - ERROR("No valid jtag interface found (%s)", args[0]); - ERROR("compiled-in jtag interfaces:"); + LOG_ERROR("No valid jtag interface found (%s)", args[0]); + LOG_ERROR("compiled-in jtag interfaces:"); for (i = 0; jtag_interfaces[i]; i++) { - ERROR("%i: %s", i, jtag_interfaces[i]->name); + LOG_ERROR("%i: %s", i, jtag_interfaces[i]->name); } return ERROR_JTAG_INVALID_INTERFACE; @@ -1548,7 +1606,7 @@ int handle_jtag_device_command(struct command_context_s *cmd_ctx, char *cmd, cha jtag_register_event_callback(jtag_reset_callback, (*last_device_p)); jtag_num_devices++; - + return ERROR_OK; } @@ -1573,6 +1631,9 @@ int handle_scan_chain_command(struct command_context_s *cmd_ctx, char *cmd, char int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { + if (argc < 1) + return ERROR_COMMAND_SYNTAX_ERROR; + if (argc >= 1) { if (strcmp(args[0], "none") == 0) @@ -1585,7 +1646,7 @@ int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, ch jtag_reset_config = RESET_TRST_AND_SRST; else { - ERROR("invalid reset_config argument, defaulting to none"); + LOG_ERROR("invalid reset_config argument, defaulting to none"); jtag_reset_config = RESET_NONE; return ERROR_INVALID_ARGUMENTS; } @@ -1593,19 +1654,23 @@ int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, ch if (argc >= 2) { - if (strcmp(args[1], "srst_pulls_trst") == 0) - jtag_reset_config |= RESET_SRST_PULLS_TRST; - else if (strcmp(args[1], "trst_pulls_srst") == 0) - jtag_reset_config |= RESET_TRST_PULLS_SRST; - else if (strcmp(args[1], "combined") == 0) - jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST; - else if (strcmp(args[1], "separate") == 0) - jtag_reset_config &= ~(RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST); - else + if (strcmp(args[1], "separate") == 0) { - ERROR("invalid reset_config argument, defaulting to none"); - jtag_reset_config = RESET_NONE; - return ERROR_INVALID_ARGUMENTS; + /* seperate reset lines - default */ + } else + { + if (strcmp(args[1], "srst_pulls_trst") == 0) + jtag_reset_config |= RESET_SRST_PULLS_TRST; + else if (strcmp(args[1], "trst_pulls_srst") == 0) + jtag_reset_config |= RESET_TRST_PULLS_SRST; + else if (strcmp(args[1], "combined") == 0) + jtag_reset_config |= RESET_SRST_PULLS_TRST | RESET_TRST_PULLS_SRST; + else + { + LOG_ERROR("invalid reset_config argument, defaulting to none"); + jtag_reset_config = RESET_NONE; + return ERROR_INVALID_ARGUMENTS; + } } } @@ -1617,7 +1682,7 @@ int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, ch jtag_reset_config &= ~RESET_TRST_OPEN_DRAIN; else { - ERROR("invalid reset_config argument, defaulting to none"); + LOG_ERROR("invalid reset_config argument, defaulting to none"); jtag_reset_config = RESET_NONE; return ERROR_INVALID_ARGUMENTS; } @@ -1631,7 +1696,7 @@ int handle_reset_config_command(struct command_context_s *cmd_ctx, char *cmd, ch jtag_reset_config &= ~RESET_SRST_PUSH_PULL; else { - ERROR("invalid reset_config argument, defaulting to none"); + LOG_ERROR("invalid reset_config argument, defaulting to none"); jtag_reset_config = RESET_NONE; return ERROR_INVALID_ARGUMENTS; } @@ -1644,7 +1709,7 @@ int handle_jtag_nsrst_delay_command(struct command_context_s *cmd_ctx, char *cmd { if (argc < 1) { - ERROR("jtag_nsrst_delay command takes one required argument"); + LOG_ERROR("jtag_nsrst_delay command takes one required argument"); exit(-1); } else @@ -1659,7 +1724,7 @@ int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd { if (argc < 1) { - ERROR("jtag_ntrst_delay command takes one required argument"); + LOG_ERROR("jtag_ntrst_delay command takes one required argument"); exit(-1); } else @@ -1672,22 +1737,67 @@ int handle_jtag_ntrst_delay_command(struct command_context_s *cmd_ctx, char *cmd int handle_jtag_speed_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - if (argc == 0) - command_print(cmd_ctx, "jtag_speed: %i", jtag_speed); - - if (argc > 0) + int cur_speed = 0; + + if (argc != 0) { + if ((argc<1) || (argc>2)) + return ERROR_COMMAND_SYNTAX_ERROR; + + LOG_DEBUG("handle jtag speed"); + + if (argc >= 1) + cur_speed = jtag_speed = jtag_speed_post_reset = strtoul(args[0], NULL, 0); + if (argc == 2) + cur_speed = jtag_speed_post_reset = strtoul(args[1], NULL, 0); + /* this command can be called during CONFIG, * in which case jtag isn't initialized */ if (jtag) - jtag->speed(strtoul(args[0], NULL, 0)); - else - jtag_speed = strtoul(args[0], NULL, 0); - } + jtag->speed(cur_speed); + } + command_print(cmd_ctx, "jtag_speed: %d, %d", jtag_speed, jtag_speed_post_reset); + + return ERROR_OK; +} +int handle_jtag_khz_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +{ + LOG_DEBUG("handle jtag khz"); + + if ((argc<1) || (argc>2)) + return ERROR_COMMAND_SYNTAX_ERROR; + + if (argc >= 1) + speed1 = speed2 = strtoul(args[0], NULL, 0); + if (argc == 2) + speed2 = strtoul(args[1], NULL, 0); + + if (jtag != NULL) + { + int cur_speed = 0; + LOG_DEBUG("have interface set up"); + int speed_div1, speed_div2; + if (jtag->khz(speed1, &speed_div1)!=ERROR_OK) + return ERROR_OK; + if (jtag->khz(speed2, &speed_div2)!=ERROR_OK) + return ERROR_OK; + + if (argc >= 1) + cur_speed = jtag_speed = jtag_speed_post_reset = speed_div1; + if (argc == 2) + cur_speed = jtag_speed_post_reset = speed_div2; + + jtag->speed(cur_speed); + } else + { + hasKHz = 1; + } + return ERROR_OK; } + int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { enum tap_state state; @@ -1707,7 +1817,7 @@ int handle_endstate_command(struct command_context_s *cmd_ctx, char *cmd, char * } } } - command_print(cmd_ctx, "current endstate: %s", tap_state_strings[end_state]); + command_print(cmd_ctx, "current endstate: %s", tap_state_strings[cmd_queue_end_state]); return ERROR_OK; } @@ -1716,12 +1826,10 @@ int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char { int trst = -1; int srst = -1; - int retval; if (argc < 2) { return ERROR_COMMAND_SYNTAX_ERROR; - } if (args[0][0] == '1') @@ -1745,20 +1853,7 @@ int handle_jtag_reset_command(struct command_context_s *cmd_ctx, char *cmd, char 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) - { - case ERROR_JTAG_RESET_WOULD_ASSERT_TRST: - command_print(cmd_ctx, "requested reset would assert trst\nif this is acceptable, use jtag_reset 1 %c", args[1][0]); - break; - case ERROR_JTAG_RESET_CANT_SRST: - command_print(cmd_ctx, "can't assert srst because the current reset_config doesn't support it"); - break; - default: - command_print(cmd_ctx, "unknown error"); - } - } + jtag_add_reset(trst, srst); jtag_execute_queue(); return ERROR_OK; @@ -1778,28 +1873,6 @@ int handle_runtest_command(struct command_context_s *cmd_ctx, char *cmd, char ** } -int handle_statemove_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) -{ - enum tap_state state; - - state = -1; - if (argc == 1) - { - for (state = 0; state < 16; state++) - { - if (strcmp(args[0], tap_state_strings[state]) == 0) - { - break; - } - } - } - - jtag_add_statemove(state); - jtag_execute_queue(); - - return ERROR_OK; - -} int handle_irscan_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { @@ -1897,43 +1970,6 @@ 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)