1 /***************************************************************************
2 * Copyright (C) 2011-2012 by Mathias Kuester *
3 * Mathias Kuester <kesmtp@freenet.de> *
5 * Copyright (C) 2012 by Spencer Oliver *
6 * spen@spen-soft.co.uk *
8 * This code is based on https://github.com/texane/stlink *
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. *
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. *
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 ***************************************************************************/
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>
38 #include <target/cortex_m.h>
40 #include "libusb_common.h"
42 #define ENDPOINT_IN 0x80
43 #define ENDPOINT_OUT 0x00
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)
53 enum stlink_jtag_api_version
{
54 STLINK_JTAG_API_V1
= 1,
59 struct stlink_usb_version
{
66 /** highest supported jtag api version */
67 enum stlink_jtag_api_version jtag_api_max
;
71 struct stlink_usb_handle_s
{
73 struct jtag_libusb_device_handle
*fd
;
75 struct libusb_transfer
*trans
;
77 uint8_t cmdbuf
[STLINK_SG_SIZE
];
83 uint8_t databuf
[STLINK_DATA_SIZE
];
85 enum hl_transports transport
;
87 struct stlink_usb_version version
;
92 /** this is the currently used jtag api */
93 enum stlink_jtag_api_version jtag_api
;
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
101 #define STLINK_CORE_RUNNING 0x80
102 #define STLINK_CORE_HALTED 0x81
103 #define STLINK_CORE_STAT_UNKNOWN -1
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
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
119 #define STLINK_DFU_EXIT 0x07
121 #define STLINK_SWIM_ENTER 0x00
122 #define STLINK_SWIM_EXIT 0x01
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
142 #define STLINK_DEBUG_ENTER_JTAG 0x00
143 #define STLINK_DEBUG_ENTER_SWD 0xa3
145 #define STLINK_DEBUG_APIV1_ENTER 0x20
146 #define STLINK_DEBUG_EXIT 0x21
147 #define STLINK_DEBUG_READCOREID 0x22
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
157 #define STLINK_DEBUG_APIV2_READALLREGS 0x3A
158 #define STLINK_DEBUG_APIV2_GETLASTRWSTATUS 0x3B
159 #define STLINK_DEBUG_APIV2_DRIVE_NRST 0x3C
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
167 STLINK_MODE_UNKNOWN
= 0,
170 STLINK_MODE_DEBUG_JTAG
,
171 STLINK_MODE_DEBUG_SWD
,
172 STLINK_MODE_DEBUG_SWIM
175 #define REQUEST_SENSE 0x03
176 #define REQUEST_SENSE_LENGTH 18
178 static void stlink_usb_init_buffer(void *handle
, uint8_t direction
, uint32_t size
);
181 static int stlink_usb_xfer_v1_get_status(void *handle
)
183 struct stlink_usb_handle_s
*h
;
185 assert(handle
!= NULL
);
187 h
= (struct stlink_usb_handle_s
*)handle
;
190 memset(h
->cmdbuf
, 0, STLINK_SG_SIZE
);
192 if (jtag_libusb_bulk_read(h
->fd
, STLINK_RX_EP
, (char *)h
->cmdbuf
,
198 t1
= buf_get_u32(h
->cmdbuf
, 0, 32);
201 if (t1
!= 0x53425355)
209 if (h
->cmdbuf
[12] != 0)
216 static int stlink_usb_xfer_rw(void *handle
, int cmdsize
, const uint8_t *buf
, int size
)
218 struct stlink_usb_handle_s
*h
;
220 assert(handle
!= NULL
);
222 h
= (struct stlink_usb_handle_s
*)handle
;
224 if (jtag_libusb_bulk_write(h
->fd
, STLINK_TX_EP
, (char *)h
->cmdbuf
, cmdsize
,
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");
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");
247 static int stlink_usb_xfer_v1_get_sense(void *handle
)
250 struct stlink_usb_handle_s
*h
;
252 assert(handle
!= NULL
);
254 h
= (struct stlink_usb_handle_s
*)handle
;
256 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 16);
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
;
264 res
= stlink_usb_xfer_rw(handle
, REQUEST_SENSE_LENGTH
, h
->databuf
, 16);
269 if (stlink_usb_xfer_v1_get_status(handle
) != ERROR_OK
)
276 static int stlink_usb_xfer(void *handle
, const uint8_t *buf
, int size
)
278 int err
, cmdsize
= STLINK_CMD_SIZE_V2
;
279 struct stlink_usb_handle_s
*h
;
281 assert(handle
!= NULL
);
283 h
= (struct stlink_usb_handle_s
*)handle
;
285 if (h
->version
.stlink
== 1)
286 cmdsize
= STLINK_SG_SIZE
;
288 err
= stlink_usb_xfer_rw(handle
, cmdsize
, buf
, size
);
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
)
309 static void stlink_usb_xfer_v1_create_cmd(void *handle
, uint8_t direction
, uint32_t size
)
311 struct stlink_usb_handle_s
*h
;
313 h
= (struct stlink_usb_handle_s
*)handle
;
315 /* fill the send buffer */
316 strcpy((char *)h
->cmdbuf
, "USBC");
318 /* csw tag not used */
320 buf_set_u32(h
->cmdbuf
+h
->cmdidx
, 0, 32, size
);
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
;
328 static void stlink_usb_init_buffer(void *handle
, uint8_t direction
, uint32_t size
)
330 struct stlink_usb_handle_s
*h
;
332 h
= (struct stlink_usb_handle_s
*)handle
;
334 h
->direction
= direction
;
338 memset(h
->cmdbuf
, 0, STLINK_SG_SIZE
);
339 memset(h
->databuf
, 0, STLINK_DATA_SIZE
);
341 if (h
->version
.stlink
== 1)
342 stlink_usb_xfer_v1_create_cmd(handle
, direction
, size
);
345 static const char * const stlink_usb_error_msg
[] = {
350 static int stlink_usb_error_check(void *handle
)
353 const char *err_msg
= 0;
354 struct stlink_usb_handle_s
*h
;
356 assert(handle
!= NULL
);
358 h
= (struct stlink_usb_handle_s
*)handle
;
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
;
364 switch (h
->databuf
[0]) {
365 case STLINK_DEBUG_ERR_OK
:
368 case STLINK_DEBUG_ERR_FAULT
:
370 err_msg
= stlink_usb_error_msg
[0];
376 LOG_DEBUG("status error: %d ('%s')", h
->databuf
[0], err_msg
);
382 static int stlink_usb_version(void *handle
)
386 struct stlink_usb_handle_s
*h
;
388 assert(handle
!= NULL
);
390 h
= (struct stlink_usb_handle_s
*)handle
;
392 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 6);
394 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_VERSION
;
396 res
= stlink_usb_xfer(handle
, h
->databuf
, 6);
401 v
= (h
->databuf
[0] << 8) | h
->databuf
[1];
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);
409 /* set the supported jtag api version
410 * API V2 is supported since JTAG V11
412 if (h
->version
.jtag
>= 11)
413 h
->version
.jtag_api_max
= STLINK_JTAG_API_V2
;
415 h
->version
.jtag_api_max
= STLINK_JTAG_API_V1
;
417 LOG_INFO("STLINK v%d JTAG v%d API v%d SWIM v%d VID 0x%04X PID 0x%04X",
420 (h
->version
.jtag_api_max
== STLINK_JTAG_API_V1
) ? 1 : 2,
428 static int stlink_usb_check_voltage(void *handle
, float *target_voltage
)
430 struct stlink_usb_handle_s
*h
;
431 uint32_t adc_results
[2];
433 h
= (struct stlink_usb_handle_s
*)handle
;
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
;
439 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 8);
441 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_TARGET_VOLTAGE
;
443 int result
= stlink_usb_xfer(handle
, h
->databuf
, 8);
445 if (result
!= ERROR_OK
)
449 adc_results
[0] = le_to_h_u32(h
->databuf
);
450 adc_results
[1] = le_to_h_u32(h
->databuf
+ 4);
455 *target_voltage
= 2 * ((float)adc_results
[1]) * (float)(1.2 / adc_results
[0]);
457 LOG_INFO("Target voltage: %f", (double)*target_voltage
);
463 static int stlink_usb_current_mode(void *handle
, uint8_t *mode
)
466 struct stlink_usb_handle_s
*h
;
468 assert(handle
!= NULL
);
470 h
= (struct stlink_usb_handle_s
*)handle
;
472 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
474 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_CURRENT_MODE
;
476 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
481 *mode
= h
->databuf
[0];
487 static int stlink_usb_mode_enter(void *handle
, enum stlink_mode type
)
491 struct stlink_usb_handle_s
*h
;
493 assert(handle
!= NULL
);
495 h
= (struct stlink_usb_handle_s
*)handle
;
497 /* on api V2 we are able the read the latest command
499 * TODO: we need the test on api V1 too
501 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
504 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, rx_size
);
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
;
512 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_ENTER
;
513 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_ENTER_JTAG
;
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
;
520 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_ENTER
;
521 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_ENTER_SWD
;
523 case STLINK_MODE_DEBUG_SWIM
:
524 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
525 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_ENTER
;
527 case STLINK_MODE_DFU
:
528 case STLINK_MODE_MASS
:
533 res
= stlink_usb_xfer(handle
, h
->databuf
, rx_size
);
538 res
= stlink_usb_error_check(h
);
544 static int stlink_usb_mode_leave(void *handle
, enum stlink_mode type
)
547 struct stlink_usb_handle_s
*h
;
549 assert(handle
!= NULL
);
551 h
= (struct stlink_usb_handle_s
*)handle
;
553 stlink_usb_init_buffer(handle
, STLINK_NULL_EP
, 0);
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
;
561 case STLINK_MODE_DEBUG_SWIM
:
562 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
563 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_EXIT
;
565 case STLINK_MODE_DFU
:
566 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DFU_COMMAND
;
567 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DFU_EXIT
;
569 case STLINK_MODE_MASS
:
574 res
= stlink_usb_xfer(handle
, 0, 0);
583 static int stlink_usb_init_mode(void *handle
)
587 enum stlink_mode emode
;
588 struct stlink_usb_handle_s
*h
;
590 assert(handle
!= NULL
);
592 h
= (struct stlink_usb_handle_s
*)handle
;
594 res
= stlink_usb_current_mode(handle
, &mode
);
599 LOG_DEBUG("MODE: 0x%02X", mode
);
601 /* try to exit current mode */
603 case STLINK_DEV_DFU_MODE
:
604 emode
= STLINK_MODE_DFU
;
606 case STLINK_DEV_DEBUG_MODE
:
607 emode
= STLINK_MODE_DEBUG_SWD
;
609 case STLINK_DEV_SWIM_MODE
:
610 emode
= STLINK_MODE_DEBUG_SWIM
;
612 case STLINK_DEV_BOOTLOADER_MODE
:
613 case STLINK_DEV_MASS_MODE
:
615 emode
= STLINK_MODE_UNKNOWN
;
619 if (emode
!= STLINK_MODE_UNKNOWN
) {
620 res
= stlink_usb_mode_leave(handle
, emode
);
626 res
= stlink_usb_current_mode(handle
, &mode
);
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
635 if (mode
!= STLINK_DEV_DFU_MODE
) {
637 float target_voltage
;
639 /* check target voltage (if supported) */
640 res
= stlink_usb_check_voltage(h
, &target_voltage
);
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 */
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");
654 LOG_DEBUG("MODE: 0x%02X", mode
);
656 /* set selected mode */
657 switch (h
->transport
) {
658 case HL_TRANSPORT_SWD
:
659 emode
= STLINK_MODE_DEBUG_SWD
;
661 case HL_TRANSPORT_JTAG
:
662 emode
= STLINK_MODE_DEBUG_JTAG
;
664 case HL_TRANSPORT_SWIM
:
665 emode
= STLINK_MODE_DEBUG_SWIM
;
668 emode
= STLINK_MODE_UNKNOWN
;
672 if (emode
== STLINK_MODE_UNKNOWN
) {
673 LOG_ERROR("selected mode (transport) not supported");
677 res
= stlink_usb_mode_enter(handle
, emode
);
682 res
= stlink_usb_current_mode(handle
, &mode
);
687 LOG_DEBUG("MODE: 0x%02X", mode
);
693 static int stlink_usb_idcode(void *handle
, uint32_t *idcode
)
696 struct stlink_usb_handle_s
*h
;
698 assert(handle
!= NULL
);
700 h
= (struct stlink_usb_handle_s
*)handle
;
702 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 4);
704 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
705 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READCOREID
;
707 res
= stlink_usb_xfer(handle
, h
->databuf
, 4);
712 *idcode
= le_to_h_u32(h
->databuf
);
714 LOG_DEBUG("IDCODE: 0x%08X", *idcode
);
719 static int stlink_usb_v2_read_debug_reg(void *handle
, uint32_t addr
, uint32_t *val
)
721 struct stlink_usb_handle_s
*h
;
724 assert(handle
!= NULL
);
726 h
= (struct stlink_usb_handle_s
*)handle
;
728 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 8);
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
);
735 res
= stlink_usb_xfer(handle
, h
->databuf
, 8);
740 *val
= le_to_h_u32(h
->databuf
+ 4);
742 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
745 static int stlink_usb_write_debug_reg(void *handle
, uint32_t addr
, uint32_t val
)
748 struct stlink_usb_handle_s
*h
;
750 assert(handle
!= NULL
);
752 h
= (struct stlink_usb_handle_s
*)handle
;
754 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
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
;
760 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_WRITEDEBUGREG
;
761 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
763 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, val
);
766 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
771 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
774 static enum target_state
stlink_usb_v2_get_status(void *handle
)
779 result
= stlink_usb_v2_read_debug_reg(handle
, DCB_DHCSR
, &status
);
780 if (result
!= ERROR_OK
)
781 return TARGET_UNKNOWN
;
784 return TARGET_HALTED
;
785 else if (status
& S_RESET_ST
)
788 return TARGET_RUNNING
;
792 static enum target_state
stlink_usb_state(void *handle
)
795 struct stlink_usb_handle_s
*h
;
797 assert(handle
!= NULL
);
799 h
= (struct stlink_usb_handle_s
*)handle
;
801 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
802 return stlink_usb_v2_get_status(handle
);
804 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
806 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
807 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_GETSTATUS
;
809 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
812 return TARGET_UNKNOWN
;
814 if (h
->databuf
[0] == STLINK_CORE_RUNNING
)
815 return TARGET_RUNNING
;
816 if (h
->databuf
[0] == STLINK_CORE_HALTED
)
817 return TARGET_HALTED
;
819 return TARGET_UNKNOWN
;
823 static int stlink_usb_reset(void *handle
)
826 struct stlink_usb_handle_s
*h
;
828 assert(handle
!= NULL
);
830 h
= (struct stlink_usb_handle_s
*)handle
;
832 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
834 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
836 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
837 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_RESETSYS
;
839 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_RESETSYS
;
841 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
846 LOG_DEBUG("RESET: 0x%08X", h
->databuf
[0]);
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
)
852 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
855 static int stlink_usb_assert_srst(void *handle
, int srst
)
858 struct stlink_usb_handle_s
*h
;
860 assert(handle
!= NULL
);
862 h
= (struct stlink_usb_handle_s
*)handle
;
864 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
865 return ERROR_COMMAND_NOTFOUND
;
867 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
869 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
870 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_DRIVE_NRST
;
871 h
->cmdbuf
[h
->cmdidx
++] = srst
;
873 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
878 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
882 static int stlink_usb_run(void *handle
)
885 struct stlink_usb_handle_s
*h
;
887 assert(handle
!= NULL
);
889 h
= (struct stlink_usb_handle_s
*)handle
;
891 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
892 return stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_DEBUGEN
);
894 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
896 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
897 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_RUNCORE
;
899 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
904 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
908 static int stlink_usb_halt(void *handle
)
911 struct stlink_usb_handle_s
*h
;
913 assert(handle
!= NULL
);
915 h
= (struct stlink_usb_handle_s
*)handle
;
917 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
918 return stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_HALT
|C_DEBUGEN
);
920 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
922 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
923 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_FORCEDEBUG
;
925 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
930 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
934 static int stlink_usb_step(void *handle
)
937 struct stlink_usb_handle_s
*h
;
939 assert(handle
!= NULL
);
941 h
= (struct stlink_usb_handle_s
*)handle
;
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
);
951 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
953 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
954 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_STEPCORE
;
956 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
961 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
965 static int stlink_usb_read_regs(void *handle
)
968 struct stlink_usb_handle_s
*h
;
970 assert(handle
!= NULL
);
972 h
= (struct stlink_usb_handle_s
*)handle
;
974 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 84);
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
;
980 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READALLREGS
;
982 res
= stlink_usb_xfer(handle
, h
->databuf
, 84);
991 static int stlink_usb_read_reg(void *handle
, int num
, uint32_t *val
)
994 struct stlink_usb_handle_s
*h
;
996 assert(handle
!= NULL
);
998 h
= (struct stlink_usb_handle_s
*)handle
;
1000 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, h
->jtag_api
== STLINK_JTAG_API_V1
? 4 : 8);
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
;
1006 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READREG
;
1007 h
->cmdbuf
[h
->cmdidx
++] = num
;
1009 res
= stlink_usb_xfer(handle
, h
->databuf
, h
->jtag_api
== STLINK_JTAG_API_V1
? 4 : 8);
1011 if (res
!= ERROR_OK
)
1014 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
1015 *val
= le_to_h_u32(h
->databuf
);
1017 *val
= le_to_h_u32(h
->databuf
+ 4);
1018 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
1025 static int stlink_usb_write_reg(void *handle
, int num
, uint32_t val
)
1028 struct stlink_usb_handle_s
*h
;
1030 assert(handle
!= NULL
);
1032 h
= (struct stlink_usb_handle_s
*)handle
;
1034 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
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
;
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
);
1045 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
1047 if (res
!= ERROR_OK
)
1050 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: ERROR_FAIL
;
1053 static int stlink_usb_get_rw_status(void *handle
)
1056 struct stlink_usb_handle_s
*h
;
1058 assert(handle
!= NULL
);
1060 h
= (struct stlink_usb_handle_s
*)handle
;
1062 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
1065 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, 2);
1067 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1068 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_GETLASTRWSTATUS
;
1070 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
1072 if (res
!= ERROR_OK
)
1075 return h
->databuf
[0] == STLINK_DEBUG_ERR_OK
? ERROR_OK
: res
;
1079 static int stlink_usb_read_mem8(void *handle
, uint32_t addr
, uint16_t len
,
1083 uint16_t read_len
= len
;
1084 struct stlink_usb_handle_s
*h
;
1086 assert(handle
!= NULL
);
1088 h
= (struct stlink_usb_handle_s
*)handle
;
1090 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, read_len
);
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
);
1096 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1099 /* we need to fix read length for single bytes */
1103 res
= stlink_usb_xfer(handle
, h
->databuf
, read_len
);
1105 if (res
!= ERROR_OK
)
1108 memcpy(buffer
, h
->databuf
, len
);
1110 return stlink_usb_get_rw_status(handle
);
1114 static int stlink_usb_write_mem8(void *handle
, uint32_t addr
, uint16_t len
,
1115 const uint8_t *buffer
)
1118 struct stlink_usb_handle_s
*h
;
1120 assert(handle
!= NULL
);
1122 h
= (struct stlink_usb_handle_s
*)handle
;
1124 stlink_usb_init_buffer(handle
, STLINK_TX_EP
, len
);
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
);
1130 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1133 res
= stlink_usb_xfer(handle
, buffer
, len
);
1135 if (res
!= ERROR_OK
)
1138 return stlink_usb_get_rw_status(handle
);
1142 static int stlink_usb_read_mem32(void *handle
, uint32_t addr
, uint16_t len
,
1146 struct stlink_usb_handle_s
*h
;
1148 assert(handle
!= NULL
);
1150 h
= (struct stlink_usb_handle_s
*)handle
;
1154 stlink_usb_init_buffer(handle
, STLINK_RX_EP
, len
);
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
);
1160 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1163 res
= stlink_usb_xfer(handle
, h
->databuf
, len
);
1165 if (res
!= ERROR_OK
)
1168 memcpy(buffer
, h
->databuf
, len
);
1170 return stlink_usb_get_rw_status(handle
);
1174 static int stlink_usb_write_mem32(void *handle
, uint32_t addr
, uint16_t len
,
1175 const uint8_t *buffer
)
1178 struct stlink_usb_handle_s
*h
;
1180 assert(handle
!= NULL
);
1182 h
= (struct stlink_usb_handle_s
*)handle
;
1186 stlink_usb_init_buffer(handle
, STLINK_TX_EP
, len
);
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
);
1192 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1195 res
= stlink_usb_xfer(handle
, buffer
, len
);
1197 if (res
!= ERROR_OK
)
1200 return stlink_usb_get_rw_status(handle
);
1204 static int stlink_usb_close(void *fd
)
1206 struct stlink_usb_handle_s
*h
;
1208 h
= (struct stlink_usb_handle_s
*)fd
;
1211 jtag_libusb_close(h
->fd
);
1219 static int stlink_usb_open(struct hl_interface_param_s
*param
, void **fd
)
1222 struct stlink_usb_handle_s
*h
;
1223 enum stlink_jtag_api_version api
;
1225 LOG_DEBUG("stlink_usb_open");
1227 h
= calloc(1, sizeof(struct stlink_usb_handle_s
));
1230 LOG_DEBUG("malloc failed");
1234 h
->transport
= param
->transport
;
1236 /* set max read/write buffer size in bytes */
1237 param
->max_buffer
= 512;
1239 const uint16_t vids
[] = { param
->vid
, 0 };
1240 const uint16_t pids
[] = { param
->pid
, 0 };
1242 LOG_DEBUG("transport: %d vid: 0x%04x pid: 0x%04x", param
->transport
,
1243 param
->vid
, param
->pid
);
1245 if (jtag_libusb_open(vids
, pids
, &h
->fd
) != ERROR_OK
) {
1246 LOG_ERROR("open failed");
1250 jtag_libusb_set_configuration(h
->fd
, 0);
1252 if (jtag_libusb_claim_interface(h
->fd
, 0) != ERROR_OK
) {
1253 LOG_DEBUG("claim interface failed");
1257 /* wrap version for first read */
1258 switch (param
->pid
) {
1260 h
->version
.stlink
= 1;
1263 h
->version
.stlink
= 2;
1267 /* get the device version */
1268 err
= stlink_usb_version(h
);
1270 if (err
!= ERROR_OK
) {
1271 LOG_ERROR("read version failed");
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
,
1281 /* check if mode is supported */
1284 switch (h
->transport
) {
1285 case HL_TRANSPORT_SWD
:
1286 case HL_TRANSPORT_JTAG
:
1287 if (h
->version
.jtag
== 0)
1290 case HL_TRANSPORT_SWIM
:
1291 if (h
->version
.swim
== 0)
1299 if (err
!= ERROR_OK
) {
1300 LOG_ERROR("mode (transport) not supported by device");
1304 api
= h
->version
.jtag_api_max
;
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
)) {
1310 LOG_INFO("using stlink api v%d", api
);
1313 /* set the used jtag api, this will default to the newest supported version */
1316 /* initialize the debug hardware */
1317 err
= stlink_usb_init_mode(h
);
1319 if (err
!= ERROR_OK
) {
1320 LOG_ERROR("init mode failed");
1329 stlink_usb_close(h
);
1335 struct hl_layout_api_s stlink_usb_layout_api
= {
1337 .open
= stlink_usb_open
,
1339 .close
= stlink_usb_close
,
1341 .idcode
= stlink_usb_idcode
,
1343 .state
= stlink_usb_state
,
1345 .reset
= stlink_usb_reset
,
1347 .assert_srst
= stlink_usb_assert_srst
,
1349 .run
= stlink_usb_run
,
1351 .halt
= stlink_usb_halt
,
1353 .step
= stlink_usb_step
,
1355 .read_regs
= stlink_usb_read_regs
,
1357 .read_reg
= stlink_usb_read_reg
,
1359 .write_reg
= stlink_usb_write_reg
,
1361 .read_mem8
= stlink_usb_read_mem8
,
1363 .write_mem8
= stlink_usb_write_mem8
,
1365 .read_mem32
= stlink_usb_read_mem32
,
1367 .write_mem32
= stlink_usb_write_mem32
,
1369 .write_debug_reg
= stlink_usb_write_debug_reg
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)