zcy
/
tinyriscv-openocd
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

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 <kesmtp@freenet.de>
Reviewed-on: http://openocd.zylin.com/393
Tested-by: jenkins
Reviewed-by: Spencer Oliver <spen@spen-soft.co.uk>
__archive__
Mathias K 2012-01-25 09:30:45 +01:00 committed by Spencer Oliver
parent f2ee4eff73
commit 6bbb1479b3
9 changed files with 297 additions and 92 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

302
src/jtag/drivers/stlink_usb.c
View File

@ -28,6 +28,7 @@
#include <helper/binarybuffer.h> #include <helper/binarybuffer.h>
#include <jtag/interface.h> #include <jtag/interface.h>
#include <jtag/stlink/stlink_layout.h> #include <jtag/stlink/stlink_layout.h>
#include <jtag/stlink/stlink_transport.h>
#include <jtag/stlink/stlink_interface.h> #include <jtag/stlink/stlink_interface.h>
#include <target/target.h> #include <target/target.h>
@ -42,6 +43,16 @@
#define STLINK_TX_SIZE (4*128) #define STLINK_TX_SIZE (4*128)
#define STLINK_RX_SIZE (4*128) #define STLINK_RX_SIZE (4*128)
/** */
struct stlink_usb_version {
/** */
int stlink;
/** */
int jtag;
/** */
int swim;
};
/** */ /** */
struct stlink_usb_handle_s { struct stlink_usb_handle_s {
/** */ /** */
@ -52,6 +63,14 @@ struct stlink_usb_handle_s {
uint8_t txbuf[STLINK_TX_SIZE]; uint8_t txbuf[STLINK_TX_SIZE];
/** */ /** */
uint8_t rxbuf[STLINK_RX_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 #define STLINK_OK 0x80
@ -60,22 +79,24 @@ struct stlink_usb_handle_s {
#define STLINK_CORE_HALTED 0x81 #define STLINK_CORE_HALTED 0x81
#define STLINK_CORE_STAT_UNKNOWN -1 #define STLINK_CORE_STAT_UNKNOWN -1
#define STLINK_GET_VERSION 0xf1 #define STLINK_GET_VERSION 0xF1
#define STLINK_GET_CURRENT_MODE 0xf5
#define STLINK_DEBUG_COMMAND 0xF2 #define STLINK_DEBUG_COMMAND 0xF2
#define STLINK_DFU_COMMAND 0xF3 #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_DFU_MODE 0x00
#define STLINK_DEV_MASS_MODE 0x01 #define STLINK_DEV_MASS_MODE 0x01
#define STLINK_DEV_DEBUG_MODE 0x02 #define STLINK_DEV_DEBUG_MODE 0x02
#define STLINK_DEV_SWIM_MODE 0x03
#define STLINK_DEV_UNKNOWN_MODE -1 #define STLINK_DEV_UNKNOWN_MODE -1
#define STLINK_DEBUG_ENTER 0x20 #define STLINK_DFU_EXIT 0x07
#define STLINK_DEBUG_EXIT 0x21
#define STLINK_DEBUG_READCOREID 0x22
#define STLINK_SWIM_ENTER 0x00
#define STLINK_SWIM_EXIT 0x01
#define STLINK_DEBUG_ENTER_JTAG 0x00
#define STLINK_DEBUG_GETSTATUS 0x01 #define STLINK_DEBUG_GETSTATUS 0x01
#define STLINK_DEBUG_FORCEDEBUG 0x02 #define STLINK_DEBUG_FORCEDEBUG 0x02
#define STLINK_DEBUG_RESETSYS 0x03 #define STLINK_DEBUG_RESETSYS 0x03
@ -91,14 +112,26 @@ struct stlink_usb_handle_s {
#define STLINK_DEBUG_WRITEMEM_8BIT 0x0d #define STLINK_DEBUG_WRITEMEM_8BIT 0x0d
#define STLINK_DEBUG_CLEARFP 0x0e #define STLINK_DEBUG_CLEARFP 0x0e
#define STLINK_DEBUG_WRITEDEBUGREG 0x0f #define STLINK_DEBUG_WRITEDEBUGREG 0x0f
#define STLINK_DEBUG_ENTER_SWD 0xa3
#define STLINK_DEBUG_ENTER_JTAG 0x00
#define STLINK_SWD_ENTER 0x30 #define STLINK_DEBUG_ENTER_JTAG 0x00
#define STLINK_SWD_READCOREID 0x32 #define STLINK_DEBUG_ENTER_SWD 0xa3
#define STLINK_DEBUG_ENTER 0x20
#define STLINK_DEBUG_EXIT 0x21
#define STLINK_DEBUG_READCOREID 0x22
/** */ /** */
int stlink_usb_recv(void *handle, const uint8_t *txbuf, int txsize, uint8_t *rxbuf, 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
};
/** */
static int stlink_usb_recv(void *handle, const uint8_t *txbuf, int txsize, uint8_t *rxbuf,
int rxsize) int rxsize)
{ {
struct stlink_usb_handle_s *h; 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; 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; int res;
uint16_t v; uint16_t v;
@ -154,17 +187,24 @@ int stlink_usb_version(void *handle)
v = (h->rxbuf[0] << 8) | h->rxbuf[1]; v = (h->rxbuf[0] << 8) | h->rxbuf[1];
LOG_DEBUG("STLINK v%d", (v >> 12) & 0x0f); h->version.stlink = (v >> 12) & 0x0f;
LOG_DEBUG("JTAG v%d", (v >> 6) & 0x3f); h->version.jtag = (v >> 6) & 0x3f;
LOG_DEBUG("SWIM v%d", v & 0x3f); h->version.swim = v & 0x3f;
LOG_DEBUG("VID %04X", buf_get_u32(h->rxbuf, 16, 16)); h->vid = buf_get_u32(h->rxbuf, 16, 16);
LOG_DEBUG("PID %04X", buf_get_u32(h->rxbuf, 32, 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; 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; int res;
struct stlink_usb_handle_s *h; 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; int res;
struct stlink_usb_handle_s *h; struct stlink_usb_handle_s *h;
@ -199,11 +239,28 @@ int stlink_usb_dfu_mode_leave(void *handle)
stlink_usb_init_buffer(handle); stlink_usb_init_buffer(handle);
h->txbuf[0] = STLINK_DFU_COMMAND; switch (type) {
h->txbuf[1] = STLINK_DFU_EXIT; 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); res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, 0, 0);
if (res != ERROR_OK) if (res != ERROR_OK)
return res; 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; int res;
struct stlink_usb_handle_s *h; struct stlink_usb_handle_s *h;
@ -222,9 +279,24 @@ int stlink_usb_swd_mode_enter(void *handle)
stlink_usb_init_buffer(handle); stlink_usb_init_buffer(handle);
h->txbuf[0] = STLINK_DEBUG_COMMAND; switch (type) {
h->txbuf[1] = STLINK_DEBUG_ENTER; case STLINK_MODE_DEBUG_JTAG:
h->txbuf[2] = STLINK_DEBUG_ENTER_SWD; 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); res = stlink_usb_recv(handle, h->txbuf, STLINK_CMD_SIZE, 0, 0);
if (res != ERROR_OK) 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;
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; int res;
uint8_t mode; uint8_t mode;
enum stlink_mode emode;
struct stlink_usb_handle_s *h;
assert(handle != NULL); assert(handle != NULL);
h = (struct stlink_usb_handle_s *)handle;
res = stlink_usb_current_mode(handle, &mode); res = stlink_usb_current_mode(handle, &mode);
if (res != ERROR_OK) if (res != ERROR_OK)
@ -270,8 +324,24 @@ int stlink_usb_init_mode(void *handle)
LOG_DEBUG("MODE: %02X", mode); LOG_DEBUG("MODE: %02X", mode);
if (mode == STLINK_DEV_DFU_MODE) { /* try to exit current mode */
res = stlink_usb_dfu_mode_leave(handle); 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) if (res != ERROR_OK)
return res; return res;
@ -284,13 +354,30 @@ int stlink_usb_init_mode(void *handle)
LOG_DEBUG("MODE: %02X", mode); LOG_DEBUG("MODE: %02X", mode);
if (mode != STLINK_DEV_DEBUG_MODE) { /* set selected mode */
res = stlink_usb_swd_mode_enter(handle); switch (h->transport) {
case STLINK_TRANSPORT_SWD:
if (res != ERROR_OK) emode = STLINK_MODE_DEBUG_SWD;
return res; break;
case STLINK_TRANSPORT_JTAG:
emode = STLINK_MODE_DEBUG_JTAG;
break;
case STLINK_TRANSPORT_SWIM:
default:
emode = STLINK_MODE_UNKNOWN;
break;
} }
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); res = stlink_usb_current_mode(handle, &mode);
if (res != ERROR_OK) 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; int res;
struct stlink_usb_handle_s *h; 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; int res;
struct stlink_usb_handle_s *h; 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; int res;
struct stlink_usb_handle_s *h; 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; int res;
struct stlink_usb_handle_s *h; 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; int res;
struct stlink_usb_handle_s *h; 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; int res;
struct stlink_usb_handle_s *h; 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; int res;
struct stlink_usb_handle_s *h; 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; int res;
struct stlink_usb_handle_s *h; 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; int res;
struct stlink_usb_handle_s *h; 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) uint8_t *buffer)
{ {
int res; 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) const uint8_t *buffer)
{ {
int res; 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) uint32_t *buffer)
{ {
int res; 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) const uint32_t *buffer)
{ {
int res; 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; struct stlink_usb_handle_s *h;
LOG_DEBUG("stlink_usb_open"); 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)); h = malloc(sizeof(struct stlink_usb_handle_s));
if (h == 0) { if (h == 0) {
LOG_DEBUG("stlink_open_usb: malloc failed"); LOG_DEBUG("malloc failed");
return ERROR_FAIL; return ERROR_FAIL;
} }
h->transport = param->transport;
const uint16_t vids[] = { param->vid, 0 }; const uint16_t vids[] = { param->vid, 0 };
const uint16_t pids[] = { param->pid, 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); param->pid);
if (jtag_libusb_open(vids, pids, &h->fd) != ERROR_OK) { if (jtag_libusb_open(vids, pids, &h->fd) != ERROR_OK) {
LOG_ERROR("stlink_open_usb: open failed"); LOG_ERROR("open failed");
return ERROR_FAIL; return ERROR_FAIL;
} }
jtag_libusb_set_configuration(h->fd, 0); jtag_libusb_set_configuration(h->fd, 0);
if (jtag_libusb_claim_interface(h->fd, 0) != ERROR_OK) { 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; 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; *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, .open = stlink_usb_open,
/** */ /** */
.close = stlink_usb_close,
/** */
.idcode = stlink_usb_idcode, .idcode = stlink_usb_idcode,
/** */ /** */
.state = stlink_usb_state, .state = stlink_usb_state,

10
src/jtag/stlink/stlink_interface.c
View File

@ -28,16 +28,20 @@
#include <jtag/stlink/stlink_tcl.h> #include <jtag/stlink/stlink_tcl.h>
#include <jtag/stlink/stlink_layout.h> #include <jtag/stlink/stlink_layout.h>
#include <jtag/stlink/stlink_transport.h>
#include <jtag/stlink/stlink_interface.h> #include <jtag/stlink/stlink_interface.h>
#include <target/target.h> #include <target/target.h>
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"); LOG_DEBUG("stlink_interface_open");
/* set transport mode */
stlink_if.param.transport = tr;
return stlink_if.layout->open(&stlink_if); return stlink_if.layout->open(&stlink_if);
} }
@ -45,6 +49,8 @@ int stlink_interface_init_target(struct target *t)
{ {
int res; int res;
LOG_DEBUG("stlink_interface_init_target");
/* this is the interface for the current target and we /* this is the interface for the current target and we
* can setup the private pointer in the tap structure * can setup the private pointer in the tap structure
* if the interface match the tap idcode * if the interface match the tap idcode

6
src/jtag/stlink/stlink_interface.h
View File

@ -23,6 +23,8 @@
/** */ /** */
struct target; struct target;
/** */ /** */
enum e_stlink_transports;
/** */
extern const char *stlink_transports[]; extern const char *stlink_transports[];
struct stlink_interface_param_s { struct stlink_interface_param_s {
@ -34,6 +36,8 @@ struct stlink_interface_param_s {
uint16_t vid; uint16_t vid;
/** */ /** */
uint16_t pid; uint16_t pid;
/** */
enum stlink_transports transport;
}; };
struct stlink_interface_s { 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); int stlink_interface_init_target(struct target *t);

5
src/jtag/stlink/stlink_layout.c
View File

@ -29,6 +29,7 @@
#include <jtag/stlink/stlink_layout.h> #include <jtag/stlink/stlink_layout.h>
#include <jtag/stlink/stlink_tcl.h> #include <jtag/stlink/stlink_tcl.h>
#include <jtag/stlink/stlink_transport.h>
#include <jtag/stlink/stlink_interface.h> #include <jtag/stlink/stlink_interface.h>
#define STLINK_LAYOUT_UNKNOWN 0 #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); res = stlink_if->layout->api->open(&stlink_if->param, &stlink_if->fd);
if (res != ERROR_OK) { if (res != ERROR_OK) {
LOG_DEBUG("stlink_layout_open: failed"); LOG_DEBUG("failed");
return res; return res;
} }
@ -64,7 +65,7 @@ static const struct stlink_layout stlink_layouts[] = {
.type = STLINK_LAYOUT_USB, .type = STLINK_LAYOUT_USB,
.open = stlink_layout_open, .open = stlink_layout_open,
.close = stlink_layout_close, .close = stlink_layout_close,
.api = &stlink_layout_api, .api = &stlink_usb_layout_api,
}, },
{.name = NULL, /* END OF TABLE */ }, {.name = NULL, /* END OF TABLE */ },
}; };

2
src/jtag/stlink/stlink_layout.h
View File

@ -25,7 +25,7 @@ struct stlink_interface_s;
struct stlink_interface_param_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 { struct stlink_layout_api_s {

51
src/jtag/stlink/stlink_transport.c
View File

@ -29,6 +29,7 @@
#include <helper/time_support.h> #include <helper/time_support.h>
#include <target/target.h> #include <target/target.h>
#include <jtag/stlink/stlink_tcl.h> #include <jtag/stlink/stlink_tcl.h>
#include <jtag/stlink/stlink_transport.h>
#include <jtag/stlink/stlink_interface.h> #include <jtag/stlink/stlink_interface.h>
COMMAND_HANDLER(stlink_transport_jtag_command) 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"); LOG_DEBUG("stlink_transport_init");
struct target *t = get_current_target(cmd_ctx); struct target *t = get_current_target(cmd_ctx);
struct transport *transport;
enum stlink_transports tr;
if (!t) { if (!t) {
LOG_ERROR("stlink_transport_init: no current target"); LOG_ERROR("no current target");
return ERROR_FAIL; 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) if (retval != ERROR_OK)
return retval; return retval;
@ -169,21 +192,35 @@ static int stlink_transport_select(struct command_context *ctx)
return ERROR_OK; return ERROR_OK;
} }
static struct transport stlink_transport = { static struct transport stlink_swd_transport = {
.name = "stlink", .name = "stlink_swd",
.select = stlink_transport_select, .select = stlink_transport_select,
.init = stlink_transport_init, .init = stlink_transport_init,
}; };
const char *stlink_transports[] = { "stlink", NULL }; 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_swd", "stlink_jtag", "stlink_swim", NULL };
static void stlink_constructor(void) __attribute__ ((constructor)); static void stlink_constructor(void) __attribute__ ((constructor));
static void stlink_constructor(void) 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) bool transport_is_stlink(void)
{ {
return get_current_transport() == &stlink_transport; return get_current_transport() == &stlink_swd_transport;
} }

7
src/jtag/stlink/stlink_transport.h
View File

@ -20,4 +20,11 @@
#ifndef _STLINK_TRANSPORT_ #ifndef _STLINK_TRANSPORT_
#define _STLINK_TRANSPORT_ #define _STLINK_TRANSPORT_
enum stlink_transports {
STLINK_TRANSPORT_UNKNOWN = 0,
STLINK_TRANSPORT_SWD,
STLINK_TRANSPORT_JTAG,
STLINK_TRANSPORT_SWIM
};
#endif #endif

1
src/target/stm32_stlink.c
View File

@ -25,6 +25,7 @@
#endif #endif
#include "jtag/jtag.h" #include "jtag/jtag.h"
#include "jtag/stlink/stlink_transport.h"
#include "jtag/stlink/stlink_interface.h" #include "jtag/stlink/stlink_interface.h"
#include "jtag/stlink/stlink_layout.h" #include "jtag/stlink/stlink_layout.h"
#include "register.h" #include "register.h"

5
tcl/target/stm32_stlink.cfg
View File

@ -23,6 +23,11 @@ if { [info exists CPUTAPID] } {
set _CPUTAPID 0x1ba01477 set _CPUTAPID 0x1ba01477
} }
#
# possibles value are stlink_swd or stlink_jtag
#
transport select stlink_swd
stlink newtap $_CHIPNAME cpu -expected-id $_CPUTAPID stlink newtap $_CHIPNAME cpu -expected-id $_CPUTAPID
set _TARGETNAME $_CHIPNAME.cpu set _TARGETNAME $_CHIPNAME.cpu