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");
}
}
