usb 2.1.1 → 2.2.0

package/libusb/examples/ezusb.h

@@ -20,23 +20,10 @@
  *    along with this program; if not, write to the Free Software
  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
-#if !defined(_MSC_VER)
+
+#include <config.h>
+
 #include <stdbool.h>
-#else
-#define __attribute__(x)
-#if !defined(bool)
-#define bool int
-#endif
-#if !defined(true)
-#define true (1 == 1)
-#endif
-#if !defined(false)
-#define false (!true)
-#endif
-#if defined(_PREFAST_)
-#pragma warning(disable:28193)
-#endif
-#endif
 
 #define FX_TYPE_UNDEFINED  -1
 #define FX_TYPE_AN21       0	/* Original AnchorChips parts */
@@ -59,7 +46,7 @@
 extern "C" {
 #endif
 
-/* 
+/*
  * Automatically identified devices (VID, PID, type, designation).
  * TODO: Could use some validation. Also where's the FX2?
  */
@@ -113,6 +100,8 @@ extern int ezusb_load_eeprom(libusb_device_handle *device,
 /* Verbosity level (default 1). Can be increased or decreased with options v/q  */
 extern int verbose;
 
+extern void logerror(const char *format, ...) PRINTF_FORMAT(1, 2);
+
 #ifdef __cplusplus
 }
 #endif

package/libusb/examples/fxload.c

@@ -21,6 +21,8 @@
  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
 
+#include <config.h>
+
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
@@ -32,7 +34,7 @@
 #include "libusb.h"
 #include "ezusb.h"
 
-#if !defined(_WIN32) || defined(__CYGWIN__ )
+#if !defined(_WIN32) || defined(__CYGWIN__)
 #include <syslog.h>
 static bool dosyslog = false;
 #include <strings.h>
@@ -47,15 +49,12 @@ static bool dosyslog = false;
 #define ARRAYSIZE(A) (sizeof(A)/sizeof((A)[0]))
 #endif
 
-void logerror(const char *format, ...)
-	__attribute__ ((format (__printf__, 1, 2)));
-
 void logerror(const char *format, ...)
 {
 	va_list ap;
 	va_start(ap, format);
 
-#if !defined(_WIN32) || defined(__CYGWIN__ )
+#if !defined(_WIN32) || defined(__CYGWIN__)
 	if (dosyslog)
 		vsyslog(LOG_ERR, format, ap);
 	else

package/libusb/examples/hotplugtest.c

@@ -95,7 +95,7 @@ int main(int argc, char *argv[])
 	}
 
 	if (!libusb_has_capability (LIBUSB_CAP_HAS_HOTPLUG)) {
-		printf ("Hotplug capabilites are not supported on this platform\n");
+		printf ("Hotplug capabilities are not supported on this platform\n");
 		libusb_exit (NULL);
 		return EXIT_FAILURE;
 	}

package/libusb/examples/sam3u_benchmark.c

@@ -22,24 +22,54 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include <unistd.h>
-#include <stdlib.h>
-#include <stdio.h>
+#include <config.h>
+
 #include <errno.h>
 #include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#ifdef HAVE_SYS_TIME_H
+#include <sys/time.h>
+#endif
+#include <time.h>
 
-#include <libusb.h>
-
+#include "libusb.h"
 
 #define EP_DATA_IN	0x82
 #define EP_ISO_IN	0x86
 
-static int do_exit = 0;
+static volatile sig_atomic_t 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 get_timestamp(struct timeval *tv)
+{
+#if defined(PLATFORM_WINDOWS)
+	static LARGE_INTEGER frequency;
+	LARGE_INTEGER counter;
+
+	if (!frequency.QuadPart)
+		QueryPerformanceFrequency(&frequency);
+
+	QueryPerformanceCounter(&counter);
+	counter.QuadPart *= 1000000;
+	counter.QuadPart /= frequency.QuadPart;
+
+	tv->tv_sec = (long)(counter.QuadPart / 1000000ULL);
+	tv->tv_usec = (long)(counter.QuadPart % 1000000ULL);
+#elif defined(HAVE_CLOCK_GETTIME)
+	struct timespec ts;
+
+	(void)clock_gettime(CLOCK_MONOTONIC, &ts);
+	tv->tv_sec = ts.tv_sec;
+	tv->tv_usec = (int)(ts.tv_nsec / 1000L);
+#else
+	gettimeofday(tv, NULL);
+#endif
+}
+
 static void LIBUSB_CALL cb_xfr(struct libusb_transfer *xfr)
 {
 	int i;
@@ -92,8 +122,10 @@ static int benchmark_in(uint8_t ep)
 		num_iso_pack = 16;
 
 	xfr = libusb_alloc_transfer(num_iso_pack);
-	if (!xfr)
-		return -ENOMEM;
+	if (!xfr) {
+		errno = ENOMEM;
+		return -1;
+	}
 
 	if (ep == EP_ISO_IN) {
 		libusb_fill_iso_transfer(xfr, devh, ep, buf,
@@ -103,7 +135,7 @@ static int benchmark_in(uint8_t ep)
 		libusb_fill_bulk_transfer(xfr, devh, ep, buf,
 				sizeof(buf), cb_xfr, NULL, 0);
 
-	gettimeofday(&tv_start, NULL);
+	get_timestamp(&tv_start);
 
 	/* NOTE: To reach maximum possible performance the program must
 	 * submit *multiple* transfers here, not just one.
@@ -125,36 +157,39 @@ static int benchmark_in(uint8_t ep)
 static void measure(void)
 {
 	struct timeval tv_stop;
-	unsigned int diff_msec;
+	unsigned long diff_msec;
 
-	gettimeofday(&tv_stop, NULL);
+	get_timestamp(&tv_stop);
 
-	diff_msec = (tv_stop.tv_sec - tv_start.tv_sec)*1000;
-	diff_msec += (tv_stop.tv_usec - tv_start.tv_usec)/1000;
+	diff_msec = (tv_stop.tv_sec - tv_start.tv_sec) * 1000L;
+	diff_msec += (tv_stop.tv_usec - tv_start.tv_usec) / 1000L;
 
-	printf("%lu transfers (total %lu bytes) in %u miliseconds => %lu bytes/sec\n",
-		num_xfer, num_bytes, diff_msec, (num_bytes*1000)/diff_msec);
+	printf("%lu transfers (total %lu bytes) in %lu milliseconds => %lu bytes/sec\n",
+		num_xfer, num_bytes, diff_msec, (num_bytes * 1000L) / diff_msec);
 }
 
 static void sig_hdlr(int signum)
 {
-	switch (signum) {
-	case SIGINT:
-		measure();
-		do_exit = 1;
-		break;
-	}
+	(void)signum;
+
+	measure();
+	do_exit = 1;
 }
 
-int main(int argc, char **argv)
+int main(void)
 {
 	int rc;
+
+#if defined(PLATFORM_POSIX)
 	struct sigaction sigact;
 
 	sigact.sa_handler = sig_hdlr;
 	sigemptyset(&sigact.sa_mask);
 	sigact.sa_flags = 0;
-	sigaction(SIGINT, &sigact, NULL);
+	(void)sigaction(SIGINT, &sigact, NULL);
+#else
+	(void)signal(SIGINT, sig_hdlr);
+#endif
 
 	rc = libusb_init(NULL);
 	if (rc < 0) {
@@ -184,7 +219,7 @@ int main(int argc, char **argv)
 
 	/* Measurement has already been done by the signal handler. */
 
-	libusb_release_interface(devh, 0);
+	libusb_release_interface(devh, 2);
 out:
 	if (devh)
 		libusb_close(devh);

package/libusb/examples/testlibusb.c

@@ -21,18 +21,14 @@
 #include <string.h>
 #include "libusb.h"
 
-#if defined(_MSC_VER) && (_MSC_VER < 1900)
-#define snprintf _snprintf
-#endif
-
 int verbose = 0;
 
 static void print_endpoint_comp(const struct libusb_ss_endpoint_companion_descriptor *ep_comp)
 {
 	printf("      USB 3.0 Endpoint Companion:\n");
-	printf("        bMaxBurst:        %d\n", ep_comp->bMaxBurst);
-	printf("        bmAttributes:     0x%02x\n", ep_comp->bmAttributes);
-	printf("        wBytesPerInterval: %d\n", ep_comp->wBytesPerInterval);
+	printf("        bMaxBurst:           %u\n", ep_comp->bMaxBurst);
+	printf("        bmAttributes:        %02xh\n", ep_comp->bmAttributes);
+	printf("        wBytesPerInterval:   %u\n", ep_comp->wBytesPerInterval);
 }
 
 static void print_endpoint(const struct libusb_endpoint_descriptor *endpoint)
@@ -40,21 +36,20 @@ static void print_endpoint(const struct libusb_endpoint_descriptor *endpoint)
 	int i, ret;
 
 	printf("      Endpoint:\n");
-	printf("        bEndpointAddress: %02xh\n", endpoint->bEndpointAddress);
-	printf("        bmAttributes:     %02xh\n", endpoint->bmAttributes);
-	printf("        wMaxPacketSize:   %d\n", endpoint->wMaxPacketSize);
-	printf("        bInterval:        %d\n", endpoint->bInterval);
-	printf("        bRefresh:         %d\n", endpoint->bRefresh);
-	printf("        bSynchAddress:    %d\n", endpoint->bSynchAddress);
+	printf("        bEndpointAddress:    %02xh\n", endpoint->bEndpointAddress);
+	printf("        bmAttributes:        %02xh\n", endpoint->bmAttributes);
+	printf("        wMaxPacketSize:      %u\n", endpoint->wMaxPacketSize);
+	printf("        bInterval:           %u\n", endpoint->bInterval);
+	printf("        bRefresh:            %u\n", endpoint->bRefresh);
+	printf("        bSynchAddress:       %u\n", endpoint->bSynchAddress);
 
 	for (i = 0; i < endpoint->extra_length;) {
 		if (LIBUSB_DT_SS_ENDPOINT_COMPANION == endpoint->extra[i + 1]) {
 			struct libusb_ss_endpoint_companion_descriptor *ep_comp;
 
 			ret = libusb_get_ss_endpoint_companion_descriptor(NULL, endpoint, &ep_comp);
-			if (LIBUSB_SUCCESS != ret) {
+			if (LIBUSB_SUCCESS != ret)
 				continue;
-			}
 
 			print_endpoint_comp(ep_comp);
 
@@ -70,13 +65,13 @@ static void print_altsetting(const struct libusb_interface_descriptor *interface
 	uint8_t i;
 
 	printf("    Interface:\n");
-	printf("      bInterfaceNumber:   %d\n", interface->bInterfaceNumber);
-	printf("      bAlternateSetting:  %d\n", interface->bAlternateSetting);
-	printf("      bNumEndpoints:      %d\n", interface->bNumEndpoints);
-	printf("      bInterfaceClass:    %d\n", interface->bInterfaceClass);
-	printf("      bInterfaceSubClass: %d\n", interface->bInterfaceSubClass);
-	printf("      bInterfaceProtocol: %d\n", interface->bInterfaceProtocol);
-	printf("      iInterface:         %d\n", interface->iInterface);
+	printf("      bInterfaceNumber:      %u\n", interface->bInterfaceNumber);
+	printf("      bAlternateSetting:     %u\n", interface->bAlternateSetting);
+	printf("      bNumEndpoints:         %u\n", interface->bNumEndpoints);
+	printf("      bInterfaceClass:       %u\n", interface->bInterfaceClass);
+	printf("      bInterfaceSubClass:    %u\n", interface->bInterfaceSubClass);
+	printf("      bInterfaceProtocol:    %u\n", interface->bInterfaceProtocol);
+	printf("      iInterface:            %u\n", interface->iInterface);
 
 	for (i = 0; i < interface->bNumEndpoints; i++)
 		print_endpoint(&interface->endpoint[i]);
@@ -85,58 +80,58 @@ static void print_altsetting(const struct libusb_interface_descriptor *interface
 static void print_2_0_ext_cap(struct libusb_usb_2_0_extension_descriptor *usb_2_0_ext_cap)
 {
 	printf("    USB 2.0 Extension Capabilities:\n");
-	printf("      bDevCapabilityType: %d\n", usb_2_0_ext_cap->bDevCapabilityType);
-	printf("      bmAttributes:       0x%x\n", usb_2_0_ext_cap->bmAttributes);
+	printf("      bDevCapabilityType:    %u\n", usb_2_0_ext_cap->bDevCapabilityType);
+	printf("      bmAttributes:          %08xh\n", usb_2_0_ext_cap->bmAttributes);
 }
 
 static void print_ss_usb_cap(struct libusb_ss_usb_device_capability_descriptor *ss_usb_cap)
 {
 	printf("    USB 3.0 Capabilities:\n");
-	printf("      bDevCapabilityType: %d\n", ss_usb_cap->bDevCapabilityType);
-	printf("      bmAttributes:       0x%x\n", ss_usb_cap->bmAttributes);
-	printf("      wSpeedSupported:    0x%x\n", ss_usb_cap->wSpeedSupported);
-	printf("      bFunctionalitySupport: %d\n", ss_usb_cap->bFunctionalitySupport);
-	printf("      bU1devExitLat:      %d\n", ss_usb_cap->bU1DevExitLat);
-	printf("      bU2devExitLat:      %d\n", ss_usb_cap->bU2DevExitLat);
+	printf("      bDevCapabilityType:    %u\n", ss_usb_cap->bDevCapabilityType);
+	printf("      bmAttributes:          %02xh\n", ss_usb_cap->bmAttributes);
+	printf("      wSpeedSupported:       %u\n", ss_usb_cap->wSpeedSupported);
+	printf("      bFunctionalitySupport: %u\n", ss_usb_cap->bFunctionalitySupport);
+	printf("      bU1devExitLat:         %u\n", ss_usb_cap->bU1DevExitLat);
+	printf("      bU2devExitLat:         %u\n", ss_usb_cap->bU2DevExitLat);
 }
 
 static void print_bos(libusb_device_handle *handle)
 {
 	struct libusb_bos_descriptor *bos;
+	uint8_t i;
 	int ret;
 
 	ret = libusb_get_bos_descriptor(handle, &bos);
-	if (0 > ret) {
+	if (ret < 0)
 		return;
-	}
 
 	printf("  Binary Object Store (BOS):\n");
-	printf("    wTotalLength:       %d\n", bos->wTotalLength);
-	printf("    bNumDeviceCaps:     %d\n", bos->bNumDeviceCaps);
+	printf("    wTotalLength:            %u\n", bos->wTotalLength);
+	printf("    bNumDeviceCaps:          %u\n", bos->bNumDeviceCaps);
 
-	if(bos->dev_capability[0]->bDevCapabilityType == LIBUSB_BT_USB_2_0_EXTENSION) {
+	for (i = 0; i < bos->bNumDeviceCaps; i++) {
+		struct libusb_bos_dev_capability_descriptor *dev_cap = bos->dev_capability[i];
 
-		struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension;
-	        ret =  libusb_get_usb_2_0_extension_descriptor(NULL, bos->dev_capability[0],&usb_2_0_extension);
-	        if (0 > ret) {
-		        return;
-	        }
+		if (dev_cap->bDevCapabilityType == LIBUSB_BT_USB_2_0_EXTENSION) {
+			struct libusb_usb_2_0_extension_descriptor *usb_2_0_extension;
 
-                print_2_0_ext_cap(usb_2_0_extension);
-                libusb_free_usb_2_0_extension_descriptor(usb_2_0_extension);
-        }
+			ret = libusb_get_usb_2_0_extension_descriptor(NULL, dev_cap, &usb_2_0_extension);
+			if (ret < 0)
+				return;
 
-	if(bos->dev_capability[0]->bDevCapabilityType == LIBUSB_BT_SS_USB_DEVICE_CAPABILITY) {
+			print_2_0_ext_cap(usb_2_0_extension);
+			libusb_free_usb_2_0_extension_descriptor(usb_2_0_extension);
+		} else if (dev_cap->bDevCapabilityType == LIBUSB_BT_SS_USB_DEVICE_CAPABILITY) {
+			struct libusb_ss_usb_device_capability_descriptor *ss_dev_cap;
 
-	        struct libusb_ss_usb_device_capability_descriptor *dev_cap;
-		ret = libusb_get_ss_usb_device_capability_descriptor(NULL, bos->dev_capability[0],&dev_cap);
-	        if (0 > ret) {
-		        return;
-	        }
+			ret = libusb_get_ss_usb_device_capability_descriptor(NULL, dev_cap, &ss_dev_cap);
+			if (ret < 0)
+				return;
 
-	        print_ss_usb_cap(dev_cap);
-	        libusb_free_ss_usb_device_capability_descriptor(dev_cap);
-        }
+			print_ss_usb_cap(ss_dev_cap);
+			libusb_free_ss_usb_device_capability_descriptor(ss_dev_cap);
+		}
+	}
 
 	libusb_free_bos_descriptor(bos);
 }
@@ -154,79 +149,71 @@ static void print_configuration(struct libusb_config_descriptor *config)
 	uint8_t i;
 
 	printf("  Configuration:\n");
-	printf("    wTotalLength:         %d\n", config->wTotalLength);
-	printf("    bNumInterfaces:       %d\n", config->bNumInterfaces);
-	printf("    bConfigurationValue:  %d\n", config->bConfigurationValue);
-	printf("    iConfiguration:       %d\n", config->iConfiguration);
-	printf("    bmAttributes:         %02xh\n", config->bmAttributes);
-	printf("    MaxPower:             %d\n", config->MaxPower);
+	printf("    wTotalLength:            %u\n", config->wTotalLength);
+	printf("    bNumInterfaces:          %u\n", config->bNumInterfaces);
+	printf("    bConfigurationValue:     %u\n", config->bConfigurationValue);
+	printf("    iConfiguration:          %u\n", config->iConfiguration);
+	printf("    bmAttributes:            %02xh\n", config->bmAttributes);
+	printf("    MaxPower:                %u\n", config->MaxPower);
 
 	for (i = 0; i < config->bNumInterfaces; i++)
 		print_interface(&config->interface[i]);
 }
 
-static int print_device(libusb_device *dev, int level)
+static void print_device(libusb_device *dev, libusb_device_handle *handle)
 {
 	struct libusb_device_descriptor desc;
-	libusb_device_handle *handle = NULL;
-	char description[260];
-	char string[256];
+	unsigned char string[256];
+	const char *speed;
 	int ret;
 	uint8_t i;
 
+	switch (libusb_get_device_speed(dev)) {
+	case LIBUSB_SPEED_LOW:		speed = "1.5M"; break;
+	case LIBUSB_SPEED_FULL:		speed = "12M"; break;
+	case LIBUSB_SPEED_HIGH:		speed = "480M"; break;
+	case LIBUSB_SPEED_SUPER:	speed = "5G"; break;
+	case LIBUSB_SPEED_SUPER_PLUS:	speed = "10G"; break;
+	default:			speed = "Unknown";
+	}
+
 	ret = libusb_get_device_descriptor(dev, &desc);
 	if (ret < 0) {
 		fprintf(stderr, "failed to get device descriptor");
-		return -1;
+		return;
 	}
 
-	ret = libusb_open(dev, &handle);
-	if (LIBUSB_SUCCESS == ret) {
+	printf("Dev (bus %u, device %u): %04X - %04X speed: %s\n",
+	       libusb_get_bus_number(dev), libusb_get_device_address(dev),
+	       desc.idVendor, desc.idProduct, speed);
+
+	if (!handle)
+		libusb_open(dev, &handle);
+
+	if (handle) {
 		if (desc.iManufacturer) {
 			ret = libusb_get_string_descriptor_ascii(handle, desc.iManufacturer, string, sizeof(string));
 			if (ret > 0)
-				snprintf(description, sizeof(description), "%s - ", string);
-			else
-				snprintf(description, sizeof(description), "%04X - ",
-				desc.idVendor);
+				printf("  Manufacturer:              %s\n", (char *)string);
 		}
-		else
-			snprintf(description, sizeof(description), "%04X - ",
-			desc.idVendor);
 
 		if (desc.iProduct) {
 			ret = libusb_get_string_descriptor_ascii(handle, desc.iProduct, string, sizeof(string));
 			if (ret > 0)
-				snprintf(description + strlen(description), sizeof(description) -
-				strlen(description), "%s", string);
-			else
-				snprintf(description + strlen(description), sizeof(description) -
-				strlen(description), "%04X", desc.idProduct);
+				printf("  Product:                   %s\n", (char *)string);
 		}
-		else
-			snprintf(description + strlen(description), sizeof(description) -
-			strlen(description), "%04X", desc.idProduct);
-	}
-	else {
-		snprintf(description, sizeof(description), "%04X - %04X",
-			desc.idVendor, desc.idProduct);
-	}
 
-	printf("%.*sDev (bus %d, device %d): %s\n", level * 2, "                    ",
-		libusb_get_bus_number(dev), libusb_get_device_address(dev), description);
-
-	if (handle && verbose) {
-		if (desc.iSerialNumber) {
+		if (desc.iSerialNumber && verbose) {
 			ret = libusb_get_string_descriptor_ascii(handle, desc.iSerialNumber, string, sizeof(string));
 			if (ret > 0)
-				printf("%.*s  - Serial Number: %s\n", level * 2,
-				"                    ", string);
+				printf("  Serial Number:             %s\n", (char *)string);
 		}
 	}
 
 	if (verbose) {
 		for (i = 0; i < desc.bNumConfigurations; i++) {
 			struct libusb_config_descriptor *config;
+
 			ret = libusb_get_config_descriptor(dev, i, &config);
 			if (LIBUSB_SUCCESS != ret) {
 				printf("  Couldn't retrieve descriptors\n");
@@ -238,40 +225,87 @@ static int print_device(libusb_device *dev, int level)
 			libusb_free_config_descriptor(config);
 		}
 
-		if (handle && desc.bcdUSB >= 0x0201) {
+		if (handle && desc.bcdUSB >= 0x0201)
 			print_bos(handle);
-		}
 	}
 
 	if (handle)
 		libusb_close(handle);
+}
+
+#ifdef __linux__
+#include <errno.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+static int test_wrapped_device(const char *device_name)
+{
+	libusb_device_handle *handle;
+	int r, fd;
 
+	fd = open(device_name, O_RDWR);
+	if (fd < 0) {
+		printf("Error could not open %s: %s\n", device_name, strerror(errno));
+		return 1;
+	}
+	r = libusb_wrap_sys_device(NULL, fd, &handle);
+	if (r) {
+		printf("Error wrapping device: %s: %s\n", device_name, libusb_strerror(r));
+		close(fd);
+		return 1;
+	}
+	print_device(libusb_get_device(handle), handle);
+	close(fd);
 	return 0;
 }
+#else
+static int test_wrapped_device(const char *device_name)
+{
+	(void)device_name;
+	printf("Testing wrapped devices is not supported on your platform\n");
+	return 1;
+}
+#endif
 
 int main(int argc, char *argv[])
 {
+	const char *device_name = NULL;
 	libusb_device **devs;
 	ssize_t cnt;
 	int r, i;
 
-	if (argc > 1 && !strcmp(argv[1], "-v"))
-		verbose = 1;
+	for (i = 1; i < argc; i++) {
+		if (!strcmp(argv[i], "-v")) {
+			verbose = 1;
+		} else if (!strcmp(argv[i], "-d") && (i + 1) < argc) {
+			i++;
+			device_name = argv[i];
+		} else {
+			printf("Usage %s [-v] [-d </dev/bus/usb/...>]\n", argv[0]);
+			printf("Note use -d to test libusb_wrap_sys_device()\n");
+			return 1;
+		}
+	}
 
 	r = libusb_init(NULL);
 	if (r < 0)
 		return r;
 
-	cnt = libusb_get_device_list(NULL, &devs);
-	if (cnt < 0)
-		return (int)cnt;
+	if (device_name) {
+		r = test_wrapped_device(device_name);
+	} else {
+		cnt = libusb_get_device_list(NULL, &devs);
+		if (cnt < 0) {
+			libusb_exit(NULL);
+			return 1;
+		}
 
-	for (i = 0; devs[i]; ++i) {
-		print_device(devs[i], 0);
-	}
+		for (i = 0; devs[i]; i++)
+			print_device(devs[i], NULL);
 
-	libusb_free_device_list(devs, 1);
+		libusb_free_device_list(devs, 1);
+	}
 
 	libusb_exit(NULL);
-	return 0;
+	return r;
 }