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 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; }
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_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 void morpheus_close_usb_device( MorpheusUSBContext *morpheus_context) { for (int interface_index = 0; morpheus_context->usb_claimed_interface_mask != 0; ++interface_index) { int interface_mask = 1 << interface_index; if ((morpheus_context->usb_claimed_interface_mask & interface_mask) != 0) { libusb_release_interface(morpheus_context->usb_device_handle, interface_index); morpheus_context->usb_claimed_interface_mask &= ~interface_mask; } } if (morpheus_context->usb_device_descriptor != nullptr) { libusb_free_config_descriptor(morpheus_context->usb_device_descriptor); morpheus_context->usb_device_descriptor = nullptr; } if (morpheus_context->usb_device_handle != nullptr) { libusb_close(morpheus_context->usb_device_handle); morpheus_context->usb_device_handle = nullptr; } if (morpheus_context->usb_context != nullptr) { libusb_exit(morpheus_context->usb_context); morpheus_context->usb_context = nullptr; } }
/* Retrieves alternate interface name string. * Returns string length, or negative on error */ int get_alt_name(struct dfu_if *dfu_if, unsigned char *name) { libusb_device *dev = dfu_if->dev; struct libusb_config_descriptor *cfg; int alt_name_str_idx; int ret; ret = libusb_get_config_descriptor_by_value(dev, dfu_if->configuration, &cfg); if (ret) return ret; alt_name_str_idx = cfg->interface[dfu_if->interface]. altsetting[dfu_if->altsetting].iInterface; ret = -1; if (alt_name_str_idx) { if (!dfu_if->dev_handle) if (libusb_open(dfu_if->dev, &dfu_if->dev_handle)) dfu_if->dev_handle = NULL; if (dfu_if->dev_handle) ret = libusb_get_string_descriptor_ascii( dfu_if->dev_handle, alt_name_str_idx, name, MAX_DESC_STR_LEN); } libusb_free_config_descriptor(cfg); return ret; }
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; }
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 UsbDeviceManager::enumerateAvailableDevices( const enumerationcallback_t& cb) { void** device_list; int result = OK; ssize_t count = libusb_get_device_list(mContext, (libusb_device***)&device_list); if (count <= 0) { result = count; } else { libusb_device_descriptor desc; libusb_config_descriptor* config; bool keepGoing = true; void** current = device_list; while (*current && keepGoing) { libusb_get_device_descriptor((libusb_device*)*current, &desc); libusb_get_active_config_descriptor((libusb_device*)*current, &config); keepGoing = cb(desc, *config); libusb_free_config_descriptor(config); ++current; } libusb_free_device_list((libusb_device**)device_list, 1); } return result; }
static void foreach_usb_device(libusb_context* usb_context, std::function<void( const usb_device_info&, libusb_device*)> action) { // Obtain libusb_device_handle for each device libusb_device ** list = nullptr; int status = libusb_get_device_list(usb_context, &list); if(status < 0) throw linux_backend_exception(to_string() << "libusb_get_device_list(...) returned " << libusb_error_name(status)); for(int i=0; list[i]; ++i) { libusb_device * usb_device = list[i]; libusb_config_descriptor *config; status = libusb_get_active_config_descriptor(usb_device, &config); if(status == 0) { auto parent_device = libusb_get_parent(usb_device); //if (parent_device) { usb_device_info info{}; std::stringstream ss; info.unique_id = get_usb_port_id(usb_device); info.mi = config->bNumInterfaces - 1; // The hardware monitor USB interface is expected to be the last one action(info, usb_device); } libusb_free_config_descriptor(config); } } libusb_free_device_list(list, 1); }
int API_EXPORTED libusb_get_max_iso_packet_size(libusb_device *dev, unsigned char endpoint) { struct libusb_config_descriptor *config; const struct libusb_endpoint_descriptor *ep; enum libusb_transfer_type ep_type; uint16_t val; int r; r = libusb_get_active_config_descriptor(dev, &config); if (r < 0) { usbi_err(DEVICE_CTX(dev), "could not retrieve active config descriptor"); return LIBUSB_ERROR_OTHER; } ep = find_endpoint(config, endpoint); if (!ep) return LIBUSB_ERROR_NOT_FOUND; val = ep->wMaxPacketSize; ep_type = ep->bmAttributes & 0x3; libusb_free_config_descriptor(config); r = val & 0x07ff; if (ep_type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS || ep_type == LIBUSB_TRANSFER_TYPE_INTERRUPT) r *= (1 + ((val >> 11) & 3)); return r; }
static int getEndpoint(libusb_device *dev, int* input, int* output) { struct libusb_config_descriptor *config; int altsetting_index,interface_index=0,ret_active; int i,ret_print; *input = 0; *output = 0; ret_active = libusb_get_active_config_descriptor(dev,&config); for(interface_index = 0; interface_index < config->bNumInterfaces; interface_index++) { const struct libusb_interface *iface = &config->interface[interface_index]; for( altsetting_index = 0; altsetting_index < iface->num_altsetting; altsetting_index++ ) { const struct libusb_interface_descriptor *altsetting = &iface->altsetting[altsetting_index]; int endpoint_index; for(endpoint_index=0;endpoint_index<altsetting->bNumEndpoints;endpoint_index++) { const struct libusb_endpoint_descriptor *endpoint = &altsetting->endpoint[endpoint_index]; TraceOp.trc( name, TRCLEVEL_INFO, __LINE__, 9999,"EP addr=0x%02X type=%d packetsize=%d", endpoint->bEndpointAddress, endpoint->bDescriptorType, endpoint->wMaxPacketSize ); if( endpoint->bEndpointAddress & 0x80 ) *input = endpoint->bEndpointAddress; else *output = endpoint->bEndpointAddress; } } } libusb_free_config_descriptor(NULL); return 0; }
static int detach_kernel_drivers(libusb_device_handle* usb_device_handle) { int i, num_interfaces, result; libusb_device* dev; struct libusb_config_descriptor* config; dev = libusb_get_device(usb_device_handle); result = libusb_get_active_config_descriptor(dev, &config); if( result < 0 ) { return HACKRF_ERROR_LIBUSB; } num_interfaces = config->bNumInterfaces; libusb_free_config_descriptor(config); for(i=0; i<num_interfaces; i++) { result = libusb_kernel_driver_active(usb_device_handle, i); if( result < 0 ) { if( result == LIBUSB_ERROR_NOT_SUPPORTED ) { return 0; } return HACKRF_ERROR_LIBUSB; } else if( result == 1 ) { result = libusb_detach_kernel_driver(usb_device_handle, i); if( result != 0 ) { return HACKRF_ERROR_LIBUSB; } } } return HACKRF_SUCCESS; }
///////////////////////////////////////--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); }
///////////////////////////////////////--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; }
static bool usb_endpoint_iterate(libusb_device_handle* handle, const Callback& callback) { struct libusb_config_descriptor* config; int rc = libusb_get_active_config_descriptor(libusb_get_device(handle), &config); if (rc != 0) { error("failed to get active config descriptor"); return false; } Auto(libusb_free_config_descriptor(config)); for (size_t i = 0; i < config->bNumInterfaces; ++i) { const libusb_interface& interface = config->interface[i]; for (ssize_t j = 0; j < interface.num_altsetting; ++j) { const libusb_interface_descriptor& interface_descriptor = interface.altsetting[j]; for (size_t k = 0; k < interface_descriptor.bNumEndpoints; ++k) { const libusb_endpoint_descriptor& endpoint = interface_descriptor.endpoint[k]; switch (callback(interface_descriptor, endpoint)) { case usb_endpoint_iterate_result::proceed: continue; case usb_endpoint_iterate_result::terminate: return true; } } } } return true; }
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; }
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); }
/* Look for a descriptor in the active configuration * Will also find extra descriptors which are normally * not returned by the standard libusb_get_descriptor() */ int usb_get_any_descriptor(struct libusb_device_handle *dev_handle, uint8_t desc_type, uint8_t desc_index, unsigned char *resbuf, int res_len) { struct libusb_device *dev; struct libusb_config_descriptor *config; int ret; uint16_t conflen; unsigned char *cbuf; dev = libusb_get_device(dev_handle); if (!dev) { fprintf(stderr, "Error: Broken device handle\n"); return -1; } /* Get the total length of the configuration descriptors */ ret = libusb_get_active_config_descriptor(dev, &config); if (ret == LIBUSB_ERROR_NOT_FOUND) { fprintf(stderr, "Error: Device is unconfigured\n"); return -1; } else if (ret) { fprintf(stderr, "Error: failed " "libusb_get_active_config_descriptor()\n"); exit(1); } conflen = config->wTotalLength; libusb_free_config_descriptor(config); /* Suck in the configuration descriptor list from device */ cbuf = malloc(conflen); ret = libusb_get_descriptor(dev_handle, LIBUSB_DT_CONFIG, desc_index, cbuf, conflen); if (ret < conflen) { fprintf(stderr, "Warning: failed to retrieve complete " "configuration descriptor, got %i/%i\n", ret, conflen); conflen = ret; } /* Search through the configuration descriptor list */ ret = find_descriptor(cbuf, conflen, desc_type, desc_index, resbuf, res_len); free(cbuf); /* A descriptor must be at least 2 bytes long */ if (ret > 1) { if (verbose) printf("Found descriptor in complete configuration " "descriptor list\n"); return ret; } /* Finally try to retrieve it requesting the device directly * This is not supported on all devices for non-standard types */ return libusb_get_descriptor(dev_handle, desc_type, desc_index, resbuf, res_len); }
/** * 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; }
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; }
/** * \brief Get configuration by value. * * \param value configuration value to search for. */ ConfigurationPtr Device::configValue(uint8_t value) throw(USBError) { struct libusb_config_descriptor *config; int rc = libusb_get_config_descriptor_by_value(dev, value, &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); }
static int sunos_find_interface(struct libusb_device_handle *hdev, uint8_t endpoint, uint8_t *interface) { struct libusb_config_descriptor *config; int r; int iface_idx; r = libusb_get_active_config_descriptor(hdev->dev, &config); if (r < 0) { return (LIBUSB_ERROR_INVALID_PARAM); } for (iface_idx = 0; iface_idx < config->bNumInterfaces; iface_idx++) { const struct libusb_interface *iface = &config->interface[iface_idx]; int altsetting_idx; for (altsetting_idx = 0; altsetting_idx < iface->num_altsetting; altsetting_idx++) { const struct libusb_interface_descriptor *altsetting = &iface->altsetting[altsetting_idx]; int ep_idx; for (ep_idx = 0; ep_idx < altsetting->bNumEndpoints; ep_idx++) { const struct libusb_endpoint_descriptor *ep = &altsetting->endpoint[ep_idx]; if (ep->bEndpointAddress == endpoint) { *interface = iface_idx; libusb_free_config_descriptor(config); return (LIBUSB_SUCCESS); } } } } libusb_free_config_descriptor(config); return (LIBUSB_ERROR_INVALID_PARAM); }
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; }
void close() { if (m_usbdevicehandle) { libusb_free_transfer(transfer); libusb_free_config_descriptor(config); libusb_release_interface(m_usbdevicehandle, ifno); libusb_close(m_usbdevicehandle); } if (context) libusb_exit(context); }
int ez430_close(struct ez430_dev *dev) { DEBUG_PRINTF("Closing device!\n"); libusb_free_config_descriptor(dev->ez430_config); libusb_release_interface(dev->ez430_handle, UART_IFACE); libusb_close(dev->ez430_handle); libusb_exit(NULL); free(dev); return 0; }
/** * @brief Opens the camera specified by \a dev. * * @todo This is one of the places where we expose the fact that PTP uses libusb as a backend. * It would be nice if we could let the caller completely ignore the underlying protocol. * @param[in] dev The \c libusb_device which specifies which device to connect to. * @exception PTP::ERR_ALREADY_OPEN if this \c CameraBase already has an open device. * @exception PTP::ERR_CANNOT_CONNECT if we cannot connect to the camera specified. * @return true if we successfully connect, false otherwise. */ bool CameraBase::open(libusb_device * dev) { if(this->handle != NULL) { // Handle will be non-null if the device is already open throw PTP::ERR_ALREADY_OPEN; return false; } int err = libusb_open(dev, &(this->handle)); // Open the device, placing the handle in this->handle if(err) { throw PTP::ERR_CANNOT_CONNECT; return false; } libusb_unref_device(dev); // We needed this device refed before we opened it, so we added an extra ref. open adds another ref, so remove one ref struct libusb_config_descriptor * desc; int r = libusb_get_active_config_descriptor(dev, &desc); if (r < 0) { this->usb_error = r; return false; } int j, k; for(j = 0; j < desc->bNumInterfaces; j++) { struct libusb_interface interface = desc->interface[j]; for(k = 0; k < interface.num_altsetting; k++) { struct libusb_interface_descriptor altsetting = interface.altsetting[k]; if(altsetting.bInterfaceClass == 6) { // If this has the PTP interface this->intf = &altsetting; libusb_claim_interface(this->handle, this->intf->bInterfaceNumber); // Claim the interface -- Needs to be done before I/O operations break; } } if(this->intf) break; } const struct libusb_endpoint_descriptor * endpoint; for(j = 0; j < this->intf->bNumEndpoints; j++) { endpoint = &(this->intf->endpoint[j]); if((endpoint->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK == LIBUSB_ENDPOINT_IN) && (endpoint->bmAttributes & LIBUSB_TRANSFER_TYPE_MASK) == LIBUSB_TRANSFER_TYPE_BULK) { this->ep_in = endpoint->bEndpointAddress; } else if((endpoint->bEndpointAddress & LIBUSB_ENDPOINT_DIR_MASK) == LIBUSB_ENDPOINT_OUT) { this->ep_out = endpoint->bEndpointAddress; } } libusb_free_config_descriptor(desc); // If we haven't detected an error by now, assume that this worked. return true; }
/** * 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; }
int fnusb_num_interfaces(fnusb_dev *dev) { int retval = 0; int res; libusb_device* d = libusb_get_device(dev->dev); struct libusb_config_descriptor* config; res = libusb_get_active_config_descriptor(d, &config); if (res < 0) // Something went wrong return res; retval = config->bNumInterfaces; libusb_free_config_descriptor(config); return retval; }
int luausb_config_descriptor_gc(lua_State* L) { struct libusb_config_descriptor** config; config = (struct libusb_config_descriptor**)lua_touserdata(L, 1); if (*config) { libusb_free_config_descriptor(*config); *config = 0; } return 0; }