static void *read_thread(void *param) { hid_device *dev = param; unsigned char *buf; const size_t length = dev->input_ep_max_packet_size; /* Set up the transfer object. */ buf = malloc(length); dev->transfer = libusb_alloc_transfer(0); libusb_fill_interrupt_transfer(dev->transfer, dev->device_handle, dev->input_endpoint, buf, length, read_callback, dev, 5000/*timeout*/); /* Make the first submission. Further submissions are made from inside read_callback() */ libusb_submit_transfer(dev->transfer); // Notify the main thread that the read thread is up and running. pthread_barrier_wait(&dev->barrier); /* Handle all the events. */ while (!dev->shutdown_thread) { int res; struct timeval tv; tv.tv_sec = 0; tv.tv_usec = 100; //TODO: Fix this value. res = libusb_handle_events_timeout(NULL, &tv); if (res < 0) { /* There was an error. Break out of this loop. */ break; } } /* Cancel any transfer that may be pending. This call will fail if no transfers are pending, but that's OK. */ if (libusb_cancel_transfer(dev->transfer) == 0) { /* The transfer was cancelled, so wait for its completion. */ libusb_handle_events(NULL); } /* The dev->transfer->buffer and dev->transfer objects are cleaned up in hid_close(). They are not cleaned up here because this thread could end either due to a disconnect or due to a user call to hid_close(). In both cases the objects can be safely cleaned up after the call to pthread_join() (in hid_close()), but since hid_close() calls libusb_cancel_transfer(), on these objects, they can not be cleaned up here. */ return NULL; }
/////////////////////////////////////////////////////////////////////////////// // readAsync() - read async data from accessory device /////////////////////////////////////////////////////////////////////////////// //argument // callback : callback function. // void function(struct libusb_transfer *transfer) //return // <0 : LIBUSB_ERROR_NO_DEVICE if the device has been disconnected and a // LIBUSB_ERROR code on other failure. // =0 : Succes // int AOA::readAsync(libusb_transfer_cb_fn callback, char* buffer, int bufferLen, void* userData, unsigned int timeout) { libusb_fill_bulk_transfer( inTransfer, handle, inEP, // EP_RESPONSE, (uint8_t*)buffer, bufferLen, callback, userData, timeout); inTransfer->type = LIBUSB_TRANSFER_TYPE_BULK; int result = libusb_submit_transfer(inTransfer); return result; }
int hw_start_acquisition(int device_index, gpointer session_device_id) { struct usb_device_instance *udi; struct datafeed_packet *packet; struct datafeed_header *header; struct libusb_transfer *transfer; const struct libusb_pollfd **lupfd; int size, i; unsigned char *buf; if( !(udi = get_usb_device_instance(usb_devices, device_index))) return SIGROK_NOK; packet = g_malloc(sizeof(struct datafeed_packet)); header = g_malloc(sizeof(struct datafeed_header)); if(!packet || !header) return SIGROK_NOK; /* start with 2K transfer, subsequently increased to 4K */ size = 2048; for(i = 0; i < NUM_SIMUL_TRANSFERS; i++) { buf = g_malloc(size); transfer = libusb_alloc_transfer(0); libusb_fill_bulk_transfer(transfer, udi->devhdl, 2 | LIBUSB_ENDPOINT_IN, buf, size, receive_transfer, session_device_id, 40); if(libusb_submit_transfer(transfer) != 0) { /* TODO: free them all */ libusb_free_transfer(transfer); g_free(buf); return SIGROK_NOK; } size = 4096; } lupfd = libusb_get_pollfds(usb_context); for(i = 0; lupfd[i]; i++) add_source_fd(lupfd[i]->fd, lupfd[i]->events, receive_data, NULL); free(lupfd); packet->type = DF_HEADER; packet->length = sizeof(struct datafeed_header); packet->payload = (unsigned char *) header; header->feed_version = 1; gettimeofday(&header->starttime, NULL); header->rate = cur_sample_rate; header->protocol_id = PROTO_RAW; header->num_probes = NUM_PROBES; session_bus(session_device_id, packet); g_free(header); g_free(packet); return SIGROK_OK; }
void portpilot_helpers_start_reading_data(struct portpilot_dev *pp_dev) { int32_t retval; if (!pp_dev->read_buf) pp_dev->read_buf = calloc(pp_dev->max_packet_size, 1); //Failed to allocate buffer, must indicate to loop if (!pp_dev->read_buf) { fprintf(stderr, "Failed to allocate read buffer\n"); if (pp_dev->read_state != READ_STATE_FAILED_START) portpilot_set_read_start_failed(pp_dev); return; } if (!pp_dev->transfer) { pp_dev->transfer = libusb_alloc_transfer(0); pp_dev->transfer->flags = LIBUSB_TRANSFER_FREE_BUFFER; } if (!pp_dev->transfer) { fprintf(stderr, "Failed to allocate libusb transfer\n"); if (pp_dev->read_state != READ_STATE_FAILED_START) portpilot_set_read_start_failed(pp_dev); return; } libusb_fill_interrupt_transfer(pp_dev->transfer, pp_dev->handle, pp_dev->input_endpoint, (unsigned char*) pp_dev->read_buf, pp_dev->max_packet_size, portpilot_cb_read_cb, pp_dev, 5000); retval = libusb_submit_transfer(pp_dev->transfer); //Don't consider an already transfered transfer a failure. This should not //really happen now, but it could be that we want to do something smart wrt //caching and so on later if (retval && retval != LIBUSB_ERROR_BUSY) { fprintf(stderr, "Failed to submit transfer\n"); if (pp_dev->read_state != READ_STATE_FAILED_START) portpilot_set_read_start_failed(pp_dev); return; } if (pp_dev->read_state == READ_STATE_FAILED_START) portpilot_logger_stop_itr_cb(pp_dev->pp_ctx); pp_dev->read_state = READ_STATE_RUNNING; }
// input bool UsbEndPoint::receive(Message* message) { //if (_busy) return false; _transfer->timeout = 0; _transfer->buffer = (unsigned char*)message; _transfer->length = sizeof(Message); _busy = true; return libusb_submit_transfer(_transfer) == 0; }
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); } }
extern "C" void LIBUSB_CALL asyncBulkReadTransferCallback(struct libusb_transfer *transfer) { LibUsbDevice *cthis = static_cast<LibUsbDevice *>(transfer->user_data); cthis->dataAvailable = true; if(cthis->enableEventThread) { cthis->dataLength = transfer->actual_length; libusb_submit_transfer(transfer); } }
int usbio_transfer_submit(struct usbio_transfer *xfer) { int res = libusb_submit_transfer(xfer->transfer); if (res != 0) { g_warning("usbio_transfer_submit: cannot submit transfer '%s:%d', error = %s", xfer->transfer_type, xfer->index, libusb_error_name(res)); return res; } xfer->pending = TRUE; return 0; }
// output bool UsbEndPoint::submit(MessageHeader* msgHeader) { if (_busy) return false; _transfer->timeout = msgHeader->Timeout; _transfer->buffer = (unsigned char*)&msgHeader->Message; _transfer->length = sizeof(Message); _busy = true; return libusb_submit_transfer(_transfer) == 0; }
static void cb_xfer(struct libusb_transfer *xfer) { int r; uint8_t *tmp; ubertooth_t* ut = (ubertooth_t*)xfer->user_data; if (xfer->status != LIBUSB_TRANSFER_COMPLETED) { if(xfer->status == LIBUSB_TRANSFER_TIMED_OUT) { r = libusb_submit_transfer(ut->rx_xfer); if (r < 0) fprintf(stderr, "Failed to submit USB transfer (%d)\n", r); return; } if(xfer->status != LIBUSB_TRANSFER_CANCELLED) rx_xfer_status(xfer->status); libusb_free_transfer(xfer); ut->rx_xfer = NULL; return; } if(ut->usb_really_full) { /* This should never happen, but we'd prefer to error and exit * than to clobber existing data */ fprintf(stderr, "uh oh, full_usb_buf not emptied\n"); ut->stop_ubertooth = 1; } if(ut->stop_ubertooth) return; tmp = ut->full_usb_buf; ut->full_usb_buf = ut->empty_usb_buf; ut->empty_usb_buf = tmp; ut->usb_really_full = 1; ut->rx_xfer->buffer = ut->empty_usb_buf; r = libusb_submit_transfer(ut->rx_xfer); if (r < 0) fprintf(stderr, "Failed to submit USB transfer (%d)\n", r); }
static void submit_control(struct aura_node *node) { int ret; struct usb_dev_info *inf = aura_get_transportdata(node); ret = libusb_submit_transfer(inf->ctransfer); if (ret!= 0) { slog(0, SLOG_ERROR, "usb: error submitting control transfer"); usb_panic_and_reset_state(node); } inf->cbusy=true; }
static int do_sync_bulk_transfer(struct libusb_device_handle *dev_handle, unsigned char endpoint, unsigned char *buffer, int length, int *transferred, unsigned int timeout, unsigned char type) { struct libusb_transfer *transfer = libusb_alloc_transfer(0); int completed = 0; int r; if (!transfer) return LIBUSB_ERROR_NO_MEM; libusb_fill_bulk_transfer(transfer, dev_handle, endpoint, buffer, length, sync_transfer_cb, &completed, timeout); transfer->type = type; r = libusb_submit_transfer(transfer); if (r < 0) { libusb_free_transfer(transfer); return r; } sync_transfer_wait_for_completion(transfer); *transferred = transfer->actual_length; switch (transfer->status) { case LIBUSB_TRANSFER_COMPLETED: r = 0; break; case LIBUSB_TRANSFER_TIMED_OUT: r = LIBUSB_ERROR_TIMEOUT; break; case LIBUSB_TRANSFER_STALL: r = LIBUSB_ERROR_PIPE; break; case LIBUSB_TRANSFER_OVERFLOW: r = LIBUSB_ERROR_OVERFLOW; break; case LIBUSB_TRANSFER_NO_DEVICE: r = LIBUSB_ERROR_NO_DEVICE; break; case LIBUSB_TRANSFER_ERROR: case LIBUSB_TRANSFER_CANCELLED: r = LIBUSB_ERROR_IO; break; default: usbi_warn(HANDLE_CTX(dev_handle), "unrecognised status code %d", transfer->status); r = LIBUSB_ERROR_OTHER; } libusb_free_transfer(transfer); return r; }
static int init_capture(void) { int r; r = libusb_submit_transfer(irq_transfer); if (r < 0) return r; r = libusb_submit_transfer(img_transfer); if (r < 0) { libusb_cancel_transfer(irq_transfer); while (irq_transfer) if (libusb_handle_events(NULL) < 0) break; return r; } /* start state machine */ state = STATE_AWAIT_IRQ_FINGER_REMOVED; return next_state(); }
static void LIBUSB_CALL dump_iface_list_stream_cb(struct libusb_transfer *transfer) { enum libusb_error err; uhd_iface *iface; assert(transfer != NULL); iface = (uhd_iface *)transfer->user_data; assert(uhd_iface_valid(iface)); /* Clear interface "has transfer submitted" flag */ iface->submitted = false; switch (transfer->status) { case LIBUSB_TRANSFER_COMPLETED: /* Dump the result */ if (!stream_paused) { dump(iface, "STREAM", transfer->buffer, transfer->actual_length); if (stream_feedback) fputc('.', stderr); } /* Resubmit the transfer */ err = libusb_submit_transfer(transfer); if (err != LIBUSB_SUCCESS) LIBUSB_IFACE_FAILURE(iface, "resubmit a transfer"); else { /* Set interface "has transfer submitted" flag */ iface->submitted = true; } break; #define MAP(_name, _desc) \ case LIBUSB_TRANSFER_##_name: \ IFACE_ERROR(iface, _desc); \ break MAP(ERROR, "Interrupt transfer failed"); MAP(TIMED_OUT, "Interrupt transfer timed out"); MAP(STALL, "Interrupt transfer halted (endpoint stalled)"); MAP(NO_DEVICE, "Device was disconnected"); MAP(OVERFLOW, "Interrupt transfer overflowed " "(device sent more data than requested)"); #undef MAP case LIBUSB_TRANSFER_CANCELLED: break; } }
int slogic_pump_data(struct slogic_ctx *handle, unsigned int transfer_id){ int retval; if((retval = libusb_submit_transfer(handle->transfers[transfer_id].transfer))){ handle->transfers[transfer_id].state = 1; log_printf( ERR, "libusb_submit_transfer: %s\n", usbutil_error_to_string(retval)); handle->recording_state = UNKNOWN; return 1; } return 0; }
bool start_transfers(libusb_device_handle *handle, uint32_t curr_frame_size) { struct libusb_transfer *xfr0,*xfr1; uint8_t* buff, *buff1; uint8_t ep_addr; int bsize = 16384; frame_size = curr_frame_size; // bulk transfers xfr0 = libusb_alloc_transfer(0); xfr1 = libusb_alloc_transfer(0); buff = frame_buffer_end; buff1 = buff + bsize; memset(frame_buffer_end, 0, bsize*2); xfr[0] = xfr0; xfr[1] = xfr1; ep_addr = find_ep(libusb_get_device(handle)); //debug("found ep: %d\n", ep_addr); libusb_clear_halt(handle, ep_addr); libusb_fill_bulk_transfer(xfr0, handle, ep_addr, buff, bsize, cb_xfr, reinterpret_cast<void*>(this), 0); libusb_fill_bulk_transfer(xfr1, handle, ep_addr, buff1, bsize, cb_xfr, reinterpret_cast<void*>(this), 0); int res = libusb_submit_transfer(xfr0); res |= libusb_submit_transfer(xfr1); num_transfers = 2; frame_complete_ind = 0; frame_work_ind = 0; last_pts = 0; last_fid = 0; last_frame_time = 0; return res == 0; }
void usb_write(uint8_t *data, size_t datalen) { struct libusb_transfer *xfer; unsigned char *buf; writes_pending += 1; xfer = libusb_alloc_transfer(0); buf = (unsigned char *)malloc(datalen); memcpy(buf, data, datalen); libusb_fill_bulk_transfer(xfer, usb_dev, d->ep_out, buf, datalen, usb_write_done, NULL, 0); libusb_submit_transfer(xfer); }
static void usb_initiate_transfer() { unsigned char *buf; buf = (unsigned char *)malloc(256); // Tell libusb we want to know about bulk transfers struct libusb_transfer *xfer = libusb_alloc_transfer(0); libusb_fill_bulk_transfer(xfer, usb_dev, d->ep_in, buf, 256, usb_xfer_done, NULL, 0); libusb_submit_transfer(xfer); reads_pending += 1; }
static void submit_interrupt(struct aura_node *node) { struct usb_dev_info *inf = aura_get_transportdata(node); int ret; if (inf->ibusy) return; ret = libusb_submit_transfer(inf->itransfer); inf->ibusy = true; if (ret!= 0) { slog(0, SLOG_ERROR, "usb: error submitting interrupt transfer"); usb_panic_and_reset_state(node); } }
bool fusb_devhandle::_submit_lut (libusb_transfer *lut) { int ret = libusb_submit_transfer (lut); if (ret < 0) { LOG(ERR) << "submit_lut " << ret; return false; } pending_add(lut); return true; }
void DeviceHandleLibUSB::readAsyncImpl(uint8_t endpoint_) { libusb_transfer* pTransfer = libusb_alloc_transfer(0); libusb_fill_bulk_transfer(pTransfer, m_pCurrentDevice, endpoint_, m_inputBuffer.data(), kInputBufferSize, cbTransfer, this, kLibUSBReadTimeout); libusb_submit_transfer(pTransfer); //!\todo check libusb_submit_transfer return code }
bool FalconCommLibUSB::write(uint8_t* buffer, uint32_t size) { if(!m_isCommOpen) { m_errorCode = FALCON_COMM_DEVICE_NOT_VALID_ERROR; return false; } libusb_fill_bulk_transfer(in_transfer, m_falconDevice, 0x02, buffer, size, FalconCommLibUSB::cb_in, this, 0); libusb_submit_transfer(in_transfer); m_isWriteAllocated = true; //Try to read over 64 and you'll fry libusb-1.0. Granted, the endpoint //limits that anyways, but still. libusb_fill_bulk_transfer(out_transfer, m_falconDevice, 0x81, output, 64, FalconCommLibUSB::cb_out, this, 1000); libusb_submit_transfer(out_transfer); m_isReadAllocated = true; return true; }
/* Handle callbacks * * With Exit request, free memory and release the transfer * * state->result is only set when some error happens */ static void ftdi_readstream_cb(struct libusb_transfer *transfer) { FTDIStreamState *state = transfer->user_data; int packet_size = state->packetsize; state->activity++; if (transfer->status == LIBUSB_TRANSFER_COMPLETED) { int i; uint8_t *ptr = transfer->buffer; int length = transfer->actual_length; int numPackets = (length + packet_size - 1) / packet_size; int res = 0; for (i = 0; i < numPackets; i++) { int payloadLen; int packetLen = length; if (packetLen > packet_size) packetLen = packet_size; payloadLen = packetLen - 2; state->progress.current.totalBytes += payloadLen; res = state->callback(ptr + 2, payloadLen, NULL, state->userdata); ptr += packetLen; length -= packetLen; } if (res) { free(transfer->buffer); libusb_free_transfer(transfer); } else { transfer->status = -1; state->result = libusb_submit_transfer(transfer); } } else { fprintf(stderr, "unknown status %d\n",transfer->status); state->result = LIBUSB_ERROR_IO; } }
int freespace_setReceiveMessageCallback(FreespaceDeviceId id, freespace_receiveMessageCallback callback, void* cookie) { struct FreespaceDevice* device = findDeviceById(id); int wereInSyncMode; int rc; if (device == NULL) { return FREESPACE_ERROR_NOT_FOUND; } wereInSyncMode = (device->receiveMessageCallback_ == NULL && device->receiveCallback_ == NULL); device->receiveMessageCallback_ = callback; device->receiveMessageCookie_ = cookie; if (callback != NULL && wereInSyncMode && device->state_ == FREESPACE_OPENED) { struct freespace_message m; // Transition from sync mode to async mode. // Need to run the callback on all received messages. struct FreespaceReceiveTransfer* rt; rt = &device->receiveQueue_[device->receiveQueueHead_]; while (rt->submitted_ == 0) { rc = freespace_decode_message((const uint8_t*) rt->buffer_, rt->transfer_->actual_length, &m, device->api_->hVer_); if (rc == FREESPACE_SUCCESS) { callback(device->id_, &m, cookie, libusb_transfer_status_to_freespace_error(rt->transfer_->status)); } else { callback(device->id_, NULL, cookie, rc); } rt->submitted_ = 1; libusb_submit_transfer(rt->transfer_); device->receiveQueueHead_++; if (device->receiveQueueHead_ >= FREESPACE_RECEIVE_QUEUE_SIZE) { device->receiveQueueHead_ = 0; } rt = &device->receiveQueue_[device->receiveQueueHead_]; } } return FREESPACE_SUCCESS; }
void recv(libusb_device_handle *dh) { pack_ = Packet::create(); busy_ = true; xfer_->dev_handle = dh; libusb_fill_bulk_transfer(xfer_, dh, RECV_ENDPOINT, pack_->buffer(), pack_->max_size(), &Transfer::callback, this, 1000); // a second is a long time! int err = libusb_submit_transfer(xfer_); if (err != 0) { std::cerr << "libusb_submit_transfer(): " << err << ": " << libusb_error_name(err) << std::endl; pack_->destroy(); pack_ = 0; usleep(10000); busy_ = false; } }
/* Submit an already filled-in USB transfer. */ static int submit_transfer(struct dev_context *devc, struct libusb_transfer *xfer) { int ret; ret = libusb_submit_transfer(xfer); if (ret != 0) { sr_err("Submit transfer failed: %s.", libusb_error_name(ret)); devc->transfer_error = TRUE; return SR_ERR; } return SR_OK; }
int64_t FX3Stream::send(int64_t words, uint32_t *data, unsigned timeout) { if( error ) { cerr << "Blocked" << endl; return 0; } totalBytes = words*4; extBuf = (unsigned char*)data; transferredBytes = 0; submittedBytes = 0; shortPackets = 0; //Start transfer for( unsigned i = 0; i < transfers.size() && transferredBytes+submittedBytes < totalBytes; ++i ) { int64_t remainingBytes = totalBytes-(transferredBytes+submittedBytes); if( remainingBytes > FX3_TRANSFER_SIZE ) { libusb_fill_bulk_transfer( transfers[i], devhandle, FX3_OUT_EP, &extBuf[transferredBytes+submittedBytes], FX3_TRANSFER_SIZE, FX3Stream::sendCallback, this, timeout ); submittedBytes += FX3_TRANSFER_SIZE; } else if( remainingBytes > 0 ) { libusb_fill_bulk_transfer( transfers[i], devhandle, FX3_OUT_EP, &extBuf[transferredBytes+submittedBytes], remainingBytes, FX3Stream::sendCallback, this, timeout ); submittedBytes += remainingBytes; } error = libusb_submit_transfer( transfers[i] ); if( error ) { cerr << "Error submitting transfer: " << libusb_error_name(error) << endl; break; } } //Wait for transfer while( submittedBytes ) { int r = libusb_handle_events_completed(0,0); if( r ) { cerr << "Error handling events: " << libusb_error_name(r) << endl; error = r; break; } } if( shortPackets ) { cerr << "Error: Short packet(s) in outgoing transfers." << endl; shortPackets = 0; } if( error < 0 ) { cerr << "Error sending data: " << libusb_error_name(error) << endl; } if( error == LIBUSB_ERROR_TIMEOUT ) { error = 0; } return transferredBytes/4; }
static void iso_callback(struct libusb_transfer *xfer) { int i; fnusb_isoc_stream *strm = xfer->user_data; if(xfer->status == LIBUSB_TRANSFER_COMPLETED) { uint8_t *buf = (void*)xfer->buffer; for (i=0; i<strm->pkts; i++) { strm->cb(strm->parent->parent, buf, xfer->iso_packet_desc[i].actual_length); buf += strm->len; } libusb_submit_transfer(xfer); } else { printf("Xfer error: %d\n", xfer->status); } }
static void cb_req(struct libusb_transfer *transfer) { if (transfer->status != LIBUSB_TRANSFER_COMPLETED) { wmlog_msg(1, "async bulk read error %d", transfer->status); if (transfer->status == LIBUSB_TRANSFER_NO_DEVICE) { device_disconnected = 1; return; } } else { wmlog_dumphexasc(3, transfer->buffer, transfer->actual_length, "Async read:"); process_response(&wd_status, transfer->buffer, transfer->actual_length); } if (libusb_submit_transfer(req_transfer) < 0) { wmlog_msg(1, "async read transfer sumbit failed"); } }