Code Review / openocd.git / blob
? search:


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