*
* Copyright (C) 2012 Uwe Hermann <uwe@hermann-uwe.de>
* Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
+ * Copyright (C) 2015 Daniel Elstner <daniel.kitta@gmail.com>
*
- * This program is free software; you can redistribute it and/or modify
+ * This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
- * the Free Software Foundation; either version 2 of the License, or
+ * the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
+#include <config.h>
#include <stdlib.h>
#include <memory.h>
#include <glib.h>
#include "libsigrok-internal.h"
/* SR_CONF_CONN takes one of these: */
-#define CONN_USB_VIDPID "^([0-9a-z]{4})\\.([0-9a-z]{4})$"
+#define CONN_USB_VIDPID "^([0-9a-fA-F]{4})\\.([0-9a-fA-F]{4})$"
#define CONN_USB_BUSADDR "^(\\d+)\\.(\\d+)$"
#define LOG_PREFIX "usb"
+#if !HAVE_LIBUSB_OS_HANDLE
+typedef int libusb_os_handle;
+#endif
+
+/** Custom GLib event source for libusb I/O.
+ */
+struct usb_source {
+ GSource base;
+
+ int64_t timeout_us;
+ int64_t due_us;
+
+ /* Needed to keep track of installed sources */
+ struct sr_session *session;
+
+ struct libusb_context *usb_ctx;
+ GPtrArray *pollfds;
+};
+
+/** USB event source prepare() method.
+ */
+static gboolean usb_source_prepare(GSource *source, int *timeout)
+{
+ int64_t now_us, usb_due_us;
+ struct usb_source *usource;
+ struct timeval usb_timeout;
+ int remaining_ms;
+ int ret;
+
+ usource = (struct usb_source *)source;
+
+ ret = libusb_get_next_timeout(usource->usb_ctx, &usb_timeout);
+ if (G_UNLIKELY(ret < 0)) {
+ sr_err("Failed to get libusb timeout: %s",
+ libusb_error_name(ret));
+ }
+ now_us = g_source_get_time(source);
+
+ if (usource->due_us == 0) {
+ /* First-time initialization of the expiration time */
+ usource->due_us = now_us + usource->timeout_us;
+ }
+ if (ret == 1) {
+ usb_due_us = (int64_t)usb_timeout.tv_sec * G_USEC_PER_SEC
+ + usb_timeout.tv_usec + now_us;
+ if (usb_due_us < usource->due_us)
+ usource->due_us = usb_due_us;
+ }
+ if (usource->due_us != INT64_MAX)
+ remaining_ms = (MAX(0, usource->due_us - now_us) + 999) / 1000;
+ else
+ remaining_ms = -1;
+
+ *timeout = remaining_ms;
+
+ return (remaining_ms == 0);
+}
+
+/** USB event source check() method.
+ */
+static gboolean usb_source_check(GSource *source)
+{
+ struct usb_source *usource;
+ GPollFD *pollfd;
+ unsigned int revents;
+ unsigned int i;
+
+ usource = (struct usb_source *)source;
+ revents = 0;
+
+ for (i = 0; i < usource->pollfds->len; i++) {
+ pollfd = g_ptr_array_index(usource->pollfds, i);
+ revents |= pollfd->revents;
+ }
+ return (revents != 0 || (usource->due_us != INT64_MAX
+ && usource->due_us <= g_source_get_time(source)));
+}
+
+/** USB event source dispatch() method.
+ */
+static gboolean usb_source_dispatch(GSource *source,
+ GSourceFunc callback, void *user_data)
+{
+ struct usb_source *usource;
+ GPollFD *pollfd;
+ unsigned int revents;
+ unsigned int i;
+ gboolean keep;
+
+ usource = (struct usb_source *)source;
+ revents = 0;
+ /*
+ * This is somewhat arbitrary, but drivers use revents to distinguish
+ * actual I/O from timeouts. When we remove the user timeout from the
+ * driver API, this will no longer be needed.
+ */
+ for (i = 0; i < usource->pollfds->len; i++) {
+ pollfd = g_ptr_array_index(usource->pollfds, i);
+ revents |= pollfd->revents;
+ }
+
+ if (!callback) {
+ sr_err("Callback not set, cannot dispatch event.");
+ return G_SOURCE_REMOVE;
+ }
+ keep = (*SR_RECEIVE_DATA_CALLBACK(callback))(-1, revents, user_data);
+
+ if (G_LIKELY(keep) && G_LIKELY(!g_source_is_destroyed(source))) {
+ if (usource->timeout_us >= 0)
+ usource->due_us = g_source_get_time(source)
+ + usource->timeout_us;
+ else
+ usource->due_us = INT64_MAX;
+ }
+ return keep;
+}
+
+/** USB event source finalize() method.
+ */
+static void usb_source_finalize(GSource *source)
+{
+ struct usb_source *usource;
+
+ usource = (struct usb_source *)source;
+
+ sr_spew("%s", __func__);
+
+ libusb_set_pollfd_notifiers(usource->usb_ctx, NULL, NULL, NULL);
+
+ g_ptr_array_unref(usource->pollfds);
+ usource->pollfds = NULL;
+
+ sr_session_source_destroyed(usource->session,
+ usource->usb_ctx, source);
+}
+
+/** Callback invoked when a new libusb FD should be added to the poll set.
+ */
+static LIBUSB_CALL void usb_pollfd_added(libusb_os_handle fd,
+ short events, void *user_data)
+{
+ struct usb_source *usource;
+ GPollFD *pollfd;
+
+ usource = user_data;
+
+ if (G_UNLIKELY(g_source_is_destroyed(&usource->base)))
+ return;
+
+ pollfd = g_slice_new(GPollFD);
+#ifdef _WIN32
+ events = G_IO_IN;
+#endif
+ pollfd->fd = (gintptr)fd;
+ pollfd->events = events;
+ pollfd->revents = 0;
+
+ g_ptr_array_add(usource->pollfds, pollfd);
+ g_source_add_poll(&usource->base, pollfd);
+}
+
+/** Callback invoked when a libusb FD should be removed from the poll set.
+ */
+static LIBUSB_CALL void usb_pollfd_removed(libusb_os_handle fd, void *user_data)
+{
+ struct usb_source *usource;
+ GPollFD *pollfd;
+ unsigned int i;
+
+ usource = user_data;
+
+ if (G_UNLIKELY(g_source_is_destroyed(&usource->base)))
+ return;
+
+ /* It's likely that the removed poll FD is at the end.
+ */
+ for (i = usource->pollfds->len; G_LIKELY(i > 0); i--) {
+ pollfd = g_ptr_array_index(usource->pollfds, i - 1);
+
+ if ((libusb_os_handle)pollfd->fd == fd) {
+ g_source_remove_poll(&usource->base, pollfd);
+ g_ptr_array_remove_index_fast(usource->pollfds, i - 1);
+ return;
+ }
+ }
+ sr_err("FD to be removed (%" G_GINTPTR_FORMAT
+ ") not found in event source poll set.", (gintptr)fd);
+}
+
+/** Destroy notify callback for FDs maintained by the USB event source.
+ */
+static void usb_source_free_pollfd(void *data)
+{
+ g_slice_free(GPollFD, data);
+}
+
+/** Create an event source for libusb I/O.
+ *
+ * TODO: The combination of the USB I/O source with a user timeout is
+ * conceptually broken. The user timeout supplied here is completely
+ * unrelated to I/O -- the actual I/O timeout is set when submitting
+ * a USB transfer.
+ * The sigrok drivers generally use the timeout to poll device state.
+ * Usually, this polling can be sensibly done only when there is no
+ * active USB transfer -- i.e. it's actually mutually exclusive with
+ * waiting for transfer completion.
+ * Thus, the user timeout should be removed from the USB event source
+ * API at some point. Instead, drivers should install separate timer
+ * event sources for their polling needs.
+ *
+ * @param session The session the event source belongs to.
+ * @param usb_ctx The libusb context for which to handle events.
+ * @param timeout_ms The timeout interval in ms, or -1 to wait indefinitely.
+ * @return A new event source object, or NULL on failure.
+ */
+static GSource *usb_source_new(struct sr_session *session,
+ struct libusb_context *usb_ctx, int timeout_ms)
+{
+ static GSourceFuncs usb_source_funcs = {
+ .prepare = &usb_source_prepare,
+ .check = &usb_source_check,
+ .dispatch = &usb_source_dispatch,
+ .finalize = &usb_source_finalize
+ };
+ GSource *source;
+ struct usb_source *usource;
+ const struct libusb_pollfd **upollfds, **upfd;
+
+ upollfds = libusb_get_pollfds(usb_ctx);
+ if (!upollfds) {
+ sr_err("Failed to get libusb file descriptors.");
+ return NULL;
+ }
+ source = g_source_new(&usb_source_funcs, sizeof(struct usb_source));
+ usource = (struct usb_source *)source;
+
+ g_source_set_name(source, "usb");
+
+ if (timeout_ms >= 0) {
+ usource->timeout_us = 1000 * (int64_t)timeout_ms;
+ usource->due_us = 0;
+ } else {
+ usource->timeout_us = -1;
+ usource->due_us = INT64_MAX;
+ }
+ usource->session = session;
+ usource->usb_ctx = usb_ctx;
+ usource->pollfds = g_ptr_array_new_full(8, &usb_source_free_pollfd);
+
+ for (upfd = upollfds; *upfd != NULL; upfd++)
+ usb_pollfd_added((*upfd)->fd, (*upfd)->events, usource);
+
+#if (LIBUSB_API_VERSION >= 0x01000104)
+ libusb_free_pollfds(upollfds);
+#else
+ free(upollfds);
+#endif
+ libusb_set_pollfd_notifiers(usb_ctx,
+ &usb_pollfd_added, &usb_pollfd_removed, usource);
+
+ return source;
+}
+
/**
* Find USB devices according to a connection string.
*
if ((mstr = g_match_info_fetch(match, 2)))
pid = strtoul(mstr, NULL, 16);
g_free(mstr);
- sr_dbg("Trying to find USB device with VID:PID = %04x:%04x.",
- vid, pid);
+ /* Trying to find USB device via VID:PID. */
} else {
g_match_info_unref(match);
g_regex_unref(reg);
if ((mstr = g_match_info_fetch(match, 2)))
addr = strtoul(mstr, NULL, 10);
g_free(mstr);
- sr_dbg("Trying to find USB device with bus.address = "
- "%d.%d.", bus, addr);
+ /* Trying to find USB device via bus.address. */
}
}
g_match_info_unref(match);
return NULL;
}
- if (bus > 64) {
+ if (bus > 255) {
sr_err("Invalid bus specified: %d.", bus);
return NULL;
}
sr_dbg("Found USB device (VID:PID = %04x:%04x, bus.address = "
"%d.%d).", des.idVendor, des.idProduct, b, a);
- usb = sr_usb_dev_inst_new(libusb_get_bus_number(devlist[i]),
- libusb_get_device_address(devlist[i]), NULL);
+ usb = sr_usb_dev_inst_new(b, a, NULL);
devices = g_slist_append(devices, usb);
}
libusb_free_device_list(devlist, 1);
- sr_dbg("Found %d device(s).", g_slist_length(devices));
-
+ /* No log message for #devices found (caller will log that). */
+
return devices;
}
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)
-{
- 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;
-}
-
-/* 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)
{
- 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_pollfd.revents = 0;
- ctx->usb_cb = cb;
- ctx->usb_cb_data = cb_data;
- sr_session_source_add_internal(session, &ctx->usb_pollfd, timeout,
- usb_callback, ctx, (gintptr)&ctx->usb_pollfd, TRUE);
-#else
- const struct libusb_pollfd **lupfd;
- unsigned int i;
+ GSource *source;
+ int ret;
- lupfd = libusb_get_pollfds(ctx->libusb_ctx);
- for (i = 0; lupfd[i]; i++) {
- GPollFD p;
+ source = usb_source_new(session, ctx->libusb_ctx, timeout);
+ if (!source)
+ return SR_ERR;
- p.fd = lupfd[i]->fd;
- p.events = lupfd[i]->events;
- p.revents = 0;
+ g_source_set_callback(source, G_SOURCE_FUNC(cb), cb_data, NULL);
- sr_session_source_add_internal(session, &p, timeout,
- cb, cb_data, p.fd, TRUE);
- }
- free(lupfd);
-#endif
- ctx->usb_source_present = TRUE;
+ ret = sr_session_source_add_internal(session, ctx->libusb_ctx, source);
+ g_source_unref(source);
- return 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, ctx->libusb_ctx);
}
SR_PRIV int usb_get_port_path(libusb_device *dev, char *path, int path_len)
/*
* FreeBSD requires that devices prior to calling libusb_get_port_numbers()
* have been opened with libusb_open().
+ * This apparently also applies to some Mac OS X versions.
*/
-#ifdef __FreeBSD__
+#if defined(__FreeBSD__) || defined(__APPLE__)
struct libusb_device_handle *devh;
if (libusb_open(dev, &devh) != 0)
return SR_ERR;
#endif
n = libusb_get_port_numbers(dev, port_numbers, sizeof(port_numbers));
-#ifdef __FreeBSD__
+#if defined(__FreeBSD__) || defined(__APPLE__)
libusb_close(devh);
#endif
-/* Workaround FreeBSD libusb_get_port_numbers() returning 0. */
-#ifdef __FreeBSD__
+/* Workaround FreeBSD / Mac OS X libusb_get_port_numbers() returning 0. */
+#if defined(__FreeBSD__) || defined(__APPLE__)
if (n == 0) {
port_numbers[0] = libusb_get_device_address(dev);
n = 1;
return SR_OK;
}
+
+/**
+ * Check the USB configuration to determine if this device has a given
+ * manufacturer and product string.
+ *
+ * @return TRUE if the device's configuration profile strings
+ * configuration, FALSE otherwise.
+ */
+SR_PRIV gboolean usb_match_manuf_prod(libusb_device *dev,
+ const char *manufacturer, const char *product)
+{
+ struct libusb_device_descriptor des;
+ struct libusb_device_handle *hdl;
+ gboolean ret;
+ unsigned char strdesc[64];
+
+ hdl = NULL;
+ ret = FALSE;
+ while (!ret) {
+ /* Assume the FW has not been loaded, unless proven wrong. */
+ libusb_get_device_descriptor(dev, &des);
+
+ if (libusb_open(dev, &hdl) != 0)
+ break;
+
+ if (libusb_get_string_descriptor_ascii(hdl,
+ des.iManufacturer, strdesc, sizeof(strdesc)) < 0)
+ break;
+ if (strcmp((const char *)strdesc, manufacturer))
+ break;
+
+ if (libusb_get_string_descriptor_ascii(hdl,
+ des.iProduct, strdesc, sizeof(strdesc)) < 0)
+ break;
+ if (strcmp((const char *)strdesc, product))
+ break;
+
+ ret = TRUE;
+ }
+ if (hdl)
+ libusb_close(hdl);
+
+ return ret;
+}
projects / libsigrok.git / blobdiff