Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
jtag/drivers/cmsis-dap: fix connect in cmsis_dap_swd_switch_seq()
[openocd.git] / src / jtag / drivers / cmsis_dap_usb.c
1 /***************************************************************************
2 * Copyright (C) 2016 by Maksym Hilliaka *
3 * oter@frozen-team.com *
4 * *
5 * Copyright (C) 2016 by Phillip Pearson *
6 * pp@myelin.co.nz *
7 * *
8 * Copyright (C) 2014 by Paul Fertser *
9 * fercerpav@gmail.com *
10 * *
11 * Copyright (C) 2013 by mike brown *
12 * mike@theshedworks.org.uk *
13 * *
14 * Copyright (C) 2013 by Spencer Oliver *
15 * spen@spen-soft.co.uk *
16 * *
17 * This program is free software; you can redistribute it and/or modify *
18 * it under the terms of the GNU General Public License as published by *
19 * the Free Software Foundation; either version 2 of the License, or *
20 * (at your option) any later version. *
21 * *
22 * This program is distributed in the hope that it will be useful, *
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
25 * GNU General Public License for more details. *
26 * *
27 * You should have received a copy of the GNU General Public License *
28 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
29 ***************************************************************************/
30
31 #ifdef HAVE_CONFIG_H
32 #include "config.h"
33 #endif
34
35 #include <transport/transport.h>
36 #include <jtag/swd.h>
37 #include <jtag/interface.h>
38 #include <jtag/commands.h>
39 #include <jtag/tcl.h>
40
41 #include <hidapi.h>
42
43 /*
44 * See CMSIS-DAP documentation:
45 * Version 0.01 - Beta.
46 */
47
48 /* USB Config */
49
50 /* Known vid/pid pairs:
51 * VID 0xc251: Keil Software
52 * PID 0xf001: LPC-Link-II CMSIS_DAP
53 * PID 0xf002: OPEN-SDA CMSIS_DAP (Freedom Board)
54 * PID 0x2722: Keil ULINK2 CMSIS-DAP
55 *
56 * VID 0x0d28: mbed Software
57 * PID 0x0204: MBED CMSIS-DAP
58 */
59
60 #define MAX_USB_IDS 8
61 /* vid = pid = 0 marks the end of the list */
62 static uint16_t cmsis_dap_vid[MAX_USB_IDS + 1] = { 0 };
63 static uint16_t cmsis_dap_pid[MAX_USB_IDS + 1] = { 0 };
64 static wchar_t *cmsis_dap_serial;
65 static bool swd_mode;
66
67 #define PACKET_SIZE (64 + 1) /* 64 bytes plus report id */
68 #define USB_TIMEOUT 1000
69
70 /* CMSIS-DAP General Commands */
71 #define CMD_DAP_INFO 0x00
72 #define CMD_DAP_LED 0x01
73 #define CMD_DAP_CONNECT 0x02
74 #define CMD_DAP_DISCONNECT 0x03
75 #define CMD_DAP_WRITE_ABORT 0x08
76 #define CMD_DAP_DELAY 0x09
77 #define CMD_DAP_RESET_TARGET 0x0A
78
79 /* CMD_INFO */
80 #define INFO_ID_VID 0x00 /* string */
81 #define INFO_ID_PID 0x02 /* string */
82 #define INFO_ID_SERNUM 0x03 /* string */
83 #define INFO_ID_FW_VER 0x04 /* string */
84 #define INFO_ID_TD_VEND 0x05 /* string */
85 #define INFO_ID_TD_NAME 0x06 /* string */
86 #define INFO_ID_CAPS 0xf0 /* byte */
87 #define INFO_ID_PKT_CNT 0xfe /* byte */
88 #define INFO_ID_PKT_SZ 0xff /* short */
89
90 #define INFO_CAPS_SWD 0x01
91 #define INFO_CAPS_JTAG 0x02
92
93 /* CMD_LED */
94 #define LED_ID_CONNECT 0x00
95 #define LED_ID_RUN 0x01
96
97 #define LED_OFF 0x00
98 #define LED_ON 0x01
99
100 /* CMD_CONNECT */
101 #define CONNECT_DEFAULT 0x00
102 #define CONNECT_SWD 0x01
103 #define CONNECT_JTAG 0x02
104
105 /* CMSIS-DAP Common SWD/JTAG Commands */
106 #define CMD_DAP_DELAY 0x09
107 #define CMD_DAP_SWJ_PINS 0x10
108 #define CMD_DAP_SWJ_CLOCK 0x11
109 #define CMD_DAP_SWJ_SEQ 0x12
110
111 /*
112 * PINS
113 * Bit 0: SWCLK/TCK
114 * Bit 1: SWDIO/TMS
115 * Bit 2: TDI
116 * Bit 3: TDO
117 * Bit 5: nTRST
118 * Bit 7: nRESET
119 */
120
121 #define SWJ_PIN_TCK (1<<0)
122 #define SWJ_PIN_TMS (1<<1)
123 #define SWJ_PIN_TDI (1<<2)
124 #define SWJ_PIN_TDO (1<<3)
125 #define SWJ_PIN_TRST (1<<5)
126 #define SWJ_PIN_SRST (1<<7)
127
128 /* CMSIS-DAP SWD Commands */
129 #define CMD_DAP_SWD_CONFIGURE 0x13
130
131 /* CMSIS-DAP JTAG Commands */
132 #define CMD_DAP_JTAG_SEQ 0x14
133 #define CMD_DAP_JTAG_CONFIGURE 0x15
134 #define CMD_DAP_JTAG_IDCODE 0x16
135
136 /* CMSIS-DAP JTAG sequence info masks */
137 /* Number of bits to clock through (0 means 64) */
138 #define DAP_JTAG_SEQ_TCK 0x3F
139 /* TMS will be set during the sequence if this bit is set */
140 #define DAP_JTAG_SEQ_TMS 0x40
141 /* TDO output will be captured if this bit is set */
142 #define DAP_JTAG_SEQ_TDO 0x80
143
144
145 /* CMSIS-DAP Transfer Commands */
146 #define CMD_DAP_TFER_CONFIGURE 0x04
147 #define CMD_DAP_TFER 0x05
148 #define CMD_DAP_TFER_BLOCK 0x06
149 #define CMD_DAP_TFER_ABORT 0x07
150
151 /* DAP Status Code */
152 #define DAP_OK 0
153 #define DAP_ERROR 0xFF
154
155 /* CMSIS-DAP Vendor Commands
156 * None as yet... */
157
158 static const char * const info_caps_str[] = {
159 "SWD Supported",
160 "JTAG Supported"
161 };
162
163 /* max clock speed (kHz) */
164 #define DAP_MAX_CLOCK 5000
165
166 struct cmsis_dap {
167 hid_device *dev_handle;
168 uint16_t packet_size;
169 uint16_t packet_count;
170 uint8_t *packet_buffer;
171 uint8_t caps;
172 uint8_t mode;
173 };
174
175 struct pending_transfer_result {
176 uint8_t cmd;
177 uint32_t data;
178 void *buffer;
179 };
180
181 struct pending_scan_result {
182 /** Offset in bytes in the CMD_DAP_JTAG_SEQ response buffer. */
183 unsigned first;
184 /** Number of bits to read. */
185 unsigned length;
186 /** Location to store the result */
187 uint8_t *buffer;
188 /** Offset in the destination buffer */
189 unsigned buffer_offset;
190 };
191
192 static int pending_transfer_count, pending_queue_len;
193 static struct pending_transfer_result *pending_transfers;
194
195 /* pointers to buffers that will receive jtag scan results on the next flush */
196 #define MAX_PENDING_SCAN_RESULTS 256
197 static int pending_scan_result_count;
198 static struct pending_scan_result pending_scan_results[MAX_PENDING_SCAN_RESULTS];
199
200 /* queued JTAG sequences that will be executed on the next flush */
201 #define QUEUED_SEQ_BUF_LEN (cmsis_dap_handle->packet_size - 3)
202 static int queued_seq_count;
203 static int queued_seq_buf_end;
204 static int queued_seq_tdo_ptr;
205 static uint8_t queued_seq_buf[1024]; /* TODO: make dynamic / move into cmsis object */
206
207 static int queued_retval;
208
209 static uint8_t output_pins = SWJ_PIN_SRST | SWJ_PIN_TRST;
210
211 static struct cmsis_dap *cmsis_dap_handle;
212
213 static int cmsis_dap_usb_open(void)
214 {
215 hid_device *dev = NULL;
216 int i;
217 struct hid_device_info *devs, *cur_dev;
218 unsigned short target_vid, target_pid;
219 wchar_t *target_serial = NULL;
220
221 bool found = false;
222 bool serial_found = false;
223
224 target_vid = 0;
225 target_pid = 0;
226
227 /*
228 * The CMSIS-DAP specification stipulates:
229 * "The Product String must contain "CMSIS-DAP" somewhere in the string. This is used by the
230 * debuggers to identify a CMSIS-DAP compliant Debug Unit that is connected to a host computer."
231 */
232 devs = hid_enumerate(0x0, 0x0);
233 cur_dev = devs;
234 while (NULL != cur_dev) {
235 if (0 == cmsis_dap_vid[0]) {
236 if (NULL == cur_dev->product_string) {
237 LOG_DEBUG("Cannot read product string of device 0x%x:0x%x",
238 cur_dev->vendor_id, cur_dev->product_id);
239 } else {
240 if (wcsstr(cur_dev->product_string, L"CMSIS-DAP")) {
241 /* if the user hasn't specified VID:PID *and*
242 * product string contains "CMSIS-DAP", pick it
243 */
244 found = true;
245 }
246 }
247 } else {
248 /* otherwise, exhaustively compare against all VID:PID in list */
249 for (i = 0; cmsis_dap_vid[i] || cmsis_dap_pid[i]; i++) {
250 if ((cmsis_dap_vid[i] == cur_dev->vendor_id) && (cmsis_dap_pid[i] == cur_dev->product_id))
251 found = true;
252 }
253
254 if (cmsis_dap_vid[i] || cmsis_dap_pid[i])
255 found = true;
256 }
257
258 if (found) {
259 /* we have found an adapter, so exit further checks */
260 /* check serial number matches if given */
261 if (cmsis_dap_serial != NULL) {
262 if ((cur_dev->serial_number != NULL) && wcscmp(cmsis_dap_serial, cur_dev->serial_number) == 0) {
263 serial_found = true;
264 break;
265 }
266 } else
267 break;
268
269 found = false;
270 }
271
272 cur_dev = cur_dev->next;
273 }
274
275 if (NULL != cur_dev) {
276 target_vid = cur_dev->vendor_id;
277 target_pid = cur_dev->product_id;
278 if (serial_found)
279 target_serial = cmsis_dap_serial;
280 }
281
282 hid_free_enumeration(devs);
283
284 if (target_vid == 0 && target_pid == 0) {
285 LOG_ERROR("unable to find CMSIS-DAP device");
286 return ERROR_FAIL;
287 }
288
289 if (hid_init() != 0) {
290 LOG_ERROR("unable to open HIDAPI");
291 return ERROR_FAIL;
292 }
293
294 dev = hid_open(target_vid, target_pid, target_serial);
295
296 if (dev == NULL) {
297 LOG_ERROR("unable to open CMSIS-DAP device 0x%x:0x%x", target_vid, target_pid);
298 return ERROR_FAIL;
299 }
300
301 struct cmsis_dap *dap = malloc(sizeof(struct cmsis_dap));
302 if (dap == NULL) {
303 LOG_ERROR("unable to allocate memory");
304 return ERROR_FAIL;
305 }
306
307 dap->dev_handle = dev;
308 dap->caps = 0;
309 dap->mode = 0;
310
311 cmsis_dap_handle = dap;
312
313 /* allocate default packet buffer, may be changed later.
314 * currently with HIDAPI we have no way of getting the output report length
315 * without this info we cannot communicate with the adapter.
316 * For the moment we ahve to hard code the packet size */
317
318 int packet_size = PACKET_SIZE;
319
320 /* atmel cmsis-dap uses 512 byte reports */
321 /* except when it doesn't e.g. with mEDBG on SAMD10 Xplained
322 * board */
323 /* TODO: HID report descriptor should be parsed instead of
324 * hardcoding a match by VID */
325 if (target_vid == 0x03eb && target_pid != 0x2145)
326 packet_size = 512 + 1;
327
328 cmsis_dap_handle->packet_buffer = malloc(packet_size);
329 cmsis_dap_handle->packet_size = packet_size;
330
331 if (cmsis_dap_handle->packet_buffer == NULL) {
332 LOG_ERROR("unable to allocate memory");
333 return ERROR_FAIL;
334 }
335
336 return ERROR_OK;
337 }
338
339 static void cmsis_dap_usb_close(struct cmsis_dap *dap)
340 {
341 hid_close(dap->dev_handle);
342 hid_exit();
343
344 free(cmsis_dap_handle->packet_buffer);
345 free(cmsis_dap_handle);
346 cmsis_dap_handle = NULL;
347 free(cmsis_dap_serial);
348 cmsis_dap_serial = NULL;
349 free(pending_transfers);
350 pending_transfers = NULL;
351
352 return;
353 }
354
355 /* Send a message and receive the reply */
356 static int cmsis_dap_usb_xfer(struct cmsis_dap *dap, int txlen)
357 {
358 #ifdef CMSIS_DAP_JTAG_DEBUG
359 LOG_DEBUG("cmsis-dap usb xfer cmd=%02X", dap->packet_buffer[1]);
360 #endif
361 /* Pad the rest of the TX buffer with 0's */
362 memset(dap->packet_buffer + txlen, 0, dap->packet_size - txlen);
363
364 /* write data to device */
365 int retval = hid_write(dap->dev_handle, dap->packet_buffer, dap->packet_size);
366 if (retval == -1) {
367 LOG_ERROR("error writing data: %ls", hid_error(dap->dev_handle));
368 return ERROR_FAIL;
369 }
370
371 /* get reply */
372 retval = hid_read_timeout(dap->dev_handle, dap->packet_buffer, dap->packet_size, USB_TIMEOUT);
373 if (retval == -1 || retval == 0) {
374 LOG_DEBUG("error reading data: %ls", hid_error(dap->dev_handle));
375 return ERROR_FAIL;
376 }
377
378 return ERROR_OK;
379 }
380
381 static int cmsis_dap_cmd_DAP_SWJ_Pins(uint8_t pins, uint8_t mask, uint32_t delay, uint8_t *input)
382 {
383 int retval;
384 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
385
386 buffer[0] = 0; /* report number */
387 buffer[1] = CMD_DAP_SWJ_PINS;
388 buffer[2] = pins;
389 buffer[3] = mask;
390 buffer[4] = delay & 0xff;
391 buffer[5] = (delay >> 8) & 0xff;
392 buffer[6] = (delay >> 16) & 0xff;
393 buffer[7] = (delay >> 24) & 0xff;
394 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 8);
395
396 if (retval != ERROR_OK) {
397 LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_PINS failed.");
398 return ERROR_JTAG_DEVICE_ERROR;
399 }
400
401 if (input)
402 *input = buffer[1];
403
404 return ERROR_OK;
405 }
406
407 static int cmsis_dap_cmd_DAP_SWJ_Clock(uint32_t swj_clock)
408 {
409 int retval;
410 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
411
412 /* set clock in Hz */
413 swj_clock *= 1000;
414 buffer[0] = 0; /* report number */
415 buffer[1] = CMD_DAP_SWJ_CLOCK;
416 buffer[2] = swj_clock & 0xff;
417 buffer[3] = (swj_clock >> 8) & 0xff;
418 buffer[4] = (swj_clock >> 16) & 0xff;
419 buffer[5] = (swj_clock >> 24) & 0xff;
420 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 6);
421
422 if (retval != ERROR_OK || buffer[1] != DAP_OK) {
423 LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_CLOCK failed.");
424 return ERROR_JTAG_DEVICE_ERROR;
425 }
426
427 return ERROR_OK;
428 }
429
430 /* clock a sequence of bits out on TMS, to change JTAG states */
431 static int cmsis_dap_cmd_DAP_SWJ_Sequence(uint8_t s_len, const uint8_t *sequence)
432 {
433 int retval;
434 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
435
436 #ifdef CMSIS_DAP_JTAG_DEBUG
437 LOG_DEBUG("cmsis-dap TMS sequence: len=%d", s_len);
438 for (int i = 0; i < DIV_ROUND_UP(s_len, 8); ++i)
439 printf("%02X ", sequence[i]);
440
441 printf("\n");
442 #endif
443
444 buffer[0] = 0; /* report number */
445 buffer[1] = CMD_DAP_SWJ_SEQ;
446 buffer[2] = s_len;
447 bit_copy(&buffer[3], 0, sequence, 0, s_len);
448
449 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, DIV_ROUND_UP(s_len, 8) + 3);
450
451 if (retval != ERROR_OK || buffer[1] != DAP_OK)
452 return ERROR_FAIL;
453
454 return ERROR_OK;
455 }
456
457 static int cmsis_dap_cmd_DAP_Info(uint8_t info, uint8_t **data)
458 {
459 int retval;
460 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
461
462 buffer[0] = 0; /* report number */
463 buffer[1] = CMD_DAP_INFO;
464 buffer[2] = info;
465 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 3);
466
467 if (retval != ERROR_OK) {
468 LOG_ERROR("CMSIS-DAP command CMD_INFO failed.");
469 return ERROR_JTAG_DEVICE_ERROR;
470 }
471
472 *data = &(buffer[1]);
473
474 return ERROR_OK;
475 }
476
477 static int cmsis_dap_cmd_DAP_LED(uint8_t leds)
478 {
479 int retval;
480 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
481
482 buffer[0] = 0; /* report number */
483 buffer[1] = CMD_DAP_LED;
484 buffer[2] = 0x00;
485 buffer[3] = leds;
486 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 4);
487
488 if (retval != ERROR_OK || buffer[1] != 0x00) {
489 LOG_ERROR("CMSIS-DAP command CMD_LED failed.");
490 return ERROR_JTAG_DEVICE_ERROR;
491 }
492
493 return ERROR_OK;
494 }
495
496 static int cmsis_dap_cmd_DAP_Connect(uint8_t mode)
497 {
498 int retval;
499 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
500
501 buffer[0] = 0; /* report number */
502 buffer[1] = CMD_DAP_CONNECT;
503 buffer[2] = mode;
504 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 3);
505
506 if (retval != ERROR_OK) {
507 LOG_ERROR("CMSIS-DAP command CMD_CONNECT failed.");
508 return ERROR_JTAG_DEVICE_ERROR;
509 }
510
511 if (buffer[1] != mode) {
512 LOG_ERROR("CMSIS-DAP failed to connect in mode (%d)", mode);
513 return ERROR_JTAG_DEVICE_ERROR;
514 }
515
516 return ERROR_OK;
517 }
518
519 static int cmsis_dap_cmd_DAP_Disconnect(void)
520 {
521 int retval;
522 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
523
524 buffer[0] = 0; /* report number */
525 buffer[1] = CMD_DAP_DISCONNECT;
526 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 2);
527
528 if (retval != ERROR_OK || buffer[1] != DAP_OK) {
529 LOG_ERROR("CMSIS-DAP command CMD_DISCONNECT failed.");
530 return ERROR_JTAG_DEVICE_ERROR;
531 }
532
533 return ERROR_OK;
534 }
535
536 static int cmsis_dap_cmd_DAP_TFER_Configure(uint8_t idle, uint16_t retry_count, uint16_t match_retry)
537 {
538 int retval;
539 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
540
541 buffer[0] = 0; /* report number */
542 buffer[1] = CMD_DAP_TFER_CONFIGURE;
543 buffer[2] = idle;
544 buffer[3] = retry_count & 0xff;
545 buffer[4] = (retry_count >> 8) & 0xff;
546 buffer[5] = match_retry & 0xff;
547 buffer[6] = (match_retry >> 8) & 0xff;
548 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 7);
549
550 if (retval != ERROR_OK || buffer[1] != DAP_OK) {
551 LOG_ERROR("CMSIS-DAP command CMD_TFER_Configure failed.");
552 return ERROR_JTAG_DEVICE_ERROR;
553 }
554
555 return ERROR_OK;
556 }
557
558 static int cmsis_dap_cmd_DAP_SWD_Configure(uint8_t cfg)
559 {
560 int retval;
561 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
562
563 buffer[0] = 0; /* report number */
564 buffer[1] = CMD_DAP_SWD_CONFIGURE;
565 buffer[2] = cfg;
566 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 3);
567
568 if (retval != ERROR_OK || buffer[1] != DAP_OK) {
569 LOG_ERROR("CMSIS-DAP command CMD_SWD_Configure failed.");
570 return ERROR_JTAG_DEVICE_ERROR;
571 }
572
573 return ERROR_OK;
574 }
575
576 #if 0
577 static int cmsis_dap_cmd_DAP_Delay(uint16_t delay_us)
578 {
579 int retval;
580 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
581
582 buffer[0] = 0; /* report number */
583 buffer[1] = CMD_DAP_DELAY;
584 buffer[2] = delay_us & 0xff;
585 buffer[3] = (delay_us >> 8) & 0xff;
586 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 4);
587
588 if (retval != ERROR_OK || buffer[1] != DAP_OK) {
589 LOG_ERROR("CMSIS-DAP command CMD_Delay failed.");
590 return ERROR_JTAG_DEVICE_ERROR;
591 }
592
593 return ERROR_OK;
594 }
595 #endif
596
597 static int cmsis_dap_swd_run_queue(void)
598 {
599 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
600
601 LOG_DEBUG_IO("Executing %d queued transactions", pending_transfer_count);
602
603 if (queued_retval != ERROR_OK) {
604 LOG_DEBUG("Skipping due to previous errors: %d", queued_retval);
605 goto skip;
606 }
607
608 if (!pending_transfer_count)
609 goto skip;
610
611 size_t idx = 0;
612 buffer[idx++] = 0; /* report number */
613 buffer[idx++] = CMD_DAP_TFER;
614 buffer[idx++] = 0x00; /* DAP Index */
615 buffer[idx++] = pending_transfer_count;
616
617 for (int i = 0; i < pending_transfer_count; i++) {
618 uint8_t cmd = pending_transfers[i].cmd;
619 uint32_t data = pending_transfers[i].data;
620
621 LOG_DEBUG_IO("%s %s reg %x %"PRIx32,
622 cmd & SWD_CMD_APnDP ? "AP" : "DP",
623 cmd & SWD_CMD_RnW ? "read" : "write",
624 (cmd & SWD_CMD_A32) >> 1, data);
625
626 /* When proper WAIT handling is implemented in the
627 * common SWD framework, this kludge can be
628 * removed. However, this might lead to minor
629 * performance degradation as the adapter wouldn't be
630 * able to automatically retry anything (because ARM
631 * has forgotten to implement sticky error flags
632 * clearing). See also comments regarding
633 * cmsis_dap_cmd_DAP_TFER_Configure() and
634 * cmsis_dap_cmd_DAP_SWD_Configure() in
635 * cmsis_dap_init().
636 */
637 if (!(cmd & SWD_CMD_RnW) &&
638 !(cmd & SWD_CMD_APnDP) &&
639 (cmd & SWD_CMD_A32) >> 1 == DP_CTRL_STAT &&
640 (data & CORUNDETECT)) {
641 LOG_DEBUG("refusing to enable sticky overrun detection");
642 data &= ~CORUNDETECT;
643 }
644
645 buffer[idx++] = (cmd >> 1) & 0x0f;
646 if (!(cmd & SWD_CMD_RnW)) {
647 buffer[idx++] = (data) & 0xff;
648 buffer[idx++] = (data >> 8) & 0xff;
649 buffer[idx++] = (data >> 16) & 0xff;
650 buffer[idx++] = (data >> 24) & 0xff;
651 }
652 }
653
654 queued_retval = cmsis_dap_usb_xfer(cmsis_dap_handle, idx);
655 if (queued_retval != ERROR_OK)
656 goto skip;
657
658 idx = 2;
659 uint8_t ack = buffer[idx] & 0x07;
660 if (ack != SWD_ACK_OK || (buffer[idx] & 0x08)) {
661 LOG_DEBUG("SWD ack not OK: %d %s", buffer[idx-1],
662 ack == SWD_ACK_WAIT ? "WAIT" : ack == SWD_ACK_FAULT ? "FAULT" : "JUNK");
663 queued_retval = ack == SWD_ACK_WAIT ? ERROR_WAIT : ERROR_FAIL;
664 goto skip;
665 }
666 idx++;
667
668 if (pending_transfer_count != buffer[1])
669 LOG_ERROR("CMSIS-DAP transfer count mismatch: expected %d, got %d",
670 pending_transfer_count, buffer[1]);
671
672 for (int i = 0; i < buffer[1]; i++) {
673 if (pending_transfers[i].cmd & SWD_CMD_RnW) {
674 static uint32_t last_read;
675 uint32_t data = le_to_h_u32(&buffer[idx]);
676 uint32_t tmp = data;
677 idx += 4;
678
679 LOG_DEBUG_IO("Read result: %"PRIx32, data);
680
681 /* Imitate posted AP reads */
682 if ((pending_transfers[i].cmd & SWD_CMD_APnDP) ||
683 ((pending_transfers[i].cmd & SWD_CMD_A32) >> 1 == DP_RDBUFF)) {
684 tmp = last_read;
685 last_read = data;
686 }
687
688 if (pending_transfers[i].buffer)
689 *(uint32_t *)pending_transfers[i].buffer = tmp;
690 }
691 }
692
693 skip:
694 pending_transfer_count = 0;
695 int retval = queued_retval;
696 queued_retval = ERROR_OK;
697
698 return retval;
699 }
700
701 static void cmsis_dap_swd_queue_cmd(uint8_t cmd, uint32_t *dst, uint32_t data)
702 {
703 if (pending_transfer_count == pending_queue_len) {
704 /* Not enough room in the queue. Run the queue. */
705 queued_retval = cmsis_dap_swd_run_queue();
706 }
707
708 if (queued_retval != ERROR_OK)
709 return;
710
711 pending_transfers[pending_transfer_count].data = data;
712 pending_transfers[pending_transfer_count].cmd = cmd;
713 if (cmd & SWD_CMD_RnW) {
714 /* Queue a read transaction */
715 pending_transfers[pending_transfer_count].buffer = dst;
716 }
717 pending_transfer_count++;
718 }
719
720 static void cmsis_dap_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk)
721 {
722 assert(!(cmd & SWD_CMD_RnW));
723 cmsis_dap_swd_queue_cmd(cmd, NULL, value);
724 }
725
726 static void cmsis_dap_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk)
727 {
728 assert(cmd & SWD_CMD_RnW);
729 cmsis_dap_swd_queue_cmd(cmd, value, 0);
730 }
731
732 static int cmsis_dap_get_version_info(void)
733 {
734 uint8_t *data;
735
736 /* INFO_ID_FW_VER - string */
737 int retval = cmsis_dap_cmd_DAP_Info(INFO_ID_FW_VER, &data);
738 if (retval != ERROR_OK)
739 return retval;
740
741 if (data[0]) /* strlen */
742 LOG_INFO("CMSIS-DAP: FW Version = %s", &data[1]);
743
744 return ERROR_OK;
745 }
746
747 static int cmsis_dap_get_caps_info(void)
748 {
749 uint8_t *data;
750
751 /* INFO_ID_CAPS - byte */
752 int retval = cmsis_dap_cmd_DAP_Info(INFO_ID_CAPS, &data);
753 if (retval != ERROR_OK)
754 return retval;
755
756 if (data[0] == 1) {
757 uint8_t caps = data[1];
758
759 cmsis_dap_handle->caps = caps;
760
761 if (caps & INFO_CAPS_SWD)
762 LOG_INFO("CMSIS-DAP: %s", info_caps_str[0]);
763 if (caps & INFO_CAPS_JTAG)
764 LOG_INFO("CMSIS-DAP: %s", info_caps_str[1]);
765 }
766
767 return ERROR_OK;
768 }
769
770 static int cmsis_dap_get_status(void)
771 {
772 uint8_t d;
773
774 int retval = cmsis_dap_cmd_DAP_SWJ_Pins(0, 0, 0, &d);
775
776 if (retval == ERROR_OK) {
777 LOG_INFO("SWCLK/TCK = %d SWDIO/TMS = %d TDI = %d TDO = %d nTRST = %d nRESET = %d",
778 (d & SWJ_PIN_TCK) ? 1 : 0,
779 (d & SWJ_PIN_TMS) ? 1 : 0,
780 (d & SWJ_PIN_TDI) ? 1 : 0,
781 (d & SWJ_PIN_TDO) ? 1 : 0,
782 (d & SWJ_PIN_TRST) ? 1 : 0,
783 (d & SWJ_PIN_SRST) ? 1 : 0);
784 }
785
786 return retval;
787 }
788
789 static int cmsis_dap_swd_switch_seq(enum swd_special_seq seq)
790 {
791 const uint8_t *s;
792 unsigned int s_len;
793 int retval;
794
795 if ((output_pins & (SWJ_PIN_SRST | SWJ_PIN_TRST)) == (SWJ_PIN_SRST | SWJ_PIN_TRST)) {
796 /* Following workaround deasserts reset on most adapters.
797 * Do not reconnect if a reset line is active!
798 * Reconnecting would break connecting under reset. */
799
800 /* First disconnect before connecting, Atmel EDBG needs it for SAMD/R/L/C */
801 cmsis_dap_cmd_DAP_Disconnect();
802
803 /* When we are reconnecting, DAP_Connect needs to be rerun, at
804 * least on Keil ULINK-ME */
805 retval = cmsis_dap_cmd_DAP_Connect(CONNECT_SWD);
806 if (retval != ERROR_OK)
807 return retval;
808 }
809
810 switch (seq) {
811 case LINE_RESET:
812 LOG_DEBUG("SWD line reset");
813 s = swd_seq_line_reset;
814 s_len = swd_seq_line_reset_len;
815 break;
816 case JTAG_TO_SWD:
817 LOG_DEBUG("JTAG-to-SWD");
818 s = swd_seq_jtag_to_swd;
819 s_len = swd_seq_jtag_to_swd_len;
820 break;
821 case SWD_TO_JTAG:
822 LOG_DEBUG("SWD-to-JTAG");
823 s = swd_seq_swd_to_jtag;
824 s_len = swd_seq_swd_to_jtag_len;
825 break;
826 default:
827 LOG_ERROR("Sequence %d not supported", seq);
828 return ERROR_FAIL;
829 }
830
831 retval = cmsis_dap_cmd_DAP_SWJ_Sequence(s_len, s);
832 if (retval != ERROR_OK)
833 return retval;
834
835 /* Atmel EDBG needs renew clock setting after SWJ_Sequence
836 * otherwise default frequency is used */
837 return cmsis_dap_cmd_DAP_SWJ_Clock(jtag_get_speed_khz());
838 }
839
840 static int cmsis_dap_swd_open(void)
841 {
842 int retval;
843
844 if (cmsis_dap_handle == NULL) {
845 /* SWD init */
846 retval = cmsis_dap_usb_open();
847 if (retval != ERROR_OK)
848 return retval;
849
850 retval = cmsis_dap_get_caps_info();
851 if (retval != ERROR_OK)
852 return retval;
853 }
854
855 if (!(cmsis_dap_handle->caps & INFO_CAPS_SWD)) {
856 LOG_ERROR("CMSIS-DAP: SWD not supported");
857 return ERROR_JTAG_DEVICE_ERROR;
858 }
859
860 retval = cmsis_dap_cmd_DAP_Connect(CONNECT_SWD);
861 if (retval != ERROR_OK)
862 return retval;
863
864 /* Add more setup here.??... */
865
866 LOG_INFO("CMSIS-DAP: Interface Initialised (SWD)");
867 return ERROR_OK;
868 }
869
870 static int cmsis_dap_init(void)
871 {
872 int retval;
873 uint8_t *data;
874
875 if (swd_mode) {
876 retval = cmsis_dap_swd_open();
877 if (retval != ERROR_OK)
878 return retval;
879 }
880
881 if (cmsis_dap_handle == NULL) {
882
883 /* JTAG init */
884 retval = cmsis_dap_usb_open();
885 if (retval != ERROR_OK)
886 return retval;
887
888 retval = cmsis_dap_get_caps_info();
889 if (retval != ERROR_OK)
890 return retval;
891
892 /* Connect in JTAG mode */
893 if (!(cmsis_dap_handle->caps & INFO_CAPS_JTAG)) {
894 LOG_ERROR("CMSIS-DAP: JTAG not supported");
895 return ERROR_JTAG_DEVICE_ERROR;
896 }
897
898 retval = cmsis_dap_cmd_DAP_Connect(CONNECT_JTAG);
899 if (retval != ERROR_OK)
900 return retval;
901
902 LOG_INFO("CMSIS-DAP: Interface Initialised (JTAG)");
903 }
904
905 retval = cmsis_dap_get_version_info();
906 if (retval != ERROR_OK)
907 return retval;
908
909 /* INFO_ID_PKT_SZ - short */
910 retval = cmsis_dap_cmd_DAP_Info(INFO_ID_PKT_SZ, &data);
911 if (retval != ERROR_OK)
912 return retval;
913
914 if (data[0] == 2) { /* short */
915 uint16_t pkt_sz = data[1] + (data[2] << 8);
916
917 /* 4 bytes of command header + 5 bytes per register
918 * write. For bulk read sequences just 4 bytes are
919 * needed per transfer, so this is suboptimal. */
920 pending_queue_len = (pkt_sz - 4) / 5;
921 pending_transfers = malloc(pending_queue_len * sizeof(*pending_transfers));
922 if (!pending_transfers) {
923 LOG_ERROR("Unable to allocate memory for CMSIS-DAP queue");
924 return ERROR_FAIL;
925 }
926
927 if (cmsis_dap_handle->packet_size != pkt_sz + 1) {
928 /* reallocate buffer */
929 cmsis_dap_handle->packet_size = pkt_sz + 1;
930 cmsis_dap_handle->packet_buffer = realloc(cmsis_dap_handle->packet_buffer,
931 cmsis_dap_handle->packet_size);
932 if (cmsis_dap_handle->packet_buffer == NULL) {
933 LOG_ERROR("unable to reallocate memory");
934 return ERROR_FAIL;
935 }
936 }
937
938 LOG_DEBUG("CMSIS-DAP: Packet Size = %" PRId16, pkt_sz);
939 }
940
941 /* INFO_ID_PKT_CNT - byte */
942 retval = cmsis_dap_cmd_DAP_Info(INFO_ID_PKT_CNT, &data);
943 if (retval != ERROR_OK)
944 return retval;
945
946 if (data[0] == 1) { /* byte */
947 uint16_t pkt_cnt = data[1];
948 cmsis_dap_handle->packet_count = pkt_cnt;
949 LOG_DEBUG("CMSIS-DAP: Packet Count = %" PRId16, pkt_cnt);
950 }
951
952 retval = cmsis_dap_get_status();
953 if (retval != ERROR_OK)
954 return ERROR_FAIL;
955
956 /* Now try to connect to the target
957 * TODO: This is all SWD only @ present */
958 retval = cmsis_dap_cmd_DAP_SWJ_Clock(jtag_get_speed_khz());
959 if (retval != ERROR_OK)
960 return ERROR_FAIL;
961
962 /* Ask CMSIS-DAP to automatically retry on receiving WAIT for
963 * up to 64 times. This must be changed to 0 if sticky
964 * overrun detection is enabled. */
965 retval = cmsis_dap_cmd_DAP_TFER_Configure(0, 64, 0);
966 if (retval != ERROR_OK)
967 return ERROR_FAIL;
968
969 if (swd_mode) {
970 /* Data Phase (bit 2) must be set to 1 if sticky overrun
971 * detection is enabled */
972 retval = cmsis_dap_cmd_DAP_SWD_Configure(0); /* 1 TRN, no Data Phase */
973 if (retval != ERROR_OK)
974 return ERROR_FAIL;
975 }
976
977 retval = cmsis_dap_cmd_DAP_LED(0x03); /* Both LEDs on */
978 if (retval != ERROR_OK)
979 return ERROR_FAIL;
980
981 /* support connecting with srst asserted */
982 enum reset_types jtag_reset_config = jtag_get_reset_config();
983
984 if (jtag_reset_config & RESET_CNCT_UNDER_SRST) {
985 if (jtag_reset_config & RESET_SRST_NO_GATING) {
986 retval = cmsis_dap_cmd_DAP_SWJ_Pins(0, (1 << 7), 0, NULL);
987 if (retval != ERROR_OK)
988 return ERROR_FAIL;
989 LOG_INFO("Connecting under reset");
990 }
991 }
992
993 cmsis_dap_cmd_DAP_LED(0x00); /* Both LEDs off */
994
995 LOG_INFO("CMSIS-DAP: Interface ready");
996
997 return ERROR_OK;
998 }
999
1000 static int cmsis_dap_swd_init(void)
1001 {
1002 swd_mode = true;
1003 return ERROR_OK;
1004 }
1005
1006 static int cmsis_dap_quit(void)
1007 {
1008 cmsis_dap_cmd_DAP_Disconnect();
1009 cmsis_dap_cmd_DAP_LED(0x00); /* Both LEDs off */
1010
1011 cmsis_dap_usb_close(cmsis_dap_handle);
1012
1013 return ERROR_OK;
1014 }
1015
1016 static void cmsis_dap_execute_reset(struct jtag_command *cmd)
1017 {
1018 /* Set both TRST and SRST even if they're not enabled as
1019 * there's no way to tristate them */
1020
1021 output_pins = 0;
1022 if (!cmd->cmd.reset->srst)
1023 output_pins |= SWJ_PIN_SRST;
1024 if (!cmd->cmd.reset->trst)
1025 output_pins |= SWJ_PIN_TRST;
1026
1027 int retval = cmsis_dap_cmd_DAP_SWJ_Pins(output_pins,
1028 SWJ_PIN_TRST | SWJ_PIN_SRST, 0, NULL);
1029 if (retval != ERROR_OK)
1030 LOG_ERROR("CMSIS-DAP: Interface reset failed");
1031 }
1032
1033 static void cmsis_dap_execute_sleep(struct jtag_command *cmd)
1034 {
1035 #if 0
1036 int retval = cmsis_dap_cmd_DAP_Delay(cmd->cmd.sleep->us);
1037 if (retval != ERROR_OK)
1038 #endif
1039 jtag_sleep(cmd->cmd.sleep->us);
1040 }
1041
1042 /* Set TMS high for five TCK clocks, to move the TAP to the Test-Logic-Reset state */
1043 static int cmsis_dap_execute_tlr_reset(struct jtag_command *cmd)
1044 {
1045 LOG_INFO("cmsis-dap JTAG TLR_RESET");
1046 uint8_t seq = 0xff;
1047 int ret = cmsis_dap_cmd_DAP_SWJ_Sequence(8, &seq);
1048 if (ret == ERROR_OK)
1049 tap_set_state(TAP_RESET);
1050 return ret;
1051 }
1052
1053 /* Set new end state */
1054 static void cmsis_dap_end_state(tap_state_t state)
1055 {
1056 if (tap_is_state_stable(state))
1057 tap_set_end_state(state);
1058 else {
1059 LOG_ERROR("BUG: %i is not a valid end state", state);
1060 exit(-1);
1061 }
1062 }
1063
1064 #ifdef SPRINT_BINARY
1065 static void sprint_binary(char *s, const uint8_t *buf, int offset, int len)
1066 {
1067 if (!len)
1068 return;
1069
1070 /*
1071 buf = { 0x18 } len=5 should result in: 11000
1072 buf = { 0xff 0x18 } len=13 should result in: 11111111 11000
1073 buf = { 0xc0 0x18 } offset=3 len=10 should result in: 11000 11000
1074 i=3 there means i/8 = 0 so c = 0xFF, and
1075 */
1076 for (int i = offset; i < offset + len; ++i) {
1077 uint8_t c = buf[i / 8], mask = 1 << (i % 8);
1078 if ((i != offset) && !(i % 8))
1079 putchar(' ');
1080 *s++ = (c & mask) ? '1' : '0';
1081 }
1082 *s = 0;
1083 }
1084 #endif
1085
1086 #ifdef CMSIS_DAP_JTAG_DEBUG
1087 static void debug_parse_cmsis_buf(const uint8_t *cmd, int cmdlen)
1088 {
1089 /* cmd is a usb packet to go to the cmsis-dap interface */
1090 printf("cmsis-dap buffer (%d b): ", cmdlen);
1091 for (int i = 0; i < cmdlen; ++i)
1092 printf(" %02x", cmd[i]);
1093 printf("\n");
1094 switch (cmd[1]) {
1095 case CMD_DAP_JTAG_SEQ: {
1096 printf("cmsis-dap jtag sequence command %02x (n=%d)\n", cmd[1], cmd[2]);
1097 /*
1098 * #2 = number of sequences
1099 * #3 = sequence info 1
1100 * #4...4+n_bytes-1 = sequence 1
1101 * #4+n_bytes = sequence info 2
1102 * #5+n_bytes = sequence 2 (single bit)
1103 */
1104 int pos = 3;
1105 for (int seq = 0; seq < cmd[2]; ++seq) {
1106 uint8_t info = cmd[pos++];
1107 int len = info & DAP_JTAG_SEQ_TCK;
1108 if (len == 0)
1109 len = 64;
1110 printf(" sequence %d starting %d: info %02x (len=%d tms=%d read_tdo=%d): ",
1111 seq, pos, info, len, info & DAP_JTAG_SEQ_TMS, info & DAP_JTAG_SEQ_TDO);
1112 for (int i = 0; i < DIV_ROUND_UP(len, 8); ++i)
1113 printf(" %02x", cmd[pos+i]);
1114 pos += DIV_ROUND_UP(len, 8);
1115 printf("\n");
1116 }
1117 if (pos != cmdlen) {
1118 printf("BUFFER LENGTH MISMATCH looks like %d but %d specified", pos, cmdlen);
1119 exit(-1);
1120 }
1121
1122 break;
1123 }
1124 default:
1125 LOG_DEBUG("unknown cmsis-dap command %02x", cmd[1]);
1126 break;
1127 }
1128 }
1129 #endif
1130
1131 static void cmsis_dap_flush(void)
1132 {
1133 if (!queued_seq_count)
1134 return;
1135
1136 DEBUG_JTAG_IO("Flushing %d queued sequences (%d bytes) with %d pending scan results to capture",
1137 queued_seq_count, queued_seq_buf_end, pending_scan_result_count);
1138
1139 /* prep CMSIS-DAP packet */
1140 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
1141 buffer[0] = 0; /* report number */
1142 buffer[1] = CMD_DAP_JTAG_SEQ;
1143 buffer[2] = queued_seq_count;
1144 memcpy(buffer + 3, queued_seq_buf, queued_seq_buf_end);
1145
1146 #ifdef CMSIS_DAP_JTAG_DEBUG
1147 debug_parse_cmsis_buf(buffer, queued_seq_buf_end + 3);
1148 #endif
1149
1150 /* send command to USB device */
1151 int retval = cmsis_dap_usb_xfer(cmsis_dap_handle, queued_seq_buf_end + 3);
1152 if (retval != ERROR_OK || buffer[1] != DAP_OK) {
1153 LOG_ERROR("CMSIS-DAP command CMD_DAP_JTAG_SEQ failed.");
1154 exit(-1);
1155 }
1156
1157 #ifdef CMSIS_DAP_JTAG_DEBUG
1158 DEBUG_JTAG_IO("USB response buf:");
1159 for (int c = 0; c < queued_seq_buf_end + 3; ++c)
1160 printf("%02X ", buffer[c]);
1161 printf("\n");
1162 #endif
1163
1164 /* copy scan results into client buffers */
1165 for (int i = 0; i < pending_scan_result_count; ++i) {
1166 struct pending_scan_result *scan = &pending_scan_results[i];
1167 DEBUG_JTAG_IO("Copying pending_scan_result %d/%d: %d bits from byte %d -> buffer + %d bits",
1168 i, pending_scan_result_count, scan->length, scan->first + 2, scan->buffer_offset);
1169 #ifdef CMSIS_DAP_JTAG_DEBUG
1170 for (uint32_t b = 0; b < DIV_ROUND_UP(scan->length, 8); ++b)
1171 printf("%02X ", buffer[2+scan->first+b]);
1172 printf("\n");
1173 #endif
1174 bit_copy(scan->buffer, scan->buffer_offset, buffer + 2 + scan->first, 0, scan->length);
1175 }
1176
1177 /* reset */
1178 queued_seq_count = 0;
1179 queued_seq_buf_end = 0;
1180 queued_seq_tdo_ptr = 0;
1181 pending_scan_result_count = 0;
1182 }
1183
1184 /* queue a sequence of bits to clock out TDI / in TDO, executing if the buffer is full.
1185 *
1186 * sequence=NULL means clock out zeros on TDI
1187 * tdo_buffer=NULL means don't capture TDO
1188 */
1189 static void cmsis_dap_add_jtag_sequence(int s_len, const uint8_t *sequence, int s_offset,
1190 bool tms, uint8_t *tdo_buffer, int tdo_buffer_offset)
1191 {
1192 DEBUG_JTAG_IO("[at %d] %d bits, tms %s, seq offset %d, tdo buf %p, tdo offset %d",
1193 queued_seq_buf_end,
1194 s_len, tms ? "HIGH" : "LOW", s_offset, tdo_buffer, tdo_buffer_offset);
1195
1196 if (s_len == 0)
1197 return;
1198
1199 if (s_len > 64) {
1200 DEBUG_JTAG_IO("START JTAG SEQ SPLIT");
1201 for (int offset = 0; offset < s_len; offset += 64) {
1202 int len = s_len - offset;
1203 if (len > 64)
1204 len = 64;
1205 DEBUG_JTAG_IO("Splitting long jtag sequence: %d-bit chunk starting at offset %d", len, offset);
1206 cmsis_dap_add_jtag_sequence(
1207 len,
1208 sequence,
1209 s_offset + offset,
1210 tms,
1211 tdo_buffer,
1212 tdo_buffer == NULL ? 0 : (tdo_buffer_offset + offset)
1213 );
1214 }
1215 DEBUG_JTAG_IO("END JTAG SEQ SPLIT");
1216 return;
1217 }
1218
1219 int cmd_len = 1 + DIV_ROUND_UP(s_len, 8);
1220 if (queued_seq_count >= 255 || queued_seq_buf_end + cmd_len > QUEUED_SEQ_BUF_LEN)
1221 /* empty out the buffer */
1222 cmsis_dap_flush();
1223
1224 ++queued_seq_count;
1225
1226 /* control byte */
1227 queued_seq_buf[queued_seq_buf_end] =
1228 (tms ? DAP_JTAG_SEQ_TMS : 0) |
1229 (tdo_buffer != NULL ? DAP_JTAG_SEQ_TDO : 0) |
1230 (s_len == 64 ? 0 : s_len);
1231
1232 if (sequence != NULL)
1233 bit_copy(&queued_seq_buf[queued_seq_buf_end + 1], 0, sequence, s_offset, s_len);
1234 else
1235 memset(&queued_seq_buf[queued_seq_buf_end + 1], 0, DIV_ROUND_UP(s_len, 8));
1236
1237 queued_seq_buf_end += cmd_len;
1238
1239 if (tdo_buffer != NULL) {
1240 struct pending_scan_result *scan = &pending_scan_results[pending_scan_result_count++];
1241 scan->first = queued_seq_tdo_ptr;
1242 queued_seq_tdo_ptr += DIV_ROUND_UP(s_len, 8);
1243 scan->length = s_len;
1244 scan->buffer = tdo_buffer;
1245 scan->buffer_offset = tdo_buffer_offset;
1246 }
1247 }
1248
1249 /* queue a sequence of bits to clock out TMS, executing if the buffer is full */
1250 static void cmsis_dap_add_tms_sequence(const uint8_t *sequence, int s_len)
1251 {
1252 DEBUG_JTAG_IO("%d bits: %02X", s_len, *sequence);
1253 /* we use a series of CMD_DAP_JTAG_SEQ commands to toggle TMS,
1254 because even though it seems ridiculously inefficient, it
1255 allows us to combine TMS and scan sequences into the same
1256 USB packet. */
1257 /* TODO: combine runs of the same tms value */
1258 for (int i = 0; i < s_len; ++i) {
1259 bool bit = (sequence[i / 8] & (1 << (i % 8))) != 0;
1260 cmsis_dap_add_jtag_sequence(1, NULL, 0, bit, NULL, 0);
1261 }
1262 }
1263
1264 /* Move to the end state by queuing a sequence to clock into TMS */
1265 static void cmsis_dap_state_move(void)
1266 {
1267 uint8_t tms_scan;
1268 uint8_t tms_scan_bits;
1269
1270 tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state());
1271 tms_scan_bits = tap_get_tms_path_len(tap_get_state(), tap_get_end_state());
1272
1273 DEBUG_JTAG_IO("state move from %s to %s: %d clocks, %02X on tms",
1274 tap_state_name(tap_get_state()), tap_state_name(tap_get_end_state()),
1275 tms_scan_bits, tms_scan);
1276 cmsis_dap_add_tms_sequence(&tms_scan, tms_scan_bits);
1277
1278 tap_set_state(tap_get_end_state());
1279 }
1280
1281
1282 /* Execute a JTAG scan operation by queueing TMS and TDI/TDO sequences */
1283 static void cmsis_dap_execute_scan(struct jtag_command *cmd)
1284 {
1285 DEBUG_JTAG_IO("%s type:%d", cmd->cmd.scan->ir_scan ? "IRSCAN" : "DRSCAN",
1286 jtag_scan_type(cmd->cmd.scan));
1287
1288 /* Make sure there are no trailing fields with num_bits == 0, or the logic below will fail. */
1289 while (cmd->cmd.scan->num_fields > 0
1290 && cmd->cmd.scan->fields[cmd->cmd.scan->num_fields - 1].num_bits == 0) {
1291 cmd->cmd.scan->num_fields--;
1292 LOG_DEBUG("discarding trailing empty field");
1293 }
1294
1295 if (cmd->cmd.scan->num_fields == 0) {
1296 LOG_DEBUG("empty scan, doing nothing");
1297 return;
1298 }
1299
1300 if (cmd->cmd.scan->ir_scan) {
1301 if (tap_get_state() != TAP_IRSHIFT) {
1302 cmsis_dap_end_state(TAP_IRSHIFT);
1303 cmsis_dap_state_move();
1304 }
1305 } else {
1306 if (tap_get_state() != TAP_DRSHIFT) {
1307 cmsis_dap_end_state(TAP_DRSHIFT);
1308 cmsis_dap_state_move();
1309 }
1310 }
1311
1312 cmsis_dap_end_state(cmd->cmd.scan->end_state);
1313
1314 struct scan_field *field = cmd->cmd.scan->fields;
1315 unsigned scan_size = 0;
1316
1317 for (int i = 0; i < cmd->cmd.scan->num_fields; i++, field++) {
1318 scan_size += field->num_bits;
1319 DEBUG_JTAG_IO("%s%s field %d/%d %d bits",
1320 field->in_value ? "in" : "",
1321 field->out_value ? "out" : "",
1322 i,
1323 cmd->cmd.scan->num_fields,
1324 field->num_bits);
1325
1326 if (i == cmd->cmd.scan->num_fields - 1 && tap_get_state() != tap_get_end_state()) {
1327 DEBUG_JTAG_IO("Last field and have to move out of SHIFT state");
1328 /* Last field, and we're leaving IRSHIFT/DRSHIFT. Clock last bit during tap
1329 * movement. This last field can't have length zero, it was checked above. */
1330 cmsis_dap_add_jtag_sequence(
1331 field->num_bits - 1, /* number of bits to clock */
1332 field->out_value, /* output sequence */
1333 0, /* output offset */
1334 false, /* TMS low */
1335 field->in_value,
1336 0);
1337
1338 /* Clock the last bit out, with TMS high */
1339 uint8_t last_bit = 0;
1340 if (field->out_value)
1341 bit_copy(&last_bit, 0, field->out_value, field->num_bits - 1, 1);
1342 cmsis_dap_add_jtag_sequence(
1343 1,
1344 &last_bit,
1345 0,
1346 true,
1347 field->in_value,
1348 field->num_bits - 1);
1349 tap_set_state(tap_state_transition(tap_get_state(), 1));
1350
1351 /* Now clock one more cycle, with TMS low, to get us into a PAUSE state */
1352 cmsis_dap_add_jtag_sequence(
1353 1,
1354 &last_bit,
1355 0,
1356 false,
1357 NULL,
1358 0);
1359 tap_set_state(tap_state_transition(tap_get_state(), 0));
1360 } else {
1361 DEBUG_JTAG_IO("Internal field, staying in SHIFT state afterwards");
1362 /* Clocking part of a sequence into DR or IR with TMS=0,
1363 leaving TMS=0 at the end so we can continue later */
1364 cmsis_dap_add_jtag_sequence(
1365 field->num_bits,
1366 field->out_value,
1367 0,
1368 false,
1369 field->in_value,
1370 0);
1371 }
1372 }
1373
1374 if (tap_get_state() != tap_get_end_state()) {
1375 cmsis_dap_end_state(tap_get_end_state());
1376 cmsis_dap_state_move();
1377 }
1378
1379 DEBUG_JTAG_IO("%s scan, %i bits, end in %s",
1380 (cmd->cmd.scan->ir_scan) ? "IR" : "DR", scan_size,
1381 tap_state_name(tap_get_end_state()));
1382 }
1383
1384 static void cmsis_dap_pathmove(int num_states, tap_state_t *path)
1385 {
1386 int i;
1387 uint8_t tms0 = 0x00;
1388 uint8_t tms1 = 0xff;
1389
1390 for (i = 0; i < num_states; i++) {
1391 if (path[i] == tap_state_transition(tap_get_state(), false))
1392 cmsis_dap_add_tms_sequence(&tms0, 1);
1393 else if (path[i] == tap_state_transition(tap_get_state(), true))
1394 cmsis_dap_add_tms_sequence(&tms1, 1);
1395 else {
1396 LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition.",
1397 tap_state_name(tap_get_state()), tap_state_name(path[i]));
1398 exit(-1);
1399 }
1400
1401 tap_set_state(path[i]);
1402 }
1403
1404 cmsis_dap_end_state(tap_get_state());
1405 }
1406
1407 static void cmsis_dap_execute_pathmove(struct jtag_command *cmd)
1408 {
1409 DEBUG_JTAG_IO("pathmove: %i states, end in %i",
1410 cmd->cmd.pathmove->num_states,
1411 cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
1412
1413 cmsis_dap_pathmove(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path);
1414 }
1415
1416 static void cmsis_dap_stableclocks(int num_cycles)
1417 {
1418 int i;
1419
1420 uint8_t tms = tap_get_state() == TAP_RESET;
1421 /* TODO: Perform optimizations? */
1422 /* Execute num_cycles. */
1423 for (i = 0; i < num_cycles; i++)
1424 cmsis_dap_add_tms_sequence(&tms, 1);
1425 }
1426
1427 static void cmsis_dap_runtest(int num_cycles)
1428 {
1429 tap_state_t saved_end_state = tap_get_end_state();
1430
1431 /* Only do a state_move when we're not already in IDLE. */
1432 if (tap_get_state() != TAP_IDLE) {
1433 cmsis_dap_end_state(TAP_IDLE);
1434 cmsis_dap_state_move();
1435 }
1436 cmsis_dap_stableclocks(num_cycles);
1437
1438 /* Finish in end_state. */
1439 cmsis_dap_end_state(saved_end_state);
1440
1441 if (tap_get_state() != tap_get_end_state())
1442 cmsis_dap_state_move();
1443 }
1444
1445 static void cmsis_dap_execute_runtest(struct jtag_command *cmd)
1446 {
1447 DEBUG_JTAG_IO("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles,
1448 cmd->cmd.runtest->end_state);
1449
1450 cmsis_dap_end_state(cmd->cmd.runtest->end_state);
1451 cmsis_dap_runtest(cmd->cmd.runtest->num_cycles);
1452 }
1453
1454 static void cmsis_dap_execute_stableclocks(struct jtag_command *cmd)
1455 {
1456 DEBUG_JTAG_IO("stableclocks %i cycles", cmd->cmd.runtest->num_cycles);
1457 cmsis_dap_stableclocks(cmd->cmd.runtest->num_cycles);
1458 }
1459
1460 /* TODO: Is there need to call cmsis_dap_flush() for the JTAG_PATHMOVE,
1461 * JTAG_RUNTEST, JTAG_STABLECLOCKS? */
1462 static void cmsis_dap_execute_command(struct jtag_command *cmd)
1463 {
1464 switch (cmd->type) {
1465 case JTAG_RESET:
1466 cmsis_dap_flush();
1467 cmsis_dap_execute_reset(cmd);
1468 break;
1469 case JTAG_SLEEP:
1470 cmsis_dap_flush();
1471 cmsis_dap_execute_sleep(cmd);
1472 break;
1473 case JTAG_TLR_RESET:
1474 cmsis_dap_flush();
1475 cmsis_dap_execute_tlr_reset(cmd);
1476 break;
1477 case JTAG_SCAN:
1478 cmsis_dap_execute_scan(cmd);
1479 break;
1480 case JTAG_PATHMOVE:
1481 cmsis_dap_execute_pathmove(cmd);
1482 break;
1483 case JTAG_RUNTEST:
1484 cmsis_dap_execute_runtest(cmd);
1485 break;
1486 case JTAG_STABLECLOCKS:
1487 cmsis_dap_execute_stableclocks(cmd);
1488 break;
1489 case JTAG_TMS:
1490 default:
1491 LOG_ERROR("BUG: unknown JTAG command type 0x%X encountered", cmd->type);
1492 exit(-1);
1493 }
1494 }
1495
1496 static int cmsis_dap_execute_queue(void)
1497 {
1498 struct jtag_command *cmd = jtag_command_queue;
1499
1500 while (cmd != NULL) {
1501 cmsis_dap_execute_command(cmd);
1502 cmd = cmd->next;
1503 }
1504
1505 cmsis_dap_flush();
1506
1507 return ERROR_OK;
1508 }
1509
1510 static int cmsis_dap_speed(int speed)
1511 {
1512 if (speed > DAP_MAX_CLOCK)
1513 LOG_INFO("High speed (adapter_khz %d) may be limited by adapter firmware.", speed);
1514
1515 if (speed == 0) {
1516 LOG_ERROR("RTCK not supported. Set nonzero adapter_khz.");
1517 return ERROR_JTAG_NOT_IMPLEMENTED;
1518 }
1519
1520 return cmsis_dap_cmd_DAP_SWJ_Clock(speed);
1521 }
1522
1523 static int cmsis_dap_speed_div(int speed, int *khz)
1524 {
1525 *khz = speed;
1526 return ERROR_OK;
1527 }
1528
1529 static int cmsis_dap_khz(int khz, int *jtag_speed)
1530 {
1531 *jtag_speed = khz;
1532 return ERROR_OK;
1533 }
1534
1535 static int_least32_t cmsis_dap_swd_frequency(int_least32_t hz)
1536 {
1537 if (hz > 0)
1538 cmsis_dap_speed(hz / 1000);
1539
1540 return hz;
1541 }
1542
1543
1544 COMMAND_HANDLER(cmsis_dap_handle_info_command)
1545 {
1546 if (cmsis_dap_get_version_info() == ERROR_OK)
1547 cmsis_dap_get_status();
1548
1549 return ERROR_OK;
1550 }
1551
1552 COMMAND_HANDLER(cmsis_dap_handle_vid_pid_command)
1553 {
1554 if (CMD_ARGC > MAX_USB_IDS * 2) {
1555 LOG_WARNING("ignoring extra IDs in cmsis_dap_vid_pid "
1556 "(maximum is %d pairs)", MAX_USB_IDS);
1557 CMD_ARGC = MAX_USB_IDS * 2;
1558 }
1559 if (CMD_ARGC < 2 || (CMD_ARGC & 1)) {
1560 LOG_WARNING("incomplete cmsis_dap_vid_pid configuration directive");
1561 if (CMD_ARGC < 2)
1562 return ERROR_COMMAND_SYNTAX_ERROR;
1563 /* remove the incomplete trailing id */
1564 CMD_ARGC -= 1;
1565 }
1566
1567 unsigned i;
1568 for (i = 0; i < CMD_ARGC; i += 2) {
1569 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i], cmsis_dap_vid[i >> 1]);
1570 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], cmsis_dap_pid[i >> 1]);
1571 }
1572
1573 /*
1574 * Explicitly terminate, in case there are multiples instances of
1575 * cmsis_dap_vid_pid.
1576 */
1577 cmsis_dap_vid[i >> 1] = cmsis_dap_pid[i >> 1] = 0;
1578
1579 return ERROR_OK;
1580 }
1581
1582 COMMAND_HANDLER(cmsis_dap_handle_serial_command)
1583 {
1584 if (CMD_ARGC == 1) {
1585 size_t len = mbstowcs(NULL, CMD_ARGV[0], 0);
1586 cmsis_dap_serial = calloc(len + 1, sizeof(wchar_t));
1587 if (cmsis_dap_serial == NULL) {
1588 LOG_ERROR("unable to allocate memory");
1589 return ERROR_OK;
1590 }
1591 if (mbstowcs(cmsis_dap_serial, CMD_ARGV[0], len + 1) == (size_t)-1) {
1592 free(cmsis_dap_serial);
1593 cmsis_dap_serial = NULL;
1594 LOG_ERROR("unable to convert serial");
1595 }
1596 } else {
1597 LOG_ERROR("expected exactly one argument to cmsis_dap_serial <serial-number>");
1598 }
1599
1600 return ERROR_OK;
1601 }
1602
1603 static const struct command_registration cmsis_dap_subcommand_handlers[] = {
1604 {
1605 .name = "info",
1606 .handler = &cmsis_dap_handle_info_command,
1607 .mode = COMMAND_EXEC,
1608 .usage = "",
1609 .help = "show cmsis-dap info",
1610 },
1611 COMMAND_REGISTRATION_DONE
1612 };
1613
1614 static const struct command_registration cmsis_dap_command_handlers[] = {
1615 {
1616 .name = "cmsis-dap",
1617 .mode = COMMAND_ANY,
1618 .help = "perform CMSIS-DAP management",
1619 .usage = "<cmd>",
1620 .chain = cmsis_dap_subcommand_handlers,
1621 },
1622 {
1623 .name = "cmsis_dap_vid_pid",
1624 .handler = &cmsis_dap_handle_vid_pid_command,
1625 .mode = COMMAND_CONFIG,
1626 .help = "the vendor ID and product ID of the CMSIS-DAP device",
1627 .usage = "(vid pid)* ",
1628 },
1629 {
1630 .name = "cmsis_dap_serial",
1631 .handler = &cmsis_dap_handle_serial_command,
1632 .mode = COMMAND_CONFIG,
1633 .help = "set the serial number of the adapter",
1634 .usage = "serial_string",
1635 },
1636 COMMAND_REGISTRATION_DONE
1637 };
1638
1639 static const struct swd_driver cmsis_dap_swd_driver = {
1640 .init = cmsis_dap_swd_init,
1641 .frequency = cmsis_dap_swd_frequency,
1642 .switch_seq = cmsis_dap_swd_switch_seq,
1643 .read_reg = cmsis_dap_swd_read_reg,
1644 .write_reg = cmsis_dap_swd_write_reg,
1645 .run = cmsis_dap_swd_run_queue,
1646 };
1647
1648 static const char * const cmsis_dap_transport[] = { "swd", "jtag", NULL };
1649
1650 struct jtag_interface cmsis_dap_interface = {
1651 .name = "cmsis-dap",
1652 .commands = cmsis_dap_command_handlers,
1653 .swd = &cmsis_dap_swd_driver,
1654 .transports = cmsis_dap_transport,
1655
1656 .execute_queue = cmsis_dap_execute_queue,
1657 .speed = cmsis_dap_speed,
1658 .speed_div = cmsis_dap_speed_div,
1659 .khz = cmsis_dap_khz,
1660 .init = cmsis_dap_init,
1661 .quit = cmsis_dap_quit,
1662 };
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)