usb 2.17.0 → 3.0.0-alpha.2

package/libusb/libusb/os/events_posix.c

@@ -1,340 +0,0 @@
-/*
- * libusb event abstraction on POSIX platforms
- *
- * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include "libusbi.h"
-
-#include <errno.h>
-#include <fcntl.h>
-#ifdef HAVE_EVENTFD
-#include <sys/eventfd.h>
-#endif
-#ifdef HAVE_TIMERFD
-#include <sys/timerfd.h>
-#endif
-
-#ifdef __EMSCRIPTEN__
-/* On Emscripten `pipe` does not conform to the spec and does not block
- * until events are available, which makes it unusable for event system
- * and often results in deadlocks when `pipe` is in a loop like it is
- * in libusb.
- *
- * Therefore use a custom event system based on browser event emitters. */
-#include <emscripten.h>
-#include <emscripten/atomic.h>
-#include <emscripten/threading.h>
-
-EM_ASYNC_JS(void, em_libusb_wait_async, (const _Atomic int* ptr, int expected_value, int timeout), {
-	await Atomics.waitAsync(HEAP32, ptr >> 2, expected_value, timeout).value;
-});
-
-static void em_libusb_wait(const _Atomic int *ptr, int expected_value, int timeout)
-{
-	if (emscripten_is_main_runtime_thread()) {
-		em_libusb_wait_async(ptr, expected_value, timeout);
-	} else {
-		emscripten_atomic_wait_u32((int*)ptr, expected_value, 1000000LL * timeout);
-	}
-}
-#endif
-#include <unistd.h>
-
-#ifdef HAVE_EVENTFD
-#define EVENT_READ_FD(e)	((e)->eventfd)
-#define EVENT_WRITE_FD(e)	((e)->eventfd)
-#else
-#define EVENT_READ_FD(e)	((e)->pipefd[0])
-#define EVENT_WRITE_FD(e)	((e)->pipefd[1])
-#endif
-
-#ifdef HAVE_NFDS_T
-typedef nfds_t usbi_nfds_t;
-#else
-typedef unsigned int usbi_nfds_t;
-#endif
-
-int usbi_create_event(usbi_event_t *event)
-{
-#ifdef HAVE_EVENTFD
-	event->eventfd = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
-	if (event->eventfd == -1) {
-		usbi_err(NULL, "failed to create eventfd, errno=%d", errno);
-		return LIBUSB_ERROR_OTHER;
-	}
-
-	return 0;
-#else
-#if defined(HAVE_PIPE2)
-	int ret = pipe2(event->pipefd, O_CLOEXEC);
-#else
-	int ret = pipe(event->pipefd);
-#endif
-
-	if (ret != 0) {
-		usbi_err(NULL, "failed to create pipe, errno=%d", errno);
-		return LIBUSB_ERROR_OTHER;
-	}
-
-#if !defined(HAVE_PIPE2) && defined(FD_CLOEXEC)
-	ret = fcntl(event->pipefd[0], F_GETFD);
-	if (ret == -1) {
-		usbi_err(NULL, "failed to get pipe fd flags, errno=%d", errno);
-		goto err_close_pipe;
-	}
-	ret = fcntl(event->pipefd[0], F_SETFD, ret | FD_CLOEXEC);
-	if (ret == -1) {
-		usbi_err(NULL, "failed to set pipe fd flags, errno=%d", errno);
-		goto err_close_pipe;
-	}
-
-	ret = fcntl(event->pipefd[1], F_GETFD);
-	if (ret == -1) {
-		usbi_err(NULL, "failed to get pipe fd flags, errno=%d", errno);
-		goto err_close_pipe;
-	}
-	ret = fcntl(event->pipefd[1], F_SETFD, ret | FD_CLOEXEC);
-	if (ret == -1) {
-		usbi_err(NULL, "failed to set pipe fd flags, errno=%d", errno);
-		goto err_close_pipe;
-	}
-#endif
-
-	ret = fcntl(event->pipefd[1], F_GETFL);
-	if (ret == -1) {
-		usbi_err(NULL, "failed to get pipe fd status flags, errno=%d", errno);
-		goto err_close_pipe;
-	}
-	ret = fcntl(event->pipefd[1], F_SETFL, ret | O_NONBLOCK);
-	if (ret == -1) {
-		usbi_err(NULL, "failed to set pipe fd status flags, errno=%d", errno);
-		goto err_close_pipe;
-	}
-
-	return 0;
-
-err_close_pipe:
-	close(event->pipefd[1]);
-	close(event->pipefd[0]);
-	return LIBUSB_ERROR_OTHER;
-#endif
-}
-
-void usbi_destroy_event(usbi_event_t *event)
-{
-#ifdef HAVE_EVENTFD
-	if (close(event->eventfd) == -1)
-		usbi_warn(NULL, "failed to close eventfd, errno=%d", errno);
-#else
-	if (close(event->pipefd[1]) == -1)
-		usbi_warn(NULL, "failed to close pipe write end, errno=%d", errno);
-	if (close(event->pipefd[0]) == -1)
-		usbi_warn(NULL, "failed to close pipe read end, errno=%d", errno);
-#endif
-}
-
-void usbi_signal_event(usbi_event_t *event)
-{
-	uint64_t dummy = 1;
-	ssize_t r;
-
-	r = write(EVENT_WRITE_FD(event), &dummy, sizeof(dummy));
-	if (r != sizeof(dummy))
-		usbi_warn(NULL, "event write failed");
-#ifdef __EMSCRIPTEN__
-	event->has_event = 1;
-	emscripten_atomic_notify(&event->has_event, EMSCRIPTEN_NOTIFY_ALL_WAITERS);
-#endif
-}
-
-void usbi_clear_event(usbi_event_t *event)
-{
-	uint64_t dummy;
-	ssize_t r;
-
-	r = read(EVENT_READ_FD(event), &dummy, sizeof(dummy));
-	if (r != sizeof(dummy))
-		usbi_warn(NULL, "event read failed");
-#ifdef __EMSCRIPTEN__
-	event->has_event = 0;
-#endif
-}
-
-#ifdef HAVE_TIMERFD
-int usbi_create_timer(usbi_timer_t *timer)
-{
-	timer->timerfd = timerfd_create(CLOCK_MONOTONIC, TFD_NONBLOCK | TFD_CLOEXEC);
-	if (timer->timerfd == -1) {
-		usbi_warn(NULL, "failed to create timerfd, errno=%d", errno);
-		return LIBUSB_ERROR_OTHER;
-	}
-
-	return 0;
-}
-
-void usbi_destroy_timer(usbi_timer_t *timer)
-{
-	if (close(timer->timerfd) == -1)
-		usbi_warn(NULL, "failed to close timerfd, errno=%d", errno);
-}
-
-int usbi_arm_timer(usbi_timer_t *timer, const struct timespec *timeout)
-{
-	const struct itimerspec it = { { 0, 0 }, { timeout->tv_sec, timeout->tv_nsec } };
-
-	if (timerfd_settime(timer->timerfd, TFD_TIMER_ABSTIME, &it, NULL) == -1) {
-		usbi_warn(NULL, "failed to arm timerfd, errno=%d", errno);
-		return LIBUSB_ERROR_OTHER;
-	}
-
-	return 0;
-}
-
-int usbi_disarm_timer(usbi_timer_t *timer)
-{
-	const struct itimerspec it = { { 0, 0 }, { 0, 0 } };
-
-	if (timerfd_settime(timer->timerfd, 0, &it, NULL) == -1) {
-		usbi_warn(NULL, "failed to disarm timerfd, errno=%d", errno);
-		return LIBUSB_ERROR_OTHER;
-	}
-
-	return 0;
-}
-#endif
-
-int usbi_alloc_event_data(struct libusb_context *ctx)
-{
-	struct usbi_event_source *ievent_source;
-	struct pollfd *fds;
-	size_t i = 0;
-
-	if (ctx->event_data) {
-		free(ctx->event_data);
-		ctx->event_data = NULL;
-	}
-
-	ctx->event_data_cnt = 0;
-	for_each_event_source(ctx, ievent_source)
-		ctx->event_data_cnt++;
-
-	fds = calloc(ctx->event_data_cnt, sizeof(*fds));
-	if (!fds)
-		return LIBUSB_ERROR_NO_MEM;
-
-	for_each_event_source(ctx, ievent_source) {
-		fds[i].fd = ievent_source->data.os_handle;
-		fds[i].events = ievent_source->data.poll_events;
-		i++;
-	}
-
-	ctx->event_data = fds;
-	return 0;
-}
-
-int usbi_wait_for_events(struct libusb_context *ctx,
-	struct usbi_reported_events *reported_events, int timeout_ms)
-{
-	struct pollfd *fds = ctx->event_data;
-	usbi_nfds_t nfds = (usbi_nfds_t)ctx->event_data_cnt;
-	int internal_fds, num_ready;
-
-	usbi_dbg(ctx, "poll() %u fds with timeout in %dms", (unsigned int)nfds, timeout_ms);
-#ifdef __EMSCRIPTEN__
-	/* Emscripten's poll doesn't actually block, so we need to use an
-	 * out-of-band waiting signal. */
-	em_libusb_wait(&ctx->event.has_event, 0, timeout_ms);
-	/* Emscripten ignores timeout_ms, but set it to 0 for future-proofing
-	 * in case they ever implement real poll. */
-	timeout_ms = 0;
-#endif
-	num_ready = poll(fds, nfds, timeout_ms);
-	usbi_dbg(ctx, "poll() returned %d", num_ready);
-	if (num_ready == 0) {
-		if (usbi_using_timer(ctx))
-			goto done;
-		return LIBUSB_ERROR_TIMEOUT;
-	} else if (num_ready == -1) {
-		if (errno == EINTR)
-			return LIBUSB_ERROR_INTERRUPTED;
-		usbi_err(ctx, "poll() failed, errno=%d", errno);
-		return LIBUSB_ERROR_IO;
-	}
-
-	/* fds[0] is always the internal signalling event */
-	if (fds[0].revents) {
-		reported_events->event_triggered = 1;
-		num_ready--;
-	} else {
-		reported_events->event_triggered = 0;
-	}
-
-#ifdef HAVE_OS_TIMER
-	/* on timer configurations, fds[1] is the timer */
-	if (usbi_using_timer(ctx) && fds[1].revents) {
-		reported_events->timer_triggered = 1;
-		num_ready--;
-	} else {
-		reported_events->timer_triggered = 0;
-	}
-#endif
-
-	if (!num_ready)
-		goto done;
-
-	/* the backend will never need to attempt to handle events on the
-	 * library's internal file descriptors, so we determine how many are
-	 * in use internally for this context and skip these when passing any
-	 * remaining pollfds to the backend. */
-	internal_fds = usbi_using_timer(ctx) ? 2 : 1;
-	fds += internal_fds;
-	nfds -= internal_fds;
-
-	usbi_mutex_lock(&ctx->event_data_lock);
-	if (ctx->event_flags & USBI_EVENT_EVENT_SOURCES_MODIFIED) {
-		struct usbi_event_source *ievent_source;
-
-		for_each_removed_event_source(ctx, ievent_source) {
-			usbi_nfds_t n;
-
-			for (n = 0; n < nfds; n++) {
-				if (ievent_source->data.os_handle != fds[n].fd)
-					continue;
-				if (!fds[n].revents)
-					continue;
-				/* pollfd was removed between the creation of the fds array and
-				 * here. remove triggered revent as it is no longer relevant. */
-				usbi_dbg(ctx, "fd %d was removed, ignoring raised events", fds[n].fd);
-				fds[n].revents = 0;
-				num_ready--;
-				break;
-			}
-		}
-	}
-	usbi_mutex_unlock(&ctx->event_data_lock);
-
-	if (num_ready) {
-		assert(num_ready > 0);
-		reported_events->event_data = fds;
-		reported_events->event_data_count = (unsigned int)nfds;
-	}
-
-done:
-	reported_events->num_ready = num_ready;
-	return LIBUSB_SUCCESS;
-}

package/libusb/libusb/os/events_posix.h

@@ -1,62 +0,0 @@
-/*
- * libusb event abstraction on POSIX platforms
- *
- * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef LIBUSB_EVENTS_POSIX_H
-#define LIBUSB_EVENTS_POSIX_H
-
-#include <poll.h>
-
-typedef int usbi_os_handle_t;
-#define USBI_OS_HANDLE_FORMAT_STRING	"fd %d"
-
-#ifdef HAVE_EVENTFD
-typedef struct usbi_event {
-	int eventfd;
-} usbi_event_t;
-#define USBI_EVENT_OS_HANDLE(e)	((e)->eventfd)
-#define USBI_EVENT_POLL_EVENTS	POLLIN
-#define USBI_INVALID_EVENT	{ -1 }
-#else
-typedef struct usbi_event {
-	int pipefd[2];
-#ifdef __EMSCRIPTEN__
-	_Atomic int has_event;
-#endif
-} usbi_event_t;
-#define USBI_EVENT_OS_HANDLE(e)	((e)->pipefd[0])
-#define USBI_EVENT_POLL_EVENTS	POLLIN
-#define USBI_INVALID_EVENT	{ { -1, -1 } }
-#endif
-
-#ifdef HAVE_TIMERFD
-#define HAVE_OS_TIMER 1
-typedef struct usbi_timer {
-	int timerfd;
-} usbi_timer_t;
-#define USBI_TIMER_OS_HANDLE(t)	((t)->timerfd)
-#define USBI_TIMER_POLL_EVENTS	POLLIN
-
-static inline int usbi_timer_valid(usbi_timer_t *timer)
-{
-	return timer->timerfd >= 0;
-}
-#endif
-
-#endif

package/libusb/libusb/os/events_windows.c

@@ -1,214 +0,0 @@
-/*
- * libusb event abstraction on Microsoft Windows
- *
- * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#include <config.h>
-
-#include "libusbi.h"
-#include "windows_common.h"
-
-int usbi_create_event(usbi_event_t *event)
-{
-	event->hEvent = CreateEvent(NULL, TRUE, FALSE, NULL);
-	if (event->hEvent == NULL) {
-		usbi_err(NULL, "CreateEvent failed: %s", windows_error_str(0));
-		return LIBUSB_ERROR_OTHER;
-	}
-
-	return 0;
-}
-
-void usbi_destroy_event(usbi_event_t *event)
-{
-	if (!CloseHandle(event->hEvent))
-		usbi_warn(NULL, "CloseHandle failed: %s", windows_error_str(0));
-}
-
-void usbi_signal_event(usbi_event_t *event)
-{
-	if (!SetEvent(event->hEvent))
-		usbi_warn(NULL, "SetEvent failed: %s", windows_error_str(0));
-}
-
-void usbi_clear_event(usbi_event_t *event)
-{
-	if (!ResetEvent(event->hEvent))
-		usbi_warn(NULL, "ResetEvent failed: %s", windows_error_str(0));
-}
-
-#ifdef HAVE_OS_TIMER
-int usbi_create_timer(usbi_timer_t *timer)
-{
-	timer->hTimer = CreateWaitableTimer(NULL, TRUE, NULL);
-	if (timer->hTimer == NULL) {
-		usbi_warn(NULL, "CreateWaitableTimer failed: %s", windows_error_str(0));
-		return LIBUSB_ERROR_OTHER;
-	}
-
-	return 0;
-}
-
-void usbi_destroy_timer(usbi_timer_t *timer)
-{
-	if (!CloseHandle(timer->hTimer))
-		usbi_warn(NULL, "CloseHandle failed: %s", windows_error_str(0));
-}
-
-int usbi_arm_timer(usbi_timer_t *timer, const struct timespec *timeout)
-{
-	struct timespec systime, remaining;
-	FILETIME filetime;
-	LARGE_INTEGER dueTime;
-
-	/* Transfer timeouts are based on the monotonic clock and the waitable
-	 * timers on the system clock. This requires a conversion between the
-	 * two, so we calculate the remaining time relative to the monotonic
-	 * clock and calculate an absolute system time for the timer expiration.
-	 * Note that if the timeout has already passed, the remaining time will
-	 * be negative and thus an absolute system time in the past will be set.
-	 * This works just as intended because the timer becomes signalled
-	 * immediately. */
-	usbi_get_monotonic_time(&systime);
-
-	TIMESPEC_SUB(timeout, &systime, &remaining);
-
-	GetSystemTimeAsFileTime(&filetime);
-	dueTime.LowPart = filetime.dwLowDateTime;
-	dueTime.HighPart = filetime.dwHighDateTime;
-	dueTime.QuadPart += (remaining.tv_sec * 10000000LL) + (remaining.tv_nsec / 100LL);
-
-	if (!SetWaitableTimer(timer->hTimer, &dueTime, 0, NULL, NULL, FALSE)) {
-		usbi_warn(NULL, "SetWaitableTimer failed: %s", windows_error_str(0));
-		return LIBUSB_ERROR_OTHER;
-	}
-
-	return 0;
-}
-
-int usbi_disarm_timer(usbi_timer_t *timer)
-{
-	LARGE_INTEGER dueTime;
-
-	/* A manual-reset waitable timer will stay in the signalled state until
-	 * another call to SetWaitableTimer() is made. It is possible that the
-	 * timer has already expired by the time we come in to disarm it, so to
-	 * be entirely sure the timer is disarmed and not in the signalled state,
-	 * we will set it with an impossibly large expiration and immediately
-	 * cancel. */
-	dueTime.QuadPart = LLONG_MAX;
-	if (!SetWaitableTimer(timer->hTimer, &dueTime, 0, NULL, NULL, FALSE)) {
-		usbi_warn(NULL, "SetWaitableTimer failed: %s", windows_error_str(0));
-		return LIBUSB_ERROR_OTHER;
-	}
-
-	if (!CancelWaitableTimer(timer->hTimer)) {
-		usbi_warn(NULL, "SetWaitableTimer failed: %s", windows_error_str(0));
-		return LIBUSB_ERROR_OTHER;
-	}
-
-	return 0;
-}
-#endif
-
-int usbi_alloc_event_data(struct libusb_context *ctx)
-{
-	struct usbi_event_source *ievent_source;
-	HANDLE *handles;
-	size_t i = 0;
-
-	/* Event sources are only added during usbi_io_init(). We should not
-	 * be running this function again if the event data has already been
-	 * allocated. */
-	if (ctx->event_data) {
-		usbi_warn(ctx, "program assertion failed - event data already allocated");
-		return LIBUSB_ERROR_OTHER;
-	}
-
-	ctx->event_data_cnt = 0;
-	for_each_event_source(ctx, ievent_source)
-		ctx->event_data_cnt++;
-
-	/* We only expect up to two HANDLEs to wait on, one for the internal
-	 * signalling event and the other for the timer. */
-	if (ctx->event_data_cnt != 1 && ctx->event_data_cnt != 2) {
-		usbi_err(ctx, "program assertion failed - expected exactly 1 or 2 HANDLEs");
-		return LIBUSB_ERROR_OTHER;
-	}
-
-	handles = calloc(ctx->event_data_cnt, sizeof(HANDLE));
-	if (!handles)
-		return LIBUSB_ERROR_NO_MEM;
-
-	for_each_event_source(ctx, ievent_source) {
-		handles[i] = ievent_source->data.os_handle;
-		i++;
-	}
-
-	ctx->event_data = handles;
-	return 0;
-}
-
-int usbi_wait_for_events(struct libusb_context *ctx,
-	struct usbi_reported_events *reported_events, int timeout_ms)
-{
-	HANDLE *handles = ctx->event_data;
-	DWORD num_handles = (DWORD)ctx->event_data_cnt;
-	DWORD result;
-
-	usbi_dbg(ctx, "WaitForMultipleObjects() for %lu HANDLEs with timeout in %dms", ULONG_CAST(num_handles), timeout_ms);
-	result = WaitForMultipleObjects(num_handles, handles, FALSE, (DWORD)timeout_ms);
-	usbi_dbg(ctx, "WaitForMultipleObjects() returned %lu", ULONG_CAST(result));
-	if (result == WAIT_TIMEOUT) {
-		if (usbi_using_timer(ctx))
-			goto done;
-		return LIBUSB_ERROR_TIMEOUT;
-	} else if (result == WAIT_FAILED) {
-		usbi_err(ctx, "WaitForMultipleObjects() failed: %s", windows_error_str(0));
-		return LIBUSB_ERROR_IO;
-	}
-
-	result -= WAIT_OBJECT_0;
-
-	/* handles[0] is always the internal signalling event */
-	if (result == 0)
-		reported_events->event_triggered = 1;
-	else
-		reported_events->event_triggered = 0;
-
-#ifdef HAVE_OS_TIMER
-	/* on timer configurations, handles[1] is the timer */
-	if (usbi_using_timer(ctx)) {
-		/* The WaitForMultipleObjects() function reports the index of
-		 * the first object that became signalled. If the internal
-		 * signalling event was reported, we need to also check and
-		 * report whether the timer is in the signalled state. */
-		if (result == 1 || WaitForSingleObject(handles[1], 0) == WAIT_OBJECT_0)
-			reported_events->timer_triggered = 1;
-		else
-			reported_events->timer_triggered = 0;
-	} else {
-		reported_events->timer_triggered = 0;
-	}
-#endif
-
-done:
-	/* no events are ever reported to the backend */
-	reported_events->num_ready = 0;
-	return LIBUSB_SUCCESS;
-}

package/libusb/libusb/os/events_windows.h

@@ -1,46 +0,0 @@
-/*
- * libusb event abstraction on Microsoft Windows
- *
- * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#ifndef LIBUSB_EVENTS_WINDOWS_H
-#define LIBUSB_EVENTS_WINDOWS_H
-
-typedef HANDLE usbi_os_handle_t;
-#define USBI_OS_HANDLE_FORMAT_STRING	"HANDLE %p"
-
-typedef struct usbi_event {
-	HANDLE hEvent;
-} usbi_event_t;
-#define USBI_EVENT_OS_HANDLE(e)	((e)->hEvent)
-#define USBI_EVENT_POLL_EVENTS	0
-#define USBI_INVALID_EVENT	{ INVALID_HANDLE_VALUE }
-
-#define HAVE_OS_TIMER 1
-typedef struct usbi_timer {
-	HANDLE hTimer;
-} usbi_timer_t;
-#define USBI_TIMER_OS_HANDLE(t)	((t)->hTimer)
-#define USBI_TIMER_POLL_EVENTS	0
-
-static inline int usbi_timer_valid(usbi_timer_t *timer)
-{
-	return timer->hTimer != NULL;
-}
-
-#endif