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
= 0,
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 * V1 doesn't support API V2 at all
404 * V2 support API V2 since JTAG V13
406 if ((h
->version
.stlink
== 2) && (h
->version
.jtag
> 12))
407 h
->version
.jtag_api_max
= STLINK_JTAG_API_V2
;
409 h
->version
.jtag_api_max
= STLINK_JTAG_API_V1
;
411 LOG_DEBUG("STLINK v%d JTAG v%d API v%d SWIM v%d VID 0x%04X PID 0x%04X",
414 (h
->version
.jtag_api_max
== STLINK_JTAG_API_V1
) ? 1 : 2,
423 static int stlink_usb_current_mode(void *handle
, uint8_t *mode
)
426 struct stlink_usb_handle_s
*h
;
428 assert(handle
!= NULL
);
430 h
= (struct stlink_usb_handle_s
*)handle
;
432 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
434 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_CURRENT_MODE
;
436 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
441 *mode
= h
->databuf
[0];
447 static int stlink_usb_mode_enter(void *handle
, enum stlink_mode type
)
451 struct stlink_usb_handle_s
*h
;
453 assert(handle
!= NULL
);
455 h
= (struct stlink_usb_handle_s
*)handle
;
457 /* on api V2 we are able the read the latest command
459 * TODO: we need the test on api V1 too
461 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
464 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, rx_size
);
467 case STLINK_MODE_DEBUG_JTAG
:
468 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
469 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
470 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_ENTER
;
472 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_ENTER
;
473 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_ENTER_JTAG
;
475 case STLINK_MODE_DEBUG_SWD
:
476 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
477 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
478 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_ENTER
;
480 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_ENTER
;
481 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_ENTER_SWD
;
483 case STLINK_MODE_DEBUG_SWIM
:
484 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
485 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_ENTER
;
487 case STLINK_MODE_DFU
:
488 case STLINK_MODE_MASS
:
493 res
= stlink_usb_xfer(handle
, h
->databuf
, rx_size
);
498 res
= stlink_usb_error_check(h
);
504 static int stlink_usb_mode_leave(void *handle
, enum stlink_mode type
)
507 struct stlink_usb_handle_s
*h
;
509 assert(handle
!= NULL
);
511 h
= (struct stlink_usb_handle_s
*)handle
;
513 stlink_usb_init_buffer(handle
, STLINK_NULL_EP
, 0);
516 case STLINK_MODE_DEBUG_JTAG
:
517 case STLINK_MODE_DEBUG_SWD
:
518 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
519 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_EXIT
;
521 case STLINK_MODE_DEBUG_SWIM
:
522 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
523 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_EXIT
;
525 case STLINK_MODE_DFU
:
526 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DFU_COMMAND
;
527 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DFU_EXIT
;
529 case STLINK_MODE_MASS
:
534 res
= stlink_usb_xfer(handle
, 0, 0);
543 static int stlink_usb_init_mode(void *handle
)
547 enum stlink_mode emode
;
548 struct stlink_usb_handle_s
*h
;
550 assert(handle
!= NULL
);
552 h
= (struct stlink_usb_handle_s
*)handle
;
554 res
= stlink_usb_current_mode(handle
, &mode
);
559 LOG_DEBUG("MODE: 0x%02X", mode
);
561 /* try to exit current mode */
563 case STLINK_DEV_DFU_MODE
:
564 emode
= STLINK_MODE_DFU
;
566 case STLINK_DEV_DEBUG_MODE
:
567 emode
= STLINK_MODE_DEBUG_SWD
;
569 case STLINK_DEV_SWIM_MODE
:
570 emode
= STLINK_MODE_DEBUG_SWIM
;
572 case STLINK_DEV_BOOTLOADER_MODE
:
573 case STLINK_DEV_MASS_MODE
:
575 emode
= STLINK_MODE_UNKNOWN
;
579 if (emode
!= STLINK_MODE_UNKNOWN
) {
580 res
= stlink_usb_mode_leave(handle
, emode
);
586 res
= stlink_usb_current_mode(handle
, &mode
);
591 LOG_DEBUG("MODE: 0x%02X", mode
);
593 /* set selected mode */
594 switch (h
->transport
) {
595 case STLINK_TRANSPORT_SWD
:
596 emode
= STLINK_MODE_DEBUG_SWD
;
598 case STLINK_TRANSPORT_JTAG
:
599 emode
= STLINK_MODE_DEBUG_JTAG
;
601 case STLINK_TRANSPORT_SWIM
:
602 emode
= STLINK_MODE_DEBUG_SWIM
;
605 emode
= STLINK_MODE_UNKNOWN
;
609 if (emode
== STLINK_MODE_UNKNOWN
) {
610 LOG_ERROR("selected mode (transport) not supported");
614 res
= stlink_usb_mode_enter(handle
, emode
);
619 res
= stlink_usb_current_mode(handle
, &mode
);
624 LOG_DEBUG("MODE: 0x%02X", mode
);
630 static int stlink_usb_idcode(void *handle
, uint32_t *idcode
)
633 struct stlink_usb_handle_s
*h
;
635 assert(handle
!= NULL
);
637 h
= (struct stlink_usb_handle_s
*)handle
;
639 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 4);
641 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
642 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READCOREID
;
644 res
= stlink_usb_xfer(handle
, h
->databuf
, 4);
649 *idcode
= le_to_h_u32(h
->databuf
);
651 LOG_DEBUG("IDCODE: 0x%08X", *idcode
);
656 static int stlink_usb_v2_read_debug_reg(void *handle
, uint32_t addr
, uint32_t *val
)
658 struct stlink_usb_handle_s
*h
;
661 assert(handle
!= NULL
);
663 h
= (struct stlink_usb_handle_s
*)handle
;
665 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 8);
667 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
668 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READDEBUGREG
;
669 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
672 res
= stlink_usb_xfer(handle
, h
->databuf
, 8);
677 *val
= le_to_h_u32(h
->databuf
+ 4);
679 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
682 static int stlink_usb_write_debug_reg(void *handle
, uint32_t addr
, uint32_t val
)
685 struct stlink_usb_handle_s
*h
;
687 assert(handle
!= NULL
);
689 h
= (struct stlink_usb_handle_s
*)handle
;
691 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
693 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
694 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
695 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_WRITEDEBUGREG
;
697 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_WRITEDEBUGREG
;
698 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
700 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, val
);
703 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
708 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
711 static enum target_state
stlink_usb_v2_get_status(void *handle
)
716 result
= stlink_usb_v2_read_debug_reg(handle
, DCB_DHCSR
, &status
);
717 if (result
!= ERROR_OK
)
718 return TARGET_UNKNOWN
;
721 return TARGET_HALTED
;
723 return TARGET_RUNNING
;
727 static enum target_state
stlink_usb_state(void *handle
)
730 struct stlink_usb_handle_s
*h
;
732 assert(handle
!= NULL
);
734 h
= (struct stlink_usb_handle_s
*)handle
;
736 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
737 return stlink_usb_v2_get_status(handle
);
739 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
741 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
742 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_GETSTATUS
;
744 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
747 return TARGET_UNKNOWN
;
749 if (h
->databuf
[0] == STLINK_CORE_RUNNING
)
750 return TARGET_RUNNING
;
751 if (h
->databuf
[0] == STLINK_CORE_HALTED
)
752 return TARGET_HALTED
;
754 return TARGET_UNKNOWN
;
758 static int stlink_usb_reset(void *handle
)
761 struct stlink_usb_handle_s
*h
;
763 assert(handle
!= NULL
);
765 h
= (struct stlink_usb_handle_s
*)handle
;
767 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
769 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
771 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
772 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_RESETSYS
;
774 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_RESETSYS
;
776 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
781 LOG_DEBUG("RESET: 0x%08X", h
->databuf
[0]);
783 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
787 static int stlink_usb_run(void *handle
)
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_V2
)
797 return stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_DEBUGEN
);
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_RUNCORE
;
804 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
809 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
813 static int stlink_usb_halt(void *handle
)
816 struct stlink_usb_handle_s
*h
;
818 assert(handle
!= NULL
);
820 h
= (struct stlink_usb_handle_s
*)handle
;
822 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
823 return stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_HALT
|C_DEBUGEN
);
825 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
827 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
828 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_FORCEDEBUG
;
830 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
835 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
839 static int stlink_usb_step(void *handle
)
842 struct stlink_usb_handle_s
*h
;
844 assert(handle
!= NULL
);
846 h
= (struct stlink_usb_handle_s
*)handle
;
848 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
849 return stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_STEP
|C_DEBUGEN
);
851 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
853 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
854 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_STEPCORE
;
856 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
861 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
865 static int stlink_usb_read_regs(void *handle
)
868 struct stlink_usb_handle_s
*h
;
870 assert(handle
!= NULL
);
872 h
= (struct stlink_usb_handle_s
*)handle
;
874 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 84);
876 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
877 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
878 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_READALLREGS
;
880 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READALLREGS
;
882 res
= stlink_usb_xfer(handle
, h
->databuf
, 84);
891 static int stlink_usb_read_reg(void *handle
, int num
, uint32_t *val
)
894 struct stlink_usb_handle_s
*h
;
896 assert(handle
!= NULL
);
898 h
= (struct stlink_usb_handle_s
*)handle
;
900 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, h
->jtag_api
== STLINK_JTAG_API_V1
? 4 : 8);
902 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
903 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
904 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_READREG
;
906 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READREG
;
907 h
->cmdbuf
[h
->cmdidx
++] = num
;
909 res
= stlink_usb_xfer(handle
, h
->databuf
, h
->jtag_api
== STLINK_JTAG_API_V1
? 4 : 8);
914 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
915 *val
= le_to_h_u32(h
->databuf
);
917 *val
= le_to_h_u32(h
->databuf
+ 4);
918 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
925 static int stlink_usb_write_reg(void *handle
, int num
, uint32_t val
)
928 struct stlink_usb_handle_s
*h
;
930 assert(handle
!= NULL
);
932 h
= (struct stlink_usb_handle_s
*)handle
;
934 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
936 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
937 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
938 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_WRITEREG
;
940 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_WRITEREG
;
941 h
->cmdbuf
[h
->cmdidx
++] = num
;
942 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, val
);
945 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
950 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
953 static int stlink_usb_get_rw_status(void *handle
)
956 struct stlink_usb_handle_s
*h
;
958 assert(handle
!= NULL
);
960 h
= (struct stlink_usb_handle_s
*)handle
;
962 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
965 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
967 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
968 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_GETLASTRWSTATUS
;
970 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
975 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: res
;
979 static int stlink_usb_read_mem8(void *handle
, uint32_t addr
, uint16_t len
,
983 uint16_t read_len
= len
;
984 struct stlink_usb_handle_s
*h
;
986 assert(handle
!= NULL
);
988 h
= (struct stlink_usb_handle_s
*)handle
;
990 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, read_len
);
992 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
993 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READMEM_8BIT
;
994 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
996 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
999 /* we need to fix read length for single bytes */
1003 res
= stlink_usb_xfer(handle
, h
->databuf
, read_len
);
1005 if (res
!= ERROR_OK
)
1008 memcpy(buffer
, h
->databuf
, len
);
1010 return stlink_usb_get_rw_status(handle
);
1014 static int stlink_usb_write_mem8(void *handle
, uint32_t addr
, uint16_t len
,
1015 const uint8_t *buffer
)
1018 struct stlink_usb_handle_s
*h
;
1020 assert(handle
!= NULL
);
1022 h
= (struct stlink_usb_handle_s
*)handle
;
1024 stlink_usb_init_buffer(handle
, STLINK_TX_EP
, len
);
1026 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1027 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_WRITEMEM_8BIT
;
1028 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1030 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1033 res
= stlink_usb_xfer(handle
, buffer
, len
);
1035 if (res
!= ERROR_OK
)
1038 return stlink_usb_get_rw_status(handle
);
1042 static int stlink_usb_read_mem32(void *handle
, uint32_t addr
, uint16_t len
,
1046 struct stlink_usb_handle_s
*h
;
1048 assert(handle
!= NULL
);
1050 h
= (struct stlink_usb_handle_s
*)handle
;
1054 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, len
);
1056 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1057 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READMEM_32BIT
;
1058 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1060 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1063 res
= stlink_usb_xfer(handle
, h
->databuf
, len
);
1065 if (res
!= ERROR_OK
)
1068 memcpy(buffer
, h
->databuf
, len
);
1070 return stlink_usb_get_rw_status(handle
);
1074 static int stlink_usb_write_mem32(void *handle
, uint32_t addr
, uint16_t len
,
1075 const uint8_t *buffer
)
1078 struct stlink_usb_handle_s
*h
;
1080 assert(handle
!= NULL
);
1082 h
= (struct stlink_usb_handle_s
*)handle
;
1086 stlink_usb_init_buffer(handle
, STLINK_TX_EP
, len
);
1088 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1089 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_WRITEMEM_32BIT
;
1090 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1092 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1095 res
= stlink_usb_xfer(handle
, buffer
, len
);
1097 if (res
!= ERROR_OK
)
1100 return stlink_usb_get_rw_status(handle
);
1104 static int stlink_usb_open(struct stlink_interface_param_s
*param
, void **fd
)
1107 struct stlink_usb_handle_s
*h
;
1109 LOG_DEBUG("stlink_usb_open");
1111 h
= malloc(sizeof(struct stlink_usb_handle_s
));
1114 LOG_DEBUG("malloc failed");
1118 h
->transport
= param
->transport
;
1120 const uint16_t vids
[] = { param
->vid
, 0 };
1121 const uint16_t pids
[] = { param
->pid
, 0 };
1123 LOG_DEBUG("transport: %d vid: 0x%04x pid: 0x%04x", param
->transport
,
1124 param
->vid
, param
->pid
);
1126 if (jtag_libusb_open(vids
, pids
, &h
->fd
) != ERROR_OK
) {
1127 LOG_ERROR("open failed");
1131 jtag_libusb_set_configuration(h
->fd
, 0);
1133 if (jtag_libusb_claim_interface(h
->fd
, 0) != ERROR_OK
) {
1134 LOG_DEBUG("claim interface failed");
1138 /* wrap version for first read */
1139 switch (param
->pid
) {
1141 h
->version
.stlink
= 1;
1144 h
->version
.stlink
= 2;
1148 /* get the device version */
1149 err
= stlink_usb_version(h
);
1151 if (err
!= ERROR_OK
) {
1152 LOG_ERROR("read version failed");
1153 jtag_libusb_close(h
->fd
);
1158 /* compare usb vid/pid */
1159 if ((param
->vid
!= h
->vid
) || (param
->pid
!= h
->pid
))
1160 LOG_INFO("vid/pid are not identical: 0x%04X/0x%04X 0x%04X/0x%04X",
1161 param
->vid
, param
->pid
,
1164 /* check if mode is supported */
1167 switch (h
->transport
) {
1168 case STLINK_TRANSPORT_SWD
:
1169 case STLINK_TRANSPORT_JTAG
:
1170 if (h
->version
.jtag
== 0)
1173 case STLINK_TRANSPORT_SWIM
:
1174 if (h
->version
.swim
== 0)
1182 if (err
!= ERROR_OK
) {
1183 LOG_ERROR("mode (transport) not supported by device");
1184 jtag_libusb_close(h
->fd
);
1189 /* set the used jtag api */
1190 h
->jtag_api
= STLINK_JTAG_API_V1
;
1192 /* initialize the debug hardware */
1193 err
= stlink_usb_init_mode(h
);
1195 if (err
!= ERROR_OK
) {
1196 LOG_ERROR("init mode failed");
1197 jtag_libusb_close(h
->fd
);
1208 static int stlink_usb_close(void *fd
)
1214 struct stlink_layout_api_s stlink_usb_layout_api
= {
1216 .open
= stlink_usb_open
,
1218 .close
= stlink_usb_close
,
1220 .idcode
= stlink_usb_idcode
,
1222 .state
= stlink_usb_state
,
1224 .reset
= stlink_usb_reset
,
1226 .run
= stlink_usb_run
,
1228 .halt
= stlink_usb_halt
,
1230 .step
= stlink_usb_step
,
1232 .read_regs
= stlink_usb_read_regs
,
1234 .read_reg
= stlink_usb_read_reg
,
1236 .write_reg
= stlink_usb_write_reg
,
1238 .read_mem8
= stlink_usb_read_mem8
,
1240 .write_mem8
= stlink_usb_write_mem8
,
1242 .read_mem32
= stlink_usb_read_mem32
,
1244 .write_mem32
= stlink_usb_write_mem32
,