1 /***************************************************************************
2 * Copyright (C) 2005 by Dominic Rath *
3 * Dominic.Rath@gmx.de *
5 * Copyright (C) 2007,2008 Øyvind Harboe *
6 * oyvind.harboe@zylin.com *
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. *
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. *
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 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
26 #include "binarybuffer.h"
30 #ifdef _DEBUG_JTAG_IO_
31 #define DEBUG_JTAG_IO(expr ...) LOG_DEBUG(expr)
33 #define DEBUG_JTAG_IO(expr ...)
36 #ifndef DEBUG_JTAG_IOZ
37 #define DEBUG_JTAG_IOZ 64
40 /*-----<Macros>--------------------------------------------------*/
42 /** When given an array, compute its DIMension, i.e. number of elements in the array */
43 #define DIM(x) (sizeof(x)/sizeof((x)[0]))
45 /** Calculate the number of bytes required to hold @a n TAP scan bits */
46 #define TAP_SCAN_BYTES(n) CEIL(n, 8)
48 /*-----</Macros>-------------------------------------------------*/
53 * Tap states from ARM7TDMI-S Technical reference manual.
54 * Also, validated against several other ARM core technical manuals.
56 * N.B. tap_get_tms_path() was changed to reflect this corrected
57 * numbering and ordering of the TAP states.
59 * DANGER!!!! some interfaces care about the actual numbers used
60 * as they are handed off directly to hardware implementations.
63 typedef enum tap_state
66 /* These are the old numbers. Leave as-is for now... */
67 TAP_RESET
= 0, TAP_IDLE
= 8,
68 TAP_DRSELECT
= 1, TAP_DRCAPTURE
= 2, TAP_DRSHIFT
= 3, TAP_DREXIT1
= 4,
69 TAP_DRPAUSE
= 5, TAP_DREXIT2
= 6, TAP_DRUPDATE
= 7,
70 TAP_IRSELECT
= 9, TAP_IRCAPTURE
= 10, TAP_IRSHIFT
= 11, TAP_IREXIT1
= 12,
71 TAP_IRPAUSE
= 13, TAP_IREXIT2
= 14, TAP_IRUPDATE
= 15,
73 TAP_NUM_STATES
= 16, TAP_INVALID
= -1,
75 /* Proper ARM recommended numbers */
93 TAP_NUM_STATES
= 0x10,
99 typedef struct tap_transition_s
105 //extern tap_transition_t tap_transitions[16]; /* describe the TAP state diagram */
108 #ifdef INCLUDE_JTAG_INTERFACE_H
110 /*-----<Cable Helper API>-------------------------------------------*/
112 /* The "Cable Helper API" is what the cable drivers can use to help implement
113 * their "Cable API". So a Cable Helper API is a set of helper functions used by
114 * cable drivers, and this is different from a Cable API. A "Cable API" is what
115 * higher level code used to talk to a cable.
119 /** implementation of wrapper function tap_set_state() */
120 void tap_set_state_impl(tap_state_t new_state
);
123 * Function tap_set_state
124 * sets the state of a "state follower" which tracks the state of the TAPs connected to the
125 * cable. The state follower is hopefully always in the same state as the actual
126 * TAPs in the jtag chain, and will be so if there are no bugs in the tracking logic within that
127 * cable driver. All the cable drivers call this function to indicate the state they think
128 * the TAPs attached to their cables are in. Because this function can also log transitions,
129 * it will be helpful to call this function with every transition that the TAPs being manipulated
130 * are expected to traverse, not just end points of a multi-step state path.
131 * @param new_state is the state we think the TAPs are currently in or are about to enter.
133 #if defined(_DEBUG_JTAG_IO_)
134 #define tap_set_state(new_state) \
136 LOG_DEBUG( "tap_set_state(%s)", tap_state_name(new_state) ); \
137 tap_set_state_impl(new_state); \
140 static inline void tap_set_state(tap_state_t new_state
)
142 tap_set_state_impl(new_state
);
148 * Function tap_get_state
149 * gets the state of the "state follower" which tracks the state of the TAPs connected to
152 * @return tap_state_t - The state the TAPs are in now.
154 tap_state_t
tap_get_state(void);
157 * Function tap_set_end_state
158 * sets the state of an "end state follower" which tracks the state that any cable driver
159 * thinks will be the end (resultant) state of the current TAP SIR or SDR operation. At completion
160 * of that TAP operation this value is copied into the state follower via tap_set_state().
161 * @param new_end_state is that state the TAPs should enter at completion of a pending TAP operation.
163 void tap_set_end_state(tap_state_t new_end_state
);
166 * Function tap_get_end_state
167 * @see tap_set_end_state
168 * @return tap_state_t - The state the TAPs should be in at completion of the current TAP operation.
170 tap_state_t
tap_get_end_state(void);
173 * Function tap_get_tms_path
174 * returns a 7 bit long "bit sequence" indicating what has to be done with TMS
175 * during a sequence of seven TAP clock cycles in order to get from
176 * state \a "from" to state \a "to".
177 * @param from is the starting state
178 * @param to is the resultant or final state
179 * @return int - a 7 bit sequence, with the first bit in the sequence at bit 0.
181 int tap_get_tms_path(tap_state_t from
, tap_state_t to
);
185 * Function int tap_get_tms_path_len
186 * returns the total number of bits that represents a TMS path
187 * transition as given by the function tap_get_tms_path().
189 * For at least one interface (JLink) it's not OK to simply "pad" TMS sequences
190 * to fit a whole byte. (I suspect this is a general TAP problem within OOCD.)
191 * Padding TMS causes all manner of instability that's not easily
192 * discovered. Using this routine we can apply EXACTLY the state transitions
193 * required to make something work - no more - no less.
195 * @param from is the starting state
196 * @param to is the resultant or final state
197 * @return int - the total number of bits in a transition.
199 int tap_get_tms_path_len(tap_state_t from
, tap_state_t to
);
203 * Function tap_move_ndx
204 * when given a stable state, returns an index from 0-5. The index corresponds to a
205 * sequence of stable states which are given in this order: <p>
206 * { TAP_RESET, TAP_IDLE, TAP_DRSHIFT, TAP_DRPAUSE, TAP_IRSHIFT, TAP_IRPAUSE }
208 * This sequence corresponds to look up tables which are used in some of the
210 * @param astate is the stable state to find in the sequence. If a non stable
211 * state is passed, this may cause the program to output an error message
213 * @return int - the array (or sequence) index as described above
215 int tap_move_ndx(tap_state_t astate
);
218 * Function tap_is_state_stable
219 * returns true if the \a astate is stable.
221 bool tap_is_state_stable(tap_state_t astate
);
224 * Function tap_state_transition
225 * takes a current TAP state and returns the next state according to the tms value.
226 * @param current_state is the state of a TAP currently.
227 * @param tms is either zero or non-zero, just like a real TMS line in a jtag interface.
228 * @return tap_state_t - the next state a TAP would enter.
230 tap_state_t
tap_state_transition(tap_state_t current_state
, bool tms
);
233 * Function tap_state_name
234 * Returns a string suitable for display representing the JTAG tap_state
236 const char* tap_state_name(tap_state_t state
);
238 #ifdef _DEBUG_JTAG_IO_
240 * @brief Prints verbose TAP state transitions for the given TMS/TDI buffers.
241 * @param tms_buf must points to a buffer containing the TMS bitstream.
242 * @param tdi_buf must points to a buffer containing the TDI bitstream.
243 * @param tap_len must specify the length of the TMS/TDI bitstreams.
244 * @param start_tap_state must specify the current TAP state.
245 * @returns the final TAP state; pass as @a start_tap_state in following call.
247 tap_state_t
jtag_debug_state_machine(const void *tms_buf
, const void *tdi_buf
,
248 unsigned tap_len
, tap_state_t start_tap_state
);
250 static inline tap_state_t
jtag_debug_state_machine(const void *tms_buf
,
251 const void *tdi_buf
, unsigned tap_len
, tap_state_t start_tap_state
)
253 return start_tap_state
;
255 #endif // _DEBUG_JTAG_IO_
257 /*-----</Cable Helper API>------------------------------------------*/
259 #endif // INCLUDE_JTAG_INTERFACE_H
262 extern tap_state_t cmd_queue_end_state
; /* finish DR scans in dr_end_state */
263 extern tap_state_t cmd_queue_cur_state
; /* current TAP state */
265 typedef struct scan_field_s
267 jtag_tap_t
* tap
; /* tap pointer this instruction refers to */
268 int num_bits
; /* number of bits this field specifies (up to 32) */
269 u8
* out_value
; /* value to be scanned into the device */
270 u8
* in_value
; /* pointer to a 32-bit memory location to take data scanned out */
272 u8
* check_value
; /* Used together with jtag_add_dr_scan_check() to check data clocked
274 u8
* check_mask
; /* mask to go with check_value */
276 /* internal work space */
277 int allocated
; /* in_value has been allocated for the queue */
278 int modified
; /* did we modify the in_value? */
279 u8 intmp
[4]; /* temporary storage for checking synchronously */
282 #ifdef INCLUDE_JTAG_INTERFACE_H
285 /* IN: from device to host, OUT: from host to device */
286 SCAN_IN
= 1, SCAN_OUT
= 2, SCAN_IO
= 3
289 typedef struct scan_command_s
291 bool ir_scan
; /* instruction/not data scan */
292 int num_fields
; /* number of fields in *fields array */
293 scan_field_t
* fields
; /* pointer to an array of data scan fields */
294 tap_state_t end_state
; /* TAP state in which JTAG commands should finish */
297 typedef struct statemove_command_s
299 tap_state_t end_state
; /* TAP state in which JTAG commands should finish */
300 } statemove_command_t
;
302 typedef struct pathmove_command_s
304 int num_states
; /* number of states in *path */
305 tap_state_t
* path
; /* states that have to be passed */
306 } pathmove_command_t
;
308 typedef struct runtest_command_s
310 int num_cycles
; /* number of cycles that should be spent in Run-Test/Idle */
311 tap_state_t end_state
; /* TAP state in which JTAG commands should finish */
315 typedef struct stableclocks_command_s
317 int num_cycles
; /* number of clock cycles that should be sent */
318 } stableclocks_command_t
;
321 typedef struct reset_command_s
323 int trst
; /* trst/srst 0: deassert, 1: assert, -1: don't change */
327 typedef struct end_state_command_s
329 tap_state_t end_state
; /* TAP state in which JTAG commands should finish */
330 } end_state_command_t
;
332 typedef struct sleep_command_s
334 u32 us
; /* number of microseconds to sleep */
337 typedef union jtag_command_container_u
339 scan_command_t
* scan
;
340 statemove_command_t
* statemove
;
341 pathmove_command_t
* pathmove
;
342 runtest_command_t
* runtest
;
343 stableclocks_command_t
* stableclocks
;
344 reset_command_t
* reset
;
345 end_state_command_t
* end_state
;
346 sleep_command_t
* sleep
;
347 } jtag_command_container_t
;
349 enum jtag_command_type
{
356 JTAG_STABLECLOCKS
= 8
359 typedef struct jtag_command_s
361 jtag_command_container_t cmd
;
362 enum jtag_command_type type
;
363 struct jtag_command_s
* next
;
366 extern jtag_command_t
* jtag_command_queue
;
368 #endif // INCLUDE_JTAG_INTERFACE_H
370 /* forward declaration */
371 typedef struct jtag_tap_event_action_s jtag_tap_event_action_t
;
373 /* this is really: typedef jtag_tap_t */
374 /* But - the typedef is done in "types.h" */
375 /* due to "forward decloration reasons" */
380 const char* dotted_name
;
381 int abs_chain_position
;
383 int ir_length
; /* size of instruction register */
384 u32 ir_capture_value
;
385 u8
* expected
; /* Capture-IR expected value */
387 u8
* expected_mask
; /* Capture-IR expected mask */
388 u32 idcode
; /* device identification code */
389 u32
* expected_ids
; /* Array of expected identification codes */
390 u8 expected_ids_cnt
; /* Number of expected identification codes */
391 u8
* cur_instr
; /* current instruction */
392 int bypass
; /* bypass register selected */
394 jtag_tap_event_action_t
* event_action
;
396 jtag_tap_t
* next_tap
;
398 extern jtag_tap_t
* jtag_AllTaps(void);
399 extern jtag_tap_t
* jtag_TapByPosition(int n
);
400 extern jtag_tap_t
* jtag_TapByString(const char* dotted_name
);
401 extern jtag_tap_t
* jtag_TapByJimObj(Jim_Interp
* interp
, Jim_Obj
* obj
);
402 extern jtag_tap_t
* jtag_TapByAbsPosition(int abs_position
);
403 extern int jtag_NumEnabledTaps(void);
404 extern int jtag_NumTotalTaps(void);
406 static __inline__ jtag_tap_t
* jtag_NextEnabledTap(jtag_tap_t
* p
)
410 /* start at the head of list */
415 /* start *after* this one */
434 enum reset_line_mode
{
435 LINE_OPEN_DRAIN
= 0x0,
436 LINE_PUSH_PULL
= 0x1,
439 #ifdef INCLUDE_JTAG_INTERFACE_H
441 typedef struct jtag_interface_s
445 /* queued command execution
447 int (*execute_queue
)(void);
449 /* interface initalization
451 int (*speed
)(int speed
);
452 int (*register_commands
)(struct command_context_s
* cmd_ctx
);
456 /* returns JTAG maxium speed for KHz. 0=RTCK. The function returns
457 * a failure if it can't support the KHz/RTCK.
459 * WARNING!!!! if RTCK is *slow* then think carefully about
460 * whether you actually want to support this in the driver.
461 * Many target scripts are written to handle the absence of RTCK
462 * and use a fallback kHz TCK.
464 int (*khz
)(int khz
, int* jtag_speed
);
466 /* returns the KHz for the provided JTAG speed. 0=RTCK. The function returns
467 * a failure if it can't support the KHz/RTCK. */
468 int (*speed_div
)(int speed
, int* khz
);
470 /* Read and clear the power dropout flag. Note that a power dropout
471 * can be transitionary, easily much less than a ms.
473 * So to find out if the power is *currently* on, you must invoke
474 * this method twice. Once to clear the power dropout flag and a
475 * second time to read the current state.
477 * Currently the default implementation is never to detect power dropout.
479 int (*power_dropout
)(int* power_dropout
);
481 /* Read and clear the srst asserted detection flag.
483 * NB!!!! like power_dropout this does *not* read the current
484 * state. srst assertion is transitionary and *can* be much
487 int (*srst_asserted
)(int* srst_asserted
);
490 #endif // INCLUDE_JTAG_INTERFACE_H
496 extern char* jtag_event_strings
[];
498 enum jtag_tap_event
{
499 JTAG_TAP_EVENT_ENABLE
,
500 JTAG_TAP_EVENT_DISABLE
503 extern const Jim_Nvp nvp_jtag_tap_event
[];
505 struct jtag_tap_event_action_s
507 enum jtag_tap_event event
;
509 jtag_tap_event_action_t
* next
;
512 extern int jtag_trst
;
513 extern int jtag_srst
;
515 typedef struct jtag_event_callback_s
517 int (*callback
)(enum jtag_event event
, void* priv
);
519 struct jtag_event_callback_s
* next
;
520 } jtag_event_callback_t
;
522 extern jtag_event_callback_t
* jtag_event_callbacks
;
524 extern int jtag_speed
;
525 extern int jtag_speed_post_reset
;
529 RESET_HAS_TRST
= 0x1,
530 RESET_HAS_SRST
= 0x2,
531 RESET_TRST_AND_SRST
= 0x3,
532 RESET_SRST_PULLS_TRST
= 0x4,
533 RESET_TRST_PULLS_SRST
= 0x8,
534 RESET_TRST_OPEN_DRAIN
= 0x10,
535 RESET_SRST_PUSH_PULL
= 0x20,
538 extern enum reset_types jtag_reset_config
;
540 /* initialize interface upon startup. A successful no-op
541 * upon subsequent invocations
543 extern int jtag_interface_init(struct command_context_s
* cmd_ctx
);
545 /// Shutdown the JTAG interface upon program exit.
546 extern int jtag_interface_quit(void);
548 /* initialize JTAG chain using only a RESET reset. If init fails,
551 extern int jtag_init(struct command_context_s
* cmd_ctx
);
553 /* reset, then initialize JTAG chain */
554 extern int jtag_init_reset(struct command_context_s
* cmd_ctx
);
555 extern int jtag_register_commands(struct command_context_s
* cmd_ctx
);
557 /* JTAG interface, can be implemented with a software or hardware fifo
559 * TAP_DRSHIFT and TAP_IRSHIFT are illegal end states. TAP_DRSHIFT/IRSHIFT as end states
560 * can be emulated by using a larger scan.
562 * Code that is relatively insensitive to the path(as long
563 * as it is JTAG compliant) taken through state machine can use
564 * endstate for jtag_add_xxx_scan(). Otherwise the pause state must be
565 * specified as end state and a subsequent jtag_add_pathmove() must
569 extern void jtag_add_ir_scan(int num_fields
, scan_field_t
* fields
, tap_state_t endstate
);
570 /* same as jtag_add_ir_scan except no verify is performed */
571 extern void jtag_add_ir_scan_noverify(int num_fields
, const scan_field_t
*fields
, tap_state_t state
);
572 extern void jtag_add_dr_scan(int num_fields
, const scan_field_t
* fields
, tap_state_t endstate
);
574 /* set in_value to point to 32 bits of memory to scan into. This function
575 * is a way to handle the case of synchronous and asynchronous
578 * In the event of an asynchronous queue execution the queue buffer
579 * allocation method is used, for the synchronous case the temporary 32 bits come
580 * from the input field itself.
583 #ifndef HAVE_JTAG_MINIDRIVER_H
584 extern void jtag_alloc_in_value32(scan_field_t
*field
);
586 static __inline__
void jtag_alloc_in_value32(scan_field_t
*field
)
588 field
->in_value
=field
->intmp
;
594 /* This version of jtag_add_dr_scan() uses the check_value/mask fields */
595 extern void jtag_add_dr_scan_check(int num_fields
, scan_field_t
* fields
, tap_state_t endstate
);
596 extern void jtag_add_plain_ir_scan(int num_fields
, const scan_field_t
* fields
, tap_state_t endstate
);
597 extern void jtag_add_plain_dr_scan(int num_fields
, const scan_field_t
* fields
, tap_state_t endstate
);
600 /* Simplest/typical callback - do some conversion on the data clocked in.
601 * This callback is for such conversion that can not fail.
602 * For conversion types or checks that can
603 * fail, use the jtag_callback_t variant */
604 typedef void (*jtag_callback1_t
)(u8
*in
);
606 #ifndef HAVE_JTAG_MINIDRIVER_H
607 /* A simpler version of jtag_add_callback4 */
608 extern void jtag_add_callback(jtag_callback1_t
, u8
*in
);
610 /* implemented by minidriver */
614 /* This type can store an integer safely by a normal cast on 64 and
616 typedef intptr_t jtag_callback_data_t
;
618 /* The generic callback mechanism.
620 * The callback is invoked with three arguments. The first argument is
621 * the pointer to the data clocked in.
623 typedef int (*jtag_callback_t
)(u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
);
626 /* This callback can be executed immediately the queue has been flushed. Note that
627 * the JTAG queue can either be executed synchronously or asynchronously. Typically
628 * for USB the queue is executed asynchronously. For low latency interfaces, the
629 * queue may be executed synchronously.
631 * These callbacks are typically executed *after* the *entire* JTAG queue has been
632 * executed for e.g. USB interfaces.
634 * The callbacks are guaranteeed to be invoked in the order that they were queued.
636 * The strange name is due to C's lack of overloading using function arguments
638 * The callback mechansim is very general and does not really make any assumptions
639 * about what the callback does and what the arguments are.
641 * in - typically used to point to the data to operate on. More often than not
642 * this will be the data clocked in during a shift operation
644 * data1 - an integer that is big enough to be used either as an 'int' or
645 * cast to/from a pointer
647 * data2 - an integer that is big enough to be used either as an 'int' or
648 * cast to/from a pointer
650 * Why stop at 'data2' for arguments? Somewhat historical reasons. This is
651 * sufficient to implement the jtag_check_value_mask(), besides the
652 * line is best drawn somewhere...
654 * If the execution of the queue fails before the callbacks, then the
655 * callbacks may or may not be invoked depending on driver implementation.
657 #ifndef HAVE_JTAG_MINIDRIVER_H
658 extern void jtag_add_callback4(jtag_callback_t
, u8
*in
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
);
660 /* implemented by minidriver */
664 /* run a TAP_RESET reset. End state is TAP_RESET, regardless
667 extern void jtag_add_tlr(void);
669 /* Application code *must* assume that interfaces will
670 * implement transitions between states with different
671 * paths and path lengths through the state diagram. The
672 * path will vary across interface and also across versions
673 * of the same interface over time. Even if the OpenOCD code
674 * is unchanged, the actual path taken may vary over time
675 * and versions of interface firmware or PCB revisions.
677 * Use jtag_add_pathmove() when specific transition sequences
680 * Do not use jtag_add_pathmove() unless you need to, but do use it
683 * DANGER! If the target is dependent upon a particular sequence
684 * of transitions for things to work correctly(e.g. as a workaround
685 * for an errata that contradicts the JTAG standard), then pathmove
686 * must be used, even if some jtag interfaces happen to use the
687 * desired path. Worse, the jtag interface used for testing a
688 * particular implementation, could happen to use the "desired"
689 * path when transitioning to/from end
692 * A list of unambigious single clock state transitions, not
693 * all drivers can support this, but it is required for e.g.
694 * XScale and Xilinx support
696 * Note! TAP_RESET must not be used in the path!
698 * Note that the first on the list must be reachable
699 * via a single transition from the current state.
701 * All drivers are required to implement jtag_add_pathmove().
702 * However, if the pathmove sequence can not be precisely
703 * executed, an interface_jtag_add_pathmove() or jtag_execute_queue()
704 * must return an error. It is legal, but not recommended, that
705 * a driver returns an error in all cases for a pathmove if it
706 * can only implement a few transitions and therefore
707 * a partial implementation of pathmove would have little practical
710 extern void jtag_add_pathmove(int num_states
, const tap_state_t
* path
);
712 /* go to TAP_IDLE, if we're not already there and cycle
713 * precisely num_cycles in the TAP_IDLE after which move
714 * to the end state, if it is != TAP_IDLE
716 * nb! num_cycles can be 0, in which case the fn will navigate
717 * to endstate via TAP_IDLE
719 extern void jtag_add_runtest(int num_cycles
, tap_state_t endstate
);
721 /* A reset of the TAP state machine can be requested.
723 * Whether tms or trst reset is used depends on the capabilities of
724 * the target and jtag interface(reset_config command configures this).
726 * srst can driver a reset of the TAP state machine and vice
729 * Application code may need to examine value of jtag_reset_config
730 * to determine the proper codepath
732 * DANGER! Even though srst drives trst, trst might not be connected to
733 * the interface, and it might actually be *harmful* to assert trst in this case.
735 * This is why combinations such as "reset_config srst_only srst_pulls_trst"
738 * only req_tlr_or_trst and srst can have a transition for a
739 * call as the effects of transitioning both at the "same time"
740 * are undefined, but when srst_pulls_trst or vice versa,
741 * then trst & srst *must* be asserted together.
743 extern void jtag_add_reset(int req_tlr_or_trst
, int srst
);
745 extern void jtag_add_end_state(tap_state_t endstate
);
746 extern void jtag_add_sleep(u32 us
);
750 * Function jtag_add_stable_clocks
751 * first checks that the state in which the clocks are to be issued is
752 * stable, then queues up clock_count clocks for transmission.
754 void jtag_add_clocks(int num_cycles
);
758 * For software FIFO implementations, the queued commands can be executed
759 * during this call or earlier. A sw queue might decide to push out
760 * some of the jtag_add_xxx() operations once the queue is "big enough".
762 * This fn will return an error code if any of the prior jtag_add_xxx()
763 * calls caused a failure, e.g. check failure. Note that it does not
764 * matter if the operation was executed *before* jtag_execute_queue(),
765 * jtag_execute_queue() will still return an error code.
767 * All jtag_add_xxx() calls that have in_handler!=NULL will have been
768 * executed when this fn returns, but if what has been queued only
769 * clocks data out, without reading anything back, then JTAG could
770 * be running *after* jtag_execute_queue() returns. The API does
771 * not define a way to flush a hw FIFO that runs *after*
772 * jtag_execute_queue() returns.
774 * jtag_add_xxx() commands can either be executed immediately or
775 * at some time between the jtag_add_xxx() fn call and jtag_execute_queue().
777 extern int jtag_execute_queue(void);
779 /* same as jtag_execute_queue() but does not clear the error flag */
780 extern void jtag_execute_queue_noclear(void);
782 /* this flag is set when an error occurs while executing the queue. cleared
783 * by jtag_execute_queue()
785 * this flag can also be set from application code if some error happens
786 * during processing that should be reported during jtag_execute_queue().
788 extern int jtag_error
;
790 static __inline__
void jtag_set_error(int error
)
792 if ((error
==ERROR_OK
)||(jtag_error
!=ERROR_OK
))
794 /* keep first error */
802 /* can be implemented by hw+sw */
803 extern int jtag_power_dropout(int* dropout
);
804 extern int jtag_srst_asserted(int* srst_asserted
);
806 /* JTAG support functions */
808 /* execute jtag queue and check value and use mask if mask is != NULL. invokes
809 * jtag_set_error() with any error. */
810 extern void jtag_check_value_mask(scan_field_t
*field
, u8
*value
, u8
*mask
);
812 #ifdef INCLUDE_JTAG_INTERFACE_H
813 extern enum scan_type
jtag_scan_type(const scan_command_t
* cmd
);
814 extern int jtag_scan_size(const scan_command_t
* cmd
);
815 extern int jtag_read_buffer(u8
* buffer
, const scan_command_t
* cmd
);
816 extern int jtag_build_buffer(const scan_command_t
* cmd
, u8
** buffer
);
817 #endif // INCLUDE_JTAG_INTERFACE_H
819 extern void jtag_sleep(u32 us
);
820 extern int jtag_call_event_callbacks(enum jtag_event event
);
821 extern int jtag_register_event_callback(int (* callback
)(enum jtag_event event
, void* priv
), void* priv
);
823 extern int jtag_verify_capture_ir
;
825 void jtag_tap_handle_event(jtag_tap_t
* tap
, enum jtag_tap_event e
);
828 * JTAG subsystem uses codes between -100 and -199 */
830 #define ERROR_JTAG_INIT_FAILED (-100)
831 #define ERROR_JTAG_INVALID_INTERFACE (-101)
832 #define ERROR_JTAG_NOT_IMPLEMENTED (-102)
833 #define ERROR_JTAG_TRST_ASSERTED (-103)
834 #define ERROR_JTAG_QUEUE_FAILED (-104)
835 #define ERROR_JTAG_NOT_STABLE_STATE (-105)
836 #define ERROR_JTAG_DEVICE_ERROR (-107)
838 #ifdef INCLUDE_JTAG_MINIDRIVER_H
840 extern int interface_jtag_add_ir_scan(
841 int num_fields
, const scan_field_t
* fields
,
842 tap_state_t endstate
);
843 extern int interface_jtag_add_plain_ir_scan(
844 int num_fields
, const scan_field_t
* fields
,
845 tap_state_t endstate
);
847 extern int interface_jtag_add_dr_scan(
848 int num_fields
, const scan_field_t
* fields
,
849 tap_state_t endstate
);
850 extern int interface_jtag_add_plain_dr_scan(
851 int num_fields
, const scan_field_t
* fields
,
852 tap_state_t endstate
);
854 extern int interface_jtag_add_tlr(void);
855 extern int interface_jtag_add_pathmove(int num_states
, const tap_state_t
* path
);
856 extern int interface_jtag_add_runtest(int num_cycles
, tap_state_t endstate
);
859 * This drives the actual srst and trst pins. srst will always be 0
860 * if jtag_reset_config & RESET_SRST_PULLS_TRST != 0 and ditto for
863 * the higher level jtag_add_reset will invoke jtag_add_tlr() if
866 extern int interface_jtag_add_reset(int trst
, int srst
);
867 extern int interface_jtag_add_end_state(tap_state_t endstate
);
868 extern int interface_jtag_add_sleep(u32 us
);
869 extern int interface_jtag_add_clocks(int num_cycles
);
870 extern int interface_jtag_execute_queue(void);
873 * Calls the interface callback to execute the queue. This routine
874 * is used by the JTAG driver layer and should not be called directly.
876 extern int default_interface_jtag_execute_queue(void);
879 #endif // INCLUDE_JTAG_MINIDRIVER_H
881 /* this allows JTAG devices to implement the entire jtag_xxx() layer in hw/sw */
882 #ifdef HAVE_JTAG_MINIDRIVER_H
883 /* Here a #define MINIDRIVER() and an inline version of hw fifo interface_jtag_add_dr_out can be defined */
884 #include "jtag_minidriver.h"
885 #define MINIDRIVER(a) notused ## a
887 #define MINIDRIVER(a) a
888 extern void interface_jtag_add_dr_out(jtag_tap_t
* tap
, int num_fields
, const int* num_bits
, const u32
* value
,
889 tap_state_t end_state
);
893 /* jtag_add_dr_out() is a version of jtag_add_dr_scan() which
894 * only scans data out. It operates on 32 bit integers instead
895 * of 8 bit, which makes it a better impedance match with
896 * the calling code which often operate on 32 bit integers.
898 * Current or end_state can not be TAP_RESET. end_state can be TAP_INVALID
900 * num_bits[i] is the number of bits to clock out from value[i] LSB first.
902 * If the device is in bypass, then that is an error condition in
903 * the caller code that is not detected by this fn, whereas jtag_add_dr_scan()
904 * does detect it. Similarly if the device is not in bypass, data must
907 * If anything fails, then jtag_error will be set and jtag_execute() will
908 * return an error. There is no way to determine if there was a failure
909 * during this function call.
911 * This is an inline fn to speed up embedded hosts. Also note that
912 * interface_jtag_add_dr_out() can be a *small* inline function for
915 * There is no jtag_add_dr_outin() version of this fn that also allows
916 * clocking data back in. Patches gladly accepted!
918 static __inline__
void jtag_add_dr_out(jtag_tap_t
* tap
, int num_fields
, const int* num_bits
, const u32
* value
,
919 tap_state_t end_state
)
921 if (end_state
!= TAP_INVALID
)
922 cmd_queue_end_state
= end_state
;
923 cmd_queue_cur_state
= cmd_queue_end_state
;
924 interface_jtag_add_dr_out(tap
, num_fields
, num_bits
, value
, cmd_queue_end_state
);
931 * Function jtag_add_statemove
932 * moves from the current state to the goal \a state. This needs
933 * to be handled according to the xsvf spec, see the XSTATE command
936 extern int jtag_add_statemove(tap_state_t goal_state
);
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)