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"
40 bitbang_interface_t *bitbang_interface;
42 int bitbang_execute_queue(void);
44 /* The bitbang driver leaves the TCK 0 when in idle */
46 static enum tap_state end_state;
47 static enum tap_state cur_state;
49 void bitbang_end_state(enum tap_state state)
51 if (tap_move_map[state] != -1)
55 LOG_ERROR("BUG: %i is not a valid end state", state);
60 void bitbang_state_move(void) {
63 u8 tms_scan = TAP_MOVE(cur_state, end_state);
65 for (i = 0; i < 7; i++)
67 tms = (tms_scan >> i) & 1;
68 bitbang_interface->write(0, tms, 0);
69 bitbang_interface->write(1, tms, 0);
71 bitbang_interface->write(0, tms, 0);
73 cur_state = end_state;
76 void bitbang_path_move(pathmove_command_t *cmd)
78 int num_states = cmd->num_states;
85 if (tap_transitions[cur_state].low == cmd->path[state_count])
89 else if (tap_transitions[cur_state].high == cmd->path[state_count])
95 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[state_count]]);
99 bitbang_interface->write(0, tms, 0);
100 bitbang_interface->write(1, tms, 0);
102 cur_state = cmd->path[state_count];
107 bitbang_interface->write(0, tms, 0);
109 end_state = cur_state;
112 void bitbang_runtest(int num_cycles)
116 enum tap_state saved_end_state = end_state;
118 /* only do a state_move when we're not already in RTI */
119 if (cur_state != TAP_RTI)
121 bitbang_end_state(TAP_RTI);
122 bitbang_state_move();
125 /* execute num_cycles */
126 bitbang_interface->write(0, 0, 0);
127 for (i = 0; i < num_cycles; i++)
129 bitbang_interface->write(1, 0, 0);
130 bitbang_interface->write(0, 0, 0);
133 /* finish in end_state */
134 bitbang_end_state(saved_end_state);
135 if (cur_state != end_state)
136 bitbang_state_move();
139 void bitbang_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)
141 enum tap_state saved_end_state = end_state;
144 if (!((!ir_scan && (cur_state == TAP_SD)) || (ir_scan && (cur_state == TAP_SI))))
147 bitbang_end_state(TAP_SI);
149 bitbang_end_state(TAP_SD);
151 bitbang_state_move();
152 bitbang_end_state(saved_end_state);
155 for (bit_cnt = 0; bit_cnt < scan_size; bit_cnt++)
157 /* if we're just reading the scan, but don't care about the output
158 * default to outputting 'low', this also makes valgrind traces more readable,
159 * as it removes the dependency on an uninitialised value
161 if ((type != SCAN_IN) && ((buffer[bit_cnt/8] >> (bit_cnt % 8)) & 0x1))
163 bitbang_interface->write(0, (bit_cnt==scan_size-1) ? 1 : 0, 1);
164 bitbang_interface->write(1, (bit_cnt==scan_size-1) ? 1 : 0, 1);
166 bitbang_interface->write(0, (bit_cnt==scan_size-1) ? 1 : 0, 0);
167 bitbang_interface->write(1, (bit_cnt==scan_size-1) ? 1 : 0, 0);
170 if (type != SCAN_OUT)
173 TDO should be sampled on the rising edge, and will change
176 Because there is no way to read the signal exactly at the rising edge,
177 read after the rising edge.
179 This is plain IEEE 1149 JTAG - nothing specific to the OpenOCD or its JTAG
182 if (bitbang_interface->read())
183 buffer[(bit_cnt)/8] |= 1 << ((bit_cnt) % 8);
185 buffer[(bit_cnt)/8] &= ~(1 << ((bit_cnt) % 8));
189 /* TAP_SD & TAP_SI are illegal end states, so we always transition to the pause
190 * state which is a legal stable state from which statemove will work.
194 bitbang_interface->write(0, 0, 0);
195 bitbang_interface->write(1, 0, 0);
196 bitbang_interface->write(0, 0, 0);
203 if (cur_state != end_state)
204 bitbang_state_move();
207 int bitbang_execute_queue(void)
209 jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
215 if (!bitbang_interface)
217 LOG_ERROR("BUG: Bitbang interface called, but not yet initialized");
221 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
222 * that wasn't handled by a caller-provided error handler
226 if(bitbang_interface->blink)
227 bitbang_interface->blink(1);
234 #ifdef _DEBUG_JTAG_IO_
235 LOG_DEBUG("end_state: %i", cmd->cmd.end_state->end_state);
237 if (cmd->cmd.end_state->end_state != -1)
238 bitbang_end_state(cmd->cmd.end_state->end_state);
241 #ifdef _DEBUG_JTAG_IO_
242 LOG_DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
244 if ((cmd->cmd.reset->trst == 1) || (cmd->cmd.reset->srst && (jtag_reset_config & RESET_SRST_PULLS_TRST)))
248 bitbang_interface->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
251 #ifdef _DEBUG_JTAG_IO_
252 LOG_DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
254 if (cmd->cmd.runtest->end_state != -1)
255 bitbang_end_state(cmd->cmd.runtest->end_state);
256 bitbang_runtest(cmd->cmd.runtest->num_cycles);
259 #ifdef _DEBUG_JTAG_IO_
260 LOG_DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
262 if (cmd->cmd.statemove->end_state != -1)
263 bitbang_end_state(cmd->cmd.statemove->end_state);
264 bitbang_state_move();
267 #ifdef _DEBUG_JTAG_IO_
268 LOG_DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
270 bitbang_path_move(cmd->cmd.pathmove);
273 #ifdef _DEBUG_JTAG_IO_
274 LOG_DEBUG("%s scan end in %i", (cmd->cmd.scan->ir_scan) ? "IR" : "DR", cmd->cmd.scan->end_state);
276 if (cmd->cmd.scan->end_state != -1)
277 bitbang_end_state(cmd->cmd.scan->end_state);
278 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
279 type = jtag_scan_type(cmd->cmd.scan);
280 bitbang_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
281 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
282 retval = ERROR_JTAG_QUEUE_FAILED;
287 #ifdef _DEBUG_JTAG_IO_
288 LOG_DEBUG("sleep %i", cmd->cmd.sleep->us);
290 jtag_sleep(cmd->cmd.sleep->us);
293 LOG_ERROR("BUG: unknown JTAG command type encountered");
298 if(bitbang_interface->blink)
299 bitbang_interface->blink(0);