X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fjtag%2Fdrivers%2Fstlink_usb.c;h=77448d508245e8e704cb9272ed70f52faaf270ce;hb=c1c613bdbb1de958a0f8099cfcedc7681888d30d;hp=b4dc0de3c9e646d665d34473de32b82ed37ca755;hpb=4c9d6038b265321be24b40f97350a17ccb634f5f;p=openocd.git diff --git a/src/jtag/drivers/stlink_usb.c b/src/jtag/drivers/stlink_usb.c index b4dc0de3c9..77448d5082 100644 --- a/src/jtag/drivers/stlink_usb.c +++ b/src/jtag/drivers/stlink_usb.c @@ -66,6 +66,11 @@ * 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, @@ -126,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 @@ -340,6 +348,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<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) { @@ -527,7 +559,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; @@ -569,14 +600,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); } /** */ @@ -618,6 +642,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) { @@ -691,20 +729,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"); @@ -771,19 +796,16 @@ static int stlink_usb_v2_read_debug_reg(void *handle, uint32_t addr, uint32_t *v 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); @@ -800,12 +822,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); } /** */ @@ -877,8 +894,22 @@ 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, h->rx_ep, 2); @@ -895,13 +926,14 @@ 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); @@ -915,23 +947,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); @@ -945,12 +965,7 @@ static int stlink_usb_assert_srst(void *handle, int srst) 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); } /** */ @@ -1110,12 +1125,7 @@ static int stlink_usb_run(void *handle) 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); } /** */ @@ -1140,18 +1150,12 @@ static int stlink_usb_halt(void *handle) 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); @@ -1169,12 +1173,7 @@ static int stlink_usb_step(void *handle) 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); } /** */ @@ -1218,25 +1217,24 @@ 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); @@ -1252,12 +1250,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) @@ -1280,7 +1273,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); } /** */ @@ -1433,6 +1426,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 */ @@ -1463,6 +1457,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<