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 ...) \
32 do { if (1) LOG_DEBUG(expr); } while (0)
34 #define DEBUG_JTAG_IO(expr ...) \
35 do { if (0) LOG_DEBUG(expr); } while (0)
38 #ifndef DEBUG_JTAG_IOZ
39 #define DEBUG_JTAG_IOZ 64
42 /*-----<Macros>--------------------------------------------------*/
45 * When given an array, compute its DIMension; in other words, the
46 * number of elements in the array
48 #define DIM(x) (sizeof(x)/sizeof((x)[0]))
50 /** Calculate the number of bytes required to hold @a n TAP scan bits */
51 #define TAP_SCAN_BYTES(n) CEIL(n, 8)
53 /*-----</Macros>-------------------------------------------------*/
56 * Defines JTAG Test Access Port states.
58 * These definitions were gleaned from the ARM7TDMI-S Technical
59 * Reference Manual and validated against several other ARM core
60 * technical manuals. tap_get_tms_path() is sensitive to this numbering
61 * and ordering of the TAP states; furthermore, some interfaces require
62 * specific numbers be used, as they are handed-off directly to their
63 * hardware implementations.
65 typedef enum tap_state
68 /* These are the old numbers. Leave as-is for now... */
69 TAP_RESET
= 0, TAP_IDLE
= 8,
70 TAP_DRSELECT
= 1, TAP_DRCAPTURE
= 2, TAP_DRSHIFT
= 3, TAP_DREXIT1
= 4,
71 TAP_DRPAUSE
= 5, TAP_DREXIT2
= 6, TAP_DRUPDATE
= 7,
72 TAP_IRSELECT
= 9, TAP_IRCAPTURE
= 10, TAP_IRSHIFT
= 11, TAP_IREXIT1
= 12,
73 TAP_IRPAUSE
= 13, TAP_IREXIT2
= 14, TAP_IRUPDATE
= 15,
75 TAP_NUM_STATES
= 16, TAP_INVALID
= -1,
77 /* Proper ARM recommended numbers */
95 TAP_NUM_STATES
= 0x10,
102 * Function tap_state_name
103 * Returns a string suitable for display representing the JTAG tap_state
105 const char* tap_state_name(tap_state_t state
);
107 /// The current TAP state of the pending JTAG command queue.
108 extern tap_state_t cmd_queue_cur_state
;
111 * This structure defines a single scan field in the scan. It provides
112 * fields for the field's width and pointers to scan input and output
115 * In addition, this structure includes a value and mask that is used by
116 * jtag_add_dr_scan_check() to validate the value that was scanned out.
118 * The allocated, modified, and intmp fields are internal work space.
120 typedef struct scan_field_s
122 /// A pointer to the tap structure to which this field refers.
125 /// The number of bits this field specifies (up to 32)
127 /// A pointer to value to be scanned into the device
129 /// A pointer to a 32-bit memory location for data scanned out
132 /// The value used to check the data scanned out.
133 uint8_t* check_value
;
134 /// The mask to go with check_value
137 /// in_value has been allocated for the queue
139 /// Indicates we modified the in_value.
141 /// temporary storage for performing value checks synchronously
145 typedef struct jtag_tap_event_action_s jtag_tap_event_action_t
;
147 /* this is really: typedef jtag_tap_t */
148 /* But - the typedef is done in "types.h" */
149 /* due to "forward declaration reasons" */
154 const char* dotted_name
;
155 int abs_chain_position
;
156 /// Is this TAP disabled after JTAG reset?
157 bool disabled_after_reset
;
158 /// Is this TAP currently enabled?
160 int ir_length
; /**< size of instruction register */
161 uint32_t ir_capture_value
;
162 uint8_t* expected
; /**< Capture-IR expected value */
163 uint32_t ir_capture_mask
;
164 uint8_t* expected_mask
; /**< Capture-IR expected mask */
166 bool hasidcode
; /* not all devices have idcode, we'll discover this during chain examination */
167 /**< device identification code */
169 /// Array of expected identification codes */
170 uint32_t* expected_ids
;
171 /// Number of expected identification codes
172 uint8_t expected_ids_cnt
;
174 /// current instruction
176 /// Bypass register selected
179 jtag_tap_event_action_t
*event_action
;
181 jtag_tap_t
* next_tap
;
184 void jtag_tap_init(jtag_tap_t
*tap
);
185 void jtag_tap_free(jtag_tap_t
*tap
);
187 extern jtag_tap_t
* jtag_all_taps(void);
188 extern const char *jtag_tap_name(const jtag_tap_t
*tap
);
189 extern jtag_tap_t
* jtag_tap_by_string(const char* dotted_name
);
190 extern jtag_tap_t
* jtag_tap_by_jim_obj(Jim_Interp
* interp
, Jim_Obj
* obj
);
191 extern jtag_tap_t
* jtag_tap_next_enabled(jtag_tap_t
* p
);
192 extern unsigned jtag_tap_count_enabled(void);
193 extern unsigned jtag_tap_count(void);
197 * - TRST_ASSERTED triggers two sets of callbacks, after operations to
198 * reset the scan chain -- via TMS+TCK signaling, or deasserting the
199 * nTRST signal -- are queued:
201 * + Callbacks in C code fire first, patching internal state
202 * + Then post-reset event scripts fire ... activating JTAG circuits
203 * via TCK cycles, exiting SWD mode via TMS sequences, etc
205 * During those callbacks, scan chain contents have not been validated.
206 * JTAG operations that address a specific TAP (primarily DR/IR scans)
207 * must *not* be queued.
209 * - TAP_EVENT_SETUP is reported after TRST_ASSERTED, and after the scan
210 * chain has been validated. JTAG operations including scans that
211 * target specific TAPs may be performed.
213 * - TAP_EVENT_ENABLE and TAP_EVENT_DISABLE implement TAP activation and
214 * deactivation outside the core using scripted code that understands
215 * the specific JTAG router type. They might be triggered indirectly
216 * from EVENT_SETUP operations.
220 JTAG_TAP_EVENT_SETUP
,
221 JTAG_TAP_EVENT_ENABLE
,
222 JTAG_TAP_EVENT_DISABLE
,
225 struct jtag_tap_event_action_s
227 enum jtag_event event
;
229 jtag_tap_event_action_t
* next
;
233 * Defines the function signature requide for JTAG event callback
234 * functions, which are added with jtag_register_event_callback()
235 * and removed jtag_unregister_event_callback().
236 * @param event The event to handle.
237 * @param prive A pointer to data that was passed to
238 * jtag_register_event_callback().
239 * @returns Must return ERROR_OK on success, or an error code on failure.
241 * @todo Change to return void or define a use for its return code.
243 typedef int (*jtag_event_handler_t
)(enum jtag_event event
, void* priv
);
245 extern int jtag_register_event_callback(jtag_event_handler_t f
, void *x
);
246 extern int jtag_unregister_event_callback(jtag_event_handler_t f
, void *x
);
248 extern int jtag_call_event_callbacks(enum jtag_event event
);
251 /// @returns The current JTAG speed setting.
252 int jtag_get_speed(void);
254 * Given a @a speed setting, use the interface @c speed_div callback to
255 * adjust the setting.
256 * @param speed The speed setting to convert back to readable KHz.
257 * @returns ERROR_OK if the interface has not been initialized or on success;
258 * otherwise, the error code produced by the @c speed_div callback.
260 int jtag_get_speed_readable(int *speed
);
262 * Set the JTAG speed. This routine will call the underlying
263 * interface @c speed callback, if the interface has been initialized.
264 * @param speed The new speed setting.
265 * @returns ERROR_OK during configuration or on success, or an error
266 * code returned from the interface @c speed callback.
268 int jtag_config_speed(int speed
);
271 /// Attempt to configure the interface for the specified KHz.
272 int jtag_config_khz(unsigned khz
);
274 * Attempt to enable RTCK/RCLK. If that fails, fallback to the
275 * specified frequency.
277 int jtag_config_rclk(unsigned fallback_speed_khz
);
278 /// Retreives the clock speed of the JTAG interface in KHz.
279 unsigned jtag_get_speed_khz(void);
284 RESET_HAS_TRST
= 0x1,
285 RESET_HAS_SRST
= 0x2,
286 RESET_TRST_AND_SRST
= 0x3,
287 RESET_SRST_PULLS_TRST
= 0x4,
288 RESET_TRST_PULLS_SRST
= 0x8,
289 RESET_TRST_OPEN_DRAIN
= 0x10,
290 RESET_SRST_PUSH_PULL
= 0x20,
291 RESET_SRST_NO_GATING
= 0x40,
294 enum reset_types
jtag_get_reset_config(void);
295 void jtag_set_reset_config(enum reset_types type
);
297 void jtag_set_nsrst_delay(unsigned delay
);
298 unsigned jtag_get_nsrst_delay(void);
300 void jtag_set_ntrst_delay(unsigned delay
);
301 unsigned jtag_get_ntrst_delay(void);
303 void jtag_set_nsrst_assert_width(unsigned delay
);
304 unsigned jtag_get_nsrst_assert_width(void);
306 void jtag_set_ntrst_assert_width(unsigned delay
);
307 unsigned jtag_get_ntrst_assert_width(void);
309 /// @returns The current state of TRST.
310 int jtag_get_trst(void);
311 /// @returns The current state of SRST.
312 int jtag_get_srst(void);
314 /// Enable or disable data scan verification checking.
315 void jtag_set_verify(bool enable
);
316 /// @returns True if data scan verification will be performed.
317 bool jtag_will_verify(void);
319 /// Enable or disable verification of IR scan checking.
320 void jtag_set_verify_capture_ir(bool enable
);
321 /// @returns True if IR scan verification will be performed.
322 bool jtag_will_verify_capture_ir(void);
325 * Initialize interface upon startup. Return a successful no-op upon
326 * subsequent invocations.
328 extern int jtag_interface_init(struct command_context_s
* cmd_ctx
);
330 /// Shutdown the JTAG interface upon program exit.
331 extern int jtag_interface_quit(void);
334 * Initialize JTAG chain using only a RESET reset. If init fails,
337 extern int jtag_init(struct command_context_s
* cmd_ctx
);
339 /// reset, then initialize JTAG chain
340 extern int jtag_init_reset(struct command_context_s
* cmd_ctx
);
341 extern int jtag_register_commands(struct command_context_s
* cmd_ctx
);
342 extern int jtag_init_inner(struct command_context_s
*cmd_ctx
);
346 * The JTAG interface can be implemented with a software or hardware fifo.
348 * TAP_DRSHIFT and TAP_IRSHIFT are illegal end states; however,
349 * TAP_DRSHIFT/IRSHIFT can be emulated as end states, by using longer
352 * Code that is relatively insensitive to the path taken through state
353 * machine (as long as it is JTAG compliant) can use @a endstate for
354 * jtag_add_xxx_scan(). Otherwise, the pause state must be specified as
355 * end state and a subsequent jtag_add_pathmove() must be issued.
359 * Generate an IR SCAN with a list of scan fields with one entry for
362 * If the input field list contains an instruction value for a TAP then
363 * that is used otherwise the TAP is set to bypass.
365 * TAPs for which no fields are passed are marked as bypassed for
366 * subsequent DR SCANs.
369 extern void jtag_add_ir_scan(int num_fields
, scan_field_t
* fields
, tap_state_t endstate
);
371 * The same as jtag_add_ir_scan except no verification is performed out
374 extern void jtag_add_ir_scan_noverify(int num_fields
, const scan_field_t
*fields
, tap_state_t state
);
376 * Duplicate the scan fields passed into the function into an IR SCAN
377 * command. This function assumes that the caller handles extra fields
380 extern void jtag_add_plain_ir_scan(int num_fields
, const scan_field_t
* fields
, tap_state_t endstate
);
384 * Set in_value to point to 32 bits of memory to scan into. This
385 * function is a way to handle the case of synchronous and asynchronous
388 * In the event of an asynchronous queue execution the queue buffer
389 * allocation method is used, for the synchronous case the temporary 32
390 * bits come from the input field itself.
392 extern void jtag_alloc_in_value32(scan_field_t
*field
);
395 * Generate a DR SCAN using the fields passed to the function.
396 * For connected TAPs, the function checks in_fields and uses fields
397 * specified there. For bypassed TAPs, the function generates a dummy
398 * 1-bit field. The bypass status of TAPs is set by jtag_add_ir_scan().
400 extern void jtag_add_dr_scan(int num_fields
, const scan_field_t
* fields
, tap_state_t endstate
);
401 /// A version of jtag_add_dr_scan() that uses the check_value/mask fields
402 extern void jtag_add_dr_scan_check(int num_fields
, scan_field_t
* fields
, tap_state_t endstate
);
404 * Duplicate the scan fields passed into the function into a DR SCAN
405 * command. Unlike jtag_add_dr_scan(), this function assumes that the
406 * caller handles extra fields for bypassed TAPs.
408 extern void jtag_add_plain_dr_scan(int num_fields
, const scan_field_t
* fields
, tap_state_t endstate
);
411 * Defines the type of data passed to the jtag_callback_t interface.
412 * The underlying type must allow storing an @c int or pointer type.
414 typedef intptr_t jtag_callback_data_t
;
417 * Defines a simple JTAG callback that can allow conversions on data
418 * scanned in from an interface.
420 * This callback should only be used for conversion that cannot fail.
421 * For conversion types or checks that can fail, use the more complete
422 * variant: jtag_callback_t.
424 typedef void (*jtag_callback1_t
)(jtag_callback_data_t data0
);
426 /// A simpler version of jtag_add_callback4().
427 extern void jtag_add_callback(jtag_callback1_t
, jtag_callback_data_t data0
);
432 * Defines the interface of the JTAG callback mechanism.
434 * @param in the pointer to the data clocked in
435 * @param data1 An integer big enough to use as an @c int or a pointer.
436 * @param data2 An integer big enough to use as an @c int or a pointer.
437 * @param data3 An integer big enough to use as an @c int or a pointer.
438 * @returns an error code
440 typedef int (*jtag_callback_t
)(jtag_callback_data_t data0
, jtag_callback_data_t data1
, jtag_callback_data_t data2
, jtag_callback_data_t data3
);
444 * This callback can be executed immediately the queue has been flushed.
446 * The JTAG queue can be executed synchronously or asynchronously.
447 * Typically for USB, the queue is executed asynchronously. For
448 * low-latency interfaces, the queue may be executed synchronously.
450 * The callback mechanism is very general and does not make many
451 * assumptions about what the callback does or what its arguments are.
452 * These callbacks are typically executed *after* the *entire* JTAG
453 * queue has been executed for e.g. USB interfaces, and they are
454 * guaranteeed to be invoked in the order that they were queued.
456 * If the execution of the queue fails before the callbacks, then --
457 * depending on driver implementation -- the callbacks may or may not be
458 * invoked. @todo Can we make this behavior consistent?
460 * The strange name is due to C's lack of overloading using function
463 * @param f The callback function to add.
464 * @param data0 Typically used to point to the data to operate on.
465 * Frequently this will be the data clocked in during a shift operation.
466 * @param data1 An integer big enough to use as an @c int or a pointer.
467 * @param data2 An integer big enough to use as an @c int or a pointer.
468 * @param data3 An integer big enough to use as an @c int or a pointer.
471 extern void jtag_add_callback4(jtag_callback_t f
, jtag_callback_data_t data0
,
472 jtag_callback_data_t data1
, jtag_callback_data_t data2
,
473 jtag_callback_data_t data3
);
477 * Run a TAP_RESET reset where the end state is TAP_RESET,
478 * regardless of the start state.
480 extern void jtag_add_tlr(void);
483 * Application code *must* assume that interfaces will
484 * implement transitions between states with different
485 * paths and path lengths through the state diagram. The
486 * path will vary across interface and also across versions
487 * of the same interface over time. Even if the OpenOCD code
488 * is unchanged, the actual path taken may vary over time
489 * and versions of interface firmware or PCB revisions.
491 * Use jtag_add_pathmove() when specific transition sequences
494 * Do not use jtag_add_pathmove() unless you need to, but do use it
497 * DANGER! If the target is dependent upon a particular sequence
498 * of transitions for things to work correctly(e.g. as a workaround
499 * for an errata that contradicts the JTAG standard), then pathmove
500 * must be used, even if some jtag interfaces happen to use the
501 * desired path. Worse, the jtag interface used for testing a
502 * particular implementation, could happen to use the "desired"
503 * path when transitioning to/from end
506 * A list of unambigious single clock state transitions, not
507 * all drivers can support this, but it is required for e.g.
508 * XScale and Xilinx support
510 * Note! TAP_RESET must not be used in the path!
512 * Note that the first on the list must be reachable
513 * via a single transition from the current state.
515 * All drivers are required to implement jtag_add_pathmove().
516 * However, if the pathmove sequence can not be precisely
517 * executed, an interface_jtag_add_pathmove() or jtag_execute_queue()
518 * must return an error. It is legal, but not recommended, that
519 * a driver returns an error in all cases for a pathmove if it
520 * can only implement a few transitions and therefore
521 * a partial implementation of pathmove would have little practical
524 * If an error occurs, jtag_error will contain one of these error codes:
525 * - ERROR_JTAG_NOT_STABLE_STATE -- The final state was not stable.
526 * - ERROR_JTAG_STATE_INVALID -- The path passed through TAP_RESET.
527 * - ERROR_JTAG_TRANSITION_INVALID -- The path includes invalid
530 extern void jtag_add_pathmove(int num_states
, const tap_state_t
* path
);
533 * jtag_add_statemove() moves from the current state to @a goal_state.
535 * @param goal_state The final TAP state.
536 * @return ERROR_OK on success, or an error code on failure.
538 * Moves from the current state to the goal \a state.
540 * This needs to be handled according to the xsvf spec, see the XSTATE
541 * command description. From the XSVF spec, pertaining to XSTATE:
543 * For special states known as stable states (Test-Logic-Reset,
544 * Run-Test/Idle, Pause-DR, Pause- IR), an XSVF interpreter follows
545 * predefined TAP state paths when the starting state is a stable state
546 * and when the XSTATE specifies a new stable state. See the STATE
547 * command in the [Ref 5] for the TAP state paths between stable
550 * For non-stable states, XSTATE should specify a state that is only one
551 * TAP state transition distance from the current TAP state to avoid
552 * undefined TAP state paths. A sequence of multiple XSTATE commands can
553 * be issued to transition the TAP through a specific state path.
555 * @note Unless @c tms_bits holds a path that agrees with [Ref 5] in the
556 * above spec, then this code is not fully conformant to the xsvf spec.
557 * This puts a burden on tap_get_tms_path() function from the xsvf spec.
558 * If in doubt, you should confirm that that burden is being met.
560 * Otherwise, @a goal_state must be immediately reachable in one clock
561 * cycle, and does not need to be a stable state.
563 extern int jtag_add_statemove(tap_state_t goal_state
);
566 * Goes to TAP_IDLE (if we're not already there), cycle
567 * precisely num_cycles in the TAP_IDLE state, after which move
568 * to @a endstate (unless it is also TAP_IDLE).
570 * @param num_cycles Number of cycles in TAP_IDLE state. This argument
571 * may be 0, in which case this routine will navigate to @a endstate
573 * @param endstate The final state.
575 extern void jtag_add_runtest(int num_cycles
, tap_state_t endstate
);
578 * A reset of the TAP state machine can be requested.
580 * Whether tms or trst reset is used depends on the capabilities of
581 * the target and jtag interface(reset_config command configures this).
583 * srst can driver a reset of the TAP state machine and vice
586 * Application code may need to examine value of jtag_reset_config
587 * to determine the proper codepath
589 * DANGER! Even though srst drives trst, trst might not be connected to
590 * the interface, and it might actually be *harmful* to assert trst in this case.
592 * This is why combinations such as "reset_config srst_only srst_pulls_trst"
595 * only req_tlr_or_trst and srst can have a transition for a
596 * call as the effects of transitioning both at the "same time"
597 * are undefined, but when srst_pulls_trst or vice versa,
598 * then trst & srst *must* be asserted together.
600 extern void jtag_add_reset(int req_tlr_or_trst
, int srst
);
604 * Function jtag_set_end_state
606 * Set a global variable to \a state if \a state != TAP_INVALID.
608 * Return the value of the global variable.
611 extern tap_state_t
jtag_set_end_state(tap_state_t state
);
613 * Function jtag_get_end_state
615 * Return the value of the global variable for end state
618 extern tap_state_t
jtag_get_end_state(void);
619 extern void jtag_add_sleep(uint32_t us
);
623 * Function jtag_add_stable_clocks
624 * first checks that the state in which the clocks are to be issued is
625 * stable, then queues up clock_count clocks for transmission.
627 void jtag_add_clocks(int num_cycles
);
631 * For software FIFO implementations, the queued commands can be executed
632 * during this call or earlier. A sw queue might decide to push out
633 * some of the jtag_add_xxx() operations once the queue is "big enough".
635 * This fn will return an error code if any of the prior jtag_add_xxx()
636 * calls caused a failure, e.g. check failure. Note that it does not
637 * matter if the operation was executed *before* jtag_execute_queue(),
638 * jtag_execute_queue() will still return an error code.
640 * All jtag_add_xxx() calls that have in_handler != NULL will have been
641 * executed when this fn returns, but if what has been queued only
642 * clocks data out, without reading anything back, then JTAG could
643 * be running *after* jtag_execute_queue() returns. The API does
644 * not define a way to flush a hw FIFO that runs *after*
645 * jtag_execute_queue() returns.
647 * jtag_add_xxx() commands can either be executed immediately or
648 * at some time between the jtag_add_xxx() fn call and jtag_execute_queue().
650 extern int jtag_execute_queue(void);
652 /// same as jtag_execute_queue() but does not clear the error flag
653 extern void jtag_execute_queue_noclear(void);
655 /// @returns the number of times the scan queue has been flushed
656 int jtag_get_flush_queue_count(void);
658 /// Report Tcl event to all TAPs
659 void jtag_notify_event(enum jtag_event
);
662 /* can be implemented by hw + sw */
663 extern int jtag_power_dropout(int* dropout
);
664 extern int jtag_srst_asserted(int* srst_asserted
);
666 /* JTAG support functions */
669 * Execute jtag queue and check value with an optional mask.
670 * @param field Pointer to scan field.
671 * @param value Pointer to scan value.
672 * @param mask Pointer to scan mask; may be NULL.
673 * @returns Nothing, but calls jtag_set_error() on any error.
675 extern void jtag_check_value_mask(scan_field_t
*field
, uint8_t *value
, uint8_t *mask
);
677 extern void jtag_sleep(uint32_t us
);
680 * The JTAG subsystem defines a number of error codes,
681 * using codes between -100 and -199.
683 #define ERROR_JTAG_INIT_FAILED (-100)
684 #define ERROR_JTAG_INVALID_INTERFACE (-101)
685 #define ERROR_JTAG_NOT_IMPLEMENTED (-102)
686 #define ERROR_JTAG_TRST_ASSERTED (-103)
687 #define ERROR_JTAG_QUEUE_FAILED (-104)
688 #define ERROR_JTAG_NOT_STABLE_STATE (-105)
689 #define ERROR_JTAG_DEVICE_ERROR (-107)
690 #define ERROR_JTAG_STATE_INVALID (-108)
691 #define ERROR_JTAG_TRANSITION_INVALID (-109)
692 #define ERROR_JTAG_INIT_SOFT_FAIL (-110)
695 * jtag_add_dr_out() is a version of jtag_add_dr_scan() which
696 * only scans data out. It operates on 32 bit integers instead
697 * of 8 bit, which makes it a better impedance match with
698 * the calling code which often operate on 32 bit integers.
700 * Current or end_state can not be TAP_RESET. end_state can be TAP_INVALID
702 * num_bits[i] is the number of bits to clock out from value[i] LSB first.
704 * If the device is in bypass, then that is an error condition in
705 * the caller code that is not detected by this fn, whereas
706 * jtag_add_dr_scan() does detect it. Similarly if the device is not in
707 * bypass, data must be passed to it.
709 * If anything fails, then jtag_error will be set and jtag_execute() will
710 * return an error. There is no way to determine if there was a failure
711 * during this function call.
713 * This is an inline fn to speed up embedded hosts. Also note that
714 * interface_jtag_add_dr_out() can be a *small* inline function for
717 * There is no jtag_add_dr_outin() version of this fn that also allows
718 * clocking data back in. Patches gladly accepted!
720 extern void jtag_add_dr_out(jtag_tap_t
* tap
,
721 int num_fields
, const int* num_bits
, const uint32_t* value
,
722 tap_state_t end_state
);
726 * Set the current JTAG core execution error, unless one was set
727 * by a previous call previously. Driver or application code must
728 * use jtag_error_clear to reset jtag_error once this routine has been
729 * called with a non-zero error code.
731 void jtag_set_error(int error
);
732 /// @returns The current value of jtag_error
733 int jtag_get_error(void);
735 * Resets jtag_error to ERROR_OK, returning its previous value.
736 * @returns The previous value of @c jtag_error.
738 int jtag_error_clear(void);
741 * Return true if it's safe for a background polling task to access the
742 * JTAG scan chain. Polling may be explicitly disallowed, and is also
743 * unsafe while nTRST is active or the JTAG clock is gated off.,
745 bool is_jtag_poll_safe(void);
748 * Return flag reporting whether JTAG polling is disallowed.
750 bool jtag_poll_get_enabled(void);
753 * Assign flag reporting whether JTAG polling is disallowed.
755 void jtag_poll_set_enabled(bool value
);
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)