int jtag_libusb_set_configuration(jtag_libusb_device_handle *devh, int configuration) { struct jtag_libusb_device *udev = jtag_libusb_get_device(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; 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; }
///////////////////////////////////////--Code from Xin Gao void list_endpoints(libusb_device *dev) { libusb_config_descriptor *config; const libusb_interface *inter; const libusb_interface_descriptor *interdesc; const libusb_endpoint_descriptor *epdesc; int endpoints_no; int i; libusb_get_config_descriptor(dev, 0, &config); inter = &config->interface[0]; interdesc = &inter->altsetting[0]; endpoints_no=(int)interdesc->bNumEndpoints; cout<<"Number of endpoints: "<<endpoints_no<<endl; for(i=0;i<endpoints_no;i++) { epdesc = &interdesc->endpoint[i]; if(epdesc->bEndpointAddress & 0x80) printf("found an IN End Point %d with attributes %d and address 0x%x\n",i,epdesc->bmAttributes, epdesc->bEndpointAddress); else printf("found an OUT End Point %d with atributes %d and address 0x%x\n",i,epdesc->bmAttributes,epdesc->bEndpointAddress); } libusb_free_config_descriptor(config); return; }
bool USBTransport::open() { int nEp = 0; if (this->usb_dev_ == 0) { std::cerr << "Device not found!" << std::endl; return false; } int r = libusb_open(this->usb_dev_, &(this->pUSBHandle_)); if (r != 0) { std::cerr << "Not able to claim the USB device" << std::endl; return false; } else { libusb_config_descriptor *config; libusb_get_config_descriptor(this->usb_dev_, 0, &config); if (config->interface) { if (config->interface->altsetting) { r = libusb_claim_interface(this->pUSBHandle_, config->interface->altsetting->bInterfaceNumber); if ((nEp = config->interface->altsetting->bNumEndpoints)) { if (config->interface->altsetting->endpoint) { this->ucEpIn_ = (config->interface->altsetting->endpoint[0].bEndpointAddress); if (nEp > 1) { this->ucEpOut_ = (config->interface->altsetting->endpoint[1].bEndpointAddress); } } } } } } return true; }
int jtag_libusb_get_endpoints(struct jtag_libusb_device *udev, unsigned int *usb_read_ep, unsigned int *usb_write_ep) { const struct libusb_interface *inter; const struct libusb_interface_descriptor *interdesc; const struct libusb_endpoint_descriptor *epdesc; struct libusb_config_descriptor *config; 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; } } } libusb_free_config_descriptor(config); return 0; }
static int gp_libusb1_find_first_altsetting(struct libusb_device *dev, int *config, int *interface, int *altsetting) { int i, i1, i2; struct libusb_device_descriptor desc; if (LOG_ON_LIBUSB_E (libusb_get_device_descriptor (dev, &desc))) return -1; for (i = 0; i < desc.bNumConfigurations; i++) { struct libusb_config_descriptor *confdesc; if (LOG_ON_LIBUSB_E (libusb_get_config_descriptor (dev, i, &confdesc))) return -1; for (i1 = 0; i1 < confdesc->bNumInterfaces; i1++) for (i2 = 0; i2 < confdesc->interface[i1].num_altsetting; i2++) if (confdesc->interface[i1].altsetting[i2].bNumEndpoints) { *config = i; *interface = i1; *altsetting = i2; libusb_free_config_descriptor (confdesc); return 0; } libusb_free_config_descriptor (confdesc); } return -1; }
static void AddGCAdapter(libusb_device* device) { libusb_config_descriptor *config = nullptr; libusb_get_config_descriptor(device, 0, &config); for (u8 ic = 0; ic < config->bNumInterfaces; ic++) { const libusb_interface *interfaceContainer = &config->interface[ic]; for (int i = 0; i < interfaceContainer->num_altsetting; i++) { const libusb_interface_descriptor *interface = &interfaceContainer->altsetting[i]; for (u8 e = 0; e < interface->bNumEndpoints; e++) { const libusb_endpoint_descriptor *endpoint = &interface->endpoint[e]; if (endpoint->bEndpointAddress & LIBUSB_ENDPOINT_IN) s_endpoint_in = endpoint->bEndpointAddress; else s_endpoint_out = endpoint->bEndpointAddress; } } } int tmp = 0; unsigned char payload = 0x13; libusb_interrupt_transfer(s_handle, s_endpoint_out, &payload, sizeof(payload), &tmp, 16); s_adapter_thread_running.Set(true); s_adapter_thread = std::thread(Read); s_detected = true; if (s_detect_callback != nullptr) s_detect_callback(); }
int libusb_show_device(uint16_t vendor_id, uint16_t product_id) { struct libusb_device_handle *handle; struct libusb_device_descriptor desc; struct libusb_config_descriptor **config; int ret = 0, i, config_size; handle = libusb_open_device_with_vid_pid(NULL, vendor_id, product_id); if (handle == NULL) return -EIO; ret = libusb_get_device_descriptor(handle->dev, &desc); if (ret < 0) return -EINVAL; printf("usb device has %d configurations \n", desc.bNumConfigurations); config_size = sizeof(struct libusb_config_descriptor *) * desc.bNumConfigurations; config = (struct libusb_config_descriptor **) malloc(config_size); for (i = 0; i < desc.bNumConfigurations; i++) { ret = libusb_get_config_descriptor(handle->dev, i, &config[i]); if (ret < 0) { free(config); return -EINVAL; } } for (i = 0; i < desc.bNumConfigurations; i++) { show_config(config[i], i); } }
int libusb_get_config_descriptor_by_value(libusb_device *dev, uint8_t bConfigurationValue, struct libusb_config_descriptor **config) { struct LIBUSB20_DEVICE_DESC_DECODED *pdesc; struct libusb20_device *pdev; int i; int err; if (dev == NULL || config == NULL) return (LIBUSB_ERROR_INVALID_PARAM); pdev = dev->os_priv; pdesc = libusb20_dev_get_device_desc(pdev); for (i = 0; i < pdesc->bNumConfigurations; i++) { err = libusb_get_config_descriptor(dev, i, config); if (err) return (err); if ((*config)->bConfigurationValue == bConfigurationValue) return (0); /* success */ libusb_free_config_descriptor(*config); } *config = NULL; return (LIBUSB_ERROR_NOT_FOUND); }
int hwstub_probe(libusb_device *dev) { struct libusb_config_descriptor *config = NULL; int ret = -1; if(libusb_get_config_descriptor(dev, 0, &config) != 0) goto Lend; /* search hwstub interface */ for(unsigned i = 0; i < config->bNumInterfaces; i++) { /* hwstub interface has only one setting */ if(config->interface[i].num_altsetting != 1) continue; const struct libusb_interface_descriptor *intf = &config->interface[i].altsetting[0]; /* check class/subclass/protocol */ if(intf->bInterfaceClass != HWSTUB_CLASS || intf->bInterfaceSubClass != HWSTUB_SUBCLASS || intf->bInterfaceProtocol != HWSTUB_PROTOCOL) continue; /* found ! */ ret = i; break; } Lend: if(config) libusb_free_config_descriptor(config); return ret; }
///////////////////////////////////////--Code from Xin Gao void printdev(libusb_device *dev) { libusb_device_descriptor desc; int r = libusb_get_device_descriptor(dev, &desc); if (r < 0) { cout<<"failed to get device descriptor"<<endl; return; } cout<<"Number of possible configurations: "<<(int)desc.bNumConfigurations<<" "; cout<<"Device Class: "<<(int)desc.bDeviceClass<<" "; printf("VendorID: %.4X ",desc.idVendor); printf("ProductID: %.4X\n",desc.idProduct); libusb_config_descriptor *config; libusb_get_config_descriptor(dev, 0, &config); cout<<"Total interface number: "<<(int)config->bNumInterfaces<<" ||| "; const libusb_interface *inter; const libusb_interface_descriptor *interdesc; const libusb_endpoint_descriptor *epdesc; for(int i=0; i<(int)config->bNumInterfaces; i++) { inter = &config->interface[i]; cout<<"Number of alternate settings: "<<inter->num_altsetting<<" | "; for(int j=0; j<inter->num_altsetting; j++) { interdesc = &inter->altsetting[j]; cout<<"Interface Number: "<<(int)interdesc->bInterfaceNumber<<" | "; } } cout<<endl<<endl<<endl; libusb_free_config_descriptor(config); }
static int gp_port_usb_find_first_altsetting(struct libusb_device *dev, int *config, int *interface, int *altsetting) { int i, i1, i2, ret; struct libusb_device_descriptor desc; ret = libusb_get_device_descriptor (dev, &desc); if (ret) { gp_log (GP_LOG_ERROR, "libusb1", "libusb_get_device_descriptor ret %d", ret); return -1; } for (i = 0; i < desc.bNumConfigurations; i++) { struct libusb_config_descriptor *confdesc; ret = libusb_get_config_descriptor (dev, i, &confdesc); if (ret) return -1; for (i1 = 0; i1 < confdesc->bNumInterfaces; i1++) for (i2 = 0; i2 < confdesc->interface[i1].num_altsetting; i2++) if (confdesc->interface[i1].altsetting[i2].bNumEndpoints) { *config = i; *interface = i1; *altsetting = i2; libusb_free_config_descriptor (confdesc); return 0; } libusb_free_config_descriptor (confdesc); } return -1; }
static void libusb_get_description(struct libusb_device *device, struct libusb_adapter *adapter) { int j; unsigned i, k; struct libusb_config_descriptor *config; libusb_get_config_descriptor(device, 0, &config); for (i = 0; i < (int)config->bNumInterfaces; i++) { const struct libusb_interface *inter = &config->interface[i]; for(j = 0; j < inter->num_altsetting; j++) { const struct libusb_interface_descriptor *interdesc = &inter->altsetting[j]; #if 0 if (interdesc->bInterfaceClass == LIBUSB_CLASS_HID) #endif { adapter->interface_number = (int)interdesc->bInterfaceNumber; for(k = 0; k < (int)interdesc->bNumEndpoints; k++) { const struct libusb_endpoint_descriptor *epdesc = &interdesc->endpoint[k]; bool is_int = (epdesc->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) == LIBUSB_TRANSFER_TYPE_INTERRUPT; bool is_out = (epdesc->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_OUT; bool is_in = (epdesc->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_IN; if (is_int) { if (is_in) { adapter->endpoint_in = epdesc->bEndpointAddress; adapter->endpoint_in_max_size = epdesc->wMaxPacketSize; } if (is_out) { adapter->endpoint_out = epdesc->bEndpointAddress; adapter->endpoint_out_max_size = epdesc->wMaxPacketSize; } } } } goto ret; } } ret: libusb_free_config_descriptor(config); }
static int32_t dfu_find_interface( struct libusb_device *device, const dfu_bool honor_interfaceclass, const uint8_t bNumConfigurations) { int32_t c,i,s; TRACE( "%s()\n", __FUNCTION__ ); /* Loop through all of the configurations */ for( c = 0; c < bNumConfigurations; c++ ) { struct libusb_config_descriptor *config; if( libusb_get_config_descriptor(device, c, &config) ) { DEBUG( "can't get_config_descriptor: %d\n", c ); return -1; } DEBUG( "config %d: maxpower=%d*2 mA\n", c, config->MaxPower ); /* Loop through all of the interfaces */ for( i = 0; i < config->bNumInterfaces; i++ ) { struct libusb_interface interface; interface = config->interface[i]; DEBUG( "interface %d\n", i ); /* Loop through all of the settings */ for( s = 0; s < interface.num_altsetting; s++ ) { struct libusb_interface_descriptor setting; setting = interface.altsetting[s]; DEBUG( "setting %d: class:%d, subclass %d, protocol:%d\n", s, setting.bInterfaceClass, setting.bInterfaceSubClass, setting.bInterfaceProtocol ); if( honor_interfaceclass ) { /* Check if the interface is a DFU interface */ if( (USB_CLASS_APP_SPECIFIC == setting.bInterfaceClass) && (DFU_SUBCLASS == setting.bInterfaceSubClass) ) { DEBUG( "Found DFU Interface: %d\n", setting.bInterfaceNumber ); return setting.bInterfaceNumber; } } else { /* If there is a bug in the DFU firmware, return the first * found interface. */ DEBUG( "Found DFU Interface: %d\n", setting.bInterfaceNumber ); return setting.bInterfaceNumber; } } } libusb_free_config_descriptor( config ); } return -1; }
ConfigurationPtr Device::config(uint8_t index) throw(USBError) { struct libusb_config_descriptor *config = NULL; int rc = libusb_get_config_descriptor(dev, index, &config); if (rc != LIBUSB_SUCCESS) { throw USBError(libusb_error_name(rc)); } Configuration *result = new Configuration(*this, config); libusb_free_config_descriptor(config); return ConfigurationPtr(result); }
int shdev_usb_init(shdev_t *c_dev) { #ifdef USE_USB struct libusb_device *dev = NULL; struct libusb_config_descriptor *conf_desc; libusb_device_handle *hndl = NULL; char ebuf[1024]; char buf[4096]; char rbuf[1024]; uint16_t max_len; unsigned int r_len; unsigned int len; int nb_ifaces; int val; int code; int iface; int err; int i; hndl = libusb_open_device_with_vid_pid(NULL, c_dev->def->arg1, c_dev->def->arg2); if (!hndl) return (SHERR_IO); #ifdef __linux__ /* detach kernel from device. */ libusb_detach_kernel_driver(hndl, 0); #endif /* Claim the device if it lists one or more interfaces available. */ dev = libusb_get_device(hndl); libusb_get_config_descriptor(dev, 0, &conf_desc); nb_ifaces = conf_desc->bNumInterfaces; if (nb_ifaces) { for (iface = 0; iface < nb_ifaces; iface++) { err = libusb_claim_interface(hndl, iface); if (err != LIBUSB_SUCCESS) continue; /* in use */ sprintf(ebuf, "claimed usb v%d:p%d (iface #%d).", c_dev->def->arg1, c_dev->def->arg2, iface); shinfo(ebuf); fprintf(stderr, "DEBUG: %s\n", ebuf); break; } if (iface == nb_ifaces) { /* no slots left */ return (SHERR_AGAIN); } } c_dev->usb = hndl; c_dev->iface = iface; #endif return (0); }
/** * Check the USB configuration to determine if this is a Saleae Logic. * * @return 1 if the device's configuration profile match the Logic firmware's * configuration, 0 otherwise. */ static int check_conf_profile(libusb_device *dev) { struct libusb_device_descriptor des; struct libusb_config_descriptor *conf_dsc = NULL; const struct libusb_interface_descriptor *intf_dsc; int ret = -1; while (ret == -1) { /* Assume it's not a Saleae Logic unless proven wrong. */ ret = 0; if (libusb_get_device_descriptor(dev, &des) != 0) break; if (des.bNumConfigurations != 1) /* Need exactly 1 configuration. */ break; if (libusb_get_config_descriptor(dev, 0, &conf_dsc) != 0) break; if (conf_dsc->bNumInterfaces != 1) /* Need exactly 1 interface. */ break; if (conf_dsc->interface[0].num_altsetting != 1) /* Need just one alternate setting. */ break; intf_dsc = &(conf_dsc->interface[0].altsetting[0]); if (intf_dsc->bNumEndpoints != 2) /* Need 2 endpoints. */ break; if ((intf_dsc->endpoint[0].bEndpointAddress & 0x8f) != (1 | LIBUSB_ENDPOINT_OUT)) /* First endpoint should be 1 (outbound). */ break; if ((intf_dsc->endpoint[1].bEndpointAddress & 0x8f) != (2 | LIBUSB_ENDPOINT_IN)) /* First endpoint should be 2 (inbound). */ break; /* If we made it here, it must be a Saleae Logic. */ ret = 1; } if (conf_dsc) libusb_free_config_descriptor(conf_dsc); return ret; }
/** \ingroup desc * Get a USB configuration descriptor with a specific bConfigurationValue. * This is a non-blocking function which does not involve any requests being * sent to the device. * * \param dev a device * \param bConfigurationValue the bConfigurationValue of the configuration you * wish to retrieve * \param config output location for the USB configuration descriptor. Only * valid if 0 was returned. Must be freed with libusb_free_config_descriptor() * after use. * \returns 0 on success * \returns LIBUSB_ERROR_NOT_FOUND if the configuration does not exist * \returns another LIBUSB_ERROR code on error * \see libusb_get_active_config_descriptor() * \see libusb_get_config_descriptor() */ int API_EXPORTED libusb_get_config_descriptor_by_value(libusb_device *dev, uint8_t bConfigurationValue, struct libusb_config_descriptor **config) { int idx; int r = usbi_get_config_index_by_value(dev, bConfigurationValue, &idx); if (r < 0) return r; else if (idx == -1) return LIBUSB_ERROR_NOT_FOUND; else return libusb_get_config_descriptor(dev, (uint8_t) idx, config); }
static GSList *scpi_usbtmc_libusb_scan(struct drv_context *drvc) { struct libusb_device **devlist; struct libusb_device_descriptor des; struct libusb_config_descriptor *confdes; const struct libusb_interface_descriptor *intfdes; GSList *resources = NULL; int confidx, intfidx, ret, i; char *res; ret = libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist); if (ret < 0) { sr_err("Failed to get device list: %s.", libusb_error_name(ret)); return NULL; } for (i = 0; devlist[i]; i++) { if ((ret = libusb_get_device_descriptor(devlist[i], &des))) { sr_err("Failed to get device descriptor: %s.", libusb_error_name(ret)); continue; } for (confidx = 0; confidx < des.bNumConfigurations; confidx++) { if (libusb_get_config_descriptor(devlist[i], confidx, &confdes) != 0) { sr_err("Failed to get configuration descriptor: %s.", libusb_error_name(ret)); break; } for (intfidx = 0; intfidx < confdes->bNumInterfaces; intfidx++) { intfdes = confdes->interface[intfidx].altsetting; if (intfdes->bInterfaceClass != LIBUSB_CLASS_APPLICATION || intfdes->bInterfaceSubClass != SUBCLASS_USBTMC || intfdes->bInterfaceProtocol != USBTMC_USB488) continue; sr_dbg("Found USBTMC device (VID:PID = %04x:%04x, " "bus.address = %d.%d).", des.idVendor, des.idProduct, libusb_get_bus_number(devlist[i]), libusb_get_device_address(devlist[i])); res = g_strdup_printf("usbtmc/%d.%d", libusb_get_bus_number(devlist[i]), libusb_get_device_address(devlist[i])); resources = g_slist_append(resources, res); } libusb_free_config_descriptor(confdes); } } libusb_free_device_list(devlist, 1); sr_dbg("Found %d device(s).", g_slist_length(resources)); return resources; }
int libusb_get_active_config_descriptor(libusb_device *dev, struct libusb_config_descriptor **config) { struct libusb20_device *pdev; uint8_t config_index; pdev = dev->os_priv; config_index = libusb20_dev_get_config_index(pdev); return (libusb_get_config_descriptor(dev, config_index, config)); }
static int initialize_device(struct usb_device *dev) { libusb_device *newlib_dev = dev->dev; int num_configurations; size_t alloc_size; int r; int i; /* device descriptor is identical in both libs */ r = libusb_get_device_descriptor(newlib_dev, (struct libusb_device_descriptor *) &dev->descriptor); if (r < 0) { usbi_err("error %d getting device descriptor", r); return compat_err(r); } num_configurations = dev->descriptor.bNumConfigurations; alloc_size = sizeof(struct usb_config_descriptor) * num_configurations; dev->config = malloc(alloc_size); if (!dev->config) return -ENOMEM; memset(dev->config, 0, alloc_size); /* even though structures are identical, we can't just use libusb-1.0's * config descriptors because we have to store all configurations in * a single flat memory area (libusb-1.0 provides separate allocations). * we hand-copy libusb-1.0's descriptors into our own structures. */ for (i = 0; i < num_configurations; i++) { struct libusb_config_descriptor *newlib_config; r = libusb_get_config_descriptor(newlib_dev, i, &newlib_config); if (r < 0) { clear_device(dev); free(dev->config); return compat_err(r); } r = copy_config_descriptor(dev->config + i, newlib_config); libusb_free_config_descriptor(newlib_config); if (r < 0) { clear_device(dev); free(dev->config); return r; } } /* libusb doesn't implement this and it doesn't seem that important. If * someone asks for it, we can implement it in v1.1 or later. */ dev->num_children = 0; dev->children = NULL; libusb_ref_device(newlib_dev); return 0; }
void print_devices(libusb_device *dev) { struct libusb_device_descriptor desc; struct libusb_config_descriptor *config; const struct libusb_interface *inter; const struct libusb_interface_descriptor *interdesc; const struct libusb_endpoint_descriptor *endpointdesc; int ret; int i, j, k; ret = libusb_get_device_descriptor(dev, &desc); if(ret < 0) { fprintf(stderr, "error in getting device descriptor\n"); return; } printf("number of pos config is %d\n", desc.bNumConfigurations); printf("Device class: %d\n", desc.idVendor); printf("Product ID: %d\n", desc.idProduct); libusb_get_config_descriptor(dev, 0, &config); printf("Interface: %d\n", config->bNumInterfaces); for(i = 0; i , config->bNumInterfaces; i++) { inter = &config->interface[i]; printf(" number of alt settings: %d\n", inter->num_altsetting); for(j = 0; j < inter->num_altsetting; j++) { interdesc = &inter->altsetting[j]; printf(" Interface number: %d, ", interdesc->bInterfaceNumber); printf(" Num of endpoints: %d\n", interdesc->bNumEndpoints); for(k = 0; k < interdesc->bNumEndpoints; k++) { endpointdesc = &interdesc->endpoint[k]; printf(" Desc Type: %d, ", endpointdesc->bDescriptorType); printf(" EP addr: %d\n", endpointdesc->bEndpointAddress); } } } printf("\n\n"); libusb_free_config_descriptor(config); }
int jtag_libusb_choose_interface(struct jtag_libusb_device_handle *devh, unsigned int *usb_read_ep, unsigned int *usb_write_ep, int bclass, int subclass, int protocol) { 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]; 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]; 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 ERROR_FAIL; }
int jtag_libusb_set_configuration(jtag_libusb_device_handle *devh, int configuration) { struct jtag_libusb_device *udev = jtag_libusb_get_device(devh); int retCode = -99; struct libusb_config_descriptor *config = NULL; libusb_get_config_descriptor(udev, configuration, &config); retCode = libusb_set_configuration(devh, config->bConfigurationValue); libusb_free_config_descriptor(config); return retCode; }
/* * Iterate through the the interfaces of the USB device and print out the interface details to the console. */ void SickTimCommonUsb::printUSBInterfaceDetails(libusb_device* device) { struct libusb_config_descriptor *config; /* * Get a USB configuration descriptor based on its index. */ libusb_get_config_descriptor(device, 0, &config); ROS_INFO("Interfaces: %i", (int)config->bNumInterfaces); ROS_INFO("----------------------------------------"); const struct libusb_interface *interface; const struct libusb_interface_descriptor *interface_descriptor; const struct libusb_endpoint_descriptor *endpoint_descriptor; int i, j, k; for (i = 0; i < config->bNumInterfaces; i++) { interface = &config->interface[i]; ROS_INFO("Number of alternate settings: %i", interface->num_altsetting); for (j = 0; j < interface->num_altsetting; j++) { interface_descriptor = &interface->altsetting[j]; ROS_INFO("Interface number: %i", (int)interface_descriptor->bInterfaceNumber); ROS_INFO("Number of endpoints: %i", (int)interface_descriptor->bNumEndpoints); for (k = 0; k < interface_descriptor->bNumEndpoints; k++) { endpoint_descriptor = &interface_descriptor->endpoint[k]; ROS_INFO("Descriptor Type: %i", endpoint_descriptor->bDescriptorType); ROS_INFO("EP Address: %i", endpoint_descriptor->bEndpointAddress); } } if (i < config->bNumInterfaces - 1) { ROS_INFO("----------------------------------------"); } } /* * Free the configuration descriptor obtained from 'libusb_get_config_descriptor' */ libusb_free_config_descriptor(config); }
/** * Find USB devices supporting the USBTMC class * * @param usb_ctx libusb context to use while scanning. * * @return A GSList of struct sr_usb_dev_inst, with bus and address fields * indicating devices with USBTMC support. */ SR_PRIV GSList *sr_usb_find_usbtmc(libusb_context *usb_ctx) { struct sr_usb_dev_inst *usb; struct libusb_device **devlist; struct libusb_device_descriptor des; struct libusb_config_descriptor *confdes; const struct libusb_interface_descriptor *intfdes; GSList *devices; int confidx, intfidx, ret, i; devices = NULL; libusb_get_device_list(usb_ctx, &devlist); for (i = 0; devlist[i]; i++) { if ((ret = libusb_get_device_descriptor(devlist[i], &des))) { sr_err("Failed to get device descriptor: %s.", libusb_error_name(ret)); continue; } for (confidx = 0; confidx < des.bNumConfigurations; confidx++) { if (libusb_get_config_descriptor(devlist[i], confidx, &confdes) != 0) { sr_err("Failed to get configuration descriptor."); break; } for (intfidx = 0; intfidx < confdes->bNumInterfaces; intfidx++) { intfdes = confdes->interface[intfidx].altsetting; if (intfdes->bInterfaceClass != LIBUSB_CLASS_APPLICATION || intfdes->bInterfaceSubClass != SUBCLASS_USBTMC || intfdes->bInterfaceProtocol != USBTMC_USB488) continue; sr_dbg("Found USBTMC device (VID:PID = %04x:%04x, bus.address = " "%d.%d).", des.idVendor, des.idProduct, libusb_get_bus_number(devlist[i]), libusb_get_device_address(devlist[i])); usb = sr_usb_dev_inst_new(libusb_get_bus_number(devlist[i]), libusb_get_device_address(devlist[i]), NULL); devices = g_slist_append(devices, usb); } libusb_free_config_descriptor(confdes); } } libusb_free_device_list(devlist, 1); sr_dbg("Found %d device(s).", g_slist_length(devices)); return devices; }
static int getDevConfig(libusb_device *dev, struct libusb_config_descriptor **config) { int res = libusb_get_active_config_descriptor(dev, config); if(res==LIBUSB_ERROR_NOT_FOUND){ HALLOG("not yet configured\n"); if(libusb_get_config_descriptor(dev, 0, config)!=0){ return -1; } }else if(res!=0){ HALLOG("unable to get active configuration %d\n",res); return -1; } return 0; }
struct ft232r_device_handle *ft232r_open(libusb_device *dev) { // FIXME: Cleanup on errors libusb_device_handle *devh; struct ft232r_device_handle *ftdi; if (libusb_open(dev, &devh)) { applog(LOG_ERR, "ft232r_open: Error opening device"); return NULL; } libusb_reset_device(devh); libusb_detach_kernel_driver(devh, 0); if (libusb_set_configuration(devh, 1)) { applog(LOG_ERR, "ft232r_open: Error setting configuration"); return NULL; } if (libusb_claim_interface(devh, 0)) { applog(LOG_ERR, "ft232r_open: Error claiming interface"); return NULL; } if (libusb_control_transfer(devh, FTDI_REQTYPE_OUT, FTDI_REQUEST_SET_BAUDRATE, FTDI_BAUDRATE_3M, NULL, 0, FTDI_TIMEOUT) < 0) { applog(LOG_ERR, "ft232r_open: Error performing control transfer"); return NULL; } struct libusb_config_descriptor *cfg; if (libusb_get_config_descriptor(dev, 0, &cfg)) { applog(LOG_ERR, "ft232r_open: Error getting config descriptor"); return NULL; } const struct libusb_interface_descriptor *altcfg = &cfg->interface[0].altsetting[0]; if (altcfg->bNumEndpoints < 2) { applog(LOG_ERR, "ft232r_open: Too few endpoints"); return NULL; } ftdi = calloc(1, sizeof(*ftdi)); ftdi->h = devh; ftdi->i = altcfg->endpoint[0].bEndpointAddress; ftdi->o = altcfg->endpoint[1].bEndpointAddress; ftdi->osz = 0x1000; ftdi->obuf = malloc(ftdi->osz); libusb_free_config_descriptor(cfg); return ftdi; }
static void print_devs(libusb_device **devs) { libusb_device *dev; struct libusb_config_descriptor *conf_desc; int nb_ifaces = 0; int i = 0, j = 0, n = 0; uint8_t path[8]; while ((dev = devs[n++]) != NULL) { struct libusb_device_descriptor desc; int r = libusb_get_device_descriptor(dev, &desc); if (r < 0) { fprintf(stderr, "failed to get device descriptor"); return; } printf("%04x:%04x (bus %d, device %d)", desc.idVendor, desc.idProduct, libusb_get_bus_number(dev), libusb_get_device_address(dev)); r = libusb_get_port_numbers(dev, path, sizeof(path)); if (r > 0) { printf(" path: %d", path[0]); for (j = 1; j < r; j++) printf(".%d", path[j]); } printf("\n"); libusb_get_config_descriptor(dev, 0, &conf_desc); nb_ifaces = conf_desc->bNumInterfaces; fprintf(stdout, "nb_ifaces:::%d\n", nb_ifaces); for (i=0; i<nb_ifaces; i++) { printf(" interface[%d]: id = %d\n", i, conf_desc->interface[i].altsetting[0].bInterfaceNumber); for (j=0; j<conf_desc->interface[i].num_altsetting; j++) { printf("interface[%d].altsetting[%d]: num endpoints = %d\n", i, j, conf_desc->interface[i].altsetting[j].bNumEndpoints); printf(" Class.SubClass.Protocol: %02X.%02X.%02X\n", conf_desc->interface[i].altsetting[j].bInterfaceClass, conf_desc->interface[i].altsetting[j].bInterfaceSubClass, conf_desc->interface[i].altsetting[j].bInterfaceProtocol); } } } }
bool IdacDriverUsb24Base::checkUsbFirmwareReady() { CHECK_PRECOND_RETVAL(handle() != NULL, false); bool b = false; libusb_device* dev = libusb_get_device(handle()); CHECK_ASSERT_RETVAL(dev != NULL, false); libusb_config_descriptor* config = NULL; int res = libusb_get_config_descriptor(dev, 0, &config); CHECK_USBRESULT_RETVAL(res, false); if (config->bNumInterfaces == 1) { const libusb_interface* interface = &config->interface[0]; b = (interface->num_altsetting == 1); } //interface[0].altsetting[0].bNumEndpoints != 3 return b; }
/** * Checks if the given end point is available */ bool A2300::BulkDataPort::EndPointAvailable(byte epid) { libusb_device *pDev = libusb_get_device(DeviceHandle()); libusb_device_descriptor desc; int retval = libusb_get_device_descriptor(pDev, &desc); if (retval < 0) { return false; } libusb_config_descriptor *config; libusb_get_config_descriptor(pDev, 0, &config); const libusb_interface *inter; const libusb_interface_descriptor *interdesc; const libusb_endpoint_descriptor *epdesc; 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]; if (epdesc->bEndpointAddress == epid) { libusb_free_config_descriptor(config); return true; } } } } libusb_free_config_descriptor(config); return false; }