usb 2.1.3 → 2.2.0

package/libusb/examples/Makefile.am

@@ -1,19 +1,12 @@
 AM_CPPFLAGS = -I$(top_srcdir)/libusb
 LDADD = ../libusb/libusb-1.0.la
+LIBS =
 
-noinst_PROGRAMS = listdevs xusb fxload hotplugtest testlibusb
+noinst_PROGRAMS = dpfp dpfp_threaded fxload hotplugtest listdevs sam3u_benchmark testlibusb xusb
 
-if HAVE_SIGACTION
-noinst_PROGRAMS += dpfp
-
-if THREADS_POSIX
-dpfp_threaded_CFLAGS = $(AM_CFLAGS)
-noinst_PROGRAMS += dpfp_threaded
-endif
-
-sam3u_benchmark_SOURCES = sam3u_benchmark.c
-noinst_PROGRAMS += sam3u_benchmark
-endif
+dpfp_threaded_CPPFLAGS = $(AM_CPPFLAGS) -DDPFP_THREADED
+dpfp_threaded_CFLAGS = $(AM_CFLAGS) $(THREAD_CFLAGS)
+dpfp_threaded_LDADD = $(LDADD) $(THREAD_LIBS)
+dpfp_threaded_SOURCES = dpfp.c
 
 fxload_SOURCES = ezusb.c ezusb.h fxload.c
-fxload_CFLAGS = $(THREAD_CFLAGS) $(AM_CFLAGS)

package/libusb/examples/dpfp.c

@@ -1,6 +1,8 @@
 /*
  * libusb example program to manipulate U.are.U 4000B fingerprint scanner.
  * Copyright © 2007 Daniel Drake <dsd@gentoo.org>
+ * Copyright © 2016 Nathan Hjelm <hjelmn@mac.com>
+ * Copyright © 2020 Chris Dickens <christopher.a.dickens@gmail.com>
  *
  * Basic image capture program only, does not consider the powerup quirks or
  * the fact that image encryption may be enabled. Not expected to work
@@ -21,14 +23,121 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
+#include <config.h>
+
 #include <errno.h>
 #include <signal.h>
-#include <string.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 
 #include "libusb.h"
 
+#if defined(_MSC_VER)
+#define snprintf _snprintf
+#endif
+
+#if defined(DPFP_THREADED)
+#if defined(PLATFORM_POSIX)
+#include <fcntl.h>
+#include <pthread.h>
+#include <semaphore.h>
+#include <unistd.h>
+
+#define THREAD_RETURN_VALUE	NULL
+typedef sem_t * semaphore_t;
+typedef pthread_t thread_t;
+
+static inline semaphore_t semaphore_create(void)
+{
+	sem_t *semaphore;
+	char name[50];
+
+	sprintf(name, "/org.libusb.example.dpfp_threaded:%d", (int)getpid());
+	semaphore = sem_open(name, O_CREAT | O_EXCL, 0, 0);
+	if (semaphore == SEM_FAILED)
+		return NULL;
+	/* Remove semaphore so that it does not persist after process exits */
+	(void)sem_unlink(name);
+	return semaphore;
+}
+
+static inline void semaphore_give(semaphore_t semaphore)
+{
+	(void)sem_post(semaphore);
+}
+
+static inline void semaphore_take(semaphore_t semaphore)
+{
+	(void)sem_wait(semaphore);
+}
+
+static inline void semaphore_destroy(semaphore_t semaphore)
+{
+	(void)sem_close(semaphore);
+}
+
+static inline int thread_create(thread_t *thread,
+	void *(*thread_entry)(void *arg), void *arg)
+{
+	return pthread_create(thread, NULL, thread_entry, arg) == 0 ? 0 : -1;
+}
+
+static inline void thread_join(thread_t thread)
+{
+	(void)pthread_join(thread, NULL);
+}
+#elif defined(PLATFORM_WINDOWS)
+#define THREAD_RETURN_VALUE	0
+typedef HANDLE semaphore_t;
+typedef HANDLE thread_t;
+
+#if defined(__CYGWIN__)
+typedef DWORD thread_return_t;
+#else
+#include <process.h>
+typedef unsigned thread_return_t;
+#endif
+
+static inline semaphore_t semaphore_create(void)
+{
+	return CreateSemaphore(NULL, 0, 1, NULL);
+}
+
+static inline void semaphore_give(semaphore_t semaphore)
+{
+	(void)ReleaseSemaphore(semaphore, 1, NULL);
+}
+
+static inline void semaphore_take(semaphore_t semaphore)
+{
+	(void)WaitForSingleObject(semaphore, INFINITE);
+}
+
+static inline void semaphore_destroy(semaphore_t semaphore)
+{
+	(void)CloseHandle(semaphore);
+}
+
+static inline int thread_create(thread_t *thread,
+	thread_return_t (__stdcall *thread_entry)(void *arg), void *arg)
+{
+#if defined(__CYGWIN__)
+	*thread = CreateThread(NULL, 0, thread_entry, arg, 0, NULL);
+#else
+	*thread = (HANDLE)_beginthreadex(NULL, 0, thread_entry, arg, 0, NULL);
+#endif
+	return *thread != NULL ? 0 : -1;
+}
+
+static inline void thread_join(thread_t thread)
+{
+	(void)WaitForSingleObject(thread, INFINITE);
+	(void)CloseHandle(thread);
+}
+#endif
+#endif
+
 #define EP_INTR			(1 | LIBUSB_ENDPOINT_IN)
 #define EP_DATA			(2 | LIBUSB_ENDPOINT_IN)
 #define CTRL_IN			(LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_ENDPOINT_IN)
@@ -57,25 +166,69 @@ enum {
 };
 
 static int state = 0;
-static struct libusb_device_handle *devh = NULL;
+static libusb_device_handle *devh = NULL;
 static unsigned char imgbuf[0x1b340];
 static unsigned char irqbuf[INTR_LENGTH];
 static struct libusb_transfer *img_transfer = NULL;
 static struct libusb_transfer *irq_transfer = NULL;
 static int img_idx = 0;
-static int do_exit = 0;
+static volatile sig_atomic_t do_exit = 0;
+
+#if defined(DPFP_THREADED)
+static semaphore_t exit_semaphore;
+static thread_t poll_thread;
+#endif
+
+static void request_exit(sig_atomic_t code)
+{
+	do_exit = code;
+#if defined(DPFP_THREADED)
+	semaphore_give(exit_semaphore);
+#endif
+}
+
+#if defined(DPFP_THREADED)
+#if defined(PLATFORM_POSIX)
+static void *poll_thread_main(void *arg)
+#elif defined(PLATFORM_WINDOWS)
+static thread_return_t __stdcall poll_thread_main(void *arg)
+#endif
+{
+	(void)arg;
+
+	printf("poll thread running\n");
+
+	while (!do_exit) {
+		struct timeval tv = { 1, 0 };
+		int r;
+
+		r = libusb_handle_events_timeout(NULL, &tv);
+		if (r < 0) {
+			request_exit(2);
+			break;
+		}
+	}
+
+	printf("poll thread shutting down\n");
+	return THREAD_RETURN_VALUE;
+}
+#endif
 
 static int find_dpfp_device(void)
 {
 	devh = libusb_open_device_with_vid_pid(NULL, 0x05ba, 0x000a);
-	return devh ? 0 : -EIO;
+	if (!devh) {
+		errno = ENODEV;
+		return -1;
+	}
+	return 0;
 }
 
 static int print_f0_data(void)
 {
 	unsigned char data[0x10];
+	size_t i;
 	int r;
-	unsigned int i;
 
 	r = libusb_control_transfer(devh, CTRL_IN, USB_RQ, 0xf0, 0, data,
 		sizeof(data), 0);
@@ -83,14 +236,14 @@ static int print_f0_data(void)
 		fprintf(stderr, "F0 error %d\n", r);
 		return r;
 	}
-	if ((unsigned int) r < sizeof(data)) {
+	if (r < (int)sizeof(data)) {
 		fprintf(stderr, "short read (%d)\n", r);
 		return -1;
 	}
 
 	printf("F0 data:");
 	for (i = 0; i < sizeof(data); i++)
-		printf("%02x ", data[i]);
+		printf(" %02x", data[i]);
 	printf("\n");
 	return 0;
 }
@@ -104,7 +257,7 @@ static int get_hwstat(unsigned char *status)
 		fprintf(stderr, "read hwstat error %d\n", r);
 		return r;
 	}
-	if ((unsigned int) r < 1) {
+	if (r < 1) {
 		fprintf(stderr, "short read (%d)\n", r);
 		return -1;
 	}
@@ -123,8 +276,8 @@ static int set_hwstat(unsigned char data)
 		fprintf(stderr, "set hwstat error %d\n", r);
 		return r;
 	}
-	if ((unsigned int) r < 1) {
-		fprintf(stderr, "short write (%d)", r);
+	if (r < 1) {
+		fprintf(stderr, "short write (%d)\n", r);
 		return -1;
 	}
 
@@ -134,15 +287,15 @@ static int set_hwstat(unsigned char data)
 static int set_mode(unsigned char data)
 {
 	int r;
-	printf("set mode %02x\n", data);
 
+	printf("set mode %02x\n", data);
 	r = libusb_control_transfer(devh, CTRL_OUT, USB_RQ, 0x4e, 0, &data, 1, 0);
 	if (r < 0) {
 		fprintf(stderr, "set mode error %d\n", r);
 		return r;
 	}
-	if ((unsigned int) r < 1) {
-		fprintf(stderr, "short write (%d)", r);
+	if (r < 1) {
+		fprintf(stderr, "short write (%d)\n", r);
 		return -1;
 	}
 
@@ -153,27 +306,30 @@ static void LIBUSB_CALL cb_mode_changed(struct libusb_transfer *transfer)
 {
 	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
 		fprintf(stderr, "mode change transfer not completed!\n");
-		do_exit = 2;
+		request_exit(2);
 	}
 
 	printf("async cb_mode_changed length=%d actual_length=%d\n",
 		transfer->length, transfer->actual_length);
 	if (next_state() < 0)
-		do_exit = 2;
+		request_exit(2);
 }
 
 static int set_mode_async(unsigned char data)
 {
-	unsigned char *buf = (unsigned char*) malloc(LIBUSB_CONTROL_SETUP_SIZE + 1);
+	unsigned char *buf = malloc(LIBUSB_CONTROL_SETUP_SIZE + 1);
 	struct libusb_transfer *transfer;
 
-	if (!buf)
-		return -ENOMEM;
+	if (!buf) {
+		errno = ENOMEM;
+		return -1;
+	}
 
 	transfer = libusb_alloc_transfer(0);
 	if (!transfer) {
 		free(buf);
-		return -ENOMEM;
+		errno = ENOMEM;
+		return -1;
 	}
 
 	printf("async set mode %02x\n", data);
@@ -203,7 +359,7 @@ static int do_sync_intr(unsigned char *data)
 		return -1;
 	}
 
-	printf("recv interrupt %04x\n", *((uint16_t *) data));
+	printf("recv interrupt %04x\n", *((uint16_t *)data));
 	return 0;
 }
 
@@ -223,17 +379,17 @@ static int sync_intr(unsigned char type)
 
 static int save_to_file(unsigned char *data)
 {
-	FILE *fd;
+	FILE *f;
 	char filename[64];
 
 	snprintf(filename, sizeof(filename), "finger%d.pgm", img_idx++);
-	fd = fopen(filename, "w");
-	if (!fd)
+	f = fopen(filename, "w");
+	if (!f)
 		return -1;
 
-	fputs("P5 384 289 255 ", fd);
-	(void) fwrite(data + 64, 1, 384*289, fd);
-	fclose(fd);
+	fputs("P5 384 289 255 ", f);
+	(void)fwrite(data + 64, 1, 384*289, f);
+	fclose(f);
 	printf("saved image to %s\n", filename);
 	return 0;
 }
@@ -241,6 +397,7 @@ static int save_to_file(unsigned char *data)
 static int next_state(void)
 {
 	int r = 0;
+
 	printf("old state: %d\n", state);
 	switch (state) {
 	case STATE_AWAIT_IRQ_FINGER_REMOVED:
@@ -282,57 +439,60 @@ static void LIBUSB_CALL cb_irq(struct libusb_transfer *transfer)
 
 	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
 		fprintf(stderr, "irq transfer status %d?\n", transfer->status);
-		do_exit = 2;
-		libusb_free_transfer(transfer);
-		irq_transfer = NULL;
-		return;
+		goto err_free_transfer;
 	}
 
 	printf("IRQ callback %02x\n", irqtype);
 	switch (state) {
 	case STATE_AWAIT_IRQ_FINGER_DETECTED:
 		if (irqtype == 0x01) {
-			if (next_state() < 0) {
-				do_exit = 2;
-				return;
-			}
+			if (next_state() < 0)
+				goto err_free_transfer;
 		} else {
 			printf("finger-on-sensor detected in wrong state!\n");
 		}
 		break;
 	case STATE_AWAIT_IRQ_FINGER_REMOVED:
 		if (irqtype == 0x02) {
-			if (next_state() < 0) {
-				do_exit = 2;
-				return;
-			}
+			if (next_state() < 0)
+				goto err_free_transfer;
 		} else {
 			printf("finger-on-sensor detected in wrong state!\n");
 		}
 		break;
 	}
 	if (libusb_submit_transfer(irq_transfer) < 0)
-		do_exit = 2;
+		goto err_free_transfer;
+
+	return;
+
+err_free_transfer:
+	libusb_free_transfer(transfer);
+	irq_transfer = NULL;
+	request_exit(2);
 }
 
 static void LIBUSB_CALL cb_img(struct libusb_transfer *transfer)
 {
 	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
 		fprintf(stderr, "img transfer status %d?\n", transfer->status);
-		do_exit = 2;
-		libusb_free_transfer(transfer);
-		img_transfer = NULL;
-		return;
+		goto err_free_transfer;
 	}
 
 	printf("Image callback\n");
 	save_to_file(imgbuf);
-	if (next_state() < 0) {
-		do_exit = 2;
-		return;
-	}
+	if (next_state() < 0)
+		goto err_free_transfer;
+
 	if (libusb_submit_transfer(img_transfer) < 0)
-		do_exit = 2;
+		goto err_free_transfer;
+
+	return;
+
+err_free_transfer:
+	libusb_free_transfer(transfer);
+	img_transfer = NULL;
+	request_exit(2);
 }
 
 static int init_capture(void)
@@ -394,12 +554,16 @@ static int do_init(void)
 static int alloc_transfers(void)
 {
 	img_transfer = libusb_alloc_transfer(0);
-	if (!img_transfer)
-		return -ENOMEM;
+	if (!img_transfer) {
+		errno = ENOMEM;
+		return -1;
+	}
 
 	irq_transfer = libusb_alloc_transfer(0);
-	if (!irq_transfer)
-		return -ENOMEM;
+	if (!irq_transfer) {
+		errno = ENOMEM;
+		return -1;
+	}
 
 	libusb_fill_bulk_transfer(img_transfer, devh, EP_DATA, imgbuf,
 		sizeof(imgbuf), cb_img, NULL, 0);
@@ -413,17 +577,33 @@ static void sighandler(int signum)
 {
 	(void)signum;
 
-	do_exit = 1;
+	request_exit(1);
 }
 
-int main(void)
+static void setup_signals(void)
 {
+#if defined(PLATFORM_POSIX)
 	struct sigaction sigact;
+
+	sigact.sa_handler = sighandler;
+	sigemptyset(&sigact.sa_mask);
+	sigact.sa_flags = 0;
+	(void)sigaction(SIGINT, &sigact, NULL);
+	(void)sigaction(SIGTERM, &sigact, NULL);
+	(void)sigaction(SIGQUIT, &sigact, NULL);
+#else
+	(void)signal(SIGINT, sighandler);
+	(void)signal(SIGTERM, sighandler);
+#endif
+}
+
+int main(void)
+{
 	int r;
 
 	r = libusb_init(NULL);
 	if (r < 0) {
-		fprintf(stderr, "failed to initialise libusb\n");
+		fprintf(stderr, "failed to initialise libusb %d - %s\n", r, libusb_strerror(r));
 		exit(1);
 	}
 
@@ -435,7 +615,7 @@ int main(void)
 
 	r = libusb_claim_interface(devh, 0);
 	if (r < 0) {
-		fprintf(stderr, "usb_claim_interface error %d\n", r);
+		fprintf(stderr, "claim interface error %d - %s\n", r, libusb_strerror(r));
 		goto out;
 	}
 	printf("claimed interface\n");
@@ -449,45 +629,66 @@ int main(void)
 		goto out_deinit;
 
 	/* async from here onwards */
+	setup_signals();
 
 	r = alloc_transfers();
 	if (r < 0)
 		goto out_deinit;
 
+#if defined(DPFP_THREADED)
+	exit_semaphore = semaphore_create();
+	if (!exit_semaphore) {
+		fprintf(stderr, "failed to initialise semaphore\n");
+		goto out_deinit;
+	}
+
+	r = thread_create(&poll_thread, poll_thread_main, NULL);
+	if (r) {
+		semaphore_destroy(exit_semaphore);
+		goto out_deinit;
+	}
+
 	r = init_capture();
 	if (r < 0)
-		goto out_deinit;
+		request_exit(2);
 
-	sigact.sa_handler = sighandler;
-	sigemptyset(&sigact.sa_mask);
-	sigact.sa_flags = 0;
-	sigaction(SIGINT, &sigact, NULL);
-	sigaction(SIGTERM, &sigact, NULL);
-	sigaction(SIGQUIT, &sigact, NULL);
+	while (!do_exit)
+		semaphore_take(exit_semaphore);
+#else
+	r = init_capture();
+	if (r < 0)
+		goto out_deinit;
 
 	while (!do_exit) {
 		r = libusb_handle_events(NULL);
 		if (r < 0)
-			goto out_deinit;
+			request_exit(2);
 	}
+#endif
 
 	printf("shutting down...\n");
 
-	if (irq_transfer) {
-		r = libusb_cancel_transfer(irq_transfer);
-		if (r < 0)
-			goto out_deinit;
-	}
+#if defined(DPFP_THREADED)
+	thread_join(poll_thread);
+	semaphore_destroy(exit_semaphore);
+#endif
 
 	if (img_transfer) {
 		r = libusb_cancel_transfer(img_transfer);
 		if (r < 0)
-			goto out_deinit;
+			fprintf(stderr, "failed to cancel transfer %d - %s\n", r, libusb_strerror(r));
 	}
 
-	while (irq_transfer || img_transfer)
+	if (irq_transfer) {
+		r = libusb_cancel_transfer(irq_transfer);
+		if (r < 0)
+			fprintf(stderr, "failed to cancel transfer %d - %s\n", r, libusb_strerror(r));
+	}
+
+	while (img_transfer || irq_transfer) {
 		if (libusb_handle_events(NULL) < 0)
 			break;
+	}
 
 	if (do_exit == 1)
 		r = 0;
@@ -495,8 +696,10 @@ int main(void)
 		r = 1;
 
 out_deinit:
-	libusb_free_transfer(img_transfer);
-	libusb_free_transfer(irq_transfer);
+	if (img_transfer)
+		libusb_free_transfer(img_transfer);
+	if (irq_transfer)
+		libusb_free_transfer(irq_transfer);
 	set_mode(0);
 	set_hwstat(0x80);
 out_release:

package/libusb/examples/ezusb.c

@@ -20,6 +20,9 @@
  *    along with this program; if not, write to the Free Software
  *    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
  */
+
+#include <config.h>
+
 #include <stdio.h>
 #include <errno.h>
 #include <stdlib.h>
@@ -29,9 +32,6 @@
 #include "libusb.h"
 #include "ezusb.h"
 
-extern void logerror(const char *format, ...)
-	__attribute__ ((format(printf, 1, 2)));
-
 /*
  * This file contains functions for uploading firmware into Cypress
  * EZ-USB microcontrollers. These chips use control endpoint 0 and vendor
@@ -139,7 +139,11 @@ static int ezusb_write(libusb_device_handle *device, const char *label,
 		else
 			logerror("%s ==> %d\n", label, status);
 	}
-	return (status < 0) ? -EIO : 0;
+	if (status < 0) {
+		errno = EIO;
+		return -1;
+	}
+	return 0;
 }
 
 /*
@@ -162,7 +166,11 @@ static int ezusb_read(libusb_device_handle *device, const char *label,
 		else
 			logerror("%s ==> %d\n", label, status);
 	}
-	return (status < 0) ? -EIO : 0;
+	if (status < 0) {
+		errno = EIO;
+		return -1;
+	}
+	return 0;
 }
 
 /*
@@ -195,7 +203,7 @@ static bool ezusb_cpucs(libusb_device_handle *device, uint32_t addr, bool doRun)
 }
 
 /*
- * Send an FX3 jumpt to address command
+ * Send an FX3 jump to address command
  * Returns false on error.
  */
 static bool ezusb_fx3_jump(libusb_device_handle *device, uint32_t addr)
@@ -514,7 +522,8 @@ static int ram_poke(void *context, uint32_t addr, bool external,
 		if (external) {
 			logerror("can't write %u bytes external memory at 0x%08x\n",
 				(unsigned)len, addr);
-			return -EINVAL;
+			errno = EINVAL;
+			return -1;
 		}
 		break;
 	case skip_internal:		/* CPU must be running */
@@ -538,7 +547,8 @@ static int ram_poke(void *context, uint32_t addr, bool external,
 	case _undef:
 	default:
 		logerror("bug\n");
-		return -EDOM;
+		errno = EDOM;
+		return -1;
 	}
 
 	ctx->total += len;