X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fdrivers%2Fstlink_usb.c;h=554ffc1edcbfc2e76e6fe9fd558a3dce37f988b1;hp=e9d13d566da44ca389864f3991dff28de6c24e91;hb=d019080dfaa6c0c49228ecec2ad0c585ac65cb73;hpb=94d64ccaebd3df17f5873c076fc08ca97088cb1e diff --git a/src/jtag/drivers/stlink_usb.c b/src/jtag/drivers/stlink_usb.c index e9d13d566d..554ffc1edc 100644 --- a/src/jtag/drivers/stlink_usb.c +++ b/src/jtag/drivers/stlink_usb.c @@ -45,19 +45,32 @@ #define STLINK_WRITE_TIMEOUT 1000 #define STLINK_READ_TIMEOUT 1000 -#define STLINK_NULL_EP 0 -#define STLINK_RX_EP (1|ENDPOINT_IN) -#define STLINK_TX_EP (2|ENDPOINT_OUT) -#define STLINK_TRACE_EP (3|ENDPOINT_IN) -#define STLINK_SG_SIZE (31) -#define STLINK_DATA_SIZE (4096) -#define STLINK_CMD_SIZE_V2 (16) -#define STLINK_CMD_SIZE_V1 (10) +#define STLINK_NULL_EP 0 +#define STLINK_RX_EP (1|ENDPOINT_IN) +#define STLINK_TX_EP (2|ENDPOINT_OUT) +#define STLINK_TRACE_EP (3|ENDPOINT_IN) + +#define STLINK_V2_1_TX_EP (1|ENDPOINT_OUT) +#define STLINK_V2_1_TRACE_EP (2|ENDPOINT_IN) + +#define STLINK_SG_SIZE (31) +#define STLINK_DATA_SIZE (4096) +#define STLINK_CMD_SIZE_V2 (16) +#define STLINK_CMD_SIZE_V1 (10) + +#define STLINK_V1_PID (0x3744) +#define STLINK_V2_PID (0x3748) +#define STLINK_V2_1_PID (0x374B) /* the current implementation of the stlink limits * 8bit read/writes to max 64 bytes. */ #define STLINK_MAX_RW8 (64) +/* "WAIT" responses will be retried (with exponential backoff) at + * most this many times before failing to caller. + */ +#define MAX_WAIT_RETRIES 8 + enum stlink_jtag_api_version { STLINK_JTAG_API_V1 = 1, STLINK_JTAG_API_V2, @@ -82,6 +95,12 @@ struct stlink_usb_handle_s { /** */ struct libusb_transfer *trans; /** */ + uint8_t rx_ep; + /** */ + uint8_t tx_ep; + /** */ + uint8_t trace_ep; + /** */ uint8_t cmdbuf[STLINK_SG_SIZE]; /** */ uint8_t cmdidx; @@ -112,6 +131,9 @@ struct stlink_usb_handle_s { /** trace module clock prescaler */ uint32_t prescale; } trace; + /** reconnect is needed next time we try to query the + * status */ + bool reconnect_pending; }; #define STLINK_DEBUG_ERR_OK 0x80 @@ -182,6 +204,7 @@ struct stlink_usb_handle_s { #define STLINK_DEBUG_APIV2_START_TRACE_RX 0x40 #define STLINK_DEBUG_APIV2_STOP_TRACE_RX 0x41 #define STLINK_DEBUG_APIV2_GET_TRACE_NB 0x42 +#define STLINK_DEBUG_APIV2_SWD_SET_FREQ 0x43 #define STLINK_DEBUG_APIV2_DRIVE_NRST_LOW 0x00 #define STLINK_DEBUG_APIV2_DRIVE_NRST_HIGH 0x01 @@ -204,6 +227,24 @@ enum stlink_mode { #define REQUEST_SENSE 0x03 #define REQUEST_SENSE_LENGTH 18 +static const struct { + int speed; + int speed_divisor; +} stlink_khz_to_speed_map[] = { + {4000, 0}, + {1800, 1}, /* default */ + {1200, 2}, + {950, 3}, + {480, 7}, + {240, 15}, + {125, 31}, + {100, 40}, + {50, 79}, + {25, 158}, + {15, 265}, + {5, 798} +}; + static void stlink_usb_init_buffer(void *handle, uint8_t direction, uint32_t size); /** */ @@ -216,7 +257,7 @@ static int stlink_usb_xfer_v1_get_status(void *handle) /* read status */ memset(h->cmdbuf, 0, STLINK_SG_SIZE); - if (jtag_libusb_bulk_read(h->fd, STLINK_RX_EP, (char *)h->cmdbuf, + if (jtag_libusb_bulk_read(h->fd, h->rx_ep, (char *)h->cmdbuf, 13, STLINK_READ_TIMEOUT) != 13) return ERROR_FAIL; @@ -246,19 +287,19 @@ static int stlink_usb_xfer_rw(void *handle, int cmdsize, const uint8_t *buf, int assert(handle != NULL); - if (jtag_libusb_bulk_write(h->fd, STLINK_TX_EP, (char *)h->cmdbuf, cmdsize, + if (jtag_libusb_bulk_write(h->fd, h->tx_ep, (char *)h->cmdbuf, cmdsize, STLINK_WRITE_TIMEOUT) != cmdsize) { return ERROR_FAIL; } - if (h->direction == STLINK_TX_EP && size) { - if (jtag_libusb_bulk_write(h->fd, STLINK_TX_EP, (char *)buf, + if (h->direction == h->tx_ep && size) { + if (jtag_libusb_bulk_write(h->fd, h->tx_ep, (char *)buf, size, STLINK_WRITE_TIMEOUT) != size) { LOG_DEBUG("bulk write failed"); return ERROR_FAIL; } - } else if (h->direction == STLINK_RX_EP && size) { - if (jtag_libusb_bulk_read(h->fd, STLINK_RX_EP, (char *)buf, + } else if (h->direction == h->rx_ep && size) { + if (jtag_libusb_bulk_read(h->fd, h->rx_ep, (char *)buf, size, STLINK_READ_TIMEOUT) != size) { LOG_DEBUG("bulk read failed"); return ERROR_FAIL; @@ -276,7 +317,7 @@ static int stlink_usb_xfer_v1_get_sense(void *handle) assert(handle != NULL); - stlink_usb_init_buffer(handle, STLINK_RX_EP, 16); + stlink_usb_init_buffer(handle, h->rx_ep, 16); h->cmdbuf[h->cmdidx++] = REQUEST_SENSE; h->cmdbuf[h->cmdidx++] = 0; @@ -326,6 +367,64 @@ static int stlink_usb_xfer(void *handle, const uint8_t *buf, int size) return ERROR_OK; } + +/** + Converts an STLINK status code held in the first byte of a response + to an openocd error, logs any error/wait status as debug output. +*/ +static int stlink_usb_error_check(void *handle) +{ + struct stlink_usb_handle_s *h = handle; + + assert(handle != NULL); + + /* TODO: no error checking yet on api V1 */ + if (h->jtag_api == STLINK_JTAG_API_V1) + h->databuf[0] = STLINK_DEBUG_ERR_OK; + + switch (h->databuf[0]) { + case STLINK_DEBUG_ERR_OK: + return ERROR_OK; + case STLINK_DEBUG_ERR_FAULT: + LOG_DEBUG("SWD fault response (0x%x)", STLINK_DEBUG_ERR_FAULT); + return ERROR_FAIL; + case STLINK_SWD_AP_WAIT: + LOG_DEBUG("wait status SWD_AP_WAIT (0x%x)", STLINK_SWD_AP_WAIT); + return ERROR_WAIT; + case STLINK_SWD_DP_WAIT: + LOG_DEBUG("wait status SWD_DP_WAIT (0x%x)", STLINK_SWD_AP_WAIT); + return ERROR_WAIT; + default: + LOG_DEBUG("unknown/unexpected STLINK status code 0x%x", h->databuf[0]); + return ERROR_FAIL; + } +} + + +/** Issue an STLINK command via USB transfer, with retries on any wait status responses. + + Works for commands where the STLINK_DEBUG status is returned in the first + byte of the response packet. + + Returns an openocd result code. +*/ +static int stlink_cmd_allow_retry(void *handle, const uint8_t *buf, int size) +{ + int retries = 0; + int res; + while (1) { + res = stlink_usb_xfer(handle, buf, size); + if (res != ERROR_OK) + return res; + res = stlink_usb_error_check(handle); + if (res == ERROR_WAIT && retries < MAX_WAIT_RETRIES) { + usleep((1<version.stlink >= 2); - if (jtag_libusb_bulk_read(h->fd, STLINK_TRACE_EP, (char *)buf, + if (jtag_libusb_bulk_read(h->fd, h->trace_ep, (char *)buf, size, STLINK_READ_TIMEOUT) != size) { LOG_ERROR("bulk trace read failed"); return ERROR_FAIL; @@ -356,7 +455,7 @@ static void stlink_usb_xfer_v1_create_cmd(void *handle, uint8_t direction, uint3 h->cmdidx += 4; buf_set_u32(h->cmdbuf+h->cmdidx, 0, 32, size); h->cmdidx += 4; - h->cmdbuf[h->cmdidx++] = (direction == STLINK_RX_EP ? ENDPOINT_IN : ENDPOINT_OUT); + h->cmdbuf[h->cmdidx++] = (direction == h->rx_ep ? ENDPOINT_IN : ENDPOINT_OUT); h->cmdbuf[h->cmdidx++] = 0; /* lun */ h->cmdbuf[h->cmdidx++] = STLINK_CMD_SIZE_V1; } @@ -377,40 +476,6 @@ static void stlink_usb_init_buffer(void *handle, uint8_t direction, uint32_t siz stlink_usb_xfer_v1_create_cmd(handle, direction, size); } -static const char * const stlink_usb_error_msg[] = { - "unknown" -}; - -/** */ -static int stlink_usb_error_check(void *handle) -{ - int res; - const char *err_msg = 0; - struct stlink_usb_handle_s *h = handle; - - assert(handle != NULL); - - /* TODO: no error checking yet on api V1 */ - if (h->jtag_api == STLINK_JTAG_API_V1) - h->databuf[0] = STLINK_DEBUG_ERR_OK; - - switch (h->databuf[0]) { - case STLINK_DEBUG_ERR_OK: - res = ERROR_OK; - break; - case STLINK_DEBUG_ERR_FAULT: - default: - err_msg = stlink_usb_error_msg[0]; - res = ERROR_FAIL; - break; - } - - if (res != ERROR_OK) - LOG_DEBUG("status error: %d ('%s')", h->databuf[0], err_msg); - - return res; -} - /** */ static int stlink_usb_version(void *handle) { @@ -420,7 +485,7 @@ static int stlink_usb_version(void *handle) assert(handle != NULL); - stlink_usb_init_buffer(handle, STLINK_RX_EP, 6); + stlink_usb_init_buffer(handle, h->rx_ep, 6); h->cmdbuf[h->cmdidx++] = STLINK_GET_VERSION; @@ -465,7 +530,7 @@ static int stlink_usb_check_voltage(void *handle, float *target_voltage) if (h->version.stlink == 1 || h->version.jtag < 13) return ERROR_COMMAND_NOTFOUND; - stlink_usb_init_buffer(handle, STLINK_RX_EP, 8); + stlink_usb_init_buffer(handle, h->rx_ep, 8); h->cmdbuf[h->cmdidx++] = STLINK_GET_TARGET_VOLTAGE; @@ -488,6 +553,31 @@ static int stlink_usb_check_voltage(void *handle, float *target_voltage) return ERROR_OK; } +static int stlink_usb_set_swdclk(void *handle, uint16_t clk_divisor) +{ + struct stlink_usb_handle_s *h = handle; + + assert(handle != NULL); + + /* only supported by stlink/v2 and for firmware >= 22 */ + if (h->version.stlink == 1 || h->version.jtag < 22) + return ERROR_COMMAND_NOTFOUND; + + stlink_usb_init_buffer(handle, h->rx_ep, 2); + + h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; + h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_SWD_SET_FREQ; + h_u16_to_le(h->cmdbuf+h->cmdidx, clk_divisor); + h->cmdidx += 2; + + int result = stlink_cmd_allow_retry(handle, h->databuf, 2); + + if (result != ERROR_OK) + return result; + + return ERROR_OK; +} + /** */ static int stlink_usb_current_mode(void *handle, uint8_t *mode) { @@ -496,7 +586,7 @@ static int stlink_usb_current_mode(void *handle, uint8_t *mode) assert(handle != NULL); - stlink_usb_init_buffer(handle, STLINK_RX_EP, 2); + stlink_usb_init_buffer(handle, h->rx_ep, 2); h->cmdbuf[h->cmdidx++] = STLINK_GET_CURRENT_MODE; @@ -513,7 +603,6 @@ static int stlink_usb_current_mode(void *handle, uint8_t *mode) /** */ static int stlink_usb_mode_enter(void *handle, enum stlink_mode type) { - int res; int rx_size = 0; struct stlink_usb_handle_s *h = handle; @@ -526,7 +615,7 @@ static int stlink_usb_mode_enter(void *handle, enum stlink_mode type) if (h->jtag_api == STLINK_JTAG_API_V2) rx_size = 2; - stlink_usb_init_buffer(handle, STLINK_RX_EP, rx_size); + stlink_usb_init_buffer(handle, h->rx_ep, rx_size); switch (type) { case STLINK_MODE_DEBUG_JTAG: @@ -555,14 +644,7 @@ static int stlink_usb_mode_enter(void *handle, enum stlink_mode type) return ERROR_FAIL; } - res = stlink_usb_xfer(handle, h->databuf, rx_size); - - if (res != ERROR_OK) - return res; - - res = stlink_usb_error_check(h); - - return res; + return stlink_cmd_allow_retry(handle, h->databuf, rx_size); } /** */ @@ -604,6 +686,20 @@ static int stlink_usb_mode_leave(void *handle, enum stlink_mode type) static int stlink_usb_assert_srst(void *handle, int srst); +static enum stlink_mode stlink_get_mode(enum hl_transports t) +{ + switch (t) { + case HL_TRANSPORT_SWD: + return STLINK_MODE_DEBUG_SWD; + case HL_TRANSPORT_JTAG: + return STLINK_MODE_DEBUG_JTAG; + case HL_TRANSPORT_SWIM: + return STLINK_MODE_DEBUG_SWIM; + default: + return STLINK_MODE_UNKNOWN; + } +} + /** */ static int stlink_usb_init_mode(void *handle, bool connect_under_reset) { @@ -677,20 +773,7 @@ static int stlink_usb_init_mode(void *handle, bool connect_under_reset) LOG_DEBUG("MODE: 0x%02X", mode); /* set selected mode */ - switch (h->transport) { - case HL_TRANSPORT_SWD: - emode = STLINK_MODE_DEBUG_SWD; - break; - case HL_TRANSPORT_JTAG: - emode = STLINK_MODE_DEBUG_JTAG; - break; - case HL_TRANSPORT_SWIM: - emode = STLINK_MODE_DEBUG_SWIM; - break; - default: - emode = STLINK_MODE_UNKNOWN; - break; - } + emode = stlink_get_mode(h->transport); if (emode == STLINK_MODE_UNKNOWN) { LOG_ERROR("selected mode (transport) not supported"); @@ -726,7 +809,7 @@ static int stlink_usb_idcode(void *handle, uint32_t *idcode) assert(handle != NULL); - stlink_usb_init_buffer(handle, STLINK_RX_EP, 4); + stlink_usb_init_buffer(handle, h->rx_ep, 4); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_READCOREID; @@ -750,31 +833,28 @@ static int stlink_usb_v2_read_debug_reg(void *handle, uint32_t addr, uint32_t *v assert(handle != NULL); - stlink_usb_init_buffer(handle, STLINK_RX_EP, 8); + stlink_usb_init_buffer(handle, h->rx_ep, 8); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_READDEBUGREG; h_u32_to_le(h->cmdbuf+h->cmdidx, addr); h->cmdidx += 4; - res = stlink_usb_xfer(handle, h->databuf, 8); - + res = stlink_cmd_allow_retry(handle, h->databuf, 8); if (res != ERROR_OK) return res; *val = le_to_h_u32(h->databuf + 4); - - return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL; + return ERROR_OK; } static int stlink_usb_write_debug_reg(void *handle, uint32_t addr, uint32_t val) { - int res; struct stlink_usb_handle_s *h = handle; assert(handle != NULL); - stlink_usb_init_buffer(handle, STLINK_RX_EP, 2); + stlink_usb_init_buffer(handle, h->rx_ep, 2); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; if (h->jtag_api == STLINK_JTAG_API_V1) @@ -786,12 +866,7 @@ static int stlink_usb_write_debug_reg(void *handle, uint32_t addr, uint32_t val) h_u32_to_le(h->cmdbuf+h->cmdidx, val); h->cmdidx += 4; - res = stlink_usb_xfer(handle, h->databuf, 2); - - if (res != ERROR_OK) - return res; - - return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL; + return stlink_cmd_allow_retry(handle, h->databuf, 2); } /** */ @@ -804,7 +879,7 @@ static void stlink_usb_trace_read(void *handle) if (h->trace.enabled && h->version.jtag >= STLINK_TRACE_MIN_VERSION) { int res; - stlink_usb_init_buffer(handle, STLINK_RX_EP, 10); + stlink_usb_init_buffer(handle, h->rx_ep, 10); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_GET_TRACE_NB; @@ -830,6 +905,12 @@ static void stlink_usb_trace_read(void *handle) } } +static int stlink_usb_trace_read_callback(void *handle) +{ + stlink_usb_trace_read(handle); + return ERROR_OK; +} + static enum target_state stlink_usb_v2_get_status(void *handle) { int result; @@ -857,10 +938,24 @@ static enum target_state stlink_usb_state(void *handle) assert(handle != NULL); - if (h->jtag_api == STLINK_JTAG_API_V2) - return stlink_usb_v2_get_status(handle); + if (h->reconnect_pending) { + LOG_INFO("Previous state query failed, trying to reconnect"); + res = stlink_usb_mode_enter(handle, stlink_get_mode(h->transport)); + + if (res != ERROR_OK) + return TARGET_UNKNOWN; + + h->reconnect_pending = false; + } + + if (h->jtag_api == STLINK_JTAG_API_V2) { + res = stlink_usb_v2_get_status(handle); + if (res == TARGET_UNKNOWN) + h->reconnect_pending = true; + return res; + } - stlink_usb_init_buffer(handle, STLINK_RX_EP, 2); + stlink_usb_init_buffer(handle, h->rx_ep, 2); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_GETSTATUS; @@ -875,18 +970,19 @@ static enum target_state stlink_usb_state(void *handle) if (h->databuf[0] == STLINK_CORE_HALTED) return TARGET_HALTED; + h->reconnect_pending = true; + return TARGET_UNKNOWN; } /** */ static int stlink_usb_reset(void *handle) { - int res; struct stlink_usb_handle_s *h = handle; assert(handle != NULL); - stlink_usb_init_buffer(handle, STLINK_RX_EP, 2); + stlink_usb_init_buffer(handle, h->rx_ep, 2); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; @@ -895,23 +991,11 @@ static int stlink_usb_reset(void *handle) else h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_RESETSYS; - res = stlink_usb_xfer(handle, h->databuf, 2); - - if (res != ERROR_OK) - return res; - - LOG_DEBUG("RESET: 0x%08X", h->databuf[0]); - - /* the following is not a error under swd (using hardware srst), so return success */ - if (h->databuf[0] == STLINK_SWD_AP_WAIT || h->databuf[0] == STLINK_SWD_DP_WAIT) - return ERROR_OK; - - return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL; + return stlink_cmd_allow_retry(handle, h->databuf, 2); } static int stlink_usb_assert_srst(void *handle, int srst) { - int res; struct stlink_usb_handle_s *h = handle; assert(handle != NULL); @@ -919,18 +1003,13 @@ static int stlink_usb_assert_srst(void *handle, int srst) if (h->jtag_api == STLINK_JTAG_API_V1) return ERROR_COMMAND_NOTFOUND; - stlink_usb_init_buffer(handle, STLINK_RX_EP, 2); + stlink_usb_init_buffer(handle, h->rx_ep, 2); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_DRIVE_NRST; h->cmdbuf[h->cmdidx++] = srst; - res = stlink_usb_xfer(handle, h->databuf, 2); - - if (res != ERROR_OK) - return res; - - return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL; + return stlink_cmd_allow_retry(handle, h->databuf, 2); } /** */ @@ -999,15 +1078,17 @@ static void stlink_usb_trace_disable(void *handle) assert(h->version.jtag >= STLINK_TRACE_MIN_VERSION); - LOG_DEBUG("Tracing: disable\n"); + LOG_DEBUG("Tracing: disable"); - stlink_usb_init_buffer(handle, STLINK_RX_EP, 2); + stlink_usb_init_buffer(handle, h->rx_ep, 2); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_STOP_TRACE_RX; res = stlink_usb_xfer(handle, h->databuf, 2); - if (res == ERROR_OK) + if (res == ERROR_OK) { h->trace.enabled = false; + target_unregister_timer_callback(stlink_usb_trace_read_callback, handle); + } } @@ -1024,13 +1105,13 @@ static int stlink_usb_trace_enable(void *handle) res = stlink_configure_target_trace_port(handle); if (res != ERROR_OK) - LOG_ERROR("Unable to configure tracing on target\n"); + LOG_ERROR("Unable to configure tracing on target"); trace_hz = h->trace.prescale > 0 ? h->trace.source_hz / (h->trace.prescale + 1) : h->trace.source_hz; - stlink_usb_init_buffer(handle, STLINK_RX_EP, 10); + stlink_usb_init_buffer(handle, h->rx_ep, 10); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_START_TRACE_RX; @@ -1043,7 +1124,15 @@ static int stlink_usb_trace_enable(void *handle) if (res == ERROR_OK) { h->trace.enabled = true; - LOG_DEBUG("Tracing: recording at %" PRIu32 "Hz\n", trace_hz); + LOG_DEBUG("Tracing: recording at %" PRIu32 "Hz", trace_hz); + /* We need the trace read function to be called at a + * high-enough frequency to ensure reasonable + * "timeliness" in processing ITM/DWT data. + * TODO: An alternative could be using the asynchronous + * features of the libusb-1.0 API to queue up one or more + * reads in advance and requeue them once they are + * completed. */ + target_register_timer_callback(stlink_usb_trace_read_callback, 1, 1, handle); } } else { LOG_ERROR("Tracing is not supported by this version."); @@ -1065,27 +1154,22 @@ static int stlink_usb_run(void *handle) res = stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_DEBUGEN); /* Try to start tracing, if requested */ - if (res == ERROR_OK && h->trace.source_hz) { + if (res == ERROR_OK && h->trace.source_hz && !h->trace.enabled) { if (stlink_usb_trace_enable(handle) == ERROR_OK) - LOG_DEBUG("Tracing: enabled\n"); + LOG_DEBUG("Tracing: enabled"); else - LOG_ERROR("Tracing: enable failed\n"); + LOG_ERROR("Tracing: enable failed"); } return res; } - stlink_usb_init_buffer(handle, STLINK_RX_EP, 2); + stlink_usb_init_buffer(handle, h->rx_ep, 2); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_RUNCORE; - res = stlink_usb_xfer(handle, h->databuf, 2); - - if (res != ERROR_OK) - return res; - - return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL; + return stlink_cmd_allow_retry(handle, h->databuf, 2); } /** */ @@ -1105,23 +1189,17 @@ static int stlink_usb_halt(void *handle) return res; } - stlink_usb_init_buffer(handle, STLINK_RX_EP, 2); + stlink_usb_init_buffer(handle, h->rx_ep, 2); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_FORCEDEBUG; - res = stlink_usb_xfer(handle, h->databuf, 2); - - if (res != ERROR_OK) - return res; - - return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL; + return stlink_cmd_allow_retry(handle, h->databuf, 2); } /** */ static int stlink_usb_step(void *handle) { - int res; struct stlink_usb_handle_s *h = handle; assert(handle != NULL); @@ -1134,17 +1212,12 @@ static int stlink_usb_step(void *handle) return stlink_usb_write_debug_reg(handle, DCB_DHCSR, DBGKEY|C_HALT|C_DEBUGEN); } - stlink_usb_init_buffer(handle, STLINK_RX_EP, 2); + stlink_usb_init_buffer(handle, h->rx_ep, 2); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_STEPCORE; - res = stlink_usb_xfer(handle, h->databuf, 2); - - if (res != ERROR_OK) - return res; - - return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL; + return stlink_cmd_allow_retry(handle, h->databuf, 2); } /** */ @@ -1155,7 +1228,7 @@ static int stlink_usb_read_regs(void *handle) assert(handle != NULL); - stlink_usb_init_buffer(handle, STLINK_RX_EP, 84); + stlink_usb_init_buffer(handle, h->rx_ep, 84); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; if (h->jtag_api == STLINK_JTAG_API_V1) @@ -1179,7 +1252,7 @@ static int stlink_usb_read_reg(void *handle, int num, uint32_t *val) assert(handle != NULL); - stlink_usb_init_buffer(handle, STLINK_RX_EP, h->jtag_api == STLINK_JTAG_API_V1 ? 4 : 8); + stlink_usb_init_buffer(handle, h->rx_ep, h->jtag_api == STLINK_JTAG_API_V1 ? 4 : 8); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; if (h->jtag_api == STLINK_JTAG_API_V1) @@ -1188,30 +1261,29 @@ static int stlink_usb_read_reg(void *handle, int num, uint32_t *val) h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_READREG; h->cmdbuf[h->cmdidx++] = num; - res = stlink_usb_xfer(handle, h->databuf, h->jtag_api == STLINK_JTAG_API_V1 ? 4 : 8); - - if (res != ERROR_OK) - return res; - - if (h->jtag_api == STLINK_JTAG_API_V1) + if (h->jtag_api == STLINK_JTAG_API_V1) { + res = stlink_usb_xfer(handle, h->databuf, 4); + if (res != ERROR_OK) + return res; *val = le_to_h_u32(h->databuf); - else { + return ERROR_OK; + } else { + res = stlink_cmd_allow_retry(handle, h->databuf, 8); + if (res != ERROR_OK) + return res; *val = le_to_h_u32(h->databuf + 4); - return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL; + return ERROR_OK; } - - return ERROR_OK; } /** */ static int stlink_usb_write_reg(void *handle, int num, uint32_t val) { - int res; struct stlink_usb_handle_s *h = handle; assert(handle != NULL); - stlink_usb_init_buffer(handle, STLINK_RX_EP, 2); + stlink_usb_init_buffer(handle, h->rx_ep, 2); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; if (h->jtag_api == STLINK_JTAG_API_V1) @@ -1222,12 +1294,7 @@ static int stlink_usb_write_reg(void *handle, int num, uint32_t val) h_u32_to_le(h->cmdbuf+h->cmdidx, val); h->cmdidx += 4; - res = stlink_usb_xfer(handle, h->databuf, 2); - - if (res != ERROR_OK) - return res; - - return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : ERROR_FAIL; + return stlink_cmd_allow_retry(handle, h->databuf, 2); } static int stlink_usb_get_rw_status(void *handle) @@ -1240,7 +1307,7 @@ static int stlink_usb_get_rw_status(void *handle) if (h->jtag_api == STLINK_JTAG_API_V1) return ERROR_OK; - stlink_usb_init_buffer(handle, STLINK_RX_EP, 2); + stlink_usb_init_buffer(handle, h->rx_ep, 2); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_APIV2_GETLASTRWSTATUS; @@ -1250,7 +1317,7 @@ static int stlink_usb_get_rw_status(void *handle) if (res != ERROR_OK) return res; - return h->databuf[0] == STLINK_DEBUG_ERR_OK ? ERROR_OK : res; + return stlink_usb_error_check(h); } /** */ @@ -1269,7 +1336,7 @@ static int stlink_usb_read_mem8(void *handle, uint32_t addr, uint16_t len, return ERROR_FAIL; } - stlink_usb_init_buffer(handle, STLINK_RX_EP, read_len); + stlink_usb_init_buffer(handle, h->rx_ep, read_len); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_READMEM_8BIT; @@ -1307,7 +1374,7 @@ static int stlink_usb_write_mem8(void *handle, uint32_t addr, uint16_t len, return ERROR_FAIL; } - stlink_usb_init_buffer(handle, STLINK_TX_EP, len); + stlink_usb_init_buffer(handle, h->tx_ep, len); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_WRITEMEM_8BIT; @@ -1339,7 +1406,7 @@ static int stlink_usb_read_mem32(void *handle, uint32_t addr, uint16_t len, return ERROR_TARGET_UNALIGNED_ACCESS; } - stlink_usb_init_buffer(handle, STLINK_RX_EP, len); + stlink_usb_init_buffer(handle, h->rx_ep, len); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_READMEM_32BIT; @@ -1373,7 +1440,7 @@ static int stlink_usb_write_mem32(void *handle, uint32_t addr, uint16_t len, return ERROR_TARGET_UNALIGNED_ACCESS; } - stlink_usb_init_buffer(handle, STLINK_TX_EP, len); + stlink_usb_init_buffer(handle, h->tx_ep, len); h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_COMMAND; h->cmdbuf[h->cmdidx++] = STLINK_DEBUG_WRITEMEM_32BIT; @@ -1403,6 +1470,7 @@ static int stlink_usb_read_mem(void *handle, uint32_t addr, uint32_t size, { int retval = ERROR_OK; uint32_t bytes_remaining; + int retries = 0; struct stlink_usb_handle_s *h = handle; /* calculate byte count */ @@ -1433,6 +1501,10 @@ static int stlink_usb_read_mem(void *handle, uint32_t addr, uint32_t size, uint32_t head_bytes = 4 - (addr % 4); retval = stlink_usb_read_mem8(handle, addr, head_bytes, buffer); + if (retval == ERROR_WAIT && retries < MAX_WAIT_RETRIES) { + usleep((1<= 22 */ + if (h && (h->version.stlink == 1 || h->version.jtag < 22)) + return khz; + + for (i = 0; i < ARRAY_SIZE(stlink_khz_to_speed_map); i++) { + if (khz == stlink_khz_to_speed_map[i].speed) { + speed_index = i; + break; + } else { + int current_diff = khz - stlink_khz_to_speed_map[i].speed; + /* get abs value for comparison */ + current_diff = (current_diff > 0) ? current_diff : -current_diff; + if ((current_diff < speed_diff) && khz >= stlink_khz_to_speed_map[i].speed) { + speed_diff = current_diff; + speed_index = i; + } + } + } + + bool match = true; + + if (speed_index == -1) { + /* this will only be here if we cannot match the slow speed. + * use the slowest speed we support.*/ + speed_index = ARRAY_SIZE(stlink_khz_to_speed_map) - 1; + match = false; + } else if (i == ARRAY_SIZE(stlink_khz_to_speed_map)) + match = false; + + if (!match && query) { + LOG_INFO("Unable to match requested speed %d kHz, using %d kHz", \ + khz, stlink_khz_to_speed_map[speed_index].speed); + } + + if (h && !query) { + int result = stlink_usb_set_swdclk(h, stlink_khz_to_speed_map[speed_index].speed_divisor); + if (result != ERROR_OK) { + LOG_ERROR("Unable to set adapter speed"); + return khz; + } + } + + return stlink_khz_to_speed_map[speed_index].speed; +} + +/** */ +static int stlink_usb_close(void *handle) { - struct stlink_usb_handle_s *h = fd; + struct stlink_usb_handle_s *h = handle; - if (h->fd) + if (h && h->fd) jtag_libusb_close(h->fd); - free(fd); + free(h); return ERROR_OK; } @@ -1553,9 +1696,11 @@ static int stlink_usb_open(struct hl_interface_param_s *param, void **fd) const uint16_t vids[] = { param->vid, 0 }; const uint16_t pids[] = { param->pid, 0 }; + const char *serial = param->serial; - LOG_DEBUG("transport: %d vid: 0x%04x pid: 0x%04x", param->transport, - param->vid, param->pid); + LOG_DEBUG("transport: %d vid: 0x%04x pid: 0x%04x serial: %s", + param->transport, param->vid, param->pid, + param->serial ? param->serial : ""); /* On certain host USB configurations(e.g. MacBook Air) @@ -1567,7 +1712,7 @@ static int stlink_usb_open(struct hl_interface_param_s *param, void **fd) in order to become operational. */ do { - if (jtag_libusb_open(vids, pids, &h->fd) != ERROR_OK) { + if (jtag_libusb_open(vids, pids, serial, &h->fd) != ERROR_OK) { LOG_ERROR("open failed"); goto error_open; } @@ -1579,14 +1724,28 @@ static int stlink_usb_open(struct hl_interface_param_s *param, void **fd) goto error_open; } + /* RX EP is common for all versions */ + h->rx_ep = STLINK_RX_EP; + /* wrap version for first read */ switch (param->pid) { - case 0x3744: - h->version.stlink = 1; - break; - default: - h->version.stlink = 2; - break; + case STLINK_V1_PID: + h->version.stlink = 1; + h->tx_ep = STLINK_TX_EP; + h->trace_ep = STLINK_TRACE_EP; + break; + case STLINK_V2_1_PID: + h->version.stlink = 2; + h->tx_ep = STLINK_V2_1_TX_EP; + h->trace_ep = STLINK_V2_1_TRACE_EP; + break; + default: + /* fall through - we assume V2 to be the default version*/ + case STLINK_V2_PID: + h->version.stlink = 2; + h->tx_ep = STLINK_TX_EP; + h->trace_ep = STLINK_TRACE_EP; + break; } /* get the device version */ @@ -1672,10 +1831,20 @@ static int stlink_usb_open(struct hl_interface_param_s *param, void **fd) err = stlink_usb_init_mode(h, param->connect_under_reset); if (err != ERROR_OK) { - LOG_ERROR("init mode failed"); + LOG_ERROR("init mode failed (unable to connect to the target)"); goto error_open; } + /* clock speed only supported by stlink/v2 and for firmware >= 22 */ + if (h->version.stlink >= 2 && h->version.jtag >= 22) { + LOG_DEBUG("Supported clock speeds are:"); + + for (unsigned i = 0; i < ARRAY_SIZE(stlink_khz_to_speed_map); i++) + LOG_DEBUG("%d kHz", stlink_khz_to_speed_map[i].speed); + + stlink_speed(h, param->initial_interface_speed, false); + } + /* get cpuid, so we can determine the max page size * start with a safe default */ h->max_mem_packet = (1 << 10); @@ -1734,5 +1903,9 @@ struct hl_layout_api_s stlink_usb_layout_api = { /** */ .write_mem = stlink_usb_write_mem, /** */ - .write_debug_reg = stlink_usb_write_debug_reg + .write_debug_reg = stlink_usb_write_debug_reg, + /** */ + .override_target = stlink_usb_override_target, + /** */ + .speed = stlink_speed, };