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 data destination file */
129 /** trace module source clock (for prescaler) */
131 /** trace module clock prescaler */
134 /** reconnect is needed next time we try to query the
136 bool reconnect_pending
;
139 #define STLINK_DEBUG_ERR_OK 0x80
140 #define STLINK_DEBUG_ERR_FAULT 0x81
141 #define STLINK_SWD_AP_WAIT 0x10
142 #define STLINK_SWD_DP_WAIT 0x14
144 #define STLINK_CORE_RUNNING 0x80
145 #define STLINK_CORE_HALTED 0x81
146 #define STLINK_CORE_STAT_UNKNOWN -1
148 #define STLINK_GET_VERSION 0xF1
149 #define STLINK_DEBUG_COMMAND 0xF2
150 #define STLINK_DFU_COMMAND 0xF3
151 #define STLINK_SWIM_COMMAND 0xF4
152 #define STLINK_GET_CURRENT_MODE 0xF5
153 #define STLINK_GET_TARGET_VOLTAGE 0xF7
155 #define STLINK_DEV_DFU_MODE 0x00
156 #define STLINK_DEV_MASS_MODE 0x01
157 #define STLINK_DEV_DEBUG_MODE 0x02
158 #define STLINK_DEV_SWIM_MODE 0x03
159 #define STLINK_DEV_BOOTLOADER_MODE 0x04
160 #define STLINK_DEV_UNKNOWN_MODE -1
162 #define STLINK_DFU_EXIT 0x07
164 #define STLINK_SWIM_ENTER 0x00
165 #define STLINK_SWIM_EXIT 0x01
167 #define STLINK_DEBUG_ENTER_JTAG 0x00
168 #define STLINK_DEBUG_GETSTATUS 0x01
169 #define STLINK_DEBUG_FORCEDEBUG 0x02
170 #define STLINK_DEBUG_APIV1_RESETSYS 0x03
171 #define STLINK_DEBUG_APIV1_READALLREGS 0x04
172 #define STLINK_DEBUG_APIV1_READREG 0x05
173 #define STLINK_DEBUG_APIV1_WRITEREG 0x06
174 #define STLINK_DEBUG_READMEM_32BIT 0x07
175 #define STLINK_DEBUG_WRITEMEM_32BIT 0x08
176 #define STLINK_DEBUG_RUNCORE 0x09
177 #define STLINK_DEBUG_STEPCORE 0x0a
178 #define STLINK_DEBUG_APIV1_SETFP 0x0b
179 #define STLINK_DEBUG_READMEM_8BIT 0x0c
180 #define STLINK_DEBUG_WRITEMEM_8BIT 0x0d
181 #define STLINK_DEBUG_APIV1_CLEARFP 0x0e
182 #define STLINK_DEBUG_APIV1_WRITEDEBUGREG 0x0f
183 #define STLINK_DEBUG_APIV1_SETWATCHPOINT 0x10
185 #define STLINK_DEBUG_ENTER_JTAG 0x00
186 #define STLINK_DEBUG_ENTER_SWD 0xa3
188 #define STLINK_DEBUG_APIV1_ENTER 0x20
189 #define STLINK_DEBUG_EXIT 0x21
190 #define STLINK_DEBUG_READCOREID 0x22
192 #define STLINK_DEBUG_APIV2_ENTER 0x30
193 #define STLINK_DEBUG_APIV2_READ_IDCODES 0x31
194 #define STLINK_DEBUG_APIV2_RESETSYS 0x32
195 #define STLINK_DEBUG_APIV2_READREG 0x33
196 #define STLINK_DEBUG_APIV2_WRITEREG 0x34
197 #define STLINK_DEBUG_APIV2_WRITEDEBUGREG 0x35
198 #define STLINK_DEBUG_APIV2_READDEBUGREG 0x36
200 #define STLINK_DEBUG_APIV2_READALLREGS 0x3A
201 #define STLINK_DEBUG_APIV2_GETLASTRWSTATUS 0x3B
202 #define STLINK_DEBUG_APIV2_DRIVE_NRST 0x3C
204 #define STLINK_DEBUG_APIV2_START_TRACE_RX 0x40
205 #define STLINK_DEBUG_APIV2_STOP_TRACE_RX 0x41
206 #define STLINK_DEBUG_APIV2_GET_TRACE_NB 0x42
208 #define STLINK_DEBUG_APIV2_DRIVE_NRST_LOW 0x00
209 #define STLINK_DEBUG_APIV2_DRIVE_NRST_HIGH 0x01
210 #define STLINK_DEBUG_APIV2_DRIVE_NRST_PULSE 0x02
212 #define STLINK_TRACE_SIZE 1024
213 #define STLINK_TRACE_MAX_HZ 2000000
214 #define STLINK_TRACE_MIN_VERSION 13
218 STLINK_MODE_UNKNOWN
= 0,
221 STLINK_MODE_DEBUG_JTAG
,
222 STLINK_MODE_DEBUG_SWD
,
223 STLINK_MODE_DEBUG_SWIM
226 #define REQUEST_SENSE 0x03
227 #define REQUEST_SENSE_LENGTH 18
229 static void stlink_usb_init_buffer(void *handle
, uint8_t direction
, uint32_t size
);
232 static int stlink_usb_xfer_v1_get_status(void *handle
)
234 struct stlink_usb_handle_s
*h
= handle
;
236 assert(handle
!= NULL
);
239 memset(h
->cmdbuf
, 0, STLINK_SG_SIZE
);
241 if (jtag_libusb_bulk_read(h
->fd
, h
->rx_ep
, (char *)h
->cmdbuf
,
242 13, STLINK_READ_TIMEOUT
) != 13)
247 t1
= buf_get_u32(h
->cmdbuf
, 0, 32);
250 if (t1
!= 0x53425355)
258 if (h
->cmdbuf
[12] != 0)
265 static int stlink_usb_xfer_rw(void *handle
, int cmdsize
, const uint8_t *buf
, int size
)
267 struct stlink_usb_handle_s
*h
= handle
;
269 assert(handle
!= NULL
);
271 if (jtag_libusb_bulk_write(h
->fd
, h
->tx_ep
, (char *)h
->cmdbuf
, cmdsize
,
272 STLINK_WRITE_TIMEOUT
) != cmdsize
) {
276 if (h
->direction
== h
->tx_ep
&& size
) {
277 if (jtag_libusb_bulk_write(h
->fd
, h
->tx_ep
, (char *)buf
,
278 size
, STLINK_WRITE_TIMEOUT
) != size
) {
279 LOG_DEBUG("bulk write failed");
282 } else if (h
->direction
== h
->rx_ep
&& size
) {
283 if (jtag_libusb_bulk_read(h
->fd
, h
->rx_ep
, (char *)buf
,
284 size
, STLINK_READ_TIMEOUT
) != size
) {
285 LOG_DEBUG("bulk read failed");
294 static int stlink_usb_xfer_v1_get_sense(void *handle
)
297 struct stlink_usb_handle_s
*h
= handle
;
299 assert(handle
!= NULL
);
301 stlink_usb_init_buffer(handle
, h
->rx_ep
, 16);
303 h
->cmdbuf
[h
->cmdidx
++] = REQUEST_SENSE
;
304 h
->cmdbuf
[h
->cmdidx
++] = 0;
305 h
->cmdbuf
[h
->cmdidx
++] = 0;
306 h
->cmdbuf
[h
->cmdidx
++] = 0;
307 h
->cmdbuf
[h
->cmdidx
++] = REQUEST_SENSE_LENGTH
;
309 res
= stlink_usb_xfer_rw(handle
, REQUEST_SENSE_LENGTH
, h
->databuf
, 16);
314 if (stlink_usb_xfer_v1_get_status(handle
) != ERROR_OK
)
321 static int stlink_usb_xfer(void *handle
, const uint8_t *buf
, int size
)
323 int err
, cmdsize
= STLINK_CMD_SIZE_V2
;
324 struct stlink_usb_handle_s
*h
= handle
;
326 assert(handle
!= NULL
);
328 if (h
->version
.stlink
== 1)
329 cmdsize
= STLINK_SG_SIZE
;
331 err
= stlink_usb_xfer_rw(handle
, cmdsize
, buf
, size
);
336 if (h
->version
.stlink
== 1) {
337 if (stlink_usb_xfer_v1_get_status(handle
) != ERROR_OK
) {
338 /* check csw status */
339 if (h
->cmdbuf
[12] == 1) {
340 LOG_DEBUG("get sense");
341 if (stlink_usb_xfer_v1_get_sense(handle
) != ERROR_OK
)
353 Converts an STLINK status code held in the first byte of a response
354 to an openocd error, logs any error/wait status as debug output.
356 static int stlink_usb_error_check(void *handle
)
358 struct stlink_usb_handle_s
*h
= handle
;
360 assert(handle
!= NULL
);
362 /* TODO: no error checking yet on api V1 */
363 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
364 h
->databuf
[0] = STLINK_DEBUG_ERR_OK
;
366 switch (h
->databuf
[0]) {
367 case STLINK_DEBUG_ERR_OK
:
369 case STLINK_DEBUG_ERR_FAULT
:
370 LOG_DEBUG("SWD fault response (0x%x)", STLINK_DEBUG_ERR_FAULT
);
372 case STLINK_SWD_AP_WAIT
:
373 LOG_DEBUG("wait status SWD_AP_WAIT (0x%x)", STLINK_SWD_AP_WAIT
);
375 case STLINK_SWD_DP_WAIT
:
376 LOG_DEBUG("wait status SWD_DP_WAIT (0x%x)", STLINK_SWD_AP_WAIT
);
379 LOG_DEBUG("unknown/unexpected STLINK status code 0x%x", h
->databuf
[0]);
385 /** Issue an STLINK command via USB transfer, with retries on any wait status responses.
387 Works for commands where the STLINK_DEBUG status is returned in the first
388 byte of the response packet.
390 Returns an openocd result code.
392 static int stlink_cmd_allow_retry(void *handle
, const uint8_t *buf
, int size
)
397 res
= stlink_usb_xfer(handle
, buf
, size
);
400 res
= stlink_usb_error_check(handle
);
401 if (res
== ERROR_WAIT
&& retries
< MAX_WAIT_RETRIES
) {
402 usleep((1<<retries
++) * 1000);
410 static int stlink_usb_read_trace(void *handle
, const uint8_t *buf
, int size
)
412 struct stlink_usb_handle_s
*h
= handle
;
414 assert(handle
!= NULL
);
416 assert(h
->version
.stlink
>= 2);
418 if (jtag_libusb_bulk_read(h
->fd
, h
->trace_ep
, (char *)buf
,
419 size
, STLINK_READ_TIMEOUT
) != size
) {
420 LOG_ERROR("bulk trace read failed");
428 static void stlink_usb_xfer_v1_create_cmd(void *handle
, uint8_t direction
, uint32_t size
)
430 struct stlink_usb_handle_s
*h
= handle
;
432 /* fill the send buffer */
433 strcpy((char *)h
->cmdbuf
, "USBC");
435 /* csw tag not used */
437 buf_set_u32(h
->cmdbuf
+h
->cmdidx
, 0, 32, size
);
439 h
->cmdbuf
[h
->cmdidx
++] = (direction
== h
->rx_ep
? ENDPOINT_IN
: ENDPOINT_OUT
);
440 h
->cmdbuf
[h
->cmdidx
++] = 0; /* lun */
441 h
->cmdbuf
[h
->cmdidx
++] = STLINK_CMD_SIZE_V1
;
445 static void stlink_usb_init_buffer(void *handle
, uint8_t direction
, uint32_t size
)
447 struct stlink_usb_handle_s
*h
= handle
;
449 h
->direction
= direction
;
453 memset(h
->cmdbuf
, 0, STLINK_SG_SIZE
);
454 memset(h
->databuf
, 0, STLINK_DATA_SIZE
);
456 if (h
->version
.stlink
== 1)
457 stlink_usb_xfer_v1_create_cmd(handle
, direction
, size
);
461 static int stlink_usb_version(void *handle
)
465 struct stlink_usb_handle_s
*h
= handle
;
467 assert(handle
!= NULL
);
469 stlink_usb_init_buffer(handle
, h
->rx_ep
, 6);
471 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_VERSION
;
473 res
= stlink_usb_xfer(handle
, h
->databuf
, 6);
478 v
= (h
->databuf
[0] << 8) | h
->databuf
[1];
480 h
->version
.stlink
= (v
>> 12) & 0x0f;
481 h
->version
.jtag
= (v
>> 6) & 0x3f;
482 h
->version
.swim
= v
& 0x3f;
483 h
->vid
= buf_get_u32(h
->databuf
, 16, 16);
484 h
->pid
= buf_get_u32(h
->databuf
, 32, 16);
486 /* set the supported jtag api version
487 * API V2 is supported since JTAG V11
489 if (h
->version
.jtag
>= 11)
490 h
->version
.jtag_api_max
= STLINK_JTAG_API_V2
;
492 h
->version
.jtag_api_max
= STLINK_JTAG_API_V1
;
494 LOG_INFO("STLINK v%d JTAG v%d API v%d SWIM v%d VID 0x%04X PID 0x%04X",
497 (h
->version
.jtag_api_max
== STLINK_JTAG_API_V1
) ? 1 : 2,
505 static int stlink_usb_check_voltage(void *handle
, float *target_voltage
)
507 struct stlink_usb_handle_s
*h
= handle
;
508 uint32_t adc_results
[2];
510 /* only supported by stlink/v2 and for firmware >= 13 */
511 if (h
->version
.stlink
== 1 || h
->version
.jtag
< 13)
512 return ERROR_COMMAND_NOTFOUND
;
514 stlink_usb_init_buffer(handle
, h
->rx_ep
, 8);
516 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_TARGET_VOLTAGE
;
518 int result
= stlink_usb_xfer(handle
, h
->databuf
, 8);
520 if (result
!= ERROR_OK
)
524 adc_results
[0] = le_to_h_u32(h
->databuf
);
525 adc_results
[1] = le_to_h_u32(h
->databuf
+ 4);
530 *target_voltage
= 2 * ((float)adc_results
[1]) * (float)(1.2 / adc_results
[0]);
532 LOG_INFO("Target voltage: %f", (double)*target_voltage
);
538 static int stlink_usb_current_mode(void *handle
, uint8_t *mode
)
541 struct stlink_usb_handle_s
*h
= handle
;
543 assert(handle
!= NULL
);
545 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
547 h
->cmdbuf
[h
->cmdidx
++] = STLINK_GET_CURRENT_MODE
;
549 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
554 *mode
= h
->databuf
[0];
560 static int stlink_usb_mode_enter(void *handle
, enum stlink_mode type
)
563 struct stlink_usb_handle_s
*h
= handle
;
565 assert(handle
!= NULL
);
567 /* on api V2 we are able the read the latest command
569 * TODO: we need the test on api V1 too
571 if (h
->jtag_api
== STLINK_JTAG_API_V2
)
574 stlink_usb_init_buffer(handle
, h
->rx_ep
, rx_size
);
577 case STLINK_MODE_DEBUG_JTAG
:
578 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
579 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
580 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_ENTER
;
582 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_ENTER
;
583 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_ENTER_JTAG
;
585 case STLINK_MODE_DEBUG_SWD
:
586 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
587 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
588 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_ENTER
;
590 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_ENTER
;
591 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_ENTER_SWD
;
593 case STLINK_MODE_DEBUG_SWIM
:
594 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
595 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_ENTER
;
597 case STLINK_MODE_DFU
:
598 case STLINK_MODE_MASS
:
603 return stlink_cmd_allow_retry(handle
, h
->databuf
, rx_size
);
607 static int stlink_usb_mode_leave(void *handle
, enum stlink_mode type
)
610 struct stlink_usb_handle_s
*h
= handle
;
612 assert(handle
!= NULL
);
614 stlink_usb_init_buffer(handle
, STLINK_NULL_EP
, 0);
617 case STLINK_MODE_DEBUG_JTAG
:
618 case STLINK_MODE_DEBUG_SWD
:
619 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
620 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_EXIT
;
622 case STLINK_MODE_DEBUG_SWIM
:
623 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_COMMAND
;
624 h
->cmdbuf
[h
->cmdidx
++] = STLINK_SWIM_EXIT
;
626 case STLINK_MODE_DFU
:
627 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DFU_COMMAND
;
628 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DFU_EXIT
;
630 case STLINK_MODE_MASS
:
635 res
= stlink_usb_xfer(handle
, 0, 0);
643 static int stlink_usb_assert_srst(void *handle
, int srst
);
645 static enum stlink_mode
stlink_get_mode(enum hl_transports t
)
648 case HL_TRANSPORT_SWD
:
649 return STLINK_MODE_DEBUG_SWD
;
650 case HL_TRANSPORT_JTAG
:
651 return STLINK_MODE_DEBUG_JTAG
;
652 case HL_TRANSPORT_SWIM
:
653 return STLINK_MODE_DEBUG_SWIM
;
655 return STLINK_MODE_UNKNOWN
;
660 static int stlink_usb_init_mode(void *handle
, bool connect_under_reset
)
664 enum stlink_mode emode
;
665 struct stlink_usb_handle_s
*h
= handle
;
667 assert(handle
!= NULL
);
669 res
= stlink_usb_current_mode(handle
, &mode
);
674 LOG_DEBUG("MODE: 0x%02X", mode
);
676 /* try to exit current mode */
678 case STLINK_DEV_DFU_MODE
:
679 emode
= STLINK_MODE_DFU
;
681 case STLINK_DEV_DEBUG_MODE
:
682 emode
= STLINK_MODE_DEBUG_SWD
;
684 case STLINK_DEV_SWIM_MODE
:
685 emode
= STLINK_MODE_DEBUG_SWIM
;
687 case STLINK_DEV_BOOTLOADER_MODE
:
688 case STLINK_DEV_MASS_MODE
:
690 emode
= STLINK_MODE_UNKNOWN
;
694 if (emode
!= STLINK_MODE_UNKNOWN
) {
695 res
= stlink_usb_mode_leave(handle
, emode
);
701 res
= stlink_usb_current_mode(handle
, &mode
);
706 /* we check the target voltage here as an aid to debugging connection problems.
707 * the stlink requires the target Vdd to be connected for reliable debugging.
708 * this cmd is supported in all modes except DFU
710 if (mode
!= STLINK_DEV_DFU_MODE
) {
712 float target_voltage
;
714 /* check target voltage (if supported) */
715 res
= stlink_usb_check_voltage(h
, &target_voltage
);
717 if (res
!= ERROR_OK
) {
718 if (res
!= ERROR_COMMAND_NOTFOUND
)
719 LOG_ERROR("voltage check failed");
720 /* attempt to continue as it is not a catastrophic failure */
722 /* check for a sensible target voltage, operating range is 1.65-5.5v
723 * according to datasheet */
724 if (target_voltage
< 1.5)
725 LOG_ERROR("target voltage may be too low for reliable debugging");
729 LOG_DEBUG("MODE: 0x%02X", mode
);
731 /* set selected mode */
732 emode
= stlink_get_mode(h
->transport
);
734 if (emode
== STLINK_MODE_UNKNOWN
) {
735 LOG_ERROR("selected mode (transport) not supported");
739 if (connect_under_reset
) {
740 res
= stlink_usb_assert_srst(handle
, 0);
745 res
= stlink_usb_mode_enter(handle
, emode
);
750 res
= stlink_usb_current_mode(handle
, &mode
);
755 LOG_DEBUG("MODE: 0x%02X", mode
);
761 static int stlink_usb_idcode(void *handle
, uint32_t *idcode
)
764 struct stlink_usb_handle_s
*h
= handle
;
766 assert(handle
!= NULL
);
768 stlink_usb_init_buffer(handle
, h
->rx_ep
, 4);
770 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
771 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READCOREID
;
773 res
= stlink_usb_xfer(handle
, h
->databuf
, 4);
778 *idcode
= le_to_h_u32(h
->databuf
);
780 LOG_DEBUG("IDCODE: 0x%08" PRIX32
, *idcode
);
785 static int stlink_usb_v2_read_debug_reg(void *handle
, uint32_t addr
, uint32_t *val
)
787 struct stlink_usb_handle_s
*h
= handle
;
790 assert(handle
!= NULL
);
792 stlink_usb_init_buffer(handle
, h
->rx_ep
, 8);
794 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
795 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READDEBUGREG
;
796 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
799 res
= stlink_cmd_allow_retry(handle
, h
->databuf
, 8);
803 *val
= le_to_h_u32(h
->databuf
+ 4);
807 static int stlink_usb_write_debug_reg(void *handle
, uint32_t addr
, uint32_t val
)
809 struct stlink_usb_handle_s
*h
= handle
;
811 assert(handle
!= NULL
);
813 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
815 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
816 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
817 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_WRITEDEBUGREG
;
819 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_WRITEDEBUGREG
;
820 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
822 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, val
);
825 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
829 static void stlink_usb_trace_read(void *handle
)
831 struct stlink_usb_handle_s
*h
= handle
;
833 assert(handle
!= NULL
);
835 if (h
->trace
.enabled
&& h
->version
.jtag
>= STLINK_TRACE_MIN_VERSION
) {
838 stlink_usb_init_buffer(handle
, h
->rx_ep
, 10);
840 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
841 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_GET_TRACE_NB
;
843 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
844 if (res
== ERROR_OK
) {
845 uint8_t buf
[STLINK_TRACE_SIZE
];
846 size_t size
= le_to_h_u16(h
->databuf
);
849 size
= size
< sizeof(buf
) ? size
: sizeof(buf
) - 1;
851 res
= stlink_usb_read_trace(handle
, buf
, size
);
852 if (res
== ERROR_OK
) {
853 if (h
->trace
.output_f
) {
854 /* Log retrieved trace output */
855 if (fwrite(buf
, 1, size
, h
->trace
.output_f
) > 0)
856 fflush(h
->trace
.output_f
);
864 static int stlink_usb_trace_read_callback(void *handle
)
866 stlink_usb_trace_read(handle
);
870 static enum target_state
stlink_usb_v2_get_status(void *handle
)
875 result
= stlink_usb_v2_read_debug_reg(handle
, DCB_DHCSR
, &status
);
876 if (result
!= ERROR_OK
)
877 return TARGET_UNKNOWN
;
880 return TARGET_HALTED
;
881 else if (status
& S_RESET_ST
)
884 stlink_usb_trace_read(handle
);
886 return TARGET_RUNNING
;
890 static enum target_state
stlink_usb_state(void *handle
)
893 struct stlink_usb_handle_s
*h
= handle
;
895 assert(handle
!= NULL
);
897 if (h
->reconnect_pending
) {
898 LOG_INFO("Previous state query failed, trying to reconnect");
899 res
= stlink_usb_mode_enter(handle
, stlink_get_mode(h
->transport
));
902 return TARGET_UNKNOWN
;
904 h
->reconnect_pending
= false;
907 if (h
->jtag_api
== STLINK_JTAG_API_V2
) {
908 res
= stlink_usb_v2_get_status(handle
);
909 if (res
== TARGET_UNKNOWN
)
910 h
->reconnect_pending
= true;
914 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
916 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
917 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_GETSTATUS
;
919 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
922 return TARGET_UNKNOWN
;
924 if (h
->databuf
[0] == STLINK_CORE_RUNNING
)
925 return TARGET_RUNNING
;
926 if (h
->databuf
[0] == STLINK_CORE_HALTED
)
927 return TARGET_HALTED
;
929 h
->reconnect_pending
= true;
931 return TARGET_UNKNOWN
;
935 static int stlink_usb_reset(void *handle
)
937 struct stlink_usb_handle_s
*h
= handle
;
939 assert(handle
!= NULL
);
941 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
943 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
945 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
946 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_RESETSYS
;
948 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_RESETSYS
;
950 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
953 static int stlink_usb_assert_srst(void *handle
, int srst
)
955 struct stlink_usb_handle_s
*h
= handle
;
957 assert(handle
!= NULL
);
959 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
960 return ERROR_COMMAND_NOTFOUND
;
962 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
964 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
965 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_DRIVE_NRST
;
966 h
->cmdbuf
[h
->cmdidx
++] = srst
;
968 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
972 static int stlink_configure_target_trace_port(void *handle
)
976 struct stlink_usb_handle_s
*h
= handle
;
978 assert(handle
!= NULL
);
980 /* configure the TPI */
982 /* enable the trace subsystem */
983 res
= stlink_usb_v2_read_debug_reg(handle
, DCB_DEMCR
, ®
);
986 res
= stlink_usb_write_debug_reg(handle
, DCB_DEMCR
, TRCENA
|reg
);
989 /* set the TPI clock prescaler */
990 res
= stlink_usb_write_debug_reg(handle
, TPI_ACPR
, h
->trace
.prescale
);
993 /* select the pin protocol. The STLinkv2 only supports asynchronous
994 * UART emulation (NRZ) mode, so that's what we pick. */
995 res
= stlink_usb_write_debug_reg(handle
, TPI_SPPR
, 0x02);
998 /* disable continuous formatting */
999 res
= stlink_usb_write_debug_reg(handle
, TPI_FFCR
, (1<<8));
1000 if (res
!= ERROR_OK
)
1003 /* configure the ITM */
1005 /* unlock access to the ITM registers */
1006 res
= stlink_usb_write_debug_reg(handle
, ITM_LAR
, 0xC5ACCE55);
1007 if (res
!= ERROR_OK
)
1009 /* enable trace with ATB ID 1 */
1010 res
= stlink_usb_write_debug_reg(handle
, ITM_TCR
, (1<<16)|(1<<0)|(1<<2));
1011 if (res
!= ERROR_OK
)
1013 /* trace privilege */
1014 res
= stlink_usb_write_debug_reg(handle
, ITM_TPR
, 1);
1015 if (res
!= ERROR_OK
)
1017 /* trace port enable (port 0) */
1018 res
= stlink_usb_write_debug_reg(handle
, ITM_TER
, (1<<0));
1019 if (res
!= ERROR_OK
)
1028 static void stlink_usb_trace_disable(void *handle
)
1031 struct stlink_usb_handle_s
*h
= handle
;
1033 assert(handle
!= NULL
);
1035 assert(h
->version
.jtag
>= STLINK_TRACE_MIN_VERSION
);
1037 LOG_DEBUG("Tracing: disable");
1039 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1040 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1041 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_STOP_TRACE_RX
;
1042 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
1044 if (res
== ERROR_OK
) {
1045 h
->trace
.enabled
= false;
1046 target_unregister_timer_callback(stlink_usb_trace_read_callback
, handle
);
1052 static int stlink_usb_trace_enable(void *handle
)
1055 struct stlink_usb_handle_s
*h
= handle
;
1057 assert(handle
!= NULL
);
1059 if (h
->version
.jtag
>= STLINK_TRACE_MIN_VERSION
) {
1062 res
= stlink_configure_target_trace_port(handle
);
1063 if (res
!= ERROR_OK
)
1064 LOG_ERROR("Unable to configure tracing on target");
1066 trace_hz
= h
->trace
.prescale
> 0 ?
1067 h
->trace
.source_hz
/ (h
->trace
.prescale
+ 1) :
1070 stlink_usb_init_buffer(handle
, h
->rx_ep
, 10);
1072 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1073 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_START_TRACE_RX
;
1074 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, (uint16_t)STLINK_TRACE_SIZE
);
1076 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, trace_hz
);
1079 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
1081 if (res
== ERROR_OK
) {
1082 h
->trace
.enabled
= true;
1083 LOG_DEBUG("Tracing: recording at %" PRIu32
"Hz", trace_hz
);
1084 /* We need the trace read function to be called at a
1085 * high-enough frequency to ensure reasonable
1086 * "timeliness" in processing ITM/DWT data.
1087 * TODO: An alternative could be using the asynchronous
1088 * features of the libusb-1.0 API to queue up one or more
1089 * reads in advance and requeue them once they are
1091 target_register_timer_callback(stlink_usb_trace_read_callback
, 1, 1, handle
);
1094 LOG_ERROR("Tracing is not supported by this version.");
1102 static int stlink_usb_run(void *handle
)
1105 struct stlink_usb_handle_s
*h
= handle
;
1107 assert(handle
!= NULL
);
1109 if (h
->jtag_api
== STLINK_JTAG_API_V2
) {
1110 res
= stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_DEBUGEN
);
1112 /* Try to start tracing, if requested */
1113 if (res
== ERROR_OK
&& h
->trace
.source_hz
&& !h
->trace
.enabled
) {
1114 if (stlink_usb_trace_enable(handle
) == ERROR_OK
)
1115 LOG_DEBUG("Tracing: enabled");
1117 LOG_ERROR("Tracing: enable failed");
1123 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1125 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1126 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_RUNCORE
;
1128 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1132 static int stlink_usb_halt(void *handle
)
1135 struct stlink_usb_handle_s
*h
= handle
;
1137 assert(handle
!= NULL
);
1139 if (h
->jtag_api
== STLINK_JTAG_API_V2
) {
1140 res
= stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_HALT
|C_DEBUGEN
);
1142 if (res
== ERROR_OK
&& h
->trace
.enabled
)
1143 stlink_usb_trace_disable(handle
);
1148 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1150 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1151 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_FORCEDEBUG
;
1153 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1157 static int stlink_usb_step(void *handle
)
1159 struct stlink_usb_handle_s
*h
= handle
;
1161 assert(handle
!= NULL
);
1163 if (h
->jtag_api
== STLINK_JTAG_API_V2
) {
1164 /* TODO: this emulates the v1 api, it should really use a similar auto mask isr
1165 * that the cortex-m3 currently does. */
1166 stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_HALT
|C_MASKINTS
|C_DEBUGEN
);
1167 stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_STEP
|C_MASKINTS
|C_DEBUGEN
);
1168 return stlink_usb_write_debug_reg(handle
, DCB_DHCSR
, DBGKEY
|C_HALT
|C_DEBUGEN
);
1171 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1173 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1174 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_STEPCORE
;
1176 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1180 static int stlink_usb_read_regs(void *handle
)
1183 struct stlink_usb_handle_s
*h
= handle
;
1185 assert(handle
!= NULL
);
1187 stlink_usb_init_buffer(handle
, h
->rx_ep
, 84);
1189 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1190 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
1191 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_READALLREGS
;
1193 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READALLREGS
;
1195 res
= stlink_usb_xfer(handle
, h
->databuf
, 84);
1197 if (res
!= ERROR_OK
)
1204 static int stlink_usb_read_reg(void *handle
, int num
, uint32_t *val
)
1207 struct stlink_usb_handle_s
*h
= handle
;
1209 assert(handle
!= NULL
);
1211 stlink_usb_init_buffer(handle
, h
->rx_ep
, h
->jtag_api
== STLINK_JTAG_API_V1
? 4 : 8);
1213 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1214 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
1215 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_READREG
;
1217 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_READREG
;
1218 h
->cmdbuf
[h
->cmdidx
++] = num
;
1220 if (h
->jtag_api
== STLINK_JTAG_API_V1
) {
1221 res
= stlink_usb_xfer(handle
, h
->databuf
, 4);
1222 if (res
!= ERROR_OK
)
1224 *val
= le_to_h_u32(h
->databuf
);
1227 res
= stlink_cmd_allow_retry(handle
, h
->databuf
, 8);
1228 if (res
!= ERROR_OK
)
1230 *val
= le_to_h_u32(h
->databuf
+ 4);
1236 static int stlink_usb_write_reg(void *handle
, int num
, uint32_t val
)
1238 struct stlink_usb_handle_s
*h
= handle
;
1240 assert(handle
!= NULL
);
1242 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1244 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1245 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
1246 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV1_WRITEREG
;
1248 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_WRITEREG
;
1249 h
->cmdbuf
[h
->cmdidx
++] = num
;
1250 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, val
);
1253 return stlink_cmd_allow_retry(handle
, h
->databuf
, 2);
1256 static int stlink_usb_get_rw_status(void *handle
)
1259 struct stlink_usb_handle_s
*h
= handle
;
1261 assert(handle
!= NULL
);
1263 if (h
->jtag_api
== STLINK_JTAG_API_V1
)
1266 stlink_usb_init_buffer(handle
, h
->rx_ep
, 2);
1268 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1269 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_APIV2_GETLASTRWSTATUS
;
1271 res
= stlink_usb_xfer(handle
, h
->databuf
, 2);
1273 if (res
!= ERROR_OK
)
1276 return stlink_usb_error_check(h
);
1280 static int stlink_usb_read_mem8(void *handle
, uint32_t addr
, uint16_t len
,
1284 uint16_t read_len
= len
;
1285 struct stlink_usb_handle_s
*h
= handle
;
1287 assert(handle
!= NULL
);
1289 /* max 8bit read/write is 64bytes */
1290 if (len
> STLINK_MAX_RW8
) {
1291 LOG_DEBUG("max buffer length exceeded");
1295 stlink_usb_init_buffer(handle
, h
->rx_ep
, read_len
);
1297 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1298 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READMEM_8BIT
;
1299 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1301 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1304 /* we need to fix read length for single bytes */
1308 res
= stlink_usb_xfer(handle
, h
->databuf
, read_len
);
1310 if (res
!= ERROR_OK
)
1313 memcpy(buffer
, h
->databuf
, len
);
1315 return stlink_usb_get_rw_status(handle
);
1319 static int stlink_usb_write_mem8(void *handle
, uint32_t addr
, uint16_t len
,
1320 const uint8_t *buffer
)
1323 struct stlink_usb_handle_s
*h
= handle
;
1325 assert(handle
!= NULL
);
1327 /* max 8bit read/write is 64bytes */
1328 if (len
> STLINK_MAX_RW8
) {
1329 LOG_DEBUG("max buffer length exceeded");
1333 stlink_usb_init_buffer(handle
, h
->tx_ep
, len
);
1335 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1336 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_WRITEMEM_8BIT
;
1337 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1339 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1342 res
= stlink_usb_xfer(handle
, buffer
, len
);
1344 if (res
!= ERROR_OK
)
1347 return stlink_usb_get_rw_status(handle
);
1351 static int stlink_usb_read_mem32(void *handle
, uint32_t addr
, uint16_t len
,
1355 struct stlink_usb_handle_s
*h
= handle
;
1357 assert(handle
!= NULL
);
1359 /* data must be a multiple of 4 and word aligned */
1360 if (len
% 4 || addr
% 4) {
1361 LOG_DEBUG("Invalid data alignment");
1362 return ERROR_TARGET_UNALIGNED_ACCESS
;
1365 stlink_usb_init_buffer(handle
, h
->rx_ep
, len
);
1367 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1368 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_READMEM_32BIT
;
1369 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1371 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1374 res
= stlink_usb_xfer(handle
, h
->databuf
, len
);
1376 if (res
!= ERROR_OK
)
1379 memcpy(buffer
, h
->databuf
, len
);
1381 return stlink_usb_get_rw_status(handle
);
1385 static int stlink_usb_write_mem32(void *handle
, uint32_t addr
, uint16_t len
,
1386 const uint8_t *buffer
)
1389 struct stlink_usb_handle_s
*h
= handle
;
1391 assert(handle
!= NULL
);
1393 /* data must be a multiple of 4 and word aligned */
1394 if (len
% 4 || addr
% 4) {
1395 LOG_DEBUG("Invalid data alignment");
1396 return ERROR_TARGET_UNALIGNED_ACCESS
;
1399 stlink_usb_init_buffer(handle
, h
->tx_ep
, len
);
1401 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_COMMAND
;
1402 h
->cmdbuf
[h
->cmdidx
++] = STLINK_DEBUG_WRITEMEM_32BIT
;
1403 h_u32_to_le(h
->cmdbuf
+h
->cmdidx
, addr
);
1405 h_u16_to_le(h
->cmdbuf
+h
->cmdidx
, len
);
1408 res
= stlink_usb_xfer(handle
, buffer
, len
);
1410 if (res
!= ERROR_OK
)
1413 return stlink_usb_get_rw_status(handle
);
1416 static uint32_t stlink_max_block_size(uint32_t tar_autoincr_block
, uint32_t address
)
1418 uint32_t max_tar_block
= (tar_autoincr_block
- ((tar_autoincr_block
- 1) & address
));
1419 if (max_tar_block
== 0)
1421 return max_tar_block
;
1424 static int stlink_usb_read_mem(void *handle
, uint32_t addr
, uint32_t size
,
1425 uint32_t count
, uint8_t *buffer
)
1427 int retval
= ERROR_OK
;
1428 uint32_t bytes_remaining
;
1430 struct stlink_usb_handle_s
*h
= handle
;
1432 /* calculate byte count */
1437 bytes_remaining
= (size
== 4) ? \
1438 stlink_max_block_size(h
->max_mem_packet
, addr
) : STLINK_MAX_RW8
;
1440 if (count
< bytes_remaining
)
1441 bytes_remaining
= count
;
1443 /* the stlink only supports 8/32bit memory read/writes
1444 * honour 32bit, all others will be handled as 8bit access */
1447 /* When in jtag mode the stlink uses the auto-increment functinality.
1448 * However it expects us to pass the data correctly, this includes
1449 * alignment and any page boundaries. We already do this as part of the
1450 * adi_v5 implementation, but the stlink is a hla adapter and so this
1451 * needs implementiong manually.
1452 * currently this only affects jtag mode, according to ST they do single
1453 * access in SWD mode - but this may change and so we do it for both modes */
1455 /* we first need to check for any unaligned bytes */
1458 uint32_t head_bytes
= 4 - (addr
% 4);
1459 retval
= stlink_usb_read_mem8(handle
, addr
, head_bytes
, buffer
);
1460 if (retval
== ERROR_WAIT
&& retries
< MAX_WAIT_RETRIES
) {
1461 usleep((1<<retries
++) * 1000);
1464 if (retval
!= ERROR_OK
)
1466 buffer
+= head_bytes
;
1468 count
-= head_bytes
;
1469 bytes_remaining
-= head_bytes
;
1472 if (bytes_remaining
% 4)
1473 retval
= stlink_usb_read_mem(handle
, addr
, 1, bytes_remaining
, buffer
);
1475 retval
= stlink_usb_read_mem32(handle
, addr
, bytes_remaining
, buffer
);
1477 retval
= stlink_usb_read_mem8(handle
, addr
, bytes_remaining
, buffer
);
1479 if (retval
== ERROR_WAIT
&& retries
< MAX_WAIT_RETRIES
) {
1480 usleep((1<<retries
++) * 1000);
1483 if (retval
!= ERROR_OK
)
1486 buffer
+= bytes_remaining
;
1487 addr
+= bytes_remaining
;
1488 count
-= bytes_remaining
;
1494 static int stlink_usb_write_mem(void *handle
, uint32_t addr
, uint32_t size
,
1495 uint32_t count
, const uint8_t *buffer
)
1497 int retval
= ERROR_OK
;
1498 uint32_t bytes_remaining
;
1500 struct stlink_usb_handle_s
*h
= handle
;
1502 /* calculate byte count */
1507 bytes_remaining
= (size
== 4) ? \
1508 stlink_max_block_size(h
->max_mem_packet
, addr
) : STLINK_MAX_RW8
;
1510 if (count
< bytes_remaining
)
1511 bytes_remaining
= count
;
1513 /* the stlink only supports 8/32bit memory read/writes
1514 * honour 32bit, all others will be handled as 8bit access */
1517 /* When in jtag mode the stlink uses the auto-increment functinality.
1518 * However it expects us to pass the data correctly, this includes
1519 * alignment and any page boundaries. We already do this as part of the
1520 * adi_v5 implementation, but the stlink is a hla adapter and so this
1521 * needs implementiong manually.
1522 * currently this only affects jtag mode, according to ST they do single
1523 * access in SWD mode - but this may change and so we do it for both modes */
1525 /* we first need to check for any unaligned bytes */
1528 uint32_t head_bytes
= 4 - (addr
% 4);
1529 retval
= stlink_usb_write_mem8(handle
, addr
, head_bytes
, buffer
);
1530 if (retval
== ERROR_WAIT
&& retries
< MAX_WAIT_RETRIES
) {
1531 usleep((1<<retries
++) * 1000);
1534 if (retval
!= ERROR_OK
)
1536 buffer
+= head_bytes
;
1538 count
-= head_bytes
;
1539 bytes_remaining
-= head_bytes
;
1542 if (bytes_remaining
% 4)
1543 retval
= stlink_usb_write_mem(handle
, addr
, 1, bytes_remaining
, buffer
);
1545 retval
= stlink_usb_write_mem32(handle
, addr
, bytes_remaining
, buffer
);
1548 retval
= stlink_usb_write_mem8(handle
, addr
, bytes_remaining
, buffer
);
1549 if (retval
== ERROR_WAIT
&& retries
< MAX_WAIT_RETRIES
) {
1550 usleep((1<<retries
++) * 1000);
1553 if (retval
!= ERROR_OK
)
1556 buffer
+= bytes_remaining
;
1557 addr
+= bytes_remaining
;
1558 count
-= bytes_remaining
;
1565 static int stlink_usb_override_target(const char *targetname
)
1567 return !strcmp(targetname
, "cortex_m");
1571 static int stlink_usb_close(void *fd
)
1573 struct stlink_usb_handle_s
*h
= fd
;
1576 jtag_libusb_close(h
->fd
);
1584 static int stlink_usb_open(struct hl_interface_param_s
*param
, void **fd
)
1586 int err
, retry_count
= 1;
1587 struct stlink_usb_handle_s
*h
;
1588 enum stlink_jtag_api_version api
;
1590 LOG_DEBUG("stlink_usb_open");
1592 h
= calloc(1, sizeof(struct stlink_usb_handle_s
));
1595 LOG_DEBUG("malloc failed");
1599 h
->transport
= param
->transport
;
1601 const uint16_t vids
[] = { param
->vid
, 0 };
1602 const uint16_t pids
[] = { param
->pid
, 0 };
1604 LOG_DEBUG("transport: %d vid: 0x%04x pid: 0x%04x", param
->transport
,
1605 param
->vid
, param
->pid
);
1608 On certain host USB configurations(e.g. MacBook Air)
1609 STLINKv2 dongle seems to have its FW in a funky state if,
1610 after plugging it in, you try to use openocd with it more
1611 then once (by launching and closing openocd). In cases like
1612 that initial attempt to read the FW info via
1613 stlink_usb_version will fail and the device has to be reset
1614 in order to become operational.
1617 if (jtag_libusb_open(vids
, pids
, &h
->fd
) != ERROR_OK
) {
1618 LOG_ERROR("open failed");
1622 jtag_libusb_set_configuration(h
->fd
, 0);
1624 if (jtag_libusb_claim_interface(h
->fd
, 0) != ERROR_OK
) {
1625 LOG_DEBUG("claim interface failed");
1629 /* RX EP is common for all versions */
1630 h
->rx_ep
= STLINK_RX_EP
;
1632 /* wrap version for first read */
1633 switch (param
->pid
) {
1635 h
->version
.stlink
= 1;
1636 h
->tx_ep
= STLINK_TX_EP
;
1637 h
->trace_ep
= STLINK_TRACE_EP
;
1639 case STLINK_V2_1_PID
:
1640 h
->version
.stlink
= 2;
1641 h
->tx_ep
= STLINK_V2_1_TX_EP
;
1642 h
->trace_ep
= STLINK_V2_1_TRACE_EP
;
1645 /* fall through - we assume V2 to be the default version*/
1647 h
->version
.stlink
= 2;
1648 h
->tx_ep
= STLINK_TX_EP
;
1649 h
->trace_ep
= STLINK_TRACE_EP
;
1653 /* get the device version */
1654 err
= stlink_usb_version(h
);
1656 if (err
== ERROR_OK
) {
1658 } else if (h
->version
.stlink
== 1 ||
1660 LOG_ERROR("read version failed");
1663 err
= jtag_libusb_release_interface(h
->fd
, 0);
1664 if (err
!= ERROR_OK
) {
1665 LOG_ERROR("release interface failed");
1669 err
= jtag_libusb_reset_device(h
->fd
);
1670 if (err
!= ERROR_OK
) {
1671 LOG_ERROR("reset device failed");
1675 jtag_libusb_close(h
->fd
);
1677 Give the device one second to settle down and
1680 usleep(1 * 1000 * 1000);
1685 /* compare usb vid/pid */
1686 if ((param
->vid
!= h
->vid
) || (param
->pid
!= h
->pid
))
1687 LOG_INFO("vid/pid are not identical: 0x%04X/0x%04X 0x%04X/0x%04X",
1688 param
->vid
, param
->pid
,
1691 /* check if mode is supported */
1694 switch (h
->transport
) {
1695 case HL_TRANSPORT_SWD
:
1696 case HL_TRANSPORT_JTAG
:
1697 if (h
->version
.jtag
== 0)
1700 case HL_TRANSPORT_SWIM
:
1701 if (h
->version
.swim
== 0)
1709 if (err
!= ERROR_OK
) {
1710 LOG_ERROR("mode (transport) not supported by device");
1714 api
= h
->version
.jtag_api_max
;
1716 LOG_INFO("using stlink api v%d", api
);
1718 /* set the used jtag api, this will default to the newest supported version */
1721 if (h
->jtag_api
>= 2 && param
->trace_source_hz
> 0) {
1724 prescale
= param
->trace_source_hz
> STLINK_TRACE_MAX_HZ
?
1725 (param
->trace_source_hz
/ STLINK_TRACE_MAX_HZ
) - 1 : 0;
1727 h
->trace
.output_f
= param
->trace_f
;
1728 h
->trace
.source_hz
= param
->trace_source_hz
;
1729 h
->trace
.prescale
= prescale
;
1732 /* initialize the debug hardware */
1733 err
= stlink_usb_init_mode(h
, param
->connect_under_reset
);
1735 if (err
!= ERROR_OK
) {
1736 LOG_ERROR("init mode failed");
1740 /* get cpuid, so we can determine the max page size
1741 * start with a safe default */
1742 h
->max_mem_packet
= (1 << 10);
1745 err
= stlink_usb_read_mem32(h
, CPUID
, 4, buffer
);
1746 if (err
== ERROR_OK
) {
1747 uint32_t cpuid
= le_to_h_u32(buffer
);
1748 int i
= (cpuid
>> 4) & 0xf;
1749 if (i
== 4 || i
== 3) {
1750 /* Cortex-M3/M4 has 4096 bytes autoincrement range */
1751 h
->max_mem_packet
= (1 << 12);
1755 LOG_DEBUG("Using TAR autoincrement: %" PRIu32
, h
->max_mem_packet
);
1762 stlink_usb_close(h
);
1768 struct hl_layout_api_s stlink_usb_layout_api
= {
1770 .open
= stlink_usb_open
,
1772 .close
= stlink_usb_close
,
1774 .idcode
= stlink_usb_idcode
,
1776 .state
= stlink_usb_state
,
1778 .reset
= stlink_usb_reset
,
1780 .assert_srst
= stlink_usb_assert_srst
,
1782 .run
= stlink_usb_run
,
1784 .halt
= stlink_usb_halt
,
1786 .step
= stlink_usb_step
,
1788 .read_regs
= stlink_usb_read_regs
,
1790 .read_reg
= stlink_usb_read_reg
,
1792 .write_reg
= stlink_usb_write_reg
,
1794 .read_mem
= stlink_usb_read_mem
,
1796 .write_mem
= stlink_usb_write_mem
,
1798 .write_debug_reg
= stlink_usb_write_debug_reg
,
1800 .override_target
= stlink_usb_override_target
,
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)