X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fvsllink.c;h=decca16c61eecb1fad46c6a35696d922309f2859;hp=88a59d787b93f21225fa7931b5d019de9f098385;hb=cfc4d5c6b7b6f8f82dc5bbf3ee661c179814666e;hpb=38e51eb4fb9ef311e38858c4429118723e65fdd9 diff --git a/src/jtag/vsllink.c b/src/jtag/vsllink.c index 88a59d787b..decca16c61 100644 --- a/src/jtag/vsllink.c +++ b/src/jtag/vsllink.c @@ -1,5 +1,5 @@ /*************************************************************************** - * Copyright (C) 2007 by Simon Qian * + * Copyright (C) 2009 by Simon Qian * * * * 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 * @@ -26,48 +26,32 @@ #include "config.h" #endif -#include "replacements.h" - -#include "jtag.h" +#include "interface.h" +#include "commands.h" #include -#include -#include "log.h" //#define _VSLLINK_IN_DEBUG_MODE_ -/* enable this to view USB communication - */ -#if 0 -#define _DEBUG_USB_COMMS_ -#endif - -#ifdef _DEBUG_JTAG_IO_ -#define DEBUG_JTAG_IO(expr ...) LOG_DEBUG(expr) -#else -#define DEBUG_JTAG_IO(expr ...) -#endif - -#define VID 0x03EB -#define PID 0x2103 -#define VSLLINK_WRITE_ENDPOINT 0x02 -#define VSLLINK_READ_ENDPOINT 0x82 +#define VSLLINK_MODE_NORMAL 0 +#define VSLLINK_MODE_DMA 1 -u16 vsllink_vid = VID; -u16 vsllink_pid = PID; -u8 vsllink_bulkout = VSLLINK_WRITE_ENDPOINT; -u8 vsllink_bulkin = VSLLINK_READ_ENDPOINT; - -#define VSLLINK_USB_TIMEOUT 1000 +static uint16_t vsllink_usb_vid; +static uint16_t vsllink_usb_pid; +static uint8_t vsllink_usb_bulkout; +static uint8_t vsllink_usb_bulkin; +static uint8_t vsllink_usb_interface; +static uint8_t vsllink_mode = VSLLINK_MODE_NORMAL; +static int VSLLINK_USB_TIMEOUT = 10000; static int VSLLINK_BufferSize = 1024; /* Global USB buffers */ static int vsllink_usb_out_buffer_idx; static int vsllink_usb_in_want_length; -static u8* vsllink_usb_in_buffer = NULL; -static u8* vsllink_usb_out_buffer = NULL; +static uint8_t* vsllink_usb_in_buffer = NULL; +static uint8_t* vsllink_usb_out_buffer = NULL; /* Constants for VSLLink command */ #define VSLLINK_CMD_CONN 0x80 @@ -77,8 +61,12 @@ static u8* vsllink_usb_out_buffer = NULL; #define VSLLINK_CMD_GET_PORT 0x91 #define VSLLINK_CMD_SET_PORTDIR 0x92 #define VSLLINK_CMD_HW_JTAGSEQCMD 0xA0 +#define VSLLINK_CMD_HW_JTAGHLCMD 0xA1 +#define VSLLINK_CMD_HW_SWDCMD 0xA2 +#define VSLLINK_CMD_HW_JTAGRAWCMD 0xA3 #define VSLLINK_CMDJTAGSEQ_TMSBYTE 0x00 +#define VSLLINK_CMDJTAGSEQ_TMSCLOCK 0x40 #define VSLLINK_CMDJTAGSEQ_SCAN 0x80 #define VSLLINK_CMDJTAGSEQ_CMDMSK 0xC0 @@ -94,7 +82,7 @@ static u8* vsllink_usb_out_buffer = NULL; #define JTAG_PINMSK_TDO (1 << 7) -#define VSLLINK_TAP_MOVE(from, to) VSLLINK_tap_move[tap_move_map[from]][tap_move_map[to]] +#define VSLLINK_TAP_MOVE(from, to) VSLLINK_tap_move[tap_move_ndx(from)][tap_move_ndx(to)] /* VSLLINK_tap_move[i][j]: tap movement command to go from state i to state j * 0: Test-Logic-Reset @@ -103,27 +91,27 @@ static u8* vsllink_usb_out_buffer = NULL; * 3: Pause-DR * 4: Shift-IR * 5: Pause-IR - * + * * SD->SD and SI->SI have to be caught in interface specific code */ -u8 VSLLINK_tap_move[6][6] = +static uint8_t VSLLINK_tap_move[6][6] = { /* TLR RTI SD PD SI PI */ - {0xff, 0x00, 0x2f, 0x0a, 0x37, 0x16}, /* TLR */ + {0xff, 0x7f, 0x2f, 0x0a, 0x37, 0x16}, /* TLR */ {0xff, 0x00, 0x45, 0x05, 0x4b, 0x0b}, /* RTI */ {0xff, 0x61, 0x00, 0x01, 0x0f, 0x2f}, /* SD */ - {0xff, 0x60, 0x40, 0x17, 0x3c, 0x2f}, /* PD */ + {0xfe, 0x60, 0x40, 0x5c, 0x3c, 0x5e}, /* PD */ {0xff, 0x61, 0x07, 0x17, 0x00, 0x01}, /* SI */ - {0xff, 0x60, 0x38, 0x17, 0x40, 0x2f} /* PI */ + {0xfe, 0x60, 0x38, 0x5c, 0x40, 0x5e} /* PI */ }; -u8 VSLLINK_TAP_MOVE_FROM_E1[6] = +typedef struct insert_insignificant_operation { -// TLR RTI SD PD SI PI - 0xff, 0x60, 0x38, 0x5c, 0x3c, 0x5E -}; + unsigned char insert_value; + unsigned char insert_position; +}insert_insignificant_operation_t; -u8 VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[7][6][2] = +static insert_insignificant_operation_t VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[6][6] = { /* stuff offset */ {/* TLR */ @@ -170,40 +158,57 @@ u8 VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[7][6][2] = {0, 0,}}, /* PI */ }; -u8 VSLLINK_BIT_MSK[8] = +static uint8_t VSLLINK_BIT_MSK[8] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f }; -/* External interface functions */ -int vsllink_execute_queue(void); -int vsllink_speed(int speed); -int vsllink_khz(int khz, int *jtag_speed); -int vsllink_speed_div(int jtag_speed, int *khz); -int vsllink_register_commands(struct command_context_s *cmd_ctx); -int vsllink_init(void); -int vsllink_quit(void); - -/* CLI command handler functions */ -int vsllink_handle_usb_vid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int vsllink_handle_usb_pid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int vsllink_handle_usb_bulkin_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); -int vsllink_handle_usb_bulkout_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +typedef struct +{ + int offset; + int length; /* Number of bits to read */ + scan_command_t *command; /* Corresponding scan command */ + uint8_t *buffer; +} pending_scan_result_t; + +#define MAX_PENDING_SCAN_RESULTS 256 + +static int pending_scan_results_length; +static pending_scan_result_t pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS]; /* Queue command functions */ -void vsllink_end_state(enum tap_state state); -void vsllink_state_move(void); -void vsllink_path_move(int num_states, enum tap_state *path); -void vsllink_runtest(int num_cycles); -void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, scan_command_t *command); -void vsllink_reset(int trst, int srst); -void vsllink_simple_command(u8 command); +static void vsllink_end_state(tap_state_t state); +static void vsllink_state_move_dma(void); +static void vsllink_state_move_normal(void); +static void (*vsllink_state_move)(void); +static void vsllink_path_move_dma(int num_states, tap_state_t *path); +static void vsllink_path_move_normal(int num_states, tap_state_t *path); +static void (*vsllink_path_move)(int num_states, tap_state_t *path); +static void vsllink_runtest(int num_cycles); +static void vsllink_stableclocks_dma(int num_cycles, int tms); +static void vsllink_stableclocks_normal(int num_cycles, int tms); +static void (*vsllink_stableclocks)(int num_cycles, int tms); +static void vsllink_scan_dma(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command); +static void vsllink_scan_normal(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command); +static void (*vsllink_scan)(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command); +static void vsllink_reset(int trst, int srst); +static void vsllink_simple_command(uint8_t command); +static int vsllink_connect(void); +static int vsllink_disconnect(void); /* VSLLink tap buffer functions */ -void vsllink_tap_init(void); -int vsllink_tap_execute(void); -void vsllink_tap_ensure_space(int scans, int bytes); -void vsllink_tap_append_scan(int length, u8 *buffer, scan_command_t *command, int offset); +static void vsllink_tap_append_step(int tms, int tdi); +static void vsllink_tap_init_dma(void); +static void vsllink_tap_init_normal(void); +static void (*vsllink_tap_init)(void); +static int vsllink_tap_execute_dma(void); +static int vsllink_tap_execute_normal(void); +static int (*vsllink_tap_execute)(void); +static void vsllink_tap_ensure_space_dma(int scans, int length); +static void vsllink_tap_ensure_space_normal(int scans, int length); +static void (*vsllink_tap_ensure_space)(int scans, int length); +static void vsllink_tap_append_scan_dma(int length, uint8_t *buffer, scan_command_t *command); +static void vsllink_tap_append_scan_normal(int length, uint8_t *buffer, scan_command_t *command, int offset); /* VSLLink lowlevel functions */ typedef struct vsllink_jtag @@ -211,101 +216,89 @@ typedef struct vsllink_jtag struct usb_dev_handle* usb_handle; } vsllink_jtag_t; -vsllink_jtag_t *vsllink_usb_open(void); -void vsllink_usb_close(vsllink_jtag_t *vsllink_jtag); -int vsllink_usb_message(vsllink_jtag_t *vsllink_jtag, int out_length, int in_length); -int vsllink_usb_write(vsllink_jtag_t *vsllink_jtag, int out_length); -int vsllink_usb_read(vsllink_jtag_t *vsllink_jtag); +static vsllink_jtag_t *vsllink_usb_open(void); +static void vsllink_usb_close(vsllink_jtag_t *vsllink_jtag); +static int vsllink_usb_message(vsllink_jtag_t *vsllink_jtag, int out_length, int in_length); +static int vsllink_usb_write(vsllink_jtag_t *vsllink_jtag, int out_length); +static int vsllink_usb_read(vsllink_jtag_t *vsllink_jtag); -void vsllink_debug_buffer(u8 *buffer, int length); +#if defined _DEBUG_USB_COMMS_ || defined _DEBUG_JTAG_IO_ +static void vsllink_debug_buffer(uint8_t *buffer, int length); +#endif -int vsllink_tms_data_len = 0; -u8* vsllink_tms_cmd_pos; +static int vsllink_tms_data_len = 0; +static uint8_t* vsllink_tms_cmd_pos; -vsllink_jtag_t* vsllink_jtag_handle; +static int tap_length = 0; +static int tap_buffer_size = 0; +static uint8_t *tms_buffer = NULL; +static uint8_t *tdi_buffer = NULL; +static uint8_t *tdo_buffer = NULL; +static int last_tms; -/***************************************************************************/ -/* External interface implementation */ +static vsllink_jtag_t* vsllink_jtag_handle = NULL; -jtag_interface_t vsllink_interface = +static void reset_command_pointer(void) { - .name = "vsllink", - .execute_queue = vsllink_execute_queue, - .speed = vsllink_speed, - .khz = vsllink_khz, - .speed_div = vsllink_speed_div, - .register_commands = vsllink_register_commands, - .init = vsllink_init, - .quit = vsllink_quit -}; + if (vsllink_mode == VSLLINK_MODE_NORMAL) + { + vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_JTAGSEQCMD; + vsllink_usb_out_buffer_idx = 3; + } + else + { + tap_length = 0; + } +} -int vsllink_execute_queue(void) +static int vsllink_execute_queue(void) { jtag_command_t *cmd = jtag_command_queue; int scan_size; enum scan_type type; - u8 *buffer; + uint8_t *buffer; - DEBUG_JTAG_IO("--------------------------------------------------------------------------------"); + DEBUG_JTAG_IO("--------------------------------- vsllink -------------------------------------"); - vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_JTAGSEQCMD; - vsllink_usb_out_buffer_idx = 3; + reset_command_pointer(); while (cmd != NULL) { switch (cmd->type) { - case JTAG_END_STATE: - DEBUG_JTAG_IO("end_state: %i", cmd->cmd.end_state->end_state); - - if (cmd->cmd.end_state->end_state != -1) - { - vsllink_end_state(cmd->cmd.end_state->end_state); - } - break; - 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) - { - vsllink_end_state(cmd->cmd.runtest->end_state); - } + DEBUG_JTAG_IO("runtest %i cycles, end in %s", cmd->cmd.runtest->num_cycles, \ + tap_state_name(cmd->cmd.runtest->end_state)); + + vsllink_end_state(cmd->cmd.runtest->end_state); vsllink_runtest(cmd->cmd.runtest->num_cycles); break; - + case JTAG_STATEMOVE: - DEBUG_JTAG_IO("statemove end in %i", cmd->cmd.statemove->end_state); - - if (cmd->cmd.statemove->end_state != -1) - { - vsllink_end_state(cmd->cmd.statemove->end_state); - } + DEBUG_JTAG_IO("statemove end in %s", tap_state_name(cmd->cmd.statemove->end_state)); + + vsllink_end_state(cmd->cmd.statemove->end_state); vsllink_state_move(); break; - + case JTAG_PATHMOVE: - DEBUG_JTAG_IO("pathmove: %i states, end in %i", \ + DEBUG_JTAG_IO("pathmove: %i states, end in %s", \ cmd->cmd.pathmove->num_states, \ - cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1]); - + tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1])); + vsllink_path_move(cmd->cmd.pathmove->num_states, cmd->cmd.pathmove->path); break; - + case JTAG_SCAN: - if (cmd->cmd.scan->end_state != -1) - { - vsllink_end_state(cmd->cmd.scan->end_state); - } - + vsllink_end_state(cmd->cmd.scan->end_state); + scan_size = jtag_build_buffer(cmd->cmd.scan, &buffer); if (cmd->cmd.scan->ir_scan) { - DEBUG_JTAG_IO("JTAG Scan write IR(%d bits), end in %d:", scan_size, cmd->cmd.scan->end_state); + DEBUG_JTAG_IO("JTAG Scan write IR(%d bits), end in %s:", scan_size, tap_state_name(cmd->cmd.scan->end_state)); } else { - DEBUG_JTAG_IO("JTAG Scan write DR(%d bits), end in %d:", scan_size, cmd->cmd.scan->end_state); + DEBUG_JTAG_IO("JTAG Scan write DR(%d bits), end in %s:", scan_size, tap_state_name(cmd->cmd.scan->end_state)); } #ifdef _DEBUG_JTAG_IO_ @@ -316,48 +309,69 @@ int vsllink_execute_queue(void) vsllink_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); vsllink_tap_execute(); - + if (cmd->cmd.reset->trst == 1) { - cur_state = TAP_RESET; + tap_set_state(TAP_RESET); } vsllink_reset(cmd->cmd.reset->trst, cmd->cmd.reset->srst); - - vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_JTAGSEQCMD; - vsllink_usb_out_buffer_idx = 3; break; - + case JTAG_SLEEP: DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us); vsllink_tap_execute(); jtag_sleep(cmd->cmd.sleep->us); break; - + + case JTAG_STABLECLOCKS: + DEBUG_JTAG_IO("add %d clocks", cmd->cmd.stableclocks->num_cycles); + switch (tap_get_state()) + { + case TAP_RESET: + // tms should be '1' to stay in TAP_RESET mode + scan_size = 1; + break; + case TAP_DRSHIFT: + case TAP_IDLE: + case TAP_DRPAUSE: + case TAP_IRSHIFT: + case TAP_IRPAUSE: + // in other mode, tms should be '0' + scan_size = 0; + break; /* above stable states are OK */ + default: + LOG_ERROR("jtag_add_clocks() was called with TAP in non-stable state \"%s\"", + tap_state_name(tap_get_state())); + exit(-1); + } + vsllink_stableclocks(cmd->cmd.stableclocks->num_cycles, scan_size); + break; + default: - LOG_ERROR("BUG: unknown JTAG command type encountered"); + LOG_ERROR("BUG: unknown JTAG command type encountered: %d", cmd->type); exit(-1); } cmd = cmd->next; } - + return vsllink_tap_execute(); } -int vsllink_speed(int speed) +static int vsllink_speed(int speed) { int result; vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_SPEED; vsllink_usb_out_buffer[1] = (speed >> 0) & 0xff; vsllink_usb_out_buffer[2] = (speed >> 8) & 0xFF; - + result = vsllink_usb_write(vsllink_jtag_handle, 3); - + if (result == 3) { return ERROR_OK; @@ -367,41 +381,27 @@ int vsllink_speed(int speed) LOG_ERROR("VSLLink setting speed failed (%d)", result); return ERROR_JTAG_DEVICE_ERROR; } - - return ERROR_OK; -} -int vsllink_khz(int khz, int *jtag_speed) -{ - *jtag_speed = khz; - return ERROR_OK; } -int vsllink_speed_div(int jtag_speed, int *khz) +static int vsllink_khz(int khz, int *jtag_speed) { - *khz = jtag_speed; + *jtag_speed = khz; return ERROR_OK; } -int vsllink_register_commands(struct command_context_s *cmd_ctx) +static int vsllink_speed_div(int jtag_speed, int *khz) { - register_command(cmd_ctx, NULL, "vsllink_usb_vid", vsllink_handle_usb_vid_command, - COMMAND_CONFIG, NULL); - register_command(cmd_ctx, NULL, "vsllink_usb_pid", vsllink_handle_usb_pid_command, - COMMAND_CONFIG, NULL); - register_command(cmd_ctx, NULL, "vsllink_usb_bulkin", vsllink_handle_usb_bulkin_command, - COMMAND_CONFIG, NULL); - register_command(cmd_ctx, NULL, "vsllink_usb_bulkout", vsllink_handle_usb_bulkout_command, - COMMAND_CONFIG, NULL); + *khz = jtag_speed; return ERROR_OK; } -int vsllink_init(void) +static int vsllink_init(void) { - int check_cnt; + int check_cnt, to_tmp; int result; char version_str[100]; @@ -414,17 +414,20 @@ int vsllink_init(void) } vsllink_jtag_handle = vsllink_usb_open(); - + if (vsllink_jtag_handle == 0) { LOG_ERROR("Can't find USB JTAG Interface! Please check connection and permissions."); return ERROR_JTAG_INIT_FAILED; } - + LOG_DEBUG("vsllink found on %04X:%04X", vsllink_usb_vid, vsllink_usb_pid); + + to_tmp = VSLLINK_USB_TIMEOUT; + VSLLINK_USB_TIMEOUT = 100; check_cnt = 0; - while (check_cnt < 3) + while (check_cnt < 5) { - vsllink_simple_command(VSLLINK_CMD_CONN); + vsllink_simple_command(0x00); result = vsllink_usb_read(vsllink_jtag_handle); if (result > 2) @@ -432,7 +435,7 @@ int vsllink_init(void) vsllink_usb_in_buffer[result] = 0; VSLLINK_BufferSize = vsllink_usb_in_buffer[0] + (vsllink_usb_in_buffer[1] << 8); strncpy(version_str, (char *)vsllink_usb_in_buffer + 2, sizeof(version_str)); - LOG_INFO(version_str); + LOG_INFO("%s", version_str); // free the pre-alloc memroy free(vsllink_usb_in_buffer); @@ -452,26 +455,69 @@ int vsllink_init(void) { LOG_INFO("buffer size for USB is %d bytes", VSLLINK_BufferSize); } + // alloc memory for dma mode + if (vsllink_mode == VSLLINK_MODE_DMA) + { + tap_buffer_size = (VSLLINK_BufferSize - 3) / 2; + tms_buffer = (uint8_t*)malloc(tap_buffer_size); + tdi_buffer = (uint8_t*)malloc(tap_buffer_size); + tdo_buffer = (uint8_t*)malloc(tap_buffer_size); + if ((tms_buffer == NULL) || (tdi_buffer == NULL) || (tdo_buffer == NULL)) + { + LOG_ERROR("Not enough memory"); + exit(-1); + } + } break; } vsllink_simple_command(VSLLINK_CMD_DISCONN); - check_cnt++; } - if (check_cnt == 3) { // It's dangerout to proced LOG_ERROR("VSLLink initial failed"); exit(-1); } + VSLLINK_USB_TIMEOUT = to_tmp; + + // connect to vsllink + vsllink_connect(); + // initialize function pointers + if (vsllink_mode == VSLLINK_MODE_NORMAL) + { + // normal mode + vsllink_state_move = vsllink_state_move_normal; + vsllink_path_move = vsllink_path_move_normal; + vsllink_stableclocks = vsllink_stableclocks_normal; + vsllink_scan = vsllink_scan_normal; + + vsllink_tap_init = vsllink_tap_init_normal; + vsllink_tap_execute = vsllink_tap_execute_normal; + vsllink_tap_ensure_space = vsllink_tap_ensure_space_normal; + + LOG_INFO("vsllink run in NORMAL mode"); + } + else + { + // dma mode + vsllink_state_move = vsllink_state_move_dma; + vsllink_path_move = vsllink_path_move_dma; + vsllink_stableclocks = vsllink_stableclocks_dma; + vsllink_scan = vsllink_scan_dma; + + vsllink_tap_init = vsllink_tap_init_dma; + vsllink_tap_execute = vsllink_tap_execute_dma; + vsllink_tap_ensure_space = vsllink_tap_ensure_space_dma; + + LOG_INFO("vsllink run in DMA mode"); + } // Set SRST and TRST to output, Set USR1 and USR2 to input vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_PORTDIR; vsllink_usb_out_buffer[1] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST | JTAG_PINMSK_USR1 | JTAG_PINMSK_USR2; vsllink_usb_out_buffer[2] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST; - result = vsllink_usb_write(vsllink_jtag_handle, 3); - if (result != 3) + if (vsllink_usb_write(vsllink_jtag_handle, 3) != 3) { LOG_ERROR("VSLLink USB send data error"); exit(-1); @@ -482,48 +528,94 @@ int vsllink_init(void) LOG_INFO("VSLLink JTAG Interface ready"); vsllink_tap_init(); - + return ERROR_OK; } -int vsllink_quit(void) +static int vsllink_quit(void) { if ((vsllink_usb_in_buffer != NULL) && (vsllink_usb_out_buffer != NULL)) { - vsllink_simple_command(VSLLINK_CMD_DISCONN); + // Set all pins to input + vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_PORTDIR; + vsllink_usb_out_buffer[1] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST | JTAG_PINMSK_USR1 | JTAG_PINMSK_USR2; + vsllink_usb_out_buffer[2] = 0; + if (vsllink_usb_write(vsllink_jtag_handle, 3) != 3) + { + LOG_ERROR("VSLLink USB send data error"); + exit(-1); + } + + // disconnect + vsllink_disconnect(); vsllink_usb_close(vsllink_jtag_handle); + vsllink_jtag_handle = NULL; } if (vsllink_usb_in_buffer != NULL) { free(vsllink_usb_in_buffer); + vsllink_usb_in_buffer = NULL; } if (vsllink_usb_out_buffer != NULL) { free(vsllink_usb_out_buffer); + vsllink_usb_out_buffer = NULL; } + return ERROR_OK; } -// when vsllink_tms_data_len > 0, vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] is the byte that need to be appended. -// length of VSLLINK_CMDJTAGSEQ_TMSBYTE has been set. -void VSLLINK_add_tms_from_RTI(enum tap_state state) +/***************************************************************************/ +/* Queue command implementations */ +static int vsllink_disconnect(void) +{ + vsllink_simple_command(VSLLINK_CMD_DISCONN); + return ERROR_OK; +} + +static int vsllink_connect(void) { - u8 tms_scan = VSLLINK_TAP_MOVE(TAP_IDLE, state); - u16 tms2; + char vsllink_str[100]; + + vsllink_usb_out_buffer[0] = VSLLINK_CMD_CONN; + vsllink_usb_out_buffer[1] = vsllink_mode; + vsllink_usb_message(vsllink_jtag_handle, 2, 0); + if (vsllink_usb_read(vsllink_jtag_handle) > 2) + { + strncpy(vsllink_str, (char *)vsllink_usb_in_buffer + 2, sizeof(vsllink_str)); + LOG_INFO("%s", vsllink_str); + } - if ((cur_state != TAP_IDLE) || (state == TAP_IDLE) || (vsllink_tms_data_len <= 0) || (vsllink_tms_data_len >= 8) || (vsllink_tms_cmd_pos == NULL)) + return ERROR_OK; +} + +// when vsllink_tms_data_len > 0, vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] is the byte that need to be appended. +// length of VSLLINK_CMDJTAGSEQ_TMSBYTE has been set, no need to set it here. +static void vsllink_append_tms(void) +{ + uint8_t tms_scan = VSLLINK_TAP_MOVE(tap_get_state(), tap_get_end_state()); + uint16_t tms2; + insert_insignificant_operation_t *insert = \ + &VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_ndx(tap_get_state())][tap_move_ndx(tap_get_end_state())]; + + if (((tap_get_state() != TAP_RESET) && (tap_get_state() != TAP_IDLE) && (tap_get_state() != TAP_DRPAUSE) && (tap_get_state() != TAP_IRPAUSE)) || \ + (vsllink_tms_data_len <= 0) || (vsllink_tms_data_len >= 8) || \ + (vsllink_tms_cmd_pos == NULL)) { LOG_ERROR("There MUST be some bugs in the driver"); exit(-1); } - tms2 = (tms_scan & VSLLINK_BIT_MSK[VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[1][tap_move_map[state]][1]]) << vsllink_tms_data_len; - if (VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[1][tap_move_map[state]][0] == 1) + tms2 = (tms_scan & VSLLINK_BIT_MSK[insert->insert_position]) << \ + vsllink_tms_data_len; + if (insert->insert_value == 1) { - tms2 |= VSLLINK_BIT_MSK[8 - vsllink_tms_data_len] << (vsllink_tms_data_len + VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[1][tap_move_map[state]][1]); + tms2 |= VSLLINK_BIT_MSK[8 - vsllink_tms_data_len] << \ + (vsllink_tms_data_len + insert->insert_position); } - tms2 |= (tms_scan >> VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[1][tap_move_map[state]][1]) << (8 + VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[1][tap_move_map[state]][1]); + tms2 |= (tms_scan >> insert->insert_position) << \ + (8 + insert->insert_position); vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (tms2 >> 0) & 0xff; vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tms2 >> 8) & 0xff; @@ -532,14 +624,11 @@ void VSLLINK_add_tms_from_RTI(enum tap_state state) vsllink_tms_cmd_pos = NULL; } -/***************************************************************************/ -/* Queue command implementations */ - -void vsllink_end_state(enum tap_state state) +static void vsllink_end_state(tap_state_t state) { - if (tap_move_map[state] != -1) + if (tap_is_state_stable(state)) { - end_state = state; + tap_set_end_state(state); } else { @@ -549,25 +638,71 @@ void vsllink_end_state(enum tap_state state) } /* Goes to the end state. */ -void vsllink_state_move(void) +static void vsllink_state_move_normal(void) { if (vsllink_tms_data_len > 0) { - VSLLINK_add_tms_from_RTI(end_state); + vsllink_append_tms(); } else { vsllink_tap_ensure_space(0, 2); vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE; - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(cur_state, end_state); + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(tap_get_state(), tap_get_end_state()); } - cur_state = end_state; + tap_set_state(tap_get_end_state()); +} +static void vsllink_state_move_dma(void) +{ + int i, insert_length = (tap_length % 8) ? (8 - (tap_length % 8)) : 0; + insert_insignificant_operation_t *insert = \ + &VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_ndx(tap_get_state())][tap_move_ndx(tap_get_end_state())]; + uint8_t tms_scan = VSLLINK_TAP_MOVE(tap_get_state(), tap_get_end_state()); + + if (tap_get_state() == TAP_RESET) + { + vsllink_tap_ensure_space(0, 8); + + for (i = 0; i < 8; i++) + { + vsllink_tap_append_step(1, 0); + } + } + + if (insert_length > 0) + { + vsllink_tap_ensure_space(0, 16); + + for (i = 0; i < insert->insert_position; i++) + { + vsllink_tap_append_step((tms_scan >> i) & 1, 0); + } + for (i = 0; i < insert_length; i++) + { + vsllink_tap_append_step(insert->insert_value, 0); + } + for (i = insert->insert_position; i < 8; i++) + { + vsllink_tap_append_step((tms_scan >> i) & 1, 0); + } + } + else + { + vsllink_tap_ensure_space(0, 8); + + for (i = 0; i < 8; i++) + { + vsllink_tap_append_step((tms_scan >> i) & 1, 0); + } + } + + tap_set_state(tap_get_end_state()); } // write tms from current vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] -void vsllink_add_path(int start, int num, enum tap_state *path) +static void vsllink_add_path(int start, int num, tap_state_t *path) { int i; @@ -577,71 +712,103 @@ void vsllink_add_path(int start, int num, enum tap_state *path) { if (i > 0) { - vsllink_usb_out_buffer[++vsllink_usb_out_buffer_idx] = 0; - } - else - { - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = 0; + vsllink_usb_out_buffer_idx++; } + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = 0; } - if (path[i - start] == tap_transitions[cur_state].high) + if (path[i - start] == tap_state_transition(tap_get_state(), true)) { vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] |= 1 << (i & 7); } + else if (path[i - start] == tap_state_transition(tap_get_state(), false)) + { + // nothing to do + } else { - LOG_ERROR("BUG: %d -> %d isn't a valid TAP transition", cur_state, path[i]); + LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", tap_state_name(tap_get_state()), tap_state_name(path[i])); exit(-1); } - - cur_state = path[i]; + tap_set_state(path[i - start]); + } + if ((i > 0) && ((i & 7) == 0)) + { + vsllink_usb_out_buffer_idx++; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = 0; } - end_state = cur_state; + + tap_set_end_state(tap_get_state()); } -void vsllink_path_move(int num_states, enum tap_state *path) +static void vsllink_path_move_normal(int num_states, tap_state_t *path) { int i, tms_len, tms_cmd_pos, path_idx = 0; if (vsllink_tms_data_len > 0) { - if ((vsllink_tms_data_len + num_states) < 8) + // there are vsllink_tms_data_len more tms bits to be shifted + // so there are vsllink_tms_data_len + num_states tms bits in all + tms_len = vsllink_tms_data_len + num_states; + if (tms_len <= 16) { - vsllink_add_path(vsllink_tms_data_len, num_states, path); - num_states = 0; - } - else if ((vsllink_tms_data_len + num_states) < 16) - { - if ((*vsllink_tms_cmd_pos & VSLLINK_CMDJTAGSEQ_LENMSK) \ - < VSLLINK_CMDJTAGSEQ_LENMSK) + // merge into last tms shift + if (tms_len < 8) { - *vsllink_tms_cmd_pos++; + // just append tms data to the last tms byte vsllink_add_path(vsllink_tms_data_len, num_states, path); } - else + else if (tms_len == 8) { - // need a new VSLLINK_CMDJTAGSEQ_TMSBYTE command - // if vsllink_tms_data_len > 0, length of VSLLINK_CMDJTAGSEQ_TMSBYTE MUST be > 1(tms_len > 2) - *vsllink_tms_cmd_pos--; - vsllink_add_path(vsllink_tms_data_len, 8 - vsllink_tms_data_len, path); - vsllink_usb_out_buffer_idx++; - vsllink_tap_ensure_space(0, 3); - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE | 1; - vsllink_tms_cmd_pos = vsllink_usb_out_buffer + vsllink_usb_out_buffer_idx; - vsllink_add_path(vsllink_tms_data_len, num_states + vsllink_tms_data_len - 8, path + 8 - vsllink_tms_data_len); + // end last tms shift command + (*vsllink_tms_cmd_pos)--; + vsllink_add_path(vsllink_tms_data_len, num_states, path); } + else if (tms_len < 16) + { + if ((*vsllink_tms_cmd_pos & VSLLINK_CMDJTAGSEQ_LENMSK) < VSLLINK_CMDJTAGSEQ_LENMSK) + { + // every tms shift command can contain VSLLINK_CMDJTAGSEQ_LENMSK + 1 bytes in most + // there is enought tms length in the current tms shift command + (*vsllink_tms_cmd_pos)++; + vsllink_add_path(vsllink_tms_data_len, num_states, path); + } + else + { + // every tms shift command can contain VSLLINK_CMDJTAGSEQ_LENMSK + 1 bytes in most + // not enough tms length in the current tms shift command + // so a new command should be added + // first decrease byte length of last tms shift command + (*vsllink_tms_cmd_pos)--; + // append tms data to the last tms byte + vsllink_add_path(vsllink_tms_data_len, 8 - vsllink_tms_data_len, path); + path += 8 - vsllink_tms_data_len; + // add new command(3 bytes) + vsllink_tap_ensure_space(0, 3); + vsllink_tms_cmd_pos = &vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx]; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE | 1; + vsllink_add_path(0, num_states - (8 - vsllink_tms_data_len), path); + } + } + else if (tms_len == 16) + { + // end last tms shift command + vsllink_add_path(vsllink_tms_data_len, num_states, path); + } + vsllink_tms_data_len = (vsllink_tms_data_len + num_states) & 7; + if (vsllink_tms_data_len == 0) + { + vsllink_tms_cmd_pos = NULL; + } num_states = 0; } else { vsllink_add_path(vsllink_tms_data_len, 16 - vsllink_tms_data_len, path); - path_idx = 16 - vsllink_tms_data_len; - vsllink_usb_out_buffer_idx++; - num_states -= 16 - vsllink_tms_data_len; path += 16 - vsllink_tms_data_len; + num_states -= 16 - vsllink_tms_data_len; vsllink_tms_data_len = 0; vsllink_tms_cmd_pos = NULL; } @@ -677,213 +844,353 @@ void vsllink_path_move(int num_states, enum tap_state *path) { if (tms_len < (VSLLINK_CMDJTAGSEQ_LENMSK + 1)) { - vsllink_usb_out_buffer[tms_cmd_pos]++; - vsllink_usb_out_buffer = vsllink_usb_out_buffer + tms_cmd_pos; + vsllink_tms_cmd_pos = &vsllink_usb_out_buffer[tms_cmd_pos]; + (*vsllink_tms_cmd_pos)++; } else { vsllink_usb_out_buffer[tms_cmd_pos]--; + tms_len = vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx]; vsllink_tap_ensure_space(0, 3); + vsllink_tms_cmd_pos = &vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx]; vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE | 1; vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = tms_len; } } } } - -void vsllink_runtest(int num_cycles) +static void vsllink_path_move_dma(int num_states, tap_state_t *path) { - int i = 0, j; - int tms_len, first_tms = 0, tms_cmd_pos = 0; - enum tap_state saved_end_state = end_state; + int i, j = 0; - if (cur_state != TAP_IDLE) + if (tap_length & 7) { - vsllink_end_state(TAP_IDLE); - - if (vsllink_tms_data_len > 0) + if ((8 - (tap_length & 7)) < num_states) { - VSLLINK_add_tms_from_RTI(end_state); + j = 8 - (tap_length & 7); } else { - first_tms = 1; + j = num_states; + } + for (i = 0; i < j; i++) + { + if (path[i] == tap_state_transition(tap_get_state(), false)) + { + vsllink_tap_append_step(0, 0); + } + else if (path[i] == tap_state_transition(tap_get_state(), true)) + { + vsllink_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]); + } + num_states -= j; + } + + if (num_states > 0) + { + vsllink_tap_ensure_space(0, num_states); + + for (i = 0; i < num_states; i++) + { + if (path[j + i] == tap_state_transition(tap_get_state(), false)) + { + vsllink_tap_append_step(0, 0); + } + else if (path[j + i] == tap_state_transition(tap_get_state(), true)) + { + vsllink_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[j + i]); } } + tap_set_end_state(tap_get_state()); +} + +static void vsllink_stableclocks_normal(int num_cycles, int tms) +{ + int tms_len; + uint16_t tms_append_byte; + if (vsllink_tms_data_len > 0) { - // cur_state == TAP_IDLE - if ((vsllink_tms_data_len + num_cycles) < 8) + // there are vsllink_tms_data_len more tms bits to be shifted + // so there are vsllink_tms_data_len + num_cycles tms bits in all + tms_len = vsllink_tms_data_len + num_cycles; + if (tms > 0) { - vsllink_tms_data_len += num_cycles; - num_cycles = 0; + // append '1' for tms + tms_append_byte = (uint16_t)((((1 << num_cycles) - 1) << vsllink_tms_data_len) & 0xFFFF); } - else if ((vsllink_tms_data_len + num_cycles) < 16) + else + { + // append '0' for tms + tms_append_byte = 0; + } + if (tms_len <= 16) { - if ((*vsllink_tms_cmd_pos & VSLLINK_CMDJTAGSEQ_LENMSK) \ - < VSLLINK_CMDJTAGSEQ_LENMSK) + // merge into last tms shift + if (tms_len < 8) { - *vsllink_tms_cmd_pos++; - vsllink_usb_out_buffer[++vsllink_usb_out_buffer_idx] = 0; + // just add to vsllink_tms_data_len + // same result if tun through + //vsllink_tms_data_len += num_cycles; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] |= (uint8_t)(tms_append_byte & 0xFF); } - else + else if (tms_len == 8) { - // need a new VSLLINK_CMDJTAGSEQ_TMSBYTE command - // if vsllink_tms_data_len > 0, length of VSLLINK_CMDJTAGSEQ_TMSBYTE MUST be > 1(tms_len > 2) - *vsllink_tms_cmd_pos--; - vsllink_tap_ensure_space(0, 3); - vsllink_usb_out_buffer[++vsllink_usb_out_buffer_idx] = VSLLINK_CMDJTAGSEQ_TMSBYTE | 1; - vsllink_tms_cmd_pos = vsllink_usb_out_buffer + vsllink_usb_out_buffer_idx; - vsllink_usb_out_buffer[++vsllink_usb_out_buffer_idx] = 0; + // end last tms shift command + // just reduce it, and append last tms byte + (*vsllink_tms_cmd_pos)--; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (uint8_t)(tms_append_byte & 0xFF); + } + else if (tms_len < 16) + { + if ((*vsllink_tms_cmd_pos & VSLLINK_CMDJTAGSEQ_LENMSK) < VSLLINK_CMDJTAGSEQ_LENMSK) + { + // every tms shift command can contain VSLLINK_CMDJTAGSEQ_LENMSK + 1 bytes in most + // there is enought tms length in the current tms shift command + // increase the tms byte length by 1 and set the last byte to 0 + (*vsllink_tms_cmd_pos)++; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (uint8_t)(tms_append_byte & 0xFF); + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = (uint8_t)(tms_append_byte >> 8); + } + else + { + // every tms shift command can contain VSLLINK_CMDJTAGSEQ_LENMSK + 1 bytes in most + // not enough tms length in the current tms shift command + // so a new command should be added + // first decrease byte length of last tms shift command + (*vsllink_tms_cmd_pos)--; + // append last tms byte and move the command pointer to the next empty position + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (uint8_t)(tms_append_byte & 0xFF); + // add new command(3 bytes) + vsllink_tap_ensure_space(0, 3); + vsllink_tms_cmd_pos = &vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx]; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE | 1; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = (uint8_t)(tms_append_byte >> 8); + } + } + else if (tms_len == 16) + { + // end last tms shift command + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (uint8_t)(tms_append_byte & 0xFF); + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (uint8_t)(tms_append_byte >> 8); + } + + vsllink_tms_data_len = tms_len & 7; + if (vsllink_tms_data_len == 0) + { + vsllink_tms_cmd_pos = NULL; } - vsllink_tms_data_len = (vsllink_tms_data_len + num_cycles) & 7; num_cycles = 0; } else { - vsllink_usb_out_buffer[++vsllink_usb_out_buffer_idx] = 0; - vsllink_usb_out_buffer_idx++; + // more shifts will be needed + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (uint8_t)(tms_append_byte & 0xFF); + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (uint8_t)(tms_append_byte >> 8); num_cycles -= 16 - vsllink_tms_data_len; vsllink_tms_data_len = 0; vsllink_tms_cmd_pos = NULL; } } + // from here vsllink_tms_data_len == 0 or num_cycles == 0 - tms_len = ((num_cycles + 7) >> 3) + first_tms; - if (tms_len > 0) + if (vsllink_tms_data_len > 0) { - // Normal operation, don't need to append tms data - vsllink_tms_data_len = num_cycles & 7; - - if (vsllink_tms_data_len > 0) + // num_cycles == 0 + // no need to shift + if (num_cycles > 0) { - tms_len += 1; + LOG_ERROR("There MUST be some bugs in the driver"); + exit(-1); } - // tms_len includes the length of tms byte to append - - // Make sure there is enough space - // 1 more byte maybe needed for the last tms move - vsllink_tap_ensure_space(0, (tms_len / VSLLINK_CMDJTAGSEQ_LENMSK) + tms_len + 1); - - while(tms_len > 0) + } + else + { + // get number of bytes left to be sent + tms_len = num_cycles >> 3; + if (tms_len > 0) { - if (tms_len > (VSLLINK_CMDJTAGSEQ_LENMSK + 1)) + vsllink_tap_ensure_space(1, 5); + // if tms_len > 0, vsllink_tms_data_len == 0 + // so just add new command + // LSB of the command byte is the tms value when do the shifting + if (tms > 0) { - i = VSLLINK_CMDJTAGSEQ_LENMSK + 1; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSCLOCK | 1; } else { - i = tms_len; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSCLOCK; } + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tms_len >> 0) & 0xff; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tms_len >> 8) & 0xff; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tms_len >> 16) & 0xff; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tms_len >> 24) & 0xff; - tms_cmd_pos = vsllink_usb_out_buffer_idx; - - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE | (i - 1); + vsllink_usb_in_want_length += 1; + pending_scan_results_buffer[pending_scan_results_length].buffer = NULL; + pending_scan_results_length++; - if (first_tms) + if (tms_len > 0xFFFF) { - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(cur_state, end_state); - first_tms = 0; - j = i - 1; - } - else - { - j = i; - } - - while (j-- > 0) - { - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0; + vsllink_tap_execute(); } - - tms_len -= i; } - // post process vsllink_usb_out_buffer_idx + // post-process + vsllink_tms_data_len = num_cycles & 7; if (vsllink_tms_data_len > 0) { - vsllink_usb_out_buffer_idx -= 2; - } - - // Set end_state - vsllink_end_state(saved_end_state); - cur_state = TAP_IDLE; - if (saved_end_state != TAP_IDLE) - { - if (vsllink_tms_data_len > 0) + vsllink_tap_ensure_space(0, 3); + vsllink_tms_cmd_pos = &vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx]; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE | 1; + if (tms > 0) { - VSLLINK_add_tms_from_RTI(end_state); + // append '1' for tms + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = (1 << vsllink_tms_data_len) - 1; } else { - if (i < (VSLLINK_CMDJTAGSEQ_LENMSK + 1)) - { - vsllink_usb_out_buffer[tms_cmd_pos]++; - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(TAP_IDLE, end_state); - } - else - { - vsllink_tap_ensure_space(0, 2); - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE; - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(TAP_IDLE, end_state); - } + // append '0' for tms + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = 0x00; } - cur_state = saved_end_state; } + } +} +static void vsllink_stableclocks_dma(int num_cycles, int tms) +{ + int i, cur_cycles; - if (vsllink_tms_data_len > 0) + if (tap_length & 7) + { + if ((8 - (tap_length & 7)) < num_cycles) + { + cur_cycles = 8 - (tap_length & 7); + } + else + { + cur_cycles = num_cycles; + } + for (i = 0; i < cur_cycles; i++) { - vsllink_tms_cmd_pos = vsllink_usb_out_buffer + tms_cmd_pos; + vsllink_tap_append_step(tms, 0); } + num_cycles -= cur_cycles; } - else + + while (num_cycles > 0) { - // Set end_state if no RTI shifts - vsllink_end_state(saved_end_state); - cur_state = TAP_IDLE; - if (saved_end_state != TAP_IDLE) + if (num_cycles > 8 * tap_buffer_size) + { + cur_cycles = 8 * tap_buffer_size; + } + else { - vsllink_tap_ensure_space(0, 2); - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_TMSBYTE; - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(TAP_IDLE, end_state); + cur_cycles = num_cycles; + } + + vsllink_tap_ensure_space(0, cur_cycles); - cur_state = saved_end_state; + for (i = 0; i < cur_cycles; i++) + { + vsllink_tap_append_step(tms, 0); } + + num_cycles -= cur_cycles; + } +} + +static void vsllink_runtest(int num_cycles) +{ + tap_state_t saved_end_state = tap_get_end_state(); + + if (tap_get_state() != TAP_IDLE) + { + // enter into IDLE state + vsllink_end_state(TAP_IDLE); + vsllink_state_move(); + } + + vsllink_stableclocks(num_cycles, 0); + + // post-process + // set end_state + vsllink_end_state(saved_end_state); + tap_set_state(TAP_IDLE); + if (tap_get_end_state() != TAP_IDLE) + { + vsllink_state_move(); } } -void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, scan_command_t *command) +static void vsllink_scan_normal(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command) { - enum tap_state saved_end_state; - u8 bits_left, tms_tmp, tdi_len; + tap_state_t saved_end_state; + uint8_t bits_left, tms_tmp, tdi_len; int i; + if (0 == scan_size) + { + return; + } + tdi_len = ((scan_size + 7) >> 3); if ((tdi_len + 7) > VSLLINK_BufferSize) { LOG_ERROR("Your implementation of VSLLink has not enough buffer"); exit(-1); } - - saved_end_state = end_state; - + + saved_end_state = tap_get_end_state(); + /* Move to appropriate scan state */ vsllink_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT); if (vsllink_tms_data_len > 0) { - if (cur_state == end_state) + if (tap_get_state() == tap_get_end_state()) { - *vsllink_tms_cmd_pos--; - tms_tmp = vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx]; - vsllink_tap_ensure_space(1, tdi_len + 7); + // already in IRSHIFT or DRSHIFT state + // merge tms data in the last tms shift command into next scan command + if (*vsllink_tms_cmd_pos < 1) + { + LOG_ERROR("There MUST be some bugs in the driver"); + exit(-1); + } + else if (*vsllink_tms_cmd_pos < 2) + { + tms_tmp = vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx]; + vsllink_usb_out_buffer_idx--; + } + else + { + tms_tmp = vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx]; + *vsllink_tms_cmd_pos -= 2; + } + vsllink_tap_ensure_space(1, tdi_len + 7); + // VSLLINK_CMDJTAGSEQ_SCAN ored by 1 means that tms_before is valid + // which is merged from the last tms shift command vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_SCAN | 1; vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1) >> 0) & 0xff; - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1)>> 8) & 0xff; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1) >> 8) & 0xff; vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = tms_tmp; vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = buffer[0] << (8 - vsllink_tms_data_len); @@ -896,19 +1203,20 @@ void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, s } } - vsllink_tap_append_scan(scan_size - vsllink_tms_data_len, buffer, command, vsllink_tms_data_len); + vsllink_tap_append_scan_normal(scan_size - vsllink_tms_data_len, buffer, command, vsllink_tms_data_len); scan_size -= 8 - vsllink_tms_data_len; + vsllink_tms_data_len = 0; } else { - VSLLINK_add_tms_from_RTI(end_state); + vsllink_state_move(); vsllink_tap_ensure_space(1, tdi_len + 5); vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_SCAN; vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tdi_len >> 0) & 0xff; vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (tdi_len >> 8) & 0xff; - vsllink_tap_append_scan(scan_size, buffer, command, 0); + vsllink_tap_append_scan_normal(scan_size, buffer, command, 0); } } else @@ -918,15 +1226,15 @@ void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, s vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_CMDJTAGSEQ_SCAN | 1; vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1) >> 0) & 0xff; vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = ((tdi_len + 1)>> 8) & 0xff; - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(cur_state, end_state); + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(tap_get_state(), tap_get_end_state()); vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0; - vsllink_tap_append_scan(scan_size, buffer, command, 8); + vsllink_tap_append_scan_normal(scan_size, buffer, command, 8); } vsllink_end_state(saved_end_state); bits_left = scan_size & 0x07; - cur_state = ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE; + tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE); if (bits_left > 0) { @@ -937,24 +1245,51 @@ void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, s vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 1 << 7; } - if (cur_state != end_state) + if (tap_get_state() != tap_get_end_state()) { - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE_FROM_E1[tap_move_map[end_state]]; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = VSLLINK_TAP_MOVE(tap_get_state(), tap_get_end_state()); } else { vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0; } - cur_state = end_state; + tap_set_state(tap_get_end_state()); +} +static void vsllink_scan_dma(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, scan_command_t *command) +{ + tap_state_t saved_end_state; + + saved_end_state = tap_get_end_state(); + + /* Move to appropriate scan state */ + vsllink_end_state(ir_scan ? TAP_IRSHIFT : TAP_DRSHIFT); + + vsllink_state_move(); + vsllink_end_state(saved_end_state); + + /* Scan */ + vsllink_tap_append_scan_dma(scan_size, buffer, command); + + tap_set_state(ir_scan ? TAP_IRPAUSE : TAP_DRPAUSE); + while (tap_length % 8 != 0) + { + // more 0s in Pause + vsllink_tap_append_step(0, 0); + } + + if (tap_get_state() != tap_get_end_state()) + { + vsllink_state_move(); + } } -void vsllink_reset(int trst, int srst) +static void vsllink_reset(int trst, int srst) { int result; LOG_DEBUG("trst: %i, srst: %i", trst, srst); - + /* Signals are active low */ vsllink_usb_out_buffer[0] = VSLLINK_CMD_SET_PORT; vsllink_usb_out_buffer[1] = JTAG_PINMSK_SRST | JTAG_PINMSK_TRST; @@ -975,106 +1310,183 @@ void vsllink_reset(int trst, int srst) } } -void vsllink_simple_command(u8 command) +static void vsllink_simple_command(uint8_t command) { int result; - + DEBUG_JTAG_IO("0x%02x", command); - + vsllink_usb_out_buffer[0] = command; result = vsllink_usb_write(vsllink_jtag_handle, 1); - + if (result != 1) { LOG_ERROR("VSLLink command 0x%02x failed (%d)", command, result); } } -int vsllink_handle_usb_vid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(vsllink_handle_mode_command) { if (argc != 1) { - LOG_ERROR("parameter error, should be one parameter for VID"); - return ERROR_OK; + LOG_ERROR("parameter error, should be one parameter for VID"); + return ERROR_FAIL; } - vsllink_vid = strtol(args[0], NULL, 0); + if (!strcmp(args[0], "normal")) + { + vsllink_mode = VSLLINK_MODE_NORMAL; + } + else if (!strcmp(args[0], "dma")) + { + vsllink_mode = VSLLINK_MODE_DMA; + } + else + { + LOG_ERROR("invalid vsllink_mode: %s", args[0]); + return ERROR_FAIL; + } return ERROR_OK; } -int vsllink_handle_usb_pid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(vsllink_handle_usb_vid_command) { - if (argc != 1) { - LOG_ERROR("parameter error, should be one parameter for PID"); + if (argc != 1) + { + LOG_ERROR("parameter error, should be one parameter for VID"); return ERROR_OK; } - vsllink_pid = strtol(args[0], NULL, 0); + COMMAND_PARSE_NUMBER(u16, args[0], vsllink_usb_vid); + return ERROR_OK; +} +COMMAND_HANDLER(vsllink_handle_usb_pid_command) +{ + if (argc != 1) + { + LOG_ERROR("parameter error, should be one parameter for PID"); + return ERROR_OK; + } + COMMAND_PARSE_NUMBER(u16, args[0], vsllink_usb_pid); return ERROR_OK; } -int vsllink_handle_usb_bulkin_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(vsllink_handle_usb_bulkin_command) { - if (argc != 1) { - LOG_ERROR("parameter error, should be one parameter for BULKIN endpoint"); + if (argc != 1) + { + LOG_ERROR("parameter error, should be one parameter for BULKIN endpoint"); return ERROR_OK; } - vsllink_bulkin = strtol(args[0], NULL, 0) | 0x80; + COMMAND_PARSE_NUMBER(u8, args[0], vsllink_usb_bulkin); + + vsllink_usb_bulkin |= 0x80; return ERROR_OK; } -int vsllink_handle_usb_bulkout_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +COMMAND_HANDLER(vsllink_handle_usb_bulkout_command) { - if (argc != 1) { - LOG_ERROR("parameter error, should be one parameter for BULKOUT endpoint"); + if (argc != 1) + { + LOG_ERROR("parameter error, should be one parameter for BULKOUT endpoint"); return ERROR_OK; } - vsllink_bulkout = strtol(args[0], NULL, 0); + COMMAND_PARSE_NUMBER(u8, args[0], vsllink_usb_bulkout); + + vsllink_usb_bulkout &= ~0x80; return ERROR_OK; } -/***************************************************************************/ -/* VSLLink tap functions */ - -typedef struct +COMMAND_HANDLER(vsllink_handle_usb_interface_command) { - int length; /* Number of bits to read */ - int offset; - scan_command_t *command; /* Corresponding scan command */ - u8 *buffer; -} pending_scan_result_t; + if (argc != 1) + { + LOG_ERROR("parameter error, should be one parameter for interface number"); + return ERROR_OK; + } -#define MAX_PENDING_SCAN_RESULTS 256 + COMMAND_PARSE_NUMBER(u8, args[0], vsllink_usb_interface); + return ERROR_OK; +} -static int pending_scan_results_length; -static pending_scan_result_t pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS]; +/***************************************************************************/ +/* VSLLink tap functions */ -void vsllink_tap_init(void) +static void vsllink_tap_init_normal(void) { vsllink_usb_out_buffer_idx = 0; vsllink_usb_in_want_length = 0; pending_scan_results_length = 0; } +static void vsllink_tap_init_dma(void) +{ + tap_length = 0; + pending_scan_results_length = 0; +} -void vsllink_tap_ensure_space(int scans, int bytes) +static void vsllink_tap_ensure_space_normal(int scans, int length) { int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length; int available_bytes = VSLLINK_BufferSize - vsllink_usb_out_buffer_idx; - - if (scans > available_scans || bytes > available_bytes) + + if (scans > available_scans || length > available_bytes) { vsllink_tap_execute(); - vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_JTAGSEQCMD; - vsllink_usb_out_buffer_idx = 3; + } +} +static void vsllink_tap_ensure_space_dma(int scans, int length) +{ + int available_scans = MAX_PENDING_SCAN_RESULTS - pending_scan_results_length; + int available_bytes = tap_buffer_size * 8 - tap_length; + + if (scans > available_scans || length > available_bytes) + { + vsllink_tap_execute(); + } +} + +static void vsllink_tap_append_step(int tms, int tdi) +{ + last_tms = tms; + int index = tap_length / 8; + + if (index < tap_buffer_size) + { + int bit_index = tap_length % 8; + uint8_t bit = 1 << bit_index; + + if (tms) + { + tms_buffer[index] |= bit; + } + else + { + tms_buffer[index] &= ~bit; + } + + if (tdi) + { + tdi_buffer[index] |= bit; + } + else + { + tdi_buffer[index] &= ~bit; + } + + tap_length++; + } + else + { + LOG_ERROR("buffer overflow, tap_length=%d", tap_length); } } -void vsllink_tap_append_scan(int length, u8 *buffer, scan_command_t *command, int offset) +static void vsllink_tap_append_scan_normal(int length, uint8_t *buffer, scan_command_t *command, int offset) { pending_scan_result_t *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length]; int i; @@ -1099,10 +1511,44 @@ void vsllink_tap_append_scan(int length, u8 *buffer, scan_command_t *command, in pending_scan_results_length++; } +static void vsllink_tap_append_scan_dma(int length, uint8_t *buffer, scan_command_t *command) +{ + pending_scan_result_t *pending_scan_result; + int len_tmp, len_all, i; + + len_all = 0; + while (len_all < length) + { + if ((length - len_all) > tap_buffer_size * 8) + { + len_tmp = tap_buffer_size * 8; + } + else + { + len_tmp = length - len_all; + } + + vsllink_tap_ensure_space(1, (len_tmp + 7) & ~7); + + pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length]; + pending_scan_result->offset = tap_length; + pending_scan_result->length = len_tmp; + pending_scan_result->command = command; + pending_scan_result->buffer = buffer + len_all / 8; + + for (i = 0; i < len_tmp; i++) + { + vsllink_tap_append_step(((len_all + i) < length-1 ? 0 : 1), (buffer[(len_all + i)/8] >> ((len_all + i)%8)) & 1); + } + + pending_scan_results_length++; + len_all += len_tmp; + } +} /* 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 vsllink_tap_execute(void) + * For the purpose of padding we assume that we are in reset or idle or pause state. */ +static int vsllink_tap_execute_normal(void) { int i; int result; @@ -1110,13 +1556,17 @@ int vsllink_tap_execute(void) if (vsllink_tms_data_len > 0) { + if ((tap_get_state() != TAP_RESET) && (tap_get_state() != TAP_IDLE) && (tap_get_state() != TAP_IRPAUSE) && (tap_get_state() != TAP_DRPAUSE)) + { + LOG_WARNING("%s is not in RESET or IDLE or PAUSR state", tap_state_name(tap_get_state())); + } + if (vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] & (1 << (vsllink_tms_data_len - 1))) { // last tms bit is '1' - // the only possible state is TLR, no need to control the number of shifts in RLT - // There MUST be some errors in the code - LOG_ERROR("last tms bit is '1'"); - exit(-1); + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= 0xFF << vsllink_tms_data_len; + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = 0xFF; + vsllink_tms_data_len = 0; } else { @@ -1126,7 +1576,7 @@ int vsllink_tap_execute(void) vsllink_tms_data_len = 0; } } - + if (vsllink_usb_out_buffer_idx > 3) { if (vsllink_usb_out_buffer[0] == VSLLINK_CMD_HW_JTAGSEQCMD) @@ -1136,22 +1586,93 @@ int vsllink_tap_execute(void) } result = vsllink_usb_message(vsllink_jtag_handle, vsllink_usb_out_buffer_idx, vsllink_usb_in_want_length); - + if (result == vsllink_usb_in_want_length) { for (i = 0; i < pending_scan_results_length; i++) { pending_scan_result_t *pending_scan_result = &pending_scan_results_buffer[i]; - u8 *buffer = pending_scan_result->buffer; + uint8_t *buffer = pending_scan_result->buffer; int length = pending_scan_result->length; int offset = pending_scan_result->offset; scan_command_t *command = pending_scan_result->command; - - /* Copy to buffer */ - buf_set_buf(vsllink_usb_in_buffer, first * 8 + offset, buffer, 0, length); - first += (length + offset + 7) >> 3; - - DEBUG_JTAG_IO("JTAG scan read(%d bits):", length); + + if (buffer != NULL) + { + // IRSHIFT or DRSHIFT + buf_set_buf(vsllink_usb_in_buffer, first * 8 + offset, buffer, 0, length); + first += (length + offset + 7) >> 3; + + DEBUG_JTAG_IO("JTAG scan read(%d bits):", length); +#ifdef _DEBUG_JTAG_IO_ + vsllink_debug_buffer(buffer, (length + 7) >> 3); +#endif + + if (jtag_read_buffer(buffer, command) != ERROR_OK) + { + vsllink_tap_init(); + return ERROR_JTAG_QUEUE_FAILED; + } + + free(pending_scan_result->buffer); + pending_scan_result->buffer = NULL; + } + else + { + first++; + } + } + } + else + { + LOG_ERROR("vsllink_tap_execute, wrong result %d, expected %d", result, vsllink_usb_in_want_length); + return ERROR_JTAG_QUEUE_FAILED; + } + + vsllink_tap_init(); + } + reset_command_pointer(); + + return ERROR_OK; +} +static int vsllink_tap_execute_dma(void) +{ + int byte_length; + int i; + int result; + + if (tap_length > 0) + { + /* Pad last byte so that tap_length is divisible by 8 */ + while (tap_length % 8 != 0) + { + /* More of the last TMS value keeps us in the same state, + * analogous to free-running JTAG interfaces. */ + vsllink_tap_append_step(last_tms, 0); + } + byte_length = tap_length / 8; + + vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_JTAGRAWCMD; + vsllink_usb_out_buffer[1] = ((byte_length * 2 + 3) >> 0) & 0xff; // package size + vsllink_usb_out_buffer[2] = ((byte_length * 2 + 3) >> 8) & 0xff; + + memcpy(&vsllink_usb_out_buffer[3], tdi_buffer, byte_length); + memcpy(&vsllink_usb_out_buffer[3 + byte_length], tms_buffer, byte_length); + + result = vsllink_usb_message(vsllink_jtag_handle, 3 + 2 * byte_length, byte_length); + if (result == byte_length) + { + for (i = 0; i < pending_scan_results_length; i++) + { + pending_scan_result_t *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->offset; + + scan_command_t *command = pending_scan_result->command; + buf_set_buf(vsllink_usb_in_buffer, first, buffer, 0, length); + + DEBUG_JTAG_IO("JTAG scan read(%d bits, from %d bits):", length, first); #ifdef _DEBUG_JTAG_IO_ vsllink_debug_buffer(buffer, (length + 7) >> 3); #endif @@ -1161,93 +1682,123 @@ int vsllink_tap_execute(void) vsllink_tap_init(); return ERROR_JTAG_QUEUE_FAILED; } - + if (pending_scan_result->buffer != NULL) { free(pending_scan_result->buffer); - pending_scan_result->buffer = NULL; } } } else { - LOG_ERROR("vsllink_tap_execute, wrong result %d, expected %d", result, vsllink_usb_in_want_length); + LOG_ERROR("vsllink_tap_execute, wrong result %d, expected %d", result, byte_length); return ERROR_JTAG_QUEUE_FAILED; } - + vsllink_tap_init(); } - + return ERROR_OK; } /*****************************************************************************/ /* VSLLink USB low-level functions */ -vsllink_jtag_t* vsllink_usb_open(void) +static vsllink_jtag_t* vsllink_usb_open(void) { struct usb_bus *busses; struct usb_bus *bus; struct usb_device *dev; - + int ret; + vsllink_jtag_t *result; - + result = (vsllink_jtag_t*) malloc(sizeof(vsllink_jtag_t)); - + usb_init(); usb_find_busses(); usb_find_devices(); - + busses = usb_get_busses(); - + /* find vsllink_jtag device in usb bus */ - + for (bus = busses; bus; bus = bus->next) { for (dev = bus->devices; dev; dev = dev->next) { - if ((dev->descriptor.idVendor == vsllink_vid) && (dev->descriptor.idProduct == vsllink_pid)) + if ((dev->descriptor.idVendor == vsllink_usb_vid) && (dev->descriptor.idProduct == vsllink_usb_pid)) { result->usb_handle = usb_open(dev); - + if (NULL == result->usb_handle) + { + LOG_ERROR("failed to open %04X:%04X, not enough permissions?", vsllink_usb_vid, vsllink_usb_pid); + exit(-1); + } + /* usb_set_configuration required under win32 */ - usb_set_configuration(result->usb_handle, dev->config[0].bConfigurationValue); - usb_claim_interface(result->usb_handle, 0); - + ret = usb_set_configuration(result->usb_handle, dev->config[0].bConfigurationValue); + if (ret != 0) + { + LOG_ERROR("fail to set configuration to %d, %d returned, not enough permissions?", dev->config[0].bConfigurationValue, ret); + exit(-1); + } + ret = usb_claim_interface(result->usb_handle, vsllink_usb_interface); + if (ret != 0) + { + LOG_ERROR("fail to claim interface %d, %d returned", vsllink_usb_interface, ret); + exit(-1); + } + #if 0 - /* + /* * This makes problems under Mac OS X. And is not needed * under Windows. Hopefully this will not break a linux build */ usb_set_altinterface(result->usb_handle, 0); -#endif +#endif return result; } } } - + free(result); return NULL; } -void vsllink_usb_close(vsllink_jtag_t *vsllink_jtag) +static void vsllink_usb_close(vsllink_jtag_t *vsllink_jtag) { - usb_close(vsllink_jtag->usb_handle); + int ret; + + ret = usb_release_interface(vsllink_jtag->usb_handle, vsllink_usb_interface); + if (ret != 0) + { + LOG_ERROR("fail to release interface %d, %d returned", vsllink_usb_interface, ret); + exit(-1); + } + + ret = usb_close(vsllink_jtag->usb_handle); + if (ret != 0) + { + LOG_ERROR("fail to close usb, %d returned", ret); + exit(-1); + } + free(vsllink_jtag); } /* Send a message and receive the reply. */ -int vsllink_usb_message(vsllink_jtag_t *vsllink_jtag, int out_length, int in_length) +static int vsllink_usb_message(vsllink_jtag_t *vsllink_jtag, int out_length, int in_length) { int result; - + result = vsllink_usb_write(vsllink_jtag, out_length); if (result == out_length) { if (in_length > 0) { result = vsllink_usb_read(vsllink_jtag); - if (result == in_length ) + if (result == in_length) { return result; } @@ -1267,21 +1818,21 @@ int vsllink_usb_message(vsllink_jtag_t *vsllink_jtag, int out_length, int in_len } /* Write data from out_buffer to USB. */ -int vsllink_usb_write(vsllink_jtag_t *vsllink_jtag, int out_length) +static int vsllink_usb_write(vsllink_jtag_t *vsllink_jtag, int out_length) { int result; - + if (out_length > VSLLINK_BufferSize) { LOG_ERROR("vsllink_jtag_write illegal out_length=%d (max=%d)", out_length, VSLLINK_BufferSize); return -1; } - - result = usb_bulk_write(vsllink_jtag->usb_handle, vsllink_bulkout, \ + + result = usb_bulk_write(vsllink_jtag->usb_handle, vsllink_usb_bulkout, \ (char *)vsllink_usb_out_buffer, out_length, VSLLINK_USB_TIMEOUT); - + DEBUG_JTAG_IO("vsllink_usb_write, out_length = %d, result = %d", out_length, result); - + #ifdef _DEBUG_USB_COMMS_ LOG_DEBUG("USB out:"); vsllink_debug_buffer(vsllink_usb_out_buffer, out_length); @@ -1295,13 +1846,13 @@ int vsllink_usb_write(vsllink_jtag_t *vsllink_jtag, int out_length) } /* Read data from USB into in_buffer. */ -int vsllink_usb_read(vsllink_jtag_t *vsllink_jtag) +static int vsllink_usb_read(vsllink_jtag_t *vsllink_jtag) { - int result = usb_bulk_read(vsllink_jtag->usb_handle, vsllink_bulkin, \ + int result = usb_bulk_read(vsllink_jtag->usb_handle, vsllink_usb_bulkin, \ (char *)vsllink_usb_in_buffer, VSLLINK_BufferSize, VSLLINK_USB_TIMEOUT); DEBUG_JTAG_IO("vsllink_usb_read, result = %d", result); - + #ifdef _DEBUG_USB_COMMS_ LOG_DEBUG("USB in:"); vsllink_debug_buffer(vsllink_usb_in_buffer, result); @@ -1311,13 +1862,14 @@ int vsllink_usb_read(vsllink_jtag_t *vsllink_jtag) #define BYTES_PER_LINE 16 -void vsllink_debug_buffer(u8 *buffer, int length) +#if defined _DEBUG_USB_COMMS_ || defined _DEBUG_JTAG_IO_ +static void vsllink_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); @@ -1326,6 +1878,42 @@ void vsllink_debug_buffer(u8 *buffer, int length) snprintf(s, 4, " %02x", buffer[j]); strcat(line, s); } - LOG_DEBUG(line); + LOG_DEBUG("%s", line); } } +#endif // _DEBUG_USB_COMMS_ || _DEBUG_JTAG_IO_ + +static int vsllink_register_commands(struct command_context_s *cmd_ctx) +{ + register_command(cmd_ctx, NULL, "vsllink_usb_vid", + vsllink_handle_usb_vid_command, COMMAND_CONFIG, + NULL); + register_command(cmd_ctx, NULL, "vsllink_usb_pid", + vsllink_handle_usb_pid_command, COMMAND_CONFIG, + NULL); + register_command(cmd_ctx, NULL, "vsllink_usb_bulkin", + vsllink_handle_usb_bulkin_command, COMMAND_CONFIG, + NULL); + register_command(cmd_ctx, NULL, "vsllink_usb_bulkout", + vsllink_handle_usb_bulkout_command, COMMAND_CONFIG, + NULL); + register_command(cmd_ctx, NULL, "vsllink_usb_interface", + vsllink_handle_usb_interface_command, COMMAND_CONFIG, + NULL); + register_command(cmd_ctx, NULL, "vsllink_mode", + vsllink_handle_mode_command, COMMAND_CONFIG, + NULL); + + return ERROR_OK; +} + +jtag_interface_t vsllink_interface = { + .name = "vsllink", + .register_commands = &vsllink_register_commands, + .init = &vsllink_init, + .quit = &vsllink_quit, + .khz = &vsllink_khz, + .speed = &vsllink_speed, + .speed_div = &vsllink_speed_div, + .execute_queue = &vsllink_execute_queue, + };