X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fbitbang.c;h=dacd65ec23fba079adf457b0707d25557cce25bd;hp=8c4a3761c984f9ca24d9fe9ca1f217aa8fca7cb3;hb=aea6815462d3302f7f8b6576f59320d5f5985642;hpb=0cba0d4df3fe120f08945703506f8405760325c9 diff --git a/src/jtag/bitbang.c b/src/jtag/bitbang.c index 8c4a3761c9..dacd65ec23 100644 --- a/src/jtag/bitbang.c +++ b/src/jtag/bitbang.c @@ -25,17 +25,19 @@ #endif #include "bitbang.h" +#include "interface.h" +#include "commands.h" + +/** + * Function bitbang_stableclocks + * issues a number of clock cycles while staying in a stable state. + * Because the TMS value required to stay in the RESET state is a 1, whereas + * the TMS value required to stay in any of the other stable states is a 0, + * this function checks the current stable state to decide on the value of TMS + * to use. + */ +static void bitbang_stableclocks(int num_cycles); -/* project specific includes */ -#include "log.h" -#include "types.h" -#include "jtag.h" -#include "configuration.h" - -/* system includes */ -#include -#include -#include bitbang_interface_t *bitbang_interface; @@ -59,14 +61,12 @@ bitbang_interface_t *bitbang_interface; */ #define CLOCK_IDLE() 0 -int bitbang_execute_queue(void); /* The bitbang driver leaves the TCK 0 when in idle */ - -void bitbang_end_state(enum tap_state state) +static void bitbang_end_state(tap_state_t state) { - if (tap_move_map[state] != -1) - end_state = state; + if (tap_is_state_stable(state)) + tap_set_end_state(state); else { LOG_ERROR("BUG: %i is not a valid end state", state); @@ -74,12 +74,13 @@ void bitbang_end_state(enum tap_state state) } } -void bitbang_state_move(void) { - +static void bitbang_state_move(int skip) +{ int i=0, tms=0; - u8 tms_scan = TAP_MOVE(cur_state, end_state); + uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state()); + int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state()); - for (i = 0; i < 7; i++) + for (i = skip; i < tms_count; i++) { tms = (tms_scan >> i) & 1; bitbang_interface->write(0, tms, 0); @@ -87,10 +88,10 @@ void bitbang_state_move(void) { } bitbang_interface->write(CLOCK_IDLE(), tms, 0); - cur_state = end_state; + tap_set_state(tap_get_end_state()); } -void bitbang_path_move(pathmove_command_t *cmd) +static void bitbang_path_move(pathmove_command_t *cmd) { int num_states = cmd->num_states; int state_count; @@ -99,44 +100,44 @@ void bitbang_path_move(pathmove_command_t *cmd) state_count = 0; while (num_states) { - if (tap_transitions[cur_state].low == cmd->path[state_count]) + if (tap_state_transition(tap_get_state(), false) == cmd->path[state_count]) { tms = 0; } - else if (tap_transitions[cur_state].high == cmd->path[state_count]) + else if (tap_state_transition(tap_get_state(), true) == cmd->path[state_count]) { tms = 1; } else { - LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[state_count]]); + LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(cmd->path[state_count])); exit(-1); } bitbang_interface->write(0, tms, 0); bitbang_interface->write(1, tms, 0); - cur_state = cmd->path[state_count]; + tap_set_state(cmd->path[state_count]); state_count++; num_states--; } bitbang_interface->write(CLOCK_IDLE(), tms, 0); - end_state = cur_state; + tap_set_end_state(tap_get_state()); } -void bitbang_runtest(int num_cycles) +static void bitbang_runtest(int num_cycles) { int i; - enum tap_state saved_end_state = end_state; + tap_state_t saved_end_state = tap_get_end_state(); /* only do a state_move when we're not already in IDLE */ - if (cur_state != TAP_IDLE) + if (tap_get_state() != TAP_IDLE) { bitbang_end_state(TAP_IDLE); - bitbang_state_move(); + bitbang_state_move(0); } /* execute num_cycles */ @@ -149,23 +150,39 @@ void bitbang_runtest(int num_cycles) /* finish in end_state */ bitbang_end_state(saved_end_state); - if (cur_state != end_state) - bitbang_state_move(); + if (tap_get_state() != tap_get_end_state()) + bitbang_state_move(0); } -void bitbang_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size) + +static void bitbang_stableclocks(int num_cycles) { - enum tap_state saved_end_state = end_state; + int tms = (tap_get_state() == TAP_RESET ? 1 : 0); + int i; + + /* send num_cycles clocks onto the cable */ + for (i = 0; i < num_cycles; i++) + { + bitbang_interface->write(1, tms, 0); + bitbang_interface->write(0, tms, 0); + } +} + + + +static void bitbang_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size) +{ + tap_state_t saved_end_state = tap_get_end_state(); int bit_cnt; - if (!((!ir_scan && (cur_state == TAP_DRSHIFT)) || (ir_scan && (cur_state == TAP_IRSHIFT)))) + if (!((!ir_scan && (tap_get_state() == TAP_DRSHIFT)) || (ir_scan && (tap_get_state() == TAP_IRSHIFT)))) { if (ir_scan) bitbang_end_state(TAP_IRSHIFT); else bitbang_end_state(TAP_DRSHIFT); - bitbang_state_move(); + bitbang_state_move(0); bitbang_end_state(saved_end_state); } @@ -175,7 +192,7 @@ void bitbang_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size) int tms=(bit_cnt==scan_size-1) ? 1 : 0; int tdi; int bytec=bit_cnt/8; - int bcval=1<<(bit_cnt % 8); + int bcval=1 << (bit_cnt % 8); /* if we're just reading the scan, but don't care about the output * default to outputting 'low', this also makes valgrind traces more readable, @@ -187,7 +204,7 @@ void bitbang_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size) bitbang_interface->write(0, tms, tdi); - if (type!=SCAN_OUT) + if (type != SCAN_OUT) val=bitbang_interface->read(); bitbang_interface->write(1, tms, tdi); @@ -201,22 +218,14 @@ void bitbang_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size) } } - /* TAP_DRSHIFT & TAP_IRSHIFT are illegal end states, so we always transition to the pause - * state which is a legal stable state from which statemove will work. - * - * Exit1 -> Pause - */ - bitbang_interface->write(0, 0, 0); - bitbang_interface->write(1, 0, 0); - bitbang_interface->write(CLOCK_IDLE(), 0, 0); - - if (ir_scan) - cur_state = TAP_IRPAUSE; - else - cur_state = TAP_DRPAUSE; - - if (cur_state != end_state) - bitbang_state_move(); + if (tap_get_state() != tap_get_end_state()) + { + /* we *KNOW* the above loop transitioned out of + * the shift state, so we skip the first state + * and move directly to the end state. + */ + bitbang_state_move(1); + } } int bitbang_execute_queue(void) @@ -224,7 +233,7 @@ int bitbang_execute_queue(void) jtag_command_t *cmd = jtag_command_queue; /* currently processed command */ int scan_size; enum scan_type type; - u8 *buffer; + uint8_t *buffer; int retval; if (!bitbang_interface) @@ -238,58 +247,57 @@ int bitbang_execute_queue(void) */ retval = ERROR_OK; - if(bitbang_interface->blink) + if (bitbang_interface->blink) bitbang_interface->blink(1); while (cmd) { switch (cmd->type) { - case JTAG_END_STATE: -#ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("end_state: %i", cmd->cmd.end_state->end_state); -#endif - if (cmd->cmd.end_state->end_state != -1) - bitbang_end_state(cmd->cmd.end_state->end_state); - break; case JTAG_RESET: #ifdef _DEBUG_JTAG_IO_ LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); #endif - if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_reset_config & RESET_SRST_PULLS_TRST))) + if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST))) { - cur_state = TAP_RESET; + tap_set_state(TAP_RESET); } bitbang_interface->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); break; case JTAG_RUNTEST: #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state); + LOG_DEBUG("runtest %i cycles, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name(cmd->cmd.runtest->end_state) ); #endif - if (cmd->cmd.runtest->end_state != -1) - bitbang_end_state(cmd->cmd.runtest->end_state); + bitbang_end_state(cmd->cmd.runtest->end_state); bitbang_runtest(cmd->cmd.runtest->num_cycles); break; + + case JTAG_STABLECLOCKS: + /* this is only allowed while in a stable state. A check for a stable + * state was done in jtag_add_clocks() + */ + bitbang_stableclocks(cmd->cmd.stableclocks->num_cycles); + break; + case JTAG_STATEMOVE: #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state); + LOG_DEBUG("statemove end in %s", tap_state_name(cmd->cmd.statemove->end_state)); #endif - if (cmd->cmd.statemove->end_state != -1) - bitbang_end_state(cmd->cmd.statemove->end_state); - bitbang_state_move(); + bitbang_end_state(cmd->cmd.statemove->end_state); + bitbang_state_move(0); break; case JTAG_PATHMOVE: #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); + LOG_DEBUG("pathmove: %i states, end in %s", cmd->cmd.pathmove->num_states, + tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1])); #endif bitbang_path_move(cmd->cmd.pathmove); break; case JTAG_SCAN: #ifdef _DEBUG_JTAG_IO_ - LOG_DEBUG("%s scan end in %i", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", cmd->cmd.scan->end_state); + LOG_DEBUG("%s scan end in %s", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", tap_state_name(cmd->cmd.scan->end_state) ); #endif - if (cmd->cmd.scan->end_state != -1) - bitbang_end_state(cmd->cmd.scan->end_state); + bitbang_end_state(cmd->cmd.scan->end_state); scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); type = jtag_scan_type(cmd->cmd.scan); bitbang_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size); @@ -310,7 +318,7 @@ int bitbang_execute_queue(void) } cmd = cmd->next; } - if(bitbang_interface->blink) + if (bitbang_interface->blink) bitbang_interface->blink(0); return retval;