X-Git-Url: http://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Fusb.c;h=60d828ad3d325b012d1607359688b81c376a355f;hb=3a1a6d6b04d7937f025adb557c9051fb21dffa92;hp=7fe1eff6e5b0bdba7608127ecbd065d39dcd6bc5;hpb=c1aae90038456a61d0f9313d34e6107c3440d3e7;p=libsigrok.git

diff --git a/src/usb.c b/src/usb.c
index 7fe1eff6..60d828ad 100644
--- a/src/usb.c
+++ b/src/usb.c
@@ -177,121 +177,60 @@ SR_PRIV int sr_usb_open(libusb_context *usb_ctx, struct sr_usb_dev_inst *usb)
 	return ret;
 }
 
-#ifdef _WIN32
-/* Thread used to run libusb_wait_for_event() and set a pollable event. */
-static gpointer usb_thread(gpointer data)
+SR_PRIV void sr_usb_close(struct sr_usb_dev_inst *usb)
 {
-	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);
-	}
-
-	return NULL;
+	libusb_close(usb->devhdl);
+	usb->devhdl = NULL;
+	sr_dbg("Closed USB device %d.%d.", usb->bus, usb->address);
 }
 
-/* Callback wrapper run when main g_poll() gets a USB event or timeout. */
-static int usb_callback(int fd, int revents, void *cb_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);
-
-	/* Were we triggered by an event from the wait thread, rather than by a
-	 * timeout? */
-	int triggered_by_event = (revents & G_IO_IN);
-
-	/* 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;
-}
-#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 **lupfd;
+	GPollFD *pollfds;
+	int i;
+	int num_fds = 0;
+	int ret;
+
 	if (ctx->usb_source_present) {
 		sr_err("A USB event source is already present.");
 		return SR_ERR;
 	}
-
-#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_cb = cb;
-	ctx->usb_cb_data = cb_data;
-	sr_session_source_add_pollfd(session, &ctx->usb_pollfd, timeout,
-			usb_callback, ctx);
-#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);
+	if (!lupfd || !lupfd[0]) {
+		free(lupfd);
+		sr_err("Failed to get libusb file descriptors.");
+		return SR_ERR;
+	}
+	while (lupfd[num_fds])
+		++num_fds;
+	pollfds = g_new(GPollFD, num_fds);
+
+	for (i = 0; i < num_fds; ++i) {
+#if defined(G_OS_WIN32) && (GLIB_SIZEOF_VOID_P == 4)
+		/* Avoid a warning on 32-bit Windows. */
+		pollfds[i].fd = (gintptr)lupfd[i]->fd;
+#else
+		pollfds[i].fd = lupfd[i]->fd;
 #endif
-	ctx->usb_source_present = TRUE;
+		pollfds[i].events = lupfd[i]->events;
+		pollfds[i].revents = 0;
+	}
+	free(lupfd);
+	ret = sr_session_source_add_internal(session, pollfds, num_fds,
+			timeout, cb, cb_data, (gintptr)ctx->libusb_ctx);
+	g_free(pollfds);
 
-	return SR_OK;
+	ctx->usb_source_present = (ret == SR_OK);
+
+	return ret;
 }
 
 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;
+	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)