X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;ds=sidebyside;f=src%2Fjtag%2Fbitbang.c;h=44e889864b2b5a821659c28478e0d3f602ffbd8c;hb=0bba832713cca8e5931d5d21f37f526d0a3979cf;hp=819d8e5800079b912783ba342c86d6ce90377b56;hpb=87939e553d542ee2ec2b82075798838b77468ead;p=openocd.git diff --git a/src/jtag/bitbang.c b/src/jtag/bitbang.c index 819d8e5800..44e889864b 100644 --- a/src/jtag/bitbang.c +++ b/src/jtag/bitbang.c @@ -2,6 +2,9 @@ * Copyright (C) 2005 by Dominic Rath * * Dominic.Rath@gmx.de * * * + * Copyright (C) 2007,2008 Øyvind Harboe * + * oyvind.harboe@zylin.com * + * * * This program is free software; you can redistribute it and/or modify * * it under the terms of the GNU General Public License as published by * * the Free Software Foundation; either version 2 of the License, or * @@ -34,194 +37,215 @@ #include #include -#include -#include + +/** + * 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); + bitbang_interface_t *bitbang_interface; +/* DANGER!!!! clock absolutely *MUST* be 0 in idle or reset won't work! + * + * Set this to 1 and str912 reset halt will fail. + * + * If someone can submit a patch with an explanation it will be greatly + * appreciated, but as far as I can tell (ØH) DCLK is generated upon + * clk=0 in TAP_IDLE. Good luck deducing that from the ARM documentation! + * The ARM documentation uses the term "DCLK is asserted while in the TAP_IDLE + * state". With hardware there is no such thing as *while* in a state. There + * are only edges. So clk => 0 is in fact a very subtle state transition that + * happens *while* in the TAP_IDLE state. "#&¤"#¤&"#&"#& + * + * For "reset halt" the last thing that happens before srst is asserted + * is that the breakpoint is set up. If DCLK is not wiggled one last + * time before the reset, then the breakpoint is not set up and + * "reset halt" will fail to halt. + * + */ +#define CLOCK_IDLE() 0 + int bitbang_execute_queue(void); -/* The bitbang driver leaves the TCK 0 when in idle */ +/* The bitbang driver leaves the TCK 0 when in idle */ -void bitbang_end_state(enum tap_state state) +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 { - ERROR("BUG: %i is not a valid end state", state); + LOG_ERROR("BUG: %i is not a valid end state", state); exit(-1); } } -void bitbang_state_move(void) { - +void bitbang_state_move(void) +{ int i=0, tms=0; - u8 tms_scan = TAP_MOVE(cur_state, end_state); - + u8 tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state()); + for (i = 0; i < 7; i++) { tms = (tms_scan >> i) & 1; bitbang_interface->write(0, tms, 0); bitbang_interface->write(1, tms, 0); } - bitbang_interface->write(0, tms, 0); - - cur_state = end_state; + bitbang_interface->write(CLOCK_IDLE(), tms, 0); + + tap_set_state(tap_get_end_state()); } void bitbang_path_move(pathmove_command_t *cmd) { int num_states = cmd->num_states; int state_count; - int tms; + int tms = 0; 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 { - 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(0, tms, 0); - end_state = cur_state; + bitbang_interface->write(CLOCK_IDLE(), tms, 0); + + tap_set_end_state(tap_get_state()); } void bitbang_runtest(int num_cycles) { int i; - - enum tap_state saved_end_state = end_state; - - /* only do a state_move when we're not already in RTI */ - if (cur_state != TAP_RTI) + + tap_state_t saved_end_state = tap_get_end_state(); + + /* only do a state_move when we're not already in IDLE */ + if (tap_get_state() != TAP_IDLE) { - bitbang_end_state(TAP_RTI); + bitbang_end_state(TAP_IDLE); bitbang_state_move(); } - + /* execute num_cycles */ - bitbang_interface->write(0, 0, 0); for (i = 0; i < num_cycles; i++) { - bitbang_interface->write(1, 0, 0); bitbang_interface->write(0, 0, 0); + bitbang_interface->write(1, 0, 0); } - + bitbang_interface->write(CLOCK_IDLE(), 0, 0); + /* finish in end_state */ bitbang_end_state(saved_end_state); - if (cur_state != end_state) + if (tap_get_state() != tap_get_end_state()) bitbang_state_move(); } + +static void bitbang_stableclocks(int num_cycles) +{ + 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); + } +} + + + void bitbang_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size) { - enum tap_state saved_end_state = end_state; + tap_state_t saved_end_state = tap_get_end_state(); int bit_cnt; - int last_bit, last_bit_in; - - if (!((!ir_scan && (cur_state == TAP_SD)) || (ir_scan && (cur_state == TAP_SI)))) + + if (!((!ir_scan && (tap_get_state() == TAP_DRSHIFT)) || (ir_scan && (tap_get_state() == TAP_IRSHIFT)))) { if (ir_scan) - bitbang_end_state(TAP_SI); + bitbang_end_state(TAP_IRSHIFT); else - bitbang_end_state(TAP_SD); + bitbang_end_state(TAP_DRSHIFT); bitbang_state_move(); bitbang_end_state(saved_end_state); } - for (bit_cnt = 0; bit_cnt < scan_size - 1; bit_cnt++) + for (bit_cnt = 0; bit_cnt < scan_size; bit_cnt++) { + int val=0; + int tms=(bit_cnt==scan_size-1) ? 1 : 0; + int tdi; + int bytec=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, * as it removes the dependency on an uninitialised value - */ - if ((type != SCAN_IN) && ((buffer[bit_cnt/8] >> (bit_cnt % 8)) & 0x1)) - { - bitbang_interface->write(0, 0, 1); - bitbang_interface->write(1, 0, 1); - } else { - bitbang_interface->write(0, 0, 0); - bitbang_interface->write(1, 0, 0); - } - + */ + tdi=0; + if ((type != SCAN_IN) && (buffer[bytec] & bcval)) + tdi=1; + + bitbang_interface->write(0, tms, tdi); + + if (type!=SCAN_OUT) + val=bitbang_interface->read(); + + bitbang_interface->write(1, tms, tdi); + if (type != SCAN_OUT) { - if (bitbang_interface->read()) - buffer[(bit_cnt)/8] |= 1 << ((bit_cnt) % 8); + if (val) + buffer[bytec] |= bcval; else - buffer[(bit_cnt)/8] &= ~(1 << ((bit_cnt) % 8)); + buffer[bytec] &= ~bcval; } } - if ((type != SCAN_IN) && ((buffer[bit_cnt/8] >> (bit_cnt % 8)) & 0x1)) - last_bit = 1; - else - last_bit = 0; - - if ((ir_scan && (end_state == TAP_SI)) || - (!ir_scan && (end_state == TAP_SD))) - { - bitbang_interface->write(0, 0, last_bit); - bitbang_interface->write(1, 0, last_bit); - - if (type != SCAN_OUT) - last_bit_in = bitbang_interface->read(); + /* 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); - bitbang_interface->write(0, 0, last_bit); - } + if (ir_scan) + tap_set_state(TAP_IRPAUSE); else - { - /* Shift-[ID]R -> Exit1-[ID]R */ - bitbang_interface->write(0, 1, last_bit); - bitbang_interface->write(1, 1, last_bit); - - if (type != SCAN_OUT) - last_bit_in = bitbang_interface->read(); + tap_set_state(TAP_DRPAUSE); - /* Exit1-[ID]R -> Pause-[ID]R */ - bitbang_interface->write(0, 0, 0); - bitbang_interface->write(1, 0, 0); - - if (cur_state == TAP_SI) - cur_state = TAP_PI; - else - cur_state = TAP_PD; - - if (cur_state != end_state) - bitbang_state_move(); - else - bitbang_interface->write(0, 0, 0); - } - - if (type != SCAN_OUT) - { - if (last_bit_in) - buffer[(bit_cnt)/8] |= 1 << ((bit_cnt) % 8); - else - buffer[(bit_cnt)/8] &= ~(1 << ((bit_cnt) % 8)); - } + if (tap_get_state() != tap_get_end_state()) + bitbang_state_move(); } int bitbang_execute_queue(void) @@ -231,18 +255,18 @@ int bitbang_execute_queue(void) enum scan_type type; u8 *buffer; int retval; - + if (!bitbang_interface) { - ERROR("BUG: Bitbang interface called, but not yet initialized"); + LOG_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; - + if(bitbang_interface->blink) bitbang_interface->blink(1); @@ -252,48 +276,57 @@ int bitbang_execute_queue(void) { case JTAG_END_STATE: #ifdef _DEBUG_JTAG_IO_ - DEBUG("end_state: %i", cmd->cmd.end_state->end_state); + LOG_DEBUG("end_state: %s", tap_state_name(cmd->cmd.end_state->end_state) ); #endif - if (cmd->cmd.end_state->end_state != -1) + if (cmd->cmd.end_state->end_state != TAP_INVALID) bitbang_end_state(cmd->cmd.end_state->end_state); break; case JTAG_RESET: #ifdef _DEBUG_JTAG_IO_ - DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); + LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); #endif - if (cmd->cmd.reset->trst == 1) + if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_reset_config & RESET_SRST_PULLS_TRST))) { - cur_state = TAP_TLR; + tap_set_state(TAP_RESET); } bitbang_interface->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); break; case JTAG_RUNTEST: #ifdef _DEBUG_JTAG_IO_ - 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) + if (cmd->cmd.runtest->end_state != TAP_INVALID) 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_ - 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) + if (cmd->cmd.statemove->end_state != TAP_INVALID) bitbang_end_state(cmd->cmd.statemove->end_state); bitbang_state_move(); break; case JTAG_PATHMOVE: #ifdef _DEBUG_JTAG_IO_ - 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_ - 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) + if (cmd->cmd.scan->end_state != TAP_INVALID) bitbang_end_state(cmd->cmd.scan->end_state); scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); type = jtag_scan_type(cmd->cmd.scan); @@ -305,19 +338,18 @@ int bitbang_execute_queue(void) break; case JTAG_SLEEP: #ifdef _DEBUG_JTAG_IO_ - DEBUG("sleep %i", cmd->cmd.sleep->us); + LOG_DEBUG("sleep %i", cmd->cmd.sleep->us); #endif jtag_sleep(cmd->cmd.sleep->us); break; default: - ERROR("BUG: unknown JTAG command type encountered"); + LOG_ERROR("BUG: unknown JTAG command type encountered"); exit(-1); } cmd = cmd->next; } if(bitbang_interface->blink) bitbang_interface->blink(0); - + return retval; } -