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 Status Code */
165 #define DAP_ERROR 0xFF
167 /* CMSIS-DAP SWO Commands */
168 #define CMD_DAP_SWO_TRANSPORT 0x17
169 #define CMD_DAP_SWO_MODE 0x18
170 #define CMD_DAP_SWO_BAUDRATE 0x19
171 #define CMD_DAP_SWO_CONTROL 0x1A
172 #define CMD_DAP_SWO_STATUS 0x1B
173 #define CMD_DAP_SWO_DATA 0x1C
174 #define CMD_DAP_SWO_EX_STATUS 0x1E
176 /* SWO transport mode for reading trace data */
177 #define DAP_SWO_TRANSPORT_NONE 0
178 #define DAP_SWO_TRANSPORT_DATA 1
179 #define DAP_SWO_TRANSPORT_WINUSB 2
181 /* SWO trace capture mode */
182 #define DAP_SWO_MODE_OFF 0
183 #define DAP_SWO_MODE_UART 1
184 #define DAP_SWO_MODE_MANCHESTER 2
186 /* SWO trace data capture */
187 #define DAP_SWO_CONTROL_STOP 0
188 #define DAP_SWO_CONTROL_START 1
190 /* SWO trace status */
191 #define DAP_SWO_STATUS_CAPTURE_INACTIVE 0
192 #define DAP_SWO_STATUS_CAPTURE_ACTIVE 1
193 #define DAP_SWO_STATUS_CAPTURE_MASK BIT(0)
194 #define DAP_SWO_STATUS_STREAM_ERROR_MASK BIT(6)
195 #define DAP_SWO_STATUS_BUFFER_OVERRUN_MASK BIT(7)
197 /* CMSIS-DAP Vendor Commands
200 static const char * const info_caps_str
[INFO_CAPS__NUM_CAPS
] = {
203 "SWO-UART supported",
204 "SWO-MANCHESTER supported",
205 "Atomic commands supported",
206 "Test domain timer supported",
207 "SWO streaming trace supported",
208 "UART communication port supported",
209 "UART via USB COM port supported",
212 struct pending_transfer_result
{
218 struct pending_request_block
{
219 struct pending_transfer_result
*transfers
;
223 struct pending_scan_result
{
224 /** Offset in bytes in the CMD_DAP_JTAG_SEQ response buffer. */
226 /** Number of bits to read. */
228 /** Location to store the result */
230 /** Offset in the destination buffer */
231 unsigned buffer_offset
;
234 /* Up to MIN(packet_count, MAX_PENDING_REQUESTS) requests may be issued
235 * until the first response arrives */
236 #define MAX_PENDING_REQUESTS 3
238 /* Pending requests are organized as a FIFO - circular buffer */
239 /* Each block in FIFO can contain up to pending_queue_len transfers */
240 static int pending_queue_len
;
241 static struct pending_request_block pending_fifo
[MAX_PENDING_REQUESTS
];
242 static int pending_fifo_put_idx
, pending_fifo_get_idx
;
243 static int pending_fifo_block_count
;
245 /* pointers to buffers that will receive jtag scan results on the next flush */
246 #define MAX_PENDING_SCAN_RESULTS 256
247 static int pending_scan_result_count
;
248 static struct pending_scan_result pending_scan_results
[MAX_PENDING_SCAN_RESULTS
];
250 /* queued JTAG sequences that will be executed on the next flush */
251 #define QUEUED_SEQ_BUF_LEN (cmsis_dap_handle->packet_size - 3)
252 static int queued_seq_count
;
253 static int queued_seq_buf_end
;
254 static int queued_seq_tdo_ptr
;
255 static uint8_t queued_seq_buf
[1024]; /* TODO: make dynamic / move into cmsis object */
257 static int queued_retval
;
259 static uint8_t output_pins
= SWJ_PIN_SRST
| SWJ_PIN_TRST
;
261 static struct cmsis_dap
*cmsis_dap_handle
;
264 static int cmsis_dap_quit(void);
266 static int cmsis_dap_open(void)
268 const struct cmsis_dap_backend
*backend
= NULL
;
270 struct cmsis_dap
*dap
= calloc(1, sizeof(struct cmsis_dap
));
272 LOG_ERROR("unable to allocate memory");
276 if (cmsis_dap_backend
>= 0) {
277 /* Use forced backend */
278 backend
= cmsis_dap_backends
[cmsis_dap_backend
];
279 if (backend
->open(dap
, cmsis_dap_vid
, cmsis_dap_pid
, adapter_get_required_serial()) != ERROR_OK
)
282 /* Try all backends */
283 for (unsigned int i
= 0; i
< ARRAY_SIZE(cmsis_dap_backends
); i
++) {
284 backend
= cmsis_dap_backends
[i
];
285 if (backend
->open(dap
, cmsis_dap_vid
, cmsis_dap_pid
, adapter_get_required_serial()) == ERROR_OK
)
293 LOG_ERROR("unable to find a matching CMSIS-DAP device");
298 dap
->backend
= backend
;
300 cmsis_dap_handle
= dap
;
305 static void cmsis_dap_close(struct cmsis_dap
*dap
)
308 dap
->backend
->close(dap
);
312 free(cmsis_dap_handle
->packet_buffer
);
313 free(cmsis_dap_handle
);
314 cmsis_dap_handle
= NULL
;
316 for (int i
= 0; i
< MAX_PENDING_REQUESTS
; i
++) {
317 free(pending_fifo
[i
].transfers
);
318 pending_fifo
[i
].transfers
= NULL
;
322 static void cmsis_dap_flush_read(struct cmsis_dap
*dap
)
325 /* Some CMSIS-DAP adapters keep buffered packets over
326 * USB close/open so we need to flush up to 64 old packets
327 * to be sure all buffers are empty */
328 for (i
= 0; i
< 64; i
++) {
329 int retval
= dap
->backend
->read(dap
, 10);
330 if (retval
== ERROR_TIMEOUT_REACHED
)
334 LOG_DEBUG("Flushed %u packets", i
);
337 /* Send a message and receive the reply */
338 static int cmsis_dap_xfer(struct cmsis_dap
*dap
, int txlen
)
340 if (pending_fifo_block_count
) {
341 LOG_ERROR("pending %d blocks, flushing", pending_fifo_block_count
);
342 while (pending_fifo_block_count
) {
343 dap
->backend
->read(dap
, 10);
344 pending_fifo_block_count
--;
346 pending_fifo_put_idx
= 0;
347 pending_fifo_get_idx
= 0;
350 uint8_t current_cmd
= cmsis_dap_handle
->command
[0];
351 int retval
= dap
->backend
->write(dap
, txlen
, LIBUSB_TIMEOUT_MS
);
356 retval
= dap
->backend
->read(dap
, LIBUSB_TIMEOUT_MS
);
360 uint8_t *resp
= cmsis_dap_handle
->response
;
361 if (resp
[0] == DAP_ERROR
) {
362 LOG_ERROR("CMSIS-DAP command 0x%" PRIx8
" not implemented", current_cmd
);
363 return ERROR_NOT_IMPLEMENTED
;
366 if (resp
[0] != current_cmd
) {
367 LOG_ERROR("CMSIS-DAP command mismatch. Sent 0x%" PRIx8
368 " received 0x%" PRIx8
, current_cmd
, resp
[0]);
370 cmsis_dap_flush_read(dap
);
377 static int cmsis_dap_cmd_dap_swj_pins(uint8_t pins
, uint8_t mask
, uint32_t delay
, uint8_t *input
)
379 uint8_t *command
= cmsis_dap_handle
->command
;
381 command
[0] = CMD_DAP_SWJ_PINS
;
384 h_u32_to_le(&command
[3], delay
);
386 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 7);
387 if (retval
!= ERROR_OK
) {
388 LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_PINS failed.");
389 return ERROR_JTAG_DEVICE_ERROR
;
393 *input
= cmsis_dap_handle
->response
[1];
398 static int cmsis_dap_cmd_dap_swj_clock(uint32_t swj_clock
)
400 uint8_t *command
= cmsis_dap_handle
->command
;
402 /* set clock in Hz */
405 command
[0] = CMD_DAP_SWJ_CLOCK
;
406 h_u32_to_le(&command
[1], swj_clock
);
408 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 5);
409 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
410 LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_CLOCK failed.");
411 return ERROR_JTAG_DEVICE_ERROR
;
417 /* clock a sequence of bits out on TMS, to change JTAG states */
418 static int cmsis_dap_cmd_dap_swj_sequence(uint8_t s_len
, const uint8_t *sequence
)
420 uint8_t *command
= cmsis_dap_handle
->command
;
422 #ifdef CMSIS_DAP_JTAG_DEBUG
423 LOG_DEBUG("cmsis-dap TMS sequence: len=%d", s_len
);
424 for (int i
= 0; i
< DIV_ROUND_UP(s_len
, 8); ++i
)
425 printf("%02X ", sequence
[i
]);
430 command
[0] = CMD_DAP_SWJ_SEQ
;
432 bit_copy(&command
[2], 0, sequence
, 0, s_len
);
434 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 2 + DIV_ROUND_UP(s_len
, 8));
435 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
)
441 static int cmsis_dap_cmd_dap_info(uint8_t info
, uint8_t **data
)
443 uint8_t *command
= cmsis_dap_handle
->command
;
445 command
[0] = CMD_DAP_INFO
;
448 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 2);
449 if (retval
!= ERROR_OK
) {
450 LOG_ERROR("CMSIS-DAP command CMD_INFO failed.");
451 return ERROR_JTAG_DEVICE_ERROR
;
454 *data
= &cmsis_dap_handle
->response
[1];
459 static int cmsis_dap_cmd_dap_led(uint8_t led
, uint8_t state
)
461 uint8_t *command
= cmsis_dap_handle
->command
;
463 command
[0] = CMD_DAP_LED
;
467 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 3);
468 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
469 LOG_ERROR("CMSIS-DAP command CMD_LED failed.");
470 return ERROR_JTAG_DEVICE_ERROR
;
476 static int cmsis_dap_cmd_dap_connect(uint8_t mode
)
478 uint8_t *command
= cmsis_dap_handle
->command
;
480 command
[0] = CMD_DAP_CONNECT
;
483 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 2);
484 if (retval
!= ERROR_OK
) {
485 LOG_ERROR("CMSIS-DAP command CMD_CONNECT failed.");
486 return ERROR_JTAG_DEVICE_ERROR
;
489 if (cmsis_dap_handle
->response
[1] != mode
) {
490 LOG_ERROR("CMSIS-DAP failed to connect in mode (%d)", mode
);
491 return ERROR_JTAG_DEVICE_ERROR
;
497 static int cmsis_dap_cmd_dap_disconnect(void)
499 uint8_t *command
= cmsis_dap_handle
->command
;
501 command
[0] = CMD_DAP_DISCONNECT
;
503 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 1);
504 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
505 LOG_ERROR("CMSIS-DAP command CMD_DISCONNECT failed.");
506 return ERROR_JTAG_DEVICE_ERROR
;
512 static int cmsis_dap_cmd_dap_tfer_configure(uint8_t idle
, uint16_t retry_count
, uint16_t match_retry
)
514 uint8_t *command
= cmsis_dap_handle
->command
;
516 command
[0] = CMD_DAP_TFER_CONFIGURE
;
518 h_u16_to_le(&command
[2], retry_count
);
519 h_u16_to_le(&command
[4], match_retry
);
521 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 6);
522 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
523 LOG_ERROR("CMSIS-DAP command CMD_TFER_Configure failed.");
524 return ERROR_JTAG_DEVICE_ERROR
;
530 static int cmsis_dap_cmd_dap_swd_configure(uint8_t cfg
)
532 uint8_t *command
= cmsis_dap_handle
->command
;
534 command
[0] = CMD_DAP_SWD_CONFIGURE
;
537 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 2);
538 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
539 LOG_ERROR("CMSIS-DAP command CMD_SWD_Configure failed.");
540 return ERROR_JTAG_DEVICE_ERROR
;
547 static int cmsis_dap_cmd_dap_delay(uint16_t delay_us
)
549 uint8_t *command
= cmsis_dap_handle
->command
;
551 command
[0] = CMD_DAP_DELAY
;
552 h_u16_to_le(&command
[1], delay_us
);
554 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 3);
555 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
556 LOG_ERROR("CMSIS-DAP command CMD_Delay failed.");
557 return ERROR_JTAG_DEVICE_ERROR
;
564 static int cmsis_dap_metacmd_targetsel(uint32_t instance_id
)
566 uint8_t *command
= cmsis_dap_handle
->command
;
567 const uint32_t SEQ_RD
= 0x80, SEQ_WR
= 0x00;
569 /* SWD multi-drop requires a transfer ala CMD_DAP_TFER,
570 but with no expectation of an SWD ACK response. In
571 CMSIS-DAP v1.20 and v2.00, CMD_DAP_SWD_SEQUENCE was
572 added to allow this special sequence to be generated.
573 The purpose of this operation is to select the target
574 corresponding to the instance_id that is written */
576 LOG_DEBUG_IO("DP write reg TARGETSEL %" PRIx32
, instance_id
);
579 command
[idx
++] = CMD_DAP_SWD_SEQUENCE
;
580 command
[idx
++] = 3; /* sequence count */
582 /* sequence 0: packet request for TARGETSEL */
583 command
[idx
++] = SEQ_WR
| 8;
584 command
[idx
++] = SWD_CMD_START
| swd_cmd(false, false, DP_TARGETSEL
) | SWD_CMD_STOP
| SWD_CMD_PARK
;
586 /* sequence 1: read Trn ACK Trn, no expectation for target to ACK */
587 command
[idx
++] = SEQ_RD
| 5;
589 /* sequence 2: WDATA plus parity */
590 command
[idx
++] = SEQ_WR
| (32 + 1);
591 h_u32_to_le(command
+ idx
, instance_id
);
593 command
[idx
++] = parity_u32(instance_id
);
595 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, idx
);
596 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
597 LOG_ERROR("CMSIS-DAP command SWD_Sequence failed.");
598 return ERROR_JTAG_DEVICE_ERROR
;
605 * Sets the SWO transport mode.
606 * @param[in] transport The transport mode. Can be None, SWO_Data or
607 * WinUSB (requires CMSIS-DAP v2).
609 static int cmsis_dap_cmd_dap_swo_transport(uint8_t transport
)
611 uint8_t *command
= cmsis_dap_handle
->command
;
613 command
[0] = CMD_DAP_SWO_TRANSPORT
;
614 command
[1] = transport
;
616 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 2);
617 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
618 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Transport(%d) failed.", transport
);
619 return ERROR_JTAG_DEVICE_ERROR
;
626 * Sets the SWO trace capture mode.
627 * @param[in] mode Trace capture mode. Can be UART or MANCHESTER.
629 static int cmsis_dap_cmd_dap_swo_mode(uint8_t mode
)
631 uint8_t *command
= cmsis_dap_handle
->command
;
633 command
[0] = CMD_DAP_SWO_MODE
;
636 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 2);
637 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
638 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Mode(%d) failed.", mode
);
639 return ERROR_JTAG_DEVICE_ERROR
;
646 * Sets the baudrate for capturing SWO trace data.
647 * Can be called iteratively to determine supported baudrates.
648 * @param[in] in_baudrate Requested baudrate.
649 * @param[out] dev_baudrate Actual baudrate or 0 (baudrate not configured).
650 * When requested baudrate is not achievable the
651 * closest configured baudrate can be returned or
652 * 0 which indicates that baudrate was not configured.
654 static int cmsis_dap_cmd_dap_swo_baudrate(
655 uint32_t in_baudrate
,
656 uint32_t *dev_baudrate
)
658 uint8_t *command
= cmsis_dap_handle
->command
;
660 command
[0] = CMD_DAP_SWO_BAUDRATE
;
661 h_u32_to_le(&command
[1], in_baudrate
);
663 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 5);
664 uint32_t rvbr
= le_to_h_u32(&cmsis_dap_handle
->response
[1]);
665 if (retval
!= ERROR_OK
|| rvbr
== 0) {
666 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Baudrate(%u) -> %u failed.", in_baudrate
, rvbr
);
669 return ERROR_JTAG_DEVICE_ERROR
;
673 *dev_baudrate
= rvbr
;
679 * Controls the SWO trace data capture.
680 * @param[in] control Start or stop a trace. Starting capture automatically
681 * flushes any existing trace data in buffers which has
684 static int cmsis_dap_cmd_dap_swo_control(uint8_t control
)
686 uint8_t *command
= cmsis_dap_handle
->command
;
688 command
[0] = CMD_DAP_SWO_CONTROL
;
689 command
[1] = control
;
691 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 2);
692 if (retval
!= ERROR_OK
|| cmsis_dap_handle
->response
[1] != DAP_OK
) {
693 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Control(%d) failed.", control
);
694 return ERROR_JTAG_DEVICE_ERROR
;
701 * Reads the SWO trace status.
702 * @param[out] trace_status The trace's status.
703 * Bit0: Trace Capture (1 - active, 0 - inactive).
704 * Bit6: Trace Stream Error.
705 * Bit7: Trace Buffer Overrun.
706 * @param[out] trace_count Number of bytes in Trace Buffer (not yet read).
708 static int cmsis_dap_cmd_dap_swo_status(
709 uint8_t *trace_status
,
712 uint8_t *command
= cmsis_dap_handle
->command
;
714 command
[0] = CMD_DAP_SWO_STATUS
;
716 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 1);
717 if (retval
!= ERROR_OK
) {
718 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Status failed.");
719 return ERROR_JTAG_DEVICE_ERROR
;
723 *trace_status
= cmsis_dap_handle
->response
[1];
725 *trace_count
= le_to_h_u32(&cmsis_dap_handle
->response
[2]);
731 * Reads the captured SWO trace data from Trace Buffer.
732 * @param[in] max_trace_count Maximum number of Trace Data bytes to read.
733 * @param[out] trace_status The trace's status.
734 * @param[out] trace_count Number of Trace Data bytes read.
735 * @param[out] data Trace Data bytes read.
737 static int cmsis_dap_cmd_dap_swo_data(
738 size_t max_trace_count
,
739 uint8_t *trace_status
,
743 uint8_t *command
= cmsis_dap_handle
->command
;
745 command
[0] = CMD_DAP_SWO_DATA
;
746 h_u16_to_le(&command
[1], max_trace_count
);
748 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, 3);
749 if (retval
!= ERROR_OK
) {
750 LOG_ERROR("CMSIS-DAP: command CMD_SWO_Data failed.");
751 return ERROR_JTAG_DEVICE_ERROR
;
754 *trace_status
= cmsis_dap_handle
->response
[1];
755 *trace_count
= le_to_h_u16(&cmsis_dap_handle
->response
[2]);
757 if (*trace_count
> 0)
758 memcpy(data
, &cmsis_dap_handle
->response
[4], *trace_count
);
763 static void cmsis_dap_swd_write_from_queue(struct cmsis_dap
*dap
)
765 uint8_t *command
= cmsis_dap_handle
->command
;
766 struct pending_request_block
*block
= &pending_fifo
[pending_fifo_put_idx
];
768 LOG_DEBUG_IO("Executing %d queued transactions from FIFO index %d", block
->transfer_count
, pending_fifo_put_idx
);
770 if (queued_retval
!= ERROR_OK
) {
771 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval
);
775 if (block
->transfer_count
== 0)
778 command
[0] = CMD_DAP_TFER
;
779 command
[1] = 0x00; /* DAP Index */
780 command
[2] = block
->transfer_count
;
783 for (int i
= 0; i
< block
->transfer_count
; i
++) {
784 struct pending_transfer_result
*transfer
= &(block
->transfers
[i
]);
785 uint8_t cmd
= transfer
->cmd
;
786 uint32_t data
= transfer
->data
;
788 LOG_DEBUG_IO("%s %s reg %x %" PRIx32
,
789 cmd
& SWD_CMD_APNDP
? "AP" : "DP",
790 cmd
& SWD_CMD_RNW
? "read" : "write",
791 (cmd
& SWD_CMD_A32
) >> 1, data
);
793 /* When proper WAIT handling is implemented in the
794 * common SWD framework, this kludge can be
795 * removed. However, this might lead to minor
796 * performance degradation as the adapter wouldn't be
797 * able to automatically retry anything (because ARM
798 * has forgotten to implement sticky error flags
799 * clearing). See also comments regarding
800 * cmsis_dap_cmd_dap_tfer_configure() and
801 * cmsis_dap_cmd_dap_swd_configure() in
804 if (!(cmd
& SWD_CMD_RNW
) &&
805 !(cmd
& SWD_CMD_APNDP
) &&
806 (cmd
& SWD_CMD_A32
) >> 1 == DP_CTRL_STAT
&&
807 (data
& CORUNDETECT
)) {
808 LOG_DEBUG("refusing to enable sticky overrun detection");
809 data
&= ~CORUNDETECT
;
812 command
[idx
++] = (cmd
>> 1) & 0x0f;
813 if (!(cmd
& SWD_CMD_RNW
)) {
814 h_u32_to_le(&command
[idx
], data
);
819 int retval
= dap
->backend
->write(dap
, idx
, LIBUSB_TIMEOUT_MS
);
821 queued_retval
= retval
;
824 queued_retval
= ERROR_OK
;
827 pending_fifo_put_idx
= (pending_fifo_put_idx
+ 1) % dap
->packet_count
;
828 pending_fifo_block_count
++;
829 if (pending_fifo_block_count
> dap
->packet_count
)
830 LOG_ERROR("too much pending writes %d", pending_fifo_block_count
);
835 block
->transfer_count
= 0;
838 static void cmsis_dap_swd_read_process(struct cmsis_dap
*dap
, int timeout_ms
)
840 struct pending_request_block
*block
= &pending_fifo
[pending_fifo_get_idx
];
842 if (pending_fifo_block_count
== 0)
843 LOG_ERROR("no pending write");
846 int retval
= dap
->backend
->read(dap
, timeout_ms
);
847 if (retval
== ERROR_TIMEOUT_REACHED
&& timeout_ms
< LIBUSB_TIMEOUT_MS
)
851 LOG_DEBUG("error reading data");
852 queued_retval
= ERROR_FAIL
;
856 uint8_t *resp
= dap
->response
;
857 if (resp
[0] != CMD_DAP_TFER
) {
858 LOG_ERROR("CMSIS-DAP command mismatch. Expected 0x%x received 0x%" PRIx8
,
859 CMD_DAP_TFER
, resp
[0]);
860 queued_retval
= ERROR_FAIL
;
864 uint8_t transfer_count
= resp
[1];
865 uint8_t ack
= resp
[2] & 0x07;
866 if (resp
[2] & 0x08) {
867 LOG_DEBUG("CMSIS-DAP Protocol Error @ %d (wrong parity)", transfer_count
);
868 queued_retval
= ERROR_FAIL
;
871 if (ack
!= SWD_ACK_OK
) {
872 LOG_DEBUG("SWD ack not OK @ %d %s", transfer_count
,
873 ack
== SWD_ACK_WAIT
? "WAIT" : ack
== SWD_ACK_FAULT
? "FAULT" : "JUNK");
874 queued_retval
= ack
== SWD_ACK_WAIT
? ERROR_WAIT
: ERROR_FAIL
;
875 /* TODO: use results of transfers completed before the error occurred? */
879 if (block
->transfer_count
!= transfer_count
)
880 LOG_ERROR("CMSIS-DAP transfer count mismatch: expected %d, got %d",
881 block
->transfer_count
, transfer_count
);
883 LOG_DEBUG_IO("Received results of %d queued transactions FIFO index %d",
884 transfer_count
, pending_fifo_get_idx
);
886 for (int i
= 0; i
< transfer_count
; i
++) {
887 struct pending_transfer_result
*transfer
= &(block
->transfers
[i
]);
888 if (transfer
->cmd
& SWD_CMD_RNW
) {
889 static uint32_t last_read
;
890 uint32_t data
= le_to_h_u32(&resp
[idx
]);
894 LOG_DEBUG_IO("Read result: %" PRIx32
, data
);
896 /* Imitate posted AP reads */
897 if ((transfer
->cmd
& SWD_CMD_APNDP
) ||
898 ((transfer
->cmd
& SWD_CMD_A32
) >> 1 == DP_RDBUFF
)) {
903 if (transfer
->buffer
)
904 *(uint32_t *)(transfer
->buffer
) = tmp
;
909 block
->transfer_count
= 0;
910 pending_fifo_get_idx
= (pending_fifo_get_idx
+ 1) % dap
->packet_count
;
911 pending_fifo_block_count
--;
914 static int cmsis_dap_swd_run_queue(void)
916 if (pending_fifo_block_count
)
917 cmsis_dap_swd_read_process(cmsis_dap_handle
, 0);
919 cmsis_dap_swd_write_from_queue(cmsis_dap_handle
);
921 while (pending_fifo_block_count
)
922 cmsis_dap_swd_read_process(cmsis_dap_handle
, LIBUSB_TIMEOUT_MS
);
924 pending_fifo_put_idx
= 0;
925 pending_fifo_get_idx
= 0;
927 int retval
= queued_retval
;
928 queued_retval
= ERROR_OK
;
933 static void cmsis_dap_swd_queue_cmd(uint8_t cmd
, uint32_t *dst
, uint32_t data
)
935 bool targetsel_cmd
= swd_cmd(false, false, DP_TARGETSEL
) == cmd
;
937 if (pending_fifo
[pending_fifo_put_idx
].transfer_count
== pending_queue_len
939 if (pending_fifo_block_count
)
940 cmsis_dap_swd_read_process(cmsis_dap_handle
, 0);
942 /* Not enough room in the queue. Run the queue. */
943 cmsis_dap_swd_write_from_queue(cmsis_dap_handle
);
945 if (pending_fifo_block_count
>= cmsis_dap_handle
->packet_count
)
946 cmsis_dap_swd_read_process(cmsis_dap_handle
, LIBUSB_TIMEOUT_MS
);
949 if (queued_retval
!= ERROR_OK
)
953 cmsis_dap_metacmd_targetsel(data
);
957 struct pending_request_block
*block
= &pending_fifo
[pending_fifo_put_idx
];
958 struct pending_transfer_result
*transfer
= &(block
->transfers
[block
->transfer_count
]);
959 transfer
->data
= data
;
961 if (cmd
& SWD_CMD_RNW
) {
962 /* Queue a read transaction */
963 transfer
->buffer
= dst
;
965 block
->transfer_count
++;
968 static void cmsis_dap_swd_write_reg(uint8_t cmd
, uint32_t value
, uint32_t ap_delay_clk
)
970 assert(!(cmd
& SWD_CMD_RNW
));
971 cmsis_dap_swd_queue_cmd(cmd
, NULL
, value
);
974 static void cmsis_dap_swd_read_reg(uint8_t cmd
, uint32_t *value
, uint32_t ap_delay_clk
)
976 assert(cmd
& SWD_CMD_RNW
);
977 cmsis_dap_swd_queue_cmd(cmd
, value
, 0);
980 static int cmsis_dap_get_serial_info(void)
984 int retval
= cmsis_dap_cmd_dap_info(INFO_ID_SERNUM
, &data
);
985 if (retval
!= ERROR_OK
)
988 if (data
[0]) /* strlen */
989 LOG_INFO("CMSIS-DAP: Serial# = %s", &data
[1]);
994 static int cmsis_dap_get_version_info(void)
998 /* INFO_ID_FW_VER - string */
999 int retval
= cmsis_dap_cmd_dap_info(INFO_ID_FW_VER
, &data
);
1000 if (retval
!= ERROR_OK
)
1003 if (data
[0]) /* strlen */
1004 LOG_INFO("CMSIS-DAP: FW Version = %s", &data
[1]);
1009 static int cmsis_dap_get_caps_info(void)
1013 /* INFO_ID_CAPS - byte */
1014 int retval
= cmsis_dap_cmd_dap_info(INFO_ID_CAPS
, &data
);
1015 if (retval
!= ERROR_OK
)
1018 if (data
[0] == 1 || data
[0] == 2) {
1019 uint16_t caps
= data
[1];
1021 caps
|= (uint16_t)data
[2] << 8;
1023 cmsis_dap_handle
->caps
= caps
;
1025 for (int i
= 0; i
< INFO_CAPS__NUM_CAPS
; ++i
) {
1027 LOG_INFO("CMSIS-DAP: %s", info_caps_str
[i
]);
1034 static int cmsis_dap_get_swo_buf_sz(uint32_t *swo_buf_sz
)
1038 /* INFO_ID_SWO_BUF_SZ - word */
1039 int retval
= cmsis_dap_cmd_dap_info(INFO_ID_SWO_BUF_SZ
, &data
);
1040 if (retval
!= ERROR_OK
)
1046 *swo_buf_sz
= le_to_h_u32(&data
[1]);
1048 LOG_INFO("CMSIS-DAP: SWO Trace Buffer Size = %u bytes", *swo_buf_sz
);
1053 static int cmsis_dap_get_status(void)
1057 int retval
= cmsis_dap_cmd_dap_swj_pins(0, 0, 0, &d
);
1059 if (retval
== ERROR_OK
) {
1060 LOG_INFO("SWCLK/TCK = %d SWDIO/TMS = %d TDI = %d TDO = %d nTRST = %d nRESET = %d",
1061 (d
& SWJ_PIN_TCK
) ? 1 : 0,
1062 (d
& SWJ_PIN_TMS
) ? 1 : 0,
1063 (d
& SWJ_PIN_TDI
) ? 1 : 0,
1064 (d
& SWJ_PIN_TDO
) ? 1 : 0,
1065 (d
& SWJ_PIN_TRST
) ? 1 : 0,
1066 (d
& SWJ_PIN_SRST
) ? 1 : 0);
1072 static int cmsis_dap_swd_switch_seq(enum swd_special_seq seq
)
1078 if ((output_pins
& (SWJ_PIN_SRST
| SWJ_PIN_TRST
)) == (SWJ_PIN_SRST
| SWJ_PIN_TRST
)) {
1079 /* Following workaround deasserts reset on most adapters.
1080 * Do not reconnect if a reset line is active!
1081 * Reconnecting would break connecting under reset. */
1083 /* First disconnect before connecting, Atmel EDBG needs it for SAMD/R/L/C */
1084 cmsis_dap_cmd_dap_disconnect();
1086 /* When we are reconnecting, DAP_Connect needs to be rerun, at
1087 * least on Keil ULINK-ME */
1088 retval
= cmsis_dap_cmd_dap_connect(CONNECT_SWD
);
1089 if (retval
!= ERROR_OK
)
1095 LOG_DEBUG_IO("SWD line reset");
1096 s
= swd_seq_line_reset
;
1097 s_len
= swd_seq_line_reset_len
;
1100 LOG_DEBUG("JTAG-to-SWD");
1101 s
= swd_seq_jtag_to_swd
;
1102 s_len
= swd_seq_jtag_to_swd_len
;
1104 case JTAG_TO_DORMANT
:
1105 LOG_DEBUG("JTAG-to-DORMANT");
1106 s
= swd_seq_jtag_to_dormant
;
1107 s_len
= swd_seq_jtag_to_dormant_len
;
1110 LOG_DEBUG("SWD-to-JTAG");
1111 s
= swd_seq_swd_to_jtag
;
1112 s_len
= swd_seq_swd_to_jtag_len
;
1114 case SWD_TO_DORMANT
:
1115 LOG_DEBUG("SWD-to-DORMANT");
1116 s
= swd_seq_swd_to_dormant
;
1117 s_len
= swd_seq_swd_to_dormant_len
;
1119 case DORMANT_TO_SWD
:
1120 LOG_DEBUG("DORMANT-to-SWD");
1121 s
= swd_seq_dormant_to_swd
;
1122 s_len
= swd_seq_dormant_to_swd_len
;
1124 case DORMANT_TO_JTAG
:
1125 LOG_DEBUG("DORMANT-to-JTAG");
1126 s
= swd_seq_dormant_to_jtag
;
1127 s_len
= swd_seq_dormant_to_jtag_len
;
1130 LOG_ERROR("Sequence %d not supported", seq
);
1134 retval
= cmsis_dap_cmd_dap_swj_sequence(s_len
, s
);
1135 if (retval
!= ERROR_OK
)
1138 /* Atmel EDBG needs renew clock setting after SWJ_Sequence
1139 * otherwise default frequency is used */
1140 return cmsis_dap_cmd_dap_swj_clock(adapter_get_speed_khz());
1143 static int cmsis_dap_swd_open(void)
1145 if (!(cmsis_dap_handle
->caps
& INFO_CAPS_SWD
)) {
1146 LOG_ERROR("CMSIS-DAP: SWD not supported");
1147 return ERROR_JTAG_DEVICE_ERROR
;
1150 int retval
= cmsis_dap_cmd_dap_connect(CONNECT_SWD
);
1151 if (retval
!= ERROR_OK
)
1154 /* Add more setup here.??... */
1156 LOG_INFO("CMSIS-DAP: Interface Initialised (SWD)");
1160 static int cmsis_dap_init(void)
1164 int retval
= cmsis_dap_open();
1165 if (retval
!= ERROR_OK
)
1168 cmsis_dap_flush_read(cmsis_dap_handle
);
1170 retval
= cmsis_dap_get_caps_info();
1171 if (retval
!= ERROR_OK
)
1174 retval
= cmsis_dap_get_version_info();
1175 if (retval
!= ERROR_OK
)
1178 retval
= cmsis_dap_get_serial_info();
1179 if (retval
!= ERROR_OK
)
1183 retval
= cmsis_dap_swd_open();
1184 if (retval
!= ERROR_OK
)
1187 /* Connect in JTAG mode */
1188 if (!(cmsis_dap_handle
->caps
& INFO_CAPS_JTAG
)) {
1189 LOG_ERROR("CMSIS-DAP: JTAG not supported");
1190 return ERROR_JTAG_DEVICE_ERROR
;
1193 retval
= cmsis_dap_cmd_dap_connect(CONNECT_JTAG
);
1194 if (retval
!= ERROR_OK
)
1197 LOG_INFO("CMSIS-DAP: Interface Initialised (JTAG)");
1200 /* Be conservative and suppress submitting multiple HID requests
1201 * until we get packet count info from the adaptor */
1202 cmsis_dap_handle
->packet_count
= 1;
1203 pending_queue_len
= 12;
1205 /* INFO_ID_PKT_SZ - short */
1206 retval
= cmsis_dap_cmd_dap_info(INFO_ID_PKT_SZ
, &data
);
1207 if (retval
!= ERROR_OK
)
1210 if (data
[0] == 2) { /* short */
1211 uint16_t pkt_sz
= data
[1] + (data
[2] << 8);
1212 if (pkt_sz
!= cmsis_dap_handle
->packet_size
) {
1214 /* 4 bytes of command header + 5 bytes per register
1215 * write. For bulk read sequences just 4 bytes are
1216 * needed per transfer, so this is suboptimal. */
1217 pending_queue_len
= (pkt_sz
- 4) / 5;
1219 free(cmsis_dap_handle
->packet_buffer
);
1220 retval
= cmsis_dap_handle
->backend
->packet_buffer_alloc(cmsis_dap_handle
, pkt_sz
);
1221 if (retval
!= ERROR_OK
)
1224 LOG_DEBUG("CMSIS-DAP: Packet Size = %" PRIu16
, pkt_sz
);
1228 /* INFO_ID_PKT_CNT - byte */
1229 retval
= cmsis_dap_cmd_dap_info(INFO_ID_PKT_CNT
, &data
);
1230 if (retval
!= ERROR_OK
)
1233 if (data
[0] == 1) { /* byte */
1234 int pkt_cnt
= data
[1];
1236 cmsis_dap_handle
->packet_count
= MIN(MAX_PENDING_REQUESTS
, pkt_cnt
);
1238 LOG_DEBUG("CMSIS-DAP: Packet Count = %d", pkt_cnt
);
1241 LOG_DEBUG("Allocating FIFO for %d pending packets", cmsis_dap_handle
->packet_count
);
1242 for (int i
= 0; i
< cmsis_dap_handle
->packet_count
; i
++) {
1243 pending_fifo
[i
].transfers
= malloc(pending_queue_len
* sizeof(struct pending_transfer_result
));
1244 if (!pending_fifo
[i
].transfers
) {
1245 LOG_ERROR("Unable to allocate memory for CMSIS-DAP queue");
1246 retval
= ERROR_FAIL
;
1251 /* Intentionally not checked for error, just logs an info message
1252 * not vital for further debugging */
1253 (void)cmsis_dap_get_status();
1255 /* Now try to connect to the target
1256 * TODO: This is all SWD only @ present */
1257 retval
= cmsis_dap_cmd_dap_swj_clock(adapter_get_speed_khz());
1258 if (retval
!= ERROR_OK
)
1261 /* Ask CMSIS-DAP to automatically retry on receiving WAIT for
1262 * up to 64 times. This must be changed to 0 if sticky
1263 * overrun detection is enabled. */
1264 retval
= cmsis_dap_cmd_dap_tfer_configure(0, 64, 0);
1265 if (retval
!= ERROR_OK
)
1269 /* Data Phase (bit 2) must be set to 1 if sticky overrun
1270 * detection is enabled */
1271 retval
= cmsis_dap_cmd_dap_swd_configure(0); /* 1 TRN, no Data Phase */
1272 if (retval
!= ERROR_OK
)
1276 /* Intentionally not checked for error, debugging will work
1278 (void)cmsis_dap_cmd_dap_led(LED_ID_CONNECT
, LED_ON
);
1279 (void)cmsis_dap_cmd_dap_led(LED_ID_RUN
, LED_ON
);
1281 /* support connecting with srst asserted */
1282 enum reset_types jtag_reset_config
= jtag_get_reset_config();
1284 if (jtag_reset_config
& RESET_CNCT_UNDER_SRST
) {
1285 if (jtag_reset_config
& RESET_SRST_NO_GATING
) {
1286 retval
= cmsis_dap_cmd_dap_swj_pins(0, SWJ_PIN_SRST
, 0, NULL
);
1287 if (retval
!= ERROR_OK
)
1289 LOG_INFO("Connecting under reset");
1292 LOG_INFO("CMSIS-DAP: Interface ready");
1300 static int cmsis_dap_swd_init(void)
1306 static int cmsis_dap_quit(void)
1308 cmsis_dap_cmd_dap_disconnect();
1311 cmsis_dap_cmd_dap_led(LED_ID_RUN
, LED_OFF
);
1312 cmsis_dap_cmd_dap_led(LED_ID_CONNECT
, LED_OFF
);
1314 cmsis_dap_close(cmsis_dap_handle
);
1319 static int cmsis_dap_reset(int trst
, int srst
)
1321 /* Set both TRST and SRST even if they're not enabled as
1322 * there's no way to tristate them */
1326 output_pins
|= SWJ_PIN_SRST
;
1328 output_pins
|= SWJ_PIN_TRST
;
1330 int retval
= cmsis_dap_cmd_dap_swj_pins(output_pins
,
1331 SWJ_PIN_TRST
| SWJ_PIN_SRST
, 0, NULL
);
1332 if (retval
!= ERROR_OK
)
1333 LOG_ERROR("CMSIS-DAP: Interface reset failed");
1337 static void cmsis_dap_execute_sleep(struct jtag_command
*cmd
)
1340 int retval
= cmsis_dap_cmd_dap_delay(cmd
->cmd
.sleep
->us
);
1341 if (retval
!= ERROR_OK
)
1343 jtag_sleep(cmd
->cmd
.sleep
->us
);
1346 /* Set TMS high for five TCK clocks, to move the TAP to the Test-Logic-Reset state */
1347 static int cmsis_dap_execute_tlr_reset(struct jtag_command
*cmd
)
1349 LOG_INFO("cmsis-dap JTAG TLR_RESET");
1352 int retval
= cmsis_dap_cmd_dap_swj_sequence(8, &seq
);
1353 if (retval
== ERROR_OK
)
1354 tap_set_state(TAP_RESET
);
1358 /* Set new end state */
1359 static void cmsis_dap_end_state(tap_state_t state
)
1361 if (tap_is_state_stable(state
))
1362 tap_set_end_state(state
);
1364 LOG_ERROR("BUG: %i is not a valid end state", state
);
1369 #ifdef SPRINT_BINARY
1370 static void sprint_binary(char *s
, const uint8_t *buf
, int offset
, int len
)
1376 buf = { 0x18 } len=5 should result in: 11000
1377 buf = { 0xff 0x18 } len=13 should result in: 11111111 11000
1378 buf = { 0xc0 0x18 } offset=3 len=10 should result in: 11000 11000
1379 i=3 there means i/8 = 0 so c = 0xFF, and
1381 for (int i
= offset
; i
< offset
+ len
; ++i
) {
1382 uint8_t c
= buf
[i
/ 8], mask
= 1 << (i
% 8);
1383 if ((i
!= offset
) && !(i
% 8))
1385 *s
++ = (c
& mask
) ? '1' : '0';
1391 #ifdef CMSIS_DAP_JTAG_DEBUG
1392 static void debug_parse_cmsis_buf(const uint8_t *cmd
, int cmdlen
)
1394 /* cmd is a usb packet to go to the cmsis-dap interface */
1395 printf("cmsis-dap buffer (%d b): ", cmdlen
);
1396 for (int i
= 0; i
< cmdlen
; ++i
)
1397 printf(" %02x", cmd
[i
]);
1400 case CMD_DAP_JTAG_SEQ
: {
1401 printf("cmsis-dap jtag sequence command %02x (n=%d)\n", cmd
[0], cmd
[1]);
1403 * #1 = number of sequences
1404 * #2 = sequence info 1
1405 * #3...4+n_bytes-1 = sequence 1
1406 * #4+n_bytes = sequence info 2
1407 * #5+n_bytes = sequence 2 (single bit)
1410 for (int seq
= 0; seq
< cmd
[1]; ++seq
) {
1411 uint8_t info
= cmd
[pos
++];
1412 int len
= info
& DAP_JTAG_SEQ_TCK
;
1415 printf(" sequence %d starting %d: info %02x (len=%d tms=%d read_tdo=%d): ",
1416 seq
, pos
, info
, len
, info
& DAP_JTAG_SEQ_TMS
, info
& DAP_JTAG_SEQ_TDO
);
1417 for (int i
= 0; i
< DIV_ROUND_UP(len
, 8); ++i
)
1418 printf(" %02x", cmd
[pos
+i
]);
1419 pos
+= DIV_ROUND_UP(len
, 8);
1422 if (pos
!= cmdlen
) {
1423 printf("BUFFER LENGTH MISMATCH looks like %d but %d specified", pos
, cmdlen
);
1430 LOG_DEBUG("unknown cmsis-dap command %02x", cmd
[1]);
1436 static void cmsis_dap_flush(void)
1438 if (!queued_seq_count
)
1441 LOG_DEBUG_IO("Flushing %d queued sequences (%d bytes) with %d pending scan results to capture",
1442 queued_seq_count
, queued_seq_buf_end
, pending_scan_result_count
);
1444 /* prepare CMSIS-DAP packet */
1445 uint8_t *command
= cmsis_dap_handle
->command
;
1446 command
[0] = CMD_DAP_JTAG_SEQ
;
1447 command
[1] = queued_seq_count
;
1448 memcpy(&command
[2], queued_seq_buf
, queued_seq_buf_end
);
1450 #ifdef CMSIS_DAP_JTAG_DEBUG
1451 debug_parse_cmsis_buf(command
, queued_seq_buf_end
+ 2);
1454 /* send command to USB device */
1455 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, queued_seq_buf_end
+ 2);
1457 uint8_t *resp
= cmsis_dap_handle
->response
;
1458 if (retval
!= ERROR_OK
|| resp
[1] != DAP_OK
) {
1459 LOG_ERROR("CMSIS-DAP command CMD_DAP_JTAG_SEQ failed.");
1463 #ifdef CMSIS_DAP_JTAG_DEBUG
1464 LOG_DEBUG_IO("USB response buf:");
1465 for (int c
= 0; c
< queued_seq_buf_end
+ 3; ++c
)
1466 printf("%02X ", resp
[c
]);
1470 /* copy scan results into client buffers */
1471 for (int i
= 0; i
< pending_scan_result_count
; ++i
) {
1472 struct pending_scan_result
*scan
= &pending_scan_results
[i
];
1473 LOG_DEBUG_IO("Copying pending_scan_result %d/%d: %d bits from byte %d -> buffer + %d bits",
1474 i
, pending_scan_result_count
, scan
->length
, scan
->first
+ 2, scan
->buffer_offset
);
1475 #ifdef CMSIS_DAP_JTAG_DEBUG
1476 for (uint32_t b
= 0; b
< DIV_ROUND_UP(scan
->length
, 8); ++b
)
1477 printf("%02X ", resp
[2+scan
->first
+b
]);
1480 bit_copy(scan
->buffer
, scan
->buffer_offset
, &resp
[2 + scan
->first
], 0, scan
->length
);
1484 queued_seq_count
= 0;
1485 queued_seq_buf_end
= 0;
1486 queued_seq_tdo_ptr
= 0;
1487 pending_scan_result_count
= 0;
1490 /* queue a sequence of bits to clock out TDI / in TDO, executing if the buffer is full.
1492 * sequence=NULL means clock out zeros on TDI
1493 * tdo_buffer=NULL means don't capture TDO
1495 static void cmsis_dap_add_jtag_sequence(int s_len
, const uint8_t *sequence
, int s_offset
,
1496 bool tms
, uint8_t *tdo_buffer
, int tdo_buffer_offset
)
1498 LOG_DEBUG_IO("[at %d] %d bits, tms %s, seq offset %d, tdo buf %p, tdo offset %d",
1500 s_len
, tms
? "HIGH" : "LOW", s_offset
, tdo_buffer
, tdo_buffer_offset
);
1506 LOG_DEBUG_IO("START JTAG SEQ SPLIT");
1507 for (int offset
= 0; offset
< s_len
; offset
+= 64) {
1508 int len
= s_len
- offset
;
1511 LOG_DEBUG_IO("Splitting long jtag sequence: %d-bit chunk starting at offset %d", len
, offset
);
1512 cmsis_dap_add_jtag_sequence(
1518 !tdo_buffer
? 0 : (tdo_buffer_offset
+ offset
)
1521 LOG_DEBUG_IO("END JTAG SEQ SPLIT");
1525 int cmd_len
= 1 + DIV_ROUND_UP(s_len
, 8);
1526 if (queued_seq_count
>= 255 || queued_seq_buf_end
+ cmd_len
> QUEUED_SEQ_BUF_LEN
)
1527 /* empty out the buffer */
1533 queued_seq_buf
[queued_seq_buf_end
] =
1534 (tms
? DAP_JTAG_SEQ_TMS
: 0) |
1535 (tdo_buffer
? DAP_JTAG_SEQ_TDO
: 0) |
1536 (s_len
== 64 ? 0 : s_len
);
1539 bit_copy(&queued_seq_buf
[queued_seq_buf_end
+ 1], 0, sequence
, s_offset
, s_len
);
1541 memset(&queued_seq_buf
[queued_seq_buf_end
+ 1], 0, DIV_ROUND_UP(s_len
, 8));
1543 queued_seq_buf_end
+= cmd_len
;
1546 struct pending_scan_result
*scan
= &pending_scan_results
[pending_scan_result_count
++];
1547 scan
->first
= queued_seq_tdo_ptr
;
1548 queued_seq_tdo_ptr
+= DIV_ROUND_UP(s_len
, 8);
1549 scan
->length
= s_len
;
1550 scan
->buffer
= tdo_buffer
;
1551 scan
->buffer_offset
= tdo_buffer_offset
;
1555 /* queue a sequence of bits to clock out TMS, executing if the buffer is full */
1556 static void cmsis_dap_add_tms_sequence(const uint8_t *sequence
, int s_len
)
1558 LOG_DEBUG_IO("%d bits: %02X", s_len
, *sequence
);
1559 /* we use a series of CMD_DAP_JTAG_SEQ commands to toggle TMS,
1560 because even though it seems ridiculously inefficient, it
1561 allows us to combine TMS and scan sequences into the same
1563 /* TODO: combine runs of the same tms value */
1564 for (int i
= 0; i
< s_len
; ++i
) {
1565 bool bit
= (sequence
[i
/ 8] & (1 << (i
% 8))) != 0;
1566 cmsis_dap_add_jtag_sequence(1, NULL
, 0, bit
, NULL
, 0);
1570 /* Move to the end state by queuing a sequence to clock into TMS */
1571 static void cmsis_dap_state_move(void)
1573 uint8_t tms_scan
= tap_get_tms_path(tap_get_state(), tap_get_end_state());
1574 uint8_t tms_scan_bits
= tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1576 LOG_DEBUG_IO("state move from %s to %s: %d clocks, %02X on tms",
1577 tap_state_name(tap_get_state()), tap_state_name(tap_get_end_state()),
1578 tms_scan_bits
, tms_scan
);
1579 cmsis_dap_add_tms_sequence(&tms_scan
, tms_scan_bits
);
1581 tap_set_state(tap_get_end_state());
1585 /* Execute a JTAG scan operation by queueing TMS and TDI/TDO sequences */
1586 static void cmsis_dap_execute_scan(struct jtag_command
*cmd
)
1588 LOG_DEBUG_IO("%s type:%d", cmd
->cmd
.scan
->ir_scan
? "IRSCAN" : "DRSCAN",
1589 jtag_scan_type(cmd
->cmd
.scan
));
1591 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
1592 while (cmd
->cmd
.scan
->num_fields
> 0
1593 && cmd
->cmd
.scan
->fields
[cmd
->cmd
.scan
->num_fields
- 1].num_bits
== 0) {
1594 cmd
->cmd
.scan
->num_fields
--;
1595 LOG_DEBUG("discarding trailing empty field");
1598 if (cmd
->cmd
.scan
->num_fields
== 0) {
1599 LOG_DEBUG("empty scan, doing nothing");
1603 if (cmd
->cmd
.scan
->ir_scan
) {
1604 if (tap_get_state() != TAP_IRSHIFT
) {
1605 cmsis_dap_end_state(TAP_IRSHIFT
);
1606 cmsis_dap_state_move();
1609 if (tap_get_state() != TAP_DRSHIFT
) {
1610 cmsis_dap_end_state(TAP_DRSHIFT
);
1611 cmsis_dap_state_move();
1615 cmsis_dap_end_state(cmd
->cmd
.scan
->end_state
);
1617 struct scan_field
*field
= cmd
->cmd
.scan
->fields
;
1618 unsigned scan_size
= 0;
1620 for (int i
= 0; i
< cmd
->cmd
.scan
->num_fields
; i
++, field
++) {
1621 scan_size
+= field
->num_bits
;
1622 LOG_DEBUG_IO("%s%s field %d/%d %d bits",
1623 field
->in_value
? "in" : "",
1624 field
->out_value
? "out" : "",
1626 cmd
->cmd
.scan
->num_fields
,
1629 if (i
== cmd
->cmd
.scan
->num_fields
- 1 && tap_get_state() != tap_get_end_state()) {
1630 LOG_DEBUG_IO("Last field and have to move out of SHIFT state");
1631 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
1632 * movement. This last field can't have length zero, it was checked above. */
1633 cmsis_dap_add_jtag_sequence(
1634 field
->num_bits
- 1, /* number of bits to clock */
1635 field
->out_value
, /* output sequence */
1636 0, /* output offset */
1637 false, /* TMS low */
1641 /* Clock the last bit out, with TMS high */
1642 uint8_t last_bit
= 0;
1643 if (field
->out_value
)
1644 bit_copy(&last_bit
, 0, field
->out_value
, field
->num_bits
- 1, 1);
1645 cmsis_dap_add_jtag_sequence(
1651 field
->num_bits
- 1);
1652 tap_set_state(tap_state_transition(tap_get_state(), 1));
1654 /* Now clock one more cycle, with TMS low, to get us into a PAUSE state */
1655 cmsis_dap_add_jtag_sequence(
1662 tap_set_state(tap_state_transition(tap_get_state(), 0));
1664 LOG_DEBUG_IO("Internal field, staying in SHIFT state afterwards");
1665 /* Clocking part of a sequence into DR or IR with TMS=0,
1666 leaving TMS=0 at the end so we can continue later */
1667 cmsis_dap_add_jtag_sequence(
1677 if (tap_get_state() != tap_get_end_state()) {
1678 cmsis_dap_end_state(tap_get_end_state());
1679 cmsis_dap_state_move();
1682 LOG_DEBUG_IO("%s scan, %i bits, end in %s",
1683 (cmd
->cmd
.scan
->ir_scan
) ? "IR" : "DR", scan_size
,
1684 tap_state_name(tap_get_end_state()));
1687 static void cmsis_dap_pathmove(int num_states
, tap_state_t
*path
)
1689 uint8_t tms0
= 0x00;
1690 uint8_t tms1
= 0xff;
1692 for (int i
= 0; i
< num_states
; i
++) {
1693 if (path
[i
] == tap_state_transition(tap_get_state(), false))
1694 cmsis_dap_add_tms_sequence(&tms0
, 1);
1695 else if (path
[i
] == tap_state_transition(tap_get_state(), true))
1696 cmsis_dap_add_tms_sequence(&tms1
, 1);
1698 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition.",
1699 tap_state_name(tap_get_state()), tap_state_name(path
[i
]));
1703 tap_set_state(path
[i
]);
1706 cmsis_dap_end_state(tap_get_state());
1709 static void cmsis_dap_execute_pathmove(struct jtag_command
*cmd
)
1711 LOG_DEBUG_IO("pathmove: %i states, end in %i",
1712 cmd
->cmd
.pathmove
->num_states
,
1713 cmd
->cmd
.pathmove
->path
[cmd
->cmd
.pathmove
->num_states
- 1]);
1715 cmsis_dap_pathmove(cmd
->cmd
.pathmove
->num_states
, cmd
->cmd
.pathmove
->path
);
1718 static void cmsis_dap_stableclocks(int num_cycles
)
1720 uint8_t tms
= tap_get_state() == TAP_RESET
;
1721 /* TODO: Perform optimizations? */
1722 /* Execute num_cycles. */
1723 for (int i
= 0; i
< num_cycles
; i
++)
1724 cmsis_dap_add_tms_sequence(&tms
, 1);
1727 static void cmsis_dap_runtest(int num_cycles
)
1729 tap_state_t saved_end_state
= tap_get_end_state();
1731 /* Only do a state_move when we're not already in IDLE. */
1732 if (tap_get_state() != TAP_IDLE
) {
1733 cmsis_dap_end_state(TAP_IDLE
);
1734 cmsis_dap_state_move();
1736 cmsis_dap_stableclocks(num_cycles
);
1738 /* Finish in end_state. */
1739 cmsis_dap_end_state(saved_end_state
);
1741 if (tap_get_state() != tap_get_end_state())
1742 cmsis_dap_state_move();
1745 static void cmsis_dap_execute_runtest(struct jtag_command
*cmd
)
1747 LOG_DEBUG_IO("runtest %i cycles, end in %i", cmd
->cmd
.runtest
->num_cycles
,
1748 cmd
->cmd
.runtest
->end_state
);
1750 cmsis_dap_end_state(cmd
->cmd
.runtest
->end_state
);
1751 cmsis_dap_runtest(cmd
->cmd
.runtest
->num_cycles
);
1754 static void cmsis_dap_execute_stableclocks(struct jtag_command
*cmd
)
1756 LOG_DEBUG_IO("stableclocks %i cycles", cmd
->cmd
.runtest
->num_cycles
);
1757 cmsis_dap_stableclocks(cmd
->cmd
.runtest
->num_cycles
);
1760 static void cmsis_dap_execute_tms(struct jtag_command
*cmd
)
1762 LOG_DEBUG_IO("TMS: %d bits", cmd
->cmd
.tms
->num_bits
);
1763 cmsis_dap_cmd_dap_swj_sequence(cmd
->cmd
.tms
->num_bits
, cmd
->cmd
.tms
->bits
);
1766 /* TODO: Is there need to call cmsis_dap_flush() for the JTAG_PATHMOVE,
1767 * JTAG_RUNTEST, JTAG_STABLECLOCKS? */
1768 static void cmsis_dap_execute_command(struct jtag_command
*cmd
)
1770 switch (cmd
->type
) {
1773 cmsis_dap_execute_sleep(cmd
);
1775 case JTAG_TLR_RESET
:
1777 cmsis_dap_execute_tlr_reset(cmd
);
1780 cmsis_dap_execute_scan(cmd
);
1783 cmsis_dap_execute_pathmove(cmd
);
1786 cmsis_dap_execute_runtest(cmd
);
1788 case JTAG_STABLECLOCKS
:
1789 cmsis_dap_execute_stableclocks(cmd
);
1792 cmsis_dap_execute_tms(cmd
);
1795 LOG_ERROR("BUG: unknown JTAG command type 0x%X encountered", cmd
->type
);
1800 static int cmsis_dap_execute_queue(void)
1802 struct jtag_command
*cmd
= jtag_command_queue
;
1805 cmsis_dap_execute_command(cmd
);
1814 static int cmsis_dap_speed(int speed
)
1817 LOG_ERROR("RTCK not supported. Set nonzero \"adapter speed\".");
1818 return ERROR_JTAG_NOT_IMPLEMENTED
;
1821 return cmsis_dap_cmd_dap_swj_clock(speed
);
1824 static int cmsis_dap_speed_div(int speed
, int *khz
)
1830 static int cmsis_dap_khz(int khz
, int *jtag_speed
)
1836 static bool calculate_swo_prescaler(unsigned int traceclkin_freq
,
1837 uint32_t trace_freq
, uint16_t *prescaler
)
1839 unsigned int presc
= (traceclkin_freq
+ trace_freq
/ 2) / trace_freq
;
1840 if (presc
== 0 || presc
> TPIU_ACPR_MAX_SWOSCALER
+ 1)
1843 /* Probe's UART speed must be within 3% of the TPIU's SWO baud rate. */
1844 unsigned int max_deviation
= (traceclkin_freq
* 3) / 100;
1845 if (presc
* trace_freq
< traceclkin_freq
- max_deviation
||
1846 presc
* trace_freq
> traceclkin_freq
+ max_deviation
)
1855 * @see adapter_driver::config_trace
1857 static int cmsis_dap_config_trace(
1859 enum tpiu_pin_protocol pin_protocol
,
1861 unsigned int *swo_freq
,
1862 unsigned int traceclkin_hz
,
1863 uint16_t *swo_prescaler
)
1867 if (!trace_enabled
) {
1868 if (cmsis_dap_handle
->trace_enabled
) {
1869 retval
= cmsis_dap_cmd_dap_swo_control(DAP_SWO_CONTROL_STOP
);
1870 if (retval
!= ERROR_OK
) {
1871 LOG_ERROR("Failed to disable the SWO-trace.");
1875 cmsis_dap_handle
->trace_enabled
= false;
1876 LOG_INFO("SWO-trace disabled.");
1880 if (!(cmsis_dap_handle
->caps
& INFO_CAPS_SWO_UART
) &&
1881 !(cmsis_dap_handle
->caps
& INFO_CAPS_SWO_MANCHESTER
)) {
1882 LOG_ERROR("SWO-trace is not supported by the device.");
1887 if (pin_protocol
== TPIU_PIN_PROTOCOL_ASYNC_UART
&&
1888 (cmsis_dap_handle
->caps
& INFO_CAPS_SWO_UART
)) {
1889 swo_mode
= DAP_SWO_MODE_UART
;
1890 } else if (pin_protocol
== TPIU_PIN_PROTOCOL_ASYNC_MANCHESTER
&&
1891 (cmsis_dap_handle
->caps
& INFO_CAPS_SWO_MANCHESTER
)) {
1892 swo_mode
= DAP_SWO_MODE_MANCHESTER
;
1894 LOG_ERROR("Selected pin protocol is not supported.");
1898 if (*swo_freq
== 0) {
1899 LOG_INFO("SWO-trace frequency autodetection not implemented.");
1903 retval
= cmsis_dap_cmd_dap_swo_control(DAP_SWO_CONTROL_STOP
);
1904 if (retval
!= ERROR_OK
)
1907 cmsis_dap_handle
->trace_enabled
= false;
1909 retval
= cmsis_dap_get_swo_buf_sz(&cmsis_dap_handle
->swo_buf_sz
);
1910 if (retval
!= ERROR_OK
)
1913 retval
= cmsis_dap_cmd_dap_swo_transport(DAP_SWO_TRANSPORT_DATA
);
1914 if (retval
!= ERROR_OK
)
1917 retval
= cmsis_dap_cmd_dap_swo_mode(swo_mode
);
1918 if (retval
!= ERROR_OK
)
1921 retval
= cmsis_dap_cmd_dap_swo_baudrate(*swo_freq
, swo_freq
);
1922 if (retval
!= ERROR_OK
)
1925 if (!calculate_swo_prescaler(traceclkin_hz
, *swo_freq
,
1927 LOG_ERROR("SWO frequency is not suitable. Please choose a "
1928 "different frequency or use auto-detection.");
1932 LOG_INFO("SWO frequency: %u Hz.", *swo_freq
);
1933 LOG_INFO("SWO prescaler: %u.", *swo_prescaler
);
1935 retval
= cmsis_dap_cmd_dap_swo_control(DAP_SWO_CONTROL_START
);
1936 if (retval
!= ERROR_OK
)
1939 cmsis_dap_handle
->trace_enabled
= true;
1945 * @see adapter_driver::poll_trace
1947 static int cmsis_dap_poll_trace(uint8_t *buf
, size_t *size
)
1949 uint8_t trace_status
;
1952 if (!cmsis_dap_handle
->trace_enabled
) {
1957 int retval
= cmsis_dap_cmd_dap_swo_status(&trace_status
, &trace_count
);
1958 if (retval
!= ERROR_OK
)
1960 if ((trace_status
& DAP_SWO_STATUS_CAPTURE_MASK
) != DAP_SWO_STATUS_CAPTURE_ACTIVE
)
1963 *size
= trace_count
< *size
? trace_count
: *size
;
1964 size_t read_so_far
= 0;
1967 uint32_t packet_size
= cmsis_dap_handle
->packet_size
- 4 /*data-reply*/;
1968 uint32_t remaining
= *size
- read_so_far
;
1969 if (remaining
< packet_size
)
1970 packet_size
= remaining
;
1971 retval
= cmsis_dap_cmd_dap_swo_data(
1976 if (retval
!= ERROR_OK
)
1978 if ((trace_status
& DAP_SWO_STATUS_CAPTURE_MASK
) != DAP_SWO_STATUS_CAPTURE_ACTIVE
)
1982 } while (read_so_far
< *size
);
1987 COMMAND_HANDLER(cmsis_dap_handle_info_command
)
1989 if (cmsis_dap_get_version_info() == ERROR_OK
)
1990 cmsis_dap_get_status();
1995 COMMAND_HANDLER(cmsis_dap_handle_cmd_command
)
1997 uint8_t *command
= cmsis_dap_handle
->command
;
1999 for (unsigned i
= 0; i
< CMD_ARGC
; i
++)
2000 COMMAND_PARSE_NUMBER(u8
, CMD_ARGV
[i
], command
[i
]);
2002 int retval
= cmsis_dap_xfer(cmsis_dap_handle
, CMD_ARGC
);
2004 if (retval
!= ERROR_OK
) {
2005 LOG_ERROR("CMSIS-DAP command failed.");
2006 return ERROR_JTAG_DEVICE_ERROR
;
2009 uint8_t *resp
= cmsis_dap_handle
->response
;
2010 LOG_INFO("Returned data %02" PRIx8
" %02" PRIx8
" %02" PRIx8
" %02" PRIx8
,
2011 resp
[1], resp
[2], resp
[3], resp
[4]);
2016 COMMAND_HANDLER(cmsis_dap_handle_vid_pid_command
)
2018 if (CMD_ARGC
> MAX_USB_IDS
* 2) {
2019 LOG_WARNING("ignoring extra IDs in cmsis_dap_vid_pid "
2020 "(maximum is %d pairs)", MAX_USB_IDS
);
2021 CMD_ARGC
= MAX_USB_IDS
* 2;
2023 if (CMD_ARGC
< 2 || (CMD_ARGC
& 1)) {
2024 LOG_WARNING("incomplete cmsis_dap_vid_pid configuration directive");
2026 return ERROR_COMMAND_SYNTAX_ERROR
;
2027 /* remove the incomplete trailing id */
2032 for (i
= 0; i
< CMD_ARGC
; i
+= 2) {
2033 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
], cmsis_dap_vid
[i
>> 1]);
2034 COMMAND_PARSE_NUMBER(u16
, CMD_ARGV
[i
+ 1], cmsis_dap_pid
[i
>> 1]);
2038 * Explicitly terminate, in case there are multiples instances of
2039 * cmsis_dap_vid_pid.
2041 cmsis_dap_vid
[i
>> 1] = cmsis_dap_pid
[i
>> 1] = 0;
2046 COMMAND_HANDLER(cmsis_dap_handle_backend_command
)
2048 if (CMD_ARGC
== 1) {
2049 if (strcmp(CMD_ARGV
[0], "auto") == 0) {
2050 cmsis_dap_backend
= -1; /* autoselect */
2052 for (unsigned int i
= 0; i
< ARRAY_SIZE(cmsis_dap_backends
); i
++) {
2053 if (strcasecmp(cmsis_dap_backends
[i
]->name
, CMD_ARGV
[0]) == 0) {
2054 cmsis_dap_backend
= i
;
2059 LOG_ERROR("invalid backend argument to cmsis_dap_backend <backend>");
2062 LOG_ERROR("expected exactly one argument to cmsis_dap_backend <backend>");
2068 static const struct command_registration cmsis_dap_subcommand_handlers
[] = {
2071 .handler
= &cmsis_dap_handle_info_command
,
2072 .mode
= COMMAND_EXEC
,
2074 .help
= "show cmsis-dap info",
2078 .handler
= &cmsis_dap_handle_cmd_command
,
2079 .mode
= COMMAND_EXEC
,
2081 .help
= "issue cmsis-dap command",
2083 COMMAND_REGISTRATION_DONE
2087 static const struct command_registration cmsis_dap_command_handlers
[] = {
2089 .name
= "cmsis-dap",
2090 .mode
= COMMAND_ANY
,
2091 .help
= "perform CMSIS-DAP management",
2093 .chain
= cmsis_dap_subcommand_handlers
,
2096 .name
= "cmsis_dap_vid_pid",
2097 .handler
= &cmsis_dap_handle_vid_pid_command
,
2098 .mode
= COMMAND_CONFIG
,
2099 .help
= "the vendor ID and product ID of the CMSIS-DAP device",
2100 .usage
= "(vid pid)*",
2103 .name
= "cmsis_dap_backend",
2104 .handler
= &cmsis_dap_handle_backend_command
,
2105 .mode
= COMMAND_CONFIG
,
2106 .help
= "set the communication backend to use (USB bulk or HID).",
2107 .usage
= "(auto | usb_bulk | hid)",
2109 #if BUILD_CMSIS_DAP_USB
2111 .name
= "cmsis_dap_usb",
2112 .chain
= cmsis_dap_usb_subcommand_handlers
,
2113 .mode
= COMMAND_ANY
,
2114 .help
= "USB bulk backend-specific commands",
2118 COMMAND_REGISTRATION_DONE
2121 static const struct swd_driver cmsis_dap_swd_driver
= {
2122 .init
= cmsis_dap_swd_init
,
2123 .switch_seq
= cmsis_dap_swd_switch_seq
,
2124 .read_reg
= cmsis_dap_swd_read_reg
,
2125 .write_reg
= cmsis_dap_swd_write_reg
,
2126 .run
= cmsis_dap_swd_run_queue
,
2129 static const char * const cmsis_dap_transport
[] = { "swd", "jtag", NULL
};
2131 static struct jtag_interface cmsis_dap_interface
= {
2132 .supported
= DEBUG_CAP_TMS_SEQ
,
2133 .execute_queue
= cmsis_dap_execute_queue
,
2136 struct adapter_driver cmsis_dap_adapter_driver
= {
2137 .name
= "cmsis-dap",
2138 .transports
= cmsis_dap_transport
,
2139 .commands
= cmsis_dap_command_handlers
,
2141 .init
= cmsis_dap_init
,
2142 .quit
= cmsis_dap_quit
,
2143 .reset
= cmsis_dap_reset
,
2144 .speed
= cmsis_dap_speed
,
2145 .khz
= cmsis_dap_khz
,
2146 .speed_div
= cmsis_dap_speed_div
,
2147 .config_trace
= cmsis_dap_config_trace
,
2148 .poll_trace
= cmsis_dap_poll_trace
,
2150 .jtag_ops
= &cmsis_dap_interface
,
2151 .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)