gdb_server: ignore stray + in ACK mode
[openocd.git] / src / jtag / drivers / bitbang.c
1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
4 * *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
22 ***************************************************************************/
23
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27
28 #include "bitbang.h"
29 #include <jtag/interface.h>
30 #include <jtag/commands.h>
31
32 /**
33 * Function bitbang_stableclocks
34 * issues a number of clock cycles while staying in a stable state.
35 * Because the TMS value required to stay in the RESET state is a 1, whereas
36 * the TMS value required to stay in any of the other stable states is a 0,
37 * this function checks the current stable state to decide on the value of TMS
38 * to use.
39 */
40 static void bitbang_stableclocks(int num_cycles);
41
42 struct bitbang_interface *bitbang_interface;
43
44 /* DANGER!!!! clock absolutely *MUST* be 0 in idle or reset won't work!
45 *
46 * Set this to 1 and str912 reset halt will fail.
47 *
48 * If someone can submit a patch with an explanation it will be greatly
49 * appreciated, but as far as I can tell (ØH) DCLK is generated upon
50 * clk = 0 in TAP_IDLE. Good luck deducing that from the ARM documentation!
51 * The ARM documentation uses the term "DCLK is asserted while in the TAP_IDLE
52 * state". With hardware there is no such thing as *while* in a state. There
53 * are only edges. So clk => 0 is in fact a very subtle state transition that
54 * happens *while* in the TAP_IDLE state. "#&¤"#¤&"#&"#&
55 *
56 * For "reset halt" the last thing that happens before srst is asserted
57 * is that the breakpoint is set up. If DCLK is not wiggled one last
58 * time before the reset, then the breakpoint is not set up and
59 * "reset halt" will fail to halt.
60 *
61 */
62 #define CLOCK_IDLE() 0
63
64 /* The bitbang driver leaves the TCK 0 when in idle */
65 static void bitbang_end_state(tap_state_t state)
66 {
67 if (tap_is_state_stable(state))
68 tap_set_end_state(state);
69 else {
70 LOG_ERROR("BUG: %i is not a valid end state", state);
71 exit(-1);
72 }
73 }
74
75 static void bitbang_state_move(int skip)
76 {
77 int i = 0, tms = 0;
78 uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
79 int tms_count = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
80
81 for (i = skip; i < tms_count; i++) {
82 tms = (tms_scan >> i) & 1;
83 bitbang_interface->write(0, tms, 0);
84 bitbang_interface->write(1, tms, 0);
85 }
86 bitbang_interface->write(CLOCK_IDLE(), tms, 0);
87
88 tap_set_state(tap_get_end_state());
89 }
90
91 /**
92 * Clock a bunch of TMS (or SWDIO) transitions, to change the JTAG
93 * (or SWD) state machine.
94 */
95 static int bitbang_execute_tms(struct jtag_command *cmd)
96 {
97 unsigned num_bits = cmd->cmd.tms->num_bits;
98 const uint8_t *bits = cmd->cmd.tms->bits;
99
100 DEBUG_JTAG_IO("TMS: %d bits", num_bits);
101
102 int tms = 0;
103 for (unsigned i = 0; i < num_bits; i++) {
104 tms = ((bits[i/8] >> (i % 8)) & 1);
105 bitbang_interface->write(0, tms, 0);
106 bitbang_interface->write(1, tms, 0);
107 }
108 bitbang_interface->write(CLOCK_IDLE(), tms, 0);
109
110 return ERROR_OK;
111 }
112
113 static void bitbang_path_move(struct pathmove_command *cmd)
114 {
115 int num_states = cmd->num_states;
116 int state_count;
117 int tms = 0;
118
119 state_count = 0;
120 while (num_states) {
121 if (tap_state_transition(tap_get_state(), false) == cmd->path[state_count])
122 tms = 0;
123 else if (tap_state_transition(tap_get_state(), true) == cmd->path[state_count])
124 tms = 1;
125 else {
126 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition",
127 tap_state_name(tap_get_state()),
128 tap_state_name(cmd->path[state_count]));
129 exit(-1);
130 }
131
132 bitbang_interface->write(0, tms, 0);
133 bitbang_interface->write(1, tms, 0);
134
135 tap_set_state(cmd->path[state_count]);
136 state_count++;
137 num_states--;
138 }
139
140 bitbang_interface->write(CLOCK_IDLE(), tms, 0);
141
142 tap_set_end_state(tap_get_state());
143 }
144
145 static void bitbang_runtest(int num_cycles)
146 {
147 int i;
148
149 tap_state_t saved_end_state = tap_get_end_state();
150
151 /* only do a state_move when we're not already in IDLE */
152 if (tap_get_state() != TAP_IDLE) {
153 bitbang_end_state(TAP_IDLE);
154 bitbang_state_move(0);
155 }
156
157 /* execute num_cycles */
158 for (i = 0; i < num_cycles; i++) {
159 bitbang_interface->write(0, 0, 0);
160 bitbang_interface->write(1, 0, 0);
161 }
162 bitbang_interface->write(CLOCK_IDLE(), 0, 0);
163
164 /* finish in end_state */
165 bitbang_end_state(saved_end_state);
166 if (tap_get_state() != tap_get_end_state())
167 bitbang_state_move(0);
168 }
169
170 static void bitbang_stableclocks(int num_cycles)
171 {
172 int tms = (tap_get_state() == TAP_RESET ? 1 : 0);
173 int i;
174
175 /* send num_cycles clocks onto the cable */
176 for (i = 0; i < num_cycles; i++) {
177 bitbang_interface->write(1, tms, 0);
178 bitbang_interface->write(0, tms, 0);
179 }
180 }
181
182 static void bitbang_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size)
183 {
184 tap_state_t saved_end_state = tap_get_end_state();
185 int bit_cnt;
186
187 if (!((!ir_scan &&
188 (tap_get_state() == TAP_DRSHIFT)) ||
189 (ir_scan && (tap_get_state() == TAP_IRSHIFT)))) {
190 if (ir_scan)
191 bitbang_end_state(TAP_IRSHIFT);
192 else
193 bitbang_end_state(TAP_DRSHIFT);
194
195 bitbang_state_move(0);
196 bitbang_end_state(saved_end_state);
197 }
198
199 for (bit_cnt = 0; bit_cnt < scan_size; bit_cnt++) {
200 int val = 0;
201 int tms = (bit_cnt == scan_size-1) ? 1 : 0;
202 int tdi;
203 int bytec = bit_cnt/8;
204 int bcval = 1 << (bit_cnt % 8);
205
206 /* if we're just reading the scan, but don't care about the output
207 * default to outputting 'low', this also makes valgrind traces more readable,
208 * as it removes the dependency on an uninitialised value
209 */
210 tdi = 0;
211 if ((type != SCAN_IN) && (buffer[bytec] & bcval))
212 tdi = 1;
213
214 bitbang_interface->write(0, tms, tdi);
215
216 if (type != SCAN_OUT)
217 val = bitbang_interface->read();
218
219 bitbang_interface->write(1, tms, tdi);
220
221 if (type != SCAN_OUT) {
222 if (val)
223 buffer[bytec] |= bcval;
224 else
225 buffer[bytec] &= ~bcval;
226 }
227 }
228
229 if (tap_get_state() != tap_get_end_state()) {
230 /* we *KNOW* the above loop transitioned out of
231 * the shift state, so we skip the first state
232 * and move directly to the end state.
233 */
234 bitbang_state_move(1);
235 }
236 }
237
238 int bitbang_execute_queue(void)
239 {
240 struct jtag_command *cmd = jtag_command_queue; /* currently processed command */
241 int scan_size;
242 enum scan_type type;
243 uint8_t *buffer;
244 int retval;
245
246 if (!bitbang_interface) {
247 LOG_ERROR("BUG: Bitbang interface called, but not yet initialized");
248 exit(-1);
249 }
250
251 /* return ERROR_OK, unless a jtag_read_buffer returns a failed check
252 * that wasn't handled by a caller-provided error handler
253 */
254 retval = ERROR_OK;
255
256 if (bitbang_interface->blink)
257 bitbang_interface->blink(1);
258
259 while (cmd) {
260 switch (cmd->type) {
261 case JTAG_RESET:
262 #ifdef _DEBUG_JTAG_IO_
263 LOG_DEBUG("reset trst: %i srst %i",
264 cmd->cmd.reset->trst,
265 cmd->cmd.reset->srst);
266 #endif
267 if ((cmd->cmd.reset->trst == 1) ||
268 (cmd->cmd.reset->srst && (jtag_get_reset_config() & RESET_SRST_PULLS_TRST)))
269 tap_set_state(TAP_RESET);
270 bitbang_interface->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
271 break;
272 case JTAG_RUNTEST:
273 #ifdef _DEBUG_JTAG_IO_
274 LOG_DEBUG("runtest %i cycles, end in %s",
275 cmd->cmd.runtest->num_cycles,
276 tap_state_name(cmd->cmd.runtest->end_state));
277 #endif
278 bitbang_end_state(cmd->cmd.runtest->end_state);
279 bitbang_runtest(cmd->cmd.runtest->num_cycles);
280 break;
281
282 case JTAG_STABLECLOCKS:
283 /* this is only allowed while in a stable state. A check for a stable
284 * state was done in jtag_add_clocks()
285 */
286 bitbang_stableclocks(cmd->cmd.stableclocks->num_cycles);
287 break;
288
289 case JTAG_TLR_RESET:
290 #ifdef _DEBUG_JTAG_IO_
291 LOG_DEBUG("statemove end in %s",
292 tap_state_name(cmd->cmd.statemove->end_state));
293 #endif
294 bitbang_end_state(cmd->cmd.statemove->end_state);
295 bitbang_state_move(0);
296 break;
297 case JTAG_PATHMOVE:
298 #ifdef _DEBUG_JTAG_IO_
299 LOG_DEBUG("pathmove: %i states, end in %s",
300 cmd->cmd.pathmove->num_states,
301 tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]));
302 #endif
303 bitbang_path_move(cmd->cmd.pathmove);
304 break;
305 case JTAG_SCAN:
306 #ifdef _DEBUG_JTAG_IO_
307 LOG_DEBUG("%s scan end in %s",
308 (cmd->cmd.scan->ir_scan) ? "IR" : "DR",
309 tap_state_name(cmd->cmd.scan->end_state));
310 #endif
311 bitbang_end_state(cmd->cmd.scan->end_state);
312 scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
313 type = jtag_scan_type(cmd->cmd.scan);
314 bitbang_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
315 if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
316 retval = ERROR_JTAG_QUEUE_FAILED;
317 if (buffer)
318 free(buffer);
319 break;
320 case JTAG_SLEEP:
321 #ifdef _DEBUG_JTAG_IO_
322 LOG_DEBUG("sleep %" PRIi32, cmd->cmd.sleep->us);
323 #endif
324 jtag_sleep(cmd->cmd.sleep->us);
325 break;
326 case JTAG_TMS:
327 retval = bitbang_execute_tms(cmd);
328 break;
329 default:
330 LOG_ERROR("BUG: unknown JTAG command type encountered");
331 exit(-1);
332 }
333 cmd = cmd->next;
334 }
335 if (bitbang_interface->blink)
336 bitbang_interface->blink(0);
337
338 return retval;
339 }

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)