Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
openocd: fix SPDX tag format for files .c
[openocd.git] / src / jtag / drivers / xds110.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2
3 /***************************************************************************
4 * Copyright (C) 2017 by Texas Instruments, Inc. *
5 ***************************************************************************/
6
7 #ifdef HAVE_CONFIG_H
8 #include "config.h"
9 #endif
10
11 #include <transport/transport.h>
12 #include <jtag/adapter.h>
13 #include <jtag/swd.h>
14 #include <jtag/interface.h>
15 #include <jtag/commands.h>
16 #include <jtag/tcl.h>
17 #include <libusb.h>
18
19 /* XDS110 stand-alone probe voltage supply limits */
20 #define XDS110_MIN_VOLTAGE 1800
21 #define XDS110_MAX_VOLTAGE 3600
22
23 /* XDS110 stand-alone probe hardware ID */
24 #define XDS110_STAND_ALONE_ID 0x21
25
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"
30
31 /* Firmware version that introduced improved TCK performance */
32 #define FAST_TCK_FIRMWARE_VERSION 0x03000000
33
34 /* Firmware version that introduced 10 MHz and 12 MHz TCK support */
35 #define FAST_TCK_PLUS_FIRMWARE_VERSION 0x03000003
36
37 /***************************************************************************
38 * USB Connection Buffer Definitions *
39 ***************************************************************************/
40
41 /* Max USB packet size for up to USB 3.0 */
42 #define MAX_PACKET 1024
43
44 /*
45 * Maximum data payload that can be handled in a single call
46 * Limitation is the size of the buffers in the XDS110 firmware
47 */
48 #define MAX_DATA_BLOCK 4096
49
50 #ifndef USB_PAYLOAD_SIZE
51 /* Largest data block plus parameters */
52 #define USB_PAYLOAD_SIZE (MAX_DATA_BLOCK + 60)
53 #endif
54 #define MAX_RESULT_QUEUE (MAX_DATA_BLOCK / 4)
55
56 /***************************************************************************
57 * XDS110 Firmware API Definitions *
58 ***************************************************************************/
59
60 /*
61 * Default values controlling how the host communicates commands
62 * with XDS110 firmware (automatic retry count and wait timeout)
63 */
64 #define DEFAULT_ATTEMPTS (1)
65 #define DEFAULT_TIMEOUT (4000)
66
67 /* XDS110 API error codes */
68 #define SC_ERR_NONE 0
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
75
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 */
81
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 */
89
90 /* Scan mode on connect */
91 #define MODE_JTAG 1
92
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
110
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
115
116 /* DAP register definitions as used by XDS110 APIs */
117
118 #define DAP_AP 0 /* DAP AP register type */
119 #define DAP_DP 1 /* DAP DP register type */
120
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 */
129
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 */
139
140 /* Command packet definitions */
141
142 #define XDS_OUT_LEN 1 /* command (byte) */
143 #define XDS_IN_LEN 4 /* error code (int) */
144
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 */
169
170 #define CMD_IR_SCAN 1
171 #define CMD_DR_SCAN 2
172 #define CMD_RUNTEST 3
173 #define CMD_STABLECLOCKS 4
174
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 */
193 };
194
195 struct scan_result {
196 bool first;
197 uint8_t *buffer;
198 uint32_t num_bits;
199 };
200
201 struct xds110_info {
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];
208 /* Device vid/pid */
209 uint16_t vid;
210 uint16_t pid;
211 /* Debug interface */
212 uint8_t interface;
213 uint8_t endpoint_in;
214 uint8_t endpoint_out;
215 /* Status flags */
216 bool is_connected;
217 bool is_cmapi_connected;
218 bool is_cmapi_acquired;
219 bool is_swd_mode;
220 bool is_ap_dirty;
221 /* DAP register caches */
222 uint32_t select;
223 uint32_t rdbuff;
224 bool use_rdbuff;
225 /* TCK speed and delay count*/
226 uint32_t speed;
227 uint32_t delay_count;
228 /* XDS110 voltage supply setting */
229 uint32_t voltage;
230 /* XDS110 firmware and hardware version */
231 uint32_t firmware;
232 uint16_t hardware;
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;
240 };
241
242 static struct xds110_info xds110 = {
243 .ctx = NULL,
244 .dev = NULL,
245 .vid = 0,
246 .pid = 0,
247 .interface = 0,
248 .endpoint_in = 0,
249 .endpoint_out = 0,
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,
256 .delay_count = 0,
257 .voltage = 0,
258 .firmware = 0,
259 .hardware = 0,
260 .txn_request_size = 0,
261 .txn_result_size = 0,
262 .txn_result_count = 0
263 };
264
265 static inline void xds110_set_u32(uint8_t *buffer, uint32_t value)
266 {
267 buffer[3] = (value >> 24) & 0xff;
268 buffer[2] = (value >> 16) & 0xff;
269 buffer[1] = (value >> 8) & 0xff;
270 buffer[0] = (value >> 0) & 0xff;
271 }
272
273 static inline void xds110_set_u16(uint8_t *buffer, uint16_t value)
274 {
275 buffer[1] = (value >> 8) & 0xff;
276 buffer[0] = (value >> 0) & 0xff;
277 }
278
279 static inline uint32_t xds110_get_u32(uint8_t *buffer)
280 {
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);
285 return value;
286 }
287
288 static inline uint16_t xds110_get_u16(uint8_t *buffer)
289 {
290 uint16_t value = (((uint32_t)buffer[1]) << 8) |
291 (((uint32_t)buffer[0]) << 0);
292 return value;
293 }
294
295 /***************************************************************************
296 * usb connection routines *
297 * *
298 * The following functions handle connecting, reading, and writing to *
299 * the XDS110 over USB using the libusb library. *
300 ***************************************************************************/
301
302 static bool usb_connect(void)
303 {
304 struct libusb_context *ctx = NULL;
305 struct libusb_device **list = NULL;
306 struct libusb_device_handle *dev = NULL;
307
308 struct libusb_device_descriptor desc;
309
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 };
317
318 ssize_t count = 0;
319 ssize_t i = 0;
320 int result = 0;
321 bool found = false;
322 uint32_t device = 0;
323 bool match = false;
324
325 /* Initialize libusb context */
326 result = libusb_init(&ctx);
327
328 if (result == 0) {
329 /* Get list of USB devices attached to system */
330 count = libusb_get_device_list(ctx, &list);
331 if (count <= 0) {
332 result = -1;
333 list = NULL;
334 }
335 }
336
337 if (result == 0) {
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);
342 match = false;
343 for (device = 0; device < ARRAY_SIZE(vids); device++) {
344 if (desc.idVendor == vids[device] &&
345 desc.idProduct == pids[device]) {
346 match = true;
347 break;
348 }
349 }
350 if (match) {
351 result = libusb_open(list[i], &dev);
352 if (result == 0) {
353 const int max_data = 256;
354 unsigned char data[max_data + 1];
355 *data = '\0';
356
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 */
360 found = true;
361 break;
362 } else {
363 /* Get the device's serial number string */
364 result = libusb_get_string_descriptor_ascii(dev,
365 desc.iSerialNumber, data, max_data);
366 if (result > 0 &&
367 strcmp((char *)data, adapter_get_required_serial()) == 0) {
368 found = true;
369 break;
370 }
371 }
372
373 /* If we fall though to here, we don't want this device */
374 libusb_close(dev);
375 dev = NULL;
376 }
377 }
378 }
379 }
380
381 /*
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
385 */
386
387 if (list) {
388 /* Free the device list, we're done with it */
389 libusb_free_device_list(list, 1);
390 }
391
392 if (found) {
393 /* Save the vid/pid of the device we're using */
394 xds110.vid = vids[device];
395 xds110.pid = pids[device];
396
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;
401
402 /* Save the context and device handles */
403 xds110.ctx = ctx;
404 xds110.dev = dev;
405
406 /* Set libusb to auto detach kernel */
407 (void)libusb_set_auto_detach_kernel_driver(dev, 1);
408
409 /* Claim the debug interface on the XDS110 */
410 result = libusb_claim_interface(dev, xds110.interface);
411 } else {
412 /* Couldn't find an XDS110, flag the error */
413 result = -1;
414 }
415
416 /* On an error, clean up what we can */
417 if (result != 0) {
418 if (dev) {
419 /* Release the debug and data interface on the XDS110 */
420 (void)libusb_release_interface(dev, xds110.interface);
421 libusb_close(dev);
422 }
423 if (ctx)
424 libusb_exit(ctx);
425 xds110.ctx = NULL;
426 xds110.dev = NULL;
427 }
428
429 /* Log the results */
430 if (result == 0)
431 LOG_INFO("XDS110: connected");
432 else
433 LOG_ERROR("XDS110: failed to connect");
434
435 return (result == 0) ? true : false;
436 }
437
438 static void usb_disconnect(void)
439 {
440 if (xds110.dev) {
441 /* Release the debug and data interface on the XDS110 */
442 (void)libusb_release_interface(xds110.dev, xds110.interface);
443 libusb_close(xds110.dev);
444 xds110.dev = NULL;
445 }
446 if (xds110.ctx) {
447 libusb_exit(xds110.ctx);
448 xds110.ctx = NULL;
449 }
450
451 LOG_INFO("XDS110: disconnected");
452 }
453
454 static bool usb_read(unsigned char *buffer, int size, int *bytes_read,
455 int timeout)
456 {
457 int result;
458
459 if (!xds110.dev || !buffer || !bytes_read)
460 return false;
461
462 /* Force a non-zero timeout to prevent blocking */
463 if (timeout == 0)
464 timeout = DEFAULT_TIMEOUT;
465
466 result = libusb_bulk_transfer(xds110.dev, xds110.endpoint_in, buffer, size,
467 bytes_read, timeout);
468
469 return (result == 0) ? true : false;
470 }
471
472 static bool usb_write(unsigned char *buffer, int size, int *written)
473 {
474 int bytes_written = 0;
475 int result = LIBUSB_SUCCESS;
476 int retries = 0;
477
478 if (!xds110.dev || !buffer)
479 return false;
480
481 result = libusb_bulk_transfer(xds110.dev, xds110.endpoint_out, buffer,
482 size, &bytes_written, 0);
483
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);
489 retries++;
490 }
491
492 if (written)
493 *written = bytes_written;
494
495 return (result == 0 && size == bytes_written) ? true : false;
496 }
497
498 static bool usb_get_response(uint32_t *total_bytes_read, uint32_t timeout)
499 {
500 static unsigned char buffer[MAX_PACKET];
501 int bytes_read;
502 uint16_t size;
503 uint16_t count;
504 bool success;
505
506 size = 0;
507 success = true;
508 while (success) {
509 success = usb_read(buffer, sizeof(buffer), &bytes_read, timeout);
510 if (success) {
511 /*
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
515 */
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 */
524 break;
525 }
526 }
527 }
528 }
529 /*
530 * Somehow received an invalid packet, retry till we
531 * time out or a valid response packet is received
532 */
533 }
534
535 /* Abort now if we didn't receive a valid response */
536 if (!success) {
537 if (total_bytes_read)
538 *total_bytes_read = 0;
539 return false;
540 }
541
542 /* Build the return payload into xds110.read_payload */
543
544 /* Copy over payload data from received buffer (skipping header) */
545 count = 0;
546 bytes_read -= 3;
547 memcpy((void *)&xds110.read_payload[count], (void *)&buffer[3], bytes_read);
548 count += bytes_read;
549 /*
550 * Drop timeout to just 1/2 second. Once the XDS110 starts sending
551 * a response, the remaining packets should arrive in short order
552 */
553 if (timeout > 500)
554 timeout = 500; /* ms */
555
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);
559 if (success) {
560 if ((count + bytes_read) > size) {
561 /* Read too much data, not a valid packet, abort */
562 success = false;
563 } else {
564 /* Copy this data over to xds110.read_payload */
565 memcpy((void *)&xds110.read_payload[count], (void *)buffer,
566 bytes_read);
567 count += bytes_read;
568 }
569 }
570 }
571
572 if (!success)
573 count = 0;
574 if (total_bytes_read)
575 *total_bytes_read = count;
576
577 return success;
578 }
579
580 static bool usb_send_command(uint16_t size)
581 {
582 int written;
583 bool success = true;
584
585 /* Check the packet length */
586 if (size > USB_PAYLOAD_SIZE)
587 return false;
588
589 /* Place the start character into the packet buffer */
590 xds110.write_packet[0] = '*';
591
592 /* Place the payload size into the packet buffer */
593 xds110_set_u16(&xds110.write_packet[1], size);
594
595 /* Adjust size to include header */
596 size += 3;
597
598 /* Send the data via the USB connection */
599 success = usb_write(xds110.write_packet, (int)size, &written);
600
601 /* Check if the correct number of bytes was written */
602 if (written != (int)size)
603 success = false;
604
605 return success;
606 }
607
608 /***************************************************************************
609 * XDS110 firmware API routines *
610 * *
611 * The following functions handle calling into the XDS110 firmware to *
612 * perform requested debug actions. *
613 ***************************************************************************/
614
615 static bool xds_execute(uint32_t out_length, uint32_t in_length,
616 uint32_t attempts, uint32_t timeout)
617 {
618 bool done = false;
619 bool success = true;
620 int error = 0;
621 uint32_t bytes_read = 0;
622
623 if (!xds110.dev)
624 return false;
625
626 while (!done && attempts > 0) {
627 attempts--;
628
629 /* Send command to XDS110 */
630 success = usb_send_command(out_length);
631
632 if (success) {
633 /* Get response from XDS110 */
634 success = usb_get_response(&bytes_read, timeout);
635 }
636
637 if (success) {
638 /* Check for valid response from XDS code handling */
639 if (bytes_read != in_length) {
640 /* Unexpected amount of data returned */
641 success = false;
642 LOG_DEBUG("XDS110: command 0x%02x return %" PRIu32 " bytes, expected %" PRIu32,
643 xds110.write_payload[0], bytes_read, in_length);
644 } else {
645 /* Extract error code from return packet */
646 error = (int)xds110_get_u32(&xds110.read_payload[0]);
647 done = true;
648 if (error != SC_ERR_NONE)
649 LOG_DEBUG("XDS110: command 0x%02x returned error %d",
650 xds110.write_payload[0], error);
651 }
652 }
653 }
654
655 if (!success)
656 error = SC_ERR_XDS110_FAIL;
657
658 if (error != 0)
659 success = false;
660
661 return success;
662 }
663
664 static bool xds_connect(void)
665 {
666 bool success;
667
668 xds110.write_payload[0] = XDS_CONNECT;
669
670 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
671 DEFAULT_TIMEOUT);
672
673 return success;
674 }
675
676 static bool xds_disconnect(void)
677 {
678 bool success;
679
680 xds110.write_payload[0] = XDS_DISCONNECT;
681
682 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
683 DEFAULT_TIMEOUT);
684
685 return success;
686 }
687
688 static bool xds_version(uint32_t *firmware_id, uint16_t *hardware_id)
689 {
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 */
692
693 bool success;
694
695 xds110.write_payload[0] = XDS_VERSION;
696
697 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN + 6, DEFAULT_ATTEMPTS,
698 DEFAULT_TIMEOUT);
699
700 if (success) {
701 if (firmware_id)
702 *firmware_id = xds110_get_u32(fw_id_pntr);
703 if (hardware_id)
704 *hardware_id = xds110_get_u16(hw_id_pntr);
705 }
706
707 return success;
708 }
709
710 static bool xds_set_tck_delay(uint32_t delay)
711 {
712 uint8_t *delay_pntr = &xds110.write_payload[XDS_OUT_LEN + 0]; /* 32-bits */
713
714 bool success;
715
716 xds110.write_payload[0] = XDS_SET_TCK;
717
718 xds110_set_u32(delay_pntr, delay);
719
720 success = xds_execute(XDS_OUT_LEN + 4, XDS_IN_LEN, DEFAULT_ATTEMPTS,
721 DEFAULT_TIMEOUT);
722
723 return success;
724 }
725
726 static bool xds_set_trst(uint8_t trst)
727 {
728 uint8_t *trst_pntr = &xds110.write_payload[XDS_OUT_LEN + 0]; /* 8-bits */
729
730 bool success;
731
732 xds110.write_payload[0] = XDS_SET_TRST;
733
734 *trst_pntr = trst;
735
736 success = xds_execute(XDS_OUT_LEN + 1, XDS_IN_LEN, DEFAULT_ATTEMPTS,
737 DEFAULT_TIMEOUT);
738
739 return success;
740 }
741
742 static bool xds_cycle_tck(uint32_t count)
743 {
744 uint8_t *count_pntr = &xds110.write_payload[XDS_OUT_LEN + 0]; /* 32-bits */
745
746 bool success;
747
748 xds110.write_payload[0] = XDS_CYCLE_TCK;
749
750 xds110_set_u32(count_pntr, count);
751
752 success = xds_execute(XDS_OUT_LEN + 4, XDS_IN_LEN, DEFAULT_ATTEMPTS,
753 DEFAULT_TIMEOUT);
754
755 return success;
756 }
757
758 static bool xds_goto_state(uint32_t state)
759 {
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 */
762
763 bool success;
764
765 xds110.write_payload[0] = XDS_GOTO_STATE;
766
767 xds110_set_u32(state_pntr, state);
768 xds110_set_u32(transit_pntr, XDS_JTAG_TRANSIT_QUICKEST);
769
770 success = xds_execute(XDS_OUT_LEN+8, XDS_IN_LEN, DEFAULT_ATTEMPTS,
771 DEFAULT_TIMEOUT);
772
773 return success;
774 }
775
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)
778 {
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];
792
793 uint16_t total_bytes = DIV_ROUND_UP(shift_bits, 8);
794
795 bool success;
796
797 xds110.write_payload[0] = XDS_JTAG_SCAN;
798
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) */
810
811 memcpy((void *)data_out_pntr, (void *)data_out, total_bytes);
812
813 success = xds_execute(XDS_OUT_LEN + 18 + total_bytes,
814 XDS_IN_LEN + total_bytes, DEFAULT_ATTEMPTS, DEFAULT_TIMEOUT);
815
816 if (success)
817 memcpy((void *)data_in, (void *)data_in_pntr, total_bytes);
818
819 return success;
820 }
821
822 static bool xds_set_srst(uint8_t srst)
823 {
824 uint8_t *srst_pntr = &xds110.write_payload[XDS_OUT_LEN + 0]; /* 8-bits */
825
826 bool success;
827
828 xds110.write_payload[0] = XDS_SET_SRST;
829
830 *srst_pntr = srst;
831
832 success = xds_execute(XDS_OUT_LEN + 1, XDS_IN_LEN, DEFAULT_ATTEMPTS,
833 DEFAULT_TIMEOUT);
834
835 return success;
836 }
837
838 static bool cmapi_connect(uint32_t *idcode)
839 {
840 uint8_t *idcode_pntr = &xds110.read_payload[XDS_IN_LEN + 0]; /* 32-bits */
841
842 bool success;
843
844 xds110.write_payload[0] = CMAPI_CONNECT;
845
846 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN+4, DEFAULT_ATTEMPTS,
847 DEFAULT_TIMEOUT);
848
849 if (success) {
850 if (idcode)
851 *idcode = xds110_get_u32(idcode_pntr);
852 }
853
854 return success;
855 }
856
857 static bool cmapi_disconnect(void)
858 {
859 bool success;
860
861 xds110.write_payload[0] = CMAPI_DISCONNECT;
862
863 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
864 DEFAULT_TIMEOUT);
865
866 return success;
867 }
868
869 static bool cmapi_acquire(void)
870 {
871 bool success;
872
873 xds110.write_payload[0] = CMAPI_ACQUIRE;
874
875 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
876 DEFAULT_TIMEOUT);
877
878 return success;
879 }
880
881 static bool cmapi_release(void)
882 {
883 bool success;
884
885 xds110.write_payload[0] = CMAPI_RELEASE;
886
887 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
888 DEFAULT_TIMEOUT);
889
890 return success;
891 }
892
893 static bool cmapi_read_dap_reg(uint32_t type, uint32_t ap_num,
894 uint32_t address, uint32_t *value)
895 {
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 */
900
901 bool success;
902
903 xds110.write_payload[0] = CMAPI_REG_READ;
904
905 *type_pntr = (uint8_t)(type & 0xff);
906 *ap_num_pntr = (uint8_t)(ap_num & 0xff);
907 *address_pntr = (uint8_t)(address & 0xff);
908
909 success = xds_execute(XDS_OUT_LEN + 3, XDS_IN_LEN + 4, DEFAULT_ATTEMPTS,
910 DEFAULT_TIMEOUT);
911
912 if (success) {
913 if (value)
914 *value = xds110_get_u32(value_pntr);
915 }
916
917 return success;
918 }
919
920 static bool cmapi_write_dap_reg(uint32_t type, uint32_t ap_num,
921 uint32_t address, uint32_t *value)
922 {
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 */
927
928 bool success;
929
930 if (!value)
931 return false;
932
933 xds110.write_payload[0] = CMAPI_REG_WRITE;
934
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);
939
940 success = xds_execute(XDS_OUT_LEN + 7, XDS_IN_LEN, DEFAULT_ATTEMPTS,
941 DEFAULT_TIMEOUT);
942
943 return success;
944 }
945
946 static bool swd_connect(void)
947 {
948 bool success;
949
950 xds110.write_payload[0] = SWD_CONNECT;
951
952 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
953 DEFAULT_TIMEOUT);
954
955 return success;
956 }
957
958 static bool swd_disconnect(void)
959 {
960 bool success;
961
962 xds110.write_payload[0] = SWD_DISCONNECT;
963
964 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
965 DEFAULT_TIMEOUT);
966
967 return success;
968 }
969
970 static bool cjtag_connect(uint32_t format)
971 {
972 uint8_t *format_pntr = &xds110.write_payload[XDS_OUT_LEN + 0]; /* 32-bits */
973
974 bool success;
975
976 xds110.write_payload[0] = CJTAG_CONNECT;
977
978 xds110_set_u32(format_pntr, format);
979
980 success = xds_execute(XDS_OUT_LEN + 4, XDS_IN_LEN, DEFAULT_ATTEMPTS,
981 DEFAULT_TIMEOUT);
982
983 return success;
984 }
985
986 static bool cjtag_disconnect(void)
987 {
988 bool success;
989
990 xds110.write_payload[0] = CJTAG_DISCONNECT;
991
992 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
993 DEFAULT_TIMEOUT);
994
995 return success;
996 }
997
998 static bool xds_set_supply(uint32_t voltage)
999 {
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 */
1002
1003 bool success;
1004
1005 xds110.write_payload[0] = XDS_SET_SUPPLY;
1006
1007 xds110_set_u32(volts_pntr, voltage);
1008 *source_pntr = (uint8_t)(voltage != 0 ? 1 : 0);
1009
1010 success = xds_execute(XDS_OUT_LEN + 5, XDS_IN_LEN, DEFAULT_ATTEMPTS,
1011 DEFAULT_TIMEOUT);
1012
1013 return success;
1014 }
1015
1016 static bool ocd_dap_request(uint8_t *dap_requests, uint32_t request_size,
1017 uint32_t *dap_results, uint32_t result_count)
1018 {
1019 uint8_t *request_pntr = &xds110.write_payload[XDS_OUT_LEN + 0];
1020 uint8_t *result_pntr = &xds110.read_payload[XDS_IN_LEN + 0];
1021
1022 bool success;
1023
1024 if (!dap_requests || !dap_results)
1025 return false;
1026
1027 xds110.write_payload[0] = OCD_DAP_REQUEST;
1028
1029 memcpy((void *)request_pntr, (void *)dap_requests, request_size);
1030
1031 success = xds_execute(XDS_OUT_LEN + request_size,
1032 XDS_IN_LEN + (result_count * 4), DEFAULT_ATTEMPTS,
1033 DEFAULT_TIMEOUT);
1034
1035 if (success && (result_count > 0))
1036 memcpy((void *)dap_results, (void *)result_pntr, result_count * 4);
1037
1038 return success;
1039 }
1040
1041 static bool ocd_scan_request(uint8_t *scan_requests, uint32_t request_size,
1042 uint8_t *scan_results, uint32_t result_size)
1043 {
1044 uint8_t *request_pntr = &xds110.write_payload[XDS_OUT_LEN + 0];
1045 uint8_t *result_pntr = &xds110.read_payload[XDS_IN_LEN + 0];
1046
1047 bool success;
1048
1049 if (!scan_requests || !scan_results)
1050 return false;
1051
1052 xds110.write_payload[0] = OCD_SCAN_REQUEST;
1053
1054 memcpy((void *)request_pntr, (void *)scan_requests, request_size);
1055
1056 success = xds_execute(XDS_OUT_LEN + request_size,
1057 XDS_IN_LEN + result_size, DEFAULT_ATTEMPTS,
1058 DEFAULT_TIMEOUT);
1059
1060 if (success && (result_size > 0))
1061 memcpy((void *)scan_results, (void *)result_pntr, result_size);
1062
1063 return success;
1064 }
1065
1066 static bool ocd_pathmove(uint32_t num_states, uint8_t *path)
1067 {
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];
1070
1071 bool success;
1072
1073 if (!path)
1074 return false;
1075
1076 xds110.write_payload[0] = OCD_PATHMOVE;
1077
1078 xds110_set_u32(num_pntr, num_states);
1079
1080 memcpy((void *)path_pntr, (void *)path, num_states);
1081
1082 success = xds_execute(XDS_OUT_LEN + 4 + num_states, XDS_IN_LEN,
1083 DEFAULT_ATTEMPTS, DEFAULT_TIMEOUT);
1084
1085 return success;
1086 }
1087
1088 /***************************************************************************
1089 * swd driver interface *
1090 * *
1091 * The following functions provide SWD support to OpenOCD. *
1092 ***************************************************************************/
1093
1094 static int xds110_swd_init(void)
1095 {
1096 xds110.is_swd_mode = true;
1097 return ERROR_OK;
1098 }
1099
1100 static int xds110_swd_switch_seq(enum swd_special_seq seq)
1101 {
1102 uint32_t idcode;
1103 bool success;
1104
1105 switch (seq) {
1106 case LINE_RESET:
1107 LOG_ERROR("Sequence SWD line reset (%d) not supported", seq);
1108 return ERROR_FAIL;
1109 case JTAG_TO_SWD:
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 */
1117 if (success) {
1118 xds110.is_swd_mode = true;
1119 success = cmapi_connect(&idcode);
1120 if (success) {
1121 xds110.is_cmapi_connected = true;
1122 success = cmapi_acquire();
1123 }
1124 }
1125 break;
1126 case SWD_TO_JTAG:
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();
1133 if (success) {
1134 /* Re-initialize JTAG interface */
1135 success = cjtag_connect(MODE_JTAG);
1136 }
1137 break;
1138 default:
1139 LOG_ERROR("Sequence %d not supported", seq);
1140 return ERROR_FAIL;
1141 }
1142
1143 if (success)
1144 return ERROR_OK;
1145 else
1146 return ERROR_FAIL;
1147 }
1148
1149 static bool xds110_legacy_read_reg(uint8_t cmd, uint32_t *value)
1150 {
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);
1161
1162 uint32_t reg_value = 0;
1163 uint32_t temp_value = 0;
1164
1165 bool success;
1166
1167 if (!is_read_request)
1168 return false;
1169
1170 if (type == DAP_AP) {
1171 /* Add bank address to register address for CMAPI call */
1172 address |= bank;
1173 }
1174
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;
1178 success = true;
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);
1184 } else {
1185 success = cmapi_read_dap_reg(type, ap_num, address, &temp_value);
1186 if (success)
1187 reg_value = temp_value;
1188 }
1189
1190 /* Mark that we have consumed or invalidated the RDBUFF cache */
1191 xds110.use_rdbuff = false;
1192
1193 /* Handle result of read attempt */
1194 if (!success)
1195 LOG_ERROR("XDS110: failed to read DAP register");
1196 else if (value)
1197 *value = reg_value;
1198
1199 if (success && DAP_AP == type) {
1200 /*
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
1203 */
1204 xds110.use_rdbuff = true;
1205 xds110.rdbuff = temp_value;
1206 }
1207
1208 return success;
1209 }
1210
1211 static bool xds110_legacy_write_reg(uint8_t cmd, uint32_t value)
1212 {
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);
1223
1224 bool success;
1225
1226 if (is_read_request)
1227 return false;
1228
1229 /* Invalidate the RDBUFF cache */
1230 xds110.use_rdbuff = false;
1231
1232 if (type == DAP_AP) {
1233 /* Add bank address to register address for CMAPI call */
1234 address |= bank;
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;
1240 }
1241
1242 success = cmapi_write_dap_reg(type, ap_num, address, &value);
1243
1244 if (!success) {
1245 LOG_ERROR("XDS110: failed to write DAP register");
1246 } else {
1247 /*
1248 * If the debugger wrote to SELECT, cache the value
1249 * to use to build the apNum and address values above
1250 */
1251 if ((type == DAP_DP) && (address == DAP_DP_SELECT))
1252 xds110.select = value;
1253 }
1254
1255 return success;
1256 }
1257
1258 static int xds110_swd_run_queue(void)
1259 {
1260 static uint32_t dap_results[MAX_RESULT_QUEUE];
1261 uint8_t cmd;
1262 uint32_t request;
1263 uint32_t result;
1264 uint32_t value;
1265 bool success = true;
1266
1267 if (xds110.txn_request_size == 0)
1268 return ERROR_OK;
1269
1270 /* Terminate request queue */
1271 xds110.txn_requests[xds110.txn_request_size++] = 0;
1272
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);
1277 } else {
1278 /* Legacy firmware needs to handle queue via discrete DAP calls */
1279 request = 0;
1280 result = 0;
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;
1289 if (success)
1290 success = xds110_legacy_write_reg(cmd, value);
1291 } else {
1292 /* DAP register read command */
1293 value = 0;
1294 if (success)
1295 success = xds110_legacy_read_reg(cmd, &value);
1296 dap_results[result++] = value;
1297 }
1298 }
1299 }
1300
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];
1305
1306 xds110.txn_request_size = 0;
1307 xds110.txn_result_size = 0;
1308 xds110.txn_result_count = 0;
1309
1310 return (success) ? ERROR_OK : ERROR_FAIL;
1311 }
1312
1313 static void xds110_swd_queue_cmd(uint8_t cmd, uint32_t *value)
1314 {
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;
1322
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();
1327
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;
1331
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;
1338 } else {
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;
1344 }
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;
1351 }
1352 }
1353
1354 static void xds110_swd_read_reg(uint8_t cmd, uint32_t *value,
1355 uint32_t ap_delay_clk)
1356 {
1357 xds110_swd_queue_cmd(cmd, value);
1358 }
1359 static void xds110_swd_write_reg(uint8_t cmd, uint32_t value,
1360 uint32_t ap_delay_clk)
1361 {
1362 xds110_swd_queue_cmd(cmd, &value);
1363 }
1364
1365 /***************************************************************************
1366 * jtag interface *
1367 * *
1368 * The following functions provide XDS110 interface to OpenOCD. *
1369 ***************************************************************************/
1370
1371 static void xds110_show_info(void)
1372 {
1373 uint32_t firmware = xds110.firmware;
1374
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);
1387 } else {
1388 LOG_INFO("XDS110: connected to target via JTAG");
1389 LOG_INFO("XDS110: TCK set to %" PRIu32 " kHz", xds110.speed);
1390 }
1391
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);
1396 }
1397 }
1398
1399 static int xds110_quit(void)
1400 {
1401 if (xds110.is_cmapi_acquired) {
1402 (void)cmapi_release();
1403 xds110.is_cmapi_acquired = false;
1404 }
1405 if (xds110.is_cmapi_connected) {
1406 (void)cmapi_disconnect();
1407 xds110.is_cmapi_connected = false;
1408 }
1409 if (xds110.is_connected) {
1410 if (xds110.is_swd_mode) {
1411 /* Switch out of SWD mode */
1412 (void)swd_disconnect();
1413 } else {
1414 /* Switch out of cJTAG mode */
1415 (void)cjtag_disconnect();
1416 }
1417 /* Tell firmware we're disconnecting */
1418 (void)xds_disconnect();
1419 xds110.is_connected = false;
1420 }
1421 /* Close down the USB connection to the XDS110 debug probe */
1422 usb_disconnect();
1423
1424 return ERROR_OK;
1425 }
1426
1427 static int xds110_init(void)
1428 {
1429 bool success;
1430
1431 /* Establish USB connection to the XDS110 debug probe */
1432 success = usb_connect();
1433
1434 if (success) {
1435 /* Send connect message to XDS110 firmware */
1436 success = xds_connect();
1437 if (success)
1438 xds110.is_connected = true;
1439 }
1440
1441 if (success) {
1442 uint32_t firmware;
1443 uint16_t hardware;
1444
1445 /* Retrieve version IDs from firmware */
1446 /* Version numbers are stored in BCD format */
1447 success = xds_version(&firmware, &hardware);
1448 if (success) {
1449 /* Save the firmware and hardware version */
1450 xds110.firmware = firmware;
1451 xds110.hardware = hardware;
1452 }
1453 }
1454
1455 if (success) {
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) */
1461 alive_sleep(1500);
1462 } else if (xds110.voltage != 0) {
1463 /* Voltage supply not a feature of embedded probes */
1464 LOG_WARNING(
1465 "XDS110: ignoring supply voltage, not supported on this probe");
1466 }
1467 }
1468
1469 if (success) {
1470 success = xds_set_trst(0);
1471 if (success)
1472 success = xds_cycle_tck(50);
1473 if (success)
1474 success = xds_set_trst(1);
1475 if (success)
1476 success = xds_cycle_tck(50);
1477 }
1478
1479 if (success) {
1480 if (xds110.is_swd_mode) {
1481 /* Switch to SWD if needed */
1482 success = swd_connect();
1483 } else {
1484 success = cjtag_connect(MODE_JTAG);
1485 }
1486 }
1487
1488 if (success && xds110.is_swd_mode) {
1489 uint32_t idcode;
1490
1491 /* Connect to CMAPI interface in XDS110 */
1492 success = cmapi_connect(&idcode);
1493
1494 /* Acquire exclusive access to CMAPI interface */
1495 if (success) {
1496 xds110.is_cmapi_connected = true;
1497 success = cmapi_acquire();
1498 if (success)
1499 xds110.is_cmapi_acquired = true;
1500 }
1501 }
1502
1503 if (!success)
1504 xds110_quit();
1505
1506 if (success)
1507 xds110_show_info();
1508
1509 return (success) ? ERROR_OK : ERROR_FAIL;
1510 }
1511
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)
1514 {
1515 (void)xds_jtag_scan(shift_state, total_bits, end_state, data_out, data_in);
1516 }
1517
1518 static void xds110_legacy_runtest(uint32_t clocks, uint32_t end_state)
1519 {
1520 xds_goto_state(XDS_JTAG_STATE_IDLE);
1521 xds_cycle_tck(clocks);
1522 xds_goto_state(end_state);
1523 }
1524
1525 static void xds110_legacy_stableclocks(uint32_t clocks)
1526 {
1527 xds_cycle_tck(clocks);
1528 }
1529
1530 static void xds110_flush(void)
1531 {
1532 uint8_t command;
1533 uint32_t clocks;
1534 uint32_t shift_state;
1535 uint32_t end_state;
1536 uint32_t bits;
1537 uint32_t bytes;
1538 uint32_t request;
1539 uint32_t result;
1540 uint8_t *data_out;
1541 uint8_t data_in[MAX_DATA_BLOCK];
1542 uint8_t *data_pntr;
1543
1544 if (xds110.txn_request_size == 0)
1545 return;
1546
1547 /* Terminate request queue */
1548 xds110.txn_requests[xds110.txn_request_size++] = 0;
1549
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);
1554 } else {
1555 /* Legacy firmware needs to handle queue via discrete JTAG calls */
1556 request = 0;
1557 result = 0;
1558 while (xds110.txn_requests[request] != 0) {
1559 command = xds110.txn_requests[request++];
1560 switch (command) {
1561 case CMD_IR_SCAN:
1562 case CMD_DR_SCAN:
1563 if (command == CMD_IR_SCAN)
1564 shift_state = XDS_JTAG_STATE_SHIFT_IR;
1565 else
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,
1573 &data_in[result]);
1574 result += bytes;
1575 request += bytes;
1576 break;
1577 case CMD_RUNTEST:
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);
1584 break;
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);
1591 break;
1592 default:
1593 LOG_ERROR("BUG: unknown JTAG command type 0x%x encountered",
1594 command);
1595 exit(-1);
1596 break;
1597 }
1598 }
1599 }
1600
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) {
1606 if (bits != 0) {
1607 bytes = DIV_ROUND_UP(bits, 8);
1608 data_pntr += bytes;
1609 }
1610 bits = 0;
1611 }
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;
1616 }
1617
1618 xds110.txn_request_size = 0;
1619 xds110.txn_result_size = 0;
1620 xds110.txn_result_count = 0;
1621 }
1622
1623 static int xds110_reset(int trst, int srst)
1624 {
1625 uint8_t value;
1626 bool success;
1627 int retval = ERROR_OK;
1628
1629 if (trst != -1) {
1630 if (trst == 0) {
1631 /* Deassert nTRST (active low) */
1632 value = 1;
1633 } else {
1634 /* Assert nTRST (active low) */
1635 value = 0;
1636 }
1637 success = xds_set_trst(value);
1638 if (!success)
1639 retval = ERROR_FAIL;
1640 }
1641
1642 if (srst != -1) {
1643 if (srst == 0) {
1644 /* Deassert nSRST (active low) */
1645 value = 1;
1646 } else {
1647 /* Assert nSRST (active low) */
1648 value = 0;
1649 }
1650 success = xds_set_srst(value);
1651 if (!success)
1652 retval = ERROR_FAIL;
1653
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);
1658 }
1659
1660 if (!success)
1661 retval = ERROR_FAIL;
1662 }
1663
1664 return retval;
1665 }
1666
1667 static void xds110_execute_sleep(struct jtag_command *cmd)
1668 {
1669 jtag_sleep(cmd->cmd.sleep->us);
1670 }
1671
1672 static void xds110_execute_tlr_reset(struct jtag_command *cmd)
1673 {
1674 (void)xds_goto_state(XDS_JTAG_STATE_RESET);
1675 }
1676
1677 static void xds110_execute_pathmove(struct jtag_command *cmd)
1678 {
1679 uint32_t i;
1680 uint32_t num_states;
1681 uint8_t *path;
1682
1683 num_states = (uint32_t)cmd->cmd.pathmove->num_states;
1684
1685 if (num_states == 0)
1686 return;
1687
1688 path = (uint8_t *)malloc(num_states * sizeof(uint8_t));
1689 if (path == 0) {
1690 LOG_ERROR("XDS110: unable to allocate memory");
1691 return;
1692 }
1693
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]];
1697
1698 if (xds110.firmware >= OCD_FIRMWARE_VERSION) {
1699 /* Updated firmware fully supports pathmove */
1700 (void)ocd_pathmove(num_states, path);
1701 } else {
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 */
1706 exit(-1);
1707 }
1708
1709 free((void *)path);
1710 }
1711
1712 static void xds110_queue_scan(struct jtag_command *cmd)
1713 {
1714 int i;
1715 uint32_t offset;
1716 uint32_t total_fields;
1717 uint32_t total_bits;
1718 uint32_t total_bytes;
1719 uint8_t end_state;
1720 uint8_t *buffer;
1721
1722 /* Calculate the total number of bits to scan */
1723 total_bits = 0;
1724 total_fields = 0;
1725 for (i = 0; i < cmd->cmd.scan->num_fields; i++) {
1726 total_fields++;
1727 total_bits += (uint32_t)cmd->cmd.scan->fields[i].num_bits;
1728 }
1729
1730 if (total_bits == 0)
1731 return;
1732
1733 total_bytes = DIV_ROUND_UP(total_bits, 8);
1734
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) >
1738 MAX_RESULT_QUEUE))
1739 xds110_flush();
1740
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)",
1744 total_bits);
1745 /* Failing to run this scan mucks up debug on this target */
1746 exit(-1);
1747 }
1748
1749 if (cmd->cmd.scan->ir_scan)
1750 xds110.txn_requests[xds110.txn_request_size++] = CMD_IR_SCAN;
1751 else
1752 xds110.txn_requests[xds110.txn_request_size++] = CMD_DR_SCAN;
1753
1754 end_state = (uint8_t)xds_jtag_state[cmd->cmd.scan->end_state];
1755 xds110.txn_requests[xds110.txn_request_size++] = end_state;
1756
1757 xds110.txn_requests[xds110.txn_request_size++] = (total_bits >> 0) & 0xff;
1758 xds110.txn_requests[xds110.txn_request_size++] = (total_bits >> 8) & 0xff;
1759
1760 /* Build request data by flattening fields into single buffer */
1761 /* also populate the results array to return the results when run */
1762 offset = 0;
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);
1771 }
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;
1778 }
1779 xds110.txn_request_size += total_bytes;
1780 xds110.txn_result_size += total_bytes;
1781 }
1782
1783 static void xds110_queue_runtest(struct jtag_command *cmd)
1784 {
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];
1787
1788 /* Check if new request would be too large to fit */
1789 if ((xds110.txn_request_size + 1 + sizeof(clocks) + sizeof(end_state) + 1)
1790 > MAX_DATA_BLOCK)
1791 xds110_flush();
1792
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;
1800 }
1801
1802 static void xds110_queue_stableclocks(struct jtag_command *cmd)
1803 {
1804 uint32_t clocks = (uint32_t)cmd->cmd.stableclocks->num_cycles;
1805
1806 /* Check if new request would be too large to fit */
1807 if ((xds110.txn_request_size + 1 + sizeof(clocks) + 1) > MAX_DATA_BLOCK)
1808 xds110_flush();
1809
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;
1816 }
1817
1818 static void xds110_execute_command(struct jtag_command *cmd)
1819 {
1820 switch (cmd->type) {
1821 case JTAG_SLEEP:
1822 xds110_flush();
1823 xds110_execute_sleep(cmd);
1824 break;
1825 case JTAG_TLR_RESET:
1826 xds110_flush();
1827 xds110_execute_tlr_reset(cmd);
1828 break;
1829 case JTAG_PATHMOVE:
1830 xds110_flush();
1831 xds110_execute_pathmove(cmd);
1832 break;
1833 case JTAG_SCAN:
1834 xds110_queue_scan(cmd);
1835 break;
1836 case JTAG_RUNTEST:
1837 xds110_queue_runtest(cmd);
1838 break;
1839 case JTAG_STABLECLOCKS:
1840 xds110_queue_stableclocks(cmd);
1841 break;
1842 case JTAG_TMS:
1843 default:
1844 LOG_ERROR("BUG: unknown JTAG command type 0x%x encountered",
1845 cmd->type);
1846 exit(-1);
1847 }
1848 }
1849
1850 static int xds110_execute_queue(void)
1851 {
1852 struct jtag_command *cmd = jtag_command_queue;
1853
1854 while (cmd) {
1855 xds110_execute_command(cmd);
1856 cmd = cmd->next;
1857 }
1858
1859 xds110_flush();
1860
1861 return ERROR_OK;
1862 }
1863
1864 static int xds110_speed(int speed)
1865 {
1866 double freq_to_use;
1867 uint32_t delay_count;
1868 bool success;
1869
1870 if (speed == 0) {
1871 LOG_INFO("XDS110: RTCK not supported");
1872 return ERROR_JTAG_NOT_IMPLEMENTED;
1873 }
1874
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;
1879 }
1880
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) {
1884
1885 /* Check for request for top speed or higher */
1886 if (speed >= XDS110_MAX_SLOW_TCK_SPEED) {
1887
1888 /* Inform user that speed was adjusted down to max possible */
1889 if (speed > XDS110_MAX_SLOW_TCK_SPEED) {
1890 LOG_INFO(
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;
1894 }
1895 delay_count = 0;
1896
1897 } else {
1898
1899 const double XDS110_TCK_PULSE_INCREMENT = 66.0;
1900 freq_to_use = speed * 1000; /* Hz */
1901 delay_count = 0;
1902
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);
1908
1909 /* Convert frequency to pulse duration */
1910 double freq_to_pulse_width_in_ns = one_giga / freq_to_use;
1911
1912 /*
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.
1916 */
1917 double current_value = max_freq_pulse_duration;
1918
1919 while (current_value < freq_to_pulse_width_in_ns) {
1920 current_value += XDS110_TCK_PULSE_INCREMENT;
1921 ++delay_count;
1922 }
1923
1924 /*
1925 * Determine which delay count yields the best match.
1926 * The one obtained above or one less.
1927 */
1928 if (delay_count) {
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)))) -
1934 freq_to_use;
1935
1936 /* One less count value yields a better match */
1937 if (diff_freq_1 > diff_freq_2)
1938 --delay_count;
1939 }
1940 }
1941
1942 /* Newer firmware has reworked TCK routines that are much more efficient */
1943 /* and can now achieve a peak TCK frequency of 14000 kHz */
1944 } else {
1945
1946 if (speed >= XDS110_MAX_FAST_TCK_SPEED) {
1947 if (speed > XDS110_MAX_FAST_TCK_SPEED) {
1948 LOG_INFO(
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;
1952 }
1953 delay_count = 0;
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;
1964 } else {
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 */
1970
1971 freq_to_use = speed * 1000; /* Hz */
1972 double period = 1.0/freq_to_use;
1973 double delay = m * period + b;
1974
1975 if (delay < 1.0)
1976 delay_count = 1;
1977 else
1978 delay_count = (uint32_t)delay;
1979 }
1980 }
1981
1982 /* Send the delay count to the XDS110 firmware */
1983 success = xds_set_tck_delay(delay_count);
1984
1985 if (success) {
1986 xds110.delay_count = delay_count;
1987 xds110.speed = speed;
1988 }
1989
1990 return (success) ? ERROR_OK : ERROR_FAIL;
1991 }
1992
1993 static int xds110_speed_div(int speed, int *khz)
1994 {
1995 *khz = speed;
1996 return ERROR_OK;
1997 }
1998
1999 static int xds110_khz(int khz, int *jtag_speed)
2000 {
2001 *jtag_speed = khz;
2002 return ERROR_OK;
2003 }
2004
2005 COMMAND_HANDLER(xds110_handle_info_command)
2006 {
2007 xds110_show_info();
2008 return ERROR_OK;
2009 }
2010
2011 COMMAND_HANDLER(xds110_handle_supply_voltage_command)
2012 {
2013 uint32_t voltage = 0;
2014
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;
2021 } else {
2022 LOG_ERROR("XDS110: voltage must be 0 or between %d and %d "
2023 "millivolts", XDS110_MIN_VOLTAGE, XDS110_MAX_VOLTAGE);
2024 return ERROR_FAIL;
2025 }
2026 xds110.voltage = voltage;
2027 } else
2028 return ERROR_COMMAND_SYNTAX_ERROR;
2029
2030 return ERROR_OK;
2031 }
2032
2033 static const struct command_registration xds110_subcommand_handlers[] = {
2034 {
2035 .name = "info",
2036 .handler = &xds110_handle_info_command,
2037 .mode = COMMAND_EXEC,
2038 .help = "show XDS110 info",
2039 .usage = "",
2040 },
2041 {
2042 .name = "supply",
2043 .handler = &xds110_handle_supply_voltage_command,
2044 .mode = COMMAND_CONFIG,
2045 .help = "set the XDS110 probe supply voltage",
2046 .usage = "voltage_in_millivolts",
2047 },
2048 COMMAND_REGISTRATION_DONE
2049 };
2050
2051 static const struct command_registration xds110_command_handlers[] = {
2052 {
2053 .name = "xds110",
2054 .mode = COMMAND_ANY,
2055 .help = "perform XDS110 management",
2056 .usage = "",
2057 .chain = xds110_subcommand_handlers,
2058 },
2059 COMMAND_REGISTRATION_DONE
2060 };
2061
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,
2068 };
2069
2070 static const char * const xds110_transport[] = { "swd", "jtag", NULL };
2071
2072 static struct jtag_interface xds110_interface = {
2073 .execute_queue = xds110_execute_queue,
2074 };
2075
2076 struct adapter_driver xds110_adapter_driver = {
2077 .name = "xds110",
2078 .transports = xds110_transport,
2079 .commands = xds110_command_handlers,
2080
2081 .init = xds110_init,
2082 .quit = xds110_quit,
2083 .reset = xds110_reset,
2084 .speed = xds110_speed,
2085 .khz = xds110_khz,
2086 .speed_div = xds110_speed_div,
2087
2088 .jtag_ops = &xds110_interface,
2089 .swd_ops = &xds110_swd_driver,
2090 };
Open On-Chip Debugger

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)