Code Review / openocd.git / blob
? search:


72b31c96a6e65a7a0bc1fed6b7ba6e4dd5eb34ee
[openocd.git] / src / jtag / drivers / stlink_usb.c
1 /***************************************************************************
2 * Copyright (C) 2011-2012 by Mathias Kuester *
3 * Mathias Kuester <kesmtp@freenet.de> *
4 * *
5 * Copyright (C) 2012 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
7 * *
8 * This code is based on https://github.com/texane/stlink *
9 * *
10 * This program is free software; you can redistribute it and/or modify *
11 * it under the terms of the GNU General Public License as published by *
12 * the Free Software Foundation; either version 2 of the License, or *
13 * (at your option) any later version. *
14 * *
15 * This program is distributed in the hope that it will be useful, *
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
18 * GNU General Public License for more details. *
19 * *
20 * You should have received a copy of the GNU General Public License *
21 * along with this program; if not, write to the *
22 * Free Software Foundation, Inc., *
23 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
24 ***************************************************************************/
25
26 #ifdef HAVE_CONFIG_H
27 #include "config.h"
28 #endif
29
30 /* project specific includes */
31 #include <helper/binarybuffer.h>
32 #include <jtag/interface.h>
33 #include <jtag/hla/hla_layout.h>
34 #include <jtag/hla/hla_transport.h>
35 #include <jtag/hla/hla_interface.h>
36 #include <target/target.h>
37
38 #include <target/cortex_m.h>
39
40 #include "libusb_common.h"
41
42 #define ENDPOINT_IN 0x80
43 #define ENDPOINT_OUT 0x00
44
45 #define STLINK_NULL_EP 0
46 #define STLINK_RX_EP (1|ENDPOINT_IN)
47 #define STLINK_TX_EP (2|ENDPOINT_OUT)
48 #define STLINK_SG_SIZE (31)
49 #define STLINK_DATA_SIZE (4*128)
50 #define STLINK_CMD_SIZE_V2 (16)
51 #define STLINK_CMD_SIZE_V1 (10)
52
53 enum stlink_jtag_api_version {
54 STLINK_JTAG_API_V1 = 1,
55 STLINK_JTAG_API_V2,
56 };
57
58 /** */
59 struct stlink_usb_version {
60 /** */
61 int stlink;
62 /** */
63 int jtag;
64 /** */
65 int swim;
66 /** highest supported jtag api version */
67 enum stlink_jtag_api_version jtag_api_max;
68 };
69
70 /** */
71 struct stlink_usb_handle_s {
72 /** */
73 struct jtag_libusb_device_handle *fd;
74 /** */
75 struct libusb_transfer *trans;
76 /** */
77 uint8_t cmdbuf[STLINK_SG_SIZE];
78 /** */
79 uint8_t cmdidx;
80 /** */
81 uint8_t direction;
82 /** */
83 uint8_t databuf[STLINK_DATA_SIZE];
84 /** */
85 enum hl_transports transport;
86 /** */
87 struct stlink_usb_version version;
88 /** */
89 uint16_t vid;
90 /** */
91 uint16_t pid;
92 /** this is the currently used jtag api */
93 enum stlink_jtag_api_version jtag_api;
94 };
95
96 #define STLINK_DEBUG_ERR_OK 0x80
97 #define STLINK_DEBUG_ERR_FAULT 0x81
98 #define STLINK_SWD_AP_WAIT 0x10
99 #define STLINK_SWD_DP_WAIT 0x14
100
101 #define STLINK_CORE_RUNNING 0x80
102 #define STLINK_CORE_HALTED 0x81
103 #define STLINK_CORE_STAT_UNKNOWN -1
104
105 #define STLINK_GET_VERSION 0xF1
106 #define STLINK_DEBUG_COMMAND 0xF2
107 #define STLINK_DFU_COMMAND 0xF3
108 #define STLINK_SWIM_COMMAND 0xF4
109 #define STLINK_GET_CURRENT_MODE 0xF5
110 #define STLINK_GET_TARGET_VOLTAGE 0xF7
111
112 #define STLINK_DEV_DFU_MODE 0x00
113 #define STLINK_DEV_MASS_MODE 0x01
114 #define STLINK_DEV_DEBUG_MODE 0x02
115 #define STLINK_DEV_SWIM_MODE 0x03
116 #define STLINK_DEV_BOOTLOADER_MODE 0x04
117 #define STLINK_DEV_UNKNOWN_MODE -1
118
119 #define STLINK_DFU_EXIT 0x07
120
121 #define STLINK_SWIM_ENTER 0x00
122 #define STLINK_SWIM_EXIT 0x01
123
124 #define STLINK_DEBUG_ENTER_JTAG 0x00
125 #define STLINK_DEBUG_GETSTATUS 0x01
126 #define STLINK_DEBUG_FORCEDEBUG 0x02
127 #define STLINK_DEBUG_APIV1_RESETSYS 0x03
128 #define STLINK_DEBUG_APIV1_READALLREGS 0x04
129 #define STLINK_DEBUG_APIV1_READREG 0x05
130 #define STLINK_DEBUG_APIV1_WRITEREG 0x06
131 #define STLINK_DEBUG_READMEM_32BIT 0x07
132 #define STLINK_DEBUG_WRITEMEM_32BIT 0x08
133 #define STLINK_DEBUG_RUNCORE 0x09
134 #define STLINK_DEBUG_STEPCORE 0x0a
135 #define STLINK_DEBUG_APIV1_SETFP 0x0b
136 #define STLINK_DEBUG_READMEM_8BIT 0x0c
137 #define STLINK_DEBUG_WRITEMEM_8BIT 0x0d
138 #define STLINK_DEBUG_APIV1_CLEARFP 0x0e
139 #define STLINK_DEBUG_APIV1_WRITEDEBUGREG 0x0f
140 #define STLINK_DEBUG_APIV1_SETWATCHPOINT 0x10
141
142 #define STLINK_DEBUG_ENTER_JTAG 0x00
143 #define STLINK_DEBUG_ENTER_SWD 0xa3
144
145 #define STLINK_DEBUG_APIV1_ENTER 0x20
146 #define STLINK_DEBUG_EXIT 0x21
147 #define STLINK_DEBUG_READCOREID 0x22
148
149 #define STLINK_DEBUG_APIV2_ENTER 0x30
150 #define STLINK_DEBUG_APIV2_READ_IDCODES 0x31
151 #define STLINK_DEBUG_APIV2_RESETSYS 0x32
152 #define STLINK_DEBUG_APIV2_READREG 0x33
153 #define STLINK_DEBUG_APIV2_WRITEREG 0x34
154 #define STLINK_DEBUG_APIV2_WRITEDEBUGREG 0x35
155 #define STLINK_DEBUG_APIV2_READDEBUGREG 0x36
156
157 #define STLINK_DEBUG_APIV2_READALLREGS 0x3A
158 #define STLINK_DEBUG_APIV2_GETLASTRWSTATUS 0x3B
159 #define STLINK_DEBUG_APIV2_DRIVE_NRST 0x3C
160
161 #define STLINK_DEBUG_APIV2_DRIVE_NRST_LOW 0x00
162 #define STLINK_DEBUG_APIV2_DRIVE_NRST_HIGH 0x01
163 #define STLINK_DEBUG_APIV2_DRIVE_NRST_PULSE 0x02
164
165 /** */
166 enum stlink_mode {
167 STLINK_MODE_UNKNOWN = 0,
168 STLINK_MODE_DFU,
169 STLINK_MODE_MASS,
170 STLINK_MODE_DEBUG_JTAG,
171 STLINK_MODE_DEBUG_SWD,
172 STLINK_MODE_DEBUG_SWIM
173 };
174
175 #define REQUEST_SENSE 0x03
176 #define REQUEST_SENSE_LENGTH 18
177
178 static void stlink_usb_init_buffer(void *handle, uint8_t direction, uint32_t size);
179
180 /** */
181 static int stlink_usb_xfer_v1_get_status(void *handle)
182 {
183 struct stlink_usb_handle_s *h;
184
185 assert(handle != NULL);
186
187 h = (struct stlink_usb_handle_s *)handle;
188
189 /* read status */
190 memset(h->cmdbuf, 0, STLINK_SG_SIZE);
191
192 if (jtag_libusb_bulk_read(h->fd, STLINK_RX_EP, (char *)h->cmdbuf,
193 13, 1000) != 13)
194 return ERROR_FAIL;
195
196 uint32_t t1;
197
198 t1 = buf_get_u32(h->cmdbuf, 0, 32);
199
200 /* check for USBS */
201 if (t1 != 0x53425355)
202 return ERROR_FAIL;
203 /*
204 * CSW status:
205 * 0 success
206 * 1 command failure
207 * 2 phase error
208 */
209 if (h->cmdbuf[12] != 0)
210 return ERROR_FAIL;
211
212 return ERROR_OK;
213 }
214
215 /** */
216 static int stlink_usb_xfer_rw(void *handle, int cmdsize, const uint8_t *buf, int size)
217 {
218 struct stlink_usb_handle_s *h;
219
220 assert(handle != NULL);
221
222 h = (struct stlink_usb_handle_s *)handle;
223
224 if (jtag_libusb_bulk_write(h->fd, STLINK_TX_EP, (char *)h->cmdbuf, cmdsize,
225 1000) != cmdsize) {
226 return ERROR_FAIL;
227 }
228
229 if (h->direction == STLINK_TX_EP && size) {
230 if (jtag_libusb_bulk_write(h->fd, STLINK_TX_EP, (char *)buf,
231 size, 1000) != size) {
232 LOG_DEBUG("bulk write failed");
233 return ERROR_FAIL;
234 }
235 } else if (h->direction == STLINK_RX_EP && size) {
236 if (jtag_libusb_bulk_read(h->fd, STLINK_RX_EP, (char *)buf,
237 size, 1000) != size) {
238 LOG_DEBUG("bulk read failed");
239 return ERROR_FAIL;
240 }
241 }
242
243 return ERROR_OK;
244 }
245
246 /** */
247 static int stlink_usb_xfer_v1_get_sense(void *handle)
248 {
249 int res;
250 struct stlink_usb_handle_s *h;
251
252 assert(handle != NULL);
253
254 h = (struct stlink_usb_handle_s *)handle;
255
256 stlink_usb_init_buffer(handle, STLINK_RX_EP, 16);
257
258 h->cmdbuf[h->cmdidx++] = REQUEST_SENSE;
259 h->cmdbuf[h->cmdidx++] = 0;
260 h->cmdbuf[h->cmdidx++] = 0;
261 h->cmdbuf[h->cmdidx++] = 0;
262 h->cmdbuf[h->cmdidx++] = REQUEST_SENSE_LENGTH;
263
264 res = stlink_usb_xfer_rw(handle, REQUEST_SENSE_LENGTH, h->databuf, 16);
265
266 if (res != ERROR_OK)
267 return res;
268
269 if (stlink_usb_xfer_v1_get_status(handle) != ERROR_OK)
270 return ERROR_FAIL;
271
272 return ERROR_OK;
273 }
274
275 /** */
276 static int stlink_usb_xfer(void *handle, const uint8_t *buf, int size)
277 {
278 int err, cmdsize = STLINK_CMD_SIZE_V2;
279 struct stlink_usb_handle_s *h;
280
281 assert(handle != NULL);
282
283 h = (struct stlink_usb_handle_s *)handle;
284
285 if (h->version.stlink == 1)
286 cmdsize = STLINK_SG_SIZE;
287
288 err = stlink_usb_xfer_rw(handle, cmdsize, buf, size);
289
290 if (err != ERROR_OK)
291 return err;
292
293 if (h->version.stlink == 1) {
294 if (stlink_usb_xfer_v1_get_status(handle) != ERROR_OK) {
295 /* check csw status */
296 if (h->cmdbuf[12] == 1) {
297 LOG_DEBUG("get sense");
298 if (stlink_usb_xfer_v1_get_sense(handle) != ERROR_OK)
299 return ERROR_FAIL;
300 }
301 return ERROR_FAIL;
302 }
303 }
304
305 return ERROR_OK;
306 }
307
308 /** */
309 static void stlink_usb_xfer_v1_create_cmd(void *handle, uint8_t direction, uint32_t size)
310 {
311 struct stlink_usb_handle_s *h;
312
313 h = (struct stlink_usb_handle_s *)handle;
314
315 /* fill the send buffer */
316 strcpy((char *)h->cmdbuf, "USBC");
317 h->cmdidx += 4;
318 /* csw tag not used */
319 h->cmdidx += 4;
320 buf_set_u32(h->cmdbuf+h->cmdidx, 0, 32, size);
321 h->cmdidx += 4;
322 h->cmdbuf[h->cmdidx++] = (direction == STLINK_RX_EP ? ENDPOINT_IN : ENDPOINT_OUT);
323 h->cmdbuf[h->cmdidx++] = 0; /* lun */
324 h->cmdbuf[h->cmdidx++] = STLINK_CMD_SIZE_V1;
325 }
326
327 /** */
328 static void stlink_usb_init_buffer(void *handle, uint8_t direction, uint32_t size)
329 {
330 struct stlink_usb_handle_s *h;
331
332 h = (struct stlink_usb_handle_s *)handle;
333
334 h->direction = direction;
335
336 h->cmdidx = 0;
337
338 memset(h->cmdbuf, 0, STLINK_SG_SIZE);
339 memset(h->databuf, 0, STLINK_DATA_SIZE);
340
341 if (h->version.stlink == 1)
342 stlink_usb_xfer_v1_create_cmd(handle, direction, size);
343 }
344
345 static const char * const stlink_usb_error_msg[] = {
346 "unknown"
347 };
348
349 /** */
350 static int stlink_usb_error_check(void *handle)
351 {
352 int res;
353 const char *err_msg = 0;
354 struct stlink_usb_handle_s *h;
355
356 assert(handle != NULL);
357
358 h = (struct stlink_usb_handle_s *)handle;
359
360 /* TODO: no error checking yet on api V1 */
361 if (h->jtag_api == STLINK_JTAG_API_V1)
362 h->databuf[0] = STLINK_DEBUG_ERR_OK;
363
364 switch (h->databuf[0]) {
365 case STLINK_DEBUG_ERR_OK:
366 res = ERROR_OK;
367 break;
368 case STLINK_DEBUG_ERR_FAULT:
369 default:
370 err_msg = stlink_usb_error_msg[0];
371 res = ERROR_FAIL;
372 break;
373 }
374
375 if (res != ERROR_OK)
376 LOG_DEBUG("status error: %d ('%s')", h->databuf[0], err_msg);
377
378 return res;
379 }
380
381 /** */
382 static int stlink_usb_version(void *handle)
383 {
384 int res;
385 uint16_t v;
386 struct stlink_usb_handle_s *h;
387
388 assert(handle != NULL);
389
390 h = (struct stlink_usb_handle_s *)handle;
391
392 stlink_usb_init_buffer(handle, STLINK_RX_EP, 6);
393
394 h->cmdbuf[h->cmdidx++] = STLINK_GET_VERSION;
395
396 res = stlink_usb_xfer(handle, h->databuf, 6);
397
398 if (res != ERROR_OK)
399 return res;
400
401 v = (h->databuf[0] << 8) | h->databuf[1];
402
403 h->version.stlink = (v >> 12) & 0x0f;
404 h->version.jtag = (v >> 6) & 0x3f;
405 h->version.swim = v & 0x3f;
406 h->vid = buf_get_u32(h->databuf, 16, 16);
407 h->pid = buf_get_u32(h->databuf, 32, 16);
408
409 /* set the supported jtag api version
410 * API V2 is supported since JTAG V11
411 */
412 if (h->version.jtag >= 11)
413 h->version.jtag_api_max = STLINK_JTAG_API_V2;
414 else
415 h->version.jtag_api_max = STLINK_JTAG_API_V1;
416
417 LOG_INFO("STLINK v%d JTAG v%d API v%d SWIM v%d VID 0x%04X PID 0x%04X",
418 h->version.stlink,
419 h->version.jtag,
420 (h->version.jtag_api_max == STLINK_JTAG_API_V1) ? 1 : 2,
421 h->version.swim,
422 h->vid,
423 h->pid);
424
425 return ERROR_OK;
426 }
427
428 static int stlink_usb_check_voltage(void *handle, float *target_voltage)
429 {
430 struct stlink_usb_handle_s *h;
431 uint32_t adc_results[2];
432
433 h = (struct stlink_usb_handle_s *)handle;
434
435 /* only supported by stlink/v2 and for firmware >= 13 */
436 if (h->version.stlink == 1 || h->version.jtag < 13)
437 return ERROR_COMMAND_NOTFOUND;
438
439 stlink_usb_init_buffer(handle, STLINK_RX_EP, 8);
440
441 h->cmdbuf[h->cmdidx++] = STLINK_GET_TARGET_VOLTAGE;
442
443 int result = stlink_usb_xfer(handle, h->databuf, 8);
444
445 if (result != ERROR_OK)
446 return result;
447
448 /* convert result */
449 adc_results[0] = le_to_h_u32(h->databuf);
450 adc_results[1] = le_to_h_u32(h->databuf + 4);
451
452 *target_voltage = 0;
453
454 if (adc_results[0])
455 *target_voltage = 2 * ((float)adc_results[1]) * (float)(1.2 / adc_results[0]);
456
457 LOG_INFO("Target voltage: %f", (double)*target_voltage);
458
459 return ERROR_OK;
460 }
461
462 /** */
463 static int stlink_usb_current_mode(void *handle, uint8_t *mode)
464 {
465 int res;
466 struct stlink_usb_handle_s *h;
467
468 assert(handle != NULL);
469
470 h = (struct stlink_usb_handle_s *)handle;
471
472 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
473
474 h->cmdbuf[h->cmdidx++] = STLINK_GET_CURRENT_MODE;
475
476 res = stlink_usb_xfer(handle, h->databuf, 2);
477
478 if (res != ERROR_OK)
479 return res;
480
481 *mode = h->databuf[0];
482
483 return ERROR_OK;
484 }
485
486 /** */
487 static int stlink_usb_mode_enter(void *handle, enum stlink_mode type)
488 {
489 int res;
490 int rx_size = 0;
491 struct stlink_usb_handle_s *h;
492
493 assert(handle != NULL);
494
495 h = (struct stlink_usb_handle_s *)handle;
496
497 /* on api V2 we are able the read the latest command
498 * status
499 * TODO: we need the test on api V1 too
500 */
501 if (h->jtag_api == STLINK_JTAG_API_V2)
502 rx_size = 2;
503
504 stlink_usb_init_buffer(handle, STLINK_RX_EP, rx_size);
505
506 switch (type) {
507 case STLINK_MODE_DEBUG_JTAG:
508 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
509 if (h->jtag_api == STLINK_JTAG_API_V1)
510 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_ENTER;
511 else
512 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_ENTER;
513 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_ENTER_JTAG;
514 break;
515 case STLINK_MODE_DEBUG_SWD:
516 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
517 if (h->jtag_api == STLINK_JTAG_API_V1)
518 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_ENTER;
519 else
520 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_ENTER;
521 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_ENTER_SWD;
522 break;
523 case STLINK_MODE_DEBUG_SWIM:
524 h->cmdbuf[h->cmdidx++] = STLINK_SWIM_COMMAND;
525 h->cmdbuf[h->cmdidx++] = STLINK_SWIM_ENTER;
526 break;
527 case STLINK_MODE_DFU:
528 case STLINK_MODE_MASS:
529 default:
530 return ERROR_FAIL;
531 }
532
533 res = stlink_usb_xfer(handle, h->databuf, rx_size);
534
535 if (res != ERROR_OK)
536 return res;
537
538 res = stlink_usb_error_check(h);
539
540 return res;
541 }
542
543 /** */
544 static int stlink_usb_mode_leave(void *handle, enum stlink_mode type)
545 {
546 int res;
547 struct stlink_usb_handle_s *h;
548
549 assert(handle != NULL);
550
551 h = (struct stlink_usb_handle_s *)handle;
552
553 stlink_usb_init_buffer(handle, STLINK_NULL_EP, 0);
554
555 switch (type) {
556 case STLINK_MODE_DEBUG_JTAG:
557 case STLINK_MODE_DEBUG_SWD:
558 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
559 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_EXIT;
560 break;
561 case STLINK_MODE_DEBUG_SWIM:
562 h->cmdbuf[h->cmdidx++] = STLINK_SWIM_COMMAND;
563 h->cmdbuf[h->cmdidx++] = STLINK_SWIM_EXIT;
564 break;
565 case STLINK_MODE_DFU:
566 h->cmdbuf[h->cmdidx++] = STLINK_DFU_COMMAND;
567 h->cmdbuf[h->cmdidx++] = STLINK_DFU_EXIT;
568 break;
569 case STLINK_MODE_MASS:
570 default:
571 return ERROR_FAIL;
572 }
573
574 res = stlink_usb_xfer(handle, 0, 0);
575
576 if (res != ERROR_OK)
577 return res;
578
579 return ERROR_OK;
580 }
581
582 static int stlink_usb_assert_srst(void *handle, int srst);
583
584 /** */
585 static int stlink_usb_init_mode(void *handle, bool connect_under_reset)
586 {
587 int res;
588 uint8_t mode;
589 enum stlink_mode emode;
590 struct stlink_usb_handle_s *h;
591
592 assert(handle != NULL);
593
594 h = (struct stlink_usb_handle_s *)handle;
595
596 res = stlink_usb_current_mode(handle, &mode);
597
598 if (res != ERROR_OK)
599 return res;
600
601 LOG_DEBUG("MODE: 0x%02X", mode);
602
603 /* try to exit current mode */
604 switch (mode) {
605 case STLINK_DEV_DFU_MODE:
606 emode = STLINK_MODE_DFU;
607 break;
608 case STLINK_DEV_DEBUG_MODE:
609 emode = STLINK_MODE_DEBUG_SWD;
610 break;
611 case STLINK_DEV_SWIM_MODE:
612 emode = STLINK_MODE_DEBUG_SWIM;
613 break;
614 case STLINK_DEV_BOOTLOADER_MODE:
615 case STLINK_DEV_MASS_MODE:
616 default:
617 emode = STLINK_MODE_UNKNOWN;
618 break;
619 }
620
621 if (emode != STLINK_MODE_UNKNOWN) {
622 res = stlink_usb_mode_leave(handle, emode);
623
624 if (res != ERROR_OK)
625 return res;
626 }
627
628 res = stlink_usb_current_mode(handle, &mode);
629
630 if (res != ERROR_OK)
631 return res;
632
633 /* we check the target voltage here as an aid to debugging connection problems.
634 * the stlink requires the target Vdd to be connected for reliable debugging.
635 * this cmd is supported in all modes except DFU
636 */
637 if (mode != STLINK_DEV_DFU_MODE) {
638
639 float target_voltage;
640
641 /* check target voltage (if supported) */
642 res = stlink_usb_check_voltage(h, &target_voltage);
643
644 if (res != ERROR_OK) {
645 if (res != ERROR_COMMAND_NOTFOUND)
646 LOG_ERROR("voltage check failed");
647 /* attempt to continue as it is not a catastrophic failure */
648 } else {
649 /* check for a sensible target voltage, operating range is 1.65-5.5v
650 * according to datasheet */
651 if (target_voltage < 1.5)
652 LOG_ERROR("target voltage may be too low for reliable debugging");
653 }
654 }
655
656 LOG_DEBUG("MODE: 0x%02X", mode);
657
658 /* set selected mode */
659 switch (h->transport) {
660 case HL_TRANSPORT_SWD:
661 emode = STLINK_MODE_DEBUG_SWD;
662 break;
663 case HL_TRANSPORT_JTAG:
664 emode = STLINK_MODE_DEBUG_JTAG;
665 break;
666 case HL_TRANSPORT_SWIM:
667 emode = STLINK_MODE_DEBUG_SWIM;
668 break;
669 default:
670 emode = STLINK_MODE_UNKNOWN;
671 break;
672 }
673
674 if (emode == STLINK_MODE_UNKNOWN) {
675 LOG_ERROR("selected mode (transport) not supported");
676 return ERROR_FAIL;
677 }
678
679 if (connect_under_reset) {
680 res = stlink_usb_assert_srst(handle, 0);
681 if (res != ERROR_OK)
682 return res;
683 }
684
685 res = stlink_usb_mode_enter(handle, emode);
686
687 if (res != ERROR_OK)
688 return res;
689
690 res = stlink_usb_current_mode(handle, &mode);
691
692 if (res != ERROR_OK)
693 return res;
694
695 LOG_DEBUG("MODE: 0x%02X", mode);
696
697 return ERROR_OK;
698 }
699
700 /** */
701 static int stlink_usb_idcode(void *handle, uint32_t *idcode)
702 {
703 int res;
704 struct stlink_usb_handle_s *h;
705
706 assert(handle != NULL);
707
708 h = (struct stlink_usb_handle_s *)handle;
709
710 stlink_usb_init_buffer(handle, STLINK_RX_EP, 4);
711
712 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
713 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_READCOREID;
714
715 res = stlink_usb_xfer(handle, h->databuf, 4);
716
717 if (res != ERROR_OK)
718 return res;
719
720 *idcode = le_to_h_u32(h->databuf);
721
722 LOG_DEBUG("IDCODE: 0x%08X", *idcode);
723
724 return ERROR_OK;
725 }
726
727 static int stlink_usb_v2_read_debug_reg(void *handle, uint32_t addr, uint32_t *val)
728 {
729 struct stlink_usb_handle_s *h;
730 int res;
731
732 assert(handle != NULL);
733
734 h = (struct stlink_usb_handle_s *)handle;
735
736 stlink_usb_init_buffer(handle, STLINK_RX_EP, 8);
737
738 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
739 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_READDEBUGREG;
740 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
741 h->cmdidx += 4;
742
743 res = stlink_usb_xfer(handle, h->databuf, 8);
744
745 if (res != ERROR_OK)
746 return res;
747
748 *val = le_to_h_u32(h->databuf + 4);
749
750 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
751 }
752
753 static int stlink_usb_write_debug_reg(void *handle, uint32_t addr, uint32_t val)
754 {
755 int res;
756 struct stlink_usb_handle_s *h;
757
758 assert(handle != NULL);
759
760 h = (struct stlink_usb_handle_s *)handle;
761
762 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
763
764 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
765 if (h->jtag_api == STLINK_JTAG_API_V1)
766 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_WRITEDEBUGREG;
767 else
768 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_WRITEDEBUGREG;
769 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
770 h->cmdidx += 4;
771 h_u32_to_le(h->cmdbuf+h->cmdidx, val);
772 h->cmdidx += 4;
773
774 res = stlink_usb_xfer(handle, h->databuf, 2);
775
776 if (res != ERROR_OK)
777 return res;
778
779 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
780 }
781
782 static enum target_state stlink_usb_v2_get_status(void *handle)
783 {
784 int result;
785 uint32_t status;
786
787 result = stlink_usb_v2_read_debug_reg(handle, DCB_DHCSR, &status);
788 if (result != ERROR_OK)
789 return TARGET_UNKNOWN;
790
791 if (status & S_HALT)
792 return TARGET_HALTED;
793 else if (status & S_RESET_ST)
794 return TARGET_RESET;
795
796 return TARGET_RUNNING;
797 }
798
799 /** */
800 static enum target_state stlink_usb_state(void *handle)
801 {
802 int res;
803 struct stlink_usb_handle_s *h;
804
805 assert(handle != NULL);
806
807 h = (struct stlink_usb_handle_s *)handle;
808
809 if (h->jtag_api == STLINK_JTAG_API_V2)
810 return stlink_usb_v2_get_status(handle);
811
812 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
813
814 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
815 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_GETSTATUS;
816
817 res = stlink_usb_xfer(handle, h->databuf, 2);
818
819 if (res != ERROR_OK)
820 return TARGET_UNKNOWN;
821
822 if (h->databuf[0] == STLINK_CORE_RUNNING)
823 return TARGET_RUNNING;
824 if (h->databuf[0] == STLINK_CORE_HALTED)
825 return TARGET_HALTED;
826
827 return TARGET_UNKNOWN;
828 }
829
830 /** */
831 static int stlink_usb_reset(void *handle)
832 {
833 int res;
834 struct stlink_usb_handle_s *h;
835
836 assert(handle != NULL);
837
838 h = (struct stlink_usb_handle_s *)handle;
839
840 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
841
842 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
843
844 if (h->jtag_api == STLINK_JTAG_API_V1)
845 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_RESETSYS;
846 else
847 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_RESETSYS;
848
849 res = stlink_usb_xfer(handle, h->databuf, 2);
850
851 if (res != ERROR_OK)
852 return res;
853
854 LOG_DEBUG("RESET: 0x%08X", h->databuf[0]);
855
856 /* the following is not a error under swd (using hardware srst), so return success */
857 if (h->databuf[0] == STLINK_SWD_AP_WAIT || h->databuf[0] == STLINK_SWD_DP_WAIT)
858 return ERROR_OK;
859
860 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
861 }
862
863 static int stlink_usb_assert_srst(void *handle, int srst)
864 {
865 int res;
866 struct stlink_usb_handle_s *h;
867
868 assert(handle != NULL);
869
870 h = (struct stlink_usb_handle_s *)handle;
871
872 if (h->jtag_api == STLINK_JTAG_API_V1)
873 return ERROR_COMMAND_NOTFOUND;
874
875 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
876
877 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
878 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_DRIVE_NRST;
879 h->cmdbuf[h->cmdidx++] = srst;
880
881 res = stlink_usb_xfer(handle, h->databuf, 2);
882
883 if (res != ERROR_OK)
884 return res;
885
886 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
887 }
888
889 /** */
890 static int stlink_usb_run(void *handle)
891 {
892 int res;
893 struct stlink_usb_handle_s *h;
894
895 assert(handle != NULL);
896
897 h = (struct stlink_usb_handle_s *)handle;
898
899 if (h->jtag_api == STLINK_JTAG_API_V2)
900 return stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_DEBUGEN);
901
902 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
903
904 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
905 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_RUNCORE;
906
907 res = stlink_usb_xfer(handle, h->databuf, 2);
908
909 if (res != ERROR_OK)
910 return res;
911
912 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
913 }
914
915 /** */
916 static int stlink_usb_halt(void *handle)
917 {
918 int res;
919 struct stlink_usb_handle_s *h;
920
921 assert(handle != NULL);
922
923 h = (struct stlink_usb_handle_s *)handle;
924
925 if (h->jtag_api == STLINK_JTAG_API_V2)
926 return stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_HALT|C_DEBUGEN);
927
928 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
929
930 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
931 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_FORCEDEBUG;
932
933 res = stlink_usb_xfer(handle, h->databuf, 2);
934
935 if (res != ERROR_OK)
936 return res;
937
938 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
939 }
940
941 /** */
942 static int stlink_usb_step(void *handle)
943 {
944 int res;
945 struct stlink_usb_handle_s *h;
946
947 assert(handle != NULL);
948
949 h = (struct stlink_usb_handle_s *)handle;
950
951 if (h->jtag_api == STLINK_JTAG_API_V2) {
952 /* TODO: this emulates the v1 api, it should really use a similar auto mask isr
953 * that the cortex-m3 currently does. */
954 stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_HALT|C_MASKINTS|C_DEBUGEN);
955 stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_STEP|C_MASKINTS|C_DEBUGEN);
956 return stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_HALT|C_DEBUGEN);
957 }
958
959 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
960
961 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
962 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_STEPCORE;
963
964 res = stlink_usb_xfer(handle, h->databuf, 2);
965
966 if (res != ERROR_OK)
967 return res;
968
969 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
970 }
971
972 /** */
973 static int stlink_usb_read_regs(void *handle)
974 {
975 int res;
976 struct stlink_usb_handle_s *h;
977
978 assert(handle != NULL);
979
980 h = (struct stlink_usb_handle_s *)handle;
981
982 stlink_usb_init_buffer(handle, STLINK_RX_EP, 84);
983
984 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
985 if (h->jtag_api == STLINK_JTAG_API_V1)
986 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_READALLREGS;
987 else
988 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_READALLREGS;
989
990 res = stlink_usb_xfer(handle, h->databuf, 84);
991
992 if (res != ERROR_OK)
993 return res;
994
995 return ERROR_OK;
996 }
997
998 /** */
999 static int stlink_usb_read_reg(void *handle, int num, uint32_t *val)
1000 {
1001 int res;
1002 struct stlink_usb_handle_s *h;
1003
1004 assert(handle != NULL);
1005
1006 h = (struct stlink_usb_handle_s *)handle;
1007
1008 stlink_usb_init_buffer(handle, STLINK_RX_EP, h->jtag_api == STLINK_JTAG_API_V1 ? 4 : 8);
1009
1010 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1011 if (h->jtag_api == STLINK_JTAG_API_V1)
1012 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_READREG;
1013 else
1014 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_READREG;
1015 h->cmdbuf[h->cmdidx++] = num;
1016
1017 res = stlink_usb_xfer(handle, h->databuf, h->jtag_api == STLINK_JTAG_API_V1 ? 4 : 8);
1018
1019 if (res != ERROR_OK)
1020 return res;
1021
1022 if (h->jtag_api == STLINK_JTAG_API_V1)
1023 *val = le_to_h_u32(h->databuf);
1024 else {
1025 *val = le_to_h_u32(h->databuf + 4);
1026 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
1027 }
1028
1029 return ERROR_OK;
1030 }
1031
1032 /** */
1033 static int stlink_usb_write_reg(void *handle, int num, uint32_t val)
1034 {
1035 int res;
1036 struct stlink_usb_handle_s *h;
1037
1038 assert(handle != NULL);
1039
1040 h = (struct stlink_usb_handle_s *)handle;
1041
1042 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
1043
1044 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1045 if (h->jtag_api == STLINK_JTAG_API_V1)
1046 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_WRITEREG;
1047 else
1048 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_WRITEREG;
1049 h->cmdbuf[h->cmdidx++] = num;
1050 h_u32_to_le(h->cmdbuf+h->cmdidx, val);
1051 h->cmdidx += 4;
1052
1053 res = stlink_usb_xfer(handle, h->databuf, 2);
1054
1055 if (res != ERROR_OK)
1056 return res;
1057
1058 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
1059 }
1060
1061 static int stlink_usb_get_rw_status(void *handle)
1062 {
1063 int res;
1064 struct stlink_usb_handle_s *h;
1065
1066 assert(handle != NULL);
1067
1068 h = (struct stlink_usb_handle_s *)handle;
1069
1070 if (h->jtag_api == STLINK_JTAG_API_V1)
1071 return ERROR_OK;
1072
1073 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
1074
1075 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1076 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_GETLASTRWSTATUS;
1077
1078 res = stlink_usb_xfer(handle, h->databuf, 2);
1079
1080 if (res != ERROR_OK)
1081 return res;
1082
1083 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : res;
1084 }
1085
1086 /** */
1087 static int stlink_usb_read_mem8(void *handle, uint32_t addr, uint16_t len,
1088 uint8_t *buffer)
1089 {
1090 int res;
1091 uint16_t read_len = len;
1092 struct stlink_usb_handle_s *h;
1093
1094 assert(handle != NULL);
1095
1096 h = (struct stlink_usb_handle_s *)handle;
1097
1098 stlink_usb_init_buffer(handle, STLINK_RX_EP, read_len);
1099
1100 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1101 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_READMEM_8BIT;
1102 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
1103 h->cmdidx += 4;
1104 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
1105 h->cmdidx += 2;
1106
1107 /* we need to fix read length for single bytes */
1108 if (read_len == 1)
1109 read_len++;
1110
1111 res = stlink_usb_xfer(handle, h->databuf, read_len);
1112
1113 if (res != ERROR_OK)
1114 return res;
1115
1116 memcpy(buffer, h->databuf, len);
1117
1118 return stlink_usb_get_rw_status(handle);
1119 }
1120
1121 /** */
1122 static int stlink_usb_write_mem8(void *handle, uint32_t addr, uint16_t len,
1123 const uint8_t *buffer)
1124 {
1125 int res;
1126 struct stlink_usb_handle_s *h;
1127
1128 assert(handle != NULL);
1129
1130 h = (struct stlink_usb_handle_s *)handle;
1131
1132 stlink_usb_init_buffer(handle, STLINK_TX_EP, len);
1133
1134 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1135 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_WRITEMEM_8BIT;
1136 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
1137 h->cmdidx += 4;
1138 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
1139 h->cmdidx += 2;
1140
1141 res = stlink_usb_xfer(handle, buffer, len);
1142
1143 if (res != ERROR_OK)
1144 return res;
1145
1146 return stlink_usb_get_rw_status(handle);
1147 }
1148
1149 /** */
1150 static int stlink_usb_read_mem32(void *handle, uint32_t addr, uint16_t len,
1151 uint8_t *buffer)
1152 {
1153 int res;
1154 struct stlink_usb_handle_s *h;
1155
1156 assert(handle != NULL);
1157
1158 h = (struct stlink_usb_handle_s *)handle;
1159
1160 len *= 4;
1161
1162 stlink_usb_init_buffer(handle, STLINK_RX_EP, len);
1163
1164 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1165 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_READMEM_32BIT;
1166 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
1167 h->cmdidx += 4;
1168 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
1169 h->cmdidx += 2;
1170
1171 res = stlink_usb_xfer(handle, h->databuf, len);
1172
1173 if (res != ERROR_OK)
1174 return res;
1175
1176 memcpy(buffer, h->databuf, len);
1177
1178 return stlink_usb_get_rw_status(handle);
1179 }
1180
1181 /** */
1182 static int stlink_usb_write_mem32(void *handle, uint32_t addr, uint16_t len,
1183 const uint8_t *buffer)
1184 {
1185 int res;
1186 struct stlink_usb_handle_s *h;
1187
1188 assert(handle != NULL);
1189
1190 h = (struct stlink_usb_handle_s *)handle;
1191
1192 len *= 4;
1193
1194 stlink_usb_init_buffer(handle, STLINK_TX_EP, len);
1195
1196 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1197 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_WRITEMEM_32BIT;
1198 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
1199 h->cmdidx += 4;
1200 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
1201 h->cmdidx += 2;
1202
1203 res = stlink_usb_xfer(handle, buffer, len);
1204
1205 if (res != ERROR_OK)
1206 return res;
1207
1208 return stlink_usb_get_rw_status(handle);
1209 }
1210
1211 /** */
1212 static int stlink_usb_close(void *fd)
1213 {
1214 struct stlink_usb_handle_s *h;
1215
1216 h = (struct stlink_usb_handle_s *)fd;
1217
1218 if (h->fd)
1219 jtag_libusb_close(h->fd);
1220
1221 free(fd);
1222
1223 return ERROR_OK;
1224 }
1225
1226 /** */
1227 static int stlink_usb_open(struct hl_interface_param_s *param, void **fd)
1228 {
1229 int err;
1230 struct stlink_usb_handle_s *h;
1231 enum stlink_jtag_api_version api;
1232
1233 LOG_DEBUG("stlink_usb_open");
1234
1235 h = calloc(1, sizeof(struct stlink_usb_handle_s));
1236
1237 if (h == 0) {
1238 LOG_DEBUG("malloc failed");
1239 return ERROR_FAIL;
1240 }
1241
1242 h->transport = param->transport;
1243
1244 /* set max read/write buffer size in bytes */
1245 param->max_buffer = 512;
1246
1247 const uint16_t vids[] = { param->vid, 0 };
1248 const uint16_t pids[] = { param->pid, 0 };
1249
1250 LOG_DEBUG("transport: %d vid: 0x%04x pid: 0x%04x", param->transport,
1251 param->vid, param->pid);
1252
1253 if (jtag_libusb_open(vids, pids, &h->fd) != ERROR_OK) {
1254 LOG_ERROR("open failed");
1255 goto error_open;
1256 }
1257
1258 jtag_libusb_set_configuration(h->fd, 0);
1259
1260 if (jtag_libusb_claim_interface(h->fd, 0) != ERROR_OK) {
1261 LOG_DEBUG("claim interface failed");
1262 goto error_open;
1263 }
1264
1265 /* wrap version for first read */
1266 switch (param->pid) {
1267 case 0x3744:
1268 h->version.stlink = 1;
1269 break;
1270 default:
1271 h->version.stlink = 2;
1272 break;
1273 }
1274
1275 /* get the device version */
1276 err = stlink_usb_version(h);
1277
1278 if (err != ERROR_OK) {
1279 LOG_ERROR("read version failed");
1280 goto error_open;
1281 }
1282
1283 /* compare usb vid/pid */
1284 if ((param->vid != h->vid) || (param->pid != h->pid))
1285 LOG_INFO("vid/pid are not identical: 0x%04X/0x%04X 0x%04X/0x%04X",
1286 param->vid, param->pid,
1287 h->vid, h->pid);
1288
1289 /* check if mode is supported */
1290 err = ERROR_OK;
1291
1292 switch (h->transport) {
1293 case HL_TRANSPORT_SWD:
1294 case HL_TRANSPORT_JTAG:
1295 if (h->version.jtag == 0)
1296 err = ERROR_FAIL;
1297 break;
1298 case HL_TRANSPORT_SWIM:
1299 if (h->version.swim == 0)
1300 err = ERROR_FAIL;
1301 break;
1302 default:
1303 err = ERROR_FAIL;
1304 break;
1305 }
1306
1307 if (err != ERROR_OK) {
1308 LOG_ERROR("mode (transport) not supported by device");
1309 goto error_open;
1310 }
1311
1312 api = h->version.jtag_api_max;
1313
1314 /* check that user has not requested certain api version
1315 * and if they have check it is supported */
1316 if ((param->api != 0) && (param->api <= h->version.jtag_api_max)) {
1317 api = param->api;
1318 LOG_INFO("using stlink api v%d", api);
1319 }
1320
1321 /* set the used jtag api, this will default to the newest supported version */
1322 h->jtag_api = api;
1323
1324 /* initialize the debug hardware */
1325 err = stlink_usb_init_mode(h, param->connect_under_reset);
1326
1327 if (err != ERROR_OK) {
1328 LOG_ERROR("init mode failed");
1329 goto error_open;
1330 }
1331
1332 *fd = h;
1333
1334 return ERROR_OK;
1335
1336 error_open:
1337 stlink_usb_close(h);
1338
1339 return ERROR_FAIL;
1340 }
1341
1342 /** */
1343 struct hl_layout_api_s stlink_usb_layout_api = {
1344 /** */
1345 .open = stlink_usb_open,
1346 /** */
1347 .close = stlink_usb_close,
1348 /** */
1349 .idcode = stlink_usb_idcode,
1350 /** */
1351 .state = stlink_usb_state,
1352 /** */
1353 .reset = stlink_usb_reset,
1354 /** */
1355 .assert_srst = stlink_usb_assert_srst,
1356 /** */
1357 .run = stlink_usb_run,
1358 /** */
1359 .halt = stlink_usb_halt,
1360 /** */
1361 .step = stlink_usb_step,
1362 /** */
1363 .read_regs = stlink_usb_read_regs,
1364 /** */
1365 .read_reg = stlink_usb_read_reg,
1366 /** */
1367 .write_reg = stlink_usb_write_reg,
1368 /** */
1369 .read_mem8 = stlink_usb_read_mem8,
1370 /** */
1371 .write_mem8 = stlink_usb_write_mem8,
1372 /** */
1373 .read_mem32 = stlink_usb_read_mem32,
1374 /** */
1375 .write_mem32 = stlink_usb_write_mem32,
1376 /** */
1377 .write_debug_reg = stlink_usb_write_debug_reg
1378 };
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)