1 /***************************************************************************
2 * SWIM contributions by Ake Rehnman *
3 * Copyright (C) 2017 Ake Rehnman *
4 * ake.rehnman(at)gmail.com *
6 * Copyright (C) 2011-2012 by Mathias Kuester *
7 * Mathias Kuester <kesmtp@freenet.de> *
9 * Copyright (C) 2012 by Spencer Oliver *
10 * spen@spen-soft.co.uk *
12 * This code is based on https://github.com/texane/stlink *
14 * This program is free software; you can redistribute it and/or modify *
15 * it under the terms of the GNU General Public License as published by *
16 * the Free Software Foundation; either version 2 of the License, or *
17 * (at your option) any later version. *
19 * This program is distributed in the hope that it will be useful, *
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
22 * GNU General Public License for more details. *
24 * You should have received a copy of the GNU General Public License *
25 * along with this program. If not, see <http://www.gnu.org/licenses/>. *
26 ***************************************************************************/
32 /* project specific includes */
33 #include <helper/binarybuffer.h>
34 #include <jtag/interface.h>
35 #include <jtag/hla/hla_layout.h>
36 #include <jtag/hla/hla_transport.h>
37 #include <jtag/hla/hla_interface.h>
38 #include <target/target.h>
40 #include <target/cortex_m.h>
42 #include "libusb_common.h"
44 #define ENDPOINT_IN 0x80
45 #define ENDPOINT_OUT 0x00
47 #define STLINK_WRITE_TIMEOUT 1000
48 #define STLINK_READ_TIMEOUT 1000
50 #define STLINK_NULL_EP 0
51 #define STLINK_RX_EP (1|ENDPOINT_IN)
52 #define STLINK_TX_EP (2|ENDPOINT_OUT)
53 #define STLINK_TRACE_EP (3|ENDPOINT_IN)
55 #define STLINK_V2_1_TX_EP (1|ENDPOINT_OUT)
56 #define STLINK_V2_1_TRACE_EP (2|ENDPOINT_IN)
58 #define STLINK_SG_SIZE (31)
59 #define STLINK_DATA_SIZE (4096)
60 #define STLINK_CMD_SIZE_V2 (16)
61 #define STLINK_CMD_SIZE_V1 (10)
63 #define STLINK_V1_PID (0x3744)
64 #define STLINK_V2_PID (0x3748)
65 #define STLINK_V2_1_PID (0x374B)
66 #define STLINK_V2_1_NO_MSD_PID (0x3752)
68 /* the current implementation of the stlink limits
69 * 8bit read/writes to max 64 bytes. */
70 #define STLINK_MAX_RW8 (64)
72 /* "WAIT" responses will be retried (with exponential backoff) at
73 * most this many times before failing to caller.
75 #define MAX_WAIT_RETRIES 8
77 enum stlink_jtag_api_version
{
78 STLINK_JTAG_API_V1
= 1,
83 struct stlink_usb_version
{
90 /** jtag api version supported */
91 enum stlink_jtag_api_version jtag_api
;
92 /** one bit for each feature supported. See macros STLINK_F_* */
97 struct stlink_usb_handle_s
{
99 struct jtag_libusb_device_handle
*fd
;
101 struct libusb_transfer
*trans
;
109 uint8_t cmdbuf
[STLINK_SG_SIZE
];
115 uint8_t databuf
[STLINK_DATA_SIZE
];
117 uint32_t max_mem_packet
;
119 enum hl_transports transport
;
121 struct stlink_usb_version version
;
128 /** whether SWO tracing is enabled or not */
130 /** trace module source clock */
133 /** reconnect is needed next time we try to query the
135 bool reconnect_pending
;
138 #define STLINK_SWIM_ERR_OK 0x00
139 #define STLINK_SWIM_BUSY 0x01
140 #define STLINK_DEBUG_ERR_OK 0x80
141 #define STLINK_DEBUG_ERR_FAULT 0x81
142 #define STLINK_SWD_AP_WAIT 0x10
143 #define STLINK_SWD_AP_FAULT 0x11
144 #define STLINK_SWD_AP_ERROR 0x12
145 #define STLINK_SWD_AP_PARITY_ERROR 0x13
146 #define STLINK_JTAG_WRITE_ERROR 0x0c
147 #define STLINK_JTAG_WRITE_VERIF_ERROR 0x0d
148 #define STLINK_SWD_DP_WAIT 0x14
149 #define STLINK_SWD_DP_FAULT 0x15
150 #define STLINK_SWD_DP_ERROR 0x16
151 #define STLINK_SWD_DP_PARITY_ERROR 0x17
153 #define STLINK_SWD_AP_WDATA_ERROR 0x18
154 #define STLINK_SWD_AP_STICKY_ERROR 0x19
155 #define STLINK_SWD_AP_STICKYORUN_ERROR 0x1a
157 #define STLINK_CORE_RUNNING 0x80
158 #define STLINK_CORE_HALTED 0x81
159 #define STLINK_CORE_STAT_UNKNOWN -1
161 #define STLINK_GET_VERSION 0xF1
162 #define STLINK_DEBUG_COMMAND 0xF2
163 #define STLINK_DFU_COMMAND 0xF3
164 #define STLINK_SWIM_COMMAND 0xF4
165 #define STLINK_GET_CURRENT_MODE 0xF5
166 #define STLINK_GET_TARGET_VOLTAGE 0xF7
168 #define STLINK_DEV_DFU_MODE 0x00
169 #define STLINK_DEV_MASS_MODE 0x01
170 #define STLINK_DEV_DEBUG_MODE 0x02
171 #define STLINK_DEV_SWIM_MODE 0x03
172 #define STLINK_DEV_BOOTLOADER_MODE 0x04
173 #define STLINK_DEV_UNKNOWN_MODE -1
175 #define STLINK_DFU_EXIT 0x07
178 STLINK_SWIM_ENTER_SEQ
179 1.3ms low then 750Hz then 1.5kHz
182 STM8 DM pulls reset pin low 50us
185 uint8_t (0=low|1=high)
192 send syncronization seq (16us low, response 64 clocks low)
194 #define STLINK_SWIM_ENTER 0x00
195 #define STLINK_SWIM_EXIT 0x01
196 #define STLINK_SWIM_READ_CAP 0x02
197 #define STLINK_SWIM_SPEED 0x03
198 #define STLINK_SWIM_ENTER_SEQ 0x04
199 #define STLINK_SWIM_GEN_RST 0x05
200 #define STLINK_SWIM_RESET 0x06
201 #define STLINK_SWIM_ASSERT_RESET 0x07
202 #define STLINK_SWIM_DEASSERT_RESET 0x08
203 #define STLINK_SWIM_READSTATUS 0x09
204 #define STLINK_SWIM_WRITEMEM 0x0a
205 #define STLINK_SWIM_READMEM 0x0b
206 #define STLINK_SWIM_READBUF 0x0c
208 #define STLINK_DEBUG_GETSTATUS 0x01
209 #define STLINK_DEBUG_FORCEDEBUG 0x02
210 #define STLINK_DEBUG_APIV1_RESETSYS 0x03
211 #define STLINK_DEBUG_APIV1_READALLREGS 0x04
212 #define STLINK_DEBUG_APIV1_READREG 0x05
213 #define STLINK_DEBUG_APIV1_WRITEREG 0x06
214 #define STLINK_DEBUG_READMEM_32BIT 0x07
215 #define STLINK_DEBUG_WRITEMEM_32BIT 0x08
216 #define STLINK_DEBUG_RUNCORE 0x09
217 #define STLINK_DEBUG_STEPCORE 0x0a
218 #define STLINK_DEBUG_APIV1_SETFP 0x0b
219 #define STLINK_DEBUG_READMEM_8BIT 0x0c
220 #define STLINK_DEBUG_WRITEMEM_8BIT 0x0d
221 #define STLINK_DEBUG_APIV1_CLEARFP 0x0e
222 #define STLINK_DEBUG_APIV1_WRITEDEBUGREG 0x0f
223 #define STLINK_DEBUG_APIV1_SETWATCHPOINT 0x10
225 #define STLINK_DEBUG_ENTER_JTAG_RESET 0x00
226 #define STLINK_DEBUG_ENTER_SWD_NO_RESET 0xa3
227 #define STLINK_DEBUG_ENTER_JTAG_NO_RESET 0xa4
229 #define STLINK_DEBUG_APIV1_ENTER 0x20
230 #define STLINK_DEBUG_EXIT 0x21
231 #define STLINK_DEBUG_READCOREID 0x22
233 #define STLINK_DEBUG_APIV2_ENTER 0x30
234 #define STLINK_DEBUG_APIV2_READ_IDCODES 0x31
235 #define STLINK_DEBUG_APIV2_RESETSYS 0x32
236 #define STLINK_DEBUG_APIV2_READREG 0x33
237 #define STLINK_DEBUG_APIV2_WRITEREG 0x34
238 #define STLINK_DEBUG_APIV2_WRITEDEBUGREG 0x35
239 #define STLINK_DEBUG_APIV2_READDEBUGREG 0x36
241 #define STLINK_DEBUG_APIV2_READALLREGS 0x3A
242 #define STLINK_DEBUG_APIV2_GETLASTRWSTATUS 0x3B
243 #define STLINK_DEBUG_APIV2_DRIVE_NRST 0x3C
245 #define STLINK_DEBUG_APIV2_GETLASTRWSTATUS2 0x3E
247 #define STLINK_DEBUG_APIV2_START_TRACE_RX 0x40
248 #define STLINK_DEBUG_APIV2_STOP_TRACE_RX 0x41
249 #define STLINK_DEBUG_APIV2_GET_TRACE_NB 0x42
250 #define STLINK_DEBUG_APIV2_SWD_SET_FREQ 0x43
251 #define STLINK_DEBUG_APIV2_JTAG_SET_FREQ 0x44
253 #define STLINK_DEBUG_APIV2_READMEM_16BIT 0x47
254 #define STLINK_DEBUG_APIV2_WRITEMEM_16BIT 0x48
256 #define STLINK_DEBUG_APIV2_DRIVE_NRST_LOW 0x00
257 #define STLINK_DEBUG_APIV2_DRIVE_NRST_HIGH 0x01
258 #define STLINK_DEBUG_APIV2_DRIVE_NRST_PULSE 0x02
260 #define STLINK_TRACE_SIZE 4096
261 #define STLINK_TRACE_MAX_HZ 2000000
265 STLINK_MODE_UNKNOWN
= 0,
268 STLINK_MODE_DEBUG_JTAG
,
269 STLINK_MODE_DEBUG_SWD
,
270 STLINK_MODE_DEBUG_SWIM
273 #define REQUEST_SENSE 0x03
274 #define REQUEST_SENSE_LENGTH 18
277 * Map the relevant features, quirks and workaround for specific firmware
280 #define STLINK_F_HAS_TRACE (1UL << 0)
281 #define STLINK_F_HAS_SWD_SET_FREQ (1UL << 1)
282 #define STLINK_F_HAS_JTAG_SET_FREQ (1UL << 2)
283 #define STLINK_F_HAS_MEM_16BIT (1UL << 3)
284 #define STLINK_F_HAS_GETLASTRWSTATUS2 (1UL << 4)
287 #define STLINK_F_HAS_TARGET_VOLT STLINK_F_HAS_TRACE
294 /* SWD clock speed */
295 static const struct speed_map stlink_khz_to_speed_map_swd
[] = {
297 {1800, 1}, /* default */
310 /* JTAG clock speed */
311 static const struct speed_map stlink_khz_to_speed_map_jtag
[] = {
316 {1125, 32}, /* default */
322 static void stlink_usb_init_buffer(void *handle
, uint8_t direction
, uint32_t size
);
323 static int stlink_swim_status(void *handle
);
326 static int stlink_usb_xfer_v1_get_status(void *handle
)
328 struct stlink_usb_handle_s
*h
= handle
;
330 assert(handle
!= NULL
);
333 memset(h
->cmdbuf
, 0, STLINK_SG_SIZE
);
335 if (jtag_libusb_bulk_read(h
->fd
, h
->rx_ep
, (char *)h
->cmdbuf
,
336 13, STLINK_READ_TIMEOUT
) != 13)
341 t1
= buf_get_u32(h
->cmdbuf
, 0, 32);
344 if (t1
!= 0x53425355)
352 if (h
->cmdbuf
[12] != 0)
359 static int stlink_usb_xfer_rw(void *handle
, int cmdsize
, const uint8_t *buf
, int size
)
361 struct stlink_usb_handle_s
*h
= handle
;
363 assert(handle
!= NULL
);
365 if (jtag_libusb_bulk_write(h
->fd
, h
->tx_ep
, (char *)h
->cmdbuf
, cmdsize
,
366 STLINK_WRITE_TIMEOUT
) != cmdsize
) {
370 if (h
->direction
== h
->tx_ep
&& size
) {
371 if (jtag_libusb_bulk_write(h
->fd
, h
->tx_ep
, (char *)buf
,
372 size
, STLINK_WRITE_TIMEOUT
) != size
) {
373 LOG_DEBUG("bulk write failed");
376 } else if (h
->direction
== h
->rx_ep
&& size
) {
377 if (jtag_libusb_bulk_read(h
->fd
, h
->rx_ep
, (char *)buf
,
378 size
, STLINK_READ_TIMEOUT
) != size
) {
379 LOG_DEBUG("bulk read failed");
388 static int stlink_usb_xfer_v1_get_sense(void *handle
)
391 struct stlink_usb_handle_s
*h
= handle
;
393 assert(handle
!= NULL
);
395 stlink_usb_init_buffer(handle
, h
->rx_ep
, 16);
397 h
->cmdbuf
[h
->cmdidx
++] = REQUEST_SENSE
;
398 h
->cmdbuf
[h
->cmdidx
++] = 0;
399 h
->cmdbuf
[h
->cmdidx
++] = 0;
400 h
->cmdbuf
[h
->cmdidx
++] = 0;
401 h
->cmdbuf
[h
->cmdidx
++] = REQUEST_SENSE_LENGTH
;
403 res
= stlink_usb_xfer_rw(handle
, REQUEST_SENSE_LENGTH
, h
->databuf
, 16);
408 if (stlink_usb_xfer_v1_get_status(handle
) != ERROR_OK
)
415 transfers block in cmdbuf
416 <size> indicates number of bytes in the following
419 static int stlink_usb_xfer(void *handle
, const uint8_t *buf
, int size
)
421 int err
, cmdsize
= STLINK_CMD_SIZE_V2
;
422 struct stlink_usb_handle_s
*h
= handle
;
424 assert(handle
!= NULL
);
426 if (h
->version
.stlink
== 1) {
427 cmdsize
= STLINK_SG_SIZE
;
428 /* put length in bCBWCBLength */
429 h
->cmdbuf
[14] = h
->cmdidx
-15;
432 err
= stlink_usb_xfer_rw(handle
, cmdsize
, buf
, size
);
437 if (h
->version
.stlink
== 1) {
438 if (stlink_usb_xfer_v1_get_status(handle
) != ERROR_OK
) {
439 /* check csw status */
440 if (h
->cmdbuf
[12] == 1) {
441 LOG_DEBUG("get sense");
442 if (stlink_usb_xfer_v1_get_sense(handle
) != ERROR_OK
)
453 Converts an STLINK status code held in the first byte of a response
454 to an openocd error, logs any error/wait status as debug output.
456 static int stlink_usb_error_check(void *handle
)
458 struct stlink_usb_handle_s
*h
= handle
;
460 assert(handle
!= NULL
);
462 if (h
->transport
== HL_TRANSPORT_SWIM
) {
463 switch (h
->databuf
[0]) {
464 case STLINK_SWIM_ERR_OK
:
466 case STLINK_SWIM_BUSY
:
469 LOG_DEBUG("unknown/unexpected STLINK status code 0x%x", h
->databuf
[0]);
474 /* TODO: no error checking yet on api V1 */
475 if (h
->version
.jtag_api
== STLINK_JTAG_API_V1
)
476 h
->databuf
[0] = STLINK_DEBUG_ERR_OK
;
478 switch (h
->databuf
[0]) {
479 case STLINK_DEBUG_ERR_OK
:
481 case STLINK_DEBUG_ERR_FAULT
:
482 LOG_DEBUG("SWD fault response (0x%x)", STLINK_DEBUG_ERR_FAULT
);
484 case STLINK_SWD_AP_WAIT
:
485 LOG_DEBUG("wait status SWD_AP_WAIT (0x%x)", STLINK_SWD_AP_WAIT
);
487 case STLINK_SWD_DP_WAIT
:
488 LOG_DEBUG("wait status SWD_DP_WAIT (0x%x)", STLINK_SWD_DP_WAIT
);
490 case STLINK_JTAG_WRITE_ERROR
:
491 LOG_DEBUG("Write error");
493 case STLINK_JTAG_WRITE_VERIF_ERROR
:
494 LOG_DEBUG("Write verify error, ignoring");
496 case STLINK_SWD_AP_FAULT
:
497 /* git://git.ac6.fr/openocd commit 657e3e885b9ee10
498 * returns ERROR_OK with the comment:
499 * Change in error status when reading outside RAM.
500 * This fix allows CDT plugin to visualize memory.
502 LOG_DEBUG("STLINK_SWD_AP_FAULT");
504 case STLINK_SWD_AP_ERROR
:
505 LOG_DEBUG("STLINK_SWD_AP_ERROR");
507 case STLINK_SWD_AP_PARITY_ERROR
:
508 LOG_DEBUG("STLINK_SWD_AP_PARITY_ERROR");
510 case STLINK_SWD_DP_FAULT
:
511 LOG_DEBUG("STLINK_SWD_DP_FAULT");
513 case STLINK_SWD_DP_ERROR
:
514 LOG_DEBUG("STLINK_SWD_DP_ERROR");
516 case STLINK_SWD_DP_PARITY_ERROR
:
517 LOG_DEBUG("STLINK_SWD_DP_PARITY_ERROR");
519 case STLINK_SWD_AP_WDATA_ERROR
:
520 LOG_DEBUG("STLINK_SWD_AP_WDATA_ERROR");
522 case STLINK_SWD_AP_STICKY_ERROR
:
523 LOG_DEBUG("STLINK_SWD_AP_STICKY_ERROR");
525 case STLINK_SWD_AP_STICKYORUN_ERROR
:
526 LOG_DEBUG("STLINK_SWD_AP_STICKYORUN_ERROR");
529 LOG_DEBUG("unknown/unexpected STLINK status code 0x%x", h
->databuf
[0]);
535 /** Issue an STLINK command via USB transfer, with retries on any wait status responses.
537 Works for commands where the STLINK_DEBUG status is returned in the first
538 byte of the response packet. For SWIM a SWIM_READSTATUS is requested instead.
540 Returns an openocd result code.
542 static int stlink_cmd_allow_retry(void *handle
, const uint8_t *buf
, int size
)
546 struct stlink_usb_handle_s
*h
= handle
;
549 if ((h
->transport
!= HL_TRANSPORT_SWIM
) || !retries
) {
550 res
= stlink_usb_xfer(handle
, buf
, size
);
555 if (h
->transport
== HL_TRANSPORT_SWIM
) {
556 res
= stlink_swim_status(handle
);
561 res
= stlink_usb_error_check(handle
);
562 if (res
== ERROR_WAIT
&& retries
< MAX_WAIT_RETRIES
) {
563 usleep((1<<retries
++) * 1000);
571 static int stlink_usb_read_trace(void *handle
, const uint8_t *buf
, int size
)
573 struct stlink_usb_handle_s
*h
= handle
;
575 assert(handle
!= NULL
);
577 assert(h
->version
.flags
& STLINK_F_HAS_TRACE
);
579 if (jtag_libusb_bulk_read(h
->fd
, h
->trace_ep
, (char *)buf
,
580 size
, STLINK_READ_TIMEOUT
) != size
) {
581 LOG_ERROR("bulk trace read failed");
589 this function writes transfer length in
590 the right place in the cb
592 static void stlink_usb_set_cbw_transfer_datalength(void *handle
, uint32_t size
)
594 struct stlink_usb_handle_s
*h
= handle
;
596 buf_set_u32(h
->cmdbuf
+8, 0, 32, size
);
599 static void stlink_usb_xfer_v1_create_cmd(void *handle
, uint8_t direction
, uint32_t size
)
601 struct stlink_usb_handle_s
*h
= handle
;
603 /* fill the send buffer */
604 strcpy((char *)h
->cmdbuf
, "USBC");
606 /* csw tag not used */
607 buf_set_u32(h
->cmdbuf
+h
->cmdidx
, 0, 32, 0);
609 /* cbw data transfer length (in the following data phase in or out) */
610 buf_set_u32(h
->cmdbuf
+h
->cmdidx
, 0, 32, size
);
613 h
->cmdbuf
[h
->cmdidx
++] = (direction
== h
->rx_ep
? ENDPOINT_IN
: ENDPOINT_OUT
);
614 h
->cmdbuf
[h
->cmdidx
++] = 0; /* lun */
615 /* cdb clength (is filled in at xfer) */
616 h
->cmdbuf
[h
->cmdidx
++] = 0;
620 static void stlink_usb_init_buffer(void *handle
, uint8_t direction
, uint32_t size
)
622 struct stlink_usb_handle_s
*h
= handle
;
624 h
->direction
= direction
;
628 memset(h
->cmdbuf
, 0, STLINK_SG_SIZE
);
629 memset(h
->databuf
, 0, STLINK_DATA_SIZE
);
631 if (h
->version
.stlink
== 1)
632 stlink_usb_xfer_v1_create_cmd(handle
, direction
, size
);
636 static int stlink_usb_version(void *handle
)
641 uint8_t v
, x
, y
, jtag
, swim
, msd
;
642 char v_str
[4 * (1 + 3) + 1]; /* VvJjMmSs */
644 struct stlink_usb_handle_s
*h
= handle
;
646 assert(handle
!= NULL
);
648 stlink_usb_init_buffer(handle
, h
->rx_ep
, 6);
650 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_VERSION
;
652 res
= stlink_usb_xfer(handle
, h
->databuf
, 6);
657 version
= be_to_h_u16(h
->databuf
);
658 v
= (version
>> 12) & 0x0f;
659 x
= (version
>> 6) & 0x3f;
662 h
->vid
= le_to_h_u16(h
->databuf
+ 2);
663 h
->pid
= le_to_h_u16(h
->databuf
+ 4);
666 case STLINK_V2_1_PID
:
667 case STLINK_V2_1_NO_MSD_PID
:
668 if ((x
<= 22 && y
== 7) || (x
>= 25 && y
>= 7 && y
<= 12)) {
669 /* MxSy : STM8 V2.1 - SWIM only */
674 /* JxMy : STM32 V2.1 - JTAG/SWD only */
687 h
->version
.stlink
= v
;
688 h
->version
.jtag
= jtag
;
689 h
->version
.swim
= swim
;
692 switch (h
->version
.stlink
) {
694 /* ST-LINK/V1 from J11 switch to api-v2 (and support SWD) */
695 if (h
->version
.jtag
>= 11)
696 h
->version
.jtag_api
= STLINK_JTAG_API_V2
;
698 h
->version
.jtag_api
= STLINK_JTAG_API_V1
;
702 /* all ST-LINK/V2 and ST-Link/V2.1 use api-v2 */
703 h
->version
.jtag_api
= STLINK_JTAG_API_V2
;
705 /* API for trace from J13 */
706 /* API for target voltage from J13 */
707 if (h
->version
.jtag
>= 13)
708 flags
|= STLINK_F_HAS_TRACE
;
710 /* preferred API to get last R/W status from J15 */
711 if (h
->version
.jtag
>= 15)
712 flags
|= STLINK_F_HAS_GETLASTRWSTATUS2
;
714 /* API to set SWD frequency from J22 */
715 if (h
->version
.jtag
>= 22)
716 flags
|= STLINK_F_HAS_SWD_SET_FREQ
;
718 /* API to set JTAG frequency from J24 */
719 if (h
->version
.jtag
>= 24)
720 flags
|= STLINK_F_HAS_JTAG_SET_FREQ
;
722 /* API to read/write memory at 16 bit from J26 */
723 if (h
->version
.jtag
>= 26)
724 flags
|= STLINK_F_HAS_MEM_16BIT
;
730 h
->version
.flags
= flags
;
733 p
+= sprintf(p
, "V%d", v
);
735 p
+= sprintf(p
, "J%d", jtag
);
737 p
+= sprintf(p
, "M%d", msd
);
739 p
+= sprintf(p
, "S%d", swim
);
741 LOG_INFO("STLINK %s (API v%d) VID:PID %04X:%04X",
750 static int stlink_usb_check_voltage(void *handle
, float *target_voltage
)
752 struct stlink_usb_handle_s
*h
= handle
;
753 uint32_t adc_results
[2];
755 /* no error message, simply quit with error */
756 if (!(h
->version
.flags
& STLINK_F_HAS_TARGET_VOLT
))
757 return ERROR_COMMAND_NOTFOUND
;
759 stlink_usb_init_buffer(handle
, h
->rx_ep
, 8);
761 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_TARGET_VOLTAGE
;
763 int result
= stlink_usb_xfer(handle
, h
->databuf
, 8);
765 if (result
!= ERROR_OK
)
769 adc_results
[0] = le_to_h_u32(h
->databuf
);
770 adc_results
[1] = le_to_h_u32(h
->databuf
+ 4);
775 *target_voltage
= 2 * ((float)adc_results
[1]) * (float)(1.2 / adc_results
[0]);
777 LOG_INFO("Target voltage: %f", (double)*target_voltage
);
782 static int stlink_usb_set_swdclk(void *handle
, uint16_t clk_divisor
)
784 struct stlink_usb_handle_s
*h
= handle
;
786 assert(handle
!= NULL
);
788 if (!(h
->version
.flags
& STLINK_F_HAS_SWD_SET_FREQ
))
789 return ERROR_COMMAND_NOTFOUND
;
791 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
793 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
794 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_SWD_SET_FREQ
;
795 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, clk_divisor
);
798 int result
= stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
800 if (result
!= ERROR_OK
)
806 static int stlink_usb_set_jtagclk(void *handle
, uint16_t clk_divisor
)
808 struct stlink_usb_handle_s
*h
= handle
;
810 assert(handle
!= NULL
);
812 if (!(h
->version
.flags
& STLINK_F_HAS_JTAG_SET_FREQ
))
813 return ERROR_COMMAND_NOTFOUND
;
815 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
817 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
818 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_JTAG_SET_FREQ
;
819 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, clk_divisor
);
822 int result
= stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
824 if (result
!= ERROR_OK
)
831 static int stlink_usb_current_mode(void *handle
, uint8_t *mode
)
834 struct stlink_usb_handle_s
*h
= handle
;
836 assert(handle
!= NULL
);
838 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
840 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_CURRENT_MODE
;
842 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
847 *mode
= h
->databuf
[0];
853 static int stlink_usb_mode_enter(void *handle
, enum stlink_mode type
)
856 struct stlink_usb_handle_s
*h
= handle
;
858 assert(handle
!= NULL
);
860 /* on api V2 we are able the read the latest command
862 * TODO: we need the test on api V1 too
864 if (h
->version
.jtag_api
== STLINK_JTAG_API_V2
)
867 stlink_usb_init_buffer(handle
, h
->rx_ep
, rx_size
);
870 case STLINK_MODE_DEBUG_JTAG
:
871 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
872 if (h
->version
.jtag_api
== STLINK_JTAG_API_V1
)
873 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_ENTER
;
875 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_ENTER
;
876 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_ENTER_JTAG_NO_RESET
;
878 case STLINK_MODE_DEBUG_SWD
:
879 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
880 if (h
->version
.jtag_api
== STLINK_JTAG_API_V1
)
881 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_ENTER
;
883 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_ENTER
;
884 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_ENTER_SWD_NO_RESET
;
886 case STLINK_MODE_DEBUG_SWIM
:
887 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
888 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_ENTER
;
889 /* no answer for this function... */
892 case STLINK_MODE_DFU
:
893 case STLINK_MODE_MASS
:
898 return stlink_cmd_allow_retry(handle
, h
->databuf
, rx_size
);
902 static int stlink_usb_mode_leave(void *handle
, enum stlink_mode type
)
905 struct stlink_usb_handle_s
*h
= handle
;
907 assert(handle
!= NULL
);
909 stlink_usb_init_buffer(handle
, STLINK_NULL_EP
, 0);
912 case STLINK_MODE_DEBUG_JTAG
:
913 case STLINK_MODE_DEBUG_SWD
:
914 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
915 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_EXIT
;
917 case STLINK_MODE_DEBUG_SWIM
:
918 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
919 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_EXIT
;
921 case STLINK_MODE_DFU
:
922 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DFU_COMMAND
;
923 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DFU_EXIT
;
925 case STLINK_MODE_MASS
:
930 res
= stlink_usb_xfer(handle
, 0, 0);
938 static int stlink_usb_assert_srst(void *handle
, int srst
);
940 static enum stlink_mode
stlink_get_mode(enum hl_transports t
)
943 case HL_TRANSPORT_SWD
:
944 return STLINK_MODE_DEBUG_SWD
;
945 case HL_TRANSPORT_JTAG
:
946 return STLINK_MODE_DEBUG_JTAG
;
947 case HL_TRANSPORT_SWIM
:
948 return STLINK_MODE_DEBUG_SWIM
;
950 return STLINK_MODE_UNKNOWN
;
955 static int stlink_usb_init_mode(void *handle
, bool connect_under_reset
)
959 enum stlink_mode emode
;
960 struct stlink_usb_handle_s
*h
= handle
;
962 assert(handle
!= NULL
);
964 res
= stlink_usb_current_mode(handle
, &mode
);
969 LOG_DEBUG("MODE: 0x%02X", mode
);
971 /* try to exit current mode */
973 case STLINK_DEV_DFU_MODE
:
974 emode
= STLINK_MODE_DFU
;
976 case STLINK_DEV_DEBUG_MODE
:
977 emode
= STLINK_MODE_DEBUG_SWD
;
979 case STLINK_DEV_SWIM_MODE
:
980 emode
= STLINK_MODE_DEBUG_SWIM
;
982 case STLINK_DEV_BOOTLOADER_MODE
:
983 case STLINK_DEV_MASS_MODE
:
985 emode
= STLINK_MODE_UNKNOWN
;
989 if (emode
!= STLINK_MODE_UNKNOWN
) {
990 res
= stlink_usb_mode_leave(handle
, emode
);
996 res
= stlink_usb_current_mode(handle
, &mode
);
1001 /* we check the target voltage here as an aid to debugging connection problems.
1002 * the stlink requires the target Vdd to be connected for reliable debugging.
1003 * this cmd is supported in all modes except DFU
1005 if (mode
!= STLINK_DEV_DFU_MODE
) {
1007 float target_voltage
;
1009 /* check target voltage (if supported) */
1010 res
= stlink_usb_check_voltage(h
, &target_voltage
);
1012 if (res
!= ERROR_OK
) {
1013 if (res
!= ERROR_COMMAND_NOTFOUND
)
1014 LOG_ERROR("voltage check failed");
1015 /* attempt to continue as it is not a catastrophic failure */
1017 /* check for a sensible target voltage, operating range is 1.65-5.5v
1018 * according to datasheet */
1019 if (target_voltage
< 1.5)
1020 LOG_ERROR("target voltage may be too low for reliable debugging");
1024 LOG_DEBUG("MODE: 0x%02X", mode
);
1026 /* set selected mode */
1027 emode
= stlink_get_mode(h
->transport
);
1029 if (emode
== STLINK_MODE_UNKNOWN
) {
1030 LOG_ERROR("selected mode (transport) not supported");
1034 /* preliminary SRST assert:
1035 * We want SRST is asserted before activating debug signals (mode_enter).
1036 * As the required mode has not been set, the adapter may not know what pin to use.
1037 * Tested firmware STLINK v2 JTAG v29 API v2 SWIM v0 uses T_NRST pin by default
1038 * Tested firmware STLINK v2 JTAG v27 API v2 SWIM v6 uses T_NRST pin by default
1039 * after power on, SWIM_RST stays unchanged */
1040 if (connect_under_reset
&& emode
!= STLINK_MODE_DEBUG_SWIM
)
1041 stlink_usb_assert_srst(handle
, 0);
1042 /* do not check the return status here, we will
1043 proceed and enter the desired mode below
1044 and try asserting srst again. */
1046 res
= stlink_usb_mode_enter(handle
, emode
);
1047 if (res
!= ERROR_OK
)
1050 /* assert SRST again: a little bit late but now the adapter knows for sure what pin to use */
1051 if (connect_under_reset
) {
1052 res
= stlink_usb_assert_srst(handle
, 0);
1053 if (res
!= ERROR_OK
)
1057 res
= stlink_usb_current_mode(handle
, &mode
);
1059 if (res
!= ERROR_OK
)
1062 LOG_DEBUG("MODE: 0x%02X", mode
);
1067 /* request status from last swim request */
1068 static int stlink_swim_status(void *handle
)
1070 struct stlink_usb_handle_s
*h
= handle
;
1073 stlink_usb_init_buffer(handle
, h
->rx_ep
, 4);
1074 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
1075 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_READSTATUS
;
1076 res
= stlink_usb_xfer(handle
, h
->databuf
, 4);
1077 if (res
!= ERROR_OK
)
1082 the purpose of this function is unknown...
1083 capabilites? anyway for swim v6 it returns
1086 __attribute__((unused
))
1087 static int stlink_swim_cap(void *handle
, uint8_t *cap
)
1089 struct stlink_usb_handle_s
*h
= handle
;
1092 stlink_usb_init_buffer(handle
, h
->rx_ep
, 8);
1093 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
1094 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_READ_CAP
;
1095 h
->cmdbuf
[h
->cmdidx
++] = 0x01;
1096 res
= stlink_usb_xfer(handle
, h
->databuf
, 8);
1097 if (res
!= ERROR_OK
)
1099 memcpy(cap
, h
->databuf
, 8);
1103 /* debug dongle assert/deassert sreset line */
1104 static int stlink_swim_assert_reset(void *handle
, int reset
)
1106 struct stlink_usb_handle_s
*h
= handle
;
1109 stlink_usb_init_buffer(handle
, h
->rx_ep
, 0);
1110 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
1112 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_ASSERT_RESET
;
1114 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_DEASSERT_RESET
;
1115 res
= stlink_cmd_allow_retry(handle
, h
->databuf
, 0);
1116 if (res
!= ERROR_OK
)
1123 1.3ms low then 750Hz then 1.5kHz
1125 static int stlink_swim_enter(void *handle
)
1127 struct stlink_usb_handle_s
*h
= handle
;
1130 stlink_usb_init_buffer(handle
, h
->rx_ep
, 0);
1131 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
1132 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_ENTER_SEQ
;
1133 res
= stlink_cmd_allow_retry(handle
, h
->databuf
, 0);
1134 if (res
!= ERROR_OK
)
1139 /* switch high/low speed swim */
1140 static int stlink_swim_speed(void *handle
, int speed
)
1142 struct stlink_usb_handle_s
*h
= handle
;
1145 stlink_usb_init_buffer(handle
, h
->rx_ep
, 0);
1146 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
1147 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_SPEED
;
1149 h
->cmdbuf
[h
->cmdidx
++] = 1;
1151 h
->cmdbuf
[h
->cmdidx
++] = 0;
1152 res
= stlink_cmd_allow_retry(handle
, h
->databuf
, 0);
1153 if (res
!= ERROR_OK
)
1159 initiate srst from swim.
1160 nrst is pulled low for 50us.
1162 static int stlink_swim_generate_rst(void *handle
)
1164 struct stlink_usb_handle_s
*h
= handle
;
1167 stlink_usb_init_buffer(handle
, h
->rx_ep
, 0);
1168 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
1169 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_GEN_RST
;
1170 res
= stlink_cmd_allow_retry(handle
, h
->databuf
, 0);
1171 if (res
!= ERROR_OK
)
1177 send resyncronize sequence
1178 swim is pulled low for 16us
1179 reply is 64 clks low
1181 static int stlink_swim_resync(void *handle
)
1183 struct stlink_usb_handle_s
*h
= handle
;
1186 stlink_usb_init_buffer(handle
, h
->rx_ep
, 0);
1187 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
1188 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_RESET
;
1189 res
= stlink_cmd_allow_retry(handle
, h
->databuf
, 0);
1190 if (res
!= ERROR_OK
)
1195 static int stlink_swim_writebytes(void *handle
, uint32_t addr
, uint32_t len
, const uint8_t *data
)
1197 struct stlink_usb_handle_s
*h
= handle
;
1200 unsigned int datalen
= 0;
1201 int cmdsize
= STLINK_CMD_SIZE_V2
;
1203 if (len
> STLINK_DATA_SIZE
)
1206 if (h
->version
.stlink
== 1)
1207 cmdsize
= STLINK_SG_SIZE
;
1209 stlink_usb_init_buffer(handle
, h
->tx_ep
, 0);
1210 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
1211 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_WRITEMEM
;
1212 h_u16_to_be(h
->cmdbuf
+h
->cmdidx
, len
);
1214 h_u32_to_be(h
->cmdbuf
+h
->cmdidx
, addr
);
1216 for (i
= 0; i
< len
; i
++) {
1217 if (h
->cmdidx
== cmdsize
)
1218 h
->databuf
[datalen
++] = *(data
++);
1220 h
->cmdbuf
[h
->cmdidx
++] = *(data
++);
1222 if (h
->version
.stlink
== 1)
1223 stlink_usb_set_cbw_transfer_datalength(handle
, datalen
);
1225 res
= stlink_cmd_allow_retry(handle
, h
->databuf
, datalen
);
1226 if (res
!= ERROR_OK
)
1231 static int stlink_swim_readbytes(void *handle
, uint32_t addr
, uint32_t len
, uint8_t *data
)
1233 struct stlink_usb_handle_s
*h
= handle
;
1236 if (len
> STLINK_DATA_SIZE
)
1239 stlink_usb_init_buffer(handle
, h
->rx_ep
, 0);
1240 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
1241 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_READMEM
;
1242 h_u16_to_be(h
->cmdbuf
+h
->cmdidx
, len
);
1244 h_u32_to_be(h
->cmdbuf
+h
->cmdidx
, addr
);
1246 res
= stlink_cmd_allow_retry(handle
, h
->databuf
, 0);
1247 if (res
!= ERROR_OK
)
1250 stlink_usb_init_buffer(handle
, h
->rx_ep
, len
);
1251 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
1252 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_READBUF
;
1253 res
= stlink_usb_xfer(handle
, data
, len
);
1254 if (res
!= ERROR_OK
)
1261 static int stlink_usb_idcode(void *handle
, uint32_t *idcode
)
1264 struct stlink_usb_handle_s
*h
= handle
;
1266 assert(handle
!= NULL
);
1268 /* there is no swim read core id cmd */
1269 if (h
->transport
== HL_TRANSPORT_SWIM
) {
1274 stlink_usb_init_buffer(handle
, h
->rx_ep
, 4);
1276 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1277 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READCOREID
;
1279 res
= stlink_usb_xfer(handle
, h
->databuf
, 4);
1281 if (res
!= ERROR_OK
)
1284 *idcode
= le_to_h_u32(h
->databuf
);
1286 LOG_DEBUG("IDCODE: 0x%08" PRIX32
, *idcode
);
1291 static int stlink_usb_v2_read_debug_reg(void *handle
, uint32_t addr
, uint32_t *val
)
1293 struct stlink_usb_handle_s
*h
= handle
;
1296 assert(handle
!= NULL
);
1298 stlink_usb_init_buffer(handle
, h
->rx_ep
, 8);
1300 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1301 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READDEBUGREG
;
1302 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1305 res
= stlink_cmd_allow_retry(handle
, h
->databuf
, 8);
1306 if (res
!= ERROR_OK
)
1309 *val
= le_to_h_u32(h
->databuf
+ 4);
1313 static int stlink_usb_write_debug_reg(void *handle
, uint32_t addr
, uint32_t val
)
1315 struct stlink_usb_handle_s
*h
= handle
;
1317 assert(handle
!= NULL
);
1319 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1321 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1322 if (h
->version
.jtag_api
== STLINK_JTAG_API_V1
)
1323 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_WRITEDEBUGREG
;
1325 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_WRITEDEBUGREG
;
1326 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1328 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, val
);
1331 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1335 static int stlink_usb_trace_read(void *handle
, uint8_t *buf
, size_t *size
)
1337 struct stlink_usb_handle_s
*h
= handle
;
1339 assert(handle
!= NULL
);
1341 if (h
->trace
.enabled
&& (h
->version
.flags
& STLINK_F_HAS_TRACE
)) {
1344 stlink_usb_init_buffer(handle
, h
->rx_ep
, 10);
1346 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1347 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_GET_TRACE_NB
;
1349 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
1350 if (res
!= ERROR_OK
)
1353 size_t bytes_avail
= le_to_h_u16(h
->databuf
);
1354 *size
= bytes_avail
< *size
? bytes_avail
: *size
- 1;
1357 res
= stlink_usb_read_trace(handle
, buf
, *size
);
1358 if (res
!= ERROR_OK
)
1367 static enum target_state
stlink_usb_v2_get_status(void *handle
)
1372 result
= stlink_usb_v2_read_debug_reg(handle
, DCB_DHCSR
, &status
);
1373 if (result
!= ERROR_OK
)
1374 return TARGET_UNKNOWN
;
1376 if (status
& S_HALT
)
1377 return TARGET_HALTED
;
1378 else if (status
& S_RESET_ST
)
1379 return TARGET_RESET
;
1381 return TARGET_RUNNING
;
1385 static enum target_state
stlink_usb_state(void *handle
)
1388 struct stlink_usb_handle_s
*h
= handle
;
1390 assert(handle
!= NULL
);
1392 if (h
->transport
== HL_TRANSPORT_SWIM
) {
1393 res
= stlink_usb_mode_enter(handle
, stlink_get_mode(h
->transport
));
1394 if (res
!= ERROR_OK
)
1395 return TARGET_UNKNOWN
;
1397 res
= stlink_swim_resync(handle
);
1398 if (res
!= ERROR_OK
)
1399 return TARGET_UNKNOWN
;
1404 if (h
->reconnect_pending
) {
1405 LOG_INFO("Previous state query failed, trying to reconnect");
1406 res
= stlink_usb_mode_enter(handle
, stlink_get_mode(h
->transport
));
1408 if (res
!= ERROR_OK
)
1409 return TARGET_UNKNOWN
;
1411 h
->reconnect_pending
= false;
1414 if (h
->version
.jtag_api
== STLINK_JTAG_API_V2
) {
1415 res
= stlink_usb_v2_get_status(handle
);
1416 if (res
== TARGET_UNKNOWN
)
1417 h
->reconnect_pending
= true;
1421 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1423 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1424 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_GETSTATUS
;
1426 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
1428 if (res
!= ERROR_OK
)
1429 return TARGET_UNKNOWN
;
1431 if (h
->databuf
[0] == STLINK_CORE_RUNNING
)
1432 return TARGET_RUNNING
;
1433 if (h
->databuf
[0] == STLINK_CORE_HALTED
)
1434 return TARGET_HALTED
;
1436 h
->reconnect_pending
= true;
1438 return TARGET_UNKNOWN
;
1441 static int stlink_usb_assert_srst(void *handle
, int srst
)
1443 struct stlink_usb_handle_s
*h
= handle
;
1445 assert(handle
!= NULL
);
1447 if (h
->transport
== HL_TRANSPORT_SWIM
)
1448 return stlink_swim_assert_reset(handle
, srst
);
1450 if (h
->version
.stlink
== 1)
1451 return ERROR_COMMAND_NOTFOUND
;
1453 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1455 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1456 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_DRIVE_NRST
;
1457 h
->cmdbuf
[h
->cmdidx
++] = srst
;
1459 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1463 static void stlink_usb_trace_disable(void *handle
)
1466 struct stlink_usb_handle_s
*h
= handle
;
1468 assert(handle
!= NULL
);
1470 assert(h
->version
.flags
& STLINK_F_HAS_TRACE
);
1472 LOG_DEBUG("Tracing: disable");
1474 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1475 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1476 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_STOP_TRACE_RX
;
1477 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
1479 if (res
== ERROR_OK
)
1480 h
->trace
.enabled
= false;
1485 static int stlink_usb_trace_enable(void *handle
)
1488 struct stlink_usb_handle_s
*h
= handle
;
1490 assert(handle
!= NULL
);
1492 if (h
->version
.flags
& STLINK_F_HAS_TRACE
) {
1493 stlink_usb_init_buffer(handle
, h
->rx_ep
, 10);
1495 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1496 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_START_TRACE_RX
;
1497 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, (uint16_t)STLINK_TRACE_SIZE
);
1499 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, h
->trace
.source_hz
);
1502 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
1504 if (res
== ERROR_OK
) {
1505 h
->trace
.enabled
= true;
1506 LOG_DEBUG("Tracing: recording at %" PRIu32
"Hz", h
->trace
.source_hz
);
1509 LOG_ERROR("Tracing is not supported by this version.");
1517 static int stlink_usb_reset(void *handle
)
1519 struct stlink_usb_handle_s
*h
= handle
;
1522 assert(handle
!= NULL
);
1524 if (h
->transport
== HL_TRANSPORT_SWIM
)
1525 return stlink_swim_generate_rst(handle
);
1527 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1529 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1531 if (h
->version
.jtag_api
== STLINK_JTAG_API_V1
)
1532 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_RESETSYS
;
1534 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_RESETSYS
;
1536 retval
= stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1537 if (retval
!= ERROR_OK
)
1540 if (h
->trace
.enabled
) {
1541 stlink_usb_trace_disable(h
);
1542 return stlink_usb_trace_enable(h
);
1549 static int stlink_usb_run(void *handle
)
1552 struct stlink_usb_handle_s
*h
= handle
;
1554 assert(handle
!= NULL
);
1556 if (h
->version
.jtag_api
== STLINK_JTAG_API_V2
) {
1557 res
= stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_DEBUGEN
);
1562 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1564 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1565 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_RUNCORE
;
1567 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1571 static int stlink_usb_halt(void *handle
)
1574 struct stlink_usb_handle_s
*h
= handle
;
1576 assert(handle
!= NULL
);
1578 if (h
->version
.jtag_api
== STLINK_JTAG_API_V2
) {
1579 res
= stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_HALT
|C_DEBUGEN
);
1584 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1586 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1587 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_FORCEDEBUG
;
1589 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1593 static int stlink_usb_step(void *handle
)
1595 struct stlink_usb_handle_s
*h
= handle
;
1597 assert(handle
!= NULL
);
1599 if (h
->version
.jtag_api
== STLINK_JTAG_API_V2
) {
1600 /* TODO: this emulates the v1 api, it should really use a similar auto mask isr
1601 * that the Cortex-M3 currently does. */
1602 stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_HALT
|C_MASKINTS
|C_DEBUGEN
);
1603 stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_STEP
|C_MASKINTS
|C_DEBUGEN
);
1604 return stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_HALT
|C_DEBUGEN
);
1607 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1609 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1610 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_STEPCORE
;
1612 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1616 static int stlink_usb_read_regs(void *handle
)
1619 struct stlink_usb_handle_s
*h
= handle
;
1621 assert(handle
!= NULL
);
1623 stlink_usb_init_buffer(handle
, h
->rx_ep
, 84);
1625 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1626 if (h
->version
.jtag_api
== STLINK_JTAG_API_V1
)
1627 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_READALLREGS
;
1629 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READALLREGS
;
1631 res
= stlink_usb_xfer(handle
, h
->databuf
, 84);
1633 if (res
!= ERROR_OK
)
1640 static int stlink_usb_read_reg(void *handle
, int num
, uint32_t *val
)
1643 struct stlink_usb_handle_s
*h
= handle
;
1645 assert(handle
!= NULL
);
1647 stlink_usb_init_buffer(handle
, h
->rx_ep
, h
->version
.jtag_api
== STLINK_JTAG_API_V1
? 4 : 8);
1649 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1650 if (h
->version
.jtag_api
== STLINK_JTAG_API_V1
)
1651 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_READREG
;
1653 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READREG
;
1654 h
->cmdbuf
[h
->cmdidx
++] = num
;
1656 if (h
->version
.jtag_api
== STLINK_JTAG_API_V1
) {
1657 res
= stlink_usb_xfer(handle
, h
->databuf
, 4);
1658 if (res
!= ERROR_OK
)
1660 *val
= le_to_h_u32(h
->databuf
);
1663 res
= stlink_cmd_allow_retry(handle
, h
->databuf
, 8);
1664 if (res
!= ERROR_OK
)
1666 *val
= le_to_h_u32(h
->databuf
+ 4);
1672 static int stlink_usb_write_reg(void *handle
, int num
, uint32_t val
)
1674 struct stlink_usb_handle_s
*h
= handle
;
1676 assert(handle
!= NULL
);
1678 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1680 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1681 if (h
->version
.jtag_api
== STLINK_JTAG_API_V1
)
1682 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_WRITEREG
;
1684 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_WRITEREG
;
1685 h
->cmdbuf
[h
->cmdidx
++] = num
;
1686 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, val
);
1689 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1692 static int stlink_usb_get_rw_status(void *handle
)
1695 struct stlink_usb_handle_s
*h
= handle
;
1697 assert(handle
!= NULL
);
1699 if (h
->version
.jtag_api
== STLINK_JTAG_API_V1
)
1702 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1704 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1705 if (h
->version
.flags
& STLINK_F_HAS_GETLASTRWSTATUS2
) {
1706 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_GETLASTRWSTATUS2
;
1708 res
= stlink_usb_xfer(handle
, h
->databuf
, 12);
1710 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_GETLASTRWSTATUS
;
1712 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
1715 if (res
!= ERROR_OK
)
1718 return stlink_usb_error_check(h
);
1722 static int stlink_usb_read_mem8(void *handle
, uint32_t addr
, uint16_t len
,
1726 uint16_t read_len
= len
;
1727 struct stlink_usb_handle_s
*h
= handle
;
1729 assert(handle
!= NULL
);
1731 /* max 8bit read/write is 64bytes */
1732 if (len
> STLINK_MAX_RW8
) {
1733 LOG_DEBUG("max buffer length exceeded");
1737 stlink_usb_init_buffer(handle
, h
->rx_ep
, read_len
);
1739 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1740 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READMEM_8BIT
;
1741 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1743 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1746 /* we need to fix read length for single bytes */
1750 res
= stlink_usb_xfer(handle
, h
->databuf
, read_len
);
1752 if (res
!= ERROR_OK
)
1755 memcpy(buffer
, h
->databuf
, len
);
1757 return stlink_usb_get_rw_status(handle
);
1761 static int stlink_usb_write_mem8(void *handle
, uint32_t addr
, uint16_t len
,
1762 const uint8_t *buffer
)
1765 struct stlink_usb_handle_s
*h
= handle
;
1767 assert(handle
!= NULL
);
1769 /* max 8bit read/write is 64bytes */
1770 if (len
> STLINK_MAX_RW8
) {
1771 LOG_DEBUG("max buffer length exceeded");
1775 stlink_usb_init_buffer(handle
, h
->tx_ep
, len
);
1777 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1778 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_WRITEMEM_8BIT
;
1779 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1781 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1784 res
= stlink_usb_xfer(handle
, buffer
, len
);
1786 if (res
!= ERROR_OK
)
1789 return stlink_usb_get_rw_status(handle
);
1793 static int stlink_usb_read_mem16(void *handle
, uint32_t addr
, uint16_t len
,
1797 struct stlink_usb_handle_s
*h
= handle
;
1799 assert(handle
!= NULL
);
1801 if (!(h
->version
.flags
& STLINK_F_HAS_MEM_16BIT
))
1802 return ERROR_COMMAND_NOTFOUND
;
1804 /* data must be a multiple of 2 and half-word aligned */
1805 if (len
% 2 || addr
% 2) {
1806 LOG_DEBUG("Invalid data alignment");
1807 return ERROR_TARGET_UNALIGNED_ACCESS
;
1810 stlink_usb_init_buffer(handle
, h
->rx_ep
, len
);
1812 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1813 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READMEM_16BIT
;
1814 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1816 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1819 res
= stlink_usb_xfer(handle
, h
->databuf
, len
);
1821 if (res
!= ERROR_OK
)
1824 memcpy(buffer
, h
->databuf
, len
);
1826 return stlink_usb_get_rw_status(handle
);
1830 static int stlink_usb_write_mem16(void *handle
, uint32_t addr
, uint16_t len
,
1831 const uint8_t *buffer
)
1834 struct stlink_usb_handle_s
*h
= handle
;
1836 assert(handle
!= NULL
);
1838 if (!(h
->version
.flags
& STLINK_F_HAS_MEM_16BIT
))
1839 return ERROR_COMMAND_NOTFOUND
;
1841 /* data must be a multiple of 2 and half-word aligned */
1842 if (len
% 2 || addr
% 2) {
1843 LOG_DEBUG("Invalid data alignment");
1844 return ERROR_TARGET_UNALIGNED_ACCESS
;
1847 stlink_usb_init_buffer(handle
, h
->tx_ep
, len
);
1849 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1850 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_WRITEMEM_16BIT
;
1851 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1853 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1856 res
= stlink_usb_xfer(handle
, buffer
, len
);
1858 if (res
!= ERROR_OK
)
1861 return stlink_usb_get_rw_status(handle
);
1865 static int stlink_usb_read_mem32(void *handle
, uint32_t addr
, uint16_t len
,
1869 struct stlink_usb_handle_s
*h
= handle
;
1871 assert(handle
!= NULL
);
1873 /* data must be a multiple of 4 and word aligned */
1874 if (len
% 4 || addr
% 4) {
1875 LOG_DEBUG("Invalid data alignment");
1876 return ERROR_TARGET_UNALIGNED_ACCESS
;
1879 stlink_usb_init_buffer(handle
, h
->rx_ep
, len
);
1881 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1882 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READMEM_32BIT
;
1883 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1885 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1888 res
= stlink_usb_xfer(handle
, h
->databuf
, len
);
1890 if (res
!= ERROR_OK
)
1893 memcpy(buffer
, h
->databuf
, len
);
1895 return stlink_usb_get_rw_status(handle
);
1899 static int stlink_usb_write_mem32(void *handle
, uint32_t addr
, uint16_t len
,
1900 const uint8_t *buffer
)
1903 struct stlink_usb_handle_s
*h
= handle
;
1905 assert(handle
!= NULL
);
1907 /* data must be a multiple of 4 and word aligned */
1908 if (len
% 4 || addr
% 4) {
1909 LOG_DEBUG("Invalid data alignment");
1910 return ERROR_TARGET_UNALIGNED_ACCESS
;
1913 stlink_usb_init_buffer(handle
, h
->tx_ep
, len
);
1915 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1916 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_WRITEMEM_32BIT
;
1917 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1919 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1922 res
= stlink_usb_xfer(handle
, buffer
, len
);
1924 if (res
!= ERROR_OK
)
1927 return stlink_usb_get_rw_status(handle
);
1930 static uint32_t stlink_max_block_size(uint32_t tar_autoincr_block
, uint32_t address
)
1932 uint32_t max_tar_block
= (tar_autoincr_block
- ((tar_autoincr_block
- 1) & address
));
1933 if (max_tar_block
== 0)
1935 return max_tar_block
;
1938 static int stlink_usb_read_mem(void *handle
, uint32_t addr
, uint32_t size
,
1939 uint32_t count
, uint8_t *buffer
)
1941 int retval
= ERROR_OK
;
1942 uint32_t bytes_remaining
;
1944 struct stlink_usb_handle_s
*h
= handle
;
1946 /* calculate byte count */
1949 /* switch to 8 bit if stlink does not support 16 bit memory read */
1950 if (size
== 2 && !(h
->version
.flags
& STLINK_F_HAS_MEM_16BIT
))
1955 bytes_remaining
= (size
!= 1) ? \
1956 stlink_max_block_size(h
->max_mem_packet
, addr
) : STLINK_MAX_RW8
;
1958 if (count
< bytes_remaining
)
1959 bytes_remaining
= count
;
1961 if (h
->transport
== HL_TRANSPORT_SWIM
) {
1962 retval
= stlink_swim_readbytes(handle
, addr
, bytes_remaining
, buffer
);
1963 if (retval
!= ERROR_OK
)
1967 * all stlink support 8/32bit memory read/writes and only from
1968 * stlink V2J26 there is support for 16 bit memory read/write.
1969 * Honour 32 bit and, if possible, 16 bit too. Otherwise, handle
1974 /* When in jtag mode the stlink uses the auto-increment functionality.
1975 * However it expects us to pass the data correctly, this includes
1976 * alignment and any page boundaries. We already do this as part of the
1977 * adi_v5 implementation, but the stlink is a hla adapter and so this
1978 * needs implementing manually.
1979 * currently this only affects jtag mode, according to ST they do single
1980 * access in SWD mode - but this may change and so we do it for both modes */
1982 /* we first need to check for any unaligned bytes */
1983 if (addr
& (size
- 1)) {
1985 uint32_t head_bytes
= size
- (addr
& (size
- 1));
1986 retval
= stlink_usb_read_mem8(handle
, addr
, head_bytes
, buffer
);
1987 if (retval
== ERROR_WAIT
&& retries
< MAX_WAIT_RETRIES
) {
1988 usleep((1<<retries
++) * 1000);
1991 if (retval
!= ERROR_OK
)
1993 buffer
+= head_bytes
;
1995 count
-= head_bytes
;
1996 bytes_remaining
-= head_bytes
;
1999 if (bytes_remaining
& (size
- 1))
2000 retval
= stlink_usb_read_mem(handle
, addr
, 1, bytes_remaining
, buffer
);
2002 retval
= stlink_usb_read_mem16(handle
, addr
, bytes_remaining
, buffer
);
2004 retval
= stlink_usb_read_mem32(handle
, addr
, bytes_remaining
, buffer
);
2006 retval
= stlink_usb_read_mem8(handle
, addr
, bytes_remaining
, buffer
);
2008 if (retval
== ERROR_WAIT
&& retries
< MAX_WAIT_RETRIES
) {
2009 usleep((1<<retries
++) * 1000);
2012 if (retval
!= ERROR_OK
)
2015 buffer
+= bytes_remaining
;
2016 addr
+= bytes_remaining
;
2017 count
-= bytes_remaining
;
2023 static int stlink_usb_write_mem(void *handle
, uint32_t addr
, uint32_t size
,
2024 uint32_t count
, const uint8_t *buffer
)
2026 int retval
= ERROR_OK
;
2027 uint32_t bytes_remaining
;
2029 struct stlink_usb_handle_s
*h
= handle
;
2031 /* calculate byte count */
2034 /* switch to 8 bit if stlink does not support 16 bit memory read */
2035 if (size
== 2 && !(h
->version
.flags
& STLINK_F_HAS_MEM_16BIT
))
2040 bytes_remaining
= (size
!= 1) ? \
2041 stlink_max_block_size(h
->max_mem_packet
, addr
) : STLINK_MAX_RW8
;
2043 if (count
< bytes_remaining
)
2044 bytes_remaining
= count
;
2046 if (h
->transport
== HL_TRANSPORT_SWIM
) {
2047 retval
= stlink_swim_writebytes(handle
, addr
, bytes_remaining
, buffer
);
2048 if (retval
!= ERROR_OK
)
2052 * all stlink support 8/32bit memory read/writes and only from
2053 * stlink V2J26 there is support for 16 bit memory read/write.
2054 * Honour 32 bit and, if possible, 16 bit too. Otherwise, handle
2059 /* When in jtag mode the stlink uses the auto-increment functionality.
2060 * However it expects us to pass the data correctly, this includes
2061 * alignment and any page boundaries. We already do this as part of the
2062 * adi_v5 implementation, but the stlink is a hla adapter and so this
2063 * needs implementing manually.
2064 * currently this only affects jtag mode, according to ST they do single
2065 * access in SWD mode - but this may change and so we do it for both modes */
2067 /* we first need to check for any unaligned bytes */
2068 if (addr
& (size
- 1)) {
2070 uint32_t head_bytes
= size
- (addr
& (size
- 1));
2071 retval
= stlink_usb_write_mem8(handle
, addr
, head_bytes
, buffer
);
2072 if (retval
== ERROR_WAIT
&& retries
< MAX_WAIT_RETRIES
) {
2073 usleep((1<<retries
++) * 1000);
2076 if (retval
!= ERROR_OK
)
2078 buffer
+= head_bytes
;
2080 count
-= head_bytes
;
2081 bytes_remaining
-= head_bytes
;
2084 if (bytes_remaining
& (size
- 1))
2085 retval
= stlink_usb_write_mem(handle
, addr
, 1, bytes_remaining
, buffer
);
2087 retval
= stlink_usb_write_mem16(handle
, addr
, bytes_remaining
, buffer
);
2089 retval
= stlink_usb_write_mem32(handle
, addr
, bytes_remaining
, buffer
);
2092 retval
= stlink_usb_write_mem8(handle
, addr
, bytes_remaining
, buffer
);
2093 if (retval
== ERROR_WAIT
&& retries
< MAX_WAIT_RETRIES
) {
2094 usleep((1<<retries
++) * 1000);
2097 if (retval
!= ERROR_OK
)
2100 buffer
+= bytes_remaining
;
2101 addr
+= bytes_remaining
;
2102 count
-= bytes_remaining
;
2109 static int stlink_usb_override_target(const char *targetname
)
2111 return !strcmp(targetname
, "cortex_m");
2114 static int stlink_speed_swim(void *handle
, int khz
, bool query
)
2117 we dont care what the khz rate is
2118 we only have low and high speed...
2119 before changing speed the SWIM_CSR HS bit
2123 stlink_swim_speed(handle
, 0);
2125 stlink_swim_speed(handle
, 1);
2129 static int stlink_match_speed_map(const struct speed_map
*map
, unsigned int map_size
, int khz
, bool query
)
2132 int speed_index
= -1;
2133 int speed_diff
= INT_MAX
;
2136 for (i
= 0; i
< map_size
; i
++) {
2137 if (khz
== map
[i
].speed
) {
2141 int current_diff
= khz
- map
[i
].speed
;
2142 /* get abs value for comparison */
2143 current_diff
= (current_diff
> 0) ? current_diff
: -current_diff
;
2144 if ((current_diff
< speed_diff
) && khz
>= map
[i
].speed
) {
2145 speed_diff
= current_diff
;
2151 if (speed_index
== -1) {
2152 /* this will only be here if we cannot match the slow speed.
2153 * use the slowest speed we support.*/
2154 speed_index
= map_size
- 1;
2156 } else if (i
== map_size
)
2159 if (!match
&& query
) {
2160 LOG_INFO("Unable to match requested speed %d kHz, using %d kHz", \
2161 khz
, map
[speed_index
].speed
);
2167 static int stlink_speed_swd(void *handle
, int khz
, bool query
)
2170 struct stlink_usb_handle_s
*h
= handle
;
2172 /* old firmware cannot change it */
2173 if (!(h
->version
.flags
& STLINK_F_HAS_SWD_SET_FREQ
))
2176 speed_index
= stlink_match_speed_map(stlink_khz_to_speed_map_swd
,
2177 ARRAY_SIZE(stlink_khz_to_speed_map_swd
), khz
, query
);
2180 int result
= stlink_usb_set_swdclk(h
, stlink_khz_to_speed_map_swd
[speed_index
].speed_divisor
);
2181 if (result
!= ERROR_OK
) {
2182 LOG_ERROR("Unable to set adapter speed");
2187 return stlink_khz_to_speed_map_swd
[speed_index
].speed
;
2190 static int stlink_speed_jtag(void *handle
, int khz
, bool query
)
2193 struct stlink_usb_handle_s
*h
= handle
;
2195 /* old firmware cannot change it */
2196 if (!(h
->version
.flags
& STLINK_F_HAS_JTAG_SET_FREQ
))
2199 speed_index
= stlink_match_speed_map(stlink_khz_to_speed_map_jtag
,
2200 ARRAY_SIZE(stlink_khz_to_speed_map_jtag
), khz
, query
);
2203 int result
= stlink_usb_set_jtagclk(h
, stlink_khz_to_speed_map_jtag
[speed_index
].speed_divisor
);
2204 if (result
!= ERROR_OK
) {
2205 LOG_ERROR("Unable to set adapter speed");
2210 return stlink_khz_to_speed_map_jtag
[speed_index
].speed
;
2213 void stlink_dump_speed_map(const struct speed_map
*map
, unsigned int map_size
)
2217 LOG_DEBUG("Supported clock speeds are:");
2218 for (i
= 0; i
< map_size
; i
++)
2219 LOG_DEBUG("%d kHz", map
[i
].speed
);
2222 static int stlink_speed(void *handle
, int khz
, bool query
)
2224 struct stlink_usb_handle_s
*h
= handle
;
2229 if (h
->transport
== HL_TRANSPORT_SWIM
)
2230 return stlink_speed_swim(handle
, khz
, query
);
2231 else if (h
->transport
== HL_TRANSPORT_SWD
)
2232 return stlink_speed_swd(handle
, khz
, query
);
2233 else if (h
->transport
== HL_TRANSPORT_JTAG
)
2234 return stlink_speed_jtag(handle
, khz
, query
);
2240 static int stlink_usb_close(void *handle
)
2244 enum stlink_mode emode
;
2245 struct stlink_usb_handle_s
*h
= handle
;
2248 res
= stlink_usb_current_mode(handle
, &mode
);
2251 /* do not exit if return code != ERROR_OK,
2252 it prevents us from closing jtag_libusb */
2254 if (res
== ERROR_OK
) {
2255 /* try to exit current mode */
2257 case STLINK_DEV_DFU_MODE
:
2258 emode
= STLINK_MODE_DFU
;
2260 case STLINK_DEV_DEBUG_MODE
:
2261 emode
= STLINK_MODE_DEBUG_SWD
;
2263 case STLINK_DEV_SWIM_MODE
:
2264 emode
= STLINK_MODE_DEBUG_SWIM
;
2266 case STLINK_DEV_BOOTLOADER_MODE
:
2267 case STLINK_DEV_MASS_MODE
:
2269 emode
= STLINK_MODE_UNKNOWN
;
2273 if (emode
!= STLINK_MODE_UNKNOWN
)
2274 stlink_usb_mode_leave(handle
, emode
);
2275 /* do not check return code, it prevent
2276 us from closing jtag_libusb */
2280 jtag_libusb_close(h
->fd
);
2288 static int stlink_usb_open(struct hl_interface_param_s
*param
, void **fd
)
2290 int err
, retry_count
= 1;
2291 struct stlink_usb_handle_s
*h
;
2293 LOG_DEBUG("stlink_usb_open");
2295 h
= calloc(1, sizeof(struct stlink_usb_handle_s
));
2298 LOG_DEBUG("malloc failed");
2302 h
->transport
= param
->transport
;
2304 for (unsigned i
= 0; param
->vid
[i
]; i
++) {
2305 LOG_DEBUG("transport: %d vid: 0x%04x pid: 0x%04x serial: %s",
2306 param
->transport
, param
->vid
[i
], param
->pid
[i
],
2307 param
->serial
? param
->serial
: "");
2311 On certain host USB configurations(e.g. MacBook Air)
2312 STLINKv2 dongle seems to have its FW in a funky state if,
2313 after plugging it in, you try to use openocd with it more
2314 then once (by launching and closing openocd). In cases like
2315 that initial attempt to read the FW info via
2316 stlink_usb_version will fail and the device has to be reset
2317 in order to become operational.
2320 if (jtag_libusb_open(param
->vid
, param
->pid
, param
->serial
, &h
->fd
) != ERROR_OK
) {
2321 LOG_ERROR("open failed");
2325 jtag_libusb_set_configuration(h
->fd
, 0);
2327 if (jtag_libusb_claim_interface(h
->fd
, 0) != ERROR_OK
) {
2328 LOG_DEBUG("claim interface failed");
2332 /* RX EP is common for all versions */
2333 h
->rx_ep
= STLINK_RX_EP
;
2336 if (jtag_libusb_get_pid(jtag_libusb_get_device(h
->fd
), &pid
) != ERROR_OK
) {
2337 LOG_DEBUG("libusb_get_pid failed");
2341 /* wrap version for first read */
2344 h
->version
.stlink
= 1;
2345 h
->tx_ep
= STLINK_TX_EP
;
2347 case STLINK_V2_1_PID
:
2348 case STLINK_V2_1_NO_MSD_PID
:
2349 h
->version
.stlink
= 2;
2350 h
->tx_ep
= STLINK_V2_1_TX_EP
;
2351 h
->trace_ep
= STLINK_V2_1_TRACE_EP
;
2354 /* fall through - we assume V2 to be the default version*/
2356 h
->version
.stlink
= 2;
2357 h
->tx_ep
= STLINK_TX_EP
;
2358 h
->trace_ep
= STLINK_TRACE_EP
;
2362 /* get the device version */
2363 err
= stlink_usb_version(h
);
2365 if (err
== ERROR_OK
) {
2367 } else if (h
->version
.stlink
== 1 ||
2369 LOG_ERROR("read version failed");
2372 err
= jtag_libusb_release_interface(h
->fd
, 0);
2373 if (err
!= ERROR_OK
) {
2374 LOG_ERROR("release interface failed");
2378 err
= jtag_libusb_reset_device(h
->fd
);
2379 if (err
!= ERROR_OK
) {
2380 LOG_ERROR("reset device failed");
2384 jtag_libusb_close(h
->fd
);
2386 Give the device one second to settle down and
2389 usleep(1 * 1000 * 1000);
2394 /* check if mode is supported */
2397 switch (h
->transport
) {
2398 case HL_TRANSPORT_SWD
:
2399 if (h
->version
.jtag_api
== STLINK_JTAG_API_V1
)
2402 case HL_TRANSPORT_JTAG
:
2403 if (h
->version
.jtag
== 0)
2406 case HL_TRANSPORT_SWIM
:
2407 if (h
->version
.swim
== 0)
2415 if (err
!= ERROR_OK
) {
2416 LOG_ERROR("mode (transport) not supported by device");
2420 /* initialize the debug hardware */
2421 err
= stlink_usb_init_mode(h
, param
->connect_under_reset
);
2423 if (err
!= ERROR_OK
) {
2424 LOG_ERROR("init mode failed (unable to connect to the target)");
2428 if (h
->transport
== HL_TRANSPORT_SWIM
) {
2429 err
= stlink_swim_enter(h
);
2430 if (err
!= ERROR_OK
) {
2431 LOG_ERROR("stlink_swim_enter_failed (unable to connect to the target)");
2435 h
->max_mem_packet
= STLINK_DATA_SIZE
;
2439 if (h
->transport
== HL_TRANSPORT_JTAG
) {
2440 if (h
->version
.flags
& STLINK_F_HAS_JTAG_SET_FREQ
) {
2441 stlink_dump_speed_map(stlink_khz_to_speed_map_jtag
, ARRAY_SIZE(stlink_khz_to_speed_map_jtag
));
2442 stlink_speed(h
, param
->initial_interface_speed
, false);
2444 } else if (h
->transport
== HL_TRANSPORT_SWD
) {
2445 if (h
->version
.flags
& STLINK_F_HAS_SWD_SET_FREQ
) {
2446 stlink_dump_speed_map(stlink_khz_to_speed_map_swd
, ARRAY_SIZE(stlink_khz_to_speed_map_swd
));
2447 stlink_speed(h
, param
->initial_interface_speed
, false);
2451 /* get cpuid, so we can determine the max page size
2452 * start with a safe default */
2453 h
->max_mem_packet
= (1 << 10);
2456 err
= stlink_usb_read_mem32(h
, CPUID
, 4, buffer
);
2457 if (err
== ERROR_OK
) {
2458 uint32_t cpuid
= le_to_h_u32(buffer
);
2459 int i
= (cpuid
>> 4) & 0xf;
2460 if (i
== 4 || i
== 3) {
2461 /* Cortex-M3/M4 has 4096 bytes autoincrement range */
2462 h
->max_mem_packet
= (1 << 12);
2466 LOG_DEBUG("Using TAR autoincrement: %" PRIu32
, h
->max_mem_packet
);
2473 stlink_usb_close(h
);
2478 int stlink_config_trace(void *handle
, bool enabled
, enum tpiu_pin_protocol pin_protocol
,
2479 uint32_t port_size
, unsigned int *trace_freq
)
2481 struct stlink_usb_handle_s
*h
= handle
;
2483 if (enabled
&& (!(h
->version
.flags
& STLINK_F_HAS_TRACE
) ||
2484 pin_protocol
!= TPIU_PIN_PROTOCOL_ASYNC_UART
)) {
2485 LOG_ERROR("The attached ST-LINK version doesn't support this trace mode");
2490 stlink_usb_trace_disable(h
);
2494 if (*trace_freq
> STLINK_TRACE_MAX_HZ
) {
2495 LOG_ERROR("ST-LINK doesn't support SWO frequency higher than %u",
2496 STLINK_TRACE_MAX_HZ
);
2500 stlink_usb_trace_disable(h
);
2503 *trace_freq
= STLINK_TRACE_MAX_HZ
;
2504 h
->trace
.source_hz
= *trace_freq
;
2506 return stlink_usb_trace_enable(h
);
2510 struct hl_layout_api_s stlink_usb_layout_api
= {
2512 .open
= stlink_usb_open
,
2514 .close
= stlink_usb_close
,
2516 .idcode
= stlink_usb_idcode
,
2518 .state
= stlink_usb_state
,
2520 .reset
= stlink_usb_reset
,
2522 .assert_srst
= stlink_usb_assert_srst
,
2524 .run
= stlink_usb_run
,
2526 .halt
= stlink_usb_halt
,
2528 .step
= stlink_usb_step
,
2530 .read_regs
= stlink_usb_read_regs
,
2532 .read_reg
= stlink_usb_read_reg
,
2534 .write_reg
= stlink_usb_write_reg
,
2536 .read_mem
= stlink_usb_read_mem
,
2538 .write_mem
= stlink_usb_write_mem
,
2540 .write_debug_reg
= stlink_usb_write_debug_reg
,
2542 .override_target
= stlink_usb_override_target
,
2544 .speed
= stlink_speed
,
2546 .config_trace
= stlink_config_trace
,
2548 .poll_trace
= stlink_usb_trace_read
,