1 /***************************************************************************
2 * Copyright (C) 2011-2012 by Mathias Kuester *
3 * Mathias Kuester <kesmtp@freenet.de> *
5 * This code is based on https://github.com/texane/stlink *
7 * This program is free software; you can redistribute it and/or modify *
8 * it under the terms of the GNU General Public License as published by *
9 * the Free Software Foundation; either version 2 of the License, or *
10 * (at your option) any later version. *
12 * This program is distributed in the hope that it will be useful, *
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
15 * GNU General Public License for more details. *
17 * You should have received a copy of the GNU General Public License *
18 * along with this program; if not, write to the *
19 * Free Software Foundation, Inc., *
20 * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
21 ***************************************************************************/
27 /* project specific includes */
28 #include <helper/binarybuffer.h>
29 #include <jtag/interface.h>
30 #include <jtag/stlink/stlink_layout.h>
31 #include <jtag/stlink/stlink_transport.h>
32 #include <jtag/stlink/stlink_interface.h>
33 #include <target/target.h>
35 #include "libusb_common.h"
37 #define ENDPOINT_IN 0x80
38 #define ENDPOINT_OUT 0x00
40 #define STLINK_NULL_EP 0
41 #define STLINK_RX_EP (1|ENDPOINT_IN)
42 #define STLINK_TX_EP (2|ENDPOINT_OUT)
43 #define STLINK_SG_SIZE (31)
44 #define STLINK_DATA_SIZE (4*128)
45 #define STLINK_CMD_SIZE_V2 (16)
46 #define STLINK_CMD_SIZE_V1 (10)
48 enum stlink_jtag_api_version
{
49 STLINK_JTAG_API_V1
= 0,
54 struct stlink_usb_version
{
61 /** highest supported jtag api version */
62 enum stlink_jtag_api_version jtag_api_max
;
66 struct stlink_usb_handle_s
{
68 struct jtag_libusb_device_handle
*fd
;
70 struct libusb_transfer
*trans
;
72 uint8_t cmdbuf
[STLINK_SG_SIZE
];
78 uint8_t databuf
[STLINK_DATA_SIZE
];
80 enum stlink_transports transport
;
82 struct stlink_usb_version version
;
87 /** this is the currently used jtag api */
88 enum stlink_jtag_api_version jtag_api
;
91 #define STLINK_DEBUG_ERR_OK 0x80
92 #define STLINK_DEBUG_ERR_FAULT 0x81
93 #define STLINK_CORE_RUNNING 0x80
94 #define STLINK_CORE_HALTED 0x81
95 #define STLINK_CORE_STAT_UNKNOWN -1
97 #define STLINK_GET_VERSION 0xF1
98 #define STLINK_DEBUG_COMMAND 0xF2
99 #define STLINK_DFU_COMMAND 0xF3
100 #define STLINK_SWIM_COMMAND 0xF4
101 #define STLINK_GET_CURRENT_MODE 0xF5
103 #define STLINK_DEV_DFU_MODE 0x00
104 #define STLINK_DEV_MASS_MODE 0x01
105 #define STLINK_DEV_DEBUG_MODE 0x02
106 #define STLINK_DEV_SWIM_MODE 0x03
107 #define STLINK_DEV_BOOTLOADER_MODE 0x04
108 #define STLINK_DEV_UNKNOWN_MODE -1
110 #define STLINK_DFU_EXIT 0x07
112 #define STLINK_SWIM_ENTER 0x00
113 #define STLINK_SWIM_EXIT 0x01
115 #define STLINK_DEBUG_ENTER_JTAG 0x00
116 #define STLINK_DEBUG_GETSTATUS 0x01
117 #define STLINK_DEBUG_FORCEDEBUG 0x02
118 #define STLINK_DEBUG_APIV1_RESETSYS 0x03
119 #define STLINK_DEBUG_APIV1_READALLREGS 0x04
120 #define STLINK_DEBUG_APIV1_READREG 0x05
121 #define STLINK_DEBUG_APIV1_WRITEREG 0x06
122 #define STLINK_DEBUG_READMEM_32BIT 0x07
123 #define STLINK_DEBUG_WRITEMEM_32BIT 0x08
124 #define STLINK_DEBUG_RUNCORE 0x09
125 #define STLINK_DEBUG_STEPCORE 0x0a
126 #define STLINK_DEBUG_APIV1_SETFP 0x0b
127 #define STLINK_DEBUG_READMEM_8BIT 0x0c
128 #define STLINK_DEBUG_WRITEMEM_8BIT 0x0d
129 #define STLINK_DEBUG_APIV1_CLEARFP 0x0e
130 #define STLINK_DEBUG_APIV1_WRITEDEBUGREG 0x0f
131 #define STLINK_DEBUG_APIV1_SETWATCHPOINT 0x10
133 #define STLINK_DEBUG_ENTER_JTAG 0x00
134 #define STLINK_DEBUG_ENTER_SWD 0xa3
136 #define STLINK_DEBUG_APIV1_ENTER 0x20
137 #define STLINK_DEBUG_EXIT 0x21
138 #define STLINK_DEBUG_READCOREID 0x22
140 #define STLINK_DEBUG_APIV2_ENTER 0x30
141 #define STLINK_DEBUG_APIV2_READ_IDCODES 0x31
142 #define STLINK_DEBUG_APIV2_RESETSYS 0x32
143 #define STLINK_DEBUG_APIV2_READREG 0x33
144 #define STLINK_DEBUG_APIV2_WRITEREG 0x34
146 #define STLINK_DEBUG_APIV2_READALLREGS 0x3A
148 #define STLINK_DEBUG_APIV2_DRIVE_NRST 0x3C
150 #define STLINK_DEBUG_APIV2_DRIVE_NRST_LOW 0x00
151 #define STLINK_DEBUG_APIV2_DRIVE_NRST_HIGH 0x01
152 #define STLINK_DEBUG_APIV2_DRIVE_NRST_PULSE 0x02
156 STLINK_MODE_UNKNOWN
= 0,
159 STLINK_MODE_DEBUG_JTAG
,
160 STLINK_MODE_DEBUG_SWD
,
161 STLINK_MODE_DEBUG_SWIM
164 #define REQUEST_SENSE 0x03
165 #define REQUEST_SENSE_LENGTH 18
167 static void stlink_usb_init_buffer(void *handle
, uint8_t direction
, uint32_t size
);
170 static int stlink_usb_xfer_v1_get_status(void *handle
)
172 struct stlink_usb_handle_s
*h
;
174 assert(handle
!= NULL
);
176 h
= (struct stlink_usb_handle_s
*)handle
;
179 memset(h
->cmdbuf
, 0, STLINK_SG_SIZE
);
181 if (jtag_libusb_bulk_read(h
->fd
, STLINK_RX_EP
, (char *)h
->cmdbuf
,
187 t1
= buf_get_u32(h
->cmdbuf
, 0, 32);
190 if (t1
!= 0x53425355)
198 if (h
->cmdbuf
[12] != 0)
205 static int stlink_usb_xfer_rw(void *handle
, int cmdsize
, const uint8_t *buf
, int size
)
207 struct stlink_usb_handle_s
*h
;
209 assert(handle
!= NULL
);
211 h
= (struct stlink_usb_handle_s
*)handle
;
213 if (jtag_libusb_bulk_write(h
->fd
, STLINK_TX_EP
, (char *)h
->cmdbuf
, cmdsize
,
218 if (h
->direction
== STLINK_TX_EP
&& size
) {
219 if (jtag_libusb_bulk_write(h
->fd
, STLINK_TX_EP
, (char *)buf
,
220 size
, 1000) != size
) {
221 LOG_DEBUG("bulk write failed");
224 } else if (h
->direction
== STLINK_RX_EP
&& size
) {
225 if (jtag_libusb_bulk_read(h
->fd
, STLINK_RX_EP
, (char *)buf
,
226 size
, 1000) != size
) {
227 LOG_DEBUG("bulk read failed");
236 static int stlink_usb_xfer_v1_get_sense(void *handle
)
239 struct stlink_usb_handle_s
*h
;
241 assert(handle
!= NULL
);
243 h
= (struct stlink_usb_handle_s
*)handle
;
245 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 16);
247 h
->cmdbuf
[h
->cmdidx
++] = REQUEST_SENSE
;
248 h
->cmdbuf
[h
->cmdidx
++] = 0;
249 h
->cmdbuf
[h
->cmdidx
++] = 0;
250 h
->cmdbuf
[h
->cmdidx
++] = 0;
251 h
->cmdbuf
[h
->cmdidx
++] = REQUEST_SENSE_LENGTH
;
253 res
= stlink_usb_xfer_rw(handle
, REQUEST_SENSE_LENGTH
, h
->databuf
, 16);
258 if (stlink_usb_xfer_v1_get_status(handle
) != ERROR_OK
)
265 static int stlink_usb_xfer(void *handle
, const uint8_t *buf
, int size
)
267 int err
, cmdsize
= STLINK_CMD_SIZE_V2
;
268 struct stlink_usb_handle_s
*h
;
270 assert(handle
!= NULL
);
272 h
= (struct stlink_usb_handle_s
*)handle
;
274 if (h
->version
.stlink
== 1)
275 cmdsize
= STLINK_SG_SIZE
;
277 err
= stlink_usb_xfer_rw(handle
, cmdsize
, buf
, size
);
282 if (h
->version
.stlink
== 1) {
283 if (stlink_usb_xfer_v1_get_status(handle
) != ERROR_OK
) {
284 /* check csw status */
285 if (h
->cmdbuf
[12] == 1) {
286 LOG_DEBUG("get sense");
287 if (stlink_usb_xfer_v1_get_sense(handle
) != ERROR_OK
)
298 static void stlink_usb_xfer_v1_create_cmd(void *handle
, uint8_t direction
, uint32_t size
)
300 struct stlink_usb_handle_s
*h
;
302 h
= (struct stlink_usb_handle_s
*)handle
;
304 /* fill the send buffer */
305 strcpy((char *)h
->cmdbuf
, "USBC");
307 /* csw tag not used */
309 buf_set_u32(h
->cmdbuf
+h
->cmdidx
, 0, 32, size
);
311 h
->cmdbuf
[h
->cmdidx
++] = (direction
== STLINK_RX_EP
? ENDPOINT_IN
: ENDPOINT_OUT
);
312 h
->cmdbuf
[h
->cmdidx
++] = 0; /* lun */
313 h
->cmdbuf
[h
->cmdidx
++] = STLINK_CMD_SIZE_V1
;
317 static void stlink_usb_init_buffer(void *handle
, uint8_t direction
, uint32_t size
)
319 struct stlink_usb_handle_s
*h
;
321 h
= (struct stlink_usb_handle_s
*)handle
;
323 h
->direction
= direction
;
327 memset(h
->cmdbuf
, 0, STLINK_SG_SIZE
);
328 memset(h
->databuf
, 0, STLINK_DATA_SIZE
);
330 if (h
->version
.stlink
== 1)
331 stlink_usb_xfer_v1_create_cmd(handle
, direction
, size
);
334 static const char * const stlink_usb_error_msg
[] = {
339 static int stlink_usb_error_check(void *handle
)
342 const char *err_msg
= 0;
343 struct stlink_usb_handle_s
*h
;
345 assert(handle
!= NULL
);
347 h
= (struct stlink_usb_handle_s
*)handle
;
349 /* TODO: no error checking yet on api V1 */
350 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
351 h
->databuf
[0] = STLINK_DEBUG_ERR_OK
;
353 switch (h
->databuf
[0]) {
354 case STLINK_DEBUG_ERR_OK
:
357 case STLINK_DEBUG_ERR_FAULT
:
359 err_msg
= stlink_usb_error_msg
[0];
365 LOG_DEBUG("status error: %d ('%s')", h
->databuf
[0], err_msg
);
371 static int stlink_usb_version(void *handle
)
375 struct stlink_usb_handle_s
*h
;
377 assert(handle
!= NULL
);
379 h
= (struct stlink_usb_handle_s
*)handle
;
381 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 6);
383 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_VERSION
;
385 res
= stlink_usb_xfer(handle
, h
->databuf
, 6);
390 v
= (h
->databuf
[0] << 8) | h
->databuf
[1];
392 h
->version
.stlink
= (v
>> 12) & 0x0f;
393 h
->version
.jtag
= (v
>> 6) & 0x3f;
394 h
->version
.swim
= v
& 0x3f;
395 h
->vid
= buf_get_u32(h
->databuf
, 16, 16);
396 h
->pid
= buf_get_u32(h
->databuf
, 32, 16);
398 /* set the supported jtag api version
399 * V1 doesn't support API V2 at all
400 * V2 support API V2 since JTAG V13
402 if ((h
->version
.stlink
== 2) && (h
->version
.jtag
> 12))
403 h
->version
.jtag_api_max
= STLINK_JTAG_API_V2
;
405 h
->version
.jtag_api_max
= STLINK_JTAG_API_V1
;
407 LOG_DEBUG("STLINK v%d JTAG v%d API v%d SWIM v%d VID %04X PID %04X",
410 (h
->version
.jtag_api_max
== STLINK_JTAG_API_V1
) ? 1 : 2,
419 static int stlink_usb_current_mode(void *handle
, uint8_t *mode
)
422 struct stlink_usb_handle_s
*h
;
424 assert(handle
!= NULL
);
426 h
= (struct stlink_usb_handle_s
*)handle
;
428 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
430 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_CURRENT_MODE
;
432 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
437 *mode
= h
->databuf
[0];
443 static int stlink_usb_mode_enter(void *handle
, enum stlink_mode type
)
447 struct stlink_usb_handle_s
*h
;
449 assert(handle
!= NULL
);
451 h
= (struct stlink_usb_handle_s
*)handle
;
453 /* on api V2 we are able the read the latest command
455 * TODO: we need the test on api V1 too
457 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
460 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, rx_size
);
463 case STLINK_MODE_DEBUG_JTAG
:
464 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
465 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
466 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_ENTER
;
468 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_ENTER
;
469 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_ENTER_JTAG
;
471 case STLINK_MODE_DEBUG_SWD
:
472 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
473 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
474 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_ENTER
;
476 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_ENTER
;
477 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_ENTER_SWD
;
479 case STLINK_MODE_DEBUG_SWIM
:
480 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
481 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_ENTER
;
483 case STLINK_MODE_DFU
:
484 case STLINK_MODE_MASS
:
489 res
= stlink_usb_xfer(handle
, h
->databuf
, rx_size
);
494 res
= stlink_usb_error_check(h
);
500 static int stlink_usb_mode_leave(void *handle
, enum stlink_mode type
)
503 struct stlink_usb_handle_s
*h
;
505 assert(handle
!= NULL
);
507 h
= (struct stlink_usb_handle_s
*)handle
;
509 stlink_usb_init_buffer(handle
, STLINK_NULL_EP
, 0);
512 case STLINK_MODE_DEBUG_JTAG
:
513 case STLINK_MODE_DEBUG_SWD
:
514 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
515 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_EXIT
;
517 case STLINK_MODE_DEBUG_SWIM
:
518 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
519 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_EXIT
;
521 case STLINK_MODE_DFU
:
522 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DFU_COMMAND
;
523 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DFU_EXIT
;
525 case STLINK_MODE_MASS
:
530 res
= stlink_usb_xfer(handle
, 0, 0);
539 static int stlink_usb_init_mode(void *handle
)
543 enum stlink_mode emode
;
544 struct stlink_usb_handle_s
*h
;
546 assert(handle
!= NULL
);
548 h
= (struct stlink_usb_handle_s
*)handle
;
550 res
= stlink_usb_current_mode(handle
, &mode
);
555 LOG_DEBUG("MODE: %02X", mode
);
557 /* try to exit current mode */
559 case STLINK_DEV_DFU_MODE
:
560 emode
= STLINK_MODE_DFU
;
562 case STLINK_DEV_DEBUG_MODE
:
563 emode
= STLINK_MODE_DEBUG_SWD
;
565 case STLINK_DEV_SWIM_MODE
:
566 emode
= STLINK_MODE_DEBUG_SWIM
;
568 case STLINK_DEV_BOOTLOADER_MODE
:
569 case STLINK_DEV_MASS_MODE
:
571 emode
= STLINK_MODE_UNKNOWN
;
575 if (emode
!= STLINK_MODE_UNKNOWN
) {
576 res
= stlink_usb_mode_leave(handle
, emode
);
582 res
= stlink_usb_current_mode(handle
, &mode
);
587 LOG_DEBUG("MODE: %02X", mode
);
589 /* set selected mode */
590 switch (h
->transport
) {
591 case STLINK_TRANSPORT_SWD
:
592 emode
= STLINK_MODE_DEBUG_SWD
;
594 case STLINK_TRANSPORT_JTAG
:
595 emode
= STLINK_MODE_DEBUG_JTAG
;
597 case STLINK_TRANSPORT_SWIM
:
598 emode
= STLINK_MODE_DEBUG_SWIM
;
601 emode
= STLINK_MODE_UNKNOWN
;
605 if (emode
== STLINK_MODE_UNKNOWN
) {
606 LOG_ERROR("selected mode (transport) not supported");
610 res
= stlink_usb_mode_enter(handle
, emode
);
615 res
= stlink_usb_current_mode(handle
, &mode
);
620 LOG_DEBUG("MODE: %02X", mode
);
626 static int stlink_usb_idcode(void *handle
, uint32_t *idcode
)
629 struct stlink_usb_handle_s
*h
;
631 assert(handle
!= NULL
);
633 h
= (struct stlink_usb_handle_s
*)handle
;
635 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 4);
637 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
638 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READCOREID
;
640 res
= stlink_usb_xfer(handle
, h
->databuf
, 4);
645 *idcode
= le_to_h_u32(h
->databuf
);
647 LOG_DEBUG("IDCODE: %08X", *idcode
);
653 static enum target_state
stlink_usb_state(void *handle
)
656 struct stlink_usb_handle_s
*h
;
658 assert(handle
!= NULL
);
660 h
= (struct stlink_usb_handle_s
*)handle
;
662 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
663 return TARGET_UNKNOWN
;
665 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
667 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
668 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_GETSTATUS
;
670 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
673 return TARGET_UNKNOWN
;
675 if (h
->databuf
[0] == STLINK_CORE_RUNNING
)
676 return TARGET_RUNNING
;
677 if (h
->databuf
[0] == STLINK_CORE_HALTED
)
678 return TARGET_HALTED
;
680 return TARGET_UNKNOWN
;
684 static int stlink_usb_reset(void *handle
)
687 struct stlink_usb_handle_s
*h
;
689 assert(handle
!= NULL
);
691 h
= (struct stlink_usb_handle_s
*)handle
;
693 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
695 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
697 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
698 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_RESETSYS
;
700 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_RESETSYS
;
702 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
707 LOG_DEBUG("RESET: %08X", h
->databuf
[0]);
713 static int stlink_usb_run(void *handle
)
716 struct stlink_usb_handle_s
*h
;
718 assert(handle
!= NULL
);
720 h
= (struct stlink_usb_handle_s
*)handle
;
722 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
725 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
727 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
728 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_RUNCORE
;
730 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
739 static int stlink_usb_halt(void *handle
)
742 struct stlink_usb_handle_s
*h
;
744 assert(handle
!= NULL
);
746 h
= (struct stlink_usb_handle_s
*)handle
;
748 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
751 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
753 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
754 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_FORCEDEBUG
;
756 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
765 static int stlink_usb_step(void *handle
)
768 struct stlink_usb_handle_s
*h
;
770 assert(handle
!= NULL
);
772 h
= (struct stlink_usb_handle_s
*)handle
;
774 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
777 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
779 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
780 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_STEPCORE
;
782 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
791 static int stlink_usb_read_regs(void *handle
)
794 struct stlink_usb_handle_s
*h
;
796 assert(handle
!= NULL
);
798 h
= (struct stlink_usb_handle_s
*)handle
;
800 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 84);
802 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
803 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
804 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_READALLREGS
;
806 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READALLREGS
;
808 res
= stlink_usb_xfer(handle
, h
->databuf
, 84);
817 static int stlink_usb_read_reg(void *handle
, int num
, uint32_t *val
)
820 struct stlink_usb_handle_s
*h
;
822 assert(handle
!= NULL
);
824 h
= (struct stlink_usb_handle_s
*)handle
;
826 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 4);
828 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
829 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
830 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_READREG
;
832 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READREG
;
833 h
->cmdbuf
[h
->cmdidx
++] = num
;
835 res
= stlink_usb_xfer(handle
, h
->databuf
, 4);
840 *val
= le_to_h_u32(h
->databuf
);
846 static int stlink_usb_write_reg(void *handle
, int num
, uint32_t val
)
849 struct stlink_usb_handle_s
*h
;
851 assert(handle
!= NULL
);
853 h
= (struct stlink_usb_handle_s
*)handle
;
855 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
857 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
858 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
859 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_WRITEREG
;
861 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_WRITEREG
;
862 h
->cmdbuf
[h
->cmdidx
++] = num
;
863 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, val
);
866 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
875 static int stlink_usb_read_mem8(void *handle
, uint32_t addr
, uint16_t len
,
879 uint16_t read_len
= len
;
880 struct stlink_usb_handle_s
*h
;
882 assert(handle
!= NULL
);
884 h
= (struct stlink_usb_handle_s
*)handle
;
886 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, read_len
);
888 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
889 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READMEM_8BIT
;
890 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
892 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
895 /* we need to fix read length for single bytes */
899 res
= stlink_usb_xfer(handle
, h
->databuf
, read_len
);
904 memcpy(buffer
, h
->databuf
, len
);
910 static int stlink_usb_write_mem8(void *handle
, uint32_t addr
, uint16_t len
,
911 const uint8_t *buffer
)
914 struct stlink_usb_handle_s
*h
;
916 assert(handle
!= NULL
);
918 h
= (struct stlink_usb_handle_s
*)handle
;
920 stlink_usb_init_buffer(handle
, STLINK_TX_EP
, len
);
922 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
923 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_WRITEMEM_8BIT
;
924 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
926 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
929 res
= stlink_usb_xfer(handle
, buffer
, len
);
938 static int stlink_usb_read_mem32(void *handle
, uint32_t addr
, uint16_t len
,
942 struct stlink_usb_handle_s
*h
;
944 assert(handle
!= NULL
);
946 h
= (struct stlink_usb_handle_s
*)handle
;
950 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, len
);
952 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
953 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READMEM_32BIT
;
954 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
956 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
959 res
= stlink_usb_xfer(handle
, h
->databuf
, len
);
964 memcpy(buffer
, h
->databuf
, len
);
970 static int stlink_usb_write_mem32(void *handle
, uint32_t addr
, uint16_t len
,
971 const uint8_t *buffer
)
974 struct stlink_usb_handle_s
*h
;
976 assert(handle
!= NULL
);
978 h
= (struct stlink_usb_handle_s
*)handle
;
982 stlink_usb_init_buffer(handle
, STLINK_TX_EP
, len
);
984 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
985 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_WRITEMEM_32BIT
;
986 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
988 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
991 res
= stlink_usb_xfer(handle
, buffer
, len
);
1000 static int stlink_usb_open(struct stlink_interface_param_s
*param
, void **fd
)
1003 struct stlink_usb_handle_s
*h
;
1005 LOG_DEBUG("stlink_usb_open");
1007 h
= malloc(sizeof(struct stlink_usb_handle_s
));
1010 LOG_DEBUG("malloc failed");
1014 h
->transport
= param
->transport
;
1016 const uint16_t vids
[] = { param
->vid
, 0 };
1017 const uint16_t pids
[] = { param
->pid
, 0 };
1019 LOG_DEBUG("transport: %d vid: %04x pid: %04x", param
->transport
,
1020 param
->vid
, param
->pid
);
1022 if (jtag_libusb_open(vids
, pids
, &h
->fd
) != ERROR_OK
) {
1023 LOG_ERROR("open failed");
1027 jtag_libusb_set_configuration(h
->fd
, 0);
1029 if (jtag_libusb_claim_interface(h
->fd
, 0) != ERROR_OK
) {
1030 LOG_DEBUG("claim interface failed");
1034 /* wrap version for first read */
1035 switch (param
->pid
) {
1037 h
->version
.stlink
= 1;
1040 h
->version
.stlink
= 2;
1044 /* get the device version */
1045 err
= stlink_usb_version(h
);
1047 if (err
!= ERROR_OK
) {
1048 LOG_ERROR("read version failed");
1049 jtag_libusb_close(h
->fd
);
1054 /* compare usb vid/pid */
1055 if ((param
->vid
!= h
->vid
) || (param
->pid
!= h
->pid
))
1056 LOG_INFO("vid/pid are not identical: %04X/%04X %04X/%04X",
1057 param
->vid
, param
->pid
,
1060 /* check if mode is supported */
1063 switch (h
->transport
) {
1064 case STLINK_TRANSPORT_SWD
:
1065 case STLINK_TRANSPORT_JTAG
:
1066 if (h
->version
.jtag
== 0)
1069 case STLINK_TRANSPORT_SWIM
:
1070 if (h
->version
.swim
== 0)
1078 if (err
!= ERROR_OK
) {
1079 LOG_ERROR("mode (transport) not supported by device");
1080 jtag_libusb_close(h
->fd
);
1085 /* set the used jtag api */
1086 h
->jtag_api
= STLINK_JTAG_API_V1
;
1088 /* initialize the debug hardware */
1089 err
= stlink_usb_init_mode(h
);
1091 if (err
!= ERROR_OK
) {
1092 LOG_ERROR("init mode failed");
1093 jtag_libusb_close(h
->fd
);
1104 static int stlink_usb_close(void *fd
)
1110 struct stlink_layout_api_s stlink_usb_layout_api
= {
1112 .open
= stlink_usb_open
,
1114 .close
= stlink_usb_close
,
1116 .idcode
= stlink_usb_idcode
,
1118 .state
= stlink_usb_state
,
1120 .reset
= stlink_usb_reset
,
1122 .run
= stlink_usb_run
,
1124 .halt
= stlink_usb_halt
,
1126 .step
= stlink_usb_step
,
1128 .read_regs
= stlink_usb_read_regs
,
1130 .read_reg
= stlink_usb_read_reg
,
1132 .write_reg
= stlink_usb_write_reg
,
1134 .read_mem8
= stlink_usb_read_mem8
,
1136 .write_mem8
= stlink_usb_write_mem8
,
1138 .read_mem32
= stlink_usb_read_mem32
,
1140 .write_mem32
= stlink_usb_write_mem32
,
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)