/***************************************************************************
+ * Copyright (C) 2021 by Adrian Negreanu *
+ * groleo@gmail.com *
+ * *
* Copyright (C) 2018 by Mickaël Thomas *
* mickael9@gmail.com *
* *
#include <jtag/interface.h>
#include <jtag/commands.h>
#include <jtag/tcl.h>
+#include <target/cortex_m.h>
#include "cmsis_dap.h"
#define INFO_ID_CAPS 0xf0 /* byte */
#define INFO_ID_PKT_CNT 0xfe /* byte */
#define INFO_ID_PKT_SZ 0xff /* short */
+#define INFO_ID_SWO_BUF_SZ 0xfd /* word */
-#define INFO_CAPS_SWD 0x01
-#define INFO_CAPS_JTAG 0x02
+#define INFO_CAPS_SWD BIT(0)
+#define INFO_CAPS_JTAG BIT(1)
+#define INFO_CAPS_SWO_UART BIT(2)
+#define INFO_CAPS_SWO_MANCHESTER BIT(3)
/* CMD_LED */
#define LED_ID_CONNECT 0x00
#define DAP_OK 0
#define DAP_ERROR 0xFF
+/* CMSIS-DAP SWO Commands */
+#define CMD_DAP_SWO_TRANSPORT 0x17
+#define CMD_DAP_SWO_MODE 0x18
+#define CMD_DAP_SWO_BAUDRATE 0x19
+#define CMD_DAP_SWO_CONTROL 0x1A
+#define CMD_DAP_SWO_STATUS 0x1B
+#define CMD_DAP_SWO_DATA 0x1C
+#define CMD_DAP_SWO_EX_STATUS 0x1E
+
+/* SWO transport mode for reading trace data */
+#define DAP_SWO_TRANSPORT_NONE 0
+#define DAP_SWO_TRANSPORT_DATA 1
+#define DAP_SWO_TRANSPORT_WINUSB 2
+
+/* SWO trace capture mode */
+#define DAP_SWO_MODE_OFF 0
+#define DAP_SWO_MODE_UART 1
+#define DAP_SWO_MODE_MANCHESTER 2
+
+/* SWO trace data capture */
+#define DAP_SWO_CONTROL_STOP 0
+#define DAP_SWO_CONTROL_START 1
+
+/* SWO trace status */
+#define DAP_SWO_STATUS_CAPTURE_INACTIVE 0
+#define DAP_SWO_STATUS_CAPTURE_ACTIVE 1
+#define DAP_SWO_STATUS_CAPTURE_MASK BIT(0)
+#define DAP_SWO_STATUS_STREAM_ERROR_MASK BIT(6)
+#define DAP_SWO_STATUS_BUFFER_OVERRUN_MASK BIT(7)
+
/* CMSIS-DAP Vendor Commands
* None as yet... */
static const char * const info_caps_str[] = {
"SWD Supported",
- "JTAG Supported"
+ "JTAG Supported",
+ "SWO-UART Supported",
+ "SWO-MANCHESTER Supported"
};
struct pending_transfer_result {
return ERROR_OK;
}
-static int cmsis_dap_cmd_DAP_SWJ_Pins(uint8_t pins, uint8_t mask, uint32_t delay, uint8_t *input)
+static int cmsis_dap_cmd_dap_swj_pins(uint8_t pins, uint8_t mask, uint32_t delay, uint8_t *input)
{
- int retval;
uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_SWJ_PINS;
command[2] = mask;
h_u32_to_le(&command[3], delay);
- retval = cmsis_dap_xfer(cmsis_dap_handle, 7);
-
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 7);
if (retval != ERROR_OK) {
LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_PINS failed.");
return ERROR_JTAG_DEVICE_ERROR;
return ERROR_OK;
}
-static int cmsis_dap_cmd_DAP_SWJ_Clock(uint32_t swj_clock)
+static int cmsis_dap_cmd_dap_swj_clock(uint32_t swj_clock)
{
- int retval;
uint8_t *command = cmsis_dap_handle->command;
/* set clock in Hz */
command[0] = CMD_DAP_SWJ_CLOCK;
h_u32_to_le(&command[1], swj_clock);
- retval = cmsis_dap_xfer(cmsis_dap_handle, 5);
-
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 5);
if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_CLOCK failed.");
return ERROR_JTAG_DEVICE_ERROR;
}
/* clock a sequence of bits out on TMS, to change JTAG states */
-static int cmsis_dap_cmd_DAP_SWJ_Sequence(uint8_t s_len, const uint8_t *sequence)
+static int cmsis_dap_cmd_dap_swj_sequence(uint8_t s_len, const uint8_t *sequence)
{
- int retval;
uint8_t *command = cmsis_dap_handle->command;
#ifdef CMSIS_DAP_JTAG_DEBUG
command[1] = s_len;
bit_copy(&command[2], 0, sequence, 0, s_len);
- retval = cmsis_dap_xfer(cmsis_dap_handle, 2 + DIV_ROUND_UP(s_len, 8));
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 2 + DIV_ROUND_UP(s_len, 8));
if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK)
return ERROR_FAIL;
return ERROR_OK;
}
-static int cmsis_dap_cmd_DAP_Info(uint8_t info, uint8_t **data)
+static int cmsis_dap_cmd_dap_info(uint8_t info, uint8_t **data)
{
- int retval;
uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_INFO;
command[1] = info;
- retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
-
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
if (retval != ERROR_OK) {
LOG_ERROR("CMSIS-DAP command CMD_INFO failed.");
return ERROR_JTAG_DEVICE_ERROR;
return ERROR_OK;
}
-static int cmsis_dap_cmd_DAP_LED(uint8_t led, uint8_t state)
+static int cmsis_dap_cmd_dap_led(uint8_t led, uint8_t state)
{
- int retval;
uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_LED;
command[1] = led;
command[2] = state;
- retval = cmsis_dap_xfer(cmsis_dap_handle, 3);
-
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 3);
if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
LOG_ERROR("CMSIS-DAP command CMD_LED failed.");
return ERROR_JTAG_DEVICE_ERROR;
return ERROR_OK;
}
-static int cmsis_dap_cmd_DAP_Connect(uint8_t mode)
+static int cmsis_dap_cmd_dap_connect(uint8_t mode)
{
- int retval;
uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_CONNECT;
command[1] = mode;
- retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
-
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
if (retval != ERROR_OK) {
LOG_ERROR("CMSIS-DAP command CMD_CONNECT failed.");
return ERROR_JTAG_DEVICE_ERROR;
return ERROR_OK;
}
-static int cmsis_dap_cmd_DAP_Disconnect(void)
+static int cmsis_dap_cmd_dap_disconnect(void)
{
- int retval;
uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_DISCONNECT;
- retval = cmsis_dap_xfer(cmsis_dap_handle, 1);
-
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 1);
if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
LOG_ERROR("CMSIS-DAP command CMD_DISCONNECT failed.");
return ERROR_JTAG_DEVICE_ERROR;
return ERROR_OK;
}
-static int cmsis_dap_cmd_DAP_TFER_Configure(uint8_t idle, uint16_t retry_count, uint16_t match_retry)
+static int cmsis_dap_cmd_dap_tfer_configure(uint8_t idle, uint16_t retry_count, uint16_t match_retry)
{
- int retval;
uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_TFER_CONFIGURE;
h_u16_to_le(&command[2], retry_count);
h_u16_to_le(&command[4], match_retry);
- retval = cmsis_dap_xfer(cmsis_dap_handle, 6);
-
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 6);
if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
LOG_ERROR("CMSIS-DAP command CMD_TFER_Configure failed.");
return ERROR_JTAG_DEVICE_ERROR;
return ERROR_OK;
}
-static int cmsis_dap_cmd_DAP_SWD_Configure(uint8_t cfg)
+static int cmsis_dap_cmd_dap_swd_configure(uint8_t cfg)
{
- int retval;
uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_SWD_CONFIGURE;
command[1] = cfg;
- retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
-
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
LOG_ERROR("CMSIS-DAP command CMD_SWD_Configure failed.");
return ERROR_JTAG_DEVICE_ERROR;
}
#if 0
-static int cmsis_dap_cmd_DAP_Delay(uint16_t delay_us)
+static int cmsis_dap_cmd_dap_delay(uint16_t delay_us)
{
- int retval;
uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_DELAY;
h_u16_to_le(&command[1], delay_us);
- retval = cmsis_dap_xfer(cmsis_dap_handle, 3);
-
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 3);
if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
LOG_ERROR("CMSIS-DAP command CMD_Delay failed.");
return ERROR_JTAG_DEVICE_ERROR;
static int cmsis_dap_metacmd_targetsel(uint32_t instance_id)
{
- int retval;
uint8_t *command = cmsis_dap_handle->command;
const uint32_t SEQ_RD = 0x80, SEQ_WR = 0x00;
idx += 4;
command[idx++] = parity_u32(instance_id);
- retval = cmsis_dap_xfer(cmsis_dap_handle, idx);
-
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, idx);
if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
LOG_ERROR("CMSIS-DAP command SWD_Sequence failed.");
return ERROR_JTAG_DEVICE_ERROR;
}
+
+ return ERROR_OK;
+}
+
+/**
+ * Sets the SWO transport mode.
+ * @param[in] transport The transport mode. Can be None, SWO_Data or
+ * WinUSB (requires CMSIS-DAP v2).
+ */
+static int cmsis_dap_cmd_dap_swo_transport(uint8_t transport)
+{
+ uint8_t *command = cmsis_dap_handle->command;
+
+ command[0] = CMD_DAP_SWO_TRANSPORT;
+ command[1] = transport;
+
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
+ if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
+ LOG_ERROR("CMSIS-DAP: command CMD_SWO_Transport(%d) failed.", transport);
+ return ERROR_JTAG_DEVICE_ERROR;
+ }
+
+ return ERROR_OK;
+}
+
+/**
+ * Sets the SWO trace capture mode.
+ * @param[in] mode Trace capture mode. Can be UART or MANCHESTER.
+ */
+static int cmsis_dap_cmd_dap_swo_mode(uint8_t mode)
+{
+ uint8_t *command = cmsis_dap_handle->command;
+
+ command[0] = CMD_DAP_SWO_MODE;
+ command[1] = mode;
+
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
+ if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
+ LOG_ERROR("CMSIS-DAP: command CMD_SWO_Mode(%d) failed.", mode);
+ return ERROR_JTAG_DEVICE_ERROR;
+ }
+
+ return ERROR_OK;
+}
+
+/**
+ * Sets the baudrate for capturing SWO trace data.
+ * Can be called iteratively to determine supported baudrates.
+ * @param[in] in_baudrate Requested baudrate.
+ * @param[out] dev_baudrate Actual baudrate or 0 (baudrate not configured).
+ * When requested baudrate is not achievable the
+ * closest configured baudrate can be returned or
+ * 0 which indicates that baudrate was not configured.
+ */
+static int cmsis_dap_cmd_dap_swo_baudrate(
+ uint32_t in_baudrate,
+ uint32_t *dev_baudrate)
+{
+ uint8_t *command = cmsis_dap_handle->command;
+
+ command[0] = CMD_DAP_SWO_BAUDRATE;
+ h_u32_to_le(&command[1], in_baudrate);
+
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 4);
+ uint32_t rvbr = le_to_h_u32(&cmsis_dap_handle->response[1]);
+ if (retval != ERROR_OK || rvbr == 0) {
+ LOG_ERROR("CMSIS-DAP: command CMD_SWO_Baudrate(%u) -> %u failed.", in_baudrate, rvbr);
+ if (dev_baudrate)
+ *dev_baudrate = 0;
+ return ERROR_JTAG_DEVICE_ERROR;
+ }
+
+ if (dev_baudrate)
+ *dev_baudrate = rvbr;
+
+ return ERROR_OK;
+}
+
+/**
+ * Controls the SWO trace data capture.
+ * @param[in] control Start or stop a trace. Starting capture automatically
+ * flushes any existing trace data in buffers which has
+ * not yet been read.
+ */
+static int cmsis_dap_cmd_dap_swo_control(uint8_t control)
+{
+ uint8_t *command = cmsis_dap_handle->command;
+
+ command[0] = CMD_DAP_SWO_CONTROL;
+ command[1] = control;
+
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
+ if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
+ LOG_ERROR("CMSIS-DAP: command CMD_SWO_Control(%d) failed.", control);
+ return ERROR_JTAG_DEVICE_ERROR;
+ }
+
+ return ERROR_OK;
+}
+
+/**
+ * Reads the SWO trace status.
+ * @param[out] trace_status The trace's status.
+ * Bit0: Trace Capture (1 - active, 0 - inactive).
+ * Bit6: Trace Stream Error.
+ * Bit7: Trace Buffer Overrun.
+ * @param[out] trace_count Number of bytes in Trace Buffer (not yet read).
+ */
+static int cmsis_dap_cmd_dap_swo_status(
+ uint8_t *trace_status,
+ size_t *trace_count)
+{
+ uint8_t *command = cmsis_dap_handle->command;
+
+ command[0] = CMD_DAP_SWO_STATUS;
+
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 1);
+ if (retval != ERROR_OK) {
+ LOG_ERROR("CMSIS-DAP: command CMD_SWO_Status failed.");
+ return ERROR_JTAG_DEVICE_ERROR;
+ }
+
+ if (trace_status)
+ *trace_status = cmsis_dap_handle->response[1];
+ if (trace_count)
+ *trace_count = le_to_h_u32(&cmsis_dap_handle->response[2]);
+
+ return ERROR_OK;
+}
+
+/**
+ * Reads the captured SWO trace data from Trace Buffer.
+ * @param[in] max_trace_count Maximum number of Trace Data bytes to read.
+ * @param[out] trace_status The trace's status.
+ * @param[out] trace_count Number of Trace Data bytes read.
+ * @param[out] data Trace Data bytes read.
+ */
+static int cmsis_dap_cmd_dap_swo_data(
+ size_t max_trace_count,
+ uint8_t *trace_status,
+ size_t *trace_count,
+ uint8_t *data)
+{
+ uint8_t *command = cmsis_dap_handle->command;
+
+ command[0] = CMD_DAP_SWO_DATA;
+ h_u16_to_le(&command[1], max_trace_count);
+
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, 3);
+ if (retval != ERROR_OK) {
+ LOG_ERROR("CMSIS-DAP: command CMD_SWO_Data failed.");
+ return ERROR_JTAG_DEVICE_ERROR;
+ }
+
+ *trace_status = cmsis_dap_handle->response[1];
+ *trace_count = le_to_h_u16(&cmsis_dap_handle->response[2]);
+
+ if (*trace_count > 0)
+ memcpy(data, &cmsis_dap_handle->response[4], *trace_count);
+
return ERROR_OK;
}
* able to automatically retry anything (because ARM
* has forgotten to implement sticky error flags
* clearing). See also comments regarding
- * cmsis_dap_cmd_DAP_TFER_Configure() and
- * cmsis_dap_cmd_DAP_SWD_Configure() in
+ * cmsis_dap_cmd_dap_tfer_configure() and
+ * cmsis_dap_cmd_dap_swd_configure() in
* cmsis_dap_init().
*/
if (!(cmd & SWD_CMD_RnW) &&
}
int retval = dap->backend->write(dap, idx, USB_TIMEOUT);
-
if (retval < 0) {
queued_retval = retval;
goto skip;
{
uint8_t *data;
- int retval = cmsis_dap_cmd_DAP_Info(INFO_ID_SERNUM, &data);
+ int retval = cmsis_dap_cmd_dap_info(INFO_ID_SERNUM, &data);
if (retval != ERROR_OK)
return retval;
uint8_t *data;
/* INFO_ID_FW_VER - string */
- int retval = cmsis_dap_cmd_DAP_Info(INFO_ID_FW_VER, &data);
+ int retval = cmsis_dap_cmd_dap_info(INFO_ID_FW_VER, &data);
if (retval != ERROR_OK)
return retval;
uint8_t *data;
/* INFO_ID_CAPS - byte */
- int retval = cmsis_dap_cmd_DAP_Info(INFO_ID_CAPS, &data);
+ int retval = cmsis_dap_cmd_dap_info(INFO_ID_CAPS, &data);
if (retval != ERROR_OK)
return retval;
LOG_INFO("CMSIS-DAP: %s", info_caps_str[0]);
if (caps & INFO_CAPS_JTAG)
LOG_INFO("CMSIS-DAP: %s", info_caps_str[1]);
+ if (caps & INFO_CAPS_SWO_UART)
+ LOG_INFO("CMSIS-DAP: %s", info_caps_str[2]);
+ if (caps & INFO_CAPS_SWO_MANCHESTER)
+ LOG_INFO("CMSIS-DAP: %s", info_caps_str[3]);
}
return ERROR_OK;
}
+static int cmsis_dap_get_swo_buf_sz(uint32_t *swo_buf_sz)
+{
+ uint8_t *data;
+
+ /* INFO_ID_SWO_BUF_SZ - word */
+ int retval = cmsis_dap_cmd_dap_info(INFO_ID_SWO_BUF_SZ, &data);
+ if (retval != ERROR_OK)
+ return retval;
+
+ if (data[0] != 4)
+ return ERROR_FAIL;
+
+ *swo_buf_sz = le_to_h_u32(&data[1]);
+
+ LOG_INFO("CMSIS-DAP: SWO Trace Buffer Size = %u bytes", *swo_buf_sz);
+
+ return ERROR_OK;
+}
+
static int cmsis_dap_get_status(void)
{
uint8_t d;
- int retval = cmsis_dap_cmd_DAP_SWJ_Pins(0, 0, 0, &d);
+ int retval = cmsis_dap_cmd_dap_swj_pins(0, 0, 0, &d);
if (retval == ERROR_OK) {
LOG_INFO("SWCLK/TCK = %d SWDIO/TMS = %d TDI = %d TDO = %d nTRST = %d nRESET = %d",
* Reconnecting would break connecting under reset. */
/* First disconnect before connecting, Atmel EDBG needs it for SAMD/R/L/C */
- cmsis_dap_cmd_DAP_Disconnect();
+ cmsis_dap_cmd_dap_disconnect();
/* When we are reconnecting, DAP_Connect needs to be rerun, at
* least on Keil ULINK-ME */
- retval = cmsis_dap_cmd_DAP_Connect(CONNECT_SWD);
+ retval = cmsis_dap_cmd_dap_connect(CONNECT_SWD);
if (retval != ERROR_OK)
return retval;
}
return ERROR_FAIL;
}
- retval = cmsis_dap_cmd_DAP_SWJ_Sequence(s_len, s);
+ retval = cmsis_dap_cmd_dap_swj_sequence(s_len, s);
if (retval != ERROR_OK)
return retval;
/* Atmel EDBG needs renew clock setting after SWJ_Sequence
* otherwise default frequency is used */
- return cmsis_dap_cmd_DAP_SWJ_Clock(jtag_get_speed_khz());
+ return cmsis_dap_cmd_dap_swj_clock(jtag_get_speed_khz());
}
static int cmsis_dap_swd_open(void)
{
- int retval;
-
if (!(cmsis_dap_handle->caps & INFO_CAPS_SWD)) {
LOG_ERROR("CMSIS-DAP: SWD not supported");
return ERROR_JTAG_DEVICE_ERROR;
}
- retval = cmsis_dap_cmd_DAP_Connect(CONNECT_SWD);
+ int retval = cmsis_dap_cmd_dap_connect(CONNECT_SWD);
if (retval != ERROR_OK)
return retval;
static int cmsis_dap_init(void)
{
- int retval;
uint8_t *data;
- retval = cmsis_dap_open();
+ int retval = cmsis_dap_open();
if (retval != ERROR_OK)
return retval;
return ERROR_JTAG_DEVICE_ERROR;
}
- retval = cmsis_dap_cmd_DAP_Connect(CONNECT_JTAG);
+ retval = cmsis_dap_cmd_dap_connect(CONNECT_JTAG);
if (retval != ERROR_OK)
return retval;
pending_queue_len = 12;
/* INFO_ID_PKT_SZ - short */
- retval = cmsis_dap_cmd_DAP_Info(INFO_ID_PKT_SZ, &data);
+ retval = cmsis_dap_cmd_dap_info(INFO_ID_PKT_SZ, &data);
if (retval != ERROR_OK)
goto init_err;
}
/* INFO_ID_PKT_CNT - byte */
- retval = cmsis_dap_cmd_DAP_Info(INFO_ID_PKT_CNT, &data);
+ retval = cmsis_dap_cmd_dap_info(INFO_ID_PKT_CNT, &data);
if (retval != ERROR_OK)
goto init_err;
/* Now try to connect to the target
* TODO: This is all SWD only @ present */
- retval = cmsis_dap_cmd_DAP_SWJ_Clock(jtag_get_speed_khz());
+ retval = cmsis_dap_cmd_dap_swj_clock(jtag_get_speed_khz());
if (retval != ERROR_OK)
goto init_err;
/* Ask CMSIS-DAP to automatically retry on receiving WAIT for
* up to 64 times. This must be changed to 0 if sticky
* overrun detection is enabled. */
- retval = cmsis_dap_cmd_DAP_TFER_Configure(0, 64, 0);
+ retval = cmsis_dap_cmd_dap_tfer_configure(0, 64, 0);
if (retval != ERROR_OK)
goto init_err;
if (swd_mode) {
/* Data Phase (bit 2) must be set to 1 if sticky overrun
* detection is enabled */
- retval = cmsis_dap_cmd_DAP_SWD_Configure(0); /* 1 TRN, no Data Phase */
+ retval = cmsis_dap_cmd_dap_swd_configure(0); /* 1 TRN, no Data Phase */
if (retval != ERROR_OK)
goto init_err;
}
/* Both LEDs on */
/* Intentionally not checked for error, debugging will work
* without LEDs */
- (void)cmsis_dap_cmd_DAP_LED(LED_ID_CONNECT, LED_ON);
- (void)cmsis_dap_cmd_DAP_LED(LED_ID_RUN, LED_ON);
+ (void)cmsis_dap_cmd_dap_led(LED_ID_CONNECT, LED_ON);
+ (void)cmsis_dap_cmd_dap_led(LED_ID_RUN, LED_ON);
/* support connecting with srst asserted */
enum reset_types jtag_reset_config = jtag_get_reset_config();
if (jtag_reset_config & RESET_CNCT_UNDER_SRST) {
if (jtag_reset_config & RESET_SRST_NO_GATING) {
- retval = cmsis_dap_cmd_DAP_SWJ_Pins(0, SWJ_PIN_SRST, 0, NULL);
+ retval = cmsis_dap_cmd_dap_swj_pins(0, SWJ_PIN_SRST, 0, NULL);
if (retval != ERROR_OK)
goto init_err;
LOG_INFO("Connecting under reset");
static int cmsis_dap_quit(void)
{
- cmsis_dap_cmd_DAP_Disconnect();
+ cmsis_dap_cmd_dap_disconnect();
+
/* Both LEDs off */
- cmsis_dap_cmd_DAP_LED(LED_ID_RUN, LED_OFF);
- cmsis_dap_cmd_DAP_LED(LED_ID_CONNECT, LED_OFF);
+ cmsis_dap_cmd_dap_led(LED_ID_RUN, LED_OFF);
+ cmsis_dap_cmd_dap_led(LED_ID_CONNECT, LED_OFF);
cmsis_dap_close(cmsis_dap_handle);
if (!trst)
output_pins |= SWJ_PIN_TRST;
- int retval = cmsis_dap_cmd_DAP_SWJ_Pins(output_pins,
+ int retval = cmsis_dap_cmd_dap_swj_pins(output_pins,
SWJ_PIN_TRST | SWJ_PIN_SRST, 0, NULL);
if (retval != ERROR_OK)
LOG_ERROR("CMSIS-DAP: Interface reset failed");
static void cmsis_dap_execute_sleep(struct jtag_command *cmd)
{
#if 0
- int retval = cmsis_dap_cmd_DAP_Delay(cmd->cmd.sleep->us);
+ int retval = cmsis_dap_cmd_dap_delay(cmd->cmd.sleep->us);
if (retval != ERROR_OK)
#endif
jtag_sleep(cmd->cmd.sleep->us);
{
LOG_INFO("cmsis-dap JTAG TLR_RESET");
uint8_t seq = 0xff;
- int ret = cmsis_dap_cmd_DAP_SWJ_Sequence(8, &seq);
- if (ret == ERROR_OK)
+
+ int retval = cmsis_dap_cmd_dap_swj_sequence(8, &seq);
+ if (retval == ERROR_OK)
tap_set_state(TAP_RESET);
- return ret;
+ return retval;
}
/* Set new end state */
/* Move to the end state by queuing a sequence to clock into TMS */
static void cmsis_dap_state_move(void)
{
- uint8_t tms_scan;
- uint8_t tms_scan_bits;
-
- tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
- tms_scan_bits = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
+ uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
+ uint8_t tms_scan_bits = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
LOG_DEBUG_IO("state move from %s to %s: %d clocks, %02X on tms",
tap_state_name(tap_get_state()), tap_state_name(tap_get_end_state()),
static void cmsis_dap_pathmove(int num_states, tap_state_t *path)
{
- int i;
uint8_t tms0 = 0x00;
uint8_t tms1 = 0xff;
- for (i = 0; i < num_states; i++) {
+ for (int i = 0; i < num_states; i++) {
if (path[i] == tap_state_transition(tap_get_state(), false))
cmsis_dap_add_tms_sequence(&tms0, 1);
else if (path[i] == tap_state_transition(tap_get_state(), true))
static void cmsis_dap_stableclocks(int num_cycles)
{
- int i;
-
uint8_t tms = tap_get_state() == TAP_RESET;
/* TODO: Perform optimizations? */
/* Execute num_cycles. */
- for (i = 0; i < num_cycles; i++)
+ for (int i = 0; i < num_cycles; i++)
cmsis_dap_add_tms_sequence(&tms, 1);
}
static void cmsis_dap_execute_tms(struct jtag_command *cmd)
{
LOG_DEBUG_IO("TMS: %d bits", cmd->cmd.tms->num_bits);
- cmsis_dap_cmd_DAP_SWJ_Sequence(cmd->cmd.tms->num_bits, cmd->cmd.tms->bits);
+ cmsis_dap_cmd_dap_swj_sequence(cmd->cmd.tms->num_bits, cmd->cmd.tms->bits);
}
/* TODO: Is there need to call cmsis_dap_flush() for the JTAG_PATHMOVE,
return ERROR_JTAG_NOT_IMPLEMENTED;
}
- return cmsis_dap_cmd_DAP_SWJ_Clock(speed);
+ return cmsis_dap_cmd_dap_swj_clock(speed);
}
static int cmsis_dap_speed_div(int speed, int *khz)
return ERROR_OK;
}
+static bool calculate_swo_prescaler(unsigned int traceclkin_freq,
+ uint32_t trace_freq, uint16_t *prescaler)
+{
+ unsigned int presc = (traceclkin_freq + trace_freq / 2) / trace_freq;
+ if (presc == 0 || presc > TPIU_ACPR_MAX_SWOSCALER + 1)
+ return false;
+
+ /* Probe's UART speed must be within 3% of the TPIU's SWO baud rate. */
+ unsigned int max_deviation = (traceclkin_freq * 3) / 100;
+ if (presc * trace_freq < traceclkin_freq - max_deviation ||
+ presc * trace_freq > traceclkin_freq + max_deviation)
+ return false;
+
+ *prescaler = presc;
+
+ return true;
+}
+
+/**
+ * @see adapter_driver::config_trace
+ */
+static int cmsis_dap_config_trace(
+ bool trace_enabled,
+ enum tpiu_pin_protocol pin_protocol,
+ uint32_t port_size,
+ unsigned int *swo_freq,
+ unsigned int traceclkin_hz,
+ uint16_t *swo_prescaler)
+{
+ int retval;
+
+ if (!trace_enabled) {
+ if (cmsis_dap_handle->trace_enabled) {
+ retval = cmsis_dap_cmd_dap_swo_control(DAP_SWO_CONTROL_STOP);
+ if (retval != ERROR_OK) {
+ LOG_ERROR("Failed to disable the SWO-trace.");
+ return retval;
+ }
+ }
+ cmsis_dap_handle->trace_enabled = false;
+ LOG_INFO("SWO-trace disabled.");
+ return ERROR_OK;
+ }
+
+ if (!(cmsis_dap_handle->caps & INFO_CAPS_SWO_UART) &&
+ !(cmsis_dap_handle->caps & INFO_CAPS_SWO_MANCHESTER)) {
+ LOG_ERROR("SWO-trace is not supported by the device.");
+ return ERROR_FAIL;
+ }
+
+ uint8_t swo_mode;
+ if (pin_protocol == TPIU_PIN_PROTOCOL_ASYNC_UART &&
+ (cmsis_dap_handle->caps & INFO_CAPS_SWO_UART)) {
+ swo_mode = DAP_SWO_MODE_UART;
+ } else if (pin_protocol == TPIU_PIN_PROTOCOL_ASYNC_MANCHESTER &&
+ (cmsis_dap_handle->caps & INFO_CAPS_SWO_MANCHESTER)) {
+ swo_mode = DAP_SWO_MODE_MANCHESTER;
+ } else {
+ LOG_ERROR("Selected pin protocol is not supported.");
+ return ERROR_FAIL;
+ }
+
+ if (*swo_freq == 0) {
+ LOG_INFO("SWO-trace frequency autodetection not implemented.");
+ return ERROR_FAIL;
+ }
+
+ retval = cmsis_dap_cmd_dap_swo_control(DAP_SWO_CONTROL_STOP);
+ if (retval != ERROR_OK)
+ return retval;
+
+ cmsis_dap_handle->trace_enabled = false;
+
+ retval = cmsis_dap_get_swo_buf_sz(&cmsis_dap_handle->swo_buf_sz);
+ if (retval != ERROR_OK)
+ return retval;
+
+ retval = cmsis_dap_cmd_dap_swo_transport(DAP_SWO_TRANSPORT_DATA);
+ if (retval != ERROR_OK)
+ return retval;
+
+ retval = cmsis_dap_cmd_dap_swo_mode(swo_mode);
+ if (retval != ERROR_OK)
+ return retval;
+
+ retval = cmsis_dap_cmd_dap_swo_baudrate(*swo_freq, swo_freq);
+ if (retval != ERROR_OK)
+ return retval;
+
+ if (!calculate_swo_prescaler(traceclkin_hz, *swo_freq,
+ swo_prescaler)) {
+ LOG_ERROR("SWO frequency is not suitable. Please choose a "
+ "different frequency or use auto-detection.");
+ return ERROR_FAIL;
+ }
+
+ LOG_INFO("SWO frequency: %u Hz.", *swo_freq);
+ LOG_INFO("SWO prescaler: %u.", *swo_prescaler);
+
+ retval = cmsis_dap_cmd_dap_swo_control(DAP_SWO_CONTROL_START);
+ if (retval != ERROR_OK)
+ return retval;
+
+ cmsis_dap_handle->trace_enabled = true;
+
+ return ERROR_OK;
+}
+
+/**
+ * @see adapter_driver::poll_trace
+ */
+static int cmsis_dap_poll_trace(uint8_t *buf, size_t *size)
+{
+ uint8_t trace_status;
+ size_t trace_count;
+
+ if (!cmsis_dap_handle->trace_enabled) {
+ *size = 0;
+ return ERROR_OK;
+ }
+
+ int retval = cmsis_dap_cmd_dap_swo_status(&trace_status, &trace_count);
+ if (retval != ERROR_OK)
+ return retval;
+ if ((trace_status & DAP_SWO_STATUS_CAPTURE_MASK) != DAP_SWO_STATUS_CAPTURE_ACTIVE)
+ return ERROR_FAIL;
+
+ *size = trace_count < *size ? trace_count : *size;
+ size_t read_so_far = 0;
+ do {
+ size_t rb = 0;
+ uint32_t packet_size = cmsis_dap_handle->packet_size - 4 /*data-reply*/;
+ uint32_t remaining = *size - read_so_far;
+ if (remaining < packet_size)
+ packet_size = remaining;
+ retval = cmsis_dap_cmd_dap_swo_data(
+ packet_size,
+ &trace_status,
+ &rb,
+ &buf[read_so_far]);
+ if (retval != ERROR_OK)
+ return retval;
+ if ((trace_status & DAP_SWO_STATUS_CAPTURE_MASK) != DAP_SWO_STATUS_CAPTURE_ACTIVE)
+ return ERROR_FAIL;
+
+ read_so_far += rb;
+ } while (read_so_far < *size);
+
+ return ERROR_OK;
+}
+
COMMAND_HANDLER(cmsis_dap_handle_info_command)
{
if (cmsis_dap_get_version_info() == ERROR_OK)
COMMAND_HANDLER(cmsis_dap_handle_cmd_command)
{
- int retval;
- unsigned i;
uint8_t *command = cmsis_dap_handle->command;
- for (i = 0; i < CMD_ARGC; i++)
+ for (unsigned i = 0; i < CMD_ARGC; i++)
command[i] = strtoul(CMD_ARGV[i], NULL, 16);
- retval = cmsis_dap_xfer(cmsis_dap_handle, CMD_ARGC);
+ int retval = cmsis_dap_xfer(cmsis_dap_handle, CMD_ARGC);
if (retval != ERROR_OK) {
LOG_ERROR("CMSIS-DAP command failed.");
.speed = cmsis_dap_speed,
.khz = cmsis_dap_khz,
.speed_div = cmsis_dap_speed_div,
+ .config_trace = cmsis_dap_config_trace,
+ .poll_trace = cmsis_dap_poll_trace,
.jtag_ops = &cmsis_dap_interface,
.swd_ops = &cmsis_dap_swd_driver,
Code Review / openocd.git / commitdiff