Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
jtag/drivers/cmsis_dap: speed up long transfers using DAP_TransferBlock
[openocd.git] / src / jtag / drivers / cmsis_dap.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2
3 /***************************************************************************
4 * Copyright (C) 2021 by Adrian Negreanu *
5 * groleo@gmail.com *
6 * *
7 * Copyright (C) 2018 by Mickaël Thomas *
8 * mickael9@gmail.com *
9 * *
10 * Copyright (C) 2016 by Maksym Hilliaka *
11 * oter@frozen-team.com *
12 * *
13 * Copyright (C) 2016 by Phillip Pearson *
14 * pp@myelin.co.nz *
15 * *
16 * Copyright (C) 2014 by Paul Fertser *
17 * fercerpav@gmail.com *
18 * *
19 * Copyright (C) 2013 by mike brown *
20 * mike@theshedworks.org.uk *
21 * *
22 * Copyright (C) 2013 by Spencer Oliver *
23 * spen@spen-soft.co.uk *
24 ***************************************************************************/
25
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29
30 #include <transport/transport.h>
31 #include "helper/replacements.h"
32 #include <jtag/adapter.h>
33 #include <jtag/swd.h>
34 #include <jtag/interface.h>
35 #include <jtag/commands.h>
36 #include <jtag/tcl.h>
37 #include <target/cortex_m.h>
38
39 #include "cmsis_dap.h"
40 #include "libusb_helper.h"
41
42 static const struct cmsis_dap_backend *const cmsis_dap_backends[] = {
43 #if BUILD_CMSIS_DAP_USB == 1
44 &cmsis_dap_usb_backend,
45 #endif
46
47 #if BUILD_CMSIS_DAP_HID == 1
48 &cmsis_dap_hid_backend,
49 #endif
50 };
51
52 /* USB Config */
53
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
60 *
61 * VID 0x0d28: mbed Software
62 * PID 0x0204: MBED CMSIS-DAP
63 */
64
65 #define MAX_USB_IDS 8
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;
70 static bool swd_mode;
71
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
80
81 /* CMD_INFO */
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 */
92
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
103
104 /* CMD_LED */
105 #define LED_ID_CONNECT 0x00
106 #define LED_ID_RUN 0x01
107
108 #define LED_OFF 0x00
109 #define LED_ON 0x01
110
111 /* CMD_CONNECT */
112 #define CONNECT_DEFAULT 0x00
113 #define CONNECT_SWD 0x01
114 #define CONNECT_JTAG 0x02
115
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
121
122 /*
123 * PINS
124 * Bit 0: SWCLK/TCK
125 * Bit 1: SWDIO/TMS
126 * Bit 2: TDI
127 * Bit 3: TDO
128 * Bit 5: nTRST
129 * Bit 7: nRESET
130 */
131
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)
138
139 /* CMSIS-DAP SWD Commands */
140 #define CMD_DAP_SWD_CONFIGURE 0x13
141 #define CMD_DAP_SWD_SEQUENCE 0x1D
142
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
147
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
155
156
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
162
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
167
168 /* DAP Status Code */
169 #define DAP_OK 0
170 #define DAP_ERROR 0xFF
171
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
180
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
185
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
190
191 /* SWO trace data capture */
192 #define DAP_SWO_CONTROL_STOP 0
193 #define DAP_SWO_CONTROL_START 1
194
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)
201
202 /* CMSIS-DAP Vendor Commands
203 * None as yet... */
204
205 static const char * const info_caps_str[INFO_CAPS__NUM_CAPS] = {
206 "SWD supported",
207 "JTAG supported",
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",
215 };
216
217 struct pending_scan_result {
218 /** Offset in bytes in the CMD_DAP_JTAG_SEQ response buffer. */
219 unsigned int first;
220 /** Number of bits to read. */
221 unsigned int length;
222 /** Location to store the result */
223 uint8_t *buffer;
224 /** Offset in the destination buffer */
225 unsigned int buffer_offset;
226 };
227
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;
232
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];
237
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 */
244
245 static int queued_retval;
246
247 static uint8_t output_pins = SWJ_PIN_SRST | SWJ_PIN_TRST;
248
249 static struct cmsis_dap *cmsis_dap_handle;
250
251
252 static int cmsis_dap_quit(void);
253
254 static int cmsis_dap_open(void)
255 {
256 const struct cmsis_dap_backend *backend = NULL;
257
258 struct cmsis_dap *dap = calloc(1, sizeof(struct cmsis_dap));
259 if (!dap) {
260 LOG_ERROR("unable to allocate memory");
261 return ERROR_FAIL;
262 }
263
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)
268 backend = NULL;
269 } else {
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)
274 break;
275 else
276 backend = NULL;
277 }
278 }
279
280 if (!backend) {
281 LOG_ERROR("unable to find a matching CMSIS-DAP device");
282 free(dap);
283 return ERROR_FAIL;
284 }
285
286 dap->backend = backend;
287
288 cmsis_dap_handle = dap;
289
290 return ERROR_OK;
291 }
292
293 static void cmsis_dap_close(struct cmsis_dap *dap)
294 {
295 if (dap->backend) {
296 dap->backend->close(dap);
297 dap->backend = NULL;
298 }
299
300 free(dap->packet_buffer);
301
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;
305 }
306
307 free(cmsis_dap_handle);
308 cmsis_dap_handle = NULL;
309 }
310
311 static void cmsis_dap_flush_read(struct cmsis_dap *dap)
312 {
313 unsigned int i;
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)
320 break;
321 }
322 if (i)
323 LOG_DEBUG("Flushed %u packets", i);
324 }
325
326 /* Send a message and receive the reply */
327 static int cmsis_dap_xfer(struct cmsis_dap *dap, int txlen)
328 {
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--;
334 }
335 dap->pending_fifo_put_idx = 0;
336 dap->pending_fifo_get_idx = 0;
337 }
338
339 uint8_t current_cmd = dap->command[0];
340 int retval = dap->backend->write(dap, txlen, LIBUSB_TIMEOUT_MS);
341 if (retval < 0)
342 return retval;
343
344 /* get reply */
345 retval = dap->backend->read(dap, LIBUSB_TIMEOUT_MS);
346 if (retval < 0)
347 return retval;
348
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;
353 }
354
355 if (resp[0] != current_cmd) {
356 LOG_ERROR("CMSIS-DAP command mismatch. Sent 0x%" PRIx8
357 " received 0x%" PRIx8, current_cmd, resp[0]);
358
359 cmsis_dap_flush_read(dap);
360 return ERROR_FAIL;
361 }
362
363 return ERROR_OK;
364 }
365
366 static int cmsis_dap_cmd_dap_swj_pins(uint8_t pins, uint8_t mask, uint32_t delay, uint8_t *input)
367 {
368 uint8_t *command = cmsis_dap_handle->command;
369
370 command[0] = CMD_DAP_SWJ_PINS;
371 command[1] = pins;
372 command[2] = mask;
373 h_u32_to_le(&command[3], delay);
374
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;
379 }
380
381 if (input)
382 *input = cmsis_dap_handle->response[1];
383
384 return ERROR_OK;
385 }
386
387 static int cmsis_dap_cmd_dap_swj_clock(uint32_t swj_clock)
388 {
389 uint8_t *command = cmsis_dap_handle->command;
390
391 /* set clock in Hz */
392 swj_clock *= 1000;
393
394 command[0] = CMD_DAP_SWJ_CLOCK;
395 h_u32_to_le(&command[1], swj_clock);
396
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;
401 }
402
403 return ERROR_OK;
404 }
405
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)
408 {
409 uint8_t *command = cmsis_dap_handle->command;
410
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]);
415
416 printf("\n");
417 #endif
418
419 command[0] = CMD_DAP_SWJ_SEQ;
420 command[1] = s_len;
421 bit_copy(&command[2], 0, sequence, 0, s_len);
422
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)
425 return ERROR_FAIL;
426
427 return ERROR_OK;
428 }
429
430 static int cmsis_dap_cmd_dap_info(uint8_t info, uint8_t **data)
431 {
432 uint8_t *command = cmsis_dap_handle->command;
433
434 command[0] = CMD_DAP_INFO;
435 command[1] = info;
436
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;
441 }
442
443 *data = &cmsis_dap_handle->response[1];
444
445 return ERROR_OK;
446 }
447
448 static int cmsis_dap_cmd_dap_led(uint8_t led, uint8_t state)
449 {
450 uint8_t *command = cmsis_dap_handle->command;
451
452 command[0] = CMD_DAP_LED;
453 command[1] = led;
454 command[2] = state;
455
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;
460 }
461
462 return ERROR_OK;
463 }
464
465 static int cmsis_dap_cmd_dap_connect(uint8_t mode)
466 {
467 uint8_t *command = cmsis_dap_handle->command;
468
469 command[0] = CMD_DAP_CONNECT;
470 command[1] = mode;
471
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;
476 }
477
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;
481 }
482
483 return ERROR_OK;
484 }
485
486 static int cmsis_dap_cmd_dap_disconnect(void)
487 {
488 uint8_t *command = cmsis_dap_handle->command;
489
490 command[0] = CMD_DAP_DISCONNECT;
491
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;
496 }
497
498 return ERROR_OK;
499 }
500
501 static int cmsis_dap_cmd_dap_tfer_configure(uint8_t idle, uint16_t retry_count, uint16_t match_retry)
502 {
503 uint8_t *command = cmsis_dap_handle->command;
504
505 command[0] = CMD_DAP_TFER_CONFIGURE;
506 command[1] = idle;
507 h_u16_to_le(&command[2], retry_count);
508 h_u16_to_le(&command[4], match_retry);
509
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;
514 }
515
516 return ERROR_OK;
517 }
518
519 static int cmsis_dap_cmd_dap_swd_configure(uint8_t cfg)
520 {
521 uint8_t *command = cmsis_dap_handle->command;
522
523 command[0] = CMD_DAP_SWD_CONFIGURE;
524 command[1] = cfg;
525
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;
530 }
531
532 return ERROR_OK;
533 }
534
535 #if 0
536 static int cmsis_dap_cmd_dap_delay(uint16_t delay_us)
537 {
538 uint8_t *command = cmsis_dap_handle->command;
539
540 command[0] = CMD_DAP_DELAY;
541 h_u16_to_le(&command[1], delay_us);
542
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;
547 }
548
549 return ERROR_OK;
550 }
551 #endif
552
553 static int cmsis_dap_metacmd_targetsel(uint32_t instance_id)
554 {
555 uint8_t *command = cmsis_dap_handle->command;
556 const uint32_t SEQ_RD = 0x80, SEQ_WR = 0x00;
557
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 */
564
565 LOG_DEBUG_IO("DP write reg TARGETSEL %" PRIx32, instance_id);
566
567 size_t idx = 0;
568 command[idx++] = CMD_DAP_SWD_SEQUENCE;
569 command[idx++] = 3; /* sequence count */
570
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;
574
575 /* sequence 1: read Trn ACK Trn, no expectation for target to ACK */
576 command[idx++] = SEQ_RD | 5;
577
578 /* sequence 2: WDATA plus parity */
579 command[idx++] = SEQ_WR | (32 + 1);
580 h_u32_to_le(command + idx, instance_id);
581 idx += 4;
582 command[idx++] = parity_u32(instance_id);
583
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;
588 }
589
590 return ERROR_OK;
591 }
592
593 /**
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).
597 */
598 static int cmsis_dap_cmd_dap_swo_transport(uint8_t transport)
599 {
600 uint8_t *command = cmsis_dap_handle->command;
601
602 command[0] = CMD_DAP_SWO_TRANSPORT;
603 command[1] = transport;
604
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;
609 }
610
611 return ERROR_OK;
612 }
613
614 /**
615 * Sets the SWO trace capture mode.
616 * @param[in] mode Trace capture mode. Can be UART or MANCHESTER.
617 */
618 static int cmsis_dap_cmd_dap_swo_mode(uint8_t mode)
619 {
620 uint8_t *command = cmsis_dap_handle->command;
621
622 command[0] = CMD_DAP_SWO_MODE;
623 command[1] = mode;
624
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;
629 }
630
631 return ERROR_OK;
632 }
633
634 /**
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.
642 */
643 static int cmsis_dap_cmd_dap_swo_baudrate(
644 uint32_t in_baudrate,
645 uint32_t *dev_baudrate)
646 {
647 uint8_t *command = cmsis_dap_handle->command;
648
649 command[0] = CMD_DAP_SWO_BAUDRATE;
650 h_u32_to_le(&command[1], in_baudrate);
651
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);
656 if (dev_baudrate)
657 *dev_baudrate = 0;
658 return ERROR_JTAG_DEVICE_ERROR;
659 }
660
661 if (dev_baudrate)
662 *dev_baudrate = rvbr;
663
664 return ERROR_OK;
665 }
666
667 /**
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
671 * not yet been read.
672 */
673 static int cmsis_dap_cmd_dap_swo_control(uint8_t control)
674 {
675 uint8_t *command = cmsis_dap_handle->command;
676
677 command[0] = CMD_DAP_SWO_CONTROL;
678 command[1] = control;
679
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;
684 }
685
686 return ERROR_OK;
687 }
688
689 /**
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).
696 */
697 static int cmsis_dap_cmd_dap_swo_status(
698 uint8_t *trace_status,
699 size_t *trace_count)
700 {
701 uint8_t *command = cmsis_dap_handle->command;
702
703 command[0] = CMD_DAP_SWO_STATUS;
704
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;
709 }
710
711 if (trace_status)
712 *trace_status = cmsis_dap_handle->response[1];
713 if (trace_count)
714 *trace_count = le_to_h_u32(&cmsis_dap_handle->response[2]);
715
716 return ERROR_OK;
717 }
718
719 /**
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.
725 */
726 static int cmsis_dap_cmd_dap_swo_data(
727 size_t max_trace_count,
728 uint8_t *trace_status,
729 size_t *trace_count,
730 uint8_t *data)
731 {
732 uint8_t *command = cmsis_dap_handle->command;
733
734 command[0] = CMD_DAP_SWO_DATA;
735 h_u16_to_le(&command[1], max_trace_count);
736
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;
741 }
742
743 *trace_status = cmsis_dap_handle->response[1];
744 *trace_count = le_to_h_u16(&cmsis_dap_handle->response[2]);
745
746 if (*trace_count > 0)
747 memcpy(data, &cmsis_dap_handle->response[4], *trace_count);
748
749 return ERROR_OK;
750 }
751
752
753 static void cmsis_dap_swd_write_from_queue(struct cmsis_dap *dap)
754 {
755 uint8_t *command = dap->command;
756 struct pending_request_block *block = &dap->pending_fifo[dap->pending_fifo_put_idx];
757
758 assert(dap->write_count + dap->read_count == block->transfer_count);
759
760 /* Reset packet size check counters for the next packet */
761 dap->write_count = 0;
762 dap->read_count = 0;
763
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");
767
768 if (queued_retval != ERROR_OK) {
769 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval);
770 goto skip;
771 }
772
773 if (block->transfer_count == 0)
774 goto skip;
775
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;
779
780 command[0] = block->command;
781 command[1] = 0x00; /* DAP Index */
782
783 unsigned int idx;
784 if (block_cmd) {
785 h_u16_to_le(&command[2], block->transfer_count);
786 idx = 4; /* The first transfer will store the common DAP register */
787 } else {
788 command[2] = block->transfer_count;
789 idx = 3;
790 }
791
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;
796
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);
801
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
811 * cmsis_dap_init().
812 */
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;
819 }
820
821 if (!block_cmd || i == 0)
822 command[idx++] = (cmd >> 1) & 0x0f;
823
824 if (!(cmd & SWD_CMD_RNW)) {
825 h_u32_to_le(&command[idx], data);
826 idx += 4;
827 }
828 }
829
830 int retval = dap->backend->write(dap, idx, LIBUSB_TIMEOUT_MS);
831 if (retval < 0) {
832 queued_retval = retval;
833 goto skip;
834 } else {
835 queued_retval = ERROR_OK;
836 }
837
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);
842
843 return;
844
845 skip:
846 block->transfer_count = 0;
847 }
848
849 static void cmsis_dap_swd_read_process(struct cmsis_dap *dap, int timeout_ms)
850 {
851 struct pending_request_block *block = &dap->pending_fifo[dap->pending_fifo_get_idx];
852
853 if (dap->pending_fifo_block_count == 0)
854 LOG_ERROR("no pending write");
855
856 /* get reply */
857 int retval = dap->backend->read(dap, timeout_ms);
858 if (retval == ERROR_TIMEOUT_REACHED && timeout_ms < LIBUSB_TIMEOUT_MS)
859 return;
860
861 if (retval <= 0) {
862 LOG_DEBUG("error reading data");
863 queued_retval = ERROR_FAIL;
864 goto skip;
865 }
866
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;
872 goto skip;
873 }
874
875 unsigned int transfer_count;
876 unsigned int idx;
877 if (block->command == CMD_DAP_TFER_BLOCK) {
878 transfer_count = le_to_h_u16(&resp[1]);
879 idx = 3;
880 } else {
881 transfer_count = resp[1];
882 idx = 2;
883 }
884 if (resp[idx] & 0x08) {
885 LOG_DEBUG("CMSIS-DAP Protocol Error @ %d (wrong parity)", transfer_count);
886 queued_retval = ERROR_FAIL;
887 goto skip;
888 }
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? */
895 goto skip;
896 }
897
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);
901
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);
904
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]);
910 uint32_t tmp = data;
911 idx += 4;
912
913 LOG_DEBUG_IO("Read result: %" PRIx32, data);
914
915 /* Imitate posted AP reads */
916 if ((transfer->cmd & SWD_CMD_APNDP) ||
917 ((transfer->cmd & SWD_CMD_A32) >> 1 == DP_RDBUFF)) {
918 tmp = last_read;
919 last_read = data;
920 }
921
922 if (transfer->buffer)
923 *(uint32_t *)(transfer->buffer) = tmp;
924 }
925 }
926
927 skip:
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--;
931 }
932
933 static int cmsis_dap_swd_run_queue(void)
934 {
935 if (cmsis_dap_handle->pending_fifo_block_count)
936 cmsis_dap_swd_read_process(cmsis_dap_handle, 0);
937
938 cmsis_dap_swd_write_from_queue(cmsis_dap_handle);
939
940 while (cmsis_dap_handle->pending_fifo_block_count)
941 cmsis_dap_swd_read_process(cmsis_dap_handle, LIBUSB_TIMEOUT_MS);
942
943 cmsis_dap_handle->pending_fifo_put_idx = 0;
944 cmsis_dap_handle->pending_fifo_get_idx = 0;
945
946 int retval = queued_retval;
947 queued_retval = ERROR_OK;
948
949 return retval;
950 }
951
952 static unsigned int cmsis_dap_tfer_cmd_size(unsigned int write_count,
953 unsigned int read_count, bool block_tfer)
954 {
955 unsigned int size;
956 if (block_tfer) {
957 size = 5; /* DAP_TransferBlock header */
958 size += write_count * 4; /* data */
959 } else {
960 size = 3; /* DAP_Transfer header */
961 size += write_count * (1 + 4); /* DAP register + data */
962 size += read_count; /* DAP register */
963 }
964 return size;
965 }
966
967 static unsigned int cmsis_dap_tfer_resp_size(unsigned int write_count,
968 unsigned int read_count, bool block_tfer)
969 {
970 unsigned int size;
971 if (block_tfer)
972 size = 4; /* DAP_TransferBlock response header */
973 else
974 size = 3; /* DAP_Transfer response header */
975
976 size += read_count * 4; /* data */
977 return size;
978 }
979
980 static void cmsis_dap_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data)
981 {
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;
985
986 unsigned int write_count = cmsis_dap_handle->write_count;
987 unsigned int read_count = cmsis_dap_handle->read_count;
988 bool block_cmd;
989 if (write_count + read_count < CMD_DAP_TFER_BLOCK_MIN_OPS)
990 block_cmd = false;
991 else
992 block_cmd = !cmsis_dap_handle->swd_cmds_differ
993 && cmd == cmsis_dap_handle->common_swd_cmd;
994
995 if (cmd & SWD_CMD_RNW)
996 read_count++;
997 else
998 write_count++;
999
1000 unsigned int cmd_size = cmsis_dap_tfer_cmd_size(write_count, read_count,
1001 block_cmd);
1002 unsigned int resp_size = cmsis_dap_tfer_resp_size(write_count, read_count,
1003 block_cmd);
1004
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
1009 || targetsel_cmd) {
1010 if (cmsis_dap_handle->pending_fifo_block_count)
1011 cmsis_dap_swd_read_process(cmsis_dap_handle, 0);
1012
1013 /* Not enough room in the queue. Run the queue. */
1014 cmsis_dap_swd_write_from_queue(cmsis_dap_handle);
1015
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);
1018 }
1019
1020 assert(cmsis_dap_handle->pending_fifo[cmsis_dap_handle->pending_fifo_put_idx].transfer_count < pending_queue_len);
1021
1022 if (queued_retval != ERROR_OK)
1023 return;
1024
1025 if (targetsel_cmd) {
1026 cmsis_dap_metacmd_targetsel(data);
1027 return;
1028 }
1029
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;
1039 }
1040
1041 if (cmd & SWD_CMD_RNW) {
1042 /* Queue a read transaction */
1043 transfer->buffer = dst;
1044 cmsis_dap_handle->read_count++;
1045 } else {
1046 cmsis_dap_handle->write_count++;
1047 }
1048 block->transfer_count++;
1049 }
1050
1051 static void cmsis_dap_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
1052 {
1053 assert(!(cmd & SWD_CMD_RNW));
1054 cmsis_dap_swd_queue_cmd(cmd, NULL, value);
1055 }
1056
1057 static void cmsis_dap_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
1058 {
1059 assert(cmd & SWD_CMD_RNW);
1060 cmsis_dap_swd_queue_cmd(cmd, value, 0);
1061 }
1062
1063 static int cmsis_dap_get_serial_info(void)
1064 {
1065 uint8_t *data;
1066
1067 int retval = cmsis_dap_cmd_dap_info(INFO_ID_SERNUM, &data);
1068 if (retval != ERROR_OK)
1069 return retval;
1070
1071 if (data[0]) /* strlen */
1072 LOG_INFO("CMSIS-DAP: Serial# = %s", &data[1]);
1073
1074 return ERROR_OK;
1075 }
1076
1077 static int cmsis_dap_get_version_info(void)
1078 {
1079 uint8_t *data;
1080
1081 /* INFO_ID_FW_VER - string */
1082 int retval = cmsis_dap_cmd_dap_info(INFO_ID_FW_VER, &data);
1083 if (retval != ERROR_OK)
1084 return retval;
1085
1086 if (data[0]) /* strlen */
1087 LOG_INFO("CMSIS-DAP: FW Version = %s", &data[1]);
1088
1089 return ERROR_OK;
1090 }
1091
1092 static int cmsis_dap_get_caps_info(void)
1093 {
1094 uint8_t *data;
1095
1096 /* INFO_ID_CAPS - byte */
1097 int retval = cmsis_dap_cmd_dap_info(INFO_ID_CAPS, &data);
1098 if (retval != ERROR_OK)
1099 return retval;
1100
1101 if (data[0] == 1 || data[0] == 2) {
1102 uint16_t caps = data[1];
1103 if (data[0] == 2)
1104 caps |= (uint16_t)data[2] << 8;
1105
1106 cmsis_dap_handle->caps = caps;
1107
1108 for (unsigned int i = 0; i < INFO_CAPS__NUM_CAPS; ++i) {
1109 if (caps & BIT(i))
1110 LOG_INFO("CMSIS-DAP: %s", info_caps_str[i]);
1111 }
1112 }
1113
1114 return ERROR_OK;
1115 }
1116
1117 static int cmsis_dap_get_swo_buf_sz(uint32_t *swo_buf_sz)
1118 {
1119 uint8_t *data;
1120
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)
1124 return retval;
1125
1126 if (data[0] != 4)
1127 return ERROR_FAIL;
1128
1129 *swo_buf_sz = le_to_h_u32(&data[1]);
1130
1131 LOG_INFO("CMSIS-DAP: SWO Trace Buffer Size = %u bytes", *swo_buf_sz);
1132
1133 return ERROR_OK;
1134 }
1135
1136 static int cmsis_dap_get_status(void)
1137 {
1138 uint8_t d;
1139
1140 int retval = cmsis_dap_cmd_dap_swj_pins(0, 0, 0, &d);
1141
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);
1150 }
1151
1152 return retval;
1153 }
1154
1155 static int cmsis_dap_swd_switch_seq(enum swd_special_seq seq)
1156 {
1157 const uint8_t *s;
1158 unsigned int s_len;
1159 int retval;
1160
1161 if ((output_pins & (SWJ_PIN_SRST | SWJ_PIN_TRST)) == (SWJ_PIN_SRST | SWJ_PIN_TRST)) {
1162 /* Following workaround deasserts reset on most adapters.
1163 * Do not reconnect if a reset line is active!
1164 * Reconnecting would break connecting under reset. */
1165
1166 /* First disconnect before connecting, Atmel EDBG needs it for SAMD/R/L/C */
1167 cmsis_dap_cmd_dap_disconnect();
1168
1169 /* When we are reconnecting, DAP_Connect needs to be rerun, at
1170 * least on Keil ULINK-ME */
1171 retval = cmsis_dap_cmd_dap_connect(CONNECT_SWD);
1172 if (retval != ERROR_OK)
1173 return retval;
1174 }
1175
1176 switch (seq) {
1177 case LINE_RESET:
1178 LOG_DEBUG_IO("SWD line reset");
1179 s = swd_seq_line_reset;
1180 s_len = swd_seq_line_reset_len;
1181 break;
1182 case JTAG_TO_SWD:
1183 LOG_DEBUG("JTAG-to-SWD");
1184 s = swd_seq_jtag_to_swd;
1185 s_len = swd_seq_jtag_to_swd_len;
1186 break;
1187 case JTAG_TO_DORMANT:
1188 LOG_DEBUG("JTAG-to-DORMANT");
1189 s = swd_seq_jtag_to_dormant;
1190 s_len = swd_seq_jtag_to_dormant_len;
1191 break;
1192 case SWD_TO_JTAG:
1193 LOG_DEBUG("SWD-to-JTAG");
1194 s = swd_seq_swd_to_jtag;
1195 s_len = swd_seq_swd_to_jtag_len;
1196 break;
1197 case SWD_TO_DORMANT:
1198 LOG_DEBUG("SWD-to-DORMANT");
1199 s = swd_seq_swd_to_dormant;
1200 s_len = swd_seq_swd_to_dormant_len;
1201 break;
1202 case DORMANT_TO_SWD:
1203 LOG_DEBUG("DORMANT-to-SWD");
1204 s = swd_seq_dormant_to_swd;
1205 s_len = swd_seq_dormant_to_swd_len;
1206 break;
1207 case DORMANT_TO_JTAG:
1208 LOG_DEBUG("DORMANT-to-JTAG");
1209 s = swd_seq_dormant_to_jtag;
1210 s_len = swd_seq_dormant_to_jtag_len;
1211 break;
1212 default:
1213 LOG_ERROR("Sequence %d not supported", seq);
1214 return ERROR_FAIL;
1215 }
1216
1217 retval = cmsis_dap_cmd_dap_swj_sequence(s_len, s);
1218 if (retval != ERROR_OK)
1219 return retval;
1220
1221 /* Atmel EDBG needs renew clock setting after SWJ_Sequence
1222 * otherwise default frequency is used */
1223 return cmsis_dap_cmd_dap_swj_clock(adapter_get_speed_khz());
1224 }
1225
1226 static int cmsis_dap_swd_open(void)
1227 {
1228 if (!(cmsis_dap_handle->caps & INFO_CAPS_SWD)) {
1229 LOG_ERROR("CMSIS-DAP: SWD not supported");
1230 return ERROR_JTAG_DEVICE_ERROR;
1231 }
1232
1233 int retval = cmsis_dap_cmd_dap_connect(CONNECT_SWD);
1234 if (retval != ERROR_OK)
1235 return retval;
1236
1237 /* Add more setup here.??... */
1238
1239 LOG_INFO("CMSIS-DAP: Interface Initialised (SWD)");
1240 return ERROR_OK;
1241 }
1242
1243 static int cmsis_dap_init(void)
1244 {
1245 uint8_t *data;
1246
1247 int retval = cmsis_dap_open();
1248 if (retval != ERROR_OK)
1249 return retval;
1250
1251 cmsis_dap_flush_read(cmsis_dap_handle);
1252
1253 retval = cmsis_dap_get_caps_info();
1254 if (retval != ERROR_OK)
1255 return retval;
1256
1257 retval = cmsis_dap_get_version_info();
1258 if (retval != ERROR_OK)
1259 return retval;
1260
1261 retval = cmsis_dap_get_serial_info();
1262 if (retval != ERROR_OK)
1263 return retval;
1264
1265 if (swd_mode) {
1266 retval = cmsis_dap_swd_open();
1267 if (retval != ERROR_OK)
1268 return retval;
1269 } else {
1270 /* Connect in JTAG mode */
1271 if (!(cmsis_dap_handle->caps & INFO_CAPS_JTAG)) {
1272 LOG_ERROR("CMSIS-DAP: JTAG not supported");
1273 return ERROR_JTAG_DEVICE_ERROR;
1274 }
1275
1276 retval = cmsis_dap_cmd_dap_connect(CONNECT_JTAG);
1277 if (retval != ERROR_OK)
1278 return retval;
1279
1280 LOG_INFO("CMSIS-DAP: Interface Initialised (JTAG)");
1281 }
1282
1283 /* Be conservative and suppress submitting multiple HID requests
1284 * until we get packet count info from the adaptor */
1285 cmsis_dap_handle->packet_count = 1;
1286
1287 /* INFO_ID_PKT_SZ - short */
1288 retval = cmsis_dap_cmd_dap_info(INFO_ID_PKT_SZ, &data);
1289 if (retval != ERROR_OK)
1290 goto init_err;
1291
1292 if (data[0] == 2) { /* short */
1293 uint16_t pkt_sz = data[1] + (data[2] << 8);
1294 if (pkt_sz != cmsis_dap_handle->packet_size) {
1295 free(cmsis_dap_handle->packet_buffer);
1296 retval = cmsis_dap_handle->backend->packet_buffer_alloc(cmsis_dap_handle, pkt_sz);
1297 if (retval != ERROR_OK)
1298 goto init_err;
1299
1300 LOG_DEBUG("CMSIS-DAP: Packet Size = %" PRIu16, pkt_sz);
1301 }
1302 }
1303
1304 /* Maximal number of transfers which fit to one packet:
1305 * Limited by response size: 3 bytes of response header + 4 per read
1306 * Plus writes to full command size: 3 bytes cmd header + 1 per read + 5 per write */
1307 tfer_max_command_size = cmsis_dap_handle->packet_usable_size;
1308 tfer_max_response_size = cmsis_dap_handle->packet_usable_size;
1309 unsigned int max_reads = tfer_max_response_size / 4;
1310 pending_queue_len = max_reads + (tfer_max_command_size - max_reads) / 5;
1311 cmsis_dap_handle->write_count = 0;
1312 cmsis_dap_handle->read_count = 0;
1313
1314 /* INFO_ID_PKT_CNT - byte */
1315 retval = cmsis_dap_cmd_dap_info(INFO_ID_PKT_CNT, &data);
1316 if (retval != ERROR_OK)
1317 goto init_err;
1318
1319 if (data[0] == 1) { /* byte */
1320 unsigned int pkt_cnt = data[1];
1321 if (pkt_cnt > 1)
1322 cmsis_dap_handle->packet_count = MIN(MAX_PENDING_REQUESTS, pkt_cnt);
1323
1324 LOG_DEBUG("CMSIS-DAP: Packet Count = %u", pkt_cnt);
1325 }
1326
1327 LOG_DEBUG("Allocating FIFO for %u pending packets", cmsis_dap_handle->packet_count);
1328 for (unsigned int i = 0; i < cmsis_dap_handle->packet_count; i++) {
1329 cmsis_dap_handle->pending_fifo[i].transfers = malloc(pending_queue_len
1330 * sizeof(struct pending_transfer_result));
1331 if (!cmsis_dap_handle->pending_fifo[i].transfers) {
1332 LOG_ERROR("Unable to allocate memory for CMSIS-DAP queue");
1333 retval = ERROR_FAIL;
1334 goto init_err;
1335 }
1336 }
1337
1338 /* Intentionally not checked for error, just logs an info message
1339 * not vital for further debugging */
1340 (void)cmsis_dap_get_status();
1341
1342 /* Now try to connect to the target
1343 * TODO: This is all SWD only @ present */
1344 retval = cmsis_dap_cmd_dap_swj_clock(adapter_get_speed_khz());
1345 if (retval != ERROR_OK)
1346 goto init_err;
1347
1348 /* Ask CMSIS-DAP to automatically retry on receiving WAIT for
1349 * up to 64 times. This must be changed to 0 if sticky
1350 * overrun detection is enabled. */
1351 retval = cmsis_dap_cmd_dap_tfer_configure(0, 64, 0);
1352 if (retval != ERROR_OK)
1353 goto init_err;
1354
1355 if (swd_mode) {
1356 /* Data Phase (bit 2) must be set to 1 if sticky overrun
1357 * detection is enabled */
1358 retval = cmsis_dap_cmd_dap_swd_configure(0); /* 1 TRN, no Data Phase */
1359 if (retval != ERROR_OK)
1360 goto init_err;
1361 }
1362 /* Both LEDs on */
1363 /* Intentionally not checked for error, debugging will work
1364 * without LEDs */
1365 (void)cmsis_dap_cmd_dap_led(LED_ID_CONNECT, LED_ON);
1366 (void)cmsis_dap_cmd_dap_led(LED_ID_RUN, LED_ON);
1367
1368 /* support connecting with srst asserted */
1369 enum reset_types jtag_reset_config = jtag_get_reset_config();
1370
1371 if (jtag_reset_config & RESET_CNCT_UNDER_SRST) {
1372 if (jtag_reset_config & RESET_SRST_NO_GATING) {
1373 retval = cmsis_dap_cmd_dap_swj_pins(0, SWJ_PIN_SRST, 0, NULL);
1374 if (retval != ERROR_OK)
1375 goto init_err;
1376 LOG_INFO("Connecting under reset");
1377 }
1378 }
1379 LOG_INFO("CMSIS-DAP: Interface ready");
1380 return ERROR_OK;
1381
1382 init_err:
1383 cmsis_dap_quit();
1384 return retval;
1385 }
1386
1387 static int cmsis_dap_swd_init(void)
1388 {
1389 swd_mode = true;
1390 return ERROR_OK;
1391 }
1392
1393 static int cmsis_dap_quit(void)
1394 {
1395 cmsis_dap_cmd_dap_disconnect();
1396
1397 /* Both LEDs off */
1398 cmsis_dap_cmd_dap_led(LED_ID_RUN, LED_OFF);
1399 cmsis_dap_cmd_dap_led(LED_ID_CONNECT, LED_OFF);
1400
1401 cmsis_dap_close(cmsis_dap_handle);
1402
1403 return ERROR_OK;
1404 }
1405
1406 static int cmsis_dap_reset(int trst, int srst)
1407 {
1408 /* Set both TRST and SRST even if they're not enabled as
1409 * there's no way to tristate them */
1410
1411 output_pins = 0;
1412 if (!srst)
1413 output_pins |= SWJ_PIN_SRST;
1414 if (!trst)
1415 output_pins |= SWJ_PIN_TRST;
1416
1417 int retval = cmsis_dap_cmd_dap_swj_pins(output_pins,
1418 SWJ_PIN_TRST | SWJ_PIN_SRST, 0, NULL);
1419 if (retval != ERROR_OK)
1420 LOG_ERROR("CMSIS-DAP: Interface reset failed");
1421 return retval;
1422 }
1423
1424 static void cmsis_dap_execute_sleep(struct jtag_command *cmd)
1425 {
1426 #if 0
1427 int retval = cmsis_dap_cmd_dap_delay(cmd->cmd.sleep->us);
1428 if (retval != ERROR_OK)
1429 #endif
1430 jtag_sleep(cmd->cmd.sleep->us);
1431 }
1432
1433 /* Set TMS high for five TCK clocks, to move the TAP to the Test-Logic-Reset state */
1434 static int cmsis_dap_execute_tlr_reset(struct jtag_command *cmd)
1435 {
1436 LOG_INFO("cmsis-dap JTAG TLR_RESET");
1437 uint8_t seq = 0xff;
1438
1439 int retval = cmsis_dap_cmd_dap_swj_sequence(8, &seq);
1440 if (retval == ERROR_OK)
1441 tap_set_state(TAP_RESET);
1442 return retval;
1443 }
1444
1445 /* Set new end state */
1446 static void cmsis_dap_end_state(tap_state_t state)
1447 {
1448 if (tap_is_state_stable(state))
1449 tap_set_end_state(state);
1450 else {
1451 LOG_ERROR("BUG: %i is not a valid end state", state);
1452 exit(-1);
1453 }
1454 }
1455
1456 #ifdef SPRINT_BINARY
1457 static void sprint_binary(char *s, const uint8_t *buf, unsigned int offset, unsigned int len)
1458 {
1459 if (!len)
1460 return;
1461
1462 /*
1463 buf = { 0x18 } len=5 should result in: 11000
1464 buf = { 0xff 0x18 } len=13 should result in: 11111111 11000
1465 buf = { 0xc0 0x18 } offset=3 len=10 should result in: 11000 11000
1466 i=3 there means i/8 = 0 so c = 0xFF, and
1467 */
1468 for (unsigned int i = offset; i < offset + len; ++i) {
1469 uint8_t c = buf[i / 8], mask = 1 << (i % 8);
1470 if ((i != offset) && !(i % 8))
1471 putchar(' ');
1472 *s++ = (c & mask) ? '1' : '0';
1473 }
1474 *s = 0;
1475 }
1476 #endif
1477
1478 #ifdef CMSIS_DAP_JTAG_DEBUG
1479 static void debug_parse_cmsis_buf(const uint8_t *cmd, int cmdlen)
1480 {
1481 /* cmd is a usb packet to go to the cmsis-dap interface */
1482 printf("cmsis-dap buffer (%d b): ", cmdlen);
1483 for (int i = 0; i < cmdlen; ++i)
1484 printf(" %02x", cmd[i]);
1485 printf("\n");
1486 switch (cmd[0]) {
1487 case CMD_DAP_JTAG_SEQ: {
1488 printf("cmsis-dap jtag sequence command %02x (n=%d)\n", cmd[0], cmd[1]);
1489 /*
1490 * #1 = number of sequences
1491 * #2 = sequence info 1
1492 * #3...4+n_bytes-1 = sequence 1
1493 * #4+n_bytes = sequence info 2
1494 * #5+n_bytes = sequence 2 (single bit)
1495 */
1496 int pos = 2;
1497 for (int seq = 0; seq < cmd[1]; ++seq) {
1498 uint8_t info = cmd[pos++];
1499 int len = info & DAP_JTAG_SEQ_TCK;
1500 if (len == 0)
1501 len = 64;
1502 printf(" sequence %d starting %d: info %02x (len=%d tms=%d read_tdo=%d): ",
1503 seq, pos, info, len, info & DAP_JTAG_SEQ_TMS, info & DAP_JTAG_SEQ_TDO);
1504 for (int i = 0; i < DIV_ROUND_UP(len, 8); ++i)
1505 printf(" %02x", cmd[pos+i]);
1506 pos += DIV_ROUND_UP(len, 8);
1507 printf("\n");
1508 }
1509 if (pos != cmdlen) {
1510 printf("BUFFER LENGTH MISMATCH looks like %d but %d specified", pos, cmdlen);
1511 exit(-1);
1512 }
1513
1514 break;
1515 }
1516 default:
1517 LOG_DEBUG("unknown cmsis-dap command %02x", cmd[1]);
1518 break;
1519 }
1520 }
1521 #endif
1522
1523 static void cmsis_dap_flush(void)
1524 {
1525 if (!queued_seq_count)
1526 return;
1527
1528 LOG_DEBUG_IO("Flushing %d queued sequences (%d bytes) with %d pending scan results to capture",
1529 queued_seq_count, queued_seq_buf_end, pending_scan_result_count);
1530
1531 /* prepare CMSIS-DAP packet */
1532 uint8_t *command = cmsis_dap_handle->command;
1533 command[0] = CMD_DAP_JTAG_SEQ;
1534 command[1] = queued_seq_count;
1535 memcpy(&command[2], queued_seq_buf, queued_seq_buf_end);
1536
1537 #ifdef CMSIS_DAP_JTAG_DEBUG
1538 debug_parse_cmsis_buf(command, queued_seq_buf_end + 2);
1539 #endif
1540
1541 /* send command to USB device */
1542 int retval = cmsis_dap_xfer(cmsis_dap_handle, queued_seq_buf_end + 2);
1543
1544 uint8_t *resp = cmsis_dap_handle->response;
1545 if (retval != ERROR_OK || resp[1] != DAP_OK) {
1546 LOG_ERROR("CMSIS-DAP command CMD_DAP_JTAG_SEQ failed.");
1547 exit(-1);
1548 }
1549
1550 #ifdef CMSIS_DAP_JTAG_DEBUG
1551 LOG_DEBUG_IO("USB response buf:");
1552 for (int c = 0; c < queued_seq_buf_end + 3; ++c)
1553 printf("%02X ", resp[c]);
1554 printf("\n");
1555 #endif
1556
1557 /* copy scan results into client buffers */
1558 for (int i = 0; i < pending_scan_result_count; ++i) {
1559 struct pending_scan_result *scan = &pending_scan_results[i];
1560 LOG_DEBUG_IO("Copying pending_scan_result %d/%d: %d bits from byte %d -> buffer + %d bits",
1561 i, pending_scan_result_count, scan->length, scan->first + 2, scan->buffer_offset);
1562 #ifdef CMSIS_DAP_JTAG_DEBUG
1563 for (uint32_t b = 0; b < DIV_ROUND_UP(scan->length, 8); ++b)
1564 printf("%02X ", resp[2+scan->first+b]);
1565 printf("\n");
1566 #endif
1567 bit_copy(scan->buffer, scan->buffer_offset, &resp[2 + scan->first], 0, scan->length);
1568 }
1569
1570 /* reset */
1571 queued_seq_count = 0;
1572 queued_seq_buf_end = 0;
1573 queued_seq_tdo_ptr = 0;
1574 pending_scan_result_count = 0;
1575 }
1576
1577 /* queue a sequence of bits to clock out TDI / in TDO, executing if the buffer is full.
1578 *
1579 * sequence=NULL means clock out zeros on TDI
1580 * tdo_buffer=NULL means don't capture TDO
1581 */
1582 static void cmsis_dap_add_jtag_sequence(unsigned int s_len, const uint8_t *sequence,
1583 unsigned int s_offset, bool tms,
1584 uint8_t *tdo_buffer, unsigned int tdo_buffer_offset)
1585 {
1586 LOG_DEBUG_IO("[at %d] %u bits, tms %s, seq offset %u, tdo buf %p, tdo offset %u",
1587 queued_seq_buf_end,
1588 s_len, tms ? "HIGH" : "LOW", s_offset, tdo_buffer, tdo_buffer_offset);
1589
1590 if (s_len == 0)
1591 return;
1592
1593 if (s_len > 64) {
1594 LOG_DEBUG_IO("START JTAG SEQ SPLIT");
1595 for (unsigned int offset = 0; offset < s_len; offset += 64) {
1596 unsigned int len = s_len - offset;
1597 if (len > 64)
1598 len = 64;
1599 LOG_DEBUG_IO("Splitting long jtag sequence: %u-bit chunk starting at offset %u", len, offset);
1600 cmsis_dap_add_jtag_sequence(
1601 len,
1602 sequence,
1603 s_offset + offset,
1604 tms,
1605 tdo_buffer,
1606 !tdo_buffer ? 0 : (tdo_buffer_offset + offset)
1607 );
1608 }
1609 LOG_DEBUG_IO("END JTAG SEQ SPLIT");
1610 return;
1611 }
1612
1613 unsigned int cmd_len = 1 + DIV_ROUND_UP(s_len, 8);
1614 if (queued_seq_count >= 255 || queued_seq_buf_end + cmd_len > QUEUED_SEQ_BUF_LEN)
1615 /* empty out the buffer */
1616 cmsis_dap_flush();
1617
1618 ++queued_seq_count;
1619
1620 /* control byte */
1621 queued_seq_buf[queued_seq_buf_end] =
1622 (tms ? DAP_JTAG_SEQ_TMS : 0) |
1623 (tdo_buffer ? DAP_JTAG_SEQ_TDO : 0) |
1624 (s_len == 64 ? 0 : s_len);
1625
1626 if (sequence)
1627 bit_copy(&queued_seq_buf[queued_seq_buf_end + 1], 0, sequence, s_offset, s_len);
1628 else
1629 memset(&queued_seq_buf[queued_seq_buf_end + 1], 0, DIV_ROUND_UP(s_len, 8));
1630
1631 queued_seq_buf_end += cmd_len;
1632
1633 if (tdo_buffer) {
1634 struct pending_scan_result *scan = &pending_scan_results[pending_scan_result_count++];
1635 scan->first = queued_seq_tdo_ptr;
1636 queued_seq_tdo_ptr += DIV_ROUND_UP(s_len, 8);
1637 scan->length = s_len;
1638 scan->buffer = tdo_buffer;
1639 scan->buffer_offset = tdo_buffer_offset;
1640 }
1641 }
1642
1643 /* queue a sequence of bits to clock out TMS, executing if the buffer is full */
1644 static void cmsis_dap_add_tms_sequence(const uint8_t *sequence, int s_len)
1645 {
1646 LOG_DEBUG_IO("%d bits: %02X", s_len, *sequence);
1647 /* we use a series of CMD_DAP_JTAG_SEQ commands to toggle TMS,
1648 because even though it seems ridiculously inefficient, it
1649 allows us to combine TMS and scan sequences into the same
1650 USB packet. */
1651 /* TODO: combine runs of the same tms value */
1652 for (int i = 0; i < s_len; ++i) {
1653 bool bit = (sequence[i / 8] & (1 << (i % 8))) != 0;
1654 cmsis_dap_add_jtag_sequence(1, NULL, 0, bit, NULL, 0);
1655 }
1656 }
1657
1658 /* Move to the end state by queuing a sequence to clock into TMS */
1659 static void cmsis_dap_state_move(void)
1660 {
1661 uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
1662 uint8_t tms_scan_bits = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1663
1664 LOG_DEBUG_IO("state move from %s to %s: %d clocks, %02X on tms",
1665 tap_state_name(tap_get_state()), tap_state_name(tap_get_end_state()),
1666 tms_scan_bits, tms_scan);
1667 cmsis_dap_add_tms_sequence(&tms_scan, tms_scan_bits);
1668
1669 tap_set_state(tap_get_end_state());
1670 }
1671
1672
1673 /* Execute a JTAG scan operation by queueing TMS and TDI/TDO sequences */
1674 static void cmsis_dap_execute_scan(struct jtag_command *cmd)
1675 {
1676 LOG_DEBUG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN",
1677 jtag_scan_type(cmd->cmd.scan));
1678
1679 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
1680 while (cmd->cmd.scan->num_fields > 0
1681 && cmd->cmd.scan->fields[cmd->cmd.scan->num_fields - 1].num_bits == 0) {
1682 cmd->cmd.scan->num_fields--;
1683 LOG_DEBUG("discarding trailing empty field");
1684 }
1685
1686 if (cmd->cmd.scan->num_fields == 0) {
1687 LOG_DEBUG("empty scan, doing nothing");
1688 return;
1689 }
1690
1691 if (cmd->cmd.scan->ir_scan) {
1692 if (tap_get_state() != TAP_IRSHIFT) {
1693 cmsis_dap_end_state(TAP_IRSHIFT);
1694 cmsis_dap_state_move();
1695 }
1696 } else {
1697 if (tap_get_state() != TAP_DRSHIFT) {
1698 cmsis_dap_end_state(TAP_DRSHIFT);
1699 cmsis_dap_state_move();
1700 }
1701 }
1702
1703 cmsis_dap_end_state(cmd->cmd.scan->end_state);
1704
1705 struct scan_field *field = cmd->cmd.scan->fields;
1706 unsigned scan_size = 0;
1707
1708 for (int i = 0; i < cmd->cmd.scan->num_fields; i++, field++) {
1709 scan_size += field->num_bits;
1710 LOG_DEBUG_IO("%s%s field %d/%d %d bits",
1711 field->in_value ? "in" : "",
1712 field->out_value ? "out" : "",
1713 i,
1714 cmd->cmd.scan->num_fields,
1715 field->num_bits);
1716
1717 if (i == cmd->cmd.scan->num_fields - 1 && tap_get_state() != tap_get_end_state()) {
1718 LOG_DEBUG_IO("Last field and have to move out of SHIFT state");
1719 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
1720 * movement. This last field can't have length zero, it was checked above. */
1721 cmsis_dap_add_jtag_sequence(
1722 field->num_bits - 1, /* number of bits to clock */
1723 field->out_value, /* output sequence */
1724 0, /* output offset */
1725 false, /* TMS low */
1726 field->in_value,
1727 0);
1728
1729 /* Clock the last bit out, with TMS high */
1730 uint8_t last_bit = 0;
1731 if (field->out_value)
1732 bit_copy(&last_bit, 0, field->out_value, field->num_bits - 1, 1);
1733 cmsis_dap_add_jtag_sequence(
1734 1,
1735 &last_bit,
1736 0,
1737 true,
1738 field->in_value,
1739 field->num_bits - 1);
1740 tap_set_state(tap_state_transition(tap_get_state(), 1));
1741
1742 /* Now clock one more cycle, with TMS low, to get us into a PAUSE state */
1743 cmsis_dap_add_jtag_sequence(
1744 1,
1745 &last_bit,
1746 0,
1747 false,
1748 NULL,
1749 0);
1750 tap_set_state(tap_state_transition(tap_get_state(), 0));
1751 } else {
1752 LOG_DEBUG_IO("Internal field, staying in SHIFT state afterwards");
1753 /* Clocking part of a sequence into DR or IR with TMS=0,
1754 leaving TMS=0 at the end so we can continue later */
1755 cmsis_dap_add_jtag_sequence(
1756 field->num_bits,
1757 field->out_value,
1758 0,
1759 false,
1760 field->in_value,
1761 0);
1762 }
1763 }
1764
1765 if (tap_get_state() != tap_get_end_state()) {
1766 cmsis_dap_end_state(tap_get_end_state());
1767 cmsis_dap_state_move();
1768 }
1769
1770 LOG_DEBUG_IO("%s scan, %i bits, end in %s",
1771 (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1772 tap_state_name(tap_get_end_state()));
1773 }
1774
1775 static void cmsis_dap_pathmove(int num_states, tap_state_t *path)
1776 {
1777 uint8_t tms0 = 0x00;
1778 uint8_t tms1 = 0xff;
1779
1780 for (int i = 0; i < num_states; i++) {
1781 if (path[i] == tap_state_transition(tap_get_state(), false))
1782 cmsis_dap_add_tms_sequence(&tms0, 1);
1783 else if (path[i] == tap_state_transition(tap_get_state(), true))
1784 cmsis_dap_add_tms_sequence(&tms1, 1);
1785 else {
1786 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition.",
1787 tap_state_name(tap_get_state()), tap_state_name(path[i]));
1788 exit(-1);
1789 }
1790
1791 tap_set_state(path[i]);
1792 }
1793
1794 cmsis_dap_end_state(tap_get_state());
1795 }
1796
1797 static void cmsis_dap_execute_pathmove(struct jtag_command *cmd)
1798 {
1799 LOG_DEBUG_IO("pathmove: %i states, end in %i",
1800 cmd->cmd.pathmove->num_states,
1801 cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
1802
1803 cmsis_dap_pathmove(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path);
1804 }
1805
1806 static void cmsis_dap_stableclocks(int num_cycles)
1807 {
1808 uint8_t tms = tap_get_state() == TAP_RESET;
1809 /* TODO: Perform optimizations? */
1810 /* Execute num_cycles. */
1811 for (int i = 0; i < num_cycles; i++)
1812 cmsis_dap_add_tms_sequence(&tms, 1);
1813 }
1814
1815 static void cmsis_dap_runtest(int num_cycles)
1816 {
1817 tap_state_t saved_end_state = tap_get_end_state();
1818
1819 /* Only do a state_move when we're not already in IDLE. */
1820 if (tap_get_state() != TAP_IDLE) {
1821 cmsis_dap_end_state(TAP_IDLE);
1822 cmsis_dap_state_move();
1823 }
1824 cmsis_dap_stableclocks(num_cycles);
1825
1826 /* Finish in end_state. */
1827 cmsis_dap_end_state(saved_end_state);
1828
1829 if (tap_get_state() != tap_get_end_state())
1830 cmsis_dap_state_move();
1831 }
1832
1833 static void cmsis_dap_execute_runtest(struct jtag_command *cmd)
1834 {
1835 LOG_DEBUG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles,
1836 cmd->cmd.runtest->end_state);
1837
1838 cmsis_dap_end_state(cmd->cmd.runtest->end_state);
1839 cmsis_dap_runtest(cmd->cmd.runtest->num_cycles);
1840 }
1841
1842 static void cmsis_dap_execute_stableclocks(struct jtag_command *cmd)
1843 {
1844 LOG_DEBUG_IO("stableclocks %i cycles", cmd->cmd.runtest->num_cycles);
1845 cmsis_dap_stableclocks(cmd->cmd.runtest->num_cycles);
1846 }
1847
1848 static void cmsis_dap_execute_tms(struct jtag_command *cmd)
1849 {
1850 LOG_DEBUG_IO("TMS: %d bits", cmd->cmd.tms->num_bits);
1851 cmsis_dap_cmd_dap_swj_sequence(cmd->cmd.tms->num_bits, cmd->cmd.tms->bits);
1852 }
1853
1854 /* TODO: Is there need to call cmsis_dap_flush() for the JTAG_PATHMOVE,
1855 * JTAG_RUNTEST, JTAG_STABLECLOCKS? */
1856 static void cmsis_dap_execute_command(struct jtag_command *cmd)
1857 {
1858 switch (cmd->type) {
1859 case JTAG_SLEEP:
1860 cmsis_dap_flush();
1861 cmsis_dap_execute_sleep(cmd);
1862 break;
1863 case JTAG_TLR_RESET:
1864 cmsis_dap_flush();
1865 cmsis_dap_execute_tlr_reset(cmd);
1866 break;
1867 case JTAG_SCAN:
1868 cmsis_dap_execute_scan(cmd);
1869 break;
1870 case JTAG_PATHMOVE:
1871 cmsis_dap_execute_pathmove(cmd);
1872 break;
1873 case JTAG_RUNTEST:
1874 cmsis_dap_execute_runtest(cmd);
1875 break;
1876 case JTAG_STABLECLOCKS:
1877 cmsis_dap_execute_stableclocks(cmd);
1878 break;
1879 case JTAG_TMS:
1880 cmsis_dap_execute_tms(cmd);
1881 break;
1882 default:
1883 LOG_ERROR("BUG: unknown JTAG command type 0x%X encountered", cmd->type);
1884 exit(-1);
1885 }
1886 }
1887
1888 static int cmsis_dap_execute_queue(void)
1889 {
1890 struct jtag_command *cmd = jtag_command_queue;
1891
1892 while (cmd) {
1893 cmsis_dap_execute_command(cmd);
1894 cmd = cmd->next;
1895 }
1896
1897 cmsis_dap_flush();
1898
1899 return ERROR_OK;
1900 }
1901
1902 static int cmsis_dap_speed(int speed)
1903 {
1904 if (speed == 0) {
1905 LOG_ERROR("RTCK not supported. Set nonzero \"adapter speed\".");
1906 return ERROR_JTAG_NOT_IMPLEMENTED;
1907 }
1908
1909 return cmsis_dap_cmd_dap_swj_clock(speed);
1910 }
1911
1912 static int cmsis_dap_speed_div(int speed, int *khz)
1913 {
1914 *khz = speed;
1915 return ERROR_OK;
1916 }
1917
1918 static int cmsis_dap_khz(int khz, int *jtag_speed)
1919 {
1920 *jtag_speed = khz;
1921 return ERROR_OK;
1922 }
1923
1924 static bool calculate_swo_prescaler(unsigned int traceclkin_freq,
1925 uint32_t trace_freq, uint16_t *prescaler)
1926 {
1927 unsigned int presc = (traceclkin_freq + trace_freq / 2) / trace_freq;
1928 if (presc == 0 || presc > TPIU_ACPR_MAX_SWOSCALER + 1)
1929 return false;
1930
1931 /* Probe's UART speed must be within 3% of the TPIU's SWO baud rate. */
1932 unsigned int max_deviation = (traceclkin_freq * 3) / 100;
1933 if (presc * trace_freq < traceclkin_freq - max_deviation ||
1934 presc * trace_freq > traceclkin_freq + max_deviation)
1935 return false;
1936
1937 *prescaler = presc;
1938
1939 return true;
1940 }
1941
1942 /**
1943 * @see adapter_driver::config_trace
1944 */
1945 static int cmsis_dap_config_trace(
1946 bool trace_enabled,
1947 enum tpiu_pin_protocol pin_protocol,
1948 uint32_t port_size,
1949 unsigned int *swo_freq,
1950 unsigned int traceclkin_hz,
1951 uint16_t *swo_prescaler)
1952 {
1953 int retval;
1954
1955 if (!trace_enabled) {
1956 if (cmsis_dap_handle->trace_enabled) {
1957 retval = cmsis_dap_cmd_dap_swo_control(DAP_SWO_CONTROL_STOP);
1958 if (retval != ERROR_OK) {
1959 LOG_ERROR("Failed to disable the SWO-trace.");
1960 return retval;
1961 }
1962 }
1963 cmsis_dap_handle->trace_enabled = false;
1964 LOG_INFO("SWO-trace disabled.");
1965 return ERROR_OK;
1966 }
1967
1968 if (!(cmsis_dap_handle->caps & INFO_CAPS_SWO_UART) &&
1969 !(cmsis_dap_handle->caps & INFO_CAPS_SWO_MANCHESTER)) {
1970 LOG_ERROR("SWO-trace is not supported by the device.");
1971 return ERROR_FAIL;
1972 }
1973
1974 uint8_t swo_mode;
1975 if (pin_protocol == TPIU_PIN_PROTOCOL_ASYNC_UART &&
1976 (cmsis_dap_handle->caps & INFO_CAPS_SWO_UART)) {
1977 swo_mode = DAP_SWO_MODE_UART;
1978 } else if (pin_protocol == TPIU_PIN_PROTOCOL_ASYNC_MANCHESTER &&
1979 (cmsis_dap_handle->caps & INFO_CAPS_SWO_MANCHESTER)) {
1980 swo_mode = DAP_SWO_MODE_MANCHESTER;
1981 } else {
1982 LOG_ERROR("Selected pin protocol is not supported.");
1983 return ERROR_FAIL;
1984 }
1985
1986 if (*swo_freq == 0) {
1987 LOG_INFO("SWO-trace frequency autodetection not implemented.");
1988 return ERROR_FAIL;
1989 }
1990
1991 retval = cmsis_dap_cmd_dap_swo_control(DAP_SWO_CONTROL_STOP);
1992 if (retval != ERROR_OK)
1993 return retval;
1994
1995 cmsis_dap_handle->trace_enabled = false;
1996
1997 retval = cmsis_dap_get_swo_buf_sz(&cmsis_dap_handle->swo_buf_sz);
1998 if (retval != ERROR_OK)
1999 return retval;
2000
2001 retval = cmsis_dap_cmd_dap_swo_transport(DAP_SWO_TRANSPORT_DATA);
2002 if (retval != ERROR_OK)
2003 return retval;
2004
2005 retval = cmsis_dap_cmd_dap_swo_mode(swo_mode);
2006 if (retval != ERROR_OK)
2007 return retval;
2008
2009 retval = cmsis_dap_cmd_dap_swo_baudrate(*swo_freq, swo_freq);
2010 if (retval != ERROR_OK)
2011 return retval;
2012
2013 if (!calculate_swo_prescaler(traceclkin_hz, *swo_freq,
2014 swo_prescaler)) {
2015 LOG_ERROR("SWO frequency is not suitable. Please choose a "
2016 "different frequency or use auto-detection.");
2017 return ERROR_FAIL;
2018 }
2019
2020 LOG_INFO("SWO frequency: %u Hz.", *swo_freq);
2021 LOG_INFO("SWO prescaler: %u.", *swo_prescaler);
2022
2023 retval = cmsis_dap_cmd_dap_swo_control(DAP_SWO_CONTROL_START);
2024 if (retval != ERROR_OK)
2025 return retval;
2026
2027 cmsis_dap_handle->trace_enabled = true;
2028
2029 return ERROR_OK;
2030 }
2031
2032 /**
2033 * @see adapter_driver::poll_trace
2034 */
2035 static int cmsis_dap_poll_trace(uint8_t *buf, size_t *size)
2036 {
2037 uint8_t trace_status;
2038 size_t trace_count;
2039
2040 if (!cmsis_dap_handle->trace_enabled) {
2041 *size = 0;
2042 return ERROR_OK;
2043 }
2044
2045 int retval = cmsis_dap_cmd_dap_swo_status(&trace_status, &trace_count);
2046 if (retval != ERROR_OK)
2047 return retval;
2048 if ((trace_status & DAP_SWO_STATUS_CAPTURE_MASK) != DAP_SWO_STATUS_CAPTURE_ACTIVE)
2049 return ERROR_FAIL;
2050
2051 *size = trace_count < *size ? trace_count : *size;
2052 size_t read_so_far = 0;
2053 do {
2054 size_t rb = 0;
2055 uint32_t packet_size = cmsis_dap_handle->packet_size - 4 /*data-reply*/;
2056 uint32_t remaining = *size - read_so_far;
2057 if (remaining < packet_size)
2058 packet_size = remaining;
2059 retval = cmsis_dap_cmd_dap_swo_data(
2060 packet_size,
2061 &trace_status,
2062 &rb,
2063 &buf[read_so_far]);
2064 if (retval != ERROR_OK)
2065 return retval;
2066 if ((trace_status & DAP_SWO_STATUS_CAPTURE_MASK) != DAP_SWO_STATUS_CAPTURE_ACTIVE)
2067 return ERROR_FAIL;
2068
2069 read_so_far += rb;
2070 } while (read_so_far < *size);
2071
2072 return ERROR_OK;
2073 }
2074
2075 COMMAND_HANDLER(cmsis_dap_handle_info_command)
2076 {
2077 if (cmsis_dap_get_version_info() == ERROR_OK)
2078 cmsis_dap_get_status();
2079
2080 return ERROR_OK;
2081 }
2082
2083 COMMAND_HANDLER(cmsis_dap_handle_cmd_command)
2084 {
2085 uint8_t *command = cmsis_dap_handle->command;
2086
2087 for (unsigned i = 0; i < CMD_ARGC; i++)
2088 COMMAND_PARSE_NUMBER(u8, CMD_ARGV[i], command[i]);
2089
2090 int retval = cmsis_dap_xfer(cmsis_dap_handle, CMD_ARGC);
2091
2092 if (retval != ERROR_OK) {
2093 LOG_ERROR("CMSIS-DAP command failed.");
2094 return ERROR_JTAG_DEVICE_ERROR;
2095 }
2096
2097 uint8_t *resp = cmsis_dap_handle->response;
2098 LOG_INFO("Returned data %02" PRIx8 " %02" PRIx8 " %02" PRIx8 " %02" PRIx8,
2099 resp[1], resp[2], resp[3], resp[4]);
2100
2101 return ERROR_OK;
2102 }
2103
2104 COMMAND_HANDLER(cmsis_dap_handle_vid_pid_command)
2105 {
2106 if (CMD_ARGC > MAX_USB_IDS * 2) {
2107 LOG_WARNING("ignoring extra IDs in cmsis_dap_vid_pid "
2108 "(maximum is %d pairs)", MAX_USB_IDS);
2109 CMD_ARGC = MAX_USB_IDS * 2;
2110 }
2111 if (CMD_ARGC < 2 || (CMD_ARGC & 1)) {
2112 LOG_WARNING("incomplete cmsis_dap_vid_pid configuration directive");
2113 if (CMD_ARGC < 2)
2114 return ERROR_COMMAND_SYNTAX_ERROR;
2115 /* remove the incomplete trailing id */
2116 CMD_ARGC -= 1;
2117 }
2118
2119 unsigned i;
2120 for (i = 0; i < CMD_ARGC; i += 2) {
2121 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i], cmsis_dap_vid[i >> 1]);
2122 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], cmsis_dap_pid[i >> 1]);
2123 }
2124
2125 /*
2126 * Explicitly terminate, in case there are multiples instances of
2127 * cmsis_dap_vid_pid.
2128 */
2129 cmsis_dap_vid[i >> 1] = cmsis_dap_pid[i >> 1] = 0;
2130
2131 return ERROR_OK;
2132 }
2133
2134 COMMAND_HANDLER(cmsis_dap_handle_backend_command)
2135 {
2136 if (CMD_ARGC == 1) {
2137 if (strcmp(CMD_ARGV[0], "auto") == 0) {
2138 cmsis_dap_backend = -1; /* autoselect */
2139 } else {
2140 for (unsigned int i = 0; i < ARRAY_SIZE(cmsis_dap_backends); i++) {
2141 if (strcasecmp(cmsis_dap_backends[i]->name, CMD_ARGV[0]) == 0) {
2142 cmsis_dap_backend = i;
2143 return ERROR_OK;
2144 }
2145 }
2146
2147 LOG_ERROR("invalid backend argument to cmsis_dap_backend <backend>");
2148 }
2149 } else {
2150 LOG_ERROR("expected exactly one argument to cmsis_dap_backend <backend>");
2151 }
2152
2153 return ERROR_OK;
2154 }
2155
2156 static const struct command_registration cmsis_dap_subcommand_handlers[] = {
2157 {
2158 .name = "info",
2159 .handler = &cmsis_dap_handle_info_command,
2160 .mode = COMMAND_EXEC,
2161 .usage = "",
2162 .help = "show cmsis-dap info",
2163 },
2164 {
2165 .name = "cmd",
2166 .handler = &cmsis_dap_handle_cmd_command,
2167 .mode = COMMAND_EXEC,
2168 .usage = "",
2169 .help = "issue cmsis-dap command",
2170 },
2171 COMMAND_REGISTRATION_DONE
2172 };
2173
2174
2175 static const struct command_registration cmsis_dap_command_handlers[] = {
2176 {
2177 .name = "cmsis-dap",
2178 .mode = COMMAND_ANY,
2179 .help = "perform CMSIS-DAP management",
2180 .usage = "<cmd>",
2181 .chain = cmsis_dap_subcommand_handlers,
2182 },
2183 {
2184 .name = "cmsis_dap_vid_pid",
2185 .handler = &cmsis_dap_handle_vid_pid_command,
2186 .mode = COMMAND_CONFIG,
2187 .help = "the vendor ID and product ID of the CMSIS-DAP device",
2188 .usage = "(vid pid)*",
2189 },
2190 {
2191 .name = "cmsis_dap_backend",
2192 .handler = &cmsis_dap_handle_backend_command,
2193 .mode = COMMAND_CONFIG,
2194 .help = "set the communication backend to use (USB bulk or HID).",
2195 .usage = "(auto | usb_bulk | hid)",
2196 },
2197 #if BUILD_CMSIS_DAP_USB
2198 {
2199 .name = "cmsis_dap_usb",
2200 .chain = cmsis_dap_usb_subcommand_handlers,
2201 .mode = COMMAND_ANY,
2202 .help = "USB bulk backend-specific commands",
2203 .usage = "<cmd>",
2204 },
2205 #endif
2206 COMMAND_REGISTRATION_DONE
2207 };
2208
2209 static const struct swd_driver cmsis_dap_swd_driver = {
2210 .init = cmsis_dap_swd_init,
2211 .switch_seq = cmsis_dap_swd_switch_seq,
2212 .read_reg = cmsis_dap_swd_read_reg,
2213 .write_reg = cmsis_dap_swd_write_reg,
2214 .run = cmsis_dap_swd_run_queue,
2215 };
2216
2217 static const char * const cmsis_dap_transport[] = { "swd", "jtag", NULL };
2218
2219 static struct jtag_interface cmsis_dap_interface = {
2220 .supported = DEBUG_CAP_TMS_SEQ,
2221 .execute_queue = cmsis_dap_execute_queue,
2222 };
2223
2224 struct adapter_driver cmsis_dap_adapter_driver = {
2225 .name = "cmsis-dap",
2226 .transports = cmsis_dap_transport,
2227 .commands = cmsis_dap_command_handlers,
2228
2229 .init = cmsis_dap_init,
2230 .quit = cmsis_dap_quit,
2231 .reset = cmsis_dap_reset,
2232 .speed = cmsis_dap_speed,
2233 .khz = cmsis_dap_khz,
2234 .speed_div = cmsis_dap_speed_div,
2235 .config_trace = cmsis_dap_config_trace,
2236 .poll_trace = cmsis_dap_poll_trace,
2237
2238 .jtag_ops = &cmsis_dap_interface,
2239 .swd_ops = &cmsis_dap_swd_driver,
2240 };
Open On-Chip Debugger

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)