Index: openocd-0.5.0/tcl/interface/estick.cfg =================================================================== --- openocd-0.5.0/tcl/interface/estick.cfg (revision 0) +++ openocd-0.5.0/tcl/interface/estick.cfg (revision 13) @@ -0,0 +1,9 @@ +# +# eStick +# +# http://code.google.com/p/estick-jtag/ +# + +interface estick +adapter_khz 66 + Index: openocd-0.5.0/configure.in =================================================================== --- openocd-0.5.0/configure.in (revision 11) +++ openocd-0.5.0/configure.in (working copy) @@ -462,6 +462,10 @@ AS_HELP_STRING([--enable-jlink], [Enable building support for the Segger J-Link JTAG Programmer]), [build_jlink=$enableval], [build_jlink=no]) +AC_ARG_ENABLE(estick, + AS_HELP_STRING([--enable-estick], [Enable building support for the estick JTAG Programmer]), + [build_estick=$enableval], [build_estick=no]) + AC_ARG_ENABLE(vsllink, AS_HELP_STRING([--enable-vsllink], [Enable building support for the Versaloon-Link JTAG Programmer]), [build_vsllink=$enableval], [build_vsllink=no]) @@ -723,6 +727,12 @@ AC_DEFINE(BUILD_JLINK, 0, [0 if you don't want the J-Link JTAG driver.]) fi +if test $build_estick = yes; then + AC_DEFINE(BUILD_ESTICK, 1, [1 if you want the estick JTAG driver.]) +else + AC_DEFINE(BUILD_ESTICK, 0, [0 if you don't want the estick JTAG driver.]) +fi + if test $build_vsllink = yes; then AC_DEFINE(BUILD_VSLLINK, 1, [1 if you want the Versaloon-Link JTAG driver.]) else @@ -1073,6 +1083,7 @@ AM_CONDITIONAL(USBPROG, test $build_usbprog = yes) AM_CONDITIONAL(OOCD_TRACE, test $build_oocd_trace = yes) AM_CONDITIONAL(JLINK, test $build_jlink = yes) +AM_CONDITIONAL(ESTICK, test $build_estick = yes) AM_CONDITIONAL(VSLLINK, test $build_vsllink = yes) AM_CONDITIONAL(RLINK, test $build_rlink = yes) AM_CONDITIONAL(ULINK, test $build_ulink = yes) Index: openocd-0.5.0/src/jtag/interfaces.c =================================================================== --- openocd-0.5.0/src/jtag/interfaces.c (revision 11) +++ openocd-0.5.0/src/jtag/interfaces.c (working copy) @@ -94,6 +94,9 @@ #if BUILD_ARMJTAGEW == 1 extern struct jtag_interface armjtagew_interface; #endif +#if BUILD_ESTICK == 1 +extern struct jtag_interface estick_interface; +#endif #if BUILD_BUSPIRATE == 1 extern struct jtag_interface buspirate_interface; #endif @@ -160,6 +163,9 @@ #if BUILD_ARMJTAGEW == 1 &armjtagew_interface, #endif +#if BUILD_ESTICK == 1 + &estick_interface, +#endif #if BUILD_BUSPIRATE == 1 &buspirate_interface, #endif Index: openocd-0.5.0/src/jtag/drivers/estick.c =================================================================== --- openocd-0.5.0/src/jtag/drivers/estick.c (revision 0) +++ openocd-0.5.0/src/jtag/drivers/estick.c (revision 13) @@ -0,0 +1,854 @@ +/*************************************************************************** + * * + * Copyright (C) 2009 by Cahya Wirawan * + * Based on opendous driver by Vladimir Fonov * + * * + * Copyright (C) 2009 by Vladimir Fonov * + * Based on J-link driver by Juergen Stuber * + * * + * Copyright (C) 2007 by Juergen Stuber * + * based on Dominic Rath's and Benedikt Sauter's usbprog.c * + * * + * Copyright (C) 2008 by Spencer Oliver * + * spen@spen-soft.co.uk * + * * + * 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 +#include +#include "usb_common.h" +#include +#include +#include + +#define VID 0x1781 +#define PID 0xC0C0 + +#define ESTICK_WRITE_ENDPOINT 0x02 +#define ESTICK_READ_ENDPOINT 0x81 + +static unsigned int estick_hw_jtag_version = 1; + +#define ESTICK_USB_TIMEOUT 1000 + +#define ESTICK_USB_BUFFER_SIZE 360 +#define ESTICK_IN_BUFFER_SIZE (ESTICK_USB_BUFFER_SIZE) +#define ESTICK_OUT_BUFFER_SIZE (ESTICK_USB_BUFFER_SIZE) + +/* Global USB buffers */ +static uint8_t usb_in_buffer[ESTICK_IN_BUFFER_SIZE]; +static uint8_t usb_out_buffer[ESTICK_OUT_BUFFER_SIZE]; + +/* Constants for ESTICK command */ + +#define ESTICK_MAX_SPEED 66 +#define ESTICK_MAX_TAP_TRANSMIT 350 //even number is easier to handle +#define ESTICK_MAX_INPUT_DATA (ESTICK_MAX_TAP_TRANSMIT*4) + +#define ESTICK_TAP_BUFFER_SIZE 65536 + +#define MAX_PENDING_SCAN_RESULTS (ESTICK_MAX_INPUT_DATA) + +//JTAG usb commans +#define JTAG_CMD_TAP_OUTPUT 0x0 +#define JTAG_CMD_SET_TRST 0x1 +#define JTAG_CMD_SET_SRST 0x2 +#define JTAG_CMD_READ_INPUT 0x3 +#define JTAG_CMD_TAP_OUTPUT_EMU 0x4 +#define JTAG_CMD_SET_DELAY 0x5 +#define JTAG_CMD_SET_SRST_TRST 0x6 + +/* External interface functions */ +static int estick_execute_queue(void); +static int estick_speed(int speed); +static int estick_speed_div(int speed, int *khz); +static int estick_khz(int khz, int *jtag_speed); +static int estick_init(void); +static int estick_quit(void); + +/* Queue command functions */ +static void estick_end_state(tap_state_t state); +static void estick_state_move(void); +static void estick_path_move(int num_states, tap_state_t *path); +static void estick_runtest(int num_cycles); +static void estick_scan(int ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command); +static void estick_reset(int trst, int srst); +static void estick_simple_command(uint8_t command,uint8_t _data); +static int estick_get_status(void); + +/* eStick tap buffer functions */ +static void estick_tap_init(void); +static int estick_tap_execute(void); +static void estick_tap_ensure_space(int scans, int bits); +static void estick_tap_append_step(int tms, int tdi); +static void estick_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command); + +/* estick lowlevel functions */ +struct estick_jtag +{ + struct usb_dev_handle* usb_handle; +}; + +static struct estick_jtag *estick_usb_open(void); +static void estick_usb_close(struct estick_jtag *estick_jtag); +static int estick_usb_message(struct estick_jtag *estick_jtag, int out_length, int in_length); +static int estick_usb_write(struct estick_jtag *estick_jtag, int out_length); +static int estick_usb_read(struct estick_jtag *estick_jtag); +//static int estick_usb_read_emu_result(struct estick_jtag *estick_jtag); + +/* helper functions */ +int estick_get_version_info(void); + +#ifdef _DEBUG_USB_COMMS_ +char time_str[50]; +static void estick_debug_buffer(uint8_t *buffer, int length); +char *estick_get_time(char *); +#endif + +static struct estick_jtag* estick_jtag_handle; + +/***************************************************************************/ +/* External interface implementation */ + +COMMAND_HANDLER(estick_handle_estick_info_command) +{ + if (estick_get_version_info() == ERROR_OK) + { + /* attempt to get status */ + estick_get_status(); + } + + return ERROR_OK; +} + +COMMAND_HANDLER(estick_handle_estick_hw_jtag_command) +{ + switch (CMD_ARGC) { + case 0: + command_print(CMD_CTX, "estick hw jtag %i", estick_hw_jtag_version); + break; + case 1: { + int request_version = atoi(CMD_ARGV[0]); + switch (request_version) { + case 2: case 3: + estick_hw_jtag_version = request_version; + break; + default: + return ERROR_COMMAND_SYNTAX_ERROR; + } + break; + } + default: + return ERROR_COMMAND_SYNTAX_ERROR; + } + + return ERROR_OK; +} + +static const struct command_registration estick_command_handlers[] = { + { + .name = "estick_info", + .handler = &estick_handle_estick_info_command, + .mode = COMMAND_EXEC, + .help = "show estick info", + }, + { + .name = "estick_hw_jtag", + .handler = &estick_handle_estick_hw_jtag_command, + .mode = COMMAND_EXEC, + .help = "access eStick HW JTAG command version", + .usage = "[2|3]", + }, + COMMAND_REGISTRATION_DONE +}; + +struct jtag_interface estick_interface = +{ + .name = "estick", + .commands = estick_command_handlers, + .execute_queue = estick_execute_queue, + .speed = estick_speed, + .speed_div = estick_speed_div, + .khz = estick_khz, + .init = estick_init, + .quit = estick_quit, +}; + +static int estick_execute_queue(void) +{ + struct jtag_command *cmd = jtag_command_queue; + int scan_size; + enum scan_type type; + uint8_t *buffer; + + while (cmd != NULL) + { + switch (cmd->type) + { + case JTAG_RUNTEST: + DEBUG_JTAG_IO( "runtest %i cycles, end in %i", cmd->cmd.runtest->num_cycles, \ + cmd->cmd.runtest->end_state); + + if (cmd->cmd.runtest->end_state != -1) + { + estick_end_state(cmd->cmd.runtest->end_state); + } + estick_runtest(cmd->cmd.runtest->num_cycles); + break; + + case JTAG_TLR_RESET: + DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state); + + estick_end_state(cmd->cmd.statemove->end_state); + estick_state_move(); + break; + + case JTAG_PATHMOVE: + DEBUG_JTAG_IO("pathmove: %i states, end in %i", \ + cmd->cmd.pathmove->num_states, \ + cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); + + estick_path_move(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path); + break; + + case JTAG_SCAN: + DEBUG_JTAG_IO("scan end in %i", cmd->cmd.scan->end_state); + + if (cmd->cmd.scan->end_state != -1) + { + estick_end_state(cmd->cmd.scan->end_state); + } + + scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); + DEBUG_JTAG_IO("scan input, length = %d", scan_size); + +#ifdef _DEBUG_USB_COMMS_ + estick_debug_buffer(buffer, (scan_size + 7) / 8); +#endif + type = jtag_scan_type(cmd->cmd.scan); + estick_scan(cmd->cmd.scan->ir_scan, type, buffer, scan_size, cmd->cmd.scan); + break; + + case JTAG_RESET: + DEBUG_JTAG_IO("reset trst: %i srst %i", cmd->cmd.reset->trst, cmd->cmd.reset->srst); + + estick_tap_execute(); + + if (cmd->cmd.reset->trst == 1) + { + tap_set_state(TAP_RESET); + } + estick_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); + break; + + case JTAG_SLEEP: + DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us); + estick_tap_execute(); + jtag_sleep(cmd->cmd.sleep->us); + break; + + default: + LOG_ERROR("BUG: unknown JTAG command type encountered"); + exit(-1); + } + cmd = cmd->next; + } + return estick_tap_execute(); +} + +/* Sets speed in kHz. */ +static int estick_speed(int speed) +{ + + if (speed <= ESTICK_MAX_SPEED) + { + //one day... + return ERROR_OK; + } + else + { + LOG_INFO("Requested speed %dkHz exceeds maximum of %dkHz, ignored", speed, ESTICK_MAX_SPEED); + } + + return ERROR_OK; +} + +static int estick_speed_div(int speed, int* khz) +{ + *khz = speed; + + return ERROR_OK; +} + +static int estick_khz(int khz, int *jtag_speed) +{ + *jtag_speed = khz; + //TODO: convert this into delay value for estick + + return ERROR_OK; +} + +static int estick_init(void) +{ + int check_cnt; + + estick_jtag_handle = estick_usb_open(); + + if (estick_jtag_handle == 0) + { + LOG_ERROR("Cannot find eStick Interface! Please check connection and permissions."); + return ERROR_JTAG_INIT_FAILED; + } + + //reset the board + + //usb_control_msg(estick_jtag_handle, (REQDIR_DEVICETOHOST | REQTYPE_VENDOR | REQTYPE_STANDARD), 1, 0, 0, &dummy, 1, ESTICK_USB_TIMEOUT); + + check_cnt = 0; + while (check_cnt < 3) + { + if (estick_get_version_info() == ERROR_OK) + { + /* attempt to get status */ + estick_get_status(); + break; + } + + check_cnt++; + } + + LOG_INFO("eStick JTAG Interface ready"); + + estick_reset(0, 0); + estick_tap_init(); + //estick_simple_command ( JTAG_CMD_SET_DELAY, 255); + + + return ERROR_OK; +} + +static int estick_quit(void) +{ + estick_usb_close(estick_jtag_handle); + return ERROR_OK; +} + +/***************************************************************************/ +/* Queue command implementations */ + +void estick_end_state(tap_state_t state) +{ + if (tap_is_state_stable(state)) + { + tap_set_end_state(state); + } + else + { + LOG_ERROR("BUG: %i is not a valid end state", state); + exit(-1); + } +} + +/* Goes to the end state. */ +void estick_state_move(void) +{ + int i; + int tms = 0; + uint8_t tms_scan = tap_get_tms_path(tap_get_state(), tap_get_end_state()); + uint8_t tms_scan_bits = tap_get_tms_path_len(tap_get_state(), tap_get_end_state()); + + for (i = 0; i < tms_scan_bits; i++) + { + tms = (tms_scan >> i) & 1; + estick_tap_append_step(tms, 0); + } + + tap_set_state(tap_get_end_state()); +} + +void estick_path_move(int num_states, tap_state_t *path) +{ + int i; + + for (i = 0; i < num_states; i++) + { + if (path[i] == tap_state_transition(tap_get_state(), false)) + { + estick_tap_append_step(0, 0); + } + else if (path[i] == tap_state_transition(tap_get_state(), true)) + { + estick_tap_append_step(1, 0); + } + else + { + LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path[i])); + exit(-1); + } + + tap_set_state(path[i]); + } + + tap_set_end_state(tap_get_state()); +} + +void estick_runtest(int num_cycles) +{ + int i; + + tap_state_t saved_end_state = tap_get_end_state(); + + /* only do a state_move when we're not already in IDLE */ + if (tap_get_state() != TAP_IDLE) + { + estick_end_state(TAP_IDLE); + estick_state_move(); + } + + /* execute num_cycles */ + for (i = 0; i < num_cycles; i++) + { + estick_tap_append_step(0, 0); + } + + /* finish in end_state */ + estick_end_state(saved_end_state); + if (tap_get_state() != tap_get_end_state()) + { + estick_state_move(); + } +} + +void estick_scan(int ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command) +{ + tap_state_t saved_end_state; + + estick_tap_ensure_space(1, scan_size + 8); + + saved_end_state = tap_get_end_state(); + + /* Move to appropriate scan state */ + estick_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT); + + if (tap_get_state() != tap_get_end_state()) + estick_state_move(); + + estick_end_state(saved_end_state); + + /* Scan */ + estick_tap_append_scan(scan_size, buffer, command); + + /* We are in Exit1, go to Pause */ + estick_tap_append_step(0, 0); + + tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE); + + if (tap_get_state() != tap_get_end_state()) + { + estick_state_move(); + } +} + +void estick_reset(int trst, int srst) +{ + LOG_DEBUG("trst: %i, srst: %i", trst, srst); + + /* Signals are active low */ +/* + if (srst == 0) + { + estick_simple_command ( JTAG_CMD_SET_SRST,1); + } + else if (srst == 1) + { + estick_simple_command ( JTAG_CMD_SET_SRST,0); + } + + if (trst == 0) + { + estick_simple_command ( JTAG_CMD_SET_TRST,1); + } + else if (trst == 1) + { + estick_simple_command ( JTAG_CMD_SET_TRST,0); + }*/ + + srst=srst?0:1; + trst=trst?0:2; + estick_simple_command ( JTAG_CMD_SET_SRST_TRST,srst|trst ); +} + +void estick_simple_command(uint8_t command,uint8_t _data) +{ + int result; + + DEBUG_JTAG_IO("0x%02x 0x%02x", command,_data); + + usb_out_buffer[0] = (uint16_t) 2; + usb_out_buffer[2] = command; + usb_out_buffer[3] = _data; + + result = estick_usb_message(estick_jtag_handle, 4, 1); + if (result != 1) + { + LOG_ERROR("Estick command 0x%02x failed (%d)", command, result); + } +} + +int estick_get_status(void) +{ +/* + estick_simple_command(EMU_CMD_GET_STATE); + estick_simple_command(EMU_CMD_GET_STATE); + result = estick_usb_read(estick_jtag_handle); + + if (result == 8) + { + int vref = usb_in_buffer[0] + (usb_in_buffer[1] << 8); + LOG_INFO("Vref = %d.%d TCK = %d TDI = %d TDO = %d TMS = %d SRST = %d TRST = %d\n", \ + vref / 1000, vref % 1000, \ + usb_in_buffer[2], usb_in_buffer[3], usb_in_buffer[4], \ + usb_in_buffer[5], usb_in_buffer[6], usb_in_buffer[7]); + + if (vref < 1500) + { + LOG_ERROR("Vref too low. Check Target Power\n"); + } + } + else + { + LOG_ERROR("J-Link command EMU_CMD_GET_STATE failed (%d)\n", result); + } +*/ + return ERROR_OK; +} + +int estick_get_version_info(void) +{ + return ERROR_OK; +} + +/***************************************************************************/ +/* Estick tap functions */ + + +static int tap_length; +static uint8_t tms_buffer[ESTICK_TAP_BUFFER_SIZE]; +static uint8_t tdo_buffer[ESTICK_TAP_BUFFER_SIZE]; + +struct pending_scan_result { + int first; /* First bit position in tdo_buffer to read */ + int length; /* Number of bits to read */ + struct scan_command *command; /* Corresponding scan command */ + uint8_t *buffer; +}; + +static int pending_scan_results_length; +static struct pending_scan_result pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS]; + +static int last_tms; + +void estick_tap_init(void) +{ + tap_length = 0; + pending_scan_results_length = 0; +} + +void estick_tap_ensure_space(int scans, int bits) +{ + int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length; + + if (scans > available_scans ) + { + estick_tap_execute(); + } +} + +void estick_tap_append_step(int tms, int tdi) +{ + last_tms = tms; + unsigned char _tms=tms?1:0; + unsigned char _tdi=tdi?1:0; + + int index = tap_length/4; + int bits = (tap_length%4)*2; + + if (tap_length < ESTICK_TAP_BUFFER_SIZE) + { + if(!bits) + tms_buffer[index]=0; + + tms_buffer[index] |= (_tdi<first = tap_length; + pending_scan_result->length = length; + pending_scan_result->command = command; + pending_scan_result->buffer = buffer; + + for (i = 0; i < length; i++) + { + estick_tap_append_step((i < length-1 ? 0 : 1), (buffer[i/8] >> (i%8)) & 1); + } + pending_scan_results_length++; +} + +/* Pad and send a tap sequence to the device, and receive the answer. + * For the purpose of padding we assume that we are in idle or pause state. */ +int estick_tap_execute(void) +{ + int byte_length,byte_length_out; + int i,j; + int result; + int output_counter; + + + if (tap_length > 0) + { + + //memset(tdo_buffer,0,ESTICK_TAP_BUFFER_SIZE); + //LOG_INFO("ESTICK tap execute %d",tap_length); + byte_length = (tap_length+3)/4; + byte_length_out = (tap_length+7)/8; + +#ifdef _DEBUG_USB_COMMS_ + LOG_DEBUG("eStick is sending %d bytes", byte_length); +#endif + + output_counter=0; + for (j = 0, i = 0; j < byte_length;) + { + int recieve; + int transmit=byte_length-j; + if(transmit>ESTICK_MAX_TAP_TRANSMIT) + { + transmit=ESTICK_MAX_TAP_TRANSMIT; + recieve=(ESTICK_MAX_TAP_TRANSMIT)/2; + usb_out_buffer[2]=JTAG_CMD_TAP_OUTPUT; + + } else { + usb_out_buffer[2]=JTAG_CMD_TAP_OUTPUT | ((tap_length%4)<<4); + recieve=(transmit+1)/2; + } + *(uint16_t *)&usb_out_buffer[0]=transmit+1; + memmove(usb_out_buffer+3,tms_buffer+j,transmit); + result = estick_usb_message(estick_jtag_handle, 3 + transmit, recieve); + if(result!=recieve) + { + LOG_ERROR("estick_tap_execute, wrong result %d, expected %d", result, recieve); + return ERROR_JTAG_QUEUE_FAILED; + } + + memmove(tdo_buffer+i,usb_in_buffer,recieve); + i+=recieve; + j+=transmit; + } + + result=byte_length_out; +#ifdef _DEBUG_USB_COMMS_ + LOG_DEBUG("eStick tap result %d",result); + estick_debug_buffer(tdo_buffer,result); +#endif + //LOG_INFO("eStick tap execute %d",tap_length); + for (i = 0; i < pending_scan_results_length; i++) + { + struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[i]; + uint8_t *buffer = pending_scan_result->buffer; + int length = pending_scan_result->length; + int first = pending_scan_result->first; + struct scan_command *command = pending_scan_result->command; + + /* Copy to buffer */ + buf_set_buf(tdo_buffer, first, buffer, 0, length); + + DEBUG_JTAG_IO("pending scan result, length = %d", length); + +#ifdef _DEBUG_USB_COMMS_ + //estick_debug_buffer(buffer, byte_length_out); +#endif + + if (jtag_read_buffer(buffer, command) != ERROR_OK) + { + estick_tap_init(); + return ERROR_JTAG_QUEUE_FAILED; + } + + if (pending_scan_result->buffer != NULL) + { + free(pending_scan_result->buffer); + } + } + + estick_tap_init(); + } + + return ERROR_OK; +} + +/*****************************************************************************/ +/* Estick USB low-level functions */ + +struct estick_jtag* estick_usb_open() +{ + usb_set_debug(10); + usb_init(); + + const uint16_t vids[] = { VID, 0 }; + const uint16_t pids[] = { PID, 0 }; + struct usb_dev_handle *dev; + if (jtag_usb_open(vids, pids, &dev) != ERROR_OK) + return NULL; + + struct estick_jtag *tmp = malloc(sizeof(struct estick_jtag)); + tmp->usb_handle = dev; + + usb_set_configuration(dev, 1); + usb_claim_interface(dev, 0); + usb_set_altinterface(dev, 0); + + return tmp; +} + +void estick_usb_close(struct estick_jtag *estick_jtag) +{ + usb_close(estick_jtag->usb_handle); + free(estick_jtag); +} + +/* Send a message and receive the reply. */ +int estick_usb_message(struct estick_jtag *estick_jtag, int out_length, int in_length) +{ + int result; + + result = estick_usb_write(estick_jtag, out_length); + if (result == out_length) + { + result = estick_usb_read(estick_jtag); + if (result == in_length) + { + return result; + } + else + { + LOG_ERROR("usb_bulk_read failed (requested=%d, result=%d)", in_length, result); + return -1; + } + } + else + { + LOG_ERROR("usb_bulk_write failed (requested=%d, result=%d)", out_length, result); + return -1; + } +} + +/* Write data from out_buffer to USB. */ +int estick_usb_write(struct estick_jtag *estick_jtag, int out_length) +{ + int result; + + if (out_length > ESTICK_OUT_BUFFER_SIZE) + { + LOG_ERROR("estick_jtag_write illegal out_length=%d (max=%d)", out_length, ESTICK_OUT_BUFFER_SIZE); + return -1; + } + +#ifdef _DEBUG_USB_COMMS_ + LOG_DEBUG("%s: USB write begin", estick_get_time(time_str)); +#endif + result = usb_bulk_write(estick_jtag->usb_handle, ESTICK_WRITE_ENDPOINT, \ + (char *)usb_out_buffer, out_length, ESTICK_USB_TIMEOUT); +#ifdef _DEBUG_USB_COMMS_ + LOG_DEBUG("%s: USB write end: %d bytes", estick_get_time(time_str), result); +#endif + + DEBUG_JTAG_IO("estick_usb_write, out_length = %d, result = %d", out_length, result); + +#ifdef _DEBUG_USB_COMMS_ + //estick_debug_buffer(usb_out_buffer, out_length); +#endif + return result; +} + +/* Read data from USB into in_buffer. */ +int estick_usb_read(struct estick_jtag *estick_jtag) +{ +#ifdef _DEBUG_USB_COMMS_ + LOG_DEBUG("%s: USB read begin", estick_get_time(time_str)); +#endif + int result = usb_bulk_read(estick_jtag->usb_handle, ESTICK_READ_ENDPOINT, + (char *)usb_in_buffer, ESTICK_IN_BUFFER_SIZE, ESTICK_USB_TIMEOUT); +#ifdef _DEBUG_USB_COMMS_ + LOG_DEBUG("%s: USB read end: %d bytes", estick_get_time(time_str), result); +#endif + DEBUG_JTAG_IO("estick_usb_read, result = %d", result); + +#ifdef _DEBUG_USB_COMMS_ + //estick_debug_buffer(usb_in_buffer, result); +#endif + return result; +} + +//#ifdef _DEBUG_USB_COMMS_ +#define BYTES_PER_LINE 16 + +void estick_debug_buffer(uint8_t *buffer, int length) +{ + char line[81]; + char s[4]; + int i; + int j; + + for (i = 0; i < length; i += BYTES_PER_LINE) + { + snprintf(line, 5, "%04x", i); + for (j = i; j < i + BYTES_PER_LINE && j < length; j++) + { + snprintf(s, 4, " %02x", buffer[j]); + strcat(line, s); + } + LOG_DEBUG("%s", line); + } +} + +char *estick_get_time(char *str) +{ + struct timeb timebuffer; + char *timeline; + + ftime( &timebuffer ); + timeline = ctime( & ( timebuffer.time ) ); + snprintf(str, 49, "%.8s.%hu", &timeline[11], timebuffer.millitm); + return str; +} +//#endif Index: openocd-0.5.0/src/jtag/drivers/Makefile.am =================================================================== --- openocd-0.5.0/src/jtag/drivers/Makefile.am (revision 11) +++ openocd-0.5.0/src/jtag/drivers/Makefile.am (working copy) @@ -72,6 +72,9 @@ if ARMJTAGEW DRIVERFILES += arm-jtag-ew.c endif +if ESTICK +DRIVERFILES += estick.c +endif if BUSPIRATE DRIVERFILES += buspirate.c endif Index: openocd-0.5.0/src/Makefile.am =================================================================== --- openocd-0.5.0/src/Makefile.am (revision 11) +++ openocd-0.5.0/src/Makefile.am (working copy) @@ -92,12 +92,16 @@ if VSLLINK LIBUSB = -lusb else +if ESTICK +LIBUSB = -lusb +else LIBUSB = endif endif endif endif endif +endif libopenocd_la_LIBADD = \ $(top_builddir)/src/xsvf/libxsvf.la \