+// SPDX-License-Identifier: GPL-2.0-or-later
+
/***************************************************************************
* Copyright (C) 2017 by Texas Instruments, Inc. *
- * *
- * This program is free software; you can redistribute it and/or modify *
- * it under the terms of the GNU General Public License as published by *
- * the Free Software Foundation; either version 2 of the License, or *
- * (at your option) any later version. *
- * *
- * This program is distributed in the hope that it will be useful, *
- * but WITHOUT ANY WARRANTY; without even the implied warranty of *
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
- * GNU General Public License for more details. *
- * *
- * You should have received a copy of the GNU General Public License *
- * along with this program. If not, see <http://www.gnu.org/licenses/>. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#endif
#include <transport/transport.h>
+#include <jtag/adapter.h>
#include <jtag/swd.h>
#include <jtag/interface.h>
#include <jtag/commands.h>
#include <jtag/tcl.h>
#include <libusb.h>
-/* XDS110 USB serial number length */
-#define XDS110_SERIAL_LEN 8
-
/* XDS110 stand-alone probe voltage supply limits */
#define XDS110_MIN_VOLTAGE 1800
#define XDS110_MAX_VOLTAGE 3600
#define CMD_STABLECLOCKS 4
/* Array to convert from OpenOCD tap_state_t to XDS JTAG state */
-const uint32_t xds_jtag_state[] = {
+static const uint32_t xds_jtag_state[] = {
XDS_JTAG_STATE_EXIT2_DR, /* TAP_DREXIT2 = 0x0 */
XDS_JTAG_STATE_EXIT1_DR, /* TAP_DREXIT1 = 0x1 */
XDS_JTAG_STATE_SHIFT_DR, /* TAP_DRSHIFT = 0x2 */
struct xds110_info {
/* USB connection handles and data buffers */
- libusb_context *ctx;
- libusb_device_handle *dev;
+ struct libusb_context *ctx;
+ struct libusb_device_handle *dev;
unsigned char read_payload[USB_PAYLOAD_SIZE];
unsigned char write_packet[3];
unsigned char write_payload[USB_PAYLOAD_SIZE];
/* TCK speed and delay count*/
uint32_t speed;
uint32_t delay_count;
- /* XDS110 serial number */
- char serial[XDS110_SERIAL_LEN + 1];
/* XDS110 voltage supply setting */
uint32_t voltage;
/* XDS110 firmware and hardware version */
.is_ap_dirty = false,
.speed = XDS110_DEFAULT_TCK_SPEED,
.delay_count = 0,
- .serial = {0},
.voltage = 0,
.firmware = 0,
.hardware = 0,
static bool usb_connect(void)
{
- libusb_context *ctx = NULL;
- libusb_device **list = NULL;
- libusb_device_handle *dev = NULL;
+ struct libusb_context *ctx = NULL;
+ struct libusb_device **list = NULL;
+ struct libusb_device_handle *dev = NULL;
struct libusb_device_descriptor desc;
/* Initialize libusb context */
result = libusb_init(&ctx);
- if (0 == result) {
+ if (result == 0) {
/* Get list of USB devices attached to system */
count = libusb_get_device_list(ctx, &list);
if (count <= 0) {
}
}
- if (0 == result) {
+ if (result == 0) {
/* Scan through list of devices for any XDS110s */
for (i = 0; i < count; i++) {
/* Check for device vid/pid match */
libusb_get_device_descriptor(list[i], &desc);
match = false;
- for (device = 0; device < sizeof(vids)/sizeof(vids[0]); device++) {
+ for (device = 0; device < ARRAY_SIZE(vids); device++) {
if (desc.idVendor == vids[device] &&
desc.idProduct == pids[device]) {
match = true;
}
if (match) {
result = libusb_open(list[i], &dev);
- if (0 == result) {
+ if (result == 0) {
const int max_data = 256;
unsigned char data[max_data + 1];
*data = '\0';
/* May be the requested device if serial number matches */
- if (0 == xds110.serial[0]) {
+ if (!adapter_get_required_serial()) {
/* No serial number given; match first XDS110 found */
found = true;
break;
/* Get the device's serial number string */
result = libusb_get_string_descriptor_ascii(dev,
desc.iSerialNumber, data, max_data);
- if (0 < result &&
- 0 == strcmp((char *)data, (char *)xds110.serial)) {
+ if (result > 0 &&
+ strcmp((char *)data, adapter_get_required_serial()) == 0) {
found = true;
break;
}
* 2) didn't find the XDS110, and no devices are currently open
*/
- if (NULL != list) {
+ if (list) {
/* Free the device list, we're done with it */
libusb_free_device_list(list, 1);
}
}
/* On an error, clean up what we can */
- if (0 != result) {
- if (NULL != dev) {
+ if (result != 0) {
+ if (dev) {
/* Release the debug and data interface on the XDS110 */
(void)libusb_release_interface(dev, xds110.interface);
libusb_close(dev);
}
- if (NULL != ctx)
+ if (ctx)
libusb_exit(ctx);
xds110.ctx = NULL;
xds110.dev = NULL;
}
/* Log the results */
- if (0 == result)
+ if (result == 0)
LOG_INFO("XDS110: connected");
else
LOG_ERROR("XDS110: failed to connect");
- return (0 == result) ? true : false;
+ return (result == 0) ? true : false;
}
static void usb_disconnect(void)
{
- if (NULL != xds110.dev) {
+ if (xds110.dev) {
/* Release the debug and data interface on the XDS110 */
(void)libusb_release_interface(xds110.dev, xds110.interface);
libusb_close(xds110.dev);
xds110.dev = NULL;
}
- if (NULL != xds110.ctx) {
+ if (xds110.ctx) {
libusb_exit(xds110.ctx);
xds110.ctx = NULL;
}
{
int result;
- if (NULL == xds110.dev || NULL == buffer || NULL == bytes_read)
+ if (!xds110.dev || !buffer || !bytes_read)
return false;
/* Force a non-zero timeout to prevent blocking */
- if (0 == timeout)
+ if (timeout == 0)
timeout = DEFAULT_TIMEOUT;
result = libusb_bulk_transfer(xds110.dev, xds110.endpoint_in, buffer, size,
bytes_read, timeout);
- return (0 == result) ? true : false;
+ return (result == 0) ? true : false;
}
static bool usb_write(unsigned char *buffer, int size, int *written)
int result = LIBUSB_SUCCESS;
int retries = 0;
- if (NULL == xds110.dev || NULL == buffer)
+ if (!xds110.dev || !buffer)
return false;
result = libusb_bulk_transfer(xds110.dev, xds110.endpoint_out, buffer,
size, &bytes_written, 0);
- while (LIBUSB_ERROR_PIPE == result && retries < 3) {
+ while (result == LIBUSB_ERROR_PIPE && retries < 3) {
/* Try clearing the pipe stall and retry transfer */
libusb_clear_halt(xds110.dev, xds110.endpoint_out);
result = libusb_bulk_transfer(xds110.dev, xds110.endpoint_out, buffer,
retries++;
}
- if (NULL != written)
+ if (written)
*written = bytes_written;
- return (0 == result && size == bytes_written) ? true : false;
+ return (result == 0 && size == bytes_written) ? true : false;
}
static bool usb_get_response(uint32_t *total_bytes_read, uint32_t timeout)
/* Abort now if we didn't receive a valid response */
if (!success) {
- if (NULL != total_bytes_read)
+ if (total_bytes_read)
*total_bytes_read = 0;
return false;
}
if (!success)
count = 0;
- if (NULL != total_bytes_read)
+ if (total_bytes_read)
*total_bytes_read = count;
return success;
int error = 0;
uint32_t bytes_read = 0;
- if (NULL == xds110.dev)
+ if (!xds110.dev)
return false;
while (!done && attempts > 0) {
if (bytes_read != in_length) {
/* Unexpected amount of data returned */
success = false;
- LOG_DEBUG("XDS110: command 0x%02x return %d bytes, expected %d",
+ LOG_DEBUG("XDS110: command 0x%02x return %" PRIu32 " bytes, expected %" PRIu32,
xds110.write_payload[0], bytes_read, in_length);
} else {
/* Extract error code from return packet */
error = (int)xds110_get_u32(&xds110.read_payload[0]);
done = true;
- if (SC_ERR_NONE != error)
+ if (error != SC_ERR_NONE)
LOG_DEBUG("XDS110: command 0x%02x returned error %d",
xds110.write_payload[0], error);
}
if (!success)
error = SC_ERR_XDS110_FAIL;
- if (0 != error)
+ if (error != 0)
success = false;
return success;
DEFAULT_TIMEOUT);
if (success) {
- if (NULL != firmware_id)
+ if (firmware_id)
*firmware_id = xds110_get_u32(fw_id_pntr);
- if (NULL != hardware_id)
+ if (hardware_id)
*hardware_id = xds110_get_u16(hw_id_pntr);
}
DEFAULT_TIMEOUT);
if (success) {
- if (NULL != idcode)
+ if (idcode)
*idcode = xds110_get_u32(idcode_pntr);
}
DEFAULT_TIMEOUT);
if (success) {
- if (NULL != value)
+ if (value)
*value = xds110_get_u32(value_pntr);
}
bool success;
- if (NULL == value)
+ if (!value)
return false;
xds110.write_payload[0] = CMAPI_REG_WRITE;
xds110.write_payload[0] = XDS_SET_SUPPLY;
xds110_set_u32(volts_pntr, voltage);
- *source_pntr = (uint8_t)(0 != voltage ? 1 : 0);
+ *source_pntr = (uint8_t)(voltage != 0 ? 1 : 0);
success = xds_execute(XDS_OUT_LEN + 5, XDS_IN_LEN, DEFAULT_ATTEMPTS,
DEFAULT_TIMEOUT);
bool success;
- if (NULL == dap_requests || NULL == dap_results)
+ if (!dap_requests || !dap_results)
return false;
xds110.write_payload[0] = OCD_DAP_REQUEST;
bool success;
- if (NULL == scan_requests || NULL == scan_results)
+ if (!scan_requests || !scan_results)
return false;
xds110.write_payload[0] = OCD_SCAN_REQUEST;
bool success;
- if (NULL == path)
+ if (!path)
return false;
xds110.write_payload[0] = OCD_PATHMOVE;
xds110.is_cmapi_acquired = false;
/* Run sequence to put target in SWD mode */
success = swd_connect();
- /* Re-iniitialize CMAPI API for DAP access */
+ /* Re-initialize CMAPI API for DAP access */
if (success) {
xds110.is_swd_mode = true;
success = cmapi_connect(&idcode);
static bool xds110_legacy_read_reg(uint8_t cmd, uint32_t *value)
{
/* Make sure this is a read request */
- bool is_read_request = (0 != (SWD_CMD_RnW & cmd));
+ bool is_read_request = (0 != (SWD_CMD_RNW & cmd));
/* Determine whether this is a DP or AP register access */
- uint32_t type = (0 != (SWD_CMD_APnDP & cmd)) ? DAP_AP : DAP_DP;
+ uint32_t type = (0 != (SWD_CMD_APNDP & cmd)) ? DAP_AP : DAP_DP;
/* Determine the AP number from cached SELECT value */
uint32_t ap_num = (xds110.select & 0xff000000) >> 24;
/* Extract register address from command */
if (!is_read_request)
return false;
- if (DAP_AP == type) {
+ if (type == DAP_AP) {
/* Add bank address to register address for CMAPI call */
address |= bank;
}
/* Handle result of read attempt */
if (!success)
LOG_ERROR("XDS110: failed to read DAP register");
- else if (NULL != value)
+ else if (value)
*value = reg_value;
if (success && DAP_AP == type) {
static bool xds110_legacy_write_reg(uint8_t cmd, uint32_t value)
{
/* Make sure this isn't a read request */
- bool is_read_request = (0 != (SWD_CMD_RnW & cmd));
+ bool is_read_request = (0 != (SWD_CMD_RNW & cmd));
/* Determine whether this is a DP or AP register access */
- uint32_t type = (0 != (SWD_CMD_APnDP & cmd)) ? DAP_AP : DAP_DP;
+ uint32_t type = (0 != (SWD_CMD_APNDP & cmd)) ? DAP_AP : DAP_DP;
/* Determine the AP number from cached SELECT value */
uint32_t ap_num = (xds110.select & 0xff000000) >> 24;
/* Extract register address from command */
/* Invalidate the RDBUFF cache */
xds110.use_rdbuff = false;
- if (DAP_AP == type) {
+ if (type == DAP_AP) {
/* Add bank address to register address for CMAPI call */
address |= bank;
/* Any write to an AP register invalidates the firmware's cache */
xds110.is_ap_dirty = true;
- } else if (DAP_DP_SELECT == address) {
+ } else if (address == DAP_DP_SELECT) {
/* Any write to the SELECT register invalidates the firmware's cache */
xds110.is_ap_dirty = true;
}
* If the debugger wrote to SELECT, cache the value
* to use to build the apNum and address values above
*/
- if ((DAP_DP == type) && (DAP_DP_SELECT == address))
+ if ((type == DAP_DP) && (address == DAP_DP_SELECT))
xds110.select = value;
}
uint32_t value;
bool success = true;
- if (0 == xds110.txn_request_size)
+ if (xds110.txn_request_size == 0)
return ERROR_OK;
/* Terminate request queue */
result = 0;
while (xds110.txn_requests[request] != 0) {
cmd = xds110.txn_requests[request++];
- if (0 == (SWD_CMD_RnW & cmd)) {
+ if (0 == (SWD_CMD_RNW & cmd)) {
/* DAP register write command */
value = (uint32_t)(xds110.txn_requests[request++]) << 0;
value |= (uint32_t)(xds110.txn_requests[request++]) << 8;
/* Transfer results into caller's buffers */
for (result = 0; result < xds110.txn_result_count; result++)
- if (0 != xds110.txn_dap_results[result])
+ if (xds110.txn_dap_results[result] != 0)
*xds110.txn_dap_results[result] = dap_results[result];
xds110.txn_request_size = 0;
static void xds110_swd_queue_cmd(uint8_t cmd, uint32_t *value)
{
/* Check if this is a read or write request */
- bool is_read_request = (0 != (SWD_CMD_RnW & cmd));
+ bool is_read_request = (0 != (SWD_CMD_RNW & cmd));
/* Determine whether this is a DP or AP register access */
- uint32_t type = (0 != (SWD_CMD_APnDP & cmd)) ? DAP_AP : DAP_DP;
+ uint32_t type = (0 != (SWD_CMD_APNDP & cmd)) ? DAP_AP : DAP_DP;
/* Extract register address from command */
uint32_t address = ((cmd & SWD_CMD_A32) >> 1);
uint32_t request_size = (is_read_request) ? 1 : 5;
uint32_t firmware = xds110.firmware;
LOG_INFO("XDS110: vid/pid = %04x/%04x", xds110.vid, xds110.pid);
- LOG_INFO("XDS110: firmware version = %d.%d.%d.%d",
+ LOG_INFO("XDS110: firmware version = %" PRIu32 ".%" PRIu32 ".%" PRIu32 ".%" PRIu32,
(((firmware >> 28) & 0xf) * 10) + ((firmware >> 24) & 0xf),
(((firmware >> 20) & 0xf) * 10) + ((firmware >> 16) & 0xf),
(((firmware >> 12) & 0xf) * 10) + ((firmware >> 8) & 0xf),
(((firmware >> 4) & 0xf) * 10) + ((firmware >> 0) & 0xf));
LOG_INFO("XDS110: hardware version = 0x%04x", xds110.hardware);
- if (0 != xds110.serial[0])
- LOG_INFO("XDS110: serial number = %s", xds110.serial);
+ if (adapter_get_required_serial())
+ LOG_INFO("XDS110: serial number = %s", adapter_get_required_serial());
if (xds110.is_swd_mode) {
LOG_INFO("XDS110: connected to target via SWD");
- LOG_INFO("XDS110: SWCLK set to %d kHz", xds110.speed);
+ LOG_INFO("XDS110: SWCLK set to %" PRIu32 " kHz", xds110.speed);
} else {
LOG_INFO("XDS110: connected to target via JTAG");
- LOG_INFO("XDS110: TCK set to %d kHz", xds110.speed);
+ LOG_INFO("XDS110: TCK set to %" PRIu32 " kHz", xds110.speed);
}
/* Alert user that there's a better firmware to use */
if (success) {
/* Set supply voltage for stand-alone probes */
- if (XDS110_STAND_ALONE_ID == xds110.hardware) {
+ if (xds110.hardware == XDS110_STAND_ALONE_ID) {
success = xds_set_supply(xds110.voltage);
/* Allow time for target device to power up */
/* (CC32xx takes up to 1300 ms before debug is enabled) */
alive_sleep(1500);
- } else if (0 != xds110.voltage) {
+ } else if (xds110.voltage != 0) {
/* Voltage supply not a feature of embedded probes */
LOG_WARNING(
"XDS110: ignoring supply voltage, not supported on this probe");
uint8_t data_in[MAX_DATA_BLOCK];
uint8_t *data_pntr;
- if (0 == xds110.txn_request_size)
+ if (xds110.txn_request_size == 0)
return;
/* Terminate request queue */
/* Check if this single request is too large to fit */
if ((1 + total_bytes + sizeof(end_state) + 1) > MAX_DATA_BLOCK) {
- LOG_ERROR("BUG: JTAG scan request is too large to handle (%d bits)",
+ LOG_ERROR("BUG: JTAG scan request is too large to handle (%" PRIu32 " bits)",
total_bits);
/* Failing to run this scan mucks up debug on this target */
exit(-1);
{
struct jtag_command *cmd = jtag_command_queue;
- while (cmd != NULL) {
+ while (cmd) {
xds110_execute_command(cmd);
cmd = cmd->next;
}
return ERROR_OK;
}
-COMMAND_HANDLER(xds110_handle_serial_command)
-{
- wchar_t serial[XDS110_SERIAL_LEN + 1];
-
- xds110.serial[0] = 0;
-
- if (CMD_ARGC == 1) {
- size_t len = mbstowcs(0, CMD_ARGV[0], 0);
- if (len > XDS110_SERIAL_LEN) {
- LOG_ERROR("XDS110: serial number is limited to %d characters",
- XDS110_SERIAL_LEN);
- return ERROR_FAIL;
- }
- if ((size_t)-1 == mbstowcs(serial, CMD_ARGV[0], len + 1)) {
- LOG_ERROR("XDS110: unable to convert serial number");
- return ERROR_FAIL;
- }
-
- for (uint32_t i = 0; i < len; i++)
- xds110.serial[i] = (char)serial[i];
-
- xds110.serial[len] = 0;
- } else
- return ERROR_COMMAND_SYNTAX_ERROR;
-
- return ERROR_OK;
-}
-
COMMAND_HANDLER(xds110_handle_supply_voltage_command)
{
uint32_t voltage = 0;
if (CMD_ARGC == 1) {
- COMMAND_PARSE_NUMBER(uint, CMD_ARGV[0], voltage);
+ COMMAND_PARSE_NUMBER(u32, CMD_ARGV[0], voltage);
if (voltage == 0 || (voltage >= XDS110_MIN_VOLTAGE && voltage
<= XDS110_MAX_VOLTAGE)) {
/* Requested voltage is in range */
.help = "show XDS110 info",
.usage = "",
},
- {
- .name = "serial",
- .handler = &xds110_handle_serial_command,
- .mode = COMMAND_CONFIG,
- .help = "set the XDS110 probe serial number",
- .usage = "serial_string",
- },
{
.name = "supply",
.handler = &xds110_handle_supply_voltage_command,
projects / fw / openocd / blobdiff