fixup! Simplify Synaptics driver

Ignore zreo format length warning from GCC

.ci/check-abi

@@ -1,113 +0,0 @@
-#!/usr/bin/python3
-
-
-import argparse
-import contextlib
-import os
-import shutil
-import subprocess
-import sys
-
-
-def format_title(title):
-    box = {
-        'tl': '╔', 'tr': '╗', 'bl': '╚', 'br': '╝', 'h': '═', 'v': '║',
-    }
-    hline = box['h'] * (len(title) + 2)
-
-    return '\n'.join([
-        f"{box['tl']}{hline}{box['tr']}",
-        f"{box['v']} {title} {box['v']}",
-        f"{box['bl']}{hline}{box['br']}",
-    ])
-
-
-def rm_rf(path):
-    try:
-        shutil.rmtree(path)
-    except FileNotFoundError:
-        pass
-
-
-def sanitize_path(name):
-    return name.replace('/', '-')
-
-
-def get_current_revision():
-    revision = subprocess.check_output(['git', 'rev-parse', '--abbrev-ref', 'HEAD'],
-                                       encoding='utf-8').strip()
-
-    if revision == 'HEAD':
-        # This is a detached HEAD, get the commit hash
-        revision = subprocess.check_output(['git', 'rev-parse', 'HEAD']).strip().decode('utf-8')
-
-    return revision
-
-
-@contextlib.contextmanager
-def checkout_git_revision(revision):
-    current_revision = get_current_revision()
-    subprocess.check_call(['git', 'checkout', '-q', revision])
-
-    try:
-        yield
-    finally:
-        subprocess.check_call(['git', 'checkout', '-q', current_revision])
-
-
-def build_install(revision):
-    build_dir = '_build'
-    dest_dir = os.path.abspath(sanitize_path(revision))
-    print(format_title(f'# Building and installing {revision} in {dest_dir}'),
-          end='\n\n', flush=True)
-
-    with checkout_git_revision(revision):
-        rm_rf(build_dir)
-        rm_rf(revision)
-
-        subprocess.check_call(['meson', build_dir,
-                               '--prefix=/usr', '--libdir=lib',
-                               '-Dx11-examples=false', '-Ddoc=false', '-Dgtk-examples=false'])
-        subprocess.check_call(['ninja', '-v', '-C', build_dir])
-        subprocess.check_call(['ninja', '-v', '-C', build_dir, 'install'],
-                              env={'DESTDIR': dest_dir})
-
-    return dest_dir
-
-
-def compare(old_tree, new_tree):
-    print(format_title(f'# Comparing the two ABIs'), end='\n\n', flush=True)
-
-    old_headers = os.path.join(old_tree, 'usr', 'include')
-    old_lib = os.path.join(old_tree, 'usr', 'lib', 'libfprint.so')
-
-    new_headers = os.path.join(new_tree, 'usr', 'include')
-    new_lib = os.path.join(new_tree, 'usr', 'lib', 'libfprint.so')
-
-    subprocess.check_call([
-        'abidiff', '--headers-dir1', old_headers, '--headers-dir2', new_headers,
-        '--drop-private-types', '--fail-no-debug-info', '--no-added-syms', old_lib, new_lib])
-
-
-if __name__ == '__main__':
-    parser = argparse.ArgumentParser()
-
-    parser.add_argument('old', help='the previous revision, considered the reference')
-    parser.add_argument('new', help='the new revision, to compare to the reference')
-
-    args = parser.parse_args()
-
-    if args.old == args.new:
-        print("Let's not waste time comparing something to itself")
-        sys.exit(0)
-
-    old_tree = build_install(args.old)
-    new_tree = build_install(args.new)
-
-    try:
-        compare(old_tree, new_tree)
-
-    except Exception:
-        sys.exit(1)
-
-    print(f'Hurray! {args.old} and {args.new} are ABI-compatible!')

.gitignore

@@ -1,3 +1,24 @@
+ltmain.sh
+missing
+stamp-h1
+libtool
+*.la
+*.lo
 *.o
 *.swp
-_build
+Makefile
+Makefile.in
+config.h*
+aclocal.m4
+autom4te.cache
+config.guess
+config.log
+config.status
+config.sub
+configure
+depcomp
+install-sh
+.deps
+.libs
+compile
+ChangeLog

.gitlab-ci.yml

@@ -1,111 +1,33 @@
-include:
+image: fedora:rawhide
-  - local: '.gitlab-ci/libfprint-templates.yaml'
-  - project: 'wayland/ci-templates'
-    ref: master
-    file: '/templates/fedora.yml'
-
-variables:
-  extends: .libfprint_common_variables
-  FDO_DISTRIBUTION_TAG: latest
-  FDO_DISTRIBUTION_VERSION: rawhide
-  FEDORA_IMAGE: "$CI_REGISTRY/libfprint/$CI_PROJECT_NAME/fedora/$FDO_DISTRIBUTION_VERSION:$FDO_DISTRIBUTION_TAG"
-  BUNDLE: "org.freedesktop.libfprint.Demo.flatpak"
-  LAST_ABI_BREAK: "056ea541ddc97f5806cffbd99a12dc87e4da3546"
-
 stages:
-  - check-source
   - build
   - test
-  - flatpak
 
-image: "$FEDORA_IMAGE"
+variables:
+  DEPENDENCIES: libusb1-devel glib2-devel nss-devel pixman-devel systemd meson gtk-doc
+                gcc gcc-c++ glibc-devel libX11-devel libXv-devel gtk3-devel flatpak-builder
+  BUNDLE: "org.freedesktop.libfprint.Demo.flatpak"
 
 .build_one_driver_template: &build_one_driver
   script:
+    - dnf update -y --nogpgcheck && dnf install -y --nogpgcheck $DEPENDENCIES
     # Build with a driver that doesn't need imaging, or nss
-    - meson --werror -Ddrivers=$driver . _build
+    - meson -Ddrivers=elan . _build
     - ninja -C _build
     - rm -rf _build/
 
 .build_template: &build
   script:
+    - dnf update -y --nogpgcheck && dnf install -y --nogpgcheck $DEPENDENCIES
     # And build with everything
-    - meson --werror -Ddrivers=all . _build
+    - meson -Ddrivers=all . _build
     - ninja -C _build
     - ninja -C _build install
 
-.build_template: &check_abi
-  script:
-    - ./.ci/check-abi ${LAST_ABI_BREAK} $(git rev-parse HEAD)
-
 build:
   stage: build
-  except:
-    variables:
-      - $CI_PIPELINE_SOURCE == "schedule"
-  variables:
-    driver: virtual_image
   <<: *build_one_driver
   <<: *build
-#  <<: *check_abi
-  artifacts:
-    expose_as: "HTML Documentation"
-    paths:
-    - _build/doc/html/
-    expire_in: 1 week
-
-test:
-  stage: test
-  except:
-    variables:
-      - $CI_PIPELINE_SOURCE == "schedule"
-  script:
-    - meson --werror -Ddrivers=all -Db_coverage=true . _build
-    - ninja -C _build
-    - meson test -C _build --verbose --no-stdsplit --timeout-multiplier 3
-    - ninja -C _build coverage
-    - cat _build/meson-logs/coverage.txt
-  artifacts:
-    paths:
-      - _build/meson-logs
-    expire_in: 1 week
-
-test_valgrind:
-  stage: test
-  except:
-    variables:
-      - $CI_PIPELINE_SOURCE == "schedule"
-  script:
-    - meson -Ddrivers=all . _build
-    - ninja -C _build
-    - meson test -C _build --verbose --no-stdsplit --setup=valgrind
-
-test_scan_build:
-  stage: test
-  except:
-    variables:
-      - $CI_PIPELINE_SOURCE == "schedule"
-  allow_failure: true
-  script:
-    - meson -Ddrivers=all . _build
-    # This is ugly, the wrapper disables the malloc checker
-    - SCANBUILD=$CI_PROJECT_DIR/.gitlab-ci/scan-build ninja -C _build scan-build
-    # Check that the directory is empty
-    - "! ls -A _build/meson-logs/scanbuild | grep -q ."
-  artifacts:
-    paths:
-      - _build/meson-logs
-    expire_in: 1 week
-
-test_indent:
-  stage: check-source
-  except:
-    variables:
-      - $CI_PIPELINE_SOURCE == "schedule"
-  script:
-    - scripts/uncrustify.sh
-    - git diff
-    - "! git status -s | grep -q ."
 
 .flatpak_script_template: &flatpak_script
     script:
@@ -130,9 +52,9 @@ test_indent:
     <<: *flatpak_script
     <<: *flatpak_artifacts
 
-.flatpak_master_template: &flatpak_master
+flatpak master:
-    image: registry.gitlab.gnome.org/gnome/gnome-runtime-images/gnome:3.32
+    image: registry.gitlab.gnome.org/gnome/gnome-runtime-images/gnome:master
-    stage: flatpak
+    stage: test
     variables:
         MANIFEST_PATH: "demo/org.freedesktop.libfprint.Demo.json"
         # From demo/org.freedesktop.libfprint.Demo.json
@@ -140,31 +62,3 @@ test_indent:
         FLATPAK_MODULE: "libfprint"
         DBUS_ID: "org.freedesktop.libfprint.Demo"
     <<: *flatpak
-
-flatpak-auto master:
-    <<: *flatpak_master
-    when: always
-    only:
-      - tags
-      - master
-
-flatpak-manual master:
-    <<: *flatpak_master
-    when: manual
-    except:
-      refs:
-        - tags
-        - master
-      variables:
-        - $CI_PIPELINE_SOURCE == "schedule"
-
-# CONTAINERS creation stage
-container_fedora_build:
-  extends: .fdo.container-build@fedora
-  only:
-    variables:
-      - $CI_PIPELINE_SOURCE == "schedule" && $CRON_TASK == "BUILD_CI_IMAGES"
-  variables:
-    GIT_STRATEGY: none # no need to pull the whole tree for rebuilding the image
-    # a list of packages to install
-    FDO_DISTRIBUTION_PACKAGES: $LIBFPRINT_DEPENDENCIES

.gitlab-ci/libfprint-templates.yaml

@@ -1,27 +0,0 @@
-.libfprint_common_variables:
-  LIBFPRINT_DEPENDENCIES:
-    doxygen
-    flatpak-builder
-    gcc
-    gcc-c++
-    gcovr
-    git
-    glib2-devel
-    glibc-devel
-    gobject-introspection-devel
-    gtk-doc
-    gtk3-devel
-    libabigail
-    libgusb-devel
-    libX11-devel
-    libXv-devel
-    meson
-    nss-devel
-    pixman-devel
-    python3-cairo
-    python3-gobject
-    systemd
-    umockdev
-    uncrustify
-    valgrind
-    clang-analyzer

.gitlab-ci/scan-build

@@ -1,4 +0,0 @@
-#!/bin/sh
-
-# This wrapper just disables the malloc checker
-exec /usr/bin/scan-build -disable-checker unix.Malloc "$@"

HACKING.md

@@ -3,29 +3,8 @@
 ## GLib
 
 Although the library uses GLib internally, libfprint is designed to provide
-a completely neutral interface to its application users. So, the public
+a completely neutral interface to it's application users. So, the public
-APIs should never return GLib data types.
+APIs should never return GLib data types or anything like that.
-
-## License clarification
-
-Although this library's license could allow for shims that hook up into
-proprietary blobs to add driver support for some unsupported devices, the
-intent of the original authors, and of current maintainers of the library,
-was for this license to allow _integration into_ proprietary stacks, not
-_integration of_ proprietary code in the library.
-
-As such, no code to integrate proprietary drivers will be accepted in libfprint
-upstream. Proprietary drivers would make it impossible to debug problems in
-libfprint, as we wouldn't know what the proprietary driver does behind the
-library's back. The closed source nature of drivers is usually used to hide
-parts of the hardware setup, such as encryption keys, or protocols, in order
-to protect the hardware's integrity. Unfortunately, this is only [security through
-obscurity](https://en.wikipedia.org/wiki/Security_through_obscurity).
-
-We however encourage potential contributors to take advantage of libfprint's
-source availability to create such shims to make it easier to reverse-engineer
-proprietary drivers in order to create new free software drivers, to the extent
-permitted by local laws.
 
 ## Two-faced-ness
 

MAINTAINERS

@@ -1,13 +0,0 @@
-Current maintainers of libfprint are:
-
- * Benjamin Berg <bberg@redhat.com>
- * Marco Trevisan (Treviño) <mail@3v1n0.net>
-
-Many drivers are not actively maintained and may not be fully functional.
-We are happy to receive contributions, but the support we can give is
-limitted unfortunately. For many drivers we may not even have test devices.
-
-Maintained drivers are:
- * synaptics:
-   Contributed and maintained by Synaptics Inc.
-   Contact: Vincent Huang <vincent.huang@tw.synaptics.com>

NEWS

@@ -1,89 +1,6 @@
 This file lists notable changes in each release. For the full history of all
 changes, see ChangeLog.
 
-2019-11-20: v1.90.1 release
-
-This release fixes a lot of the regressions introduced in 1.90.0. Please note
-that both the driver and external APIs have changed, as both the verify and
-the identify functions now have early reporting mechanisms.
-The soname for the library, as well as a number of file locations have also
-changed. While this allows installation in parallel with the 1.0 version of
-libfprint, we recommend installing only one, and migrating from version 1.0 to
-version 2.0 alongside its main consumer (fprintd).
-
-Only major changes are listed below. A lot of other cleanup work and small
-fixes have also been merged.
-
-* Library:
-  - Add support to run tests in gdb/valgrind
-  - Allow testing on all architectures
-  - Avoid image device AWAIT_FINGER_ON to deactivate state transitions
-  - Fix verify/identify error propagation to library user
-  - Correctly read image device information from class data
-  - Continue enroll after an image driver reported a retry error
-  - Change external API to allow reporting match results early
-  - A lot of new unit tests and integration tests have been added
-
-* Drivers API
-  - Support variadic arguments in error functions
-  - Various re-definitions of ownership handling
-  - Add convenience API to change state after a timeout
-  - Add unit tests for all the drivers API
-
-* Drivers:
-  - elan: Ensure correct deactivation of device
-  - uru4000: Fix IRQ handler registration and internal state handling
-  - uru4000: Fix control transfer request type
-  - synaptics: Ensure errors are only reported after finger removal
-
-2019-11-20: v1.90.0 release
-
-This release updates the core of the library to use GLib routines and Gio
-style APIs. While the API both for library users remain similar in most
-ways, there are some changes and all users will need to be ported.
-
-A large motivation for the in-depth changes was the requirement to add
-new API to support sensors that store the prints on the sensor. This
-support is already used by the new synaptics driver, which will support
-the current generation of the Prometheus MIS (match-in-sensor) chipset
-by Synaptics (USB ID 06cb:00bd).
-
-The current codebase is considered stable at this point. However, due to
-the lack of wider testing it is only released as a 1.90.0 release which
-can be considered a beta-release for 2.0.
-
-With the rewrite, it is now also possible to support devices that are not
-connected through USB (e.g. I2C). Another major improvement is that the
-library has now a test suite, testing both the library core and allowing
-tests of the drivers using umockdev.
-
-2019-08-08: v1.0 release
-* Library:
-  - Add guards to the public API and require GLib 2.50
-  - Deprecate print storage API
-  - Better documentation for fp_discover_devs()
-  - Remove unused internal fpi_timeout_cancel_for_dev()
-  - Remove state from fp_img_driver activate handler
-  - Bug fixes related to restarting a failed verification immediately
-
-* Drivers:
-  - The Elan driver received a lot of bug fixes including a fix for a
-    hang when verifying prints with fprintd, quirks for some devices,
-    a memory leak fix and support for 04f3:0c42
-  - Fix a probable crash in all the AES drivers
-  - Add support for Lenovo Preferred Pro Keyboard (KUF1256) to vfs5011
-  - Prevent hang during enroll process in etes603 driver
-  - Fix possible integer overflow in uru4000
-  - Work-around SELinux AVC warnings when uru4000 driver starts
-  - Remove long-unmaintained and broken fdu2000 driver
-
-* Tools/Examples:
-  - Fix examples not working due to an overly strict check
-  - Fix crash in GTK demo when there's no supported devices
-  - Disable GTK demo until we have a USB Flatpak portal
-  - Remove sleep() in enroll example which caused a crash in some drivers
-  - Add a simple storage implementation example
-
 2018-12-14: v0.99.0 release
 * Library:
   - All the internal API for device driver writers is now covered by the

code-of-conduct.md

@@ -1,3 +0,0 @@
-This project and its community follow the [Freedesktop.org code of conduct]
-
-[Freedesktop.org code of conduct]: https://www.freedesktop.org/wiki/CodeOfConduct/

demo/gtk-libfprint-test.c

@@ -22,11 +22,11 @@
 #include <gtk/gtk.h>
 #include <libfprint/fprint.h>
 
-struct _LibfprintDemo
+#include "loop.h"
-{
+
-  GtkApplication parent;
+typedef GtkApplication LibfprintDemo;
-};
+typedef GtkApplicationClass LibfprintDemoClass;
-G_DECLARE_FINAL_TYPE (LibfprintDemo, libfprint_demo, FP, DEMO, GtkApplication)
+
 G_DEFINE_TYPE (LibfprintDemo, libfprint_demo, GTK_TYPE_APPLICATION)
 
 typedef enum {
@@ -35,28 +35,25 @@ typedef enum {
 	IMAGE_DISPLAY_BINARY   =  1 << 1
 } ImageDisplayFlags;
 
-struct _LibfprintDemoWindow
+typedef struct {
-{
 	GtkApplicationWindow parent_instance;
 
 	GtkWidget *header_bar;
 	GtkWidget *mode_stack;
 	GtkWidget *capture_button;
-  GtkWidget           *cancel_button;
 	GtkWidget *capture_image;
 	GtkWidget *spinner;
 	GtkWidget *instructions;
 
-  GCancellable        *cancellable;
+	struct fp_dscv_dev *ddev;
+	struct fp_dev *dev;
 
-  gboolean             opened;
+	struct fp_img *img;
-  FpDevice            *dev;
-
-  FpImage             *img;
 	ImageDisplayFlags img_flags;
-};
+} LibfprintDemoWindow;
+
+typedef GtkApplicationWindowClass LibfprintDemoWindowClass;
 
-G_DECLARE_FINAL_TYPE (LibfprintDemoWindow, libfprint_demo_window, FP, DEMO_WINDOW, GtkApplicationWindow)
 G_DEFINE_TYPE (LibfprintDemoWindow, libfprint_demo_window, GTK_TYPE_APPLICATION_WINDOW)
 
 typedef enum {
@@ -64,26 +61,33 @@ typedef enum {
 	NOIMAGING_MODE,
 	CAPTURE_MODE,
 	SPINNER_MODE,
-  ERROR_MODE,
+	ERROR_MODE
-  RETRY_MODE
 } LibfprintDemoMode;
 
 static void libfprint_demo_set_mode (LibfprintDemoWindow *win,
 				     LibfprintDemoMode    mode);
 
+static void
+pixbuf_destroy (guchar *pixels, gpointer data)
+{
+	if (pixels == NULL)
+		return;
+	g_free (pixels);
+}
+
 static unsigned char *
-img_to_rgbdata (const guint8 *imgdata,
+img_to_rgbdata (struct fp_img *img,
 		int            width,
 		int            height)
 {
 	int size = width * height;
-  guint8 *rgbdata = g_malloc (size * 3);
+	unsigned char *imgdata = fp_img_get_data (img);
+	unsigned char *rgbdata = g_malloc (size * 3);
 	size_t i;
 	size_t rgb_offset = 0;
 
-  for (i = 0; i < size; i++)
+	for (i = 0; i < size; i++) {
-    {
+		unsigned char pixel = imgdata[i];
-      guint8 pixel = imgdata[i];
 
 		rgbdata[rgb_offset++] = pixel;
 		rgbdata[rgb_offset++] = pixel;
@@ -97,19 +101,18 @@ static void
 plot_minutiae (unsigned char      *rgbdata,
 	       int                 width,
 	       int                 height,
-               GPtrArray     *minutiae)
+	       struct fp_minutia **minlist,
+	       int                 nr_minutiae)
 {
 	int i;
-
 #define write_pixel(num) do { \
 		rgbdata[((num) * 3)] = 0xff; \
 		rgbdata[((num) * 3) + 1] = 0; \
 		rgbdata[((num) * 3) + 2] = 0; \
 	} while(0)
 
-  for (i = 0; i < minutiae->len; i++)
+	for (i = 0; i < nr_minutiae; i++) {
-    {
+		struct fp_minutia *min = minlist[i];
-      struct fp_minutia *min = g_ptr_array_index (minutiae, i);
 		int x, y;
 		size_t pixel_offset;
 
@@ -133,38 +136,36 @@ plot_minutiae (unsigned char *rgbdata,
 }
 
 static GdkPixbuf *
-img_to_pixbuf (FpImage          *img,
+img_to_pixbuf (struct fp_img     *img,
 	       ImageDisplayFlags  flags)
 {
 	int width;
 	int height;
-  const guint8 *data;
 	unsigned char *rgbdata;
 
-  width = fp_image_get_width (img);
+	width = fp_img_get_width (img);
-  height = fp_image_get_height (img);
+	height = fp_img_get_height (img);
 
-  if (flags & IMAGE_DISPLAY_BINARY)
+	if (flags & IMAGE_DISPLAY_BINARY) {
-    data = fp_image_get_binarized (img, NULL);
+		struct fp_img *binary;
-  else
+		binary = fp_img_binarize (img);
-    data = fp_image_get_data (img, NULL);
+		rgbdata = img_to_rgbdata (binary, width, height);
+		fp_img_free (binary);
+	} else {
+		rgbdata = img_to_rgbdata (img, width, height);
+	}
 
-  if (!data)
+	if (flags & IMAGE_DISPLAY_MINUTIAE) {
-    return NULL;
+		struct fp_minutia **minlist;
+		int nr_minutiae;
 
-  rgbdata = img_to_rgbdata (data, width, height);
+		minlist = fp_img_get_minutiae (img, &nr_minutiae);
-
+		plot_minutiae (rgbdata, width, height, minlist, nr_minutiae);
-  if (flags & IMAGE_DISPLAY_MINUTIAE)
-    {
-      GPtrArray *minutiae;
-
-      minutiae = fp_image_get_minutiae (img);
-      plot_minutiae (rgbdata, width, height, minutiae);
 	}
 
 	return gdk_pixbuf_new_from_data (rgbdata, GDK_COLORSPACE_RGB,
 					 FALSE, 8, width, height,
-                                   width * 3, (GdkPixbufDestroyNotify) g_free,
+					 width * 3, pixbuf_destroy,
 					 NULL);
 }
 
@@ -173,8 +174,7 @@ update_image (LibfprintDemoWindow *win)
 {
 	GdkPixbuf *pixbuf;
 
-  if (win->img == NULL)
+	if (win->img == NULL) {
-    {
 		gtk_image_clear (GTK_IMAGE (win->capture_image));
 		return;
 	}
@@ -201,21 +201,20 @@ libfprint_demo_set_spinner_label (LibfprintDemoWindow *win,
 static void
 libfprint_demo_set_capture_label (LibfprintDemoWindow *win)
 {
-  FpScanType scan_type;
+	struct fp_driver *drv;
+	enum fp_scan_type scan_type;
 	const char *message;
 
-  scan_type = fp_device_get_scan_type (win->dev);
+	drv = fp_dscv_dev_get_driver (win->ddev);
+	scan_type = fp_driver_get_scan_type(drv);
 
-  switch (scan_type)
+	switch (scan_type) {
-    {
 	case FP_SCAN_TYPE_PRESS:
 		message = "Place your finger on the fingerprint reader";
 		break;
-
 	case FP_SCAN_TYPE_SWIPE:
 		message = "Swipe your finger across the fingerprint reader";
 		break;
-
 	default:
 		g_assert_not_reached ();
 	}
@@ -224,58 +223,46 @@ libfprint_demo_set_capture_label (LibfprintDemoWindow *win)
 }
 
 static void
-dev_capture_start_cb (FpDevice     *dev,
+dev_capture_start_cb (struct fp_dev *dev,
-                      GAsyncResult *res,
+		      int            result,
+		      struct fp_img *img,
 		      void          *user_data)
 {
-  g_autoptr(GError) error = NULL;
 	LibfprintDemoWindow *win = user_data;
-  FpImage *image = NULL;
 
-  g_clear_object (&win->cancellable);
+	if (result < 0) {
-
-  image = fp_device_capture_finish (dev, res, &error);
-  if (!image)
-    {
-      g_warning ("Error capturing data: %s", error->message);
-      if (error->domain == FP_DEVICE_RETRY ||
-          g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
-        libfprint_demo_set_mode (win, RETRY_MODE);
-      else
 		libfprint_demo_set_mode (win, ERROR_MODE);
 		return;
 	}
 
-  g_clear_object (&win->img);
+	fp_async_capture_stop (dev, NULL, NULL);
-  win->img = image;
+
+	win->img = img;
 	update_image (win);
 
 	libfprint_demo_set_mode (win, CAPTURE_MODE);
 }
 
 static void
-dev_start_capture (LibfprintDemoWindow *win)
+dev_open_cb (struct fp_dev *dev, int status, void *user_data)
-{
-  libfprint_demo_set_capture_label (win);
-
-  fp_device_capture (win->dev, TRUE, win->cancellable, (GAsyncReadyCallback) dev_capture_start_cb, win);
-}
-
-static void
-dev_open_cb (FpDevice *dev, GAsyncResult *res, void *user_data)
 {
 	LibfprintDemoWindow *win = user_data;
+	int r;
 
-  g_autoptr(GError) error = NULL;
+	if (status < 0) {
-
-  if (!fp_device_open_finish (dev, res, &error))
-    {
-      g_warning ("Failed to open device: %s", error->message);
 		libfprint_demo_set_mode (win, ERROR_MODE);
 		return;
 	}
 
-  dev_start_capture (win);
+	libfprint_demo_set_capture_label (win);
+
+	win->dev = dev;
+	r = fp_async_capture_start (win->dev, FALSE, dev_capture_start_cb, user_data);
+	if (r < 0) {
+		g_warning ("fp_async_capture_start failed: %d", r);
+		libfprint_demo_set_mode (win, ERROR_MODE);
+		return;
+	}
 }
 
 static void
@@ -284,36 +271,24 @@ activate_capture (GSimpleAction *action,
 		  gpointer       user_data)
 {
 	LibfprintDemoWindow *win = user_data;
+	int r;
 
 	libfprint_demo_set_mode (win, SPINNER_MODE);
-  g_clear_pointer (&win->img, g_object_unref);
+	g_clear_pointer (&win->img, fp_img_free);
 
-  g_clear_object (&win->cancellable);
+	if (win->dev != NULL) {
-  win->cancellable = g_cancellable_new ();
+		dev_open_cb (win->dev, 0, user_data);
-
-  if (win->opened)
-    {
-      dev_start_capture (win);
 		return;
 	}
 
 	libfprint_demo_set_spinner_label (win, "Opening fingerprint reader");
 
-  win->opened = TRUE;
+	r = fp_async_dev_open (win->ddev, dev_open_cb, user_data);
-  fp_device_open (win->dev, win->cancellable, (GAsyncReadyCallback) dev_open_cb, user_data);
+	if (r < 0) {
+		g_warning ("fp_async_dev_open failed: %d", r);
+		libfprint_demo_set_mode (win, ERROR_MODE);
+		return;
 	}
-
-static void
-cancel_capture (GSimpleAction *action,
-                GVariant      *parameter,
-                gpointer       user_data)
-{
-  LibfprintDemoWindow *win = user_data;
-
-  g_debug ("cancelling %p", win->cancellable);
-
-  if (win->cancellable)
-    g_cancellable_cancel (win->cancellable);
 }
 
 static void
@@ -404,8 +379,7 @@ static GActionEntry app_entries[] = {
 static GActionEntry win_entries[] = {
 	{ "show-minutiae", activate_show_minutiae, NULL, "false", change_show_minutiae_state },
 	{ "show-binary", activate_show_binary, NULL, "false", change_show_binary_state },
-  { "capture", activate_capture, NULL, NULL, NULL },
+	{ "capture", activate_capture, NULL, NULL, NULL }
-  { "cancel", cancel_capture, NULL, NULL, NULL }
 };
 
 static void
@@ -423,57 +397,41 @@ static void
 libfprint_demo_set_mode (LibfprintDemoWindow *win,
 			 LibfprintDemoMode    mode)
 {
+	struct fp_driver *drv;
 	char *title;
 
-  switch (mode)
+	switch (mode) {
-    {
 	case EMPTY_MODE:
 		gtk_stack_set_visible_child_name (GTK_STACK (win->mode_stack), "empty-mode");
 		gtk_widget_set_sensitive (win->capture_button, FALSE);
-      gtk_widget_set_sensitive (win->cancel_button, FALSE);
 		gtk_spinner_stop (GTK_SPINNER (win->spinner));
 		break;
-
 	case NOIMAGING_MODE:
 		gtk_stack_set_visible_child_name (GTK_STACK (win->mode_stack), "noimaging-mode");
 		gtk_widget_set_sensitive (win->capture_button, FALSE);
-      gtk_widget_set_sensitive (win->cancel_button, FALSE);
 		gtk_spinner_stop (GTK_SPINNER (win->spinner));
 		break;
-
 	case CAPTURE_MODE:
 		gtk_stack_set_visible_child_name (GTK_STACK (win->mode_stack), "capture-mode");
 		gtk_widget_set_sensitive (win->capture_button, TRUE);
-      gtk_widget_set_sensitive (win->cancel_button, FALSE);
 
-      title = g_strdup_printf ("%s Test", fp_device_get_name (win->dev));
+		drv = fp_dscv_dev_get_driver (win->ddev);
+		title = g_strdup_printf ("%s Test", fp_driver_get_full_name (drv));
 		gtk_header_bar_set_title (GTK_HEADER_BAR (win->header_bar), title);
 		g_free (title);
 
 		gtk_spinner_stop (GTK_SPINNER (win->spinner));
 		break;
-
 	case SPINNER_MODE:
 		gtk_stack_set_visible_child_name (GTK_STACK (win->mode_stack), "spinner-mode");
 		gtk_widget_set_sensitive (win->capture_button, FALSE);
-      gtk_widget_set_sensitive (win->cancel_button, TRUE);
 		gtk_spinner_start (GTK_SPINNER (win->spinner));
 		break;
-
 	case ERROR_MODE:
 		gtk_stack_set_visible_child_name (GTK_STACK (win->mode_stack), "error-mode");
 		gtk_widget_set_sensitive (win->capture_button, FALSE);
-      gtk_widget_set_sensitive (win->cancel_button, FALSE);
 		gtk_spinner_stop (GTK_SPINNER (win->spinner));
 		break;
-
-    case RETRY_MODE:
-      gtk_stack_set_visible_child_name (GTK_STACK (win->mode_stack), "retry-mode");
-      gtk_widget_set_sensitive (win->capture_button, TRUE);
-      gtk_widget_set_sensitive (win->cancel_button, FALSE);
-      gtk_spinner_stop (GTK_SPINNER (win->spinner));
-      break;
-
 	default:
 		g_assert_not_reached ();
 	}
@@ -498,8 +456,7 @@ libfprint_demo_class_init (LibfprintDemoClass *class)
 static void
 libfprint_demo_window_init (LibfprintDemoWindow *window)
 {
-  FpContext *ctx;
+	struct fp_dscv_dev **discovered_devs;
-  GPtrArray *devices;
 
 	gtk_widget_init_template (GTK_WIDGET (window));
 	gtk_window_set_default_size (GTK_WINDOW (window), 700, 500);
@@ -508,29 +465,32 @@ libfprint_demo_window_init (LibfprintDemoWindow *window)
 					 win_entries, G_N_ELEMENTS (win_entries),
 					 window);
 
-  ctx = fp_context_new ();
+	if (fp_init () < 0) {
+		libfprint_demo_set_mode (window, ERROR_MODE);
+		return;
+	}
 
-  devices = fp_context_get_devices (ctx);
+	setup_pollfds ();
-  if (!devices)
+
-    {
+	discovered_devs = fp_discover_devs();
+	if (!discovered_devs) {
 		libfprint_demo_set_mode (window, ERROR_MODE);
 		return;
 	}
 
 	/* Empty list? */
-  if (devices->len == 0)
+	if (discovered_devs[0] == NULL) {
-    {
+		fp_dscv_devs_free (discovered_devs);
 		libfprint_demo_set_mode (window, EMPTY_MODE);
 		return;
 	}
 
-  if (!fp_device_supports_capture (g_ptr_array_index (devices, 0)))
+	if (!fp_driver_supports_imaging(fp_dscv_dev_get_driver(discovered_devs[0]))) {
-    {
 		libfprint_demo_set_mode (window, NOIMAGING_MODE);
 		return;
 	}
 
-  window->dev = g_object_ref (g_ptr_array_index (devices, 0));
+	window->ddev = discovered_devs[0];
 	libfprint_demo_set_mode (window, CAPTURE_MODE);
 }
 
@@ -543,7 +503,6 @@ libfprint_demo_window_class_init (LibfprintDemoWindowClass *class)
 	gtk_widget_class_bind_template_child (widget_class, LibfprintDemoWindow, header_bar);
 	gtk_widget_class_bind_template_child (widget_class, LibfprintDemoWindow, mode_stack);
 	gtk_widget_class_bind_template_child (widget_class, LibfprintDemoWindow, capture_button);
-  gtk_widget_class_bind_template_child (widget_class, LibfprintDemoWindow, cancel_button);
 	gtk_widget_class_bind_template_child (widget_class, LibfprintDemoWindow, capture_image);
 	gtk_widget_class_bind_template_child (widget_class, LibfprintDemoWindow, spinner);
 	gtk_widget_class_bind_template_child (widget_class, LibfprintDemoWindow, instructions);
@@ -551,8 +510,7 @@ libfprint_demo_window_class_init (LibfprintDemoWindowClass *class)
 	//FIXME setup dispose
 }
 
-int
+int main (int argc, char **argv)
-main (int argc, char **argv)
 {
 	GtkApplication *app;
 

demo/gtk-libfprint-test.ui

@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<!-- Generated with glade 3.22.0 -->
+<!-- Generated with glade 3.22.1 -->
 <interface>
   <requires lib="gtk+" version="3.20"/>
   <template class="LibfprintDemoWindow" parent="GtkApplicationWindow">
@@ -7,6 +7,59 @@
     <property name="default_width">500</property>
     <property name="default_height">400</property>
     <property name="show_menubar">False</property>
+    <child type="titlebar">
+      <object class="GtkHeaderBar" id="header_bar">
+        <property name="visible">True</property>
+        <property name="can_focus">False</property>
+        <property name="title">Fingerprint Reader Test</property>
+        <property name="subtitle">Capture test</property>
+        <property name="show_close_button">True</property>
+        <child>
+          <object class="GtkMenuButton" id="option-menu-button">
+            <property name="visible">True</property>
+            <property name="sensitive">False</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">False</property>
+            <property name="valign">center</property>
+            <property name="menu-model">options-menu</property>
+            <child>
+              <object class="GtkImage">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="icon_name">open-menu-symbolic</property>
+              </object>
+            </child>
+          </object>
+          <packing>
+            <property name="pack_type">end</property>
+          </packing>
+        </child>
+        <child>
+          <object class="GtkButton" id="capture_button">
+            <property name="visible">True</property>
+            <property name="sensitive">False</property>
+            <property name="can_focus">True</property>
+            <property name="receives_default">False</property>
+            <property name="valign">center</property>
+            <property name="action_name">win.capture</property>
+            <child>
+              <object class="GtkLabel" id="capture_label">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="label" translatable="yes">_Capture</property>
+                <property name="use_underline">True</property>
+              </object>
+            </child>
+            <style>
+              <class name="text-button"/>
+            </style>
+          </object>
+          <packing>
+            <property name="pack_type">end</property>
+          </packing>
+        </child>
+      </object>
+    </child>
     <child>
       <object class="GtkStack" id="mode_stack">
         <property name="visible">True</property>
@@ -51,6 +104,9 @@
             <child>
               <placeholder/>
             </child>
+            <child>
+              <placeholder/>
+            </child>
             <style>
               <class name="dim-label"/>
             </style>
@@ -60,6 +116,70 @@
             <property name="title">spinner-mode</property>
           </packing>
         </child>
+        <child>
+          <object class="GtkGrid" id="empty-mode">
+            <property name="visible">True</property>
+            <property name="can_focus">False</property>
+            <property name="halign">center</property>
+            <property name="valign">center</property>
+            <property name="hexpand">True</property>
+            <property name="vexpand">True</property>
+            <property name="orientation">vertical</property>
+            <property name="row_spacing">12</property>
+            <child>
+              <object class="GtkImage">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="margin_bottom">9</property>
+                <property name="pixel_size">192</property>
+              </object>
+              <packing>
+                <property name="left_attach">1</property>
+                <property name="top_attach">0</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="margin_top">9</property>
+                <property name="label" translatable="yes">&lt;b&gt;&lt;span size="large"&gt;No fingerprint readers found&lt;/span&gt;&lt;/b&gt;</property>
+                <property name="use_markup">True</property>
+              </object>
+              <packing>
+                <property name="left_attach">1</property>
+                <property name="top_attach">1</property>
+              </packing>
+            </child>
+            <child>
+              <object class="GtkLabel">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="label" translatable="yes">Please connect a supported fingerprint reader and start the application again</property>
+              </object>
+              <packing>
+                <property name="left_attach">1</property>
+                <property name="top_attach">2</property>
+              </packing>
+            </child>
+            <child>
+              <placeholder/>
+            </child>
+            <child>
+              <placeholder/>
+            </child>
+            <child>
+              <placeholder/>
+            </child>
+            <style>
+              <class name="dim-label"/>
+            </style>
+          </object>
+          <packing>
+            <property name="name">empty-mode</property>
+            <property name="title">empty-mode</property>
+          </packing>
+        </child>
         <child>
           <object class="GtkAspectFrame" id="capture-mode">
             <property name="visible">True</property>
@@ -81,7 +201,7 @@
           </packing>
         </child>
         <child>
-          <object class="GtkGrid" id="retry-mode">
+          <object class="GtkGrid" id="error-mode">
             <property name="visible">True</property>
             <property name="can_focus">False</property>
             <property name="halign">center</property>
@@ -108,7 +228,7 @@
                 <property name="visible">True</property>
                 <property name="can_focus">False</property>
                 <property name="margin_top">9</property>
-                <property name="label" translatable="yes">&lt;b&gt;&lt;span size="large"&gt;Device reported a recoverable error. Please retry!&lt;/span&gt;&lt;/b&gt;</property>
+                <property name="label" translatable="yes">&lt;b&gt;&lt;span size="large"&gt;An error occurred trying to access the fingerprint reader&lt;/span&gt;&lt;/b&gt;</property>
                 <property name="use_markup">True</property>
               </object>
               <packing>
@@ -116,6 +236,20 @@
                 <property name="top_attach">1</property>
               </packing>
             </child>
+            <child>
+              <object class="GtkLabel">
+                <property name="visible">True</property>
+                <property name="can_focus">False</property>
+                <property name="label" translatable="yes">Please consult the debugging output before restarting the application</property>
+              </object>
+              <packing>
+                <property name="left_attach">1</property>
+                <property name="top_attach">2</property>
+              </packing>
+            </child>
+            <child>
+              <placeholder/>
+            </child>
             <child>
               <placeholder/>
             </child>
@@ -127,8 +261,8 @@
             </style>
           </object>
           <packing>
-            <property name="name">retry-mode</property>
+            <property name="name">error-mode</property>
-            <property name="title">retry-mode</property>
+            <property name="title">error-mode</property>
             <property name="position">2</property>
           </packing>
         </child>
@@ -198,216 +332,6 @@
             <property name="position">3</property>
           </packing>
         </child>
-        <child>
-          <object class="GtkGrid" id="error-mode">
-            <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="halign">center</property>
-            <property name="valign">center</property>
-            <property name="hexpand">True</property>
-            <property name="vexpand">True</property>
-            <property name="orientation">vertical</property>
-            <property name="row_spacing">12</property>
-            <child>
-              <object class="GtkImage">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="margin_bottom">9</property>
-                <property name="pixel_size">192</property>
-                <property name="icon_name">dialog-warning-symbolic</property>
-              </object>
-              <packing>
-                <property name="left_attach">1</property>
-                <property name="top_attach">0</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkLabel">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="margin_top">9</property>
-                <property name="label" translatable="yes">&lt;b&gt;&lt;span size="large"&gt;An error occurred trying to access the fingerprint reader&lt;/span&gt;&lt;/b&gt;</property>
-                <property name="use_markup">True</property>
-              </object>
-              <packing>
-                <property name="left_attach">1</property>
-                <property name="top_attach">1</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkLabel">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="label" translatable="yes">Please consult the debugging output before restarting the application</property>
-              </object>
-              <packing>
-                <property name="left_attach">1</property>
-                <property name="top_attach">2</property>
-              </packing>
-            </child>
-            <child>
-              <placeholder/>
-            </child>
-            <child>
-              <placeholder/>
-            </child>
-            <child>
-              <placeholder/>
-            </child>
-            <style>
-              <class name="dim-label"/>
-            </style>
-          </object>
-          <packing>
-            <property name="name">error-mode</property>
-            <property name="title">error-mode</property>
-            <property name="position">4</property>
-          </packing>
-        </child>
-        <child>
-          <object class="GtkGrid" id="empty-mode">
-            <property name="visible">True</property>
-            <property name="can_focus">False</property>
-            <property name="halign">center</property>
-            <property name="valign">center</property>
-            <property name="hexpand">True</property>
-            <property name="vexpand">True</property>
-            <property name="orientation">vertical</property>
-            <property name="row_spacing">12</property>
-            <child>
-              <object class="GtkImage">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="margin_bottom">9</property>
-                <property name="pixel_size">192</property>
-              </object>
-              <packing>
-                <property name="left_attach">1</property>
-                <property name="top_attach">0</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkLabel">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="margin_top">9</property>
-                <property name="label" translatable="yes">&lt;b&gt;&lt;span size="large"&gt;No fingerprint readers found&lt;/span&gt;&lt;/b&gt;</property>
-                <property name="use_markup">True</property>
-              </object>
-              <packing>
-                <property name="left_attach">1</property>
-                <property name="top_attach">1</property>
-              </packing>
-            </child>
-            <child>
-              <object class="GtkLabel">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="label" translatable="yes">Please connect a supported fingerprint reader and start the application again</property>
-              </object>
-              <packing>
-                <property name="left_attach">1</property>
-                <property name="top_attach">2</property>
-              </packing>
-            </child>
-            <child>
-              <placeholder/>
-            </child>
-            <child>
-              <placeholder/>
-            </child>
-            <child>
-              <placeholder/>
-            </child>
-            <style>
-              <class name="dim-label"/>
-            </style>
-          </object>
-          <packing>
-            <property name="name">empty-mode</property>
-            <property name="title">empty-mode</property>
-            <property name="position">5</property>
-          </packing>
-        </child>
-      </object>
-    </child>
-    <child type="titlebar">
-      <object class="GtkHeaderBar" id="header_bar">
-        <property name="visible">True</property>
-        <property name="can_focus">False</property>
-        <property name="title">Fingerprint Reader Test</property>
-        <property name="subtitle">Capture test</property>
-        <property name="show_close_button">True</property>
-        <child>
-          <object class="GtkMenuButton" id="option-menu-button">
-            <property name="visible">True</property>
-            <property name="sensitive">False</property>
-            <property name="can_focus">True</property>
-            <property name="receives_default">False</property>
-            <property name="valign">center</property>
-            <property name="menu-model">options-menu</property>
-            <child>
-              <object class="GtkImage">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="icon_name">open-menu-symbolic</property>
-              </object>
-            </child>
-          </object>
-          <packing>
-            <property name="pack_type">end</property>
-          </packing>
-        </child>
-        <child>
-          <object class="GtkButton" id="cancel_button">
-            <property name="visible">True</property>
-            <property name="sensitive">False</property>
-            <property name="can_focus">True</property>
-            <property name="receives_default">False</property>
-            <property name="valign">center</property>
-            <property name="action_name">win.cancel</property>
-            <child>
-              <object class="GtkLabel" id="cancel_label">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="label" translatable="yes">Cancel</property>
-                <property name="use_underline">True</property>
-              </object>
-            </child>
-            <style>
-              <class name="text-button"/>
-            </style>
-          </object>
-          <packing>
-            <property name="pack_type">end</property>
-            <property name="position">1</property>
-          </packing>
-        </child>
-        <child>
-          <object class="GtkButton" id="capture_button">
-            <property name="visible">True</property>
-            <property name="sensitive">False</property>
-            <property name="can_focus">True</property>
-            <property name="receives_default">False</property>
-            <property name="valign">center</property>
-            <property name="action_name">win.capture</property>
-            <child>
-              <object class="GtkLabel" id="capture_label">
-                <property name="visible">True</property>
-                <property name="can_focus">False</property>
-                <property name="label" translatable="yes">_Capture</property>
-                <property name="use_underline">True</property>
-              </object>
-            </child>
-            <style>
-              <class name="text-button"/>
-            </style>
-          </object>
-          <packing>
-            <property name="pack_type">end</property>
-            <property name="position">2</property>
-          </packing>
-        </child>
       </object>
     </child>
   </template>

demo/loop.c

@@ -0,0 +1,196 @@
+/*
+ * fprint D-Bus daemon
+ * Copyright (C) 2008 Daniel Drake <dsd@gentoo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program 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 General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
+
+#include "config.h"
+
+#include <glib.h>
+#include <libfprint/fprint.h>
+
+#include <poll.h>
+#include <stdlib.h>
+
+#include "loop.h"
+
+struct fdsource {
+	GSource source;
+	GSList *pollfds;
+};
+
+static gboolean source_prepare(GSource *source, gint *timeout)
+{
+	int r;
+	struct timeval tv;
+
+	r = fp_get_next_timeout(&tv);
+	if (r == 0) {
+		*timeout = -1;
+		return FALSE;
+	}
+
+	if (!timerisset(&tv))
+		return TRUE;
+
+	*timeout = (tv.tv_sec * 1000) + (tv.tv_usec / 1000);
+	return FALSE;
+}
+
+static gboolean source_check(GSource *source)
+{
+	struct fdsource *_fdsource = (struct fdsource *) source;
+	GSList *l;
+	struct timeval tv;
+	int r;
+
+	if (!_fdsource->pollfds)
+		return FALSE;
+
+	for (l = _fdsource->pollfds; l != NULL; l = l->next) {
+		GPollFD *pollfd = l->data;
+
+		if (pollfd->revents)
+			return TRUE;
+	}
+
+	r = fp_get_next_timeout(&tv);
+	if (r == 1 && !timerisset(&tv))
+		return TRUE;
+
+	return FALSE;
+}
+
+static gboolean source_dispatch(GSource *source, GSourceFunc callback,
+	gpointer data)
+{
+	struct timeval zerotimeout = {
+		.tv_sec = 0,
+		.tv_usec = 0,
+	};
+
+	/* FIXME error handling */
+	fp_handle_events_timeout(&zerotimeout);
+
+	/* FIXME whats the return value used for? */
+	return TRUE;
+}
+
+static void source_finalize(GSource *source)
+{
+	struct fdsource *_fdsource = (struct fdsource *) source;
+	GSList *l;
+
+	if (!_fdsource->pollfds)
+		return;
+
+	for (l = _fdsource->pollfds; l != NULL; l = l->next) {
+		GPollFD *pollfd = l->data;
+
+		g_source_remove_poll((GSource *) _fdsource, pollfd);
+		g_slice_free(GPollFD, pollfd);
+		_fdsource->pollfds = g_slist_delete_link(_fdsource->pollfds, l);
+	}
+
+	g_slist_free(_fdsource->pollfds);
+}
+
+static GSourceFuncs sourcefuncs = {
+	.prepare = source_prepare,
+	.check = source_check,
+	.dispatch = source_dispatch,
+	.finalize = source_finalize,
+};
+
+static struct fdsource *fdsource = NULL;
+
+static void pollfd_add(int fd, short events)
+{
+	GPollFD *pollfd;
+
+	pollfd = g_slice_new(GPollFD);
+	pollfd->fd = fd;
+	pollfd->events = 0;
+	pollfd->revents = 0;
+	if (events & POLLIN)
+		pollfd->events |= G_IO_IN;
+	if (events & POLLOUT)
+		pollfd->events |= G_IO_OUT;
+
+	fdsource->pollfds = g_slist_prepend(fdsource->pollfds, pollfd);
+	g_source_add_poll((GSource *) fdsource, pollfd);
+}
+
+static void pollfd_added_cb(int fd, short events)
+{
+	g_debug("now monitoring fd %d", fd);
+	pollfd_add(fd, events);
+}
+
+static void pollfd_removed_cb(int fd)
+{
+	GSList *l;
+
+	g_debug("no longer monitoring fd %d", fd);
+
+	if (!fdsource->pollfds) {
+		g_debug("cannot remove from list as list is empty?");
+		return;
+	}
+
+	for (l = fdsource->pollfds; l != NULL; l = l->next) {
+		GPollFD *pollfd = l->data;
+
+		if (pollfd->fd != fd)
+			continue;
+
+		g_source_remove_poll((GSource *) fdsource, pollfd);
+		g_slice_free(GPollFD, pollfd);
+		fdsource->pollfds = g_slist_delete_link(fdsource->pollfds, l);
+		return;
+	}
+
+	g_error("couldn't find fd %d in list\n", fd);
+}
+
+int setup_pollfds(void)
+{
+	ssize_t numfds;
+	size_t i;
+	struct fp_pollfd *fpfds;
+	GSource *gsource;
+
+	gsource = g_source_new(&sourcefuncs, sizeof(struct fdsource));
+	fdsource = (struct fdsource *) gsource;
+	fdsource->pollfds = NULL;
+
+	numfds = fp_get_pollfds(&fpfds);
+	if (numfds < 0) {
+		if (fpfds)
+			free(fpfds);
+		return (int) numfds;
+	} else if (numfds > 0) {
+		for (i = 0; i < numfds; i++) {
+			struct fp_pollfd *fpfd = &fpfds[i];
+			pollfd_add(fpfd->fd, fpfd->events);
+		}
+	}
+
+	free(fpfds);
+	fp_set_pollfd_notifiers(pollfd_added_cb, pollfd_removed_cb);
+	g_source_attach(gsource, NULL);
+	return 0;
+}

demo/loop.h

@@ -0,0 +1,27 @@
+/*
+ * Copyright (C) 2008 Daniel Drake <dsd@gentoo.org>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * 
+ * This program 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 General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ */
+
+#ifndef POLL_H
+
+#define POLL_H
+
+int setup_pollfds(void);
+
+#endif
+

demo/meson.build

@@ -1,5 +1,4 @@
-gtk_test_resources = gnome.compile_resources('gtk-test-resources',
+gtk_test_resources = gnome.compile_resources('gtk-test-resources', 'gtk-libfprint-test.gresource.xml',
-    'gtk-libfprint-test.gresource.xml',
                                              source_dir : '.',
                                              c_name : 'gtk_test')
 
@@ -8,12 +7,13 @@ bindir = join_paths(prefix, get_option('bindir'))
 datadir = join_paths(prefix, get_option('datadir'))
 
 executable('gtk-libfprint-test',
-    [ 'gtk-libfprint-test.c', gtk_test_resources ],
+           [ 'gtk-libfprint-test.c', 'loop.c', 'loop.h', gtk_test_resources ],
-    dependencies: [
+           dependencies: [ libfprint_dep, gtk_dep ],
-        gtk_dep,
+           include_directories: [
-        libfprint_dep,
+             root_inc,
            ],
-    c_args: '-DPACKAGE_VERSION="' + meson.project_version() + '"',
+           c_args: [ common_cflags,
+                     '-DPACKAGE_VERSION="' + meson.project_version() + '"' ],
            install: true,
            install_dir: bindir)
 

demo/org.freedesktop.libfprint.Demo.json

@@ -1,7 +1,7 @@
 {
     "app-id": "org.freedesktop.libfprint.Demo",
     "runtime": "org.gnome.Platform",
-    "runtime-version": "3.32",
+    "runtime-version": "master",
     "sdk": "org.gnome.Sdk",
     "command": "gtk-libfprint-test",
     "finish-args": [
@@ -32,30 +32,18 @@
                 }
             ],
             "post-install": [
-                "install -Dm644 COPYING /app/share/licenses/libgusb/COPYING"
+                "install -Dm644 COPYING /app/share/licenses/libusb/COPYING"
-            ]
-        },
-        {
-            "name": "libgusb",
-            "buildsystem": "meson",
-            "config-opts": [ "-Dtests=false", "-Dvapi=false", "-Ddocs=false", "-Dintrospection=false" ],
-            "sources": [
-                {
-                    "type": "archive",
-                    "url": "https://github.com/hughsie/libgusb/archive/0.3.0.tar.gz",
-                    "sha256": "b36310f8405d5fd68f6caf4a829f7ab4c627b38fd3d02a139d411fce0f3a49f1"
-                }
             ]
         },
         {
             "name": "libfprint",
             "buildsystem": "meson",
-            "config-opts": [ "-Dudev_rules=false", "-Dx11-examples=false", "-Dgtk-examples=true", "-Ddrivers=all" ],
+            "config-opts": [ "-Dudev_rules=false", "-Dx11-examples=false", "-Dgtk-examples=true" ],
             "sources": [
                 {
                     "type": "git",
                     "url": "https://gitlab.freedesktop.org/libfprint/libfprint.git",
-                    "branch": "wip/benzea/v2"
+                    "branch": "wip/hadess/gtk-example"
                 }
             ]
         }

doc/advanced-topics.xml

@@ -60,18 +60,21 @@
     <para>
     In summary, libfprint represents fingerprints in several internal structures
     and each representation will offer you a way of determining the
-    <ulink url="#driver">driver</ulink> and <ulink url="#device-id">device ID</ulink> of the print in
+    <ulink url="#driver_id">driver ID</ulink> and <ulink url="#device-types">devtype</ulink> of the print in
     question. Prints are only compatible if the driver ID <emphasis role="strong">and</emphasis> devtypes
     match. libfprint does offer you some "is this print compatible?" helper
     functions, so you don't have to worry about these details too much.
     </para>
   </refsect2>
 
-  <refsect2 id="driver">
+  <refsect2 id="driver_id">
-    <title>Driver</title>
+    <title>Driver IDs</title>
 
     <para>
-    Each driver is assigned a unique string identifier by the project maintainer.
+    Each driver is assigned a unique ID by the project maintainer. These
+    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>
@@ -86,23 +89,22 @@
     </para>
   </refsect2>
 
-  <refsect2 id="device-id">
+  <refsect2 id="device-types">
-    <title>Device ID</title>
+    <title>Device types</title>
 
     <para>
-    Internally, the behind a device assigns a string identifier to the device
+    Internally, the <ulink url="libfprint-Driver-operations.html#libfprint-Driver-operations.description">driver</ulink> behind a device assigns a 32-bit
-    This cannot be used as a unique ID for a specific device as many devices
+    <emphasis>devtype</emphasis> identifier to the device. This cannot be used as a unique
-    under the same range may share the same devtype. The device ID may even
+    ID for a specific device as many devices under the same range may share
-    be the same string in all cases. It is guaranteed to have a non-zero length
+    the same devtype. The devtype may even be 0 in all cases.
-    and be a valid file name. It defaults to "0".
     </para>
 
     <para>
-    The only reason you may be interested in retrieving the device ID for a
+    The only reason you may be interested in retrieving the devtype for a
     device is for the purpose of checking if some print data is compatible
-    with a device. libfprint uses the device ID as one way of checking that the
+    with a device. libfprint uses the devtype as one way of checking that the
     print you are verifying is compatible with the device in question - the
-    device ID must be equal. This effectively allows drivers to support more
+    devtypes must be equal. This effectively allows drivers to support more
     than one type of device where the data from each one is not compatible with
     the other. Note that libfprint does provide you with helper functions to
     determine whether a print is compatible with a device, so under most

doc/getting-started.xml

@@ -13,12 +13,12 @@
 
   <para>
   Usually the first thing you want to do is determine which fingerprint
-  devices are present. This is done using the <ulink url="fp-context.html">FpContext</ulink> object.
+  devices are present. This is done through <ulink url="libfprint-Device-discovery.html">device discovery</ulink>.
   </para>
 
   <para>
   Once you have found a device you would like to operate, you should open it.
-  Refer to <ulink url="fp-context.html">device operations</ulink>. This section also details enrollment,
+  Refer to <ulink url="libfprint-Devices-operations.html">device operations</ulink>. This section also details enrollment,
   image capture, and verification.
   </para>
 

doc/libfprint-2-sections.txt

@@ -1,262 +0,0 @@
-<SECTION>
-<FILE>drivers_api</FILE>
-
-</SECTION>
-
-<SECTION>
-<FILE>fp-context</FILE>
-<TITLE>FpContext</TITLE>
-FP_TYPE_CONTEXT
-FpContextClass
-fp_context_new
-fp_context_enumerate
-fp_context_get_devices
-FpContext
-</SECTION>
-
-<SECTION>
-<FILE>fp-device</FILE>
-FP_TYPE_DEVICE
-FP_DEVICE_RETRY
-FP_DEVICE_ERROR
-FpDeviceType
-FpScanType
-FpDeviceRetry
-FpDeviceError
-fp_device_retry_quark
-fp_device_error_quark
-FpEnrollProgress
-FpMatchCb
-fp_device_get_driver
-fp_device_get_device_id
-fp_device_get_name
-fp_device_get_scan_type
-fp_device_get_nr_enroll_stages
-fp_device_has_storage
-fp_device_supports_identify
-fp_device_supports_capture
-fp_device_open
-fp_device_close
-fp_device_enroll
-fp_device_verify
-fp_device_identify
-fp_device_capture
-fp_device_delete_print
-fp_device_list_prints
-fp_device_open_finish
-fp_device_close_finish
-fp_device_enroll_finish
-fp_device_verify_finish
-fp_device_identify_finish
-fp_device_capture_finish
-fp_device_delete_print_finish
-fp_device_list_prints_finish
-fp_device_open_sync
-fp_device_close_sync
-fp_device_enroll_sync
-fp_device_verify_sync
-fp_device_identify_sync
-fp_device_capture_sync
-fp_device_delete_print_sync
-fp_device_list_prints_sync
-FpDevice
-</SECTION>
-
-<SECTION>
-<FILE>fp-image</FILE>
-FP_TYPE_IMAGE
-FpMinutia
-fp_image_new
-fp_image_get_width
-fp_image_get_height
-fp_image_get_ppmm
-fp_image_get_minutiae
-fp_image_detect_minutiae
-fp_image_detect_minutiae_finish
-fp_image_get_data
-fp_image_get_binarized
-fp_minutia_get_coords
-FpImage
-</SECTION>
-
-<SECTION>
-<FILE>fp-image-device</FILE>
-FP_TYPE_IMAGE_DEVICE
-FpImageDevice
-</SECTION>
-
-<SECTION>
-<FILE>fp-print</FILE>
-FP_TYPE_PRINT
-FpFinger
-FpPrint
-fp_print_new
-fp_print_new_from_data
-fp_print_to_data
-fp_print_get_driver
-fp_print_get_device_id
-fp_print_get_device_stored
-fp_print_get_image
-fp_print_get_finger
-fp_print_get_username
-fp_print_get_description
-fp_print_get_enroll_date
-fp_print_set_finger
-fp_print_set_username
-fp_print_set_description
-fp_print_set_enroll_date
-fp_print_compatible
-fp_print_equal
-fp_print_serialize
-fp_print_deserialize
-</SECTION>
-
-<SECTION>
-<FILE>fpi-assembling</FILE>
-fpi_frame
-fpi_frame_asmbl_ctx
-fpi_do_movement_estimation
-fpi_assemble_frames
-fpi_line_asmbl_ctx
-fpi_assemble_lines
-</SECTION>
-
-<SECTION>
-<FILE>fpi-context</FILE>
-fpi_get_driver_types
-</SECTION>
-
-<SECTION>
-<FILE>fpi-device</FILE>
-FpDeviceClass
-FpTimeoutFunc
-FpiDeviceAction
-FpIdEntry
-fpi_device_get_usb_device
-fpi_device_get_virtual_env
-fpi_device_get_current_action
-fpi_device_retry_new
-fpi_device_error_new
-fpi_device_retry_new_msg
-fpi_device_error_new_msg
-fpi_device_get_driver_data
-fpi_device_get_enroll_data
-fpi_device_get_capture_data
-fpi_device_get_verify_data
-fpi_device_get_identify_data
-fpi_device_get_delete_data
-fpi_device_get_cancellable
-fpi_device_action_is_cancelled
-fpi_device_add_timeout
-fpi_device_set_nr_enroll_stages
-fpi_device_set_scan_type
-fpi_device_action_error
-fpi_device_probe_complete
-fpi_device_open_complete
-fpi_device_close_complete
-fpi_device_enroll_complete
-fpi_device_verify_complete
-fpi_device_identify_complete
-fpi_device_capture_complete
-fpi_device_delete_complete
-fpi_device_enroll_progress
-fpi_device_verify_report
-fpi_device_identify_report
-</SECTION>
-
-<SECTION>
-<FILE>fpi-image</FILE>
-FpiImageFlags
-FpImage
-fpi_std_sq_dev
-fpi_mean_sq_diff_norm
-fpi_image_resize
-</SECTION>
-
-<SECTION>
-<FILE>fpi-image-device</FILE>
-<TITLE>Internal FpImageDevice</TITLE>
-FpiImageDeviceState
-FpImageDeviceClass
-fpi_image_device_session_error
-fpi_image_device_open_complete
-fpi_image_device_close_complete
-fpi_image_device_activate_complete
-fpi_image_device_deactivate_complete
-fpi_image_device_report_finger_status
-fpi_image_device_image_captured
-fpi_image_device_retry_scan
-</SECTION>
-
-<SECTION>
-<FILE>fpi-log</FILE>
-fp_dbg
-fp_info
-fp_warn
-fp_err
-BUG_ON
-BUG
-</SECTION>
-
-<SECTION>
-<FILE>fpi-print</FILE>
-FpiPrintType
-FpiMatchResult
-fpi_print_add_print
-fpi_print_set_type
-fpi_print_set_device_stored
-fpi_print_add_from_image
-fpi_print_bz3_match
-fpi_print_generate_user_id
-fpi_print_fill_from_user_id
-</SECTION>
-
-<SECTION>
-<FILE>fpi-ssm</FILE>
-FpiSsmCompletedCallback
-FpiSsmHandlerCallback
-fpi_ssm_new
-fpi_ssm_new_full
-fpi_ssm_free
-fpi_ssm_start
-fpi_ssm_start_subsm
-fpi_ssm_next_state
-fpi_ssm_next_state_delayed
-fpi_ssm_jump_to_state
-fpi_ssm_jump_to_state_delayed
-fpi_ssm_cancel_delayed_state_change
-fpi_ssm_mark_completed
-fpi_ssm_mark_failed
-fpi_ssm_set_data
-fpi_ssm_get_data
-fpi_ssm_get_error
-fpi_ssm_dup_error
-fpi_ssm_get_cur_state
-fpi_ssm_next_state_timeout_cb
-fpi_ssm_usb_transfer_cb
-FpiSsm
-</SECTION>
-
-<SECTION>
-<FILE>fpi-usb-transfer</FILE>
-FPI_USB_ENDPOINT_IN
-FPI_USB_ENDPOINT_OUT
-FpiUsbTransferCallback
-FpiTransferType
-FpiUsbTransfer
-fpi_usb_transfer_new
-fpi_usb_transfer_ref
-fpi_usb_transfer_unref
-fpi_usb_transfer_set_short_error
-fpi_usb_transfer_fill_bulk
-fpi_usb_transfer_fill_bulk_full
-fpi_usb_transfer_fill_control
-fpi_usb_transfer_fill_interrupt
-fpi_usb_transfer_fill_interrupt_full
-fpi_usb_transfer_submit
-fpi_usb_transfer_submit_sync
-<SUBSECTION Standard>
-FPI_TYPE_USB_TRANSFER
-fpi_usb_transfer_get_type
-</SECTION>
-

doc/libfprint-docs.xml

@@ -25,43 +25,41 @@
 
   <part>
     <title>Library API Documentation</title>
-    <xi:include href="xml/fp-context.xml"/>
+    <xi:include href="xml/events.xml"/>
-    <xi:include href="xml/fp-device.xml"/>
+    <xi:include href="xml/discovery.xml"/>
-    <xi:include href="xml/fp-image-device.xml"/>
+
-    <xi:include href="xml/fp-print.xml"/>
+    <xi:include href="xml/drv.xml"/>
-    <xi:include href="xml/fp-image.xml"/>
+    <xi:include href="xml/dev.xml"/>
+    <xi:include href="xml/print_data.xml"/>
+    <!-- FIXME https://bugs.freedesktop.org/show_bug.cgi?id=106550 -->
+    <xi:include href="xml/dscv_print.xml"/>
+    <xi:include href="xml/img.xml"/>
   </part>
 
   <part>
     <title>Writing Drivers</title>
-    <chapter id="driver-dev">
+    <chapter id="driver-helpers">
-      <title>Device methods for drivers</title>
+      <title>Logging, and async machinery</title>
-      <xi:include href="xml/fpi-device.xml"/>
+      <xi:include href="xml/fpi-log.xml"/>
-      <xi:include href="xml/fpi-image-device.xml"/>
+      <xi:include href="xml/fpi-ssm.xml"/>
+      <xi:include href="xml/fpi-poll.xml"/>
     </chapter>
 
-    <chapter id="driver-helpers">
+    <chapter id="driver-dev">
-      <title>USB and State Machine helpers</title>
+      <title>Device and driver structures</title>
-      <xi:include href="xml/fpi-usb-transfer.xml"/>
+      <xi:include href="xml/fpi-dev.xml"/>
-      <xi:include href="xml/fpi-ssm.xml"/>
+      <xi:include href="xml/fpi-dev-img.xml"/>
-      <xi:include href="xml/fpi-log.xml"/>
+      <xi:include href="xml/fpi-core.xml"/>
+      <xi:include href="xml/fpi-core-img.xml"/>
     </chapter>
 
     <chapter id="driver-img">
       <title>Image manipulation</title>
-      <xi:include href="xml/fpi-image.xml"/>
+      <xi:include href="xml/fpi-img.xml"/>
       <xi:include href="xml/fpi-assembling.xml"/>
     </chapter>
 
-    <chapter id="driver-print">
+    <xi:include href="xml/fpi-usb.xml"/>
-      <title>Print handling</title>
-      <xi:include href="xml/fpi-print.xml"/>
-    </chapter>
-
-    <chapter id="driver-misc">
-      <title>Listing drivers</title>
-      <xi:include href="xml/fpi-context.xml"/>
-    </chapter>
   </part>
 
   <index id="api-index">

doc/libfprint-sections.txt

@@ -0,0 +1,271 @@
+
+<SECTION>
+<INCLUDE>fprint.h</INCLUDE>
+<FILE>events</FILE>
+<TITLE>Initialisation and events handling</TITLE>
+LIBFPRINT_DEPRECATED
+fp_set_debug
+fp_init
+fp_exit
+fp_pollfd
+fp_handle_events_timeout
+fp_handle_events
+fp_get_next_timeout
+fp_get_pollfds
+fp_pollfd_added_cb
+fp_pollfd_removed_cb
+fp_set_pollfd_notifiers
+</SECTION>
+
+<SECTION>
+<INCLUDE>fprint.h</INCLUDE>
+<FILE>discovery</FILE>
+<TITLE>Device discovery</TITLE>
+fp_dscv_dev
+fp_discover_devs
+fp_dscv_devs_free
+fp_dscv_dev_get_driver
+fp_dscv_dev_get_devtype
+fp_dscv_dev_get_driver_id
+fp_dscv_dev_supports_print_data
+fp_dscv_dev_supports_dscv_print
+fp_dscv_dev_for_print_data
+fp_dscv_dev_for_dscv_print
+</SECTION>
+
+<SECTION>
+<INCLUDE>fprint.h</INCLUDE>
+<FILE>drv</FILE>
+fp_driver
+fp_driver_get_name
+fp_driver_get_full_name
+fp_driver_get_driver_id
+fp_driver_get_scan_type
+fp_driver_supports_imaging
+</SECTION>
+
+<SECTION>
+<INCLUDE>fprint.h</INCLUDE>
+<FILE>dev</FILE>
+fp_dev
+fp_scan_type
+fp_capture_result
+fp_enroll_result
+fp_verify_result
+
+fp_dev_get_driver
+fp_dev_get_nr_enroll_stages
+fp_dev_get_devtype
+fp_dev_supports_print_data
+fp_dev_supports_imaging
+fp_dev_supports_identification
+fp_dev_supports_dscv_print
+fp_dev_get_img_width
+fp_dev_get_img_height
+
+fp_operation_stop_cb
+fp_img_operation_cb
+fp_dev_open_cb
+fp_enroll_stage_cb
+fp_identify_cb
+
+fp_dev_open
+fp_async_dev_open
+
+fp_dev_close
+fp_async_dev_close
+
+fp_enroll_finger
+fp_enroll_finger_img
+fp_async_enroll_start
+fp_async_enroll_stop
+
+fp_verify_finger
+fp_verify_finger_img
+fp_async_verify_start
+fp_async_verify_stop
+
+fp_identify_finger
+fp_identify_finger_img
+fp_async_identify_start
+fp_async_identify_stop
+
+fp_dev_img_capture
+fp_async_capture_start
+fp_async_capture_stop
+</SECTION>
+
+<SECTION>
+<INCLUDE>fprint.h</INCLUDE>
+<FILE>print_data</FILE>
+fp_finger
+fp_print_data
+fp_print_data_get_data
+fp_print_data_from_data
+fp_print_data_save
+fp_print_data_load
+fp_print_data_delete
+fp_print_data_from_dscv_print
+fp_print_data_free
+fp_print_data_get_driver_id
+fp_print_data_get_devtype
+</SECTION>
+
+<SECTION>
+<INCLUDE>fprint.h</INCLUDE>
+<FILE>dscv_print</FILE>
+fp_dscv_print
+fp_discover_prints
+fp_dscv_prints_free
+fp_dscv_print_get_driver_id
+fp_dscv_print_get_devtype
+fp_dscv_print_get_finger
+fp_dscv_print_delete
+</SECTION>
+
+<SECTION>
+<INCLUDE>fprint.h</INCLUDE>
+<FILE>img</FILE>
+fp_img
+fp_minutia
+fp_img_free
+fp_img_get_height
+fp_img_get_width
+fp_img_get_data
+fp_img_save_to_file
+fp_img_standardize
+fp_img_binarize
+fp_img_get_minutiae
+fp_minutia_get_coords
+</SECTION>
+
+<SECTION>
+<INCLUDE>fpi-log.h</INCLUDE>
+<FILE>fpi-log</FILE>
+fp_dbg
+fp_info
+fp_warn
+fp_err
+BUG_ON
+BUG
+</SECTION>
+
+<SECTION>
+<INCLUDE>fpi-ssm.h</INCLUDE>
+<FILE>fpi-ssm</FILE>
+fpi_ssm
+ssm_completed_fn
+ssm_handler_fn
+
+fpi_ssm_new
+fpi_ssm_free
+fpi_ssm_start
+fpi_ssm_start_subsm
+
+fpi_ssm_next_state
+fpi_ssm_next_state_timeout_cb
+fpi_ssm_jump_to_state
+fpi_ssm_mark_completed
+fpi_ssm_mark_failed
+fpi_ssm_get_user_data
+fpi_ssm_get_error
+fpi_ssm_get_cur_state
+</SECTION>
+
+<SECTION>
+<INCLUDE>fpi-poll.h</INCLUDE>
+<FILE>fpi-poll</FILE>
+fpi_timeout
+fpi_timeout_fn
+fpi_timeout_add
+fpi_timeout_set_name
+fpi_timeout_cancel
+</SECTION>
+
+<SECTION>
+<INCLUDE>fpi-dev.h</INCLUDE>
+<FILE>fpi-dev</FILE>
+fp_img_dev
+
+FP_DEV
+FP_IMG_DEV
+fp_dev_set_instance_data
+FP_INSTANCE_DATA
+
+fpi_dev_get_usb_dev
+fpi_dev_get_verify_data
+fpi_dev_set_nr_enroll_stages
+</SECTION>
+
+<SECTION>
+<INCLUDE>fpi-dev-img.h</INCLUDE>
+<FILE>fpi-dev-img</FILE>
+fp_imgdev_action
+fp_imgdev_state
+fp_imgdev_enroll_state
+
+fpi_imgdev_abort_scan
+fpi_imgdev_activate_complete
+fpi_imgdev_close_complete
+fpi_imgdev_deactivate_complete
+fpi_imgdev_get_action
+fpi_imgdev_get_action_result
+fpi_imgdev_get_action_state
+fpi_imgdev_image_captured
+fpi_imgdev_open_complete
+fpi_imgdev_report_finger_status
+fpi_imgdev_session_error
+fpi_imgdev_set_action_result
+</SECTION>
+
+<SECTION>
+<INCLUDE>fpi-core.h</INCLUDE>
+<FILE>fpi-core</FILE>
+usb_id
+fp_driver_type
+</SECTION>
+
+<SECTION>
+<INCLUDE>fpi-core.h</INCLUDE>
+<FILE>fpi-core-img</FILE>
+FpiImgDriverFlags
+fp_img_driver
+</SECTION>
+
+<SECTION>
+<INCLUDE>fpi-img.h</INCLUDE>
+<FILE>fpi-img</FILE>
+FpiImgFlags
+
+fpi_img_new
+fpi_img_new_for_imgdev
+fpi_img_realloc
+fpi_img_resize
+
+fpi_std_sq_dev
+fpi_mean_sq_diff_norm
+</SECTION>
+
+<SECTION>
+<INCLUDE>fpi-assembling.h</INCLUDE>
+<FILE>fpi-assembling</FILE>
+fpi_frame
+fpi_frame_asmbl_ctx
+fpi_line_asmbl_ctx
+
+fpi_do_movement_estimation
+fpi_assemble_frames
+fpi_assemble_lines
+</SECTION>
+
+<SECTION>
+<INCLUDE>fpi-usb.h</INCLUDE>
+<FILE>fpi-usb</FILE>
+fpi_usb_transfer
+
+fpi_usb_transfer_cb_fn
+fpi_usb_alloc
+fpi_usb_fill_bulk_transfer
+fpi_usb_submit_transfer
+fpi_usb_cancel_transfer
+</SECTION>

doc/libfprint-sections.txt-new-manual

@@ -1,116 +0,0 @@
-
-<SECTION>
-<INCLUDE>fprint.h</INCLUDE>
-<FILE>context</FILE>
-<TITLE>Device discovery and hotplugging</TITLE>
-FP_TYPE_CONTEXT
-FpContext
-fp_context_new
-fp_context_enumerate
-fp_context_get_devices
-</SECTION>
-
-
-<SECTION>
-<INCLUDE>fprint.h</INCLUDE>
-<FILE>device</FILE>
-<TITLE>Device</TITLE>
-FP_TYPE_DEVICE
-FpDevice
-FpDeviceType
-FpScanType
-FpDeviceRetry
-FpDeviceError
-FP_DEVICE_ERROR
-FP_DEVICE_RETRY
-fp_device_get_driver
-fp_device_get_device_id
-fp_device_get_name
-fp_device_get_scan_type
-
-fp_device_open
-fp_device_open_finish
-fp_device_open_sync
-
-fp_device_close
-fp_device_close_finish
-fp_device_close_sync
-
-fp_device_enroll
-fp_device_enroll_finish
-fp_device_enroll_sync
-
-fp_device_identify
-fp_device_identify_finish
-fp_device_identify_sync
-
-fp_device_capture
-fp_device_capture_finish
-fp_device_capture_sync
-
-fp_device_verify
-fp_device_verify_finish
-fp_device_verify_sync
-
-_fp_device_get_cancellable
-</SECTION>
-
-
-<SECTION>
-<INCLUDE>fprint.h</INCLUDE>
-<FILE>print</FILE>
-<TITLE>Fingerprint handling</TITLE>
-FpPrint
-fp_print_new
-</SECTION>
-
-
-<SECTION>
-<INCLUDE>fprint.h</INCLUDE>
-<FILE>image</FILE>
-<TITLE>Image handling</TITLE>
-FP_TYPE_IMAGE
-FpImage
-fp_image_new
-fp_image_detect_minutiae
-fp_image_detect_minutiae_finish
-fp_image_device_new
-fp_image_get_binarized
-fp_image_get_data
-fp_image_get_height
-fp_image_get_minutiae
-fp_image_get_ppmm
-fp_image_get_width
-</SECTION>
-
-
-<SECTION>
-<FILE>internal-image-device</FILE>
-<INCLUDE>drivers_api.h</INCLUDE>
-<TITLE>Base class for image devices</TITLE>
-FpImageDevice
-FpImageDeviceClass
-FpiImageDeviceState
-</SECTION>
-
-<SECTION>
-<FILE>internal-usb-transfers</FILE>
-<INCLUDE>drivers_api.h</INCLUDE>
-<TITLE>USB Transfers</TITLE>
-FpUsbTransfer
-fp_usb_transfer_fill_bulk
-fp_usb_transfer_fill_bulk_full
-fp_usb_transfer_fill_control
-fp_usb_transfer_fill_interrupt
-fp_usb_transfer_fill_interrupt_full
-fp_usb_transfer_get_type
-fp_usb_transfer_new
-fp_usb_transfer_ref
-fp_usb_transfer_set_short_error
-fp_usb_transfer_submit
-fp_usb_transfer_submit_sync
-fp_usb_transfer_unref
-FpUsbTransferCallback
-FP_USB_ENDPOINT_IN
-FP_USB_ENDPOINT_OUT
-</SECTION>

doc/meson.build

@@ -2,12 +2,42 @@ subdir('xml')
 
 private_headers = [
   'config.h',
-    'nbis-helpers.h',
-    'fprint.h',
 
-    # Subdirectories to ignore
+  'aeslib.h',
-    'drivers',
+  'assembling.h',
-    'nbis',
+  'fp_internal.h',
+  'nbis-helpers.h',
+  'fpi-async.h',
+  'fpi-data.h',
+
+  # Drivers
+  'aes1660.h',
+  'aes2501.h',
+  'aes2550.h',
+  'aes2660.h',
+  'aes3k.h',
+  'aesx660.h',
+  'driver_ids.h',
+  'elan.h',
+  'upek_proto.h',
+  'upeksonly.h',
+  'upektc.h',
+  'upektc_img.h',
+  'vfs0050.h',
+  'vfs301_proto_fragments.h',
+  'vfs301_proto.h',
+  'vfs5011_proto.h',
+  'synaptics.h',
+
+  # NBIS
+  'morph.h',
+  'sunrast.h',
+  'bozorth.h',
+  'defs.h',
+  'log.h',
+  'bz_array.h',
+  'lfs.h',
+  'mytime.h',
 ]
 
 html_images = [
@@ -23,13 +53,16 @@ glib_prefix = dependency('glib-2.0').get_pkgconfig_variable('prefix')
 glib_docpath = join_paths(glib_prefix, 'share', 'gtk-doc', 'html')
 docpath = join_paths(get_option('datadir'), 'gtk-doc', 'html')
 
-gnome.gtkdoc(versioned_libname,
+gnome.gtkdoc('libfprint',
              main_xml: 'libfprint-docs.xml',
              src_dir: join_paths(meson.source_root(), 'libfprint'),
              dependencies: libfprint_dep,
              content_files: content_files,
              expand_content_files: expand_content_files,
-    ignore_headers: private_headers,
+             scan_args: [
+               '--ignore-decorators=API_EXPORTED',
+               '--ignore-headers=' + ' '.join(private_headers),
+             ],
              fixxref_args: [
                '--html-dir=@0@'.format(docpath),
                '--extra-dir=@0@'.format(join_paths(glib_docpath, 'glib')),

doc/xml/meson.build

@@ -1,12 +1,10 @@
 ent_conf = configuration_data()
-ent_conf.set('PACKAGE', versioned_libname)
+ent_conf.set('PACKAGE', 'libfprint')
 ent_conf.set('PACKAGE_BUGREPORT', 'https://gitlab.freedesktop.org/libfprint/libfprint/issues')
-ent_conf.set('PACKAGE_NAME', versioned_libname)
+ent_conf.set('PACKAGE_NAME', 'libfprint')
-ent_conf.set('PACKAGE_STRING', versioned_libname)
+ent_conf.set('PACKAGE_STRING', 'libfprint')
 ent_conf.set('PACKAGE_TARNAME', 'libfprint-' + meson.project_version())
 ent_conf.set('PACKAGE_URL', 'https://fprint.freedesktop.org/')
 ent_conf.set('PACKAGE_VERSION', meson.project_version())
 ent_conf.set('PACKAGE_API_VERSION', '1.0')
-configure_file(input: 'gtkdocentities.ent.in',
+configure_file(input: 'gtkdocentities.ent.in', output: 'gtkdocentities.ent', configuration: ent_conf)
-    output: 'gtkdocentities.ent',
-    configuration: ent_conf)

examples/cpp-test.cpp

@@ -6,10 +6,6 @@
 
 int main (int argc, char **argv)
 {
-  FpContext *ctx;
+	fp_init ();
-
-  ctx = fp_context_new ();
-  g_object_unref (ctx);
-
 	return 0;
 }

examples/delete.c

@@ -0,0 +1,115 @@
+/*
+ * Example fingerprint delete finger program, which delete the right index
+ * finger which has been previously enrolled to disk.
+ * Copyright (C) 2019 Synaptics Inc
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <libfprint/fprint.h>
+
+struct fp_dscv_dev *discover_device(struct fp_dscv_dev **discovered_devs)
+{
+	struct fp_dscv_dev *ddev = discovered_devs[0];
+	struct fp_driver *drv;
+	if (!ddev)
+		return NULL;
+	
+	drv = fp_dscv_dev_get_driver(ddev);
+	printf("Found device claimed by %s driver\n", fp_driver_get_full_name(drv));
+	return ddev;
+}
+
+
+int main(void)
+{
+	int r = 1;
+	struct fp_dscv_dev *ddev;
+	struct fp_dscv_dev **discovered_devs;
+	struct fp_dev *dev;
+	struct fp_print_data *data;
+
+	setenv ("G_MESSAGES_DEBUG", "all", 0);
+	setenv ("LIBUSB_DEBUG", "3", 0);
+
+	r = fp_init();
+	if (r < 0) {
+		fprintf(stderr, "Failed to initialize libfprint\n");
+		exit(1);
+	}
+
+	discovered_devs = fp_discover_devs();
+	if (!discovered_devs) {
+		fprintf(stderr, "Could not discover devices\n");
+		goto out;
+	}
+
+	ddev = discover_device(discovered_devs);
+	if (!ddev) {
+		fprintf(stderr, "No devices detected.\n");
+		goto out;
+	}
+
+	dev = fp_dev_open(ddev);
+	fp_dscv_devs_free(discovered_devs);
+	if (!dev) {
+		fprintf(stderr, "Could not open device.\n");
+		goto out;
+	}
+
+	printf("Opened device. Loading previously enrolled right index finger "
+		"data...\n");
+
+	r = fp_print_data_load(dev, RIGHT_INDEX, &data);
+	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");
+		goto out_close;
+	}
+
+	printf("Print loaded. delete data in sensor.\n");
+	if(!fp_dev_supports_data_in_sensor(dev))
+	{
+		printf("This driver doesn't support to store data in sensor.\n");
+		goto out_close;
+	}
+		
+	r = fp_delete_finger(dev, data);
+	fp_print_data_free(data);
+	if (r) {
+		printf("delete finger failed with error %d :(\n", r);
+	}
+	else
+	{
+		printf("sensor data deleted. now delete host data");
+		r = fp_print_data_delete(dev, RIGHT_INDEX);
+		if (r < 0) {
+			printf("Delete sensor data successfully but delete host data failed. %d :(\n", r);
+		}
+	}
+	
+out_close:
+	fp_dev_close(dev);
+out:
+	fp_exit();
+	return r;
+}
+
+

examples/enroll.c

@@ -1,8 +1,7 @@
 /*
  * Example fingerprint enrollment program
- * Enrolls your chosen finger and saves the print to disk
+ * Enrolls your right index finger and saves the print to disk
  * Copyright (C) 2007 Daniel Drake <dsd@gentoo.org>
- * Copyright (C) 2019 Marco Trevisan <marco.trevisan@canonical.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -19,203 +18,143 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#define FP_COMPONENT "example-enroll"
-
 #include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
 #include <libfprint/fprint.h>
-#include <glib-unix.h>
 
-#include "storage.h"
+struct fp_dscv_dev *discover_device(struct fp_dscv_dev **discovered_devs)
-#include "utilities.h"
-
-typedef struct _EnrollData
 {
-  GMainLoop    *loop;
+	struct fp_dscv_dev *ddev = discovered_devs[0];
-  GCancellable *cancellable;
+	struct fp_driver *drv;
-  unsigned int  sigint_handler;
+	if (!ddev)
-  FpFinger      finger;
+		return NULL;
-  int           ret_value;
-} EnrollData;
 	
-static void
+	drv = fp_dscv_dev_get_driver(ddev);
-enroll_data_free (EnrollData *enroll_data)
+	printf("Found device claimed by %s driver\n", fp_driver_get_full_name(drv));
-{
+	return ddev;
-  g_clear_handle_id (&enroll_data->sigint_handler, g_source_remove);
-  g_clear_object (&enroll_data->cancellable);
-  g_main_loop_unref (enroll_data->loop);
-  g_free (enroll_data);
-}
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (EnrollData, enroll_data_free)
-
-static void
-on_device_closed (FpDevice *dev, GAsyncResult *res, void *user_data)
-{
-  EnrollData *enroll_data = user_data;
-
-  g_autoptr(GError) error = NULL;
-
-  fp_device_close_finish (dev, res, &error);
-
-  if (error)
-    g_warning ("Failed closing device %s\n", error->message);
-
-  g_main_loop_quit (enroll_data->loop);
 }
 
-static void
+struct fp_print_data *enroll(struct fp_dev *dev) {
-on_enroll_completed (FpDevice *dev, GAsyncResult *res, void *user_data)
+	struct fp_print_data *enrolled_print = NULL;
-{
+	int r;
-  EnrollData *enroll_data = user_data;
 
-  g_autoptr(FpPrint) print = NULL;
+	printf("You will need to successfully scan your finger %d times to "
-  g_autoptr(GError) error = NULL;
+		"complete the process.\n", fp_dev_get_nr_enroll_stages(dev));
 
-  print = fp_device_enroll_finish (dev, res, &error);
+	do {
+		struct fp_img *img = NULL;
 
-  if (!error)
+		printf("\nScan your finger now.\n");
-    {
-      enroll_data->ret_value = EXIT_SUCCESS;
 
-      if (!fp_device_has_storage (dev))
+		r = fp_enroll_finger_img(dev, &enrolled_print, &img);
-        {
+		if (img) {
-          g_debug ("Device has not storage, saving locally");
+			fp_img_save_to_file(img, "enrolled.pgm");
-          int r = print_data_save (print, enroll_data->finger);
-          if (r < 0)
-            {
-              g_warning ("Data save failed, code %d", r);
-              enroll_data->ret_value = EXIT_FAILURE;
-            }
-        }
-    }
-  else
-    {
-      g_warning ("Enroll failed with error %s\n", error->message);
-    }
-
-  fp_device_close (dev, NULL, (GAsyncReadyCallback) on_device_closed,
-                   enroll_data);
-}
-
-static void
-on_enroll_progress (FpDevice *device,
-                    gint      completed_stages,
-                    FpPrint  *print,
-                    gpointer  user_data,
-                    GError   *error)
-{
-  if (error)
-    {
-      g_warning ("Enroll stage %d of %d failed with error %s",
-                 completed_stages,
-                 fp_device_get_nr_enroll_stages (device),
-                 error->message);
-      return;
-    }
-
-  if (fp_device_supports_capture (device) &&
-      print_image_save (print, "enrolled.pgm"))
 			printf("Wrote scanned image to enrolled.pgm\n");
-
+			fp_img_free(img);
-  printf ("Enroll stage %d of %d passed. Yay!\n", completed_stages,
+		}
-          fp_device_get_nr_enroll_stages (device));
+		if (r < 0) {
+			printf("Enroll failed with error %d\n", r);
+			return NULL;
 		}
 
-static void
+		switch (r) {
-on_device_opened (FpDevice *dev, GAsyncResult *res, void *user_data)
+		case FP_ENROLL_COMPLETE:
-{
+			printf("Enroll complete!\n");
-  EnrollData *enroll_data = user_data;
+			break;
-  FpPrint *print_template;
+		case FP_ENROLL_FAIL:
+			printf("Enroll failed, something wen't wrong :(\n");
+			return NULL;
+		case FP_ENROLL_PASS:
+			printf("Enroll stage passed. Yay!\n");
+			break;
+		case FP_ENROLL_RETRY:
+			printf("Didn't quite catch that. Please try again.\n");
+			break;
+		case FP_ENROLL_RETRY_TOO_SHORT:
+			printf("Your swipe was too short, please try again.\n");
+			break;
+		case FP_ENROLL_RETRY_CENTER_FINGER:
+			printf("Didn't catch that, please center your finger on the "
+				"sensor and try again.\n");
+			break;
+		case FP_ENROLL_RETRY_REMOVE_FINGER:
+			printf("Scan failed, please remove your finger and then try "
+				"again.\n");
+			break;
+		}
+	} while (r != FP_ENROLL_COMPLETE);
 
-  g_autoptr(GError) error = NULL;
+	if (!enrolled_print) {
-
+		fprintf(stderr, "Enroll complete but no print?\n");
-  if (!fp_device_open_finish (dev, res, &error))
+		return NULL;
-    {
-      g_warning ("Failed to open device: %s", error->message);
-      g_main_loop_quit (enroll_data->loop);
-      return;
 	}
 
-  printf ("Opened device. It's now time to enroll your finger.\n\n");
+	printf("Enrollment completed!\n\n");
-  printf ("You will need to successfully scan your %s finger %d times to "
+	return enrolled_print;
-          "complete the process.\n\n", finger_to_string (enroll_data->finger),
-          fp_device_get_nr_enroll_stages (dev));
-  printf ("Scan your finger now.\n");
-
-  print_template = print_create_template (dev, enroll_data->finger);
-  fp_device_enroll (dev, print_template, enroll_data->cancellable,
-                    on_enroll_progress, NULL, NULL,
-                    (GAsyncReadyCallback) on_enroll_completed,
-                    enroll_data);
 }
 
-static gboolean
+int main(void)
-sigint_cb (void *user_data)
 {
-  EnrollData *enroll_data = user_data;
+	int r = 1;
+	struct fp_dscv_dev *ddev;
+	struct fp_dscv_dev **discovered_devs;
+	struct fp_dev *dev;
+	struct fp_print_data *data;
 
-  g_cancellable_cancel (enroll_data->cancellable);
+	printf("This program will enroll your right index finger, "
-
+		"unconditionally overwriting any right-index print that was enrolled "
-  return G_SOURCE_CONTINUE;
-}
-
-int
-main (void)
-{
-  g_autoptr(FpContext) ctx = NULL;
-  g_autoptr(EnrollData) enroll_data = NULL;
-  GPtrArray *devices;
-  FpDevice *dev;
-  FpFinger finger;
-
-  g_print ("This program will enroll the selected finger, unconditionally "
-           "overwriting any print for the same finger that was enrolled "
 		"previously. If you want to continue, press enter, otherwise hit "
 		"Ctrl+C\n");
 	getchar();
 
-  g_print ("Choose the finger to enroll:\n");
-  finger = finger_chooser ();
-
-  if (finger == FP_FINGER_UNKNOWN)
-    {
-      g_warning ("Unknown finger selected");
-      return EXIT_FAILURE;
-    }
-
 	setenv ("G_MESSAGES_DEBUG", "all", 0);
+	setenv ("LIBUSB_DEBUG", "3", 0);
 
-  ctx = fp_context_new ();
+	r = fp_init();
-
+	if (r < 0) {
-  devices = fp_context_get_devices (ctx);
+		fprintf(stderr, "Failed to initialize libfprint\n");
-  if (!devices)
+		exit(1);
-    {
-      g_warning ("Impossible to get devices");
-      return EXIT_FAILURE;
 	}
 
-  dev = discover_device (devices);
+	discovered_devs = fp_discover_devs();
-  if (!dev)
+	if (!discovered_devs) {
-    {
+		fprintf(stderr, "Could not discover devices\n");
-      g_warning ("No devices detected.");
+		goto out;
-      return EXIT_FAILURE;
 	}
 
-  enroll_data = g_new0 (EnrollData, 1);
+	ddev = discover_device(discovered_devs);
-  enroll_data->finger = finger;
+	if (!ddev) {
-  enroll_data->ret_value = EXIT_FAILURE;
+		fprintf(stderr, "No devices detected.\n");
-  enroll_data->loop = g_main_loop_new (NULL, FALSE);
+		goto out;
-  enroll_data->cancellable = g_cancellable_new ();
-  enroll_data->sigint_handler = g_unix_signal_add_full (G_PRIORITY_HIGH,
-                                                        SIGINT,
-                                                        sigint_cb,
-                                                        enroll_data,
-                                                        NULL);
-
-  fp_device_open (dev, enroll_data->cancellable,
-                  (GAsyncReadyCallback) on_device_opened,
-                  enroll_data);
-
-  g_main_loop_run (enroll_data->loop);
-
-  return enroll_data->ret_value;
 	}
+
+	dev = fp_dev_open(ddev);
+	fp_dscv_devs_free(discovered_devs);
+	if (!dev) {
+		fprintf(stderr, "Could not open device.\n");
+		goto out;
+	}
+
+	printf("Opened device. It's now time to enroll your finger.\n\n");
+	data = enroll(dev);
+	if (!data)
+		goto out_close;
+
+#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);
+
+	fp_print_data_free(data);
+out_close:
+	fp_dev_close(dev);
+out:
+	fp_exit();
+	return r;
+}
+
+

examples/img_capture.c

@@ -0,0 +1,108 @@
+/*
+ * Example libfprint image capture program
+ * Copyright (C) 2007 Daniel Drake <dsd@gentoo.org>
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+
+#include <libfprint/fprint.h>
+
+struct fp_dscv_dev *discover_device(struct fp_dscv_dev **discovered_devs)
+{
+	struct fp_dscv_dev *ddev = discovered_devs[0];
+	struct fp_driver *drv;
+	if (!ddev)
+		return NULL;
+	
+	drv = fp_dscv_dev_get_driver(ddev);
+	printf("Found device claimed by %s driver\n", fp_driver_get_full_name(drv));
+	return ddev;
+}
+
+int main(void)
+{
+	int r = 1;
+	struct fp_dscv_dev *ddev;
+	struct fp_dscv_dev **discovered_devs;
+	struct fp_dev *dev;
+	struct fp_img *img = NULL;
+
+	setenv ("G_MESSAGES_DEBUG", "all", 0);
+	setenv ("LIBUSB_DEBUG", "3", 0);
+
+	r = fp_init();
+	if (r < 0) {
+		fprintf(stderr, "Failed to initialize libfprint\n");
+		exit(1);
+	}
+
+	discovered_devs = fp_discover_devs();
+	if (!discovered_devs) {
+		fprintf(stderr, "Could not discover devices\n");
+		goto out;
+	}
+
+	ddev = discover_device(discovered_devs);
+	if (!ddev) {
+		fp_dscv_devs_free(discovered_devs);
+		fprintf(stderr, "No devices detected.\n");
+		goto out;
+	}
+
+	dev = fp_dev_open(ddev);
+	fp_dscv_devs_free(discovered_devs);
+	if (!dev) {
+		fprintf(stderr, "Could not open device.\n");
+		goto out;
+	}
+
+	if (!fp_dev_supports_imaging(dev)) {
+		fprintf(stderr, "this device does not have imaging capabilities.\n");
+		goto out_close;
+	}
+
+	printf("Opened device. It's now time to scan your finger.\n\n");
+
+	r = fp_dev_img_capture(dev, 0, &img);
+	if (r) {
+		fprintf(stderr, "image capture failed, code %d\n", r);
+		goto out_close;
+	}
+
+	r = fp_img_save_to_file(img, "finger.pgm");
+	if (r) {
+		fprintf(stderr, "img save failed, code %d\n", r);
+		goto out_close;
+	}
+
+	fp_img_standardize(img);
+	r = fp_img_save_to_file(img, "finger_standardized.pgm");
+	fp_img_free(img);
+	if (r) {
+		fprintf(stderr, "standardized img save failed, code %d\n", r);
+		goto out_close;
+	}
+
+	r = 0;
+out_close:
+	fp_dev_close(dev);
+out:
+	fp_exit();
+	return r;
+}
+

examples/img_capture_continuous.c

@@ -0,0 +1,261 @@
+/*
+ * Example libfprint continuous image capture program
+ * Copyright (C) 2007 Daniel Drake <dsd@gentoo.org>
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <libfprint/fprint.h>
+#include <X11/Xlib.h>
+#include <X11/keysym.h>
+#include <X11/extensions/Xvlib.h>
+
+#define FORMAT 0x32595559
+
+static int adaptor = -1;
+static char *framebuffer = NULL;
+
+static Display *display = NULL;
+static Window window=(Window)NULL;
+static XvImage *xv_image = NULL;
+static XvAdaptorInfo *info;
+static GC gc;
+static int connection = -1;
+
+/* based on macro by Bart Nabbe */
+#define GREY2YUV(grey, y, u, v)\
+  y = (9798*grey + 19235*grey + 3736*grey)  / 32768;\
+  u = (-4784*grey - 9437*grey + 14221*grey)  / 32768 + 128;\
+  v = (20218*grey - 16941*grey - 3277*grey) / 32768 + 128;\
+  y = y < 0 ? 0 : y;\
+  u = u < 0 ? 0 : u;\
+  v = v < 0 ? 0 : v;\
+  y = y > 255 ? 255 : y;\
+  u = u > 255 ? 255 : u;\
+  v = v > 255 ? 255 : v
+
+static void grey2yuy2 (unsigned char *grey, char *YUV, int num) {
+	int i, j;
+	int y0, y1, u0, u1, v0, v1;
+	uint64_t gval;
+
+	for (i = 0, j = 0; i < num; i += 2, j += 4)
+	{
+		gval = grey[i];
+		GREY2YUV (gval, y0, u0 , v0);
+		gval = grey[i + 1];
+		GREY2YUV (gval, y1, u1 , v1);
+		YUV[j + 0] = y0;
+		YUV[j + 1] = (u0+u1)/2;
+		YUV[j + 2] = y1;
+		YUV[j + 3] = (v0+v1)/2;
+	}
+}
+
+static void display_frame(struct fp_img *img)
+{
+	int width = fp_img_get_width(img);
+	int height = fp_img_get_height(img);
+	unsigned char *data = fp_img_get_data(img);
+
+	if (adaptor < 0)
+		return;
+
+	grey2yuy2(data, framebuffer, width * height);
+	xv_image = XvCreateImage(display, info[adaptor].base_id, FORMAT,
+			framebuffer, width, height);
+	XvPutImage(display, info[adaptor].base_id, window, gc, xv_image,
+			0, 0, width, height, 0, 0, width, height);
+}
+
+static void QueryXv(void)
+{
+	unsigned int num_adaptors;
+	int num_formats;
+	XvImageFormatValues *formats = NULL;
+	int i,j;
+	char xv_name[5];
+
+	XvQueryAdaptors(display, DefaultRootWindow(display), &num_adaptors,
+			&info);
+
+	for(i = 0; i < num_adaptors; i++) {
+		formats = XvListImageFormats(display, info[i].base_id,
+				&num_formats);
+		for(j = 0; j < num_formats; j++) {
+			xv_name[4] = 0;
+			memcpy(xv_name, &formats[j].id, 4);
+			if(formats[j].id == FORMAT) {
+				printf("using Xv format 0x%x %s %s\n",
+						formats[j].id, xv_name,
+						(formats[j].format==XvPacked)
+						? "packed" : "planar");
+				if (adaptor < 0)
+					adaptor = i;
+			}
+		}
+	}
+	XFree(formats);
+	if (adaptor < 0)
+		printf("No suitable Xv adaptor found\n");
+}
+
+struct fp_dscv_dev *discover_device(struct fp_dscv_dev **discovered_devs)
+{
+	struct fp_dscv_dev *ddev = discovered_devs[0];
+	struct fp_driver *drv;
+	if (!ddev)
+		return NULL;
+	
+	drv = fp_dscv_dev_get_driver(ddev);
+	printf("Found device claimed by %s driver\n", fp_driver_get_full_name(drv));
+	return ddev;
+}
+
+int main(void)
+{
+	int r = 1;
+	XEvent xev;
+	XGCValues xgcv;
+	long background=0x010203;
+	struct fp_dscv_dev *ddev;
+	struct fp_dscv_dev **discovered_devs;
+	struct fp_dev *dev;
+	int img_width;
+	int img_height;
+	int standardize = 0;
+
+	setenv ("G_MESSAGES_DEBUG", "all", 0);
+	setenv ("LIBUSB_DEBUG", "3", 0);
+
+	r = fp_init();
+	if (r < 0) {
+		fprintf(stderr, "Failed to initialize libfprint\n");
+		exit(1);
+	}
+
+	discovered_devs = fp_discover_devs();
+	if (!discovered_devs) {
+		fprintf(stderr, "Could not discover devices\n");
+		goto out;
+	}
+
+	ddev = discover_device(discovered_devs);
+	if (!ddev) {
+		fprintf(stderr, "No devices detected.\n");
+		goto out;
+	}
+
+	dev = fp_dev_open(ddev);
+	fp_dscv_devs_free(discovered_devs);
+	if (!dev) {
+		fprintf(stderr, "Could not open device.\n");
+		goto out;
+	}
+
+	if (!fp_dev_supports_imaging(dev)) {
+		fprintf(stderr, "this device does not have imaging capabilities.\n");
+		goto out_close;
+	}
+
+	img_width = fp_dev_get_img_width(dev);
+	img_height = fp_dev_get_img_height(dev);
+	if (img_width <= 0 || img_height <= 0) {
+		fprintf(stderr, "this device returns images with variable dimensions,"
+			" this example does not support that.\n");
+		goto out_close;
+	}
+	framebuffer = malloc(img_width * img_height * 2);
+	if (!framebuffer)
+		goto out_close;
+
+	/* make the window */
+	display = XOpenDisplay(getenv("DISPLAY"));
+	if(display == NULL) {
+		fprintf(stderr,"Could not open display \"%s\"\n",
+				getenv("DISPLAY"));
+		goto out_close;
+	}
+
+	QueryXv();
+
+	if (adaptor < 0)
+		goto out_close;
+
+	window = XCreateSimpleWindow(display, DefaultRootWindow(display), 0, 0,
+			img_width, img_height, 0,
+			WhitePixel(display, DefaultScreen(display)), background);
+
+	XSelectInput(display, window, StructureNotifyMask | KeyPressMask);
+	XMapWindow(display, window);
+	connection = ConnectionNumber(display);
+
+	gc = XCreateGC(display, window, 0, &xgcv);
+
+	printf("Press S to toggle standardized mode, Q to quit\n");
+	
+	while (1) { /* event loop */
+		struct fp_img *img;
+
+		r = fp_dev_img_capture(dev, 1, &img);
+		if (r) {
+			fprintf(stderr, "image capture failed, code %d\n", r);
+			goto out_close;
+		}
+		if (standardize)
+			fp_img_standardize(img);
+
+		display_frame(img);
+		fp_img_free(img);
+		XFlush(display);
+
+		while (XPending(display) > 0) {
+			XNextEvent(display, &xev);
+			if (xev.type != KeyPress)
+				continue;
+
+			switch (XKeycodeToKeysym(display, xev.xkey.keycode, 0)) {
+			case XK_q:
+			case XK_Q:
+				r = 0;
+				goto out_close;
+				break;
+			case XK_s:
+			case XK_S:
+				standardize = !standardize;
+				break;
+			}
+		} /* XPending */
+	}
+
+	r = 0;
+out_close:
+	if (framebuffer)
+		free(framebuffer);
+	fp_dev_close(dev);
+	if ((void *) window != NULL)
+		XUnmapWindow(display, window);
+	if (display != NULL)
+		XFlush(display);
+out:
+	fp_exit();
+	return r;
+}
+
+

examples/manage-prints.c

@@ -1,283 +0,0 @@
-/*
- * Example fingerprint device prints listing and deletion
- * Enrolls your right index finger and saves the print to disk
- * Copyright (C) 2019 Marco Trevisan <marco.trevisan@canonical.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
- */
-
-#define FP_COMPONENT "example-mange-prints"
-
-#include <stdio.h>
-
-#include <libfprint/fprint.h>
-#include "utilities.h"
-
-typedef struct _ListData
-{
-  GMainLoop *loop;
-  int        ret_value;
-  GList     *to_delete;
-  gboolean   any_failed;
-} ListData;
-
-static void
-list_data_free (ListData *list_data)
-{
-  g_list_free_full (list_data->to_delete, g_object_unref);
-  g_main_loop_unref (list_data->loop);
-  g_free (list_data);
-}
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (ListData, list_data_free)
-
-static void
-on_device_closed (FpDevice     *dev,
-                  GAsyncResult *res,
-                  gpointer      user_data)
-{
-  ListData *list_data = user_data;
-
-  g_autoptr(GError) error = NULL;
-
-  fp_device_close_finish (dev, res, &error);
-
-  if (error)
-    g_warning ("Failed closing device %s\n", error->message);
-
-  g_main_loop_quit (list_data->loop);
-}
-
-typedef struct _DeleteData
-{
-  ListData *list_data;
-  FpPrint  *print;
-} DeleteData;
-
-static void
-delete_data_free (DeleteData *delete_data)
-{
-  g_object_unref (delete_data->print);
-  g_free (delete_data);
-}
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (DeleteData, delete_data_free);
-
-static void on_print_deleted (FpDevice     *dev,
-                              GAsyncResult *res,
-                              gpointer      user_data);
-
-static void
-delete_next_print (FpDevice *dev,
-                   ListData *list_data)
-{
-  FpPrint *print;
-
-  g_assert_nonnull (list_data->to_delete);
-  print = list_data->to_delete->data;
-
-  g_debug ("Deleting print %s\n", fp_print_get_description (print));
-  fp_device_delete_print (dev, print, NULL,
-                          (GAsyncReadyCallback) on_print_deleted, list_data);
-}
-
-static void
-on_print_deleted (FpDevice     *dev,
-                  GAsyncResult *res,
-                  gpointer      user_data)
-{
-  ListData *list_data = user_data;
-
-  g_autoptr(GError) error = NULL;
-  g_autoptr(FpPrint) print = NULL;
-  GList *deleted_link;
-
-  fp_device_delete_print_finish (dev, res, &error);
-
-  deleted_link = list_data->to_delete;
-  print = g_steal_pointer (&deleted_link->data);
-  list_data->to_delete = g_list_delete_link (list_data->to_delete, deleted_link);
-
-  if (error)
-    {
-      g_warning ("Failed to remove print %s: %s",
-                 fp_print_get_description (print), error->message);
-      list_data->any_failed = TRUE;
-    }
-  else
-    {
-      g_debug ("Deleted print %s from device", fp_print_get_description (print));
-    }
-
-  if (list_data->to_delete != NULL)
-    {
-      delete_next_print (dev, list_data);
-    }
-  else
-    {
-      if (!list_data->any_failed)
-        list_data->ret_value = EXIT_SUCCESS;
-
-      fp_device_close (dev, NULL, (GAsyncReadyCallback) on_device_closed,
-                       list_data);
-    }
-}
-
-static void
-on_list_completed (FpDevice     *dev,
-                   GAsyncResult *res,
-                   gpointer      user_data)
-{
-  ListData *list_data = user_data;
-
-  g_autoptr(GPtrArray) prints = NULL;
-  g_autoptr(GError) error = NULL;
-
-  prints = fp_device_list_prints_finish (dev, res, &error);
-
-  if (!error)
-    {
-      guint i;
-      char buf[128];
-
-      g_print ("Device contains %u prints\n", prints->len);
-
-      for (i = 0; i < prints->len; ++i)
-        {
-          FpPrint * print = prints->pdata[i];
-          const GDate *date = fp_print_get_enroll_date (print);
-
-          g_print ("[%d] Print of %s finger for username %s", i + 1,
-                   finger_to_string (fp_print_get_finger (print)),
-                   fp_print_get_username (print));
-
-          if (date)
-            {
-              g_date_strftime (buf, G_N_ELEMENTS (buf), "%Y-%m-%d\0", date);
-              g_print (", enrolled on %s", buf);
-            }
-
-          g_print (". Description: %s\n", fp_print_get_description (print));
-        }
-
-      if (prints->len)
-        {
-          gint64 idx = 0;
-
-          g_print ("Want to delete saved print? [<number>/A/n]\n> ");
-          if (fgets (buf, 3, stdin))
-            idx = g_ascii_strtoll (buf, NULL, 10);
-
-          if (idx > 0 && idx <= prints->len)
-            {
-              FpPrint *print = prints->pdata[idx - 1];
-              list_data->to_delete = g_list_prepend (list_data->to_delete,
-                                                     g_object_ref (print));
-            }
-          else if (buf[0] == 'A')
-            {
-              for (i = 0; i < prints->len; ++i)
-                {
-                  FpPrint *print = prints->pdata[i];
-                  list_data->to_delete = g_list_prepend (list_data->to_delete,
-                                                         g_object_ref (print));
-                }
-            }
-          else
-            {
-              if (buf[0] == 'n' || buf[0] == 'N')
-                list_data->ret_value = EXIT_SUCCESS;
-              else
-                g_warning ("Invalid finger selected");
-            }
-        }
-
-      if (list_data->to_delete)
-        delete_next_print (dev, list_data);
-      else
-        fp_device_close (dev, NULL, (GAsyncReadyCallback) on_device_closed,
-                         list_data);
-    }
-  else
-    {
-      g_warning ("Getting prints failed with error %s", error->message);
-      g_main_loop_quit (list_data->loop);
-    }
-}
-
-static void
-on_device_opened (FpDevice     *dev,
-                  GAsyncResult *res,
-                  gpointer      user_data)
-{
-  ListData *list_data = user_data;
-
-  g_autoptr(GError) error = NULL;
-
-  if (!fp_device_open_finish (dev, res, &error))
-    {
-      g_warning ("Failed to open device: %s", error->message);
-      g_main_loop_quit (list_data->loop);
-      return;
-    }
-
-  if (!fp_device_has_storage (dev))
-    {
-      g_warning ("Device %s doesn't support storage", fp_device_get_name (dev));
-      g_main_loop_quit (list_data->loop);
-      return;
-    }
-
-  fp_device_list_prints (dev, NULL,
-                         (GAsyncReadyCallback) on_list_completed, list_data);
-
-}
-
-int
-main (void)
-{
-  g_autoptr(FpContext) ctx = NULL;
-  g_autoptr(ListData) list_data = NULL;
-  GPtrArray *devices;
-  FpDevice *dev;
-
-  g_print ("This program will report the prints saved in device\n");
-
-  setenv ("G_MESSAGES_DEBUG", "all", 0);
-
-  ctx = fp_context_new ();
-
-  devices = fp_context_get_devices (ctx);
-  if (!devices)
-    {
-      g_warning ("Impossible to get devices");
-      return EXIT_FAILURE;
-    }
-
-  dev = discover_device (devices);
-  if (!dev)
-    {
-      g_warning ("No devices detected.");
-      return EXIT_FAILURE;
-    }
-
-  list_data = g_new0 (ListData, 1);
-  list_data->ret_value = EXIT_FAILURE;
-  list_data->loop = g_main_loop_new (NULL, FALSE);
-
-  fp_device_open (dev, NULL, (GAsyncReadyCallback) on_device_opened, list_data);
-
-  g_main_loop_run (list_data->loop);
-
-  return list_data->ret_value;
-}

examples/meson.build

@@ -1,16 +1,29 @@
 
-examples = [ 'enroll', 'verify', 'manage-prints' ]
+examples = [ 'verify_live', 'enroll', 'verify', 'img_capture', 'delete' ]
 foreach example: examples
     executable(example,
-        [ example + '.c', 'storage.c', 'utilities.c' ],
+               example + '.c',
-        dependencies: [
+               dependencies: libfprint_dep,
-            libfprint_dep,
+               include_directories: [
-            glib_dep,
+                 root_inc,
                ],
-    )
+               c_args: common_cflags)
 endforeach
 
 executable('cpp-test',
            'cpp-test.cpp',
            dependencies: libfprint_dep,
-)
+           include_directories: [
+             root_inc,
+           ],
+           c_args: common_cflags)
+
+if get_option('x11-examples')
+    executable('img_capture_continuous',
+               'img_capture_continuous.c',
+               dependencies: [ libfprint_dep, xv_dep, x11_dep ],
+               include_directories: [
+                 root_inc,
+               ],
+               c_args: common_cflags)
+endif

examples/prints/README

@@ -1,3 +0,0 @@
-These are example images from NIST and are in the public domain.
-
-The PNG files have been generated by using the greyscale data as a mask.

examples/sendvirtimg.py

@@ -1,111 +0,0 @@
-#!/usr/bin/env python3
-
-# This script can be used together with the virtual_imgdev to simulate an
-# image based fingerprint reader.
-#
-# To use, set the FP_VIRTUAL_IMAGE environment variable for both the
-# libfprint using program (e.g. fprintd) and this script.
-#
-# Usually this would work by adding it into the systemd unit file. The
-# best way of doing so is to create
-#  /etc/systemd/system/fprintd.service.d/fprintd-test.conf
-#
-# [Service]
-# RuntimeDirectory=fprint
-# Environment=FP_VIRTUAL_IMAGE=/run/fprint/virtimg_sock
-# Environment=G_MESSAGES_DEBUG=all
-# ReadWritePaths=$RUNTIME_DIR
-#
-# After that run:
-#
-#   systemctl daemon-reload
-#   systemctl restart fprintd.service
-#
-# You may also need to disable selinux.
-#
-# Then run this script with e.g.
-# FP_VIRTUAL_IMAGE=/run/fprint/virtimg_sock ./sendvirtimg.py prints/whorl.png
-
-
-
-import cairo
-import sys
-import os
-import socket
-import struct
-
-if len(sys.argv) != 2:
-    sys.stderr.write('You need to pass a PNG with an alpha channel!\n')
-    sys.exit(1)
-
-# Just copied from the C file, we could also use the introspection data for
-# this. Also, most of them do *not* make any sense.
-commands = {
-    'retry' : struct.pack('ii', -1, 0),
-    'retry-too-short' : struct.pack('ii', -1, 1),
-    'retry-center-finger' : struct.pack('ii', -1, 2),
-    'retry-remove-finger' : struct.pack('ii', -1, 3),
-
-    'error' : struct.pack('ii', -2, 0),
-    'error-not-supported' : struct.pack('ii', -2, 1),
-    'error-not-open' : struct.pack('ii', -2, 2),
-    'error-already-open' : struct.pack('ii', -2, 3),
-    'error-busy' : struct.pack('ii', -2, 4),
-    'error-proto' : struct.pack('ii', -2, 5),
-    'error-data-invalid' : struct.pack('ii', -2, 6),
-    'error-data-not-found' : struct.pack('ii', -2, 7),
-    'error-data-full' : struct.pack('ii', -2, 8),
-}
-
-
-if sys.argv[1] in commands:
-    command = commands[sys.argv[1]]
-else:
-    png = cairo.ImageSurface.create_from_png(sys.argv[1])
-
-    # Cairo wants 4 byte aligned rows, so just add a few pixel if necessary
-    w = png.get_width()
-    h = png.get_height()
-    w = (w + 3) // 4 * 4
-    h = (h + 3) // 4 * 4
-    img = cairo.ImageSurface(cairo.Format.A8, w, h)
-    cr = cairo.Context(img)
-
-    cr.set_source_rgba(1, 1, 1, 1)
-    cr.paint()
-
-    cr.set_source_rgba(0, 0, 0, 0)
-    cr.set_operator(cairo.OPERATOR_SOURCE)
-
-    cr.set_source_surface(png)
-    cr.paint()
-
-    mem = img.get_data()
-    mem = mem.tobytes()
-    assert len(mem) == img.get_width() * img.get_height()
-
-    command = struct.pack('ii', img.get_width(), img.get_height())
-    command += mem
-
-
-
-def write_dbg_img():
-    dbg_img_rgb = cairo.ImageSurface(cairo.Format.RGB24, img.get_width(), img.get_height())
-    dbg_cr = cairo.Context(dbg_img_rgb)
-    dbg_cr.set_source_rgb(0, 0, 0)
-    dbg_cr.paint()
-    dbg_cr.set_source_rgb(1, 1, 1)
-    dbg_cr.mask_surface(img, 0, 0)
-
-    dbg_img_rgb.write_to_png('/tmp/test.png')
-
-#write_dbg_img()
-
-# Send image through socket
-sockaddr = os.environ['FP_VIRTUAL_IMAGE']
-
-sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
-sock.connect(sockaddr)
-
-sock.sendall(command)
-

examples/storage.c

@@ -1,234 +0,0 @@
-/*
- * Trivial storage driver for example programs
- *
- * Copyright (C) 2019 Benjamin Berg <bberg@redhat.com>
- * Copyright (C) 2019 Marco Trevisan <marco.trevisan@canonical.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
- */
-
-#define FP_COMPONENT "example-storage"
-
-#include <libfprint/fprint.h>
-#include <libfprint/fpi-compat.h>
-#include "storage.h"
-
-#include <errno.h>
-#include <stdio.h>
-#include <stdlib.h>
-#include <unistd.h>
-
-#define STORAGE_FILE "test-storage.variant"
-
-static char *
-get_print_data_descriptor (FpPrint *print, FpDevice *dev, FpFinger finger)
-{
-  const char *driver;
-  const char *dev_id;
-
-  if (print)
-    {
-      driver = fp_print_get_driver (print);
-      dev_id = fp_print_get_device_id (print);
-    }
-  else
-    {
-      driver = fp_device_get_driver (dev);
-      dev_id = fp_device_get_device_id (dev);
-    }
-
-  return g_strdup_printf ("%s/%s/%x",
-                          driver,
-                          dev_id,
-                          finger);
-}
-
-static GVariantDict *
-load_data (void)
-{
-  GVariantDict *res;
-  GVariant *var;
-  gchar *contents = NULL;
-  gsize 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,
-                                 g_free,
-                                 contents);
-
-  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 (FpPrint *print, FpFinger finger)
-{
-  g_autofree gchar *descr = get_print_data_descriptor (print, NULL, finger);
-
-  g_autoptr(GError) error = NULL;
-  g_autoptr(GVariantDict) dict = NULL;
-  g_autofree guchar *data = NULL;
-  GVariant *val;
-  gsize size;
-  int res;
-
-  dict = load_data ();
-
-  fp_print_serialize (print, &data, &size, &error);
-  if (error)
-    {
-      g_warning ("Error serializing data: %s", error->message);
-      return -1;
-    }
-  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));
-
-  return res;
-}
-
-FpPrint *
-print_data_load (FpDevice *dev, FpFinger finger)
-{
-  g_autofree gchar *descr = get_print_data_descriptor (NULL, dev, finger);
-
-  g_autoptr(GVariant) val = NULL;
-  g_autoptr(GVariantDict) dict = NULL;
-  const guchar *stored_data = NULL;
-  gsize stored_len;
-
-  dict = load_data ();
-  val = g_variant_dict_lookup_value (dict, descr, G_VARIANT_TYPE ("ay"));
-
-  if (val)
-    {
-      FpPrint *print;
-      g_autoptr(GError) error = NULL;
-
-      stored_data = (const guchar *) g_variant_get_fixed_array (val, &stored_len, 1);
-      print = fp_print_deserialize (stored_data, stored_len, &error);
-
-      if (error)
-        g_warning ("Error deserializing data: %s", error->message);
-
-      return print;
-    }
-
-  return NULL;
-}
-
-FpPrint *
-print_create_template (FpDevice *dev, FpFinger finger)
-{
-  g_autoptr(GDateTime) datetime = NULL;
-  g_autoptr(GDate) date = NULL;
-  FpPrint *template = NULL;
-  gint year, month, day;
-
-  template = fp_print_new (dev);
-  fp_print_set_finger (template, finger);
-  fp_print_set_username (template, g_get_user_name ());
-  datetime = g_date_time_new_now_local ();
-  g_date_time_get_ymd (datetime, &year, &month, &day);
-  date = g_date_new_dmy (day, month, year);
-  fp_print_set_enroll_date (template, date);
-
-  return template;
-}
-
-
-static gboolean
-save_image_to_pgm (FpImage *img, const char *path)
-{
-  FILE *fd = fopen (path, "w");
-  size_t write_size;
-  const guchar *data = fp_image_get_data (img, &write_size);
-  int r;
-
-  if (!fd)
-    {
-      g_warning ("could not open '%s' for writing: %d", path, errno);
-      return FALSE;
-    }
-
-  r = fprintf (fd, "P5 %d %d 255\n",
-               fp_image_get_width (img), fp_image_get_height (img));
-  if (r < 0)
-    {
-      fclose (fd);
-      g_critical ("pgm header write failed, error %d", r);
-      return FALSE;
-    }
-
-  r = fwrite (data, 1, write_size, fd);
-  if (r < write_size)
-    {
-      fclose (fd);
-      g_critical ("short write (%d)", r);
-      return FALSE;
-    }
-
-  fclose (fd);
-  g_debug ("written to '%s'", path);
-
-  return TRUE;
-}
-
-gboolean
-print_image_save (FpPrint *print, const char *path)
-{
-  FpImage *img = NULL;
-
-  g_return_val_if_fail (FP_IS_PRINT (print), FALSE);
-  g_return_val_if_fail (path != NULL, FALSE);
-
-  img = fp_print_get_image (print);
-
-  if (img)
-    return save_image_to_pgm (img, path);
-
-  return FALSE;
-}

examples/storage.h

@@ -1,30 +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
- */
-
-#pragma once
-
-int print_data_save (FpPrint *print,
-                     FpFinger finger);
-FpPrint * print_data_load (FpDevice *dev,
-                           FpFinger  finger);
-FpPrint * print_create_template (FpDevice *dev,
-                                 FpFinger  finger);
-gboolean print_image_save (FpPrint    *print,
-                           const char *path);

examples/utilities.c

@@ -1,127 +0,0 @@
-/*
- * Utilities for example programs
- *
- * Copyright (C) 2019 Marco Trevisan <marco.trevisan@canonical.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
- */
-
-#define FP_COMPONENT "example-utilities"
-
-#include <libfprint/fprint.h>
-#include <stdio.h>
-
-#include "utilities.h"
-
-FpDevice *
-discover_device (GPtrArray * devices)
-{
-  FpDevice *dev;
-  int i;
-
-  if (!devices->len)
-    return NULL;
-
-  if (devices->len == 1)
-    {
-      i = 0;
-    }
-  else
-    {
-      g_print ("Multiple devices found, choose one\n");
-
-      for (i = 0; i < devices->len; ++i)
-        {
-          dev = g_ptr_array_index (devices, i);
-          g_print ("[%d] %s (%s) - driver %s\n", i,
-                   fp_device_get_device_id (dev), fp_device_get_name (dev),
-                   fp_device_get_driver (dev));
-        }
-
-      g_print ("> ");
-      if (!scanf ("%d%*c", &i))
-        return NULL;
-
-      if (i < 0 || i >= devices->len)
-        return NULL;
-    }
-
-  dev = g_ptr_array_index (devices, i);
-  g_print ("Selected device %s (%s) claimed by %s driver\n",
-           fp_device_get_device_id (dev), fp_device_get_name (dev),
-           fp_device_get_driver (dev));
-
-  return dev;
-}
-
-const char *
-finger_to_string (FpFinger finger)
-{
-  switch (finger)
-    {
-    case FP_FINGER_LEFT_THUMB:
-      return "left thumb";
-
-    case FP_FINGER_LEFT_INDEX:
-      return "left index";
-
-    case FP_FINGER_LEFT_MIDDLE:
-      return "left middle";
-
-    case FP_FINGER_LEFT_RING:
-      return "left ring";
-
-    case FP_FINGER_LEFT_LITTLE:
-      return "left little";
-
-    case FP_FINGER_RIGHT_THUMB:
-      return "right thumb";
-
-    case FP_FINGER_RIGHT_INDEX:
-      return "right index";
-
-    case FP_FINGER_RIGHT_MIDDLE:
-      return "right middle";
-
-    case FP_FINGER_RIGHT_RING:
-      return "right ring";
-
-    case FP_FINGER_RIGHT_LITTLE:
-      return "right little";
-
-    default:
-      return "unknown";
-    }
-}
-
-FpFinger
-finger_chooser (void)
-{
-  int i = FP_FINGER_UNKNOWN;
-
-  for (i = FP_FINGER_FIRST; i <= FP_FINGER_LAST; ++i)
-    g_print ("  [%d] %s\n", (i - FP_FINGER_FIRST), finger_to_string (i));
-
-  g_print ("> ");
-  if (!scanf ("%d%*c", &i))
-    return FP_FINGER_UNKNOWN;
-
-  i += FP_FINGER_FIRST;
-
-  if (i < FP_FINGER_FIRST || i > FP_FINGER_LAST)
-    return FP_FINGER_UNKNOWN;
-
-  return i;
-}

examples/utilities.h

@@ -1,25 +0,0 @@
-/*
- * Trivial storage driver for example programs
- *
- * Copyright (C) 2019 Marco Trevisan <marco.trevisan@canonical.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
- */
-
-#pragma once
-
-FpDevice * discover_device (GPtrArray *devices);
-FpFinger finger_chooser (void);
-const char * finger_to_string (FpFinger finger);

examples/verify.c

@@ -1,8 +1,7 @@
 /*
- * Example fingerprint verification program, which verifies the
+ * Example fingerprint verification program, which verifies the right index
  * finger which has been previously enrolled to disk.
  * Copyright (C) 2007 Daniel Drake <dsd@gentoo.org>
- * Copyright (C) 2019 Marco Trevisan <marco.trevisan@canonical.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -19,319 +18,133 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#define FP_COMPONENT "example-verify"
-
 #include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
 #include <libfprint/fprint.h>
-#include <glib-unix.h>
 
-#include "storage.h"
+struct fp_dscv_dev *discover_device(struct fp_dscv_dev **discovered_devs)
-#include "utilities.h"
-
-typedef struct _VerifyData
 {
-  GMainLoop    *loop;
+	struct fp_dscv_dev *ddev = discovered_devs[0];
-  GCancellable *cancellable;
+	struct fp_driver *drv;
-  unsigned int  sigint_handler;
+	if (!ddev)
-  FpFinger      finger;
+		return NULL;
-  int           ret_value;
-} VerifyData;
 	
-static void
+	drv = fp_dscv_dev_get_driver(ddev);
-verify_data_free (VerifyData *verify_data)
+	printf("Found device claimed by %s driver\n", fp_driver_get_full_name(drv));
-{
+	return ddev;
-  g_clear_handle_id (&verify_data->sigint_handler, g_source_remove);
-  g_clear_object (&verify_data->cancellable);
-  g_main_loop_unref (verify_data->loop);
-  g_free (verify_data);
-}
-G_DEFINE_AUTOPTR_CLEANUP_FUNC (VerifyData, verify_data_free)
-
-static void
-on_device_closed (FpDevice *dev, GAsyncResult *res, void *user_data)
-{
-  VerifyData *verify_data = user_data;
-
-  g_autoptr(GError) error = NULL;
-
-  fp_device_close_finish (dev, res, &error);
-
-  if (error)
-    g_warning ("Failed closing device %s\n", error->message);
-
-  g_main_loop_quit (verify_data->loop);
 }
 
-static void
+int verify(struct fp_dev *dev, struct fp_print_data *data)
-verify_quit (FpDevice   *dev,
-             VerifyData *verify_data)
 {
-  if (!fp_device_is_open (dev))
+	int r;
-    {
+
-      g_main_loop_quit (verify_data->loop);
+	do {
-      return;
+		struct fp_img *img = NULL;
+
+		sleep(1);
+		printf("\nScan your finger now.\n");
+		r = fp_verify_finger_img(dev, data, &img);
+		if (img) {
+			fp_img_save_to_file(img, "verify.pgm");
+			printf("Wrote scanned image to verify.pgm\n");
+			fp_img_free(img);
+		}
+		if (r < 0) {
+			printf("verification failed with error %d :(\n", r);
+			return r;
+		}
+		switch (r) {
+		case FP_VERIFY_NO_MATCH:
+			printf("NO MATCH!\n");
+			return 0;
+		case FP_VERIFY_MATCH:
+			printf("MATCH!\n");
+			return 0;
+		case FP_VERIFY_RETRY:
+			printf("Scan didn't quite work. Please try again.\n");
+			break;
+		case FP_VERIFY_RETRY_TOO_SHORT:
+			printf("Swipe was too short, please try again.\n");
+			break;
+		case FP_VERIFY_RETRY_CENTER_FINGER:
+			printf("Please center your finger on the sensor and try again.\n");
+			break;
+		case FP_VERIFY_RETRY_REMOVE_FINGER:
+			printf("Please remove finger from the sensor and try again.\n");
+			break;
+		}
+	} while (1);
 }
 
-  fp_device_close (dev, NULL, (GAsyncReadyCallback) on_device_closed, verify_data);
+int main(void)
-}
-
-static void start_verification (FpDevice   *dev,
-                                VerifyData *verify_data);
-
-static void
-on_verify_completed (FpDevice *dev, GAsyncResult *res, void *user_data)
 {
-  VerifyData *verify_data = user_data;
+	int r = 1;
-
+	struct fp_dscv_dev *ddev;
-  g_autoptr(FpPrint) print = NULL;
+	struct fp_dscv_dev **discovered_devs;
-  g_autoptr(GError) error = NULL;
+	struct fp_dev *dev;
-  char buffer[20];
+	struct fp_print_data *data;
-  gboolean match;
-
-  if (!fp_device_verify_finish (dev, res, &match, &print, &error))
-    {
-      g_warning ("Failed to verify print: %s", error->message);
-      verify_data->ret_value = EXIT_FAILURE;
-
-      if (error->domain != FP_DEVICE_RETRY)
-        {
-          verify_quit (dev, verify_data);
-          return;
-        }
-    }
-
-  g_print ("Verify again? [Y/n]? ");
-  if (fgets (buffer, sizeof (buffer), stdin) &&
-      (buffer[0] == 'Y' || buffer[0] == 'y' || buffer[0] == '\n'))
-    {
-      start_verification (dev, verify_data);
-      return;
-    }
-
-  verify_quit (dev, verify_data);
-}
-
-static void
-on_match_cb (FpDevice *dev, FpPrint *match, FpPrint *print,
-             gpointer user_data, GError *error)
-{
-  VerifyData *verify_data = user_data;
-
-  if (error)
-    {
-      g_warning ("Match report: Finger not matched, retry error reported: %s",
-                 error->message);
-      return;
-    }
-
-  if (print && fp_device_supports_capture (dev) &&
-      print_image_save (print, "verify.pgm"))
-    g_print ("Print image saved as verify.pgm\n");
-
-  if (match)
-    {
-      char date_str[128];
-
-      verify_data->ret_value = EXIT_SUCCESS;
-
-      g_date_strftime (date_str, G_N_ELEMENTS (date_str), "%Y-%m-%d\0",
-                       fp_print_get_enroll_date (match));
-      g_debug ("Match report: device %s matched finger %s successifully "
-               "with print %s, enrolled on date %s by user %s",
-               fp_device_get_name (dev),
-               finger_to_string (fp_print_get_finger (match)),
-               fp_print_get_description (match), date_str,
-               fp_print_get_username (match));
-
-      g_print ("MATCH!\n");
-    }
-  else
-    {
-      g_debug ("Match report: Finger not matched");
-      g_print ("NO MATCH!\n");
-    }
-}
-
-static void
-on_list_completed (FpDevice *dev, GAsyncResult *res, gpointer user_data)
-{
-  VerifyData *verify_data = user_data;
-
-  g_autoptr(GPtrArray) prints = NULL;
-  g_autoptr(GError) error = NULL;
-
-  prints = fp_device_list_prints_finish (dev, res, &error);
-
-  if (!error)
-    {
-      FpPrint *verify_print = NULL;
-      guint i;
-
-      if (!prints->len)
-        g_warning ("No prints saved on device");
-
-      for (i = 0; i < prints->len; ++i)
-        {
-          FpPrint *print = prints->pdata[i];
-
-          if (fp_print_get_finger (print) == verify_data->finger &&
-              g_strcmp0 (fp_print_get_username (print), g_get_user_name ()) == 0)
-            {
-              const GDate *verify_print_date = NULL;
-              const GDate *print_date = fp_print_get_enroll_date (print);
-
-              if (verify_print)
-                verify_print_date = fp_print_get_enroll_date (verify_print);
-
-              if (!verify_print || !print_date || !verify_print_date ||
-                  g_date_compare (print_date, verify_print_date) >= 0)
-                verify_print = print;
-            }
-        }
-
-      if (!verify_print)
-        {
-          g_warning ("Did you remember to enroll your %s finger first?",
-                     finger_to_string (verify_data->finger));
-          verify_quit (dev, verify_data);
-          return;
-        }
-
-      g_debug ("Comparing print with %s",
-               fp_print_get_description (verify_print));
-
-      g_print ("Print loaded. Time to verify!\n");
-      fp_device_verify (dev, verify_print, verify_data->cancellable,
-                        on_match_cb, verify_data, NULL,
-                        (GAsyncReadyCallback) on_verify_completed,
-                        verify_data);
-    }
-  else
-    {
-      g_warning ("Loading prints failed with error %s", error->message);
-      verify_quit (dev, verify_data);
-    }
-}
-
-static void
-start_verification (FpDevice *dev, VerifyData *verify_data)
-{
-  if (verify_data->finger == FP_FINGER_UNKNOWN)
-    {
-      g_print ("Choose the finger to verify:\n");
-      verify_data->finger = finger_chooser ();
-    }
-
-  if (verify_data->finger == FP_FINGER_UNKNOWN)
-    {
-      g_warning ("Unknown finger selected");
-      verify_data->ret_value = EXIT_FAILURE;
-      verify_quit (dev, verify_data);
-      return;
-    }
-
-  if (fp_device_has_storage (dev))
-    {
-      g_print ("Creating finger template, using device storage...\n");
-      fp_device_list_prints (dev, NULL,
-                             (GAsyncReadyCallback) on_list_completed,
-                             verify_data);
-    }
-  else
-    {
-      g_print ("Loading previously enrolled %s finger data...\n",
-               finger_to_string (verify_data->finger));
-      g_autoptr(FpPrint) verify_print = NULL;
-
-      verify_print = print_data_load (dev, verify_data->finger);
-
-      if (!verify_print)
-        {
-          g_warning ("Failed to load fingerprint data");
-          g_warning ("Did you remember to enroll your %s finger first?",
-                     finger_to_string (verify_data->finger));
-          verify_quit (dev, verify_data);
-          return;
-        }
-
-      g_print ("Print loaded. Time to verify!\n");
-      fp_device_verify (dev, verify_print, verify_data->cancellable,
-                        NULL, NULL, NULL,
-                        (GAsyncReadyCallback) on_verify_completed,
-                        verify_data);
-    }
-}
-
-static void
-on_device_opened (FpDevice *dev, GAsyncResult *res, void *user_data)
-{
-  VerifyData *verify_data = user_data;
-
-  g_autoptr(GError) error = NULL;
-
-  if (!fp_device_open_finish (dev, res, &error))
-    {
-      g_warning ("Failed to open device: %s", error->message);
-      verify_quit (dev, verify_data);
-      return;
-    }
-
-  g_print ("Opened device. ");
-
-  start_verification (dev, verify_data);
-}
-
-static gboolean
-sigint_cb (void *user_data)
-{
-  VerifyData *verify_data = user_data;
-
-  g_cancellable_cancel (verify_data->cancellable);
-
-  return G_SOURCE_CONTINUE;
-}
-
-int
-main (void)
-{
-  g_autoptr(FpContext) ctx = NULL;
-  g_autoptr(VerifyData) verify_data = NULL;
-  GPtrArray *devices;
-  FpDevice *dev;
 
 	setenv ("G_MESSAGES_DEBUG", "all", 0);
 	setenv ("LIBUSB_DEBUG", "3", 0);
 
-  ctx = fp_context_new ();
+	r = fp_init();
-
+	if (r < 0) {
-  devices = fp_context_get_devices (ctx);
+		fprintf(stderr, "Failed to initialize libfprint\n");
-  if (!devices)
+		exit(1);
-    {
-      g_warning ("Impossible to get devices");
-      return EXIT_FAILURE;
 	}
 
-  dev = discover_device (devices);
+	discovered_devs = fp_discover_devs();
-  if (!dev)
+	if (!discovered_devs) {
-    {
+		fprintf(stderr, "Could not discover devices\n");
-      g_warning ("No devices detected.");
+		goto out;
-      return EXIT_FAILURE;
 	}
 
-  verify_data = g_new0 (VerifyData, 1);
+	ddev = discover_device(discovered_devs);
-  verify_data->ret_value = EXIT_FAILURE;
+	if (!ddev) {
-  verify_data->loop = g_main_loop_new (NULL, FALSE);
+		fprintf(stderr, "No devices detected.\n");
-  verify_data->cancellable = g_cancellable_new ();
+		goto out;
-  verify_data->sigint_handler = g_unix_signal_add_full (G_PRIORITY_HIGH,
-                                                        SIGINT,
-                                                        sigint_cb,
-                                                        verify_data,
-                                                        NULL);
-  fp_device_open (dev, verify_data->cancellable,
-                  (GAsyncReadyCallback) on_device_opened,
-                  verify_data);
-
-  g_main_loop_run (verify_data->loop);
-
-  return verify_data->ret_value;
 	}
+
+	dev = fp_dev_open(ddev);
+	fp_dscv_devs_free(discovered_devs);
+	if (!dev) {
+		fprintf(stderr, "Could not open device.\n");
+		goto out;
+	}
+
+	printf("Opened device. Loading previously enrolled right index finger "
+		"data...\n");
+
+#pragma GCC diagnostic push
+#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");
+		goto out_close;
+	}
+
+	printf("Print loaded. Time to verify!\n");
+	do {
+		char buffer[20];
+
+		verify(dev, data);
+		printf("Verify again? [Y/n]? ");
+		fgets(buffer, sizeof(buffer), stdin);
+		if (buffer[0] != '\n' && buffer[0] != 'y' && buffer[0] != 'Y')
+			break;
+	} while (1);
+
+	fp_print_data_free(data);
+out_close:
+	fp_dev_close(dev);
+out:
+	fp_exit();
+	return r;
+}
+
+

examples/verify_live.c

@@ -0,0 +1,188 @@
+/*
+ * Example fingerprint verification program
+ * Copyright (C) 2007 Daniel Drake <dsd@gentoo.org>
+ *
+ * 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 <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+
+#include <libfprint/fprint.h>
+
+struct fp_dscv_dev *discover_device(struct fp_dscv_dev **discovered_devs)
+{
+	struct fp_dscv_dev *ddev = discovered_devs[0];
+	struct fp_driver *drv;
+	if (!ddev)
+		return NULL;
+	
+	drv = fp_dscv_dev_get_driver(ddev);
+	printf("Found device claimed by %s driver\n", fp_driver_get_full_name(drv));
+	return ddev;
+}
+
+struct fp_print_data *enroll(struct fp_dev *dev) {
+	struct fp_print_data *enrolled_print = NULL;
+	int r;
+
+	printf("You will need to successfully scan your finger %d times to "
+		"complete the process.\n", fp_dev_get_nr_enroll_stages(dev));
+
+	do {
+		printf("\nScan your finger now.\n");
+		r = fp_enroll_finger(dev, &enrolled_print);
+		if (r < 0) {
+			printf("Enroll failed with error %d\n", r);
+			return NULL;
+		}
+		switch (r) {
+		case FP_ENROLL_COMPLETE:
+			printf("Enroll complete!\n");
+			break;
+		case FP_ENROLL_FAIL:
+			printf("Enroll failed, something wen't wrong :(\n");
+			return NULL;
+		case FP_ENROLL_PASS:
+			printf("Enroll stage passed. Yay!\n");
+			break;
+		case FP_ENROLL_RETRY:
+			printf("Didn't quite catch that. Please try again.\n");
+			break;
+		case FP_ENROLL_RETRY_TOO_SHORT:
+			printf("Your swipe was too short, please try again.\n");
+			break;
+		case FP_ENROLL_RETRY_CENTER_FINGER:
+			printf("Didn't catch that, please center your finger on the "
+				"sensor and try again.\n");
+			break;
+		case FP_ENROLL_RETRY_REMOVE_FINGER:
+			printf("Scan failed, please remove your finger and then try "
+				"again.\n");
+			break;
+		}
+	} while (r != FP_ENROLL_COMPLETE);
+
+	if (!enrolled_print) {
+		fprintf(stderr, "Enroll complete but no print?\n");
+		return NULL;
+	}
+
+	printf("Enrollment completed!\n\n");
+	return enrolled_print;
+}
+
+int verify(struct fp_dev *dev, struct fp_print_data *data)
+{
+	int r;
+
+	do {
+		sleep(1);
+		printf("\nScan your finger now.\n");
+		r = fp_verify_finger(dev, data);
+		if (r < 0) {
+			printf("verification failed with error %d :(\n", r);
+			return r;
+		}
+		switch (r) {
+		case FP_VERIFY_NO_MATCH:
+			printf("NO MATCH!\n");
+			return 0;
+		case FP_VERIFY_MATCH:
+			printf("MATCH!\n");
+			return 0;
+		case FP_VERIFY_RETRY:
+			printf("Scan didn't quite work. Please try again.\n");
+			break;
+		case FP_VERIFY_RETRY_TOO_SHORT:
+			printf("Swipe was too short, please try again.\n");
+			break;
+		case FP_VERIFY_RETRY_CENTER_FINGER:
+			printf("Please center your finger on the sensor and try again.\n");
+			break;
+		case FP_VERIFY_RETRY_REMOVE_FINGER:
+			printf("Please remove finger from the sensor and try again.\n");
+			break;
+		}
+	} while (1);
+}
+
+int main(void)
+{
+	int r = 1;
+	struct fp_dscv_dev *ddev;
+	struct fp_dscv_dev **discovered_devs;
+	struct fp_dev *dev;
+	struct fp_print_data *data;
+
+	setenv ("G_MESSAGES_DEBUG", "all", 0);
+	setenv ("LIBUSB_DEBUG", "3", 0);
+
+	r = fp_init();
+	if (r < 0) {
+		fprintf(stderr, "Failed to initialize libfprint\n");
+		exit(1);
+	}
+
+	discovered_devs = fp_discover_devs();
+	if (!discovered_devs) {
+		fprintf(stderr, "Could not discover devices\n");
+		goto out;
+	}
+
+	ddev = discover_device(discovered_devs);
+	if (!ddev) {
+		fprintf(stderr, "No devices detected.\n");
+		goto out;
+	}
+
+	dev = fp_dev_open(ddev);
+	fp_dscv_devs_free(discovered_devs);
+	if (!dev) {
+		fprintf(stderr, "Could not open device.\n");
+		goto out;
+	}
+
+	printf("Opened device. It's now time to enroll your finger.\n\n");
+	data = enroll(dev);
+	if (!data)
+		goto out_close;
+
+
+	printf("Normally we'd save that print to disk, and recall it at some "
+		"point later when we want to authenticate the user who just "
+		"enrolled. In the interests of demonstration, we'll authenticate "
+		"that user immediately.\n");
+
+	do {
+		char buffer[20];
+
+		verify(dev, data);
+		printf("Verify again? [Y/n]? ");
+		fgets(buffer, sizeof(buffer), stdin);
+		if (buffer[0] != '\n' && buffer[0] != 'y' && buffer[0] != 'Y')
+			break;
+	} while (1);
+
+	fp_print_data_free(data);
+out_close:
+	fp_dev_close(dev);
+out:
+	fp_exit();
+	return r;
+}
+
+

libfprint/drivers/aes1610.c

@@ -28,10 +28,9 @@
 #include "drivers_api.h"
 #include "aeslib.h"
 
-static void start_capture (FpImageDevice *dev);
+static void start_capture(struct fp_img_dev *dev);
-static void complete_deactivation (FpImageDevice *dev);
+static void complete_deactivation(struct fp_img_dev *dev);
-static int adjust_gain (unsigned char *buffer,
+static int adjust_gain(unsigned char *buffer, int status);
-                        int            status);
 
 #define FIRST_AES1610_REG	0x1B
 #define LAST_AES1610_REG	0xFF
@@ -40,8 +39,8 @@ static int adjust_gain (unsigned char *buffer,
 #define GAIN_STATUS_NORMAL 2
 
 /* FIXME these need checking */
-#define EP_IN (1 | FPI_USB_ENDPOINT_IN)
+#define EP_IN			(1 | LIBUSB_ENDPOINT_IN)
-#define EP_OUT (2 | FPI_USB_ENDPOINT_OUT)
+#define EP_OUT			(2 | LIBUSB_ENDPOINT_OUT)
 
 #define BULK_TIMEOUT 4000
 
@@ -70,19 +69,13 @@ static int adjust_gain (unsigned char *buffer,
 
 /****** GENERAL FUNCTIONS ******/
 
-struct _FpiDeviceAes1610
+struct aes1610_dev {
-{
+	uint8_t read_regs_retry_count;
-  FpImageDevice parent;
-
-  guint8        read_regs_retry_count;
 	GSList *strips;
-  gsize         strips_len;
+	size_t strips_len;
 	gboolean deactivating;
-  guint8        blanks_count;
+	uint8_t blanks_count;
 };
-G_DECLARE_FINAL_TYPE (FpiDeviceAes1610, fpi_device_aes1610, FPI, DEVICE_AES1610,
-                      FpImageDevice);
-G_DEFINE_TYPE (FpiDeviceAes1610, fpi_device_aes1610, FP_TYPE_IMAGE_DEVICE);
 
 static struct fpi_frame_asmbl_ctx assembling_ctx = {
 	.frame_width = FRAME_WIDTH,
@@ -91,58 +84,67 @@ static struct fpi_frame_asmbl_ctx assembling_ctx = {
 	.get_pixel = aes_get_pixel,
 };
 
-typedef void (*aes1610_read_regs_cb)(FpImageDevice *dev,
+typedef void (*aes1610_read_regs_cb)(struct fp_img_dev *dev, int status,
-                                     int            status,
+	unsigned char *regs, void *user_data);
-                                     unsigned char *regs,
-                                     void          *user_data);
 
-struct aes1610_read_regs
+struct aes1610_read_regs {
-{
+	struct fp_img_dev *dev;
-  FpImageDevice       *dev;
 	aes1610_read_regs_cb callback;
 	struct aes_regwrite *regwrite;
 	void *user_data;
 };
 
 /* FIXME: what to do here? */
-static void
+static void stub_capture_stop_cb(struct fp_img_dev *dev, int result, void *user_data)
-stub_capture_stop_cb (FpImageDevice *dev, GError *error,
-                      void *user_data)
 {
-  if (error)
+
-    {
-      fp_warn ("Error stopping capture: %s", error->message);
-      g_error_free (error);
-    }
 }
 
-static void
+
-generic_write_regv_cb (FpImageDevice *dev, GError *error,
+/* check that read succeeded but ignore all data */
+static void generic_ignore_data_cb(struct libusb_transfer *transfer)
+{
+	fpi_ssm *ssm = transfer->user_data;
+
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED)
+		fpi_ssm_mark_failed(ssm, -EIO);
+	else if (transfer->length != transfer->actual_length)
+		fpi_ssm_mark_failed(ssm, -EPROTO);
+	else
+		fpi_ssm_next_state(ssm);
+
+	g_free(transfer->buffer);
+	libusb_free_transfer(transfer);
+}
+
+static void generic_write_regv_cb(struct fp_img_dev *dev, int result,
 	void *user_data)
 {
-  FpiSsm *ssm = user_data;
+	fpi_ssm *ssm = user_data;
-
+	if (result == 0)
-  if (!error)
 		fpi_ssm_next_state(ssm);
 	else
-    fpi_ssm_mark_failed (ssm, error);
+		fpi_ssm_mark_failed(ssm, result);
 }
 
 /* read the specified number of bytes from the IN endpoint but throw them
  * away, then increment the SSM */
-static void
+static void generic_read_ignore_data(fpi_ssm *ssm, struct fp_dev *dev, size_t bytes)
-generic_read_ignore_data (FpiSsm *ssm, FpDevice *dev,
-                          size_t bytes)
 {
-  FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
+	struct libusb_transfer *transfer = fpi_usb_alloc();
 	unsigned char *data;
+	int r;
 
 	data = g_malloc(bytes);
-  fpi_usb_transfer_fill_bulk_full (transfer, EP_IN, data, bytes, g_free);
+	libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(dev), EP_IN, data, bytes,
-  transfer->ssm = ssm;
+		generic_ignore_data_cb, ssm, BULK_TIMEOUT);
-  transfer->short_is_error = TRUE;
+
-  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+	r = libusb_submit_transfer(transfer);
-                           fpi_ssm_usb_transfer_cb, NULL);
+	if (r < 0) {
+		g_free(data);
+		libusb_free_transfer(transfer);
+		fpi_ssm_mark_failed(ssm, r);
+	}
 }
 
 /****** FINGER PRESENCE DETECTION ******/
@@ -173,67 +175,72 @@ static const struct aes_regwrite finger_det_reqs[] = {
 	{ 0x81, 0x04 }
 };
 
-static void start_finger_detection (FpImageDevice *dev);
+static void start_finger_detection(struct fp_img_dev *dev);
 
-static void
+static void finger_det_data_cb(struct libusb_transfer *transfer)
-finger_det_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                    gpointer user_data, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
+	struct fp_img_dev *dev = transfer->user_data;
 	unsigned char *data = transfer->buffer;
 	int i;
 	int sum = 0;
 
-  if (error)
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
-    {
+		fpi_imgdev_session_error(dev, -EIO);
-      fpi_image_device_session_error (dev, error);
+		goto out;
-      return;
+	} else if (transfer->length != transfer->actual_length) {
+		fpi_imgdev_session_error(dev, -EPROTO);
+		goto out;
 	}
 
 	/* examine histogram to determine finger presence */
 	for (i = 3; i < 17; i++)
 		sum += (data[i] & 0xf) + (data[i] >> 4);
-  if (sum > 20)
+	if (sum > 20) {
-    {
 		/* reset default gain */
 		adjust_gain(data,GAIN_STATUS_FIRST);
 		/* finger present, start capturing */
-      fpi_image_device_report_finger_status (dev, TRUE);
+		fpi_imgdev_report_finger_status(dev, TRUE);
 		start_capture(dev);
-    }
+	} else {
-  else
-    {
 		/* no finger, poll for a new histogram */
 		start_finger_detection(dev);
 	}
+
+out:
+	g_free(data);
+	libusb_free_transfer(transfer);
 }
 
-static void
+static void finger_det_reqs_cb(struct fp_img_dev *dev, int result, void *user_data)
-finger_det_reqs_cb (FpImageDevice *dev, GError *error,
-                    void *user_data)
 {
-  FpiUsbTransfer *transfer;
+	struct libusb_transfer *transfer;
+	unsigned char *data;
+	int r;
 
-  if (error)
+	if (result) {
-    {
+		fpi_imgdev_session_error(dev, result);
-      fpi_image_device_session_error (dev, error);
 		return;
 	}
 
-  transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
+	transfer = fpi_usb_alloc();
-  fpi_usb_transfer_fill_bulk (transfer, EP_IN, FINGER_DETECTION_LEN);
+	data = g_malloc(FINGER_DETECTION_LEN);
-  transfer->short_is_error = TRUE;
+	libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), EP_IN, data, FINGER_DETECTION_LEN,
-  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+		finger_det_data_cb, dev, BULK_TIMEOUT);
-                           finger_det_data_cb, NULL);
+
+	r = libusb_submit_transfer(transfer);
+	if (r < 0) {
+		g_free(data);
+		libusb_free_transfer(transfer);
+		fpi_imgdev_session_error(dev, r);
 	}
 
-static void
+}
-start_finger_detection (FpImageDevice *dev)
-{
-  FpiDeviceAes1610 *self = FPI_DEVICE_AES1610 (dev);
 
-  if (self->deactivating)
+static void start_finger_detection(struct fp_img_dev *dev)
 {
+	struct aes1610_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
+
+	if (aesdev->deactivating) {
 		complete_deactivation(dev);
 		return;
 	}
@@ -397,42 +404,36 @@ static unsigned char list_BD_values[10] = {
 /*
  * Adjust the gain according to the histogram data
  * 0xbd, 0xbe, 0x29 and 0x2A registers are affected
- * Returns 0 if no problem occurred
+ * Returns 0 if no problem occured
  * TODO: This is a basic support for gain. It needs testing/tweaking.  */
-static int
+static int adjust_gain(unsigned char *buffer, int status)
-adjust_gain (unsigned char *buffer, int status)
 {
 	// The position in the array of possible values for 0xBE and 0xBD registers
 	static int pos_list_BE = 0;
 	static int pos_list_BD = 0;
 
-  // This is the first adjustment (we begin acquisition)
+	// This is the first adjustement (we begin acquisition)
 	// We adjust strip_scan_reqs for future strips and capture_reqs that is sent just after this step
-  if (status == GAIN_STATUS_FIRST)
+	if (status == GAIN_STATUS_FIRST) {
-    {
+		if (buffer[1] > 0x78) { // maximum gain needed
-      if (buffer[1] > 0x78)             // maximum gain needed
-        {
 			strip_scan_reqs[0].value = 0x6B;
 			strip_scan_reqs[1].value = 0x06;
 			strip_scan_reqs[2].value = 0x35;
 			strip_scan_reqs[3].value = 0x4B;
 		}
-      else if (buffer[1] > 0x55)
+		else if (buffer[1] > 0x55) {
-        {
 			strip_scan_reqs[0].value = 0x63;
 			strip_scan_reqs[1].value = 0x15;
 			strip_scan_reqs[2].value = 0x35;
 			strip_scan_reqs[3].value = 0x3b;
 		}
-      else if (buffer[1] > 0x40 || buffer[16] > 0x19)
+		else if (buffer[1] > 0x40 || buffer[16] > 0x19) {
-        {
 			strip_scan_reqs[0].value = 0x43;
 			strip_scan_reqs[1].value = 0x13;
 			strip_scan_reqs[2].value = 0x35;
 			strip_scan_reqs[3].value = 0x30;
 		}
-      else             // minimum gain needed
+		else { // minimum gain needed
-        {
 			strip_scan_reqs[0].value = 0x23;
 			strip_scan_reqs[1].value = 0x07;
 			strip_scan_reqs[2].value = 0x35;
@@ -447,13 +448,12 @@ adjust_gain (unsigned char *buffer, int status)
 
 		fp_dbg("first gain: %x %x %x %x %x %x %x %x", strip_scan_reqs[0].reg, strip_scan_reqs[0].value, strip_scan_reqs[1].reg, strip_scan_reqs[1].value, strip_scan_reqs[2].reg, strip_scan_reqs[2].value, strip_scan_reqs[3].reg, strip_scan_reqs[3].value);
 	}
+
 	// Every 2/3 strips
 	// We try to soften big changes of the gain (at least for 0xBE and 0xBD
 	// FIXME: This softenning will need testing and tweaking too
-  else if (status == GAIN_STATUS_NORMAL)
+	else if (status == GAIN_STATUS_NORMAL) {
-    {
+		if (buffer[514] > 0x78) { // maximum gain needed
-      if (buffer[514] > 0x78)             // maximum gain needed
-        {
 			if (pos_list_BE < 7)
 				pos_list_BE++;
 
@@ -463,8 +463,7 @@ adjust_gain (unsigned char *buffer, int status)
 			strip_scan_reqs[1].value = 0x04;
 			strip_scan_reqs[2].value = 0x35;
 		}
-      else if (buffer[514] > 0x55)
+		else if (buffer[514] > 0x55) {
-        {
 			if (pos_list_BE < 2)
 				pos_list_BE++;
 			else if (pos_list_BE > 2)
@@ -478,8 +477,7 @@ adjust_gain (unsigned char *buffer, int status)
 			strip_scan_reqs[1].value = 0x15;
 			strip_scan_reqs[2].value = 0x35;
 		}
-      else if (buffer[514] > 0x40 || buffer[529] > 0x19)
+		else if (buffer[514] > 0x40 || buffer[529] > 0x19) {
-        {
 			if (pos_list_BE < 1)
 				pos_list_BE++;
 			else if (pos_list_BE > 1)
@@ -493,8 +491,7 @@ adjust_gain (unsigned char *buffer, int status)
 			strip_scan_reqs[1].value = 0x13;
 			strip_scan_reqs[2].value = 0x35;
 		}
-      else             // minimum gain needed
+		else { // minimum gain needed
-        {
 			if (pos_list_BE > 0)
 				pos_list_BE--;
 
@@ -511,8 +508,7 @@ adjust_gain (unsigned char *buffer, int status)
 		fp_dbg("gain: %x %x %x %x %x %x %x %x", strip_scan_reqs[0].reg, strip_scan_reqs[0].value, strip_scan_reqs[1].reg, strip_scan_reqs[1].value, strip_scan_reqs[2].reg, strip_scan_reqs[2].value, strip_scan_reqs[3].reg, strip_scan_reqs[3].value);
 	}
 	// Unknown status
-  else
+	else {
-    {
 		fp_err("Unexpected gain status.");
 		return 1;
 	}
@@ -522,8 +518,7 @@ adjust_gain (unsigned char *buffer, int status)
 
 /*
  * Restore the default gain values */
-static void
+static void restore_gain(void)
-restore_gain (void)
 {
 	strip_scan_reqs[0].value = list_BE_values[0];
 	strip_scan_reqs[1].value = 0x04;
@@ -539,7 +534,7 @@ restore_gain (void)
 
 /* capture SM movement:
  * request and read strip,
- * jump back to request UNLESS there's no finger, in which case exit SM,
+ * jump back to request UNLESS theres no finger, in which case exit SM,
  * report lack of finger presence, and move to finger detection */
 
 enum capture_states {
@@ -550,168 +545,163 @@ enum capture_states {
 	CAPTURE_NUM_STATES,
 };
 
-static void
+static void capture_read_strip_cb(struct libusb_transfer *transfer)
-capture_read_strip_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                       gpointer user_data, GError *error)
 {
 	unsigned char *stripdata;
-  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
+	fpi_ssm *ssm = transfer->user_data;
-  FpiDeviceAes1610 *self = FPI_DEVICE_AES1610 (dev);
+	struct fp_img_dev *dev = fpi_ssm_get_user_data(ssm);
+	struct aes1610_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
 	unsigned char *data = transfer->buffer;
-  gint sum, i;
+	int sum, i;
 
-  if (error)
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
-    {
+		fpi_ssm_mark_failed(ssm, -EIO);
-      fpi_ssm_mark_failed (transfer->ssm, error);
+		goto out;
-      return;
+	} else if (transfer->length != transfer->actual_length) {
+		fpi_ssm_mark_failed(ssm, -EPROTO);
+		goto out;
 	}
 
 	/* FIXME: would preallocating strip buffers be a decent optimization? */
 
 	sum = 0;
 	for (i = 516; i < 530; i++)
+	{
 		/* histogram[i] = number of pixels of value i
 		   Only the pixel values from 10 to 15 are used to detect finger. */
 		sum += data[i];
+	}
 
-  fp_dbg ("sum=%d", sum);
+	if (sum > 0) {
-  if (sum > 0)
-    {
 		/* FIXME: would preallocating strip buffers be a decent optimization? */
 		struct fpi_frame *stripe = g_malloc(FRAME_WIDTH * (FRAME_HEIGHT / 2) + sizeof(struct fpi_frame));
 		stripe->delta_x = 0;
 		stripe->delta_y = 0;
 		stripdata = stripe->data;
 		memcpy(stripdata, data + 1, FRAME_WIDTH * (FRAME_HEIGHT / 2));
-      self->strips = g_slist_prepend (self->strips, stripe);
+		aesdev->strips = g_slist_prepend(aesdev->strips, stripe);
-      self->strips_len++;
+		aesdev->strips_len++;
-      self->blanks_count = 0;
+		aesdev->blanks_count = 0;
 	}
-  else
+
-    {
+	if (sum < 0) {
+		fpi_ssm_mark_failed(ssm, sum);
+		goto out;
+	}
+	fp_dbg("sum=%d", sum);
+
 	/* FIXME: 0 might be too low as a threshold */
 	/* FIXME: sometimes we get 0 in the middle of a scan, should we wait for
 	 * a few consecutive zeroes? */
 
-      /* sum cannot be negative, so is 0 */
+	/* If sum is 0 for a reasonable # of frames, finger has been removed */
-      self->blanks_count++;
+	if (sum == 0) {
+		aesdev->blanks_count++;
 		fp_dbg("got blank frame");
 	}
 
-
 	/* use histogram data above for gain calibration (0xbd, 0xbe, 0x29 and 0x2A ) */
 	adjust_gain(data, GAIN_STATUS_NORMAL);
 
 	/* stop capturing if MAX_FRAMES is reached */
-  if (self->blanks_count > 10 || g_slist_length (self->strips) >= MAX_FRAMES)
+	if (aesdev->blanks_count > 10 || g_slist_length(aesdev->strips) >= MAX_FRAMES) {
-    {
+		struct fp_img *img;
-      FpImage *img;
 
-      fp_dbg ("sending stop capture.... blanks=%d  frames=%d",
+		fp_dbg("sending stop capture.... blanks=%d  frames=%d", aesdev->blanks_count, g_slist_length(aesdev->strips));
-              self->blanks_count, g_slist_length (self->strips));
 		/* send stop capture bits */
 		aes_write_regv(dev, capture_stop, G_N_ELEMENTS(capture_stop), stub_capture_stop_cb, NULL);
-      self->strips = g_slist_reverse (self->strips);
+		aesdev->strips = g_slist_reverse(aesdev->strips);
-      fpi_do_movement_estimation (&assembling_ctx, self->strips);
+		fpi_do_movement_estimation(&assembling_ctx, aesdev->strips, aesdev->strips_len);
-      img = fpi_assemble_frames (&assembling_ctx, self->strips);
+		img = fpi_assemble_frames(&assembling_ctx, aesdev->strips, aesdev->strips_len);
-      img->flags |= FPI_IMAGE_PARTIAL;
+		img->flags |= FP_IMG_PARTIAL;
-
+		g_slist_free_full(aesdev->strips, g_free);
-      g_slist_free_full (self->strips, g_free);
+		aesdev->strips = NULL;
-      self->strips = NULL;
+		aesdev->strips_len = 0;
-      self->strips_len = 0;
+		aesdev->blanks_count = 0;
-      self->blanks_count = 0;
+		fpi_imgdev_image_captured(dev, img);
-      fpi_image_device_image_captured (dev, img);
+		fpi_imgdev_report_finger_status(dev, FALSE);
-      fpi_image_device_report_finger_status (dev, FALSE);
 		/* marking machine complete will re-trigger finger detection loop */
-      fpi_ssm_mark_completed (transfer->ssm);
+		fpi_ssm_mark_completed(ssm);
 		/* Acquisition finished: restore default gain values */
 		restore_gain();
-    }
+	} else {
-  else
-    {
 		/* obtain next strip */
-      fpi_ssm_jump_to_state (transfer->ssm, CAPTURE_REQUEST_STRIP);
+		fpi_ssm_jump_to_state(ssm, CAPTURE_REQUEST_STRIP);
-    }
 	}
 
-static void
+out:
-capture_run_state (FpiSsm *ssm, FpDevice *_dev)
+	g_free(data);
-{
+	libusb_free_transfer(transfer);
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+}
-  FpiDeviceAes1610 *self = FPI_DEVICE_AES1610 (_dev);
 
-  switch (fpi_ssm_get_cur_state (ssm))
+static void capture_run_state(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
 {
+	struct fp_img_dev *dev = user_data;
+	struct aes1610_dev *aesdev = FP_INSTANCE_DATA(_dev);
+	int r;
+
+	switch (fpi_ssm_get_cur_state(ssm)) {
 	case CAPTURE_WRITE_REQS:
 		fp_dbg("write reqs");
 		aes_write_regv(dev, capture_reqs, G_N_ELEMENTS(capture_reqs),
 			generic_write_regv_cb, ssm);
 		break;
-
 	case CAPTURE_READ_DATA:
 		fp_dbg("read data");
 		generic_read_ignore_data(ssm, _dev, STRIP_CAPTURE_LEN);
 		break;
-
 	case CAPTURE_REQUEST_STRIP:
 		fp_dbg("request strip");
-      if (self->deactivating)
+		if (aesdev->deactivating)
 			fpi_ssm_mark_completed(ssm);
 		else
 			aes_write_regv(dev, strip_scan_reqs, G_N_ELEMENTS(strip_scan_reqs),
 				generic_write_regv_cb, ssm);
 		break;
-
 	case CAPTURE_READ_STRIP: ;
-      FpiUsbTransfer *transfer = fpi_usb_transfer_new (_dev);
+		struct libusb_transfer *transfer = fpi_usb_alloc();
+		unsigned char *data;
 
-      fpi_usb_transfer_fill_bulk (transfer, EP_IN, STRIP_CAPTURE_LEN);
+		data = g_malloc(STRIP_CAPTURE_LEN);
-      transfer->ssm = ssm;
+		libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), EP_IN, data, STRIP_CAPTURE_LEN,
-      transfer->short_is_error = TRUE;
+			capture_read_strip_cb, ssm, BULK_TIMEOUT);
-      fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+
-                               capture_read_strip_cb, NULL);
+		r = libusb_submit_transfer(transfer);
+		if (r < 0) {
+			g_free(data);
+			libusb_free_transfer(transfer);
+			fpi_ssm_mark_failed(ssm, r);
+		}
 		break;
-    }
+	};
-  ;
 }
 
-static void
+static void capture_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = user_data;
-  FpiDeviceAes1610 *self = FPI_DEVICE_AES1610 (_dev);
+	struct aes1610_dev *aesdev = FP_INSTANCE_DATA(_dev);
 
 	G_DEBUG_HERE();
-  if (self->deactivating)
+	if (aesdev->deactivating)
-    {
 		complete_deactivation(dev);
-      if (error)
+	else if (fpi_ssm_get_error(ssm))
-        g_error_free (error);
+		fpi_imgdev_session_error(dev, fpi_ssm_get_error(ssm));
-    }
-  else if (error)
-    {
-      fpi_image_device_session_error (dev, error);
-    }
 	else
-    {
 		start_finger_detection(dev);
-    }
+	fpi_ssm_free(ssm);
 }
 
-static void
+static void start_capture(struct fp_img_dev *dev)
-start_capture (FpImageDevice *dev)
 {
-  FpiDeviceAes1610 *self = FPI_DEVICE_AES1610 (dev);
+	struct aes1610_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpiSsm *ssm;
+	fpi_ssm *ssm;
 
-  if (self->deactivating)
+	if (aesdev->deactivating) {
-    {
 		complete_deactivation(dev);
 		return;
 	}
 
-  ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state,
+	ssm = fpi_ssm_new(FP_DEV(dev), capture_run_state, CAPTURE_NUM_STATES, dev);
-                     CAPTURE_NUM_STATES);
 	G_DEBUG_HERE();
 	fpi_ssm_start(ssm, capture_sm_complete);
 }
@@ -733,15 +723,13 @@ enum activate_states {
 	ACTIVATE_NUM_STATES,
 };
 
-static void
+static void activate_run_state(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-activate_run_state (FpiSsm *ssm, FpDevice *_dev)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = user_data;
 
 	/* activation on aes1610 seems much more straightforward compared to aes2501 */
-  /* verify there's anything missing here */
+	/* verify theres anything missing here */
-  switch (fpi_ssm_get_cur_state (ssm))
+	switch (fpi_ssm_get_cur_state(ssm)) {
-    {
 	case WRITE_INIT:
 		fp_dbg("write init");
 		aes_write_regv(dev, init, G_N_ELEMENTS(init), generic_write_regv_cb, ssm);
@@ -750,110 +738,100 @@ activate_run_state (FpiSsm *ssm, FpDevice *_dev)
 }
 
 /* jump to finger detection */
-static void
+static void activate_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = user_data;
+	fp_dbg("status %d", fpi_ssm_get_error(ssm));
+	fpi_imgdev_activate_complete(dev, fpi_ssm_get_error(ssm));
 
-  fpi_image_device_activate_complete (dev, error);
+	if (!fpi_ssm_get_error(ssm))
-
-  if (!error)
 		start_finger_detection(dev);
+	fpi_ssm_free(ssm);
 }
 
-static void
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
-dev_activate (FpImageDevice *dev)
 {
-  FpiDeviceAes1610 *self = FPI_DEVICE_AES1610 (dev);
+	struct aes1610_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state,
+	fpi_ssm *ssm = fpi_ssm_new(FP_DEV(dev), activate_run_state,
-                             ACTIVATE_NUM_STATES);
+		ACTIVATE_NUM_STATES, dev);
-
+	aesdev->read_regs_retry_count = 0;
-  self->read_regs_retry_count = 0;
 	fpi_ssm_start(ssm, activate_sm_complete);
+	return 0;
 }
 
-static void
+static void dev_deactivate(struct fp_img_dev *dev)
-dev_deactivate (FpImageDevice *dev)
 {
-  FpiDeviceAes1610 *self = FPI_DEVICE_AES1610 (dev);
+	struct aes1610_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-
 	/* FIXME: audit cancellation points, probably need more, specifically
 	 * in error handling paths? */
-  self->deactivating = TRUE;
+	aesdev->deactivating = TRUE;
 }
 
-static void
+static void complete_deactivation(struct fp_img_dev *dev)
-complete_deactivation (FpImageDevice *dev)
 {
-  FpiDeviceAes1610 *self = FPI_DEVICE_AES1610 (dev);
+	struct aes1610_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-
 	G_DEBUG_HERE();
 
 	/* FIXME: if we're in the middle of a scan, we should cancel the scan.
 	 * maybe we can do this with a master reset, unconditionally? */
 
-  self->deactivating = FALSE;
+	aesdev->deactivating = FALSE;
-  g_slist_free (self->strips);
+	g_slist_free(aesdev->strips);
-  self->strips = NULL;
+	aesdev->strips = NULL;
-  self->strips_len = 0;
+	aesdev->strips_len = 0;
-  self->blanks_count = 0;
+	aesdev->blanks_count = 0;
-  fpi_image_device_deactivate_complete (dev, NULL);
+	fpi_imgdev_deactivate_complete(dev);
 }
 
-static void
+static int dev_init(struct fp_img_dev *dev, unsigned long driver_data)
-dev_init (FpImageDevice *dev)
 {
-  GError *error = NULL;
-
 	/* FIXME check endpoints */
+	int r;
+	struct aes1610_dev *aesdev;
 
-  if (!g_usb_device_claim_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error))
+	r = libusb_claim_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
+	if (r < 0) {
+		fp_err("could not claim interface 0: %s", libusb_error_name(r));
+		return r;
+	}
+
+	aesdev = g_malloc0(sizeof(struct aes1610_dev));
+	fp_dev_set_instance_data(FP_DEV(dev), aesdev);
+	fpi_imgdev_open_complete(dev, 0);
+	return 0;
+}
+
+static void dev_deinit(struct fp_img_dev *dev)
 {
-      fpi_image_device_open_complete (dev, error);
+	struct aes1610_dev *aesdev;
-      return;
+	aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
+	g_free(aesdev);
+	libusb_release_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
+	fpi_imgdev_close_complete(dev);
 }
 
-  fpi_image_device_open_complete (dev, NULL);
+static const struct usb_id id_table[] = {
-}
+	{ .vendor = 0x08ff, .product = 0x1600 }, /* AES1600 */
-
+	{ 0, 0, 0, },
-static void
-dev_deinit (FpImageDevice *dev)
-{
-  GError *error = NULL;
-
-  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)),
-                                  0, 0, &error);
-  fpi_image_device_close_complete (dev, error);
-}
-
-static const FpIdEntry id_table[] = {
-  { .vid = 0x08ff,  .pid = 0x1600, },/* AES1600 */
-  { .vid = 0,  .pid = 0,  .driver_data = 0 },
 };
 
-static void
+struct fp_img_driver aes1610_driver = {
-fpi_device_aes1610_init (FpiDeviceAes1610 *self)
+	.driver = {
-{
+		.id = AES1610_ID,
-}
+		.name = FP_COMPONENT,
-static void
+		.full_name = "AuthenTec AES1610",
-fpi_device_aes1610_class_init (FpiDeviceAes1610Class *klass)
+		.id_table = id_table,
-{
+		.scan_type = FP_SCAN_TYPE_SWIPE,
-  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
+	},
-  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
+	.flags = 0,
+	.img_height = -1,
+	.img_width = IMAGE_WIDTH,
 
-  dev_class->id = "aes1610";
+	.bz3_threshold = 20,
-  dev_class->full_name = "AuthenTec AES1610";
-  dev_class->type = FP_DEVICE_TYPE_USB;
-  dev_class->id_table = id_table;
-  dev_class->scan_type = FP_SCAN_TYPE_SWIPE;
 
-  img_class->img_open = dev_init;
+	.open = dev_init,
-  img_class->img_close = dev_deinit;
+	.close = dev_deinit,
-  img_class->activate = dev_activate;
+	.activate = dev_activate,
-  img_class->deactivate = dev_deactivate;
+	.deactivate = dev_deactivate,
+};
 
-  img_class->bz3_threshold = 20;
-
-  img_class->img_width = IMAGE_WIDTH;
-  img_class->img_height = -1;
-}

libfprint/drivers/aes1660.c

@@ -27,14 +27,6 @@
 #define FRAME_WIDTH 128
 #define IMAGE_WIDTH	(FRAME_WIDTH + (FRAME_WIDTH / 2))
 
-struct _FpiDeviceAes1660
-{
-  FpiDeviceAesX660 parent;
-};
-G_DECLARE_FINAL_TYPE (FpiDeviceAes1660, fpi_device_aes1660, FPI,
-                      DEVICE_AES1660, FpiDeviceAesX660);
-G_DEFINE_TYPE (FpiDeviceAes1660, fpi_device_aes1660, FPI_TYPE_DEVICE_AES_X660);
-
 static struct fpi_frame_asmbl_ctx assembling_ctx = {
 	.frame_width = FRAME_WIDTH,
 	.frame_height = AESX660_FRAME_HEIGHT,
@@ -42,54 +34,79 @@ static struct fpi_frame_asmbl_ctx assembling_ctx = {
 	.get_pixel = aes_get_pixel,
 };
 
-static const FpIdEntry id_table[] = {
+static int dev_init(struct fp_img_dev *dev, unsigned long driver_data)
-  { .vid = 0x08ff,  .pid = 0x1660, },
+{
-  { .vid = 0x08ff,  .pid = 0x1680, },
+	/* TODO check that device has endpoints we're using */
-  { .vid = 0x08ff,  .pid = 0x1681, },
+	int r;
-  { .vid = 0x08ff,  .pid = 0x1682, },
+	struct aesX660_dev *aesdev;
-  { .vid = 0x08ff,  .pid = 0x1683, },
+
-  { .vid = 0x08ff,  .pid = 0x1684, },
+	r = libusb_claim_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
-  { .vid = 0x08ff,  .pid = 0x1685, },
+	if (r < 0) {
-  { .vid = 0x08ff,  .pid = 0x1686, },
+		fp_err("could not claim interface 0: %s", libusb_error_name(r));
-  { .vid = 0x08ff,  .pid = 0x1687, },
+		return r;
-  { .vid = 0x08ff,  .pid = 0x1688, },
+	}
-  { .vid = 0x08ff,  .pid = 0x1689, },
+
-  { .vid = 0x08ff,  .pid = 0x168a, },
+	aesdev = g_malloc0(sizeof(struct aesX660_dev));
-  { .vid = 0x08ff,  .pid = 0x168b, },
+	fp_dev_set_instance_data(FP_DEV(dev), aesdev);
-  { .vid = 0x08ff,  .pid = 0x168c, },
+	aesdev->buffer = g_malloc0(AES1660_FRAME_SIZE + AESX660_HEADER_SIZE);
-  { .vid = 0x08ff,  .pid = 0x168d, },
+	aesdev->init_seqs[0] = aes1660_init_1;
-  { .vid = 0x08ff,  .pid = 0x168e, },
+	aesdev->init_seqs_len[0] = G_N_ELEMENTS(aes1660_init_1);
-  { .vid = 0x08ff,  .pid = 0x168f, },
+	aesdev->init_seqs[1] = aes1660_init_2;
-  { .vid = 0,  .pid = 0,  .driver_data = 0 },
+	aesdev->init_seqs_len[1] = G_N_ELEMENTS(aes1660_init_2);
+	aesdev->start_imaging_cmd = (unsigned char *)aes1660_start_imaging_cmd;
+	aesdev->start_imaging_cmd_len = sizeof(aes1660_start_imaging_cmd);
+	aesdev->assembling_ctx = &assembling_ctx;
+	aesdev->extra_img_flags = FP_IMG_PARTIAL;
+
+	fpi_imgdev_open_complete(dev, 0);
+	return 0;
+}
+
+static void dev_deinit(struct fp_img_dev *dev)
+{
+	struct aesX660_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
+	g_free(aesdev->buffer);
+	g_free(aesdev);
+	libusb_release_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
+	fpi_imgdev_close_complete(dev);
+}
+
+static const struct usb_id id_table[] = {
+	{ .vendor = 0x08ff, .product = 0x1660 },
+	{ .vendor = 0x08ff, .product = 0x1680 },
+	{ .vendor = 0x08ff, .product = 0x1681 },
+	{ .vendor = 0x08ff, .product = 0x1682 },
+	{ .vendor = 0x08ff, .product = 0x1683 },
+	{ .vendor = 0x08ff, .product = 0x1684 },
+	{ .vendor = 0x08ff, .product = 0x1685 },
+	{ .vendor = 0x08ff, .product = 0x1686 },
+	{ .vendor = 0x08ff, .product = 0x1687 },
+	{ .vendor = 0x08ff, .product = 0x1688 },
+	{ .vendor = 0x08ff, .product = 0x1689 },
+	{ .vendor = 0x08ff, .product = 0x168a },
+	{ .vendor = 0x08ff, .product = 0x168b },
+	{ .vendor = 0x08ff, .product = 0x168c },
+	{ .vendor = 0x08ff, .product = 0x168d },
+	{ .vendor = 0x08ff, .product = 0x168e },
+	{ .vendor = 0x08ff, .product = 0x168f },
+	{ 0, 0, 0, },
 };
 
-static void
+struct fp_img_driver aes1660_driver = {
-fpi_device_aes1660_init (FpiDeviceAes1660 *self)
+	.driver = {
-{
+		.id = AES1660_ID,
-}
+		.name = FP_COMPONENT,
-static void
+		.full_name = "AuthenTec AES1660",
-fpi_device_aes1660_class_init (FpiDeviceAes1660Class *klass)
+		.id_table = id_table,
-{
+		.scan_type = FP_SCAN_TYPE_SWIPE,
-  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
+	},
-  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
+	.flags = 0,
-  FpiDeviceAesX660Class *aes_class = FPI_DEVICE_AES_X660_CLASS (klass);
+	.img_height = -1,
+	.img_width = FRAME_WIDTH + FRAME_WIDTH / 2,
+	.bz3_threshold = 20,
 
-  dev_class->id = "aes1660";
+	.open = dev_init,
-  dev_class->full_name = "AuthenTec AES1660";
+	.close = dev_deinit,
-  dev_class->type = FP_DEVICE_TYPE_USB;
+	.activate = aesX660_dev_activate,
-  dev_class->id_table = id_table;
+	.deactivate = aesX660_dev_deactivate,
-  dev_class->scan_type = FP_SCAN_TYPE_SWIPE;
+};
-
-  img_class->bz3_threshold = 20;
-
-  img_class->img_width = FRAME_WIDTH + FRAME_WIDTH / 2;
-  img_class->img_height = -1;
-
-  aes_class->init_seqs[0] = aes1660_init_1;
-  aes_class->init_seqs_len[0] = G_N_ELEMENTS (aes1660_init_1);
-  aes_class->init_seqs[1] = aes1660_init_2;
-  aes_class->init_seqs_len[1] = G_N_ELEMENTS (aes1660_init_2);
-  aes_class->start_imaging_cmd = (unsigned char *) aes1660_start_imaging_cmd;
-  aes_class->start_imaging_cmd_len = sizeof (aes1660_start_imaging_cmd);
-  aes_class->assembling_ctx = &assembling_ctx;
-}

libfprint/drivers/aes1660.h

@@ -18,7 +18,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
+#ifndef __AES1660_H
+#define __AES1660_H
 
 #define AES1660_FRAME_SIZE 0x244
 
@@ -1985,3 +1986,5 @@ static const unsigned char aes1660_start_imaging_cmd[] = {
 0x55, 0x07, 0x00, 0x80, 0x42, 0x00, 0x7f, 0x00, 0x00, 0x14,
 0x49, 0x03, 0x00, 0x20, 0x00, 0xc8
 };
+
+#endif

libfprint/drivers/aes2501.c

@@ -27,12 +27,12 @@
 #include "aeslib.h"
 #include "aes2501.h"
 
-static void start_capture (FpImageDevice *dev);
+static void start_capture(struct fp_img_dev *dev);
-static void complete_deactivation (FpImageDevice *dev);
+static void complete_deactivation(struct fp_img_dev *dev);
 
 /* FIXME these need checking */
-#define EP_IN (1 | FPI_USB_ENDPOINT_IN)
+#define EP_IN			(1 | LIBUSB_ENDPOINT_IN)
-#define EP_OUT (2 | FPI_USB_ENDPOINT_OUT)
+#define EP_OUT			(2 | LIBUSB_ENDPOINT_OUT)
 
 #define BULK_TIMEOUT 4000
 
@@ -63,19 +63,13 @@ static void complete_deactivation (FpImageDevice *dev);
 
 /****** GENERAL FUNCTIONS ******/
 
-struct _FpiDeviceAes2501
+struct aes2501_dev {
-{
+	uint8_t read_regs_retry_count;
-  FpImageDevice parent;
-
-  guint8        read_regs_retry_count;
 	GSList *strips;
 	size_t strips_len;
 	gboolean deactivating;
 	int no_finger_cnt;
 };
-G_DECLARE_FINAL_TYPE (FpiDeviceAes2501, fpi_device_aes2501, FPI, DEVICE_AES2501,
-                      FpImageDevice);
-G_DEFINE_TYPE (FpiDeviceAes2501, fpi_device_aes2501, FP_TYPE_IMAGE_DEVICE);
 
 static struct fpi_frame_asmbl_ctx assembling_ctx = {
 	.frame_width = FRAME_WIDTH,
@@ -84,52 +78,72 @@ static struct fpi_frame_asmbl_ctx assembling_ctx = {
 	.get_pixel = aes_get_pixel,
 };
 
-typedef void (*aes2501_read_regs_cb)(FpImageDevice *dev,
+typedef void (*aes2501_read_regs_cb)(struct fp_img_dev *dev, int status,
-                                     GError        *error,
+	unsigned char *regs, void *user_data);
-                                     unsigned char *regs,
-                                     void          *user_data);
 
-struct aes2501_read_regs
+struct aes2501_read_regs {
-{
+	struct fp_img_dev *dev;
-  FpImageDevice       *dev;
 	aes2501_read_regs_cb callback;
 	struct aes_regwrite *regwrite;
 	void *user_data;
 };
 
-static void
+static void read_regs_data_cb(struct libusb_transfer *transfer,
-read_regs_data_cb (FpiUsbTransfer *transfer, FpDevice *dev,
+			      struct fp_dev          *dev,
-                   gpointer user_data, GError *error)
+			      fpi_ssm                *ssm,
+			      void                   *user_data)
 {
 	struct aes2501_read_regs *rdata = user_data;
+	unsigned char *retdata = NULL;
+	int r;
 
-  rdata->callback (rdata->dev, error, transfer->buffer, rdata->user_data);
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
+		r = -EIO;
+	} else if (transfer->length != transfer->actual_length) {
+		r = -EPROTO;
+	} else {
+		r = 0;
+		retdata = transfer->buffer;
+	}
+
+	rdata->callback(rdata->dev, r, retdata, rdata->user_data);
 	g_free(rdata);
 }
 
-static void
+static void read_regs_rq_cb(struct fp_img_dev *dev, int result, void *user_data)
-read_regs_rq_cb (FpImageDevice *dev, GError *error, void *user_data)
 {
 	struct aes2501_read_regs *rdata = user_data;
-  FpiUsbTransfer *transfer;
+	fpi_usb_transfer *transfer;
+	unsigned char *data;
+	int r;
 
 	g_free(rdata->regwrite);
-  if (error)
+	if (result != 0)
-    {
+		goto err;
-      rdata->callback (dev, error, NULL, rdata->user_data);
+
-      g_free (rdata);
+	data = g_malloc(READ_REGS_LEN);
+	transfer = fpi_usb_fill_bulk_transfer(FP_DEV(dev),
+					      NULL,
+					      EP_IN,
+					      data,
+					      READ_REGS_LEN,
+					      read_regs_data_cb,
+					      rdata,
+					      BULK_TIMEOUT);
+
+	r = fpi_usb_submit_transfer(transfer);
+	if (r < 0) {
+		result = -EIO;
+		goto err;
+	}
+
 	return;
+err:
+	rdata->callback(dev, result, NULL, rdata->user_data);
+	g_free(rdata);
 }
 
-  transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
+static void read_regs(struct fp_img_dev *dev, aes2501_read_regs_cb callback,
-  transfer->short_is_error = TRUE;
-  fpi_usb_transfer_fill_bulk (transfer, EP_IN, READ_REGS_LEN);
-  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
-                           read_regs_data_cb, rdata);
-}
-
-static void
-read_regs (FpImageDevice *dev, aes2501_read_regs_cb callback,
 	void *user_data)
 {
 	/* FIXME: regwrite is dynamic because of asynchronity. is this really
@@ -150,19 +164,16 @@ read_regs (FpImageDevice *dev, aes2501_read_regs_cb callback,
 }
 
 /* Read the value of a specific register from a register dump */
-static int
+static int regval_from_dump(unsigned char *data, uint8_t target)
-regval_from_dump (unsigned char *data, guint8 target)
-{
-  if (*data != FIRST_AES2501_REG)
 {
+	if (*data != FIRST_AES2501_REG) {
 		fp_err("not a register dump");
-      return -1;
+		return -EILSEQ;
 	}
 
-  if (!(FIRST_AES2501_REG <= target && target <= LAST_AES2501_REG))
+	if (!(FIRST_AES2501_REG <= target && target <= LAST_AES2501_REG)) {
-    {
 		fp_err("out of range");
-      return -1;
+		return -EINVAL;
 	}
 
 	target -= FIRST_AES2501_REG;
@@ -170,48 +181,66 @@ regval_from_dump (unsigned char *data, guint8 target)
 	return data[target + 1];
 }
 
-static void
+static void generic_write_regv_cb(struct fp_img_dev *dev, int result,
-generic_write_regv_cb (FpImageDevice *dev, GError *error,
 	void *user_data)
 {
-  FpiSsm *ssm = user_data;
+	fpi_ssm *ssm = user_data;
-
+	if (result == 0)
-  if (!error)
 		fpi_ssm_next_state(ssm);
 	else
-    fpi_ssm_mark_failed (ssm, error);
+		fpi_ssm_mark_failed(ssm, result);
+}
+
+/* check that read succeeded but ignore all data */
+static void generic_ignore_data_cb(struct libusb_transfer *transfer,
+				   struct fp_dev          *dev,
+				   fpi_ssm                *ssm,
+				   void                   *user_data)
+{
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED)
+		fpi_ssm_mark_failed(ssm, -EIO);
+	else if (transfer->length != transfer->actual_length)
+		fpi_ssm_mark_failed(ssm, -EPROTO);
+	else
+		fpi_ssm_next_state(ssm);
 }
 
 /* read the specified number of bytes from the IN endpoint but throw them
  * away, then increment the SSM */
-static void
+static void generic_read_ignore_data(fpi_ssm *ssm, struct fp_dev *dev, size_t bytes)
-generic_read_ignore_data (FpiSsm *ssm, FpDevice *dev,
-                          size_t bytes)
 {
-  FpiUsbTransfer *transfer;
+	fpi_usb_transfer *transfer;
+	unsigned char *data;
+	int r;
 
-  transfer = fpi_usb_transfer_new (dev);
+	data = g_malloc(bytes);
-  transfer->ssm = ssm;
+	transfer = fpi_usb_fill_bulk_transfer(dev,
-  transfer->short_is_error = TRUE;
+					      ssm,
-  fpi_usb_transfer_fill_bulk (transfer, EP_IN, bytes);
+					      EP_IN,
-  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+					      data,
-                           fpi_ssm_usb_transfer_cb, NULL);
+					      bytes,
+					      generic_ignore_data_cb,
+					      NULL,
+					      BULK_TIMEOUT);
+
+	r = fpi_usb_submit_transfer(transfer);
+	if (r < 0)
+		fpi_ssm_mark_failed(ssm, r);
 }
 
 /****** IMAGE PROCESSING ******/
 
-static int
+static int sum_histogram_values(unsigned char *data, uint8_t threshold)
-sum_histogram_values (unsigned char *data, guint8 threshold)
 {
 	int r = 0;
 	int i;
-  guint16 *histogram = (guint16 *) (data + 1);
+	uint16_t *histogram = (uint16_t *)(data + 1);
 
 	if (*data != 0xde)
-    return -1;
+		return -EILSEQ;
 
 	if (threshold > 0x0f)
-    return -1;
+		return -EINVAL;
 
 	/* FIXME endianness */
 	for (i = threshold; i < 16; i++)
@@ -250,67 +279,72 @@ static const struct aes_regwrite finger_det_reqs[] = {
 	{ AES2501_REG_LPONT, AES2501_LPONT_MIN_VALUE },
 };
 
-static void start_finger_detection (FpImageDevice *dev);
+static void start_finger_detection(struct fp_img_dev *dev);
 
-static void
+static void finger_det_data_cb(struct libusb_transfer *transfer,
-finger_det_data_cb (FpiUsbTransfer *transfer, FpDevice *_dev,
+			       struct fp_dev          *_dev,
-                    gpointer user_data, GError *error)
+			       fpi_ssm                *ssm,
+			       void                   *user_data)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = FP_IMG_DEV(_dev);
 	unsigned char *data = transfer->buffer;
 	int i;
 	int sum = 0;
 
-  if (error)
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
-    {
+		fpi_imgdev_session_error(dev, -EIO);
-      fpi_image_device_session_error (dev, error);
+		return;
+	} else if (transfer->length != transfer->actual_length) {
+		fpi_imgdev_session_error(dev, -EPROTO);
 		return;
 	}
 
 	/* examine histogram to determine finger presence */
 	for (i = 1; i < 9; i++)
 		sum += (data[i] & 0xf) + (data[i] >> 4);
-  if (sum > 20)
+	if (sum > 20) {
-    {
 		/* finger present, start capturing */
-      fpi_image_device_report_finger_status (dev, TRUE);
+		fpi_imgdev_report_finger_status(dev, TRUE);
 		start_capture(dev);
-    }
+	} else {
-  else
-    {
 		/* no finger, poll for a new histogram */
 		start_finger_detection(dev);
 	}
 }
 
-static void
+static void finger_det_reqs_cb(struct fp_img_dev *dev, int result,
-finger_det_reqs_cb (FpImageDevice *dev, GError *error,
 	void *user_data)
 {
-  FpiUsbTransfer *transfer;
+	fpi_usb_transfer *transfer;
+	unsigned char *data;
+	int r;
 
-  if (error)
+	if (result) {
-    {
+		fpi_imgdev_session_error(dev, result);
-      fpi_image_device_session_error (dev, error);
 		return;
 	}
 
-  transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
+	data = g_malloc(FINGER_DETECTION_LEN);
-  transfer->short_is_error = TRUE;
+	transfer = fpi_usb_fill_bulk_transfer(FP_DEV(dev),
-  fpi_usb_transfer_fill_bulk (transfer, EP_IN, FINGER_DETECTION_LEN);
+					      NULL,
-  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+					      EP_IN,
-                           finger_det_data_cb, NULL);
+					      data,
+					      FINGER_DETECTION_LEN,
+					      finger_det_data_cb,
+					      NULL,
+					      BULK_TIMEOUT);
+
+	r = fpi_usb_submit_transfer(transfer);
+	if (r < 0)
+		fpi_imgdev_session_error(dev, r);
 }
 
-static void
+static void start_finger_detection(struct fp_img_dev *dev)
-start_finger_detection (FpImageDevice *dev)
 {
-  FpiDeviceAes2501 *self = FPI_DEVICE_AES2501 (dev);
+	struct aes2501_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-
 	G_DEBUG_HERE();
 
-  if (self->deactivating)
+	if (aesdev->deactivating) {
-    {
 		complete_deactivation(dev);
 		return;
 	}
@@ -381,7 +415,7 @@ static struct aes_regwrite strip_scan_reqs[] = {
 /* capture SM movement:
  * write reqs and read data 1 + 2,
  * request and read strip,
- * jump back to request UNLESS there's no finger, in which case exit SM,
+ * jump back to request UNLESS theres no finger, in which case exit SM,
  * report lack of finger presence, and move to finger detection */
 
 enum capture_states {
@@ -394,50 +428,45 @@ enum capture_states {
 	CAPTURE_NUM_STATES,
 };
 
-static void
+static void capture_read_strip_cb(struct libusb_transfer *transfer,
-capture_read_strip_cb (FpiUsbTransfer *transfer, FpDevice *_dev,
+				  struct fp_dev          *_dev,
-                       gpointer user_data, GError *error)
+				  fpi_ssm                *ssm,
+				  void                   *user_data)
 {
-  FpiSsm *ssm = transfer->ssm;
 	unsigned char *stripdata;
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = FP_IMG_DEV(_dev);
-  FpiDeviceAes2501 *self = FPI_DEVICE_AES2501 (_dev);
+	struct aes2501_dev *aesdev = FP_INSTANCE_DATA(_dev);
 	unsigned char *data = transfer->buffer;
 	int sum;
 	int threshold;
 
-  if (error)
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
-    {
+		fpi_ssm_mark_failed(ssm, -EIO);
-      fpi_ssm_mark_failed (ssm, error);
+		return;
+	} else if (transfer->length != transfer->actual_length) {
+		fpi_ssm_mark_failed(ssm, -EPROTO);
 		return;
 	}
 
 	threshold = regval_from_dump(data + 1 + 192*8 + 1 + 16*2 + 1 + 8,
 		AES2501_REG_DATFMT);
-  if (threshold < 0)
+	if (threshold < 0) {
-    {
+		fpi_ssm_mark_failed(ssm, threshold);
-      fpi_ssm_mark_failed (ssm,
-                           fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
 		return;
 	}
 
 	sum = sum_histogram_values(data + 1 + 192*8, threshold & 0x0f);
-  if (sum < 0)
+	if (sum < 0) {
-    {
+		fpi_ssm_mark_failed(ssm, sum);
-      fpi_ssm_mark_failed (ssm,
-                           fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
 		return;
 	}
 	fp_dbg("sum=%d", sum);
 
-  if (sum < AES2501_SUM_LOW_THRESH)
+	if (sum < AES2501_SUM_LOW_THRESH) {
-    {
 		strip_scan_reqs[4].value -= 0x8;
 		if (strip_scan_reqs[4].value < AES2501_ADREFHI_MIN_VALUE)
 			strip_scan_reqs[4].value = AES2501_ADREFHI_MIN_VALUE;
-    }
+	} else if (sum > AES2501_SUM_HIGH_THRESH) {
-  else if (sum > AES2501_SUM_HIGH_THRESH)
-    {
 		strip_scan_reqs[4].value += 0x8;
 		if (strip_scan_reqs[4].value > AES2501_ADREFHI_MAX_VALUE)
 			strip_scan_reqs[4].value = AES2501_ADREFHI_MAX_VALUE;
@@ -447,33 +476,28 @@ capture_read_strip_cb (FpiUsbTransfer *transfer, FpDevice *_dev,
 	/* Sum is 0, maybe finger was removed? Wait for 3 empty frames
 	 * to ensure
 	 */
-  if (sum == 0)
+	if (sum == 0) {
-    {
+		aesdev->no_finger_cnt++;
-      self->no_finger_cnt++;
+		if (aesdev->no_finger_cnt == 3) {
-      if (self->no_finger_cnt == 3)
+			struct fp_img *img;
-        {
-          FpImage *img;
 
-          self->strips = g_slist_reverse (self->strips);
+			aesdev->strips = g_slist_reverse(aesdev->strips);
-          fpi_do_movement_estimation (&assembling_ctx, self->strips);
+			fpi_do_movement_estimation(&assembling_ctx,
+					aesdev->strips, aesdev->strips_len);
 			img = fpi_assemble_frames(&assembling_ctx,
-                                     self->strips);
+						  aesdev->strips, aesdev->strips_len);
-          img->flags |= FPI_IMAGE_PARTIAL;
+			img->flags |= FP_IMG_PARTIAL;
-          g_slist_free_full (self->strips, g_free);
+			g_slist_free_full(aesdev->strips, g_free);
-          self->strips = NULL;
+			aesdev->strips = NULL;
-          self->strips_len = 0;
+			aesdev->strips_len = 0;
-          fpi_image_device_image_captured (dev, img);
+			fpi_imgdev_image_captured(dev, img);
-          fpi_image_device_report_finger_status (dev, FALSE);
+			fpi_imgdev_report_finger_status(dev, FALSE);
 			/* marking machine complete will re-trigger finger detection loop */
 			fpi_ssm_mark_completed(ssm);
-        }
+		} else {
-      else
-        {
 			fpi_ssm_jump_to_state(ssm, CAPTURE_REQUEST_STRIP);
 		}
-    }
+	} else {
-  else
-    {
 		/* obtain next strip */
 		/* FIXME: would preallocating strip buffers be a decent optimization? */
 		struct fpi_frame *stripe = g_malloc(FRAME_WIDTH * FRAME_HEIGHT / 2 + sizeof(struct fpi_frame));
@@ -481,103 +505,92 @@ capture_read_strip_cb (FpiUsbTransfer *transfer, FpDevice *_dev,
 		stripe->delta_y = 0;
 		stripdata = stripe->data;
 		memcpy(stripdata, data + 1, 192*8);
-      self->no_finger_cnt = 0;
+		aesdev->no_finger_cnt = 0;
-      self->strips = g_slist_prepend (self->strips, stripe);
+		aesdev->strips = g_slist_prepend(aesdev->strips, stripe);
-      self->strips_len++;
+		aesdev->strips_len++;
 
 		fpi_ssm_jump_to_state(ssm, CAPTURE_REQUEST_STRIP);
 	}
 }
 
-static void
+static void capture_run_state(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-capture_run_state (FpiSsm *ssm, FpDevice *device)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
+	struct fp_img_dev *dev = user_data;
-  FpiDeviceAes2501 *self = FPI_DEVICE_AES2501 (device);
+	struct aes2501_dev *aesdev = FP_INSTANCE_DATA(_dev);
+	int r;
 
-  switch (fpi_ssm_get_cur_state (ssm))
+	switch (fpi_ssm_get_cur_state(ssm)) {
-    {
 	case CAPTURE_WRITE_REQS_1:
 		aes_write_regv(dev, capture_reqs_1, G_N_ELEMENTS(capture_reqs_1),
 			generic_write_regv_cb, ssm);
 		break;
-
 	case CAPTURE_READ_DATA_1:
-      generic_read_ignore_data (ssm, device, READ_REGS_RESP_LEN);
+		generic_read_ignore_data(ssm, _dev, READ_REGS_RESP_LEN);
 		break;
-
 	case CAPTURE_WRITE_REQS_2:
 		aes_write_regv(dev, capture_reqs_2, G_N_ELEMENTS(capture_reqs_2),
 			generic_write_regv_cb, ssm);
 		break;
-
 	case CAPTURE_READ_DATA_2:
-      generic_read_ignore_data (ssm, device, READ_REGS_RESP_LEN);
+		generic_read_ignore_data(ssm, _dev, READ_REGS_RESP_LEN);
 		break;
-
 	case CAPTURE_REQUEST_STRIP:
-      if (self->deactivating)
+		if (aesdev->deactivating)
 			fpi_ssm_mark_completed(ssm);
 		else
 			aes_write_regv(dev, strip_scan_reqs, G_N_ELEMENTS(strip_scan_reqs),
 				generic_write_regv_cb, ssm);
 		break;
+	case CAPTURE_READ_STRIP: ;
+		fpi_usb_transfer *transfer;
+		unsigned char *data;
 
-    case CAPTURE_READ_STRIP: {
+		data = g_malloc(STRIP_CAPTURE_LEN);
-        FpiUsbTransfer *transfer;
+		transfer = fpi_usb_fill_bulk_transfer(FP_DEV(dev),
+						      ssm,
+						      EP_IN,
+						      data,
+						      STRIP_CAPTURE_LEN,
+						      capture_read_strip_cb,
+						      NULL,
+						      BULK_TIMEOUT);
 
-        transfer = fpi_usb_transfer_new (device);
+		r = fpi_usb_submit_transfer(transfer);
-        transfer->ssm = ssm;
+		if (r < 0)
-        transfer->short_is_error = TRUE;
+			fpi_ssm_mark_failed(ssm, r);
-        fpi_usb_transfer_fill_bulk (transfer, EP_IN, STRIP_CAPTURE_LEN);
-        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
-                                 capture_read_strip_cb, NULL);
 		break;
-      }
+	};
-    }
-  ;
 }
 
-static void
+static void capture_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = user_data;
-  FpiDeviceAes2501 *self = FPI_DEVICE_AES2501 (_dev);
+	struct aes2501_dev *aesdev = FP_INSTANCE_DATA(_dev);
 
 	G_DEBUG_HERE();
-
+	if (aesdev->deactivating)
-  if (self->deactivating)
-    {
 		complete_deactivation(dev);
-      g_clear_pointer (&error, g_error_free);
+	else if (fpi_ssm_get_error(ssm))
-    }
+		fpi_imgdev_session_error(dev, fpi_ssm_get_error(ssm));
-  else if (error)
-    {
-      fpi_image_device_session_error (dev, error);
-    }
 	else
-    {
 		start_finger_detection(dev);
-    }
+	fpi_ssm_free(ssm);
 }
 
-static void
+static void start_capture(struct fp_img_dev *dev)
-start_capture (FpImageDevice *dev)
 {
-  FpiDeviceAes2501 *self = FPI_DEVICE_AES2501 (dev);
+	struct aes2501_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpiSsm *ssm;
+	fpi_ssm *ssm;
 
-  if (self->deactivating)
+	if (aesdev->deactivating) {
-    {
 		complete_deactivation(dev);
 		return;
 	}
 
-  self->no_finger_cnt = 0;
+	aesdev->no_finger_cnt = 0;
 	/* Reset gain */
 	strip_scan_reqs[4].value = AES2501_ADREFHI_MAX_VALUE;
-  ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state,
+	ssm = fpi_ssm_new(FP_DEV(dev), capture_run_state, CAPTURE_NUM_STATES, dev);
-                     CAPTURE_NUM_STATES);
 	G_DEBUG_HERE();
 	fpi_ssm_start(ssm, capture_sm_complete);
 }
@@ -687,43 +700,36 @@ enum activate_states {
 	ACTIVATE_NUM_STATES,
 };
 
-static void
+void activate_read_regs_cb(struct fp_img_dev *dev, int status,
-activate_read_regs_cb (FpImageDevice *dev, GError *error,
 	unsigned char *regs, void *user_data)
 {
-  FpiSsm *ssm = user_data;
+	fpi_ssm *ssm = user_data;
-  FpiDeviceAes2501 *self = FPI_DEVICE_AES2501 (dev);
+	struct aes2501_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
 
-  if (error)
+	if (status != 0) {
-    {
+		fpi_ssm_mark_failed(ssm, status);
-      fpi_ssm_mark_failed (ssm, error);
+	} else {
-    }
-  else
-    {
 		fp_dbg("reg 0xaf = %x", regs[0x5f]);
-      if (regs[0x5f] != 0x6b || ++self->read_regs_retry_count == 13)
+		if (regs[0x5f] != 0x6b || ++aesdev->read_regs_retry_count == 13)
 			fpi_ssm_jump_to_state(ssm, WRITE_INIT_4);
 		else
 			fpi_ssm_next_state(ssm);
 	}
 }
 
-static void
+static void activate_init3_cb(struct fp_img_dev *dev, int result,
-activate_init3_cb (FpImageDevice *dev, GError *error,
 	void *user_data)
 {
-  FpiSsm *ssm = user_data;
+	fpi_ssm *ssm = user_data;
-
+	if (result == 0)
-  if (!error)
 		fpi_ssm_jump_to_state(ssm, READ_REGS);
 	else
-    fpi_ssm_mark_failed (ssm, error);
+		fpi_ssm_mark_failed(ssm, result);
 }
 
-static void
+static void activate_run_state(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-activate_run_state (FpiSsm *ssm, FpDevice *_dev)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = user_data;
 
 	/* This state machine isn't as linear as it may appear. After doing init1
 	 * and init2 register configuration writes, we have to poll a register
@@ -744,37 +750,30 @@ activate_run_state (FpiSsm *ssm, FpDevice *_dev)
 	   aes_write_regv(init_4);
 	*/
 
-  switch (fpi_ssm_get_cur_state (ssm))
+	switch (fpi_ssm_get_cur_state(ssm)) {
-    {
 	case WRITE_INIT_1:
 		aes_write_regv(dev, init_1, G_N_ELEMENTS(init_1),
 			generic_write_regv_cb, ssm);
 		break;
-
 	case READ_DATA_1:
 		fp_dbg("read data 1");
 		generic_read_ignore_data(ssm, _dev, FINGER_DETECTION_LEN);
 		break;
-
 	case WRITE_INIT_2:
 		aes_write_regv(dev, init_2, G_N_ELEMENTS(init_2),
 			generic_write_regv_cb, ssm);
 		break;
-
 	case READ_REGS:
 		read_regs(dev, activate_read_regs_cb, ssm);
 		break;
-
 	case WRITE_INIT_3:
 		aes_write_regv(dev, init_3, G_N_ELEMENTS(init_3),
 			activate_init3_cb, ssm);
 		break;
-
 	case WRITE_INIT_4:
 		aes_write_regv(dev, init_4, G_N_ELEMENTS(init_4),
 			generic_write_regv_cb, ssm);
 		break;
-
 	case WRITE_INIT_5:
 		aes_write_regv(dev, init_5, G_N_ELEMENTS(init_5),
 			generic_write_regv_cb, ssm);
@@ -782,101 +781,97 @@ activate_run_state (FpiSsm *ssm, FpDevice *_dev)
 	}
 }
 
-static void
+static void activate_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-activate_sm_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
 {
-  fpi_image_device_activate_complete (FP_IMAGE_DEVICE (dev), error);
+	struct fp_img_dev *dev = user_data;
+	fp_dbg("status %d", fpi_ssm_get_error(ssm));
+	fpi_imgdev_activate_complete(dev, fpi_ssm_get_error(ssm));
 
-  if (!error)
+	if (!fpi_ssm_get_error(ssm))
-    start_finger_detection (FP_IMAGE_DEVICE (dev));
+		start_finger_detection(dev);
+	fpi_ssm_free(ssm);
 }
 
-static void
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
-dev_activate (FpImageDevice *dev)
 {
-  FpiDeviceAes2501 *self = FPI_DEVICE_AES2501 (dev);
+	struct aes2501_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state,
+	fpi_ssm *ssm = fpi_ssm_new(FP_DEV(dev), activate_run_state,
-                             ACTIVATE_NUM_STATES);
+		ACTIVATE_NUM_STATES, dev);
-
+	aesdev->read_regs_retry_count = 0;
-  self->read_regs_retry_count = 0;
 	fpi_ssm_start(ssm, activate_sm_complete);
+	return 0;
 }
 
-static void
+static void dev_deactivate(struct fp_img_dev *dev)
-dev_deactivate (FpImageDevice *dev)
 {
-  FpiDeviceAes2501 *self = FPI_DEVICE_AES2501 (dev);
+	struct aes2501_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-
 	/* FIXME: audit cancellation points, probably need more, specifically
 	 * in error handling paths? */
-  self->deactivating = TRUE;
+	aesdev->deactivating = TRUE;
 }
 
-static void
+static void complete_deactivation(struct fp_img_dev *dev)
-complete_deactivation (FpImageDevice *dev)
 {
-  FpiDeviceAes2501 *self = FPI_DEVICE_AES2501 (dev);
+	struct aes2501_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-
 	G_DEBUG_HERE();
 
 	/* FIXME: if we're in the middle of a scan, we should cancel the scan.
 	 * maybe we can do this with a master reset, unconditionally? */
 
-  self->deactivating = FALSE;
+	aesdev->deactivating = FALSE;
-  g_slist_free (self->strips);
+	g_slist_free(aesdev->strips);
-  self->strips = NULL;
+	aesdev->strips = NULL;
-  self->strips_len = 0;
+	aesdev->strips_len = 0;
-  fpi_image_device_deactivate_complete (dev, NULL);
+	fpi_imgdev_deactivate_complete(dev);
 }
 
-static void
+static int dev_init(struct fp_img_dev *dev, unsigned long driver_data)
-dev_init (FpImageDevice *dev)
 {
-  GError *error = NULL;
-
 	/* FIXME check endpoints */
+	int r;
+	struct aes2501_dev *aesdev;
 
-  g_usb_device_claim_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error);
+	r = libusb_claim_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
-  fpi_image_device_open_complete (dev, error);
+	if (r < 0) {
+		fp_err("could not claim interface 0: %s", libusb_error_name(r));
+		return r;
 	}
 
-static void
+	aesdev = g_malloc0(sizeof(struct aes2501_dev));
-dev_deinit (FpImageDevice *dev)
+	fp_dev_set_instance_data(FP_DEV(dev), aesdev);
+	fpi_imgdev_open_complete(dev, 0);
+	return 0;
+}
+
+static void dev_deinit(struct fp_img_dev *dev)
 {
-  GError *error = NULL;
+	struct aes2501_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-
+	g_free(aesdev);
-  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)),
+	libusb_release_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
-                                  0, 0, &error);
+	fpi_imgdev_close_complete(dev);
-  fpi_image_device_close_complete (dev, error);
 }
 
-static const FpIdEntry id_table[] = {
+static const struct usb_id id_table[] = {
-  { .vid = 0x08ff,  .pid = 0x2500, },/* AES2500 */
+	{ .vendor = 0x08ff, .product = 0x2500 }, /* AES2500 */
-  { .vid = 0x08ff,  .pid = 0x2580, },/* AES2501 */
+	{ .vendor = 0x08ff, .product = 0x2580 }, /* AES2501 */
-  { .vid = 0,  .pid = 0,  .driver_data = 0 },
+	{ 0, 0, 0, },
 };
 
-static void
+struct fp_img_driver aes2501_driver = {
-fpi_device_aes2501_init (FpiDeviceAes2501 *self)
+	.driver = {
-{
+		.id = AES2501_ID,
-}
+		.name = FP_COMPONENT,
-static void
+		.full_name = "AuthenTec AES2501",
-fpi_device_aes2501_class_init (FpiDeviceAes2501Class *klass)
+		.id_table = id_table,
-{
+		.scan_type = FP_SCAN_TYPE_SWIPE,
-  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
+	},
-  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
+	.flags = 0,
+	.img_height = -1,
+	.img_width = IMAGE_WIDTH,
 
-  dev_class->id = "aes2501";
+	.open = dev_init,
-  dev_class->full_name = "AuthenTec AES2501";
+	.close = dev_deinit,
-  dev_class->type = FP_DEVICE_TYPE_USB;
+	.activate = dev_activate,
-  dev_class->id_table = id_table;
+	.deactivate = dev_deactivate,
-  dev_class->scan_type = FP_SCAN_TYPE_SWIPE;
+};
 
-  img_class->img_open = dev_init;
-  img_class->img_close = dev_deinit;
-  img_class->activate = dev_activate;
-  img_class->deactivate = dev_deactivate;
-
-  img_class->img_width = IMAGE_WIDTH;
-  img_class->img_height = -1;
-}

libfprint/drivers/aes2501.h

@@ -19,7 +19,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
+#ifndef __AES2501_H
+#define __AES2501_H
 
 enum aes2501_regs {
 	AES2501_REG_CTRL1 = 0x80,
@@ -108,7 +109,7 @@ enum aes2501_mesure_drive {
 
 /* Select (1=square | 0=sine) wave drive during measure */
 #define AES2501_MEASDRV_SQUARE		0x20
-/* 0 = use measure drive setting, 1 = when sine wave is selected */
+/* 0 = use mesure drive setting, 1 = when sine wave is selected */
 #define AES2501_MEASDRV_MEASURE_SQUARE	0x10
 
 enum aes2501_measure_freq {
@@ -171,3 +172,5 @@ enum aes2501_sensor_gain2 {
 
 #define AES2501_SUM_HIGH_THRESH 1000
 #define AES2501_SUM_LOW_THRESH 700
+
+#endif	/* __AES2501_H */

libfprint/drivers/aes2550.c

@@ -27,11 +27,11 @@
 #include "aes2550.h"
 #include "aeslib.h"
 
-static void start_capture (FpImageDevice *dev);
+static void start_capture(struct fp_img_dev *dev);
-static void complete_deactivation (FpImageDevice *dev);
+static void complete_deactivation(struct fp_img_dev *dev);
 
-#define EP_IN (1 | FPI_USB_ENDPOINT_IN)
+#define EP_IN			(1 | LIBUSB_ENDPOINT_IN)
-#define EP_OUT (2 | FPI_USB_ENDPOINT_OUT)
+#define EP_OUT			(2 | LIBUSB_ENDPOINT_OUT)
 #define BULK_TIMEOUT 4000
 
 /*
@@ -51,18 +51,12 @@ static void complete_deactivation (FpImageDevice *dev);
 #define FRAME_SIZE		(FRAME_WIDTH * FRAME_HEIGHT)
 #define IMAGE_WIDTH		(FRAME_WIDTH + (FRAME_WIDTH / 2))
 
-struct _FpiDeviceAes2550
+struct aes2550_dev {
-{
-  FpImageDevice parent;
-
 	GSList *strips;
 	size_t strips_len;
 	gboolean deactivating;
 	int heartbeat_cnt;
 };
-G_DECLARE_FINAL_TYPE (FpiDeviceAes2550, fpi_device_aes2550, FPI, DEVICE_AES2550,
-                      FpImageDevice);
-G_DEFINE_TYPE (FpiDeviceAes2550, fpi_device_aes2550, FP_TYPE_IMAGE_DEVICE);
 
 static struct fpi_frame_asmbl_ctx assembling_ctx = {
 	.frame_width = FRAME_WIDTH,
@@ -84,78 +78,89 @@ static unsigned char finger_det_reqs[] = {
 	AES2550_CMD_RUN_FD,
 };
 
-static void start_finger_detection (FpImageDevice *dev);
+static void start_finger_detection(struct fp_img_dev *dev);
 
-static void
+static void finger_det_data_cb(struct libusb_transfer *transfer)
-finger_det_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                    gpointer user_data, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
+	struct fp_img_dev *dev = transfer->user_data;
 	unsigned char *data = transfer->buffer;
 
-  if (error)
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
-    {
+		fp_dbg("data transfer status %d\n", transfer->status);
-      fpi_image_device_session_error (FP_IMAGE_DEVICE (device), error);
+		fpi_imgdev_session_error(dev, -EIO);
-      return;
+		goto out;
 	}
 
 	fp_dbg("transfer completed, len: %.4x, data: %.2x %.2x",
-          (gint) transfer->actual_length, (int) data[0], (int) data[1]);
+		transfer->actual_length, (int)data[0], (int)data[1]);
 
 	/* Check if we got 2 bytes, reg address 0x83 and its value */
-  if ((transfer->actual_length >= 2) && (data[0] == 0x83) && (data[1] & AES2550_REG83_FINGER_PRESENT))
+	if ((transfer->actual_length >= 2) && (data[0] == 0x83) && (data[1] & AES2550_REG83_FINGER_PRESENT)) {
-    {
 		/* finger present, start capturing */
-      fpi_image_device_report_finger_status (dev, TRUE);
+		fpi_imgdev_report_finger_status(dev, TRUE);
 		start_capture(dev);
-    }
+	} else {
-  else
-    {
 		/* no finger, poll for a new histogram */
 		start_finger_detection(dev);
 	}
+out:
+	g_free(data);
+	libusb_free_transfer(transfer);
 }
 
-static void
+static void finger_det_reqs_cb(struct libusb_transfer *t)
-finger_det_reqs_cb (FpiUsbTransfer *t, FpDevice *device,
-                    gpointer user_data, GError *error)
 {
-  FpiUsbTransfer *transfer;
+	struct libusb_transfer *transfer;
-  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
+	unsigned char *data;
+	int r;
+	struct fp_img_dev *dev = t->user_data;
 
-  if (error)
+	if (t->status != LIBUSB_TRANSFER_COMPLETED) {
-    {
+		fp_dbg("req transfer status %d\n", t->status);
-      fpi_image_device_session_error (dev, error);
+		fpi_imgdev_session_error(dev, -EIO);
-      return;
+		goto exit_free_transfer;
+	} else if (t->length != t->actual_length) {
+		fp_dbg("expected %d, got %d bytes", t->length, t->actual_length);
+		fpi_imgdev_session_error(dev, -EPROTO);
+		goto exit_free_transfer;
 	}
 
-  transfer = fpi_usb_transfer_new (device);
+	transfer = fpi_usb_alloc();
 	/* 2 bytes of result */
-  fpi_usb_transfer_fill_bulk (transfer, EP_IN, AES2550_EP_IN_BUF_SIZE);
+	data = g_malloc(AES2550_EP_IN_BUF_SIZE);
-  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+	libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), EP_IN, data, AES2550_EP_IN_BUF_SIZE,
-                           finger_det_data_cb, NULL);
+		finger_det_data_cb, dev, BULK_TIMEOUT);
+
+	r = libusb_submit_transfer(transfer);
+	if (r < 0) {
+		g_free(data);
+		libusb_free_transfer(transfer);
+		fpi_imgdev_session_error(dev, r);
+	}
+exit_free_transfer:
+	libusb_free_transfer(t);
 }
 
-static void
+static void start_finger_detection(struct fp_img_dev *dev)
-start_finger_detection (FpImageDevice *dev)
 {
-  FpiDeviceAes2550 *self = FPI_DEVICE_AES2550 (dev);
+	int r;
-  FpiUsbTransfer *transfer;
+	struct aes2550_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-
+	struct libusb_transfer *transfer;
 	G_DEBUG_HERE();
 
-  if (self->deactivating)
+	if (aesdev->deactivating) {
-    {
 		complete_deactivation(dev);
 		return;
 	}
 
-  transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
+	transfer = fpi_usb_alloc();
-  transfer->short_is_error = TRUE;
+	libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), EP_OUT, finger_det_reqs,
-  fpi_usb_transfer_fill_bulk_full (transfer, EP_OUT, finger_det_reqs,
+		sizeof(finger_det_reqs), finger_det_reqs_cb, dev, BULK_TIMEOUT);
-                                   sizeof (finger_det_reqs), NULL);
+	r = libusb_submit_transfer(transfer);
-  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+	if (r < 0) {
-                           finger_det_reqs_cb, NULL);
+		libusb_free_transfer(transfer);
+		fpi_imgdev_session_error(dev, r);
+	}
 }
 
 /****** CAPTURE ******/
@@ -186,213 +191,207 @@ enum capture_states {
 };
 
 /* Returns number of processed bytes */
-static gboolean
+static int process_strip_data(fpi_ssm *ssm, struct fp_img_dev *dev, unsigned char *data)
-process_strip_data (FpiSsm *ssm, FpImageDevice *dev,
-                    unsigned char *data)
 {
 	unsigned char *stripdata;
-  FpiDeviceAes2550 *self = FPI_DEVICE_AES2550 (dev);
+	struct aes2550_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
 	struct fpi_frame *stripe;
 	int len;
 
-  if (data[0] != AES2550_EDATA_MAGIC)
+	if (data[0] != AES2550_EDATA_MAGIC) {
-    {
 		fp_dbg("Bogus magic: %.2x\n", (int)(data[0]));
-      return FALSE;
+		return -EPROTO;
 	}
 	len = data[1] * 256 + data[2];
-  if (len != (AES2550_STRIP_SIZE - 3))
+	if (len != (AES2550_STRIP_SIZE - 3)) {
 		fp_dbg("Bogus frame len: %.4x\n", len);
-  stripe = g_malloc0 (FRAME_WIDTH * FRAME_HEIGHT / 2 + sizeof (struct fpi_frame));     /* 4 bits per pixel */
+	}
+	stripe = g_malloc(FRAME_WIDTH * FRAME_HEIGHT / 2 + sizeof(struct fpi_frame)); /* 4 bits per pixel */
 	stripe->delta_x = (int8_t)data[6];
 	stripe->delta_y = -(int8_t)data[7];
 	stripdata = stripe->data;
 	memcpy(stripdata, data + 33, FRAME_WIDTH * FRAME_HEIGHT / 2);
-  self->strips = g_slist_prepend (self->strips, stripe);
+	aesdev->strips = g_slist_prepend(aesdev->strips, stripe);
-  self->strips_len++;
+	aesdev->strips_len++;
 
 	fp_dbg("deltas: %dx%d", stripe->delta_x, stripe->delta_y);
 
-  return TRUE;
+	return 0;
 }
 
-static void
+static void capture_reqs_cb(struct libusb_transfer *transfer)
-capture_set_idle_reqs_cb (FpiUsbTransfer *transfer,
-                          FpDevice *device, gpointer user_data,
-                          GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
+	fpi_ssm *ssm = transfer->user_data;
-  FpiDeviceAes2550 *self = FPI_DEVICE_AES2550 (dev);
 
-  if (!error && self->strips_len)
+	if ((transfer->status == LIBUSB_TRANSFER_COMPLETED) &&
+		(transfer->length == transfer->actual_length)) {
+		fpi_ssm_next_state(ssm);
+	} else {
+		fpi_ssm_mark_failed(ssm, -EIO);
+	}
+	libusb_free_transfer(transfer);
+}
+
+static void capture_set_idle_reqs_cb(struct libusb_transfer *transfer)
 {
-      FpImage *img;
+	fpi_ssm *ssm = transfer->user_data;
+	struct fp_img_dev *dev = fpi_ssm_get_user_data(ssm);
+	struct aes2550_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
 
-      self->strips = g_slist_reverse (self->strips);
+	if ((transfer->status == LIBUSB_TRANSFER_COMPLETED) &&
-      img = fpi_assemble_frames (&assembling_ctx, self->strips);
+		(transfer->length == transfer->actual_length) &&
-      img->flags |= FPI_IMAGE_PARTIAL;
+		aesdev->strips_len) {
-      g_slist_free_full (self->strips, g_free);
+		struct fp_img *img;
-      self->strips = NULL;
+
-      self->strips_len = 0;
+		aesdev->strips = g_slist_reverse(aesdev->strips);
-      fpi_image_device_image_captured (dev, img);
+		img = fpi_assemble_frames(&assembling_ctx,
-      fpi_image_device_report_finger_status (dev, FALSE);
+					  aesdev->strips, aesdev->strips_len);
+		img->flags |= FP_IMG_PARTIAL;
+		g_slist_free_full(aesdev->strips, g_free);
+		aesdev->strips = NULL;
+		aesdev->strips_len = 0;
+		fpi_imgdev_image_captured(dev, img);
+		fpi_imgdev_report_finger_status(dev, FALSE);
 		/* marking machine complete will re-trigger finger detection loop */
-      fpi_ssm_mark_completed (transfer->ssm);
+		fpi_ssm_mark_completed(ssm);
-    }
+	} else {
-  else
+		fpi_ssm_mark_failed(ssm, -EIO);
-    {
-      if (error)
-        fpi_ssm_mark_failed (transfer->ssm, error);
-      else
-        fpi_ssm_mark_failed (transfer->ssm,
-                             fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
 	}
+	libusb_free_transfer(transfer);
 }
 
-static void
+static void capture_read_data_cb(struct libusb_transfer *transfer)
-capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                      gpointer user_data, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
+	fpi_ssm *ssm = transfer->user_data;
-  FpiDeviceAes2550 *self = FPI_DEVICE_AES2550 (dev);
+	struct fp_img_dev *dev = fpi_ssm_get_user_data(ssm);
+	struct aes2550_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
 	unsigned char *data = transfer->buffer;
+	int r;
 
-  if (error)
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
-    {
+		fp_dbg("request is not completed, %d", transfer->status);
-      fpi_ssm_mark_failed (transfer->ssm, error);
+		fpi_ssm_mark_failed(ssm, -EIO);
-      return;
+		goto out;
 	}
 
-  fp_dbg ("request completed, len: %.4x", (gint) transfer->actual_length);
+	fp_dbg("request completed, len: %.4x", transfer->actual_length);
 	if (transfer->actual_length >= 2)
 		fp_dbg("data: %.2x %.2x", (int)data[0], (int)data[1]);
 
-  switch (transfer->actual_length)
+	switch (transfer->actual_length) {
-    {
 		case AES2550_STRIP_SIZE:
-      if (!process_strip_data (transfer->ssm, dev, data))
+			r = process_strip_data(ssm, dev, data);
-        {
+			if (r < 0) {
-          fp_dbg ("Processing strip data failed");
+				fp_dbg("Processing strip data failed: %d", r);
-          fpi_ssm_mark_failed (transfer->ssm,
+				fpi_ssm_mark_failed(ssm, -EPROTO);
-                               fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
+				goto out;
-          return;
 			}
-      self->heartbeat_cnt = 0;
+			aesdev->heartbeat_cnt = 0;
-      fpi_ssm_jump_to_state (transfer->ssm, CAPTURE_READ_DATA);
+			fpi_ssm_jump_to_state(ssm, CAPTURE_READ_DATA);
 			break;
-
 		case AES2550_HEARTBEAT_SIZE:
-      if (data[0] == AES2550_HEARTBEAT_MAGIC)
+			if (data[0] == AES2550_HEARTBEAT_MAGIC) {
-        {
 				/* No data for a long time => finger was removed or there's no movement */
-          self->heartbeat_cnt++;
+				aesdev->heartbeat_cnt++;
-          if (self->heartbeat_cnt == 3)
+				if (aesdev->heartbeat_cnt == 3) {
-            {
 					/* Got 3 heartbeat message, that's enough to consider that finger was removed,
 					 * assemble image and submit it to the library */
 					fp_dbg("Got 3 heartbeats => finger removed");
-              fpi_ssm_next_state (transfer->ssm);
+					fpi_ssm_next_state(ssm);
-            }
+				} else {
-          else
+					fpi_ssm_jump_to_state(ssm, CAPTURE_READ_DATA);
-            {
-              fpi_ssm_jump_to_state (transfer->ssm,
-                                     CAPTURE_READ_DATA);
 				}
 			}
 			break;
-
 		default:
-      fp_dbg ("Short frame %d, skip",
+			fp_dbg("Short frame %d, skip", transfer->actual_length);
-              (gint) transfer->actual_length);
+			fpi_ssm_jump_to_state(ssm, CAPTURE_READ_DATA);
-      fpi_ssm_jump_to_state (transfer->ssm, CAPTURE_READ_DATA);
 			break;
 	}
+out:
+	g_free(transfer->buffer);
+	libusb_free_transfer(transfer);
 }
 
-static void
+static void capture_run_state(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-capture_run_state (FpiSsm *ssm, FpDevice *dev)
-{
-  switch (fpi_ssm_get_cur_state (ssm))
 {
+	struct fp_img_dev *dev = user_data;
+	int r;
+
+	switch (fpi_ssm_get_cur_state(ssm)) {
 	case CAPTURE_WRITE_REQS:
 	{
-        FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
+		struct libusb_transfer *transfer = fpi_usb_alloc();
 
-        fpi_usb_transfer_fill_bulk_full (transfer, EP_OUT, capture_reqs,
+		libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), EP_OUT, capture_reqs,
-                                         sizeof (capture_reqs), NULL);
+			sizeof(capture_reqs), capture_reqs_cb, ssm, BULK_TIMEOUT);
-        transfer->ssm = ssm;
+		r = libusb_submit_transfer(transfer);
-        transfer->short_is_error = TRUE;
+		if (r < 0) {
-        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+			libusb_free_transfer(transfer);
-                                 fpi_ssm_usb_transfer_cb, NULL);
+			fpi_ssm_mark_failed(ssm, -ENOMEM);
+		}
 	}
 	break;
-
 	case CAPTURE_READ_DATA:
 	{
-        FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
+		struct libusb_transfer *transfer = fpi_usb_alloc();
+		unsigned char *data;
 
-        fpi_usb_transfer_fill_bulk (transfer, EP_IN, AES2550_EP_IN_BUF_SIZE);
+		data = g_malloc(AES2550_EP_IN_BUF_SIZE);
-        transfer->ssm = ssm;
+		libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), EP_IN, data, AES2550_EP_IN_BUF_SIZE,
-        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+			capture_read_data_cb, ssm, BULK_TIMEOUT);
-                                 capture_read_data_cb, NULL);
+
+		r = libusb_submit_transfer(transfer);
+		if (r < 0) {
+			g_free(data);
+			libusb_free_transfer(transfer);
+			fpi_ssm_mark_failed(ssm, r);
+		}
 	}
 	break;
-
 	case CAPTURE_SET_IDLE:
 	{
-        FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
+		struct libusb_transfer *transfer = fpi_usb_alloc();
 
-        fpi_usb_transfer_fill_bulk_full (transfer, EP_OUT,
+		libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), EP_OUT, capture_set_idle_reqs,
-                                         capture_set_idle_reqs,
+			sizeof(capture_set_idle_reqs), capture_set_idle_reqs_cb, ssm, BULK_TIMEOUT);
-                                         sizeof (capture_set_idle_reqs),
+		r = libusb_submit_transfer(transfer);
-                                         NULL);
+		if (r < 0) {
-        transfer->ssm = ssm;
+			libusb_free_transfer(transfer);
-        transfer->short_is_error = TRUE;
+			fpi_ssm_mark_failed(ssm, -ENOMEM);
-        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+		}
-                                 capture_set_idle_reqs_cb, NULL);
 	}
 	break;
-    }
+	};
-  ;
 }
 
-static void
+static void capture_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 {
-  FpiDeviceAes2550 *self = FPI_DEVICE_AES2550 (_dev);
+	struct fp_img_dev *dev = user_data;
-  FpImageDevice *dev = FP_IMAGE_DEVICE (self);
+	struct aes2550_dev *aesdev = FP_INSTANCE_DATA(_dev);
 
 	fp_dbg("Capture completed");
-
+	if (aesdev->deactivating)
-  if (self->deactivating)
-    {
 		complete_deactivation(dev);
-      g_clear_pointer (&error, g_error_free);
+	else if (fpi_ssm_get_error(ssm))
-    }
+		fpi_imgdev_session_error(dev, fpi_ssm_get_error(ssm));
-  else if (error)
-    {
-      fpi_image_device_session_error (dev, error);
-    }
 	else
-    {
 		start_finger_detection(dev);
-    }
+	fpi_ssm_free(ssm);
 }
 
-static void
+static void start_capture(struct fp_img_dev *dev)
-start_capture (FpImageDevice *dev)
 {
-  FpiDeviceAes2550 *self = FPI_DEVICE_AES2550 (dev);
+	struct aes2550_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpiSsm *ssm;
+	fpi_ssm *ssm;
 
-  if (self->deactivating)
+	if (aesdev->deactivating) {
-    {
 		complete_deactivation(dev);
 		return;
 	}
 
-  self->heartbeat_cnt = 0;
+	aesdev->heartbeat_cnt = 0;
-  ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state, CAPTURE_NUM_STATES);
+	ssm = fpi_ssm_new(FP_DEV(dev), capture_run_state, CAPTURE_NUM_STATES, dev);
 	G_DEBUG_HERE();
 	fpi_ssm_start(ssm, capture_sm_complete);
 }
@@ -421,162 +420,201 @@ enum activate_states {
 	ACTIVATE_NUM_STATES,
 };
 
-/* TODO: use calibration table, datasheet is rather terse on that
+static void init_reqs_cb(struct libusb_transfer *transfer)
- * need more info for implementation */
-static void
-calibrate_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                        gpointer user_data, GError *error)
 {
-  fpi_ssm_usb_transfer_cb (transfer, device, user_data, error);
+	fpi_ssm *ssm = transfer->user_data;
+
+	if ((transfer->status == LIBUSB_TRANSFER_COMPLETED) &&
+		(transfer->length == transfer->actual_length)) {
+		fpi_ssm_next_state(ssm);
+	} else {
+		fpi_ssm_mark_failed(ssm, -EIO);
+	}
+	libusb_free_transfer(transfer);
 }
 
-static void
+static void init_read_data_cb(struct libusb_transfer *transfer)
-activate_run_state (FpiSsm *ssm, FpDevice *dev)
 {
-  switch (fpi_ssm_get_cur_state (ssm))
+	fpi_ssm *ssm = transfer->user_data;
+
+	if (transfer->status == LIBUSB_TRANSFER_COMPLETED) {
+		fpi_ssm_next_state(ssm);
+	} else {
+		fpi_ssm_mark_failed(ssm, -EIO);
+	}
+	g_free(transfer->buffer);
+	libusb_free_transfer(transfer);
+}
+
+/* TODO: use calibration table, datasheet is rather terse on that
+ * need more info for implementaion */
+static void calibrate_read_data_cb(struct libusb_transfer *transfer)
 {
+	fpi_ssm *ssm = transfer->user_data;
+
+	if (transfer->status == LIBUSB_TRANSFER_COMPLETED) {
+		fpi_ssm_next_state(ssm);
+	} else {
+		fpi_ssm_mark_failed(ssm, -EIO);
+	}
+	g_free(transfer->buffer);
+	libusb_free_transfer(transfer);
+}
+
+static void activate_run_state(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
+{
+	struct fp_img_dev *dev = user_data;
+	int r;
+
+	switch (fpi_ssm_get_cur_state(ssm)) {
 	case WRITE_INIT:
 	{
-        FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
+		struct libusb_transfer *transfer = fpi_usb_alloc();
 
-        fpi_usb_transfer_fill_bulk_full (transfer, EP_OUT, init_reqs,
+		libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), EP_OUT, init_reqs,
-                                         sizeof (init_reqs), NULL);
+			sizeof(init_reqs), init_reqs_cb, ssm, BULK_TIMEOUT);
-        transfer->ssm = ssm;
+		r = libusb_submit_transfer(transfer);
-        transfer->short_is_error = TRUE;
+		if (r < 0) {
-        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+			libusb_free_transfer(transfer);
-                                 fpi_ssm_usb_transfer_cb, NULL);
+			fpi_ssm_mark_failed(ssm, -ENOMEM);
+		}
 	}
 	break;
-
 	case READ_DATA:
 	{
-        FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
+		struct libusb_transfer *transfer = fpi_usb_alloc();
+		unsigned char *data;
 
-        fpi_usb_transfer_fill_bulk (transfer, EP_IN, AES2550_EP_IN_BUF_SIZE);
+		data = g_malloc(AES2550_EP_IN_BUF_SIZE);
-        transfer->ssm = ssm;
+		libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), EP_IN, data, AES2550_EP_IN_BUF_SIZE,
-        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+			init_read_data_cb, ssm, BULK_TIMEOUT);
-                                 fpi_ssm_usb_transfer_cb, NULL);
+
+		r = libusb_submit_transfer(transfer);
+		if (r < 0) {
+			g_free(data);
+			libusb_free_transfer(transfer);
+			fpi_ssm_mark_failed(ssm, r);
+		}
 	}
 	break;
-
 	case CALIBRATE:
 	{
-        FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
+		struct libusb_transfer *transfer = fpi_usb_alloc();
 
-        fpi_usb_transfer_fill_bulk_full (transfer, EP_OUT,
+		libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), EP_OUT, calibrate_reqs,
-                                         calibrate_reqs,
+			sizeof(calibrate_reqs), init_reqs_cb, ssm, BULK_TIMEOUT);
-                                         sizeof (calibrate_reqs), NULL);
+		r = libusb_submit_transfer(transfer);
-        transfer->ssm = ssm;
+		if (r < 0) {
-        transfer->short_is_error = TRUE;
+			libusb_free_transfer(transfer);
-        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+			fpi_ssm_mark_failed(ssm, -ENOMEM);
-                                 fpi_ssm_usb_transfer_cb, NULL);
+		}
 	}
 	break;
-
 	case READ_CALIB_TABLE:
 	{
-        FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
+		struct libusb_transfer *transfer = fpi_usb_alloc();
+		unsigned char *data;
 
-        fpi_usb_transfer_fill_bulk (transfer, EP_IN, AES2550_EP_IN_BUF_SIZE);
+		data = g_malloc(AES2550_EP_IN_BUF_SIZE);
-        transfer->ssm = ssm;
+		libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), EP_IN, data, AES2550_EP_IN_BUF_SIZE,
-        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+			calibrate_read_data_cb, ssm, BULK_TIMEOUT);
-                                 calibrate_read_data_cb, NULL);
+
+		r = libusb_submit_transfer(transfer);
+		if (r < 0) {
+			g_free(data);
+			libusb_free_transfer(transfer);
+			fpi_ssm_mark_failed(ssm, r);
+		}
 	}
 	break;
 	}
 }
 
-static void
+static void activate_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = user_data;
+	fp_dbg("status %d", fpi_ssm_get_error(ssm));
+	fpi_imgdev_activate_complete(dev, fpi_ssm_get_error(ssm));
 
-  fpi_image_device_activate_complete (dev, error);
+	if (!fpi_ssm_get_error(ssm))
-
-  if (!error)
 		start_finger_detection(dev);
+	fpi_ssm_free(ssm);
 }
 
-static void
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
-dev_activate (FpImageDevice *dev)
 {
-  FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state,
+	fpi_ssm *ssm = fpi_ssm_new(FP_DEV(dev), activate_run_state,
-                             ACTIVATE_NUM_STATES);
+		ACTIVATE_NUM_STATES, dev);
-
 	fpi_ssm_start(ssm, activate_sm_complete);
+	return 0;
 }
 
-static void
+static void dev_deactivate(struct fp_img_dev *dev)
-dev_deactivate (FpImageDevice *dev)
 {
-  FpiDeviceAes2550 *self = FPI_DEVICE_AES2550 (dev);
+	struct aes2550_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
 
-  self->deactivating = TRUE;
+	aesdev->deactivating = TRUE;
 }
 
-static void
+static void complete_deactivation(struct fp_img_dev *dev)
-complete_deactivation (FpImageDevice *dev)
 {
-  FpiDeviceAes2550 *self = FPI_DEVICE_AES2550 (dev);
+	struct aes2550_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-
 	G_DEBUG_HERE();
 
-  self->deactivating = FALSE;
+	aesdev->deactivating = FALSE;
-  g_slist_free (self->strips);
+	g_slist_free(aesdev->strips);
-  self->strips = NULL;
+	aesdev->strips = NULL;
-  self->strips_len = 0;
+	aesdev->strips_len = 0;
-  fpi_image_device_deactivate_complete (dev, NULL);
+	fpi_imgdev_deactivate_complete(dev);
 }
 
-static void
+static int dev_init(struct fp_img_dev *dev, unsigned long driver_data)
-dev_init (FpImageDevice *dev)
 {
-  GError *error = NULL;
-
 	/* TODO check that device has endpoints we're using */
+	int r;
+	struct aes2550_dev *aes2550_dev;
 
-  g_usb_device_claim_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error);
+	r = libusb_claim_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
-
+	if (r < 0) {
-  fpi_image_device_open_complete (dev, error);
+		fp_err("could not claim interface 0: %s", libusb_error_name(r));
+		return r;
 	}
 
-static void
+	aes2550_dev = g_malloc0(sizeof(struct aes2550_dev));
-dev_deinit (FpImageDevice *dev)
+	fp_dev_set_instance_data(FP_DEV(dev), aes2550_dev);
+	fpi_imgdev_open_complete(dev, 0);
+	return 0;
+}
+
+static void dev_deinit(struct fp_img_dev *dev)
 {
-  GError *error = NULL;
+	struct aes2550_dev *aesdev;
-
+	aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)),
+	g_free(aesdev);
-                                  0, 0, &error);
+	libusb_release_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
-  fpi_image_device_close_complete (dev, error);
+	fpi_imgdev_close_complete(dev);
 }
 
-static const FpIdEntry id_table[] = {
+static const struct usb_id id_table[] = {
-  { .vid = 0x08ff,  .pid = 0x2550, },/* AES2550 */
+	{ .vendor = 0x08ff, .product = 0x2550 }, /* AES2550 */
-  { .vid = 0x08ff,  .pid = 0x2810, },/* AES2810 */
+	{ .vendor = 0x08ff, .product = 0x2810 }, /* AES2810 */
-  { .vid = 0,  .pid = 0,  .driver_data = 0 },
+	{ 0, 0, 0, },
 };
 
-static void
+struct fp_img_driver aes2550_driver = {
-fpi_device_aes2550_init (FpiDeviceAes2550 *self)
+	.driver = {
-{
+		.id = AES2550_ID,
-}
+		.name = FP_COMPONENT,
-static void
+		.full_name = "AuthenTec AES2550/AES2810",
-fpi_device_aes2550_class_init (FpiDeviceAes2550Class *klass)
+		.id_table = id_table,
-{
+		.scan_type = FP_SCAN_TYPE_SWIPE,
-  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
+	},
-  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
+	.flags = 0,
+	.img_height = -1,
+	.img_width = FRAME_WIDTH + FRAME_WIDTH / 2,
 
-  dev_class->id = "aes2550";
+	.open = dev_init,
-  dev_class->full_name = "AuthenTec AES2550/AES2810";
+	.close = dev_deinit,
-  dev_class->type = FP_DEVICE_TYPE_USB;
+	.activate = dev_activate,
-  dev_class->id_table = id_table;
+	.deactivate = dev_deactivate,
-  dev_class->scan_type = FP_SCAN_TYPE_SWIPE;
+};
-
-  img_class->img_open = dev_init;
-  img_class->img_close = dev_deinit;
-  img_class->activate = dev_activate;
-  img_class->deactivate = dev_deactivate;
-
-  img_class->img_width = FRAME_WIDTH + FRAME_WIDTH / 2;
-  img_class->img_height = -1;
-}

libfprint/drivers/aes2550.h

@@ -17,7 +17,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
+#ifndef __AES2550_H
+#define __AES2550_H
 
 /* Registers bits */
 
@@ -109,3 +110,5 @@ enum aes2550_cmds {
 #define AES2550_HEARTBEAT_MAGIC		0xdb
 
 #define AES2550_EP_IN_BUF_SIZE		8192
+
+#endif

libfprint/drivers/aes2660.c

@@ -27,14 +27,6 @@
 #define FRAME_WIDTH 192
 #define IMAGE_WIDTH	(FRAME_WIDTH + (FRAME_WIDTH / 2))
 
-struct _FpiDeviceAes2660
-{
-  FpiDeviceAesX660 parent;
-};
-G_DECLARE_FINAL_TYPE (FpiDeviceAes2660, fpi_device_aes2660, FPI,
-                      DEVICE_AES2660, FpiDeviceAesX660);
-G_DEFINE_TYPE (FpiDeviceAes2660, fpi_device_aes2660, FPI_TYPE_DEVICE_AES_X660);
-
 static struct fpi_frame_asmbl_ctx assembling_ctx = {
 	.frame_width = FRAME_WIDTH,
 	.frame_height = AESX660_FRAME_HEIGHT,
@@ -42,56 +34,81 @@ static struct fpi_frame_asmbl_ctx assembling_ctx = {
 	.get_pixel = aes_get_pixel,
 };
 
-static const FpIdEntry id_table[] = {
+static int dev_init(struct fp_img_dev *dev, unsigned long driver_data)
-  { .vid = 0x08ff,  .pid = 0x2660, },
+{
-  { .vid = 0x08ff,  .pid = 0x2680, },
+	/* TODO check that device has endpoints we're using */
-  { .vid = 0x08ff,  .pid = 0x2681, },
+	int r;
-  { .vid = 0x08ff,  .pid = 0x2682, },
+	struct aesX660_dev *aesdev;
-  { .vid = 0x08ff,  .pid = 0x2683, },
+
-  { .vid = 0x08ff,  .pid = 0x2684, },
+	r = libusb_claim_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
-  { .vid = 0x08ff,  .pid = 0x2685, },
+	if (r < 0) {
-  { .vid = 0x08ff,  .pid = 0x2686, },
+		fp_err("could not claim interface 0: %s", libusb_error_name(r));
-  { .vid = 0x08ff,  .pid = 0x2687, },
+		return r;
-  { .vid = 0x08ff,  .pid = 0x2688, },
+	}
-  { .vid = 0x08ff,  .pid = 0x2689, },
+
-  { .vid = 0x08ff,  .pid = 0x268a, },
+	aesdev = g_malloc0(sizeof(struct aesX660_dev));
-  { .vid = 0x08ff,  .pid = 0x268b, },
+	fp_dev_set_instance_data(FP_DEV(dev), aesdev);
-  { .vid = 0x08ff,  .pid = 0x268c, },
+	aesdev->buffer = g_malloc0(AES2660_FRAME_SIZE + AESX660_HEADER_SIZE);
-  { .vid = 0x08ff,  .pid = 0x268d, },
+	/* No scaling for AES2660 */
-  { .vid = 0x08ff,  .pid = 0x268e, },
+	aesdev->init_seqs[0] = aes2660_init_1;
-  { .vid = 0x08ff,  .pid = 0x268f, },
+	aesdev->init_seqs_len[0] = G_N_ELEMENTS(aes2660_init_1);
-  { .vid = 0x08ff,  .pid = 0x2691, },
+	aesdev->init_seqs[1] = aes2660_init_2;
-  { .vid = 0,  .pid = 0,  .driver_data = 0 },
+	aesdev->init_seqs_len[1] = G_N_ELEMENTS(aes2660_init_2);
+	aesdev->start_imaging_cmd = (unsigned char *)aes2660_start_imaging_cmd;
+	aesdev->start_imaging_cmd_len = sizeof(aes2660_start_imaging_cmd);
+	aesdev->assembling_ctx = &assembling_ctx;
+	aesdev->extra_img_flags = FP_IMG_PARTIAL;
+
+	fpi_imgdev_open_complete(dev, 0);
+	return 0;
+}
+
+static void dev_deinit(struct fp_img_dev *dev)
+{
+	struct aesX660_dev *aesdev;
+	aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
+	g_free(aesdev->buffer);
+	g_free(aesdev);
+	libusb_release_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
+	fpi_imgdev_close_complete(dev);
+}
+
+static const struct usb_id id_table[] = {
+	{ .vendor = 0x08ff, .product = 0x2660 },
+	{ .vendor = 0x08ff, .product = 0x2680 },
+	{ .vendor = 0x08ff, .product = 0x2681 },
+	{ .vendor = 0x08ff, .product = 0x2682 },
+	{ .vendor = 0x08ff, .product = 0x2683 },
+	{ .vendor = 0x08ff, .product = 0x2684 },
+	{ .vendor = 0x08ff, .product = 0x2685 },
+	{ .vendor = 0x08ff, .product = 0x2686 },
+	{ .vendor = 0x08ff, .product = 0x2687 },
+	{ .vendor = 0x08ff, .product = 0x2688 },
+	{ .vendor = 0x08ff, .product = 0x2689 },
+	{ .vendor = 0x08ff, .product = 0x268a },
+	{ .vendor = 0x08ff, .product = 0x268b },
+	{ .vendor = 0x08ff, .product = 0x268c },
+	{ .vendor = 0x08ff, .product = 0x268d },
+	{ .vendor = 0x08ff, .product = 0x268e },
+	{ .vendor = 0x08ff, .product = 0x268f },
+	{ .vendor = 0x08ff, .product = 0x2691 },
+	{ 0, 0, 0, },
 };
 
-static void
+struct fp_img_driver aes2660_driver = {
-fpi_device_aes2660_init (FpiDeviceAes2660 *self)
+	.driver = {
-{
+		.id = AES2660_ID,
-}
+		.name = FP_COMPONENT,
+		.full_name = "AuthenTec AES2660",
+		.id_table = id_table,
+		.scan_type = FP_SCAN_TYPE_SWIPE,
+	},
+	.flags = 0,
+	.img_height = -1,
+	.img_width = FRAME_WIDTH + FRAME_WIDTH / 2,
 
-static void
+	.open = dev_init,
-fpi_device_aes2660_class_init (FpiDeviceAes2660Class *klass)
+	.close = dev_deinit,
-{
+	.activate = aesX660_dev_activate,
-  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
+	.deactivate = aesX660_dev_deactivate,
-  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
+};
-  FpiDeviceAesX660Class *aes_class = FPI_DEVICE_AES_X660_CLASS (klass);
-
-  dev_class->id = "aes2660";
-  dev_class->full_name = "AuthenTec AES2660";
-  dev_class->type = FP_DEVICE_TYPE_USB;
-  dev_class->id_table = id_table;
-  dev_class->scan_type = FP_SCAN_TYPE_SWIPE;
-
-  img_class->bz3_threshold = 20;
-
-  img_class->img_width = FRAME_WIDTH + FRAME_WIDTH / 2;
-  img_class->img_height = -1;
-
-  aes_class->init_seqs[0] = aes2660_init_1;
-  aes_class->init_seqs_len[0] = G_N_ELEMENTS (aes2660_init_1);
-  aes_class->init_seqs[1] = aes2660_init_2;
-  aes_class->init_seqs_len[1] = G_N_ELEMENTS (aes2660_init_2);
-  aes_class->start_imaging_cmd = (unsigned char *) aes2660_start_imaging_cmd;
-  aes_class->start_imaging_cmd_len = sizeof (aes2660_start_imaging_cmd);
-  aes_class->assembling_ctx = &assembling_ctx;
-}

libfprint/drivers/aes2660.h

@@ -17,7 +17,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
+#ifndef __AES2660_H
+#define __AES2660_H
 
 #define AES2660_FRAME_SIZE 0x354
 
@@ -1959,3 +1960,5 @@ static const unsigned char aes2660_start_imaging_cmd[] = {
 0x55, 0x07, 0x00, 0x80, 0x42, 0x00, 0xbf, 0x00, 0x00, 0x18,
 0x49, 0x03, 0x00, 0x20, 0x08, 0xc8
 };
+
+#endif

libfprint/drivers/aes3500.c

@@ -29,6 +29,8 @@
 
 #define FP_COMPONENT "aes3500"
 
+#include "drivers_api.h"
+#include "aeslib.h"
 #include "aes3k.h"
 
 #define DATA_BUFLEN	0x2089
@@ -115,44 +117,67 @@ static struct aes_regwrite init_reqs[] = {
 	{ 0x81, 0x00 },
 };
 
-struct _FpiDeviceAes3500
+static int dev_init(struct fp_img_dev *dev, unsigned long driver_data)
 {
-  FpiDeviceAes3k parent;
+	int r;
-};
+	struct aes3k_dev *aesdev;
-G_DECLARE_FINAL_TYPE (FpiDeviceAes3500, fpi_device_aes3500, FPI,
-                      DEVICE_AES3500, FpiDeviceAes3k);
-G_DEFINE_TYPE (FpiDeviceAes3500, fpi_device_aes3500, FPI_TYPE_DEVICE_AES3K);
 
-
+	r = libusb_claim_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
-static const FpIdEntry id_table[] = {
+	if (r < 0) {
-  { .vid = 0x08ff, .pid = 0x5731 },
+		fp_err("could not claim interface 0: %s", libusb_error_name(r));
-  { .vid = 0,  .pid = 0,  .driver_data = 0 },
+		return r;
-};
-
-static void
-fpi_device_aes3500_init (FpiDeviceAes3500 *self)
-{
 	}
 
-static void
+	aesdev = g_malloc0(sizeof(struct aes3k_dev));
-fpi_device_aes3500_class_init (FpiDeviceAes3500Class *klass)
+	fp_dev_set_instance_data(FP_DEV(dev), aesdev);
-{
-  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
-  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
-  FpiDeviceAes3kClass *aes_class = FPI_DEVICE_AES3K_CLASS (klass);
 
-  dev_class->id = "aes3500";
+	if (!aesdev)
-  dev_class->full_name = "AuthenTec AES3500";
+		return -ENOMEM;
-  dev_class->id_table = id_table;
 
-  img_class->img_height = FRAME_WIDTH * ENLARGE_FACTOR;
+	aesdev->data_buflen = DATA_BUFLEN;
-  img_class->img_width = FRAME_WIDTH * ENLARGE_FACTOR;
+	aesdev->frame_width = FRAME_WIDTH;
+	aesdev->frame_size = FRAME_SIZE;
+	aesdev->frame_number = FRAME_NUMBER;
+	aesdev->enlarge_factor = ENLARGE_FACTOR;
+	aesdev->init_reqs = init_reqs;
+	aesdev->init_reqs_len = G_N_ELEMENTS(init_reqs);
+	fpi_imgdev_open_complete(dev, 0);
 
-  aes_class->data_buflen = DATA_BUFLEN;
+	return r;
-  aes_class->frame_width = FRAME_WIDTH;
-  aes_class->frame_size = FRAME_SIZE;
-  aes_class->frame_number = FRAME_NUMBER;
-  aes_class->enlarge_factor = ENLARGE_FACTOR;
-  aes_class->init_reqs = init_reqs;
-  aes_class->init_reqs_len = G_N_ELEMENTS (init_reqs);
 }
+
+static void dev_deinit(struct fp_img_dev *dev)
+{
+	struct aes3k_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
+	g_free(aesdev);
+	libusb_release_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
+	fpi_imgdev_close_complete(dev);
+}
+
+
+static const struct usb_id id_table[] = {
+	{ .vendor = 0x08ff, .product = 0x5731 },
+	{ 0, 0, 0, },
+};
+
+struct fp_img_driver aes3500_driver = {
+	.driver = {
+		.id = AES3500_ID,
+		.name = FP_COMPONENT,
+		.full_name = "AuthenTec AES3500",
+		.id_table = id_table,
+		.scan_type = FP_SCAN_TYPE_PRESS,
+	},
+	.flags = 0,
+	.img_height = FRAME_WIDTH * ENLARGE_FACTOR,
+	.img_width = FRAME_WIDTH * ENLARGE_FACTOR,
+
+	/* temporarily lowered until image quality improves */
+	.bz3_threshold = 9,
+
+	.open = dev_init,
+	.close = dev_deinit,
+	.activate = aes3k_dev_activate,
+	.deactivate = aes3k_dev_deactivate,
+};
+

libfprint/drivers/aes3k.c

@@ -40,30 +40,19 @@
 #include "aeslib.h"
 #include "aes3k.h"
 
-typedef struct
-{
-  FpiUsbTransfer *img_trf;
-  gboolean        deactivating;
-} FpiDeviceAes3kPrivate;
-
 #define CTRL_TIMEOUT	1000
-#define EP_IN (1 | FPI_USB_ENDPOINT_IN)
+#define EP_IN		(1 | LIBUSB_ENDPOINT_IN)
-#define EP_OUT (2 | FPI_USB_ENDPOINT_OUT)
+#define EP_OUT		(2 | LIBUSB_ENDPOINT_OUT)
 
-static void do_capture (FpImageDevice *dev);
+static void do_capture(struct fp_img_dev *dev);
 
-G_DEFINE_ABSTRACT_TYPE_WITH_PRIVATE (FpiDeviceAes3k, fpi_device_aes3k, FP_TYPE_IMAGE_DEVICE);
+static void aes3k_assemble_image(unsigned char *input, size_t width, size_t height,
-
-static void
-aes3k_assemble_image (unsigned char *input, size_t width, size_t height,
 	unsigned char *output)
 {
 	size_t row, column;
 
-  for (column = 0; column < width; column++)
+	for (column = 0; column < width; column++) {
-    {
+		for (row = 0; row < height; row += 2) {
-      for (row = 0; row < height; row += 2)
-        {
 			output[width * row + column] = (*input & 0x0f) * 17;
 			output[width * (row + 1) + column] = ((*input & 0xf0) >> 4) * 17;
 			input++;
@@ -71,156 +60,99 @@ aes3k_assemble_image (unsigned char *input, size_t width, size_t height,
 	}
 }
 
-static void
+static void img_cb(struct libusb_transfer *transfer)
-img_cb (FpiUsbTransfer *transfer, FpDevice *device,
-        gpointer user_data, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
+	struct fp_img_dev *dev = transfer->user_data;
-  FpiDeviceAes3k *self = FPI_DEVICE_AES3K (device);
+	struct aes3k_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpiDeviceAes3kPrivate *priv = fpi_device_aes3k_get_instance_private (self);
-  FpiDeviceAes3kClass *cls = FPI_DEVICE_AES3K_GET_CLASS (self);
 	unsigned char *ptr = transfer->buffer;
-  FpImage *tmp;
+	struct fp_img *tmp;
-  FpImage *img;
+	struct fp_img *img;
 	int i;
 
-  priv->img_trf = NULL;
+	if (transfer->status == LIBUSB_TRANSFER_CANCELLED) {
-
+		goto err;
-  if (error)
+	} else if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
-    {
+		fpi_imgdev_session_error(dev, -EIO);
-      if (g_error_matches (error,
+		goto err;
-                           G_IO_ERROR,
+	} else if (transfer->length != transfer->actual_length) {
-                           G_IO_ERROR_CANCELLED))
+		fpi_imgdev_session_error(dev, -EPROTO);
-        {
+		goto err;
-          /* Deactivation was completed. */
-          g_error_free (error);
-          if (priv->deactivating)
-            fpi_image_device_deactivate_complete (dev, NULL);
-          return;
 	}
 
-      fpi_image_device_session_error (dev, error);
+	fpi_imgdev_report_finger_status(dev, TRUE);
-    }
 
-  fpi_image_device_report_finger_status (dev, TRUE);
+	tmp = fpi_img_new(aesdev->frame_width * aesdev->frame_width);
-
+	tmp->width = aesdev->frame_width;
-  tmp = fp_image_new (cls->frame_width, cls->frame_width);
+	tmp->height = aesdev->frame_width;
-  tmp->width = cls->frame_width;
+	tmp->flags = FP_IMG_COLORS_INVERTED | FP_IMG_V_FLIPPED | FP_IMG_H_FLIPPED;
-  tmp->height = cls->frame_width;
+	for (i = 0; i < aesdev->frame_number; i++) {
-  tmp->flags = FPI_IMAGE_COLORS_INVERTED | FPI_IMAGE_V_FLIPPED | FPI_IMAGE_H_FLIPPED;
-  for (i = 0; i < cls->frame_number; i++)
-    {
 		fp_dbg("frame header byte %02x", *ptr);
 		ptr++;
-      aes3k_assemble_image (ptr, cls->frame_width, AES3K_FRAME_HEIGHT, tmp->data + (i * cls->frame_width * AES3K_FRAME_HEIGHT));
+		aes3k_assemble_image(ptr, aesdev->frame_width, AES3K_FRAME_HEIGHT, tmp->data + (i * aesdev->frame_width * AES3K_FRAME_HEIGHT));
-      ptr += cls->frame_size;
+		ptr += aesdev->frame_size;
 	}
 
 	/* FIXME: this is an ugly hack to make the image big enough for NBIS
 	 * to process reliably */
-  img = fpi_image_resize (tmp, cls->enlarge_factor, cls->enlarge_factor);
+	img = fpi_img_resize(tmp, aesdev->enlarge_factor, aesdev->enlarge_factor);
-  g_object_unref (tmp);
+	fp_img_free(tmp);
-  fpi_image_device_image_captured (dev, img);
+	fpi_imgdev_image_captured(dev, img);
 
 	/* FIXME: rather than assuming finger has gone, we should poll regs until
 	 * it really has, then restart the capture */
-  fpi_image_device_report_finger_status (dev, FALSE);
+	fpi_imgdev_report_finger_status(dev, FALSE);
 
 	do_capture(dev);
+
+err:
+	g_free(transfer->buffer);
+	aesdev->img_trf = NULL;
+	libusb_free_transfer(transfer);
+}
+
+static void do_capture(struct fp_img_dev *dev)
+{
+	struct aes3k_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
+	unsigned char *data;
+	int r;
+
+	aesdev->img_trf = fpi_usb_alloc();
+	data = g_malloc(aesdev->data_buflen);
+	libusb_fill_bulk_transfer(aesdev->img_trf, fpi_dev_get_usb_dev(FP_DEV(dev)), EP_IN, data,
+		aesdev->data_buflen, img_cb, dev, 0);
+
+	r = libusb_submit_transfer(aesdev->img_trf);
+	if (r < 0) {
+		g_free(data);
+		libusb_free_transfer(aesdev->img_trf);
+		aesdev->img_trf = NULL;
+		fpi_imgdev_session_error(dev, r);
+	}
+}
+
+static void init_reqs_cb(struct fp_img_dev *dev, int result, void *user_data)
+{
+	fpi_imgdev_activate_complete(dev, result);
+	if (result == 0)
+		do_capture(dev);
 }
 
-static void
+int aes3k_dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
-do_capture (FpImageDevice *dev)
 {
-  FpiDeviceAes3k *self = FPI_DEVICE_AES3K (dev);
+	struct aes3k_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpiDeviceAes3kPrivate *priv = fpi_device_aes3k_get_instance_private (self);
+	aes_write_regv(dev, aesdev->init_reqs, aesdev->init_reqs_len, init_reqs_cb, NULL);
-  FpiDeviceAes3kClass *cls = FPI_DEVICE_AES3K_GET_CLASS (self);
+	return 0;
-
-  priv->img_trf = fpi_usb_transfer_new (FP_DEVICE (dev));
-  fpi_usb_transfer_fill_bulk (priv->img_trf, EP_IN, cls->data_buflen);
-  priv->img_trf->short_is_error = TRUE;
-  fpi_usb_transfer_submit (priv->img_trf, 0,
-                           fpi_device_get_cancellable (FP_DEVICE (dev)),
-                           img_cb, NULL);
 }
 
-static void
+void aes3k_dev_deactivate(struct fp_img_dev *dev)
-init_reqs_cb (FpImageDevice *dev, GError *result, void *user_data)
 {
-  fpi_image_device_activate_complete (dev, result);
+	struct aes3k_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  if (!result)
+
-    do_capture (dev);
+	/* FIXME: should wait for cancellation to complete before returning
+	 * from deactivation, otherwise app may legally exit before we've
+	 * cleaned up */
+	if (aesdev->img_trf)
+		libusb_cancel_transfer(aesdev->img_trf);
+	fpi_imgdev_deactivate_complete(dev);
 }
 
-static void
-aes3k_dev_activate (FpImageDevice *dev)
-{
-  FpiDeviceAes3k *self = FPI_DEVICE_AES3K (dev);
-  FpiDeviceAes3kPrivate *priv = fpi_device_aes3k_get_instance_private (self);
-  FpiDeviceAes3kClass *cls = FPI_DEVICE_AES3K_GET_CLASS (self);
-
-  priv->deactivating = FALSE;
-  aes_write_regv (dev, cls->init_reqs, cls->init_reqs_len, init_reqs_cb, NULL);
-}
-
-static void
-aes3k_dev_deactivate (FpImageDevice *dev)
-{
-  FpiDeviceAes3k *self = FPI_DEVICE_AES3K (dev);
-  FpiDeviceAes3kPrivate *priv = fpi_device_aes3k_get_instance_private (self);
-
-  priv->deactivating = TRUE;
-  if (priv->img_trf)
-    return;
-  fpi_image_device_deactivate_complete (dev, NULL);
-}
-
-static void
-fpi_device_aes3k_init (FpiDeviceAes3k *self)
-{
-}
-
-static void
-aes3k_dev_init (FpImageDevice *dev)
-{
-  GError *error = NULL;
-
-  if (!g_usb_device_claim_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error))
-    {
-      fpi_image_device_open_complete (dev, error);
-      return;
-    }
-
-  fpi_image_device_open_complete (dev, NULL);
-}
-
-static void
-aes3k_dev_deinit (FpImageDevice *dev)
-{
-  GError *error = NULL;
-
-  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)),
-                                  0, 0, &error);
-  fpi_image_device_close_complete (dev, error);
-}
-
-
-static void
-fpi_device_aes3k_class_init (FpiDeviceAes3kClass *klass)
-{
-  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
-  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
-
-  dev_class->type = FP_DEVICE_TYPE_USB;
-  dev_class->scan_type = FP_SCAN_TYPE_PRESS;
-
-  img_class->img_open = aes3k_dev_init;
-  img_class->img_close = aes3k_dev_deinit;
-  img_class->activate = aes3k_dev_activate;
-  img_class->deactivate = aes3k_dev_deactivate;
-
-  /* Extremely low due to low image quality. */
-  img_class->bz3_threshold = 9;
-
-  /* Everything else is set by the subclasses. */
-}

libfprint/drivers/aes3k.h

@@ -34,27 +34,25 @@
  *
  */
 
-#pragma once
+#ifndef __AES3K_H
-#include "fpi-image-device.h"
+#define __AES3K_H
-#include "aeslib.h"
 
 #define AES3K_FRAME_HEIGHT	16
 
-G_DECLARE_DERIVABLE_TYPE (FpiDeviceAes3k, fpi_device_aes3k, FPI,
+struct aes3k_dev {
-                          DEVICE_AES3K, FpImageDevice)
+	struct libusb_transfer *img_trf;
+	size_t frame_width;  /* image size = frame_width x frame_width */
+	size_t frame_size;   /* 4 bits/pixel: frame_width x AES3K_FRAME_HEIGHT / 2 */
+	size_t frame_number; /* number of frames */
+	size_t enlarge_factor;
 
-#define FPI_TYPE_DEVICE_AES3K (fpi_device_aes3k_get_type ())
+	size_t data_buflen;             /* buffer length of usb bulk transfer */
-
-struct _FpiDeviceAes3kClass
-{
-  FpImageDeviceClass   parent;
-
-  gsize                frame_width; /* image size = frame_width x frame_width */
-  gsize                frame_size; /* 4 bits/pixel: frame_width x AES3K_FRAME_HEIGHT / 2 */
-  gsize                frame_number; /* number of frames */
-  gsize                enlarge_factor;
-
-  gsize                data_buflen;    /* buffer length of usb bulk transfer */
 	struct aes_regwrite *init_reqs; /* initial values sent to device */
-  gsize                init_reqs_len;
+	size_t init_reqs_len;
 };
+
+
+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

@@ -26,6 +26,8 @@
 
 #define FP_COMPONENT "aes4000"
 
+#include "drivers_api.h"
+#include "aeslib.h"
 #include "aes3k.h"
 
 #define DATA_BUFLEN	0x1259
@@ -112,44 +114,67 @@ static struct aes_regwrite init_reqs[] = {
 	{ 0x81, 0x00 },
 };
 
-struct _FpiDeviceAes4000
+static int dev_init(struct fp_img_dev *dev, unsigned long driver_data)
 {
-  FpiDeviceAes3k parent;
+	int r;
-};
+	struct aes3k_dev *aesdev;
-G_DECLARE_FINAL_TYPE (FpiDeviceAes4000, fpi_device_aes4000, FPI,
-                      DEVICE_AES4000, FpiDeviceAes3k);
-G_DEFINE_TYPE (FpiDeviceAes4000, fpi_device_aes4000, FPI_TYPE_DEVICE_AES3K);
 
-
+	r = libusb_claim_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
-static const FpIdEntry id_table[] = {
+	if (r < 0) {
-  { .pid = 0x08ff, .vid = 0x5501 },
+		fp_err("could not claim interface 0: %s", libusb_error_name(r));
-  { .vid = 0,  .pid = 0,  .driver_data = 0 },
+		return r;
-};
-
-static void
-fpi_device_aes4000_init (FpiDeviceAes4000 *self)
-{
 	}
 
-static void
+	aesdev = g_malloc0(sizeof(struct aes3k_dev));
-fpi_device_aes4000_class_init (FpiDeviceAes4000Class *klass)
+	fp_dev_set_instance_data(FP_DEV(dev), aesdev);
-{
-  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
-  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
-  FpiDeviceAes3kClass *aes_class = FPI_DEVICE_AES3K_CLASS (klass);
 
-  dev_class->id = "aes4000";
+	if (!aesdev)
-  dev_class->full_name = "AuthenTec AES4000";
+		return -ENOMEM;
-  dev_class->id_table = id_table;
 
-  img_class->img_height = FRAME_WIDTH * ENLARGE_FACTOR;
+	aesdev->data_buflen = DATA_BUFLEN;
-  img_class->img_width = FRAME_WIDTH * ENLARGE_FACTOR;
+	aesdev->frame_width = FRAME_WIDTH;
+	aesdev->frame_size = FRAME_SIZE;
+	aesdev->frame_number = FRAME_NUMBER;
+	aesdev->enlarge_factor = ENLARGE_FACTOR;
+	aesdev->init_reqs = init_reqs;
+	aesdev->init_reqs_len = G_N_ELEMENTS(init_reqs);
+	fpi_imgdev_open_complete(dev, 0);
 
-  aes_class->data_buflen = DATA_BUFLEN;
+	return r;
-  aes_class->frame_width = FRAME_WIDTH;
-  aes_class->frame_size = FRAME_SIZE;
-  aes_class->frame_number = FRAME_NUMBER;
-  aes_class->enlarge_factor = ENLARGE_FACTOR;
-  aes_class->init_reqs = init_reqs;
-  aes_class->init_reqs_len = G_N_ELEMENTS (init_reqs);
 }
+
+static void dev_deinit(struct fp_img_dev *dev)
+{
+	struct aes3k_dev *aesdev = FP_INSTANCE_DATA(FP_DEV(dev));
+	g_free(aesdev);
+	libusb_release_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
+	fpi_imgdev_close_complete(dev);
+}
+
+
+static const struct usb_id id_table[] = {
+	{ .vendor = 0x08ff, .product = 0x5501 },
+	{ 0, 0, 0, },
+};
+
+struct fp_img_driver aes4000_driver = {
+	.driver = {
+		.id = AES4000_ID,
+		.name = FP_COMPONENT,
+		.full_name = "AuthenTec AES4000",
+		.id_table = id_table,
+		.scan_type = FP_SCAN_TYPE_PRESS,
+	},
+	.flags = 0,
+	.img_height = FRAME_WIDTH * ENLARGE_FACTOR,
+	.img_width = FRAME_WIDTH * ENLARGE_FACTOR,
+
+	/* temporarily lowered until image quality improves */
+	.bz3_threshold = 9,
+
+	.open = dev_init,
+	.close = dev_deinit,
+	.activate = aes3k_dev_activate,
+	.deactivate = aes3k_dev_deactivate,
+};
+

libfprint/drivers/aeslib.c

@@ -19,21 +19,25 @@
 
 #define FP_COMPONENT "aeslib"
 
-#include "drivers_api.h"
+#include "fp_internal.h"
 
 #include <errno.h>
 #include <string.h>
 
+#include <glib.h>
+
+#include "fpi-usb.h"
+#include "fpi-assembling.h"
 #include "aeslib.h"
 
 #define MAX_REGWRITES_PER_REQUEST	16
 
 #define BULK_TIMEOUT	4000
-#define EP_IN (1 | FPI_USB_ENDPOINT_IN)
+#define EP_IN			(1 | LIBUSB_ENDPOINT_IN)
-#define EP_OUT (2 | FPI_USB_ENDPOINT_OUT)
+#define EP_OUT			(2 | LIBUSB_ENDPOINT_OUT)
 
-struct write_regv_data
+struct write_regv_data {
-{
+	struct fp_img_dev *imgdev;
 	unsigned int num_regs;
 	const struct aes_regwrite *regs;
 	unsigned int offset;
@@ -41,72 +45,70 @@ struct write_regv_data
 	void *user_data;
 };
 
-static void continue_write_regv (FpImageDevice          *dev,
+static void continue_write_regv(struct write_regv_data *wdata);
-                                 struct write_regv_data *wdata);
 
 /* libusb bulk callback for regv write completion transfer. continues the
  * transaction */
-static void
+static void write_regv_trf_complete(struct libusb_transfer *transfer)
-write_regv_trf_complete (FpiUsbTransfer *transfer, FpDevice *device,
-                         gpointer user_data, GError *error)
 {
-  struct write_regv_data *wdata = user_data;
+	struct write_regv_data *wdata = transfer->user_data;
 
-  if (error)
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED)
-    {
+		wdata->callback(wdata->imgdev, -EIO, wdata->user_data);
-      wdata->callback (FP_IMAGE_DEVICE (device), error, wdata->user_data);
+	else if (transfer->length != transfer->actual_length)
-      g_free (wdata);
+		wdata->callback(wdata->imgdev, -EPROTO, wdata->user_data);
-    }
 	else
-    {
+		continue_write_regv(wdata);
-      continue_write_regv (FP_IMAGE_DEVICE (device), wdata);
+
-    }
+	g_free(transfer->buffer);
+	libusb_free_transfer(transfer);
 }
 
 /* write from wdata->offset to upper_bound (inclusive) of wdata->regs */
-static void
+static int do_write_regv(struct write_regv_data *wdata, int upper_bound)
-do_write_regv (FpImageDevice *dev, struct write_regv_data *wdata, int upper_bound)
 {
 	unsigned int offset = wdata->offset;
 	unsigned int num = upper_bound - offset + 1;
 	size_t alloc_size = num * 2;
+	unsigned char *data = g_malloc(alloc_size);
 	unsigned int i;
 	size_t data_offset = 0;
-  FpiUsbTransfer *transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
+	struct libusb_transfer *transfer = fpi_usb_alloc();
+	int r;
 
-  fpi_usb_transfer_fill_bulk (transfer, EP_OUT, alloc_size);
+	for (i = offset; i < offset + num; i++) {
-
-  for (i = offset; i < offset + num; i++)
-    {
 		const struct aes_regwrite *regwrite = &wdata->regs[i];
-      transfer->buffer[data_offset++] = regwrite->reg;
+		data[data_offset++] = regwrite->reg;
-      transfer->buffer[data_offset++] = regwrite->value;
+		data[data_offset++] = regwrite->value;
 	}
 
-  transfer->short_is_error = TRUE;
+	libusb_fill_bulk_transfer(transfer, FP_DEV(wdata->imgdev)->udev, EP_OUT, data,
-  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+		alloc_size, write_regv_trf_complete, wdata, BULK_TIMEOUT);
-                           write_regv_trf_complete, wdata);
+	r = libusb_submit_transfer(transfer);
+	if (r < 0) {
+		g_free(data);
+		libusb_free_transfer(transfer);
+	}
+
+	return r;
 }
 
 /* write the next batch of registers to be written, or if there are no more,
  * indicate completion to the caller */
-static void
+static void continue_write_regv(struct write_regv_data *wdata)
-continue_write_regv (FpImageDevice *dev, struct write_regv_data *wdata)
 {
 	unsigned int offset = wdata->offset;
 	unsigned int regs_remaining;
 	unsigned int limit;
 	unsigned int upper_bound;
 	int i;
+	int r;
 
 	/* skip all zeros and ensure there is still work to do */
-  while (TRUE)
+	while (TRUE) {
-    {
+		if (offset >= wdata->num_regs) {
-      if (offset >= wdata->num_regs)
-        {
 			fp_dbg("all registers written");
-          wdata->callback (dev, 0, wdata->user_data);
+			wdata->callback(wdata->imgdev, 0, wdata->user_data);
-          g_free (wdata);
 			return;
 		}
 		if (wdata->regs[offset].reg)
@@ -122,13 +124,16 @@ continue_write_regv (FpImageDevice *dev, struct write_regv_data *wdata)
 	/* determine if we can write the entire of the regs at once, or if there
 	 * is a zero dividing things up */
 	for (i = offset; i <= upper_bound; i++)
-    if (!wdata->regs[i].reg)
+		if (!wdata->regs[i].reg) {
-      {
 			upper_bound = i - 1;
 			break;
 		}
 
-  do_write_regv (dev, wdata, upper_bound);
+	r = do_write_regv(wdata, upper_bound);
+	if (r < 0) {
+		wdata->callback(wdata->imgdev, r, wdata->user_data);
+		return;
+	}
 
 	wdata->offset = upper_bound + 1;
 }
@@ -136,25 +141,25 @@ continue_write_regv (FpImageDevice *dev, struct write_regv_data *wdata)
 /* write a load of registers to the device, combining multiple writes in a
  * single URB up to a limit. insert writes to non-existent register 0 to force
  * specific groups of writes to be separated by different URBs. */
-void
+void aes_write_regv(struct fp_img_dev *dev, const struct aes_regwrite *regs,
-aes_write_regv (FpImageDevice *dev, const struct aes_regwrite *regs,
+	unsigned int num_regs, aes_write_regv_cb callback, void *user_data)
-                unsigned int num_regs, aes_write_regv_cb callback,
-                void *user_data)
 {
 	struct write_regv_data *wdata;
 
 	fp_dbg("write %d regs", num_regs);
 	wdata = g_malloc(sizeof(*wdata));
+	wdata->imgdev = dev;
 	wdata->num_regs = num_regs;
 	wdata->regs = regs;
 	wdata->offset = 0;
 	wdata->callback = callback;
 	wdata->user_data = user_data;
-  continue_write_regv (dev, wdata);
+	continue_write_regv(wdata);
+
+	g_free(wdata);
 }
 
-unsigned char
+unsigned char aes_get_pixel(struct fpi_frame_asmbl_ctx *ctx,
-aes_get_pixel (struct fpi_frame_asmbl_ctx *ctx,
 					  struct fpi_frame *frame,
 					  unsigned int x,
 					  unsigned int y)

libfprint/drivers/aeslib.h

@@ -17,12 +17,12 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
+#ifndef __AESLIB_H__
+#define __AESLIB_H__
 
 #include <fprint.h>
 
-struct aes_regwrite
+struct aes_regwrite {
-{
 	unsigned char reg;
 	unsigned char value;
 };
@@ -30,17 +30,16 @@ struct aes_regwrite
 struct fpi_frame;
 struct fpi_frame_asmbl_ctx;
 
-typedef void (*aes_write_regv_cb)(FpImageDevice *dev,
+typedef void (*aes_write_regv_cb)(struct fp_img_dev *dev, int result,
-                                  GError        *error,
 	void *user_data);
 
-void aes_write_regv (FpImageDevice             *dev,
+void aes_write_regv(struct fp_img_dev *dev, const struct aes_regwrite *regs,
-                     const struct aes_regwrite *regs,
+	unsigned int num_regs, aes_write_regv_cb callback, void *user_data);
-                     unsigned int               num_regs,
-                     aes_write_regv_cb          callback,
-                     void                      *user_data);
 
 unsigned char aes_get_pixel(struct fpi_frame_asmbl_ctx *ctx,
 			    struct fpi_frame *frame,
 			    unsigned int x,
 			    unsigned int y);
+
+#endif
+

libfprint/drivers/aesx660.h

@@ -17,7 +17,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
+#ifndef __AESX660_H
+#define __AESX660_H
 
 #define AESX660_HEADER_SIZE 3
 #define AESX660_RESPONSE_TYPE_OFFSET 0x00
@@ -42,32 +43,37 @@
 
 #define AESX660_FRAME_HEIGHT 8
 
-G_DECLARE_DERIVABLE_TYPE (FpiDeviceAesX660, fpi_device_aes_x660, FPI,
+struct aesX660_dev {
-                          DEVICE_AES_X660, FpImageDevice)
+	GSList *strips;
-
+	size_t strips_len;
-#define FPI_TYPE_DEVICE_AES_X660 (fpi_device_aes_x660_get_type ())
+	gboolean deactivating;
-
+	struct aesX660_cmd *init_seq;
-struct _FpiDeviceAesX660Class
+	size_t init_seq_len;
-{
+	unsigned int init_cmd_idx;
-  FpImageDeviceClass          parent;
+	unsigned int init_seq_idx;
+	struct libusb_transfer *fd_data_transfer;
+	unsigned char *buffer;
+	size_t buffer_size;
+	size_t buffer_max;
 
+	/* Device-specific stuff */
 	struct aesX660_cmd *init_seqs[2];
-  gsize                       init_seqs_len[2];
+	size_t init_seqs_len[2];
-  guint8                     *start_imaging_cmd;
+	unsigned char *start_imaging_cmd;
-  gsize                       start_imaging_cmd_len;
+	size_t start_imaging_cmd_len;
 	struct fpi_frame_asmbl_ctx *assembling_ctx;
+	uint16_t extra_img_flags;
 };
 
-struct aesX660_cmd
+struct aesX660_cmd {
-{
+	const unsigned char *cmd;
-  const guint8 *cmd;
+	size_t len;
-  gsize         len;
 };
 
 /* 0x77 cmd seems to control LED, this sequence
  * makes LED blink
  */
-static const guint8 led_blink_cmd[] = {
+static const unsigned char led_blink_cmd[] = {
 0x77, 0x18, 0x00,
 0x00, 0x3f, 0x00, 0xff, 0x00,
 0x01, 0x01, 0x00, 0x00, 0x00, 0xf3, 0x01, 0x00,
@@ -77,35 +83,40 @@ static const guint8 led_blink_cmd[] = {
 
 /* This sequence makes LED light solid
  */
-static const guint8 led_solid_cmd[] = {
+static const unsigned char led_solid_cmd[] = {
 0x77, 0x18, 0x00, 0x00, 0x3f, 0x00, 0xff, 0x00,
 0x01, 0x01, 0x00, 0x00, 0x00, 0xe7, 0x03, 0x00,
 0x00, 0x00, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00,
 0x00, 0x00, 0x7f
 };
 
-static const guint8 wait_for_finger_cmd[] = {
+static const unsigned char wait_for_finger_cmd[] = {
 0x20,
 0x40, 0x04, 0x00, 0x02, 0x1e, 0x00, 0x32
 };
 
 /* 0x40 cmd response
  *
-   static const guint8 pkt1371[] = {
+static const unsigned char pkt1371[] = {
 0x40, 0x01, 0x00, 0x01
 };
 */
 
-static const guint8 set_idle_cmd[] = {
+static const unsigned char set_idle_cmd[] = {
 	0x0d, /* Reset or "set idle"? */
 };
 
-static const guint8 read_id_cmd[] = {
+static const unsigned char read_id_cmd[] = {
 	0x44, 0x02, 0x00, 0x08, 0x00, /* Max transfer size is 8 */
 	0x07, /* Read ID? */
 };
 
-static const guint8 calibrate_cmd[] = {
+static const unsigned char calibrate_cmd[] = {
 	0x44, 0x02, 0x00, 0x04, 0x00,
 	0x06,
 };
+
+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,7 +1,6 @@
 /*
- * Example fingerprint device prints listing and deletion
+ * Driver IDs
- * Enrolls your right index finger and saves the print to disk
+ * Copyright (C) 2012 Vasily Khoruzhick <anarsoul@gmail.com>
- * Copyright (C) 2019 Marco Trevisan <marco.trevisan@canonical.com>
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
@@ -18,18 +17,32 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
+#ifndef __DRIVER_IDS
+#define __DRIVER_IDS
 
-#pragma GCC diagnostic push
+enum {
-#pragma GCC diagnostic ignored "-Wredundant-decls"
+	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,
+	SYNAPTICS_ID	= 22,
+};
 
-#include <bozorth.h>
+#endif
-#include <bz_array.h>
-#include <defs.h>
-#include <lfs.h>
-#include <log.h>
-#include <morph.h>
-#include <mytime.h>
-#include <sunrast.h>
-
-#pragma GCC diagnostic pop

libfprint/drivers/elan.h

@@ -18,9 +18,10 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
+#ifndef __ELAN_H
+#define __ELAN_H
 
-#include <glib.h>
+#include <libusb.h>
 
 #define ELAN_VEND_ID 0x04f3
 
@@ -58,9 +59,9 @@
 #define ELAN_SKIP_LAST_FRAMES 2
 
 #define ELAN_CMD_LEN 0x2
-#define ELAN_EP_CMD_OUT (0x1 | FPI_USB_ENDPOINT_OUT)
+#define ELAN_EP_CMD_OUT (0x1 | LIBUSB_ENDPOINT_OUT)
-#define ELAN_EP_CMD_IN (0x3 | FPI_USB_ENDPOINT_IN)
+#define ELAN_EP_CMD_IN (0x3 | LIBUSB_ENDPOINT_IN)
-#define ELAN_EP_IMG_IN (0x2 | FPI_USB_ENDPOINT_IN)
+#define ELAN_EP_IMG_IN (0x2 | LIBUSB_ENDPOINT_IN)
 
 /* used as response length to tell the driver to skip reading response */
 #define ELAN_CMD_SKIP_READ 0
@@ -70,13 +71,11 @@
 #define ELAN_CMD_TIMEOUT 10000
 #define ELAN_FINGER_TIMEOUT 200
 
-struct elan_cmd
+struct elan_cmd {
-{
 	unsigned char cmd[ELAN_CMD_LEN];
 	int response_len;
 	int response_in;
 	unsigned short devices;
-  gboolean       never_cancel;
 };
 
 static const struct elan_cmd get_sensor_dim_cmd = {
@@ -153,73 +152,73 @@ static const struct elan_cmd stop_cmd = {
 	.response_len = ELAN_CMD_SKIP_READ,
 	.response_in = ELAN_EP_CMD_IN,
 	.devices = ELAN_ALL_DEV,
-  .never_cancel = TRUE,
 };
 
-static const FpIdEntry elan_id_table[] = {
+static const struct usb_id elan_id_table[] = {
-  {.vid = ELAN_VEND_ID,  .pid = 0x0903, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0903,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0907, .driver_data = ELAN_0907},
+	{.vendor = ELAN_VEND_ID,.product = 0x0907,.driver_data = ELAN_0907},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c01, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c01,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c02, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c02,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c03, .driver_data = ELAN_0C03},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c03,.driver_data = ELAN_0C03},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c04, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c04,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c05, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c05,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c06, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c06,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c07, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c07,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c08, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c08,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c09, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c09,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c0a, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c0a,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c0b, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c0b,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c0c, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c0c,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c0d, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c0d,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c0e, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c0e,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c0f, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c0f,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c10, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c10,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c11, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c11,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c12, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c12,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c13, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c13,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c14, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c14,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c15, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c15,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c16, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c16,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c17, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c17,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c18, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c18,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c19, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c19,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c1a, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c1a,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c1b, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c1b,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c1c, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c1c,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c1d, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c1d,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c1e, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c1e,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c1f, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c1f,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c20, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c20,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c21, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c21,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c22, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c22,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c23, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c23,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c24, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c24,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c25, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c25,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c26, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c26,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c27, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c27,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c28, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c28,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c29, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c29,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c2a, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c2a,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c2b, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c2b,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c2c, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c2c,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c2d, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c2d,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c2e, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c2e,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c2f, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c2f,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c30, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c30,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c31, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c31,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c32, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c32,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c33, .driver_data = ELAN_ALL_DEV},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c33,.driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c42, .driver_data = ELAN_0C42},
+	{.vendor = ELAN_VEND_ID,.product = 0x0c42,.driver_data = ELAN_0C42},
-  {.vid = 0,  .pid = 0,  .driver_data = 0},
+	{0, 0, 0,},
 };
 
-static void elan_cmd_done (FpiSsm *ssm);
+static void elan_cmd_done(fpi_ssm *ssm);
-static void elan_cmd_read (FpiSsm   *ssm,
+static void elan_cmd_read(fpi_ssm *ssm, struct fp_img_dev *dev);
-                           FpDevice *dev);
 
-static void elan_calibrate (FpDevice *dev);
+static void elan_calibrate(struct fp_img_dev *dev);
-static void elan_capture (FpDevice *dev);
+static void elan_capture(struct fp_img_dev *dev);
+static void elan_deactivate(struct fp_img_dev *dev);
 
-static void dev_change_state (FpImageDevice      *dev,
+static int dev_change_state(struct fp_img_dev *dev, enum fp_imgdev_state state);
-                              FpiImageDeviceState state);
+
+#endif

libfprint/drivers/fdu2000.c

@@ -0,0 +1,318 @@
+/*
+ * 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 = {
+		.id = FDU2000_ID,
+		.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/synaptics/bmkt.c

@@ -0,0 +1,260 @@
+/*
+ * Copyright (C) 2019 Synaptics Inc
+ *
+ * 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 "bmkt_internal.h"
+#include "bmkt_message.h"
+#include "sensor.h"
+
+struct bmkt_ctx
+{
+	bmkt_sensor_t sensor;
+};
+
+bmkt_ctx_t g_ctx;
+
+int bmkt_init(bmkt_ctx_t **ctx)
+{
+	if (ctx == NULL)
+	{
+		return BMKT_INVALID_PARAM;
+	}
+
+	memset(&g_ctx, 0, sizeof(bmkt_ctx_t));
+	*ctx = &g_ctx;
+
+	bmkt_dbg_log("%s: context size: %ld", __func__, sizeof(bmkt_ctx_t));
+	return BMKT_SUCCESS;
+}
+
+void bmkt_exit(bmkt_ctx_t *ctx)
+{
+
+	if (ctx == NULL)
+	{
+		return;
+	}
+}
+
+int bmkt_open(bmkt_ctx_t *ctx, bmkt_sensor_t **sensor,
+				bmkt_general_error_cb_t err_cb, void *err_cb_ctx, libusb_device_handle *usb_handle)
+{
+	int ret;
+
+	if (ctx == NULL || sensor == NULL)
+	{
+		return BMKT_INVALID_PARAM;
+	}
+
+	*sensor = &ctx->sensor;
+
+	memset(*sensor, 0, sizeof(bmkt_sensor_t));
+
+	(*sensor)->usb_xport.handle = usb_handle;
+
+	ret = bmkt_sensor_open(*sensor, err_cb, err_cb_ctx);
+	if (ret != BMKT_SUCCESS)
+	{
+		return ret;
+	}
+
+	return BMKT_SUCCESS;
+}
+
+int bmkt_init_fps(bmkt_sensor_t *sensor)
+{
+	int ret;
+	uint8_t *resp_buf;
+	int resp_len;
+	bmkt_response_t resp;
+
+	if (sensor->sensor_state != BMKT_SENSOR_STATE_UNINIT)
+    {
+        //sensor is already initialized
+        return BMKT_OPERATION_DENIED;
+    }
+	ret = bmkt_sensor_send_message_sync(sensor, BMKT_CMD_FPS_INIT, 0, NULL, &resp_buf, &resp_len, &resp);
+	if (ret != BMKT_SUCCESS)
+	{
+		return ret;
+	}
+
+	if (resp.result != BMKT_SUCCESS)
+	{
+		return resp.result;
+	}
+
+	return bmkt_sensor_init_fps(sensor);
+}
+
+int bmkt_close(bmkt_sensor_t *sensor)
+{
+	if (sensor == NULL)
+	{
+		return BMKT_INVALID_PARAM;
+	}
+
+	return bmkt_sensor_close(sensor);
+}
+
+
+int bmkt_delete_enrolled_user(bmkt_sensor_t *sensor, uint8_t finger_id, const char *user_id, uint32_t user_id_len, 
+                            bmkt_resp_cb_t resp_cb, void *cb_ctx)
+{
+	int ret;
+	uint8_t payload[BMKT_MAX_USER_ID_LEN + sizeof(finger_id)];
+	uint8_t payload_len;
+
+	if (sensor == NULL)
+	{
+		return BMKT_INVALID_PARAM;
+	}
+
+	if (user_id_len > BMKT_MAX_USER_ID_LEN)
+	{
+		return BMKT_INVALID_PARAM;
+	}
+
+	memset(payload, 0, sizeof(payload));
+	payload_len = user_id_len + sizeof(finger_id);
+	payload[0] = finger_id;
+	memcpy(&payload[1], user_id, user_id_len);
+
+	ret = bmkt_sensor_send_message(sensor, BMKT_CMD_DEL_USER_FP, payload_len, payload, resp_cb, cb_ctx);
+	if (ret != BMKT_SUCCESS)
+	{
+		return ret;
+	}
+
+	return BMKT_SUCCESS;
+}
+
+int bmkt_enroll(bmkt_sensor_t *sensor, const uint8_t *user_id, uint32_t user_id_len,
+				uint8_t finger_id, bmkt_resp_cb_t resp_cb, void *cb_ctx)
+{
+	int ret = BMKT_GENERAL_ERROR;
+	/* Payload data for enroll_user [1 byte<backup option> 1 byte<finger Id> maximum length: 100 bytes]*/
+	uint8_t payload[BMKT_MAX_USER_ID_LEN + 2];
+	uint8_t payload_len = 0;
+	/* Backup options is not supported for Prometheus. */
+	uint8_t backup_opt	= 0;
+
+	if (sensor == NULL || user_id == NULL)
+	{
+		return BMKT_INVALID_PARAM;
+	}
+
+	if (user_id_len > BMKT_MAX_USER_ID_LEN)
+	{
+		return BMKT_INVALID_PARAM;
+	}
+
+	payload_len = user_id_len + 2;
+	payload[0] = backup_opt;
+	payload[1] = finger_id;
+	memcpy(&payload[2], user_id, user_id_len);
+
+	ret = bmkt_sensor_send_message(sensor, BMKT_CMD_ENROLL_USER, payload_len, payload, resp_cb, cb_ctx);
+	if (ret != BMKT_SUCCESS)
+	{
+		return ret;
+	}
+
+	return BMKT_SUCCESS;
+}
+
+
+int bmkt_verify(bmkt_sensor_t *sensor, bmkt_user_id_t *user, 
+	bmkt_resp_cb_t resp_cb, void *cb_ctx)
+{
+	int ret;
+	uint8_t payload[BMKT_MAX_USER_ID_LEN + 1];
+	uint8_t payload_len;
+
+	if (sensor == NULL || user == NULL || user->user_id == NULL)
+	{
+		return BMKT_INVALID_PARAM;
+	}
+
+	if (user->user_id_len == 0 || user->user_id_len > BMKT_MAX_USER_ID_LEN)
+	{
+		return BMKT_INVALID_PARAM;
+	}
+
+	payload_len = user->user_id_len;
+	memset(payload, 0, sizeof(payload));
+	memcpy(&payload[0], user->user_id, user->user_id_len);
+
+	ret = bmkt_sensor_send_message(sensor, BMKT_CMD_VERIFY_USER, payload_len, payload, resp_cb,
+				cb_ctx);
+	if (ret != BMKT_SUCCESS)
+	{
+		return ret;
+	}
+
+	return BMKT_SUCCESS;
+}
+
+void bmkt_op_set_state(bmkt_sensor_t* sensor, bmkt_op_state_t state)
+{
+	sensor->op_state = state;
+}
+
+void bmkt_op_sm(bmkt_sensor_t *sensor)
+{
+	int ret;
+	int len = 0;
+	bmkt_dbg_log("bmkt_op_sm state = %d", sensor->op_state);
+	switch(sensor->op_state)
+	{
+		case BMKT_OP_STATE_GET_RESP:
+			ret = usb_receive_resp_async(&sensor->usb_xport, &len);
+			if (ret != BMKT_SUCCESS)
+			{
+				bmkt_dbg_log("bmkt_op_sm: usb_receive_resp_async failed %d", ret);
+			}
+			break;
+		case BMKT_OP_STATE_WAIT_INTERRUPT:
+			ret = usb_check_interrupt(&sensor->usb_xport);
+			if (ret != BMKT_SUCCESS)
+			{
+				bmkt_dbg_log("bmkt_op_sm: check_interrupt failed %d", ret);
+			}
+			break;
+		case BMKT_OP_STATE_SEND_ASYNC:
+			ret = bmkt_sensor_send_async_read_command(sensor);
+			if (ret != BMKT_SUCCESS)
+			{
+				bmkt_dbg_log("bmkt_op_sm: bmkt_sensor_send_async_read_command failed %d", ret);
+			}
+			break;
+		case BMKT_OP_STATE_COMPLETE:
+			break;
+		default:
+			break;
+	}
+}
+
+void bmkt_op_next_state(bmkt_sensor_t* sensor)
+{
+	if(sensor->op_state != BMKT_OP_STATE_COMPLETE)
+		sensor->op_state = (sensor->op_state + 1) % BMKT_OP_STATE_COMPLETE;
+	bmkt_op_sm(sensor);
+}
+
+
+

libfprint/drivers/synaptics/bmkt.h

@@ -17,7 +17,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
+#ifndef _BMKT_H_
+#define _BMKT_H_
 
 /**< User ID maximum length allowed */
 #define BMKT_MAX_USER_ID_LEN                    100
@@ -30,6 +31,7 @@
 #define BMKT_MAX_NUM_TEMPLATES_INTERNAL_FLASH   15
 
 #include <stdint.h>
+#include "libusb-1.0/libusb.h"
 #include "bmkt_response.h"
 
 /*!
@@ -131,7 +133,8 @@ extern "C" {
 * bmkt_mode:
 * Fingerprint system operational mode values level 1
 */
-typedef enum bmkt_mode {
+typedef enum bmkt_mode
+{
 	BMKT_STATE_UNINIT    = 0xFF,
 	BMKT_STATE_IDLE      = 0x00,
 	BMKT_STATE_ENROLL    = 0x10,
@@ -146,7 +149,8 @@ typedef enum bmkt_mode {
 * bmkt_mode_level2:
 * Fingerprint system operational mode values level 2
 */
-typedef enum bmkt_mode_level2 {
+typedef enum bmkt_mode_level2
+{
 	BMKT_STATE_L2_IDLE                  = 0x00,
 	BMKT_STATE_L2_STARTING              = 0x11,
 	BMKT_STATE_L2_WAITING_FOR_FINGER    = 0x12,
@@ -167,7 +171,8 @@ typedef enum bmkt_mode_level2 {
 * bmkt_transport_type:
 * Fingerprint system transport types
 */
-typedef enum bmkt_transport_type {
+typedef enum bmkt_transport_type
+{
 	BMKT_TRANSPORT_TYPE_USB = 0,
 } bmkt_transport_type_t;
 
@@ -203,7 +208,8 @@ typedef struct bmkt_sensor_desc
 * bmkt_finger_state_t:
 * Finger state representation values.
 */
-typedef enum {
+typedef enum
+{
 	BMKT_FINGER_STATE_UNKNOWN    = 0,
 	BMKT_FINGER_STATE_ON_SENSOR,
 	BMKT_FINGER_STATE_NOT_ON_SENSOR,
@@ -224,6 +230,223 @@ typedef struct bmkt_user_id
 	uint8_t      user_id[BMKT_MAX_USER_ID_LEN];
 } bmkt_user_id_t;
 
+typedef struct bmkt_ctx bmkt_ctx_t;
+typedef struct bmkt_sensor bmkt_sensor_t;
+typedef struct bmkt_sensor_desc bmkt_sensor_desc_t;
+typedef struct bmkt_event bmkt_event_t;
+
+typedef int (*bmkt_resp_cb_t)(bmkt_response_t *resp, void *cb_ctx);
+typedef int (*bmkt_event_cb_t)(bmkt_finger_event_t *event, void *cb_ctx);
+typedef int (*bmkt_general_error_cb_t)(uint16_t error, void *cb_ctx);
+
+/**
+* bmkt_init:
+* @brief      Initialize the bmkt library.
+*
+* @param[out] ctx  A double pointer to return the created library module context pointer.
+*
+* @return     BMKT_SUCCESS
+*             BMKT_INVALID_PARAM
+*
+* The bmkt_init function must be invoked to intialize the bmkt library before calling other functions. 
+* The library module context pointer is returned, which must be passed to all other library interface functions.
+*/
+int
+bmkt_init(
+	bmkt_ctx_t **   ctx);
+
+/**
+* bmkt_exit:
+* @brief      Uninitialize the bmkt library.
+*
+* @param[in]  ctx Context pointer created by bmkt_init.
+*
+* @return     none
+*
+* The bmkt_exit function must be invoked when the module is no longer needed.
+*/
+
+void
+bmkt_exit(
+	bmkt_ctx_t *    ctx);
+
+/**
+* bmkt_open:
+* @brief      Open the specified sensor module.
+*
+* @param[in]  ctx           Context pointer created by bmkt_init.
+* @param[out] sensor        A double pointer to return the created sensor module pointer
+* @param[in]  err_cb        General Error callback function
+* @param[in]  err_cb_ctx    General Error callback user context
+*
+* @return     VCS_RESULT_OK if success
+*
+* The bmkt_open function must be called to open a specific sensor module. Returned sensor module pointer
+* must be passed to all other interface functions that expect a sensor pointer.
+*/
+
+int
+bmkt_open(
+	bmkt_ctx_t *                ctx, 
+	bmkt_sensor_t **            sensor,
+	bmkt_general_error_cb_t     err_cb, 
+	void *                      err_cb_ctx,
+	libusb_device_handle *		handle);
+
+/**
+* bmkt_close:
+* @brief      Close the specified sensor module, and release all the resources
+*
+* @param[in]  sensor  The sensor module pointer
+*
+* @return     VCS_RESULT_OK if success
+*
+* The bmkt_close function must be invoked when the sensor module is no longer needed.
+*/
+int
+bmkt_close(
+	bmkt_sensor_t *     sensor);
+
+/**
+* bmkt_init_fps:
+* @brief      Initialize the sensor module.
+*
+* @param[in]  sensor  The sensor module pointer
+*
+* @return     VCS_RESULT_OK if success
+*
+* Initializes the fingerprint sensor module. Must be the first command to be issued to the fingerprint sensor module, before any other commands are issued.
+*/
+int
+bmkt_init_fps(
+	bmkt_sensor_t *     sensor);
+
+/**
+* bmkt_enroll:
+* @brief      Put the fingerprint sensor module into enrollment mode to Enroll a user’s fingerprint into the system.
+*
+* @param[in]  sensor        The sensor module pointer
+* @param[in]  user_id       Enrolled User ID
+* @param[in]  user_id_len   Enrolled User ID lenght
+* @param[in]  finger_id     Enrolled finger ID
+* @param[in]  resp_cb       Responce callback function. Available responses:
+*                           - BMKT_RSP_ENROLL_READY
+*                           - BMKT_RSP_CAPTURE_COMPLETE
+*                           - BMKT_RSP_ENROLL_REPORT
+*                           - BMKT_RSP_ENROLL_PAUSED
+*                           - BMKT_RSP_ENROLL_RESUMED
+*                           - BMKT_RSP_ENROLL_FAIL
+*                           - BMKT_RSP_ENROLL_OK
+
+* @param[in]  cb_ctx        Responce callback user context
+*
+* @return     VCS_RESULT_OK if success
+*
+* Enrolled users have to touch the fingerprint sensor multiple times based on cues provided by the system.
+* After successful enrollment, a template is generated from features of the user’s fingerprint and stored
+* in encrypted storage within the fingerprint sensor module.
+* When this command is being executed, fingerprint sensor module’s mode is: Enrollment
+*/
+int
+bmkt_enroll(
+	bmkt_sensor_t *     sensor, 
+	const uint8_t *     user_id, 
+	uint32_t            user_id_len,
+	uint8_t             finger_id, 
+	bmkt_resp_cb_t      resp_cb, 
+	void *              cb_ctx);
+
+/**
+* bmkt_verify:
+* @brief      Put the fingerprint sensor module into verification mode.
+*
+* @param[in]  sensor        The sensor module pointer
+* @param[in]  user          Enrolled User
+* @param[in]  resp_cb       Responce callback function. Available responses:
+*                           - BMKT_RSP_CAPTURE_COMPLETE
+*                           - BMKT_RSP_VERIFY_READY
+*                           - BMKT_RSP_VERIFY_FAIL
+*                           - BMKT_RSP_VERIFY_OK
+* @param[in]  cb_ctx        Responce callback user context
+*
+* @return     VCS_RESULT_OK if success
+*
+* The user being verifyed has to touch the fingerprint sensor once based on a cue provided by the system.
+* The Captured fingerprint is matched only against the stored templates corresponding to specifyed user ID,
+* If a user’s fingerprint cannot be matched to any of the stored fingerprint templates of the specified user or
+* if the fingerprint sensor module detects that the fingerprint being presented to the sensor is a spoof, 
+* then an error response is generated.
+* When this command is being executed, fingerprint sensor module’s mode is: Verification
+*/
+int
+bmkt_verify(
+	bmkt_sensor_t *     sensor,
+	bmkt_user_id_t*     user,
+	bmkt_resp_cb_t      resp_cb,
+	void *              cb_ctx);
+
+
+/**
+* bmkt_delete_enrolled_user:
+* @brief      Delete a specific fingerprint template of an enrolled user from the database.
+*
+* @param[in]  sensor        The sensor module pointer
+* @param[in]  finger_id     Finger ID to be deleted 
+* @param[in]  user_id       User ID to be deleted
+* @param[in]  user_id_len   User ID lenght
+* @param[in]  resp_cb       Responce callback function. Available responses:
+*                           - BMKT_RSP_DEL_USER_FP_FAIL
+*                           - BMKT_RSP_DEL_USER_FP_OK
+* @param[in]  cb_ctx        Responce callback user context
+*
+* @return     VCS_RESULT_OK if success
+*
+* If the value of finger ID is set equal to 0 then all fingerprints of that user will be deleted from the database.
+* If the value of user ID is set to an empty string (string with length 0) and the finger ID is set equal to 0 then 
+* all templates stored in the fingerprint database which are marked as corrupt will be deleted.
+* When this command is being executed, fingerprint sensor module’s mode is: Database operations
+*/
+int
+bmkt_delete_enrolled_user(
+	bmkt_sensor_t *     sensor,
+	uint8_t             finger_id,
+	const char *        user_id,
+	uint32_t            user_id_len,
+	bmkt_resp_cb_t      resp_cb,
+	void *              cb_ctx);
+
+
+/**
+* bmkt_register_finger_event_notification:
+* @brief      Register finger presence event callback function
+*
+* @param[in]  sensor    The sensor module pointer
+* @param[in]  cb        Event callback function
+* @param[in]  cb_ctx    Event callback user context
+*
+* @return     VCS_RESULT_OK if success
+*
+* The registered callback function will be called whenever a finger is detected as being placed on the sensor or removed from the sensor.
+*/
+int
+bmkt_register_finger_event_notification(
+	bmkt_sensor_t *     sensor, 
+	bmkt_event_cb_t     cb, 
+	void *              cb_ctx);
+
+
+typedef enum
+{
+	BMKT_OP_STATE_START    = -1,
+	BMKT_OP_STATE_GET_RESP,
+	BMKT_OP_STATE_WAIT_INTERRUPT,
+	BMKT_OP_STATE_SEND_ASYNC,
+	BMKT_OP_STATE_COMPLETE,
+} bmkt_op_state_t;
+void bmkt_op_set_state(bmkt_sensor_t* sensor, bmkt_op_state_t state);
+
 #ifdef __cplusplus
 }
 #endif
+
+#endif /* _BMKT_H_ */

libfprint/drivers/synaptics/bmkt_internal.h

@@ -1,7 +1,5 @@
 /*
- * FPrint Print handling
+ * Copyright (C) 2019 Synaptics Inc
- * Copyright (C) 2007 Daniel Drake <dsd@gentoo.org>
- * 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
@@ -18,29 +16,29 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "fpi-print.h"
+#ifndef _BMKT_INTERNAL_H_
-#include "fpi-image.h"
+#define _BMKT_INTERNAL_H_
 
-#include <nbis.h>
+#include "bmkt.h"
+#include "bmkt_message.h"
+#include <time.h>
+#include <errno.h>
+#include <stdarg.h>
+#include <string.h>
+#include <stdio.h>
+#include "fp_internal.h"
 
-struct _FpPrint
+uint32_t extract32(const uint8_t *buf, int *offset);
-{
+uint16_t extract16(const uint8_t *buf, int *offset);
-  GInitiallyUnowned parent_instance;
+uint8_t extract8(const uint8_t *buf, int *offset);
+void print_buffer(uint8_t *buf, int len);
 
-  FpiPrintType      type;
 
-  gchar            *driver;
+#define bmkt_dbg_log	fp_dbg
-  gchar            *device_id;
+#define bmkt_info_log	fp_info
-  gboolean          device_stored;
+#define bmkt_warn_log	fp_warn
+#define bmkt_err_log	fp_err
 
-  FpImage          *image;
+void bmkt_op_next_state(bmkt_sensor_t *sensor);
 
-  /* Metadata */
+#endif /* _BMKT_INTERNAL_H_ */
-  FpFinger   finger;
-  gchar     *username;
-  gchar     *description;
-  GDate     *enroll_date;
-
-  GVariant  *data;
-  GPtrArray *prints;
-};

libfprint/drivers/synaptics/bmkt_message.c

@@ -16,46 +16,32 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include <glib.h>
+#include "bmkt_internal.h"
 #include "bmkt_response.h"
 #include "bmkt_message.h"
+#include "usb_transport.h"
+#include "sensor.h"
 
-static uint8_t
+static int parse_error_response(bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
-extract8 (const uint8_t *buf, int *offset)
-{
-  uint8_t ret = 0;
-  int off = 0;
-
-  if (offset)
-    off = *offset;
-
-  ret = *(buf + off);
-
-  if (offset)
-    *offset += 1;
-
-  return ret;
-}
-
-
-static int
-parse_error_response (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 {
 	if (msg_resp->payload_len != 2)
+	{
 		return BMKT_UNRECOGNIZED_MESSAGE;
+	}
 
 	resp->result = (msg_resp->payload[0] << 8) | msg_resp->payload[1];
 
 	return BMKT_SUCCESS;
 }
 
-static int
+static int parse_init_ok(bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
-parse_init_ok (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 {
 	bmkt_init_resp_t *init_resp = &resp->response.init_resp;
 
 	if (msg_resp->payload_len != 1)
+	{
 		return BMKT_UNRECOGNIZED_MESSAGE;
+	}
 
 	init_resp->finger_presence = extract8(msg_resp->payload, NULL);
 
@@ -63,14 +49,15 @@ parse_init_ok (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 }
 
 
-static int
+static int parse_fps_mode_report(bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
-parse_fps_mode_report (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 {
 	int offset = 0;
 	bmkt_fps_mode_resp_t *fps_mode_resp = &resp->response.fps_mode_resp;
 
 	if (msg_resp->payload_len != sizeof(bmkt_fps_mode_resp_t))
+	{
 		return BMKT_UNRECOGNIZED_MESSAGE;
+	}
 
 	fps_mode_resp->mode = extract8(msg_resp->payload, &offset);
 	fps_mode_resp->level2_mode = extract8(msg_resp->payload, &offset);
@@ -80,26 +67,28 @@ parse_fps_mode_report (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 	return BMKT_SUCCESS;
 }
 
-static int
+static int parse_enroll_report(bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
-parse_enroll_report (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 {
 	bmkt_enroll_resp_t *enroll_resp = &resp->response.enroll_resp;
 
 	if (msg_resp->payload_len != 1)
+	{
 		return BMKT_UNRECOGNIZED_MESSAGE;
+	}
 
 	enroll_resp->progress = extract8(msg_resp->payload, NULL);
 
 	return BMKT_SUCCESS;
 }
 
-static int
+static int parse_enroll_ok(bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
-parse_enroll_ok (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 {
 	bmkt_enroll_resp_t *enroll_resp = &resp->response.enroll_resp;
 
 	if (msg_resp->payload_len < 1 || msg_resp->payload_len > (BMKT_MAX_USER_ID_LEN + 1))
+	{
 		return BMKT_UNRECOGNIZED_MESSAGE;
+	}
 
 	enroll_resp->finger_id = msg_resp->payload[0];
 	memcpy(enroll_resp->user_id, &msg_resp->payload[1], msg_resp->payload_len - 1);
@@ -107,13 +96,14 @@ parse_enroll_ok (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 	return BMKT_SUCCESS;
 }
 
-static int
+static int parse_auth_ok(bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
-parse_auth_ok (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 {
 	bmkt_identify_resp_t *id_resp = &resp->response.id_resp;
 
 	if (msg_resp->payload_len < 3 || msg_resp->payload_len > (BMKT_MAX_USER_ID_LEN + 3))
+	{
 		return BMKT_UNRECOGNIZED_MESSAGE;
+	}
 
 	id_resp->match_result = (double)msg_resp->payload[0] + 0.01 * (double)msg_resp->payload[1];
 	id_resp->finger_id = msg_resp->payload[2];
@@ -122,40 +112,43 @@ parse_auth_ok (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 	return BMKT_SUCCESS;
 }
 
-static int
+static int parse_security_level_report(bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
-parse_security_level_report (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 {
 	bmkt_set_sec_level_resp_t *sec_level_resp = &resp->response.sec_level_resp;
 
 	if (msg_resp->payload_len != 1)
+	{
 		return BMKT_UNRECOGNIZED_MESSAGE;
+	}
 
 	sec_level_resp->sec_level = extract8(msg_resp->payload, NULL);
 
 	return BMKT_SUCCESS;
 }
 
-static int
+static int parse_del_all_users_progress_report(bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
-parse_del_all_users_progress_report (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 {
 	bmkt_del_all_users_resp_t *del_all_users_resp = &resp->response.del_all_users_resp;
 
 	if (msg_resp->payload_len != 1)
+	{
 		return BMKT_UNRECOGNIZED_MESSAGE;
+	}
 
 	del_all_users_resp->progress = extract8(msg_resp->payload, NULL);
 
 	return BMKT_SUCCESS;
 }
 
-static int
+static int parse_db_cap_report(bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
-parse_db_cap_report (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 {
 	bmkt_get_db_capacity_resp_t *db_cap_resp = &resp->response.db_cap_resp;
 	int offset = 0;
 
 	if (msg_resp->payload_len < 2 || msg_resp->payload_len > 4)
+	{
 		return BMKT_UNRECOGNIZED_MESSAGE;
+	}
 
 	db_cap_resp->total = extract8(msg_resp->payload, &offset);
 	db_cap_resp->empty = extract8(msg_resp->payload, &offset);
@@ -169,14 +162,15 @@ parse_db_cap_report (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 	return BMKT_SUCCESS;
 }
 
-static int
+static int parse_get_enrolled_fingers_report(bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
-parse_get_enrolled_fingers_report (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 {
 	int offset = 0;
 	int i = 0;
 
 	if (msg_resp->payload_len < 2)
+	{
 		 return BMKT_UNRECOGNIZED_MESSAGE;
+	}
 	/* 2 bytes per finger so calculate the total number of fingers to process*/
 	int num_fingers = (msg_resp->payload_len) / 2;
 
@@ -190,15 +184,16 @@ parse_get_enrolled_fingers_report (bmkt_msg_resp_t *msg_resp, bmkt_response_t *r
 	}
 	return BMKT_SUCCESS;
 }
-static int
+static int parse_get_enrolled_users_report(bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
-parse_get_enrolled_users_report (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 {
 	int offset = 0;
 	int i = 0;
 
 	/* the payload is 2 bytes + template data */
 	if (msg_resp->payload_len < 2)
+	{
 		return BMKT_UNRECOGNIZED_MESSAGE;
+	}
 	
 	bmkt_enroll_templates_resp_t *get_enroll_templates_resp = &resp->response.enroll_templates_resp;
 
@@ -206,32 +201,36 @@ parse_get_enrolled_users_report (bmkt_msg_resp_t *msg_resp, bmkt_response_t *res
 	get_enroll_templates_resp->query_sequence = extract8(msg_resp->payload, &offset);
 
 	int n = 0;
-
 	for (n = 0; n < BMKT_MAX_NUM_TEMPLATES_INTERNAL_FLASH; n++)
 	{
 		if (offset >= msg_resp->payload_len)
 			break;
 		get_enroll_templates_resp->templates[n].user_id_len = extract8(msg_resp->payload, &offset) - 2;
 		if(get_enroll_templates_resp->templates[n].user_id_len > BMKT_MAX_USER_ID_LEN)
+		{
 			return BMKT_UNRECOGNIZED_MESSAGE;
+		}
 		get_enroll_templates_resp->templates[n].template_status = extract8(msg_resp->payload, &offset);
 		get_enroll_templates_resp->templates[n].finger_id = extract8(msg_resp->payload, &offset);
 		for (i = 0; i < get_enroll_templates_resp->templates[n].user_id_len; i++)
+		{
 			get_enroll_templates_resp->templates[n].user_id[i] = extract8(msg_resp->payload, &offset);
+		}
 		get_enroll_templates_resp->templates[n].user_id[i] = '\0';
 	}
 
 	return BMKT_SUCCESS;
 }
 
-static int
+static int parse_get_version_report(bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
-parse_get_version_report (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 {
 	bmkt_get_version_resp_t *get_version_resp = &resp->response.get_version_resp;
 	int offset = 0;
 
 	if (msg_resp->payload_len != 15)
+	{
 		return BMKT_UNRECOGNIZED_MESSAGE;
+	}
 
 	memcpy(get_version_resp->part, msg_resp->payload, BMKT_PART_NUM_LEN);
 	offset += BMKT_PART_NUM_LEN;
@@ -243,14 +242,15 @@ parse_get_version_report (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 	return BMKT_SUCCESS;
 }
 
-int
+int bmkt_compose_message(uint8_t *cmd, int *cmd_len, uint8_t msg_id, uint8_t seq_num,
-bmkt_compose_message (uint8_t *cmd, int *cmd_len, uint8_t msg_id, uint8_t seq_num,
+						uint8_t payload_size, uint8_t *payload)
-                      uint8_t payload_size, const uint8_t *payload)
 {
 	int message_len = BMKT_MESSAGE_HEADER_LEN + payload_size;
 
 	if (*cmd_len < message_len)
+	{
 		return BMKT_OUT_OF_MEMORY;
+	}
 
 	cmd[BMKT_MESSAGE_HEADER_ID_FIELD] = BMKT_MESSAGE_HEADER_ID;
 	cmd[BMKT_MESSAGE_SEQ_NUM_FIELD] = seq_num;
@@ -263,25 +263,29 @@ bmkt_compose_message (uint8_t *cmd, int *cmd_len, uint8_t msg_id, uint8_t seq_nu
 	return BMKT_SUCCESS;
 }
 
-int
+int bmkt_parse_message_header(uint8_t *resp_buf, int resp_len, bmkt_msg_resp_t *msg_resp)
-bmkt_parse_message_header (uint8_t *resp_buf, int resp_len, bmkt_msg_resp_t *msg_resp)
 {
 	if (resp_buf[BMKT_MESSAGE_HEADER_ID_FIELD] != BMKT_MESSAGE_HEADER_ID)
+	{
 		return BMKT_CORRUPT_MESSAGE;
+	}
 
 	msg_resp->seq_num = resp_buf[BMKT_MESSAGE_SEQ_NUM_FIELD];
 	msg_resp->msg_id = resp_buf[BMKT_MESSAGE_ID_FIELD];
 	msg_resp->payload_len = resp_buf[BMKT_MESSAGE_PAYLOAD_LEN_FIELD];
 	if (msg_resp->payload_len > 0)
+	{
 		msg_resp->payload = &resp_buf[BMKT_MESSAGE_PAYLOAD_FIELD];
+	}
 	else
+	{
 		msg_resp->payload = NULL;
+	}
 
 	return BMKT_SUCCESS;
 }
 
-int
+int bmkt_parse_message_payload(bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
-bmkt_parse_message_payload (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 {
 	int ret = BMKT_SUCCESS;
 
@@ -368,21 +372,17 @@ bmkt_parse_message_payload (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 			ret = parse_auth_ok(msg_resp, resp);
 			resp->complete = 1;
 			break;
-
 		case BMKT_RSP_GET_ENROLLED_FINGERS_REPORT:
 			ret = parse_get_enrolled_fingers_report(msg_resp, resp);
 			resp->complete = 1;
 			break;
-
 		case BMKT_RSP_DATABASE_CAPACITY_REPORT:
 			resp->complete = 1;
 			ret = parse_db_cap_report(msg_resp, resp);
 			break;
-
 		case BMKT_RSP_TEMPLATE_RECORDS_REPORT:
 			ret = parse_get_enrolled_users_report(msg_resp, resp);           
 			break;	
-
 		case BMKT_RSP_QUERY_RESPONSE_COMPLETE:
 			resp->complete = 1;
 			break;
@@ -391,10 +391,6 @@ bmkt_parse_message_payload (bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp)
 			ret = parse_get_version_report(msg_resp, resp);
 			resp->complete = 1;
 			break;
-
-    case BMKT_RSP_POWER_DOWN_READY:
-      resp->complete = 1;
-      break;
 	}
 
 	return ret;

libfprint/drivers/synaptics/bmkt_message.h

@@ -16,7 +16,11 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
+
+#ifndef BMKT_MESSAGE_H_
+#define BMKT_MESSAGE_H_
+
+#include "bmkt_internal.h"
 
 #define BMKT_MESSAGE_HEADER_ID                      0xFE
 #define BMKT_MESSAGE_HEADER_LEN                     (4)
@@ -75,15 +79,16 @@ typedef struct bmkt_msg_resp
 	int result;
 } bmkt_msg_resp_t;
 
-int bmkt_compose_message (uint8_t       *cmd,
+typedef struct bmkt_session_ctx
-                          int           *cmd_len,
+{
-                          uint8_t        msg_id,
+	uint8_t seq_num;
-                          uint8_t        seq_num,
+	bmkt_resp_cb_t resp_cb;
-                          uint8_t        payload_size,
+	void *cb_ctx;
-                          const uint8_t *payload);
+} bmkt_session_ctx_t;
 
-int bmkt_parse_message_header (uint8_t         *resp_buf,
+int bmkt_compose_message(uint8_t *cmd, int *cmd_len, uint8_t msg_id, uint8_t seq_num,
-                               int              resp_len,
+				uint8_t payload_size, uint8_t *payload);
-                               bmkt_msg_resp_t *msg_resp);
+
-int bmkt_parse_message_payload (bmkt_msg_resp_t *msg_resp,
+int bmkt_parse_message_header(uint8_t *resp_buf, int resp_len, bmkt_msg_resp_t *msg_resp);
-                                bmkt_response_t *resp);
+int bmkt_parse_message_payload(bmkt_msg_resp_t *msg_resp, bmkt_response_t *resp);
+#endif /* BMKT_MESSAGE_H_ */

libfprint/drivers/synaptics/bmkt_response.h

@@ -17,9 +17,9 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
 
-#include "bmkt.h"
+#ifndef _BMKT_RESPONSE_H_
+#define _BMKT_RESPONSE_H_
 
 /** List of response message IDs */
 #define BMKT_RSP_CONTINUOUS_IMAGE_CAPTURE_FAIL    0x02
@@ -316,7 +316,7 @@ typedef struct bmkt_init_resp
 */
 typedef struct bmkt_enroll_resp
 {
-  int     progress;                             /**< Shows current progress status [0-100] */
+	int progress;                           /**< Shows current progress stutus [0-100] */
 	uint8_t finger_id;                      /**< User's finger id [1-10] */
 	uint8_t user_id[BMKT_MAX_USER_ID_LEN];  /**< User name to be enrolled */
 } bmkt_enroll_resp_t;
@@ -376,7 +376,8 @@ typedef struct bmkt_get_db_capacity_resp
 * bmkt_sec_level:
 * Security level values.
 */
-typedef enum bmkt_sec_level {
+typedef enum bmkt_sec_level
+{
 	BMKT_SECURITY_LEVEL_LOW     = 0x10,
 	BMKT_SECURITY_LEVEL_MEDIUM  = 0x40,
 	BMKT_SECURITY_LEVEL_HIGH    = 0x60,
@@ -455,8 +456,7 @@ typedef struct bmkt_enrolled_fingers_resp
 * bmkt_response_data_t:
 * Union combining all response payload data types.
 */
-typedef union
+typedef union {
-{
 	bmkt_init_resp_t init_resp;
 	bmkt_enroll_resp_t enroll_resp;
 	bmkt_verify_resp_t verify_resp;
@@ -483,3 +483,5 @@ typedef struct bmkt_response
 	int complete;                   /**< Operation completion status 1: complete / 0: not completed */
 	bmkt_response_data_t response;  /**< Operation specific response union */
 } bmkt_response_t;
+
+#endif /* _BMKT_RESPONSE_H_ */

libfprint/drivers/synaptics/sensor.c

@@ -0,0 +1,481 @@
+/*
+ * Copyright (C) 2019 Synaptics Inc
+ *
+ * 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 "bmkt_internal.h"
+#include "bmkt_message.h"
+#include "sensor.h"
+
+#define SENSOR_CMD_GET_VERSION				1
+#define SENSOR_CMD_ACE_COMMAND				167
+#define SENSOR_CMD_ASYNCMSG_READ			168
+
+#define SENSOR_FW_CMD_HEADER_LEN			1
+#define SENSOR_FW_REPLY_HEADER_LEN		2
+
+static int get_version(bmkt_sensor_t *sensor, bmkt_sensor_version_t *mis_version)
+{
+	int ret;
+	uint8_t *resp = NULL;
+	int resp_len = 40;
+	uint16_t status = 0;
+	uint8_t *cmd;
+	int cmd_len = 0;
+	int cmd_buf_len;
+	int offset = 0;
+
+	ret = usb_get_command_buffer(&sensor->usb_xport, &cmd, &cmd_buf_len);
+	if (ret != BMKT_SUCCESS)
+	{
+		return BMKT_OUT_OF_MEMORY;
+	}
+
+	if (cmd_buf_len < SENSOR_FW_CMD_HEADER_LEN)
+	{
+		return BMKT_OUT_OF_MEMORY;
+	}
+
+	cmd[0] = SENSOR_CMD_GET_VERSION;
+	cmd_len = 1;
+	ret = usb_send_command_sync(&sensor->usb_xport, cmd_len, &resp, &resp_len);
+	if (ret != BMKT_SUCCESS)
+	{
+		return ret;
+	}
+
+	status = extract16(resp, &offset);
+	if (status)
+	{
+		bmkt_err_log("The sensor reported an error when sending get version command: 0x%x",
+					status);
+		return BMKT_SENSOR_MALFUNCTION;
+	}
+
+	if (resp_len < 38)
+	{
+		return BMKT_SENSOR_MALFUNCTION;
+	}
+
+	mis_version->build_time = extract32(resp, &offset);
+	mis_version->build_num = extract32(resp, &offset);
+	mis_version->version_major = extract8(resp, &offset);
+	mis_version->version_minor = extract8(resp, &offset);
+	mis_version->target = extract8(resp, &offset);
+	mis_version->product = extract8(resp, &offset);
+
+	ret = usb_release_command_buffer(&sensor->usb_xport);
+	if (ret != BMKT_SUCCESS)
+	{
+		bmkt_dbg_log("%s: failed to release command buffer: %d", __func__, ret);
+		return ret;
+	}
+
+	return BMKT_SUCCESS;
+}
+
+static bmkt_session_ctx_t *get_empty_session_ctx(bmkt_sensor_t *sensor)
+{
+	bmkt_session_ctx_t *ctx;
+	int i;
+	int idx;
+
+	for (i = 0; i < BMKT_MAX_PENDING_SESSIONS; i++)
+	{
+		idx = (sensor->empty_session_idx + i) % BMKT_MAX_PENDING_SESSIONS;
+		ctx = &sensor->pending_sessions[idx];
+		if (ctx->seq_num == 0)
+		{
+			sensor->empty_session_idx = (idx + 1) % BMKT_MAX_PENDING_SESSIONS;
+			return ctx;
+		}
+	}
+
+	return NULL;
+}
+
+static bmkt_session_ctx_t *get_session_ctx(bmkt_sensor_t *sensor, int seq_num)
+{
+	int i;
+	bmkt_session_ctx_t *ctx;
+
+	/* Sequence number of 0 is not valid for a response to
+	 a command.*/
+	if (seq_num == 0)
+	{
+		return NULL;
+	}
+
+	for (i = 0; i < BMKT_MAX_PENDING_SESSIONS; i++)
+	{
+		ctx = &sensor->pending_sessions[i];
+		if (ctx->seq_num == seq_num)
+		{
+			return ctx;
+		}
+	}
+
+	return NULL;
+}
+
+static int release_session_ctx(bmkt_sensor_t *sensor, bmkt_session_ctx_t *ctx)
+{
+
+	memset(ctx, 0, sizeof(bmkt_session_ctx_t));
+
+	return BMKT_SUCCESS;
+}
+
+int bmkt_sensor_open(bmkt_sensor_t *sensor, bmkt_general_error_cb_t err_cb, void *err_cb_ctx)
+{
+	int ret;
+
+	sensor->seq_num = 1;
+
+	sensor->sensor_state = BMKT_SENSOR_STATE_UNINIT;
+	sensor->usb_xport.sensor = sensor;
+	ret = usb_open(&sensor->usb_xport);
+
+	if (ret != BMKT_SUCCESS)
+	{
+		bmkt_err_log("Failed to open transport: %d", ret);
+		return ret;
+	}
+
+	sensor->gen_err_cb = err_cb;
+	sensor->gen_err_cb_ctx = err_cb_ctx;
+
+	ret = get_version(sensor, &sensor->version);
+	if (ret != BMKT_SUCCESS)
+	{
+		bmkt_err_log("Failed to get version info: %d", ret);
+		return ret;
+	}
+
+	bmkt_dbg_log("Build Time: %d", sensor->version.build_time);
+	bmkt_dbg_log("Build Num: %d", sensor->version.build_num);
+	bmkt_dbg_log("Version: %d.%d", sensor->version.version_major, sensor->version.version_minor);
+	bmkt_dbg_log("Target: %d", sensor->version.target);
+	bmkt_dbg_log("Product: %d", sensor->version.product);
+
+	return BMKT_SUCCESS;
+}
+
+int bmkt_sensor_close(bmkt_sensor_t *sensor)
+{
+	int ret;
+
+	sensor->sensor_state = BMKT_SENSOR_STATE_EXIT;
+
+	ret = usb_close(&sensor->usb_xport);
+	if (ret != BMKT_SUCCESS)
+	{
+		return ret;
+	}
+
+	sensor->sensor_state = BMKT_SENSOR_STATE_EXIT;
+	return BMKT_SUCCESS;
+}
+
+int bmkt_sensor_init_fps(bmkt_sensor_t *sensor)
+{
+	sensor->sensor_state = BMKT_SENSOR_STATE_INIT;
+
+	return BMKT_SUCCESS;
+}
+
+int bmkt_sensor_send_message(bmkt_sensor_t *sensor, uint8_t msg_id, uint8_t payload_size,
+								uint8_t *payload, bmkt_resp_cb_t resp_cb, void *cb_ctx)
+{
+	int ret;
+	uint8_t *cmd;
+	int cmd_buf_len = 0;
+	int msg_len;
+	int seq_num = 0;
+	bmkt_session_ctx_t *session_ctx = get_empty_session_ctx(sensor);
+
+	if (session_ctx == NULL)
+	{
+		return BMKT_OPERATION_DENIED;
+	}
+
+	if (sensor->seq_num > 255) {
+		/* seq. number is in range [1 – 255]. After it reaches 255, it rolls over to 1 and starts over again. 
+		 (0 is reserved for special purposes) */
+		sensor->seq_num = 1;
+	}
+	session_ctx->seq_num = sensor->seq_num++;
+	session_ctx->resp_cb = resp_cb;
+	session_ctx->cb_ctx = cb_ctx;
+
+	bmkt_dbg_log("session_ctx->seq_num=%d, sensor->seq_num=%d", session_ctx->seq_num, sensor->seq_num);
+
+	bmkt_op_set_state(sensor, BMKT_OP_STATE_START);
+
+	ret = usb_get_command_buffer(&sensor->usb_xport, &cmd, &cmd_buf_len);
+	if (ret != BMKT_SUCCESS)
+	{
+		return BMKT_OUT_OF_MEMORY;
+	}
+
+	/* MIS sensors send ACE commands encapsulated in FW commands*/
+	cmd[0] = SENSOR_CMD_ACE_COMMAND;
+	msg_len = cmd_buf_len - SENSOR_FW_CMD_HEADER_LEN;
+
+	if (session_ctx != NULL)
+	{
+		seq_num = session_ctx->seq_num;
+	}
+
+	ret = bmkt_compose_message(&cmd[1], &msg_len, msg_id, seq_num, payload_size, payload);
+	if (ret != BMKT_SUCCESS)
+	{
+		bmkt_dbg_log("Failed to compose ace message: %d", ret);
+		goto cleanup;
+	}
+
+	ret = usb_send_command(&sensor->usb_xport, msg_len + SENSOR_FW_CMD_HEADER_LEN);
+
+	if (ret != BMKT_SUCCESS)
+	{
+		bmkt_dbg_log("%s: failed to send ACE command: %d", __func__, ret);
+		goto cleanup;
+	}
+
+cleanup:
+	usb_release_command_buffer(&sensor->usb_xport);
+	if (ret != BMKT_SUCCESS)
+	{
+		release_session_ctx(sensor, session_ctx);
+	}
+
+	return ret;
+}
+
+int bmkt_sensor_send_async_read_command(bmkt_sensor_t *sensor)
+{
+	int ret;
+	uint8_t *cmd;
+	int cmd_buf_len = 0;
+
+	ret = usb_get_command_buffer(&sensor->usb_xport, &cmd, &cmd_buf_len);
+	if (ret != BMKT_SUCCESS)
+	{
+		return BMKT_OUT_OF_MEMORY;
+	}
+
+	/* MIS sensors send ACE commands encapsulated in FW commands */
+	cmd[0] = SENSOR_CMD_ASYNCMSG_READ;
+
+	ret = usb_send_command(&sensor->usb_xport, SENSOR_FW_CMD_HEADER_LEN);
+	if (ret == BMKT_SENSOR_RESPONSE_PENDING)
+	{
+		/* The caller needs to handle the response before we can send this command */
+		goto cleanup;
+	}
+	else if (ret != BMKT_SUCCESS)
+	{
+		if (ret != BMKT_SENSOR_NOT_READY)
+		{
+			bmkt_dbg_log("%s: failed to send ACE ASYNC READ command: %d", __func__, ret);
+		}
+		goto cleanup;
+	}
+
+cleanup:
+	usb_release_command_buffer(&sensor->usb_xport);
+
+	return ret;
+}
+
+int bmkt_sensor_send_message_sync(bmkt_sensor_t *sensor, uint8_t msg_id, uint8_t payload_size,
+					uint8_t *payload, uint8_t **resp_buf, int *resp_len, bmkt_response_t *resp)
+{
+	int ret;
+	uint8_t *cmd;
+	int cmd_buf_len = 0;
+	int msg_len;
+	bmkt_msg_resp_t msg_resp;
+
+	*resp_len = BMKT_MAX_TRANSFER_LEN;
+
+	ret = usb_get_command_buffer(&sensor->usb_xport, &cmd, &cmd_buf_len);
+	if (ret != BMKT_SUCCESS)
+	{
+		return BMKT_OUT_OF_MEMORY;
+	}
+
+	cmd[0] = SENSOR_CMD_ACE_COMMAND;
+	msg_len = cmd_buf_len - SENSOR_FW_CMD_HEADER_LEN;
+
+	ret = bmkt_compose_message(&cmd[1], &msg_len, msg_id, sensor->seq_num++, payload_size,
+						payload);
+	if (ret != BMKT_SUCCESS)
+	{
+		bmkt_dbg_log("Failed to compose ace message: %d", ret);
+		goto cleanup;
+	}
+
+	ret = usb_send_command_sync(&sensor->usb_xport, msg_len + SENSOR_FW_CMD_HEADER_LEN,
+						resp_buf, resp_len);
+	if (ret != BMKT_SUCCESS)
+	{
+		bmkt_dbg_log("%s: failed to send ACE command: %d", __func__, ret);
+		goto cleanup;
+	}
+
+	ret = bmkt_parse_message_header(&(*resp_buf)[2], *resp_len - 2, &msg_resp);
+	if (ret != BMKT_SUCCESS)
+	{
+		goto cleanup;
+	}
+
+	ret = bmkt_parse_message_payload(&msg_resp, resp);
+	if (ret != BMKT_SUCCESS)
+	{
+		goto cleanup;
+	}
+
+cleanup:
+	ret = usb_release_command_buffer(&sensor->usb_xport);
+	if (ret != BMKT_SUCCESS)
+	{
+		bmkt_dbg_log("%s: failed to release command buffer: %d", __func__, ret);
+		return ret;
+	}
+	return ret;
+}
+
+int bmkt_sensor_handle_response(bmkt_sensor_t *sensor, uint8_t *resp_buf, int resp_len, bmkt_msg_resp_t *msg_resp)
+{
+	int ret;
+	bmkt_session_ctx_t *session_ctx;
+	bmkt_response_t resp;
+	int i;
+
+	ret = bmkt_parse_message_header(&resp_buf[2], resp_len - 2, msg_resp);
+	if (ret == BMKT_CORRUPT_MESSAGE)
+	{
+		bmkt_warn_log("Corrupt Message Received");
+		return ret;
+	}
+	else if (ret != BMKT_SUCCESS)
+	{
+		return ret;
+	}
+
+	if (msg_resp->msg_id == BMKT_EVT_FINGER_REPORT)
+	{
+		/* finger event message */
+		bmkt_info_log("Finger event!");
+		bmkt_finger_event_t finger_event;
+
+		if (msg_resp->payload_len != 1)
+		{
+			return BMKT_UNRECOGNIZED_MESSAGE;
+		}
+
+		if (msg_resp->payload[0] == 0x01)
+		{
+			finger_event.finger_state = BMKT_FINGER_STATE_ON_SENSOR;
+		}
+		else
+		{
+			finger_event.finger_state = BMKT_FINGER_STATE_NOT_ON_SENSOR;
+		}
+
+		if (sensor->finger_event_cb != NULL)
+		{
+			sensor->finger_event_cb(&finger_event, sensor->finger_cb_ctx);
+		}
+		return BMKT_SUCCESS;
+	}
+
+	if (msg_resp->seq_num == 0)
+	{
+
+		if (msg_resp->msg_id == BMKT_RSP_GENERAL_ERROR)
+		{
+			/* report general error */
+			bmkt_info_log("General Error!");
+			uint16_t err;
+
+			if (sensor->gen_err_cb != NULL)
+			{
+				err = (msg_resp->payload[0] << 8) | msg_resp->payload[1];
+				sensor->gen_err_cb(err, sensor->gen_err_cb_ctx);
+			}
+			return BMKT_SUCCESS;
+		}
+	}
+
+	ret = bmkt_parse_message_payload(msg_resp, &resp);
+	if (ret != BMKT_SUCCESS)
+	{
+		bmkt_warn_log("Failed to process response: %d", ret);
+		return ret;
+	}
+
+	session_ctx = get_session_ctx(sensor, msg_resp->seq_num);
+	if (session_ctx == NULL)
+	{
+		bmkt_warn_log("Response received with invalid sequence number: %d, return BMKT_UNRECOGNIZED_MESSAGE(112)", msg_resp->seq_num);
+		return BMKT_UNRECOGNIZED_MESSAGE;
+	}
+
+	if (session_ctx->resp_cb != NULL)
+	{
+		ret = session_ctx->resp_cb(&resp, session_ctx->cb_ctx);
+		if (ret != BMKT_SUCCESS)
+		{
+			bmkt_warn_log("response callback failed: %d", ret);
+		}
+	}
+
+	if (resp.complete == 1)
+	{
+		ret = release_session_ctx(sensor, session_ctx);
+		if (ret != BMKT_SUCCESS)
+		{
+			return ret;
+		}
+	}
+
+	if (resp.response_id == BMKT_RSP_CANCEL_OP_OK && resp.result == BMKT_SUCCESS)
+	{
+		/* The previous commands have been canceled. Release all session ctx */
+		for (i = 0; i < BMKT_MAX_PENDING_SESSIONS; i++)
+		{
+			release_session_ctx(sensor, &sensor->pending_sessions[i]);
+		}
+	}
+
+	return BMKT_SUCCESS;
+}
+
+int bmkt_register_finger_event_notification(bmkt_sensor_t *sensor, bmkt_event_cb_t cb, void *cb_ctx)
+{
+	if (sensor == NULL || cb == NULL)
+	{
+		return BMKT_INVALID_PARAM;
+	}
+
+	sensor->finger_event_cb = cb;
+	sensor->finger_cb_ctx = cb_ctx;
+
+	return BMKT_SUCCESS;
+}

libfprint/drivers/synaptics/sensor.h

@@ -16,12 +16,14 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
+#ifndef _SENSOR_H_
+#define _SENSOR_H_
 
 #include "usb_transport.h"
 #define BMKT_MAX_PENDING_SESSIONS		2
 
-typedef enum bmkt_sensor_state {
+typedef enum bmkt_sensor_state
+{
 	BMKT_SENSOR_STATE_UNINIT 			= 0,
 	BMKT_SENSOR_STATE_IDLE,
 	BMKT_SENSOR_STATE_INIT,
@@ -65,21 +67,16 @@ typedef struct bmkt_sensor
 } bmkt_sensor_t;
 
 int bmkt_sensor_open(bmkt_sensor_t *sensor, 
-                      bmkt_general_error_cb_t err_cb,
+						bmkt_general_error_cb_t err_cb, void *err_cb_ctx);
-                      void                   *err_cb_ctx);
 int bmkt_sensor_close(bmkt_sensor_t *sensor);
 
 int bmkt_sensor_init_fps(bmkt_sensor_t *sensor);
 
-int bmkt_sensor_send_message (bmkt_sensor_t *sensor,
+int bmkt_sensor_send_message(bmkt_sensor_t *sensor, uint8_t msg_id, uint8_t payload_size,
-                              uint8_t        msg_id,
+						uint8_t *payload, bmkt_resp_cb_t resp_cb, void *resp_data);
-                              uint8_t        payload_size,
+int bmkt_sensor_send_message_sync(bmkt_sensor_t *sensor, uint8_t msg_id, uint8_t payload_size,
-                              uint8_t       *payload,
+						uint8_t *payload, uint8_t **resp_buf, int *resp_len, bmkt_response_t *resp);
-                              bmkt_resp_cb_t resp_cb,
+int bmkt_sensor_handle_response(bmkt_sensor_t *sensor, uint8_t *resp_buf, int resp_len, bmkt_msg_resp_t *msg_resp);
-                              void          *resp_data);
-int bmkt_sensor_handle_response (bmkt_sensor_t   *sensor,
-                                 uint8_t         *resp_buf,
-                                 int              resp_len,
-                                 bmkt_msg_resp_t *msg_resp);
 
 int bmkt_sensor_send_async_read_command(bmkt_sensor_t *sensor);
+#endif /* _SENSOR_H_ */

libfprint/drivers/synaptics/synaptics.h

@@ -16,67 +16,26 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
+#ifndef __synaptics_h__
-
+#define __synaptics_h__
-#include "fpi-device.h"
-#include "fpi-ssm.h"
 
 #define SYNAPTICS_VENDOR_ID          0x06cb
-
+#define SYNAPTICS_PRODUCT_ID_A9	    0x00a9
-G_DECLARE_FINAL_TYPE (FpiDeviceSynaptics, fpi_device_synaptics, FPI, DEVICE_SYNAPTICS, FpDevice)
-
-
-#define MAX_TRANSFER_LEN 263 + 1 /* SPI Header */ + 2                                /* VCSFW header */
-
-#define USB_EP_REQUEST 0x01
-#define USB_EP_REPLY 0x81
-#define USB_EP_FINGERPRINT 0x82
-#define USB_EP_INTERRUPT 0x83
-
-#define USB_ASYNC_MESSAGE_PENDING 0x4
-#define USB_INTERRUPT_DATA_SIZE 7
-
-#define SENSOR_CMD_GET_VERSION 1
-#define SENSOR_CMD_ACE_COMMAND 167
-#define SENSOR_CMD_ASYNCMSG_READ 168
-
-#define SENSOR_FW_CMD_HEADER_LEN 1
-#define SENSOR_FW_REPLY_HEADER_LEN 2
-
 
 /* Number of enroll stages */
-#define ENROLL_SAMPLES 8
+#define ENROLL_SAMPLES		12
-
 
 #define SYNAPTICS_DRIVER_FULLNAME    "Synaptics Sensors"
 #include "bmkt.h"
 #include "bmkt_response.h"
 
 
-typedef struct bmkt_sensor_version
-{
-  uint32_t build_time;
-  uint32_t build_num;
-  uint8_t  version_major;
-  uint8_t  version_minor;
-  uint8_t  target;
-  uint8_t  product;
-  uint8_t  silicon_rev;
-  uint8_t  formal_release;
-  uint8_t  platform;
-  uint8_t  patch;
-  uint8_t  serial_number[6];
-  uint16_t security;
-  uint8_t  iface;
-  uint8_t  device_type;
-} bmkt_sensor_version_t;
-
-
 struct syna_enroll_resp_data
 {
 	int progress;
 };
-typedef enum syna_state {
+typedef enum syna_state
+{
 	SYNA_STATE_UNINIT 							= 0,
 	SYNA_STATE_IDLE								,
 	SYNA_STATE_ENROLL							,
@@ -87,39 +46,13 @@ typedef enum syna_state {
 	SYNA_STATE_DELETE							,
 } syna_state_t;
 
-typedef enum {
+typedef struct synaptics_dev_s 
-  SYNAPTICS_CMD_SEND_PENDING = 0,
-  SYNAPTICS_CMD_GET_RESP,
-  SYNAPTICS_CMD_WAIT_INTERRUPT,
-  SYNAPTICS_CMD_SEND_ASYNC,
-  SYNAPTICS_CMD_RESTART,
-  SYNAPTICS_CMD_NUM_STATES,
-} SynapticsCmdState;
-
-
-typedef void (*SynCmdMsgCallback) (FpiDeviceSynaptics *self,
-                                   bmkt_response_t    *resp,
-                                   GError             *error);
-
-struct _FpiDeviceSynaptics
 {
-  FpDevice              parent;
+	bmkt_ctx_t *ctx;
-
+	bmkt_sensor_t *sensor;
-  guint8                cmd_seq_num;
-  guint8                last_seq_num;
-  FpiSsm               *cmd_ssm;
-  FpiUsbTransfer       *cmd_pending_transfer;
-  gboolean              cmd_complete_on_removal;
-
-  bmkt_sensor_version_t mis_version;
-
-  GCancellable         *interrupt_cancellable;
-
-  gint                  enroll_stage;
-  gboolean              finger_on_sensor;
-  GPtrArray            *list_result;
-
-
 	struct syna_enroll_resp_data enroll_resp_data;
+	gboolean isFingerOnSensor;
 	syna_state_t state;
-};
+}synaptics_dev;
+
+#endif //__synaptics_h__

libfprint/drivers/synaptics/usb_transport.c

@@ -0,0 +1,386 @@
+/*
+ * Copyright (C) 2019 Synaptics Inc
+ *
+ * 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 "bmkt_internal.h"
+#include "sensor.h"
+#include "drivers_api.h"
+
+
+#define USB_ASYNC_MESSAGE_PENDING		0x4
+
+static void usb_int_callback(struct libusb_transfer *transfer)
+{
+	bmkt_usb_transport_t *usb_xport = (bmkt_usb_transport_t *)transfer->user_data;
+
+#ifdef TRANSPORT_DEBUG
+	bmkt_dbg_log("INTERRUPT: (%d) ", transfer->actual_length);
+	print_buffer(transfer->buffer, transfer->actual_length);
+#endif
+
+	if (transfer->buffer[0] & USB_ASYNC_MESSAGE_PENDING)
+	{
+		libusb_free_transfer(transfer);
+		bmkt_op_next_state(usb_xport->sensor);
+	}
+	else
+		libusb_submit_transfer(transfer);
+}
+
+int usb_check_interrupt(bmkt_usb_transport_t *usb_xport)
+{
+	int ret;
+	struct libusb_transfer *interrupt_xfer;
+	interrupt_xfer = libusb_alloc_transfer(0);
+	if (interrupt_xfer == NULL)
+	{
+		return BMKT_GENERAL_ERROR;
+	}
+
+	libusb_fill_interrupt_transfer(interrupt_xfer, usb_xport->handle, USB_EP_INTERRUPT,
+			usb_xport->interrupt_data, sizeof(usb_xport->interrupt_data), usb_int_callback, usb_xport, 0);
+
+	ret = libusb_submit_transfer(interrupt_xfer);
+	if (ret != LIBUSB_SUCCESS)
+	{
+		libusb_free_transfer(interrupt_xfer);
+		if (ret == LIBUSB_ERROR_NO_DEVICE)
+		{
+			return BMKT_SENSOR_MALFUNCTION;
+		}
+		else
+		{
+			return BMKT_GENERAL_ERROR;
+		}
+	}
+
+	return BMKT_SUCCESS;
+}
+
+int usb_open(bmkt_usb_transport_t *usb_xport)
+{
+	int ret;
+	struct libusb_config_descriptor *configDesc;
+	const struct libusb_interface *iface;
+	const struct libusb_interface_descriptor *ifaceDesc;
+	const struct libusb_endpoint_descriptor *endpointDesc;
+	int config;
+	int i;
+
+	usb_xport->device = libusb_get_device(usb_xport->handle);
+	
+	ret = libusb_reset_device(usb_xport->handle);
+	if (ret)
+	{
+		bmkt_dbg_log("Failed to reset device\n");
+	}
+
+	ret = libusb_get_config_descriptor(usb_xport->device, USB_DEFAULT_CONFIGURATION, &configDesc);
+	if (ret)
+	{
+		ret = BMKT_SENSOR_MALFUNCTION;
+		return ret;
+	}
+
+	ret = libusb_get_configuration(usb_xport->handle, &config);
+	if (ret)
+	{
+		ret = BMKT_SENSOR_MALFUNCTION;
+		goto free_config;
+	}
+
+	if (configDesc->bConfigurationValue != config)
+	{
+		ret = libusb_set_configuration(usb_xport->handle, config);
+		if (ret)
+		{
+			ret = BMKT_SENSOR_MALFUNCTION;
+			goto free_config;
+		}
+	}
+
+	ret = libusb_kernel_driver_active(usb_xport->handle, 0);
+	if (ret == 1)
+	{
+		bmkt_err_log("Failed to detect kernel driver\n");
+		ret = BMKT_SENSOR_MALFUNCTION;
+		goto free_config;
+	}
+
+	ret = libusb_claim_interface(usb_xport->handle, USB_DEFAULT_INTERFACE);
+	if (ret)
+	{
+		ret = BMKT_SENSOR_MALFUNCTION;
+		goto free_config;
+	}
+
+	iface = configDesc->interface + USB_DEFAULT_INTERFACE;
+	ifaceDesc = iface->altsetting + USB_DEFAULT_ALT_SETTING;
+	endpointDesc = ifaceDesc->endpoint;
+
+	for (i = 0; i < ifaceDesc->bNumEndpoints; i++)
+	{
+		ret = libusb_clear_halt(usb_xport->handle, endpointDesc->bEndpointAddress);
+		if (ret)
+		{
+			ret = BMKT_SENSOR_MALFUNCTION;
+			goto free_config;
+		}
+		++endpointDesc;
+	}
+
+free_config:
+	libusb_free_config_descriptor(configDesc);
+
+	return ret;
+}
+
+int usb_close(bmkt_usb_transport_t *usb_xport)
+{
+	if (usb_xport->handle)
+	{
+		libusb_release_interface(usb_xport->handle, USB_DEFAULT_INTERFACE);
+	}
+
+	return BMKT_SUCCESS;
+}
+
+void usb_in_cb(struct libusb_transfer *transfer)
+{
+	uint8_t *resp_buf;
+	int resp_len;
+	bmkt_msg_resp_t msg_resp;
+	bmkt_usb_transport_t *usb_xport = (bmkt_usb_transport_t *)transfer->user_data;
+
+#ifdef TRANSPORT_DEBUG
+	bmkt_dbg_log("RX_ASYNC: (%d) ", transfer->actual_length);
+	print_buffer(transfer->buffer, transfer->actual_length);
+#endif
+
+	resp_buf = transfer->buffer;
+	resp_len = transfer->actual_length;
+	bmkt_sensor_handle_response(usb_xport->sensor, resp_buf, resp_len, &msg_resp);
+	libusb_free_transfer(transfer);
+
+	bmkt_op_next_state(usb_xport->sensor);
+}
+
+void usb_out_cb(struct libusb_transfer *transfer)
+{
+
+	bmkt_usb_transport_t *usb_xport = (bmkt_usb_transport_t *)transfer->user_data;
+
+	libusb_free_transfer(transfer);
+	bmkt_op_next_state(usb_xport->sensor);
+	
+}
+
+static int bulk_transfer_async(bmkt_usb_transport_t *usb_xport, uint8_t *buf, int size, uint8_t endpoint,
+						int *transferred, uint32_t timeout, libusb_transfer_cb_fn callback)
+{
+	int ret;
+	struct libusb_transfer *transfer;
+
+#ifdef TRANSPORT_DEBUG
+	if (!(endpoint & 0x80))
+	{
+		bmkt_dbg_log("TX2: (%d) ", size);
+		print_buffer(buf, size);
+	}
+#endif
+	
+	transfer = libusb_alloc_transfer(0);
+	libusb_fill_bulk_transfer( transfer, usb_xport->handle, endpoint,
+		buf, size, callback, usb_xport, 0);
+
+	ret = libusb_submit_transfer(transfer);
+	if (ret != LIBUSB_SUCCESS)
+	{
+		libusb_free_transfer(transfer);
+		if (ret == LIBUSB_ERROR_NO_DEVICE)
+		{
+			return BMKT_SENSOR_MALFUNCTION;
+		}
+		else
+		{
+			return BMKT_GENERAL_ERROR;
+		}
+	}
+	return BMKT_SUCCESS;
+}
+
+
+
+static int bulk_transfer(bmkt_usb_transport_t *usb_xport, uint8_t *buf, int size, uint8_t endpoint,
+						int *transferred, uint32_t timeout)
+{
+	int ret;
+
+#ifdef TRANSPORT_DEBUG
+	if (!(endpoint & 0x80))
+	{
+		bmkt_dbg_log("TX: (%d) ", size);
+		print_buffer(buf, size);
+	}
+#endif
+
+	ret = libusb_bulk_transfer(usb_xport->handle, endpoint, buf, size, transferred, timeout);
+	if (ret)
+	{
+		bmkt_warn_log("libusb_bulk_transfer: bulk transfer failed: %d\n", ret);
+		if (ret == LIBUSB_ERROR_TIMEOUT)
+		{
+			return BMKT_OP_TIME_OUT;
+		}
+		else
+		{
+			return BMKT_SENSOR_MALFUNCTION;
+		}
+	}
+	bmkt_dbg_log("transferred: %d\n", *transferred);
+
+#ifdef TRANSPORT_DEBUG
+	if (endpoint & 0x80)
+	{
+		bmkt_dbg_log("RX: (%d) ", *transferred);
+		print_buffer(buf, *transferred);
+	}
+#endif
+
+	return BMKT_SUCCESS;
+}
+
+int usb_send_command(bmkt_usb_transport_t *usb_xport, int len)
+{
+	int ret;
+	int tx_len = 0;
+
+	ret = bulk_transfer_async(usb_xport, usb_xport->transfer, len, USB_EP_REQUEST, &tx_len, 0, usb_out_cb);
+	if (ret != BMKT_SUCCESS)
+	{
+		bmkt_dbg_log("Failed to send usb command\n");
+		return ret;
+	}
+
+	return BMKT_SUCCESS;
+}
+
+
+int usb_get_command_buffer(bmkt_usb_transport_t *usb_xport, uint8_t **cmd, int *len)
+{
+
+	*len = BMKT_MAX_TRANSFER_LEN;
+	*cmd = usb_xport->transfer;
+
+	return BMKT_SUCCESS;
+}
+
+int usb_get_response_buffer(bmkt_usb_transport_t *usb_xport, uint8_t **resp, int *len)
+{
+	*len = BMKT_MAX_TRANSFER_LEN;
+	*resp = usb_xport->transfer;
+
+	return BMKT_SUCCESS;
+}
+
+int usb_receive_resp_async(bmkt_usb_transport_t *usb_xport, int *len)
+{
+	int ret;
+
+	*len = BMKT_MAX_TRANSFER_LEN;
+
+	/* Check to make sure the buffer is clear */
+	memset(usb_xport->transfer, 0, BMKT_MAX_TRANSFER_LEN);
+	
+	ret = bulk_transfer_async(usb_xport, usb_xport->transfer, *len, USB_EP_REPLY, len, 0, usb_in_cb);
+
+	if (ret != BMKT_SUCCESS)
+	{
+		bmkt_dbg_log("Failed to send usb command\n");
+		return ret;
+	}
+	
+	return BMKT_SUCCESS;
+}
+
+
+int usb_receive_resp(bmkt_usb_transport_t *usb_xport, int *len)
+{
+	int ret;
+
+	*len = BMKT_MAX_TRANSFER_LEN;
+
+	/* Check to make sure the buffer is clear */
+	memset(usb_xport->transfer, 0, BMKT_MAX_TRANSFER_LEN);
+
+	ret = bulk_transfer(usb_xport, usb_xport->transfer, *len, USB_EP_REPLY, len, 0);
+
+
+	if (ret != BMKT_SUCCESS)
+	{
+		bmkt_dbg_log("Failed to send usb command\n");
+		return ret;
+	}
+	
+	return BMKT_SUCCESS;
+}
+
+int usb_send_command_sync(bmkt_usb_transport_t *usb_xport, int len, uint8_t **resp_buf,
+						int *resp_len)
+{
+	int ret;
+	int tx_len = 0;
+
+	ret = bulk_transfer(usb_xport, usb_xport->transfer, len, USB_EP_REQUEST, &tx_len, 0);
+	if (ret != BMKT_SUCCESS)
+	{
+		bmkt_dbg_log("Failed to send usb command\n");
+		return ret;
+	}
+
+	/* Check to make sure the buffer is clear */
+	memset(usb_xport->transfer, 0, BMKT_MAX_TRANSFER_LEN);
+
+	ret = bulk_transfer(usb_xport, usb_xport->transfer, *resp_len, USB_EP_REPLY, resp_len, 0);
+	if (ret != BMKT_SUCCESS)
+	{
+		bmkt_dbg_log("Failed to send usb command\n");
+		return ret;
+	}
+
+	*resp_buf = usb_xport->transfer;
+
+	return BMKT_SUCCESS;
+}
+
+int usb_reset(bmkt_usb_transport_t *usb_xport)
+{
+	return BMKT_OPERATION_DENIED;
+}
+
+int usb_release_command_buffer(bmkt_usb_transport_t *usb_xport)
+{
+	return BMKT_SUCCESS;
+}
+int usb_release_response_buffer(bmkt_usb_transport_t *usb_xport)
+{
+	return BMKT_SUCCESS;
+}
+
+
+

libfprint/drivers/synaptics/usb_transport.h

@@ -0,0 +1,76 @@
+/*
+ * Copyright (C) 2019 Synaptics Inc
+ *
+ * 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 _USB_TRANSPORT_H_
+#define _USB_TRANSPORT_H_
+
+#include "bmkt_internal.h"
+#include "libusb-1.0/libusb.h"
+
+
+
+#define BMKT_MAX_TRANSFER_LEN 				263 + 1 /* SPI Header */ + 2 /* VCSFW header */
+
+#define BMKT_XPORT_INT_NONE					0x0
+#define BMKT_XPORT_INT_RESPONSE				0x1
+#define BMKT_XPORT_INT_FINGER				0x2
+#define BMKT_XPORT_INT_ASYNC				0x4
+
+#define USB_DEFAULT_CONFIGURATION		0
+#define USB_DEFAULT_INTERFACE			0
+#define USB_DEFAULT_ALT_SETTING			0
+
+#define USB_EP_REQUEST					0x01
+#define USB_EP_REPLY					0x81
+#define USB_EP_FINGERPRINT				0x82
+#define USB_EP_INTERRUPT				0x83
+
+#define USB_INTERRUPT_DATA_SIZE			7
+
+
+typedef struct bmkt_usb_transport
+{
+	libusb_context *ctx;
+	libusb_device *device;
+	libusb_device_handle *handle;
+	uint8_t interrupt_data[USB_INTERRUPT_DATA_SIZE];
+	bmkt_sensor_t *sensor;
+	uint8_t transfer[BMKT_MAX_TRANSFER_LEN];
+} bmkt_usb_transport_t;
+
+
+int usb_release_command_buffer(bmkt_usb_transport_t *xport);
+int usb_release_response_buffer(bmkt_usb_transport_t *xport);
+
+
+
+
+int usb_open(bmkt_usb_transport_t *xport);
+int usb_close(bmkt_usb_transport_t *xport);
+int usb_send_command(bmkt_usb_transport_t *xport, int len);
+int usb_get_command_buffer(bmkt_usb_transport_t *xport, uint8_t **cmd, int *len);
+int usb_get_response_buffer(bmkt_usb_transport_t *xport, uint8_t **resp, int *len);
+int usb_receive_resp(bmkt_usb_transport_t *xport, int *len);
+
+int usb_send_command_sync(bmkt_usb_transport_t *xport, int len, uint8_t **resp_buf,
+						int *resp_len);
+int usb_receive_resp_async(bmkt_usb_transport_t *usb_xport, int *len);
+int usb_check_interrupt(bmkt_usb_transport_t *usb_xport);
+
+
+#endif /* _USB_TRANSPORT_H_ */

libfprint/drivers/synaptics/util.c

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2019 Synaptics Inc
+ *
+ * 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 "bmkt_internal.h"
+#include "sensor.h"
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wformat-zero-length"
+void print_buffer(uint8_t *buf, int len)
+{
+	int i;
+
+	for (i = 0; i < len; i++)
+	{
+		bmkt_dbg_log("0x%02x ", buf[i]);
+		if ((i % 16) == 15)
+		{
+			bmkt_dbg_log("");
+		}
+	}
+	bmkt_dbg_log("");
+}
+#pragma GCC diagnostic pop
+
+uint32_t extract32(const uint8_t *buf, int *offset)
+{
+	uint32_t ret = 0;
+	int off = 0;
+	if (offset)
+	{
+		off = *offset;
+	}
+	ret = GUINT32_FROM_LE(*(uint32_t*)(buf + off));
+	if (offset)
+	{
+		*offset += 4;
+	}
+	return ret;
+}
+
+uint16_t extract16(const uint8_t *buf, int *offset)
+{
+	uint16_t ret = 0;
+	int off = 0;
+	if (offset)
+	{
+		off = *offset;
+	}
+	ret = GUINT16_FROM_LE(*(uint16_t*)(buf + off));
+	if (offset)
+	{
+		*offset += 2;
+	}
+	return ret;
+}
+
+uint8_t extract8(const uint8_t *buf, int *offset)
+{
+	uint8_t ret = 0;
+	int off = 0;
+	if (offset)
+	{
+		off = *offset;
+	}
+	ret = *(buf + off);
+	if (offset)
+	{
+		*offset += 1;
+	}
+	return ret;
+}
+

libfprint/drivers/upek_proto.c

@@ -59,7 +59,6 @@ uint16_t
 udf_crc(unsigned char *buffer, size_t size)
 {
 	uint16_t crc = 0;
-
 	while (size--)
 		crc = (uint16_t) ((crc << 8) ^
 				  crc_table[((crc >> 8) & 0x00ff) ^ *buffer++]);

libfprint/drivers/upek_proto.h

@@ -21,5 +21,4 @@
 #include <stdint.h>
 #include <stddef.h>
 
-uint16_t udf_crc (unsigned char *buffer,
+uint16_t udf_crc(unsigned char *buffer, size_t size);
-                  size_t         size);

libfprint/drivers/upeksonly.h

@@ -27,10 +27,9 @@
 #define IMG_WIDTH_1000	288
 #define IMG_WIDTH_1001	216
 
-struct sonly_regwrite
+struct sonly_regwrite {
-{
+	uint8_t reg;
-  guint8 reg;
+	uint8_t value;
-  guint8 value;
 };
 
 /***** AWAIT FINGER *****/

libfprint/drivers/upektc.c

@@ -23,16 +23,13 @@
 #include "drivers_api.h"
 #include "upektc.h"
 
-#define UPEKTC_EP_IN (2 | FPI_USB_ENDPOINT_IN)
+#define UPEKTC_EP_IN (2 | LIBUSB_ENDPOINT_IN)
-#define UPEKTC_EP_OUT (3 | FPI_USB_ENDPOINT_OUT)
+#define UPEKTC_EP_OUT (3 | LIBUSB_ENDPOINT_OUT)
-#define UPEKET_EP_IN (1 | FPI_USB_ENDPOINT_IN)
+#define UPEKET_EP_IN (1 | LIBUSB_ENDPOINT_IN)
-#define UPEKET_EP_OUT (2 | FPI_USB_ENDPOINT_OUT)
+#define UPEKET_EP_OUT (2 | LIBUSB_ENDPOINT_OUT)
 #define BULK_TIMEOUT 4000
 
-struct _FpiDeviceUpektc
+struct upektc_dev {
-{
-  FpImageDevice           parent;
-
 	gboolean deactivating;
 	const struct setup_cmd *setup_commands;
 	size_t setup_commands_len;
@@ -41,19 +38,15 @@ struct _FpiDeviceUpektc
 	int init_idx;
 	int sum_threshold;
 };
-G_DECLARE_FINAL_TYPE (FpiDeviceUpektc, fpi_device_upektc, FPI, DEVICE_UPEKTC,
-                      FpImageDevice);
-G_DEFINE_TYPE (FpiDeviceUpektc, fpi_device_upektc, FP_TYPE_IMAGE_DEVICE);
 
 enum upektc_driver_data {
 	UPEKTC_2015,
 	UPEKTC_3001,
 };
 
-static void start_capture (FpImageDevice *dev);
+static void start_capture(struct fp_img_dev *dev);
-static void complete_deactivation (FpImageDevice *dev,
+static void complete_deactivation(struct fp_img_dev *dev);
-                                   GError        *error);
+static void start_finger_detection(struct fp_img_dev *dev);
-static void start_finger_detection (FpImageDevice *dev);
 
 /****** INITIALIZATION/DEINITIALIZATION ******/
 
@@ -64,188 +57,205 @@ enum activate_states {
 };
 
 static void
-upektc_next_init_cmd (FpiSsm        *ssm,
+upektc_next_init_cmd(fpi_ssm           *ssm,
-                      FpImageDevice *dev)
+		     struct fp_img_dev *dev)
 {
-  FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (dev);
+	struct upektc_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
 
-  self->init_idx += 1;
+	upekdev->init_idx += 1;
-  if (self->init_idx == self->setup_commands_len)
+	if (upekdev->init_idx == upekdev->setup_commands_len)
 		fpi_ssm_mark_completed(ssm);
 	else
 		fpi_ssm_jump_to_state(ssm, WRITE_INIT);
 }
 
-static void
+static void write_init_cb(struct libusb_transfer *transfer)
-write_init_cb (FpiUsbTransfer *transfer, FpDevice *device,
-               gpointer user_data, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
+	fpi_ssm *ssm = transfer->user_data;
-  FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (dev);
+	struct fp_img_dev *dev = fpi_ssm_get_user_data(ssm);
+	struct upektc_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
 
-  if (!error)
+	if ((transfer->status == LIBUSB_TRANSFER_COMPLETED) &&
-    {
+		(transfer->length == transfer->actual_length)) {
-      if (self->setup_commands[self->init_idx].response_len)
+		if (upekdev->setup_commands[upekdev->init_idx].response_len)
-        fpi_ssm_next_state (transfer->ssm);
+			fpi_ssm_next_state(ssm);
 		else
-        upektc_next_init_cmd (transfer->ssm, dev);
+			upektc_next_init_cmd(ssm, dev);
+	} else {
+		fpi_ssm_mark_failed(ssm, -EIO);
 	}
+	libusb_free_transfer(transfer);
+}
+
+static void read_init_data_cb(struct libusb_transfer *transfer)
+{
+	fpi_ssm *ssm = transfer->user_data;
+	struct fp_img_dev *dev = fpi_ssm_get_user_data(ssm);
+
+	if (transfer->status == LIBUSB_TRANSFER_COMPLETED)
+		upektc_next_init_cmd(ssm, dev);
 	else
-    {
+		fpi_ssm_mark_failed(ssm, -EIO);
-      fpi_ssm_mark_failed (transfer->ssm, error);
+	g_free(transfer->buffer);
-    }
+	libusb_free_transfer(transfer);
 }
 
-static void
+static void activate_run_state(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-read_init_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                   gpointer user_data, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
+	struct fp_img_dev *dev = user_data;
+	struct upektc_dev *upekdev = FP_INSTANCE_DATA(_dev);
+	int r;
 
-  if (!error)
+	switch (fpi_ssm_get_cur_state(ssm)) {
-    upektc_next_init_cmd (transfer->ssm, dev);
-  else
-    fpi_ssm_mark_failed (transfer->ssm, error);
-}
-
-static void
-activate_run_state (FpiSsm *ssm, FpDevice *dev)
-{
-  FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (dev);
-
-  switch (fpi_ssm_get_cur_state (ssm))
-    {
 	case WRITE_INIT:
 	{
-        FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
+		struct libusb_transfer *transfer = fpi_usb_alloc();
 
-        fpi_usb_transfer_fill_bulk_full (transfer,
+		libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), upekdev->ep_out,
-                                         self->ep_out,
+			(unsigned char*)upekdev->setup_commands[upekdev->init_idx].cmd,
-                                         (unsigned char *) self->setup_commands[self->init_idx].cmd,
+			UPEKTC_CMD_LEN, write_init_cb, ssm, BULK_TIMEOUT);
-                                         UPEKTC_CMD_LEN,
+		r = libusb_submit_transfer(transfer);
-                                         NULL);
+		if (r < 0) {
-        transfer->ssm = ssm;
+			libusb_free_transfer(transfer);
-        transfer->short_is_error = TRUE;
+			fpi_ssm_mark_failed(ssm, -ENOMEM);
-        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+		}
-                                 write_init_cb, NULL);
 	}
 	break;
-
 	case READ_DATA:
 	{
-        FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
+		struct libusb_transfer *transfer = fpi_usb_alloc();
+		unsigned char *data;
 
-        fpi_usb_transfer_fill_bulk (transfer,
+		data = g_malloc(upekdev->setup_commands[upekdev->init_idx].response_len);
-                                    self->ep_in,
+		libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), upekdev->ep_in, data,
-                                    self->setup_commands[self->init_idx].response_len);
+			upekdev->setup_commands[upekdev->init_idx].response_len,
-        transfer->ssm = ssm;
+			read_init_data_cb, ssm, BULK_TIMEOUT);
-        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+
-                                 read_init_data_cb, NULL);
+		r = libusb_submit_transfer(transfer);
+		if (r < 0) {
+			g_free(data);
+			libusb_free_transfer(transfer);
+			fpi_ssm_mark_failed(ssm, r);
+		}
 	}
 	break;
 	}
 }
 
-static void
+static void activate_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = user_data;
+	fp_dbg("status %d", fpi_ssm_get_error(ssm));
+	fpi_imgdev_activate_complete(dev, fpi_ssm_get_error(ssm));
 
-  fpi_image_device_activate_complete (dev, error);
+	if (!fpi_ssm_get_error(ssm))
-
-  if (!error)
 		start_finger_detection(dev);
+	fpi_ssm_free(ssm);
 }
 
 
 /****** FINGER PRESENCE DETECTION ******/
 
-static int
+static int finger_present(unsigned char *img, size_t len, int sum_threshold)
-finger_present (unsigned char *img, size_t len, int sum_threshold)
 {
 	int i, sum;
 
 	sum = 0;
 
-  for (i = 0; i < len; i++)
+	for (i = 0; i < len; i++) {
-    if (img[i] < 160)
+		if (img[i] < 160) {
 			sum++;
+		}
+	}
 
 	fp_dbg("finger_present: sum is %d\n", sum);
 	return sum < sum_threshold ? 0 : 1;
 }
 
-static void
+static void finger_det_data_cb(struct libusb_transfer *transfer)
-finger_det_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                    gpointer user_data, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
+	struct fp_img_dev *dev = transfer->user_data;
-  FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (dev);
+	struct upektc_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
+	unsigned char *data = transfer->buffer;
 
-  if (error)
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
-    {
+		fp_dbg("data transfer status %d\n", transfer->status);
-      fp_dbg ("data transfer status %s\n", error->message);
+		fpi_imgdev_session_error(dev, -EIO);
-      fpi_image_device_session_error (dev, error);
+		goto out;
-      return;
+	} else if (transfer->length != transfer->actual_length) {
+		fp_dbg("expected %d, got %d bytes", transfer->length,
+			transfer->actual_length);
+		fpi_imgdev_session_error(dev, -EPROTO);
 	}
 
-  if (finger_present (transfer->buffer, IMAGE_SIZE, self->sum_threshold))
+	if (finger_present(data, IMAGE_SIZE, upekdev->sum_threshold)) {
-    {
 		/* finger present, start capturing */
-      fpi_image_device_report_finger_status (dev, TRUE);
+		fpi_imgdev_report_finger_status(dev, TRUE);
 		start_capture(dev);
-    }
+	} else {
-  else
-    {
 		/* no finger, poll for a new histogram */
 		start_finger_detection(dev);
 	}
+
+out:
+	g_free(data);
+	libusb_free_transfer(transfer);
 }
 
-static void
+static void finger_det_cmd_cb(struct libusb_transfer *t)
-finger_det_cmd_cb (FpiUsbTransfer *t, FpDevice *device,
-                   gpointer user_data, GError *error)
 {
-  FpiUsbTransfer *transfer;
+	struct libusb_transfer *transfer;
-  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
+	unsigned char *data;
-  FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (dev);
+	int r;
+	struct fp_img_dev *dev = t->user_data;
+	struct upektc_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
 
-  if (error)
+	if (t->status != LIBUSB_TRANSFER_COMPLETED) {
-    {
+		fp_dbg("req transfer status %d\n", t->status);
-      fp_dbg ("req transfer status %s\n", error->message);
+		fpi_imgdev_session_error(dev, -EIO);
-      fpi_image_device_session_error (dev, error);
+		goto exit_free_transfer;
-      return;
+	} else if (t->length != t->actual_length) {
+		fp_dbg("expected %d, sent %d bytes", t->length, t->actual_length);
+		fpi_imgdev_session_error(dev, -EPROTO);
+		goto exit_free_transfer;
 	}
 
-  transfer = fpi_usb_transfer_new (device);
+	transfer = fpi_usb_alloc();
-  transfer->short_is_error = TRUE;
+	data = g_malloc(IMAGE_SIZE);
-  fpi_usb_transfer_fill_bulk (transfer, self->ep_in,
+	libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), upekdev->ep_in, data, IMAGE_SIZE,
-                              IMAGE_SIZE);
+		finger_det_data_cb, dev, BULK_TIMEOUT);
-  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+
-                           finger_det_data_cb, NULL);
+	r = libusb_submit_transfer(transfer);
+	if (r < 0) {
+		g_free(data);
+		libusb_free_transfer(transfer);
+		fpi_imgdev_session_error(dev, r);
+	}
+exit_free_transfer:
+	libusb_free_transfer(t);
 }
 
-static void
+static void start_finger_detection(struct fp_img_dev *dev)
-start_finger_detection (FpImageDevice *dev)
 {
-  FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (dev);
+	int r;
-  FpiUsbTransfer *transfer;
+	struct upektc_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
-
+	struct libusb_transfer *transfer;
 	G_DEBUG_HERE();
 
-  if (self->deactivating)
+	if (upekdev->deactivating) {
-    {
+		complete_deactivation(dev);
-      complete_deactivation (dev, NULL);
 		return;
 	}
 
-  transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
+	transfer = fpi_usb_alloc();
-  transfer->short_is_error = TRUE;
+	libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), upekdev->ep_out,
-  fpi_usb_transfer_fill_bulk_full (transfer, self->ep_out,
+		(unsigned char *)scan_cmd, UPEKTC_CMD_LEN,
-                                   (unsigned char *) scan_cmd,
+		finger_det_cmd_cb, dev, BULK_TIMEOUT);
-                                   UPEKTC_CMD_LEN, NULL);
+	r = libusb_submit_transfer(transfer);
-  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+	if (r < 0) {
-                           finger_det_cmd_cb, NULL);
+		libusb_free_transfer(transfer);
+		fpi_imgdev_session_error(dev, r);
+	}
 }
 
 /****** CAPTURE ******/
@@ -256,208 +266,213 @@ enum capture_states {
 	CAPTURE_NUM_STATES,
 };
 
-static void
+static void capture_cmd_cb(struct libusb_transfer *transfer)
-capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                      gpointer user_data, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
+	fpi_ssm *ssm = transfer->user_data;
-  FpImage *img;
 
-  if (error)
+	if ((transfer->status == LIBUSB_TRANSFER_COMPLETED) &&
-    {
+		(transfer->length == transfer->actual_length)) {
-      fp_dbg ("request is not completed, %s", error->message);
+		fpi_ssm_next_state(ssm);
-      fpi_ssm_mark_failed (transfer->ssm, error);
+	} else {
-      return;
+		fpi_ssm_mark_failed(ssm, -EIO);
+	}
+	libusb_free_transfer(transfer);
 }
 
-  img = fp_image_new (IMAGE_WIDTH, IMAGE_HEIGHT);
+static void capture_read_data_cb(struct libusb_transfer *transfer)
-  memcpy (img->data, transfer->buffer, IMAGE_SIZE);
+{
-  fpi_image_device_image_captured (dev, img);
+	fpi_ssm *ssm = transfer->user_data;
-  fpi_image_device_report_finger_status (dev, FALSE);
+	struct fp_img_dev *dev = fpi_ssm_get_user_data(ssm);
-  fpi_ssm_mark_completed (transfer->ssm);
+	unsigned char *data = transfer->buffer;
+	struct fp_img *img;
+
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
+		fp_dbg("request is not completed, %d", transfer->status);
+		fpi_ssm_mark_failed(ssm, -EIO);
+		goto out;
+	} else if (transfer->length != transfer->actual_length) {
+		fp_dbg("expected %d, sent %d bytes", transfer->length, transfer->actual_length);
+		fpi_ssm_mark_failed(ssm, -EPROTO);
+		goto out;
 	}
 
-static void
+	img = fpi_img_new(IMAGE_SIZE);
-capture_run_state (FpiSsm *ssm, FpDevice *_dev)
+	memcpy(img->data, data, IMAGE_SIZE);
-{
+	fpi_imgdev_image_captured(dev, img);
-  FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (_dev);
+	fpi_imgdev_report_finger_status(dev, FALSE);
+	fpi_ssm_mark_completed(ssm);
+out:
+	g_free(transfer->buffer);
+	libusb_free_transfer(transfer);
+}
 
-  switch (fpi_ssm_get_cur_state (ssm))
+static void capture_run_state(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
 {
+	struct fp_img_dev *dev = user_data;
+	struct upektc_dev *upekdev = FP_INSTANCE_DATA(_dev);
+	int r;
+
+	switch (fpi_ssm_get_cur_state(ssm)) {
 	case CAPTURE_WRITE_CMD:
 	{
-        FpiUsbTransfer *transfer = fpi_usb_transfer_new (_dev);
+		struct libusb_transfer *transfer = fpi_usb_alloc();
 
-        fpi_usb_transfer_fill_bulk_full (transfer, self->ep_out,
+		libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), upekdev->ep_out,
-                                         (unsigned char *) scan_cmd,
+			(unsigned char *)scan_cmd, UPEKTC_CMD_LEN,
-                                         UPEKTC_CMD_LEN, NULL);
+			capture_cmd_cb, ssm, BULK_TIMEOUT);
-        transfer->ssm = ssm;
+		r = libusb_submit_transfer(transfer);
-        transfer->short_is_error = TRUE;
+		if (r < 0) {
-        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+			libusb_free_transfer(transfer);
-                                 fpi_ssm_usb_transfer_cb, NULL);
+			fpi_ssm_mark_failed(ssm, -ENOMEM);
+		}
 	}
 	break;
-
 	case CAPTURE_READ_DATA:
 	{
-        FpiUsbTransfer *transfer = fpi_usb_transfer_new (_dev);
+		struct libusb_transfer *transfer = fpi_usb_alloc();
+		unsigned char *data;
 
-        fpi_usb_transfer_fill_bulk (transfer, self->ep_in,
+		data = g_malloc(IMAGE_SIZE);
-                                    IMAGE_SIZE);
+		libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), upekdev->ep_in, data, IMAGE_SIZE,
-        transfer->ssm = ssm;
+			capture_read_data_cb, ssm, BULK_TIMEOUT);
-        transfer->short_is_error = TRUE;
+
-        fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
+		r = libusb_submit_transfer(transfer);
-                                 capture_read_data_cb, NULL);
+		if (r < 0) {
+			g_free(data);
+			libusb_free_transfer(transfer);
+			fpi_ssm_mark_failed(ssm, r);
+		}
 	}
 	break;
-    }
+	};
-  ;
 }
 
-static void
+static void capture_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = user_data;
-  FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (_dev);
+	struct upektc_dev *upekdev = FP_INSTANCE_DATA(_dev);
 
 	fp_dbg("Capture completed");
-  if (self->deactivating)
+	if (upekdev->deactivating)
-    complete_deactivation (dev, error);
+		complete_deactivation(dev);
-  else if (error)
+	else if (fpi_ssm_get_error(ssm))
-    fpi_image_device_session_error (dev, error);
+		fpi_imgdev_session_error(dev, fpi_ssm_get_error(ssm));
 	else
 		start_finger_detection(dev);
-
+	fpi_ssm_free(ssm);
 }
 
-static void
+static void start_capture(struct fp_img_dev *dev)
-start_capture (FpImageDevice *dev)
 {
-  FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (dev);
+	struct upektc_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpiSsm *ssm;
+	fpi_ssm *ssm;
 
-  if (self->deactivating)
+	if (upekdev->deactivating) {
-    {
+		complete_deactivation(dev);
-      complete_deactivation (dev, NULL);
 		return;
 	}
 
-  ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state, CAPTURE_NUM_STATES);
+	ssm = fpi_ssm_new(FP_DEV(dev), capture_run_state, CAPTURE_NUM_STATES, dev);
 	G_DEBUG_HERE();
 	fpi_ssm_start(ssm, capture_sm_complete);
 }
 
-static void
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
-dev_activate (FpImageDevice *dev)
 {
-  FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (dev);
+	struct upektc_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state,
+	fpi_ssm *ssm = fpi_ssm_new(FP_DEV(dev), activate_run_state,
-                             ACTIVATE_NUM_STATES);
+		ACTIVATE_NUM_STATES, dev);
-
+	upekdev->init_idx = 0;
-  self->init_idx = 0;
 	fpi_ssm_start(ssm, activate_sm_complete);
+	return 0;
 }
 
-static void
+static void dev_deactivate(struct fp_img_dev *dev)
-dev_deactivate (FpImageDevice *dev)
 {
-  FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (dev);
+	struct upektc_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
 
-  self->deactivating = TRUE;
+	upekdev->deactivating = TRUE;
 }
 
-static void
+static void complete_deactivation(struct fp_img_dev *dev)
-complete_deactivation (FpImageDevice *dev, GError *error)
 {
-  FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (dev);
+	struct upektc_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
-
 	G_DEBUG_HERE();
 
-  self->deactivating = FALSE;
+	upekdev->deactivating = FALSE;
-  fpi_image_device_deactivate_complete (dev, error);
+	fpi_imgdev_deactivate_complete(dev);
 }
 
-static void
+static int dev_init(struct fp_img_dev *dev, unsigned long driver_data)
-dev_init (FpImageDevice *dev)
 {
-  GError *error = NULL;
-  FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (dev);
-  guint64 driver_data = fpi_device_get_driver_data (FP_DEVICE (dev));
-
 	/* TODO check that device has endpoints we're using */
+	int r;
+	struct upektc_dev *upekdev;
 
-  if (!g_usb_device_claim_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error))
+	r = libusb_claim_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
-    {
+	if (r < 0) {
-      fpi_image_device_open_complete (dev, error);
+		fp_err("could not claim interface 0: %s", libusb_error_name(r));
-      return;
+		return r;
 	}
 
-  switch (driver_data)
+	upekdev = g_malloc0(sizeof(struct upektc_dev));
-    {
+	fp_dev_set_instance_data(FP_DEV(dev), upekdev);
+	switch (driver_data) {
 	case UPEKTC_2015:
-      self->ep_in = UPEKTC_EP_IN;
+		upekdev->ep_in = UPEKTC_EP_IN;
-      self->ep_out = UPEKTC_EP_OUT;
+		upekdev->ep_out = UPEKTC_EP_OUT;
-      self->setup_commands = upektc_setup_commands;
+		upekdev->setup_commands = upektc_setup_commands;
-      self->setup_commands_len = G_N_ELEMENTS (upektc_setup_commands);
+		upekdev->setup_commands_len = G_N_ELEMENTS(upektc_setup_commands);
-      self->sum_threshold = UPEKTC_SUM_THRESHOLD;
+		upekdev->sum_threshold = UPEKTC_SUM_THRESHOLD;
 		break;
-
 	case UPEKTC_3001:
-      self->ep_in = UPEKET_EP_IN;
+		upekdev->ep_in = UPEKET_EP_IN;
-      self->ep_out = UPEKET_EP_OUT;
+		upekdev->ep_out = UPEKET_EP_OUT;
-      self->setup_commands = upeket_setup_commands;
+		upekdev->setup_commands = upeket_setup_commands;
-      self->setup_commands_len = G_N_ELEMENTS (upeket_setup_commands);
+		upekdev->setup_commands_len = G_N_ELEMENTS(upeket_setup_commands);
-      self->sum_threshold = UPEKET_SUM_THRESHOLD;
+		upekdev->sum_threshold = UPEKET_SUM_THRESHOLD;
 		break;
-
 	default:
 		fp_err("Device variant %lu is not known\n", driver_data);
-      g_assert_not_reached ();
+		g_free(upekdev);
-      fpi_image_device_open_complete (dev, fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
+		fp_dev_set_instance_data(FP_DEV(dev), NULL);
-      return;
+		return -ENODEV;
+		break;
 	}
-  fpi_image_device_open_complete (dev, NULL);
+	fpi_imgdev_open_complete(dev, 0);
+	return 0;
 }
 
-static void
+static void dev_deinit(struct fp_img_dev *dev)
-dev_deinit (FpImageDevice *dev)
 {
-  GError *error = NULL;
+	void *user_data;
-
+	user_data = FP_INSTANCE_DATA(FP_DEV(dev));
-  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)),
+	g_free(user_data);
-                                  0, 0, &error);
+	libusb_release_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
-  fpi_image_device_close_complete (dev, error);
+	fpi_imgdev_close_complete(dev);
 }
 
-static const FpIdEntry id_table[] = {
+static const struct usb_id id_table[] = {
-  { .vid = 0x0483,  .pid = 0x2015, .driver_data = UPEKTC_2015 },
+	{ .vendor = 0x0483, .product = 0x2015, .driver_data = UPEKTC_2015 },
-  { .vid = 0x147e,  .pid = 0x3001, .driver_data = UPEKTC_3001 },
+	{ .vendor = 0x147e, .product = 0x3001, .driver_data = UPEKTC_3001 },
-  { .vid = 0,  .pid = 0,  .driver_data = 0 },
+	{ 0, 0, 0, },
 };
 
-static void
+struct fp_img_driver upektc_driver = {
-fpi_device_upektc_init (FpiDeviceUpektc *self)
+	.driver = {
-{
+		.id = UPEKTC_ID,
-}
+		.name = FP_COMPONENT,
-static void
+		.full_name = "UPEK TouchChip/Eikon Touch 300",
-fpi_device_upektc_class_init (FpiDeviceUpektcClass *klass)
+		.id_table = id_table,
-{
+		.scan_type = FP_SCAN_TYPE_PRESS,
-  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
+	},
-  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
+	.flags = 0,
+	.img_height = IMAGE_HEIGHT,
+	.img_width = IMAGE_WIDTH,
 
-  dev_class->id = "upektc";
+	.bz3_threshold = 30,
-  dev_class->full_name = "UPEK TouchChip/Eikon Touch 300";
+	.open = dev_init,
-  dev_class->type = FP_DEVICE_TYPE_USB;
+	.close = dev_deinit,
-  dev_class->id_table = id_table;
+	.activate = dev_activate,
-  dev_class->scan_type = FP_SCAN_TYPE_PRESS;
+	.deactivate = dev_deactivate,
-
+};
-  img_class->img_open = dev_init;
-  img_class->img_close = dev_deinit;
-  img_class->activate = dev_activate;
-  img_class->deactivate = dev_deactivate;
-
-  img_class->bz3_threshold = 30;
-
-  img_class->img_width = IMAGE_WIDTH;
-  img_class->img_height = IMAGE_HEIGHT;
-}

libfprint/drivers/upektc.h

@@ -19,7 +19,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
+#ifndef __UPEKTC_H
+#define __UPEKTC_H
 
 #define UPEKTC_CMD_LEN 0x40
 #define IMAGE_WIDTH 208
@@ -28,8 +29,7 @@
 #define UPEKTC_SUM_THRESHOLD 10000
 #define UPEKET_SUM_THRESHOLD 5000
 
-struct setup_cmd
+struct setup_cmd {
-{
 	unsigned char cmd[0x40];
 	int response_len;
 };
@@ -1935,3 +1935,5 @@ static const unsigned char scan_cmd[0x40] = {
 	0x05, 0x90, 0xf6, 0x77, 0x84, 0xf5, 0x2f, 0x01,
 	0x05, 0x90, 0xf6, 0x00, 0xc8, 0x00, 0xec, 0x00
 };
+
+#endif

libfprint/drivers/upektc_img.c

@@ -21,13 +21,14 @@
 
 #include "drivers_api.h"
 #include "upek_proto.h"
+#include "aeslib.h"
 #include "upektc_img.h"
 
-static void start_capture (FpImageDevice *dev);
+static void start_capture(struct fp_img_dev *dev);
-static void start_deactivation (FpImageDevice *dev);
+static void start_deactivation(struct fp_img_dev *dev);
 
-#define EP_IN (1 | FPI_USB_ENDPOINT_IN)
+#define EP_IN			(1 | LIBUSB_ENDPOINT_IN)
-#define EP_OUT (2 | FPI_USB_ENDPOINT_OUT)
+#define EP_OUT			(2 | LIBUSB_ENDPOINT_OUT)
 #define CTRL_TIMEOUT		4000
 #define BULK_TIMEOUT		4000
 
@@ -39,26 +40,19 @@ static void start_deactivation (FpImageDevice *dev);
 #define MAX_RESPONSE_SIZE	2052
 #define SHORT_RESPONSE_SIZE	64
 
-struct _FpiDeviceUpektcImg
+struct upektc_img_dev {
-{
-  FpImageDevice  parent;
-
 	unsigned char cmd[MAX_CMD_SIZE];
 	unsigned char response[MAX_RESPONSE_SIZE];
-  unsigned char *image_bits;
+	unsigned char image_bits[IMAGE_SIZE * 2];
 	unsigned char seq;
 	size_t image_size;
 	size_t response_rest;
 	gboolean deactivating;
 };
-G_DECLARE_FINAL_TYPE (FpiDeviceUpektcImg, fpi_device_upektc_img, FPI,
-                      DEVICE_UPEKTC_IMG, FpImageDevice);
-G_DEFINE_TYPE (FpiDeviceUpektcImg, fpi_device_upektc_img, FP_TYPE_IMAGE_DEVICE);
 
 /****** HELPERS ******/
 
-static void
+static void upektc_img_cmd_fix_seq(unsigned char *cmd_buf, unsigned char seq)
-upektc_img_cmd_fix_seq (unsigned char *cmd_buf, unsigned char seq)
 {
 	uint8_t byte;
 
@@ -68,8 +62,7 @@ upektc_img_cmd_fix_seq (unsigned char *cmd_buf, unsigned char seq)
 	cmd_buf[5] = byte;
 }
 
-static void
+static void upektc_img_cmd_update_crc(unsigned char *cmd_buf, size_t size)
-upektc_img_cmd_update_crc (unsigned char *cmd_buf, size_t size)
 {
 	/* CRC does not cover Ciao prefix (4 bytes) and CRC location (2 bytes) */
 	uint16_t crc = udf_crc(cmd_buf + 4, size - 6);
@@ -79,46 +72,58 @@ upektc_img_cmd_update_crc (unsigned char *cmd_buf, size_t size)
 }
 
 static void
-upektc_img_submit_req (FpiSsm                *ssm,
+upektc_img_submit_req(fpi_ssm               *ssm,
-                       FpImageDevice         *dev,
+		      struct fp_img_dev     *dev,
 		      const unsigned char   *buf,
 		      size_t                 buf_size,
 		      unsigned char          seq,
-                       FpiUsbTransferCallback cb)
+		      libusb_transfer_cb_fn  cb)
 {
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
+	struct upektc_img_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpiUsbTransfer *transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
+	struct libusb_transfer *transfer = fpi_usb_alloc();
+	int r;
 
 	BUG_ON(buf_size > MAX_CMD_SIZE);
 
-  memcpy (self->cmd, buf, buf_size);
+	transfer->flags |= LIBUSB_TRANSFER_FREE_TRANSFER;
-  upektc_img_cmd_fix_seq (self->cmd, seq);
-  upektc_img_cmd_update_crc (self->cmd, buf_size);
 
-  fpi_usb_transfer_fill_bulk_full (transfer, EP_OUT, self->cmd, buf_size,
+	memcpy(upekdev->cmd, buf, buf_size);
-                                   NULL);
+	upektc_img_cmd_fix_seq(upekdev->cmd, seq);
-  transfer->ssm = ssm;
+	upektc_img_cmd_update_crc(upekdev->cmd, buf_size);
-  transfer->short_is_error = TRUE;
+
-  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL, cb, NULL);
+	libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), EP_OUT, upekdev->cmd, buf_size,
+		cb, ssm, BULK_TIMEOUT);
+
+	r = libusb_submit_transfer(transfer);
+	if (r < 0) {
+		libusb_free_transfer(transfer);
+		fpi_ssm_mark_failed(ssm, r);
+	}
 }
 
 static void
-upektc_img_read_data (FpiSsm                *ssm,
+upektc_img_read_data(fpi_ssm               *ssm,
-                      FpImageDevice         *dev,
+		     struct fp_img_dev     *dev,
 		     size_t                 buf_size,
 		     size_t                 buf_offset,
-                      FpiUsbTransferCallback cb)
+		     libusb_transfer_cb_fn  cb)
 {
-  FpiUsbTransfer *transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
+	struct libusb_transfer *transfer = fpi_usb_alloc();
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
+	struct upektc_img_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
+	int r;
 
-  BUG_ON (buf_offset + buf_size > MAX_RESPONSE_SIZE);
+	BUG_ON(buf_size > MAX_RESPONSE_SIZE);
 
-  fpi_usb_transfer_fill_bulk_full (transfer, EP_IN,
+	transfer->flags |= LIBUSB_TRANSFER_FREE_TRANSFER;
-                                   self->response + buf_offset, buf_size,
+
-                                   NULL);
+	libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), EP_IN, upekdev->response + buf_offset, buf_size,
-  transfer->ssm = ssm;
+		cb, ssm, BULK_TIMEOUT);
-  fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL, cb, NULL);
+
+	r = libusb_submit_transfer(transfer);
+	if (r < 0) {
+		libusb_free_transfer(transfer);
+		fpi_ssm_mark_failed(ssm, r);
+	}
 }
 
 /****** CAPTURE ******/
@@ -134,280 +139,230 @@ enum capture_states {
 	CAPTURE_NUM_STATES,
 };
 
-static void
+static void capture_reqs_cb(struct libusb_transfer *transfer)
-capture_reqs_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                 gpointer user_data, GError *error)
 {
-  if (error)
+	fpi_ssm *ssm = transfer->user_data;
-    {
+
-      fpi_ssm_mark_failed (transfer->ssm, error);
+	if ((transfer->status != LIBUSB_TRANSFER_COMPLETED) ||
+		(transfer->length != transfer->actual_length)) {
+		fpi_ssm_mark_failed(ssm, -EIO);
 		return;
 	}
-  switch (fpi_ssm_get_cur_state (transfer->ssm))
+	switch (fpi_ssm_get_cur_state(ssm)) {
-    {
 	case CAPTURE_ACK_00_28_TERM:
-      fpi_ssm_jump_to_state (transfer->ssm, CAPTURE_READ_DATA_TERM);
+		fpi_ssm_jump_to_state(ssm, CAPTURE_READ_DATA_TERM);
 		break;
-
 	default:
-      fpi_ssm_jump_to_state (transfer->ssm, CAPTURE_READ_DATA);
+		fpi_ssm_jump_to_state(ssm, CAPTURE_READ_DATA);
 		break;
 	}
 }
 
-static int
+static int upektc_img_process_image_frame(unsigned char *image_buf, unsigned char *cmd_res)
-upektc_img_process_image_frame (unsigned char *image_buf, unsigned char *cmd_res)
 {
 	int offset = 8;
 	int len = ((cmd_res[5] & 0x0f) << 8) | (cmd_res[6]);
 
 	len -= 1;
-  if (cmd_res[7] == 0x2c)
+	if (cmd_res[7] == 0x2c) {
-    {
 		len -= 10;
 		offset += 10;
 	}
-  if (cmd_res[7] == 0x20)
+	if (cmd_res[7] == 0x20) {
 		len -= 4;
+	}
 	memcpy(image_buf, cmd_res + offset, len);
 
 	return len;
 }
 
-static void
+static void capture_read_data_cb(struct libusb_transfer *transfer)
-capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                      gpointer user_data, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
+	fpi_ssm *ssm = transfer->user_data;
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
+	struct fp_img_dev *dev = fpi_ssm_get_user_data(ssm);
-  unsigned char *data = self->response;
+	struct upektc_img_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpImage *img;
+	unsigned char *data = upekdev->response;
+	struct fp_img *img;
 	size_t response_size;
 
-  if (error)
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
-    {
+		fp_dbg("request is not completed, %d", transfer->status);
-      fp_dbg ("request is not completed, %s", error->message);
+		fpi_ssm_mark_failed(ssm, -EIO);
-      fpi_ssm_mark_failed (transfer->ssm, error);
 		return;
 	}
 
-  if (self->deactivating)
+	if (upekdev->deactivating) {
-    {
 		fp_dbg("Deactivate requested\n");
-      fpi_ssm_mark_completed (transfer->ssm);
+		fpi_ssm_mark_completed(ssm);
 		return;
 	}
 
-  fp_dbg ("request completed, len: %.4x", (gint) transfer->actual_length);
+	fp_dbg("request completed, len: %.4x", transfer->actual_length);
-  if (transfer->actual_length == 0)
+	if (transfer->actual_length == 0) {
-    {
+		fpi_ssm_jump_to_state(ssm, fpi_ssm_get_cur_state(ssm));
-      fpi_ssm_jump_to_state (transfer->ssm,
-                             fpi_ssm_get_cur_state (transfer->ssm));
 		return;
 	}
 
-  if (fpi_ssm_get_cur_state (transfer->ssm) == CAPTURE_READ_DATA_TERM)
+	if (fpi_ssm_get_cur_state(ssm) == CAPTURE_READ_DATA_TERM) {
-    {
 		fp_dbg("Terminating SSM\n");
-      fpi_ssm_mark_completed (transfer->ssm);
+		fpi_ssm_mark_completed(ssm);
 		return;
 	}
 
-  if (!self->response_rest)
+	if (!upekdev->response_rest) {
-    {
 		response_size = ((data[5] & 0x0f) << 8) + data[6];
 		response_size += 9; /* 7 bytes for header, 2 for CRC */
-      if (response_size > transfer->actual_length)
+		if (response_size > transfer->actual_length) {
-        {
 			fp_dbg("response_size is %lu, actual_length is %d\n",
-                  response_size, (gint) transfer->actual_length);
+				response_size, transfer->actual_length);
 			fp_dbg("Waiting for rest of transfer");
-          BUG_ON (self->response_rest);
+			BUG_ON(upekdev->response_rest);
-          self->response_rest = response_size - transfer->actual_length;
+			upekdev->response_rest = response_size - transfer->actual_length;
-          fpi_ssm_jump_to_state (transfer->ssm, CAPTURE_READ_DATA);
+			fpi_ssm_jump_to_state(ssm, CAPTURE_READ_DATA);
 			return;
 		}
 	}
-  self->response_rest = 0;
+	upekdev->response_rest = 0;
 
-  switch (data[4])
+	switch (data[4]) {
-    {
 	case 0x00:
-      switch (data[7])
+		switch (data[7]) {
-        {
 			/* No finger */
 			case 0x28:
 				fp_dbg("18th byte is %.2x\n", data[18]);
-          switch (data[18])
+				switch (data[18]) {
-            {
 				case 0x0c:
 					/* no finger */
-              fpi_ssm_jump_to_state (transfer->ssm,
+					fpi_ssm_jump_to_state(ssm, CAPTURE_ACK_00_28);
-                                     CAPTURE_ACK_00_28);
 					break;
-
 				case 0x00:
 					/* finger is present! */
-              fpi_ssm_jump_to_state (transfer->ssm,
+					fpi_ssm_jump_to_state(ssm, CAPTURE_ACK_00_28);
-                                     CAPTURE_ACK_00_28);
 					break;
-
 				case 0x1e:
 					/* short scan */
 					fp_err("short scan, aborting\n");
-              fpi_image_device_retry_scan (dev,
+					fpi_imgdev_abort_scan(dev, FP_VERIFY_RETRY_TOO_SHORT);
-                                           FP_DEVICE_RETRY_TOO_SHORT);
+					fpi_imgdev_report_finger_status(dev, FALSE);
-              fpi_image_device_report_finger_status (dev,
+					fpi_ssm_jump_to_state(ssm, CAPTURE_ACK_00_28_TERM);
-                                                     FALSE);
-              fpi_ssm_jump_to_state (transfer->ssm,
-                                     CAPTURE_ACK_00_28_TERM);
 					break;
-
 				case 0x1d:
 					/* too much horisontal movement */
 					fp_err("too much horisontal movement, aborting\n");
-              fpi_image_device_retry_scan (dev,
+					fpi_imgdev_abort_scan(dev, FP_VERIFY_RETRY_CENTER_FINGER);
-                                           FP_DEVICE_RETRY_CENTER_FINGER);
+					fpi_imgdev_report_finger_status(dev, FALSE);
-              fpi_image_device_report_finger_status (dev,
+					fpi_ssm_jump_to_state(ssm, CAPTURE_ACK_00_28_TERM);
-                                                     FALSE);
-              fpi_ssm_jump_to_state (transfer->ssm,
-                                     CAPTURE_ACK_00_28_TERM);
 					break;
-
 				default:
 					/* some error happened, cancel scan */
 					fp_err("something bad happened, stop scan\n");
-              fpi_image_device_retry_scan (dev,
+					fpi_imgdev_abort_scan(dev, FP_VERIFY_RETRY);
-                                           FP_DEVICE_RETRY);
+					fpi_imgdev_report_finger_status(dev, FALSE);
-              fpi_image_device_report_finger_status (dev,
+					fpi_ssm_jump_to_state(ssm, CAPTURE_ACK_00_28_TERM);
-                                                     FALSE);
-              fpi_ssm_jump_to_state (transfer->ssm,
-                                     CAPTURE_ACK_00_28_TERM);
 					break;
 				}
 				break;
-
 			/* Image frame with additional info */
 			case 0x2c:
-          fpi_image_device_report_finger_status (dev,
+				fpi_imgdev_report_finger_status(dev, TRUE);
-                                                 TRUE);
-
 			/* Plain image frame */
 			case 0x24:
-          self->image_size +=
+				upekdev->image_size +=
-            upektc_img_process_image_frame (self->image_bits + self->image_size,
+					upektc_img_process_image_frame(upekdev->image_bits + upekdev->image_size,
 						data);
-          fpi_ssm_jump_to_state (transfer->ssm,
+				fpi_ssm_jump_to_state(ssm, CAPTURE_ACK_FRAME);
-                                 CAPTURE_ACK_FRAME);
 				break;
-
 			/* Last image frame */
 			case 0x20:
-          self->image_size +=
+				upekdev->image_size +=
-            upektc_img_process_image_frame (self->image_bits + self->image_size,
+					upektc_img_process_image_frame(upekdev->image_bits + upekdev->image_size,
 						data);
-          BUG_ON (self->image_size != IMAGE_SIZE);
+				BUG_ON(upekdev->image_size != IMAGE_SIZE);
-          fp_dbg ("Image size is %lu\n",
+				fp_dbg("Image size is %lu\n", upekdev->image_size);
-                  self->image_size);
+				img = fpi_img_new(IMAGE_SIZE);
-          img = fp_image_new (IMAGE_WIDTH, IMAGE_HEIGHT);
+				img->flags = FP_IMG_PARTIAL;
-          img->flags |= FPI_IMAGE_PARTIAL;
+				memcpy(img->data, upekdev->image_bits, IMAGE_SIZE);
-          memcpy (img->data, self->image_bits,
+				fpi_imgdev_image_captured(dev, img);
-                  IMAGE_SIZE);
+				fpi_imgdev_report_finger_status(dev, FALSE);
-          fpi_image_device_image_captured (dev, img);
+				fpi_ssm_mark_completed(ssm);
-          fpi_image_device_report_finger_status (dev,
-                                                 FALSE);
-          fpi_ssm_mark_completed (transfer->ssm);
 				break;
-
 			default:
-          fp_err ("Unknown response!\n");
+				fp_err("Uknown response!\n");
-          fpi_ssm_mark_failed (transfer->ssm, fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
+				fpi_ssm_mark_failed(ssm, -EIO);
 				break;
 		}
 		break;
-
 	case 0x08:
-      fpi_ssm_jump_to_state (transfer->ssm, CAPTURE_ACK_08);
+		fpi_ssm_jump_to_state(ssm, CAPTURE_ACK_08);
 		break;
-
 	default:
 		fp_err("Not handled response!\n");
-      fpi_ssm_mark_failed (transfer->ssm, fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
+		fpi_ssm_mark_failed(ssm, -EIO);
 	}
 }
 
-static void
+static void capture_run_state(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-capture_run_state (FpiSsm *ssm, FpDevice *_dev)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = user_data;
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev);
+	struct upektc_img_dev *upekdev = FP_INSTANCE_DATA(_dev);
 
-  switch (fpi_ssm_get_cur_state (ssm))
+	switch (fpi_ssm_get_cur_state(ssm)) {
-    {
 	case CAPTURE_INIT_CAPTURE:
 		upektc_img_submit_req(ssm, dev, upek2020_init_capture, sizeof(upek2020_init_capture),
-                             self->seq, capture_reqs_cb);
+			upekdev->seq, capture_reqs_cb);
-      self->seq++;
+			upekdev->seq++;
 		break;
-
 	case CAPTURE_READ_DATA:
 	case CAPTURE_READ_DATA_TERM:
-      if (!self->response_rest)
+		if (!upekdev->response_rest)
 			upektc_img_read_data(ssm, dev, SHORT_RESPONSE_SIZE, 0, capture_read_data_cb);
 		else
 			upektc_img_read_data(ssm, dev, MAX_RESPONSE_SIZE - SHORT_RESPONSE_SIZE,
 			SHORT_RESPONSE_SIZE, capture_read_data_cb);
 		break;
-
 	case CAPTURE_ACK_00_28:
 	case CAPTURE_ACK_00_28_TERM:
 		upektc_img_submit_req(ssm, dev, upek2020_ack_00_28, sizeof(upek2020_ack_00_28),
-                             self->seq, capture_reqs_cb);
+			upekdev->seq, capture_reqs_cb);
-      self->seq++;
+			upekdev->seq++;
 		break;
-
 	case CAPTURE_ACK_08:
 		upektc_img_submit_req(ssm, dev, upek2020_ack_08, sizeof(upek2020_ack_08),
 			0, capture_reqs_cb);
 		break;
-
 	case CAPTURE_ACK_FRAME:
 		upektc_img_submit_req(ssm, dev, upek2020_ack_frame, sizeof(upek2020_ack_frame),
-                             self->seq, capture_reqs_cb);
+			upekdev->seq, capture_reqs_cb);
-      self->seq++;
+			upekdev->seq++;
 		break;
-    }
+	};
-  ;
 }
 
-static void
+static void capture_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error_arg)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = user_data;
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev);
+	struct upektc_img_dev *upekdev = FP_INSTANCE_DATA(_dev);
+	int err = fpi_ssm_get_error(ssm);
 
-  g_autoptr(GError) error = error_arg;
+	fp_dbg("Capture completed, %d", err);
+	fpi_ssm_free(ssm);
 
-
+	if (upekdev->deactivating)
-  /* Note: We assume that the error is a cancellation in the deactivation case */
-  if (self->deactivating)
 		start_deactivation(dev);
-  else if (error)
+	else if (err)
-    fpi_image_device_session_error (dev, g_steal_pointer (&error));
+		fpi_imgdev_session_error(dev, err);
 	else
 		start_capture(dev);
 }
 
-static void
+static void start_capture(struct fp_img_dev *dev)
-start_capture (FpImageDevice *dev)
 {
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
+	struct upektc_img_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpiSsm *ssm;
+	fpi_ssm *ssm;
 
-  self->image_size = 0;
+	upekdev->image_size = 0;
 
-  ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state,
+	ssm = fpi_ssm_new(FP_DEV(dev), capture_run_state, CAPTURE_NUM_STATES, dev);
-                     CAPTURE_NUM_STATES);
 	fpi_ssm_start(ssm, capture_sm_complete);
 }
 
@@ -419,70 +374,73 @@ enum deactivate_states {
 	DEACTIVATE_NUM_STATES,
 };
 
-static void
+static void deactivate_reqs_cb(struct libusb_transfer *transfer)
-deactivate_reqs_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                    gpointer user_data, GError *error)
 {
-  if (!error)
+	fpi_ssm *ssm = transfer->user_data;
-    fpi_ssm_jump_to_state (transfer->ssm, CAPTURE_READ_DATA);
+
-  else
+	if ((transfer->status == LIBUSB_TRANSFER_COMPLETED) &&
-    fpi_ssm_mark_failed (transfer->ssm, error);
+		(transfer->length == transfer->actual_length)) {
+		fpi_ssm_jump_to_state(ssm, CAPTURE_READ_DATA);
+	} else {
+		fpi_ssm_mark_failed(ssm, -EIO);
+	}
 }
 
 /* TODO: process response properly */
-static void
+static void deactivate_read_data_cb(struct libusb_transfer *transfer)
-deactivate_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                         gpointer user_data, GError *error)
 {
-  if (!error)
+	fpi_ssm *ssm = transfer->user_data;
-    fpi_ssm_mark_completed (transfer->ssm);
+
-  else
+	if (transfer->status == LIBUSB_TRANSFER_COMPLETED) {
-    fpi_ssm_mark_failed (transfer->ssm, error);
+		fpi_ssm_mark_completed(ssm);
+	} else {
+		fpi_ssm_mark_failed(ssm, -EIO);
+	}
 }
 
-static void
+static void deactivate_run_state(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-deactivate_run_state (FpiSsm *ssm, FpDevice *_dev)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = user_data;
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev);
+	struct upektc_img_dev *upekdev = FP_INSTANCE_DATA(_dev);
 
-  switch (fpi_ssm_get_cur_state (ssm))
+	switch (fpi_ssm_get_cur_state(ssm)) {
-    {
 	case DEACTIVATE_DEINIT:
 		upektc_img_submit_req(ssm, dev, upek2020_deinit, sizeof(upek2020_deinit),
-                             self->seq, deactivate_reqs_cb);
+			upekdev->seq, deactivate_reqs_cb);
-      self->seq++;
+		upekdev->seq++;
 		break;
-
 	case DEACTIVATE_READ_DEINIT_DATA:
 		upektc_img_read_data(ssm, dev, SHORT_RESPONSE_SIZE, 0, deactivate_read_data_cb);
 		break;
-    }
+	};
-  ;
 }
 
-static void
+static void deactivate_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-deactivate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = user_data;
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev);
+	struct upektc_img_dev *upekdev = FP_INSTANCE_DATA(_dev);
+	int err = fpi_ssm_get_error(ssm);
 
 	fp_dbg("Deactivate completed");
+	fpi_ssm_free(ssm);
 
-  self->deactivating = FALSE;
+	if (err) {
-  fpi_image_device_deactivate_complete (dev,  error);
+		fpi_imgdev_session_error(dev, err);
+		return;
 	}
 
-static void
+	upekdev->deactivating = FALSE;
-start_deactivation (FpImageDevice *dev)
+	fpi_imgdev_deactivate_complete(dev);
+}
+
+static void start_deactivation(struct fp_img_dev *dev)
 {
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
+	struct upektc_img_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpiSsm *ssm;
+	fpi_ssm *ssm;
 
-  self->image_size = 0;
+	upekdev->image_size = 0;
 
-  ssm = fpi_ssm_new (FP_DEVICE (dev), deactivate_run_state,
+	ssm = fpi_ssm_new(FP_DEV(dev), deactivate_run_state, DEACTIVATE_NUM_STATES, dev);
-                     DEACTIVATE_NUM_STATES);
 	fpi_ssm_start(ssm, deactivate_sm_complete);
 }
 
@@ -502,75 +460,89 @@ enum activate_states {
 	ACTIVATE_NUM_STATES,
 };
 
-static void
+static void init_reqs_ctrl_cb(struct libusb_transfer *transfer)
-init_reqs_cb (FpiUsbTransfer *transfer, FpDevice *device,
-              gpointer user_data, GError *error)
 {
-  if (!error)
+	fpi_ssm *ssm = transfer->user_data;
-    fpi_ssm_next_state (transfer->ssm);
+
-  else
+	if (transfer->status == LIBUSB_TRANSFER_COMPLETED) {
-    fpi_ssm_mark_failed (transfer->ssm, error);
+		fpi_ssm_next_state(ssm);
+	} else {
+		fpi_ssm_mark_failed(ssm, -EIO);
+	}
+}
+
+static void init_reqs_cb(struct libusb_transfer *transfer)
+{
+	fpi_ssm *ssm = transfer->user_data;
+
+	if ((transfer->status == LIBUSB_TRANSFER_COMPLETED) &&
+		(transfer->length == transfer->actual_length)) {
+		fpi_ssm_next_state(ssm);
+	} else {
+		fpi_ssm_mark_failed(ssm, -EIO);
+	}
 }
 
 /* TODO: process response properly */
-static void
+static void init_read_data_cb(struct libusb_transfer *transfer)
-init_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
-                   gpointer user_data, GError *error)
 {
-  if (!error)
+	fpi_ssm *ssm = transfer->user_data;
-    fpi_ssm_next_state (transfer->ssm);
+
-  else
+	if (transfer->status == LIBUSB_TRANSFER_COMPLETED) {
-    fpi_ssm_mark_failed (transfer->ssm, error);
+		fpi_ssm_next_state(ssm);
+	} else {
+		fpi_ssm_mark_failed(ssm, -EIO);
+	}
 }
 
-static void
+static void activate_run_state(fpi_ssm *ssm, struct fp_dev *dev, void *user_data)
-activate_run_state (FpiSsm *ssm, FpDevice *dev)
 {
-  FpiUsbTransfer *transfer;
+	struct libusb_transfer *transfer;
-  FpImageDevice *idev = FP_IMAGE_DEVICE (dev);
+	struct fp_img_dev *idev = user_data;
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
+	struct upektc_img_dev *upekdev = FP_INSTANCE_DATA(dev);
+	int r;
 
-  switch (fpi_ssm_get_cur_state (ssm))
+	switch (fpi_ssm_get_cur_state(ssm)) {
-    {
 	case ACTIVATE_CONTROL_REQ_1:
 	case ACTIVATE_CONTROL_REQ_2:
 	{
-        transfer = fpi_usb_transfer_new (dev);
+		unsigned char *data;
 
-        fpi_usb_transfer_fill_control (transfer,
+		transfer = fpi_usb_alloc();
-                                       G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
+		transfer->flags |= LIBUSB_TRANSFER_FREE_BUFFER |
-                                       G_USB_DEVICE_REQUEST_TYPE_VENDOR,
+			LIBUSB_TRANSFER_FREE_TRANSFER;
-                                       G_USB_DEVICE_RECIPIENT_DEVICE,
+
-                                       0x0c, 0x100, 0x0400, 1);
+		data = g_malloc0(LIBUSB_CONTROL_SETUP_SIZE + 1);
-        transfer->buffer[0] = '\0';
+		libusb_fill_control_setup(data,
-        transfer->ssm = ssm;
+			LIBUSB_REQUEST_TYPE_VENDOR | LIBUSB_RECIPIENT_DEVICE, 0x0c, 0x100, 0x0400, 1);
-        fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL,
+		libusb_fill_control_transfer(transfer, fpi_dev_get_usb_dev(dev), data,
-                                 fpi_ssm_usb_transfer_cb, NULL);
+			init_reqs_ctrl_cb, ssm, CTRL_TIMEOUT);
+		r = libusb_submit_transfer(transfer);
+		if (r < 0) {
+			g_free(data);
+			libusb_free_transfer(transfer);
+			fpi_ssm_mark_failed(ssm, r);
+		}
 	}
 	break;
-
 	case ACTIVATE_INIT_1:
 		upektc_img_submit_req(ssm, idev, upek2020_init_1, sizeof(upek2020_init_1),
 			0, init_reqs_cb);
 	break;
-
 	case ACTIVATE_INIT_2:
 		upektc_img_submit_req(ssm, idev, upek2020_init_2, sizeof(upek2020_init_2),
 			0, init_reqs_cb);
 	break;
-
 	case ACTIVATE_INIT_3:
 		upektc_img_submit_req(ssm, idev, upek2020_init_3, sizeof(upek2020_init_3),
 			0, init_reqs_cb);
 	break;
-
 	case ACTIVATE_INIT_4:
 		upektc_img_submit_req(ssm, idev, upek2020_init_4, sizeof(upek2020_init_4),
-                             self->seq, init_reqs_cb);
+			upekdev->seq, init_reqs_cb);
 		/* Seq should be updated after 4th init */
-      self->seq++;
+		upekdev->seq++;
 	break;
-
 	case ACTIVATE_READ_CTRL_RESP_1:
 	case ACTIVATE_READ_CTRL_RESP_2:
 	case ACTIVATE_READ_INIT_1_RESP:
@@ -582,110 +554,94 @@ activate_run_state (FpiSsm *ssm, FpDevice *dev)
 	}
 }
 
-static void
+static void activate_sm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = user_data;
+	int err = fpi_ssm_get_error(ssm);
 
-  fpi_image_device_activate_complete (dev, error);
+	fpi_ssm_free(ssm);
+	fp_dbg("%s status %d", __func__, err);
+	fpi_imgdev_activate_complete(dev, err);
 
-  if (!error)
+	if (!err)
 		start_capture(dev);
 }
 
-static void
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
-dev_activate (FpImageDevice *dev)
 {
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
+	struct upektc_img_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state,
+	fpi_ssm *ssm = fpi_ssm_new(FP_DEV(dev), activate_run_state,
-                             ACTIVATE_NUM_STATES);
+		ACTIVATE_NUM_STATES, dev);
-
+	upekdev->seq = 0;
-  self->seq = 0;
 	fpi_ssm_start(ssm, activate_sm_complete);
+	return 0;
 }
 
-static void
+static void dev_deactivate(struct fp_img_dev *dev)
-dev_deactivate (FpImageDevice *dev)
 {
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
+	struct upektc_img_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
 
-  self->deactivating = TRUE;
+	upekdev->deactivating = TRUE;
 }
 
-static void
+static int dev_init(struct fp_img_dev *dev, unsigned long driver_data)
-dev_init (FpImageDevice *dev)
 {
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
-  GError *error = NULL;
-
 	/* TODO check that device has endpoints we're using */
+	int r;
+	struct upektc_img_dev *upekdev;
 
-  if (!g_usb_device_claim_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error))
+	r = libusb_claim_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
-    {
+	if (r < 0) {
-      fpi_image_device_open_complete (dev, error);
+		fp_err("could not claim interface 0: %s", libusb_error_name(r));
-      return;
+		return r;
 	}
 
-  self->image_bits = g_malloc0 (IMAGE_SIZE * 2);
+	upekdev = g_malloc0(sizeof(struct upektc_img_dev));
-  fpi_image_device_open_complete (dev, NULL);
+	fp_dev_set_instance_data(FP_DEV(dev), upekdev);
+	fpi_imgdev_open_complete(dev, 0);
+	return 0;
 }
 
-static void
+static void dev_deinit(struct fp_img_dev *dev)
-dev_deinit (FpImageDevice *dev)
 {
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
+	struct upektc_img_dev *upekdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  GError *error = NULL;
+	g_free(upekdev);
-
+	libusb_release_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
-  g_clear_pointer (&self->image_bits, g_free);
+	fpi_imgdev_close_complete(dev);
-  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)),
-                                  0, 0, &error);
-  fpi_image_device_close_complete (dev, error);
 }
 
-static int
+static int discover(struct libusb_device_descriptor *dsc, uint32_t *devtype)
-discover (GUsbDevice *usb_device)
 {
-  gint16 pid = g_usb_device_get_pid (usb_device);
+	if (dsc->idProduct == 0x2020 && dsc->bcdDevice == 1)
-  gint16 bcd = g_usb_device_get_release (usb_device);
+		return 1;
-
+	if (dsc->idProduct == 0x2016 && dsc->bcdDevice == 2)
-  if (pid == 0x2020 && bcd == 1)
+		return 1;
-    return 100;
-  if (pid == 0x2016 && bcd == 2)
-    return 100;
 
 	return 0;
 }
 
-static const FpIdEntry id_table[] = {
+static const struct usb_id id_table[] = {
-  { .vid = 0x147e,  .pid = 0x2016, },
+	{ .vendor = 0x147e, .product = 0x2016 },
-  { .vid = 0x147e,  .pid = 0x2020, },
+	{ .vendor = 0x147e, .product = 0x2020 },
-  { .vid = 0,  .pid = 0,  .driver_data = 0 },
+	{ 0, 0, 0, },
 };
 
-static void
+struct fp_img_driver upektc_img_driver = {
-fpi_device_upektc_img_init (FpiDeviceUpektcImg *self)
+	.driver = {
-{
+		.id = UPEKTC_IMG_ID,
-}
+		.name = FP_COMPONENT,
-static void
+		.full_name = "Upek TouchChip Fingerprint Coprocessor",
-fpi_device_upektc_img_class_init (FpiDeviceUpektcImgClass *klass)
+		.id_table = id_table,
-{
+		.scan_type = FP_SCAN_TYPE_SWIPE,
-  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
+		.discover = discover,
-  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
+	},
+	.flags = 0,
+	.img_height = IMAGE_HEIGHT,
+	.img_width = IMAGE_WIDTH,
+	.bz3_threshold = 20,
 
-  dev_class->id = "upektc_img";
+	.open = dev_init,
-  dev_class->full_name = "Upek TouchChip Fingerprint Coprocessor";
+	.close = dev_deinit,
-  dev_class->type = FP_DEVICE_TYPE_USB;
+	.activate = dev_activate,
-  dev_class->id_table = id_table;
+	.deactivate = dev_deactivate,
-  dev_class->scan_type = FP_SCAN_TYPE_SWIPE;
+};
-  dev_class->usb_discover = discover;
-
-  img_class->img_open = dev_init;
-  img_class->img_close = dev_deinit;
-  img_class->activate = dev_activate;
-  img_class->deactivate = dev_deactivate;
-
-  img_class->bz3_threshold = 20;
-
-  img_class->img_width = IMAGE_WIDTH;
-  img_class->img_height = IMAGE_HEIGHT;
-}

libfprint/drivers/upektc_img.h

@@ -17,7 +17,8 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
+#ifndef __UPEKTC_IMG_H
+#define __UPEKTC_IMG_H
 
 static const unsigned char upek2020_init_1[] = {
 'C', 'i', 'a', 'o',
@@ -139,3 +140,5 @@ static const unsigned char upek2020_ack_frame[] = {
 0x30,
 0xac, 0x5b /* CRC */
 };
+
+#endif

libfprint/drivers/vcom5s.c

@@ -28,8 +28,10 @@
  * powerdown? does windows do anything special on exit?
  */
 
+#define CTRL_IN 0xc0
+#define CTRL_OUT 0x40
 #define CTRL_TIMEOUT	1000
-#define EP_IN (1 | FPI_USB_ENDPOINT_IN)
+#define EP_IN			(1 | LIBUSB_ENDPOINT_IN)
 
 #define IMG_WIDTH		300
 #define IMG_HEIGHT		288
@@ -38,18 +40,12 @@
 #define RQ_SIZE			(IMG_WIDTH * ROWS_PER_RQ)
 #define IMG_SIZE		(IMG_WIDTH * IMG_HEIGHT)
 
-struct _FpDeviceVcom5s
+struct v5s_dev {
-{
-  FpImageDevice parent;
-
 	int capture_iteration;
-  FpImage      *capture_img;
+	struct fp_img *capture_img;
 	gboolean loop_running;
 	gboolean deactivating;
 };
-G_DECLARE_FINAL_TYPE (FpDeviceVcom5s, fpi_device_vcom5s, FPI, DEVICE_VCOM5S,
-                      FpImageDevice);
-G_DEFINE_TYPE (FpDeviceVcom5s, fpi_device_vcom5s, FP_TYPE_IMAGE_DEVICE);
 
 enum v5s_regs {
 	/* when using gain 0x29:
@@ -76,42 +72,76 @@ enum v5s_cmd {
 
 /***** REGISTER I/O *****/
 
-static void
+static void sm_write_reg_cb(struct libusb_transfer *transfer)
-sm_write_reg (FpiSsm       *ssm,
-              FpDevice     *dev,
-              unsigned char reg,
-              unsigned char value)
 {
-  FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
+	fpi_ssm *ssm = transfer->user_data;
 
-  fp_dbg ("set %02x=%02x", reg, value);
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED)
-  fpi_usb_transfer_fill_control (transfer,
+		fpi_ssm_mark_failed(ssm, -EIO);
-                                 G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE,
+	else
-                                 G_USB_DEVICE_REQUEST_TYPE_VENDOR,
+		fpi_ssm_next_state(ssm);
-                                 G_USB_DEVICE_RECIPIENT_DEVICE,
+
-                                 reg, value, 0, 0);
+	g_free(transfer->buffer);
-  transfer->ssm = ssm;
+	libusb_free_transfer(transfer);
-  fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL,
-                           fpi_ssm_usb_transfer_cb, NULL);
 }
 
 static void
-sm_exec_cmd (FpiSsm       *ssm,
+sm_write_reg(fpi_ssm           *ssm,
-             FpDevice     *dev,
+	     struct fp_img_dev *dev,
+	     unsigned char      reg,
+	     unsigned char      value)
+{
+	struct libusb_transfer *transfer = fpi_usb_alloc();
+	unsigned char *data;
+	int r;
+	
+	fp_dbg("set %02x=%02x", reg, value);
+	data = g_malloc(LIBUSB_CONTROL_SETUP_SIZE);
+	libusb_fill_control_setup(data, CTRL_OUT, reg, value, 0, 0);
+	libusb_fill_control_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), data, sm_write_reg_cb,
+		ssm, CTRL_TIMEOUT);
+	r = libusb_submit_transfer(transfer);
+	if (r < 0) {
+		g_free(data);
+		libusb_free_transfer(transfer);
+		fpi_ssm_mark_failed(ssm, r);
+	}
+}
+
+static void sm_exec_cmd_cb(struct libusb_transfer *transfer)
+{
+	fpi_ssm *ssm = transfer->user_data;
+
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED)
+		fpi_ssm_mark_failed(ssm, -EIO);
+	else
+		fpi_ssm_next_state(ssm);
+
+	g_free(transfer->buffer);
+	libusb_free_transfer(transfer);
+}
+
+static void
+sm_exec_cmd(fpi_ssm           *ssm,
+	    struct fp_img_dev *dev,
 	    unsigned char      cmd,
 	    unsigned char      param)
 {
-  FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
+	struct libusb_transfer *transfer = fpi_usb_alloc();
+	unsigned char *data;
+	int r;
 
 	fp_dbg("cmd %02x param %02x", cmd, param);
-  fpi_usb_transfer_fill_control (transfer,
+	data = g_malloc(LIBUSB_CONTROL_SETUP_SIZE);
-                                 G_USB_DEVICE_DIRECTION_DEVICE_TO_HOST,
+	libusb_fill_control_setup(data, CTRL_IN, cmd, param, 0, 0);
-                                 G_USB_DEVICE_REQUEST_TYPE_VENDOR,
+	libusb_fill_control_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), data, sm_exec_cmd_cb,
-                                 G_USB_DEVICE_RECIPIENT_DEVICE,
+		ssm, CTRL_TIMEOUT);
-                                 cmd, param, 0, 0);
+	r = libusb_submit_transfer(transfer);
-  transfer->ssm = ssm;
+	if (r < 0) {
-  fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL,
+		g_free(data);
-                           fpi_ssm_usb_transfer_cb, NULL);
+		libusb_free_transfer(transfer);
+		fpi_ssm_mark_failed(ssm, r);
+	}
 }
 
 /***** FINGER DETECTION *****/
@@ -126,16 +156,14 @@ sm_exec_cmd (FpiSsm       *ssm,
 #define DETBOX_COL_END (DETBOX_COL_START + DETBOX_COLS)
 #define FINGER_PRESENCE_THRESHOLD 100
 
-static gboolean
+static gboolean finger_is_present(unsigned char *data)
-finger_is_present (unsigned char *data)
 {
 	int row;
-  guint16 imgavg = 0;
+	uint16_t imgavg = 0;
 
-  for (row = DETBOX_ROW_START; row < DETBOX_ROW_END; row++)
+	for (row = DETBOX_ROW_START; row < DETBOX_ROW_END; row++) {
-    {
 		unsigned char *rowdata = data + (row * IMG_WIDTH);
-      guint16 rowavg = 0;
+		uint16_t rowavg = 0;
 		int col;
 
 		for (col = DETBOX_COL_START; col < DETBOX_COL_END; col++)
@@ -146,78 +174,74 @@ finger_is_present (unsigned char *data)
 	imgavg /= DETBOX_ROWS;
 	fp_dbg("img avg %d", imgavg);
 
-  return imgavg <= FINGER_PRESENCE_THRESHOLD;
+	return (imgavg <= FINGER_PRESENCE_THRESHOLD);
 }
 
 
 
 /***** IMAGE ACQUISITION *****/
 
-static void capture_iterate (FpiSsm   *ssm,
+static void capture_iterate(fpi_ssm *ssm, struct fp_img_dev *dev);
-                             FpDevice *dev);
 
-static void
+static void capture_cb(struct libusb_transfer *transfer)
-capture_cb (FpiUsbTransfer *transfer, FpDevice *device,
-            gpointer user_data, GError *error)
 {
-  FpImageDevice *imgdev = FP_IMAGE_DEVICE (device);
+	fpi_ssm *ssm = transfer->user_data;
-  FpDeviceVcom5s *self = FPI_DEVICE_VCOM5S (device);
+	struct fp_img_dev *dev = fpi_ssm_get_user_data(ssm);
+	struct v5s_dev *vdev = FP_INSTANCE_DATA(FP_DEV(dev));
 
-  if (error)
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
-    {
+		fpi_ssm_mark_failed(ssm, -EIO);
-      fpi_ssm_mark_failed (transfer->ssm, error);
+		goto out;
-      return;
 	}
 
-  if (++self->capture_iteration == NR_REQS)
+	if (++vdev->capture_iteration == NR_REQS) {
-    {
+		struct fp_img *img = vdev->capture_img;
-      FpImage *img = self->capture_img;
 		/* must clear this early, otherwise the call chain takes us into
 		 * loopsm_complete where we would free it, when in fact we are
 		 * supposed to be handing off this image */
-      self->capture_img = NULL;
+		vdev->capture_img = NULL;
 
-      fpi_image_device_report_finger_status (imgdev,
+		fpi_imgdev_report_finger_status(dev, finger_is_present(img->data));
-                                             finger_is_present (img->data));
+		fpi_imgdev_image_captured(dev, img);
-      fpi_image_device_image_captured (imgdev, img);
+		fpi_ssm_next_state(ssm);
-      fpi_ssm_next_state (transfer->ssm);
+	} else {
-    }
+		capture_iterate(ssm, dev);
-  else
-    {
-      capture_iterate (transfer->ssm, device);
 	}
+
+out:
+	libusb_free_transfer(transfer);
 }
 
 static void
-capture_iterate (FpiSsm   *ssm,
+capture_iterate(fpi_ssm           *ssm,
-                 FpDevice *dev)
+		struct fp_img_dev *dev)
 {
-  FpDeviceVcom5s *self = FPI_DEVICE_VCOM5S (dev);
+	struct v5s_dev *vdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  int iteration = self->capture_iteration;
+	int iteration = vdev->capture_iteration;
-  FpiUsbTransfer *transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
+	struct libusb_transfer *transfer = fpi_usb_alloc();
+	int r;
 
-  transfer->ssm = ssm;
+	libusb_fill_bulk_transfer(transfer, fpi_dev_get_usb_dev(FP_DEV(dev)), EP_IN,
-  transfer->short_is_error = TRUE;
+		vdev->capture_img->data + (RQ_SIZE * iteration), RQ_SIZE,
-  fpi_usb_transfer_fill_bulk_full (transfer,
+		capture_cb, ssm, CTRL_TIMEOUT);
-                                   EP_IN,
+	transfer->flags = LIBUSB_TRANSFER_SHORT_NOT_OK;
-                                   self->capture_img->data + (RQ_SIZE * iteration),
+	r = libusb_submit_transfer(transfer);
-                                   RQ_SIZE,
+	if (r < 0) {
-                                   NULL);
+		libusb_free_transfer(transfer);
-
+		fpi_ssm_mark_failed(ssm, r);
-  fpi_usb_transfer_submit (transfer, CTRL_TIMEOUT, NULL, capture_cb, NULL);
+	}
 }
 
 
 static void
-sm_do_capture (FpiSsm   *ssm,
+sm_do_capture(fpi_ssm           *ssm,
-               FpDevice *dev)
+	      struct fp_img_dev *dev)
 {
-  FpDeviceVcom5s *self = FPI_DEVICE_VCOM5S (dev);
+	struct v5s_dev *vdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (dev);
 
 	G_DEBUG_HERE();
-  self->capture_img = fp_image_new (cls->img_width, cls->img_height);
+	vdev->capture_img = fpi_img_new_for_imgdev(dev);
-  self->capture_iteration = 0;
+	vdev->capture_iteration = 0;
 	capture_iterate(ssm, dev);
 }
 
@@ -232,136 +256,120 @@ enum loop_states {
 	LOOP_NUM_STATES,
 };
 
-static void
+static void loop_run_state(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-loop_run_state (FpiSsm *ssm, FpDevice *dev)
 {
-  FpDeviceVcom5s *self = FPI_DEVICE_VCOM5S (dev);
+	struct fp_img_dev *dev = user_data;
+	struct v5s_dev *vdev = FP_INSTANCE_DATA(_dev);
 
-  switch (fpi_ssm_get_cur_state (ssm))
+	switch (fpi_ssm_get_cur_state(ssm)) {
-    {
 	case LOOP_SET_CONTRAST:
 		sm_write_reg(ssm, dev, REG_CONTRAST, 0x01);
 		break;
-
 	case LOOP_SET_GAIN:
 		sm_write_reg(ssm, dev, REG_GAIN, 0x29);
 		break;
-
 	case LOOP_CMD_SCAN:
-      if (self->deactivating)
+		if (vdev->deactivating) {
-        {
 			fp_dbg("deactivating, marking completed");
 			fpi_ssm_mark_completed(ssm);
-        }
+		} else
-      else
-        {
 			sm_exec_cmd(ssm, dev, CMD_SCAN, 0x00);
-        }
 		break;
-
 	case LOOP_CAPTURE:
 		sm_do_capture(ssm, dev);
 		break;
-
 	case LOOP_CAPTURE_DONE:
 		fpi_ssm_jump_to_state(ssm, LOOP_CMD_SCAN);
 		break;
-
-    default:
-      g_assert_not_reached ();
 	}
 }
 
-static void
+static void loopsm_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-loopsm_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
 {
-  FpImageDevice *imgdev = FP_IMAGE_DEVICE (dev);
+	struct fp_img_dev *dev = user_data;
-  FpDeviceVcom5s *self = FPI_DEVICE_VCOM5S (dev);
+	struct v5s_dev *vdev = FP_INSTANCE_DATA(_dev);
+	int r = fpi_ssm_get_error(ssm);
 
-  g_object_unref (self->capture_img);
+	fpi_ssm_free(ssm);
-  self->capture_img = NULL;
+	fp_img_free(vdev->capture_img);
-  self->loop_running = FALSE;
+	vdev->capture_img = NULL;
+	vdev->loop_running = FALSE;
 
-  if (error && !self->deactivating)
+	if (r)
-    fpi_image_device_session_error (imgdev, error);
+		fpi_imgdev_session_error(dev, r);
-  else if (error)
-    g_error_free (error);
 
-  if (self->deactivating)
+	if (vdev->deactivating)
-    fpi_image_device_deactivate_complete (imgdev, NULL);
+		fpi_imgdev_deactivate_complete(dev);
 }
 
-static void
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
-dev_activate (FpImageDevice *dev)
 {
-  FpDeviceVcom5s *self = FPI_DEVICE_VCOM5S (dev);
+	struct v5s_dev *vdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), loop_run_state, LOOP_NUM_STATES);
+	fpi_ssm *ssm = fpi_ssm_new(FP_DEV(dev), loop_run_state,
-
+		LOOP_NUM_STATES, dev);
-  self->deactivating = FALSE;
+	vdev->deactivating = FALSE;
 	fpi_ssm_start(ssm, loopsm_complete);
-  self->loop_running = TRUE;
+	vdev->loop_running = TRUE;
-  fpi_image_device_activate_complete (dev, NULL);
+	fpi_imgdev_activate_complete(dev, 0);
+	return 0;
 }
 
-static void
+static void dev_deactivate(struct fp_img_dev *dev)
-dev_deactivate (FpImageDevice *dev)
 {
-  FpDeviceVcom5s *self = FPI_DEVICE_VCOM5S (dev);
+	struct v5s_dev *vdev = FP_INSTANCE_DATA(FP_DEV(dev));
-
+	if (vdev->loop_running)
-  if (self->loop_running)
+		vdev->deactivating = TRUE;
-    self->deactivating = TRUE;
 	else
-    fpi_image_device_deactivate_complete (dev, NULL);
+		fpi_imgdev_deactivate_complete(dev);
 }
 
-static void
+static int dev_init(struct fp_img_dev *dev, unsigned long driver_data)
-dev_init (FpImageDevice *dev)
 {
-  GError *error = NULL;
+	int r;
+	struct v5s_dev *v5s_dev;
 
-  g_usb_device_claim_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error);
+	v5s_dev = g_malloc0(sizeof(struct v5s_dev));
+	fp_dev_set_instance_data(FP_DEV(dev), v5s_dev);
 
-  fpi_image_device_open_complete (dev, error);
+	r = libusb_claim_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
+	if (r < 0)
+		fp_err("could not claim interface 0: %s", libusb_error_name(r));
+
+	if (r == 0)
+		fpi_imgdev_open_complete(dev, 0);
+
+	return r;
 }
 
-static void
+static void dev_deinit(struct fp_img_dev *dev)
-dev_deinit (FpImageDevice *dev)
 {
-  GError *error = NULL;
+	struct v5s_dev *v5s_dev;
-
+	v5s_dev = FP_INSTANCE_DATA(FP_DEV(dev));
-  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)),
+	g_free(v5s_dev);
-                                  0, 0, &error);
+	libusb_release_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
-
+	fpi_imgdev_close_complete(dev);
-  fpi_image_device_close_complete (dev, error);
 }
 
-static const FpIdEntry id_table[] = {
+static const struct usb_id id_table[] = {
-  { .vid = 0x061a,  .pid = 0x0110, },
+	{ .vendor = 0x061a, .product = 0x0110 },
-  { .vid = 0,  .pid = 0,  .driver_data = 0 },
+	{ 0, 0, 0, },
 };
 
-static void
+struct fp_img_driver vcom5s_driver = {
-fpi_device_vcom5s_init (FpDeviceVcom5s *self)
+	.driver = {
-{
+		.id = VCOM5S_ID,
-}
+		.name = FP_COMPONENT,
+		.full_name = "Veridicom 5thSense",
+		.id_table = id_table,
+		.scan_type = FP_SCAN_TYPE_PRESS,
+	},
+	.flags = 0,
+	.img_height = IMG_HEIGHT,
+	.img_width = IMG_WIDTH,
 
-static void
+	.open = dev_init,
-fpi_device_vcom5s_class_init (FpDeviceVcom5sClass *klass)
+	.close = dev_deinit,
-{
+	.activate = dev_activate,
-  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
+	.deactivate = dev_deactivate,
-  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
+};
 
-  dev_class->id = "vcom5s";
-  dev_class->full_name = "Veridicom 5thSense";
-  dev_class->type = FP_DEVICE_TYPE_USB;
-  dev_class->id_table = id_table;
-  dev_class->scan_type = FP_SCAN_TYPE_PRESS;
-
-  img_class->img_open = dev_init;
-  img_class->img_close = dev_deinit;
-  img_class->activate = dev_activate;
-  img_class->deactivate = dev_deactivate;
-
-  img_class->img_width = IMG_WIDTH;
-  img_class->img_height = IMG_HEIGHT;
-}

libfprint/drivers/vfs0050.h

@@ -17,10 +17,6 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#pragma once
-
-#include "fpi-image-device.h"
-
 /* Timeout for all send/recv operations, except interrupt waiting and abort */
 #define VFS_USB_TIMEOUT 100
 /* Timeout for usb abort */
@@ -51,8 +47,7 @@
 #define EP3_IN 0x83
 
 /* Fingerprint horizontal line */
-struct vfs_line
+struct vfs_line {
-{
 	/* It must be always 0x01 */
 	unsigned char _0x01;
 	/* It must be always 0xfe */
@@ -79,10 +74,7 @@ struct vfs_line
 } __attribute__ ((__packed__));
 
 /* The main driver structure */
-struct _FpDeviceVfs0050
+struct vfs_dev_t {
-{
-  FpImageDevice parent;
-
 	/* One if we were asked to read fingerprint, zero otherwise */
 	char active;
 
@@ -92,9 +84,15 @@ struct _FpDeviceVfs0050
 	/* For dev_deactivate to check whether ssm still running or not */
 	char ssm_active;
 
+	/* Current async transfer */
+	struct libusb_transfer *transfer;
+
 	/* Should we call fpi_imgdev_activate_complete or fpi_imgdev_deactivate_complete */
 	char need_report;
 
+	/* Should we wait more for interrupt */
+	char wait_interrupt;
+
 	/* Received fingerprint raw lines */
 	struct vfs_line *lines_buffer;
 
@@ -108,8 +106,6 @@ struct _FpDeviceVfs0050
 	unsigned char interrupt[8];
 };
 
-G_DECLARE_FINAL_TYPE (FpDeviceVfs0050, fpi_device_vfs0050, FPI, DEVICE_VFS0050, FpImageDevice)
-
 /* SSM states for clear_ep2 */
 enum SUBSM1 {
 	SUBSM1_COMMAND_04,

libfprint/drivers/vfs301.c

@@ -22,52 +22,64 @@
 #define FP_COMPONENT "vfs301"
 
 #include "drivers_api.h"
-#include "vfs301.h"
+#include "vfs301_proto.h"
-
-G_DEFINE_TYPE (FpDeviceVfs301, fpi_device_vfs301, FP_TYPE_IMAGE_DEVICE)
 
 /************************** GENERIC STUFF *************************************/
 
-static int
+/* Submit asynchronous sleep */
-submit_image (FpiSsm        *ssm,
+static void
-              FpImageDevice *dev)
+async_sleep(unsigned int       msec,
+	    fpi_ssm           *ssm,
+	    struct fp_img_dev *dev)
 {
-  FpDeviceVfs301 *self = FPI_DEVICE_VFS301 (dev);
+	/* Add timeout */
+	if (fpi_timeout_add(msec, fpi_ssm_next_state_timeout_cb, FP_DEV(dev), ssm) == NULL) {
+		/* Failed to add timeout */
+		fp_err("failed to add timeout");
+		fpi_imgdev_session_error(dev, -ETIME);
+		fpi_ssm_mark_failed(ssm, -ETIME);
+	}
+}
+
+static int
+submit_image(fpi_ssm           *ssm,
+	     struct fp_img_dev *dev)
+{
+	vfs301_dev_t *vdev = FP_INSTANCE_DATA(FP_DEV(dev));
 	int height;
-  FpImage *img;
+	struct fp_img *img;
 
 #if 0
 	/* XXX: This is probably handled by libfprint automagically? */
-  if (vdev->scanline_count < 20)
+	if (vdev->scanline_count < 20) {
-    {
 		fpi_ssm_jump_to_state(ssm, M_REQUEST_PRINT);
 		return 0;
 	}
 #endif
 
-  img = fp_image_new (VFS301_FP_OUTPUT_WIDTH, self->scanline_count);
+	img = fpi_img_new(VFS301_FP_OUTPUT_WIDTH * vdev->scanline_count);
 	if (img == NULL)
 		return 0;
 
-  vfs301_extract_image (self, img->data, &height);
+	vfs301_extract_image(vdev, img->data, &height);
 
 	/* TODO: how to detect flip? should the resulting image be
 	 * oriented so that it is equal e.g. to a fingerprint on a paper,
 	 * or to the finger when I look at it?) */
-  img->flags = FPI_IMAGE_COLORS_INVERTED | FPI_IMAGE_V_FLIPPED;
+	img->flags = FP_IMG_COLORS_INVERTED | FP_IMG_V_FLIPPED;
 
-  /* The image buffer is larger at this point, but that does not
-   * matter. */
 	img->width = VFS301_FP_OUTPUT_WIDTH;
 	img->height = height;
 
-  fpi_image_device_image_captured (dev, img);
+	img = fpi_img_realloc(img, img->height * img->width);
+	fpi_imgdev_image_captured(dev, img);
 
 	return 1;
 }
 
 /* Loop ssm states */
-enum {
+enum
+{
 	/* Step 0 - Scan finger */
 	M_REQUEST_PRINT,
 	M_WAIT_PRINT,
@@ -82,45 +94,43 @@ enum {
 };
 
 /* Exec loop sequential state machine */
-static void
+static void m_loop_state(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-m_loop_state (FpiSsm *ssm, FpDevice *_dev)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+	struct fp_img_dev *dev = user_data;
-  FpDeviceVfs301 *self = FPI_DEVICE_VFS301 (_dev);
+	vfs301_dev_t *vdev = FP_INSTANCE_DATA(_dev);
 
-  switch (fpi_ssm_get_cur_state (ssm))
+	switch (fpi_ssm_get_cur_state(ssm)) {
-    {
 	case M_REQUEST_PRINT:
-      vfs301_proto_request_fingerprint (self);
+		vfs301_proto_request_fingerprint(fpi_dev_get_usb_dev(FP_DEV(dev)), vdev);
 		fpi_ssm_next_state(ssm);
 		break;
 
 	case M_WAIT_PRINT:
 		/* Wait fingerprint scanning */
-      fpi_ssm_next_state_delayed (ssm, 200, NULL);
+		async_sleep(200, ssm, dev);
 		break;
 
 	case M_CHECK_PRINT:
-      if (!vfs301_proto_peek_event (self))
+		if (!vfs301_proto_peek_event(fpi_dev_get_usb_dev(FP_DEV(dev)), vdev))
 			fpi_ssm_jump_to_state(ssm, M_WAIT_PRINT);
 		else
 			fpi_ssm_next_state(ssm);
 		break;
 
 	case M_READ_PRINT_START:
-      fpi_image_device_report_finger_status (dev, TRUE);
+		fpi_imgdev_report_finger_status(dev, TRUE);
-      vfs301_proto_process_event_start (self);
+		vfs301_proto_process_event_start(fpi_dev_get_usb_dev(FP_DEV(dev)), vdev);
 		fpi_ssm_next_state(ssm);
 		break;
 
 	case M_READ_PRINT_WAIT:
 		/* Wait fingerprint scanning */
-      fpi_ssm_next_state_delayed (ssm, 200, NULL);
+		async_sleep(200, ssm, dev);
 		break;
 
 	case M_READ_PRINT_POLL:
 		{
-        int rv = vfs301_proto_process_event_poll (self);
+		int rv = vfs301_proto_process_event_poll(fpi_dev_get_usb_dev(FP_DEV(dev)), vdev);
 		g_assert(rv != VFS301_FAILURE);
 		if (rv == VFS301_ONGOING)
 			fpi_ssm_jump_to_state(ssm, M_READ_PRINT_WAIT);
@@ -130,152 +140,150 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)
 		break;
 
 	case M_SUBMIT_PRINT:
-      if (submit_image (ssm, dev))
+		if (submit_image(ssm, dev)) {
-        {
 			fpi_ssm_mark_completed(ssm);
 			/* NOTE: finger off is expected only after submitting image... */
-          fpi_image_device_report_finger_status (dev, FALSE);
+			fpi_imgdev_report_finger_status(dev, FALSE);
-        }
+		} else {
-      else
-        {
 			fpi_ssm_jump_to_state(ssm, M_REQUEST_PRINT);
 		}
 		break;
-
-    default:
-      g_assert_not_reached ();
 	}
 }
 
 /* Complete loop sequential state machine */
-static void
+static void m_loop_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-m_loop_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
 {
-  if (error)
-    {
-      g_warning ("State machine completed with an error: %s", error->message);
-      g_error_free (error);
-    }
 	/* Free sequential state machine */
+	fpi_ssm_free(ssm);
 }
 
 /* Exec init sequential state machine */
-static void
+static void m_init_state(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-m_init_state (FpiSsm *ssm, FpDevice *_dev)
 {
-  FpDeviceVfs301 *self = FPI_DEVICE_VFS301 (_dev);
+	struct fp_img_dev *dev = user_data;
+	vfs301_dev_t *vdev = FP_INSTANCE_DATA(_dev);
 
 	g_assert(fpi_ssm_get_cur_state(ssm) == 0);
 
-  vfs301_proto_init (self);
+	vfs301_proto_init(fpi_dev_get_usb_dev(FP_DEV(dev)), vdev);
 
 	fpi_ssm_mark_completed(ssm);
 }
 
 /* Complete init sequential state machine */
-static void
+static void m_init_complete(fpi_ssm *ssm, struct fp_dev *_dev, void *user_data)
-m_init_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
 {
-  FpiSsm *ssm_loop;
+	struct fp_img_dev *dev = user_data;
+	fpi_ssm *ssm_loop;
 
-  fpi_image_device_activate_complete (FP_IMAGE_DEVICE (dev), error);
+	if (!fpi_ssm_get_error(ssm)) {
-  if (!error)
-    {
 		/* Notify activate complete */
+		fpi_imgdev_activate_complete(dev, 0);
 
 		/* Start loop ssm */
-      ssm_loop = fpi_ssm_new (dev, m_loop_state, M_LOOP_NUM_STATES);
+		ssm_loop = fpi_ssm_new(FP_DEV(dev), m_loop_state, M_LOOP_NUM_STATES, dev);
 		fpi_ssm_start(ssm_loop, m_loop_complete);
 	}
 
 	/* Free sequential state machine */
+	fpi_ssm_free(ssm);
 }
 
 /* Activate device */
-static void
+static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
-dev_activate (FpImageDevice *dev)
 {
-  FpiSsm *ssm;
+	fpi_ssm *ssm;
 
 	/* Start init ssm */
-  ssm = fpi_ssm_new (FP_DEVICE (dev), m_init_state, 1);
+	ssm = fpi_ssm_new(FP_DEV(dev), m_init_state, 1, dev);
 	fpi_ssm_start(ssm, m_init_complete);
+
+	return 0;
 }
 
 /* Deactivate device */
-static void
+static void dev_deactivate(struct fp_img_dev *dev)
-dev_deactivate (FpImageDevice *dev)
 {
-  FpDeviceVfs301 *self;
+	vfs301_dev_t *vdev;
 
-  self = FPI_DEVICE_VFS301 (dev);
+	vdev = FP_INSTANCE_DATA(FP_DEV(dev));
-  vfs301_proto_deinit (self);
+	vfs301_proto_deinit(fpi_dev_get_usb_dev(FP_DEV(dev)), vdev);
-  fpi_image_device_deactivate_complete (dev, NULL);
+	fpi_imgdev_deactivate_complete(dev);
 }
 
-static void
+static int dev_open(struct fp_img_dev *dev, unsigned long driver_data)
-dev_open (FpImageDevice *dev)
 {
-  FpDeviceVfs301 *self = FPI_DEVICE_VFS301 (dev);
+	vfs301_dev_t *vdev = NULL;
-  GError *error = NULL;
+	int r;
 
 	/* Claim usb interface */
-  g_usb_device_claim_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error);
+	r = libusb_claim_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
-
+	if (r < 0) {
-  /* Initialize private structure */
+		/* Interface not claimed, return error */
-  self->scanline_count = 0;
+		fp_err("could not claim interface 0: %s", libusb_error_name(r));
-
+		return r;
-  /* Notify open complete */
-  fpi_image_device_open_complete (dev, error);
 	}
 
-static void
+	/* Initialize private structure */
-dev_close (FpImageDevice *dev)
+	vdev = g_malloc0(sizeof(vfs301_dev_t));
+	fp_dev_set_instance_data(FP_DEV(dev), vdev);
+
+	vdev->scanline_buf = malloc(0);
+	vdev->scanline_count = 0;
+
+	/* Notify open complete */
+	fpi_imgdev_open_complete(dev, 0);
+
+	return 0;
+}
+
+static void dev_close(struct fp_img_dev *dev)
 {
-  FpDeviceVfs301 *self = FPI_DEVICE_VFS301 (dev);
+	vfs301_dev_t *vdev;
-  GError *error = NULL;
 
 	/* Release private structure */
-  g_clear_pointer (&self->scanline_buf, g_free);
+	vdev = FP_INSTANCE_DATA(FP_DEV(dev));
+	free(vdev->scanline_buf);
+	g_free(vdev);
 
 	/* Release usb interface */
-  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)),
+	libusb_release_interface(fpi_dev_get_usb_dev(FP_DEV(dev)), 0);
-                                  0, 0, &error);
 
 	/* Notify close complete */
-  fpi_image_device_close_complete (dev, error);
+	fpi_imgdev_close_complete(dev);
 }
 
 /* Usb id table of device */
-static const FpIdEntry id_table[] = {
+static const struct usb_id id_table[] =
-  { /* vfs301 */ .vid = 0x138a,  .pid = 0x0005, },
+{
-  { /* vfs300 */ .vid = 0x138a,  .pid = 0x0008, },
+	{ .vendor = 0x138a, .product = 0x0005 /* vfs301 */ },
-  { .vid = 0,  .pid = 0,  .driver_data = 0 },
+	{ .vendor = 0x138a, .product = 0x0008 /* vfs300 */ },
+	{ 0, 0, 0, },
 };
 
-static void
+/* Device driver definition */
-fpi_device_vfs301_init (FpDeviceVfs301 *self)
+struct fp_img_driver vfs301_driver =
 {
-}
+	/* Driver specification */
-static void
+	.driver =
-fpi_device_vfs301_class_init (FpDeviceVfs301Class *klass)
 	{
-  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
+		.id = VFS301_ID,
-  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
+		.name = FP_COMPONENT,
+		.full_name = "Validity VFS301",
+		.id_table = id_table,
+		.scan_type = FP_SCAN_TYPE_SWIPE,
+	},
 
-  dev_class->id = "vfs301";
+	/* Image specification */
-  dev_class->full_name = "Validity VFS301";
+	.flags = 0,
-  dev_class->type = FP_DEVICE_TYPE_USB;
+	.img_width = VFS301_FP_WIDTH,
-  dev_class->id_table = id_table;
+	.img_height = -1,
-  dev_class->scan_type = FP_SCAN_TYPE_SWIPE;
+	.bz3_threshold = 24,
 
-  img_class->img_open = dev_open;
+	/* Routine specification */
-  img_class->img_close = dev_close;
+	.open = dev_open,
-  img_class->activate = dev_activate;
+	.close = dev_close,
-  img_class->deactivate = dev_deactivate;
+	.activate = dev_activate,
-
+	.deactivate = dev_deactivate,
-  img_class->bz3_threshold = 24;
+};
-
-  img_class->img_width = VFS301_FP_WIDTH;
-  img_class->img_height = -1;
-}

libfprint/drivers/vfs301.h

@@ -1,142 +0,0 @@
-/*
- * vfs301/vfs300 fingerprint reader driver
- * https://github.com/andree182/vfs301
- *
- * Copyright (c) 2011-2012 Andrej Krutak <dev@andree.sk>
- *
- * 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
- */
-
-#pragma once
-
-#include "fpi-usb-transfer.h"
-#include "fpi-image-device.h"
-
-enum {
-  VFS301_DEFAULT_WAIT_TIMEOUT = 300,
-
-  VFS301_SEND_ENDPOINT = 0x01,
-  VFS301_RECEIVE_ENDPOINT_CTRL = 0x81,
-  VFS301_RECEIVE_ENDPOINT_DATA = 0x82
-};
-
-#define VFS301_FP_RECV_LEN_1 (84032)
-#define VFS301_FP_RECV_LEN_2 (84096)
-
-struct _FpDeviceVfs301
-{
-  FpImageDevice parent;
-
-  /* buffer to hold raw scanlines */
-  unsigned char *scanline_buf;
-  int            scanline_count;
-
-  enum {
-    VFS301_ONGOING = 0,
-    VFS301_ENDED = 1,
-    VFS301_FAILURE = -1
-  } recv_progress;
-  int recv_exp_amt;
-};
-
-G_DECLARE_FINAL_TYPE (FpDeviceVfs301, fpi_device_vfs301, FPI, DEVICE_VFS301, FpImageDevice)
-
-enum {
-  /* Width of the scanned data in px */
-  VFS301_FP_WIDTH = 200,
-
-  /* sizeof(fp_line_t) */
-  VFS301_FP_FRAME_SIZE = 288,
-  /* Width of output line */
-#ifndef OUTPUT_RAW
-  VFS301_FP_OUTPUT_WIDTH = VFS301_FP_WIDTH,
-#else
-  VFS301_FP_OUTPUT_WIDTH = VFS301_FP_FRAME_SIZE,
-#endif
-
-  VFS301_FP_SUM_LINES = 3,
-
-#ifdef SCAN_FINISH_DETECTION
-  /* TODO: The following changes (seen ~60 and ~80) In that
-   * case we'll need to calibrate this from empty data somehow... */
-  VFS301_FP_SUM_MEDIAN = 60,
-  VFS301_FP_SUM_EMPTY_RANGE = 5,
-#endif
-
-  /* Minimum average difference between returned lines */
-  VFS301_FP_LINE_DIFF_THRESHOLD = 15,
-
-  /* Maximum waiting time for a single fingerprint frame */
-  VFS301_FP_RECV_TIMEOUT = 2000
-};
-
-/* Arrays of this structure is returned during the initialization as a response
- * to the 0x02D0 messages.
- * It seems to be always the same - what is it for? Some kind of confirmation?
- */
-typedef struct
-{
-  unsigned char sync_0x01;
-  unsigned char sync_0xfe;
-
-  unsigned char counter_lo;
-  unsigned char counter_hi;       /* FIXME ? */
-
-  unsigned char flags[3];
-
-  unsigned char sync_0x00;
-
-  unsigned char scan[VFS301_FP_WIDTH];
-} vfs301_init_line_t;
-
-typedef struct
-{
-  unsigned char sync_0x01;
-  unsigned char sync_0xfe;
-
-  unsigned char counter_lo;
-  unsigned char counter_hi;
-
-  unsigned char sync_0x08[2];       /* XXX: always? 0x08 0x08 */
-  /* 0x08 | 0x18 - Looks like 0x08 marks good quality lines */
-  unsigned char flag_1;
-  unsigned char sync_0x00;
-
-  unsigned char scan[VFS301_FP_WIDTH];
-
-  /* A offsetted, stretched, inverted copy of scan... probably could
-   * serve finger motion speed detection?
-   * Seems to be subdivided to some 10B + 53B + 1B blocks */
-  unsigned char mirror[64];
-
-  /* Some kind of sum of the scan, very low contrast */
-  unsigned char sum1[2];
-  unsigned char sum2[11];
-  unsigned char sum3[3];
-} vfs301_line_t;
-
-void vfs301_proto_init (FpDeviceVfs301 *dev);
-void vfs301_proto_deinit (FpDeviceVfs301 *dev);
-
-void vfs301_proto_request_fingerprint (FpDeviceVfs301 *dev);
-
-/** returns 0 if no event is ready, or 1 if there is one... */
-int vfs301_proto_peek_event (FpDeviceVfs301 *dev);
-void vfs301_proto_process_event_start (FpDeviceVfs301 *dev);
-int vfs301_proto_process_event_poll (FpDeviceVfs301 *dev);
-
-void vfs301_extract_image (FpDeviceVfs301 *vfs,
-                           unsigned char  *output,
-                           int            *output_height);

libfprint/drivers/vfs301_proto.c

@@ -34,23 +34,21 @@
 #include <stdlib.h>
 #include <glib.h>
 
-#include "fpi-usb-transfer.h"
+#include "fpi-usb.h"
-#include "vfs301.h"
+#include "vfs301_proto.h"
 #include "vfs301_proto_fragments.h"
 
 /************************** USB STUFF *****************************************/
 
 #ifdef DEBUG
-static void
+static void usb_print_packet(int dir, int rv, const unsigned char *data, int length)
-usb_print_packet (int dir, GError *error, const guint8 *data, int length)
 {
-  fprintf (stderr, "%s, error %s, len %d\n", dir ? "send" : "recv", error ? error->message : "-", length);
+	fprintf(stderr, "%s, rv %d, len %d\n", dir ? "send" : "recv", rv, length);
 
 #ifdef PRINT_VERBOSE
 	int i;
 
-  for (i = 0; i < MIN (length, 128); i++)
+	for (i = 0; i < MIN(length, 128); i++) {
-    {
 		fprintf(stderr, "%.2X ", data[i]);
 		if (i % 8 == 7)
 			fprintf(stderr, " ");
@@ -63,137 +61,106 @@ usb_print_packet (int dir, GError *error, const guint8 *data, int length)
 }
 #endif
 
-static void
+static int usb_recv(
-usb_recv (FpDeviceVfs301 *dev, guint8 endpoint, int max_bytes, FpiUsbTransfer **out, GError **error)
+	vfs301_dev_t *dev,
+	struct libusb_device_handle *devh, unsigned char endpoint, int max_bytes)
 {
-  GError *err = NULL;
+	g_assert(max_bytes <= sizeof(dev->recv_buf));
 
-  g_autoptr(FpiUsbTransfer) transfer = NULL;
+	int r = libusb_bulk_transfer(
-
+		devh, endpoint,
-  /* XXX: This function swallows any transfer errors, that is obviously
+		dev->recv_buf, max_bytes,
-   *      quite bad (it used to assert on no-error)! */
+		&dev->recv_len, VFS301_DEFAULT_WAIT_TIMEOUT
-
+	);
-  transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
-  transfer->short_is_error = TRUE;
-  fpi_usb_transfer_fill_bulk (transfer, endpoint, max_bytes);
-
-  fpi_usb_transfer_submit_sync (transfer, VFS301_DEFAULT_WAIT_TIMEOUT, &err);
 
 #ifdef DEBUG
-  usb_print_packet (0, err, transfer->buffer, transfer->actual_length);
+	usb_print_packet(0, r, dev->recv_buf, dev->recv_len);
 #endif
-  if (err)
+
-    {
+	if (r < 0)
-      if (!error)
+		return r;
-        g_warning ("Unhandled receive error: %s", err->message);
+	return 0;
-      g_propagate_error (error, err);
 }
 
-  if (out)
+static int usb_send(
-    *out = g_steal_pointer (&transfer);
+	struct libusb_device_handle *devh, const unsigned char *data, int length)
-}
-
-static void
-usb_send (FpDeviceVfs301 *dev, const guint8 *data, gssize length, GError **error)
 {
-  GError *err = NULL;
+	int transferred = 0;
 
-  g_autoptr(FpiUsbTransfer) transfer = NULL;
+	int r = libusb_bulk_transfer(
-
+		devh, VFS301_SEND_ENDPOINT,
-  /* XXX: This function swallows any transfer errors, that is obviously
+		(unsigned char *)data, length, &transferred, VFS301_DEFAULT_WAIT_TIMEOUT
-   *      quite bad (it used to assert on no-error)! */
+	);
-
-  transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
-  transfer->short_is_error = TRUE;
-  fpi_usb_transfer_fill_bulk_full (transfer, VFS301_SEND_ENDPOINT, (guint8 *) data, length, g_free);
-
-  fpi_usb_transfer_submit_sync (transfer, VFS301_DEFAULT_WAIT_TIMEOUT, &err);
 
 #ifdef DEBUG
-  usb_print_packet (1, err, data, length);
+	usb_print_packet(1, r, data, length);
 #endif
 
-  if (err)
+	g_assert(r == 0);
-    {
+
-      g_warning ("Error while sending data, continuing anyway: %s", err->message);
+	if (r < 0)
-      g_propagate_error (error, err);
+		return r;
-    }
+	if (transferred < length)
+		return r;
+
+	return 0;
 }
 
 /************************** OUT MESSAGES GENERATION ***************************/
 
-static guint8 *
+static void vfs301_proto_generate_0B(int subtype, unsigned char *data, int *len)
-vfs301_proto_generate_0B (int subtype, gssize *len)
 {
-  guint8 *res = g_malloc0 (39);
-  guint8 *data = res;
-
 	*data = 0x0B;
 	*len = 1;
 	data++;
 
+	memset(data, 0, 39);
 	*len += 38;
 
 	data[20] = subtype;
 
-  switch (subtype)
+	switch (subtype) {
-    {
 	case 0x04:
 		data[34] = 0x9F;
 		break;
-
 	case 0x05:
 		data[34] = 0xAB;
-      /* NOTE: There was a len++ here, which could never do anything */
+		len++;
 		break;
-
 	default:
 		g_assert_not_reached();
 		break;
 	}
-
-  return res;
 }
 
 #define HEX_TO_INT(c) \
 	(((c) >= '0' && (c) <= '9') ? ((c) - '0') : ((c) - 'A' + 10))
 
-static guint8 *
+static void translate_str(const char **srcL, unsigned char *data, int *len)
-translate_str (const char **srcL, gssize *len)
 {
-  guint8 *res = NULL;
-  guint8 *dst;
-  const char **src_pos;
 	const char *src;
-  gssize src_len = 0;
+	unsigned char *dataOrig = data;
 
-  for (src_pos = srcL; *src_pos; src_pos++)
+	while (*srcL != NULL) {
-    {
+		src = *srcL;
-      gint tmp;
+		while (*src != '\0') {
+			g_assert(*src != '\0');
+			g_assert(*(src +1) != '\0');
+			*data = (unsigned char)((HEX_TO_INT(*src) << 4) | (HEX_TO_INT(*(src + 1))));
 
-      src = *src_pos;
+			data++;
-      tmp = strlen (src);
+			src += 2;
-      g_assert (tmp % 2 == 0);
-      src_len += tmp;
 		}
 
-  g_assert (src_len >= 2);
+		srcL++;
-  *len = src_len / 2;
-  res = g_malloc0 (*len);
-  dst = res;
-
-  for (src_pos = srcL; *src_pos; src_pos++)
-    for (src = *src_pos; *src; src += 2, dst += 1)
-      *dst = (guint8) ((HEX_TO_INT (src[0]) << 4) | (HEX_TO_INT (src[1])));
-
-  return res;
 	}
 
-static guint8 *
+	*len = data - dataOrig;
-vfs301_proto_generate (int type, int subtype, gssize *len)
+}
-{
+
-  switch (type)
+static void vfs301_proto_generate(int type, int subtype, unsigned char *data, int *len)
 {
+	switch (type) {
 	case 0x01:
 	case 0x04:
 		/* After cmd 0x04 is sent, a data is received on VALIDITY_RECEIVE_ENDPOINT_CTRL.
@@ -206,18 +173,12 @@ vfs301_proto_generate (int type, int subtype, gssize *len)
 	case 0x17:
 	case 0x19:
 	case 0x1A:
-      {
-        guint8 *data = g_malloc0 (1);
 		*data = type;
 		*len = 1;
-        return data;
-      }
 		break;
-
 	case 0x0B:
-      return vfs301_proto_generate_0B (subtype, len);
+		vfs301_proto_generate_0B(subtype, data, len);
 		break;
-
 	case 0x02D0:
 		{
 			const char **dataLs[] = {
@@ -229,93 +190,76 @@ vfs301_proto_generate (int type, int subtype, gssize *len)
 				vfs301_02D0_06,
 				vfs301_02D0_07,
 			};
-        g_assert ((int) subtype <= G_N_ELEMENTS (dataLs));
+			g_assert((int)subtype <= (int)(sizeof(dataLs) / sizeof(dataLs[0])));
-        return translate_str (dataLs[subtype - 1], len);
+			translate_str(dataLs[subtype - 1], data, len);
 		}
 		break;
-
 	case 0x0220:
-      switch (subtype)
+		switch (subtype) {
-        {
 		case 1:
-          return translate_str (vfs301_0220_01, len);
+			translate_str(vfs301_0220_01, data, len);
 			break;
-
 		case 2:
-          return translate_str (vfs301_0220_02, len);
+			translate_str(vfs301_0220_02, data, len);
 			break;
-
 		case 3:
-          return translate_str (vfs301_0220_03, len);
+			translate_str(vfs301_0220_03, data, len);
 			break;
-
 		case 0xFA00:
 		case 0x2C01:
-        case 0x5E01: {
+		case 0x5E01:
-            guint8 *data;
+			translate_str(vfs301_next_scan_template, data, len);
-            guint8 *field;
+			unsigned char *field = data + *len - (sizeof(S4_TAIL) - 1) / 2 - 4;
 
-            data = translate_str (vfs301_next_scan_template, len);
+			g_assert(*field == 0xDE);
-            field = data + *len - (sizeof (S4_TAIL) - 1) / 2 - 4;
+			g_assert(*(field + 1) == 0xAD);
+			g_assert(*(field + 2) == 0xDE);
+			g_assert(*(field + 3) == 0xAD);
 
-            g_assert (field >= data && field < data + *len);
+			*field = (unsigned char)((subtype >> 8) & 0xFF);
-            g_assert (field[0] == 0xDE);
+			*(field + 1) = (unsigned char)(subtype & 0xFF);
-            g_assert (field[1] == 0xAD);
+			*(field + 2) = *field;
-            g_assert (field[2] == 0xDE);
+			*(field + 3) = *(field + 1);
-            g_assert (field[3] == 0xAD);
-
-            field[0] = (guint8) ((subtype >> 8) & 0xFF);
-            field[1] = (guint8) (subtype & 0xFF);
-            field[2] = field[0];
-            field[3] = field[1];
-
-            return data;
 			break;
-          }
-
 		default:
-          g_assert_not_reached ();
+			g_assert(0);
 			break;
 		}
 		break;
-
 	case 0x06:
+		g_assert_not_reached();
+		break;
 	default:
+		g_assert_not_reached();
 		break;
 	}
-
-  g_assert_not_reached ();
-  *len = 0;
-  return NULL;
 }
 
 /************************** SCAN IMAGE PROCESSING *****************************/
 
 #ifdef SCAN_FINISH_DETECTION
-static int
+static int img_is_finished_scan(fp_line_t *lines, int no_lines)
-img_is_finished_scan (fp_line_t *lines, int no_lines)
 {
 	int i;
 	int j;
 	int rv = 1;
 
-  for (i = no_lines - VFS301_FP_SUM_LINES; i < no_lines; i++)
+	for (i = no_lines - VFS301_FP_SUM_LINES; i < no_lines; i++) {
-    {
 		/* check the line for fingerprint data */
-      for (j = 0; j < sizeof (lines[i].sum2); j++)
+		for (j = 0; j < sizeof(lines[i].sum2); j++) {
 			if (lines[i].sum2[j] > (VFS301_FP_SUM_MEDIAN + VFS301_FP_SUM_EMPTY_RANGE))
 				rv = 0;
 		}
+	}
 
 	return rv;
 }
 #endif
 
-static int
+static int scanline_diff(const unsigned char *scanlines, int prev, int cur)
-scanline_diff (const guint8 *scanlines, int prev, int cur)
 {
-  const guint8 *line1 = scanlines + prev * VFS301_FP_OUTPUT_WIDTH;
+	const unsigned char *line1 = scanlines + prev * VFS301_FP_OUTPUT_WIDTH;
-  const guint8 *line2 = scanlines + cur * VFS301_FP_OUTPUT_WIDTH;
+	const unsigned char *line2 = scanlines + cur * VFS301_FP_OUTPUT_WIDTH;
 	int i;
 	int diff;
 
@@ -327,8 +271,7 @@ scanline_diff (const guint8 *scanlines, int prev, int cur)
 
 	/* TODO: This doesn't work too well when there are parallel lines in the 
 	 * fingerprint. */
-  for (diff = 0, i = 0; i < VFS301_FP_WIDTH; i++)
+	for (diff = 0, i = 0; i < VFS301_FP_WIDTH; i++) {
-    {
 		if (*line1 > *line2)
 			diff += *line1 - *line2;
 		else
@@ -338,15 +281,15 @@ scanline_diff (const guint8 *scanlines, int prev, int cur)
 		line2++;
 	}
 
-  return (diff / VFS301_FP_WIDTH) > VFS301_FP_LINE_DIFF_THRESHOLD;
+	return ((diff / VFS301_FP_WIDTH) > VFS301_FP_LINE_DIFF_THRESHOLD);
 }
 
 /** Transform the input data to a normalized fingerprint scan */
-void
+void vfs301_extract_image(
-vfs301_extract_image (FpDeviceVfs301 *vfs, guint8 *output, int *output_height
+	vfs301_dev_t *vfs, unsigned char *output, int *output_height
 )
 {
-  const guint8 *scanlines = vfs->scanline_buf;
+	const unsigned char *scanlines = vfs->scanline_buf;
 	int last_line;
 	int i;
 
@@ -362,10 +305,8 @@ vfs301_extract_image (FpDeviceVfs301 *vfs, guint8 *output, int *output_height
 	 * of bi/tri-linear resampling to get the output (so that we don't get so
 	 * many false edges etc.).
 	 */
-  for (i = 1; i < vfs->scanline_count; i++)
+	for (i = 1; i < vfs->scanline_count; i++) {
-    {
+		if (scanline_diff(scanlines, last_line, i)) {
-      if (scanline_diff (scanlines, last_line, i))
-        {
 			memcpy(
 				output + VFS301_FP_OUTPUT_WIDTH * (*output_height),
 				scanlines + VFS301_FP_OUTPUT_WIDTH * i,
@@ -377,38 +318,35 @@ vfs301_extract_image (FpDeviceVfs301 *vfs, guint8 *output, int *output_height
 	}
 }
 
-static int
+static int img_process_data(
-img_process_data (int first_block, FpDeviceVfs301 *dev, const guint8 *buf, int len)
+	int first_block, vfs301_dev_t *dev, const unsigned char *buf, int len
+)
 {
 	vfs301_line_t *lines = (vfs301_line_t*)buf;
 	int no_lines = len / sizeof(vfs301_line_t);
 	int i;
 	/*int no_nonempty;*/
-  guint8 *cur_line;
+	unsigned char *cur_line;
 	int last_img_height;
-
 #ifdef SCAN_FINISH_DETECTION
 	int finished_scan;
 #endif
 
-  if (first_block)
+	if (first_block) {
-    {
 		last_img_height = 0;
 		dev->scanline_count = no_lines;
-    }
+	} else {
-  else
-    {
 		last_img_height = dev->scanline_count;
 		dev->scanline_count += no_lines;
 	}
 
-  dev->scanline_buf = g_realloc (dev->scanline_buf, dev->scanline_count * VFS301_FP_OUTPUT_WIDTH);
+	dev->scanline_buf = realloc(dev->scanline_buf, dev->scanline_count * VFS301_FP_OUTPUT_WIDTH);
+	g_assert(dev->scanline_buf != NULL);
 
 	for (cur_line = dev->scanline_buf + last_img_height * VFS301_FP_OUTPUT_WIDTH, i = 0;
 		i < no_lines;
 		i++, cur_line += VFS301_FP_OUTPUT_WIDTH
-      )
+	) {
-    {
 #ifndef OUTPUT_RAW
 		memcpy(cur_line, lines[i].scan, VFS301_FP_OUTPUT_WIDTH);
 #else
@@ -427,127 +365,115 @@ img_process_data (int first_block, FpDeviceVfs301 *dev, const guint8 *buf, int l
 
 /************************** PROTOCOL STUFF ************************************/
 
+static unsigned char usb_send_buf[0x2000];
+
 #define USB_RECV(from, len) \
-  usb_recv (dev, from, len, NULL, NULL)
+	usb_recv(dev, devh, from, len)
 
 #define USB_SEND(type, subtype) \
 	{ \
-    const guint8 *data; \
+		int len; \
-    gssize len; \
+		vfs301_proto_generate(type, subtype, usb_send_buf, &len); \
-    data = vfs301_proto_generate (type, subtype, &len); \
+		usb_send(devh, usb_send_buf, len); \
-    usb_send (dev, data, len, NULL); \
 	}
 
 #define RAW_DATA(x) x, sizeof(x)
 
 #define IS_VFS301_FP_SEQ_START(b) ((b[0] == 0x01) && (b[1] == 0xfe))
 
-static int
+static int vfs301_proto_process_data(int first_block, vfs301_dev_t *dev)
-vfs301_proto_process_data (FpDeviceVfs301 *dev, int first_block, const guint8 *buf, gint len)
 {
 	int i;
+	const unsigned char *buf = dev->recv_buf;
+	int len = dev->recv_len;
 
-  if (first_block)
+	if (first_block) {
-    {
 		g_assert(len >= VFS301_FP_FRAME_SIZE);
 
 		/* Skip bytes until start_sequence is found */
-      for (i = 0; i < VFS301_FP_FRAME_SIZE; i++, buf++, len--)
+		for (i = 0; i < VFS301_FP_FRAME_SIZE; i++, buf++, len--) {
 			if (IS_VFS301_FP_SEQ_START(buf))
 				break;
 		}
+	}
 
 	return img_process_data(first_block, dev, buf, len);
 }
 
-void
+void vfs301_proto_request_fingerprint(
-vfs301_proto_request_fingerprint (FpDeviceVfs301 *dev)
+	struct libusb_device_handle *devh, vfs301_dev_t *dev)
 {
 	USB_SEND(0x0220, 0xFA00);
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 000000000000 */
 }
 
-int
+int vfs301_proto_peek_event(
-vfs301_proto_peek_event (FpDeviceVfs301 *dev)
+	struct libusb_device_handle *devh, vfs301_dev_t *dev)
 {
-  g_autoptr(GError) error = NULL;
-  FpiUsbTransfer *transfer;
-
 	const char no_event[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
 	const char got_event[] = {0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00};
 
 	USB_SEND(0x17, -1);
-  usb_recv (dev, VFS301_RECEIVE_ENDPOINT_CTRL, 7, &transfer, &error);
+	g_assert(USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 7) == 0);
 
-  /* XXX: This is obviously not a sane error handling! */
+	if (memcmp(dev->recv_buf, no_event, sizeof(no_event)) == 0) {
-  g_assert (!error);
-
-  if (memcmp (transfer->buffer, no_event, sizeof (no_event)) == 0)
 		return 0;
-  else if (memcmp (transfer->buffer, got_event, sizeof (no_event)) == 0)
+	} else if (memcmp(dev->recv_buf, got_event, sizeof(no_event)) == 0) {
 		return 1;
-  else
+	} else {
 		g_assert_not_reached();
 	}
+}
 
-/* XXX: We sometimes need to receive data on from two endpoints at the same
+#define VARIABLE_ORDER(a, b) \
- *      time. However, as this driver is currently all synchronous (yikes),
- *      we will run into timeouts randomly and need to then try again.
- */
-#define PARALLEL_RECEIVE(e1, l1, e2, l2) \
 	{ \
-    g_autoptr(GError) error = NULL; \
+		int _rv = a;\
-    usb_recv (dev, e1, l1, NULL, &error); \
+		b; \
-    usb_recv (dev, e2, l2, NULL, NULL); \
+		if (_rv == -7) \
-    if (g_error_matches (error, G_USB_DEVICE_ERROR, G_USB_DEVICE_ERROR_TIMED_OUT)) \
+			a; \
-    usb_recv (dev, e1, l1, NULL, NULL); \
 	}
 
-static void
+static void vfs301_proto_process_event_cb(struct libusb_transfer *transfer)
-vfs301_proto_process_event_cb (FpiUsbTransfer *transfer,
-                               FpDevice *device,
-                               gpointer user_data, GError *error)
 {
-  FpDeviceVfs301 *dev = user_data;
+	vfs301_dev_t *dev = transfer->user_data;
+	struct libusb_device_handle *devh = transfer->dev_handle;
 
-  if (error)
+	if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
-    {
-      g_warning ("Error receiving data: %s", error->message);
-      g_error_free (error);
 		dev->recv_progress = VFS301_FAILURE;
-      return;
+		goto end;
-    }
+	} else if (transfer->actual_length < dev->recv_exp_amt) {
-  else if (transfer->actual_length < transfer->length)
-    {
 		/* TODO: process the data anyway? */
 		dev->recv_progress = VFS301_ENDED;
-      return;
+		goto end;
-    }
+	} else {
-  else
+		dev->recv_len = transfer->actual_length;
-    {
+		if (!vfs301_proto_process_data(dev->recv_exp_amt == VFS301_FP_RECV_LEN_1, dev)) {
-      FpiUsbTransfer *new;
-      if (!vfs301_proto_process_data (dev,
-                                      transfer->length == VFS301_FP_RECV_LEN_1,
-                                      transfer->buffer,
-                                      transfer->actual_length))
-        {
 			dev->recv_progress = VFS301_ENDED;
+			goto end;
+		}
+
+		dev->recv_exp_amt = VFS301_FP_RECV_LEN_2;
+		libusb_fill_bulk_transfer(
+			transfer, devh, VFS301_RECEIVE_ENDPOINT_DATA,
+			dev->recv_buf, dev->recv_exp_amt,
+			vfs301_proto_process_event_cb, dev, VFS301_FP_RECV_TIMEOUT);
+
+		if (libusb_submit_transfer(transfer) < 0) {
+			printf("cb::continue fail\n");
+			dev->recv_progress = VFS301_FAILURE;
+			goto end;
+		}
 		return;
 	}
 
-      new = fpi_usb_transfer_new (device);
+end:
-
+	libusb_free_transfer(transfer);
-      fpi_usb_transfer_fill_bulk (new, VFS301_RECEIVE_ENDPOINT_DATA, VFS301_FP_RECV_LEN_2);
-      fpi_usb_transfer_submit (new, VFS301_FP_RECV_TIMEOUT, NULL,
-                               vfs301_proto_process_event_cb, NULL);
-      return;
-    }
 }
 
-void
+void vfs301_proto_process_event_start(
-vfs301_proto_process_event_start (FpDeviceVfs301 *dev)
+	struct libusb_device_handle *devh, vfs301_dev_t *dev)
 {
-  FpiUsbTransfer *transfer;
+	struct libusb_transfer *transfer;
 
 	/*
 	 * Notes:
@@ -573,16 +499,24 @@ vfs301_proto_process_event_start (FpDeviceVfs301 *dev)
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_DATA, 64);
 
 	/* now read the fingerprint data, while there are some */
-  transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
+	transfer = fpi_usb_alloc();
 	dev->recv_progress = VFS301_ONGOING;
+	dev->recv_exp_amt = VFS301_FP_RECV_LEN_1;
 
-  fpi_usb_transfer_fill_bulk (transfer, VFS301_RECEIVE_ENDPOINT_DATA, VFS301_FP_RECV_LEN_1);
+	libusb_fill_bulk_transfer(
-  fpi_usb_transfer_submit (transfer, VFS301_FP_RECV_TIMEOUT, NULL,
+		transfer, devh, VFS301_RECEIVE_ENDPOINT_DATA,
-                           vfs301_proto_process_event_cb, NULL);
+		dev->recv_buf, dev->recv_exp_amt,
+		vfs301_proto_process_event_cb, dev, VFS301_FP_RECV_TIMEOUT);
+
+	if (libusb_submit_transfer(transfer) < 0) {
+		libusb_free_transfer(transfer);
+		dev->recv_progress = VFS301_FAILURE;
+		return;
+	}
 }
 
-int
+int /* vfs301_dev_t::recv_progress */ vfs301_proto_process_event_poll(
-vfs301_proto_process_event_poll (FpDeviceVfs301 *dev)
+	struct libusb_device_handle *devh, vfs301_dev_t *dev)
 {
 	if (dev->recv_progress != VFS301_ENDED)
 		return dev->recv_progress;
@@ -592,22 +526,21 @@ vfs301_proto_process_event_poll (FpDeviceVfs301 *dev)
 	USB_SEND(0x04, -1);
 	/* the following may come in random order, data may not come at all, don't
 	* try for too long... */
-  PARALLEL_RECEIVE (
+	VARIABLE_ORDER(
-    VFS301_RECEIVE_ENDPOINT_CTRL, 2,             /* 1204 */
+		USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2), /* 1204 */
-    VFS301_RECEIVE_ENDPOINT_DATA, 16384
+		USB_RECV(VFS301_RECEIVE_ENDPOINT_DATA, 16384)
 	);
 
 	USB_SEND(0x0220, 2);
-  PARALLEL_RECEIVE (
+	VARIABLE_ORDER(
-    VFS301_RECEIVE_ENDPOINT_DATA, 5760,             /* seems to always come */
+		USB_RECV(VFS301_RECEIVE_ENDPOINT_DATA, 5760), /* seems to always come */
-    VFS301_RECEIVE_ENDPOINT_CTRL, 2             /* 0000 */
+		USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2) /* 0000 */
 	);
 
 	return dev->recv_progress;
 }
 
-void
+void vfs301_proto_init(struct libusb_device_handle *devh, vfs301_dev_t *dev)
-vfs301_proto_init (FpDeviceVfs301 *dev)
 {
 	USB_SEND(0x01, -1);
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 38);
@@ -618,14 +551,14 @@ vfs301_proto_init (FpDeviceVfs301 *dev)
 	USB_SEND(0x19, -1);
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 64);
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 4); /* 6BB4D0BC */
-  usb_send (dev, RAW_DATA (vfs301_06_1), NULL);
+	usb_send(devh, RAW_DATA(vfs301_06_1));
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 0000 */
 
 	USB_SEND(0x01, -1);
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 38);
 	USB_SEND(0x1A, -1);
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 0000 */
-  usb_send (dev, RAW_DATA (vfs301_06_2), NULL);
+	usb_send(devh, RAW_DATA(vfs301_06_2));
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 0000 */
 	USB_SEND(0x0220, 1);
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 0000 */
@@ -634,7 +567,7 @@ vfs301_proto_init (FpDeviceVfs301 *dev)
 
 	USB_SEND(0x1A, -1);
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 0000 */
-  usb_send (dev, RAW_DATA (vfs301_06_3), NULL);
+	usb_send(devh, RAW_DATA(vfs301_06_3));
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 0000 */
 
 	USB_SEND(0x01, -1);
@@ -660,29 +593,29 @@ vfs301_proto_init (FpDeviceVfs301 *dev)
 	USB_SEND(0x02D0, 7);
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 0000 */
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_DATA, 832);
-  usb_send (dev, RAW_DATA (vfs301_12), NULL);
+	usb_send(devh, RAW_DATA(vfs301_12));
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 0000 */
 
 	USB_SEND(0x1A, -1);
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 0000 */
-  usb_send (dev, RAW_DATA (vfs301_06_2), NULL);
+	usb_send(devh, RAW_DATA(vfs301_06_2));
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 0000 */
 	USB_SEND(0x0220, 2);
-  PARALLEL_RECEIVE (
+	VARIABLE_ORDER(
-    VFS301_RECEIVE_ENDPOINT_CTRL, 2,             /* 0000 */
+		USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2), /* 0000 */
-    VFS301_RECEIVE_ENDPOINT_DATA, 5760
+		USB_RECV(VFS301_RECEIVE_ENDPOINT_DATA, 5760)
 	);
 
 	USB_SEND(0x1A, -1);
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 0000 */
-  usb_send (dev, RAW_DATA (vfs301_06_1), NULL);
+	usb_send(devh, RAW_DATA(vfs301_06_1));
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 0000 */
 
 	USB_SEND(0x1A, -1);
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 0000 */
-  usb_send (dev, RAW_DATA (vfs301_06_4), NULL);
+	usb_send(devh, RAW_DATA(vfs301_06_4));
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 0000 */
-  usb_send (dev, RAW_DATA (vfs301_24), NULL);     /* turns on white */
+	usb_send(devh, RAW_DATA(vfs301_24)); /* turns on white */
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_CTRL, 2); /* 0000 */
 
 	USB_SEND(0x01, -1);
@@ -693,7 +626,6 @@ vfs301_proto_init (FpDeviceVfs301 *dev)
 	USB_RECV(VFS301_RECEIVE_ENDPOINT_DATA, 5760);
 }
 
-void
+void vfs301_proto_deinit(struct libusb_device_handle *devh, vfs301_dev_t *dev)
-vfs301_proto_deinit (FpDeviceVfs301 *dev)
 {
 }

libfprint/drivers/vfs301_proto.h

@@ -0,0 +1,137 @@
+/*
+ * vfs301/vfs300 fingerprint reader driver
+ * https://github.com/andree182/vfs301
+ *
+ * Copyright (c) 2011-2012 Andrej Krutak <dev@andree.sk>
+ *
+ * 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 <libusb-1.0/libusb.h>
+
+enum {
+	VFS301_DEFAULT_WAIT_TIMEOUT = 300,
+
+	VFS301_SEND_ENDPOINT = 0x01,
+	VFS301_RECEIVE_ENDPOINT_CTRL = 0x81,
+	VFS301_RECEIVE_ENDPOINT_DATA = 0x82
+};
+
+#define VFS301_FP_RECV_LEN_1 (84032)
+#define VFS301_FP_RECV_LEN_2 (84096)
+
+typedef struct {
+	/* buffer for received data */
+	unsigned char recv_buf[0x20000];
+	int recv_len;
+
+	/* buffer to hold raw scanlines */
+	unsigned char *scanline_buf;
+	int scanline_count;
+
+	enum {
+		VFS301_ONGOING = 0,
+		VFS301_ENDED = 1,
+		VFS301_FAILURE = -1
+	} recv_progress;
+	int recv_exp_amt;
+} vfs301_dev_t;
+
+enum {
+	/* Width of the scanned data in px */
+	VFS301_FP_WIDTH = 200,
+
+	/* sizeof(fp_line_t) */
+	VFS301_FP_FRAME_SIZE = 288,
+	/* Width of output line */
+#ifndef OUTPUT_RAW
+	VFS301_FP_OUTPUT_WIDTH = VFS301_FP_WIDTH,
+#else
+	VFS301_FP_OUTPUT_WIDTH = VFS301_FP_FRAME_SIZE,
+#endif
+
+	VFS301_FP_SUM_LINES = 3,
+
+#ifdef SCAN_FINISH_DETECTION
+	/* TODO: The following changes (seen ~60 and ~80) In that
+	 * case we'll need to calibrate this from empty data somehow... */
+	VFS301_FP_SUM_MEDIAN = 60,
+	VFS301_FP_SUM_EMPTY_RANGE = 5,
+#endif
+
+	/* Minimum average difference between returned lines */
+	VFS301_FP_LINE_DIFF_THRESHOLD = 15,
+
+	/* Maximum waiting time for a single fingerprint frame */
+	VFS301_FP_RECV_TIMEOUT = 2000
+};
+
+/* Arrays of this structure is returned during the initialization as a response
+ * to the 0x02D0 messages.
+ * It seems to be always the same - what is it for? Some kind of confirmation?
+ */
+typedef struct {
+	unsigned char sync_0x01;
+	unsigned char sync_0xfe;
+
+	unsigned char counter_lo;
+	unsigned char counter_hi; /* FIXME ? */
+
+	unsigned char flags[3];
+
+	unsigned char sync_0x00;
+
+	unsigned char scan[VFS301_FP_WIDTH];
+} vfs301_init_line_t;
+
+typedef struct {
+	unsigned char sync_0x01;
+	unsigned char sync_0xfe;
+
+	unsigned char counter_lo;
+	unsigned char counter_hi;
+
+	unsigned char sync_0x08[2]; /* XXX: always? 0x08 0x08 */
+	/* 0x08 | 0x18 - Looks like 0x08 marks good quality lines */
+	unsigned char flag_1;
+	unsigned char sync_0x00;
+
+	unsigned char scan[VFS301_FP_WIDTH];
+
+	/* A offseted, stretched, inverted copy of scan... probably could
+	 * serve finger motion speed detection?
+	 * Seems to be subdivided to some 10B + 53B + 1B blocks */
+	unsigned char mirror[64];
+
+	/* Some kind of sum of the scan, very low contrast */
+	unsigned char sum1[2];
+	unsigned char sum2[11];
+	unsigned char sum3[3];
+} vfs301_line_t;
+
+void vfs301_proto_init(struct libusb_device_handle *devh, vfs301_dev_t *dev);
+void vfs301_proto_deinit(struct libusb_device_handle *devh, vfs301_dev_t *dev);
+
+void vfs301_proto_request_fingerprint(
+	struct libusb_device_handle *devh, vfs301_dev_t *dev);
+
+/** returns 0 if no event is ready, or 1 if there is one... */
+int vfs301_proto_peek_event(
+	struct libusb_device_handle *devh, vfs301_dev_t *dev);
+void vfs301_proto_process_event_start(
+	struct libusb_device_handle *devh, vfs301_dev_t *dev);
+int vfs301_proto_process_event_poll(
+	struct libusb_device_handle *devh, vfs301_dev_t *dev);
+
+void vfs301_extract_image(vfs301_dev_t *vfs, unsigned char *output, int *output_height);

libfprint/drivers/vfs301_proto_fragments.h

@@ -1147,7 +1147,7 @@ static const unsigned char vfs301_24[] = { /* 119 B */
  *
  * The contents of PACKET() inside this blob seems to be some kind
  * of a micro-program, which specifies which columns contain what. LE seems
- * to be used also here. Not necessarily is 1 output column described
+ * to be used also here. Not neccessarily is 1 output column described
  * by 1 operation. For example the vfs301_line_t::sum section seems
  * to perform 2 operations for each column - probably some kind of diff between
  * input lines?