1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
26 /* project specific includes */
30 #include "configuration.h"
37 bitbang_interface_t *bitbang_interface;
40 /* DANGER!!!! clock absolutely *MUST* be 0 in idle or reset won't work!
42 * Set this to 1 and str912 reset halt will fail.
44 * If someone can submit a patch with an explanation it will be greatly
45 * appreciated, but as far as I can tell (ØH) DCLK is generated upon
46 * clk=0 in TAP_RTI. Good luck deducing that from the ARM documentation!
47 * The ARM documentation uses the term "DCLK is asserted while in the TAP_RTI
48 * state". With hardware there is no such thing as *while* in a state. There
49 * are only edges. So clk => 0 is in fact a very subtle state transition that
50 * happens *while* in the TAP_RTI state. "#&¤"#¤&"#&"#&
52 * For "reset halt" the last thing that happens before srst is asserted
53 * is that the breakpoint is set up. If DCLK is not wiggled one last
54 * time before the reset, then the breakpoint is not set up and
55 * "reset halt" will fail to halt.
58 #define CLOCK_IDLE() 0
60 int bitbang_execute_queue(void);
62 /* The bitbang driver leaves the TCK 0 when in idle */
64 void bitbang_end_state(enum tap_state state)
66 if (tap_move_map[state] != -1)
70 LOG_ERROR("BUG: %i is not a valid end state", state);
75 void bitbang_state_move(void) {
78 u8 tms_scan = TAP_MOVE(cur_state, end_state);
80 for (i = 0; i < 7; i++)
82 tms = (tms_scan >> i) & 1;
83 bitbang_interface->write(0, tms, 0);
84 bitbang_interface->write(1, tms, 0);
86 bitbang_interface->write(CLOCK_IDLE(), tms, 0);
88 cur_state = end_state;
91 void bitbang_path_move(pathmove_command_t *cmd)
93 int num_states = cmd->num_states;
100 if (tap_transitions[cur_state].low == cmd->path[state_count])
104 else if (tap_transitions[cur_state].high == cmd->path[state_count])
110 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[state_count]]);
114 bitbang_interface->write(0, tms, 0);
115 bitbang_interface->write(1, tms, 0);
117 cur_state = cmd->path[state_count];
122 bitbang_interface->write(CLOCK_IDLE(), tms, 0);
124 end_state = cur_state;
127 void bitbang_runtest(int num_cycles)
131 enum tap_state saved_end_state = end_state;
133 /* only do a state_move when we're not already in RTI */
134 if (cur_state != TAP_RTI)
136 bitbang_end_state(TAP_RTI);
137 bitbang_state_move();
140 /* execute num_cycles */
141 for (i = 0; i < num_cycles; i++)
143 bitbang_interface->write(0, 0, 0);
144 bitbang_interface->write(1, 0, 0);
146 bitbang_interface->write(CLOCK_IDLE(), 0, 0);
148 /* finish in end_state */
149 bitbang_end_state(saved_end_state);
150 if (cur_state != end_state)
151 bitbang_state_move();
154 void bitbang_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)
156 enum tap_state saved_end_state = end_state;
159 if (!((!ir_scan && (cur_state == TAP_SD)) || (ir_scan && (cur_state == TAP_SI))))
162 bitbang_end_state(TAP_SI);
164 bitbang_end_state(TAP_SD);
166 bitbang_state_move();
167 bitbang_end_state(saved_end_state);
170 for (bit_cnt = 0; bit_cnt < scan_size; bit_cnt++)
172 /* if we're just reading the scan, but don't care about the output
173 * default to outputting 'low', this also makes valgrind traces more readable,
174 * as it removes the dependency on an uninitialised value
176 if ((type != SCAN_IN) && ((buffer[bit_cnt/8] >> (bit_cnt % 8)) & 0x1))
178 bitbang_interface->write(0, (bit_cnt==scan_size-1) ? 1 : 0, 1);
179 bitbang_interface->write(1, (bit_cnt==scan_size-1) ? 1 : 0, 1);
181 bitbang_interface->write(0, (bit_cnt==scan_size-1) ? 1 : 0, 0);
182 bitbang_interface->write(1, (bit_cnt==scan_size-1) ? 1 : 0, 0);
185 if (type != SCAN_OUT)
188 TDO should be sampled on the rising edge, and will change
191 Because there is no way to read the signal exactly at the rising edge,
192 read after the rising edge.
194 This is plain IEEE 1149 JTAG - nothing specific to the OpenOCD or its JTAG
197 if (bitbang_interface->read())
198 buffer[(bit_cnt)/8] |= 1 << ((bit_cnt) % 8);
200 buffer[(bit_cnt)/8] &= ~(1 << ((bit_cnt) % 8));
204 /* TAP_SD & TAP_SI are illegal end states, so we always transition to the pause
205 * state which is a legal stable state from which statemove will work.
209 bitbang_interface->write(0, 0, 0);
210 bitbang_interface->write(1, 0, 0);
211 bitbang_interface->write(CLOCK_IDLE(), 0, 0);
218 if (cur_state != end_state)
219 bitbang_state_move();
222 int bitbang_execute_queue(void)
224 jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
230 if (!bitbang_interface)
232 LOG_ERROR("BUG: Bitbang interface called, but not yet initialized");
236 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
237 * that wasn't handled by a caller-provided error handler
241 if(bitbang_interface->blink)
242 bitbang_interface->blink(1);
249 #ifdef _DEBUG_JTAG_IO_
250 LOG_DEBUG("end_state: %i", cmd->cmd.end_state->end_state);
252 if (cmd->cmd.end_state->end_state != -1)
253 bitbang_end_state(cmd->cmd.end_state->end_state);
256 #ifdef _DEBUG_JTAG_IO_
257 LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
259 if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_reset_config & RESET_SRST_PULLS_TRST)))
263 bitbang_interface->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
266 #ifdef _DEBUG_JTAG_IO_
267 LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
269 if (cmd->cmd.runtest->end_state != -1)
270 bitbang_end_state(cmd->cmd.runtest->end_state);
271 bitbang_runtest(cmd->cmd.runtest->num_cycles);
274 #ifdef _DEBUG_JTAG_IO_
275 LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
277 if (cmd->cmd.statemove->end_state != -1)
278 bitbang_end_state(cmd->cmd.statemove->end_state);
279 bitbang_state_move();
282 #ifdef _DEBUG_JTAG_IO_
283 LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
285 bitbang_path_move(cmd->cmd.pathmove);
288 #ifdef _DEBUG_JTAG_IO_
289 LOG_DEBUG("%s scan end in %i", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", cmd->cmd.scan->end_state);
291 if (cmd->cmd.scan->end_state != -1)
292 bitbang_end_state(cmd->cmd.scan->end_state);
293 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
294 type = jtag_scan_type(cmd->cmd.scan);
295 bitbang_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
296 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
297 retval = ERROR_JTAG_QUEUE_FAILED;
302 #ifdef _DEBUG_JTAG_IO_
303 LOG_DEBUG("sleep %i", cmd->cmd.sleep->us);
305 jtag_sleep(cmd->cmd.sleep->us);
308 LOG_ERROR("BUG: unknown JTAG command type encountered");
313 if(bitbang_interface->blink)
314 bitbang_interface->blink(0);