X-Git-Url: http://sigrok.org/gitweb/?a=blobdiff_plain;f=src%2Fusb.c;h=be4eedcf37449899f8f9aa71f9f75e7e17d07a43;hb=358c4ed5b8d9c010cfe78ca44607a2b376593cee;hp=c3279d0ae1ef58640013483f9b6711deca9be15a;hpb=155b680da482cea2381becb73c51cfb838bff31e;p=libsigrok.git diff --git a/src/usb.c b/src/usb.c index c3279d0a..be4eedcf 100644 --- a/src/usb.c +++ b/src/usb.c @@ -20,9 +20,10 @@ */ #include +#include #include #include -#include "libsigrok.h" +#include #include "libsigrok-internal.h" /* SR_CONF_CONN takes one of these: */ @@ -176,96 +177,173 @@ SR_PRIV int sr_usb_open(libusb_context *usb_ctx, struct sr_usb_dev_inst *usb) 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); } +#ifdef G_OS_WIN32 +/* + * USB callback wrapper run when the main loop is idle. + */ static int usb_callback(int fd, int revents, void *cb_data) { - struct sr_context *ctx = cb_data; + int64_t start_time, stop_time, due, timeout; + struct timeval tv; + struct sr_context *ctx; int ret; - g_mutex_lock(&ctx->usb_mutex); - ret = ctx->usb_cb(fd, revents, ctx->usb_cb_data); + (void)fd; + (void)revents; + ctx = cb_data; - if (ctx->usb_thread_running) { - ResetEvent(ctx->usb_event); - g_mutex_unlock(&ctx->usb_mutex); - } + start_time = g_get_monotonic_time(); - return ret; + due = ctx->usb_due; + timeout = MAX(due - start_time, 0); + tv.tv_sec = timeout / G_USEC_PER_SEC; + tv.tv_usec = timeout % G_USEC_PER_SEC; + + sr_spew("libusb_handle_events enter, timeout %g ms", 1e-3 * timeout); + + ret = libusb_handle_events_timeout_completed(ctx->libusb_ctx, + (ctx->usb_timeout < 0) ? NULL : &tv, NULL); + if (ret != 0) { + /* Warn but still invoke the callback, to give the driver + * a chance to deal with the problem. + */ + sr_warn("Error handling libusb event (%s)", + libusb_error_name(ret)); + } + stop_time = g_get_monotonic_time(); + + sr_spew("libusb_handle_events leave, %g ms elapsed", + 1e-3 * (stop_time - start_time)); + + if (ctx->usb_timeout >= 0) + ctx->usb_due = stop_time + ctx->usb_timeout; + /* + * Run registered callback to execute any follow-up activity + * to libusb event handling. + */ + return ctx->usb_cb(-1, (stop_time < due) ? G_IO_IN : 0, + ctx->usb_cb_data); } #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) { + int ret; + if (ctx->usb_source_present) { sr_err("A USB event source is already present."); 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; +#ifdef G_OS_WIN32 + if (timeout >= 0) { + ctx->usb_timeout = INT64_C(1000) * timeout; + ctx->usb_due = g_get_monotonic_time() + ctx->usb_timeout; + } else { + ctx->usb_timeout = -1; + ctx->usb_due = INT64_MAX; + } ctx->usb_cb = cb; ctx->usb_cb_data = cb_data; - sr_session_source_add_pollfd(session, &ctx->usb_pollfd, timeout, - usb_callback, ctx); + /* + * TODO: Install an idle source which will fire permanently, and block + * in a wrapper callback until any libusb events have been processed. + * This will have to do for now, until we implement a proper way to + * deal with libusb events on Windows. + */ + ret = sr_session_source_add(session, -2, 0, 0, &usb_callback, ctx); #else const struct libusb_pollfd **lupfd; - unsigned int i; + GPollFD *pollfds; + int i; + int num_fds = 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); + 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) { + pollfds[i].fd = lupfd[i]->fd; + 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); #endif - ctx->usb_source_present = TRUE; + ctx->usb_source_present = (ret == SR_OK); - return SR_OK; + return ret; } SR_PRIV int usb_source_remove(struct sr_session *session, struct sr_context *ctx) { + int ret; + if (!ctx->usb_source_present) return SR_OK; -#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); +#ifdef G_OS_WIN32 + /* Remove our idle source */ + sr_session_source_remove(session, -2); #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); + ret = sr_session_source_remove_internal(session, + (gintptr)ctx->libusb_ctx); #endif ctx->usb_source_present = FALSE; + return ret; +} + +SR_PRIV int usb_get_port_path(libusb_device *dev, char *path, int path_len) +{ + 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(). + */ +#ifdef __FreeBSD__ + 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__ + libusb_close(devh); +#endif + +/* Workaround FreeBSD libusb_get_port_numbers() returning 0. */ +#ifdef __FreeBSD__ + if (n == 0) { + port_numbers[0] = libusb_get_device_address(dev); + n = 1; + } +#endif + if (n < 1) + return SR_ERR; + + len = snprintf(path, path_len, "usb/%d-%d", + libusb_get_bus_number(dev), port_numbers[0]); + + for (i = 1; i < n; i++) + len += snprintf(path+len, path_len-len, ".%d", port_numbers[i]); + return SR_OK; }