1 /***************************************************************************
2 * Copyright (C) 2007 by Pavel Chromy *
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 bitq_interface_t
* bitq_interface
; /* low level bit queue interface */
39 bitq_state_t bitq_in_state
; /* state of input queue */
41 u8
* bitq_in_buffer
; /* buffer dynamically reallocated as needed */
42 unsigned long bitq_in_bufsize
= 32; /* min. buffer size */
45 * input queue processing does not use jtag_read_buffer() to avoid unnecessary overhead
46 * also the buffer for incomming data is reallocated only if necessary
47 * no parameters, makes use of stored state information
49 void bitq_in_proc(void)
51 /* static information preserved between calls to increase performance */
52 static u8
* in_buff
; /* pointer to buffer for scanned data */
53 static int in_idx
; /* index of byte being scanned */
54 static u8 in_mask
; /* mask of next bit to be scanned */
59 /* loop through the queue */
60 while (bitq_in_state
.cmd
)
62 /* only JTAG_SCAN command may return data */
63 if (bitq_in_state
.cmd
->type
==JTAG_SCAN
)
65 /* loop through the fields */
66 while (bitq_in_state
.field_idx
<bitq_in_state
.cmd
->cmd
.scan
->num_fields
)
68 field
= &bitq_in_state
.cmd
->cmd
.scan
->fields
[bitq_in_state
.field_idx
];
69 if (field
->in_value
|| field
->in_handler
)
71 if (bitq_in_state
.bit_pos
==0)
73 /* initialize field scanning */
77 in_buff
= field
->in_value
;
80 /* buffer reallocation needed? */
81 if (field
->num_bits
>bitq_in_bufsize
* 8)
83 /* buffer previously allocated? */
84 if (bitq_in_buffer
!=NULL
)
88 bitq_in_buffer
= NULL
;
90 /* double the buffer size until it fits */
91 while (field
->num_bits
>bitq_in_bufsize
* 8)
94 /* if necessary, allocate buffer and check for malloc error */
95 if (bitq_in_buffer
==NULL
&& ( bitq_in_buffer
= malloc(bitq_in_bufsize
) )==NULL
)
97 LOG_ERROR("malloc error");
100 in_buff
= (void*) bitq_in_buffer
;
105 while (bitq_in_state
.bit_pos
<field
->num_bits
)
107 if ( ( tdo
= bitq_interface
->in() )<0 )
109 #ifdef _DEBUG_JTAG_IO_
110 LOG_DEBUG("bitq in EOF");
117 in_buff
[in_idx
] |= in_mask
;
125 bitq_in_state
.bit_pos
++;
129 if (field
->in_handler
&& bitq_in_state
.status
==ERROR_OK
)
131 bitq_in_state
.status
= (*field
->in_handler
)(in_buff
, field
->in_handler_priv
, field
);
135 bitq_in_state
.field_idx
++; /* advance to next field */
136 bitq_in_state
.bit_pos
= 0; /* start next field from the first bit */
139 bitq_in_state
.cmd
= bitq_in_state
.cmd
->next
; /* advance to next command */
140 bitq_in_state
.field_idx
= 0; /* preselect first field */
145 void bitq_io(int tms
, int tdi
, int tdo_req
)
147 bitq_interface
->out(tms
, tdi
, tdo_req
);
148 /* check and process the input queue */
149 if ( bitq_interface
->in_rdy() )
154 void bitq_end_state(tap_state_t state
)
159 if (!tap_is_state_stable(state
))
161 LOG_ERROR("BUG: %i is not a valid end state", state
);
164 tap_set_end_state(state
);
168 void bitq_state_move(tap_state_t new_state
)
173 if (!tap_is_state_stable(tap_get_state()) || !tap_is_state_stable(new_state
))
175 LOG_ERROR("TAP move from or to unstable state");
179 tms_scan
= tap_get_tms_path(tap_get_state(), new_state
);
181 for (i
= 0; i
<7; i
++)
183 bitq_io(tms_scan
& 1, 0, 0);
187 tap_set_state(new_state
);
191 void bitq_path_move(pathmove_command_t
* cmd
)
195 for (i
= 0; i
<=cmd
->num_states
; i
++)
197 if (tap_state_transition(tap_get_state(), FALSE
) == cmd
->path
[i
])
199 else if (tap_state_transition(tap_get_state(), TRUE
) == cmd
->path
[i
])
203 LOG_ERROR( "BUG: %s -> %s isn't a valid TAP transition", tap_state_name(
204 tap_get_state() ), tap_state_name(cmd
->path
[i
]) );
208 tap_set_state(cmd
->path
[i
]);
211 tap_set_end_state( tap_get_state() );
215 void bitq_runtest(int num_cycles
)
219 /* only do a state_move when we're not already in IDLE */
220 if (tap_get_state() != TAP_IDLE
)
221 bitq_state_move(TAP_IDLE
);
223 /* execute num_cycles */
224 for (i
= 0; i
< num_cycles
; i
++)
227 /* finish in end_state */
228 if ( tap_get_state() != tap_get_end_state() )
229 bitq_state_move( tap_get_end_state() );
233 void bitq_scan_field(scan_field_t
* field
, int pause
)
241 if (field
->in_value
|| field
->in_handler
)
246 if (field
->out_value
==NULL
)
248 /* just send zeros and request data from TDO */
249 for (bit_cnt
= field
->num_bits
; bit_cnt
>1; bit_cnt
--)
250 bitq_io(0, 0, tdo_req
);
252 bitq_io(pause
, 0, tdo_req
);
256 /* send data, and optionally request TDO */
258 out_ptr
= field
->out_value
;
259 for (bit_cnt
= field
->num_bits
; bit_cnt
>1; bit_cnt
--)
261 bitq_io(0, ( (*out_ptr
) & out_mask
)!=0, tdo_req
);
271 bitq_io(pause
, ( (*out_ptr
) & out_mask
)!=0, tdo_req
);
277 if (tap_get_state()==TAP_IRSHIFT
)
278 tap_set_state(TAP_IRPAUSE
);
279 else if (tap_get_state()==TAP_DRSHIFT
)
280 tap_set_state(TAP_DRPAUSE
);
285 void bitq_scan(scan_command_t
* cmd
)
290 bitq_state_move(TAP_IRSHIFT
);
292 bitq_state_move(TAP_DRSHIFT
);
294 for (i
= 0; i
< cmd
->num_fields
- 1; i
++)
295 bitq_scan_field(&cmd
->fields
[i
], 0);
297 bitq_scan_field(&cmd
->fields
[i
], 1);
301 int bitq_execute_queue(void)
303 jtag_command_t
* cmd
= jtag_command_queue
; /* currently processed command */
305 bitq_in_state
.cmd
= jtag_command_queue
;
306 bitq_in_state
.field_idx
= 0;
307 bitq_in_state
.bit_pos
= 0;
308 bitq_in_state
.status
= ERROR_OK
;
315 #ifdef _DEBUG_JTAG_IO_
316 LOG_DEBUG("end_state: %i", cmd
->cmd
.end_state
->end_state
);
318 bitq_end_state(cmd
->cmd
.end_state
->end_state
);
322 #ifdef _DEBUG_JTAG_IO_
323 LOG_DEBUG("reset trst: %i srst %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
325 if ( (cmd
->cmd
.reset
->trst
== 1) || ( cmd
->cmd
.reset
->srst
&& (jtag_reset_config
& RESET_SRST_PULLS_TRST
) ) )
327 tap_set_state(TAP_RESET
);
329 bitq_interface
->reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
330 if ( bitq_interface
->in_rdy() )
335 #ifdef _DEBUG_JTAG_IO_
336 LOG_DEBUG("runtest %i cycles, end in %i", cmd
->cmd
.runtest
->num_cycles
, cmd
->cmd
.runtest
->end_state
);
338 bitq_end_state(cmd
->cmd
.runtest
->end_state
);
339 bitq_runtest(cmd
->cmd
.runtest
->num_cycles
);
343 #ifdef _DEBUG_JTAG_IO_
344 LOG_DEBUG("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
346 bitq_end_state(cmd
->cmd
.statemove
->end_state
);
347 bitq_state_move( tap_get_end_state() ); /* uncoditional TAP move */
351 #ifdef _DEBUG_JTAG_IO_
352 LOG_DEBUG("pathmove: %i states, end in %i", cmd
->cmd
.pathmove
->num_states
,
353 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
355 bitq_path_move(cmd
->cmd
.pathmove
);
359 #ifdef _DEBUG_JTAG_IO_
360 LOG_DEBUG("scan end in %i", cmd
->cmd
.scan
->end_state
);
361 if (cmd
->cmd
.scan
->ir_scan
)
362 LOG_DEBUG("scan ir");
364 LOG_DEBUG("scan dr");
366 bitq_end_state(cmd
->cmd
.scan
->end_state
);
367 bitq_scan(cmd
->cmd
.scan
);
368 if ( tap_get_state() != tap_get_end_state() )
369 bitq_state_move( tap_get_end_state() );
373 #ifdef _DEBUG_JTAG_IO_
374 LOG_DEBUG("sleep %i", cmd
->cmd
.sleep
->us
);
376 bitq_interface
->sleep(cmd
->cmd
.sleep
->us
);
377 if ( bitq_interface
->in_rdy() )
382 LOG_ERROR("BUG: unknown JTAG command type encountered");
389 bitq_interface
->flush();
392 if (bitq_in_state
.cmd
)
394 LOG_ERROR("missing data from bitq interface");
395 return ERROR_JTAG_QUEUE_FAILED
;
397 if (bitq_interface
->in()>=0)
399 LOG_ERROR("extra data from bitq interface");
400 return ERROR_JTAG_QUEUE_FAILED
;
403 return bitq_in_state
.status
;
407 void bitq_cleanup(void)
409 if (bitq_in_buffer
!=NULL
)
411 free(bitq_in_buffer
);
412 bitq_in_buffer
= NULL
;
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)