1 /***************************************************************************
2 * Copyright (C) 2011 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, write to the *
17 * Free Software Foundation, Inc., *
18 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
19 ***************************************************************************/
25 #include <jtag/interface.h>
26 #include <jtag/commands.h>
27 #include <target/image.h>
28 #include <helper/types.h>
29 #include "usb_common.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 PKGLIBDIR "/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 */
77 /** Original ULINK adapter, based on Cypress EZ-USB (AN2131):
78 * Full JTAG support, no SWD support. */
81 /** Newer ULINK adapter, based on NXP LPC2148. Currently unsupported. */
84 /** Newer ULINK adapter, based on EZ-USB FX2 + FPGA. Currently unsupported. */
87 /** Newer ULINK adapter, possibly based on ULINK 2. Currently unsupported. */
91 enum ulink_payload_direction
93 PAYLOAD_DIRECTION_OUT
,
98 * OpenULINK command (OpenULINK command queue element).
100 * For the OUT direction payload, things are quite easy: Payload is stored
101 * in a rather small array (up to 63 bytes), the payload is always allocated
102 * by the function generating the command and freed by ulink_clear_queue().
104 * For the IN direction payload, things get a little bit more complicated:
105 * The maximum IN payload size for a single command is 64 bytes. Assume that
106 * a single OpenOCD command needs to scan 256 bytes. This results in the
107 * generation of four OpenULINK commands. The function generating these
108 * commands shall allocate an uint8_t[256] array. Each command's #payload_in
109 * pointer shall point to the corresponding offset where IN data shall be
110 * placed, while #payload_in_start shall point to the first element of the 256
112 * - first command: #payload_in_start + 0
113 * - second command: #payload_in_start + 64
114 * - third command: #payload_in_start + 128
115 * - fourth command: #payload_in_start + 192
117 * The last command sets #needs_postprocessing to true.
120 uint8_t id
; ///< ULINK command ID
122 uint8_t *payload_out
; ///< OUT direction payload data
123 uint8_t payload_out_size
; ///< OUT direction payload size for this command
125 uint8_t *payload_in_start
; ///< Pointer to first element of IN payload array
126 uint8_t *payload_in
; ///< Pointer where IN payload shall be stored
127 uint8_t payload_in_size
; ///< IN direction payload size for this command
129 /** Indicates if this command needs post-processing */
130 bool needs_postprocessing
;
132 /** Indicates if ulink_clear_queue() should free payload_in_start */
133 bool free_payload_in_start
;
135 /** Pointer to corresponding OpenOCD command for post-processing */
136 struct jtag_command
*cmd_origin
;
138 struct ulink_cmd
*next
; ///< Pointer to next command (linked list)
141 typedef struct ulink_cmd ulink_cmd_t
;
143 /** Describes one driver instance */
146 struct usb_dev_handle
*usb_handle
;
147 enum ulink_type type
;
149 int commands_in_queue
; ///< Number of commands in queue
150 ulink_cmd_t
*queue_start
; ///< Pointer to first command in queue
151 ulink_cmd_t
*queue_end
; ///< Pointer to last command in queue
154 /**************************** Function Prototypes *****************************/
156 /* USB helper functions */
157 int ulink_usb_open(struct ulink
**device
);
158 int ulink_usb_close(struct ulink
**device
);
160 /* ULINK MCU (Cypress EZ-USB) specific functions */
161 int ulink_cpu_reset(struct ulink
*device
, char reset_bit
);
162 int ulink_load_firmware_and_renumerate(struct ulink
**device
, char *filename
,
164 int ulink_load_firmware(struct ulink
*device
, char *filename
);
165 int ulink_write_firmware_section(struct ulink
*device
,
166 struct image
*firmware_image
, int section_index
);
168 /* Generic helper functions */
169 void ulink_print_signal_states(uint8_t input_signals
, uint8_t output_signals
);
171 /* OpenULINK command generation helper functions */
172 int ulink_allocate_payload(ulink_cmd_t
*ulink_cmd
, int size
,
173 enum ulink_payload_direction direction
);
175 /* OpenULINK command queue helper functions */
176 int ulink_get_queue_size(struct ulink
*device
,
177 enum ulink_payload_direction direction
);
178 void ulink_clear_queue(struct ulink
*device
);
179 int ulink_append_queue(struct ulink
*device
, ulink_cmd_t
*ulink_cmd
);
180 int ulink_execute_queued_commands(struct ulink
*device
, int timeout
);
182 #ifdef _DEBUG_JTAG_IO_
183 const char * ulink_cmd_id_string(uint8_t id
);
184 void ulink_print_command(ulink_cmd_t
*ulink_cmd
);
185 void ulink_print_queue(struct ulink
*device
);
188 int ulink_append_scan_cmd(struct ulink
*device
, enum scan_type scan_type
,
189 int scan_size_bits
, uint8_t *tdi
, uint8_t *tdo_start
, uint8_t *tdo
,
190 uint8_t tms_count_start
, uint8_t tms_sequence_start
, uint8_t tms_count_end
,
191 uint8_t tms_sequence_end
, struct jtag_command
*origin
, bool postprocess
);
192 int ulink_append_clock_tms_cmd(struct ulink
*device
, uint8_t count
,
194 int ulink_append_clock_tck_cmd(struct ulink
*device
, uint16_t count
);
195 int ulink_append_get_signals_cmd(struct ulink
*device
);
196 int ulink_append_set_signals_cmd(struct ulink
*device
, uint8_t low
,
198 int ulink_append_sleep_cmd(struct ulink
*device
, uint32_t us
);
199 int ulink_append_configure_tck_cmd(struct ulink
*device
, uint8_t delay_scan
,
200 uint8_t delay_tck
, uint8_t delay_tms
);
201 int ulink_append_led_cmd(struct ulink
*device
, uint8_t led_state
);
202 int ulink_append_test_cmd(struct ulink
*device
);
204 /* Interface between OpenULINK and OpenOCD */
205 static void ulink_set_end_state(tap_state_t endstate
);
206 int ulink_queue_statemove(struct ulink
*device
);
208 int ulink_queue_scan(struct ulink
*device
, struct jtag_command
*cmd
);
209 int ulink_queue_tlr_reset(struct ulink
*device
, struct jtag_command
*cmd
);
210 int ulink_queue_runtest(struct ulink
*device
, struct jtag_command
*cmd
);
211 int ulink_queue_reset(struct ulink
*device
, struct jtag_command
*cmd
);
212 int ulink_queue_pathmove(struct ulink
*device
, struct jtag_command
*cmd
);
213 int ulink_queue_sleep(struct ulink
*device
, struct jtag_command
*cmd
);
214 int ulink_queue_stableclocks(struct ulink
*device
, struct jtag_command
*cmd
);
216 int ulink_post_process_scan(ulink_cmd_t
*ulink_cmd
);
217 int ulink_post_process_queue(struct ulink
*device
);
219 /* JTAG driver functions (registered in struct jtag_interface) */
220 static int ulink_execute_queue(void);
221 static int ulink_khz(int khz
, int *jtag_speed
);
222 static int ulink_speed(int speed
);
223 static int ulink_speed_div(int speed
, int *khz
);
224 static int ulink_init(void);
225 static int ulink_quit(void);
227 /****************************** Global Variables ******************************/
229 struct ulink
*ulink_handle
;
231 /**************************** USB helper functions ****************************/
234 * Opens the ULINK device and claims its USB interface.
236 * @param device pointer to struct ulink identifying ULINK driver instance.
237 * @return on success: ERROR_OK
238 * @return on failure: ERROR_FAIL
240 int ulink_usb_open(struct ulink
**device
)
243 struct usb_dev_handle
*usb_handle
;
245 /* Currently, only original ULINK is supported */
246 uint16_t vids
[] = { ULINK_VID
, 0 };
247 uint16_t pids
[] = { ULINK_PID
, 0 };
249 ret
= jtag_usb_open(vids
, pids
, &usb_handle
);
251 if (ret
!= ERROR_OK
) {
255 ret
= usb_claim_interface(usb_handle
, 0);
261 (*device
)->usb_handle
= usb_handle
;
262 (*device
)->type
= ULINK_1
;
268 * Releases the ULINK interface and closes the USB device handle.
270 * @param device pointer to struct ulink identifying ULINK driver instance.
271 * @return on success: ERROR_OK
272 * @return on failure: ERROR_FAIL
274 int ulink_usb_close(struct ulink
**device
)
276 if (usb_release_interface((*device
)->usb_handle
, 0) != 0) {
280 if (usb_close((*device
)->usb_handle
) != 0) {
284 (*device
)->usb_handle
= NULL
;
289 /******************* ULINK CPU (EZ-USB) specific functions ********************/
292 * Writes '0' or '1' to the CPUCS register, putting the EZ-USB CPU into reset
295 * @param device pointer to struct ulink identifying ULINK driver instance.
296 * @param reset_bit 0 to put CPU into reset, 1 to put CPU out of reset.
297 * @return on success: ERROR_OK
298 * @return on failure: ERROR_FAIL
300 int ulink_cpu_reset(struct ulink
*device
, char reset_bit
)
304 ret
= usb_control_msg(device
->usb_handle
,
305 (USB_ENDPOINT_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
),
306 REQUEST_FIRMWARE_LOAD
, CPUCS_REG
, 0, &reset_bit
, 1, USB_TIMEOUT
);
308 /* usb_control_msg() returns the number of bytes transferred during the
309 * DATA stage of the control transfer - must be exactly 1 in this case! */
317 * Puts the ULINK's EZ-USB microcontroller into reset state, downloads
318 * the firmware image, resumes the microcontroller and re-enumerates
321 * @param device pointer to struct ulink identifying ULINK driver instance.
322 * The usb_handle member will be modified during re-enumeration.
323 * @param filename path to the Intel HEX file containing the firmware image.
324 * @param delay the delay to wait for the device to re-enumerate.
325 * @return on success: ERROR_OK
326 * @return on failure: ERROR_FAIL
328 int ulink_load_firmware_and_renumerate(struct ulink
**device
,
329 char *filename
, uint32_t delay
)
333 /* Basic process: After downloading the firmware, the ULINK will disconnect
334 * itself and re-connect after a short amount of time so we have to close
335 * the handle and re-enumerate USB devices */
337 ret
= ulink_load_firmware(*device
, filename
);
338 if (ret
!= ERROR_OK
) {
342 ret
= ulink_usb_close(device
);
343 if (ret
!= ERROR_OK
) {
349 ret
= ulink_usb_open(device
);
350 if (ret
!= ERROR_OK
) {
358 * Downloads a firmware image to the ULINK's EZ-USB microcontroller
361 * @param device pointer to struct ulink identifying ULINK driver instance.
362 * @param filename an absolute or relative path to the Intel HEX file
363 * containing the firmware image.
364 * @return on success: ERROR_OK
365 * @return on failure: ERROR_FAIL
367 int ulink_load_firmware(struct ulink
*device
, char *filename
)
369 struct image ulink_firmware_image
;
372 ret
= ulink_cpu_reset(device
, CPU_RESET
);
373 if (ret
!= ERROR_OK
) {
374 LOG_ERROR("Could not halt ULINK CPU");
378 ulink_firmware_image
.base_address
= 0;
379 ulink_firmware_image
.base_address_set
= 0;
381 ret
= image_open(&ulink_firmware_image
, filename
, "ihex");
382 if (ret
!= ERROR_OK
) {
383 LOG_ERROR("Could not load firmware image");
387 /* Download all sections in the image to ULINK */
388 for (i
= 0; i
< ulink_firmware_image
.num_sections
; i
++) {
389 ret
= ulink_write_firmware_section(device
, &ulink_firmware_image
, i
);
390 if (ret
!= ERROR_OK
) {
395 image_close(&ulink_firmware_image
);
397 ret
= ulink_cpu_reset(device
, CPU_START
);
398 if (ret
!= ERROR_OK
) {
399 LOG_ERROR("Could not restart ULINK CPU");
407 * Send one contiguous firmware section to the ULINK's EZ-USB microcontroller
410 * @param device pointer to struct ulink identifying ULINK driver instance.
411 * @param firmware_image pointer to the firmware image that contains the section
412 * which should be sent to the ULINK's EZ-USB microcontroller.
413 * @param section_index index of the section within the firmware image.
414 * @return on success: ERROR_OK
415 * @return on failure: ERROR_FAIL
417 int ulink_write_firmware_section(struct ulink
*device
,
418 struct image
*firmware_image
, int section_index
)
420 uint16_t addr
, size
, bytes_remaining
, chunk_size
;
421 uint8_t data
[SECTION_BUFFERSIZE
];
422 uint8_t *data_ptr
= data
;
426 size
= (uint16_t)firmware_image
->sections
[section_index
].size
;
427 addr
= (uint16_t)firmware_image
->sections
[section_index
].base_address
;
429 LOG_DEBUG("section %02i at addr 0x%04x (size 0x%04x)", section_index
, addr
,
436 /* Copy section contents to local buffer */
437 ret
= image_read_section(firmware_image
, section_index
, 0, size
, data
,
440 if ((ret
!= ERROR_OK
) || (size_read
!= size
)) {
441 /* Propagating the return code would return '0' (misleadingly indicating
442 * successful execution of the function) if only the size check fails. */
446 bytes_remaining
= size
;
448 /* Send section data in chunks of up to 64 bytes to ULINK */
449 while (bytes_remaining
> 0) {
450 if (bytes_remaining
> 64) {
454 chunk_size
= bytes_remaining
;
457 ret
= usb_control_msg(device
->usb_handle
,
458 (USB_ENDPOINT_OUT
| USB_TYPE_VENDOR
| USB_RECIP_DEVICE
),
459 REQUEST_FIRMWARE_LOAD
, addr
, FIRMWARE_ADDR
, (char *)data_ptr
,
460 chunk_size
, USB_TIMEOUT
);
462 if (ret
!= (int)chunk_size
) {
463 /* Abort if libusb sent less data than requested */
467 bytes_remaining
-= chunk_size
;
469 data_ptr
+= chunk_size
;
475 /************************** Generic helper functions **************************/
478 * Print state of interesting signals via LOG_INFO().
480 * @param input_signals input signal states as returned by CMD_GET_SIGNALS
481 * @param output_signals output signal states as returned by CMD_GET_SIGNALS
483 void ulink_print_signal_states(uint8_t input_signals
, uint8_t output_signals
)
485 LOG_INFO("ULINK signal states: TDI: %i, TDO: %i, TMS: %i, TCK: %i, TRST: %i,"
487 (output_signals
& SIGNAL_TDI
? 1 : 0),
488 (input_signals
& SIGNAL_TDO
? 1 : 0),
489 (output_signals
& SIGNAL_TMS
? 1 : 0),
490 (output_signals
& SIGNAL_TCK
? 1 : 0),
491 (output_signals
& SIGNAL_TRST
? 0 : 1), // TRST and RESET are inverted
492 (output_signals
& SIGNAL_RESET
? 0 : 1)); // by hardware
495 /**************** OpenULINK command generation helper functions ***************/
498 * Allocate and initialize space in memory for OpenULINK command payload.
500 * @param ulink_cmd pointer to command whose payload should be allocated.
501 * @param size the amount of memory to allocate (bytes).
502 * @param direction which payload to allocate.
503 * @return on success: ERROR_OK
504 * @return on failure: ERROR_FAIL
506 int ulink_allocate_payload(ulink_cmd_t
*ulink_cmd
, int size
,
507 enum ulink_payload_direction direction
)
511 payload
= calloc(size
, sizeof(uint8_t));
513 if (payload
== NULL
) {
514 LOG_ERROR("Could not allocate OpenULINK command payload: out of memory");
519 case PAYLOAD_DIRECTION_OUT
:
520 if (ulink_cmd
->payload_out
!= NULL
) {
521 LOG_ERROR("BUG: Duplicate payload allocation for OpenULINK command");
525 ulink_cmd
->payload_out
= payload
;
526 ulink_cmd
->payload_out_size
= size
;
529 case PAYLOAD_DIRECTION_IN
:
530 if (ulink_cmd
->payload_in_start
!= NULL
) {
531 LOG_ERROR("BUG: Duplicate payload allocation for OpenULINK command");
535 ulink_cmd
->payload_in_start
= payload
;
536 ulink_cmd
->payload_in
= payload
;
537 ulink_cmd
->payload_in_size
= size
;
539 /* By default, free payload_in_start in ulink_clear_queue(). Commands
540 * that do not want this behavior (e. g. split scans) must turn it off
542 ulink_cmd
->free_payload_in_start
= true;
550 /****************** OpenULINK command queue helper functions ******************/
553 * Get the current number of bytes in the queue, including command IDs.
555 * @param device pointer to struct ulink identifying ULINK driver instance.
556 * @param direction the transfer direction for which to get byte count.
557 * @return the number of bytes currently stored in the queue for the specified
560 int ulink_get_queue_size(struct ulink
*device
,
561 enum ulink_payload_direction direction
)
563 ulink_cmd_t
*current
= device
->queue_start
;
566 while (current
!= NULL
) {
568 case PAYLOAD_DIRECTION_OUT
:
569 sum
+= current
->payload_out_size
+ 1; // + 1 byte for Command ID
571 case PAYLOAD_DIRECTION_IN
:
572 sum
+= current
->payload_in_size
;
576 current
= current
->next
;
583 * Clear the OpenULINK command queue.
585 * @param device pointer to struct ulink identifying ULINK driver instance.
586 * @return on success: ERROR_OK
587 * @return on failure: ERROR_FAIL
589 void ulink_clear_queue(struct ulink
*device
)
591 ulink_cmd_t
*current
= device
->queue_start
;
592 ulink_cmd_t
*next
= NULL
;
594 while (current
!= NULL
) {
595 /* Save pointer to next element */
596 next
= current
->next
;
598 /* Free payloads: OUT payload can be freed immediately */
599 free(current
->payload_out
);
600 current
->payload_out
= NULL
;
602 /* IN payload MUST be freed ONLY if no other commands use the
603 * payload_in_start buffer */
604 if (current
->free_payload_in_start
== true) {
605 free(current
->payload_in_start
);
606 current
->payload_in_start
= NULL
;
607 current
->payload_in
= NULL
;
610 /* Free queue element */
613 /* Proceed with next element */
617 device
->commands_in_queue
= 0;
618 device
->queue_start
= NULL
;
619 device
->queue_end
= NULL
;
623 * Add a command to the OpenULINK command queue.
625 * @param device pointer to struct ulink identifying ULINK driver instance.
626 * @param ulink_cmd pointer to command that shall be appended to the OpenULINK
628 * @return on success: ERROR_OK
629 * @return on failure: ERROR_FAIL
631 int ulink_append_queue(struct ulink
*device
, ulink_cmd_t
*ulink_cmd
)
633 int newsize_out
, newsize_in
;
636 newsize_out
= ulink_get_queue_size(device
, PAYLOAD_DIRECTION_OUT
) + 1
637 + ulink_cmd
->payload_out_size
;
639 newsize_in
= ulink_get_queue_size(device
, PAYLOAD_DIRECTION_IN
)
640 + ulink_cmd
->payload_in_size
;
642 /* Check if the current command can be appended to the queue */
643 if ((newsize_out
> 64) || (newsize_in
> 64)) {
644 /* New command does not fit. Execute all commands in queue before starting
645 * new queue with the current command as first entry. */
646 ret
= ulink_execute_queued_commands(device
, USB_TIMEOUT
);
647 if (ret
!= ERROR_OK
) {
651 ret
= ulink_post_process_queue(device
);
652 if (ret
!= ERROR_OK
) {
656 ulink_clear_queue(device
);
659 if (device
->queue_start
== NULL
) {
660 /* Queue was empty */
661 device
->commands_in_queue
= 1;
663 device
->queue_start
= ulink_cmd
;
664 device
->queue_end
= ulink_cmd
;
667 /* There are already commands in the queue */
668 device
->commands_in_queue
++;
670 device
->queue_end
->next
= ulink_cmd
;
671 device
->queue_end
= ulink_cmd
;
678 * Sends all queued OpenULINK commands to the ULINK for execution.
680 * @param device pointer to struct ulink identifying ULINK driver instance.
681 * @return on success: ERROR_OK
682 * @return on failure: ERROR_FAIL
684 int ulink_execute_queued_commands(struct ulink
*device
, int timeout
)
686 ulink_cmd_t
*current
;
687 int ret
, i
, index_out
, index_in
, count_out
, count_in
;
690 #ifdef _DEBUG_JTAG_IO_
691 ulink_print_queue(device
);
698 for (current
= device
->queue_start
; current
; current
= current
->next
) {
699 /* Add command to packet */
700 buffer
[index_out
] = current
->id
;
704 for (i
= 0; i
< current
->payload_out_size
; i
++) {
705 buffer
[index_out
+ i
] = current
->payload_out
[i
];
707 index_out
+= current
->payload_out_size
;
708 count_in
+= current
->payload_in_size
;
709 count_out
+= current
->payload_out_size
;
712 /* Send packet to ULINK */
713 ret
= usb_bulk_write(device
->usb_handle
, (2 | USB_ENDPOINT_OUT
),
714 (char *)buffer
, count_out
, timeout
);
718 if (ret
!= count_out
) {
722 /* Wait for response if commands contain IN payload data */
724 ret
= usb_bulk_read(device
->usb_handle
, (2 | USB_ENDPOINT_IN
),
725 (char *)buffer
, 64, timeout
);
729 if (ret
!= count_in
) {
733 /* Write back IN payload data */
735 for (current
= device
->queue_start
; current
; current
= current
->next
) {
736 for (i
= 0; i
< current
->payload_in_size
; i
++) {
737 current
->payload_in
[i
] = buffer
[index_in
];
746 #ifdef _DEBUG_JTAG_IO_
749 * Convert an OpenULINK command ID (\a id) to a human-readable string.
751 * @param id the OpenULINK command ID.
752 * @return the corresponding human-readable string.
754 const char * ulink_cmd_id_string(uint8_t id
)
758 return "CMD_SCAN_IN";
760 case CMD_SLOW_SCAN_IN
:
761 return "CMD_SLOW_SCAN_IN";
764 return "CMD_SCAN_OUT";
766 case CMD_SLOW_SCAN_OUT
:
767 return "CMD_SLOW_SCAN_OUT";
770 return "CMD_SCAN_IO";
772 case CMD_SLOW_SCAN_IO
:
773 return "CMD_SLOW_SCAN_IO";
776 return "CMD_CLOCK_TMS";
778 case CMD_SLOW_CLOCK_TMS
:
779 return "CMD_SLOW_CLOCK_TMS";
782 return "CMD_CLOCK_TCK";
785 return "CMD_SLEEP_US";
788 return "CMD_SLEEP_MS";
790 case CMD_GET_SIGNALS
:
791 return "CMD_GET_SIGNALS";
793 case CMD_SET_SIGNALS
:
794 return "CMD_SET_SIGNALS";
796 case CMD_CONFIGURE_TCK_FREQ
:
797 return "CMD_CONFIGURE_TCK_FREQ";
800 return "CMD_SET_LEDS";
806 return "CMD_UNKNOWN";
812 * Print one OpenULINK command to stdout.
814 * @param ulink_cmd pointer to OpenULINK command.
816 void ulink_print_command(ulink_cmd_t
*ulink_cmd
)
820 printf(" %-22s | OUT size = %i, bytes = 0x", ulink_cmd_id_string(ulink_cmd
->id
),
821 ulink_cmd
->payload_out_size
);
823 for (i
= 0; i
< ulink_cmd
->payload_out_size
; i
++) {
824 printf("%02X ", ulink_cmd
->payload_out
[i
]);
826 printf("\n | IN size = %i\n", ulink_cmd
->payload_in_size
);
830 * Print the OpenULINK command queue to stdout.
832 * @param device pointer to struct ulink identifying ULINK driver instance.
834 void ulink_print_queue(struct ulink
*device
)
836 ulink_cmd_t
*current
;
838 printf("OpenULINK command queue:\n");
840 for (current
= device
->queue_start
; current
; current
= current
->next
) {
841 ulink_print_command(current
);
845 #endif /* _DEBUG_JTAG_IO_ */
850 * Creates and appends a JTAG scan command to the OpenULINK command queue.
851 * A JTAG scan consists of three steps:
852 * - Move to the desired SHIFT state, depending on scan type (IR/DR scan).
853 * - Shift TDI data into the JTAG chain, optionally reading the TDO pin.
854 * - Move to the desired end state.
856 * @param device pointer to struct ulink identifying ULINK driver instance.
857 * @param scan_type the type of the scan (IN, OUT, IO (bidirectional)).
858 * @param scan_size_bits number of bits to shift into the JTAG chain.
859 * @param tdi pointer to array containing TDI data.
860 * @param tdo_start pointer to first element of array where TDO data shall be
861 * stored. See #ulink_cmd for details.
862 * @param tdo pointer to array where TDO data shall be stored
863 * @param tms_count_start number of TMS state transitions to perform BEFORE
864 * shifting data into the JTAG chain.
865 * @param tms_sequence_start sequence of TMS state transitions that will be
866 * performed BEFORE shifting data into the JTAG chain.
867 * @param tms_count_end number of TMS state transitions to perform AFTER
868 * shifting data into the JTAG chain.
869 * @param tms_sequence_end sequence of TMS state transitions that will be
870 * performed AFTER shifting data into the JTAG chain.
871 * @param origin pointer to OpenOCD command that generated this scan command.
872 * @param postprocess whether this command needs to be post-processed after
874 * @return on success: ERROR_OK
875 * @return on failure: ERROR_FAIL
877 int ulink_append_scan_cmd(struct ulink
*device
, enum scan_type scan_type
,
878 int scan_size_bits
, uint8_t *tdi
, uint8_t *tdo_start
, uint8_t *tdo
,
879 uint8_t tms_count_start
, uint8_t tms_sequence_start
, uint8_t tms_count_end
,
880 uint8_t tms_sequence_end
, struct jtag_command
*origin
, bool postprocess
)
882 ulink_cmd_t
*cmd
= calloc(1, sizeof(ulink_cmd_t
));
883 int ret
, i
, scan_size_bytes
;
884 uint8_t bits_last_byte
;
890 /* Check size of command. USB buffer can hold 64 bytes, 1 byte is command ID,
891 * 5 bytes are setup data -> 58 remaining payload bytes for TDI data */
892 if (scan_size_bits
> (58 * 8)) {
893 LOG_ERROR("BUG: Tried to create CMD_SCAN_IO OpenULINK command with too"
898 scan_size_bytes
= DIV_ROUND_UP(scan_size_bits
, 8);
900 bits_last_byte
= scan_size_bits
% 8;
901 if (bits_last_byte
== 0) {
905 /* Allocate out_payload depending on scan type */
906 // TODO: set command ID depending on interface speed settings (slow scan)
909 cmd
->id
= CMD_SCAN_IN
;
910 ret
= ulink_allocate_payload(cmd
, 5, PAYLOAD_DIRECTION_OUT
);
913 cmd
->id
= CMD_SCAN_OUT
;
914 ret
= ulink_allocate_payload(cmd
, scan_size_bytes
+ 5, PAYLOAD_DIRECTION_OUT
);
917 cmd
->id
= CMD_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
) {
930 /* Build payload_out that is common to all scan types */
931 cmd
->payload_out
[0] = scan_size_bytes
& 0xFF;
932 cmd
->payload_out
[1] = bits_last_byte
& 0xFF;
933 cmd
->payload_out
[2] = ((tms_count_start
& 0x0F) << 4) | (tms_count_end
& 0x0F);
934 cmd
->payload_out
[3] = tms_sequence_start
;
935 cmd
->payload_out
[4] = tms_sequence_end
;
937 /* Setup payload_out for types with OUT transfer */
938 if ((scan_type
== SCAN_OUT
) || (scan_type
== SCAN_IO
)) {
939 for (i
= 0; i
< scan_size_bytes
; i
++) {
940 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 int ulink_append_clock_tms_cmd(struct ulink
*device
, uint8_t count
,
974 ulink_cmd_t
*cmd
= calloc(1, sizeof(ulink_cmd_t
));
981 cmd
->id
= CMD_CLOCK_TMS
;
983 /* CMD_CLOCK_TMS has two OUT payload bytes and zero IN payload bytes */
984 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
985 if (ret
!= ERROR_OK
) {
989 cmd
->payload_out
[0] = count
;
990 cmd
->payload_out
[1] = sequence
;
992 return ulink_append_queue(device
, cmd
);
996 * Generate a defined amount of TCK clock cycles
998 * All other JTAG signals are left unchanged.
1000 * @param device pointer to struct ulink identifying ULINK driver instance.
1001 * @param count the number of TCK clock cycles to generate.
1002 * @return on success: ERROR_OK
1003 * @return on failure: ERROR_FAIL
1005 int ulink_append_clock_tck_cmd(struct ulink
*device
, uint16_t count
)
1007 ulink_cmd_t
*cmd
= calloc(1, sizeof(ulink_cmd_t
));
1014 cmd
->id
= CMD_CLOCK_TCK
;
1016 /* CMD_CLOCK_TCK has two OUT payload bytes and zero IN payload bytes */
1017 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
1018 if (ret
!= ERROR_OK
) {
1022 cmd
->payload_out
[0] = count
& 0xff;
1023 cmd
->payload_out
[1] = (count
>> 8) & 0xff;
1025 return ulink_append_queue(device
, cmd
);
1029 * Read JTAG signals.
1031 * @param device pointer to struct ulink identifying ULINK driver instance.
1032 * @return on success: ERROR_OK
1033 * @return on failure: ERROR_FAIL
1035 int ulink_append_get_signals_cmd(struct ulink
*device
)
1037 ulink_cmd_t
*cmd
= calloc(1, sizeof(ulink_cmd_t
));
1044 cmd
->id
= CMD_GET_SIGNALS
;
1045 cmd
->needs_postprocessing
= true;
1047 /* CMD_GET_SIGNALS has two IN payload bytes */
1048 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_IN
);
1050 if (ret
!= ERROR_OK
) {
1054 return ulink_append_queue(device
, cmd
);
1058 * Arbitrarily set JTAG output signals.
1060 * @param device pointer to struct ulink identifying ULINK driver instance.
1061 * @param low defines which signals will be de-asserted. Each bit corresponds
1070 * @param high defines which signals will be asserted.
1071 * @return on success: ERROR_OK
1072 * @return on failure: ERROR_FAIL
1074 int ulink_append_set_signals_cmd(struct ulink
*device
, uint8_t low
,
1077 ulink_cmd_t
*cmd
= calloc(1, sizeof(ulink_cmd_t
));
1084 cmd
->id
= CMD_SET_SIGNALS
;
1086 /* CMD_SET_SIGNALS has two OUT payload bytes and zero IN payload bytes */
1087 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
1089 if (ret
!= ERROR_OK
) {
1093 cmd
->payload_out
[0] = low
;
1094 cmd
->payload_out
[1] = high
;
1096 return ulink_append_queue(device
, cmd
);
1100 * Sleep for a pre-defined number of microseconds
1102 * @param device pointer to struct ulink identifying ULINK driver instance.
1103 * @param us the number microseconds to sleep.
1104 * @return on success: ERROR_OK
1105 * @return on failure: ERROR_FAIL
1107 int ulink_append_sleep_cmd(struct ulink
*device
, uint32_t us
)
1109 ulink_cmd_t
*cmd
= calloc(1, sizeof(ulink_cmd_t
));
1116 cmd
->id
= CMD_SLEEP_US
;
1118 /* CMD_SLEEP_US has two OUT payload bytes and zero IN payload bytes */
1119 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
1121 if (ret
!= ERROR_OK
) {
1125 cmd
->payload_out
[0] = us
& 0x00ff;
1126 cmd
->payload_out
[1] = (us
>> 8) & 0x00ff;
1128 return ulink_append_queue(device
, cmd
);
1132 * Set TCK delay counters
1134 * @param device pointer to struct ulink identifying ULINK driver instance.
1135 * @param delay_scan delay count top value in jtag_slow_scan() functions
1136 * @param delay_tck delay count top value in jtag_clock_tck() function
1137 * @param delay_tms delay count top value in jtag_slow_clock_tms() function
1138 * @return on success: ERROR_OK
1139 * @return on failure: ERROR_FAIL
1141 int ulink_append_configure_tck_cmd(struct ulink
*device
, uint8_t delay_scan
,
1142 uint8_t delay_tck
, uint8_t delay_tms
)
1144 ulink_cmd_t
*cmd
= calloc(1, sizeof(ulink_cmd_t
));
1151 cmd
->id
= CMD_CONFIGURE_TCK_FREQ
;
1153 /* CMD_CONFIGURE_TCK_FREQ has three OUT payload bytes and zero
1154 * IN payload bytes */
1155 ret
= ulink_allocate_payload(cmd
, 3, PAYLOAD_DIRECTION_OUT
);
1156 if (ret
!= ERROR_OK
) {
1160 cmd
->payload_out
[0] = delay_scan
;
1161 cmd
->payload_out
[1] = delay_tck
;
1162 cmd
->payload_out
[2] = delay_tms
;
1164 return ulink_append_queue(device
, cmd
);
1168 * Turn on/off ULINK LEDs.
1170 * @param device pointer to struct ulink identifying ULINK driver instance.
1171 * @param led_state which LED(s) to turn on or off. The following bits
1172 * influence the LEDS:
1173 * - Bit 0: Turn COM LED on
1174 * - Bit 1: Turn RUN LED on
1175 * - Bit 2: Turn COM LED off
1176 * - Bit 3: Turn RUN LED off
1177 * If both the on-bit and the off-bit for the same LED is set, the LED is
1179 * @return on success: ERROR_OK
1180 * @return on failure: ERROR_FAIL
1182 int ulink_append_led_cmd(struct ulink
*device
, uint8_t led_state
)
1184 ulink_cmd_t
*cmd
= calloc(1, sizeof(ulink_cmd_t
));
1191 cmd
->id
= CMD_SET_LEDS
;
1193 /* CMD_SET_LEDS has one OUT payload byte and zero IN payload bytes */
1194 ret
= ulink_allocate_payload(cmd
, 1, PAYLOAD_DIRECTION_OUT
);
1195 if (ret
!= ERROR_OK
) {
1199 cmd
->payload_out
[0] = led_state
;
1201 return ulink_append_queue(device
, cmd
);
1205 * Test command. Used to check if the ULINK device is ready to accept new
1208 * @param device pointer to struct ulink identifying ULINK driver instance.
1209 * @return on success: ERROR_OK
1210 * @return on failure: ERROR_FAIL
1212 int ulink_append_test_cmd(struct ulink
*device
)
1214 ulink_cmd_t
*cmd
= calloc(1, sizeof(ulink_cmd_t
));
1223 /* CMD_TEST has one OUT payload byte and zero IN payload bytes */
1224 ret
= ulink_allocate_payload(cmd
, 1, PAYLOAD_DIRECTION_OUT
);
1225 if (ret
!= ERROR_OK
) {
1229 cmd
->payload_out
[0] = 0xAA;
1231 return ulink_append_queue(device
, cmd
);
1234 /******************* Interface between OpenULINK and OpenOCD ******************/
1237 * Sets the end state follower (see interface.h) if \a endstate is a stable
1240 * @param endstate the state the end state follower should be set to.
1242 static void ulink_set_end_state(tap_state_t endstate
)
1244 if (tap_is_state_stable(endstate
)) {
1245 tap_set_end_state(endstate
);
1248 LOG_ERROR("BUG: %s is not a valid end state", tap_state_name(endstate
));
1249 exit( EXIT_FAILURE
);
1254 * Move from the current TAP state to the current TAP end state.
1256 * @param device pointer to struct ulink identifying ULINK driver instance.
1257 * @return on success: ERROR_OK
1258 * @return on failure: ERROR_FAIL
1260 int ulink_queue_statemove(struct ulink
*device
)
1262 uint8_t tms_sequence
, tms_count
;
1265 if (tap_get_state() == tap_get_end_state()) {
1266 /* Do nothing if we are already there */
1270 tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1271 tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1273 ret
= ulink_append_clock_tms_cmd(device
, tms_count
, tms_sequence
);
1275 if (ret
== ERROR_OK
) {
1276 tap_set_state(tap_get_end_state());
1283 * Perform a scan operation on a JTAG register.
1285 * @param device pointer to struct ulink identifying ULINK driver instance.
1286 * @param cmd pointer to the command that shall be executed.
1287 * @return on success: ERROR_OK
1288 * @return on failure: ERROR_FAIL
1290 int ulink_queue_scan(struct ulink
*device
, struct jtag_command
*cmd
)
1292 uint32_t scan_size_bits
, scan_size_bytes
, bits_last_scan
;
1293 uint32_t scans_max_payload
, bytecount
;
1294 uint8_t *tdi_buffer_start
= NULL
, *tdi_buffer
= NULL
;
1295 uint8_t *tdo_buffer_start
= NULL
, *tdo_buffer
= NULL
;
1297 uint8_t first_tms_count
, first_tms_sequence
;
1298 uint8_t last_tms_count
, last_tms_sequence
;
1300 uint8_t tms_count_pause
, tms_sequence_pause
;
1301 uint8_t tms_count_resume
, tms_sequence_resume
;
1303 uint8_t tms_count_start
, tms_sequence_start
;
1304 uint8_t tms_count_end
, tms_sequence_end
;
1306 enum scan_type type
;
1309 /* Determine scan size */
1310 scan_size_bits
= jtag_scan_size(cmd
->cmd
.scan
);
1311 scan_size_bytes
= DIV_ROUND_UP(scan_size_bits
, 8);
1313 /* Determine scan type (IN/OUT/IO) */
1314 type
= jtag_scan_type(cmd
->cmd
.scan
);
1316 /* Determine number of scan commands with maximum payload */
1317 scans_max_payload
= scan_size_bytes
/ 58;
1319 /* Determine size of last shift command */
1320 bits_last_scan
= scan_size_bits
- (scans_max_payload
* 58 * 8);
1322 /* Allocate TDO buffer if required */
1323 if ((type
== SCAN_IN
) || (type
== SCAN_IO
)) {
1324 tdo_buffer_start
= calloc(sizeof(uint8_t), scan_size_bytes
);
1326 if (tdo_buffer_start
== NULL
) {
1330 tdo_buffer
= tdo_buffer_start
;
1333 /* Fill TDI buffer if required */
1334 if ((type
== SCAN_OUT
) || (type
== SCAN_IO
)) {
1335 jtag_build_buffer(cmd
->cmd
.scan
, &tdi_buffer_start
);
1336 tdi_buffer
= tdi_buffer_start
;
1339 /* Get TAP state transitions */
1340 if (cmd
->cmd
.scan
->ir_scan
) {
1341 ulink_set_end_state(TAP_IRSHIFT
);
1342 first_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1343 first_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1345 tap_set_state(TAP_IRSHIFT
);
1346 tap_set_end_state(cmd
->cmd
.scan
->end_state
);
1347 last_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1348 last_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1350 /* TAP state transitions for split scans */
1351 tms_count_pause
= tap_get_tms_path_len(TAP_IRSHIFT
, TAP_IRPAUSE
);
1352 tms_sequence_pause
= tap_get_tms_path(TAP_IRSHIFT
, TAP_IRPAUSE
);
1353 tms_count_resume
= tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRSHIFT
);
1354 tms_sequence_resume
= tap_get_tms_path(TAP_IRPAUSE
, TAP_IRSHIFT
);
1357 ulink_set_end_state(TAP_DRSHIFT
);
1358 first_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1359 first_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1361 tap_set_state(TAP_DRSHIFT
);
1362 tap_set_end_state(cmd
->cmd
.scan
->end_state
);
1363 last_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1364 last_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1366 /* TAP state transitions for split scans */
1367 tms_count_pause
= tap_get_tms_path_len(TAP_DRSHIFT
, TAP_DRPAUSE
);
1368 tms_sequence_pause
= tap_get_tms_path(TAP_DRSHIFT
, TAP_DRPAUSE
);
1369 tms_count_resume
= tap_get_tms_path_len(TAP_DRPAUSE
, TAP_DRSHIFT
);
1370 tms_sequence_resume
= tap_get_tms_path(TAP_DRPAUSE
, TAP_DRSHIFT
);
1373 /* Generate scan commands */
1374 bytecount
= scan_size_bytes
;
1375 while (bytecount
> 0) {
1376 if (bytecount
== scan_size_bytes
) {
1377 /* This is the first scan */
1378 tms_count_start
= first_tms_count
;
1379 tms_sequence_start
= first_tms_sequence
;
1382 /* Resume from previous scan */
1383 tms_count_start
= tms_count_resume
;
1384 tms_sequence_start
= tms_sequence_resume
;
1387 if (bytecount
> 58) { /* Full scan, at least one scan will follow */
1388 tms_count_end
= tms_count_pause
;
1389 tms_sequence_end
= tms_sequence_pause
;
1391 ret
= ulink_append_scan_cmd(device
, type
, 58 * 8, tdi_buffer
,
1392 tdo_buffer_start
, tdo_buffer
, tms_count_start
, tms_sequence_start
,
1393 tms_count_end
, tms_sequence_end
, cmd
, false);
1397 /* Update TDI and TDO buffer pointers */
1398 if (tdi_buffer_start
!= NULL
) {
1401 if (tdo_buffer_start
!= NULL
) {
1405 else if (bytecount
== 58) { /* Full scan, no further scans */
1406 tms_count_end
= last_tms_count
;
1407 tms_sequence_end
= last_tms_sequence
;
1409 ret
= ulink_append_scan_cmd(device
, type
, 58 * 8, tdi_buffer
,
1410 tdo_buffer_start
, tdo_buffer
, tms_count_start
, tms_sequence_start
,
1411 tms_count_end
, tms_sequence_end
, cmd
, true);
1415 else { /* Scan with less than maximum payload, no further scans */
1416 tms_count_end
= last_tms_count
;
1417 tms_sequence_end
= last_tms_sequence
;
1419 ret
= ulink_append_scan_cmd(device
, type
, bits_last_scan
, tdi_buffer
,
1420 tdo_buffer_start
, tdo_buffer
, tms_count_start
, tms_sequence_start
,
1421 tms_count_end
, tms_sequence_end
, cmd
, true);
1426 if (ret
!= ERROR_OK
) {
1427 free(tdi_buffer_start
);
1432 free(tdi_buffer_start
);
1434 /* Set current state to the end state requested by the command */
1435 tap_set_state(cmd
->cmd
.scan
->end_state
);
1441 * Move the TAP into the Test Logic Reset state.
1443 * @param device pointer to struct ulink identifying ULINK driver instance.
1444 * @param cmd pointer to the command that shall be executed.
1445 * @return on success: ERROR_OK
1446 * @return on failure: ERROR_FAIL
1448 int ulink_queue_tlr_reset(struct ulink
*device
, struct jtag_command
*cmd
)
1452 ret
= ulink_append_clock_tms_cmd(device
, 5, 0xff);
1454 if (ret
== ERROR_OK
) {
1455 tap_set_state(TAP_RESET
);
1464 * Generate TCK clock cycles while remaining
1465 * in the Run-Test/Idle state.
1467 * @param device pointer to struct ulink identifying ULINK driver instance.
1468 * @param cmd pointer to the command that shall be executed.
1469 * @return on success: ERROR_OK
1470 * @return on failure: ERROR_FAIL
1472 int ulink_queue_runtest(struct ulink
*device
, struct jtag_command
*cmd
)
1476 /* Only perform statemove if the TAP currently isn't in the TAP_IDLE state */
1477 if (tap_get_state() != TAP_IDLE
) {
1478 ulink_set_end_state(TAP_IDLE
);
1479 ulink_queue_statemove(device
);
1482 /* Generate the clock cycles */
1483 ret
= ulink_append_clock_tck_cmd(device
, cmd
->cmd
.runtest
->num_cycles
);
1484 if (ret
!= ERROR_OK
) {
1488 /* Move to end state specified in command */
1489 if (cmd
->cmd
.runtest
->end_state
!= tap_get_state()) {
1490 tap_set_end_state(cmd
->cmd
.runtest
->end_state
);
1491 ulink_queue_statemove(device
);
1498 * Execute a JTAG_RESET command
1500 * @param cmd pointer to the command that shall be executed.
1501 * @return on success: ERROR_OK
1502 * @return on failure: ERROR_FAIL
1504 int ulink_queue_reset(struct ulink
*device
, struct jtag_command
*cmd
)
1506 uint8_t low
= 0, high
= 0;
1508 if (cmd
->cmd
.reset
->trst
) {
1509 tap_set_state(TAP_RESET
);
1510 high
|= SIGNAL_TRST
;
1516 if (cmd
->cmd
.reset
->srst
) {
1517 high
|= SIGNAL_RESET
;
1520 low
|= SIGNAL_RESET
;
1523 return ulink_append_set_signals_cmd(device
, low
, high
);
1527 * Move to one TAP state or several states in succession.
1529 * @param device pointer to struct ulink identifying ULINK driver instance.
1530 * @param cmd pointer to the command that shall be executed.
1531 * @return on success: ERROR_OK
1532 * @return on failure: ERROR_FAIL
1534 int ulink_queue_pathmove(struct ulink
*device
, struct jtag_command
*cmd
)
1536 // TODO: Implement this!
1541 * Sleep for a specific amount of time.
1543 * @param device pointer to struct ulink identifying ULINK driver instance.
1544 * @param cmd pointer to the command that shall be executed.
1545 * @return on success: ERROR_OK
1546 * @return on failure: ERROR_FAIL
1548 int ulink_queue_sleep(struct ulink
*device
, struct jtag_command
*cmd
)
1550 /* IMPORTANT! Due to the time offset in command execution introduced by
1551 * command queueing, this needs to be implemented in the ULINK device */
1552 return ulink_append_sleep_cmd(device
, cmd
->cmd
.sleep
->us
);
1556 * Generate TCK cycles while remaining in a stable state.
1558 * @param device pointer to struct ulink identifying ULINK driver instance.
1559 * @param cmd pointer to the command that shall be executed.
1561 int ulink_queue_stableclocks(struct ulink
*device
, struct jtag_command
*cmd
)
1564 unsigned num_cycles
;
1566 if (!tap_is_state_stable(tap_get_state())) {
1567 LOG_ERROR("JTAG_STABLECLOCKS: state not stable");
1571 num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
1573 /* TMS stays either high (Test Logic Reset state) or low (all other states) */
1574 if (tap_get_state() == TAP_RESET
) {
1575 ret
= ulink_append_set_signals_cmd(device
, 0, SIGNAL_TMS
);
1578 ret
= ulink_append_set_signals_cmd(device
, SIGNAL_TMS
, 0);
1581 if (ret
!= ERROR_OK
) {
1585 while (num_cycles
> 0) {
1586 if (num_cycles
> 0xFFFF) {
1587 /* OpenULINK CMD_CLOCK_TCK can generate up to 0xFFFF (uint16_t) cycles */
1588 ret
= ulink_append_clock_tck_cmd(device
, 0xFFFF);
1589 num_cycles
-= 0xFFFF;
1592 ret
= ulink_append_clock_tck_cmd(device
, num_cycles
);
1596 if (ret
!= ERROR_OK
) {
1605 * Post-process JTAG_SCAN command
1607 * @param ulink_cmd pointer to OpenULINK command that shall be processed.
1608 * @return on success: ERROR_OK
1609 * @return on failure: ERROR_FAIL
1611 int ulink_post_process_scan(ulink_cmd_t
*ulink_cmd
)
1613 struct jtag_command
*cmd
= ulink_cmd
->cmd_origin
;
1616 switch (jtag_scan_type(cmd
->cmd
.scan
)) {
1619 ret
= jtag_read_buffer(ulink_cmd
->payload_in_start
, cmd
->cmd
.scan
);
1622 /* Nothing to do for OUT scans */
1626 LOG_ERROR("BUG: ulink_post_process_scan() encountered an unknown"
1636 * Perform post-processing of commands after OpenULINK queue has been executed.
1638 * @param device pointer to struct ulink identifying ULINK driver instance.
1639 * @return on success: ERROR_OK
1640 * @return on failure: ERROR_FAIL
1642 int ulink_post_process_queue(struct ulink
*device
)
1644 ulink_cmd_t
*current
;
1645 struct jtag_command
*openocd_cmd
;
1648 current
= device
->queue_start
;
1650 while (current
!= NULL
) {
1651 openocd_cmd
= current
->cmd_origin
;
1653 /* Check if a corresponding OpenOCD command is stored for this
1654 * OpenULINK command */
1655 if ((current
->needs_postprocessing
== true) && (openocd_cmd
!= NULL
)) {
1656 switch (openocd_cmd
->type
) {
1658 ret
= ulink_post_process_scan(current
);
1660 case JTAG_TLR_RESET
:
1665 case JTAG_STABLECLOCKS
:
1666 /* Nothing to do for these commands */
1671 LOG_ERROR("BUG: ulink_post_process_queue() encountered unknown JTAG "
1676 if (ret
!= ERROR_OK
) {
1681 current
= current
->next
;
1687 /**************************** JTAG driver functions ***************************/
1690 * Executes the JTAG Command Queue.
1692 * This is done in three stages: First, all OpenOCD commands are processed into
1693 * queued OpenULINK commands. Next, the OpenULINK command queue is sent to the
1694 * ULINK device and data received from the ULINK device is cached. Finally,
1695 * the post-processing function writes back data to the corresponding OpenOCD
1698 * @return on success: ERROR_OK
1699 * @return on failure: ERROR_FAIL
1701 static int ulink_execute_queue(void)
1703 struct jtag_command
*cmd
= jtag_command_queue
;
1707 switch (cmd
->type
) {
1709 ret
= ulink_queue_scan(ulink_handle
, cmd
);
1711 case JTAG_TLR_RESET
:
1712 ret
= ulink_queue_tlr_reset(ulink_handle
, cmd
);
1715 ret
= ulink_queue_runtest(ulink_handle
, cmd
);
1718 ret
= ulink_queue_reset(ulink_handle
, cmd
);
1721 ret
= ulink_queue_pathmove(ulink_handle
, cmd
);
1724 ret
= ulink_queue_sleep(ulink_handle
, cmd
);
1726 case JTAG_STABLECLOCKS
:
1727 ret
= ulink_queue_stableclocks(ulink_handle
, cmd
);
1731 LOG_ERROR("BUG: encountered unknown JTAG command type");
1735 if (ret
!= ERROR_OK
) {
1742 if (ulink_handle
->commands_in_queue
> 0) {
1743 ret
= ulink_execute_queued_commands(ulink_handle
, USB_TIMEOUT
);
1744 if (ret
!= ERROR_OK
) {
1748 ret
= ulink_post_process_queue(ulink_handle
);
1749 if (ret
!= ERROR_OK
) {
1753 ulink_clear_queue(ulink_handle
);
1760 * Set the TCK frequency of the ULINK adapter.
1763 * @param jtag_speed ???
1764 * @return on success: ERROR_OK
1765 * @return on failure: ERROR_FAIL
1767 static int ulink_khz(int khz
, int *jtag_speed
)
1770 LOG_ERROR("RCLK not supported");
1774 LOG_INFO("ulink_khz: %i kHz", khz
);
1776 /* ULINK maximum TCK frequency is ~ 150 kHz */
1787 * Set the TCK frequency of the ULINK adapter.
1790 * @return on success: ERROR_OK
1791 * @return on failure: ERROR_FAIL
1793 static int ulink_speed(int speed
)
1801 static int ulink_speed_div(int speed
, int *khz
)
1803 LOG_INFO("ulink_speed_div: %i", speed
);
1818 * Initiates the firmware download to the ULINK adapter and prepares
1821 * @return on success: ERROR_OK
1822 * @return on failure: ERROR_FAIL
1824 static int ulink_init(void)
1827 char str_manufacturer
[20];
1828 bool download_firmware
= false;
1830 uint8_t input_signals
, output_signals
;
1832 ulink_handle
= calloc(1, sizeof(struct ulink
));
1833 if (ulink_handle
== NULL
) {
1839 ret
= ulink_usb_open(&ulink_handle
);
1840 if (ret
!= ERROR_OK
) {
1841 LOG_ERROR("Could not open ULINK device");
1845 /* Get String Descriptor to determine if firmware needs to be loaded */
1846 ret
= usb_get_string_simple(ulink_handle
->usb_handle
, 1, str_manufacturer
, 20);
1848 /* Could not get descriptor -> Unconfigured or original Keil firmware */
1849 download_firmware
= true;
1852 /* We got a String Descriptor, check if it is the correct one */
1853 if (strncmp(str_manufacturer
, "OpenULINK", 9) != 0) {
1854 download_firmware
= true;
1858 if (download_firmware
== true) {
1859 LOG_INFO("Loading OpenULINK firmware. This is reversible by power-cycling"
1861 ret
= ulink_load_firmware_and_renumerate(&ulink_handle
,
1862 ULINK_FIRMWARE_FILE
, ULINK_RENUMERATION_DELAY
);
1863 if (ret
!= ERROR_OK
) {
1864 LOG_ERROR("Could not download firmware and re-numerate ULINK");
1869 LOG_INFO("ULINK device is already running OpenULINK firmware");
1872 /* Initialize OpenULINK command queue */
1873 ulink_clear_queue(ulink_handle
);
1875 /* Issue one test command with short timeout */
1876 ret
= ulink_append_test_cmd(ulink_handle
);
1877 if (ret
!= ERROR_OK
) {
1881 ret
= ulink_execute_queued_commands(ulink_handle
, 200);
1882 if (ret
!= ERROR_OK
) {
1883 /* Sending test command failed. The ULINK device may be forever waiting for
1884 * the host to fetch an USB Bulk IN packet (e. g. OpenOCD crashed or was
1885 * shut down by the user via Ctrl-C. Try to retrieve this Bulk IN packet. */
1886 dummy
= calloc(64, sizeof(uint8_t));
1888 ret
= usb_bulk_read(ulink_handle
->usb_handle
, (2 | USB_ENDPOINT_IN
),
1889 (char *)dummy
, 64, 200);
1894 /* Bulk IN transfer failed -> unrecoverable error condition */
1895 LOG_ERROR("Cannot communicate with ULINK device. Disconnect ULINK from "
1896 "the USB port and re-connect, then re-run OpenOCD");
1899 #ifdef _DEBUG_USB_COMMS_
1901 /* Successfully received Bulk IN packet -> continue */
1902 LOG_INFO("Recovered from lost Bulk IN packet");
1906 ulink_clear_queue(ulink_handle
);
1908 ulink_append_get_signals_cmd(ulink_handle
);
1909 ulink_execute_queued_commands(ulink_handle
, 200);
1911 /* Post-process the single CMD_GET_SIGNALS command */
1912 input_signals
= ulink_handle
->queue_start
->payload_in
[0];
1913 output_signals
= ulink_handle
->queue_start
->payload_in
[1];
1915 ulink_print_signal_states(input_signals
, output_signals
);
1917 ulink_clear_queue(ulink_handle
);
1923 * Closes the USB handle for the ULINK device.
1925 * @return on success: ERROR_OK
1926 * @return on failure: ERROR_FAIL
1928 static int ulink_quit(void)
1932 ret
= ulink_usb_close(&ulink_handle
);
1939 * Set a custom path to ULINK firmware image and force downloading to ULINK.
1941 COMMAND_HANDLER(ulink_download_firmware_handler
)
1945 if (CMD_ARGC
!= 1) {
1946 LOG_ERROR("Need exactly one argument to ulink_download_firmware");
1950 LOG_INFO("Downloading ULINK firmware image %s", CMD_ARGV
[0]);
1952 /* Download firmware image in CMD_ARGV[0] */
1953 ret
= ulink_load_firmware_and_renumerate(&ulink_handle
, (char *)CMD_ARGV
[0],
1954 ULINK_RENUMERATION_DELAY
);
1959 /*************************** Command Registration **************************/
1961 static const struct command_registration ulink_command_handlers
[] = {
1963 .name
= "ulink_download_firmware",
1964 .handler
= &ulink_download_firmware_handler
,
1965 .mode
= COMMAND_EXEC
,
1966 .help
= "download firmware image to ULINK device",
1967 .usage
= "path/to/ulink_firmware.hex",
1969 COMMAND_REGISTRATION_DONE
,
1972 struct jtag_interface ulink_interface
= {
1975 .commands
= ulink_command_handlers
,
1976 .transports
= jtag_only
,
1978 .execute_queue
= ulink_execute_queue
,
1980 .speed
= ulink_speed
,
1981 .speed_div
= ulink_speed_div
,
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)