?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix libusb-1.0.22 deprecated libusb_set_debug with libusb_set_option
[openocd.git] / src / jtag / drivers / xds110.c
blob9bfe02ea87b4cd3f5dea45abbadd9a159c5864ff
1 /***************************************************************************
2 * Copyright (C) 2017 by Texas Instruments, Inc. *
3 * *
4 * This program is free software; you can redistribute it and/or modify *
5 * it under the terms of the GNU General Public License as published by *
6 * the Free Software Foundation; either version 2 of the License, or *
7 * (at your option) any later version. *
8 * *
9 * This program is distributed in the hope that it will be useful, *
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
12 * GNU General Public License for more details. *
13 * *
14 * You should have received a copy of the GNU General Public License *
15 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
16 ***************************************************************************/
17
18 #ifdef HAVE_CONFIG_H
19 #include "config.h"
20 #endif
21
22 #include <transport/transport.h>
23 #include <jtag/swd.h>
24 #include <jtag/interface.h>
25 #include <jtag/commands.h>
26 #include <jtag/tcl.h>
27 #include <libusb.h>
28
29 /* XDS110 USB serial number length */
30 #define XDS110_SERIAL_LEN 8
31
32 /* Firmware version that introduced OpenOCD support via block accesses */
33 #define OCD_FIRMWARE_VERSION 0x02030011
34 #define OCD_FIRMWARE_UPGRADE \
35 "XDS110: upgrade to version 2.3.0.11+ for improved support"
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 * USB Connection Endpoints *
58 ***************************************************************************/
59
60 /* Bulk endpoints used by the XDS110 debug interface */
61 #define INTERFACE_DEBUG (2)
62 #define ENDPOINT_DEBUG_IN (3 | LIBUSB_ENDPOINT_IN)
63 #define ENDPOINT_DEBUG_OUT (2 | LIBUSB_ENDPOINT_OUT)
64
65 /***************************************************************************
66 * XDS110 Firmware API Definitions *
67 ***************************************************************************/
68
69 /*
70 * Default values controlling how the host communicates commands
71 * with XDS110 firmware (automatic retry count and wait timeout)
72 */
73 #define DEFAULT_ATTEMPTS (1)
74 #define DEFAULT_TIMEOUT (4000)
75
76 /* XDS110 API error codes */
77 #define SC_ERR_NONE 0
78 #define SC_ERR_XDS110_FAIL -261
79 #define SC_ERR_SWD_WAIT -613
80 #define SC_ERR_SWD_FAULT -614
81 #define SC_ERR_SWD_PROTOCOL -615
82 #define SC_ERR_SWD_PARITY -616
83 #define SC_ERR_SWD_DEVICE_ID -617
84
85 /* TCK frequency limits */
86 #define XDS110_MIN_TCK_SPEED 100 /* kHz */
87 #define XDS110_MAX_TCK_SPEED 2500 /* kHz */
88 #define XDS110_TCK_PULSE_INCREMENT 66.0
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 OCD_DAP_REQUEST 0x3a /* Handle block of DAP requests */
166 #define OCD_SCAN_REQUEST 0x3b /* Handle block of JTAG scan requests */
167 #define OCD_PATHMOVE 0x3c /* Handle PATHMOVE to navigate JTAG states */
168
169 #define CMD_IR_SCAN 1
170 #define CMD_DR_SCAN 2
171 #define CMD_RUNTEST 3
172 #define CMD_STABLECLOCKS 4
173
174 /* Array to convert from OpenOCD tap_state_t to XDS JTAG state */
175 const uint32_t xds_jtag_state[] = {
176 XDS_JTAG_STATE_EXIT2_DR, /* TAP_DREXIT2 = 0x0 */
177 XDS_JTAG_STATE_EXIT1_DR, /* TAP_DREXIT1 = 0x1 */
178 XDS_JTAG_STATE_SHIFT_DR, /* TAP_DRSHIFT = 0x2 */
179 XDS_JTAG_STATE_PAUSE_DR, /* TAP_DRPAUSE = 0x3 */
180 XDS_JTAG_STATE_SELECT_IR, /* TAP_IRSELECT = 0x4 */
181 XDS_JTAG_STATE_UPDATE_DR, /* TAP_DRUPDATE = 0x5 */
182 XDS_JTAG_STATE_CAPTURE_DR, /* TAP_DRCAPTURE = 0x6 */
183 XDS_JTAG_STATE_SELECT_DR, /* TAP_DRSELECT = 0x7 */
184 XDS_JTAG_STATE_EXIT2_IR, /* TAP_IREXIT2 = 0x8 */
185 XDS_JTAG_STATE_EXIT1_IR, /* TAP_IREXIT1 = 0x9 */
186 XDS_JTAG_STATE_SHIFT_IR, /* TAP_IRSHIFT = 0xa */
187 XDS_JTAG_STATE_PAUSE_IR, /* TAP_IRPAUSE = 0xb */
188 XDS_JTAG_STATE_IDLE, /* TAP_IDLE = 0xc */
189 XDS_JTAG_STATE_UPDATE_IR, /* TAP_IRUPDATE = 0xd */
190 XDS_JTAG_STATE_CAPTURE_IR, /* TAP_IRCAPTURE = 0xe */
191 XDS_JTAG_STATE_RESET, /* TAP_RESET = 0xf */
192 };
193
194 struct scan_result {
195 bool first;
196 uint8_t *buffer;
197 uint32_t num_bits;
198 };
199
200 struct xds110_info {
201 /* USB connection handles and data buffers */
202 libusb_context *ctx;
203 libusb_device_handle *dev;
204 unsigned char read_payload[USB_PAYLOAD_SIZE];
205 unsigned char write_packet[3];
206 unsigned char write_payload[USB_PAYLOAD_SIZE];
207 /* Status flags */
208 bool is_connected;
209 bool is_cmapi_connected;
210 bool is_cmapi_acquired;
211 bool is_swd_mode;
212 bool is_ap_dirty;
213 /* DAP register caches */
214 uint32_t select;
215 uint32_t rdbuff;
216 bool use_rdbuff;
217 /* TCK speed and delay count*/
218 uint32_t speed;
219 uint32_t delay_count;
220 /* XDS110 serial number */
221 char serial[XDS110_SERIAL_LEN + 1];
222 /* XDS110 firmware and hardware version */
223 uint32_t firmware;
224 uint16_t hardware;
225 /* Transaction queues */
226 unsigned char txn_requests[MAX_DATA_BLOCK];
227 uint32_t *txn_dap_results[MAX_DATA_BLOCK / 4];
228 struct scan_result txn_scan_results[MAX_DATA_BLOCK / 4];
229 uint32_t txn_request_size;
230 uint32_t txn_result_size;
231 uint32_t txn_result_count;
232 };
233
234 static struct xds110_info xds110 = {
235 .ctx = NULL,
236 .dev = NULL,
237 .is_connected = false,
238 .is_cmapi_connected = false,
239 .is_cmapi_acquired = false,
240 .is_swd_mode = false,
241 .is_ap_dirty = false,
242 .speed = XDS110_MAX_TCK_SPEED,
243 .delay_count = 0,
244 .serial = {0},
245 .firmware = 0,
246 .hardware = 0,
247 .txn_request_size = 0,
248 .txn_result_size = 0,
249 .txn_result_count = 0
250 };
251
252 static inline void xds110_set_u32(uint8_t *buffer, uint32_t value)
253 {
254 buffer[3] = (value >> 24) & 0xff;
255 buffer[2] = (value >> 16) & 0xff;
256 buffer[1] = (value >> 8) & 0xff;
257 buffer[0] = (value >> 0) & 0xff;
258 }
259
260 static inline void xds110_set_u16(uint8_t *buffer, uint16_t value)
261 {
262 buffer[1] = (value >> 8) & 0xff;
263 buffer[0] = (value >> 0) & 0xff;
264 }
265
266 static inline uint32_t xds110_get_u32(uint8_t *buffer)
267 {
268 uint32_t value = (((uint32_t)buffer[3]) << 24) |
269 (((uint32_t)buffer[2]) << 16) |
270 (((uint32_t)buffer[1]) << 8) |
271 (((uint32_t)buffer[0]) << 0);
272 return value;
273 }
274
275 static inline uint16_t xds110_get_u16(uint8_t *buffer)
276 {
277 uint16_t value = (((uint32_t)buffer[1]) << 8) |
278 (((uint32_t)buffer[0]) << 0);
279 return value;
280 }
281
282 /***************************************************************************
283 * usb connection routines *
284 * *
285 * The following functions handle connecting, reading, and writing to *
286 * the XDS110 over USB using the libusb library. *
287 ***************************************************************************/
288
289 static bool usb_connect(void)
290 {
291 libusb_context *ctx = NULL;
292 libusb_device **list = NULL;
293 libusb_device_handle *dev = NULL;
294
295 struct libusb_device_descriptor desc;
296
297 uint16_t vid = 0x0451;
298 uint16_t pid = 0xbef3;
299 ssize_t count = 0;
300 ssize_t i = 0;
301 int result = 0;
302 bool found = false;
303
304 /* Initialize libusb context */
305 result = libusb_init(&ctx);
306
307 if (0 == result) {
308 /* Get list of USB devices attached to system */
309 count = libusb_get_device_list(ctx, &list);
310 if (count <= 0) {
311 result = -1;
312 list = NULL;
313 }
314 }
315
316 if (0 == result) {
317 /* Scan through list of devices for any XDS110s */
318 for (i = 0; i < count; i++) {
319 /* Check for device VID/PID match */
320 libusb_get_device_descriptor(list[i], &desc);
321 if (desc.idVendor == vid && desc.idProduct == pid) {
322 result = libusb_open(list[i], &dev);
323 if (0 == result) {
324 const int MAX_DATA = 256;
325 unsigned char data[MAX_DATA + 1];
326 *data = '\0';
327
328 /* May be the requested device if serial number matches */
329 if (0 == xds110.serial[0]) {
330 /* No serial number given; match first XDS110 found */
331 found = true;
332 break;
333 } else {
334 /* Get the device's serial number string */
335 result = libusb_get_string_descriptor_ascii(dev,
336 desc.iSerialNumber, data, MAX_DATA);
337 if (0 < result &&
338 0 == strcmp((char *)data, (char *)xds110.serial)) {
339 found = true;
340 break;
341 }
342 }
343
344 /* If we fall though to here, we don't want this device */
345 libusb_close(dev);
346 dev = NULL;
347 }
348 }
349 }
350 }
351
352 /*
353 * We can fall through the for() loop with two possible exit conditions:
354 * 1) found the right XDS110, and that device is open
355 * 2) didn't find the XDS110, and no devices are currently open
356 */
357
358 if (NULL != list) {
359 /* Free the device list, we're done with it */
360 libusb_free_device_list(list, 1);
361 }
362
363 if (found) {
364 /* Save the context and device handles */
365 xds110.ctx = ctx;
366 xds110.dev = dev;
367
368 /* Set libusb to auto detach kernel and disable debug messages */
369 (void)libusb_set_auto_detach_kernel_driver(dev, 1);
370 #if LIBUSB_API_VERSION >= 0x01000106
371 libusb_set_option(ctx, LIBUSB_OPTION_LOG_LEVEL, LIBUSB_LOG_LEVEL_NONE);
372 #else
373 libusb_set_debug(ctx, LIBUSB_LOG_LEVEL_NONE);
374 #endif
375 /* Claim the debug interface on the XDS110 */
376 result = libusb_claim_interface(dev, INTERFACE_DEBUG);
377 } else {
378 /* Couldn't find an XDS110, flag the error */
379 result = -1;
380 }
381
382 /* On an error, clean up what we can */
383 if (0 != result) {
384 if (NULL != dev) {
385 /* Release the debug and data interface on the XDS110 */
386 (void)libusb_release_interface(dev, INTERFACE_DEBUG);
387 libusb_close(dev);
388 }
389 if (NULL != ctx)
390 libusb_exit(ctx);
391 xds110.ctx = NULL;
392 xds110.dev = NULL;
393 }
394
395 /* Log the results */
396 if (0 == result)
397 LOG_INFO("XDS110: connected");
398 else
399 LOG_ERROR("XDS110: failed to connect");
400
401 return (0 == result) ? true : false;
402 }
403
404 static void usb_disconnect(void)
405 {
406 if (NULL != xds110.dev) {
407 /* Release the debug and data interface on the XDS110 */
408 (void)libusb_release_interface(xds110.dev, INTERFACE_DEBUG);
409 libusb_close(xds110.dev);
410 xds110.dev = NULL;
411 }
412 if (NULL != xds110.ctx) {
413 libusb_exit(xds110.ctx);
414 xds110.ctx = NULL;
415 }
416
417 LOG_INFO("XDS110: disconnected");
418 }
419
420 static bool usb_read(unsigned char *buffer, int size, int *bytes_read,
421 int timeout)
422 {
423 int result;
424
425 if (NULL == xds110.dev || NULL == buffer || NULL == bytes_read)
426 return false;
427
428 /* Force a non-zero timeout to prevent blocking */
429 if (0 == timeout)
430 timeout = DEFAULT_TIMEOUT;
431
432 result = libusb_bulk_transfer(xds110.dev, ENDPOINT_DEBUG_IN, buffer, size,
433 bytes_read, timeout);
434
435 return (0 == result) ? true : false;
436 }
437
438 static bool usb_write(unsigned char *buffer, int size, int *written)
439 {
440 int bytes_written = 0;
441 int result = LIBUSB_SUCCESS;
442 int retries = 0;
443
444 if (NULL == xds110.dev || NULL == buffer)
445 return false;
446
447 result = libusb_bulk_transfer(xds110.dev, ENDPOINT_DEBUG_OUT, buffer,
448 size, &bytes_written, 0);
449
450 while (LIBUSB_ERROR_PIPE == result && retries < 3) {
451 /* Try clearing the pipe stall and retry transfer */
452 libusb_clear_halt(xds110.dev, ENDPOINT_DEBUG_OUT);
453 result = libusb_bulk_transfer(xds110.dev, ENDPOINT_DEBUG_OUT, buffer,
454 size, &bytes_written, 0);
455 retries++;
456 }
457
458 if (NULL != written)
459 *written = bytes_written;
460
461 return (0 == result && size == bytes_written) ? true : false;
462 }
463
464 static bool usb_get_response(uint32_t *total_bytes_read, uint32_t timeout)
465 {
466 static unsigned char buffer[MAX_PACKET];
467 int bytes_read;
468 uint16_t size;
469 uint16_t count;
470 bool success;
471
472 size = 0;
473 success = true;
474 while (success) {
475 success = usb_read(buffer, sizeof(buffer), &bytes_read, timeout);
476 if (success) {
477 /*
478 * Validate that this appears to be a good response packet
479 * First check it contains enough data for header and error
480 * code, plus the first character is the start character
481 */
482 if (bytes_read >= 7 && '*' == buffer[0]) {
483 /* Extract the payload size */
484 size = xds110_get_u16(&buffer[1]);
485 /* Sanity test on payload size */
486 if (USB_PAYLOAD_SIZE >= size && 4 <= size) {
487 /* Check we didn't get more data than expected */
488 if ((bytes_read - 3) <= size) {
489 /* Packet appears to be valid, move on */
490 break;
491 }
492 }
493 }
494 }
495 /*
496 * Somehow received an invalid packet, retry till we
497 * time out or a valid response packet is received
498 */
499 }
500
501 /* Abort now if we didn't receive a valid response */
502 if (!success) {
503 if (NULL != total_bytes_read)
504 *total_bytes_read = 0;
505 return false;
506 }
507
508 /* Build the return payload into xds110.read_payload */
509
510 /* Copy over payload data from received buffer (skipping header) */
511 count = 0;
512 bytes_read -= 3;
513 memcpy((void *)&xds110.read_payload[count], (void *)&buffer[3], bytes_read);
514 count += bytes_read;
515 /*
516 * Drop timeout to just 1/2 second. Once the XDS110 starts sending
517 * a response, the remaining packets should arrive in short order
518 */
519 if (timeout > 500)
520 timeout = 500; /* ms */
521
522 /* If there's more data to retrieve, get it now */
523 while ((count < size) && success) {
524 success = usb_read(buffer, sizeof(buffer), &bytes_read, timeout);
525 if (success) {
526 if ((count + bytes_read) > size) {
527 /* Read too much data, not a valid packet, abort */
528 success = false;
529 } else {
530 /* Copy this data over to xds110.read_payload */
531 memcpy((void *)&xds110.read_payload[count], (void *)buffer,
532 bytes_read);
533 count += bytes_read;
534 }
535 }
536 }
537
538 if (!success)
539 count = 0;
540 if (NULL != total_bytes_read)
541 *total_bytes_read = count;
542
543 return success;
544 }
545
546 static bool usb_send_command(uint16_t size)
547 {
548 int written;
549 bool success = true;
550
551 /* Check the packet length */
552 if (size > USB_PAYLOAD_SIZE)
553 return false;
554
555 /* Place the start character into the packet buffer */
556 xds110.write_packet[0] = '*';
557
558 /* Place the payload size into the packet buffer */
559 xds110_set_u16(&xds110.write_packet[1], size);
560
561 /* Adjust size to include header */
562 size += 3;
563
564 /* Send the data via the USB connection */
565 success = usb_write(xds110.write_packet, (int)size, &written);
566
567 /* Check if the correct number of bytes was written */
568 if (written != (int)size)
569 success = false;
570
571 return success;
572 }
573
574 /***************************************************************************
575 * XDS110 firmware API routines *
576 * *
577 * The following functions handle calling into the XDS110 firmware to *
578 * perform requested debug actions. *
579 ***************************************************************************/
580
581 static bool xds_execute(uint32_t out_length, uint32_t in_length,
582 uint32_t attempts, uint32_t timeout)
583 {
584 bool done = false;
585 bool success = true;
586 int error = 0;
587 uint32_t bytes_read = 0;
588
589 if (NULL == xds110.dev)
590 return false;
591
592 while (!done && attempts > 0) {
593 attempts--;
594
595 /* Send command to XDS110 */
596 success = usb_send_command(out_length);
597
598 if (success) {
599 /* Get response from XDS110 */
600 success = usb_get_response(&bytes_read, timeout);
601 }
602
603 if (success) {
604 /* Check for valid response from XDS code handling */
605 if (bytes_read != in_length) {
606 /* Unexpected amount of data returned */
607 success = false;
608 } else {
609 /* Extract error code from return packet */
610 error = (int)xds110_get_u32(&xds110.read_payload[0]);
611 done = true;
612 }
613 }
614 }
615
616 if (!success)
617 error = SC_ERR_XDS110_FAIL;
618
619 if (0 != error)
620 success = false;
621
622 return success;
623 }
624
625 static bool xds_connect(void)
626 {
627 bool success;
628
629 xds110.write_payload[0] = XDS_CONNECT;
630
631 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
632 DEFAULT_TIMEOUT);
633
634 return success;
635 }
636
637 static bool xds_disconnect(void)
638 {
639 bool success;
640
641 xds110.write_payload[0] = XDS_DISCONNECT;
642
643 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
644 DEFAULT_TIMEOUT);
645
646 return success;
647 }
648
649 static bool xds_version(uint32_t *firmware_id, uint16_t *hardware_id)
650 {
651 uint8_t *fw_id_pntr = &xds110.read_payload[XDS_IN_LEN + 0]; /* 32-bits */
652 uint8_t *hw_id_pntr = &xds110.read_payload[XDS_IN_LEN + 4]; /* 16-bits */
653
654 bool success;
655
656 xds110.write_payload[0] = XDS_VERSION;
657
658 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN + 6, DEFAULT_ATTEMPTS,
659 DEFAULT_TIMEOUT);
660
661 if (success) {
662 if (NULL != firmware_id)
663 *firmware_id = xds110_get_u32(fw_id_pntr);
664 if (NULL != hardware_id)
665 *hardware_id = xds110_get_u16(hw_id_pntr);
666 }
667
668 return success;
669 }
670
671 static bool xds_set_tck_delay(uint32_t delay)
672 {
673 uint8_t *delay_pntr = &xds110.write_payload[XDS_OUT_LEN + 0]; /* 32-bits */
674
675 bool success;
676
677 xds110.write_payload[0] = XDS_SET_TCK;
678
679 xds110_set_u32(delay_pntr, delay);
680
681 success = xds_execute(XDS_OUT_LEN + 4, XDS_IN_LEN, DEFAULT_ATTEMPTS,
682 DEFAULT_TIMEOUT);
683
684 return success;
685 }
686
687 static bool xds_set_trst(uint8_t trst)
688 {
689 uint8_t *trst_pntr = &xds110.write_payload[XDS_OUT_LEN + 0]; /* 8-bits */
690
691 bool success;
692
693 xds110.write_payload[0] = XDS_SET_TRST;
694
695 *trst_pntr = trst;
696
697 success = xds_execute(XDS_OUT_LEN + 1, XDS_IN_LEN, DEFAULT_ATTEMPTS,
698 DEFAULT_TIMEOUT);
699
700 return success;
701 }
702
703 static bool xds_cycle_tck(uint32_t count)
704 {
705 uint8_t *count_pntr = &xds110.write_payload[XDS_OUT_LEN + 0]; /* 32-bits */
706
707 bool success;
708
709 xds110.write_payload[0] = XDS_CYCLE_TCK;
710
711 xds110_set_u32(count_pntr, count);
712
713 success = xds_execute(XDS_OUT_LEN + 4, XDS_IN_LEN, DEFAULT_ATTEMPTS,
714 DEFAULT_TIMEOUT);
715
716 return success;
717 }
718
719 static bool xds_goto_state(uint32_t state)
720 {
721 uint8_t *state_pntr = &xds110.write_payload[XDS_OUT_LEN + 0]; /* 32-bits */
722 uint8_t *transit_pntr = &xds110.write_payload[XDS_OUT_LEN+4]; /* 32-bits */
723
724 bool success;
725
726 xds110.write_payload[0] = XDS_GOTO_STATE;
727
728 xds110_set_u32(state_pntr, state);
729 xds110_set_u32(transit_pntr, XDS_JTAG_TRANSIT_QUICKEST);
730
731 success = xds_execute(XDS_OUT_LEN+8, XDS_IN_LEN, DEFAULT_ATTEMPTS,
732 DEFAULT_TIMEOUT);
733
734 return success;
735 }
736
737 static bool xds_jtag_scan(uint32_t shift_state, uint16_t shift_bits,
738 uint32_t end_state, uint8_t *data_out, uint8_t *data_in)
739 {
740 uint8_t *bits_pntr = &xds110.write_payload[XDS_OUT_LEN + 0]; /* 16-bits */
741 uint8_t *path_pntr = &xds110.write_payload[XDS_OUT_LEN + 2]; /* 8-bits */
742 uint8_t *trans1_pntr = &xds110.write_payload[XDS_OUT_LEN + 3]; /* 8-bits */
743 uint8_t *end_pntr = &xds110.write_payload[XDS_OUT_LEN + 4]; /* 8-bits */
744 uint8_t *trans2_pntr = &xds110.write_payload[XDS_OUT_LEN + 5]; /* 8-bits */
745 uint8_t *pre_pntr = &xds110.write_payload[XDS_OUT_LEN + 6]; /* 16-bits */
746 uint8_t *pos_pntr = &xds110.write_payload[XDS_OUT_LEN + 8]; /* 16-bits */
747 uint8_t *delay_pntr = &xds110.write_payload[XDS_OUT_LEN + 10]; /* 16-bits */
748 uint8_t *rep_pntr = &xds110.write_payload[XDS_OUT_LEN + 12]; /* 16-bits */
749 uint8_t *out_pntr = &xds110.write_payload[XDS_OUT_LEN + 14]; /* 16-bits */
750 uint8_t *in_pntr = &xds110.write_payload[XDS_OUT_LEN + 16]; /* 16-bits */
751 uint8_t *data_out_pntr = &xds110.write_payload[XDS_OUT_LEN + 18];
752 uint8_t *data_in_pntr = &xds110.read_payload[XDS_IN_LEN+0];
753
754 uint16_t total_bytes = DIV_ROUND_UP(shift_bits, 8);
755
756 bool success;
757
758 xds110.write_payload[0] = XDS_JTAG_SCAN;
759
760 xds110_set_u16(bits_pntr, shift_bits); /* bits to scan */
761 *path_pntr = (uint8_t)(shift_state & 0xff); /* IR vs DR path */
762 *trans1_pntr = (uint8_t)XDS_JTAG_TRANSIT_QUICKEST; /* start state route */
763 *end_pntr = (uint8_t)(end_state & 0xff); /* JTAG state after scan */
764 *trans2_pntr = (uint8_t)XDS_JTAG_TRANSIT_QUICKEST; /* end state route */
765 xds110_set_u16(pre_pntr, 0); /* number of preamble bits */
766 xds110_set_u16(pos_pntr, 0); /* number of postamble bits */
767 xds110_set_u16(delay_pntr, 0); /* number of extra TCKs after scan */
768 xds110_set_u16(rep_pntr, 1); /* number of repetitions */
769 xds110_set_u16(out_pntr, total_bytes); /* out buffer offset (if repeats) */
770 xds110_set_u16(in_pntr, total_bytes); /* in buffer offset (if repeats) */
771
772 memcpy((void *)data_out_pntr, (void *)data_out, total_bytes);
773
774 success = xds_execute(XDS_OUT_LEN + 18 + total_bytes,
775 XDS_IN_LEN + total_bytes, DEFAULT_ATTEMPTS, DEFAULT_TIMEOUT);
776
777 if (success)
778 memcpy((void *)data_in, (void *)data_in_pntr, total_bytes);
779
780 return success;
781 }
782
783 static bool xds_set_srst(uint8_t srst)
784 {
785 uint8_t *srst_pntr = &xds110.write_payload[XDS_OUT_LEN + 0]; /* 8-bits */
786
787 bool success;
788
789 xds110.write_payload[0] = XDS_SET_SRST;
790
791 *srst_pntr = srst;
792
793 success = xds_execute(XDS_OUT_LEN + 1, XDS_IN_LEN, DEFAULT_ATTEMPTS,
794 DEFAULT_TIMEOUT);
795
796 return success;
797 }
798
799 static bool cmapi_connect(uint32_t *idcode)
800 {
801 uint8_t *idcode_pntr = &xds110.read_payload[XDS_IN_LEN + 0]; /* 32-bits */
802
803 bool success;
804
805 xds110.write_payload[0] = CMAPI_CONNECT;
806
807 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN+4, DEFAULT_ATTEMPTS,
808 DEFAULT_TIMEOUT);
809
810 if (success) {
811 if (NULL != idcode)
812 *idcode = xds110_get_u32(idcode_pntr);
813 }
814
815 return success;
816 }
817
818 static bool cmapi_disconnect(void)
819 {
820 bool success;
821
822 xds110.write_payload[0] = CMAPI_DISCONNECT;
823
824 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
825 DEFAULT_TIMEOUT);
826
827 return success;
828 }
829
830 static bool cmapi_acquire(void)
831 {
832 bool success;
833
834 xds110.write_payload[0] = CMAPI_ACQUIRE;
835
836 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
837 DEFAULT_TIMEOUT);
838
839 return success;
840 }
841
842 static bool cmapi_release(void)
843 {
844 bool success;
845
846 xds110.write_payload[0] = CMAPI_RELEASE;
847
848 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
849 DEFAULT_TIMEOUT);
850
851 return success;
852 }
853
854 static bool cmapi_read_dap_reg(uint32_t type, uint32_t ap_num,
855 uint32_t address, uint32_t *value)
856 {
857 uint8_t *type_pntr = &xds110.write_payload[XDS_OUT_LEN + 0]; /* 8-bits */
858 uint8_t *ap_num_pntr = &xds110.write_payload[XDS_OUT_LEN + 1]; /* 8-bits */
859 uint8_t *address_pntr = &xds110.write_payload[XDS_OUT_LEN + 2]; /* 8-bits */
860 uint8_t *value_pntr = &xds110.read_payload[XDS_IN_LEN + 0]; /* 32-bits */
861
862 bool success;
863
864 xds110.write_payload[0] = CMAPI_REG_READ;
865
866 *type_pntr = (uint8_t)(type & 0xff);
867 *ap_num_pntr = (uint8_t)(ap_num & 0xff);
868 *address_pntr = (uint8_t)(address & 0xff);
869
870 success = xds_execute(XDS_OUT_LEN + 3, XDS_IN_LEN + 4, DEFAULT_ATTEMPTS,
871 DEFAULT_TIMEOUT);
872
873 if (success) {
874 if (NULL != value)
875 *value = xds110_get_u32(value_pntr);
876 }
877
878 return success;
879 }
880
881 static bool cmapi_write_dap_reg(uint32_t type, uint32_t ap_num,
882 uint32_t address, uint32_t *value)
883 {
884 uint8_t *type_pntr = &xds110.write_payload[XDS_OUT_LEN + 0]; /* 8-bits */
885 uint8_t *ap_num_pntr = &xds110.write_payload[XDS_OUT_LEN + 1]; /* 8-bits */
886 uint8_t *address_pntr = &xds110.write_payload[XDS_OUT_LEN + 2]; /* 8-bits */
887 uint8_t *value_pntr = &xds110.write_payload[XDS_OUT_LEN + 3]; /* 32-bits */
888
889 bool success;
890
891 if (NULL == value)
892 return false;
893
894 xds110.write_payload[0] = CMAPI_REG_WRITE;
895
896 *type_pntr = (uint8_t)(type & 0xff);
897 *ap_num_pntr = (uint8_t)(ap_num & 0xff);
898 *address_pntr = (uint8_t)(address & 0xff);
899 xds110_set_u32(value_pntr, *value);
900
901 success = xds_execute(XDS_OUT_LEN + 7, XDS_IN_LEN, DEFAULT_ATTEMPTS,
902 DEFAULT_TIMEOUT);
903
904 return success;
905 }
906
907 static bool swd_connect(void)
908 {
909 bool success;
910
911 xds110.write_payload[0] = SWD_CONNECT;
912
913 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
914 DEFAULT_TIMEOUT);
915
916 return success;
917 }
918
919 static bool swd_disconnect(void)
920 {
921 bool success;
922
923 xds110.write_payload[0] = SWD_DISCONNECT;
924
925 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
926 DEFAULT_TIMEOUT);
927
928 return success;
929 }
930
931 static bool cjtag_connect(uint32_t format)
932 {
933 uint8_t *format_pntr = &xds110.write_payload[XDS_OUT_LEN + 0]; /* 32-bits */
934
935 bool success;
936
937 xds110.write_payload[0] = CJTAG_CONNECT;
938
939 xds110_set_u32(format_pntr, format);
940
941 success = xds_execute(XDS_OUT_LEN + 4, XDS_IN_LEN, DEFAULT_ATTEMPTS,
942 DEFAULT_TIMEOUT);
943
944 return success;
945 }
946
947 static bool cjtag_disconnect(void)
948 {
949 bool success;
950
951 xds110.write_payload[0] = CJTAG_DISCONNECT;
952
953 success = xds_execute(XDS_OUT_LEN, XDS_IN_LEN, DEFAULT_ATTEMPTS,
954 DEFAULT_TIMEOUT);
955
956 return success;
957 }
958
959 static bool ocd_dap_request(uint8_t *dap_requests, uint32_t request_size,
960 uint32_t *dap_results, uint32_t result_count)
961 {
962 uint8_t *request_pntr = &xds110.write_payload[XDS_OUT_LEN + 0];
963 uint8_t *result_pntr = &xds110.read_payload[XDS_IN_LEN + 0];
964
965 bool success;
966
967 if (NULL == dap_requests || NULL == dap_results)
968 return false;
969
970 xds110.write_payload[0] = OCD_DAP_REQUEST;
971
972 memcpy((void *)request_pntr, (void *)dap_requests, request_size);
973
974 success = xds_execute(XDS_OUT_LEN + request_size,
975 XDS_IN_LEN + (result_count * 4), DEFAULT_ATTEMPTS,
976 DEFAULT_TIMEOUT);
977
978 if (success && (result_count > 0))
979 memcpy((void *)dap_results, (void *)result_pntr, result_count * 4);
980
981 return success;
982 }
983
984 static bool ocd_scan_request(uint8_t *scan_requests, uint32_t request_size,
985 uint8_t *scan_results, uint32_t result_size)
986 {
987 uint8_t *request_pntr = &xds110.write_payload[XDS_OUT_LEN + 0];
988 uint8_t *result_pntr = &xds110.read_payload[XDS_IN_LEN + 0];
989
990 bool success;
991
992 if (NULL == scan_requests || NULL == scan_results)
993 return false;
994
995 xds110.write_payload[0] = OCD_SCAN_REQUEST;
996
997 memcpy((void *)request_pntr, (void *)scan_requests, request_size);
998
999 success = xds_execute(XDS_OUT_LEN + request_size,
1000 XDS_IN_LEN + result_size, DEFAULT_ATTEMPTS,
1001 DEFAULT_TIMEOUT);
1002
1003 if (success && (result_size > 0))
1004 memcpy((void *)scan_results, (void *)result_pntr, result_size);
1005
1006 return success;
1007 }
1008
1009 static bool ocd_pathmove(uint32_t num_states, uint8_t *path)
1010 {
1011 uint8_t *num_pntr = &xds110.write_payload[XDS_OUT_LEN + 0]; /* 32-bits */
1012 uint8_t *path_pntr = &xds110.write_payload[XDS_OUT_LEN + 4];
1013
1014 bool success;
1015
1016 if (NULL == path)
1017 return false;
1018
1019 xds110.write_payload[0] = OCD_PATHMOVE;
1020
1021 xds110_set_u32(num_pntr, num_states);
1022
1023 memcpy((void *)path_pntr, (void *)path, num_states);
1024
1025 success = xds_execute(XDS_OUT_LEN + 4 + num_states, XDS_IN_LEN,
1026 DEFAULT_ATTEMPTS, DEFAULT_TIMEOUT);
1027
1028 return success;
1029 }
1030
1031 /***************************************************************************
1032 * swd driver interface *
1033 * *
1034 * The following functions provide SWD support to OpenOCD. *
1035 ***************************************************************************/
1036
1037 static int xds110_swd_init(void)
1038 {
1039 xds110.is_swd_mode = true;
1040 return ERROR_OK;
1041 }
1042
1043 static int xds110_swd_switch_seq(enum swd_special_seq seq)
1044 {
1045 uint32_t idcode;
1046 bool success;
1047
1048 switch (seq) {
1049 case LINE_RESET:
1050 LOG_ERROR("Sequence SWD line reset (%d) not supported", seq);
1051 return ERROR_FAIL;
1052 case JTAG_TO_SWD:
1053 LOG_DEBUG("JTAG-to-SWD");
1054 xds110.is_swd_mode = false;
1055 xds110.is_cmapi_connected = false;
1056 xds110.is_cmapi_acquired = false;
1057 /* Run sequence to put target in SWD mode */
1058 success = swd_connect();
1059 /* Re-iniitialize CMAPI API for DAP access */
1060 if (success) {
1061 xds110.is_swd_mode = true;
1062 success = cmapi_connect(&idcode);
1063 if (success) {
1064 xds110.is_cmapi_connected = true;
1065 success = cmapi_acquire();
1066 }
1067 }
1068 break;
1069 case SWD_TO_JTAG:
1070 LOG_DEBUG("SWD-to-JTAG");
1071 xds110.is_swd_mode = false;
1072 xds110.is_cmapi_connected = false;
1073 xds110.is_cmapi_acquired = false;
1074 /* Run sequence to put target in JTAG mode */
1075 success = swd_disconnect();
1076 if (success) {
1077 /* Re-initialize JTAG interface */
1078 success = cjtag_connect(MODE_JTAG);
1079 }
1080 break;
1081 default:
1082 LOG_ERROR("Sequence %d not supported", seq);
1083 return ERROR_FAIL;
1084 }
1085
1086 if (success)
1087 return ERROR_OK;
1088 else
1089 return ERROR_FAIL;
1090 }
1091
1092 static bool xds110_legacy_read_reg(uint8_t cmd, uint32_t *value)
1093 {
1094 /* Make sure this is a read request */
1095 bool is_read_request = (0 != (SWD_CMD_RnW & cmd));
1096 /* Determine whether this is a DP or AP register access */
1097 uint32_t type = (0 != (SWD_CMD_APnDP & cmd)) ? DAP_AP : DAP_DP;
1098 /* Determine the AP number from cached SELECT value */
1099 uint32_t ap_num = (xds110.select & 0xff000000) >> 24;
1100 /* Extract register address from command */
1101 uint32_t address = ((cmd & SWD_CMD_A32) >> 1);
1102 /* Extract bank address from cached SELECT value */
1103 uint32_t bank = (xds110.select & 0x000000f0);
1104
1105 uint32_t reg_value = 0;
1106 uint32_t temp_value = 0;
1107
1108 bool success;
1109
1110 if (!is_read_request)
1111 return false;
1112
1113 if (DAP_AP == type) {
1114 /* Add bank address to register address for CMAPI call */
1115 address |= bank;
1116 }
1117
1118 if (DAP_DP == type && DAP_DP_RDBUFF == address && xds110.use_rdbuff) {
1119 /* If RDBUFF is cached and this is a DP RDBUFF read, use the cache */
1120 reg_value = xds110.rdbuff;
1121 success = true;
1122 } else if (DAP_AP == type && DAP_AP_DRW == address && xds110.use_rdbuff) {
1123 /* If RDBUFF is cached and this is an AP DRW read, use the cache, */
1124 /* but still call into the firmware to get the next read. */
1125 reg_value = xds110.rdbuff;
1126 success = cmapi_read_dap_reg(type, ap_num, address, &temp_value);
1127 } else {
1128 success = cmapi_read_dap_reg(type, ap_num, address, &temp_value);
1129 if (success)
1130 reg_value = temp_value;
1131 }
1132
1133 /* Mark that we have consumed or invalidated the RDBUFF cache */
1134 xds110.use_rdbuff = false;
1135
1136 /* Handle result of read attempt */
1137 if (!success)
1138 LOG_ERROR("XDS110: failed to read DAP register");
1139 else if (NULL != value)
1140 *value = reg_value;
1141
1142 if (success && DAP_AP == type) {
1143 /*
1144 * On a successful DAP AP read, we actually have the value from RDBUFF,
1145 * the firmware will have run the AP request and made the RDBUFF read
1146 */
1147 xds110.use_rdbuff = true;
1148 xds110.rdbuff = temp_value;
1149 }
1150
1151 return success;
1152 }
1153
1154 static bool xds110_legacy_write_reg(uint8_t cmd, uint32_t value)
1155 {
1156 /* Make sure this isn't a read request */
1157 bool is_read_request = (0 != (SWD_CMD_RnW & cmd));
1158 /* Determine whether this is a DP or AP register access */
1159 uint32_t type = (0 != (SWD_CMD_APnDP & cmd)) ? DAP_AP : DAP_DP;
1160 /* Determine the AP number from cached SELECT value */
1161 uint32_t ap_num = (xds110.select & 0xff000000) >> 24;
1162 /* Extract register address from command */
1163 uint32_t address = ((cmd & SWD_CMD_A32) >> 1);
1164 /* Extract bank address from cached SELECT value */
1165 uint32_t bank = (xds110.select & 0x000000f0);
1166
1167 bool success;
1168
1169 if (is_read_request)
1170 return false;
1171
1172 /* Invalidate the RDBUFF cache */
1173 xds110.use_rdbuff = false;
1174
1175 if (DAP_AP == type) {
1176 /* Add bank address to register address for CMAPI call */
1177 address |= bank;
1178 /* Any write to an AP register invalidates the firmware's cache */
1179 xds110.is_ap_dirty = true;
1180 } else if (DAP_DP_SELECT == address) {
1181 /* Any write to the SELECT register invalidates the firmware's cache */
1182 xds110.is_ap_dirty = true;
1183 }
1184
1185 success = cmapi_write_dap_reg(type, ap_num, address, &value);
1186
1187 if (!success) {
1188 LOG_ERROR("XDS110: failed to write DAP register");
1189 } else {
1190 /*
1191 * If the debugger wrote to SELECT, cache the value
1192 * to use to build the apNum and address values above
1193 */
1194 if ((DAP_DP == type) && (DAP_DP_SELECT == address))
1195 xds110.select = value;
1196 }
1197
1198 return success;
1199 }
1200
1201 static int xds110_swd_run_queue(void)
1202 {
1203 static uint32_t dap_results[MAX_RESULT_QUEUE];
1204 uint8_t cmd;
1205 uint32_t request;
1206 uint32_t result;
1207 uint32_t value;
1208 bool success = true;
1209
1210 if (0 == xds110.txn_request_size)
1211 return ERROR_OK;
1212
1213 /* Terminate request queue */
1214 xds110.txn_requests[xds110.txn_request_size++] = 0;
1215
1216 if (xds110.firmware >= OCD_FIRMWARE_VERSION) {
1217 /* XDS110 firmware has the API to directly handle the queue */
1218 success = ocd_dap_request(xds110.txn_requests,
1219 xds110.txn_request_size, dap_results, xds110.txn_result_count);
1220 } else {
1221 /* Legacy firmware needs to handle queue via discrete DAP calls */
1222 request = 0;
1223 result = 0;
1224 while (xds110.txn_requests[request] != 0) {
1225 cmd = xds110.txn_requests[request++];
1226 if (0 == (SWD_CMD_RnW & cmd)) {
1227 /* DAP register write command */
1228 value = (uint32_t)(xds110.txn_requests[request++]) << 0;
1229 value |= (uint32_t)(xds110.txn_requests[request++]) << 8;
1230 value |= (uint32_t)(xds110.txn_requests[request++]) << 16;
1231 value |= (uint32_t)(xds110.txn_requests[request++]) << 24;
1232 if (success)
1233 success = xds110_legacy_write_reg(cmd, value);
1234 } else {
1235 /* DAP register read command */
1236 value = 0;
1237 if (success)
1238 success = xds110_legacy_read_reg(cmd, &value);
1239 dap_results[result++] = value;
1240 }
1241 }
1242 }
1243
1244 /* Transfer results into caller's buffers */
1245 for (result = 0; result < xds110.txn_result_count; result++)
1246 if (0 != xds110.txn_dap_results[result])
1247 *xds110.txn_dap_results[result] = dap_results[result];
1248
1249 xds110.txn_request_size = 0;
1250 xds110.txn_result_size = 0;
1251 xds110.txn_result_count = 0;
1252
1253 return (success) ? ERROR_OK : ERROR_FAIL;
1254 }
1255
1256 static void xds110_swd_queue_cmd(uint8_t cmd, uint32_t *value)
1257 {
1258 /* Check if this is a read or write request */
1259 bool is_read_request = (0 != (SWD_CMD_RnW & cmd));
1260 /* Determine whether this is a DP or AP register access */
1261 uint32_t type = (0 != (SWD_CMD_APnDP & cmd)) ? DAP_AP : DAP_DP;
1262 /* Extract register address from command */
1263 uint32_t address = ((cmd & SWD_CMD_A32) >> 1);
1264 uint32_t request_size = (is_read_request) ? 1 : 5;
1265
1266 /* Check if new request would be too large to fit */
1267 if (((xds110.txn_request_size + request_size + 1) > MAX_DATA_BLOCK) ||
1268 ((xds110.txn_result_count + 1) > MAX_RESULT_QUEUE))
1269 xds110_swd_run_queue();
1270
1271 /* Set the START bit in cmd to ensure cmd is not zero */
1272 /* (a value of zero is used to terminate the buffer) */
1273 cmd |= SWD_CMD_START;
1274
1275 /* Add request to queue; queue is built marshalled for XDS110 call */
1276 if (is_read_request) {
1277 /* Queue read request, save pointer to pass back result */
1278 xds110.txn_requests[xds110.txn_request_size++] = cmd;
1279 xds110.txn_dap_results[xds110.txn_result_count++] = value;
1280 xds110.txn_result_size += 4;
1281 } else {
1282 /* Check for and prevent sticky overrun detection */
1283 if (DAP_DP == type && DAP_DP_CTRL == address &&
1284 (*value & CORUNDETECT)) {
1285 LOG_DEBUG("XDS110: refusing to enable sticky overrun detection");
1286 *value &= ~CORUNDETECT;
1287 }
1288 /* Queue write request, add value directly to queue buffer */
1289 xds110.txn_requests[xds110.txn_request_size++] = cmd;
1290 xds110.txn_requests[xds110.txn_request_size++] = (*value >> 0) & 0xff;
1291 xds110.txn_requests[xds110.txn_request_size++] = (*value >> 8) & 0xff;
1292 xds110.txn_requests[xds110.txn_request_size++] = (*value >> 16) & 0xff;
1293 xds110.txn_requests[xds110.txn_request_size++] = (*value >> 24) & 0xff;
1294 }
1295 }
1296
1297 static void xds110_swd_read_reg(uint8_t cmd, uint32_t *value,
1298 uint32_t ap_delay_clk)
1299 {
1300 xds110_swd_queue_cmd(cmd, value);
1301 }
1302 static void xds110_swd_write_reg(uint8_t cmd, uint32_t value,
1303 uint32_t ap_delay_clk)
1304 {
1305 xds110_swd_queue_cmd(cmd, &value);
1306 }
1307
1308 /***************************************************************************
1309 * jtag interface *
1310 * *
1311 * The following functions provide XDS110 interface to OpenOCD. *
1312 ***************************************************************************/
1313
1314 static void xds110_show_info(void)
1315 {
1316 uint32_t firmware = xds110.firmware;
1317
1318 LOG_INFO("XDS110: firmware version = %d.%d.%d.%d",
1319 (((firmware >> 28) & 0xf) * 10) + ((firmware >> 24) & 0xf),
1320 (((firmware >> 20) & 0xf) * 10) + ((firmware >> 16) & 0xf),
1321 (((firmware >> 12) & 0xf) * 10) + ((firmware >> 8) & 0xf),
1322 (((firmware >> 4) & 0xf) * 10) + ((firmware >> 0) & 0xf));
1323 LOG_INFO("XDS110: hardware version = 0x%04x", xds110.hardware);
1324 if (0 != xds110.serial[0])
1325 LOG_INFO("XDS110: serial number = %s)", xds110.serial);
1326 if (xds110.is_swd_mode) {
1327 LOG_INFO("XDS110: connected to target via SWD");
1328 LOG_INFO("XDS110: SWCLK set to %d kHz", xds110.speed);
1329 } else {
1330 LOG_INFO("XDS110: connected to target via JTAG");
1331 LOG_INFO("XDS110: TCK set to %d kHz", xds110.speed);
1332 }
1333
1334 /* Alert user that there's a better firmware to use */
1335 if (firmware < OCD_FIRMWARE_VERSION) {
1336 LOG_WARNING("XDS110: the firmware is not optimized for OpenOCD");
1337 LOG_WARNING(OCD_FIRMWARE_UPGRADE);
1338 }
1339 }
1340
1341 static int xds110_quit(void)
1342 {
1343 if (xds110.is_cmapi_acquired) {
1344 (void)cmapi_release();
1345 xds110.is_cmapi_acquired = false;
1346 }
1347 if (xds110.is_cmapi_connected) {
1348 (void)cmapi_disconnect();
1349 xds110.is_cmapi_connected = false;
1350 }
1351 if (xds110.is_connected) {
1352 if (xds110.is_swd_mode) {
1353 /* Switch out of SWD mode */
1354 (void)swd_disconnect();
1355 } else {
1356 /* Switch out of cJTAG mode */
1357 (void)cjtag_disconnect();
1358 }
1359 /* Tell firmware we're disconnecting */
1360 (void)xds_disconnect();
1361 xds110.is_connected = false;
1362 }
1363 /* Close down the USB connection to the XDS110 debug probe */
1364 usb_disconnect();
1365
1366 return ERROR_OK;
1367 }
1368
1369 static int xds110_init(void)
1370 {
1371 bool success;
1372
1373 /* Establish USB connection to the XDS110 debug probe */
1374 success = usb_connect();
1375
1376 if (success) {
1377 /* Send connect message to XDS110 firmware */
1378 success = xds_connect();
1379 if (success)
1380 xds110.is_connected = true;
1381 }
1382
1383 if (success) {
1384 uint32_t firmware;
1385 uint16_t hardware;
1386
1387 /* Retrieve version IDs from firmware */
1388 /* Version numbers are stored in BCD format */
1389 success = xds_version(&firmware, &hardware);
1390 if (success) {
1391 /* Save the firmware and hardware version */
1392 xds110.firmware = firmware;
1393 xds110.hardware = hardware;
1394 }
1395 }
1396
1397 if (success) {
1398 success = xds_set_trst(0);
1399 if (success)
1400 success = xds_cycle_tck(50);
1401 if (success)
1402 success = xds_set_trst(1);
1403 if (success)
1404 success = xds_cycle_tck(50);
1405 }
1406
1407 if (success) {
1408 if (xds110.is_swd_mode) {
1409 /* Switch to SWD if needed */
1410 success = swd_connect();
1411 } else {
1412 success = cjtag_connect(MODE_JTAG);
1413 }
1414 }
1415
1416 if (success && xds110.is_swd_mode) {
1417 uint32_t idcode;
1418
1419 /* Connect to CMAPI interface in XDS110 */
1420 success = cmapi_connect(&idcode);
1421
1422 /* Acquire exclusive access to CMAPI interface */
1423 if (success) {
1424 xds110.is_cmapi_connected = true;
1425 success = cmapi_acquire();
1426 if (success)
1427 xds110.is_cmapi_acquired = true;
1428 }
1429 }
1430
1431 if (!success)
1432 xds110_quit();
1433
1434 if (success)
1435 xds110_show_info();
1436
1437 return (success) ? ERROR_OK : ERROR_FAIL;
1438 }
1439
1440 static void xds110_legacy_scan(uint32_t shift_state, uint32_t total_bits,
1441 uint32_t end_state, uint8_t *data_out, uint8_t *data_in)
1442 {
1443 (void)xds_jtag_scan(shift_state, total_bits, end_state, data_out, data_in);
1444 }
1445
1446 static void xds110_legacy_runtest(uint32_t clocks, uint32_t end_state)
1447 {
1448 xds_goto_state(XDS_JTAG_STATE_IDLE);
1449 xds_cycle_tck(clocks);
1450 xds_goto_state(end_state);
1451 }
1452
1453 static void xds110_legacy_stableclocks(uint32_t clocks)
1454 {
1455 xds_cycle_tck(clocks);
1456 }
1457
1458 static void xds110_flush(void)
1459 {
1460 uint8_t command;
1461 uint32_t clocks;
1462 uint32_t shift_state;
1463 uint32_t end_state;
1464 uint32_t bits;
1465 uint32_t bytes;
1466 uint32_t request;
1467 uint32_t result;
1468 uint8_t *data_out;
1469 uint8_t data_in[MAX_DATA_BLOCK];
1470 uint8_t *data_pntr;
1471
1472 if (0 == xds110.txn_request_size)
1473 return;
1474
1475 /* Terminate request queue */
1476 xds110.txn_requests[xds110.txn_request_size++] = 0;
1477
1478 if (xds110.firmware >= OCD_FIRMWARE_VERSION) {
1479 /* Updated firmware has the API to directly handle the queue */
1480 (void)ocd_scan_request(xds110.txn_requests, xds110.txn_request_size,
1481 data_in, xds110.txn_result_size);
1482 } else {
1483 /* Legacy firmware needs to handle queue via discrete JTAG calls */
1484 request = 0;
1485 result = 0;
1486 while (xds110.txn_requests[request] != 0) {
1487 command = xds110.txn_requests[request++];
1488 switch (command) {
1489 case CMD_IR_SCAN:
1490 case CMD_DR_SCAN:
1491 if (command == CMD_IR_SCAN)
1492 shift_state = XDS_JTAG_STATE_SHIFT_IR;
1493 else
1494 shift_state = XDS_JTAG_STATE_SHIFT_DR;
1495 end_state = (uint32_t)(xds110.txn_requests[request++]);
1496 bits = (uint32_t)(xds110.txn_requests[request++]) << 0;
1497 bits |= (uint32_t)(xds110.txn_requests[request++]) << 8;
1498 data_out = &xds110.txn_requests[request];
1499 bytes = DIV_ROUND_UP(bits, 8);
1500 xds110_legacy_scan(shift_state, bits, end_state, data_out,
1501 &data_in[result]);
1502 result += bytes;
1503 request += bytes;
1504 break;
1505 case CMD_RUNTEST:
1506 clocks = (uint32_t)(xds110.txn_requests[request++]) << 0;
1507 clocks |= (uint32_t)(xds110.txn_requests[request++]) << 8;
1508 clocks |= (uint32_t)(xds110.txn_requests[request++]) << 16;
1509 clocks |= (uint32_t)(xds110.txn_requests[request++]) << 24;
1510 end_state = (uint32_t)xds110.txn_requests[request++];
1511 xds110_legacy_runtest(clocks, end_state);
1512 break;
1513 case CMD_STABLECLOCKS:
1514 clocks = (uint32_t)(xds110.txn_requests[request++]) << 0;
1515 clocks |= (uint32_t)(xds110.txn_requests[request++]) << 8;
1516 clocks |= (uint32_t)(xds110.txn_requests[request++]) << 16;
1517 clocks |= (uint32_t)(xds110.txn_requests[request++]) << 24;
1518 xds110_legacy_stableclocks(clocks);
1519 break;
1520 default:
1521 LOG_ERROR("BUG: unknown JTAG command type 0x%x encountered",
1522 command);
1523 exit(-1);
1524 break;
1525 }
1526 }
1527 }
1528
1529 /* Transfer results into caller's buffers from data_in buffer */
1530 bits = 0; /* Bit offset into current scan result */
1531 data_pntr = data_in;
1532 for (result = 0; result < xds110.txn_result_count; result++) {
1533 if (xds110.txn_scan_results[result].first) {
1534 if (bits != 0) {
1535 bytes = DIV_ROUND_UP(bits, 8);
1536 data_pntr += bytes;
1537 }
1538 bits = 0;
1539 }
1540 if (xds110.txn_scan_results[result].buffer != 0)
1541 bit_copy(xds110.txn_scan_results[result].buffer, 0, data_pntr,
1542 bits, xds110.txn_scan_results[result].num_bits);
1543 bits += xds110.txn_scan_results[result].num_bits;
1544 }
1545
1546 xds110.txn_request_size = 0;
1547 xds110.txn_result_size = 0;
1548 xds110.txn_result_count = 0;
1549 }
1550
1551 static void xds110_execute_reset(struct jtag_command *cmd)
1552 {
1553 char trst;
1554 char srst;
1555
1556 if (cmd->cmd.reset->trst != -1) {
1557 if (cmd->cmd.reset->trst == 0) {
1558 /* Deassert nTRST (active low) */
1559 trst = 1;
1560 } else {
1561 /* Assert nTRST (active low) */
1562 trst = 0;
1563 }
1564 (void)xds_set_trst(trst);
1565 }
1566
1567 if (cmd->cmd.reset->srst != -1) {
1568 if (cmd->cmd.reset->srst == 0) {
1569 /* Deassert nSRST (active low) */
1570 srst = 1;
1571 } else {
1572 /* Assert nSRST (active low) */
1573 srst = 0;
1574 }
1575 (void)xds_set_srst(srst);
1576 }
1577 }
1578
1579 static void xds110_execute_sleep(struct jtag_command *cmd)
1580 {
1581 jtag_sleep(cmd->cmd.sleep->us);
1582 return;
1583 }
1584
1585 static void xds110_execute_tlr_reset(struct jtag_command *cmd)
1586 {
1587 (void)xds_goto_state(XDS_JTAG_STATE_RESET);
1588
1589 return;
1590 }
1591
1592 static void xds110_execute_pathmove(struct jtag_command *cmd)
1593 {
1594 uint32_t i;
1595 uint32_t num_states;
1596 uint8_t *path;
1597
1598 num_states = (uint32_t)cmd->cmd.pathmove->num_states;
1599
1600 if (num_states == 0)
1601 return;
1602
1603 path = (uint8_t *)malloc(num_states * sizeof(uint8_t));
1604 if (path == 0) {
1605 LOG_ERROR("XDS110: unable to allocate memory");
1606 return;
1607 }
1608
1609 /* Convert requested path states into XDS API states */
1610 for (i = 0; i < num_states; i++)
1611 path[i] = (uint8_t)xds_jtag_state[cmd->cmd.pathmove->path[i]];
1612
1613 if (xds110.firmware >= OCD_FIRMWARE_VERSION) {
1614 /* Updated firmware fully supports pathmove */
1615 (void)ocd_pathmove(num_states, path);
1616 } else {
1617 /* Notify user that legacy firmware simply cannot handle pathmove */
1618 LOG_ERROR("XDS110: the firmware does not support pathmove command");
1619 LOG_ERROR(OCD_FIRMWARE_UPGRADE);
1620 /* If pathmove is required, then debug is not possible */
1621 exit(-1);
1622 }
1623
1624 free((void *)path);
1625
1626 return;
1627 }
1628
1629 static void xds110_queue_scan(struct jtag_command *cmd)
1630 {
1631 int i;
1632 uint32_t offset;
1633 uint32_t total_fields;
1634 uint32_t total_bits;
1635 uint32_t total_bytes;
1636 uint8_t end_state;
1637 uint8_t *buffer;
1638
1639 /* Calculate the total number of bits to scan */
1640 total_bits = 0;
1641 total_fields = 0;
1642 for (i = 0; i < cmd->cmd.scan->num_fields; i++) {
1643 total_fields++;
1644 total_bits += (uint32_t)cmd->cmd.scan->fields[i].num_bits;
1645 }
1646
1647 if (total_bits == 0)
1648 return;
1649
1650 total_bytes = DIV_ROUND_UP(total_bits, 8);
1651
1652 /* Check if new request would be too large to fit */
1653 if (((xds110.txn_request_size + 1 + total_bytes + sizeof(end_state) + 1)
1654 > MAX_DATA_BLOCK) || ((xds110.txn_result_count + total_fields) >
1655 MAX_RESULT_QUEUE))
1656 xds110_flush();
1657
1658 /* Check if this single request is too large to fit */
1659 if ((1 + total_bytes + sizeof(end_state) + 1) > MAX_DATA_BLOCK) {
1660 LOG_ERROR("BUG: JTAG scan request is too large to handle (%d bits)",
1661 total_bits);
1662 /* Failing to run this scan mucks up debug on this target */
1663 exit(-1);
1664 }
1665
1666 if (cmd->cmd.scan->ir_scan)
1667 xds110.txn_requests[xds110.txn_request_size++] = CMD_IR_SCAN;
1668 else
1669 xds110.txn_requests[xds110.txn_request_size++] = CMD_DR_SCAN;
1670
1671 end_state = (uint8_t)xds_jtag_state[cmd->cmd.scan->end_state];
1672 xds110.txn_requests[xds110.txn_request_size++] = end_state;
1673
1674 xds110.txn_requests[xds110.txn_request_size++] = (total_bits >> 0) & 0xff;
1675 xds110.txn_requests[xds110.txn_request_size++] = (total_bits >> 8) & 0xff;
1676
1677 /* Build request data by flattening fields into single buffer */
1678 /* also populate the results array to return the results when run */
1679 offset = 0;
1680 buffer = &xds110.txn_requests[xds110.txn_request_size];
1681 /* Clear data out buffer to default value of all zeros */
1682 memset((void *)buffer, 0x00, total_bytes);
1683 for (i = 0; i < cmd->cmd.scan->num_fields; i++) {
1684 if (cmd->cmd.scan->fields[i].out_value != 0) {
1685 /* Copy over data to scan out into request buffer */
1686 bit_copy(buffer, offset, cmd->cmd.scan->fields[i].out_value, 0,
1687 cmd->cmd.scan->fields[i].num_bits);
1688 }
1689 offset += cmd->cmd.scan->fields[i].num_bits;
1690 xds110.txn_scan_results[xds110.txn_result_count].first = (i == 0);
1691 xds110.txn_scan_results[xds110.txn_result_count].num_bits =
1692 cmd->cmd.scan->fields[i].num_bits;
1693 xds110.txn_scan_results[xds110.txn_result_count++].buffer =
1694 cmd->cmd.scan->fields[i].in_value;
1695 }
1696 xds110.txn_request_size += total_bytes;
1697 xds110.txn_result_size += total_bytes;
1698
1699 return;
1700 }
1701
1702 static void xds110_queue_runtest(struct jtag_command *cmd)
1703 {
1704 uint32_t clocks = (uint32_t)cmd->cmd.stableclocks->num_cycles;
1705 uint8_t end_state = (uint8_t)xds_jtag_state[cmd->cmd.runtest->end_state];
1706
1707 /* Check if new request would be too large to fit */
1708 if ((xds110.txn_request_size + 1 + sizeof(clocks) + sizeof(end_state) + 1)
1709 > MAX_DATA_BLOCK)
1710 xds110_flush();
1711
1712 /* Queue request and cycle count directly to queue buffer */
1713 xds110.txn_requests[xds110.txn_request_size++] = CMD_RUNTEST;
1714 xds110.txn_requests[xds110.txn_request_size++] = (clocks >> 0) & 0xff;
1715 xds110.txn_requests[xds110.txn_request_size++] = (clocks >> 8) & 0xff;
1716 xds110.txn_requests[xds110.txn_request_size++] = (clocks >> 16) & 0xff;
1717 xds110.txn_requests[xds110.txn_request_size++] = (clocks >> 24) & 0xff;
1718 xds110.txn_requests[xds110.txn_request_size++] = end_state;
1719
1720 return;
1721 }
1722
1723 static void xds110_queue_stableclocks(struct jtag_command *cmd)
1724 {
1725 uint32_t clocks = (uint32_t)cmd->cmd.stableclocks->num_cycles;
1726
1727 /* Check if new request would be too large to fit */
1728 if ((xds110.txn_request_size + 1 + sizeof(clocks) + 1) > MAX_DATA_BLOCK)
1729 xds110_flush();
1730
1731 /* Queue request and cycle count directly to queue buffer */
1732 xds110.txn_requests[xds110.txn_request_size++] = CMD_STABLECLOCKS;
1733 xds110.txn_requests[xds110.txn_request_size++] = (clocks >> 0) & 0xff;
1734 xds110.txn_requests[xds110.txn_request_size++] = (clocks >> 8) & 0xff;
1735 xds110.txn_requests[xds110.txn_request_size++] = (clocks >> 16) & 0xff;
1736 xds110.txn_requests[xds110.txn_request_size++] = (clocks >> 24) & 0xff;
1737
1738 return;
1739 }
1740
1741 static void xds110_execute_command(struct jtag_command *cmd)
1742 {
1743 switch (cmd->type) {
1744 case JTAG_RESET:
1745 xds110_flush();
1746 xds110_execute_reset(cmd);
1747 break;
1748 case JTAG_SLEEP:
1749 xds110_flush();
1750 xds110_execute_sleep(cmd);
1751 break;
1752 case JTAG_TLR_RESET:
1753 xds110_flush();
1754 xds110_execute_tlr_reset(cmd);
1755 break;
1756 case JTAG_PATHMOVE:
1757 xds110_flush();
1758 xds110_execute_pathmove(cmd);
1759 break;
1760 case JTAG_SCAN:
1761 xds110_queue_scan(cmd);
1762 break;
1763 case JTAG_RUNTEST:
1764 xds110_queue_runtest(cmd);
1765 break;
1766 case JTAG_STABLECLOCKS:
1767 xds110_queue_stableclocks(cmd);
1768 break;
1769 case JTAG_TMS:
1770 default:
1771 LOG_ERROR("BUG: unknown JTAG command type 0x%x encountered",
1772 cmd->type);
1773 exit(-1);
1774 }
1775 }
1776
1777 static int xds110_execute_queue(void)
1778 {
1779 struct jtag_command *cmd = jtag_command_queue;
1780
1781 while (cmd != NULL) {
1782 xds110_execute_command(cmd);
1783 cmd = cmd->next;
1784 }
1785
1786 xds110_flush();
1787
1788 return ERROR_OK;
1789 }
1790
1791 static int xds110_speed(int speed)
1792 {
1793 bool success;
1794
1795 if (speed == 0) {
1796 LOG_INFO("XDS110: RTCK not supported");
1797 return ERROR_JTAG_NOT_IMPLEMENTED;
1798 }
1799
1800 if (speed > XDS110_MAX_TCK_SPEED) {
1801 LOG_INFO("XDS110: reduce speed request: %dkHz to %dkHz maximum",
1802 speed, XDS110_MAX_TCK_SPEED);
1803 speed = XDS110_MAX_TCK_SPEED;
1804 }
1805
1806 if (speed < XDS110_MIN_TCK_SPEED) {
1807 LOG_INFO("XDS110: increase speed request: %dkHz to %dkHz minimum",
1808 speed, XDS110_MIN_TCK_SPEED);
1809 speed = XDS110_MIN_TCK_SPEED;
1810 }
1811
1812 /* The default is the maximum frequency the XDS110 can support */
1813 uint32_t freq_to_use = XDS110_MAX_TCK_SPEED * 1000; /* Hz */
1814 uint32_t delay_count = 0;
1815
1816 if (XDS110_MAX_TCK_SPEED != speed) {
1817 freq_to_use = speed * 1000; /* Hz */
1818
1819 /* Calculate the delay count value */
1820 double one_giga = 1000000000;
1821 /* Get the pulse duration for the maximum frequency supported in ns */
1822 double max_freq_pulse_duration = one_giga /
1823 (XDS110_MAX_TCK_SPEED * 1000);
1824
1825 /* Convert frequency to pulse duration */
1826 double freq_to_pulse_width_in_ns = one_giga / freq_to_use;
1827
1828 /*
1829 * Start with the pulse duration for the maximum frequency. Keep
1830 * decrementing the time added by each count value till the requested
1831 * frequency pulse is less than the calculated value.
1832 */
1833 double current_value = max_freq_pulse_duration;
1834
1835 while (current_value < freq_to_pulse_width_in_ns) {
1836 current_value += XDS110_TCK_PULSE_INCREMENT;
1837 ++delay_count;
1838 }
1839
1840 /*
1841 * Determine which delay count yields the best match.
1842 * The one obtained above or one less.
1843 */
1844 if (delay_count) {
1845 double diff_freq_1 = freq_to_use -
1846 (one_giga / (max_freq_pulse_duration +
1847 (XDS110_TCK_PULSE_INCREMENT * delay_count)));
1848 double diff_freq_2 = (one_giga / (max_freq_pulse_duration +
1849 (XDS110_TCK_PULSE_INCREMENT * (delay_count - 1)))) -
1850 freq_to_use;
1851
1852 /* One less count value yields a better match */
1853 if (diff_freq_1 > diff_freq_2)
1854 --delay_count;
1855 }
1856 }
1857
1858 /* Send the delay count to the XDS110 firmware */
1859 success = xds_set_tck_delay(delay_count);
1860
1861 if (success) {
1862 xds110.delay_count = delay_count;
1863 xds110.speed = speed;
1864 }
1865
1866 return (success) ? ERROR_OK : ERROR_FAIL;
1867 }
1868
1869 static int xds110_speed_div(int speed, int *khz)
1870 {
1871 *khz = speed;
1872 return ERROR_OK;
1873 }
1874
1875 static int xds110_khz(int khz, int *jtag_speed)
1876 {
1877 *jtag_speed = khz;
1878 return ERROR_OK;
1879 }
1880
1881 static int_least32_t xds110_swd_frequency(int_least32_t hz)
1882 {
1883 if (hz > 0)
1884 xds110_speed(hz / 1000);
1885 return hz;
1886 }
1887
1888 COMMAND_HANDLER(xds110_handle_info_command)
1889 {
1890 xds110_show_info();
1891 return ERROR_OK;
1892 }
1893
1894 COMMAND_HANDLER(xds110_handle_serial_command)
1895 {
1896 wchar_t serial[XDS110_SERIAL_LEN + 1];
1897
1898 xds110.serial[0] = 0;
1899
1900 if (CMD_ARGC == 1) {
1901 size_t len = mbstowcs(0, CMD_ARGV[0], 0);
1902 if (len > XDS110_SERIAL_LEN) {
1903 LOG_ERROR("XDS110: serial number is limited to %d characters",
1904 XDS110_SERIAL_LEN);
1905 return ERROR_FAIL;
1906 }
1907 if ((size_t)-1 == mbstowcs(serial, CMD_ARGV[0], len + 1)) {
1908 LOG_ERROR("XDS110: unable to convert serial number");
1909 return ERROR_FAIL;
1910 }
1911
1912 for (uint32_t i = 0; i < len; i++)
1913 xds110.serial[i] = (char)serial[i];
1914
1915 xds110.serial[len] = 0;
1916 } else {
1917 LOG_ERROR("XDS110: expected exactly one argument to xds110_serial "
1918 "<serial-number>");
1919 return ERROR_FAIL;
1920 }
1921
1922 return ERROR_OK;
1923 }
1924
1925 static const struct command_registration xds110_subcommand_handlers[] = {
1926 {
1927 .name = "info",
1928 .handler = &xds110_handle_info_command,
1929 .mode = COMMAND_EXEC,
1930 .usage = "",
1931 .help = "show XDS110 info",
1932 },
1933 COMMAND_REGISTRATION_DONE
1934 };
1935
1936 static const struct command_registration xds110_command_handlers[] = {
1937 {
1938 .name = "xds110",
1939 .mode = COMMAND_ANY,
1940 .help = "perform XDS110 management",
1941 .usage = "<cmd>",
1942 .chain = xds110_subcommand_handlers,
1943 },
1944 {
1945 .name = "xds110_serial",
1946 .handler = &xds110_handle_serial_command,
1947 .mode = COMMAND_CONFIG,
1948 .help = "set the XDS110 probe serial number",
1949 .usage = "serial_string",
1950 },
1951 COMMAND_REGISTRATION_DONE
1952 };
1953
1954 static const struct swd_driver xds110_swd_driver = {
1955 .init = xds110_swd_init,
1956 .frequency = xds110_swd_frequency,
1957 .switch_seq = xds110_swd_switch_seq,
1958 .read_reg = xds110_swd_read_reg,
1959 .write_reg = xds110_swd_write_reg,
1960 .run = xds110_swd_run_queue,
1961 };
1962
1963 static const char * const xds110_transport[] = { "swd", "jtag", NULL };
1964
1965 struct jtag_interface xds110_interface = {
1966 .name = "xds110",
1967 .commands = xds110_command_handlers,
1968 .swd = &xds110_swd_driver,
1969 .transports = xds110_transport,
1970
1971 .execute_queue = xds110_execute_queue,
1972 .speed = xds110_speed,
1973 .speed_div = xds110_speed_div,
1974 .khz = xds110_khz,
1975 .init = xds110_init,
1976 .quit = xds110_quit,
1977 };
Official OpenOCD Mirror