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 <target/cortex_m.h>
37 #include "libusb_common.h"
39 #define ENDPOINT_IN 0x80
40 #define ENDPOINT_OUT 0x00
42 #define STLINK_NULL_EP 0
43 #define STLINK_RX_EP (1|ENDPOINT_IN)
44 #define STLINK_TX_EP (2|ENDPOINT_OUT)
45 #define STLINK_SG_SIZE (31)
46 #define STLINK_DATA_SIZE (4*128)
47 #define STLINK_CMD_SIZE_V2 (16)
48 #define STLINK_CMD_SIZE_V1 (10)
50 enum stlink_jtag_api_version
{
51 STLINK_JTAG_API_V1
= 1,
56 struct stlink_usb_version
{
63 /** highest supported jtag api version */
64 enum stlink_jtag_api_version jtag_api_max
;
68 struct stlink_usb_handle_s
{
70 struct jtag_libusb_device_handle
*fd
;
72 struct libusb_transfer
*trans
;
74 uint8_t cmdbuf
[STLINK_SG_SIZE
];
80 uint8_t databuf
[STLINK_DATA_SIZE
];
82 enum stlink_transports transport
;
84 struct stlink_usb_version version
;
89 /** this is the currently used jtag api */
90 enum stlink_jtag_api_version jtag_api
;
93 #define STLINK_DEBUG_ERR_OK 0x80
94 #define STLINK_DEBUG_ERR_FAULT 0x81
95 #define STLINK_CORE_RUNNING 0x80
96 #define STLINK_CORE_HALTED 0x81
97 #define STLINK_CORE_STAT_UNKNOWN -1
99 #define STLINK_GET_VERSION 0xF1
100 #define STLINK_DEBUG_COMMAND 0xF2
101 #define STLINK_DFU_COMMAND 0xF3
102 #define STLINK_SWIM_COMMAND 0xF4
103 #define STLINK_GET_CURRENT_MODE 0xF5
105 #define STLINK_DEV_DFU_MODE 0x00
106 #define STLINK_DEV_MASS_MODE 0x01
107 #define STLINK_DEV_DEBUG_MODE 0x02
108 #define STLINK_DEV_SWIM_MODE 0x03
109 #define STLINK_DEV_BOOTLOADER_MODE 0x04
110 #define STLINK_DEV_UNKNOWN_MODE -1
112 #define STLINK_DFU_EXIT 0x07
114 #define STLINK_SWIM_ENTER 0x00
115 #define STLINK_SWIM_EXIT 0x01
117 #define STLINK_DEBUG_ENTER_JTAG 0x00
118 #define STLINK_DEBUG_GETSTATUS 0x01
119 #define STLINK_DEBUG_FORCEDEBUG 0x02
120 #define STLINK_DEBUG_APIV1_RESETSYS 0x03
121 #define STLINK_DEBUG_APIV1_READALLREGS 0x04
122 #define STLINK_DEBUG_APIV1_READREG 0x05
123 #define STLINK_DEBUG_APIV1_WRITEREG 0x06
124 #define STLINK_DEBUG_READMEM_32BIT 0x07
125 #define STLINK_DEBUG_WRITEMEM_32BIT 0x08
126 #define STLINK_DEBUG_RUNCORE 0x09
127 #define STLINK_DEBUG_STEPCORE 0x0a
128 #define STLINK_DEBUG_APIV1_SETFP 0x0b
129 #define STLINK_DEBUG_READMEM_8BIT 0x0c
130 #define STLINK_DEBUG_WRITEMEM_8BIT 0x0d
131 #define STLINK_DEBUG_APIV1_CLEARFP 0x0e
132 #define STLINK_DEBUG_APIV1_WRITEDEBUGREG 0x0f
133 #define STLINK_DEBUG_APIV1_SETWATCHPOINT 0x10
135 #define STLINK_DEBUG_ENTER_JTAG 0x00
136 #define STLINK_DEBUG_ENTER_SWD 0xa3
138 #define STLINK_DEBUG_APIV1_ENTER 0x20
139 #define STLINK_DEBUG_EXIT 0x21
140 #define STLINK_DEBUG_READCOREID 0x22
142 #define STLINK_DEBUG_APIV2_ENTER 0x30
143 #define STLINK_DEBUG_APIV2_READ_IDCODES 0x31
144 #define STLINK_DEBUG_APIV2_RESETSYS 0x32
145 #define STLINK_DEBUG_APIV2_READREG 0x33
146 #define STLINK_DEBUG_APIV2_WRITEREG 0x34
147 #define STLINK_DEBUG_APIV2_WRITEDEBUGREG 0x35
148 #define STLINK_DEBUG_APIV2_READDEBUGREG 0x36
150 #define STLINK_DEBUG_APIV2_READALLREGS 0x3A
151 #define STLINK_DEBUG_APIV2_GETLASTRWSTATUS 0x3B
152 #define STLINK_DEBUG_APIV2_DRIVE_NRST 0x3C
154 #define STLINK_DEBUG_APIV2_DRIVE_NRST_LOW 0x00
155 #define STLINK_DEBUG_APIV2_DRIVE_NRST_HIGH 0x01
156 #define STLINK_DEBUG_APIV2_DRIVE_NRST_PULSE 0x02
160 STLINK_MODE_UNKNOWN
= 0,
163 STLINK_MODE_DEBUG_JTAG
,
164 STLINK_MODE_DEBUG_SWD
,
165 STLINK_MODE_DEBUG_SWIM
168 #define REQUEST_SENSE 0x03
169 #define REQUEST_SENSE_LENGTH 18
171 static void stlink_usb_init_buffer(void *handle
, uint8_t direction
, uint32_t size
);
174 static int stlink_usb_xfer_v1_get_status(void *handle
)
176 struct stlink_usb_handle_s
*h
;
178 assert(handle
!= NULL
);
180 h
= (struct stlink_usb_handle_s
*)handle
;
183 memset(h
->cmdbuf
, 0, STLINK_SG_SIZE
);
185 if (jtag_libusb_bulk_read(h
->fd
, STLINK_RX_EP
, (char *)h
->cmdbuf
,
191 t1
= buf_get_u32(h
->cmdbuf
, 0, 32);
194 if (t1
!= 0x53425355)
202 if (h
->cmdbuf
[12] != 0)
209 static int stlink_usb_xfer_rw(void *handle
, int cmdsize
, const uint8_t *buf
, int size
)
211 struct stlink_usb_handle_s
*h
;
213 assert(handle
!= NULL
);
215 h
= (struct stlink_usb_handle_s
*)handle
;
217 if (jtag_libusb_bulk_write(h
->fd
, STLINK_TX_EP
, (char *)h
->cmdbuf
, cmdsize
,
222 if (h
->direction
== STLINK_TX_EP
&& size
) {
223 if (jtag_libusb_bulk_write(h
->fd
, STLINK_TX_EP
, (char *)buf
,
224 size
, 1000) != size
) {
225 LOG_DEBUG("bulk write failed");
228 } else if (h
->direction
== STLINK_RX_EP
&& size
) {
229 if (jtag_libusb_bulk_read(h
->fd
, STLINK_RX_EP
, (char *)buf
,
230 size
, 1000) != size
) {
231 LOG_DEBUG("bulk read failed");
240 static int stlink_usb_xfer_v1_get_sense(void *handle
)
243 struct stlink_usb_handle_s
*h
;
245 assert(handle
!= NULL
);
247 h
= (struct stlink_usb_handle_s
*)handle
;
249 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 16);
251 h
->cmdbuf
[h
->cmdidx
++] = REQUEST_SENSE
;
252 h
->cmdbuf
[h
->cmdidx
++] = 0;
253 h
->cmdbuf
[h
->cmdidx
++] = 0;
254 h
->cmdbuf
[h
->cmdidx
++] = 0;
255 h
->cmdbuf
[h
->cmdidx
++] = REQUEST_SENSE_LENGTH
;
257 res
= stlink_usb_xfer_rw(handle
, REQUEST_SENSE_LENGTH
, h
->databuf
, 16);
262 if (stlink_usb_xfer_v1_get_status(handle
) != ERROR_OK
)
269 static int stlink_usb_xfer(void *handle
, const uint8_t *buf
, int size
)
271 int err
, cmdsize
= STLINK_CMD_SIZE_V2
;
272 struct stlink_usb_handle_s
*h
;
274 assert(handle
!= NULL
);
276 h
= (struct stlink_usb_handle_s
*)handle
;
278 if (h
->version
.stlink
== 1)
279 cmdsize
= STLINK_SG_SIZE
;
281 err
= stlink_usb_xfer_rw(handle
, cmdsize
, buf
, size
);
286 if (h
->version
.stlink
== 1) {
287 if (stlink_usb_xfer_v1_get_status(handle
) != ERROR_OK
) {
288 /* check csw status */
289 if (h
->cmdbuf
[12] == 1) {
290 LOG_DEBUG("get sense");
291 if (stlink_usb_xfer_v1_get_sense(handle
) != ERROR_OK
)
302 static void stlink_usb_xfer_v1_create_cmd(void *handle
, uint8_t direction
, uint32_t size
)
304 struct stlink_usb_handle_s
*h
;
306 h
= (struct stlink_usb_handle_s
*)handle
;
308 /* fill the send buffer */
309 strcpy((char *)h
->cmdbuf
, "USBC");
311 /* csw tag not used */
313 buf_set_u32(h
->cmdbuf
+h
->cmdidx
, 0, 32, size
);
315 h
->cmdbuf
[h
->cmdidx
++] = (direction
== STLINK_RX_EP
? ENDPOINT_IN
: ENDPOINT_OUT
);
316 h
->cmdbuf
[h
->cmdidx
++] = 0; /* lun */
317 h
->cmdbuf
[h
->cmdidx
++] = STLINK_CMD_SIZE_V1
;
321 static void stlink_usb_init_buffer(void *handle
, uint8_t direction
, uint32_t size
)
323 struct stlink_usb_handle_s
*h
;
325 h
= (struct stlink_usb_handle_s
*)handle
;
327 h
->direction
= direction
;
331 memset(h
->cmdbuf
, 0, STLINK_SG_SIZE
);
332 memset(h
->databuf
, 0, STLINK_DATA_SIZE
);
334 if (h
->version
.stlink
== 1)
335 stlink_usb_xfer_v1_create_cmd(handle
, direction
, size
);
338 static const char * const stlink_usb_error_msg
[] = {
343 static int stlink_usb_error_check(void *handle
)
346 const char *err_msg
= 0;
347 struct stlink_usb_handle_s
*h
;
349 assert(handle
!= NULL
);
351 h
= (struct stlink_usb_handle_s
*)handle
;
353 /* TODO: no error checking yet on api V1 */
354 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
355 h
->databuf
[0] = STLINK_DEBUG_ERR_OK
;
357 switch (h
->databuf
[0]) {
358 case STLINK_DEBUG_ERR_OK
:
361 case STLINK_DEBUG_ERR_FAULT
:
363 err_msg
= stlink_usb_error_msg
[0];
369 LOG_DEBUG("status error: %d ('%s')", h
->databuf
[0], err_msg
);
375 static int stlink_usb_version(void *handle
)
379 struct stlink_usb_handle_s
*h
;
381 assert(handle
!= NULL
);
383 h
= (struct stlink_usb_handle_s
*)handle
;
385 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 6);
387 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_VERSION
;
389 res
= stlink_usb_xfer(handle
, h
->databuf
, 6);
394 v
= (h
->databuf
[0] << 8) | h
->databuf
[1];
396 h
->version
.stlink
= (v
>> 12) & 0x0f;
397 h
->version
.jtag
= (v
>> 6) & 0x3f;
398 h
->version
.swim
= v
& 0x3f;
399 h
->vid
= buf_get_u32(h
->databuf
, 16, 16);
400 h
->pid
= buf_get_u32(h
->databuf
, 32, 16);
402 /* set the supported jtag api version
403 * API V2 is supported since JTAG V11
405 if (h
->version
.jtag
>= 11)
406 h
->version
.jtag_api_max
= STLINK_JTAG_API_V2
;
408 h
->version
.jtag_api_max
= STLINK_JTAG_API_V1
;
410 LOG_DEBUG("STLINK v%d JTAG v%d API v%d SWIM v%d VID 0x%04X PID 0x%04X",
413 (h
->version
.jtag_api_max
== STLINK_JTAG_API_V1
) ? 1 : 2,
422 static int stlink_usb_current_mode(void *handle
, uint8_t *mode
)
425 struct stlink_usb_handle_s
*h
;
427 assert(handle
!= NULL
);
429 h
= (struct stlink_usb_handle_s
*)handle
;
431 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
433 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_CURRENT_MODE
;
435 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
440 *mode
= h
->databuf
[0];
446 static int stlink_usb_mode_enter(void *handle
, enum stlink_mode type
)
450 struct stlink_usb_handle_s
*h
;
452 assert(handle
!= NULL
);
454 h
= (struct stlink_usb_handle_s
*)handle
;
456 /* on api V2 we are able the read the latest command
458 * TODO: we need the test on api V1 too
460 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
463 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, rx_size
);
466 case STLINK_MODE_DEBUG_JTAG
:
467 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
468 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
469 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_ENTER
;
471 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_ENTER
;
472 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_ENTER_JTAG
;
474 case STLINK_MODE_DEBUG_SWD
:
475 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
476 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
477 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_ENTER
;
479 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_ENTER
;
480 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_ENTER_SWD
;
482 case STLINK_MODE_DEBUG_SWIM
:
483 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
484 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_ENTER
;
486 case STLINK_MODE_DFU
:
487 case STLINK_MODE_MASS
:
492 res
= stlink_usb_xfer(handle
, h
->databuf
, rx_size
);
497 res
= stlink_usb_error_check(h
);
503 static int stlink_usb_mode_leave(void *handle
, enum stlink_mode type
)
506 struct stlink_usb_handle_s
*h
;
508 assert(handle
!= NULL
);
510 h
= (struct stlink_usb_handle_s
*)handle
;
512 stlink_usb_init_buffer(handle
, STLINK_NULL_EP
, 0);
515 case STLINK_MODE_DEBUG_JTAG
:
516 case STLINK_MODE_DEBUG_SWD
:
517 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
518 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_EXIT
;
520 case STLINK_MODE_DEBUG_SWIM
:
521 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
522 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_EXIT
;
524 case STLINK_MODE_DFU
:
525 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DFU_COMMAND
;
526 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DFU_EXIT
;
528 case STLINK_MODE_MASS
:
533 res
= stlink_usb_xfer(handle
, 0, 0);
542 static int stlink_usb_init_mode(void *handle
)
546 enum stlink_mode emode
;
547 struct stlink_usb_handle_s
*h
;
549 assert(handle
!= NULL
);
551 h
= (struct stlink_usb_handle_s
*)handle
;
553 res
= stlink_usb_current_mode(handle
, &mode
);
558 LOG_DEBUG("MODE: 0x%02X", mode
);
560 /* try to exit current mode */
562 case STLINK_DEV_DFU_MODE
:
563 emode
= STLINK_MODE_DFU
;
565 case STLINK_DEV_DEBUG_MODE
:
566 emode
= STLINK_MODE_DEBUG_SWD
;
568 case STLINK_DEV_SWIM_MODE
:
569 emode
= STLINK_MODE_DEBUG_SWIM
;
571 case STLINK_DEV_BOOTLOADER_MODE
:
572 case STLINK_DEV_MASS_MODE
:
574 emode
= STLINK_MODE_UNKNOWN
;
578 if (emode
!= STLINK_MODE_UNKNOWN
) {
579 res
= stlink_usb_mode_leave(handle
, emode
);
585 res
= stlink_usb_current_mode(handle
, &mode
);
590 LOG_DEBUG("MODE: 0x%02X", mode
);
592 /* set selected mode */
593 switch (h
->transport
) {
594 case STLINK_TRANSPORT_SWD
:
595 emode
= STLINK_MODE_DEBUG_SWD
;
597 case STLINK_TRANSPORT_JTAG
:
598 emode
= STLINK_MODE_DEBUG_JTAG
;
600 case STLINK_TRANSPORT_SWIM
:
601 emode
= STLINK_MODE_DEBUG_SWIM
;
604 emode
= STLINK_MODE_UNKNOWN
;
608 if (emode
== STLINK_MODE_UNKNOWN
) {
609 LOG_ERROR("selected mode (transport) not supported");
613 res
= stlink_usb_mode_enter(handle
, emode
);
618 res
= stlink_usb_current_mode(handle
, &mode
);
623 LOG_DEBUG("MODE: 0x%02X", mode
);
629 static int stlink_usb_idcode(void *handle
, uint32_t *idcode
)
632 struct stlink_usb_handle_s
*h
;
634 assert(handle
!= NULL
);
636 h
= (struct stlink_usb_handle_s
*)handle
;
638 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 4);
640 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
641 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READCOREID
;
643 res
= stlink_usb_xfer(handle
, h
->databuf
, 4);
648 *idcode
= le_to_h_u32(h
->databuf
);
650 LOG_DEBUG("IDCODE: 0x%08X", *idcode
);
655 static int stlink_usb_v2_read_debug_reg(void *handle
, uint32_t addr
, uint32_t *val
)
657 struct stlink_usb_handle_s
*h
;
660 assert(handle
!= NULL
);
662 h
= (struct stlink_usb_handle_s
*)handle
;
664 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 8);
666 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
667 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READDEBUGREG
;
668 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
671 res
= stlink_usb_xfer(handle
, h
->databuf
, 8);
676 *val
= le_to_h_u32(h
->databuf
+ 4);
678 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
681 static int stlink_usb_write_debug_reg(void *handle
, uint32_t addr
, uint32_t val
)
684 struct stlink_usb_handle_s
*h
;
686 assert(handle
!= NULL
);
688 h
= (struct stlink_usb_handle_s
*)handle
;
690 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
692 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
693 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
694 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_WRITEDEBUGREG
;
696 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_WRITEDEBUGREG
;
697 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
699 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, val
);
702 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
707 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
710 static enum target_state
stlink_usb_v2_get_status(void *handle
)
715 result
= stlink_usb_v2_read_debug_reg(handle
, DCB_DHCSR
, &status
);
716 if (result
!= ERROR_OK
)
717 return TARGET_UNKNOWN
;
720 return TARGET_HALTED
;
721 else if (status
& S_RESET_ST
)
724 return TARGET_RUNNING
;
728 static enum target_state
stlink_usb_state(void *handle
)
731 struct stlink_usb_handle_s
*h
;
733 assert(handle
!= NULL
);
735 h
= (struct stlink_usb_handle_s
*)handle
;
737 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
738 return stlink_usb_v2_get_status(handle
);
740 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
742 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
743 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_GETSTATUS
;
745 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
748 return TARGET_UNKNOWN
;
750 if (h
->databuf
[0] == STLINK_CORE_RUNNING
)
751 return TARGET_RUNNING
;
752 if (h
->databuf
[0] == STLINK_CORE_HALTED
)
753 return TARGET_HALTED
;
755 return TARGET_UNKNOWN
;
759 static int stlink_usb_reset(void *handle
)
762 struct stlink_usb_handle_s
*h
;
764 assert(handle
!= NULL
);
766 h
= (struct stlink_usb_handle_s
*)handle
;
768 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
770 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
772 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
773 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_RESETSYS
;
775 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_RESETSYS
;
777 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
782 LOG_DEBUG("RESET: 0x%08X", h
->databuf
[0]);
784 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
787 static int stlink_usb_assert_srst(void *handle
, int srst
)
790 struct stlink_usb_handle_s
*h
;
792 assert(handle
!= NULL
);
794 h
= (struct stlink_usb_handle_s
*)handle
;
796 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
797 return ERROR_COMMAND_NOTFOUND
;
799 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
801 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
802 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_DRIVE_NRST
;
803 h
->cmdbuf
[h
->cmdidx
++] = srst
;
805 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
810 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
814 static int stlink_usb_run(void *handle
)
817 struct stlink_usb_handle_s
*h
;
819 assert(handle
!= NULL
);
821 h
= (struct stlink_usb_handle_s
*)handle
;
823 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
824 return stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_DEBUGEN
);
826 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
828 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
829 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_RUNCORE
;
831 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
836 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
840 static int stlink_usb_halt(void *handle
)
843 struct stlink_usb_handle_s
*h
;
845 assert(handle
!= NULL
);
847 h
= (struct stlink_usb_handle_s
*)handle
;
849 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
850 return stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_HALT
|C_DEBUGEN
);
852 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
854 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
855 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_FORCEDEBUG
;
857 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
862 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
866 static int stlink_usb_step(void *handle
)
869 struct stlink_usb_handle_s
*h
;
871 assert(handle
!= NULL
);
873 h
= (struct stlink_usb_handle_s
*)handle
;
875 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
876 return stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_STEP
|C_DEBUGEN
);
878 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
880 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
881 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_STEPCORE
;
883 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
888 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
892 static int stlink_usb_read_regs(void *handle
)
895 struct stlink_usb_handle_s
*h
;
897 assert(handle
!= NULL
);
899 h
= (struct stlink_usb_handle_s
*)handle
;
901 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 84);
903 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
904 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
905 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_READALLREGS
;
907 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READALLREGS
;
909 res
= stlink_usb_xfer(handle
, h
->databuf
, 84);
918 static int stlink_usb_read_reg(void *handle
, int num
, uint32_t *val
)
921 struct stlink_usb_handle_s
*h
;
923 assert(handle
!= NULL
);
925 h
= (struct stlink_usb_handle_s
*)handle
;
927 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, h
->jtag_api
== STLINK_JTAG_API_V1
? 4 : 8);
929 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
930 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
931 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_READREG
;
933 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READREG
;
934 h
->cmdbuf
[h
->cmdidx
++] = num
;
936 res
= stlink_usb_xfer(handle
, h
->databuf
, h
->jtag_api
== STLINK_JTAG_API_V1
? 4 : 8);
941 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
942 *val
= le_to_h_u32(h
->databuf
);
944 *val
= le_to_h_u32(h
->databuf
+ 4);
945 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
952 static int stlink_usb_write_reg(void *handle
, int num
, uint32_t val
)
955 struct stlink_usb_handle_s
*h
;
957 assert(handle
!= NULL
);
959 h
= (struct stlink_usb_handle_s
*)handle
;
961 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
963 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
964 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
965 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_WRITEREG
;
967 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_WRITEREG
;
968 h
->cmdbuf
[h
->cmdidx
++] = num
;
969 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, val
);
972 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
977 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
980 static int stlink_usb_get_rw_status(void *handle
)
983 struct stlink_usb_handle_s
*h
;
985 assert(handle
!= NULL
);
987 h
= (struct stlink_usb_handle_s
*)handle
;
989 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
992 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
994 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
995 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_GETLASTRWSTATUS
;
997 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
1002 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: res
;
1006 static int stlink_usb_read_mem8(void *handle
, uint32_t addr
, uint16_t len
,
1010 uint16_t read_len
= len
;
1011 struct stlink_usb_handle_s
*h
;
1013 assert(handle
!= NULL
);
1015 h
= (struct stlink_usb_handle_s
*)handle
;
1017 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, read_len
);
1019 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1020 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READMEM_8BIT
;
1021 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1023 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1026 /* we need to fix read length for single bytes */
1030 res
= stlink_usb_xfer(handle
, h
->databuf
, read_len
);
1032 if (res
!= ERROR_OK
)
1035 memcpy(buffer
, h
->databuf
, len
);
1037 return stlink_usb_get_rw_status(handle
);
1041 static int stlink_usb_write_mem8(void *handle
, uint32_t addr
, uint16_t len
,
1042 const uint8_t *buffer
)
1045 struct stlink_usb_handle_s
*h
;
1047 assert(handle
!= NULL
);
1049 h
= (struct stlink_usb_handle_s
*)handle
;
1051 stlink_usb_init_buffer(handle
, STLINK_TX_EP
, len
);
1053 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1054 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_WRITEMEM_8BIT
;
1055 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1057 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1060 res
= stlink_usb_xfer(handle
, buffer
, len
);
1062 if (res
!= ERROR_OK
)
1065 return stlink_usb_get_rw_status(handle
);
1069 static int stlink_usb_read_mem32(void *handle
, uint32_t addr
, uint16_t len
,
1073 struct stlink_usb_handle_s
*h
;
1075 assert(handle
!= NULL
);
1077 h
= (struct stlink_usb_handle_s
*)handle
;
1081 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, len
);
1083 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1084 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READMEM_32BIT
;
1085 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1087 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1090 res
= stlink_usb_xfer(handle
, h
->databuf
, len
);
1092 if (res
!= ERROR_OK
)
1095 memcpy(buffer
, h
->databuf
, len
);
1097 return stlink_usb_get_rw_status(handle
);
1101 static int stlink_usb_write_mem32(void *handle
, uint32_t addr
, uint16_t len
,
1102 const uint8_t *buffer
)
1105 struct stlink_usb_handle_s
*h
;
1107 assert(handle
!= NULL
);
1109 h
= (struct stlink_usb_handle_s
*)handle
;
1113 stlink_usb_init_buffer(handle
, STLINK_TX_EP
, len
);
1115 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1116 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_WRITEMEM_32BIT
;
1117 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1119 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1122 res
= stlink_usb_xfer(handle
, buffer
, len
);
1124 if (res
!= ERROR_OK
)
1127 return stlink_usb_get_rw_status(handle
);
1131 static int stlink_usb_open(struct stlink_interface_param_s
*param
, void **fd
)
1134 struct stlink_usb_handle_s
*h
;
1135 enum stlink_jtag_api_version api
;
1137 LOG_DEBUG("stlink_usb_open");
1139 h
= malloc(sizeof(struct stlink_usb_handle_s
));
1142 LOG_DEBUG("malloc failed");
1146 h
->transport
= param
->transport
;
1148 const uint16_t vids
[] = { param
->vid
, 0 };
1149 const uint16_t pids
[] = { param
->pid
, 0 };
1151 LOG_DEBUG("transport: %d vid: 0x%04x pid: 0x%04x", param
->transport
,
1152 param
->vid
, param
->pid
);
1154 if (jtag_libusb_open(vids
, pids
, &h
->fd
) != ERROR_OK
) {
1155 LOG_ERROR("open failed");
1159 jtag_libusb_set_configuration(h
->fd
, 0);
1161 if (jtag_libusb_claim_interface(h
->fd
, 0) != ERROR_OK
) {
1162 LOG_DEBUG("claim interface failed");
1166 /* wrap version for first read */
1167 switch (param
->pid
) {
1169 h
->version
.stlink
= 1;
1172 h
->version
.stlink
= 2;
1176 /* get the device version */
1177 err
= stlink_usb_version(h
);
1179 if (err
!= ERROR_OK
) {
1180 LOG_ERROR("read version failed");
1181 jtag_libusb_close(h
->fd
);
1186 /* compare usb vid/pid */
1187 if ((param
->vid
!= h
->vid
) || (param
->pid
!= h
->pid
))
1188 LOG_INFO("vid/pid are not identical: 0x%04X/0x%04X 0x%04X/0x%04X",
1189 param
->vid
, param
->pid
,
1192 /* check if mode is supported */
1195 switch (h
->transport
) {
1196 case STLINK_TRANSPORT_SWD
:
1197 case STLINK_TRANSPORT_JTAG
:
1198 if (h
->version
.jtag
== 0)
1201 case STLINK_TRANSPORT_SWIM
:
1202 if (h
->version
.swim
== 0)
1210 if (err
!= ERROR_OK
) {
1211 LOG_ERROR("mode (transport) not supported by device");
1212 jtag_libusb_close(h
->fd
);
1217 api
= h
->version
.jtag_api_max
;
1219 /* check that user has not requested certain api version
1220 * and if they have check it is supported */
1221 if ((param
->api
!= 0) && (param
->api
<= h
->version
.jtag_api_max
)) {
1223 LOG_INFO("using stlink api v%d", api
);
1226 /* set the used jtag api, this will default to the newest supported version */
1229 /* initialize the debug hardware */
1230 err
= stlink_usb_init_mode(h
);
1232 if (err
!= ERROR_OK
) {
1233 LOG_ERROR("init mode failed");
1234 jtag_libusb_close(h
->fd
);
1245 static int stlink_usb_close(void *fd
)
1251 struct stlink_layout_api_s stlink_usb_layout_api
= {
1253 .open
= stlink_usb_open
,
1255 .close
= stlink_usb_close
,
1257 .idcode
= stlink_usb_idcode
,
1259 .state
= stlink_usb_state
,
1261 .reset
= stlink_usb_reset
,
1263 .assert_srst
= stlink_usb_assert_srst
,
1265 .run
= stlink_usb_run
,
1267 .halt
= stlink_usb_halt
,
1269 .step
= stlink_usb_step
,
1271 .read_regs
= stlink_usb_read_regs
,
1273 .read_reg
= stlink_usb_read_reg
,
1275 .write_reg
= stlink_usb_write_reg
,
1277 .read_mem8
= stlink_usb_read_mem8
,
1279 .write_mem8
= stlink_usb_write_mem8
,
1281 .read_mem32
= stlink_usb_read_mem32
,
1283 .write_mem32
= stlink_usb_write_mem32
,
1285 .write_debug_reg
= stlink_usb_write_debug_reg