remove TAP_SCAN_BYTES macro
[openocd.git] / src / jtag / jtag.h
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 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
22 ***************************************************************************/
23 #ifndef JTAG_H
24 #define JTAG_H
25
26 #include "binarybuffer.h"
27 #include "log.h"
28
29 #ifdef _DEBUG_JTAG_IO_
30 #define DEBUG_JTAG_IO(expr ...) \
31 do { if (1) LOG_DEBUG(expr); } while (0)
32 #else
33 #define DEBUG_JTAG_IO(expr ...) \
34 do { if (0) LOG_DEBUG(expr); } while (0)
35 #endif
36
37 #ifndef DEBUG_JTAG_IOZ
38 #define DEBUG_JTAG_IOZ 64
39 #endif
40
41 /*-----<Macros>--------------------------------------------------*/
42
43 /**
44 * When given an array, compute its DIMension; in other words, the
45 * number of elements in the array
46 */
47 #define DIM(x) (sizeof(x)/sizeof((x)[0]))
48
49 /*-----</Macros>-------------------------------------------------*/
50
51 /**
52 * Defines JTAG Test Access Port states.
53 *
54 * These definitions were gleaned from the ARM7TDMI-S Technical
55 * Reference Manual and validated against several other ARM core
56 * technical manuals.
57 *
58 * FIXME some interfaces require specific numbers be used, as they
59 * are handed-off directly to their hardware implementations.
60 * Fix those drivers to map as appropriate ... then pick some
61 * sane set of numbers here (where 0/uninitialized == INVALID).
62 */
63 typedef enum tap_state
64 {
65 TAP_INVALID = -1,
66
67 #if BUILD_ZY1000
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,
74
75 #else
76 /* Proper ARM recommended numbers */
77 TAP_DREXIT2 = 0x0,
78 TAP_DREXIT1 = 0x1,
79 TAP_DRSHIFT = 0x2,
80 TAP_DRPAUSE = 0x3,
81 TAP_IRSELECT = 0x4,
82 TAP_DRUPDATE = 0x5,
83 TAP_DRCAPTURE = 0x6,
84 TAP_DRSELECT = 0x7,
85 TAP_IREXIT2 = 0x8,
86 TAP_IREXIT1 = 0x9,
87 TAP_IRSHIFT = 0xa,
88 TAP_IRPAUSE = 0xb,
89 TAP_IDLE = 0xc,
90 TAP_IRUPDATE = 0xd,
91 TAP_IRCAPTURE = 0xe,
92 TAP_RESET = 0x0f,
93
94 #endif
95 } tap_state_t;
96
97 /**
98 * Function tap_state_name
99 * Returns a string suitable for display representing the JTAG tap_state
100 */
101 const char *tap_state_name(tap_state_t state);
102
103 /// Provides user-friendly name lookup of TAP states.
104 tap_state_t tap_state_by_name(const char *name);
105
106 /// The current TAP state of the pending JTAG command queue.
107 extern tap_state_t cmd_queue_cur_state;
108
109 /**
110 * This structure defines a single scan field in the scan. It provides
111 * fields for the field's width and pointers to scan input and output
112 * values.
113 *
114 * In addition, this structure includes a value and mask that is used by
115 * jtag_add_dr_scan_check() to validate the value that was scanned out.
116 *
117 * The allocated, modified, and intmp fields are internal work space.
118 */
119 struct scan_field {
120 /// A pointer to the tap structure to which this field refers.
121 struct jtag_tap* tap;
122
123 /// The number of bits this field specifies (up to 32)
124 int num_bits;
125 /// A pointer to value to be scanned into the device
126 uint8_t* out_value;
127 /// A pointer to a 32-bit memory location for data scanned out
128 uint8_t* in_value;
129
130 /// The value used to check the data scanned out.
131 uint8_t* check_value;
132 /// The mask to go with check_value
133 uint8_t* check_mask;
134
135 /// in_value has been allocated for the queue
136 int allocated;
137 /// Indicates we modified the in_value.
138 int modified;
139 /// temporary storage for performing value checks synchronously
140 uint8_t intmp[4];
141 };
142
143 struct jtag_tap {
144 const char* chip;
145 const char* tapname;
146 const char* dotted_name;
147 int abs_chain_position;
148 /// Is this TAP disabled after JTAG reset?
149 bool disabled_after_reset;
150 /// Is this TAP currently enabled?
151 bool enabled;
152 int ir_length; /**< size of instruction register */
153 uint32_t ir_capture_value;
154 uint8_t* expected; /**< Capture-IR expected value */
155 uint32_t ir_capture_mask;
156 uint8_t* expected_mask; /**< Capture-IR expected mask */
157 uint32_t idcode; /**< device identification code */
158 /** not all devices have idcode,
159 * we'll discover this during chain examination */
160 bool hasidcode;
161
162 /// Array of expected identification codes */
163 uint32_t* expected_ids;
164 /// Number of expected identification codes
165 uint8_t expected_ids_cnt;
166
167 /// current instruction
168 uint8_t* cur_instr;
169 /// Bypass register selected
170 int bypass;
171
172 struct jtag_tap_event_action *event_action;
173
174 struct jtag_tap* next_tap;
175 };
176
177 void jtag_tap_init(struct jtag_tap *tap);
178 void jtag_tap_free(struct jtag_tap *tap);
179
180 struct jtag_tap* jtag_all_taps(void);
181 const char *jtag_tap_name(const struct jtag_tap *tap);
182 struct jtag_tap* jtag_tap_by_string(const char* dotted_name);
183 struct jtag_tap* jtag_tap_by_jim_obj(Jim_Interp* interp, Jim_Obj* obj);
184 struct jtag_tap* jtag_tap_next_enabled(struct jtag_tap* p);
185 unsigned jtag_tap_count_enabled(void);
186 unsigned jtag_tap_count(void);
187
188
189 /*
190 * - TRST_ASSERTED triggers two sets of callbacks, after operations to
191 * reset the scan chain -- via TMS+TCK signaling, or deasserting the
192 * nTRST signal -- are queued:
193 *
194 * + Callbacks in C code fire first, patching internal state
195 * + Then post-reset event scripts fire ... activating JTAG circuits
196 * via TCK cycles, exiting SWD mode via TMS sequences, etc
197 *
198 * During those callbacks, scan chain contents have not been validated.
199 * JTAG operations that address a specific TAP (primarily DR/IR scans)
200 * must *not* be queued.
201 *
202 * - TAP_EVENT_SETUP is reported after TRST_ASSERTED, and after the scan
203 * chain has been validated. JTAG operations including scans that
204 * target specific TAPs may be performed.
205 *
206 * - TAP_EVENT_ENABLE and TAP_EVENT_DISABLE implement TAP activation and
207 * deactivation outside the core using scripted code that understands
208 * the specific JTAG router type. They might be triggered indirectly
209 * from EVENT_SETUP operations.
210 */
211 enum jtag_event {
212 JTAG_TRST_ASSERTED,
213 JTAG_TAP_EVENT_SETUP,
214 JTAG_TAP_EVENT_ENABLE,
215 JTAG_TAP_EVENT_DISABLE,
216 };
217
218 struct jtag_tap_event_action
219 {
220 enum jtag_event event;
221 Jim_Obj* body;
222 struct jtag_tap_event_action* next;
223 };
224
225 /**
226 * Defines the function signature requide for JTAG event callback
227 * functions, which are added with jtag_register_event_callback()
228 * and removed jtag_unregister_event_callback().
229 * @param event The event to handle.
230 * @param prive A pointer to data that was passed to
231 * jtag_register_event_callback().
232 * @returns Must return ERROR_OK on success, or an error code on failure.
233 *
234 * @todo Change to return void or define a use for its return code.
235 */
236 typedef int (*jtag_event_handler_t)(enum jtag_event event, void* priv);
237
238 int jtag_register_event_callback(jtag_event_handler_t f, void *x);
239 int jtag_unregister_event_callback(jtag_event_handler_t f, void *x);
240
241 int jtag_call_event_callbacks(enum jtag_event event);
242
243
244 /// @returns The current JTAG speed setting.
245 int jtag_get_speed(void);
246
247 /**
248 * Given a @a speed setting, use the interface @c speed_div callback to
249 * adjust the setting.
250 * @param speed The speed setting to convert back to readable KHz.
251 * @returns ERROR_OK if the interface has not been initialized or on success;
252 * otherwise, the error code produced by the @c speed_div callback.
253 */
254 int jtag_get_speed_readable(int *speed);
255
256 /// Attempt to configure the interface for the specified KHz.
257 int jtag_config_khz(unsigned khz);
258
259 /**
260 * Attempt to enable RTCK/RCLK. If that fails, fallback to the
261 * specified frequency.
262 */
263 int jtag_config_rclk(unsigned fallback_speed_khz);
264
265 /// Retreives the clock speed of the JTAG interface in KHz.
266 unsigned jtag_get_speed_khz(void);
267
268
269 enum reset_types {
270 RESET_NONE = 0x0,
271 RESET_HAS_TRST = 0x1,
272 RESET_HAS_SRST = 0x2,
273 RESET_TRST_AND_SRST = 0x3,
274 RESET_SRST_PULLS_TRST = 0x4,
275 RESET_TRST_PULLS_SRST = 0x8,
276 RESET_TRST_OPEN_DRAIN = 0x10,
277 RESET_SRST_PUSH_PULL = 0x20,
278 RESET_SRST_NO_GATING = 0x40,
279 };
280
281 enum reset_types jtag_get_reset_config(void);
282 void jtag_set_reset_config(enum reset_types type);
283
284 void jtag_set_nsrst_delay(unsigned delay);
285 unsigned jtag_get_nsrst_delay(void);
286
287 void jtag_set_ntrst_delay(unsigned delay);
288 unsigned jtag_get_ntrst_delay(void);
289
290 void jtag_set_nsrst_assert_width(unsigned delay);
291 unsigned jtag_get_nsrst_assert_width(void);
292
293 void jtag_set_ntrst_assert_width(unsigned delay);
294 unsigned jtag_get_ntrst_assert_width(void);
295
296 /// @returns The current state of TRST.
297 int jtag_get_trst(void);
298 /// @returns The current state of SRST.
299 int jtag_get_srst(void);
300
301 /// Enable or disable data scan verification checking.
302 void jtag_set_verify(bool enable);
303 /// @returns True if data scan verification will be performed.
304 bool jtag_will_verify(void);
305
306 /// Enable or disable verification of IR scan checking.
307 void jtag_set_verify_capture_ir(bool enable);
308 /// @returns True if IR scan verification will be performed.
309 bool jtag_will_verify_capture_ir(void);
310
311 /**
312 * Initialize interface upon startup. Return a successful no-op upon
313 * subsequent invocations.
314 */
315 int jtag_interface_init(struct command_context* cmd_ctx);
316
317 /// Shutdown the JTAG interface upon program exit.
318 int jtag_interface_quit(void);
319
320 /**
321 * Initialize JTAG chain using only a RESET reset. If init fails,
322 * try reset + init.
323 */
324 int jtag_init(struct command_context* cmd_ctx);
325
326 /// reset, then initialize JTAG chain
327 int jtag_init_reset(struct command_context* cmd_ctx);
328 int jtag_register_commands(struct command_context* cmd_ctx);
329 int jtag_init_inner(struct command_context *cmd_ctx);
330
331 /**
332 * @file
333 * The JTAG interface can be implemented with a software or hardware fifo.
334 *
335 * TAP_DRSHIFT and TAP_IRSHIFT are illegal end states; however,
336 * TAP_DRSHIFT/IRSHIFT can be emulated as end states, by using longer
337 * scans.
338 *
339 * Code that is relatively insensitive to the path taken through state
340 * machine (as long as it is JTAG compliant) can use @a endstate for
341 * jtag_add_xxx_scan(). Otherwise, the pause state must be specified as
342 * end state and a subsequent jtag_add_pathmove() must be issued.
343 */
344
345 /**
346 * Generate an IR SCAN with a list of scan fields with one entry for
347 * each enabled TAP.
348 *
349 * If the input field list contains an instruction value for a TAP then
350 * that is used otherwise the TAP is set to bypass.
351 *
352 * TAPs for which no fields are passed are marked as bypassed for
353 * subsequent DR SCANs.
354 *
355 */
356 void jtag_add_ir_scan(int num_fields,
357 struct scan_field* fields, tap_state_t endstate);
358 /**
359 * The same as jtag_add_ir_scan except no verification is performed out
360 * the output values.
361 */
362 void jtag_add_ir_scan_noverify(int num_fields,
363 const struct scan_field *fields, tap_state_t state);
364 /**
365 * Duplicate the scan fields passed into the function into an IR SCAN
366 * command. This function assumes that the caller handles extra fields
367 * for bypassed TAPs.
368 */
369 void jtag_add_plain_ir_scan(int num_fields,
370 const struct scan_field* fields, tap_state_t endstate);
371
372
373 /**
374 * Set in_value to point to 32 bits of memory to scan into. This
375 * function is a way to handle the case of synchronous and asynchronous
376 * JTAG queues.
377 *
378 * In the event of an asynchronous queue execution the queue buffer
379 * allocation method is used, for the synchronous case the temporary 32
380 * bits come from the input field itself.
381 */
382 void jtag_alloc_in_value32(struct scan_field *field);
383
384 /**
385 * Generate a DR SCAN using the fields passed to the function.
386 * For connected TAPs, the function checks in_fields and uses fields
387 * specified there. For bypassed TAPs, the function generates a dummy
388 * 1-bit field. The bypass status of TAPs is set by jtag_add_ir_scan().
389 */
390 void jtag_add_dr_scan(int num_fields,
391 const struct scan_field* fields, tap_state_t endstate);
392 /// A version of jtag_add_dr_scan() that uses the check_value/mask fields
393 void jtag_add_dr_scan_check(int num_fields,
394 struct scan_field* fields, tap_state_t endstate);
395 /**
396 * Duplicate the scan fields passed into the function into a DR SCAN
397 * command. Unlike jtag_add_dr_scan(), this function assumes that the
398 * caller handles extra fields for bypassed TAPs.
399 */
400 void jtag_add_plain_dr_scan(int num_fields,
401 const struct scan_field* fields, tap_state_t endstate);
402
403 /**
404 * Defines the type of data passed to the jtag_callback_t interface.
405 * The underlying type must allow storing an @c int or pointer type.
406 */
407 typedef intptr_t jtag_callback_data_t;
408
409 /**
410 * Defines a simple JTAG callback that can allow conversions on data
411 * scanned in from an interface.
412 *
413 * This callback should only be used for conversion that cannot fail.
414 * For conversion types or checks that can fail, use the more complete
415 * variant: jtag_callback_t.
416 */
417 typedef void (*jtag_callback1_t)(jtag_callback_data_t data0);
418
419 /// A simpler version of jtag_add_callback4().
420 void jtag_add_callback(jtag_callback1_t, jtag_callback_data_t data0);
421
422
423
424 /**
425 * Defines the interface of the JTAG callback mechanism.
426 *
427 * @param in the pointer to the data clocked in
428 * @param data1 An integer big enough to use as an @c int or a pointer.
429 * @param data2 An integer big enough to use as an @c int or a pointer.
430 * @param data3 An integer big enough to use as an @c int or a pointer.
431 * @returns an error code
432 */
433 typedef int (*jtag_callback_t)(jtag_callback_data_t data0,
434 jtag_callback_data_t data1,
435 jtag_callback_data_t data2,
436 jtag_callback_data_t data3);
437
438
439 /**
440 * This callback can be executed immediately the queue has been flushed.
441 *
442 * The JTAG queue can be executed synchronously or asynchronously.
443 * Typically for USB, the queue is executed asynchronously. For
444 * low-latency interfaces, the queue may be executed synchronously.
445 *
446 * The callback mechanism is very general and does not make many
447 * assumptions about what the callback does or what its arguments are.
448 * These callbacks are typically executed *after* the *entire* JTAG
449 * queue has been executed for e.g. USB interfaces, and they are
450 * guaranteeed to be invoked in the order that they were queued.
451 *
452 * If the execution of the queue fails before the callbacks, then --
453 * depending on driver implementation -- the callbacks may or may not be
454 * invoked. @todo Can we make this behavior consistent?
455 *
456 * The strange name is due to C's lack of overloading using function
457 * arguments.
458 *
459 * @param f The callback function to add.
460 * @param data0 Typically used to point to the data to operate on.
461 * Frequently this will be the data clocked in during a shift operation.
462 * @param data1 An integer big enough to use as an @c int or a pointer.
463 * @param data2 An integer big enough to use as an @c int or a pointer.
464 * @param data3 An integer big enough to use as an @c int or a pointer.
465 *
466 */
467 void jtag_add_callback4(jtag_callback_t f, jtag_callback_data_t data0,
468 jtag_callback_data_t data1, jtag_callback_data_t data2,
469 jtag_callback_data_t data3);
470
471
472 /**
473 * Run a TAP_RESET reset where the end state is TAP_RESET,
474 * regardless of the start state.
475 */
476 void jtag_add_tlr(void);
477
478 /**
479 * Application code *must* assume that interfaces will
480 * implement transitions between states with different
481 * paths and path lengths through the state diagram. The
482 * path will vary across interface and also across versions
483 * of the same interface over time. Even if the OpenOCD code
484 * is unchanged, the actual path taken may vary over time
485 * and versions of interface firmware or PCB revisions.
486 *
487 * Use jtag_add_pathmove() when specific transition sequences
488 * are required.
489 *
490 * Do not use jtag_add_pathmove() unless you need to, but do use it
491 * if you have to.
492 *
493 * DANGER! If the target is dependent upon a particular sequence
494 * of transitions for things to work correctly(e.g. as a workaround
495 * for an errata that contradicts the JTAG standard), then pathmove
496 * must be used, even if some jtag interfaces happen to use the
497 * desired path. Worse, the jtag interface used for testing a
498 * particular implementation, could happen to use the "desired"
499 * path when transitioning to/from end
500 * state.
501 *
502 * A list of unambigious single clock state transitions, not
503 * all drivers can support this, but it is required for e.g.
504 * XScale and Xilinx support
505 *
506 * Note! TAP_RESET must not be used in the path!
507 *
508 * Note that the first on the list must be reachable
509 * via a single transition from the current state.
510 *
511 * All drivers are required to implement jtag_add_pathmove().
512 * However, if the pathmove sequence can not be precisely
513 * executed, an interface_jtag_add_pathmove() or jtag_execute_queue()
514 * must return an error. It is legal, but not recommended, that
515 * a driver returns an error in all cases for a pathmove if it
516 * can only implement a few transitions and therefore
517 * a partial implementation of pathmove would have little practical
518 * application.
519 *
520 * If an error occurs, jtag_error will contain one of these error codes:
521 * - ERROR_JTAG_NOT_STABLE_STATE -- The final state was not stable.
522 * - ERROR_JTAG_STATE_INVALID -- The path passed through TAP_RESET.
523 * - ERROR_JTAG_TRANSITION_INVALID -- The path includes invalid
524 * state transitions.
525 */
526 void jtag_add_pathmove(int num_states, const tap_state_t* path);
527
528 /**
529 * jtag_add_statemove() moves from the current state to @a goal_state.
530 *
531 * @param goal_state The final TAP state.
532 * @return ERROR_OK on success, or an error code on failure.
533 *
534 * Moves from the current state to the goal \a state.
535 * Both states must be stable.
536 */
537 int jtag_add_statemove(tap_state_t goal_state);
538
539 /**
540 * Goes to TAP_IDLE (if we're not already there), cycle
541 * precisely num_cycles in the TAP_IDLE state, after which move
542 * to @a endstate (unless it is also TAP_IDLE).
543 *
544 * @param num_cycles Number of cycles in TAP_IDLE state. This argument
545 * may be 0, in which case this routine will navigate to @a endstate
546 * via TAP_IDLE.
547 * @param endstate The final state.
548 */
549 void jtag_add_runtest(int num_cycles, tap_state_t endstate);
550
551 /**
552 * A reset of the TAP state machine can be requested.
553 *
554 * Whether tms or trst reset is used depends on the capabilities of
555 * the target and jtag interface(reset_config command configures this).
556 *
557 * srst can driver a reset of the TAP state machine and vice
558 * versa
559 *
560 * Application code may need to examine value of jtag_reset_config
561 * to determine the proper codepath
562 *
563 * DANGER! Even though srst drives trst, trst might not be connected to
564 * the interface, and it might actually be *harmful* to assert trst in this case.
565 *
566 * This is why combinations such as "reset_config srst_only srst_pulls_trst"
567 * are supported.
568 *
569 * only req_tlr_or_trst and srst can have a transition for a
570 * call as the effects of transitioning both at the "same time"
571 * are undefined, but when srst_pulls_trst or vice versa,
572 * then trst & srst *must* be asserted together.
573 */
574 void jtag_add_reset(int req_tlr_or_trst, int srst);
575
576
577 /**
578 * Function jtag_set_end_state
579 *
580 * Set a global variable to \a state if \a state != TAP_INVALID.
581 *
582 * Return the value of the global variable.
583 *
584 **/
585 tap_state_t jtag_set_end_state(tap_state_t state);
586 /**
587 * Function jtag_get_end_state
588 *
589 * Return the value of the global variable for end state
590 *
591 **/
592 tap_state_t jtag_get_end_state(void);
593 void jtag_add_sleep(uint32_t us);
594
595
596 /**
597 * Function jtag_add_stable_clocks
598 * first checks that the state in which the clocks are to be issued is
599 * stable, then queues up clock_count clocks for transmission.
600 */
601 void jtag_add_clocks(int num_cycles);
602
603
604 /**
605 * For software FIFO implementations, the queued commands can be executed
606 * during this call or earlier. A sw queue might decide to push out
607 * some of the jtag_add_xxx() operations once the queue is "big enough".
608 *
609 * This fn will return an error code if any of the prior jtag_add_xxx()
610 * calls caused a failure, e.g. check failure. Note that it does not
611 * matter if the operation was executed *before* jtag_execute_queue(),
612 * jtag_execute_queue() will still return an error code.
613 *
614 * All jtag_add_xxx() calls that have in_handler != NULL will have been
615 * executed when this fn returns, but if what has been queued only
616 * clocks data out, without reading anything back, then JTAG could
617 * be running *after* jtag_execute_queue() returns. The API does
618 * not define a way to flush a hw FIFO that runs *after*
619 * jtag_execute_queue() returns.
620 *
621 * jtag_add_xxx() commands can either be executed immediately or
622 * at some time between the jtag_add_xxx() fn call and jtag_execute_queue().
623 */
624 int jtag_execute_queue(void);
625
626 /// same as jtag_execute_queue() but does not clear the error flag
627 void jtag_execute_queue_noclear(void);
628
629 /// @returns the number of times the scan queue has been flushed
630 int jtag_get_flush_queue_count(void);
631
632 /// Report Tcl event to all TAPs
633 void jtag_notify_event(enum jtag_event);
634
635
636 /* can be implemented by hw + sw */
637 int jtag_power_dropout(int* dropout);
638 int jtag_srst_asserted(int* srst_asserted);
639
640 /* JTAG support functions */
641
642 /**
643 * Execute jtag queue and check value with an optional mask.
644 * @param field Pointer to scan field.
645 * @param value Pointer to scan value.
646 * @param mask Pointer to scan mask; may be NULL.
647 * @returns Nothing, but calls jtag_set_error() on any error.
648 */
649 void jtag_check_value_mask(struct scan_field *field, uint8_t *value, uint8_t *mask);
650
651 void jtag_sleep(uint32_t us);
652
653 /*
654 * The JTAG subsystem defines a number of error codes,
655 * using codes between -100 and -199.
656 */
657 #define ERROR_JTAG_INIT_FAILED (-100)
658 #define ERROR_JTAG_INVALID_INTERFACE (-101)
659 #define ERROR_JTAG_NOT_IMPLEMENTED (-102)
660 #define ERROR_JTAG_TRST_ASSERTED (-103)
661 #define ERROR_JTAG_QUEUE_FAILED (-104)
662 #define ERROR_JTAG_NOT_STABLE_STATE (-105)
663 #define ERROR_JTAG_DEVICE_ERROR (-107)
664 #define ERROR_JTAG_STATE_INVALID (-108)
665 #define ERROR_JTAG_TRANSITION_INVALID (-109)
666 #define ERROR_JTAG_INIT_SOFT_FAIL (-110)
667
668 /**
669 * jtag_add_dr_out() is a version of jtag_add_dr_scan() which
670 * only scans data out. It operates on 32 bit integers instead
671 * of 8 bit, which makes it a better impedance match with
672 * the calling code which often operate on 32 bit integers.
673 *
674 * Current or end_state can not be TAP_RESET. end_state can be TAP_INVALID
675 *
676 * num_bits[i] is the number of bits to clock out from value[i] LSB first.
677 *
678 * If the device is in bypass, then that is an error condition in
679 * the caller code that is not detected by this fn, whereas
680 * jtag_add_dr_scan() does detect it. Similarly if the device is not in
681 * bypass, data must be passed to it.
682 *
683 * If anything fails, then jtag_error will be set and jtag_execute() will
684 * return an error. There is no way to determine if there was a failure
685 * during this function call.
686 *
687 * This is an inline fn to speed up embedded hosts. Also note that
688 * interface_jtag_add_dr_out() can be a *small* inline function for
689 * embedded hosts.
690 *
691 * There is no jtag_add_dr_outin() version of this fn that also allows
692 * clocking data back in. Patches gladly accepted!
693 */
694 void jtag_add_dr_out(struct jtag_tap* tap,
695 int num_fields, const int* num_bits, const uint32_t* value,
696 tap_state_t end_state);
697
698
699 /**
700 * Set the current JTAG core execution error, unless one was set
701 * by a previous call previously. Driver or application code must
702 * use jtag_error_clear to reset jtag_error once this routine has been
703 * called with a non-zero error code.
704 */
705 void jtag_set_error(int error);
706 /// @returns The current value of jtag_error
707 int jtag_get_error(void);
708 /**
709 * Resets jtag_error to ERROR_OK, returning its previous value.
710 * @returns The previous value of @c jtag_error.
711 */
712 int jtag_error_clear(void);
713
714 /**
715 * Return true if it's safe for a background polling task to access the
716 * JTAG scan chain. Polling may be explicitly disallowed, and is also
717 * unsafe while nTRST is active or the JTAG clock is gated off.,
718 */
719 bool is_jtag_poll_safe(void);
720
721 /**
722 * Return flag reporting whether JTAG polling is disallowed.
723 */
724 bool jtag_poll_get_enabled(void);
725
726 /**
727 * Assign flag reporting whether JTAG polling is disallowed.
728 */
729 void jtag_poll_set_enabled(bool value);
730
731 #endif /* JTAG_H */

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)