libusb 0.3.4 → 0.4.0

data/ext/libusbx-1.0.17/examples/hotplugtest.c

@@ -0,0 +1,97 @@
+/* -*- Mode: C; indent-tabs-mode:t ; c-basic-offset:8 -*- */
+/*
+ * libusb example program for hotplug API
+ * Copyright © 2012-2013 Nathan Hjelm <hjelmn@mac.ccom>
+ *
+ * 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 <stdlib.h>
+#include <stdio.h>
+
+#include "libusb.h"
+
+int done = 0;
+libusb_device_handle *handle;
+
+static int LIBUSB_CALL hotplug_callback(libusb_context *ctx, libusb_device *dev, libusb_hotplug_event event, void *user_data)
+{
+	struct libusb_device_descriptor desc;
+	int rc;
+
+	rc = libusb_get_device_descriptor(dev, &desc);
+	if (LIBUSB_SUCCESS != rc) {
+		fprintf (stderr, "Error getting device descriptor\n");
+	}
+
+	printf ("Device attached: %04x:%04x\n", desc.idVendor, desc.idProduct);
+
+	libusb_open (dev, &handle);
+
+	done++;
+
+	return 0;
+}
+
+static int LIBUSB_CALL hotplug_callback_detach(libusb_context *ctx, libusb_device *dev, libusb_hotplug_event event, void *user_data)
+{
+	printf ("Device detached\n");
+
+	libusb_close (handle);
+
+	done++;
+	return 0;
+}
+
+int main(int argc, char *argv[])
+{
+	libusb_hotplug_callback_handle hp[2];
+	int product_id, vendor_id, class_id;
+	int rc;
+
+	vendor_id  = (argc > 1) ? strtol (argv[1], NULL, 0) : 0x045a;
+	product_id = (argc > 2) ? strtol (argv[2], NULL, 0) : 0x5005;
+	class_id   = (argc > 3) ? strtol (argv[3], NULL, 0) : LIBUSB_HOTPLUG_MATCH_ANY;
+
+	libusb_init (NULL);
+
+	if (!libusb_has_capability (LIBUSB_CAP_HAS_HOTPLUG)) {
+		printf ("Hotplug capabilites are not supported on this platform\n");
+		libusb_exit (NULL);
+		return EXIT_FAILURE;
+	}
+
+	rc = libusb_hotplug_register_callback (NULL, LIBUSB_HOTPLUG_EVENT_DEVICE_ARRIVED, 0, vendor_id,
+		product_id, class_id, hotplug_callback, NULL, &hp[0]);
+	if (LIBUSB_SUCCESS != rc) {
+		fprintf (stderr, "Error registering callback 0\n");
+		libusb_exit (NULL);
+		return EXIT_FAILURE;
+	}
+
+	rc = libusb_hotplug_register_callback (NULL, LIBUSB_HOTPLUG_EVENT_DEVICE_LEFT, 0, vendor_id,
+		product_id,class_id, hotplug_callback_detach, NULL, &hp[1]);
+	if (LIBUSB_SUCCESS != rc) {
+		fprintf (stderr, "Error registering callback 1\n");
+		libusb_exit (NULL);
+		return EXIT_FAILURE;
+	}
+
+	while (done < 2) {
+		libusb_handle_events (NULL);
+	}
+
+	libusb_exit (NULL);
+}

data/ext/{libusbx-1.0.14 → libusbx-1.0.17}/examples/listdevs.c

@@ -18,14 +18,14 @@
  */
 
 #include <stdio.h>
-#include <sys/types.h>
 
-#include <libusb.h>
+#include "libusb.h"
 
 static void print_devs(libusb_device **devs)
 {
 	libusb_device *dev;
-	int i = 0;
+	int i = 0, j = 0;
+	uint8_t path[8]; 
 
 	while ((dev = devs[i++]) != NULL) {
 		struct libusb_device_descriptor desc;
@@ -35,9 +35,17 @@ static void print_devs(libusb_device **devs)
 			return;
 		}
 
-		printf("%04x:%04x (bus %d, device %d)\n",
+		printf("%04x:%04x (bus %d, device %d)",
 			desc.idVendor, desc.idProduct,
 			libusb_get_bus_number(dev), libusb_get_device_address(dev));
+
+		r = libusb_get_port_numbers(dev, path, sizeof(path));
+		if (r > 0) {
+			printf(" path: %d", path[0]);
+			for (j = 1; j < r; j++)
+				printf(".%d", path[j]);
+		}
+		printf("\n");
 	}
 }
 

data/ext/libusbx-1.0.17/examples/sam3u_benchmark.c

@@ -0,0 +1,193 @@
+/*
+ * libusb example program to measure Atmel SAM3U isochronous performance
+ * Copyright (C) 2012 Harald Welte <laforge@gnumonks.org>
+ *
+ * Copied with the author's permission under LGPL-2.1 from
+ * http://git.gnumonks.org/cgi-bin/gitweb.cgi?p=sam3u-tests.git;a=blob;f=usb-benchmark-project/host/benchmark.c;h=74959f7ee88f1597286cd435f312a8ff52c56b7e
+ *
+ * An Atmel SAM3U test firmware is also available in the above repository.
+ *
+ * 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 <unistd.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <signal.h>
+
+#include <libusb.h>
+
+
+#define EP_DATA_IN	0x82
+#define EP_ISO_IN	0x86
+
+static int do_exit = 0;
+static struct libusb_device_handle *devh = NULL;
+
+static unsigned long num_bytes = 0, num_xfer = 0;
+static struct timeval tv_start;
+
+static void LIBUSB_CALL cb_xfr(struct libusb_transfer *xfr)
+{
+	unsigned int i;
+
+	if (xfr->status != LIBUSB_TRANSFER_COMPLETED) {
+		fprintf(stderr, "transfer status %d\n", xfr->status);
+		libusb_free_transfer(xfr);
+		exit(3);
+	}
+
+	if (xfr->type == LIBUSB_TRANSFER_TYPE_ISOCHRONOUS) {
+		for (i = 0; i < xfr->num_iso_packets; i++) {
+			struct libusb_iso_packet_descriptor *pack = &xfr->iso_packet_desc[i];
+
+			if (pack->status != LIBUSB_TRANSFER_COMPLETED) {
+				fprintf(stderr, "Error: pack %u status %d\n", i, pack->status);
+				exit(5);
+			}
+
+			printf("pack%u length:%u, actual_length:%u\n", i, pack->length, pack->actual_length);
+		}
+	}
+
+	printf("length:%u, actual_length:%u\n", xfr->length, xfr->actual_length);
+	for (i = 0; i < xfr->actual_length; i++) {
+		printf("%02x", xfr->buffer[i]);
+		if (i % 16)
+			printf("\n");
+		else if (i % 8)
+			printf("  ");
+		else
+			printf(" ");
+	}
+	num_bytes += xfr->actual_length;
+	num_xfer++;
+
+	if (libusb_submit_transfer(xfr) < 0) {
+		fprintf(stderr, "error re-submitting URB\n");
+		exit(1);
+	}
+}
+
+static int benchmark_in(uint8_t ep)
+{
+	static uint8_t buf[2048];
+	static struct libusb_transfer *xfr;
+	int num_iso_pack = 0;
+
+	if (ep == EP_ISO_IN)
+		num_iso_pack = 16;
+
+	xfr = libusb_alloc_transfer(num_iso_pack);
+	if (!xfr)
+		return -ENOMEM;
+
+	if (ep == EP_ISO_IN) {
+		libusb_fill_iso_transfer(xfr, devh, ep, buf,
+				sizeof(buf), num_iso_pack, cb_xfr, NULL, 0);
+		libusb_set_iso_packet_lengths(xfr, sizeof(buf)/num_iso_pack);
+	} else
+		libusb_fill_bulk_transfer(xfr, devh, ep, buf,
+				sizeof(buf), cb_xfr, NULL, 0);
+
+	gettimeofday(&tv_start, NULL);
+
+	/* NOTE: To reach maximum possible performance the program must
+	 * submit *multiple* transfers here, not just one.
+	 *
+	 * When only one transfer is submitted there is a gap in the bus
+	 * schedule from when the transfer completes until a new transfer
+	 * is submitted by the callback. This causes some jitter for
+	 * isochronous transfers and loss of throughput for bulk transfers.
+	 *
+	 * This is avoided by queueing multiple transfers in advance, so
+	 * that the host controller is always kept busy, and will schedule
+	 * more transfers on the bus while the callback is running for
+	 * transfers which have completed on the bus.
+	 */
+
+	return libusb_submit_transfer(xfr);
+}
+
+static void measure(void)
+{
+	struct timeval tv_stop;
+	unsigned int diff_msec;
+
+	gettimeofday(&tv_stop, NULL);
+
+	diff_msec = (tv_stop.tv_sec - tv_start.tv_sec)*1000;
+	diff_msec += (tv_stop.tv_usec - tv_start.tv_usec)/1000;
+
+	printf("%lu transfers (total %lu bytes) in %u miliseconds => %lu bytes/sec\n",
+		num_xfer, num_bytes, diff_msec, (num_bytes*1000)/diff_msec);
+}
+
+static void sig_hdlr(int signum)
+{
+	switch (signum) {
+	case SIGINT:
+		measure();
+		do_exit = 1;
+		break;
+	}
+}
+
+int main(int argc, char **argv)
+{
+	int rc;
+	struct sigaction sigact;
+
+	sigact.sa_handler = sig_hdlr;
+	sigemptyset(&sigact.sa_mask);
+	sigact.sa_flags = 0;
+	sigaction(SIGINT, &sigact, NULL);
+
+	rc = libusb_init(NULL);
+	if (rc < 0) {
+		fprintf(stderr, "Error initializing libusb: %s\n", libusb_error_name(rc));
+		exit(1);
+	}
+
+	devh = libusb_open_device_with_vid_pid(NULL, 0x16c0, 0x0763);
+	if (!devh) {
+		fprintf(stderr, "Error finding USB device\n");
+		goto out;
+	}
+
+	rc = libusb_claim_interface(devh, 2);
+	if (rc < 0) {
+		fprintf(stderr, "Error claiming interface: %s\n", libusb_error_name(rc));
+		goto out;
+	}
+
+	benchmark_in(EP_ISO_IN);
+
+	while (!do_exit) {
+		rc = libusb_handle_events(NULL);
+		if (rc != LIBUSB_SUCCESS)
+			break;
+	}
+
+	/* Measurement has already been done by the signal handler. */
+
+	libusb_release_interface(devh, 0);
+out:
+	if (devh)
+		libusb_close(devh);
+	libusb_exit(NULL);
+	return rc;
+}

data/ext/{libusbx-1.0.14 → libusbx-1.0.17}/examples/xusb.c

@@ -33,10 +33,6 @@
 #define msleep(msecs) usleep(1000*msecs)
 #endif
 
-#if !defined(_MSC_VER) || _MSC_VER<=1200
-#define sscanf_s sscanf
-#endif
-
 #if !defined(bool)
 #define bool int
 #endif
@@ -47,15 +43,14 @@
 #define false (!true)
 #endif
 
-
 // Future versions of libusbx will use usb_interface instead of interface
 // in libusb_config_descriptor => catter for that
 #define usb_interface interface
 
 // Global variables
-bool binary_dump = false;
-bool extra_info = false;
-const char* binary_name = NULL;
+static bool binary_dump = false;
+static bool extra_info = false;
+static const char* binary_name = NULL;
 
 static int perr(char const *format, ...)
 {
@@ -69,7 +64,7 @@ static int perr(char const *format, ...)
 	return r;
 }
 
-#define ERR_EXIT(errcode) do { perr("   %s\n", libusb_error_name((enum libusb_error)errcode)); return -1; } while (0)
+#define ERR_EXIT(errcode) do { perr("   %s\n", libusb_strerror((enum libusb_error)errcode)); return -1; } while (0)
 #define CALL_CHECK(fcall) do { r=fcall; if (r < 0) ERR_EXIT(r); } while (0);
 #define B(x) (((x)!=0)?1:0)
 #define be_to_int32(buf) (((buf)[0]<<24)|((buf)[1]<<16)|((buf)[2]<<8)|(buf)[3])
@@ -133,14 +128,14 @@ static uint8_t cdb_length[256] = {
 	00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,00,  //  F
 };
 
-enum test_type {
+static enum test_type {
 	USE_GENERIC,
 	USE_PS3,
 	USE_XBOX,
 	USE_SCSI,
 	USE_HID,
 } test_mode;
-uint16_t VID, PID;
+static uint16_t VID, PID;
 
 static void display_buffer_hex(unsigned char *buffer, unsigned size)
 {
@@ -170,6 +165,16 @@ static void display_buffer_hex(unsigned char *buffer, unsigned size)
 	printf("\n" );
 }
 
+static char* uuid_to_string(const uint8_t* uuid)
+{
+	static char uuid_string[40];
+	if (uuid == NULL) return NULL;
+	sprintf(uuid_string, "{%02x%02x%02x%02x-%02x%02x-%02x%02x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
+		uuid[0], uuid[1], uuid[2], uuid[3], uuid[4], uuid[5], uuid[6], uuid[7],
+		uuid[8], uuid[9], uuid[10], uuid[11], uuid[12], uuid[13], uuid[14], uuid[15]);
+	return uuid_string;
+}
+
 // The PS3 Controller is really a HID device that got its HID Report Descriptors
 // removed by Sony
 static int display_ps3_status(libusb_device_handle *handle)
@@ -349,7 +354,7 @@ static int send_mass_storage_command(libusb_device_handle *handle, uint8_t endpo
 		i++;
 	} while ((r == LIBUSB_ERROR_PIPE) && (i<RETRY_MAX));
 	if (r != LIBUSB_SUCCESS) {
-		perr("   send_mass_storage_command: %s\n", libusb_error_name(r));
+		perr("   send_mass_storage_command: %s\n", libusb_strerror((enum libusb_error)r));
 		return -1;
 	}
 
@@ -373,7 +378,7 @@ static int get_mass_storage_status(libusb_device_handle *handle, uint8_t endpoin
 		i++;
 	} while ((r == LIBUSB_ERROR_PIPE) && (i<RETRY_MAX));
 	if (r != LIBUSB_SUCCESS) {
-		perr("   get_mass_storage_status: %s\n", libusb_error_name(r));
+		perr("   get_mass_storage_status: %s\n", libusb_strerror((enum libusb_error)r));
 		return -1;
 	}
 	if (size != 13) {
@@ -455,7 +460,7 @@ static int test_mass_storage(libusb_device_handle *handle, uint8_t endpoint_in,
 	if (r == 0) {
 		lun = 0;
 	} else if (r < 0) {
-		perr("   Failed: %s", libusb_error_name((enum libusb_error)r));
+		perr("   Failed: %s", libusb_strerror((enum libusb_error)r));
 	}
 	printf("   Max LUN = %d\n", lun);
 
@@ -633,7 +638,7 @@ static int test_hid(libusb_device_handle *handle, uint8_t endpoint_in)
 				libusb_clear_halt(handle, 0);
 				break;
 			default:
-				printf("   Error: %s\n", libusb_error_name(r));
+				printf("   Error: %s\n", libusb_strerror((enum libusb_error)r));
 				break;
 			}
 		}
@@ -664,7 +669,7 @@ static int test_hid(libusb_device_handle *handle, uint8_t endpoint_in)
 				libusb_clear_halt(handle, 0);
 				break;
 			default:
-				printf("   Error: %s\n", libusb_error_name(r));
+				printf("   Error: %s\n", libusb_strerror((enum libusb_error)r));
 				break;
 			}
 		}
@@ -675,7 +680,7 @@ static int test_hid(libusb_device_handle *handle, uint8_t endpoint_in)
 		if (r >= 0) {
 			display_buffer_hex(report_buffer, size);
 		} else {
-			printf("   %s\n", libusb_error_name(r));
+			printf("   %s\n", libusb_strerror((enum libusb_error)r));
 		}
 
 		free(report_buffer);
@@ -693,11 +698,12 @@ static void read_ms_winsub_feature_descriptors(libusb_device_handle *handle, uin
 	void* le_type_punning_IS_fine;
 	struct {
 		const char* desc;
+		uint8_t recipient;
 		uint16_t index;
 		uint16_t header_size;
 	} os_fd[2] = {
-		{"Extended Compat ID", 0x0004, 0x10},
-		{"Extended Properties", 0x0005, 0x0A}
+		{"Extended Compat ID", LIBUSB_RECIPIENT_DEVICE, 0x0004, 0x10},
+		{"Extended Properties", LIBUSB_RECIPIENT_INTERFACE, 0x0005, 0x0A}
 	};
 
 	if (iface_number < 0) return;
@@ -706,10 +712,10 @@ static void read_ms_winsub_feature_descriptors(libusb_device_handle *handle, uin
 		printf("\nReading %s OS Feature Descriptor (wIndex = 0x%04d):\n", os_fd[i].desc, os_fd[i].index);
 
 		// Read the header part
-		r = libusb_control_transfer(handle, (uint8_t)(LIBUSB_ENDPOINT_IN|LIBUSB_REQUEST_TYPE_VENDOR|LIBUSB_RECIPIENT_DEVICE),
+		r = libusb_control_transfer(handle, (uint8_t)(LIBUSB_ENDPOINT_IN|LIBUSB_REQUEST_TYPE_VENDOR|os_fd[i].recipient),
 			bRequest, (uint16_t)(((iface_number)<< 8)|0x00), os_fd[i].index, os_desc, os_fd[i].header_size, 1000);
 		if (r < os_fd[i].header_size) {
-			perr("   Failed: %s", (r<0)?libusb_error_name((enum libusb_error)r):"header size is too small");
+			perr("   Failed: %s", (r<0)?libusb_strerror((enum libusb_error)r):"header size is too small");
 			return;
 		}
 		le_type_punning_IS_fine = (void*)os_desc;
@@ -719,10 +725,10 @@ static void read_ms_winsub_feature_descriptors(libusb_device_handle *handle, uin
 		}
 
 		// Read the full feature descriptor
-		r = libusb_control_transfer(handle, (uint8_t)(LIBUSB_ENDPOINT_IN|LIBUSB_REQUEST_TYPE_VENDOR|LIBUSB_RECIPIENT_DEVICE),
+		r = libusb_control_transfer(handle, (uint8_t)(LIBUSB_ENDPOINT_IN|LIBUSB_REQUEST_TYPE_VENDOR|os_fd[i].recipient),
 			bRequest, (uint16_t)(((iface_number)<< 8)|0x00), os_fd[i].index, os_desc, (uint16_t)length, 1000);
 		if (r < 0) {
-			perr("   Failed: %s", libusb_error_name((enum libusb_error)r));
+			perr("   Failed: %s", libusb_strerror((enum libusb_error)r));
 			return;
 		} else {
 			display_buffer_hex(os_desc, r);
@@ -730,19 +736,55 @@ static void read_ms_winsub_feature_descriptors(libusb_device_handle *handle, uin
 	}
 }
 
+static void print_device_cap(struct libusb_bos_dev_capability_descriptor *dev_cap)
+{
+	switch(dev_cap->bDevCapabilityType) {
+	case LIBUSB_BT_USB_2_0_EXTENSION: {
+		struct libusb_usb_2_0_extension_descriptor *usb_2_0_ext = NULL;
+		libusb_get_usb_2_0_extension_descriptor(NULL, dev_cap, &usb_2_0_ext);
+		if (usb_2_0_ext) {
+			printf("    USB 2.0 extension:\n");
+			printf("      attributes             : %02X\n", usb_2_0_ext->bmAttributes);
+			libusb_free_usb_2_0_extension_descriptor(usb_2_0_ext);
+		}
+		break;
+	}
+	case LIBUSB_BT_SS_USB_DEVICE_CAPABILITY: {
+		struct libusb_ss_usb_device_capability_descriptor *ss_usb_device_cap = NULL;
+		libusb_get_ss_usb_device_capability_descriptor(NULL, dev_cap, &ss_usb_device_cap);
+		if (ss_usb_device_cap) {
+			printf("    USB 3.0 capabilities:\n");
+			printf("      attributes             : %02X\n", ss_usb_device_cap->bmAttributes);
+			printf("      supported speeds       : %04X\n", ss_usb_device_cap->wSpeedSupported);
+			printf("      supported functionality: %02X\n", ss_usb_device_cap->bFunctionalitySupport);
+			libusb_free_ss_usb_device_capability_descriptor(ss_usb_device_cap);
+		}
+		break;
+	}
+	case LIBUSB_BT_CONTAINER_ID: {
+		struct libusb_container_id_descriptor *container_id = NULL;
+		libusb_get_container_id_descriptor(NULL, dev_cap, &container_id);
+		if (container_id) {
+			printf("    Container ID:\n      %s\n", uuid_to_string(container_id->ContainerID));
+			libusb_free_container_id_descriptor(container_id);
+		}
+		break;
+	}
+	default:
+		printf("    Unknown BOS device capability %02x:\n", dev_cap->bDevCapabilityType);
+	}	
+}
+
 static int test_device(uint16_t vid, uint16_t pid)
 {
 	libusb_device_handle *handle;
 	libusb_device *dev;
 	uint8_t bus, port_path[8];
+	struct libusb_bos_descriptor *bos_desc;
 	struct libusb_config_descriptor *conf_desc;
 	const struct libusb_endpoint_descriptor *endpoint;
 	int i, j, k, r;
 	int iface, nb_ifaces, first_iface = -1;
-#if defined(__linux__)
-	// Attaching/detaching the kernel driver is only relevant for Linux
-	int iface_detached = -1;
-#endif
 	struct libusb_device_descriptor dev_desc;
 	const char* speed_name[5] = { "Unknown", "1.5 Mbit/s (USB LowSpeed)", "12 Mbit/s (USB FullSpeed)",
 		"480 Mbit/s (USB HighSpeed)", "5000 Mbit/s (USB SuperSpeed)"};
@@ -761,7 +803,7 @@ static int test_device(uint16_t vid, uint16_t pid)
 	dev = libusb_get_device(handle);
 	bus = libusb_get_bus_number(dev);
 	if (extra_info) {
-		r = libusb_get_port_path(NULL, dev, port_path, sizeof(port_path));
+		r = libusb_get_port_numbers(dev, port_path, sizeof(port_path));
 		if (r > 0) {
 			printf("\nDevice properties:\n");
 			printf("        bus number: %d\n", bus);
@@ -790,7 +832,17 @@ static int test_device(uint16_t vid, uint16_t pid)
 	string_index[1] = dev_desc.iProduct;
 	string_index[2] = dev_desc.iSerialNumber;
 
-	printf("\nReading configuration descriptors:\n");
+	printf("\nReading BOS descriptor: ");
+	if (libusb_get_bos_descriptor(handle, &bos_desc) == LIBUSB_SUCCESS) {
+		printf("%d caps\n", bos_desc->bNumDeviceCaps);
+		for (i = 0; i < bos_desc->bNumDeviceCaps; i++)
+			print_device_cap(bos_desc->dev_capability[i]);
+		libusb_free_bos_descriptor(bos_desc);
+	} else {
+		printf("no descriptor\n");
+	}
+
+	printf("\nReading first configuration descriptor:\n");
 	CALL_CHECK(libusb_get_config_descriptor(dev, 0, &conf_desc));
 	nb_ifaces = conf_desc->bNumInterfaces;
 	printf("             nb interfaces: %d\n", nb_ifaces);
@@ -814,6 +866,7 @@ static int test_device(uint16_t vid, uint16_t pid)
 				test_mode = USE_SCSI;
 			}
 			for (k=0; k<conf_desc->usb_interface[i].altsetting[j].bNumEndpoints; k++) {
+				struct libusb_ss_endpoint_companion_descriptor *ep_comp = NULL;
 				endpoint = &conf_desc->usb_interface[i].altsetting[j].endpoint[k];
 				printf("       endpoint[%d].address: %02X\n", k, endpoint->bEndpointAddress);
 				// Use the first interrupt or bulk IN/OUT endpoints as default for testing
@@ -828,25 +881,22 @@ static int test_device(uint16_t vid, uint16_t pid)
 				}
 				printf("           max packet size: %04X\n", endpoint->wMaxPacketSize);
 				printf("          polling interval: %02X\n", endpoint->bInterval);
+				libusb_get_ss_endpoint_companion_descriptor(NULL, endpoint, &ep_comp);
+				if (ep_comp) {
+					printf("                 max burst: %02X   (USB 3.0)\n", ep_comp->bMaxBurst);
+					printf("        bytes per interval: %04X (USB 3.0)\n", ep_comp->wBytesPerInterval);
+					libusb_free_ss_endpoint_companion_descriptor(ep_comp);
+				}
 			}
 		}
 	}
 	libusb_free_config_descriptor(conf_desc);
 
+	libusb_set_auto_detach_kernel_driver(handle, 1);
 	for (iface = 0; iface < nb_ifaces; iface++)
 	{
 		printf("\nClaiming interface %d...\n", iface);
 		r = libusb_claim_interface(handle, iface);
-#if defined(__linux__)
-		if ((r != LIBUSB_SUCCESS) && (iface == 0)) {
-			// Maybe we need to detach the driver
-			perr("   Failed. Trying to detach driver...\n");
-			libusb_detach_kernel_driver(handle, iface);
-			iface_detached = iface;
-			printf("   Claiming interface again...\n");
-			r = libusb_claim_interface(handle, iface);
-		}
-#endif
 		if (r != LIBUSB_SUCCESS) {
 			perr("   Failed.\n");
 		}
@@ -895,13 +945,6 @@ static int test_device(uint16_t vid, uint16_t pid)
 		libusb_release_interface(handle, iface);
 	}
 
-#if defined(__linux__)
-	if (iface_detached >= 0) {
-		printf("Re-attaching kernel driver...\n");
-		libusb_attach_kernel_driver(handle, iface_detached);
-	}
-#endif
-
 	printf("Closing device...\n");
 	libusb_close(handle);
 
@@ -917,6 +960,7 @@ int main(int argc, char** argv)
 	size_t i, arglen;
 	unsigned tmp_vid, tmp_pid;
 	uint16_t endian_test = 0xBE00;
+	char* error_lang = NULL;
 
 	// Default to generic, expecting VID:PID
 	VID = 0;
@@ -943,12 +987,19 @@ int main(int argc, char** argv)
 					break;
 				case 'b':
 					if ((j+1 >= argc) || (argv[j+1][0] == '-') || (argv[j+1][0] == '/')) {
-						printf("   Option -b requires a file name");
+						printf("   Option -b requires a file name\n");
 						return 1;
 					}
 					binary_name = argv[++j];
 					binary_dump = true;
 					break;
+				case 'l':
+					if ((j+1 >= argc) || (argv[j+1][0] == '-') || (argv[j+1][0] == '/')) {
+						printf("   Option -l requires an ISO 639-1 language parameter\n");
+						return 1;
+					}
+					error_lang = argv[++j];
+					break;
 				case 'j':
 					// OLIMEX ARM-USB-TINY JTAG, 2 channel composite device - 2 interfaces
 					if (!VID && !PID) {
@@ -992,7 +1043,7 @@ int main(int argc, char** argv)
 						break;
 				}
 				if (i != arglen) {
-					if (sscanf_s(argv[j], "%x:%x" , &tmp_vid, &tmp_pid) != 2) {
+					if (sscanf(argv[j], "%x:%x" , &tmp_vid, &tmp_pid) != 2) {
 						printf("   Please specify VID & PID as \"vid:pid\" in hexadecimal format\n");
 						return 1;
 					}
@@ -1006,7 +1057,7 @@ int main(int argc, char** argv)
 	}
 
 	if ((show_help) || (argc == 1) || (argc > 7)) {
-		printf("usage: %s [-h] [-d] [-i] [-k] [-b file] [-j] [-x] [-s] [-p] [vid:pid]\n", argv[0]);
+		printf("usage: %s [-h] [-d] [-i] [-k] [-b file] [-l lang] [-j] [-x] [-s] [-p] [vid:pid]\n", argv[0]);
 		printf("   -h      : display usage\n");
 		printf("   -d      : enable debug output\n");
 		printf("   -i      : print topology and speed info\n");
@@ -1016,6 +1067,7 @@ int main(int argc, char** argv)
 		printf("   -p      : test Sony PS3 SixAxis controller\n");
 		printf("   -s      : test Microsoft Sidewinder Precision Pro (HID)\n");
 		printf("   -x      : test Microsoft XBox Controller Type S\n");
+		printf("   -l lang : language to report errors in (ISO 639-1)\n");
 		printf("If only the vid:pid is provided, xusb attempts to run the most appropriate test\n");
 		return 0;
 	}
@@ -1027,6 +1079,11 @@ int main(int argc, char** argv)
 		return r;
 
 	libusb_set_debug(NULL, debug_mode?LIBUSB_LOG_LEVEL_DEBUG:LIBUSB_LOG_LEVEL_INFO);
+	if (error_lang != NULL) {
+		r = libusb_setlocale(error_lang);
+		if (r < 0)
+			printf("Invalid or unsupported locale '%s': %s\n", error_lang, libusb_strerror((enum libusb_error)r));
+	}
 
 	test_device(VID, PID);