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 "interface.h"
29 #include "time_support.h"
33 /* PRESTO access library includes */
34 #if BUILD_PRESTO_FTD2XX == 1
36 #elif BUILD_PRESTO_LIBFTDI == 1
39 #error "BUG: either FTD2XX and LIBFTDI has to be used"
42 static int presto_jtag_speed(int speed
);
43 static int presto_jtag_khz(int khz
, int *jtag_speed
);
44 static int presto_jtag_speed_div(int speed
, int *khz
);
45 static int presto_jtag_register_commands(struct command_context_s
*cmd_ctx
);
46 static int presto_jtag_init(void);
47 static int presto_jtag_quit(void);
49 jtag_interface_t presto_interface
=
52 .execute_queue
= bitq_execute_queue
,
53 .speed
= presto_jtag_speed
,
54 .khz
= presto_jtag_khz
,
55 .speed_div
= presto_jtag_speed_div
,
56 .register_commands
= presto_jtag_register_commands
,
57 .init
= presto_jtag_init
,
58 .quit
= presto_jtag_quit
,
61 static int presto_bitq_out(int tms
, int tdi
, int tdo_req
);
62 static int presto_bitq_flush(void);
63 static int presto_bitq_sleep(unsigned long us
);
64 static int presto_bitq_reset(int trst
, int srst
);
65 static int presto_bitq_in_rdy(void);
66 static int presto_bitq_in(void);
68 static bitq_interface_t presto_bitq
=
70 .out
= presto_bitq_out
,
71 .flush
= presto_bitq_flush
,
72 .sleep
= presto_bitq_sleep
,
73 .reset
= presto_bitq_reset
,
74 .in_rdy
= presto_bitq_in_rdy
,
78 /* -------------------------------------------------------------------------- */
80 #define FT_DEVICE_NAME_LEN 64
81 #define FT_DEVICE_SERNUM_LEN 64
83 #define PRESTO_VID_PID 0x0403f1a0
84 #define PRESTO_VID (0x0403)
85 #define PRESTO_PID (0xf1a0)
87 #define BUFFER_SIZE (64*62)
89 typedef struct presto_s
91 #if BUILD_PRESTO_FTD2XX == 1
94 #elif BUILD_PRESTO_LIBFTDI == 1
95 struct ftdi_context ftdic
;
99 char serial
[FT_DEVICE_SERNUM_LEN
];
101 uint8_t buff_out
[BUFFER_SIZE
];
104 uint8_t buff_in
[BUFFER_SIZE
];
105 int buff_in_exp
; /* expected in buffer length */
106 int buff_in_len
; /* length of data received */
109 unsigned long total_out
;
110 unsigned long total_in
;
112 int jtag_tms
; /* last tms state */
113 int jtag_tck
; /* last tck state */
114 int jtag_rst
; /* last trst state */
123 static presto_t presto_state
;
124 static presto_t
*presto
= &presto_state
;
126 static uint8_t presto_init_seq
[] =
128 0x80, 0xA0, 0xA8, 0xB0, 0xC0, 0xE0
131 static int presto_write(uint8_t *buf
, uint32_t size
)
133 #if BUILD_PRESTO_FTD2XX == 1
135 if ((presto
->status
= FT_Write(presto
->handle
, buf
, size
, &ftbytes
)) != FT_OK
)
137 LOG_ERROR("FT_Write returned: %lu", presto
->status
);
138 return ERROR_JTAG_DEVICE_ERROR
;
141 #elif BUILD_PRESTO_LIBFTDI == 1
143 if ((presto
->retval
= ftdi_write_data(&presto
->ftdic
, buf
, size
)) < 0)
145 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&presto
->ftdic
));
146 return ERROR_JTAG_DEVICE_ERROR
;
148 ftbytes
= presto
->retval
;
153 LOG_ERROR("couldn't write the requested number of bytes to PRESTO (%u < %u)",
154 (unsigned)ftbytes
, (unsigned)size
);
155 return ERROR_JTAG_DEVICE_ERROR
;
161 static int presto_read(uint8_t* buf
, uint32_t size
)
163 #if BUILD_PRESTO_FTD2XX == 1
165 if ((presto
->status
= FT_Read(presto
->handle
, buf
, size
, &ftbytes
)) != FT_OK
)
167 LOG_ERROR("FT_Read returned: %lu", presto
->status
);
168 return ERROR_JTAG_DEVICE_ERROR
;
171 #elif BUILD_PRESTO_LIBFTDI == 1
172 uint32_t ftbytes
= 0;
174 struct timeval timeout
, now
;
175 gettimeofday(&timeout
, NULL
);
176 timeval_add_time(&timeout
, 1, 0); /* one second timeout */
178 while (ftbytes
< size
)
180 if ((presto
->retval
= ftdi_read_data(&presto
->ftdic
, buf
+ ftbytes
, size
- ftbytes
)) < 0)
182 LOG_ERROR("ftdi_read_data: %s", ftdi_get_error_string(&presto
->ftdic
));
183 return ERROR_JTAG_DEVICE_ERROR
;
185 ftbytes
+= presto
->retval
;
187 gettimeofday(&now
, NULL
);
188 if ((now
.tv_sec
> timeout
.tv_sec
) || ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
> timeout
.tv_usec
)))
195 /* this is just a warning, there might have been timeout when detecting PRESTO, which is not fatal */
196 LOG_WARNING("couldn't read the requested number of bytes from PRESTO (%u < %u)",
197 (unsigned)ftbytes
, (unsigned)size
);
198 return ERROR_JTAG_DEVICE_ERROR
;
204 #if BUILD_PRESTO_FTD2XX == 1
205 static int presto_open_ftd2xx(char *req_serial
)
210 char devname
[FT_DEVICE_NAME_LEN
];
216 presto
->handle
= (FT_HANDLE
)INVALID_HANDLE_VALUE
;
219 /* Add non-standard Vid/Pid to the linux driver */
220 if ((presto
->status
= FT_SetVIDPID(PRESTO_VID
, PRESTO_PID
)) != FT_OK
)
222 LOG_ERROR("couldn't add PRESTO VID/PID");
227 if ((presto
->status
= FT_ListDevices(&numdevs
, NULL
, FT_LIST_NUMBER_ONLY
)) != FT_OK
)
229 LOG_ERROR("FT_ListDevices failed: %i", (int)presto
->status
);
230 return ERROR_JTAG_DEVICE_ERROR
;
233 LOG_DEBUG("FTDI devices available: %lu", numdevs
);
234 for (i
= 0; i
< numdevs
; i
++)
236 if ((presto
->status
= FT_Open(i
, &(presto
->handle
))) != FT_OK
)
238 /* this is not fatal, the device may be legitimately open by other process, hence debug message only */
239 LOG_DEBUG("FT_Open failed: %i", (int)presto
->status
);
242 LOG_DEBUG("FTDI device %i open", i
);
244 if ((presto
->status
= FT_GetDeviceInfo(presto
->handle
, &device
, &vidpid
,
245 presto
->serial
, devname
, NULL
)) == FT_OK
)
247 if (vidpid
== PRESTO_VID_PID
248 && (req_serial
== NULL
|| !strcmp(presto
->serial
, req_serial
)))
252 LOG_DEBUG("FT_GetDeviceInfo failed: %lu", presto
->status
);
254 LOG_DEBUG("FTDI device %i does not match, closing", i
);
255 FT_Close(presto
->handle
);
256 presto
->handle
= (FT_HANDLE
)INVALID_HANDLE_VALUE
;
259 if (presto
->handle
== (FT_HANDLE
)INVALID_HANDLE_VALUE
)
260 return ERROR_JTAG_DEVICE_ERROR
; /* presto not open, return */
262 if ((presto
->status
= FT_SetLatencyTimer(presto
->handle
, 1)) != FT_OK
)
263 return ERROR_JTAG_DEVICE_ERROR
;
266 if ((presto
->status
= FT_SetTimeouts(presto
->handle
, 100, 0)) != FT_OK
)
267 return ERROR_JTAG_DEVICE_ERROR
;
269 if ((presto
->status
= FT_Purge(presto
->handle
, FT_PURGE_TX
| FT_PURGE_RX
)) != FT_OK
)
270 return ERROR_JTAG_DEVICE_ERROR
;
273 if ((presto
->status
= FT_Write(presto
->handle
, &presto_data
, 1, &ftbytes
)) != FT_OK
)
274 return ERROR_JTAG_DEVICE_ERROR
;
276 /* delay between first write/read turnaround (after purge?) necessary under Linux for unknown reason,
277 probably a bug in library threading */
279 if ((presto
->status
= FT_Read(presto
->handle
, &presto_data
, 1, &ftbytes
)) != FT_OK
)
280 return ERROR_JTAG_DEVICE_ERROR
;
284 LOG_DEBUG("PRESTO reset");
286 if ((presto
->status
= FT_Purge(presto
->handle
, FT_PURGE_TX
| FT_PURGE_RX
)) != FT_OK
)
287 return ERROR_JTAG_DEVICE_ERROR
;
288 if ((presto
->status
= FT_SetBitMode(presto
->handle
, 0x80, 1)) != FT_OK
)
289 return ERROR_JTAG_DEVICE_ERROR
;
290 if ((presto
->status
= FT_SetBaudRate(presto
->handle
, 9600)) != FT_OK
)
291 return ERROR_JTAG_DEVICE_ERROR
;
294 for (i
= 0; i
< 4 * 62; i
++)
295 if ((presto
->status
= FT_Write(presto
->handle
, &presto_data
, 1, &ftbytes
)) != FT_OK
)
296 return ERROR_JTAG_DEVICE_ERROR
;
300 if ((presto
->status
= FT_SetBitMode(presto
->handle
, 0x00, 0)) != FT_OK
)
301 return ERROR_JTAG_DEVICE_ERROR
;
303 if ((presto
->status
= FT_Purge(presto
->handle
, FT_PURGE_TX
| FT_PURGE_RX
)) != FT_OK
)
304 return ERROR_JTAG_DEVICE_ERROR
;
307 if ((presto
->status
= FT_Write(presto
->handle
, &presto_data
, 1, &ftbytes
)) != FT_OK
)
308 return ERROR_JTAG_DEVICE_ERROR
;
310 /* delay between first write/read turnaround (after purge?) necessary under Linux for unknown reason,
311 probably a bug in library threading */
313 if ((presto
->status
= FT_Read(presto
->handle
, &presto_data
, 1, &ftbytes
)) != FT_OK
)
314 return ERROR_JTAG_DEVICE_ERROR
;
318 LOG_DEBUG("PRESTO not responding");
319 return ERROR_JTAG_DEVICE_ERROR
;
323 if ((presto
->status
= FT_SetTimeouts(presto
->handle
, 0, 0)) != FT_OK
)
324 return ERROR_JTAG_DEVICE_ERROR
;
327 presto
->status
= FT_Write(presto
->handle
, &presto_init_seq
, sizeof(presto_init_seq
), &ftbytes
);
328 if (presto
->status
!= FT_OK
|| ftbytes
!= sizeof(presto_init_seq
))
329 return ERROR_JTAG_DEVICE_ERROR
;
334 #elif BUILD_PRESTO_LIBFTDI == 1
335 static int presto_open_libftdi(char *req_serial
)
339 LOG_DEBUG("searching for PRESTO using libftdi");
341 /* initialize FTDI context structure */
342 if (ftdi_init(&presto
->ftdic
) < 0)
344 LOG_ERROR("unable to init libftdi: %s", presto
->ftdic
.error_str
);
345 return ERROR_JTAG_DEVICE_ERROR
;
348 /* context, vendor id, product id */
349 if (ftdi_usb_open_desc(&presto
->ftdic
, PRESTO_VID
, PRESTO_PID
, NULL
, req_serial
) < 0)
351 LOG_ERROR("unable to open PRESTO: %s", presto
->ftdic
.error_str
);
352 return ERROR_JTAG_DEVICE_ERROR
;
355 if (ftdi_usb_reset(&presto
->ftdic
) < 0)
357 LOG_ERROR("unable to reset PRESTO device");
358 return ERROR_JTAG_DEVICE_ERROR
;
361 if (ftdi_set_latency_timer(&presto
->ftdic
, 1) < 0)
363 LOG_ERROR("unable to set latency timer");
364 return ERROR_JTAG_DEVICE_ERROR
;
367 if (ftdi_usb_purge_buffers(&presto
->ftdic
) < 0)
369 LOG_ERROR("unable to purge PRESTO buffers");
370 return ERROR_JTAG_DEVICE_ERROR
;
374 if (presto_write(&presto_data
, 1) != ERROR_OK
)
376 LOG_ERROR("error writing to PRESTO");
377 return ERROR_JTAG_DEVICE_ERROR
;
380 if (presto_read(&presto_data
, 1) != ERROR_OK
)
382 LOG_DEBUG("no response from PRESTO, retrying");
384 if (ftdi_usb_purge_buffers(&presto
->ftdic
) < 0)
385 return ERROR_JTAG_DEVICE_ERROR
;
388 if (presto_write(&presto_data
, 1) != ERROR_OK
)
389 return ERROR_JTAG_DEVICE_ERROR
;
391 if (presto_read(&presto_data
, 1) != ERROR_OK
)
393 LOG_ERROR("no response from PRESTO, giving up");
394 return ERROR_JTAG_DEVICE_ERROR
;
398 if (presto_write(presto_init_seq
, sizeof(presto_init_seq
)) != ERROR_OK
)
400 LOG_ERROR("error writing PRESTO init sequence");
401 return ERROR_JTAG_DEVICE_ERROR
;
406 #endif /* BUILD_PRESTO_LIBFTDI == 1 */
408 static int presto_open(char *req_serial
)
410 presto
->buff_out_pos
= 0;
411 presto
->buff_in_pos
= 0;
412 presto
->buff_in_len
= 0;
413 presto
->buff_in_exp
= 0;
415 presto
->total_out
= 0;
416 presto
->total_in
= 0;
418 presto
->jtag_tms
= 0;
419 presto
->jtag_tck
= 0;
420 presto
->jtag_rst
= 0;
421 presto
->jtag_tdi_data
= 0;
422 presto
->jtag_tdi_count
= 0;
424 presto
->jtag_speed
= 0;
426 #if BUILD_PRESTO_FTD2XX == 1
427 return presto_open_ftd2xx(req_serial
);
428 #elif BUILD_PRESTO_LIBFTDI == 1
429 return presto_open_libftdi(req_serial
);
433 static int presto_close(void)
436 int result
= ERROR_OK
;
438 #if BUILD_PRESTO_FTD2XX == 1
439 unsigned long ftbytes
;
441 if (presto
->handle
== (FT_HANDLE
)INVALID_HANDLE_VALUE
)
444 presto
->status
= FT_Purge(presto
->handle
, FT_PURGE_TX
| FT_PURGE_RX
);
445 if (presto
->status
!= FT_OK
)
446 result
= ERROR_JTAG_DEVICE_ERROR
;
448 presto
->status
= FT_Write(presto
->handle
, &presto_init_seq
, sizeof(presto_init_seq
), &ftbytes
);
449 if (presto
->status
!= FT_OK
|| ftbytes
!= sizeof(presto_init_seq
))
450 result
= ERROR_JTAG_DEVICE_ERROR
;
452 if ((presto
->status
= FT_SetLatencyTimer(presto
->handle
, 16)) != FT_OK
)
453 result
= ERROR_JTAG_DEVICE_ERROR
;
455 if ((presto
->status
= FT_Close(presto
->handle
)) != FT_OK
)
456 result
= ERROR_JTAG_DEVICE_ERROR
;
458 presto
->handle
= (FT_HANDLE
)INVALID_HANDLE_VALUE
;
460 #elif BUILD_PRESTO_LIBFTDI == 1
462 if ((presto
->retval
= ftdi_write_data(&presto
->ftdic
, presto_init_seq
, sizeof(presto_init_seq
))) != sizeof(presto_init_seq
))
463 result
= ERROR_JTAG_DEVICE_ERROR
;
465 if ((presto
->retval
= ftdi_set_latency_timer(&presto
->ftdic
, 16)) < 0)
466 result
= ERROR_JTAG_DEVICE_ERROR
;
468 if ((presto
->retval
= ftdi_usb_close(&presto
->ftdic
)) < 0)
469 result
= ERROR_JTAG_DEVICE_ERROR
;
471 ftdi_deinit(&presto
->ftdic
);
477 static int presto_flush(void)
479 if (presto
->buff_out_pos
== 0)
482 #if BUILD_PRESTO_FTD2XX == 1
483 if (presto
->status
!= FT_OK
)
484 #elif BUILD_PRESTO_LIBFTDI == 1
485 if (presto
->retval
< 0)
488 LOG_DEBUG("error in previous communication, canceling I/O operation");
489 return ERROR_JTAG_DEVICE_ERROR
;
492 if (presto_write(presto
->buff_out
, presto
->buff_out_pos
) != ERROR_OK
)
494 presto
->buff_out_pos
= 0;
495 return ERROR_JTAG_DEVICE_ERROR
;
498 presto
->total_out
+= presto
->buff_out_pos
;
499 presto
->buff_out_pos
= 0;
501 if (presto
->buff_in_exp
== 0)
504 presto
->buff_in_pos
= 0;
505 presto
->buff_in_len
= 0;
507 if (presto_read(presto
->buff_in
, presto
->buff_in_exp
) != ERROR_OK
)
509 presto
->buff_in_exp
= 0;
510 return ERROR_JTAG_DEVICE_ERROR
;
513 presto
->total_in
+= presto
->buff_in_exp
;
514 presto
->buff_in_len
= presto
->buff_in_exp
;
515 presto
->buff_in_exp
= 0;
520 static int presto_sendbyte(int data
)
522 if (data
== EOF
) return presto_flush();
524 if (presto
->buff_out_pos
< BUFFER_SIZE
)
526 presto
->buff_out
[presto
->buff_out_pos
++] = (uint8_t)data
;
527 if (((data
& 0xC0) == 0x40) || ((data
& 0xD0)== 0xD0))
528 presto
->buff_in_exp
++;
531 return ERROR_JTAG_DEVICE_ERROR
;
533 #if BUILD_PRESTO_FTD2XX == 1
534 if (presto
->buff_out_pos
>= BUFFER_SIZE
)
535 #elif BUILD_PRESTO_LIBFTDI == 1
536 /* libftdi does not do background read, be sure that USB IN buffer does not overflow (128 bytes only!) */
537 if (presto
->buff_out_pos
>= BUFFER_SIZE
|| presto
->buff_in_exp
== 128)
539 return presto_flush();
545 static int presto_getbyte(void)
547 if (presto
->buff_in_pos
< presto
->buff_in_len
)
548 return presto
->buff_in
[presto
->buff_in_pos
++];
550 if (presto
->buff_in_exp
== 0)
553 if (presto_flush() != ERROR_OK
)
556 if (presto
->buff_in_pos
<presto
->buff_in_len
)
557 return presto
->buff_in
[presto
->buff_in_pos
++];
563 /* -------------------------------------------------------------------------- */
565 static int presto_tdi_flush(void)
567 if (presto
->jtag_tdi_count
== 0)
570 if (presto
->jtag_tck
== 0)
572 LOG_ERROR("BUG: unexpected TAP condition, TCK low");
576 presto
->jtag_tdi_data
|= (presto
->jtag_tdi_count
- 1) << 4;
577 presto_sendbyte(presto
->jtag_tdi_data
);
578 presto
->jtag_tdi_count
= 0;
579 presto
->jtag_tdi_data
= 0;
584 static int presto_tck_idle(void)
586 if (presto
->jtag_tck
== 1)
588 presto_sendbyte(0xCA);
589 presto
->jtag_tck
= 0;
595 /* -------------------------------------------------------------------------- */
597 static int presto_bitq_out(int tms
, int tdi
, int tdo_req
)
602 if (presto
->jtag_tck
== 0)
604 presto_sendbyte(0xA4); /* LED idicator - JTAG active */
606 else if (presto
->jtag_speed
== 0 && !tdo_req
&& tms
== presto
->jtag_tms
)
608 presto
->jtag_tdi_data
|= (tdi
!= 0) << presto
->jtag_tdi_count
;
610 if (++presto
->jtag_tdi_count
== 4)
618 cmd
= tdi
? 0xCB : 0xCA;
619 presto_sendbyte(cmd
);
621 if (tms
!= presto
->jtag_tms
)
623 presto_sendbyte((tms
? 0xEC : 0xE8) | (presto
->jtag_rst
? 0x02 : 0));
624 presto
->jtag_tms
= tms
;
627 /* delay with TCK low */
628 for (i
= presto
->jtag_speed
; i
>1; i
--)
629 presto_sendbyte(cmd
);
632 presto_sendbyte(cmd
| (tdo_req
? 0x10 : 0));
634 /* delay with TCK high */
635 for (i
= presto
->jtag_speed
; i
>1; i
--)
636 presto_sendbyte(cmd
);
638 presto
->jtag_tck
= 1;
643 static int presto_bitq_flush(void)
648 presto_sendbyte(0xA0); /* LED idicator - JTAG idle */
650 return presto_flush();
653 static int presto_bitq_in_rdy(void)
655 if (presto
->buff_in_pos
>= presto
->buff_in_len
)
657 return presto
->buff_in_len
-presto
->buff_in_pos
;
660 static int presto_bitq_in(void)
662 if (presto
->buff_in_pos
>= presto
->buff_in_len
)
664 if (presto
->buff_in
[presto
->buff_in_pos
++]&0x08) return 1;
668 static int presto_bitq_sleep(unsigned long us
)
682 waits
= us
/ 170 + 2;
684 presto_sendbyte(0x80);
689 static int presto_bitq_reset(int trst
, int srst
)
694 /* add a delay after possible TCK transition */
695 presto_sendbyte(0x80);
696 presto_sendbyte(0x80);
698 presto
->jtag_rst
= trst
|| srst
;
699 presto_sendbyte((presto
->jtag_rst
? 0xEA : 0xE8) | (presto
->jtag_tms
? 0x04 : 0));
704 /* -------------------------------------------------------------------------- */
706 static int presto_jtag_khz(int khz
, int *jtag_speed
)
711 return ERROR_INVALID_ARGUMENTS
;
714 if (khz
>= 3000) *jtag_speed
= 0;
715 else *jtag_speed
= (1000+khz
-1)/khz
;
720 static int presto_jtag_speed_div(int speed
, int *khz
)
722 if ((speed
< 0) || (speed
> 1000))
725 return ERROR_INVALID_ARGUMENTS
;
728 if (speed
== 0) *khz
= 3000;
729 else *khz
= 1000/speed
;
734 static int presto_jtag_speed(int speed
)
738 if (presto_jtag_speed_div(speed
, &khz
))
740 return ERROR_INVALID_ARGUMENTS
;
743 presto
->jtag_speed
= speed
;
746 LOG_INFO("setting speed to %d, max. TCK freq. is %d MHz", speed
, khz
/1000);
748 LOG_INFO("setting speed to %d, max. TCK freq. is %d kHz", speed
, khz
);
753 static char *presto_serial
;
755 static int presto_handle_serial_command(struct command_context_s
*cmd_ctx
, char *cmd
, char **args
, int argc
)
761 presto_serial
= strdup(args
[0]);
765 LOG_ERROR("expected exactly one argument to presto_serial <serial-number>");
771 static int presto_jtag_register_commands(struct command_context_s
*cmd_ctx
)
773 register_command(cmd_ctx
, NULL
, "presto_serial", presto_handle_serial_command
,
774 COMMAND_CONFIG
, NULL
);
778 static int presto_jtag_init(void)
780 if (presto_open(presto_serial
) != ERROR_OK
)
783 if (presto_serial
!= NULL
)
784 LOG_ERROR("Cannot open PRESTO, serial number '%s'", presto_serial
);
786 LOG_ERROR("Cannot open PRESTO");
787 return ERROR_JTAG_INIT_FAILED
;
789 LOG_INFO("PRESTO open, serial number '%s'", presto
->serial
);
791 /* use JTAG speed setting from configuration file */
792 presto_jtag_speed(jtag_get_speed());
794 bitq_interface
= &presto_bitq
;
798 static int presto_jtag_quit(void)
802 LOG_INFO("PRESTO closed");
807 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)