//********************************************************** //! //! 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); }
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; }
/* 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; }
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; }
/* 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; }
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; }
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; }
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; }
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; }
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; }
/* * 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; }
int jtag_libusb_set_configuration(jtag_libusb_device_handle *devh, int configuration) { struct jtag_libusb_device *udev = jtag_libusb_get_device(devh); int retCode = -99; struct libusb_config_descriptor *config = NULL; int current_config = -1; retCode = libusb_get_configuration(devh, ¤t_config); if (retCode != 0) return retCode; retCode = libusb_get_config_descriptor(udev, configuration, &config); if (retCode != 0 || config == NULL) return retCode; /* Only change the configuration if it is not already set to the same one. Otherwise this issues a lightweight reset and hangs LPC-Link2 with JLink firmware. */ if (current_config != config->bConfigurationValue) retCode = libusb_set_configuration(devh, config->bConfigurationValue); libusb_free_config_descriptor(config); return retCode; }
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; }
/** * @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; }
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; }
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 */ }
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; }
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 }
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)); } }
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); } }
//============================================================================== 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); }
// 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); }
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(); }