Release 1.94.5

We used to ignore leaks, and we are ending up in having various of them,
so let's make valgrind to exit with error when using the valgrind test
setup (so in CI) to catch them better.

.gitlab-ci.yml

@@ -1,25 +1,28 @@
 include:
+  - local: '.gitlab-ci/libfprint-image-variables.yaml'
   - local: '.gitlab-ci/libfprint-templates.yaml'
-  - project: 'wayland/ci-templates'
+  - project: 'freedesktop/ci-templates'
     ref: master
     file: '/templates/fedora.yml'
   - remote: 'https://gitlab.gnome.org/GNOME/citemplates/-/raw/master/flatpak/flatpak_ci_initiative.yml'
 
 variables:
   extends: .libfprint_common_variables
-  FDO_DISTRIBUTION_TAG: latest
+  FDO_DISTRIBUTION_TAG: $LIBFPRINT_IMAGE_TAG
   FDO_DISTRIBUTION_VERSION: rawhide
+  FDO_UPSTREAM_REPO: "libfprint/$CI_PROJECT_NAME"
   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:
+  - image-build
   - check-source
   - build
   - test
   - flatpak
 
-image: "$FEDORA_IMAGE"
+image: $FEDORA_IMAGE
 
 .build_one_driver_template: &build_one_driver
   script:
@@ -52,7 +55,8 @@ build:
   artifacts:
     expose_as: "HTML Documentation"
     paths:
-    - _build/doc/html/
+    - _build/doc/html
+    - _build/doc/html/index.html
     expire_in: 1 week
 
 test:
@@ -63,12 +67,20 @@ test:
   script:
     - meson --werror -Ddrivers=all -Db_coverage=true . _build
     - ninja -C _build
-    - meson test -C _build --verbose --no-stdsplit --timeout-multiplier 3
+    - meson test -C _build --print-errorlogs --no-stdsplit --timeout-multiplier 3
     - ninja -C _build coverage
     - cat _build/meson-logs/coverage.txt
   artifacts:
+    reports:
+      junit: "_build/meson-logs/testlog.junit.xml"
+      coverage_report:
+        coverage_format: cobertura
+        path: _build/meson-logs/coverage.xml
+    expose_as: 'Coverage Report'
+    when: always
     paths:
       - _build/meson-logs
+      - _build/meson-logs/coveragereport/index.html
     expire_in: 1 week
   coverage: '/^TOTAL.*\s+(\d+\%)$/'
 
@@ -80,7 +92,17 @@ test_valgrind:
   script:
     - meson -Ddrivers=all . _build
     - ninja -C _build
-    - meson test -C _build --verbose --no-stdsplit --setup=valgrind
+    - meson test -C _build --print-errorlogs --no-stdsplit --setup=valgrind
+  artifacts:
+    reports:
+      junit: "_build/meson-logs/testlog.junit.xml"
+    expose_as: 'Valgrind test logs'
+    when: always
+    paths:
+      - _build/meson-logs
+      - _build/meson-logs/testlog-valgrind.txt
+    expire_in: 1 week
+
 
 test_scan_build:
   stage: test
@@ -90,10 +112,8 @@ test_scan_build:
   allow_failure: true
   script:
     - meson -Ddrivers=all . _build
-    # This is ugly, the wrapper disables the malloc checker
+    # Wrapper to add --status-bugs and disable 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
@@ -107,7 +127,7 @@ test_indent:
   script:
     - scripts/uncrustify.sh
     - git diff
-    - "! git status -s | grep -q ."
+    - git diff-index --name-only --exit-code HEAD
 
 test_unsupported_list:
   stage: check-source
@@ -121,7 +141,8 @@ test_unsupported_list:
 flatpak:
   stage: flatpak
   extends: .flatpak
-  image: registry.gitlab.gnome.org/gnome/gnome-runtime-images/gnome:3.36
+  # From https://gitlab.gnome.org/GNOME/gnome-runtime-images/container_registry
+  image: registry.gitlab.gnome.org/gnome/gnome-runtime-images/gnome:42
   variables:
     MANIFEST_PATH: "demo/org.freedesktop.libfprint.Demo.json"
     FLATPAK_MODULE: "libfprint"
@@ -142,12 +163,43 @@ flatpak:
       allow_failure: true
 
 # CONTAINERS creation stage
-container_fedora_build:
+.container_fedora_build_base:
   extends: .fdo.container-build@fedora
+  stage: image-build
+  only:
+    variables:
+      - $CI_PIPELINE_SOURCE == "never"
+  variables:
+    GIT_STRATEGY: none # no need to pull the whole tree for rebuilding the image
+    FDO_FORCE_REBUILD: 1
+    # a list of packages to install
+    FDO_DISTRIBUTION_PACKAGES:
+      $LIBFPRINT_DEPENDENCIES
+      vala
+      libpcap-devel
+      libudev-devel
+    FDO_DISTRIBUTION_EXEC: |
+      $LIBFPRINT_EXEC
+
+container_fedora_build_schedule:
+  extends: .container_fedora_build_base
   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
+
+container_fedora_build_manual:
+  extends: .container_fedora_build_base
+  only:
+    variables:
+      - $LIBFPRINT_CI_ACTION == "build-image"
+
+container_fedora_build_on_deps_changed:
+  extends: .container_fedora_build_base
+  only:
+    variables:
+      - $CI_PROJECT_NAMESPACE == "libfprint" && $CI_PIPELINE_SOURCE != "schedule"
+    refs:
+      - branches
+      - merge_requests
+    changes:
+      - .gitlab-ci/libfprint-image-variables.yaml

.gitlab-ci/libfprint-image-variables.yaml

@@ -0,0 +1,2 @@
+variables:
+  LIBFPRINT_IMAGE_TAG: v2

.gitlab-ci/libfprint-templates.yaml

@@ -1,6 +1,10 @@
+# Bump image version on .gitlab-ci/libfprint-image-variables.yaml to trigger
+# a rebuild on changes to this file
+
 .libfprint_common_variables:
   LIBFPRINT_DEPENDENCIES:
     doxygen
+    dnf-plugins-core
     flatpak-builder
     gcc
     gcc-c++
@@ -13,6 +17,7 @@
     gtk3-devel
     libabigail
     libgusb-devel
+    libgudev-devel
     libX11-devel
     libXv-devel
     meson
@@ -25,3 +30,18 @@
     uncrustify
     valgrind
     clang-analyzer
+    diffutils
+
+  LIBFPRINT_EXEC: |
+    dnf debuginfo-install -y \
+      glib2 \
+      glibc \
+      libgusb \
+      libusb \
+      nss \
+      pixman
+
+    git clone https://github.com/martinpitt/umockdev.git && \
+        cd umockdev && \
+        meson _build --prefix=/usr && \
+        ninja -C _build && ninja -C _build install

.gitlab-ci/scan-build

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

NEWS

@@ -1,6 +1,121 @@
 This file lists notable changes in each release. For the full history of all
 changes, see ChangeLog.
 
+2022-10-13: v1.94.5 release
+
+Highlights:
+ * New driver: fpcmoc, supporting various FPC MOC Fingerprint Sensors
+ * goodixmoc: New PIDs 0x6014, 0x6094, 0x631C, 0x634C, 0x6384, 0x659A.
+ * goodixmoc: Support resetting device on firmware failure due to corrupted DB.
+ * elanmoc: New PIDs 0x0c88, 0x0c8c, 0x0c8d.
+ * synaptics: New PID 0x0104.
+ * upektc: New PID 0x2017.
+ * Fixed various memory leaks
+ * More tests
+
+2022-05-24: v1.94.4 release
+
+Highlights:
+ * synaptics: New PIDs 0x0168, 0x015f
+ * elan: New PID 0x0c4b
+ * elanspi: New PID 0x241f
+ * synaptics: Minor fix to interrupt transfer resubmission
+ * Avoid sysfs writes if value is already expected
+ * Improvements to the testing setup
+ * Fixes to the internal critical section API
+
+2021-11-02: v1.94.3 release
+
+Highlights:
+ * Ensure idle mainloop before completing enumeration (fprintd#119)
+ * It is now possible to extend already enrolled prints
+ * elanspi: Fix timeout error with some hardware (#438)
+ * elanspi: Fix cancellation issues
+ * goodixmoc: Return matching device print; fixes duplicate checking (#444)
+ * goodixmoc: Support clearing the storage (usually unused)
+
+2021-11-02: v1.94.2 release
+
+Highlights:
+ * goodixmoc: Fix protocol error with certain username lengths
+ * elanmoc: New PID 0x0c7d
+ * goodixmoc: New PID 0x63cc
+
+2021-09-24: v1.94.1 release
+
+Highlights:
+ * Ship a simple script to create new CI tests using tshark
+ * Added CI tests for elan, uru4000, aes2501
+ * goodixmoc: Remove duplicate checking during enroll and let fprintd handle it
+ * uru4000: Fix USB transfer type
+ * synaptics: Support for new PIDs
+ * goodixmoc: Support for new PIDs
+
+2021-08-20: v1.94.0 release
+
+Highlights:
+ * Implement suspend/resume handling including USB wakeup configuration.
+   This requires writing the "persist" and "wakeup" sysfs attributes.
+ * Add simple temperature module to prevent devices from becoming too hot
+ * Add feature for continuous scanning
+ * New internal "critical section" API to simplify driver development
+ * elan: new PID 0x0c58
+ * elanmoc: Fixes for multi-user handling and FW changes
+ * virtual-device: Do not time out for SCAN command
+
+2021-06-30: v1.92.1 release
+
+Highlights:
+ * elanmoc: New driver for ELAN match-on-chip devices
+ * egis0570: New driver for some Egis Technology devices
+ * synaptics: Fix empty identify causing enroll issues
+ * elan: Support more PIDs
+ * misc: Architecture related bugfixes
+
+2021-06-30: v1.92.0 release
+
+Highlights:
+ * Support for SPI devices was added together with the elanspi driver
+ * Generate hwdb for autosuspend (which is now pulled by systemd)
+ * An API was added to clear the device storage.
+   Note: Devices may not implement the "list" API anymore.
+ * Device features can now be queried using a common API
+
+New drivers:
+ * vfs7552
+ * nb1010
+ * elanspi
+
+Driver changes:
+ * uru4000: Fix deactivation when unplugged unexpectedly
+ * goodixmoc: Correctly complete verify/identify after retry condition
+ * goodixmoc: Support power shield feature
+ * goodixmoc: Support new PIDs
+ * synaptics: Fix driver lockup when sequence counter overflows (#358)
+ * synaptics: Remove unnecessary device reset
+ * synaptics: Support new PIDs
+ * synaptics: Add clear_storage and remove list support
+ * synaptics: Fix initialization if the device is still busy when opening
+ * upeksonly: Fix double free in USB transfer callbacks
+ * elan: Support new PIDs
+ * vfs301: Fix leak of USB transfer
+ * uru4000: Silence warning happening during startup
+
+Internal API changes:
+ * ssm: Add getter for the device
+ * ssm: Add cleanup state feature
+ * image-device: Allow overriding number of enroll stages
+ * context: Support udev based device discovery
+ * spi-transfer: Add SPI transfer helper routines
+
+Other:
+ * Use pcap based USB replay for CI
+ * New virtual drivers for more advanced testing
+ * Ensure async operations are run in the thread local main context
+ * Disable drivers on big-endian unless they are verified to work
+ * Add missing gobject-introspection dependency
+
+
 2020-12-01: v1.90.7 release
 
 Highlights:

README

@@ -1,51 +0,0 @@
-libfprint
-=========
-
-libfprint is part of the fprint project:
-https://fprint.freedesktop.org/
-
-libfprint was originally developed as part of an academic project at the
-University of Manchester with the aim of hiding differences between different
-consumer fingerprint scanners and providing a single uniform API to application
-developers. The ultimate goal of the fprint project is to make fingerprint
-scanners widely and easily usable under common Linux environments.
-
-The academic university project runs off a codebase maintained separately
-from this one, although I try to keep them as similar as possible (I'm not
-hiding anything in the academic branch, it's just the open source release
-contains some commits excluded from the academic project).
-
-THE UNIVERSITY OF MANCHESTER DOES NOT ENDORSE THIS THIS SOFTWARE RELEASE AND
-IS IN NO WAY RESPONSIBLE FOR THE CODE CONTAINED WITHIN, OR ANY DAMAGES CAUSED
-BY USING OR DISTRIBUTING THE SOFTWARE. Development does not happen on
-university computers and the project is not hosted at the university either.
-
-For more information on libfprint, supported devices, API documentation, etc.,
-see the homepage:
-https://fprint.freedesktop.org/
-
-libfprint is licensed under the GNU LGPL version 2.1. See the COPYING file
-for the license text.
-
-Section 6 of the license states that for compiled works that use this
-library, such works must include libfprint copyright notices alongside the
-copyright notices for the other parts of the work. We have attempted to
-make this process slightly easier for you by grouping these all in one place:
-the AUTHORS file.
-
-libfprint includes code from NIST's NBIS software distribution:
-http://fingerprint.nist.gov/NBIS/index.html
-We include bozorth3 from the US export controlled distribution. We have
-determined that it is fine to ship bozorth3 in an open source project,
-see https://fprint.freedesktop.org/us-export-control.html
-
-## Historical links
-
-Older versions of libfprint are available at:
-https://sourceforge.net/projects/fprint/files/
-
-Historical mailing-list archives:
-http://www.reactivated.net/fprint_list_archives/
-
-Historical website:
-http://web.archive.org/web/*/https://www.freedesktop.org/wiki/Software/fprint/

README.md

@@ -0,0 +1,86 @@
+
+
+<div align="center">
+
+# LibFPrint
+
+*LibFPrint is part of the **[FPrint][Website]** project.*
+
+<br/>
+
+[![Button Website]][Website]
+[![Button Documentation]][Documentation]
+
+[![Button Supported]][Supported]
+[![Button Unsupported]][Unsupported]
+
+[![Button Contribute]][Contribute]
+[![Button Contributors]][Contributors]
+
+</div>
+
+## History
+
+**LibFPrint** was originally developed as part of an
+academic project at the **[University Of Manchester]**.
+
+It aimed to hide the differences between consumer
+fingerprint scanners and provide a single uniform
+API to application developers.
+
+## Goal
+
+The ultimate goal of the **FPrint** project is to make
+fingerprint scanners widely and easily usable under
+common Linux environments.
+
+## License
+
+`Section 6` of the license states that for compiled works that use
+this library, such works must include **LibFPrint** copyright notices
+alongside the copyright notices for the other parts of the work.
+
+**LibFPrint** includes code from **NIST's** **[NBIS]** software distribution.
+
+We include **Bozorth3** from the **[US Export Controlled]**
+distribution, which we have determined to be fine
+being shipped in an open source project.
+
+<br/>
+
+<div align="right">
+
+[![Badge License]][License]
+
+</div>
+
+
+<!----------------------------------------------------------------------------->
+
+[Documentation]: https://fprint.freedesktop.org/libfprint-dev/
+[Contributors]: https://gitlab.freedesktop.org/libfprint/libfprint/-/graphs/master
+[Unsupported]: https://gitlab.freedesktop.org/libfprint/wiki/-/wikis/Unsupported-Devices
+[Supported]: https://fprint.freedesktop.org/supported-devices.html
+[Website]: https://fprint.freedesktop.org/
+
+[Contribute]: ./HACKING.md
+[License]: ./COPYING
+
+[University Of Manchester]: https://www.manchester.ac.uk/
+[US Export Controlled]: https://fprint.freedesktop.org/us-export-control.html
+[NBIS]: http://fingerprint.nist.gov/NBIS/index.html
+
+
+<!---------------------------------[ Badges ]---------------------------------->
+
+[Badge License]: https://img.shields.io/badge/License-LGPL2.1-015d93.svg?style=for-the-badge&labelColor=blue
+
+
+<!---------------------------------[ Buttons ]--------------------------------->
+
+[Button Documentation]: https://img.shields.io/badge/Documentation-04ACE6?style=for-the-badge&logoColor=white&logo=BookStack
+[Button Contributors]: https://img.shields.io/badge/Contributors-FF4F8B?style=for-the-badge&logoColor=white&logo=ActiGraph
+[Button Unsupported]: https://img.shields.io/badge/Unsupported_Devices-EF2D5E?style=for-the-badge&logoColor=white&logo=AdBlock
+[Button Contribute]: https://img.shields.io/badge/Contribute-66459B?style=for-the-badge&logoColor=white&logo=Git
+[Button Supported]: https://img.shields.io/badge/Supported_Devices-428813?style=for-the-badge&logoColor=white&logo=AdGuard
+[Button Website]: https://img.shields.io/badge/Homepage-3B80AE?style=for-the-badge&logoColor=white&logo=freedesktopDotOrg

TODO

@@ -1,30 +0,0 @@
-LIBRARY
-=======
-test suite against NFIQ compliance set
-make library optionally asynchronous and maybe thread-safe
-nbis cleanups
-API function to determine if img device supports uncond. capture
-race-free way of saying "save this print but don't overwrite"
-
-NEW DRIVERS
-===========
-Sunplus 895 driver
-AES3400/3500 driver
-ID Mouse driver
-Support for 2nd generation MS devices
-Support for 2nd generation UPEK devices
-
-IMAGING
-=======
-ignore first frame or two with aes2501
-aes2501: increase threshold "sum" for end-of-image detection
-aes2501 gain calibration
-aes4000 gain calibration
-aes4000 resampling
-PPMM parameter to get_minutiae seems to have no effect
-nbis minutiae should be stored in endian-independent format
-
-PORTABILITY
-===========
-OpenBSD can't do -Wshadow or visibility
-OpenBSD: add compat codes for ENOTSUP ENODATA and EPROTO

data/autosuspend.hwdb

@@ -4,6 +4,7 @@
 # Supported by libfprint driver aes1610
 usb:v08FFp1600*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver aes1660
 usb:v08FFp1660*
@@ -24,16 +25,19 @@ usb:v08FFp168D*
 usb:v08FFp168E*
 usb:v08FFp168F*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver aes2501
 usb:v08FFp2500*
 usb:v08FFp2580*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver aes2550
 usb:v08FFp2550*
 usb:v08FFp2810*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver aes2660
 usb:v08FFp2660*
@@ -55,14 +59,23 @@ usb:v08FFp268E*
 usb:v08FFp268F*
 usb:v08FFp2691*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver aes3500
 usb:v08FFp5731*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver aes4000
 usb:v5501p08FF*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
+
+# Supported by libfprint driver egis0570
+usb:v1C7Ap0570*
+usb:v1C7Ap0571*
+ ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver elan
 usb:v04F3p0903*
@@ -118,48 +131,106 @@ usb:v04F3p0C30*
 usb:v04F3p0C31*
 usb:v04F3p0C32*
 usb:v04F3p0C33*
+usb:v04F3p0C3D*
 usb:v04F3p0C42*
+usb:v04F3p0C4B*
 usb:v04F3p0C4D*
+usb:v04F3p0C4F*
+usb:v04F3p0C63*
+usb:v04F3p0C6E*
+usb:v04F3p0C58*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
+
+# Supported by libfprint driver elanmoc
+usb:v04F3p0C7D*
+usb:v04F3p0C7E*
+usb:v04F3p0C82*
+usb:v04F3p0C88*
+usb:v04F3p0C8C*
+usb:v04F3p0C8D*
+ ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver etes603
 usb:v1C7Ap0603*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
+
+# Supported by libfprint driver fpcmoc
+usb:v10A5pFFE0*
+usb:v10A5pA305*
+usb:v10A5pDA04*
+usb:v10A5pD805*
+usb:v10A5pD205*
+ ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver goodixmoc
 usb:v27C6p5840*
-usb:v27C6p6496*
+usb:v27C6p6014*
+usb:v27C6p6094*
+usb:v27C6p609C*
 usb:v27C6p60A2*
-usb:v27C6p63AC*
+usb:v27C6p631C*
+usb:v27C6p634C*
+usb:v27C6p6384*
 usb:v27C6p639C*
+usb:v27C6p63AC*
+usb:v27C6p63BC*
+usb:v27C6p63CC*
+usb:v27C6p6496*
+usb:v27C6p6584*
+usb:v27C6p658C*
+usb:v27C6p6592*
 usb:v27C6p6594*
+usb:v27C6p659A*
+usb:v27C6p659C*
+usb:v27C6p6A94*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
+
+# Supported by libfprint driver nb1010
+usb:v298Dp1010*
+ ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver synaptics
 usb:v06CBp00BD*
-usb:v06CBp00E9*
 usb:v06CBp00DF*
 usb:v06CBp00F9*
 usb:v06CBp00FC*
 usb:v06CBp00C2*
-usb:v06CBp00C9*
-usb:v06CBp00E7*
+usb:v06CBp0100*
+usb:v06CBp00F0*
+usb:v06CBp0103*
+usb:v06CBp0123*
+usb:v06CBp0126*
+usb:v06CBp0129*
+usb:v06CBp0168*
+usb:v06CBp015F*
+usb:v06CBp0104*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver upeksonly
 usb:v147Ep2016*
 usb:v147Ep1000*
 usb:v147Ep1001*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver upektc
 usb:v0483p2015*
+usb:v0483p2017*
 usb:v147Ep3001*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver upektc_img
 usb:v147Ep2020*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver uru4000
 usb:v045Ep00BC*
@@ -169,23 +240,28 @@ usb:v05BAp0007*
 usb:v05BAp0008*
 usb:v05BAp000A*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver vcom5s
 usb:v061Ap0110*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver vfs0050
 usb:v138Ap0050*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver vfs101
 usb:v138Ap0001*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver vfs301
 usb:v138Ap0005*
 usb:v138Ap0008*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Supported by libfprint driver vfs5011
 usb:v138Ap0010*
@@ -194,32 +270,60 @@ usb:v138Ap0015*
 usb:v138Ap0017*
 usb:v138Ap0018*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0
+
+# Supported by libfprint driver vfs7552
+usb:v138Ap0091*
+ ID_AUTOSUSPEND=1
+ ID_PERSIST=0
 
 # Known unsupported devices
+usb:v04E8p730B*
 usb:v04F3p036B*
 usb:v04F3p0C00*
-usb:v04F3p0C4B*
 usb:v04F3p0C4C*
-usb:v04F3p0C4F*
 usb:v04F3p0C57*
+usb:v04F3p0C5E*
+usb:v04F3p0C5A*
+usb:v04F3p0C70*
+usb:v04F3p0C72*
 usb:v04F3p2706*
+usb:v04F3p3057*
+usb:v04F3p3104*
+usb:v04F3p310D*
 usb:v06CBp0081*
 usb:v06CBp0088*
 usb:v06CBp008A*
 usb:v06CBp009A*
 usb:v06CBp009B*
 usb:v06CBp00A2*
+usb:v06CBp00A8*
 usb:v06CBp00B7*
 usb:v06CBp00BB*
 usb:v06CBp00BE*
+usb:v06CBp00C4*
 usb:v06CBp00CB*
+usb:v06CBp00C9*
 usb:v06CBp00D8*
 usb:v06CBp00DA*
+usb:v06CBp00DC*
+usb:v06CBp00E4*
+usb:v06CBp00E7*
+usb:v06CBp00E9*
+usb:v06CBp00FD*
 usb:v0A5Cp5801*
 usb:v0A5Cp5805*
 usb:v0A5Cp5834*
+usb:v0A5Cp5840*
+usb:v0A5Cp5841*
+usb:v0A5Cp5842*
 usb:v0A5Cp5843*
+usb:v0A5Cp5844*
+usb:v0A5Cp5845*
+usb:v0BDAp5812*
 usb:v10A5p0007*
+usb:v10A5p9200*
+usb:v10A5p9800*
 usb:v1188p9545*
 usb:v138Ap0007*
 usb:v138Ap003A*
@@ -227,7 +331,6 @@ usb:v138Ap003C*
 usb:v138Ap003D*
 usb:v138Ap003F*
 usb:v138Ap0090*
-usb:v138Ap0091*
 usb:v138Ap0092*
 usb:v138Ap0094*
 usb:v138Ap0097*
@@ -237,28 +340,39 @@ usb:v147Ep1002*
 usb:v1491p0088*
 usb:v16D1p1027*
 usb:v1C7Ap0300*
-usb:v1C7Ap0570*
 usb:v1C7Ap0575*
+usb:v1C7Ap0576*
 usb:v27C6p5042*
 usb:v27C6p5110*
 usb:v27C6p5117*
+usb:v27C6p5120*
+usb:v27C6p5125*
 usb:v27C6p5201*
 usb:v27C6p521D*
 usb:v27C6p5301*
 usb:v27C6p530C*
 usb:v27C6p532D*
+usb:v27C6p5335*
 usb:v27C6p533C*
 usb:v27C6p5381*
 usb:v27C6p5385*
 usb:v27C6p538C*
 usb:v27C6p538D*
 usb:v27C6p5395*
+usb:v27C6p5503*
+usb:v27C6p550A*
+usb:v27C6p550C*
 usb:v27C6p5584*
 usb:v27C6p55A2*
 usb:v27C6p55A4*
 usb:v27C6p55B4*
 usb:v27C6p5740*
+usb:v27C6p5E0A*
+usb:v27C6p581A*
 usb:v2808p9338*
+usb:v2808p93A9*
+usb:v298Dp2020*
 usb:v298Dp2033*
 usb:v3538p0930*
  ID_AUTOSUSPEND=1
+ ID_PERSIST=0

data/meson.build

@@ -1,6 +1,8 @@
-if get_option('udev_rules')
+if udev_hwdb_dir != ''
     # This file has to be updated using
     # ninja -C <builddir> libfprint/sync-udev-hwdb
+    # Note that the unsupported device list needs to be manually synced from
+    # the wiki. See comment in libfprint/fprint-list-uev-hwdb.c
 
     install_data('autosuspend.hwdb',
         rename: '60-autosuspend-@0@.hwdb'.format(versioned_libname),

demo/gtk-libfprint-test.c

@@ -526,7 +526,7 @@ libfprint_demo_window_init (LibfprintDemoWindow *window)
       return;
     }
 
-  if (!fp_device_supports_capture (g_ptr_array_index (devices, 0)))
+  if (!fp_device_has_feature (g_ptr_array_index (devices, 0), FP_DEVICE_FEATURE_CAPTURE))
     {
       libfprint_demo_set_mode (window, NOIMAGING_MODE);
       return;

demo/org.freedesktop.libfprint.Demo.json

@@ -1,12 +1,12 @@
 {
     "app-id": "org.freedesktop.libfprint.Demo",
     "runtime": "org.gnome.Platform",
-    "runtime-version": "3.36",
+    "runtime-version": "42",
     "sdk": "org.gnome.Sdk",
     "command": "gtk-libfprint-test",
     "finish-args": [
         /* X11 + XShm access */
-        "--share=ipc", "--socket=x11",
+        "--share=ipc", "--socket=fallback-x11",
         /* Wayland access */
         "--socket=wayland",
         /* OpenGL access */
@@ -18,7 +18,7 @@
     "modules": [
         {
             "name": "libusb",
-            "config-opts": [ "--disable-static", "--disable-udev" ],
+            "config-opts": [ "--disable-static" ],
             "cleanup": [
                 "/lib/*.la",
                 "/lib/pkgconfig",
@@ -26,13 +26,13 @@
             ],
             "sources": [
                 {
-                    "type": "archive",
-                    "url": "https://github.com/libusb/libusb/archive/v1.0.22.tar.gz",
-                    "sha256": "3500f7b182750cd9ccf9be8b1df998f83df56a39ab264976bdb3307773e16f48"
+                   "type": "archive",
+                   "url": "https://github.com/libusb/libusb/releases/download/v1.0.26/libusb-1.0.26.tar.bz2",
+                   "sha256": "12ce7a61fc9854d1d2a1ffe095f7b5fac19ddba095c259e6067a46500381b5a5"
                 }
             ],
             "post-install": [
-                "install -Dm644 COPYING /app/share/licenses/libgusb/COPYING"
+                "install -Dm644 COPYING /app/share/licenses/libusb/COPYING"
             ]
         },
         {
@@ -47,15 +47,26 @@
                 }
             ]
         },
+        {
+            "name": "gudev",
+            "buildsystem": "meson",
+            "config-opts": [ "-Dtests=disabled", "-Dintrospection=disabled" ],
+            "sources": [
+                {
+                    "type": "archive",
+                    "url": "https://download.gnome.org/sources/libgudev/236/libgudev-236.tar.xz",
+                    "sha256": "e50369d06d594bae615eb7aeb787de304ebaad07a26d1043cef8e9c7ab7c9524"
+                }
+            ]
+        },
         {
             "name": "libfprint",
             "buildsystem": "meson",
-            "config-opts": [ "-Dudev_rules=false", "-Dx11-examples=false", "-Dgtk-examples=true", "-Ddrivers=all" ],
+            "config-opts": [ "-Dudev_hwdb=disabled", "-Dudev_rules=disabled", "-Dgtk-examples=true", "-Ddrivers=all" ],
             "sources": [
                 {
                     "type": "git",
-                    "url": "https://gitlab.freedesktop.org/libfprint/libfprint.git",
-                    "branch": "wip/benzea/v2"
+                    "url": "https://gitlab.freedesktop.org/libfprint/libfprint.git"
                 }
             ]
         }

doc/libfprint-2-sections.txt

@@ -20,9 +20,11 @@ FP_TYPE_DEVICE
 FP_DEVICE_RETRY
 FP_DEVICE_ERROR
 FpDeviceType
+FpDeviceFeature
 FpScanType
 FpDeviceRetry
 FpDeviceError
+FpFingerStatusFlags
 fp_device_retry_quark
 fp_device_error_quark
 FpEnrollProgress
@@ -32,9 +34,13 @@ fp_device_get_device_id
 fp_device_get_name
 fp_device_get_scan_type
 fp_device_get_nr_enroll_stages
+fp_device_get_finger_status
+fp_device_get_features
+fp_device_has_feature
 fp_device_has_storage
 fp_device_supports_identify
 fp_device_supports_capture
+fp_device_is_open
 fp_device_open
 fp_device_close
 fp_device_enroll
@@ -43,6 +49,9 @@ fp_device_identify
 fp_device_capture
 fp_device_delete_print
 fp_device_list_prints
+fp_device_clear_storage
+fp_device_suspend
+fp_device_resume
 fp_device_open_finish
 fp_device_close_finish
 fp_device_enroll_finish
@@ -51,6 +60,9 @@ fp_device_identify_finish
 fp_device_capture_finish
 fp_device_delete_print_finish
 fp_device_list_prints_finish
+fp_device_clear_storage_finish
+fp_device_suspend_finish
+fp_device_resume_finish
 fp_device_open_sync
 fp_device_close_sync
 fp_device_enroll_sync
@@ -59,6 +71,9 @@ fp_device_identify_sync
 fp_device_capture_sync
 fp_device_delete_print_sync
 fp_device_list_prints_sync
+fp_device_clear_storage_sync
+fp_device_suspend_sync
+fp_device_resume_sync
 FpDevice
 </SECTION>
 
@@ -130,7 +145,9 @@ FpDeviceClass
 FpTimeoutFunc
 FpiDeviceAction
 FpIdEntry
+FpiDeviceUdevSubtypeFlags
 fpi_device_get_usb_device
+fpi_device_get_udev_data
 fpi_device_get_virtual_env
 fpi_device_get_current_action
 fpi_device_retry_new
@@ -148,6 +165,12 @@ fpi_device_action_is_cancelled
 fpi_device_add_timeout
 fpi_device_set_nr_enroll_stages
 fpi_device_set_scan_type
+fpi_device_update_features
+fpi_device_critical_enter
+fpi_device_critical_leave
+fpi_device_remove
+fpi_device_report_finger_status
+fpi_device_report_finger_status_changes
 fpi_device_action_error
 fpi_device_probe_complete
 fpi_device_open_complete
@@ -156,10 +179,15 @@ fpi_device_enroll_complete
 fpi_device_verify_complete
 fpi_device_identify_complete
 fpi_device_capture_complete
+fpi_device_clear_storage_complete
 fpi_device_delete_complete
+fpi_device_list_complete
+fpi_device_suspend_complete
+fpi_device_resume_complete
 fpi_device_enroll_progress
 fpi_device_verify_report
 fpi_device_identify_report
+fpi_device_class_auto_initialize_features
 </SECTION>
 
 <SECTION>
@@ -184,6 +212,7 @@ fpi_image_device_deactivate_complete
 fpi_image_device_report_finger_status
 fpi_image_device_image_captured
 fpi_image_device_retry_scan
+fpi_image_device_set_bz3_threshold
 </SECTION>
 
 <SECTION>
@@ -227,11 +256,15 @@ fpi_ssm_mark_completed
 fpi_ssm_mark_failed
 fpi_ssm_set_data
 fpi_ssm_get_data
+fpi_ssm_get_device
 fpi_ssm_get_error
 fpi_ssm_dup_error
 fpi_ssm_get_cur_state
-fpi_ssm_next_state_timeout_cb
+fpi_ssm_silence_debug
+fpi_ssm_spi_transfer_cb
+fpi_ssm_spi_transfer_with_weak_pointer_cb
 fpi_ssm_usb_transfer_cb
+fpi_ssm_usb_transfer_with_weak_pointer_cb
 FpiSsm
 </SECTION>
 
@@ -258,3 +291,20 @@ FPI_TYPE_USB_TRANSFER
 fpi_usb_transfer_get_type
 </SECTION>
 
+<SECTION>
+<FILE>fpi-spi-transfer</FILE>
+FpiSpiTransferCallback
+FpiSpiTransfer
+fpi_spi_transfer_new
+fpi_spi_transfer_ref
+fpi_spi_transfer_unref
+fpi_spi_transfer_write
+fpi_spi_transfer_write_full
+fpi_spi_transfer_read
+fpi_spi_transfer_read_full
+fpi_spi_transfer_submit
+fpi_spi_transfer_submit_sync
+<SUBSECTION Standard>
+FPI_TYPE_SPI_TRANSFER
+fpi_spi_transfer_get_type
+</SECTION>

doc/libfprint-2.types

@@ -0,0 +1,8 @@
+#include <fprint.h>
+#include <fp-image-device.h>
+
+fp_context_get_type
+fp_device_get_type
+fp_image_device_get_type
+fp_image_get_type
+fp_print_get_type

doc/libfprint-docs.xml

@@ -41,7 +41,8 @@
     </chapter>
 
     <chapter id="driver-helpers">
-      <title>USB and State Machine helpers</title>
+      <title>USB, SPI and State Machine helpers</title>
+      <xi:include href="xml/fpi-spi-transfer.xml"/>
       <xi:include href="xml/fpi-usb-transfer.xml"/>
       <xi:include href="xml/fpi-ssm.xml"/>
       <xi:include href="xml/fpi-log.xml"/>

doc/meson.build

@@ -26,10 +26,12 @@ docpath = join_paths(get_option('datadir'), 'gtk-doc', 'html')
 gnome.gtkdoc(versioned_libname,
     main_xml: 'libfprint-docs.xml',
     src_dir: join_paths(meson.source_root(), 'libfprint'),
+    include_directories: include_directories('../libfprint'),
     dependencies: libfprint_dep,
     content_files: content_files,
     expand_content_files: expand_content_files,
     ignore_headers: private_headers,
+    gobject_typesfile: 'libfprint-2.types',
     fixxref_args: [
         '--html-dir=@0@'.format(docpath),
         '--extra-dir=@0@'.format(join_paths(glib_docpath, 'glib')),

examples/enroll.c

@@ -35,6 +35,7 @@ typedef struct _EnrollData
   unsigned int  sigint_handler;
   FpFinger      finger;
   int           ret_value;
+  gboolean      update_fingerprint;
 } EnrollData;
 
 static void
@@ -76,7 +77,7 @@ on_enroll_completed (FpDevice *dev, GAsyncResult *res, void *user_data)
     {
       enroll_data->ret_value = EXIT_SUCCESS;
 
-      if (fp_device_has_storage (dev))
+      if (fp_device_has_feature (dev, FP_DEVICE_FEATURE_STORAGE))
         g_debug ("Device has storage, saving a print reference locally");
       else
         g_debug ("Device has not storage, saving print only locally");
@@ -84,7 +85,8 @@ on_enroll_completed (FpDevice *dev, GAsyncResult *res, void *user_data)
       /* Even if the device has storage, it may not be able to save all the
        * metadata that the print contains, so we can always save a local copy
        * containing the handle to the device print */
-      int r = print_data_save (print, enroll_data->finger);
+      int r = print_data_save (print, enroll_data->finger,
+                               enroll_data->update_fingerprint);
       if (r < 0)
         {
           g_warning ("Data save failed, code %d", r);
@@ -124,6 +126,40 @@ on_enroll_progress (FpDevice *device,
           fp_device_get_nr_enroll_stages (device));
 }
 
+static gboolean
+should_update_fingerprint (void)
+{
+  int update_choice;
+  gboolean update_fingerprint = FALSE;
+
+  printf ("Should an existing fingerprint be updated instead of being replaced (if present)? "
+          "Enter Y/y or N/n to make a choice.\n");
+  update_choice = getchar ();
+  if (update_choice == EOF)
+    {
+      g_warning ("EOF encountered while reading a character");
+      return EXIT_FAILURE;
+    }
+
+  switch (update_choice)
+    {
+    case 'y':
+    case 'Y':
+      update_fingerprint = TRUE;
+      break;
+
+    case 'n':
+    case 'N':
+      update_fingerprint = FALSE;
+      break;
+
+    default:
+      g_warning ("Invalid choice %c, should be Y/y or N/n.", update_choice);
+      return EXIT_FAILURE;
+    }
+  return update_fingerprint;
+}
+
 static void
 on_device_opened (FpDevice *dev, GAsyncResult *res, void *user_data)
 {
@@ -139,13 +175,26 @@ on_device_opened (FpDevice *dev, GAsyncResult *res, void *user_data)
       return;
     }
 
-  printf ("Opened device. It's now time to enroll your finger.\n\n");
+  printf ("Opened device.\n");
+
+  if (fp_device_has_feature (dev, FP_DEVICE_FEATURE_UPDATE_PRINT))
+    {
+      printf ("The device supports fingerprint updates.\n");
+      enroll_data->update_fingerprint = should_update_fingerprint ();
+    }
+  else
+    {
+      printf ("The device doesn't support fingerprint updates. Old prints will be erased.\n");
+      enroll_data->update_fingerprint = FALSE;
+    }
+
+  printf ("It's now time to enroll your finger.\n\n");
   printf ("You will need to successfully scan your %s finger %d times to "
           "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);
+  print_template = print_create_template (dev, enroll_data->finger, enroll_data->update_fingerprint);
   fp_device_enroll (dev, print_template, enroll_data->cancellable,
                     on_enroll_progress, NULL, NULL,
                     (GAsyncReadyCallback) on_enroll_completed,
@@ -171,11 +220,9 @@ main (void)
   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 ("This program will enroll the selected finger overwriting any print for the same"
+           " finger that was enrolled previously. Fingerprint updates without erasing old data"
+           " are possible on devices supporting that. Ctrl+C interrupts program execution.\n");
 
   g_print ("Choose the finger to enroll:\n");
   finger = finger_chooser ();

examples/identify.c

@@ -143,6 +143,7 @@ on_identify_cb (FpDevice *dev, FpPrint *match, FpPrint *print,
   if (match)
     {
       g_autoptr(FpPrint) matched_print = g_object_ref (match);
+      const GDate *date;
       char date_str[128] = {};
 
       identify_data->ret_value = EXIT_SUCCESS;
@@ -155,7 +156,8 @@ on_identify_cb (FpDevice *dev, FpPrint *match, FpPrint *print,
             matched_print = g_steal_pointer (&stored_print);
         }
 
-      if (fp_print_get_enroll_date (matched_print))
+      date = fp_print_get_enroll_date (matched_print);
+      if (date && g_date_valid (date))
         g_date_strftime (date_str, G_N_ELEMENTS (date_str), "%Y-%m-%d\0",
                          fp_print_get_enroll_date (matched_print));
       else
@@ -212,7 +214,7 @@ on_list_completed (FpDevice *dev, GAsyncResult *res, gpointer user_data)
 static void
 start_identification (FpDevice *dev, IdentifyData *identify_data)
 {
-  if (fp_device_has_storage (dev))
+  if (fp_device_has_feature (dev, FP_DEVICE_FEATURE_STORAGE))
     {
       g_print ("Creating finger template, using device storage...\n");
       fp_device_list_prints (dev, NULL,
@@ -293,7 +295,7 @@ main (void)
       return EXIT_FAILURE;
     }
 
-  if (!fp_device_supports_identify (dev))
+  if (!fp_device_has_feature (dev, FP_DEVICE_FEATURE_IDENTIFY))
     {
       g_warning ("Device %s does not support identification.",
                  fp_device_get_name (dev));

examples/img-capture.c

@@ -162,7 +162,7 @@ main (int argc, const char *argv[])
       return EXIT_FAILURE;
     }
 
-  if (!fp_device_supports_capture (dev))
+  if (!fp_device_has_feature (dev, FP_DEVICE_FEATURE_CAPTURE))
     {
       g_warning ("Device %s doesn't support capture",
                  fp_device_get_name (dev));

examples/manage-prints.c

@@ -161,7 +161,7 @@ on_list_completed (FpDevice     *dev,
                    finger_to_string (fp_print_get_finger (print)),
                    fp_print_get_username (print));
 
-          if (date)
+          if (date && g_date_valid (date))
             {
               g_date_strftime (buf, G_N_ELEMENTS (buf), "%Y-%m-%d\0", date);
               g_print (", enrolled on %s", buf);
@@ -231,7 +231,7 @@ on_device_opened (FpDevice     *dev,
       return;
     }
 
-  if (!fp_device_has_storage (dev))
+  if (!fp_device_has_feature (dev, FP_DEVICE_FEATURE_STORAGE))
     {
       g_warning ("Device %s doesn't support storage", fp_device_get_name (dev));
       g_main_loop_quit (list_data->loop);

examples/storage.c

@@ -102,8 +102,23 @@ save_data (GVariant *data)
   return 0;
 }
 
+static FpPrint *
+load_print_from_data (GVariant *data)
+{
+  const guchar *stored_data = NULL;
+  gsize stored_len;
+  FpPrint *print;
+
+  g_autoptr(GError) error = NULL;
+  stored_data = (const guchar *) g_variant_get_fixed_array (data, &stored_len, 1);
+  print = fp_print_deserialize (stored_data, stored_len, &error);
+  if (error)
+    g_warning ("Error deserializing data: %s", error->message);
+  return print;
+}
+
 int
-print_data_save (FpPrint *print, FpFinger finger)
+print_data_save (FpPrint *print, FpFinger finger, gboolean update_fingerprint)
 {
   g_autofree gchar *descr = get_print_data_descriptor (print, NULL, finger);
 
@@ -137,25 +152,12 @@ print_data_load (FpDevice *dev, FpFinger 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 load_print_from_data (val);
 
   return NULL;
 }
@@ -207,16 +209,30 @@ gallery_data_load (FpDevice *dev)
 }
 
 FpPrint *
-print_create_template (FpDevice *dev, FpFinger finger)
+print_create_template (FpDevice *dev, FpFinger finger, gboolean load_existing)
 {
+  g_autoptr(GVariantDict) dict = NULL;
   g_autoptr(GDateTime) datetime = NULL;
   g_autoptr(GDate) date = NULL;
+  g_autoptr(GVariant) existing_val = NULL;
+  g_autofree gchar *descr = get_print_data_descriptor (NULL, dev, finger);
   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 ());
+  if (load_existing)
+    {
+      dict = load_data ();
+      existing_val = g_variant_dict_lookup_value (dict, descr, G_VARIANT_TYPE ("ay"));
+      if (existing_val != NULL)
+        template = load_print_from_data (existing_val);
+    }
+  if (template == NULL)
+    {
+      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);

examples/storage.h

@@ -21,12 +21,14 @@
 #pragma once
 
 int print_data_save (FpPrint *print,
-                     FpFinger finger);
+                     FpFinger finger,
+                     gboolean update_fingerprint);
 FpPrint * print_data_load (FpDevice *dev,
                            FpFinger  finger);
 GPtrArray * gallery_data_load (FpDevice *dev);
-FpPrint * print_create_template (FpDevice *dev,
-                                 FpFinger  finger);
+FpPrint * print_create_template (FpDevice      *dev,
+                                 FpFinger       finger,
+                                 const gboolean load_existing);
 gboolean print_image_save (FpPrint    *print,
                            const char *path);
 gboolean save_image_to_pgm (FpImage    *img,

examples/utilities.c

@@ -101,6 +101,7 @@ finger_to_string (FpFinger finger)
     case FP_FINGER_RIGHT_LITTLE:
       return "right little";
 
+    case FP_FINGER_UNKNOWN:
     default:
       return "unknown";
     }

examples/verify.c

@@ -130,12 +130,14 @@ on_match_cb (FpDevice *dev, FpPrint *match, FpPrint *print,
 
   if (match)
     {
-      char date_str[128];
+      const GDate *date = fp_print_get_enroll_date (match);
+      char date_str[128] = "<unknown>";
 
       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));
+      if (date && g_date_valid (date))
+        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),
@@ -260,7 +262,7 @@ start_verification (FpDevice *dev, VerifyData *verify_data)
       return;
     }
 
-  if (fp_device_has_storage (dev))
+  if (fp_device_has_feature (dev, FP_DEVICE_FEATURE_STORAGE))
     {
       g_print ("Creating finger template, using device storage...\n");
       fp_device_list_prints (dev, NULL,

libfprint/drivers/aesx660.c

@@ -365,7 +365,7 @@ capture_read_stripe_data_cb (FpiUsbTransfer *transfer,
       return;
     }
 
-  fp_dbg ("Got %lu bytes of data", actual_length);
+  fp_dbg ("Got %" G_GSIZE_FORMAT " bytes of data", actual_length);
   while (actual_length)
     {
       gssize payload_length;
@@ -386,7 +386,7 @@ capture_read_stripe_data_cb (FpiUsbTransfer *transfer,
                        (priv->stripe_packet->data[AESX660_RESPONSE_SIZE_MSB_OFFSET] << 8);
       fp_dbg ("Got frame, type %.2x payload of size %.4lx",
               priv->stripe_packet->data[AESX660_RESPONSE_TYPE_OFFSET],
-              payload_length);
+              (long) payload_length);
 
       still_needed_len = MAX (0, AESX660_HEADER_SIZE + payload_length - (gssize) priv->stripe_packet->len);
       copy_len = MIN (actual_length, still_needed_len);
@@ -441,7 +441,7 @@ capture_run_state (FpiSsm *ssm, FpDevice *_dev)
       break;
 
     case CAPTURE_SET_IDLE:
-      fp_dbg ("Got %lu frames", priv->strips_len);
+      fp_dbg ("Got %" G_GSIZE_FORMAT " frames", priv->strips_len);
       aesX660_send_cmd (ssm, _dev, set_idle_cmd, sizeof (set_idle_cmd),
                         capture_set_idle_cmd_cb);
       break;

libfprint/drivers/egis0570.c

@@ -0,0 +1,444 @@
+/*
+ * Egis Technology Inc. (aka. LighTuning) 0570 driver for libfprint
+ * Copyright (C) 2021 Maxim Kolesnikov <kolesnikov@svyazcom.ru>
+ * Copyright (C) 2021 Saeed/Ali Rk <saeed.ali.rahimi@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#define FP_COMPONENT "egis0570"
+
+#include "egis0570.h"
+#include "drivers_api.h"
+
+/* Packet types */
+#define PKT_TYPE_INIT 0
+#define PKT_TYPE_REPEAT 1
+
+/* Struct */
+struct _FpDeviceEgis0570
+{
+  FpImageDevice parent;
+
+  gboolean      running;
+  gboolean      stop;
+
+  GSList       *strips;
+  guint8       *background;
+  gsize         strips_len;
+
+  int           pkt_num;
+  int           pkt_type;
+};
+G_DECLARE_FINAL_TYPE (FpDeviceEgis0570, fpi_device_egis0570, FPI, DEVICE_EGIS0570, FpImageDevice);
+G_DEFINE_TYPE (FpDeviceEgis0570, fpi_device_egis0570, FP_TYPE_IMAGE_DEVICE);
+
+static unsigned char
+egis_get_pixel (struct fpi_frame_asmbl_ctx *ctx, struct fpi_frame *frame, unsigned int x, unsigned int y)
+{
+  return frame->data[x + y * ctx->frame_width];
+}
+
+static struct fpi_frame_asmbl_ctx assembling_ctx = {
+  .frame_width = EGIS0570_IMGWIDTH,
+  .frame_height = EGIS0570_RFMGHEIGHT,
+  .image_width = EGIS0570_IMGWIDTH * 4 / 3,
+  .get_pixel = egis_get_pixel,
+};
+
+/*
+ * Service
+ */
+
+static gboolean
+is_last_pkt (FpDevice *dev)
+{
+  FpDeviceEgis0570 *self = FPI_DEVICE_EGIS0570 (dev);
+
+  int type = self->pkt_type;
+  int num = self->pkt_num;
+
+  gboolean r;
+
+  r = ((type == PKT_TYPE_INIT) && (num == (EGIS0570_INIT_TOTAL - 1)));
+  r |= ((type == PKT_TYPE_REPEAT) && (num == (EGIS0570_REPEAT_TOTAL - 1)));
+
+  return r;
+}
+
+/*
+ * Returns a bit for each frame on whether or not a finger has been detected.
+ * e.g. 00110 means that there is a finger in frame two and three.
+ */
+static char
+postprocess_frames (FpDeviceEgis0570 *self, guint8 * img)
+{
+  size_t mean[EGIS0570_IMGCOUNT] = {0, 0, 0, 0, 0};
+
+  if (!self->background)
+    {
+      self->background = g_malloc (EGIS0570_IMGWIDTH * EGIS0570_RFMGHEIGHT);
+      memset (self->background, 255, EGIS0570_IMGWIDTH * EGIS0570_RFMGHEIGHT);
+
+      for (size_t k = 0; k < EGIS0570_IMGCOUNT; k += 1)
+        {
+          guint8 * frame = &img[(k * EGIS0570_IMGSIZE) + EGIS0570_RFMDIS * EGIS0570_IMGWIDTH];
+
+          for (size_t i = 0; i < EGIS0570_IMGWIDTH * EGIS0570_RFMGHEIGHT; i += 1)
+            self->background[i] = MIN (self->background[i], frame[i]);
+        }
+
+      return 0;
+    }
+
+  for (size_t k = 0; k < EGIS0570_IMGCOUNT; k += 1)
+    {
+      guint8 * frame = &img[(k * EGIS0570_IMGSIZE) + EGIS0570_RFMDIS * EGIS0570_IMGWIDTH];
+
+      for (size_t i = 0; i < EGIS0570_IMGWIDTH * EGIS0570_RFMGHEIGHT; i += 1)
+        {
+          if (frame[i] - EGIS0570_MARGIN  > self->background[i])
+            frame[i] -= self->background[i];
+          else
+            frame[i] = 0;
+
+          mean[k] += frame[i];
+        }
+
+      mean[k] /= EGIS0570_IMGWIDTH * EGIS0570_RFMGHEIGHT;
+    }
+
+  char result = 0;
+
+  for (size_t k = 0; k < EGIS0570_IMGCOUNT; k += 1)
+    {
+      fp_dbg ("Finger status (picture number, mean) : %ld , %ld", k, mean[k]);
+      if (mean[k] > EGIS0570_MIN_MEAN)
+        result |= 1 << k;
+    }
+
+  return result;
+}
+
+/*
+ * Device communication
+ */
+
+static void
+data_resp_cb (FpiUsbTransfer *transfer, FpDevice *dev, gpointer user_data, GError *error)
+{
+  unsigned char *stripdata;
+  gboolean end = FALSE;
+  FpImageDevice *img_self = FP_IMAGE_DEVICE (dev);
+  FpDeviceEgis0570 *self = FPI_DEVICE_EGIS0570 (dev);
+
+  if (error)
+    {
+      fpi_ssm_mark_failed (transfer->ssm, error);
+      return;
+    }
+
+  int where_finger_is = postprocess_frames (self, transfer->buffer);
+
+  if (where_finger_is > 0)
+    {
+      FpiImageDeviceState state;
+
+      fpi_image_device_report_finger_status (img_self, TRUE);
+
+      g_object_get (dev, "fpi-image-device-state", &state, NULL);
+      if (state == FPI_IMAGE_DEVICE_STATE_CAPTURE)
+        {
+          for (size_t k = 0; k < EGIS0570_IMGCOUNT; k += 1)
+            {
+              if (where_finger_is & (1 << k))
+                {
+                  struct fpi_frame *stripe = g_malloc (EGIS0570_IMGWIDTH * EGIS0570_RFMGHEIGHT + sizeof (struct fpi_frame));
+                  stripe->delta_x = 0;
+                  stripe->delta_y = 0;
+                  stripdata = stripe->data;
+                  memcpy (stripdata, (transfer->buffer) + (((k) * EGIS0570_IMGSIZE) + EGIS0570_IMGWIDTH * EGIS0570_RFMDIS), EGIS0570_IMGWIDTH * EGIS0570_RFMGHEIGHT);
+                  self->strips = g_slist_prepend (self->strips, stripe);
+                  self->strips_len += 1;
+                }
+              else
+                {
+                  end = TRUE;
+                  break;
+                }
+            }
+        }
+    }
+  else
+    {
+      end = TRUE;
+    }
+
+  if (end)
+    {
+      if (!self->stop && (self->strips_len > 0))
+        {
+          g_autoptr(FpImage) img = NULL;
+          self->strips = g_slist_reverse (self->strips);
+          fpi_do_movement_estimation (&assembling_ctx, self->strips);
+          img = fpi_assemble_frames (&assembling_ctx, self->strips);
+          img->flags |= (FPI_IMAGE_COLORS_INVERTED | FPI_IMAGE_PARTIAL);
+          g_slist_free_full (self->strips, g_free);
+          self->strips = NULL;
+          self->strips_len = 0;
+          FpImage *resizeImage = fpi_image_resize (img, EGIS0570_RESIZE, EGIS0570_RESIZE);
+          fpi_image_device_image_captured (img_self, g_steal_pointer (&resizeImage));
+        }
+
+      fpi_image_device_report_finger_status (img_self, FALSE);
+    }
+
+  fpi_ssm_next_state (transfer->ssm);
+}
+
+static void
+recv_data_resp (FpiSsm *ssm, FpDevice *dev)
+{
+  FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
+
+  fpi_usb_transfer_fill_bulk (transfer, EGIS0570_EPIN, EGIS0570_INPSIZE);
+
+  transfer->ssm = ssm;
+  transfer->short_is_error = TRUE;
+
+  fpi_usb_transfer_submit (transfer, EGIS0570_TIMEOUT, NULL, data_resp_cb, NULL);
+}
+
+static void
+cmd_resp_cb (FpiUsbTransfer *transfer, FpDevice *dev, gpointer user_data, GError *error)
+{
+  if (error)
+    fpi_ssm_mark_failed (transfer->ssm, error);
+}
+
+static void
+recv_cmd_resp (FpiSsm *ssm, FpDevice *dev)
+{
+  FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
+
+  fpi_usb_transfer_fill_bulk (transfer, EGIS0570_EPIN, EGIS0570_PKTSIZE);
+
+  transfer->ssm = ssm;
+
+  fpi_usb_transfer_submit (transfer, EGIS0570_TIMEOUT, NULL, cmd_resp_cb, NULL);
+}
+
+static void
+send_cmd_req (FpiSsm *ssm, FpDevice *dev, unsigned char *pkt)
+{
+  FpiUsbTransfer *transfer = fpi_usb_transfer_new (dev);
+
+  fpi_usb_transfer_fill_bulk_full (transfer, EGIS0570_EPOUT, pkt, EGIS0570_PKTSIZE, NULL);
+
+  transfer->ssm = ssm;
+  transfer->short_is_error = TRUE;
+
+  fpi_usb_transfer_submit (transfer, EGIS0570_TIMEOUT, NULL, fpi_ssm_usb_transfer_cb, NULL);
+}
+
+/*
+ * SSM States
+ */
+
+enum sm_states {
+  SM_INIT,
+  SM_START,
+  SM_REQ,
+  SM_RESP,
+  SM_REC_DATA,
+  SM_DONE,
+  SM_STATES_NUM
+};
+
+static void
+ssm_run_state (FpiSsm *ssm, FpDevice *dev)
+{
+  FpDeviceEgis0570 *self = FPI_DEVICE_EGIS0570 (dev);
+  FpImageDevice *img_dev = FP_IMAGE_DEVICE (dev);
+
+  switch (fpi_ssm_get_cur_state (ssm))
+    {
+    case SM_INIT:
+      self->pkt_type = PKT_TYPE_INIT;
+      fpi_ssm_next_state (ssm);
+      break;
+
+    case SM_START:
+      if (self->stop)
+        {
+          fp_dbg ("deactivating, marking completed");
+          fpi_ssm_mark_completed (ssm);
+          fpi_image_device_deactivate_complete (img_dev, NULL);
+        }
+      else
+        {
+          self->pkt_num = 0;
+          fpi_ssm_next_state (ssm);
+        }
+      break;
+
+    case SM_REQ:
+      if (self->pkt_type == PKT_TYPE_INIT)
+        send_cmd_req (ssm, dev, init_pkts[self->pkt_num]);
+      else
+        send_cmd_req (ssm, dev, repeat_pkts[self->pkt_num]);
+      break;
+
+    case SM_RESP:
+      if (is_last_pkt (dev) == FALSE)
+        {
+          recv_cmd_resp (ssm, dev);
+          self->pkt_num += 1;
+          fpi_ssm_jump_to_state (ssm, SM_REQ);
+        }
+      else
+        {
+          if (self->pkt_type == PKT_TYPE_INIT)
+            self->pkt_type = PKT_TYPE_REPEAT;
+
+          fpi_ssm_next_state (ssm);
+        }
+      break;
+
+    case SM_REC_DATA:
+      recv_data_resp (ssm, dev);
+      break;
+
+    case SM_DONE:
+      fpi_ssm_jump_to_state (ssm, SM_START);
+      break;
+
+    default:
+      g_assert_not_reached ();
+    }
+}
+
+/*
+ * Activation
+ */
+
+static void
+loop_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
+{
+  FpImageDevice *img_dev = FP_IMAGE_DEVICE (dev);
+  FpDeviceEgis0570 *self = FPI_DEVICE_EGIS0570 (dev);
+
+  self->running = FALSE;
+  g_clear_pointer (&self->background, g_free);
+
+  if (error)
+    fpi_image_device_session_error (img_dev, error);
+}
+
+static void
+dev_activate (FpImageDevice *dev)
+{
+  FpDeviceEgis0570 *self = FPI_DEVICE_EGIS0570 (dev);
+  FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), ssm_run_state, SM_STATES_NUM);
+
+  self->stop    = FALSE;
+
+  fpi_ssm_start (ssm, loop_complete);
+
+  self->running = TRUE;
+
+  fpi_image_device_activate_complete (dev, NULL);
+}
+
+/*
+ * Opening
+ */
+
+static void
+dev_init (FpImageDevice *dev)
+{
+  GError *error = NULL;
+
+  g_usb_device_claim_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error);
+
+  fpi_image_device_open_complete (dev, error);
+}
+
+/*
+ * Closing
+ */
+
+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);
+}
+
+/*
+ * Deactivation
+ */
+
+static void
+dev_deactivate (FpImageDevice *dev)
+{
+  FpDeviceEgis0570 *self = FPI_DEVICE_EGIS0570 (dev);
+
+  if (self->running)
+    self->stop = TRUE;
+  else
+    fpi_image_device_deactivate_complete (dev, NULL);
+}
+
+/*
+ * Driver data
+ */
+
+static const FpIdEntry id_table[] = {
+  { .vid = 0x1c7a, .pid = 0x0570, },
+  { .vid = 0x1c7a, .pid = 0x0571, },
+  { .vid = 0,      .pid = 0, },
+};
+
+static void
+fpi_device_egis0570_init (FpDeviceEgis0570 *self)
+{
+}
+
+static void
+fpi_device_egis0570_class_init (FpDeviceEgis0570Class *klass)
+{
+  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
+  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
+
+  dev_class->id = "egis0570";
+  dev_class->full_name = "Egis Technology Inc. (aka. LighTuning) 0570";
+  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;
+  img_class->img_close = dev_deinit;
+  img_class->activate = dev_activate;
+  img_class->deactivate = dev_deactivate;
+
+  img_class->img_width = EGIS0570_IMGWIDTH;
+  img_class->img_height = -1;
+
+  img_class->bz3_threshold = EGIS0570_BZ3_THRESHOLD; /* security issue */
+}

libfprint/drivers/egis0570.h

@@ -0,0 +1,177 @@
+/*
+ * Egis Technology Inc. (aka. LighTuning) 0570 driver for libfprint
+ * Copyright (C) 2021 Maxim Kolesnikov <kolesnikov@svyazcom.ru>
+ * Copyright (C) 2021 Saeed/Ali Rk <saeed.ali.rahimi@gmail.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#ifndef __EGIS0570_H
+
+#define __EGIS0570_H 1
+
+/*
+ * Device data
+ */
+
+#define EGIS0570_CONF 1
+#define EGIS0570_INTF 0
+
+/*
+ * Device endpoints
+ */
+
+#define EGIS0570_EPOUT 0x04 /* ( 4 | FPI_USB_ENDPOINT_OUT ) */
+#define EGIS0570_EPIN 0x83  /* ( 3 | FPI_USB_ENDPOINT_IN ) */
+
+/*
+ * Initialization packets (7 bytes each)
+ *
+ * First 4 bytes are equivalent to string "EGIS", which must be just a company identificator
+ * Other 3 bytes are not recognized yet and may be not important, as they are always the same
+
+ * Answers for each packet contain 7 bytes again
+ * First 4 bytes are reversed "EGIS", which is "SIGE", which is company ID again
+ * Other 3 bytes are not recognized yet
+ * But there is a pattern.
+ * Sending last packet makes sensor return image
+ */
+
+#define EGIS0570_TIMEOUT 10000
+#define EGIS0570_PKTSIZE 7
+
+#define EGIS0570_INIT_TOTAL (sizeof ((init_pkts)) / sizeof ((init_pkts[0])))
+
+static unsigned char init_pkts[][EGIS0570_PKTSIZE] =
+{
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x20, 0x3f },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x58, 0x3f },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x21, 0x09 },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x57, 0x09 },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x22, 0x03 },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x56, 0x03 },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x23, 0x01 },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x55, 0x01 },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x24, 0x01 },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x54, 0x01 },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x3e },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x0b },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x03 },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00 },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x0f },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x10, 0x00 },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x11, 0x38 },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x12, 0x00 },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x13, 0x71 },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x03, 0x80 },
+  { 0x45, 0x47, 0x49, 0x53, 0x00, 0x02, 0x80 },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x2f },
+  { 0x45, 0x47, 0x49, 0x53, 0x06, 0x00, 0xfe }        /* image returned after this packet */
+};
+
+/* There is another Packet !
+ * That just Work the same !!
+ * And the Size is different !!!
+ */
+
+/*
+
+ #define EGIS0570_INIT_TOTAL2 (sizeof((init_pkts2)) / sizeof((init_pkts2[0])))
+
+   static unsigned char init_pkts2[][EGIS0570_PKTSIZE] =
+   {
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x10, 0x00},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x11, 0x38},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x12, 0x00},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x13, 0x71},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x20, 0x3f},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x58, 0x3f},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x21, 0x07},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x57, 0x07},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x22, 0x02},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x56, 0x02},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x23, 0x00},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x55, 0x00},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x24, 0x00},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x54, 0x00},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x25, 0x00},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x53, 0x00},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x3b},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x0a},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x00},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x0f},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x03, 0x80},
+        {0x45, 0x47, 0x49, 0x53, 0x00, 0x02, 0x80},
+        {0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x2f},
+        {0x45, 0x47, 0x49, 0x53, 0x06, 0x00, 0xfe}
+   };
+
+ */
+
+/*
+ * After sending initial packets device returns image data (32512 bytes)
+ * To ask device to send image data again, host needs to send four additional packets
+ * Further work is to repeatedly send four repeat packets and read image data
+ */
+
+#define EGIS0570_INPSIZE 32512
+
+/* 5 image with captured in different time of size 114 * 57 = 6498
+ * 5 * 6498 = 32490 plus 22 extra unrecognized char size data
+ * Two continuous image in this 5 images may have time delay of less than 20ms
+ */
+
+#define EGIS0570_IMGSIZE 6498
+#define EGIS0570_IMGWIDTH 114
+#define EGIS0570_IMGHEIGHT 57
+
+/* size of middle area that is used from each frame */
+#define EGIS0570_RFMGHEIGHT 17
+/* rows to ignore from top and bottom of the image*/
+#define EGIS0570_RFMDIS (EGIS0570_IMGHEIGHT - EGIS0570_RFMGHEIGHT) / 2
+#define EGIS0570_IMGCOUNT 5
+
+/*
+ * Image repeat request
+ * First 4 bytes are the same as in initialization packets
+ * Have no idea what the other 3 bytes mean
+ */
+
+#define EGIS0570_REPEAT_TOTAL (sizeof ((repeat_pkts)) / sizeof ((repeat_pkts[0])))
+
+static unsigned char repeat_pkts[][EGIS0570_PKTSIZE] =
+{
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x0f },
+  { 0x45, 0x47, 0x49, 0x53, 0x00, 0x02, 0x0f },
+  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x2f },
+  { 0x45, 0x47, 0x49, 0x53, 0x06, 0x00, 0xfe }         /* image returned after this packet */
+};
+
+/*
+ * This sensor is small so I decided to reduce bz3_threshold from
+ * 40 to 10 to have more success to fail ratio
+ * Bozorth3 Algorithm seems not fine at the end
+ * foreget about security :))
+ */
+
+#define EGIS0570_BZ3_THRESHOLD 25 /* and even less What a joke */
+
+#define EGIS0570_MIN_MEAN 20
+#define EGIS0570_MARGIN 3
+
+#define EGIS0570_RESIZE 2
+
+#endif

libfprint/drivers/elan.c

@@ -357,7 +357,7 @@ elan_cmd_cb (FpiUsbTransfer *transfer, FpDevice *dev,
   if (transfer->endpoint & FPI_USB_ENDPOINT_IN)
     {
       /* just finished receiving */
-      self->last_read = g_memdup (transfer->buffer, transfer->actual_length);
+      self->last_read = g_memdup2 (transfer->buffer, transfer->actual_length);
       elan_cmd_done (ssm);
     }
   else
@@ -760,7 +760,7 @@ calibrate_run_state (FpiSsm *ssm, FpDevice *dev)
           if (self->calib_status == 0x00 &&
               self->last_read[0] == 0x01)
             self->calib_status = 0x01;
-          fpi_ssm_next_state_delayed (ssm, 50, NULL);
+          fpi_ssm_next_state_delayed (ssm, 50);
         }
       break;
 

libfprint/drivers/elan.h

@@ -213,8 +213,14 @@ static const FpIdEntry elan_id_table[] = {
   {.vid = ELAN_VEND_ID,  .pid = 0x0c31, .driver_data = ELAN_ALL_DEV},
   {.vid = ELAN_VEND_ID,  .pid = 0x0c32, .driver_data = ELAN_ALL_DEV},
   {.vid = ELAN_VEND_ID,  .pid = 0x0c33, .driver_data = ELAN_ALL_DEV},
+  {.vid = ELAN_VEND_ID,  .pid = 0x0c3d, .driver_data = ELAN_ALL_DEV},
   {.vid = ELAN_VEND_ID,  .pid = 0x0c42, .driver_data = ELAN_0C42},
+  {.vid = ELAN_VEND_ID,  .pid = 0x0c4b, .driver_data = ELAN_ALL_DEV},
   {.vid = ELAN_VEND_ID,  .pid = 0x0c4d, .driver_data = ELAN_ALL_DEV},
+  {.vid = ELAN_VEND_ID,  .pid = 0x0c4f, .driver_data = ELAN_ALL_DEV},
+  {.vid = ELAN_VEND_ID,  .pid = 0x0c63, .driver_data = ELAN_ALL_DEV},
+  {.vid = ELAN_VEND_ID,  .pid = 0x0c6e, .driver_data = ELAN_ALL_DEV},
+  {.vid = ELAN_VEND_ID,  .pid = 0x0c58, .driver_data = ELAN_ALL_DEV},
   {.vid = 0,  .pid = 0,  .driver_data = 0},
 };
 

libfprint/drivers/elanmoc/elanmoc.h

@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2021 Elan Microelectronics
+ *
+ * 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-device.h"
+#include "fpi-ssm.h"
+#include <libusb.h>
+
+#include <stdio.h>
+#include <stdlib.h>
+
+G_DECLARE_FINAL_TYPE (FpiDeviceElanmoc, fpi_device_elanmoc, FPI, DEVICE_ELANMOC, FpDevice)
+
+#define ELAN_MOC_DRIVER_FULLNAME "Elan MOC Sensors"
+#define ELAN_M0C_CMD_LEN 0x3
+#define ELAN_EP_CMD_OUT (0x1 | LIBUSB_ENDPOINT_OUT)
+#define ELAN_EP_CMD_IN (0x3 | LIBUSB_ENDPOINT_IN)
+#define ELAN_EP_MOC_CMD_IN (0x4 | LIBUSB_ENDPOINT_IN)
+#define ELAN_EP_IMG_IN (0x2 | LIBUSB_ENDPOINT_IN)
+
+#define ELAN_MOC_CMD_TIMEOUT 5000
+#define ELAN_MOC_CAL_RETRY 500
+#define ELAN_MOC_ENROLL_TIMES 9
+#define ELAN_MAX_USER_ID_LEN 92
+#define ELAN_MAX_ENROLL_NUM 9
+
+#define ELAN_MSG_VERIFY_ERR 0xfd
+#define ELAN_MSG_DIRTY 0xfb
+#define ELAN_MSG_AREA_NOT_ENOUGH 0xfe
+#define ELAN_MSG_TOO_HIGH 0x41
+#define ELAN_MSG_TOO_LEFT 0x42
+#define ELAN_MSG_TOO_LOW 0x43
+#define ELAN_MSG_TOO_RIGHT 0x44
+#define ELAN_MSG_OK 0x00
+
+#define ELAN_MAX_HDR_LEN 3
+#define ELAN_USERDATE_SIZE (ELAN_MAX_USER_ID_LEN + 3)
+
+#define ELAN_MSG_DRIVER_VERSION "1004"
+
+struct elanmoc_cmd
+{
+  unsigned char cmd_header[ELAN_MAX_HDR_LEN];
+  int           cmd_len;
+  int           resp_len;
+};
+
+static const struct elanmoc_cmd fw_ver_cmd = {
+  .cmd_header = {0x40, 0x19},
+  .cmd_len = 2,
+  .resp_len = 2,
+};
+
+static const struct elanmoc_cmd sensor_dim_cmd = {
+  .cmd_header = {0x00, 0x0c},
+  .cmd_len = 2,
+  .resp_len = 4,
+};
+
+static const struct elanmoc_cmd cal_status_cmd = {
+  .cmd_header = {0x40, 0xff, 0x00},
+  .cmd_len = 3,
+  .resp_len = 2,
+};
+
+static const struct elanmoc_cmd enrolled_number_cmd = {
+  .cmd_header = {0x40, 0xff, 0x04},
+  .cmd_len = 3,
+  .resp_len = 2,
+};
+
+static const struct elanmoc_cmd elanmoc_verify_cmd = {
+  .cmd_header = {0x40, 0xff, 0x73},
+  .cmd_len = 5,
+  .resp_len = 2,
+};
+
+static const struct elanmoc_cmd elanmoc_above_cmd = {
+  .cmd_header = {0x40, 0xff, 0x02},
+  .cmd_len = 3,
+  .resp_len = 0,
+};
+
+static const struct elanmoc_cmd elanmoc_enroll_cmd = {
+  .cmd_header = {0x40, 0xff, 0x01},
+  .cmd_len = 7,
+  .resp_len = 2,
+};
+
+static const struct elanmoc_cmd elanmoc_delete_cmd = {
+  .cmd_header = {0x40, 0xff, 0x13},
+  .cmd_len = 128,
+  .resp_len = 2,
+};
+
+static const struct elanmoc_cmd elanmoc_enroll_commit_cmd = {
+  .cmd_header = {0x40, 0xff, 0x11},
+  .cmd_len = 128,
+  .resp_len = 2,
+};
+
+static const struct elanmoc_cmd elanmoc_remove_all_cmd = {
+  .cmd_header = {0x40, 0xff, 0x98},
+  .cmd_len = 3,
+  .resp_len = 2,
+};
+
+static const struct elanmoc_cmd elanmoc_get_userid_cmd = {
+  .cmd_header = {0x43, 0x21, 0x00},
+  .cmd_len = 3,
+  .resp_len = 97,
+};
+
+static const struct elanmoc_cmd elanmoc_set_mod_cmd = {
+  .cmd_header = {0x40, 0xff, 0x14},
+  .cmd_len = 4,
+  .resp_len = 2,
+};
+
+static const struct elanmoc_cmd elanmoc_check_reenroll_cmd = {
+  .cmd_header = {0x40, 0xff, 0x22},
+  .cmd_len = 3 + ELAN_USERDATE_SIZE,
+  .resp_len = 2,
+};
+
+typedef void (*ElanCmdMsgCallback) (FpiDeviceElanmoc *self,
+                                    GError           *error);
+
+enum moc_enroll_states {
+  MOC_ENROLL_GET_ENROLLED_NUM,
+  MOC_ENROLL_REENROLL_CHECK,
+  MOC_ENROLL_WAIT_FINGER,
+  MOC_ENROLL_COMMIT_RESULT,
+  MOC_ENROLL_NUM_STATES,
+};
+
+enum moc_list_states {
+  MOC_LIST_GET_ENROLLED,
+  MOC_LIST_GET_FINGER,
+  MOC_LIST_NUM_STATES,
+};
+
+enum delete_states {
+  DELETE_SEND_CMD,
+  DELETE_NUM_STATES,
+};
+
+enum dev_init_states {
+  DEV_WAIT_READY,
+  DEV_SET_MODE,
+  DEV_GET_VER,
+  DEV_GET_DIM,
+  DEV_GET_ENROLLED,
+  DEV_INIT_STATES,
+};
+
+enum dev_exit_states {
+  DEV_EXIT_ABOVE,
+  DEV_EXIT_STATES,
+};
+
+struct _FpiDeviceElanmoc
+{
+  FpDevice        parent;
+  FpiSsm         *task_ssm;
+  FpiSsm         *cmd_ssm;
+  FpiUsbTransfer *cmd_transfer;
+  gboolean        cmd_cancelable;
+  gsize           cmd_len_in;
+  unsigned short  fw_ver;
+  unsigned char   x_trace;
+  unsigned char   y_trace;
+  int             num_frames;
+  int             curr_enrolled;
+  int             max_moc_enroll_time;
+  int             cancel_result;
+  int             cmd_retry_cnt;
+  int             list_index;
+  GPtrArray      *list_result;
+};

libfprint/drivers/elanspi.h

@@ -0,0 +1,382 @@
+/*
+ * Elan SPI driver for libfprint
+ *
+ * Copyright (C) 2021 Matthew Mirvish <matthew@mm12.xyz>
+ *
+ * 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 <config.h>
+
+#ifndef HAVE_UDEV
+#error "elanspi requires udev"
+#endif
+
+#include <fp-device.h>
+#include <fpi-device.h>
+
+#define ELANSPI_TP_PID 0x04f3
+
+/* Sensor ID information copied from the windows driver */
+
+struct elanspi_sensor_entry
+{
+  unsigned char sensor_id, height, width, ic_version;
+  gboolean      is_otp_model;
+  const gchar * name;
+};
+
+static const struct elanspi_sensor_entry elanspi_sensor_table[] = {
+  {0x0, 0x78, 0x78, 0x0, 0x0, "eFSA120S"},
+  {0x1, 0x78, 0x78, 0x1, 0x1, "eFSA120SA"},
+  {0x2, 0xA0, 0xA0, 0x0, 0x0, "eFSA160S"},
+  {0x3, 0xd0, 0x50, 0x0, 0x0, "eFSA820R"},
+  {0x4, 0xC0, 0x38, 0x0, 0x0, "eFSA519R"},
+  {0x5, 0x60, 0x60, 0x0, 0x0, "eFSA96S"},
+  {0x6, 0x60, 0x60, 0x1, 0x1, "eFSA96SA"},
+  {0x7, 0x60, 0x60, 0x2, 0x1, "eFSA96SB"},
+  {0x8, 0xa0, 0x50, 0x1, 0x1, "eFSA816RA"},
+  {0x9, 0x90, 0x40, 0x1, 0x1, "eFSA614RA"},
+  {0xA, 0x90, 0x40, 0x2, 0x1, "eFSA614RB"},
+  {0xB, 0x40, 0x58, 0x1, 0x1, "eFSA688RA"},
+  {0xC, 0x50, 0x50, 0x1, 0x0, "eFSA80SA"},
+  {0xD, 0x47, 0x80, 0x1, 0x1, "eFSA712RA"},
+  {0xE, 0x50, 0x50, 0x2, 0x0, "eFSA80SC"},
+  {0,   0,    0,    0,   0,   NULL}
+};
+
+struct elanspi_reg_entry
+{
+  unsigned char addr, value;
+  /* terminates with 0xFF, 0xFF since register 0x0 is valid */
+};
+
+struct elanspi_regtable
+{
+  const struct elanspi_reg_entry *other;
+  struct
+  {
+    unsigned char                   sid;
+    const struct elanspi_reg_entry *table;
+  } entries[];
+};
+
+static const struct elanspi_reg_entry elanspi_calibration_table_default[] = {
+  {0x05, 0x60},
+  {0x06, 0xc0},
+  {0x07, 0x80},
+  {0x08, 0x04},
+  {0x0a, 0x97},
+  {0x0b, 0x72},
+  {0x0c, 0x69},
+  {0x0f, 0x2a},
+  {0x11, 0x2a},
+  {0x13, 0x27},
+  {0x15, 0x67},
+  {0x18, 0x04},
+  {0x21, 0x20},
+  {0x22, 0x36},
+  {0x2a, 0x5f},
+  {0x2b, 0xc0},
+  {0x2e, 0xff},
+
+  {0xff, 0xff}
+};
+
+static const struct elanspi_reg_entry elanspi_calibration_table_id6[] = {
+  {0x2A, 0x07},
+  {0x1,  0x00},
+  {0x2,  0x5f},
+  {0x3,  0x00},
+  {0x4,  0x5f},
+  {0x5,  0x60},
+  {0x6,  0xC0},
+  {0x7,  0x80},
+  {0x8,  0x04},
+  {0xA,  0x97},
+  {0xB,  0x72},
+  {0xC,  0x69},
+  {0xF,  0x2A},
+  {0x11, 0x2A},
+  {0x13, 0x27},
+  {0x15, 0x67},
+  {0x18, 0x04},
+  {0x21, 0x20},
+  {0x22, 0x36},
+  {0x29, 0x02},
+  {0x2A, 0x03},
+  {0x2A, 0x5F},
+  {0x2B, 0xC0},
+  {0x2C, 0x10},
+  {0x2E, 0xFF},
+
+  {0xff, 0xff}
+};
+
+static const struct elanspi_reg_entry elanspi_calibration_table_id57[] = {
+  {0x2A, 0x07},
+  {0x5,  0x60},
+  {0x6,  0xC0},
+  {0x7,  0x80},
+  {0x8,  0x04},
+  {0xA,  0x97},
+  {0xB,  0x72},
+  {0xC,  0x69},
+  {0xF,  0x2A},
+  {0x11, 0x2A},
+  {0x13, 0x27},
+  {0x15, 0x67},
+  {0x18, 0x04},
+  {0x21, 0x20},
+  {0x22, 0x36},
+  {0x2A, 0x5F},
+  {0x2B, 0xC0},
+  {0x2E, 0xFF},
+
+  {0xff, 0xff}
+};
+
+static const struct elanspi_reg_entry elanspi_calibration_table_id0[] = {
+  {0x5,  0x60},
+  {0x6,  0xC0},
+  {0x8,  0x04},
+  {0xA,  0x97},
+  {0xB,  0x72},
+  {0xC,  0x69},
+  {0xF,  0x2B},
+  {0x11, 0x2B},
+  {0x13, 0x28},
+  {0x15, 0x28},
+  {0x18, 0x04},
+  {0x21, 0x20},
+  {0x2A, 0x4B},
+
+  {0xff, 0xff}
+};
+
+// old style sensor calibration, with only one page of registers
+static const struct elanspi_regtable elanspi_calibration_table_old = {
+  .other = elanspi_calibration_table_default,
+  .entries = {
+    { .sid = 0x0, .table = elanspi_calibration_table_id0 },
+    { .sid = 0x5, .table = elanspi_calibration_table_id57 },
+    { .sid = 0x6, .table = elanspi_calibration_table_id6 },
+    { .sid = 0x7, .table = elanspi_calibration_table_id57 },
+    { .sid = 0x0, .table = NULL }
+  }
+};
+
+// new style sensor calibration, with two pages of registers
+static const struct elanspi_reg_entry elanspi_calibration_table_page0_id14[] = {
+  {0x00, 0x5a},
+  {0x01, 0x00},
+  {0x02, 0x4f},
+  {0x03, 0x00},
+  {0x04, 0x4f},
+  {0x05, 0xa0},
+  {0x06, 0x00},
+  {0x07, 0x00},
+  {0x08, 0x00},
+  {0x09, 0x04},
+  {0x0a, 0x74},
+  {0x0b, 0x05},
+  {0x0c, 0x08},
+  {0x0d, 0x00},
+  {0x0e, 0x00},
+  {0x0f, 0x14},
+  {0x10, 0x3c},
+  {0x11, 0x41},
+  {0x12, 0x0c},
+  {0x13, 0x00},
+  {0x14, 0x00},
+  {0x15, 0x04},
+  {0x16, 0x02},
+  {0x17, 0x00},
+  {0x18, 0x01},
+  {0x19, 0xf4},
+  {0x1a, 0x00},
+  {0x1b, 0x00},
+  {0x1c, 0x00},
+  {0x1d, 0x00},
+  {0x1e, 0x00},
+  {0x1f, 0x00},
+  {0x20, 0x00},
+  {0x21, 0x80},
+  {0x22, 0x06},
+  {0x23, 0x00},
+  {0x24, 0x00},
+  {0x25, 0x00},
+  {0x26, 0x00},
+  {0x27, 0x00},
+  {0x28, 0x00},
+  {0x29, 0x04},
+  {0x2a, 0x5f},
+  {0x2b, 0xe2},
+  {0x2c, 0xa0},
+  {0x2d, 0x00},
+  {0x2e, 0xff},
+  {0x2f, 0x40},
+  {0x30, 0x01},
+  {0x31, 0x38},
+  {0x32, 0x00},
+  {0x33, 0x00},
+  {0x34, 0x00},
+  {0x35, 0x1f},
+  {0x36, 0xff},
+  {0x37, 0x00},
+  {0x38, 0x00},
+  {0x39, 0x00},
+  {0x3a, 0x00},
+  {0xff, 0xff}
+};
+
+static const struct elanspi_reg_entry elanspi_calibration_table_page1_id14[] = {
+  {0x00, 0x7b},
+  {0x01, 0x7f},
+  {0x02, 0x77},
+  {0x03, 0xd4},
+  {0x04, 0x7d},
+  {0x05, 0x19},
+  {0x06, 0x80},
+  {0x07, 0x40},
+  {0x08, 0x11},
+  {0x09, 0x00},
+  {0x0a, 0x00},
+  {0x0b, 0x14},
+  {0x0c, 0x00},
+  {0x0d, 0x00},
+  {0x0e, 0x32},
+  {0x0f, 0x02},
+  {0x10, 0x08},
+  {0x11, 0x6c},
+  {0x12, 0x00},
+  {0x13, 0x00},
+  {0x14, 0x32},
+  {0x15, 0x01},
+  {0x16, 0x16},
+  {0x17, 0x01},
+  {0x18, 0x14},
+  {0x19, 0x01},
+  {0x1a, 0x16},
+  {0x1b, 0x01},
+  {0x1c, 0x17},
+  {0x1d, 0x01},
+  {0x1e, 0x0a},
+  {0x1f, 0x01},
+  {0x20, 0x0a},
+  {0x21, 0x02},
+  {0x22, 0x08},
+  {0x23, 0x29},
+  {0x24, 0x00},
+  {0x25, 0x0c},
+  {0x26, 0x1a},
+  {0x27, 0x30},
+  {0x28, 0x1a},
+  {0x29, 0x30},
+  {0x2a, 0x00},
+  {0x2b, 0x00},
+  {0x2c, 0x01},
+  {0x2d, 0x16},
+  {0x2e, 0x01},
+  {0x2f, 0x17},
+  {0x30, 0x03},
+  {0x31, 0x2d},
+  {0x32, 0x03},
+  {0x33, 0x2d},
+  {0x34, 0x14},
+  {0x35, 0x00},
+  {0x36, 0x00},
+  {0x37, 0x00},
+  {0x38, 0x00},
+  {0x39, 0x03},
+  {0x3a, 0xfe},
+  {0x3b, 0x00},
+  {0x3c, 0x00},
+  {0x3d, 0x02},
+  {0x3e, 0x00},
+  {0x3f, 0x00},
+  {0xff, 0xff}
+};
+
+static const struct elanspi_regtable elanspi_calibration_table_new_page0 = {
+  .other = NULL,
+  .entries = {
+    { .sid = 0xe, .table = elanspi_calibration_table_page0_id14 },
+    { .sid = 0x0, .table = NULL }
+  }
+};
+
+static const struct elanspi_regtable elanspi_calibration_table_new_page1 = {
+  .other = NULL,
+  .entries = {
+    { .sid = 0xe, .table = elanspi_calibration_table_page1_id14 },
+    { .sid = 0x0, .table = NULL }
+  }
+};
+
+#define ELANSPI_NO_ROTATE 0
+#define ELANSPI_90LEFT_ROTATE 1
+#define ELANSPI_180_ROTATE 2
+#define ELANSPI_90RIGHT_ROTATE 3
+
+#define ELANSPI_HV_FLIPPED 1
+
+#define ELANSPI_UDEV_TYPES FPI_DEVICE_UDEV_SUBTYPE_SPIDEV | FPI_DEVICE_UDEV_SUBTYPE_HIDRAW
+#define ELANSPI_TP_VID 0x04f3
+
+// using checkargs ACPI:HIDPID
+static const FpIdEntry elanspi_id_table[] = {
+  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x3057}, .driver_data = ELANSPI_180_ROTATE},
+  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x3087}, .driver_data = ELANSPI_180_ROTATE},
+  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x30c6}, .driver_data = ELANSPI_180_ROTATE},
+  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN70A1", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x3134}, .driver_data = ELANSPI_90LEFT_ROTATE},
+  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x3148}, .driver_data = ELANSPI_180_ROTATE},
+  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x30b2}, .driver_data = ELANSPI_NO_ROTATE},
+  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN70A1", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x30b2}, .driver_data = ELANSPI_NO_ROTATE},
+  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x309f}, .driver_data = ELANSPI_180_ROTATE},
+  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x241f}, .driver_data = ELANSPI_NO_ROTATE},
+  {.udev_types = 0}
+};
+
+#define ELANSPI_MAX_OLD_STAGE1_CALIBRATION_MEAN 1000
+
+#define ELANSPI_MIN_OLD_STAGE2_CALBIRATION_MEAN 3000
+#define ELANSPI_MAX_OLD_STAGE2_CALBIRATION_MEAN 8000
+
+#define ELANSPI_HV_CALIBRATION_TARGET_MEAN 3000
+
+#define ELANSPI_MIN_EMPTY_INVALID_PERCENT 6
+#define ELANSPI_MAX_REAL_INVALID_PERCENT 3
+
+#define ELANSPI_MIN_REAL_STDDEV (592 * 592)
+#define ELANSPI_MAX_EMPTY_STDDEV (350 * 350)
+
+#define ELANSPI_MIN_FRAMES_DEBOUNCE 2
+
+#define ELANSPI_SWIPE_FRAMES_DISCARD 1
+#define ELANSPI_MIN_FRAMES_SWIPE (7 + ELANSPI_SWIPE_FRAMES_DISCARD)
+#define ELANSPI_MAX_FRAMES_SWIPE (20 + ELANSPI_SWIPE_FRAMES_DISCARD)
+
+#define ELANSPI_MAX_FRAME_HEIGHT 43
+#define ELANSPI_MIN_FRAME_TO_FRAME_DIFF (250 * 250)
+
+#define ELANSPI_HV_SENSOR_FRAME_DELAY 23
+
+#define ELANSPI_OTP_TIMEOUT_USEC (12 * 1000)
+
+#define ELANSPI_OLD_CAPTURE_TIMEOUT_USEC (100 * 1000)
+#define ELANSPI_HV_CAPTURE_TIMEOUT_USEC (50 * 1000)

libfprint/drivers/fpcmoc/fpc.h

@@ -0,0 +1,221 @@
+/*
+ * Copyright (c) 2022 Fingerprint Cards AB <tech@fingerprints.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
+
+#include "fpi-device.h"
+#include "fpi-ssm.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#define TEMPLATE_ID_SIZE (32)
+#define MAX_FW_VERSION_STR_LEN (16)
+#define FPC_CMD_INIT (0x01)
+#define FPC_CMD_ARM (0x02)
+#define FPC_CMD_ABORT (0x03)
+#define FPC_CMD_INDICATE_S_STATE (0x08)
+#define FPC_CMD_GET_IMG (0x09)
+#define FPC_CMD_GET_KPI (0x0C)
+#define FPC_CMD_LOAD_DB (0x60)
+#define FPC_CMD_STORE_DB (0x61)
+#define FPC_CMD_DELETE_DB (0x62)
+#define FPC_CMD_DELETE_TEMPLATE (0x63)
+#define FPC_CMD_BEGIN_ENROL (0x67)
+#define FPC_CMD_ENROL (0x68)
+#define FPC_CMD_END_ENROL (0x69)
+#define FPC_CMD_BIND_IDENTITY (0x6A)
+#define FPC_CMD_IDENTIFY (0x6B)
+#define FPC_CMD_ENUM (0x70)
+#define FPC_EVT_INIT_RESULT (0x02)
+#define FPC_EVT_FINGER_DWN (0x06)
+#define FPC_EVT_IMG (0x08)
+#define FPC_EVT_FID_DATA (0x31)
+#define FPC_DB_ID_LEN (16)
+#define FPC_IDENTITY_TYPE_WILDCARD (0x1)
+#define FPC_IDENTITY_TYPE_RESERVED (0x3)
+#define FPC_IDENTITY_WILDCARD (0x25066282)
+#define FPC_SUBTYPE_ANY (0xFF)
+#define FPC_SUBTYPE_RESERVED (0xF5)
+#define FPC_SUBTYPE_NOINFORMATION (0x00)
+#define FPC_CAPTUREID_RESERVED (0x701100F)
+#define FPC_SESSIONID_RESERVED (0x0077FF12)
+#define FPC_TEMPLATES_MAX (10)
+#define SECURITY_MAX_SID_SIZE (68)
+#define FPC_HOST_MS_S0 (0x10)
+#define FPC_HOST_MS_SX (0x11)
+
+G_DECLARE_FINAL_TYPE (FpiDeviceFpcMoc, fpi_device_fpcmoc, FPI,
+                      DEVICE_FPCMOC, FpDevice);
+
+typedef struct _FPC_FID_DATA
+{
+  guint32 identity_type;
+  guint32 reserved;
+  guint32 identity_size;
+  guint32 subfactor;
+  guint8  data[SECURITY_MAX_SID_SIZE];
+} FPC_FID_DATA, *PFPC_FID_DATA;
+
+typedef struct _FPC_LOAD_DB
+{
+  gint32  status;
+  guint32 reserved;
+  guint32 database_id_size;
+  guint8  data[FPC_DB_ID_LEN];
+} FPC_LOAD_DB, *PFPC_LOAD_DB;
+
+typedef union _FPC_DELETE_DB
+{
+  guint32 reserved;
+  guint32 database_id_size;
+  guint8  data[FPC_DB_ID_LEN];
+} FPC_DB_OP, *PFPC_DB_OP;
+
+typedef struct _FPC_BEGIN_ENROL
+{
+  gint32  status;
+  guint32 reserved1;
+  guint32 reserved2;
+} FPC_BEGIN_ENROL, *PFPC_BEGIN_ENROL;
+
+typedef struct _FPC_ENROL
+{
+  gint32  status;
+  guint32 remaining;
+} FPC_ENROL, *PFPC_ENROL;
+
+typedef struct _FPC_END_ENROL
+{
+  gint32  status;
+  guint32 fid;
+} FPC_END_ENROL, *PFPC_END_ENROL;
+
+typedef struct _FPC_IDENTIFY
+{
+  gint32  status;
+  guint32 identity_type;
+  guint32 identity_offset;
+  guint32 identity_size;
+  guint32 subfactor;
+  guint8  data[SECURITY_MAX_SID_SIZE];
+} FPC_IDENTIFY, *PFPC_IDENTIFY;
+
+typedef struct
+{
+  guint32 cmdid;
+  guint32 length;
+  guint32 status;
+} evt_hdr_t;
+
+typedef struct
+{
+  evt_hdr_t hdr;
+  guint16   sensor;
+  guint16   hw_id;
+  guint16   img_w;
+  guint16   img_h;
+  guint8    fw_version[MAX_FW_VERSION_STR_LEN];
+  guint16   fw_capabilities;
+} evt_initiated_t;
+
+typedef struct
+{
+  guint8  subfactor;
+  guint32 identity_type;
+  guint32 identity_size;
+  guint8  identity[SECURITY_MAX_SID_SIZE];
+} __attribute__((packed)) fpc_fid_data_t;
+
+typedef struct
+{
+  evt_hdr_t      hdr;
+  gint           status;
+  guint32        num_ids;
+  fpc_fid_data_t fid_data[FPC_TEMPLATES_MAX];
+} __attribute__((packed)) evt_enum_fids_t;
+
+typedef struct _fp_cmd_response
+{
+  union
+  {
+    evt_hdr_t       evt_hdr;
+    evt_initiated_t evt_inited;
+    evt_enum_fids_t evt_enum_fids;
+  };
+} fpc_cmd_response_t, *pfpc_cmd_response_t;
+
+enum {
+  FPC_ENROL_STATUS_COMPLETED = 0,
+  FPC_ENROL_STATUS_PROGRESS = 1,
+  FPC_ENROL_STATUS_FAILED_COULD_NOT_COMPLETE = 2,
+  FPC_ENROL_STATUS_FAILED_ALREADY_ENROLED = 3,
+  FPC_ENROL_STATUS_IMAGE_LOW_COVERAGE = 4,
+  FPC_ENROL_STATUS_IMAGE_TOO_SIMILAR = 5,
+  FPC_ENROL_STATUS_IMAGE_LOW_QUALITY = 6,
+};
+
+typedef enum {
+  FPC_CMDTYPE_UNKNOWN = 0,
+  FPC_CMDTYPE_TO_DEVICE,
+  FPC_CMDTYPE_TO_DEVICE_EVTDATA,
+  FPC_CMDTYPE_FROM_DEVICE,
+} FpcCmdType;
+
+typedef enum {
+  FP_CMD_SEND = 0,
+  FP_CMD_GET_DATA,
+  FP_CMD_SUSPENDED,
+  FP_CMD_RESUME,
+  FP_CMD_NUM_STATES,
+} FpCmdState;
+
+typedef enum {
+  FP_INIT = 0,
+  FP_LOAD_DB,
+  FP_INIT_NUM_STATES,
+} FpInitState;
+
+typedef enum {
+  FP_ENROLL_ENUM = 0,
+  FP_ENROLL_CREATE,
+  FP_ENROLL_CAPTURE,
+  FP_ENROLL_GET_IMG,
+  FP_ENROLL_UPDATE,
+  FP_ENROLL_COMPLETE,
+  FP_ENROLL_CHECK_DUPLICATE,
+  FP_ENROLL_BINDID,
+  FP_ENROLL_COMMIT,
+  FP_ENROLL_DICARD,
+  FP_ENROLL_CLEANUP,
+  FP_ENROLL_NUM_STATES,
+} FpEnrollState;
+
+typedef enum {
+  FP_VERIFY_CAPTURE = 0,
+  FP_VERIFY_GET_IMG,
+  FP_VERIFY_IDENTIFY,
+  FP_VERIFY_CANCEL,
+  FP_VERIFY_NUM_STATES,
+} FpVerifyState;
+
+typedef enum {
+  FP_CLEAR_DELETE_DB = 0,
+  FP_CLEAR_CREATE_DB,
+  FP_CLEAR_NUM_STATES,
+} FpClearState;

libfprint/drivers/goodixmoc/goodix.c

@@ -54,10 +54,8 @@ struct _FpiDeviceGoodixMoc
   gint               enroll_stage;
   gint               max_enroll_stage;
   gint               max_stored_prints;
-  GCancellable      *cancellable;
   GPtrArray         *list_result;
   guint8             template_id[TEMPLATE_ID_SIZE];
-  gboolean           is_enroll_identify;
   gboolean           is_power_button_shield_on;
 
 };
@@ -80,6 +78,44 @@ static gboolean parse_print_data (GVariant      *data,
                                   gsize         *tid_len,
                                   const guint8 **user_id,
                                   gsize         *user_id_len);
+
+static FpPrint *
+fp_print_from_template (FpiDeviceGoodixMoc *self, template_format_t *template)
+{
+  FpPrint *print;
+  GVariant *data;
+  GVariant *tid;
+  GVariant *uid;
+  g_autofree gchar *userid = NULL;
+
+  userid = g_strndup ((gchar *) template->payload.data, template->payload.size);
+
+  print = fp_print_new (FP_DEVICE (self));
+
+  tid = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
+                                   template->tid,
+                                   TEMPLATE_ID_SIZE,
+                                   1);
+
+  uid = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
+                                   template->payload.data,
+                                   template->payload.size,
+                                   1);
+
+  data = g_variant_new ("(y@ay@ay)",
+                        template->finger_index,
+                        tid,
+                        uid);
+
+  fpi_print_set_type (print, FPI_PRINT_RAW);
+  fpi_print_set_device_stored (print, TRUE);
+  g_object_set (print, "fpi-data", data, NULL);
+  g_object_set (print, "description", userid, NULL);
+  fpi_print_fill_from_user_id (print, userid);
+
+  return print;
+}
+
 /******************************************************************************
  *
  *  fp_cmd_xxx Function
@@ -123,7 +159,7 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
     {
       fpi_ssm_mark_failed (transfer->ssm,
                            fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                                     "Corrupted message received"));
+                                                     "Corrupted message header received"));
       return;
     }
 
@@ -220,7 +256,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
       fpi_usb_transfer_fill_bulk (transfer, EP_IN, EP_IN_MAX_BUF_SIZE);
       fpi_usb_transfer_submit (transfer,
                                self->cmd_cancelable ? 0 : DATA_TIMEOUT,
-                               self->cmd_cancelable ? self->cancellable : NULL,
+                               self->cmd_cancelable ? fpi_device_get_cancellable (dev) : NULL,
                                fp_cmd_receive_cb,
                                fpi_ssm_get_data (ssm));
       break;
@@ -384,11 +420,9 @@ fp_verify_cb (FpiDeviceGoodixMoc  *self,
               gxfp_cmd_response_t *resp,
               GError              *error)
 {
-  g_autoptr(GPtrArray) templates = NULL;
   FpDevice *device = FP_DEVICE (self);
-  FpPrint *print = NULL;
-  gint cnt = 0;
-  gboolean find = false;
+  FpPrint *new_scan = NULL;
+  FpPrint *matching = NULL;
 
   if (error)
     {
@@ -397,57 +431,34 @@ fp_verify_cb (FpiDeviceGoodixMoc  *self,
     }
   if (resp->verify.match)
     {
+      new_scan = fp_print_from_template (self, &resp->verify.template);
+
       if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY)
         {
-          templates = g_ptr_array_sized_new (1);
-          fpi_device_get_verify_data (device, &print);
-          g_ptr_array_add (templates, print);
+          fpi_device_get_verify_data (device, &matching);
+          if (!fp_print_equal (matching, new_scan))
+            matching = NULL;
         }
       else
         {
+          GPtrArray *templates = NULL;
           fpi_device_get_identify_data (device, &templates);
-          g_ptr_array_ref (templates);
-        }
-      for (cnt = 0; cnt < templates->len; cnt++)
-        {
-          g_autoptr(GVariant) data = NULL;
-          guint8 finger;
-          const guint8 *user_id;
-          gsize user_id_len = 0;
-          const guint8 *tid;
-          gsize tid_len = 0;
-          print = g_ptr_array_index (templates, cnt);
-          g_object_get (print, "fpi-data", &data, NULL);
-          if (!parse_print_data (data, &finger, &tid, &tid_len, &user_id, &user_id_len))
-            {
-              fpi_ssm_mark_failed (self->task_ssm,
-                                   fpi_device_error_new_msg (FP_DEVICE_ERROR_DATA_INVALID,
-                                                             "Parse print error"));
-              return;
-            }
-          if (memcmp (&resp->verify.template.tid, tid, TEMPLATE_ID_SIZE) == 0)
-            {
-              find = true;
-              break;
-            }
 
-        }
-      if (find)
-        {
-          if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY)
-            fpi_device_verify_report (device, FPI_MATCH_SUCCESS, NULL, error);
-          else
-            fpi_device_identify_report (device, print, print, error);
+          for (gint i = 0; i < templates->len; i++)
+            {
+              if (fp_print_equal (g_ptr_array_index (templates, i), new_scan))
+                {
+                  matching = g_ptr_array_index (templates, i);
+                  break;
+                }
+            }
         }
     }
 
-  if (!find)
-    {
-      if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY)
-        fpi_device_verify_report (device, FPI_MATCH_FAIL, NULL, error);
-      else
-        fpi_device_identify_report (device, NULL, NULL, error);
-    }
+  if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY)
+    fpi_device_verify_report (device, matching ? FPI_MATCH_SUCCESS : FPI_MATCH_FAIL, new_scan, error);
+  else
+    fpi_device_identify_report (device, matching, new_scan, error);
 
   fpi_ssm_next_state (self->task_ssm);
 
@@ -623,28 +634,6 @@ fp_enroll_enum_cb (FpiDeviceGoodixMoc  *self,
   fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
 }
 
-static void
-fp_enroll_identify_cb (FpiDeviceGoodixMoc  *self,
-                       gxfp_cmd_response_t *resp,
-                       GError              *error)
-{
-  if (error)
-    {
-      fpi_ssm_mark_failed (self->task_ssm, error);
-      return;
-    }
-  if (resp->verify.match)
-    {
-      fpi_ssm_mark_failed (self->task_ssm,
-                           fpi_device_error_new_msg (FP_DEVICE_ERROR_DATA_DUPLICATE,
-                                                     "Finger is too similar to another, try use a different finger"));
-      // maybe need fpi_device_enroll_report_message ...
-      return;
-    }
-  fpi_ssm_next_state (self->task_ssm);
-
-}
-
 static void
 fp_enroll_init_cb (FpiDeviceGoodixMoc  *self,
                    gxfp_cmd_response_t *resp,
@@ -672,7 +661,7 @@ fp_enroll_capture_cb (FpiDeviceGoodixMoc  *self,
   /* */
   if (resp->result >= GX_FAILED)
     {
-      fp_warn ("Capture sample failed, result: 0x%x", resp->result);
+      fp_info ("Capture sample failed, result: 0x%x", resp->result);
       fpi_device_enroll_progress (FP_DEVICE (self),
                                   self->enroll_stage,
                                   NULL,
@@ -686,7 +675,7 @@ fp_enroll_capture_cb (FpiDeviceGoodixMoc  *self,
   if ((resp->capture_data_resp.img_quality < self->sensorcfg->config[4]) ||
       (resp->capture_data_resp.img_coverage < self->sensorcfg->config[5]))
     {
-      fp_warn ("Capture sample poor quality(%d): %d or coverage(%d): %d",
+      fp_info ("Capture sample poor quality(%d): %d or coverage(%d): %d",
                self->sensorcfg->config[4],
                resp->capture_data_resp.img_quality,
                self->sensorcfg->config[5],
@@ -698,11 +687,6 @@ fp_enroll_capture_cb (FpiDeviceGoodixMoc  *self,
       fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
       return;
     }
-  if (self->is_enroll_identify)
-    {
-      self->is_enroll_identify = false;
-      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_IDENTIFY);
-    }
   else
     {
       fpi_ssm_next_state (self->task_ssm);
@@ -765,9 +749,14 @@ fp_enroll_check_duplicate_cb (FpiDeviceGoodixMoc  *self,
     }
   if (resp->check_duplicate_resp.duplicate)
     {
+      g_autoptr(FpPrint) print = NULL;
+
+      print = g_object_ref_sink (fp_print_from_template (self, &resp->check_duplicate_resp.template));
+
       fpi_ssm_mark_failed (self->task_ssm,
                            fpi_device_error_new_msg (FP_DEVICE_ERROR_DATA_DUPLICATE,
-                                                     "Finger has already enrolled"));
+                                                     "Finger was already enrolled as '%s'",
+                                                     fp_print_get_description (print)));
       return;
     }
 
@@ -868,19 +857,6 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_ENROLL_IDENTIFY:
-      {
-        dummy[0] = 0x01;
-        dummy[1] = self->sensorcfg->config[10];
-        dummy[2] = self->sensorcfg->config[11];
-        goodix_sensor_cmd (self, MOC_CMD0_IDENTIFY, MOC_CMD1_DEFAULT,
-                           false,
-                           (const guint8 *) &self->template_id,
-                           TEMPLATE_ID_SIZE,
-                           fp_enroll_identify_cb);
-      }
-      break;
-
     case FP_ENROLL_CREATE:
       {
         goodix_sensor_cmd (self, MOC_CMD0_ENROLL_INIT, MOC_CMD1_DEFAULT,
@@ -1065,6 +1041,47 @@ fp_init_config_cb (FpiDeviceGoodixMoc  *self,
   fpi_ssm_next_state (self->task_ssm);
 }
 
+static void
+fp_init_cb_reset_or_complete (FpiDeviceGoodixMoc  *self,
+                              gxfp_cmd_response_t *resp,
+                              GError              *error)
+{
+  if (error)
+    {
+      fp_warn ("Template storage appears to have been corrupted! Error was: %s", error->message);
+      fp_warn ("A known reason for this to happen is a firmware bug triggered by another storage area being initialized.");
+      fpi_ssm_jump_to_state (self->task_ssm, FP_INIT_RESET_DEVICE);
+    }
+  else
+    {
+      fpi_ssm_mark_completed (self->task_ssm);
+    }
+}
+
+static void
+fp_init_reset_device_cb (FpiDeviceGoodixMoc  *self,
+                         gxfp_cmd_response_t *resp,
+                         GError              *error)
+{
+  if (error)
+    {
+      fp_warn ("Reset failed: %s", error->message);
+      fpi_ssm_mark_failed (self->task_ssm, error);
+      return;
+    }
+  if ((resp->result >= GX_FAILED) && (resp->result != GX_ERROR_FINGER_ID_NOEXIST))
+    {
+      fp_warn ("Reset failed, device reported: 0x%x", resp->result);
+      fpi_ssm_mark_failed (self->task_ssm,
+                           fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
+                                                     "Failed clear storage, result: 0x%x",
+                                                     resp->result));
+      return;
+    }
+
+  fp_warn ("Reset completed");
+  fpi_ssm_mark_completed (self->task_ssm);
+}
 
 static void
 fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
@@ -1089,6 +1106,30 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          sizeof (gxfp_sensor_cfg_t),
                          fp_init_config_cb);
       break;
+
+    case FP_INIT_TEMPLATE_LIST:
+      /* List prints to check whether the template DB was corrupted.
+       * As of 2022-06-13 there is a known firmware issue that can cause the
+       * stored templates for Linux to be corrupted when the Windows storage
+       * area is initialized.
+       * In that case, we'll get a protocol failure trying to retrieve the
+       * list of prints.
+       */
+      goodix_sensor_cmd (self, MOC_CMD0_GETFINGERLIST, MOC_CMD1_DEFAULT,
+                         FALSE,
+                         (const guint8 *) &dummy,
+                         1,
+                         fp_init_cb_reset_or_complete);
+      break;
+
+    case FP_INIT_RESET_DEVICE:
+      fp_warn ("Resetting device storage, you will need to enroll all prints again!");
+      goodix_sensor_cmd (self, MOC_CMD0_DELETETEMPLATE, MOC_CMD1_DELETE_ALL,
+                         FALSE,
+                         NULL,
+                         0,
+                         fp_init_reset_device_cb);
+      break;
     }
 
 
@@ -1184,6 +1225,32 @@ fp_template_delete_cb (FpiDeviceGoodixMoc  *self,
   fp_info ("Successfully deleted enrolled user");
   fpi_device_delete_complete (device, NULL);
 }
+
+static void
+fp_template_delete_all_cb (FpiDeviceGoodixMoc  *self,
+                           gxfp_cmd_response_t *resp,
+                           GError              *error)
+{
+  FpDevice *device = FP_DEVICE (self);
+
+  if (error)
+    {
+      fpi_device_clear_storage_complete (device, error);
+      return;
+    }
+  if ((resp->result >= GX_FAILED) && (resp->result != GX_ERROR_FINGER_ID_NOEXIST))
+    {
+      fpi_device_clear_storage_complete (FP_DEVICE (self),
+                                         fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
+                                                                   "Failed clear storage, result: 0x%x",
+                                                                   resp->result));
+      return;
+    }
+
+  fp_info ("Successfully cleared storage");
+  fpi_device_clear_storage_complete (device, NULL);
+}
+
 /******************************************************************************
  *
  *  fp_template_list Function
@@ -1225,36 +1292,10 @@ fp_template_list_cb (FpiDeviceGoodixMoc  *self,
 
   for (int n = 0; n < resp->finger_list_resp.finger_num; n++)
     {
-      GVariant *data = NULL;
-      GVariant *tid = NULL;
-      GVariant *uid = NULL;
       FpPrint *print;
-      gchar *userid;
 
-      userid = (gchar *) resp->finger_list_resp.finger_list[n].payload.data;
+      print = fp_print_from_template (self, &resp->finger_list_resp.finger_list[n]);
 
-      print = fp_print_new (FP_DEVICE (self));
-
-      tid = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
-                                       resp->finger_list_resp.finger_list[n].tid,
-                                       TEMPLATE_ID_SIZE,
-                                       1);
-
-      uid = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
-                                       resp->finger_list_resp.finger_list[n].payload.data,
-                                       resp->finger_list_resp.finger_list[n].payload.size,
-                                       1);
-
-      data = g_variant_new ("(y@ay@ay)",
-                            resp->finger_list_resp.finger_list[n].finger_index,
-                            tid,
-                            uid);
-
-      fpi_print_set_type (print, FPI_PRINT_RAW);
-      fpi_print_set_device_stored (print, TRUE);
-      g_object_set (print, "fpi-data", data, NULL);
-      g_object_set (print, "description", userid, NULL);
-      fpi_print_fill_from_user_id (print, userid);
       g_ptr_array_add (self->list_result, g_object_ref_sink (print));
     }
 
@@ -1318,6 +1359,18 @@ gx_fp_probe (FpDevice *device)
     {
     case 0x6496:
     case 0x60A2:
+    case 0x6014:
+    case 0x6094:
+    case 0x609C:
+    case 0x631C:
+    case 0x634C:
+    case 0x6384:
+    case 0x639C:
+    case 0x63AC:
+    case 0x63BC:
+    case 0x63CC:
+    case 0x6A94:
+    case 0x659A:
       self->max_enroll_stage = 12;
       break;
 
@@ -1348,8 +1401,6 @@ gx_fp_init (FpDevice *device)
   self->max_stored_prints = FP_MAX_FINGERNUM;
   self->is_power_button_shield_on = false;
 
-  self->cancellable = g_cancellable_new ();
-
   self->sensorcfg = g_new0 (gxfp_sensor_cfg_t, 1);
 
   ret = gx_proto_init_sensor_config (self->sensorcfg);
@@ -1387,7 +1438,6 @@ gx_fp_release_interface (FpiDeviceGoodixMoc *self,
 {
   g_autoptr(GError) release_error = NULL;
 
-  g_clear_object (&self->cancellable);
   g_clear_pointer (&self->sensorcfg, g_free);
 
   /* Release usb interface */
@@ -1443,8 +1493,10 @@ gx_fp_verify_identify (FpDevice *device)
 {
   FpiDeviceGoodixMoc *self = FPI_DEVICE_GOODIXMOC (device);
 
-  self->task_ssm = fpi_ssm_new (device, fp_verify_sm_run_state,
-                                FP_VERIFY_NUM_STATES);
+  self->task_ssm = fpi_ssm_new_full (device, fp_verify_sm_run_state,
+                                     FP_VERIFY_NUM_STATES,
+                                     FP_VERIFY_PWR_BTN_SHIELD_OFF,
+                                     "verify");
 
   fpi_ssm_start (self->task_ssm, fp_verify_ssm_done);
 
@@ -1457,10 +1509,11 @@ gx_fp_enroll (FpDevice *device)
   FpiDeviceGoodixMoc *self = FPI_DEVICE_GOODIXMOC (device);
 
   self->enroll_stage = 0;
-  self->is_enroll_identify = true;
 
-  self->task_ssm = fpi_ssm_new (device, fp_enroll_sm_run_state,
-                                FP_ENROLL_NUM_STATES);
+  self->task_ssm = fpi_ssm_new_full (device, fp_enroll_sm_run_state,
+                                     FP_ENROLL_NUM_STATES,
+                                     FP_ENROLL_PWR_BTN_SHIELD_OFF,
+                                     "enroll");
 
   fpi_ssm_start (self->task_ssm, fp_enroll_ssm_done);
 
@@ -1527,33 +1580,46 @@ gx_fp_template_delete (FpDevice *device)
 
 }
 
+static void
+gx_fp_template_delete_all (FpDevice *device)
+{
+  FpiDeviceGoodixMoc *self = FPI_DEVICE_GOODIXMOC (device);
+
+  goodix_sensor_cmd (self, MOC_CMD0_DELETETEMPLATE, MOC_CMD1_DELETE_ALL,
+                     false,
+                     NULL,
+                     0,
+                     fp_template_delete_all_cb);
+
+}
+
 static void
 fpi_device_goodixmoc_init (FpiDeviceGoodixMoc *self)
 {
 
 }
 
-static void
-gx_fp_cancel (FpDevice *device)
-{
-  FpiDeviceGoodixMoc *self = FPI_DEVICE_GOODIXMOC (device);
-
-  /* Cancel any current interrupt transfer (resulting us to go into
-   * response reading mode again); then create a new cancellable
-   * for the next transfers. */
-  g_cancellable_cancel (self->cancellable);
-  g_clear_object (&self->cancellable);
-  self->cancellable = g_cancellable_new ();
-
-}
-
 static const FpIdEntry id_table[] = {
   { .vid = 0x27c6,  .pid = 0x5840,  },
-  { .vid = 0x27c6,  .pid = 0x6496,  },
+  { .vid = 0x27c6,  .pid = 0x6014,  },
+  { .vid = 0x27c6,  .pid = 0x6094,  },
+  { .vid = 0x27c6,  .pid = 0x609C,  },
   { .vid = 0x27c6,  .pid = 0x60A2,  },
-  { .vid = 0x27c6,  .pid = 0x63AC,  },
+  { .vid = 0x27c6,  .pid = 0x631C,  },
+  { .vid = 0x27c6,  .pid = 0x634C,  },
+  { .vid = 0x27c6,  .pid = 0x6384,  },
   { .vid = 0x27c6,  .pid = 0x639C,  },
+  { .vid = 0x27c6,  .pid = 0x63AC,  },
+  { .vid = 0x27c6,  .pid = 0x63BC,  },
+  { .vid = 0x27c6,  .pid = 0x63CC,  },
+  { .vid = 0x27c6,  .pid = 0x6496,  },
+  { .vid = 0x27c6,  .pid = 0x6584,  },
+  { .vid = 0x27c6,  .pid = 0x658C,  },
+  { .vid = 0x27c6,  .pid = 0x6592,  },
   { .vid = 0x27c6,  .pid = 0x6594,  },
+  { .vid = 0x27c6,  .pid = 0x659A,  },
+  { .vid = 0x27c6,  .pid = 0x659C,  },
+  { .vid = 0x27c6,  .pid = 0x6A94,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 
@@ -1569,14 +1635,18 @@ fpi_device_goodixmoc_class_init (FpiDeviceGoodixMocClass *klass)
   dev_class->scan_type = FP_SCAN_TYPE_PRESS;
   dev_class->id_table = id_table;
   dev_class->nr_enroll_stages = DEFAULT_ENROLL_SAMPLES;
+  dev_class->temp_hot_seconds = -1;
 
   dev_class->open   = gx_fp_init;
   dev_class->close  = gx_fp_exit;
   dev_class->probe  = gx_fp_probe;
   dev_class->enroll = gx_fp_enroll;
   dev_class->delete = gx_fp_template_delete;
+  dev_class->clear_storage = gx_fp_template_delete_all;
   dev_class->list   = gx_fp_template_list;
-  dev_class->cancel = gx_fp_cancel;
   dev_class->verify   = gx_fp_verify_identify;
   dev_class->identify = gx_fp_verify_identify;
+
+  fpi_device_class_auto_initialize_features (dev_class);
+  dev_class->features |= FP_DEVICE_FEATURE_DUPLICATES_CHECK;
 }

libfprint/drivers/goodixmoc/goodix.h

@@ -35,6 +35,8 @@ typedef enum {
 typedef enum {
   FP_INIT_VERSION = 0,
   FP_INIT_CONFIG,
+  FP_INIT_TEMPLATE_LIST,
+  FP_INIT_RESET_DEVICE,
   FP_INIT_NUM_STATES,
 } FpInitState;
 

libfprint/drivers/goodixmoc/goodix_proto.c

@@ -259,12 +259,9 @@ gx_proto_parse_fingerid (
 
   if (buffer[Offset++] != 67)
     return -1;
-  fid_buffer_size--;
 
   template->type = buffer[Offset++];
-  fid_buffer_size--;
   template->finger_index = buffer[Offset++];
-  fid_buffer_size--;
   Offset++;
   memcpy (template->accountid, &buffer[Offset], sizeof (template->accountid));
   Offset += sizeof (template->accountid);
@@ -273,6 +270,8 @@ gx_proto_parse_fingerid (
   template->payload.size = buffer[Offset++];
   if (template->payload.size > sizeof (template->payload.data))
     return -1;
+  if (template->payload.size + Offset > fid_buffer_size)
+    return -1;
   memset (template->payload.data, 0, template->payload.size);
   memcpy (template->payload.data, &buffer[Offset], template->payload.size);
 
@@ -365,9 +364,12 @@ gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_c
           if (buffer_len < 3)
             return -1;
           uint16_t tid_size = GUINT16_FROM_LE (*(uint16_t *) (buffer + 1));
-          if ((buffer_len < tid_size + 3) || (buffer_len > sizeof (template_format_t)) + 3)
+          offset += 3;
+
+          if (buffer_len < tid_size + offset)
+            return -1;
+          if (gx_proto_parse_fingerid (buffer + offset, tid_size, &presp->check_duplicate_resp.template) != 0)
             return -1;
-          memcpy (&presp->check_duplicate_resp.template, buffer + 3, tid_size);
         }
       break;
 
@@ -380,18 +382,19 @@ gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_c
       fingerlist = buffer + 2;
       for(uint8_t num = 0; num < presp->finger_list_resp.finger_num; num++)
         {
-          uint16_t fingerid_length = GUINT16_FROM_LE (*(uint16_t *) (fingerlist + offset));
+          uint16_t fingerid_length;
+          if (buffer_len < offset + 2)
+            return -1;
+          fingerid_length = GUINT16_FROM_LE (*(uint16_t *) (fingerlist + offset));
           offset += 2;
-          if (buffer_len < fingerid_length + offset + 2)
+          if (buffer_len < fingerid_length + offset)
             return -1;
           if (gx_proto_parse_fingerid (fingerlist + offset,
                                        fingerid_length,
                                        &presp->finger_list_resp.finger_list[num]) != 0)
             {
-              g_error ("parse fingerlist error");
-              presp->finger_list_resp.finger_num = 0;
-              presp->result = GX_FAILED;
-              break;
+              g_warning ("Failed to parse finger list");
+              return -1;
             }
           offset += fingerid_length;
         }
@@ -405,7 +408,7 @@ gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_c
         presp->verify.match = (buffer[0] == 0) ? true : false;
         if (presp->verify.match)
           {
-            if (buffer_len < sizeof (template_format_t) + 10)
+            if (buffer_len < 10)
               return -1;
             offset += 1;
             presp->verify.rejectdetail = GUINT16_FROM_LE (*(uint16_t *) (buffer + offset));
@@ -416,6 +419,8 @@ gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_c
             offset += 1;
             fingerid_size = GUINT16_FROM_LE (*(uint16_t *) (buffer + offset));
             offset += 2;
+            if (buffer_len < fingerid_size + offset)
+              return -1;
             if (gx_proto_parse_fingerid (buffer + offset, fingerid_size, &presp->verify.template) != 0)
               {
                 presp->result = GX_FAILED;

libfprint/drivers/goodixmoc/goodix_proto.h

@@ -113,14 +113,16 @@ typedef struct _gxfp_enroll_init
 #pragma pack(push, 1)
 typedef struct _template_format
 {
+  uint8_t _0x43_byte;
   uint8_t type;
   uint8_t finger_index;
+  uint8_t pad0;
   uint8_t accountid[32];
   uint8_t tid[32];
   struct
   {
-    uint32_t size;
-    uint8_t  data[56];
+    uint8_t size;
+    uint8_t data[56];
   } payload;
   uint8_t reserve[2];
 } template_format_t, *ptemplate_format_t;

libfprint/drivers/nb1010.c

@@ -0,0 +1,445 @@
+/*
+ * Next Biometrics driver for libfprint
+ *
+ * Copyright (C) 2021 Huan Wang <fredwanghuan@gmail.com>
+ * 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
+ */
+
+#define FP_COMPONENT "nb1010"
+#include "fpi-log.h"
+
+#include "drivers_api.h"
+
+#define FRAME_HEIGHT 180
+#define FRAME_WIDTH 256
+
+#define NB1010_EP_OUT 0x02 | FPI_USB_ENDPOINT_OUT
+#define NB1010_EP_IN 0x03 | FPI_USB_ENDPOINT_IN
+
+#define NB1010_SENSITIVITY_BIT 12
+
+#define NB1010_CMD_RECV_LEN 16
+#define NB1010_CAPTURE_RECV_LEN 540
+#define NB1010_CAPTURE_HEADER_LEN 25
+
+#define NB1010_LINE_PER_PARTIAL 2
+#define NB1010_N_PARTIAL (FRAME_HEIGHT / NB1010_LINE_PER_PARTIAL)
+
+#define NB1010_DEFAULT_TIMEOUT 500
+#define NB1010_TRANSITION_DELAY 50
+
+/* Loop ssm states */
+enum {
+  M_WAIT_PRINT,
+  M_REQUEST_PRINT,
+  M_CHECK_PRINT,
+  M_READ_PRINT_PRESTART,
+  M_READ_PRINT_START,
+  M_READ_PRINT_POLL,
+  M_SUBMIT_PRINT,
+
+  /* Number of states */
+  M_LOOP_NUM_STATES,
+};
+
+/*
+ * The Follow Commands are obtained by decoding the usbcap, so it does not expose all the command available to the device.
+ * Known:
+ * 1. every command starts with 0x80
+ * 2. second byte is the comand, third byte is the seqence nubmer, init with rand, gets incremented
+ *    everytime a new instruction is sent to the device. However device does not care or check the sequence, just echo back
+ *    whatever chosen by the host.
+ * 3. cmd: 0x07 check, expect [0x80, 0x29...] as response
+ * 4. cmd: 0x16 ???, expect [0x80, 0x20...] as response. Happens during device init.
+ * 5. cmd: 0x13 print device, expect [0x80, 0x23...] as response. Response contains the device string
+ * 6. cmd: 0x38 check finger, expect [0x80, 0x37...] as response. The 14th byte indicate whether finger present [0-255]
+ * 7. cmd: 0x0d ???, expect [0x80, 0x20...] as response. Happens before capture.
+ * 8. cmd: 0x12 capture, expect [0x80, 0x20...] as response. After capture read 90 times in sequence to get all the frame.
+ */
+
+static guint8 nb1010_cmd_check_finger[] = {
+  0x80, 0x38, 0x01, 0x00, 0x08, 0x00, 0x00, 0x00,
+};
+
+/* pre capture, dont know what does it do, but appears everytime a capture begins */
+static guint8 nb1010_cmd_precapture[] = {
+  0x80, 0x0d, 0x03, 0x00, 0x0c, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+};
+
+static guint8 nb1010_cmd_capture[] = {
+  0x80, 0x12, 0x04, 0x00, 0x20, 0x00, 0x00, 0x00,
+  0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00,
+};
+
+struct _FpiDeviceNb1010
+{
+  FpImageDevice parent;
+  FpiSsm       *ssm;
+  guint8       *scanline_buf;
+  gboolean      deactivating;
+  int           partial_received;
+};
+G_DECLARE_FINAL_TYPE (FpiDeviceNb1010, fpi_device_nb1010, FPI, DEVICE_NB1010, FpImageDevice);
+G_DEFINE_TYPE (FpiDeviceNb1010, fpi_device_nb1010, FP_TYPE_IMAGE_DEVICE);
+
+static void
+nb1010_dev_init (FpImageDevice *dev)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+  GError *error = NULL;
+
+  g_usb_device_claim_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error);
+
+  self->scanline_buf = g_malloc0 (FRAME_WIDTH * FRAME_HEIGHT);
+
+  fpi_image_device_open_complete (dev, error);
+  fp_dbg ("nb1010 Initialized");
+}
+
+static void
+nb1010_dev_deinit (FpImageDevice *dev)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+  GError *error = NULL;
+
+  g_clear_pointer (&self->scanline_buf, g_free);
+
+  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error);
+  fpi_image_device_close_complete (dev, error);
+  fp_dbg ("nb1010 Deinitialized");
+}
+
+static void
+nb1010_dev_activate (FpImageDevice *dev)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+
+  self->deactivating = FALSE;
+
+  fpi_image_device_activate_complete (dev, NULL);
+  fp_dbg ("nb1010 Activated");
+}
+
+static void
+nb1010_dev_deactivated (FpImageDevice *dev, GError * err)
+{
+  fpi_image_device_deactivate_complete (dev, err);
+  fp_dbg ("nb1010 Deactivated");
+}
+
+static void
+nb1010_dev_deactivate (FpImageDevice *dev)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+
+  self->deactivating = TRUE;
+  if (self->ssm == NULL)
+    nb1010_dev_deactivated (dev, NULL);
+}
+
+static void
+nb1010_request_fingerprint (FpiDeviceNb1010 *dev)
+{
+  FpiUsbTransfer *transfer = NULL;
+
+  transfer = fpi_usb_transfer_new (FP_DEVICE ( dev));
+  transfer->short_is_error = TRUE;
+  transfer->ssm = dev->ssm;
+
+  fpi_usb_transfer_fill_bulk_full (transfer, NB1010_EP_OUT,
+                                   nb1010_cmd_check_finger, G_N_ELEMENTS (nb1010_cmd_check_finger),
+                                   NULL);
+  fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT,
+                           fpi_device_get_cancellable (FP_DEVICE (dev)),
+                           fpi_ssm_usb_transfer_cb, NULL);
+}
+
+static void
+nb1010_check_fingerprint_cb (FpiUsbTransfer *transfer, FpDevice *dev,
+                             gpointer unused_data, GError *error)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+
+  if (error)
+    {
+      fpi_ssm_mark_failed (transfer->ssm, error);
+      return;
+    }
+  if (self->deactivating)
+    {
+      fpi_ssm_mark_completed (transfer->ssm);
+      return;
+    }
+
+  if (transfer->buffer[NB1010_SENSITIVITY_BIT] > 0x30)
+    fpi_ssm_next_state (transfer->ssm);
+  else
+    fpi_ssm_jump_to_state (transfer->ssm, M_WAIT_PRINT);
+}
+
+static void
+nb1010_cmd_check_fingerprint (FpiDeviceNb1010 *dev)
+{
+  FpiUsbTransfer *transfer = NULL;
+
+  transfer = fpi_usb_transfer_new (FP_DEVICE ( dev));
+  transfer->short_is_error = TRUE;
+  transfer->ssm = dev->ssm;
+
+  fpi_usb_transfer_fill_bulk (transfer, NB1010_EP_IN, NB1010_CMD_RECV_LEN);
+  fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT,
+                           fpi_device_get_cancellable (FP_DEVICE (dev)),
+                           nb1010_check_fingerprint_cb, NULL);
+}
+
+static void
+nb1010_read_ignore_data_cb (FpiUsbTransfer *transfer, FpDevice *dev,
+                            gpointer unused_data, GError *error)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+  FpiUsbTransfer *new_transfer = NULL;
+
+  if (error)
+    {
+      fpi_ssm_mark_failed (transfer->ssm, error);
+      return;
+    }
+  if (self->deactivating)
+    {
+      fpi_ssm_mark_completed (transfer->ssm);
+      return;
+    }
+
+  new_transfer = fpi_usb_transfer_new ( dev );
+  new_transfer->short_is_error = TRUE;
+  new_transfer->ssm = transfer->ssm;
+
+  fpi_usb_transfer_fill_bulk (new_transfer, NB1010_EP_IN, NB1010_CMD_RECV_LEN);
+  fpi_usb_transfer_submit (new_transfer, NB1010_DEFAULT_TIMEOUT,
+                           fpi_device_get_cancellable (FP_DEVICE (dev)),
+                           fpi_ssm_usb_transfer_cb, NULL);
+}
+
+static void
+nb1010_write_ignore_read (FpiDeviceNb1010 *dev, guint8 *buf, gsize len)
+{
+  FpiUsbTransfer *transfer = NULL;
+
+  transfer = fpi_usb_transfer_new (FP_DEVICE ( dev));
+  transfer->short_is_error = TRUE;
+  transfer->ssm = dev->ssm;
+
+  fpi_usb_transfer_fill_bulk_full (transfer, NB1010_EP_OUT, buf, len, NULL);
+  fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT,
+                           fpi_device_get_cancellable (FP_DEVICE (dev)),
+                           nb1010_read_ignore_data_cb, NULL);
+}
+
+
+static void
+nb1010_read_capture_cb (FpiUsbTransfer *transfer, FpDevice *dev,
+                        gpointer unused_data, GError *error)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+
+  if (error)
+    {
+      fpi_ssm_mark_failed (transfer->ssm, error);
+      return;
+    }
+  if (self->deactivating)
+    {
+      fpi_ssm_mark_completed (transfer->ssm);
+      return;
+    }
+
+  g_assert (transfer->actual_length == NB1010_CAPTURE_RECV_LEN);
+
+  size_t offset = self->partial_received * NB1010_LINE_PER_PARTIAL * FRAME_WIDTH;
+
+  memcpy (self->scanline_buf + offset,
+          transfer->buffer + NB1010_CAPTURE_HEADER_LEN, NB1010_LINE_PER_PARTIAL * FRAME_WIDTH);
+
+  self->partial_received++;
+  if (self->partial_received == NB1010_N_PARTIAL)
+    {
+      fpi_ssm_next_state (transfer->ssm);
+      return;
+    }
+
+  fpi_usb_transfer_submit (fpi_usb_transfer_ref (transfer), NB1010_DEFAULT_TIMEOUT,
+                           fpi_device_get_cancellable (FP_DEVICE (dev)),
+                           nb1010_read_capture_cb, NULL);
+}
+
+static void
+nb1010_read_capture (FpiDeviceNb1010 *dev)
+{
+  FpiUsbTransfer *transfer = NULL;
+
+  transfer = fpi_usb_transfer_new ( FP_DEVICE ( dev));
+  transfer->short_is_error = TRUE;
+  transfer->ssm = dev->ssm;
+
+  fpi_usb_transfer_fill_bulk (transfer, NB1010_EP_IN, NB1010_CAPTURE_RECV_LEN);
+  fpi_usb_transfer_submit (transfer, NB1010_DEFAULT_TIMEOUT,
+                           fpi_device_get_cancellable (FP_DEVICE (dev)),
+                           nb1010_read_capture_cb, NULL);
+}
+
+static int
+submit_image (FpiSsm        *ssm,
+              FpImageDevice *dev)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+  FpImage *img;
+
+  img = fp_image_new (FRAME_WIDTH, FRAME_HEIGHT);
+  if (img == NULL)
+    return 0;
+
+  memcpy (img->data, self->scanline_buf, FRAME_WIDTH * FRAME_HEIGHT);
+  fpi_image_device_image_captured (dev, img);
+
+  return 1;
+}
+
+static void
+m_loop_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
+{
+  fp_dbg ("nb1010 ssm complete cb");
+
+  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (_dev);
+
+  self->ssm = NULL;
+
+  if (self->deactivating)
+    nb1010_dev_deactivated (dev, error);
+  else if (error != NULL)
+    fpi_image_device_session_error (dev, error);
+}
+
+static void
+m_loop_state (FpiSsm *ssm, FpDevice *_dev)
+{
+  FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (_dev);
+
+  if (self->deactivating)
+    {
+      fp_dbg ("deactivating, marking completed");
+      fpi_ssm_mark_completed (ssm);
+      return;
+    }
+
+  switch (fpi_ssm_get_cur_state (ssm))
+    {
+    case M_WAIT_PRINT:
+      /* Wait fingerprint scanning */
+      fpi_ssm_next_state_delayed (ssm, NB1010_TRANSITION_DELAY);
+      break;
+
+    case M_REQUEST_PRINT:
+      nb1010_request_fingerprint (self);
+      break;
+
+    case M_CHECK_PRINT:
+      nb1010_cmd_check_fingerprint (self);
+      break;
+
+    case M_READ_PRINT_PRESTART:
+      fpi_image_device_report_finger_status (dev, TRUE);
+      nb1010_write_ignore_read (self, nb1010_cmd_precapture, G_N_ELEMENTS (nb1010_cmd_precapture));
+      break;
+
+    case M_READ_PRINT_START:
+      self->partial_received = 0;
+      nb1010_write_ignore_read (self, nb1010_cmd_capture, G_N_ELEMENTS (nb1010_cmd_capture));
+      break;
+
+    case M_READ_PRINT_POLL:
+      nb1010_read_capture (self);
+      break;
+
+    case M_SUBMIT_PRINT:
+      if (submit_image (ssm, dev))
+        {
+          fpi_ssm_mark_completed (ssm);
+          fpi_image_device_report_finger_status (dev, FALSE);
+        }
+      else
+        {
+          fpi_ssm_jump_to_state (ssm, M_WAIT_PRINT);
+        }
+      break;
+
+    default:
+      g_assert_not_reached ();
+    }
+}
+
+static void
+nb1010_dev_change_state (FpImageDevice *dev, FpiImageDeviceState state)
+{
+  FpiDeviceNb1010 *self = FPI_DEVICE_NB1010 (dev);
+  FpiSsm *ssm_loop;
+
+  if (state == FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON)
+    {
+      ssm_loop = fpi_ssm_new (FP_DEVICE (dev), m_loop_state, M_LOOP_NUM_STATES);
+      self->ssm = ssm_loop;
+      fpi_ssm_start (ssm_loop, m_loop_complete);
+    }
+}
+
+
+static const FpIdEntry id_table[] = {
+  { .vid = 0x298d,  .pid = 0x1010, },
+  { .vid = 0,  .pid = 0,  .driver_data = 0 },
+};
+
+static void
+fpi_device_nb1010_init (FpiDeviceNb1010 *self)
+{
+}
+
+static void
+fpi_device_nb1010_class_init (FpiDeviceNb1010Class *klass)
+{
+  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
+  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
+
+  dev_class->id = FP_COMPONENT;
+  dev_class->full_name = "NextBiometrics NB-1010-U";
+  dev_class->type = FP_DEVICE_TYPE_USB;
+  dev_class->id_table = id_table;
+  dev_class->scan_type = FP_SCAN_TYPE_PRESS;
+
+  img_class->img_height = FRAME_HEIGHT;
+  img_class->img_width = FRAME_WIDTH;
+
+  img_class->bz3_threshold = 24;
+
+  img_class->img_open = nb1010_dev_init;
+  img_class->img_close = nb1010_dev_deinit;
+  img_class->activate = nb1010_dev_activate;
+  img_class->deactivate = nb1010_dev_deactivate;
+  img_class->change_state = nb1010_dev_change_state;
+}

libfprint/drivers/synaptics/bmkt_response.h

@@ -468,6 +468,7 @@ typedef union
   bmkt_del_all_users_resp_t    del_all_users_resp;
   bmkt_enroll_templates_resp_t enroll_templates_resp;
   bmkt_del_user_resp_t         del_user_resp;
+  bmkt_del_all_users_resp_t    del_all_user_resp;
   bmkt_enrolled_fingers_resp_t enrolled_fingers_resp;
 } bmkt_response_data_t;
 

libfprint/drivers/synaptics/synaptics.c

@@ -31,14 +31,20 @@ static void init_identify_msg (FpDevice *device);
 static void compose_and_send_identify_msg (FpDevice *device);
 
 static const FpIdEntry id_table[] = {
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xBD,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xE9,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xDF,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xF9,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xFC,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xC2,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xC9,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0xE7,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00BD,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00DF,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F9,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00FC,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C2,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0100,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F0,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0103,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0123,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0126,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0129,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0168,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x015F,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0104,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 
@@ -197,12 +203,17 @@ cmd_interrupt_cb (FpiUsbTransfer *transfer,
                   GError         *error)
 {
   g_debug ("interrupt transfer done");
+  fpi_device_critical_enter (device);
+
   if (error)
     {
       if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
         {
           g_error_free (error);
-          fpi_ssm_jump_to_state (transfer->ssm, SYNAPTICS_CMD_GET_RESP);
+          if (FPI_DEVICE_SYNAPTICS (device)->cmd_suspended)
+            fpi_ssm_jump_to_state (transfer->ssm, SYNAPTICS_CMD_SUSPENDED);
+          else
+            fpi_ssm_jump_to_state (transfer->ssm, SYNAPTICS_CMD_GET_RESP);
           return;
         }
 
@@ -216,6 +227,7 @@ cmd_interrupt_cb (FpiUsbTransfer *transfer,
     }
   else
     {
+      fpi_device_critical_leave (device);
       fpi_usb_transfer_submit (fpi_usb_transfer_ref (transfer),
                                0,
                                NULL,
@@ -263,6 +275,9 @@ synaptics_cmd_run_state (FpiSsm   *ssm,
       break;
 
     case SYNAPTICS_CMD_WAIT_INTERRUPT:
+      /* Interruptions are permitted only during an interrupt transfer */
+      fpi_device_critical_leave (dev);
+
       transfer = fpi_usb_transfer_new (dev);
       transfer->ssm = ssm;
       fpi_usb_transfer_fill_interrupt (transfer, USB_EP_INTERRUPT, USB_INTERRUPT_DATA_SIZE);
@@ -290,6 +305,17 @@ synaptics_cmd_run_state (FpiSsm   *ssm,
     case SYNAPTICS_CMD_RESTART:
       fpi_ssm_jump_to_state (ssm, SYNAPTICS_CMD_SEND_PENDING);
       break;
+
+    case SYNAPTICS_CMD_SUSPENDED:
+      /* The resume handler continues to the next state! */
+      fpi_device_critical_leave (dev);
+      fpi_device_suspend_complete (dev, NULL);
+      break;
+
+    case SYNAPTICS_CMD_RESUME:
+      fpi_device_critical_enter (dev);
+      fpi_ssm_jump_to_state (ssm, SYNAPTICS_CMD_WAIT_INTERRUPT);
+      break;
     }
 }
 
@@ -305,6 +331,7 @@ cmd_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
   if (error || self->cmd_complete_on_removal)
     callback (self, NULL, error);
 
+  fpi_device_critical_leave (dev);
   self->cmd_complete_on_removal = FALSE;
 }
 
@@ -414,6 +441,7 @@ synaptics_sensor_cmd (FpiDeviceSynaptics *self,
                                        SYNAPTICS_CMD_NUM_STATES);
           fpi_ssm_set_data (self->cmd_ssm, callback, NULL);
 
+          fpi_device_critical_enter (FP_DEVICE (self));
           fpi_ssm_start (self->cmd_ssm, cmd_ssm_done);
         }
     }
@@ -460,7 +488,7 @@ create_print (FpiDeviceSynaptics *self,
               guint8              finger_id)
 {
   FpPrint *print;
-  g_autofree gchar *user_id_safe;
+  g_autofree gchar *user_id_safe = NULL;
   GVariant *data = NULL;
   GVariant *uid = NULL;
 
@@ -485,100 +513,6 @@ create_print (FpiDeviceSynaptics *self,
   return print;
 }
 
-static void
-list_msg_cb (FpiDeviceSynaptics *self,
-             bmkt_response_t    *resp,
-             GError             *error)
-{
-  bmkt_enroll_templates_resp_t *get_enroll_templates_resp;
-
-  if (error)
-    {
-      g_clear_pointer (&self->list_result, g_ptr_array_unref);
-      fpi_device_list_complete (FP_DEVICE (self), NULL, error);
-      return;
-    }
-
-  get_enroll_templates_resp = &resp->response.enroll_templates_resp;
-
-  switch (resp->response_id)
-    {
-    case BMKT_RSP_QUERY_FAIL:
-      if (resp->result == BMKT_FP_DATABASE_EMPTY)
-        {
-          fp_info ("Database is empty");
-
-          fpi_device_list_complete (FP_DEVICE (self),
-                                    g_steal_pointer (&self->list_result),
-                                    NULL);
-        }
-      else
-        {
-          fp_info ("Failed to query enrolled users: %d", resp->result);
-          g_clear_pointer (&self->list_result, g_ptr_array_unref);
-          fpi_device_list_complete (FP_DEVICE (self),
-                                    NULL,
-                                    fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
-                                                              "Failed to query enrolled users: %d",
-                                                              resp->result));
-        }
-      break;
-
-    case BMKT_RSP_QUERY_RESPONSE_COMPLETE:
-      fp_info ("Query complete!");
-
-      fpi_device_list_complete (FP_DEVICE (self),
-                                g_steal_pointer (&self->list_result),
-                                NULL);
-
-      break;
-
-    case BMKT_RSP_TEMPLATE_RECORDS_REPORT:
-
-      for (int n = 0; n < BMKT_MAX_NUM_TEMPLATES_INTERNAL_FLASH; n++)
-        {
-          FpPrint *print;
-
-          if (get_enroll_templates_resp->templates[n].user_id_len == 0)
-            continue;
-
-          fp_info ("![query %d of %d] template %d: status=0x%x, userId=%s, fingerId=%d",
-                   get_enroll_templates_resp->query_sequence,
-                   get_enroll_templates_resp->total_query_messages,
-                   n,
-                   get_enroll_templates_resp->templates[n].template_status,
-                   get_enroll_templates_resp->templates[n].user_id,
-                   get_enroll_templates_resp->templates[n].finger_id);
-
-          print = create_print (self,
-                                get_enroll_templates_resp->templates[n].user_id,
-                                get_enroll_templates_resp->templates[n].finger_id);
-
-          g_ptr_array_add (self->list_result, g_object_ref_sink (print));
-        }
-
-      synaptics_sensor_cmd (self,
-                            self->cmd_seq_num,
-                            BMKT_CMD_GET_NEXT_QUERY_RESPONSE,
-                            NULL,
-                            0,
-                            NULL);
-
-      break;
-    }
-}
-
-static void
-list (FpDevice *device)
-{
-  FpiDeviceSynaptics *self = FPI_DEVICE_SYNAPTICS (device);
-
-  G_DEBUG_HERE ();
-
-  self->list_result = g_ptr_array_new_with_free_func (g_object_unref);
-  synaptics_sensor_cmd (self, 0, BMKT_CMD_GET_TEMPLATE_RECORDS, NULL, 0, list_msg_cb);
-}
-
 static void
 verify_complete_after_finger_removal (FpiDeviceSynaptics *self)
 {
@@ -603,6 +537,12 @@ verify_msg_cb (FpiDeviceSynaptics *self,
   FpDevice *device = FP_DEVICE (self);
   bmkt_verify_resp_t *verify_resp;
 
+  if (self->action_starting)
+    {
+      fpi_device_critical_leave (device);
+      self->action_starting = FALSE;
+    }
+
   if (error)
     {
       fpi_device_verify_complete (device, error);
@@ -695,6 +635,8 @@ verify (FpDevice *device)
 
   G_DEBUG_HERE ();
 
+  self->action_starting = TRUE;
+  fpi_device_critical_enter (device);
   synaptics_sensor_cmd (self, 0, BMKT_CMD_VERIFY_USER, user_id, user_id_len, verify_msg_cb);
 }
 
@@ -722,6 +664,12 @@ identify_msg_cb (FpiDeviceSynaptics *self,
 {
   FpDevice *device = FP_DEVICE (self);
 
+  if (self->action_starting)
+    {
+      fpi_device_critical_leave (device);
+      self->action_starting = FALSE;
+    }
+
   if (error)
     {
       fpi_device_identify_complete (device, error);
@@ -810,6 +758,25 @@ identify_msg_cb (FpiDeviceSynaptics *self,
 static void
 identify (FpDevice *device)
 {
+  GPtrArray *prints = NULL;
+  FpiDeviceSynaptics *self = FPI_DEVICE_SYNAPTICS (device);
+
+  fpi_device_get_identify_data (device, &prints);
+
+  /* Identify over no prints does not work for synaptics.
+   * This *may* make sense for other devices though, as identify may return
+   * a matched print even if it is not in the list of prints.
+   */
+  if (prints->len == 0)
+    {
+      fpi_device_identify_report (device, NULL, NULL, NULL);
+      fpi_device_identify_complete (device, NULL);
+      return;
+    }
+
+  self->action_starting = TRUE;
+  fpi_device_critical_enter (device);
+
   init_identify_msg (device);
   compose_and_send_identify_msg (device);
 }
@@ -912,6 +879,12 @@ enroll_msg_cb (FpiDeviceSynaptics *self,
   FpDevice *device = FP_DEVICE (self);
   bmkt_enroll_resp_t *enroll_resp;
 
+  if (self->action_starting)
+    {
+      fpi_device_critical_leave (device);
+      self->action_starting = FALSE;
+    }
+
   if (error)
     {
       fpi_device_enroll_complete (device, NULL, error);
@@ -1058,6 +1031,9 @@ enroll (FpDevice *device)
   payload[1] = finger;
   memcpy (payload + 2, user_id, user_id_len);
 
+  self->action_starting = TRUE;
+  fpi_device_critical_enter (device);
+
   synaptics_sensor_cmd (self, 0, BMKT_CMD_ENROLL_USER, payload, user_id_len + 2, enroll_msg_cb);
 }
 
@@ -1071,6 +1047,7 @@ delete_msg_cb (FpiDeviceSynaptics *self,
 
   if (error)
     {
+      fpi_device_critical_leave (device);
       fpi_device_delete_complete (device, error);
       return;
     }
@@ -1085,17 +1062,24 @@ delete_msg_cb (FpiDeviceSynaptics *self,
       break;
 
     case BMKT_RSP_DEL_USER_FP_FAIL:
-      fp_info ("Failed to delete enrolled user: %d", resp->result);
-      if (resp->result == BMKT_FP_DATABASE_NO_RECORD_EXISTS)
-        fpi_device_delete_complete (device,
-                                    fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
+      fpi_device_critical_leave (device);
+      if (resp->result == BMKT_FP_DATABASE_NO_RECORD_EXISTS ||
+          resp->result == BMKT_FP_DATABASE_EMPTY)
+        {
+          fp_info ("Database no record");
+          fpi_device_delete_complete (device, NULL);
+        }
       else
-        fpi_device_delete_complete (device,
-                                    fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
+        {
+          fp_info ("Failed to delete enrolled user: %d", resp->result);
+          fpi_device_delete_complete (device,
+                                      fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
+        }
       break;
 
     case BMKT_RSP_DEL_USER_FP_OK:
       fp_info ("Successfully deleted enrolled user");
+      fpi_device_critical_leave (device);
       fpi_device_delete_complete (device, NULL);
       break;
     }
@@ -1130,9 +1114,58 @@ delete_print (FpDevice *device)
   payload[0] = finger;
   memcpy (payload + 1, user_id, user_id_len);
 
+  fpi_device_critical_enter (device);
   synaptics_sensor_cmd (self, 0, BMKT_CMD_DEL_USER_FP, payload, user_id_len + 1, delete_msg_cb);
 }
 
+static void
+clear_storage_msg_cb (FpiDeviceSynaptics *self,
+                      bmkt_response_t    *resp,
+                      GError             *error)
+{
+  FpDevice *device = FP_DEVICE (self);
+  bmkt_del_all_users_resp_t *del_all_user_resp;
+
+  if (error)
+    {
+      fpi_device_clear_storage_complete (device, error);
+      return;
+    }
+  del_all_user_resp = &resp->response.del_all_user_resp;
+
+  switch (resp->response_id)
+    {
+    case BMKT_RSP_DELETE_PROGRESS:
+      fp_info ("Deleting All Enrolled Users is %d%% complete",
+               del_all_user_resp->progress);
+      break;
+
+    case BMKT_RSP_DEL_FULL_DB_FAIL:
+      if (resp->result == BMKT_FP_DATABASE_EMPTY)
+        fpi_device_clear_storage_complete (device, NULL);
+      else
+        fpi_device_clear_storage_complete (device,
+                                           fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
+      break;
+
+    case BMKT_RSP_DEL_FULL_DB_OK:
+      fp_info ("Successfully deleted all enrolled user");
+      fpi_device_clear_storage_complete (device, NULL);
+      break;
+    }
+}
+
+static void
+clear_storage (FpDevice *device)
+{
+  FpiDeviceSynaptics *self = FPI_DEVICE_SYNAPTICS (device);
+
+  g_debug ("clear all prints in database");
+  synaptics_sensor_cmd (self, 0, BMKT_CMD_DEL_FULL_DB, NULL, 0, clear_storage_msg_cb);
+  return;
+}
+
+
 static void
 prob_msg_cb (FpiDeviceSynaptics *self,
              bmkt_response_t    *resp,
@@ -1140,14 +1173,18 @@ prob_msg_cb (FpiDeviceSynaptics *self,
 {
   GUsbDevice *usb_dev = NULL;
   g_autofree gchar *serial = NULL;
+  GError *err = NULL;
 
   usb_dev = fpi_device_get_usb_device (FP_DEVICE (self));
 
   if (error)
     {
+      if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        err = fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL, "unsupported firmware version");
+
       g_usb_device_close (usb_dev, NULL);
-      fpi_device_probe_complete (FP_DEVICE (self), NULL, NULL,
-                                 fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL, "unsupported firmware version"));
+      fpi_device_probe_complete (FP_DEVICE (self), NULL, NULL, err);
+      g_clear_error (&error);
       return;
     }
 
@@ -1156,12 +1193,17 @@ prob_msg_cb (FpiDeviceSynaptics *self,
   else
     serial = g_usb_device_get_string_descriptor (usb_dev,
                                                  g_usb_device_get_serial_number_index (usb_dev),
-                                                 &error);
+                                                 &err);
 
-  if (resp->result == BMKT_SUCCESS)
+  /* BMKT_OPERATION_DENIED is returned if the sensor is already initialized */
+  if (resp->result == BMKT_SUCCESS || resp->result == BMKT_OPERATION_DENIED)
     {
       g_usb_device_close (usb_dev, NULL);
-      fpi_device_probe_complete (FP_DEVICE (self), serial, NULL, error);
+      fpi_device_probe_complete (FP_DEVICE (self), serial, NULL, err);
+    }
+  else if (resp->result == BMKT_FP_SYSTEM_BUSY)
+    {
+      synaptics_sensor_cmd (self, self->cmd_seq_num, BMKT_CMD_CANCEL_OP, NULL, 0, NULL);
     }
   else
     {
@@ -1196,9 +1238,6 @@ dev_probe (FpDevice *device)
       return;
     }
 
-  if (!g_usb_device_reset (usb_dev, &error))
-    goto err_close;
-
   if (!g_usb_device_claim_interface (usb_dev, 0, 0, &error))
     goto err_close;
 
@@ -1287,6 +1326,9 @@ fps_init_msg_cb (FpiDeviceSynaptics *self,
 {
   if (error)
     {
+      if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
+        g_clear_error (&error);
+
       fpi_device_open_complete (FP_DEVICE (self), error);
       return;
     }
@@ -1296,6 +1338,10 @@ fps_init_msg_cb (FpiDeviceSynaptics *self,
     {
       fpi_device_open_complete (FP_DEVICE (self), NULL);
     }
+  else if (resp->result == BMKT_FP_SYSTEM_BUSY)
+    {
+      synaptics_sensor_cmd (self, self->cmd_seq_num, BMKT_CMD_CANCEL_OP, NULL, 0, NULL);
+    }
   else
     {
       g_warning ("Initializing fingerprint sensor failed with %d!", resp->result);
@@ -1308,8 +1354,12 @@ fps_deinit_cb (FpiDeviceSynaptics *self,
                bmkt_response_t    *resp,
                GError             *error)
 {
+  g_autoptr(GError) err = NULL;
+
   /* Release usb interface */
-  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (self)), 0, 0, &error);
+  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (self)), 0, 0, &err);
+  if (!error)
+    error = g_steal_pointer (&err);
 
   g_clear_object (&self->interrupt_cancellable);
 
@@ -1342,9 +1392,6 @@ dev_init (FpDevice *device)
 
   self->interrupt_cancellable = g_cancellable_new ();
 
-  if (!g_usb_device_reset (fpi_device_get_usb_device (device), &error))
-    goto error;
-
   /* Claim usb interface */
   if (!g_usb_device_claim_interface (fpi_device_get_usb_device (device), 0, 0, &error))
     goto error;
@@ -1383,6 +1430,59 @@ cancel (FpDevice *dev)
   self->interrupt_cancellable = g_cancellable_new ();
 }
 
+static void
+suspend (FpDevice *dev)
+{
+  FpiDeviceSynaptics *self = FPI_DEVICE_SYNAPTICS (dev);
+  FpiDeviceAction action = fpi_device_get_current_action (dev);
+
+  g_debug ("got suspend request");
+
+  if (action != FPI_DEVICE_ACTION_VERIFY && action != FPI_DEVICE_ACTION_IDENTIFY)
+    {
+      fpi_device_suspend_complete (dev, fpi_device_error_new (FP_DEVICE_ERROR_NOT_SUPPORTED));
+      return;
+    }
+
+  /* We are guaranteed to have a cmd_ssm running at this time. */
+  g_assert (self->cmd_ssm);
+  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == SYNAPTICS_CMD_WAIT_INTERRUPT);
+  self->cmd_suspended = TRUE;
+
+  /* Cancel the current transfer.
+   * The CMD SSM will go into the suspend state and signal readyness. */
+  g_cancellable_cancel (self->interrupt_cancellable);
+  g_clear_object (&self->interrupt_cancellable);
+  self->interrupt_cancellable = g_cancellable_new ();
+}
+
+static void
+resume (FpDevice *dev)
+{
+  FpiDeviceSynaptics *self = FPI_DEVICE_SYNAPTICS (dev);
+  FpiDeviceAction action = fpi_device_get_current_action (dev);
+
+  g_debug ("got resume request");
+
+  if (action != FPI_DEVICE_ACTION_VERIFY && action != FPI_DEVICE_ACTION_IDENTIFY)
+    {
+      g_assert_not_reached ();
+      fpi_device_resume_complete (dev, fpi_device_error_new (FP_DEVICE_ERROR_NOT_SUPPORTED));
+      return;
+    }
+
+  /* We must have a suspended cmd_ssm at this point */
+  g_assert (self->cmd_ssm);
+  g_assert (self->cmd_suspended);
+  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == SYNAPTICS_CMD_SUSPENDED);
+  self->cmd_suspended = FALSE;
+
+  /* Restart interrupt transfer. */
+  fpi_ssm_jump_to_state (self->cmd_ssm, SYNAPTICS_CMD_RESUME);
+
+  fpi_device_resume_complete (dev, NULL);
+}
+
 static void
 fpi_device_synaptics_init (FpiDeviceSynaptics *self)
 {
@@ -1400,6 +1500,7 @@ fpi_device_synaptics_class_init (FpiDeviceSynapticsClass *klass)
   dev_class->scan_type = FP_SCAN_TYPE_PRESS;
   dev_class->id_table = id_table;
   dev_class->nr_enroll_stages = ENROLL_SAMPLES;
+  dev_class->temp_hot_seconds = -1;
 
   dev_class->open = dev_init;
   dev_class->close = dev_exit;
@@ -1408,6 +1509,10 @@ fpi_device_synaptics_class_init (FpiDeviceSynapticsClass *klass)
   dev_class->identify = identify;
   dev_class->enroll = enroll;
   dev_class->delete = delete_print;
+  dev_class->clear_storage = clear_storage;
   dev_class->cancel = cancel;
-  dev_class->list = list;
+  dev_class->suspend = suspend;
+  dev_class->resume = resume;
+
+  fpi_device_class_auto_initialize_features (dev_class);
 }

libfprint/drivers/synaptics/synaptics.h

@@ -93,6 +93,8 @@ typedef enum {
   SYNAPTICS_CMD_WAIT_INTERRUPT,
   SYNAPTICS_CMD_SEND_ASYNC,
   SYNAPTICS_CMD_RESTART,
+  SYNAPTICS_CMD_SUSPENDED,
+  SYNAPTICS_CMD_RESUME,
   SYNAPTICS_CMD_NUM_STATES,
 } SynapticsCmdState;
 
@@ -110,10 +112,12 @@ struct _FpiDeviceSynaptics
   FpiSsm               *cmd_ssm;
   FpiUsbTransfer       *cmd_pending_transfer;
   gboolean              cmd_complete_on_removal;
+  gboolean              cmd_suspended;
   guint8                id_idx;
 
   bmkt_sensor_version_t mis_version;
 
+  gboolean              action_starting;
   GCancellable         *interrupt_cancellable;
 
   gint                  enroll_stage;

libfprint/drivers/upek_proto.c

@@ -1,21 +1,24 @@
 /*
- * LGPL CRC code copied from GStreamer-0.10.10:
+ * Code copied from gstreamer-plugins-bad gst/gdp/dataprotocol.c
+ *
  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
  * Copyright (C) 2004,2006 Thomas Vander Stichele <thomas at apestaart dot 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; version
- * 2.1 of the License.
+ * Copyright (C) 2014 Tim-Philipp Müller <tim centricular com>
  *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301 USA
  */
 
 #include "upek_proto.h"

libfprint/drivers/upek_proto.h

@@ -1,21 +1,24 @@
 /*
- * LGPL CRC code copied from GStreamer-0.10.10:
+ * Code copied from gstreamer-plugins-bad gst/gdp/dataprotocol.c
+ *
  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
  * Copyright (C) 2004,2006 Thomas Vander Stichele <thomas at apestaart dot 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; version
- * 2.1 of the License.
+ * Copyright (C) 2014 Tim-Philipp Müller <tim centricular com>
  *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301 USA
  */
 
 #include <stdint.h>

libfprint/drivers/upeksonly.c

@@ -79,7 +79,7 @@ struct _FpiDeviceUpeksonly
   int                              num_flying;
 
   GSList                          *rows;
-  size_t                           num_rows;
+  unsigned                         num_rows;
   unsigned char                   *rowbuf;
   int                              rowbuf_offset;
 
@@ -176,6 +176,7 @@ last_transfer_killed (FpImageDevice *dev)
       fpi_image_device_session_error (dev, g_steal_pointer (&self->kill_error));
       return;
 
+    case NOT_KILLING:
     default:
       return;
     }
@@ -214,7 +215,7 @@ handoff_img (FpImageDevice *dev)
 
   self->rows = g_slist_reverse (self->rows);
 
-  fp_dbg ("%lu rows", self->num_rows);
+  fp_dbg ("%u rows", self->num_rows);
   img = fpi_assemble_lines (&self->assembling_ctx, self->rows, self->num_rows);
 
   g_slist_free_full (self->rows, g_free);
@@ -294,7 +295,7 @@ row_complete (FpImageDevice *dev)
           if (self->num_blank > FINGER_REMOVED_THRESHOLD)
             {
               self->finger_state = FINGER_REMOVED;
-              fp_dbg ("detected finger removal. Blank rows: %d, Full rows: %lu",
+              fp_dbg ("detected finger removal. Blank rows: %d, Full rows: %u",
                       self->num_blank, self->num_rows);
               handoff_img (dev);
               return;
@@ -693,8 +694,6 @@ sm_read_reg_cb (FpiUsbTransfer *transfer, FpDevice *device,
       fp_dbg ("read reg result = %02x", self->read_reg_result);
       fpi_ssm_next_state (transfer->ssm);
     }
-
-  g_free (transfer->buffer);
 }
 
 static void
@@ -731,7 +730,6 @@ sm_await_intr_cb (FpiUsbTransfer *transfer, FpDevice *device,
 
   if (error)
     {
-      g_free (transfer->buffer);
       fpi_ssm_mark_failed (transfer->ssm, error);
       return;
     }
@@ -739,7 +737,6 @@ sm_await_intr_cb (FpiUsbTransfer *transfer, FpDevice *device,
   fp_dbg ("interrupt received: %02x %02x %02x %02x",
           transfer->buffer[0], transfer->buffer[1],
           transfer->buffer[2], transfer->buffer[3]);
-  g_free (transfer->buffer);
 
   self->finger_state = FINGER_DETECTED;
   fpi_image_device_report_finger_status (dev, TRUE);

libfprint/drivers/upektc.c

@@ -411,7 +411,7 @@ dev_init (FpImageDevice *dev)
       break;
 
     default:
-      fp_err ("Device variant %lu is not known", driver_data);
+      fp_err ("Device variant %" G_GUINT64_FORMAT " is not known", driver_data);
       g_assert_not_reached ();
       fpi_image_device_open_complete (dev, fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
       return;
@@ -431,6 +431,7 @@ dev_deinit (FpImageDevice *dev)
 
 static const FpIdEntry id_table[] = {
   { .vid = 0x0483,  .pid = 0x2015, .driver_data = UPEKTC_2015 },
+  { .vid = 0x0483,  .pid = 0x2017, .driver_data = UPEKTC_2015 },
   { .vid = 0x147e,  .pid = 0x3001, .driver_data = UPEKTC_3001 },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },
 };

libfprint/drivers/upektc_img.c

@@ -221,7 +221,7 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
       if (response_size > transfer->actual_length)
         {
           fp_dbg ("response_size is %lu, actual_length is %d",
-                  response_size, (gint) transfer->actual_length);
+                  (gulong) response_size, (gint) transfer->actual_length);
           fp_dbg ("Waiting for rest of transfer");
           BUG_ON (self->response_rest);
           self->response_rest = response_size - transfer->actual_length;
@@ -309,7 +309,7 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
                                             data);
           BUG_ON (self->image_size != IMAGE_SIZE);
           fp_dbg ("Image size is %lu",
-                  self->image_size);
+                  (gulong) self->image_size);
           img = fp_image_new (IMAGE_WIDTH, IMAGE_HEIGHT);
           img->flags |= FPI_IMAGE_PARTIAL;
           memcpy (img->data, self->image_bits,

libfprint/drivers/upekts.c

@@ -10,19 +10,20 @@
  * Copyright (C) <1999> Erik Walthinsen <omega@cse.ogi.edu>
  * Copyright (C) 2004,2006 Thomas Vander Stichele <thomas at apestaart dot 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; version
- * 2.1 of the License.
+ * 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
+ * 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
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301 USA
  */
 
 #define FP_COMPONENT "upekts"
@@ -365,7 +366,7 @@ read_msg_cb (FpiUsbTransfer *transfer, FpDevice *device,
       fp_err ("async msg read too short (%d)",
               (gint) transfer->actual_length);
       error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                        "Packet from device was too short (%lu)",
+                                        "Packet from device was too short (%" G_GSSIZE_FORMAT ")",
                                         transfer->actual_length);
       goto err;
     }
@@ -992,7 +993,7 @@ e_handle_resp00 (FpDevice *dev, unsigned char *data,
 
   if (data_len != 14)
     {
-      fp_err ("received 3001 poll response of %lu bytes?", data_len);
+      fp_err ("received 3001 poll response of %" G_GSIZE_FORMAT " bytes?", data_len);
       do_enroll_stop (dev, NULL,
                       fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
                                                 "received 3001 response with wrong length"));
@@ -1089,7 +1090,7 @@ e_handle_resp02 (FpDevice *dev, unsigned char *data,
 
   if (data_len < sizeof (scan_comp))
     {
-      fp_err ("fingerprint data too short (%lu bytes)", data_len);
+      fp_err ("fingerprint data too short (%" G_GSIZE_FORMAT "u bytes)", data_len);
       error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, "fingerprint data too short");
     }
   else if (memcmp (data, scan_comp, sizeof (scan_comp)) != 0)
@@ -1317,7 +1318,7 @@ v_handle_resp00 (FpDevice *dev, unsigned char *data,
 
   if (data_len != 14)
     {
-      fp_warn ("received 3001 poll response of %lu bytes?", data_len);
+      fp_warn ("received 3001 poll response of %" G_GSIZE_FORMAT "u bytes?", data_len);
       error = fpi_device_error_new (FP_DEVICE_ERROR_PROTO);
       goto out;
     }
@@ -1555,4 +1556,6 @@ fpi_device_upekts_class_init (FpiDeviceUpektsClass *klass)
   dev_class->verify = verify;
   dev_class->enroll = enroll;
   /* dev_class->cancel = cancel; */
+
+  fpi_device_class_auto_initialize_features (dev_class);
 }

libfprint/drivers/uru4000.c

@@ -131,6 +131,7 @@ struct _FpiDeviceUru4000
   void                           *img_data;
   int                             img_data_actual_length;
   uint16_t                        img_lines_done, img_block;
+  GRand                          *rand;
   uint32_t                        img_enc_seed;
 
   irq_cb_fn                       irq_cb;
@@ -316,6 +317,7 @@ irq_handler (FpiUsbTransfer *transfer,
       if (urudev->irqs_stopped_cb)
         urudev->irqs_stopped_cb (imgdev);
       urudev->irqs_stopped_cb = NULL;
+      g_clear_error (&error);
       return;
     }
   else if (error)
@@ -359,9 +361,9 @@ start_irq_handler (FpImageDevice *dev)
   transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
   transfer->ssm = NULL;
   transfer->short_is_error = TRUE;
-  fpi_usb_transfer_fill_bulk (transfer,
-                              EP_INTR,
-                              IRQ_LENGTH);
+  fpi_usb_transfer_fill_interrupt (transfer,
+                                   EP_INTR,
+                                   IRQ_LENGTH);
   fpi_usb_transfer_submit (transfer, 0, self->irq_cancellable, irq_handler, NULL);
 }
 
@@ -397,7 +399,7 @@ finger_presence_irq_cb (FpImageDevice *dev,
     fpi_image_device_report_finger_status (dev, TRUE);
   else if (type == IRQDATA_FINGER_OFF)
     fpi_image_device_report_finger_status (dev, FALSE);
-  else
+  else if (type != IRQDATA_SCANPWR_ON)
     fp_warn ("ignoring unexpected interrupt %04x", type);
 }
 
@@ -550,7 +552,7 @@ image_transfer_cb (FpiUsbTransfer *transfer, FpDevice *dev,
     }
   else
     {
-      self->img_data = g_memdup (transfer->buffer, sizeof (struct uru4k_image));
+      self->img_data = g_memdup2 (transfer->buffer, sizeof (struct uru4k_image));
       self->img_data_actual_length = transfer->actual_length;
       fpi_ssm_next_state (ssm);
     }
@@ -722,7 +724,8 @@ imaging_run_state (FpiSsm *ssm, FpDevice *_dev)
               fp_dbg ("changing encryption keys.");
               img->block_info[self->img_block].flags &= ~BLOCKF_CHANGE_KEY;
               img->key_number++;
-              self->img_enc_seed = rand ();
+              self->img_enc_seed = g_rand_int_range (self->rand, 0, RAND_MAX);
+              fp_dbg ("New image encryption seed: %d", self->img_enc_seed);
               fpi_ssm_jump_to_state (ssm, IMAGING_SEND_INDEX);
               return;
             }
@@ -865,7 +868,7 @@ rebootpwr_run_state (FpiSsm *ssm, FpDevice *_dev)
         }
       else
         {
-          fpi_ssm_jump_to_state_delayed (ssm, 10, REBOOTPWR_GET_HWSTAT, NULL);
+          fpi_ssm_jump_to_state_delayed (ssm, 10, REBOOTPWR_GET_HWSTAT);
         }
       break;
     }
@@ -947,11 +950,11 @@ powerup_run_state (FpiSsm *ssm, FpDevice *_dev)
         }
       else if (!self->profile->auth_cr)
         {
-          fpi_ssm_jump_to_state_delayed (ssm, POWERUP_SET_HWSTAT, 10, NULL);
+          fpi_ssm_jump_to_state_delayed (ssm, POWERUP_SET_HWSTAT, 10);
         }
       else
         {
-          fpi_ssm_next_state_delayed (ssm, 10, NULL);
+          fpi_ssm_next_state_delayed (ssm, 10);
         }
       break;
 
@@ -1219,7 +1222,8 @@ execute_state_change (FpImageDevice *dev)
 
       ssm = fpi_ssm_new (FP_DEVICE (dev), imaging_run_state,
                          IMAGING_NUM_STATES);
-      self->img_enc_seed = rand ();
+      self->img_enc_seed = g_rand_int_range (self->rand, 0, RAND_MAX);
+      fp_dbg ("Image encryption seed: %d", self->img_enc_seed);
       self->img_transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
       self->img_transfer->ssm = ssm;
       self->img_transfer->short_is_error = FALSE;
@@ -1355,6 +1359,11 @@ dev_init (FpImageDevice *dev)
 
   self = FPI_DEVICE_URU4000 (dev);
 
+  g_clear_pointer (&self->rand, g_rand_free);
+  self->rand = g_rand_new ();
+  if (g_strcmp0 (g_getenv ("FP_DEVICE_EMULATION"), "1") == 0)
+    g_rand_set_seed (self->rand, 0xFACADE);
+
   driver_data = fpi_device_get_driver_data (FP_DEVICE (dev));
   self->profile = &uru4k_dev_info[driver_data];
   self->interface = g_usb_interface_get_number (iface);
@@ -1405,8 +1414,12 @@ dev_deinit (FpImageDevice *dev)
     SECITEM_FreeItem (self->param, PR_TRUE);
   if (self->slot)
     PK11_FreeSlot (self->slot);
+
+  NSS_Shutdown ();
+
   g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)),
                                   self->interface, 0, &error);
+  g_clear_pointer (&self->rand, g_rand_free);
   fpi_image_device_close_complete (dev, error);
 }
 

libfprint/drivers/vfs0050.c

@@ -581,7 +581,7 @@ activate_ssm (FpiSsm *ssm, FpDevice *dev)
             /* Initialize fingerprint buffer */
             g_free (self->lines_buffer);
             self->memory = VFS_USB_BUFFER_SIZE;
-            self->lines_buffer = g_malloc (self->memory);
+            self->lines_buffer = g_malloc0 (self->memory);
             self->bytes = 0;
 
             /* Finger is on the scanner */
@@ -589,12 +589,15 @@ activate_ssm (FpiSsm *ssm, FpDevice *dev)
           }
 
         /* Increase buffer size while it's insufficient */
-        while (self->bytes + VFS_USB_BUFFER_SIZE > self->memory)
+        while (self->memory < self->bytes + VFS_USB_BUFFER_SIZE)
           {
-            self->memory <<= 1;
+            int pre_memory = self->memory;
+            self->memory += VFS_USB_BUFFER_SIZE;
             self->lines_buffer =
               (struct vfs_line *) g_realloc (self->lines_buffer,
                                              self->memory);
+            memset ((guint8 *) self->lines_buffer + pre_memory, 0,
+                    VFS_USB_BUFFER_SIZE);
           }
 
         /* Receive chunk of data */
@@ -613,7 +616,7 @@ activate_ssm (FpiSsm *ssm, FpDevice *dev)
       clear_data (self);
 
       /* Wait for probable vdev->active changing */
-      fpi_ssm_next_state_delayed (ssm, VFS_SSM_TIMEOUT, NULL);
+      fpi_ssm_next_state_delayed (ssm, VFS_SSM_TIMEOUT);
       break;
 
     case SSM_NEXT_RECEIVE:
@@ -632,8 +635,7 @@ activate_ssm (FpiSsm *ssm, FpDevice *dev)
 
     case SSM_WAIT_ANOTHER_SCAN:
       /* Orange light is on now */
-      fpi_ssm_jump_to_state_delayed (ssm, SSM_TURN_ON, VFS_SSM_ORANGE_TIMEOUT,
-                                     NULL);
+      fpi_ssm_jump_to_state_delayed (ssm, SSM_TURN_ON, VFS_SSM_ORANGE_TIMEOUT);
       break;
 
     default:

libfprint/drivers/vfs101.c

@@ -785,7 +785,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)
 
     case M_LOOP_0_SLEEP:
       /* Wait fingerprint scanning */
-      fpi_ssm_next_state_delayed (ssm, 50, NULL);
+      fpi_ssm_next_state_delayed (ssm, 50);
       break;
 
     case M_LOOP_0_GET_STATE:
@@ -828,7 +828,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)
       img_extract (ssm, dev);
 
       /* Wait handling image */
-      fpi_ssm_next_state_delayed (ssm, 10, NULL);
+      fpi_ssm_next_state_delayed (ssm, 10);
       break;
 
     case M_LOOP_0_CHECK_ACTION:
@@ -851,7 +851,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)
       if (vfs_finger_state (self) == VFS_FINGER_PRESENT)
         {
           fpi_image_device_report_finger_status (dev, TRUE);
-          fpi_ssm_next_state_delayed (ssm, 250, NULL);
+          fpi_ssm_next_state_delayed (ssm, 250);
         }
       else
         {
@@ -881,7 +881,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)
 
     case M_LOOP_1_SLEEP:
       /* Wait fingerprint scanning */
-      fpi_ssm_next_state_delayed (ssm, 10, NULL);
+      fpi_ssm_next_state_delayed (ssm, 10);
       break;
 
     case M_LOOP_2_ABORT_PRINT:
@@ -917,7 +917,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)
         {
           /* Wait aborting */
           self->counter++;
-          fpi_ssm_next_state_delayed (ssm, 100, NULL);
+          fpi_ssm_next_state_delayed (ssm, 100);
         }
       else
         {
@@ -1055,7 +1055,7 @@ m_init_state (FpiSsm *ssm, FpDevice *_dev)
         {
           /* Wait aborting */
           self->counter++;
-          fpi_ssm_next_state_delayed (ssm, 100, NULL);
+          fpi_ssm_next_state_delayed (ssm, 100);
         }
       else
         {
@@ -1084,7 +1084,7 @@ m_init_state (FpiSsm *ssm, FpDevice *_dev)
             {
               /* Wait removing finger */
               self->counter++;
-              fpi_ssm_next_state_delayed (ssm, 250, NULL);
+              fpi_ssm_next_state_delayed (ssm, 250);
             }
           else
             {

libfprint/drivers/vfs301.c

@@ -97,7 +97,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)
 
     case M_WAIT_PRINT:
       /* Wait fingerprint scanning */
-      fpi_ssm_next_state_delayed (ssm, 200, NULL);
+      fpi_ssm_next_state_delayed (ssm, 200);
       break;
 
     case M_CHECK_PRINT:
@@ -115,7 +115,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev)
 
     case M_READ_PRINT_WAIT:
       /* Wait fingerprint scanning */
-      fpi_ssm_next_state_delayed (ssm, 200, NULL);
+      fpi_ssm_next_state_delayed (ssm, 200);
       break;
 
     case M_READ_PRINT_POLL:

libfprint/drivers/vfs301_proto.c

@@ -432,7 +432,7 @@ img_process_data (int first_block, FpDeviceVfs301 *dev, const guint8 *buf, int l
     usb_send (dev, data, len, NULL); \
   }
 
-#define RAW_DATA(x) g_memdup (x, sizeof (x)), sizeof (x)
+#define RAW_DATA(x) g_memdup2 (x, sizeof (x)), sizeof (x)
 
 #define IS_VFS301_FP_SEQ_START(b) ((b[0] == 0x01) && (b[1] == 0xfe))
 
@@ -465,7 +465,7 @@ int
 vfs301_proto_peek_event (FpDeviceVfs301 *dev)
 {
   g_autoptr(GError) error = NULL;
-  FpiUsbTransfer *transfer;
+  g_autoptr(FpiUsbTransfer) transfer = NULL;
 
   const char no_event[] = {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
   const char got_event[] = {0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00};

libfprint/drivers/vfs5011.c

@@ -196,6 +196,7 @@ usb_exchange_async (FpiSsm                  *ssm,
   FpiSsm *subsm = fpi_ssm_new_full (FP_DEVICE (data->device),
                                     usbexchange_loop,
                                     data->stepcount,
+                                    data->stepcount,
                                     exchange_name);
 
   fpi_ssm_set_data (subsm, data, NULL);
@@ -705,7 +706,7 @@ activate_loop (FpiSsm *ssm, FpDevice *_dev)
       break;
 
     case DEV_ACTIVATE_DATA_COMPLETE:
-      fpi_ssm_next_state_delayed (ssm, 1, NULL);
+      fpi_ssm_next_state_delayed (ssm, 1);
       break;
 
     case DEV_ACTIVATE_PREPARE_NEXT_CAPTURE:

libfprint/drivers/virtual-device-listener.c

@@ -28,35 +28,35 @@
 
 #include "virtual-device-private.h"
 
-struct _FpDeviceVirtualListener
+struct _FpiDeviceVirtualListener
 {
-  GSocketListener                     parent_instance;
+  GSocketListener                      parent_instance;
 
-  GSocketConnection                  *connection;
-  GCancellable                       *cancellable;
-  guint                               cancellable_id;
+  GSocketConnection                   *connection;
+  GCancellable                        *cancellable;
+  guint                                cancellable_id;
 
-  FpDeviceVirtualListenerConnectionCb ready_cb;
-  gpointer                            ready_cb_data;
+  FpiDeviceVirtualListenerConnectionCb ready_cb;
+  gpointer                             ready_cb_data;
 
-  gint                                socket_fd;
-  gint                                client_fd;
+  gint                                 socket_fd;
+  gint                                 client_fd;
 };
 
-G_DEFINE_TYPE (FpDeviceVirtualListener, fp_device_virtual_listener, G_TYPE_SOCKET_LISTENER)
+G_DEFINE_TYPE (FpiDeviceVirtualListener, fpi_device_virtual_listener, G_TYPE_SOCKET_LISTENER)
 
-static void start_listen (FpDeviceVirtualListener *self);
+static void start_listen (FpiDeviceVirtualListener *self);
 
-FpDeviceVirtualListener *
-fp_device_virtual_listener_new (void)
+FpiDeviceVirtualListener *
+fpi_device_virtual_listener_new (void)
 {
-  return g_object_new (fp_device_virtual_listener_get_type (), NULL);
+  return g_object_new (fpi_device_virtual_listener_get_type (), NULL);
 }
 
 static void
-fp_device_virtual_listener_dispose (GObject *object)
+fpi_device_virtual_listener_dispose (GObject *object)
 {
-  FpDeviceVirtualListener *self = FP_DEVICE_VIRTUAL_LISTENER (object);
+  FpiDeviceVirtualListener *self = FPI_DEVICE_VIRTUAL_LISTENER (object);
 
   if (self->cancellable_id)
     {
@@ -70,19 +70,19 @@ fp_device_virtual_listener_dispose (GObject *object)
 
   self->ready_cb = NULL;
 
-  G_OBJECT_CLASS (fp_device_virtual_listener_parent_class)->dispose (object);
+  G_OBJECT_CLASS (fpi_device_virtual_listener_parent_class)->dispose (object);
 }
 
 static void
-fp_device_virtual_listener_class_init (FpDeviceVirtualListenerClass *klass)
+fpi_device_virtual_listener_class_init (FpiDeviceVirtualListenerClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-  object_class->dispose = fp_device_virtual_listener_dispose;
+  object_class->dispose = fpi_device_virtual_listener_dispose;
 }
 
 static void
-fp_device_virtual_listener_init (FpDeviceVirtualListener *self)
+fpi_device_virtual_listener_init (FpiDeviceVirtualListener *self)
 {
 }
 
@@ -90,7 +90,7 @@ static void
 new_connection_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
 {
   g_autoptr(GError) error = NULL;
-  FpDeviceVirtualListener *self = user_data;
+  FpiDeviceVirtualListener *self = user_data;
   GSocketConnection *connection;
 
   connection = g_socket_listener_accept_finish (G_SOCKET_LISTENER (source_object),
@@ -123,7 +123,7 @@ new_connection_cb (GObject *source_object, GAsyncResult *res, gpointer user_data
 }
 
 static void
-start_listen (FpDeviceVirtualListener *self)
+start_listen (FpiDeviceVirtualListener *self)
 {
   g_socket_listener_accept_async (G_SOCKET_LISTENER (self),
                                   self->cancellable,
@@ -132,27 +132,27 @@ start_listen (FpDeviceVirtualListener *self)
 }
 
 static void
-on_cancelled (GCancellable            *cancellable,
-              FpDeviceVirtualListener *self)
+on_cancelled (GCancellable             *cancellable,
+              FpiDeviceVirtualListener *self)
 {
-  fp_device_virtual_listener_connection_close (self);
+  fpi_device_virtual_listener_connection_close (self);
   g_socket_listener_close (G_SOCKET_LISTENER (self));
   g_clear_object (&self->cancellable);
   self->ready_cb = NULL;
 }
 
 gboolean
-fp_device_virtual_listener_start (FpDeviceVirtualListener            *self,
-                                  const char                         *address,
-                                  GCancellable                       *cancellable,
-                                  FpDeviceVirtualListenerConnectionCb cb,
-                                  gpointer                            user_data,
-                                  GError                            **error)
+fpi_device_virtual_listener_start (FpiDeviceVirtualListener            *self,
+                                   const char                          *address,
+                                   GCancellable                        *cancellable,
+                                   FpiDeviceVirtualListenerConnectionCb cb,
+                                   gpointer                             user_data,
+                                   GError                             **error)
 {
   g_autoptr(GSocketAddress) addr = NULL;
   G_DEBUG_HERE ();
 
-  g_return_val_if_fail (FP_IS_DEVICE_VIRTUAL_LISTENER (self), FALSE);
+  g_return_val_if_fail (FPI_IS_DEVICE_VIRTUAL_LISTENER (self), FALSE);
   g_return_val_if_fail (cb != NULL, FALSE);
   g_return_val_if_fail (self->ready_cb == NULL, FALSE);
 
@@ -191,9 +191,9 @@ fp_device_virtual_listener_start (FpDeviceVirtualListener            *self,
 }
 
 gboolean
-fp_device_virtual_listener_connection_close (FpDeviceVirtualListener *self)
+fpi_device_virtual_listener_connection_close (FpiDeviceVirtualListener *self)
 {
-  g_return_val_if_fail (FP_IS_DEVICE_VIRTUAL_LISTENER (self), FALSE);
+  g_return_val_if_fail (FPI_IS_DEVICE_VIRTUAL_LISTENER (self), FALSE);
 
   if (!self->connection)
     return FALSE;
@@ -211,7 +211,7 @@ on_stream_read_cb (GObject      *source_object,
 {
   g_autoptr(GError) error = NULL;
   g_autoptr(GTask) task = user_data;
-  FpDeviceVirtualListener *self = g_task_get_source_object (task);
+  FpiDeviceVirtualListener *self = g_task_get_source_object (task);
   gboolean all;
   gboolean success;
   gsize bytes;
@@ -282,17 +282,17 @@ on_stream_read_cb (GObject      *source_object,
 }
 
 void
-fp_device_virtual_listener_read (FpDeviceVirtualListener *self,
-                                 gboolean                 all,
-                                 void                    *buffer,
-                                 gsize                    count,
-                                 GAsyncReadyCallback      callback,
-                                 gpointer                 user_data)
+fpi_device_virtual_listener_read (FpiDeviceVirtualListener *self,
+                                  gboolean                  all,
+                                  void                     *buffer,
+                                  gsize                     count,
+                                  GAsyncReadyCallback       callback,
+                                  gpointer                  user_data)
 {
   g_autoptr(GTask) task = NULL;
   GInputStream *stream;
 
-  g_return_if_fail (FP_IS_DEVICE_VIRTUAL_LISTENER (self));
+  g_return_if_fail (FPI_IS_DEVICE_VIRTUAL_LISTENER (self));
 
   task = g_task_new (self, self->cancellable, callback, user_data);
   g_object_set_data (G_OBJECT (task), "all", GINT_TO_POINTER (all));
@@ -324,9 +324,9 @@ fp_device_virtual_listener_read (FpDeviceVirtualListener *self,
 }
 
 gsize
-fp_device_virtual_listener_read_finish (FpDeviceVirtualListener *self,
-                                        GAsyncResult            *result,
-                                        GError                 **error)
+fpi_device_virtual_listener_read_finish (FpiDeviceVirtualListener *self,
+                                         GAsyncResult             *result,
+                                         GError                  **error)
 {
   g_return_val_if_fail (g_task_is_valid (result, self), 0);
 
@@ -334,10 +334,10 @@ fp_device_virtual_listener_read_finish (FpDeviceVirtualListener *self,
 }
 
 gboolean
-fp_device_virtual_listener_write_sync (FpDeviceVirtualListener *self,
-                                       const char              *buffer,
-                                       gsize                    count,
-                                       GError                 **error)
+fpi_device_virtual_listener_write_sync (FpiDeviceVirtualListener *self,
+                                        const char               *buffer,
+                                        gsize                     count,
+                                        GError                  **error)
 {
   if (!self->connection || g_io_stream_is_closed (G_IO_STREAM (self->connection)))
     {

libfprint/drivers/virtual-device-private.h

@@ -32,59 +32,59 @@
 
 #define MAX_LINE_LEN 1024
 
-G_DECLARE_FINAL_TYPE (FpDeviceVirtualListener, fp_device_virtual_listener, FP, DEVICE_VIRTUAL_LISTENER, GSocketListener)
+G_DECLARE_FINAL_TYPE (FpiDeviceVirtualListener, fpi_device_virtual_listener, FPI, DEVICE_VIRTUAL_LISTENER, GSocketListener)
 
-typedef void (*FpDeviceVirtualListenerConnectionCb) (FpDeviceVirtualListener *listener,
-                                                     gpointer                 user_data);
+typedef void (*FpiDeviceVirtualListenerConnectionCb) (FpiDeviceVirtualListener *listener,
+                                                      gpointer                  user_data);
 
-FpDeviceVirtualListener * fp_device_virtual_listener_new (void);
+FpiDeviceVirtualListener * fpi_device_virtual_listener_new (void);
 
-gboolean fp_device_virtual_listener_start (FpDeviceVirtualListener            *listener,
-                                           const char                         *address,
-                                           GCancellable                       *cancellable,
-                                           FpDeviceVirtualListenerConnectionCb cb,
-                                           gpointer                            user_data,
-                                           GError                            **error);
+gboolean fpi_device_virtual_listener_start (FpiDeviceVirtualListener            *listener,
+                                            const char                          *address,
+                                            GCancellable                        *cancellable,
+                                            FpiDeviceVirtualListenerConnectionCb cb,
+                                            gpointer                             user_data,
+                                            GError                             **error);
 
-gboolean fp_device_virtual_listener_connection_close (FpDeviceVirtualListener *listener);
+gboolean fpi_device_virtual_listener_connection_close (FpiDeviceVirtualListener *listener);
 
-void fp_device_virtual_listener_read (FpDeviceVirtualListener *listener,
-                                      gboolean                 all,
-                                      void                    *buffer,
-                                      gsize                    count,
-                                      GAsyncReadyCallback      callback,
-                                      gpointer                 user_data);
-gsize fp_device_virtual_listener_read_finish (FpDeviceVirtualListener *listener,
-                                              GAsyncResult            *result,
-                                              GError                 **error);
+void fpi_device_virtual_listener_read (FpiDeviceVirtualListener *listener,
+                                       gboolean                  all,
+                                       void                     *buffer,
+                                       gsize                     count,
+                                       GAsyncReadyCallback       callback,
+                                       gpointer                  user_data);
+gsize fpi_device_virtual_listener_read_finish (FpiDeviceVirtualListener *listener,
+                                               GAsyncResult             *result,
+                                               GError                  **error);
 
-gboolean fp_device_virtual_listener_write_sync (FpDeviceVirtualListener *self,
-                                                const char              *buffer,
-                                                gsize                    count,
-                                                GError                 **error);
+gboolean fpi_device_virtual_listener_write_sync (FpiDeviceVirtualListener *self,
+                                                 const char               *buffer,
+                                                 gsize                     count,
+                                                 GError                  **error);
 
 
 struct _FpDeviceVirtualDevice
 {
-  FpDevice                 parent;
+  FpDevice                  parent;
 
-  FpDeviceVirtualListener *listener;
-  GCancellable            *cancellable;
+  FpiDeviceVirtualListener *listener;
+  GCancellable             *cancellable;
 
-  char                     recv_buf[MAX_LINE_LEN];
+  char                      recv_buf[MAX_LINE_LEN];
 
-  GPtrArray               *pending_commands;
+  GPtrArray                *pending_commands;
 
-  GHashTable              *prints_storage;
+  GHashTable               *prints_storage;
 
-  guint                    wait_command_id;
-  guint                    sleep_timeout_id;
-  guint                    enroll_stages_passed;
-  gboolean                 match_reported;
-  gboolean                 supports_cancellation;
-  gboolean                 injected_synthetic_cmd;
-  gboolean                 ignore_wait;
-  gboolean                 keep_alive;
+  guint                     wait_command_id;
+  guint                     sleep_timeout_id;
+  guint                     enroll_stages_passed;
+  gboolean                  match_reported;
+  gboolean                  supports_cancellation;
+  gboolean                  injected_synthetic_cmd;
+  gboolean                  ignore_wait;
+  gboolean                  keep_alive;
 };
 
 /* Not really final here, but we can do this to share the FpDeviceVirtualDevice
@@ -99,11 +99,13 @@ struct _FpDeviceVirtualDeviceStorage
 G_DECLARE_FINAL_TYPE (FpDeviceVirtualDeviceStorage, fpi_device_virtual_device_storage, FP, DEVICE_VIRTUAL_DEVICE_STORAGE, FpDeviceVirtualDevice)
 
 
-char * process_cmds (FpDeviceVirtualDevice * self, gboolean scan, GError **error);
-char * start_scan_command (FpDeviceVirtualDevice *self,
-                           GError               **error);
-gboolean should_wait_for_command (FpDeviceVirtualDevice *self,
-                                  GError                *error);
+gboolean process_cmds (FpDeviceVirtualDevice * self,
+                       gboolean                scan,
+                       char                  **scan_id,
+                       GError                **error);
+gboolean start_scan_command (FpDeviceVirtualDevice *self,
+                             char                 **scan_id,
+                             GError               **error);
 gboolean should_wait_to_sleep (FpDeviceVirtualDevice *self,
                                const char            *scan_id,
                                GError                *error);

libfprint/drivers/virtual-device-storage.c

@@ -42,8 +42,7 @@ dev_identify (FpDevice *dev)
   FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (dev);
   g_autofree char *scan_id = NULL;
 
-  scan_id = start_scan_command (self, &error);
-  if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_PENDING))
+  if (!start_scan_command (self, &scan_id, &error))
     return;
 
   if (scan_id)
@@ -68,12 +67,17 @@ dev_identify (FpDevice *dev)
                                              new_scan,
                                              (GEqualFunc) fp_print_equal,
                                              NULL))
-        error = fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND);
+        {
+          match = FALSE;
+          g_clear_object (&new_scan);
+        }
       else if (g_ptr_array_find_with_equal_func (prints,
                                                  new_scan,
                                                  (GEqualFunc) fp_print_equal,
                                                  &idx))
-        match = g_ptr_array_index (prints, idx);
+        {
+          match = g_ptr_array_index (prints, idx);
+        }
 
       if (!self->match_reported)
         {
@@ -147,11 +151,10 @@ dev_list (FpDevice *dev)
   g_autoptr(GError) error = NULL;
   FpDeviceVirtualDevice *vdev = FP_DEVICE_VIRTUAL_DEVICE (dev);
 
-  process_cmds (vdev, FALSE, &error);
-  if (should_wait_for_command (vdev, error))
+  if (!process_cmds (vdev, FALSE, NULL, &error))
     return;
 
-  if (error && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+  if (error)
     {
       fpi_device_list_complete (dev, NULL, g_steal_pointer (&error));
       return;
@@ -160,6 +163,27 @@ dev_list (FpDevice *dev)
   fpi_device_list_complete (dev, get_stored_prints (vdev), NULL);
 }
 
+static void
+dev_clear_storage (FpDevice *dev)
+{
+  g_autoptr(GPtrArray) prints_list = NULL;
+  g_autoptr(GError) error = NULL;
+  FpDeviceVirtualDevice *vdev = FP_DEVICE_VIRTUAL_DEVICE (dev);
+
+  if (!process_cmds (vdev, FALSE, NULL, &error))
+    return;
+
+  if (error)
+    {
+      fpi_device_clear_storage_complete (dev, g_steal_pointer (&error));
+      return;
+    }
+
+  g_hash_table_remove_all (vdev->prints_storage);
+
+  fpi_device_clear_storage_complete (dev, NULL);
+}
+
 static void
 dev_delete (FpDevice *dev)
 {
@@ -169,11 +193,10 @@ dev_delete (FpDevice *dev)
   FpPrint *print = NULL;
   const char *id = NULL;
 
-  process_cmds (vdev, FALSE, &error);
-  if (should_wait_for_command (vdev, error))
+  if (!process_cmds (vdev, FALSE, NULL, &error))
     return;
 
-  if (error && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+  if (error)
     {
       fpi_device_delete_complete (dev, g_steal_pointer (&error));
       return;
@@ -202,6 +225,15 @@ dev_delete (FpDevice *dev)
                                 fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
 }
 
+static void
+dev_probe (FpDevice *dev)
+{
+  /* Disable features listed in driver_data */
+  fpi_device_update_features (dev, fpi_device_get_driver_data (dev), 0);
+
+  fpi_device_probe_complete (dev, NULL, NULL, NULL);
+}
+
 static void
 fpi_device_virtual_device_storage_init (FpDeviceVirtualDeviceStorage *self)
 {
@@ -224,8 +256,8 @@ fpi_device_virtual_device_storage_finalize (GObject *object)
 }
 
 static const FpIdEntry driver_ids[] = {
-  { .virtual_envvar = "FP_VIRTUAL_DEVICE_STORAGE" },
-  { .virtual_envvar = "FP_VIRTUAL_DEVICE_IDENT" },
+  { .virtual_envvar = "FP_VIRTUAL_DEVICE_STORAGE", .driver_data = 0 },
+  { .virtual_envvar = "FP_VIRTUAL_DEVICE_STORAGE_NO_LIST", .driver_data = FP_DEVICE_FEATURE_STORAGE_LIST },
   { .virtual_envvar = NULL }
 };
 
@@ -241,7 +273,12 @@ fpi_device_virtual_device_storage_class_init (FpDeviceVirtualDeviceStorageClass
   dev_class->full_name = "Virtual device with storage and identification for debugging";
   dev_class->id_table = driver_ids;
 
+  dev_class->probe = dev_probe;
   dev_class->identify = dev_identify;
   dev_class->list = dev_list;
   dev_class->delete = dev_delete;
+  dev_class->clear_storage = dev_clear_storage;
+
+  fpi_device_class_auto_initialize_features (dev_class);
+  dev_class->features |= FP_DEVICE_FEATURE_DUPLICATES_CHECK;
 }

libfprint/drivers/virtual-device.c

@@ -37,6 +37,7 @@ G_DEFINE_TYPE (FpDeviceVirtualDevice, fpi_device_virtual_device, FP_TYPE_DEVICE)
 #define INSERT_CMD_PREFIX "INSERT "
 #define REMOVE_CMD_PREFIX "REMOVE "
 #define SCAN_CMD_PREFIX "SCAN "
+#define CONT_CMD_PREFIX "CONT "
 #define ERROR_CMD_PREFIX "ERROR "
 #define RETRY_CMD_PREFIX "RETRY "
 #define FINGER_CMD_PREFIX "FINGER "
@@ -57,6 +58,8 @@ maybe_continue_current_action (FpDeviceVirtualDevice *self)
   if (self->sleep_timeout_id)
     return;
 
+  g_assert (self->wait_command_id == 0);
+
   switch (fpi_device_get_current_action (dev))
     {
     case FPI_DEVICE_ACTION_ENROLL:
@@ -87,6 +90,14 @@ maybe_continue_current_action (FpDeviceVirtualDevice *self)
       FP_DEVICE_GET_CLASS (self)->close (dev);
       break;
 
+    case FPI_DEVICE_ACTION_CLEAR_STORAGE:
+      FP_DEVICE_GET_CLASS (self)->clear_storage (dev);
+      break;
+
+    /* Not implemented/nothing to do. */
+    case FPI_DEVICE_ACTION_NONE:
+    case FPI_DEVICE_ACTION_PROBE:
+    case FPI_DEVICE_ACTION_CAPTURE:
     default:
       break;
     }
@@ -108,23 +119,56 @@ sleep_timeout_cb (gpointer data)
   return FALSE;
 }
 
-char *
+static gboolean
+wait_for_command_timeout (gpointer data)
+{
+  FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (data);
+  FpiDeviceAction action;
+  GError *error = NULL;
+
+  self->wait_command_id = 0;
+
+  action = fpi_device_get_current_action (FP_DEVICE (self));
+  if (action == FPI_DEVICE_ACTION_LIST || action == FPI_DEVICE_ACTION_DELETE)
+    {
+      self->ignore_wait = TRUE;
+      maybe_continue_current_action (self);
+      self->ignore_wait = FALSE;
+
+      return FALSE;
+    }
+
+  error = g_error_new (G_IO_ERROR, G_IO_ERROR_TIMED_OUT, "No commands arrived in time to run!");
+  fpi_device_action_error (FP_DEVICE (self), error);
+
+  return FALSE;
+}
+
+gboolean
 process_cmds (FpDeviceVirtualDevice * self,
               gboolean                scan,
+              char                  **scan_id,
               GError                **error)
 {
+  gboolean removed;
+
   if (g_cancellable_is_cancelled (self->cancellable) ||
       (fpi_device_get_current_action (FP_DEVICE (self)) != FPI_DEVICE_ACTION_NONE &&
        g_cancellable_is_cancelled (fpi_device_get_cancellable (FP_DEVICE (self)))))
     {
       g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CANCELLED,
                            "Operation was cancelled");
-      return NULL;
+      return TRUE;
     }
 
   while (self->pending_commands->len > 0)
     {
-      gchar *cmd = g_ptr_array_index (self->pending_commands, 0);
+      g_autofree gchar *cmd = NULL;
+
+      /* TODO: g_ptr_array_steal_index requires GLib 2.58, we depend on 2.56 */
+      cmd = g_ptr_array_index (self->pending_commands, 0);
+      g_ptr_array_index (self->pending_commands, 0) = NULL;
+      g_ptr_array_remove_index (self->pending_commands, 0);
 
       g_debug ("Processing command %s", cmd);
 
@@ -135,7 +179,6 @@ process_cmds (FpDeviceVirtualDevice * self,
           g_hash_table_add (self->prints_storage,
                             g_strdup (cmd + strlen (INSERT_CMD_PREFIX)));
 
-          g_ptr_array_remove_index (self->pending_commands, 0);
           continue;
         }
       else if (g_str_has_prefix (cmd, REMOVE_CMD_PREFIX))
@@ -145,50 +188,49 @@ process_cmds (FpDeviceVirtualDevice * self,
                                     cmd + strlen (REMOVE_CMD_PREFIX)))
             g_warning ("ID %s was not found in storage", cmd + strlen (REMOVE_CMD_PREFIX));
 
-          g_ptr_array_remove_index (self->pending_commands, 0);
           continue;
         }
       else if (g_str_has_prefix (cmd, SLEEP_CMD_PREFIX))
         {
           guint64 sleep_ms = g_ascii_strtoull (cmd + strlen (SLEEP_CMD_PREFIX), NULL, 10);
 
-          g_debug ("Sleeping %lums", sleep_ms);
+          g_debug ("Sleeping %" G_GUINT64_FORMAT "ms", sleep_ms);
           self->sleep_timeout_id = g_timeout_add (sleep_ms, sleep_timeout_cb, self);
-          g_ptr_array_remove_index (self->pending_commands, 0);
 
-          return NULL;
+          return FALSE;
         }
       else if (g_str_has_prefix (cmd, ERROR_CMD_PREFIX))
         {
           g_propagate_error (error,
                              fpi_device_error_new (g_ascii_strtoull (cmd + strlen (ERROR_CMD_PREFIX), NULL, 10)));
 
-          g_ptr_array_remove_index (self->pending_commands, 0);
-          return NULL;
+          return TRUE;
+        }
+      else if (!scan && g_str_has_prefix (cmd, CONT_CMD_PREFIX))
+        {
+          return TRUE;
         }
 
       /* If we are not scanning, then we have to stop here. */
       if (!scan)
         {
           g_warning ("Could not process command: %s", cmd);
-          g_ptr_array_remove_index (self->pending_commands, 0);
           break;
         }
 
       if (g_str_has_prefix (cmd, SCAN_CMD_PREFIX))
         {
-          char *res = g_strdup (cmd + strlen (SCAN_CMD_PREFIX));
+          if (scan_id)
+            *scan_id = g_strdup (cmd + strlen (SCAN_CMD_PREFIX));
 
-          g_ptr_array_remove_index (self->pending_commands, 0);
-          return res;
+          return TRUE;
         }
       else if (g_str_has_prefix (cmd, RETRY_CMD_PREFIX))
         {
           g_propagate_error (error,
                              fpi_device_retry_new (g_ascii_strtoull (cmd + strlen (RETRY_CMD_PREFIX), NULL, 10)));
 
-          g_ptr_array_remove_index (self->pending_commands, 0);
-          return NULL;
+          return TRUE;
         }
       else if (g_str_has_prefix (cmd, FINGER_CMD_PREFIX))
         {
@@ -199,28 +241,32 @@ process_cmds (FpDeviceVirtualDevice * self,
                                                    finger_present ? FP_FINGER_STATUS_PRESENT : FP_FINGER_STATUS_NONE,
                                                    finger_present ? FP_FINGER_STATUS_NONE : FP_FINGER_STATUS_PRESENT);
 
-          g_ptr_array_remove_index (self->pending_commands, 0);
           continue;
         }
       else
         {
           g_warning ("Could not process command: %s", cmd);
-          g_ptr_array_remove_index (self->pending_commands, 0);
         }
     }
 
-  /* No commands left, throw a timeout error. */
-  g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND, "No commands left that can be run!");
-  return NULL;
+  if (self->ignore_wait)
+    return TRUE;
+
+  g_object_get (self, "removed", &removed, NULL);
+
+  g_assert (self->wait_command_id == 0);
+  if (!scan || removed)
+    self->wait_command_id = g_timeout_add (500, wait_for_command_timeout, self);
+  return FALSE;
 }
 
 static void
 write_key_to_listener (void *key, void *val, void *user_data)
 {
-  FpDeviceVirtualListener *listener = FP_DEVICE_VIRTUAL_LISTENER (user_data);
+  FpiDeviceVirtualListener *listener = FPI_DEVICE_VIRTUAL_LISTENER (user_data);
 
-  if (!fp_device_virtual_listener_write_sync (listener, key, strlen (key), NULL) ||
-      !fp_device_virtual_listener_write_sync (listener, "\n", 1, NULL))
+  if (!fpi_device_virtual_listener_write_sync (listener, key, strlen (key), NULL) ||
+      !fpi_device_virtual_listener_write_sync (listener, "\n", 1, NULL))
     g_warning ("Error writing reply to LIST command");
 }
 
@@ -230,11 +276,11 @@ recv_instruction_cb (GObject      *source_object,
                      gpointer      user_data)
 {
   g_autoptr(GError) error = NULL;
-  FpDeviceVirtualListener *listener = FP_DEVICE_VIRTUAL_LISTENER (source_object);
+  FpiDeviceVirtualListener *listener = FPI_DEVICE_VIRTUAL_LISTENER (source_object);
   gsize bytes;
 
-  bytes = fp_device_virtual_listener_read_finish (listener, res, &error);
-  fp_dbg ("Got instructions of length %ld", bytes);
+  bytes = fpi_device_virtual_listener_read_finish (listener, res, &error);
+  fp_dbg ("Got instructions of length %" G_GSIZE_FORMAT, bytes);
 
   if (error)
     {
@@ -263,6 +309,7 @@ recv_instruction_cb (GObject      *source_object,
       else if (g_str_has_prefix (cmd, UNPLUG_CMD))
         {
           fpi_device_remove (FP_DEVICE (self));
+          maybe_continue_current_action (self);
         }
       else if (g_str_has_prefix (cmd, SET_ENROLL_STAGES_PREFIX))
         {
@@ -306,23 +353,23 @@ recv_instruction_cb (GObject      *source_object,
         }
     }
 
-  fp_device_virtual_listener_connection_close (listener);
+  fpi_device_virtual_listener_connection_close (listener);
 }
 
 static void
 recv_instruction (FpDeviceVirtualDevice *self)
 {
-  fp_device_virtual_listener_read (self->listener,
-                                   FALSE,
-                                   self->recv_buf,
-                                   sizeof (self->recv_buf),
-                                   recv_instruction_cb,
-                                   self);
+  fpi_device_virtual_listener_read (self->listener,
+                                    FALSE,
+                                    self->recv_buf,
+                                    sizeof (self->recv_buf),
+                                    recv_instruction_cb,
+                                    self);
 }
 
 static void
-on_listener_connected (FpDeviceVirtualListener *listener,
-                       gpointer                 user_data)
+on_listener_connected (FpiDeviceVirtualListener *listener,
+                       gpointer                  user_data)
 {
   FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (user_data);
 
@@ -334,19 +381,22 @@ dev_init (FpDevice *dev)
 {
   g_autoptr(GError) error = NULL;
   g_autoptr(GCancellable) cancellable = NULL;
-  g_autoptr(FpDeviceVirtualListener) listener = NULL;
+  g_autoptr(FpiDeviceVirtualListener) listener = NULL;
   FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (dev);
 
   G_DEBUG_HERE ();
 
-  process_cmds (self, FALSE, &error);
-  if (error && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+  self->ignore_wait = TRUE;
+  if (!process_cmds (self, FALSE, NULL, &error))
     {
-      fpi_device_open_complete (dev, g_steal_pointer (&error));
+      self->ignore_wait = FALSE;
       return;
     }
-  else if (self->sleep_timeout_id)
+  self->ignore_wait = FALSE;
+
+  if (error)
     {
+      fpi_device_open_complete (dev, g_steal_pointer (&error));
       return;
     }
   else if (self->listener)
@@ -355,15 +405,15 @@ dev_init (FpDevice *dev)
       return;
     }
 
-  listener = fp_device_virtual_listener_new ();
+  listener = fpi_device_virtual_listener_new ();
   cancellable = g_cancellable_new ();
 
-  if (!fp_device_virtual_listener_start (listener,
-                                         fpi_device_get_virtual_env (FP_DEVICE (self)),
-                                         cancellable,
-                                         on_listener_connected,
-                                         self,
-                                         &error))
+  if (!fpi_device_virtual_listener_start (listener,
+                                          fpi_device_get_virtual_env (FP_DEVICE (self)),
+                                          cancellable,
+                                          on_listener_connected,
+                                          self,
+                                          &error))
     {
       fpi_device_open_complete (dev, g_steal_pointer (&error));
       return;
@@ -375,65 +425,21 @@ dev_init (FpDevice *dev)
   fpi_device_open_complete (dev, NULL);
 }
 
-static gboolean
-wait_for_command_timeout (gpointer data)
-{
-  FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (data);
-  GError *error = NULL;
-
-  self->wait_command_id = 0;
-
-  switch (fpi_device_get_current_action (FP_DEVICE (self)))
-    {
-    case FPI_DEVICE_ACTION_LIST:
-    case FPI_DEVICE_ACTION_DELETE:
-      self->ignore_wait = TRUE;
-      maybe_continue_current_action (self);
-      self->ignore_wait = FALSE;
-      return FALSE;
-
-    default:
-      break;
-    }
-
-  error = g_error_new (G_IO_ERROR, G_IO_ERROR_TIMED_OUT, "No commands arrived in time to run!");
-  fpi_device_action_error (FP_DEVICE (self), error);
-
-  return FALSE;
-}
-
 gboolean
-should_wait_for_command (FpDeviceVirtualDevice *self,
-                         GError                *error)
-{
-  if (!error && self->sleep_timeout_id)
-    return TRUE;
-
-  if (self->ignore_wait)
-    return FALSE;
-
-  if (!g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
-    return FALSE;
-
-  if (self->wait_command_id)
-    return FALSE;
-
-  self->wait_command_id = g_timeout_add (500, wait_for_command_timeout, self);
-  return TRUE;
-}
-
-char *
 start_scan_command (FpDeviceVirtualDevice *self,
+                    char                 **scan_id,
                     GError               **error)
 {
   g_autoptr(GError) local_error = NULL;
-  g_autofree char *scan_id = NULL;
+  gboolean cont;
 
   if (fp_device_get_finger_status (FP_DEVICE (self)) == FP_FINGER_STATUS_NONE)
     self->injected_synthetic_cmd = FALSE;
 
-  scan_id = process_cmds (self, TRUE, &local_error);
-
+  cont = process_cmds (self, TRUE, scan_id, &local_error);
+  /* We report finger needed if we are waiting for instructions
+   * (i.e. we did not get an explicit SLEEP command).
+   */
   if (!self->sleep_timeout_id)
     {
       fpi_device_report_finger_status_changes (FP_DEVICE (self),
@@ -441,14 +447,13 @@ start_scan_command (FpDeviceVirtualDevice *self,
                                                FP_FINGER_STATUS_NONE);
     }
 
-  if (should_wait_for_command (self, local_error))
-    {
-      g_assert (!scan_id);
+  if (!cont)
+    return FALSE;
 
-      g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_PENDING,
-                           "Still waiting for command");
-      return NULL;
-    }
+  /* Scan or error*/
+  fpi_device_report_finger_status_changes (FP_DEVICE (self),
+                                           FP_FINGER_STATUS_NEEDED,
+                                           FP_FINGER_STATUS_NONE);
 
   if (local_error)
     g_propagate_error (error, g_steal_pointer (&local_error));
@@ -457,7 +462,7 @@ start_scan_command (FpDeviceVirtualDevice *self,
                                              FP_FINGER_STATUS_PRESENT,
                                              FP_FINGER_STATUS_NONE);
 
-  return g_steal_pointer (&scan_id);
+  return TRUE;
 }
 
 gboolean
@@ -478,7 +483,7 @@ should_wait_to_sleep (FpDeviceVirtualDevice *self,
   if (g_str_has_prefix (cmd, SLEEP_CMD_PREFIX))
     {
       g_autoptr(GError) local_error = NULL;
-      g_free (process_cmds (self, FALSE, &local_error));
+      process_cmds (self, FALSE, NULL, &local_error);
 
       if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
         return FALSE;
@@ -516,14 +521,13 @@ dev_verify (FpDevice *dev)
   FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (dev);
   g_autofree char *scan_id = NULL;
 
-  scan_id = start_scan_command (self, &error);
-  if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_PENDING))
+  if (!start_scan_command (self, &scan_id, &error))
     return;
 
   if (scan_id)
     {
+      g_autoptr(FpPrint) new_scan = NULL;
       GVariant *data = NULL;
-      FpPrint *new_scan;
       FpPrint *print;
       gboolean success;
 
@@ -539,7 +543,7 @@ dev_verify (FpDevice *dev)
 
       if (self->prints_storage && !g_hash_table_contains (self->prints_storage, scan_id))
         {
-          error = fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND);
+          g_clear_object (&new_scan);
           success = FALSE;
         }
       else
@@ -552,7 +556,7 @@ dev_verify (FpDevice *dev)
           self->match_reported = TRUE;
           fpi_device_verify_report (dev,
                                     success ? FPI_MATCH_SUCCESS : FPI_MATCH_FAIL,
-                                    new_scan,
+                                    g_steal_pointer (&new_scan),
                                     NULL);
         }
     }
@@ -583,8 +587,7 @@ dev_enroll (FpDevice *dev)
   FpPrint *print = NULL;
   g_autofree char *id = NULL;
 
-  id = start_scan_command (self, &error);
-  if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_PENDING))
+  if (!start_scan_command (self, &id, &error))
     return;
 
   fpi_device_get_enroll_data (dev, &print);
@@ -696,6 +699,7 @@ dev_cancel (FpDevice *dev)
 
   g_debug ("Got cancellation!");
   g_clear_handle_id (&self->sleep_timeout_id, g_source_remove);
+  g_clear_handle_id (&self->wait_command_id, g_source_remove);
 
   maybe_continue_current_action (self);
 }
@@ -714,19 +718,19 @@ dev_deinit (FpDevice *dev)
   g_autoptr(GError) error = NULL;
   FpDeviceVirtualDevice *self = FP_DEVICE_VIRTUAL_DEVICE (dev);
 
-  process_cmds (self, FALSE, &error);
-  if (error && !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_NOT_FOUND))
+  self->ignore_wait = TRUE;
+  if (!process_cmds (self, FALSE, NULL, &error))
+    {
+      self->ignore_wait = FALSE;
+      return;
+    }
+  self->ignore_wait = FALSE;
+
+  if (error)
     {
       fpi_device_close_complete (dev, g_steal_pointer (&error));
       return;
     }
-  else if (self->sleep_timeout_id)
-    {
-      return;
-    }
-
-  g_clear_handle_id (&self->wait_command_id, g_source_remove);
-  g_clear_handle_id (&self->sleep_timeout_id, g_source_remove);
 
   if (!self->keep_alive)
     stop_listener (self);
@@ -776,4 +780,6 @@ fpi_device_virtual_device_class_init (FpDeviceVirtualDeviceClass *klass)
   dev_class->verify = dev_verify;
   dev_class->enroll = dev_enroll;
   dev_class->cancel = dev_cancel;
+
+  fpi_device_class_auto_initialize_features (dev_class);
 }

libfprint/drivers/virtual-image.c

@@ -36,14 +36,14 @@
 
 struct _FpDeviceVirtualImage
 {
-  FpImageDevice            parent;
+  FpImageDevice             parent;
 
-  FpDeviceVirtualListener *listener;
-  GCancellable            *cancellable;
+  FpiDeviceVirtualListener *listener;
+  GCancellable             *cancellable;
 
-  gboolean                 automatic_finger;
-  FpImage                 *recv_img;
-  gint                     recv_img_hdr[2];
+  gboolean                  automatic_finger;
+  FpImage                  *recv_img;
+  gint                      recv_img_hdr[2];
 };
 
 G_DECLARE_FINAL_TYPE (FpDeviceVirtualImage, fpi_device_virtual_image, FPI, DEVICE_VIRTUAL_IMAGE, FpImageDevice)
@@ -57,12 +57,12 @@ recv_image_img_recv_cb (GObject      *source_object,
                         gpointer      user_data)
 {
   g_autoptr(GError) error = NULL;
-  FpDeviceVirtualListener *listener = FP_DEVICE_VIRTUAL_LISTENER (source_object);
+  FpiDeviceVirtualListener *listener = FPI_DEVICE_VIRTUAL_LISTENER (source_object);
   FpDeviceVirtualImage *self;
   FpImageDevice *device;
   gsize bytes;
 
-  bytes = fp_device_virtual_listener_read_finish (listener, res, &error);
+  bytes = fpi_device_virtual_listener_read_finish (listener, res, &error);
 
   if (!bytes || g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) ||
       g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CONNECTION_CLOSED))
@@ -88,10 +88,10 @@ recv_image_hdr_recv_cb (GObject      *source_object,
 {
   g_autoptr(GError) error = NULL;
   FpDeviceVirtualImage *self;
-  FpDeviceVirtualListener *listener = FP_DEVICE_VIRTUAL_LISTENER (source_object);
+  FpiDeviceVirtualListener *listener = FPI_DEVICE_VIRTUAL_LISTENER (source_object);
   gsize bytes;
 
-  bytes = fp_device_virtual_listener_read_finish (listener, res, &error);
+  bytes = fpi_device_virtual_listener_read_finish (listener, res, &error);
 
   if (error)
     {
@@ -111,7 +111,7 @@ recv_image_hdr_recv_cb (GObject      *source_object,
   if (self->recv_img_hdr[0] > 5000 || self->recv_img_hdr[1] > 5000)
     {
       g_warning ("Image header suggests an unrealistically large image, disconnecting client.");
-      fp_device_virtual_listener_connection_close (listener);
+      fpi_device_virtual_listener_connection_close (listener);
     }
 
   if (self->recv_img_hdr[0] < 0 || self->recv_img_hdr[1] < 0)
@@ -147,7 +147,7 @@ recv_image_hdr_recv_cb (GObject      *source_object,
 
         default:
           /* disconnect client, it didn't play fair */
-          fp_device_virtual_listener_connection_close (listener);
+          fpi_device_virtual_listener_connection_close (listener);
         }
 
       /* And, listen for more images from the same client. */
@@ -157,28 +157,28 @@ recv_image_hdr_recv_cb (GObject      *source_object,
 
   self->recv_img = fp_image_new (self->recv_img_hdr[0], self->recv_img_hdr[1]);
   g_debug ("image data: %p", self->recv_img->data);
-  fp_device_virtual_listener_read (listener,
-                                   TRUE,
-                                   (guint8 *) self->recv_img->data,
-                                   self->recv_img->width * self->recv_img->height,
-                                   recv_image_img_recv_cb,
-                                   self);
+  fpi_device_virtual_listener_read (listener,
+                                    TRUE,
+                                    (guint8 *) self->recv_img->data,
+                                    self->recv_img->width * self->recv_img->height,
+                                    recv_image_img_recv_cb,
+                                    self);
 }
 
 static void
 recv_image (FpDeviceVirtualImage *self)
 {
-  fp_device_virtual_listener_read (self->listener,
-                                   TRUE,
-                                   self->recv_img_hdr,
-                                   sizeof (self->recv_img_hdr),
-                                   recv_image_hdr_recv_cb,
-                                   self);
+  fpi_device_virtual_listener_read (self->listener,
+                                    TRUE,
+                                    self->recv_img_hdr,
+                                    sizeof (self->recv_img_hdr),
+                                    recv_image_hdr_recv_cb,
+                                    self);
 }
 
 static void
-on_listener_connected (FpDeviceVirtualListener *listener,
-                       gpointer                 user_data)
+on_listener_connected (FpiDeviceVirtualListener *listener,
+                       gpointer                  user_data)
 {
   FpDeviceVirtualImage *self = FPI_DEVICE_VIRTUAL_IMAGE (user_data);
   FpiImageDeviceState state;
@@ -188,32 +188,42 @@ on_listener_connected (FpDeviceVirtualListener *listener,
   g_object_get (self,
                 "fpi-image-device-state", &state,
                 NULL);
-  /* Only read if we are in AWAIT_FINGER_* or CAPTURE states */
-  if (state <= FPI_IMAGE_DEVICE_STATE_DEACTIVATING)
-    return;
 
-  recv_image (self);
+  switch (state)
+    {
+    case FPI_IMAGE_DEVICE_STATE_IDLE:
+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_ON:
+    case FPI_IMAGE_DEVICE_STATE_CAPTURE:
+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
+      recv_image (self);
+
+    case FPI_IMAGE_DEVICE_STATE_INACTIVE:
+    case FPI_IMAGE_DEVICE_STATE_ACTIVATING:
+    case FPI_IMAGE_DEVICE_STATE_DEACTIVATING:
+    default:
+      break;
+    }
 }
 
 static void
 dev_init (FpImageDevice *dev)
 {
   g_autoptr(GError) error = NULL;
-  g_autoptr(FpDeviceVirtualListener) listener = NULL;
+  g_autoptr(FpiDeviceVirtualListener) listener = NULL;
   g_autoptr(GCancellable) cancellable = NULL;
   FpDeviceVirtualImage *self = FPI_DEVICE_VIRTUAL_IMAGE (dev);
 
   G_DEBUG_HERE ();
 
-  listener = fp_device_virtual_listener_new ();
+  listener = fpi_device_virtual_listener_new ();
   cancellable = g_cancellable_new ();
 
-  if (!fp_device_virtual_listener_start (listener,
-                                         fpi_device_get_virtual_env (FP_DEVICE (self)),
-                                         cancellable,
-                                         on_listener_connected,
-                                         self,
-                                         &error))
+  if (!fpi_device_virtual_listener_start (listener,
+                                          fpi_device_get_virtual_env (FP_DEVICE (self)),
+                                          cancellable,
+                                          on_listener_connected,
+                                          self,
+                                          &error))
     {
       fpi_image_device_open_complete (dev, g_steal_pointer (&error));
       return;

libfprint/drivers_api.h

@@ -29,4 +29,5 @@
 #include "fpi-log.h"
 #include "fpi-print.h"
 #include "fpi-usb-transfer.h"
+#include "fpi-spi-transfer.h"
 #include "fpi-ssm.h"

libfprint/fp-context.c

@@ -23,6 +23,13 @@
 #include "fpi-context.h"
 #include "fpi-device.h"
 #include <gusb.h>
+#include <stdio.h>
+
+#include <config.h>
+
+#ifdef HAVE_UDEV
+#include <gudev/gudev.h>
+#endif
 
 /**
  * SECTION: fp-context
@@ -41,6 +48,8 @@ typedef struct
   GUsbContext  *usb_ctx;
   GCancellable *cancellable;
 
+  GSList       *sources;
+
   gint          pending_devices;
   gboolean      enumerated;
 
@@ -90,6 +99,7 @@ typedef struct
 {
   FpContext *context;
   FpDevice  *device;
+  GSource   *source;
 } RemoveDeviceData;
 
 static gboolean
@@ -103,21 +113,36 @@ remove_device_idle_cb (RemoveDeviceData *data)
   g_signal_emit (data->context, signals[DEVICE_REMOVED_SIGNAL], 0, data->device);
   g_ptr_array_remove_index_fast (priv->devices, idx);
 
-  g_free (data);
-
   return G_SOURCE_REMOVE;
 }
 
+static void
+remove_device_data_free (RemoveDeviceData *data)
+{
+  FpContextPrivate *priv = fp_context_get_instance_private (data->context);
+
+  priv->sources = g_slist_remove (priv->sources, data->source);
+  g_free (data);
+}
+
 static void
 remove_device (FpContext *context, FpDevice *device)
 {
+  g_autoptr(GSource) source = NULL;
+  FpContextPrivate *priv = fp_context_get_instance_private (context);
   RemoveDeviceData *data;
 
   data = g_new (RemoveDeviceData, 1);
   data->context = context;
   data->device = device;
 
-  g_idle_add ((GSourceFunc) remove_device_idle_cb, data);
+  source = data->source = g_idle_source_new ();
+  g_source_set_callback (source,
+                         G_SOURCE_FUNC (remove_device_idle_cb), data,
+                         (GDestroyNotify) remove_device_data_free);
+  g_source_attach (source, g_main_context_get_thread_default ());
+
+  priv->sources = g_slist_prepend (priv->sources, source);
 }
 
 static void
@@ -135,9 +160,16 @@ device_removed_cb (FpContext *context, FpDevice *device)
 
   /* Wait for device close if the device is currently still open. */
   if (open)
-    g_signal_connect_swapped (device, "notify::open", (GCallback) device_remove_on_notify_open_cb, context);
+    {
+      g_signal_connect_object (device, "notify::open",
+                               (GCallback) device_remove_on_notify_open_cb,
+                               context,
+                               G_CONNECT_SWAPPED);
+    }
   else
-    remove_device (context, device);
+    {
+      remove_device (context, device);
+    }
 }
 
 static void
@@ -165,7 +197,10 @@ async_device_init_done_cb (GObject *source_object, GAsyncResult *res, gpointer u
 
   g_ptr_array_add (priv->devices, device);
 
-  g_signal_connect_swapped (device, "removed", (GCallback) device_removed_cb, context);
+  g_signal_connect_object (device, "removed",
+                           (GCallback) device_removed_cb,
+                           context,
+                           G_CONNECT_SWAPPED);
 
   g_signal_emit (context, signals[DEVICE_ADDED_SIGNAL], 0, device);
 }
@@ -256,11 +291,12 @@ fp_context_finalize (GObject *object)
   FpContext *self = (FpContext *) object;
   FpContextPrivate *priv = fp_context_get_instance_private (self);
 
-  g_clear_pointer (&priv->devices, g_ptr_array_unref);
-
   g_cancellable_cancel (priv->cancellable);
   g_clear_object (&priv->cancellable);
   g_clear_pointer (&priv->drivers, g_array_unref);
+  g_clear_pointer (&priv->devices, g_ptr_array_unref);
+
+  g_slist_free_full (g_steal_pointer (&priv->sources), (GDestroyNotify) g_source_destroy);
 
   if (priv->usb_ctx)
     g_object_run_dispose (G_OBJECT (priv->usb_ctx));
@@ -324,6 +360,8 @@ fp_context_init (FpContext *self)
   FpContextPrivate *priv = fp_context_get_instance_private (self);
   guint i;
 
+  g_debug ("Initializing FpContext (libfprint version " LIBFPRINT_VERSION ")");
+
   priv->drivers = fpi_get_driver_types ();
 
   if (get_drivers_whitelist_env ())
@@ -389,6 +427,7 @@ void
 fp_context_enumerate (FpContext *context)
 {
   FpContextPrivate *priv = fp_context_get_instance_private (context);
+  gboolean dispatched;
   gint i;
 
   g_return_if_fail (FP_IS_CONTEXT (context));
@@ -434,8 +473,112 @@ fp_context_enumerate (FpContext *context)
         }
     }
 
-  while (priv->pending_devices)
-    g_main_context_iteration (NULL, TRUE);
+
+#ifdef HAVE_UDEV
+  {
+    g_autoptr(GUdevClient) udev_client = g_udev_client_new (NULL);
+
+    /* This uses a very simple algorithm to allocate devices to drivers and assumes that no two drivers will want the same device. Future improvements
+     * could add a usb_discover style udev_discover that returns a score, however for internal devices the potential overlap should be very low between
+     * separate drivers.
+     */
+
+    g_autoptr(GList) spidev_devices = g_udev_client_query_by_subsystem (udev_client, "spidev");
+    g_autoptr(GList) hidraw_devices = g_udev_client_query_by_subsystem (udev_client, "hidraw");
+
+    /* for each potential driver, try to match all requested resources. */
+    for (i = 0; i < priv->drivers->len; i++)
+      {
+        GType driver = g_array_index (priv->drivers, GType, i);
+        g_autoptr(FpDeviceClass) cls = g_type_class_ref (driver);
+        const FpIdEntry *entry;
+
+        if (cls->type != FP_DEVICE_TYPE_UDEV)
+          continue;
+
+        for (entry = cls->id_table; entry->udev_types; entry++)
+          {
+            GList *matched_spidev = NULL, *matched_hidraw = NULL;
+
+            if (entry->udev_types & FPI_DEVICE_UDEV_SUBTYPE_SPIDEV)
+              {
+                for (matched_spidev = spidev_devices; matched_spidev; matched_spidev = matched_spidev->next)
+                  {
+                    const gchar * sysfs = g_udev_device_get_sysfs_path (matched_spidev->data);
+                    if (!sysfs)
+                      continue;
+                    if (strstr (sysfs, entry->spi_acpi_id))
+                      break;
+                  }
+                /* If match was not found exit */
+                if (matched_spidev == NULL)
+                  continue;
+              }
+            if (entry->udev_types & FPI_DEVICE_UDEV_SUBTYPE_HIDRAW)
+              {
+                for (matched_hidraw = hidraw_devices; matched_hidraw; matched_hidraw = matched_hidraw->next)
+                  {
+                    /* Find the parent HID node, and check the vid/pid from its HID_ID property */
+                    g_autoptr(GUdevDevice) parent = g_udev_device_get_parent_with_subsystem (matched_hidraw->data, "hid", NULL);
+                    const gchar * hid_id = g_udev_device_get_property (parent, "HID_ID");
+                    guint32 vendor, product;
+
+                    if (!parent || !hid_id)
+                      continue;
+
+                    if (sscanf (hid_id, "%*X:%X:%X", &vendor, &product) != 2)
+                      continue;
+
+                    if (vendor == entry->hid_id.vid && product == entry->hid_id.pid)
+                      break;
+                  }
+                /* If match was not found exit */
+                if (matched_hidraw == NULL)
+                  continue;
+              }
+            priv->pending_devices++;
+            g_async_initable_new_async (driver,
+                                        G_PRIORITY_LOW,
+                                        priv->cancellable,
+                                        async_device_init_done_cb,
+                                        context,
+                                        "fpi-driver-data", entry->driver_data,
+                                        "fpi-udev-data-spidev", (matched_spidev ? g_udev_device_get_device_file (matched_spidev->data) : NULL),
+                                        "fpi-udev-data-hidraw", (matched_hidraw ? g_udev_device_get_device_file (matched_hidraw->data) : NULL),
+                                        NULL);
+            /* remove entries from list to avoid conflicts */
+            if (matched_spidev)
+              {
+                g_object_unref (matched_spidev->data);
+                spidev_devices = g_list_delete_link (spidev_devices, matched_spidev);
+              }
+            if (matched_hidraw)
+              {
+                g_object_unref (matched_hidraw->data);
+                hidraw_devices = g_list_delete_link (hidraw_devices, matched_hidraw);
+              }
+          }
+      }
+
+    /* free all unused elemnts in both lists */
+    g_list_foreach (spidev_devices, (GFunc) g_object_unref, NULL);
+    g_list_foreach (hidraw_devices, (GFunc) g_object_unref, NULL);
+  }
+#endif
+
+  /* Iterate until 1. we have no pending devices, and 2. the mainloop is idle
+   * This takes care of processing hotplug events that happened during
+   * enumeration.
+   * This is important due to USB `persist` being turned off. At resume time,
+   * devices will disappear and immediately re-appear. In this situation,
+   * enumerate could first see the old state with a removed device resulting
+   * in it to not be discovered.
+   * As a hotplug event is seemingly emitted by the kernel immediately, we can
+   * simply make sure to process all events before returning from enumerate.
+   */
+  dispatched = TRUE;
+  while (priv->pending_devices || dispatched)
+    dispatched = g_main_context_iteration (NULL, !!priv->pending_devices);
 }
 
 /**
@@ -444,7 +587,7 @@ fp_context_enumerate (FpContext *context)
  *
  * Get all devices. fp_context_enumerate() will be called as needed.
  *
- * Returns: (transfer none) (element-type FpDevice): a new #GPtrArray of #GUsbDevice's.
+ * Returns: (transfer none) (element-type FpDevice): a new #GPtrArray of #FpDevice's.
  */
 GPtrArray *
 fp_context_get_devices (FpContext *context)

libfprint/fp-device-private.h

@@ -22,36 +22,83 @@
 
 #include "fpi-device.h"
 
+/* Chosen so that if we turn on after WARM -> COLD, it takes exactly one time
+ * constant to go from COLD -> HOT.
+ *   TEMP_COLD_THRESH = 1 / (e + 1)
+ */
+#define TEMP_COLD_THRESH (0.26894142136999512075)
+#define TEMP_WARM_HOT_THRESH (1.0 - TEMP_COLD_THRESH)
+#define TEMP_HOT_WARM_THRESH (0.5)
+
+/* Delay updates by 100ms to avoid hitting the border exactly */
+#define TEMP_DELAY_SECONDS 0.1
+
+/* Hopefully 3min is long enough to not get in the way, while also not
+ * properly overheating any devices.
+ */
+#define DEFAULT_TEMP_HOT_SECONDS (3 * 60)
+#define DEFAULT_TEMP_COLD_SECONDS (9 * 60)
+
 typedef struct
 {
   FpDeviceType type;
 
   GUsbDevice  *usb_device;
   const gchar *virtual_env;
+  struct
+  {
+    gchar *spidev_path;
+    gchar *hidraw_path;
+  } udev_data;
 
-  gboolean     is_removed;
-  gboolean     is_open;
+  gboolean        is_removed;
+  gboolean        is_open;
+  gboolean        is_suspended;
 
-  gchar       *device_id;
-  gchar       *device_name;
-  FpScanType   scan_type;
+  gchar          *device_id;
+  gchar          *device_name;
+  FpScanType      scan_type;
+  FpDeviceFeature features;
 
-  guint64      driver_data;
+  guint64         driver_data;
 
-  gint         nr_enroll_stages;
-  GSList      *sources;
+  gint            nr_enroll_stages;
+  GSList         *sources;
 
   /* We always make sure that only one task is run at a time. */
   FpiDeviceAction     current_action;
   GTask              *current_task;
+  GError             *current_cancellation_reason;
   GAsyncReadyCallback current_user_cb;
+  GCancellable       *current_cancellable;
   gulong              current_cancellable_id;
+  gulong              current_task_cancellable_id;
   GSource            *current_idle_cancel_source;
   GSource            *current_task_idle_return_source;
 
   /* State for tasks */
   gboolean            wait_for_finger;
   FpFingerStatusFlags finger_status;
+
+  /* Driver critical sections */
+  guint    critical_section;
+  GSource *critical_section_flush_source;
+  gboolean cancel_queued;
+  gboolean suspend_queued;
+  gboolean resume_queued;
+
+  /* Suspend/resume tasks */
+  GTask  *suspend_resume_task;
+  GError *suspend_error;
+
+  /* Device temperature model information and state */
+  GSource      *temp_timeout;
+  FpTemperature temp_current;
+  gint32        temp_hot_seconds;
+  gint32        temp_cold_seconds;
+  gint64        temp_last_update;
+  gboolean      temp_last_active;
+  gdouble       temp_current_ratio;
 } FpDevicePrivate;
 
 
@@ -82,3 +129,11 @@ typedef struct
 } FpMatchData;
 
 void match_data_free (FpMatchData *match_data);
+
+void fpi_device_suspend (FpDevice *device);
+void fpi_device_resume (FpDevice *device);
+
+void fpi_device_configure_wakeup (FpDevice *device,
+                                  gboolean  enabled);
+void fpi_device_update_temp (FpDevice *device,
+                             gboolean  is_active);

libfprint/fp-device.h

@@ -38,13 +38,43 @@ G_DECLARE_DERIVABLE_TYPE (FpDevice, fp_device, FP, DEVICE, GObject)
 /**
  * FpDeviceType:
  * @FP_DEVICE_TYPE_VIRTUAL: The device is a virtual device
+ * @FP_DEVICE_TYPE_UDEV: The device is a udev device
  * @FP_DEVICE_TYPE_USB: The device is a USB device
  */
 typedef enum {
   FP_DEVICE_TYPE_VIRTUAL,
+  FP_DEVICE_TYPE_UDEV,
   FP_DEVICE_TYPE_USB,
 } FpDeviceType;
 
+/**
+ * FpDeviceFeature:
+ * @FP_DEVICE_FEATURE_NONE: Device does not support any feature
+ * @FP_DEVICE_FEATURE_CAPTURE: Supports image capture
+ * @FP_DEVICE_FEATURE_VERIFY: Supports finger verification
+ * @FP_DEVICE_FEATURE_IDENTIFY: Supports finger identification
+ * @FP_DEVICE_FEATURE_STORAGE: Device has a persistent storage
+ * @FP_DEVICE_FEATURE_STORAGE_LIST: Supports listing the storage templates
+ * @FP_DEVICE_FEATURE_STORAGE_DELETE: Supports deleting stored templates
+ * @FP_DEVICE_FEATURE_STORAGE_CLEAR: Supports clearing the whole storage
+ * @FP_DEVICE_FEATURE_DUPLICATES_CHECK: Natively supports duplicates detection
+ * @FP_DEVICE_FEATURE_ALWAYS_ON: Whether the device can run continuously
+ * @FP_DEVICE_FEATURE_UPDATE_PRINT: Supports updating an existing print record using new scans
+ */
+typedef enum /*< flags >*/ {
+  FP_DEVICE_FEATURE_NONE = 0,
+  FP_DEVICE_FEATURE_CAPTURE = 1 << 0,
+  FP_DEVICE_FEATURE_IDENTIFY = 1 << 1,
+  FP_DEVICE_FEATURE_VERIFY = 1 << 2,
+  FP_DEVICE_FEATURE_STORAGE = 1 << 3,
+  FP_DEVICE_FEATURE_STORAGE_LIST = 1 << 4,
+  FP_DEVICE_FEATURE_STORAGE_DELETE = 1 << 5,
+  FP_DEVICE_FEATURE_STORAGE_CLEAR = 1 << 6,
+  FP_DEVICE_FEATURE_DUPLICATES_CHECK = 1 << 7,
+  FP_DEVICE_FEATURE_ALWAYS_ON = 1 << 8,
+  FP_DEVICE_FEATURE_UPDATE_PRINT = 1 << 9,
+} FpDeviceFeature;
+
 /**
  * FpScanType:
  * @FP_SCAN_TYPE_SWIPE: Sensor requires swiping the finger.
@@ -55,6 +85,23 @@ typedef enum {
   FP_SCAN_TYPE_PRESS,
 } FpScanType;
 
+/**
+ * FpTemperature:
+ * @FP_TEMPERATURE_COLD: Sensor is considered cold.
+ * @FP_TEMPERATURE_WARM: Sensor is warm, usage time may be limited.
+ * @FP_TEMPERATURE_HOT: Sensor is hot and cannot be used.
+ *
+ * When a device is created, it is assumed to be cold. Applications such as
+ * fprintd may want to ensure all devices on the system are cold before
+ * shutting down in order to ensure that the cool-off period is not violated
+ * because the internal libfprint state about the device is lost.
+ */
+typedef enum {
+  FP_TEMPERATURE_COLD,
+  FP_TEMPERATURE_WARM,
+  FP_TEMPERATURE_HOT,
+} FpTemperature;
+
 /**
  * FpDeviceRetry:
  * @FP_DEVICE_RETRY_GENERAL: The scan did not succeed due to poor scan quality
@@ -92,6 +139,7 @@ typedef enum {
  * @FP_DEVICE_ERROR_DATA_FULL: No space on device available for operation
  * @FP_DEVICE_ERROR_DATA_DUPLICATE: Enrolling template duplicates storaged templates
  * @FP_DEVICE_ERROR_REMOVED: The device has been removed.
+ * @FP_DEVICE_ERROR_TOO_HOT: The device might be getting too hot
  *
  * Error codes for device operations. More specific errors from other domains
  * such as #G_IO_ERROR or #G_USB_DEVICE_ERROR may also be reported.
@@ -109,6 +157,7 @@ typedef enum {
   FP_DEVICE_ERROR_DATA_DUPLICATE,
   /* Leave some room to add more DATA related errors */
   FP_DEVICE_ERROR_REMOVED = 0x100,
+  FP_DEVICE_ERROR_TOO_HOT,
 } FpDeviceError;
 
 GQuark fp_device_retry_quark (void);
@@ -175,10 +224,11 @@ gboolean     fp_device_is_open (FpDevice *device);
 FpScanType   fp_device_get_scan_type (FpDevice *device);
 FpFingerStatusFlags fp_device_get_finger_status (FpDevice *device);
 gint         fp_device_get_nr_enroll_stages (FpDevice *device);
+FpTemperature fp_device_get_temperature (FpDevice *device);
 
-gboolean     fp_device_supports_identify (FpDevice *device);
-gboolean     fp_device_supports_capture (FpDevice *device);
-gboolean     fp_device_has_storage (FpDevice *device);
+FpDeviceFeature     fp_device_get_features (FpDevice *device);
+gboolean            fp_device_has_feature (FpDevice       *device,
+                                           FpDeviceFeature feature);
 
 /* Opening the device */
 void fp_device_open (FpDevice           *device,
@@ -191,6 +241,16 @@ void fp_device_close (FpDevice           *device,
                       GAsyncReadyCallback callback,
                       gpointer            user_data);
 
+void fp_device_suspend (FpDevice           *device,
+                        GCancellable       *cancellable,
+                        GAsyncReadyCallback callback,
+                        gpointer            user_data);
+
+void fp_device_resume (FpDevice           *device,
+                       GCancellable       *cancellable,
+                       GAsyncReadyCallback callback,
+                       gpointer            user_data);
+
 void fp_device_enroll (FpDevice           *device,
                        FpPrint            *template_print,
                        GCancellable       *cancellable,
@@ -235,12 +295,23 @@ void fp_device_list_prints (FpDevice           *device,
                             GAsyncReadyCallback callback,
                             gpointer            user_data);
 
+void fp_device_clear_storage (FpDevice           *device,
+                              GCancellable       *cancellable,
+                              GAsyncReadyCallback callback,
+                              gpointer            user_data);
+
 gboolean fp_device_open_finish (FpDevice     *device,
                                 GAsyncResult *result,
                                 GError      **error);
 gboolean fp_device_close_finish (FpDevice     *device,
                                  GAsyncResult *result,
                                  GError      **error);
+gboolean fp_device_suspend_finish (FpDevice     *device,
+                                   GAsyncResult *result,
+                                   GError      **error);
+gboolean fp_device_resume_finish (FpDevice     *device,
+                                  GAsyncResult *result,
+                                  GError      **error);
 FpPrint *fp_device_enroll_finish (FpDevice     *device,
                                   GAsyncResult *result,
                                   GError      **error);
@@ -263,7 +334,9 @@ gboolean fp_device_delete_print_finish (FpDevice     *device,
 GPtrArray * fp_device_list_prints_finish (FpDevice     *device,
                                           GAsyncResult *result,
                                           GError      **error);
-
+gboolean fp_device_clear_storage_finish (FpDevice     *device,
+                                         GAsyncResult *result,
+                                         GError      **error);
 
 gboolean fp_device_open_sync (FpDevice     *device,
                               GCancellable *cancellable,
@@ -304,6 +377,22 @@ gboolean fp_device_delete_print_sync (FpDevice     *device,
 GPtrArray * fp_device_list_prints_sync (FpDevice     *device,
                                         GCancellable *cancellable,
                                         GError      **error);
+gboolean fp_device_clear_storage_sync (FpDevice     *device,
+                                       GCancellable *cancellable,
+                                       GError      **error);
+gboolean fp_device_suspend_sync (FpDevice     *device,
+                                 GCancellable *cancellable,
+                                 GError      **error);
+gboolean fp_device_resume_sync (FpDevice     *device,
+                                GCancellable *cancellable,
+                                GError      **error);
 
+/* Deprecated functions */
+G_DEPRECATED_FOR (fp_device_get_features)
+gboolean     fp_device_supports_identify (FpDevice *device);
+G_DEPRECATED_FOR (fp_device_get_features)
+gboolean     fp_device_supports_capture (FpDevice *device);
+G_DEPRECATED_FOR (fp_device_get_features)
+gboolean     fp_device_has_storage (FpDevice *device);
 
 G_END_DECLS

libfprint/fp-image-device.c

@@ -101,6 +101,7 @@ fp_image_device_start_capture_action (FpDevice *device)
   FpImageDevice *self = FP_IMAGE_DEVICE (device);
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
   FpiDeviceAction action;
+  FpiPrintType print_type;
 
   /* There is just one action that we cannot support out
    * of the box, which is a capture without first waiting
@@ -124,7 +125,9 @@ fp_image_device_start_capture_action (FpDevice *device)
       FpPrint *enroll_print = NULL;
 
       fpi_device_get_enroll_data (device, &enroll_print);
-      fpi_print_set_type (enroll_print, FPI_PRINT_NBIS);
+      g_object_get (enroll_print, "fpi-type", &print_type, NULL);
+      if (print_type != FPI_PRINT_NBIS)
+        fpi_print_set_type (enroll_print, FPI_PRINT_NBIS);
     }
 
   priv->enroll_stage = 0;
@@ -190,9 +193,7 @@ fp_image_device_constructed (GObject *obj)
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
   FpImageDeviceClass *cls = FP_IMAGE_DEVICE_GET_CLASS (self);
 
-  /* Set default values. */
-  fpi_device_set_nr_enroll_stages (FP_DEVICE (self), IMG_ENROLL_STAGES);
-
+  /* Set default threshold. */
   priv->bz3_threshold = BOZORTH3_DEFAULT_THRESHOLD;
   if (cls->bz3_threshold > 0)
     priv->bz3_threshold = cls->bz3_threshold;
@@ -210,6 +211,9 @@ fp_image_device_class_init (FpImageDeviceClass *klass)
   object_class->get_property = fp_image_device_get_property;
   object_class->constructed = fp_image_device_constructed;
 
+  /* Set default enroll stage count. */
+  fp_device_class->nr_enroll_stages = IMG_ENROLL_STAGES;
+
   fp_device_class->open = fp_image_device_open;
   fp_device_class->close = fp_image_device_close;
   fp_device_class->enroll = fp_image_device_start_capture_action;
@@ -219,6 +223,9 @@ fp_image_device_class_init (FpImageDeviceClass *klass)
 
   fp_device_class->cancel = fp_image_device_cancel_action;
 
+  fpi_device_class_auto_initialize_features (fp_device_class);
+  fp_device_class->features |= FP_DEVICE_FEATURE_UPDATE_PRINT;
+
   /* Default implementations */
   klass->activate = fp_image_device_default_activate;
   klass->deactivate = fp_image_device_default_deactivate;

libfprint/fp-image.c

@@ -20,6 +20,7 @@
 
 #define FP_COMPONENT "image"
 
+#include "fpi-compat.h"
 #include "fpi-image.h"
 #include "fpi-log.h"
 
@@ -295,7 +296,7 @@ fp_image_detect_minutiae_thread_func (GTask        *task,
 
   data->flags &= ~(FPI_IMAGE_H_FLIPPED | FPI_IMAGE_V_FLIPPED | FPI_IMAGE_COLORS_INVERTED);
 
-  lfsparms = g_memdup (&g_lfsparms_V2, sizeof (LFSPARMS));
+  lfsparms = g_memdup2 (&g_lfsparms_V2, sizeof (LFSPARMS));
   lfsparms->remove_perimeter_pts = data->flags & FPI_IMAGE_PARTIAL ? TRUE : FALSE;
 
   timer = g_timer_new ();

libfprint/fp-print.c

@@ -61,6 +61,7 @@ enum {
   /* Private property*/
   PROP_FPI_TYPE,
   PROP_FPI_DATA,
+  PROP_FPI_PRINTS,
   N_PROPS
 };
 
@@ -133,6 +134,10 @@ fp_print_get_property (GObject    *object,
       g_value_set_variant (value, self->data);
       break;
 
+    case PROP_FPI_PRINTS:
+      g_value_set_pointer (value, self->prints);
+      break;
+
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     }
@@ -188,6 +193,11 @@ fp_print_set_property (GObject      *object,
       self->data = g_value_dup_variant (value);
       break;
 
+    case PROP_FPI_PRINTS:
+      g_clear_pointer (&self->prints, g_ptr_array_unref);
+      self->prints = g_value_get_pointer (value);
+      break;
+
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     }
@@ -281,7 +291,7 @@ fp_print_class_init (FpPrintClass *klass)
                        "Type",
                        "Private: The type of the print data",
                        FPI_TYPE_PRINT_TYPE,
-                       FPI_PRINT_RAW,
+                       FPI_PRINT_UNDEFINED,
                        G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE | G_PARAM_EXPLICIT_NOTIFY);
 
   /**
@@ -299,6 +309,19 @@ fp_print_class_init (FpPrintClass *klass)
                           NULL,
                           G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
 
+  /**
+   * FpPrint::fpi-prints: (skip)
+   *
+   * This property is only for internal purposes.
+   *
+   * Stability: private
+   */
+  properties[PROP_FPI_PRINTS] =
+    g_param_spec_pointer ("fpi-prints",
+                          "Prints",
+                          "Prints for internal use only",
+                          G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
+
   g_object_class_install_properties (object_class, N_PROPS, properties);
 }
 
@@ -316,7 +339,7 @@ fp_print_init (FpPrint *self)
  * create a new print, fill in the relevant metadata, and then start
  * enrollment.
  *
- * Returns: (transfer floating): A newyl created #FpPrint
+ * Returns: (transfer floating): A newly created #FpPrint
  */
 FpPrint *
 fp_print_new (FpDevice *device)

libfprint/fpi-assembling.c

@@ -210,69 +210,36 @@ aes_blit_stripe (struct fpi_frame_asmbl_ctx *ctx,
                  struct fpi_frame *stripe,
                  int x, int y)
 {
-  unsigned int ix, iy;
-  unsigned int fx, fy;
-  unsigned int width, height;
+  unsigned int ix1, iy1;
+  unsigned int fx1, fy1;
+  unsigned int fx, fy, ix, iy;
 
-  /* Find intersection */
+  /* Select starting point inside image and frame */
   if (x < 0)
     {
-      width = ctx->frame_width + x;
-      ix = 0;
-      fx = -x;
+      ix1 = 0;
+      fx1 = -x;
     }
   else
     {
-      ix = x;
-      fx = 0;
-      width = ctx->frame_width;
+      ix1 = x;
+      fx1 = 0;
     }
-  if ((ix + width) > img->width)
-    width = img->width - ix;
 
   if (y < 0)
     {
-      iy = 0;
-      fy = -y;
-      height = ctx->frame_height + y;
+      iy1 = 0;
+      fy1 = -y;
     }
   else
     {
-      iy = y;
-      fy = 0;
-      height = ctx->frame_height;
+      iy1 = y;
+      fy1 = 0;
     }
 
-  if (fx > ctx->frame_width)
-    return;
-
-  if (fy > ctx->frame_height)
-    return;
-
-  if (ix > img->width)
-    return;
-
-  if (iy > img->height)
-    return;
-
-  if ((iy + height) > img->height)
-    height = img->height - iy;
-
-  for (; fy < height; fy++, iy++)
-    {
-      if (x < 0)
-        {
-          ix = 0;
-          fx = -x;
-        }
-      else
-        {
-          ix = x;
-          fx = 0;
-        }
-      for (; fx < width; fx++, ix++)
-        img->data[ix + (iy * img->width)] = ctx->get_pixel (ctx, stripe, fx, fy);
-    }
+  for (fy = fy1, iy = iy1; fy < ctx->frame_height && iy < img->height; fy++, iy++)
+    for (fx = fx1, ix = ix1; fx < ctx->frame_width && ix < img->width; fx++, ix++)
+      img->data[ix + (iy * img->width)] = ctx->get_pixel (ctx, stripe, fx, fy);
 }
 
 /**
@@ -298,7 +265,6 @@ fpi_assemble_frames (struct fpi_frame_asmbl_ctx *ctx,
 
   //FIXME g_return_if_fail
   g_return_val_if_fail (stripes != NULL, NULL);
-  BUG_ON (ctx->image_width < ctx->frame_width);
 
   /* No offset for 1st image */
   fpi_frame = stripes->data;
@@ -331,7 +297,7 @@ fpi_assemble_frames (struct fpi_frame_asmbl_ctx *ctx,
 
   /* Assemble stripes */
   y = reverse ? (height - ctx->frame_height) : 0;
-  x = (ctx->image_width - ctx->frame_width) / 2;
+  x = ((int) ctx->image_width - (int) ctx->frame_width) / 2;
 
   for (l = stripes; l != NULL; l = l->next)
     {

libfprint/fpi-assembling.h

@@ -19,7 +19,7 @@
 
 #pragma once
 
-#include <fprint.h>
+#include "fp-image.h"
 
 /**
  * fpi_frame:

libfprint/fpi-byte-reader.c

@@ -1181,7 +1181,7 @@ fpi_byte_reader_dup_string_utf##bits (FpiByteReader * reader, type ** str) \
     *str = NULL; \
     return FALSE; \
   } \
-  *str = g_memdup (reader->data + reader->byte, size); \
+  *str = g_memdup2 (reader->data + reader->byte, size); \
   reader->byte += size; \
   return TRUE; \
 }

libfprint/fpi-byte-reader.h

@@ -22,6 +22,7 @@
 #pragma once
 
 #include <glib.h>
+#include "fpi-compat.h"
 #include "fpi-byte-utils.h"
 
 G_BEGIN_DECLS
@@ -360,7 +361,7 @@ static inline guint8 *
 fpi_byte_reader_dup_data_unchecked (FpiByteReader * reader, guint size)
 {
   gconstpointer data = fpi_byte_reader_get_data_unchecked (reader, size);
-  return (guint8 *) g_memdup (data, size);
+  return (guint8 *) g_memdup2 (data, size);
 }
 
 /* Unchecked variants that should not be used */

libfprint/fpi-byte-writer.c

@@ -211,7 +211,7 @@ fpi_byte_writer_reset_and_get_data (FpiByteWriter * writer)
 
   data = (guint8 *) writer->parent.data;
   if (!writer->owned)
-    data = g_memdup (data, writer->parent.size);
+    data = g_memdup2 (data, writer->parent.size);
   writer->parent.data = NULL;
   fpi_byte_writer_reset (writer);
 

libfprint/fpi-compat.h

@@ -39,6 +39,17 @@ G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpDeviceClass, g_type_class_unref);
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (GDate, g_date_free);
 #endif
 
+#if !GLIB_CHECK_VERSION (2, 68, 0)
+#define g_memdup2(data, size) g_memdup ((data), (size))
+#else
+#define g_memdup2(data, size)        \
+  (G_GNUC_EXTENSION ({               \
+    G_GNUC_BEGIN_IGNORE_DEPRECATIONS \
+      g_memdup2 ((data), (size));    \
+    G_GNUC_END_IGNORE_DEPRECATIONS   \
+  }))
+#endif
+
 #if  __GNUC__ > 10 || (__GNUC__ == 10 && __GNUC_MINOR__ >= 1)
 #define FP_GNUC_ACCESS(m, p, s) __attribute__((access (m, p, s)))
 #else

libfprint/fpi-device.c

@@ -19,6 +19,10 @@
  */
 
 #define FP_COMPONENT "device"
+#include <math.h>
+#include <fcntl.h>
+#include <errno.h>
+
 #include "fpi-log.h"
 
 #include "fp-device-private.h"
@@ -46,6 +50,43 @@ fp_device_get_instance_private (FpDevice *self)
                             g_type_class_get_instance_private_offset (dev_class));
 }
 
+/**
+ * fpi_device_class_auto_initialize_features:
+ *
+ * Initializes the #FpDeviceClass @features flags checking what device vfuncs
+ * are implemented.
+ * Drivers should call this at the end of the class initialization.
+ */
+void
+fpi_device_class_auto_initialize_features (FpDeviceClass *device_class)
+{
+  g_return_if_fail (FP_IS_DEVICE_CLASS (device_class));
+
+  if (device_class->capture)
+    device_class->features |= FP_DEVICE_FEATURE_CAPTURE;
+
+  if (device_class->verify)
+    device_class->features |= FP_DEVICE_FEATURE_VERIFY;
+
+  if (device_class->identify)
+    device_class->features |= FP_DEVICE_FEATURE_IDENTIFY;
+
+  if (device_class->list)
+    device_class->features |= FP_DEVICE_FEATURE_STORAGE_LIST;
+
+  if (device_class->delete)
+    device_class->features |= FP_DEVICE_FEATURE_STORAGE_DELETE;
+
+  if (device_class->clear_storage)
+    device_class->features |= FP_DEVICE_FEATURE_STORAGE_CLEAR;
+
+  if (device_class->delete && (device_class->list || device_class->clear_storage))
+    device_class->features |= FP_DEVICE_FEATURE_STORAGE;
+
+  if (device_class->temp_hot_seconds < 0)
+    device_class->features |= FP_DEVICE_FEATURE_ALWAYS_ON;
+}
+
 /**
  * fpi_device_retry_new:
  * @error: The #FpDeviceRetry error value describing the issue
@@ -143,6 +184,10 @@ fpi_device_error_new (FpDeviceError error)
       msg = "This device has been removed from the system.";
       break;
 
+    case FP_DEVICE_ERROR_TOO_HOT:
+      msg = "Device disabled to prevent overheating.";
+      break;
+
     default:
       g_warning ("Unsupported error, returning general error instead!");
       error = FP_DEVICE_ERROR_GENERAL;
@@ -243,6 +288,29 @@ fpi_device_set_scan_type (FpDevice  *device,
   g_object_notify (G_OBJECT (device), "scan-type");
 }
 
+/**
+ * fpi_device_update_features:
+ * @device: The #FpDevice
+ * @update: The feature flags to update
+ * @value: The value to set the flags to
+ *
+ * Updates the feature flags for the device. This can be used
+ * to runtime detect features that are supported by the device.
+ */
+void
+fpi_device_update_features (FpDevice       *device,
+                            FpDeviceFeature update,
+                            FpDeviceFeature value)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  g_return_if_fail (FP_IS_DEVICE (device));
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_PROBE);
+  g_return_if_fail ((value & update) == value);
+
+  priv->features = (priv->features & ~update) | (value & update);
+}
+
 typedef struct
 {
   GSource   source;
@@ -300,12 +368,18 @@ fpi_device_add_timeout (FpDevice      *device,
 {
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
   FpDeviceTimeoutSource *source;
+  GMainContext *context;
 
   source = (FpDeviceTimeoutSource *) g_source_new (&timeout_funcs,
                                                    sizeof (FpDeviceTimeoutSource));
   source->device = device;
 
-  g_source_attach (&source->source, NULL);
+  if (priv->current_task)
+    context = g_task_get_context (priv->current_task);
+  else
+    context = g_main_context_get_thread_default ();
+
+  g_source_attach (&source->source, context);
   g_source_set_callback (&source->source, (GSourceFunc) func, user_data, destroy_notify);
   g_source_set_ready_time (&source->source,
                            g_source_get_time (&source->source) + interval * (guint64) 1000);
@@ -335,6 +409,38 @@ fpi_device_get_usb_device (FpDevice *device)
   return priv->usb_device;
 }
 
+/**
+ * fpi_device_get_udev_data:
+ * @device: The #FpDevice
+ * @subtype: Which subtype to get information about
+ *
+ * Get a subtype-specific hardware resource for this #FpDevice. Only permissible to call if the
+ * #FpDevice is of type %FP_DEVICE_TYPE_UDEV.
+ *
+ * Returns: Depends on @subtype; for SPIDEV/HIDRAW returns a path to the relevant device.
+ */
+gpointer
+fpi_device_get_udev_data (FpDevice *device, FpiDeviceUdevSubtypeFlags subtype)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  g_return_val_if_fail (FP_IS_DEVICE (device), NULL);
+  g_return_val_if_fail (priv->type == FP_DEVICE_TYPE_UDEV, NULL);
+
+  switch (subtype)
+    {
+    case FPI_DEVICE_UDEV_SUBTYPE_HIDRAW:
+      return priv->udev_data.hidraw_path;
+
+    case FPI_DEVICE_UDEV_SUBTYPE_SPIDEV:
+      return priv->udev_data.spidev_path;
+
+    default:
+      g_return_val_if_reached (NULL);
+      return NULL;
+    }
+}
+
 /**
  * fpi_device_get_virtual_env:
  * @device: The #FpDevice
@@ -393,14 +499,11 @@ gboolean
 fpi_device_action_is_cancelled (FpDevice *device)
 {
   FpDevicePrivate *priv = fp_device_get_instance_private (device);
-  GCancellable *cancellable;
 
   g_return_val_if_fail (FP_IS_DEVICE (device), TRUE);
   g_return_val_if_fail (priv->current_action != FPI_DEVICE_ACTION_NONE, TRUE);
 
-  cancellable = g_task_get_cancellable (priv->current_task);
-
-  return g_cancellable_is_cancelled (cancellable);
+  return g_cancellable_is_cancelled (priv->current_cancellable);
 }
 
 /**
@@ -519,7 +622,14 @@ fpi_device_get_verify_data (FpDevice *device,
  * @device: The #FpDevice
  * @prints: (out) (transfer none) (element-type FpPrint): The gallery of prints
  *
- * Get data for identify.
+ * Get prints gallery for identification.
+ *
+ * The @prints array is always non-%NULL and may contain a list of #FpPrint's
+ * that the device should match against.
+ *
+ * Note that @prints can be an empty array, in such case the device is expected
+ * to report the scanned print matching the one in its internal storage, if any.
+ *
  */
 void
 fpi_device_get_identify_data (FpDevice   *device,
@@ -578,7 +688,7 @@ fpi_device_get_cancellable (FpDevice *device)
   g_return_val_if_fail (FP_IS_DEVICE (device), NULL);
   g_return_val_if_fail (priv->current_action != FPI_DEVICE_ACTION_NONE, NULL);
 
-  return g_task_get_cancellable (priv->current_task);
+  return priv->current_cancellable;
 }
 
 static void
@@ -696,6 +806,10 @@ fpi_device_action_error (FpDevice *device,
       fpi_device_list_complete (device, NULL, error);
       break;
 
+    case FPI_DEVICE_ACTION_CLEAR_STORAGE:
+      fpi_device_clear_storage_complete (device, error);
+      break;
+
     default:
     case FPI_DEVICE_ACTION_NONE:
       g_return_if_reached ();
@@ -703,6 +817,121 @@ fpi_device_action_error (FpDevice *device,
     }
 }
 
+/**
+ * fpi_device_critical_enter:
+ * @device: The #FpDevice
+ *
+ * Enter a critical section in the driver code where no outside calls from
+ * libfprint should happen. Drivers can already assume that everything
+ * happens from the same thread, however, that still allows e.g. the cancel
+ * vfunc to be called at any point in time.
+ *
+ * Using this kind of critical section, the driver can assume that libfprint
+ * will not forward any external requests to the driver for the time being.
+ * This is for example useful to prevent cancellation while the device is being
+ * set up. Or, said differently, using this feature means that the cancel
+ * handler is able to make more assumptions about the current state.
+ *
+ * Please note that the driver is not shielded from all external changes. For
+ * example the cancellable as returned by fpi_device_get_cancellable() will
+ * still change immediately.
+ *
+ * The driver may call this function multiple times, but must also ensure that
+ * fpi_device_critical_leave() is called an equal amount of times and that all
+ * critical sections are left before command completion.
+ */
+void
+fpi_device_critical_enter (FpDevice *device)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  g_return_if_fail (priv->current_action != FPI_DEVICE_ACTION_NONE);
+
+  priv->critical_section += 1;
+
+  /* Stop flushing events if that was previously queued. */
+  if (priv->critical_section_flush_source)
+    g_source_destroy (priv->critical_section_flush_source);
+  priv->critical_section_flush_source = NULL;
+}
+
+static gboolean
+fpi_device_critical_section_flush_idle_cb (FpDevice *device)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+  FpDeviceClass *cls = FP_DEVICE_GET_CLASS (device);
+
+  if (priv->cancel_queued)
+    {
+      /* Cancellation must only happen if the driver is busy. */
+      if (priv->current_action != FPI_DEVICE_ACTION_NONE &&
+          priv->current_task_idle_return_source == NULL)
+        cls->cancel (device);
+      priv->cancel_queued = FALSE;
+
+      return G_SOURCE_CONTINUE;
+    }
+
+  if (priv->suspend_queued)
+    {
+      priv->suspend_queued = FALSE;
+      fpi_device_suspend (device);
+
+      return G_SOURCE_CONTINUE;
+    }
+
+  if (priv->resume_queued)
+    {
+      priv->resume_queued = FALSE;
+      fpi_device_resume (device);
+
+      return G_SOURCE_CONTINUE;
+    }
+
+  priv->critical_section_flush_source = NULL;
+
+  return G_SOURCE_REMOVE;
+}
+
+/**
+ * fpi_device_critical_leave:
+ * @device: The #FpDevice
+ *
+ * Leave a critical section started by fpi_device_critical_enter().
+ *
+ * Once all critical sections have been left, libfprint will start flushing
+ * out the queued up requests. This is done from the mainloop and the driver
+ * is protected from reentrency issues.
+ */
+void
+fpi_device_critical_leave (FpDevice *device)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  g_return_if_fail (priv->current_action != FPI_DEVICE_ACTION_NONE);
+  g_return_if_fail (priv->critical_section);
+
+  priv->critical_section -= 1;
+  if (priv->critical_section)
+    return;
+
+  /* We left the critical section, make sure a flush is queued. */
+  if (priv->critical_section_flush_source)
+    return;
+
+  priv->critical_section_flush_source = g_idle_source_new ();
+  g_source_set_priority (priv->critical_section_flush_source, G_PRIORITY_HIGH);
+  g_source_set_callback (priv->critical_section_flush_source,
+                         (GSourceFunc) fpi_device_critical_section_flush_idle_cb,
+                         device,
+                         NULL);
+  g_source_set_name (priv->critical_section_flush_source,
+                     "Flush libfprint driver critical section");
+  g_source_attach (priv->critical_section_flush_source,
+                   g_task_get_context (priv->current_task));
+  g_source_unref (priv->critical_section_flush_source);
+}
+
 static void
 clear_device_cancel_action (FpDevice *device)
 {
@@ -712,10 +941,17 @@ clear_device_cancel_action (FpDevice *device)
 
   if (priv->current_cancellable_id)
     {
-      g_cancellable_disconnect (g_task_get_cancellable (priv->current_task),
+      g_cancellable_disconnect (priv->current_cancellable,
                                 priv->current_cancellable_id);
       priv->current_cancellable_id = 0;
     }
+
+  if (priv->current_task_cancellable_id)
+    {
+      g_cancellable_disconnect (g_task_get_cancellable (priv->current_task),
+                                priv->current_task_cancellable_id);
+      priv->current_task_cancellable_id = 0;
+    }
 }
 
 typedef enum _FpDeviceTaskReturnType {
@@ -742,6 +978,7 @@ fp_device_task_return_in_idle_cb (gpointer user_data)
   FpiDeviceAction action;
 
   g_autoptr(GTask) task = NULL;
+  g_autoptr(GError) cancellation_reason = NULL;
 
 
   action_str = g_enum_to_string (FPI_TYPE_DEVICE_ACTION, priv->current_action);
@@ -751,6 +988,10 @@ fp_device_task_return_in_idle_cb (gpointer user_data)
   action = priv->current_action;
   priv->current_action = FPI_DEVICE_ACTION_NONE;
   priv->current_task_idle_return_source = NULL;
+  g_clear_object (&priv->current_cancellable);
+  cancellation_reason = g_steal_pointer (&priv->current_cancellation_reason);
+
+  fpi_device_update_temp (data->device, FALSE);
 
   if (action == FPI_DEVICE_ACTION_OPEN &&
       data->type != FP_DEVICE_TASK_RETURN_ERROR)
@@ -767,6 +1008,8 @@ fp_device_task_return_in_idle_cb (gpointer user_data)
       g_object_notify (G_OBJECT (data->device), "open");
     }
 
+  /* TODO: Port/use the cancellation mechanism for device removal! */
+
   /* Return FP_DEVICE_ERROR_REMOVED if the device is removed,
    * with the exception of a successful open, which is an odd corner case. */
   if (priv->is_removed &&
@@ -802,7 +1045,18 @@ fp_device_task_return_in_idle_cb (gpointer user_data)
       break;
 
     case FP_DEVICE_TASK_RETURN_ERROR:
-      g_task_return_error (task, g_steal_pointer (&data->result));
+      /* Return internal cancellation reason instead if we have one.
+       * Note that an external cancellation always returns G_IO_ERROR_CANCELLED
+       */
+      if (cancellation_reason)
+        {
+          g_task_set_task_data (task, NULL, NULL);
+          g_task_return_error (task, g_steal_pointer (&cancellation_reason));
+        }
+      else
+        {
+          g_task_return_error (task, g_steal_pointer (&data->result));
+        }
       break;
 
     default:
@@ -864,7 +1118,8 @@ fpi_device_return_task_in_idle (FpDevice              *device,
                          data,
                          (GDestroyNotify) fpi_device_task_return_data_free);
 
-  g_source_attach (priv->current_task_idle_return_source, NULL);
+  g_source_attach (priv->current_task_idle_return_source,
+                   g_task_get_context (priv->current_task));
   g_source_unref (priv->current_task_idle_return_source);
 }
 
@@ -977,6 +1232,7 @@ fpi_device_close_complete (FpDevice *device, GError *error)
       break;
 
     case FP_DEVICE_TYPE_VIRTUAL:
+    case FP_DEVICE_TYPE_UDEV:
       break;
 
     default:
@@ -1063,12 +1319,14 @@ fpi_device_enroll_complete (FpDevice *device, FpPrint *print, GError *error)
  * @device: The #FpDevice
  * @error: A #GError if result is %FPI_MATCH_ERROR
  *
- * Finish an ongoing verify operation. The returned print should be
- * representing the new scan and not the one passed for verification.
+ * Finish an ongoing verify operation.
  *
  * Note that @error should only be set for actual errors. In the case
  * of retry errors, report these using fpi_device_verify_report()
  * and then call this function without any error argument.
+ *
+ * If @error is not set, we expect that a result (and print, in case)
+ * have been already reported via fpi_device_verify_report().
  */
 void
 fpi_device_verify_complete (FpDevice *device,
@@ -1126,9 +1384,14 @@ fpi_device_verify_complete (FpDevice *device,
  * @device: The #FpDevice
  * @error: The #GError or %NULL on success
  *
- * Finish an ongoing identify operation. The match that was identified is
- * returned in @match. The @print parameter returns the newly created scan
- * that was used for matching.
+ * Finish an ongoing identify operation.
+ *
+ * Note that @error should only be set for actual errors. In the case
+ * of retry errors, report these using fpi_device_identify_report()
+ * and then call this function without any error argument.
+ *
+ * If @error is not set, we expect that a match and / or a print have been
+ * already reported via fpi_device_identify_report()
  */
 void
 fpi_device_identify_complete (FpDevice *device,
@@ -1303,7 +1566,348 @@ fpi_device_list_complete (FpDevice  *device,
     fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_ERROR, error);
 }
 
+static int
+update_attr (const char *attr, const char *value)
+{
+  int fd, err;
+  gssize r;
+  char buf[50] = { 0 };
+
+  fd = open (attr, O_RDONLY);
+  err = -errno;
+  if (fd < 0)
+    return -err;
+
+  r = read (fd, buf, sizeof (buf) - 1);
+  err = errno;
+  close (fd);
+  if (r < 0)
+    return -err;
+
+  g_strchomp (buf);
+  if (g_strcmp0 (buf, value) == 0)
+    return 0;
+
+  /* O_TRUNC makes things work in the umockdev environment */
+  fd = open (attr, O_WRONLY | O_TRUNC);
+  err = errno;
+  if (fd < 0)
+    return -err;
+
+  r = write (fd, value, strlen (value));
+  err = -errno;
+  close (fd);
+  if (r < 0)
+    {
+      /* Write failures are weird, and are worth a warning */
+      g_warning ("Could not write %s to %s", value, attr);
+      return -err;
+    }
+
+  return 0;
+}
+
+static void
+complete_suspend_resume_task (FpDevice *device)
+{
+  g_autoptr(GTask) task = NULL;
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  g_assert (priv->suspend_resume_task);
+  task = g_steal_pointer (&priv->suspend_resume_task);
+
+  g_task_return_boolean (task, TRUE);
+}
+
+void
+fpi_device_suspend (FpDevice *device)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  /* If the device is currently idle, just complete immediately.
+   * For long running tasks, call the driver handler right away, for short
+   * tasks, wait for completion and then return the task.
+   */
+  switch (priv->current_action)
+    {
+    case FPI_DEVICE_ACTION_NONE:
+      fpi_device_suspend_complete (device, NULL);
+      break;
+
+    case FPI_DEVICE_ACTION_ENROLL:
+    case FPI_DEVICE_ACTION_VERIFY:
+    case FPI_DEVICE_ACTION_IDENTIFY:
+    case FPI_DEVICE_ACTION_CAPTURE:
+      if (FP_DEVICE_GET_CLASS (device)->suspend)
+        {
+          if (priv->critical_section)
+            priv->suspend_queued = TRUE;
+          else
+            FP_DEVICE_GET_CLASS (device)->suspend (device);
+        }
+      else
+        {
+          fpi_device_suspend_complete (device, fpi_device_error_new (FP_DEVICE_ERROR_NOT_SUPPORTED));
+        }
+      break;
+
+    default:
+    case FPI_DEVICE_ACTION_PROBE:
+    case FPI_DEVICE_ACTION_OPEN:
+    case FPI_DEVICE_ACTION_CLOSE:
+    case FPI_DEVICE_ACTION_DELETE:
+    case FPI_DEVICE_ACTION_LIST:
+    case FPI_DEVICE_ACTION_CLEAR_STORAGE:
+      g_signal_connect_object (priv->current_task,
+                               "notify::completed",
+                               G_CALLBACK (complete_suspend_resume_task),
+                               device,
+                               G_CONNECT_SWAPPED);
+
+      break;
+    }
+}
+
+void
+fpi_device_resume (FpDevice *device)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  switch (priv->current_action)
+    {
+    case FPI_DEVICE_ACTION_NONE:
+      fpi_device_resume_complete (device, NULL);
+      break;
+
+    case FPI_DEVICE_ACTION_ENROLL:
+    case FPI_DEVICE_ACTION_VERIFY:
+    case FPI_DEVICE_ACTION_IDENTIFY:
+    case FPI_DEVICE_ACTION_CAPTURE:
+      if (FP_DEVICE_GET_CLASS (device)->resume)
+        {
+          if (priv->critical_section)
+            priv->resume_queued = TRUE;
+          else
+            FP_DEVICE_GET_CLASS (device)->resume (device);
+        }
+      else
+        {
+          fpi_device_resume_complete (device, fpi_device_error_new (FP_DEVICE_ERROR_NOT_SUPPORTED));
+        }
+      break;
+
+    default:
+    case FPI_DEVICE_ACTION_PROBE:
+    case FPI_DEVICE_ACTION_OPEN:
+    case FPI_DEVICE_ACTION_CLOSE:
+    case FPI_DEVICE_ACTION_DELETE:
+    case FPI_DEVICE_ACTION_LIST:
+    case FPI_DEVICE_ACTION_CLEAR_STORAGE:
+      /* cannot happen as we make sure these tasks complete before suspend */
+      g_assert_not_reached ();
+      complete_suspend_resume_task (device);
+      break;
+    }
+}
+
+void
+fpi_device_configure_wakeup (FpDevice *device, gboolean enabled)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  switch (priv->type)
+    {
+    case FP_DEVICE_TYPE_USB:
+      {
+        g_autoptr(GString) ports = NULL;
+        g_autoptr(GUsbDevice) dev = NULL;
+        const char *wakeup_command = enabled ? "enabled" : "disabled";
+        guint8 bus;
+        g_autofree gchar *sysfs_wakeup = NULL;
+        g_autofree gchar *sysfs_persist = NULL;
+        int res;
+
+        ports = g_string_new (NULL);
+        bus = g_usb_device_get_bus (priv->usb_device);
+
+        /* Walk up, skipping the root hub. */
+        g_set_object (&dev, priv->usb_device);
+        while (TRUE)
+          {
+            g_autoptr(GUsbDevice) parent = g_usb_device_get_parent (dev);
+            g_autofree gchar *port_str = NULL;
+            guint8 port;
+
+            if (!parent)
+              break;
+
+            port = g_usb_device_get_port_number (dev);
+            port_str = g_strdup_printf ("%d.", port);
+            g_string_prepend (ports, port_str);
+            g_set_object (&dev, parent);
+          }
+        g_string_set_size (ports, ports->len - 1);
+
+        sysfs_wakeup = g_strdup_printf ("/sys/bus/usb/devices/%d-%s/power/wakeup", bus, ports->str);
+        res = update_attr (sysfs_wakeup, wakeup_command);
+        if (res < 0)
+          g_debug ("Failed to set %s to %s", sysfs_wakeup, wakeup_command);
+
+        /* Persist means that the kernel tries to keep the USB device open
+         * in case it is "replugged" due to suspend.
+         * This is not helpful, as it will receive a reset and will be in a bad
+         * state. Instead, seeing an unplug and a new device makes more sense.
+         */
+        sysfs_persist = g_strdup_printf ("/sys/bus/usb/devices/%d-%s/power/persist", bus, ports->str);
+        res = update_attr (sysfs_persist, "0");
+        if (res < 0)
+          g_warning ("Failed to disable USB persist by writing to %s", sysfs_persist);
+
+        break;
+      }
+
+    case FP_DEVICE_TYPE_VIRTUAL:
+    case FP_DEVICE_TYPE_UDEV:
+      break;
+
+    default:
+      g_assert_not_reached ();
+      fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_ERROR,
+                                      fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
+      return;
+    }
+}
+
+static void
+fpi_device_suspend_completed (FpDevice *device)
+{
+  g_autoptr(GTask) task = NULL;
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  /* We have an ongoing operation, allow the device to wake up the machine. */
+  if (priv->current_action != FPI_DEVICE_ACTION_NONE)
+    fpi_device_configure_wakeup (device, TRUE);
+
+  if (priv->critical_section)
+    g_warning ("Driver was in a critical section at suspend time. It likely deadlocked!");
+
+  task = g_steal_pointer (&priv->suspend_resume_task);
+
+  if (priv->suspend_error)
+    g_task_return_error (task, g_steal_pointer (&priv->suspend_error));
+  else
+    g_task_return_boolean (task, TRUE);
+}
+
 /**
+ * fpi_device_suspend_complete:
+ * @device: The #FpDevice
+ * @error: The #GError or %NULL on success
+ *
+ * Finish a suspend request. Only return a %NULL error if suspend has been
+ * correctly configured and the current action as returned by
+ * fpi_device_get_current_action() will continue to run after resume.
+ *
+ * In all other cases an error must be returned. Should this happen, the
+ * current action will be cancelled before the error is forwarded to the
+ * application.
+ *
+ * It is recommended to set @error to #FP_ERROR_NOT_IMPLEMENTED.
+ */
+void
+fpi_device_suspend_complete (FpDevice *device,
+                             GError   *error)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  g_return_if_fail (FP_IS_DEVICE (device));
+  g_return_if_fail (priv->suspend_resume_task);
+  g_return_if_fail (priv->suspend_error == NULL);
+
+  priv->suspend_error = g_steal_pointer (&error);
+  priv->is_suspended = TRUE;
+
+  /* If there is no error, we have no running task, return immediately. */
+  if (!priv->suspend_error || !priv->current_task ||
+      g_task_get_completed (priv->current_task))
+    {
+      fpi_device_suspend_completed (device);
+      return;
+    }
+
+  /* Wait for completion of the current task. */
+  g_signal_connect_object (priv->current_task,
+                           "notify::completed",
+                           G_CALLBACK (fpi_device_suspend_completed),
+                           device,
+                           G_CONNECT_SWAPPED);
+
+  /* And cancel any action that might be long-running. */
+  if (!priv->current_cancellation_reason)
+    priv->current_cancellation_reason = fpi_device_error_new_msg (FP_DEVICE_ERROR_BUSY,
+                                                                  "Cannot run while suspended.");
+
+  g_cancellable_cancel (priv->current_cancellable);
+}
+
+/**
+ * fpi_device_resume_complete:
+ * @device: The #FpDevice
+ * @error: The #GError or %NULL on success
+ *
+ * Finish a resume request.
+ */
+void
+fpi_device_resume_complete (FpDevice *device,
+                            GError   *error)
+{
+  g_autoptr(GTask) task = NULL;
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  g_return_if_fail (FP_IS_DEVICE (device));
+  g_return_if_fail (priv->suspend_resume_task);
+
+  priv->is_suspended = FALSE;
+  fpi_device_configure_wakeup (device, FALSE);
+
+  task = g_steal_pointer (&priv->suspend_resume_task);
+
+  if (error)
+    g_task_return_error (task, error);
+  else
+    g_task_return_boolean (task, TRUE);
+}
+
+/**
+ * fpi_device_clear_storage_complete:
+ * @device: The #FpDevice
+ * @error: The #GError or %NULL on success
+ *
+ * Finish an ongoing clear_storage operation.
+ */
+void
+fpi_device_clear_storage_complete (FpDevice *device,
+                                   GError   *error)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  g_return_if_fail (FP_IS_DEVICE (device));
+  g_return_if_fail (priv->current_action == FPI_DEVICE_ACTION_CLEAR_STORAGE);
+
+  g_debug ("Device reported deletion completion");
+
+  clear_device_cancel_action (device);
+  fpi_device_report_finger_status (device, FP_FINGER_STATUS_NONE);
+
+  if (!error)
+    fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_BOOL,
+                                    GUINT_TO_POINTER (TRUE));
+  else
+    fpi_device_return_task_in_idle (device, FP_DEVICE_TASK_RETURN_ERROR, error);
+}
+
+/**
+
  * fpi_device_enroll_progress:
  * @device: The #FpDevice
  * @completed_stages: The number of stages that are completed at this point
@@ -1428,12 +2032,26 @@ fpi_device_verify_report (FpDevice      *device,
  * fpi_device_identify_report:
  * @device: The #FpDevice
  * @match: (transfer none): The #FpPrint from the gallery that matched
- * @print: (transfer floating): The scanned #FpPrint
- * @error: A #GError if result is %FPI_MATCH_ERROR
+ * @print: (transfer floating): The scanned #FpPrint, set in the absence
+ *   of an error.
+ * @error: A #GError of %FP_DEVICE_RETRY type if @match and @print are unset.
  *
- * Report the result of a identify operation. Note that the passed @error must be
- * a retry error with the %FP_DEVICE_RETRY domain. For all other error cases,
- * the error should passed to fpi_device_identify_complete().
+ * Report the results of an identify operation.
+ *
+ * In case of successful identification @match is expected to be set to a
+ * #FpPrint that matches one from the provided gallery, while @print
+ * represents the scanned print and will be different.
+ *
+ * If there are no errors, it's expected that the device always reports the
+ * recognized @print even if there is no @match with the provided gallery (that
+ * can be potentially empty). This is required for application logic further
+ * up in the stack, such as for enroll-duplicate checking. @print needs to be
+ * sufficiently filled to do a comparison.
+ *
+ * In case of error, both @match and @print are expected to be %NULL.
+ * Note that the passed @error must be a retry error from the %FP_DEVICE_RETRY
+ * domain. For all other error cases, the error should passed to
+ * fpi_device_identify_complete().
  */
 void
 fpi_device_identify_report (FpDevice *device,
@@ -1555,3 +2173,128 @@ fpi_device_report_finger_status_changes (FpDevice           *device,
 
   return fpi_device_report_finger_status (device, finger_status);
 }
+
+static void
+update_temp_timeout (FpDevice *device, gpointer user_data)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+
+  fpi_device_update_temp (device, priv->temp_last_active);
+}
+
+/**
+ * fpi_device_update_temp:
+ * @device: The #FpDevice
+ * @is_active: Whether the device is now active
+ *
+ * Purely internal function to update the temperature. Also ensure that the
+ * state is updated once a threshold is reached.
+ */
+void
+fpi_device_update_temp (FpDevice *device, gboolean is_active)
+{
+  FpDevicePrivate *priv = fp_device_get_instance_private (device);
+  gint64 now = g_get_monotonic_time ();
+  gdouble passed_seconds;
+  gdouble alpha;
+  gdouble next_threshold;
+  gdouble old_ratio;
+  FpTemperature old_temp;
+  g_autofree char *old_temp_str = NULL;
+  g_autofree char *new_temp_str = NULL;
+
+  if (priv->temp_hot_seconds < 0)
+    {
+      g_debug ("Not updating temperature model, device can run continuously!");
+      return;
+    }
+
+  passed_seconds = (now - priv->temp_last_update) / 1e6;
+  old_ratio = priv->temp_current_ratio;
+
+  if (priv->temp_last_active)
+    {
+      alpha = exp (-passed_seconds / priv->temp_hot_seconds);
+      priv->temp_current_ratio = alpha * priv->temp_current_ratio + 1 - alpha;
+    }
+  else
+    {
+      alpha = exp (-passed_seconds / priv->temp_cold_seconds);
+      priv->temp_current_ratio = alpha * priv->temp_current_ratio;
+    }
+
+  priv->temp_last_active = is_active;
+  priv->temp_last_update = now;
+
+  old_temp = priv->temp_current;
+  if (priv->temp_current_ratio < TEMP_COLD_THRESH)
+    {
+      priv->temp_current = FP_TEMPERATURE_COLD;
+      next_threshold = is_active ? TEMP_COLD_THRESH : -1.0;
+    }
+  else if (priv->temp_current_ratio < TEMP_HOT_WARM_THRESH)
+    {
+      priv->temp_current = FP_TEMPERATURE_WARM;
+      next_threshold = is_active ? TEMP_WARM_HOT_THRESH : TEMP_COLD_THRESH;
+    }
+  else if (priv->temp_current_ratio < TEMP_WARM_HOT_THRESH)
+    {
+      /* Keep HOT until we reach TEMP_HOT_WARM_THRESH */
+      if (priv->temp_current != FP_TEMPERATURE_HOT)
+        priv->temp_current = FP_TEMPERATURE_WARM;
+
+      next_threshold = is_active ? TEMP_WARM_HOT_THRESH : TEMP_HOT_WARM_THRESH;
+    }
+  else
+    {
+      priv->temp_current = FP_TEMPERATURE_HOT;
+      next_threshold = is_active ? -1.0 : TEMP_HOT_WARM_THRESH;
+    }
+
+  old_temp_str = g_enum_to_string (FP_TYPE_TEMPERATURE, old_temp);
+  new_temp_str = g_enum_to_string (FP_TYPE_TEMPERATURE, priv->temp_current);
+  g_debug ("Updated temperature model after %0.2f seconds, ratio %0.2f -> %0.2f, active %d -> %d, %s -> %s",
+           passed_seconds,
+           old_ratio,
+           priv->temp_current_ratio,
+           priv->temp_last_active,
+           is_active,
+           old_temp_str,
+           new_temp_str);
+
+  if (priv->temp_current != old_temp)
+    g_object_notify (G_OBJECT (device), "temperature");
+
+  /* If the device is HOT, then do an internal cancellation of long running tasks. */
+  if (priv->temp_current == FP_TEMPERATURE_HOT)
+    {
+      if (priv->current_action == FPI_DEVICE_ACTION_ENROLL ||
+          priv->current_action == FPI_DEVICE_ACTION_VERIFY ||
+          priv->current_action == FPI_DEVICE_ACTION_IDENTIFY ||
+          priv->current_action == FPI_DEVICE_ACTION_CAPTURE)
+        {
+          if (!priv->current_cancellation_reason)
+            priv->current_cancellation_reason = fpi_device_error_new (FP_DEVICE_ERROR_TOO_HOT);
+
+          g_cancellable_cancel (priv->current_cancellable);
+        }
+    }
+
+  g_clear_pointer (&priv->temp_timeout, g_source_destroy);
+
+  if (next_threshold < 0)
+    return;
+
+  /* Set passed_seconds to the time until the next update is needed */
+  if (is_active)
+    passed_seconds = -priv->temp_hot_seconds * log ((next_threshold - 1.0) / (priv->temp_current_ratio - 1.0));
+  else
+    passed_seconds = -priv->temp_cold_seconds * log (next_threshold / priv->temp_current_ratio);
+
+  passed_seconds += TEMP_DELAY_SECONDS;
+
+  priv->temp_timeout = fpi_device_add_timeout (device,
+                                               passed_seconds * 1000,
+                                               update_temp_timeout,
+                                               NULL, NULL);
+}

libfprint/fpi-device.h

@@ -24,6 +24,18 @@
 #include "fp-image.h"
 #include "fpi-print.h"
 
+/**
+ * FpiDeviceUdevSubtypeFlags:
+ * @FPI_DEVICE_UDEV_SUBTYPE_SPIDEV: The device requires an spidev node
+ * @FPI_DEVICE_UDEV_SUBTYPE_HIDRAW: The device requires a hidraw node
+ *
+ * Bitfield of required hardware resources for a udev-backed device.
+ */
+typedef enum {
+  FPI_DEVICE_UDEV_SUBTYPE_SPIDEV = 1 << 0,
+  FPI_DEVICE_UDEV_SUBTYPE_HIDRAW = 1 << 1,
+} FpiDeviceUdevSubtypeFlags;
+
 /**
  * FpIdEntry:
  *
@@ -43,6 +55,16 @@ struct _FpIdEntry
       guint vid;
     };
     const gchar *virtual_envvar;
+    struct
+    {
+      FpiDeviceUdevSubtypeFlags udev_types;
+      const gchar              *spi_acpi_id;
+      struct
+      {
+        guint pid;
+        guint vid;
+      } hid_id;
+    };
   };
   guint64 driver_data;
 };
@@ -54,10 +76,16 @@ struct _FpIdEntry
  * @full_name: Human readable description of the driver
  * @type: The type of driver
  * @id_table: The table of IDs to bind the driver to
+ * @features: The features the device supports, it can be initialized using
+ *   fpi_device_class_auto_initialize_features() on @class_init.
  * @nr_enroll_stages: The number of enroll stages supported devices need; use
  *   fpi_device_set_nr_enroll_stages() from @probe if this is dynamic.
  * @scan_type: The scan type of supported devices; use
  *   fpi_device_set_scan_type() from @probe if this is dynamic.
+ * @temp_hot_seconds: Assumed time in seconds for the device to become too hot
+ *   after being mostly cold. Set to -1 if the device can be always-on.
+ * @temp_cold_seconds: Assumed time in seconds for the device to be mostly cold
+ *   after having been too hot to operate.
  * @usb_discover: Class method to check whether a USB device is supported by
  *  the driver. Should return 0 if the device is unsupported and a positive
  *  score otherwise. The default score is 50 and the driver with the highest
@@ -77,8 +105,13 @@ struct _FpIdEntry
  * @capture: Start a capture operation
  * @list: List prints stored on the device
  * @delete: Delete a print from the device
+ * @clear_storage: Delete all prints from the device
  * @cancel: Called on cancellation, this is a convenience to not need to handle
  *   the #GCancellable directly by using fpi_device_get_cancellable().
+ * @suspend: Called when an interactive action is running (ENROLL, VERIFY,
+ *    IDENTIFY or CAPTURE) and the system is about to go into suspend.
+ * @resume: Called to resume an ongoing interactive action after the system has
+ *    resumed from suspend.
  *
  * NOTE: If your driver is image based, then you should subclass #FpImageDevice
  * instead. #FpImageDevice based drivers use a different way of interacting
@@ -97,6 +130,9 @@ struct _FpIdEntry
  * operation (i.e. any operation that requires capturing). It is entirely fine
  * to ignore cancellation requests for short operations (e.g. open/close).
  *
+ * Note that @cancel, @suspend and @resume will not be called while the device
+ * is within a fpi_device_critical_enter()/fpi_device_critical_leave() block.
+ *
  * This API is solely intended for drivers. It is purely internal and neither
  * API nor ABI stable.
  */
@@ -111,11 +147,16 @@ struct _FpDeviceClass
   const gchar     *full_name;
   FpDeviceType     type;
   const FpIdEntry *id_table;
+  FpDeviceFeature  features;
 
   /* Defaults for device properties */
   gint       nr_enroll_stages;
   FpScanType scan_type;
 
+  /* Simple device temperature model constants */
+  gint32 temp_hot_seconds;
+  gint32 temp_cold_seconds;
+
   /* Callbacks */
   gint (*usb_discover) (GUsbDevice *usb_device);
   void (*probe)    (FpDevice *device);
@@ -127,10 +168,15 @@ struct _FpDeviceClass
   void (*capture)  (FpDevice *device);
   void (*list)     (FpDevice *device);
   void (*delete)   (FpDevice * device);
+  void (*clear_storage)  (FpDevice * device);
 
   void (*cancel)   (FpDevice *device);
+  void (*suspend)  (FpDevice *device);
+  void (*resume)   (FpDevice *device);
 };
 
+void fpi_device_class_auto_initialize_features (FpDeviceClass *device_class);
+
 /**
  * FpTimeoutFunc:
  * @device: The #FpDevice passed to fpi_device_add_timeout()
@@ -153,6 +199,7 @@ typedef void (*FpTimeoutFunc) (FpDevice *device,
  * @FPI_DEVICE_ACTION_CAPTURE: Device is currently capturing an image.
  * @FPI_DEVICE_ACTION_LIST: Device stored prints are being queried.
  * @FPI_DEVICE_ACTION_DELETE: Device stored print is being deleted.
+ * @FPI_DEVICE_ACTION_CLEAR_STORAGE: Device stored prints are being deleted.
  *
  * Current active action of the device. A driver can retrieve the action.
  */
@@ -167,10 +214,13 @@ typedef enum {
   FPI_DEVICE_ACTION_CAPTURE,
   FPI_DEVICE_ACTION_LIST,
   FPI_DEVICE_ACTION_DELETE,
+  FPI_DEVICE_ACTION_CLEAR_STORAGE,
 } FpiDeviceAction;
 
 GUsbDevice  *fpi_device_get_usb_device (FpDevice *device);
 const gchar *fpi_device_get_virtual_env (FpDevice *device);
+gpointer     fpi_device_get_udev_data (FpDevice                 *device,
+                                       FpiDeviceUdevSubtypeFlags subtype);
 //const gchar *fpi_device_get_spi_dev (FpDevice *device);
 
 
@@ -216,9 +266,16 @@ void fpi_device_set_nr_enroll_stages (FpDevice *device,
 void fpi_device_set_scan_type (FpDevice  *device,
                                FpScanType scan_type);
 
+void fpi_device_update_features (FpDevice       *device,
+                                 FpDeviceFeature update,
+                                 FpDeviceFeature value);
+
 void fpi_device_action_error (FpDevice *device,
                               GError   *error);
 
+void fpi_device_critical_enter (FpDevice *device);
+void fpi_device_critical_leave (FpDevice *device);
+
 void fpi_device_probe_complete (FpDevice    *device,
                                 const gchar *device_id,
                                 const gchar *device_name,
@@ -242,6 +299,12 @@ void fpi_device_delete_complete (FpDevice *device,
 void fpi_device_list_complete (FpDevice  *device,
                                GPtrArray *prints,
                                GError    *error);
+void fpi_device_clear_storage_complete (FpDevice *device,
+                                        GError   *error);
+void fpi_device_suspend_complete (FpDevice *device,
+                                  GError   *error);
+void fpi_device_resume_complete (FpDevice *device,
+                                 GError   *error);
 
 void fpi_device_enroll_progress (FpDevice *device,
                                  gint      completed_stages,

libfprint/fpi-image-device.c

@@ -306,7 +306,7 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
                                   g_steal_pointer (&print), error);
 
       /* Start another scan or deactivate. */
-      if (priv->enroll_stage == IMG_ENROLL_STAGES)
+      if (priv->enroll_stage == fp_device_get_nr_enroll_stages (device))
         {
           fp_image_device_maybe_complete_action (self, g_steal_pointer (&error));
           fpi_image_device_deactivate (self, FALSE);

libfprint/fpi-print.c

@@ -50,7 +50,7 @@ fpi_print_add_print (FpPrint *print, FpPrint *add)
   g_return_if_fail (add->type == FPI_PRINT_NBIS);
 
   g_assert (add->prints->len == 1);
-  g_ptr_array_add (print->prints, g_memdup (add->prints->pdata[0], sizeof (struct xyt_struct)));
+  g_ptr_array_add (print->prints, g_memdup2 (add->prints->pdata[0], sizeof (struct xyt_struct)));
 }
 
 /**

libfprint/fpi-print.h

@@ -42,9 +42,9 @@ gboolean fpi_print_add_from_image (FpPrint *print,
                                    FpImage *image,
                                    GError **error);
 
-FpiMatchResult fpi_print_bz3_match (FpPrint * template,
-                                    FpPrint * print,
-                                    gint bz3_threshold,
+FpiMatchResult fpi_print_bz3_match (FpPrint *temp,
+                                    FpPrint *print,
+                                    gint     bz3_threshold,
                                     GError **error);
 
 /* Helpers to encode metadata into user ID strings. */

libfprint/fpi-spi-transfer.c

@@ -0,0 +1,519 @@
+/*
+ * FPrint SPI transfer handling
+ * Copyright (C) 2019-2020 Benjamin Berg <bberg@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "fpi-spi-transfer.h"
+#include <sys/ioctl.h>
+#include <linux/spi/spidev.h>
+#include <errno.h>
+
+/* spidev can only handle the specified block size, which defaults to 4096. */
+#define SPIDEV_BLOCK_SIZE_PARAM "/sys/module/spidev/parameters/bufsiz"
+#define SPIDEV_BLOCK_SIZE_FALLBACK 4096
+static gsize block_size = 0;
+
+/**
+ * SECTION:fpi-spi-transfer
+ * @title: SPI transfer helpers
+ * @short_description: Helpers to ease SPI transfers
+ *
+ * #FpiSpiTransfer is a structure to simplify the SPI transfer handling
+ * for the linux spidev device. The main goal are to ease memory management
+ * and provide a usable asynchronous API to libfprint drivers.
+ *
+ * Currently only transfers with a write and subsequent read are supported.
+ *
+ * Drivers should always use this API rather than calling read/write/ioctl on
+ * the spidev device.
+ *
+ * Setting G_MESSAGES_DEBUG and FP_DEBUG_TRANSFER will result in the message
+ * content to be dumped.
+ */
+
+
+G_DEFINE_BOXED_TYPE (FpiSpiTransfer, fpi_spi_transfer, fpi_spi_transfer_ref, fpi_spi_transfer_unref)
+
+static void
+dump_buffer (guchar *buf, gssize dump_len)
+{
+  g_autoptr(GString) line = NULL;
+
+  line = g_string_new ("");
+  /* Dump the buffer. */
+  for (gssize i = 0; i < dump_len; i++)
+    {
+      g_string_append_printf (line, "%02x ", buf[i]);
+      if ((i + 1) % 16 == 0)
+        {
+          g_debug ("%s", line->str);
+          g_string_set_size (line, 0);
+        }
+    }
+
+  if (line->len)
+    g_debug ("%s", line->str);
+}
+
+static void
+log_transfer (FpiSpiTransfer *transfer, gboolean submit, GError *error)
+{
+  if (g_getenv ("FP_DEBUG_TRANSFER"))
+    {
+      if (submit)
+        {
+          g_debug ("Transfer %p submitted, write length %zd, read length %zd",
+                   transfer,
+                   transfer->length_wr,
+                   transfer->length_rd);
+
+          if (transfer->buffer_wr)
+            dump_buffer (transfer->buffer_wr, transfer->length_wr);
+        }
+      else
+        {
+          g_autofree gchar *error_str = NULL;
+          if (error)
+            error_str = g_strdup_printf ("with error (%s)", error->message);
+          else
+            error_str = g_strdup ("successfully");
+
+          g_debug ("Transfer %p completed %s, write length %zd, read length %zd",
+                   transfer,
+                   error_str,
+                   transfer->length_wr,
+                   transfer->length_rd);
+          if (transfer->buffer_rd)
+            dump_buffer (transfer->buffer_rd, transfer->length_rd);
+        }
+    }
+}
+
+/**
+ * fpi_spi_transfer_new:
+ * @device: The #FpDevice the transfer is for
+ * @spidev_fd: The file descriptor for the spidev device
+ *
+ * Creates a new #FpiSpiTransfer.
+ *
+ * Returns: (transfer full): A newly created #FpiSpiTransfer
+ */
+FpiSpiTransfer *
+fpi_spi_transfer_new (FpDevice * device, int spidev_fd)
+{
+  FpiSpiTransfer *self;
+
+  g_assert (FP_IS_DEVICE (device));
+
+  if (G_UNLIKELY (block_size == 0))
+    {
+      g_autoptr(GError) error = NULL;
+      g_autofree char *contents = NULL;
+
+      block_size = SPIDEV_BLOCK_SIZE_FALLBACK;
+
+      if (g_file_get_contents (SPIDEV_BLOCK_SIZE_PARAM, &contents, NULL, &error))
+        {
+          block_size = MIN (g_ascii_strtoull (contents, NULL, 0), G_MAXUINT16);
+          if (block_size == 0)
+            {
+              block_size = SPIDEV_BLOCK_SIZE_FALLBACK;
+              g_warning ("spidev blocksize could not be decoded, using %" G_GSIZE_FORMAT, block_size);
+            }
+        }
+      else
+        {
+          g_message ("Failed to read spidev block size, using %" G_GSIZE_FORMAT, block_size);
+        }
+    }
+
+  self = g_slice_new0 (FpiSpiTransfer);
+  self->ref_count = 1;
+
+  /* Purely to enhance the debug log output. */
+  self->length_wr = -1;
+  self->length_rd = -1;
+
+  self->device = device;
+  self->spidev_fd = spidev_fd;
+
+  return self;
+}
+
+static void
+fpi_spi_transfer_free (FpiSpiTransfer *self)
+{
+  g_assert (self);
+  g_assert_cmpint (self->ref_count, ==, 0);
+
+  if (self->free_buffer_wr && self->buffer_wr)
+    self->free_buffer_wr (self->buffer_wr);
+  if (self->free_buffer_rd && self->buffer_rd)
+    self->free_buffer_rd (self->buffer_rd);
+  self->buffer_wr = NULL;
+  self->buffer_rd = NULL;
+
+  g_slice_free (FpiSpiTransfer, self);
+}
+
+/**
+ * fpi_spi_transfer_ref:
+ * @self: A #FpiSpiTransfer
+ *
+ * Increments the reference count of @self by one.
+ *
+ * Returns: (transfer full): @self
+ */
+FpiSpiTransfer *
+fpi_spi_transfer_ref (FpiSpiTransfer *self)
+{
+  g_return_val_if_fail (self, NULL);
+  g_return_val_if_fail (self->ref_count, NULL);
+
+  g_atomic_int_inc (&self->ref_count);
+
+  return self;
+}
+
+/**
+ * fpi_spi_transfer_unref:
+ * @self: A #FpiSpiTransfer
+ *
+ * Decrements the reference count of @self by one, freeing the structure when
+ * the reference count reaches zero.
+ */
+void
+fpi_spi_transfer_unref (FpiSpiTransfer *self)
+{
+  g_return_if_fail (self);
+  g_return_if_fail (self->ref_count);
+
+  if (g_atomic_int_dec_and_test (&self->ref_count))
+    fpi_spi_transfer_free (self);
+}
+
+/**
+ * fpi_spi_transfer_write:
+ * @transfer: The #FpiSpiTransfer
+ * @length: The buffer size to allocate
+ *
+ * Prepare the write part of an SPI transfer allocating a new buffer
+ * internally that will be free'ed automatically.
+ */
+void
+fpi_spi_transfer_write (FpiSpiTransfer *transfer,
+                        gsize           length)
+{
+  fpi_spi_transfer_write_full (transfer,
+                               g_malloc0 (length),
+                               length,
+                               g_free);
+}
+
+/**
+ * fpi_spi_transfer_write_full:
+ * @transfer: The #FpiSpiTransfer
+ * @buffer: The data to write.
+ * @length: The size of @buffer
+ * @free_func: (destroy buffer): Destroy notify for @buffer
+ *
+ * Prepare the write part of an SPI transfer.
+ */
+void
+fpi_spi_transfer_write_full (FpiSpiTransfer *transfer,
+                             guint8         *buffer,
+                             gsize           length,
+                             GDestroyNotify  free_func)
+{
+  g_assert (buffer != NULL);
+  g_return_if_fail (transfer);
+
+  /* Write is always before read, so ensure both are NULL. */
+  g_return_if_fail (transfer->buffer_wr == NULL);
+  g_return_if_fail (transfer->buffer_rd == NULL);
+
+  transfer->buffer_wr = buffer;
+  transfer->length_wr = length;
+  transfer->free_buffer_wr = free_func;
+}
+
+/**
+ * fpi_spi_transfer_read:
+ * @transfer: The #FpiSpiTransfer
+ * @length: The buffer size to allocate
+ *
+ * Prepare the read part of an SPI transfer allocating a new buffer
+ * internally that will be free'ed automatically.
+ */
+void
+fpi_spi_transfer_read (FpiSpiTransfer *transfer,
+                       gsize           length)
+{
+  fpi_spi_transfer_read_full (transfer,
+                              g_malloc0 (length),
+                              length,
+                              g_free);
+}
+
+/**
+ * fpi_spi_transfer_read_full:
+ * @transfer: The #FpiSpiTransfer
+ * @buffer: Buffer to read data into.
+ * @length: The size of @buffer
+ * @free_func: (destroy buffer): Destroy notify for @buffer
+ *
+ * Prepare the read part of an SPI transfer.
+ */
+void
+fpi_spi_transfer_read_full (FpiSpiTransfer *transfer,
+                            guint8         *buffer,
+                            gsize           length,
+                            GDestroyNotify  free_func)
+{
+  g_assert (buffer != NULL);
+  g_return_if_fail (transfer);
+  g_return_if_fail (transfer->buffer_rd == NULL);
+
+  transfer->buffer_rd = buffer;
+  transfer->length_rd = length;
+  transfer->free_buffer_rd = free_func;
+}
+
+static void
+transfer_finish_cb (GObject *source_object, GAsyncResult *res, gpointer user_data)
+{
+  GTask *task = G_TASK (res);
+  FpiSpiTransfer *transfer = g_task_get_task_data (task);
+  GError *error = NULL;
+  FpiSpiTransferCallback callback;
+
+  g_task_propagate_boolean (task, &error);
+
+  log_transfer (transfer, FALSE, error);
+
+  callback = transfer->callback;
+  transfer->callback = NULL;
+  callback (transfer, transfer->device, transfer->user_data, error);
+}
+
+static int
+transfer_chunk (FpiSpiTransfer *transfer, gsize full_length, gsize *transferred)
+{
+  struct spi_ioc_transfer xfer[2] = { 0 };
+  gsize skip = *transferred;
+  gsize len = 0;
+  int transfers = 0;
+  int status;
+
+  if (transfer->buffer_wr)
+    {
+      if (skip < transfer->length_wr && len < block_size)
+        {
+          xfer[transfers].tx_buf = (gsize) transfer->buffer_wr + skip;
+          xfer[transfers].len = MIN (block_size, transfer->length_wr - skip);
+
+          len += xfer[transfers].len;
+          skip += xfer[transfers].len;
+
+          transfers += 1;
+        }
+
+      /* How much we need to skip in the next transfer. */
+      skip -= transfer->length_wr;
+    }
+
+  if (transfer->buffer_rd)
+    {
+      if (skip < transfer->length_rd && len < block_size)
+        {
+          xfer[transfers].rx_buf = (gsize) transfer->buffer_rd + skip;
+          xfer[transfers].len = MIN (block_size, transfer->length_rd - skip);
+
+          len += xfer[transfers].len;
+          /* skip += xfer[transfers].len; */
+
+          transfers += 1;
+        }
+
+      /* How much we need to skip in the next transfer. */
+      /* skip -= transfer->length_rd; */
+    }
+
+  g_assert (transfers > 0);
+
+  /* We have not transferred everything; ask driver to not deselect the chip.
+   * Unfortunately, this is inherently racy in case there are further devices
+   * on the same bus. In practice, it is hopefully unlikely to be an issue,
+   * but print a message once to help with debugging.
+   */
+  if (full_length < *transferred + len)
+    {
+      static gboolean warned = FALSE;
+
+      if (!warned)
+        {
+          g_message ("Split SPI transfer. In case of issues, try increasing the spidev buffer size.");
+          warned = TRUE;
+        }
+
+      xfer[transfers - 1].cs_change = TRUE;
+    }
+
+  /* This ioctl cannot be interrupted. */
+  status = ioctl (transfer->spidev_fd, SPI_IOC_MESSAGE (transfers), xfer);
+
+  if (status >= 0)
+    *transferred += len;
+
+  return status;
+}
+
+static void
+transfer_thread_func (GTask        *task,
+                      gpointer      source_object,
+                      gpointer      task_data,
+                      GCancellable *cancellable)
+{
+  FpiSpiTransfer *transfer = (FpiSpiTransfer *) task_data;
+  gsize full_length;
+  gsize transferred = 0;
+  int status = 0;
+
+  if (transfer->buffer_wr == NULL && transfer->buffer_rd == NULL)
+    {
+      g_task_return_new_error (task,
+                               G_IO_ERROR,
+                               G_IO_ERROR_INVALID_ARGUMENT,
+                               "Transfer with neither write or read!");
+      return;
+    }
+
+  full_length = 0;
+  if (transfer->buffer_wr)
+    full_length += transfer->length_wr;
+  if (transfer->buffer_rd)
+    full_length += transfer->length_rd;
+
+  while (transferred < full_length && status >= 0)
+    status = transfer_chunk (transfer, full_length, &transferred);
+
+  if (status < 0)
+    {
+      g_task_return_new_error (task,
+                               G_IO_ERROR,
+                               g_io_error_from_errno (errno),
+                               "Error invoking ioctl for SPI transfer (%d)",
+                               errno);
+    }
+  else
+    {
+      g_task_return_boolean (task, TRUE);
+    }
+}
+
+/**
+ * fpi_spi_transfer_submit:
+ * @transfer: (transfer full): The transfer to submit, must have been filled.
+ * @cancellable: Cancellable to use, e.g. fpi_device_get_cancellable()
+ * @callback: Callback on completion or error
+ * @user_data: Data to pass to callback
+ *
+ * Submit an SPI transfer with a specific timeout and callback functions.
+ *
+ * The underlying transfer cannot be cancelled. The current implementation
+ * will only call @callback after the transfer has been completed.
+ *
+ * Note that #FpiSpiTransfer will be stolen when this function is called.
+ * So that all associated data will be free'ed automatically, after the
+ * callback ran unless fpi_usb_transfer_ref() is explicitly called.
+ */
+void
+fpi_spi_transfer_submit (FpiSpiTransfer        *transfer,
+                         GCancellable          *cancellable,
+                         FpiSpiTransferCallback callback,
+                         gpointer               user_data)
+{
+  g_autoptr(GTask) task = NULL;
+
+  g_return_if_fail (transfer);
+  g_return_if_fail (callback);
+
+  /* Recycling is allowed, but not two at the same time. */
+  g_return_if_fail (transfer->callback == NULL);
+
+  transfer->callback = callback;
+  transfer->user_data = user_data;
+
+  log_transfer (transfer, TRUE, NULL);
+
+  task = g_task_new (transfer->device,
+                     cancellable,
+                     transfer_finish_cb,
+                     NULL);
+  g_task_set_task_data (task,
+                        g_steal_pointer (&transfer),
+                        (GDestroyNotify) fpi_spi_transfer_unref);
+
+  g_task_run_in_thread (task, transfer_thread_func);
+}
+
+/**
+ * fpi_spi_transfer_submit_sync:
+ * @transfer: The transfer to submit, must have been filled.
+ * @error: Location to store #GError to
+ *
+ * Synchronously submit an SPI transfer. Use of this function is discouraged
+ * as it will block all other operations in the application.
+ *
+ * Note that you still need to fpi_spi_transfer_unref() the
+ * #FpiSpiTransfer afterwards.
+ *
+ * Returns: #TRUE on success, otherwise #FALSE and @error will be set
+ */
+gboolean
+fpi_spi_transfer_submit_sync (FpiSpiTransfer *transfer,
+                              GError        **error)
+{
+  g_autoptr(GTask) task = NULL;
+  GError *err = NULL;
+  gboolean res;
+
+  g_return_val_if_fail (transfer, FALSE);
+
+  /* Recycling is allowed, but not two at the same time. */
+  g_return_val_if_fail (transfer->callback == NULL, FALSE);
+
+  log_transfer (transfer, TRUE, NULL);
+
+  task = g_task_new (transfer->device,
+                     NULL,
+                     NULL,
+                     NULL);
+  g_task_set_task_data (task,
+                        fpi_spi_transfer_ref (transfer),
+                        (GDestroyNotify) fpi_spi_transfer_unref);
+
+  g_task_run_in_thread_sync (task, transfer_thread_func);
+
+  res = g_task_propagate_boolean (task, &err);
+
+  log_transfer (transfer, FALSE, err);
+
+  g_propagate_error (error, err);
+
+  return res;
+}

libfprint/fpi-spi-transfer.h

@@ -0,0 +1,113 @@
+/*
+ * FPrint spidev transfer handling
+ * Copyright (C) 2019-2020 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
+
+#include "fpi-compat.h"
+#include "fpi-device.h"
+
+G_BEGIN_DECLS
+
+#define FPI_TYPE_SPI_TRANSFER (fpi_spi_transfer_get_type ())
+
+typedef struct _FpiSpiTransfer FpiSpiTransfer;
+typedef struct _FpiSsm         FpiSsm;
+
+typedef void (*FpiSpiTransferCallback)(FpiSpiTransfer *transfer,
+                                       FpDevice       *dev,
+                                       gpointer        user_data,
+                                       GError         *error);
+
+/**
+ * FpiSpiTransfer:
+ * @device: The #FpDevice that the transfer belongs to.
+ * @ssm: Storage slot to associate the transfer with a state machine.
+ *   Used by fpi_ssm_spi_transfer_cb() to modify the given state machine.
+ * @length_wr: The length of the write buffer
+ * @length_rd: The length of the read buffer
+ * @buffer_wr: The write buffer.
+ * @buffer_rd: The read buffer.
+ *
+ * Helper for handling SPI transfers. Currently transfers can either be pure
+ * write/read transfers or a write followed by a read (full duplex support
+ * can easily be added if desired).
+ */
+struct _FpiSpiTransfer
+{
+  /*< public >*/
+  FpDevice *device;
+
+  FpiSsm   *ssm;
+
+  gssize    length_wr;
+  gssize    length_rd;
+
+  guchar   *buffer_wr;
+  guchar   *buffer_rd;
+
+  /*< private >*/
+  guint ref_count;
+
+  int   spidev_fd;
+
+  /* Callbacks */
+  gpointer               user_data;
+  FpiSpiTransferCallback callback;
+
+  /* Data free function */
+  GDestroyNotify free_buffer_wr;
+  GDestroyNotify free_buffer_rd;
+};
+
+GType              fpi_spi_transfer_get_type (void) G_GNUC_CONST;
+FpiSpiTransfer     *fpi_spi_transfer_new (FpDevice *device,
+                                          int       spidev_fd);
+FpiSpiTransfer     *fpi_spi_transfer_ref (FpiSpiTransfer *self);
+void               fpi_spi_transfer_unref (FpiSpiTransfer *self);
+
+void               fpi_spi_transfer_write (FpiSpiTransfer *transfer,
+                                           gsize           length);
+
+FP_GNUC_ACCESS (read_only, 2, 3)
+void               fpi_spi_transfer_write_full (FpiSpiTransfer *transfer,
+                                                guint8         *buffer,
+                                                gsize           length,
+                                                GDestroyNotify  free_func);
+
+void               fpi_spi_transfer_read (FpiSpiTransfer *transfer,
+                                          gsize           length);
+
+FP_GNUC_ACCESS (write_only, 2, 3)
+void               fpi_spi_transfer_read_full (FpiSpiTransfer *transfer,
+                                               guint8         *buffer,
+                                               gsize           length,
+                                               GDestroyNotify  free_func);
+
+void               fpi_spi_transfer_submit (FpiSpiTransfer        *transfer,
+                                            GCancellable          *cancellable,
+                                            FpiSpiTransferCallback callback,
+                                            gpointer               user_data);
+
+gboolean           fpi_spi_transfer_submit_sync (FpiSpiTransfer *transfer,
+                                                 GError        **error);
+
+
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpiSpiTransfer, fpi_spi_transfer_unref)
+
+G_END_DECLS

libfprint/fpi-ssm.c

@@ -31,27 +31,24 @@
  * @short_description: State machine helpers
  *
  * Asynchronous driver design encourages some kind of state machine behind it.
- * In most cases, the state machine is entirely linear - you only go to the
- * next state, you never jump or go backwards. The #FpiSsm functions help you
- * implement such a machine.
+ * #FpiSsm provides a simple mechanism to implement a state machine, which
+ * is often entirely linear. You can however also jump to a specific state
+ * or do an early return from the SSM by completing it.
  *
- * e.g. `S1` ↦ `S2` ↦ `S3` ↦ `S4`
+ * e.g. `S1` ↦ `S2` ↦ `S3` ↦ `S4` ↦ `C1` ↦ `C2` ↦ `final`
  *
- * `S1` is the start state
- * There is also an implicit error state and an implicit accepting state
- * (both with implicit edges from every state).
+ * Where `S1` is the start state. The `C1` and later states are cleanup states
+ * that may be defined. The difference is that these states will never be
+ * skipped when marking the SSM as completed.
  *
- * You can also jump to any arbitrary state (while marking completion of the
- * current state) while the machine is running. In other words there are
- * implicit edges linking one state to every other state.
- *
- * To create an #fpi_ssm, you pass a state handler function and the total number of
- * states (4 in the above example) to fpi_ssm_new (). Note that the state numbers
- * start at zero, making them match the first value in a C enumeration.
+ * Use fpi_ssm_new() to create a new state machine with a defined number of
+ * states. Note that the state numbers start at zero, making them match the
+ * first value in a C enumeration.
  *
  * To start a ssm, you pass in a completion callback function to fpi_ssm_start()
- * which gets called when the ssm completes (both on error and on failure).
- * Starting a ssm also takes ownership of it.
+ * which gets called when the ssm completes (both on failure and on success).
+ * Starting a ssm also takes ownership of it and it will be automatically
+ * free'ed after the callback function has been called.
  *
  * To iterate to the next state, call fpi_ssm_next_state(). It is legal to
  * attempt to iterate beyond the final state - this is equivalent to marking
@@ -59,7 +56,6 @@
  *
  * To mark successful completion of a SSM, either iterate beyond the final
  * state or call fpi_ssm_mark_completed() from any state.
- * This will also invalidate the machine, freeing it.
  *
  * To mark failed completion of a SSM, call fpi_ssm_mark_failed() from any
  * state. You must pass a non-zero error code.
@@ -69,13 +65,9 @@
  * which operations to perform (a switch statement is appropriate).
  *
  * Typically, the state handling function fires off an asynchronous
- * communication with the device (such as a libsub transfer), and the
+ * communication with the device (such as a USB transfer), and the
  * callback function iterates the machine to the next state
  * upon success (or fails).
- *
- * Your completion callback should examine the return value of
- * fpi_ssm_get_error() in order to determine whether the #FpiSsm completed or
- * failed. An error code of zero indicates successful completion.
  */
 
 struct _FpiSsm
@@ -86,11 +78,11 @@ struct _FpiSsm
   gpointer                ssm_data;
   GDestroyNotify          ssm_data_destroy;
   int                     nr_states;
+  int                     start_cleanup;
   int                     cur_state;
   gboolean                completed;
+  gboolean                silence;
   GSource                *timeout;
-  GCancellable           *cancellable;
-  gulong                  cancellable_id;
   GError                 *error;
   FpiSsmCompletedCallback callback;
   FpiSsmHandlerCallback   handler;
@@ -104,8 +96,9 @@ struct _FpiSsm
  *
  * Allocate a new ssm, with @nr_states states. The @handler callback
  * will be called after each state transition.
- * This is a macro that calls fpi_ssm_new_full() using the stringified
- * version of @nr_states, so will work better with named parameters.
+ * This is a macro that calls fpi_ssm_new_full() using @nr_states as the
+ * cleanup states and using the stringified version of @nr_states. It should
+ * be used with an enum value.
  *
  * Returns: a new #FpiSsm state machine
  */
@@ -115,6 +108,7 @@ struct _FpiSsm
  * @dev: a #fp_dev fingerprint device
  * @handler: the callback function
  * @nr_states: the number of states
+ * @start_cleanup: the first cleanup state
  * @machine_name: the name of the state machine (for debug purposes)
  *
  * Allocate a new ssm, with @nr_states states. The @handler callback
@@ -126,17 +120,21 @@ FpiSsm *
 fpi_ssm_new_full (FpDevice             *dev,
                   FpiSsmHandlerCallback handler,
                   int                   nr_states,
+                  int                   start_cleanup,
                   const char           *machine_name)
 {
   FpiSsm *machine;
 
   BUG_ON (dev == NULL);
   BUG_ON (nr_states < 1);
+  BUG_ON (start_cleanup < 1);
+  BUG_ON (start_cleanup > nr_states);
   BUG_ON (handler == NULL);
 
   machine = g_new0 (FpiSsm, 1);
   machine->handler = handler;
   machine->nr_states = nr_states;
+  machine->start_cleanup = start_cleanup;
   machine->dev = dev;
   machine->name = g_strdup (machine_name);
   machine->completed = TRUE;
@@ -181,64 +179,34 @@ fpi_ssm_get_data (FpiSsm *machine)
   return machine->ssm_data;
 }
 
+/**
+ * fpi_ssm_get_device:
+ * @machine: an #FpiSsm state machine
+ *
+ * Retrieve the device that the SSM is for.
+ *
+ * Returns: #FpDevice
+ */
+FpDevice *
+fpi_ssm_get_device (FpiSsm *machine)
+{
+  g_return_val_if_fail (machine, NULL);
+
+  return machine->dev;
+}
+
 static void
 fpi_ssm_clear_delayed_action (FpiSsm *machine)
 {
   g_return_if_fail (machine);
 
-  if (machine->cancellable_id)
-    {
-      g_cancellable_disconnect (machine->cancellable, machine->cancellable_id);
-      machine->cancellable_id = 0;
-    }
-
-  g_clear_object (&machine->cancellable);
   g_clear_pointer (&machine->timeout, g_source_destroy);
 }
 
-typedef struct _CancelledActionIdleData
-{
-  gulong        cancellable_id;
-  GCancellable *cancellable;
-} CancelledActionIdleData;
-
-static gboolean
-on_delayed_action_cancelled_idle (gpointer user_data)
-{
-  CancelledActionIdleData *data = user_data;
-
-  g_cancellable_disconnect (data->cancellable, data->cancellable_id);
-  g_object_unref (data->cancellable);
-  g_free (data);
-
-  return G_SOURCE_REMOVE;
-}
-
-static void
-on_delayed_action_cancelled (GCancellable *cancellable,
-                             FpiSsm       *machine)
-{
-  CancelledActionIdleData *data;
-
-  fp_dbg ("[%s] %s cancelled delayed state change",
-          fp_device_get_driver (machine->dev), machine->name);
-
-  g_clear_pointer (&machine->timeout, g_source_destroy);
-
-  data = g_new0 (CancelledActionIdleData, 1);
-  data->cancellable = g_steal_pointer (&machine->cancellable);
-  data->cancellable_id = machine->cancellable_id;
-  machine->cancellable_id = 0;
-
-  g_idle_add_full (G_PRIORITY_HIGH_IDLE, on_delayed_action_cancelled_idle,
-                   data, NULL);
-}
-
 static void
 fpi_ssm_set_delayed_action_timeout (FpiSsm        *machine,
                                     int            delay,
                                     FpTimeoutFunc  callback,
-                                    GCancellable  *cancellable,
                                     gpointer       user_data,
                                     GDestroyNotify destroy_func)
 {
@@ -249,16 +217,6 @@ fpi_ssm_set_delayed_action_timeout (FpiSsm        *machine,
 
   fpi_ssm_clear_delayed_action (machine);
 
-  if (cancellable != NULL)
-    {
-      g_set_object (&machine->cancellable, cancellable);
-
-      machine->cancellable_id =
-        g_cancellable_connect (machine->cancellable,
-                               G_CALLBACK (on_delayed_action_cancelled),
-                               machine, NULL);
-    }
-
   machine->timeout = fpi_device_add_timeout (machine->dev, delay, callback,
                                              user_data, destroy_func);
 }
@@ -288,10 +246,11 @@ fpi_ssm_free (FpiSsm *machine)
 
 /* Invoke the state handler */
 static void
-__ssm_call_handler (FpiSsm *machine)
+__ssm_call_handler (FpiSsm *machine, gboolean force_msg)
 {
-  fp_dbg ("[%s] %s entering state %d", fp_device_get_driver (machine->dev),
-          machine->name, machine->cur_state);
+  if (force_msg || !machine->silence)
+    fp_dbg ("[%s] %s entering state %d", fp_device_get_driver (machine->dev),
+            machine->name, machine->cur_state);
   machine->handler (machine, machine->dev);
 }
 
@@ -318,7 +277,7 @@ fpi_ssm_start (FpiSsm *ssm, FpiSsmCompletedCallback callback)
   ssm->cur_state = 0;
   ssm->completed = FALSE;
   ssm->error = NULL;
-  __ssm_call_handler (ssm);
+  __ssm_call_handler (ssm, TRUE);
 }
 
 static void
@@ -364,11 +323,15 @@ fpi_ssm_start_subsm (FpiSsm *parent, FpiSsm *child)
  * @machine: an #FpiSsm state machine
  *
  * Mark a ssm as completed successfully. The callback set when creating
- * the state machine with fpi_ssm_new () will be called synchronously.
+ * the state machine with fpi_ssm_new() will be called synchronously.
+ *
+ * Note that any later cleanup state will still be executed.
  */
 void
 fpi_ssm_mark_completed (FpiSsm *machine)
 {
+  int next_state;
+
   g_return_if_fail (machine != NULL);
 
   BUG_ON (machine->completed);
@@ -376,6 +339,19 @@ fpi_ssm_mark_completed (FpiSsm *machine)
 
   fpi_ssm_clear_delayed_action (machine);
 
+  /* complete in a cleanup state just moves forward one step */
+  if (machine->cur_state < machine->start_cleanup)
+    next_state = machine->start_cleanup;
+  else
+    next_state = machine->cur_state + 1;
+
+  if (next_state < machine->nr_states)
+    {
+      machine->cur_state = next_state;
+      __ssm_call_handler (machine, TRUE);
+      return;
+    }
+
   machine->completed = TRUE;
 
   if (machine->error)
@@ -407,24 +383,21 @@ on_device_timeout_complete (FpDevice *dev,
  * fpi_ssm_mark_completed_delayed:
  * @machine: an #FpiSsm state machine
  * @delay: the milliseconds to wait before switching to the next state
- * @cancellable: (nullable): a #GCancellable to cancel the delayed operation
  *
  * Mark a ssm as completed successfully with a delay of @delay ms.
  * The callback set when creating the state machine with fpi_ssm_new () will be
  * called when the timeout is over.
- * The request can be cancelled passing a #GCancellable as @cancellable.
  */
 void
-fpi_ssm_mark_completed_delayed (FpiSsm       *machine,
-                                int           delay,
-                                GCancellable *cancellable)
+fpi_ssm_mark_completed_delayed (FpiSsm *machine,
+                                int     delay)
 {
   g_autofree char *source_name = NULL;
 
   g_return_if_fail (machine != NULL);
 
   fpi_ssm_set_delayed_action_timeout (machine, delay,
-                                      on_device_timeout_complete, cancellable,
+                                      on_device_timeout_complete,
                                       machine, NULL);
 
   source_name = g_strdup_printf ("[%s] ssm %s complete %d",
@@ -445,7 +418,9 @@ fpi_ssm_mark_failed (FpiSsm *machine, GError *error)
 {
   g_return_if_fail (machine != NULL);
   g_assert (error);
-  if (machine->error)
+
+  /* During cleanup it is OK to call fpi_ssm_mark_failed a second time */
+  if (machine->error && machine->cur_state < machine->start_cleanup)
     {
       fp_warn ("[%s] SSM %s already has an error set, ignoring new error %s",
                fp_device_get_driver (machine->dev), machine->name, error->message);
@@ -453,10 +428,15 @@ fpi_ssm_mark_failed (FpiSsm *machine, GError *error)
       return;
     }
 
-  fp_dbg ("[%s] SSM %s failed in state %d with error: %s",
+  fp_dbg ("[%s] SSM %s failed in state %d%s with error: %s",
           fp_device_get_driver (machine->dev), machine->name,
-          machine->cur_state, error->message);
-  machine->error = g_steal_pointer (&error);
+          machine->cur_state,
+          machine->cur_state >= machine->start_cleanup ? " (cleanup)" : "",
+          error->message);
+  if (!machine->error)
+    machine->error = g_steal_pointer (&error);
+  else
+    g_error_free (error);
   fpi_ssm_mark_completed (machine);
 }
 
@@ -482,7 +462,7 @@ fpi_ssm_next_state (FpiSsm *machine)
   if (machine->cur_state == machine->nr_states)
     fpi_ssm_mark_completed (machine);
   else
-    __ssm_call_handler (machine);
+    __ssm_call_handler (machine, FALSE);
 }
 
 void
@@ -512,25 +492,21 @@ on_device_timeout_next_state (FpDevice *dev,
  * fpi_ssm_next_state_delayed:
  * @machine: an #FpiSsm state machine
  * @delay: the milliseconds to wait before switching to the next state
- * @cancellable: (nullable): a #GCancellable to cancel the delayed operation
  *
  * Iterate to next state of a state machine with a delay of @delay ms. If the
  * current state is the last state, then the state machine will be marked as
  * completed, as if calling fpi_ssm_mark_completed().
- * Passing a valid #GCancellable will cause the action to be cancelled when
- * @cancellable is.
  */
 void
-fpi_ssm_next_state_delayed (FpiSsm       *machine,
-                            int           delay,
-                            GCancellable *cancellable)
+fpi_ssm_next_state_delayed (FpiSsm *machine,
+                            int     delay)
 {
   g_autofree char *source_name = NULL;
 
   g_return_if_fail (machine != NULL);
 
   fpi_ssm_set_delayed_action_timeout (machine, delay,
-                                      on_device_timeout_next_state, cancellable,
+                                      on_device_timeout_next_state,
                                       machine, NULL);
 
   source_name = g_strdup_printf ("[%s] ssm %s jump to next state %d",
@@ -554,13 +530,16 @@ fpi_ssm_jump_to_state (FpiSsm *machine, int state)
   g_return_if_fail (machine != NULL);
 
   BUG_ON (machine->completed);
-  BUG_ON (state < 0 || state >= machine->nr_states);
+  BUG_ON (state < 0 || state > machine->nr_states);
   BUG_ON (machine->timeout != NULL);
 
   fpi_ssm_clear_delayed_action (machine);
 
   machine->cur_state = state;
-  __ssm_call_handler (machine);
+  if (machine->cur_state == machine->nr_states)
+    fpi_ssm_mark_completed (machine);
+  else
+    __ssm_call_handler (machine, FALSE);
 }
 
 typedef struct
@@ -584,24 +563,20 @@ on_device_timeout_jump_to_state (FpDevice *dev,
  * @machine: an #FpiSsm state machine
  * @state: the state to jump to
  * @delay: the milliseconds to wait before switching to @state state
- * @cancellable: (nullable): a #GCancellable to cancel the delayed operation
  *
  * Jump to the @state state with a delay of @delay milliseconds, bypassing
  * intermediary states.
- * Passing a valid #GCancellable will cause the action to be cancelled when
- * @cancellable is.
  */
 void
-fpi_ssm_jump_to_state_delayed (FpiSsm       *machine,
-                               int           state,
-                               int           delay,
-                               GCancellable *cancellable)
+fpi_ssm_jump_to_state_delayed (FpiSsm *machine,
+                               int     state,
+                               int     delay)
 {
   FpiSsmJumpToStateDelayedData *data;
   g_autofree char *source_name = NULL;
 
   g_return_if_fail (machine != NULL);
-  BUG_ON (state < 0 || state >= machine->nr_states);
+  BUG_ON (state < 0 || state > machine->nr_states);
 
   data = g_new0 (FpiSsmJumpToStateDelayedData, 1);
   data->machine = machine;
@@ -609,7 +584,7 @@ fpi_ssm_jump_to_state_delayed (FpiSsm       *machine,
 
   fpi_ssm_set_delayed_action_timeout (machine, delay,
                                       on_device_timeout_jump_to_state,
-                                      cancellable, data, g_free);
+                                      data, g_free);
 
   source_name = g_strdup_printf ("[%s] ssm %s jump to state %d",
                                  fp_device_get_device_id (machine->dev),
@@ -669,6 +644,22 @@ fpi_ssm_dup_error (FpiSsm *machine)
   return NULL;
 }
 
+/**
+ * fpi_ssm_silence_debug:
+ * @machine: an #FpiSsm state machine
+ *
+ * Turn off state change debug messages from this SSM. This does not disable
+ * all messages, as e.g. the initial state, SSM completion and cleanup states
+ * are still printed out.
+ *
+ * Use if the SSM loops and would flood the debug log otherwise.
+ */
+void
+fpi_ssm_silence_debug (FpiSsm *machine)
+{
+  machine->silence = TRUE;
+}
+
 /**
  * fpi_ssm_usb_transfer_cb:
  * @transfer: a #FpiUsbTransfer
@@ -721,3 +712,56 @@ fpi_ssm_usb_transfer_with_weak_pointer_cb (FpiUsbTransfer *transfer,
 
   fpi_ssm_usb_transfer_cb (transfer, device, weak_ptr, error);
 }
+
+/**
+ * fpi_ssm_spi_transfer_cb:
+ * @transfer: a #FpiSpiTransfer
+ * @device: a #FpDevice
+ * @unused_data: User data (unused)
+ * @error: The #GError or %NULL
+ *
+ * Can be used in as a #FpiSpiTransfer callback handler to automatically
+ * advance or fail a statemachine on transfer completion.
+ *
+ * Make sure to set the #FpiSsm on the transfer.
+ */
+void
+fpi_ssm_spi_transfer_cb (FpiSpiTransfer *transfer, FpDevice *device,
+                         gpointer unused_data, GError *error)
+{
+  g_return_if_fail (transfer->ssm);
+
+  if (error)
+    fpi_ssm_mark_failed (transfer->ssm, error);
+  else
+    fpi_ssm_next_state (transfer->ssm);
+}
+
+/**
+ * fpi_ssm_spi_transfer_with_weak_pointer_cb:
+ * @transfer: a #FpiSpiTransfer
+ * @device: a #FpDevice
+ * @weak_ptr: A #gpointer pointer to nullify. You can pass a pointer to any
+ *            #gpointer to nullify when the callback is completed. I.e a
+ *            pointer to the current #FpiSpiTransfer.
+ * @error: The #GError or %NULL
+ *
+ * Can be used in as a #FpiSpiTransfer callback handler to automatically
+ * advance or fail a statemachine on transfer completion.
+ * Passing a #gpointer* as @weak_ptr permits to nullify it once we're done
+ * with the transfer.
+ *
+ * Make sure to set the #FpiSsm on the transfer.
+ */
+void
+fpi_ssm_spi_transfer_with_weak_pointer_cb (FpiSpiTransfer *transfer,
+                                           FpDevice *device, gpointer weak_ptr,
+                                           GError *error)
+{
+  g_return_if_fail (transfer->ssm);
+
+  if (weak_ptr)
+    g_nullify_pointer ((gpointer *) weak_ptr);
+
+  fpi_ssm_spi_transfer_cb (transfer, device, weak_ptr, error);
+}

libfprint/fpi-ssm.h

@@ -60,10 +60,11 @@ typedef void (*FpiSsmHandlerCallback)(FpiSsm   *ssm,
 
 /* for library and drivers */
 #define fpi_ssm_new(dev, handler, nr_states) \
-  fpi_ssm_new_full (dev, handler, nr_states, #nr_states)
+  fpi_ssm_new_full (dev, handler, nr_states, nr_states, #nr_states)
 FpiSsm *fpi_ssm_new_full (FpDevice             *dev,
                           FpiSsmHandlerCallback handler,
                           int                   nr_states,
+                          int                   start_cleanup,
                           const char           *machine_name);
 void fpi_ssm_free (FpiSsm *machine);
 void fpi_ssm_start (FpiSsm                 *ssm,
@@ -75,28 +76,28 @@ void fpi_ssm_start_subsm (FpiSsm *parent,
 void fpi_ssm_next_state (FpiSsm *machine);
 void fpi_ssm_jump_to_state (FpiSsm *machine,
                             int     state);
-void fpi_ssm_next_state_delayed (FpiSsm       *machine,
-                                 int           delay,
-                                 GCancellable *cancellable);
-void fpi_ssm_jump_to_state_delayed (FpiSsm       *machine,
-                                    int           state,
-                                    int           delay,
-                                    GCancellable *cancellable);
+void fpi_ssm_next_state_delayed (FpiSsm *machine,
+                                 int     delay);
+void fpi_ssm_jump_to_state_delayed (FpiSsm *machine,
+                                    int     state,
+                                    int     delay);
 void fpi_ssm_cancel_delayed_state_change (FpiSsm *machine);
 void fpi_ssm_mark_completed (FpiSsm *machine);
-void fpi_ssm_mark_completed_delayed (FpiSsm       *machine,
-                                     int           delay,
-                                     GCancellable *cancellable);
+void fpi_ssm_mark_completed_delayed (FpiSsm *machine,
+                                     int     delay);
 void fpi_ssm_mark_failed (FpiSsm *machine,
                           GError *error);
 void fpi_ssm_set_data (FpiSsm        *machine,
                        gpointer       ssm_data,
                        GDestroyNotify ssm_data_destroy);
 gpointer fpi_ssm_get_data (FpiSsm *machine);
+FpDevice * fpi_ssm_get_device (FpiSsm *machine);
 GError * fpi_ssm_get_error (FpiSsm *machine);
 GError * fpi_ssm_dup_error (FpiSsm *machine);
 int fpi_ssm_get_cur_state (FpiSsm *machine);
 
+void fpi_ssm_silence_debug (FpiSsm *machine);
+
 /* Callbacks to be used by the driver instead of implementing their own
  * logic.
  */
@@ -111,4 +112,15 @@ void fpi_ssm_usb_transfer_with_weak_pointer_cb (FpiUsbTransfer *transfer,
                                                 gpointer        weak_ptr,
                                                 GError         *error);
 
+typedef struct _FpiSpiTransfer FpiSpiTransfer;
+
+void fpi_ssm_spi_transfer_cb (FpiSpiTransfer *transfer,
+                              FpDevice       *device,
+                              gpointer        unused_data,
+                              GError         *error);
+void fpi_ssm_spi_transfer_with_weak_pointer_cb (FpiSpiTransfer *transfer,
+                                                FpDevice       *device,
+                                                gpointer        weak_ptr,
+                                                GError         *error);
+
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpiSsm, fpi_ssm_free)

libfprint/fpi-usb-transfer.c

@@ -354,9 +354,10 @@ transfer_finish_cb (GObject *source_object, GAsyncResult *res, gpointer user_dat
   fpi_usb_transfer_unref (transfer);
 }
 
-static gboolean
-transfer_cancel_cb (FpiUsbTransfer *transfer)
+static void
+transfer_cancel_cb (FpDevice *device, gpointer user_data)
 {
+  FpiUsbTransfer *transfer = user_data;
   GError *error;
   FpiUsbTransferCallback callback;
 
@@ -369,8 +370,6 @@ transfer_cancel_cb (FpiUsbTransfer *transfer)
   callback (transfer, transfer->device, transfer->user_data, error);
 
   fpi_usb_transfer_unref (transfer);
-
-  return G_SOURCE_REMOVE;
 }
 
 /**
@@ -413,7 +412,8 @@ fpi_usb_transfer_submit (FpiUsbTransfer        *transfer,
    */
   if (cancellable && g_cancellable_is_cancelled (cancellable))
     {
-      g_idle_add ((GSourceFunc) transfer_cancel_cb, transfer);
+      fpi_device_add_timeout (transfer->device, 0,
+                              transfer_cancel_cb, transfer, NULL);
       return;
     }
 

libfprint/fprint-list-supported-devices.c

@@ -28,8 +28,8 @@
 
 GHashTable *printed = NULL;
 
-static GList *
-insert_drivers (GList *list)
+static void
+insert_drivers (GList **usb_list, GList **spi_list)
 {
   g_autoptr(GArray) drivers = fpi_get_driver_types ();
   gint i;
@@ -41,34 +41,70 @@ insert_drivers (GList *list)
       g_autoptr(FpDeviceClass) cls = g_type_class_ref (driver);
       const FpIdEntry *entry;
 
-      if (cls->type != FP_DEVICE_TYPE_USB)
-        continue;
-
-      for (entry = cls->id_table; entry->vid; entry++)
+      switch (cls->type)
         {
-          char *key;
+        case FP_DEVICE_TYPE_USB:
 
-          key = g_strdup_printf ("%04x:%04x", entry->vid, entry->pid);
-
-          if (g_hash_table_lookup (printed, key) != NULL)
+          for (entry = cls->id_table; entry->vid; entry++)
             {
-              g_free (key);
-              continue;
+              char *key;
+
+              key = g_strdup_printf ("%04x:%04x", entry->vid, entry->pid);
+
+              if (g_hash_table_lookup (printed, key) != NULL)
+                {
+                  g_free (key);
+                  continue;
+                }
+
+              g_hash_table_insert (printed, key, GINT_TO_POINTER (1));
+
+              *usb_list = g_list_prepend (*usb_list,
+                                          g_strdup_printf ("%s | %s\n", key, cls->full_name));
             }
+          break;
 
-          g_hash_table_insert (printed, key, GINT_TO_POINTER (1));
+        case FP_DEVICE_TYPE_UDEV:
+          for (entry = cls->id_table; entry->udev_types; entry++)
+            {
+              char *key;
 
-          list = g_list_prepend (list, g_strdup_printf ("%s | %s\n", key, cls->full_name));
+              /* Need SPI device */
+              if ((entry->udev_types & FPI_DEVICE_UDEV_SUBTYPE_SPIDEV) == 0)
+                continue;
+
+              key = g_strdup_printf ("SPI:%s:%04x:%04x", entry->spi_acpi_id, entry->hid_id.vid, entry->hid_id.pid);
+
+              if (g_hash_table_lookup (printed, key) != NULL)
+                {
+                  g_free (key);
+                  continue;
+                }
+
+              g_hash_table_insert (printed, key, GINT_TO_POINTER (1));
+
+              if (entry->udev_types & FPI_DEVICE_UDEV_SUBTYPE_HIDRAW)
+                *spi_list = g_list_prepend (*spi_list,
+                                            g_strdup_printf ("%s | %04x:%04x | %s\n", entry->spi_acpi_id, entry->hid_id.vid, entry->hid_id.pid, cls->full_name));
+              else
+                *spi_list = g_list_prepend (*spi_list,
+                                            g_strdup_printf ("%s | - | %s\n", entry->spi_acpi_id, cls->full_name));
+            }
+          break;
+
+        case FP_DEVICE_TYPE_VIRTUAL:
+        default:
+          break;
         }
     }
-
-  return list;
 }
 
 int
 main (int argc, char **argv)
 {
-  GList *list, *l;
+  GList *usb_list = NULL;
+  GList *spi_list = NULL;
+  GList *l;
 
   setlocale (LC_ALL, "");
 
@@ -83,19 +119,36 @@ main (int argc, char **argv)
   g_print ("\n");
   g_print ("This is a list of supported devices in libfprint's development version. Those drivers might not all be available in the stable, released version. If in doubt, contact your distribution or systems integrator for details.\n");
   g_print ("\n");
+
+  insert_drivers (&usb_list, &spi_list);
+
   g_print ("## USB devices\n");
   g_print ("\n");
   g_print ("USB ID | Driver\n");
   g_print ("------------ | ------------\n");
 
-  list = NULL;
-  list = insert_drivers (list);
-
-  list = g_list_sort (list, (GCompareFunc) g_strcmp0);
-  for (l = list; l != NULL; l = l->next)
+  usb_list = g_list_sort (usb_list, (GCompareFunc) g_strcmp0);
+  for (l = usb_list; l != NULL; l = l->next)
     g_print ("%s", (char *) l->data);
+  g_print ("\n");
+
+  g_list_free_full (usb_list, g_free);
+
+  g_print ("## SPI devices\n");
+  g_print ("\n");
+  g_print ("The ACPI ID represents the SPI interface. Some sensors are also connected to a HID device (Human Input Device) for side-channel requests such as resets.\n");
+  g_print ("\n");
+  g_print ("ACPI ID | HID ID | Driver\n");
+  g_print ("------------ | ------------ | ------------\n");
+
+  spi_list = g_list_sort (spi_list, (GCompareFunc) g_strcmp0);
+  for (l = spi_list; l != NULL; l = l->next)
+    g_print ("%s", (char *) l->data);
+  g_print ("\n");
+
+  g_list_free_full (usb_list, g_free);
+
 
-  g_list_free_full (list, g_free);
   g_hash_table_destroy (printed);
 
   return 0;

libfprint/fprint-list-udev-hwdb.c

@@ -29,30 +29,52 @@ static const FpIdEntry whitelist_id_table[] = {
    * You can generate this list from the wiki page using e.g.:
    *   gio cat https://gitlab.freedesktop.org/libfprint/wiki/-/wikis/Unsupported-Devices.md | sed -n 's!|.*\([0-9a-fA-F]\{4\}\):\([0-9a-fA-F]\{4\}\).*|.*!  { .vid = 0x\1, .pid = 0x\2 },!p'
    */
+  { .vid = 0x04e8, .pid = 0x730b },
   { .vid = 0x04f3, .pid = 0x036b },
   { .vid = 0x04f3, .pid = 0x0c00 },
-  { .vid = 0x04f3, .pid = 0x0c4b },
   { .vid = 0x04f3, .pid = 0x0c4c },
-  { .vid = 0x04f3, .pid = 0x0c4f },
   { .vid = 0x04f3, .pid = 0x0c57 },
+  { .vid = 0x04f3, .pid = 0x0c5e },
+  { .vid = 0x04f3, .pid = 0x0c5a },
+  { .vid = 0x04f3, .pid = 0x0c70 },
+  { .vid = 0x04f3, .pid = 0x0c72 },
   { .vid = 0x04f3, .pid = 0x2706 },
+  { .vid = 0x04f3, .pid = 0x3057 },
+  { .vid = 0x04f3, .pid = 0x3104 },
+  { .vid = 0x04f3, .pid = 0x310d },
   { .vid = 0x06cb, .pid = 0x0081 },
   { .vid = 0x06cb, .pid = 0x0088 },
   { .vid = 0x06cb, .pid = 0x008a },
   { .vid = 0x06cb, .pid = 0x009a },
   { .vid = 0x06cb, .pid = 0x009b },
   { .vid = 0x06cb, .pid = 0x00a2 },
+  { .vid = 0x06cb, .pid = 0x00a8 },
   { .vid = 0x06cb, .pid = 0x00b7 },
   { .vid = 0x06cb, .pid = 0x00bb },
   { .vid = 0x06cb, .pid = 0x00be },
+  { .vid = 0x06cb, .pid = 0x00c4 },
   { .vid = 0x06cb, .pid = 0x00cb },
+  { .vid = 0x06cb, .pid = 0x00c9 },
   { .vid = 0x06cb, .pid = 0x00d8 },
   { .vid = 0x06cb, .pid = 0x00da },
+  { .vid = 0x06cb, .pid = 0x00dc },
+  { .vid = 0x06cb, .pid = 0x00e4 },
+  { .vid = 0x06cb, .pid = 0x00e7 },
+  { .vid = 0x06cb, .pid = 0x00e9 },
+  { .vid = 0x06cb, .pid = 0x00fd },
   { .vid = 0x0a5c, .pid = 0x5801 },
   { .vid = 0x0a5c, .pid = 0x5805 },
   { .vid = 0x0a5c, .pid = 0x5834 },
+  { .vid = 0x0a5c, .pid = 0x5840 },
+  { .vid = 0x0a5c, .pid = 0x5841 },
+  { .vid = 0x0a5c, .pid = 0x5842 },
   { .vid = 0x0a5c, .pid = 0x5843 },
+  { .vid = 0x0a5c, .pid = 0x5844 },
+  { .vid = 0x0a5c, .pid = 0x5845 },
+  { .vid = 0x0bda, .pid = 0x5812 },
   { .vid = 0x10a5, .pid = 0x0007 },
+  { .vid = 0x10a5, .pid = 0x9200 },
+  { .vid = 0x10a5, .pid = 0x9800 },
   { .vid = 0x1188, .pid = 0x9545 },
   { .vid = 0x138a, .pid = 0x0007 },
   { .vid = 0x138a, .pid = 0x003a },
@@ -60,7 +82,6 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0x138a, .pid = 0x003d },
   { .vid = 0x138a, .pid = 0x003f },
   { .vid = 0x138a, .pid = 0x0090 },
-  { .vid = 0x138a, .pid = 0x0091 },
   { .vid = 0x138a, .pid = 0x0092 },
   { .vid = 0x138a, .pid = 0x0094 },
   { .vid = 0x138a, .pid = 0x0097 },
@@ -70,28 +91,38 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0x1491, .pid = 0x0088 },
   { .vid = 0x16d1, .pid = 0x1027 },
   { .vid = 0x1c7a, .pid = 0x0300 },
-  { .vid = 0x1c7a, .pid = 0x0570 },
   { .vid = 0x1c7a, .pid = 0x0575 },
+  { .vid = 0x1c7a, .pid = 0x0576 },
   { .vid = 0x27c6, .pid = 0x5042 },
   { .vid = 0x27c6, .pid = 0x5110 },
   { .vid = 0x27c6, .pid = 0x5117 },
+  { .vid = 0x27c6, .pid = 0x5120 },
+  { .vid = 0x27c6, .pid = 0x5125 },
   { .vid = 0x27c6, .pid = 0x5201 },
   { .vid = 0x27c6, .pid = 0x521d },
   { .vid = 0x27c6, .pid = 0x5301 },
   { .vid = 0x27c6, .pid = 0x530c },
   { .vid = 0x27c6, .pid = 0x532d },
+  { .vid = 0x27c6, .pid = 0x5335 },
   { .vid = 0x27c6, .pid = 0x533c },
   { .vid = 0x27c6, .pid = 0x5381 },
   { .vid = 0x27c6, .pid = 0x5385 },
   { .vid = 0x27c6, .pid = 0x538c },
   { .vid = 0x27c6, .pid = 0x538d },
   { .vid = 0x27c6, .pid = 0x5395 },
+  { .vid = 0x27c6, .pid = 0x5503 },
+  { .vid = 0x27c6, .pid = 0x550a },
+  { .vid = 0x27c6, .pid = 0x550c },
   { .vid = 0x27c6, .pid = 0x5584 },
   { .vid = 0x27c6, .pid = 0x55a2 },
   { .vid = 0x27c6, .pid = 0x55a4 },
   { .vid = 0x27c6, .pid = 0x55b4 },
   { .vid = 0x27c6, .pid = 0x5740 },
+  { .vid = 0x27c6, .pid = 0x5e0a },
+  { .vid = 0x27c6, .pid = 0x581a },
   { .vid = 0x2808, .pid = 0x9338 },
+  { .vid = 0x2808, .pid = 0x93a9 },
+  { .vid = 0x298d, .pid = 0x2020 },
   { .vid = 0x298d, .pid = 0x2033 },
   { .vid = 0x3538, .pid = 0x0930 },
   { .vid = 0 },
@@ -161,7 +192,10 @@ print_driver (const FpDeviceClass *cls)
     }
 
   if (num_printed > 0)
-    g_print (" ID_AUTOSUSPEND=1\n");
+    {
+      g_print (" ID_AUTOSUSPEND=1\n");
+      g_print (" ID_PERSIST=0\n");
+    }
 }
 
 static int

libfprint/fprint-list-udev-rules.c

@@ -0,0 +1,93 @@
+/*
+ * Copyright (C) 2009 Red Hat <mjg@redhat.com>
+ * Copyright (C) 2008 Bastien Nocera <hadess@hadess.net>
+ * Copyright (C) 2008 Timo Hoenig <thoenig@suse.de>, <thoenig@nouse.net>
+ * Coypright (C) 2019 Benjamin Berg <bberg@redhat.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include <config.h>
+
+#include "fpi-context.h"
+#include "fpi-device.h"
+
+GHashTable *printed = NULL;
+
+static void
+print_driver (const FpDeviceClass *cls)
+{
+  const FpIdEntry *entry;
+  gint num_printed = 0;
+
+  if (cls->type != FP_DEVICE_TYPE_UDEV)
+    return;
+
+  for (entry = cls->id_table; entry->udev_types != 0; entry++)
+    {
+      /* We only add rules for spidev right now. */
+      if ((entry->udev_types & FPI_DEVICE_UDEV_SUBTYPE_SPIDEV) == 0)
+        continue;
+
+      if (g_hash_table_lookup (printed, entry->spi_acpi_id) != NULL)
+        continue;
+
+      g_hash_table_insert (printed, g_strdup (entry->spi_acpi_id), GINT_TO_POINTER (1));
+
+      if (num_printed == 0)
+        g_print ("# %s\n", cls->full_name);
+
+      g_print ("ACTION==\"add|change\", SUBSYSTEM==\"spi\", ENV{MODALIAS}==\"acpi:%s:\", RUN{builtin}+=\"kmod load spi:spidev\", RUN+=\"/bin/sh -c 'echo spidev > %%S%%p/driver_override && echo %%k > %%S%%p/subsystem/drivers/spidev/bind'\"\n",
+               entry->spi_acpi_id);
+      num_printed++;
+    }
+
+  if (num_printed > 0)
+    g_print ("\n");
+}
+
+int
+main (int argc, char **argv)
+{
+  g_autoptr(GArray) drivers = fpi_get_driver_types ();
+  guint i;
+
+  printed = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+
+  g_print ("# This file is part of libfprint\n");
+  g_print ("# Do not modify this file, it will get overwritten on updates.\n");
+  g_print ("# To override or extend the rules place a file in /etc/udev/rules.d\n");
+  g_print ("\n");
+
+  for (i = 0; i < drivers->len; i++)
+    {
+      GType driver = g_array_index (drivers, GType, i);
+      FpDeviceClass *cls = FP_DEVICE_CLASS (g_type_class_ref (driver));
+
+      if (cls->type != FP_DEVICE_TYPE_UDEV)
+        {
+          g_type_class_unref (cls);
+          continue;
+        }
+
+      print_driver (cls);
+
+      g_type_class_unref (cls);
+    }
+
+  g_hash_table_destroy (printed);
+
+  return 0;
+}

libfprint/meson.build

@@ -16,6 +16,7 @@ libfprint_private_sources = [
     'fpi-print.c',
     'fpi-ssm.c',
     'fpi-usb-transfer.c',
+    'fpi-spi-transfer.c',
 ]
 
 libfprint_public_headers = [
@@ -40,6 +41,7 @@ libfprint_private_headers = [
     'fpi-minutiae.h',
     'fpi-print.h',
     'fpi-usb-transfer.h',
+    'fpi-spi-transfer.h',
     'fpi-ssm.h',
 ]
 
@@ -78,117 +80,93 @@ nbis_sources = [
     'nbis/mindtct/xytreps.c',
 ]
 
-aeslib = false
-aesx660 = false
-aes3k = false
+driver_sources = {
+    'upekts' :
+        [ 'drivers/upekts.c', 'drivers/upek_proto.c' ],
+    'upektc' :
+        [ 'drivers/upektc.c' ],
+    'upeksonly' :
+        [ 'drivers/upeksonly.c' ],
+    'uru4000' :
+        [ 'drivers/uru4000.c' ],
+    'aes1610' :
+        [ 'drivers/aes1610.c' ],
+    'aes1660' :
+        [ 'drivers/aes1660.c' ],
+    'aes2501' :
+        [ 'drivers/aes2501.c' ],
+    'aes2550' :
+        [ 'drivers/aes2550.c' ],
+    'aes2660' :
+        [ 'drivers/aes2660.c' ],
+    'aes3500' :
+        [ 'drivers/aes3500.c' ],
+    'aes4000' :
+        [ 'drivers/aes4000.c' ],
+    'vcom5s' :
+        [ 'drivers/vcom5s.c' ],
+    'vfs101' :
+        [ 'drivers/vfs101.c' ],
+    'vfs301' :
+        [ 'drivers/vfs301.c', 'drivers/vfs301_proto.c' ],
+    'vfs5011' :
+        [ 'drivers/vfs5011.c' ],
+    'vfs7552' :
+        [ 'drivers/vfs7552.c' ],
+    'upektc_img' :
+        [ 'drivers/upektc_img.c',  'drivers/upek_proto.c' ],
+    'etes603' :
+        [ 'drivers/etes603.c' ],
+    'egis0570' :
+        [ 'drivers/egis0570.c' ],
+    'vfs0050' :
+        [ 'drivers/vfs0050.c' ],
+    'elan' :
+        [ 'drivers/elan.c' ],
+    'elanmoc' :
+        [ 'drivers/elanmoc/elanmoc.c' ],
+    'elanspi' :
+        [ 'drivers/elanspi.c' ],
+    'nb1010' :
+        [ 'drivers/nb1010.c' ],
+    'virtual_image' :
+        [ 'drivers/virtual-image.c' ],
+    'virtual_device' :
+        [ 'drivers/virtual-device.c' ],
+    'virtual_device_storage' :
+        [ 'drivers/virtual-device-storage.c' ],
+    'synaptics' :
+        [ 'drivers/synaptics/synaptics.c', 'drivers/synaptics/bmkt_message.c' ],
+    'goodixmoc' :
+        [ 'drivers/goodixmoc/goodix.c', 'drivers/goodixmoc/goodix_proto.c' ],
+    'fpcmoc' :
+        [ 'drivers/fpcmoc/fpc.c' ],
+}
+
+helper_sources = {
+    'aeslib' :
+        [ 'drivers/aeslib.c' ],
+    'aesx660' :
+        [ 'drivers/aesx660.c' ],
+    'aes3k' :
+        [ 'drivers/aes3k.c' ],
+    'nss' :
+        [ ],
+    'udev' :
+        [ ],
+    'virtual' :
+        [ 'drivers/virtual-device-listener.c' ],
+}
+
 drivers_sources = []
 drivers_cflags = []
 foreach driver: drivers
-    if driver == 'upekts'
-        drivers_sources += [ 'drivers/upekts.c', 'drivers/upek_proto.c' ]
-    endif
-    if driver == 'upektc'
-        drivers_sources += [ 'drivers/upektc.c' ]
-    endif
-    if driver == 'upeksonly'
-        drivers_sources += [ 'drivers/upeksonly.c' ]
-    endif
-    if driver == 'uru4000'
-        drivers_sources += [ 'drivers/uru4000.c' ]
-    endif
-    if driver == 'aes1610'
-        drivers_sources += [ 'drivers/aes1610.c' ]
-        aeslib = true
-    endif
-    if driver == 'aes1660'
-        drivers_sources += [ 'drivers/aes1660.c' ]
-        aeslib = true
-        aesx660 = true
-    endif
-    if driver == 'aes2501'
-        drivers_sources += [ 'drivers/aes2501.c' ]
-        aeslib = true
-    endif
-    if driver == 'aes2550'
-        drivers_sources += [ 'drivers/aes2550.c' ]
-        aeslib = true
-    endif
-    if driver == 'aes2660'
-        drivers_sources += [ 'drivers/aes2660.c' ]
-        aeslib = true
-        aesx660 = true
-    endif
-    if driver == 'aes3500'
-        drivers_sources += [ 'drivers/aes3500.c' ]
-        aeslib = true
-        aes3k = true
-    endif
-    if driver == 'aes4000'
-        drivers_sources += [ 'drivers/aes4000.c' ]
-        aeslib = true
-        aes3k = true
-    endif
-    if driver == 'vcom5s'
-        drivers_sources += [ 'drivers/vcom5s.c' ]
-    endif
-    if driver == 'vfs101'
-        drivers_sources += [ 'drivers/vfs101.c' ]
-    endif
-    if driver == 'vfs301'
-        drivers_sources += [ 'drivers/vfs301.c', 'drivers/vfs301_proto.c' ]
-    endif
-    if driver == 'vfs5011'
-        drivers_sources += [ 'drivers/vfs5011.c' ]
-    endif
-    if driver == 'upektc_img'
-        drivers_sources += [ 'drivers/upektc_img.c',  'drivers/upek_proto.c' ]
-    endif
-    if driver == 'etes603'
-        drivers_sources += [ 'drivers/etes603.c' ]
-    endif
-    if driver == 'vfs0050'
-        drivers_sources += [ 'drivers/vfs0050.c' ]
-    endif
-    if driver == 'elan'
-        drivers_sources += [ 'drivers/elan.c' ]
-    endif
-    if driver == 'virtual_image'
-        drivers_sources += [ 'drivers/virtual-image.c' ]
-    endif
-    if driver == 'virtual_device'
-        drivers_sources += [ 'drivers/virtual-device.c' ]
-    endif
-    if driver == 'virtual_device_storage'
-        drivers_sources += [ 'drivers/virtual-device-storage.c' ]
-    endif
-    if driver.startswith('virtual_')
-        drivers_sources += [ 'drivers/virtual-device-listener.c' ]
-    endif
-    if driver == 'synaptics'
-    drivers_sources += [
-        'drivers/synaptics/synaptics.c',
-        'drivers/synaptics/bmkt_message.c',
-    ]
-    endif
-    if driver == 'goodixmoc'
-    drivers_sources += [
-        'drivers/goodixmoc/goodix.c',
-        'drivers/goodixmoc/goodix_proto.c',
-    ]
-    endif
+    drivers_sources += driver_sources[driver]
+endforeach
+foreach helper : driver_helpers
+    drivers_sources += helper_sources[helper]
 endforeach
 
-if aeslib
-    drivers_sources += [ 'drivers/aeslib.c' ]
-endif
-if aesx660
-    drivers_sources += ['drivers/aesx660.c' ]
-endif
-if aes3k
-    drivers_sources += ['drivers/aes3k.c' ]
-endif
-
-other_sources = []
 
 fp_enums = gnome.mkenums_simple('fp-enums',
     sources: libfprint_public_headers,
@@ -207,6 +185,28 @@ enums_dep = declare_dependency(
     sources: [ fp_enums_h, fpi_enums_h ]
 )
 
+# Export the drivers' types to the core code
+drivers_type_list = []
+drivers_type_func = []
+drivers_type_list += '#include <glib-object.h>'
+drivers_type_list += '#include "fpi-context.h"'
+drivers_type_list += ''
+drivers_type_func += 'GArray *'
+drivers_type_func += 'fpi_get_driver_types (void)'
+drivers_type_func += '{'
+drivers_type_func += '  GArray *drivers = g_array_new (TRUE, FALSE, sizeof (GType));'
+drivers_type_func += '  GType t;'
+drivers_type_func += ''
+foreach driver: supported_drivers
+    drivers_type_list += 'extern GType (fpi_device_' + driver + '_get_type) (void);'
+    drivers_type_func += '  t = fpi_device_' + driver + '_get_type ();'
+    drivers_type_func += '  g_array_append_val (drivers, t);'
+    drivers_type_func += ''
+endforeach
+drivers_type_list += ''
+drivers_type_func += '  return drivers;'
+drivers_type_func += '}'
+
 drivers_sources += configure_file(input: 'empty_file',
     output: 'fpi-drivers.c',
     capture: true,
@@ -221,10 +221,8 @@ deps = [
     glib_dep,
     gobject_dep,
     gusb_dep,
-    imaging_dep,
     mathlib_dep,
-    nss_dep,
-]
+] + optional_deps
 
 # These are empty and only exist so that the include directories are created
 # in the build tree. This silences a build time warning.
@@ -271,7 +269,6 @@ libfprint = shared_library(versioned_libname.split('lib')[1],
     sources: [
         fp_enums,
         libfprint_sources,
-        other_sources,
     ],
     soversion: soversion,
     version: libversion,
@@ -318,7 +315,24 @@ udev_hwdb_generator = custom_target('udev-hwdb',
     install: false,
 )
 
-custom_target('sync-udev-hwdb',
+if install_udev_rules
+    udev_rules = executable('fprint-list-udev-rules',
+        'fprint-list-udev-rules.c',
+        dependencies: libfprint_private_dep,
+        link_with: libfprint_drivers,
+        install: false)
+
+    custom_target('udev-rules',
+        output: '70-@0@.rules'.format(versioned_libname),
+        depend_files: drivers_sources,
+        capture: true,
+        command: [ udev_rules ],
+        install: true,
+        install_dir: udev_rules_dir,
+    )
+endif
+
+sync_udev_udb = custom_target('sync-udev-hwdb',
     depends: udev_hwdb_generator,
     output: 'sync-udev-hwdb',
     install: false,
@@ -329,6 +343,8 @@ custom_target('sync-udev-hwdb',
     ]
 )
 
+alias_target('sync-udev-hwdb', sync_udev_udb)
+
 supported_devices = executable('fprint-list-supported-devices',
     'fprint-list-supported-devices.c',
     dependencies: libfprint_private_dep,

libfprint/nbis/fix-musl-build.patch

@@ -0,0 +1,31 @@
+From 2584d440afc87d463cb8dc809d48c660e091c2c4 Mon Sep 17 00:00:00 2001
+From: Sam James <sam@gentoo.org>
+Date: Thu, 23 Jun 2022 05:57:46 +0100
+Subject: [PATCH] nbis: fix build on musl
+
+Drop re-definition of stderr. There's no need for this anywhere
+(including glibc). This breaks in particular on musl because
+stderr (and stdin) are both const, and macros unlike in glibc.
+
+Bug: https://bugs.gentoo.org/853811
+---
+ nbis/include/bozorth.h | 2 --
+ 1 file changed, 2 deletions(-)
+
+diff --git a/nbis/include/bozorth.h b/nbis/include/bozorth.h
+index a705da98..fd8975bf 100644
+--- a/nbis/include/bozorth.h
++++ b/nbis/include/bozorth.h
+@@ -217,8 +217,6 @@ struct xytq_struct {
+ /**************************************************************************/
+ /* Globals supporting command line options */
+ extern int verbose_threshold;
+-/* Global supporting error reporting */
+-extern FILE *stderr;
+ 
+ /**************************************************************************/
+ /* In: BZ_GBLS.C */
+-- 
+GitLab
+
+

libfprint/nbis/include/bozorth.h

@@ -217,8 +217,6 @@ struct xytq_struct {
 /**************************************************************************/
 /* Globals supporting command line options */
 extern int verbose_threshold;
-/* Global supporting error reporting */
-extern FILE *stderr;
 
 /**************************************************************************/
 /* In: BZ_GBLS.C */

libfprint/nbis/update-from-nbis.sh

@@ -198,3 +198,6 @@ patch -p0 < fix-scan-build-reports.patch
 
 # Add pass to remove perimeter points
 patch -p0 < remove-perimeter-pts.patch
+
+# Fix build on musl by dropping unnecessary redeclaration of stderr
+patch -p0 < fix-musl-build.patch

meson.build

@@ -1,5 +1,5 @@
 project('libfprint', [ 'c', 'cpp' ],
-    version: '1.90.7',
+    version: '1.94.4',
     license: 'LGPLv2.1+',
     default_options: [
         'buildtype=debugoptimized',
@@ -11,6 +11,7 @@ project('libfprint', [ 'c', 'cpp' ],
 gnome = import('gnome')
 
 libfprint_conf = configuration_data()
+libfprint_conf.set_quoted('LIBFPRINT_VERSION', meson.project_version())
 
 cc = meson.get_compiler('c')
 cpp = meson.get_compiler('cpp')
@@ -33,6 +34,7 @@ common_cflags = cc.get_supported_arguments([
     '-Wmissing-noreturn',
     '-Wpointer-arith',
     '-Wshadow',
+    '-Wswitch-enum',
     '-Wtype-limits',
     '-Wundef',
     '-Wunused',
@@ -86,6 +88,9 @@ mathlib_dep = cc.find_library('m', required: false)
 # The following dependencies are only used for tests
 cairo_dep = dependency('cairo', required: false)
 
+# introspection scanning and Gio-2.0.gir
+gobject_introspection = dependency('gobject-introspection-1.0', required: get_option('introspection'))
+
 # Drivers
 drivers = get_option('drivers').split(',')
 virtual_drivers = [
@@ -97,6 +102,7 @@ virtual_drivers = [
 default_drivers = [
     'upektc_img',
     'vfs5011',
+    'vfs7552',
     'aes3500',
     'aes4000',
     'aes1610',
@@ -108,14 +114,21 @@ default_drivers = [
     'vfs301',
     'vfs0050',
     'etes603',
+    'egis0570',
     'vcom5s',
     'synaptics',
     'elan',
+    'elanmoc',
     'uru4000',
     'upektc',
     'upeksonly',
     'upekts',
     'goodixmoc',
+    'nb1010',
+    'fpcmoc',
+
+    # SPI
+    'elanspi',
 ]
 
 # FIXME: All the drivers should be fixed by adjusting the byte order.
@@ -135,6 +148,33 @@ if drivers == [ 'default' ]
     drivers = default_drivers
 endif
 
+driver_helper_mapping = {
+    'aes1610' : [ 'aeslib' ],
+    'aes1660' : [ 'aeslib', 'aesx660' ],
+    'aes2501' : [ 'aeslib' ],
+    'aes2550' : [ 'aeslib' ],
+    'aes2660' : [ 'aeslib', 'aesx660' ],
+    'aes3500' : [ 'aeslib', 'aes3k' ],
+    'aes4000' : [ 'aeslib', 'aes3k' ],
+    'uru4000' : [ 'nss' ],
+    'elanspi' : [ 'udev' ],
+    'virtual_image'          : [ 'virtual' ],
+    'virtual_device'         : [ 'virtual' ],
+    'virtual_device_storage' : [ 'virtual' ],
+}
+
+driver_helpers = []
+foreach driver : drivers
+    if driver in driver_helper_mapping
+        foreach helper : driver_helper_mapping[driver]
+            if helper not in driver_helpers
+                driver_helpers += helper
+            endif
+        endforeach
+    endif
+endforeach
+
+
 if drivers.length() == 0 or drivers[0] == ''
     error('Cannot build libfprint without drivers, please specify a valid value for the drivers option')
 endif
@@ -151,29 +191,61 @@ else
     endforeach
 endif
 
-nss_dep = dependency('', required: false)
-imaging_dep = dependency('', required: false)
-libfprint_conf.set10('HAVE_PIXMAN', false)
-foreach driver: drivers
-    if driver == 'uru4000'
-        nss_dep = dependency('nss', required: false)
-        if not nss_dep.found()
-            error('NSS is required for the URU4000/URU4500 driver')
+udev_rules = get_option('udev_rules')
+install_udev_rules = udev_rules.enabled()
+
+optional_deps = []
+
+# Resolve extra dependencies
+foreach i : driver_helpers
+    foreach d, helpers : driver_helper_mapping
+        if i in helpers
+            driver = d
+            break
         endif
-    endif
-    if driver == 'aes3500' or driver == 'aes4000'
+    endforeach
+
+    if i == 'aes3k'
         imaging_dep = dependency('pixman-1', required: false)
         if not imaging_dep.found()
-            error('pixman is required for imaging support')
+            error('pixman is required for @0@ and possibly others'.format(driver))
         endif
 
         libfprint_conf.set10('HAVE_PIXMAN', true)
-    endif
-    if not all_drivers.contains(driver)
-        error('Invalid driver \'' + driver + '\'')
+        optional_deps += imaging_dep
+    elif i == 'nss'
+        nss_dep = dependency('nss', required: false)
+        if not nss_dep.found()
+            error('nss is required for @0@ and possibly others'.format(driver))
+        endif
+
+        optional_deps += nss_dep
+    elif i == 'udev'
+        install_udev_rules = true
+
+        gudev_dep = dependency('gudev-1.0', required: false)
+        if not gudev_dep.found()
+            error('udev is required for SPI support')
+        endif
+
+        libfprint_conf.set10('HAVE_UDEV', true)
+
+        optional_deps += gudev_dep
     endif
 endforeach
 
+if udev_rules.disabled()
+    install_udev_rules = false
+endif
+
+if install_udev_rules
+    udev_rules_dir = get_option('udev_rules_dir')
+    if udev_rules_dir == 'auto'
+        udev_dep = dependency('udev')
+        udev_rules_dir = udev_dep.get_pkgconfig_variable('udevdir') + '/rules.d'
+    endif
+endif
+
 supported_drivers = []
 foreach driver: drivers
     if build_machine.endian() == 'little' or driver in endian_independent_drivers
@@ -188,39 +260,29 @@ if default_drivers_are_enabled and supported_drivers != drivers
     default_drivers_are_enabled = false
 endif
 
-# Export the drivers' types to the core code
-drivers_type_list = []
-drivers_type_func = []
-drivers_type_list += '#include <glib-object.h>'
-drivers_type_list += '#include "fpi-context.h"'
-drivers_type_list += ''
-drivers_type_func += 'GArray *'
-drivers_type_func += 'fpi_get_driver_types (void)'
-drivers_type_func += '{'
-drivers_type_func += '  GArray *drivers = g_array_new (TRUE, FALSE, sizeof (GType));'
-drivers_type_func += '  GType t;'
-drivers_type_func += ''
-foreach driver: supported_drivers
-    drivers_type_list += 'extern GType (fpi_device_' + driver + '_get_type) (void);'
-    drivers_type_func += '  t = fpi_device_' + driver + '_get_type ();'
-    drivers_type_func += '  g_array_append_val (drivers, t);'
-    drivers_type_func += ''
-endforeach
-drivers_type_list += ''
-drivers_type_func += '  return drivers;'
-drivers_type_func += '}'
-
 root_inc = include_directories('.')
 
-if get_option('udev_rules')
+udev_hwdb = get_option('udev_hwdb')
+if not udev_hwdb.disabled()
+    # systemd v248 includes our autosuspend rules
+    udev_versioned_dep = dependency('udev', version: '>= 248', required: false)
     udev_hwdb_dir = get_option('udev_hwdb_dir')
+    if udev_hwdb.auto()
+        if udev_versioned_dep.found()
+            udev_hwdb_dir = ''
+        endif
+    else
+        if udev_versioned_dep.found()
+            warning('udev hwdb will be installed by both systemd and libfprint')
+        endif
+    endif
 
     if udev_hwdb_dir == 'auto'
         udev_dep = dependency('udev')
         udev_hwdb_dir = udev_dep.get_pkgconfig_variable('udevdir') + '/hwdb.d'
     endif
 else
-    udev_hwdb_dir = false
+    udev_hwdb_dir = ''
 endif
 
 if get_option('gtk-examples')
@@ -232,9 +294,11 @@ if get_option('gtk-examples')
     endif
 endif
 
+# Some dependency resolving happens inside here
+subdir('libfprint')
+
 configure_file(output: 'config.h', configuration: libfprint_conf)
 
-subdir('libfprint')
 subdir('examples')
 if get_option('doc')
     gnome = import('gnome')

meson_options.txt

@@ -7,9 +7,17 @@ option('introspection',
        type: 'boolean',
        value: true)
 option('udev_rules',
-       description: 'Whether to create a udev rules file',
-       type: 'boolean',
-       value: true)
+       description: 'Whether to create and install udev rules (auto: turn on when needed by a driver)',
+       type: 'feature',
+       value: 'auto')
+option('udev_rules_dir',
+       description: 'Installation path for udev rules',
+       type: 'string',
+       value: 'auto')
+option('udev_hwdb',
+       description: 'Whether to create a udev hwdb for autosuspend (included in systemd v248 and later)',
+       type: 'feature',
+       value: 'auto')
 option('udev_hwdb_dir',
        description: 'Installation path for udev hwdb',
        type: 'string',

scripts/uncrustify.cfg

@@ -120,7 +120,7 @@ nl_multi_line_cond              true
 # Not clear what to do about that...
 mod_full_brace_for              Remove
 mod_full_brace_if               Remove
-mod_full_brace_if_chain         True
+mod_full_brace_if_chain         1
 mod_full_brace_while            Remove
 mod_full_brace_do               Remove
 mod_full_brace_nl               3
@@ -137,3 +137,7 @@ pos_conditional                 Trail
 
 # custom keywords
 set FOR udev_list_entry_foreach
+
+# macros
+macro-open G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+macro-close G_GNUC_END_IGNORE_DEPRECATIONS

scripts/uncrustify.sh

@@ -12,8 +12,11 @@ case "$1" in
         ;;
 esac
 
+ARGS=4
+JOBS=4
+
 pushd "$SRCROOT"
-uncrustify -c "$CFG" $OPTS `git ls-tree --name-only -r HEAD | grep -E '.*\.[ch]$' | grep -v nbis | grep -v fpi-byte | grep -v build/`
+git ls-tree --name-only -r HEAD | grep -E '.*\.[ch]$' | grep -v nbis | grep -v fpi-byte | grep -v build/ | xargs -n$ARGS -P $JOBS uncrustify -c "$CFG" $OPTS
 RES=$?
 popd
-exit $RES
+exit $RES

tests/README.md

@@ -3,91 +3,46 @@
 `umockdev` tests use fingerprint devices mocked by [`umockdev`
 toolchain][umockdev].
 
-This document describes how to create a 'capture' test: a test that
-captures a picture of a fingerprint from the device (mocked by
-`umockdev`) and compares it with the standard one.
+This document describes how to create test cases (for USB devices). Many of
+these tests are tests for image devices, where a single image is captured
+and stored.
 
-Other kinds of `umockdev` tests could be created in a similar manner.
+Other kinds of `umockdev` tests can be created in a similar manner. For
+match-on-chip devices you would instead create a test specific `custom.py`
+script, capture it and store the capture to `custom.pcapng`.
 
+'capture' and 'custom' Test Creation
+------------------------------------
 
-'Capture' Test Creation
------------------------
-A new 'capture' test is created by means of `capture.py` script:
+For image devices the `capture.py` script will be used to capture one reference
+image. If the driver is a non-image driver, then a `custom.py` script should be
+created in advance, which will be run instead.
 
-1. Create (if needed) a directory for the driver under `tests`
-   directory:
+1. Make sure that libfprint is built with support for the device driver
+   that you want to create a test case for.
 
-   `mkdir DRIVER`
+2. From the build directory, run tests/create-driver-test.py as root. Note
+   that if you're capturing data for a driver which already has a test case
+   but the hardware is slightly different, you might want to pass a variant
+   name as a command-line options, for example:
+```sh
+$ sudo tests/create-driver-test.py driver [variant]
+```
 
-2. Prepare your execution environment.
+3. If the capture is not successful, run the tool again to start another capture.
 
-   In the next step a working and up to date libfprint is needed. This can be
-   achieved by installing it into your system. Alternatively, you can set
-   the following environment variables to run a local build:
-   - `export LD_PRELOAD=<meson-build-dir>/libfprint/libfprint-2.so`
-   - `export GI_TYPELIB_PATH=<meson-build-dir>/libfprint`
+4. Add driver test name to `drivers_tests` in the `meson.build`, as instructed,
+   and change the ownership of the just-created test directory in the source.
 
-   Also, sometimes the driver must be adapted to the emulated environment
-   (mainly if it uses random numbers, see `synaptics.c` for an example).
-   Set the following environment variable to enable this adaptation:
-   - `export FP_DEVICE_EMULATION=1`
+5. Check whether `meson test` passes with this new test.
 
-   Run the next steps in the same terminal.
-
-3. Find the real USB fingerprint device with `lsusb`, e.g.:
-
-   `Bus 001 Device 005: ID 138a:0090 Validity Sensors, Inc. VFS7500 Touch Fingerprint Sensor`
-
-   The following USB device is used in the example above:
-   `/dev/bus/usb/001/005`.
-
-   For the following commands, it is assumed that the user that's
-   running the commands has full access to the device node, whether
-   by running the commands as `root`, or changing the permissions for
-   that device node.
-
-4. Record information about this device:
-
-   `umockdev-record /dev/bus/usb/001/005 > DRIVER/device`
-
-5. Record interaction of `capture.py` (or other test) with the device:
-
-   `umockdev-record -i /dev/bus/usb/001/005=DRIVER/capture.ioctl -- python3 ./capture.py DRIVER/capture.png`
-
-   Files `capture.ioctl` and `capture.png` will be created as the
-   result of this command.
-
-6. Add driver's name to `drivers_tests` in the `meson.build`.
-7. Check whether everything works as expected.
-
-**Note.** To avoid submitting a real fingerprint, the side of finger,
-arm, or anything else producing an image with the device can be used.
+**Note.** To avoid submitting a real fingerprint when creating a 'capture' test,
+the side of finger, arm, or anything else producing an image with the device
+can be used.
 
 
 Possible Issues
 ---------------
-`umockdev-record` aggressively groups URBs. In most cases, manual
-intervention is unfortunately required. Often, drivers do a chain of
-commands like: A then B each with a different reply. However,
-`umockdev-record` could create a file like this:
-
-    A
-     reply 1
-     reply 2
-    B
-     reply 1
-     reply 2
-
-In that case, records must be re-ordered:
-
-    A
-     reply 1
-    B
-     reply 1
-    A
-     reply 2
-    B
-     reply 2
 
 Other changes may be needed to get everything working. For example the
 `elan` driver relies on a timeout that is not reported correctly. In