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;
}
