gboolean read_g_stdin(GIOChannel * source, GIOCondition condition, gpointer data){
struct libusb_transfer ** bulkIO = (struct libusb_transfer **)data;
struct libusb_transfer * bulk_in = bulkIO[0];
struct libusb_transfer * bulk_out = bulkIO[1];
unsigned char * in_buf = NULL;
gsize bytes_read = 0;
gsize terminator_pos = 0;
GError * error = NULL;
if(condition & ~(G_IO_IN | G_IO_ERR | G_IO_HUP)){
printf("**Unknown GIOCondition\n");
g_main_loop_quit(edfc_main);
return FALSE;
}
if(condition & G_IO_ERR){
printf("**stdin error\n");
g_main_loop_quit(edfc_main);
return FALSE;
}
if(condition & G_IO_HUP){
printf("**stdin hung up\n");
g_main_loop_quit(edfc_main);
return FALSE;
}
//then condition must be G_IO_IN
g_io_channel_read_line(source, (gchar**)&in_buf, &bytes_read, &terminator_pos, &error);
if(bytes_read > 0){ //todo: handle series of chars?
printf("input: %c\n", in_buf[0]);
bulk_out->length=1;
switch(in_buf[0]){
case 'g':
libusb_submit_transfer(bulk_in);
break;
case 'B':
bulk_out->buffer[0] = 'B';
if(libusb_submit_transfer(bulk_out))
printf("last char transfer not yet submitted\n");
break;
case 'q':
printf("\nquit\n");
//todo: send stop to IMU?
libusb_cancel_transfer(bulk_in);
libusb_cancel_transfer(bulk_out);
g_main_loop_quit(edfc_main);
break;
default:
printf("unknown input\n");
break;
}
g_free(in_buf);
}
return TRUE;
}
static void usb_panic_and_reset_state(struct aura_node *node)
{
struct usb_dev_info *inf = aura_get_transportdata(node);
slog(4, SLOG_DEBUG, "usb: pending transfers: %s %s",
inf->ibusy ? "interrupt " : "",
inf->cbusy ? "control" : "" );
if (inf->state != AUSB_DEVICE_SEARCHING) {
slog(4, SLOG_DEBUG, "usb: Entering 'failing' state");
inf->state = AUSB_DEVICE_FAILING;
if (inf->ibusy) {
libusb_cancel_transfer(inf->itransfer);
slog(4, SLOG_DEBUG, "usb: cancelling itransfer");
}
if (inf->cbusy) {
libusb_cancel_transfer(inf->ctransfer);
slog(4, SLOG_DEBUG, "usb: cancelling ctransfer");
}
}
if ((!inf->ibusy) && (!inf->cbusy)) {
slog(4, SLOG_DEBUG, "usb: Cleanup done, entering 'restart' state");
/*
* We can't call libusb_close from within a callback
* some versions of libusb will hang, we'll close
* from main loop
*/
/* libusb_close(inf->handle); */
inf->state = AUSB_DEVICE_RESTART;
}
}
static void
cd_sensor_unlock_thread_cb (GTask *task,
gpointer source_object,
gpointer task_data,
GCancellable *cancellable)
{
CdSensor *sensor = CD_SENSOR (object);
CdSensorMunkiPrivate *priv = cd_sensor_munki_get_private (sensor);
gboolean ret = FALSE;
g_autoptr(GError) error = NULL;
/* stop watching the dial */
libusb_cancel_transfer (priv->transfer_interrupt);
libusb_cancel_transfer (priv->transfer_state);
/* close */
if (priv->device != NULL) {
if (!g_usb_device_close (priv->device, &error)) {
g_task_return_new_error (task,
CD_SENSOR_ERROR,
CD_SENSOR_ERROR_INTERNAL,
"%s", error->message);
return;
}
g_clear_object (&priv->device);
}
/* success */
g_task_return_boolean (task, TRUE);
}
void close_transfers()
{
libusb_cancel_transfer(xfr[0]);
libusb_cancel_transfer(xfr[1]);
while(num_transfers)
{
if( !USBMgr::instance()->handleEvents() )
{
break;
}
}
}
void FalconCommLibUSB::reset()
{
if(m_isWriteAllocated)
{
libusb_cancel_transfer(in_transfer);
setSent();
}
if(m_isReadAllocated)
{
libusb_cancel_transfer(out_transfer);
setReceived();
}
}
void HID_API_EXPORT hid_close(hid_device *dev)
{
if (!dev)
return;
/* Cause read_thread() to stop. */
dev->shutdown_thread = 1;
libusb_cancel_transfer(dev->transfer);
/* Wait for read_thread() to end. */
pthread_join(dev->thread, NULL);
/* Clean up the Transfer objects allocated in read_thread(). */
free(dev->transfer->buffer);
libusb_free_transfer(dev->transfer);
/* release the interface */
libusb_release_interface(dev->device_handle, dev->interface);
/* Close the handle */
libusb_close(dev->device_handle);
/* Clear out the queue of received reports. */
pthread_mutex_lock(&dev->mutex);
while (dev->input_reports) {
return_data(dev, NULL, 0);
}
pthread_mutex_unlock(&dev->mutex);
free_hid_device(dev);
}
FN_INTERNAL int fnusb_stop_iso(fnusb_dev *dev, fnusb_isoc_stream *strm)
{
freenect_context *ctx = dev->parent->parent;
int i;
FN_FLOOD("fnusb_stop_iso() called\n");
strm->dead = 1;
for (i=0; i<strm->num_xfers; i++)
libusb_cancel_transfer(strm->xfers[i]);
FN_FLOOD("fnusb_stop_iso() cancelled all transfers\n");
while (strm->dead_xfers < strm->num_xfers) {
FN_FLOOD("fnusb_stop_iso() dead = %d\tnum = %d\n", strm->dead_xfers, strm->num_xfers);
libusb_handle_events(ctx->usb.ctx);
}
for (i=0; i<strm->num_xfers; i++)
libusb_free_transfer(strm->xfers[i]);
FN_FLOOD("fnusb_stop_iso() freed all transfers\n");
free(strm->buffer);
free(strm->xfers);
FN_FLOOD("fnusb_stop_iso() freed buffers and stream\n");
FN_FLOOD("fnusb_stop_iso() done\n");
return 0;
}
void ubertooth_stop(struct libusb_device_handle *devh)
{
/* make sure xfers are not active */
if(rx_xfer != NULL)
libusb_cancel_transfer(rx_xfer);
if (devh != NULL) {
cmd_stop(devh);
libusb_release_interface(devh, 0);
}
libusb_close(devh);
libusb_exit(NULL);
#if defined(USE_PCAP)
if (h_pcap_bredr) {
btbb_pcap_close(h_pcap_bredr);
h_pcap_bredr = NULL;
}
if (h_pcap_le) {
lell_pcap_close(h_pcap_le);
h_pcap_le = NULL;
}
#endif
if (h_pcapng_bredr) {
btbb_pcapng_close(h_pcapng_bredr);
h_pcapng_bredr = NULL;
}
if (h_pcapng_le) {
lell_pcapng_close(h_pcapng_le);
h_pcapng_le = NULL;
}
}
uint8_t portpilot_helpers_free_ctx(struct portpilot_ctx *pp_ctx, uint8_t force)
{
struct portpilot_dev *ppd_itr = pp_ctx->dev_head.lh_first, *ppd_tmp;
uint8_t failed_cancels = 0;
while (ppd_itr != NULL) {
ppd_tmp = ppd_itr;
ppd_itr = ppd_itr->next_dev.le_next;
//We are only allowed to free memory if transfer is cancelled, so check
//for this and indicate to loop if we need to wait for cancelled
//transfers
if (force || (ppd_tmp->transfer &&
libusb_cancel_transfer(ppd_tmp->transfer) ==
LIBUSB_ERROR_NOT_FOUND)) {
portpilot_helpers_free_dev(ppd_tmp);
} else {
++pp_ctx->num_cancel;
++failed_cancels;
}
}
if (failed_cancels)
return failed_cancels;
if (pp_ctx->output_timeout_handle)
free(pp_ctx->output_timeout_handle);
free(pp_ctx->itr_timeout_handle);
free(pp_ctx->libusb_handle);
free(pp_ctx->event_loop);
free(pp_ctx);
return failed_cancels;
}
FX3Dev::~FX3Dev() {
if ( write_transfer ) {
libusb_cancel_transfer(write_transfer);
libusb_free_transfer(write_transfer);
}
if ( device_handle ) {
int ires = libusb_release_interface(device_handle, 0);
if( ires != 0 ) {
fprintf( stderr,"FX3Dev::~FX3Dev(): libusb_release_interface failed with code %d %s\n", ires, libusb_error_name( ires ) );
}
libusb_close( device_handle );
device_handle = NULL;
}
if ( ctx ) {
libusb_exit( ctx );
}
for( uint32_t i = 0; i < buffers_count; i++ ) {
delete [] half_full_buffers[ i ];
}
if ( write_buffer ) {
delete[] write_buffer;
}
}
static void exit_release_resources(int code)
{
if(tap_fd >= 0) {
if_down();
while (wait(NULL) > 0) {}
if_release();
while (wait(NULL) > 0) {}
}
if(ctx != NULL) {
if(req_transfer != NULL) {
libusb_cancel_transfer(req_transfer);
libusb_free_transfer(req_transfer);
}
libusb_set_pollfd_notifiers(ctx, NULL, NULL, NULL);
if(fds != NULL) {
free(fds);
}
if(devh != NULL) {
libusb_release_interface(devh, 0);
if (kernel_driver_active)
libusb_attach_kernel_driver(devh, 0);
libusb_unlock_events(ctx);
libusb_close(devh);
}
libusb_exit(ctx);
}
if(logfile != NULL) {
fclose(logfile);
}
exit(code);
}
int ubertooth_bulk_receive(ubertooth_t* ut, rx_callback cb, void* cb_args)
{
int i;
usb_pkt_rx* rx;
if (ut->usb_really_full) {
/* process each received block */
for (i = 0; i < PKTS_PER_XFER; i++) {
rx = (usb_pkt_rx *)(ut->full_usb_buf + PKT_LEN * i);
if(rx->pkt_type != KEEP_ALIVE) {
ringbuffer_add(ut->packets, rx);
(*cb)(ut, cb_args);
}
if(ut->stop_ubertooth) {
if(ut->rx_xfer)
libusb_cancel_transfer(ut->rx_xfer);
return 1;
}
}
ut->usb_really_full = 0;
fflush(stderr);
return 0;
} else {
return -1;
}
}
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,
bulk_transfer_cb, &completed, timeout);
transfer->type = type;
r = libusb_submit_transfer(transfer);
if (r < 0) {
libusb_free_transfer(transfer);
return r;
}
while (!completed) {
r = libusb_handle_events(HANDLE_CTX(dev_handle));
if (r < 0) {
libusb_cancel_transfer(transfer);
while (!completed)
if (libusb_handle_events(HANDLE_CTX(dev_handle)) < 0)
break;
libusb_free_transfer(transfer);
return r;
}
}
*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;
default:
usbi_warn(HANDLE_CTX(dev_handle),
"unrecognised status code %d", transfer->status);
r = LIBUSB_ERROR_OTHER;
}
libusb_free_transfer(transfer);
return r;
}
Chatpad::~Chatpad()
{
if (m_read_transfer)
{
libusb_cancel_transfer(m_read_transfer);
libusb_free_transfer(m_read_transfer);
}
}
void LibusbDevice::TransferEndpoint::CancelTransfers()
{
std::lock_guard<std::mutex> lk(m_transfers_mutex);
if (m_transfers.empty())
return;
INFO_LOG(IOS_USB, "Cancelling %ld transfer(s)", m_transfers.size());
for (const auto& pending_transfer : m_transfers)
libusb_cancel_transfer(pending_transfer.first);
}
void aesX660_dev_deactivate(struct fp_img_dev *dev)
{
struct aesX660_dev *aesdev = dev->priv;
if (aesdev->fd_data_transfer)
libusb_cancel_transfer(aesdev->fd_data_transfer);
aesdev->deactivating = TRUE;
}
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;
}
static void abort_acquisition(struct dev_context *devc)
{
int i;
devc->sent_samples = -1;
for (i = devc->num_transfers - 1; i >= 0; i--) {
if (devc->transfers[i])
libusb_cancel_transfer(devc->transfers[i]);
}
}
extern "C" int LIBUSB_CALL hotplugDetachCallback (libusb_context *, libusb_device *, libusb_hotplug_event, void *ref)
{
qDebug()<<"Hotplug detach";
LibUsbDevice *cthis = static_cast<LibUsbDevice *>(ref);
if(cthis->isDeviceConnected)
{
if(cthis->usbDeviceToPcTransfer)
{
libusb_cancel_transfer(cthis->usbDeviceToPcTransfer);
}
if(cthis->pcToUsbDeviceTransfer)
{
libusb_cancel_transfer(cthis->pcToUsbDeviceTransfer);
}
libusb_release_interface(cthis->deviceHandle, INTERFACE_NUMBER);
libusb_close(cthis->deviceHandle);
cthis->isDeviceConnected = false;
}
return 0;
}
SR_PRIV void fx2lafw_abort_acquisition(struct dev_context *devc)
{
int i;
devc->acq_aborted = TRUE;
for (i = devc->num_transfers - 1; i >= 0; i--) {
if (devc->transfers[i])
libusb_cancel_transfer(devc->transfers[i]);
}
}
/*The API is used to cancel the uart Event notification*/
CYWINEXPORT CY_RETURN_STATUS WINCALLCONVEN CyAbortEventNotification(
CY_HANDLE handle /*Valid handle to communicate with device*/
)
{
CY_DEVICE *device;
device = (CY_DEVICE*)handle;
pthread_mutex_lock (&device->notificationLock);
if (device->deviceType == CY_TYPE_UART){
if ((device->uartThreadId == 0)){
CY_DEBUG_PRINT_ERROR ("CY:Error uart event notification not created ....function is %s \n", __func__);
pthread_mutex_unlock (&device->notificationLock);
return CY_ERROR_REQUEST_FAILED;
}
device->uartCancelEvent = true;
libusb_cancel_transfer (device->uartTransfer);
pthread_join (device->uartThreadId, NULL);
device->uartThreadId = 0;
device->uartCancelEvent = false;
pthread_mutex_unlock (&device->notificationLock);
return CY_SUCCESS;
}
else if (device->deviceType == CY_TYPE_SPI){
if ((device->spiThreadId == 0)){
CY_DEBUG_PRINT_ERROR ("CY:Error spi event notification not created ....function is %s \n", __func__);
pthread_mutex_unlock (&device->notificationLock);
return CY_ERROR_REQUEST_FAILED;
}
device->spiCancelEvent = true;
libusb_cancel_transfer (device->spiTransfer);
pthread_join (device->spiThreadId, NULL);
device->spiThreadId = 0;
device->spiCancelEvent = false;
pthread_mutex_unlock (&device->notificationLock);
return CY_SUCCESS;
}
else {
CY_DEBUG_PRINT_ERROR ("CY:Error.. unknown device type ....function is %s \n", __func__);
pthread_mutex_unlock (&device->notificationLock);
return CY_ERROR_REQUEST_FAILED;
}
}
EnttecDMXDevice::~EnttecDMXDevice()
{
/*
* If we have pending transfers, cancel them.
* The Transfer objects themselves will be freed once libusb completes them.
*/
for (std::set<Transfer*>::iterator i = mPending.begin(), e = mPending.end(); i != e; ++i) {
Transfer *fct = *i;
libusb_cancel_transfer(fct->transfer);
}
}
int slogic_spindown(struct slogic_ctx *handle){
unsigned int transfer_id;
for (transfer_id = 0; transfer_id < handle->n_transfer_buffers; transfer_id++) {
if(handle->transfers[transfer_id].state == 1){
libusb_cancel_transfer(handle->transfers[transfer_id].transfer);
libusb_free_transfer(handle->transfers[transfer_id].transfer);
handle->transfers[transfer_id].state = 0;
}
}
return 1; //did i want to do something with this?
}
FCDevice::~FCDevice()
{
/*
* If we have pending transfers, cancel them and jettison them
* from the FCDevice. The Transfer objects themselves will be freed
* once libusb completes them.
*/
for (std::set<Transfer*>::iterator i = mPending.begin(), e = mPending.end(); i != e; ++i) {
Transfer *fct = *i;
libusb_cancel_transfer(fct->transfer);
fct->device = 0;
}
}
int ReapTransfer(transfer_wrapper* wrapper, int timeout)
{
void* context (wrapper->usb);
libusb_transfer* transfer (&wrapper->libusb);
if (transfer->flags & LIBUSB_TRANSFER_FREE_TRANSFER)
{
libusb_free_transfer(transfer);
return(0);
}
const int read = usb_reap_async_nocancel(context, timeout);
bool processed (true);
if (read > 0)
{
PreprocessTransfer(transfer, read);
}
else if (0 == read)
{
const int pkts (transfer->num_iso_packets);
for (int i=0; i<pkts; ++i)
{
libusb_iso_packet_descriptor& desc (transfer->iso_packet_desc[i]);
desc.actual_length = 0;
}
}
else if (read < 0)
{
enum { ETIMEOUT = -116 };
if (ETIMEOUT == read)
{
if (LIBUSB_TRANSFER_CANCELLED != transfer->status)
processed = false;
}
else
{
libusb_cancel_transfer(transfer);
processed = false;
}
}
if (processed)
{
TListTransfers::Remove(wrapper);
transfer->callback(transfer);
if (read > 0)
memset(transfer->buffer, 0, transfer->length);
}
return(read);
}
void TransferPool::cancel()
{
for(TransferQueue::iterator it = pending_transfers_.begin(); it != pending_transfers_.end(); ++it)
{
int r = libusb_cancel_transfer(*it);
if(r != LIBUSB_SUCCESS)
{
// TODO: error reporting
}
}
//idle_transfers_.insert(idle_transfers_.end(), pending_transfers_.begin(), pending_transfers_.end());
}
void LibUsbDevice::closeDevice()
{
if(isDeviceConnected)
{
if(usbDeviceToPcTransfer)
{
libusb_cancel_transfer(usbDeviceToPcTransfer);
}
if(pcToUsbDeviceTransfer)
{
libusb_cancel_transfer(pcToUsbDeviceTransfer);
}
enableEventThread = false;
if(hasHotPlugSupport)
{
// libusb_hotplug_deregister_callback(context, hotplugHandle[0]);
// libusb_hotplug_deregister_callback(context, hotplugHandle[1]);
}
future.waitForFinished();
saveDeviceSettings();
libusb_release_interface(deviceHandle, INTERFACE_NUMBER);
libusb_close(deviceHandle);
libusb_exit(context);
}
else if(isInitialiazed)
{
enableEventThread = false;
if(hasHotPlugSupport)
{
// libusb_hotplug_deregister_callback(context, hotplugHandle[0]);
// libusb_hotplug_deregister_callback(context, hotplugHandle[1]);
}
future.waitForFinished();
libusb_exit(context);
}
}
USBInterface::~USBInterface()
{
// cancel all transfer that might still be running
for(Endpoints::iterator it = m_endpoints.begin(); it != m_endpoints.end(); ++it)
{
if (it->second)
{
libusb_cancel_transfer(it->second);
libusb_free_transfer(it->second);
}
}
m_endpoints.clear();
libusb_release_interface(m_handle, m_interface);
}
void
USBInterface::cancel_transfer(int endpoint)
{
Endpoints::iterator it = m_endpoints.find(endpoint);
if (it == m_endpoints.end())
{
raise_exception(std::runtime_error, "endpoint " << (endpoint & LIBUSB_ENDPOINT_ADDRESS_MASK) << "not found");
}
else
{
libusb_cancel_transfer(it->second);
libusb_free_transfer(it->second);
m_endpoints.erase(it);
}
}
/* Stop the audio capture by selecting the alternate settings 0 */
static int _mxuvc_audio_stop(audio_channel_t ch)
{
int ret;
unsigned int c=0, i;
TRACE("Stopping audio\n");
CHECK_ERROR(ch >= audio_num_channels, -1,
"Unsupported channel number %d", ch);
CHECK_ERROR(aud_started == 0, -1, "Unable to stop the audio: "
"audio hasn't been started yet.");
aud_started = 0;
if(!audio_disconnected) {
/* First try to wait for the transfer to complete instead of canceling them.
* Cancel the transfers if it takes more than 1 seconds for the transfers
* to complete.
* The reason why we don't directly cancel the transfers is that in ISOC
* mode, libusb sometimes seems to miss packets on other interfaces while
* transfers are being canceled on this interface */
while(get_active_transfers()) {
if(c >= 1000000) {
for(i=0; i<num_transfers; i++)
if(aud_cfg.xfers[i] != NULL)
libusb_cancel_transfer(aud_cfg.xfers[i]);
}
usleep(3000);
c+=3000;
}
/* Select alt settings 0 */
ret = libusb_set_interface_alt_setting(audio_hdl,
aud_cfg.interface, 0);
CHECK_ERROR(ret < 0, -1,
"Unable to stop the audio: could not set the "
"alternate setting.");
} else {
while(get_active_transfers())
usleep(3000);
}
TRACE("%u audio frames captured\n", aud_frame_count);
aud_frame_count = 0;
return 0;
}
