1 /***************************************************************************
2 * Copyright (C) 2021 by Adrian Negreanu *
5 * Copyright (C) 2018 by Mickaƫl Thomas *
8 * Copyright (C) 2016 by Maksym Hilliaka *
9 * oter@frozen-team.com *
11 * Copyright (C) 2016 by Phillip Pearson *
14 * Copyright (C) 2014 by Paul Fertser *
15 * fercerpav@gmail.com *
17 * Copyright (C) 2013 by mike brown *
18 * mike@theshedworks.org.uk *
20 * Copyright (C) 2013 by Spencer Oliver *
21 * spen@spen-soft.co.uk *
23 * This program is free software; you can redistribute it and/or modify *
24 * it under the terms of the GNU General Public License as published by *
25 * the Free Software Foundation; either version 2 of the License, or *
26 * (at your option) any later version. *
28 * This program is distributed in the hope that it will be useful, *
29 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
30 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
31 * GNU General Public License for more details. *
33 * You should have received a copy of the GNU General Public License *
34 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
35 ***************************************************************************/
41 #include <transport/transport.h>
42 #include "helper/replacements.h"
43 #include <jtag/adapter.h>
45 #include <jtag/interface.h>
46 #include <jtag/commands.h>
48 #include <target/cortex_m.h>
50 #include "cmsis_dap.h"
52 static const struct cmsis_dap_backend *const cmsis_dap_backends[] = {
53 #if BUILD_CMSIS_DAP_USB == 1
54 &cmsis_dap_usb_backend,
57 #if BUILD_CMSIS_DAP_HID == 1
58 &cmsis_dap_hid_backend,
64 /* Known vid/pid pairs:
65 * VID 0xc251: Keil Software
66 * PID 0xf001: LPC-Link-II CMSIS_DAP
67 * PID 0xf002: OPEN-SDA CMSIS_DAP (Freedom Board)
68 * PID 0x2722: Keil ULINK2 CMSIS-DAP
69 * PID 0x2750: Keil ULINKplus CMSIS-DAP
71 * VID 0x0d28: mbed Software
72 * PID 0x0204: MBED CMSIS-DAP
76 /* vid = pid = 0 marks the end of the list */
77 static uint16_t cmsis_dap_vid[MAX_USB_IDS + 1] = { 0 };
78 static uint16_t cmsis_dap_pid[MAX_USB_IDS + 1] = { 0 };
79 static char *cmsis_dap_serial;
80 static int cmsis_dap_backend = -1;
83 #define USB_TIMEOUT 1000
85 /* CMSIS-DAP General Commands */
86 #define CMD_DAP_INFO 0x00
87 #define CMD_DAP_LED 0x01
88 #define CMD_DAP_CONNECT 0x02
89 #define CMD_DAP_DISCONNECT 0x03
90 #define CMD_DAP_WRITE_ABORT 0x08
91 #define CMD_DAP_DELAY 0x09
92 #define CMD_DAP_RESET_TARGET 0x0A
95 #define INFO_ID_VENDOR 0x01 /* string */
96 #define INFO_ID_PRODUCT 0x02 /* string */
97 #define INFO_ID_SERNUM 0x03 /* string */
98 #define INFO_ID_FW_VER 0x04 /* string */
99 #define INFO_ID_TD_VEND 0x05 /* string */
100 #define INFO_ID_TD_NAME 0x06 /* string */
101 #define INFO_ID_CAPS 0xf0 /* byte */
102 #define INFO_ID_PKT_CNT 0xfe /* byte */
103 #define INFO_ID_PKT_SZ 0xff /* short */
104 #define INFO_ID_SWO_BUF_SZ 0xfd /* word */
106 #define INFO_CAPS_SWD BIT(0)
107 #define INFO_CAPS_JTAG BIT(1)
108 #define INFO_CAPS_SWO_UART BIT(2)
109 #define INFO_CAPS_SWO_MANCHESTER BIT(3)
110 #define INFO_CAPS_ATOMIC_CMDS BIT(4)
111 #define INFO_CAPS_TEST_DOMAIN_TIMER BIT(5)
112 #define INFO_CAPS_SWO_STREAMING_TRACE BIT(6)
113 #define INFO_CAPS_UART_PORT BIT(7)
114 #define INFO_CAPS_USB_COM_PORT BIT(8)
115 #define INFO_CAPS__NUM_CAPS 9
118 #define LED_ID_CONNECT 0x00
119 #define LED_ID_RUN 0x01
125 #define CONNECT_DEFAULT 0x00
126 #define CONNECT_SWD 0x01
127 #define CONNECT_JTAG 0x02
129 /* CMSIS-DAP Common SWD/JTAG Commands */
130 #define CMD_DAP_DELAY 0x09
131 #define CMD_DAP_SWJ_PINS 0x10
132 #define CMD_DAP_SWJ_CLOCK 0x11
133 #define CMD_DAP_SWJ_SEQ 0x12
145 #define SWJ_PIN_TCK (1<<0)
146 #define SWJ_PIN_TMS (1<<1)
147 #define SWJ_PIN_TDI (1<<2)
148 #define SWJ_PIN_TDO (1<<3)
149 #define SWJ_PIN_TRST (1<<5)
150 #define SWJ_PIN_SRST (1<<7)
152 /* CMSIS-DAP SWD Commands */
153 #define CMD_DAP_SWD_CONFIGURE 0x13
154 #define CMD_DAP_SWD_SEQUENCE 0x1D
156 /* CMSIS-DAP JTAG Commands */
157 #define CMD_DAP_JTAG_SEQ 0x14
158 #define CMD_DAP_JTAG_CONFIGURE 0x15
159 #define CMD_DAP_JTAG_IDCODE 0x16
161 /* CMSIS-DAP JTAG sequence info masks */
162 /* Number of bits to clock through (0 means 64) */
163 #define DAP_JTAG_SEQ_TCK 0x3F
164 /* TMS will be set during the sequence if this bit is set */
165 #define DAP_JTAG_SEQ_TMS 0x40
166 /* TDO output will be captured if this bit is set */
167 #define DAP_JTAG_SEQ_TDO 0x80
170 /* CMSIS-DAP Transfer Commands */
171 #define CMD_DAP_TFER_CONFIGURE 0x04
172 #define CMD_DAP_TFER 0x05
173 #define CMD_DAP_TFER_BLOCK 0x06
174 #define CMD_DAP_TFER_ABORT 0x07
176 /* DAP Status Code */
178 #define DAP_ERROR 0xFF
180 /* CMSIS-DAP SWO Commands */
181 #define CMD_DAP_SWO_TRANSPORT 0x17
182 #define CMD_DAP_SWO_MODE 0x18
183 #define CMD_DAP_SWO_BAUDRATE 0x19
184 #define CMD_DAP_SWO_CONTROL 0x1A
185 #define CMD_DAP_SWO_STATUS 0x1B
186 #define CMD_DAP_SWO_DATA 0x1C
187 #define CMD_DAP_SWO_EX_STATUS 0x1E
189 /* SWO transport mode for reading trace data */
190 #define DAP_SWO_TRANSPORT_NONE 0
191 #define DAP_SWO_TRANSPORT_DATA 1
192 #define DAP_SWO_TRANSPORT_WINUSB 2
194 /* SWO trace capture mode */
195 #define DAP_SWO_MODE_OFF 0
196 #define DAP_SWO_MODE_UART 1
197 #define DAP_SWO_MODE_MANCHESTER 2
199 /* SWO trace data capture */
200 #define DAP_SWO_CONTROL_STOP 0
201 #define DAP_SWO_CONTROL_START 1
203 /* SWO trace status */
204 #define DAP_SWO_STATUS_CAPTURE_INACTIVE 0
205 #define DAP_SWO_STATUS_CAPTURE_ACTIVE 1
206 #define DAP_SWO_STATUS_CAPTURE_MASK BIT(0)
207 #define DAP_SWO_STATUS_STREAM_ERROR_MASK BIT(6)
208 #define DAP_SWO_STATUS_BUFFER_OVERRUN_MASK BIT(7)
210 /* CMSIS-DAP Vendor Commands
213 static const char * const info_caps_str[INFO_CAPS__NUM_CAPS] = {
216 "SWO-UART supported",
217 "SWO-MANCHESTER supported",
218 "Atomic commands supported",
219 "Test domain timer supported",
220 "SWO streaming trace supported",
221 "UART communication port supported",
222 "UART via USB COM port supported",
225 struct pending_transfer_result {
231 struct pending_request_block {
232 struct pending_transfer_result *transfers;
236 struct pending_scan_result {
237 /** Offset in bytes in the CMD_DAP_JTAG_SEQ response buffer. */
239 /** Number of bits to read. */
241 /** Location to store the result */
243 /** Offset in the destination buffer */
244 unsigned buffer_offset;
247 /* Up to MIN(packet_count, MAX_PENDING_REQUESTS) requests may be issued
248 * until the first response arrives */
249 #define MAX_PENDING_REQUESTS 3
251 /* Pending requests are organized as a FIFO - circular buffer */
252 /* Each block in FIFO can contain up to pending_queue_len transfers */
253 static int pending_queue_len;
254 static struct pending_request_block pending_fifo[MAX_PENDING_REQUESTS];
255 static int pending_fifo_put_idx, pending_fifo_get_idx;
256 static int pending_fifo_block_count;
258 /* pointers to buffers that will receive jtag scan results on the next flush */
259 #define MAX_PENDING_SCAN_RESULTS 256
260 static int pending_scan_result_count;
261 static struct pending_scan_result pending_scan_results[MAX_PENDING_SCAN_RESULTS];
263 /* queued JTAG sequences that will be executed on the next flush */
264 #define QUEUED_SEQ_BUF_LEN (cmsis_dap_handle->packet_size - 3)
265 static int queued_seq_count;
266 static int queued_seq_buf_end;
267 static int queued_seq_tdo_ptr;
268 static uint8_t queued_seq_buf[1024]; /* TODO: make dynamic / move into cmsis object */
270 static int queued_retval;
272 static uint8_t output_pins = SWJ_PIN_SRST | SWJ_PIN_TRST;
274 static struct cmsis_dap *cmsis_dap_handle;
277 static int cmsis_dap_quit(void);
279 static int cmsis_dap_open(void)
281 const struct cmsis_dap_backend *backend = NULL;
283 struct cmsis_dap *dap = calloc(1, sizeof(struct cmsis_dap));
285 LOG_ERROR("unable to allocate memory");
289 if (cmsis_dap_backend >= 0) {
290 /* Use forced backend */
291 backend = cmsis_dap_backends[cmsis_dap_backend];
292 if (backend->open(dap, cmsis_dap_vid, cmsis_dap_pid, cmsis_dap_serial) != ERROR_OK)
295 /* Try all backends */
296 for (unsigned int i = 0; i < ARRAY_SIZE(cmsis_dap_backends); i++) {
297 backend = cmsis_dap_backends[i];
298 if (backend->open(dap, cmsis_dap_vid, cmsis_dap_pid, cmsis_dap_serial) == ERROR_OK)
306 LOG_ERROR("unable to find a matching CMSIS-DAP device");
311 dap->backend = backend;
313 cmsis_dap_handle = dap;
318 static void cmsis_dap_close(struct cmsis_dap *dap)
321 dap->backend->close(dap);
325 free(cmsis_dap_handle->packet_buffer);
326 free(cmsis_dap_handle);
327 cmsis_dap_handle = NULL;
328 free(cmsis_dap_serial);
329 cmsis_dap_serial = NULL;
331 for (int i = 0; i < MAX_PENDING_REQUESTS; i++) {
332 free(pending_fifo[i].transfers);
333 pending_fifo[i].transfers = NULL;
337 static void cmsis_dap_flush_read(struct cmsis_dap *dap)
340 /* Some CMSIS-DAP adapters keep buffered packets over
341 * USB close/open so we need to flush up to 64 old packets
342 * to be sure all buffers are empty */
343 for (i = 0; i < 64; i++) {
344 int retval = dap->backend->read(dap, 10);
345 if (retval == ERROR_TIMEOUT_REACHED)
349 LOG_DEBUG("Flushed %u packets", i);
352 /* Send a message and receive the reply */
353 static int cmsis_dap_xfer(struct cmsis_dap *dap, int txlen)
355 if (pending_fifo_block_count) {
356 LOG_ERROR("pending %d blocks, flushing", pending_fifo_block_count);
357 while (pending_fifo_block_count) {
358 dap->backend->read(dap, 10);
359 pending_fifo_block_count--;
361 pending_fifo_put_idx = 0;
362 pending_fifo_get_idx = 0;
365 uint8_t current_cmd = cmsis_dap_handle->command[0];
366 int retval = dap->backend->write(dap, txlen, USB_TIMEOUT);
371 retval = dap->backend->read(dap, USB_TIMEOUT);
375 uint8_t *resp = cmsis_dap_handle->response;
376 if (resp[0] == DAP_ERROR) {
377 LOG_ERROR("CMSIS-DAP command 0x%" PRIx8 " not implemented", current_cmd);
378 return ERROR_NOT_IMPLEMENTED;
381 if (resp[0] != current_cmd) {
382 LOG_ERROR("CMSIS-DAP command mismatch. Sent 0x%" PRIx8
383 " received 0x%" PRIx8, current_cmd, resp[0]);
385 cmsis_dap_flush_read(dap);
392 static int cmsis_dap_cmd_dap_swj_pins(uint8_t pins, uint8_t mask, uint32_t delay, uint8_t *input)
394 uint8_t *command = cmsis_dap_handle->command;
396 command[0] = CMD_DAP_SWJ_PINS;
399 h_u32_to_le(&command[3], delay);
401 int retval = cmsis_dap_xfer(cmsis_dap_handle, 7);
402 if (retval != ERROR_OK) {
403 LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_PINS failed.");
404 return ERROR_JTAG_DEVICE_ERROR;
408 *input = cmsis_dap_handle->response[1];
413 static int cmsis_dap_cmd_dap_swj_clock(uint32_t swj_clock)
415 uint8_t *command = cmsis_dap_handle->command;
417 /* set clock in Hz */
420 command[0] = CMD_DAP_SWJ_CLOCK;
421 h_u32_to_le(&command[1], swj_clock);
423 int retval = cmsis_dap_xfer(cmsis_dap_handle, 5);
424 if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
425 LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_CLOCK failed.");
426 return ERROR_JTAG_DEVICE_ERROR;
432 /* clock a sequence of bits out on TMS, to change JTAG states */
433 static int cmsis_dap_cmd_dap_swj_sequence(uint8_t s_len, const uint8_t *sequence)
435 uint8_t *command = cmsis_dap_handle->command;
437 #ifdef CMSIS_DAP_JTAG_DEBUG
438 LOG_DEBUG("cmsis-dap TMS sequence: len=%d", s_len);
439 for (int i = 0; i < DIV_ROUND_UP(s_len, 8); ++i)
440 printf("%02X ", sequence[i]);
445 command[0] = CMD_DAP_SWJ_SEQ;
447 bit_copy(&command[2], 0, sequence, 0, s_len);
449 int retval = cmsis_dap_xfer(cmsis_dap_handle, 2 + DIV_ROUND_UP(s_len, 8));
450 if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK)
456 static int cmsis_dap_cmd_dap_info(uint8_t info, uint8_t **data)
458 uint8_t *command = cmsis_dap_handle->command;
460 command[0] = CMD_DAP_INFO;
463 int retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
464 if (retval != ERROR_OK) {
465 LOG_ERROR("CMSIS-DAP command CMD_INFO failed.");
466 return ERROR_JTAG_DEVICE_ERROR;
469 *data = &cmsis_dap_handle->response[1];
474 static int cmsis_dap_cmd_dap_led(uint8_t led, uint8_t state)
476 uint8_t *command = cmsis_dap_handle->command;
478 command[0] = CMD_DAP_LED;
482 int retval = cmsis_dap_xfer(cmsis_dap_handle, 3);
483 if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
484 LOG_ERROR("CMSIS-DAP command CMD_LED failed.");
485 return ERROR_JTAG_DEVICE_ERROR;
491 static int cmsis_dap_cmd_dap_connect(uint8_t mode)
493 uint8_t *command = cmsis_dap_handle->command;
495 command[0] = CMD_DAP_CONNECT;
498 int retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
499 if (retval != ERROR_OK) {
500 LOG_ERROR("CMSIS-DAP command CMD_CONNECT failed.");
501 return ERROR_JTAG_DEVICE_ERROR;
504 if (cmsis_dap_handle->response[1] != mode) {
505 LOG_ERROR("CMSIS-DAP failed to connect in mode (%d)", mode);
506 return ERROR_JTAG_DEVICE_ERROR;
512 static int cmsis_dap_cmd_dap_disconnect(void)
514 uint8_t *command = cmsis_dap_handle->command;
516 command[0] = CMD_DAP_DISCONNECT;
518 int retval = cmsis_dap_xfer(cmsis_dap_handle, 1);
519 if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
520 LOG_ERROR("CMSIS-DAP command CMD_DISCONNECT failed.");
521 return ERROR_JTAG_DEVICE_ERROR;
527 static int cmsis_dap_cmd_dap_tfer_configure(uint8_t idle, uint16_t retry_count, uint16_t match_retry)
529 uint8_t *command = cmsis_dap_handle->command;
531 command[0] = CMD_DAP_TFER_CONFIGURE;
533 h_u16_to_le(&command[2], retry_count);
534 h_u16_to_le(&command[4], match_retry);
536 int retval = cmsis_dap_xfer(cmsis_dap_handle, 6);
537 if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
538 LOG_ERROR("CMSIS-DAP command CMD_TFER_Configure failed.");
539 return ERROR_JTAG_DEVICE_ERROR;
545 static int cmsis_dap_cmd_dap_swd_configure(uint8_t cfg)
547 uint8_t *command = cmsis_dap_handle->command;
549 command[0] = CMD_DAP_SWD_CONFIGURE;
552 int retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
553 if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
554 LOG_ERROR("CMSIS-DAP command CMD_SWD_Configure failed.");
555 return ERROR_JTAG_DEVICE_ERROR;
562 static int cmsis_dap_cmd_dap_delay(uint16_t delay_us)
564 uint8_t *command = cmsis_dap_handle->command;
566 command[0] = CMD_DAP_DELAY;
567 h_u16_to_le(&command[1], delay_us);
569 int retval = cmsis_dap_xfer(cmsis_dap_handle, 3);
570 if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
571 LOG_ERROR("CMSIS-DAP command CMD_Delay failed.");
572 return ERROR_JTAG_DEVICE_ERROR;
579 static int cmsis_dap_metacmd_targetsel(uint32_t instance_id)
581 uint8_t *command = cmsis_dap_handle->command;
582 const uint32_t SEQ_RD = 0x80, SEQ_WR = 0x00;
584 /* SWD multi-drop requires a transfer ala CMD_DAP_TFER,
585 but with no expectation of an SWD ACK response. In
586 CMSIS-DAP v1.20 and v2.00, CMD_DAP_SWD_SEQUENCE was
587 added to allow this special sequence to be generated.
588 The purpose of this operation is to select the target
589 corresponding to the instance_id that is written */
592 command[idx++] = CMD_DAP_SWD_SEQUENCE;
593 command[idx++] = 3; /* sequence count */
595 /* sequence 0: packet request for TARGETSEL */
596 command[idx++] = SEQ_WR | 8;
597 command[idx++] = SWD_CMD_START | swd_cmd(false, false, DP_TARGETSEL) | SWD_CMD_STOP | SWD_CMD_PARK;
599 /* sequence 1: read Trn ACK Trn, no expectation for target to ACK */
600 command[idx++] = SEQ_RD | 5;
602 /* sequence 2: WDATA plus parity */
603 command[idx++] = SEQ_WR | (32 + 1);
604 h_u32_to_le(command + idx, instance_id);
606 command[idx++] = parity_u32(instance_id);
608 int retval = cmsis_dap_xfer(cmsis_dap_handle, idx);
609 if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
610 LOG_ERROR("CMSIS-DAP command SWD_Sequence failed.");
611 return ERROR_JTAG_DEVICE_ERROR;
618 * Sets the SWO transport mode.
619 * @param[in] transport The transport mode. Can be None, SWO_Data or
620 * WinUSB (requires CMSIS-DAP v2).
622 static int cmsis_dap_cmd_dap_swo_transport(uint8_t transport)
624 uint8_t *command = cmsis_dap_handle->command;
626 command[0] = CMD_DAP_SWO_TRANSPORT;
627 command[1] = transport;
629 int retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
630 if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
631 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Transport(%d) failed.", transport);
632 return ERROR_JTAG_DEVICE_ERROR;
639 * Sets the SWO trace capture mode.
640 * @param[in] mode Trace capture mode. Can be UART or MANCHESTER.
642 static int cmsis_dap_cmd_dap_swo_mode(uint8_t mode)
644 uint8_t *command = cmsis_dap_handle->command;
646 command[0] = CMD_DAP_SWO_MODE;
649 int retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
650 if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
651 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Mode(%d) failed.", mode);
652 return ERROR_JTAG_DEVICE_ERROR;
659 * Sets the baudrate for capturing SWO trace data.
660 * Can be called iteratively to determine supported baudrates.
661 * @param[in] in_baudrate Requested baudrate.
662 * @param[out] dev_baudrate Actual baudrate or 0 (baudrate not configured).
663 * When requested baudrate is not achievable the
664 * closest configured baudrate can be returned or
665 * 0 which indicates that baudrate was not configured.
667 static int cmsis_dap_cmd_dap_swo_baudrate(
668 uint32_t in_baudrate,
669 uint32_t *dev_baudrate)
671 uint8_t *command = cmsis_dap_handle->command;
673 command[0] = CMD_DAP_SWO_BAUDRATE;
674 h_u32_to_le(&command[1], in_baudrate);
676 int retval = cmsis_dap_xfer(cmsis_dap_handle, 4);
677 uint32_t rvbr = le_to_h_u32(&cmsis_dap_handle->response[1]);
678 if (retval != ERROR_OK || rvbr == 0) {
679 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Baudrate(%u) -> %u failed.", in_baudrate, rvbr);
682 return ERROR_JTAG_DEVICE_ERROR;
686 *dev_baudrate = rvbr;
692 * Controls the SWO trace data capture.
693 * @param[in] control Start or stop a trace. Starting capture automatically
694 * flushes any existing trace data in buffers which has
697 static int cmsis_dap_cmd_dap_swo_control(uint8_t control)
699 uint8_t *command = cmsis_dap_handle->command;
701 command[0] = CMD_DAP_SWO_CONTROL;
702 command[1] = control;
704 int retval = cmsis_dap_xfer(cmsis_dap_handle, 2);
705 if (retval != ERROR_OK || cmsis_dap_handle->response[1] != DAP_OK) {
706 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Control(%d) failed.", control);
707 return ERROR_JTAG_DEVICE_ERROR;
714 * Reads the SWO trace status.
715 * @param[out] trace_status The trace's status.
716 * Bit0: Trace Capture (1 - active, 0 - inactive).
717 * Bit6: Trace Stream Error.
718 * Bit7: Trace Buffer Overrun.
719 * @param[out] trace_count Number of bytes in Trace Buffer (not yet read).
721 static int cmsis_dap_cmd_dap_swo_status(
722 uint8_t *trace_status,
725 uint8_t *command = cmsis_dap_handle->command;
727 command[0] = CMD_DAP_SWO_STATUS;
729 int retval = cmsis_dap_xfer(cmsis_dap_handle, 1);
730 if (retval != ERROR_OK) {
731 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Status failed.");
732 return ERROR_JTAG_DEVICE_ERROR;
736 *trace_status = cmsis_dap_handle->response[1];
738 *trace_count = le_to_h_u32(&cmsis_dap_handle->response[2]);
744 * Reads the captured SWO trace data from Trace Buffer.
745 * @param[in] max_trace_count Maximum number of Trace Data bytes to read.
746 * @param[out] trace_status The trace's status.
747 * @param[out] trace_count Number of Trace Data bytes read.
748 * @param[out] data Trace Data bytes read.
750 static int cmsis_dap_cmd_dap_swo_data(
751 size_t max_trace_count,
752 uint8_t *trace_status,
756 uint8_t *command = cmsis_dap_handle->command;
758 command[0] = CMD_DAP_SWO_DATA;
759 h_u16_to_le(&command[1], max_trace_count);
761 int retval = cmsis_dap_xfer(cmsis_dap_handle, 3);
762 if (retval != ERROR_OK) {
763 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Data failed.");
764 return ERROR_JTAG_DEVICE_ERROR;
767 *trace_status = cmsis_dap_handle->response[1];
768 *trace_count = le_to_h_u16(&cmsis_dap_handle->response[2]);
770 if (*trace_count > 0)
771 memcpy(data, &cmsis_dap_handle->response[4], *trace_count);
776 static void cmsis_dap_swd_write_from_queue(struct cmsis_dap *dap)
778 uint8_t *command = cmsis_dap_handle->command;
779 struct pending_request_block *block = &pending_fifo[pending_fifo_put_idx];
781 LOG_DEBUG_IO("Executing %d queued transactions from FIFO index %d", block->transfer_count, pending_fifo_put_idx);
783 if (queued_retval != ERROR_OK) {
784 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval);
788 if (block->transfer_count == 0)
791 command[0] = CMD_DAP_TFER;
792 command[1] = 0x00; /* DAP Index */
793 command[2] = block->transfer_count;
796 for (int i = 0; i < block->transfer_count; i++) {
797 struct pending_transfer_result *transfer = &(block->transfers[i]);
798 uint8_t cmd = transfer->cmd;
799 uint32_t data = transfer->data;
801 LOG_DEBUG_IO("%s %s reg %x %"PRIx32,
802 cmd & SWD_CMD_APNDP ? "AP" : "DP",
803 cmd & SWD_CMD_RNW ? "read" : "write",
804 (cmd & SWD_CMD_A32) >> 1, data);
806 /* When proper WAIT handling is implemented in the
807 * common SWD framework, this kludge can be
808 * removed. However, this might lead to minor
809 * performance degradation as the adapter wouldn't be
810 * able to automatically retry anything (because ARM
811 * has forgotten to implement sticky error flags
812 * clearing). See also comments regarding
813 * cmsis_dap_cmd_dap_tfer_configure() and
814 * cmsis_dap_cmd_dap_swd_configure() in
817 if (!(cmd & SWD_CMD_RNW) &&
818 !(cmd & SWD_CMD_APNDP) &&
819 (cmd & SWD_CMD_A32) >> 1 == DP_CTRL_STAT &&
820 (data & CORUNDETECT)) {
821 LOG_DEBUG("refusing to enable sticky overrun detection");
822 data &= ~CORUNDETECT;
825 command[idx++] = (cmd >> 1) & 0x0f;
826 if (!(cmd & SWD_CMD_RNW)) {
827 h_u32_to_le(&command[idx], data);
832 int retval = dap->backend->write(dap, idx, USB_TIMEOUT);
834 queued_retval = retval;
837 queued_retval = ERROR_OK;
840 pending_fifo_put_idx = (pending_fifo_put_idx + 1) % dap->packet_count;
841 pending_fifo_block_count++;
842 if (pending_fifo_block_count > dap->packet_count)
843 LOG_ERROR("too much pending writes %d", pending_fifo_block_count);
848 block->transfer_count = 0;
851 static void cmsis_dap_swd_read_process(struct cmsis_dap *dap, int timeout_ms)
853 struct pending_request_block *block = &pending_fifo[pending_fifo_get_idx];
855 if (pending_fifo_block_count == 0)
856 LOG_ERROR("no pending write");
859 int retval = dap->backend->read(dap, timeout_ms);
860 if (retval == ERROR_TIMEOUT_REACHED && timeout_ms < USB_TIMEOUT)
864 LOG_DEBUG("error reading data");
865 queued_retval = ERROR_FAIL;
869 uint8_t *resp = dap->response;
870 if (resp[0] != CMD_DAP_TFER) {
871 LOG_ERROR("CMSIS-DAP command mismatch. Expected 0x%x received 0x%" PRIx8,
872 CMD_DAP_TFER, resp[0]);
873 queued_retval = ERROR_FAIL;
877 uint8_t transfer_count = resp[1];
878 uint8_t ack = resp[2] & 0x07;
879 if (resp[2] & 0x08) {
880 LOG_DEBUG("CMSIS-DAP Protocol Error @ %d (wrong parity)", transfer_count);
881 queued_retval = ERROR_FAIL;
884 if (ack != SWD_ACK_OK) {
885 LOG_DEBUG("SWD ack not OK @ %d %s", transfer_count,
886 ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK");
887 queued_retval = ack == SWD_ACK_WAIT ? ERROR_WAIT : ERROR_FAIL;
888 /* TODO: use results of transfers completed before the error occurred? */
892 if (block->transfer_count != transfer_count)
893 LOG_ERROR("CMSIS-DAP transfer count mismatch: expected %d, got %d",
894 block->transfer_count, transfer_count);
896 LOG_DEBUG_IO("Received results of %d queued transactions FIFO index %d",
897 transfer_count, pending_fifo_get_idx);
899 for (int i = 0; i < transfer_count; i++) {
900 struct pending_transfer_result *transfer = &(block->transfers[i]);
901 if (transfer->cmd & SWD_CMD_RNW) {
902 static uint32_t last_read;
903 uint32_t data = le_to_h_u32(&resp[idx]);
907 LOG_DEBUG_IO("Read result: %"PRIx32, data);
909 /* Imitate posted AP reads */
910 if ((transfer->cmd & SWD_CMD_APNDP) ||
911 ((transfer->cmd & SWD_CMD_A32) >> 1 == DP_RDBUFF)) {
916 if (transfer->buffer)
917 *(uint32_t *)(transfer->buffer) = tmp;
922 block->transfer_count = 0;
923 pending_fifo_get_idx = (pending_fifo_get_idx + 1) % dap->packet_count;
924 pending_fifo_block_count--;
927 static int cmsis_dap_swd_run_queue(void)
929 if (pending_fifo_block_count)
930 cmsis_dap_swd_read_process(cmsis_dap_handle, 0);
932 cmsis_dap_swd_write_from_queue(cmsis_dap_handle);
934 while (pending_fifo_block_count)
935 cmsis_dap_swd_read_process(cmsis_dap_handle, USB_TIMEOUT);
937 pending_fifo_put_idx = 0;
938 pending_fifo_get_idx = 0;
940 int retval = queued_retval;
941 queued_retval = ERROR_OK;
946 static void cmsis_dap_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data)
948 bool targetsel_cmd = swd_cmd(false, false, DP_TARGETSEL) == cmd;
950 if (pending_fifo[pending_fifo_put_idx].transfer_count == pending_queue_len
952 if (pending_fifo_block_count)
953 cmsis_dap_swd_read_process(cmsis_dap_handle, 0);
955 /* Not enough room in the queue. Run the queue. */
956 cmsis_dap_swd_write_from_queue(cmsis_dap_handle);
958 if (pending_fifo_block_count >= cmsis_dap_handle->packet_count)
959 cmsis_dap_swd_read_process(cmsis_dap_handle, USB_TIMEOUT);
962 if (queued_retval != ERROR_OK)
966 cmsis_dap_metacmd_targetsel(data);
970 struct pending_request_block *block = &pending_fifo[pending_fifo_put_idx];
971 struct pending_transfer_result *transfer = &(block->transfers[block->transfer_count]);
972 transfer->data = data;
974 if (cmd & SWD_CMD_RNW) {
975 /* Queue a read transaction */
976 transfer->buffer = dst;
978 block->transfer_count++;
981 static void cmsis_dap_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
983 assert(!(cmd & SWD_CMD_RNW));
984 cmsis_dap_swd_queue_cmd(cmd, NULL, value);
987 static void cmsis_dap_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
989 assert(cmd & SWD_CMD_RNW);
990 cmsis_dap_swd_queue_cmd(cmd, value, 0);
993 static int cmsis_dap_get_serial_info(void)
997 int retval = cmsis_dap_cmd_dap_info(INFO_ID_SERNUM, &data);
998 if (retval != ERROR_OK)
1001 if (data[0]) /* strlen */
1002 LOG_INFO("CMSIS-DAP: Serial# = %s", &data[1]);
1007 static int cmsis_dap_get_version_info(void)
1011 /* INFO_ID_FW_VER - string */
1012 int retval = cmsis_dap_cmd_dap_info(INFO_ID_FW_VER, &data);
1013 if (retval != ERROR_OK)
1016 if (data[0]) /* strlen */
1017 LOG_INFO("CMSIS-DAP: FW Version = %s", &data[1]);
1022 static int cmsis_dap_get_caps_info(void)
1026 /* INFO_ID_CAPS - byte */
1027 int retval = cmsis_dap_cmd_dap_info(INFO_ID_CAPS, &data);
1028 if (retval != ERROR_OK)
1031 if (data[0] == 1 || data[0] == 2) {
1032 uint16_t caps = data[1];
1034 caps |= (uint16_t)data[2] << 8;
1036 cmsis_dap_handle->caps = caps;
1038 for (int i = 0; i < INFO_CAPS__NUM_CAPS; ++i) {
1040 LOG_INFO("CMSIS-DAP: %s", info_caps_str[i]);
1047 static int cmsis_dap_get_swo_buf_sz(uint32_t *swo_buf_sz)
1051 /* INFO_ID_SWO_BUF_SZ - word */
1052 int retval = cmsis_dap_cmd_dap_info(INFO_ID_SWO_BUF_SZ, &data);
1053 if (retval != ERROR_OK)
1059 *swo_buf_sz = le_to_h_u32(&data[1]);
1061 LOG_INFO("CMSIS-DAP: SWO Trace Buffer Size = %u bytes", *swo_buf_sz);
1066 static int cmsis_dap_get_status(void)
1070 int retval = cmsis_dap_cmd_dap_swj_pins(0, 0, 0, &d);
1072 if (retval == ERROR_OK) {
1073 LOG_INFO("SWCLK/TCK = %d SWDIO/TMS = %d TDI = %d TDO = %d nTRST = %d nRESET = %d",
1074 (d & SWJ_PIN_TCK) ? 1 : 0,
1075 (d & SWJ_PIN_TMS) ? 1 : 0,
1076 (d & SWJ_PIN_TDI) ? 1 : 0,
1077 (d & SWJ_PIN_TDO) ? 1 : 0,
1078 (d & SWJ_PIN_TRST) ? 1 : 0,
1079 (d & SWJ_PIN_SRST) ? 1 : 0);
1085 static int cmsis_dap_swd_switch_seq(enum swd_special_seq seq)
1091 if ((output_pins & (SWJ_PIN_SRST | SWJ_PIN_TRST)) == (SWJ_PIN_SRST | SWJ_PIN_TRST)) {
1092 /* Following workaround deasserts reset on most adapters.
1093 * Do not reconnect if a reset line is active!
1094 * Reconnecting would break connecting under reset. */
1096 /* First disconnect before connecting, Atmel EDBG needs it for SAMD/R/L/C */
1097 cmsis_dap_cmd_dap_disconnect();
1099 /* When we are reconnecting, DAP_Connect needs to be rerun, at
1100 * least on Keil ULINK-ME */
1101 retval = cmsis_dap_cmd_dap_connect(CONNECT_SWD);
1102 if (retval != ERROR_OK)
1108 LOG_DEBUG_IO("SWD line reset");
1109 s = swd_seq_line_reset;
1110 s_len = swd_seq_line_reset_len;
1113 LOG_DEBUG("JTAG-to-SWD");
1114 s = swd_seq_jtag_to_swd;
1115 s_len = swd_seq_jtag_to_swd_len;
1117 case JTAG_TO_DORMANT:
1118 LOG_DEBUG("JTAG-to-DORMANT");
1119 s = swd_seq_jtag_to_dormant;
1120 s_len = swd_seq_jtag_to_dormant_len;
1123 LOG_DEBUG("SWD-to-JTAG");
1124 s = swd_seq_swd_to_jtag;
1125 s_len = swd_seq_swd_to_jtag_len;
1127 case SWD_TO_DORMANT:
1128 LOG_DEBUG("SWD-to-DORMANT");
1129 s = swd_seq_swd_to_dormant;
1130 s_len = swd_seq_swd_to_dormant_len;
1132 case DORMANT_TO_SWD:
1133 LOG_DEBUG("DORMANT-to-SWD");
1134 s = swd_seq_dormant_to_swd;
1135 s_len = swd_seq_dormant_to_swd_len;
1137 case DORMANT_TO_JTAG:
1138 LOG_DEBUG("DORMANT-to-JTAG");
1139 s = swd_seq_dormant_to_jtag;
1140 s_len = swd_seq_dormant_to_jtag_len;
1143 LOG_ERROR("Sequence %d not supported", seq);
1147 retval = cmsis_dap_cmd_dap_swj_sequence(s_len, s);
1148 if (retval != ERROR_OK)
1151 /* Atmel EDBG needs renew clock setting after SWJ_Sequence
1152 * otherwise default frequency is used */
1153 return cmsis_dap_cmd_dap_swj_clock(adapter_get_speed_khz());
1156 static int cmsis_dap_swd_open(void)
1158 if (!(cmsis_dap_handle->caps & INFO_CAPS_SWD)) {
1159 LOG_ERROR("CMSIS-DAP: SWD not supported");
1160 return ERROR_JTAG_DEVICE_ERROR;
1163 int retval = cmsis_dap_cmd_dap_connect(CONNECT_SWD);
1164 if (retval != ERROR_OK)
1167 /* Add more setup here.??... */
1169 LOG_INFO("CMSIS-DAP: Interface Initialised (SWD)");
1173 static int cmsis_dap_init(void)
1177 int retval = cmsis_dap_open();
1178 if (retval != ERROR_OK)
1181 cmsis_dap_flush_read(cmsis_dap_handle);
1183 retval = cmsis_dap_get_caps_info();
1184 if (retval != ERROR_OK)
1187 retval = cmsis_dap_get_version_info();
1188 if (retval != ERROR_OK)
1191 retval = cmsis_dap_get_serial_info();
1192 if (retval != ERROR_OK)
1196 retval = cmsis_dap_swd_open();
1197 if (retval != ERROR_OK)
1200 /* Connect in JTAG mode */
1201 if (!(cmsis_dap_handle->caps & INFO_CAPS_JTAG)) {
1202 LOG_ERROR("CMSIS-DAP: JTAG not supported");
1203 return ERROR_JTAG_DEVICE_ERROR;
1206 retval = cmsis_dap_cmd_dap_connect(CONNECT_JTAG);
1207 if (retval != ERROR_OK)
1210 LOG_INFO("CMSIS-DAP: Interface Initialised (JTAG)");
1213 /* Be conservative and suppress submitting multiple HID requests
1214 * until we get packet count info from the adaptor */
1215 cmsis_dap_handle->packet_count = 1;
1216 pending_queue_len = 12;
1218 /* INFO_ID_PKT_SZ - short */
1219 retval = cmsis_dap_cmd_dap_info(INFO_ID_PKT_SZ, &data);
1220 if (retval != ERROR_OK)
1223 if (data[0] == 2) { /* short */
1224 uint16_t pkt_sz = data[1] + (data[2] << 8);
1225 if (pkt_sz != cmsis_dap_handle->packet_size) {
1227 /* 4 bytes of command header + 5 bytes per register
1228 * write. For bulk read sequences just 4 bytes are
1229 * needed per transfer, so this is suboptimal. */
1230 pending_queue_len = (pkt_sz - 4) / 5;
1232 free(cmsis_dap_handle->packet_buffer);
1233 retval = cmsis_dap_handle->backend->packet_buffer_alloc(cmsis_dap_handle, pkt_sz);
1234 if (retval != ERROR_OK)
1237 LOG_DEBUG("CMSIS-DAP: Packet Size = %" PRIu16, pkt_sz);
1241 /* INFO_ID_PKT_CNT - byte */
1242 retval = cmsis_dap_cmd_dap_info(INFO_ID_PKT_CNT, &data);
1243 if (retval != ERROR_OK)
1246 if (data[0] == 1) { /* byte */
1247 int pkt_cnt = data[1];
1249 cmsis_dap_handle->packet_count = MIN(MAX_PENDING_REQUESTS, pkt_cnt);
1251 LOG_DEBUG("CMSIS-DAP: Packet Count = %d", pkt_cnt);
1254 LOG_DEBUG("Allocating FIFO for %d pending packets", cmsis_dap_handle->packet_count);
1255 for (int i = 0; i < cmsis_dap_handle->packet_count; i++) {
1256 pending_fifo[i].transfers = malloc(pending_queue_len * sizeof(struct pending_transfer_result));
1257 if (!pending_fifo[i].transfers) {
1258 LOG_ERROR("Unable to allocate memory for CMSIS-DAP queue");
1259 retval = ERROR_FAIL;
1264 /* Intentionally not checked for error, just logs an info message
1265 * not vital for further debugging */
1266 (void)cmsis_dap_get_status();
1268 /* Now try to connect to the target
1269 * TODO: This is all SWD only @ present */
1270 retval = cmsis_dap_cmd_dap_swj_clock(adapter_get_speed_khz());
1271 if (retval != ERROR_OK)
1274 /* Ask CMSIS-DAP to automatically retry on receiving WAIT for
1275 * up to 64 times. This must be changed to 0 if sticky
1276 * overrun detection is enabled. */
1277 retval = cmsis_dap_cmd_dap_tfer_configure(0, 64, 0);
1278 if (retval != ERROR_OK)
1282 /* Data Phase (bit 2) must be set to 1 if sticky overrun
1283 * detection is enabled */
1284 retval = cmsis_dap_cmd_dap_swd_configure(0); /* 1 TRN, no Data Phase */
1285 if (retval != ERROR_OK)
1289 /* Intentionally not checked for error, debugging will work
1291 (void)cmsis_dap_cmd_dap_led(LED_ID_CONNECT, LED_ON);
1292 (void)cmsis_dap_cmd_dap_led(LED_ID_RUN, LED_ON);
1294 /* support connecting with srst asserted */
1295 enum reset_types jtag_reset_config = jtag_get_reset_config();
1297 if (jtag_reset_config & RESET_CNCT_UNDER_SRST) {
1298 if (jtag_reset_config & RESET_SRST_NO_GATING) {
1299 retval = cmsis_dap_cmd_dap_swj_pins(0, SWJ_PIN_SRST, 0, NULL);
1300 if (retval != ERROR_OK)
1302 LOG_INFO("Connecting under reset");
1305 LOG_INFO("CMSIS-DAP: Interface ready");
1313 static int cmsis_dap_swd_init(void)
1319 static int cmsis_dap_quit(void)
1321 cmsis_dap_cmd_dap_disconnect();
1324 cmsis_dap_cmd_dap_led(LED_ID_RUN, LED_OFF);
1325 cmsis_dap_cmd_dap_led(LED_ID_CONNECT, LED_OFF);
1327 cmsis_dap_close(cmsis_dap_handle);
1332 static int cmsis_dap_reset(int trst, int srst)
1334 /* Set both TRST and SRST even if they're not enabled as
1335 * there's no way to tristate them */
1339 output_pins |= SWJ_PIN_SRST;
1341 output_pins |= SWJ_PIN_TRST;
1343 int retval = cmsis_dap_cmd_dap_swj_pins(output_pins,
1344 SWJ_PIN_TRST | SWJ_PIN_SRST, 0, NULL);
1345 if (retval != ERROR_OK)
1346 LOG_ERROR("CMSIS-DAP: Interface reset failed");
1350 static void cmsis_dap_execute_sleep(struct jtag_command *cmd)
1353 int retval = cmsis_dap_cmd_dap_delay(cmd->cmd.sleep->us);
1354 if (retval != ERROR_OK)
1356 jtag_sleep(cmd->cmd.sleep->us);
1359 /* Set TMS high for five TCK clocks, to move the TAP to the Test-Logic-Reset state */
1360 static int cmsis_dap_execute_tlr_reset(struct jtag_command *cmd)
1362 LOG_INFO("cmsis-dap JTAG TLR_RESET");
1365 int retval = cmsis_dap_cmd_dap_swj_sequence(8, &seq);
1366 if (retval == ERROR_OK)
1367 tap_set_state(TAP_RESET);
1371 /* Set new end state */
1372 static void cmsis_dap_end_state(tap_state_t state)
1374 if (tap_is_state_stable(state))
1375 tap_set_end_state(state);
1377 LOG_ERROR("BUG: %i is not a valid end state", state);
1382 #ifdef SPRINT_BINARY
1383 static void sprint_binary(char *s, const uint8_t *buf, int offset, int len)
1389 buf = { 0x18 } len=5 should result in: 11000
1390 buf = { 0xff 0x18 } len=13 should result in: 11111111 11000
1391 buf = { 0xc0 0x18 } offset=3 len=10 should result in: 11000 11000
1392 i=3 there means i/8 = 0 so c = 0xFF, and
1394 for (int i = offset; i < offset + len; ++i) {
1395 uint8_t c = buf[i / 8], mask = 1 << (i % 8);
1396 if ((i != offset) && !(i % 8))
1398 *s++ = (c & mask) ? '1' : '0';
1404 #ifdef CMSIS_DAP_JTAG_DEBUG
1405 static void debug_parse_cmsis_buf(const uint8_t *cmd, int cmdlen)
1407 /* cmd is a usb packet to go to the cmsis-dap interface */
1408 printf("cmsis-dap buffer (%d b): ", cmdlen);
1409 for (int i = 0; i < cmdlen; ++i)
1410 printf(" %02x", cmd[i]);
1413 case CMD_DAP_JTAG_SEQ: {
1414 printf("cmsis-dap jtag sequence command %02x (n=%d)\n", cmd[1], cmd[2]);
1416 * #2 = number of sequences
1417 * #3 = sequence info 1
1418 * #4...4+n_bytes-1 = sequence 1
1419 * #4+n_bytes = sequence info 2
1420 * #5+n_bytes = sequence 2 (single bit)
1423 for (int seq = 0; seq < cmd[2]; ++seq) {
1424 uint8_t info = cmd[pos++];
1425 int len = info & DAP_JTAG_SEQ_TCK;
1428 printf(" sequence %d starting %d: info %02x (len=%d tms=%d read_tdo=%d): ",
1429 seq, pos, info, len, info & DAP_JTAG_SEQ_TMS, info & DAP_JTAG_SEQ_TDO);
1430 for (int i = 0; i < DIV_ROUND_UP(len, 8); ++i)
1431 printf(" %02x", cmd[pos+i]);
1432 pos += DIV_ROUND_UP(len, 8);
1435 if (pos != cmdlen) {
1436 printf("BUFFER LENGTH MISMATCH looks like %d but %d specified", pos, cmdlen);
1443 LOG_DEBUG("unknown cmsis-dap command %02x", cmd[1]);
1449 static void cmsis_dap_flush(void)
1451 if (!queued_seq_count)
1454 LOG_DEBUG_IO("Flushing %d queued sequences (%d bytes) with %d pending scan results to capture",
1455 queued_seq_count, queued_seq_buf_end, pending_scan_result_count);
1457 /* prepare CMSIS-DAP packet */
1458 uint8_t *command = cmsis_dap_handle->command;
1459 command[0] = CMD_DAP_JTAG_SEQ;
1460 command[1] = queued_seq_count;
1461 memcpy(&command[2], queued_seq_buf, queued_seq_buf_end);
1463 #ifdef CMSIS_DAP_JTAG_DEBUG
1464 debug_parse_cmsis_buf(command, queued_seq_buf_end + 2);
1467 /* send command to USB device */
1468 int retval = cmsis_dap_xfer(cmsis_dap_handle, queued_seq_buf_end + 2);
1470 uint8_t *resp = cmsis_dap_handle->response;
1471 if (retval != ERROR_OK || resp[1] != DAP_OK) {
1472 LOG_ERROR("CMSIS-DAP command CMD_DAP_JTAG_SEQ failed.");
1476 #ifdef CMSIS_DAP_JTAG_DEBUG
1477 LOG_DEBUG_IO("USB response buf:");
1478 for (int c = 0; c < queued_seq_buf_end + 3; ++c)
1479 printf("%02X ", resp[c]);
1483 /* copy scan results into client buffers */
1484 for (int i = 0; i < pending_scan_result_count; ++i) {
1485 struct pending_scan_result *scan = &pending_scan_results[i];
1486 LOG_DEBUG_IO("Copying pending_scan_result %d/%d: %d bits from byte %d -> buffer + %d bits",
1487 i, pending_scan_result_count, scan->length, scan->first + 2, scan->buffer_offset);
1488 #ifdef CMSIS_DAP_JTAG_DEBUG
1489 for (uint32_t b = 0; b < DIV_ROUND_UP(scan->length, 8); ++b)
1490 printf("%02X ", resp[2+scan->first+b]);
1493 bit_copy(scan->buffer, scan->buffer_offset, &resp[2 + scan->first], 0, scan->length);
1497 queued_seq_count = 0;
1498 queued_seq_buf_end = 0;
1499 queued_seq_tdo_ptr = 0;
1500 pending_scan_result_count = 0;
1503 /* queue a sequence of bits to clock out TDI / in TDO, executing if the buffer is full.
1505 * sequence=NULL means clock out zeros on TDI
1506 * tdo_buffer=NULL means don't capture TDO
1508 static void cmsis_dap_add_jtag_sequence(int s_len, const uint8_t *sequence, int s_offset,
1509 bool tms, uint8_t *tdo_buffer, int tdo_buffer_offset)
1511 LOG_DEBUG_IO("[at %d] %d bits, tms %s, seq offset %d, tdo buf %p, tdo offset %d",
1513 s_len, tms ? "HIGH" : "LOW", s_offset, tdo_buffer, tdo_buffer_offset);
1519 LOG_DEBUG_IO("START JTAG SEQ SPLIT");
1520 for (int offset = 0; offset < s_len; offset += 64) {
1521 int len = s_len - offset;
1524 LOG_DEBUG_IO("Splitting long jtag sequence: %d-bit chunk starting at offset %d", len, offset);
1525 cmsis_dap_add_jtag_sequence(
1531 !tdo_buffer ? 0 : (tdo_buffer_offset + offset)
1534 LOG_DEBUG_IO("END JTAG SEQ SPLIT");
1538 int cmd_len = 1 + DIV_ROUND_UP(s_len, 8);
1539 if (queued_seq_count >= 255 || queued_seq_buf_end + cmd_len > QUEUED_SEQ_BUF_LEN)
1540 /* empty out the buffer */
1546 queued_seq_buf[queued_seq_buf_end] =
1547 (tms ? DAP_JTAG_SEQ_TMS : 0) |
1548 (tdo_buffer ? DAP_JTAG_SEQ_TDO : 0) |
1549 (s_len == 64 ? 0 : s_len);
1552 bit_copy(&queued_seq_buf[queued_seq_buf_end + 1], 0, sequence, s_offset, s_len);
1554 memset(&queued_seq_buf[queued_seq_buf_end + 1], 0, DIV_ROUND_UP(s_len, 8));
1556 queued_seq_buf_end += cmd_len;
1559 struct pending_scan_result *scan = &pending_scan_results[pending_scan_result_count++];
1560 scan->first = queued_seq_tdo_ptr;
1561 queued_seq_tdo_ptr += DIV_ROUND_UP(s_len, 8);
1562 scan->length = s_len;
1563 scan->buffer = tdo_buffer;
1564 scan->buffer_offset = tdo_buffer_offset;
1568 /* queue a sequence of bits to clock out TMS, executing if the buffer is full */
1569 static void cmsis_dap_add_tms_sequence(const uint8_t *sequence, int s_len)
1571 LOG_DEBUG_IO("%d bits: %02X", s_len, *sequence);
1572 /* we use a series of CMD_DAP_JTAG_SEQ commands to toggle TMS,
1573 because even though it seems ridiculously inefficient, it
1574 allows us to combine TMS and scan sequences into the same
1576 /* TODO: combine runs of the same tms value */
1577 for (int i = 0; i < s_len; ++i) {
1578 bool bit = (sequence[i / 8] & (1 << (i % 8))) != 0;
1579 cmsis_dap_add_jtag_sequence(1, NULL, 0, bit, NULL, 0);
1583 /* Move to the end state by queuing a sequence to clock into TMS */
1584 static void cmsis_dap_state_move(void)
1586 uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
1587 uint8_t tms_scan_bits = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1589 LOG_DEBUG_IO("state move from %s to %s: %d clocks, %02X on tms",
1590 tap_state_name(tap_get_state()), tap_state_name(tap_get_end_state()),
1591 tms_scan_bits, tms_scan);
1592 cmsis_dap_add_tms_sequence(&tms_scan, tms_scan_bits);
1594 tap_set_state(tap_get_end_state());
1598 /* Execute a JTAG scan operation by queueing TMS and TDI/TDO sequences */
1599 static void cmsis_dap_execute_scan(struct jtag_command *cmd)
1601 LOG_DEBUG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN",
1602 jtag_scan_type(cmd->cmd.scan));
1604 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
1605 while (cmd->cmd.scan->num_fields > 0
1606 && cmd->cmd.scan->fields[cmd->cmd.scan->num_fields - 1].num_bits == 0) {
1607 cmd->cmd.scan->num_fields--;
1608 LOG_DEBUG("discarding trailing empty field");
1611 if (cmd->cmd.scan->num_fields == 0) {
1612 LOG_DEBUG("empty scan, doing nothing");
1616 if (cmd->cmd.scan->ir_scan) {
1617 if (tap_get_state() != TAP_IRSHIFT) {
1618 cmsis_dap_end_state(TAP_IRSHIFT);
1619 cmsis_dap_state_move();
1622 if (tap_get_state() != TAP_DRSHIFT) {
1623 cmsis_dap_end_state(TAP_DRSHIFT);
1624 cmsis_dap_state_move();
1628 cmsis_dap_end_state(cmd->cmd.scan->end_state);
1630 struct scan_field *field = cmd->cmd.scan->fields;
1631 unsigned scan_size = 0;
1633 for (int i = 0; i < cmd->cmd.scan->num_fields; i++, field++) {
1634 scan_size += field->num_bits;
1635 LOG_DEBUG_IO("%s%s field %d/%d %d bits",
1636 field->in_value ? "in" : "",
1637 field->out_value ? "out" : "",
1639 cmd->cmd.scan->num_fields,
1642 if (i == cmd->cmd.scan->num_fields - 1 && tap_get_state() != tap_get_end_state()) {
1643 LOG_DEBUG_IO("Last field and have to move out of SHIFT state");
1644 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
1645 * movement. This last field can't have length zero, it was checked above. */
1646 cmsis_dap_add_jtag_sequence(
1647 field->num_bits - 1, /* number of bits to clock */
1648 field->out_value, /* output sequence */
1649 0, /* output offset */
1650 false, /* TMS low */
1654 /* Clock the last bit out, with TMS high */
1655 uint8_t last_bit = 0;
1656 if (field->out_value)
1657 bit_copy(&last_bit, 0, field->out_value, field->num_bits - 1, 1);
1658 cmsis_dap_add_jtag_sequence(
1664 field->num_bits - 1);
1665 tap_set_state(tap_state_transition(tap_get_state(), 1));
1667 /* Now clock one more cycle, with TMS low, to get us into a PAUSE state */
1668 cmsis_dap_add_jtag_sequence(
1675 tap_set_state(tap_state_transition(tap_get_state(), 0));
1677 LOG_DEBUG_IO("Internal field, staying in SHIFT state afterwards");
1678 /* Clocking part of a sequence into DR or IR with TMS=0,
1679 leaving TMS=0 at the end so we can continue later */
1680 cmsis_dap_add_jtag_sequence(
1690 if (tap_get_state() != tap_get_end_state()) {
1691 cmsis_dap_end_state(tap_get_end_state());
1692 cmsis_dap_state_move();
1695 LOG_DEBUG_IO("%s scan, %i bits, end in %s",
1696 (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1697 tap_state_name(tap_get_end_state()));
1700 static void cmsis_dap_pathmove(int num_states, tap_state_t *path)
1702 uint8_t tms0 = 0x00;
1703 uint8_t tms1 = 0xff;
1705 for (int i = 0; i < num_states; i++) {
1706 if (path[i] == tap_state_transition(tap_get_state(), false))
1707 cmsis_dap_add_tms_sequence(&tms0, 1);
1708 else if (path[i] == tap_state_transition(tap_get_state(), true))
1709 cmsis_dap_add_tms_sequence(&tms1, 1);
1711 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition.",
1712 tap_state_name(tap_get_state()), tap_state_name(path[i]));
1716 tap_set_state(path[i]);
1719 cmsis_dap_end_state(tap_get_state());
1722 static void cmsis_dap_execute_pathmove(struct jtag_command *cmd)
1724 LOG_DEBUG_IO("pathmove: %i states, end in %i",
1725 cmd->cmd.pathmove->num_states,
1726 cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
1728 cmsis_dap_pathmove(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path);
1731 static void cmsis_dap_stableclocks(int num_cycles)
1733 uint8_t tms = tap_get_state() == TAP_RESET;
1734 /* TODO: Perform optimizations? */
1735 /* Execute num_cycles. */
1736 for (int i = 0; i < num_cycles; i++)
1737 cmsis_dap_add_tms_sequence(&tms, 1);
1740 static void cmsis_dap_runtest(int num_cycles)
1742 tap_state_t saved_end_state = tap_get_end_state();
1744 /* Only do a state_move when we're not already in IDLE. */
1745 if (tap_get_state() != TAP_IDLE) {
1746 cmsis_dap_end_state(TAP_IDLE);
1747 cmsis_dap_state_move();
1749 cmsis_dap_stableclocks(num_cycles);
1751 /* Finish in end_state. */
1752 cmsis_dap_end_state(saved_end_state);
1754 if (tap_get_state() != tap_get_end_state())
1755 cmsis_dap_state_move();
1758 static void cmsis_dap_execute_runtest(struct jtag_command *cmd)
1760 LOG_DEBUG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles,
1761 cmd->cmd.runtest->end_state);
1763 cmsis_dap_end_state(cmd->cmd.runtest->end_state);
1764 cmsis_dap_runtest(cmd->cmd.runtest->num_cycles);
1767 static void cmsis_dap_execute_stableclocks(struct jtag_command *cmd)
1769 LOG_DEBUG_IO("stableclocks %i cycles", cmd->cmd.runtest->num_cycles);
1770 cmsis_dap_stableclocks(cmd->cmd.runtest->num_cycles);
1773 static void cmsis_dap_execute_tms(struct jtag_command *cmd)
1775 LOG_DEBUG_IO("TMS: %d bits", cmd->cmd.tms->num_bits);
1776 cmsis_dap_cmd_dap_swj_sequence(cmd->cmd.tms->num_bits, cmd->cmd.tms->bits);
1779 /* TODO: Is there need to call cmsis_dap_flush() for the JTAG_PATHMOVE,
1780 * JTAG_RUNTEST, JTAG_STABLECLOCKS? */
1781 static void cmsis_dap_execute_command(struct jtag_command *cmd)
1783 switch (cmd->type) {
1786 cmsis_dap_execute_sleep(cmd);
1788 case JTAG_TLR_RESET:
1790 cmsis_dap_execute_tlr_reset(cmd);
1793 cmsis_dap_execute_scan(cmd);
1796 cmsis_dap_execute_pathmove(cmd);
1799 cmsis_dap_execute_runtest(cmd);
1801 case JTAG_STABLECLOCKS:
1802 cmsis_dap_execute_stableclocks(cmd);
1805 cmsis_dap_execute_tms(cmd);
1808 LOG_ERROR("BUG: unknown JTAG command type 0x%X encountered", cmd->type);
1813 static int cmsis_dap_execute_queue(void)
1815 struct jtag_command *cmd = jtag_command_queue;
1818 cmsis_dap_execute_command(cmd);
1827 static int cmsis_dap_speed(int speed)
1830 LOG_ERROR("RTCK not supported. Set nonzero \"adapter speed\".");
1831 return ERROR_JTAG_NOT_IMPLEMENTED;
1834 return cmsis_dap_cmd_dap_swj_clock(speed);
1837 static int cmsis_dap_speed_div(int speed, int *khz)
1843 static int cmsis_dap_khz(int khz, int *jtag_speed)
1849 static bool calculate_swo_prescaler(unsigned int traceclkin_freq,
1850 uint32_t trace_freq, uint16_t *prescaler)
1852 unsigned int presc = (traceclkin_freq + trace_freq / 2) / trace_freq;
1853 if (presc == 0 || presc > TPIU_ACPR_MAX_SWOSCALER + 1)
1856 /* Probe's UART speed must be within 3% of the TPIU's SWO baud rate. */
1857 unsigned int max_deviation = (traceclkin_freq * 3) / 100;
1858 if (presc * trace_freq < traceclkin_freq - max_deviation ||
1859 presc * trace_freq > traceclkin_freq + max_deviation)
1868 * @see adapter_driver::config_trace
1870 static int cmsis_dap_config_trace(
1872 enum tpiu_pin_protocol pin_protocol,
1874 unsigned int *swo_freq,
1875 unsigned int traceclkin_hz,
1876 uint16_t *swo_prescaler)
1880 if (!trace_enabled) {
1881 if (cmsis_dap_handle->trace_enabled) {
1882 retval = cmsis_dap_cmd_dap_swo_control(DAP_SWO_CONTROL_STOP);
1883 if (retval != ERROR_OK) {
1884 LOG_ERROR("Failed to disable the SWO-trace.");
1888 cmsis_dap_handle->trace_enabled = false;
1889 LOG_INFO("SWO-trace disabled.");
1893 if (!(cmsis_dap_handle->caps & INFO_CAPS_SWO_UART) &&
1894 !(cmsis_dap_handle->caps & INFO_CAPS_SWO_MANCHESTER)) {
1895 LOG_ERROR("SWO-trace is not supported by the device.");
1900 if (pin_protocol == TPIU_PIN_PROTOCOL_ASYNC_UART &&
1901 (cmsis_dap_handle->caps & INFO_CAPS_SWO_UART)) {
1902 swo_mode = DAP_SWO_MODE_UART;
1903 } else if (pin_protocol == TPIU_PIN_PROTOCOL_ASYNC_MANCHESTER &&
1904 (cmsis_dap_handle->caps & INFO_CAPS_SWO_MANCHESTER)) {
1905 swo_mode = DAP_SWO_MODE_MANCHESTER;
1907 LOG_ERROR("Selected pin protocol is not supported.");
1911 if (*swo_freq == 0) {
1912 LOG_INFO("SWO-trace frequency autodetection not implemented.");
1916 retval = cmsis_dap_cmd_dap_swo_control(DAP_SWO_CONTROL_STOP);
1917 if (retval != ERROR_OK)
1920 cmsis_dap_handle->trace_enabled = false;
1922 retval = cmsis_dap_get_swo_buf_sz(&cmsis_dap_handle->swo_buf_sz);
1923 if (retval != ERROR_OK)
1926 retval = cmsis_dap_cmd_dap_swo_transport(DAP_SWO_TRANSPORT_DATA);
1927 if (retval != ERROR_OK)
1930 retval = cmsis_dap_cmd_dap_swo_mode(swo_mode);
1931 if (retval != ERROR_OK)
1934 retval = cmsis_dap_cmd_dap_swo_baudrate(*swo_freq, swo_freq);
1935 if (retval != ERROR_OK)
1938 if (!calculate_swo_prescaler(traceclkin_hz, *swo_freq,
1940 LOG_ERROR("SWO frequency is not suitable. Please choose a "
1941 "different frequency or use auto-detection.");
1945 LOG_INFO("SWO frequency: %u Hz.", *swo_freq);
1946 LOG_INFO("SWO prescaler: %u.", *swo_prescaler);
1948 retval = cmsis_dap_cmd_dap_swo_control(DAP_SWO_CONTROL_START);
1949 if (retval != ERROR_OK)
1952 cmsis_dap_handle->trace_enabled = true;
1958 * @see adapter_driver::poll_trace
1960 static int cmsis_dap_poll_trace(uint8_t *buf, size_t *size)
1962 uint8_t trace_status;
1965 if (!cmsis_dap_handle->trace_enabled) {
1970 int retval = cmsis_dap_cmd_dap_swo_status(&trace_status, &trace_count);
1971 if (retval != ERROR_OK)
1973 if ((trace_status & DAP_SWO_STATUS_CAPTURE_MASK) != DAP_SWO_STATUS_CAPTURE_ACTIVE)
1976 *size = trace_count < *size ? trace_count : *size;
1977 size_t read_so_far = 0;
1980 uint32_t packet_size = cmsis_dap_handle->packet_size - 4 /*data-reply*/;
1981 uint32_t remaining = *size - read_so_far;
1982 if (remaining < packet_size)
1983 packet_size = remaining;
1984 retval = cmsis_dap_cmd_dap_swo_data(
1989 if (retval != ERROR_OK)
1991 if ((trace_status & DAP_SWO_STATUS_CAPTURE_MASK) != DAP_SWO_STATUS_CAPTURE_ACTIVE)
1995 } while (read_so_far < *size);
2000 COMMAND_HANDLER(cmsis_dap_handle_info_command)
2002 if (cmsis_dap_get_version_info() == ERROR_OK)
2003 cmsis_dap_get_status();
2008 COMMAND_HANDLER(cmsis_dap_handle_cmd_command)
2010 uint8_t *command = cmsis_dap_handle->command;
2012 for (unsigned i = 0; i < CMD_ARGC; i++)
2013 COMMAND_PARSE_NUMBER(u8, CMD_ARGV[i], command[i]);
2015 int retval = cmsis_dap_xfer(cmsis_dap_handle, CMD_ARGC);
2017 if (retval != ERROR_OK) {
2018 LOG_ERROR("CMSIS-DAP command failed.");
2019 return ERROR_JTAG_DEVICE_ERROR;
2022 uint8_t *resp = cmsis_dap_handle->response;
2023 LOG_INFO("Returned data %02" PRIx8 " %02" PRIx8 " %02" PRIx8 " %02" PRIx8,
2024 resp[1], resp[2], resp[3], resp[4]);
2029 COMMAND_HANDLER(cmsis_dap_handle_vid_pid_command)
2031 if (CMD_ARGC > MAX_USB_IDS * 2) {
2032 LOG_WARNING("ignoring extra IDs in cmsis_dap_vid_pid "
2033 "(maximum is %d pairs)", MAX_USB_IDS);
2034 CMD_ARGC = MAX_USB_IDS * 2;
2036 if (CMD_ARGC < 2 || (CMD_ARGC & 1)) {
2037 LOG_WARNING("incomplete cmsis_dap_vid_pid configuration directive");
2039 return ERROR_COMMAND_SYNTAX_ERROR;
2040 /* remove the incomplete trailing id */
2045 for (i = 0; i < CMD_ARGC; i += 2) {
2046 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i], cmsis_dap_vid[i >> 1]);
2047 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], cmsis_dap_pid[i >> 1]);
2051 * Explicitly terminate, in case there are multiples instances of
2052 * cmsis_dap_vid_pid.
2054 cmsis_dap_vid[i >> 1] = cmsis_dap_pid[i >> 1] = 0;
2059 COMMAND_HANDLER(cmsis_dap_handle_serial_command)
2062 cmsis_dap_serial = strdup(CMD_ARGV[0]);
2064 LOG_ERROR("expected exactly one argument to cmsis_dap_serial <serial-number>");
2069 COMMAND_HANDLER(cmsis_dap_handle_backend_command)
2071 if (CMD_ARGC == 1) {
2072 if (strcmp(CMD_ARGV[0], "auto") == 0) {
2073 cmsis_dap_backend = -1; /* autoselect */
2075 for (unsigned int i = 0; i < ARRAY_SIZE(cmsis_dap_backends); i++) {
2076 if (strcasecmp(cmsis_dap_backends[i]->name, CMD_ARGV[0]) == 0) {
2077 cmsis_dap_backend = i;
2082 LOG_ERROR("invalid backend argument to cmsis_dap_backend <backend>");
2085 LOG_ERROR("expected exactly one argument to cmsis_dap_backend <backend>");
2091 static const struct command_registration cmsis_dap_subcommand_handlers[] = {
2094 .handler = &cmsis_dap_handle_info_command,
2095 .mode = COMMAND_EXEC,
2097 .help = "show cmsis-dap info",
2101 .handler = &cmsis_dap_handle_cmd_command,
2102 .mode = COMMAND_EXEC,
2104 .help = "issue cmsis-dap command",
2106 COMMAND_REGISTRATION_DONE
2110 static const struct command_registration cmsis_dap_command_handlers[] = {
2112 .name = "cmsis-dap",
2113 .mode = COMMAND_ANY,
2114 .help = "perform CMSIS-DAP management",
2116 .chain = cmsis_dap_subcommand_handlers,
2119 .name = "cmsis_dap_vid_pid",
2120 .handler = &cmsis_dap_handle_vid_pid_command,
2121 .mode = COMMAND_CONFIG,
2122 .help = "the vendor ID and product ID of the CMSIS-DAP device",
2123 .usage = "(vid pid)*",
2126 .name = "cmsis_dap_serial",
2127 .handler = &cmsis_dap_handle_serial_command,
2128 .mode = COMMAND_CONFIG,
2129 .help = "set the serial number of the adapter",
2130 .usage = "serial_string",
2133 .name = "cmsis_dap_backend",
2134 .handler = &cmsis_dap_handle_backend_command,
2135 .mode = COMMAND_CONFIG,
2136 .help = "set the communication backend to use (USB bulk or HID).",
2137 .usage = "(auto | usb_bulk | hid)",
2139 #if BUILD_CMSIS_DAP_USB
2141 .name = "cmsis_dap_usb",
2142 .chain = cmsis_dap_usb_subcommand_handlers,
2143 .mode = COMMAND_ANY,
2144 .help = "USB bulk backend-specific commands",
2148 COMMAND_REGISTRATION_DONE
2151 static const struct swd_driver cmsis_dap_swd_driver = {
2152 .init = cmsis_dap_swd_init,
2153 .switch_seq = cmsis_dap_swd_switch_seq,
2154 .read_reg = cmsis_dap_swd_read_reg,
2155 .write_reg = cmsis_dap_swd_write_reg,
2156 .run = cmsis_dap_swd_run_queue,
2159 static const char * const cmsis_dap_transport[] = { "swd", "jtag", NULL };
2161 static struct jtag_interface cmsis_dap_interface = {
2162 .supported = DEBUG_CAP_TMS_SEQ,
2163 .execute_queue = cmsis_dap_execute_queue,
2166 struct adapter_driver cmsis_dap_adapter_driver = {
2167 .name = "cmsis-dap",
2168 .transports = cmsis_dap_transport,
2169 .commands = cmsis_dap_command_handlers,
2171 .init = cmsis_dap_init,
2172 .quit = cmsis_dap_quit,
2173 .reset = cmsis_dap_reset,
2174 .speed = cmsis_dap_speed,
2175 .khz = cmsis_dap_khz,
2176 .speed_div = cmsis_dap_speed_div,
2177 .config_trace = cmsis_dap_config_trace,
2178 .poll_trace = cmsis_dap_poll_trace,
2180 .jtag_ops = &cmsis_dap_interface,
2181 .swd_ops = &cmsis_dap_swd_driver,