usb 2.1.2 → 2.3.0

package/libusb/libusb/os/netbsd_usb.c

@@ -36,8 +36,7 @@ struct device_priv {
 	char devnode[16];
 	int fd;
 
-	unsigned char *cdesc;			/* active config descriptor */
-	usb_device_descriptor_t ddesc;		/* usb device descriptor */
+	usb_config_descriptor_t *cdesc;		/* active config descriptor */
 };
 
 struct handle_priv {
@@ -52,30 +51,25 @@ static int netbsd_get_device_list(struct libusb_context *,
 static int netbsd_open(struct libusb_device_handle *);
 static void netbsd_close(struct libusb_device_handle *);
 
-static int netbsd_get_device_descriptor(struct libusb_device *, unsigned char *,
-    int *);
 static int netbsd_get_active_config_descriptor(struct libusb_device *,
-    unsigned char *, size_t, int *);
+    void *, size_t);
 static int netbsd_get_config_descriptor(struct libusb_device *, uint8_t,
-    unsigned char *, size_t, int *);
+    void *, size_t);
 
-static int netbsd_get_configuration(struct libusb_device_handle *, int *);
+static int netbsd_get_configuration(struct libusb_device_handle *, uint8_t *);
 static int netbsd_set_configuration(struct libusb_device_handle *, int);
 
-static int netbsd_claim_interface(struct libusb_device_handle *, int);
-static int netbsd_release_interface(struct libusb_device_handle *, int);
+static int netbsd_claim_interface(struct libusb_device_handle *, uint8_t);
+static int netbsd_release_interface(struct libusb_device_handle *, uint8_t);
 
-static int netbsd_set_interface_altsetting(struct libusb_device_handle *, int,
-    int);
+static int netbsd_set_interface_altsetting(struct libusb_device_handle *,
+    uint8_t, uint8_t);
 static int netbsd_clear_halt(struct libusb_device_handle *, unsigned char);
-static int netbsd_reset_device(struct libusb_device_handle *);
 static void netbsd_destroy_device(struct libusb_device *);
 
 static int netbsd_submit_transfer(struct usbi_transfer *);
 static int netbsd_cancel_transfer(struct usbi_transfer *);
-static void netbsd_clear_transfer_priv(struct usbi_transfer *);
 static int netbsd_handle_transfer_completion(struct usbi_transfer *);
-static int netbsd_clock_gettime(int, struct timespec *);
 
 /*
  * Private functions
@@ -87,55 +81,33 @@ static int _sync_gen_transfer(struct usbi_transfer *);
 static int _access_endpoint(struct libusb_transfer *);
 
 const struct usbi_os_backend usbi_backend = {
-	"Synchronous NetBSD backend",
-	0,
-	NULL,				/* init() */
-	NULL,				/* exit() */
-	NULL,				/* set_option() */
-	netbsd_get_device_list,
-	NULL,				/* hotplug_poll */
-	netbsd_open,
-	netbsd_close,
-
-	netbsd_get_device_descriptor,
-	netbsd_get_active_config_descriptor,
-	netbsd_get_config_descriptor,
-	NULL,				/* get_config_descriptor_by_value() */
-
-	netbsd_get_configuration,
-	netbsd_set_configuration,
-
-	netbsd_claim_interface,
-	netbsd_release_interface,
-
-	netbsd_set_interface_altsetting,
-	netbsd_clear_halt,
-	netbsd_reset_device,
-
-	NULL,				/* alloc_streams */
-	NULL,				/* free_streams */
-
-	NULL,				/* dev_mem_alloc() */
-	NULL,				/* dev_mem_free() */
-
-	NULL,				/* kernel_driver_active() */
-	NULL,				/* detach_kernel_driver() */
-	NULL,				/* attach_kernel_driver() */
-
-	netbsd_destroy_device,
-
-	netbsd_submit_transfer,
-	netbsd_cancel_transfer,
-	netbsd_clear_transfer_priv,
-
-	NULL,				/* handle_events() */
-	netbsd_handle_transfer_completion,
-
-	netbsd_clock_gettime,
-	0,				/* context_priv_size */
-	sizeof(struct device_priv),
-	sizeof(struct handle_priv),
-	0,				/* transfer_priv_size */
+	.name = "Synchronous NetBSD backend",
+	.caps = 0,
+	.get_device_list = netbsd_get_device_list,
+	.open = netbsd_open,
+	.close = netbsd_close,
+
+	.get_active_config_descriptor = netbsd_get_active_config_descriptor,
+	.get_config_descriptor = netbsd_get_config_descriptor,
+
+	.get_configuration = netbsd_get_configuration,
+	.set_configuration = netbsd_set_configuration,
+
+	.claim_interface = netbsd_claim_interface,
+	.release_interface = netbsd_release_interface,
+
+	.set_interface_altsetting = netbsd_set_interface_altsetting,
+	.clear_halt = netbsd_clear_halt,
+
+	.destroy_device = netbsd_destroy_device,
+
+	.submit_transfer = netbsd_submit_transfer,
+	.cancel_transfer = netbsd_cancel_transfer,
+
+	.handle_transfer_completion = netbsd_handle_transfer_completion,
+
+	.device_priv_size = sizeof(struct device_priv),
+	.device_handle_priv_size = sizeof(struct handle_priv),
 };
 
 int
@@ -145,11 +117,12 @@ netbsd_get_device_list(struct libusb_context * ctx,
 	struct libusb_device *dev;
 	struct device_priv *dpriv;
 	struct usb_device_info di;
+	usb_device_descriptor_t ddesc;
 	unsigned long session_id;
 	char devnode[16];
 	int fd, err, i;
 
-	usbi_dbg("");
+	usbi_dbg(ctx, " ");
 
 	/* Only ugen(4) is supported */
 	for (i = 0; i < USB_MAX_DEVICES; i++) {
@@ -177,16 +150,20 @@ netbsd_get_device_list(struct libusb_context * ctx,
 			dev->device_address = di.udi_addr;
 			dev->speed = di.udi_speed;
 
-			dpriv = (struct device_priv *)dev->os_priv;
+			dpriv = usbi_get_device_priv(dev);
 			strlcpy(dpriv->devnode, devnode, sizeof(devnode));
 			dpriv->fd = -1;
 
-			if (ioctl(fd, USB_GET_DEVICE_DESC, &dpriv->ddesc) < 0) {
+			if (ioctl(fd, USB_GET_DEVICE_DESC, &ddesc) < 0) {
 				err = errno;
 				goto error;
 			}
 
-			dpriv->cdesc = NULL;
+			static_assert(sizeof(dev->device_descriptor) == sizeof(ddesc),
+				      "mismatch between libusb and OS device descriptor sizes");
+			memcpy(&dev->device_descriptor, &ddesc, LIBUSB_DT_DEVICE_SIZE);
+			usbi_localize_device_descriptor(&dev->device_descriptor);
+
 			if (_cache_active_config_descriptor(dev, fd)) {
 				err = errno;
 				goto error;
@@ -214,8 +191,8 @@ error:
 int
 netbsd_open(struct libusb_device_handle *handle)
 {
-	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
-	struct handle_priv *hpriv = (struct handle_priv *)handle->os_priv;
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+	struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
 	int i;
 
 	dpriv->fd = open(dpriv->devnode, O_RDWR);
@@ -228,7 +205,7 @@ netbsd_open(struct libusb_device_handle *handle)
 	for (i = 0; i < USB_MAX_ENDPOINTS; i++)
 		hpriv->endpoints[i] = -1;
 
-	usbi_dbg("open %s: fd %d", dpriv->devnode, dpriv->fd);
+	usbi_dbg(HANDLE_CTX(handle), "open %s: fd %d", dpriv->devnode, dpriv->fd);
 
 	return (LIBUSB_SUCCESS);
 }
@@ -236,57 +213,38 @@ netbsd_open(struct libusb_device_handle *handle)
 void
 netbsd_close(struct libusb_device_handle *handle)
 {
-	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
 
-	usbi_dbg("close: fd %d", dpriv->fd);
+	usbi_dbg(HANDLE_CTX(handle), "close: fd %d", dpriv->fd);
 
 	close(dpriv->fd);
 	dpriv->fd = -1;
 }
 
-int
-netbsd_get_device_descriptor(struct libusb_device *dev, unsigned char *buf,
-    int *host_endian)
-{
-	struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
-
-	usbi_dbg("");
-
-	memcpy(buf, &dpriv->ddesc, DEVICE_DESC_LENGTH);
-
-	*host_endian = 0;
-
-	return (LIBUSB_SUCCESS);
-}
-
 int
 netbsd_get_active_config_descriptor(struct libusb_device *dev,
-    unsigned char *buf, size_t len, int *host_endian)
+    void *buf, size_t len)
 {
-	struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
-	usb_config_descriptor_t *ucd;
+	struct device_priv *dpriv = usbi_get_device_priv(dev);
 
-	ucd = (usb_config_descriptor_t *) dpriv->cdesc;
-	len = MIN(len, UGETW(ucd->wTotalLength));
+	len = MIN(len, (size_t)UGETW(dpriv->cdesc->wTotalLength));
 
-	usbi_dbg("len %d", len);
+	usbi_dbg(DEVICE_CTX(dev), "len %zu", len);
 
 	memcpy(buf, dpriv->cdesc, len);
 
-	*host_endian = 0;
-
-	return len;
+	return (int)len;
 }
 
 int
 netbsd_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
-    unsigned char *buf, size_t len, int *host_endian)
+    void *buf, size_t len)
 {
-	struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
+	struct device_priv *dpriv = usbi_get_device_priv(dev);
 	struct usb_full_desc ufd;
 	int fd, err;
 
-	usbi_dbg("index %d, len %d", idx, len);
+	usbi_dbg(DEVICE_CTX(dev), "index %u, len %zu", idx, len);
 
 	/* A config descriptor may be requested before opening the device */
 	if (dpriv->fd >= 0) {
@@ -311,22 +269,22 @@ netbsd_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
 	if (dpriv->fd < 0)
 		close(fd);
 
-	*host_endian = 0;
-
-	return len;
+	return (int)len;
 }
 
 int
-netbsd_get_configuration(struct libusb_device_handle *handle, int *config)
+netbsd_get_configuration(struct libusb_device_handle *handle, uint8_t *config)
 {
-	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
+	int tmp;
 
-	usbi_dbg("");
+	usbi_dbg(HANDLE_CTX(handle), " ");
 
-	if (ioctl(dpriv->fd, USB_GET_CONFIG, config) < 0)
+	if (ioctl(dpriv->fd, USB_GET_CONFIG, &tmp) < 0)
 		return _errno_to_libusb(errno);
 
-	usbi_dbg("configuration %d", *config);
+	usbi_dbg(HANDLE_CTX(handle), "configuration %d", tmp);
+	*config = (uint8_t)tmp;
 
 	return (LIBUSB_SUCCESS);
 }
@@ -334,9 +292,9 @@ netbsd_get_configuration(struct libusb_device_handle *handle, int *config)
 int
 netbsd_set_configuration(struct libusb_device_handle *handle, int config)
 {
-	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
 
-	usbi_dbg("configuration %d", config);
+	usbi_dbg(HANDLE_CTX(handle), "configuration %d", config);
 
 	if (ioctl(dpriv->fd, USB_SET_CONFIG, &config) < 0)
 		return _errno_to_libusb(errno);
@@ -345,11 +303,13 @@ netbsd_set_configuration(struct libusb_device_handle *handle, int config)
 }
 
 int
-netbsd_claim_interface(struct libusb_device_handle *handle, int iface)
+netbsd_claim_interface(struct libusb_device_handle *handle, uint8_t iface)
 {
-	struct handle_priv *hpriv = (struct handle_priv *)handle->os_priv;
+	struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
 	int i;
 
+	UNUSED(iface);
+
 	for (i = 0; i < USB_MAX_ENDPOINTS; i++)
 		hpriv->endpoints[i] = -1;
 
@@ -357,11 +317,13 @@ netbsd_claim_interface(struct libusb_device_handle *handle, int iface)
 }
 
 int
-netbsd_release_interface(struct libusb_device_handle *handle, int iface)
+netbsd_release_interface(struct libusb_device_handle *handle, uint8_t iface)
 {
-	struct handle_priv *hpriv = (struct handle_priv *)handle->os_priv;
+	struct handle_priv *hpriv = usbi_get_device_handle_priv(handle);
 	int i;
 
+	UNUSED(iface);
+
 	for (i = 0; i < USB_MAX_ENDPOINTS; i++)
 		if (hpriv->endpoints[i] >= 0)
 			close(hpriv->endpoints[i]);
@@ -370,13 +332,13 @@ netbsd_release_interface(struct libusb_device_handle *handle, int iface)
 }
 
 int
-netbsd_set_interface_altsetting(struct libusb_device_handle *handle, int iface,
-    int altsetting)
+netbsd_set_interface_altsetting(struct libusb_device_handle *handle, uint8_t iface,
+    uint8_t altsetting)
 {
-	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
 	struct usb_alt_interface intf;
 
-	usbi_dbg("iface %d, setting %d", iface, altsetting);
+	usbi_dbg(HANDLE_CTX(handle), "iface %u, setting %u", iface, altsetting);
 
 	memset(&intf, 0, sizeof(intf));
 
@@ -392,10 +354,10 @@ netbsd_set_interface_altsetting(struct libusb_device_handle *handle, int iface,
 int
 netbsd_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
 {
-	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
 	struct usb_ctl_request req;
 
-	usbi_dbg("");
+	usbi_dbg(HANDLE_CTX(handle), " ");
 
 	req.ucr_request.bmRequestType = UT_WRITE_ENDPOINT;
 	req.ucr_request.bRequest = UR_CLEAR_FEATURE;
@@ -409,20 +371,12 @@ netbsd_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
 	return (LIBUSB_SUCCESS);
 }
 
-int
-netbsd_reset_device(struct libusb_device_handle *handle)
-{
-	usbi_dbg("");
-
-	return (LIBUSB_ERROR_NOT_SUPPORTED);
-}
-
 void
 netbsd_destroy_device(struct libusb_device *dev)
 {
-	struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
+	struct device_priv *dpriv = usbi_get_device_priv(dev);
 
-	usbi_dbg("");
+	usbi_dbg(DEVICE_CTX(dev), " ");
 
 	free(dpriv->cdesc);
 }
@@ -431,13 +385,11 @@ int
 netbsd_submit_transfer(struct usbi_transfer *itransfer)
 {
 	struct libusb_transfer *transfer;
-	struct handle_priv *hpriv;
 	int err = 0;
 
-	usbi_dbg("");
+	usbi_dbg(ITRANSFER_CTX(itransfer), " ");
 
 	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
-	hpriv = (struct handle_priv *)transfer->dev_handle->os_priv;
 
 	switch (transfer->type) {
 	case LIBUSB_TRANSFER_TYPE_CONTROL:
@@ -476,17 +428,11 @@ netbsd_submit_transfer(struct usbi_transfer *itransfer)
 int
 netbsd_cancel_transfer(struct usbi_transfer *itransfer)
 {
-	usbi_dbg("");
+	UNUSED(itransfer);
 
-	return (LIBUSB_ERROR_NOT_SUPPORTED);
-}
+	usbi_dbg(ITRANSFER_CTX(itransfer), " ");
 
-void
-netbsd_clear_transfer_priv(struct usbi_transfer *itransfer)
-{
-	usbi_dbg("");
-
-	/* Nothing to do */
+	return (LIBUSB_ERROR_NOT_SUPPORTED);
 }
 
 int
@@ -495,20 +441,6 @@ netbsd_handle_transfer_completion(struct usbi_transfer *itransfer)
 	return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
 }
 
-int
-netbsd_clock_gettime(int clkid, struct timespec *tp)
-{
-	usbi_dbg("clock %d", clkid);
-
-	if (clkid == USBI_CLOCK_REALTIME)
-		return clock_gettime(CLOCK_REALTIME, tp);
-
-	if (clkid == USBI_CLOCK_MONOTONIC)
-		return clock_gettime(CLOCK_MONOTONIC, tp);
-
-	return (LIBUSB_ERROR_INVALID_PARAM);
-}
-
 int
 _errno_to_libusb(int err)
 {
@@ -521,9 +453,12 @@ _errno_to_libusb(int err)
 		return (LIBUSB_ERROR_NO_DEVICE);
 	case ENOMEM:
 		return (LIBUSB_ERROR_NO_MEM);
+	case EWOULDBLOCK:
+	case ETIMEDOUT:
+		return (LIBUSB_ERROR_TIMEOUT);
 	}
 
-	usbi_dbg("error: %s", strerror(err));
+	usbi_dbg(NULL, "error: %s", strerror(err));
 
 	return (LIBUSB_ERROR_OTHER);
 }
@@ -531,23 +466,23 @@ _errno_to_libusb(int err)
 int
 _cache_active_config_descriptor(struct libusb_device *dev, int fd)
 {
-	struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
+	struct device_priv *dpriv = usbi_get_device_priv(dev);
 	struct usb_config_desc ucd;
 	struct usb_full_desc ufd;
-	unsigned char* buf;
+	void *buf;
 	int len;
 
-	usbi_dbg("fd %d", fd);
+	usbi_dbg(DEVICE_CTX(dev), "fd %d", fd);
 
 	ucd.ucd_config_index = USB_CURRENT_CONFIG_INDEX;
 
 	if ((ioctl(fd, USB_GET_CONFIG_DESC, &ucd)) < 0)
 		return _errno_to_libusb(errno);
 
-	usbi_dbg("active bLength %d", ucd.ucd_desc.bLength);
+	usbi_dbg(DEVICE_CTX(dev), "active bLength %d", ucd.ucd_desc.bLength);
 
 	len = UGETW(ucd.ucd_desc.wTotalLength);
-	buf = malloc(len);
+	buf = malloc((size_t)len);
 	if (buf == NULL)
 		return (LIBUSB_ERROR_NO_MEM);
 
@@ -555,7 +490,7 @@ _cache_active_config_descriptor(struct libusb_device *dev, int fd)
 	ufd.ufd_size = len;
 	ufd.ufd_data = buf;
 
-	usbi_dbg("index %d, len %d", ufd.ufd_config_index, len);
+	usbi_dbg(DEVICE_CTX(dev), "index %d, len %d", ufd.ufd_config_index, len);
 
 	if ((ioctl(fd, USB_GET_FULL_DESC, &ufd)) < 0) {
 		free(buf);
@@ -578,10 +513,10 @@ _sync_control_transfer(struct usbi_transfer *itransfer)
 	struct usb_ctl_request req;
 
 	transfer = USBI_TRANSFER_TO_LIBUSB_TRANSFER(itransfer);
-	dpriv = (struct device_priv *)transfer->dev_handle->dev->os_priv;
+	dpriv = usbi_get_device_priv(transfer->dev_handle->dev);
 	setup = (struct libusb_control_setup *)transfer->buffer;
 
-	usbi_dbg("type %d request %d value %d index %d length %d timeout %d",
+	usbi_dbg(ITRANSFER_CTX(itransfer), "type %d request %d value %d index %d length %d timeout %d",
 	    setup->bmRequestType, setup->bRequest,
 	    libusb_le16_to_cpu(setup->wValue),
 	    libusb_le16_to_cpu(setup->wIndex),
@@ -606,7 +541,7 @@ _sync_control_transfer(struct usbi_transfer *itransfer)
 
 	itransfer->transferred = req.ucr_actlen;
 
-	usbi_dbg("transferred %d", itransfer->transferred);
+	usbi_dbg(ITRANSFER_CTX(itransfer), "transferred %d", itransfer->transferred);
 
 	return (0);
 }
@@ -620,13 +555,13 @@ _access_endpoint(struct libusb_transfer *transfer)
 	int fd, endpt;
 	mode_t mode;
 
-	hpriv = (struct handle_priv *)transfer->dev_handle->os_priv;
-	dpriv = (struct device_priv *)transfer->dev_handle->dev->os_priv;
+	hpriv = usbi_get_device_handle_priv(transfer->dev_handle);
+	dpriv = usbi_get_device_priv(transfer->dev_handle->dev);
 
 	endpt = UE_GET_ADDR(transfer->endpoint);
 	mode = IS_XFERIN(transfer) ? O_RDONLY : O_WRONLY;
 
-	usbi_dbg("endpoint %d mode %d", endpt, mode);
+	usbi_dbg(TRANSFER_CTX(transfer), "endpoint %d mode %d", endpt, mode);
 
 	if (hpriv->endpoints[endpt] < 0) {
 		/* Pick the right node given the control one */

package/libusb/libusb/os/null_usb.c

@@ -0,0 +1,111 @@
+/*
+ * Copyright © 2019 Pino Toscano <toscano.pino@tiscali.it>
+ *
+ * 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"
+
+static int
+null_get_device_list(struct libusb_context * ctx,
+	struct discovered_devs **discdevs)
+{
+	return LIBUSB_SUCCESS;
+}
+
+static int
+null_open(struct libusb_device_handle *handle)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static void
+null_close(struct libusb_device_handle *handle)
+{
+}
+
+static int
+null_get_active_config_descriptor(struct libusb_device *dev,
+    void *buf, size_t len)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
+    void *buf, size_t len)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_set_configuration(struct libusb_device_handle *handle, int config)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_claim_interface(struct libusb_device_handle *handle, uint8_t iface)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_release_interface(struct libusb_device_handle *handle, uint8_t iface)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_set_interface_altsetting(struct libusb_device_handle *handle, uint8_t iface,
+    uint8_t altsetting)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_submit_transfer(struct usbi_transfer *itransfer)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+static int
+null_cancel_transfer(struct usbi_transfer *itransfer)
+{
+	return LIBUSB_ERROR_NOT_SUPPORTED;
+}
+
+const struct usbi_os_backend usbi_backend = {
+	.name = "Null backend",
+	.caps = 0,
+	.get_device_list = null_get_device_list,
+	.open = null_open,
+	.close = null_close,
+	.get_active_config_descriptor = null_get_active_config_descriptor,
+	.get_config_descriptor = null_get_config_descriptor,
+	.set_configuration = null_set_configuration,
+	.claim_interface = null_claim_interface,
+	.release_interface = null_release_interface,
+	.set_interface_altsetting = null_set_interface_altsetting,
+	.clear_halt = null_clear_halt,
+	.submit_transfer = null_submit_transfer,
+	.cancel_transfer = null_cancel_transfer,
+};