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 "OpenULINK/include/msgtypes.h"
30 /** USB Vendor ID of ULINK device in unconfigured state (no firmware loaded
31 * yet) or with OpenULINK firmware. */
32 #define ULINK_VID 0xC251
34 /** USB Product ID of ULINK device in unconfigured state (no firmware loaded
35 * yet) or with OpenULINK firmware. */
36 #define ULINK_PID 0x2710
38 /** Address of EZ-USB CPU Control & Status register. This register can be
39 * written by issuing a Control EP0 vendor request. */
40 #define CPUCS_REG 0x7F92
42 /** USB Control EP0 bRequest: "Firmware Load". */
43 #define REQUEST_FIRMWARE_LOAD 0xA0
45 /** Value to write into CPUCS to put EZ-USB into reset. */
46 #define CPU_RESET 0x01
48 /** Value to write into CPUCS to put EZ-USB out of reset. */
49 #define CPU_START 0x00
51 /** Base address of firmware in EZ-USB code space. */
52 #define FIRMWARE_ADDR 0x0000
54 /** USB interface number */
55 #define USB_INTERFACE 0
57 /** libusb timeout in ms */
58 #define USB_TIMEOUT 5000
60 /** Delay (in microseconds) to wait while EZ-USB performs ReNumeration. */
61 #define ULINK_RENUMERATION_DELAY 1500000
63 /** Default location of OpenULINK firmware image. */
64 #define ULINK_FIRMWARE_FILE PKGDATADIR "/OpenULINK/ulink_firmware.hex"
66 /** Maximum size of a single firmware section. Entire EZ-USB code space = 8kB */
67 #define SECTION_BUFFERSIZE 8192
69 /** Tuning of OpenOCD SCAN commands split into multiple OpenULINK commands. */
70 #define SPLIT_SCAN_THRESHOLD 10
72 /** ULINK hardware type */
74 /** Original ULINK adapter, based on Cypress EZ-USB (AN2131):
75 * Full JTAG support, no SWD support. */
78 /** Newer ULINK adapter, based on NXP LPC2148. Currently unsupported. */
81 /** Newer ULINK adapter, based on EZ-USB FX2 + FPGA. Currently unsupported. */
84 /** Newer ULINK adapter, possibly based on ULINK 2. Currently unsupported. */
88 enum ulink_payload_direction
{
89 PAYLOAD_DIRECTION_OUT
,
93 enum ulink_delay_type
{
102 * OpenULINK command (OpenULINK command queue element).
104 * For the OUT direction payload, things are quite easy: Payload is stored
105 * in a rather small array (up to 63 bytes), the payload is always allocated
106 * by the function generating the command and freed by ulink_clear_queue().
108 * For the IN direction payload, things get a little bit more complicated:
109 * The maximum IN payload size for a single command is 64 bytes. Assume that
110 * a single OpenOCD command needs to scan 256 bytes. This results in the
111 * generation of four OpenULINK commands. The function generating these
112 * commands shall allocate an uint8_t[256] array. Each command's #payload_in
113 * pointer shall point to the corresponding offset where IN data shall be
114 * placed, while #payload_in_start shall point to the first element of the 256
116 * - first command: #payload_in_start + 0
117 * - second command: #payload_in_start + 64
118 * - third command: #payload_in_start + 128
119 * - fourth command: #payload_in_start + 192
121 * The last command sets #needs_postprocessing to true.
124 uint8_t id
; /**< ULINK command ID */
126 uint8_t *payload_out
; /**< OUT direction payload data */
127 uint8_t payload_out_size
; /**< OUT direction payload size for this command */
129 uint8_t *payload_in_start
; /**< Pointer to first element of IN payload array */
130 uint8_t *payload_in
; /**< Pointer where IN payload shall be stored */
131 uint8_t payload_in_size
; /**< IN direction payload size for this command */
133 /** Indicates if this command needs post-processing */
134 bool needs_postprocessing
;
136 /** Indicates if ulink_clear_queue() should free payload_in_start */
137 bool free_payload_in_start
;
139 /** Pointer to corresponding OpenOCD command for post-processing */
140 struct jtag_command
*cmd_origin
;
142 struct ulink_cmd
*next
; /**< Pointer to next command (linked list) */
145 /** Describes one driver instance */
147 struct libusb_context
*libusb_ctx
;
148 struct libusb_device_handle
*usb_device_handle
;
149 enum ulink_type type
;
151 int delay_scan_in
; /**< Delay value for SCAN_IN commands */
152 int delay_scan_out
; /**< Delay value for SCAN_OUT commands */
153 int delay_scan_io
; /**< Delay value for SCAN_IO commands */
154 int delay_clock_tck
; /**< Delay value for CLOCK_TMS commands */
155 int delay_clock_tms
; /**< Delay value for CLOCK_TCK commands */
157 int commands_in_queue
; /**< Number of commands in queue */
158 struct ulink_cmd
*queue_start
; /**< Pointer to first command in queue */
159 struct ulink_cmd
*queue_end
; /**< Pointer to last command in queue */
162 /**************************** Function Prototypes *****************************/
164 /* USB helper functions */
165 int ulink_usb_open(struct ulink
**device
);
166 int ulink_usb_close(struct ulink
**device
);
168 /* ULINK MCU (Cypress EZ-USB) specific functions */
169 int ulink_cpu_reset(struct ulink
*device
, unsigned char reset_bit
);
170 int ulink_load_firmware_and_renumerate(struct ulink
**device
, const char *filename
,
172 int ulink_load_firmware(struct ulink
*device
, const char *filename
);
173 int ulink_write_firmware_section(struct ulink
*device
,
174 struct image
*firmware_image
, int section_index
);
176 /* Generic helper functions */
177 void ulink_print_signal_states(uint8_t input_signals
, uint8_t output_signals
);
179 /* OpenULINK command generation helper functions */
180 int ulink_allocate_payload(struct ulink_cmd
*ulink_cmd
, int size
,
181 enum ulink_payload_direction direction
);
183 /* OpenULINK command queue helper functions */
184 int ulink_get_queue_size(struct ulink
*device
,
185 enum ulink_payload_direction direction
);
186 void ulink_clear_queue(struct ulink
*device
);
187 int ulink_append_queue(struct ulink
*device
, struct ulink_cmd
*ulink_cmd
);
188 int ulink_execute_queued_commands(struct ulink
*device
, int timeout
);
190 static void ulink_print_queue(struct ulink
*device
);
192 int ulink_append_scan_cmd(struct ulink
*device
,
193 enum scan_type scan_type
,
198 uint8_t tms_count_start
,
199 uint8_t tms_sequence_start
,
200 uint8_t tms_count_end
,
201 uint8_t tms_sequence_end
,
202 struct jtag_command
*origin
,
204 int ulink_append_clock_tms_cmd(struct ulink
*device
, uint8_t count
,
206 int ulink_append_clock_tck_cmd(struct ulink
*device
, uint16_t count
);
207 int ulink_append_get_signals_cmd(struct ulink
*device
);
208 int ulink_append_set_signals_cmd(struct ulink
*device
, uint8_t low
,
210 int ulink_append_sleep_cmd(struct ulink
*device
, uint32_t us
);
211 int ulink_append_configure_tck_cmd(struct ulink
*device
,
217 int ulink_append_led_cmd(struct ulink
*device
, uint8_t led_state
);
218 int ulink_append_test_cmd(struct ulink
*device
);
220 /* OpenULINK TCK frequency helper functions */
221 int ulink_calculate_delay(enum ulink_delay_type type
, long f
, int *delay
);
223 /* Interface between OpenULINK and OpenOCD */
224 static void ulink_set_end_state(tap_state_t endstate
);
225 int ulink_queue_statemove(struct ulink
*device
);
227 int ulink_queue_scan(struct ulink
*device
, struct jtag_command
*cmd
);
228 int ulink_queue_tlr_reset(struct ulink
*device
, struct jtag_command
*cmd
);
229 int ulink_queue_runtest(struct ulink
*device
, struct jtag_command
*cmd
);
230 int ulink_queue_reset(struct ulink
*device
, struct jtag_command
*cmd
);
231 int ulink_queue_pathmove(struct ulink
*device
, struct jtag_command
*cmd
);
232 int ulink_queue_sleep(struct ulink
*device
, struct jtag_command
*cmd
);
233 int ulink_queue_stableclocks(struct ulink
*device
, struct jtag_command
*cmd
);
235 int ulink_post_process_scan(struct ulink_cmd
*ulink_cmd
);
236 int ulink_post_process_queue(struct ulink
*device
);
238 /* adapter driver functions */
239 static int ulink_execute_queue(void);
240 static int ulink_khz(int khz
, int *jtag_speed
);
241 static int ulink_speed(int speed
);
242 static int ulink_speed_div(int speed
, int *khz
);
243 static int ulink_init(void);
244 static int ulink_quit(void);
246 /****************************** Global Variables ******************************/
248 struct ulink
*ulink_handle
;
250 /**************************** USB helper functions ****************************/
253 * Opens the ULINK device and claims its USB interface.
255 * Currently, only the original ULINK is supported
257 * @param device pointer to struct ulink identifying ULINK driver instance.
258 * @return on success: ERROR_OK
259 * @return on failure: ERROR_FAIL
261 int ulink_usb_open(struct ulink
**device
)
263 ssize_t num_devices
, i
;
265 libusb_device
**usb_devices
;
266 struct libusb_device_descriptor usb_desc
;
267 struct libusb_device_handle
*usb_device_handle
;
269 num_devices
= libusb_get_device_list((*device
)->libusb_ctx
, &usb_devices
);
271 if (num_devices
<= 0)
275 for (i
= 0; i
< num_devices
; i
++) {
276 if (libusb_get_device_descriptor(usb_devices
[i
], &usb_desc
) != 0)
278 else if (usb_desc
.idVendor
== ULINK_VID
&& usb_desc
.idProduct
== ULINK_PID
) {
287 if (libusb_open(usb_devices
[i
], &usb_device_handle
) != 0)
289 libusb_free_device_list(usb_devices
, 1);
291 if (libusb_claim_interface(usb_device_handle
, 0) != 0)
294 (*device
)->usb_device_handle
= usb_device_handle
;
295 (*device
)->type
= ULINK_1
;
301 * Releases the ULINK interface and closes the USB device handle.
303 * @param device pointer to struct ulink identifying ULINK driver instance.
304 * @return on success: ERROR_OK
305 * @return on failure: ERROR_FAIL
307 int ulink_usb_close(struct ulink
**device
)
309 if (libusb_release_interface((*device
)->usb_device_handle
, 0) != 0)
312 libusb_close((*device
)->usb_device_handle
);
314 (*device
)->usb_device_handle
= NULL
;
319 /******************* ULINK CPU (EZ-USB) specific functions ********************/
322 * Writes '0' or '1' to the CPUCS register, putting the EZ-USB CPU into reset
325 * @param device pointer to struct ulink identifying ULINK driver instance.
326 * @param reset_bit 0 to put CPU into reset, 1 to put CPU out of reset.
327 * @return on success: ERROR_OK
328 * @return on failure: ERROR_FAIL
330 int ulink_cpu_reset(struct ulink
*device
, unsigned char reset_bit
)
334 ret
= libusb_control_transfer(device
->usb_device_handle
,
335 (LIBUSB_ENDPOINT_OUT
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
),
336 REQUEST_FIRMWARE_LOAD
, CPUCS_REG
, 0, &reset_bit
, 1, USB_TIMEOUT
);
338 /* usb_control_msg() returns the number of bytes transferred during the
339 * DATA stage of the control transfer - must be exactly 1 in this case! */
346 * Puts the ULINK's EZ-USB microcontroller into reset state, downloads
347 * the firmware image, resumes the microcontroller and re-enumerates
350 * @param device pointer to struct ulink identifying ULINK driver instance.
351 * The usb_handle member will be modified during re-enumeration.
352 * @param filename path to the Intel HEX file containing the firmware image.
353 * @param delay the delay to wait for the device to re-enumerate.
354 * @return on success: ERROR_OK
355 * @return on failure: ERROR_FAIL
357 int ulink_load_firmware_and_renumerate(struct ulink
**device
,
358 const char *filename
, uint32_t delay
)
362 /* Basic process: After downloading the firmware, the ULINK will disconnect
363 * itself and re-connect after a short amount of time so we have to close
364 * the handle and re-enumerate USB devices */
366 ret
= ulink_load_firmware(*device
, filename
);
370 ret
= ulink_usb_close(device
);
376 ret
= ulink_usb_open(device
);
384 * Downloads a firmware image to the ULINK's EZ-USB microcontroller
387 * @param device pointer to struct ulink identifying ULINK driver instance.
388 * @param filename an absolute or relative path to the Intel HEX file
389 * containing the firmware image.
390 * @return on success: ERROR_OK
391 * @return on failure: ERROR_FAIL
393 int ulink_load_firmware(struct ulink
*device
, const char *filename
)
395 struct image ulink_firmware_image
;
398 ret
= ulink_cpu_reset(device
, CPU_RESET
);
399 if (ret
!= ERROR_OK
) {
400 LOG_ERROR("Could not halt ULINK CPU");
404 ulink_firmware_image
.base_address
= 0;
405 ulink_firmware_image
.base_address_set
= 0;
407 ret
= image_open(&ulink_firmware_image
, filename
, "ihex");
408 if (ret
!= ERROR_OK
) {
409 LOG_ERROR("Could not load firmware image");
413 /* Download all sections in the image to ULINK */
414 for (i
= 0; i
< ulink_firmware_image
.num_sections
; i
++) {
415 ret
= ulink_write_firmware_section(device
, &ulink_firmware_image
, i
);
420 image_close(&ulink_firmware_image
);
422 ret
= ulink_cpu_reset(device
, CPU_START
);
423 if (ret
!= ERROR_OK
) {
424 LOG_ERROR("Could not restart ULINK CPU");
432 * Send one contiguous firmware section to the ULINK's EZ-USB microcontroller
435 * @param device pointer to struct ulink identifying ULINK driver instance.
436 * @param firmware_image pointer to the firmware image that contains the section
437 * which should be sent to the ULINK's EZ-USB microcontroller.
438 * @param section_index index of the section within the firmware image.
439 * @return on success: ERROR_OK
440 * @return on failure: ERROR_FAIL
442 int ulink_write_firmware_section(struct ulink
*device
,
443 struct image
*firmware_image
, int section_index
)
445 uint16_t addr
, size
, bytes_remaining
, chunk_size
;
446 uint8_t data
[SECTION_BUFFERSIZE
];
447 uint8_t *data_ptr
= data
;
451 size
= (uint16_t)firmware_image
->sections
[section_index
].size
;
452 addr
= (uint16_t)firmware_image
->sections
[section_index
].base_address
;
454 LOG_DEBUG("section %02i at addr 0x%04x (size 0x%04x)", section_index
, addr
,
457 /* Copy section contents to local buffer */
458 ret
= image_read_section(firmware_image
, section_index
, 0, size
, data
,
461 if ((ret
!= ERROR_OK
) || (size_read
!= size
)) {
462 /* Propagating the return code would return '0' (misleadingly indicating
463 * successful execution of the function) if only the size check fails. */
467 bytes_remaining
= size
;
469 /* Send section data in chunks of up to 64 bytes to ULINK */
470 while (bytes_remaining
> 0) {
471 if (bytes_remaining
> 64)
474 chunk_size
= bytes_remaining
;
476 ret
= libusb_control_transfer(device
->usb_device_handle
,
477 (LIBUSB_ENDPOINT_OUT
| LIBUSB_REQUEST_TYPE_VENDOR
| LIBUSB_RECIPIENT_DEVICE
),
478 REQUEST_FIRMWARE_LOAD
, addr
, FIRMWARE_ADDR
, (unsigned char *)data_ptr
,
479 chunk_size
, USB_TIMEOUT
);
481 if (ret
!= (int)chunk_size
) {
482 /* Abort if libusb sent less data than requested */
486 bytes_remaining
-= chunk_size
;
488 data_ptr
+= chunk_size
;
494 /************************** Generic helper functions **************************/
497 * Print state of interesting signals via LOG_INFO().
499 * @param input_signals input signal states as returned by CMD_GET_SIGNALS
500 * @param output_signals output signal states as returned by CMD_GET_SIGNALS
502 void ulink_print_signal_states(uint8_t input_signals
, uint8_t output_signals
)
504 LOG_INFO("ULINK signal states: TDI: %i, TDO: %i, TMS: %i, TCK: %i, TRST: %i,"
506 (output_signals
& SIGNAL_TDI
? 1 : 0),
507 (input_signals
& SIGNAL_TDO
? 1 : 0),
508 (output_signals
& SIGNAL_TMS
? 1 : 0),
509 (output_signals
& SIGNAL_TCK
? 1 : 0),
510 (output_signals
& SIGNAL_TRST
? 0 : 1), /* Inverted by hardware */
511 (output_signals
& SIGNAL_RESET
? 0 : 1)); /* Inverted by hardware */
514 /**************** OpenULINK command generation helper functions ***************/
517 * Allocate and initialize space in memory for OpenULINK command payload.
519 * @param ulink_cmd pointer to command whose payload should be allocated.
520 * @param size the amount of memory to allocate (bytes).
521 * @param direction which payload to allocate.
522 * @return on success: ERROR_OK
523 * @return on failure: ERROR_FAIL
525 int ulink_allocate_payload(struct ulink_cmd
*ulink_cmd
, int size
,
526 enum ulink_payload_direction direction
)
530 payload
= calloc(size
, sizeof(uint8_t));
532 if (payload
== NULL
) {
533 LOG_ERROR("Could not allocate OpenULINK command payload: out of memory");
538 case PAYLOAD_DIRECTION_OUT
:
539 if (ulink_cmd
->payload_out
!= NULL
) {
540 LOG_ERROR("BUG: Duplicate payload allocation for OpenULINK command");
544 ulink_cmd
->payload_out
= payload
;
545 ulink_cmd
->payload_out_size
= size
;
548 case PAYLOAD_DIRECTION_IN
:
549 if (ulink_cmd
->payload_in_start
!= NULL
) {
550 LOG_ERROR("BUG: Duplicate payload allocation for OpenULINK command");
554 ulink_cmd
->payload_in_start
= payload
;
555 ulink_cmd
->payload_in
= payload
;
556 ulink_cmd
->payload_in_size
= size
;
558 /* By default, free payload_in_start in ulink_clear_queue(). Commands
559 * that do not want this behavior (e. g. split scans) must turn it off
561 ulink_cmd
->free_payload_in_start
= true;
569 /****************** OpenULINK command queue helper functions ******************/
572 * Get the current number of bytes in the queue, including command IDs.
574 * @param device pointer to struct ulink identifying ULINK driver instance.
575 * @param direction the transfer direction for which to get byte count.
576 * @return the number of bytes currently stored in the queue for the specified
579 int ulink_get_queue_size(struct ulink
*device
,
580 enum ulink_payload_direction direction
)
582 struct ulink_cmd
*current
= device
->queue_start
;
585 while (current
!= NULL
) {
587 case PAYLOAD_DIRECTION_OUT
:
588 sum
+= current
->payload_out_size
+ 1; /* + 1 byte for Command ID */
590 case PAYLOAD_DIRECTION_IN
:
591 sum
+= current
->payload_in_size
;
595 current
= current
->next
;
602 * Clear the OpenULINK command queue.
604 * @param device pointer to struct ulink identifying ULINK driver instance.
605 * @return on success: ERROR_OK
606 * @return on failure: ERROR_FAIL
608 void ulink_clear_queue(struct ulink
*device
)
610 struct ulink_cmd
*current
= device
->queue_start
;
611 struct ulink_cmd
*next
= NULL
;
613 while (current
!= NULL
) {
614 /* Save pointer to next element */
615 next
= current
->next
;
617 /* Free payloads: OUT payload can be freed immediately */
618 free(current
->payload_out
);
619 current
->payload_out
= NULL
;
621 /* IN payload MUST be freed ONLY if no other commands use the
622 * payload_in_start buffer */
623 if (current
->free_payload_in_start
== true) {
624 free(current
->payload_in_start
);
625 current
->payload_in_start
= NULL
;
626 current
->payload_in
= NULL
;
629 /* Free queue element */
632 /* Proceed with next element */
636 device
->commands_in_queue
= 0;
637 device
->queue_start
= NULL
;
638 device
->queue_end
= NULL
;
642 * Add a command to the OpenULINK command queue.
644 * @param device pointer to struct ulink identifying ULINK driver instance.
645 * @param ulink_cmd pointer to command that shall be appended to the OpenULINK
647 * @return on success: ERROR_OK
648 * @return on failure: ERROR_FAIL
650 int ulink_append_queue(struct ulink
*device
, struct ulink_cmd
*ulink_cmd
)
652 int newsize_out
, newsize_in
;
655 newsize_out
= ulink_get_queue_size(device
, PAYLOAD_DIRECTION_OUT
) + 1
656 + ulink_cmd
->payload_out_size
;
658 newsize_in
= ulink_get_queue_size(device
, PAYLOAD_DIRECTION_IN
)
659 + ulink_cmd
->payload_in_size
;
661 /* Check if the current command can be appended to the queue */
662 if ((newsize_out
> 64) || (newsize_in
> 64)) {
663 /* New command does not fit. Execute all commands in queue before starting
664 * new queue with the current command as first entry. */
665 ret
= ulink_execute_queued_commands(device
, USB_TIMEOUT
);
668 ret
= ulink_post_process_queue(device
);
671 ulink_clear_queue(device
);
674 if (device
->queue_start
== NULL
) {
675 /* Queue was empty */
676 device
->commands_in_queue
= 1;
678 device
->queue_start
= ulink_cmd
;
679 device
->queue_end
= ulink_cmd
;
681 /* There are already commands in the queue */
682 device
->commands_in_queue
++;
684 device
->queue_end
->next
= ulink_cmd
;
685 device
->queue_end
= ulink_cmd
;
689 ulink_clear_queue(device
);
695 * Sends all queued OpenULINK commands to the ULINK for execution.
697 * @param device pointer to struct ulink identifying ULINK driver instance.
698 * @return on success: ERROR_OK
699 * @return on failure: ERROR_FAIL
701 int ulink_execute_queued_commands(struct ulink
*device
, int timeout
)
703 struct ulink_cmd
*current
;
704 int ret
, i
, index_out
, index_in
, count_out
, count_in
, transferred
;
707 if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO
))
708 ulink_print_queue(device
);
714 for (current
= device
->queue_start
; current
; current
= current
->next
) {
715 /* Add command to packet */
716 buffer
[index_out
] = current
->id
;
720 for (i
= 0; i
< current
->payload_out_size
; i
++)
721 buffer
[index_out
+ i
] = current
->payload_out
[i
];
722 index_out
+= current
->payload_out_size
;
723 count_in
+= current
->payload_in_size
;
724 count_out
+= current
->payload_out_size
;
727 /* Send packet to ULINK */
728 ret
= libusb_bulk_transfer(device
->usb_device_handle
, (2 | LIBUSB_ENDPOINT_OUT
),
729 (unsigned char *)buffer
, count_out
, &transferred
, timeout
);
732 if (transferred
!= count_out
)
735 /* Wait for response if commands contain IN payload data */
737 ret
= libusb_bulk_transfer(device
->usb_device_handle
, (2 | LIBUSB_ENDPOINT_IN
),
738 (unsigned char *)buffer
, 64, &transferred
, timeout
);
741 if (transferred
!= count_in
)
744 /* Write back IN payload data */
746 for (current
= device
->queue_start
; current
; current
= current
->next
) {
747 for (i
= 0; i
< current
->payload_in_size
; i
++) {
748 current
->payload_in
[i
] = buffer
[index_in
];
758 * Convert an OpenULINK command ID (\a id) to a human-readable string.
760 * @param id the OpenULINK command ID.
761 * @return the corresponding human-readable string.
763 static const char *ulink_cmd_id_string(uint8_t id
)
767 return "CMD_SCAN_IN";
769 case CMD_SLOW_SCAN_IN
:
770 return "CMD_SLOW_SCAN_IN";
773 return "CMD_SCAN_OUT";
775 case CMD_SLOW_SCAN_OUT
:
776 return "CMD_SLOW_SCAN_OUT";
779 return "CMD_SCAN_IO";
781 case CMD_SLOW_SCAN_IO
:
782 return "CMD_SLOW_SCAN_IO";
785 return "CMD_CLOCK_TMS";
787 case CMD_SLOW_CLOCK_TMS
:
788 return "CMD_SLOW_CLOCK_TMS";
791 return "CMD_CLOCK_TCK";
793 case CMD_SLOW_CLOCK_TCK
:
794 return "CMD_SLOW_CLOCK_TCK";
797 return "CMD_SLEEP_US";
800 return "CMD_SLEEP_MS";
802 case CMD_GET_SIGNALS
:
803 return "CMD_GET_SIGNALS";
805 case CMD_SET_SIGNALS
:
806 return "CMD_SET_SIGNALS";
808 case CMD_CONFIGURE_TCK_FREQ
:
809 return "CMD_CONFIGURE_TCK_FREQ";
812 return "CMD_SET_LEDS";
818 return "CMD_UNKNOWN";
824 * Print one OpenULINK command to stdout.
826 * @param ulink_cmd pointer to OpenULINK command.
828 static void ulink_print_command(struct ulink_cmd
*ulink_cmd
)
832 printf(" %-22s | OUT size = %i, bytes = 0x",
833 ulink_cmd_id_string(ulink_cmd
->id
), ulink_cmd
->payload_out_size
);
835 for (i
= 0; i
< ulink_cmd
->payload_out_size
; i
++)
836 printf("%02X ", ulink_cmd
->payload_out
[i
]);
837 printf("\n | IN size = %i\n",
838 ulink_cmd
->payload_in_size
);
842 * Print the OpenULINK command queue to stdout.
844 * @param device pointer to struct ulink identifying ULINK driver instance.
846 static void ulink_print_queue(struct ulink
*device
)
848 struct ulink_cmd
*current
;
850 printf("OpenULINK command queue:\n");
852 for (current
= device
->queue_start
; current
; current
= current
->next
)
853 ulink_print_command(current
);
859 * Creates and appends a JTAG scan command to the OpenULINK command queue.
860 * A JTAG scan consists of three steps:
861 * - Move to the desired SHIFT state, depending on scan type (IR/DR scan).
862 * - Shift TDI data into the JTAG chain, optionally reading the TDO pin.
863 * - Move to the desired end state.
865 * @param device pointer to struct ulink identifying ULINK driver instance.
866 * @param scan_type the type of the scan (IN, OUT, IO (bidirectional)).
867 * @param scan_size_bits number of bits to shift into the JTAG chain.
868 * @param tdi pointer to array containing TDI data.
869 * @param tdo_start pointer to first element of array where TDO data shall be
870 * stored. See #ulink_cmd for details.
871 * @param tdo pointer to array where TDO data shall be stored
872 * @param tms_count_start number of TMS state transitions to perform BEFORE
873 * shifting data into the JTAG chain.
874 * @param tms_sequence_start sequence of TMS state transitions that will be
875 * performed BEFORE shifting data into the JTAG chain.
876 * @param tms_count_end number of TMS state transitions to perform AFTER
877 * shifting data into the JTAG chain.
878 * @param tms_sequence_end sequence of TMS state transitions that will be
879 * performed AFTER shifting data into the JTAG chain.
880 * @param origin pointer to OpenOCD command that generated this scan command.
881 * @param postprocess whether this command needs to be post-processed after
883 * @return on success: ERROR_OK
884 * @return on failure: ERROR_FAIL
886 int ulink_append_scan_cmd(struct ulink
*device
, enum scan_type scan_type
,
887 int scan_size_bits
, uint8_t *tdi
, uint8_t *tdo_start
, uint8_t *tdo
,
888 uint8_t tms_count_start
, uint8_t tms_sequence_start
, uint8_t tms_count_end
,
889 uint8_t tms_sequence_end
, struct jtag_command
*origin
, bool postprocess
)
891 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
892 int ret
, i
, scan_size_bytes
;
893 uint8_t bits_last_byte
;
898 /* Check size of command. USB buffer can hold 64 bytes, 1 byte is command ID,
899 * 5 bytes are setup data -> 58 remaining payload bytes for TDI data */
900 if (scan_size_bits
> (58 * 8)) {
901 LOG_ERROR("BUG: Tried to create CMD_SCAN_IO OpenULINK command with too"
907 scan_size_bytes
= DIV_ROUND_UP(scan_size_bits
, 8);
909 bits_last_byte
= scan_size_bits
% 8;
910 if (bits_last_byte
== 0)
913 /* Allocate out_payload depending on scan type */
916 if (device
->delay_scan_in
< 0)
917 cmd
->id
= CMD_SCAN_IN
;
919 cmd
->id
= CMD_SLOW_SCAN_IN
;
920 ret
= ulink_allocate_payload(cmd
, 5, PAYLOAD_DIRECTION_OUT
);
923 if (device
->delay_scan_out
< 0)
924 cmd
->id
= CMD_SCAN_OUT
;
926 cmd
->id
= CMD_SLOW_SCAN_OUT
;
927 ret
= ulink_allocate_payload(cmd
, scan_size_bytes
+ 5, PAYLOAD_DIRECTION_OUT
);
930 if (device
->delay_scan_io
< 0)
931 cmd
->id
= CMD_SCAN_IO
;
933 cmd
->id
= CMD_SLOW_SCAN_IO
;
934 ret
= ulink_allocate_payload(cmd
, scan_size_bytes
+ 5, PAYLOAD_DIRECTION_OUT
);
937 LOG_ERROR("BUG: ulink_append_scan_cmd() encountered an unknown scan type");
942 if (ret
!= ERROR_OK
) {
947 /* Build payload_out that is common to all scan types */
948 cmd
->payload_out
[0] = scan_size_bytes
& 0xFF;
949 cmd
->payload_out
[1] = bits_last_byte
& 0xFF;
950 cmd
->payload_out
[2] = ((tms_count_start
& 0x0F) << 4) | (tms_count_end
& 0x0F);
951 cmd
->payload_out
[3] = tms_sequence_start
;
952 cmd
->payload_out
[4] = tms_sequence_end
;
954 /* Setup payload_out for types with OUT transfer */
955 if ((scan_type
== SCAN_OUT
) || (scan_type
== SCAN_IO
)) {
956 for (i
= 0; i
< scan_size_bytes
; i
++)
957 cmd
->payload_out
[i
+ 5] = tdi
[i
];
960 /* Setup payload_in pointers for types with IN transfer */
961 if ((scan_type
== SCAN_IN
) || (scan_type
== SCAN_IO
)) {
962 cmd
->payload_in_start
= tdo_start
;
963 cmd
->payload_in
= tdo
;
964 cmd
->payload_in_size
= scan_size_bytes
;
967 cmd
->needs_postprocessing
= postprocess
;
968 cmd
->cmd_origin
= origin
;
970 /* For scan commands, we free payload_in_start only when the command is
971 * the last in a series of split commands or a stand-alone command */
972 cmd
->free_payload_in_start
= postprocess
;
974 return ulink_append_queue(device
, cmd
);
978 * Perform TAP state transitions
980 * @param device pointer to struct ulink identifying ULINK driver instance.
981 * @param count defines the number of TCK clock cycles generated (up to 8).
982 * @param sequence defines the TMS pin levels for each state transition. The
983 * Least-Significant Bit is read first.
984 * @return on success: ERROR_OK
985 * @return on failure: ERROR_FAIL
987 int ulink_append_clock_tms_cmd(struct ulink
*device
, uint8_t count
,
990 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
996 if (device
->delay_clock_tms
< 0)
997 cmd
->id
= CMD_CLOCK_TMS
;
999 cmd
->id
= CMD_SLOW_CLOCK_TMS
;
1001 /* CMD_CLOCK_TMS has two OUT payload bytes and zero IN payload bytes */
1002 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
1003 if (ret
!= ERROR_OK
) {
1008 cmd
->payload_out
[0] = count
;
1009 cmd
->payload_out
[1] = sequence
;
1011 return ulink_append_queue(device
, cmd
);
1015 * Generate a defined amount of TCK clock cycles
1017 * All other JTAG signals are left unchanged.
1019 * @param device pointer to struct ulink identifying ULINK driver instance.
1020 * @param count the number of TCK clock cycles to generate.
1021 * @return on success: ERROR_OK
1022 * @return on failure: ERROR_FAIL
1024 int ulink_append_clock_tck_cmd(struct ulink
*device
, uint16_t count
)
1026 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1032 if (device
->delay_clock_tck
< 0)
1033 cmd
->id
= CMD_CLOCK_TCK
;
1035 cmd
->id
= CMD_SLOW_CLOCK_TCK
;
1037 /* CMD_CLOCK_TCK has two OUT payload bytes and zero IN payload bytes */
1038 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
1039 if (ret
!= ERROR_OK
) {
1044 cmd
->payload_out
[0] = count
& 0xff;
1045 cmd
->payload_out
[1] = (count
>> 8) & 0xff;
1047 return ulink_append_queue(device
, cmd
);
1051 * Read JTAG signals.
1053 * @param device pointer to struct ulink identifying ULINK driver instance.
1054 * @return on success: ERROR_OK
1055 * @return on failure: ERROR_FAIL
1057 int ulink_append_get_signals_cmd(struct ulink
*device
)
1059 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1065 cmd
->id
= CMD_GET_SIGNALS
;
1066 cmd
->needs_postprocessing
= true;
1068 /* CMD_GET_SIGNALS has two IN payload bytes */
1069 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_IN
);
1071 if (ret
!= ERROR_OK
) {
1076 return ulink_append_queue(device
, cmd
);
1080 * Arbitrarily set JTAG output signals.
1082 * @param device pointer to struct ulink identifying ULINK driver instance.
1083 * @param low defines which signals will be de-asserted. Each bit corresponds
1092 * @param high defines which signals will be asserted.
1093 * @return on success: ERROR_OK
1094 * @return on failure: ERROR_FAIL
1096 int ulink_append_set_signals_cmd(struct ulink
*device
, uint8_t low
,
1099 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1105 cmd
->id
= CMD_SET_SIGNALS
;
1107 /* CMD_SET_SIGNALS has two OUT payload bytes and zero IN payload bytes */
1108 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
1110 if (ret
!= ERROR_OK
) {
1115 cmd
->payload_out
[0] = low
;
1116 cmd
->payload_out
[1] = high
;
1118 return ulink_append_queue(device
, cmd
);
1122 * Sleep for a pre-defined number of microseconds
1124 * @param device pointer to struct ulink identifying ULINK driver instance.
1125 * @param us the number microseconds to sleep.
1126 * @return on success: ERROR_OK
1127 * @return on failure: ERROR_FAIL
1129 int ulink_append_sleep_cmd(struct ulink
*device
, uint32_t us
)
1131 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1137 cmd
->id
= CMD_SLEEP_US
;
1139 /* CMD_SLEEP_US has two OUT payload bytes and zero IN payload bytes */
1140 ret
= ulink_allocate_payload(cmd
, 2, PAYLOAD_DIRECTION_OUT
);
1142 if (ret
!= ERROR_OK
) {
1147 cmd
->payload_out
[0] = us
& 0x00ff;
1148 cmd
->payload_out
[1] = (us
>> 8) & 0x00ff;
1150 return ulink_append_queue(device
, cmd
);
1154 * Set TCK delay counters
1156 * @param device pointer to struct ulink identifying ULINK driver instance.
1157 * @param delay_scan_in delay count top value in jtag_slow_scan_in() function.
1158 * @param delay_scan_out delay count top value in jtag_slow_scan_out() function.
1159 * @param delay_scan_io delay count top value in jtag_slow_scan_io() function.
1160 * @param delay_tck delay count top value in jtag_clock_tck() function.
1161 * @param delay_tms delay count top value in jtag_slow_clock_tms() function.
1162 * @return on success: ERROR_OK
1163 * @return on failure: ERROR_FAIL
1165 int ulink_append_configure_tck_cmd(struct ulink
*device
, int delay_scan_in
,
1166 int delay_scan_out
, int delay_scan_io
, int delay_tck
, int delay_tms
)
1168 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1174 cmd
->id
= CMD_CONFIGURE_TCK_FREQ
;
1176 /* CMD_CONFIGURE_TCK_FREQ has five OUT payload bytes and zero
1177 * IN payload bytes */
1178 ret
= ulink_allocate_payload(cmd
, 5, PAYLOAD_DIRECTION_OUT
);
1179 if (ret
!= ERROR_OK
) {
1184 if (delay_scan_in
< 0)
1185 cmd
->payload_out
[0] = 0;
1187 cmd
->payload_out
[0] = (uint8_t)delay_scan_in
;
1189 if (delay_scan_out
< 0)
1190 cmd
->payload_out
[1] = 0;
1192 cmd
->payload_out
[1] = (uint8_t)delay_scan_out
;
1194 if (delay_scan_io
< 0)
1195 cmd
->payload_out
[2] = 0;
1197 cmd
->payload_out
[2] = (uint8_t)delay_scan_io
;
1200 cmd
->payload_out
[3] = 0;
1202 cmd
->payload_out
[3] = (uint8_t)delay_tck
;
1205 cmd
->payload_out
[4] = 0;
1207 cmd
->payload_out
[4] = (uint8_t)delay_tms
;
1209 return ulink_append_queue(device
, cmd
);
1213 * Turn on/off ULINK LEDs.
1215 * @param device pointer to struct ulink identifying ULINK driver instance.
1216 * @param led_state which LED(s) to turn on or off. The following bits
1217 * influence the LEDS:
1218 * - Bit 0: Turn COM LED on
1219 * - Bit 1: Turn RUN LED on
1220 * - Bit 2: Turn COM LED off
1221 * - Bit 3: Turn RUN LED off
1222 * If both the on-bit and the off-bit for the same LED is set, the LED is
1224 * @return on success: ERROR_OK
1225 * @return on failure: ERROR_FAIL
1227 int ulink_append_led_cmd(struct ulink
*device
, uint8_t led_state
)
1229 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1235 cmd
->id
= CMD_SET_LEDS
;
1237 /* CMD_SET_LEDS has one OUT payload byte and zero IN payload bytes */
1238 ret
= ulink_allocate_payload(cmd
, 1, PAYLOAD_DIRECTION_OUT
);
1239 if (ret
!= ERROR_OK
) {
1244 cmd
->payload_out
[0] = led_state
;
1246 return ulink_append_queue(device
, cmd
);
1250 * Test command. Used to check if the ULINK device is ready to accept new
1253 * @param device pointer to struct ulink identifying ULINK driver instance.
1254 * @return on success: ERROR_OK
1255 * @return on failure: ERROR_FAIL
1257 int ulink_append_test_cmd(struct ulink
*device
)
1259 struct ulink_cmd
*cmd
= calloc(1, sizeof(struct ulink_cmd
));
1267 /* CMD_TEST has one OUT payload byte and zero IN payload bytes */
1268 ret
= ulink_allocate_payload(cmd
, 1, PAYLOAD_DIRECTION_OUT
);
1269 if (ret
!= ERROR_OK
) {
1274 cmd
->payload_out
[0] = 0xAA;
1276 return ulink_append_queue(device
, cmd
);
1279 /****************** OpenULINK TCK frequency helper functions ******************/
1282 * Calculate delay values for a given TCK frequency.
1284 * The OpenULINK firmware uses five different speed values for different
1285 * commands. These speed values are calculated in these functions.
1287 * The five different commands which support variable TCK frequency are
1288 * implemented twice in the firmware:
1289 * 1. Maximum possible frequency without any artificial delay
1290 * 2. Variable frequency with artificial linear delay loop
1292 * To set the ULINK to maximum frequency, it is only neccessary to use the
1293 * corresponding command IDs. To set the ULINK to a lower frequency, the
1294 * delay loop top values have to be calculated first. Then, a
1295 * CMD_CONFIGURE_TCK_FREQ command needs to be sent to the ULINK device.
1297 * The delay values are described by linear equations:
1299 * (t = period, k = constant, x = delay value, d = constant)
1301 * Thus, the delay can be calculated as in the following equation:
1304 * The constants in these equations have been determined and validated by
1305 * measuring the frequency resulting from different delay values.
1307 * @param type for which command to calculate the delay value.
1308 * @param f TCK frequency for which to calculate the delay value in Hz.
1309 * @param delay where to store resulting delay value.
1310 * @return on success: ERROR_OK
1311 * @return on failure: ERROR_FAIL
1313 int ulink_calculate_delay(enum ulink_delay_type type
, long f
, int *delay
)
1317 /* Calculate period of requested TCK frequency */
1318 t
= 1.0 / (float)(f
);
1321 case DELAY_CLOCK_TCK
:
1322 x
= (t
- (float)(6E-6)) / (float)(4E-6);
1324 case DELAY_CLOCK_TMS
:
1325 x
= (t
- (float)(8.5E-6)) / (float)(4E-6);
1328 x
= (t
- (float)(8.8308E-6)) / (float)(4E-6);
1330 case DELAY_SCAN_OUT
:
1331 x
= (t
- (float)(1.0527E-5)) / (float)(4E-6);
1334 x
= (t
- (float)(1.3132E-5)) / (float)(4E-6);
1341 /* Check if the delay value is negative. This happens when a frequency is
1342 * requested that is too high for the delay loop implementation. In this
1343 * case, set delay value to zero. */
1347 /* We need to convert the exact delay value to an integer. Therefore, we
1348 * round the exact value UP to ensure that the resulting frequency is NOT
1349 * higher than the requested frequency. */
1352 /* Check if the value is within limits */
1356 *delay
= (int)x_ceil
;
1362 * Calculate frequency for a given delay value.
1364 * Similar to the #ulink_calculate_delay function, this function calculates the
1365 * TCK frequency for a given delay value by using linear equations of the form:
1367 * (t = period, k = constant, x = delay value, d = constant)
1369 * @param type for which command to calculate the delay value.
1370 * @param delay delay value for which to calculate the resulting TCK frequency.
1371 * @return the resulting TCK frequency
1373 static long ulink_calculate_frequency(enum ulink_delay_type type
, int delay
)
1381 case DELAY_CLOCK_TCK
:
1383 t
= (float)(2.666E-6);
1385 t
= (float)(4E-6) * (float)(delay
) + (float)(6E-6);
1387 case DELAY_CLOCK_TMS
:
1389 t
= (float)(5.666E-6);
1391 t
= (float)(4E-6) * (float)(delay
) + (float)(8.5E-6);
1395 t
= (float)(5.5E-6);
1397 t
= (float)(4E-6) * (float)(delay
) + (float)(8.8308E-6);
1399 case DELAY_SCAN_OUT
:
1401 t
= (float)(7.0E-6);
1403 t
= (float)(4E-6) * (float)(delay
) + (float)(1.0527E-5);
1407 t
= (float)(9.926E-6);
1409 t
= (float)(4E-6) * (float)(delay
) + (float)(1.3132E-5);
1416 return roundf(f_float
);
1419 /******************* Interface between OpenULINK and OpenOCD ******************/
1422 * Sets the end state follower (see interface.h) if \a endstate is a stable
1425 * @param endstate the state the end state follower should be set to.
1427 static void ulink_set_end_state(tap_state_t endstate
)
1429 if (tap_is_state_stable(endstate
))
1430 tap_set_end_state(endstate
);
1432 LOG_ERROR("BUG: %s is not a valid end state", tap_state_name(endstate
));
1438 * Move from the current TAP state to the current TAP end state.
1440 * @param device pointer to struct ulink identifying ULINK driver instance.
1441 * @return on success: ERROR_OK
1442 * @return on failure: ERROR_FAIL
1444 int ulink_queue_statemove(struct ulink
*device
)
1446 uint8_t tms_sequence
, tms_count
;
1449 if (tap_get_state() == tap_get_end_state()) {
1450 /* Do nothing if we are already there */
1454 tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1455 tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1457 ret
= ulink_append_clock_tms_cmd(device
, tms_count
, tms_sequence
);
1459 if (ret
== ERROR_OK
)
1460 tap_set_state(tap_get_end_state());
1466 * Perform a scan operation on a JTAG register.
1468 * @param device pointer to struct ulink identifying ULINK driver instance.
1469 * @param cmd pointer to the command that shall be executed.
1470 * @return on success: ERROR_OK
1471 * @return on failure: ERROR_FAIL
1473 int ulink_queue_scan(struct ulink
*device
, struct jtag_command
*cmd
)
1475 uint32_t scan_size_bits
, scan_size_bytes
, bits_last_scan
;
1476 uint32_t scans_max_payload
, bytecount
;
1477 uint8_t *tdi_buffer_start
= NULL
, *tdi_buffer
= NULL
;
1478 uint8_t *tdo_buffer_start
= NULL
, *tdo_buffer
= NULL
;
1480 uint8_t first_tms_count
, first_tms_sequence
;
1481 uint8_t last_tms_count
, last_tms_sequence
;
1483 uint8_t tms_count_pause
, tms_sequence_pause
;
1484 uint8_t tms_count_resume
, tms_sequence_resume
;
1486 uint8_t tms_count_start
, tms_sequence_start
;
1487 uint8_t tms_count_end
, tms_sequence_end
;
1489 enum scan_type type
;
1492 /* Determine scan size */
1493 scan_size_bits
= jtag_scan_size(cmd
->cmd
.scan
);
1494 scan_size_bytes
= DIV_ROUND_UP(scan_size_bits
, 8);
1496 /* Determine scan type (IN/OUT/IO) */
1497 type
= jtag_scan_type(cmd
->cmd
.scan
);
1499 /* Determine number of scan commands with maximum payload */
1500 scans_max_payload
= scan_size_bytes
/ 58;
1502 /* Determine size of last shift command */
1503 bits_last_scan
= scan_size_bits
- (scans_max_payload
* 58 * 8);
1505 /* Allocate TDO buffer if required */
1506 if ((type
== SCAN_IN
) || (type
== SCAN_IO
)) {
1507 tdo_buffer_start
= calloc(sizeof(uint8_t), scan_size_bytes
);
1509 if (tdo_buffer_start
== NULL
)
1512 tdo_buffer
= tdo_buffer_start
;
1515 /* Fill TDI buffer if required */
1516 if ((type
== SCAN_OUT
) || (type
== SCAN_IO
)) {
1517 jtag_build_buffer(cmd
->cmd
.scan
, &tdi_buffer_start
);
1518 tdi_buffer
= tdi_buffer_start
;
1521 /* Get TAP state transitions */
1522 if (cmd
->cmd
.scan
->ir_scan
) {
1523 ulink_set_end_state(TAP_IRSHIFT
);
1524 first_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1525 first_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1527 tap_set_state(TAP_IRSHIFT
);
1528 tap_set_end_state(cmd
->cmd
.scan
->end_state
);
1529 last_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1530 last_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1532 /* TAP state transitions for split scans */
1533 tms_count_pause
= tap_get_tms_path_len(TAP_IRSHIFT
, TAP_IRPAUSE
);
1534 tms_sequence_pause
= tap_get_tms_path(TAP_IRSHIFT
, TAP_IRPAUSE
);
1535 tms_count_resume
= tap_get_tms_path_len(TAP_IRPAUSE
, TAP_IRSHIFT
);
1536 tms_sequence_resume
= tap_get_tms_path(TAP_IRPAUSE
, TAP_IRSHIFT
);
1538 ulink_set_end_state(TAP_DRSHIFT
);
1539 first_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1540 first_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1542 tap_set_state(TAP_DRSHIFT
);
1543 tap_set_end_state(cmd
->cmd
.scan
->end_state
);
1544 last_tms_count
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1545 last_tms_sequence
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1547 /* TAP state transitions for split scans */
1548 tms_count_pause
= tap_get_tms_path_len(TAP_DRSHIFT
, TAP_DRPAUSE
);
1549 tms_sequence_pause
= tap_get_tms_path(TAP_DRSHIFT
, TAP_DRPAUSE
);
1550 tms_count_resume
= tap_get_tms_path_len(TAP_DRPAUSE
, TAP_DRSHIFT
);
1551 tms_sequence_resume
= tap_get_tms_path(TAP_DRPAUSE
, TAP_DRSHIFT
);
1554 /* Generate scan commands */
1555 bytecount
= scan_size_bytes
;
1556 while (bytecount
> 0) {
1557 if (bytecount
== scan_size_bytes
) {
1558 /* This is the first scan */
1559 tms_count_start
= first_tms_count
;
1560 tms_sequence_start
= first_tms_sequence
;
1562 /* Resume from previous scan */
1563 tms_count_start
= tms_count_resume
;
1564 tms_sequence_start
= tms_sequence_resume
;
1567 if (bytecount
> 58) { /* Full scan, at least one scan will follow */
1568 tms_count_end
= tms_count_pause
;
1569 tms_sequence_end
= tms_sequence_pause
;
1571 ret
= ulink_append_scan_cmd(device
,
1586 /* Update TDI and TDO buffer pointers */
1587 if (tdi_buffer_start
!= NULL
)
1589 if (tdo_buffer_start
!= NULL
)
1591 } else if (bytecount
== 58) { /* Full scan, no further scans */
1592 tms_count_end
= last_tms_count
;
1593 tms_sequence_end
= last_tms_sequence
;
1595 ret
= ulink_append_scan_cmd(device
,
1609 } else {/* Scan with less than maximum payload, no further scans */
1610 tms_count_end
= last_tms_count
;
1611 tms_sequence_end
= last_tms_sequence
;
1613 ret
= ulink_append_scan_cmd(device
,
1629 if (ret
!= ERROR_OK
) {
1630 free(tdi_buffer_start
);
1631 free(tdo_buffer_start
);
1636 free(tdi_buffer_start
);
1638 /* Set current state to the end state requested by the command */
1639 tap_set_state(cmd
->cmd
.scan
->end_state
);
1645 * Move the TAP into the Test Logic Reset state.
1647 * @param device pointer to struct ulink identifying ULINK driver instance.
1648 * @param cmd pointer to the command that shall be executed.
1649 * @return on success: ERROR_OK
1650 * @return on failure: ERROR_FAIL
1652 int ulink_queue_tlr_reset(struct ulink
*device
, struct jtag_command
*cmd
)
1656 ret
= ulink_append_clock_tms_cmd(device
, 5, 0xff);
1658 if (ret
== ERROR_OK
)
1659 tap_set_state(TAP_RESET
);
1667 * Generate TCK clock cycles while remaining
1668 * in the Run-Test/Idle state.
1670 * @param device pointer to struct ulink identifying ULINK driver instance.
1671 * @param cmd pointer to the command that shall be executed.
1672 * @return on success: ERROR_OK
1673 * @return on failure: ERROR_FAIL
1675 int ulink_queue_runtest(struct ulink
*device
, struct jtag_command
*cmd
)
1679 /* Only perform statemove if the TAP currently isn't in the TAP_IDLE state */
1680 if (tap_get_state() != TAP_IDLE
) {
1681 ulink_set_end_state(TAP_IDLE
);
1682 ulink_queue_statemove(device
);
1685 /* Generate the clock cycles */
1686 ret
= ulink_append_clock_tck_cmd(device
, cmd
->cmd
.runtest
->num_cycles
);
1687 if (ret
!= ERROR_OK
)
1690 /* Move to end state specified in command */
1691 if (cmd
->cmd
.runtest
->end_state
!= tap_get_state()) {
1692 tap_set_end_state(cmd
->cmd
.runtest
->end_state
);
1693 ulink_queue_statemove(device
);
1700 * Execute a JTAG_RESET command
1702 * @param cmd pointer to the command that shall be executed.
1703 * @return on success: ERROR_OK
1704 * @return on failure: ERROR_FAIL
1706 int ulink_queue_reset(struct ulink
*device
, struct jtag_command
*cmd
)
1708 uint8_t low
= 0, high
= 0;
1710 if (cmd
->cmd
.reset
->trst
) {
1711 tap_set_state(TAP_RESET
);
1712 high
|= SIGNAL_TRST
;
1716 if (cmd
->cmd
.reset
->srst
)
1717 high
|= SIGNAL_RESET
;
1719 low
|= SIGNAL_RESET
;
1721 return ulink_append_set_signals_cmd(device
, low
, high
);
1725 * Move to one TAP state or several states in succession.
1727 * @param device pointer to struct ulink identifying ULINK driver instance.
1728 * @param cmd pointer to the command that shall be executed.
1729 * @return on success: ERROR_OK
1730 * @return on failure: ERROR_FAIL
1732 int ulink_queue_pathmove(struct ulink
*device
, struct jtag_command
*cmd
)
1734 int ret
, i
, num_states
, batch_size
, state_count
;
1736 uint8_t tms_sequence
;
1738 num_states
= cmd
->cmd
.pathmove
->num_states
;
1739 path
= cmd
->cmd
.pathmove
->path
;
1742 while (num_states
> 0) {
1745 /* Determine batch size */
1746 if (num_states
>= 8)
1749 batch_size
= num_states
;
1751 for (i
= 0; i
< batch_size
; i
++) {
1752 if (tap_state_transition(tap_get_state(), false) == path
[state_count
]) {
1753 /* Append '0' transition: clear bit 'i' in tms_sequence */
1754 buf_set_u32(&tms_sequence
, i
, 1, 0x0);
1755 } else if (tap_state_transition(tap_get_state(), true)
1756 == path
[state_count
]) {
1757 /* Append '1' transition: set bit 'i' in tms_sequence */
1758 buf_set_u32(&tms_sequence
, i
, 1, 0x1);
1760 /* Invalid state transition */
1761 LOG_ERROR("BUG: %s -> %s isn't a valid TAP state transition",
1762 tap_state_name(tap_get_state()),
1763 tap_state_name(path
[state_count
]));
1767 tap_set_state(path
[state_count
]);
1772 /* Append CLOCK_TMS command to OpenULINK command queue */
1774 "pathmove batch: count = %i, sequence = 0x%x", batch_size
, tms_sequence
);
1775 ret
= ulink_append_clock_tms_cmd(ulink_handle
, batch_size
, tms_sequence
);
1776 if (ret
!= ERROR_OK
)
1784 * Sleep for a specific amount of time.
1786 * @param device pointer to struct ulink identifying ULINK driver instance.
1787 * @param cmd pointer to the command that shall be executed.
1788 * @return on success: ERROR_OK
1789 * @return on failure: ERROR_FAIL
1791 int ulink_queue_sleep(struct ulink
*device
, struct jtag_command
*cmd
)
1793 /* IMPORTANT! Due to the time offset in command execution introduced by
1794 * command queueing, this needs to be implemented in the ULINK device */
1795 return ulink_append_sleep_cmd(device
, cmd
->cmd
.sleep
->us
);
1799 * Generate TCK cycles while remaining in a stable state.
1801 * @param device pointer to struct ulink identifying ULINK driver instance.
1802 * @param cmd pointer to the command that shall be executed.
1804 int ulink_queue_stableclocks(struct ulink
*device
, struct jtag_command
*cmd
)
1807 unsigned num_cycles
;
1809 if (!tap_is_state_stable(tap_get_state())) {
1810 LOG_ERROR("JTAG_STABLECLOCKS: state not stable");
1814 num_cycles
= cmd
->cmd
.stableclocks
->num_cycles
;
1816 /* TMS stays either high (Test Logic Reset state) or low (all other states) */
1817 if (tap_get_state() == TAP_RESET
)
1818 ret
= ulink_append_set_signals_cmd(device
, 0, SIGNAL_TMS
);
1820 ret
= ulink_append_set_signals_cmd(device
, SIGNAL_TMS
, 0);
1822 if (ret
!= ERROR_OK
)
1825 while (num_cycles
> 0) {
1826 if (num_cycles
> 0xFFFF) {
1827 /* OpenULINK CMD_CLOCK_TCK can generate up to 0xFFFF (uint16_t) cycles */
1828 ret
= ulink_append_clock_tck_cmd(device
, 0xFFFF);
1829 num_cycles
-= 0xFFFF;
1831 ret
= ulink_append_clock_tck_cmd(device
, num_cycles
);
1835 if (ret
!= ERROR_OK
)
1843 * Post-process JTAG_SCAN command
1845 * @param ulink_cmd pointer to OpenULINK command that shall be processed.
1846 * @return on success: ERROR_OK
1847 * @return on failure: ERROR_FAIL
1849 int ulink_post_process_scan(struct ulink_cmd
*ulink_cmd
)
1851 struct jtag_command
*cmd
= ulink_cmd
->cmd_origin
;
1854 switch (jtag_scan_type(cmd
->cmd
.scan
)) {
1857 ret
= jtag_read_buffer(ulink_cmd
->payload_in_start
, cmd
->cmd
.scan
);
1860 /* Nothing to do for OUT scans */
1864 LOG_ERROR("BUG: ulink_post_process_scan() encountered an unknown"
1874 * Perform post-processing of commands after OpenULINK queue has been executed.
1876 * @param device pointer to struct ulink identifying ULINK driver instance.
1877 * @return on success: ERROR_OK
1878 * @return on failure: ERROR_FAIL
1880 int ulink_post_process_queue(struct ulink
*device
)
1882 struct ulink_cmd
*current
;
1883 struct jtag_command
*openocd_cmd
;
1886 current
= device
->queue_start
;
1888 while (current
!= NULL
) {
1889 openocd_cmd
= current
->cmd_origin
;
1891 /* Check if a corresponding OpenOCD command is stored for this
1892 * OpenULINK command */
1893 if ((current
->needs_postprocessing
== true) && (openocd_cmd
!= NULL
)) {
1894 switch (openocd_cmd
->type
) {
1896 ret
= ulink_post_process_scan(current
);
1898 case JTAG_TLR_RESET
:
1903 case JTAG_STABLECLOCKS
:
1904 /* Nothing to do for these commands */
1909 LOG_ERROR("BUG: ulink_post_process_queue() encountered unknown JTAG "
1914 if (ret
!= ERROR_OK
)
1918 current
= current
->next
;
1924 /**************************** JTAG driver functions ***************************/
1927 * Executes the JTAG Command Queue.
1929 * This is done in three stages: First, all OpenOCD commands are processed into
1930 * queued OpenULINK commands. Next, the OpenULINK command queue is sent to the
1931 * ULINK device and data received from the ULINK device is cached. Finally,
1932 * the post-processing function writes back data to the corresponding OpenOCD
1935 * @return on success: ERROR_OK
1936 * @return on failure: ERROR_FAIL
1938 static int ulink_execute_queue(void)
1940 struct jtag_command
*cmd
= jtag_command_queue
;
1944 switch (cmd
->type
) {
1946 ret
= ulink_queue_scan(ulink_handle
, cmd
);
1948 case JTAG_TLR_RESET
:
1949 ret
= ulink_queue_tlr_reset(ulink_handle
, cmd
);
1952 ret
= ulink_queue_runtest(ulink_handle
, cmd
);
1955 ret
= ulink_queue_reset(ulink_handle
, cmd
);
1958 ret
= ulink_queue_pathmove(ulink_handle
, cmd
);
1961 ret
= ulink_queue_sleep(ulink_handle
, cmd
);
1963 case JTAG_STABLECLOCKS
:
1964 ret
= ulink_queue_stableclocks(ulink_handle
, cmd
);
1968 LOG_ERROR("BUG: encountered unknown JTAG command type");
1972 if (ret
!= ERROR_OK
)
1978 if (ulink_handle
->commands_in_queue
> 0) {
1979 ret
= ulink_execute_queued_commands(ulink_handle
, USB_TIMEOUT
);
1980 if (ret
!= ERROR_OK
)
1983 ret
= ulink_post_process_queue(ulink_handle
);
1984 if (ret
!= ERROR_OK
)
1987 ulink_clear_queue(ulink_handle
);
1994 * Set the TCK frequency of the ULINK adapter.
1996 * @param khz desired JTAG TCK frequency.
1997 * @param jtag_speed where to store corresponding adapter-specific speed value.
1998 * @return on success: ERROR_OK
1999 * @return on failure: ERROR_FAIL
2001 static int ulink_khz(int khz
, int *jtag_speed
)
2006 LOG_ERROR("RCLK not supported");
2010 /* CLOCK_TCK commands are decoupled from others. Therefore, the frequency
2011 * setting can be done independently from all other commands. */
2013 ulink_handle
->delay_clock_tck
= -1;
2015 ret
= ulink_calculate_delay(DELAY_CLOCK_TCK
, khz
* 1000,
2016 &ulink_handle
->delay_clock_tck
);
2017 if (ret
!= ERROR_OK
)
2021 /* SCAN_{IN,OUT,IO} commands invoke CLOCK_TMS commands. Therefore, if the
2022 * requested frequency goes below the maximum frequency for SLOW_CLOCK_TMS
2023 * commands, all SCAN commands MUST also use the variable frequency
2024 * implementation! */
2026 ulink_handle
->delay_clock_tms
= -1;
2027 ulink_handle
->delay_scan_in
= -1;
2028 ulink_handle
->delay_scan_out
= -1;
2029 ulink_handle
->delay_scan_io
= -1;
2031 ret
= ulink_calculate_delay(DELAY_CLOCK_TMS
, khz
* 1000,
2032 &ulink_handle
->delay_clock_tms
);
2033 if (ret
!= ERROR_OK
)
2036 ret
= ulink_calculate_delay(DELAY_SCAN_IN
, khz
* 1000,
2037 &ulink_handle
->delay_scan_in
);
2038 if (ret
!= ERROR_OK
)
2041 ret
= ulink_calculate_delay(DELAY_SCAN_OUT
, khz
* 1000,
2042 &ulink_handle
->delay_scan_out
);
2043 if (ret
!= ERROR_OK
)
2046 ret
= ulink_calculate_delay(DELAY_SCAN_IO
, khz
* 1000,
2047 &ulink_handle
->delay_scan_io
);
2048 if (ret
!= ERROR_OK
)
2052 LOG_DEBUG_IO("ULINK TCK setup: delay_tck = %i (%li Hz),",
2053 ulink_handle
->delay_clock_tck
,
2054 ulink_calculate_frequency(DELAY_CLOCK_TCK
, ulink_handle
->delay_clock_tck
));
2055 LOG_DEBUG_IO(" delay_tms = %i (%li Hz),",
2056 ulink_handle
->delay_clock_tms
,
2057 ulink_calculate_frequency(DELAY_CLOCK_TMS
, ulink_handle
->delay_clock_tms
));
2058 LOG_DEBUG_IO(" delay_scan_in = %i (%li Hz),",
2059 ulink_handle
->delay_scan_in
,
2060 ulink_calculate_frequency(DELAY_SCAN_IN
, ulink_handle
->delay_scan_in
));
2061 LOG_DEBUG_IO(" delay_scan_out = %i (%li Hz),",
2062 ulink_handle
->delay_scan_out
,
2063 ulink_calculate_frequency(DELAY_SCAN_OUT
, ulink_handle
->delay_scan_out
));
2064 LOG_DEBUG_IO(" delay_scan_io = %i (%li Hz),",
2065 ulink_handle
->delay_scan_io
,
2066 ulink_calculate_frequency(DELAY_SCAN_IO
, ulink_handle
->delay_scan_io
));
2068 /* Configure the ULINK device with the new delay values */
2069 ret
= ulink_append_configure_tck_cmd(ulink_handle
,
2070 ulink_handle
->delay_scan_in
,
2071 ulink_handle
->delay_scan_out
,
2072 ulink_handle
->delay_scan_io
,
2073 ulink_handle
->delay_clock_tck
,
2074 ulink_handle
->delay_clock_tms
);
2076 if (ret
!= ERROR_OK
)
2085 * Set the TCK frequency of the ULINK adapter.
2087 * Because of the way the TCK frequency is set up in the OpenULINK firmware,
2088 * there are five different speed settings. To simplify things, the
2089 * adapter-specific speed setting value is identical to the TCK frequency in
2092 * @param speed desired adapter-specific speed value.
2093 * @return on success: ERROR_OK
2094 * @return on failure: ERROR_FAIL
2096 static int ulink_speed(int speed
)
2100 return ulink_khz(speed
, &dummy
);
2104 * Convert adapter-specific speed value to corresponding TCK frequency in kHz.
2106 * Because of the way the TCK frequency is set up in the OpenULINK firmware,
2107 * there are five different speed settings. To simplify things, the
2108 * adapter-specific speed setting value is identical to the TCK frequency in
2111 * @param speed adapter-specific speed value.
2112 * @param khz where to store corresponding TCK frequency in kHz.
2113 * @return on success: ERROR_OK
2114 * @return on failure: ERROR_FAIL
2116 static int ulink_speed_div(int speed
, int *khz
)
2124 * Initiates the firmware download to the ULINK adapter and prepares
2127 * @return on success: ERROR_OK
2128 * @return on failure: ERROR_FAIL
2130 static int ulink_init(void)
2132 int ret
, transferred
;
2133 char str_manufacturer
[20];
2134 bool download_firmware
= false;
2135 unsigned char *dummy
;
2136 uint8_t input_signals
, output_signals
;
2138 ulink_handle
= calloc(1, sizeof(struct ulink
));
2139 if (ulink_handle
== NULL
)
2142 libusb_init(&ulink_handle
->libusb_ctx
);
2144 ret
= ulink_usb_open(&ulink_handle
);
2145 if (ret
!= ERROR_OK
) {
2146 LOG_ERROR("Could not open ULINK device");
2148 ulink_handle
= NULL
;
2152 /* Get String Descriptor to determine if firmware needs to be loaded */
2153 ret
= libusb_get_string_descriptor_ascii(ulink_handle
->usb_device_handle
, 1, (unsigned char *)str_manufacturer
, 20);
2155 /* Could not get descriptor -> Unconfigured or original Keil firmware */
2156 download_firmware
= true;
2158 /* We got a String Descriptor, check if it is the correct one */
2159 if (strncmp(str_manufacturer
, "OpenULINK", 9) != 0)
2160 download_firmware
= true;
2163 if (download_firmware
== true) {
2164 LOG_INFO("Loading OpenULINK firmware. This is reversible by power-cycling"
2166 ret
= ulink_load_firmware_and_renumerate(&ulink_handle
,
2167 ULINK_FIRMWARE_FILE
, ULINK_RENUMERATION_DELAY
);
2168 if (ret
!= ERROR_OK
) {
2169 LOG_ERROR("Could not download firmware and re-numerate ULINK");
2171 ulink_handle
= NULL
;
2175 LOG_INFO("ULINK device is already running OpenULINK firmware");
2177 /* Initialize OpenULINK command queue */
2178 ulink_clear_queue(ulink_handle
);
2180 /* Issue one test command with short timeout */
2181 ret
= ulink_append_test_cmd(ulink_handle
);
2182 if (ret
!= ERROR_OK
)
2185 ret
= ulink_execute_queued_commands(ulink_handle
, 200);
2186 if (ret
!= ERROR_OK
) {
2187 /* Sending test command failed. The ULINK device may be forever waiting for
2188 * the host to fetch an USB Bulk IN packet (e. g. OpenOCD crashed or was
2189 * shut down by the user via Ctrl-C. Try to retrieve this Bulk IN packet. */
2190 dummy
= calloc(64, sizeof(uint8_t));
2192 ret
= libusb_bulk_transfer(ulink_handle
->usb_device_handle
, (2 | LIBUSB_ENDPOINT_IN
),
2193 dummy
, 64, &transferred
, 200);
2197 if (ret
!= 0 || transferred
== 0) {
2198 /* Bulk IN transfer failed -> unrecoverable error condition */
2199 LOG_ERROR("Cannot communicate with ULINK device. Disconnect ULINK from "
2200 "the USB port and re-connect, then re-run OpenOCD");
2202 ulink_handle
= NULL
;
2205 #ifdef _DEBUG_USB_COMMS_
2207 /* Successfully received Bulk IN packet -> continue */
2208 LOG_INFO("Recovered from lost Bulk IN packet");
2212 ulink_clear_queue(ulink_handle
);
2214 ret
= ulink_append_get_signals_cmd(ulink_handle
);
2215 if (ret
== ERROR_OK
)
2216 ret
= ulink_execute_queued_commands(ulink_handle
, 200);
2218 if (ret
== ERROR_OK
) {
2219 /* Post-process the single CMD_GET_SIGNALS command */
2220 input_signals
= ulink_handle
->queue_start
->payload_in
[0];
2221 output_signals
= ulink_handle
->queue_start
->payload_in
[1];
2223 ulink_print_signal_states(input_signals
, output_signals
);
2226 ulink_clear_queue(ulink_handle
);
2232 * Closes the USB handle for the ULINK device.
2234 * @return on success: ERROR_OK
2235 * @return on failure: ERROR_FAIL
2237 static int ulink_quit(void)
2241 ret
= ulink_usb_close(&ulink_handle
);
2248 * Set a custom path to ULINK firmware image and force downloading to ULINK.
2250 COMMAND_HANDLER(ulink_download_firmware_handler
)
2255 return ERROR_COMMAND_SYNTAX_ERROR
;
2258 LOG_INFO("Downloading ULINK firmware image %s", CMD_ARGV
[0]);
2260 /* Download firmware image in CMD_ARGV[0] */
2261 ret
= ulink_load_firmware_and_renumerate(&ulink_handle
, CMD_ARGV
[0],
2262 ULINK_RENUMERATION_DELAY
);
2267 /*************************** Command Registration **************************/
2269 static const struct command_registration ulink_command_handlers
[] = {
2271 .name
= "ulink_download_firmware",
2272 .handler
= &ulink_download_firmware_handler
,
2273 .mode
= COMMAND_EXEC
,
2274 .help
= "download firmware image to ULINK device",
2275 .usage
= "path/to/ulink_firmware.hex",
2277 COMMAND_REGISTRATION_DONE
,
2280 static struct jtag_interface ulink_interface
= {
2281 .execute_queue
= ulink_execute_queue
,
2284 struct adapter_driver ulink_adapter_driver
= {
2286 .transports
= jtag_only
,
2287 .commands
= ulink_command_handlers
,
2291 .speed
= ulink_speed
,
2293 .speed_div
= ulink_speed_div
,
2295 .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)