X-Git-Url: https://review.openocd.org/gitweb?a=blobdiff_plain;f=src%2Fjtag%2Fdrivers%2Fvsllink.c;h=f08fa9165ed40191c0882abe6cc1d1a363e7bc3b;hb=11d918d9c1f7cb637a525a92521b747d2d4c840f;hp=1f861baa97cb515723ba8ac3d806ce6b19dbd522;hpb=5f9c59409b193c3f3f1408db43ad7d05e004d687;p=openocd.git diff --git a/src/jtag/drivers/vsllink.c b/src/jtag/drivers/vsllink.c index 1f861baa97..f08fa9165e 100644 --- a/src/jtag/drivers/vsllink.c +++ b/src/jtag/drivers/vsllink.c @@ -12,9 +12,7 @@ * GNU General Public License for more details. * * * * You should have received a copy of the GNU General Public License * - * along with this program; if not, write to the * - * Free Software Foundation, Inc., * - * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. * + * along with this program. If not, see . * ***************************************************************************/ /* Versaloon is a programming tool for multiple MCUs. @@ -29,7 +27,7 @@ #include #include #include -#include "usb_common.h" +#include #include "versaloon/versaloon_include.h" #include "versaloon/versaloon.h" @@ -61,7 +59,7 @@ static void vsllink_runtest(int num_cycles); static void vsllink_stableclocks(int num_cycles, int tms); 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 int vsllink_reset(int trst, int srst); /* VSLLink tap buffer functions */ static void vsllink_tap_append_step(int tms, int tdi); @@ -72,22 +70,19 @@ static void vsllink_tap_append_scan(int length, uint8_t *buffer, struct scan_command *command); /* VSLLink SWD functions */ -static int_least32_t vsllink_swd_frequency(struct adiv5_dap *dap, - int_least32_t hz); -static int vsllink_swd_switch_seq(struct adiv5_dap *dap, - enum swd_special_seq seq); +static int_least32_t vsllink_swd_frequency(int_least32_t hz); +static int vsllink_swd_switch_seq(enum swd_special_seq seq); /* VSLLink lowlevel functions */ struct vsllink { - struct usb_dev_handle *usb_handle; + struct libusb_context *libusb_ctx; + struct libusb_device_handle *usb_device_handle; }; -static struct vsllink *vsllink_usb_open(void); +static int vsllink_usb_open(struct vsllink *vsllink); static void vsllink_usb_close(struct vsllink *vsllink); -#if defined _DEBUG_JTAG_IO_ static void vsllink_debug_buffer(uint8_t *buffer, int length); -#endif static int tap_length; static int tap_buffer_size; @@ -96,9 +91,8 @@ static uint8_t *tdi_buffer; static uint8_t *tdo_buffer; static bool swd_mode; -static int queued_retval; -struct vsllink *vsllink_handle; +static struct vsllink *vsllink_handle; static int vsllink_execute_queue(void) { @@ -107,14 +101,14 @@ static int vsllink_execute_queue(void) enum scan_type type; uint8_t *buffer; - DEBUG_JTAG_IO("-------------------------------------" + LOG_DEBUG_IO("-------------------------------------" " vsllink " "-------------------------------------"); while (cmd != NULL) { switch (cmd->type) { case JTAG_RUNTEST: - DEBUG_JTAG_IO("runtest %i cycles, end in %s", + LOG_DEBUG_IO("runtest %i cycles, end in %s", cmd->cmd.runtest->num_cycles, tap_state_name(cmd->cmd.runtest->end_state)); @@ -123,7 +117,7 @@ static int vsllink_execute_queue(void) break; case JTAG_TLR_RESET: - DEBUG_JTAG_IO("statemove end in %s", + LOG_DEBUG_IO("statemove end in %s", tap_state_name(cmd->cmd.statemove->end_state)); vsllink_end_state(cmd->cmd.statemove->end_state); @@ -131,7 +125,7 @@ static int vsllink_execute_queue(void) break; case JTAG_PATHMOVE: - DEBUG_JTAG_IO("pathmove: %i states, end in %s", + LOG_DEBUG_IO("pathmove: %i states, end in %s", cmd->cmd.pathmove->num_states, tap_state_name(cmd->cmd.pathmove->path[cmd->cmd.pathmove->num_states - 1])); @@ -139,7 +133,7 @@ static int vsllink_execute_queue(void) break; case JTAG_SCAN: - DEBUG_JTAG_IO("JTAG Scan..."); + LOG_DEBUG_IO("JTAG Scan..."); vsllink_end_state(cmd->cmd.scan->end_state); @@ -147,23 +141,21 @@ static int vsllink_execute_queue(void) cmd->cmd.scan, &buffer); if (cmd->cmd.scan->ir_scan) - DEBUG_JTAG_IO( + LOG_DEBUG_IO( "JTAG Scan write IR(%d bits), " "end in %s:", scan_size, tap_state_name(cmd->cmd.scan->end_state)); else - DEBUG_JTAG_IO( + LOG_DEBUG_IO( "JTAG Scan write DR(%d bits), " "end in %s:", scan_size, tap_state_name(cmd->cmd.scan->end_state)); -#ifdef _DEBUG_JTAG_IO_ - vsllink_debug_buffer(buffer, - DIV_ROUND_UP(scan_size, 8)); -#endif + if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO)) + vsllink_debug_buffer(buffer, DIV_ROUND_UP(scan_size, 8)); type = jtag_scan_type(cmd->cmd.scan); @@ -172,28 +164,14 @@ static int vsllink_execute_queue(void) 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) - tap_set_state(TAP_RESET); - - vsllink_reset(cmd->cmd.reset->trst, - cmd->cmd.reset->srst); - break; - case JTAG_SLEEP: - DEBUG_JTAG_IO("sleep %i", cmd->cmd.sleep->us); + LOG_DEBUG_IO("sleep %" PRIu32, cmd->cmd.sleep->us); vsllink_tap_execute(); jtag_sleep(cmd->cmd.sleep->us); break; case JTAG_STABLECLOCKS: - DEBUG_JTAG_IO("add %d clocks", + LOG_DEBUG_IO("add %d clocks", cmd->cmd.stableclocks->num_cycles); switch (tap_get_state()) { @@ -223,7 +201,7 @@ static int vsllink_execute_queue(void) break; case JTAG_TMS: - DEBUG_JTAG_IO("add %d jtag tms", + LOG_DEBUG_IO("add %d jtag tms", cmd->cmd.tms->num_bits); vsllink_tms(cmd->cmd.tms->num_bits, cmd->cmd.tms->bits); @@ -242,8 +220,10 @@ static int vsllink_execute_queue(void) static int vsllink_speed(int speed) { - if (swd_mode) + if (swd_mode) { + vsllink_swd_frequency(speed * 1000); return ERROR_OK; + } versaloon_interface.adaptors.jtag_raw.config(0, (uint16_t)speed); return versaloon_interface.adaptors.peripheral_commit(); @@ -265,18 +245,14 @@ static int vsllink_speed_div(int jtag_speed, int *khz) static void vsllink_free_buffer(void) { - if (tdi_buffer != NULL) { - free(tdi_buffer); - tdi_buffer = NULL; - } - if (tdo_buffer != NULL) { - free(tdo_buffer); - tdo_buffer = NULL; - } - if (tms_buffer != NULL) { - free(tms_buffer); - tms_buffer = NULL; - } + free(tdi_buffer); + tdi_buffer = NULL; + + free(tdo_buffer); + tdo_buffer = NULL; + + free(tms_buffer); + tms_buffer = NULL; } static int vsllink_quit(void) @@ -296,21 +272,30 @@ static int vsllink_quit(void) vsllink_free_buffer(); vsllink_usb_close(vsllink_handle); + free(vsllink_handle); + return ERROR_OK; } static int vsllink_interface_init(void) { - vsllink_handle = vsllink_usb_open(); - if (vsllink_handle == 0) { - LOG_ERROR("Can't find USB JTAG Interface!" \ + vsllink_handle = malloc(sizeof(struct vsllink)); + if (NULL == vsllink_handle) { + LOG_ERROR("unable to allocate memory"); + return ERROR_FAIL; + } + + libusb_init(&vsllink_handle->libusb_ctx); + + if (ERROR_OK != vsllink_usb_open(vsllink_handle)) { + 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", versaloon_interface.usb_setting.vid, versaloon_interface.usb_setting.pid); - versaloon_usb_device_handle = vsllink_handle->usb_handle; + versaloon_usb_device_handle = vsllink_handle->usb_device_handle; if (ERROR_OK != versaloon_interface.init()) return ERROR_FAIL; @@ -338,8 +323,8 @@ static int vsllink_init(void) versaloon_interface.adaptors.gpio.config(0, GPIO_TRST, 0, GPIO_TRST, GPIO_TRST); versaloon_interface.adaptors.swd.init(0); - vsllink_swd_frequency(NULL, jtag_get_speed_khz() * 1000); - vsllink_swd_switch_seq(NULL, JTAG_TO_SWD); + vsllink_swd_frequency(jtag_get_speed_khz() * 1000); + vsllink_swd_switch_seq(JTAG_TO_SWD); } else { /* malloc buffer size for tap */ @@ -475,7 +460,7 @@ static void vsllink_scan(bool ir_scan, enum scan_type type, uint8_t *buffer, vsllink_state_move(); } -static void vsllink_reset(int trst, int srst) +static int vsllink_reset(int trst, int srst) { LOG_DEBUG("trst: %i, srst: %i", trst, srst); @@ -491,7 +476,7 @@ static void vsllink_reset(int trst, int srst) versaloon_interface.adaptors.gpio.out(0, GPIO_TRST, 0); } - versaloon_interface.adaptors.peripheral_commit(); + return versaloon_interface.adaptors.peripheral_commit(); } COMMAND_HANDLER(vsllink_handle_usb_vid_command) @@ -674,13 +659,11 @@ static int vsllink_jtag_execute(void) command = pending_scan_result->command; buf_set_buf(tdo_buffer, src_first, buffer, dest_first, length); -#ifdef _DEBUG_JTAG_IO_ - DEBUG_JTAG_IO( + LOG_DEBUG_IO( "JTAG scan read(%d bits, from src %d bits to dest %d bits):", length, src_first, dest_first); - vsllink_debug_buffer(buffer + dest_first / 8, - DIV_ROUND_UP(length, 7)); -#endif + if (LOG_LEVEL_IS(LOG_LVL_DEBUG_IO)) + vsllink_debug_buffer(buffer + dest_first / 8, DIV_ROUND_UP(length, 7)); if (last) { if (jtag_read_buffer(buffer, command) @@ -689,8 +672,7 @@ static int vsllink_jtag_execute(void) return ERROR_JTAG_QUEUE_FAILED; } - if (pending_scan_result->buffer != NULL) - free(pending_scan_result->buffer); + free(pending_scan_result->buffer); } } } else { @@ -719,8 +701,7 @@ static int vsllink_swd_init(void) return ERROR_OK; } -static int_least32_t vsllink_swd_frequency(struct adiv5_dap *dap, - int_least32_t hz) +static int_least32_t vsllink_swd_frequency(int_least32_t hz) { const int_least32_t delay2hz[] = { 1850000, 235000, 130000, 102000, 85000, 72000 @@ -748,14 +729,12 @@ static int_least32_t vsllink_swd_frequency(struct adiv5_dap *dap, LOG_DEBUG("SWD delay: %d, retry count: %d", delay, retry_count); versaloon_interface.adaptors.swd.config(0, 2, retry_count, delay); - queued_retval = versaloon_interface.adaptors.peripheral_commit(); } return hz; } -static int vsllink_swd_switch_seq(struct adiv5_dap *dap, - enum swd_special_seq seq) +static int vsllink_swd_switch_seq(enum swd_special_seq seq) { switch (seq) { case LINE_RESET: @@ -778,204 +757,119 @@ static int vsllink_swd_switch_seq(struct adiv5_dap *dap, return ERROR_FAIL; } - return versaloon_interface.adaptors.peripheral_commit(); + return ERROR_OK; } -static void vsllink_swd_read_reg(struct adiv5_dap *dap, uint8_t cmd, - uint32_t *value) +static void vsllink_swd_read_reg(uint8_t cmd, uint32_t *value, uint32_t ap_delay_clk) { - if (queued_retval != ERROR_OK) - return; - - int retval; - uint32_t val = 0; - uint8_t ack; - - versaloon_interface.adaptors.swd.transact(0, cmd, &val, &ack); - retval = versaloon_interface.adaptors.peripheral_commit(); - - if (retval != ERROR_OK) { - queued_retval = ERROR_FAIL; - return; - } - - if (ack != 0x01) { - queued_retval = ack; - return; - } - - if (value) - *value = val; - - queued_retval = retval; + versaloon_interface.adaptors.swd.transact(0, cmd, value, NULL); } -static void vsllink_swd_write_reg(struct adiv5_dap *dap, uint8_t cmd, - uint32_t value) +static void vsllink_swd_write_reg(uint8_t cmd, uint32_t value, uint32_t ap_delay_clk) { - if (queued_retval != ERROR_OK) - return; - - int retval; - uint8_t ack; - - versaloon_interface.adaptors.swd.transact(0, cmd, &value, &ack); - retval = versaloon_interface.adaptors.peripheral_commit(); - - if (retval != ERROR_OK) { - queued_retval = ERROR_FAIL; - return; - } - - if (ack != 0x01) { - queued_retval = ack; - return; - } - - queued_retval = retval; + versaloon_interface.adaptors.swd.transact(0, cmd, &value, NULL); } -static int vsllink_swd_run_queue(struct adiv5_dap *dap) +static int vsllink_swd_run_queue(void) { - int retval = queued_retval; - queued_retval = ERROR_OK; - return retval; + return versaloon_interface.adaptors.peripheral_commit(); } /**************************************************************************** * VSLLink USB low-level functions */ -static uint8_t usb_check_string(usb_dev_handle *usb, uint8_t stringidx, - char *string, char *buff, uint16_t buf_size) +static int vsllink_check_usb_strings( + struct libusb_device_handle *usb_device_handle, + struct libusb_device_descriptor *usb_desc) { - int len; - uint8_t alloced = 0; - uint8_t ret = 1; - - if (NULL == buff) { - buf_size = 256; - buff = malloc(buf_size); - if (NULL == buff) { - ret = 0; - goto free_and_return; - } - alloced = 1; - } + char desc_string[256]; + int retval; - strcpy(buff, ""); - len = usb_get_string_simple(usb, stringidx, buff, buf_size); - if ((len < 0) || ((size_t)len != strlen(buff))) { - ret = 0; - goto free_and_return; - } + if (NULL != versaloon_interface.usb_setting.serialstring) { + retval = libusb_get_string_descriptor_ascii(usb_device_handle, + usb_desc->iSerialNumber, (unsigned char *)desc_string, + sizeof(desc_string)); + if (retval < 0) + return ERROR_FAIL; - buff[len] = '\0'; - if ((string != NULL) && strcmp(buff, string)) { - ret = 0; - goto free_and_return; + if (strncmp(desc_string, versaloon_interface.usb_setting.serialstring, + sizeof(desc_string))) + return ERROR_FAIL; } -free_and_return: - if (alloced && (buff != NULL)) { - free(buff); - buff = NULL; - } - return ret; + retval = libusb_get_string_descriptor_ascii(usb_device_handle, + usb_desc->iProduct, (unsigned char *)desc_string, + sizeof(desc_string)); + if (retval < 0) + return ERROR_FAIL; + + if (strstr(desc_string, "Versaloon") == NULL) + return ERROR_FAIL; + + return ERROR_OK; } -static usb_dev_handle *find_usb_device(uint16_t VID, uint16_t PID, uint8_t interface, - char *serialstring, char *productstring) +static int vsllink_usb_open(struct vsllink *vsllink) { - usb_dev_handle *dev_handle = NULL; - struct usb_bus *busses; - struct usb_bus *bus; - struct usb_device *dev; - - usb_init(); - usb_find_busses(); - usb_find_devices(); - busses = usb_get_busses(); - - for (bus = busses; bus; bus = bus->next) { - for (dev = bus->devices; dev; dev = dev->next) { - if ((dev->descriptor.idVendor == VID) - && (dev->descriptor.idProduct == PID)) { - dev_handle = usb_open(dev); - if (NULL == dev_handle) { - LOG_ERROR("failed to open %04X:%04X, %s", VID, PID, - usb_strerror()); - continue; - } + ssize_t num_devices, i; + struct libusb_device **usb_devices; + struct libusb_device_descriptor usb_desc; + struct libusb_device_handle *usb_device_handle; + int retval; - /* check description string */ - if ((productstring != NULL && !usb_check_string(dev_handle, - dev->descriptor.iProduct, productstring, NULL, 0)) - || (serialstring != NULL && !usb_check_string(dev_handle, - dev->descriptor.iSerialNumber, serialstring, NULL, 0))) { - usb_close(dev_handle); - dev_handle = NULL; - continue; - } + num_devices = libusb_get_device_list(vsllink->libusb_ctx, &usb_devices); - if (usb_claim_interface(dev_handle, interface) != 0) { - LOG_ERROR(ERRMSG_FAILURE_OPERATION_MESSAGE, - "claim interface", usb_strerror()); - usb_close(dev_handle); - dev_handle = NULL; - continue; - } + if (num_devices <= 0) + return ERROR_FAIL; - if (dev_handle != NULL) - return dev_handle; - } - } - } + for (i = 0; i < num_devices; i++) { + struct libusb_device *device = usb_devices[i]; - return dev_handle; -} + retval = libusb_get_device_descriptor(device, &usb_desc); + if (retval != 0) + continue; -static struct vsllink *vsllink_usb_open(void) -{ - usb_init(); + if (usb_desc.idVendor != versaloon_interface.usb_setting.vid || + usb_desc.idProduct != versaloon_interface.usb_setting.pid) + continue; - struct usb_dev_handle *dev; + retval = libusb_open(device, &usb_device_handle); + if (retval != 0) + continue; - dev = find_usb_device(versaloon_interface.usb_setting.vid, - versaloon_interface.usb_setting.pid, - versaloon_interface.usb_setting.interface, - versaloon_interface.usb_setting.serialstring, "Versaloon"); - if (NULL == dev) - return NULL; + retval = vsllink_check_usb_strings(usb_device_handle, &usb_desc); + if (ERROR_OK == retval) + break; - struct vsllink *result = malloc(sizeof(struct vsllink)); - result->usb_handle = dev; - return result; -} + libusb_close(usb_device_handle); + } -static void vsllink_usb_close(struct vsllink *vsllink) -{ - int ret; + libusb_free_device_list(usb_devices, 1); - ret = usb_release_interface(vsllink->usb_handle, - versaloon_interface.usb_setting.interface); - if (ret != 0) { - LOG_ERROR("fail to release interface %d, %d returned", - versaloon_interface.usb_setting.interface, ret); - exit(-1); - } + if (i == num_devices) + return ERROR_FAIL; - ret = usb_close(vsllink->usb_handle); - if (ret != 0) { - LOG_ERROR("fail to close usb, %d returned", ret); - exit(-1); + retval = libusb_claim_interface(usb_device_handle, + versaloon_interface.usb_setting.interface); + if (retval != 0) { + LOG_ERROR("unable to claim interface"); + libusb_close(usb_device_handle); + return ERROR_FAIL; } - free(vsllink); + vsllink->usb_device_handle = usb_device_handle; + return ERROR_OK; +} + +static void vsllink_usb_close(struct vsllink *vsllink) +{ + libusb_release_interface(vsllink->usb_device_handle, + versaloon_interface.usb_setting.interface); + libusb_close(vsllink->usb_device_handle); } #define BYTES_PER_LINE 16 -#if defined _DEBUG_JTAG_IO_ static void vsllink_debug_buffer(uint8_t *buffer, int length) { char line[81]; @@ -984,46 +878,57 @@ static void vsllink_debug_buffer(uint8_t *buffer, int length) int j; for (i = 0; i < length; i += BYTES_PER_LINE) { - snprintf(line, 5, "%04x", i); + snprintf(line, 5, "%04x", i & 0xffff); for (j = i; j < i + BYTES_PER_LINE && j < length; j++) { snprintf(s, 4, " %02x", buffer[j]); strcat(line, s); } - LOG_DEBUG("%s", line); + LOG_DEBUG_IO("%s", line); } } -#endif /* _DEBUG_JTAG_IO_ */ static const struct command_registration vsllink_command_handlers[] = { { .name = "vsllink_usb_vid", .handler = &vsllink_handle_usb_vid_command, .mode = COMMAND_CONFIG, + .help = "Set USB VID", + .usage = "", }, { .name = "vsllink_usb_pid", .handler = &vsllink_handle_usb_pid_command, .mode = COMMAND_CONFIG, + .help = "Set USB PID", + .usage = "", }, { .name = "vsllink_usb_serial", .handler = &vsllink_handle_usb_serial_command, .mode = COMMAND_CONFIG, + .help = "Set or disable check for USB serial", + .usage = "[]", }, { .name = "vsllink_usb_bulkin", .handler = &vsllink_handle_usb_bulkin_command, .mode = COMMAND_CONFIG, + .help = "Set USB input endpoint", + .usage = "", }, { .name = "vsllink_usb_bulkout", .handler = &vsllink_handle_usb_bulkout_command, .mode = COMMAND_CONFIG, + .help = "Set USB output endpoint", + .usage = "", }, { .name = "vsllink_usb_interface", .handler = &vsllink_handle_usb_interface_command, .mode = COMMAND_CONFIG, + .help = "Set USB output interface", + .usage = "", }, COMMAND_REGISTRATION_DONE }; @@ -1032,24 +937,29 @@ static const char * const vsllink_transports[] = {"jtag", "swd", NULL}; static const struct swd_driver vsllink_swd_driver = { .init = vsllink_swd_init, - .frequency = vsllink_swd_frequency, .switch_seq = vsllink_swd_switch_seq, .read_reg = vsllink_swd_read_reg, .write_reg = vsllink_swd_write_reg, .run = vsllink_swd_run_queue, }; -struct jtag_interface vsllink_interface = { - .name = "vsllink", +static struct jtag_interface vsllink_interface = { .supported = DEBUG_CAP_TMS_SEQ, - .commands = vsllink_command_handlers, + .execute_queue = vsllink_execute_queue, +}; + +struct adapter_driver vsllink_adapter_driver = { + .name = "vsllink", .transports = vsllink_transports, - .swd = &vsllink_swd_driver, + .commands = vsllink_command_handlers, .init = vsllink_init, .quit = vsllink_quit, - .khz = vsllink_khz, + .reset = vsllink_reset, .speed = vsllink_speed, + .khz = vsllink_khz, .speed_div = vsllink_speed_div, - .execute_queue = vsllink_execute_queue, + + .jtag_ops = &vsllink_interface, + .swd_ops = &vsllink_swd_driver, };