Code Review / openocd.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | review | tree
raw | inline | side by side
zy1000: add version command to print FPGA version and timestamps
[openocd.git] / src / jtag / vsllink.c
diff --git a/src/jtag/vsllink.c b/src/jtag/vsllink.c
index 7ecd6c7fde516acfa7cf3d793a921d070e9fcb1f..0684dd3bb79415f32ac9ec29b6f92697d428c0cd 100644 (file)
--- a/src/jtag/vsllink.c
+++ b/src/jtag/vsllink.c
@@ -37,8 +37,8 @@
 #define VSLLINK_MODE_NORMAL                    0
 #define VSLLINK_MODE_DMA                       1
 
-static u16 vsllink_usb_vid;
-static u16 vsllink_usb_pid;
+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;
@@ -105,13 +105,12 @@ static uint8_t VSLLINK_tap_move[6][6] =
        {0xfe, 0x60, 0x38, 0x5c, 0x40, 0x5e}    /* PI  */
 };
 
-typedef struct insert_insignificant_operation
-{
+struct insert_insignificant_operation {
        unsigned char insert_value;
        unsigned char insert_position;
-}insert_insignificant_operation_t;
+};
 
-static insert_insignificant_operation_t VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[6][6] =
+static struct insert_insignificant_operation VSLLINK_TAP_MOVE_INSERT_INSIGNIFICANT[6][6] =
 {
 /*      stuff  offset   */
        {/*     TLR     */
@@ -163,35 +162,17 @@ static uint8_t VSLLINK_BIT_MSK[8] =
        0x00, 0x01, 0x03, 0x07, 0x0f, 0x1f, 0x3f, 0x7f
 };
 
-typedef struct
-{
+struct pending_scan_result {
        int offset;
        int length; /* Number of bits to read */
-       scan_command_t *command; /* Corresponding scan command */
+       struct scan_command *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];
-
-/* External interface functions */
-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 */
-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);
+static struct pending_scan_result pending_scan_results_buffer[MAX_PENDING_SCAN_RESULTS];
 
 /* Queue command functions */
 static void vsllink_end_state(tap_state_t state);
@@ -205,9 +186,9 @@ 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_scan_dma(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command);
+static void vsllink_scan_normal(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command);
+static void (*vsllink_scan)(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command);
 static void vsllink_reset(int trst, int srst);
 static void vsllink_simple_command(uint8_t command);
 static int vsllink_connect(void);
@@ -224,20 +205,19 @@ 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);
+static void vsllink_tap_append_scan_dma(int length, uint8_t *buffer, struct scan_command *command);
+static void vsllink_tap_append_scan_normal(int length, uint8_t *buffer, struct scan_command *command, int offset);
 
 /* VSLLink lowlevel functions */
-typedef struct vsllink_jtag
-{
+struct vsllink {
        struct usb_dev_handle* usb_handle;
-} vsllink_jtag_t;
+};
 
-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);
+static struct vsllink *vsllink_usb_open(void);
+static void vsllink_usb_close(struct vsllink *vsllink);
+static int vsllink_usb_message(struct vsllink *vsllink, int out_length, int in_length);
+static int vsllink_usb_write(struct vsllink *vsllink, int out_length);
+static int vsllink_usb_read(struct vsllink *vsllink);
 
 #if defined _DEBUG_USB_COMMS_ || defined _DEBUG_JTAG_IO_
 static void vsllink_debug_buffer(uint8_t *buffer, int length);
@@ -253,22 +233,7 @@ static uint8_t *tdi_buffer = NULL;
 static uint8_t *tdo_buffer = NULL;
 static int last_tms;
 
-static vsllink_jtag_t* vsllink_jtag_handle = NULL;
-
-/***************************************************************************/
-/* External interface implementation */
-
-jtag_interface_t vsllink_interface =
-{
-       .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
-};
+static struct vsllink* vsllink_handle = NULL;
 
 static void reset_command_pointer(void)
 {
@@ -285,7 +250,7 @@ static void reset_command_pointer(void)
 
 static int vsllink_execute_queue(void)
 {
-       jtag_command_t *cmd = jtag_command_queue;
+       struct jtag_command *cmd = jtag_command_queue;
        int scan_size;
        enum scan_type type;
        uint8_t *buffer;
@@ -298,7 +263,7 @@ static int vsllink_execute_queue(void)
                switch (cmd->type)
                {
                        case JTAG_RUNTEST:
-                               DEBUG_JTAG_IO( "runtest %i cycles, end in %s", cmd->cmd.runtest->num_cycles, \
+                               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);
@@ -362,7 +327,7 @@ static int vsllink_execute_queue(void)
 
                        case JTAG_STABLECLOCKS:
                                DEBUG_JTAG_IO("add %d clocks", cmd->cmd.stableclocks->num_cycles);
-                               switch(tap_get_state())
+                               switch (tap_get_state())
                                {
                                case TAP_RESET:
                                        // tms should be '1' to stay in TAP_RESET mode
@@ -377,8 +342,8 @@ static 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\"",
-                                                        tap_state_name(tap_get_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);
@@ -402,7 +367,7 @@ static int vsllink_speed(int 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);
+       result = vsllink_usb_write(vsllink_handle, 3);
 
        if (result == 3)
        {
@@ -445,9 +410,9 @@ static int vsllink_init(void)
                exit(-1);
        }
 
-       vsllink_jtag_handle = vsllink_usb_open();
+       vsllink_handle = vsllink_usb_open();
 
-       if (vsllink_jtag_handle == 0)
+       if (vsllink_handle == 0)
        {
                LOG_ERROR("Can't find USB JTAG Interface! Please check connection and permissions.");
                return ERROR_JTAG_INIT_FAILED;
@@ -460,7 +425,7 @@ static int vsllink_init(void)
        while (check_cnt < 5)
        {
                vsllink_simple_command(0x00);
-               result = vsllink_usb_read(vsllink_jtag_handle);
+               result = vsllink_usb_read(vsllink_handle);
 
                if (result > 2)
                {
@@ -549,7 +514,7 @@ static int vsllink_init(void)
        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;
-       if (vsllink_usb_write(vsllink_jtag_handle, 3) != 3)
+       if (vsllink_usb_write(vsllink_handle, 3) != 3)
        {
                LOG_ERROR("VSLLink USB send data error");
                exit(-1);
@@ -572,7 +537,7 @@ static int vsllink_quit(void)
                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)
+               if (vsllink_usb_write(vsllink_handle, 3) != 3)
                {
                        LOG_ERROR("VSLLink USB send data error");
                        exit(-1);
@@ -580,8 +545,8 @@ static int vsllink_quit(void)
 
                // disconnect
                vsllink_disconnect();
-               vsllink_usb_close(vsllink_jtag_handle);
-               vsllink_jtag_handle = NULL;
+               vsllink_usb_close(vsllink_handle);
+               vsllink_handle = NULL;
        }
 
        if (vsllink_usb_in_buffer != NULL)
@@ -612,8 +577,8 @@ static int vsllink_connect(void)
 
        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)
+       vsllink_usb_message(vsllink_handle, 2, 0);
+       if (vsllink_usb_read(vsllink_handle) > 2)
        {
                strncpy(vsllink_str, (char *)vsllink_usb_in_buffer + 2, sizeof(vsllink_str));
                LOG_INFO("%s", vsllink_str);
@@ -627,8 +592,8 @@ static int vsllink_connect(void)
 static void vsllink_append_tms(void)
 {
        uint8_t tms_scan = VSLLINK_TAP_MOVE(tap_get_state(), tap_get_end_state());
-       u16 tms2;
-       insert_insignificant_operation_t *insert = \
+       uint16_t tms2;
+       struct insert_insignificant_operation *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)) || \
@@ -689,7 +654,7 @@ static void vsllink_state_move_normal(void)
 static void vsllink_state_move_dma(void)
 {
        int i, insert_length = (tap_length % 8) ? (8 - (tap_length % 8)) : 0;
-       insert_insignificant_operation_t *insert = \
+       struct insert_insignificant_operation *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());
 
@@ -955,7 +920,7 @@ static void vsllink_path_move_dma(int num_states, tap_state_t *path)
 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)
        {
@@ -965,7 +930,7 @@ static void vsllink_stableclocks_normal(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
                {
@@ -1172,13 +1137,13 @@ static void vsllink_runtest(int num_cycles)
        }
 }
 
-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_normal(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command)
 {
        tap_state_t saved_end_state;
        uint8_t bits_left, tms_tmp, tdi_len;
        int i;
 
-       if (0 == scan_size )
+       if (0 == scan_size)
        {
                return;
        }
@@ -1201,12 +1166,12 @@ static void vsllink_scan_normal(bool ir_scan, enum scan_type type, uint8_t *buff
                {
                        // 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--;
@@ -1288,7 +1253,7 @@ static void vsllink_scan_normal(bool ir_scan, enum scan_type type, uint8_t *buff
 
        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)
+static void vsllink_scan_dma(bool ir_scan, enum scan_type type, uint8_t *buffer, int scan_size, struct scan_command *command)
 {
        tap_state_t saved_end_state;
 
@@ -1335,7 +1300,7 @@ static void vsllink_reset(int trst, int srst)
                vsllink_usb_out_buffer[2] |= JTAG_PINMSK_TRST;
        }
 
-       result = vsllink_usb_write(vsllink_jtag_handle, 3);
+       result = vsllink_usb_write(vsllink_handle, 3);
        if (result != 3)
        {
                LOG_ERROR("VSLLink command VSLLINK_CMD_SET_PORT failed (%d)", result);
@@ -1349,7 +1314,7 @@ static void vsllink_simple_command(uint8_t command)
        DEBUG_JTAG_IO("0x%02x", command);
 
        vsllink_usb_out_buffer[0] = command;
-       result = vsllink_usb_write(vsllink_jtag_handle, 1);
+       result = vsllink_usb_write(vsllink_handle, 1);
 
        if (result != 1)
        {
@@ -1357,25 +1322,7 @@ static void vsllink_simple_command(uint8_t command)
        }
 }
 
-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)
+COMMAND_HANDLER(vsllink_handle_mode_command)
 {
        if (argc != 1) {
                LOG_ERROR("parameter error, should be one parameter for VID");
@@ -1399,7 +1346,7 @@ static int vsllink_handle_mode_command(struct command_context_s *cmd_ctx, char *
        return ERROR_OK;
 }
 
-static int vsllink_handle_usb_vid_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(vsllink_handle_usb_vid_command)
 {
        if (argc != 1)
        {
@@ -1407,20 +1354,22 @@ static int vsllink_handle_usb_vid_command(struct command_context_s *cmd_ctx, cha
                return ERROR_OK;
        }
 
-       return parse_u16(args[0], &vsllink_usb_vid);
+       COMMAND_PARSE_NUMBER(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)
+COMMAND_HANDLER(vsllink_handle_usb_pid_command)
 {
        if (argc != 1)
        {
                LOG_ERROR("parameter error, should be one parameter for PID");
                return ERROR_OK;
        }
-       return parse_u16(args[0], &vsllink_usb_pid);
+       COMMAND_PARSE_NUMBER(u16, args[0], vsllink_usb_pid);
+       return ERROR_OK;
 }
 
-static 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)
        {
@@ -1428,14 +1377,14 @@ static int vsllink_handle_usb_bulkin_command(struct command_context_s *cmd_ctx,
                return ERROR_OK;
        }
 
-       int retval = parse_u8(args[0], &vsllink_usb_bulkin);
-       if (ERROR_OK == retval)
-               vsllink_usb_bulkin |= 0x80;
+       COMMAND_PARSE_NUMBER(u8, args[0], vsllink_usb_bulkin);
+
+       vsllink_usb_bulkin |= 0x80;
 
-       return retval;
+       return ERROR_OK;
 }
 
-static 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)
        {
@@ -1443,14 +1392,14 @@ static int vsllink_handle_usb_bulkout_command(struct command_context_s *cmd_ctx,
                return ERROR_OK;
        }
 
-       int retval = parse_u8(args[0], &vsllink_usb_bulkout);
-       if (ERROR_OK == retval)
-               vsllink_usb_bulkout &= ~0x80;
+       COMMAND_PARSE_NUMBER(u8, args[0], vsllink_usb_bulkout);
+
+       vsllink_usb_bulkout &= ~0x80;
 
-       return retval;
+       return ERROR_OK;
 }
 
-static int vsllink_handle_usb_interface_command(struct command_context_s *cmd_ctx, char *cmd, char **args, int argc)
+COMMAND_HANDLER(vsllink_handle_usb_interface_command)
 {
        if (argc != 1)
        {
@@ -1458,7 +1407,8 @@ static int vsllink_handle_usb_interface_command(struct command_context_s *cmd_ct
                return ERROR_OK;
        }
 
-       return parse_u8(args[0], &vsllink_usb_interface);
+       COMMAND_PARSE_NUMBER(u8, args[0], vsllink_usb_interface);
+       return ERROR_OK;
 }
 
 /***************************************************************************/
@@ -1533,9 +1483,9 @@ static void vsllink_tap_append_step(int tms, int tdi)
        }
 }
 
-static void vsllink_tap_append_scan_normal(int length, uint8_t *buffer, scan_command_t *command, int offset)
+static void vsllink_tap_append_scan_normal(int length, uint8_t *buffer, struct scan_command *command, int offset)
 {
-       pending_scan_result_t *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length];
+       struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[pending_scan_results_length];
        int i;
 
        if (offset > 0)
@@ -1558,9 +1508,9 @@ static void vsllink_tap_append_scan_normal(int length, uint8_t *buffer, scan_com
 
        pending_scan_results_length++;
 }
-static void vsllink_tap_append_scan_dma(int length, uint8_t *buffer, scan_command_t *command)
+static void vsllink_tap_append_scan_dma(int length, uint8_t *buffer, struct scan_command *command)
 {
-       pending_scan_result_t *pending_scan_result;
+       struct pending_scan_result *pending_scan_result;
        int len_tmp, len_all, i;
 
        len_all = 0;
@@ -1585,7 +1535,7 @@ static void vsllink_tap_append_scan_dma(int length, uint8_t *buffer, scan_comman
 
                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);
+                       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++;
@@ -1603,7 +1553,7 @@ static int vsllink_tap_execute_normal(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))
+               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()));
                }
@@ -1632,17 +1582,17 @@ static int vsllink_tap_execute_normal(void)
                        vsllink_usb_out_buffer[2] = (vsllink_usb_out_buffer_idx >> 8) & 0xff;
                }
 
-               result = vsllink_usb_message(vsllink_jtag_handle, vsllink_usb_out_buffer_idx, vsllink_usb_in_want_length);
+               result = vsllink_usb_message(vsllink_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];
+                               struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[i];
                                uint8_t *buffer = pending_scan_result->buffer;
                                int length = pending_scan_result->length;
                                int offset = pending_scan_result->offset;
-                               scan_command_t *command = pending_scan_result->command;
+                               struct scan_command *command = pending_scan_result->command;
 
                                if (buffer != NULL)
                                {
@@ -1706,17 +1656,17 @@ static int vsllink_tap_execute_dma(void)
                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);
+               result = vsllink_usb_message(vsllink_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];
+                               struct pending_scan_result *pending_scan_result = &pending_scan_results_buffer[i];
                                uint8_t *buffer = pending_scan_result->buffer;
                                int length = pending_scan_result->length;
                                int first = pending_scan_result->offset;
 
-                               scan_command_t *command = pending_scan_result->command;
+                               struct scan_command *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);
@@ -1751,16 +1701,16 @@ static int vsllink_tap_execute_dma(void)
 /*****************************************************************************/
 /* VSLLink USB low-level functions */
 
-static vsllink_jtag_t* vsllink_usb_open(void)
+static struct vsllink* vsllink_usb_open(void)
 {
        struct usb_bus *busses;
        struct usb_bus *bus;
        struct usb_device *dev;
        int ret;
 
-       vsllink_jtag_t *result;
+       struct vsllink *result;
 
-       result = (vsllink_jtag_t*) malloc(sizeof(vsllink_jtag_t));
+       result = (struct vsllink*) malloc(sizeof(struct vsllink));
 
        usb_init();
        usb_find_busses();
@@ -1768,7 +1718,7 @@ static vsllink_jtag_t* vsllink_usb_open(void)
 
        busses = usb_get_busses();
 
-       /* find vsllink_jtag device in usb bus */
+       /* find vsllink device in usb bus */
 
        for (bus = busses; bus; bus = bus->next)
        {
@@ -1813,39 +1763,39 @@ static vsllink_jtag_t* vsllink_usb_open(void)
        return NULL;
 }
 
-static void vsllink_usb_close(vsllink_jtag_t *vsllink_jtag)
+static void vsllink_usb_close(struct vsllink *vsllink)
 {
        int ret;
 
-       ret = usb_release_interface(vsllink_jtag->usb_handle, vsllink_usb_interface);
+       ret = usb_release_interface(vsllink->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);
+       ret = usb_close(vsllink->usb_handle);
        if (ret != 0)
        {
                LOG_ERROR("fail to close usb, %d returned", ret);
                exit(-1);
        }
 
-       free(vsllink_jtag);
+       free(vsllink);
 }
 
 /* Send a message and receive the reply. */
-static int vsllink_usb_message(vsllink_jtag_t *vsllink_jtag, int out_length, int in_length)
+static int vsllink_usb_message(struct vsllink *vsllink, int out_length, int in_length)
 {
        int result;
 
-       result = vsllink_usb_write(vsllink_jtag, out_length);
+       result = vsllink_usb_write(vsllink, out_length);
        if (result == out_length)
        {
                if (in_length > 0)
                {
-                       result = vsllink_usb_read(vsllink_jtag);
-                       if (result == in_length )
+                       result = vsllink_usb_read(vsllink);
+                       if (result == in_length)
                        {
                                return result;
                        }
@@ -1865,17 +1815,17 @@ static int vsllink_usb_message(vsllink_jtag_t *vsllink_jtag, int out_length, int
 }
 
 /* Write data from out_buffer to USB. */
-static int vsllink_usb_write(vsllink_jtag_t *vsllink_jtag, int out_length)
+static int vsllink_usb_write(struct vsllink *vsllink, 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);
+               LOG_ERROR("vsllink_write illegal out_length=%d (max=%d)", out_length, VSLLINK_BufferSize);
                return -1;
        }
 
-       result = usb_bulk_write(vsllink_jtag->usb_handle, vsllink_usb_bulkout, \
+       result = usb_bulk_write(vsllink->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);
@@ -1893,9 +1843,9 @@ static int vsllink_usb_write(vsllink_jtag_t *vsllink_jtag, int out_length)
 }
 
 /* Read data from USB into in_buffer. */
-static int vsllink_usb_read(vsllink_jtag_t *vsllink_jtag)
+static int vsllink_usb_read(struct vsllink *vsllink)
 {
-       int result = usb_bulk_read(vsllink_jtag->usb_handle, vsllink_usb_bulkin, \
+       int result = usb_bulk_read(vsllink->usb_handle, vsllink_usb_bulkin, \
                (char *)vsllink_usb_in_buffer, VSLLINK_BufferSize, VSLLINK_USB_TIMEOUT);
 
        DEBUG_JTAG_IO("vsllink_usb_read, result = %d", result);
@@ -1929,3 +1879,38 @@ static void vsllink_debug_buffer(uint8_t *buffer, int length)
        }
 }
 #endif // _DEBUG_USB_COMMS_ || _DEBUG_JTAG_IO_
+
+static int vsllink_register_commands(struct command_context *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;
+}
+
+struct jtag_interface 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,
+       };
Open On-Chip Debugger

Linking to existing account procedure

If you already have an account and want to add another login method you MUST first sign in with your existing account and then change URL to read https://review.openocd.org/login/?link to get to this page again but this time it'll work for linking. Thank you.

SSH host keys fingerprints

1024 SHA256:YKx8b7u5ZWdcbp7/4AeXNaqElP49m6QrwfXaqQGJAOk gerrit-code-review@openocd.zylin.com (DSA)
384 SHA256:jHIbSQa4REvwCFG4cq5LBlBLxmxSqelQPem/EXIrxjk gerrit-code-review@openocd.org (ECDSA)
521 SHA256:UAOPYkU9Fjtcao0Ul/Rrlnj/OsQvt+pgdYSZ4jOYdgs gerrit-code-review@openocd.org (ECDSA)
256 SHA256:A13M5QlnozFOvTllybRZH6vm7iSt0XLxbA48yfc2yfY gerrit-code-review@openocd.org (ECDSA)
256 SHA256:spYMBqEYoAOtK7yZBrcwE8ZpYt6b68Cfh9yEVetvbXg gerrit-code-review@openocd.org (ED25519)
+--[ED25519 256]--+
|=..              |
|+o..   .         |
|*.o   . .        |
|+B . . .         |
|Bo. = o S        |
|Oo.+ + =         |
|oB=.* = . o      |
| =+=.+   + E     |
|. .=o   . o      |
+----[SHA256]-----+
2048 SHA256:0Onrb7/PHjpo6iVZ7xQX2riKN83FJ3KGU0TvI0TaFG4 gerrit-code-review@openocd.zylin.com (RSA)