X-Git-Url: https://review.openocd.org/gitweb?p=openocd.git;a=blobdiff_plain;f=src%2Fjtag%2Fdrivers%2Flibusb1_common.c;h=a1db86f4bb9e05f08022cf9d593a9751d2a1d38e;hp=194f737cde3a9f87955b2ec594d85765e3c6051c;hb=d1b74376336814266236054f925a9964b87dd8a5;hpb=d8b912755d3d47419584b51186b77dc48c5fee23 diff --git a/src/jtag/drivers/libusb1_common.c b/src/jtag/drivers/libusb1_common.c index 194f737cde..a1db86f4bb 100644 --- a/src/jtag/drivers/libusb1_common.c +++ b/src/jtag/drivers/libusb1_common.c @@ -14,9 +14,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., * - * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. * + * along with this program. If not, see . * ***************************************************************************/ #ifdef HAVE_CONFIG_H @@ -28,47 +26,91 @@ static struct libusb_context *jtag_libusb_context; /**< Libusb context **/ static libusb_device **devs; /**< The usb device list **/ -static bool jtag_libusb_match(struct jtag_libusb_device *dev, +static bool jtag_libusb_match(struct libusb_device_descriptor *dev_desc, const uint16_t vids[], const uint16_t pids[]) { - struct libusb_device_descriptor dev_desc; - - for (unsigned i = 0; vids[i] && pids[i]; i++) { - if (libusb_get_device_descriptor(dev, &dev_desc) == 0) { - if (dev_desc.idVendor == vids[i] && - dev_desc.idProduct == pids[i]) - return true; + for (unsigned i = 0; vids[i]; i++) { + if (dev_desc->idVendor == vids[i] && + dev_desc->idProduct == pids[i]) { + return true; } } return false; } +/* Returns true if the string descriptor indexed by str_index in device matches string */ +static bool string_descriptor_equal(libusb_device_handle *device, uint8_t str_index, + const char *string) +{ + int retval; + bool matched; + char desc_string[256+1]; /* Max size of string descriptor */ + + if (str_index == 0) + return false; + + retval = libusb_get_string_descriptor_ascii(device, str_index, + (unsigned char *)desc_string, sizeof(desc_string)-1); + if (retval < 0) { + LOG_ERROR("libusb_get_string_descriptor_ascii() failed with %d", retval); + return false; + } + + /* Null terminate descriptor string in case it needs to be logged. */ + desc_string[sizeof(desc_string)-1] = '\0'; + + matched = strncmp(string, desc_string, sizeof(desc_string)) == 0; + if (!matched) + LOG_DEBUG("Device serial number '%s' doesn't match requested serial '%s'", + desc_string, string); + return matched; +} + 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 = ERROR_FAIL; + struct jtag_libusb_device_handle *libusb_handle = NULL; if (libusb_init(&jtag_libusb_context) < 0) - return -ENODEV; - - libusb_set_debug(jtag_libusb_context, 3); + return ERROR_FAIL; cnt = libusb_get_device_list(jtag_libusb_context, &devs); for (idx = 0; idx < cnt; idx++) { - if (!jtag_libusb_match(devs[idx], vids, pids)) + struct libusb_device_descriptor dev_desc; + + if (libusb_get_device_descriptor(devs[idx], &dev_desc) != 0) continue; - errCode = libusb_open(devs[idx], out); + if (!jtag_libusb_match(&dev_desc, vids, pids)) + continue; - /** Free the device list **/ - libusb_free_device_list(devs, 1); + errCode = libusb_open(devs[idx], &libusb_handle); + + if (errCode) { + LOG_ERROR("libusb_open() failed with %s", + libusb_error_name(errCode)); + continue; + } - if (errCode < 0) - return errCode; - return 0; + /* 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 = ERROR_OK; + break; } - return -ENODEV; + if (cnt >= 0) + libusb_free_device_list(devs, 1); + return retval; } void jtag_libusb_close(jtag_libusb_device_handle *dev) @@ -79,6 +121,21 @@ void jtag_libusb_close(jtag_libusb_device_handle *dev) libusb_exit(jtag_libusb_context); } +int jtag_libusb_control_transfer(jtag_libusb_device_handle *dev, uint8_t requestType, + uint8_t request, uint16_t wValue, uint16_t wIndex, char *bytes, + uint16_t size, unsigned int timeout) +{ + int transferred = 0; + + transferred = libusb_control_transfer(dev, requestType, request, wValue, wIndex, + (unsigned char *)bytes, size, timeout); + + if (transferred < 0) + transferred = 0; + + return transferred; +} + int jtag_libusb_bulk_write(jtag_libusb_device_handle *dev, int ep, char *bytes, int size, int timeout) { @@ -106,47 +163,88 @@ int jtag_libusb_set_configuration(jtag_libusb_device_handle *devh, int retCode = -99; struct libusb_config_descriptor *config = NULL; + int current_config = -1; + + retCode = libusb_get_configuration(devh, ¤t_config); + if (retCode != 0) + return retCode; - libusb_get_config_descriptor(udev, configuration, &config); - retCode = libusb_set_configuration(devh, config->bConfigurationValue); + retCode = libusb_get_config_descriptor(udev, configuration, &config); + if (retCode != 0 || config == NULL) + return retCode; + + /* Only change the configuration if it is not already set to the + same one. Otherwise this issues a lightweight reset and hangs + LPC-Link2 with JLink firmware. */ + if (current_config != config->bConfigurationValue) + retCode = libusb_set_configuration(devh, config->bConfigurationValue); libusb_free_config_descriptor(config); return retCode; } -int jtag_libusb_get_endpoints(struct jtag_libusb_device *udev, +int jtag_libusb_choose_interface(struct jtag_libusb_device_handle *devh, unsigned int *usb_read_ep, - unsigned int *usb_write_ep) + unsigned int *usb_write_ep, + int bclass, int subclass, int protocol, int trans_type) { + struct jtag_libusb_device *udev = jtag_libusb_get_device(devh); const struct libusb_interface *inter; const struct libusb_interface_descriptor *interdesc; const struct libusb_endpoint_descriptor *epdesc; struct libusb_config_descriptor *config; + *usb_read_ep = *usb_write_ep = 0; + libusb_get_config_descriptor(udev, 0, &config); for (int i = 0; i < (int)config->bNumInterfaces; i++) { inter = &config->interface[i]; - for (int j = 0; j < inter->num_altsetting; j++) { - interdesc = &inter->altsetting[j]; - for (int k = 0; - k < (int)interdesc->bNumEndpoints; k++) { - epdesc = &interdesc->endpoint[k]; - - uint8_t epnum = epdesc->bEndpointAddress; - bool is_input = epnum & 0x80; - LOG_DEBUG("usb ep %s %02x", - is_input ? "in" : "out", epnum); - - if (is_input) - *usb_read_ep = epnum; - else - *usb_write_ep = epnum; + interdesc = &inter->altsetting[0]; + for (int k = 0; + k < (int)interdesc->bNumEndpoints; k++) { + if ((bclass > 0 && interdesc->bInterfaceClass != bclass) || + (subclass > 0 && interdesc->bInterfaceSubClass != subclass) || + (protocol > 0 && interdesc->bInterfaceProtocol != protocol)) + continue; + + epdesc = &interdesc->endpoint[k]; + if (trans_type > 0 && (epdesc->bmAttributes & 0x3) != trans_type) + continue; + + uint8_t epnum = epdesc->bEndpointAddress; + bool is_input = epnum & 0x80; + LOG_DEBUG("usb ep %s %02x", + is_input ? "in" : "out", epnum); + + if (is_input) + *usb_read_ep = epnum; + else + *usb_write_ep = epnum; + + if (*usb_read_ep && *usb_write_ep) { + LOG_DEBUG("Claiming interface %d", (int)interdesc->bInterfaceNumber); + libusb_claim_interface(devh, (int)interdesc->bInterfaceNumber); + libusb_free_config_descriptor(config); + return ERROR_OK; } } } libusb_free_config_descriptor(config); - return 0; + return ERROR_FAIL; +} + +int jtag_libusb_get_pid(struct jtag_libusb_device *dev, uint16_t *pid) +{ + struct libusb_device_descriptor dev_desc; + + if (libusb_get_device_descriptor(dev, &dev_desc) == 0) { + *pid = dev_desc.idProduct; + + return ERROR_OK; + } + + return ERROR_FAIL; }