X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fvsllink.c;h=56f92abe9ffa329c8fc3839d336399009c0dc943;hp=7c2244434eb86371ad4e043cd5130c5177ae742c;hb=f90d8fa45f2d4c9d4b7990f198b232ee55cbb4e1;hpb=44a7b25487d2fecc978bafbdd7e7e06d0f1304b2 diff --git a/src/jtag/vsllink.c b/src/jtag/vsllink.c index 7c2244434e..56f92abe9f 100644 --- a/src/jtag/vsllink.c +++ b/src/jtag/vsllink.c @@ -26,43 +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 - -u16 vsllink_vid; -u16 vsllink_pid; -u8 vsllink_bulkout; -u8 vsllink_bulkin; +#define VSLLINK_MODE_NORMAL 0 +#define VSLLINK_MODE_DMA 1 -#define VSLLINK_USB_TIMEOUT 10000 +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 @@ -74,6 +63,7 @@ static u8* vsllink_usb_out_buffer = NULL; #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 @@ -92,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 @@ -101,18 +91,18 @@ 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, 0x7f, 0x2f, 0x0a, 0x37, 0x16}, /* TLR */ {0xff, 0x00, 0x45, 0x05, 0x4b, 0x0b}, /* RTI */ {0xff, 0x61, 0x00, 0x01, 0x0f, 0x2f}, /* SD */ - {0xff, 0x60, 0x40, 0x5c, 0x3c, 0x5e}, /* PD */ + {0xfe, 0x60, 0x40, 0x5c, 0x3c, 0x5e}, /* PD */ {0xff, 0x61, 0x07, 0x17, 0x00, 0x01}, /* SI */ - {0xff, 0x60, 0x38, 0x5c, 0x40, 0x5e} /* PI */ + {0xfe, 0x60, 0x38, 0x5c, 0x40, 0x5e} /* PI */ }; typedef struct insert_insignificant_operation @@ -121,7 +111,7 @@ typedef struct insert_insignificant_operation unsigned char insert_position; }insert_insignificant_operation_t; -insert_insignificant_operation_t VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[6][6] = +static insert_insignificant_operation_t VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[6][6] = { /* stuff offset */ {/* TLR */ @@ -168,17 +158,17 @@ insert_insignificant_operation_t VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[6][6] = {0, 0,}}, /* PI */ }; -u8 VSLLINK_BIT_MSK[8] = +static uint8_t VSLLINK_BIT_MSK[8] = { 0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f }; typedef struct { - int length; /* Number of bits to read */ int offset; + int length; /* Number of bits to read */ scan_command_t *command; /* Corresponding scan command */ - u8 *buffer; + uint8_t *buffer; } pending_scan_result_t; #define MAX_PENDING_SCAN_RESULTS 256 @@ -187,35 +177,55 @@ static int pending_scan_results_length; static pending_scan_result_t pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS]; /* 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); +static int vsllink_execute_queue(void); +static int vsllink_speed(int speed); +static int vsllink_khz(int khz, int *jtag_speed); +static int vsllink_speed_div(int jtag_speed, int *khz); +static int vsllink_register_commands(struct command_context_s *cmd_ctx); +static int vsllink_init(void); +static 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); +static int vsllink_handle_usb_vid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int vsllink_handle_usb_pid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int vsllink_handle_usb_bulkin_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int vsllink_handle_usb_bulkout_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int vsllink_handle_usb_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); +static int vsllink_handle_mode_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc); /* 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_stableclocks(int num_cycles, int tms); -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 @@ -223,18 +233,27 @@ 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 static int vsllink_tms_data_len = 0; -static u8* vsllink_tms_cmd_pos; +static uint8_t* vsllink_tms_cmd_pos; + +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; -vsllink_jtag_t* vsllink_jtag_handle; +static vsllink_jtag_t* vsllink_jtag_handle = NULL; /***************************************************************************/ /* External interface implementation */ @@ -251,73 +270,67 @@ jtag_interface_t vsllink_interface = .quit = vsllink_quit }; -int vsllink_execute_queue(void) +static void reset_command_pointer(void) +{ + 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; + } +} + +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("--------------------------------- 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: %s", jtag_state_name(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 %s", cmd->cmd.runtest->num_cycles, \ - jtag_state_name(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)); - if (cmd->cmd.runtest->end_state != -1) - { - vsllink_end_state(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 %s", jtag_state_name(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 %s", \ cmd->cmd.pathmove->num_states, \ - jtag_state_name(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 %s:", scan_size, jtag_state_name(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 %s:", scan_size, jtag_state_name(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_ @@ -328,7 +341,7 @@ 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); @@ -336,14 +349,11 @@ int vsllink_execute_queue(void) 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(); @@ -352,7 +362,7 @@ int vsllink_execute_queue(void) case JTAG_STABLECLOCKS: DEBUG_JTAG_IO("add %d clocks", cmd->cmd.stableclocks->num_cycles); - switch(cur_state) + switch (tap_get_state()) { case TAP_RESET: // tms should be '1' to stay in TAP_RESET mode @@ -367,8 +377,8 @@ int vsllink_execute_queue(void) scan_size = 0; break; /* above stable states are OK */ default: - LOG_ERROR( "jtag_add_clocks() was called with TAP in non-stable state \"%s\"", - jtag_state_name(cur_state) ); + 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); @@ -380,20 +390,20 @@ int vsllink_execute_queue(void) } 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; @@ -403,41 +413,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]; @@ -450,17 +446,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) @@ -468,7 +467,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); @@ -488,19 +487,63 @@ 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; @@ -517,11 +560,11 @@ 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)) { @@ -536,29 +579,59 @@ int vsllink_quit(void) } // disconnect - vsllink_simple_command(VSLLINK_CMD_DISCONN); + 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; +} + +/***************************************************************************/ +/* Queue command implementations */ +static int vsllink_disconnect(void) +{ + vsllink_simple_command(VSLLINK_CMD_DISCONN); + return ERROR_OK; +} + +static int vsllink_connect(void) +{ + 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); } + 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. -void vsllink_append_tms(void) +static void vsllink_append_tms(void) { - u8 tms_scan = VSLLINK_TAP_MOVE(cur_state, end_state); - u16 tms2; + 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 (((cur_state != TAP_RESET) && (cur_state != TAP_IDLE) && (cur_state != TAP_DRPAUSE) && (cur_state != TAP_IRPAUSE)) || \ + 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)) { @@ -566,15 +639,15 @@ void vsllink_append_tms(void) exit(-1); } - tms2 = (tms_scan & VSLLINK_BIT_MSK[VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_map[cur_state]][tap_move_map[end_state]].insert_position]) << \ + tms2 = (tms_scan & VSLLINK_BIT_MSK[insert->insert_position]) << \ vsllink_tms_data_len; - if (VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_map[cur_state]][tap_move_map[end_state]].insert_value == 1) + if (insert->insert_value == 1) { tms2 |= VSLLINK_BIT_MSK[8 - vsllink_tms_data_len] << \ - (vsllink_tms_data_len + VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_map[cur_state]][tap_move_map[end_state]].insert_position); + (vsllink_tms_data_len + insert->insert_position); } - tms2 |= (tms_scan >> VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_map[cur_state]][tap_move_map[end_state]].insert_position) << \ - (8 + VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[tap_move_map[cur_state]][tap_move_map[end_state]].insert_position); + 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; @@ -583,14 +656,11 @@ void vsllink_append_tms(void) 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 { @@ -600,7 +670,7 @@ 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) { @@ -611,14 +681,60 @@ void vsllink_state_move(void) 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; @@ -633,20 +749,20 @@ void vsllink_add_path(int start, int num, enum tap_state *path) 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_transitions[cur_state].low) + else if (path[i - start] == tap_state_transition(tap_get_state(), false)) { // nothing to do } else { - LOG_ERROR("BUG: %s -> %s isn't a valid TAP transition", jtag_state_name(cur_state), jtag_state_name(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 - start]; + tap_set_state(path[i - start]); } if ((i > 0) && ((i & 7) == 0)) { @@ -654,10 +770,10 @@ void vsllink_add_path(int start, int num, enum tap_state *path) 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; @@ -776,11 +892,70 @@ void vsllink_path_move(int num_states, enum tap_state *path) } } } +static void vsllink_path_move_dma(int num_states, tap_state_t *path) +{ + int i, j = 0; + + if (tap_length & 7) + { + if ((8 - (tap_length & 7)) < num_states) + { + j = 8 - (tap_length & 7); + } + else + { + 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()); +} -void vsllink_stableclocks(int num_cycles, int tms) +static void vsllink_stableclocks_normal(int num_cycles, int tms) { int tms_len; - u16 tms_append_byte; + uint16_t tms_append_byte; if (vsllink_tms_data_len > 0) { @@ -790,7 +965,7 @@ void vsllink_stableclocks(int num_cycles, int tms) if (tms > 0) { // append '1' for tms - tms_append_byte = (u16)((((1 << num_cycles) - 1) << vsllink_tms_data_len) & 0xFFFF); + tms_append_byte = (uint16_t)((((1 << num_cycles) - 1) << vsllink_tms_data_len) & 0xFFFF); } else { @@ -805,14 +980,14 @@ void vsllink_stableclocks(int num_cycles, int tms) // 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] |= (u8)(tms_append_byte & 0xFF); + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] |= (uint8_t)(tms_append_byte & 0xFF); } else if (tms_len == 8) { // 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++] |= (u8)(tms_append_byte & 0xFF); + vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (uint8_t)(tms_append_byte & 0xFF); } else if (tms_len < 16) { @@ -822,8 +997,8 @@ void vsllink_stableclocks(int num_cycles, int tms) // 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++] |= (u8)(tms_append_byte & 0xFF); - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx] = (u8)(tms_append_byte >> 8); + 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 { @@ -833,19 +1008,19 @@ void vsllink_stableclocks(int num_cycles, int tms) // 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++] |= (u8)(tms_append_byte & 0xFF); + 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] = (u8)(tms_append_byte >> 8); + 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++] |= (u8)(tms_append_byte & 0xFF); - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (u8)(tms_append_byte >> 8); + 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; @@ -858,8 +1033,8 @@ void vsllink_stableclocks(int num_cycles, int tms) else { // more shifts will be needed - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] |= (u8)(tms_append_byte & 0xFF); - vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx++] = (u8)(tms_append_byte >> 8); + 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; @@ -931,12 +1106,54 @@ void vsllink_stableclocks(int num_cycles, int tms) } } } +static void vsllink_stableclocks_dma(int num_cycles, int tms) +{ + int i, cur_cycles; -void vsllink_runtest(int num_cycles) + 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_tap_append_step(tms, 0); + } + num_cycles -= cur_cycles; + } + + while (num_cycles > 0) + { + if (num_cycles > 8 * tap_buffer_size) + { + cur_cycles = 8 * tap_buffer_size; + } + else + { + cur_cycles = num_cycles; + } + + vsllink_tap_ensure_space(0, cur_cycles); + + for (i = 0; i < cur_cycles; i++) + { + vsllink_tap_append_step(tms, 0); + } + + num_cycles -= cur_cycles; + } +} + +static void vsllink_runtest(int num_cycles) { - enum tap_state saved_end_state = end_state; + tap_state_t saved_end_state = tap_get_end_state(); - if (cur_state != TAP_IDLE) + if (tap_get_state() != TAP_IDLE) { // enter into IDLE state vsllink_end_state(TAP_IDLE); @@ -948,17 +1165,17 @@ void vsllink_runtest(int num_cycles) // post-process // set end_state vsllink_end_state(saved_end_state); - cur_state = TAP_IDLE; - if (end_state != TAP_IDLE) + 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 ) @@ -972,24 +1189,24 @@ void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, s 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()) { // 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) + 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) + else if (*vsllink_tms_cmd_pos < 2) { tms_tmp = vsllink_usb_out_buffer[vsllink_usb_out_buffer_idx]; vsllink_usb_out_buffer_idx--; @@ -1001,11 +1218,11 @@ void vsllink_scan(int ir_scan, enum scan_type type, u8 *buffer, int scan_size, s } vsllink_tap_ensure_space(1, tdi_len + 7); - // VSLLINK_CMDJTAGSEQ_SCAN ored by 1 means that tms_before is valid + // 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); @@ -1018,20 +1235,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_append_tms(); + 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 @@ -1041,15 +1258,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) { @@ -1060,24 +1277,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(cur_state, 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; -void vsllink_reset(int trst, int srst) + 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(); + } +} + +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; @@ -1098,91 +1342,198 @@ 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) +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; +} + +static int vsllink_handle_mode_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { 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) +static int vsllink_handle_usb_vid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - 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); + return parse_u16(args[0], &vsllink_usb_vid); +} - return ERROR_OK; +static int vsllink_handle_usb_pid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +{ + if (argc != 1) + { + LOG_ERROR("parameter error, should be one parameter for PID"); + return ERROR_OK; + } + return parse_u16(args[0], &vsllink_usb_pid); } -int vsllink_handle_usb_bulkin_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static int vsllink_handle_usb_bulkin_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - 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; + int retval = parse_u8(args[0], &vsllink_usb_bulkin); + if (ERROR_OK == retval) + vsllink_usb_bulkin |= 0x80; - return ERROR_OK; + return retval; } -int vsllink_handle_usb_bulkout_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +static int vsllink_handle_usb_bulkout_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) { - 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); + int retval = parse_u8(args[0], &vsllink_usb_bulkout); + if (ERROR_OK == retval) + vsllink_usb_bulkout &= ~0x80; - return ERROR_OK; + return retval; +} + +static int vsllink_handle_usb_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc) +{ + if (argc != 1) + { + LOG_ERROR("parameter error, should be one parameter for interface number"); + return ERROR_OK; + } + + return parse_u8(args[0], &vsllink_usb_interface); } /***************************************************************************/ /* 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(); + } +} +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(); } } -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) +{ + 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); + } +} + +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; @@ -1207,10 +1558,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 reset or idle or pause state. */ -int vsllink_tap_execute(void) +static int vsllink_tap_execute_normal(void) { int i; int result; @@ -1218,9 +1603,9 @@ int vsllink_tap_execute(void) if (vsllink_tms_data_len > 0) { - if((cur_state != TAP_RESET) && (cur_state != TAP_IDLE) && (cur_state != TAP_IRPAUSE) && (cur_state != TAP_DRPAUSE)) + 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", jtag_state_name(cur_state)); + 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))) @@ -1238,7 +1623,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) @@ -1248,13 +1633,13 @@ 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; @@ -1264,7 +1649,7 @@ int vsllink_tap_execute(void) // 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); @@ -1290,12 +1675,75 @@ int vsllink_tap_execute(void) 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 + + if (jtag_read_buffer(buffer, command) != ERROR_OK) + { + vsllink_tap_init(); + return ERROR_JTAG_QUEUE_FAILED; + } - vsllink_usb_out_buffer[0] = VSLLINK_CMD_HW_JTAGSEQCMD; - vsllink_usb_out_buffer_idx = 3; + if (pending_scan_result->buffer != NULL) + { + free(pending_scan_result->buffer); + } + } + } + else + { + LOG_ERROR("vsllink_tap_execute, wrong result %d, expected %d", result, byte_length); + return ERROR_JTAG_QUEUE_FAILED; + } + + vsllink_tap_init(); + } return ERROR_OK; } @@ -1303,63 +1751,94 @@ int vsllink_tap_execute(void) /*****************************************************************************/ /* 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) { @@ -1386,21 +1865,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); @@ -1414,13 +1893,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); @@ -1430,13 +1909,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); @@ -1445,6 +1925,7 @@ 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_