Ejemplo n.º 1
0
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, &current_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;
}
Ejemplo n.º 2
0
///////////////////////////////////////--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;
}
Ejemplo n.º 3
0
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;
}
Ejemplo n.º 4
0
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;
}
Ejemplo n.º 5
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;
}
Ejemplo n.º 6
0
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();
}
Ejemplo n.º 7
0
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);
	}
}
Ejemplo n.º 8
0
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);
}
Ejemplo n.º 9
0
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;
}
Ejemplo n.º 10
0
///////////////////////////////////////--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);
}
Ejemplo n.º 11
0
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;
}
Ejemplo n.º 12
0
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);
}
Ejemplo n.º 13
0
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;
}
Ejemplo n.º 14
0
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);
}
Ejemplo n.º 15
0
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);
}
Ejemplo n.º 16
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;
}
Ejemplo n.º 17
0
/** \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);
}
Ejemplo n.º 18
0
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;
}
Ejemplo n.º 19
0
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));
}
Ejemplo n.º 20
0
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;
}
Ejemplo n.º 21
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);
}
Ejemplo n.º 22
0
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;
}
Ejemplo n.º 23
0
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;
}
Ejemplo n.º 24
0
/*
 * 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);
}
Ejemplo n.º 25
0
/**
 * 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;
}
Ejemplo n.º 26
0
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;

}
Ejemplo n.º 27
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;
}
Ejemplo n.º 28
0
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);
			}
		}
	}
}
Ejemplo n.º 29
0
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;
}
Ejemplo n.º 30
0
/**
 *  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;
}