From 6bbb1479b316890519da8aa93f115501711d8656 Mon Sep 17 00:00:00 2001 From: Mathias K Date: Wed, 25 Jan 2012 09:30:45 +0100 Subject: [PATCH] STLINK: swd transport renamed and jtag+swim transport added This patch add jtag support to the stlink driver add two new transport types, JTAG and SWIM. Change-Id: I7089d74250330be5c6a01c24066307641df7d11e Signed-off-by: Mathias K Reviewed-on: http://openocd.zylin.com/393 Tested-by: jenkins Reviewed-by: Spencer Oliver --- src/jtag/drivers/stlink_usb.c | 294 +++++++++++++++++++++-------- src/jtag/stlink/stlink_interface.c | 10 +- src/jtag/stlink/stlink_interface.h | 6 +- src/jtag/stlink/stlink_layout.c | 5 +- src/jtag/stlink/stlink_layout.h | 2 +- src/jtag/stlink/stlink_transport.c | 51 ++++- src/jtag/stlink/stlink_transport.h | 7 + src/target/stm32_stlink.c | 1 + tcl/target/stm32_stlink.cfg | 5 + 9 files changed, 293 insertions(+), 88 deletions(-) diff --git a/src/jtag/drivers/stlink_usb.c b/src/jtag/drivers/stlink_usb.c index cae468f1..2a4c2f45 100644 --- a/src/jtag/drivers/stlink_usb.c +++ b/src/jtag/drivers/stlink_usb.c @@ -28,6 +28,7 @@ #include #include #include +#include #include #include @@ -42,6 +43,16 @@ #define STLINK_TX_SIZE (4*128) #define STLINK_RX_SIZE (4*128) +/** */ +struct stlink_usb_version { + /** */ + int stlink; + /** */ + int jtag; + /** */ + int swim; +}; + /** */ struct stlink_usb_handle_s { /** */ @@ -52,6 +63,14 @@ struct stlink_usb_handle_s { uint8_t txbuf[STLINK_TX_SIZE]; /** */ uint8_t rxbuf[STLINK_RX_SIZE]; + /** */ + enum stlink_transports transport; + /** */ + struct stlink_usb_version version; + /** */ + uint16_t vid; + /** */ + uint16_t pid; }; #define STLINK_OK 0x80 @@ -60,22 +79,24 @@ struct stlink_usb_handle_s { #define STLINK_CORE_HALTED 0x81 #define STLINK_CORE_STAT_UNKNOWN -1 -#define STLINK_GET_VERSION 0xf1 -#define STLINK_GET_CURRENT_MODE 0xf5 - +#define STLINK_GET_VERSION 0xF1 #define STLINK_DEBUG_COMMAND 0xF2 #define STLINK_DFU_COMMAND 0xF3 -#define STLINK_DFU_EXIT 0x07 +#define STLINK_SWIM_COMMAND 0xF4 +#define STLINK_GET_CURRENT_MODE 0xF5 #define STLINK_DEV_DFU_MODE 0x00 #define STLINK_DEV_MASS_MODE 0x01 #define STLINK_DEV_DEBUG_MODE 0x02 +#define STLINK_DEV_SWIM_MODE 0x03 #define STLINK_DEV_UNKNOWN_MODE -1 -#define STLINK_DEBUG_ENTER 0x20 -#define STLINK_DEBUG_EXIT 0x21 -#define STLINK_DEBUG_READCOREID 0x22 +#define STLINK_DFU_EXIT 0x07 + +#define STLINK_SWIM_ENTER 0x00 +#define STLINK_SWIM_EXIT 0x01 +#define STLINK_DEBUG_ENTER_JTAG 0x00 #define STLINK_DEBUG_GETSTATUS 0x01 #define STLINK_DEBUG_FORCEDEBUG 0x02 #define STLINK_DEBUG_RESETSYS 0x03 @@ -91,14 +112,26 @@ struct stlink_usb_handle_s { #define STLINK_DEBUG_WRITEMEM_8BIT 0x0d #define STLINK_DEBUG_CLEARFP 0x0e #define STLINK_DEBUG_WRITEDEBUGREG 0x0f -#define STLINK_DEBUG_ENTER_SWD 0xa3 + #define STLINK_DEBUG_ENTER_JTAG 0x00 +#define STLINK_DEBUG_ENTER_SWD 0xa3 + +#define STLINK_DEBUG_ENTER 0x20 +#define STLINK_DEBUG_EXIT 0x21 +#define STLINK_DEBUG_READCOREID 0x22 -#define STLINK_SWD_ENTER 0x30 -#define STLINK_SWD_READCOREID 0x32 +/** */ +enum stlink_mode { + STLINK_MODE_UNKNOWN = 0, + STLINK_MODE_DFU, + STLINK_MODE_MASS, + STLINK_MODE_DEBUG_JTAG, + STLINK_MODE_DEBUG_SWD, + STLINK_MODE_DEBUG_SWIM +}; /** */ -int stlink_usb_recv(void *handle, const uint8_t *txbuf, int txsize, uint8_t *rxbuf, +static int stlink_usb_recv(void *handle, const uint8_t *txbuf, int txsize, uint8_t *rxbuf, int rxsize) { struct stlink_usb_handle_s *h; @@ -121,7 +154,7 @@ int stlink_usb_recv(void *handle, const uint8_t *txbuf, int txsize, uint8_t *rxb } /** */ -void stlink_usb_init_buffer(void *handle) +static void stlink_usb_init_buffer(void *handle) { struct stlink_usb_handle_s *h; @@ -133,7 +166,7 @@ void stlink_usb_init_buffer(void *handle) } /** */ -int stlink_usb_version(void *handle) +static int stlink_usb_version(void *handle) { int res; uint16_t v; @@ -154,17 +187,24 @@ int stlink_usb_version(void *handle) v = (h->rxbuf[0] << 8) | h->rxbuf[1]; - LOG_DEBUG("STLINK v%d", (v >> 12) & 0x0f); - LOG_DEBUG("JTAG v%d", (v >> 6) & 0x3f); - LOG_DEBUG("SWIM v%d", v & 0x3f); - LOG_DEBUG("VID %04X", buf_get_u32(h->rxbuf, 16, 16)); - LOG_DEBUG("PID %04X", buf_get_u32(h->rxbuf, 32, 16)); + h->version.stlink = (v >> 12) & 0x0f; + h->version.jtag = (v >> 6) & 0x3f; + h->version.swim = v & 0x3f; + h->vid = buf_get_u32(h->rxbuf, 16, 16); + h->pid = buf_get_u32(h->rxbuf, 32, 16); + + LOG_DEBUG("STLINK v%d JTAG v%d SWIM v%d VID %04X PID %04X", + h->version.stlink, + h->version.jtag, + h->version.swim, + h->vid, + h->pid); return ERROR_OK; } /** */ -int stlink_usb_current_mode(void *handle, uint8_t *mode) +static int stlink_usb_current_mode(void *handle, uint8_t *mode) { int res; struct stlink_usb_handle_s *h; @@ -188,7 +228,7 @@ int stlink_usb_current_mode(void *handle, uint8_t *mode) } /** */ -int stlink_usb_dfu_mode_leave(void *handle) +static int stlink_usb_mode_enter(void *handle, enum stlink_mode type) { int res; struct stlink_usb_handle_s *h; @@ -199,11 +239,28 @@ int stlink_usb_dfu_mode_leave(void *handle) stlink_usb_init_buffer(handle); - h->txbuf[0] = STLINK_DFU_COMMAND; - h->txbuf[1] = STLINK_DFU_EXIT; + switch (type) { + case STLINK_MODE_DEBUG_JTAG: + h->txbuf[0] = STLINK_DEBUG_COMMAND; + h->txbuf[1] = STLINK_DEBUG_ENTER; + h->txbuf[2] = STLINK_DEBUG_ENTER_JTAG; + break; + case STLINK_MODE_DEBUG_SWD: + h->txbuf[0] = STLINK_DEBUG_COMMAND; + h->txbuf[1] = STLINK_DEBUG_ENTER; + h->txbuf[2] = STLINK_DEBUG_ENTER_SWD; + break; + case STLINK_MODE_DEBUG_SWIM: + h->txbuf[0] = STLINK_SWIM_COMMAND; + h->txbuf[1] = STLINK_SWIM_ENTER; + break; + case STLINK_MODE_DFU: + case STLINK_MODE_MASS: + default: + return ERROR_FAIL; + } res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, 0, 0); - if (res != ERROR_OK) return res; @@ -211,7 +268,7 @@ int stlink_usb_dfu_mode_leave(void *handle) } /** */ -int stlink_usb_swd_mode_enter(void *handle) +static int stlink_usb_mode_leave(void *handle, enum stlink_mode type) { int res; struct stlink_usb_handle_s *h; @@ -222,9 +279,24 @@ int stlink_usb_swd_mode_enter(void *handle) stlink_usb_init_buffer(handle); - h->txbuf[0] = STLINK_DEBUG_COMMAND; - h->txbuf[1] = STLINK_DEBUG_ENTER; - h->txbuf[2] = STLINK_DEBUG_ENTER_SWD; + switch (type) { + case STLINK_MODE_DEBUG_JTAG: + case STLINK_MODE_DEBUG_SWD: + h->txbuf[0] = STLINK_DEBUG_COMMAND; + h->txbuf[1] = STLINK_DEBUG_EXIT; + break; + case STLINK_MODE_DEBUG_SWIM: + h->txbuf[0] = STLINK_SWIM_COMMAND; + h->txbuf[1] = STLINK_SWIM_EXIT; + break; + case STLINK_MODE_DFU: + h->txbuf[0] = STLINK_DFU_COMMAND; + h->txbuf[1] = STLINK_DFU_EXIT; + break; + case STLINK_MODE_MASS: + default: + return ERROR_FAIL; + } res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, 0, 0); if (res != ERROR_OK) @@ -234,35 +306,17 @@ int stlink_usb_swd_mode_enter(void *handle) } /** */ -int stlink_usb_debug_mode_leave(void *handle) +static int stlink_usb_init_mode(void *handle) { int res; + uint8_t mode; + enum stlink_mode emode; struct stlink_usb_handle_s *h; assert(handle != NULL); h = (struct stlink_usb_handle_s *)handle; - stlink_usb_init_buffer(handle); - - h->txbuf[0] = STLINK_DEBUG_COMMAND; - h->txbuf[1] = STLINK_DEBUG_EXIT; - - res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, 0, 0); - if (res != ERROR_OK) - return res; - - return ERROR_OK; -} - -/** */ -int stlink_usb_init_mode(void *handle) -{ - int res; - uint8_t mode; - - assert(handle != NULL); - res = stlink_usb_current_mode(handle, &mode); if (res != ERROR_OK) @@ -270,8 +324,24 @@ int stlink_usb_init_mode(void *handle) LOG_DEBUG("MODE: %02X", mode); - if (mode == STLINK_DEV_DFU_MODE) { - res = stlink_usb_dfu_mode_leave(handle); + /* try to exit current mode */ + switch (mode) { + case STLINK_DEV_DFU_MODE: + emode = STLINK_MODE_DFU; + break; + case STLINK_DEV_DEBUG_MODE: + emode = STLINK_MODE_DEBUG_SWD; + break; + case STLINK_DEV_SWIM_MODE: + emode = STLINK_MODE_DEBUG_SWIM; + break; + default: + emode = STLINK_MODE_UNKNOWN; + break; + } + + if (emode != STLINK_MODE_UNKNOWN) { + res = stlink_usb_mode_leave(handle, emode); if (res != ERROR_OK) return res; @@ -284,13 +354,30 @@ int stlink_usb_init_mode(void *handle) LOG_DEBUG("MODE: %02X", mode); - if (mode != STLINK_DEV_DEBUG_MODE) { - res = stlink_usb_swd_mode_enter(handle); + /* set selected mode */ + switch (h->transport) { + case STLINK_TRANSPORT_SWD: + emode = STLINK_MODE_DEBUG_SWD; + break; + case STLINK_TRANSPORT_JTAG: + emode = STLINK_MODE_DEBUG_JTAG; + break; + case STLINK_TRANSPORT_SWIM: + default: + emode = STLINK_MODE_UNKNOWN; + break; + } - if (res != ERROR_OK) - return res; + if (emode == STLINK_MODE_UNKNOWN) { + LOG_ERROR("selected mode (transport) not supported"); + return ERROR_FAIL; } + res = stlink_usb_mode_enter(handle, emode); + + if (res != ERROR_OK) + return res; + res = stlink_usb_current_mode(handle, &mode); if (res != ERROR_OK) @@ -302,7 +389,7 @@ int stlink_usb_init_mode(void *handle) } /** */ -int stlink_usb_idcode(void *handle, uint32_t *idcode) +static int stlink_usb_idcode(void *handle, uint32_t *idcode) { int res; struct stlink_usb_handle_s *h; @@ -329,7 +416,7 @@ int stlink_usb_idcode(void *handle, uint32_t *idcode) } /** */ -enum target_state stlink_usb_state(void *handle) +static enum target_state stlink_usb_state(void *handle) { int res; struct stlink_usb_handle_s *h; @@ -357,7 +444,7 @@ enum target_state stlink_usb_state(void *handle) } /** */ -int stlink_usb_reset(void *handle) +static int stlink_usb_reset(void *handle) { int res; struct stlink_usb_handle_s *h; @@ -382,7 +469,7 @@ int stlink_usb_reset(void *handle) } /** */ -int stlink_usb_run(void *handle) +static int stlink_usb_run(void *handle) { int res; struct stlink_usb_handle_s *h; @@ -405,7 +492,7 @@ int stlink_usb_run(void *handle) } /** */ -int stlink_usb_halt(void *handle) +static int stlink_usb_halt(void *handle) { int res; struct stlink_usb_handle_s *h; @@ -428,7 +515,7 @@ int stlink_usb_halt(void *handle) } /** */ -int stlink_usb_step(void *handle) +static int stlink_usb_step(void *handle) { int res; struct stlink_usb_handle_s *h; @@ -451,7 +538,7 @@ int stlink_usb_step(void *handle) } /** */ -int stlink_usb_read_regs(void *handle) +static int stlink_usb_read_regs(void *handle) { int res; struct stlink_usb_handle_s *h; @@ -474,7 +561,7 @@ int stlink_usb_read_regs(void *handle) } /** */ -int stlink_usb_read_reg(void *handle, int num, uint32_t *val) +static int stlink_usb_read_reg(void *handle, int num, uint32_t *val) { int res; struct stlink_usb_handle_s *h; @@ -500,7 +587,7 @@ int stlink_usb_read_reg(void *handle, int num, uint32_t *val) } /** */ -int stlink_usb_write_reg(void *handle, int num, uint32_t val) +static int stlink_usb_write_reg(void *handle, int num, uint32_t val) { int res; struct stlink_usb_handle_s *h; @@ -525,7 +612,7 @@ int stlink_usb_write_reg(void *handle, int num, uint32_t val) } /** */ -int stlink_usb_read_mem8(void *handle, uint32_t addr, uint16_t len, +static int stlink_usb_read_mem8(void *handle, uint32_t addr, uint16_t len, uint8_t *buffer) { int res; @@ -558,7 +645,7 @@ int stlink_usb_read_mem8(void *handle, uint32_t addr, uint16_t len, } /** */ -int stlink_usb_write_mem8(void *handle, uint32_t addr, uint16_t len, +static int stlink_usb_write_mem8(void *handle, uint32_t addr, uint16_t len, const uint8_t *buffer) { int res; @@ -589,7 +676,7 @@ int stlink_usb_write_mem8(void *handle, uint32_t addr, uint16_t len, } /** */ -int stlink_usb_read_mem32(void *handle, uint32_t addr, uint16_t len, +static int stlink_usb_read_mem32(void *handle, uint32_t addr, uint16_t len, uint32_t *buffer) { int res; @@ -619,7 +706,7 @@ int stlink_usb_read_mem32(void *handle, uint32_t addr, uint16_t len, } /** */ -int stlink_usb_write_mem32(void *handle, uint32_t addr, uint16_t len, +static int stlink_usb_write_mem32(void *handle, uint32_t addr, uint16_t len, const uint32_t *buffer) { int res; @@ -652,8 +739,9 @@ int stlink_usb_write_mem32(void *handle, uint32_t addr, uint16_t len, } /** */ -int stlink_usb_open(struct stlink_interface_param_s *param, void **fd) +static int stlink_usb_open(struct stlink_interface_param_s *param, void **fd) { + int err; struct stlink_usb_handle_s *h; LOG_DEBUG("stlink_usb_open"); @@ -661,31 +749,79 @@ int stlink_usb_open(struct stlink_interface_param_s *param, void **fd) h = malloc(sizeof(struct stlink_usb_handle_s)); if (h == 0) { - LOG_DEBUG("stlink_open_usb: malloc failed"); + LOG_DEBUG("malloc failed"); return ERROR_FAIL; } + h->transport = param->transport; + const uint16_t vids[] = { param->vid, 0 }; const uint16_t pids[] = { param->pid, 0 }; - LOG_DEBUG("stlink_open_usb: vid: %04x pid: %04x", param->vid, + LOG_DEBUG("vid: %04x pid: %04x", param->vid, param->pid); if (jtag_libusb_open(vids, pids, &h->fd) != ERROR_OK) { - LOG_ERROR("stlink_open_usb: open failed"); + LOG_ERROR("open failed"); return ERROR_FAIL; } jtag_libusb_set_configuration(h->fd, 0); if (jtag_libusb_claim_interface(h->fd, 0) != ERROR_OK) { - LOG_DEBUG("stlink_open_usb: claim failed"); + LOG_DEBUG("claim interface failed"); return ERROR_FAIL; } - stlink_usb_init_mode(h); + /* get the device version */ + err = stlink_usb_version(h); - stlink_usb_version(h); + if (err != ERROR_OK) { + LOG_ERROR("read version failed"); + jtag_libusb_close(h->fd); + free(h); + return err; + } + + /* compare usb vid/pid */ + if ((param->vid != h->vid) || (param->pid != h->pid)) + LOG_INFO("vid/pid are not identical: %04X/%04X %04X/%04X", + param->vid, param->pid, + h->vid, h->pid); + + /* check if mode is supported */ + err = ERROR_OK; + + switch (h->transport) { + case STLINK_TRANSPORT_SWD: + case STLINK_TRANSPORT_JTAG: + if (h->version.jtag == 0) + err = ERROR_FAIL; + break; + case STLINK_TRANSPORT_SWIM: + if (h->version.swim == 0) + err = ERROR_FAIL; + break; + default: + err = ERROR_FAIL; + break; + } + + if (err != ERROR_OK) { + LOG_ERROR("mode (transport) not supported by device"); + jtag_libusb_close(h->fd); + free(h); + return err; + } + + err = stlink_usb_init_mode(h); + + if (err != ERROR_OK) { + LOG_ERROR("init mode failed"); + jtag_libusb_close(h->fd); + free(h); + return err; + } *fd = h; @@ -693,10 +829,18 @@ int stlink_usb_open(struct stlink_interface_param_s *param, void **fd) } /** */ -struct stlink_layout_api_s stlink_layout_api = { +static int stlink_usb_close(void *fd) +{ + return ERROR_OK; +} + +/** */ +struct stlink_layout_api_s stlink_usb_layout_api = { /** */ .open = stlink_usb_open, /** */ + .close = stlink_usb_close, + /** */ .idcode = stlink_usb_idcode, /** */ .state = stlink_usb_state, diff --git a/src/jtag/stlink/stlink_interface.c b/src/jtag/stlink/stlink_interface.c index fc5edc61..6a856945 100644 --- a/src/jtag/stlink/stlink_interface.c +++ b/src/jtag/stlink/stlink_interface.c @@ -28,16 +28,20 @@ #include #include +#include #include #include -static struct stlink_interface_s stlink_if = { {0, 0, 0, 0}, 0, 0 }; +static struct stlink_interface_s stlink_if = { {0, 0, 0, 0, 0}, 0, 0 }; -int stlink_interface_open(void) +int stlink_interface_open(enum stlink_transports tr) { LOG_DEBUG("stlink_interface_open"); + /* set transport mode */ + stlink_if.param.transport = tr; + return stlink_if.layout->open(&stlink_if); } @@ -45,6 +49,8 @@ int stlink_interface_init_target(struct target *t) { int res; + LOG_DEBUG("stlink_interface_init_target"); + /* this is the interface for the current target and we * can setup the private pointer in the tap structure * if the interface match the tap idcode diff --git a/src/jtag/stlink/stlink_interface.h b/src/jtag/stlink/stlink_interface.h index 9b3f791e..b1bffc77 100644 --- a/src/jtag/stlink/stlink_interface.h +++ b/src/jtag/stlink/stlink_interface.h @@ -23,6 +23,8 @@ /** */ struct target; /** */ +enum e_stlink_transports; +/** */ extern const char *stlink_transports[]; struct stlink_interface_param_s { @@ -34,6 +36,8 @@ struct stlink_interface_param_s { uint16_t vid; /** */ uint16_t pid; + /** */ + enum stlink_transports transport; }; struct stlink_interface_s { @@ -46,7 +50,7 @@ struct stlink_interface_s { }; /** */ -int stlink_interface_open(void); +int stlink_interface_open(enum stlink_transports tr); /** */ int stlink_interface_init_target(struct target *t); diff --git a/src/jtag/stlink/stlink_layout.c b/src/jtag/stlink/stlink_layout.c index 4d510bb0..0681d2a6 100644 --- a/src/jtag/stlink/stlink_layout.c +++ b/src/jtag/stlink/stlink_layout.c @@ -29,6 +29,7 @@ #include #include +#include #include #define STLINK_LAYOUT_UNKNOWN 0 @@ -46,7 +47,7 @@ static int stlink_layout_open(struct stlink_interface_s *stlink_if) res = stlink_if->layout->api->open(&stlink_if->param, &stlink_if->fd); if (res != ERROR_OK) { - LOG_DEBUG("stlink_layout_open: failed"); + LOG_DEBUG("failed"); return res; } @@ -64,7 +65,7 @@ static const struct stlink_layout stlink_layouts[] = { .type = STLINK_LAYOUT_USB, .open = stlink_layout_open, .close = stlink_layout_close, - .api = &stlink_layout_api, + .api = &stlink_usb_layout_api, }, {.name = NULL, /* END OF TABLE */ }, }; diff --git a/src/jtag/stlink/stlink_layout.h b/src/jtag/stlink/stlink_layout.h index bf1e2c68..caae8284 100644 --- a/src/jtag/stlink/stlink_layout.h +++ b/src/jtag/stlink/stlink_layout.h @@ -25,7 +25,7 @@ struct stlink_interface_s; struct stlink_interface_param_s; /** */ -extern struct stlink_layout_api_s stlink_layout_api; +extern struct stlink_layout_api_s stlink_usb_layout_api; /** */ struct stlink_layout_api_s { diff --git a/src/jtag/stlink/stlink_transport.c b/src/jtag/stlink/stlink_transport.c index 14e59ec7..dc3c6810 100644 --- a/src/jtag/stlink/stlink_transport.c +++ b/src/jtag/stlink/stlink_transport.c @@ -29,6 +29,7 @@ #include #include #include +#include #include COMMAND_HANDLER(stlink_transport_jtag_command) @@ -138,13 +139,35 @@ static int stlink_transport_init(struct command_context *cmd_ctx) { LOG_DEBUG("stlink_transport_init"); struct target *t = get_current_target(cmd_ctx); + struct transport *transport; + enum stlink_transports tr; if (!t) { - LOG_ERROR("stlink_transport_init: no current target"); + LOG_ERROR("no current target"); return ERROR_FAIL; } - int retval = stlink_interface_open(); + transport = get_current_transport(); + + if (!transport) { + LOG_ERROR("no transport selected"); + return ERROR_FAIL; + } + + LOG_DEBUG("current transport %s", transport->name); + + /* get selected transport as enum */ + tr = STLINK_TRANSPORT_UNKNOWN; + + if (strcmp(transport->name, "stlink_swd") == 0) + tr = STLINK_TRANSPORT_SWD; + else if (strcmp(transport->name, "stlink_jtag") == 0) + tr = STLINK_TRANSPORT_JTAG; + else if (strcmp(transport->name, "stlink_swim") == 0) + tr = STLINK_TRANSPORT_SWIM; + + int retval = stlink_interface_open(tr); + if (retval != ERROR_OK) return retval; @@ -169,21 +192,35 @@ static int stlink_transport_select(struct command_context *ctx) return ERROR_OK; } -static struct transport stlink_transport = { - .name = "stlink", +static struct transport stlink_swd_transport = { + .name = "stlink_swd", + .select = stlink_transport_select, + .init = stlink_transport_init, +}; + +static struct transport stlink_jtag_transport = { + .name = "stlink_jtag", + .select = stlink_transport_select, + .init = stlink_transport_init, +}; + +static struct transport stlink_swim_transport = { + .name = "stlink_swim", .select = stlink_transport_select, .init = stlink_transport_init, }; -const char *stlink_transports[] = { "stlink", NULL }; +const char *stlink_transports[] = { "stlink_swd", "stlink_jtag", "stlink_swim", NULL }; static void stlink_constructor(void) __attribute__ ((constructor)); static void stlink_constructor(void) { - transport_register(&stlink_transport); + transport_register(&stlink_swd_transport); + transport_register(&stlink_jtag_transport); + transport_register(&stlink_swim_transport); } bool transport_is_stlink(void) { - return get_current_transport() == &stlink_transport; + return get_current_transport() == &stlink_swd_transport; } diff --git a/src/jtag/stlink/stlink_transport.h b/src/jtag/stlink/stlink_transport.h index 066b194b..e5197dae 100644 --- a/src/jtag/stlink/stlink_transport.h +++ b/src/jtag/stlink/stlink_transport.h @@ -20,4 +20,11 @@ #ifndef _STLINK_TRANSPORT_ #define _STLINK_TRANSPORT_ +enum stlink_transports { + STLINK_TRANSPORT_UNKNOWN = 0, + STLINK_TRANSPORT_SWD, + STLINK_TRANSPORT_JTAG, + STLINK_TRANSPORT_SWIM +}; + #endif diff --git a/src/target/stm32_stlink.c b/src/target/stm32_stlink.c index 3a4b58be..f6f9247f 100644 --- a/src/target/stm32_stlink.c +++ b/src/target/stm32_stlink.c @@ -25,6 +25,7 @@ #endif #include "jtag/jtag.h" +#include "jtag/stlink/stlink_transport.h" #include "jtag/stlink/stlink_interface.h" #include "jtag/stlink/stlink_layout.h" #include "register.h" diff --git a/tcl/target/stm32_stlink.cfg b/tcl/target/stm32_stlink.cfg index 7af07ce7..9a67b99c 100644 --- a/tcl/target/stm32_stlink.cfg +++ b/tcl/target/stm32_stlink.cfg @@ -23,6 +23,11 @@ if { [info exists CPUTAPID] } { set _CPUTAPID 0x1ba01477 } +# +# possibles value are stlink_swd or stlink_jtag +# +transport select stlink_swd + stlink newtap $_CHIPNAME cpu -expected-id $_CPUTAPID set _TARGETNAME $_CHIPNAME.cpu -- 2.39.5