interesting
/
riscv-openocd
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

cmsis_dap: add support for swo commands 

Replaced mixed snake_case_CamelCase with snake_case.
Define variables at first-use location.

CMSIS-DAP SWO specification:

    https://arm-software.github.io/CMSIS_5/DAP/html/group__DAP__swo__gr.html

Change-Id: Ieba79b16efd445143f964b614673d041aae74f92
Signed-off-by: Adrian Negreanu <adrian.negreanu@nxp.com>
Reviewed-on: http://openocd.zylin.com/5820
Tested-by: jenkins
Reviewed-by: Antonio Borneo <borneo.antonio@gmail.com>
This commit is contained in:
Adrian Negreanu 2021-05-19 13:33:30 +03:00 committed by Antonio Borneo
parent c4dd883c9a
commit 6ae38ef7f7
2 changed files with 440 additions and 94 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

532
src/jtag/drivers/cmsis_dap.c
View File

@ -1,4 +1,7 @@
/*************************************************************************** /***************************************************************************
* Copyright (C) 2021 by Adrian Negreanu *
* groleo@gmail.com *
* *
* Copyright (C) 2018 by Mickaël Thomas * * Copyright (C) 2018 by Mickaël Thomas *
* mickael9@gmail.com * * mickael9@gmail.com *
* * * *
@ -41,6 +44,7 @@
#include <jtag/interface.h> #include <jtag/interface.h>
#include <jtag/commands.h> #include <jtag/commands.h>
#include <jtag/tcl.h> #include <jtag/tcl.h>
#include <target/cortex_m.h>
#include "cmsis_dap.h" #include "cmsis_dap.h"
@ -96,9 +100,12 @@ static bool swd_mode;
#define INFO_ID_CAPS 0xf0 /* byte */ #define INFO_ID_CAPS 0xf0 /* byte */
#define INFO_ID_PKT_CNT 0xfe /* byte */ #define INFO_ID_PKT_CNT 0xfe /* byte */
#define INFO_ID_PKT_SZ 0xff /* short */ #define INFO_ID_PKT_SZ 0xff /* short */
#define INFO_ID_SWO_BUF_SZ 0xfd /* word */
#define INFO_CAPS_SWD 0x01 #define INFO_CAPS_SWD BIT(0)
#define INFO_CAPS_JTAG 0x02 #define INFO_CAPS_JTAG BIT(1)
#define INFO_CAPS_SWO_UART BIT(2)
#define INFO_CAPS_SWO_MANCHESTER BIT(3)
/* CMD_LED */ /* CMD_LED */
#define LED_ID_CONNECT 0x00 #define LED_ID_CONNECT 0x00
@ -163,12 +170,44 @@ static bool swd_mode;
#define DAP_OK 0 #define DAP_OK 0
#define DAP_ERROR 0xFF #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 /* CMSIS-DAP Vendor Commands
* None as yet... */ * None as yet... */
static const char * const info_caps_str[] = { static const char * const info_caps_str[] = {
"SWD Supported", "SWD Supported",
"JTAG Supported" "JTAG Supported",
"SWO-UART Supported",
"SWO-MANCHESTER Supported"
}; };
struct pending_transfer_result { struct pending_transfer_result {
@ -338,9 +377,8 @@ static int cmsis_dap_xfer(struct cmsis_dap *dap, int txlen)
return ERROR_OK; 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; uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_SWJ_PINS; command[0] = CMD_DAP_SWJ_PINS;
@ -348,8 +386,7 @@ static int cmsis_dap_cmd_DAP_SWJ_Pins(uint8_t pins, uint8_t mask, uint32_t delay
command[2] = mask; command[2] = mask;
h_u32_to_le(&command[3], delay); 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) { if (retval != ERROR_OK) {
LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_PINS failed."); LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_PINS failed.");
return ERROR_JTAG_DEVICE_ERROR; return ERROR_JTAG_DEVICE_ERROR;
@ -361,9 +398,8 @@ static int cmsis_dap_cmd_DAP_SWJ_Pins(uint8_t pins, uint8_t mask, uint32_t delay
return ERROR_OK; 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; uint8_t *command = cmsis_dap_handle->command;
/* set clock in Hz */ /* set clock in Hz */
@ -372,8 +408,7 @@ static int cmsis_dap_cmd_DAP_SWJ_Clock(uint32_t swj_clock)
command[0] = CMD_DAP_SWJ_CLOCK; command[0] = CMD_DAP_SWJ_CLOCK;
h_u32_to_le(&command[1], 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) { if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_CLOCK failed."); LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_CLOCK failed.");
return ERROR_JTAG_DEVICE_ERROR; return ERROR_JTAG_DEVICE_ERROR;
@ -383,9 +418,8 @@ static int cmsis_dap_cmd_DAP_SWJ_Clock(uint32_t swj_clock)
} }
/* clock a sequence of bits out on TMS, to change JTAG states */ /* 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; uint8_t *command = cmsis_dap_handle->command;
#ifdef CMSIS_DAP_JTAG_DEBUG #ifdef CMSIS_DAP_JTAG_DEBUG
@ -400,23 +434,21 @@ static int cmsis_dap_cmd_DAP_SWJ_Sequence(uint8_t s_len, const uint8_t *sequence
command[1] = s_len; command[1] = s_len;
bit_copy(&command[2], 0, sequence, 0, 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) if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK)
return ERROR_FAIL; return ERROR_FAIL;
return ERROR_OK; 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; uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_INFO; command[0] = CMD_DAP_INFO;
command[1] = 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) { if (retval != ERROR_OK) {
LOG_ERROR("CMSIS-DAP command CMD_INFO failed."); LOG_ERROR("CMSIS-DAP command CMD_INFO failed.");
return ERROR_JTAG_DEVICE_ERROR; return ERROR_JTAG_DEVICE_ERROR;
@ -427,17 +459,15 @@ static int cmsis_dap_cmd_DAP_Info(uint8_t info, uint8_t **data)
return ERROR_OK; 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; uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_LED; command[0] = CMD_DAP_LED;
command[1] = led; command[1] = led;
command[2] = state; 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) { if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
LOG_ERROR("CMSIS-DAP command CMD_LED failed."); LOG_ERROR("CMSIS-DAP command CMD_LED failed.");
return ERROR_JTAG_DEVICE_ERROR; return ERROR_JTAG_DEVICE_ERROR;
@ -446,16 +476,14 @@ static int cmsis_dap_cmd_DAP_LED(uint8_t led, uint8_t state)
return ERROR_OK; 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; uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_CONNECT; command[0] = CMD_DAP_CONNECT;
command[1] = mode; command[1] = mode;
retval = cmsis_dap_xfer(cmsis_dap_handle, 2); int retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
if (retval != ERROR_OK) { if (retval != ERROR_OK) {
LOG_ERROR("CMSIS-DAP command CMD_CONNECT failed."); LOG_ERROR("CMSIS-DAP command CMD_CONNECT failed.");
return ERROR_JTAG_DEVICE_ERROR; return ERROR_JTAG_DEVICE_ERROR;
@ -469,15 +497,13 @@ static int cmsis_dap_cmd_DAP_Connect(uint8_t mode)
return ERROR_OK; 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; uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_DISCONNECT; 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) { if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
LOG_ERROR("CMSIS-DAP command CMD_DISCONNECT failed."); LOG_ERROR("CMSIS-DAP command CMD_DISCONNECT failed.");
return ERROR_JTAG_DEVICE_ERROR; return ERROR_JTAG_DEVICE_ERROR;
@ -486,9 +512,8 @@ static int cmsis_dap_cmd_DAP_Disconnect(void)
return ERROR_OK; 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; uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_TFER_CONFIGURE; command[0] = CMD_DAP_TFER_CONFIGURE;
@ -496,8 +521,7 @@ static int cmsis_dap_cmd_DAP_TFER_Configure(uint8_t idle, uint16_t retry_count,
h_u16_to_le(&command[2], retry_count); h_u16_to_le(&command[2], retry_count);
h_u16_to_le(&command[4], match_retry); 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) { if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
LOG_ERROR("CMSIS-DAP command CMD_TFER_Configure failed."); LOG_ERROR("CMSIS-DAP command CMD_TFER_Configure failed.");
return ERROR_JTAG_DEVICE_ERROR; return ERROR_JTAG_DEVICE_ERROR;
@ -506,16 +530,14 @@ static int cmsis_dap_cmd_DAP_TFER_Configure(uint8_t idle, uint16_t retry_count,
return ERROR_OK; 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; uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_SWD_CONFIGURE; command[0] = CMD_DAP_SWD_CONFIGURE;
command[1] = cfg; 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) { if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
LOG_ERROR("CMSIS-DAP command CMD_SWD_Configure failed."); LOG_ERROR("CMSIS-DAP command CMD_SWD_Configure failed.");
return ERROR_JTAG_DEVICE_ERROR; return ERROR_JTAG_DEVICE_ERROR;
@ -525,16 +547,14 @@ static int cmsis_dap_cmd_DAP_SWD_Configure(uint8_t cfg)
} }
#if 0 #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; uint8_t *command = cmsis_dap_handle->command;
command[0] = CMD_DAP_DELAY; command[0] = CMD_DAP_DELAY;
h_u16_to_le(&command[1], delay_us); 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) { if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
LOG_ERROR("CMSIS-DAP command CMD_Delay failed."); LOG_ERROR("CMSIS-DAP command CMD_Delay failed.");
return ERROR_JTAG_DEVICE_ERROR; return ERROR_JTAG_DEVICE_ERROR;
@ -546,7 +566,6 @@ static int cmsis_dap_cmd_DAP_Delay(uint16_t delay_us)
static int cmsis_dap_metacmd_targetsel(uint32_t instance_id) static int cmsis_dap_metacmd_targetsel(uint32_t instance_id)
{ {
int retval;
uint8_t *command = cmsis_dap_handle->command; uint8_t *command = cmsis_dap_handle->command;
const uint32_t SEQ_RD = 0x80, SEQ_WR = 0x00; const uint32_t SEQ_RD = 0x80, SEQ_WR = 0x00;
@ -574,12 +593,171 @@ static int cmsis_dap_metacmd_targetsel(uint32_t instance_id)
idx += 4; idx += 4;
command[idx++] = parity_u32(instance_id); 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) { if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
LOG_ERROR("CMSIS-DAP command SWD_Sequence failed."); LOG_ERROR("CMSIS-DAP command SWD_Sequence failed.");
return ERROR_JTAG_DEVICE_ERROR; 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; return ERROR_OK;
} }
@ -620,8 +798,8 @@ static void cmsis_dap_swd_write_from_queue(struct cmsis_dap *dap)
* able to automatically retry anything (because ARM * able to automatically retry anything (because ARM
* has forgotten to implement sticky error flags * has forgotten to implement sticky error flags
* clearing). See also comments regarding * clearing). See also comments regarding
* cmsis_dap_cmd_DAP_TFER_Configure() and * cmsis_dap_cmd_dap_tfer_configure() and
* cmsis_dap_cmd_DAP_SWD_Configure() in * cmsis_dap_cmd_dap_swd_configure() in
* cmsis_dap_init(). * cmsis_dap_init().
*/ */
if (!(cmd & SWD_CMD_RnW) && if (!(cmd & SWD_CMD_RnW) &&
@ -640,7 +818,6 @@ static void cmsis_dap_swd_write_from_queue(struct cmsis_dap *dap)
} }
int retval = dap->backend->write(dap, idx, USB_TIMEOUT); int retval = dap->backend->write(dap, idx, USB_TIMEOUT);
if (retval < 0) { if (retval < 0) {
queued_retval = retval; queued_retval = retval;
goto skip; goto skip;
@ -805,7 +982,7 @@ static int cmsis_dap_get_serial_info(void)
{ {
uint8_t *data; 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) if (retval != ERROR_OK)
return retval; return retval;
@ -820,7 +997,7 @@ static int cmsis_dap_get_version_info(void)
uint8_t *data; uint8_t *data;
/* INFO_ID_FW_VER - string */ /* 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) if (retval != ERROR_OK)
return retval; return retval;
@ -835,7 +1012,7 @@ static int cmsis_dap_get_caps_info(void)
uint8_t *data; uint8_t *data;
/* INFO_ID_CAPS - byte */ /* 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) if (retval != ERROR_OK)
return retval; return retval;
@ -848,16 +1025,39 @@ static int cmsis_dap_get_caps_info(void)
LOG_INFO("CMSIS-DAP: %s", info_caps_str[0]); LOG_INFO("CMSIS-DAP: %s", info_caps_str[0]);
if (caps & INFO_CAPS_JTAG) if (caps & INFO_CAPS_JTAG)
LOG_INFO("CMSIS-DAP: %s", info_caps_str[1]); 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; 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) static int cmsis_dap_get_status(void)
{ {
uint8_t d; 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) { if (retval == ERROR_OK) {
LOG_INFO("SWCLK/TCK = %d SWDIO/TMS = %d TDI = %d TDO = %d nTRST = %d nRESET = %d", LOG_INFO("SWCLK/TCK = %d SWDIO/TMS = %d TDI = %d TDO = %d nTRST = %d nRESET = %d",
@ -884,11 +1084,11 @@ static int cmsis_dap_swd_switch_seq(enum swd_special_seq seq)
* Reconnecting would break connecting under reset. */ * Reconnecting would break connecting under reset. */
/* First disconnect before connecting, Atmel EDBG needs it for SAMD/R/L/C */ /* 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 /* When we are reconnecting, DAP_Connect needs to be rerun, at
* least on Keil ULINK-ME */ * 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) if (retval != ERROR_OK)
return retval; return retval;
} }
@ -929,25 +1129,23 @@ static int cmsis_dap_swd_switch_seq(enum swd_special_seq seq)
return ERROR_FAIL; 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) if (retval != ERROR_OK)
return retval; return retval;
/* Atmel EDBG needs renew clock setting after SWJ_Sequence /* Atmel EDBG needs renew clock setting after SWJ_Sequence
* otherwise default frequency is used */ * 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) static int cmsis_dap_swd_open(void)
{ {
int retval;
if (!(cmsis_dap_handle->caps & INFO_CAPS_SWD)) { if (!(cmsis_dap_handle->caps & INFO_CAPS_SWD)) {
LOG_ERROR("CMSIS-DAP: SWD not supported"); LOG_ERROR("CMSIS-DAP: SWD not supported");
return ERROR_JTAG_DEVICE_ERROR; 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) if (retval != ERROR_OK)
return retval; return retval;
@ -959,10 +1157,9 @@ static int cmsis_dap_swd_open(void)
static int cmsis_dap_init(void) static int cmsis_dap_init(void)
{ {
int retval;
uint8_t *data; uint8_t *data;
retval = cmsis_dap_open(); int retval = cmsis_dap_open();
if (retval != ERROR_OK) if (retval != ERROR_OK)
return retval; return retval;
@ -991,7 +1188,7 @@ static int cmsis_dap_init(void)
return ERROR_JTAG_DEVICE_ERROR; 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) if (retval != ERROR_OK)
return retval; return retval;
@ -1004,7 +1201,7 @@ static int cmsis_dap_init(void)
pending_queue_len = 12; pending_queue_len = 12;
/* INFO_ID_PKT_SZ - short */ /* 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) if (retval != ERROR_OK)
goto init_err; goto init_err;
@ -1027,7 +1224,7 @@ static int cmsis_dap_init(void)
} }
/* INFO_ID_PKT_CNT - byte */ /* 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) if (retval != ERROR_OK)
goto init_err; goto init_err;
@ -1055,36 +1252,36 @@ static int cmsis_dap_init(void)
/* Now try to connect to the target /* Now try to connect to the target
* TODO: This is all SWD only @ present */ * 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) if (retval != ERROR_OK)
goto init_err; goto init_err;
/* Ask CMSIS-DAP to automatically retry on receiving WAIT for /* Ask CMSIS-DAP to automatically retry on receiving WAIT for
* up to 64 times. This must be changed to 0 if sticky * up to 64 times. This must be changed to 0 if sticky
* overrun detection is enabled. */ * 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) if (retval != ERROR_OK)
goto init_err; goto init_err;
if (swd_mode) { if (swd_mode) {
/* Data Phase (bit 2) must be set to 1 if sticky overrun /* Data Phase (bit 2) must be set to 1 if sticky overrun
* detection is enabled */ * 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) if (retval != ERROR_OK)
goto init_err; goto init_err;
} }
/* Both LEDs on */ /* Both LEDs on */
/* Intentionally not checked for error, debugging will work /* Intentionally not checked for error, debugging will work
* without LEDs */ * without LEDs */
(void)cmsis_dap_cmd_DAP_LED(LED_ID_CONNECT, LED_ON); (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_RUN, LED_ON);
/* support connecting with srst asserted */ /* support connecting with srst asserted */
enum reset_types jtag_reset_config = jtag_get_reset_config(); enum reset_types jtag_reset_config = jtag_get_reset_config();
if (jtag_reset_config & RESET_CNCT_UNDER_SRST) { if (jtag_reset_config & RESET_CNCT_UNDER_SRST) {
if (jtag_reset_config & RESET_SRST_NO_GATING) { 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) if (retval != ERROR_OK)
goto init_err; goto init_err;
LOG_INFO("Connecting under reset"); LOG_INFO("Connecting under reset");
@ -1106,10 +1303,11 @@ static int cmsis_dap_swd_init(void)
static int cmsis_dap_quit(void) static int cmsis_dap_quit(void)
{ {
cmsis_dap_cmd_DAP_Disconnect(); cmsis_dap_cmd_dap_disconnect();
/* Both LEDs off */ /* Both LEDs off */
cmsis_dap_cmd_DAP_LED(LED_ID_RUN, LED_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_CONNECT, LED_OFF);
cmsis_dap_close(cmsis_dap_handle); cmsis_dap_close(cmsis_dap_handle);
@ -1127,7 +1325,7 @@ static int cmsis_dap_reset(int trst, int srst)
if (!trst) if (!trst)
output_pins |= SWJ_PIN_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); SWJ_PIN_TRST | SWJ_PIN_SRST, 0, NULL);
if (retval != ERROR_OK) if (retval != ERROR_OK)
LOG_ERROR("CMSIS-DAP: Interface reset failed"); LOG_ERROR("CMSIS-DAP: Interface reset failed");
@ -1137,7 +1335,7 @@ static int cmsis_dap_reset(int trst, int srst)
static void cmsis_dap_execute_sleep(struct jtag_command *cmd) static void cmsis_dap_execute_sleep(struct jtag_command *cmd)
{ {
#if 0 #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) if (retval != ERROR_OK)
#endif #endif
jtag_sleep(cmd->cmd.sleep->us); jtag_sleep(cmd->cmd.sleep->us);
@ -1148,10 +1346,11 @@ static int cmsis_dap_execute_tlr_reset(struct jtag_command *cmd)
{ {
LOG_INFO("cmsis-dap JTAG TLR_RESET"); LOG_INFO("cmsis-dap JTAG TLR_RESET");
uint8_t seq = 0xff; 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); tap_set_state(TAP_RESET);
return ret; return retval;
} }
/* Set new end state */ /* Set new end state */
@ -1369,11 +1568,8 @@ static void cmsis_dap_add_tms_sequence(const uint8_t *sequence, int s_len)
/* Move to the end state by queuing a sequence to clock into TMS */ /* Move to the end state by queuing a sequence to clock into TMS */
static void cmsis_dap_state_move(void) static void cmsis_dap_state_move(void)
{ {
uint8_t tms_scan; uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
uint8_t tms_scan_bits; uint8_t tms_scan_bits = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
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());
LOG_DEBUG_IO("state move from %s to %s: %d clocks, %02X on tms", 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()), tap_state_name(tap_get_state()), tap_state_name(tap_get_end_state()),
@ -1488,11 +1684,10 @@ static void cmsis_dap_execute_scan(struct jtag_command *cmd)
static void cmsis_dap_pathmove(int num_states, tap_state_t *path) static void cmsis_dap_pathmove(int num_states, tap_state_t *path)
{ {
int i;
uint8_t tms0 = 0x00; uint8_t tms0 = 0x00;
uint8_t tms1 = 0xff; 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)) if (path[i] == tap_state_transition(tap_get_state(), false))
cmsis_dap_add_tms_sequence(&tms0, 1); cmsis_dap_add_tms_sequence(&tms0, 1);
else if (path[i] == tap_state_transition(tap_get_state(), true)) else if (path[i] == tap_state_transition(tap_get_state(), true))
@ -1520,12 +1715,10 @@ static void cmsis_dap_execute_pathmove(struct jtag_command *cmd)
static void cmsis_dap_stableclocks(int num_cycles) static void cmsis_dap_stableclocks(int num_cycles)
{ {
int i;
uint8_t tms = tap_get_state() == TAP_RESET; uint8_t tms = tap_get_state() == TAP_RESET;
/* TODO: Perform optimizations? */ /* TODO: Perform optimizations? */
/* Execute num_cycles. */ /* 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); cmsis_dap_add_tms_sequence(&tms, 1);
} }
@ -1565,7 +1758,7 @@ static void cmsis_dap_execute_stableclocks(struct jtag_command *cmd)
static void cmsis_dap_execute_tms(struct jtag_command *cmd) static void cmsis_dap_execute_tms(struct jtag_command *cmd)
{ {
LOG_DEBUG_IO("TMS: %d bits", cmd->cmd.tms->num_bits); 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, /* TODO: Is there need to call cmsis_dap_flush() for the JTAG_PATHMOVE,
@ -1623,7 +1816,7 @@ static int cmsis_dap_speed(int speed)
return ERROR_JTAG_NOT_IMPLEMENTED; 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) static int cmsis_dap_speed_div(int speed, int *khz)
@ -1638,6 +1831,157 @@ static int cmsis_dap_khz(int khz, int *jtag_speed)
return ERROR_OK; 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) COMMAND_HANDLER(cmsis_dap_handle_info_command)
{ {
if (cmsis_dap_get_version_info() == ERROR_OK) if (cmsis_dap_get_version_info() == ERROR_OK)
@ -1648,14 +1992,12 @@ COMMAND_HANDLER(cmsis_dap_handle_info_command)
COMMAND_HANDLER(cmsis_dap_handle_cmd_command) COMMAND_HANDLER(cmsis_dap_handle_cmd_command)
{ {
int retval;
unsigned i;
uint8_t *command = cmsis_dap_handle->command; 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); 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) { if (retval != ERROR_OK) {
LOG_ERROR("CMSIS-DAP command failed."); LOG_ERROR("CMSIS-DAP command failed.");
@ -1817,6 +2159,8 @@ struct adapter_driver cmsis_dap_adapter_driver = {
.speed = cmsis_dap_speed, .speed = cmsis_dap_speed,
.khz = cmsis_dap_khz, .khz = cmsis_dap_khz,
.speed_div = cmsis_dap_speed_div, .speed_div = cmsis_dap_speed_div,
.config_trace = cmsis_dap_config_trace,
.poll_trace = cmsis_dap_poll_trace,
.jtag_ops = &cmsis_dap_interface, .jtag_ops = &cmsis_dap_interface,
.swd_ops = &cmsis_dap_swd_driver, .swd_ops = &cmsis_dap_swd_driver,

2
src/jtag/drivers/cmsis_dap.h
View File

@ -18,6 +18,8 @@ struct cmsis_dap {
uint8_t *response; uint8_t *response;
uint8_t caps; uint8_t caps;
uint8_t mode; uint8_t mode;
uint32_t swo_buf_sz;
bool trace_enabled;
}; };
struct cmsis_dap_backend { struct cmsis_dap_backend {