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 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 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_WRITE_TIMEOUT 1000
46 #define STLINK_READ_TIMEOUT 1000
48 #define STLINK_NULL_EP 0
49 #define STLINK_RX_EP (1|ENDPOINT_IN)
50 #define STLINK_TX_EP (2|ENDPOINT_OUT)
51 #define STLINK_TRACE_EP (3|ENDPOINT_IN)
53 #define STLINK_V2_1_TX_EP (1|ENDPOINT_OUT)
54 #define STLINK_V2_1_TRACE_EP (2|ENDPOINT_IN)
56 #define STLINK_SG_SIZE (31)
57 #define STLINK_DATA_SIZE (4096)
58 #define STLINK_CMD_SIZE_V2 (16)
59 #define STLINK_CMD_SIZE_V1 (10)
61 #define STLINK_V1_PID (0x3744)
62 #define STLINK_V2_PID (0x3748)
63 #define STLINK_V2_1_PID (0x374B)
65 /* the current implementation of the stlink limits
66 * 8bit read/writes to max 64 bytes. */
67 #define STLINK_MAX_RW8 (64)
69 /* "WAIT" responses will be retried (with exponential backoff) at
70 * most this many times before failing to caller.
72 #define MAX_WAIT_RETRIES 8
74 enum stlink_jtag_api_version
{
75 STLINK_JTAG_API_V1
= 1,
80 struct stlink_usb_version
{
87 /** highest supported jtag api version */
88 enum stlink_jtag_api_version jtag_api_max
;
92 struct stlink_usb_handle_s
{
94 struct jtag_libusb_device_handle
*fd
;
96 struct libusb_transfer
*trans
;
104 uint8_t cmdbuf
[STLINK_SG_SIZE
];
110 uint8_t databuf
[STLINK_DATA_SIZE
];
112 uint32_t max_mem_packet
;
114 enum hl_transports transport
;
116 struct stlink_usb_version version
;
121 /** this is the currently used jtag api */
122 enum stlink_jtag_api_version jtag_api
;
125 /** whether SWO tracing is enabled or not */
127 /** trace module source clock */
130 /** reconnect is needed next time we try to query the
132 bool reconnect_pending
;
135 #define STLINK_DEBUG_ERR_OK 0x80
136 #define STLINK_DEBUG_ERR_FAULT 0x81
137 #define STLINK_SWD_AP_WAIT 0x10
138 #define STLINK_SWD_AP_FAULT 0x11
139 #define STLINK_SWD_AP_ERROR 0x12
140 #define STLINK_SWD_AP_PARITY_ERROR 0x13
141 #define STLINK_JTAG_WRITE_ERROR 0x0c
142 #define STLINK_JTAG_WRITE_VERIF_ERROR 0x0d
143 #define STLINK_SWD_DP_WAIT 0x14
144 #define STLINK_SWD_DP_FAULT 0x15
145 #define STLINK_SWD_DP_ERROR 0x16
146 #define STLINK_SWD_DP_PARITY_ERROR 0x17
148 #define STLINK_SWD_AP_WDATA_ERROR 0x18
149 #define STLINK_SWD_AP_STICKY_ERROR 0x19
150 #define STLINK_SWD_AP_STICKYORUN_ERROR 0x1a
152 #define STLINK_CORE_RUNNING 0x80
153 #define STLINK_CORE_HALTED 0x81
154 #define STLINK_CORE_STAT_UNKNOWN -1
156 #define STLINK_GET_VERSION 0xF1
157 #define STLINK_DEBUG_COMMAND 0xF2
158 #define STLINK_DFU_COMMAND 0xF3
159 #define STLINK_SWIM_COMMAND 0xF4
160 #define STLINK_GET_CURRENT_MODE 0xF5
161 #define STLINK_GET_TARGET_VOLTAGE 0xF7
163 #define STLINK_DEV_DFU_MODE 0x00
164 #define STLINK_DEV_MASS_MODE 0x01
165 #define STLINK_DEV_DEBUG_MODE 0x02
166 #define STLINK_DEV_SWIM_MODE 0x03
167 #define STLINK_DEV_BOOTLOADER_MODE 0x04
168 #define STLINK_DEV_UNKNOWN_MODE -1
170 #define STLINK_DFU_EXIT 0x07
172 #define STLINK_SWIM_ENTER 0x00
173 #define STLINK_SWIM_EXIT 0x01
175 #define STLINK_DEBUG_ENTER_JTAG 0x00
176 #define STLINK_DEBUG_GETSTATUS 0x01
177 #define STLINK_DEBUG_FORCEDEBUG 0x02
178 #define STLINK_DEBUG_APIV1_RESETSYS 0x03
179 #define STLINK_DEBUG_APIV1_READALLREGS 0x04
180 #define STLINK_DEBUG_APIV1_READREG 0x05
181 #define STLINK_DEBUG_APIV1_WRITEREG 0x06
182 #define STLINK_DEBUG_READMEM_32BIT 0x07
183 #define STLINK_DEBUG_WRITEMEM_32BIT 0x08
184 #define STLINK_DEBUG_RUNCORE 0x09
185 #define STLINK_DEBUG_STEPCORE 0x0a
186 #define STLINK_DEBUG_APIV1_SETFP 0x0b
187 #define STLINK_DEBUG_READMEM_8BIT 0x0c
188 #define STLINK_DEBUG_WRITEMEM_8BIT 0x0d
189 #define STLINK_DEBUG_APIV1_CLEARFP 0x0e
190 #define STLINK_DEBUG_APIV1_WRITEDEBUGREG 0x0f
191 #define STLINK_DEBUG_APIV1_SETWATCHPOINT 0x10
193 #define STLINK_DEBUG_ENTER_JTAG 0x00
194 #define STLINK_DEBUG_ENTER_SWD 0xa3
196 #define STLINK_DEBUG_APIV1_ENTER 0x20
197 #define STLINK_DEBUG_EXIT 0x21
198 #define STLINK_DEBUG_READCOREID 0x22
200 #define STLINK_DEBUG_APIV2_ENTER 0x30
201 #define STLINK_DEBUG_APIV2_READ_IDCODES 0x31
202 #define STLINK_DEBUG_APIV2_RESETSYS 0x32
203 #define STLINK_DEBUG_APIV2_READREG 0x33
204 #define STLINK_DEBUG_APIV2_WRITEREG 0x34
205 #define STLINK_DEBUG_APIV2_WRITEDEBUGREG 0x35
206 #define STLINK_DEBUG_APIV2_READDEBUGREG 0x36
208 #define STLINK_DEBUG_APIV2_READALLREGS 0x3A
209 #define STLINK_DEBUG_APIV2_GETLASTRWSTATUS 0x3B
210 #define STLINK_DEBUG_APIV2_DRIVE_NRST 0x3C
212 #define STLINK_DEBUG_APIV2_START_TRACE_RX 0x40
213 #define STLINK_DEBUG_APIV2_STOP_TRACE_RX 0x41
214 #define STLINK_DEBUG_APIV2_GET_TRACE_NB 0x42
215 #define STLINK_DEBUG_APIV2_SWD_SET_FREQ 0x43
217 #define STLINK_DEBUG_APIV2_DRIVE_NRST_LOW 0x00
218 #define STLINK_DEBUG_APIV2_DRIVE_NRST_HIGH 0x01
219 #define STLINK_DEBUG_APIV2_DRIVE_NRST_PULSE 0x02
221 #define STLINK_TRACE_SIZE 1024
222 #define STLINK_TRACE_MAX_HZ 2000000
223 #define STLINK_TRACE_MIN_VERSION 13
227 STLINK_MODE_UNKNOWN
= 0,
230 STLINK_MODE_DEBUG_JTAG
,
231 STLINK_MODE_DEBUG_SWD
,
232 STLINK_MODE_DEBUG_SWIM
235 #define REQUEST_SENSE 0x03
236 #define REQUEST_SENSE_LENGTH 18
238 static const struct {
241 } stlink_khz_to_speed_map
[] = {
243 {1800, 1}, /* default */
256 static void stlink_usb_init_buffer(void *handle
, uint8_t direction
, uint32_t size
);
259 static int stlink_usb_xfer_v1_get_status(void *handle
)
261 struct stlink_usb_handle_s
*h
= handle
;
263 assert(handle
!= NULL
);
266 memset(h
->cmdbuf
, 0, STLINK_SG_SIZE
);
268 if (jtag_libusb_bulk_read(h
->fd
, h
->rx_ep
, (char *)h
->cmdbuf
,
269 13, STLINK_READ_TIMEOUT
) != 13)
274 t1
= buf_get_u32(h
->cmdbuf
, 0, 32);
277 if (t1
!= 0x53425355)
285 if (h
->cmdbuf
[12] != 0)
292 static int stlink_usb_xfer_rw(void *handle
, int cmdsize
, const uint8_t *buf
, int size
)
294 struct stlink_usb_handle_s
*h
= handle
;
296 assert(handle
!= NULL
);
298 if (jtag_libusb_bulk_write(h
->fd
, h
->tx_ep
, (char *)h
->cmdbuf
, cmdsize
,
299 STLINK_WRITE_TIMEOUT
) != cmdsize
) {
303 if (h
->direction
== h
->tx_ep
&& size
) {
304 if (jtag_libusb_bulk_write(h
->fd
, h
->tx_ep
, (char *)buf
,
305 size
, STLINK_WRITE_TIMEOUT
) != size
) {
306 LOG_DEBUG("bulk write failed");
309 } else if (h
->direction
== h
->rx_ep
&& size
) {
310 if (jtag_libusb_bulk_read(h
->fd
, h
->rx_ep
, (char *)buf
,
311 size
, STLINK_READ_TIMEOUT
) != size
) {
312 LOG_DEBUG("bulk read failed");
321 static int stlink_usb_xfer_v1_get_sense(void *handle
)
324 struct stlink_usb_handle_s
*h
= handle
;
326 assert(handle
!= NULL
);
328 stlink_usb_init_buffer(handle
, h
->rx_ep
, 16);
330 h
->cmdbuf
[h
->cmdidx
++] = REQUEST_SENSE
;
331 h
->cmdbuf
[h
->cmdidx
++] = 0;
332 h
->cmdbuf
[h
->cmdidx
++] = 0;
333 h
->cmdbuf
[h
->cmdidx
++] = 0;
334 h
->cmdbuf
[h
->cmdidx
++] = REQUEST_SENSE_LENGTH
;
336 res
= stlink_usb_xfer_rw(handle
, REQUEST_SENSE_LENGTH
, h
->databuf
, 16);
341 if (stlink_usb_xfer_v1_get_status(handle
) != ERROR_OK
)
348 static int stlink_usb_xfer(void *handle
, const uint8_t *buf
, int size
)
350 int err
, cmdsize
= STLINK_CMD_SIZE_V2
;
351 struct stlink_usb_handle_s
*h
= handle
;
353 assert(handle
!= NULL
);
355 if (h
->version
.stlink
== 1)
356 cmdsize
= STLINK_SG_SIZE
;
358 err
= stlink_usb_xfer_rw(handle
, cmdsize
, buf
, size
);
363 if (h
->version
.stlink
== 1) {
364 if (stlink_usb_xfer_v1_get_status(handle
) != ERROR_OK
) {
365 /* check csw status */
366 if (h
->cmdbuf
[12] == 1) {
367 LOG_DEBUG("get sense");
368 if (stlink_usb_xfer_v1_get_sense(handle
) != ERROR_OK
)
380 Converts an STLINK status code held in the first byte of a response
381 to an openocd error, logs any error/wait status as debug output.
383 static int stlink_usb_error_check(void *handle
)
385 struct stlink_usb_handle_s
*h
= handle
;
387 assert(handle
!= NULL
);
389 /* TODO: no error checking yet on api V1 */
390 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
391 h
->databuf
[0] = STLINK_DEBUG_ERR_OK
;
393 switch (h
->databuf
[0]) {
394 case STLINK_DEBUG_ERR_OK
:
396 case STLINK_DEBUG_ERR_FAULT
:
397 LOG_DEBUG("SWD fault response (0x%x)", STLINK_DEBUG_ERR_FAULT
);
399 case STLINK_SWD_AP_WAIT
:
400 LOG_DEBUG("wait status SWD_AP_WAIT (0x%x)", STLINK_SWD_AP_WAIT
);
402 case STLINK_SWD_DP_WAIT
:
403 LOG_DEBUG("wait status SWD_DP_WAIT (0x%x)", STLINK_SWD_DP_WAIT
);
405 case STLINK_JTAG_WRITE_ERROR
:
406 LOG_DEBUG("Write error");
408 case STLINK_JTAG_WRITE_VERIF_ERROR
:
409 LOG_DEBUG("Verify error");
411 case STLINK_SWD_AP_FAULT
:
412 /* git://git.ac6.fr/openocd commit 657e3e885b9ee10
413 * returns ERROR_OK with the comment:
414 * Change in error status when reading outside RAM.
415 * This fix allows CDT plugin to visualize memory.
417 LOG_DEBUG("STLINK_SWD_AP_FAULT");
419 case STLINK_SWD_AP_ERROR
:
420 LOG_DEBUG("STLINK_SWD_AP_ERROR");
422 case STLINK_SWD_AP_PARITY_ERROR
:
423 LOG_DEBUG("STLINK_SWD_AP_PARITY_ERROR");
425 case STLINK_SWD_DP_FAULT
:
426 LOG_DEBUG("STLINK_SWD_DP_FAULT");
428 case STLINK_SWD_DP_ERROR
:
429 LOG_DEBUG("STLINK_SWD_DP_ERROR");
431 case STLINK_SWD_DP_PARITY_ERROR
:
432 LOG_DEBUG("STLINK_SWD_DP_PARITY_ERROR");
434 case STLINK_SWD_AP_WDATA_ERROR
:
435 LOG_DEBUG("STLINK_SWD_AP_WDATA_ERROR");
437 case STLINK_SWD_AP_STICKY_ERROR
:
438 LOG_DEBUG("STLINK_SWD_AP_STICKY_ERROR");
440 case STLINK_SWD_AP_STICKYORUN_ERROR
:
441 LOG_DEBUG("STLINK_SWD_AP_STICKYORUN_ERROR");
444 LOG_DEBUG("unknown/unexpected STLINK status code 0x%x", h
->databuf
[0]);
450 /** Issue an STLINK command via USB transfer, with retries on any wait status responses.
452 Works for commands where the STLINK_DEBUG status is returned in the first
453 byte of the response packet.
455 Returns an openocd result code.
457 static int stlink_cmd_allow_retry(void *handle
, const uint8_t *buf
, int size
)
462 res
= stlink_usb_xfer(handle
, buf
, size
);
465 res
= stlink_usb_error_check(handle
);
466 if (res
== ERROR_WAIT
&& retries
< MAX_WAIT_RETRIES
) {
467 usleep((1<<retries
++) * 1000);
475 static int stlink_usb_read_trace(void *handle
, const uint8_t *buf
, int size
)
477 struct stlink_usb_handle_s
*h
= handle
;
479 assert(handle
!= NULL
);
481 assert(h
->version
.stlink
>= 2);
483 if (jtag_libusb_bulk_read(h
->fd
, h
->trace_ep
, (char *)buf
,
484 size
, STLINK_READ_TIMEOUT
) != size
) {
485 LOG_ERROR("bulk trace read failed");
493 static void stlink_usb_xfer_v1_create_cmd(void *handle
, uint8_t direction
, uint32_t size
)
495 struct stlink_usb_handle_s
*h
= handle
;
497 /* fill the send buffer */
498 strcpy((char *)h
->cmdbuf
, "USBC");
500 /* csw tag not used */
502 buf_set_u32(h
->cmdbuf
+h
->cmdidx
, 0, 32, size
);
504 h
->cmdbuf
[h
->cmdidx
++] = (direction
== h
->rx_ep
? ENDPOINT_IN
: ENDPOINT_OUT
);
505 h
->cmdbuf
[h
->cmdidx
++] = 0; /* lun */
506 h
->cmdbuf
[h
->cmdidx
++] = STLINK_CMD_SIZE_V1
;
510 static void stlink_usb_init_buffer(void *handle
, uint8_t direction
, uint32_t size
)
512 struct stlink_usb_handle_s
*h
= handle
;
514 h
->direction
= direction
;
518 memset(h
->cmdbuf
, 0, STLINK_SG_SIZE
);
519 memset(h
->databuf
, 0, STLINK_DATA_SIZE
);
521 if (h
->version
.stlink
== 1)
522 stlink_usb_xfer_v1_create_cmd(handle
, direction
, size
);
526 static int stlink_usb_version(void *handle
)
530 struct stlink_usb_handle_s
*h
= handle
;
532 assert(handle
!= NULL
);
534 stlink_usb_init_buffer(handle
, h
->rx_ep
, 6);
536 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_VERSION
;
538 res
= stlink_usb_xfer(handle
, h
->databuf
, 6);
543 v
= (h
->databuf
[0] << 8) | h
->databuf
[1];
545 h
->version
.stlink
= (v
>> 12) & 0x0f;
546 h
->version
.jtag
= (v
>> 6) & 0x3f;
547 h
->version
.swim
= v
& 0x3f;
548 h
->vid
= buf_get_u32(h
->databuf
, 16, 16);
549 h
->pid
= buf_get_u32(h
->databuf
, 32, 16);
551 /* set the supported jtag api version
552 * API V2 is supported since JTAG V11
554 if (h
->version
.jtag
>= 11)
555 h
->version
.jtag_api_max
= STLINK_JTAG_API_V2
;
557 h
->version
.jtag_api_max
= STLINK_JTAG_API_V1
;
559 LOG_INFO("STLINK v%d JTAG v%d API v%d SWIM v%d VID 0x%04X PID 0x%04X",
562 (h
->version
.jtag_api_max
== STLINK_JTAG_API_V1
) ? 1 : 2,
570 static int stlink_usb_check_voltage(void *handle
, float *target_voltage
)
572 struct stlink_usb_handle_s
*h
= handle
;
573 uint32_t adc_results
[2];
575 /* only supported by stlink/v2 and for firmware >= 13 */
576 if (h
->version
.stlink
== 1 || h
->version
.jtag
< 13)
577 return ERROR_COMMAND_NOTFOUND
;
579 stlink_usb_init_buffer(handle
, h
->rx_ep
, 8);
581 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_TARGET_VOLTAGE
;
583 int result
= stlink_usb_xfer(handle
, h
->databuf
, 8);
585 if (result
!= ERROR_OK
)
589 adc_results
[0] = le_to_h_u32(h
->databuf
);
590 adc_results
[1] = le_to_h_u32(h
->databuf
+ 4);
595 *target_voltage
= 2 * ((float)adc_results
[1]) * (float)(1.2 / adc_results
[0]);
597 LOG_INFO("Target voltage: %f", (double)*target_voltage
);
602 static int stlink_usb_set_swdclk(void *handle
, uint16_t clk_divisor
)
604 struct stlink_usb_handle_s
*h
= handle
;
606 assert(handle
!= NULL
);
608 /* only supported by stlink/v2 and for firmware >= 22 */
609 if (h
->version
.stlink
== 1 || h
->version
.jtag
< 22)
610 return ERROR_COMMAND_NOTFOUND
;
612 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
614 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
615 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_SWD_SET_FREQ
;
616 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, clk_divisor
);
619 int result
= stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
621 if (result
!= ERROR_OK
)
628 static int stlink_usb_current_mode(void *handle
, uint8_t *mode
)
631 struct stlink_usb_handle_s
*h
= handle
;
633 assert(handle
!= NULL
);
635 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
637 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_CURRENT_MODE
;
639 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
644 *mode
= h
->databuf
[0];
650 static int stlink_usb_mode_enter(void *handle
, enum stlink_mode type
)
653 struct stlink_usb_handle_s
*h
= handle
;
655 assert(handle
!= NULL
);
657 /* on api V2 we are able the read the latest command
659 * TODO: we need the test on api V1 too
661 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
664 stlink_usb_init_buffer(handle
, h
->rx_ep
, rx_size
);
667 case STLINK_MODE_DEBUG_JTAG
:
668 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
669 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
670 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_ENTER
;
672 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_ENTER
;
673 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_ENTER_JTAG
;
675 case STLINK_MODE_DEBUG_SWD
:
676 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
677 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
678 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_ENTER
;
680 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_ENTER
;
681 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_ENTER_SWD
;
683 case STLINK_MODE_DEBUG_SWIM
:
684 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
685 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_ENTER
;
687 case STLINK_MODE_DFU
:
688 case STLINK_MODE_MASS
:
693 return stlink_cmd_allow_retry(handle
, h
->databuf
, rx_size
);
697 static int stlink_usb_mode_leave(void *handle
, enum stlink_mode type
)
700 struct stlink_usb_handle_s
*h
= handle
;
702 assert(handle
!= NULL
);
704 stlink_usb_init_buffer(handle
, STLINK_NULL_EP
, 0);
707 case STLINK_MODE_DEBUG_JTAG
:
708 case STLINK_MODE_DEBUG_SWD
:
709 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
710 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_EXIT
;
712 case STLINK_MODE_DEBUG_SWIM
:
713 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
714 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_EXIT
;
716 case STLINK_MODE_DFU
:
717 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DFU_COMMAND
;
718 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DFU_EXIT
;
720 case STLINK_MODE_MASS
:
725 res
= stlink_usb_xfer(handle
, 0, 0);
733 static int stlink_usb_assert_srst(void *handle
, int srst
);
735 static enum stlink_mode
stlink_get_mode(enum hl_transports t
)
738 case HL_TRANSPORT_SWD
:
739 return STLINK_MODE_DEBUG_SWD
;
740 case HL_TRANSPORT_JTAG
:
741 return STLINK_MODE_DEBUG_JTAG
;
742 case HL_TRANSPORT_SWIM
:
743 return STLINK_MODE_DEBUG_SWIM
;
745 return STLINK_MODE_UNKNOWN
;
750 static int stlink_usb_init_mode(void *handle
, bool connect_under_reset
)
754 enum stlink_mode emode
;
755 struct stlink_usb_handle_s
*h
= handle
;
757 assert(handle
!= NULL
);
759 res
= stlink_usb_current_mode(handle
, &mode
);
764 LOG_DEBUG("MODE: 0x%02X", mode
);
766 /* try to exit current mode */
768 case STLINK_DEV_DFU_MODE
:
769 emode
= STLINK_MODE_DFU
;
771 case STLINK_DEV_DEBUG_MODE
:
772 emode
= STLINK_MODE_DEBUG_SWD
;
774 case STLINK_DEV_SWIM_MODE
:
775 emode
= STLINK_MODE_DEBUG_SWIM
;
777 case STLINK_DEV_BOOTLOADER_MODE
:
778 case STLINK_DEV_MASS_MODE
:
780 emode
= STLINK_MODE_UNKNOWN
;
784 if (emode
!= STLINK_MODE_UNKNOWN
) {
785 res
= stlink_usb_mode_leave(handle
, emode
);
791 res
= stlink_usb_current_mode(handle
, &mode
);
796 /* we check the target voltage here as an aid to debugging connection problems.
797 * the stlink requires the target Vdd to be connected for reliable debugging.
798 * this cmd is supported in all modes except DFU
800 if (mode
!= STLINK_DEV_DFU_MODE
) {
802 float target_voltage
;
804 /* check target voltage (if supported) */
805 res
= stlink_usb_check_voltage(h
, &target_voltage
);
807 if (res
!= ERROR_OK
) {
808 if (res
!= ERROR_COMMAND_NOTFOUND
)
809 LOG_ERROR("voltage check failed");
810 /* attempt to continue as it is not a catastrophic failure */
812 /* check for a sensible target voltage, operating range is 1.65-5.5v
813 * according to datasheet */
814 if (target_voltage
< 1.5)
815 LOG_ERROR("target voltage may be too low for reliable debugging");
819 LOG_DEBUG("MODE: 0x%02X", mode
);
821 /* set selected mode */
822 emode
= stlink_get_mode(h
->transport
);
824 if (emode
== STLINK_MODE_UNKNOWN
) {
825 LOG_ERROR("selected mode (transport) not supported");
829 if (connect_under_reset
) {
830 res
= stlink_usb_assert_srst(handle
, 0);
835 res
= stlink_usb_mode_enter(handle
, emode
);
840 res
= stlink_usb_current_mode(handle
, &mode
);
845 LOG_DEBUG("MODE: 0x%02X", mode
);
851 static int stlink_usb_idcode(void *handle
, uint32_t *idcode
)
854 struct stlink_usb_handle_s
*h
= handle
;
856 assert(handle
!= NULL
);
858 stlink_usb_init_buffer(handle
, h
->rx_ep
, 4);
860 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
861 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READCOREID
;
863 res
= stlink_usb_xfer(handle
, h
->databuf
, 4);
868 *idcode
= le_to_h_u32(h
->databuf
);
870 LOG_DEBUG("IDCODE: 0x%08" PRIX32
, *idcode
);
875 static int stlink_usb_v2_read_debug_reg(void *handle
, uint32_t addr
, uint32_t *val
)
877 struct stlink_usb_handle_s
*h
= handle
;
880 assert(handle
!= NULL
);
882 stlink_usb_init_buffer(handle
, h
->rx_ep
, 8);
884 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
885 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READDEBUGREG
;
886 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
889 res
= stlink_cmd_allow_retry(handle
, h
->databuf
, 8);
893 *val
= le_to_h_u32(h
->databuf
+ 4);
897 static int stlink_usb_write_debug_reg(void *handle
, uint32_t addr
, uint32_t val
)
899 struct stlink_usb_handle_s
*h
= handle
;
901 assert(handle
!= NULL
);
903 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
905 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
906 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
907 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_WRITEDEBUGREG
;
909 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_WRITEDEBUGREG
;
910 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
912 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, val
);
915 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
919 static int stlink_usb_trace_read(void *handle
, uint8_t *buf
, size_t *size
)
921 struct stlink_usb_handle_s
*h
= handle
;
923 assert(handle
!= NULL
);
925 if (h
->trace
.enabled
&& h
->version
.jtag
>= STLINK_TRACE_MIN_VERSION
) {
928 stlink_usb_init_buffer(handle
, h
->rx_ep
, 10);
930 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
931 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_GET_TRACE_NB
;
933 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
937 size_t bytes_avail
= le_to_h_u16(h
->databuf
);
938 *size
= bytes_avail
< *size
? bytes_avail
: *size
- 1;
941 res
= stlink_usb_read_trace(handle
, buf
, *size
);
951 static enum target_state
stlink_usb_v2_get_status(void *handle
)
956 result
= stlink_usb_v2_read_debug_reg(handle
, DCB_DHCSR
, &status
);
957 if (result
!= ERROR_OK
)
958 return TARGET_UNKNOWN
;
961 return TARGET_HALTED
;
962 else if (status
& S_RESET_ST
)
965 return TARGET_RUNNING
;
969 static enum target_state
stlink_usb_state(void *handle
)
972 struct stlink_usb_handle_s
*h
= handle
;
974 assert(handle
!= NULL
);
976 if (h
->reconnect_pending
) {
977 LOG_INFO("Previous state query failed, trying to reconnect");
978 res
= stlink_usb_mode_enter(handle
, stlink_get_mode(h
->transport
));
981 return TARGET_UNKNOWN
;
983 h
->reconnect_pending
= false;
986 if (h
->jtag_api
== STLINK_JTAG_API_V2
) {
987 res
= stlink_usb_v2_get_status(handle
);
988 if (res
== TARGET_UNKNOWN
)
989 h
->reconnect_pending
= true;
993 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
995 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
996 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_GETSTATUS
;
998 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
1000 if (res
!= ERROR_OK
)
1001 return TARGET_UNKNOWN
;
1003 if (h
->databuf
[0] == STLINK_CORE_RUNNING
)
1004 return TARGET_RUNNING
;
1005 if (h
->databuf
[0] == STLINK_CORE_HALTED
)
1006 return TARGET_HALTED
;
1008 h
->reconnect_pending
= true;
1010 return TARGET_UNKNOWN
;
1013 static int stlink_usb_assert_srst(void *handle
, int srst
)
1015 struct stlink_usb_handle_s
*h
= handle
;
1017 assert(handle
!= NULL
);
1019 if (h
->version
.stlink
== 1)
1020 return ERROR_COMMAND_NOTFOUND
;
1022 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1024 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1025 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_DRIVE_NRST
;
1026 h
->cmdbuf
[h
->cmdidx
++] = srst
;
1028 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1032 static void stlink_usb_trace_disable(void *handle
)
1035 struct stlink_usb_handle_s
*h
= handle
;
1037 assert(handle
!= NULL
);
1039 assert(h
->version
.jtag
>= STLINK_TRACE_MIN_VERSION
);
1041 LOG_DEBUG("Tracing: disable");
1043 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1044 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1045 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_STOP_TRACE_RX
;
1046 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
1048 if (res
== ERROR_OK
)
1049 h
->trace
.enabled
= false;
1054 static int stlink_usb_trace_enable(void *handle
)
1057 struct stlink_usb_handle_s
*h
= handle
;
1059 assert(handle
!= NULL
);
1061 if (h
->version
.jtag
>= STLINK_TRACE_MIN_VERSION
) {
1062 stlink_usb_init_buffer(handle
, h
->rx_ep
, 10);
1064 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1065 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_START_TRACE_RX
;
1066 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, (uint16_t)STLINK_TRACE_SIZE
);
1068 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, h
->trace
.source_hz
);
1071 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
1073 if (res
== ERROR_OK
) {
1074 h
->trace
.enabled
= true;
1075 LOG_DEBUG("Tracing: recording at %" PRIu32
"Hz", h
->trace
.source_hz
);
1078 LOG_ERROR("Tracing is not supported by this version.");
1086 static int stlink_usb_reset(void *handle
)
1088 struct stlink_usb_handle_s
*h
= handle
;
1091 assert(handle
!= NULL
);
1093 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1095 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1097 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
1098 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_RESETSYS
;
1100 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_RESETSYS
;
1102 retval
= stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1103 if (retval
!= ERROR_OK
)
1106 if (h
->trace
.enabled
) {
1107 stlink_usb_trace_disable(h
);
1108 return stlink_usb_trace_enable(h
);
1115 static int stlink_usb_run(void *handle
)
1118 struct stlink_usb_handle_s
*h
= handle
;
1120 assert(handle
!= NULL
);
1122 if (h
->jtag_api
== STLINK_JTAG_API_V2
) {
1123 res
= stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_DEBUGEN
);
1128 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1130 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1131 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_RUNCORE
;
1133 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1137 static int stlink_usb_halt(void *handle
)
1140 struct stlink_usb_handle_s
*h
= handle
;
1142 assert(handle
!= NULL
);
1144 if (h
->jtag_api
== STLINK_JTAG_API_V2
) {
1145 res
= stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_HALT
|C_DEBUGEN
);
1150 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1152 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1153 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_FORCEDEBUG
;
1155 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1159 static int stlink_usb_step(void *handle
)
1161 struct stlink_usb_handle_s
*h
= handle
;
1163 assert(handle
!= NULL
);
1165 if (h
->jtag_api
== STLINK_JTAG_API_V2
) {
1166 /* TODO: this emulates the v1 api, it should really use a similar auto mask isr
1167 * that the cortex-m3 currently does. */
1168 stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_HALT
|C_MASKINTS
|C_DEBUGEN
);
1169 stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_STEP
|C_MASKINTS
|C_DEBUGEN
);
1170 return stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_HALT
|C_DEBUGEN
);
1173 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1175 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1176 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_STEPCORE
;
1178 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1182 static int stlink_usb_read_regs(void *handle
)
1185 struct stlink_usb_handle_s
*h
= handle
;
1187 assert(handle
!= NULL
);
1189 stlink_usb_init_buffer(handle
, h
->rx_ep
, 84);
1191 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1192 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
1193 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_READALLREGS
;
1195 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READALLREGS
;
1197 res
= stlink_usb_xfer(handle
, h
->databuf
, 84);
1199 if (res
!= ERROR_OK
)
1206 static int stlink_usb_read_reg(void *handle
, int num
, uint32_t *val
)
1209 struct stlink_usb_handle_s
*h
= handle
;
1211 assert(handle
!= NULL
);
1213 stlink_usb_init_buffer(handle
, h
->rx_ep
, h
->jtag_api
== STLINK_JTAG_API_V1
? 4 : 8);
1215 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1216 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
1217 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_READREG
;
1219 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READREG
;
1220 h
->cmdbuf
[h
->cmdidx
++] = num
;
1222 if (h
->jtag_api
== STLINK_JTAG_API_V1
) {
1223 res
= stlink_usb_xfer(handle
, h
->databuf
, 4);
1224 if (res
!= ERROR_OK
)
1226 *val
= le_to_h_u32(h
->databuf
);
1229 res
= stlink_cmd_allow_retry(handle
, h
->databuf
, 8);
1230 if (res
!= ERROR_OK
)
1232 *val
= le_to_h_u32(h
->databuf
+ 4);
1238 static int stlink_usb_write_reg(void *handle
, int num
, uint32_t val
)
1240 struct stlink_usb_handle_s
*h
= handle
;
1242 assert(handle
!= NULL
);
1244 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1246 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1247 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
1248 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_WRITEREG
;
1250 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_WRITEREG
;
1251 h
->cmdbuf
[h
->cmdidx
++] = num
;
1252 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, val
);
1255 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1258 static int stlink_usb_get_rw_status(void *handle
)
1261 struct stlink_usb_handle_s
*h
= handle
;
1263 assert(handle
!= NULL
);
1265 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
1268 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1270 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1271 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_GETLASTRWSTATUS
;
1273 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
1275 if (res
!= ERROR_OK
)
1278 return stlink_usb_error_check(h
);
1282 static int stlink_usb_read_mem8(void *handle
, uint32_t addr
, uint16_t len
,
1286 uint16_t read_len
= len
;
1287 struct stlink_usb_handle_s
*h
= handle
;
1289 assert(handle
!= NULL
);
1291 /* max 8bit read/write is 64bytes */
1292 if (len
> STLINK_MAX_RW8
) {
1293 LOG_DEBUG("max buffer length exceeded");
1297 stlink_usb_init_buffer(handle
, h
->rx_ep
, read_len
);
1299 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1300 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READMEM_8BIT
;
1301 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1303 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1306 /* we need to fix read length for single bytes */
1310 res
= stlink_usb_xfer(handle
, h
->databuf
, read_len
);
1312 if (res
!= ERROR_OK
)
1315 memcpy(buffer
, h
->databuf
, len
);
1317 return stlink_usb_get_rw_status(handle
);
1321 static int stlink_usb_write_mem8(void *handle
, uint32_t addr
, uint16_t len
,
1322 const uint8_t *buffer
)
1325 struct stlink_usb_handle_s
*h
= handle
;
1327 assert(handle
!= NULL
);
1329 /* max 8bit read/write is 64bytes */
1330 if (len
> STLINK_MAX_RW8
) {
1331 LOG_DEBUG("max buffer length exceeded");
1335 stlink_usb_init_buffer(handle
, h
->tx_ep
, len
);
1337 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1338 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_WRITEMEM_8BIT
;
1339 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1341 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1344 res
= stlink_usb_xfer(handle
, buffer
, len
);
1346 if (res
!= ERROR_OK
)
1349 return stlink_usb_get_rw_status(handle
);
1353 static int stlink_usb_read_mem32(void *handle
, uint32_t addr
, uint16_t len
,
1357 struct stlink_usb_handle_s
*h
= handle
;
1359 assert(handle
!= NULL
);
1361 /* data must be a multiple of 4 and word aligned */
1362 if (len
% 4 || addr
% 4) {
1363 LOG_DEBUG("Invalid data alignment");
1364 return ERROR_TARGET_UNALIGNED_ACCESS
;
1367 stlink_usb_init_buffer(handle
, h
->rx_ep
, len
);
1369 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1370 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READMEM_32BIT
;
1371 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1373 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1376 res
= stlink_usb_xfer(handle
, h
->databuf
, len
);
1378 if (res
!= ERROR_OK
)
1381 memcpy(buffer
, h
->databuf
, len
);
1383 return stlink_usb_get_rw_status(handle
);
1387 static int stlink_usb_write_mem32(void *handle
, uint32_t addr
, uint16_t len
,
1388 const uint8_t *buffer
)
1391 struct stlink_usb_handle_s
*h
= handle
;
1393 assert(handle
!= NULL
);
1395 /* data must be a multiple of 4 and word aligned */
1396 if (len
% 4 || addr
% 4) {
1397 LOG_DEBUG("Invalid data alignment");
1398 return ERROR_TARGET_UNALIGNED_ACCESS
;
1401 stlink_usb_init_buffer(handle
, h
->tx_ep
, len
);
1403 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1404 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_WRITEMEM_32BIT
;
1405 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1407 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1410 res
= stlink_usb_xfer(handle
, buffer
, len
);
1412 if (res
!= ERROR_OK
)
1415 return stlink_usb_get_rw_status(handle
);
1418 static uint32_t stlink_max_block_size(uint32_t tar_autoincr_block
, uint32_t address
)
1420 uint32_t max_tar_block
= (tar_autoincr_block
- ((tar_autoincr_block
- 1) & address
));
1421 if (max_tar_block
== 0)
1423 return max_tar_block
;
1426 static int stlink_usb_read_mem(void *handle
, uint32_t addr
, uint32_t size
,
1427 uint32_t count
, uint8_t *buffer
)
1429 int retval
= ERROR_OK
;
1430 uint32_t bytes_remaining
;
1432 struct stlink_usb_handle_s
*h
= handle
;
1434 /* calculate byte count */
1439 bytes_remaining
= (size
== 4) ? \
1440 stlink_max_block_size(h
->max_mem_packet
, addr
) : STLINK_MAX_RW8
;
1442 if (count
< bytes_remaining
)
1443 bytes_remaining
= count
;
1445 /* the stlink only supports 8/32bit memory read/writes
1446 * honour 32bit, all others will be handled as 8bit access */
1449 /* When in jtag mode the stlink uses the auto-increment functinality.
1450 * However it expects us to pass the data correctly, this includes
1451 * alignment and any page boundaries. We already do this as part of the
1452 * adi_v5 implementation, but the stlink is a hla adapter and so this
1453 * needs implementiong manually.
1454 * currently this only affects jtag mode, according to ST they do single
1455 * access in SWD mode - but this may change and so we do it for both modes */
1457 /* we first need to check for any unaligned bytes */
1460 uint32_t head_bytes
= 4 - (addr
% 4);
1461 retval
= stlink_usb_read_mem8(handle
, addr
, head_bytes
, buffer
);
1462 if (retval
== ERROR_WAIT
&& retries
< MAX_WAIT_RETRIES
) {
1463 usleep((1<<retries
++) * 1000);
1466 if (retval
!= ERROR_OK
)
1468 buffer
+= head_bytes
;
1470 count
-= head_bytes
;
1471 bytes_remaining
-= head_bytes
;
1474 if (bytes_remaining
% 4)
1475 retval
= stlink_usb_read_mem(handle
, addr
, 1, bytes_remaining
, buffer
);
1477 retval
= stlink_usb_read_mem32(handle
, addr
, bytes_remaining
, buffer
);
1479 retval
= stlink_usb_read_mem8(handle
, addr
, bytes_remaining
, buffer
);
1481 if (retval
== ERROR_WAIT
&& retries
< MAX_WAIT_RETRIES
) {
1482 usleep((1<<retries
++) * 1000);
1485 if (retval
!= ERROR_OK
)
1488 buffer
+= bytes_remaining
;
1489 addr
+= bytes_remaining
;
1490 count
-= bytes_remaining
;
1496 static int stlink_usb_write_mem(void *handle
, uint32_t addr
, uint32_t size
,
1497 uint32_t count
, const uint8_t *buffer
)
1499 int retval
= ERROR_OK
;
1500 uint32_t bytes_remaining
;
1502 struct stlink_usb_handle_s
*h
= handle
;
1504 /* calculate byte count */
1509 bytes_remaining
= (size
== 4) ? \
1510 stlink_max_block_size(h
->max_mem_packet
, addr
) : STLINK_MAX_RW8
;
1512 if (count
< bytes_remaining
)
1513 bytes_remaining
= count
;
1515 /* the stlink only supports 8/32bit memory read/writes
1516 * honour 32bit, all others will be handled as 8bit access */
1519 /* When in jtag mode the stlink uses the auto-increment functinality.
1520 * However it expects us to pass the data correctly, this includes
1521 * alignment and any page boundaries. We already do this as part of the
1522 * adi_v5 implementation, but the stlink is a hla adapter and so this
1523 * needs implementiong manually.
1524 * currently this only affects jtag mode, according to ST they do single
1525 * access in SWD mode - but this may change and so we do it for both modes */
1527 /* we first need to check for any unaligned bytes */
1530 uint32_t head_bytes
= 4 - (addr
% 4);
1531 retval
= stlink_usb_write_mem8(handle
, addr
, head_bytes
, buffer
);
1532 if (retval
== ERROR_WAIT
&& retries
< MAX_WAIT_RETRIES
) {
1533 usleep((1<<retries
++) * 1000);
1536 if (retval
!= ERROR_OK
)
1538 buffer
+= head_bytes
;
1540 count
-= head_bytes
;
1541 bytes_remaining
-= head_bytes
;
1544 if (bytes_remaining
% 4)
1545 retval
= stlink_usb_write_mem(handle
, addr
, 1, bytes_remaining
, buffer
);
1547 retval
= stlink_usb_write_mem32(handle
, addr
, bytes_remaining
, buffer
);
1550 retval
= stlink_usb_write_mem8(handle
, addr
, bytes_remaining
, buffer
);
1551 if (retval
== ERROR_WAIT
&& retries
< MAX_WAIT_RETRIES
) {
1552 usleep((1<<retries
++) * 1000);
1555 if (retval
!= ERROR_OK
)
1558 buffer
+= bytes_remaining
;
1559 addr
+= bytes_remaining
;
1560 count
-= bytes_remaining
;
1567 static int stlink_usb_override_target(const char *targetname
)
1569 return !strcmp(targetname
, "cortex_m");
1572 static int stlink_speed(void *handle
, int khz
, bool query
)
1575 int speed_index
= -1;
1576 int speed_diff
= INT_MAX
;
1577 struct stlink_usb_handle_s
*h
= handle
;
1579 /* only supported by stlink/v2 and for firmware >= 22 */
1580 if (h
&& (h
->version
.stlink
== 1 || h
->version
.jtag
< 22))
1583 for (i
= 0; i
< ARRAY_SIZE(stlink_khz_to_speed_map
); i
++) {
1584 if (khz
== stlink_khz_to_speed_map
[i
].speed
) {
1588 int current_diff
= khz
- stlink_khz_to_speed_map
[i
].speed
;
1589 /* get abs value for comparison */
1590 current_diff
= (current_diff
> 0) ? current_diff
: -current_diff
;
1591 if ((current_diff
< speed_diff
) && khz
>= stlink_khz_to_speed_map
[i
].speed
) {
1592 speed_diff
= current_diff
;
1600 if (speed_index
== -1) {
1601 /* this will only be here if we cannot match the slow speed.
1602 * use the slowest speed we support.*/
1603 speed_index
= ARRAY_SIZE(stlink_khz_to_speed_map
) - 1;
1605 } else if (i
== ARRAY_SIZE(stlink_khz_to_speed_map
))
1608 if (!match
&& query
) {
1609 LOG_INFO("Unable to match requested speed %d kHz, using %d kHz", \
1610 khz
, stlink_khz_to_speed_map
[speed_index
].speed
);
1614 int result
= stlink_usb_set_swdclk(h
, stlink_khz_to_speed_map
[speed_index
].speed_divisor
);
1615 if (result
!= ERROR_OK
) {
1616 LOG_ERROR("Unable to set adapter speed");
1621 return stlink_khz_to_speed_map
[speed_index
].speed
;
1625 static int stlink_usb_close(void *handle
)
1627 struct stlink_usb_handle_s
*h
= handle
;
1630 jtag_libusb_close(h
->fd
);
1638 static int stlink_usb_open(struct hl_interface_param_s
*param
, void **fd
)
1640 int err
, retry_count
= 1;
1641 struct stlink_usb_handle_s
*h
;
1642 enum stlink_jtag_api_version api
;
1644 LOG_DEBUG("stlink_usb_open");
1646 h
= calloc(1, sizeof(struct stlink_usb_handle_s
));
1649 LOG_DEBUG("malloc failed");
1653 h
->transport
= param
->transport
;
1655 const uint16_t vids
[] = { param
->vid
, 0 };
1656 const uint16_t pids
[] = { param
->pid
, 0 };
1657 const char *serial
= param
->serial
;
1659 LOG_DEBUG("transport: %d vid: 0x%04x pid: 0x%04x serial: %s",
1660 param
->transport
, param
->vid
, param
->pid
,
1661 param
->serial
? param
->serial
: "");
1664 On certain host USB configurations(e.g. MacBook Air)
1665 STLINKv2 dongle seems to have its FW in a funky state if,
1666 after plugging it in, you try to use openocd with it more
1667 then once (by launching and closing openocd). In cases like
1668 that initial attempt to read the FW info via
1669 stlink_usb_version will fail and the device has to be reset
1670 in order to become operational.
1673 if (jtag_libusb_open(vids
, pids
, serial
, &h
->fd
) != ERROR_OK
) {
1674 LOG_ERROR("open failed");
1678 jtag_libusb_set_configuration(h
->fd
, 0);
1680 if (jtag_libusb_claim_interface(h
->fd
, 0) != ERROR_OK
) {
1681 LOG_DEBUG("claim interface failed");
1685 /* RX EP is common for all versions */
1686 h
->rx_ep
= STLINK_RX_EP
;
1688 /* wrap version for first read */
1689 switch (param
->pid
) {
1691 h
->version
.stlink
= 1;
1692 h
->tx_ep
= STLINK_TX_EP
;
1693 h
->trace_ep
= STLINK_TRACE_EP
;
1695 case STLINK_V2_1_PID
:
1696 h
->version
.stlink
= 2;
1697 h
->tx_ep
= STLINK_V2_1_TX_EP
;
1698 h
->trace_ep
= STLINK_V2_1_TRACE_EP
;
1701 /* fall through - we assume V2 to be the default version*/
1703 h
->version
.stlink
= 2;
1704 h
->tx_ep
= STLINK_TX_EP
;
1705 h
->trace_ep
= STLINK_TRACE_EP
;
1709 /* get the device version */
1710 err
= stlink_usb_version(h
);
1712 if (err
== ERROR_OK
) {
1714 } else if (h
->version
.stlink
== 1 ||
1716 LOG_ERROR("read version failed");
1719 err
= jtag_libusb_release_interface(h
->fd
, 0);
1720 if (err
!= ERROR_OK
) {
1721 LOG_ERROR("release interface failed");
1725 err
= jtag_libusb_reset_device(h
->fd
);
1726 if (err
!= ERROR_OK
) {
1727 LOG_ERROR("reset device failed");
1731 jtag_libusb_close(h
->fd
);
1733 Give the device one second to settle down and
1736 usleep(1 * 1000 * 1000);
1741 /* compare usb vid/pid */
1742 if ((param
->vid
!= h
->vid
) || (param
->pid
!= h
->pid
))
1743 LOG_INFO("vid/pid are not identical: 0x%04X/0x%04X 0x%04X/0x%04X",
1744 param
->vid
, param
->pid
,
1747 /* check if mode is supported */
1750 switch (h
->transport
) {
1751 case HL_TRANSPORT_SWD
:
1752 case HL_TRANSPORT_JTAG
:
1753 if (h
->version
.jtag
== 0)
1756 case HL_TRANSPORT_SWIM
:
1757 if (h
->version
.swim
== 0)
1765 if (err
!= ERROR_OK
) {
1766 LOG_ERROR("mode (transport) not supported by device");
1770 api
= h
->version
.jtag_api_max
;
1772 LOG_INFO("using stlink api v%d", api
);
1774 /* set the used jtag api, this will default to the newest supported version */
1777 /* initialize the debug hardware */
1778 err
= stlink_usb_init_mode(h
, param
->connect_under_reset
);
1780 if (err
!= ERROR_OK
) {
1781 LOG_ERROR("init mode failed (unable to connect to the target)");
1785 /* clock speed only supported by stlink/v2 and for firmware >= 22 */
1786 if (h
->version
.stlink
>= 2 && h
->version
.jtag
>= 22) {
1787 LOG_DEBUG("Supported clock speeds are:");
1789 for (unsigned i
= 0; i
< ARRAY_SIZE(stlink_khz_to_speed_map
); i
++)
1790 LOG_DEBUG("%d kHz", stlink_khz_to_speed_map
[i
].speed
);
1792 stlink_speed(h
, param
->initial_interface_speed
, false);
1795 /* get cpuid, so we can determine the max page size
1796 * start with a safe default */
1797 h
->max_mem_packet
= (1 << 10);
1800 err
= stlink_usb_read_mem32(h
, CPUID
, 4, buffer
);
1801 if (err
== ERROR_OK
) {
1802 uint32_t cpuid
= le_to_h_u32(buffer
);
1803 int i
= (cpuid
>> 4) & 0xf;
1804 if (i
== 4 || i
== 3) {
1805 /* Cortex-M3/M4 has 4096 bytes autoincrement range */
1806 h
->max_mem_packet
= (1 << 12);
1810 LOG_DEBUG("Using TAR autoincrement: %" PRIu32
, h
->max_mem_packet
);
1817 stlink_usb_close(h
);
1822 int stlink_config_trace(void *handle
, bool enabled
, enum tpio_pin_protocol pin_protocol
,
1823 uint32_t port_size
, unsigned int *trace_freq
)
1825 struct stlink_usb_handle_s
*h
= handle
;
1827 if (enabled
&& (h
->jtag_api
< 2 || pin_protocol
!= ASYNC_UART
)) {
1828 LOG_ERROR("The attached ST-LINK version doesn't support this trace mode");
1833 stlink_usb_trace_disable(h
);
1837 if (*trace_freq
> STLINK_TRACE_MAX_HZ
) {
1838 LOG_ERROR("ST-LINK doesn't support SWO frequency higher than %u",
1839 STLINK_TRACE_MAX_HZ
);
1843 stlink_usb_trace_disable(h
);
1846 *trace_freq
= STLINK_TRACE_MAX_HZ
;
1847 h
->trace
.source_hz
= *trace_freq
;
1849 return stlink_usb_trace_enable(h
);
1853 struct hl_layout_api_s stlink_usb_layout_api
= {
1855 .open
= stlink_usb_open
,
1857 .close
= stlink_usb_close
,
1859 .idcode
= stlink_usb_idcode
,
1861 .state
= stlink_usb_state
,
1863 .reset
= stlink_usb_reset
,
1865 .assert_srst
= stlink_usb_assert_srst
,
1867 .run
= stlink_usb_run
,
1869 .halt
= stlink_usb_halt
,
1871 .step
= stlink_usb_step
,
1873 .read_regs
= stlink_usb_read_regs
,
1875 .read_reg
= stlink_usb_read_reg
,
1877 .write_reg
= stlink_usb_write_reg
,
1879 .read_mem
= stlink_usb_read_mem
,
1881 .write_mem
= stlink_usb_write_mem
,
1883 .write_debug_reg
= stlink_usb_write_debug_reg
,
1885 .override_target
= stlink_usb_override_target
,
1887 .speed
= stlink_speed
,
1889 .config_trace
= stlink_config_trace
,
1891 .poll_trace
= stlink_usb_trace_read
,
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)