Code Review / openocd.git / blob
? search:
summary | shortlog | log | commit | commitdiff | review | tree
history | raw | HEAD
stlink: print target voltage if supported
[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 /** */
583 static int stlink_usb_init_mode(void *handle)
584 {
585 int res;
586 uint8_t mode;
587 enum stlink_mode emode;
588 struct stlink_usb_handle_s *h;
589
590 assert(handle != NULL);
591
592 h = (struct stlink_usb_handle_s *)handle;
593
594 res = stlink_usb_current_mode(handle, &mode);
595
596 if (res != ERROR_OK)
597 return res;
598
599 LOG_DEBUG("MODE: 0x%02X", mode);
600
601 /* try to exit current mode */
602 switch (mode) {
603 case STLINK_DEV_DFU_MODE:
604 emode = STLINK_MODE_DFU;
605 break;
606 case STLINK_DEV_DEBUG_MODE:
607 emode = STLINK_MODE_DEBUG_SWD;
608 break;
609 case STLINK_DEV_SWIM_MODE:
610 emode = STLINK_MODE_DEBUG_SWIM;
611 break;
612 case STLINK_DEV_BOOTLOADER_MODE:
613 case STLINK_DEV_MASS_MODE:
614 default:
615 emode = STLINK_MODE_UNKNOWN;
616 break;
617 }
618
619 if (emode != STLINK_MODE_UNKNOWN) {
620 res = stlink_usb_mode_leave(handle, emode);
621
622 if (res != ERROR_OK)
623 return res;
624 }
625
626 res = stlink_usb_current_mode(handle, &mode);
627
628 if (res != ERROR_OK)
629 return res;
630
631 /* we check the target voltage here as an aid to debugging connection problems.
632 * the stlink requires the target Vdd to be connected for reliable debugging.
633 * this cmd is supported in all modes except DFU
634 */
635 if (mode != STLINK_DEV_DFU_MODE) {
636
637 float target_voltage;
638
639 /* check target voltage (if supported) */
640 res = stlink_usb_check_voltage(h, &target_voltage);
641
642 if (res != ERROR_OK) {
643 if (res != ERROR_COMMAND_NOTFOUND)
644 LOG_ERROR("voltage check failed");
645 /* attempt to continue as it is not a catastrophic failure */
646 } else {
647 /* check for a sensible target voltage, operating range is 1.65-5.5v
648 * according to datasheet */
649 if (target_voltage < 1.5)
650 LOG_ERROR("target voltage may be too low for reliable debugging");
651 }
652 }
653
654 LOG_DEBUG("MODE: 0x%02X", mode);
655
656 /* set selected mode */
657 switch (h->transport) {
658 case HL_TRANSPORT_SWD:
659 emode = STLINK_MODE_DEBUG_SWD;
660 break;
661 case HL_TRANSPORT_JTAG:
662 emode = STLINK_MODE_DEBUG_JTAG;
663 break;
664 case HL_TRANSPORT_SWIM:
665 emode = STLINK_MODE_DEBUG_SWIM;
666 break;
667 default:
668 emode = STLINK_MODE_UNKNOWN;
669 break;
670 }
671
672 if (emode == STLINK_MODE_UNKNOWN) {
673 LOG_ERROR("selected mode (transport) not supported");
674 return ERROR_FAIL;
675 }
676
677 res = stlink_usb_mode_enter(handle, emode);
678
679 if (res != ERROR_OK)
680 return res;
681
682 res = stlink_usb_current_mode(handle, &mode);
683
684 if (res != ERROR_OK)
685 return res;
686
687 LOG_DEBUG("MODE: 0x%02X", mode);
688
689 return ERROR_OK;
690 }
691
692 /** */
693 static int stlink_usb_idcode(void *handle, uint32_t *idcode)
694 {
695 int res;
696 struct stlink_usb_handle_s *h;
697
698 assert(handle != NULL);
699
700 h = (struct stlink_usb_handle_s *)handle;
701
702 stlink_usb_init_buffer(handle, STLINK_RX_EP, 4);
703
704 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
705 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_READCOREID;
706
707 res = stlink_usb_xfer(handle, h->databuf, 4);
708
709 if (res != ERROR_OK)
710 return res;
711
712 *idcode = le_to_h_u32(h->databuf);
713
714 LOG_DEBUG("IDCODE: 0x%08X", *idcode);
715
716 return ERROR_OK;
717 }
718
719 static int stlink_usb_v2_read_debug_reg(void *handle, uint32_t addr, uint32_t *val)
720 {
721 struct stlink_usb_handle_s *h;
722 int res;
723
724 assert(handle != NULL);
725
726 h = (struct stlink_usb_handle_s *)handle;
727
728 stlink_usb_init_buffer(handle, STLINK_RX_EP, 8);
729
730 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
731 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_READDEBUGREG;
732 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
733 h->cmdidx += 4;
734
735 res = stlink_usb_xfer(handle, h->databuf, 8);
736
737 if (res != ERROR_OK)
738 return res;
739
740 *val = le_to_h_u32(h->databuf + 4);
741
742 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
743 }
744
745 static int stlink_usb_write_debug_reg(void *handle, uint32_t addr, uint32_t val)
746 {
747 int res;
748 struct stlink_usb_handle_s *h;
749
750 assert(handle != NULL);
751
752 h = (struct stlink_usb_handle_s *)handle;
753
754 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
755
756 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
757 if (h->jtag_api == STLINK_JTAG_API_V1)
758 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_WRITEDEBUGREG;
759 else
760 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_WRITEDEBUGREG;
761 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
762 h->cmdidx += 4;
763 h_u32_to_le(h->cmdbuf+h->cmdidx, val);
764 h->cmdidx += 4;
765
766 res = stlink_usb_xfer(handle, h->databuf, 2);
767
768 if (res != ERROR_OK)
769 return res;
770
771 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
772 }
773
774 static enum target_state stlink_usb_v2_get_status(void *handle)
775 {
776 int result;
777 uint32_t status;
778
779 result = stlink_usb_v2_read_debug_reg(handle, DCB_DHCSR, &status);
780 if (result != ERROR_OK)
781 return TARGET_UNKNOWN;
782
783 if (status & S_HALT)
784 return TARGET_HALTED;
785 else if (status & S_RESET_ST)
786 return TARGET_RESET;
787
788 return TARGET_RUNNING;
789 }
790
791 /** */
792 static enum target_state stlink_usb_state(void *handle)
793 {
794 int res;
795 struct stlink_usb_handle_s *h;
796
797 assert(handle != NULL);
798
799 h = (struct stlink_usb_handle_s *)handle;
800
801 if (h->jtag_api == STLINK_JTAG_API_V2)
802 return stlink_usb_v2_get_status(handle);
803
804 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
805
806 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
807 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_GETSTATUS;
808
809 res = stlink_usb_xfer(handle, h->databuf, 2);
810
811 if (res != ERROR_OK)
812 return TARGET_UNKNOWN;
813
814 if (h->databuf[0] == STLINK_CORE_RUNNING)
815 return TARGET_RUNNING;
816 if (h->databuf[0] == STLINK_CORE_HALTED)
817 return TARGET_HALTED;
818
819 return TARGET_UNKNOWN;
820 }
821
822 /** */
823 static int stlink_usb_reset(void *handle)
824 {
825 int res;
826 struct stlink_usb_handle_s *h;
827
828 assert(handle != NULL);
829
830 h = (struct stlink_usb_handle_s *)handle;
831
832 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
833
834 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
835
836 if (h->jtag_api == STLINK_JTAG_API_V1)
837 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_RESETSYS;
838 else
839 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_RESETSYS;
840
841 res = stlink_usb_xfer(handle, h->databuf, 2);
842
843 if (res != ERROR_OK)
844 return res;
845
846 LOG_DEBUG("RESET: 0x%08X", h->databuf[0]);
847
848 /* the following is not a error under swd (using hardware srst), so return success */
849 if (h->databuf[0] == STLINK_SWD_AP_WAIT || h->databuf[0] == STLINK_SWD_DP_WAIT)
850 return ERROR_OK;
851
852 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
853 }
854
855 static int stlink_usb_assert_srst(void *handle, int srst)
856 {
857 int res;
858 struct stlink_usb_handle_s *h;
859
860 assert(handle != NULL);
861
862 h = (struct stlink_usb_handle_s *)handle;
863
864 if (h->jtag_api == STLINK_JTAG_API_V1)
865 return ERROR_COMMAND_NOTFOUND;
866
867 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
868
869 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
870 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_DRIVE_NRST;
871 h->cmdbuf[h->cmdidx++] = srst;
872
873 res = stlink_usb_xfer(handle, h->databuf, 2);
874
875 if (res != ERROR_OK)
876 return res;
877
878 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
879 }
880
881 /** */
882 static int stlink_usb_run(void *handle)
883 {
884 int res;
885 struct stlink_usb_handle_s *h;
886
887 assert(handle != NULL);
888
889 h = (struct stlink_usb_handle_s *)handle;
890
891 if (h->jtag_api == STLINK_JTAG_API_V2)
892 return stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_DEBUGEN);
893
894 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
895
896 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
897 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_RUNCORE;
898
899 res = stlink_usb_xfer(handle, h->databuf, 2);
900
901 if (res != ERROR_OK)
902 return res;
903
904 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
905 }
906
907 /** */
908 static int stlink_usb_halt(void *handle)
909 {
910 int res;
911 struct stlink_usb_handle_s *h;
912
913 assert(handle != NULL);
914
915 h = (struct stlink_usb_handle_s *)handle;
916
917 if (h->jtag_api == STLINK_JTAG_API_V2)
918 return stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_HALT|C_DEBUGEN);
919
920 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
921
922 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
923 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_FORCEDEBUG;
924
925 res = stlink_usb_xfer(handle, h->databuf, 2);
926
927 if (res != ERROR_OK)
928 return res;
929
930 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
931 }
932
933 /** */
934 static int stlink_usb_step(void *handle)
935 {
936 int res;
937 struct stlink_usb_handle_s *h;
938
939 assert(handle != NULL);
940
941 h = (struct stlink_usb_handle_s *)handle;
942
943 if (h->jtag_api == STLINK_JTAG_API_V2) {
944 /* TODO: this emulates the v1 api, it should really use a similar auto mask isr
945 * that the cortex-m3 currently does. */
946 stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_HALT|C_MASKINTS|C_DEBUGEN);
947 stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_STEP|C_MASKINTS|C_DEBUGEN);
948 return stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_HALT|C_DEBUGEN);
949 }
950
951 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
952
953 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
954 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_STEPCORE;
955
956 res = stlink_usb_xfer(handle, h->databuf, 2);
957
958 if (res != ERROR_OK)
959 return res;
960
961 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
962 }
963
964 /** */
965 static int stlink_usb_read_regs(void *handle)
966 {
967 int res;
968 struct stlink_usb_handle_s *h;
969
970 assert(handle != NULL);
971
972 h = (struct stlink_usb_handle_s *)handle;
973
974 stlink_usb_init_buffer(handle, STLINK_RX_EP, 84);
975
976 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
977 if (h->jtag_api == STLINK_JTAG_API_V1)
978 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_READALLREGS;
979 else
980 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_READALLREGS;
981
982 res = stlink_usb_xfer(handle, h->databuf, 84);
983
984 if (res != ERROR_OK)
985 return res;
986
987 return ERROR_OK;
988 }
989
990 /** */
991 static int stlink_usb_read_reg(void *handle, int num, uint32_t *val)
992 {
993 int res;
994 struct stlink_usb_handle_s *h;
995
996 assert(handle != NULL);
997
998 h = (struct stlink_usb_handle_s *)handle;
999
1000 stlink_usb_init_buffer(handle, STLINK_RX_EP, h->jtag_api == STLINK_JTAG_API_V1 ? 4 : 8);
1001
1002 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1003 if (h->jtag_api == STLINK_JTAG_API_V1)
1004 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_READREG;
1005 else
1006 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_READREG;
1007 h->cmdbuf[h->cmdidx++] = num;
1008
1009 res = stlink_usb_xfer(handle, h->databuf, h->jtag_api == STLINK_JTAG_API_V1 ? 4 : 8);
1010
1011 if (res != ERROR_OK)
1012 return res;
1013
1014 if (h->jtag_api == STLINK_JTAG_API_V1)
1015 *val = le_to_h_u32(h->databuf);
1016 else {
1017 *val = le_to_h_u32(h->databuf + 4);
1018 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
1019 }
1020
1021 return ERROR_OK;
1022 }
1023
1024 /** */
1025 static int stlink_usb_write_reg(void *handle, int num, uint32_t val)
1026 {
1027 int res;
1028 struct stlink_usb_handle_s *h;
1029
1030 assert(handle != NULL);
1031
1032 h = (struct stlink_usb_handle_s *)handle;
1033
1034 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
1035
1036 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1037 if (h->jtag_api == STLINK_JTAG_API_V1)
1038 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV1_WRITEREG;
1039 else
1040 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_WRITEREG;
1041 h->cmdbuf[h->cmdidx++] = num;
1042 h_u32_to_le(h->cmdbuf+h->cmdidx, val);
1043 h->cmdidx += 4;
1044
1045 res = stlink_usb_xfer(handle, h->databuf, 2);
1046
1047 if (res != ERROR_OK)
1048 return res;
1049
1050 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL;
1051 }
1052
1053 static int stlink_usb_get_rw_status(void *handle)
1054 {
1055 int res;
1056 struct stlink_usb_handle_s *h;
1057
1058 assert(handle != NULL);
1059
1060 h = (struct stlink_usb_handle_s *)handle;
1061
1062 if (h->jtag_api == STLINK_JTAG_API_V1)
1063 return ERROR_OK;
1064
1065 stlink_usb_init_buffer(handle, STLINK_RX_EP, 2);
1066
1067 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1068 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_GETLASTRWSTATUS;
1069
1070 res = stlink_usb_xfer(handle, h->databuf, 2);
1071
1072 if (res != ERROR_OK)
1073 return res;
1074
1075 return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : res;
1076 }
1077
1078 /** */
1079 static int stlink_usb_read_mem8(void *handle, uint32_t addr, uint16_t len,
1080 uint8_t *buffer)
1081 {
1082 int res;
1083 uint16_t read_len = len;
1084 struct stlink_usb_handle_s *h;
1085
1086 assert(handle != NULL);
1087
1088 h = (struct stlink_usb_handle_s *)handle;
1089
1090 stlink_usb_init_buffer(handle, STLINK_RX_EP, read_len);
1091
1092 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1093 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_READMEM_8BIT;
1094 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
1095 h->cmdidx += 4;
1096 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
1097 h->cmdidx += 2;
1098
1099 /* we need to fix read length for single bytes */
1100 if (read_len == 1)
1101 read_len++;
1102
1103 res = stlink_usb_xfer(handle, h->databuf, read_len);
1104
1105 if (res != ERROR_OK)
1106 return res;
1107
1108 memcpy(buffer, h->databuf, len);
1109
1110 return stlink_usb_get_rw_status(handle);
1111 }
1112
1113 /** */
1114 static int stlink_usb_write_mem8(void *handle, uint32_t addr, uint16_t len,
1115 const uint8_t *buffer)
1116 {
1117 int res;
1118 struct stlink_usb_handle_s *h;
1119
1120 assert(handle != NULL);
1121
1122 h = (struct stlink_usb_handle_s *)handle;
1123
1124 stlink_usb_init_buffer(handle, STLINK_TX_EP, len);
1125
1126 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1127 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_WRITEMEM_8BIT;
1128 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
1129 h->cmdidx += 4;
1130 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
1131 h->cmdidx += 2;
1132
1133 res = stlink_usb_xfer(handle, buffer, len);
1134
1135 if (res != ERROR_OK)
1136 return res;
1137
1138 return stlink_usb_get_rw_status(handle);
1139 }
1140
1141 /** */
1142 static int stlink_usb_read_mem32(void *handle, uint32_t addr, uint16_t len,
1143 uint8_t *buffer)
1144 {
1145 int res;
1146 struct stlink_usb_handle_s *h;
1147
1148 assert(handle != NULL);
1149
1150 h = (struct stlink_usb_handle_s *)handle;
1151
1152 len *= 4;
1153
1154 stlink_usb_init_buffer(handle, STLINK_RX_EP, len);
1155
1156 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1157 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_READMEM_32BIT;
1158 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
1159 h->cmdidx += 4;
1160 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
1161 h->cmdidx += 2;
1162
1163 res = stlink_usb_xfer(handle, h->databuf, len);
1164
1165 if (res != ERROR_OK)
1166 return res;
1167
1168 memcpy(buffer, h->databuf, len);
1169
1170 return stlink_usb_get_rw_status(handle);
1171 }
1172
1173 /** */
1174 static int stlink_usb_write_mem32(void *handle, uint32_t addr, uint16_t len,
1175 const uint8_t *buffer)
1176 {
1177 int res;
1178 struct stlink_usb_handle_s *h;
1179
1180 assert(handle != NULL);
1181
1182 h = (struct stlink_usb_handle_s *)handle;
1183
1184 len *= 4;
1185
1186 stlink_usb_init_buffer(handle, STLINK_TX_EP, len);
1187
1188 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND;
1189 h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_WRITEMEM_32BIT;
1190 h_u32_to_le(h->cmdbuf+h->cmdidx, addr);
1191 h->cmdidx += 4;
1192 h_u16_to_le(h->cmdbuf+h->cmdidx, len);
1193 h->cmdidx += 2;
1194
1195 res = stlink_usb_xfer(handle, buffer, len);
1196
1197 if (res != ERROR_OK)
1198 return res;
1199
1200 return stlink_usb_get_rw_status(handle);
1201 }
1202
1203 /** */
1204 static int stlink_usb_close(void *fd)
1205 {
1206 struct stlink_usb_handle_s *h;
1207
1208 h = (struct stlink_usb_handle_s *)fd;
1209
1210 if (h->fd)
1211 jtag_libusb_close(h->fd);
1212
1213 free(fd);
1214
1215 return ERROR_OK;
1216 }
1217
1218 /** */
1219 static int stlink_usb_open(struct hl_interface_param_s *param, void **fd)
1220 {
1221 int err;
1222 struct stlink_usb_handle_s *h;
1223 enum stlink_jtag_api_version api;
1224
1225 LOG_DEBUG("stlink_usb_open");
1226
1227 h = calloc(1, sizeof(struct stlink_usb_handle_s));
1228
1229 if (h == 0) {
1230 LOG_DEBUG("malloc failed");
1231 return ERROR_FAIL;
1232 }
1233
1234 h->transport = param->transport;
1235
1236 /* set max read/write buffer size in bytes */
1237 param->max_buffer = 512;
1238
1239 const uint16_t vids[] = { param->vid, 0 };
1240 const uint16_t pids[] = { param->pid, 0 };
1241
1242 LOG_DEBUG("transport: %d vid: 0x%04x pid: 0x%04x", param->transport,
1243 param->vid, param->pid);
1244
1245 if (jtag_libusb_open(vids, pids, &h->fd) != ERROR_OK) {
1246 LOG_ERROR("open failed");
1247 goto error_open;
1248 }
1249
1250 jtag_libusb_set_configuration(h->fd, 0);
1251
1252 if (jtag_libusb_claim_interface(h->fd, 0) != ERROR_OK) {
1253 LOG_DEBUG("claim interface failed");
1254 goto error_open;
1255 }
1256
1257 /* wrap version for first read */
1258 switch (param->pid) {
1259 case 0x3744:
1260 h->version.stlink = 1;
1261 break;
1262 default:
1263 h->version.stlink = 2;
1264 break;
1265 }
1266
1267 /* get the device version */
1268 err = stlink_usb_version(h);
1269
1270 if (err != ERROR_OK) {
1271 LOG_ERROR("read version failed");
1272 goto error_open;
1273 }
1274
1275 /* compare usb vid/pid */
1276 if ((param->vid != h->vid) || (param->pid != h->pid))
1277 LOG_INFO("vid/pid are not identical: 0x%04X/0x%04X 0x%04X/0x%04X",
1278 param->vid, param->pid,
1279 h->vid, h->pid);
1280
1281 /* check if mode is supported */
1282 err = ERROR_OK;
1283
1284 switch (h->transport) {
1285 case HL_TRANSPORT_SWD:
1286 case HL_TRANSPORT_JTAG:
1287 if (h->version.jtag == 0)
1288 err = ERROR_FAIL;
1289 break;
1290 case HL_TRANSPORT_SWIM:
1291 if (h->version.swim == 0)
1292 err = ERROR_FAIL;
1293 break;
1294 default:
1295 err = ERROR_FAIL;
1296 break;
1297 }
1298
1299 if (err != ERROR_OK) {
1300 LOG_ERROR("mode (transport) not supported by device");
1301 goto error_open;
1302 }
1303
1304 api = h->version.jtag_api_max;
1305
1306 /* check that user has not requested certain api version
1307 * and if they have check it is supported */
1308 if ((param->api != 0) && (param->api <= h->version.jtag_api_max)) {
1309 api = param->api;
1310 LOG_INFO("using stlink api v%d", api);
1311 }
1312
1313 /* set the used jtag api, this will default to the newest supported version */
1314 h->jtag_api = api;
1315
1316 /* initialize the debug hardware */
1317 err = stlink_usb_init_mode(h);
1318
1319 if (err != ERROR_OK) {
1320 LOG_ERROR("init mode failed");
1321 goto error_open;
1322 }
1323
1324 *fd = h;
1325
1326 return ERROR_OK;
1327
1328 error_open:
1329 stlink_usb_close(h);
1330
1331 return ERROR_FAIL;
1332 }
1333
1334 /** */
1335 struct hl_layout_api_s stlink_usb_layout_api = {
1336 /** */
1337 .open = stlink_usb_open,
1338 /** */
1339 .close = stlink_usb_close,
1340 /** */
1341 .idcode = stlink_usb_idcode,
1342 /** */
1343 .state = stlink_usb_state,
1344 /** */
1345 .reset = stlink_usb_reset,
1346 /** */
1347 .assert_srst = stlink_usb_assert_srst,
1348 /** */
1349 .run = stlink_usb_run,
1350 /** */
1351 .halt = stlink_usb_halt,
1352 /** */
1353 .step = stlink_usb_step,
1354 /** */
1355 .read_regs = stlink_usb_read_regs,
1356 /** */
1357 .read_reg = stlink_usb_read_reg,
1358 /** */
1359 .write_reg = stlink_usb_write_reg,
1360 /** */
1361 .read_mem8 = stlink_usb_read_mem8,
1362 /** */
1363 .write_mem8 = stlink_usb_write_mem8,
1364 /** */
1365 .read_mem32 = stlink_usb_read_mem32,
1366 /** */
1367 .write_mem32 = stlink_usb_write_mem32,
1368 /** */
1369 .write_debug_reg = stlink_usb_write_debug_reg
1370 };
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)