Example #1
0
int main(int argc, char **argv)
{
	unsigned int count = 0U, removed = 0U;
	struct usb_bus *bus;
	struct usb_device *dev;
	static usb_dev_handle *handle;
	char name[256];

	usb_init();
	usb_find_busses();
	usb_find_devices();

	for (bus = usb_get_busses(); bus != NULL; bus = bus->next) {
		for (dev = bus->devices; dev != NULL; dev = dev->next) {
			if (dev->descriptor.idVendor == C108_VENDOR_ID &&
			   (dev->descriptor.idProduct == C108_PRODUCT_ID   ||
			    dev->descriptor.idProduct == C108AH_PRODUCT_ID ||
			    dev->descriptor.idProduct == C119_PRODUCT_ID)) {
				count++;
				if ((handle = usb_open(dev)) == NULL) {
					fprintf(stderr, "rmuridrv: cannot open the USB device: %s\n", usb_strerror());
					continue;
				}

				memset(name, 0, 256);
				if (usb_get_driver_np(handle, CM108_INTERFACE, name, 256) == 0) {
					if (strcmp(name, "usbhid") == 0) {
						if (usb_detach_kernel_driver_np(handle, CM108_INTERFACE) == 0)
							removed++;
						else
							fprintf(stderr, "rmuridrv: could not disconnect from usbhid: %s\n", usb_strerror());
					}
				}

				usb_close(handle);
			}
		}
	}

	fprintf(stdout, "rmuridrv: found %u CM108 devices and removed %u from the usbhid driver\n", count, removed);

	return 0;
}
Example #2
0
struct usb_dev_handle * open_port()
{
    struct usb_bus *busses, *bus;

    usb_init();
    usb_find_busses();
    usb_find_devices();

    busses = usb_get_busses();
    for (bus = busses; bus; bus = bus->next)
    {
        struct usb_device *dev;
        for (dev = bus->devices; dev; dev = dev->next)
        {
            //printf("idVendor:0x%x\t,ipProduct:0x%x\n", dev->descriptor.idVendor, dev->descriptor.idProduct);

            if (VENDOR_ID == dev->descriptor.idVendor
                    && PRODUCT_ID == dev->descriptor.idProduct)
            {
                printf("Target usb device found!\n");
                struct usb_dev_handle *hdev = usb_open(dev);
                if (!hdev)
                {
                    perror("Cannot open device");
                }
                else
                {
                    if (0 != usb_claim_interface(hdev, 0))
                    {
                        perror("Cannot claim interface");
                        usb_close(hdev);
                        hdev = NULL;
                    }
                }
                return hdev;
            }
        }
    }

    printf("Target usb device not found!\n");

    return NULL;
}
Example #3
0
int main (int argc, const char **argv) {

	int r = 0;
	struct usb_device *dev;
	struct usb_dev_handle *handle;

	printf("CC1800 usbtool v1.0.0 by Ignacio Garcia Perez <*****@*****.**>\n");

	if (argc < 2) {
		fputs(help, stderr);
		return 1;
	}

	dev = cc1800_find();
	if (dev == NULL) {
		fprintf(stderr, "ERROR: cannot find CC1800 device\n");
		return 1;
	}

	printf("Found device %s at bus %s\n", dev->filename, dev->bus->dirname);

	handle = usb_open(dev);
	if (handle == NULL) {
		fprintf(stderr, "ERROR: cannot open device (%s)\n", strerror(errno));
		return 1;
	}

	r = usb_set_configuration(handle, 1);
	if (r < 0)
		fprintf(stderr, "ERROR: cannot set configuration\n");

	else {
		r = usb_claim_interface(handle, 0);
		if (r < 0)
			fprintf(stderr, "ERROR: cannot claim interface\n");

		else r = cc1800_fiddle(handle, argc, argv);
	}

	usb_close(handle);
	return r;
}
Example #4
0
struct usb_device * find_dev(void)
{
	struct usb_bus *bus;
	struct usb_device *dev;
	struct usb_dev_handle *handle;
	char man[40];
	char prod[40];

	usb_find_busses();
	usb_find_devices();

	for(bus = usb_get_busses(); bus; bus = bus->next) {
		for(dev = bus->devices; dev; dev = dev->next) {
			/* Check for ST Microelectronics vendor ID */
			if ((dev->descriptor.idVendor != 0x483) &&
			    (dev->descriptor.idVendor != 0x1d50))
				continue;

			handle = usb_open(dev);
			usb_get_string_simple(handle, dev->descriptor.iManufacturer, man,
						sizeof(man));
			usb_get_string_simple(handle, dev->descriptor.iProduct, prod,
						sizeof(prod));
#if 0
			printf("%s:%s [%04X:%04X] %s : %s\n", bus->dirname, dev->filename,
				dev->descriptor.idVendor, dev->descriptor.idProduct, man, prod);
#endif
			usb_close(handle);

			if (((dev->descriptor.idProduct == 0x5740) ||
			     (dev->descriptor.idProduct == 0x6018)) &&
			   !strcmp(man, "Black Sphere Technologies"))
				return dev;

			if (((dev->descriptor.idProduct == 0xDF11) ||
			     (dev->descriptor.idProduct == 0x6017)) &&
			   !strcmp(man, "Black Sphere Technologies"))
				return dev;
		}
	}
	return NULL;
}
Example #5
0
static int open_device(struct bslhid_transport *tr, struct usb_device *dev)
{
	if (find_interface(tr, dev) < 0)
		return -1;

	printc_dbg("Opening interface %d (config %d)...\n",
		   tr->int_number, tr->cfg_number);

	if (find_endpoints(tr, dev) < 0)
		return -1;

	printc_dbg("Found endpoints: IN: 0x%02x, OUT: 0x%02x\n",
		   tr->in_ep, tr->out_ep);

	tr->handle = usb_open(dev);
	if (!tr->handle) {
		pr_error("bslhid: can't open device");
		return -1;
	}

#ifdef __Windows__
	if (usb_set_configuration(tr->handle, tr->cfg_number) < 0)
		pr_error("warning: bslhid: can't set configuration");
#endif

#ifdef __linux__
	if (usb_detach_kernel_driver_np(tr->handle, tr->int_number) < 0)
		pr_error("warning: bslhid: can't detach kernel driver");
#endif

	if (usb_claim_interface(tr->handle, tr->int_number) < 0) {
		pr_error("bslhid: can't claim interface");
		usb_close(tr->handle);
		return -1;
	}

	/* Save the bus path for a future suspend/resume */
	strncpy(tr->bus_name, dev->bus->dirname, sizeof(tr->bus_name));
	tr->bus_name[sizeof(tr->bus_name) - 1] = 0;

	return 0;
}
Example #6
0
/*
 * Function usbfbus_link_disconnect_request (self)
 *
 *    Shutdown the USB link
 *
 */
static int usbfbus_disconnect_request(struct gn_statemachine *state)
{
	int ret;

	if (state->device.fd < 0)
		return 0;
	ret = usb_set_altinterface(DEVINSTANCE(state)->interface->dev_data, DEVINSTANCE(state)->interface->data_idle_setting);
	if (ret < 0)
		dprintf("Can't set data idle setting %d\n", ret);
	ret = usb_release_interface(DEVINSTANCE(state)->interface->dev_data, DEVINSTANCE(state)->interface->data_interface);
	if (ret < 0) 
		dprintf("Can't release data interface %d\n", ret);
	ret = usb_release_interface(DEVINSTANCE(state)->interface->dev_data, DEVINSTANCE(state)->interface->control_interface);
	if (ret < 0) 
		dprintf("Can't release control interface %d\n", ret);
	ret = usb_close(DEVINSTANCE(state)->interface->dev_data);
	if (ret < 0)
		dprintf("Can't close data interface %d\n", ret);
	return ret;	
}
Example #7
0
static int load_from_usb(unsigned *_len, struct usb *usb)
{
	unsigned len, n;
	enable_irqs();

	usb_queue_read(usb, &len, 4);
	usb_write(usb, &MSG, 4);
	n = usb_wait_read(usb);
	if (n)
		return -1;

	if (usb_read(usb, (void*) CONFIG_ADDR_DOWNLOAD, len))
		return -1;

	usb_close(usb);

	disable_irqs();
	*_len = len;
	return 0;
}
Example #8
0
static void vsllink_usb_close(struct vsllink *vsllink)
{
	int ret;

	ret = usb_release_interface(vsllink->usb_handle,
			versaloon_interface.usb_setting.interface);
	if (ret != 0) {
		LOG_ERROR("fail to release interface %d, %d returned",
			versaloon_interface.usb_setting.interface, ret);
		exit(-1);
	}

	ret = usb_close(vsllink->usb_handle);
	if (ret != 0) {
		LOG_ERROR("fail to close usb, %d returned", ret);
		exit(-1);
	}

	free(vsllink);
}
Example #9
0
static void usbdev_close(union filedescriptor *fd)
{
  usb_dev_handle *udev = (usb_dev_handle *)fd->usb.handle;

  if (udev == NULL)
    return;

  (void)usb_release_interface(udev, usb_interface);

#if defined(__linux__)
  /*
   * Without this reset, the AVRISP mkII seems to stall the second
   * time we try to connect to it.  This is not necessary on
   * FreeBSD.
   */
  usb_reset(udev);
#endif

  usb_close(udev);
}
Example #10
0
int main (int argc,char **argv)
{
	struct usb_dev_handle *usbprog_handle;
	struct usb_device *usbprog_device;
	int send_status;
	int open_status;
	unsigned char send_data[10000];
	unsigned char receive_data[64];

	usb_init();
	usb_set_debug(2);

 	if ((usbprog_handle = locate_usbprog())==0) 
	{
		printf("Could not open the USBprog device\n");
		return (-1);
	}  

	open_status = usb_set_configuration(usbprog_handle,1);
	printf("conf_stat=%d\n",open_status);
	
	open_status = usb_claim_interface(usbprog_handle,0);
	printf("claim_stat=%d\n",open_status);
	
	open_status = usb_set_altinterface(usbprog_handle,0);
	printf("alt_stat=%d\n",open_status);


	int k;
	for(k=0;k<10000;k++)
		send_data[k]=(unsigned char)k;


	send_data[0] = 0x77;
	send_data[1] = 0x88;

	usb_bulk_write(usbprog_handle,2,send_data,320,500);
	usb_bulk_read(usbprog_handle,2,receive_data,320,500);	

	usb_close(usbprog_handle);
}	
Example #11
0
usb_dev_handle *usb_check_device(struct usb_device *dev,
				 char *vendor_name, 
				 char *product_name, 
				 char *serial)
{
	usb_dev_handle      *handle = usb_open(dev);
	if(!handle) {
		fprintf(stderr, "Warning: cannot open USB device: %s\n", usb_strerror());
		return NULL;
	}
	if (
		usb_match_string(handle, dev->descriptor.iManufacturer, vendor_name) &&
		usb_match_string(handle, dev->descriptor.iProduct,      product_name) &&
		usb_match_string(handle, dev->descriptor.iSerialNumber, serial)
		) {
		return handle;
	}
	usb_close(handle);
	return NULL;
	
}
Example #12
0
 /*
  **
  **rfidtag close - power down reader and close usb communication
  **    
  **LOCKED IN
  */
int
rfidtag_close (void)
{
  int i = 0;
  for (i = 0; i < numtagreaders; i++)
    {
      if (rfidtag_xchange
	  (rfid_dev[i], power_down, sizeof (power_down), recvbuf,
	   sizeof (recvbuf)) < 0)
	{
	  perror ("xchange");
	}
      //printf("closing[%d]\n\n", i+1);
      if (usb_close (rfid_dev[i]) < 0)
	{
	  perror ("usb_close");
	  return (-1);
	}
    }
  return (0);
}
Example #13
0
static int usb_get_device_desc(struct usb_device *dev)
{
   struct usb_dev_handle *hnd = usb_open(dev);
   if (!hnd)
      return 1;

   ULONG actlen = 0;
   if (!WinUsb_GetDescriptor(hnd->fd, USB_DEVICE_DESCRIPTOR_TYPE, 0, 0, 
                             (unsigned char*)&dev->descriptor, 
                             sizeof(dev->descriptor), &actlen)
       || actlen != sizeof(dev->descriptor))
   {
      return 1;
   }

   // Descriptor as read from the device is in little-endian format. No need
   // to convert since this is guaranteed to be Windows which runs only on
   // little-endian processors.

   return usb_close(hnd);
}
Example #14
0
int ftdibb_reset(usb_dev_handle *dev_handle,unsigned char what)
{
	unsigned short value;

	// lower 8 byte is bitmask, 
	//Set Bit Bang Mode
	//40 -> bmRequestType
	//0 -> bmRequest
	//what -> lValue, what=0->reset sio,1 purge Rx, 2 purge Tx
	//0 -> hValue
	// index: 0 = default(sioA, 1 sioA, 2 sioB, 3 parallel
	// rest is zero
	//This resets the communication port
	value=what & 0x3;
	if (usb_control_msg(dev_handle, 0x40, 0, value, 0, NULL, 0, 4000) != 0){
		usb_close (dev_handle);
		fprintf(stderr,"ftdibb error: can not execute a reset. Not a ftdi BM chip??\n");
		return(-1); // bitbang init fail
	}
	return(0);
}
Example #15
0
void close_usb_dev(struct usb_dev_handle *devh)
{
#if defined(__linux)
#if LINUX_VERSION_CODE >= KERNEL_VERSION(2,6,0) && LINUX_VERSION_CODE <= KERNEL_VERSION(2,6,10)
#define DO_USB_RESET
#endif
#endif

#ifdef DO_USB_RESET
	/* On Linux 2.6 before 2.6.11, using usb_reset() here significantly speeds
	 * up reconnection.
	 */
	usb_reset(devh);
#else
	if (usb_release_interface(devh, 0)) {
		fprintf(stderr, "usb_release_interface returned an error!\n");
	}

	usb_close(devh);
#endif
}
Example #16
0
// Disconnects from the device via USB
// Inputs
// - dh    : USB device handle
// Returns
// - 1  : operation succeeded
// - 0 : operation failed
int disconnect_device(usb_dev_handle * dh)
{
	int success = 1;

	// Release interface 0x00
	if (usb_release_interface(dh, 0x00))
	{
		success = 0;
		fprintf(stderr, "disconnect: Release interface failed 0x00\n");
	}

	// Close the device
	if (usb_close(dh))
	{
		success = 0;
		fprintf(stderr, "disconnect: Close device failed");
	}

	// Return disconnect status
	return success;
}
Example #17
0
int close(int fd) {
	static int (*func) (int) = NULL;

	if (!func)
		func = (int (*) (int)) dlsym(RTLD_NEXT, "close");
	
	if (fd == windrvrfd && windrvrfd >= 0) {
		DPRINTF("close windrvrfd\n");
		if (usbinterface >= 0)
			usb_release_interface(usb_devhandle, usbinterface);

		if (usb_devhandle)
			usb_close(usb_devhandle);

		usb_devhandle = NULL;
		usbinterface = -1;
		windrvrfd = -1;
	}

	return (*func) (fd);
}
Example #18
0
int main(void)
{
	struct usb_dev_handle *myhandle;

	myhandle = find_rl78();

	if (myhandle != NULL) {
		fd_set s_rd;
		struct timeval delay;
		char ch, ch2;
		
		configure_rl78(myhandle);
		configure_screen();

		while (ch != EOF && ch != CONTROL('d')) {
			delay.tv_sec = 0;
			delay.tv_usec = 0;
			FD_ZERO(&s_rd);
 			FD_SET(fileno(stdin), &s_rd);

    			select(fileno(stdin)+1, &s_rd, NULL, NULL, &delay);
			if (FD_ISSET (fileno(stdin), &s_rd)) {
				ch=getch();
				if (ch != EOF && ch != CONTROL('d')) 
					rl78_write(myhandle, &ch, 1, 100);
			}

			int ret = rl78_read(myhandle, &ch2, 1, 50);
			if (ret >= 0) {
				putchar (ch2);
			} 
			
		}

		usb_close(myhandle);
    		endwin();
	}

	return 0;
}
Example #19
0
int main(int argc, char **argv)
{
    usb_dev_handle      *handle = NULL;
    unsigned char       buffer[8];
    int                 nBytes;
    usb_init();
    if(usbOpenDevice(&handle, USBDEV_SHARED_VENDOR, 0, USBDEV_SHARED_PRODUCT, 0) != 0){
        fprintf(stderr, "Could not find USB device \"PowerSwitch\" with vid=0x%x pid=0x%x\n", USBDEV_SHARED_VENDOR, USBDEV_SHARED_PRODUCT);
        exit(1);
    }
    /* We have searched all devices on all busses for our USB device above. Now
 * try to open it and perform the vendor specific control operations for the
 * function requested by the user.
 */
DWORD time = GetTickCount();
int count = 1000;
    for(int i=0;i<count;i++)
    {
        nBytes = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, 0, 0, 0, (char *)buffer, sizeof(buffer), 5000);
        if(nBytes < 2){
            if(nBytes < 0)
                fprintf(stderr, "USB error: %s\n", usb_strerror());
            fprintf(stderr, "only %d bytes received in iteration %d\n", nBytes, i);
            continue;
        }

        std::cout << (char *)buffer << std::endl;
    }
    time = GetTickCount()-time;
    std::cout << (float)count*8 / time * 1000.f << std::endl;
    std::ofstream file("123.txt");
    file << time;

    printf("test succeeded\n");

    usb_close(handle);
    system("pause");
    return 0;
}
static int _command_start(usb_handle *usb, const char *cmd, unsigned size,
                          char *response)
{
    int cmdsize = strlen(cmd);

    if(response) {
        response[0] = 0;
    }

    if(cmdsize > 64) {
        sprintf(ERROR,"command too large");
        return -1;
    }

    if(usb_write(usb, cmd, cmdsize) != cmdsize) {
        sprintf(ERROR,"command write failed (%s)", strerror(errno));
        usb_close(usb);
        return -1;
    }

    return check_response(usb, size, response);
}
Example #21
0
static void aspspi_close(PROGRAMMER * pgm)
{
  if (verbose > 2)
    fprintf(stderr, "%s: aspspi_close()\n", progname);

  if (PDATA(pgm)->usbhandle!=NULL) {
    unsigned char temp[4] = {0, 0, 0, 0};

        aspspi_transmit(pgm, 1, USBASP_FUNC_DISCONNECT, temp, temp, sizeof(temp));

#ifdef USE_LIBUSB_1_0
    libusb_close(PDATA(pgm)->usbhandle);
#else
    usb_close(PDATA(pgm)->usbhandle);
#endif
  }
#ifdef USE_LIBUSB_1_0
  libusb_exit(ctx);
#else
  /* nothing for usb 0.1 ? */
#endif
}
Example #22
0
	/// \brief Disconnect the device.
	void Device::disconnect() {
		if(!this->handle)
			return;
		
		// Release claimed interface
#if LIBUSB_VERSION == 0
		usb_release_interface(this->handle, this->interface);
#else
		libusb_release_interface(this->handle, this->interface);
#endif
		this->interface = -1;
		
		// Close device handle
#if LIBUSB_VERSION == 0
		usb_close(this->handle);
#else
		libusb_close(this->handle);
#endif
		this->handle = 0;
		
		emit disconnected();
	}
Example #23
0
void process_device(int argc, char **argv, struct usb_device *dev,
		    struct usb_config_descriptor *cfg, int itfnum) {
  int mac[6];

  usb_dev_handle *devh = usb_open(dev);
  if ( ! devh ) fatal("usb_open");

  usb_detach_kernel_driver_np(devh, itfnum);

  int res = usb_claim_interface(devh, itfnum);
  if ( res < 0 ) fatal("usb_claim_interface");

  show_master(devh, itfnum);

  if ( argc >= 2 ) {
    if ( sscanf(argv[1], "%x:%x:%x:%x:%x:%x",
		&mac[0],&mac[1],&mac[2],&mac[3],&mac[4],&mac[5]) != 6 ) {

      printf("usage: %s [<bd_addr of master>]\n", argv[0]);
      exit(1);
    }
  } else {
    FILE *f = popen("hcitool dev", "r");
    if ( !f ||
	 fscanf(f, "%*s\n%*s %x:%x:%x:%x:%x:%x",
		&mac[0],&mac[1],&mac[2],&mac[3],&mac[4],&mac[5]) != 6 ) {
      printf("Unable to retrieve local bd_addr from `hcitool dev`.\n");
      printf("Please enable Bluetooth or specify an address manually.\n");
      exit(1);
    }
    pclose(f);
  }
    
  set_master(devh, itfnum, mac);

  usb_reset(devh);
  usb_release_interface(devh, itfnum);
  usb_close(devh);
}
Example #24
0
int main(int argc, char **argv)
{
    int status;
    int pollcount;

    if (argc < 1) {
        fprintf(stderr, "not enough arguments\n");
        usage(argc, argv);
    }

    handle = usb_open(&usb_match_func);
    if (!handle) {
        fprintf(stderr, "couldn't open device\n");
        return 1;
    }

    printf("got handle %p\n", handle);

#if 0
    static char buf[4096];
    int ret = usb_read_sync(handle, 0x1, buf, sizeof(buf), 1000);
    printf("usb_read_sync returns %d\n", ret);
#endif
#if 1
    static char buf[4095];

    for (int i = 0; i < sizeof(buf); i++)
        buf[i] = i;

    int ret = usb_write_sync(handle, 0x1, buf, sizeof(buf), 5000);
    printf("usb_write_sync returns %d\n", ret);
    ret = usb_write_sync(handle, 0x1, buf, sizeof(buf), 5000);
    printf("usb_write_sync returns %d\n", ret);
#endif
    usb_close(handle);

    return 0;
}
Example #25
0
int claim_interface(int num){
  int claimed = -1;
  //do stuff

  claimed = usb_claim_interface(launcher, num);
  printf("Interface %d claimed with %d\n", num, claimed);

  //usb_detach_kernel_driver_np(launcher, 1);
  //usb_detach_kernel_driver_np(launcher, 0);
  printf("%d <= 0: %s\n", claimed, claimed <= 0);

  if (claimed <= 0)
  {
    printf("Preparing to release interface %d\n", num);
    usb_release_interface(launcher, num);
    printf("Couldn't claim interface %d \n", num);
    usb_close(launcher);
    return 1;
  } else if (claimed > 0){
    printf("Claimed interface %d \n", num);
  }
  return 0;
}
Example #26
0
/* deinitialize driver -- returns 1 on success, 0 on error */
static int dfc_deinit()
{
	int err = 0;

	if (dev_handle) {
		if (usb_close(dev_handle) < 0)
			err = 1;
		dev_handle = NULL;
	}

	if (hw.fd >= 0) {
		if (close(hw.fd) < 0)
			err = 1;
		hw.fd = -1;
	}

	if (child > 1) {
		if ((kill(child, SIGTERM) == -1) || (waitpid(child, NULL, 0) == 0))
			err = 1;
	}

	return !err;
}
Example #27
0
bool IdacUsb::findIdac()
{
	if (m_handle != NULL)
	{
		usb_close(m_handle);
		m_dev = NULL;
		m_handle = NULL;
	}

	bool bFound = false;
	for (struct usb_bus* bus = usb_busses; bus && !bFound; bus = bus->next) {
		if (bus->root_dev)
			bFound = findIdac(bus->root_dev);
		else {
			struct usb_device *dev;

			for (dev = bus->devices; dev && !bFound; dev = dev->next) {
				bFound = findIdac(dev);
			}
		}
	}
	return bFound;
}
/**
 * Close the driver (do necessary clean-up).
 * \param p  Pointer to driver's private data structure.
 */
void
usb4all_HD44780_close(PrivateData *p)
{
	if (p->usbHandle != NULL) {
		if (p->have_backlight) {
			usb4all_HD44780_backlight(p, BACKLIGHT_OFF);
		}

		usb_close(p->usbHandle);
		p->usbHandle = NULL;
	}

	if (p->tx_buf.buffer != NULL) {
		free(p->tx_buf.buffer);
		p->tx_buf.buffer = NULL;
	}

	if (p->rx_buf.buffer != NULL) {
		free(p->rx_buf.buffer);
		p->rx_buf.buffer = NULL;
	}

}
Example #29
0
int jtag_libusb_open(const uint16_t vids[], const uint16_t pids[],
		const char *serial,
		struct jtag_libusb_device_handle **out)
{
	int retval = -ENODEV;
	struct jtag_libusb_device_handle *libusb_handle;
	usb_init();

	usb_find_busses();
	usb_find_devices();

	struct usb_bus *busses = usb_get_busses();
	for (struct usb_bus *bus = busses; bus; bus = bus->next) {
		for (struct usb_device *dev = bus->devices;
				dev; dev = dev->next) {
			if (!jtag_libusb_match(dev, vids, pids))
				continue;

			libusb_handle = usb_open(dev);
			if (NULL == libusb_handle) {
				retval = -errno;
				continue;
			}

			/* Device must be open to use libusb_get_string_descriptor_ascii. */
			if (serial != NULL &&
					!string_descriptor_equal(libusb_handle, dev->descriptor.iSerialNumber, serial)) {
				usb_close(libusb_handle);
				continue;
			}
			*out = libusb_handle;
			retval = 0;
			break;
		}
	}
	return retval;
}
Example #30
0
uint8_t open_usb(usb_dev_handle **handle) {
	uint16_t vid = USB_VID;
	uint16_t pid = USB_PID;
	char vendor[256];
	char product[256];
	struct usb_bus *bus;
	struct usb_device *dev;
	usb_dev_handle *target = NULL;

	usb_init();
	usb_find_busses();
	usb_find_devices();
	for (bus=usb_get_busses(); bus; bus=bus->next) {
		for (dev=bus->devices; dev; dev=dev->next) {
			if (dev->descriptor.idVendor == vid && dev->descriptor.idProduct == pid) {
				target = usb_open(dev);
				if (target) {
					usb_get_string_simple(target, dev->descriptor.iManufacturer, vendor, sizeof(vendor));
					usb_get_string_simple(target, dev->descriptor.iProduct, product, sizeof(product));
					if (strcmp(vendor, V_NAME) == 0 && strcmp(product, P_NAME) == 0) {
						/* we found our device */
						break;
					}
				}
				usb_close(target);
				target = NULL;
			}
		}
	}
	if (target != NULL) {
		usb_claim_interface(target, 0);
		*handle = target;
		return 1;
	} else {
		return 0;
	}
}