HWStubBackendHelper::~HWStubBackendHelper() { #ifndef LIBUSB_NO_HOTPLUG if(m_hotplug) libusb_hotplug_deregister_callback(NULL, m_hotplug_handle); #endif /* LIBUSB_NO_HOTPLUG */ }
HotplugCallbackAdapter::~HotplugCallbackAdapter() { if(_p->handle) { libusb_hotplug_deregister_callback(NULL, _p->handle); qDebug() << "deregistered hotplug callback"; } delete _p; _p = 0; }
void finish (int res, const char *msg) { if (msg) fprintf (stderr, "%s\n", msg); if (cb_handle_initialized) { libusb_hotplug_deregister_callback(NULL, cb_handle); } if (device_initialized) { device_deinit(); } exit (res); }
void Shutdown() { StopScanThread(); if (s_libusb_hotplug_enabled) libusb_hotplug_deregister_callback(s_libusb_context, s_hotplug_handle); Reset(); if (s_libusb_context) { libusb_exit(s_libusb_context); s_libusb_context = nullptr; } s_libusb_driver_not_supported = false; }
static void libusb_hid_free(void *data) { libusb_hid_t *hid = (libusb_hid_t*)data; while(adapters.next) if (remove_adapter(hid, adapters.next->device) == -1) RARCH_ERR("could not remove device %p\n", adapters.next->device); if (hid->poll_thread) { hid->quit = 1; sthread_join(hid->poll_thread); } pad_connection_destroy(hid->slots); libusb_hotplug_deregister_callback(hid->ctx, hid->hp); libusb_exit(hid->ctx); free(hid); }
static void g_usb_context_dispose (GObject *object) { GUsbContext *context = G_USB_CONTEXT (object); GUsbContextPrivate *priv = context->priv; /* this is safe to call even when priv->hotplug_id is unset */ if (g_atomic_int_dec_and_test (&priv->thread_event_run)) { libusb_hotplug_deregister_callback (priv->ctx, priv->hotplug_id); g_thread_join (priv->thread_event); } if (priv->hotplug_poll_id > 0) { g_source_remove (priv->hotplug_poll_id); priv->hotplug_poll_id = 0; } g_clear_pointer (&priv->main_ctx, g_main_context_unref); g_clear_pointer (&priv->devices, g_ptr_array_unref); g_clear_pointer (&priv->dict_usb_ids, g_hash_table_unref); g_clear_pointer (&priv->ctx, libusb_exit); G_OBJECT_CLASS (g_usb_context_parent_class)->dispose (object); }
int API_EXPORTED libusb_hotplug_register_callback(libusb_context *ctx, libusb_hotplug_event events, libusb_hotplug_flag flags, int vendor_id, int product_id, int dev_class, libusb_hotplug_callback_fn cb_fn, void *user_data, libusb_hotplug_callback_handle *handle) { libusb_hotplug_callback *new_callback; static int handle_id = 1; /* check for hotplug support */ if (!libusb_has_capability(LIBUSB_CAP_HAS_HOTPLUG)) { return LIBUSB_ERROR_NOT_SUPPORTED; } /* check for sane values */ if ((LIBUSB_HOTPLUG_MATCH_ANY != vendor_id && (~0xffff & vendor_id)) || (LIBUSB_HOTPLUG_MATCH_ANY != product_id && (~0xffff & product_id)) || (LIBUSB_HOTPLUG_MATCH_ANY != dev_class && (~0xff & dev_class)) || !cb_fn) { return LIBUSB_ERROR_INVALID_PARAM; } USBI_GET_CONTEXT(ctx); new_callback = (libusb_hotplug_callback *)calloc(1, sizeof (*new_callback)); if (!new_callback) { return LIBUSB_ERROR_NO_MEM; } new_callback->ctx = ctx; new_callback->vendor_id = vendor_id; new_callback->product_id = product_id; new_callback->dev_class = dev_class; new_callback->flags = flags; new_callback->events = events; new_callback->cb = cb_fn; new_callback->user_data = user_data; new_callback->needs_free = 0; usbi_mutex_lock(&ctx->hotplug_cbs_lock); /* protect the handle by the context hotplug lock. it doesn't matter if the same handle * is used for different contexts only that the handle is unique for this context */ new_callback->handle = handle_id++; list_add(&new_callback->list, &ctx->hotplug_cbs); usbi_mutex_unlock(&ctx->hotplug_cbs_lock); if (flags & LIBUSB_HOTPLUG_ENUMERATE) { int i, len; struct libusb_device **devs; len = (int) libusb_get_device_list(ctx, &devs); if (len < 0) { libusb_hotplug_deregister_callback(ctx, new_callback->handle); return len; } for (i = 0; i < len; i++) { usbi_hotplug_match_cb(ctx, devs[i], LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED, new_callback); } libusb_free_device_list(devs, 1); } if (handle) { *handle = new_callback->handle; } return LIBUSB_SUCCESS; }