FN_INTERNAL int fnusb_claim_camera(freenect_device* dev) { freenect_context *ctx = dev->parent; int ret = 0; #ifndef _WIN32 // todo: necessary? // Detach an existing kernel driver for the device ret = libusb_kernel_driver_active(dev->usb_cam.dev, 0); if (ret == 1) { ret = libusb_detach_kernel_driver(dev->usb_cam.dev, 0); if (ret < 0) { FN_ERROR("Failed to detach camera kernel driver: %s\n", libusb_error_name(ret)); libusb_close(dev->usb_cam.dev); dev->usb_cam.dev = NULL; return ret; } } #endif ret = libusb_claim_interface(dev->usb_cam.dev, 0); if (ret < 0) { FN_ERROR("Failed to claim camera interface: %s\n", libusb_error_name(ret)); libusb_close(dev->usb_cam.dev); dev->usb_cam.dev = NULL; return ret; } if (dev->usb_cam.PID == PID_K4W_CAMERA) { ret = libusb_set_interface_alt_setting(dev->usb_cam.dev, 0, 1); if (ret != 0) { FN_ERROR("Failed to set alternate interface #1 for K4W: %s\n", libusb_error_name(ret)); libusb_close(dev->usb_cam.dev); dev->usb_cam.dev = NULL; return ret; } } return ret; }
// Read the MS WinUSB Feature Descriptors, that are used on Windows 8 for automated driver installation static void read_ms_winsub_feature_descriptors(libusb_device_handle *handle, uint8_t bRequest, int iface_number) { #define MAX_OS_FD_LENGTH 256 int i, r; uint8_t os_desc[MAX_OS_FD_LENGTH]; uint32_t length; void* le_type_punning_IS_fine; struct { const char* desc; uint16_t index; uint16_t header_size; } os_fd[2] = { {"Extended Compat ID", 0x0004, 0x10}, {"Extended Properties", 0x0005, 0x0A} }; if (iface_number < 0) return; for (i=0; i<2; i++) { printf("\nReading %s OS Feature Descriptor (wIndex = 0x%04d):\n", os_fd[i].desc, os_fd[i].index); // Read the header part r = libusb_control_transfer(handle, (uint8_t)(LIBUSB_ENDPOINT_IN|LIBUSB_REQUEST_TYPE_VENDOR|LIBUSB_RECIPIENT_DEVICE), bRequest, (uint16_t)(((iface_number)<< 8)|0x00), os_fd[i].index, os_desc, os_fd[i].header_size, 1000); if (r < os_fd[i].header_size) { perr(" Failed: %s", (r<0)?libusb_error_name((enum libusb_error)r):"header size is too small"); return; } le_type_punning_IS_fine = (void*)os_desc; length = *((uint32_t*)le_type_punning_IS_fine); if (length > MAX_OS_FD_LENGTH) { length = MAX_OS_FD_LENGTH; } // Read the full feature descriptor r = libusb_control_transfer(handle, (uint8_t)(LIBUSB_ENDPOINT_IN|LIBUSB_REQUEST_TYPE_VENDOR|LIBUSB_RECIPIENT_DEVICE), bRequest, (uint16_t)(((iface_number)<< 8)|0x00), os_fd[i].index, os_desc, (uint16_t)length, 1000); if (r < 0) { perr(" Failed: %s", libusb_error_name((enum libusb_error)r)); return; } else { display_buffer_hex(os_desc, r); } } }
static bool aoa_initialize(libusb_device_handle* handle, AOAMode mode) { unsigned char aoa_version_buf[2] = {}; int rc; // https://source.android.com/devices/accessories/aoa.html rc = libusb_control_transfer(handle, USB_DIR_IN | USB_TYPE_VENDOR, 51, 0, 0, aoa_version_buf, sizeof(aoa_version_buf), 0); if (rc < 0) { error("failed to initialize AoA: %s", libusb_error_name(rc)); return false; } uint16_t aoa_version; memcpy(&aoa_version, aoa_version_buf, sizeof(aoa_version_buf)); if (aoa_version != 2) { error("unsupported AOA protocol version %u", aoa_version); return false; } auto sendString = [handle](int string_id, const std::string& string) { int rc = libusb_control_transfer(handle, USB_DIR_OUT | USB_TYPE_VENDOR, 52, 0, string_id, (unsigned char*)(string.c_str()), string.length() + 1, 0); if (rc < 0) { error("failed to send vendor string: %s", libusb_error_name(rc)); return false; } return true; }; // When not in accessory mode, don't send the manufacturer or model strings to avoid prompting. // https://source.android.com/devices/accessories/aoa2.html // // TODO: Make these strings configurable. if (!(sendString(AOA_STRING_DESCRIPTION, DESCRIPTION) && sendString(AOA_STRING_VERSION, VERSION) && sendString(AOA_STRING_URI, URI) && sendString(AOA_STRING_SERIAL, SERIAL))) { return false; } if ((mode & AOAMode::accessory) == AOAMode::accessory) { return sendString(AOA_STRING_MANUFACTURER, MANUFACTURER) && sendString(AOA_STRING_MODEL, MODEL); } return true; }
static int lusb_open(void **driver, struct bladerf_devinfo *info_in, struct bladerf_devinfo *info_out) { int status; struct bladerf_lusb *lusb = NULL; libusb_context *context; /* Initialize libusb for device tree walking */ status = libusb_init(&context); if (status) { log_error("Could not initialize libusb: %s\n", libusb_error_name(status)); return error_conv(status); } /* We can only print this out when log output is enabled, or else we'll * get snagged by -Werror=unused-but-set-variable */ # ifdef LOGGING_ENABLED { char buf[64]; get_libusb_version(buf, sizeof(buf)); log_verbose("Using libusb version: %s\n", buf); } # endif status = find_and_open_device(context, info_in, &lusb, info_out); if (status != 0) { libusb_exit(context); if (status == BLADERF_ERR_NODEV) { log_debug("No devices available on the libusb backend.\n"); } else { log_debug("Failed to open bladeRF on libusb backend: %s\n", bladerf_strerror(status)); } } else { assert(lusb != NULL); /* Cosmin and Marian from Null Team (null.ro) and YateBTS(.com) found * that it is possible to recover from "Issue #95: Not enough bandwidth * for altsetting" by performing a USB port reset prior to actually * trying to use the device. */ # if ENABLE_USB_DEV_RESET_ON_OPEN if (bladerf_usb_reset_device_on_open) { status = reset_and_reopen(context, &lusb, info_out); } # endif if (status == 0) { *driver = (void *) lusb; } } return status; }
void cmd_getter(struct libusb_device_handle* devh, int vendor_req, char *dataptr, int length) { int r; r = libusb_control_transfer(devh, CTRL_IN, vendor_req, 0, 0, dataptr, length, TIMEOUT); if (r < 0) { libusb_error_name(r); } }
unsigned char unixUsbDriver::usbIsoInit(void){ int error; for(int n=0;n<NUM_FUTURE_CTX;n++){ for (unsigned char k=0;k<NUM_ISO_ENDPOINTS;k++){ isoCtx[k][n] = libusb_alloc_transfer(ISO_PACKETS_PER_CTX); transferCompleted[k][n].number = (k * ISO_PACKETS_PER_CTX) + n; transferCompleted[k][n].completed = false; libusb_fill_iso_transfer(isoCtx[k][n], handle, pipeID[k], dataBuffer[k][n], ISO_PACKET_SIZE*ISO_PACKETS_PER_CTX, ISO_PACKETS_PER_CTX, isoCallback, (void*)&transferCompleted[k][n], 4000); libusb_set_iso_packet_lengths(isoCtx[k][n], ISO_PACKET_SIZE); } } for(int n=0;n<NUM_FUTURE_CTX;n++){ for (unsigned char k=0;k<NUM_ISO_ENDPOINTS;k++){ error = libusb_submit_transfer(isoCtx[k][n]); if(error){ qDebug() << "libusb_submit_transfer FAILED"; qDebug() << "ERROR" << libusb_error_name(error); } else { if(n == 0){ qint64 t0; qint64 t = QDateTime::currentMSecsSinceEpoch(); if(k==0){ t0 = t; } midBufferOffsets[k] = t0 - t; qDebug() << "isoCtx submitted successfully!"; qDebug() << "[n, k] = " << n << k; qDebug() << "t = " << t; qDebug() << "Delay = " << 0;//midBufferOffsets[k]; } } } } isoTimer = new QTimer(); isoTimer->setTimerType(Qt::PreciseTimer); isoTimer->start(ISO_TIMER_PERIOD); connect(isoTimer, SIGNAL(timeout()), this, SLOT(isoTimerTick())); qDebug() << "Setup successful!"; isoHandler = new worker(); workerThread = new QThread(); isoHandler->ctx = ctx; isoHandler->moveToThread(workerThread); connect(workerThread, SIGNAL(started()), isoHandler, SLOT(handle())); workerThread->start(); qDebug() << "MAIN THREAD ID" << QThread::currentThreadId(); //QThread::sleep(1); qDebug() << "Iso Stack initialised!"; return 1; }
int atecard_driver_init_inner() { int ret = libusb_init(NULL); if (ret < 0) { printf("libusb_init() failed: %s\r\n", libusb_error_name(ret)); return -1; } if (libusb_get_device_list(NULL, &g_usbdevs) < 0) { printf("libusb_get_device_list() failed: %s\r\n", libusb_error_name(ret)); libusb_exit(NULL); return -1; } return 0; }
static int scpi_usbtmc_remote(struct scpi_usbtmc_libusb *uscpi) { struct sr_usb_dev_inst *usb = uscpi->usb; struct libusb_device *dev; struct libusb_device_descriptor des; int ret; uint8_t status; if (!(uscpi->usb488_dev_cap & USB488_DEV_CAP_RL1)) return SR_OK; dev = libusb_get_device(usb->devhdl); libusb_get_device_descriptor(dev, &des); if (check_usbtmc_blacklist(blacklist_remote, des.idVendor, des.idProduct)) return SR_OK; sr_dbg("Locking out local control."); ret = libusb_control_transfer(usb->devhdl, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE, REN_CONTROL, 1, uscpi->interface, &status, 1, TRANSFER_TIMEOUT); if (ret < 0 || status != USBTMC_STATUS_SUCCESS) { if (ret < 0) sr_dbg("Failed to enter REN state: %s.", libusb_error_name(ret)); else sr_dbg("Failed to enter REN state: USBTMC status %d.", status); return SR_ERR; } ret = libusb_control_transfer(usb->devhdl, LIBUSB_ENDPOINT_IN | LIBUSB_REQUEST_TYPE_CLASS | LIBUSB_RECIPIENT_INTERFACE, LOCAL_LOCKOUT, 0, uscpi->interface, &status, 1, TRANSFER_TIMEOUT); if (ret < 0 || status != USBTMC_STATUS_SUCCESS) { if (ret < 0) sr_dbg("Failed to enter local lockout state: %s.", libusb_error_name(ret)); else sr_dbg("Failed to enter local lockout state: USBTMC " "status %d.", status); return SR_ERR; } return SR_OK; }
SR_PRIV int sr_usb_open(libusb_context *usb_ctx, struct sr_usb_dev_inst *usb) { struct libusb_device **devlist; struct libusb_device_descriptor des; int ret, r, cnt, i, a, b; sr_dbg("Trying to open USB device %d.%d.", usb->bus, usb->address); if ((cnt = libusb_get_device_list(usb_ctx, &devlist)) < 0) { sr_err("Failed to retrieve device list: %s.", libusb_error_name(cnt)); return SR_ERR; } ret = SR_ERR; for (i = 0; i < cnt; i++) { if ((r = libusb_get_device_descriptor(devlist[i], &des)) < 0) { sr_err("Failed to get device descriptor: %s.", libusb_error_name(r)); continue; } b = libusb_get_bus_number(devlist[i]); a = libusb_get_device_address(devlist[i]); if (b != usb->bus || a != usb->address) continue; if ((r = libusb_open(devlist[i], &usb->devhdl)) < 0) { sr_err("Failed to open device: %s.", libusb_error_name(r)); break; } sr_dbg("Opened USB device (VID:PID = %04x:%04x, bus.address = " "%d.%d).", des.idVendor, des.idProduct, b, a); ret = SR_OK; break; } libusb_free_device_list(devlist, 1); return ret; }
SR_PRIV int ezusb_upload_firmware(libusb_device *dev, int configuration, const char *filename) { struct libusb_device_handle *hdl; int ret; sr_info("uploading firmware to device on %d.%d", libusb_get_bus_number(dev), libusb_get_device_address(dev)); if ((ret = libusb_open(dev, &hdl)) < 0) { sr_err("failed to open device: %s.", libusb_error_name(ret)); return SR_ERR; } /* Neither Windows/MinGW nor Darwin/Mac support these libusb-1.0 calls. */ #if !defined(_WIN32) && !defined(__APPLE__) if (libusb_kernel_driver_active(hdl, 0)) { if ((ret = libusb_detach_kernel_driver(hdl, 0)) < 0) { sr_err("failed to detach kernel driver: %s", libusb_error_name(ret)); return SR_ERR; } } #endif if ((ret = libusb_set_configuration(hdl, configuration)) < 0) { sr_err("Unable to set configuration: %s", libusb_error_name(ret)); return SR_ERR; } if ((ezusb_reset(hdl, 1)) < 0) return SR_ERR; if (ezusb_install_firmware(hdl, filename) < 0) return SR_ERR; if ((ezusb_reset(hdl, 0)) < 0) return SR_ERR; libusb_close(hdl); return SR_OK; }
/** * \brief Get configuration by value. * * \param value configuration value to search for. */ ConfigurationPtr Device::configValue(uint8_t value) throw(USBError) { struct libusb_config_descriptor *config; int rc = libusb_get_config_descriptor_by_value(dev, value, &config); if (rc != LIBUSB_SUCCESS) { throw USBError(libusb_error_name(rc)); } Configuration *result = new Configuration(*this, config); libusb_free_config_descriptor(config); return ConfigurationPtr(result); }
static void write_to_usb(int resp_type,int resp_result) { int err; usb_out_buf[0]=resp_type; usb_out_buf[1]=resp_result; err=libusb_interrupt_transfer(handle,0x02,usb_out_buf,USB_BUF_SIZE,&transferred,0); if(err) puts(libusb_error_name(err)); }
int cmd_no_data(struct libusb_device_handle* devh, int vendor_req) { int r; r = libusb_control_transfer(devh, CTRL_OUT, vendor_req, 0, 0, NULL, 0, TIMEOUT); if (r < 0) { libusb_error_name(r); return r; } return 0; }
/********************************************************** * Function set_relay_conrad_4chan() * * Description: Set new relay state * * Parameters: portname (in) - communication port * relay (in) - relay number * relay_state (in) - current relay state * * Return: o - success * -1 - fail *********************************************************/ int set_relay_conrad_4chan(char* portname, uint8 relay, relay_state_t relay_state) { struct libusb_device_handle *dev = NULL; int r; uint16 gpio=0; if (relay<FIRST_RELAY || relay>(FIRST_RELAY+CONRAD_4CHANNEL_USB_NUM_RELAYS-1)) { fprintf(stderr, "ERROR: Relay number out of range\n"); return -1; } libusb_init(NULL); /* Open USB device */ //r = libusb_open(device, &dev); //if (r < 0) dev = libusb_open_device_with_vid_pid(NULL, VENDOR_ID, DEVICE_ID); if (dev == NULL) { fprintf(stderr, "unable to open CP2104 device\n"); libusb_exit(NULL); return -2; } /* Set the relay state bit */ relay = relay-1; if (relay_state == OFF) gpio = 0x0001<<(relay+RSTATES_BITOFFSET); /* Set the relay bit mask */ gpio = gpio | (0x0001<<relay); /* Set relay state on the card */ r = libusb_control_transfer ( dev, // libusb_device_handle * dev_handle, REQTYPE_HOST_TO_DEVICE, // uint8_t bmRequestType, CP210X_VENDOR_SPECIFIC, // uint8_t bRequest, CP210X_WRITE_LATCH, // uint16_t wValue, gpio, // uint16_t wIndex, NULL, // unsigned char * data, 0, // uint16_t wLength, 0); // unsigned int timeout if (r < 0) { fprintf(stderr, "libusb_control_transfer error (%s)\n", libusb_error_name(r)); libusb_close(dev); libusb_exit(NULL); return -3; } libusb_close(dev); libusb_exit(NULL); return 0; }
static int send_mass_storage_command(libusb_device_handle *handle, uint8_t endpoint, uint8_t lun, uint8_t *cdb, uint8_t direction, int data_length, uint32_t *ret_tag) { static uint32_t tag = 1; uint8_t cdb_len; int i, r, size; struct command_block_wrapper cbw; if (cdb == NULL) { return -1; } if (endpoint & LIBUSB_ENDPOINT_IN) { perr("send_mass_storage_command: cannot send command on IN endpoint\n"); return -1; } cdb_len = cdb_length[cdb[0]]; if ((cdb_len == 0) || (cdb_len > sizeof(cbw.CBWCB))) { perr("send_mass_storage_command: don't know how to handle this command (%02X, length %d)\n", cdb[0], cdb_len); return -1; } memset(&cbw, 0, sizeof(cbw)); cbw.dCBWSignature[0] = 'U'; cbw.dCBWSignature[1] = 'S'; cbw.dCBWSignature[2] = 'B'; cbw.dCBWSignature[3] = 'C'; *ret_tag = tag; cbw.dCBWTag = tag++; cbw.dCBWDataTransferLength = data_length; cbw.bmCBWFlags = direction; cbw.bCBWLUN = lun; // Subclass is 1 or 6 => cdb_len cbw.bCBWCBLength = cdb_len; memcpy(cbw.CBWCB, cdb, cdb_len); i = 0; do { // The transfer length must always be exactly 31 bytes. r = libusb_bulk_transfer(handle, endpoint, (unsigned char*)&cbw, 31, &size, 1000); if (r == LIBUSB_ERROR_PIPE) { libusb_clear_halt(handle, endpoint); } i++; } while ((r == LIBUSB_ERROR_PIPE) && (i<RETRY_MAX)); if (r != LIBUSB_SUCCESS) { perr(" send_mass_storage_command: %s\n", libusb_error_name(r)); return -1; } printf(" sent %d CDB bytes\n", cdb_len); return 0; }
/** * Queries a device instances' connection identifier. * * @param sdi Device instance to use. Must not be NULL. * * @return A copy of the connection id string or NULL. The caller is responsible * for g_free()ing the string when it is no longer needed. */ SR_API const char *sr_dev_inst_connid_get(const struct sr_dev_inst *sdi) { #ifdef HAVE_LIBUSB_1_0 struct drv_context *drvc; int cnt, i, a, b; char connection_id[64]; struct sr_usb_dev_inst *usb; struct libusb_device **devlist; #endif if (!sdi) return NULL; #ifdef HAVE_LIBSERIALPORT struct sr_serial_dev_inst *serial; if ((!sdi->connection_id) && (sdi->inst_type == SR_INST_SERIAL)) { /* connection_id isn't populated, let's do that here. */ serial = sdi->conn; ((struct sr_dev_inst *)sdi)->connection_id = g_strdup(serial->port); } #endif #ifdef HAVE_LIBUSB_1_0 if ((!sdi->connection_id) && (sdi->inst_type == SR_INST_USB)) { /* connection_id isn't populated, let's do that here. */ drvc = sdi->driver->context; usb = sdi->conn; if ((cnt = libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist)) < 0) { sr_err("Failed to retrieve device list: %s.", libusb_error_name(cnt)); return NULL; } for (i = 0; i < cnt; i++) { /* Find the USB device by the logical address we know. */ b = libusb_get_bus_number(devlist[i]); a = libusb_get_device_address(devlist[i]); if (b != usb->bus || a != usb->address) continue; usb_get_port_path(devlist[i], connection_id, sizeof(connection_id)); ((struct sr_dev_inst *)sdi)->connection_id = g_strdup(connection_id); break; } libusb_free_device_list(devlist, 1); } #endif return sdi->connection_id; }
void GlobalTrainer::init() { int ecode = 0; usb_handle = libusb_open_device_with_vid_pid (usb_ctxt, GLOBAL_TRAINER_VENDOR_ID, GLOBAL_TRAINER_PRODUCT_ID); if (!usb_handle) { std::cerr << "Unable to open USB device" << std::endl; exit(EXIT_FAILURE); } ecode = libusb_kernel_driver_active(usb_handle, 1); if (ecode == 1) { ecode = libusb_detach_kernel_driver(usb_handle, 1); if (ecode == 0) detached_kernel = true; else { std::cerr << "Libusb error detaching kernel driver: " << libusb_error_name(ecode) << std::endl; exit(EXIT_FAILURE); } } else { switch (ecode) { case 0: case LIBUSB_ERROR_NOT_SUPPORTED: break; default: std::cerr << "Libusb error: " << libusb_error_name(ecode) << std::endl; exit(EXIT_FAILURE); } } ecode = libusb_claim_interface(usb_handle, 1); if (ecode) { std::cerr << "Unable to claim USB interface: " << libusb_error_name(ecode) << std::endl; exit(EXIT_FAILURE); } interface_claimed = true; std::cout << "Claimed interface!" << std::endl; }
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(); }
static int gl_write_data(libusb_device_handle *devh, unsigned int val) { unsigned char packet[8] = { val & 0xFF }; int ret; ret = libusb_control_transfer(devh, CTRL_OUT, 0xc, REQ_WRITEDATA, 0, packet, 1, TIMEOUT); if (ret != 1) sr_err("%s: %s.", __func__, libusb_error_name(ret)); return ret; }
static void resubmit_transfer(struct libusb_transfer *transfer) { int ret; if ((ret = libusb_submit_transfer(transfer)) == LIBUSB_SUCCESS) return; sr_err("%s: %s", __func__, libusb_error_name(ret)); free_transfer(transfer); }
/** * \brief Submit a bulk transfer to the device. * * This method allocates and fills the bulk transfer, and submits it to * the libusb_submit_transfer function. It then starts to handle events, * and only returns when the complete flag is set. * \param dev_handle the libusb device handle */ void BulkTransfer::submit(libusb_device_handle *dev_handle) throw(USBError) { // allocate the transfer structure transfer = libusb_alloc_transfer(0); // fill the transfer libusb_fill_bulk_transfer(transfer, dev_handle, endpoint->bEndpointAddress(), data, length, bulktransfer_callback, this, timeout); // submit the transfer int rc = libusb_submit_transfer(transfer); if (rc != LIBUSB_SUCCESS) { throw USBError(libusb_error_name(rc)); } // handle events until the complete flag is set libusb_context *ctx = getContext(); while (!complete) { libusb_handle_events(ctx); } // at this point, the transfer has somehow completed, but we // don't know yet what happened. const char *cause = NULL; switch (transfer->status) { case LIBUSB_TRANSFER_ERROR: cause = "transfer error"; break; case LIBUSB_TRANSFER_TIMED_OUT: cause = "transfer timed out"; break; case LIBUSB_TRANSFER_CANCELLED: cause = "transfer cancelled"; break; case LIBUSB_TRANSFER_STALL: cause = "transfer stall"; break; case LIBUSB_TRANSFER_NO_DEVICE: cause = "transfer no device"; break; case LIBUSB_TRANSFER_OVERFLOW: cause = "transfer overflow"; break; case LIBUSB_TRANSFER_COMPLETED: break; } if (NULL != cause) { debug(LOG_ERR, DEBUG_LOG, 0, "transfer failed: %s", cause); throw USBError(cause); } else { debug(LOG_DEBUG, DEBUG_LOG, 0, "transfer complete, %d bytes", transfer->actual_length); } }
static int gl_read_data(libusb_device_handle *devh) { unsigned char packet[8] = { 0 }; int ret; ret = libusb_control_transfer(devh, CTRL_IN, 0xc, REQ_READDATA, 0, packet, 1, TIMEOUT); if (ret != 1) sr_err("%s: %s, val=%hhx.", __func__, libusb_error_name(ret), packet[0]); return (ret == 1) ? packet[0] : ret; }
SR_PRIV int gl_read_bulk(libusb_device_handle *devh, void *buffer, unsigned int size) { unsigned char packet[8] = { 0, 0, 0, 0, size & 0xff, (size & 0xff00) >> 8, (size & 0xff0000) >> 16, (size & 0xff000000) >> 24 }; int ret, transferred = 0; ret = libusb_control_transfer(devh, CTRL_OUT, 0x4, REQ_READBULK, 0, packet, 8, TIMEOUT); if (ret != 8) sr_err("%s: libusb_control_transfer: %s.", __func__, libusb_error_name(ret)); ret = libusb_bulk_transfer(devh, EP1_BULK_IN, buffer, size, &transferred, TIMEOUT); if (ret < 0) sr_err("%s: libusb_bulk_transfer: %s.", __func__, libusb_error_name(ret)); return transferred; }
void Usb::Initialize() throw (UsbException) { if (!_isInitialized) { int returnedValue = libusb_init(&_context); // inicjalizacja biblioteki dla naszej sesji if (returnedValue < 0) throw new UsbException(libusb_error_name(returnedValue)); _isInitialized = true; } }
DeviceDescriptorPtr Device::descriptor() throw(USBError) { // get the device descriptor libusb_device_descriptor d; int rc = libusb_get_device_descriptor(dev, &d); if (rc != LIBUSB_SUCCESS) { throw USBError(libusb_error_name(rc)); } // create a DeviceDescriptor object DeviceDescriptor *devdesc = new DeviceDescriptor(*this, &d); return DeviceDescriptorPtr(devdesc); }
SR_PRIV int command_start_acquisition(libusb_device_handle *devhdl, uint64_t samplerate, gboolean samplewide) { struct cmd_start_acquisition cmd; int delay = 0, ret; /* Compute the sample rate. */ if (samplewide && samplerate > MAX_16BIT_SAMPLE_RATE) { sr_err("Unable to sample at %" PRIu64 "Hz " "when collecting 16-bit samples.", samplerate); return SR_ERR; } if ((SR_MHZ(48) % samplerate) == 0) { cmd.flags = CMD_START_FLAGS_CLK_48MHZ; delay = SR_MHZ(48) / samplerate - 1; if (delay > MAX_SAMPLE_DELAY) delay = 0; } if (delay == 0 && (SR_MHZ(30) % samplerate) == 0) { cmd.flags = CMD_START_FLAGS_CLK_30MHZ; delay = SR_MHZ(30) / samplerate - 1; } sr_info("GPIF delay = %d, clocksource = %sMHz.", delay, (cmd.flags & CMD_START_FLAGS_CLK_48MHZ) ? "48" : "30"); if (delay <= 0 || delay > MAX_SAMPLE_DELAY) { sr_err("Unable to sample at %" PRIu64 "Hz.", samplerate); return SR_ERR; } cmd.sample_delay_h = (delay >> 8) & 0xff; cmd.sample_delay_l = delay & 0xff; /* Select the sampling width. */ cmd.flags |= samplewide ? CMD_START_FLAGS_SAMPLE_16BIT : CMD_START_FLAGS_SAMPLE_8BIT; /* Send the control message. */ ret = libusb_control_transfer(devhdl, LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT, CMD_START, 0x0000, 0x0000, (unsigned char *)&cmd, sizeof(cmd), 100); if (ret < 0) { sr_err("Unable to send start command: %s.", libusb_error_name(ret)); return SR_ERR; } return SR_OK; }
static int find_device(struct cli_state *s, libusb_context * context, uint8_t bus, uint8_t addr, libusb_device_handle **handle, bool just_print) { int status, i; libusb_device *dev, **devs; libusb_device *found_dev = NULL; ssize_t status_sz; size_t num_found = 0; status_sz = libusb_get_device_list(context, &devs); if (status_sz < 0) { cli_err(s, "Error", "libusb_get_device_list() failed: %d %s\n", status_sz, libusb_error_name((int)status_sz)); return CMD_RET_UNKNOWN; } for (i = 0; (dev = devs[i]) != NULL && found_dev == NULL; i++) { if (just_print && is_bootloader_device(s, dev)) { if (num_found++ == 0) { printf("\n"); } printf(" Bootloader @ bus=%d, addr=%d\n", libusb_get_bus_number(dev), libusb_get_device_address(dev)); } else if (is_bootloader_device(s, dev) && bus == libusb_get_bus_number(dev) && addr == libusb_get_device_address(dev)) { found_dev = dev; } } if (found_dev == NULL || (just_print && num_found == 0)) { s->last_lib_error = BLADERF_ERR_NODEV; return CMD_RET_LIBBLADERF; } else if (!just_print) { status = libusb_open(found_dev, handle); if (status != 0) { s->last_lib_error = BLADERF_ERR_IO; return CMD_RET_LIBBLADERF; } } libusb_free_device_list(devs, 1); return 0; }
/* Returns true if the string descriptor indexed by str_index in device matches string */ static bool string_descriptor_equal(libusb_device_handle *device, uint8_t str_index, const char *string) { int retval; char desc_string[256]; /* Max size of string descriptor */ retval = libusb_get_string_descriptor_ascii(device, str_index, (unsigned char *)desc_string, sizeof(desc_string)); if (retval < 0) { LOG_ERROR("libusb_get_string_descriptor_ascii() failed with %s", libusb_error_name(retval)); return false; } return strncmp(string, desc_string, sizeof(desc_string)) == 0; }
void mpsse_purge(struct mpsse_ctx *ctx) { int err; LOG_DEBUG("-"); ctx->write_count = 0; ctx->read_count = 0; ctx->retval = ERROR_OK; bit_copy_discard(&ctx->read_queue); err = libusb_control_transfer(ctx->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_RESET_REQUEST, SIO_RESET_PURGE_RX, ctx->index, NULL, 0, ctx->usb_write_timeout); if (err < 0) { LOG_ERROR("unable to purge ftdi rx buffers: %s", libusb_error_name(err)); return; } err = libusb_control_transfer(ctx->usb_dev, FTDI_DEVICE_OUT_REQTYPE, SIO_RESET_REQUEST, SIO_RESET_PURGE_TX, ctx->index, NULL, 0, ctx->usb_write_timeout); if (err < 0) { LOG_ERROR("unable to purge ftdi tx buffers: %s", libusb_error_name(err)); return; } }
static void transfer_cb(struct libusb_transfer *xfr) { int rc = 0; int len = 0; unsigned int i; /* All packets are 192 bytes. */ uint8_t* recv = malloc(PACKET_SIZE * xfr->num_iso_packets); uint8_t* recv_next = recv; for (i = 0; i < xfr->num_iso_packets; i++) { struct libusb_iso_packet_descriptor *pack = &xfr->iso_packet_desc[i]; if (pack->status != LIBUSB_TRANSFER_COMPLETED) { LOGE("Error (status %d: %s)\n", pack->status, libusb_error_name(pack->status)); continue; } const uint8_t *data = libusb_get_iso_packet_buffer_simple(xfr, i); /* PACKET_SIZE == 192 == pack->length */ memcpy(recv_next, data, PACKET_SIZE); recv_next += PACKET_SIZE; len += pack->length; } /* At this point, recv points to a buffer containing len bytes of audio. */ #if !defined(ANDROID) /* Lock around this write? */ if ((rc = write(outfd, recv, len)) < 0) { perror("Unable to write to descriptor"); } #endif free(recv); /* Sanity check. If this is true, we've overflowed the recv buffer. */ if (len > PACKET_SIZE * xfr->num_iso_packets) { LOGE("Error: incoming transfer had more data than we thought.\n"); return; } if ((rc = libusb_submit_transfer(xfr)) < 0) { LOGE("libusb_submit_transfer: %s.\n", libusb_error_name(rc)); } }