int jtag_libusb_open(const uint16_t vids[], const uint16_t pids[],
const char *serial,
struct jtag_libusb_device_handle **out)
{
int cnt, idx, errCode;
int retval = -ENODEV;
struct jtag_libusb_device_handle *libusb_handle = NULL;
if (libusb_init(&jtag_libusb_context) < 0)
return -ENODEV;
cnt = libusb_get_device_list(jtag_libusb_context, &devs);
for (idx = 0; idx < cnt; idx++) {
struct libusb_device_descriptor dev_desc;
if (libusb_get_device_descriptor(devs[idx], &dev_desc) != 0)
continue;
if (!jtag_libusb_match(&dev_desc, vids, pids))
continue;
errCode = libusb_open(devs[idx], &libusb_handle);
if (errCode) {
LOG_ERROR("libusb_open() failed with %s",
libusb_error_name(errCode));
continue;
}
/* Device must be open to use libusb_get_string_descriptor_ascii. */
if (serial != NULL &&
!string_descriptor_equal(libusb_handle, dev_desc.iSerialNumber, serial)) {
libusb_close(libusb_handle);
continue;
}
/* Success. */
*out = libusb_handle;
retval = 0;
break;
}
if (cnt >= 0)
libusb_free_device_list(devs, 1);
return retval;
}
int jtag_libusb_open(const uint16_t vids[], const uint16_t pids[],
const char *serial,
struct jtag_libusb_device_handle **out)
{
int retval = -ENODEV;
struct jtag_libusb_device_handle *libusb_handle;
usb_init();
usb_find_busses();
usb_find_devices();
struct usb_bus *busses = usb_get_busses();
for (struct usb_bus *bus = busses; bus; bus = bus->next) {
for (struct usb_device *dev = bus->devices;
dev; dev = dev->next) {
if (!jtag_libusb_match(dev, vids, pids))
continue;
libusb_handle = usb_open(dev);
if (NULL == libusb_handle) {
retval = -errno;
continue;
}
/* Device must be open to use libusb_get_string_descriptor_ascii. */
if (serial != NULL &&
!string_descriptor_equal(libusb_handle, dev->descriptor.iSerialNumber, serial)) {
usb_close(libusb_handle);
continue;
}
*out = libusb_handle;
retval = 0;
break;
}
}
return retval;
}
/* Helper to open a libusb device that matches vid, pid, product string and/or serial string.
* Set any field to 0 as a wildcard. If the device is found true is returned, with ctx containing
* the already opened handle. ctx->interface must be set to the desired interface (channel) number
* prior to calling this function. */
static bool open_matching_device(struct mpsse_ctx *ctx, const uint16_t *vid, const uint16_t *pid,
const char *product, const char *serial, const char *location)
{
libusb_device **list;
struct libusb_device_descriptor desc;
struct libusb_config_descriptor *config0;
int err;
bool found = false;
ssize_t cnt = libusb_get_device_list(ctx->usb_ctx, &list);
if (cnt < 0)
LOG_ERROR("libusb_get_device_list() failed with %s", libusb_error_name(cnt));
for (ssize_t i = 0; i < cnt; i++) {
libusb_device *device = list[i];
err = libusb_get_device_descriptor(device, &desc);
if (err != LIBUSB_SUCCESS) {
LOG_ERROR("libusb_get_device_descriptor() failed with %s", libusb_error_name(err));
continue;
}
if (vid && *vid != desc.idVendor)
continue;
if (pid && *pid != desc.idProduct)
continue;
err = libusb_open(device, &ctx->usb_dev);
if (err != LIBUSB_SUCCESS) {
LOG_ERROR("libusb_open() failed with %s",
libusb_error_name(err));
continue;
}
if (location && !device_location_equal(device, location)) {
libusb_close(ctx->usb_dev);
continue;
}
if (product && !string_descriptor_equal(ctx->usb_dev, desc.iProduct, product)) {
libusb_close(ctx->usb_dev);
continue;
}
if (serial && !string_descriptor_equal(ctx->usb_dev, desc.iSerialNumber, serial)) {
libusb_close(ctx->usb_dev);
continue;
}
found = true;
break;
}
libusb_free_device_list(list, 1);
if (!found) {
LOG_ERROR("no device found");
return false;
}
err = libusb_get_config_descriptor(libusb_get_device(ctx->usb_dev), 0, &config0);
if (err != LIBUSB_SUCCESS) {
LOG_ERROR("libusb_get_config_descriptor() failed with %s", libusb_error_name(err));
libusb_close(ctx->usb_dev);
return false;
}
/* Make sure the first configuration is selected */
int cfg;
err = libusb_get_configuration(ctx->usb_dev, &cfg);
if (err != LIBUSB_SUCCESS) {
LOG_ERROR("libusb_get_configuration() failed with %s", libusb_error_name(err));
goto error;
}
if (desc.bNumConfigurations > 0 && cfg != config0->bConfigurationValue) {
err = libusb_set_configuration(ctx->usb_dev, config0->bConfigurationValue);
if (err != LIBUSB_SUCCESS) {
LOG_ERROR("libusb_set_configuration() failed with %s", libusb_error_name(err));
goto error;
}
}
/* Try to detach ftdi_sio kernel module */
err = libusb_detach_kernel_driver(ctx->usb_dev, ctx->interface);
if (err != LIBUSB_SUCCESS && err != LIBUSB_ERROR_NOT_FOUND
&& err != LIBUSB_ERROR_NOT_SUPPORTED) {
LOG_ERROR("libusb_detach_kernel_driver() failed with %s", libusb_error_name(err));
goto error;
}
err = libusb_claim_interface(ctx->usb_dev, ctx->interface);
if (err != LIBUSB_SUCCESS) {
LOG_ERROR("libusb_claim_interface() failed with %s", libusb_error_name(err));
goto error;
}
/* Reset FTDI device */
err = libusb_control_transfer(ctx->usb_dev, FTDI_DEVICE_OUT_REQTYPE,
SIO_RESET_REQUEST, SIO_RESET_SIO,
ctx->index, NULL, 0, ctx->usb_write_timeout);
if (err < 0) {
LOG_ERROR("failed to reset FTDI device: %s", libusb_error_name(err));
goto error;
}
switch (desc.bcdDevice) {
case 0x500:
ctx->type = TYPE_FT2232C;
break;
case 0x700:
ctx->type = TYPE_FT2232H;
break;
case 0x800:
ctx->type = TYPE_FT4232H;
break;
case 0x900:
ctx->type = TYPE_FT232H;
break;
default:
LOG_ERROR("unsupported FTDI chip type: 0x%04x", desc.bcdDevice);
goto error;
}
/* Determine maximum packet size and endpoint addresses */
if (!(desc.bNumConfigurations > 0 && ctx->interface < config0->bNumInterfaces
&& config0->interface[ctx->interface].num_altsetting > 0))
goto desc_error;
const struct libusb_interface_descriptor *descriptor;
descriptor = &config0->interface[ctx->interface].altsetting[0];
if (descriptor->bNumEndpoints != 2)
goto desc_error;
ctx->in_ep = 0;
ctx->out_ep = 0;
for (int i = 0; i < descriptor->bNumEndpoints; i++) {
if (descriptor->endpoint[i].bEndpointAddress & 0x80) {
ctx->in_ep = descriptor->endpoint[i].bEndpointAddress;
ctx->max_packet_size =
descriptor->endpoint[i].wMaxPacketSize;
} else {
ctx->out_ep = descriptor->endpoint[i].bEndpointAddress;
}
}
if (ctx->in_ep == 0 || ctx->out_ep == 0)
goto desc_error;
libusb_free_config_descriptor(config0);
return true;
desc_error:
LOG_ERROR("unrecognized USB device descriptor");
error:
libusb_free_config_descriptor(config0);
libusb_close(ctx->usb_dev);
return false;
}