1 /***************************************************************************
2 * Copyright (C) 2011-2013 by Martin Schmoelzer *
3 * <martin.schmoelzer@student.tuwien.ac.at> *
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 ***************************************************************************/
24 #include "helper/system.h"
25 #include <jtag/interface.h>
26 #include <jtag/commands.h>
27 #include <target/image.h>
29 #include "libusb_helper.h"
30 #include "OpenULINK/include/msgtypes.h"
32 /** USB Vendor ID of ULINK device in unconfigured state (no firmware loaded
33 * yet) or with OpenULINK firmware. */
34 #define ULINK_VID 0xC251
36 /** USB Product ID of ULINK device in unconfigured state (no firmware loaded
37 * yet) or with OpenULINK firmware. */
38 #define ULINK_PID 0x2710
40 /** Address of EZ-USB CPU Control & Status register. This register can be
41 * written by issuing a Control EP0 vendor request. */
42 #define CPUCS_REG 0x7F92
44 /** USB Control EP0 bRequest: "Firmware Load". */
45 #define REQUEST_FIRMWARE_LOAD 0xA0
47 /** Value to write into CPUCS to put EZ-USB into reset. */
48 #define CPU_RESET 0x01
50 /** Value to write into CPUCS to put EZ-USB out of reset. */
51 #define CPU_START 0x00
53 /** Base address of firmware in EZ-USB code space. */
54 #define FIRMWARE_ADDR 0x0000
56 /** USB interface number */
57 #define USB_INTERFACE 0
59 /** libusb timeout in ms */
60 #define USB_TIMEOUT 5000
62 /** Delay (in microseconds) to wait while EZ-USB performs ReNumeration. */
63 #define ULINK_RENUMERATION_DELAY 1500000
65 /** Default location of OpenULINK firmware image. */
66 #define ULINK_FIRMWARE_FILE PKGDATADIR "/OpenULINK/ulink_firmware.hex"
68 /** Maximum size of a single firmware section. Entire EZ-USB code space = 8kB */
69 #define SECTION_BUFFERSIZE 8192
71 /** Tuning of OpenOCD SCAN commands split into multiple OpenULINK commands. */
72 #define SPLIT_SCAN_THRESHOLD 10
74 /** ULINK hardware type */
76 /** Original ULINK adapter, based on Cypress EZ-USB (AN2131):
77 * Full JTAG support, no SWD support. */
80 /** Newer ULINK adapter, based on NXP LPC2148. Currently unsupported. */
83 /** Newer ULINK adapter, based on EZ-USB FX2 + FPGA. Currently unsupported. */
86 /** Newer ULINK adapter, possibly based on ULINK 2. Currently unsupported. */
90 enum ulink_payload_direction
{
91 PAYLOAD_DIRECTION_OUT
,
95 enum ulink_delay_type
{
104 * OpenULINK command (OpenULINK command queue element).
106 * For the OUT direction payload, things are quite easy: Payload is stored
107 * in a rather small array (up to 63 bytes), the payload is always allocated
108 * by the function generating the command and freed by ulink_clear_queue().
110 * For the IN direction payload, things get a little bit more complicated:
111 * The maximum IN payload size for a single command is 64 bytes. Assume that
112 * a single OpenOCD command needs to scan 256 bytes. This results in the
113 * generation of four OpenULINK commands. The function generating these
114 * commands shall allocate an uint8_t[256] array. Each command's #payload_in
115 * pointer shall point to the corresponding offset where IN data shall be
116 * placed, while #payload_in_start shall point to the first element of the 256
118 * - first command: #payload_in_start + 0
119 * - second command: #payload_in_start + 64
120 * - third command: #payload_in_start + 128
121 * - fourth command: #payload_in_start + 192
123 * The last command sets #needs_postprocessing to true.
126 uint8_t id
; /**< ULINK command ID */
128 uint8_t *payload_out
; /**< OUT direction payload data */
129 uint8_t payload_out_size
; /**< OUT direction payload size for this command */
131 uint8_t *payload_in_start
; /**< Pointer to first element of IN payload array */
132 uint8_t *payload_in
; /**< Pointer where IN payload shall be stored */
133 uint8_t payload_in_size
; /**< IN direction payload size for this command */
135 /** Indicates if this command needs post-processing */
136 bool needs_postprocessing
;
138 /** Indicates if ulink_clear_queue() should free payload_in_start */
139 bool free_payload_in_start
;
141 /** Pointer to corresponding OpenOCD command for post-processing */
142 struct jtag_command
*cmd_origin
;
144 struct ulink_cmd
*next
; /**< Pointer to next command (linked list) */
147 /** Describes one driver instance */
149 struct libusb_context
*libusb_ctx
;
150 struct libusb_device_handle
*usb_device_handle
;
151 enum ulink_type type
;
153 unsigned int ep_in
; /**< IN endpoint number */
154 unsigned int ep_out
; /**< OUT endpoint number */
156 int delay_scan_in
; /**< Delay value for SCAN_IN commands */
157 int delay_scan_out
; /**< Delay value for SCAN_OUT commands */
158 int delay_scan_io
; /**< Delay value for SCAN_IO commands */
159 int delay_clock_tck
; /**< Delay value for CLOCK_TMS commands */
160 int delay_clock_tms
; /**< Delay value for CLOCK_TCK commands */
162 int commands_in_queue
; /**< Number of commands in queue */
163 struct ulink_cmd
*queue_start
; /**< Pointer to first command in queue */
164 struct ulink_cmd
*queue_end
; /**< Pointer to last command in queue */
167 /**************************** Function Prototypes *****************************/
169 /* USB helper functions */
170 static int ulink_usb_open(struct ulink
**device
);
171 static int ulink_usb_close(struct ulink
**device
);
173 /* ULINK MCU (Cypress EZ-USB) specific functions */
174 static int ulink_cpu_reset(struct ulink
*device
, unsigned char reset_bit
);
175 static int ulink_load_firmware_and_renumerate(struct ulink
**device
, const char *filename
,
177 static int ulink_load_firmware(struct ulink
*device
, const char *filename
);
178 static int ulink_write_firmware_section(struct ulink
*device
,
179 struct image
*firmware_image
, int section_index
);
181 /* Generic helper functions */
182 static void ulink_print_signal_states(uint8_t input_signals
, uint8_t output_signals
);
184 /* OpenULINK command generation helper functions */
185 static int ulink_allocate_payload(struct ulink_cmd
*ulink_cmd
, int size
,
186 enum ulink_payload_direction direction
);
188 /* OpenULINK command queue helper functions */
189 static int ulink_get_queue_size(struct ulink
*device
,
190 enum ulink_payload_direction direction
);
191 static void ulink_clear_queue(struct ulink
*device
);
192 static int ulink_append_queue(struct ulink
*device
, struct ulink_cmd
*ulink_cmd
);
193 static int ulink_execute_queued_commands(struct ulink
*device
, int timeout
);
195 static void ulink_print_queue(struct ulink
*device
);
197 static int ulink_append_scan_cmd(struct ulink
*device
,
198 enum scan_type scan_type
,
203 uint8_t tms_count_start
,
204 uint8_t tms_sequence_start
,
205 uint8_t tms_count_end
,
206 uint8_t tms_sequence_end
,
207 struct jtag_command
*origin
,
209 static int ulink_append_clock_tms_cmd(struct ulink
*device
, uint8_t count
,
211 static int ulink_append_clock_tck_cmd(struct ulink
*device
, uint16_t count
);
212 static int ulink_append_get_signals_cmd(struct ulink
*device
);
213 static int ulink_append_set_signals_cmd(struct ulink
*device
, uint8_t low
,
215 static int ulink_append_sleep_cmd(struct ulink
*device
, uint32_t us
);
216 static int ulink_append_configure_tck_cmd(struct ulink
*device
,
222 static int __attribute__((unused
)) ulink_append_led_cmd(struct ulink
*device
, uint8_t led_state
);
223 static int ulink_append_test_cmd(struct ulink
*device
);
225 /* OpenULINK TCK frequency helper functions */
226 static int ulink_calculate_delay(enum ulink_delay_type type
, long f
, int *delay
);
228 /* Interface between OpenULINK and OpenOCD */
229 static void ulink_set_end_state(tap_state_t endstate
);
230 static int ulink_queue_statemove(struct ulink
*device
);
232 static int ulink_queue_scan(struct ulink
*device
, struct jtag_command
*cmd
);
233 static int ulink_queue_tlr_reset(struct ulink
*device
, struct jtag_command
*cmd
);
234 static int ulink_queue_runtest(struct ulink
*device
, struct jtag_command
*cmd
);
235 static int ulink_queue_reset(struct ulink
*device
, struct jtag_command
*cmd
);
236 static int ulink_queue_pathmove(struct ulink
*device
, struct jtag_command
*cmd
);
237 static int ulink_queue_sleep(struct ulink
*device
, struct jtag_command
*cmd
);
238 static int ulink_queue_stableclocks(struct ulink
*device
, struct jtag_command
*cmd
);
240 static int ulink_post_process_scan(struct ulink_cmd
*ulink_cmd
);
241 static int ulink_post_process_queue(struct ulink
*device
);
243 /* adapter driver functions */
244 static int ulink_execute_queue(void);
245 static int ulink_khz(int khz
, int *jtag_speed
);
246 static int ulink_speed(int speed
);
247 static int ulink_speed_div(int speed
, int *khz
);
248 static int ulink_init(void);
249 static int ulink_quit(void);
251 /****************************** Global Variables ******************************/
253 static struct ulink
*ulink_handle
;
255 /**************************** USB helper functions ****************************/
258 * Opens the ULINK device
260 * Currently, only the original ULINK is supported
262 * @param device pointer to struct ulink identifying ULINK driver instance.
263 * @return on success: ERROR_OK
264 * @return on failure: ERROR_FAIL
266 static int ulink_usb_open(struct ulink
**device
)
268 ssize_t num_devices
, i
;
270 struct libusb_device
**usb_devices
;
271 struct libusb_device_descriptor usb_desc
;
272 struct libusb_device_handle
*usb_device_handle
;
274 num_devices
= libusb_get_device_list((*device
)->libusb_ctx
, &usb_devices
);
276 if (num_devices
<= 0)
280 for (i
= 0; i
< num_devices
; i
++) {
281 if (libusb_get_device_descriptor(usb_devices
[i
], &usb_desc
) != 0)
283 else if (usb_desc
.idVendor
== ULINK_VID
&& usb_desc
.idProduct
== ULINK_PID
) {
292 if (libusb_open(usb_devices
[i
], &usb_device_handle
) != 0)
294 libusb_free_device_list(usb_devices
, 1);
296 (*device
)->usb_device_handle
= usb_device_handle
;
297 (*device
)->type
= ULINK_1
;
303 * Releases the ULINK interface and closes the USB device handle.
305 * @param device pointer to struct ulink identifying ULINK driver instance.
306 * @return on success: ERROR_OK
307 * @return on failure: ERROR_FAIL
309 static int ulink_usb_close(struct ulink
**device
)
311 if (libusb_release_interface((*device
)->usb_device_handle
, 0) != 0)
314 libusb_close((*device
)->usb_device_handle
);
316 (*device
)->usb_device_handle
= NULL
;
321 /******************* ULINK CPU (EZ-USB) specific functions ********************/
324 * Writes '0' or '1' to the CPUCS register, putting the EZ-USB CPU into reset
327 * @param device pointer to struct ulink identifying ULINK driver instance.
328 * @param reset_bit 0 to put CPU into reset, 1 to put CPU out of reset.
329 * @return on success: ERROR_OK
330 * @return on failure: ERROR_FAIL
332 static int ulink_cpu_reset(struct ulink
*device
, unsigned char reset_bit
)
336 ret
= libusb_control_transfer(device
->usb_device_handle
,
337 (LIBUSB_ENDPOINT_OUT
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
),
338 REQUEST_FIRMWARE_LOAD
, CPUCS_REG
, 0, &reset_bit
, 1, USB_TIMEOUT
);
340 /* usb_control_msg() returns the number of bytes transferred during the
341 * DATA stage of the control transfer - must be exactly 1 in this case! */
348 * Puts the ULINK's EZ-USB microcontroller into reset state, downloads
349 * the firmware image, resumes the microcontroller and re-enumerates
352 * @param device pointer to struct ulink identifying ULINK driver instance.
353 * The usb_handle member will be modified during re-enumeration.
354 * @param filename path to the Intel HEX file containing the firmware image.
355 * @param delay the delay to wait for the device to re-enumerate.
356 * @return on success: ERROR_OK
357 * @return on failure: ERROR_FAIL
359 static int ulink_load_firmware_and_renumerate(struct ulink
**device
,
360 const char *filename
, uint32_t delay
)
364 /* Basic process: After downloading the firmware, the ULINK will disconnect
365 * itself and re-connect after a short amount of time so we have to close
366 * the handle and re-enumerate USB devices */
368 ret
= ulink_load_firmware(*device
, filename
);
372 ret
= ulink_usb_close(device
);
378 ret
= ulink_usb_open(device
);
386 * Downloads a firmware image to the ULINK's EZ-USB microcontroller
389 * @param device pointer to struct ulink identifying ULINK driver instance.
390 * @param filename an absolute or relative path to the Intel HEX file
391 * containing the firmware image.
392 * @return on success: ERROR_OK
393 * @return on failure: ERROR_FAIL
395 static int ulink_load_firmware(struct ulink
*device
, const char *filename
)
397 struct image ulink_firmware_image
;
400 ret
= ulink_cpu_reset(device
, CPU_RESET
);
401 if (ret
!= ERROR_OK
) {
402 LOG_ERROR("Could not halt ULINK CPU");
406 ulink_firmware_image
.base_address
= 0;
407 ulink_firmware_image
.base_address_set
= false;
409 ret
= image_open(&ulink_firmware_image
, filename
, "ihex");
410 if (ret
!= ERROR_OK
) {
411 LOG_ERROR("Could not load firmware image");
415 /* Download all sections in the image to ULINK */
416 for (unsigned int i
= 0; i
< ulink_firmware_image
.num_sections
; i
++) {
417 ret
= ulink_write_firmware_section(device
, &ulink_firmware_image
, i
);
422 image_close(&ulink_firmware_image
);
424 ret
= ulink_cpu_reset(device
, CPU_START
);
425 if (ret
!= ERROR_OK
) {
426 LOG_ERROR("Could not restart ULINK CPU");
434 * Send one contiguous firmware section to the ULINK's EZ-USB microcontroller
437 * @param device pointer to struct ulink identifying ULINK driver instance.
438 * @param firmware_image pointer to the firmware image that contains the section
439 * which should be sent to the ULINK's EZ-USB microcontroller.
440 * @param section_index index of the section within the firmware image.
441 * @return on success: ERROR_OK
442 * @return on failure: ERROR_FAIL
444 static int ulink_write_firmware_section(struct ulink
*device
,
445 struct image
*firmware_image
, int section_index
)
447 uint16_t addr
, size
, bytes_remaining
, chunk_size
;
448 uint8_t data
[SECTION_BUFFERSIZE
];
449 uint8_t *data_ptr
= data
;
453 size
= (uint16_t)firmware_image
->sections
[section_index
].size
;
454 addr
= (uint16_t)firmware_image
->sections
[section_index
].base_address
;
456 LOG_DEBUG("section %02i at addr 0x%04x (size 0x%04x)", section_index
, addr
,
459 /* Copy section contents to local buffer */
460 ret
= image_read_section(firmware_image
, section_index
, 0, size
, data
,
463 if ((ret
!= ERROR_OK
) || (size_read
!= size
)) {
464 /* Propagating the return code would return '0' (misleadingly indicating
465 * successful execution of the function) if only the size check fails. */
469 bytes_remaining
= size
;
471 /* Send section data in chunks of up to 64 bytes to ULINK */
472 while (bytes_remaining
> 0) {
473 if (bytes_remaining
> 64)
476 chunk_size
= bytes_remaining
;
478 ret
= libusb_control_transfer(device
->usb_device_handle
,
479 (LIBUSB_ENDPOINT_OUT
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
),
480 REQUEST_FIRMWARE_LOAD
, addr
, FIRMWARE_ADDR
, (unsigned char *)data_ptr
,
481 chunk_size
, USB_TIMEOUT
);
483 if (ret
!= (int)chunk_size
) {
484 /* Abort if libusb sent less data than requested */
488 bytes_remaining
-= chunk_size
;
490 data_ptr
+= chunk_size
;
496 /************************** Generic helper functions **************************/
499 * Print state of interesting signals via LOG_INFO().
501 * @param input_signals input signal states as returned by CMD_GET_SIGNALS
502 * @param output_signals output signal states as returned by CMD_GET_SIGNALS
504 static void ulink_print_signal_states(uint8_t input_signals
, uint8_t output_signals
)
506 LOG_INFO("ULINK signal states: TDI: %i, TDO: %i, TMS: %i, TCK: %i, TRST: %i,"
508 (output_signals
& SIGNAL_TDI
? 1 : 0),
509 (input_signals
& SIGNAL_TDO
? 1 : 0),
510 (output_signals
& SIGNAL_TMS
? 1 : 0),
511 (output_signals
& SIGNAL_TCK
? 1 : 0),
512 (output_signals
& SIGNAL_TRST
? 0 : 1), /* Inverted by hardware */
513 (output_signals
& SIGNAL_RESET
? 0 : 1)); /* Inverted by hardware */
516 /**************** OpenULINK command generation helper functions ***************/
519 * Allocate and initialize space in memory for OpenULINK command payload.
521 * @param ulink_cmd pointer to command whose payload should be allocated.
522 * @param size the amount of memory to allocate (bytes).
523 * @param direction which payload to allocate.
524 * @return on success: ERROR_OK
525 * @return on failure: ERROR_FAIL
527 static int ulink_allocate_payload(struct ulink_cmd
*ulink_cmd
, int size
,
528 enum ulink_payload_direction direction
)
532 payload
= calloc(size
, sizeof(uint8_t));
535 LOG_ERROR("Could not allocate OpenULINK command payload: out of memory");
540 case PAYLOAD_DIRECTION_OUT
:
541 if (ulink_cmd
->payload_out
) {
542 LOG_ERROR("BUG: Duplicate payload allocation for OpenULINK command");
546 ulink_cmd
->payload_out
= payload
;
547 ulink_cmd
->payload_out_size
= size
;
550 case PAYLOAD_DIRECTION_IN
:
551 if (ulink_cmd
->payload_in_start
) {
552 LOG_ERROR("BUG: Duplicate payload allocation for OpenULINK command");
556 ulink_cmd
->payload_in_start
= payload
;
557 ulink_cmd
->payload_in
= payload
;
558 ulink_cmd
->payload_in_size
= size
;
560 /* By default, free payload_in_start in ulink_clear_queue(). Commands
561 * that do not want this behavior (e. g. split scans) must turn it off
563 ulink_cmd
->free_payload_in_start
= true;
571 /****************** OpenULINK command queue helper functions ******************/
574 * Get the current number of bytes in the queue, including command IDs.
576 * @param device pointer to struct ulink identifying ULINK driver instance.
577 * @param direction the transfer direction for which to get byte count.
578 * @return the number of bytes currently stored in the queue for the specified
581 static int ulink_get_queue_size(struct ulink
*device
,
582 enum ulink_payload_direction direction
)
584 struct ulink_cmd
*current
= device
->queue_start
;
589 case PAYLOAD_DIRECTION_OUT
:
590 sum
+= current
->payload_out_size
+ 1; /* + 1 byte for Command ID */
592 case PAYLOAD_DIRECTION_IN
:
593 sum
+= current
->payload_in_size
;
597 current
= current
->next
;
604 * Clear the OpenULINK command queue.
606 * @param device pointer to struct ulink identifying ULINK driver instance.
607 * @return on success: ERROR_OK
608 * @return on failure: ERROR_FAIL
610 static void ulink_clear_queue(struct ulink
*device
)
612 struct ulink_cmd
*current
= device
->queue_start
;
613 struct ulink_cmd
*next
= NULL
;
616 /* Save pointer to next element */
617 next
= current
->next
;
619 /* Free payloads: OUT payload can be freed immediately */
620 free(current
->payload_out
);
621 current
->payload_out
= NULL
;
623 /* IN payload MUST be freed ONLY if no other commands use the
624 * payload_in_start buffer */
625 if (current
->free_payload_in_start
== true) {
626 free(current
->payload_in_start
);
627 current
->payload_in_start
= NULL
;
628 current
->payload_in
= NULL
;
631 /* Free queue element */
634 /* Proceed with next element */
638 device
->commands_in_queue
= 0;
639 device
->queue_start
= NULL
;
640 device
->queue_end
= NULL
;
644 * Add a command to the OpenULINK command queue.
646 * @param device pointer to struct ulink identifying ULINK driver instance.
647 * @param ulink_cmd pointer to command that shall be appended to the OpenULINK
649 * @return on success: ERROR_OK
650 * @return on failure: ERROR_FAIL
652 static int ulink_append_queue(struct ulink
*device
, struct ulink_cmd
*ulink_cmd
)
654 int newsize_out
, newsize_in
;
657 newsize_out
= ulink_get_queue_size(device
, PAYLOAD_DIRECTION_OUT
) + 1
658 + ulink_cmd
->payload_out_size
;
660 newsize_in
= ulink_get_queue_size(device
, PAYLOAD_DIRECTION_IN
)
661 + ulink_cmd
->payload_in_size
;
663 /* Check if the current command can be appended to the queue */
664 if ((newsize_out
> 64) || (newsize_in
> 64)) {
665 /* New command does not fit. Execute all commands in queue before starting
666 * new queue with the current command as first entry. */
667 ret
= ulink_execute_queued_commands(device
, USB_TIMEOUT
);
670 ret
= ulink_post_process_queue(device
);
673 ulink_clear_queue(device
);
676 if (!device
->queue_start
) {
677 /* Queue was empty */
678 device
->commands_in_queue
= 1;
680 device
->queue_start
= ulink_cmd
;
681 device
->queue_end
= ulink_cmd
;
683 /* There are already commands in the queue */
684 device
->commands_in_queue
++;
686 device
->queue_end
->next
= ulink_cmd
;
687 device
->queue_end
= ulink_cmd
;
691 ulink_clear_queue(device
);
697 * Sends all queued OpenULINK commands to the ULINK for execution.
699 * @param device pointer to struct ulink identifying ULINK driver instance.
701 * @return on success: ERROR_OK
702 * @return on failure: ERROR_FAIL
704 static int ulink_execute_queued_commands(struct ulink
*device
, int timeout
)
706 struct ulink_cmd
*current
;
707 int ret
, i
, index_out
, index_in
, count_out
, count_in
, transferred
;
710 if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO
))
711 ulink_print_queue(device
);
717 for (current
= device
->queue_start
; current
; current
= current
->next
) {
718 /* Add command to packet */
719 buffer
[index_out
] = current
->id
;
723 for (i
= 0; i
< current
->payload_out_size
; i
++)
724 buffer
[index_out
+ i
] = current
->payload_out
[i
];
725 index_out
+= current
->payload_out_size
;
726 count_in
+= current
->payload_in_size
;
727 count_out
+= current
->payload_out_size
;
730 /* Send packet to ULINK */
731 ret
= libusb_bulk_transfer(device
->usb_device_handle
, device
->ep_out
,
732 (unsigned char *)buffer
, count_out
, &transferred
, timeout
);
735 if (transferred
!= count_out
)
738 /* Wait for response if commands contain IN payload data */
740 ret
= libusb_bulk_transfer(device
->usb_device_handle
, device
->ep_in
,
741 (unsigned char *)buffer
, 64, &transferred
, timeout
);
744 if (transferred
!= count_in
)
747 /* Write back IN payload data */
749 for (current
= device
->queue_start
; current
; current
= current
->next
) {
750 for (i
= 0; i
< current
->payload_in_size
; i
++) {
751 current
->payload_in
[i
] = buffer
[index_in
];
761 * Convert an OpenULINK command ID (\a id) to a human-readable string.
763 * @param id the OpenULINK command ID.
764 * @return the corresponding human-readable string.
766 static const char *ulink_cmd_id_string(uint8_t id
)
770 return "CMD_SCAN_IN";
771 case CMD_SLOW_SCAN_IN
:
772 return "CMD_SLOW_SCAN_IN";
774 return "CMD_SCAN_OUT";
775 case CMD_SLOW_SCAN_OUT
:
776 return "CMD_SLOW_SCAN_OUT";
778 return "CMD_SCAN_IO";
779 case CMD_SLOW_SCAN_IO
:
780 return "CMD_SLOW_SCAN_IO";
782 return "CMD_CLOCK_TMS";
783 case CMD_SLOW_CLOCK_TMS
:
784 return "CMD_SLOW_CLOCK_TMS";
786 return "CMD_CLOCK_TCK";
787 case CMD_SLOW_CLOCK_TCK
:
788 return "CMD_SLOW_CLOCK_TCK";
790 return "CMD_SLEEP_US";
792 return "CMD_SLEEP_MS";
793 case CMD_GET_SIGNALS
:
794 return "CMD_GET_SIGNALS";
795 case CMD_SET_SIGNALS
:
796 return "CMD_SET_SIGNALS";
797 case CMD_CONFIGURE_TCK_FREQ
:
798 return "CMD_CONFIGURE_TCK_FREQ";
800 return "CMD_SET_LEDS";
804 return "CMD_UNKNOWN";
809 * Print one OpenULINK command to stdout.
811 * @param ulink_cmd pointer to OpenULINK command.
813 static void ulink_print_command(struct ulink_cmd
*ulink_cmd
)
817 printf(" %-22s | OUT size = %i, bytes = 0x",
818 ulink_cmd_id_string(ulink_cmd
->id
), ulink_cmd
->payload_out_size
);
820 for (i
= 0; i
< ulink_cmd
->payload_out_size
; i
++)
821 printf("%02X ", ulink_cmd
->payload_out
[i
]);
822 printf("\n | IN size = %i\n",
823 ulink_cmd
->payload_in_size
);
827 * Print the OpenULINK command queue to stdout.
829 * @param device pointer to struct ulink identifying ULINK driver instance.
831 static void ulink_print_queue(struct ulink
*device
)
833 struct ulink_cmd
*current
;
835 printf("OpenULINK command queue:\n");
837 for (current
= device
->queue_start
; current
; current
= current
->next
)
838 ulink_print_command(current
);
844 * Creates and appends a JTAG scan command to the OpenULINK command queue.
845 * A JTAG scan consists of three steps:
846 * - Move to the desired SHIFT state, depending on scan type (IR/DR scan).
847 * - Shift TDI data into the JTAG chain, optionally reading the TDO pin.
848 * - Move to the desired end state.
850 * @param device pointer to struct ulink identifying ULINK driver instance.
851 * @param scan_type the type of the scan (IN, OUT, IO (bidirectional)).
852 * @param scan_size_bits number of bits to shift into the JTAG chain.
853 * @param tdi pointer to array containing TDI data.
854 * @param tdo_start pointer to first element of array where TDO data shall be
855 * stored. See #ulink_cmd for details.
856 * @param tdo pointer to array where TDO data shall be stored
857 * @param tms_count_start number of TMS state transitions to perform BEFORE
858 * shifting data into the JTAG chain.
859 * @param tms_sequence_start sequence of TMS state transitions that will be
860 * performed BEFORE shifting data into the JTAG chain.
861 * @param tms_count_end number of TMS state transitions to perform AFTER
862 * shifting data into the JTAG chain.
863 * @param tms_sequence_end sequence of TMS state transitions that will be
864 * performed AFTER shifting data into the JTAG chain.
865 * @param origin pointer to OpenOCD command that generated this scan command.
866 * @param postprocess whether this command needs to be post-processed after
868 * @return on success: ERROR_OK
869 * @return on failure: ERROR_FAIL
871 static int ulink_append_scan_cmd(struct ulink
*device
, enum scan_type scan_type
,
872 int scan_size_bits
, uint8_t *tdi
, uint8_t *tdo_start
, uint8_t *tdo
,
873 uint8_t tms_count_start
, uint8_t tms_sequence_start
, uint8_t tms_count_end
,
874 uint8_t tms_sequence_end
, struct jtag_command
*origin
, bool postprocess
)
876 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
877 int ret
, i
, scan_size_bytes
;
878 uint8_t bits_last_byte
;
883 /* Check size of command. USB buffer can hold 64 bytes, 1 byte is command ID,
884 * 5 bytes are setup data -> 58 remaining payload bytes for TDI data */
885 if (scan_size_bits
> (58 * 8)) {
886 LOG_ERROR("BUG: Tried to create CMD_SCAN_IO OpenULINK command with too"
892 scan_size_bytes
= DIV_ROUND_UP(scan_size_bits
, 8);
894 bits_last_byte
= scan_size_bits
% 8;
895 if (bits_last_byte
== 0)
898 /* Allocate out_payload depending on scan type */
901 if (device
->delay_scan_in
< 0)
902 cmd
->id
= CMD_SCAN_IN
;
904 cmd
->id
= CMD_SLOW_SCAN_IN
;
905 ret
= ulink_allocate_payload(cmd
, 5, PAYLOAD_DIRECTION_OUT
);
908 if (device
->delay_scan_out
< 0)
909 cmd
->id
= CMD_SCAN_OUT
;
911 cmd
->id
= CMD_SLOW_SCAN_OUT
;
912 ret
= ulink_allocate_payload(cmd
, scan_size_bytes
+ 5, PAYLOAD_DIRECTION_OUT
);
915 if (device
->delay_scan_io
< 0)
916 cmd
->id
= CMD_SCAN_IO
;
918 cmd
->id
= CMD_SLOW_SCAN_IO
;
919 ret
= ulink_allocate_payload(cmd
, scan_size_bytes
+ 5, PAYLOAD_DIRECTION_OUT
);
922 LOG_ERROR("BUG: ulink_append_scan_cmd() encountered an unknown scan type");
927 if (ret
!= ERROR_OK
) {
932 /* Build payload_out that is common to all scan types */
933 cmd
->payload_out
[0] = scan_size_bytes
& 0xFF;
934 cmd
->payload_out
[1] = bits_last_byte
& 0xFF;
935 cmd
->payload_out
[2] = ((tms_count_start
& 0x0F) << 4) | (tms_count_end
& 0x0F);
936 cmd
->payload_out
[3] = tms_sequence_start
;
937 cmd
->payload_out
[4] = tms_sequence_end
;
939 /* Setup payload_out for types with OUT transfer */
940 if ((scan_type
== SCAN_OUT
) || (scan_type
== SCAN_IO
)) {
941 for (i
= 0; i
< scan_size_bytes
; i
++)
942 cmd
->payload_out
[i
+ 5] = tdi
[i
];
945 /* Setup payload_in pointers for types with IN transfer */
946 if ((scan_type
== SCAN_IN
) || (scan_type
== SCAN_IO
)) {
947 cmd
->payload_in_start
= tdo_start
;
948 cmd
->payload_in
= tdo
;
949 cmd
->payload_in_size
= scan_size_bytes
;
952 cmd
->needs_postprocessing
= postprocess
;
953 cmd
->cmd_origin
= origin
;
955 /* For scan commands, we free payload_in_start only when the command is
956 * the last in a series of split commands or a stand-alone command */
957 cmd
->free_payload_in_start
= postprocess
;
959 return ulink_append_queue(device
, cmd
);
963 * Perform TAP state transitions
965 * @param device pointer to struct ulink identifying ULINK driver instance.
966 * @param count defines the number of TCK clock cycles generated (up to 8).
967 * @param sequence defines the TMS pin levels for each state transition. The
968 * Least-Significant Bit is read first.
969 * @return on success: ERROR_OK
970 * @return on failure: ERROR_FAIL
972 static int ulink_append_clock_tms_cmd(struct ulink
*device
, uint8_t count
,
975 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
981 if (device
->delay_clock_tms
< 0)
982 cmd
->id
= CMD_CLOCK_TMS
;
984 cmd
->id
= CMD_SLOW_CLOCK_TMS
;
986 /* CMD_CLOCK_TMS has two OUT payload bytes and zero IN payload bytes */
987 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
988 if (ret
!= ERROR_OK
) {
993 cmd
->payload_out
[0] = count
;
994 cmd
->payload_out
[1] = sequence
;
996 return ulink_append_queue(device
, cmd
);
1000 * Generate a defined amount of TCK clock cycles
1002 * All other JTAG signals are left unchanged.
1004 * @param device pointer to struct ulink identifying ULINK driver instance.
1005 * @param count the number of TCK clock cycles to generate.
1006 * @return on success: ERROR_OK
1007 * @return on failure: ERROR_FAIL
1009 static int ulink_append_clock_tck_cmd(struct ulink
*device
, uint16_t count
)
1011 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1017 if (device
->delay_clock_tck
< 0)
1018 cmd
->id
= CMD_CLOCK_TCK
;
1020 cmd
->id
= CMD_SLOW_CLOCK_TCK
;
1022 /* CMD_CLOCK_TCK has two OUT payload bytes and zero IN payload bytes */
1023 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
1024 if (ret
!= ERROR_OK
) {
1029 cmd
->payload_out
[0] = count
& 0xff;
1030 cmd
->payload_out
[1] = (count
>> 8) & 0xff;
1032 return ulink_append_queue(device
, cmd
);
1036 * Read JTAG signals.
1038 * @param device pointer to struct ulink identifying ULINK driver instance.
1039 * @return on success: ERROR_OK
1040 * @return on failure: ERROR_FAIL
1042 static int ulink_append_get_signals_cmd(struct ulink
*device
)
1044 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1050 cmd
->id
= CMD_GET_SIGNALS
;
1051 cmd
->needs_postprocessing
= true;
1053 /* CMD_GET_SIGNALS has two IN payload bytes */
1054 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_IN
);
1056 if (ret
!= ERROR_OK
) {
1061 return ulink_append_queue(device
, cmd
);
1065 * Arbitrarily set JTAG output signals.
1067 * @param device pointer to struct ulink identifying ULINK driver instance.
1068 * @param low defines which signals will be de-asserted. Each bit corresponds
1077 * @param high defines which signals will be asserted.
1078 * @return on success: ERROR_OK
1079 * @return on failure: ERROR_FAIL
1081 static int ulink_append_set_signals_cmd(struct ulink
*device
, uint8_t low
,
1084 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1090 cmd
->id
= CMD_SET_SIGNALS
;
1092 /* CMD_SET_SIGNALS has two OUT payload bytes and zero IN payload bytes */
1093 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
1095 if (ret
!= ERROR_OK
) {
1100 cmd
->payload_out
[0] = low
;
1101 cmd
->payload_out
[1] = high
;
1103 return ulink_append_queue(device
, cmd
);
1107 * Sleep for a pre-defined number of microseconds
1109 * @param device pointer to struct ulink identifying ULINK driver instance.
1110 * @param us the number microseconds to sleep.
1111 * @return on success: ERROR_OK
1112 * @return on failure: ERROR_FAIL
1114 static int ulink_append_sleep_cmd(struct ulink
*device
, uint32_t us
)
1116 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1122 cmd
->id
= CMD_SLEEP_US
;
1124 /* CMD_SLEEP_US has two OUT payload bytes and zero IN payload bytes */
1125 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
1127 if (ret
!= ERROR_OK
) {
1132 cmd
->payload_out
[0] = us
& 0x00ff;
1133 cmd
->payload_out
[1] = (us
>> 8) & 0x00ff;
1135 return ulink_append_queue(device
, cmd
);
1139 * Set TCK delay counters
1141 * @param device pointer to struct ulink identifying ULINK driver instance.
1142 * @param delay_scan_in delay count top value in jtag_slow_scan_in() function.
1143 * @param delay_scan_out delay count top value in jtag_slow_scan_out() function.
1144 * @param delay_scan_io delay count top value in jtag_slow_scan_io() function.
1145 * @param delay_tck delay count top value in jtag_clock_tck() function.
1146 * @param delay_tms delay count top value in jtag_slow_clock_tms() function.
1147 * @return on success: ERROR_OK
1148 * @return on failure: ERROR_FAIL
1150 static int ulink_append_configure_tck_cmd(struct ulink
*device
, int delay_scan_in
,
1151 int delay_scan_out
, int delay_scan_io
, int delay_tck
, int delay_tms
)
1153 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1159 cmd
->id
= CMD_CONFIGURE_TCK_FREQ
;
1161 /* CMD_CONFIGURE_TCK_FREQ has five OUT payload bytes and zero
1162 * IN payload bytes */
1163 ret
= ulink_allocate_payload(cmd
, 5, PAYLOAD_DIRECTION_OUT
);
1164 if (ret
!= ERROR_OK
) {
1169 if (delay_scan_in
< 0)
1170 cmd
->payload_out
[0] = 0;
1172 cmd
->payload_out
[0] = (uint8_t)delay_scan_in
;
1174 if (delay_scan_out
< 0)
1175 cmd
->payload_out
[1] = 0;
1177 cmd
->payload_out
[1] = (uint8_t)delay_scan_out
;
1179 if (delay_scan_io
< 0)
1180 cmd
->payload_out
[2] = 0;
1182 cmd
->payload_out
[2] = (uint8_t)delay_scan_io
;
1185 cmd
->payload_out
[3] = 0;
1187 cmd
->payload_out
[3] = (uint8_t)delay_tck
;
1190 cmd
->payload_out
[4] = 0;
1192 cmd
->payload_out
[4] = (uint8_t)delay_tms
;
1194 return ulink_append_queue(device
, cmd
);
1198 * Turn on/off ULINK LEDs.
1200 * @param device pointer to struct ulink identifying ULINK driver instance.
1201 * @param led_state which LED(s) to turn on or off. The following bits
1202 * influence the LEDS:
1203 * - Bit 0: Turn COM LED on
1204 * - Bit 1: Turn RUN LED on
1205 * - Bit 2: Turn COM LED off
1206 * - Bit 3: Turn RUN LED off
1207 * If both the on-bit and the off-bit for the same LED is set, the LED is
1209 * @return on success: ERROR_OK
1210 * @return on failure: ERROR_FAIL
1212 static int ulink_append_led_cmd(struct ulink
*device
, uint8_t led_state
)
1214 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1220 cmd
->id
= CMD_SET_LEDS
;
1222 /* CMD_SET_LEDS has one OUT payload byte and zero IN payload bytes */
1223 ret
= ulink_allocate_payload(cmd
, 1, PAYLOAD_DIRECTION_OUT
);
1224 if (ret
!= ERROR_OK
) {
1229 cmd
->payload_out
[0] = led_state
;
1231 return ulink_append_queue(device
, cmd
);
1235 * Test command. Used to check if the ULINK device is ready to accept new
1238 * @param device pointer to struct ulink identifying ULINK driver instance.
1239 * @return on success: ERROR_OK
1240 * @return on failure: ERROR_FAIL
1242 static int ulink_append_test_cmd(struct ulink
*device
)
1244 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1252 /* CMD_TEST has one OUT payload byte and zero IN payload bytes */
1253 ret
= ulink_allocate_payload(cmd
, 1, PAYLOAD_DIRECTION_OUT
);
1254 if (ret
!= ERROR_OK
) {
1259 cmd
->payload_out
[0] = 0xAA;
1261 return ulink_append_queue(device
, cmd
);
1264 /****************** OpenULINK TCK frequency helper functions ******************/
1267 * Calculate delay values for a given TCK frequency.
1269 * The OpenULINK firmware uses five different speed values for different
1270 * commands. These speed values are calculated in these functions.
1272 * The five different commands which support variable TCK frequency are
1273 * implemented twice in the firmware:
1274 * 1. Maximum possible frequency without any artificial delay
1275 * 2. Variable frequency with artificial linear delay loop
1277 * To set the ULINK to maximum frequency, it is only necessary to use the
1278 * corresponding command IDs. To set the ULINK to a lower frequency, the
1279 * delay loop top values have to be calculated first. Then, a
1280 * CMD_CONFIGURE_TCK_FREQ command needs to be sent to the ULINK device.
1282 * The delay values are described by linear equations:
1284 * (t = period, k = constant, x = delay value, d = constant)
1286 * Thus, the delay can be calculated as in the following equation:
1289 * The constants in these equations have been determined and validated by
1290 * measuring the frequency resulting from different delay values.
1292 * @param type for which command to calculate the delay value.
1293 * @param f TCK frequency for which to calculate the delay value in Hz.
1294 * @param delay where to store resulting delay value.
1295 * @return on success: ERROR_OK
1296 * @return on failure: ERROR_FAIL
1298 static int ulink_calculate_delay(enum ulink_delay_type type
, long f
, int *delay
)
1302 /* Calculate period of requested TCK frequency */
1303 t
= 1.0 / (float)(f
);
1306 case DELAY_CLOCK_TCK
:
1307 x
= (t
- (float)(6E-6)) / (float)(4E-6);
1309 case DELAY_CLOCK_TMS
:
1310 x
= (t
- (float)(8.5E-6)) / (float)(4E-6);
1313 x
= (t
- (float)(8.8308E-6)) / (float)(4E-6);
1315 case DELAY_SCAN_OUT
:
1316 x
= (t
- (float)(1.0527E-5)) / (float)(4E-6);
1319 x
= (t
- (float)(1.3132E-5)) / (float)(4E-6);
1326 /* Check if the delay value is negative. This happens when a frequency is
1327 * requested that is too high for the delay loop implementation. In this
1328 * case, set delay value to zero. */
1332 /* We need to convert the exact delay value to an integer. Therefore, we
1333 * round the exact value UP to ensure that the resulting frequency is NOT
1334 * higher than the requested frequency. */
1337 /* Check if the value is within limits */
1341 *delay
= (int)x_ceil
;
1347 * Calculate frequency for a given delay value.
1349 * Similar to the #ulink_calculate_delay function, this function calculates the
1350 * TCK frequency for a given delay value by using linear equations of the form:
1352 * (t = period, k = constant, x = delay value, d = constant)
1354 * @param type for which command to calculate the delay value.
1355 * @param delay delay value for which to calculate the resulting TCK frequency.
1356 * @return the resulting TCK frequency
1358 static long ulink_calculate_frequency(enum ulink_delay_type type
, int delay
)
1366 case DELAY_CLOCK_TCK
:
1368 t
= (float)(2.666E-6);
1370 t
= (float)(4E-6) * (float)(delay
) + (float)(6E-6);
1372 case DELAY_CLOCK_TMS
:
1374 t
= (float)(5.666E-6);
1376 t
= (float)(4E-6) * (float)(delay
) + (float)(8.5E-6);
1380 t
= (float)(5.5E-6);
1382 t
= (float)(4E-6) * (float)(delay
) + (float)(8.8308E-6);
1384 case DELAY_SCAN_OUT
:
1386 t
= (float)(7.0E-6);
1388 t
= (float)(4E-6) * (float)(delay
) + (float)(1.0527E-5);
1392 t
= (float)(9.926E-6);
1394 t
= (float)(4E-6) * (float)(delay
) + (float)(1.3132E-5);
1401 return roundf(f_float
);
1404 /******************* Interface between OpenULINK and OpenOCD ******************/
1407 * Sets the end state follower (see interface.h) if \a endstate is a stable
1410 * @param endstate the state the end state follower should be set to.
1412 static void ulink_set_end_state(tap_state_t endstate
)
1414 if (tap_is_state_stable(endstate
))
1415 tap_set_end_state(endstate
);
1417 LOG_ERROR("BUG: %s is not a valid end state", tap_state_name(endstate
));
1423 * Move from the current TAP state to the current TAP end state.
1425 * @param device pointer to struct ulink identifying ULINK driver instance.
1426 * @return on success: ERROR_OK
1427 * @return on failure: ERROR_FAIL
1429 static int ulink_queue_statemove(struct ulink
*device
)
1431 uint8_t tms_sequence
, tms_count
;
1434 if (tap_get_state() == tap_get_end_state()) {
1435 /* Do nothing if we are already there */
1439 tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1440 tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1442 ret
= ulink_append_clock_tms_cmd(device
, tms_count
, tms_sequence
);
1444 if (ret
== ERROR_OK
)
1445 tap_set_state(tap_get_end_state());
1451 * Perform a scan operation on a JTAG register.
1453 * @param device pointer to struct ulink identifying ULINK driver instance.
1454 * @param cmd pointer to the command that shall be executed.
1455 * @return on success: ERROR_OK
1456 * @return on failure: ERROR_FAIL
1458 static int ulink_queue_scan(struct ulink
*device
, struct jtag_command
*cmd
)
1460 uint32_t scan_size_bits
, scan_size_bytes
, bits_last_scan
;
1461 uint32_t scans_max_payload
, bytecount
;
1462 uint8_t *tdi_buffer_start
= NULL
, *tdi_buffer
= NULL
;
1463 uint8_t *tdo_buffer_start
= NULL
, *tdo_buffer
= NULL
;
1465 uint8_t first_tms_count
, first_tms_sequence
;
1466 uint8_t last_tms_count
, last_tms_sequence
;
1468 uint8_t tms_count_pause
, tms_sequence_pause
;
1469 uint8_t tms_count_resume
, tms_sequence_resume
;
1471 uint8_t tms_count_start
, tms_sequence_start
;
1472 uint8_t tms_count_end
, tms_sequence_end
;
1474 enum scan_type type
;
1477 /* Determine scan size */
1478 scan_size_bits
= jtag_scan_size(cmd
->cmd
.scan
);
1479 scan_size_bytes
= DIV_ROUND_UP(scan_size_bits
, 8);
1481 /* Determine scan type (IN/OUT/IO) */
1482 type
= jtag_scan_type(cmd
->cmd
.scan
);
1484 /* Determine number of scan commands with maximum payload */
1485 scans_max_payload
= scan_size_bytes
/ 58;
1487 /* Determine size of last shift command */
1488 bits_last_scan
= scan_size_bits
- (scans_max_payload
* 58 * 8);
1490 /* Allocate TDO buffer if required */
1491 if ((type
== SCAN_IN
) || (type
== SCAN_IO
)) {
1492 tdo_buffer_start
= calloc(sizeof(uint8_t), scan_size_bytes
);
1494 if (!tdo_buffer_start
)
1497 tdo_buffer
= tdo_buffer_start
;
1500 /* Fill TDI buffer if required */
1501 if ((type
== SCAN_OUT
) || (type
== SCAN_IO
)) {
1502 jtag_build_buffer(cmd
->cmd
.scan
, &tdi_buffer_start
);
1503 tdi_buffer
= tdi_buffer_start
;
1506 /* Get TAP state transitions */
1507 if (cmd
->cmd
.scan
->ir_scan
) {
1508 ulink_set_end_state(TAP_IRSHIFT
);
1509 first_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1510 first_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1512 tap_set_state(TAP_IRSHIFT
);
1513 tap_set_end_state(cmd
->cmd
.scan
->end_state
);
1514 last_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1515 last_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1517 /* TAP state transitions for split scans */
1518 tms_count_pause
= tap_get_tms_path_len(TAP_IRSHIFT
, TAP_IRPAUSE
);
1519 tms_sequence_pause
= tap_get_tms_path(TAP_IRSHIFT
, TAP_IRPAUSE
);
1520 tms_count_resume
= tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRSHIFT
);
1521 tms_sequence_resume
= tap_get_tms_path(TAP_IRPAUSE
, TAP_IRSHIFT
);
1523 ulink_set_end_state(TAP_DRSHIFT
);
1524 first_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1525 first_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1527 tap_set_state(TAP_DRSHIFT
);
1528 tap_set_end_state(cmd
->cmd
.scan
->end_state
);
1529 last_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1530 last_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1532 /* TAP state transitions for split scans */
1533 tms_count_pause
= tap_get_tms_path_len(TAP_DRSHIFT
, TAP_DRPAUSE
);
1534 tms_sequence_pause
= tap_get_tms_path(TAP_DRSHIFT
, TAP_DRPAUSE
);
1535 tms_count_resume
= tap_get_tms_path_len(TAP_DRPAUSE
, TAP_DRSHIFT
);
1536 tms_sequence_resume
= tap_get_tms_path(TAP_DRPAUSE
, TAP_DRSHIFT
);
1539 /* Generate scan commands */
1540 bytecount
= scan_size_bytes
;
1541 while (bytecount
> 0) {
1542 if (bytecount
== scan_size_bytes
) {
1543 /* This is the first scan */
1544 tms_count_start
= first_tms_count
;
1545 tms_sequence_start
= first_tms_sequence
;
1547 /* Resume from previous scan */
1548 tms_count_start
= tms_count_resume
;
1549 tms_sequence_start
= tms_sequence_resume
;
1552 if (bytecount
> 58) { /* Full scan, at least one scan will follow */
1553 tms_count_end
= tms_count_pause
;
1554 tms_sequence_end
= tms_sequence_pause
;
1556 ret
= ulink_append_scan_cmd(device
,
1571 /* Update TDI and TDO buffer pointers */
1572 if (tdi_buffer_start
)
1574 if (tdo_buffer_start
)
1576 } else if (bytecount
== 58) { /* Full scan, no further scans */
1577 tms_count_end
= last_tms_count
;
1578 tms_sequence_end
= last_tms_sequence
;
1580 ret
= ulink_append_scan_cmd(device
,
1594 } else {/* Scan with less than maximum payload, no further scans */
1595 tms_count_end
= last_tms_count
;
1596 tms_sequence_end
= last_tms_sequence
;
1598 ret
= ulink_append_scan_cmd(device
,
1614 if (ret
!= ERROR_OK
) {
1615 free(tdi_buffer_start
);
1616 free(tdo_buffer_start
);
1621 free(tdi_buffer_start
);
1623 /* Set current state to the end state requested by the command */
1624 tap_set_state(cmd
->cmd
.scan
->end_state
);
1630 * Move the TAP into the Test Logic Reset state.
1632 * @param device pointer to struct ulink identifying ULINK driver instance.
1633 * @param cmd pointer to the command that shall be executed.
1634 * @return on success: ERROR_OK
1635 * @return on failure: ERROR_FAIL
1637 static int ulink_queue_tlr_reset(struct ulink
*device
, struct jtag_command
*cmd
)
1641 ret
= ulink_append_clock_tms_cmd(device
, 5, 0xff);
1643 if (ret
== ERROR_OK
)
1644 tap_set_state(TAP_RESET
);
1652 * Generate TCK clock cycles while remaining
1653 * in the Run-Test/Idle state.
1655 * @param device pointer to struct ulink identifying ULINK driver instance.
1656 * @param cmd pointer to the command that shall be executed.
1657 * @return on success: ERROR_OK
1658 * @return on failure: ERROR_FAIL
1660 static int ulink_queue_runtest(struct ulink
*device
, struct jtag_command
*cmd
)
1664 /* Only perform statemove if the TAP currently isn't in the TAP_IDLE state */
1665 if (tap_get_state() != TAP_IDLE
) {
1666 ulink_set_end_state(TAP_IDLE
);
1667 ulink_queue_statemove(device
);
1670 /* Generate the clock cycles */
1671 ret
= ulink_append_clock_tck_cmd(device
, cmd
->cmd
.runtest
->num_cycles
);
1672 if (ret
!= ERROR_OK
)
1675 /* Move to end state specified in command */
1676 if (cmd
->cmd
.runtest
->end_state
!= tap_get_state()) {
1677 tap_set_end_state(cmd
->cmd
.runtest
->end_state
);
1678 ulink_queue_statemove(device
);
1685 * Execute a JTAG_RESET command
1688 * @param cmd pointer to the command that shall be executed.
1689 * @return on success: ERROR_OK
1690 * @return on failure: ERROR_FAIL
1692 static int ulink_queue_reset(struct ulink
*device
, struct jtag_command
*cmd
)
1694 uint8_t low
= 0, high
= 0;
1696 if (cmd
->cmd
.reset
->trst
) {
1697 tap_set_state(TAP_RESET
);
1698 high
|= SIGNAL_TRST
;
1702 if (cmd
->cmd
.reset
->srst
)
1703 high
|= SIGNAL_RESET
;
1705 low
|= SIGNAL_RESET
;
1707 return ulink_append_set_signals_cmd(device
, low
, high
);
1711 * Move to one TAP state or several states in succession.
1713 * @param device pointer to struct ulink identifying ULINK driver instance.
1714 * @param cmd pointer to the command that shall be executed.
1715 * @return on success: ERROR_OK
1716 * @return on failure: ERROR_FAIL
1718 static int ulink_queue_pathmove(struct ulink
*device
, struct jtag_command
*cmd
)
1720 int ret
, i
, num_states
, batch_size
, state_count
;
1722 uint8_t tms_sequence
;
1724 num_states
= cmd
->cmd
.pathmove
->num_states
;
1725 path
= cmd
->cmd
.pathmove
->path
;
1728 while (num_states
> 0) {
1731 /* Determine batch size */
1732 if (num_states
>= 8)
1735 batch_size
= num_states
;
1737 for (i
= 0; i
< batch_size
; i
++) {
1738 if (tap_state_transition(tap_get_state(), false) == path
[state_count
]) {
1739 /* Append '0' transition: clear bit 'i' in tms_sequence */
1740 buf_set_u32(&tms_sequence
, i
, 1, 0x0);
1741 } else if (tap_state_transition(tap_get_state(), true)
1742 == path
[state_count
]) {
1743 /* Append '1' transition: set bit 'i' in tms_sequence */
1744 buf_set_u32(&tms_sequence
, i
, 1, 0x1);
1746 /* Invalid state transition */
1747 LOG_ERROR("BUG: %s -> %s isn't a valid TAP state transition",
1748 tap_state_name(tap_get_state()),
1749 tap_state_name(path
[state_count
]));
1753 tap_set_state(path
[state_count
]);
1758 /* Append CLOCK_TMS command to OpenULINK command queue */
1760 "pathmove batch: count = %i, sequence = 0x%x", batch_size
, tms_sequence
);
1761 ret
= ulink_append_clock_tms_cmd(ulink_handle
, batch_size
, tms_sequence
);
1762 if (ret
!= ERROR_OK
)
1770 * Sleep for a specific amount of time.
1772 * @param device pointer to struct ulink identifying ULINK driver instance.
1773 * @param cmd pointer to the command that shall be executed.
1774 * @return on success: ERROR_OK
1775 * @return on failure: ERROR_FAIL
1777 static int ulink_queue_sleep(struct ulink
*device
, struct jtag_command
*cmd
)
1779 /* IMPORTANT! Due to the time offset in command execution introduced by
1780 * command queueing, this needs to be implemented in the ULINK device */
1781 return ulink_append_sleep_cmd(device
, cmd
->cmd
.sleep
->us
);
1785 * Generate TCK cycles while remaining in a stable state.
1787 * @param device pointer to struct ulink identifying ULINK driver instance.
1788 * @param cmd pointer to the command that shall be executed.
1790 static int ulink_queue_stableclocks(struct ulink
*device
, struct jtag_command
*cmd
)
1793 unsigned num_cycles
;
1795 if (!tap_is_state_stable(tap_get_state())) {
1796 LOG_ERROR("JTAG_STABLECLOCKS: state not stable");
1800 num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
1802 /* TMS stays either high (Test Logic Reset state) or low (all other states) */
1803 if (tap_get_state() == TAP_RESET
)
1804 ret
= ulink_append_set_signals_cmd(device
, 0, SIGNAL_TMS
);
1806 ret
= ulink_append_set_signals_cmd(device
, SIGNAL_TMS
, 0);
1808 if (ret
!= ERROR_OK
)
1811 while (num_cycles
> 0) {
1812 if (num_cycles
> 0xFFFF) {
1813 /* OpenULINK CMD_CLOCK_TCK can generate up to 0xFFFF (uint16_t) cycles */
1814 ret
= ulink_append_clock_tck_cmd(device
, 0xFFFF);
1815 num_cycles
-= 0xFFFF;
1817 ret
= ulink_append_clock_tck_cmd(device
, num_cycles
);
1821 if (ret
!= ERROR_OK
)
1829 * Post-process JTAG_SCAN command
1831 * @param ulink_cmd pointer to OpenULINK command that shall be processed.
1832 * @return on success: ERROR_OK
1833 * @return on failure: ERROR_FAIL
1835 static int ulink_post_process_scan(struct ulink_cmd
*ulink_cmd
)
1837 struct jtag_command
*cmd
= ulink_cmd
->cmd_origin
;
1840 switch (jtag_scan_type(cmd
->cmd
.scan
)) {
1843 ret
= jtag_read_buffer(ulink_cmd
->payload_in_start
, cmd
->cmd
.scan
);
1846 /* Nothing to do for OUT scans */
1850 LOG_ERROR("BUG: ulink_post_process_scan() encountered an unknown"
1860 * Perform post-processing of commands after OpenULINK queue has been executed.
1862 * @param device pointer to struct ulink identifying ULINK driver instance.
1863 * @return on success: ERROR_OK
1864 * @return on failure: ERROR_FAIL
1866 static int ulink_post_process_queue(struct ulink
*device
)
1868 struct ulink_cmd
*current
;
1869 struct jtag_command
*openocd_cmd
;
1872 current
= device
->queue_start
;
1875 openocd_cmd
= current
->cmd_origin
;
1877 /* Check if a corresponding OpenOCD command is stored for this
1878 * OpenULINK command */
1879 if ((current
->needs_postprocessing
== true) && (openocd_cmd
)) {
1880 switch (openocd_cmd
->type
) {
1882 ret
= ulink_post_process_scan(current
);
1884 case JTAG_TLR_RESET
:
1889 case JTAG_STABLECLOCKS
:
1890 /* Nothing to do for these commands */
1895 LOG_ERROR("BUG: ulink_post_process_queue() encountered unknown JTAG "
1900 if (ret
!= ERROR_OK
)
1904 current
= current
->next
;
1910 /**************************** JTAG driver functions ***************************/
1913 * Executes the JTAG Command Queue.
1915 * This is done in three stages: First, all OpenOCD commands are processed into
1916 * queued OpenULINK commands. Next, the OpenULINK command queue is sent to the
1917 * ULINK device and data received from the ULINK device is cached. Finally,
1918 * the post-processing function writes back data to the corresponding OpenOCD
1921 * @return on success: ERROR_OK
1922 * @return on failure: ERROR_FAIL
1924 static int ulink_execute_queue(void)
1926 struct jtag_command
*cmd
= jtag_command_queue
;
1930 switch (cmd
->type
) {
1932 ret
= ulink_queue_scan(ulink_handle
, cmd
);
1934 case JTAG_TLR_RESET
:
1935 ret
= ulink_queue_tlr_reset(ulink_handle
, cmd
);
1938 ret
= ulink_queue_runtest(ulink_handle
, cmd
);
1941 ret
= ulink_queue_reset(ulink_handle
, cmd
);
1944 ret
= ulink_queue_pathmove(ulink_handle
, cmd
);
1947 ret
= ulink_queue_sleep(ulink_handle
, cmd
);
1949 case JTAG_STABLECLOCKS
:
1950 ret
= ulink_queue_stableclocks(ulink_handle
, cmd
);
1954 LOG_ERROR("BUG: encountered unknown JTAG command type");
1958 if (ret
!= ERROR_OK
)
1964 if (ulink_handle
->commands_in_queue
> 0) {
1965 ret
= ulink_execute_queued_commands(ulink_handle
, USB_TIMEOUT
);
1966 if (ret
!= ERROR_OK
)
1969 ret
= ulink_post_process_queue(ulink_handle
);
1970 if (ret
!= ERROR_OK
)
1973 ulink_clear_queue(ulink_handle
);
1980 * Set the TCK frequency of the ULINK adapter.
1982 * @param khz desired JTAG TCK frequency.
1983 * @param jtag_speed where to store corresponding adapter-specific speed value.
1984 * @return on success: ERROR_OK
1985 * @return on failure: ERROR_FAIL
1987 static int ulink_khz(int khz
, int *jtag_speed
)
1992 LOG_ERROR("RCLK not supported");
1996 /* CLOCK_TCK commands are decoupled from others. Therefore, the frequency
1997 * setting can be done independently from all other commands. */
1999 ulink_handle
->delay_clock_tck
= -1;
2001 ret
= ulink_calculate_delay(DELAY_CLOCK_TCK
, khz
* 1000,
2002 &ulink_handle
->delay_clock_tck
);
2003 if (ret
!= ERROR_OK
)
2007 /* SCAN_{IN,OUT,IO} commands invoke CLOCK_TMS commands. Therefore, if the
2008 * requested frequency goes below the maximum frequency for SLOW_CLOCK_TMS
2009 * commands, all SCAN commands MUST also use the variable frequency
2010 * implementation! */
2012 ulink_handle
->delay_clock_tms
= -1;
2013 ulink_handle
->delay_scan_in
= -1;
2014 ulink_handle
->delay_scan_out
= -1;
2015 ulink_handle
->delay_scan_io
= -1;
2017 ret
= ulink_calculate_delay(DELAY_CLOCK_TMS
, khz
* 1000,
2018 &ulink_handle
->delay_clock_tms
);
2019 if (ret
!= ERROR_OK
)
2022 ret
= ulink_calculate_delay(DELAY_SCAN_IN
, khz
* 1000,
2023 &ulink_handle
->delay_scan_in
);
2024 if (ret
!= ERROR_OK
)
2027 ret
= ulink_calculate_delay(DELAY_SCAN_OUT
, khz
* 1000,
2028 &ulink_handle
->delay_scan_out
);
2029 if (ret
!= ERROR_OK
)
2032 ret
= ulink_calculate_delay(DELAY_SCAN_IO
, khz
* 1000,
2033 &ulink_handle
->delay_scan_io
);
2034 if (ret
!= ERROR_OK
)
2038 LOG_DEBUG_IO("ULINK TCK setup: delay_tck = %i (%li Hz),",
2039 ulink_handle
->delay_clock_tck
,
2040 ulink_calculate_frequency(DELAY_CLOCK_TCK
, ulink_handle
->delay_clock_tck
));
2041 LOG_DEBUG_IO(" delay_tms = %i (%li Hz),",
2042 ulink_handle
->delay_clock_tms
,
2043 ulink_calculate_frequency(DELAY_CLOCK_TMS
, ulink_handle
->delay_clock_tms
));
2044 LOG_DEBUG_IO(" delay_scan_in = %i (%li Hz),",
2045 ulink_handle
->delay_scan_in
,
2046 ulink_calculate_frequency(DELAY_SCAN_IN
, ulink_handle
->delay_scan_in
));
2047 LOG_DEBUG_IO(" delay_scan_out = %i (%li Hz),",
2048 ulink_handle
->delay_scan_out
,
2049 ulink_calculate_frequency(DELAY_SCAN_OUT
, ulink_handle
->delay_scan_out
));
2050 LOG_DEBUG_IO(" delay_scan_io = %i (%li Hz),",
2051 ulink_handle
->delay_scan_io
,
2052 ulink_calculate_frequency(DELAY_SCAN_IO
, ulink_handle
->delay_scan_io
));
2054 /* Configure the ULINK device with the new delay values */
2055 ret
= ulink_append_configure_tck_cmd(ulink_handle
,
2056 ulink_handle
->delay_scan_in
,
2057 ulink_handle
->delay_scan_out
,
2058 ulink_handle
->delay_scan_io
,
2059 ulink_handle
->delay_clock_tck
,
2060 ulink_handle
->delay_clock_tms
);
2062 if (ret
!= ERROR_OK
)
2071 * Set the TCK frequency of the ULINK adapter.
2073 * Because of the way the TCK frequency is set up in the OpenULINK firmware,
2074 * there are five different speed settings. To simplify things, the
2075 * adapter-specific speed setting value is identical to the TCK frequency in
2078 * @param speed desired adapter-specific speed value.
2079 * @return on success: ERROR_OK
2080 * @return on failure: ERROR_FAIL
2082 static int ulink_speed(int speed
)
2086 return ulink_khz(speed
, &dummy
);
2090 * Convert adapter-specific speed value to corresponding TCK frequency in kHz.
2092 * Because of the way the TCK frequency is set up in the OpenULINK firmware,
2093 * there are five different speed settings. To simplify things, the
2094 * adapter-specific speed setting value is identical to the TCK frequency in
2097 * @param speed adapter-specific speed value.
2098 * @param khz where to store corresponding TCK frequency in kHz.
2099 * @return on success: ERROR_OK
2100 * @return on failure: ERROR_FAIL
2102 static int ulink_speed_div(int speed
, int *khz
)
2110 * Initiates the firmware download to the ULINK adapter and prepares
2113 * @return on success: ERROR_OK
2114 * @return on failure: ERROR_FAIL
2116 static int ulink_init(void)
2118 int ret
, transferred
;
2119 char str_manufacturer
[20];
2120 bool download_firmware
= false;
2121 unsigned char *dummy
;
2122 uint8_t input_signals
, output_signals
;
2124 ulink_handle
= calloc(1, sizeof(struct ulink
));
2128 libusb_init(&ulink_handle
->libusb_ctx
);
2130 ret
= ulink_usb_open(&ulink_handle
);
2131 if (ret
!= ERROR_OK
) {
2132 LOG_ERROR("Could not open ULINK device");
2134 ulink_handle
= NULL
;
2138 /* Get String Descriptor to determine if firmware needs to be loaded */
2139 ret
= libusb_get_string_descriptor_ascii(ulink_handle
->usb_device_handle
, 1, (unsigned char *)str_manufacturer
, 20);
2141 /* Could not get descriptor -> Unconfigured or original Keil firmware */
2142 download_firmware
= true;
2144 /* We got a String Descriptor, check if it is the correct one */
2145 if (strncmp(str_manufacturer
, "OpenULINK", 9) != 0)
2146 download_firmware
= true;
2149 if (download_firmware
== true) {
2150 LOG_INFO("Loading OpenULINK firmware. This is reversible by power-cycling"
2152 ret
= ulink_load_firmware_and_renumerate(&ulink_handle
,
2153 ULINK_FIRMWARE_FILE
, ULINK_RENUMERATION_DELAY
);
2154 if (ret
!= ERROR_OK
) {
2155 LOG_ERROR("Could not download firmware and re-numerate ULINK");
2157 ulink_handle
= NULL
;
2161 LOG_INFO("ULINK device is already running OpenULINK firmware");
2163 /* Get OpenULINK USB IN/OUT endpoints and claim the interface */
2164 ret
= jtag_libusb_choose_interface(ulink_handle
->usb_device_handle
,
2165 &ulink_handle
->ep_in
, &ulink_handle
->ep_out
, -1, -1, -1, -1);
2166 if (ret
!= ERROR_OK
)
2169 /* Initialize OpenULINK command queue */
2170 ulink_clear_queue(ulink_handle
);
2172 /* Issue one test command with short timeout */
2173 ret
= ulink_append_test_cmd(ulink_handle
);
2174 if (ret
!= ERROR_OK
)
2177 ret
= ulink_execute_queued_commands(ulink_handle
, 200);
2178 if (ret
!= ERROR_OK
) {
2179 /* Sending test command failed. The ULINK device may be forever waiting for
2180 * the host to fetch an USB Bulk IN packet (e. g. OpenOCD crashed or was
2181 * shut down by the user via Ctrl-C. Try to retrieve this Bulk IN packet. */
2182 dummy
= calloc(64, sizeof(uint8_t));
2184 ret
= libusb_bulk_transfer(ulink_handle
->usb_device_handle
, ulink_handle
->ep_in
,
2185 dummy
, 64, &transferred
, 200);
2189 if (ret
!= 0 || transferred
== 0) {
2190 /* Bulk IN transfer failed -> unrecoverable error condition */
2191 LOG_ERROR("Cannot communicate with ULINK device. Disconnect ULINK from "
2192 "the USB port and re-connect, then re-run OpenOCD");
2194 ulink_handle
= NULL
;
2197 #ifdef _DEBUG_USB_COMMS_
2199 /* Successfully received Bulk IN packet -> continue */
2200 LOG_INFO("Recovered from lost Bulk IN packet");
2204 ulink_clear_queue(ulink_handle
);
2206 ret
= ulink_append_get_signals_cmd(ulink_handle
);
2207 if (ret
== ERROR_OK
)
2208 ret
= ulink_execute_queued_commands(ulink_handle
, 200);
2210 if (ret
== ERROR_OK
) {
2211 /* Post-process the single CMD_GET_SIGNALS command */
2212 input_signals
= ulink_handle
->queue_start
->payload_in
[0];
2213 output_signals
= ulink_handle
->queue_start
->payload_in
[1];
2215 ulink_print_signal_states(input_signals
, output_signals
);
2218 ulink_clear_queue(ulink_handle
);
2224 * Closes the USB handle for the ULINK device.
2226 * @return on success: ERROR_OK
2227 * @return on failure: ERROR_FAIL
2229 static int ulink_quit(void)
2233 ret
= ulink_usb_close(&ulink_handle
);
2240 * Set a custom path to ULINK firmware image and force downloading to ULINK.
2242 COMMAND_HANDLER(ulink_download_firmware_handler
)
2247 return ERROR_COMMAND_SYNTAX_ERROR
;
2250 LOG_INFO("Downloading ULINK firmware image %s", CMD_ARGV
[0]);
2252 /* Download firmware image in CMD_ARGV[0] */
2253 ret
= ulink_load_firmware_and_renumerate(&ulink_handle
, CMD_ARGV
[0],
2254 ULINK_RENUMERATION_DELAY
);
2259 /*************************** Command Registration **************************/
2261 static const struct command_registration ulink_subcommand_handlers
[] = {
2263 .name
= "download_firmware",
2264 .handler
= &ulink_download_firmware_handler
,
2265 .mode
= COMMAND_EXEC
,
2266 .help
= "download firmware image to ULINK device",
2267 .usage
= "path/to/ulink_firmware.hex",
2269 COMMAND_REGISTRATION_DONE
,
2272 static const struct command_registration ulink_command_handlers
[] = {
2275 .mode
= COMMAND_ANY
,
2276 .help
= "perform ulink management",
2277 .chain
= ulink_subcommand_handlers
,
2280 COMMAND_REGISTRATION_DONE
2283 static struct jtag_interface ulink_interface
= {
2284 .execute_queue
= ulink_execute_queue
,
2287 struct adapter_driver ulink_adapter_driver
= {
2289 .transports
= jtag_only
,
2290 .commands
= ulink_command_handlers
,
2294 .speed
= ulink_speed
,
2296 .speed_div
= ulink_speed_div
,
2298 .jtag_ops
= &ulink_interface
,
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)