1 // SPDX-License-Identifier: GPL-2.0-or-later
3 /***************************************************************************
4 * Copyright (C) 2017 by Texas Instruments, Inc. *
5 ***************************************************************************/
11 #include <transport/transport.h>
12 #include <jtag/adapter.h>
14 #include <jtag/interface.h>
15 #include <jtag/commands.h>
19 /* XDS110 stand-alone probe voltage supply limits */
20 #define XDS110_MIN_VOLTAGE 1800
21 #define XDS110_MAX_VOLTAGE 3600
23 /* XDS110 stand-alone probe hardware ID */
24 #define XDS110_STAND_ALONE_ID 0x21
26 /* Firmware version that introduced OpenOCD support via block accesses */
27 #define OCD_FIRMWARE_VERSION 0x02030011
28 #define OCD_FIRMWARE_UPGRADE \
29 "XDS110: upgrade to version 2.3.0.11+ for improved support"
31 /* Firmware version that introduced improved TCK performance */
32 #define FAST_TCK_FIRMWARE_VERSION 0x03000000
34 /* Firmware version that introduced 10 MHz and 12 MHz TCK support */
35 #define FAST_TCK_PLUS_FIRMWARE_VERSION 0x03000003
37 /***************************************************************************
38 * USB Connection Buffer Definitions *
39 ***************************************************************************/
41 /* Max USB packet size for up to USB 3.0 */
42 #define MAX_PACKET 1024
45 * Maximum data payload that can be handled in a single call
46 * Limitation is the size of the buffers in the XDS110 firmware
48 #define MAX_DATA_BLOCK 4096
50 #ifndef USB_PAYLOAD_SIZE
51 /* Largest data block plus parameters */
52 #define USB_PAYLOAD_SIZE (MAX_DATA_BLOCK + 60)
54 #define MAX_RESULT_QUEUE (MAX_DATA_BLOCK / 4)
56 /***************************************************************************
57 * XDS110 Firmware API Definitions *
58 ***************************************************************************/
61 * Default values controlling how the host communicates commands
62 * with XDS110 firmware (automatic retry count and wait timeout)
64 #define DEFAULT_ATTEMPTS (1)
65 #define DEFAULT_TIMEOUT (4000)
67 /* XDS110 API error codes */
69 #define SC_ERR_XDS110_FAIL -261
70 #define SC_ERR_SWD_WAIT -613
71 #define SC_ERR_SWD_FAULT -614
72 #define SC_ERR_SWD_PROTOCOL -615
73 #define SC_ERR_SWD_PARITY -616
74 #define SC_ERR_SWD_DEVICE_ID -617
76 /* TCK frequency limits */
77 #define XDS110_MIN_TCK_SPEED 100 /* kHz */
78 #define XDS110_MAX_SLOW_TCK_SPEED 2500 /* kHz */
79 #define XDS110_MAX_FAST_TCK_SPEED 14000 /* kHz */
80 #define XDS110_DEFAULT_TCK_SPEED 2500 /* kHz */
82 /* Fixed TCK delay values for "Fast" TCK frequencies */
83 #define FAST_TCK_DELAY_14000_KHZ 0
84 #define FAST_TCK_DELAY_10000_KHZ 0xfffffffd
85 #define FAST_TCK_DELAY_12000_KHZ 0xfffffffe
86 #define FAST_TCK_DELAY_8500_KHZ 1
87 #define FAST_TCK_DELAY_5500_KHZ 2
88 /* For TCK frequencies below 5500 kHz, use calculated delay */
90 /* Scan mode on connect */
93 /* XDS110 API JTAG state definitions */
94 #define XDS_JTAG_STATE_RESET 1
95 #define XDS_JTAG_STATE_IDLE 2
96 #define XDS_JTAG_STATE_SHIFT_DR 3
97 #define XDS_JTAG_STATE_SHIFT_IR 4
98 #define XDS_JTAG_STATE_PAUSE_DR 5
99 #define XDS_JTAG_STATE_PAUSE_IR 6
100 #define XDS_JTAG_STATE_EXIT1_DR 8
101 #define XDS_JTAG_STATE_EXIT1_IR 9
102 #define XDS_JTAG_STATE_EXIT2_DR 10
103 #define XDS_JTAG_STATE_EXIT2_IR 11
104 #define XDS_JTAG_STATE_SELECT_DR 12
105 #define XDS_JTAG_STATE_SELECT_IR 13
106 #define XDS_JTAG_STATE_UPDATE_DR 14
107 #define XDS_JTAG_STATE_UPDATE_IR 15
108 #define XDS_JTAG_STATE_CAPTURE_DR 16
109 #define XDS_JTAG_STATE_CAPTURE_IR 17
111 /* XDS110 API JTAG transit definitions */
112 #define XDS_JTAG_TRANSIT_QUICKEST 1
113 #define XDS_JTAG_TRANSIT_VIA_CAPTURE 2
114 #define XDS_JTAG_TRANSIT_VIA_IDLE 3
116 /* DAP register definitions as used by XDS110 APIs */
118 #define DAP_AP 0 /* DAP AP register type */
119 #define DAP_DP 1 /* DAP DP register type */
121 #define DAP_DP_IDCODE 0x0 /* DAP DP IDCODE register (read only) */
122 #define DAP_DP_ABORT 0x0 /* DAP DP ABORT register (write only) */
123 #define DAP_DP_STAT 0x4 /* DAP DP STAT register (for read only) */
124 #define DAP_DP_CTRL 0x4 /* DAP DP CTRL register (for write only) */
125 #define DAP_DP_ADDR 0x8 /* DAP DP SELECT register (legacy name) */
126 #define DAP_DP_RESEND 0x8 /* DAP DP RESEND register (read only) */
127 #define DAP_DP_SELECT 0x8 /* DAP DP SELECT register (write only) */
128 #define DAP_DP_RDBUFF 0xc /* DAP DP RDBUFF Read Buffer register */
130 #define DAP_AP_CSW 0x00 /* DAP AP Control Status Word */
131 #define DAP_AP_TAR 0x04 /* DAP AP Transfer Address */
132 #define DAP_AP_DRW 0x0C /* DAP AP Data Read/Write */
133 #define DAP_AP_BD0 0x10 /* DAP AP Banked Data 0 */
134 #define DAP_AP_BD1 0x14 /* DAP AP Banked Data 1 */
135 #define DAP_AP_BD2 0x18 /* DAP AP Banked Data 2 */
136 #define DAP_AP_BD3 0x1C /* DAP AP Banked Data 3 */
137 #define DAP_AP_RTBL 0xF8 /* DAP AP Debug ROM Table */
138 #define DAP_AP_IDR 0xFC /* DAP AP Identification Register */
140 /* Command packet definitions */
142 #define XDS_OUT_LEN 1 /* command (byte) */
143 #define XDS_IN_LEN 4 /* error code (int) */
145 /* XDS API Commands */
146 #define XDS_CONNECT 0x01 /* Connect JTAG connection */
147 #define XDS_DISCONNECT 0x02 /* Disconnect JTAG connection */
148 #define XDS_VERSION 0x03 /* Get firmware version and hardware ID */
149 #define XDS_SET_TCK 0x04 /* Set TCK delay (to set TCK frequency) */
150 #define XDS_SET_TRST 0x05 /* Assert or deassert nTRST signal */
151 #define XDS_CYCLE_TCK 0x07 /* Toggle TCK for a number of cycles */
152 #define XDS_GOTO_STATE 0x09 /* Go to requested JTAG state */
153 #define XDS_JTAG_SCAN 0x0c /* Send and receive JTAG scan */
154 #define XDS_SET_SRST 0x0e /* Assert or deassert nSRST signal */
155 #define CMAPI_CONNECT 0x0f /* CMAPI connect */
156 #define CMAPI_DISCONNECT 0x10 /* CMAPI disconnect */
157 #define CMAPI_ACQUIRE 0x11 /* CMAPI acquire */
158 #define CMAPI_RELEASE 0x12 /* CMAPI release */
159 #define CMAPI_REG_READ 0x15 /* CMAPI DAP register read */
160 #define CMAPI_REG_WRITE 0x16 /* CMAPI DAP register write */
161 #define SWD_CONNECT 0x17 /* Switch from JTAG to SWD connection */
162 #define SWD_DISCONNECT 0x18 /* Switch from SWD to JTAG connection */
163 #define CJTAG_CONNECT 0x2b /* Switch from JTAG to cJTAG connection */
164 #define CJTAG_DISCONNECT 0x2c /* Switch from cJTAG to JTAG connection */
165 #define XDS_SET_SUPPLY 0x32 /* Set up stand-alone probe upply voltage */
166 #define OCD_DAP_REQUEST 0x3a /* Handle block of DAP requests */
167 #define OCD_SCAN_REQUEST 0x3b /* Handle block of JTAG scan requests */
168 #define OCD_PATHMOVE 0x3c /* Handle PATHMOVE to navigate JTAG states */
170 #define CMD_IR_SCAN 1
171 #define CMD_DR_SCAN 2
172 #define CMD_RUNTEST 3
173 #define CMD_STABLECLOCKS 4
175 /* Array to convert from OpenOCD tap_state_t to XDS JTAG state */
176 static const uint32_t xds_jtag_state
[] = {
177 XDS_JTAG_STATE_EXIT2_DR
, /* TAP_DREXIT2 = 0x0 */
178 XDS_JTAG_STATE_EXIT1_DR
, /* TAP_DREXIT1 = 0x1 */
179 XDS_JTAG_STATE_SHIFT_DR
, /* TAP_DRSHIFT = 0x2 */
180 XDS_JTAG_STATE_PAUSE_DR
, /* TAP_DRPAUSE = 0x3 */
181 XDS_JTAG_STATE_SELECT_IR
, /* TAP_IRSELECT = 0x4 */
182 XDS_JTAG_STATE_UPDATE_DR
, /* TAP_DRUPDATE = 0x5 */
183 XDS_JTAG_STATE_CAPTURE_DR
, /* TAP_DRCAPTURE = 0x6 */
184 XDS_JTAG_STATE_SELECT_DR
, /* TAP_DRSELECT = 0x7 */
185 XDS_JTAG_STATE_EXIT2_IR
, /* TAP_IREXIT2 = 0x8 */
186 XDS_JTAG_STATE_EXIT1_IR
, /* TAP_IREXIT1 = 0x9 */
187 XDS_JTAG_STATE_SHIFT_IR
, /* TAP_IRSHIFT = 0xa */
188 XDS_JTAG_STATE_PAUSE_IR
, /* TAP_IRPAUSE = 0xb */
189 XDS_JTAG_STATE_IDLE
, /* TAP_IDLE = 0xc */
190 XDS_JTAG_STATE_UPDATE_IR
, /* TAP_IRUPDATE = 0xd */
191 XDS_JTAG_STATE_CAPTURE_IR
, /* TAP_IRCAPTURE = 0xe */
192 XDS_JTAG_STATE_RESET
, /* TAP_RESET = 0xf */
202 /* USB connection handles and data buffers */
203 struct libusb_context
*ctx
;
204 struct libusb_device_handle
*dev
;
205 unsigned char read_payload
[USB_PAYLOAD_SIZE
];
206 unsigned char write_packet
[3];
207 unsigned char write_payload
[USB_PAYLOAD_SIZE
];
211 /* Debug interface */
214 uint8_t endpoint_out
;
217 bool is_cmapi_connected
;
218 bool is_cmapi_acquired
;
221 /* DAP register caches */
225 /* TCK speed and delay count*/
227 uint32_t delay_count
;
228 /* XDS110 voltage supply setting */
230 /* XDS110 firmware and hardware version */
233 /* Transaction queues */
234 unsigned char txn_requests
[MAX_DATA_BLOCK
];
235 uint32_t *txn_dap_results
[MAX_DATA_BLOCK
/ 4];
236 struct scan_result txn_scan_results
[MAX_DATA_BLOCK
/ 4];
237 uint32_t txn_request_size
;
238 uint32_t txn_result_size
;
239 uint32_t txn_result_count
;
242 static struct xds110_info xds110
= {
250 .is_connected
= false,
251 .is_cmapi_connected
= false,
252 .is_cmapi_acquired
= false,
253 .is_swd_mode
= false,
254 .is_ap_dirty
= false,
255 .speed
= XDS110_DEFAULT_TCK_SPEED
,
260 .txn_request_size
= 0,
261 .txn_result_size
= 0,
262 .txn_result_count
= 0
265 static inline void xds110_set_u32(uint8_t *buffer
, uint32_t value
)
267 buffer
[3] = (value
>> 24) & 0xff;
268 buffer
[2] = (value
>> 16) & 0xff;
269 buffer
[1] = (value
>> 8) & 0xff;
270 buffer
[0] = (value
>> 0) & 0xff;
273 static inline void xds110_set_u16(uint8_t *buffer
, uint16_t value
)
275 buffer
[1] = (value
>> 8) & 0xff;
276 buffer
[0] = (value
>> 0) & 0xff;
279 static inline uint32_t xds110_get_u32(uint8_t *buffer
)
281 uint32_t value
= (((uint32_t)buffer
[3]) << 24) |
282 (((uint32_t)buffer
[2]) << 16) |
283 (((uint32_t)buffer
[1]) << 8) |
284 (((uint32_t)buffer
[0]) << 0);
288 static inline uint16_t xds110_get_u16(uint8_t *buffer
)
290 uint16_t value
= (((uint32_t)buffer
[1]) << 8) |
291 (((uint32_t)buffer
[0]) << 0);
295 /***************************************************************************
296 * usb connection routines *
298 * The following functions handle connecting, reading, and writing to *
299 * the XDS110 over USB using the libusb library. *
300 ***************************************************************************/
302 static bool usb_connect(void)
304 struct libusb_context
*ctx
= NULL
;
305 struct libusb_device
**list
= NULL
;
306 struct libusb_device_handle
*dev
= NULL
;
308 struct libusb_device_descriptor desc
;
310 /* The vid/pids of possible XDS110 configurations */
311 uint16_t vids
[] = { 0x0451, 0x0451, 0x1cbe };
312 uint16_t pids
[] = { 0xbef3, 0xbef4, 0x02a5 };
313 /* Corresponding interface and endpoint numbers for configurations */
314 uint8_t interfaces
[] = { 2, 2, 0 };
315 uint8_t endpoints_in
[] = { 3, 3, 1 };
316 uint8_t endpoints_out
[] = { 2, 2, 1 };
325 /* Initialize libusb context */
326 result
= libusb_init(&ctx
);
329 /* Get list of USB devices attached to system */
330 count
= libusb_get_device_list(ctx
, &list
);
338 /* Scan through list of devices for any XDS110s */
339 for (i
= 0; i
< count
; i
++) {
340 /* Check for device vid/pid match */
341 libusb_get_device_descriptor(list
[i
], &desc
);
343 for (device
= 0; device
< ARRAY_SIZE(vids
); device
++) {
344 if (desc
.idVendor
== vids
[device
] &&
345 desc
.idProduct
== pids
[device
]) {
351 result
= libusb_open(list
[i
], &dev
);
353 const int max_data
= 256;
354 unsigned char data
[max_data
+ 1];
357 /* May be the requested device if serial number matches */
358 if (!adapter_get_required_serial()) {
359 /* No serial number given; match first XDS110 found */
363 /* Get the device's serial number string */
364 result
= libusb_get_string_descriptor_ascii(dev
,
365 desc
.iSerialNumber
, data
, max_data
);
367 strcmp((char *)data
, adapter_get_required_serial()) == 0) {
373 /* If we fall though to here, we don't want this device */
382 * We can fall through the for() loop with two possible exit conditions:
383 * 1) found the right XDS110, and that device is open
384 * 2) didn't find the XDS110, and no devices are currently open
388 /* Free the device list, we're done with it */
389 libusb_free_device_list(list
, 1);
393 /* Save the vid/pid of the device we're using */
394 xds110
.vid
= vids
[device
];
395 xds110
.pid
= pids
[device
];
397 /* Save the debug interface and endpoints for the device */
398 xds110
.interface
= interfaces
[device
];
399 xds110
.endpoint_in
= endpoints_in
[device
] | LIBUSB_ENDPOINT_IN
;
400 xds110
.endpoint_out
= endpoints_out
[device
] | LIBUSB_ENDPOINT_OUT
;
402 /* Save the context and device handles */
406 /* Set libusb to auto detach kernel */
407 (void)libusb_set_auto_detach_kernel_driver(dev
, 1);
409 /* Claim the debug interface on the XDS110 */
410 result
= libusb_claim_interface(dev
, xds110
.interface
);
412 /* Couldn't find an XDS110, flag the error */
416 /* On an error, clean up what we can */
419 /* Release the debug and data interface on the XDS110 */
420 (void)libusb_release_interface(dev
, xds110
.interface
);
429 /* Log the results */
431 LOG_INFO("XDS110: connected");
433 LOG_ERROR("XDS110: failed to connect");
435 return (result
== 0) ? true : false;
438 static void usb_disconnect(void)
441 /* Release the debug and data interface on the XDS110 */
442 (void)libusb_release_interface(xds110
.dev
, xds110
.interface
);
443 libusb_close(xds110
.dev
);
447 libusb_exit(xds110
.ctx
);
451 LOG_INFO("XDS110: disconnected");
454 static bool usb_read(unsigned char *buffer
, int size
, int *bytes_read
,
459 if (!xds110
.dev
|| !buffer
|| !bytes_read
)
462 /* Force a non-zero timeout to prevent blocking */
464 timeout
= DEFAULT_TIMEOUT
;
466 result
= libusb_bulk_transfer(xds110
.dev
, xds110
.endpoint_in
, buffer
, size
,
467 bytes_read
, timeout
);
469 return (result
== 0) ? true : false;
472 static bool usb_write(unsigned char *buffer
, int size
, int *written
)
474 int bytes_written
= 0;
475 int result
= LIBUSB_SUCCESS
;
478 if (!xds110
.dev
|| !buffer
)
481 result
= libusb_bulk_transfer(xds110
.dev
, xds110
.endpoint_out
, buffer
,
482 size
, &bytes_written
, 0);
484 while (result
== LIBUSB_ERROR_PIPE
&& retries
< 3) {
485 /* Try clearing the pipe stall and retry transfer */
486 libusb_clear_halt(xds110
.dev
, xds110
.endpoint_out
);
487 result
= libusb_bulk_transfer(xds110
.dev
, xds110
.endpoint_out
, buffer
,
488 size
, &bytes_written
, 0);
493 *written
= bytes_written
;
495 return (result
== 0 && size
== bytes_written
) ? true : false;
498 static bool usb_get_response(uint32_t *total_bytes_read
, uint32_t timeout
)
500 static unsigned char buffer
[MAX_PACKET
];
509 success
= usb_read(buffer
, sizeof(buffer
), &bytes_read
, timeout
);
512 * Validate that this appears to be a good response packet
513 * First check it contains enough data for header and error
514 * code, plus the first character is the start character
516 if (bytes_read
>= 7 && '*' == buffer
[0]) {
517 /* Extract the payload size */
518 size
= xds110_get_u16(&buffer
[1]);
519 /* Sanity test on payload size */
520 if (USB_PAYLOAD_SIZE
>= size
&& 4 <= size
) {
521 /* Check we didn't get more data than expected */
522 if ((bytes_read
- 3) <= size
) {
523 /* Packet appears to be valid, move on */
530 * Somehow received an invalid packet, retry till we
531 * time out or a valid response packet is received
535 /* Abort now if we didn't receive a valid response */
537 if (total_bytes_read
)
538 *total_bytes_read
= 0;
542 /* Build the return payload into xds110.read_payload */
544 /* Copy over payload data from received buffer (skipping header) */
547 memcpy((void *)&xds110
.read_payload
[count
], (void *)&buffer
[3], bytes_read
);
550 * Drop timeout to just 1/2 second. Once the XDS110 starts sending
551 * a response, the remaining packets should arrive in short order
554 timeout
= 500; /* ms */
556 /* If there's more data to retrieve, get it now */
557 while ((count
< size
) && success
) {
558 success
= usb_read(buffer
, sizeof(buffer
), &bytes_read
, timeout
);
560 if ((count
+ bytes_read
) > size
) {
561 /* Read too much data, not a valid packet, abort */
564 /* Copy this data over to xds110.read_payload */
565 memcpy((void *)&xds110
.read_payload
[count
], (void *)buffer
,
574 if (total_bytes_read
)
575 *total_bytes_read
= count
;
580 static bool usb_send_command(uint16_t size
)
585 /* Check the packet length */
586 if (size
> USB_PAYLOAD_SIZE
)
589 /* Place the start character into the packet buffer */
590 xds110
.write_packet
[0] = '*';
592 /* Place the payload size into the packet buffer */
593 xds110_set_u16(&xds110
.write_packet
[1], size
);
595 /* Adjust size to include header */
598 /* Send the data via the USB connection */
599 success
= usb_write(xds110
.write_packet
, (int)size
, &written
);
601 /* Check if the correct number of bytes was written */
602 if (written
!= (int)size
)
608 /***************************************************************************
609 * XDS110 firmware API routines *
611 * The following functions handle calling into the XDS110 firmware to *
612 * perform requested debug actions. *
613 ***************************************************************************/
615 static bool xds_execute(uint32_t out_length
, uint32_t in_length
,
616 uint32_t attempts
, uint32_t timeout
)
621 uint32_t bytes_read
= 0;
626 while (!done
&& attempts
> 0) {
629 /* Send command to XDS110 */
630 success
= usb_send_command(out_length
);
633 /* Get response from XDS110 */
634 success
= usb_get_response(&bytes_read
, timeout
);
638 /* Check for valid response from XDS code handling */
639 if (bytes_read
!= in_length
) {
640 /* Unexpected amount of data returned */
642 LOG_DEBUG("XDS110: command 0x%02x return %" PRIu32
" bytes, expected %" PRIu32
,
643 xds110
.write_payload
[0], bytes_read
, in_length
);
645 /* Extract error code from return packet */
646 error
= (int)xds110_get_u32(&xds110
.read_payload
[0]);
648 if (error
!= SC_ERR_NONE
)
649 LOG_DEBUG("XDS110: command 0x%02x returned error %d",
650 xds110
.write_payload
[0], error
);
656 error
= SC_ERR_XDS110_FAIL
;
664 static bool xds_connect(void)
668 xds110
.write_payload
[0] = XDS_CONNECT
;
670 success
= xds_execute(XDS_OUT_LEN
, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
676 static bool xds_disconnect(void)
680 xds110
.write_payload
[0] = XDS_DISCONNECT
;
682 success
= xds_execute(XDS_OUT_LEN
, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
688 static bool xds_version(uint32_t *firmware_id
, uint16_t *hardware_id
)
690 uint8_t *fw_id_pntr
= &xds110
.read_payload
[XDS_IN_LEN
+ 0]; /* 32-bits */
691 uint8_t *hw_id_pntr
= &xds110
.read_payload
[XDS_IN_LEN
+ 4]; /* 16-bits */
695 xds110
.write_payload
[0] = XDS_VERSION
;
697 success
= xds_execute(XDS_OUT_LEN
, XDS_IN_LEN
+ 6, DEFAULT_ATTEMPTS
,
702 *firmware_id
= xds110_get_u32(fw_id_pntr
);
704 *hardware_id
= xds110_get_u16(hw_id_pntr
);
710 static bool xds_set_tck_delay(uint32_t delay
)
712 uint8_t *delay_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 0]; /* 32-bits */
716 xds110
.write_payload
[0] = XDS_SET_TCK
;
718 xds110_set_u32(delay_pntr
, delay
);
720 success
= xds_execute(XDS_OUT_LEN
+ 4, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
726 static bool xds_set_trst(uint8_t trst
)
728 uint8_t *trst_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 0]; /* 8-bits */
732 xds110
.write_payload
[0] = XDS_SET_TRST
;
736 success
= xds_execute(XDS_OUT_LEN
+ 1, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
742 static bool xds_cycle_tck(uint32_t count
)
744 uint8_t *count_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 0]; /* 32-bits */
748 xds110
.write_payload
[0] = XDS_CYCLE_TCK
;
750 xds110_set_u32(count_pntr
, count
);
752 success
= xds_execute(XDS_OUT_LEN
+ 4, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
758 static bool xds_goto_state(uint32_t state
)
760 uint8_t *state_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 0]; /* 32-bits */
761 uint8_t *transit_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+4]; /* 32-bits */
765 xds110
.write_payload
[0] = XDS_GOTO_STATE
;
767 xds110_set_u32(state_pntr
, state
);
768 xds110_set_u32(transit_pntr
, XDS_JTAG_TRANSIT_QUICKEST
);
770 success
= xds_execute(XDS_OUT_LEN
+8, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
776 static bool xds_jtag_scan(uint32_t shift_state
, uint16_t shift_bits
,
777 uint32_t end_state
, uint8_t *data_out
, uint8_t *data_in
)
779 uint8_t *bits_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 0]; /* 16-bits */
780 uint8_t *path_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 2]; /* 8-bits */
781 uint8_t *trans1_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 3]; /* 8-bits */
782 uint8_t *end_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 4]; /* 8-bits */
783 uint8_t *trans2_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 5]; /* 8-bits */
784 uint8_t *pre_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 6]; /* 16-bits */
785 uint8_t *pos_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 8]; /* 16-bits */
786 uint8_t *delay_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 10]; /* 16-bits */
787 uint8_t *rep_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 12]; /* 16-bits */
788 uint8_t *out_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 14]; /* 16-bits */
789 uint8_t *in_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 16]; /* 16-bits */
790 uint8_t *data_out_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 18];
791 uint8_t *data_in_pntr
= &xds110
.read_payload
[XDS_IN_LEN
+0];
793 uint16_t total_bytes
= DIV_ROUND_UP(shift_bits
, 8);
797 xds110
.write_payload
[0] = XDS_JTAG_SCAN
;
799 xds110_set_u16(bits_pntr
, shift_bits
); /* bits to scan */
800 *path_pntr
= (uint8_t)(shift_state
& 0xff); /* IR vs DR path */
801 *trans1_pntr
= (uint8_t)XDS_JTAG_TRANSIT_QUICKEST
; /* start state route */
802 *end_pntr
= (uint8_t)(end_state
& 0xff); /* JTAG state after scan */
803 *trans2_pntr
= (uint8_t)XDS_JTAG_TRANSIT_QUICKEST
; /* end state route */
804 xds110_set_u16(pre_pntr
, 0); /* number of preamble bits */
805 xds110_set_u16(pos_pntr
, 0); /* number of postamble bits */
806 xds110_set_u16(delay_pntr
, 0); /* number of extra TCKs after scan */
807 xds110_set_u16(rep_pntr
, 1); /* number of repetitions */
808 xds110_set_u16(out_pntr
, total_bytes
); /* out buffer offset (if repeats) */
809 xds110_set_u16(in_pntr
, total_bytes
); /* in buffer offset (if repeats) */
811 memcpy((void *)data_out_pntr
, (void *)data_out
, total_bytes
);
813 success
= xds_execute(XDS_OUT_LEN
+ 18 + total_bytes
,
814 XDS_IN_LEN
+ total_bytes
, DEFAULT_ATTEMPTS
, DEFAULT_TIMEOUT
);
817 memcpy((void *)data_in
, (void *)data_in_pntr
, total_bytes
);
822 static bool xds_set_srst(uint8_t srst
)
824 uint8_t *srst_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 0]; /* 8-bits */
828 xds110
.write_payload
[0] = XDS_SET_SRST
;
832 success
= xds_execute(XDS_OUT_LEN
+ 1, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
838 static bool cmapi_connect(uint32_t *idcode
)
840 uint8_t *idcode_pntr
= &xds110
.read_payload
[XDS_IN_LEN
+ 0]; /* 32-bits */
844 xds110
.write_payload
[0] = CMAPI_CONNECT
;
846 success
= xds_execute(XDS_OUT_LEN
, XDS_IN_LEN
+4, DEFAULT_ATTEMPTS
,
851 *idcode
= xds110_get_u32(idcode_pntr
);
857 static bool cmapi_disconnect(void)
861 xds110
.write_payload
[0] = CMAPI_DISCONNECT
;
863 success
= xds_execute(XDS_OUT_LEN
, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
869 static bool cmapi_acquire(void)
873 xds110
.write_payload
[0] = CMAPI_ACQUIRE
;
875 success
= xds_execute(XDS_OUT_LEN
, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
881 static bool cmapi_release(void)
885 xds110
.write_payload
[0] = CMAPI_RELEASE
;
887 success
= xds_execute(XDS_OUT_LEN
, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
893 static bool cmapi_read_dap_reg(uint32_t type
, uint32_t ap_num
,
894 uint32_t address
, uint32_t *value
)
896 uint8_t *type_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 0]; /* 8-bits */
897 uint8_t *ap_num_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 1]; /* 8-bits */
898 uint8_t *address_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 2]; /* 8-bits */
899 uint8_t *value_pntr
= &xds110
.read_payload
[XDS_IN_LEN
+ 0]; /* 32-bits */
903 xds110
.write_payload
[0] = CMAPI_REG_READ
;
905 *type_pntr
= (uint8_t)(type
& 0xff);
906 *ap_num_pntr
= (uint8_t)(ap_num
& 0xff);
907 *address_pntr
= (uint8_t)(address
& 0xff);
909 success
= xds_execute(XDS_OUT_LEN
+ 3, XDS_IN_LEN
+ 4, DEFAULT_ATTEMPTS
,
914 *value
= xds110_get_u32(value_pntr
);
920 static bool cmapi_write_dap_reg(uint32_t type
, uint32_t ap_num
,
921 uint32_t address
, uint32_t *value
)
923 uint8_t *type_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 0]; /* 8-bits */
924 uint8_t *ap_num_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 1]; /* 8-bits */
925 uint8_t *address_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 2]; /* 8-bits */
926 uint8_t *value_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 3]; /* 32-bits */
933 xds110
.write_payload
[0] = CMAPI_REG_WRITE
;
935 *type_pntr
= (uint8_t)(type
& 0xff);
936 *ap_num_pntr
= (uint8_t)(ap_num
& 0xff);
937 *address_pntr
= (uint8_t)(address
& 0xff);
938 xds110_set_u32(value_pntr
, *value
);
940 success
= xds_execute(XDS_OUT_LEN
+ 7, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
946 static bool swd_connect(void)
950 xds110
.write_payload
[0] = SWD_CONNECT
;
952 success
= xds_execute(XDS_OUT_LEN
, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
958 static bool swd_disconnect(void)
962 xds110
.write_payload
[0] = SWD_DISCONNECT
;
964 success
= xds_execute(XDS_OUT_LEN
, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
970 static bool cjtag_connect(uint32_t format
)
972 uint8_t *format_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 0]; /* 32-bits */
976 xds110
.write_payload
[0] = CJTAG_CONNECT
;
978 xds110_set_u32(format_pntr
, format
);
980 success
= xds_execute(XDS_OUT_LEN
+ 4, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
986 static bool cjtag_disconnect(void)
990 xds110
.write_payload
[0] = CJTAG_DISCONNECT
;
992 success
= xds_execute(XDS_OUT_LEN
, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
998 static bool xds_set_supply(uint32_t voltage
)
1000 uint8_t *volts_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 0]; /* 32-bits */
1001 uint8_t *source_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 4]; /* 8-bits */
1005 xds110
.write_payload
[0] = XDS_SET_SUPPLY
;
1007 xds110_set_u32(volts_pntr
, voltage
);
1008 *source_pntr
= (uint8_t)(voltage
!= 0 ? 1 : 0);
1010 success
= xds_execute(XDS_OUT_LEN
+ 5, XDS_IN_LEN
, DEFAULT_ATTEMPTS
,
1016 static bool ocd_dap_request(uint8_t *dap_requests
, uint32_t request_size
,
1017 uint32_t *dap_results
, uint32_t result_count
)
1019 uint8_t *request_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 0];
1020 uint8_t *result_pntr
= &xds110
.read_payload
[XDS_IN_LEN
+ 0];
1024 if (!dap_requests
|| !dap_results
)
1027 xds110
.write_payload
[0] = OCD_DAP_REQUEST
;
1029 memcpy((void *)request_pntr
, (void *)dap_requests
, request_size
);
1031 success
= xds_execute(XDS_OUT_LEN
+ request_size
,
1032 XDS_IN_LEN
+ (result_count
* 4), DEFAULT_ATTEMPTS
,
1035 if (success
&& (result_count
> 0))
1036 memcpy((void *)dap_results
, (void *)result_pntr
, result_count
* 4);
1041 static bool ocd_scan_request(uint8_t *scan_requests
, uint32_t request_size
,
1042 uint8_t *scan_results
, uint32_t result_size
)
1044 uint8_t *request_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 0];
1045 uint8_t *result_pntr
= &xds110
.read_payload
[XDS_IN_LEN
+ 0];
1049 if (!scan_requests
|| !scan_results
)
1052 xds110
.write_payload
[0] = OCD_SCAN_REQUEST
;
1054 memcpy((void *)request_pntr
, (void *)scan_requests
, request_size
);
1056 success
= xds_execute(XDS_OUT_LEN
+ request_size
,
1057 XDS_IN_LEN
+ result_size
, DEFAULT_ATTEMPTS
,
1060 if (success
&& (result_size
> 0))
1061 memcpy((void *)scan_results
, (void *)result_pntr
, result_size
);
1066 static bool ocd_pathmove(uint32_t num_states
, uint8_t *path
)
1068 uint8_t *num_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 0]; /* 32-bits */
1069 uint8_t *path_pntr
= &xds110
.write_payload
[XDS_OUT_LEN
+ 4];
1076 xds110
.write_payload
[0] = OCD_PATHMOVE
;
1078 xds110_set_u32(num_pntr
, num_states
);
1080 memcpy((void *)path_pntr
, (void *)path
, num_states
);
1082 success
= xds_execute(XDS_OUT_LEN
+ 4 + num_states
, XDS_IN_LEN
,
1083 DEFAULT_ATTEMPTS
, DEFAULT_TIMEOUT
);
1088 /***************************************************************************
1089 * swd driver interface *
1091 * The following functions provide SWD support to OpenOCD. *
1092 ***************************************************************************/
1094 static int xds110_swd_init(void)
1096 xds110
.is_swd_mode
= true;
1100 static int xds110_swd_switch_seq(enum swd_special_seq seq
)
1107 LOG_ERROR("Sequence SWD line reset (%d) not supported", seq
);
1110 LOG_DEBUG("JTAG-to-SWD");
1111 xds110
.is_swd_mode
= false;
1112 xds110
.is_cmapi_connected
= false;
1113 xds110
.is_cmapi_acquired
= false;
1114 /* Run sequence to put target in SWD mode */
1115 success
= swd_connect();
1116 /* Re-initialize CMAPI API for DAP access */
1118 xds110
.is_swd_mode
= true;
1119 success
= cmapi_connect(&idcode
);
1121 xds110
.is_cmapi_connected
= true;
1122 success
= cmapi_acquire();
1127 LOG_DEBUG("SWD-to-JTAG");
1128 xds110
.is_swd_mode
= false;
1129 xds110
.is_cmapi_connected
= false;
1130 xds110
.is_cmapi_acquired
= false;
1131 /* Run sequence to put target in JTAG mode */
1132 success
= swd_disconnect();
1134 /* Re-initialize JTAG interface */
1135 success
= cjtag_connect(MODE_JTAG
);
1139 LOG_ERROR("Sequence %d not supported", seq
);
1149 static bool xds110_legacy_read_reg(uint8_t cmd
, uint32_t *value
)
1151 /* Make sure this is a read request */
1152 bool is_read_request
= (0 != (SWD_CMD_RNW
& cmd
));
1153 /* Determine whether this is a DP or AP register access */
1154 uint32_t type
= (0 != (SWD_CMD_APNDP
& cmd
)) ? DAP_AP
: DAP_DP
;
1155 /* Determine the AP number from cached SELECT value */
1156 uint32_t ap_num
= (xds110
.select
& 0xff000000) >> 24;
1157 /* Extract register address from command */
1158 uint32_t address
= ((cmd
& SWD_CMD_A32
) >> 1);
1159 /* Extract bank address from cached SELECT value */
1160 uint32_t bank
= (xds110
.select
& 0x000000f0);
1162 uint32_t reg_value
= 0;
1163 uint32_t temp_value
= 0;
1167 if (!is_read_request
)
1170 if (type
== DAP_AP
) {
1171 /* Add bank address to register address for CMAPI call */
1175 if (DAP_DP
== type
&& DAP_DP_RDBUFF
== address
&& xds110
.use_rdbuff
) {
1176 /* If RDBUFF is cached and this is a DP RDBUFF read, use the cache */
1177 reg_value
= xds110
.rdbuff
;
1179 } else if (DAP_AP
== type
&& DAP_AP_DRW
== address
&& xds110
.use_rdbuff
) {
1180 /* If RDBUFF is cached and this is an AP DRW read, use the cache, */
1181 /* but still call into the firmware to get the next read. */
1182 reg_value
= xds110
.rdbuff
;
1183 success
= cmapi_read_dap_reg(type
, ap_num
, address
, &temp_value
);
1185 success
= cmapi_read_dap_reg(type
, ap_num
, address
, &temp_value
);
1187 reg_value
= temp_value
;
1190 /* Mark that we have consumed or invalidated the RDBUFF cache */
1191 xds110
.use_rdbuff
= false;
1193 /* Handle result of read attempt */
1195 LOG_ERROR("XDS110: failed to read DAP register");
1199 if (success
&& DAP_AP
== type
) {
1201 * On a successful DAP AP read, we actually have the value from RDBUFF,
1202 * the firmware will have run the AP request and made the RDBUFF read
1204 xds110
.use_rdbuff
= true;
1205 xds110
.rdbuff
= temp_value
;
1211 static bool xds110_legacy_write_reg(uint8_t cmd
, uint32_t value
)
1213 /* Make sure this isn't a read request */
1214 bool is_read_request
= (0 != (SWD_CMD_RNW
& cmd
));
1215 /* Determine whether this is a DP or AP register access */
1216 uint32_t type
= (0 != (SWD_CMD_APNDP
& cmd
)) ? DAP_AP
: DAP_DP
;
1217 /* Determine the AP number from cached SELECT value */
1218 uint32_t ap_num
= (xds110
.select
& 0xff000000) >> 24;
1219 /* Extract register address from command */
1220 uint32_t address
= ((cmd
& SWD_CMD_A32
) >> 1);
1221 /* Extract bank address from cached SELECT value */
1222 uint32_t bank
= (xds110
.select
& 0x000000f0);
1226 if (is_read_request
)
1229 /* Invalidate the RDBUFF cache */
1230 xds110
.use_rdbuff
= false;
1232 if (type
== DAP_AP
) {
1233 /* Add bank address to register address for CMAPI call */
1235 /* Any write to an AP register invalidates the firmware's cache */
1236 xds110
.is_ap_dirty
= true;
1237 } else if (address
== DAP_DP_SELECT
) {
1238 /* Any write to the SELECT register invalidates the firmware's cache */
1239 xds110
.is_ap_dirty
= true;
1242 success
= cmapi_write_dap_reg(type
, ap_num
, address
, &value
);
1245 LOG_ERROR("XDS110: failed to write DAP register");
1248 * If the debugger wrote to SELECT, cache the value
1249 * to use to build the apNum and address values above
1251 if ((type
== DAP_DP
) && (address
== DAP_DP_SELECT
))
1252 xds110
.select
= value
;
1258 static int xds110_swd_run_queue(void)
1260 static uint32_t dap_results
[MAX_RESULT_QUEUE
];
1265 bool success
= true;
1267 if (xds110
.txn_request_size
== 0)
1270 /* Terminate request queue */
1271 xds110
.txn_requests
[xds110
.txn_request_size
++] = 0;
1273 if (xds110
.firmware
>= OCD_FIRMWARE_VERSION
) {
1274 /* XDS110 firmware has the API to directly handle the queue */
1275 success
= ocd_dap_request(xds110
.txn_requests
,
1276 xds110
.txn_request_size
, dap_results
, xds110
.txn_result_count
);
1278 /* Legacy firmware needs to handle queue via discrete DAP calls */
1281 while (xds110
.txn_requests
[request
] != 0) {
1282 cmd
= xds110
.txn_requests
[request
++];
1283 if (0 == (SWD_CMD_RNW
& cmd
)) {
1284 /* DAP register write command */
1285 value
= (uint32_t)(xds110
.txn_requests
[request
++]) << 0;
1286 value
|= (uint32_t)(xds110
.txn_requests
[request
++]) << 8;
1287 value
|= (uint32_t)(xds110
.txn_requests
[request
++]) << 16;
1288 value
|= (uint32_t)(xds110
.txn_requests
[request
++]) << 24;
1290 success
= xds110_legacy_write_reg(cmd
, value
);
1292 /* DAP register read command */
1295 success
= xds110_legacy_read_reg(cmd
, &value
);
1296 dap_results
[result
++] = value
;
1301 /* Transfer results into caller's buffers */
1302 for (result
= 0; result
< xds110
.txn_result_count
; result
++)
1303 if (xds110
.txn_dap_results
[result
] != 0)
1304 *xds110
.txn_dap_results
[result
] = dap_results
[result
];
1306 xds110
.txn_request_size
= 0;
1307 xds110
.txn_result_size
= 0;
1308 xds110
.txn_result_count
= 0;
1310 return (success
) ? ERROR_OK
: ERROR_FAIL
;
1313 static void xds110_swd_queue_cmd(uint8_t cmd
, uint32_t *value
)
1315 /* Check if this is a read or write request */
1316 bool is_read_request
= (0 != (SWD_CMD_RNW
& cmd
));
1317 /* Determine whether this is a DP or AP register access */
1318 uint32_t type
= (0 != (SWD_CMD_APNDP
& cmd
)) ? DAP_AP
: DAP_DP
;
1319 /* Extract register address from command */
1320 uint32_t address
= ((cmd
& SWD_CMD_A32
) >> 1);
1321 uint32_t request_size
= (is_read_request
) ? 1 : 5;
1323 /* Check if new request would be too large to fit */
1324 if (((xds110
.txn_request_size
+ request_size
+ 1) > MAX_DATA_BLOCK
) ||
1325 ((xds110
.txn_result_count
+ 1) > MAX_RESULT_QUEUE
))
1326 xds110_swd_run_queue();
1328 /* Set the START bit in cmd to ensure cmd is not zero */
1329 /* (a value of zero is used to terminate the buffer) */
1330 cmd
|= SWD_CMD_START
;
1332 /* Add request to queue; queue is built marshalled for XDS110 call */
1333 if (is_read_request
) {
1334 /* Queue read request, save pointer to pass back result */
1335 xds110
.txn_requests
[xds110
.txn_request_size
++] = cmd
;
1336 xds110
.txn_dap_results
[xds110
.txn_result_count
++] = value
;
1337 xds110
.txn_result_size
+= 4;
1339 /* Check for and prevent sticky overrun detection */
1340 if (DAP_DP
== type
&& DAP_DP_CTRL
== address
&&
1341 (*value
& CORUNDETECT
)) {
1342 LOG_DEBUG("XDS110: refusing to enable sticky overrun detection");
1343 *value
&= ~CORUNDETECT
;
1345 /* Queue write request, add value directly to queue buffer */
1346 xds110
.txn_requests
[xds110
.txn_request_size
++] = cmd
;
1347 xds110
.txn_requests
[xds110
.txn_request_size
++] = (*value
>> 0) & 0xff;
1348 xds110
.txn_requests
[xds110
.txn_request_size
++] = (*value
>> 8) & 0xff;
1349 xds110
.txn_requests
[xds110
.txn_request_size
++] = (*value
>> 16) & 0xff;
1350 xds110
.txn_requests
[xds110
.txn_request_size
++] = (*value
>> 24) & 0xff;
1354 static void xds110_swd_read_reg(uint8_t cmd
, uint32_t *value
,
1355 uint32_t ap_delay_clk
)
1357 xds110_swd_queue_cmd(cmd
, value
);
1359 static void xds110_swd_write_reg(uint8_t cmd
, uint32_t value
,
1360 uint32_t ap_delay_clk
)
1362 xds110_swd_queue_cmd(cmd
, &value
);
1365 /***************************************************************************
1368 * The following functions provide XDS110 interface to OpenOCD. *
1369 ***************************************************************************/
1371 static void xds110_show_info(void)
1373 uint32_t firmware
= xds110
.firmware
;
1375 LOG_INFO("XDS110: vid/pid = %04x/%04x", xds110
.vid
, xds110
.pid
);
1376 LOG_INFO("XDS110: firmware version = %" PRIu32
".%" PRIu32
".%" PRIu32
".%" PRIu32
,
1377 (((firmware
>> 28) & 0xf) * 10) + ((firmware
>> 24) & 0xf),
1378 (((firmware
>> 20) & 0xf) * 10) + ((firmware
>> 16) & 0xf),
1379 (((firmware
>> 12) & 0xf) * 10) + ((firmware
>> 8) & 0xf),
1380 (((firmware
>> 4) & 0xf) * 10) + ((firmware
>> 0) & 0xf));
1381 LOG_INFO("XDS110: hardware version = 0x%04x", xds110
.hardware
);
1382 if (adapter_get_required_serial())
1383 LOG_INFO("XDS110: serial number = %s", adapter_get_required_serial());
1384 if (xds110
.is_swd_mode
) {
1385 LOG_INFO("XDS110: connected to target via SWD");
1386 LOG_INFO("XDS110: SWCLK set to %" PRIu32
" kHz", xds110
.speed
);
1388 LOG_INFO("XDS110: connected to target via JTAG");
1389 LOG_INFO("XDS110: TCK set to %" PRIu32
" kHz", xds110
.speed
);
1392 /* Alert user that there's a better firmware to use */
1393 if (firmware
< OCD_FIRMWARE_VERSION
) {
1394 LOG_WARNING("XDS110: the firmware is not optimized for OpenOCD");
1395 LOG_WARNING(OCD_FIRMWARE_UPGRADE
);
1399 static int xds110_quit(void)
1401 if (xds110
.is_cmapi_acquired
) {
1402 (void)cmapi_release();
1403 xds110
.is_cmapi_acquired
= false;
1405 if (xds110
.is_cmapi_connected
) {
1406 (void)cmapi_disconnect();
1407 xds110
.is_cmapi_connected
= false;
1409 if (xds110
.is_connected
) {
1410 if (xds110
.is_swd_mode
) {
1411 /* Switch out of SWD mode */
1412 (void)swd_disconnect();
1414 /* Switch out of cJTAG mode */
1415 (void)cjtag_disconnect();
1417 /* Tell firmware we're disconnecting */
1418 (void)xds_disconnect();
1419 xds110
.is_connected
= false;
1421 /* Close down the USB connection to the XDS110 debug probe */
1427 static int xds110_init(void)
1431 /* Establish USB connection to the XDS110 debug probe */
1432 success
= usb_connect();
1435 /* Send connect message to XDS110 firmware */
1436 success
= xds_connect();
1438 xds110
.is_connected
= true;
1445 /* Retrieve version IDs from firmware */
1446 /* Version numbers are stored in BCD format */
1447 success
= xds_version(&firmware
, &hardware
);
1449 /* Save the firmware and hardware version */
1450 xds110
.firmware
= firmware
;
1451 xds110
.hardware
= hardware
;
1456 /* Set supply voltage for stand-alone probes */
1457 if (xds110
.hardware
== XDS110_STAND_ALONE_ID
) {
1458 success
= xds_set_supply(xds110
.voltage
);
1459 /* Allow time for target device to power up */
1460 /* (CC32xx takes up to 1300 ms before debug is enabled) */
1462 } else if (xds110
.voltage
!= 0) {
1463 /* Voltage supply not a feature of embedded probes */
1465 "XDS110: ignoring supply voltage, not supported on this probe");
1470 success
= xds_set_trst(0);
1472 success
= xds_cycle_tck(50);
1474 success
= xds_set_trst(1);
1476 success
= xds_cycle_tck(50);
1480 if (xds110
.is_swd_mode
) {
1481 /* Switch to SWD if needed */
1482 success
= swd_connect();
1484 success
= cjtag_connect(MODE_JTAG
);
1488 if (success
&& xds110
.is_swd_mode
) {
1491 /* Connect to CMAPI interface in XDS110 */
1492 success
= cmapi_connect(&idcode
);
1494 /* Acquire exclusive access to CMAPI interface */
1496 xds110
.is_cmapi_connected
= true;
1497 success
= cmapi_acquire();
1499 xds110
.is_cmapi_acquired
= true;
1509 return (success
) ? ERROR_OK
: ERROR_FAIL
;
1512 static void xds110_legacy_scan(uint32_t shift_state
, uint32_t total_bits
,
1513 uint32_t end_state
, uint8_t *data_out
, uint8_t *data_in
)
1515 (void)xds_jtag_scan(shift_state
, total_bits
, end_state
, data_out
, data_in
);
1518 static void xds110_legacy_runtest(uint32_t clocks
, uint32_t end_state
)
1520 xds_goto_state(XDS_JTAG_STATE_IDLE
);
1521 xds_cycle_tck(clocks
);
1522 xds_goto_state(end_state
);
1525 static void xds110_legacy_stableclocks(uint32_t clocks
)
1527 xds_cycle_tck(clocks
);
1530 static void xds110_flush(void)
1534 uint32_t shift_state
;
1541 uint8_t data_in
[MAX_DATA_BLOCK
];
1544 if (xds110
.txn_request_size
== 0)
1547 /* Terminate request queue */
1548 xds110
.txn_requests
[xds110
.txn_request_size
++] = 0;
1550 if (xds110
.firmware
>= OCD_FIRMWARE_VERSION
) {
1551 /* Updated firmware has the API to directly handle the queue */
1552 (void)ocd_scan_request(xds110
.txn_requests
, xds110
.txn_request_size
,
1553 data_in
, xds110
.txn_result_size
);
1555 /* Legacy firmware needs to handle queue via discrete JTAG calls */
1558 while (xds110
.txn_requests
[request
] != 0) {
1559 command
= xds110
.txn_requests
[request
++];
1563 if (command
== CMD_IR_SCAN
)
1564 shift_state
= XDS_JTAG_STATE_SHIFT_IR
;
1566 shift_state
= XDS_JTAG_STATE_SHIFT_DR
;
1567 end_state
= (uint32_t)(xds110
.txn_requests
[request
++]);
1568 bits
= (uint32_t)(xds110
.txn_requests
[request
++]) << 0;
1569 bits
|= (uint32_t)(xds110
.txn_requests
[request
++]) << 8;
1570 data_out
= &xds110
.txn_requests
[request
];
1571 bytes
= DIV_ROUND_UP(bits
, 8);
1572 xds110_legacy_scan(shift_state
, bits
, end_state
, data_out
,
1578 clocks
= (uint32_t)(xds110
.txn_requests
[request
++]) << 0;
1579 clocks
|= (uint32_t)(xds110
.txn_requests
[request
++]) << 8;
1580 clocks
|= (uint32_t)(xds110
.txn_requests
[request
++]) << 16;
1581 clocks
|= (uint32_t)(xds110
.txn_requests
[request
++]) << 24;
1582 end_state
= (uint32_t)xds110
.txn_requests
[request
++];
1583 xds110_legacy_runtest(clocks
, end_state
);
1585 case CMD_STABLECLOCKS
:
1586 clocks
= (uint32_t)(xds110
.txn_requests
[request
++]) << 0;
1587 clocks
|= (uint32_t)(xds110
.txn_requests
[request
++]) << 8;
1588 clocks
|= (uint32_t)(xds110
.txn_requests
[request
++]) << 16;
1589 clocks
|= (uint32_t)(xds110
.txn_requests
[request
++]) << 24;
1590 xds110_legacy_stableclocks(clocks
);
1593 LOG_ERROR("BUG: unknown JTAG command type 0x%x encountered",
1601 /* Transfer results into caller's buffers from data_in buffer */
1602 bits
= 0; /* Bit offset into current scan result */
1603 data_pntr
= data_in
;
1604 for (result
= 0; result
< xds110
.txn_result_count
; result
++) {
1605 if (xds110
.txn_scan_results
[result
].first
) {
1607 bytes
= DIV_ROUND_UP(bits
, 8);
1612 if (xds110
.txn_scan_results
[result
].buffer
!= 0)
1613 bit_copy(xds110
.txn_scan_results
[result
].buffer
, 0, data_pntr
,
1614 bits
, xds110
.txn_scan_results
[result
].num_bits
);
1615 bits
+= xds110
.txn_scan_results
[result
].num_bits
;
1618 xds110
.txn_request_size
= 0;
1619 xds110
.txn_result_size
= 0;
1620 xds110
.txn_result_count
= 0;
1623 static int xds110_reset(int trst
, int srst
)
1627 int retval
= ERROR_OK
;
1631 /* Deassert nTRST (active low) */
1634 /* Assert nTRST (active low) */
1637 success
= xds_set_trst(value
);
1639 retval
= ERROR_FAIL
;
1644 /* Deassert nSRST (active low) */
1647 /* Assert nSRST (active low) */
1650 success
= xds_set_srst(value
);
1652 retval
= ERROR_FAIL
;
1654 /* Toggle TCK to trigger HIB on CC13x/CC26x devices */
1655 if (success
&& !xds110
.is_swd_mode
) {
1656 /* Toggle TCK for about 50 ms */
1657 success
= xds_cycle_tck(xds110
.speed
* 50);
1661 retval
= ERROR_FAIL
;
1667 static void xds110_execute_sleep(struct jtag_command
*cmd
)
1669 jtag_sleep(cmd
->cmd
.sleep
->us
);
1672 static void xds110_execute_tlr_reset(struct jtag_command
*cmd
)
1674 (void)xds_goto_state(XDS_JTAG_STATE_RESET
);
1677 static void xds110_execute_pathmove(struct jtag_command
*cmd
)
1680 uint32_t num_states
;
1683 num_states
= (uint32_t)cmd
->cmd
.pathmove
->num_states
;
1685 if (num_states
== 0)
1688 path
= (uint8_t *)malloc(num_states
* sizeof(uint8_t));
1690 LOG_ERROR("XDS110: unable to allocate memory");
1694 /* Convert requested path states into XDS API states */
1695 for (i
= 0; i
< num_states
; i
++)
1696 path
[i
] = (uint8_t)xds_jtag_state
[cmd
->cmd
.pathmove
->path
[i
]];
1698 if (xds110
.firmware
>= OCD_FIRMWARE_VERSION
) {
1699 /* Updated firmware fully supports pathmove */
1700 (void)ocd_pathmove(num_states
, path
);
1702 /* Notify user that legacy firmware simply cannot handle pathmove */
1703 LOG_ERROR("XDS110: the firmware does not support pathmove command");
1704 LOG_ERROR(OCD_FIRMWARE_UPGRADE
);
1705 /* If pathmove is required, then debug is not possible */
1712 static void xds110_queue_scan(struct jtag_command
*cmd
)
1716 uint32_t total_fields
;
1717 uint32_t total_bits
;
1718 uint32_t total_bytes
;
1722 /* Calculate the total number of bits to scan */
1725 for (i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++) {
1727 total_bits
+= (uint32_t)cmd
->cmd
.scan
->fields
[i
].num_bits
;
1730 if (total_bits
== 0)
1733 total_bytes
= DIV_ROUND_UP(total_bits
, 8);
1735 /* Check if new request would be too large to fit */
1736 if (((xds110
.txn_request_size
+ 1 + total_bytes
+ sizeof(end_state
) + 1)
1737 > MAX_DATA_BLOCK
) || ((xds110
.txn_result_count
+ total_fields
) >
1741 /* Check if this single request is too large to fit */
1742 if ((1 + total_bytes
+ sizeof(end_state
) + 1) > MAX_DATA_BLOCK
) {
1743 LOG_ERROR("BUG: JTAG scan request is too large to handle (%" PRIu32
" bits)",
1745 /* Failing to run this scan mucks up debug on this target */
1749 if (cmd
->cmd
.scan
->ir_scan
)
1750 xds110
.txn_requests
[xds110
.txn_request_size
++] = CMD_IR_SCAN
;
1752 xds110
.txn_requests
[xds110
.txn_request_size
++] = CMD_DR_SCAN
;
1754 end_state
= (uint8_t)xds_jtag_state
[cmd
->cmd
.scan
->end_state
];
1755 xds110
.txn_requests
[xds110
.txn_request_size
++] = end_state
;
1757 xds110
.txn_requests
[xds110
.txn_request_size
++] = (total_bits
>> 0) & 0xff;
1758 xds110
.txn_requests
[xds110
.txn_request_size
++] = (total_bits
>> 8) & 0xff;
1760 /* Build request data by flattening fields into single buffer */
1761 /* also populate the results array to return the results when run */
1763 buffer
= &xds110
.txn_requests
[xds110
.txn_request_size
];
1764 /* Clear data out buffer to default value of all zeros */
1765 memset((void *)buffer
, 0x00, total_bytes
);
1766 for (i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++) {
1767 if (cmd
->cmd
.scan
->fields
[i
].out_value
!= 0) {
1768 /* Copy over data to scan out into request buffer */
1769 bit_copy(buffer
, offset
, cmd
->cmd
.scan
->fields
[i
].out_value
, 0,
1770 cmd
->cmd
.scan
->fields
[i
].num_bits
);
1772 offset
+= cmd
->cmd
.scan
->fields
[i
].num_bits
;
1773 xds110
.txn_scan_results
[xds110
.txn_result_count
].first
= (i
== 0);
1774 xds110
.txn_scan_results
[xds110
.txn_result_count
].num_bits
=
1775 cmd
->cmd
.scan
->fields
[i
].num_bits
;
1776 xds110
.txn_scan_results
[xds110
.txn_result_count
++].buffer
=
1777 cmd
->cmd
.scan
->fields
[i
].in_value
;
1779 xds110
.txn_request_size
+= total_bytes
;
1780 xds110
.txn_result_size
+= total_bytes
;
1783 static void xds110_queue_runtest(struct jtag_command
*cmd
)
1785 uint32_t clocks
= (uint32_t)cmd
->cmd
.stableclocks
->num_cycles
;
1786 uint8_t end_state
= (uint8_t)xds_jtag_state
[cmd
->cmd
.runtest
->end_state
];
1788 /* Check if new request would be too large to fit */
1789 if ((xds110
.txn_request_size
+ 1 + sizeof(clocks
) + sizeof(end_state
) + 1)
1793 /* Queue request and cycle count directly to queue buffer */
1794 xds110
.txn_requests
[xds110
.txn_request_size
++] = CMD_RUNTEST
;
1795 xds110
.txn_requests
[xds110
.txn_request_size
++] = (clocks
>> 0) & 0xff;
1796 xds110
.txn_requests
[xds110
.txn_request_size
++] = (clocks
>> 8) & 0xff;
1797 xds110
.txn_requests
[xds110
.txn_request_size
++] = (clocks
>> 16) & 0xff;
1798 xds110
.txn_requests
[xds110
.txn_request_size
++] = (clocks
>> 24) & 0xff;
1799 xds110
.txn_requests
[xds110
.txn_request_size
++] = end_state
;
1802 static void xds110_queue_stableclocks(struct jtag_command
*cmd
)
1804 uint32_t clocks
= (uint32_t)cmd
->cmd
.stableclocks
->num_cycles
;
1806 /* Check if new request would be too large to fit */
1807 if ((xds110
.txn_request_size
+ 1 + sizeof(clocks
) + 1) > MAX_DATA_BLOCK
)
1810 /* Queue request and cycle count directly to queue buffer */
1811 xds110
.txn_requests
[xds110
.txn_request_size
++] = CMD_STABLECLOCKS
;
1812 xds110
.txn_requests
[xds110
.txn_request_size
++] = (clocks
>> 0) & 0xff;
1813 xds110
.txn_requests
[xds110
.txn_request_size
++] = (clocks
>> 8) & 0xff;
1814 xds110
.txn_requests
[xds110
.txn_request_size
++] = (clocks
>> 16) & 0xff;
1815 xds110
.txn_requests
[xds110
.txn_request_size
++] = (clocks
>> 24) & 0xff;
1818 static void xds110_execute_command(struct jtag_command
*cmd
)
1820 switch (cmd
->type
) {
1823 xds110_execute_sleep(cmd
);
1825 case JTAG_TLR_RESET
:
1827 xds110_execute_tlr_reset(cmd
);
1831 xds110_execute_pathmove(cmd
);
1834 xds110_queue_scan(cmd
);
1837 xds110_queue_runtest(cmd
);
1839 case JTAG_STABLECLOCKS
:
1840 xds110_queue_stableclocks(cmd
);
1844 LOG_ERROR("BUG: unknown JTAG command type 0x%x encountered",
1850 static int xds110_execute_queue(void)
1852 struct jtag_command
*cmd
= jtag_command_queue
;
1855 xds110_execute_command(cmd
);
1864 static int xds110_speed(int speed
)
1867 uint32_t delay_count
;
1871 LOG_INFO("XDS110: RTCK not supported");
1872 return ERROR_JTAG_NOT_IMPLEMENTED
;
1875 if (speed
< XDS110_MIN_TCK_SPEED
) {
1876 LOG_INFO("XDS110: increase speed request: %d kHz to %d kHz minimum",
1877 speed
, XDS110_MIN_TCK_SPEED
);
1878 speed
= XDS110_MIN_TCK_SPEED
;
1881 /* Older XDS110 firmware had inefficient scan routines and could only */
1882 /* achieve a peak TCK frequency of about 2500 kHz */
1883 if (xds110
.firmware
< FAST_TCK_FIRMWARE_VERSION
) {
1885 /* Check for request for top speed or higher */
1886 if (speed
>= XDS110_MAX_SLOW_TCK_SPEED
) {
1888 /* Inform user that speed was adjusted down to max possible */
1889 if (speed
> XDS110_MAX_SLOW_TCK_SPEED
) {
1891 "XDS110: reduce speed request: %d kHz to %d kHz maximum",
1892 speed
, XDS110_MAX_SLOW_TCK_SPEED
);
1893 speed
= XDS110_MAX_SLOW_TCK_SPEED
;
1899 const double XDS110_TCK_PULSE_INCREMENT
= 66.0;
1900 freq_to_use
= speed
* 1000; /* Hz */
1903 /* Calculate the delay count value */
1904 double one_giga
= 1000000000;
1905 /* Get the pulse duration for the max frequency supported in ns */
1906 double max_freq_pulse_duration
= one_giga
/
1907 (XDS110_MAX_SLOW_TCK_SPEED
* 1000);
1909 /* Convert frequency to pulse duration */
1910 double freq_to_pulse_width_in_ns
= one_giga
/ freq_to_use
;
1913 * Start with the pulse duration for the maximum frequency. Keep
1914 * decrementing time added by each count value till the requested
1915 * frequency pulse is less than the calculated value.
1917 double current_value
= max_freq_pulse_duration
;
1919 while (current_value
< freq_to_pulse_width_in_ns
) {
1920 current_value
+= XDS110_TCK_PULSE_INCREMENT
;
1925 * Determine which delay count yields the best match.
1926 * The one obtained above or one less.
1929 double diff_freq_1
= freq_to_use
-
1930 (one_giga
/ (max_freq_pulse_duration
+
1931 (XDS110_TCK_PULSE_INCREMENT
* delay_count
)));
1932 double diff_freq_2
= (one_giga
/ (max_freq_pulse_duration
+
1933 (XDS110_TCK_PULSE_INCREMENT
* (delay_count
- 1)))) -
1936 /* One less count value yields a better match */
1937 if (diff_freq_1
> diff_freq_2
)
1942 /* Newer firmware has reworked TCK routines that are much more efficient */
1943 /* and can now achieve a peak TCK frequency of 14000 kHz */
1946 if (speed
>= XDS110_MAX_FAST_TCK_SPEED
) {
1947 if (speed
> XDS110_MAX_FAST_TCK_SPEED
) {
1949 "XDS110: reduce speed request: %d kHz to %d kHz maximum",
1950 speed
, XDS110_MAX_FAST_TCK_SPEED
);
1951 speed
= XDS110_MAX_FAST_TCK_SPEED
;
1954 } else if (speed
>= 12000 && xds110
.firmware
>=
1955 FAST_TCK_PLUS_FIRMWARE_VERSION
) {
1956 delay_count
= FAST_TCK_DELAY_12000_KHZ
;
1957 } else if (speed
>= 10000 && xds110
.firmware
>=
1958 FAST_TCK_PLUS_FIRMWARE_VERSION
) {
1959 delay_count
= FAST_TCK_DELAY_10000_KHZ
;
1960 } else if (speed
>= 8500) {
1961 delay_count
= FAST_TCK_DELAY_8500_KHZ
;
1962 } else if (speed
>= 5500) {
1963 delay_count
= FAST_TCK_DELAY_5500_KHZ
;
1965 /* Calculate the delay count to set the frequency */
1966 /* Formula determined by measuring the waveform on Saeleae logic */
1967 /* analyzer using known values for delay count */
1968 const double m
= 17100000.0; /* slope */
1969 const double b
= -1.02; /* y-intercept */
1971 freq_to_use
= speed
* 1000; /* Hz */
1972 double period
= 1.0/freq_to_use
;
1973 double delay
= m
* period
+ b
;
1978 delay_count
= (uint32_t)delay
;
1982 /* Send the delay count to the XDS110 firmware */
1983 success
= xds_set_tck_delay(delay_count
);
1986 xds110
.delay_count
= delay_count
;
1987 xds110
.speed
= speed
;
1990 return (success
) ? ERROR_OK
: ERROR_FAIL
;
1993 static int xds110_speed_div(int speed
, int *khz
)
1999 static int xds110_khz(int khz
, int *jtag_speed
)
2005 COMMAND_HANDLER(xds110_handle_info_command
)
2011 COMMAND_HANDLER(xds110_handle_supply_voltage_command
)
2013 uint32_t voltage
= 0;
2015 if (CMD_ARGC
== 1) {
2016 COMMAND_PARSE_NUMBER(u32
, CMD_ARGV
[0], voltage
);
2017 if (voltage
== 0 || (voltage
>= XDS110_MIN_VOLTAGE
&& voltage
2018 <= XDS110_MAX_VOLTAGE
)) {
2019 /* Requested voltage is in range */
2020 xds110
.voltage
= voltage
;
2022 LOG_ERROR("XDS110: voltage must be 0 or between %d and %d "
2023 "millivolts", XDS110_MIN_VOLTAGE
, XDS110_MAX_VOLTAGE
);
2026 xds110
.voltage
= voltage
;
2028 return ERROR_COMMAND_SYNTAX_ERROR
;
2033 static const struct command_registration xds110_subcommand_handlers
[] = {
2036 .handler
= &xds110_handle_info_command
,
2037 .mode
= COMMAND_EXEC
,
2038 .help
= "show XDS110 info",
2043 .handler
= &xds110_handle_supply_voltage_command
,
2044 .mode
= COMMAND_CONFIG
,
2045 .help
= "set the XDS110 probe supply voltage",
2046 .usage
= "voltage_in_millivolts",
2048 COMMAND_REGISTRATION_DONE
2051 static const struct command_registration xds110_command_handlers
[] = {
2054 .mode
= COMMAND_ANY
,
2055 .help
= "perform XDS110 management",
2057 .chain
= xds110_subcommand_handlers
,
2059 COMMAND_REGISTRATION_DONE
2062 static const struct swd_driver xds110_swd_driver
= {
2063 .init
= xds110_swd_init
,
2064 .switch_seq
= xds110_swd_switch_seq
,
2065 .read_reg
= xds110_swd_read_reg
,
2066 .write_reg
= xds110_swd_write_reg
,
2067 .run
= xds110_swd_run_queue
,
2070 static const char * const xds110_transport
[] = { "swd", "jtag", NULL
};
2072 static struct jtag_interface xds110_interface
= {
2073 .execute_queue
= xds110_execute_queue
,
2076 struct adapter_driver xds110_adapter_driver
= {
2078 .transports
= xds110_transport
,
2079 .commands
= xds110_command_handlers
,
2081 .init
= xds110_init
,
2082 .quit
= xds110_quit
,
2083 .reset
= xds110_reset
,
2084 .speed
= xds110_speed
,
2086 .speed_div
= xds110_speed_div
,
2088 .jtag_ops
= &xds110_interface
,
2089 .swd_ops
= &xds110_swd_driver
,
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)