1 /***************************************************************************
2 * Copyright (C) 2007 by Juergen Stuber <juergen@jstuber.net> *
3 * based on Dominic Rath's and Benedikt Sauter's usbprog.c *
5 * Copyright (C) 2008 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
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 ***************************************************************************/
28 #include "replacements.h"
37 /* enable this to debug communication
40 #define _DEBUG_USB_COMMS_
43 #ifdef _DEBUG_JTAG_IO_
44 #define DEBUG_JTAG_IO(expr ...) LOG_DEBUG(expr)
46 #define DEBUG_JTAG_IO(expr ...)
52 #define JLINK_WRITE_ENDPOINT 0x02
53 #define JLINK_READ_ENDPOINT 0x81
55 #define JLINK_USB_TIMEOUT 100
57 #define JLINK_IN_BUFFER_SIZE 8192
58 #define JLINK_OUT_BUFFER_SIZE 8192
59 #define JLINK_EMU_RESULT_BUFFER_SIZE 64
61 /* Global USB buffers */
62 static u8 usb_in_buffer
[JLINK_IN_BUFFER_SIZE
];
63 static u8 usb_out_buffer
[JLINK_OUT_BUFFER_SIZE
];
64 static u8 usb_emu_result_buffer
[JLINK_EMU_RESULT_BUFFER_SIZE
];
66 /* Constants for JLink command */
67 #define EMU_CMD_VERSION 0x01
68 #define EMU_CMD_SET_SPEED 0x05
69 #define EMU_CMD_GET_STATE 0x07
70 #define EMU_CMD_HW_JTAG3 0xcf
71 #define EMU_CMD_HW_RESET0 0xdc
72 #define EMU_CMD_HW_RESET1 0xdd
73 #define EMU_CMD_HW_TRST0 0xde
74 #define EMU_CMD_HW_TRST1 0xdf
76 /* max speed 12MHz v5.0 jlink */
77 #define JLINK_MAX_SPEED 12000
79 /* External interface functions */
80 int jlink_execute_queue(void);
81 int jlink_speed(int speed
);
82 int jlink_khz(int khz
, int *jtag_speed
);
83 int jlink_register_commands(struct command_context_s
*cmd_ctx
);
87 /* CLI command handler functions */
88 int jlink_handle_jlink_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
);
90 /* Queue command functions */
91 void jlink_end_state(enum tap_state state
);
92 void jlink_state_move(void);
93 void jlink_path_move(int num_states
, enum tap_state
*path
);
94 void jlink_runtest(int num_cycles
);
95 void jlink_scan(int ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
, scan_command_t
*command
);
96 void jlink_reset(int trst
, int srst
);
97 void jlink_simple_command(u8 command
);
98 int jlink_get_status(void);
100 /* J-Link tap buffer functions */
101 void jlink_tap_init(void);
102 int jlink_tap_execute(void);
103 void jlink_tap_ensure_space(int scans
, int bits
);
104 void jlink_tap_append_step(int tms
, int tdi
);
105 void jlink_tap_append_scan(int length
, u8
*buffer
, scan_command_t
*command
);
107 /* Jlink lowlevel functions */
108 typedef struct jlink_jtag
110 struct usb_dev_handle
* usb_handle
;
113 jlink_jtag_t
*jlink_usb_open(void);
114 void jlink_usb_close(jlink_jtag_t
*jlink_jtag
);
115 int jlink_usb_message(jlink_jtag_t
*jlink_jtag
, int out_length
, int in_length
);
116 int jlink_usb_write(jlink_jtag_t
*jlink_jtag
, int out_length
);
117 int jlink_usb_read(jlink_jtag_t
*jlink_jtag
);
118 int jlink_usb_read_emu_result(jlink_jtag_t
*jlink_jtag
);
120 /* helper functions */
121 int jlink_get_version_info(void);
123 #ifdef _DEBUG_USB_COMMS_
124 void jlink_debug_buffer(u8
*buffer
, int length
);
127 jlink_jtag_t
* jlink_jtag_handle
;
129 /***************************************************************************/
130 /* External interface implementation */
132 jtag_interface_t jlink_interface
=
135 .execute_queue
= jlink_execute_queue
,
136 .speed
= jlink_speed
,
138 .register_commands
= jlink_register_commands
,
143 int jlink_execute_queue(void)
145 jtag_command_t
*cmd
= jtag_command_queue
;
155 DEBUG_JTAG_IO("end_state: %i", cmd
->cmd
.end_state
->end_state
);
157 if (cmd
->cmd
.end_state
->end_state
!= -1)
159 jlink_end_state(cmd
->cmd
.end_state
->end_state
);
164 DEBUG_JTAG_IO( "runtest %i cycles, end in %i", cmd
->cmd
.runtest
->num_cycles
, \
165 cmd
->cmd
.runtest
->end_state
);
167 if (cmd
->cmd
.runtest
->end_state
!= -1)
169 jlink_end_state(cmd
->cmd
.runtest
->end_state
);
171 jlink_runtest(cmd
->cmd
.runtest
->num_cycles
);
175 DEBUG_JTAG_IO("statemove end in %i", cmd
->cmd
.statemove
->end_state
);
177 if (cmd
->cmd
.statemove
->end_state
!= -1)
179 jlink_end_state(cmd
->cmd
.statemove
->end_state
);
185 DEBUG_JTAG_IO("pathmove: %i states, end in %i", \
186 cmd
->cmd
.pathmove
->num_states
, \
187 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
189 jlink_path_move(cmd
->cmd
.pathmove
->num_states
, cmd
->cmd
.pathmove
->path
);
193 DEBUG_JTAG_IO("scan end in %i", cmd
->cmd
.scan
->end_state
);
195 if (cmd
->cmd
.scan
->end_state
!= -1)
197 jlink_end_state(cmd
->cmd
.scan
->end_state
);
200 scan_size
= jtag_build_buffer(cmd
->cmd
.scan
, &buffer
);
201 DEBUG_JTAG_IO("scan input, length = %d", scan_size
);
203 #ifdef _DEBUG_USB_COMMS_
204 jlink_debug_buffer(buffer
, (scan_size
+ 7) / 8);
206 type
= jtag_scan_type(cmd
->cmd
.scan
);
207 jlink_scan(cmd
->cmd
.scan
->ir_scan
, type
, buffer
, scan_size
, cmd
->cmd
.scan
);
211 DEBUG_JTAG_IO("reset trst: %i srst %i", cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
215 if (cmd
->cmd
.reset
->trst
== 1)
219 jlink_reset(cmd
->cmd
.reset
->trst
, cmd
->cmd
.reset
->srst
);
223 DEBUG_JTAG_IO("sleep %i", cmd
->cmd
.sleep
->us
);
225 jtag_sleep(cmd
->cmd
.sleep
->us
);
229 LOG_ERROR("BUG: unknown JTAG command type encountered");
235 return jlink_tap_execute();
238 /* Sets speed in kHz. */
239 int jlink_speed(int speed
)
243 if (speed
<= JLINK_MAX_SPEED
)
245 /* check for RTCK setting */
249 usb_out_buffer
[0] = EMU_CMD_SET_SPEED
;
250 usb_out_buffer
[1] = (speed
>> 0) & 0xff;
251 usb_out_buffer
[2] = (speed
>> 8) & 0xff;
253 result
= jlink_usb_write(jlink_jtag_handle
, 3);
261 LOG_ERROR("J-Link setting speed failed (%d)", result
);
262 return ERROR_JTAG_DEVICE_ERROR
;
267 LOG_INFO("Requested speed %dkHz exceeds maximum of %dkHz, ignored", speed
, JLINK_MAX_SPEED
);
273 int jlink_khz(int khz
, int *jtag_speed
)
280 int jlink_register_commands(struct command_context_s
*cmd_ctx
)
282 register_command(cmd_ctx
, NULL
, "jlink_info", jlink_handle_jlink_info_command
, COMMAND_EXEC
,
291 jlink_jtag_handle
= jlink_usb_open();
293 if (jlink_jtag_handle
== 0)
295 LOG_ERROR("Cannot find jlink Interface! Please check connection and permissions.");
296 return ERROR_JTAG_INIT_FAILED
;
300 while (check_cnt
< 3)
302 if (jlink_get_version_info() == ERROR_OK
)
304 /* attempt to get status */
314 LOG_INFO("J-Link initial read failed, don't worry");
317 LOG_INFO("J-Link JTAG Interface ready");
327 jlink_usb_close(jlink_jtag_handle
);
331 /***************************************************************************/
332 /* Queue command implementations */
334 void jlink_end_state(enum tap_state state
)
336 if (tap_move_map
[state
] != -1)
342 LOG_ERROR("BUG: %i is not a valid end state", state
);
347 /* Goes to the end state. */
348 void jlink_state_move(void)
352 u8 tms_scan
= TAP_MOVE(cur_state
, end_state
);
354 for (i
= 0; i
< 7; i
++)
356 tms
= (tms_scan
>> i
) & 1;
357 jlink_tap_append_step(tms
, 0);
360 cur_state
= end_state
;
363 void jlink_path_move(int num_states
, enum tap_state
*path
)
367 for (i
= 0; i
< num_states
; i
++)
369 if (path
[i
] == tap_transitions
[cur_state
].low
)
371 jlink_tap_append_step(0, 0);
373 else if (path
[i
] == tap_transitions
[cur_state
].high
)
375 jlink_tap_append_step(1, 0);
379 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings
[cur_state
], tap_state_strings
[path
[i
]]);
386 end_state
= cur_state
;
389 void jlink_runtest(int num_cycles
)
393 enum tap_state saved_end_state
= end_state
;
395 /* only do a state_move when we're not already in RTI */
396 if (cur_state
!= TAP_RTI
)
398 jlink_end_state(TAP_RTI
);
402 /* execute num_cycles */
403 for (i
= 0; i
< num_cycles
; i
++)
405 jlink_tap_append_step(0, 0);
408 /* finish in end_state */
409 jlink_end_state(saved_end_state
);
410 if (cur_state
!= end_state
)
416 void jlink_scan(int ir_scan
, enum scan_type type
, u8
*buffer
, int scan_size
, scan_command_t
*command
)
418 enum tap_state saved_end_state
;
420 jlink_tap_ensure_space(1, scan_size
+ 8);
422 saved_end_state
= end_state
;
424 /* Move to appropriate scan state */
425 jlink_end_state(ir_scan
? TAP_SI
: TAP_SD
);
428 jlink_end_state(saved_end_state
);
431 jlink_tap_append_scan(scan_size
, buffer
, command
);
433 /* We are in Exit1, go to Pause */
434 jlink_tap_append_step(0, 0);
436 cur_state
= ir_scan
? TAP_PI
: TAP_PD
;
438 if (cur_state
!= end_state
)
444 void jlink_reset(int trst
, int srst
)
446 LOG_DEBUG("trst: %i, srst: %i", trst
, srst
);
448 /* Signals are active low */
451 jlink_simple_command(EMU_CMD_HW_RESET1
);
455 jlink_simple_command(EMU_CMD_HW_RESET0
);
460 jlink_simple_command(EMU_CMD_HW_TRST1
);
464 jlink_simple_command(EMU_CMD_HW_TRST0
);
468 void jlink_simple_command(u8 command
)
472 DEBUG_JTAG_IO("0x%02x", command
);
474 usb_out_buffer
[0] = command
;
475 result
= jlink_usb_write(jlink_jtag_handle
, 1);
479 LOG_ERROR("J-Link command 0x%02x failed (%d)", command
, result
);
483 int jlink_get_status(void)
487 jlink_simple_command(EMU_CMD_GET_STATE
);
488 result
= jlink_usb_read(jlink_jtag_handle
);
492 int vref
= usb_in_buffer
[0] + (usb_in_buffer
[1] << 8);
493 LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d\n", \
494 vref
/ 1000, vref
% 1000, \
495 usb_in_buffer
[2], usb_in_buffer
[3], usb_in_buffer
[4], \
496 usb_in_buffer
[5], usb_in_buffer
[6], usb_in_buffer
[7]);
500 LOG_ERROR("Vref too low. Check Target Power\n");
505 LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result
);
511 int jlink_get_version_info(void)
516 /* query hardware version */
517 jlink_simple_command(EMU_CMD_VERSION
);
518 result
= jlink_usb_read(jlink_jtag_handle
);
522 len
= buf_get_u32(usb_in_buffer
, 0, 16);
523 result
= jlink_usb_read(jlink_jtag_handle
);
527 usb_in_buffer
[result
] = 0;
528 LOG_INFO(usb_in_buffer
);
533 LOG_ERROR("J-Link command EMU_CMD_VERSION failed (%d)\n", result
);
534 return ERROR_JTAG_DEVICE_ERROR
;
537 int jlink_handle_jlink_info_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
539 if (jlink_get_version_info() == ERROR_OK
)
541 /* attempt to get status */
548 /***************************************************************************/
549 /* J-Link tap functions */
551 /* 2048 is the max value we can use here */
552 #define JLINK_TAP_BUFFER_SIZE 2048
554 static int tap_length
;
555 static u8 tms_buffer
[JLINK_TAP_BUFFER_SIZE
];
556 static u8 tdi_buffer
[JLINK_TAP_BUFFER_SIZE
];
557 static u8 tdo_buffer
[JLINK_TAP_BUFFER_SIZE
];
561 int first
; /* First bit position in tdo_buffer to read */
562 int length
; /* Number of bits to read */
563 scan_command_t
*command
; /* Corresponding scan command */
565 } pending_scan_result_t
;
567 #define MAX_PENDING_SCAN_RESULTS 256
569 static int pending_scan_results_length
;
570 static pending_scan_result_t pending_scan_results_buffer
[MAX_PENDING_SCAN_RESULTS
];
574 void jlink_tap_init(void)
577 pending_scan_results_length
= 0;
580 void jlink_tap_ensure_space(int scans
, int bits
)
582 int available_scans
= MAX_PENDING_SCAN_RESULTS
- pending_scan_results_length
;
583 int available_bits
= JLINK_TAP_BUFFER_SIZE
* 8 - tap_length
;
585 if (scans
> available_scans
|| bits
> available_bits
)
591 void jlink_tap_append_step(int tms
, int tdi
)
594 int index
= tap_length
/ 8;
596 if (index
< JLINK_TAP_BUFFER_SIZE
)
598 int bit_index
= tap_length
% 8;
599 u8 bit
= 1 << bit_index
;
603 tms_buffer
[index
] |= bit
;
607 tms_buffer
[index
] &= ~bit
;
612 tdi_buffer
[index
] |= bit
;
616 tdi_buffer
[index
] &= ~bit
;
623 LOG_ERROR("jlink_tap_append_step, overflow");
627 void jlink_tap_append_scan(int length
, u8
*buffer
, scan_command_t
*command
)
629 pending_scan_result_t
*pending_scan_result
= &pending_scan_results_buffer
[pending_scan_results_length
];
632 pending_scan_result
->first
= tap_length
;
633 pending_scan_result
->length
= length
;
634 pending_scan_result
->command
= command
;
635 pending_scan_result
->buffer
= buffer
;
637 for (i
= 0; i
< length
; i
++)
639 jlink_tap_append_step((i
< length
-1 ? 0 : 1), (buffer
[i
/8] >> (i
%8)) & 1);
641 pending_scan_results_length
++;
644 /* Pad and send a tap sequence to the device, and receive the answer.
645 * For the purpose of padding we assume that we are in idle or pause state. */
646 int jlink_tap_execute(void)
656 /* Pad last byte so that tap_length is divisible by 8 */
657 while (tap_length
% 8 != 0)
659 /* More of the last TMS value keeps us in the same state,
660 * analogous to free-running JTAG interfaces. */
661 jlink_tap_append_step(last_tms
, 0);
664 byte_length
= tap_length
/ 8;
666 usb_out_buffer
[0] = EMU_CMD_HW_JTAG3
;
667 usb_out_buffer
[1] = 0;
668 usb_out_buffer
[2] = (tap_length
>> 0) & 0xff;
669 usb_out_buffer
[3] = (tap_length
>> 8) & 0xff;
672 for (i
= 0; i
< byte_length
; i
++)
674 usb_out_buffer
[tms_offset
+ i
] = tms_buffer
[i
];
677 tdi_offset
= tms_offset
+ byte_length
;
678 for (i
= 0; i
< byte_length
; i
++)
680 usb_out_buffer
[tdi_offset
+ i
] = tdi_buffer
[i
];
683 result
= jlink_usb_message(jlink_jtag_handle
, 4 + 2 * byte_length
, byte_length
);
685 if (result
== byte_length
)
687 for (i
= 0; i
< byte_length
; i
++)
689 tdo_buffer
[i
] = usb_in_buffer
[i
];
692 for (i
= 0; i
< pending_scan_results_length
; i
++)
694 pending_scan_result_t
*pending_scan_result
= &pending_scan_results_buffer
[i
];
695 u8
*buffer
= pending_scan_result
->buffer
;
696 int length
= pending_scan_result
->length
;
697 int first
= pending_scan_result
->first
;
698 scan_command_t
*command
= pending_scan_result
->command
;
701 buf_set_buf(tdo_buffer
, first
, buffer
, 0, length
);
703 DEBUG_JTAG_IO("pending scan result, length = %d", length
);
705 #ifdef _DEBUG_USB_COMMS_
706 jlink_debug_buffer(buffer
, byte_length
);
709 if (jtag_read_buffer(buffer
, command
) != ERROR_OK
)
712 return ERROR_JTAG_QUEUE_FAILED
;
715 if (pending_scan_result
->buffer
!= NULL
)
717 free(pending_scan_result
->buffer
);
723 LOG_ERROR("jlink_tap_execute, wrong result %d, expected %d", result
, byte_length
);
724 return ERROR_JTAG_QUEUE_FAILED
;
733 /*****************************************************************************/
734 /* JLink USB low-level functions */
736 jlink_jtag_t
* jlink_usb_open()
738 struct usb_bus
*busses
;
740 struct usb_device
*dev
;
742 jlink_jtag_t
*result
;
744 result
= (jlink_jtag_t
*) malloc(sizeof(jlink_jtag_t
));
750 busses
= usb_get_busses();
752 /* find jlink_jtag device in usb bus */
754 for (bus
= busses
; bus
; bus
= bus
->next
)
756 for (dev
= bus
->devices
; dev
; dev
= dev
->next
)
758 if ((dev
->descriptor
.idVendor
== VID
) && (dev
->descriptor
.idProduct
== PID
))
760 result
->usb_handle
= usb_open(dev
);
762 /* usb_set_configuration required under win32 */
763 usb_set_configuration(result
->usb_handle
, dev
->config
[0].bConfigurationValue
);
764 usb_claim_interface(result
->usb_handle
, 0);
768 * This makes problems under Mac OS X. And is not needed
769 * under Windows. Hopefully this will not break a linux build
771 usb_set_altinterface(result
->usb_handle
, 0);
782 void jlink_usb_close(jlink_jtag_t
*jlink_jtag
)
784 usb_close(jlink_jtag
->usb_handle
);
788 /* Send a message and receive the reply. */
789 int jlink_usb_message(jlink_jtag_t
*jlink_jtag
, int out_length
, int in_length
)
794 result
= jlink_usb_write(jlink_jtag
, out_length
);
795 if (result
== out_length
)
797 result
= jlink_usb_read(jlink_jtag
);
798 if (result
== in_length
|| result
== in_length
+1)
800 if (result
== in_length
)
802 /* Must read the result from the EMU too */
803 result2
= jlink_usb_read_emu_result(jlink_jtag
);
806 /* Check the result itself */
807 if (0 == usb_emu_result_buffer
[0])
813 LOG_ERROR("jlink_usb_read_emu_result (requested=0, result=%d)", usb_emu_result_buffer
[0]);
819 LOG_ERROR("jlink_usb_read_emu_result len (requested=1, result=%d)", result2
);
825 /* Check the result itself */
826 if (0 == usb_in_buffer
[result
-1])
832 LOG_ERROR("jlink_usb_read_emu_result (requested=0, result=%d)", usb_in_buffer
[result
]);
839 LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)", in_length
, result
);
845 LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)", out_length
, result
);
850 /* Write data from out_buffer to USB. */
851 int jlink_usb_write(jlink_jtag_t
*jlink_jtag
, int out_length
)
855 if (out_length
> JLINK_OUT_BUFFER_SIZE
)
857 LOG_ERROR("jlink_jtag_write illegal out_length=%d (max=%d)", out_length
, JLINK_OUT_BUFFER_SIZE
);
861 result
= usb_bulk_write(jlink_jtag
->usb_handle
, JLINK_WRITE_ENDPOINT
, \
862 usb_out_buffer
, out_length
, JLINK_USB_TIMEOUT
);
864 DEBUG_JTAG_IO("jlink_usb_write, out_length = %d, result = %d", out_length
, result
);
866 #ifdef _DEBUG_USB_COMMS_
867 jlink_debug_buffer(usb_out_buffer
, out_length
);
872 /* Read data from USB into in_buffer. */
873 int jlink_usb_read(jlink_jtag_t
*jlink_jtag
)
875 int result
= usb_bulk_read(jlink_jtag
->usb_handle
, JLINK_READ_ENDPOINT
, \
876 usb_in_buffer
, JLINK_IN_BUFFER_SIZE
, JLINK_USB_TIMEOUT
);
878 DEBUG_JTAG_IO("jlink_usb_read, result = %d", result
);
880 #ifdef _DEBUG_USB_COMMS_
881 jlink_debug_buffer(usb_in_buffer
, result
);
886 /* Read the result from the previous EMU cmd into result_buffer. */
887 int jlink_usb_read_emu_result(jlink_jtag_t
*jlink_jtag
)
889 int result
= usb_bulk_read(jlink_jtag
->usb_handle
, JLINK_READ_ENDPOINT
, \
890 usb_emu_result_buffer
, JLINK_EMU_RESULT_BUFFER_SIZE
, JLINK_USB_TIMEOUT
);
892 DEBUG_JTAG_IO("jlink_usb_read_result, result = %d", result
);
894 #ifdef _DEBUG_USB_COMMS_
895 jlink_debug_buffer(usb_emu_result_buffer
, result
);
900 #ifdef _DEBUG_USB_COMMS_
901 #define BYTES_PER_LINE 16
903 void jlink_debug_buffer(u8
*buffer
, int length
)
910 for (i
= 0; i
< length
; i
+= BYTES_PER_LINE
)
912 snprintf(line
, 5, "%04x", i
);
913 for (j
= i
; j
< i
+ BYTES_PER_LINE
&& j
< length
; j
++)
915 snprintf(s
, 4, " %02x", buffer
[j
]);
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)