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