interesting
/
riscv-openocd
mirror of https://github.com/riscv/riscv-openocd.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

- added support for Asix Presto JTAG interface (thanks to Pavel Chromy and Asix for making this addition possible) 

- added support for usbprog (thanks to Benedikt Sauter)
- make OpenOCD listen for WM_QUIT messages on windows (thanks to Pavel Chromy)
- register at_exit handler to do necessary unregistering (thanks to Pavel Chromy)
- added dummy ETM capture driver to allow ETM to be registered without a capture driver


git-svn-id: svn://svn.berlios.de/openocd/trunk@180 b42882b7-edfa-0310-969c-e2dbd0fdcd60
This commit is contained in:
drath 2007-07-15 11:19:33 +00:00
parent 32c6d70f6a
commit 1429d2c659
17 changed files with 1864 additions and 14 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

31
configure.in
View File

@ -15,6 +15,7 @@ AC_CHECK_FUNCS(gettimeofday)
AC_CHECK_FUNCS(usleep)
build_bitbang=no
build_bitq=no
is_cygwin=no
is_mingw=no
is_win32=no
@ -51,6 +52,14 @@ AC_ARG_ENABLE(gw16012,
AS_HELP_STRING([--enable-gw16012], [Enable building support for the Gateworks GW16012 JTAG Programmer]),
[build_gw16012=$enableval], [build_gw16012=no])
AC_ARG_ENABLE(presto,
AS_HELP_STRING([--enable-presto], [Enable building support for ASIX Presto Programmer]),
[build_presto=$enableval], [build_presto=no])
AC_ARG_ENABLE(usbprog,
AS_HELP_STRING([--enable-usbprog], [Enable building support for the usbprog JTAG Programmer]),
[build_usbprog=$enableval], [build_usbprog=no])
AC_ARG_WITH(ftd2xx,
[AS_HELP_STRING(--with-ftd2xx,
[Where libftd2xx can be found <default=search>])],
@ -156,6 +165,25 @@ else
AC_DEFINE(BUILD_GW16012, 0, [0 if you don't want the Gateworks GW16012 driver.])
fi
if test $build_presto = yes; then
build_bitq=yes
AC_DEFINE(BUILD_PRESTO, 1, [1 if you want the ASIX PRESTO driver.])
else
AC_DEFINE(BUILD_PRESTO, 0, [0 if you don't want the ASIX PRESTO driver.])
fi
if test $build_bitq = yes; then
AC_DEFINE(BUILD_BITQ, 1, [1 if you want a bitq interface.])
else
AC_DEFINE(BUILD_BITQ, 0, [0 if you don't want a bitq interface.])
fi
if test $build_usbprog = yes; then
AC_DEFINE(BUILD_USBPROG, 1, [1 if you want the usbprog JTAG driver.])
else
AC_DEFINE(BUILD_USBPROG, 0, [0 if you don't want the usbprog JTAG driver.])
fi
AM_CONFIG_HEADER(config.h)
AM_INIT_AUTOMAKE(openocd, 0.1)
@ -168,10 +196,13 @@ AM_CONDITIONAL(FT2232_LIBFTDI, test $build_ft2232_libftdi = yes)
AM_CONDITIONAL(FT2232_FTD2XX, test $build_ft2232_ftd2xx = yes)
AM_CONDITIONAL(AMTJTAGACCEL, test $build_amtjtagaccel = yes)
AM_CONDITIONAL(GW16012, test $build_gw16012 = yes)
AM_CONDITIONAL(PRESTO, test $build_presto = yes)
AM_CONDITIONAL(USBPROG, test $build_usbprog = yes)
AM_CONDITIONAL(IS_CYGWIN, test $is_cygwin = yes)
AM_CONDITIONAL(IS_MINGW, test $is_mingw = yes)
AM_CONDITIONAL(IS_WIN32, test $is_win32 = yes)
AM_CONDITIONAL(FTD2XXDIR, test $with_ftd2xx != search)
AM_CONDITIONAL(BITQ, test $build_bitq = yes)
AC_LANG_C
AC_PROG_CC

12
src/Makefile.am
View File

@ -22,6 +22,12 @@ else
FTDI2232LIB =
endif
if USBPROG
LIBUSB = -lusb
else
LIBUSB =
endif
if IS_WIN32
if FTD2XXDIR
FTD2XXLDADD = @WITH_FTD2XX@/FTD2XX.lib
@ -35,8 +41,12 @@ endif
if FT2232_FTD2XX
FTD2XXLIB = $(FTD2XXLDADD)
else
if PRESTO
FTD2XXLIB = $(FTD2XXLDADD)
else
FTD2XXLIB =
endif
endif
openocd_LDADD = $(top_builddir)/src/xsvf/libxsvf.a \
$(top_builddir)/src/target/libtarget.a $(top_builddir)/src/jtag/libjtag.a \
@ -44,4 +54,4 @@ openocd_LDADD = $(top_builddir)/src/xsvf/libxsvf.a \
$(top_builddir)/src/server/libserver.a $(top_builddir)/src/helper/libhelper.a \
$(top_builddir)/src/flash/libflash.a $(top_builddir)/src/target/libtarget.a \
$(top_builddir)/src/pld/libpld.a \
$(FTDI2232LIB) $(FTD2XXLIB) $(MINGWLDADD)
$(FTDI2232LIB) $(FTD2XXLIB) $(MINGWLDADD) $(LIBUSB)

2
src/flash/str9x.c
View File

@ -610,7 +610,7 @@ int str9x_handle_flash_config_command(struct command_context_s *cmd_ctx, char *c
if (argc < 4)
{
command_print(cmd_ctx, "usage: str9x flash_config b0size b1size b0start b1start");
command_print(cmd_ctx, "usage: str9x flash_config <b0size> <b1size> <b0start> <b1start>");
return ERROR_OK;
}

21
src/jtag/Makefile.am
View File

@ -59,6 +59,25 @@ else
GW16012FILES =
endif
libjtag_a_SOURCES = jtag.c $(BITBANGFILES) $(PARPORTFILES) $(FT2232FILES) $(AMTJTAGACCELFILES) $(EP93XXFILES) $(AT91RM9200FILES) $(GW16012FILES)
if BITQ
BITQFILES = bitq.c
else
BITQFILES =
endif
if PRESTO
PRESTOFILES = presto.c
else
PRESTOFILES =
endif
if USBPROG
USBPROGFILES = usbprog.c
else
USBPROGFILES =
endif
libjtag_a_SOURCES = jtag.c $(BITBANGFILES) $(PARPORTFILES) $(FT2232FILES) $(AMTJTAGACCELFILES) $(EP93XXFILES) \
$(AT91RM9200FILES) $(GW16012FILES) $(BITQFILES) $(PRESTOFILES) $(USBPROGFILES)
noinst_HEADERS = bitbang.h jtag.h

388
src/jtag/bitq.c Normal file
View File

@ -0,0 +1,388 @@
/***************************************************************************
* Copyright (C) 2007 by Pavel Chromy *
* chromy@asix.cz *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "bitq.h"
/* project specific includes */
#include "log.h"
#include "types.h"
#include "jtag.h"
#include "configuration.h"
/* system includes */
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <time.h>
bitq_interface_t *bitq_interface; /* low level bit queue interface */
bitq_state_t bitq_in_state; /* state of input queue */
u8 *bitq_in_buffer; /* buffer dynamically reallocated as needed */
unsigned long bitq_in_bufsize=32; /* min. buffer size */
/*
* input queue processing does not use jtag_read_buffer() to avoid unnecessary overhead
* also the buffer for incomming data is reallocated only if necessary
* no parameters, makes use of stored state information
*/
void bitq_in_proc(void)
{
/* static information preserved between calls to increase performance */
static u8 *in_buff; /* pointer to buffer for scanned data */
static int in_idx; /* index of byte being scanned */
static u8 in_mask; /* mask of next bit to be scanned */
scan_field_t *field;
int tdo;
int result;
/* loop through the queue */
while (bitq_in_state.cmd) {
/* only JTAG_SCAN command may return data */
if (bitq_in_state.cmd->type==JTAG_SCAN) {
/* loop through the fields */
while (bitq_in_state.field_idx<bitq_in_state.cmd->cmd.scan->num_fields) {
field=&bitq_in_state.cmd->cmd.scan->fields[bitq_in_state.field_idx];
if (field->in_check_value || field->in_value || field->in_handler) {
if (bitq_in_state.bit_pos==0) {
/* initialize field scanning */
in_mask=0x01;
in_idx=0;
if (field->in_value) in_buff=field->in_value;
else {
/* buffer reallocation needed? */
if (field->num_bits>bitq_in_bufsize*8) {
/* buffer previously allocated? */
if (bitq_in_buffer!=NULL) {
/* free it */
free(bitq_in_buffer);
bitq_in_buffer=NULL;
}
/* double the buffer size until it fits */
while (field->num_bits>bitq_in_bufsize*8) bitq_in_bufsize*=2;
}
/* if necessary, allocate buffer and check for malloc error */
if (bitq_in_buffer==NULL && (bitq_in_buffer=malloc(bitq_in_bufsize))==NULL) {
ERROR("malloc error");
exit(-1);
}
in_buff=(void *)bitq_in_buffer;
}
}
/* field scanning */
while (bitq_in_state.bit_pos<field->num_bits) {
if ((tdo=bitq_interface->in())<0) {
#ifdef _DEBUG_JTAG_IO_
DEBUG("bitq in EOF");
#endif
return;
}
if (in_mask==0x01) in_buff[in_idx]=0;
if (tdo) in_buff[in_idx]|=in_mask;
if (in_mask==0x80) {
in_mask=0x01;
in_idx++;
}
else in_mask<<=1;
bitq_in_state.bit_pos++;
}
if (field->in_check_value) {
/* match scanned in value */
for (in_idx=0; in_idx*8<field->num_bits; in_idx++) {
if (field->in_check_mask) in_mask=field->in_check_mask[in_idx];
else in_mask=0xff;
if (field->num_bits-in_idx*8<8) in_mask>>=8-(field->num_bits-in_idx*8);
if (field->in_check_value[in_idx]&in_mask!=in_buff[in_idx]&in_mask) {
char *captured_char = buf_to_str(in_buff, (field->num_bits > 64) ? 64 : field->num_bits, 16);
char *in_check_value_char = buf_to_str(field->in_check_value, (field->num_bits > 64) ? 64 : field->num_bits, 16);
char *in_check_mask_char = buf_to_str(field->in_check_mask, (field->num_bits > 64) ? 64 : field->num_bits, 16);
/* TODO: error reporting */
WARNING("value captured during scan didn't pass the requested check: captured: 0x%s check_value: 0x%s check_mask: 0x%s", captured_char, in_check_value_char, in_check_mask_char);
bitq_in_state.status=ERROR_JTAG_QUEUE_FAILED;
free(captured_char);
free(in_check_value_char);
free(in_check_mask_char);
break; /* leave the comparison loop upon first mismatch */
}
}
}
if (field->in_handler && bitq_in_state.status==ERROR_OK) {
bitq_in_state.status=(*field->in_handler)(in_buff, field->in_handler_priv);
}
}
bitq_in_state.field_idx++; /* advance to next field */
bitq_in_state.bit_pos=0; /* start next field from the first bit */
}
}
bitq_in_state.cmd=bitq_in_state.cmd->next; /* advance to next command */
bitq_in_state.field_idx=0; /* preselect first field */
}
}
void bitq_io(int tms, int tdi, int tdo_req)
{
bitq_interface->out(tms, tdi, tdo_req);
/* check and process the input queue */
if (bitq_interface->in_rdy()) bitq_in_proc();
}
void bitq_end_state(enum tap_state state)
{
if (state==-1) return;
if (tap_move_map[state]==-1) {
ERROR("BUG: %i is not a valid end state", state);
exit(-1);
}
end_state = state;
}
void bitq_state_move(enum tap_state new_state)
{
int i=0;
u8 tms_scan;
if (tap_move_map[cur_state]==-1 || tap_move_map[new_state]==-1) {
ERROR("TAP move from or to unstable state");
exit(-1);
}
tms_scan=TAP_MOVE(cur_state, new_state);
for (i=0; i<7; i++) {
bitq_io(tms_scan&1, 0, 0);
tms_scan>>=1;
}
cur_state = new_state;
}
void bitq_path_move(pathmove_command_t *cmd)
{
int i;
for (i=0; i<=cmd->num_states; i++) {
if (tap_transitions[cur_state].low == cmd->path[i]) bitq_io(0, 0, 0);
else if (tap_transitions[cur_state].high == cmd->path[i]) bitq_io(1, 0, 0);
else {
ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[i]]);
exit(-1);
}
cur_state = cmd->path[i];
}
end_state = cur_state;
}
void bitq_runtest(int num_cycles)
{
int i;
/* only do a state_move when we're not already in RTI */
if (cur_state != TAP_RTI) bitq_state_move(TAP_RTI);
/* execute num_cycles */
for (i = 0; i < num_cycles; i++)
bitq_io(0, 0, 0);
/* finish in end_state */
if (cur_state != end_state) bitq_state_move(end_state);
}
void bitq_scan_field(scan_field_t *field, int pause)
{
int bit_cnt;
int tdo_req;
u8 *out_ptr;
u8 out_mask;
if (field->in_check_value || field->in_value || field->in_handler) tdo_req=1;
else tdo_req=0;
if (field->out_value==NULL) {
/* just send zeros and request data from TDO */
for (bit_cnt=field->num_bits; bit_cnt>1; bit_cnt--)
bitq_io(0, 0, tdo_req);
bitq_io(pause, 0, tdo_req);
}
else {
/* send data, and optionally request TDO */
out_mask=0x01;
out_ptr=field->out_value;
for (bit_cnt=field->num_bits; bit_cnt>1; bit_cnt--) {
bitq_io(0, ((*out_ptr)&out_mask)!=0, tdo_req);
if (out_mask==0x80) {
out_mask=0x01;
out_ptr++;
}
else out_mask<<=1;
}
bitq_io(pause, ((*out_ptr)&out_mask)!=0, tdo_req);
}
if (pause) {
bitq_io(0,0,0);
if (cur_state==TAP_SI) cur_state=TAP_PI;
else if (cur_state==TAP_SD) cur_state=TAP_PD;
}
}
void bitq_scan(scan_command_t *cmd)
{
int i;
if (cmd->ir_scan) bitq_state_move(TAP_SI);
else bitq_state_move(TAP_SD);
for (i=0; i < cmd->num_fields-1; i++)
bitq_scan_field(&cmd->fields[i], 0);
bitq_scan_field(&cmd->fields[i], 1);
}
int bitq_execute_queue(void)
{
jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
bitq_in_state.cmd = jtag_command_queue;
bitq_in_state.field_idx = 0;
bitq_in_state.bit_pos = 0;
bitq_in_state.status = ERROR_OK;
while (cmd) {
switch (cmd->type) {
case JTAG_END_STATE:
#ifdef _DEBUG_JTAG_IO_
DEBUG("end_state: %i", cmd->cmd.end_state->end_state);
#endif
bitq_end_state(cmd->cmd.end_state->end_state);
break;
case JTAG_RESET:
#ifdef _DEBUG_JTAG_IO_
DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
#endif
bitq_interface->reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
if (bitq_interface->in_rdy()) bitq_in_proc();
break;
case JTAG_RUNTEST:
#ifdef _DEBUG_JTAG_IO_
DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
#endif
bitq_end_state(cmd->cmd.runtest->end_state);
bitq_runtest(cmd->cmd.runtest->num_cycles);
break;
case JTAG_STATEMOVE:
#ifdef _DEBUG_JTAG_IO_
DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
#endif
bitq_end_state(cmd->cmd.statemove->end_state);
bitq_state_move(end_state); /* uncoditional TAP move */
break;
case JTAG_PATHMOVE:
#ifdef _DEBUG_JTAG_IO_
DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
#endif
bitq_path_move(cmd->cmd.pathmove);
break;
case JTAG_SCAN:
#ifdef _DEBUG_JTAG_IO_
DEBUG("scan end in %i", cmd->cmd.scan->end_state);
if (cmd->cmd.scan->ir_scan) DEBUG("scan ir");
else DEBUG("scan dr");
#endif
bitq_end_state(cmd->cmd.scan->end_state);
bitq_scan(cmd->cmd.scan);
if (cur_state != end_state) bitq_state_move(end_state);
break;
case JTAG_SLEEP:
#ifdef _DEBUG_JTAG_IO_
DEBUG("sleep %i", cmd->cmd.sleep->us);
#endif
bitq_interface->sleep(cmd->cmd.sleep->us);
if (bitq_interface->in_rdy()) bitq_in_proc();
break;
default:
ERROR("BUG: unknown JTAG command type encountered");
exit(-1);
}
cmd = cmd->next;
}
bitq_interface->flush();
bitq_in_proc();
if (bitq_in_state.cmd) {
ERROR("missing data from bitq interface");
return ERROR_JTAG_QUEUE_FAILED;
}
if (bitq_interface->in()>=0) {
ERROR("extra data from bitq interface");
return ERROR_JTAG_QUEUE_FAILED;
}
return bitq_in_state.status;
}
void bitq_cleanup(void)
{
if (bitq_in_buffer!=NULL)
{
free(bitq_in_buffer);
bitq_in_buffer=NULL;
}
}

57
src/jtag/bitq.h Normal file
View File

@ -0,0 +1,57 @@
/***************************************************************************
* Copyright (C) 2007 by Pavel Chromy *
* chromy@asix.cz *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef BITQ_H
#define BITQ_H
#include "jtag.h"
typedef struct bitq_interface_s
{
/* functions enqueueing low level IO requests
*/
int (*out)(int tms, int tdi, int tdo_req);
int (*flush)(void);
int (*sleep)(unsigned long us);
int (*reset)(int trst, int srst);
/* delayed read of requested TDO data,
* the input shall be checked after call to any enqueuing function
*/
int (*in_rdy)(void);
int (*in)(void);
} bitq_interface_t;
typedef struct bitq_state_s
{
jtag_command_t *cmd; /* command currently processed */
int field_idx; /* index of field currently being processed */
int bit_pos; /* position of bit curently being processed */
int status; /* processing status */
} bitq_state_t;
extern bitq_interface_t *bitq_interface;
extern int bitq_execute_queue(void);
extern void bitq_cleanup(void);
#endif /* BITQ_H */

14
src/jtag/jtag.c
View File

@ -162,6 +162,14 @@ jtag_event_callback_t *jtag_event_callbacks;
extern jtag_interface_t gw16012_interface;
#endif
#if BUILD_PRESTO == 1
extern jtag_interface_t presto_interface;
#endif
#if BUILD_USBPROG == 1
extern jtag_interface_t usbprog_interface;
#endif
jtag_interface_t *jtag_interfaces[] = {
#if BUILD_PARPORT == 1
&parport_interface,
@ -183,6 +191,12 @@ jtag_interface_t *jtag_interfaces[] = {
#endif
#if BUILD_GW16012 == 1
&gw16012_interface,
#endif
#if BUILD_PRESTO == 1
&presto_interface,
#endif
#if BUILD_USBPROG == 1
&usbprog_interface,
#endif
NULL,
};

2
src/jtag/jtag.h
View File

@ -25,7 +25,7 @@
#include "command.h"
#if 0
#if 1
#define _DEBUG_JTAG_IO_
#endif

500
src/jtag/presto.c Normal file
View File

@ -0,0 +1,500 @@
/***************************************************************************
* Copyright (C) 2007 by Pavel Chromy *
* chromy@asix.cz *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#if IS_CYGWIN == 1
#include "windows.h"
#undef ERROR
#endif
#include "replacements.h"
/* project specific includes */
#include "log.h"
#include "types.h"
#include "jtag.h"
#include "configuration.h"
#include "time_support.h"
#include "bitq.h"
/* system includes */
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <sys/time.h>
#include <time.h>
#include "ftd2xx.h"
int presto_jtag_speed(int speed);
int presto_jtag_register_commands(struct command_context_s *cmd_ctx);
int presto_jtag_init(void);
int presto_jtag_quit(void);
jtag_interface_t presto_interface =
{
.name = "presto",
.execute_queue = bitq_execute_queue,
.support_pathmove = 1,
.speed = presto_jtag_speed,
.register_commands = presto_jtag_register_commands,
.init = presto_jtag_init,
.quit = presto_jtag_quit,
};
int presto_bitq_out(int tms, int tdi, int tdo_req);
int presto_bitq_flush(void);
int presto_bitq_sleep(unsigned long us);
int presto_bitq_reset(int rst, int en);
int presto_bitq_in_rdy(void);
int presto_bitq_in(void);
bitq_interface_t presto_bitq =
{
.out = presto_bitq_out,
.flush = presto_bitq_flush,
.sleep = presto_bitq_sleep,
.reset = presto_bitq_reset,
.in_rdy = presto_bitq_in_rdy,
.in = presto_bitq_in,
};
/* -------------------------------------------------------------------------- */
#define FT_DEVICE_NAME_LEN 64
#define FT_DEVICE_SERNUM_LEN 64
#define PRESTO_VID_PID 0x0403f1a0
#define PRST_OK 0
#define PRST_ERR 1
#define PRST_TIMEOUT 2
#define BUFFER_SIZE (64*62)
typedef struct presto_s
{
FT_HANDLE handle;
FT_STATUS status;
char serial[FT_DEVICE_SERNUM_LEN];
BYTE buff_out[BUFFER_SIZE];
int buff_out_pos;
BYTE buff_in[BUFFER_SIZE];
int buff_in_exp; /* expected in buffer length */
int buff_in_len; /* length of data received */
int buff_in_pos;
unsigned long total_out;
unsigned long total_in;
int jtag_tms; /* last tms state */
int jtag_tck; /* last tck state */
int jtag_tdi_data;
int jtag_tdi_count;
} presto_t;
presto_t presto_state;
presto_t *presto=&presto_state;
BYTE presto_init_seq[] =
{
0x80, 0xA0, 0xA8, 0xB0, 0xC0, 0xE0
};
int presto_open(char *req_serial)
{
int i;
int result;
DWORD numdevs;
DWORD vidpid;
char devname[FT_DEVICE_NAME_LEN];
FT_DEVICE device;
BYTE presto_data;
unsigned long ftbytes;
presto->handle=INVALID_HANDLE_VALUE;
presto->buff_out_pos=0;
presto->buff_in_pos=0;
presto->buff_in_len=0;
presto->buff_in_exp=0;
presto->total_out=0;
presto->total_in=0;
presto->jtag_tms=0;
presto->jtag_tck=0;
presto->jtag_tdi_data=0;
presto->jtag_tdi_count=0;
if (FT_ListDevices(&numdevs, NULL, FT_LIST_NUMBER_ONLY)!=FT_OK) return PRST_ERR;
for (i=0; i<numdevs; i++)
{
if (FT_Open(i, &(presto->handle))!=FT_OK) continue;
if (FT_GetDeviceInfo(presto->handle,&device,&vidpid,presto->serial,devname,NULL)==FT_OK)
{
if (vidpid==PRESTO_VID_PID && (req_serial==NULL || !strcmp(presto->serial,req_serial)))
break;
}
FT_Close(presto->handle);
presto->handle=INVALID_HANDLE_VALUE;
}
if (presto->handle==INVALID_HANDLE_VALUE) return PRST_ERR;
if ((presto->status=FT_SetLatencyTimer(presto->handle,1))!=FT_OK) return PRST_ERR;
if ((presto->status=FT_SetTimeouts(presto->handle,100,0))!=FT_OK) return PRST_ERR;
if ((presto->status=FT_Purge(presto->handle, FT_PURGE_TX|FT_PURGE_RX))!=FT_OK) return PRST_ERR;
presto_data=0xD0;
if ((presto->status=FT_Write(presto->handle,&presto_data,1,&ftbytes))!=FT_OK) return PRST_ERR;
if ((presto->status=FT_Read(presto->handle,&presto_data,1,&ftbytes))!=FT_OK) return PRST_ERR;
if (ftbytes!=1)
{
if ((presto->status=FT_SetBitMode(presto->handle,0x80,1))!=FT_OK) return PRST_ERR;
if ((presto->status=FT_Purge(presto->handle, FT_PURGE_TX|FT_PURGE_RX))!=FT_OK) return PRST_ERR ;
if ((presto->status=FT_SetBaudRate(presto->handle,9600))!=FT_OK) return PRST_ERR;
presto_data=0;
for (i=0; i<4*62; i++)
if ((presto->status=FT_Write(presto->handle,&presto_data,1,&ftbytes))!=FT_OK) return PRST_ERR;
usleep(100000);
if ((presto->status=FT_SetBitMode(presto->handle,0x00,0))!=FT_OK) return PRST_ERR;
if ((presto->status=FT_Purge(presto->handle, FT_PURGE_TX|FT_PURGE_RX))!=FT_OK) return PRST_ERR;
presto_data=0xD0;
if ((presto->status=FT_Write(presto->handle,&presto_data,1,&ftbytes))!=FT_OK) return PRST_ERR;
if ((presto->status=FT_Read(presto->handle,&presto_data,1,&ftbytes))!=FT_OK) return PRST_ERR;
if (ftbytes!=1) return PRST_ERR;
}
if ((presto->status=FT_SetTimeouts(presto->handle,0,0))!=FT_OK) return PRST_ERR;
presto->status=FT_Write(presto->handle,&presto_init_seq,sizeof(presto_init_seq),&ftbytes);
if (presto->status!=FT_OK) return PRST_ERR;
if (ftbytes!=sizeof(presto_init_seq)) return PRST_TIMEOUT;
return PRST_OK;
}
int presto_close(void)
{
unsigned long ftbytes;
int result=PRST_OK;
if (presto->handle==INVALID_HANDLE_VALUE) return result;
presto->status=FT_Write(presto->handle,&presto_init_seq,sizeof(presto_init_seq),&ftbytes);
if (presto->status!=FT_OK) result=PRST_ERR;
if (ftbytes!=sizeof(presto_init_seq)) result=PRST_TIMEOUT;
if ((presto->status=FT_SetLatencyTimer(presto->handle,16))!=FT_OK) result=PRST_ERR;
if ((presto->status=FT_Close(presto->handle))!=FT_OK) result=PRST_ERR;
else presto->handle=INVALID_HANDLE_VALUE;
return result;
}
int presto_flush(void)
{
unsigned long ftbytes;
if (presto->buff_out_pos==0) return PRST_OK;
if (presto->status!=FT_OK) return PRST_ERR;
if ((presto->status=FT_Write(presto->handle, presto->buff_out, presto->buff_out_pos, &ftbytes))!=FT_OK)
{
presto->buff_out_pos=0;
return PRST_ERR;
}
presto->total_out+=ftbytes;
if (presto->buff_out_pos!=ftbytes)
{
presto->buff_out_pos=0;
return PRST_TIMEOUT;
}
presto->buff_out_pos=0;
if (presto->buff_in_exp==0) return PRST_OK;
presto->buff_in_pos=0;
presto->buff_in_len=0;
if ((presto->status=FT_Read(presto->handle, presto->buff_in, presto->buff_in_exp, &ftbytes))!=FT_OK)
{
presto->buff_in_exp=0;
return PRST_ERR;
}
presto->total_in+=ftbytes;
if (ftbytes!=presto->buff_in_exp)
{
presto->buff_in_exp=0;
return PRST_TIMEOUT;
}
presto->buff_in_len=presto->buff_in_exp;
presto->buff_in_exp=0;
return PRST_OK;
}
int presto_sendbyte(int data)
{
if (data==EOF) return presto_flush();
if (presto->buff_out_pos < BUFFER_SIZE)
{
presto->buff_out[presto->buff_out_pos++]=(BYTE)data;
if (((data&0xC0)==0x40) || ((data&0xD0)==0xD0))
presto->buff_in_exp++;
}
else return PRST_ERR;
if (presto->buff_out_pos >= BUFFER_SIZE) return presto_flush();
return PRST_OK;
}
int presto_getbyte(void)
{
if (presto->buff_in_pos<presto->buff_in_len)
return presto->buff_in[presto->buff_in_pos++];
if (presto->buff_in_exp==0) return -1;
if (presto_flush()!=PRST_OK) return -1;
if (presto->buff_in_pos<presto->buff_in_len)
return presto->buff_in[presto->buff_in_pos++];
return -1;
}
/* -------------------------------------------------------------------------- */
int presto_bitq_out(int tms, int tdi, int tdo_req)
{
unsigned char cmdparam;
if (presto->jtag_tck==0)
{
presto_sendbyte(0xA4);
presto->jtag_tck=1;
}
else if (!tdo_req && tms==presto->jtag_tms)
{
if (presto->jtag_tdi_count==0) presto->jtag_tdi_data=(tdi!=0);
else presto->jtag_tdi_data|=(tdi!=0)<<presto->jtag_tdi_count;
if (++presto->jtag_tdi_count==4)
{
presto->jtag_tdi_data|=(presto->jtag_tdi_count-1)<<4;
presto_sendbyte(presto->jtag_tdi_data);
presto->jtag_tdi_count=0;
}
return 0;
}
if (presto->jtag_tdi_count)
{
presto->jtag_tdi_data|=(presto->jtag_tdi_count-1)<<4;
presto_sendbyte(presto->jtag_tdi_data);
presto->jtag_tdi_count=0;
}
if (tdi) cmdparam=0x0B;
else cmdparam=0x0A;
presto_sendbyte(0xC0|cmdparam);
if (tms!=presto->jtag_tms)
{
if (tms) presto_sendbyte(0xEC);
else presto_sendbyte(0xE8);
presto->jtag_tms=tms;
}
if (tdo_req) presto_sendbyte(0xD4|cmdparam);
else presto_sendbyte(0xC4|cmdparam);
return 0;
}
int presto_bitq_flush(void)
{
if (presto->jtag_tdi_count)
{
presto->jtag_tdi_data|=(presto->jtag_tdi_count-1)<<4;
presto_sendbyte(presto->jtag_tdi_data);
presto->jtag_tdi_count=0;
}
presto_sendbyte(0xCA);
presto->jtag_tck=0;
presto_sendbyte(0xA0);
return presto_flush();
}
int presto_bitq_in_rdy(void)
{
if (presto->buff_in_pos>=presto->buff_in_len) return 0;
return presto->buff_in_len-presto->buff_in_pos;
}
int presto_bitq_in(void)
{
if (presto->buff_in_pos>=presto->buff_in_len) return -1;
if (presto->buff_in[presto->buff_in_pos++]&0x08) return 1;
return 0;
}
int presto_bitq_sleep(unsigned long us)
{
long waits;
if (us>100000)
{
presto_bitq_flush();
jtag_sleep(us);
return 0;
}
waits=us/170+2;
while (waits--) presto_sendbyte(0x80);
return 0;
}
int presto_bitq_reset(int trst, int srst)
{
unsigned char cmd;
cmd=0xE8;
if (presto->jtag_tms) cmd|=0x04;
if (trst || srst) cmd|=0x02;
presto_sendbyte(cmd);
return 0;
}
/* -------------------------------------------------------------------------- */
int presto_jtag_speed(int speed)
{
jtag_speed=speed;
return ERROR_OK;
}
char *presto_serial;
int presto_handle_serial_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
if (argc == 1)
{
if (presto_serial) free(presto_serial);
presto_serial = strdup(args[0]);
}
else
{
ERROR("expected exactly one argument to presto_serial <serial-number>");
}
return ERROR_OK;
}
int presto_jtag_register_commands(struct command_context_s *cmd_ctx)
{
register_command(cmd_ctx, NULL, "presto_serial", presto_handle_serial_command,
COMMAND_CONFIG, NULL);
return ERROR_OK;
}
int presto_jtag_init(void)
{
if (presto_open(presto_serial)!=0)
{
presto_close();
if (presto_serial!=NULL) ERROR("Cannot open PRESTO, serial number %s", presto_serial);
else ERROR("Cannot open PRESTO");
return ERROR_JTAG_INIT_FAILED;
}
INFO("PRESTO open, serial number %s", presto->serial);
bitq_interface=&presto_bitq;
return ERROR_OK;
}
int presto_jtag_quit(void)
{
bitq_cleanup();
presto_close();
INFO("PRESTO closed");
if (presto_serial)
{
free(presto_serial);
presto_serial=NULL;
}
return ERROR_OK;
}

632
src/jtag/usbprog.c Normal file
View File

@ -0,0 +1,632 @@
/***************************************************************************
* Copyright (C) 2007 by Benedikt Sauter sauter@ixbat.de *
* based on Dominic Rath's usbprog.c *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include "replacements.h"
#include "jtag.h"
#include <usb.h>
/* system includes */
#include "log.h"
#define VID 0x1781
#define PID 0x0c62
int usbprog_execute_queue(void);
int usbprog_speed(int speed);
int usbprog_register_commands(struct command_context_s *cmd_ctx);
int usbprog_init(void);
int usbprog_quit(void);
void usbprog_end_state(enum tap_state state);
void usbprog_state_move(void);
void usbprog_path_move(pathmove_command_t *cmd);
void usbprog_runtest(int num_cycles);
void usbprog_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size);
jtag_interface_t usbprog_interface =
{
.name = "usbprog",
.execute_queue = usbprog_execute_queue,
.support_pathmove = 0,
.speed = usbprog_speed,
.register_commands = usbprog_register_commands,
.init = usbprog_init,
.quit = usbprog_quit
};
// pins from avr
#define TDO_BIT 0
#define TDI_BIT 3
#define TCK_BIT 2
#define TMS_BIT 1
#define UNKOWN_COMMAND 0x00
#define PORT_DIRECTION 0x01
#define PORT_SET 0x02
#define PORT_GET 0x03
#define PORT_SETBIT 0x04
#define PORT_GETBIT 0x05
#define WRITE_TDI 0x06
#define READ_TDO 0x07
#define WRITE_AND_READ 0x08
#define WRITE_TMS 0x09
struct usbprog_jtag
{
struct usb_dev_handle* usb_handle;
};
struct usbprog_jtag * usbprog_jtag_handle;
struct usbprog_jtag* usbprog_jtag_open();
void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag);
void usbprog_jtag_init(struct usbprog_jtag *usbprog_jtag);
unsigned char usbprog_jtag_message(struct usbprog_jtag *usbprog_jtag, char *msg, int msglen);
void usbprog_jtag_read_tdo(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
void usbprog_jtag_write_tdi(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
void usbprog_jtag_write_and_read(struct usbprog_jtag *usbprog_jtag, char * buffer, int size);
void usbprog_jtag_write_tms(struct usbprog_jtag *usbprog_jtag, char tms_scan);
void usbprog_write(int tck, int tms, int tdi);
void usbprog_reset(int trst, int srst);
void usbprog_jtag_set_direction(struct usbprog_jtag *usbprog_jtag, unsigned char direction);
void usbprog_jtag_write_slice(struct usbprog_jtag *usbprog_jtag,unsigned char value);
unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag);
void usbprog_jtag_set_bit(struct usbprog_jtag *usbprog_jtag,int bit, int value);
int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit);
int usbprog_speed(int speed)
{
return ERROR_OK;
}
int usbprog_register_commands(struct command_context_s *cmd_ctx)
{
return ERROR_OK;
}
int usbprog_execute_queue(void)
{
jtag_command_t *cmd = jtag_command_queue; /* currently processed command */
int scan_size;
enum scan_type type;
u8 *buffer;
while (cmd)
{
switch (cmd->type)
{
case JTAG_END_STATE:
#ifdef _DEBUG_JTAG_IO_
DEBUG("end_state: %i", cmd->cmd.end_state->end_state);
#endif
if (cmd->cmd.end_state->end_state != -1)
usbprog_end_state(cmd->cmd.end_state->end_state);
break;
case JTAG_RESET:
#ifdef _DEBUG_JTAG_IO_
DEBUG("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst);
#endif
if (cmd->cmd.reset->trst == 1)
{
cur_state = TAP_TLR;
}
usbprog_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst);
break;
case JTAG_RUNTEST:
#ifdef _DEBUG_JTAG_IO_
DEBUG("runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, cmd->cmd.runtest->end_state);
#endif
if (cmd->cmd.runtest->end_state != -1)
usbprog_end_state(cmd->cmd.runtest->end_state);
usbprog_runtest(cmd->cmd.runtest->num_cycles);
break;
case JTAG_STATEMOVE:
#ifdef _DEBUG_JTAG_IO_
DEBUG("statemove end in %i", cmd->cmd.statemove->end_state);
#endif
if (cmd->cmd.statemove->end_state != -1)
usbprog_end_state(cmd->cmd.statemove->end_state);
usbprog_state_move();
break;
case JTAG_PATHMOVE:
#ifdef _DEBUG_JTAG_IO_
DEBUG("pathmove: %i states, end in %i", cmd->cmd.pathmove->num_states,
cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]);
#endif
usbprog_path_move(cmd->cmd.pathmove);
break;
case JTAG_SCAN:
#ifdef _DEBUG_JTAG_IO_
DEBUG("scan end in %i", cmd->cmd.scan->end_state);
#endif
if (cmd->cmd.scan->end_state != -1)
usbprog_end_state(cmd->cmd.scan->end_state);
scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer);
type = jtag_scan_type(cmd->cmd.scan);
usbprog_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size);
if (jtag_read_buffer(buffer, cmd->cmd.scan) != ERROR_OK)
return ERROR_JTAG_QUEUE_FAILED;
if (buffer)
free(buffer);
break;
case JTAG_SLEEP:
#ifdef _DEBUG_JTAG_IO_
DEBUG("sleep %i", cmd->cmd.sleep->us);
#endif
jtag_sleep(cmd->cmd.sleep->us);
break;
default:
ERROR("BUG: unknown JTAG command type encountered");
exit(-1);
}
cmd = cmd->next;
}
return ERROR_OK;
}
int usbprog_init(void)
{
usbprog_jtag_handle = usbprog_jtag_open();
if(usbprog_jtag_handle==0){
ERROR("Can't find USB JTAG Interface! Please check connection and permissions.");
return ERROR_JTAG_INIT_FAILED;
}
INFO("USB JTAG Interface ready!");
usbprog_jtag_init(usbprog_jtag_handle);
usbprog_reset(0, 0);
usbprog_write(0, 0, 0);
return ERROR_OK;
}
int usbprog_quit(void)
{
return ERROR_OK;
}
/*************** jtag execute commands **********************/
void usbprog_end_state(enum tap_state state)
{
if (tap_move_map[state] != -1)
end_state = state;
else
{
ERROR("BUG: %i is not a valid end state", state);
exit(-1);
}
}
void usbprog_state_move(void) {
int i=0, tms=0;
u8 tms_scan = TAP_MOVE(cur_state, end_state);
usbprog_jtag_write_tms(usbprog_jtag_handle,(char)tms_scan);
for (i = 0; i < 7; i++)
{
tms = (tms_scan >> i) & 1;
}
// moved into firmware
// INFO("4");
// koennte man in tms verlagern
//usbprog_write(0, tms, 0);
cur_state = end_state;
}
void usbprog_path_move(pathmove_command_t *cmd)
{
int num_states = cmd->num_states;
int state_count;
state_count = 0;
while (num_states)
{
if (tap_transitions[cur_state].low == cmd->path[state_count])
{
INFO("1");
usbprog_write(0, 0, 0);
usbprog_write(1, 0, 0);
}
else if (tap_transitions[cur_state].high == cmd->path[state_count])
{
INFO("2");
usbprog_write(0, 1, 0);
usbprog_write(1, 1, 0);
}
else
{
ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_strings[cur_state], tap_state_strings[cmd->path[state_count]]);
exit(-1);
}
cur_state = cmd->path[state_count];
state_count++;
num_states--;
}
end_state = cur_state;
}
void usbprog_runtest(int num_cycles)
{
int i;
enum tap_state saved_end_state = end_state;
/* only do a state_move when we're not already in RTI */
if (cur_state != TAP_RTI)
{
usbprog_end_state(TAP_RTI);
//INFO("6");
usbprog_state_move();
}
/* execute num_cycles */
if(num_cycles>0)
{
INFO("5");
usbprog_write(0, 0, 0);
}
for (i = 0; i < num_cycles; i++)
{
INFO("3");
usbprog_write(1, 0, 0);
usbprog_write(0, 0, 0);
}
/* finish in end_state */
/*
usbprog_end_state(saved_end_state);
if (cur_state != end_state)
usbprog_state_move();
*/
}
void usbprog_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size)
{
enum tap_state saved_end_state = end_state;
int bit_cnt;
if (ir_scan)
usbprog_end_state(TAP_SI);
else
usbprog_end_state(TAP_SD);
//INFO("7");
usbprog_state_move();
usbprog_end_state(saved_end_state);
if (type == SCAN_OUT) {
usbprog_jtag_write_tdi(usbprog_jtag_handle,buffer, scan_size);
}
if (type == SCAN_IN) {
usbprog_jtag_read_tdo(usbprog_jtag_handle,buffer, scan_size);
}
if (type == SCAN_IO) {
usbprog_jtag_write_and_read(usbprog_jtag_handle,buffer, scan_size);
}
if (ir_scan)
cur_state = TAP_PI;
else
cur_state = TAP_PD;
if (cur_state != end_state)
usbprog_state_move();
}
/*************** jtag wrapper functions *********************/
void usbprog_write(int tck, int tms, int tdi)
{
//INFO("->USBPROG SLICE");
//DEBUG("slice tck %i tms %i tdi %i",tck,tms,tdi);
unsigned char output_value=0x00;
if (tms)
output_value |= (1<<TMS_BIT);
if (tdi)
output_value |= (1<<TDI_BIT);
if (tck)
output_value |= (1<<TCK_BIT);
usbprog_jtag_write_slice(usbprog_jtag_handle,output_value);
}
/* (1) assert or (0) deassert reset lines */
void usbprog_reset(int trst, int srst)
{
//INFO("->USBPROG RESET");
DEBUG("trst: %i, srst: %i", trst, srst);
if(trst)
usbprog_jtag_set_bit(usbprog_jtag_handle,5,0);
else
usbprog_jtag_set_bit(usbprog_jtag_handle,5,1);
if(srst)
usbprog_jtag_set_bit(usbprog_jtag_handle,4,0);
else
usbprog_jtag_set_bit(usbprog_jtag_handle,4,1);
}
/*************** jtag lowlevel functions ********************/
struct usbprog_jtag* usbprog_jtag_open()
{
struct usb_bus *busses;
struct usb_dev_handle* usb_handle;
struct usb_bus *bus;
struct usb_device *dev;
struct usbprog_jtag * tmp;
tmp = (struct usbprog_jtag*)malloc(sizeof(struct usbprog_jtag));
usb_init();
usb_find_busses();
usb_find_devices();
busses = usb_get_busses();
/* find usbprog_jtag device in usb bus */
for (bus = busses; bus; bus = bus->next){
for (dev = bus->devices; dev; dev = dev->next){
/* condition for sucessfully hit (too bad, I only check the vendor id)*/
if (dev->descriptor.idVendor == VID && dev->descriptor.idProduct == PID) {
tmp->usb_handle = usb_open(dev);
usb_set_configuration (tmp->usb_handle,dev->config[0].bConfigurationValue);
usb_claim_interface(tmp->usb_handle, 0);
usb_set_altinterface(tmp->usb_handle,0);
return tmp;
}
}
}
return 0;
}
void usbprog_jtag_close(struct usbprog_jtag *usbprog_jtag)
{
usb_close(usbprog_jtag->usb_handle);
free(usbprog_jtag);
}
unsigned char usbprog_jtag_message(struct usbprog_jtag *usbprog_jtag, char *msg, int msglen)
{
int res = usb_bulk_write(usbprog_jtag->usb_handle,3,msg,msglen,100);
if(msg[0]==2)
return 1;
if(res == msglen) {
res = usb_bulk_read(usbprog_jtag->usb_handle,0x82, msg, 2, 100);
if (res > 0)
return (unsigned char)msg[1];
else
return -1;
}
else
return -1;
return 0;
}
void usbprog_jtag_init(struct usbprog_jtag *usbprog_jtag)
{
usbprog_jtag_set_direction(usbprog_jtag, 0xFE);
}
void usbprog_jtag_write_and_read(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
{
char tmp[64]; // fastes packet size for usb controller
int send_bits,bufindex=0,fillindex=0,i,j,complete=size,loops;
char swap;
// 61 byte can be transfered (488 bit)
while(size > 0) {
if(size > 488) {
send_bits = 488;
size = size - 488;
loops = 61;
} else {
send_bits = size;
loops = size/8;
loops++;
size = 0;
}
tmp[0] = WRITE_AND_READ;
tmp[1] = (char)(send_bits>>8); // high
tmp[2] = (char)(send_bits); // low
i=0;
for(i=0;i < loops ;i++) {
tmp[3+i]=buffer[bufindex];
bufindex++;
}
usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,64,1000);
while(usb_bulk_read(usbprog_jtag->usb_handle,0x82, tmp, 64, 1000) < 1);
for(i=0;i<loops ;i++) {
swap = tmp[3+i];
buffer[fillindex++] = swap;
}
}
}
void usbprog_jtag_read_tdo(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
{
char tmp[64]; // fastes packet size for usb controller
int send_bits,bufindex=0,fillindex=0,i,j,complete=size,loops;
char swap;
// 61 byte can be transfered (488 bit)
while(size > 0) {
if(size > 488) {
send_bits = 488;
size = size - 488;
loops = 61;
} else {
send_bits = size;
loops = size/8;
loops++;
size = 0;
}
tmp[0] = WRITE_AND_READ;
tmp[1] = (char)(send_bits>>8); // high
tmp[2] = (char)(send_bits); // low
usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,3,1000);
while(usb_bulk_read(usbprog_jtag->usb_handle,0x82, tmp, 64, 10) < 1);
for(i=0;i<loops ;i++) {
swap = tmp[3+i];
buffer[fillindex++] = swap;
}
}
}
void usbprog_jtag_write_tdi(struct usbprog_jtag *usbprog_jtag, char * buffer, int size)
{
char tmp[64]; // fastes packet size for usb controller
int send_bits,bufindex=0,fillindex=0,i,j,complete=size,loops;
char swap;
// 61 byte can be transfered (488 bit)
while(size > 0) {
if(size > 488) {
send_bits = 488;
size = size - 488;
loops = 61;
} else {
send_bits = size;
loops = size/8;
//if(loops==0)
loops++;
size = 0;
}
tmp[0] = WRITE_TDI;
tmp[1] = (char)(send_bits>>8); // high
tmp[2] = (char)(send_bits); // low
i=0;
for(i=0;i < loops ;i++) {
tmp[3+i]=buffer[bufindex];
bufindex++;
}
usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,64,1000);
}
}
void usbprog_jtag_write_tms(struct usbprog_jtag *usbprog_jtag, char tms_scan)
{
char tmp[2]; // fastes packet size for usb controller
tmp[0] = WRITE_TMS;
tmp[1] = tms_scan;
usb_bulk_write(usbprog_jtag->usb_handle,3,tmp,2,1000);
}
void usbprog_jtag_set_direction(struct usbprog_jtag *usbprog_jtag, unsigned char direction)
{
char tmp[2];
tmp[0] = PORT_DIRECTION;
tmp[1] = (char)direction;
usbprog_jtag_message(usbprog_jtag,tmp,2);
}
void usbprog_jtag_write_slice(struct usbprog_jtag *usbprog_jtag,unsigned char value)
{
char tmp[2];
tmp[0] = PORT_SET;
tmp[1] = (char)value;
usbprog_jtag_message(usbprog_jtag,tmp,2);
}
unsigned char usbprog_jtag_get_port(struct usbprog_jtag *usbprog_jtag)
{
char tmp[2];
tmp[0] = PORT_GET;
tmp[1] = 0x00;
return usbprog_jtag_message(usbprog_jtag,tmp,2);
}
void usbprog_jtag_set_bit(struct usbprog_jtag *usbprog_jtag,int bit, int value)
{
char tmp[3];
tmp[0] = PORT_SETBIT;
tmp[1] = (char)bit;
if(value==1)
tmp[2] = 0x01;
else
tmp[2] = 0x00;
usbprog_jtag_message(usbprog_jtag,tmp,3);
}
int usbprog_jtag_get_bit(struct usbprog_jtag *usbprog_jtag, int bit)
{
char tmp[2];
tmp[0] = PORT_GETBIT;
tmp[1] = (char)bit;
if(usbprog_jtag_message(usbprog_jtag,tmp,2)>0)
return 1;
else
return 0;
}

10
src/openocd.c
View File

@ -18,7 +18,7 @@
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#define OPENOCD_VERSION "Open On-Chip Debugger (2007-06-28 12:30 CEST)"
#define OPENOCD_VERSION "Open On-Chip Debugger (2007-07-15 13:15 CEST)"
#ifdef HAVE_CONFIG_H
#include "config.h"
@ -57,6 +57,12 @@ int handle_version_command(struct command_context_s *cmd_ctx, char *cmd, char **
return ERROR_OK;
}
void exit_handler(void)
{
/* close JTAG interface */
if (jtag && jtag->quit) jtag->quit();
}
int main(int argc, char *argv[])
{
/* initialize commandline interface */
@ -99,6 +105,8 @@ int main(int argc, char *argv[])
command_set_output_handler(cmd_ctx, configuration_output_handler, NULL);
atexit(exit_handler);
if (jtag_init(cmd_ctx) != ERROR_OK)
return EXIT_FAILURE;
DEBUG("jtag init complete");

15
src/server/server.c
View File

@ -382,6 +382,12 @@ int server_loop(command_context_t *command_context)
shutdown_openocd = 1;
}
}
#else
MSG msg;
while (PeekMessage(&msg,NULL,0,0,PM_REMOVE))
{
if (msg.message==WM_QUIT) shutdown_openocd = 1;
}
#endif
}
@ -394,6 +400,10 @@ BOOL WINAPI ControlHandler(DWORD dwCtrlType)
shutdown_openocd = 1;
return TRUE;
}
void sig_handler(int sig) {
shutdown_openocd = 1;
}
#endif
int server_init()
@ -411,6 +421,11 @@ int server_init()
}
SetConsoleCtrlHandler( ControlHandler, TRUE );
signal(SIGINT, sig_handler);
signal(SIGTERM, sig_handler);
signal(SIGBREAK, sig_handler);
signal(SIGABRT, sig_handler);
#endif

8
src/target/Makefile.am
View File

@ -3,7 +3,9 @@ METASOURCES = AUTO
noinst_LIBRARIES = libtarget.a
libtarget_a_SOURCES = target.c register.c breakpoints.c armv4_5.c embeddedice.c etm.c arm7tdmi.c arm9tdmi.c \
arm_jtag.c arm7_9_common.c algorithm.c arm920t.c arm720t.c armv4_5_mmu.c armv4_5_cache.c arm_disassembler.c \
arm966e.c arm926ejs.c etb.c xscale.c arm_simulator.c image.c armv7m.c cortex_m3.c cortex_swjdp.c
arm966e.c arm926ejs.c etb.c xscale.c arm_simulator.c image.c armv7m.c cortex_m3.c cortex_swjdp.c \
etm_dummy.c
noinst_HEADERS = target.h register.h armv4_5.h embeddedice.h etm.h arm7tdmi.h arm9tdmi.h \
arm_jtag.h arm7_9_common.h arm920t.h arm720t.h armv4_5_mmu.h armv4_5_cache.h breakpoints.h algorithm.h \
arm_disassembler.h arm966e.h arm926ejs.h etb.h xscale.h arm_simulator.h image.h armv7m.h cortex_m3.h cortex_swjdp.h
arm_jtag.h arm7_9_common.h arm920t.h arm720t.h armv4_5_mmu.h armv4_5_cache.h breakpoints.h algorithm.h \
arm_disassembler.h arm966e.h arm926ejs.h etb.h xscale.h arm_simulator.h image.h armv7m.h cortex_m3.h cortex_swjdp.h \
etm_dummy.h

34
src/target/etm.c
View File

@ -465,10 +465,12 @@ int etm_store_reg(reg_t *reg)
*
*/
extern etm_capture_driver_t etb_capture_driver;
extern etm_capture_driver_t etm_dummy_capture_driver;
etm_capture_driver_t *etm_capture_drivers[] =
{
&etb_capture_driver,
&etm_dummy_capture_driver,
NULL
};
@ -1005,7 +1007,7 @@ int handle_etm_tracemode_command(struct command_context_s *cmd_ctx, char *cmd, c
tracemode = arm7_9->etm_ctx->tracemode;
if (argc == 3)
if (argc == 4)
{
if (strcmp(args[0], "none") == 0)
{
@ -1061,10 +1063,24 @@ int handle_etm_tracemode_command(struct command_context_s *cmd_ctx, char *cmd, c
command_print(cmd_ctx, "invalid option '%s'", args[2]);
return ERROR_OK;
}
if (strcmp(args[3], "enable") == 0)
{
tracemode |= ETMV1_BRANCH_OUTPUT;
}
else if (strcmp(args[3], "disable") == 0)
{
tracemode |= 0;
}
else
{
command_print(cmd_ctx, "invalid option '%s'", args[2]);
return ERROR_OK;
}
}
else if (argc != 0)
{
command_print(cmd_ctx, "usage: configure trace mode <none|data|address|all> <context id bits> <enable|disable cycle accurate>");
command_print(cmd_ctx, "usage: configure trace mode <none|data|address|all> <context id bits> <cycle accurate> <branch output>");
return ERROR_OK;
}
@ -1111,6 +1127,15 @@ int handle_etm_tracemode_command(struct command_context_s *cmd_ctx, char *cmd, c
command_print(cmd_ctx, "cycle-accurate tracing disabled");
}
if (tracemode & ETMV1_BRANCH_OUTPUT)
{
command_print(cmd_ctx, "full branch address output enabled");
}
else
{
command_print(cmd_ctx, "full branch address output disabled");
}
/* only update ETM_CTRL register if tracemode changed */
if (arm7_9->etm_ctx->tracemode != tracemode)
{
@ -1121,7 +1146,7 @@ int handle_etm_tracemode_command(struct command_context_s *cmd_ctx, char *cmd, c
buf_set_u32(etm_ctrl_reg->value, 2, 2, tracemode & ETMV1_TRACE_MASK);
buf_set_u32(etm_ctrl_reg->value, 14, 2, (tracemode & ETMV1_CONTEXTID_MASK) >> 4);
buf_set_u32(etm_ctrl_reg->value, 12, 1, (tracemode & ETMV1_CYCLE_ACCURATE) >> 8);
buf_set_u32(etm_ctrl_reg->value, 8, 1, (tracemode & ETMV1_BRANCH_OUTPUT) >> 9);
etm_store_reg(etm_ctrl_reg);
arm7_9->etm_ctx->tracemode = tracemode;
@ -1317,7 +1342,6 @@ int handle_etm_image_command(struct command_context_s *cmd_ctx, char *cmd, char
armv4_5_common_t *armv4_5;
arm7_9_common_t *arm7_9;
etm_context_t *etm_ctx;
int i;
if (argc < 1)
{
@ -1634,7 +1658,7 @@ int etm_register_commands(struct command_context_s *cmd_ctx)
int etm_register_user_commands(struct command_context_s *cmd_ctx)
{
register_command(cmd_ctx, etm_cmd, "tracemode", handle_etm_tracemode_command,
COMMAND_EXEC, "configure trace mode <none|data|address|all> <context id bits> <enable|disable cycle accurate>");
COMMAND_EXEC, "configure trace mode <none|data|address|all> <context id bits> <cycle accurate> <branch output");
register_command(cmd_ctx, etm_cmd, "status", handle_etm_status_command,
COMMAND_EXEC, "display current target's ETM status");

3
src/target/etm.h
View File

@ -103,7 +103,8 @@ typedef enum
ETMV1_CONTEXTID_32 = 0x30,
ETMV1_CONTEXTID_MASK = 0x30,
/* Misc */
ETMV1_CYCLE_ACCURATE = 0x100
ETMV1_CYCLE_ACCURATE = 0x100,
ETMV1_BRANCH_OUTPUT = 0x200
} etmv1_tracemode_t;
/* forward-declare ETM context */

116
src/target/etm_dummy.c Normal file
View File

@ -0,0 +1,116 @@
/***************************************************************************
* Copyright (C) 2007 by Dominic Rath *
* Dominic.Rath@gmx.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <string.h>
#include "etm_dummy.h"
#include "etm.h"
#include "arm7_9_common.h"
#include "log.h"
#include "types.h"
#include "binarybuffer.h"
#include "target.h"
#include "register.h"
#include "jtag.h"
#include <stdlib.h>
int handle_etm_dummy_config_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
{
target_t *target;
armv4_5_common_t *armv4_5;
arm7_9_common_t *arm7_9;
target = get_target_by_num(strtoul(args[0], NULL, 0));
if (!target)
{
ERROR("target number '%s' not defined", args[0]);
exit(-1);
}
if (arm7_9_get_arch_pointers(target, &armv4_5, &arm7_9) != ERROR_OK)
{
command_print(cmd_ctx, "current target isn't an ARM7/ARM9 target");
return ERROR_OK;
}
if (arm7_9->etm_ctx)
{
arm7_9->etm_ctx->capture_driver_priv = NULL;
}
else
{
ERROR("target has no ETM defined, ETM dummy left unconfigured");
}
return ERROR_OK;
}
int etm_dummy_register_commands(struct command_context_s *cmd_ctx)
{
command_t *etm_dummy_cmd;
etm_dummy_cmd = register_command(cmd_ctx, NULL, "etm_dummy", NULL, COMMAND_ANY, "Dummy ETM capture driver");
register_command(cmd_ctx, etm_dummy_cmd, "config", handle_etm_dummy_config_command, COMMAND_CONFIG, NULL);
return ERROR_OK;
}
int etm_dummy_init(etm_context_t *etm_ctx)
{
return ERROR_OK;
}
trace_status_t etm_dummy_status(etm_context_t *etm_ctx)
{
return TRACE_IDLE;
}
int etm_dummy_read_trace(etm_context_t *etm_ctx)
{
return ERROR_OK;
}
int etm_dummy_start_capture(etm_context_t *etm_ctx)
{
return ERROR_ETM_PORTMODE_NOT_SUPPORTED;
}
int etm_dummy_stop_capture(etm_context_t *etm_ctx)
{
return ERROR_OK;
}
etm_capture_driver_t etm_dummy_capture_driver =
{
.name = "dummy",
.register_commands = etm_dummy_register_commands,
.init = etm_dummy_init,
.status = etm_dummy_status,
.start_capture = etm_dummy_start_capture,
.stop_capture = etm_dummy_stop_capture,
.read_trace = etm_dummy_read_trace,
};

33
src/target/etm_dummy.h Normal file
View File

@ -0,0 +1,33 @@
/***************************************************************************
* Copyright (C) 2007 by Dominic Rath *
* Dominic.Rath@gmx.de *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the *
* Free Software Foundation, Inc., *
* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *
***************************************************************************/
#ifndef ETM_DUMMY_H
#define ETM_DUMMY_H
#include "command.h"
#include "target.h"
#include "register.h"
#include "arm_jtag.h"
#include "etm.h"
extern etm_capture_driver_t etm_dummy_capture_driver;
extern int etm_dummy_register_commands(struct command_context_s *cmd_ctx);
#endif /* ETB_H */