/** Tests that the default context (used for various things including
 * logging) works correctly when the first context created in a
 * process is destroyed. */
static libusb_testlib_result test_default_context_change(libusb_testlib_ctx * tctx)
{
	libusb_context * ctx = NULL;
	int r, i;

	for (i = 0; i < 100; ++i) {
		/* First create a new context */
		r = libusb_init(&ctx);
		if (r != LIBUSB_SUCCESS) {
			libusb_testlib_logf(tctx, "Failed to init libusb: %d", r);
			return TEST_STATUS_FAILURE;
		}

		/* Enable debug output, to be sure to use the context */
		libusb_set_debug(NULL, LIBUSB_LOG_LEVEL_DEBUG);
		libusb_set_debug(ctx, LIBUSB_LOG_LEVEL_DEBUG);

		/* Now create a reference to the default context */
		r = libusb_init(NULL);
		if (r != LIBUSB_SUCCESS) {
			libusb_testlib_logf(tctx, "Failed to init libusb: %d", r);
			return TEST_STATUS_FAILURE;
		}

		/* Destroy the first context */
		libusb_exit(ctx);
		/* Destroy the default context */
		libusb_exit(NULL);
	}

	return TEST_STATUS_SUCCESS;
}
Пример #2
0
void LibUsbDevice::initializeDevice()
{
    int status;
    status = libusb_init(&context); //initialize the library for the session we just declared
    if(status != 0)
    {
        cstatus = tr("Initialization Error!");
        qDebug()<<"Initialization Error! "<<status<<endl; //there was an error
        isInitialiazed = false;
        return;
    }
    isInitialiazed = true;
    if(libusb_has_capability (LIBUSB_CAP_HAS_HOTPLUG)&&0)
    {
       hasHotPlugSupport = true;
       //status = libusb_hotplug_register_callback (context, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED, LIBUSB_HOTPLUG_ENUMERATE , VENDOR_ID,
                                              //  PRODUCT_ID, CLASS_ID, hotplugAttachCallback, this, &hotplugHandle[0]);
       if (LIBUSB_SUCCESS != status)
       {
           hasHotPlugSupport = false;
       }

       //status = libusb_hotplug_register_callback (context, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, LIBUSB_HOTPLUG_ENUMERATE , VENDOR_ID,
                                                 // PRODUCT_ID, CLASS_ID, hotplugDetachCallback, this, &hotplugHandle[1]);
       if (LIBUSB_SUCCESS != status)
       {
           hasHotPlugSupport = false;
       }
       future = QtConcurrent::run (this,&LibUsbDevice::eventThread);
    }
    libusb_set_debug(context, LIBUSB_LOG_LEVEL_INFO); //set verbosity level to 3
}
Пример #3
0
void usbhost_init_libusb(void)
{
	number_ports_used = 0;

	if (libusb_init(NULL)) {
		D(bug("USBHost: Imposible to start libusb"));
		return;
	}

	libusb_set_debug(NULL, 3);
	
	for (int i = 0; i <= MAX_NUMBER_VIRT_DEV; i++) {
		virtual_device[i].connected = false;
		virtual_device[i].virtdev_available = false;
	}

	for (int i = 0; i < NUMBER_OF_PORTS; i++) {
		roothub.port[i].device_index = 0;
	}

	SDL_CreateNamedThread(trigger_interrupt, "USB", NULL);

	usbhost_get_device_list();

	init_flag = true;	
}
int IntersonManagerTest::TestSyncBulk_FrameByFrame_CheckFrameNumbers()
{
  // Testing Receiving Data : B-Mode, Synchronous Bulk
  uInt8 motorSpeed10[] = {0xB9, 0x04, 0x00, 0x00, 0xB7, 0xA4, 0x32}; // 10.0 fps
  uInt8 motorSpeed15[] = {0x7A, 0x0D, 0x00, 0x00, 0x80, 0xA4, 0x32}; // 15.0 fps
  this->m_IntMng->initializeMotorSpeed(motorSpeed15);
  libusb_set_debug(NULL, LIBUSB_LOG_LEVEL_NONE);
  std::cout<<std::dec;

  this->m_IntMng->startAcquisitionRoutine(0);

  int r;
  for (int i = 0; i < 30; ++i) // 30 frames
  {
    int transferSize = 241 * 1024;
    unsigned char endpoint = 0x82;
    unsigned char *buffer = new unsigned char[transferSize];
    int transferred = 1;
    unsigned int BULK_TRANSFER_TIMEOUT = 1000;

    libusb_device_handle *handle = this->m_IntMng->getHandle();
    r = libusb_bulk_transfer(handle, endpoint, buffer, transferSize, &transferred, BULK_TRANSFER_TIMEOUT);

    std::cout << "Frame numbers:" << std::hex << std::endl;
    for (int k = 0; k < 241 * 1024; k += 1024)
    {
      std::cout << +buffer[k] << " ";
    }
    std::cout << std::dec << std::endl;
  }

  this->m_IntMng->stopAcquisitionRoutine();

  return 0;
}
Пример #5
0
void IdacDriverManager::initLibusb()
{
    libusb_init(NULL);
#ifndef QT_NO_DEBUG
    libusb_set_debug(NULL, 3);
#endif
}
Пример #6
0
static int
scan_usb(libusb_context *ctx, libusb_device_handle **dev_handle)
{
	libusb_device **devs;

	const int ret = libusb_init(&ctx);
	if (ret < 0) {
		fprintf(stderr, "%s\n", libusb_strerror(ret));
		return -1;
	}
	libusb_set_debug(ctx, _debug > 3 ? 3 : _debug);

	const ssize_t cnt = libusb_get_device_list(ctx, &devs);
	if (cnt == 0) {
		fprintf(stderr, "Could not get device list: %s\n",
				libusb_strerror(ret));
		return -1;
	}

	*dev_handle = libusb_open_device_with_vid_pid(ctx,
			OWL_VENDOR_ID, CM160_DEV_ID);
	libusb_free_device_list(devs, 1);
	if (!*dev_handle) {
		fprintf(stderr, "Could not find an OWL CM160 plugged.\n");
		return -1;
	}
	return 0;
}
Пример #7
0
int InitDevice(AlienFxType_t *all, AlienFxHandle_t *fxh)
{
	int succp = 0;
	if(0 == libusb_init( & fxh->usb_context))	{
		libusb_set_debug(fxh->usb_context, 3);
		int i;
		for(i = 0 ; (i < AlienFxTypesCount) && ! succp ; ++i) {
			AlienFxType_t *fxtype = &all[i];
			if(verbose)
				printf("scanning for AlienFX type \"%s\"... ", fxtype->name);
			if(fxh->usb_handle =
			   libusb_open_device_with_vid_pid(fxh->usb_context,
											   fxtype->idVendor,
											   fxtype->idProduct))
			{
				fxh->info = fxtype;
				if(verbose)
					printf("found \"%s\".\n", fxh->info->name);
				succp = 1;
			} else if(verbose)
				puts("no.");
		}
		if(fxh->usb_handle) {
			Detach(fxh->usb_handle);
			if(0 > libusb_claim_interface(fxh->usb_handle, 0)) {
				perror("libusb_claim_interface");
				fxh->usb_handle = 0;
			}
		}
	} else perror("libusb_init");
	return succp;
}
Пример #8
0
dfu_error DFU::init() 
{
	int error = libusb_init(&ctx); //initialize a library session
	if (error < 0) {

		return (dfu_error)(-99);
	}
	libusb_set_debug(ctx, 3);
	dev_handle = libusb_open_device_with_vid_pid(ctx, vid, pid);
	if (dev_handle == NULL)
	{
		return dfu_error::USB_NO_DEVICE;
	}
	if (libusb_kernel_driver_active(dev_handle, 0))
	{
		libusb_detach_kernel_driver(dev_handle, 0);
	}
	error = libusb_claim_interface(dev_handle, 0);
	if (error < 0)
	{
		return dfu_error::USB_ACCESS;
	}

	//attempt to get dfu functional descriptor, does not work on atmel devices.
	/*
	unsigned char data[9];
	error = libusb_get_descriptor(dev_handle, 0x21, 0, data, 7);
	*/

	return dfu_error::USB_OK;
	

}
Пример #9
0
int InitUSB()
{
	libusb_init(&context);
    libusb_set_debug(context, 3);
    
	return 0;
}
Пример #10
0
int main() {
  printf("msp430_serial starting...\n");
  printf("libusb initing...\n");
  // initialize USB context, and get a device handle.
  HANDLE h = init_dev(1, 0, 0xf432);
  if (h == NULL) {
    fprintf(stderr, "Handle is NULL, initialization failed.\n");
    return(1);
  }
  // enable debugging
#ifdef DEBUG
  libusb_set_debug(mspContext, 3);
#endif
  // get endpoints
  MSP_get_endpoints(h, &ep_int_in, &ep_bulk_in, &ep_bulk_out);
  // Send magic setup control transfers...
  MSP_setup(h);
  get_descriptor(h);
  // TI driver does this 26 times... not sure why
  // read status
  do_control_transfer(h,0xa1,0x21);
  // write back to device
  do_send_std(h,0x21,0x20,true);

  while (1) {
    do_bulk_transfer(h);
    libusb_handle_events(mspContext);
  }
  printf("Exiting.\n");
  MSP_uninitialize(h);
  return(0);
}
Пример #11
0
/**
 * g_usb_context_set_debug:
 * @context: a #GUsbContext
 * @flags: a GLogLevelFlags such as %G_LOG_LEVEL_ERROR | %G_LOG_LEVEL_INFO, or 0
 *
 * Sets the debug flags which control what is logged to the console.
 *
 * Using %G_LOG_LEVEL_INFO will output to standard out, and everything
 * else logs to standard error.
 *
 * Since: 0.1.0
 **/
void
g_usb_context_set_debug (GUsbContext    *context,
                         GLogLevelFlags  flags)
{
	GUsbContextPrivate *priv;
	int debug_level;

	g_return_if_fail (G_USB_IS_CONTEXT (context));

	priv = context->priv;

	if (flags & (G_LOG_LEVEL_DEBUG | G_LOG_LEVEL_INFO))
		debug_level = 3;
	else if (flags & (G_LOG_LEVEL_MESSAGE | G_LOG_LEVEL_WARNING))
		debug_level = 2;
	else if (flags & (G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_ERROR))
		debug_level = 1;
	else
		debug_level = 0;

	if (debug_level != priv->debug_level) {
		priv->debug_level = debug_level;
		libusb_set_debug (priv->ctx, debug_level);

		g_object_notify_by_pspec (G_OBJECT (context), pspecs[PROP_DEBUG_LEVEL]);
	}
}
Пример #12
0
//http://www.dreamincode.net/forums/topic/148707-introduction-to-using-libusb-10/
int list_all_usb_devices() {

	libusb_device **devs; //pointer to pointer of device, used to retrieve a list of devices
	libusb_context *ctx = NULL; //a libusb session
	int r; //for return values
	ssize_t cnt; //holding number of devices in list
	r = libusb_init(&ctx); //initialize a library session
	if(r < 0) {
		std::cout<<"Init Error "<<r<<std::endl; //there was an error
				return 1;
	}

	libusb_set_debug(ctx, 3); //set verbosity level to 3, as suggested in the documentation
	cnt = libusb_get_device_list(ctx, &devs); //get the list of devices

	if(cnt < 0)
		std::cout<<"Get Device Error"<<std::endl; //there was an error

	std::cout<<cnt<<" Devices in list."<<std::endl; //print total number of usb devices
	ssize_t i; //for iterating through the list

	for(i = 0; i < cnt; i++)
		printdev(devs[i]); //print specs of this device

		libusb_free_device_list(devs, 1); //free the list, unref the devices in it
		libusb_exit(ctx); //close the session

		return 0;
}
Пример #13
0
/* Getting device handle */
int init () {
	libusb_init(NULL);
	libusb_set_debug(NULL, 3);

	// Wireless mode
	handle = libusb_open_device_with_vid_pid(NULL, DEV_VID, DEV_PID_Wireless);
	if (handle == NULL) {
		// Wired mode
		handle = libusb_open_device_with_vid_pid(NULL, DEV_VID, DEV_PID_Wired);
		
		if (handle == NULL) {
			printf("[Error] Naga Epic not found!\n");
			libusb_exit(NULL);
			return 1;
		} else {
			printf("[Info] Naga Epic is connected\n");
		}
	} else {
		printf("[Info] Naga Epic Dock is connected\n");
	}
	
	// Detaching mouse from kernel
	if (libusb_kernel_driver_active(handle,DEV_INTF))
		libusb_detach_kernel_driver(handle, DEV_INTF);
		
	if (libusb_claim_interface(handle,  DEV_INTF) < 0) {
		printf("[Error] IO exception\n");
		libusb_close(handle);
		libusb_exit(NULL);
		return 1;
	}
	
	return 0;
}
Пример #14
0
	bool FalconCommLibUSB::initLibUSB()
	{
		if((m_deviceErrorCode = libusb_init(&m_usbContext)) < 0)
		{
			std::cout << "failed to initialise libusb" << std::endl;
			return false;
		}
#if defined(LIBUSB_DEBUG)
		//Spam libusb messages
		//Between 0-3 for libusb 1.0
		libusb_set_debug(m_usbContext, 3);
#else
		libusb_set_debug(m_usbContext, 0);
#endif
		
	}
Пример #15
0
void RX2164::init(map<channelId, map<actionId, RxActionData>> v_channel_action, std::function<void(int, int, int, int, u_char, u_char, u_char, u_char)> &callback, int debug_lvl)
{
    _channel_actions = v_channel_action;
    _callback_func = callback;
    ASSERT_WITH_CODE(debug_lvl, return);
    libusb_set_debug(usb_ctx, debug_lvl);
}
Пример #16
0
int main (int argc, char *argv[])
{
    int err;
    struct libusb_device_handle* handle;

    if ((err = libusb_init (&ctx)) != 0) {
        printf ("libusb_init failed with code %d\n", err);
        return 1;
    }

    libusb_set_debug (ctx, 3);

    handle = libusb_open_device_with_vid_pid (ctx, GTP_VENDOR, GTP_PRODUCT);

    if (!handle)
        printf ("LCD-USB device not found\n");
    else {
        libusb_claim_interface (handle, 0);

        printf ("LCD-USB device found, version = %s\n", lcd_get_version (handle));
    }

    libusb_close (handle);
    libusb_exit (ctx);
    return 0;
}
Пример #17
0
	int Context::setDebug(State & state, Context_wrapper * wrapper){
		Stack * stack = state.stack;
		if (stack->is<LUA_TNUMBER>(1)){
			libusb_set_debug(wrapper->context, stack->to<int>(1));
		}
		return 0;
	}
Пример #18
0
int jtag_libusb_open(const uint16_t vids[], const uint16_t pids[],
		struct jtag_libusb_device_handle **out)
{
	int cnt, idx, errCode;

	if (libusb_init(&jtag_libusb_context) < 0)
		return -ENODEV;

	libusb_set_debug(jtag_libusb_context, 3);

	cnt = libusb_get_device_list(jtag_libusb_context, &devs);

	for (idx = 0; idx < cnt; idx++) {
		if (!jtag_libusb_match(devs[idx], vids, pids))
			continue;

		errCode = libusb_open(devs[idx], out);

		/** Free the device list **/
		libusb_free_device_list(devs, 1);

		if (errCode < 0)
			return errCode;
		return 0;
	}
	return -ENODEV;
}
Пример #19
0
int main(int argc, char **argv)
{
    //Pass Interrupt Signal to our handler
	signal(SIGINT, sighandler);

	libusb_init(&ctx);
	libusb_set_debug(ctx, 3);

    //Open Device with VendorID and ProductID
	handle = libusb_open_device_with_vid_pid(ctx,
				USB_VENDOR_ID, USB_PRODUCT_ID);
	if (!handle) {
		perror("device not found");
		return 1;
	}

	int r = 1;
	//Claim Interface 0 from the device
    r = libusb_claim_interface(handle, 0);
	if (r < 0) {
		fprintf(stderr, "usb_claim_interface error %d\n", r);
		return 2;
	}
	printf("Interface claimed\n");

	while (1){
		usb_read();
//		usb_write();
    }
    //never reached
	libusb_close(handle);
	libusb_exit(NULL);

	return 0;
}
Пример #20
0
int
FTDIDevice_Open(FTDIDevice *dev)
{
  int err;

  memset(dev, 0, sizeof *dev);

  if ((err = libusb_init(&dev->libusb))) {
    return err;
  }

  libusb_set_debug(dev->libusb, 2);

  dev->handle = libusb_open_device_with_vid_pid(dev->libusb,
						OV_VENDOR,
						OV_PRODUCT);

  if (!dev->handle) {
    dev->handle = libusb_open_device_with_vid_pid(dev->libusb,
						  FTDI_VENDOR,
						  FTDI_PRODUCT_FT2232H);
  }

  if (!dev->handle) {
    return LIBUSB_ERROR_NO_DEVICE;
  }

  return DeviceInit(dev);
}
Пример #21
0
int main(int argc, char *argv[])
{
	int err;

	libusb_init(NULL);
	libusb_set_debug(NULL, 3);

	/* Try to open directly accessory. If it's not there, try to switch phone to it */
	handle = libusb_open_device_with_vid_pid(NULL, ACCESSORY_VID, ACCESSORY_PID_DBG);
	//if(handle)
		//libusb_reset_device(handle);

	if(handle == NULL){
		printf("Device not in Accessory mode. Trying to switch it to it...\n");
		err = setupAccessory("STMicroelectronics", "adkping", "Just pings data", "2.0",
			"http://www.st.com", "1234567890123456");
		if(err < 0){
			fprintf(stdout, "Sorry, can't set up accessory, giving up\n");
			deInit();
			return -1;
		}
	}

	/* Do some stuff */
	if(mainPhase() < 0){
		fprintf(stdout, "Error during main phase\n");
		deInit();
		return -1;
	}
	
	deInit();
	fprintf(stdout, "Done, no errors\n");

	return 0;
}
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
}
Пример #23
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;
}
Пример #24
0
/** \ingroup core
 * Set message verbosity.
 *  - Level 0: no messages ever printed by the library (default)
 *  - Level 1: error messages are printed to stderr
 *  - Level 2: warning and error messages are printed to stderr
 *  - Level 3: informational messages are printed to stdout, warning and error
 *    messages are printed to stderr
 *
 * The default level is 0, which means no messages are ever printed. If you
 * choose to increase the message verbosity level, ensure that your
 * application does not close the stdout/stderr file descriptors.
 *
 * You are advised to set level 3. libfprint is conservative with its message
 * logging and most of the time, will only log messages that explain error
 * conditions and other oddities. This will help you debug your software.
 *
 * If the LIBFPRINT_DEBUG environment variable was set when libfprint was
 * initialized, this function does nothing: the message verbosity is fixed
 * to the value in the environment variable.
 *
 * If libfprint was compiled without any message logging, this function does
 * nothing: you'll never get any messages.
 *
 * If libfprint was compiled with verbose debug message logging, this function
 * does nothing: you'll always get messages from all levels.
 *
 * \param ctx the context to operate on, or NULL for the default context
 * \param level debug level to set
 */
API_EXPORTED void fp_set_debug(int level)
{
	if (log_level_fixed)
		return;

	log_level = level;
	libusb_set_debug(fpi_usb_ctx, level);
}
Пример #25
0
API_EXPORTED void usb_set_debug(int level)
{
	usb_debug = level;

	/* usb_set_debug can be called before usb_init */
	if (ctx)
		libusb_set_debug(ctx, 3);
}
Пример #26
0
void irecv_set_debug_level(int level) {
	libirecovery_debug = level;
#ifndef WIN32
	if(libirecovery_context) {
		libusb_set_debug(libirecovery_context, libirecovery_debug);
	}
#endif
}
Пример #27
0
//==============================================================================
void USB_Device::set_debug_mode(DebugLevel level)
{
#if defined(LIBUSB_API_VERSION) && (LIBUSB_API_VERSION >= 0x01000106)
	libusb_set_option(context_.get(), LIBUSB_OPTION_LOG_LEVEL, level);
#else
	libusb_set_debug(context_.get(), level);
#endif
}
Пример #28
0
int ptouch_open(ptouch_dev *ptdev)
{
	libusb_device **devs;
	libusb_device *dev;
	libusb_device_handle *handle = NULL;
	struct libusb_device_descriptor desc;
	ssize_t cnt;
	int r,i=0;

	if ((*ptdev=malloc(sizeof(struct _ptouch_dev))) == NULL) {
		fprintf(stderr, _("out of memory\n"));
		return -1;
	}
	if ((libusb_init(NULL)) < 0) {
		fprintf(stderr, _("libusb_init() failed\n"));
		return -1;
	}
#ifdef DEBUG
	libusb_set_debug(NULL, 3);
#endif /* DEBUG */
	if ((cnt=libusb_get_device_list(NULL, &devs)) < 0) {
		return -1;
	}
	while ((dev=devs[i++]) != NULL) {
		if ((r=libusb_get_device_descriptor(dev, &desc)) < 0) {
			fprintf(stderr, _("failed to get device descriptor"));
			libusb_free_device_list(devs, 1);
			return -1;
		}
		for (int k=0; ptdevs[k].vid > 0; k++) {
			if ((desc.idVendor == ptdevs[k].vid) && (desc.idProduct == ptdevs[k].pid) && (ptdevs[k].flags >= 0)) {
				fprintf(stderr, _("%s found on USB bus %d, device %d\n"),
					ptdevs[k].name,
					libusb_get_bus_number(dev),
					libusb_get_device_address(dev));
				if ((r=libusb_open(dev, &handle)) != 0) {
					fprintf(stderr, _("libusb_open error :%s\n"), libusb_error_name(r));
					return -1;
				}
				libusb_free_device_list(devs, 1);
				if ((r=libusb_kernel_driver_active(handle, 0)) == 1) {
					if ((r=libusb_detach_kernel_driver(handle, 0)) != 0) {
						fprintf(stderr, _("error while detaching kernel driver: %s\n"), libusb_error_name(r));
					}
				}
				if ((r=libusb_claim_interface(handle, 0)) != 0) {
					fprintf(stderr, _("interface claim error: %s\n"), libusb_error_name(r));
					return -1;
				}
				(*ptdev)->h=handle;
				return 0;
			}
		}
	}
	fprintf(stderr, _("No P-Touch printer found on USB (remember to put switch to position E)\n"));
	libusb_free_device_list(devs, 1);
	return -1;
}
Пример #29
0
bool AsyncPluginImpl::Start() {
  if (libusb_init(&m_context)) {
    OLA_WARN << "Failed to init libusb";
    return false;
  }

  OLA_DEBUG << "libusb debug level set to " << m_debug_level;
  libusb_set_debug(m_context, m_debug_level);

  m_use_hotplug = HotplugSupported();
  OLA_INFO << "HotplugSupported returned " << m_use_hotplug;
  if (m_use_hotplug) {
#ifdef HAVE_LIBUSB_HOTPLUG_API
    m_usb_thread.reset(new LibUsbHotplugThread(
          m_context, hotplug_callback, this));
#else
    OLA_FATAL << "Mismatch between m_use_hotplug and "
      " HAVE_LIBUSB_HOTPLUG_API";
    return false;
#endif
  } else {
    m_usb_thread.reset(new LibUsbSimpleThread(m_context));
  }
  m_usb_adaptor.reset(new AsyncronousLibUsbAdaptor(m_usb_thread.get()));

  // Setup the factories.
  m_widget_factories.push_back(new AnymauDMXFactory(m_usb_adaptor.get()));
  m_widget_factories.push_back(
      new EuroliteProFactory(m_usb_adaptor.get()));
  m_widget_factories.push_back(
      new JaRuleFactory(m_plugin_adaptor, m_usb_adaptor.get()));
  m_widget_factories.push_back(
      new ScanlimeFadecandyFactory(m_usb_adaptor.get()));
  m_widget_factories.push_back(new SunliteFactory(m_usb_adaptor.get()));
  m_widget_factories.push_back(new VellemanK8062Factory(m_usb_adaptor.get()));

  // If we're using hotplug, this starts the hotplug thread.
  if (!m_usb_thread->Init()) {
    STLDeleteElements(&m_widget_factories);
    m_usb_adaptor.reset();
    m_usb_thread.reset();
    return false;
  }

  if (!m_use_hotplug) {
    // Either we don't support hotplug or the setup failed.
    // As poor man's hotplug, we call libusb_get_device_list periodically to
    // check for new devices.
    m_scan_timeout = m_plugin_adaptor->RegisterRepeatingTimeout(
        TimeInterval(5, 0),
        NewCallback(this, &AsyncPluginImpl::ScanUSBDevices));

    // Call it immediately now.
    ScanUSBDevices();
  }

  return true;
}
Пример #30
0
	bool FalconCommLibUSB::initLibUSB()
	{
		LOG_INFO("Initializing communications");
		if((m_deviceErrorCode = libusb_init(&m_usbContext)) < 0)
		{
			LOG_ERROR("Failed to initialize");
			return false;
		}
#if defined(LIBUSB_DEBUG)
		//Spam libusb messages
		//Between 0-3 for libusb 1.0
		LOG_INFO("Setting libusb debug level to 3");
		libusb_set_debug(m_usbContext, 3);
#else
		LOG_INFO("Setting libusb debug level to 0");
		libusb_set_debug(m_usbContext, 0);
#endif
	}