*
* 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 <libusb.h>
-#include "libsigrok.h"
+#include <libsigrok/libsigrok.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.
+ * @internal
+ */
+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;
}
return ret;
}
-#ifdef _WIN32
-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) {
- g_mutex_lock(&ctx->usb_mutex);
- libusb_wait_for_event(ctx->libusb_ctx, NULL);
- SetEvent(ctx->usb_event);
- g_mutex_unlock(&ctx->usb_mutex);
- g_thread_yield();
- }
-
- return NULL;
+ libusb_close(usb->devhdl);
+ usb->devhdl = NULL;
+ sr_dbg("Closed USB device %d.%d.", usb->bus, usb->address);
}
-static int usb_callback(int fd, int revents, void *cb_data)
+SR_PRIV int usb_source_add(struct sr_session *session, struct sr_context *ctx,
+ int timeout, sr_receive_data_callback cb, void *cb_data)
{
- struct sr_context *ctx = cb_data;
+ GSource *source;
int ret;
- g_mutex_lock(&ctx->usb_mutex);
- ret = ctx->usb_cb(fd, revents, ctx->usb_cb_data);
+ source = usb_source_new(session, ctx->libusb_ctx, timeout);
+ if (!source)
+ return SR_ERR;
- if (ctx->usb_thread_running) {
- ResetEvent(ctx->usb_event);
- g_mutex_unlock(&ctx->usb_mutex);
- }
+ g_source_set_callback(source, (GSourceFunc)cb, cb_data, NULL);
+
+ ret = sr_session_source_add_internal(session, ctx->libusb_ctx, source);
+ g_source_unref(source);
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)
+SR_PRIV int usb_source_remove(struct sr_session *session, struct sr_context *ctx)
+{
+ 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)
{
- if (ctx->usb_source_present) {
- sr_err("A USB event source is already present.");
+ uint8_t port_numbers[8];
+ int i, n, 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.
+ */
+#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));
+#if defined(__FreeBSD__) || defined(__APPLE__)
+ libusb_close(devh);
+#endif
+
+/* 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;
}
+#endif
+ if (n < 1)
+ return SR_ERR;
-#ifdef _WIN32
- ctx->usb_event = CreateEvent(NULL, TRUE, FALSE, NULL);
- g_mutex_init(&ctx->usb_mutex);
- ctx->usb_thread_running = TRUE;
- ctx->usb_thread = g_thread_new("usb", usb_thread, ctx);
- ctx->usb_pollfd.fd = ctx->usb_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;
+ len = snprintf(path, path_len, "usb/%d-%d",
+ libusb_get_bus_number(dev), port_numbers[0]);
- 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);
-#endif
- ctx->usb_source_present = TRUE;
+ for (i = 1; i < n; i++)
+ len += snprintf(path+len, path_len-len, ".%d", port_numbers[i]);
return SR_OK;
}
-SR_PRIV int usb_source_remove(struct sr_session *session, struct sr_context *ctx)
+/**
+ * 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)
{
- if (!ctx->usb_source_present)
- return SR_OK;
+ struct libusb_device_descriptor des;
+ struct libusb_device_handle *hdl;
+ gboolean ret;
+ unsigned char strdesc[64];
-#ifdef _WIN32
- ctx->usb_thread_running = FALSE;
- g_mutex_unlock(&ctx->usb_mutex);
- libusb_unlock_events(ctx->libusb_ctx);
- g_thread_join(ctx->usb_thread);
- g_mutex_clear(&ctx->usb_mutex);
- sr_session_source_remove_pollfd(session, &ctx->usb_pollfd);
- CloseHandle(ctx->usb_event);
-#else
- const struct libusb_pollfd **lupfd;
- unsigned int i;
+ hdl = NULL;
+ ret = FALSE;
+ while (!ret) {
+ /* Assume the FW has not been loaded, unless proven wrong. */
+ libusb_get_device_descriptor(dev, &des);
- 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;
+ if (libusb_open(dev, &hdl) != 0)
+ break;
- return SR_OK;
-}
+ if (libusb_get_string_descriptor_ascii(hdl,
+ des.iManufacturer, strdesc, sizeof(strdesc)) < 0)
+ break;
+ if (strcmp((const char *)strdesc, manufacturer))
+ break;
-SR_PRIV int usb_get_port_path(libusb_device *dev, const char *path, int path_len)
-{
- gchar s[64];
- gchar tmp_s[8];
- uint8_t port_numbers[32];
- int i;
-
- memset(port_numbers, 0, sizeof(port_numbers));
- libusb_get_port_numbers(dev, port_numbers, sizeof(port_numbers));
-
- g_snprintf((gchar*)&s, sizeof(s), "usb/%d-%d",
- libusb_get_bus_number(dev), port_numbers[0]);
-
- i = 1;
- while (port_numbers[i]) {
- g_snprintf(tmp_s, sizeof(tmp_s), ".%d", port_numbers[i]);
- g_strlcat((gchar*)&s, tmp_s, sizeof(s));
- i++;
- }
+ if (libusb_get_string_descriptor_ascii(hdl,
+ des.iProduct, strdesc, sizeof(strdesc)) < 0)
+ break;
+ if (strcmp((const char *)strdesc, product))
+ break;
- g_strlcpy((gchar*)path, s, path_len);
+ ret = TRUE;
+ }
+ if (hdl)
+ libusb_close(hdl);
- return SR_OK;
+ return ret;
}