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 ***************************************************************************/
27 #include "binarybuffer.h"
34 #define _DEBUG_JTAG_IO_
37 #ifndef DEBUG_JTAG_IOZ
38 #define DEBUG_JTAG_IOZ 64
42 /* 16 Tap States, from page 21 of ASSET InterTech, Inc.'s svf.pdf
45 TAP_RESET
= 0, TAP_IDLE
= 8,
46 TAP_DRSELECT
= 1, TAP_DRCAPTURE
= 2, TAP_DRSHIFT
= 3, TAP_DREXIT1
= 4,
47 TAP_DRPAUSE
= 5, TAP_DREXIT2
= 6, TAP_DRUPDATE
= 7,
48 TAP_IRSELECT
= 9, TAP_IRCAPTURE
= 10, TAP_IRSHIFT
= 11, TAP_IREXIT1
= 12,
49 TAP_IRPAUSE
= 13, TAP_IREXIT2
= 14, TAP_IRUPDATE
= 15,
51 TAP_NUM_STATES
= 16, TAP_INVALID
= -1,
54 typedef enum tap_state tap_state_t
;
56 typedef struct tap_transition_s
62 //extern tap_transition_t tap_transitions[16]; /* describe the TAP state diagram */
65 /*-----<Cable Helper API>-------------------------------------------*/
67 /* The "Cable Helper API" is what the cable drivers can use to help implement
68 * their "Cable API". So a Cable Helper API is a set of helper functions used by
69 * cable drivers, and this is different from a Cable API. A "Cable API" is what
70 * higher level code used to talk to a cable.
74 /** implementation of wrapper function tap_set_state() */
75 void tap_set_state_impl(tap_state_t new_state
);
78 * Function tap_set_state
79 * sets the state of a "state follower" which tracks the state of the TAPs connected to the
80 * cable. The state follower is hopefully always in the same state as the actual
81 * TAPs in the jtag chain, and will be so if there are no bugs in the tracking logic within that
82 * cable driver. All the cable drivers call this function to indicate the state they think
83 * the TAPs attached to their cables are in. Because this function can also log transitions,
84 * it will be helpful to call this function with every transition that the TAPs being manipulated
85 * are expected to traverse, not just end points of a multi-step state path.
86 * @param new_state is the state we think the TAPs are currently in or are about to enter.
88 #if defined(_DEBUG_JTAG_IO_)
89 #define tap_set_state(new_state) \
91 LOG_DEBUG( "tap_set_state(%s)", tap_state_name(new_state) ); \
92 tap_set_state_impl(new_state); \
95 static inline void tap_set_state(tap_state_t new_state
)
97 tap_set_state_impl(new_state
);
103 * Function tap_get_state
104 * gets the state of the "state follower" which tracks the state of the TAPs connected to
107 * @return tap_state_t - The state the TAPs are in now.
109 tap_state_t
tap_get_state(void);
112 * Function tap_set_end_state
113 * sets the state of an "end state follower" which tracks the state that any cable driver
114 * thinks will be the end (resultant) state of the current TAP SIR or SDR operation. At completion
115 * of that TAP operation this value is copied into the state follower via tap_set_state().
116 * @param new_end_state is that state the TAPs should enter at completion of a pending TAP operation.
118 void tap_set_end_state(tap_state_t new_end_state
);
121 * Function tap_get_end_state
122 * @see tap_set_end_state
123 * @return tap_state_t - The state the TAPs should be in at completion of the current TAP operation.
125 tap_state_t
tap_get_end_state(void);
128 * Function tap_get_tms_path
129 * returns a 7 bit long "bit sequence" indicating what has to be done with TMS
130 * during a sequence of seven TAP clock cycles in order to get from
131 * state \a "from" to state \a "to".
132 * @param from is the starting state
133 * @param to is the resultant or final state
134 * @return int - a 7 bit sequence, with the first bit in the sequence at bit 0.
136 int tap_get_tms_path(tap_state_t from
, tap_state_t to
);
139 * Function tap_move_ndx
140 * when given a stable state, returns an index from 0-5. The index corresponds to a
141 * sequence of stable states which are given in this order: <p>
142 * { TAP_RESET, TAP_IDLE, TAP_DRSHIFT, TAP_DRPAUSE, TAP_IRSHIFT, TAP_IRPAUSE }
144 * This sequence corresponds to look up tables which are used in some of the
146 * @param astate is the stable state to find in the sequence. If a non stable
147 * state is passed, this may cause the program to output an error message
149 * @return int - the array (or sequence) index as described above
151 int tap_move_ndx(tap_state_t astate
);
154 * Function tap_is_state_stable
155 * returns true if the \a astate is stable.
157 bool tap_is_state_stable(tap_state_t astate
);
160 * Function tap_state_transition
161 * takes a current TAP state and returns the next state according to the tms value.
162 * @param current_state is the state of a TAP currently.
163 * @param tms is either zero or non-zero, just like a real TMS line in a jtag interface.
164 * @return tap_state_t - the next state a TAP would enter.
166 tap_state_t
tap_state_transition(tap_state_t current_state
, bool tms
);
169 * Function tap_state_name
170 * Returns a string suitable for display representing the JTAG tap_state
172 const char* tap_state_name(tap_state_t state
);
174 /*-----</Cable Helper API>------------------------------------------*/
177 extern tap_state_t cmd_queue_end_state
; /* finish DR scans in dr_end_state */
178 extern tap_state_t cmd_queue_cur_state
; /* current TAP state */
180 typedef void* error_handler_t
; /* Later on we can delete error_handler_t, but keep it for now to make patches more readable */
183 typedef int (*in_handler_t
)(u8
* in_value
, void* priv
, struct scan_field_s
* field
);
185 typedef struct scan_field_s
187 jtag_tap_t
* tap
; /* tap pointer this instruction refers to */
188 int num_bits
; /* number of bits this field specifies (up to 32) */
189 u8
* out_value
; /* value to be scanned into the device */
190 u8
* out_mask
; /* only masked bits care */
191 u8
* in_value
; /* pointer to a 32-bit memory location to take data scanned out */
192 /* in_check_value/mask, in_handler_error_handler, in_handler_priv can be used by the in handler, otherwise they contain garbage */
193 u8
* in_check_value
; /* used to validate scan results */
194 u8
* in_check_mask
; /* check specified bits against check_value */
195 in_handler_t in_handler
; /* process received buffer using this handler */
196 void* in_handler_priv
; /* additional information for the in_handler */
200 /* IN: from device to host, OUT: from host to device */
201 SCAN_IN
= 1, SCAN_OUT
= 2, SCAN_IO
= 3
204 typedef struct scan_command_s
206 int ir_scan
; /* instruction/not data scan */
207 int num_fields
; /* number of fields in *fields array */
208 scan_field_t
* fields
; /* pointer to an array of data scan fields */
209 tap_state_t end_state
; /* TAP state in which JTAG commands should finish */
212 typedef struct statemove_command_s
214 tap_state_t end_state
; /* TAP state in which JTAG commands should finish */
215 } statemove_command_t
;
217 typedef struct pathmove_command_s
219 int num_states
; /* number of states in *path */
220 tap_state_t
* path
; /* states that have to be passed */
221 } pathmove_command_t
;
223 typedef struct runtest_command_s
225 int num_cycles
; /* number of cycles that should be spent in Run-Test/Idle */
226 tap_state_t end_state
; /* TAP state in which JTAG commands should finish */
230 typedef struct stableclocks_command_s
232 int num_cycles
; /* number of clock cycles that should be sent */
233 } stableclocks_command_t
;
236 typedef struct reset_command_s
238 int trst
; /* trst/srst 0: deassert, 1: assert, -1: don't change */
242 typedef struct end_state_command_s
244 tap_state_t end_state
; /* TAP state in which JTAG commands should finish */
245 } end_state_command_t
;
247 typedef struct sleep_command_s
249 u32 us
; /* number of microseconds to sleep */
252 typedef union jtag_command_container_u
254 scan_command_t
* scan
;
255 statemove_command_t
* statemove
;
256 pathmove_command_t
* pathmove
;
257 runtest_command_t
* runtest
;
258 stableclocks_command_t
* stableclocks
;
259 reset_command_t
* reset
;
260 end_state_command_t
* end_state
;
261 sleep_command_t
* sleep
;
262 } jtag_command_container_t
;
264 enum jtag_command_type
{
272 JTAG_STABLECLOCKS
= 8
275 typedef struct jtag_command_s
277 jtag_command_container_t cmd
;
278 enum jtag_command_type type
;
279 struct jtag_command_s
* next
;
282 extern jtag_command_t
* jtag_command_queue
;
284 /* forward declaration */
285 typedef struct jtag_tap_event_action_s jtag_tap_event_action_t
;
287 /* this is really: typedef jtag_tap_t */
288 /* But - the typedef is done in "types.h" */
289 /* due to "forward decloration reasons" */
294 const char* dotted_name
;
295 int abs_chain_position
;
297 int ir_length
; /* size of instruction register */
298 u32 ir_capture_value
;
299 u8
* expected
; /* Capture-IR expected value */
301 u8
* expected_mask
; /* Capture-IR expected mask */
302 u32 idcode
; /* device identification code */
303 u32
* expected_ids
; /* Array of expected identification codes */
304 u8 expected_ids_cnt
; /* Number of expected identification codes */
305 u8
* cur_instr
; /* current instruction */
306 int bypass
; /* bypass register selected */
308 jtag_tap_event_action_t
* event_action
;
310 jtag_tap_t
* next_tap
;
312 extern jtag_tap_t
* jtag_AllTaps(void);
313 extern jtag_tap_t
* jtag_TapByPosition(int n
);
314 extern jtag_tap_t
* jtag_TapByPosition(int n
);
315 extern jtag_tap_t
* jtag_TapByString(const char* dotted_name
);
316 extern jtag_tap_t
* jtag_TapByJimObj(Jim_Interp
* interp
, Jim_Obj
* obj
);
317 extern jtag_tap_t
* jtag_TapByAbsPosition(int abs_position
);
318 extern int jtag_NumEnabledTaps(void);
319 extern int jtag_NumTotalTaps(void);
321 static __inline__ jtag_tap_t
* jtag_NextEnabledTap(jtag_tap_t
* p
)
325 /* start at the head of list */
330 /* start *after* this one */
349 enum reset_line_mode
{
350 LINE_OPEN_DRAIN
= 0x0,
351 LINE_PUSH_PULL
= 0x1,
354 typedef struct jtag_interface_s
358 /* queued command execution
360 int (*execute_queue
)(void);
362 /* interface initalization
364 int (*speed
)(int speed
);
365 int (*register_commands
)(struct command_context_s
* cmd_ctx
);
369 /* returns JTAG maxium speed for KHz. 0=RTCK. The function returns
370 * a failure if it can't support the KHz/RTCK.
372 * WARNING!!!! if RTCK is *slow* then think carefully about
373 * whether you actually want to support this in the driver.
374 * Many target scripts are written to handle the absence of RTCK
375 * and use a fallback kHz TCK.
377 int (*khz
)(int khz
, int* jtag_speed
);
379 /* returns the KHz for the provided JTAG speed. 0=RTCK. The function returns
380 * a failure if it can't support the KHz/RTCK. */
381 int (*speed_div
)(int speed
, int* khz
);
383 /* Read and clear the power dropout flag. Note that a power dropout
384 * can be transitionary, easily much less than a ms.
386 * So to find out if the power is *currently* on, you must invoke
387 * this method twice. Once to clear the power dropout flag and a
388 * second time to read the current state.
390 * Currently the default implementation is never to detect power dropout.
392 int (*power_dropout
)(int* power_dropout
);
394 /* Read and clear the srst asserted detection flag.
396 * NB!!!! like power_dropout this does *not* read the current
397 * state. srst assertion is transitionary and *can* be much
400 int (*srst_asserted
)(int* srst_asserted
);
407 extern char* jtag_event_strings
[];
409 enum jtag_tap_event
{
410 JTAG_TAP_EVENT_ENABLE
,
411 JTAG_TAP_EVENT_DISABLE
414 extern const Jim_Nvp nvp_jtag_tap_event
[];
416 struct jtag_tap_event_action_s
418 enum jtag_tap_event event
;
420 jtag_tap_event_action_t
* next
;
423 extern int jtag_trst
;
424 extern int jtag_srst
;
426 typedef struct jtag_event_callback_s
428 int (*callback
)(enum jtag_event event
, void* priv
);
430 struct jtag_event_callback_s
* next
;
431 } jtag_event_callback_t
;
433 extern jtag_event_callback_t
* jtag_event_callbacks
;
435 extern jtag_interface_t
* jtag
; /* global pointer to configured JTAG interface */
437 extern int jtag_speed
;
438 extern int jtag_speed_post_reset
;
442 RESET_HAS_TRST
= 0x1,
443 RESET_HAS_SRST
= 0x2,
444 RESET_TRST_AND_SRST
= 0x3,
445 RESET_SRST_PULLS_TRST
= 0x4,
446 RESET_TRST_PULLS_SRST
= 0x8,
447 RESET_TRST_OPEN_DRAIN
= 0x10,
448 RESET_SRST_PUSH_PULL
= 0x20,
451 extern enum reset_types jtag_reset_config
;
453 /* initialize interface upon startup. A successful no-op
454 * upon subsequent invocations
456 extern int jtag_interface_init(struct command_context_s
* cmd_ctx
);
458 /* initialize JTAG chain using only a RESET reset. If init fails,
461 extern int jtag_init(struct command_context_s
* cmd_ctx
);
463 /* reset, then initialize JTAG chain */
464 extern int jtag_init_reset(struct command_context_s
* cmd_ctx
);
465 extern int jtag_register_commands(struct command_context_s
* cmd_ctx
);
467 /* JTAG interface, can be implemented with a software or hardware fifo
469 * TAP_DRSHIFT and TAP_IRSHIFT are illegal end states. TAP_DRSHIFT/IRSHIFT as end states
470 * can be emulated by using a larger scan.
472 * Code that is relatively insensitive to the path(as long
473 * as it is JTAG compliant) taken through state machine can use
474 * endstate for jtag_add_xxx_scan(). Otherwise the pause state must be
475 * specified as end state and a subsequent jtag_add_pathmove() must
479 extern void jtag_add_ir_scan(int num_fields
, scan_field_t
* fields
, tap_state_t endstate
);
480 extern int interface_jtag_add_ir_scan(int num_fields
, scan_field_t
* fields
, tap_state_t endstate
);
481 extern void jtag_add_dr_scan(int num_fields
, scan_field_t
* fields
, tap_state_t endstate
);
482 extern int interface_jtag_add_dr_scan(int num_fields
, scan_field_t
* fields
, tap_state_t endstate
);
483 extern void jtag_add_plain_ir_scan(int num_fields
, scan_field_t
* fields
, tap_state_t endstate
);
484 extern int interface_jtag_add_plain_ir_scan(int num_fields
, scan_field_t
* fields
, tap_state_t endstate
);
485 extern void jtag_add_plain_dr_scan(int num_fields
, scan_field_t
* fields
, tap_state_t endstate
);
486 extern int interface_jtag_add_plain_dr_scan(int num_fields
, scan_field_t
* fields
, tap_state_t endstate
);
488 /* run a TAP_RESET reset. End state is TAP_RESET, regardless
491 extern void jtag_add_tlr(void);
492 extern int interface_jtag_add_tlr(void);
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 extern void jtag_add_pathmove(int num_states
, tap_state_t
* path
);
525 extern int interface_jtag_add_pathmove(int num_states
, tap_state_t
* path
);
527 /* go to TAP_IDLE, if we're not already there and cycle
528 * precisely num_cycles in the TAP_IDLE after which move
529 * to the end state, if it is != TAP_IDLE
531 * nb! num_cycles can be 0, in which case the fn will navigate
532 * to endstate via TAP_IDLE
534 extern void jtag_add_runtest(int num_cycles
, tap_state_t endstate
);
535 extern int interface_jtag_add_runtest(int num_cycles
, tap_state_t endstate
);
537 /* A reset of the TAP state machine can be requested.
539 * Whether tms or trst reset is used depends on the capabilities of
540 * the target and jtag interface(reset_config command configures this).
542 * srst can driver a reset of the TAP state machine and vice
545 * Application code may need to examine value of jtag_reset_config
546 * to determine the proper codepath
548 * DANGER! Even though srst drives trst, trst might not be connected to
549 * the interface, and it might actually be *harmful* to assert trst in this case.
551 * This is why combinations such as "reset_config srst_only srst_pulls_trst"
554 * only req_tlr_or_trst and srst can have a transition for a
555 * call as the effects of transitioning both at the "same time"
556 * are undefined, but when srst_pulls_trst or vice versa,
557 * then trst & srst *must* be asserted together.
559 extern void jtag_add_reset(int req_tlr_or_trst
, int srst
);
561 /* this drives the actual srst and trst pins. srst will always be 0
562 * if jtag_reset_config & RESET_SRST_PULLS_TRST != 0 and ditto for
565 * the higher level jtag_add_reset will invoke jtag_add_tlr() if
568 extern int interface_jtag_add_reset(int trst
, int srst
);
569 extern void jtag_add_end_state(tap_state_t endstate
);
570 extern int interface_jtag_add_end_state(tap_state_t endstate
);
571 extern void jtag_add_sleep(u32 us
);
572 extern int interface_jtag_add_sleep(u32 us
);
576 * Function jtag_add_stable_clocks
577 * first checks that the state in which the clocks are to be issued is
578 * stable, then queues up clock_count clocks for transmission.
580 void jtag_add_clocks(int num_cycles
);
581 int interface_jtag_add_clocks(int num_cycles
);
585 * For software FIFO implementations, the queued commands can be executed
586 * during this call or earlier. A sw queue might decide to push out
587 * some of the jtag_add_xxx() operations once the queue is "big enough".
589 * This fn will return an error code if any of the prior jtag_add_xxx()
590 * calls caused a failure, e.g. check failure. Note that it does not
591 * matter if the operation was executed *before* jtag_execute_queue(),
592 * jtag_execute_queue() will still return an error code.
594 * All jtag_add_xxx() calls that have in_handler!=NULL will have been
595 * executed when this fn returns, but if what has been queued only
596 * clocks data out, without reading anything back, then JTAG could
597 * be running *after* jtag_execute_queue() returns. The API does
598 * not define a way to flush a hw FIFO that runs *after*
599 * jtag_execute_queue() returns.
601 * jtag_add_xxx() commands can either be executed immediately or
602 * at some time between the jtag_add_xxx() fn call and jtag_execute_queue().
604 extern int jtag_execute_queue(void);
606 /* can be implemented by hw+sw */
607 extern int interface_jtag_execute_queue(void);
608 extern int jtag_power_dropout(int* dropout
);
609 extern int jtag_srst_asserted(int* srst_asserted
);
611 /* JTAG support functions */
612 extern void jtag_set_check_value(scan_field_t
* field
, u8
* value
, u8
* mask
, error_handler_t
* in_error_handler
);
613 extern enum scan_type
jtag_scan_type(scan_command_t
* cmd
);
614 extern int jtag_scan_size(scan_command_t
* cmd
);
615 extern int jtag_read_buffer(u8
* buffer
, scan_command_t
* cmd
);
616 extern int jtag_build_buffer(scan_command_t
* cmd
, u8
** buffer
);
618 extern void jtag_sleep(u32 us
);
619 extern int jtag_call_event_callbacks(enum jtag_event event
);
620 extern int jtag_register_event_callback(int (* callback
)(enum jtag_event event
, void* priv
), void* priv
);
622 extern int jtag_verify_capture_ir
;
624 void jtag_tap_handle_event(jtag_tap_t
* tap
, enum jtag_tap_event e
);
627 * JTAG subsystem uses codes between -100 and -199 */
629 #define ERROR_JTAG_INIT_FAILED (-100)
630 #define ERROR_JTAG_INVALID_INTERFACE (-101)
631 #define ERROR_JTAG_NOT_IMPLEMENTED (-102)
632 #define ERROR_JTAG_TRST_ASSERTED (-103)
633 #define ERROR_JTAG_QUEUE_FAILED (-104)
634 #define ERROR_JTAG_NOT_STABLE_STATE (-105)
635 #define ERROR_JTAG_DEVICE_ERROR (-107)
638 /* this allows JTAG devices to implement the entire jtag_xxx() layer in hw/sw */
639 #ifdef HAVE_JTAG_MINIDRIVER_H
640 /* Here a #define MINIDRIVER() and an inline version of hw fifo interface_jtag_add_dr_out can be defined */
641 #include "jtag_minidriver.h"
642 #define MINIDRIVER(a) notused ## a
644 #define MINIDRIVER(a) a
646 /* jtag_add_dr_out() is a faster version of jtag_add_dr_scan()
648 * Current or end_state can not be TAP_RESET. end_state can be TAP_INVALID
650 * num_bits[i] is the number of bits to clock out from value[i] LSB first.
652 * If the device is in bypass, then that is an error condition in
653 * the caller code that is not detected by this fn, whereas jtag_add_dr_scan()
654 * does detect it. Similarly if the device is not in bypass, data must
657 * If anything fails, then jtag_error will be set and jtag_execute() will
658 * return an error. There is no way to determine if there was a failure
659 * during this function call.
661 * Note that this jtag_add_dr_out can be defined as an inline function.
663 extern void interface_jtag_add_dr_out(jtag_tap_t
* tap
, int num_fields
, const int* num_bits
, const u32
* value
,
664 tap_state_t end_state
);
668 static __inline__
void jtag_add_dr_out(jtag_tap_t
* tap
, int num_fields
, const int* num_bits
, const u32
* value
,
669 tap_state_t end_state
)
671 if (end_state
!= TAP_INVALID
)
672 cmd_queue_end_state
= end_state
;
673 cmd_queue_cur_state
= cmd_queue_end_state
;
674 interface_jtag_add_dr_out(tap
, num_fields
, num_bits
, value
, cmd_queue_end_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)