1 /***************************************************************************
2 * Copyright (C) 2007 by Pavel Chromy *
5 * This program is free software; you can redistribute it and/or modify *
6 * it under the terms of the GNU General Public License as published by *
7 * the Free Software Foundation; either version 2 of the License, or *
8 * (at your option) any later version. *
10 * This program is distributed in the hope that it will be useful, *
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
13 * GNU General Public License for more details. *
15 * You should have received a copy of the GNU General Public License *
16 * along with this program; if not, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
28 #include "replacements.h"
30 /* project specific includes */
34 #include "configuration.h"
35 #include "time_support.h"
43 /* PRESTO access library includes */
44 #if BUILD_PRESTO_FTD2XX == 1
46 #elif BUILD_PRESTO_LIBFTDI == 1
49 #error "BUG: either FTD2XX and LIBFTDI has to be used"
53 int presto_jtag_speed(int speed
);
54 int presto_jtag_khz(int khz
, int *jtag_speed
);
55 int presto_jtag_speed_div(int speed
, int *khz
);
56 int presto_jtag_register_commands(struct command_context_s
*cmd_ctx
);
57 int presto_jtag_init(void);
58 int presto_jtag_quit(void);
60 jtag_interface_t presto_interface
=
63 .execute_queue
= bitq_execute_queue
,
64 .speed
= presto_jtag_speed
,
65 .khz
= presto_jtag_khz
,
66 .speed_div
= presto_jtag_speed_div
,
67 .register_commands
= presto_jtag_register_commands
,
68 .init
= presto_jtag_init
,
69 .quit
= presto_jtag_quit
,
73 int presto_bitq_out(int tms
, int tdi
, int tdo_req
);
74 int presto_bitq_flush(void);
75 int presto_bitq_sleep(unsigned long us
);
76 int presto_bitq_reset(int trst
, int srst
);
77 int presto_bitq_in_rdy(void);
78 int presto_bitq_in(void);
80 bitq_interface_t presto_bitq
=
82 .out
= presto_bitq_out
,
83 .flush
= presto_bitq_flush
,
84 .sleep
= presto_bitq_sleep
,
85 .reset
= presto_bitq_reset
,
86 .in_rdy
= presto_bitq_in_rdy
,
91 /* -------------------------------------------------------------------------- */
94 #define FT_DEVICE_NAME_LEN 64
95 #define FT_DEVICE_SERNUM_LEN 64
97 #define PRESTO_VID_PID 0x0403f1a0
98 #define PRESTO_VID (0x0403)
99 #define PRESTO_PID (0xf1a0)
101 #define BUFFER_SIZE (64*62)
103 typedef struct presto_s
105 #if BUILD_PRESTO_FTD2XX == 1
108 #elif BUILD_PRESTO_LIBFTDI == 1
109 struct ftdi_context ftdic
;
113 char serial
[FT_DEVICE_SERNUM_LEN
];
115 u8 buff_out
[BUFFER_SIZE
];
118 u8 buff_in
[BUFFER_SIZE
];
119 int buff_in_exp
; /* expected in buffer length */
120 int buff_in_len
; /* length of data received */
123 unsigned long total_out
;
124 unsigned long total_in
;
126 int jtag_tms
; /* last tms state */
127 int jtag_tck
; /* last tck state */
128 int jtag_rst
; /* last trst state */
137 presto_t presto_state
;
138 presto_t
*presto
= &presto_state
;
140 u8 presto_init_seq
[] =
142 0x80, 0xA0, 0xA8, 0xB0, 0xC0, 0xE0
145 int presto_write(u8
*buf
, int size
)
147 #if BUILD_PRESTO_FTD2XX == 1
149 if ((presto
->status
= FT_Write(presto
->handle
, buf
, size
, &ftbytes
)) != FT_OK
)
151 LOG_ERROR("FT_Write returned: %lu", presto
->status
);
152 return ERROR_JTAG_DEVICE_ERROR
;
155 #elif BUILD_PRESTO_LIBFTDI == 1
157 if ((presto
->retval
= ftdi_write_data(&presto
->ftdic
, buf
, size
)) < 0)
159 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&presto
->ftdic
));
160 return ERROR_JTAG_DEVICE_ERROR
;
162 ftbytes
= presto
->retval
;
167 LOG_ERROR("couldn't write the requested number of bytes to PRESTO (%i < %i)", ftbytes
, size
);
168 return ERROR_JTAG_DEVICE_ERROR
;
174 int presto_read(u8
* buf
, int size
)
176 #if BUILD_PRESTO_FTD2XX == 1
178 if ((presto
->status
= FT_Read(presto
->handle
, buf
, size
, &ftbytes
)) != FT_OK
)
180 LOG_ERROR("FT_Read returned: %lu", presto
->status
);
181 return ERROR_JTAG_DEVICE_ERROR
;
184 #elif BUILD_PRESTO_LIBFTDI == 1
187 struct timeval timeout
, now
;
188 gettimeofday(&timeout
, NULL
);
189 timeval_add_time(&timeout
, 1, 0); /* one second timeout */
191 while (ftbytes
< size
)
193 if ((presto
->retval
= ftdi_read_data(&presto
->ftdic
, buf
+ ftbytes
, size
- ftbytes
)) < 0)
195 LOG_ERROR("ftdi_read_data: %s", ftdi_get_error_string(&presto
->ftdic
));
196 return ERROR_JTAG_DEVICE_ERROR
;
198 ftbytes
+= presto
->retval
;
200 gettimeofday(&now
, NULL
);
201 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
> timeout
.tv_usec
)))
208 /* this is just a warning, there might have been timeout when detecting PRESTO, which is not fatal */
209 LOG_WARNING("couldn't read the requested number of bytes from PRESTO (%i < %i)", ftbytes
, size
);
210 return ERROR_JTAG_DEVICE_ERROR
;
216 #if BUILD_PRESTO_FTD2XX == 1
217 int presto_open_ftd2xx(char *req_serial
)
222 char devname
[FT_DEVICE_NAME_LEN
];
228 presto
->handle
= (FT_HANDLE
)INVALID_HANDLE_VALUE
;
231 /* Add non-standard Vid/Pid to the linux driver */
232 if ((presto
->status
= FT_SetVIDPID(PRESTO_VID
, PRESTO_PID
)) != FT_OK
)
234 LOG_ERROR("couldn't add PRESTO VID/PID");
239 if ((presto
->status
= FT_ListDevices(&numdevs
, NULL
, FT_LIST_NUMBER_ONLY
)) != FT_OK
)
241 LOG_ERROR("FT_ListDevices failed: %i", (int)presto
->status
);
242 return ERROR_JTAG_DEVICE_ERROR
;
245 LOG_DEBUG("FTDI devices available: %i", numdevs
);
246 for (i
= 0; i
< numdevs
; i
++)
248 if ((presto
->status
= FT_Open(i
, &(presto
->handle
))) != FT_OK
)
250 /* this is not fatal, the device may be legitimately open by other process, hence debug message only */
251 LOG_DEBUG("FT_Open failed: %i", (int)presto
->status
);
254 LOG_DEBUG("FTDI device %i open", i
);
256 if ((presto
->status
= FT_GetDeviceInfo(presto
->handle
, &device
, &vidpid
,
257 presto
->serial
, devname
, NULL
)) == FT_OK
)
259 if (vidpid
== PRESTO_VID_PID
260 && (req_serial
== NULL
|| !strcmp(presto
->serial
, req_serial
)))
264 LOG_DEBUG("FT_GetDeviceInfo failed: %i", presto
->status
);
266 LOG_DEBUG("FTDI device %i does not match, closing", i
);
267 FT_Close(presto
->handle
);
268 presto
->handle
= (FT_HANDLE
)INVALID_HANDLE_VALUE
;
271 if (presto
->handle
== (FT_HANDLE
)INVALID_HANDLE_VALUE
)
272 return ERROR_JTAG_DEVICE_ERROR
; /* presto not open, return */
274 if ((presto
->status
= FT_SetLatencyTimer(presto
->handle
, 1)) != FT_OK
)
275 return ERROR_JTAG_DEVICE_ERROR
;
278 if ((presto
->status
= FT_SetTimeouts(presto
->handle
, 100, 0)) != FT_OK
)
279 return ERROR_JTAG_DEVICE_ERROR
;
281 if ((presto
->status
= FT_Purge(presto
->handle
, FT_PURGE_TX
| FT_PURGE_RX
)) != FT_OK
)
282 return ERROR_JTAG_DEVICE_ERROR
;
285 if ((presto
->status
= FT_Write(presto
->handle
, &presto_data
, 1, &ftbytes
)) != FT_OK
)
286 return ERROR_JTAG_DEVICE_ERROR
;
288 /* delay between first write/read turnaround (after purge?) necessary under Linux for unknown reason,
289 probably a bug in library threading */
291 if ((presto
->status
= FT_Read(presto
->handle
, &presto_data
, 1, &ftbytes
)) != FT_OK
)
292 return ERROR_JTAG_DEVICE_ERROR
;
296 LOG_DEBUG("PRESTO reset");
298 if ((presto
->status
= FT_Purge(presto
->handle
, FT_PURGE_TX
| FT_PURGE_RX
)) != FT_OK
)
299 return ERROR_JTAG_DEVICE_ERROR
;
300 if ((presto
->status
= FT_SetBitMode(presto
->handle
, 0x80, 1)) != FT_OK
)
301 return ERROR_JTAG_DEVICE_ERROR
;
302 if ((presto
->status
= FT_SetBaudRate(presto
->handle
, 9600)) != FT_OK
)
303 return ERROR_JTAG_DEVICE_ERROR
;
306 for (i
= 0; i
< 4 * 62; i
++)
307 if ((presto
->status
=FT_Write(presto
->handle
, &presto_data
, 1, &ftbytes
)) != FT_OK
)
308 return ERROR_JTAG_DEVICE_ERROR
;
312 if ((presto
->status
= FT_SetBitMode(presto
->handle
, 0x00, 0)) != FT_OK
)
313 return ERROR_JTAG_DEVICE_ERROR
;
315 if ((presto
->status
= FT_Purge(presto
->handle
, FT_PURGE_TX
| FT_PURGE_RX
)) != FT_OK
)
316 return ERROR_JTAG_DEVICE_ERROR
;
319 if ((presto
->status
= FT_Write(presto
->handle
, &presto_data
, 1, &ftbytes
)) != FT_OK
)
320 return ERROR_JTAG_DEVICE_ERROR
;
322 /* delay between first write/read turnaround (after purge?) necessary under Linux for unknown reason,
323 probably a bug in library threading */
325 if ((presto
->status
= FT_Read(presto
->handle
, &presto_data
, 1, &ftbytes
)) != FT_OK
)
326 return ERROR_JTAG_DEVICE_ERROR
;
330 LOG_DEBUG("PRESTO not responding");
331 return ERROR_JTAG_DEVICE_ERROR
;
335 if ((presto
->status
= FT_SetTimeouts(presto
->handle
, 0, 0)) != FT_OK
)
336 return ERROR_JTAG_DEVICE_ERROR
;
339 presto
->status
= FT_Write(presto
->handle
, &presto_init_seq
, sizeof(presto_init_seq
), &ftbytes
);
340 if (presto
->status
!= FT_OK
|| ftbytes
!= sizeof(presto_init_seq
))
341 return ERROR_JTAG_DEVICE_ERROR
;
346 #elif BUILD_PRESTO_LIBFTDI == 1
347 int presto_open_libftdi(char *req_serial
)
351 LOG_DEBUG("searching for PRESTO using libftdi");
353 /* initialize FTDI context structure */
354 if (ftdi_init(&presto
->ftdic
) < 0)
356 LOG_ERROR("unable to init libftdi: %s", presto
->ftdic
.error_str
);
357 return ERROR_JTAG_DEVICE_ERROR
;
360 /* context, vendor id, product id */
361 if (ftdi_usb_open_desc(&presto
->ftdic
, PRESTO_VID
, PRESTO_PID
, NULL
, req_serial
) < 0)
363 LOG_ERROR("unable to open PRESTO: %s", presto
->ftdic
.error_str
);
364 return ERROR_JTAG_DEVICE_ERROR
;
367 if (ftdi_usb_reset(&presto
->ftdic
) < 0)
369 LOG_ERROR("unable to reset PRESTO device");
370 return ERROR_JTAG_DEVICE_ERROR
;
373 if (ftdi_set_latency_timer(&presto
->ftdic
, 1) < 0)
375 LOG_ERROR("unable to set latency timer");
376 return ERROR_JTAG_DEVICE_ERROR
;
379 if (ftdi_usb_purge_buffers(&presto
->ftdic
) < 0)
381 LOG_ERROR("unable to purge PRESTO buffers");
382 return ERROR_JTAG_DEVICE_ERROR
;
386 if (presto_write(&presto_data
, 1) != ERROR_OK
)
388 LOG_ERROR("error writing to PRESTO");
389 return ERROR_JTAG_DEVICE_ERROR
;
392 if (presto_read(&presto_data
, 1) != ERROR_OK
)
394 LOG_DEBUG("no response from PRESTO, retrying");
396 if (ftdi_usb_purge_buffers(&presto
->ftdic
) < 0)
397 return ERROR_JTAG_DEVICE_ERROR
;
400 if (presto_write(&presto_data
, 1) != ERROR_OK
)
401 return ERROR_JTAG_DEVICE_ERROR
;
403 if (presto_read(&presto_data
, 1) != ERROR_OK
)
405 LOG_ERROR("no response from PRESTO, giving up");
406 return ERROR_JTAG_DEVICE_ERROR
;
410 if (presto_write(presto_init_seq
, sizeof(presto_init_seq
)) != ERROR_OK
)
412 LOG_ERROR("error writing PRESTO init sequence");
413 return ERROR_JTAG_DEVICE_ERROR
;
418 #endif /* BUILD_PRESTO_LIBFTDI == 1 */
420 int presto_open(char *req_serial
)
422 presto
->buff_out_pos
=0;
423 presto
->buff_in_pos
=0;
424 presto
->buff_in_len
=0;
425 presto
->buff_in_exp
=0;
433 presto
->jtag_tdi_data
=0;
434 presto
->jtag_tdi_count
=0;
436 presto
->jtag_speed
=0;
438 #if BUILD_PRESTO_FTD2XX == 1
439 return presto_open_ftd2xx(req_serial
);
440 #elif BUILD_PRESTO_LIBFTDI == 1
441 return presto_open_libftdi(req_serial
);
445 int presto_close(void)
448 int result
= ERROR_OK
;
450 #if BUILD_PRESTO_FTD2XX == 1
451 unsigned long ftbytes
;
453 if (presto
->handle
== (FT_HANDLE
)INVALID_HANDLE_VALUE
)
456 presto
->status
= FT_Purge(presto
->handle
, FT_PURGE_TX
| FT_PURGE_RX
);
457 if (presto
->status
!= FT_OK
)
458 result
= ERROR_JTAG_DEVICE_ERROR
;
460 presto
->status
= FT_Write(presto
->handle
, &presto_init_seq
, sizeof(presto_init_seq
), &ftbytes
);
461 if (presto
->status
!= FT_OK
|| ftbytes
!= sizeof(presto_init_seq
))
462 result
= ERROR_JTAG_DEVICE_ERROR
;
464 if ((presto
->status
= FT_SetLatencyTimer(presto
->handle
, 16)) != FT_OK
)
465 result
= ERROR_JTAG_DEVICE_ERROR
;
467 if ((presto
->status
= FT_Close(presto
->handle
)) != FT_OK
)
468 result
= ERROR_JTAG_DEVICE_ERROR
;
470 presto
->handle
= (FT_HANDLE
)INVALID_HANDLE_VALUE
;
472 #elif BUILD_PRESTO_LIBFTDI == 1
474 if ((presto
->retval
= ftdi_write_data(&presto
->ftdic
, presto_init_seq
, sizeof(presto_init_seq
))) != sizeof(presto_init_seq
))
475 result
= ERROR_JTAG_DEVICE_ERROR
;
477 if ((presto
->retval
= ftdi_set_latency_timer(&presto
->ftdic
, 16)) < 0)
478 result
= ERROR_JTAG_DEVICE_ERROR
;
480 if ((presto
->retval
= ftdi_usb_close(&presto
->ftdic
)) < 0)
481 result
= ERROR_JTAG_DEVICE_ERROR
;
483 ftdi_deinit(&presto
->ftdic
);
490 int presto_flush(void)
492 if (presto
->buff_out_pos
== 0)
495 #if BUILD_PRESTO_FTD2XX == 1
496 if (presto
->status
!= FT_OK
)
497 #elif BUILD_PRESTO_LIBFTDI == 1
498 if (presto
->retval
< 0)
501 LOG_DEBUG("error in previous communication, canceling I/O operation");
502 return ERROR_JTAG_DEVICE_ERROR
;
505 if (presto_write(presto
->buff_out
, presto
->buff_out_pos
) != ERROR_OK
)
507 presto
->buff_out_pos
= 0;
508 return ERROR_JTAG_DEVICE_ERROR
;
511 presto
->total_out
+= presto
->buff_out_pos
;
512 presto
->buff_out_pos
= 0;
514 if (presto
->buff_in_exp
== 0)
517 presto
->buff_in_pos
= 0;
518 presto
->buff_in_len
= 0;
520 if (presto_read(presto
->buff_in
, presto
->buff_in_exp
) != ERROR_OK
)
522 presto
->buff_in_exp
= 0;
523 return ERROR_JTAG_DEVICE_ERROR
;
526 presto
->total_in
+= presto
->buff_in_exp
;
527 presto
->buff_in_len
= presto
->buff_in_exp
;
528 presto
->buff_in_exp
= 0;
534 int presto_sendbyte(int data
)
536 if (data
== EOF
) return presto_flush();
538 if (presto
->buff_out_pos
< BUFFER_SIZE
)
540 presto
->buff_out
[presto
->buff_out_pos
++] = (u8
)data
;
541 if (((data
& 0xC0) == 0x40) || ((data
& 0xD0)== 0xD0))
542 presto
->buff_in_exp
++;
545 return ERROR_JTAG_DEVICE_ERROR
;
547 #if BUILD_PRESTO_FTD2XX == 1
548 if (presto
->buff_out_pos
>= BUFFER_SIZE
)
549 #elif BUILD_PRESTO_LIBFTDI == 1
550 /* libftdi does not do background read, be sure that USB IN buffer does not overflow (128 bytes only!) */
551 if (presto
->buff_out_pos
>= BUFFER_SIZE
|| presto
->buff_in_exp
==128)
553 return presto_flush();
559 int presto_getbyte(void)
561 if (presto
->buff_in_pos
< presto
->buff_in_len
)
562 return presto
->buff_in
[presto
->buff_in_pos
++];
564 if (presto
->buff_in_exp
== 0)
567 if (presto_flush() != ERROR_OK
)
570 if (presto
->buff_in_pos
<presto
->buff_in_len
)
571 return presto
->buff_in
[presto
->buff_in_pos
++];
577 /* -------------------------------------------------------------------------- */
580 int presto_tdi_flush(void)
582 if (presto
->jtag_tdi_count
== 0)
585 if (presto
->jtag_tck
== 0)
587 LOG_ERROR("BUG: unexpected TAP condition, TCK low");
591 presto
->jtag_tdi_data
|= (presto
->jtag_tdi_count
- 1) << 4;
592 presto_sendbyte(presto
->jtag_tdi_data
);
593 presto
->jtag_tdi_count
= 0;
594 presto
->jtag_tdi_data
= 0;
600 int presto_tck_idle(void)
602 if (presto
->jtag_tck
== 1)
604 presto_sendbyte(0xCA);
605 presto
->jtag_tck
= 0;
612 /* -------------------------------------------------------------------------- */
615 int presto_bitq_out(int tms
, int tdi
, int tdo_req
)
620 if (presto
->jtag_tck
== 0)
622 presto_sendbyte(0xA4); /* LED idicator - JTAG active */
624 else if (presto
->jtag_speed
== 0 && !tdo_req
&& tms
== presto
->jtag_tms
)
626 presto
->jtag_tdi_data
|= (tdi
!= 0) << presto
->jtag_tdi_count
;
628 if (++presto
->jtag_tdi_count
== 4)
636 cmd
= tdi
? 0xCB : 0xCA;
637 presto_sendbyte(cmd
);
639 if (tms
!= presto
->jtag_tms
)
641 presto_sendbyte((tms
? 0xEC : 0xE8) | (presto
->jtag_rst
? 0x02 : 0));
642 presto
->jtag_tms
= tms
;
645 /* delay with TCK low */
646 for (i
=presto
->jtag_speed
; i
>1; i
--)
647 presto_sendbyte(cmd
);
650 presto_sendbyte(cmd
| (tdo_req
? 0x10 : 0));
652 /* delay with TCK high */
653 for (i
=presto
->jtag_speed
; i
>1; i
--)
654 presto_sendbyte(cmd
);
656 presto
->jtag_tck
= 1;
662 int presto_bitq_flush(void)
667 presto_sendbyte(0xA0); /* LED idicator - JTAG idle */
669 return presto_flush();
673 int presto_bitq_in_rdy(void)
675 if (presto
->buff_in_pos
>=presto
->buff_in_len
)
677 return presto
->buff_in_len
-presto
->buff_in_pos
;
681 int presto_bitq_in(void)
683 if (presto
->buff_in_pos
>=presto
->buff_in_len
)
685 if (presto
->buff_in
[presto
->buff_in_pos
++]&0x08) return 1;
690 int presto_bitq_sleep(unsigned long us
)
704 waits
= us
/ 170 + 2;
706 presto_sendbyte(0x80);
712 int presto_bitq_reset(int trst
, int srst
)
717 /* add a delay after possible TCK transition */
718 presto_sendbyte(0x80);
719 presto_sendbyte(0x80);
721 presto
->jtag_rst
= trst
|| srst
;
722 presto_sendbyte((presto
->jtag_rst
? 0xEA : 0xE8) | (presto
->jtag_tms
? 0x04 : 0));
728 /* -------------------------------------------------------------------------- */
731 int presto_jtag_khz(int khz
, int *jtag_speed
)
736 return ERROR_INVALID_ARGUMENTS
;
739 if (khz
>= 3000) *jtag_speed
= 0;
740 else *jtag_speed
= (1000+khz
-1)/khz
;
746 int presto_jtag_speed_div(int speed
, int *khz
)
748 if ((speed
< 0) || (speed
> 1000))
751 return ERROR_INVALID_ARGUMENTS
;
754 if (speed
== 0) *khz
= 3000;
755 else *khz
= 1000/speed
;
761 int presto_jtag_speed(int speed
)
765 if (presto_jtag_speed_div(speed
, &khz
))
767 return ERROR_INVALID_ARGUMENTS
;
770 presto
->jtag_speed
= speed
;
773 LOG_INFO("setting speed to %d, max. TCK freq. is %d MHz", speed
, khz
/1000);
775 LOG_INFO("setting speed to %d, max. TCK freq. is %d kHz", speed
, khz
);
783 int presto_handle_serial_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
789 presto_serial
= strdup(args
[0]);
793 LOG_ERROR("expected exactly one argument to presto_serial <serial-number>");
800 int presto_jtag_register_commands(struct command_context_s
*cmd_ctx
)
802 register_command(cmd_ctx
, NULL
, "presto_serial", presto_handle_serial_command
,
803 COMMAND_CONFIG
, NULL
);
808 int presto_jtag_init(void)
810 if (presto_open(presto_serial
) != ERROR_OK
)
813 if (presto_serial
!= NULL
)
814 LOG_ERROR("Cannot open PRESTO, serial number '%s'", presto_serial
);
816 LOG_ERROR("Cannot open PRESTO");
817 return ERROR_JTAG_INIT_FAILED
;
819 LOG_INFO("PRESTO open, serial number '%s'", presto
->serial
);
821 /* use JTAG speed setting from configuration file */
822 presto_jtag_speed(jtag_speed
);
824 bitq_interface
= &presto_bitq
;
829 int presto_jtag_quit(void)
833 LOG_INFO("PRESTO closed");
838 presto_serial
= NULL
;
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)