git.gag.com Git - fw/openocd/blob - 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 };