usb 2.1.2 → 2.3.0

package/libusb/libusb/os/openbsd_usb.c

@@ -36,8 +36,7 @@ struct device_priv {
 	char *devname;				/* name of the ugen(4) node */
 	int fd;					/* device file descriptor */
 
-	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 obsd_get_device_list(struct libusb_context *,
 static int obsd_open(struct libusb_device_handle *);
 static void obsd_close(struct libusb_device_handle *);
 
-static int obsd_get_device_descriptor(struct libusb_device *, unsigned char *,
-    int *);
 static int obsd_get_active_config_descriptor(struct libusb_device *,
-    unsigned char *, size_t, int *);
+    void *, size_t);
 static int obsd_get_config_descriptor(struct libusb_device *, uint8_t,
-    unsigned char *, size_t, int *);
+    void *, size_t);
 
-static int obsd_get_configuration(struct libusb_device_handle *, int *);
+static int obsd_get_configuration(struct libusb_device_handle *, uint8_t *);
 static int obsd_set_configuration(struct libusb_device_handle *, int);
 
-static int obsd_claim_interface(struct libusb_device_handle *, int);
-static int obsd_release_interface(struct libusb_device_handle *, int);
+static int obsd_claim_interface(struct libusb_device_handle *, uint8_t);
+static int obsd_release_interface(struct libusb_device_handle *, uint8_t);
 
-static int obsd_set_interface_altsetting(struct libusb_device_handle *, int,
-    int);
+static int obsd_set_interface_altsetting(struct libusb_device_handle *, uint8_t,
+    uint8_t);
 static int obsd_clear_halt(struct libusb_device_handle *, unsigned char);
-static int obsd_reset_device(struct libusb_device_handle *);
 static void obsd_destroy_device(struct libusb_device *);
 
 static int obsd_submit_transfer(struct usbi_transfer *);
 static int obsd_cancel_transfer(struct usbi_transfer *);
-static void obsd_clear_transfer_priv(struct usbi_transfer *);
 static int obsd_handle_transfer_completion(struct usbi_transfer *);
-static int obsd_clock_gettime(int, struct timespec *);
 
 /*
  * Private functions
@@ -95,7 +89,6 @@ const struct usbi_os_backend usbi_backend = {
 	.open = obsd_open,
 	.close = obsd_close,
 
-	.get_device_descriptor = obsd_get_device_descriptor,
 	.get_active_config_descriptor = obsd_get_active_config_descriptor,
 	.get_config_descriptor = obsd_get_config_descriptor,
 
@@ -107,16 +100,13 @@ const struct usbi_os_backend usbi_backend = {
 
 	.set_interface_altsetting = obsd_set_interface_altsetting,
 	.clear_halt = obsd_clear_halt,
-	.reset_device = obsd_reset_device,
 	.destroy_device = obsd_destroy_device,
 
 	.submit_transfer = obsd_submit_transfer,
 	.cancel_transfer = obsd_cancel_transfer,
-	.clear_transfer_priv = obsd_clear_transfer_priv,
 
 	.handle_transfer_completion = obsd_handle_transfer_completion,
 
-	.clock_gettime = obsd_clock_gettime,
 	.device_priv_size = sizeof(struct device_priv),
 	.device_handle_priv_size = sizeof(struct handle_priv),
 };
@@ -139,7 +129,7 @@ obsd_get_device_list(struct libusb_context * ctx,
 	char *udevname;
 	int fd, addr, i, j;
 
-	usbi_dbg("");
+	usbi_dbg(ctx, " ");
 
 	for (i = 0; i < 8; i++) {
 		snprintf(busnode, sizeof(busnode), USBDEV "%d", i);
@@ -183,10 +173,10 @@ obsd_get_device_list(struct libusb_context * ctx,
 				dev->bus_number = di.udi_bus;
 				dev->device_address = di.udi_addr;
 				dev->speed = di.udi_speed;
+				dev->port_number = di.udi_port;
 
-				dpriv = (struct device_priv *)dev->os_priv;
+				dpriv = usbi_get_device_priv(dev);
 				dpriv->fd = -1;
-				dpriv->cdesc = NULL;
 				dpriv->devname = udevname;
 
 				dd.udd_bus = di.udi_bus;
@@ -195,7 +185,11 @@ obsd_get_device_list(struct libusb_context * ctx,
 					libusb_unref_device(dev);
 					continue;
 				}
-				dpriv->ddesc = dd.udd_desc;
+
+				static_assert(sizeof(dev->device_descriptor) == sizeof(dd.udd_desc),
+					      "mismatch between libusb and OS device descriptor sizes");
+				memcpy(&dev->device_descriptor, &dd.udd_desc, LIBUSB_DT_DEVICE_SIZE);
+				usbi_localize_device_descriptor(&dev->device_descriptor);
 
 				if (_cache_active_config_descriptor(dev)) {
 					libusb_unref_device(dev);
@@ -228,21 +222,23 @@ obsd_get_device_list(struct libusb_context * ctx,
 int
 obsd_open(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);
 	char devnode[16];
 
 	if (dpriv->devname) {
+		int fd;
 		/*
 		 * Only open ugen(4) attached devices read-write, all
 		 * read-only operations are done through the bus node.
 		 */
 		snprintf(devnode, sizeof(devnode), DEVPATH "%s.00",
 		    dpriv->devname);
-		dpriv->fd = open(devnode, O_RDWR);
-		if (dpriv->fd < 0)
+		fd = open(devnode, O_RDWR);
+		if (fd < 0)
 			return _errno_to_libusb(errno);
+		dpriv->fd = fd;
 
-		usbi_dbg("open %s: fd %d", devnode, dpriv->fd);
+		usbi_dbg(HANDLE_CTX(handle), "open %s: fd %d", devnode, dpriv->fd);
 	}
 
 	return (LIBUSB_SUCCESS);
@@ -251,52 +247,34 @@ obsd_open(struct libusb_device_handle *handle)
 void
 obsd_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);
 
 	if (dpriv->devname) {
-		usbi_dbg("close: fd %d", dpriv->fd);
+		usbi_dbg(HANDLE_CTX(handle), "close: fd %d", dpriv->fd);
 
 		close(dpriv->fd);
 		dpriv->fd = -1;
 	}
 }
 
-int
-obsd_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
 obsd_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 = (usb_config_descriptor_t *)dpriv->cdesc;
+	struct device_priv *dpriv = usbi_get_device_priv(dev);
 
-	len = MIN(len, UGETW(ucd->wTotalLength));
+	len = MIN(len, (size_t)UGETW(dpriv->cdesc->wTotalLength));
 
-	usbi_dbg("len %zu", len);
+	usbi_dbg(DEVICE_CTX(dev), "len %zu", len);
 
 	memcpy(buf, dpriv->cdesc, len);
 
-	*host_endian = 0;
-
-	return (len);
+	return ((int)len);
 }
 
 int
 obsd_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 usb_device_fdesc udf;
 	int fd, err;
@@ -310,7 +288,7 @@ obsd_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
 	udf.udf_size = len;
 	udf.udf_data = buf;
 
-	usbi_dbg("index %d, len %zu", udf.udf_config_index, len);
+	usbi_dbg(DEVICE_CTX(dev), "index %d, len %zu", udf.udf_config_index, len);
 
 	if (ioctl(fd, USB_DEVICE_GET_FDESC, &udf) < 0) {
 		err = errno;
@@ -319,20 +297,17 @@ obsd_get_config_descriptor(struct libusb_device *dev, uint8_t idx,
 	}
 	close(fd);
 
-	*host_endian = 0;
-
-	return (len);
+	return ((int)len);
 }
 
 int
-obsd_get_configuration(struct libusb_device_handle *handle, int *config)
+obsd_get_configuration(struct libusb_device_handle *handle, uint8_t *config)
 {
-	struct device_priv *dpriv = (struct device_priv *)handle->dev->os_priv;
-	usb_config_descriptor_t *ucd = (usb_config_descriptor_t *)dpriv->cdesc;
+	struct device_priv *dpriv = usbi_get_device_priv(handle->dev);
 
-	*config = ucd->bConfigurationValue;
+	*config = dpriv->cdesc->bConfigurationValue;
 
-	usbi_dbg("bConfigurationValue %d", *config);
+	usbi_dbg(HANDLE_CTX(handle), "bConfigurationValue %u", *config);
 
 	return (LIBUSB_SUCCESS);
 }
@@ -340,12 +315,12 @@ obsd_get_configuration(struct libusb_device_handle *handle, int *config)
 int
 obsd_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);
 
 	if (dpriv->devname == NULL)
 		return (LIBUSB_ERROR_NOT_SUPPORTED);
 
-	usbi_dbg("bConfigurationValue %d", config);
+	usbi_dbg(HANDLE_CTX(handle), "bConfigurationValue %d", config);
 
 	if (ioctl(dpriv->fd, USB_SET_CONFIG, &config) < 0)
 		return _errno_to_libusb(errno);
@@ -354,11 +329,13 @@ obsd_set_configuration(struct libusb_device_handle *handle, int config)
 }
 
 int
-obsd_claim_interface(struct libusb_device_handle *handle, int iface)
+obsd_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;
 
@@ -366,11 +343,13 @@ obsd_claim_interface(struct libusb_device_handle *handle, int iface)
 }
 
 int
-obsd_release_interface(struct libusb_device_handle *handle, int iface)
+obsd_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]);
@@ -379,16 +358,16 @@ obsd_release_interface(struct libusb_device_handle *handle, int iface)
 }
 
 int
-obsd_set_interface_altsetting(struct libusb_device_handle *handle, int iface,
-    int altsetting)
+obsd_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;
 
 	if (dpriv->devname == NULL)
 		return (LIBUSB_ERROR_NOT_SUPPORTED);
 
-	usbi_dbg("iface %d, setting %d", iface, altsetting);
+	usbi_dbg(HANDLE_CTX(handle), "iface %u, setting %u", iface, altsetting);
 
 	memset(&intf, 0, sizeof(intf));
 
@@ -410,7 +389,7 @@ obsd_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
 	if ((fd = _bus_open(handle->dev->bus_number)) < 0)
 		return _errno_to_libusb(errno);
 
-	usbi_dbg("");
+	usbi_dbg(HANDLE_CTX(handle), " ");
 
 	req.ucr_addr = handle->dev->device_address;
 	req.ucr_request.bmRequestType = UT_WRITE_ENDPOINT;
@@ -429,20 +408,12 @@ obsd_clear_halt(struct libusb_device_handle *handle, unsigned char endpoint)
 	return (LIBUSB_SUCCESS);
 }
 
-int
-obsd_reset_device(struct libusb_device_handle *handle)
-{
-	usbi_dbg("");
-
-	return (LIBUSB_ERROR_NOT_SUPPORTED);
-}
-
 void
 obsd_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);
 	free(dpriv->devname);
@@ -452,13 +423,11 @@ int
 obsd_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:
@@ -497,17 +466,11 @@ obsd_submit_transfer(struct usbi_transfer *itransfer)
 int
 obsd_cancel_transfer(struct usbi_transfer *itransfer)
 {
-	usbi_dbg("");
+	UNUSED(itransfer);
 
-	return (LIBUSB_ERROR_NOT_SUPPORTED);
-}
-
-void
-obsd_clear_transfer_priv(struct usbi_transfer *itransfer)
-{
-	usbi_dbg("");
+	usbi_dbg(ITRANSFER_CTX(itransfer), " ");
 
-	/* Nothing to do */
+	return (LIBUSB_ERROR_NOT_SUPPORTED);
 }
 
 int
@@ -516,22 +479,10 @@ obsd_handle_transfer_completion(struct usbi_transfer *itransfer)
 	return usbi_handle_transfer_completion(itransfer, LIBUSB_TRANSFER_COMPLETED);
 }
 
-int
-obsd_clock_gettime(int clkid, struct timespec *tp)
-{
-	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)
 {
-	usbi_dbg("error: %s (%d)", strerror(err), err);
+	usbi_dbg(NULL, "error: %s (%d)", strerror(err), err);
 
 	switch (err) {
 	case EIO:
@@ -552,16 +503,16 @@ _errno_to_libusb(int err)
 int
 _cache_active_config_descriptor(struct libusb_device *dev)
 {
-	struct device_priv *dpriv = (struct device_priv *)dev->os_priv;
+	struct device_priv *dpriv = usbi_get_device_priv(dev);
 	struct usb_device_cdesc udc;
 	struct usb_device_fdesc udf;
-	unsigned char* buf;
+	void *buf;
 	int fd, len, err;
 
 	if ((fd = _bus_open(dev->bus_number)) < 0)
 		return _errno_to_libusb(errno);
 
-	usbi_dbg("fd %d, addr %d", fd, dev->device_address);
+	usbi_dbg(DEVICE_CTX(dev), "fd %d, addr %d", fd, dev->device_address);
 
 	udc.udc_bus = dev->bus_number;
 	udc.udc_addr = dev->device_address;
@@ -572,10 +523,10 @@ _cache_active_config_descriptor(struct libusb_device *dev)
 		return _errno_to_libusb(errno);
 	}
 
-	usbi_dbg("active bLength %d", udc.udc_desc.bLength);
+	usbi_dbg(DEVICE_CTX(dev), "active bLength %d", udc.udc_desc.bLength);
 
 	len = UGETW(udc.udc_desc.wTotalLength);
-	buf = malloc(len);
+	buf = malloc((size_t)len);
 	if (buf == NULL)
 		return (LIBUSB_ERROR_NO_MEM);
 
@@ -585,7 +536,7 @@ _cache_active_config_descriptor(struct libusb_device *dev)
 	udf.udf_size = len;
 	udf.udf_data = buf;
 
-	usbi_dbg("index %d, len %d", udf.udf_config_index, len);
+	usbi_dbg(DEVICE_CTX(dev), "index %d, len %d", udf.udf_config_index, len);
 
 	if (ioctl(fd, USB_DEVICE_GET_FDESC, &udf) < 0) {
 		err = errno;
@@ -611,10 +562,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 %x request %x value %x index %d length %d timeout %d",
+	usbi_dbg(ITRANSFER_CTX(itransfer), "type 0x%x request 0x%x value 0x%x index %d length %d timeout %d",
 	    setup->bmRequestType, setup->bRequest,
 	    libusb_le16_to_cpu(setup->wValue),
 	    libusb_le16_to_cpu(setup->wIndex),
@@ -659,7 +610,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);
 }
@@ -673,13 +624,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 endpoint node */
@@ -705,7 +656,7 @@ _sync_gen_transfer(struct usbi_transfer *itransfer)
 	int fd, nr = 1;
 
 	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);
 
 	if (dpriv->devname == NULL)
 		return (LIBUSB_ERROR_NOT_SUPPORTED);