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 /* should the clock be high or low in idle? */
41 #define CLOCK_IDLE() 0
43 int bitbang_execute_queue(void);
45 /* The bitbang driver leaves the TCK 0 when in idle */
47 void bitbang_end_state(enum tap_state state)
49 if (tap_move_map[state] != -1)
53 LOG_ERROR("BUG: %i is not a valid end state", state);
58 void bitbang_state_move(void) {
61 u8 tms_scan = TAP_MOVE(cur_state, end_state);
63 for (i = 0; i < 7; i++)
65 tms = (tms_scan >> i) & 1;
66 bitbang_interface->write(0, tms, 0);
67 bitbang_interface->write(1, tms, 0);
69 bitbang_interface->write(CLOCK_IDLE(), tms, 0);
71 cur_state = end_state;
74 void bitbang_path_move(pathmove_command_t *cmd)
76 int num_states = cmd->num_states;
83 if (tap_transitions[cur_state].low == cmd->path[state_count])
87 else if (tap_transitions[cur_state].high == cmd->path[state_count])
93 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[state_count]]);
97 bitbang_interface->write(0, tms, 0);
98 bitbang_interface->write(1, tms, 0);
100 cur_state = cmd->path[state_count];
105 bitbang_interface->write(CLOCK_IDLE(), tms, 0);
107 end_state = cur_state;
110 void bitbang_runtest(int num_cycles)
114 enum tap_state saved_end_state = end_state;
116 /* only do a state_move when we're not already in RTI */
117 if (cur_state != TAP_RTI)
119 bitbang_end_state(TAP_RTI);
120 bitbang_state_move();
123 /* execute num_cycles */
124 for (i = 0; i < num_cycles; i++)
126 bitbang_interface->write(0, 0, 0);
127 bitbang_interface->write(1, 0, 0);
129 bitbang_interface->write(CLOCK_IDLE(), 0, 0);
131 /* finish in end_state */
132 bitbang_end_state(saved_end_state);
133 if (cur_state != end_state)
134 bitbang_state_move();
137 void bitbang_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)
139 enum tap_state saved_end_state = end_state;
142 if (!((!ir_scan && (cur_state == TAP_SD)) || (ir_scan && (cur_state == TAP_SI))))
145 bitbang_end_state(TAP_SI);
147 bitbang_end_state(TAP_SD);
149 bitbang_state_move();
150 bitbang_end_state(saved_end_state);
153 for (bit_cnt = 0; bit_cnt < scan_size; bit_cnt++)
155 /* if we're just reading the scan, but don't care about the output
156 * default to outputting 'low', this also makes valgrind traces more readable,
157 * as it removes the dependency on an uninitialised value
159 if ((type != SCAN_IN) && ((buffer[bit_cnt/8] >> (bit_cnt % 8)) & 0x1))
161 bitbang_interface->write(0, (bit_cnt==scan_size-1) ? 1 : 0, 1);
162 bitbang_interface->write(1, (bit_cnt==scan_size-1) ? 1 : 0, 1);
164 bitbang_interface->write(0, (bit_cnt==scan_size-1) ? 1 : 0, 0);
165 bitbang_interface->write(1, (bit_cnt==scan_size-1) ? 1 : 0, 0);
168 if (type != SCAN_OUT)
171 TDO should be sampled on the rising edge, and will change
174 Because there is no way to read the signal exactly at the rising edge,
175 read after the rising edge.
177 This is plain IEEE 1149 JTAG - nothing specific to the OpenOCD or its JTAG
180 if (bitbang_interface->read())
181 buffer[(bit_cnt)/8] |= 1 << ((bit_cnt) % 8);
183 buffer[(bit_cnt)/8] &= ~(1 << ((bit_cnt) % 8));
187 /* TAP_SD & TAP_SI are illegal end states, so we always transition to the pause
188 * state which is a legal stable state from which statemove will work.
192 bitbang_interface->write(0, 0, 0);
193 bitbang_interface->write(1, 0, 0);
194 bitbang_interface->write(CLOCK_IDLE(), 0, 0);
201 if (cur_state != end_state)
202 bitbang_state_move();
205 int bitbang_execute_queue(void)
207 jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
213 if (!bitbang_interface)
215 LOG_ERROR("BUG: Bitbang interface called, but not yet initialized");
219 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
220 * that wasn't handled by a caller-provided error handler
224 if(bitbang_interface->blink)
225 bitbang_interface->blink(1);
232 #ifdef _DEBUG_JTAG_IO_
233 LOG_DEBUG("end_state: %i", cmd->cmd.end_state->end_state);
235 if (cmd->cmd.end_state->end_state != -1)
236 bitbang_end_state(cmd->cmd.end_state->end_state);
239 #ifdef _DEBUG_JTAG_IO_
240 LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
242 if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_reset_config & RESET_SRST_PULLS_TRST)))
246 bitbang_interface->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
249 #ifdef _DEBUG_JTAG_IO_
250 LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
252 if (cmd->cmd.runtest->end_state != -1)
253 bitbang_end_state(cmd->cmd.runtest->end_state);
254 bitbang_runtest(cmd->cmd.runtest->num_cycles);
257 #ifdef _DEBUG_JTAG_IO_
258 LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
260 if (cmd->cmd.statemove->end_state != -1)
261 bitbang_end_state(cmd->cmd.statemove->end_state);
262 bitbang_state_move();
265 #ifdef _DEBUG_JTAG_IO_
266 LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
268 bitbang_path_move(cmd->cmd.pathmove);
271 #ifdef _DEBUG_JTAG_IO_
272 LOG_DEBUG("%s scan end in %i", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", cmd->cmd.scan->end_state);
274 if (cmd->cmd.scan->end_state != -1)
275 bitbang_end_state(cmd->cmd.scan->end_state);
276 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
277 type = jtag_scan_type(cmd->cmd.scan);
278 bitbang_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
279 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
280 retval = ERROR_JTAG_QUEUE_FAILED;
285 #ifdef _DEBUG_JTAG_IO_
286 LOG_DEBUG("sleep %i", cmd->cmd.sleep->us);
288 jtag_sleep(cmd->cmd.sleep->us);
291 LOG_ERROR("BUG: unknown JTAG command type encountered");
296 if(bitbang_interface->blink)
297 bitbang_interface->blink(0);