Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
cmsis-dap: add initial cmsis-dap support
[openocd.git] / src / jtag / drivers / cmsis_dap_usb.c
1 /***************************************************************************
2 * Copyright (C) 2013 by mike brown *
3 * mike@theshedworks.org.uk *
4 * *
5 * Copyright (C) 2013 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
7 * *
8 * This program is free software; you can redistribute it and/or modify *
9 * it under the terms of the GNU General Public License as published by *
10 * the Free Software Foundation; either version 2 of the License, or *
11 * (at your option) any later version. *
12 * *
13 * This program is distributed in the hope that it will be useful, *
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
16 * GNU General Public License for more details. *
17 * *
18 * You should have received a copy of the GNU General Public License *
19 * along with this program; if not, write to the *
20 * Free Software Foundation, Inc., *
21 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. *
22 ***************************************************************************/
23
24 #ifdef HAVE_CONFIG_H
25 #include "config.h"
26 #endif
27
28 #include <transport/transport.h>
29 #include <jtag/swd.h>
30 #include <jtag/interface.h>
31 #include <jtag/commands.h>
32 #include <jtag/tcl.h>
33
34 #include <hidapi.h>
35
36 #ifdef _DEBUG_JTAG_IO_
37 #define DEBUG_IO(expr...) LOG_DEBUG(expr)
38 #else
39 #define DEBUG_IO(expr...) do {} while (0)
40 #endif
41
42 /*
43 * See CMSIS-DAP documentation:
44 * Version 0.01 - Beta.
45 */
46
47 /* USB Config */
48
49 /* Known vid/pid pairs:
50 * VID 0xc251: Keil Software
51 * PID 0xf001: LPC-Link-II CMSIS_DAP
52 * PID 0xf002: OPEN-SDA CMSIS_DAP (Freedom Board)
53 * PID 0x2722: Keil ULINK2 CMSIS-DAP
54 *
55 * VID 0x0d28: mbed Software
56 * PID 0x0204: MBED CMSIS-DAP
57 */
58
59 #define MAX_USB_IDS 8
60 /* vid = pid = 0 marks the end of the list */
61 static uint16_t cmsis_dap_vid[MAX_USB_IDS + 1] = { 0xc251, 0xc251, 0xc251, 0x0d28, 0x03eb, 0 };
62 static uint16_t cmsis_dap_pid[MAX_USB_IDS + 1] = { 0xf001, 0xf002, 0x2722, 0x0204, 0x2111, 0 };
63
64 #define PACKET_SIZE (64 + 1) /* 64 bytes plus report id */
65 #define USB_TIMEOUT 1000
66
67 /* CMSIS-DAP General Commands */
68 #define CMD_DAP_INFO 0x00
69 #define CMD_DAP_LED 0x01
70 #define CMD_DAP_CONNECT 0x02
71 #define CMD_DAP_DISCONNECT 0x03
72 #define CMD_DAP_WRITE_ABORT 0x08
73 #define CMD_DAP_DELAY 0x09
74 #define CMD_DAP_RESET_TARGET 0x0A
75
76 /* CMD_INFO */
77 #define INFO_ID_VID 0x00 /* string */
78 #define INFO_ID_PID 0x02 /* string */
79 #define INFO_ID_SERNUM 0x03 /* string */
80 #define INFO_ID_FW_VER 0x04 /* string */
81 #define INFO_ID_TD_VEND 0x05 /* string */
82 #define INFO_ID_TD_NAME 0x06 /* string */
83 #define INFO_ID_CAPS 0xf0 /* byte */
84 #define INFO_ID_PKT_CNT 0xfe /* byte */
85 #define INFO_ID_PKT_SZ 0xff /* short */
86
87 #define INFO_CAPS_SWD 0x01
88 #define INFO_CAPS_JTAG 0x02
89
90 /* CMD_LED */
91 #define LED_ID_CONNECT 0x00
92 #define LED_ID_RUN 0x01
93
94 #define LED_OFF 0x00
95 #define LED_ON 0x01
96
97 /* CMD_CONNECT */
98 #define CONNECT_DEFAULT 0x00
99 #define CONNECT_SWD 0x01
100 #define CONNECT_JTAG 0x02
101
102 /* CMSIS-DAP Common SWD/JTAG Commands */
103 #define CMD_DAP_DELAY 0x09
104 #define CMD_DAP_SWJ_PINS 0x10
105 #define CMD_DAP_SWJ_CLOCK 0x11
106 #define CMD_DAP_SWJ_SEQ 0x12
107
108 /*
109 * PINS
110 * Bit 0: SWCLK/TCK
111 * Bit 1: SWDIO/TMS
112 * Bit 2: TDI
113 * Bit 3: TDO
114 * Bit 5: nTRST
115 * Bit 7: nRESET
116 */
117
118 /* CMSIS-DAP SWD Commands */
119 #define CMD_DAP_SWD_CONFIGURE 0x13
120
121 /* CMSIS-DAP JTAG Commands */
122 #define CMD_DAP_JTAG_SEQ 0x14
123 #define CMD_DAP_JTAG_CONFIGURE 0x15
124 #define CMD_DAP_JTAG_IDCODE 0x16
125
126 /* CMSIS-DAP Transfer Commands */
127 #define CMD_DAP_TFER_CONFIGURE 0x04
128 #define CMD_DAP_TFER 0x05
129 #define CMD_DAP_TFER_BLOCK 0x06
130 #define CMD_DAP_TFER_ABORT 0x07
131
132 /* DAP Status Code */
133 #define DAP_OK 0
134 #define DAP_ERROR 0xFF
135
136 /* CMSIS-DAP Vendor Commands
137 * None as yet... */
138
139 static char *info_caps_str[] = {
140 "SWD Supported",
141 "JTAG Supported"
142 };
143
144 /* max clock speed (kHz) */
145 #define DAP_MAX_CLOCK 5000
146
147 struct cmsis_dap {
148 hid_device *dev_handle;
149 uint16_t packet_size;
150 uint16_t packet_count;
151 uint8_t *packet_buffer;
152 uint8_t caps;
153 uint8_t mode;
154 };
155
156 static struct cmsis_dap *cmsis_dap_handle;
157
158 static int cmsis_dap_usb_open(void)
159 {
160 hid_device *dev = NULL;
161 int i;
162
163 if (hid_init() != 0) {
164 LOG_ERROR("unable to open HIDAPI");
165 return ERROR_FAIL;
166 }
167
168 for (i = 0; cmsis_dap_vid[i] || cmsis_dap_pid[i]; i++) {
169 dev = hid_open(cmsis_dap_vid[i], cmsis_dap_pid[i], NULL);
170 if (dev != NULL)
171 break;
172 }
173
174 if (dev == NULL) {
175 LOG_ERROR("unable to open CMSIS-DAP device");
176 return ERROR_FAIL;
177 }
178
179 struct cmsis_dap *dap = malloc(sizeof(struct cmsis_dap));
180 if (dap == NULL) {
181 LOG_ERROR("unable to allocate memory");
182 return ERROR_FAIL;
183 }
184
185 dap->dev_handle = dev;
186 dap->caps = 0;
187 dap->mode = 0;
188
189 cmsis_dap_handle = dap;
190
191 /* allocate default packet buffer, may be changed later.
192 * currently with HIDAPI we have no way of getting the output report length
193 * without this info we cannot communicate with the adapter.
194 * For the moment we ahve to hard code the packet size */
195
196 int packet_size = PACKET_SIZE;
197
198 /* atmel cmsis-dap uses 512 byte reports */
199 if (cmsis_dap_vid[i] == 0x03eb && cmsis_dap_pid[i] == 0x2111)
200 packet_size = 512 + 1;
201
202 cmsis_dap_handle->packet_buffer = malloc(packet_size);
203 cmsis_dap_handle->packet_size = packet_size;
204
205 if (cmsis_dap_handle->packet_buffer == NULL) {
206 LOG_ERROR("unable to allocate memory");
207 return ERROR_FAIL;
208 }
209
210 return ERROR_OK;
211 }
212
213 static void cmsis_dap_usb_close(struct cmsis_dap *dap)
214 {
215 hid_close(dap->dev_handle);
216 hid_exit();
217
218 if (cmsis_dap_handle->packet_buffer)
219 free(cmsis_dap_handle->packet_buffer);
220
221 if (cmsis_dap_handle) {
222 free(cmsis_dap_handle);
223 cmsis_dap_handle = NULL;
224 }
225
226 return;
227 }
228
229 /* Send a message and receive the reply */
230 static int cmsis_dap_usb_xfer(struct cmsis_dap *dap, int txlen)
231 {
232 /* Pad the rest of the TX buffer with 0's */
233 memset(dap->packet_buffer + txlen, 0, dap->packet_size - 1 - txlen);
234
235 /* write data to device */
236 int retval = hid_write(dap->dev_handle, dap->packet_buffer, dap->packet_size);
237 if (retval == -1) {
238 LOG_ERROR("error writing data: %ls", hid_error(dap->dev_handle));
239 return ERROR_FAIL;
240 }
241
242 /* get reply */
243 retval = hid_read_timeout(dap->dev_handle, dap->packet_buffer, dap->packet_size, USB_TIMEOUT);
244 if (retval == -1 || retval == 0) {
245 LOG_DEBUG("error reading data: %ls", hid_error(dap->dev_handle));
246 return ERROR_FAIL;
247 }
248
249 return ERROR_OK;
250 }
251
252 static int cmsis_dap_cmd_DAP_SWJ_Pins(uint8_t pins, uint8_t mask, uint32_t wait, uint8_t *input)
253 {
254 int retval;
255 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
256
257 buffer[0] = 0; /* report number */
258 buffer[1] = CMD_DAP_SWJ_PINS;
259 buffer[2] = pins;
260 buffer[3] = mask;
261 buffer[4] = wait & 0xff;
262 buffer[5] = (wait >> 8) & 0xff;
263 buffer[6] = (wait >> 16) & 0xff;
264 buffer[7] = (wait >> 24) & 0xff;
265 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 8);
266
267 if (retval != ERROR_OK) {
268 LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_PINS failed.");
269 return ERROR_JTAG_DEVICE_ERROR;
270 }
271
272 if (input)
273 *input = buffer[1];
274
275 return ERROR_OK;
276 }
277
278 static int cmsis_dap_cmd_DAP_SWJ_Clock(uint32_t swj_clock)
279 {
280 int retval;
281 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
282
283 /* set clock in Hz */
284 swj_clock *= 1000;
285 buffer[0] = 0; /* report number */
286 buffer[1] = CMD_DAP_SWJ_CLOCK;
287 buffer[2] = swj_clock & 0xff;
288 buffer[3] = (swj_clock >> 8) & 0xff;
289 buffer[4] = (swj_clock >> 16) & 0xff;
290 buffer[5] = (swj_clock >> 24) & 0xff;
291 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 6);
292
293 if (retval != ERROR_OK || buffer[1] != DAP_OK) {
294 LOG_ERROR("CMSIS-DAP command CMD_DAP_SWJ_CLOCK failed.");
295 return ERROR_JTAG_DEVICE_ERROR;
296 }
297
298 return ERROR_OK;
299 }
300
301 static int cmsis_dap_cmd_DAP_Info(uint8_t info, uint8_t **data)
302 {
303 int retval;
304 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
305
306 buffer[0] = 0; /* report number */
307 buffer[1] = CMD_DAP_INFO;
308 buffer[2] = info;
309 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 3);
310
311 if (retval != ERROR_OK) {
312 LOG_ERROR("CMSIS-DAP command CMD_INFO failed.");
313 return ERROR_JTAG_DEVICE_ERROR;
314 }
315
316 *data = &(buffer[1]);
317
318 return ERROR_OK;
319 }
320
321 static int cmsis_dap_cmd_DAP_LED(uint8_t leds)
322 {
323 int retval;
324 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
325
326 buffer[0] = 0; /* report number */
327 buffer[1] = CMD_DAP_LED;
328 buffer[2] = 0x00;
329 buffer[3] = leds;
330 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 4);
331
332 if (retval != ERROR_OK || buffer[1] != 0x00) {
333 LOG_ERROR("CMSIS-DAP command CMD_LED failed.");
334 return ERROR_JTAG_DEVICE_ERROR;
335 }
336
337 return ERROR_OK;
338 }
339
340 static int cmsis_dap_cmd_DAP_Connect(uint8_t mode)
341 {
342 int retval;
343 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
344
345 buffer[0] = 0; /* report number */
346 buffer[1] = CMD_DAP_CONNECT;
347 buffer[2] = mode;
348 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 3);
349
350 if (retval != ERROR_OK) {
351 LOG_ERROR("CMSIS-DAP command CMD_CONNECT failed.");
352 return ERROR_JTAG_DEVICE_ERROR;
353 }
354
355 if (buffer[1] != mode) {
356 LOG_ERROR("CMSIS-DAP failed to connect in mode (%d)", mode);
357 return ERROR_JTAG_DEVICE_ERROR;
358 }
359
360 return ERROR_OK;
361 }
362
363 static int cmsis_dap_cmd_DAP_Disconnect(void)
364 {
365 int retval;
366 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
367
368 buffer[0] = 0; /* report number */
369 buffer[1] = CMD_DAP_DISCONNECT;
370 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 2);
371
372 if (retval != ERROR_OK || buffer[1] != DAP_OK) {
373 LOG_ERROR("CMSIS-DAP command CMD_DISCONNECT failed.");
374 return ERROR_JTAG_DEVICE_ERROR;
375 }
376
377 return ERROR_OK;
378 }
379
380 static int cmsis_dap_cmd_DAP_TFER_Configure(uint8_t idle, uint16_t wait, uint16_t retry)
381 {
382 int retval;
383 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
384
385 buffer[0] = 0; /* report number */
386 buffer[1] = CMD_DAP_TFER_CONFIGURE;
387 buffer[2] = idle;
388 buffer[3] = wait & 0xff;
389 buffer[4] = (wait >> 8) & 0xff;
390 buffer[5] = retry & 0xff;
391 buffer[6] = (retry >> 8) & 0xff;
392 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 7);
393
394 if (retval != ERROR_OK || buffer[1] != DAP_OK) {
395 LOG_ERROR("CMSIS-DAP command CMD_TFER_Configure failed.");
396 return ERROR_JTAG_DEVICE_ERROR;
397 }
398
399 return ERROR_OK;
400 }
401
402 static int cmsis_dap_cmd_DAP_SWD_Configure(uint8_t cfg)
403 {
404 int retval;
405 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
406
407 buffer[0] = 0; /* report number */
408 buffer[1] = CMD_DAP_SWD_CONFIGURE;
409 buffer[2] = cfg;
410 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 3);
411
412 if (retval != ERROR_OK || buffer[1] != DAP_OK) {
413 LOG_ERROR("CMSIS-DAP command CMD_SWD_Configure failed.");
414 return ERROR_JTAG_DEVICE_ERROR;
415 }
416
417 return ERROR_OK;
418 }
419
420 #if 0
421 static int cmsis_dap_cmd_DAP_Delay(uint16_t delay_us)
422 {
423 int retval;
424 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
425
426 buffer[0] = 0; /* report number */
427 buffer[1] = CMD_DAP_DELAY;
428 buffer[2] = delay_us & 0xff;
429 buffer[3] = (delay_us >> 8) & 0xff;
430 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 4);
431
432 if (retval != ERROR_OK || buffer[1] != DAP_OK) {
433 LOG_ERROR("CMSIS-DAP command CMD_Delay failed.");
434 return ERROR_JTAG_DEVICE_ERROR;
435 }
436
437 return ERROR_OK;
438 }
439 #endif
440
441 static int cmsis_dap_swd_read_reg(uint8_t cmd, uint32_t *value)
442 {
443 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
444 int retval;
445 uint32_t val;
446
447 DEBUG_IO("CMSIS-DAP: Read Reg 0x%02" PRIx8, cmd);
448
449 buffer[0] = 0; /* report number */
450 buffer[1] = CMD_DAP_TFER;
451 buffer[2] = 0x00;
452 buffer[3] = 0x01;
453 buffer[4] = cmd;
454 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 5);
455
456 /* TODO - need better response checking */
457 if (retval != ERROR_OK || buffer[1] != 0x01) {
458 LOG_ERROR("CMSIS-DAP: Read Error (0x%02" PRIx8 ")", buffer[2]);
459 return buffer[2];
460 }
461
462 val = le_to_h_u32(&buffer[3]);
463 DEBUG_IO("0x%08" PRIx32, val);
464
465 if (value)
466 *value = val;
467
468 return retval;
469 }
470
471 static int cmsis_dap_swd_write_reg(uint8_t cmd, uint32_t value)
472 {
473 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
474
475 DEBUG_IO("CMSIS-DAP: Write Reg 0x%02" PRIx8 " 0x%08" PRIx32, cmd, value);
476
477 buffer[0] = 0; /* report number */
478 buffer[1] = CMD_DAP_TFER;
479 buffer[2] = 0x00;
480 buffer[3] = 0x01;
481 buffer[4] = cmd;
482 buffer[5] = (value) & 0xff;
483 buffer[6] = (value >> 8) & 0xff;
484 buffer[7] = (value >> 16) & 0xff;
485 buffer[8] = (value >> 24) & 0xff;
486 int retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 9);
487
488 if (buffer[1] != 0x01) {
489 LOG_ERROR("CMSIS-DAP: Write Error (0x%02" PRIx8 ")", buffer[2]);
490 retval = buffer[2];
491 }
492
493 return retval;
494 }
495
496 static int cmsis_dap_swd_read_block(uint8_t cmd, uint32_t blocksize, uint8_t *dest_buf)
497 {
498 uint8_t *buffer;
499 int tfer_sz;
500 int retval = ERROR_OK;
501 uint16_t read_count;
502
503 DEBUG_IO("CMSIS-DAP: Read Block 0x%02" PRIx8 " %" PRIu32, cmd, blocksize);
504
505 while (blocksize) {
506
507 buffer = cmsis_dap_handle->packet_buffer;
508 tfer_sz = blocksize;
509 if (tfer_sz > 15)
510 tfer_sz = 8;
511
512 buffer[0] = 0; /* report number */
513 buffer[1] = CMD_DAP_TFER_BLOCK;
514 buffer[2] = 0x00;
515 buffer[3] = tfer_sz;
516 buffer[4] = 0x00;
517 buffer[5] = cmd;
518 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 6);
519
520 read_count = le_to_h_u16(&buffer[1]);
521 if (read_count != tfer_sz) {
522 LOG_ERROR("CMSIS-DAP: Block Read Error (0x%02" PRIx8 ")", buffer[3]);
523 retval = buffer[3];
524 }
525
526 read_count *= 4;
527 memcpy(dest_buf, &buffer[4], read_count);
528
529 dest_buf += read_count;
530 blocksize -= tfer_sz;
531 }
532
533 return retval;
534 }
535
536 static int cmsis_dap_get_version_info(void)
537 {
538 uint8_t *data;
539
540 /* INFO_ID_FW_VER - string */
541 int retval = cmsis_dap_cmd_DAP_Info(INFO_ID_FW_VER, &data);
542 if (retval != ERROR_OK)
543 return retval;
544
545 if (data[0]) /* strlen */
546 LOG_INFO("CMSIS-DAP: FW Version = %s", &data[1]);
547
548 return ERROR_OK;
549 }
550
551 static int cmsis_dap_get_caps_info(void)
552 {
553 uint8_t *data;
554
555 /* INFO_ID_CAPS - byte */
556 int retval = cmsis_dap_cmd_DAP_Info(INFO_ID_CAPS, &data);
557 if (retval != ERROR_OK)
558 return retval;
559
560 if (data[0] == 1) {
561 uint8_t caps = data[1];
562
563 cmsis_dap_handle->caps = caps;
564
565 if (caps & INFO_CAPS_SWD)
566 LOG_INFO("CMSIS-DAP: %s", info_caps_str[0]);
567 if (caps & INFO_CAPS_JTAG)
568 LOG_INFO("CMSIS-DAP: %s", info_caps_str[1]);
569 }
570
571 return ERROR_OK;
572 }
573
574 static int cmsis_dap_get_status(void)
575 {
576 uint8_t d;
577
578 int retval = cmsis_dap_cmd_DAP_SWJ_Pins(0, 0, 0, &d);
579
580 if (retval == ERROR_OK) {
581 LOG_INFO("SWCLK/TCK = %d SWDIO/TMS = %d TDI = %d TDO = %d nTRST = %d nRESET = %d",
582 (d & (0x01 << 0)) ? 1 : 0, /* Bit 0: SWCLK/TCK */
583 (d & (0x01 << 1)) ? 1 : 0, /* Bit 1: SWDIO/TMS */
584 (d & (0x01 << 2)) ? 1 : 0, /* Bit 2: TDI */
585 (d & (0x01 << 3)) ? 1 : 0, /* Bit 3: TDO */
586 (d & (0x01 << 5)) ? 1 : 0, /* Bit 5: nTRST */
587 (d & (0x01 << 7)) ? 1 : 0); /* Bit 7: nRESET */
588 }
589
590 return retval;
591 }
592
593 static int cmsis_dap_reset_link(void)
594 {
595 uint8_t *buffer = cmsis_dap_handle->packet_buffer;
596
597 LOG_DEBUG("CMSIS-DAP: cmsis_dap_reset_link");
598 LOG_INFO("DAP_SWJ Sequence (reset: 50+ '1' followed by 0)");
599
600 /* reset line with SWDIO high for >50 cycles */
601 buffer[0] = 0; /* report number */
602 buffer[1] = CMD_DAP_SWJ_SEQ;
603 buffer[2] = 7 * 8;
604 buffer[3] = 0xff;
605 buffer[4] = 0xff;
606 buffer[5] = 0xff;
607 buffer[6] = 0xff;
608 buffer[7] = 0xff;
609 buffer[8] = 0xff;
610 buffer[9] = 0xff;
611 int retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 10);
612
613 if (retval != ERROR_OK || buffer[1] != DAP_OK)
614 return ERROR_FAIL;
615
616 /* 16bit JTAG-SWD sequence */
617 buffer[0] = 0; /* report number */
618 buffer[1] = CMD_DAP_SWJ_SEQ;
619 buffer[2] = 2 * 8;
620 buffer[3] = 0x9e;
621 buffer[4] = 0xe7;
622 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 5);
623
624 if (retval != ERROR_OK || buffer[1] != DAP_OK)
625 return ERROR_FAIL;
626
627 /* another reset just incase */
628 buffer[0] = 0; /* report number */
629 buffer[1] = CMD_DAP_SWJ_SEQ;
630 buffer[2] = 7 * 8;
631 buffer[3] = 0xff;
632 buffer[4] = 0xff;
633 buffer[5] = 0xff;
634 buffer[6] = 0xff;
635 buffer[7] = 0xff;
636 buffer[8] = 0xff;
637 buffer[9] = 0xff;
638 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 10);
639
640 if (retval != ERROR_OK || buffer[1] != DAP_OK)
641 return ERROR_FAIL;
642
643 /* 16 cycle idle period */
644 buffer[0] = 0; /* report number */
645 buffer[1] = CMD_DAP_SWJ_SEQ;
646 buffer[2] = 2 * 8;
647 buffer[3] = 0x00;
648 buffer[4] = 0x00;
649 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 5);
650
651 if (retval != ERROR_OK || buffer[1] != DAP_OK)
652 return ERROR_FAIL;
653
654 DEBUG_IO("DAP Read IDCODE");
655
656 /* read the id code is always the next sequence */
657 buffer[0] = 0; /* report number */
658 buffer[1] = CMD_DAP_TFER;
659 buffer[2] = 0x00;
660 buffer[3] = 0x01;
661 buffer[4] = 0x02;
662 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 5);
663
664 if (retval != ERROR_OK)
665 return retval;
666
667 if (buffer[1] == 0) {
668 LOG_DEBUG("Result 0x%02" PRIx8 " 0x%02" PRIx8, buffer[1], buffer[2]);
669
670 LOG_DEBUG("DAP Reset Target");
671 buffer[0] = 0; /* report number */
672 buffer[1] = CMD_DAP_RESET_TARGET;
673 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 2);
674 LOG_DEBUG("Result 0x%02" PRIx8 " 0x%02" PRIx8, buffer[1], buffer[2]);
675
676 LOG_DEBUG("DAP Write Abort");
677 buffer[0] = 0; /* report number */
678 buffer[1] = CMD_DAP_WRITE_ABORT;
679 buffer[2] = 0x00;
680 buffer[3] = 0x1e/*0x1f*/;
681 buffer[4] = 0x00;
682 buffer[5] = 0x00;
683 buffer[6] = 0x00;
684 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 7);
685 LOG_DEBUG("Result 0x%02" PRIx8, buffer[1]);
686
687 return 0x80 + buffer[1];
688 }
689
690 LOG_DEBUG("DAP Write Abort");
691 buffer[0] = 0; /* report number */
692 buffer[1] = CMD_DAP_WRITE_ABORT;
693 buffer[2] = 0x00;
694 buffer[3] = 0x1e;
695 buffer[4] = 0x00;
696 buffer[5] = 0x00;
697 buffer[6] = 0x00;
698 retval = cmsis_dap_usb_xfer(cmsis_dap_handle, 7);
699 LOG_DEBUG("Result 0x%02" PRIx8, buffer[1]);
700
701 return retval;
702 }
703
704 static int cmsis_dap_init(void)
705 {
706 int retval;
707 uint8_t *data;
708
709 if (cmsis_dap_handle == NULL) {
710
711 /* JTAG init */
712 retval = cmsis_dap_usb_open();
713 if (retval != ERROR_OK)
714 return retval;
715
716 retval = cmsis_dap_get_caps_info();
717 if (retval != ERROR_OK)
718 return retval;
719
720 /* Connect in JTAG mode */
721 if (!(cmsis_dap_handle->caps & INFO_CAPS_JTAG)) {
722 LOG_ERROR("CMSIS-DAP: JTAG not supported");
723 return ERROR_JTAG_DEVICE_ERROR;
724 }
725
726 retval = cmsis_dap_cmd_DAP_Connect(CONNECT_JTAG);
727 if (retval != ERROR_OK)
728 return retval;
729
730 LOG_INFO("CMSIS-DAP: Interface Initialised (JTAG)");
731 }
732
733 retval = cmsis_dap_get_version_info();
734 if (retval != ERROR_OK)
735 return retval;
736
737 /* INFO_ID_PKT_SZ - short */
738 retval = cmsis_dap_cmd_DAP_Info(INFO_ID_PKT_SZ, &data);
739 if (retval != ERROR_OK)
740 return retval;
741
742 if (data[0] == 2) { /* short */
743 uint16_t pkt_sz = data[1] + (data[2] << 8);
744
745 if (cmsis_dap_handle->packet_size != pkt_sz + 1) {
746 /* reallocate buffer */
747 cmsis_dap_handle->packet_size = pkt_sz + 1;
748 cmsis_dap_handle->packet_buffer = realloc(cmsis_dap_handle->packet_buffer,
749 cmsis_dap_handle->packet_size);
750 if (cmsis_dap_handle->packet_buffer == NULL) {
751 LOG_ERROR("unable to reallocate memory");
752 return ERROR_FAIL;
753 }
754 }
755
756 LOG_DEBUG("CMSIS-DAP: Packet Size = %" PRId16, pkt_sz);
757 }
758
759 /* INFO_ID_PKT_CNT - byte */
760 retval = cmsis_dap_cmd_DAP_Info(INFO_ID_PKT_CNT, &data);
761 if (retval != ERROR_OK)
762 return retval;
763
764 if (data[0] == 1) { /* byte */
765 uint16_t pkt_cnt = data[1];
766 cmsis_dap_handle->packet_count = pkt_cnt;
767 LOG_DEBUG("CMSIS-DAP: Packet Count = %" PRId16, pkt_cnt);
768 }
769
770 retval = cmsis_dap_get_status();
771 if (retval != ERROR_OK)
772 return ERROR_FAIL;
773
774 /* Now try to connect to the target
775 * TODO: This is all SWD only @ present */
776 retval = cmsis_dap_cmd_DAP_SWJ_Clock(100); /* 100kHz */
777 if (retval != ERROR_OK)
778 return ERROR_FAIL;
779
780 retval = cmsis_dap_cmd_DAP_TFER_Configure(0, 64, 0);
781 if (retval != ERROR_OK)
782 return ERROR_FAIL;
783 retval = cmsis_dap_cmd_DAP_SWD_Configure(0x00);
784 if (retval != ERROR_OK)
785 return ERROR_FAIL;
786
787 retval = cmsis_dap_cmd_DAP_LED(0x03); /* Both LEDs on */
788 if (retval != ERROR_OK)
789 return ERROR_FAIL;
790
791 /* support connecting with srst asserted */
792 enum reset_types jtag_reset_config = jtag_get_reset_config();
793
794 if (jtag_reset_config & RESET_CNCT_UNDER_SRST) {
795 if (jtag_reset_config & RESET_SRST_NO_GATING) {
796 retval = cmsis_dap_cmd_DAP_SWJ_Pins(0, (1 << 7), 0, NULL);
797 if (retval != ERROR_OK)
798 return ERROR_FAIL;
799 LOG_INFO("Connecting under reset");
800 }
801 }
802
803 retval = cmsis_dap_reset_link();
804 if (retval != ERROR_OK)
805 return ERROR_FAIL;
806
807 cmsis_dap_cmd_DAP_LED(0x00); /* Both LEDs off */
808
809 LOG_INFO("CMSIS-DAP: Interface ready");
810
811 return ERROR_OK;
812 }
813
814 static int cmsis_dap_swd_init(uint8_t trn)
815 {
816 int retval;
817
818 DEBUG_IO("CMSIS-DAP: cmsis_dap_swd_init");
819
820 if (cmsis_dap_handle == NULL) {
821
822 /* SWD init */
823 retval = cmsis_dap_usb_open();
824 if (retval != ERROR_OK)
825 return retval;
826
827 retval = cmsis_dap_get_caps_info();
828 if (retval != ERROR_OK)
829 return retval;
830 }
831
832 if (!(cmsis_dap_handle->caps & INFO_CAPS_SWD)) {
833 LOG_ERROR("CMSIS-DAP: SWD not supported");
834 return ERROR_JTAG_DEVICE_ERROR;
835 }
836
837 retval = cmsis_dap_cmd_DAP_Connect(CONNECT_SWD);
838 if (retval != ERROR_OK)
839 return retval;
840
841 /* Add more setup here.??... */
842
843 LOG_INFO("CMSIS-DAP: Interface Initialised (SWD)");
844 return ERROR_OK;
845 }
846
847 static int cmsis_dap_quit(void)
848 {
849 cmsis_dap_cmd_DAP_Disconnect();
850 cmsis_dap_cmd_DAP_LED(0x00); /* Both LEDs off */
851
852 cmsis_dap_usb_close(cmsis_dap_handle);
853
854 return ERROR_OK;
855 }
856
857 static void cmsis_dap_execute_reset(struct jtag_command *cmd)
858 {
859 int retval = cmsis_dap_cmd_DAP_SWJ_Pins(cmd->cmd.reset->srst ? 0 : (1 << 7), \
860 (1 << 7), 0, NULL);
861 if (retval != ERROR_OK)
862 LOG_ERROR("CMSIS-DAP: Interface reset failed");
863 }
864
865 static void cmsis_dap_execute_sleep(struct jtag_command *cmd)
866 {
867 #if 0
868 int retval = cmsis_dap_cmd_DAP_Delay(cmd->cmd.sleep->us);
869 if (retval != ERROR_OK)
870 #endif
871 jtag_sleep(cmd->cmd.sleep->us);
872 }
873
874 static void cmsis_dap_execute_command(struct jtag_command *cmd)
875 {
876 switch (cmd->type) {
877 case JTAG_RESET:
878 cmsis_dap_execute_reset(cmd);
879 break;
880 case JTAG_SLEEP:
881 cmsis_dap_execute_sleep(cmd);
882 break;
883 default:
884 LOG_ERROR("BUG: unknown JTAG command type encountered");
885 exit(-1);
886 }
887 }
888
889 static int cmsis_dap_execute_queue(void)
890 {
891 struct jtag_command *cmd = jtag_command_queue;
892
893 while (cmd != NULL) {
894 cmsis_dap_execute_command(cmd);
895 cmd = cmd->next;
896 }
897
898 return ERROR_OK;
899 }
900
901 static int cmsis_dap_speed(int speed)
902 {
903 if (speed > DAP_MAX_CLOCK) {
904 LOG_INFO("reduce speed request: %dkHz to %dkHz maximum", speed, DAP_MAX_CLOCK);
905 speed = DAP_MAX_CLOCK;
906 }
907
908 if (speed == 0) {
909 LOG_INFO("RTCK not supported");
910 return ERROR_JTAG_NOT_IMPLEMENTED;
911 }
912
913 return cmsis_dap_cmd_DAP_SWJ_Clock(speed);
914 }
915
916 static int cmsis_dap_speed_div(int speed, int *khz)
917 {
918 *khz = speed;
919 return ERROR_OK;
920 }
921
922 static int cmsis_dap_khz(int khz, int *jtag_speed)
923 {
924 *jtag_speed = khz;
925 return ERROR_OK;
926 }
927
928 COMMAND_HANDLER(cmsis_dap_handle_info_command)
929 {
930 if (cmsis_dap_get_version_info() == ERROR_OK)
931 cmsis_dap_get_status();
932
933 return ERROR_OK;
934 }
935
936 COMMAND_HANDLER(cmsis_dap_handle_vid_pid_command)
937 {
938 if (CMD_ARGC > MAX_USB_IDS * 2) {
939 LOG_WARNING("ignoring extra IDs in cmsis_dap_vid_pid "
940 "(maximum is %d pairs)", MAX_USB_IDS);
941 CMD_ARGC = MAX_USB_IDS * 2;
942 }
943 if (CMD_ARGC < 2 || (CMD_ARGC & 1)) {
944 LOG_WARNING("incomplete cmsis_dap_vid_pid configuration directive");
945 if (CMD_ARGC < 2)
946 return ERROR_COMMAND_SYNTAX_ERROR;
947 /* remove the incomplete trailing id */
948 CMD_ARGC -= 1;
949 }
950
951 unsigned i;
952 for (i = 0; i < CMD_ARGC; i += 2) {
953 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i], cmsis_dap_vid[i >> 1]);
954 COMMAND_PARSE_NUMBER(u16, CMD_ARGV[i + 1], cmsis_dap_pid[i >> 1]);
955 }
956
957 /*
958 * Explicitly terminate, in case there are multiples instances of
959 * cmsis_dap_vid_pid.
960 */
961 cmsis_dap_vid[i >> 1] = cmsis_dap_pid[i >> 1] = 0;
962
963 return ERROR_OK;
964 }
965
966 static const struct command_registration cmsis_dap_subcommand_handlers[] = {
967 {
968 .name = "info",
969 .handler = &cmsis_dap_handle_info_command,
970 .mode = COMMAND_EXEC,
971 .usage = "",
972 .help = "show cmsis-dap info",
973 },
974 COMMAND_REGISTRATION_DONE
975 };
976
977 COMMAND_HANDLER(cmsis_dap_reset_command)
978 {
979 LOG_DEBUG("cmsis_dap_reset_command");
980 return ERROR_OK;
981 }
982
983 COMMAND_HANDLER(cmsis_dap_jtag_command)
984 {
985 LOG_DEBUG("cmsis_dap_jtag_command");
986 return ERROR_OK;
987 }
988
989 static const struct command_registration cmsis_dap_jtag_subcommand_handlers[] = {
990 {
991 .name = "init",
992 .mode = COMMAND_ANY,
993 .handler = cmsis_dap_jtag_command,
994 .usage = ""
995 },
996 {
997 .name = "arp_init",
998 .mode = COMMAND_ANY,
999 .handler = cmsis_dap_jtag_command,
1000 .usage = ""
1001 },
1002 {
1003 .name = "arp_init-reset",
1004 .mode = COMMAND_ANY,
1005 .handler = cmsis_dap_reset_command,
1006 .usage = ""
1007 },
1008 {
1009 .name = "tapisenabled",
1010 .mode = COMMAND_EXEC,
1011 .jim_handler = jim_jtag_tap_enabler,
1012 },
1013 {
1014 .name = "tapenable",
1015 .mode = COMMAND_EXEC,
1016 .jim_handler = jim_jtag_tap_enabler,
1017 },
1018 {
1019 .name = "tapdisable",
1020 .mode = COMMAND_EXEC,
1021 .handler = cmsis_dap_jtag_command,
1022 .usage = "",
1023 },
1024 {
1025 .name = "configure",
1026 .mode = COMMAND_EXEC,
1027 .handler = cmsis_dap_jtag_command,
1028 .usage = "",
1029 },
1030 {
1031 .name = "cget",
1032 .mode = COMMAND_EXEC,
1033 .jim_handler = jim_jtag_configure,
1034 },
1035 {
1036 .name = "names",
1037 .mode = COMMAND_ANY,
1038 .handler = cmsis_dap_jtag_command,
1039 .usage = "",
1040 },
1041 COMMAND_REGISTRATION_DONE
1042 };
1043
1044 static const struct command_registration cmsis_dap_command_handlers[] = {
1045 {
1046 .name = "cmsis-dap",
1047 .mode = COMMAND_ANY,
1048 .help = "perform CMSIS-DAP management",
1049 .usage = "<cmd>",
1050 .chain = cmsis_dap_subcommand_handlers,
1051 },
1052 {
1053 .name = "cmsis_dap_vid_pid",
1054 .handler = &cmsis_dap_handle_vid_pid_command,
1055 .mode = COMMAND_CONFIG,
1056 .help = "the vendor ID and product ID of the CMSIS-DAP device",
1057 .usage = "(vid pid)* ",
1058 },
1059 {
1060 /* this is currently a nasty hack so we get
1061 * reset working with non jtag interfaces */
1062 .name = "jtag",
1063 .mode = COMMAND_ANY,
1064 .usage = "",
1065 .chain = cmsis_dap_jtag_subcommand_handlers,
1066 },
1067 COMMAND_REGISTRATION_DONE
1068 };
1069
1070 static const struct swd_driver cmsis_dap_swd_driver = {
1071 .init = cmsis_dap_swd_init,
1072 .read_reg = cmsis_dap_swd_read_reg,
1073 .write_reg = cmsis_dap_swd_write_reg,
1074 .read_block = cmsis_dap_swd_read_block
1075 };
1076
1077 const char *cmsis_dap_transport[] = {"cmsis-dap", NULL};
1078
1079 struct jtag_interface cmsis_dap_interface = {
1080 .name = "cmsis-dap",
1081 .commands = cmsis_dap_command_handlers,
1082 .swd = &cmsis_dap_swd_driver,
1083 .transports = cmsis_dap_transport,
1084
1085 .execute_queue = cmsis_dap_execute_queue,
1086 .speed = cmsis_dap_speed,
1087 .speed_div = cmsis_dap_speed_div,
1088 .khz = cmsis_dap_khz,
1089 .init = cmsis_dap_init,
1090 .quit = cmsis_dap_quit,
1091 };
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)