lib: Generate driver IDs, instead of hard-coding them

Instead of adding driver IDs by hand to a header file, generate the
driver ID from the (hopefully unique) name of the driver.

This means one file less for driver authors to modify, and one possible
source of merge conflicts less as well.

However, this means that already enrolled fingerprints will need to be
enrolled again, as the driver IDs will have changed compared to their
old on-disk value.

doc/advanced-topics.xml

@@ -71,10 +71,7 @@
     <title>Driver IDs</title>
 
     <para>
-    Each driver is assigned a unique ID by the project maintainer. These
+    Each driver is assigned a unique ID automatically based on the driver name.
-    assignments are
-    <ulink url="https://gitlab.freedesktop.org/libfprint/libfprint/blob/master/libfprint/drivers/driver_ids.h">
-    documented in the sources</ulink> and will never change.
     </para>
 
     <para>

doc/meson.build

@@ -17,7 +17,6 @@ private_headers = [
   'aes2660.h',
   'aes3k.h',
   'aesx660.h',
-  'driver_ids.h',
   'elan.h',
   'upek_proto.h',
   'upeksonly.h',

examples/enroll.c

@@ -24,8 +24,6 @@
 
 #include <libfprint/fprint.h>
 
-#include "storage.h"
-
 struct fp_dscv_dev *discover_device(struct fp_dscv_dev **discovered_devs)
 {
 	struct fp_dscv_dev *ddev = discovered_devs[0];
@@ -144,7 +142,10 @@ int main(void)
 	if (!data)
 		goto out_close;
 
-	r = print_data_save(data, RIGHT_INDEX);
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+	r = fp_print_data_save(data, RIGHT_INDEX);
+#pragma GCC diagnostic pop
 	if (r < 0)
 		fprintf(stderr, "Data save failed, code %d\n", r);
 

examples/meson.build

@@ -2,8 +2,8 @@
 examples = [ 'verify_live', 'enroll', 'verify', 'img_capture' ]
 foreach example: examples
     executable(example,
-               [example + '.c', 'storage.c'],
+               example + '.c',
-               dependencies: [libfprint_dep, glib_dep],
+               dependencies: libfprint_dep,
                include_directories: [
                  root_inc,
                ],

examples/storage.c

@@ -1,136 +0,0 @@
-/*
- * Trivial storage driver for example programs
- *
- * Copyright (C) 2019 Benjamin Berg <bberg@redhat.com>
- *
- * 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 <glib.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#include <libfprint/fprint.h>
-
-#define STORAGE_FILE "test-storage.variant"
-
-static char *
-get_print_data_descriptor (struct fp_print_data *data, struct fp_dev *dev, enum fp_finger finger)
-{
-	gint drv_id;
-	gint devtype;
-
-	if (data) {
-		drv_id = fp_print_data_get_driver_id (data);
-		devtype = fp_print_data_get_devtype (data);
-	} else {
-		drv_id = fp_driver_get_driver_id(fp_dev_get_driver (dev));
-		devtype = fp_dev_get_devtype (dev);
-	}
-
-	return g_strdup_printf("%x/%08x/%x",
-			       drv_id,
-			       devtype,
-			       finger);
-}
-
-static GVariantDict*
-load_data(void)
-{
-	GVariantDict *res;
-	GVariant *var;
-	gchar *contents = NULL;
-	gssize length = 0;
-
-	if (!g_file_get_contents (STORAGE_FILE, &contents, &length, NULL)) {
-		g_warning ("Error loading storage, assuming it is empty");
-		return g_variant_dict_new(NULL);
-	}
-
-	var = g_variant_new_from_data (G_VARIANT_TYPE_VARDICT, contents, length, FALSE, NULL, NULL);
-
-	res = g_variant_dict_new(var);
-	g_variant_unref(var);
-	return res;
-}
-
-static int
-save_data(GVariant *data)
-{
-	const gchar *contents = NULL;
-	gsize length;
-
-	length = g_variant_get_size(data);
-	contents = (gchar*) g_variant_get_data (data);
-
-	if (!g_file_set_contents (STORAGE_FILE, contents, length, NULL)) {
-		g_warning ("Error saving storage,!");
-		return -1;
-	}
-
-	g_variant_ref_sink(data);
-	g_variant_unref(data);
-
-	return 0;
-}
-
-int
-print_data_save(struct fp_print_data *fp_data, enum fp_finger finger)
-{
-	gchar *descr = get_print_data_descriptor (fp_data, NULL, finger);
-	GVariantDict *dict;
-	GVariant *val;
-	guchar *data;
-	gsize size;
-	int res;
-
-	dict = load_data();
-
-	size = fp_print_data_get_data(fp_data, &data);
-	val = g_variant_new_fixed_array (G_VARIANT_TYPE("y"), data, size, 1);
-	g_variant_dict_insert_value (dict, descr, val);
-
-	res = save_data(g_variant_dict_end(dict));
-	g_variant_dict_unref(dict);
-
-	return res;
-}
-
-struct fp_print_data*
-print_data_load(struct fp_dev *dev, enum fp_finger finger)
-{
-	gchar *descr = get_print_data_descriptor (NULL, dev, finger);
-	GVariantDict *dict;
-	guchar *stored_data;
-	gsize stored_len;
-	GVariant *val;
-	struct fp_print_data *res = NULL;
-
-	dict = load_data();
-	val = g_variant_dict_lookup_value (dict, descr, G_VARIANT_TYPE ("ay"));
-
-	if (val) {
-		stored_data = (guchar*) g_variant_get_fixed_array (val, &stored_len, 1);
-		res = fp_print_data_from_data(stored_data, stored_len);
-
-		g_variant_unref(val);
-	}
-
-	g_variant_dict_unref(dict);
-	g_free(descr);
-
-	return res;
-}

examples/storage.h

@@ -1,27 +0,0 @@
-/*
- * Trivial storage driver for example programs
- *
- * Copyright (C) 2019 Benjamin Berg <bberg@redhat.com>
- *
- * 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
- */
-
-#ifndef __STORAGE_H
-#define __STORAGE_H
-
-int print_data_save(struct fp_print_data *fp_data, enum fp_finger finger);
-struct fp_print_data* print_data_load(struct fp_dev *dev, enum fp_finger finger);
-
-#endif /* __STORAGE_H */

examples/verify.c

@@ -24,8 +24,6 @@
 
 #include <libfprint/fprint.h>
 
-#include "storage.h"
-
 struct fp_dscv_dev *discover_device(struct fp_dscv_dev **discovered_devs)
 {
 	struct fp_dscv_dev *ddev = discovered_devs[0];
@@ -119,8 +117,11 @@ int main(void)
 	printf("Opened device. Loading previously enrolled right index finger "
 		"data...\n");
 
-	data = print_data_load(dev, RIGHT_INDEX);
+#pragma GCC diagnostic push
-	if (!data) {
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+	r = fp_print_data_load(dev, RIGHT_INDEX, &data);
+#pragma GCC diagnostic pop
+	if (r != 0) {
 		fprintf(stderr, "Failed to load fingerprint, error %d\n", r);
 		fprintf(stderr, "Did you remember to enroll your right index finger "
 			"first?\n");

libfprint/drivers/aes1610.c

@@ -749,7 +749,7 @@ static void activate_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_d
 	fpi_ssm_free(ssm);
 }
 
-static int dev_activate(struct fp_img_dev *dev)
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
 {
 	struct aes1610_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
 	fpi_ssm *ssm = fpi_ssm_new(FP_DEV(dev), activate_run_state,
@@ -817,7 +817,6 @@ static const struct usb_id id_table[] = {
 
 struct fp_img_driver aes1610_driver = {
 	.driver = {
-		.id = AES1610_ID,
 		.name = FP_COMPONENT,
 		.full_name = "AuthenTec AES1610",
 		.id_table = id_table,

libfprint/drivers/aes1660.c

@@ -94,7 +94,6 @@ static const struct usb_id id_table[] = {
 
 struct fp_img_driver aes1660_driver = {
 	.driver = {
-		.id = AES1660_ID,
 		.name = FP_COMPONENT,
 		.full_name = "AuthenTec AES1660",
 		.id_table = id_table,

libfprint/drivers/aes2501.c

@@ -792,7 +792,7 @@ static void activate_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_d
 	fpi_ssm_free(ssm);
 }
 
-static int dev_activate(struct fp_img_dev *dev)
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
 {
 	struct aes2501_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
 	fpi_ssm *ssm = fpi_ssm_new(FP_DEV(dev), activate_run_state,
@@ -859,7 +859,6 @@ static const struct usb_id id_table[] = {
 
 struct fp_img_driver aes2501_driver = {
 	.driver = {
-		.id = AES2501_ID,
 		.name = FP_COMPONENT,
 		.full_name = "AuthenTec AES2501",
 		.id_table = id_table,

libfprint/drivers/aes2550.c

@@ -541,7 +541,7 @@ static void activate_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_d
 	fpi_ssm_free(ssm);
 }
 
-static int dev_activate(struct fp_img_dev *dev)
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
 {
 	fpi_ssm *ssm = fpi_ssm_new(FP_DEV(dev), activate_run_state,
 		ACTIVATE_NUM_STATES, dev);
@@ -603,7 +603,6 @@ static const struct usb_id id_table[] = {
 
 struct fp_img_driver aes2550_driver = {
 	.driver = {
-		.id = AES2550_ID,
 		.name = FP_COMPONENT,
 		.full_name = "AuthenTec AES2550/AES2810",
 		.id_table = id_table,

libfprint/drivers/aes2660.c

@@ -97,7 +97,6 @@ static const struct usb_id id_table[] = {
 
 struct fp_img_driver aes2660_driver = {
 	.driver = {
-		.id = AES2660_ID,
 		.name = FP_COMPONENT,
 		.full_name = "AuthenTec AES2660",
 		.id_table = id_table,

libfprint/drivers/aes3500.c

@@ -162,7 +162,6 @@ static const struct usb_id id_table[] = {
 
 struct fp_img_driver aes3500_driver = {
 	.driver = {
-		.id = AES3500_ID,
 		.name = FP_COMPONENT,
 		.full_name = "AuthenTec AES3500",
 		.id_table = id_table,

libfprint/drivers/aes3k.c

@@ -137,7 +137,7 @@ static void init_reqs_cb(struct fp_img_dev *dev, int result, void *user_data)
 		do_capture(dev);
 }
 
-int aes3k_dev_activate(struct fp_img_dev *dev)
+int aes3k_dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
 {
 	struct aes3k_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
 	aes_write_regv(dev, aesdev->init_reqs, aesdev->init_reqs_len, init_reqs_cb, NULL);

libfprint/drivers/aes3k.h

@@ -52,7 +52,7 @@ struct aes3k_dev {
 };
 
 
-int aes3k_dev_activate(struct fp_img_dev *dev);
+int aes3k_dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state);
 void aes3k_dev_deactivate(struct fp_img_dev *dev);
 
 #endif

libfprint/drivers/aes4000.c

@@ -159,7 +159,6 @@ static const struct usb_id id_table[] = {
 
 struct fp_img_driver aes4000_driver = {
 	.driver = {
-		.id = AES4000_ID,
 		.name = FP_COMPONENT,
 		.full_name = "AuthenTec AES4000",
 		.id_table = id_table,

libfprint/drivers/aesx660.c

@@ -589,7 +589,7 @@ static void activate_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_d
 		start_finger_detection(dev);
 }
 
-int aesX660_dev_activate(struct fp_img_dev *dev)
+int aesX660_dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
 {
 	fpi_ssm *ssm = fpi_ssm_new(FP_DEV(dev), activate_run_state,
 		ACTIVATE_NUM_STATES, dev);

libfprint/drivers/aesx660.h

@@ -116,7 +116,7 @@ static const unsigned char calibrate_cmd[] = {
 	0x06,
 };
 
-int aesX660_dev_activate(struct fp_img_dev *dev);
+int aesX660_dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state);
 void aesX660_dev_deactivate(struct fp_img_dev *dev);
 
 #endif

libfprint/drivers/driver_ids.h

@@ -1,47 +0,0 @@
-/*
- * Driver IDs
- * Copyright (C) 2012 Vasily Khoruzhick <anarsoul@gmail.com>
- *
- * 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
- */
-
-#ifndef __DRIVER_IDS
-#define __DRIVER_IDS
-
-enum {
-	UPEKTS_ID	= 1,
-	URU4000_ID	= 2,
-	AES4000_ID	= 3,
-	AES2501_ID	= 4,
-	UPEKTC_ID	= 5,
-	AES1610_ID	= 6,
-	/* FDU2000_ID	= 7, */
-	VCOM5S_ID	= 8,
-	UPEKSONLY_ID	= 9,
-	VFS101_ID	= 10,
-	VFS301_ID	= 11,
-	AES2550_ID	= 12,
-	/* UPEKE2_ID = 13 */
-	AES1660_ID	= 14,
-	AES2660_ID	= 15,
-	AES3500_ID	= 16,
-	UPEKTC_IMG_ID	= 17,
-	ETES603_ID	= 18,
-	VFS5011_ID	= 19,
-	VFS0050_ID	= 20,
-	ELAN_ID		= 21,
-};
-
-#endif

libfprint/drivers/elan.c

@@ -293,24 +293,23 @@ static void elan_process_frame_thirds(unsigned short *raw_frame,
 static void elan_submit_image(struct fp_img_dev *dev)
 {
 	struct elan_dev *elandev = FP_INSTANCE_DATA(FP_DEV(dev));
-	GSList *input_frames;
 	GSList *frames = NULL;
 	struct fp_img *img;
 
 	G_DEBUG_HERE();
 
-	input_frames = elandev->frames;
 	for (int i = 0; i < ELAN_SKIP_LAST_FRAMES; i++)
-		input_frames = g_slist_next (input_frames);
+		elandev->frames = g_slist_next(elandev->frames);
+	elandev->num_frames -= ELAN_SKIP_LAST_FRAMES;
 
 	assembling_ctx.frame_width = elandev->frame_width;
 	assembling_ctx.frame_height = elandev->frame_height;
 	assembling_ctx.image_width = elandev->frame_width * 3 / 2;
-	g_slist_foreach(input_frames, (GFunc) elandev->process_frame,
+	g_slist_foreach(elandev->frames, (GFunc) elandev->process_frame,
 			&frames);
 	fpi_do_movement_estimation(&assembling_ctx, frames,
 				   elandev->num_frames);
-	img = fpi_assemble_frames(&assembling_ctx, frames, elandev->num_frames - ELAN_SKIP_LAST_FRAMES);
+	img = fpi_assemble_frames(&assembling_ctx, frames, elandev->num_frames);
 
 	img->flags |= FP_IMG_PARTIAL;
 	fpi_imgdev_image_captured(dev, img);
@@ -875,7 +874,7 @@ static void dev_deinit(struct fp_img_dev *dev)
 	fpi_imgdev_close_complete(dev);
 }
 
-static int dev_activate(struct fp_img_dev *dev)
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
 {
 	G_DEBUG_HERE();
 	elan_activate(dev);
@@ -971,7 +970,6 @@ static void dev_deactivate(struct fp_img_dev *dev)
 
 struct fp_img_driver elan_driver = {
 	.driver = {
-		   .id = ELAN_ID,
 		   .name = FP_COMPONENT,
 		   .full_name = "ElanTech Fingerprint Sensor",
 		   .id_table = elan_id_table,

libfprint/drivers/etes603.c

@@ -36,7 +36,6 @@
 #define FP_COMPONENT "etes603"
 
 #include "drivers_api.h"
-#include "driver_ids.h"
 
 /* libusb defines */
 #define EP_IN              0x81
@@ -1390,13 +1389,19 @@ static void m_init_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
 	fpi_ssm_free(ssm);
 }
 
-static int dev_activate(struct fp_img_dev *idev)
+static int dev_activate(struct fp_img_dev *idev, enum fp_imgdev_state state)
 {
 	struct etes603_dev *dev = FP_INSTANCE_DATA(FP_DEV(idev));
 	fpi_ssm *ssm;
 
 	g_assert(dev);
 
+	if (state != IMGDEV_STATE_AWAIT_FINGER_ON) {
+		fp_err("The driver is in an unexpected state: %d.", state);
+		fpi_imgdev_activate_complete(idev, 1);
+		return -1;
+	}
+
 	/* Reset info and data */
 	dev->is_active = TRUE;
 
@@ -1472,7 +1477,6 @@ static const struct usb_id id_table[] = {
 
 struct fp_img_driver etes603_driver = {
 	.driver = {
-		.id = ETES603_ID,
 		.name = FP_COMPONENT,
 		.full_name = "EgisTec ES603",
 		.id_table = id_table,

libfprint/drivers/fdu2000.c

@@ -0,0 +1,317 @@
+/*
+ * Secugen FDU2000 driver for libfprint
+ * Copyright (C) 2007 Gustavo Chain <g@0xff.cl>
+ *
+ * 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
+ */
+
+#define FP_COMPONENT "fdu2000"
+
+#include "drivers_api.h"
+
+#ifndef HAVE_MEMMEM
+gpointer
+memmem(const gpointer haystack, size_t haystack_len, const gpointer needle, size_t needle_len) {
+	const gchar *begin;
+	const char *const last_possible = (const char *) haystack + haystack_len - needle_len;
+
+	/* The first occurrence of the empty string is deemed to occur at 
+	 * the beginning of the string. */
+	if (needle_len == 0)
+		return (void *) haystack;
+	
+	/* Sanity check, otherwise the loop might search through the whole
+	 * memory.  */
+	if (haystack_len < needle_len)
+		return NULL;
+	
+	for (begin = (const char *) haystack; begin <= last_possible; ++begin)
+		if (begin[0] == ((const char *) needle)[0] &&
+			!memcmp((const void *) &begin[1],
+				(const void *) ((const char *) needle + 1),
+				needle_len - 1))
+			return (void *) begin;
+	
+	return NULL;
+}
+#endif	/* HAVE_MEMMEM */
+
+#define EP_IMAGE	( 0x02 | LIBUSB_ENDPOINT_IN )
+#define EP_REPLY	( 0x01 | LIBUSB_ENDPOINT_IN )
+#define EP_CMD		( 0x01 | LIBUSB_ENDPOINT_OUT )
+#define BULK_TIMEOUT	200
+
+/* fdu_req[] index */
+typedef enum {
+	CAPTURE_READY,
+	CAPTURE_READ,
+	CAPTURE_END,
+	LED_OFF,
+	LED_ON
+} req_index;
+
+
+#define CMD_LEN 2
+#define ACK_LEN 8
+static const struct fdu2000_req {
+	const gchar cmd[CMD_LEN];	// Command to send
+	const gchar ack[ACK_LEN];	// Expected ACK
+	const guint ack_len;	// ACK has variable length
+} fdu_req[] = {
+	/* Capture */
+	{
+		.cmd = { 0x00, 0x04 },
+		.ack = { 0x00, 0x04, 0x01, 0x01 },
+		.ack_len = 4
+	},
+	
+	{
+		.cmd = { 0x00, 0x01 },
+		.ack = { 0x00, 0x01, 0x01, 0x01 },
+		.ack_len = 4
+	},
+
+	{
+		.cmd = { 0x00, 0x05 },
+		.ack = { 0x00, 0x05, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01 },
+		.ack_len = 8
+	},
+
+	/* Led */
+	{
+		.cmd = { 0x05, 0x00 },
+		.ack = {},
+		.ack_len = 0
+	},
+
+	{
+		.cmd = { 0x05, 0x01 },
+		.ack = {},
+		.ack_len = 0
+	}
+};
+
+/*
+ * Write a command and verify reponse
+ */
+static gint
+bulk_write_safe(libusb_dev_handle *dev, req_index rIndex) {
+
+	gchar reponse[ACK_LEN];
+	gint r;
+	gchar *cmd = (gchar *)fdu_req[rIndex].cmd;
+	gchar *ack = (gchar *)fdu_req[rIndex].ack;
+	gint ack_len = fdu_req[rIndex].ack_len;
+	struct libusb_bulk_transfer wrmsg = {
+		.endpoint = EP_CMD,
+		.data = cmd,
+		.length = sizeof(cmd),
+	};
+	struct libusb_bulk_transfer readmsg = {
+		.endpoint = EP_REPLY,
+		.data = reponse,
+		.length = sizeof(reponse),
+	};
+	int trf;
+
+	r = libusb_bulk_transfer(dev, &wrmsg, &trf, BULK_TIMEOUT);
+	if (r < 0)
+		return r;
+
+	if (ack_len == 0)
+		return 0;
+
+	/* Check reply from FP */
+	r = libusb_bulk_transfer(dev, &readmsg, &trf, BULK_TIMEOUT);
+	if (r < 0)
+		return r;
+
+	if (!strncmp(ack, reponse, ack_len))
+		return 0;
+	
+	fp_err("Expected different ACK from dev");
+	return 1;	/* Error */
+}
+
+static gint
+capture(struct fp_img_dev *dev, gboolean unconditional,
+	struct fp_img **ret)
+{
+#define RAW_IMAGE_WIDTH		398
+#define RAW_IMAGE_HEIGTH	301
+#define RAW_IMAGE_SIZE		(RAW_IMAGE_WIDTH * RAW_IMAGE_HEIGTH)
+
+	struct fp_img *img = NULL;
+	int bytes, r;
+	const gchar SOF[] = { 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x0c, 0x07 };  // Start of frame
+	const gchar SOL[] = { 0x0f, 0x0f, 0x0f, 0x0f, 0x00, 0x00, 0x0b, 0x06 };  // Start of line + { L L } (L: Line num) (8 nibbles)
+	gchar *buffer = g_malloc0(RAW_IMAGE_SIZE * 6);
+	gchar *image;
+	gchar *p;
+	guint offset;
+	struct libusb_bulk_transfer msg = {
+		.endpoint = EP_IMAGE,
+		.data = buffer,
+		.length = RAW_IMAGE_SIZE * 6,
+	};
+
+	image  = g_malloc0(RAW_IMAGE_SIZE);
+
+	if ((r = bulk_write_safe(fpi_dev_get_usb_dev(FP_DEV(dev)), LED_ON))) {
+		fp_err("Command: LED_ON");
+		goto out;
+	}
+	
+	if ((r = bulk_write_safe(fpi_dev_get_usb_dev(FP_DEV(dev)), CAPTURE_READY))) {
+		fp_err("Command: CAPTURE_READY");
+		goto out;
+	}
+
+read:	
+	if ((r = bulk_write_safe(fpi_dev_get_usb_dev(FP_DEV(dev)), CAPTURE_READ))) {
+		fp_err("Command: CAPTURE_READ");
+		goto out;
+	}
+
+	/* Now we are ready to read from dev */
+
+	r = libusb_bulk_transfer(fpi_dev_get_usb_dev(FP_DEV(dev)), &msg, &bytes, BULK_TIMEOUT * 10);
+	if (r < 0 || bytes < 1)
+		goto read;
+
+	/*
+	 * Find SOF (start of line)
+	 */
+	p = memmem(buffer, RAW_IMAGE_SIZE * 6,
+			(const gpointer)SOF, sizeof SOF);
+	fp_dbg("Read %d byte/s from dev", bytes);
+	if (!p)
+		goto out;
+
+	p += sizeof SOF;
+
+	int i = 0;
+	bytes = 0;
+	while(p) {
+		if ( i >= RAW_IMAGE_HEIGTH )
+			break;
+
+		offset = p - buffer;
+		p = memmem(p, (RAW_IMAGE_SIZE * 6) - (offset),
+				(const gpointer)SOL, sizeof SOL);
+		if (p) {
+			p += sizeof SOL + 4;
+			int j;
+			for (j = 0; j < RAW_IMAGE_WIDTH; j++) {
+				/*
+				 * Convert from 4 to 8 bits
+				 * The SECUGEN-FDU2000 has 4 lines of data, so we need to join 2 bytes into 1
+				 */
+				*(image + bytes + j)  = *(p + (j * 2) + 0) << 4 & 0xf0;
+				*(image + bytes + j) |= *(p + (j * 2) + 1) & 0x0f;
+			}
+			p += RAW_IMAGE_WIDTH * 2;
+			bytes += RAW_IMAGE_WIDTH;
+			i++;
+		}
+	}
+
+	if ((r = bulk_write_safe(fpi_dev_get_usb_dev(FP_DEV(dev)), CAPTURE_END))) {
+		fp_err("Command: CAPTURE_END");
+		goto out;
+	}
+
+	if ((r = bulk_write_safe(fpi_dev_get_usb_dev(FP_DEV(dev)), LED_OFF))) {
+		fp_err("Command: LED_OFF");
+		goto out;
+	}
+
+	img = fpi_img_new_for_imgdev(dev);
+	memcpy(img->data, image, RAW_IMAGE_SIZE);
+	img->flags = FP_IMG_COLORS_INVERTED | FP_IMG_V_FLIPPED | FP_IMG_H_FLIPPED;
+	*ret = img;
+
+out:
+	g_free(buffer);
+	g_free(image);
+
+	return r;
+}
+
+static
+gint dev_init(struct fp_img_dev *dev, unsigned long driver_data)
+{
+	gint r;
+	//if ( (r = usb_set_configuration(fpi_dev_get_usb_dev(FP_DEV(dev)), 1)) < 0 )
+	//	goto out;
+
+	if ( (r = libusb_claim_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0)) < 0 ) {
+		fp_err("could not claim interface 0: %s", libusb_error_name(r));
+		return r;
+	}
+
+	//if ( (r = usb_set_altinterface(fpi_dev_get_usb_dev(FP_DEV(dev)), 1)) < 0 )
+	//	goto out;
+
+	//if ( (r = usb_clear_halt(fpi_dev_get_usb_dev(FP_DEV(dev)), EP_CMD)) < 0 )
+	//	goto out;
+
+	/* Make sure sensor mode is not capture_{ready|read} */
+	if ((r = bulk_write_safe(fpi_dev_get_usb_dev(FP_DEV(dev)), CAPTURE_END))) {
+		fp_err("Command: CAPTURE_END");
+		goto out;
+	}
+
+	if ((r = bulk_write_safe(fpi_dev_get_usb_dev(FP_DEV(dev)), LED_OFF))) {
+		fp_err("Command: LED_OFF");
+		goto out;
+	}
+
+	return 0;
+
+out:
+	fp_err("could not init dev");
+	return r;
+}
+
+static
+void dev_exit(struct fp_img_dev *dev)
+{
+	if (bulk_write_safe(fpi_dev_get_usb_dev(FP_DEV(dev)), CAPTURE_END))
+		fp_err("Command: CAPTURE_END");
+
+	libusb_release_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
+}
+
+static const struct usb_id id_table[] = {
+	{ .vendor = 0x1162, .product = 0x0300 },
+	{ 0, 0, 0, },
+};
+
+struct fp_img_driver fdu2000_driver = {
+	.driver = {
+		.name = FP_COMPONENT,
+		.full_name = "Secugen FDU 2000",
+		.id_table = id_table,
+		.scan_type = FP_SCAN_TYPE_PRESS,
+	},
+	.img_height = RAW_IMAGE_HEIGTH,
+	.img_width = RAW_IMAGE_WIDTH,
+	.bz3_threshold = 23,
+
+	.init = dev_init,
+	.exit = dev_exit,
+	.capture = capture,
+};

libfprint/drivers/upeksonly.c

@@ -1268,7 +1268,7 @@ static void initsm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
 	fpi_ssm_start(sdev->loopsm, loopsm_complete);
 }
 
-static int dev_activate(struct fp_img_dev *dev)
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
 {
 	struct sonly_dev *sdev = FP_INSTANCE_DATA(FP_DEV(dev));
 	fpi_ssm *ssm = NULL;
@@ -1345,7 +1345,6 @@ static const struct usb_id id_table[] = {
 
 struct fp_img_driver upeksonly_driver = {
 	.driver = {
-		.id = UPEKSONLY_ID,
 		.name = FP_COMPONENT,
 		.full_name = "UPEK TouchStrip Sensor-Only",
 		.id_table = id_table,

libfprint/drivers/upektc.c

@@ -377,7 +377,7 @@ static void start_capture(struct fp_img_dev *dev)
 	fpi_ssm_start(ssm, capture_sm_complete);
 }
 
-static int dev_activate(struct fp_img_dev *dev)
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
 {
 	struct upektc_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
 	fpi_ssm *ssm = fpi_ssm_new(FP_DEV(dev), activate_run_state,
@@ -460,7 +460,6 @@ static const struct usb_id id_table[] = {
 
 struct fp_img_driver upektc_driver = {
 	.driver = {
-		.id = UPEKTC_ID,
 		.name = FP_COMPONENT,
 		.full_name = "UPEK TouchChip/Eikon Touch 300",
 		.id_table = id_table,

libfprint/drivers/upektc_img.c

@@ -567,7 +567,7 @@ static void activate_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_d
 		start_capture(dev);
 }
 
-static int dev_activate(struct fp_img_dev *dev)
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
 {
 	struct upektc_img_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
 	fpi_ssm *ssm = fpi_ssm_new(FP_DEV(dev), activate_run_state,
@@ -628,7 +628,6 @@ static const struct usb_id id_table[] = {
 
 struct fp_img_driver upektc_img_driver = {
 	.driver = {
-		.id = UPEKTC_IMG_ID,
 		.name = FP_COMPONENT,
 		.full_name = "Upek TouchChip Fingerprint Coprocessor",
 		.id_table = id_table,

libfprint/drivers/upekts.c

@@ -1421,7 +1421,6 @@ static const struct usb_id id_table[] = {
 };
 
 struct fp_driver upekts_driver = {
-	.id = UPEKTS_ID,
 	.name = FP_COMPONENT,
 	.full_name = "UPEK TouchStrip",
 	.id_table = id_table,

libfprint/drivers/uru4000.c

@@ -1161,10 +1161,20 @@ static void activate_initsm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *us
 	int r = fpi_ssm_get_error(ssm);
 	fpi_ssm_free(ssm);
 
+	if (r) {
+		fpi_imgdev_activate_complete(dev, r);
+		return;
+	}
+
+	r = execute_state_change(dev);
 	fpi_imgdev_activate_complete(dev, r);
 }
 
-static int dev_activate(struct fp_img_dev *dev)
+/* FIXME: having state parameter here is kinda useless, will we ever
+ * see a scenario where the parameter is useful so early on in the activation
+ * process? asynchronity means that it'll only be used in a later function
+ * call. */
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
 {
 	struct uru4k_dev *urudev = FP_INSTANCE_DATA(FP_DEV(dev));
 	fpi_ssm *ssm;
@@ -1175,6 +1185,7 @@ static int dev_activate(struct fp_img_dev *dev)
 		return r;
 
 	urudev->scanpwr_irq_timeouts = 0;
+	urudev->activate_state = state;
 	ssm = fpi_ssm_new(FP_DEV(dev), init_run_state, INIT_NUM_STATES, dev);
 	fpi_ssm_start(ssm, activate_initsm_complete);
 	return 0;
@@ -1417,7 +1428,6 @@ static const struct usb_id id_table[] = {
 
 struct fp_img_driver uru4000_driver = {
 	.driver = {
-		.id = URU4000_ID,
 		.name = FP_COMPONENT,
 		.full_name = "Digital Persona U.are.U 4000/4000B/4500",
 		.id_table = id_table,

libfprint/drivers/vcom5s.c

@@ -302,7 +302,7 @@ static void loopsm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
 		fpi_imgdev_deactivate_complete(dev);
 }
 
-static int dev_activate(struct fp_img_dev *dev)
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
 {
 	struct v5s_dev *vdev = FP_INSTANCE_DATA(FP_DEV(dev));
 	fpi_ssm *ssm = fpi_ssm_new(FP_DEV(dev), loop_run_state,
@@ -357,7 +357,6 @@ static const struct usb_id id_table[] = {
 
 struct fp_img_driver vcom5s_driver = {
 	.driver = {
-		.id = VCOM5S_ID,
 		.name = FP_COMPONENT,
 		.full_name = "Veridicom 5thSense",
 		.id_table = id_table,

libfprint/drivers/vfs0050.c

@@ -684,7 +684,7 @@ static void dev_activate_callback(fpi_ssm *ssm, struct fp_dev *_dev, void *user_
 }
 
 /* Activate device */
-static int dev_activate(struct fp_img_dev *idev)
+static int dev_activate(struct fp_img_dev *idev, enum fp_imgdev_state state)
 {
 	struct vfs_dev_t *vdev = FP_INSTANCE_DATA(FP_DEV(idev));
 
@@ -770,7 +770,6 @@ static const struct usb_id id_table[] = {
 struct fp_img_driver vfs0050_driver = {
 	/* Driver specification */
 	.driver = {
-		   .id = VFS0050_ID,
 		   .name = FP_COMPONENT,
 		   .full_name = "Validity VFS0050",
 		   .id_table = id_table,

libfprint/drivers/vfs101.c

@@ -1424,7 +1424,7 @@ static void m_init_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
 }
 
 /* Activate device */
-static int dev_activate(struct fp_img_dev *dev)
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
 {
 	struct vfs101_dev *vdev = FP_INSTANCE_DATA(FP_DEV(dev));
 	fpi_ssm *ssm;
@@ -1526,7 +1526,6 @@ struct fp_img_driver vfs101_driver =
 	/* Driver specification */
 	.driver =
 	{
-		.id = VFS101_ID,
 		.name = FP_COMPONENT,
 		.full_name = "Validity VFS101",
 		.id_table = id_table,

libfprint/drivers/vfs301.c

@@ -191,7 +191,7 @@ static void m_init_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
 }
 
 /* Activate device */
-static int dev_activate(struct fp_img_dev *dev)
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
 {
 	fpi_ssm *ssm;
 
@@ -268,7 +268,6 @@ struct fp_img_driver vfs301_driver =
 	/* Driver specification */
 	.driver =
 	{
-		.id = VFS301_ID,
 		.name = FP_COMPONENT,
 		.full_name = "Validity VFS301",
 		.id_table = id_table,

libfprint/drivers/vfs5011.c

@@ -846,7 +846,7 @@ static void start_scan(struct fp_img_dev *dev)
 	fp_dbg("ssm done, getting out");
 }
 
-static int dev_activate(struct fp_img_dev *dev)
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
 {
 	struct vfs5011_data *data;
 
@@ -887,7 +887,6 @@ static const struct usb_id id_table[] = {
 
 struct fp_img_driver vfs5011_driver = {
 	.driver = {
-		.id = VFS5011_ID,
 		.name = "vfs5011",
 		.full_name = "Validity VFS5011",
 		.id_table = id_table,

libfprint/drivers_api.h

@@ -34,6 +34,5 @@
 #include "fpi-usb.h"
 #include "fpi-img.h"
 #include "fpi-assembling.h"
-#include "drivers/driver_ids.h"
 
 #endif

libfprint/fp_internal.h

@@ -35,7 +35,6 @@
 #include "fpi-dev-img.h"
 #include "fpi-data.h"
 #include "fpi-img.h"
-#include "drivers/driver_ids.h"
 
 /* Global variables */
 extern libusb_context *fpi_usb_ctx;
@@ -145,8 +144,6 @@ struct fp_img_dev {
 	size_t identify_match_offset;
 };
 
-/* fp_driver structure definition */
-
 /* fp_img_driver structure definition */
 #define container_of(ptr, type, member) ({                      \
         const typeof( ((type *)0)->member ) *__mptr = (ptr);    \

libfprint/fpi-core.c

@@ -137,10 +137,13 @@ GSList *opened_devices = NULL;
 
 static GSList *registered_drivers = NULL;
 
+#define DRV_ID(drv) g_str_hash(drv->name)
+
 static void register_driver(struct fp_driver *drv)
 {
-	if (drv->id == 0) {
+	if (drv->name == NULL ||
-		fp_err("not registering driver %s: driver ID is 0", drv->name);
+	    strlen(drv->name) <= 2) {
+		fp_err("not registering driver %s, name is too short or absent", drv->name);
 		return;
 	}
 	registered_drivers = g_slist_prepend(registered_drivers, (gpointer) drv);
@@ -411,7 +414,7 @@ API_EXPORTED int fp_dscv_dev_supports_print_data(struct fp_dscv_dev *dev,
 	g_return_val_if_fail(dev, 0);
 	g_return_val_if_fail(print, 0);
 
-	return fpi_print_data_compatible(dev->drv->id, dev->devtype,
+	return fpi_print_data_compatible(DRV_ID(dev->drv), dev->devtype,
 		fpi_driver_get_data_type(dev->drv), print->driver_id, print->devtype,
 		print->type);
 }
@@ -434,7 +437,7 @@ API_EXPORTED int fp_dscv_dev_supports_dscv_print(struct fp_dscv_dev *dev,
 	g_return_val_if_fail(dev, 0);
 	g_return_val_if_fail(print, 0);
 
-	return fpi_print_data_compatible(dev->drv->id, dev->devtype, 0,
+	return fpi_print_data_compatible(DRV_ID(dev->drv), dev->devtype, 0,
 		print->driver_id, print->devtype, 0);
 }
 
@@ -559,7 +562,7 @@ API_EXPORTED int fp_dev_supports_print_data(struct fp_dev *dev,
 	g_return_val_if_fail(dev, 0);
 	g_return_val_if_fail(data, 0);
 
-	return fpi_print_data_compatible(dev->drv->id, dev->devtype,
+	return fpi_print_data_compatible(DRV_ID(dev->drv), dev->devtype,
 		fpi_driver_get_data_type(dev->drv), data->driver_id, data->devtype,
 		data->type);
 }
@@ -582,7 +585,7 @@ API_EXPORTED int fp_dev_supports_dscv_print(struct fp_dev *dev,
 	g_return_val_if_fail(dev, 0);
 	g_return_val_if_fail(print, 0);
 
-	return fpi_print_data_compatible(dev->drv->id, dev->devtype,
+	return fpi_print_data_compatible(DRV_ID(dev->drv), dev->devtype,
 		0, print->driver_id, print->devtype, 0);
 }
 
@@ -628,7 +631,7 @@ API_EXPORTED uint16_t fp_driver_get_driver_id(struct fp_driver *drv)
 {
 	g_return_val_if_fail(drv, 0);
 
-	return drv->id;
+	return DRV_ID(drv);
 }
 
 /**

libfprint/fpi-core.h

@@ -68,7 +68,6 @@ enum fp_driver_type {
 };
 
 struct fp_driver {
-	const uint16_t id;
 	const char *name;
 	const char *full_name;
 	const struct usb_id * const id_table;
@@ -110,7 +109,7 @@ struct fp_img_driver {
 	/* Device operations */
 	int (*open)(struct fp_img_dev *dev, unsigned long driver_data);
 	void (*close)(struct fp_img_dev *dev);
-	int (*activate)(struct fp_img_dev *dev);
+	int (*activate)(struct fp_img_dev *dev, enum fp_imgdev_state state);
 	int (*change_state)(struct fp_img_dev *dev, enum fp_imgdev_state state);
 	void (*deactivate)(struct fp_img_dev *dev);
 };

libfprint/fpi-data.c

@@ -148,7 +148,7 @@ struct fp_print_data_item *fpi_print_data_item_new(size_t length)
 
 struct fp_print_data *fpi_print_data_new(struct fp_dev *dev)
 {
-	return print_data_new(dev->drv->id, dev->devtype,
+	return print_data_new(fp_driver_get_driver_id(dev->drv), dev->devtype,
 		fpi_driver_get_data_type(dev->drv));
 }
 
@@ -349,7 +349,7 @@ static char *__get_path_to_print(uint16_t driver_id, uint32_t devtype,
 
 static char *get_path_to_print(struct fp_dev *dev, enum fp_finger finger)
 {
-	return __get_path_to_print(dev->drv->id, dev->devtype, finger);
+	return __get_path_to_print(fp_driver_get_driver_id(dev->drv), dev->devtype, finger);
 }
 
 /**

libfprint/fpi-dev-img.c

@@ -533,14 +533,14 @@ int fpi_imgdev_get_img_height(struct fp_img_dev *imgdev)
 	return height;
 }
 
-static int dev_activate(struct fp_img_dev *imgdev)
+static int dev_activate(struct fp_img_dev *imgdev, enum fp_imgdev_state state)
 {
 	struct fp_driver *drv = FP_DEV(imgdev)->drv;
 	struct fp_img_driver *imgdrv = fpi_driver_to_img_driver(drv);
 
 	if (!imgdrv->activate)
 		return 0;
-	return imgdrv->activate(imgdev);
+	return imgdrv->activate(imgdev, state);
 }
 
 static void dev_deactivate(struct fp_img_dev *imgdev)
@@ -562,7 +562,7 @@ static int generic_acquire_start(struct fp_dev *dev, int action)
 	imgdev->action_state = IMG_ACQUIRE_STATE_ACTIVATING;
 	imgdev->enroll_stage = 0;
 
-	r = dev_activate(imgdev);
+	r = dev_activate(imgdev, IMGDEV_STATE_AWAIT_FINGER_ON);
 	if (r < 0)
 		fp_err("activation failed with error %d", r);
 

libfprint/meson.build

@@ -97,6 +97,9 @@ foreach driver: drivers
         aeslib = true
         aes3k = true
     endif
+    if driver == 'fdu2000'
+        drivers_sources += [ 'drivers/fdu2000.c' ]
+    endif
     if driver == 'vcom5s'
         drivers_sources += [ 'drivers/vcom5s.c' ]
     endif

meson.build

@@ -27,9 +27,7 @@ common_cflags = cc.get_supported_arguments([
     '-Wstrict-prototypes',
     '-Werror-implicit-function-declaration',
     '-Wno-pointer-sign',
-    '-Wshadow',
+    '-Wshadow'
-    '-DGLIB_VERSION_MIN_REQUIRED=GLIB_VERSION_2_50',
-    '-DGLIB_VERSION_MAX_ALLOWED=GLIB_VERSION_2_50',
 ])
 
 # maintaining compatibility with the previous libtool versioning
@@ -41,7 +39,7 @@ revision = 0
 libversion = '@0@.@1@.@2@'.format(soversion, current, revision)
 
 # Dependencies
-glib_dep = dependency('glib-2.0', version: '>= 2.50')
+glib_dep = dependency('glib-2.0', version: '>= 2.28')
 libusb_dep = dependency('libusb-1.0', version: '>= 0.9.1')
 mathlib_dep = cc.find_library('m', required: false)