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, see <http://www.gnu.org/licenses/>. *
17 ***************************************************************************/
21 * Holds driver for PRESTO programmer from ASIX.
22 * http://tools.asix.net/prg_presto.htm
32 #include <jtag/interface.h>
33 #include <helper/time_support.h>
36 /* PRESTO access library includes */
37 #if BUILD_PRESTO_FTD2XX == 1
39 #include "ftd2xx_common.h"
40 #elif BUILD_PRESTO_LIBFTDI == 1
43 #error "BUG: either FTD2XX and LIBFTDI has to be used"
46 /* -------------------------------------------------------------------------- */
48 #define FT_DEVICE_NAME_LEN 64
49 #define FT_DEVICE_SERNUM_LEN 64
51 #define PRESTO_VID_PID 0x0403f1a0
52 #define PRESTO_VID (0x0403)
53 #define PRESTO_PID (0xf1a0)
55 #define BUFFER_SIZE (64*62)
58 #if BUILD_PRESTO_FTD2XX == 1
61 #elif BUILD_PRESTO_LIBFTDI == 1
62 struct ftdi_context ftdic
;
66 char serial
[FT_DEVICE_SERNUM_LEN
];
68 uint8_t buff_out
[BUFFER_SIZE
];
71 uint8_t buff_in
[BUFFER_SIZE
];
72 int buff_in_exp
;/* expected in buffer length */
73 int buff_in_len
;/* length of data received */
76 unsigned long total_out
;
77 unsigned long total_in
;
79 int jtag_tms
; /* last tms state */
80 int jtag_tck
; /* last tck state */
81 int jtag_rst
; /* last trst state */
89 static struct presto presto_state
;
90 static struct presto
*presto
= &presto_state
;
92 static uint8_t presto_init_seq
[] = {
93 0x80, 0xA0, 0xA8, 0xB0, 0xC0, 0xE0
96 static int presto_write(uint8_t *buf
, uint32_t size
)
98 #if BUILD_PRESTO_FTD2XX == 1
100 presto
->status
= FT_Write(presto
->handle
, buf
, size
, &ftbytes
);
101 if (presto
->status
!= FT_OK
) {
102 LOG_ERROR("FT_Write returned: %s", ftd2xx_status_string(presto
->status
));
103 return ERROR_JTAG_DEVICE_ERROR
;
106 #elif BUILD_PRESTO_LIBFTDI == 1
108 presto
->retval
= ftdi_write_data(&presto
->ftdic
, buf
, size
);
109 if (presto
->retval
< 0) {
110 LOG_ERROR("ftdi_write_data: %s", ftdi_get_error_string(&presto
->ftdic
));
111 return ERROR_JTAG_DEVICE_ERROR
;
113 ftbytes
= presto
->retval
;
116 if (ftbytes
!= size
) {
117 LOG_ERROR("couldn't write the requested number of bytes to PRESTO (%u < %u)",
118 (unsigned)ftbytes
, (unsigned)size
);
119 return ERROR_JTAG_DEVICE_ERROR
;
125 static int presto_read(uint8_t *buf
, uint32_t size
)
127 #if BUILD_PRESTO_FTD2XX == 1
129 presto
->status
= FT_Read(presto
->handle
, buf
, size
, &ftbytes
);
130 if (presto
->status
!= FT_OK
) {
131 LOG_ERROR("FT_Read returned: %s", ftd2xx_status_string(presto
->status
));
132 return ERROR_JTAG_DEVICE_ERROR
;
135 #elif BUILD_PRESTO_LIBFTDI == 1
136 uint32_t ftbytes
= 0;
138 struct timeval timeout
, now
;
139 gettimeofday(&timeout
, NULL
);
140 timeval_add_time(&timeout
, 1, 0); /* one second timeout */
142 while (ftbytes
< size
) {
143 presto
->retval
= ftdi_read_data(&presto
->ftdic
, buf
+ ftbytes
, size
- ftbytes
);
144 if (presto
->retval
< 0) {
145 LOG_ERROR("ftdi_read_data: %s", ftdi_get_error_string(&presto
->ftdic
));
146 return ERROR_JTAG_DEVICE_ERROR
;
148 ftbytes
+= presto
->retval
;
150 gettimeofday(&now
, NULL
);
151 if ((now
.tv_sec
> timeout
.tv_sec
) ||
152 ((now
.tv_sec
== timeout
.tv_sec
) && (now
.tv_usec
> timeout
.tv_usec
)))
157 if (ftbytes
!= size
) {
158 /* this is just a warning, there might have been timeout when detecting PRESTO,
159 *which is not fatal */
160 LOG_WARNING("couldn't read the requested number of bytes from PRESTO (%u < %u)",
161 (unsigned)ftbytes
, (unsigned)size
);
162 return ERROR_JTAG_DEVICE_ERROR
;
168 #if BUILD_PRESTO_FTD2XX == 1
169 static int presto_open_ftd2xx(char *req_serial
)
174 char devname
[FT_DEVICE_NAME_LEN
];
180 presto
->handle
= (FT_HANDLE
)INVALID_HANDLE_VALUE
;
183 /* Add non-standard Vid/Pid to the linux driver */
184 presto
->status
= FT_SetVIDPID(PRESTO_VID
, PRESTO_PID
);
185 if (presto
->status
!= FT_OK
) {
186 LOG_ERROR("couldn't add PRESTO VID/PID");
191 presto
->status
= FT_ListDevices(&numdevs
, NULL
, FT_LIST_NUMBER_ONLY
);
192 if (presto
->status
!= FT_OK
) {
193 LOG_ERROR("FT_ListDevices failed: %s", ftd2xx_status_string(presto
->status
));
194 return ERROR_JTAG_DEVICE_ERROR
;
197 LOG_DEBUG("FTDI devices available: %" PRIu32
, (uint32_t)numdevs
);
198 for (i
= 0; i
< numdevs
; i
++) {
199 presto
->status
= FT_Open(i
, &(presto
->handle
));
200 if (presto
->status
!= FT_OK
) {
201 /* this is not fatal, the device may be legitimately open by other process,
202 *hence debug message only */
203 LOG_DEBUG("FT_Open failed: %s", ftd2xx_status_string(presto
->status
));
206 LOG_DEBUG("FTDI device %i open", (int)i
);
208 presto
->status
= FT_GetDeviceInfo(presto
->handle
, &device
,
209 &vidpid
, presto
->serial
, devname
, NULL
);
210 if (presto
->status
== FT_OK
) {
211 if (vidpid
== PRESTO_VID_PID
&& (req_serial
== NULL
||
212 !strcmp(presto
->serial
, req_serial
)))
215 LOG_DEBUG("FT_GetDeviceInfo failed: %s", ftd2xx_status_string(
218 LOG_DEBUG("FTDI device %i does not match, closing", (int)i
);
219 FT_Close(presto
->handle
);
220 presto
->handle
= (FT_HANDLE
)INVALID_HANDLE_VALUE
;
223 if (presto
->handle
== (FT_HANDLE
)INVALID_HANDLE_VALUE
)
224 return ERROR_JTAG_DEVICE_ERROR
; /* presto not open, return */
226 presto
->status
= FT_SetLatencyTimer(presto
->handle
, 1);
227 if (presto
->status
!= FT_OK
)
228 return ERROR_JTAG_DEVICE_ERROR
;
230 presto
->status
= FT_SetTimeouts(presto
->handle
, 100, 0);
231 if (presto
->status
!= FT_OK
)
232 return ERROR_JTAG_DEVICE_ERROR
;
234 presto
->status
= FT_Purge(presto
->handle
, FT_PURGE_TX
| FT_PURGE_RX
);
235 if (presto
->status
!= FT_OK
)
236 return ERROR_JTAG_DEVICE_ERROR
;
239 presto
->status
= FT_Write(presto
->handle
, &presto_data
, 1, &ftbytes
);
240 if (presto
->status
!= FT_OK
)
241 return ERROR_JTAG_DEVICE_ERROR
;
243 /* delay between first write/read turnaround (after purge?) necessary
244 * under Linux for unknown reason,
245 * probably a bug in library threading */
247 presto
->status
= FT_Read(presto
->handle
, &presto_data
, 1, &ftbytes
);
248 if (presto
->status
!= FT_OK
)
249 return ERROR_JTAG_DEVICE_ERROR
;
252 LOG_DEBUG("PRESTO reset");
254 presto
->status
= FT_Purge(presto
->handle
, FT_PURGE_TX
| FT_PURGE_RX
);
255 if (presto
->status
!= FT_OK
)
256 return ERROR_JTAG_DEVICE_ERROR
;
257 presto
->status
= FT_SetBitMode(presto
->handle
, 0x80, 1);
258 if (presto
->status
!= FT_OK
)
259 return ERROR_JTAG_DEVICE_ERROR
;
260 presto
->status
= FT_SetBaudRate(presto
->handle
, 9600);
261 if (presto
->status
!= FT_OK
)
262 return ERROR_JTAG_DEVICE_ERROR
;
265 for (i
= 0; i
< 4 * 62; i
++) {
266 presto
->status
= FT_Write(presto
->handle
, &presto_data
, 1, &ftbytes
);
267 if (presto
->status
!= FT_OK
)
268 return ERROR_JTAG_DEVICE_ERROR
;
272 presto
->status
= FT_SetBitMode(presto
->handle
, 0x00, 0);
273 if (presto
->status
!= FT_OK
)
274 return ERROR_JTAG_DEVICE_ERROR
;
276 presto
->status
= FT_Purge(presto
->handle
, FT_PURGE_TX
| FT_PURGE_RX
);
277 if (presto
->status
!= FT_OK
)
278 return ERROR_JTAG_DEVICE_ERROR
;
281 presto
->status
= FT_Write(presto
->handle
, &presto_data
, 1, &ftbytes
);
282 if (presto
->status
!= FT_OK
)
283 return ERROR_JTAG_DEVICE_ERROR
;
285 /* delay between first write/read turnaround (after purge?) necessary under Linux for unknown reason,
286 probably a bug in library threading */
288 presto
->status
= FT_Read(presto
->handle
, &presto_data
, 1, &ftbytes
);
289 if (presto
->status
!= FT_OK
)
290 return ERROR_JTAG_DEVICE_ERROR
;
293 LOG_DEBUG("PRESTO not responding");
294 return ERROR_JTAG_DEVICE_ERROR
;
298 presto
->status
= FT_SetTimeouts(presto
->handle
, 0, 0);
299 if (presto
->status
!= FT_OK
)
300 return ERROR_JTAG_DEVICE_ERROR
;
302 presto
->status
= FT_Write(presto
->handle
, &presto_init_seq
,
303 sizeof(presto_init_seq
), &ftbytes
);
305 if (presto
->status
!= FT_OK
|| ftbytes
!= sizeof(presto_init_seq
))
306 return ERROR_JTAG_DEVICE_ERROR
;
311 #elif BUILD_PRESTO_LIBFTDI == 1
312 static int presto_open_libftdi(char *req_serial
)
316 LOG_DEBUG("searching for PRESTO using libftdi");
318 /* initialize FTDI context structure */
319 if (ftdi_init(&presto
->ftdic
) < 0) {
320 LOG_ERROR("unable to init libftdi: %s", presto
->ftdic
.error_str
);
321 return ERROR_JTAG_DEVICE_ERROR
;
324 /* context, vendor id, product id */
325 if (ftdi_usb_open_desc(&presto
->ftdic
, PRESTO_VID
, PRESTO_PID
, NULL
, req_serial
) < 0) {
326 LOG_ERROR("unable to open PRESTO: %s", presto
->ftdic
.error_str
);
327 return ERROR_JTAG_DEVICE_ERROR
;
330 if (ftdi_usb_reset(&presto
->ftdic
) < 0) {
331 LOG_ERROR("unable to reset PRESTO device");
332 return ERROR_JTAG_DEVICE_ERROR
;
335 if (ftdi_set_latency_timer(&presto
->ftdic
, 1) < 0) {
336 LOG_ERROR("unable to set latency timer");
337 return ERROR_JTAG_DEVICE_ERROR
;
340 if (ftdi_usb_purge_buffers(&presto
->ftdic
) < 0) {
341 LOG_ERROR("unable to purge PRESTO buffers");
342 return ERROR_JTAG_DEVICE_ERROR
;
346 if (presto_write(&presto_data
, 1) != ERROR_OK
) {
347 LOG_ERROR("error writing to PRESTO");
348 return ERROR_JTAG_DEVICE_ERROR
;
351 if (presto_read(&presto_data
, 1) != ERROR_OK
) {
352 LOG_DEBUG("no response from PRESTO, retrying");
354 if (ftdi_usb_purge_buffers(&presto
->ftdic
) < 0)
355 return ERROR_JTAG_DEVICE_ERROR
;
358 if (presto_write(&presto_data
, 1) != ERROR_OK
)
359 return ERROR_JTAG_DEVICE_ERROR
;
361 if (presto_read(&presto_data
, 1) != ERROR_OK
) {
362 LOG_ERROR("no response from PRESTO, giving up");
363 return ERROR_JTAG_DEVICE_ERROR
;
367 if (presto_write(presto_init_seq
, sizeof(presto_init_seq
)) != ERROR_OK
) {
368 LOG_ERROR("error writing PRESTO init sequence");
369 return ERROR_JTAG_DEVICE_ERROR
;
374 #endif /* BUILD_PRESTO_LIBFTDI == 1 */
376 static int presto_open(char *req_serial
)
378 presto
->buff_out_pos
= 0;
379 presto
->buff_in_pos
= 0;
380 presto
->buff_in_len
= 0;
381 presto
->buff_in_exp
= 0;
383 presto
->total_out
= 0;
384 presto
->total_in
= 0;
386 presto
->jtag_tms
= 0;
387 presto
->jtag_tck
= 0;
388 presto
->jtag_rst
= 0;
389 presto
->jtag_tdi_data
= 0;
390 presto
->jtag_tdi_count
= 0;
392 presto
->jtag_speed
= 0;
394 #if BUILD_PRESTO_FTD2XX == 1
395 return presto_open_ftd2xx(req_serial
);
396 #elif BUILD_PRESTO_LIBFTDI == 1
397 return presto_open_libftdi(req_serial
);
401 static int presto_close(void)
404 int result
= ERROR_OK
;
406 #if BUILD_PRESTO_FTD2XX == 1
409 if (presto
->handle
== (FT_HANDLE
)INVALID_HANDLE_VALUE
)
412 presto
->status
= FT_Purge(presto
->handle
, FT_PURGE_TX
| FT_PURGE_RX
);
413 if (presto
->status
!= FT_OK
)
414 result
= ERROR_JTAG_DEVICE_ERROR
;
416 presto
->status
= FT_Write(presto
->handle
,
418 sizeof(presto_init_seq
),
420 if (presto
->status
!= FT_OK
|| ftbytes
!= sizeof(presto_init_seq
))
421 result
= ERROR_JTAG_DEVICE_ERROR
;
423 presto
->status
= FT_SetLatencyTimer(presto
->handle
, 16);
424 if (presto
->status
!= FT_OK
)
425 result
= ERROR_JTAG_DEVICE_ERROR
;
427 presto
->status
= FT_Close(presto
->handle
);
428 if (presto
->status
!= FT_OK
)
429 result
= ERROR_JTAG_DEVICE_ERROR
;
431 presto
->handle
= (FT_HANDLE
)INVALID_HANDLE_VALUE
;
433 #elif BUILD_PRESTO_LIBFTDI == 1
435 presto
->retval
= ftdi_write_data(&presto
->ftdic
, presto_init_seq
, sizeof(presto_init_seq
));
436 if (presto
->retval
!= sizeof(presto_init_seq
))
437 result
= ERROR_JTAG_DEVICE_ERROR
;
439 presto
->retval
= ftdi_set_latency_timer(&presto
->ftdic
, 16);
440 if (presto
->retval
< 0)
441 result
= ERROR_JTAG_DEVICE_ERROR
;
443 presto
->retval
= ftdi_usb_close(&presto
->ftdic
);
444 if (presto
->retval
< 0)
445 result
= ERROR_JTAG_DEVICE_ERROR
;
447 ftdi_deinit(&presto
->ftdic
);
453 static int presto_flush(void)
455 if (presto
->buff_out_pos
== 0)
458 #if BUILD_PRESTO_FTD2XX == 1
459 if (presto
->status
!= FT_OK
) {
460 #elif BUILD_PRESTO_LIBFTDI == 1
461 if (presto
->retval
< 0) {
463 LOG_DEBUG("error in previous communication, canceling I/O operation");
464 return ERROR_JTAG_DEVICE_ERROR
;
467 if (presto_write(presto
->buff_out
, presto
->buff_out_pos
) != ERROR_OK
) {
468 presto
->buff_out_pos
= 0;
469 return ERROR_JTAG_DEVICE_ERROR
;
472 presto
->total_out
+= presto
->buff_out_pos
;
473 presto
->buff_out_pos
= 0;
475 if (presto
->buff_in_exp
== 0)
478 presto
->buff_in_pos
= 0;
479 presto
->buff_in_len
= 0;
481 if (presto_read(presto
->buff_in
, presto
->buff_in_exp
) != ERROR_OK
) {
482 presto
->buff_in_exp
= 0;
483 return ERROR_JTAG_DEVICE_ERROR
;
486 presto
->total_in
+= presto
->buff_in_exp
;
487 presto
->buff_in_len
= presto
->buff_in_exp
;
488 presto
->buff_in_exp
= 0;
493 static int presto_sendbyte(int data
)
496 return presto_flush();
498 if (presto
->buff_out_pos
< BUFFER_SIZE
) {
499 presto
->buff_out
[presto
->buff_out_pos
++] = (uint8_t)data
;
500 if (((data
& 0xC0) == 0x40) || ((data
& 0xD0) == 0xD0))
501 presto
->buff_in_exp
++;
503 return ERROR_JTAG_DEVICE_ERROR
;
505 #if BUILD_PRESTO_FTD2XX == 1
506 if (presto
->buff_out_pos
>= BUFFER_SIZE
)
507 #elif BUILD_PRESTO_LIBFTDI == 1
508 /* libftdi does not do background read, be sure that USB IN buffer does not overflow (128
510 if (presto
->buff_out_pos
>= BUFFER_SIZE
|| presto
->buff_in_exp
== 128)
512 return presto_flush();
518 static int presto_getbyte(void)
520 if (presto
->buff_in_pos
< presto
->buff_in_len
)
521 return presto
->buff_in
[presto
->buff_in_pos
++];
523 if (presto
->buff_in_exp
== 0)
526 if (presto_flush() != ERROR_OK
)
529 if (presto
->buff_in_pos
< presto
->buff_in_len
)
530 return presto
->buff_in
[presto
->buff_in_pos
++];
536 /* -------------------------------------------------------------------------- */
538 static int presto_tdi_flush(void)
540 if (presto
->jtag_tdi_count
== 0)
543 if (presto
->jtag_tck
== 0) {
544 LOG_ERROR("BUG: unexpected TAP condition, TCK low");
548 presto
->jtag_tdi_data
|= (presto
->jtag_tdi_count
- 1) << 4;
549 presto_sendbyte(presto
->jtag_tdi_data
);
550 presto
->jtag_tdi_count
= 0;
551 presto
->jtag_tdi_data
= 0;
556 static int presto_tck_idle(void)
558 if (presto
->jtag_tck
== 1) {
559 presto_sendbyte(0xCA);
560 presto
->jtag_tck
= 0;
566 /* -------------------------------------------------------------------------- */
568 static int presto_bitq_out(int tms
, int tdi
, int tdo_req
)
573 if (presto
->jtag_tck
== 0)
574 presto_sendbyte(0xA4); /* LED idicator - JTAG active */
575 else if (presto
->jtag_speed
== 0 && !tdo_req
&& tms
== presto
->jtag_tms
) {
576 presto
->jtag_tdi_data
|= (tdi
!= 0) << presto
->jtag_tdi_count
;
578 if (++presto
->jtag_tdi_count
== 4)
586 cmd
= tdi
? 0xCB : 0xCA;
587 presto_sendbyte(cmd
);
589 if (tms
!= presto
->jtag_tms
) {
590 presto_sendbyte((tms
? 0xEC : 0xE8) | (presto
->jtag_rst
? 0x02 : 0));
591 presto
->jtag_tms
= tms
;
594 /* delay with TCK low */
595 for (i
= presto
->jtag_speed
; i
> 1; i
--)
596 presto_sendbyte(cmd
);
599 presto_sendbyte(cmd
| (tdo_req
? 0x10 : 0));
601 /* delay with TCK high */
602 for (i
= presto
->jtag_speed
; i
> 1; i
--)
603 presto_sendbyte(cmd
);
605 presto
->jtag_tck
= 1;
610 static int presto_bitq_flush(void)
615 presto_sendbyte(0xA0); /* LED idicator - JTAG idle */
617 return presto_flush();
620 static int presto_bitq_in_rdy(void)
622 if (presto
->buff_in_pos
>= presto
->buff_in_len
)
624 return presto
->buff_in_len
-presto
->buff_in_pos
;
627 static int presto_bitq_in(void)
629 if (presto
->buff_in_pos
>= presto
->buff_in_len
)
631 if (presto
->buff_in
[presto
->buff_in_pos
++]&0x08)
636 static int presto_bitq_sleep(unsigned long us
)
649 waits
= us
/ 170 + 2;
651 presto_sendbyte(0x80);
656 static int presto_bitq_reset(int trst
, int srst
)
661 /* add a delay after possible TCK transition */
662 presto_sendbyte(0x80);
663 presto_sendbyte(0x80);
665 presto
->jtag_rst
= trst
|| srst
;
666 presto_sendbyte((presto
->jtag_rst
? 0xEA : 0xE8) | (presto
->jtag_tms
? 0x04 : 0));
671 static struct bitq_interface presto_bitq
= {
672 .out
= &presto_bitq_out
,
673 .flush
= &presto_bitq_flush
,
674 .sleep
= &presto_bitq_sleep
,
675 .reset
= &presto_bitq_reset
,
676 .in_rdy
= &presto_bitq_in_rdy
,
677 .in
= &presto_bitq_in
,
680 /* -------------------------------------------------------------------------- */
682 static int presto_adapter_khz(int khz
, int *jtag_speed
)
686 return ERROR_COMMAND_SYNTAX_ERROR
;
692 *jtag_speed
= (1000 + khz
-1)/khz
;
697 static int presto_jtag_speed_div(int speed
, int *khz
)
699 if ((speed
< 0) || (speed
> 1000)) {
701 return ERROR_COMMAND_SYNTAX_ERROR
;
712 static int presto_jtag_speed(int speed
)
716 if (presto_jtag_speed_div(speed
, &khz
))
717 return ERROR_COMMAND_SYNTAX_ERROR
;
719 presto
->jtag_speed
= speed
;
722 LOG_INFO("setting speed to %d, max. TCK freq. is %d MHz", speed
, khz
/1000);
724 LOG_INFO("setting speed to %d, max. TCK freq. is %d kHz", speed
, khz
);
729 static char *presto_serial
;
731 COMMAND_HANDLER(presto_handle_serial_command
)
736 presto_serial
= strdup(CMD_ARGV
[0]);
738 return ERROR_COMMAND_SYNTAX_ERROR
;
743 static const struct command_registration presto_command_handlers
[] = {
745 .name
= "presto_serial",
746 .handler
= presto_handle_serial_command
,
747 .mode
= COMMAND_CONFIG
,
748 .help
= "Configure USB serial number of Presto device.",
749 .usage
= "serial_string",
751 COMMAND_REGISTRATION_DONE
754 static int presto_jtag_init(void)
756 if (presto_open(presto_serial
) != ERROR_OK
) {
758 if (presto_serial
!= NULL
)
759 LOG_ERROR("Cannot open PRESTO, serial number '%s'", presto_serial
);
761 LOG_ERROR("Cannot open PRESTO");
762 return ERROR_JTAG_INIT_FAILED
;
764 LOG_INFO("PRESTO open, serial number '%s'", presto
->serial
);
766 bitq_interface
= &presto_bitq
;
770 static int presto_jtag_quit(void)
774 LOG_INFO("PRESTO closed");
778 presto_serial
= NULL
;
784 struct jtag_interface presto_interface
= {
786 .commands
= presto_command_handlers
,
788 .execute_queue
= bitq_execute_queue
,
789 .speed
= presto_jtag_speed
,
790 .khz
= presto_adapter_khz
,
791 .speed_div
= presto_jtag_speed_div
,
792 .init
= presto_jtag_init
,
793 .quit
= presto_jtag_quit
,
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)