//**********************************************************
//!
//! Closes connection to the currently open device
//!
//! @return ICP_RC_OK => success (ignores errors)
//!
ICP_ErrorType bdm_usb_close( void ) {
   int rc;

   //   print("bdm_usb_close()\n");
   if (usbDeviceHandle == NULL) {
      print("bdm_usb_close() - device not open - no action\n");
      return ICP_RC_OK;
   }
   rc = libusb_release_interface(usbDeviceHandle, 0);
   if (rc != LIBUSB_SUCCESS) {
      print("bdm_usb_close() - libusb_release_interface() failed, rc = %s\n", libusb_strerror((libusb_error)rc));
   }
   int configValue;
   rc = libusb_get_configuration(usbDeviceHandle, &configValue);
   if (rc != LIBUSB_SUCCESS) {
      print("bdm_usb_close() - libusb_get_configuration() failed, rc = %s\n", libusb_strerror((libusb_error)rc));
   }
   // Unconfigure BDM
   // I know the libusb documentation says to use -1 but this ends up being passed
   // to the USB device WHICH IS NOT A GOOD THING!
#ifdef WIN32
   rc = libusb_set_configuration(usbDeviceHandle, 0);
#else
   rc = libusb_set_configuration(usbDeviceHandle, -1);
#endif
   if (rc != LIBUSB_SUCCESS) {
      print("bdm_usb_close() - libusb_set_configuration(0) failed, rc = %s\n", libusb_strerror((libusb_error)rc));
   }
   libusb_close(usbDeviceHandle);
   usbDeviceHandle = NULL;
   return ICP_RC_OK;
}
//**********************************************************
//!
//! Open connection to device enumerated by bdm_usb_find_devices()
//!
//! @param device_no Device number to open
//!
//! @return \n
//!    == ICP_RC_OK (0)     => Success\n
//!    == ICP_RC_USB_ERROR  => USB failure
//!
ICP_ErrorType bdm_usb_open( unsigned int device_no ) {

//   print("bdm_usb_open( %d )\n", device_no);

   if (!initialised) {
      print("bdm_usb_open() - Not initialised! \n");
      return ICP_RC_USB_ERROR;
   }
   if (device_no >= deviceCount) {
      print("bdm_usb_open() - Illegal device #\n");
      return ICP_RC_ILLEGAL_PARAMS;
   }
   if (usbDeviceHandle != NULL) {
      print("bdm_usb_open() - Closing previous device\n");
      bdm_usb_close();
   }
   int rc = libusb_open(bdmDevices[device_no], &usbDeviceHandle);

   if (rc != LIBUSB_SUCCESS) {
      print("bdm_usb_open() - libusb_open() failed, rc = %s\n", libusb_strerror((libusb_error)rc));
      usbDeviceHandle = NULL;
      return ICP_RC_USB_ERROR;
      }
   int configuration = 0;
   rc = libusb_get_configuration(usbDeviceHandle, &configuration);
   if (rc != LIBUSB_SUCCESS) {
      print("bdm_usb_open() - libusb_get_configuration() failed, rc = %s\n", libusb_strerror((libusb_error)rc));
   }
   if (configuration != 1) {
      rc = libusb_set_configuration(usbDeviceHandle, 1);
      if (rc != LIBUSB_SUCCESS) {
         print("bdm_usb_open() - libusb_set_configuration(1) failed, rc = %s\n", libusb_strerror((libusb_error)rc));
         // Release the device
         libusb_close(usbDeviceHandle);
         usbDeviceHandle = NULL;
         return ICP_RC_USB_ERROR;
      }
   }
   rc = libusb_claim_interface(usbDeviceHandle, 0);
   if (rc != LIBUSB_SUCCESS) {
      print("bdm_usb_open() - libusb_claim_interface(0) failed, rc = %s\n", libusb_strerror((libusb_error)rc));
      // Release the device
      libusb_set_configuration(usbDeviceHandle, 0);
      libusb_close(usbDeviceHandle);
      usbDeviceHandle = NULL;
      return ICP_RC_USB_ERROR;
   }
   rc = libusb_clear_halt(usbDeviceHandle, 0x01);
   if (rc != LIBUSB_SUCCESS) {
      print("bdm_usb_open() - libusb_clear_halt(...,0x01) failed, rc = %s\n", libusb_strerror((libusb_error)rc));
   }
   rc = libusb_clear_halt(usbDeviceHandle, 0x82);
   if (rc != LIBUSB_SUCCESS) {
      print("bdm_usb_open() - libusb_clear_halt(...,0x82) failed, rc = %s\n", libusb_strerror((libusb_error)rc));
   }
   return (ICP_RC_OK);
}
Beispiel #3
0
static int
DeviceInit(FTDIDevice *dev)
{
  int err, interface;

  for (interface = 0; interface < 2; interface++) {
    if (libusb_kernel_driver_active(dev->handle, interface) == 1) {
      if ((err = libusb_detach_kernel_driver(dev->handle, interface))) {
        perror("Error detaching kernel driver");
        return err;
      }
    }
  }

  if ((err = libusb_set_configuration(dev->handle, 1))) {
    perror("Error setting configuration");
    return err;
  }

  for (interface = 0; interface < 2; interface++) {
    if ((err = libusb_claim_interface(dev->handle, interface))) {
      perror("Error claiming interface");
      return err;
    }
  }

  return 0;
}
Beispiel #4
0
/* Find a PMD1208FS device.  Return a device handle, or NULL. */
libusb_device_handle* pmd_find_first(void) {
    int i, ret;
    libusb_device_handle* pmd;
    
    ret = libusb_init(NULL);
    if (ret) {
        err("failed to init libusb: %s\n", usb_get_errmsg(ret));
        return NULL;
    }
    
    pmd = libusb_open_device_with_vid_pid(NULL, PMD_VID, PMD_PID);
    if (!pmd) {
        err("device not found\n");
        libusb_exit(NULL);
        return NULL;
    }
    
    for(i = 0; i < 4; i++) {
        libusb_detach_kernel_driver(pmd, i);
    }
    libusb_reset_device(pmd);  /* fixes odd-number-of-operations timeout */
    libusb_set_configuration(pmd, 1);
    for(i = 0; i < 4; i++) {
        ret = libusb_claim_interface(pmd, i);
        if (ret) {
            err("failed to claim interface: %s\n", usb_get_errmsg(ret));
            libusb_close(pmd);
            libusb_exit(NULL);
            return NULL;
        }
    }
    return pmd;
}
Beispiel #5
0
bool UsbComm::open()
{
  if (dh_ != 0) {
    close();
  }
  if (libusb_init(&ctx_) < 0) {
    throw std::runtime_error("Error opening libusb");
  }
  //    todo: parse vid/pid out of name_
  dh_ = libusb_open_device_with_vid_pid(ctx_, 0xf000, 0x0001);
  if (dh_ == 0) {
    throw std::runtime_error("Could not find USB device 0xf000/0x0001 for comm board.");
  }
  libusb_device_descriptor ldd;
  int er;
  er = libusb_get_device_descriptor(libusb_get_device(dh_), &ldd);
  if (er < 0) {
    throw std::runtime_error("Could not find USB descriptor for comm board.");
  }
  er = libusb_set_configuration(dh_, 1);
  if (er < 0) {
    throw std::runtime_error("Could not set configuration on comm board.");
  }
  er = libusb_claim_interface(dh_, 0);
  if (er < 0) {
    throw std::runtime_error("Could not claim USB interface for comm board. Is another process using it?");
  }
  running_ = true;
  thread_ = new boost::thread(boost::bind(&UsbComm::read_func, this));
  return true;
}
Beispiel #6
0
/*   in libusb, we should follow this order:
 *     open => claim I/F => set config => XFER => rel I/F => close */
MOSHEXPORT
int
musb_configuration_set(void* p, int c){
    int r;
    r = libusb_set_configuration((libusb_device_handle*)p,c);
    return r;
}
void *_ykusb_open_device(int vendor_id, int product_id)
{
	libusb_device *dev;
	libusb_device_handle *h = NULL;
	struct libusb_device_descriptor desc;
	libusb_device **list;
	ssize_t cnt = libusb_get_device_list(usb_ctx, &list);
	ssize_t i = 0;
	int rc = YK_ENOKEY;

	for (i = 0; i < cnt; i++) {
		dev = list[i];
		ykl_errno = libusb_get_device_descriptor(dev, &desc);
		if (ykl_errno != 0)
			goto done;

		if (desc.idVendor == vendor_id && desc.idProduct == product_id) {
			rc = YK_EUSBERR;
			ykl_errno = libusb_open(dev, &h);
			if (ykl_errno != 0)
				goto done;
			ykl_errno = libusb_detach_kernel_driver(h, 0);
			if (ykl_errno != 0)
				goto done;
			/* This is needed for yubikey-personalization to work inside virtualbox virtualization. */
			ykl_errno = libusb_set_configuration(h, 1);
			goto done;
		}
	}
 done:
	libusb_free_device_list(list, 1);
	if (h == NULL)
		yk_errno = rc;
	return h;
}
Beispiel #8
0
static int
prepare_device(libusb_device_handle *dev_handle)
{
	if (libusb_kernel_driver_active(dev_handle, INTERFACE)) {
		DPRINTF(2, "Kernel Driver Active.\n");
		if (libusb_detach_kernel_driver(dev_handle, 0)) {
			fprintf(stderr, "Could not detach the interface.\n");
			return -1;
		}
	}

	libusb_set_configuration(dev_handle, CONFIGURATION);
	if (libusb_claim_interface(dev_handle, INTERFACE)) {
		fprintf(stderr, "Could not claim the interface.\n");
		return -1;
	}

	DPRINTF(2, "Claimed interface.\n");

	/* Set the baudrate at the correct speed to talk to the device */
	int baudrate = 250000;
	libusb_control_transfer(dev_handle, REQTYPE,
			CP210X_IFC_ENABLE, UART_ENABLE, 0, NULL, 0, 500);
	libusb_control_transfer(dev_handle, REQTYPE,
			CP210X_SET_BAUDRATE, 0, 0,
			(void *)&baudrate, sizeof(baudrate), 500);
	libusb_control_transfer(dev_handle, REQTYPE,
			CP210X_IFC_ENABLE, UART_DISABLE, 0, NULL, 0, 500);
	return 0;
}
Beispiel #9
0
static int set_hackrf_configuration(libusb_device_handle* usb_device, int config)
{
	int result, curr_config;
	result = libusb_get_configuration(usb_device, &curr_config);
	if( result != 0 )
	{
		return HACKRF_ERROR_LIBUSB;
	}

	if(curr_config != config)
	{
		result = detach_kernel_drivers(usb_device);
		if( result != 0 )
		{
			return result;
		}
		result = libusb_set_configuration(usb_device, config);
		if( result != 0 )
		{
			return HACKRF_ERROR_LIBUSB;
		}
	}

	result = detach_kernel_drivers(usb_device);
	if( result != 0 )
	{
		return result;
	}
	return LIBUSB_SUCCESS;
}
int connectDevice() {
    if ( Connection_Status != CONNECTED)  {
        libusb_init(NULL); 

        if(!(MyLibusbDeviceHandle = open_dev())) {
            fprintf(stderr, "open_dev() failed\n");
            return -1;
        }

        // Sets the Active configuration of the device
        if (libusb_set_configuration(MyLibusbDeviceHandle, 1) < 0) {

            fprintf(stderr, "usb_set_configuration() failed\n");
            libusb_close(MyLibusbDeviceHandle);
            return -2;
        }

        // claims the interface with the Operating System
        if(libusb_claim_interface(MyLibusbDeviceHandle, 0) < 0)  
        {
            fprintf(stderr, "usb_claim_interface() failed\n");
            //Closes a device opened since the claim interface is failed.
            libusb_close(MyLibusbDeviceHandle);
            return -3;
        }
        // Everything went better than expected
        Connection_Status = CONNECTED; 
    }

    return 0;
}
Beispiel #11
0
int USBLink::open()
{
    libusb_init(&m_context);

    m_handle = libusb_open_device_with_vid_pid(m_context, PIXY_VID, PIXY_DID);
    if (m_handle==NULL)
        return -1;
#ifdef __MACOS__
    libusb_reset_device(m_handle);
    Sleeper::msleep(100);
#endif
    if (libusb_set_configuration(m_handle, 1)<0)
    {
        libusb_close(m_handle);
        m_handle = 0;
        return -1;
    }
    if (libusb_claim_interface(m_handle, 1)<0)
    {
        libusb_close(m_handle);
        m_handle = 0;
        return -1;
    }
    return 0;
}
Beispiel #12
0
int TankChassis::prepare_usb_device()
{
	if (libusb_init(0) < 0) {
		fprintf(stderr, "libusb_init\n");
		return -1;
	}

	if (find_lvr_hidusb(vendor_id, product_id) < 0) {
		fprintf(stderr, "find_lvr_hidusb\n");
		return -1;
	}

	libusb_detach_kernel_driver(devh, 0);

	if (libusb_set_configuration(devh, 1) < 0) {
		fprintf(stderr, "libusb_set_configuration\n");
		return -1;
	}

	if (libusb_claim_interface(devh, 0) < 0) {
		fprintf(stderr, "libusb_claim_interface\n");
		return -1;
	}

	return 0;
}
Beispiel #13
0
static int dev_open(struct sr_dev_inst *sdi)
{
	struct sr_dev_driver *di = sdi->driver;
	struct drv_context *drvc = di->context;
	struct sr_usb_dev_inst *usb;
	int ret;

	usb = sdi->conn;

	if (sr_usb_open(drvc->sr_ctx->libusb_ctx, usb) != SR_OK)
		return SR_ERR;

	if ((ret = libusb_set_configuration(usb->devhdl, 1))) {
		sr_err("Failed to set configuration: %s.", libusb_error_name(ret));
		return SR_ERR;
	}

	if ((ret = libusb_claim_interface(usb->devhdl, USB_INTERFACE))) {
		sr_err("Failed to claim interface: %s.", libusb_error_name(ret));
		return SR_ERR;
	}
	sdi->status = SR_ST_ACTIVE;

	return ret;
}
Beispiel #14
0
/*
 * This method looks if the kernel already has a driver attached to the device. if so I will take over the device.
 */
static enum libusb_error claim_device(libusb_device_handle * dev, int interface)
{
	enum libusb_error err;
	if (libusb_kernel_driver_active(dev, interface)) {
		fprintf(stderr, "A kernel has claimed the interface, detaching it...\n");
		if ((err = libusb_detach_kernel_driver(dev, interface)) != 0) {
			fprintf(stderr, "Failed to Disconnected the OS driver: %s\n", usbutil_error_to_string(err));
			return err;
		}
	}

	if ((err = libusb_set_configuration(dev, 1))) {
		fprintf(stderr, "libusb_set_configuration: %s\n", usbutil_error_to_string(err));
		return err;
	}
	fprintf(stderr, "libusb_set_configuration: %s\n", usbutil_error_to_string(err));

	/* claim interface */
	if ((err = libusb_claim_interface(dev, interface))) {
		fprintf(stderr, "Claim interface error: %s\n", usbutil_error_to_string(err));
		return err;
	}
	fprintf(stderr, "libusb_claim_interface: %s\n", usbutil_error_to_string(err));

	if ((err = libusb_set_interface_alt_setting(dev, interface, 0))) {
		fprintf(stderr, "libusb_set_interface_alt_setting: %s\n", usbutil_error_to_string(err));
		return err;
	}
	fprintf(stderr, "libusb_set_interface_alt_setting: %s\n", usbutil_error_to_string(err));

	return LIBUSB_SUCCESS;
}
Beispiel #15
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;
}
Beispiel #16
0
int connectAccessory(void)
{
	int response;
	int tries = 5;
	
	/* Try connecting to Accessory device with proper PID/VID */
	for(;;){
		tries--;
		if((handle = libusb_open_device_with_vid_pid(NULL, ACCESSORY_VID, ACCESSORY_PID_DBG)) == NULL){
			if(tries < 0){
				return -1;
			}
		}else{
			break;
		}
		sleep(1);
	}

	/* Set configuration to 1 as per ADK protocol */
	response = libusb_set_configuration(handle, 1);
	if(response < 0){
		error(response);
		return -1;
	}
	
	response = libusb_claim_interface(handle, 0);
	if(response < 0){
		error(response);
		return -1;
	}

	fprintf(stdout, "Interface claimed, ready to transfer data\n");

	return 0;
}
Beispiel #17
0
 /**
    * @brief  Send a debug message
    * @param  s: string with message to send.
    * @retval none.
    */
 static int32_t USBHostConnect(void)
 {
   libusb_device **devs;
   struct libusb_device_descriptor desc;
   int i;
   int ret = -1;
   ssize_t devices = libusb_get_device_list(NULL, &devs);

   for(i = 0; i < devices; i++)
   {
     int r = libusb_get_device_descriptor(devs[i],&desc);
     if(r >= 0 && desc.idVendor == VID && desc.idProduct == PID)
     {
 	    ret = libusb_open(devs[i], &devhandler);
     }
   }

   ret = libusb_set_configuration(devhandler, CONFIG);

   if (ret < 0)
   {
	   libusb_close(devhandler);
   }

   if (libusb_claim_interface(devhandler, DATA_INTF) < 0)
   {
	   libusb_close(devhandler);
   }

   return ret;
 }
Beispiel #18
0
static int hw_dev_open(int dev_index)
{
	struct sr_dev_inst *sdi;
	struct context *ctx;
	int ret;

	if (!(sdi = zp_open_dev(dev_index))) {
		sr_err("zp: unable to open device");
		return SR_ERR;
	}

	/* TODO: Note: sdi is retrieved in zp_open_dev(). */

	if (!(ctx = sdi->priv)) {
		sr_err("zp: %s: sdi->priv was NULL", __func__);
		return SR_ERR_ARG;
	}

	ret = libusb_set_configuration(ctx->usb->devhdl, USB_CONFIGURATION);
	if (ret < 0) {
		sr_err("zp: Unable to set USB configuration %d: %d",
		       USB_CONFIGURATION, ret);
		return SR_ERR;
	}

	ret = libusb_claim_interface(ctx->usb->devhdl, USB_INTERFACE);
	if (ret != 0) {
		sr_err("zp: Unable to claim interface: %d", ret);
		return SR_ERR;
	}

	analyzer_reset(ctx->usb->devhdl);
	analyzer_initialize(ctx->usb->devhdl);

	analyzer_set_memory_size(MEMORY_SIZE_512K);
	// analyzer_set_freq(g_freq, g_freq_scale);
	analyzer_set_trigger_count(1);
	// analyzer_set_ramsize_trigger_address((((100 - g_pre_trigger)
	// * get_memory_size(g_memory_size)) / 100) >> 2);
	analyzer_set_ramsize_trigger_address(
		(100 * get_memory_size(MEMORY_SIZE_512K) / 100) >> 2);

#if 0
	if (g_double_mode == 1)
		analyzer_set_compression(COMPRESSION_DOUBLE);
	else if (g_compression == 1)
		analyzer_set_compression(COMPRESSION_ENABLE);
	else
#endif
	analyzer_set_compression(COMPRESSION_NONE);

	if (ctx->cur_samplerate == 0) {
		/* Samplerate hasn't been set. Default to the slowest one. */
		if (hw_dev_config_set(dev_index, SR_HWCAP_SAMPLERATE,
		     &samplerates.list[0]) == SR_ERR)
			return SR_ERR;
	}

	return SR_OK;
}
Beispiel #19
0
void mcs7715_startup(libusb_device_handle* usbdevice) {
    
    // MCS7715 only has 1 configuration
    int ret = libusb_set_configuration(usbdevice,1);
    DBG("libusb_set_configuration ret: %u\n",ret);
    ret = libusb_claim_interface(usbdevice, 0);
    DBG("libusb_claim_interface ret: %u\n",ret);
    
    /*unsigned char data;
    
    data = 0x30;
	SendMosCmd(usbdevice,MOS_READ,MOS_VEN_REG,0x04, &data);
	data = 0x80;
	SendMosCmd(usbdevice,MOS_WRITE,MOS_VEN_REG,0x04, &data);
	data = 0x00;
	SendMosCmd(usbdevice,MOS_WRITE,MOS_VEN_REG,0x04, &data);
    
    data = 0x0cc;
    SendMosCmd(usbdevice,MOS_READ,0,0x02, &data);
    data = 0x0cc;
    SendMosCmd(usbdevice,MOS_WRITE,0,0x02, &data);
    reg[1] = data; // DCR
    
    data = 0x045;
    SendMosCmd(usbdevice,MOS_READ,0,0x0A, &data);
    data = 0x045;
    SendMosCmd(usbdevice,MOS_WRITE,0,0x0A, &data);
    reg[2] = data; // ECR */
}
Beispiel #20
0
static libusb_device_handle* canusb_opendevice(struct libusb_context *ctx, char* devserial)
{
    libusb_device** devs;
    unsigned char serial[65];
    int cnt,i,n;

    cnt = libusb_get_device_list(ctx,&devs);

    for(i=0;i<cnt;i++)
    {
        /* Check if this device is interesting. */
        struct libusb_device_descriptor desc;
        libusb_device_handle *dh;

        libusb_get_device_descriptor(devs[i],&desc);

        if ((desc.idVendor != CANUSB_VID) || (desc.idProduct != CANUSB_PID))
          continue;

        /* Found one! */
        dh = NULL;

        if (libusb_open(devs[i],&dh) != 0) continue;

        n = libusb_get_string_descriptor_ascii(dh,desc.iSerialNumber,serial,64);
        serial[n] = 0;

        if ((devserial) && (strcmp((char *)serial,devserial) != 0))
        {
            libusb_close(dh);
            continue;
        }

        if ((libusb_kernel_driver_active(dh,0)) && (libusb_detach_kernel_driver(dh,0) != 0))
        {
            libusb_close(dh);
            continue;
        }

        if (libusb_set_configuration(dh,1) != 0)
        {
            libusb_close(dh);
            continue;
        }

        if (libusb_claim_interface(dh,0) != 0)
        {
            libusb_close(dh);
            continue;
        }

        /* Fount it! */
        libusb_free_device_list(devs,1);
        return dh;
    }

    libusb_free_device_list(devs,1);
    return NULL;
}
int main(int argc, char **argv)
{
	void *data;
	unsigned sz;
	struct stat s;
	int fd;
	int ret;
	struct libusb_context       *ctx = NULL;
	struct libusb_device_handle *usb = NULL;

	if (argc != 3) {
		printf("usage: %s <xloader> <rootfs>\n", argv[0]);
		return 0;
	}
	argv++;
	fd = open(argv[0], O_RDONLY);
	if (fd < 0 || fstat(fd, &s)) {
		printf("cannot open '%s'\n", argv[0]);
		return -1;
	}
	data = mmap(NULL, s.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
	if (data == MAP_FAILED) {
		printf("cannot mmap '%s'\n", argv[0]);
		return -1;
	}
	sz = s.st_size;
	close(fd);
	argv++;
	if (libusb_init(&ctx)) {
		printf("cannot initialize libusb\n");
		return -1;
	}
	printf(HFORMAT, HOST_FORMAT);
	printf("waiting for OMAP44xx device...\n");
	while (1) {
		if (!usb)
			usb = libusb_open_device_with_vid_pid(
				ctx, 0x0451, 0xD010);
		if (!usb)
			usb = libusb_open_device_with_vid_pid(
				ctx, 0x0451, 0xD00F);
		if (usb) {
			libusb_detach_kernel_driver(usb, 0);
			ret = libusb_set_configuration(usb, 1);
			if (ret)
				break;
			ret = libusb_claim_interface(usb, 0);
			if (ret)
				break;
			ret = usb_boot(usb, data, sz, argv[0]);
			break;
		}
		usleep(250000);
	}
	libusb_release_interface(usb, 0);
	libusb_close(usb);
	libusb_exit(ctx);
	return ret;
}
Beispiel #22
0
int LibusbDevice::SubmitTransfer(std::unique_ptr<CtrlMessage> cmd)
{
  if (!m_device_attached)
    return LIBUSB_ERROR_NOT_FOUND;

  DEBUG_LOG(IOS_USB,
            "[%04x:%04x %d] Control: bRequestType=%02x bRequest=%02x wValue=%04x"
            " wIndex=%04x wLength=%04x",
            m_vid, m_pid, m_active_interface, cmd->request_type, cmd->request, cmd->value,
            cmd->index, cmd->length);

  switch ((cmd->request_type << 8) | cmd->request)
  {
  // The following requests have to go through libusb and cannot be directly sent to the device.
  case USBHDR(DIR_HOST2DEVICE, TYPE_STANDARD, REC_INTERFACE, REQUEST_SET_INTERFACE):
  {
    INFO_LOG(IOS_USB, "[%04x:%04x %d] REQUEST_SET_INTERFACE index=%04x value=%04x", m_vid, m_pid,
             m_active_interface, cmd->index, cmd->value);
    if (static_cast<u8>(cmd->index) != m_active_interface)
    {
      const int ret = ChangeInterface(static_cast<u8>(cmd->index));
      if (ret < 0)
      {
        ERROR_LOG(IOS_USB, "[%04x:%04x %d] Failed to change interface to %d: %s", m_vid, m_pid,
                  m_active_interface, cmd->index, libusb_error_name(ret));
        return ret;
      }
    }
    const int ret = SetAltSetting(static_cast<u8>(cmd->value));
    if (ret == 0)
      m_ios.EnqueueIPCReply(cmd->ios_request, cmd->length);
    return ret;
  }
  case USBHDR(DIR_HOST2DEVICE, TYPE_STANDARD, REC_DEVICE, REQUEST_SET_CONFIGURATION):
  {
    INFO_LOG(IOS_USB, "[%04x:%04x %d] REQUEST_SET_CONFIGURATION index=%04x value=%04x", m_vid,
             m_pid, m_active_interface, cmd->index, cmd->value);
    ReleaseAllInterfacesForCurrentConfig();
    const int ret = libusb_set_configuration(m_handle, cmd->value);
    if (ret == 0)
    {
      ClaimAllInterfaces(cmd->value);
      m_ios.EnqueueIPCReply(cmd->ios_request, cmd->length);
    }
    return ret;
  }
  }

  const size_t size = cmd->length + LIBUSB_CONTROL_SETUP_SIZE;
  auto buffer = std::make_unique<u8[]>(size);
  libusb_fill_control_setup(buffer.get(), cmd->request_type, cmd->request, cmd->value, cmd->index,
                            cmd->length);
  Memory::CopyFromEmu(buffer.get() + LIBUSB_CONTROL_SETUP_SIZE, cmd->data_address, cmd->length);
  libusb_transfer* transfer = libusb_alloc_transfer(0);
  transfer->flags |= LIBUSB_TRANSFER_FREE_TRANSFER;
  libusb_fill_control_transfer(transfer, m_handle, buffer.release(), CtrlTransferCallback, this, 0);
  m_transfer_endpoints[0].AddTransfer(std::move(cmd), transfer);
  return libusb_submit_transfer(transfer);
}
void USBThread::ConnectToUSBDevice()
{
    printf("Connect to the USB device -> THREAD: %d\n",QThread::currentThreadId());
    //initilize usb
    libusb_init(&sensor_cxt);
    libusb_set_debug(sensor_cxt, 1);

    bool usbSetUp = false;
    while (!usbSetUp) {
        usbSetUp = true;
        printf("going to try and get handle for USB\n");
        handle = libusb_open_device_with_vid_pid(sensor_cxt,MY_VID,MY_PID);
        if (handle == 0) {
            printf("failed to get handle\n");
            usbSetUp = false;
            ((GenericExecThread*)(this->thread()))->forceSleep(1);
            continue;
        }
        printf("got handle!\n");
        //printf("Reseting device\n");
        //libusb_reset_device(handle);
        //printf("Device Reset\n");

        int usbConfig;
        libusb_get_configuration(handle, &usbConfig);
        if (usbConfig == 0)
        {
            printf("Setting Configuration\n");
            if (!libusb_set_configuration(handle, 1)) {
                printf("Failed to set configuration\n");
                libusb_close(handle);
                FailedToConnect();
                usbSetUp = false;
                ((GenericExecThread*)(this->thread()))->forceSleep(10);
                continue;
            }
            printf("Set Configuration\n");
        }
        printf("Claiming Interface\n");
        int claimResults = libusb_claim_interface(handle, 0);
        if (claimResults != 0) {
            printf("Failed to claim Interface\n");
            libusb_close(handle);
            usbSetUp = false;
            FailedToConnect();
            if (LIBUSB_ERROR_NOT_FOUND == claimResults)
                printf("Requested Interface does not exist.\n");
            else if (LIBUSB_ERROR_BUSY == claimResults)
                printf("Another program or driver has claimed the interface.\n");
            else if (LIBUSB_ERROR_NO_DEVICE == claimResults)
                printf("The device has been disconnected .\n");
            ((GenericExecThread*)(this->thread()))->forceSleep(10);
            continue;
        }
        printf("Claimed Interface\n");
    }
    // done connecting and configuring, should be able to
    //    send bulk packets now
}
Beispiel #24
0
int main(void)
{
    int i, ret, transferred;
	struct libusb_device_handle *dev = NULL;
	unsigned char readback[BUF_LEN];

	ret = libusb_init(NULL);
	if (ret < 0) {
		fprintf(stderr, "libusb_init failed (got 1.0?)\n");
		return 1;
	}
	libusb_set_debug(NULL, 3);

	printf("Daisho USB controller verification\n\n");

	dev = open_daisho_device();
	if (dev == NULL) {
		printf("Failed to find Daisho device\n");
		return -1;
	}
	printf("got device\n");
	ret = libusb_set_configuration(dev, 1);
    if (ret < 0) {
		printf("* Can't set config: %s\n", libusb_error_name(ret));
        libusb_close(dev);
        return -1;
    } else {
        printf("* Set configuration \n");
    }

	ret = libusb_claim_interface(dev, 0);
    if (ret < 0) {
        printf("* Can't claim interface: %s\n", libusb_error_name(ret));
        libusb_close(dev);
        return -1;
    } else {
        printf("* Claimed interface\n");
    }

	while(1) {
		ret = libusb_bulk_transfer(dev, 0x81, readback, BUF_LEN, &transferred, 0);
		if (ret < 0){
			printf("* Couldn't read: %s\n", libusb_error_name(ret));
			break;
		/* Ignore case where we have an incomplete state */
		} else if (transferred > 0) {
			for(i=0;i<transferred;i++)
				printf("%02x ", readback[i]);
			printf("\n");
		}
		fflush(NULL);
	}

    libusb_release_interface(dev, 0);
	if(dev) libusb_close(dev);

    printf("\n* Finished\n");
    return 0;
}
/**
 * \brief Select a configuration by number
 *
 * \param configuration	number of the configuration to select.
 */
void	Device::setConfiguration(uint8_t configuration) throw (USBError) {
	int	rc = libusb_set_configuration(dev_handle, configuration);
	if (rc != LIBUSB_SUCCESS) {
		debug(LOG_ERR, DEBUG_LOG, 0, "cannot set configuration %d: %s",
			configuration, libusb_error_name(rc));
		throw USBError(libusb_error_name(rc));
	}
}
Beispiel #26
0
int fx2::set_configuration(int configuration) {
    assert(dev_handle);
    libusb_release_interface(dev_handle,interface);
    int rv=libusb_set_configuration(dev_handle,configuration);
    if (!rv) {
        libusb_claim_interface(dev_handle,interface);
    }
}
Beispiel #27
0
//==============================================================================
void USB_Device::set_configuration(uint_t configuration)
{
	log_info("usb, set configuration %u", configuration);

	int result = libusb_set_configuration(handle_, configuration);
	if (result < 0)
		on_error("set_configuration", result);
}
Beispiel #28
0
// caller can use UsbSend() afterwards, and should
// finally do libusb_release_interface(handle, 0); libusb_close(handle);
libusb_device_handle *UsbInit(struct cutter_id *id)
{
	// Now do stuff with the handle.
	int r = 0;

	libusb_device_handle* handle = UsbOpen(id);
	if (!handle) return NULL;

	if (libusb_kernel_driver_active(handle, 0) == 1)
	{
		r = libusb_detach_kernel_driver(handle, 0);
		if (r != 0)
		{
			libusb_close(handle);
			id->msg = Error("Error detaching kernel USB driver: " + UsbError(r));
			return NULL;
		}
	}

	r = libusb_reset_device(handle);
	if (r != 0)
	{
		libusb_close(handle);
		id->msg = Error("Error resetting device: " + UsbError(r));
		return NULL;
	}

	cout << "Selecting configuration." << endl;
	r = libusb_set_configuration(handle, 1);
	if (r < 0)
	{
		libusb_close(handle);
		id->msg = Error("Error setting USB configuration: " + UsbError(r));
		return NULL;
	}


	cout << "Claiming main control interface." << endl;
	r = libusb_claim_interface(handle, 0);
	if (r < 0)
	{
		libusb_close(handle);
		id->msg = Error("Error claiming USB interface: " + UsbError(r));
		return NULL;
	}

	cout << "Setting alt interface." << endl;
	r = libusb_set_interface_alt_setting(handle, 0, 0); // Probably not really necessary.
	if (r < 0)
	{
		libusb_close(handle);
		id->msg = Error("Error setting alternate USB interface: " + UsbError(r));
		return NULL;
	}

	cout << "Initialisation successful." << endl;
	return handle;
}
USBTransport *USBTransport::create(libusb_context *ctx, libusb_device *device, QString *error) {
    Q_UNUSED(ctx);

    libusb_device_handle *handle;

    int ret = libusb_open(device, &handle);

    if(ret != 0) {
        *error = USBTransportPlugin::translate_libusb(ret);

        return NULL;
    }

    ret = libusb_set_configuration(handle, 1);

    if(ret != 0) {
        *error = USBTransportPlugin::translate_libusb(ret);

        return NULL;
    }


    ret = libusb_claim_interface(handle, 0);

    if(ret != 0) {
        *error = USBTransportPlugin::translate_libusb(ret);

        libusb_close(handle);

        return NULL;
    }

    ret = libusb_set_interface_alt_setting(handle, 0, 0);

    if(ret != 0) {
        libusb_release_interface(handle, 0);

        *error = USBTransportPlugin::translate_libusb(ret);

        libusb_close(handle);

        return NULL;
    }

    ret =  libusb_reset_device(handle);

    if(ret != 0) {
        libusb_release_interface(handle, 0);

        *error = USBTransportPlugin::translate_libusb(ret);

        libusb_close(handle);

        return NULL;
    }

    return new USBTransport(handle);
}
Beispiel #30
0
void FX3Stream::init(unsigned short vid, unsigned short pid) {
    this->vid = vid;
    this->pid = pid;
    error = libusb_init(0);
    if( error < 0 ) {
        cerr << "Error initialising libusb: " << libusb_error_name(error) << endl;
        return;
    }
    if( FX3_DEBUG ) {
        libusb_set_debug(0,LIBUSB_LOG_LEVEL_WARNING);
    }
    devhandle = libusb_open_device_with_vid_pid(0, vid, pid);
    if( !devhandle ) {
        cerr << "Error opening the device" << endl;
        error = 1;
        return;
    }
    error = libusb_reset_device( devhandle );
    if( error < 0 ) {
        cerr << "Error resetting the device: " << libusb_error_name(error) << endl;
        return;
    }
    error = libusb_kernel_driver_active( devhandle, 1 );
    if( error < 0 ) {
        cerr << "Error checking for kernel driver: " << libusb_error_name(error) << endl;
        return;
    }
    else if( error == 1 ) {
        cerr << "Error: Kernel driver active." << endl;
        return;
    }
    error = libusb_set_configuration( devhandle, 1 );
    if( error < 0 ) {
        cerr << "Error setting the configuration: " << libusb_error_name(error) << endl;
        return;
    }
    error =  libusb_claim_interface( devhandle, 0 );
    if( error < 0 ) {
        cerr << "Error claiming the interface: " << libusb_error_name(error) << endl;
        return;
    }
    interfaceClaimed = true;
    inPktSize = libusb_get_max_packet_size( libusb_get_device(devhandle), FX3_IN_EP );
    if( inPktSize < 0 ) {
        cerr << "Error getting IN EP packet size: " << libusb_error_name(error) << endl;
        return;
    }
    outPktSize = libusb_get_max_packet_size( libusb_get_device(devhandle), FX3_OUT_EP );
    if( outPktSize < 0 ) {
        cerr << "Error getting OUT EP packet size: " << libusb_error_name(error) << endl;
        return;
    }
    if( FX3_DEBUG ) {
        cerr << "inPktSize: " << inPktSize << ", outPktSize: " << outPktSize << endl;
    }
    allocTransfers();
}