X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Fusb.c;h=1b22de41acdb84bca86725da2f7fbdae4dbbe4b7;hb=c1adbb1e235629d62be02e8b579478ed1594da44;hp=5038441cc97c3db869ff5969097baaa6e36e439a;hpb=89efe06460024c2a33e57178f5812bf23c2f9888;p=libsigrok.git diff --git a/src/usb.c b/src/usb.c index 5038441c..1b22de41 100644 --- a/src/usb.c +++ b/src/usb.c @@ -32,6 +32,10 @@ #define LOG_PREFIX "usb" +#if !HAVE_LIBUSB_OS_HANDLE +typedef int libusb_os_handle; +#endif + /** * Find USB devices according to a connection string. * @@ -184,122 +188,86 @@ SR_PRIV void sr_usb_close(struct sr_usb_dev_inst *usb) sr_dbg("Closed USB device %d.%d.", usb->bus, usb->address); } -#ifdef _WIN32 -/* Thread used to run libusb_wait_for_event() and set a pollable event. */ -static gpointer usb_thread(gpointer data) +static LIBUSB_CALL void usb_pollfd_added(libusb_os_handle fd, + short events, void *user_data) { - struct sr_context *ctx = data; - - while (ctx->usb_thread_running) { - /* Acquire event waiters lock, needed for libusb_wait_for_event(). */ - libusb_lock_event_waiters(ctx->libusb_ctx); - /* Wait for any libusb event. The main thread can interrupt this wait - * by calling libusb_unlock_events(). */ - libusb_wait_for_event(ctx->libusb_ctx, NULL); - /* Release event waiters lock. */ - libusb_unlock_event_waiters(ctx->libusb_ctx); - /* Set event that the main loop will be polling on. */ - SetEvent(ctx->usb_wait_complete_event); - /* Wait for the main thread to signal us to run again. */ - WaitForSingleObject(ctx->usb_wait_request_event, INFINITE); - ResetEvent(ctx->usb_wait_request_event); - } + struct sr_session *session; + gintptr tag; - return NULL; + session = user_data; + tag = (gintptr)session->ctx->libusb_ctx; +#ifdef G_OS_WIN32 + events = G_IO_IN; +#endif + sr_session_source_poll_add(session, tag, (gintptr)fd, events); } -/* Callback wrapper run when main g_poll() gets a USB event or timeout. */ -static int usb_callback(int fd, int revents, void *cb_data) +static LIBUSB_CALL void usb_pollfd_removed(libusb_os_handle fd, void *user_data) { - struct sr_context *ctx = cb_data; - int ret; - - /* Run registered callback to handle libusb events. */ - ret = ctx->usb_cb(fd, revents, ctx->usb_cb_data); + struct sr_session *session; + gintptr tag; - /* Were we triggered by an event from the wait thread, rather than by a - * timeout? */ - int triggered_by_event = (revents & G_IO_IN); + session = user_data; + tag = (gintptr)session->ctx->libusb_ctx; - /* If so, and if the USB event source has not been removed from the - * session, reset the event that woke us and tell the wait thread to start - * waiting for events again. */ - if (triggered_by_event && ctx->usb_thread_running) { - ResetEvent(ctx->usb_wait_complete_event); - SetEvent(ctx->usb_wait_request_event); - } - - return ret; + sr_session_source_poll_remove(session, tag, (gintptr)fd); } -#endif SR_PRIV int usb_source_add(struct sr_session *session, struct sr_context *ctx, int timeout, sr_receive_data_callback cb, void *cb_data) { + const struct libusb_pollfd **pollfds; + gintptr tag; + int i; + int ret; + int events; + if (ctx->usb_source_present) { sr_err("A USB event source is already present."); return SR_ERR; } + pollfds = libusb_get_pollfds(ctx->libusb_ctx); + if (!pollfds) { + sr_err("Failed to get libusb file descriptors."); + return SR_ERR; + } + tag = (gintptr)ctx->libusb_ctx; + ret = sr_session_source_add_internal(session, + timeout, cb, cb_data, tag); + + ctx->usb_source_present = (ret == SR_OK); -#ifdef _WIN32 - /* Create events used to signal between main and USB wait threads. */ - ctx->usb_wait_request_event = CreateEvent(NULL, TRUE, FALSE, NULL); - ctx->usb_wait_complete_event = CreateEvent(NULL, TRUE, FALSE, NULL); - /* Start USB wait thread. */ - ctx->usb_thread_running = TRUE; - ctx->usb_thread = g_thread_new("usb", usb_thread, ctx); - /* Add event, set by USB wait thread, to session poll set. */ - ctx->usb_pollfd.fd = ctx->usb_wait_complete_event; - ctx->usb_pollfd.events = G_IO_IN; - ctx->usb_pollfd.revents = 0; - ctx->usb_cb = cb; - ctx->usb_cb_data = cb_data; - sr_session_source_add_pollfd(session, &ctx->usb_pollfd, timeout, - usb_callback, ctx); + for (i = 0; ret == SR_OK && pollfds[i]; ++i) { +#ifdef G_OS_WIN32 + events = G_IO_IN; +#else + events = pollfds[i]->events; +#endif + ret = sr_session_source_poll_add(session, tag, + (gintptr)pollfds[i]->fd, events); + } +#if (LIBUSB_API_VERSION >= 0x01000104) + libusb_free_pollfds(pollfds); #else - const struct libusb_pollfd **lupfd; - unsigned int i; - - lupfd = libusb_get_pollfds(ctx->libusb_ctx); - for (i = 0; lupfd[i]; i++) - sr_session_source_add(session, lupfd[i]->fd, lupfd[i]->events, - timeout, cb, cb_data); - free(lupfd); + free(pollfds); #endif - ctx->usb_source_present = TRUE; + if (ret != SR_OK) + return ret; + + libusb_set_pollfd_notifiers(ctx->libusb_ctx, + &usb_pollfd_added, &usb_pollfd_removed, session); return SR_OK; } SR_PRIV int usb_source_remove(struct sr_session *session, struct sr_context *ctx) { - if (!ctx->usb_source_present) - return SR_OK; - -#ifdef _WIN32 - /* Signal the USB wait thread to stop, then unblock it so it does. */ - ctx->usb_thread_running = FALSE; - SetEvent(ctx->usb_wait_request_event); - libusb_unlock_events(ctx->libusb_ctx); - /* Wait for USB wait thread to terminate. */ - g_thread_join(ctx->usb_thread); - /* Remove USB event from session poll set. */ - sr_session_source_remove_pollfd(session, &ctx->usb_pollfd); - /* Close event handles that were used between threads. */ - CloseHandle(ctx->usb_wait_request_event); - CloseHandle(ctx->usb_wait_complete_event); -#else - const struct libusb_pollfd **lupfd; - unsigned int i; - - lupfd = libusb_get_pollfds(ctx->libusb_ctx); - for (i = 0; lupfd[i]; i++) - sr_session_source_remove(session, lupfd[i]->fd); - free(lupfd); -#endif ctx->usb_source_present = FALSE; - return SR_OK; + libusb_set_pollfd_notifiers(ctx->libusb_ctx, NULL, NULL, NULL); + + return sr_session_source_remove_internal(session, + (gintptr)ctx->libusb_ctx); } SR_PRIV int usb_get_port_path(libusb_device *dev, char *path, int path_len)