1 // SPDX-License-Identifier: GPL-2.0-or-later
3 /***************************************************************************
4 * Copyright (C) 2021 by Adrian Negreanu *
7 * Copyright (C) 2018 by Mickaƫl Thomas *
10 * Copyright (C) 2016 by Maksym Hilliaka *
11 * oter@frozen-team.com *
13 * Copyright (C) 2016 by Phillip Pearson *
16 * Copyright (C) 2014 by Paul Fertser *
17 * fercerpav@gmail.com *
19 * Copyright (C) 2013 by mike brown *
20 * mike@theshedworks.org.uk *
22 * Copyright (C) 2013 by Spencer Oliver *
23 * spen@spen-soft.co.uk *
24 ***************************************************************************/
30 #include <transport/transport.h>
31 #include "helper/replacements.h"
32 #include <jtag/adapter.h>
34 #include <jtag/interface.h>
35 #include <jtag/commands.h>
37 #include <target/cortex_m.h>
39 #include "cmsis_dap.h"
40 #include "libusb_helper.h"
42 static const struct cmsis_dap_backend
*const cmsis_dap_backends
[] = {
43 #if BUILD_CMSIS_DAP_USB == 1
44 &cmsis_dap_usb_backend
,
47 #if BUILD_CMSIS_DAP_HID == 1
48 &cmsis_dap_hid_backend
,
54 /* Known vid/pid pairs:
55 * VID 0xc251: Keil Software
56 * PID 0xf001: LPC-Link-II CMSIS_DAP
57 * PID 0xf002: OPEN-SDA CMSIS_DAP (Freedom Board)
58 * PID 0x2722: Keil ULINK2 CMSIS-DAP
59 * PID 0x2750: Keil ULINKplus CMSIS-DAP
61 * VID 0x0d28: mbed Software
62 * PID 0x0204: MBED CMSIS-DAP
66 /* vid = pid = 0 marks the end of the list */
67 static uint16_t cmsis_dap_vid
[MAX_USB_IDS
+ 1] = { 0 };
68 static uint16_t cmsis_dap_pid
[MAX_USB_IDS
+ 1] = { 0 };
69 static int cmsis_dap_backend
= -1;
72 /* CMSIS-DAP General Commands */
73 #define CMD_DAP_INFO 0x00
74 #define CMD_DAP_LED 0x01
75 #define CMD_DAP_CONNECT 0x02
76 #define CMD_DAP_DISCONNECT 0x03
77 #define CMD_DAP_WRITE_ABORT 0x08
78 #define CMD_DAP_DELAY 0x09
79 #define CMD_DAP_RESET_TARGET 0x0A
82 #define INFO_ID_VENDOR 0x01 /* string */
83 #define INFO_ID_PRODUCT 0x02 /* string */
84 #define INFO_ID_SERNUM 0x03 /* string */
85 #define INFO_ID_FW_VER 0x04 /* string */
86 #define INFO_ID_TD_VEND 0x05 /* string */
87 #define INFO_ID_TD_NAME 0x06 /* string */
88 #define INFO_ID_CAPS 0xf0 /* byte */
89 #define INFO_ID_PKT_CNT 0xfe /* byte */
90 #define INFO_ID_PKT_SZ 0xff /* short */
91 #define INFO_ID_SWO_BUF_SZ 0xfd /* word */
93 #define INFO_CAPS_SWD BIT(0)
94 #define INFO_CAPS_JTAG BIT(1)
95 #define INFO_CAPS_SWO_UART BIT(2)
96 #define INFO_CAPS_SWO_MANCHESTER BIT(3)
97 #define INFO_CAPS_ATOMIC_CMDS BIT(4)
98 #define INFO_CAPS_TEST_DOMAIN_TIMER BIT(5)
99 #define INFO_CAPS_SWO_STREAMING_TRACE BIT(6)
100 #define INFO_CAPS_UART_PORT BIT(7)
101 #define INFO_CAPS_USB_COM_PORT BIT(8)
102 #define INFO_CAPS__NUM_CAPS 9
105 #define LED_ID_CONNECT 0x00
106 #define LED_ID_RUN 0x01
112 #define CONNECT_DEFAULT 0x00
113 #define CONNECT_SWD 0x01
114 #define CONNECT_JTAG 0x02
116 /* CMSIS-DAP Common SWD/JTAG Commands */
117 #define CMD_DAP_DELAY 0x09
118 #define CMD_DAP_SWJ_PINS 0x10
119 #define CMD_DAP_SWJ_CLOCK 0x11
120 #define CMD_DAP_SWJ_SEQ 0x12
132 #define SWJ_PIN_TCK (1<<0)
133 #define SWJ_PIN_TMS (1<<1)
134 #define SWJ_PIN_TDI (1<<2)
135 #define SWJ_PIN_TDO (1<<3)
136 #define SWJ_PIN_TRST (1<<5)
137 #define SWJ_PIN_SRST (1<<7)
139 /* CMSIS-DAP SWD Commands */
140 #define CMD_DAP_SWD_CONFIGURE 0x13
141 #define CMD_DAP_SWD_SEQUENCE 0x1D
143 /* CMSIS-DAP JTAG Commands */
144 #define CMD_DAP_JTAG_SEQ 0x14
145 #define CMD_DAP_JTAG_CONFIGURE 0x15
146 #define CMD_DAP_JTAG_IDCODE 0x16
148 /* CMSIS-DAP JTAG sequence info masks */
149 /* Number of bits to clock through (0 means 64) */
150 #define DAP_JTAG_SEQ_TCK 0x3F
151 /* TMS will be set during the sequence if this bit is set */
152 #define DAP_JTAG_SEQ_TMS 0x40
153 /* TDO output will be captured if this bit is set */
154 #define DAP_JTAG_SEQ_TDO 0x80
157 /* CMSIS-DAP Transfer Commands */
158 #define CMD_DAP_TFER_CONFIGURE 0x04
159 #define CMD_DAP_TFER 0x05
160 #define CMD_DAP_TFER_BLOCK 0x06
161 #define CMD_DAP_TFER_ABORT 0x07
163 /* DAP_TransferBlock increases the sum of command/response sizes
164 * (due to 16-bit Transfer Count) if used in a small packet.
165 * Prevent using it until we have at least r/w operations. */
166 #define CMD_DAP_TFER_BLOCK_MIN_OPS 4
168 /* DAP Status Code */
170 #define DAP_ERROR 0xFF
172 /* CMSIS-DAP SWO Commands */
173 #define CMD_DAP_SWO_TRANSPORT 0x17
174 #define CMD_DAP_SWO_MODE 0x18
175 #define CMD_DAP_SWO_BAUDRATE 0x19
176 #define CMD_DAP_SWO_CONTROL 0x1A
177 #define CMD_DAP_SWO_STATUS 0x1B
178 #define CMD_DAP_SWO_DATA 0x1C
179 #define CMD_DAP_SWO_EX_STATUS 0x1E
181 /* SWO transport mode for reading trace data */
182 #define DAP_SWO_TRANSPORT_NONE 0
183 #define DAP_SWO_TRANSPORT_DATA 1
184 #define DAP_SWO_TRANSPORT_WINUSB 2
186 /* SWO trace capture mode */
187 #define DAP_SWO_MODE_OFF 0
188 #define DAP_SWO_MODE_UART 1
189 #define DAP_SWO_MODE_MANCHESTER 2
191 /* SWO trace data capture */
192 #define DAP_SWO_CONTROL_STOP 0
193 #define DAP_SWO_CONTROL_START 1
195 /* SWO trace status */
196 #define DAP_SWO_STATUS_CAPTURE_INACTIVE 0
197 #define DAP_SWO_STATUS_CAPTURE_ACTIVE 1
198 #define DAP_SWO_STATUS_CAPTURE_MASK BIT(0)
199 #define DAP_SWO_STATUS_STREAM_ERROR_MASK BIT(6)
200 #define DAP_SWO_STATUS_BUFFER_OVERRUN_MASK BIT(7)
202 /* CMSIS-DAP Vendor Commands
205 static const char * const info_caps_str
[INFO_CAPS__NUM_CAPS
] = {
208 "SWO-UART supported",
209 "SWO-MANCHESTER supported",
210 "Atomic commands supported",
211 "Test domain timer supported",
212 "SWO streaming trace supported",
213 "UART communication port supported",
214 "UART via USB COM port supported",
217 struct pending_scan_result
{
218 /** Offset in bytes in the CMD_DAP_JTAG_SEQ response buffer. */
220 /** Number of bits to read. */
222 /** Location to store the result */
224 /** Offset in the destination buffer */
225 unsigned int buffer_offset
;
228 /* Each block in FIFO can contain up to pending_queue_len transfers */
229 static unsigned int pending_queue_len
;
230 static unsigned int tfer_max_command_size
;
231 static unsigned int tfer_max_response_size
;
233 /* pointers to buffers that will receive jtag scan results on the next flush */
234 #define MAX_PENDING_SCAN_RESULTS 256
235 static int pending_scan_result_count
;
236 static struct pending_scan_result pending_scan_results
[MAX_PENDING_SCAN_RESULTS
];
238 /* queued JTAG sequences that will be executed on the next flush */
239 #define QUEUED_SEQ_BUF_LEN (cmsis_dap_handle->packet_usable_size - 3)
240 static int queued_seq_count
;
241 static int queued_seq_buf_end
;
242 static int queued_seq_tdo_ptr
;
243 static uint8_t queued_seq_buf
[1024]; /* TODO: make dynamic / move into cmsis object */
245 static int queued_retval
;
247 static uint8_t output_pins
= SWJ_PIN_SRST
| SWJ_PIN_TRST
;
249 static struct cmsis_dap
*cmsis_dap_handle
;
252 static int cmsis_dap_quit(void);
254 static int cmsis_dap_open(void)
256 const struct cmsis_dap_backend
*backend
= NULL
;
258 struct cmsis_dap
*dap
= calloc(1, sizeof(struct cmsis_dap
));
260 LOG_ERROR("unable to allocate memory");
264 if (cmsis_dap_backend
>= 0) {
265 /* Use forced backend */
266 backend
= cmsis_dap_backends
[cmsis_dap_backend
];
267 if (backend
->open(dap
, cmsis_dap_vid
, cmsis_dap_pid
, adapter_get_required_serial()) != ERROR_OK
)
270 /* Try all backends */
271 for (unsigned int i
= 0; i
< ARRAY_SIZE(cmsis_dap_backends
); i
++) {
272 backend
= cmsis_dap_backends
[i
];
273 if (backend
->open(dap
, cmsis_dap_vid
, cmsis_dap_pid
, adapter_get_required_serial()) == ERROR_OK
)
281 LOG_ERROR("unable to find a matching CMSIS-DAP device");
286 dap
->backend
= backend
;
288 cmsis_dap_handle
= dap
;
293 static void cmsis_dap_close(struct cmsis_dap
*dap
)
296 dap
->backend
->close(dap
);
300 free(dap
->packet_buffer
);
302 for (unsigned int i
= 0; i
< MAX_PENDING_REQUESTS
; i
++) {
303 free(dap
->pending_fifo
[i
].transfers
);
304 dap
->pending_fifo
[i
].transfers
= NULL
;
307 free(cmsis_dap_handle
);
308 cmsis_dap_handle
= NULL
;
311 static void cmsis_dap_flush_read(struct cmsis_dap
*dap
)
314 /* Some CMSIS-DAP adapters keep buffered packets over
315 * USB close/open so we need to flush up to 64 old packets
316 * to be sure all buffers are empty */
317 for (i
= 0; i
< 64; i
++) {
318 int retval
= dap
->backend
->read(dap
, 10);
319 if (retval
== ERROR_TIMEOUT_REACHED
)
323 LOG_DEBUG("Flushed %u packets", i
);
326 /* Send a message and receive the reply */
327 static int cmsis_dap_xfer(struct cmsis_dap
*dap
, int txlen
)
329 if (dap
->pending_fifo_block_count
) {
330 LOG_ERROR("pending %u blocks, flushing", dap
->pending_fifo_block_count
);
331 while (dap
->pending_fifo_block_count
) {
332 dap
->backend
->read(dap
, 10);
333 dap
->pending_fifo_block_count
--;
335 dap
->pending_fifo_put_idx
= 0;
336 dap
->pending_fifo_get_idx
= 0;
339 uint8_t current_cmd
= dap
->command
[0];
340 int retval
= dap
->backend
->write(dap
, txlen
, LIBUSB_TIMEOUT_MS
);
345 retval
= dap
->backend
->read(dap
, LIBUSB_TIMEOUT_MS
);
349 uint8_t *resp
= dap
->response
;
350 if (resp
[0] == DAP_ERROR
) {
351 LOG_ERROR("CMSIS-DAP command 0x%" PRIx8
" not implemented", current_cmd
);
352 return ERROR_NOT_IMPLEMENTED
;
355 if (resp
[0] != current_cmd
) {
356 LOG_ERROR("CMSIS-DAP command mismatch. Sent 0x%" PRIx8
357 " received 0x%" PRIx8
, current_cmd
, resp
[0]);
359 cmsis_dap_flush_read(dap
);
366 static int cmsis_dap_cmd_dap_swj_pins(uint8_t pins
, uint8_t mask
, uint32_t delay
, uint8_t *input
)
368 uint8_t *command
= cmsis_dap_handle
->command
;
370 command
[0] = CMD_DAP_SWJ_PINS
;
373 h_u32_to_le(&command
[3], delay
);
375 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 7);
376 if (retval
!= ERROR_OK
) {
377 LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_PINS failed.");
378 return ERROR_JTAG_DEVICE_ERROR
;
382 *input
= cmsis_dap_handle
->response
[1];
387 static int cmsis_dap_cmd_dap_swj_clock(uint32_t swj_clock
)
389 uint8_t *command
= cmsis_dap_handle
->command
;
391 /* set clock in Hz */
394 command
[0] = CMD_DAP_SWJ_CLOCK
;
395 h_u32_to_le(&command
[1], swj_clock
);
397 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 5);
398 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
399 LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_CLOCK failed.");
400 return ERROR_JTAG_DEVICE_ERROR
;
406 /* clock a sequence of bits out on TMS, to change JTAG states */
407 static int cmsis_dap_cmd_dap_swj_sequence(uint8_t s_len
, const uint8_t *sequence
)
409 uint8_t *command
= cmsis_dap_handle
->command
;
411 #ifdef CMSIS_DAP_JTAG_DEBUG
412 LOG_DEBUG("cmsis-dap TMS sequence: len=%d", s_len
);
413 for (unsigned int i
= 0; i
< DIV_ROUND_UP(s_len
, 8); ++i
)
414 printf("%02X ", sequence
[i
]);
419 command
[0] = CMD_DAP_SWJ_SEQ
;
421 bit_copy(&command
[2], 0, sequence
, 0, s_len
);
423 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 2 + DIV_ROUND_UP(s_len
, 8));
424 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
)
430 static int cmsis_dap_cmd_dap_info(uint8_t info
, uint8_t **data
)
432 uint8_t *command
= cmsis_dap_handle
->command
;
434 command
[0] = CMD_DAP_INFO
;
437 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 2);
438 if (retval
!= ERROR_OK
) {
439 LOG_ERROR("CMSIS-DAP command CMD_INFO failed.");
440 return ERROR_JTAG_DEVICE_ERROR
;
443 *data
= &cmsis_dap_handle
->response
[1];
448 static int cmsis_dap_cmd_dap_led(uint8_t led
, uint8_t state
)
450 uint8_t *command
= cmsis_dap_handle
->command
;
452 command
[0] = CMD_DAP_LED
;
456 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 3);
457 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
458 LOG_ERROR("CMSIS-DAP command CMD_LED failed.");
459 return ERROR_JTAG_DEVICE_ERROR
;
465 static int cmsis_dap_cmd_dap_connect(uint8_t mode
)
467 uint8_t *command
= cmsis_dap_handle
->command
;
469 command
[0] = CMD_DAP_CONNECT
;
472 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 2);
473 if (retval
!= ERROR_OK
) {
474 LOG_ERROR("CMSIS-DAP command CMD_CONNECT failed.");
475 return ERROR_JTAG_DEVICE_ERROR
;
478 if (cmsis_dap_handle
->response
[1] != mode
) {
479 LOG_ERROR("CMSIS-DAP failed to connect in mode (%d)", mode
);
480 return ERROR_JTAG_DEVICE_ERROR
;
486 static int cmsis_dap_cmd_dap_disconnect(void)
488 uint8_t *command
= cmsis_dap_handle
->command
;
490 command
[0] = CMD_DAP_DISCONNECT
;
492 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 1);
493 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
494 LOG_ERROR("CMSIS-DAP command CMD_DISCONNECT failed.");
495 return ERROR_JTAG_DEVICE_ERROR
;
501 static int cmsis_dap_cmd_dap_tfer_configure(uint8_t idle
, uint16_t retry_count
, uint16_t match_retry
)
503 uint8_t *command
= cmsis_dap_handle
->command
;
505 command
[0] = CMD_DAP_TFER_CONFIGURE
;
507 h_u16_to_le(&command
[2], retry_count
);
508 h_u16_to_le(&command
[4], match_retry
);
510 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 6);
511 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
512 LOG_ERROR("CMSIS-DAP command CMD_TFER_Configure failed.");
513 return ERROR_JTAG_DEVICE_ERROR
;
519 static int cmsis_dap_cmd_dap_swd_configure(uint8_t cfg
)
521 uint8_t *command
= cmsis_dap_handle
->command
;
523 command
[0] = CMD_DAP_SWD_CONFIGURE
;
526 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 2);
527 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
528 LOG_ERROR("CMSIS-DAP command CMD_SWD_Configure failed.");
529 return ERROR_JTAG_DEVICE_ERROR
;
536 static int cmsis_dap_cmd_dap_delay(uint16_t delay_us
)
538 uint8_t *command
= cmsis_dap_handle
->command
;
540 command
[0] = CMD_DAP_DELAY
;
541 h_u16_to_le(&command
[1], delay_us
);
543 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 3);
544 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
545 LOG_ERROR("CMSIS-DAP command CMD_Delay failed.");
546 return ERROR_JTAG_DEVICE_ERROR
;
553 static int cmsis_dap_metacmd_targetsel(uint32_t instance_id
)
555 uint8_t *command
= cmsis_dap_handle
->command
;
556 const uint32_t SEQ_RD
= 0x80, SEQ_WR
= 0x00;
558 /* SWD multi-drop requires a transfer ala CMD_DAP_TFER,
559 but with no expectation of an SWD ACK response. In
560 CMSIS-DAP v1.20 and v2.00, CMD_DAP_SWD_SEQUENCE was
561 added to allow this special sequence to be generated.
562 The purpose of this operation is to select the target
563 corresponding to the instance_id that is written */
565 LOG_DEBUG_IO("DP write reg TARGETSEL %" PRIx32
, instance_id
);
568 command
[idx
++] = CMD_DAP_SWD_SEQUENCE
;
569 command
[idx
++] = 3; /* sequence count */
571 /* sequence 0: packet request for TARGETSEL */
572 command
[idx
++] = SEQ_WR
| 8;
573 command
[idx
++] = SWD_CMD_START
| swd_cmd(false, false, DP_TARGETSEL
) | SWD_CMD_STOP
| SWD_CMD_PARK
;
575 /* sequence 1: read Trn ACK Trn, no expectation for target to ACK */
576 command
[idx
++] = SEQ_RD
| 5;
578 /* sequence 2: WDATA plus parity */
579 command
[idx
++] = SEQ_WR
| (32 + 1);
580 h_u32_to_le(command
+ idx
, instance_id
);
582 command
[idx
++] = parity_u32(instance_id
);
584 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, idx
);
585 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
586 LOG_ERROR("CMSIS-DAP command SWD_Sequence failed.");
587 return ERROR_JTAG_DEVICE_ERROR
;
594 * Sets the SWO transport mode.
595 * @param[in] transport The transport mode. Can be None, SWO_Data or
596 * WinUSB (requires CMSIS-DAP v2).
598 static int cmsis_dap_cmd_dap_swo_transport(uint8_t transport
)
600 uint8_t *command
= cmsis_dap_handle
->command
;
602 command
[0] = CMD_DAP_SWO_TRANSPORT
;
603 command
[1] = transport
;
605 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 2);
606 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
607 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Transport(%d) failed.", transport
);
608 return ERROR_JTAG_DEVICE_ERROR
;
615 * Sets the SWO trace capture mode.
616 * @param[in] mode Trace capture mode. Can be UART or MANCHESTER.
618 static int cmsis_dap_cmd_dap_swo_mode(uint8_t mode
)
620 uint8_t *command
= cmsis_dap_handle
->command
;
622 command
[0] = CMD_DAP_SWO_MODE
;
625 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 2);
626 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
627 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Mode(%d) failed.", mode
);
628 return ERROR_JTAG_DEVICE_ERROR
;
635 * Sets the baudrate for capturing SWO trace data.
636 * Can be called iteratively to determine supported baudrates.
637 * @param[in] in_baudrate Requested baudrate.
638 * @param[out] dev_baudrate Actual baudrate or 0 (baudrate not configured).
639 * When requested baudrate is not achievable the
640 * closest configured baudrate can be returned or
641 * 0 which indicates that baudrate was not configured.
643 static int cmsis_dap_cmd_dap_swo_baudrate(
644 uint32_t in_baudrate
,
645 uint32_t *dev_baudrate
)
647 uint8_t *command
= cmsis_dap_handle
->command
;
649 command
[0] = CMD_DAP_SWO_BAUDRATE
;
650 h_u32_to_le(&command
[1], in_baudrate
);
652 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 5);
653 uint32_t rvbr
= le_to_h_u32(&cmsis_dap_handle
->response
[1]);
654 if (retval
!= ERROR_OK
|| rvbr
== 0) {
655 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Baudrate(%u) -> %u failed.", in_baudrate
, rvbr
);
658 return ERROR_JTAG_DEVICE_ERROR
;
662 *dev_baudrate
= rvbr
;
668 * Controls the SWO trace data capture.
669 * @param[in] control Start or stop a trace. Starting capture automatically
670 * flushes any existing trace data in buffers which has
673 static int cmsis_dap_cmd_dap_swo_control(uint8_t control
)
675 uint8_t *command
= cmsis_dap_handle
->command
;
677 command
[0] = CMD_DAP_SWO_CONTROL
;
678 command
[1] = control
;
680 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 2);
681 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
682 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Control(%d) failed.", control
);
683 return ERROR_JTAG_DEVICE_ERROR
;
690 * Reads the SWO trace status.
691 * @param[out] trace_status The trace's status.
692 * Bit0: Trace Capture (1 - active, 0 - inactive).
693 * Bit6: Trace Stream Error.
694 * Bit7: Trace Buffer Overrun.
695 * @param[out] trace_count Number of bytes in Trace Buffer (not yet read).
697 static int cmsis_dap_cmd_dap_swo_status(
698 uint8_t *trace_status
,
701 uint8_t *command
= cmsis_dap_handle
->command
;
703 command
[0] = CMD_DAP_SWO_STATUS
;
705 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 1);
706 if (retval
!= ERROR_OK
) {
707 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Status failed.");
708 return ERROR_JTAG_DEVICE_ERROR
;
712 *trace_status
= cmsis_dap_handle
->response
[1];
714 *trace_count
= le_to_h_u32(&cmsis_dap_handle
->response
[2]);
720 * Reads the captured SWO trace data from Trace Buffer.
721 * @param[in] max_trace_count Maximum number of Trace Data bytes to read.
722 * @param[out] trace_status The trace's status.
723 * @param[out] trace_count Number of Trace Data bytes read.
724 * @param[out] data Trace Data bytes read.
726 static int cmsis_dap_cmd_dap_swo_data(
727 size_t max_trace_count
,
728 uint8_t *trace_status
,
732 uint8_t *command
= cmsis_dap_handle
->command
;
734 command
[0] = CMD_DAP_SWO_DATA
;
735 h_u16_to_le(&command
[1], max_trace_count
);
737 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 3);
738 if (retval
!= ERROR_OK
) {
739 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Data failed.");
740 return ERROR_JTAG_DEVICE_ERROR
;
743 *trace_status
= cmsis_dap_handle
->response
[1];
744 *trace_count
= le_to_h_u16(&cmsis_dap_handle
->response
[2]);
746 if (*trace_count
> 0)
747 memcpy(data
, &cmsis_dap_handle
->response
[4], *trace_count
);
753 static void cmsis_dap_swd_write_from_queue(struct cmsis_dap
*dap
)
755 uint8_t *command
= dap
->command
;
756 struct pending_request_block
*block
= &dap
->pending_fifo
[dap
->pending_fifo_put_idx
];
758 assert(dap
->write_count
+ dap
->read_count
== block
->transfer_count
);
760 /* Reset packet size check counters for the next packet */
761 dap
->write_count
= 0;
764 LOG_DEBUG_IO("Executing %d queued transactions from FIFO index %u%s",
765 block
->transfer_count
, dap
->pending_fifo_put_idx
,
766 cmsis_dap_handle
->swd_cmds_differ
? "" : ", same swd ops");
768 if (queued_retval
!= ERROR_OK
) {
769 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval
);
773 if (block
->transfer_count
== 0)
776 bool block_cmd
= !cmsis_dap_handle
->swd_cmds_differ
777 && block
->transfer_count
>= CMD_DAP_TFER_BLOCK_MIN_OPS
;
778 block
->command
= block_cmd
? CMD_DAP_TFER_BLOCK
: CMD_DAP_TFER
;
780 command
[0] = block
->command
;
781 command
[1] = 0x00; /* DAP Index */
785 h_u16_to_le(&command
[2], block
->transfer_count
);
786 idx
= 4; /* The first transfer will store the common DAP register */
788 command
[2] = block
->transfer_count
;
792 for (unsigned int i
= 0; i
< block
->transfer_count
; i
++) {
793 struct pending_transfer_result
*transfer
= &(block
->transfers
[i
]);
794 uint8_t cmd
= transfer
->cmd
;
795 uint32_t data
= transfer
->data
;
797 LOG_DEBUG_IO("%s %s reg %x %" PRIx32
,
798 cmd
& SWD_CMD_APNDP
? "AP" : "DP",
799 cmd
& SWD_CMD_RNW
? "read" : "write",
800 (cmd
& SWD_CMD_A32
) >> 1, data
);
802 /* When proper WAIT handling is implemented in the
803 * common SWD framework, this kludge can be
804 * removed. However, this might lead to minor
805 * performance degradation as the adapter wouldn't be
806 * able to automatically retry anything (because ARM
807 * has forgotten to implement sticky error flags
808 * clearing). See also comments regarding
809 * cmsis_dap_cmd_dap_tfer_configure() and
810 * cmsis_dap_cmd_dap_swd_configure() in
813 if (!(cmd
& SWD_CMD_RNW
) &&
814 !(cmd
& SWD_CMD_APNDP
) &&
815 (cmd
& SWD_CMD_A32
) >> 1 == DP_CTRL_STAT
&&
816 (data
& CORUNDETECT
)) {
817 LOG_DEBUG("refusing to enable sticky overrun detection");
818 data
&= ~CORUNDETECT
;
821 if (!block_cmd
|| i
== 0)
822 command
[idx
++] = (cmd
>> 1) & 0x0f;
824 if (!(cmd
& SWD_CMD_RNW
)) {
825 h_u32_to_le(&command
[idx
], data
);
830 int retval
= dap
->backend
->write(dap
, idx
, LIBUSB_TIMEOUT_MS
);
832 queued_retval
= retval
;
835 queued_retval
= ERROR_OK
;
838 dap
->pending_fifo_put_idx
= (dap
->pending_fifo_put_idx
+ 1) % dap
->packet_count
;
839 dap
->pending_fifo_block_count
++;
840 if (dap
->pending_fifo_block_count
> dap
->packet_count
)
841 LOG_ERROR("too much pending writes %u", dap
->pending_fifo_block_count
);
846 block
->transfer_count
= 0;
849 static void cmsis_dap_swd_read_process(struct cmsis_dap
*dap
, int timeout_ms
)
851 struct pending_request_block
*block
= &dap
->pending_fifo
[dap
->pending_fifo_get_idx
];
853 if (dap
->pending_fifo_block_count
== 0)
854 LOG_ERROR("no pending write");
857 int retval
= dap
->backend
->read(dap
, timeout_ms
);
858 if (retval
== ERROR_TIMEOUT_REACHED
&& timeout_ms
< LIBUSB_TIMEOUT_MS
)
862 LOG_DEBUG("error reading data");
863 queued_retval
= ERROR_FAIL
;
867 uint8_t *resp
= dap
->response
;
868 if (resp
[0] != block
->command
) {
869 LOG_ERROR("CMSIS-DAP command mismatch. Expected 0x%x received 0x%" PRIx8
,
870 block
->command
, resp
[0]);
871 queued_retval
= ERROR_FAIL
;
875 unsigned int transfer_count
;
877 if (block
->command
== CMD_DAP_TFER_BLOCK
) {
878 transfer_count
= le_to_h_u16(&resp
[1]);
881 transfer_count
= resp
[1];
884 if (resp
[idx
] & 0x08) {
885 LOG_DEBUG("CMSIS-DAP Protocol Error @ %d (wrong parity)", transfer_count
);
886 queued_retval
= ERROR_FAIL
;
889 uint8_t ack
= resp
[idx
++] & 0x07;
890 if (ack
!= SWD_ACK_OK
) {
891 LOG_DEBUG("SWD ack not OK @ %d %s", transfer_count
,
892 ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK");
893 queued_retval
= ack
== SWD_ACK_WAIT
? ERROR_WAIT
: ERROR_FAIL
;
894 /* TODO: use results of transfers completed before the error occurred? */
898 if (block
->transfer_count
!= transfer_count
)
899 LOG_ERROR("CMSIS-DAP transfer count mismatch: expected %d, got %d",
900 block
->transfer_count
, transfer_count
);
902 LOG_DEBUG_IO("Received results of %d queued transactions FIFO index %u timeout %i",
903 transfer_count
, dap
->pending_fifo_get_idx
, timeout_ms
);
905 for (unsigned int i
= 0; i
< transfer_count
; i
++) {
906 struct pending_transfer_result
*transfer
= &(block
->transfers
[i
]);
907 if (transfer
->cmd
& SWD_CMD_RNW
) {
908 static uint32_t last_read
;
909 uint32_t data
= le_to_h_u32(&resp
[idx
]);
913 LOG_DEBUG_IO("Read result: %" PRIx32
, data
);
915 /* Imitate posted AP reads */
916 if ((transfer
->cmd
& SWD_CMD_APNDP
) ||
917 ((transfer
->cmd
& SWD_CMD_A32
) >> 1 == DP_RDBUFF
)) {
922 if (transfer
->buffer
)
923 *(uint32_t *)(transfer
->buffer
) = tmp
;
928 block
->transfer_count
= 0;
929 dap
->pending_fifo_get_idx
= (dap
->pending_fifo_get_idx
+ 1) % dap
->packet_count
;
930 dap
->pending_fifo_block_count
--;
933 static int cmsis_dap_swd_run_queue(void)
935 if (cmsis_dap_handle
->pending_fifo_block_count
)
936 cmsis_dap_swd_read_process(cmsis_dap_handle
, 0);
938 cmsis_dap_swd_write_from_queue(cmsis_dap_handle
);
940 while (cmsis_dap_handle
->pending_fifo_block_count
)
941 cmsis_dap_swd_read_process(cmsis_dap_handle
, LIBUSB_TIMEOUT_MS
);
943 cmsis_dap_handle
->pending_fifo_put_idx
= 0;
944 cmsis_dap_handle
->pending_fifo_get_idx
= 0;
946 int retval
= queued_retval
;
947 queued_retval
= ERROR_OK
;
952 static unsigned int cmsis_dap_tfer_cmd_size(unsigned int write_count
,
953 unsigned int read_count
, bool block_tfer
)
957 size
= 5; /* DAP_TransferBlock header */
958 size
+= write_count
* 4; /* data */
960 size
= 3; /* DAP_Transfer header */
961 size
+= write_count
* (1 + 4); /* DAP register + data */
962 size
+= read_count
; /* DAP register */
967 static unsigned int cmsis_dap_tfer_resp_size(unsigned int write_count
,
968 unsigned int read_count
, bool block_tfer
)
972 size
= 4; /* DAP_TransferBlock response header */
974 size
= 3; /* DAP_Transfer response header */
976 size
+= read_count
* 4; /* data */
980 static void cmsis_dap_swd_queue_cmd(uint8_t cmd
, uint32_t *dst
, uint32_t data
)
982 /* Compute sizes of the DAP Transfer command and the expected response
983 * for all queued and this operation */
984 bool targetsel_cmd
= swd_cmd(false, false, DP_TARGETSEL
) == cmd
;
986 unsigned int write_count
= cmsis_dap_handle
->write_count
;
987 unsigned int read_count
= cmsis_dap_handle
->read_count
;
989 if (write_count
+ read_count
< CMD_DAP_TFER_BLOCK_MIN_OPS
)
992 block_cmd
= !cmsis_dap_handle
->swd_cmds_differ
993 && cmd
== cmsis_dap_handle
->common_swd_cmd
;
995 if (cmd
& SWD_CMD_RNW
)
1000 unsigned int cmd_size
= cmsis_dap_tfer_cmd_size(write_count
, read_count
,
1002 unsigned int resp_size
= cmsis_dap_tfer_resp_size(write_count
, read_count
,
1005 /* Does the DAP Transfer command and the expected response fit into one packet?
1006 * Run the queue also before a targetsel - it cannot be queued */
1007 if (cmd_size
> tfer_max_command_size
1008 || resp_size
> tfer_max_response_size
1010 if (cmsis_dap_handle
->pending_fifo_block_count
)
1011 cmsis_dap_swd_read_process(cmsis_dap_handle
, 0);
1013 /* Not enough room in the queue. Run the queue. */
1014 cmsis_dap_swd_write_from_queue(cmsis_dap_handle
);
1016 if (cmsis_dap_handle
->pending_fifo_block_count
>= cmsis_dap_handle
->packet_count
)
1017 cmsis_dap_swd_read_process(cmsis_dap_handle
, LIBUSB_TIMEOUT_MS
);
1020 assert(cmsis_dap_handle
->pending_fifo
[cmsis_dap_handle
->pending_fifo_put_idx
].transfer_count
< pending_queue_len
);
1022 if (queued_retval
!= ERROR_OK
)
1025 if (targetsel_cmd
) {
1026 cmsis_dap_metacmd_targetsel(data
);
1030 struct pending_request_block
*block
= &cmsis_dap_handle
->pending_fifo
[cmsis_dap_handle
->pending_fifo_put_idx
];
1031 struct pending_transfer_result
*transfer
= &(block
->transfers
[block
->transfer_count
]);
1032 transfer
->data
= data
;
1033 transfer
->cmd
= cmd
;
1034 if (block
->transfer_count
== 0) {
1035 cmsis_dap_handle
->swd_cmds_differ
= false;
1036 cmsis_dap_handle
->common_swd_cmd
= cmd
;
1037 } else if (cmd
!= cmsis_dap_handle
->common_swd_cmd
) {
1038 cmsis_dap_handle
->swd_cmds_differ
= true;
1041 if (cmd
& SWD_CMD_RNW
) {
1042 /* Queue a read transaction */
1043 transfer
->buffer
= dst
;
1044 cmsis_dap_handle
->read_count
++;
1046 cmsis_dap_handle
->write_count
++;
1048 block
->transfer_count
++;
1051 static void cmsis_dap_swd_write_reg(uint8_t cmd
, uint32_t value
, uint32_t ap_delay_clk
)
1053 assert(!(cmd
& SWD_CMD_RNW
));
1054 cmsis_dap_swd_queue_cmd(cmd
, NULL
, value
);
1057 static void cmsis_dap_swd_read_reg(uint8_t cmd
, uint32_t *value
, uint32_t ap_delay_clk
)
1059 assert(cmd
& SWD_CMD_RNW
);
1060 cmsis_dap_swd_queue_cmd(cmd
, value
, 0);
1063 static int cmsis_dap_get_serial_info(void)
1067 int retval
= cmsis_dap_cmd_dap_info(INFO_ID_SERNUM
, &data
);
1068 if (retval
!= ERROR_OK
)
1071 if (data
[0]) /* strlen */
1072 LOG_INFO("CMSIS-DAP: Serial# = %s", &data
[1]);
1077 static int cmsis_dap_get_version_info(void)
1081 /* INFO_ID_FW_VER - string */
1082 int retval
= cmsis_dap_cmd_dap_info(INFO_ID_FW_VER
, &data
);
1083 if (retval
!= ERROR_OK
)
1086 if (data
[0]) /* strlen */
1087 LOG_INFO("CMSIS-DAP: FW Version = %s", &data
[1]);
1092 static int cmsis_dap_get_caps_info(void)
1096 /* INFO_ID_CAPS - byte */
1097 int retval
= cmsis_dap_cmd_dap_info(INFO_ID_CAPS
, &data
);
1098 if (retval
!= ERROR_OK
)
1101 if (data
[0] == 1 || data
[0] == 2) {
1102 uint16_t caps
= data
[1];
1104 caps
|= (uint16_t)data
[2] << 8;
1106 cmsis_dap_handle
->caps
= caps
;
1108 for (unsigned int i
= 0; i
< INFO_CAPS__NUM_CAPS
; ++i
) {
1110 LOG_INFO("CMSIS-DAP: %s", info_caps_str
[i
]);
1117 static int cmsis_dap_get_swo_buf_sz(uint32_t *swo_buf_sz
)
1121 /* INFO_ID_SWO_BUF_SZ - word */
1122 int retval
= cmsis_dap_cmd_dap_info(INFO_ID_SWO_BUF_SZ
, &data
);
1123 if (retval
!= ERROR_OK
)
1129 *swo_buf_sz
= le_to_h_u32(&data
[1]);
1131 LOG_INFO("CMSIS-DAP: SWO Trace Buffer Size = %u bytes", *swo_buf_sz
);
1136 static int cmsis_dap_get_status(void)
1140 int retval
= cmsis_dap_cmd_dap_swj_pins(0, 0, 0, &d
);
1142 if (retval
== ERROR_OK
) {
1143 LOG_INFO("SWCLK/TCK = %d SWDIO/TMS = %d TDI = %d TDO = %d nTRST = %d nRESET = %d",
1144 (d
& SWJ_PIN_TCK
) ? 1 : 0,
1145 (d
& SWJ_PIN_TMS
) ? 1 : 0,
1146 (d
& SWJ_PIN_TDI
) ? 1 : 0,
1147 (d
& SWJ_PIN_TDO
) ? 1 : 0,
1148 (d
& SWJ_PIN_TRST
) ? 1 : 0,
1149 (d
& SWJ_PIN_SRST
) ? 1 : 0);
1155 static int cmsis_dap_swd_switch_seq(enum swd_special_seq seq
)
1161 if (seq
!= LINE_RESET
&&
1162 (output_pins
& (SWJ_PIN_SRST
| SWJ_PIN_TRST
))
1163 == (SWJ_PIN_SRST
| SWJ_PIN_TRST
)) {
1164 /* Following workaround deasserts reset on most adapters.
1165 * Do not reconnect if a reset line is active!
1166 * Reconnecting would break connecting under reset. */
1168 /* First disconnect before connecting, Atmel EDBG needs it for SAMD/R/L/C */
1169 cmsis_dap_cmd_dap_disconnect();
1171 /* When we are reconnecting, DAP_Connect needs to be rerun, at
1172 * least on Keil ULINK-ME */
1173 retval
= cmsis_dap_cmd_dap_connect(CONNECT_SWD
);
1174 if (retval
!= ERROR_OK
)
1180 LOG_DEBUG_IO("SWD line reset");
1181 s
= swd_seq_line_reset
;
1182 s_len
= swd_seq_line_reset_len
;
1185 LOG_DEBUG("JTAG-to-SWD");
1186 s
= swd_seq_jtag_to_swd
;
1187 s_len
= swd_seq_jtag_to_swd_len
;
1189 case JTAG_TO_DORMANT
:
1190 LOG_DEBUG("JTAG-to-DORMANT");
1191 s
= swd_seq_jtag_to_dormant
;
1192 s_len
= swd_seq_jtag_to_dormant_len
;
1195 LOG_DEBUG("SWD-to-JTAG");
1196 s
= swd_seq_swd_to_jtag
;
1197 s_len
= swd_seq_swd_to_jtag_len
;
1199 case SWD_TO_DORMANT
:
1200 LOG_DEBUG("SWD-to-DORMANT");
1201 s
= swd_seq_swd_to_dormant
;
1202 s_len
= swd_seq_swd_to_dormant_len
;
1204 case DORMANT_TO_SWD
:
1205 LOG_DEBUG("DORMANT-to-SWD");
1206 s
= swd_seq_dormant_to_swd
;
1207 s_len
= swd_seq_dormant_to_swd_len
;
1209 case DORMANT_TO_JTAG
:
1210 LOG_DEBUG("DORMANT-to-JTAG");
1211 s
= swd_seq_dormant_to_jtag
;
1212 s_len
= swd_seq_dormant_to_jtag_len
;
1215 LOG_ERROR("Sequence %d not supported", seq
);
1219 retval
= cmsis_dap_cmd_dap_swj_sequence(s_len
, s
);
1220 if (retval
!= ERROR_OK
)
1223 /* Atmel EDBG needs renew clock setting after SWJ_Sequence
1224 * otherwise default frequency is used */
1225 return cmsis_dap_cmd_dap_swj_clock(adapter_get_speed_khz());
1228 static int cmsis_dap_swd_open(void)
1230 if (!(cmsis_dap_handle
->caps
& INFO_CAPS_SWD
)) {
1231 LOG_ERROR("CMSIS-DAP: SWD not supported");
1232 return ERROR_JTAG_DEVICE_ERROR
;
1235 int retval
= cmsis_dap_cmd_dap_connect(CONNECT_SWD
);
1236 if (retval
!= ERROR_OK
)
1239 /* Add more setup here.??... */
1241 LOG_INFO("CMSIS-DAP: Interface Initialised (SWD)");
1245 static int cmsis_dap_init(void)
1249 int retval
= cmsis_dap_open();
1250 if (retval
!= ERROR_OK
)
1253 cmsis_dap_flush_read(cmsis_dap_handle
);
1255 retval
= cmsis_dap_get_caps_info();
1256 if (retval
!= ERROR_OK
)
1259 retval
= cmsis_dap_get_version_info();
1260 if (retval
!= ERROR_OK
)
1263 retval
= cmsis_dap_get_serial_info();
1264 if (retval
!= ERROR_OK
)
1268 retval
= cmsis_dap_swd_open();
1269 if (retval
!= ERROR_OK
)
1272 /* Connect in JTAG mode */
1273 if (!(cmsis_dap_handle
->caps
& INFO_CAPS_JTAG
)) {
1274 LOG_ERROR("CMSIS-DAP: JTAG not supported");
1275 return ERROR_JTAG_DEVICE_ERROR
;
1278 retval
= cmsis_dap_cmd_dap_connect(CONNECT_JTAG
);
1279 if (retval
!= ERROR_OK
)
1282 LOG_INFO("CMSIS-DAP: Interface Initialised (JTAG)");
1285 /* Be conservative and suppress submitting multiple HID requests
1286 * until we get packet count info from the adaptor */
1287 cmsis_dap_handle
->packet_count
= 1;
1289 /* INFO_ID_PKT_SZ - short */
1290 retval
= cmsis_dap_cmd_dap_info(INFO_ID_PKT_SZ
, &data
);
1291 if (retval
!= ERROR_OK
)
1294 if (data
[0] == 2) { /* short */
1295 uint16_t pkt_sz
= data
[1] + (data
[2] << 8);
1296 if (pkt_sz
!= cmsis_dap_handle
->packet_size
) {
1297 free(cmsis_dap_handle
->packet_buffer
);
1298 retval
= cmsis_dap_handle
->backend
->packet_buffer_alloc(cmsis_dap_handle
, pkt_sz
);
1299 if (retval
!= ERROR_OK
)
1302 LOG_DEBUG("CMSIS-DAP: Packet Size = %" PRIu16
, pkt_sz
);
1306 /* Maximal number of transfers which fit to one packet:
1307 * Limited by response size: 3 bytes of response header + 4 per read
1308 * Plus writes to full command size: 3 bytes cmd header + 1 per read + 5 per write */
1309 tfer_max_command_size
= cmsis_dap_handle
->packet_usable_size
;
1310 tfer_max_response_size
= cmsis_dap_handle
->packet_usable_size
;
1311 unsigned int max_reads
= tfer_max_response_size
/ 4;
1312 pending_queue_len
= max_reads
+ (tfer_max_command_size
- max_reads
) / 5;
1313 cmsis_dap_handle
->write_count
= 0;
1314 cmsis_dap_handle
->read_count
= 0;
1316 /* INFO_ID_PKT_CNT - byte */
1317 retval
= cmsis_dap_cmd_dap_info(INFO_ID_PKT_CNT
, &data
);
1318 if (retval
!= ERROR_OK
)
1321 if (data
[0] == 1) { /* byte */
1322 unsigned int pkt_cnt
= data
[1];
1324 cmsis_dap_handle
->packet_count
= MIN(MAX_PENDING_REQUESTS
, pkt_cnt
);
1326 LOG_DEBUG("CMSIS-DAP: Packet Count = %u", pkt_cnt
);
1329 LOG_DEBUG("Allocating FIFO for %u pending packets", cmsis_dap_handle
->packet_count
);
1330 for (unsigned int i
= 0; i
< cmsis_dap_handle
->packet_count
; i
++) {
1331 cmsis_dap_handle
->pending_fifo
[i
].transfers
= malloc(pending_queue_len
1332 * sizeof(struct pending_transfer_result
));
1333 if (!cmsis_dap_handle
->pending_fifo
[i
].transfers
) {
1334 LOG_ERROR("Unable to allocate memory for CMSIS-DAP queue");
1335 retval
= ERROR_FAIL
;
1340 /* Intentionally not checked for error, just logs an info message
1341 * not vital for further debugging */
1342 (void)cmsis_dap_get_status();
1344 /* Now try to connect to the target
1345 * TODO: This is all SWD only @ present */
1346 retval
= cmsis_dap_cmd_dap_swj_clock(adapter_get_speed_khz());
1347 if (retval
!= ERROR_OK
)
1350 /* Ask CMSIS-DAP to automatically retry on receiving WAIT for
1351 * up to 64 times. This must be changed to 0 if sticky
1352 * overrun detection is enabled. */
1353 retval
= cmsis_dap_cmd_dap_tfer_configure(0, 64, 0);
1354 if (retval
!= ERROR_OK
)
1358 /* Data Phase (bit 2) must be set to 1 if sticky overrun
1359 * detection is enabled */
1360 retval
= cmsis_dap_cmd_dap_swd_configure(0); /* 1 TRN, no Data Phase */
1361 if (retval
!= ERROR_OK
)
1365 /* Intentionally not checked for error, debugging will work
1367 (void)cmsis_dap_cmd_dap_led(LED_ID_CONNECT
, LED_ON
);
1368 (void)cmsis_dap_cmd_dap_led(LED_ID_RUN
, LED_ON
);
1370 /* support connecting with srst asserted */
1371 enum reset_types jtag_reset_config
= jtag_get_reset_config();
1373 if (jtag_reset_config
& RESET_CNCT_UNDER_SRST
) {
1374 if (jtag_reset_config
& RESET_SRST_NO_GATING
) {
1375 retval
= cmsis_dap_cmd_dap_swj_pins(0, SWJ_PIN_SRST
, 0, NULL
);
1376 if (retval
!= ERROR_OK
)
1378 LOG_INFO("Connecting under reset");
1381 LOG_INFO("CMSIS-DAP: Interface ready");
1389 static int cmsis_dap_swd_init(void)
1395 static int cmsis_dap_quit(void)
1397 cmsis_dap_cmd_dap_disconnect();
1400 cmsis_dap_cmd_dap_led(LED_ID_RUN
, LED_OFF
);
1401 cmsis_dap_cmd_dap_led(LED_ID_CONNECT
, LED_OFF
);
1403 cmsis_dap_close(cmsis_dap_handle
);
1408 static int cmsis_dap_reset(int trst
, int srst
)
1410 /* Set both TRST and SRST even if they're not enabled as
1411 * there's no way to tristate them */
1415 output_pins
|= SWJ_PIN_SRST
;
1417 output_pins
|= SWJ_PIN_TRST
;
1419 int retval
= cmsis_dap_cmd_dap_swj_pins(output_pins
,
1420 SWJ_PIN_TRST
| SWJ_PIN_SRST
, 0, NULL
);
1421 if (retval
!= ERROR_OK
)
1422 LOG_ERROR("CMSIS-DAP: Interface reset failed");
1426 static void cmsis_dap_execute_sleep(struct jtag_command
*cmd
)
1429 int retval
= cmsis_dap_cmd_dap_delay(cmd
->cmd
.sleep
->us
);
1430 if (retval
!= ERROR_OK
)
1432 jtag_sleep(cmd
->cmd
.sleep
->us
);
1435 /* Set TMS high for five TCK clocks, to move the TAP to the Test-Logic-Reset state */
1436 static int cmsis_dap_execute_tlr_reset(struct jtag_command
*cmd
)
1438 LOG_INFO("cmsis-dap JTAG TLR_RESET");
1441 int retval
= cmsis_dap_cmd_dap_swj_sequence(8, &seq
);
1442 if (retval
== ERROR_OK
)
1443 tap_set_state(TAP_RESET
);
1447 /* Set new end state */
1448 static void cmsis_dap_end_state(tap_state_t state
)
1450 if (tap_is_state_stable(state
))
1451 tap_set_end_state(state
);
1453 LOG_ERROR("BUG: %i is not a valid end state", state
);
1458 #ifdef SPRINT_BINARY
1459 static void sprint_binary(char *s
, const uint8_t *buf
, unsigned int offset
, unsigned int len
)
1465 buf = { 0x18 } len=5 should result in: 11000
1466 buf = { 0xff 0x18 } len=13 should result in: 11111111 11000
1467 buf = { 0xc0 0x18 } offset=3 len=10 should result in: 11000 11000
1468 i=3 there means i/8 = 0 so c = 0xFF, and
1470 for (unsigned int i
= offset
; i
< offset
+ len
; ++i
) {
1471 uint8_t c
= buf
[i
/ 8], mask
= 1 << (i
% 8);
1472 if ((i
!= offset
) && !(i
% 8))
1474 *s
++ = (c
& mask
) ? '1' : '0';
1480 #ifdef CMSIS_DAP_JTAG_DEBUG
1481 static void debug_parse_cmsis_buf(const uint8_t *cmd
, int cmdlen
)
1483 /* cmd is a usb packet to go to the cmsis-dap interface */
1484 printf("cmsis-dap buffer (%d b): ", cmdlen
);
1485 for (int i
= 0; i
< cmdlen
; ++i
)
1486 printf(" %02x", cmd
[i
]);
1489 case CMD_DAP_JTAG_SEQ
: {
1490 printf("cmsis-dap jtag sequence command %02x (n=%d)\n", cmd
[0], cmd
[1]);
1492 * #1 = number of sequences
1493 * #2 = sequence info 1
1494 * #3...4+n_bytes-1 = sequence 1
1495 * #4+n_bytes = sequence info 2
1496 * #5+n_bytes = sequence 2 (single bit)
1499 for (int seq
= 0; seq
< cmd
[1]; ++seq
) {
1500 uint8_t info
= cmd
[pos
++];
1501 int len
= info
& DAP_JTAG_SEQ_TCK
;
1504 printf(" sequence %d starting %d: info %02x (len=%d tms=%d read_tdo=%d): ",
1505 seq
, pos
, info
, len
, info
& DAP_JTAG_SEQ_TMS
, info
& DAP_JTAG_SEQ_TDO
);
1506 for (int i
= 0; i
< DIV_ROUND_UP(len
, 8); ++i
)
1507 printf(" %02x", cmd
[pos
+i
]);
1508 pos
+= DIV_ROUND_UP(len
, 8);
1511 if (pos
!= cmdlen
) {
1512 printf("BUFFER LENGTH MISMATCH looks like %d but %d specified", pos
, cmdlen
);
1519 LOG_DEBUG("unknown cmsis-dap command %02x", cmd
[1]);
1525 static void cmsis_dap_flush(void)
1527 if (!queued_seq_count
)
1530 LOG_DEBUG_IO("Flushing %d queued sequences (%d bytes) with %d pending scan results to capture",
1531 queued_seq_count
, queued_seq_buf_end
, pending_scan_result_count
);
1533 /* prepare CMSIS-DAP packet */
1534 uint8_t *command
= cmsis_dap_handle
->command
;
1535 command
[0] = CMD_DAP_JTAG_SEQ
;
1536 command
[1] = queued_seq_count
;
1537 memcpy(&command
[2], queued_seq_buf
, queued_seq_buf_end
);
1539 #ifdef CMSIS_DAP_JTAG_DEBUG
1540 debug_parse_cmsis_buf(command
, queued_seq_buf_end
+ 2);
1543 /* send command to USB device */
1544 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, queued_seq_buf_end
+ 2);
1546 uint8_t *resp
= cmsis_dap_handle
->response
;
1547 if (retval
!= ERROR_OK
|| resp
[1] != DAP_OK
) {
1548 LOG_ERROR("CMSIS-DAP command CMD_DAP_JTAG_SEQ failed.");
1552 #ifdef CMSIS_DAP_JTAG_DEBUG
1553 LOG_DEBUG_IO("USB response buf:");
1554 for (int c
= 0; c
< queued_seq_buf_end
+ 3; ++c
)
1555 printf("%02X ", resp
[c
]);
1559 /* copy scan results into client buffers */
1560 for (int i
= 0; i
< pending_scan_result_count
; ++i
) {
1561 struct pending_scan_result
*scan
= &pending_scan_results
[i
];
1562 LOG_DEBUG_IO("Copying pending_scan_result %d/%d: %d bits from byte %d -> buffer + %d bits",
1563 i
, pending_scan_result_count
, scan
->length
, scan
->first
+ 2, scan
->buffer_offset
);
1564 #ifdef CMSIS_DAP_JTAG_DEBUG
1565 for (uint32_t b
= 0; b
< DIV_ROUND_UP(scan
->length
, 8); ++b
)
1566 printf("%02X ", resp
[2+scan
->first
+b
]);
1569 bit_copy(scan
->buffer
, scan
->buffer_offset
, &resp
[2 + scan
->first
], 0, scan
->length
);
1573 queued_seq_count
= 0;
1574 queued_seq_buf_end
= 0;
1575 queued_seq_tdo_ptr
= 0;
1576 pending_scan_result_count
= 0;
1579 /* queue a sequence of bits to clock out TDI / in TDO, executing if the buffer is full.
1581 * sequence=NULL means clock out zeros on TDI
1582 * tdo_buffer=NULL means don't capture TDO
1584 static void cmsis_dap_add_jtag_sequence(unsigned int s_len
, const uint8_t *sequence
,
1585 unsigned int s_offset
, bool tms
,
1586 uint8_t *tdo_buffer
, unsigned int tdo_buffer_offset
)
1588 LOG_DEBUG_IO("[at %d] %u bits, tms %s, seq offset %u, tdo buf %p, tdo offset %u",
1590 s_len
, tms
? "HIGH" : "LOW", s_offset
, tdo_buffer
, tdo_buffer_offset
);
1596 LOG_DEBUG_IO("START JTAG SEQ SPLIT");
1597 for (unsigned int offset
= 0; offset
< s_len
; offset
+= 64) {
1598 unsigned int len
= s_len
- offset
;
1601 LOG_DEBUG_IO("Splitting long jtag sequence: %u-bit chunk starting at offset %u", len
, offset
);
1602 cmsis_dap_add_jtag_sequence(
1608 !tdo_buffer
? 0 : (tdo_buffer_offset
+ offset
)
1611 LOG_DEBUG_IO("END JTAG SEQ SPLIT");
1615 unsigned int cmd_len
= 1 + DIV_ROUND_UP(s_len
, 8);
1616 if (queued_seq_count
>= 255 || queued_seq_buf_end
+ cmd_len
> QUEUED_SEQ_BUF_LEN
)
1617 /* empty out the buffer */
1623 queued_seq_buf
[queued_seq_buf_end
] =
1624 (tms
? DAP_JTAG_SEQ_TMS
: 0) |
1625 (tdo_buffer
? DAP_JTAG_SEQ_TDO
: 0) |
1626 (s_len
== 64 ? 0 : s_len
);
1629 bit_copy(&queued_seq_buf
[queued_seq_buf_end
+ 1], 0, sequence
, s_offset
, s_len
);
1631 memset(&queued_seq_buf
[queued_seq_buf_end
+ 1], 0, DIV_ROUND_UP(s_len
, 8));
1633 queued_seq_buf_end
+= cmd_len
;
1636 struct pending_scan_result
*scan
= &pending_scan_results
[pending_scan_result_count
++];
1637 scan
->first
= queued_seq_tdo_ptr
;
1638 queued_seq_tdo_ptr
+= DIV_ROUND_UP(s_len
, 8);
1639 scan
->length
= s_len
;
1640 scan
->buffer
= tdo_buffer
;
1641 scan
->buffer_offset
= tdo_buffer_offset
;
1645 /* queue a sequence of bits to clock out TMS, executing if the buffer is full */
1646 static void cmsis_dap_add_tms_sequence(const uint8_t *sequence
, int s_len
)
1648 LOG_DEBUG_IO("%d bits: %02X", s_len
, *sequence
);
1649 /* we use a series of CMD_DAP_JTAG_SEQ commands to toggle TMS,
1650 because even though it seems ridiculously inefficient, it
1651 allows us to combine TMS and scan sequences into the same
1653 /* TODO: combine runs of the same tms value */
1654 for (int i
= 0; i
< s_len
; ++i
) {
1655 bool bit
= (sequence
[i
/ 8] & (1 << (i
% 8))) != 0;
1656 cmsis_dap_add_jtag_sequence(1, NULL
, 0, bit
, NULL
, 0);
1660 /* Move to the end state by queuing a sequence to clock into TMS */
1661 static void cmsis_dap_state_move(void)
1663 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1664 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1666 LOG_DEBUG_IO("state move from %s to %s: %d clocks, %02X on tms",
1667 tap_state_name(tap_get_state()), tap_state_name(tap_get_end_state()),
1668 tms_scan_bits
, tms_scan
);
1669 cmsis_dap_add_tms_sequence(&tms_scan
, tms_scan_bits
);
1671 tap_set_state(tap_get_end_state());
1675 /* Execute a JTAG scan operation by queueing TMS and TDI/TDO sequences */
1676 static void cmsis_dap_execute_scan(struct jtag_command
*cmd
)
1678 LOG_DEBUG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN",
1679 jtag_scan_type(cmd
->cmd
.scan
));
1681 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
1682 while (cmd
->cmd
.scan
->num_fields
> 0
1683 && cmd
->cmd
.scan
->fields
[cmd
->cmd
.scan
->num_fields
- 1].num_bits
== 0) {
1684 cmd
->cmd
.scan
->num_fields
--;
1685 LOG_DEBUG("discarding trailing empty field");
1688 if (cmd
->cmd
.scan
->num_fields
== 0) {
1689 LOG_DEBUG("empty scan, doing nothing");
1693 if (cmd
->cmd
.scan
->ir_scan
) {
1694 if (tap_get_state() != TAP_IRSHIFT
) {
1695 cmsis_dap_end_state(TAP_IRSHIFT
);
1696 cmsis_dap_state_move();
1699 if (tap_get_state() != TAP_DRSHIFT
) {
1700 cmsis_dap_end_state(TAP_DRSHIFT
);
1701 cmsis_dap_state_move();
1705 cmsis_dap_end_state(cmd
->cmd
.scan
->end_state
);
1707 struct scan_field
*field
= cmd
->cmd
.scan
->fields
;
1708 unsigned scan_size
= 0;
1710 for (int i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++, field
++) {
1711 scan_size
+= field
->num_bits
;
1712 LOG_DEBUG_IO("%s%s field %d/%d %d bits",
1713 field
->in_value
? "in" : "",
1714 field
->out_value
? "out" : "",
1716 cmd
->cmd
.scan
->num_fields
,
1719 if (i
== cmd
->cmd
.scan
->num_fields
- 1 && tap_get_state() != tap_get_end_state()) {
1720 LOG_DEBUG_IO("Last field and have to move out of SHIFT state");
1721 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
1722 * movement. This last field can't have length zero, it was checked above. */
1723 cmsis_dap_add_jtag_sequence(
1724 field
->num_bits
- 1, /* number of bits to clock */
1725 field
->out_value
, /* output sequence */
1726 0, /* output offset */
1727 false, /* TMS low */
1731 /* Clock the last bit out, with TMS high */
1732 uint8_t last_bit
= 0;
1733 if (field
->out_value
)
1734 bit_copy(&last_bit
, 0, field
->out_value
, field
->num_bits
- 1, 1);
1735 cmsis_dap_add_jtag_sequence(
1741 field
->num_bits
- 1);
1742 tap_set_state(tap_state_transition(tap_get_state(), 1));
1744 /* Now clock one more cycle, with TMS low, to get us into a PAUSE state */
1745 cmsis_dap_add_jtag_sequence(
1752 tap_set_state(tap_state_transition(tap_get_state(), 0));
1754 LOG_DEBUG_IO("Internal field, staying in SHIFT state afterwards");
1755 /* Clocking part of a sequence into DR or IR with TMS=0,
1756 leaving TMS=0 at the end so we can continue later */
1757 cmsis_dap_add_jtag_sequence(
1767 if (tap_get_state() != tap_get_end_state()) {
1768 cmsis_dap_end_state(tap_get_end_state());
1769 cmsis_dap_state_move();
1772 LOG_DEBUG_IO("%s scan, %i bits, end in %s",
1773 (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
1774 tap_state_name(tap_get_end_state()));
1777 static void cmsis_dap_pathmove(int num_states
, tap_state_t
*path
)
1779 uint8_t tms0
= 0x00;
1780 uint8_t tms1
= 0xff;
1782 for (int i
= 0; i
< num_states
; i
++) {
1783 if (path
[i
] == tap_state_transition(tap_get_state(), false))
1784 cmsis_dap_add_tms_sequence(&tms0
, 1);
1785 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
1786 cmsis_dap_add_tms_sequence(&tms1
, 1);
1788 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition.",
1789 tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
1793 tap_set_state(path
[i
]);
1796 cmsis_dap_end_state(tap_get_state());
1799 static void cmsis_dap_execute_pathmove(struct jtag_command
*cmd
)
1801 LOG_DEBUG_IO("pathmove: %i states, end in %i",
1802 cmd
->cmd
.pathmove
->num_states
,
1803 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
1805 cmsis_dap_pathmove(cmd
->cmd
.pathmove
->num_states
, cmd
->cmd
.pathmove
->path
);
1808 static void cmsis_dap_stableclocks(int num_cycles
)
1810 uint8_t tms
= tap_get_state() == TAP_RESET
;
1811 /* TODO: Perform optimizations? */
1812 /* Execute num_cycles. */
1813 for (int i
= 0; i
< num_cycles
; i
++)
1814 cmsis_dap_add_tms_sequence(&tms
, 1);
1817 static void cmsis_dap_runtest(int num_cycles
)
1819 tap_state_t saved_end_state
= tap_get_end_state();
1821 /* Only do a state_move when we're not already in IDLE. */
1822 if (tap_get_state() != TAP_IDLE
) {
1823 cmsis_dap_end_state(TAP_IDLE
);
1824 cmsis_dap_state_move();
1826 cmsis_dap_stableclocks(num_cycles
);
1828 /* Finish in end_state. */
1829 cmsis_dap_end_state(saved_end_state
);
1831 if (tap_get_state() != tap_get_end_state())
1832 cmsis_dap_state_move();
1835 static void cmsis_dap_execute_runtest(struct jtag_command
*cmd
)
1837 LOG_DEBUG_IO("runtest %i cycles, end in %i", cmd
->cmd
.runtest
->num_cycles
,
1838 cmd
->cmd
.runtest
->end_state
);
1840 cmsis_dap_end_state(cmd
->cmd
.runtest
->end_state
);
1841 cmsis_dap_runtest(cmd
->cmd
.runtest
->num_cycles
);
1844 static void cmsis_dap_execute_stableclocks(struct jtag_command
*cmd
)
1846 LOG_DEBUG_IO("stableclocks %i cycles", cmd
->cmd
.runtest
->num_cycles
);
1847 cmsis_dap_stableclocks(cmd
->cmd
.runtest
->num_cycles
);
1850 static void cmsis_dap_execute_tms(struct jtag_command
*cmd
)
1852 LOG_DEBUG_IO("TMS: %d bits", cmd
->cmd
.tms
->num_bits
);
1853 cmsis_dap_cmd_dap_swj_sequence(cmd
->cmd
.tms
->num_bits
, cmd
->cmd
.tms
->bits
);
1856 /* TODO: Is there need to call cmsis_dap_flush() for the JTAG_PATHMOVE,
1857 * JTAG_RUNTEST, JTAG_STABLECLOCKS? */
1858 static void cmsis_dap_execute_command(struct jtag_command
*cmd
)
1860 switch (cmd
->type
) {
1863 cmsis_dap_execute_sleep(cmd
);
1865 case JTAG_TLR_RESET
:
1867 cmsis_dap_execute_tlr_reset(cmd
);
1870 cmsis_dap_execute_scan(cmd
);
1873 cmsis_dap_execute_pathmove(cmd
);
1876 cmsis_dap_execute_runtest(cmd
);
1878 case JTAG_STABLECLOCKS
:
1879 cmsis_dap_execute_stableclocks(cmd
);
1882 cmsis_dap_execute_tms(cmd
);
1885 LOG_ERROR("BUG: unknown JTAG command type 0x%X encountered", cmd
->type
);
1890 static int cmsis_dap_execute_queue(void)
1892 struct jtag_command
*cmd
= jtag_command_queue
;
1895 cmsis_dap_execute_command(cmd
);
1904 static int cmsis_dap_speed(int speed
)
1907 LOG_ERROR("RTCK not supported. Set nonzero \"adapter speed\".");
1908 return ERROR_JTAG_NOT_IMPLEMENTED
;
1911 return cmsis_dap_cmd_dap_swj_clock(speed
);
1914 static int cmsis_dap_speed_div(int speed
, int *khz
)
1920 static int cmsis_dap_khz(int khz
, int *jtag_speed
)
1926 static bool calculate_swo_prescaler(unsigned int traceclkin_freq
,
1927 uint32_t trace_freq
, uint16_t *prescaler
)
1929 unsigned int presc
= (traceclkin_freq
+ trace_freq
/ 2) / trace_freq
;
1930 if (presc
== 0 || presc
> TPIU_ACPR_MAX_SWOSCALER
+ 1)
1933 /* Probe's UART speed must be within 3% of the TPIU's SWO baud rate. */
1934 unsigned int max_deviation
= (traceclkin_freq
* 3) / 100;
1935 if (presc
* trace_freq
< traceclkin_freq
- max_deviation
||
1936 presc
* trace_freq
> traceclkin_freq
+ max_deviation
)
1945 * @see adapter_driver::config_trace
1947 static int cmsis_dap_config_trace(
1949 enum tpiu_pin_protocol pin_protocol
,
1951 unsigned int *swo_freq
,
1952 unsigned int traceclkin_hz
,
1953 uint16_t *swo_prescaler
)
1957 if (!trace_enabled
) {
1958 if (cmsis_dap_handle
->trace_enabled
) {
1959 retval
= cmsis_dap_cmd_dap_swo_control(DAP_SWO_CONTROL_STOP
);
1960 if (retval
!= ERROR_OK
) {
1961 LOG_ERROR("Failed to disable the SWO-trace.");
1965 cmsis_dap_handle
->trace_enabled
= false;
1966 LOG_INFO("SWO-trace disabled.");
1970 if (!(cmsis_dap_handle
->caps
& INFO_CAPS_SWO_UART
) &&
1971 !(cmsis_dap_handle
->caps
& INFO_CAPS_SWO_MANCHESTER
)) {
1972 LOG_ERROR("SWO-trace is not supported by the device.");
1977 if (pin_protocol
== TPIU_PIN_PROTOCOL_ASYNC_UART
&&
1978 (cmsis_dap_handle
->caps
& INFO_CAPS_SWO_UART
)) {
1979 swo_mode
= DAP_SWO_MODE_UART
;
1980 } else if (pin_protocol
== TPIU_PIN_PROTOCOL_ASYNC_MANCHESTER
&&
1981 (cmsis_dap_handle
->caps
& INFO_CAPS_SWO_MANCHESTER
)) {
1982 swo_mode
= DAP_SWO_MODE_MANCHESTER
;
1984 LOG_ERROR("Selected pin protocol is not supported.");
1988 if (*swo_freq
== 0) {
1989 LOG_INFO("SWO-trace frequency autodetection not implemented.");
1993 retval
= cmsis_dap_cmd_dap_swo_control(DAP_SWO_CONTROL_STOP
);
1994 if (retval
!= ERROR_OK
)
1997 cmsis_dap_handle
->trace_enabled
= false;
1999 retval
= cmsis_dap_get_swo_buf_sz(&cmsis_dap_handle
->swo_buf_sz
);
2000 if (retval
!= ERROR_OK
)
2003 retval
= cmsis_dap_cmd_dap_swo_transport(DAP_SWO_TRANSPORT_DATA
);
2004 if (retval
!= ERROR_OK
)
2007 retval
= cmsis_dap_cmd_dap_swo_mode(swo_mode
);
2008 if (retval
!= ERROR_OK
)
2011 retval
= cmsis_dap_cmd_dap_swo_baudrate(*swo_freq
, swo_freq
);
2012 if (retval
!= ERROR_OK
)
2015 if (!calculate_swo_prescaler(traceclkin_hz
, *swo_freq
,
2017 LOG_ERROR("SWO frequency is not suitable. Please choose a "
2018 "different frequency or use auto-detection.");
2022 LOG_INFO("SWO frequency: %u Hz.", *swo_freq
);
2023 LOG_INFO("SWO prescaler: %u.", *swo_prescaler
);
2025 retval
= cmsis_dap_cmd_dap_swo_control(DAP_SWO_CONTROL_START
);
2026 if (retval
!= ERROR_OK
)
2029 cmsis_dap_handle
->trace_enabled
= true;
2035 * @see adapter_driver::poll_trace
2037 static int cmsis_dap_poll_trace(uint8_t *buf
, size_t *size
)
2039 uint8_t trace_status
;
2042 if (!cmsis_dap_handle
->trace_enabled
) {
2047 int retval
= cmsis_dap_cmd_dap_swo_status(&trace_status
, &trace_count
);
2048 if (retval
!= ERROR_OK
)
2050 if ((trace_status
& DAP_SWO_STATUS_CAPTURE_MASK
) != DAP_SWO_STATUS_CAPTURE_ACTIVE
)
2053 *size
= trace_count
< *size
? trace_count
: *size
;
2054 size_t read_so_far
= 0;
2057 uint32_t packet_size
= cmsis_dap_handle
->packet_size
- 4 /*data-reply*/;
2058 uint32_t remaining
= *size
- read_so_far
;
2059 if (remaining
< packet_size
)
2060 packet_size
= remaining
;
2061 retval
= cmsis_dap_cmd_dap_swo_data(
2066 if (retval
!= ERROR_OK
)
2068 if ((trace_status
& DAP_SWO_STATUS_CAPTURE_MASK
) != DAP_SWO_STATUS_CAPTURE_ACTIVE
)
2072 } while (read_so_far
< *size
);
2077 COMMAND_HANDLER(cmsis_dap_handle_info_command
)
2079 if (cmsis_dap_get_version_info() == ERROR_OK
)
2080 cmsis_dap_get_status();
2085 COMMAND_HANDLER(cmsis_dap_handle_cmd_command
)
2087 uint8_t *command
= cmsis_dap_handle
->command
;
2089 for (unsigned i
= 0; i
< CMD_ARGC
; i
++)
2090 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[i
], command
[i
]);
2092 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, CMD_ARGC
);
2094 if (retval
!= ERROR_OK
) {
2095 LOG_ERROR("CMSIS-DAP command failed.");
2096 return ERROR_JTAG_DEVICE_ERROR
;
2099 uint8_t *resp
= cmsis_dap_handle
->response
;
2100 LOG_INFO("Returned data %02" PRIx8
" %02" PRIx8
" %02" PRIx8
" %02" PRIx8
,
2101 resp
[1], resp
[2], resp
[3], resp
[4]);
2106 COMMAND_HANDLER(cmsis_dap_handle_vid_pid_command
)
2108 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
2109 LOG_WARNING("ignoring extra IDs in cmsis_dap_vid_pid "
2110 "(maximum is %d pairs)", MAX_USB_IDS
);
2111 CMD_ARGC
= MAX_USB_IDS
* 2;
2113 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
2114 LOG_WARNING("incomplete cmsis_dap_vid_pid configuration directive");
2116 return ERROR_COMMAND_SYNTAX_ERROR
;
2117 /* remove the incomplete trailing id */
2122 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
2123 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], cmsis_dap_vid
[i
>> 1]);
2124 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], cmsis_dap_pid
[i
>> 1]);
2128 * Explicitly terminate, in case there are multiples instances of
2129 * cmsis_dap_vid_pid.
2131 cmsis_dap_vid
[i
>> 1] = cmsis_dap_pid
[i
>> 1] = 0;
2136 COMMAND_HANDLER(cmsis_dap_handle_backend_command
)
2138 if (CMD_ARGC
== 1) {
2139 if (strcmp(CMD_ARGV
[0], "auto") == 0) {
2140 cmsis_dap_backend
= -1; /* autoselect */
2142 for (unsigned int i
= 0; i
< ARRAY_SIZE(cmsis_dap_backends
); i
++) {
2143 if (strcasecmp(cmsis_dap_backends
[i
]->name
, CMD_ARGV
[0]) == 0) {
2144 cmsis_dap_backend
= i
;
2149 LOG_ERROR("invalid backend argument to cmsis_dap_backend <backend>");
2152 LOG_ERROR("expected exactly one argument to cmsis_dap_backend <backend>");
2158 static const struct command_registration cmsis_dap_subcommand_handlers
[] = {
2161 .handler
= &cmsis_dap_handle_info_command
,
2162 .mode
= COMMAND_EXEC
,
2164 .help
= "show cmsis-dap info",
2168 .handler
= &cmsis_dap_handle_cmd_command
,
2169 .mode
= COMMAND_EXEC
,
2171 .help
= "issue cmsis-dap command",
2173 COMMAND_REGISTRATION_DONE
2177 static const struct command_registration cmsis_dap_command_handlers
[] = {
2179 .name
= "cmsis-dap",
2180 .mode
= COMMAND_ANY
,
2181 .help
= "perform CMSIS-DAP management",
2183 .chain
= cmsis_dap_subcommand_handlers
,
2186 .name
= "cmsis_dap_vid_pid",
2187 .handler
= &cmsis_dap_handle_vid_pid_command
,
2188 .mode
= COMMAND_CONFIG
,
2189 .help
= "the vendor ID and product ID of the CMSIS-DAP device",
2190 .usage
= "(vid pid)*",
2193 .name
= "cmsis_dap_backend",
2194 .handler
= &cmsis_dap_handle_backend_command
,
2195 .mode
= COMMAND_CONFIG
,
2196 .help
= "set the communication backend to use (USB bulk or HID).",
2197 .usage
= "(auto | usb_bulk | hid)",
2199 #if BUILD_CMSIS_DAP_USB
2201 .name
= "cmsis_dap_usb",
2202 .chain
= cmsis_dap_usb_subcommand_handlers
,
2203 .mode
= COMMAND_ANY
,
2204 .help
= "USB bulk backend-specific commands",
2208 COMMAND_REGISTRATION_DONE
2211 static const struct swd_driver cmsis_dap_swd_driver
= {
2212 .init
= cmsis_dap_swd_init
,
2213 .switch_seq
= cmsis_dap_swd_switch_seq
,
2214 .read_reg
= cmsis_dap_swd_read_reg
,
2215 .write_reg
= cmsis_dap_swd_write_reg
,
2216 .run
= cmsis_dap_swd_run_queue
,
2219 static const char * const cmsis_dap_transport
[] = { "swd", "jtag", NULL
};
2221 static struct jtag_interface cmsis_dap_interface
= {
2222 .supported
= DEBUG_CAP_TMS_SEQ
,
2223 .execute_queue
= cmsis_dap_execute_queue
,
2226 struct adapter_driver cmsis_dap_adapter_driver
= {
2227 .name
= "cmsis-dap",
2228 .transports
= cmsis_dap_transport
,
2229 .commands
= cmsis_dap_command_handlers
,
2231 .init
= cmsis_dap_init
,
2232 .quit
= cmsis_dap_quit
,
2233 .reset
= cmsis_dap_reset
,
2234 .speed
= cmsis_dap_speed
,
2235 .khz
= cmsis_dap_khz
,
2236 .speed_div
= cmsis_dap_speed_div
,
2237 .config_trace
= cmsis_dap_config_trace
,
2238 .poll_trace
= cmsis_dap_poll_trace
,
2240 .jtag_ops
= &cmsis_dap_interface
,
2241 .swd_ops
= &cmsis_dap_swd_driver
,
Linking to existing account procedure
If you already have an account and want to add another login method
you
MUST first sign in with your existing account and
then change URL to read
https://review.openocd.org/login/?link
to get to this page again but this time it'll work for linking. Thank you.
SSH host keys fingerprints
1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=.. |
|+o.. . |
|*.o . . |
|+B . . . |
|Bo. = o S |
|Oo.+ + = |
|oB=.* = . o |
| =+=.+ + E |
|. .=o . o |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)