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 <jtag/interface.h>
25 #include <jtag/commands.h>
26 #include <target/image.h>
28 #include "libusb_helper.h"
29 #include "OpenULINK/include/msgtypes.h"
31 /** USB Vendor ID of ULINK device in unconfigured state (no firmware loaded
32 * yet) or with OpenULINK firmware. */
33 #define ULINK_VID 0xC251
35 /** USB Product ID of ULINK device in unconfigured state (no firmware loaded
36 * yet) or with OpenULINK firmware. */
37 #define ULINK_PID 0x2710
39 /** Address of EZ-USB CPU Control & Status register. This register can be
40 * written by issuing a Control EP0 vendor request. */
41 #define CPUCS_REG 0x7F92
43 /** USB Control EP0 bRequest: "Firmware Load". */
44 #define REQUEST_FIRMWARE_LOAD 0xA0
46 /** Value to write into CPUCS to put EZ-USB into reset. */
47 #define CPU_RESET 0x01
49 /** Value to write into CPUCS to put EZ-USB out of reset. */
50 #define CPU_START 0x00
52 /** Base address of firmware in EZ-USB code space. */
53 #define FIRMWARE_ADDR 0x0000
55 /** USB interface number */
56 #define USB_INTERFACE 0
58 /** libusb timeout in ms */
59 #define USB_TIMEOUT 5000
61 /** Delay (in microseconds) to wait while EZ-USB performs ReNumeration. */
62 #define ULINK_RENUMERATION_DELAY 1500000
64 /** Default location of OpenULINK firmware image. */
65 #define ULINK_FIRMWARE_FILE PKGDATADIR "/OpenULINK/ulink_firmware.hex"
67 /** Maximum size of a single firmware section. Entire EZ-USB code space = 8kB */
68 #define SECTION_BUFFERSIZE 8192
70 /** Tuning of OpenOCD SCAN commands split into multiple OpenULINK commands. */
71 #define SPLIT_SCAN_THRESHOLD 10
73 /** ULINK hardware type */
75 /** Original ULINK adapter, based on Cypress EZ-USB (AN2131):
76 * Full JTAG support, no SWD support. */
79 /** Newer ULINK adapter, based on NXP LPC2148. Currently unsupported. */
82 /** Newer ULINK adapter, based on EZ-USB FX2 + FPGA. Currently unsupported. */
85 /** Newer ULINK adapter, possibly based on ULINK 2. Currently unsupported. */
89 enum ulink_payload_direction
{
90 PAYLOAD_DIRECTION_OUT
,
94 enum ulink_delay_type
{
103 * OpenULINK command (OpenULINK command queue element).
105 * For the OUT direction payload, things are quite easy: Payload is stored
106 * in a rather small array (up to 63 bytes), the payload is always allocated
107 * by the function generating the command and freed by ulink_clear_queue().
109 * For the IN direction payload, things get a little bit more complicated:
110 * The maximum IN payload size for a single command is 64 bytes. Assume that
111 * a single OpenOCD command needs to scan 256 bytes. This results in the
112 * generation of four OpenULINK commands. The function generating these
113 * commands shall allocate an uint8_t[256] array. Each command's #payload_in
114 * pointer shall point to the corresponding offset where IN data shall be
115 * placed, while #payload_in_start shall point to the first element of the 256
117 * - first command: #payload_in_start + 0
118 * - second command: #payload_in_start + 64
119 * - third command: #payload_in_start + 128
120 * - fourth command: #payload_in_start + 192
122 * The last command sets #needs_postprocessing to true.
125 uint8_t id
; /**< ULINK command ID */
127 uint8_t *payload_out
; /**< OUT direction payload data */
128 uint8_t payload_out_size
; /**< OUT direction payload size for this command */
130 uint8_t *payload_in_start
; /**< Pointer to first element of IN payload array */
131 uint8_t *payload_in
; /**< Pointer where IN payload shall be stored */
132 uint8_t payload_in_size
; /**< IN direction payload size for this command */
134 /** Indicates if this command needs post-processing */
135 bool needs_postprocessing
;
137 /** Indicates if ulink_clear_queue() should free payload_in_start */
138 bool free_payload_in_start
;
140 /** Pointer to corresponding OpenOCD command for post-processing */
141 struct jtag_command
*cmd_origin
;
143 struct ulink_cmd
*next
; /**< Pointer to next command (linked list) */
146 /** Describes one driver instance */
148 struct libusb_context
*libusb_ctx
;
149 struct libusb_device_handle
*usb_device_handle
;
150 enum ulink_type type
;
152 unsigned int ep_in
; /**< IN endpoint number */
153 unsigned int ep_out
; /**< OUT endpoint number */
155 int delay_scan_in
; /**< Delay value for SCAN_IN commands */
156 int delay_scan_out
; /**< Delay value for SCAN_OUT commands */
157 int delay_scan_io
; /**< Delay value for SCAN_IO commands */
158 int delay_clock_tck
; /**< Delay value for CLOCK_TMS commands */
159 int delay_clock_tms
; /**< Delay value for CLOCK_TCK commands */
161 int commands_in_queue
; /**< Number of commands in queue */
162 struct ulink_cmd
*queue_start
; /**< Pointer to first command in queue */
163 struct ulink_cmd
*queue_end
; /**< Pointer to last command in queue */
166 /**************************** Function Prototypes *****************************/
168 /* USB helper functions */
169 static int ulink_usb_open(struct ulink
**device
);
170 static int ulink_usb_close(struct ulink
**device
);
172 /* ULINK MCU (Cypress EZ-USB) specific functions */
173 static int ulink_cpu_reset(struct ulink
*device
, unsigned char reset_bit
);
174 static int ulink_load_firmware_and_renumerate(struct ulink
**device
, const char *filename
,
176 static int ulink_load_firmware(struct ulink
*device
, const char *filename
);
177 static int ulink_write_firmware_section(struct ulink
*device
,
178 struct image
*firmware_image
, int section_index
);
180 /* Generic helper functions */
181 static void ulink_print_signal_states(uint8_t input_signals
, uint8_t output_signals
);
183 /* OpenULINK command generation helper functions */
184 static int ulink_allocate_payload(struct ulink_cmd
*ulink_cmd
, int size
,
185 enum ulink_payload_direction direction
);
187 /* OpenULINK command queue helper functions */
188 static int ulink_get_queue_size(struct ulink
*device
,
189 enum ulink_payload_direction direction
);
190 static void ulink_clear_queue(struct ulink
*device
);
191 static int ulink_append_queue(struct ulink
*device
, struct ulink_cmd
*ulink_cmd
);
192 static int ulink_execute_queued_commands(struct ulink
*device
, int timeout
);
194 static void ulink_print_queue(struct ulink
*device
);
196 static int ulink_append_scan_cmd(struct ulink
*device
,
197 enum scan_type scan_type
,
202 uint8_t tms_count_start
,
203 uint8_t tms_sequence_start
,
204 uint8_t tms_count_end
,
205 uint8_t tms_sequence_end
,
206 struct jtag_command
*origin
,
208 static int ulink_append_clock_tms_cmd(struct ulink
*device
, uint8_t count
,
210 static int ulink_append_clock_tck_cmd(struct ulink
*device
, uint16_t count
);
211 static int ulink_append_get_signals_cmd(struct ulink
*device
);
212 static int ulink_append_set_signals_cmd(struct ulink
*device
, uint8_t low
,
214 static int ulink_append_sleep_cmd(struct ulink
*device
, uint32_t us
);
215 static int ulink_append_configure_tck_cmd(struct ulink
*device
,
221 static int __attribute__((unused
)) ulink_append_led_cmd(struct ulink
*device
, uint8_t led_state
);
222 static int ulink_append_test_cmd(struct ulink
*device
);
224 /* OpenULINK TCK frequency helper functions */
225 static int ulink_calculate_delay(enum ulink_delay_type type
, long f
, int *delay
);
227 /* Interface between OpenULINK and OpenOCD */
228 static void ulink_set_end_state(tap_state_t endstate
);
229 static int ulink_queue_statemove(struct ulink
*device
);
231 static int ulink_queue_scan(struct ulink
*device
, struct jtag_command
*cmd
);
232 static int ulink_queue_tlr_reset(struct ulink
*device
, struct jtag_command
*cmd
);
233 static int ulink_queue_runtest(struct ulink
*device
, struct jtag_command
*cmd
);
234 static int ulink_queue_reset(struct ulink
*device
, struct jtag_command
*cmd
);
235 static int ulink_queue_pathmove(struct ulink
*device
, struct jtag_command
*cmd
);
236 static int ulink_queue_sleep(struct ulink
*device
, struct jtag_command
*cmd
);
237 static int ulink_queue_stableclocks(struct ulink
*device
, struct jtag_command
*cmd
);
239 static int ulink_post_process_scan(struct ulink_cmd
*ulink_cmd
);
240 static int ulink_post_process_queue(struct ulink
*device
);
242 /* adapter driver functions */
243 static int ulink_execute_queue(void);
244 static int ulink_khz(int khz
, int *jtag_speed
);
245 static int ulink_speed(int speed
);
246 static int ulink_speed_div(int speed
, int *khz
);
247 static int ulink_init(void);
248 static int ulink_quit(void);
250 /****************************** Global Variables ******************************/
252 static struct ulink
*ulink_handle
;
254 /**************************** USB helper functions ****************************/
257 * Opens the ULINK device
259 * Currently, only the original ULINK is supported
261 * @param device pointer to struct ulink identifying ULINK driver instance.
262 * @return on success: ERROR_OK
263 * @return on failure: ERROR_FAIL
265 static int ulink_usb_open(struct ulink
**device
)
267 ssize_t num_devices
, i
;
269 libusb_device
**usb_devices
;
270 struct libusb_device_descriptor usb_desc
;
271 struct libusb_device_handle
*usb_device_handle
;
273 num_devices
= libusb_get_device_list((*device
)->libusb_ctx
, &usb_devices
);
275 if (num_devices
<= 0)
279 for (i
= 0; i
< num_devices
; i
++) {
280 if (libusb_get_device_descriptor(usb_devices
[i
], &usb_desc
) != 0)
282 else if (usb_desc
.idVendor
== ULINK_VID
&& usb_desc
.idProduct
== ULINK_PID
) {
291 if (libusb_open(usb_devices
[i
], &usb_device_handle
) != 0)
293 libusb_free_device_list(usb_devices
, 1);
295 (*device
)->usb_device_handle
= usb_device_handle
;
296 (*device
)->type
= ULINK_1
;
302 * Releases the ULINK interface and closes the USB device handle.
304 * @param device pointer to struct ulink identifying ULINK driver instance.
305 * @return on success: ERROR_OK
306 * @return on failure: ERROR_FAIL
308 static int ulink_usb_close(struct ulink
**device
)
310 if (libusb_release_interface((*device
)->usb_device_handle
, 0) != 0)
313 libusb_close((*device
)->usb_device_handle
);
315 (*device
)->usb_device_handle
= NULL
;
320 /******************* ULINK CPU (EZ-USB) specific functions ********************/
323 * Writes '0' or '1' to the CPUCS register, putting the EZ-USB CPU into reset
326 * @param device pointer to struct ulink identifying ULINK driver instance.
327 * @param reset_bit 0 to put CPU into reset, 1 to put CPU out of reset.
328 * @return on success: ERROR_OK
329 * @return on failure: ERROR_FAIL
331 static int ulink_cpu_reset(struct ulink
*device
, unsigned char reset_bit
)
335 ret
= libusb_control_transfer(device
->usb_device_handle
,
336 (LIBUSB_ENDPOINT_OUT
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
),
337 REQUEST_FIRMWARE_LOAD
, CPUCS_REG
, 0, &reset_bit
, 1, USB_TIMEOUT
);
339 /* usb_control_msg() returns the number of bytes transferred during the
340 * DATA stage of the control transfer - must be exactly 1 in this case! */
347 * Puts the ULINK's EZ-USB microcontroller into reset state, downloads
348 * the firmware image, resumes the microcontroller and re-enumerates
351 * @param device pointer to struct ulink identifying ULINK driver instance.
352 * The usb_handle member will be modified during re-enumeration.
353 * @param filename path to the Intel HEX file containing the firmware image.
354 * @param delay the delay to wait for the device to re-enumerate.
355 * @return on success: ERROR_OK
356 * @return on failure: ERROR_FAIL
358 static int ulink_load_firmware_and_renumerate(struct ulink
**device
,
359 const char *filename
, uint32_t delay
)
363 /* Basic process: After downloading the firmware, the ULINK will disconnect
364 * itself and re-connect after a short amount of time so we have to close
365 * the handle and re-enumerate USB devices */
367 ret
= ulink_load_firmware(*device
, filename
);
371 ret
= ulink_usb_close(device
);
377 ret
= ulink_usb_open(device
);
385 * Downloads a firmware image to the ULINK's EZ-USB microcontroller
388 * @param device pointer to struct ulink identifying ULINK driver instance.
389 * @param filename an absolute or relative path to the Intel HEX file
390 * containing the firmware image.
391 * @return on success: ERROR_OK
392 * @return on failure: ERROR_FAIL
394 static int ulink_load_firmware(struct ulink
*device
, const char *filename
)
396 struct image ulink_firmware_image
;
399 ret
= ulink_cpu_reset(device
, CPU_RESET
);
400 if (ret
!= ERROR_OK
) {
401 LOG_ERROR("Could not halt ULINK CPU");
405 ulink_firmware_image
.base_address
= 0;
406 ulink_firmware_image
.base_address_set
= false;
408 ret
= image_open(&ulink_firmware_image
, filename
, "ihex");
409 if (ret
!= ERROR_OK
) {
410 LOG_ERROR("Could not load firmware image");
414 /* Download all sections in the image to ULINK */
415 for (unsigned int i
= 0; i
< ulink_firmware_image
.num_sections
; i
++) {
416 ret
= ulink_write_firmware_section(device
, &ulink_firmware_image
, i
);
421 image_close(&ulink_firmware_image
);
423 ret
= ulink_cpu_reset(device
, CPU_START
);
424 if (ret
!= ERROR_OK
) {
425 LOG_ERROR("Could not restart ULINK CPU");
433 * Send one contiguous firmware section to the ULINK's EZ-USB microcontroller
436 * @param device pointer to struct ulink identifying ULINK driver instance.
437 * @param firmware_image pointer to the firmware image that contains the section
438 * which should be sent to the ULINK's EZ-USB microcontroller.
439 * @param section_index index of the section within the firmware image.
440 * @return on success: ERROR_OK
441 * @return on failure: ERROR_FAIL
443 static int ulink_write_firmware_section(struct ulink
*device
,
444 struct image
*firmware_image
, int section_index
)
446 uint16_t addr
, size
, bytes_remaining
, chunk_size
;
447 uint8_t data
[SECTION_BUFFERSIZE
];
448 uint8_t *data_ptr
= data
;
452 size
= (uint16_t)firmware_image
->sections
[section_index
].size
;
453 addr
= (uint16_t)firmware_image
->sections
[section_index
].base_address
;
455 LOG_DEBUG("section %02i at addr 0x%04x (size 0x%04x)", section_index
, addr
,
458 /* Copy section contents to local buffer */
459 ret
= image_read_section(firmware_image
, section_index
, 0, size
, data
,
462 if ((ret
!= ERROR_OK
) || (size_read
!= size
)) {
463 /* Propagating the return code would return '0' (misleadingly indicating
464 * successful execution of the function) if only the size check fails. */
468 bytes_remaining
= size
;
470 /* Send section data in chunks of up to 64 bytes to ULINK */
471 while (bytes_remaining
> 0) {
472 if (bytes_remaining
> 64)
475 chunk_size
= bytes_remaining
;
477 ret
= libusb_control_transfer(device
->usb_device_handle
,
478 (LIBUSB_ENDPOINT_OUT
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
),
479 REQUEST_FIRMWARE_LOAD
, addr
, FIRMWARE_ADDR
, (unsigned char *)data_ptr
,
480 chunk_size
, USB_TIMEOUT
);
482 if (ret
!= (int)chunk_size
) {
483 /* Abort if libusb sent less data than requested */
487 bytes_remaining
-= chunk_size
;
489 data_ptr
+= chunk_size
;
495 /************************** Generic helper functions **************************/
498 * Print state of interesting signals via LOG_INFO().
500 * @param input_signals input signal states as returned by CMD_GET_SIGNALS
501 * @param output_signals output signal states as returned by CMD_GET_SIGNALS
503 static void ulink_print_signal_states(uint8_t input_signals
, uint8_t output_signals
)
505 LOG_INFO("ULINK signal states: TDI: %i, TDO: %i, TMS: %i, TCK: %i, TRST: %i,"
507 (output_signals
& SIGNAL_TDI
? 1 : 0),
508 (input_signals
& SIGNAL_TDO
? 1 : 0),
509 (output_signals
& SIGNAL_TMS
? 1 : 0),
510 (output_signals
& SIGNAL_TCK
? 1 : 0),
511 (output_signals
& SIGNAL_TRST
? 0 : 1), /* Inverted by hardware */
512 (output_signals
& SIGNAL_RESET
? 0 : 1)); /* Inverted by hardware */
515 /**************** OpenULINK command generation helper functions ***************/
518 * Allocate and initialize space in memory for OpenULINK command payload.
520 * @param ulink_cmd pointer to command whose payload should be allocated.
521 * @param size the amount of memory to allocate (bytes).
522 * @param direction which payload to allocate.
523 * @return on success: ERROR_OK
524 * @return on failure: ERROR_FAIL
526 static int ulink_allocate_payload(struct ulink_cmd
*ulink_cmd
, int size
,
527 enum ulink_payload_direction direction
)
531 payload
= calloc(size
, sizeof(uint8_t));
533 if (payload
== NULL
) {
534 LOG_ERROR("Could not allocate OpenULINK command payload: out of memory");
539 case PAYLOAD_DIRECTION_OUT
:
540 if (ulink_cmd
->payload_out
!= NULL
) {
541 LOG_ERROR("BUG: Duplicate payload allocation for OpenULINK command");
545 ulink_cmd
->payload_out
= payload
;
546 ulink_cmd
->payload_out_size
= size
;
549 case PAYLOAD_DIRECTION_IN
:
550 if (ulink_cmd
->payload_in_start
!= NULL
) {
551 LOG_ERROR("BUG: Duplicate payload allocation for OpenULINK command");
555 ulink_cmd
->payload_in_start
= payload
;
556 ulink_cmd
->payload_in
= payload
;
557 ulink_cmd
->payload_in_size
= size
;
559 /* By default, free payload_in_start in ulink_clear_queue(). Commands
560 * that do not want this behavior (e. g. split scans) must turn it off
562 ulink_cmd
->free_payload_in_start
= true;
570 /****************** OpenULINK command queue helper functions ******************/
573 * Get the current number of bytes in the queue, including command IDs.
575 * @param device pointer to struct ulink identifying ULINK driver instance.
576 * @param direction the transfer direction for which to get byte count.
577 * @return the number of bytes currently stored in the queue for the specified
580 static int ulink_get_queue_size(struct ulink
*device
,
581 enum ulink_payload_direction direction
)
583 struct ulink_cmd
*current
= device
->queue_start
;
586 while (current
!= NULL
) {
588 case PAYLOAD_DIRECTION_OUT
:
589 sum
+= current
->payload_out_size
+ 1; /* + 1 byte for Command ID */
591 case PAYLOAD_DIRECTION_IN
:
592 sum
+= current
->payload_in_size
;
596 current
= current
->next
;
603 * Clear the OpenULINK command queue.
605 * @param device pointer to struct ulink identifying ULINK driver instance.
606 * @return on success: ERROR_OK
607 * @return on failure: ERROR_FAIL
609 static void ulink_clear_queue(struct ulink
*device
)
611 struct ulink_cmd
*current
= device
->queue_start
;
612 struct ulink_cmd
*next
= NULL
;
614 while (current
!= NULL
) {
615 /* Save pointer to next element */
616 next
= current
->next
;
618 /* Free payloads: OUT payload can be freed immediately */
619 free(current
->payload_out
);
620 current
->payload_out
= NULL
;
622 /* IN payload MUST be freed ONLY if no other commands use the
623 * payload_in_start buffer */
624 if (current
->free_payload_in_start
== true) {
625 free(current
->payload_in_start
);
626 current
->payload_in_start
= NULL
;
627 current
->payload_in
= NULL
;
630 /* Free queue element */
633 /* Proceed with next element */
637 device
->commands_in_queue
= 0;
638 device
->queue_start
= NULL
;
639 device
->queue_end
= NULL
;
643 * Add a command to the OpenULINK command queue.
645 * @param device pointer to struct ulink identifying ULINK driver instance.
646 * @param ulink_cmd pointer to command that shall be appended to the OpenULINK
648 * @return on success: ERROR_OK
649 * @return on failure: ERROR_FAIL
651 static int ulink_append_queue(struct ulink
*device
, struct ulink_cmd
*ulink_cmd
)
653 int newsize_out
, newsize_in
;
656 newsize_out
= ulink_get_queue_size(device
, PAYLOAD_DIRECTION_OUT
) + 1
657 + ulink_cmd
->payload_out_size
;
659 newsize_in
= ulink_get_queue_size(device
, PAYLOAD_DIRECTION_IN
)
660 + ulink_cmd
->payload_in_size
;
662 /* Check if the current command can be appended to the queue */
663 if ((newsize_out
> 64) || (newsize_in
> 64)) {
664 /* New command does not fit. Execute all commands in queue before starting
665 * new queue with the current command as first entry. */
666 ret
= ulink_execute_queued_commands(device
, USB_TIMEOUT
);
669 ret
= ulink_post_process_queue(device
);
672 ulink_clear_queue(device
);
675 if (device
->queue_start
== NULL
) {
676 /* Queue was empty */
677 device
->commands_in_queue
= 1;
679 device
->queue_start
= ulink_cmd
;
680 device
->queue_end
= ulink_cmd
;
682 /* There are already commands in the queue */
683 device
->commands_in_queue
++;
685 device
->queue_end
->next
= ulink_cmd
;
686 device
->queue_end
= ulink_cmd
;
690 ulink_clear_queue(device
);
696 * Sends all queued OpenULINK commands to the ULINK for execution.
698 * @param device pointer to struct ulink identifying ULINK driver instance.
700 * @return on success: ERROR_OK
701 * @return on failure: ERROR_FAIL
703 static int ulink_execute_queued_commands(struct ulink
*device
, int timeout
)
705 struct ulink_cmd
*current
;
706 int ret
, i
, index_out
, index_in
, count_out
, count_in
, transferred
;
709 if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO
))
710 ulink_print_queue(device
);
716 for (current
= device
->queue_start
; current
; current
= current
->next
) {
717 /* Add command to packet */
718 buffer
[index_out
] = current
->id
;
722 for (i
= 0; i
< current
->payload_out_size
; i
++)
723 buffer
[index_out
+ i
] = current
->payload_out
[i
];
724 index_out
+= current
->payload_out_size
;
725 count_in
+= current
->payload_in_size
;
726 count_out
+= current
->payload_out_size
;
729 /* Send packet to ULINK */
730 ret
= libusb_bulk_transfer(device
->usb_device_handle
, device
->ep_out
,
731 (unsigned char *)buffer
, count_out
, &transferred
, timeout
);
734 if (transferred
!= count_out
)
737 /* Wait for response if commands contain IN payload data */
739 ret
= libusb_bulk_transfer(device
->usb_device_handle
, device
->ep_in
,
740 (unsigned char *)buffer
, 64, &transferred
, timeout
);
743 if (transferred
!= count_in
)
746 /* Write back IN payload data */
748 for (current
= device
->queue_start
; current
; current
= current
->next
) {
749 for (i
= 0; i
< current
->payload_in_size
; i
++) {
750 current
->payload_in
[i
] = buffer
[index_in
];
760 * Convert an OpenULINK command ID (\a id) to a human-readable string.
762 * @param id the OpenULINK command ID.
763 * @return the corresponding human-readable string.
765 static const char *ulink_cmd_id_string(uint8_t id
)
769 return "CMD_SCAN_IN";
770 case CMD_SLOW_SCAN_IN
:
771 return "CMD_SLOW_SCAN_IN";
773 return "CMD_SCAN_OUT";
774 case CMD_SLOW_SCAN_OUT
:
775 return "CMD_SLOW_SCAN_OUT";
777 return "CMD_SCAN_IO";
778 case CMD_SLOW_SCAN_IO
:
779 return "CMD_SLOW_SCAN_IO";
781 return "CMD_CLOCK_TMS";
782 case CMD_SLOW_CLOCK_TMS
:
783 return "CMD_SLOW_CLOCK_TMS";
785 return "CMD_CLOCK_TCK";
786 case CMD_SLOW_CLOCK_TCK
:
787 return "CMD_SLOW_CLOCK_TCK";
789 return "CMD_SLEEP_US";
791 return "CMD_SLEEP_MS";
792 case CMD_GET_SIGNALS
:
793 return "CMD_GET_SIGNALS";
794 case CMD_SET_SIGNALS
:
795 return "CMD_SET_SIGNALS";
796 case CMD_CONFIGURE_TCK_FREQ
:
797 return "CMD_CONFIGURE_TCK_FREQ";
799 return "CMD_SET_LEDS";
803 return "CMD_UNKNOWN";
808 * Print one OpenULINK command to stdout.
810 * @param ulink_cmd pointer to OpenULINK command.
812 static void ulink_print_command(struct ulink_cmd
*ulink_cmd
)
816 printf(" %-22s | OUT size = %i, bytes = 0x",
817 ulink_cmd_id_string(ulink_cmd
->id
), ulink_cmd
->payload_out_size
);
819 for (i
= 0; i
< ulink_cmd
->payload_out_size
; i
++)
820 printf("%02X ", ulink_cmd
->payload_out
[i
]);
821 printf("\n | IN size = %i\n",
822 ulink_cmd
->payload_in_size
);
826 * Print the OpenULINK command queue to stdout.
828 * @param device pointer to struct ulink identifying ULINK driver instance.
830 static void ulink_print_queue(struct ulink
*device
)
832 struct ulink_cmd
*current
;
834 printf("OpenULINK command queue:\n");
836 for (current
= device
->queue_start
; current
; current
= current
->next
)
837 ulink_print_command(current
);
843 * Creates and appends a JTAG scan command to the OpenULINK command queue.
844 * A JTAG scan consists of three steps:
845 * - Move to the desired SHIFT state, depending on scan type (IR/DR scan).
846 * - Shift TDI data into the JTAG chain, optionally reading the TDO pin.
847 * - Move to the desired end state.
849 * @param device pointer to struct ulink identifying ULINK driver instance.
850 * @param scan_type the type of the scan (IN, OUT, IO (bidirectional)).
851 * @param scan_size_bits number of bits to shift into the JTAG chain.
852 * @param tdi pointer to array containing TDI data.
853 * @param tdo_start pointer to first element of array where TDO data shall be
854 * stored. See #ulink_cmd for details.
855 * @param tdo pointer to array where TDO data shall be stored
856 * @param tms_count_start number of TMS state transitions to perform BEFORE
857 * shifting data into the JTAG chain.
858 * @param tms_sequence_start sequence of TMS state transitions that will be
859 * performed BEFORE shifting data into the JTAG chain.
860 * @param tms_count_end number of TMS state transitions to perform AFTER
861 * shifting data into the JTAG chain.
862 * @param tms_sequence_end sequence of TMS state transitions that will be
863 * performed AFTER shifting data into the JTAG chain.
864 * @param origin pointer to OpenOCD command that generated this scan command.
865 * @param postprocess whether this command needs to be post-processed after
867 * @return on success: ERROR_OK
868 * @return on failure: ERROR_FAIL
870 static int ulink_append_scan_cmd(struct ulink
*device
, enum scan_type scan_type
,
871 int scan_size_bits
, uint8_t *tdi
, uint8_t *tdo_start
, uint8_t *tdo
,
872 uint8_t tms_count_start
, uint8_t tms_sequence_start
, uint8_t tms_count_end
,
873 uint8_t tms_sequence_end
, struct jtag_command
*origin
, bool postprocess
)
875 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
876 int ret
, i
, scan_size_bytes
;
877 uint8_t bits_last_byte
;
882 /* Check size of command. USB buffer can hold 64 bytes, 1 byte is command ID,
883 * 5 bytes are setup data -> 58 remaining payload bytes for TDI data */
884 if (scan_size_bits
> (58 * 8)) {
885 LOG_ERROR("BUG: Tried to create CMD_SCAN_IO OpenULINK command with too"
891 scan_size_bytes
= DIV_ROUND_UP(scan_size_bits
, 8);
893 bits_last_byte
= scan_size_bits
% 8;
894 if (bits_last_byte
== 0)
897 /* Allocate out_payload depending on scan type */
900 if (device
->delay_scan_in
< 0)
901 cmd
->id
= CMD_SCAN_IN
;
903 cmd
->id
= CMD_SLOW_SCAN_IN
;
904 ret
= ulink_allocate_payload(cmd
, 5, PAYLOAD_DIRECTION_OUT
);
907 if (device
->delay_scan_out
< 0)
908 cmd
->id
= CMD_SCAN_OUT
;
910 cmd
->id
= CMD_SLOW_SCAN_OUT
;
911 ret
= ulink_allocate_payload(cmd
, scan_size_bytes
+ 5, PAYLOAD_DIRECTION_OUT
);
914 if (device
->delay_scan_io
< 0)
915 cmd
->id
= CMD_SCAN_IO
;
917 cmd
->id
= CMD_SLOW_SCAN_IO
;
918 ret
= ulink_allocate_payload(cmd
, scan_size_bytes
+ 5, PAYLOAD_DIRECTION_OUT
);
921 LOG_ERROR("BUG: ulink_append_scan_cmd() encountered an unknown scan type");
926 if (ret
!= ERROR_OK
) {
931 /* Build payload_out that is common to all scan types */
932 cmd
->payload_out
[0] = scan_size_bytes
& 0xFF;
933 cmd
->payload_out
[1] = bits_last_byte
& 0xFF;
934 cmd
->payload_out
[2] = ((tms_count_start
& 0x0F) << 4) | (tms_count_end
& 0x0F);
935 cmd
->payload_out
[3] = tms_sequence_start
;
936 cmd
->payload_out
[4] = tms_sequence_end
;
938 /* Setup payload_out for types with OUT transfer */
939 if ((scan_type
== SCAN_OUT
) || (scan_type
== SCAN_IO
)) {
940 for (i
= 0; i
< scan_size_bytes
; i
++)
941 cmd
->payload_out
[i
+ 5] = tdi
[i
];
944 /* Setup payload_in pointers for types with IN transfer */
945 if ((scan_type
== SCAN_IN
) || (scan_type
== SCAN_IO
)) {
946 cmd
->payload_in_start
= tdo_start
;
947 cmd
->payload_in
= tdo
;
948 cmd
->payload_in_size
= scan_size_bytes
;
951 cmd
->needs_postprocessing
= postprocess
;
952 cmd
->cmd_origin
= origin
;
954 /* For scan commands, we free payload_in_start only when the command is
955 * the last in a series of split commands or a stand-alone command */
956 cmd
->free_payload_in_start
= postprocess
;
958 return ulink_append_queue(device
, cmd
);
962 * Perform TAP state transitions
964 * @param device pointer to struct ulink identifying ULINK driver instance.
965 * @param count defines the number of TCK clock cycles generated (up to 8).
966 * @param sequence defines the TMS pin levels for each state transition. The
967 * Least-Significant Bit is read first.
968 * @return on success: ERROR_OK
969 * @return on failure: ERROR_FAIL
971 static int ulink_append_clock_tms_cmd(struct ulink
*device
, uint8_t count
,
974 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
980 if (device
->delay_clock_tms
< 0)
981 cmd
->id
= CMD_CLOCK_TMS
;
983 cmd
->id
= CMD_SLOW_CLOCK_TMS
;
985 /* CMD_CLOCK_TMS has two OUT payload bytes and zero IN payload bytes */
986 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
987 if (ret
!= ERROR_OK
) {
992 cmd
->payload_out
[0] = count
;
993 cmd
->payload_out
[1] = sequence
;
995 return ulink_append_queue(device
, cmd
);
999 * Generate a defined amount of TCK clock cycles
1001 * All other JTAG signals are left unchanged.
1003 * @param device pointer to struct ulink identifying ULINK driver instance.
1004 * @param count the number of TCK clock cycles to generate.
1005 * @return on success: ERROR_OK
1006 * @return on failure: ERROR_FAIL
1008 static int ulink_append_clock_tck_cmd(struct ulink
*device
, uint16_t count
)
1010 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1016 if (device
->delay_clock_tck
< 0)
1017 cmd
->id
= CMD_CLOCK_TCK
;
1019 cmd
->id
= CMD_SLOW_CLOCK_TCK
;
1021 /* CMD_CLOCK_TCK has two OUT payload bytes and zero IN payload bytes */
1022 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
1023 if (ret
!= ERROR_OK
) {
1028 cmd
->payload_out
[0] = count
& 0xff;
1029 cmd
->payload_out
[1] = (count
>> 8) & 0xff;
1031 return ulink_append_queue(device
, cmd
);
1035 * Read JTAG signals.
1037 * @param device pointer to struct ulink identifying ULINK driver instance.
1038 * @return on success: ERROR_OK
1039 * @return on failure: ERROR_FAIL
1041 static int ulink_append_get_signals_cmd(struct ulink
*device
)
1043 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1049 cmd
->id
= CMD_GET_SIGNALS
;
1050 cmd
->needs_postprocessing
= true;
1052 /* CMD_GET_SIGNALS has two IN payload bytes */
1053 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_IN
);
1055 if (ret
!= ERROR_OK
) {
1060 return ulink_append_queue(device
, cmd
);
1064 * Arbitrarily set JTAG output signals.
1066 * @param device pointer to struct ulink identifying ULINK driver instance.
1067 * @param low defines which signals will be de-asserted. Each bit corresponds
1076 * @param high defines which signals will be asserted.
1077 * @return on success: ERROR_OK
1078 * @return on failure: ERROR_FAIL
1080 static int ulink_append_set_signals_cmd(struct ulink
*device
, uint8_t low
,
1083 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1089 cmd
->id
= CMD_SET_SIGNALS
;
1091 /* CMD_SET_SIGNALS has two OUT payload bytes and zero IN payload bytes */
1092 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
1094 if (ret
!= ERROR_OK
) {
1099 cmd
->payload_out
[0] = low
;
1100 cmd
->payload_out
[1] = high
;
1102 return ulink_append_queue(device
, cmd
);
1106 * Sleep for a pre-defined number of microseconds
1108 * @param device pointer to struct ulink identifying ULINK driver instance.
1109 * @param us the number microseconds to sleep.
1110 * @return on success: ERROR_OK
1111 * @return on failure: ERROR_FAIL
1113 static int ulink_append_sleep_cmd(struct ulink
*device
, uint32_t us
)
1115 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1121 cmd
->id
= CMD_SLEEP_US
;
1123 /* CMD_SLEEP_US has two OUT payload bytes and zero IN payload bytes */
1124 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
1126 if (ret
!= ERROR_OK
) {
1131 cmd
->payload_out
[0] = us
& 0x00ff;
1132 cmd
->payload_out
[1] = (us
>> 8) & 0x00ff;
1134 return ulink_append_queue(device
, cmd
);
1138 * Set TCK delay counters
1140 * @param device pointer to struct ulink identifying ULINK driver instance.
1141 * @param delay_scan_in delay count top value in jtag_slow_scan_in() function.
1142 * @param delay_scan_out delay count top value in jtag_slow_scan_out() function.
1143 * @param delay_scan_io delay count top value in jtag_slow_scan_io() function.
1144 * @param delay_tck delay count top value in jtag_clock_tck() function.
1145 * @param delay_tms delay count top value in jtag_slow_clock_tms() function.
1146 * @return on success: ERROR_OK
1147 * @return on failure: ERROR_FAIL
1149 static int ulink_append_configure_tck_cmd(struct ulink
*device
, int delay_scan_in
,
1150 int delay_scan_out
, int delay_scan_io
, int delay_tck
, int delay_tms
)
1152 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1158 cmd
->id
= CMD_CONFIGURE_TCK_FREQ
;
1160 /* CMD_CONFIGURE_TCK_FREQ has five OUT payload bytes and zero
1161 * IN payload bytes */
1162 ret
= ulink_allocate_payload(cmd
, 5, PAYLOAD_DIRECTION_OUT
);
1163 if (ret
!= ERROR_OK
) {
1168 if (delay_scan_in
< 0)
1169 cmd
->payload_out
[0] = 0;
1171 cmd
->payload_out
[0] = (uint8_t)delay_scan_in
;
1173 if (delay_scan_out
< 0)
1174 cmd
->payload_out
[1] = 0;
1176 cmd
->payload_out
[1] = (uint8_t)delay_scan_out
;
1178 if (delay_scan_io
< 0)
1179 cmd
->payload_out
[2] = 0;
1181 cmd
->payload_out
[2] = (uint8_t)delay_scan_io
;
1184 cmd
->payload_out
[3] = 0;
1186 cmd
->payload_out
[3] = (uint8_t)delay_tck
;
1189 cmd
->payload_out
[4] = 0;
1191 cmd
->payload_out
[4] = (uint8_t)delay_tms
;
1193 return ulink_append_queue(device
, cmd
);
1197 * Turn on/off ULINK LEDs.
1199 * @param device pointer to struct ulink identifying ULINK driver instance.
1200 * @param led_state which LED(s) to turn on or off. The following bits
1201 * influence the LEDS:
1202 * - Bit 0: Turn COM LED on
1203 * - Bit 1: Turn RUN LED on
1204 * - Bit 2: Turn COM LED off
1205 * - Bit 3: Turn RUN LED off
1206 * If both the on-bit and the off-bit for the same LED is set, the LED is
1208 * @return on success: ERROR_OK
1209 * @return on failure: ERROR_FAIL
1211 static int ulink_append_led_cmd(struct ulink
*device
, uint8_t led_state
)
1213 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1219 cmd
->id
= CMD_SET_LEDS
;
1221 /* CMD_SET_LEDS has one OUT payload byte and zero IN payload bytes */
1222 ret
= ulink_allocate_payload(cmd
, 1, PAYLOAD_DIRECTION_OUT
);
1223 if (ret
!= ERROR_OK
) {
1228 cmd
->payload_out
[0] = led_state
;
1230 return ulink_append_queue(device
, cmd
);
1234 * Test command. Used to check if the ULINK device is ready to accept new
1237 * @param device pointer to struct ulink identifying ULINK driver instance.
1238 * @return on success: ERROR_OK
1239 * @return on failure: ERROR_FAIL
1241 static int ulink_append_test_cmd(struct ulink
*device
)
1243 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1251 /* CMD_TEST has one OUT payload byte and zero IN payload bytes */
1252 ret
= ulink_allocate_payload(cmd
, 1, PAYLOAD_DIRECTION_OUT
);
1253 if (ret
!= ERROR_OK
) {
1258 cmd
->payload_out
[0] = 0xAA;
1260 return ulink_append_queue(device
, cmd
);
1263 /****************** OpenULINK TCK frequency helper functions ******************/
1266 * Calculate delay values for a given TCK frequency.
1268 * The OpenULINK firmware uses five different speed values for different
1269 * commands. These speed values are calculated in these functions.
1271 * The five different commands which support variable TCK frequency are
1272 * implemented twice in the firmware:
1273 * 1. Maximum possible frequency without any artificial delay
1274 * 2. Variable frequency with artificial linear delay loop
1276 * To set the ULINK to maximum frequency, it is only necessary to use the
1277 * corresponding command IDs. To set the ULINK to a lower frequency, the
1278 * delay loop top values have to be calculated first. Then, a
1279 * CMD_CONFIGURE_TCK_FREQ command needs to be sent to the ULINK device.
1281 * The delay values are described by linear equations:
1283 * (t = period, k = constant, x = delay value, d = constant)
1285 * Thus, the delay can be calculated as in the following equation:
1288 * The constants in these equations have been determined and validated by
1289 * measuring the frequency resulting from different delay values.
1291 * @param type for which command to calculate the delay value.
1292 * @param f TCK frequency for which to calculate the delay value in Hz.
1293 * @param delay where to store resulting delay value.
1294 * @return on success: ERROR_OK
1295 * @return on failure: ERROR_FAIL
1297 static int ulink_calculate_delay(enum ulink_delay_type type
, long f
, int *delay
)
1301 /* Calculate period of requested TCK frequency */
1302 t
= 1.0 / (float)(f
);
1305 case DELAY_CLOCK_TCK
:
1306 x
= (t
- (float)(6E-6)) / (float)(4E-6);
1308 case DELAY_CLOCK_TMS
:
1309 x
= (t
- (float)(8.5E-6)) / (float)(4E-6);
1312 x
= (t
- (float)(8.8308E-6)) / (float)(4E-6);
1314 case DELAY_SCAN_OUT
:
1315 x
= (t
- (float)(1.0527E-5)) / (float)(4E-6);
1318 x
= (t
- (float)(1.3132E-5)) / (float)(4E-6);
1325 /* Check if the delay value is negative. This happens when a frequency is
1326 * requested that is too high for the delay loop implementation. In this
1327 * case, set delay value to zero. */
1331 /* We need to convert the exact delay value to an integer. Therefore, we
1332 * round the exact value UP to ensure that the resulting frequency is NOT
1333 * higher than the requested frequency. */
1336 /* Check if the value is within limits */
1340 *delay
= (int)x_ceil
;
1346 * Calculate frequency for a given delay value.
1348 * Similar to the #ulink_calculate_delay function, this function calculates the
1349 * TCK frequency for a given delay value by using linear equations of the form:
1351 * (t = period, k = constant, x = delay value, d = constant)
1353 * @param type for which command to calculate the delay value.
1354 * @param delay delay value for which to calculate the resulting TCK frequency.
1355 * @return the resulting TCK frequency
1357 static long ulink_calculate_frequency(enum ulink_delay_type type
, int delay
)
1365 case DELAY_CLOCK_TCK
:
1367 t
= (float)(2.666E-6);
1369 t
= (float)(4E-6) * (float)(delay
) + (float)(6E-6);
1371 case DELAY_CLOCK_TMS
:
1373 t
= (float)(5.666E-6);
1375 t
= (float)(4E-6) * (float)(delay
) + (float)(8.5E-6);
1379 t
= (float)(5.5E-6);
1381 t
= (float)(4E-6) * (float)(delay
) + (float)(8.8308E-6);
1383 case DELAY_SCAN_OUT
:
1385 t
= (float)(7.0E-6);
1387 t
= (float)(4E-6) * (float)(delay
) + (float)(1.0527E-5);
1391 t
= (float)(9.926E-6);
1393 t
= (float)(4E-6) * (float)(delay
) + (float)(1.3132E-5);
1400 return roundf(f_float
);
1403 /******************* Interface between OpenULINK and OpenOCD ******************/
1406 * Sets the end state follower (see interface.h) if \a endstate is a stable
1409 * @param endstate the state the end state follower should be set to.
1411 static void ulink_set_end_state(tap_state_t endstate
)
1413 if (tap_is_state_stable(endstate
))
1414 tap_set_end_state(endstate
);
1416 LOG_ERROR("BUG: %s is not a valid end state", tap_state_name(endstate
));
1422 * Move from the current TAP state to the current TAP end state.
1424 * @param device pointer to struct ulink identifying ULINK driver instance.
1425 * @return on success: ERROR_OK
1426 * @return on failure: ERROR_FAIL
1428 static int ulink_queue_statemove(struct ulink
*device
)
1430 uint8_t tms_sequence
, tms_count
;
1433 if (tap_get_state() == tap_get_end_state()) {
1434 /* Do nothing if we are already there */
1438 tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1439 tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1441 ret
= ulink_append_clock_tms_cmd(device
, tms_count
, tms_sequence
);
1443 if (ret
== ERROR_OK
)
1444 tap_set_state(tap_get_end_state());
1450 * Perform a scan operation on a JTAG register.
1452 * @param device pointer to struct ulink identifying ULINK driver instance.
1453 * @param cmd pointer to the command that shall be executed.
1454 * @return on success: ERROR_OK
1455 * @return on failure: ERROR_FAIL
1457 static int ulink_queue_scan(struct ulink
*device
, struct jtag_command
*cmd
)
1459 uint32_t scan_size_bits
, scan_size_bytes
, bits_last_scan
;
1460 uint32_t scans_max_payload
, bytecount
;
1461 uint8_t *tdi_buffer_start
= NULL
, *tdi_buffer
= NULL
;
1462 uint8_t *tdo_buffer_start
= NULL
, *tdo_buffer
= NULL
;
1464 uint8_t first_tms_count
, first_tms_sequence
;
1465 uint8_t last_tms_count
, last_tms_sequence
;
1467 uint8_t tms_count_pause
, tms_sequence_pause
;
1468 uint8_t tms_count_resume
, tms_sequence_resume
;
1470 uint8_t tms_count_start
, tms_sequence_start
;
1471 uint8_t tms_count_end
, tms_sequence_end
;
1473 enum scan_type type
;
1476 /* Determine scan size */
1477 scan_size_bits
= jtag_scan_size(cmd
->cmd
.scan
);
1478 scan_size_bytes
= DIV_ROUND_UP(scan_size_bits
, 8);
1480 /* Determine scan type (IN/OUT/IO) */
1481 type
= jtag_scan_type(cmd
->cmd
.scan
);
1483 /* Determine number of scan commands with maximum payload */
1484 scans_max_payload
= scan_size_bytes
/ 58;
1486 /* Determine size of last shift command */
1487 bits_last_scan
= scan_size_bits
- (scans_max_payload
* 58 * 8);
1489 /* Allocate TDO buffer if required */
1490 if ((type
== SCAN_IN
) || (type
== SCAN_IO
)) {
1491 tdo_buffer_start
= calloc(sizeof(uint8_t), scan_size_bytes
);
1493 if (tdo_buffer_start
== NULL
)
1496 tdo_buffer
= tdo_buffer_start
;
1499 /* Fill TDI buffer if required */
1500 if ((type
== SCAN_OUT
) || (type
== SCAN_IO
)) {
1501 jtag_build_buffer(cmd
->cmd
.scan
, &tdi_buffer_start
);
1502 tdi_buffer
= tdi_buffer_start
;
1505 /* Get TAP state transitions */
1506 if (cmd
->cmd
.scan
->ir_scan
) {
1507 ulink_set_end_state(TAP_IRSHIFT
);
1508 first_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1509 first_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1511 tap_set_state(TAP_IRSHIFT
);
1512 tap_set_end_state(cmd
->cmd
.scan
->end_state
);
1513 last_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1514 last_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1516 /* TAP state transitions for split scans */
1517 tms_count_pause
= tap_get_tms_path_len(TAP_IRSHIFT
, TAP_IRPAUSE
);
1518 tms_sequence_pause
= tap_get_tms_path(TAP_IRSHIFT
, TAP_IRPAUSE
);
1519 tms_count_resume
= tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRSHIFT
);
1520 tms_sequence_resume
= tap_get_tms_path(TAP_IRPAUSE
, TAP_IRSHIFT
);
1522 ulink_set_end_state(TAP_DRSHIFT
);
1523 first_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1524 first_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1526 tap_set_state(TAP_DRSHIFT
);
1527 tap_set_end_state(cmd
->cmd
.scan
->end_state
);
1528 last_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1529 last_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1531 /* TAP state transitions for split scans */
1532 tms_count_pause
= tap_get_tms_path_len(TAP_DRSHIFT
, TAP_DRPAUSE
);
1533 tms_sequence_pause
= tap_get_tms_path(TAP_DRSHIFT
, TAP_DRPAUSE
);
1534 tms_count_resume
= tap_get_tms_path_len(TAP_DRPAUSE
, TAP_DRSHIFT
);
1535 tms_sequence_resume
= tap_get_tms_path(TAP_DRPAUSE
, TAP_DRSHIFT
);
1538 /* Generate scan commands */
1539 bytecount
= scan_size_bytes
;
1540 while (bytecount
> 0) {
1541 if (bytecount
== scan_size_bytes
) {
1542 /* This is the first scan */
1543 tms_count_start
= first_tms_count
;
1544 tms_sequence_start
= first_tms_sequence
;
1546 /* Resume from previous scan */
1547 tms_count_start
= tms_count_resume
;
1548 tms_sequence_start
= tms_sequence_resume
;
1551 if (bytecount
> 58) { /* Full scan, at least one scan will follow */
1552 tms_count_end
= tms_count_pause
;
1553 tms_sequence_end
= tms_sequence_pause
;
1555 ret
= ulink_append_scan_cmd(device
,
1570 /* Update TDI and TDO buffer pointers */
1571 if (tdi_buffer_start
!= NULL
)
1573 if (tdo_buffer_start
!= NULL
)
1575 } else if (bytecount
== 58) { /* Full scan, no further scans */
1576 tms_count_end
= last_tms_count
;
1577 tms_sequence_end
= last_tms_sequence
;
1579 ret
= ulink_append_scan_cmd(device
,
1593 } else {/* Scan with less than maximum payload, no further scans */
1594 tms_count_end
= last_tms_count
;
1595 tms_sequence_end
= last_tms_sequence
;
1597 ret
= ulink_append_scan_cmd(device
,
1613 if (ret
!= ERROR_OK
) {
1614 free(tdi_buffer_start
);
1615 free(tdo_buffer_start
);
1620 free(tdi_buffer_start
);
1622 /* Set current state to the end state requested by the command */
1623 tap_set_state(cmd
->cmd
.scan
->end_state
);
1629 * Move the TAP into the Test Logic Reset state.
1631 * @param device pointer to struct ulink identifying ULINK driver instance.
1632 * @param cmd pointer to the command that shall be executed.
1633 * @return on success: ERROR_OK
1634 * @return on failure: ERROR_FAIL
1636 static int ulink_queue_tlr_reset(struct ulink
*device
, struct jtag_command
*cmd
)
1640 ret
= ulink_append_clock_tms_cmd(device
, 5, 0xff);
1642 if (ret
== ERROR_OK
)
1643 tap_set_state(TAP_RESET
);
1651 * Generate TCK clock cycles while remaining
1652 * in the Run-Test/Idle state.
1654 * @param device pointer to struct ulink identifying ULINK driver instance.
1655 * @param cmd pointer to the command that shall be executed.
1656 * @return on success: ERROR_OK
1657 * @return on failure: ERROR_FAIL
1659 static int ulink_queue_runtest(struct ulink
*device
, struct jtag_command
*cmd
)
1663 /* Only perform statemove if the TAP currently isn't in the TAP_IDLE state */
1664 if (tap_get_state() != TAP_IDLE
) {
1665 ulink_set_end_state(TAP_IDLE
);
1666 ulink_queue_statemove(device
);
1669 /* Generate the clock cycles */
1670 ret
= ulink_append_clock_tck_cmd(device
, cmd
->cmd
.runtest
->num_cycles
);
1671 if (ret
!= ERROR_OK
)
1674 /* Move to end state specified in command */
1675 if (cmd
->cmd
.runtest
->end_state
!= tap_get_state()) {
1676 tap_set_end_state(cmd
->cmd
.runtest
->end_state
);
1677 ulink_queue_statemove(device
);
1684 * Execute a JTAG_RESET command
1687 * @param cmd pointer to the command that shall be executed.
1688 * @return on success: ERROR_OK
1689 * @return on failure: ERROR_FAIL
1691 static int ulink_queue_reset(struct ulink
*device
, struct jtag_command
*cmd
)
1693 uint8_t low
= 0, high
= 0;
1695 if (cmd
->cmd
.reset
->trst
) {
1696 tap_set_state(TAP_RESET
);
1697 high
|= SIGNAL_TRST
;
1701 if (cmd
->cmd
.reset
->srst
)
1702 high
|= SIGNAL_RESET
;
1704 low
|= SIGNAL_RESET
;
1706 return ulink_append_set_signals_cmd(device
, low
, high
);
1710 * Move to one TAP state or several states in succession.
1712 * @param device pointer to struct ulink identifying ULINK driver instance.
1713 * @param cmd pointer to the command that shall be executed.
1714 * @return on success: ERROR_OK
1715 * @return on failure: ERROR_FAIL
1717 static int ulink_queue_pathmove(struct ulink
*device
, struct jtag_command
*cmd
)
1719 int ret
, i
, num_states
, batch_size
, state_count
;
1721 uint8_t tms_sequence
;
1723 num_states
= cmd
->cmd
.pathmove
->num_states
;
1724 path
= cmd
->cmd
.pathmove
->path
;
1727 while (num_states
> 0) {
1730 /* Determine batch size */
1731 if (num_states
>= 8)
1734 batch_size
= num_states
;
1736 for (i
= 0; i
< batch_size
; i
++) {
1737 if (tap_state_transition(tap_get_state(), false) == path
[state_count
]) {
1738 /* Append '0' transition: clear bit 'i' in tms_sequence */
1739 buf_set_u32(&tms_sequence
, i
, 1, 0x0);
1740 } else if (tap_state_transition(tap_get_state(), true)
1741 == path
[state_count
]) {
1742 /* Append '1' transition: set bit 'i' in tms_sequence */
1743 buf_set_u32(&tms_sequence
, i
, 1, 0x1);
1745 /* Invalid state transition */
1746 LOG_ERROR("BUG: %s -> %s isn't a valid TAP state transition",
1747 tap_state_name(tap_get_state()),
1748 tap_state_name(path
[state_count
]));
1752 tap_set_state(path
[state_count
]);
1757 /* Append CLOCK_TMS command to OpenULINK command queue */
1759 "pathmove batch: count = %i, sequence = 0x%x", batch_size
, tms_sequence
);
1760 ret
= ulink_append_clock_tms_cmd(ulink_handle
, batch_size
, tms_sequence
);
1761 if (ret
!= ERROR_OK
)
1769 * Sleep for a specific amount of time.
1771 * @param device pointer to struct ulink identifying ULINK driver instance.
1772 * @param cmd pointer to the command that shall be executed.
1773 * @return on success: ERROR_OK
1774 * @return on failure: ERROR_FAIL
1776 static int ulink_queue_sleep(struct ulink
*device
, struct jtag_command
*cmd
)
1778 /* IMPORTANT! Due to the time offset in command execution introduced by
1779 * command queueing, this needs to be implemented in the ULINK device */
1780 return ulink_append_sleep_cmd(device
, cmd
->cmd
.sleep
->us
);
1784 * Generate TCK cycles while remaining in a stable state.
1786 * @param device pointer to struct ulink identifying ULINK driver instance.
1787 * @param cmd pointer to the command that shall be executed.
1789 static int ulink_queue_stableclocks(struct ulink
*device
, struct jtag_command
*cmd
)
1792 unsigned num_cycles
;
1794 if (!tap_is_state_stable(tap_get_state())) {
1795 LOG_ERROR("JTAG_STABLECLOCKS: state not stable");
1799 num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
1801 /* TMS stays either high (Test Logic Reset state) or low (all other states) */
1802 if (tap_get_state() == TAP_RESET
)
1803 ret
= ulink_append_set_signals_cmd(device
, 0, SIGNAL_TMS
);
1805 ret
= ulink_append_set_signals_cmd(device
, SIGNAL_TMS
, 0);
1807 if (ret
!= ERROR_OK
)
1810 while (num_cycles
> 0) {
1811 if (num_cycles
> 0xFFFF) {
1812 /* OpenULINK CMD_CLOCK_TCK can generate up to 0xFFFF (uint16_t) cycles */
1813 ret
= ulink_append_clock_tck_cmd(device
, 0xFFFF);
1814 num_cycles
-= 0xFFFF;
1816 ret
= ulink_append_clock_tck_cmd(device
, num_cycles
);
1820 if (ret
!= ERROR_OK
)
1828 * Post-process JTAG_SCAN command
1830 * @param ulink_cmd pointer to OpenULINK command that shall be processed.
1831 * @return on success: ERROR_OK
1832 * @return on failure: ERROR_FAIL
1834 static int ulink_post_process_scan(struct ulink_cmd
*ulink_cmd
)
1836 struct jtag_command
*cmd
= ulink_cmd
->cmd_origin
;
1839 switch (jtag_scan_type(cmd
->cmd
.scan
)) {
1842 ret
= jtag_read_buffer(ulink_cmd
->payload_in_start
, cmd
->cmd
.scan
);
1845 /* Nothing to do for OUT scans */
1849 LOG_ERROR("BUG: ulink_post_process_scan() encountered an unknown"
1859 * Perform post-processing of commands after OpenULINK queue has been executed.
1861 * @param device pointer to struct ulink identifying ULINK driver instance.
1862 * @return on success: ERROR_OK
1863 * @return on failure: ERROR_FAIL
1865 static int ulink_post_process_queue(struct ulink
*device
)
1867 struct ulink_cmd
*current
;
1868 struct jtag_command
*openocd_cmd
;
1871 current
= device
->queue_start
;
1873 while (current
!= NULL
) {
1874 openocd_cmd
= current
->cmd_origin
;
1876 /* Check if a corresponding OpenOCD command is stored for this
1877 * OpenULINK command */
1878 if ((current
->needs_postprocessing
== true) && (openocd_cmd
!= NULL
)) {
1879 switch (openocd_cmd
->type
) {
1881 ret
= ulink_post_process_scan(current
);
1883 case JTAG_TLR_RESET
:
1888 case JTAG_STABLECLOCKS
:
1889 /* Nothing to do for these commands */
1894 LOG_ERROR("BUG: ulink_post_process_queue() encountered unknown JTAG "
1899 if (ret
!= ERROR_OK
)
1903 current
= current
->next
;
1909 /**************************** JTAG driver functions ***************************/
1912 * Executes the JTAG Command Queue.
1914 * This is done in three stages: First, all OpenOCD commands are processed into
1915 * queued OpenULINK commands. Next, the OpenULINK command queue is sent to the
1916 * ULINK device and data received from the ULINK device is cached. Finally,
1917 * the post-processing function writes back data to the corresponding OpenOCD
1920 * @return on success: ERROR_OK
1921 * @return on failure: ERROR_FAIL
1923 static int ulink_execute_queue(void)
1925 struct jtag_command
*cmd
= jtag_command_queue
;
1929 switch (cmd
->type
) {
1931 ret
= ulink_queue_scan(ulink_handle
, cmd
);
1933 case JTAG_TLR_RESET
:
1934 ret
= ulink_queue_tlr_reset(ulink_handle
, cmd
);
1937 ret
= ulink_queue_runtest(ulink_handle
, cmd
);
1940 ret
= ulink_queue_reset(ulink_handle
, cmd
);
1943 ret
= ulink_queue_pathmove(ulink_handle
, cmd
);
1946 ret
= ulink_queue_sleep(ulink_handle
, cmd
);
1948 case JTAG_STABLECLOCKS
:
1949 ret
= ulink_queue_stableclocks(ulink_handle
, cmd
);
1953 LOG_ERROR("BUG: encountered unknown JTAG command type");
1957 if (ret
!= ERROR_OK
)
1963 if (ulink_handle
->commands_in_queue
> 0) {
1964 ret
= ulink_execute_queued_commands(ulink_handle
, USB_TIMEOUT
);
1965 if (ret
!= ERROR_OK
)
1968 ret
= ulink_post_process_queue(ulink_handle
);
1969 if (ret
!= ERROR_OK
)
1972 ulink_clear_queue(ulink_handle
);
1979 * Set the TCK frequency of the ULINK adapter.
1981 * @param khz desired JTAG TCK frequency.
1982 * @param jtag_speed where to store corresponding adapter-specific speed value.
1983 * @return on success: ERROR_OK
1984 * @return on failure: ERROR_FAIL
1986 static int ulink_khz(int khz
, int *jtag_speed
)
1991 LOG_ERROR("RCLK not supported");
1995 /* CLOCK_TCK commands are decoupled from others. Therefore, the frequency
1996 * setting can be done independently from all other commands. */
1998 ulink_handle
->delay_clock_tck
= -1;
2000 ret
= ulink_calculate_delay(DELAY_CLOCK_TCK
, khz
* 1000,
2001 &ulink_handle
->delay_clock_tck
);
2002 if (ret
!= ERROR_OK
)
2006 /* SCAN_{IN,OUT,IO} commands invoke CLOCK_TMS commands. Therefore, if the
2007 * requested frequency goes below the maximum frequency for SLOW_CLOCK_TMS
2008 * commands, all SCAN commands MUST also use the variable frequency
2009 * implementation! */
2011 ulink_handle
->delay_clock_tms
= -1;
2012 ulink_handle
->delay_scan_in
= -1;
2013 ulink_handle
->delay_scan_out
= -1;
2014 ulink_handle
->delay_scan_io
= -1;
2016 ret
= ulink_calculate_delay(DELAY_CLOCK_TMS
, khz
* 1000,
2017 &ulink_handle
->delay_clock_tms
);
2018 if (ret
!= ERROR_OK
)
2021 ret
= ulink_calculate_delay(DELAY_SCAN_IN
, khz
* 1000,
2022 &ulink_handle
->delay_scan_in
);
2023 if (ret
!= ERROR_OK
)
2026 ret
= ulink_calculate_delay(DELAY_SCAN_OUT
, khz
* 1000,
2027 &ulink_handle
->delay_scan_out
);
2028 if (ret
!= ERROR_OK
)
2031 ret
= ulink_calculate_delay(DELAY_SCAN_IO
, khz
* 1000,
2032 &ulink_handle
->delay_scan_io
);
2033 if (ret
!= ERROR_OK
)
2037 LOG_DEBUG_IO("ULINK TCK setup: delay_tck = %i (%li Hz),",
2038 ulink_handle
->delay_clock_tck
,
2039 ulink_calculate_frequency(DELAY_CLOCK_TCK
, ulink_handle
->delay_clock_tck
));
2040 LOG_DEBUG_IO(" delay_tms = %i (%li Hz),",
2041 ulink_handle
->delay_clock_tms
,
2042 ulink_calculate_frequency(DELAY_CLOCK_TMS
, ulink_handle
->delay_clock_tms
));
2043 LOG_DEBUG_IO(" delay_scan_in = %i (%li Hz),",
2044 ulink_handle
->delay_scan_in
,
2045 ulink_calculate_frequency(DELAY_SCAN_IN
, ulink_handle
->delay_scan_in
));
2046 LOG_DEBUG_IO(" delay_scan_out = %i (%li Hz),",
2047 ulink_handle
->delay_scan_out
,
2048 ulink_calculate_frequency(DELAY_SCAN_OUT
, ulink_handle
->delay_scan_out
));
2049 LOG_DEBUG_IO(" delay_scan_io = %i (%li Hz),",
2050 ulink_handle
->delay_scan_io
,
2051 ulink_calculate_frequency(DELAY_SCAN_IO
, ulink_handle
->delay_scan_io
));
2053 /* Configure the ULINK device with the new delay values */
2054 ret
= ulink_append_configure_tck_cmd(ulink_handle
,
2055 ulink_handle
->delay_scan_in
,
2056 ulink_handle
->delay_scan_out
,
2057 ulink_handle
->delay_scan_io
,
2058 ulink_handle
->delay_clock_tck
,
2059 ulink_handle
->delay_clock_tms
);
2061 if (ret
!= ERROR_OK
)
2070 * Set the TCK frequency of the ULINK adapter.
2072 * Because of the way the TCK frequency is set up in the OpenULINK firmware,
2073 * there are five different speed settings. To simplify things, the
2074 * adapter-specific speed setting value is identical to the TCK frequency in
2077 * @param speed desired adapter-specific speed value.
2078 * @return on success: ERROR_OK
2079 * @return on failure: ERROR_FAIL
2081 static int ulink_speed(int speed
)
2085 return ulink_khz(speed
, &dummy
);
2089 * Convert adapter-specific speed value to corresponding TCK frequency in kHz.
2091 * Because of the way the TCK frequency is set up in the OpenULINK firmware,
2092 * there are five different speed settings. To simplify things, the
2093 * adapter-specific speed setting value is identical to the TCK frequency in
2096 * @param speed adapter-specific speed value.
2097 * @param khz where to store corresponding TCK frequency in kHz.
2098 * @return on success: ERROR_OK
2099 * @return on failure: ERROR_FAIL
2101 static int ulink_speed_div(int speed
, int *khz
)
2109 * Initiates the firmware download to the ULINK adapter and prepares
2112 * @return on success: ERROR_OK
2113 * @return on failure: ERROR_FAIL
2115 static int ulink_init(void)
2117 int ret
, transferred
;
2118 char str_manufacturer
[20];
2119 bool download_firmware
= false;
2120 unsigned char *dummy
;
2121 uint8_t input_signals
, output_signals
;
2123 ulink_handle
= calloc(1, sizeof(struct ulink
));
2124 if (ulink_handle
== NULL
)
2127 libusb_init(&ulink_handle
->libusb_ctx
);
2129 ret
= ulink_usb_open(&ulink_handle
);
2130 if (ret
!= ERROR_OK
) {
2131 LOG_ERROR("Could not open ULINK device");
2133 ulink_handle
= NULL
;
2137 /* Get String Descriptor to determine if firmware needs to be loaded */
2138 ret
= libusb_get_string_descriptor_ascii(ulink_handle
->usb_device_handle
, 1, (unsigned char *)str_manufacturer
, 20);
2140 /* Could not get descriptor -> Unconfigured or original Keil firmware */
2141 download_firmware
= true;
2143 /* We got a String Descriptor, check if it is the correct one */
2144 if (strncmp(str_manufacturer
, "OpenULINK", 9) != 0)
2145 download_firmware
= true;
2148 if (download_firmware
== true) {
2149 LOG_INFO("Loading OpenULINK firmware. This is reversible by power-cycling"
2151 ret
= ulink_load_firmware_and_renumerate(&ulink_handle
,
2152 ULINK_FIRMWARE_FILE
, ULINK_RENUMERATION_DELAY
);
2153 if (ret
!= ERROR_OK
) {
2154 LOG_ERROR("Could not download firmware and re-numerate ULINK");
2156 ulink_handle
= NULL
;
2160 LOG_INFO("ULINK device is already running OpenULINK firmware");
2162 /* Get OpenULINK USB IN/OUT endpoints and claim the interface */
2163 ret
= jtag_libusb_choose_interface(ulink_handle
->usb_device_handle
,
2164 &ulink_handle
->ep_in
, &ulink_handle
->ep_out
, -1, -1, -1, -1);
2165 if (ret
!= ERROR_OK
)
2168 /* Initialize OpenULINK command queue */
2169 ulink_clear_queue(ulink_handle
);
2171 /* Issue one test command with short timeout */
2172 ret
= ulink_append_test_cmd(ulink_handle
);
2173 if (ret
!= ERROR_OK
)
2176 ret
= ulink_execute_queued_commands(ulink_handle
, 200);
2177 if (ret
!= ERROR_OK
) {
2178 /* Sending test command failed. The ULINK device may be forever waiting for
2179 * the host to fetch an USB Bulk IN packet (e. g. OpenOCD crashed or was
2180 * shut down by the user via Ctrl-C. Try to retrieve this Bulk IN packet. */
2181 dummy
= calloc(64, sizeof(uint8_t));
2183 ret
= libusb_bulk_transfer(ulink_handle
->usb_device_handle
, ulink_handle
->ep_in
,
2184 dummy
, 64, &transferred
, 200);
2188 if (ret
!= 0 || transferred
== 0) {
2189 /* Bulk IN transfer failed -> unrecoverable error condition */
2190 LOG_ERROR("Cannot communicate with ULINK device. Disconnect ULINK from "
2191 "the USB port and re-connect, then re-run OpenOCD");
2193 ulink_handle
= NULL
;
2196 #ifdef _DEBUG_USB_COMMS_
2198 /* Successfully received Bulk IN packet -> continue */
2199 LOG_INFO("Recovered from lost Bulk IN packet");
2203 ulink_clear_queue(ulink_handle
);
2205 ret
= ulink_append_get_signals_cmd(ulink_handle
);
2206 if (ret
== ERROR_OK
)
2207 ret
= ulink_execute_queued_commands(ulink_handle
, 200);
2209 if (ret
== ERROR_OK
) {
2210 /* Post-process the single CMD_GET_SIGNALS command */
2211 input_signals
= ulink_handle
->queue_start
->payload_in
[0];
2212 output_signals
= ulink_handle
->queue_start
->payload_in
[1];
2214 ulink_print_signal_states(input_signals
, output_signals
);
2217 ulink_clear_queue(ulink_handle
);
2223 * Closes the USB handle for the ULINK device.
2225 * @return on success: ERROR_OK
2226 * @return on failure: ERROR_FAIL
2228 static int ulink_quit(void)
2232 ret
= ulink_usb_close(&ulink_handle
);
2239 * Set a custom path to ULINK firmware image and force downloading to ULINK.
2241 COMMAND_HANDLER(ulink_download_firmware_handler
)
2246 return ERROR_COMMAND_SYNTAX_ERROR
;
2249 LOG_INFO("Downloading ULINK firmware image %s", CMD_ARGV
[0]);
2251 /* Download firmware image in CMD_ARGV[0] */
2252 ret
= ulink_load_firmware_and_renumerate(&ulink_handle
, CMD_ARGV
[0],
2253 ULINK_RENUMERATION_DELAY
);
2258 /*************************** Command Registration **************************/
2260 static const struct command_registration ulink_command_handlers
[] = {
2262 .name
= "ulink_download_firmware",
2263 .handler
= &ulink_download_firmware_handler
,
2264 .mode
= COMMAND_EXEC
,
2265 .help
= "download firmware image to ULINK device",
2266 .usage
= "path/to/ulink_firmware.hex",
2268 COMMAND_REGISTRATION_DONE
,
2271 static struct jtag_interface ulink_interface
= {
2272 .execute_queue
= ulink_execute_queue
,
2275 struct adapter_driver ulink_adapter_driver
= {
2277 .transports
= jtag_only
,
2278 .commands
= ulink_command_handlers
,
2282 .speed
= ulink_speed
,
2284 .speed_div
= ulink_speed_div
,
2286 .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)