goodixmoc: Add support for 0x27C6:0x6090

Signed-off-by: lichenggang <lichenggang@uniontech.com>
goodixmoc: add new PID 0x6890
2026-05-06 16:28:03 +02:00 · 2026-04-14 13:43:46 +08:00 · 2026-04-13 13:01:01 +00:00 · 2026-04-09 06:43:40 +00:00 · 2026-03-20 11:23:09 +08:00 · 2026-03-17 17:55:38 +00:00
52 changed files with 1755 additions and 669 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@ -4,9 +4,10 @@ include:
  - project: 'freedesktop/ci-templates'
    ref: master
    file: '/templates/fedora.yml'
-  - remote: 'https://gitlab.gnome.org/GNOME/citemplates/-/raw/master/flatpak/flatpak_ci_initiative.yml'
+  - remote: 'https://gitlab.gnome.org/GNOME/citemplates/-/raw/71e636e012ae0ab04c5e0fe40ca73ada91ae6bde/flatpak/flatpak_ci_initiative.yml'

 default:
+  interruptible: true
  # Auto-retry jobs in case of infra failures
  retry:
    max: 1
@ -28,6 +29,8 @@ workflow:
  rules:
    - if: $CI_PIPELINE_SOURCE == 'merge_request_event'
    - if: $CI_PIPELINE_SOURCE == 'push'
+    - if: $CI_PIPELINE_SOURCE == 'schedule'
+    - if: $CI_PROJECT_NAMESPACE == 'libfprint' && $LIBFPRINT_CI_ACTION != ''

 stages:
  - image-build
@ -41,7 +44,7 @@ image: $FEDORA_IMAGE

 .build_one_driver_template: &build_one_driver
  script:
-    # Build with a driver that doesn't need imaging, or nss
+    # Build with a driver that doesn't need imaging, or openssl
    - meson setup _build --werror -Ddrivers=$driver
    - meson compile -C _build
    - rm -rf _build/
@ -57,11 +60,16 @@ image: $FEDORA_IMAGE
  script:
    - ./.ci/check-abi ${LAST_ABI_BREAK} $(git rev-parse HEAD)

+.standard_job:
+  rules:
+    - when: on_success
+    - if: $CI_PIPELINE_SOURCE == "schedule"
+      when: never
+
 build:
  stage: build
-  except:
-    variables:
-      - $CI_PIPELINE_SOURCE == "schedule"
+  extends:
+    - .standard_job
  variables:
    driver: virtual_image
  <<: *build_one_driver
@ -76,13 +84,12 @@ build:

 test:
  stage: test
-  except:
-    variables:
-      - $CI_PIPELINE_SOURCE == "schedule"
+  extends:
+    - .standard_job
  script:
    - meson setup _build --werror -Ddrivers=all -Db_coverage=true
    - meson test -C _build --print-errorlogs --no-stdsplit --timeout-multiplier 3
-    - ninja -C _build coverage
+    - ninja -C _build coverage || true
    - cat _build/meson-logs/coverage.txt || true
  artifacts:
    reports:
@ -100,9 +107,8 @@ test:

 test_valgrind:
  stage: test
-  except:
-    variables:
-      - $CI_PIPELINE_SOURCE == "schedule"
+  extends:
+    - .standard_job
  script:
    - meson setup _build -Ddrivers=all
    - meson compile -C _build
@ -117,11 +123,27 @@ test_valgrind:
      - _build/meson-logs/testlog-valgrind.txt
    expire_in: 1 week

+test_asan:
+  stage: test
+  extends:
+    - .standard_job
+  script:
+    - meson setup _build -Ddrivers=all -Db_sanitize=address,undefined
+    - meson test -C _build --print-errorlogs --no-stdsplit
+  artifacts:
+    reports:
+      junit: "_build/meson-logs/testlog.junit.xml"
+    expose_as: 'Sanitizers test logs'
+    when: always
+    paths:
+      - _build/meson-logs
+      - _build/meson-logs/testlog.txt
+    expire_in: 1 week
+
 test_installed:
  stage: test
-  except:
-    variables:
-      - $CI_PIPELINE_SOURCE == "schedule"
+  extends:
+    - .standard_job
  script:
    - meson setup _build --prefix=/usr -Ddrivers=all
    - meson install -C _build
@ -143,9 +165,8 @@ test_installed:

 test_scan_build:
  stage: test
-  except:
-    variables:
-      - $CI_PIPELINE_SOURCE == "schedule"
+  extends:
+    - .standard_job
  allow_failure: true
  script:
    - meson setup _build -Ddrivers=all
@ -160,19 +181,23 @@ test_scan_build:

 test_indent:
  stage: check-source
-  except:
-    variables:
-      - $CI_PIPELINE_SOURCE == "schedule"
+  extends:
+    - .standard_job
  script:
    - scripts/uncrustify.sh
    - git diff
    - git diff-index --name-only --exit-code HEAD
+  rules:
+    - changes:
+        compare_to: 'refs/heads/master'
+        paths:
+          - '**/*.c'
+          - '**/*.h'

 test_unsupported_list:
  stage: check-source
-  except:
-    variables:
-      - $CI_PIPELINE_SOURCE == "schedule"
+  extends:
+    - .standard_job
  allow_failure: true
  script:
    - tests/hwdb-check-unsupported.py
@ -192,7 +217,7 @@ flatpak:
    - if: '$CI_PROJECT_PATH != "libfprint/libfprint"'
      when: manual
      allow_failure: true
-    - if: '$CI_PIPELINE_SOURCE == "schedule"'
+    - if: $CI_PIPELINE_SOURCE == "schedule"
      when: never
    - if: '$CI_COMMIT_BRANCH == "master"'
      allow_failure: true
@ -213,9 +238,6 @@ flatpak:
 .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
    # a list of packages to install
@ -226,6 +248,8 @@ flatpak:
      libudev-devel
    FDO_DISTRIBUTION_EXEC: |
      $LIBFPRINT_EXEC
+  rules:
+    - when: never

 .container_fedora_build_forced:
  variables:
@ -235,28 +259,27 @@ container_fedora_build_schedule:
  extends:
    - .container_fedora_build_base
    - .container_fedora_build_forced
-  only:
-    variables:
-      - $CI_PIPELINE_SOURCE == "schedule" && $CRON_TASK == "BUILD_CI_IMAGES"
+  rules:
+    - if: $CI_PIPELINE_SOURCE == "schedule" && $CRON_TASK == "BUILD_CI_IMAGES"
+      when: always

 container_fedora_build_manual:
  extends:
    - .container_fedora_build_base
    - .container_fedora_build_forced
-  only:
-    variables:
-      - $LIBFPRINT_CI_ACTION == "build-image"
+  rules:
+    - if: $LIBFPRINT_CI_ACTION == "build-image"
+      when: always

 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
+  rules:
+    - if: $CI_PROJECT_NAMESPACE == "libfprint" && $CI_PIPELINE_SOURCE != "schedule"
+      changes:
+        compare_to: 'refs/heads/master'
+        paths:
+          - '.gitlab-ci/libfprint-image-variables.yaml'
+          - '.gitlab-ci/libfprint-templates.yaml'

 pages:
  image: alpine:latest
@ -271,4 +294,4 @@ pages:
    paths:
      - public
  rules:
-    - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH
+    - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH && $CI_PIPELINE_SOURCE == "push"
--- a/.gitlab-ci/libfprint-image-variables.yaml
+++ b/.gitlab-ci/libfprint-image-variables.yaml
@ -1,2 +1,2 @@
 variables:
-  LIBFPRINT_IMAGE_TAG: v3
+  LIBFPRINT_IMAGE_TAG: v6
--- a/.gitlab-ci/libfprint-templates.yaml
+++ b/.gitlab-ci/libfprint-templates.yaml
@ -3,6 +3,7 @@

 .libfprint_common_variables:
  LIBFPRINT_DEPENDENCIES:
+    appstream
    doxygen
    dnf-plugins-core
    flatpak-builder
@ -17,12 +18,14 @@
    gtk-doc
    gtk3-devel
    libabigail
+    libasan
    libgusb-devel
    libgudev-devel
+    libubsan
    libX11-devel
    libXv-devel
    meson
-    nss-devel
+    openssl-devel
    pixman-devel
    python3-cairo
    python3-gobject
@ -40,10 +43,7 @@
      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
+      openssl \
+      pixman \
+      python3-gobject \
+      python3-gobject-base
--- a/.gitlab-ci/scan-build
+++ b/.gitlab-ci/scan-build
@ -1,4 +1,4 @@
 #!/bin/sh

 # This wrapper just disables the malloc checker
-exec /usr/bin/scan-build --status-bugs -disable-checker unix.Malloc "$@"
+exec /usr/bin/scan-build --status-bugs -disable-checker unix.Malloc --exclude "_build/meson-private" "$@"
--- a/31
+++ b/31
@ -1,6 +1,37 @@
 This file lists notable changes in each release. For the full history of all
 changes, see ChangeLog.

+2026-02-10: v1.94.10 release
+
+Highlights:
+  * synaptics: Add USB reset in probe to recover stall condition
+  * synaptics: New PIDs 0x0169, 0x019F, 0x00E9, 0x01A0, 0x0109, 0x010A
+  * goodixmoc: New PID 0x66A9
+  * goodixmoc: Fix crash in exit callback handler
+  * fpcmoc: New PID 0xA306
+  * fpcmoc: Fix interrupt cancellable leak
+  * elanmoc: New PIDs 0x0CA7, 0x0CA8, 0x0CB0
+  * egismoc: New PIDs 0x0584, 0x0588
+  * focaltech_moc: New PIDs 0xA27A, 0x1579
+  * realtek: New PID 0xFA03
+  * fp-device: Clarify getter for open property
+  * libfprint: Use fatal-warnings on g-i-scanner
+
+2025-02-20: v1.94.9 release
+
+Highlights:
+  * uru4000: Use OpenSSL to perform AES-ECB encryption, as per this libfprint
+    does not support on NSS, but on openssl (>= 3.0).
+  * goodixmoc: New PIDs 0x60C2, 0x689A
+  * synaptics: New PIDs 0x016C, 0x0174, 0x0107, 0x0108, 0x00C2, 0x00F0
+  * fpcmoc: New PID 0xC844
+  * focaltech_moc: New PIDs 0xA99A, 0xA57A, 0xA78A
+  * elanmoc: New PIDs 0x0C98, 0x0C9D, 0x0CA3
+  * elanspi: New PIDs 0x3128, 0x2766
+  * fp-device: Add FP_DEVICE_RETRY_TOO_FAST retry error
+  * data: AppStream meta info listing supported USB devices.
+  * fixed various memory issues in multiple devices
+
 2024-09-03: v1.94.8 release

 Highlights:
--- a/data/autosuspend.hwdb
+++ b/data/autosuspend.hwdb
@ -80,8 +80,10 @@ usb:v1C7Ap0571*
 # Supported by libfprint driver egismoc
 usb:v1C7Ap0582*
 usb:v1C7Ap0583*
+usb:v1C7Ap0584*
 usb:v1C7Ap0586*
 usb:v1C7Ap0587*
+usb:v1C7Ap0588*
 usb:v1C7Ap05A1*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0
@ -158,8 +160,15 @@ usb:v04F3p0C82*
 usb:v04F3p0C88*
 usb:v04F3p0C8C*
 usb:v04F3p0C8D*
+usb:v04F3p0C98*
 usb:v04F3p0C99*
+usb:v04F3p0C9D*
 usb:v04F3p0C9F*
+usb:v04F3p0CA3*
+usb:v04F3p0CA7*
+usb:v04F3p0CA8*
+usb:v04F3p0CB0*
+usb:v04F3p0CB2*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

@ -171,24 +180,35 @@ usb:v1C7Ap0603*
 # Supported by libfprint driver focaltech_moc
 usb:v2808p9E48*
 usb:v2808pD979*
+usb:v2808pA27A*
 usb:v2808pA959*
+usb:v2808pA99A*
+usb:v2808pA57A*
+usb:v2808pA78A*
+usb:v2808p1579*
+usb:v2808p077A*
+usb:v2808p079A*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

 # Supported by libfprint driver fpcmoc
 usb:v10A5pFFE0*
 usb:v10A5pA305*
+usb:v10A5pA306*
 usb:v10A5pDA04*
 usb:v10A5pD805*
 usb:v10A5pD205*
 usb:v10A5p9524*
 usb:v10A5p9544*
+usb:v10A5pC844*
+usb:v10A5p9B24*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

 # Supported by libfprint driver goodixmoc
 usb:v27C6p5840*
 usb:v27C6p6014*
+usb:v27C6p6090*
 usb:v27C6p6092*
 usb:v27C6p6094*
 usb:v27C6p609A*
@ -196,6 +216,7 @@ usb:v27C6p609C*
 usb:v27C6p60A2*
 usb:v27C6p60A4*
 usb:v27C6p60BC*
+usb:v27C6p60C2*
 usb:v27C6p6304*
 usb:v27C6p631C*
 usb:v27C6p633C*
@ -217,6 +238,9 @@ usb:v27C6p659A*
 usb:v27C6p659C*
 usb:v27C6p6A94*
 usb:v27C6p6512*
+usb:v27C6p6890*
+usb:v27C6p689A*
+usb:v27C6p66A9*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

@ -228,30 +252,41 @@ usb:v298Dp1010*
 # Supported by libfprint driver realtek
 usb:v0BDAp5813*
 usb:v0BDAp5816*
+usb:v2541pFA03*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

 # Supported by libfprint driver synaptics
 usb:v06CBp00BD*
-usb:v06CBp00DF*
-usb:v06CBp00F9*
-usb:v06CBp00FC*
 usb:v06CBp00C2*
 usb:v06CBp00C4*
-usb:v06CBp0100*
+usb:v06CBp00C6*
+usb:v06CBp00DF*
+usb:v06CBp00E9*
 usb:v06CBp00F0*
+usb:v06CBp00F9*
+usb:v06CBp00FC*
+usb:v06CBp0100*
 usb:v06CBp0103*
+usb:v06CBp0104*
+usb:v06CBp0106*
+usb:v06CBp0107*
+usb:v06CBp0108*
+usb:v06CBp0109*
+usb:v06CBp010A*
 usb:v06CBp0123*
 usb:v06CBp0124*
 usb:v06CBp0126*
 usb:v06CBp0129*
-usb:v06CBp0168*
 usb:v06CBp015F*
-usb:v06CBp0104*
+usb:v06CBp0168*
+usb:v06CBp0169*
+usb:v06CBp016C*
 usb:v06CBp0173*
-usb:v06CBp0106*
+usb:v06CBp0174*
 usb:v06CBp019D*
-usb:v06CBp00C6*
+usb:v06CBp019F*
+usb:v06CBp01A0*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

@ -320,7 +355,10 @@ usb:v138Ap0091*
 ID_PERSIST=0

 # Known unsupported devices
+usb:v0A5Cp5802*
 usb:v047Dp00F2*
+usb:v047Dp8054*
+usb:v047Dp8055*
 usb:v04E8p730B*
 usb:v04F3p036B*
 usb:v04F3p0C00*
@ -328,25 +366,36 @@ usb:v04F3p0C4C*
 usb:v04F3p0C57*
 usb:v04F3p0C5E*
 usb:v04F3p0C5A*
+usb:v04F3p0C60*
 usb:v04F3p0C6C*
 usb:v04F3p0C70*
 usb:v04F3p0C72*
 usb:v04F3p0C77*
+usb:v04F3p0C7C*
+usb:v04F3p0C7F*
+usb:v04F3p0C80*
+usb:v04F3p0C85*
+usb:v04F3p0C90*
 usb:v04F3p2706*
 usb:v04F3p3032*
 usb:v04F3p3057*
 usb:v04F3p3104*
 usb:v04F3p310D*
 usb:v04F3p3128*
+usb:v04F3p0C8A*
+usb:v05BAp000E*
+usb:v06CBp0051*
 usb:v06CBp0081*
 usb:v06CBp0088*
 usb:v06CBp008A*
 usb:v06CBp009A*
 usb:v06CBp009B*
+usb:v06CBp00A1*
 usb:v06CBp00A2*
 usb:v06CBp00A8*
 usb:v06CBp00B7*
 usb:v06CBp00BB*
+usb:v06CBp00BC*
 usb:v06CBp00BE*
 usb:v06CBp00CB*
 usb:v06CBp00C9*
@ -355,8 +404,8 @@ usb:v06CBp00DA*
 usb:v06CBp00DC*
 usb:v06CBp00E4*
 usb:v06CBp00E7*
-usb:v06CBp00E9*
 usb:v06CBp00FD*
+usb:v06CBp00FF*
 usb:v0A5Cp5801*
 usb:v0A5Cp5805*
 usb:v0A5Cp5834*
@ -375,7 +424,11 @@ usb:v0A5Cp5867*
 usb:v0BDAp5812*
 usb:v10A5p0007*
 usb:v10A5p9200*
+usb:v10A5p9201*
 usb:v10A5p9800*
+usb:v10A5pA120*
+usb:v10A5pA900*
+usb:v10A5pA921*
 usb:v10A5pE340*
 usb:v1188p9545*
 usb:v138Ap0007*
@ -397,6 +450,9 @@ usb:v1C7Ap0300*
 usb:v1C7Ap0575*
 usb:v1C7Ap0576*
 usb:v1C7Ap0577*
+usb:v1C7Ap057E*
+usb:v2541p0236*
+usb:v2541p9711*
 usb:v27C6p5042*
 usb:v27C6p5110*
 usb:v27C6p5117*
@ -425,11 +481,19 @@ usb:v27C6p5740*
 usb:v27C6p5E0A*
 usb:v27C6p581A*
 usb:v27C6p589A*
+usb:v27C6p5F10*
+usb:v27C6p5F91*
 usb:v27C6p6382*
 usb:v2808p9338*
+usb:v2808p9348*
 usb:v2808p93A9*
+usb:v2808pA658*
+usb:v2808pC652*
+usb:v2808pA553*
 usb:v298Dp2020*
 usb:v298Dp2033*
+usb:v2DF0p0003*
+usb:v3274p8012*
 usb:v3538p0930*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0
--- a/demo/gtk-libfprint-test.c
+++ b/demo/gtk-libfprint-test.c
@ -101,11 +101,14 @@ plot_minutiae (unsigned char *rgbdata,
 {
  int i;

-#define write_pixel(num) do { \
-            rgbdata[((num) * 3)] = 0xff; \
-            rgbdata[((num) * 3) + 1] = 0; \
-            rgbdata[((num) * 3) + 2] = 0; \
-  } while(0)
+  #define write_pixel(num) \
+    do \
+      { \
+        rgbdata[((num) * 3)] = 0xff; \
+        rgbdata[((num) * 3) + 1] = 0; \
+        rgbdata[((num) * 3) + 2] = 0; \
+      } \
+    while(0)

  for (i = 0; i < minutiae->len; i++)
    {
--- a/examples/clear-storage.c
+++ b/examples/clear-storage.c
@ -0,0 +1,208 @@
+/*
+ * Example storage clearing program, which deletes all the
+ * fingers which have been previously enrolled to disk.
+ * Copyright (C) 2020 Marco Trevisan <marco.trevisan@canonical.com>
+ * Copyright (C) 2024 Abhinav Baid <abhinavbaid@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 "example-clear-storage"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <libfprint/fprint.h>
+#include <glib-unix.h>
+
+#include "storage.h"
+#include "utilities.h"
+
+typedef struct _ClearStorageData
+{
+  GMainLoop    *loop;
+  GCancellable *cancellable;
+  unsigned int  sigint_handler;
+  int           ret_value;
+} ClearStorageData;
+
+static void
+clear_storage_data_free (ClearStorageData *clear_storage_data)
+{
+  g_clear_handle_id (&clear_storage_data->sigint_handler, g_source_remove);
+  g_clear_object (&clear_storage_data->cancellable);
+  g_main_loop_unref (clear_storage_data->loop);
+  g_free (clear_storage_data);
+}
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (ClearStorageData, clear_storage_data_free)
+
+static void
+on_device_closed (FpDevice *dev, GAsyncResult *res, void *user_data)
+{
+  g_autoptr(GError) error = NULL;
+  ClearStorageData *clear_storage_data = user_data;
+
+  fp_device_close_finish (dev, res, &error);
+
+  if (error)
+    g_warning ("Failed closing device %s", error->message);
+
+  g_main_loop_quit (clear_storage_data->loop);
+}
+
+static void
+clear_storage_quit (FpDevice         *dev,
+                    ClearStorageData *clear_storage_data)
+{
+  if (!fp_device_is_open (dev))
+    {
+      g_main_loop_quit (clear_storage_data->loop);
+      return;
+    }
+
+  fp_device_close (dev, NULL, (GAsyncReadyCallback) on_device_closed,
+                   clear_storage_data);
+}
+
+static void
+on_clear_storage_completed (FpDevice *dev, GAsyncResult *res, void *user_data)
+{
+  g_autoptr(GError) error = NULL;
+  ClearStorageData *clear_storage_data = user_data;
+
+  if (fp_device_clear_storage_finish (dev, res, &error))
+    {
+      if (!clear_saved_prints (dev, &error))
+        {
+          g_warning ("Clear saved prints from local storage failed: %s",
+                     error->message);
+          clear_storage_data->ret_value = EXIT_FAILURE;
+        }
+      else
+        {
+          g_print ("Clear storage successful!\n");
+          clear_storage_data->ret_value = EXIT_SUCCESS;
+        }
+
+      clear_storage_quit (dev, clear_storage_data);
+      return;
+    }
+
+  g_warning ("Failed to clear storage: %s", error->message);
+  clear_storage_data->ret_value = EXIT_FAILURE;
+
+  if (g_error_matches (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_NOT_SUPPORTED))
+    {
+      g_autoptr(GError) clear_error = NULL;
+
+      if (clear_saved_prints (dev, &clear_error))
+        clear_storage_data->ret_value = EXIT_SUCCESS;
+      else
+        g_warning ("Clear saved prints from local storage failed: %s",
+                   clear_error->message);
+    }
+
+  clear_storage_quit (dev, clear_storage_data);
+}
+
+static void
+start_clear_storage (FpDevice *dev, ClearStorageData *clear_storage_data)
+{
+  char buffer[20];
+
+  g_print ("Clear device storage? [Y/n]? ");
+  if (fgets (buffer, sizeof (buffer), stdin) &&
+      (buffer[0] == 'Y' || buffer[0] == 'y'))
+    {
+      fp_device_clear_storage (dev, clear_storage_data->cancellable,
+                               (GAsyncReadyCallback) on_clear_storage_completed,
+                               clear_storage_data);
+      return;
+    }
+
+  clear_storage_quit (dev, clear_storage_data);
+}
+
+static void
+on_device_opened (FpDevice *dev, GAsyncResult *res, void *user_data)
+{
+  g_autoptr(GError) error = NULL;
+  ClearStorageData *clear_storage_data = user_data;
+
+  if (!fp_device_open_finish (dev, res, &error))
+    {
+      g_warning ("Failed to open device: %s", error->message);
+      clear_storage_quit (dev, clear_storage_data);
+      return;
+    }
+
+  g_print ("Opened device. ");
+
+  start_clear_storage (dev, clear_storage_data);
+}
+
+static gboolean
+sigint_cb (void *user_data)
+{
+  ClearStorageData *clear_storage_data = user_data;
+
+  g_cancellable_cancel (clear_storage_data->cancellable);
+
+  return G_SOURCE_CONTINUE;
+}
+
+int
+main (void)
+{
+  g_autoptr(FpContext) ctx = NULL;
+  g_autoptr(ClearStorageData) clear_storage_data = NULL;
+  GPtrArray *devices;
+  FpDevice *dev;
+
+  setenv ("G_MESSAGES_DEBUG", "all", 0);
+  setenv ("LIBUSB_DEBUG", "3", 0);
+
+  ctx = fp_context_new ();
+
+  devices = fp_context_get_devices (ctx);
+  if (!devices)
+    {
+      g_warning ("Impossible to get devices");
+      return EXIT_FAILURE;
+    }
+
+  dev = discover_device (devices);
+  if (!dev)
+    {
+      g_warning ("No devices detected.");
+      return EXIT_FAILURE;
+    }
+
+  clear_storage_data = g_new0 (ClearStorageData, 1);
+  clear_storage_data->ret_value = EXIT_FAILURE;
+  clear_storage_data->loop = g_main_loop_new (NULL, FALSE);
+  clear_storage_data->cancellable = g_cancellable_new ();
+  clear_storage_data->sigint_handler = g_unix_signal_add_full (G_PRIORITY_HIGH,
+                                                               SIGINT,
+                                                               sigint_cb,
+                                                               clear_storage_data,
+                                                               NULL);
+  fp_device_open (dev, clear_storage_data->cancellable,
+                  (GAsyncReadyCallback) on_device_opened,
+                  clear_storage_data);
+
+  g_main_loop_run (clear_storage_data->loop);
+
+  return clear_storage_data->ret_value;
+}
--- a/examples/meson.build
+++ b/examples/meson.build
@ -5,6 +5,7 @@ examples = [
    'img-capture',
    'manage-prints',
    'verify',
+    'clear-storage',
 ]

 foreach example: examples
--- a/examples/storage.c
+++ b/examples/storage.c
@ -26,6 +26,7 @@
 #include "storage.h"

 #include <errno.h>
+#include <glib/gstdio.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
@ -55,6 +56,18 @@ get_print_data_descriptor (FpPrint *print, FpDevice *dev, FpFinger finger)
                          finger);
 }

+static char *
+get_print_prefix_for_device (FpDevice *dev)
+{
+  const char *driver;
+  const char *dev_id;
+
+  driver = fp_device_get_driver (dev);
+  dev_id = fp_device_get_device_id (dev);
+
+  return g_strdup_printf ("%s/%s/", driver, dev_id);
+}
+
 static GVariantDict *
 load_data (void)
 {
@ -169,8 +182,6 @@ gallery_data_load (FpDevice *dev)
  g_autoptr(GVariant) dict_variant = NULL;
  g_autofree char *dev_prefix = NULL;
  GPtrArray *gallery;
-  const char *driver;
-  const char *dev_id;
  GVariantIter iter;
  GVariant *value;
  gchar *key;
@ -178,9 +189,7 @@ gallery_data_load (FpDevice *dev)
  gallery = g_ptr_array_new_with_free_func (g_object_unref);
  dict = load_data ();
  dict_variant = g_variant_dict_end (dict);
-  driver = fp_device_get_driver (dev);
-  dev_id = fp_device_get_device_id (dev);
-  dev_prefix = g_strdup_printf ("%s/%s/", driver, dev_id);
+  dev_prefix = get_print_prefix_for_device (dev);

  g_variant_iter_init (&iter, dict_variant);
  while (g_variant_iter_loop (&iter, "{sv}", &key, &value))
@ -208,6 +217,55 @@ gallery_data_load (FpDevice *dev)
  return gallery;
 }

+gboolean
+clear_saved_prints (FpDevice *dev,
+                    GError  **error)
+{
+  g_autoptr(GVariantDict) dict = NULL;
+  g_autoptr(GVariantDict) updated_dict = NULL;
+  g_autoptr(GVariant) dict_variant = NULL;
+  g_autofree char *dev_prefix = NULL;
+  GPtrArray *print_keys;
+  GVariantIter iter;
+  GVariant *value;
+  gchar *key;
+
+  print_keys = g_ptr_array_new_with_free_func (g_free);
+  dict = load_data ();
+  dict_variant = g_variant_dict_end (dict);
+  dev_prefix = get_print_prefix_for_device (dev);
+
+  g_variant_iter_init (&iter, dict_variant);
+  while (g_variant_iter_loop (&iter, "{sv}", &key, &value))
+    {
+      if (!g_str_has_prefix (key, dev_prefix))
+        continue;
+
+      g_ptr_array_add (print_keys, g_strdup (key));
+    }
+
+  if (!print_keys->len)
+    return TRUE;
+
+  updated_dict = load_data ();
+
+  for (guint i = 0; i < print_keys->len; ++i)
+    {
+      key = g_ptr_array_index (print_keys, i);
+      if (!g_variant_dict_remove (updated_dict, key))
+        {
+          g_warning ("Print '%s' key not found!", key);
+          continue;
+        }
+
+      g_debug ("Dropping print '%s' from gallery", key);
+    }
+
+  save_data (g_variant_dict_end (updated_dict));
+
+  return TRUE;
+}
+
 FpPrint *
 print_create_template (FpDevice *dev, FpFinger finger, gboolean load_existing)
 {
--- a/examples/storage.h
+++ b/examples/storage.h
@ -20,12 +20,17 @@

 #pragma once

+#include <glib.h>
+#include <libfprint/fprint.h>
+
 int print_data_save (FpPrint *print,
                     FpFinger finger,
                     gboolean update_fingerprint);
 FpPrint * print_data_load (FpDevice *dev,
                           FpFinger  finger);
 GPtrArray * gallery_data_load (FpDevice *dev);
+gboolean clear_saved_prints (FpDevice *dev,
+                             GError  **error);
 FpPrint * print_create_template (FpDevice      *dev,
                                 FpFinger       finger,
                                 const gboolean load_existing);
--- a/gcovr.cfg
+++ b/gcovr.cfg
@ -0,0 +1 @@
+gcov-ignore-parse-errors = suspicious_hits.warn
--- a/libfprint/drivers/egismoc/egismoc.c
+++ b/libfprint/drivers/egismoc/egismoc.c
@ -52,8 +52,10 @@ G_DEFINE_TYPE (FpiDeviceEgisMoc, fpi_device_egismoc, FP_TYPE_DEVICE);
 static const FpIdEntry egismoc_id_table[] = {
  { .vid = 0x1c7a, .pid = 0x0582, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 },
  { .vid = 0x1c7a, .pid = 0x0583, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 },
+  { .vid = 0x1c7a, .pid = 0x0584, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 | EGISMOC_DRIVER_MAX_ENROLL_STAGES_20 },
  { .vid = 0x1c7a, .pid = 0x0586, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 | EGISMOC_DRIVER_MAX_ENROLL_STAGES_20 },
  { .vid = 0x1c7a, .pid = 0x0587, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 | EGISMOC_DRIVER_MAX_ENROLL_STAGES_20 },
+  { .vid = 0x1c7a, .pid = 0x0588, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 | EGISMOC_DRIVER_MAX_ENROLL_STAGES_20 },
  { .vid = 0x1c7a, .pid = 0x05a1, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE2 },
  { .vid = 0,      .pid = 0,      .driver_data = 0 }
 };
--- a/libfprint/drivers/elanmoc/elanmoc.c
+++ b/libfprint/drivers/elanmoc/elanmoc.c
@ -31,8 +31,15 @@ static const FpIdEntry id_table[] = {
  { .vid = 0x04f3,  .pid = 0x0c88,  },
  { .vid = 0x04f3,  .pid = 0x0c8c,  },
  { .vid = 0x04f3,  .pid = 0x0c8d,  },
+  { .vid = 0x04f3,  .pid = 0x0c98,  },
  { .vid = 0x04f3,  .pid = 0x0c99,  },
+  { .vid = 0x04f3,  .pid = 0x0c9d,  },
  { .vid = 0x04f3,  .pid = 0x0c9f,  },
+  { .vid = 0x04f3,  .pid = 0x0ca3,  },
+  { .vid = 0x04f3,  .pid = 0x0ca7,  },
+  { .vid = 0x04f3,  .pid = 0x0ca8,  },
+  { .vid = 0x04f3,  .pid = 0x0cb0,  },
+  { .vid = 0x04f3,  .pid = 0x0cb2,  },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };

@ -129,10 +136,10 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
 }

 typedef enum {
-  FP_CMD_SEND = 0,
-  FP_CMD_GET,
-  FP_CMD_NUM_STATES,
-} FpCmdState;
+  ELAN_MOC_CMD_SEND = 0,
+  ELAN_MOC_CMD_GET,
+  ELAN_MOC_CMD_NUM_STATES,
+} ElanMocCmdState;

 static void
 fp_cmd_run_state (FpiSsm   *ssm,
@ -143,7 +150,7 @@ fp_cmd_run_state (FpiSsm   *ssm,

  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FP_CMD_SEND:
+    case ELAN_MOC_CMD_SEND:
      if (self->cmd_transfer)
        {
          self->cmd_transfer->ssm = ssm;
@ -159,7 +166,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
        }
      break;

-    case FP_CMD_GET:
+    case ELAN_MOC_CMD_GET:
      if (self->cmd_len_in == 0)
        {
          CommandData *data = fpi_ssm_get_data (ssm);
@ -226,7 +233,7 @@ elanmoc_get_cmd (FpDevice *device, guint8 *buffer_out,

  self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
                               fp_cmd_run_state,
-                               FP_CMD_NUM_STATES);
+                               ELAN_MOC_CMD_NUM_STATES);

  fpi_ssm_set_data (self->cmd_ssm, data, (GDestroyNotify) fp_cmd_ssm_done_data_free);

--- a/libfprint/drivers/elanspi.h
+++ b/libfprint/drivers/elanspi.h
@ -340,9 +340,11 @@ static const struct elanspi_regtable elanspi_calibration_table_new_page1 = {

 // 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 = 0x2766}, .driver_data = ELANSPI_NO_ROTATE},
  {.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 = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x3128}, .driver_data = ELANSPI_90LEFT_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},
--- a/libfprint/drivers/focaltech_moc/focaltech_moc.c
+++ b/libfprint/drivers/focaltech_moc/focaltech_moc.c
@ -29,7 +29,14 @@ G_DEFINE_TYPE (FpiDeviceFocaltechMoc, fpi_device_focaltech_moc, FP_TYPE_DEVICE)
 static const FpIdEntry id_table[] = {
  { .vid = 0x2808,  .pid = 0x9e48,  },
  { .vid = 0x2808,  .pid = 0xd979,  },
+  { .vid = 0x2808,  .pid = 0xa27a,  },
  { .vid = 0x2808,  .pid = 0xa959,  },
+  { .vid = 0x2808,  .pid = 0xa99a,  },
+  { .vid = 0x2808,  .pid = 0xa57a,  },
+  { .vid = 0x2808,  .pid = 0xa78a,  },
+  { .vid = 0x2808,  .pid = 0x1579,  },
+  { .vid = 0x2808,  .pid = 0x077A,  },
+  { .vid = 0x2808,  .pid = 0x079A,  },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };

@ -232,10 +239,10 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
 }

 typedef enum {
-  FP_CMD_SEND = 0,
-  FP_CMD_GET,
-  FP_CMD_NUM_STATES,
-} FpCmdState;
+  FOCALTECH_CMD_SEND = 0,
+  FOCALTECH_CMD_GET,
+  FOCALTECH_CMD_NUM_STATES,
+} FocaltechCmdState;

 static void
 fp_cmd_run_state (FpiSsm   *ssm,
@ -246,7 +253,7 @@ fp_cmd_run_state (FpiSsm   *ssm,

  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FP_CMD_SEND:
+    case FOCALTECH_CMD_SEND:
      if (self->cmd_transfer)
        {
          self->cmd_transfer->ssm = ssm;
@ -263,7 +270,7 @@ fp_cmd_run_state (FpiSsm   *ssm,

      break;

-    case FP_CMD_GET:
+    case FOCALTECH_CMD_GET:
      if (self->cmd_len_in == 0)
        {
          CommandData *data = fpi_ssm_get_data (ssm);
@ -331,7 +338,7 @@ focaltech_moc_get_cmd (FpDevice *device, guint8 *buffer_out,

  self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
                               fp_cmd_run_state,
-                               FP_CMD_NUM_STATES);
+                               FOCALTECH_CMD_NUM_STATES);

  fpi_ssm_set_data (self->cmd_ssm, data, (GDestroyNotify) fp_cmd_ssm_done_data_free);

--- a/libfprint/drivers/fpcmoc/fpc.c
+++ b/libfprint/drivers/fpcmoc/fpc.c
@ -65,11 +65,14 @@ typedef struct
 static const FpIdEntry id_table[] = {
  { .vid = 0x10A5,  .pid = 0xFFE0,  },
  { .vid = 0x10A5,  .pid = 0xA305,  },
+  { .vid = 0x10A5,  .pid = 0xA306,  },
  { .vid = 0x10A5,  .pid = 0xDA04,  },
  { .vid = 0x10A5,  .pid = 0xD805,  },
  { .vid = 0x10A5,  .pid = 0xD205,  },
  { .vid = 0x10A5,  .pid = 0x9524,  },
  { .vid = 0x10A5,  .pid = 0x9544,  },
+  { .vid = 0x10A5,  .pid = 0xC844,  },
+  { .vid = 0x10A5,  .pid = 0x9B24,  },
  /* terminating entry */
  { .vid = 0,  .pid = 0,  .driver_data = 0 },
 };
@ -84,7 +87,7 @@ fpc_suspend_resume_cb (FpiUsbTransfer *transfer,

  fp_dbg ("%s current ssm state: %d", G_STRFUNC, ssm_state);

-  if (ssm_state == FP_CMD_SUSPENDED)
+  if (ssm_state == FPC_CMD_SUSPENDED)
    {
      if (error)
        fpi_ssm_mark_failed (transfer->ssm, error);
@ -92,12 +95,12 @@ fpc_suspend_resume_cb (FpiUsbTransfer *transfer,
      fpi_device_suspend_complete (device, error);
      /* The resume handler continues to the next state! */
    }
-  else if (ssm_state == FP_CMD_RESUME)
+  else if (ssm_state == FPC_CMD_RESUME)
    {
      if (error)
        fpi_ssm_mark_failed (transfer->ssm, error);
      else
-        fpi_ssm_jump_to_state (transfer->ssm, FP_CMD_GET_DATA);
+        fpi_ssm_jump_to_state (transfer->ssm, FPC_CMD_GET_DATA);

      fpi_device_resume_complete (device, error);
    }
@ -116,7 +119,7 @@ fpc_cmd_receive_cb (FpiUsbTransfer *transfer,
  if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) && (self->cmd_suspended))
    {
      g_error_free (error);
-      fpi_ssm_jump_to_state (transfer->ssm, FP_CMD_SUSPENDED);
+      fpi_ssm_jump_to_state (transfer->ssm, FPC_CMD_SUSPENDED);
      return;
    }

@ -137,7 +140,7 @@ fpc_cmd_receive_cb (FpiUsbTransfer *transfer,
  fp_dbg ("%s current ssm request: %d state: %d", G_STRFUNC, data->request, ssm_state);

  /* clean cmd_ssm except capture command for suspend/resume case */
-  if (ssm_state != FP_CMD_SEND || data->request != FPC_CMD_ARM)
+  if (ssm_state != FPC_CMD_SEND || data->request != FPC_CMD_ARM)
    self->cmd_ssm = NULL;

  if (data->cmdtype == FPC_CMDTYPE_TO_DEVICE)
@ -151,13 +154,13 @@ fpc_cmd_receive_cb (FpiUsbTransfer *transfer,
    }
  else if (data->cmdtype == FPC_CMDTYPE_TO_DEVICE_EVTDATA)
    {
-      if (ssm_state == FP_CMD_SEND)
+      if (ssm_state == FPC_CMD_SEND)
        {
          fpi_ssm_next_state (transfer->ssm);
          return;
        }

-      if (ssm_state == FP_CMD_GET_DATA)
+      if (ssm_state == FPC_CMD_GET_DATA)
        {
          fpc_cmd_response_t evt_data = {0};
          fp_dbg ("%s recv evt data length: %ld", G_STRFUNC, transfer->actual_length);
@ -290,11 +293,11 @@ fpc_cmd_run_state (FpiSsm   *ssm,

  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FP_CMD_SEND:
+    case FPC_CMD_SEND:
      fpc_send_ctrl_cmd (dev);
      break;

-    case FP_CMD_GET_DATA:
+    case FPC_CMD_GET_DATA:
      transfer = fpi_usb_transfer_new (dev);
      transfer->ssm = ssm;
      fpi_usb_transfer_fill_bulk (transfer, EP_IN, EP_IN_MAX_BUF_SIZE);
@ -305,7 +308,7 @@ fpc_cmd_run_state (FpiSsm   *ssm,
                               fpi_ssm_get_data (ssm));
      break;

-    case FP_CMD_SUSPENDED:
+    case FPC_CMD_SUSPENDED:
      transfer = fpi_usb_transfer_new (dev);
      transfer->ssm = ssm;
      fpi_usb_transfer_fill_control (transfer,
@ -321,7 +324,7 @@ fpc_cmd_run_state (FpiSsm   *ssm,
                               fpc_suspend_resume_cb, NULL);
      break;

-    case FP_CMD_RESUME:
+    case FPC_CMD_RESUME:
      transfer = fpi_usb_transfer_new (dev);
      transfer->ssm = ssm;
      fpi_usb_transfer_fill_control (transfer,
@ -352,21 +355,22 @@ fpc_sensor_cmd (FpiDeviceFpcMoc *self,

  data = g_memdup2 (cmd_data, sizeof (CommandData));

+  g_clear_object (&self->interrupt_cancellable);
+
  if (wait_data_delay)
    {
      self->cmd_data_timeout = 0;
-      g_set_object (&self->interrupt_cancellable, g_cancellable_new ());
+      self->interrupt_cancellable = g_cancellable_new ();
    }
  else
    {
      self->cmd_data_timeout = DATA_TIMEOUT;
-      g_clear_object (&self->interrupt_cancellable);
    }

  g_assert (self->cmd_ssm == NULL);
  self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
                               fpc_cmd_run_state,
-                               FP_CMD_NUM_STATES);
+                               FPC_CMD_NUM_STATES);

  fpi_ssm_set_data (self->cmd_ssm, data, g_free);
  fpi_ssm_start (self->cmd_ssm, fpc_cmd_ssm_done);
@ -741,7 +745,7 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
    case FPC_ENROL_STATUS_COMPLETED:
      self->enroll_stage++;
      fpi_device_enroll_progress (FP_DEVICE (self), self->enroll_stage, NULL, NULL);
-      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
+      fpi_ssm_jump_to_state (self->task_ssm, FPC_ENROLL_COMPLETE);
      return;

    case FPC_ENROL_STATUS_IMAGE_TOO_SIMILAR:
@ -760,7 +764,7 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
              /* Used for customer enrollment scheme */
              if (self->enroll_stage >= (self->max_enroll_stage - self->max_immobile_stage))
                {
-                  fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
+                  fpi_ssm_jump_to_state (self->task_ssm, FPC_ENROLL_COMPLETE);
                  return;
                }
              break;
@ -778,7 +782,7 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
      /* Used for customer enrollment scheme */
      if (self->enroll_stage >= (self->max_enroll_stage - self->max_immobile_stage))
        {
-          fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
+          fpi_ssm_jump_to_state (self->task_ssm, FPC_ENROLL_COMPLETE);
          return;
        }
      break;
@ -813,7 +817,7 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
    }
  else
    {
-      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, FPC_ENROLL_CAPTURE);
    }
 }

@ -941,7 +945,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)

  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FP_ENROLL_ENUM:
+    case FPC_ENROLL_ENUM:
      {
        FPC_FID_DATA pquery_data = {0};
        gsize query_data_len = 0;
@ -966,7 +970,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_ENROLL_CREATE:
+    case FPC_ENROLL_CREATE:
      {
        recv_data_len = sizeof (FPC_BEGIN_ENROL);
        cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@ -981,7 +985,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_ENROLL_CAPTURE:
+    case FPC_ENROLL_CAPTURE:
      {
        guint32 capture_id = FPC_CAPTUREID_RESERVED;
        fpi_device_report_finger_status_changes (device,
@ -999,7 +1003,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_ENROLL_GET_IMG:
+    case FPC_ENROLL_GET_IMG:
      {
        cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA;
        cmd_data.request = FPC_CMD_GET_IMG;
@ -1013,7 +1017,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_ENROLL_UPDATE:
+    case FPC_ENROLL_UPDATE:
      {
        recv_data_len = sizeof (FPC_ENROL);
        cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@ -1028,7 +1032,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_ENROLL_COMPLETE:
+    case FPC_ENROLL_COMPLETE:
      {
        recv_data_len = sizeof (FPC_END_ENROL);
        cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@ -1043,7 +1047,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_ENROLL_CHECK_DUPLICATE:
+    case FPC_ENROLL_CHECK_DUPLICATE:
      {
        recv_data_len = sizeof (FPC_IDENTIFY);
        cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@ -1058,7 +1062,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_ENROLL_BINDID:
+    case FPC_ENROLL_BINDID:
      {
        FPC_FID_DATA data = {0};
        gsize data_len = 0;
@ -1112,7 +1116,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_ENROLL_COMMIT:
+    case FPC_ENROLL_COMMIT:
      {
        recv_data_len = sizeof (gint32);
        cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@ -1127,7 +1131,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_ENROLL_DICARD:
+    case FPC_ENROLL_DICARD:
      {
        cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE;
        cmd_data.request = FPC_CMD_ABORT;
@ -1140,7 +1144,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_ENROLL_CLEANUP:
+    case FPC_ENROLL_CLEANUP:
      {
        if (self->do_cleanup == TRUE)
          {
@ -1285,7 +1289,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)

  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FP_VERIFY_CAPTURE:
+    case FPC_VERIFY_CAPTURE:
      {
        guint32 capture_id = FPC_CAPTUREID_RESERVED;
        fpi_device_report_finger_status_changes (device,
@ -1303,7 +1307,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_VERIFY_GET_IMG:
+    case FPC_VERIFY_GET_IMG:
      {
        cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA;
        cmd_data.request = FPC_CMD_GET_IMG;
@ -1317,7 +1321,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_VERIFY_IDENTIFY:
+    case FPC_VERIFY_IDENTIFY:
      {
        gsize recv_data_len = sizeof (FPC_IDENTIFY);
        cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@ -1332,7 +1336,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_VERIFY_CANCEL:
+    case FPC_VERIFY_CANCEL:
      {
        cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE;
        cmd_data.request = FPC_CMD_ABORT;
@ -1402,7 +1406,7 @@ fpc_clear_sm_run_state (FpiSsm *ssm, FpDevice *device)

  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FP_CLEAR_DELETE_DB:
+    case FPC_CLEAR_DELETE_DB:
      {
        if (self->dbid)
          {
@ -1429,7 +1433,7 @@ fpc_clear_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_CLEAR_CREATE_DB:
+    case FPC_CLEAR_CREATE_DB:
      {
        if (self->dbid)
          {
@ -1534,7 +1538,7 @@ fpc_init_sm_run_state (FpiSsm *ssm, FpDevice *device)

  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FP_INIT:
+    case FPC_INIT:
      cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA;
      cmd_data.request = FPC_CMD_INIT;
      cmd_data.value = 0x1;
@ -1546,7 +1550,7 @@ fpc_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
      fpc_sensor_cmd (self, FALSE, &cmd_data);
      break;

-    case FP_LOAD_DB:
+    case FPC_INIT_LOAD_DB:
      {
        gsize recv_data_len = sizeof (FPC_LOAD_DB);
        cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@ -1637,11 +1641,13 @@ fpc_dev_probe (FpDevice *device)
    {
    case 0xFFE0:
    case 0xA305:
+    case 0xA306:
    case 0xD805:
    case 0xDA04:
    case 0xD205:
    case 0x9524:
    case 0x9544:
+    case 0xC844:
      self->max_enroll_stage = MAX_ENROLL_SAMPLES;
      break;

@ -1678,7 +1684,7 @@ fpc_dev_open (FpDevice *device)
    }

  self->task_ssm = fpi_ssm_new (device, fpc_init_sm_run_state,
-                                FP_INIT_NUM_STATES);
+                                FPC_INIT_NUM_STATES);

  fpi_ssm_start (self->task_ssm, fpc_init_ssm_done);
 }
@ -1690,6 +1696,7 @@ fpc_dev_close (FpDevice *device)

  fp_dbg ("%s enter -->", G_STRFUNC);
  g_clear_pointer (&self->dbid, g_free);
+  g_cancellable_cancel (self->interrupt_cancellable);
  g_clear_object (&self->interrupt_cancellable);
  fpc_dev_release_interface (self, NULL);
 }
@ -1701,8 +1708,8 @@ fpc_dev_verify_identify (FpDevice *device)

  fp_dbg ("%s enter -->", G_STRFUNC);
  self->task_ssm = fpi_ssm_new_full (device, fpc_verify_sm_run_state,
-                                     FP_VERIFY_NUM_STATES,
-                                     FP_VERIFY_CANCEL,
+                                     FPC_VERIFY_NUM_STATES,
+                                     FPC_VERIFY_CANCEL,
                                     "verify_identify");

  fpi_ssm_start (self->task_ssm, fpc_verify_ssm_done);
@ -1718,8 +1725,8 @@ fpc_dev_enroll (FpDevice *device)
  self->enroll_stage = 0;
  self->immobile_stage = 0;
  self->task_ssm = fpi_ssm_new_full (device, fpc_enroll_sm_run_state,
-                                     FP_ENROLL_NUM_STATES,
-                                     FP_ENROLL_DICARD,
+                                     FPC_ENROLL_NUM_STATES,
+                                     FPC_ENROLL_DICARD,
                                     "enroll");

  fpi_ssm_start (self->task_ssm, fpc_enroll_ssm_done);
@ -1770,7 +1777,7 @@ fpc_dev_suspend (FpDevice *device)
    }

  g_assert (self->cmd_ssm);
-  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == FP_CMD_GET_DATA);
+  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == FPC_CMD_GET_DATA);
  self->cmd_suspended = TRUE;
  g_cancellable_cancel (self->interrupt_cancellable);
 }
@ -1792,10 +1799,12 @@ fpc_dev_resume (FpDevice *device)

  g_assert (self->cmd_ssm);
  g_assert (self->cmd_suspended);
-  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == FP_CMD_SUSPENDED);
+  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == FPC_CMD_SUSPENDED);
  self->cmd_suspended = FALSE;
-  g_set_object (&self->interrupt_cancellable, g_cancellable_new ());
-  fpi_ssm_jump_to_state (self->cmd_ssm, FP_CMD_RESUME);
+
+  g_clear_object (&self->interrupt_cancellable);
+  self->interrupt_cancellable = g_cancellable_new ();
+  fpi_ssm_jump_to_state (self->cmd_ssm, FPC_CMD_RESUME);
 }

 static void
@ -1859,8 +1868,8 @@ fpc_dev_clear_storage (FpDevice *device)

  fp_dbg ("%s enter -->", G_STRFUNC);
  self->task_ssm = fpi_ssm_new_full (device, fpc_clear_sm_run_state,
-                                     FP_CLEAR_NUM_STATES,
-                                     FP_CLEAR_NUM_STATES,
+                                     FPC_CLEAR_NUM_STATES,
+                                     FPC_CLEAR_NUM_STATES,
                                     "Clear storage");

  fpi_ssm_start (self->task_ssm, fpc_clear_ssm_done);
--- a/libfprint/drivers/fpcmoc/fpc.h
+++ b/libfprint/drivers/fpcmoc/fpc.h
@ -178,44 +178,44 @@ typedef enum {
 } FpcCmdType;

 typedef enum {
-  FP_CMD_SEND = 0,
-  FP_CMD_GET_DATA,
-  FP_CMD_SUSPENDED,
-  FP_CMD_RESUME,
-  FP_CMD_NUM_STATES,
-} FpCmdState;
+  FPC_CMD_SEND = 0,
+  FPC_CMD_GET_DATA,
+  FPC_CMD_SUSPENDED,
+  FPC_CMD_RESUME,
+  FPC_CMD_NUM_STATES,
+} FpcCmdState;

 typedef enum {
-  FP_INIT = 0,
-  FP_LOAD_DB,
-  FP_INIT_NUM_STATES,
-} FpInitState;
+  FPC_INIT = 0,
+  FPC_INIT_LOAD_DB,
+  FPC_INIT_NUM_STATES,
+} FpcInitState;

 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;
+  FPC_ENROLL_ENUM = 0,
+  FPC_ENROLL_CREATE,
+  FPC_ENROLL_CAPTURE,
+  FPC_ENROLL_GET_IMG,
+  FPC_ENROLL_UPDATE,
+  FPC_ENROLL_COMPLETE,
+  FPC_ENROLL_CHECK_DUPLICATE,
+  FPC_ENROLL_BINDID,
+  FPC_ENROLL_COMMIT,
+  FPC_ENROLL_DICARD,
+  FPC_ENROLL_CLEANUP,
+  FPC_ENROLL_NUM_STATES,
+} FpcEnrollState;

 typedef enum {
-  FP_VERIFY_CAPTURE = 0,
-  FP_VERIFY_GET_IMG,
-  FP_VERIFY_IDENTIFY,
-  FP_VERIFY_CANCEL,
-  FP_VERIFY_NUM_STATES,
-} FpVerifyState;
+  FPC_VERIFY_CAPTURE = 0,
+  FPC_VERIFY_GET_IMG,
+  FPC_VERIFY_IDENTIFY,
+  FPC_VERIFY_CANCEL,
+  FPC_VERIFY_NUM_STATES,
+} FpcVerifyState;

 typedef enum {
-  FP_CLEAR_DELETE_DB = 0,
-  FP_CLEAR_CREATE_DB,
-  FP_CLEAR_NUM_STATES,
+  FPC_CLEAR_DELETE_DB = 0,
+  FPC_CLEAR_CREATE_DB,
+  FPC_CLEAR_NUM_STATES,
 } FpClearState;
--- a/libfprint/drivers/goodixmoc/goodix.c
+++ b/libfprint/drivers/goodixmoc/goodix.c
@ -128,11 +128,13 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
                   GError         *error)
 {
  FpiDeviceGoodixMoc *self = FPI_DEVICE_GOODIXMOC (device);
+  FpiByteReader reader = {0};
  CommandData *data = user_data;
-  int ret = -1, ssm_state = 0;
+  int ssm_state = 0;
  gxfp_cmd_response_t cmd_reponse = {0, };
  pack_header header;
  guint32 crc32_calc = 0;
+  guint32 crc32 = 0;
  guint16 cmd = 0;

  if (error)
@ -154,8 +156,10 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
      return;
    }

-  ret = gx_proto_parse_header (transfer->buffer, transfer->actual_length, &header);
-  if (ret != 0)
+  reader.data = transfer->buffer;
+  reader.size = transfer->actual_length;
+
+  if (gx_proto_parse_header (&reader, &header) != 0)
    {
      fpi_ssm_mark_failed (transfer->ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
@ -163,8 +167,17 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
      return;
    }

+  if (!fpi_byte_reader_set_pos (&reader, PACKAGE_HEADER_SIZE + header.len))
+    {
+      fpi_ssm_mark_failed (transfer->ssm,
+                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
+                                                     "Package crc read failed"));
+    }
+
  gx_proto_crc32_calc (transfer->buffer, PACKAGE_HEADER_SIZE + header.len, (uint8_t *) &crc32_calc);
-  if(crc32_calc != GUINT32_FROM_LE (*(uint32_t *) (transfer->buffer + PACKAGE_HEADER_SIZE + header.len)))
+
+  if (!fpi_byte_reader_get_uint32_le (&reader, &crc32) ||
+      crc32_calc != crc32)
    {
      fpi_ssm_mark_failed (transfer->ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
@ -174,8 +187,11 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,

  cmd = MAKE_CMD_EX (header.cmd0, header.cmd1);

-  ret = gx_proto_parse_body (cmd, &transfer->buffer[PACKAGE_HEADER_SIZE], header.len, &cmd_reponse);
-  if (ret != 0)
+  fpi_byte_reader_set_pos (&reader, 0);
+  reader.data = &transfer->buffer[PACKAGE_HEADER_SIZE];
+  reader.size = header.len;
+
+  if (gx_proto_parse_body (cmd, &reader, &cmd_reponse) != 0)
    {
      fpi_ssm_mark_failed (transfer->ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
@ -222,7 +238,7 @@ fp_cmd_run_state (FpiSsm   *ssm,

  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FP_CMD_SEND:
+    case GOODIX_CMD_SEND:
      if (self->cmd_transfer)
        {
          self->cmd_transfer->ssm = ssm;
@ -238,7 +254,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
        }
      break;

-    case FP_CMD_GET_ACK:
+    case GOODIX_CMD_GET_ACK:
      transfer = fpi_usb_transfer_new (dev);
      transfer->ssm = ssm;
      fpi_usb_transfer_fill_bulk (transfer, EP_IN, EP_IN_MAX_BUF_SIZE);
@ -250,7 +266,7 @@ fp_cmd_run_state (FpiSsm   *ssm,

      break;

-    case FP_CMD_GET_DATA:
+    case GOODIX_CMD_GET_DATA:
      transfer = fpi_usb_transfer_new (dev);
      transfer->ssm = ssm;
      fpi_usb_transfer_fill_bulk (transfer, EP_IN, EP_IN_MAX_BUF_SIZE);
@ -338,7 +354,7 @@ goodix_sensor_cmd (FpiDeviceGoodixMoc *self,

  self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
                               fp_cmd_run_state,
-                               FP_CMD_NUM_STATES);
+                               GOODIX_CMD_NUM_STATES);

  fpi_ssm_set_data (self->cmd_ssm, data, (GDestroyNotify) fp_cmd_ssm_done_data_free);

@ -464,6 +480,35 @@ fp_verify_cb (FpiDeviceGoodixMoc  *self,

 }

+static void
+fp_verify_finger_mode_cb (FpiDeviceGoodixMoc  *self,
+                          gxfp_cmd_response_t *resp,
+                          GError              *error)
+{
+  if (error)
+    {
+      fpi_ssm_mark_failed (self->task_ssm, error);
+      return;
+    }
+  /* if reach max timeout(5sec) finger not up, try again */
+  if (resp->finger_status.status == GX_ERROR_WAIT_FINGER_UP_TIMEOUT)
+    {
+      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_VERIFY_WAIT_FINGER_UP);
+      return;
+    }
+  else if (resp->finger_status.status != GX_SUCCESS)
+    {
+      fpi_ssm_mark_failed (self->task_ssm,
+                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
+                                                     "Switch finger mode failed"));
+      return;
+    }
+  fpi_device_report_finger_status_changes (FP_DEVICE (self),
+                                           FP_FINGER_STATUS_NONE,
+                                           FP_FINGER_STATUS_PRESENT);
+  fpi_ssm_next_state (self->task_ssm);
+}
+
 static void
 fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
 {
@ -477,7 +522,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)

  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FP_VERIFY_PWR_BTN_SHIELD_ON:
+    case GOODIX_VERIFY_PWR_BTN_SHIELD_ON:
      goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_ON,
                         false,
                         NULL,
@ -485,7 +530,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_pwr_btn_shield_cb);
      break;

-    case FP_VERIFY_CAPTURE:
+    case GOODIX_VERIFY_CAPTURE:
      fpi_device_report_finger_status_changes (device,
                                               FP_FINGER_STATUS_NEEDED,
                                               FP_FINGER_STATUS_NONE);
@ -496,7 +541,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_verify_capture_cb);
      break;

-    case FP_VERIFY_IDENTIFY:
+    case GOODIX_VERIFY_IDENTIFY:
      goodix_sensor_cmd (self, MOC_CMD0_IDENTIFY, MOC_CMD1_DEFAULT,
                         false,
                         (const guint8 *) nonce,
@ -504,7 +549,18 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_verify_cb);
      break;

-    case FP_VERIFY_PWR_BTN_SHIELD_OFF:
+    case GOODIX_VERIFY_WAIT_FINGER_UP:
+      {
+        guint8 dummy = 0;
+        goodix_sensor_cmd (self, MOC_CMD0_FINGER_MODE, MOC_CMD1_SET_FINGER_UP,
+                           true,
+                           &dummy,
+                           1,
+                           fp_verify_finger_mode_cb);
+      }
+      break;
+
+    case GOODIX_VERIFY_PWR_BTN_SHIELD_OFF:
      goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_OFF,
                         false,
                         NULL,
@ -666,7 +722,7 @@ fp_enroll_capture_cb (FpiDeviceGoodixMoc  *self,
                                  self->enroll_stage,
                                  NULL,
                                  fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL));
-      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_CAPTURE);
      return;
    }
  fpi_device_report_finger_status_changes (FP_DEVICE (self),
@ -684,7 +740,7 @@ fp_enroll_capture_cb (FpiDeviceGoodixMoc  *self,
                                  self->enroll_stage,
                                  NULL,
                                  fpi_device_retry_new (FP_DEVICE_RETRY_CENTER_FINGER));
-      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_CAPTURE);
      return;
    }
  else
@ -730,7 +786,7 @@ fp_enroll_update_cb (FpiDeviceGoodixMoc  *self,
  /* if enroll complete, no need to wait finger up */
  if (self->enroll_stage >= self->max_enroll_stage)
    {
-      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CHECK_DUPLICATE);
+      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_CHECK_DUPLICATE);
      return;
    }

@ -796,7 +852,7 @@ fp_finger_mode_cb (FpiDeviceGoodixMoc  *self,
  /* if reach max timeout(5sec) finger not up, switch to finger up again */
  if (resp->finger_status.status == GX_ERROR_WAIT_FINGER_UP_TIMEOUT)
    {
-      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_WAIT_FINGER_UP);
+      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_WAIT_FINGER_UP);
      return;
    }
  else if (resp->finger_status.status != GX_SUCCESS)
@ -811,7 +867,7 @@ fp_finger_mode_cb (FpiDeviceGoodixMoc  *self,
                                           FP_FINGER_STATUS_PRESENT);
  if (self->enroll_stage < self->max_enroll_stage)
    {
-      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_CAPTURE);
      return;
    }
  fpi_ssm_next_state (self->task_ssm);
@ -837,7 +893,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)

  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FP_ENROLL_PWR_BTN_SHIELD_ON:
+    case GOODIX_ENROLL_PWR_BTN_SHIELD_ON:
      {
        goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_ON,
                           false,
@ -847,7 +903,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_ENROLL_ENUM:
+    case GOODIX_ENROLL_ENUM:
      {
        goodix_sensor_cmd (self, MOC_CMD0_GETFINGERLIST, MOC_CMD1_DEFAULT,
                           false,
@ -857,7 +913,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_ENROLL_CREATE:
+    case GOODIX_ENROLL_CREATE:
      {
        goodix_sensor_cmd (self, MOC_CMD0_ENROLL_INIT, MOC_CMD1_DEFAULT,
                           false,
@ -867,7 +923,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_ENROLL_CAPTURE:
+    case GOODIX_ENROLL_CAPTURE:
      fpi_device_report_finger_status_changes (device,
                                               FP_FINGER_STATUS_NEEDED,
                                               FP_FINGER_STATUS_NONE);
@ -878,7 +934,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_enroll_capture_cb);
      break;

-    case FP_ENROLL_UPDATE:
+    case GOODIX_ENROLL_UPDATE:
      dummy[0] = 1;
      dummy[1] = self->sensorcfg->config[2];
      dummy[2] = self->sensorcfg->config[3];
@ -889,7 +945,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_enroll_update_cb);
      break;

-    case FP_ENROLL_WAIT_FINGER_UP:
+    case GOODIX_ENROLL_WAIT_FINGER_UP:
      dummy[0] = 0;
      goodix_sensor_cmd (self, MOC_CMD0_FINGER_MODE, MOC_CMD1_SET_FINGER_UP,
                         true,
@ -898,7 +954,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_finger_mode_cb);
      break;

-    case FP_ENROLL_CHECK_DUPLICATE:
+    case GOODIX_ENROLL_CHECK_DUPLICATE:
      goodix_sensor_cmd (self, MOC_CMD0_CHECK4DUPLICATE, MOC_CMD1_DEFAULT,
                         false,
                         (const guint8 *) &dummy,
@ -906,7 +962,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_enroll_check_duplicate_cb);
      break;

-    case FP_ENROLL_COMMIT:
+    case GOODIX_ENROLL_COMMIT:
      {
        fpi_device_get_enroll_data (device, &print);
        user_id = fpi_print_generate_user_id (print);
@ -959,7 +1015,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

-    case FP_ENROLL_PWR_BTN_SHIELD_OFF:
+    case GOODIX_ENROLL_PWR_BTN_SHIELD_OFF:
      {
        goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_OFF,
                           false,
@ -1050,7 +1106,7 @@ fp_init_cb_reset_or_complete (FpiDeviceGoodixMoc  *self,
    {
      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);
+      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_INIT_RESET_DEVICE);
    }
  else
    {
@ -1091,7 +1147,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)

  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FP_INIT_VERSION:
+    case GOODIX_INIT_VERSION:
      goodix_sensor_cmd (self, MOC_CMD0_GET_VERSION, MOC_CMD1_DEFAULT,
                         false,
                         &dummy,
@ -1099,7 +1155,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_init_version_cb);
      break;

-    case FP_INIT_CONFIG:
+    case GOODIX_INIT_CONFIG:
      goodix_sensor_cmd (self, MOC_CMD0_UPDATE_CONFIG, MOC_CMD1_WRITE_CFG_TO_FLASH,
                         false,
                         (guint8 *) self->sensorcfg,
@ -1107,7 +1163,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_init_config_cb);
      break;

-    case FP_INIT_TEMPLATE_LIST:
+    case GOODIX_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
@ -1122,7 +1178,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         fp_init_cb_reset_or_complete);
      break;

-    case FP_INIT_RESET_DEVICE:
+    case GOODIX_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,
@ -1361,11 +1417,13 @@ gx_fp_probe (FpDevice *device)
    case 0x60A2:
    case 0x60A4:
    case 0x6014:
+    case 0x6090:
    case 0x6092:
    case 0x6094:
    case 0x609A:
    case 0x609C:
    case 0x60BC:
+    case 0x60C2:
    case 0x6304:
    case 0x631C:
    case 0x633C:
@ -1380,6 +1438,7 @@ gx_fp_probe (FpDevice *device)
    case 0x6582:
    case 0x6A94:
    case 0x659A:
+    case 0x6890:
      self->max_enroll_stage = 12;
      break;

@ -1435,7 +1494,7 @@ gx_fp_init (FpDevice *device)
    }

  self->task_ssm = fpi_ssm_new (device, fp_init_sm_run_state,
-                                FP_INIT_NUM_STATES);
+                                GOODIX_INIT_NUM_STATES);

  fpi_ssm_start (self->task_ssm, fp_init_ssm_done);

@ -1466,9 +1525,7 @@ gx_fp_exit_cb (FpiDeviceGoodixMoc  *self,
               gxfp_cmd_response_t *resp,
               GError              *error)
 {
-
-
-  if (resp->result >= GX_FAILED)
+  if (resp && resp->result >= GX_FAILED)
    fp_dbg ("Setting power button shield failed, result: 0x%x", resp->result);
  self->is_power_button_shield_on = false;
  gx_fp_release_interface (self, error);
@ -1503,8 +1560,8 @@ gx_fp_verify_identify (FpDevice *device)
  FpiDeviceGoodixMoc *self = FPI_DEVICE_GOODIXMOC (device);

  self->task_ssm = fpi_ssm_new_full (device, fp_verify_sm_run_state,
-                                     FP_VERIFY_NUM_STATES,
-                                     FP_VERIFY_PWR_BTN_SHIELD_OFF,
+                                     GOODIX_VERIFY_NUM_STATES,
+                                     GOODIX_VERIFY_PWR_BTN_SHIELD_OFF,
                                     "verify");

  fpi_ssm_start (self->task_ssm, fp_verify_ssm_done);
@ -1520,8 +1577,8 @@ gx_fp_enroll (FpDevice *device)
  self->enroll_stage = 0;

  self->task_ssm = fpi_ssm_new_full (device, fp_enroll_sm_run_state,
-                                     FP_ENROLL_NUM_STATES,
-                                     FP_ENROLL_PWR_BTN_SHIELD_OFF,
+                                     GOODIX_ENROLL_NUM_STATES,
+                                     GOODIX_ENROLL_PWR_BTN_SHIELD_OFF,
                                     "enroll");

  fpi_ssm_start (self->task_ssm, fp_enroll_ssm_done);
@ -1611,6 +1668,7 @@ fpi_device_goodixmoc_init (FpiDeviceGoodixMoc *self)
 static const FpIdEntry id_table[] = {
  { .vid = 0x27c6,  .pid = 0x5840,  },
  { .vid = 0x27c6,  .pid = 0x6014,  },
+  { .vid = 0x27c6,  .pid = 0x6090,  },
  { .vid = 0x27c6,  .pid = 0x6092,  },
  { .vid = 0x27c6,  .pid = 0x6094,  },
  { .vid = 0x27c6,  .pid = 0x609A,  },
@ -1618,6 +1676,7 @@ static const FpIdEntry id_table[] = {
  { .vid = 0x27c6,  .pid = 0x60A2,  },
  { .vid = 0x27c6,  .pid = 0x60A4,  },
  { .vid = 0x27c6,  .pid = 0x60BC,  },
+  { .vid = 0x27c6,  .pid = 0x60C2,  },
  { .vid = 0x27c6,  .pid = 0x6304,  },
  { .vid = 0x27c6,  .pid = 0x631C,  },
  { .vid = 0x27c6,  .pid = 0x633C,  },
@ -1639,6 +1698,9 @@ static const FpIdEntry id_table[] = {
  { .vid = 0x27c6,  .pid = 0x659C,  },
  { .vid = 0x27c6,  .pid = 0x6A94,  },
  { .vid = 0x27c6,  .pid = 0x6512,  },
+  { .vid = 0x27c6,  .pid = 0x6890,  },
+  { .vid = 0x27c6,  .pid = 0x689A,  },
+  { .vid = 0x27c6,  .pid = 0x66A9,  },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };

--- a/libfprint/drivers/goodixmoc/goodix.h
+++ b/libfprint/drivers/goodixmoc/goodix.h
@ -25,39 +25,40 @@
 G_DECLARE_FINAL_TYPE (FpiDeviceGoodixMoc, fpi_device_goodixmoc, FPI, DEVICE_GOODIXMOC, FpDevice)

 typedef enum {
-  FP_CMD_SEND = 0,
-  FP_CMD_GET_ACK,
-  FP_CMD_GET_DATA,
-  FP_CMD_NUM_STATES,
-} FpCmdState;
+  GOODIX_CMD_SEND = 0,
+  GOODIX_CMD_GET_ACK,
+  GOODIX_CMD_GET_DATA,
+  GOODIX_CMD_NUM_STATES,
+} GoodixCmdState;


 typedef enum {
-  FP_INIT_VERSION = 0,
-  FP_INIT_CONFIG,
-  FP_INIT_TEMPLATE_LIST,
-  FP_INIT_RESET_DEVICE,
-  FP_INIT_NUM_STATES,
-} FpInitState;
+  GOODIX_INIT_VERSION = 0,
+  GOODIX_INIT_CONFIG,
+  GOODIX_INIT_TEMPLATE_LIST,
+  GOODIX_INIT_RESET_DEVICE,
+  GOODIX_INIT_NUM_STATES,
+} GoodixInitState;


 typedef enum {
-  FP_ENROLL_PWR_BTN_SHIELD_ON = 0,
-  FP_ENROLL_ENUM,
-  FP_ENROLL_CREATE,
-  FP_ENROLL_CAPTURE,
-  FP_ENROLL_UPDATE,
-  FP_ENROLL_WAIT_FINGER_UP,
-  FP_ENROLL_CHECK_DUPLICATE,
-  FP_ENROLL_COMMIT,
-  FP_ENROLL_PWR_BTN_SHIELD_OFF,
-  FP_ENROLL_NUM_STATES,
-} FpEnrollState;
+  GOODIX_ENROLL_PWR_BTN_SHIELD_ON = 0,
+  GOODIX_ENROLL_ENUM,
+  GOODIX_ENROLL_CREATE,
+  GOODIX_ENROLL_CAPTURE,
+  GOODIX_ENROLL_UPDATE,
+  GOODIX_ENROLL_WAIT_FINGER_UP,
+  GOODIX_ENROLL_CHECK_DUPLICATE,
+  GOODIX_ENROLL_COMMIT,
+  GOODIX_ENROLL_PWR_BTN_SHIELD_OFF,
+  GOODIX_ENROLL_NUM_STATES,
+} GoodixEnrollState;

 typedef enum {
-  FP_VERIFY_PWR_BTN_SHIELD_ON = 0,
-  FP_VERIFY_CAPTURE,
-  FP_VERIFY_IDENTIFY,
-  FP_VERIFY_PWR_BTN_SHIELD_OFF,
-  FP_VERIFY_NUM_STATES,
-} FpVerifyState;
+  GOODIX_VERIFY_PWR_BTN_SHIELD_ON = 0,
+  GOODIX_VERIFY_CAPTURE,
+  GOODIX_VERIFY_IDENTIFY,
+  GOODIX_VERIFY_WAIT_FINGER_UP,
+  GOODIX_VERIFY_PWR_BTN_SHIELD_OFF,
+  GOODIX_VERIFY_NUM_STATES,
+} GoodixVerifyState;
--- a/libfprint/drivers/goodixmoc/goodix_proto.c
+++ b/libfprint/drivers/goodixmoc/goodix_proto.c
@ -18,6 +18,8 @@
 */

 #include <glib.h>
+#include <stdint.h>
+
 #include "goodix_proto.h"

 /*
@ -107,7 +109,7 @@ reflect (uint32_t data, uint8_t n_bits)
       * If the LSB bit is set, set the reflection of it.
       */
      if (data & 0x01)
-        reflection |= (1 << ((n_bits - 1) - bit));
+        reflection |= (1LU << ((n_bits - 1) - bit));

      data = (data >> 1);
    }
@ -211,7 +213,11 @@ gx_proto_build_package (uint8_t       *ppackage,
  init_pack_header (&header, payload_size, cmd, 0);

  memcpy (ppackage, &header, PACKAGE_HEADER_SIZE);
-  memcpy (ppackage + PACKAGE_HEADER_SIZE, payload, payload_size);
+
+  if (payload)
+    memcpy (ppackage + PACKAGE_HEADER_SIZE, payload, payload_size);
+  else
+    ppackage[PACKAGE_HEADER_SIZE] = 0;

  gx_proto_crc32_calc (ppackage, PACKAGE_HEADER_SIZE + payload_size, ppackage + PACKAGE_HEADER_SIZE + payload_size);

@ -220,94 +226,108 @@ gx_proto_build_package (uint8_t       *ppackage,


 int
-gx_proto_parse_header (
-  uint8_t     *buffer,
-  uint32_t     buffer_len,
-  pack_header *pheader)
+gx_proto_parse_header (FpiByteReader *reader,
+                       pack_header   *pheader)
 {
-  if (!buffer || !pheader)
-    return -1;
-  if (buffer_len < PACKAGE_HEADER_SIZE + PACKAGE_CRC_SIZE)
+  if (!pheader)
    return -1;

-  memcpy (pheader, buffer, sizeof (pack_header));
-  pheader->len = GUINT16_FROM_LE (pheader->len);
-  if (buffer_len < pheader->len + PACKAGE_HEADER_SIZE)
-    return -1;
+  if (!fpi_byte_reader_get_uint8 (reader, &pheader->cmd0))
+    g_return_val_if_reached (-1);
+
+  if (!fpi_byte_reader_get_uint8 (reader, &pheader->cmd1))
+    g_return_val_if_reached (-1);
+
+  if (!fpi_byte_reader_get_uint8 (reader, &pheader->packagenum))
+    g_return_val_if_reached (-1);
+
+  if (!fpi_byte_reader_get_uint8 (reader, &pheader->reserved))
+    g_return_val_if_reached (-1);
+
+  if (!fpi_byte_reader_get_uint16_le (reader, &pheader->len))
+    g_return_val_if_reached (-1);
+
+  if (!fpi_byte_reader_get_uint8 (reader, &pheader->crc8))
+    g_return_val_if_reached (-1);
+
+  if (!fpi_byte_reader_get_uint8 (reader, &pheader->rev_crc8))
+    g_return_val_if_reached (-1);
+
  pheader->len -= PACKAGE_CRC_SIZE;
+
  return 0;
 }

 static int
-gx_proto_parse_fingerid (
-  uint8_t          * fid_buffer,
-  uint16_t           fid_buffer_size,
-  ptemplate_format_t template
-                        )
+gx_proto_parse_fingerid (FpiByteReader     *reader,
+                         ptemplate_format_t template)
 {
-  uint8_t * buffer = NULL;
-  uint16_t Offset = 0;
+  uint8_t byte;
+  const uint8_t *buffer;

-  if (!template || !fid_buffer)
+  if (!template)
    return -1;

-  if (fid_buffer_size < G_STRUCT_OFFSET (template_format_t, payload) + sizeof (uint32_t))
-    return -1;
+  if (!fpi_byte_reader_get_uint8 (reader, &byte) || byte != 67)
+    g_return_val_if_reached (-1);

-  buffer = fid_buffer;
-  Offset = 0;
+  if (!fpi_byte_reader_get_uint8 (reader, &template->type))
+    g_return_val_if_reached (-1);

-  if (buffer[Offset++] != 67)
-    return -1;
+  if (!fpi_byte_reader_get_uint8 (reader, &template->finger_index))
+    g_return_val_if_reached (-1);

-  template->type = buffer[Offset++];
-  template->finger_index = buffer[Offset++];
-  Offset++;
-  memcpy (template->accountid, &buffer[Offset], sizeof (template->accountid));
-  Offset += sizeof (template->accountid);
-  memcpy (template->tid, &buffer[Offset], sizeof (template->tid));
-  Offset += sizeof (template->tid);   // Offset == 68
-  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);
+  if (!fpi_byte_reader_skip (reader, 1))
+    g_return_val_if_reached (-1);
+
+  if (!fpi_byte_reader_get_data (reader, sizeof (template->accountid), &buffer))
+    g_return_val_if_reached (-1);
+
+  memcpy (template->accountid, buffer, sizeof (template->accountid));
+
+  if (!fpi_byte_reader_get_data (reader, sizeof (template->tid), &buffer))
+    g_return_val_if_reached (-1);
+
+  memcpy (template->tid, buffer, sizeof (template->tid));
+
+  if (!fpi_byte_reader_get_uint8 (reader, &template->payload.size))
+    g_return_val_if_reached (-1);
+
+  if (!fpi_byte_reader_get_data (reader, template->payload.size, &buffer))
+    g_return_val_if_reached (-1);
+
+  memcpy (template->payload.data, buffer, template->payload.size);

  return 0;
 }

 int
-gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_cmd_response_t presp)
+gx_proto_parse_body (uint16_t cmd, FpiByteReader *byte_reader, pgxfp_cmd_response_t presp)
 {
-  uint16_t offset = 0;
-  uint8_t *fingerlist = NULL;
+  if (!presp)
+    return -1;
+
+  if (!fpi_byte_reader_get_uint8 (byte_reader, &presp->result))
+    g_return_val_if_reached (-1);

-  if (!buffer || !presp)
-    return -1;
-  if (buffer_len < 1)
-    return -1;
-  presp->result = buffer[0];
  switch (HIBYTE (cmd))
    {
    case RESPONSE_PACKAGE_CMD:
      {
-        if (buffer_len < sizeof (gxfp_parse_msg_t) + 1)
-          return -1;
-        presp->parse_msg.ack_cmd = buffer[1];
+        if (!fpi_byte_reader_get_uint8 (byte_reader, &presp->parse_msg.ack_cmd))
+          g_return_val_if_reached (-1);
      }
      break;

    case MOC_CMD0_UPDATE_CONFIG:
      {
-        presp->finger_config.status = buffer[0];
-        if (buffer_len >= 3)
-          presp->finger_config.max_stored_prints = buffer[2];
-        else
-          /* to compatiable old version firmware */
-          presp->finger_config.max_stored_prints = FP_MAX_FINGERNUM;
+        presp->finger_config.status = presp->result;
+        /* to compatiable old version firmware */
+        presp->finger_config.max_stored_prints = FP_MAX_FINGERNUM;

+        if (fpi_byte_reader_skip (byte_reader, 1))
+          fpi_byte_reader_get_uint8 (byte_reader,
+                                     &presp->finger_config.max_stored_prints);
      }
      break;

@ -318,85 +338,99 @@ gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_c

    case MOC_CMD0_PWR_BTN_SHIELD:
      presp->power_button_shield_resp.resp_cmd1 = LOBYTE (cmd);
-      if (buffer_len >= 2)
-        {
-          uint8_t support_pwr_shield = buffer[1];
-          if (support_pwr_shield == 0xFF)
-            g_debug ("Power button shield feature not supported!\n");
-        }
+      uint8_t support_pwr_shield;
+
+      if (fpi_byte_reader_get_uint8 (byte_reader, &support_pwr_shield) &&
+          support_pwr_shield == 0xFF)
+        g_debug ("Power button shield feature not supported!\n");
      break;

    case MOC_CMD0_GET_VERSION:
-      if (buffer_len < sizeof (gxfp_version_info_t) + 1)
-        return -1;
-      memcpy (&presp->version_info, buffer + 1, sizeof (gxfp_version_info_t));
+      const uint8_t *version_info;
+
+      if (!fpi_byte_reader_get_data (byte_reader, sizeof (gxfp_version_info_t), &version_info))
+        g_return_val_if_reached (-1);
+
+      memcpy (&presp->version_info, version_info, sizeof (gxfp_version_info_t));
      break;

    case MOC_CMD0_CAPTURE_DATA:
      if (LOBYTE (cmd) == MOC_CMD1_DEFAULT)
        {
-          if (buffer_len < sizeof (gxfp_capturedata_t) + 1)
-            return -1;
-          presp->capture_data_resp.img_quality  = buffer[1];
-          presp->capture_data_resp.img_coverage = buffer[2];
+          if (!fpi_byte_reader_get_uint8 (byte_reader,
+                                          &presp->capture_data_resp.img_quality))
+            g_return_val_if_reached (-1);
+
+          if (!fpi_byte_reader_get_uint8 (byte_reader,
+                                          &presp->capture_data_resp.img_coverage))
+            g_return_val_if_reached (-1);
        }
      break;

    case MOC_CMD0_ENROLL_INIT:
-      if (buffer_len < sizeof (gxfp_enroll_create_t) + 1)
-        return -1;
-      if (presp->result == GX_SUCCESS)
-        memcpy (&presp->enroll_create.tid, &buffer[1], TEMPLATE_ID_SIZE);
+      if (presp->result != GX_SUCCESS)
+        break;
+      const uint8_t *tid;
+      if (!fpi_byte_reader_get_data (byte_reader, TEMPLATE_ID_SIZE, &tid))
+        g_return_val_if_reached (-1);
+      memcpy (presp->enroll_create.tid, tid, TEMPLATE_ID_SIZE);
      break;

    case MOC_CMD0_ENROLL:
-      if (buffer_len < sizeof (gxfp_enroll_update_t))
-        return -1;
-      presp->enroll_update.rollback = (buffer[0] < 0x80) ? false : true;
-      presp->enroll_update.img_overlay    = buffer[1];
-      presp->enroll_update.img_preoverlay = buffer[2];
+      presp->enroll_update.rollback = (presp->result < 0x80) ? false : true;
+      if (!fpi_byte_reader_get_uint8 (byte_reader,
+                                      &presp->enroll_update.img_overlay))
+        g_return_val_if_reached (-1);
+
+      if (!fpi_byte_reader_get_uint8 (byte_reader,
+                                      &presp->enroll_update.img_preoverlay))
+        g_return_val_if_reached (-1);
      break;

    case MOC_CMD0_CHECK4DUPLICATE:
      presp->check_duplicate_resp.duplicate = (presp->result == 0) ? false : true;
      if (presp->check_duplicate_resp.duplicate)
        {
-          if (buffer_len < 3)
-            return -1;
-          uint16_t tid_size = GUINT16_FROM_LE (*(uint16_t *) (buffer + 1));
-          offset += 3;
+          uint16_t tid_size;
+          FpiByteReader tid_reader;

-          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;
+          if (!fpi_byte_reader_get_uint16_le (byte_reader, &tid_size))
+            g_return_val_if_reached (-1);
+
+          if (!fpi_byte_reader_get_sub_reader (byte_reader, &tid_reader, tid_size))
+            g_return_val_if_reached (-1);
+
+          if (gx_proto_parse_fingerid (&tid_reader, &presp->check_duplicate_resp.template) != 0)
+            g_return_val_if_reached (-1);
        }
      break;

    case MOC_CMD0_GETFINGERLIST:
      if (presp->result != GX_SUCCESS)
        break;
-      if (buffer_len < 2)
-        return -1;
-      presp->finger_list_resp.finger_num = buffer[1];
-      fingerlist = buffer + 2;
+
+      if (!fpi_byte_reader_get_uint8 (byte_reader,
+                                      &presp->finger_list_resp.finger_num))
+        g_return_val_if_reached (-1);
+
      for(uint8_t num = 0; num < presp->finger_list_resp.finger_num; num++)
        {
          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)
-            return -1;
-          if (gx_proto_parse_fingerid (fingerlist + offset,
-                                       fingerid_length,
+          FpiByteReader fingerid_reader;
+
+          if (!fpi_byte_reader_get_uint16_le (byte_reader, &fingerid_length))
+            g_return_val_if_reached (-1);
+
+          if (!fpi_byte_reader_get_sub_reader (byte_reader, &fingerid_reader,
+                                               fingerid_length))
+            g_return_val_if_reached (-1);
+
+          if (gx_proto_parse_fingerid (&fingerid_reader,
                                       &presp->finger_list_resp.finger_list[num]) != 0)
            {
              g_warning ("Failed to parse finger list");
-              return -1;
+              g_return_val_if_reached (-1);
            }
-          offset += fingerid_length;
        }
      break;

@ -405,23 +439,32 @@ gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_c
        uint32_t score = 0;
        uint8_t study = 0;
        uint16_t fingerid_size = 0;
-        presp->verify.match = (buffer[0] == 0) ? true : false;
+
+        presp->verify.match = (presp->result == 0) ? true : false;
+
        if (presp->verify.match)
          {
-            if (buffer_len < 10)
-              return -1;
-            offset += 1;
-            presp->verify.rejectdetail = GUINT16_FROM_LE (*(uint16_t *) (buffer + offset));
-            offset += 2;
-            score = GUINT32_FROM_LE (*(uint32_t *) (buffer + offset));
-            offset += 4;
-            study = buffer[offset];
-            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)
+            FpiByteReader finger_reader;
+
+            if (!fpi_byte_reader_get_uint16_le (byte_reader,
+                                                &presp->verify.rejectdetail))
+              g_return_val_if_reached (-1);
+
+            if (!fpi_byte_reader_get_uint32_le (byte_reader, &score))
+              g_return_val_if_reached (-1);
+
+            if (!fpi_byte_reader_get_uint8 (byte_reader, &study))
+              g_return_val_if_reached (-1);
+
+            if (!fpi_byte_reader_get_uint16_le (byte_reader, &fingerid_size))
+              g_return_val_if_reached (-1);
+
+            if (!fpi_byte_reader_get_sub_reader (byte_reader, &finger_reader,
+                                                 fingerid_size))
+              g_return_val_if_reached (-1);
+
+            if (gx_proto_parse_fingerid (&finger_reader,
+                                         &presp->verify.template) != 0)
              {
                presp->result = GX_FAILED;
                break;
@ -432,7 +475,7 @@ gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_c
      break;

    case MOC_CMD0_FINGER_MODE:
-      presp->finger_status.status = buffer[0];
+      presp->finger_status.status = presp->result;
      break;

    default:
--- a/libfprint/drivers/goodixmoc/goodix_proto.h
+++ b/libfprint/drivers/goodixmoc/goodix_proto.h
@ -22,6 +22,8 @@
 #include <stdbool.h>
 #include <string.h>

+#include "fpi-byte-reader.h"
+
 #define PACKAGE_CRC_SIZE (4)
 #define PACKAGE_HEADER_SIZE (8)

@ -133,7 +135,7 @@ typedef struct _template_format
 typedef struct _gxfp_verify
 {
  bool     match;
-  uint32_t rejectdetail;
+  uint16_t rejectdetail;
  template_format_t  template;
 } gxfp_verify_t, *pgxfp_verify_t;

@ -232,13 +234,11 @@ int gx_proto_build_package (uint8_t       *ppackage,
                            const uint8_t *payload,
                            uint32_t       payload_size);

-int gx_proto_parse_header (uint8_t     *buffer,
-                           uint32_t     buffer_len,
-                           pack_header *pheader);
+int gx_proto_parse_header (FpiByteReader *reader,
+                           pack_header   *pheader);

 int gx_proto_parse_body (uint16_t             cmd,
-                         uint8_t             *buffer,
-                         uint16_t             buffer_len,
+                         FpiByteReader       *byte_reader,
                         pgxfp_cmd_response_t presponse);

 int gx_proto_init_sensor_config (pgxfp_sensor_cfg_t pconfig);
--- a/libfprint/drivers/realtek/realtek.c
+++ b/libfprint/drivers/realtek/realtek.c
@ -29,6 +29,7 @@ G_DEFINE_TYPE (FpiDeviceRealtek, fpi_device_realtek, FP_TYPE_DEVICE)
 static const FpIdEntry id_table[] = {
  { .vid = 0x0bda,  .pid = 0x5813,  },
  { .vid = 0x0bda,  .pid = 0x5816,  },
+  { .vid = 0x2541,  .pid = 0xfa03,  },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };

@ -1071,24 +1072,22 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      break;

    case FP_RTK_ENROLL_COMMIT:
-      guint8 *trans_id = NULL;
+      gchar *valid_uid = NULL;
      gint payload_len;

      payload_len = UID_PAYLOAD_LEN_DEFAULT;

      fpi_device_get_enroll_data (device, &print);
      user_id = fpi_print_generate_user_id (print);
-      user_id_len = strlen (user_id);
-      user_id_len = MIN (DEFAULT_UID_LEN, user_id_len);
+      user_id_len = MIN (DEFAULT_UID_LEN, strlen (user_id));

      payload = g_malloc0 (payload_len);
      memcpy (payload, user_id, user_id_len);
-
-      trans_id = g_steal_pointer (&payload);
+      valid_uid = (gchar *) payload;

      finger = SUB_FINGER_01;
      uid = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE,
-                                       user_id,
+                                       valid_uid,
                                       user_id_len,
                                       1);
      data = g_variant_new ("(y@ay)",
@ -1098,7 +1097,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      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", user_id, NULL);
+      g_object_set (print, "description", valid_uid, NULL);

      g_debug ("user_id: %s, finger: 0x%x", user_id, finger);

@ -1107,7 +1106,8 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      nor_enroll_commit.data_len[1] = GET_LEN_H (payload_len);

      cmd_buf = (guint8 *) &nor_enroll_commit;
-      rtk_sensor_bulk_cmd (self, cmd_buf, trans_id, FP_RTK_MSG_DEFAULT, 1, fp_enroll_commit_cb);
+      rtk_sensor_bulk_cmd (self, cmd_buf, g_steal_pointer (&payload),
+                           FP_RTK_MSG_DEFAULT, 1, fp_enroll_commit_cb);
      break;

    case FP_RTK_ENROLL_CANCEL_CAPTURE:
--- a/libfprint/drivers/synaptics/bmkt_message.c
+++ b/libfprint/drivers/synaptics/bmkt_message.c
@ -256,7 +256,8 @@ bmkt_compose_message (uint8_t *cmd, int *cmd_len, uint8_t msg_id, uint8_t seq_nu
  cmd[BMKT_MESSAGE_SEQ_NUM_FIELD] = seq_num;
  cmd[BMKT_MESSAGE_ID_FIELD] = msg_id;
  cmd[BMKT_MESSAGE_PAYLOAD_LEN_FIELD] = payload_size;
-  memcpy (&cmd[BMKT_MESSAGE_PAYLOAD_FIELD], payload, payload_size);
+  if (payload_size > 0)
+    memcpy (&cmd[BMKT_MESSAGE_PAYLOAD_FIELD], payload, payload_size);

  *cmd_len = message_len;

--- a/libfprint/drivers/synaptics/synaptics.c
+++ b/libfprint/drivers/synaptics/synaptics.c
@ -32,25 +32,35 @@ static void compose_and_send_identify_msg (FpDevice *device);

 static const FpIdEntry id_table[] = {
  { .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 = 0x00C4,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0100,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C6,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00DF,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00E9,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F0,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F9,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00FC,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0100,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0103,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0104,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0106,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0107,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0108,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0109,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x010A,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0123,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0124,  },
  { .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 = SYNAPTICS_VENDOR_ID,  .pid = 0x0168,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0169,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x016C,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0173,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0106,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0174,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x019D,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C6,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x019F,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x01A0,  },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };

@ -1250,6 +1260,12 @@ dev_probe (FpDevice *device)
      return;
    }

+  if (!g_usb_device_reset (usb_dev, &error))
+    {
+      fp_dbg ("%s g_usb_device_reset failed %s", G_STRFUNC, error->message);
+      goto err_close;
+    }
+
  if (!g_usb_device_claim_interface (usb_dev, 0, 0, &error))
    goto err_close;

--- a/libfprint/drivers/upekts.c
+++ b/libfprint/drivers/upekts.c
@ -196,8 +196,9 @@ struct read_msg_data
 static void __read_msg_async (FpDevice             *dev,
                              struct read_msg_data *udata);

-#define READ_MSG_DATA_CB_ERR(dev, udata, error) (udata)->callback (dev, \
-                                                                   READ_MSG_CMD, 0, 0, NULL, 0, (udata)->user_data, error)
+#define READ_MSG_DATA_CB_ERR(dev, udata, error) \
+  (udata)->callback (dev, \
+                     READ_MSG_CMD, 0, 0, NULL, 0, (udata)->user_data, error)

 static void
 busy_ack_sent_cb (FpiUsbTransfer *transfer, FpDevice *device,
@ -1243,7 +1244,7 @@ do_verify_stop (FpDevice *dev, FpiMatchResult res, GError *error)
  FpiSsm *ssm = deinitsm_new (dev, data);

  /* Report the error immediately if possible, otherwise delay it. */
-  if (error && error->domain == FP_DEVICE_RETRY)
+  if (!error || error->domain == FP_DEVICE_RETRY)
    fpi_device_verify_report (dev, res, NULL, error);
  else
    data->error = error;
@ -1295,7 +1296,7 @@ verify_start_sm_run_state (FpiSsm *ssm, FpDevice *dev)
      memcpy (msg, verify_hdr, sizeof (verify_hdr));
      memcpy (msg + sizeof (verify_hdr), data, data_len);

-      transfer = alloc_send_cmd28_transfer (dev, 0x03, data, data_len);
+      transfer = alloc_send_cmd28_transfer (dev, 0x03, msg, msg_len);

      g_free (msg);

@ -1341,7 +1342,6 @@ v_handle_resp00 (FpDevice *dev, unsigned char *data,
      fp_dbg ("good image");
      break;

-    case 0x1c:     /* FIXME what does this one mean? */
    case 0x0b:     /* FIXME what does this one mean? */
    case 0x23:     /* FIXME what does this one mean? */
      error = fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL);
@ -1351,6 +1351,14 @@ v_handle_resp00 (FpDevice *dev, unsigned char *data,
      error = fpi_device_retry_new (FP_DEVICE_RETRY_REMOVE_FINGER);
      break;

+    case 0x1c:     /* swipe too fast */
+      error = fpi_device_retry_new (FP_DEVICE_RETRY_TOO_FAST);
+      break;
+
+    case 0x1d:     /* too much horizontal movement */
+      error = fpi_device_retry_new (FP_DEVICE_RETRY_CENTER_FINGER);
+      break;
+
    case 0x1e:     /* swipe too short */
      error = fpi_device_retry_new (FP_DEVICE_RETRY_TOO_SHORT);
      break;
@ -1439,7 +1447,7 @@ verify_rd2800_cb (FpDevice *dev, enum read_msg_type msgtype,
      do_verify_stop (dev,
                      FPI_MATCH_ERROR,
                      fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                                "Response hat wrong command sequence"));
+                                                "Response had wrong command sequence"));
      return;
    }

--- a/libfprint/drivers/uru4000.c
+++ b/libfprint/drivers/uru4000.c
@ -20,8 +20,8 @@

 #define FP_COMPONENT "uru4000"

-#include <nss.h>
-#include <pk11pub.h>
+#include <openssl/evp.h>
+#include <openssl/err.h>

 #include "drivers_api.h"

@ -148,10 +148,7 @@ struct _FpiDeviceUru4000
  int                             fwfixer_offset;
  unsigned char                   fwfixer_value;

-  CK_MECHANISM_TYPE               cipher;
-  PK11SlotInfo                   *slot;
-  PK11SymKey                     *symkey;
-  SECItem                        *param;
+  EVP_CIPHER_CTX                 *cipher_ctx;
 };
 G_DECLARE_FINAL_TYPE (FpiDeviceUru4000, fpi_device_uru4000, FPI, DEVICE_URU4000,
                      FpImageDevice);
@ -246,13 +243,29 @@ response_cb (FpiUsbTransfer *transfer, FpDevice *dev, void *user_data, GError *e
    fpi_ssm_mark_failed (ssm, error);
 }

+static GError *
+openssl_device_error (void)
+{
+  char buf[256];
+  unsigned long e;
+
+  e = ERR_get_error ();
+  if (e == 0)
+    return fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
+                                     "unexpected OpenSSL error");
+
+  ERR_error_string_n (e, buf, G_N_ELEMENTS (buf));
+
+  return fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL, "OpenSSL error: %s",
+                                   buf);
+}
+
 static void
 challenge_cb (FpiUsbTransfer *transfer, FpDevice *dev, void *user_data, GError *error)
 {
  FpiSsm *ssm = user_data;
  FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev);
-  unsigned char respdata[CR_LENGTH];
-  PK11Context *ctx;
+  unsigned char respdata[CR_LENGTH * 2];
  int outlen;

  if (error)
@ -261,17 +274,39 @@ challenge_cb (FpiUsbTransfer *transfer, FpDevice *dev, void *user_data, GError *
      return;
    }

+  if (transfer->actual_length != CR_LENGTH)
+    {
+      error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
+                                        "Unexpected buffer length (%" G_GSIZE_FORMAT
+                                        "instead of %d)",
+                                        transfer->actual_length, CR_LENGTH);
+      fpi_ssm_mark_failed (ssm, g_steal_pointer (&error));
+      return;
+    }
+
  /* submit response */
  /* produce response from challenge */
-  ctx = PK11_CreateContextBySymKey (self->cipher, CKA_ENCRYPT,
-                                    self->symkey, self->param);
-  if (PK11_CipherOp (ctx, respdata, &outlen, CR_LENGTH, transfer->buffer, CR_LENGTH) != SECSuccess ||
-      PK11_Finalize (ctx) != SECSuccess)
+  if (!EVP_EncryptUpdate (self->cipher_ctx, respdata, &outlen, transfer->buffer, CR_LENGTH))
    {
-      fp_err ("Failed to encrypt challenge data");
-      error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, "Failed to encrypt challenge data");
+      fpi_ssm_mark_failed (ssm, openssl_device_error ());
+      return;
+    }
+
+  if (outlen != CR_LENGTH)
+    {
+      error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
+                                        "Unexpected encrypted buffer length (%d"
+                                        "instead of %d)",
+                                        outlen, CR_LENGTH);
+      fpi_ssm_mark_failed (ssm, g_steal_pointer (&error));
+      return;
+    }
+
+  if (!EVP_EncryptFinal_ex (self->cipher_ctx, respdata + outlen, &outlen))
+    {
+      fpi_ssm_mark_failed (ssm, openssl_device_error ());
+      return;
    }
-  PK11_DestroyContext (ctx, PR_TRUE);

  if (!error)
    write_regs (FP_IMAGE_DEVICE (dev), REG_RESPONSE, CR_LENGTH, respdata, response_cb, ssm);
@ -703,9 +738,9 @@ imaging_run_state (FpiSsm *ssm, FpDevice *_dev)

    case IMAGING_DECODE:
      key  = self->last_reg_rd[0];
-      key |= self->last_reg_rd[1] << 8;
-      key |= self->last_reg_rd[2] << 16;
-      key |= self->last_reg_rd[3] << 24;
+      key |= (uint32_t) self->last_reg_rd[1] << 8;
+      key |= (uint32_t) self->last_reg_rd[2] << 16;
+      key |= (uint32_t) self->last_reg_rd[3] << 24;
      key ^= self->img_enc_seed;

      fp_dbg ("encryption id %02x -> key %08x", img->key_number, key);
@ -1270,8 +1305,6 @@ dev_init (FpImageDevice *dev)
  g_autoptr(GPtrArray) interfaces = NULL;
  GUsbInterface *iface = NULL;
  guint64 driver_data;
-  SECStatus rv;
-  SECItem item;
  int i;

  interfaces = g_usb_device_get_interfaces (fpi_device_get_usb_device (FP_DEVICE (dev)), &error);
@ -1343,20 +1376,6 @@ dev_init (FpImageDevice *dev)
      return;
    }

-  /* Disable loading p11-kit's user configuration */
-  g_setenv ("P11_KIT_NO_USER_CONFIG", "1", TRUE);
-
-  /* Initialise NSS early */
-  rv = NSS_NoDB_Init (".");
-  if (rv != SECSuccess)
-    {
-      fp_err ("could not initialise NSS");
-      fpi_image_device_open_complete (dev,
-                                      fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
-                                                                "Could not initialise NSS"));
-      return;
-    }
-
  self = FPI_DEVICE_URU4000 (dev);

  g_clear_pointer (&self->rand, g_rand_free);
@ -1369,35 +1388,17 @@ dev_init (FpImageDevice *dev)
  self->interface = g_usb_interface_get_number (iface);

  /* Set up encryption */
-  self->cipher = CKM_AES_ECB;
-  self->slot = PK11_GetBestSlot (self->cipher, NULL);
-  if (self->slot == NULL)
+  if (!(self->cipher_ctx = EVP_CIPHER_CTX_new ()))
    {
-      fp_err ("could not get encryption slot");
-      fpi_image_device_open_complete (dev,
-                                      fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
-                                                                "Could not get encryption slot"));
+      fpi_image_device_open_complete (dev, openssl_device_error ());
      return;
    }
-  item.type = siBuffer;
-  item.data = (unsigned char *) crkey;
-  item.len = sizeof (crkey);
-  self->symkey = PK11_ImportSymKey (self->slot,
-                                    self->cipher,
-                                    PK11_OriginUnwrap,
-                                    CKA_ENCRYPT,
-                                    &item, NULL);
-  if (self->symkey == NULL)
+
+  if (!EVP_EncryptInit_ex (self->cipher_ctx, EVP_aes_128_ecb (), NULL, crkey, NULL))
    {
-      fp_err ("failed to import key into NSS");
-      PK11_FreeSlot (self->slot);
-      self->slot = NULL;
-      fpi_image_device_open_complete (dev,
-                                      fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
-                                                                "Failed to import key into NSS"));
+      fpi_image_device_open_complete (dev, openssl_device_error ());
      return;
    }
-  self->param = PK11_ParamFromIV (self->cipher, NULL);

  fpi_image_device_open_complete (dev, NULL);
 }
@ -1408,14 +1409,7 @@ dev_deinit (FpImageDevice *dev)
  GError *error = NULL;
  FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev);

-  if (self->symkey)
-    PK11_FreeSymKey (self->symkey);
-  if (self->param)
-    SECITEM_FreeItem (self->param, PR_TRUE);
-  if (self->slot)
-    PK11_FreeSlot (self->slot);
-
-  NSS_Shutdown ();
+  g_clear_pointer (&self->cipher_ctx, EVP_CIPHER_CTX_free);

  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)),
                                  self->interface, 0, &error);
--- a/libfprint/drivers/vfs101.c
+++ b/libfprint/drivers/vfs101.c
@ -162,9 +162,9 @@ enum {

 /* Dump buffer for debug */
 #define dump_buffer(buf) \
-        fp_dbg ("%02x %02x %02x %02x %02x %02x %02x %02x", \
-                buf[6], buf[7], buf[8], buf[9], buf[10], buf[11], buf[12], buf[13] \
-               )
+  fp_dbg ("%02x %02x %02x %02x %02x %02x %02x %02x", \
+          buf[6], buf[7], buf[8], buf[9], buf[10], buf[11], buf[12], buf[13] \
+         )

 /* Callback of asynchronous send */
 static void
--- a/libfprint/drivers/vfs301_proto.c
+++ b/libfprint/drivers/vfs301_proto.c
@ -157,7 +157,7 @@ vfs301_proto_generate_0B (int subtype, gssize *len)
 }

 #define HEX_TO_INT(c) \
-        (((c) >= '0' && (c) <= '9') ? ((c) - '0') : ((c) - 'A' + 10))
+  (((c) >= '0' && (c) <= '9') ? ((c) - '0') : ((c) - 'A' + 10))

 static guint8 *
 translate_str (const char **srcL, gssize *len)
@ -422,15 +422,15 @@ img_process_data (int first_block, FpDeviceVfs301 *dev, const guint8 *buf, int l
 /************************** PROTOCOL STUFF ************************************/

 #define USB_RECV(from, len) \
-        usb_recv (dev, from, len, NULL, NULL)
+  usb_recv (dev, from, len, NULL, NULL)

 #define USB_SEND(type, subtype) \
-        { \
-          const guint8 *data; \
-          gssize len; \
-          data = vfs301_proto_generate (type, subtype, &len); \
-          usb_send (dev, data, len, NULL); \
-        }
+  { \
+    const guint8 *data; \
+    gssize len; \
+    data = vfs301_proto_generate (type, subtype, &len); \
+    usb_send (dev, data, len, NULL); \
+  }

 #define RAW_DATA(x) g_memdup2 (x, sizeof (x)), sizeof (x)

@ -489,13 +489,13 @@ vfs301_proto_peek_event (FpDeviceVfs301 *dev)
 *      we will run into timeouts randomly and need to then try again.
 */
 #define PARALLEL_RECEIVE(e1, l1, e2, l2) \
-        { \
-          g_autoptr(GError) error = NULL; \
-          usb_recv (dev, e1, l1, NULL, &error); \
-          usb_recv (dev, e2, l2, NULL, NULL); \
-          if (g_error_matches (error, G_USB_DEVICE_ERROR, G_USB_DEVICE_ERROR_TIMED_OUT)) \
-          usb_recv (dev, e1, l1, NULL, NULL); \
-        }
+  { \
+    g_autoptr(GError) error = NULL; \
+    usb_recv (dev, e1, l1, NULL, &error); \
+    usb_recv (dev, e2, l2, NULL, NULL); \
+    if (g_error_matches (error, G_USB_DEVICE_ERROR, G_USB_DEVICE_ERROR_TIMED_OUT)) \
+    usb_recv (dev, e1, l1, NULL, NULL); \
+  }

 static void
 vfs301_proto_process_event_cb (FpiUsbTransfer *transfer,
--- a/libfprint/drivers/vfs5011.c
+++ b/libfprint/drivers/vfs5011.c
@ -41,30 +41,30 @@ struct usb_action
 };

 #define SEND(ENDPOINT, COMMAND) \
-        { \
-          .type = ACTION_SEND, \
-          .endpoint = ENDPOINT, \
-          .name = #COMMAND, \
-          .size = sizeof (COMMAND), \
-          .data = COMMAND \
-        },
+  { \
+    .type = ACTION_SEND, \
+    .endpoint = ENDPOINT, \
+    .name = #COMMAND, \
+    .size = sizeof (COMMAND), \
+    .data = COMMAND \
+  },

 #define RECV(ENDPOINT, SIZE) \
-        { \
-          .type = ACTION_RECEIVE, \
-          .endpoint = ENDPOINT, \
-          .size = SIZE, \
-          .data = NULL \
-        },
+  { \
+    .type = ACTION_RECEIVE, \
+    .endpoint = ENDPOINT, \
+    .size = SIZE, \
+    .data = NULL \
+  },

 #define RECV_CHECK(ENDPOINT, SIZE, EXPECTED) \
-        { \
-          .type = ACTION_RECEIVE, \
-          .endpoint = ENDPOINT, \
-          .size = SIZE, \
-          .data = EXPECTED, \
-          .correct_reply_size = sizeof (EXPECTED) \
-        },
+  { \
+    .type = ACTION_RECEIVE, \
+    .endpoint = ENDPOINT, \
+    .size = SIZE, \
+    .data = EXPECTED, \
+    .correct_reply_size = sizeof (EXPECTED) \
+  },

 struct usbexchange_data
 {
--- a/libfprint/drivers/vfs7552.c
+++ b/libfprint/drivers/vfs7552.c
@ -51,39 +51,39 @@ struct usb_action
 };

 #define SEND(ENDPOINT, COMMAND) \
-        {                             \
-          .type = ACTION_SEND,        \
-          .endpoint = ENDPOINT,       \
-          .name = #COMMAND,           \
-          .size = sizeof (COMMAND),   \
-          .data = COMMAND             \
-        },
+  {                             \
+    .type = ACTION_SEND,        \
+    .endpoint = ENDPOINT,       \
+    .name = #COMMAND,           \
+    .size = sizeof (COMMAND),   \
+    .data = COMMAND             \
+  },

 #define RECV(ENDPOINT, SIZE)  \
-        {                           \
-          .type = ACTION_RECEIVE,   \
-          .endpoint = ENDPOINT,     \
-          .size = SIZE,             \
-          .data = NULL              \
-        },
+  {                           \
+    .type = ACTION_RECEIVE,   \
+    .endpoint = ENDPOINT,     \
+    .size = SIZE,             \
+    .data = NULL              \
+  },

 #define RECV_CHECK(ENDPOINT, SIZE, EXPECTED) \
-        {                                          \
-          .type = ACTION_RECEIVE,                  \
-          .endpoint = ENDPOINT,                    \
-          .size = SIZE,                            \
-          .data = EXPECTED,                        \
-          .correct_reply_size = sizeof (EXPECTED)  \
-        },
+  {                                          \
+    .type = ACTION_RECEIVE,                  \
+    .endpoint = ENDPOINT,                    \
+    .size = SIZE,                            \
+    .data = EXPECTED,                        \
+    .correct_reply_size = sizeof (EXPECTED)  \
+  },

 #define RECV_CHECK_SIZE(ENDPOINT, SIZE, EXPECTED) \
-        {                                               \
-          .type = ACTION_RECEIVE,                       \
-          .endpoint = ENDPOINT,                         \
-          .size = SIZE,                                 \
-          .data = NULL,                                 \
-          .correct_reply_size = sizeof (EXPECTED)       \
-        },
+  {                                               \
+    .type = ACTION_RECEIVE,                       \
+    .endpoint = ENDPOINT,                         \
+    .size = SIZE,                                 \
+    .data = NULL,                                 \
+    .correct_reply_size = sizeof (EXPECTED)       \
+  },

 struct usbexchange_data
 {
--- a/libfprint/drivers/virtual-device.c
+++ b/libfprint/drivers/virtual-device.c
@ -772,6 +772,7 @@ fpi_device_virtual_device_class_init (FpDeviceVirtualDeviceClass *klass)
 {
  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  const char *hot_seconds;

  object_class->finalize = fpi_device_virtual_device_finalize;

@ -787,5 +788,18 @@ fpi_device_virtual_device_class_init (FpDeviceVirtualDeviceClass *klass)
  dev_class->enroll = dev_enroll;
  dev_class->cancel = dev_cancel;

+  if ((hot_seconds = g_getenv ("FP_VIRTUAL_DEVICE_HOT_SECONDS")) &&
+      *hot_seconds != '\0')
+    {
+      gint64 hot_seconds_value;
+
+      hot_seconds_value = g_ascii_strtoll (hot_seconds, NULL, 10);
+      if (hot_seconds_value >= G_MAXINT32 || hot_seconds_value < 0)
+        hot_seconds_value = -1;
+
+      dev_class->temp_hot_seconds = hot_seconds_value;
+      g_debug ("device hot seconds set to %d", dev_class->temp_hot_seconds);
+    }
+
  fpi_device_class_auto_initialize_features (dev_class);
 }
--- a/libfprint/drivers/virtual-image.c
+++ b/libfprint/drivers/virtual-image.c
@ -191,12 +191,12 @@ on_listener_connected (FpiDeviceVirtualListener *listener,

  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_IDLE:
+    case FPI_IMAGE_DEVICE_STATE_AWAIT_FINGER_OFF:
    case FPI_IMAGE_DEVICE_STATE_INACTIVE:
    case FPI_IMAGE_DEVICE_STATE_ACTIVATING:
    case FPI_IMAGE_DEVICE_STATE_DEACTIVATING:
@ -310,6 +310,7 @@ fpi_device_virtual_image_class_init (FpDeviceVirtualImageClass *klass)
 {
  FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
+  const char *hot_seconds;

  dev_class->id = FP_COMPONENT;
  dev_class->full_name = "Virtual image device for debugging";
@ -321,4 +322,17 @@ fpi_device_virtual_image_class_init (FpDeviceVirtualImageClass *klass)

  img_class->activate = dev_activate;
  img_class->deactivate = dev_deactivate;
+
+  if ((hot_seconds = g_getenv ("FP_VIRTUAL_IMAGE_HOT_SECONDS")) &&
+      *hot_seconds != '\0')
+    {
+      gint64 hot_seconds_value;
+
+      hot_seconds_value = g_ascii_strtoll (hot_seconds, NULL, 10);
+      if (hot_seconds_value >= G_MAXINT32 || hot_seconds_value < 0)
+        hot_seconds_value = -1;
+
+      dev_class->temp_hot_seconds = hot_seconds_value;
+      g_debug ("device hot seconds set to %d", dev_class->temp_hot_seconds);
+    }
 }
--- a/libfprint/fp-device.c
+++ b/libfprint/fp-device.c
@ -483,6 +483,9 @@ fp_device_class_init (FpDeviceClass *klass)
                         NULL,
                         G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);

+  /**
+   * FpDevice:open: (getter is_open):
+   */
  properties[PROP_OPEN] =
    g_param_spec_boolean ("open",
                          "Opened",
@ -1103,8 +1106,8 @@ enroll_data_free (FpEnrollData *data)
 * @device: a #FpDevice
 * @template_print: (transfer floating): a #FpPrint
 * @cancellable: (nullable): a #GCancellable, or %NULL
- * @progress_cb: (nullable) (scope notified): progress reporting callback
- * @progress_data: (closure progress_cb): user data for @progress_cb
+ * @progress_cb: (nullable) (closure progress_data) (scope notified): progress reporting callback
+ * @progress_data: user data for @progress_cb
 * @progress_destroy: (destroy progress_data): Destroy notify for @progress_data
 * @callback: (scope async): the function to call on completion
 * @user_data: the data to pass to @callback
@ -1248,8 +1251,8 @@ match_data_free (FpMatchData *data)
 * @device: a #FpDevice
 * @enrolled_print: a #FpPrint to verify
 * @cancellable: (nullable): a #GCancellable, or %NULL
- * @match_cb: (nullable) (scope notified): match reporting callback
- * @match_data: (closure match_cb): user data for @match_cb
+ * @match_cb: (nullable) (scope notified) (closure match_data): match reporting callback
+ * @match_data: user data for @match_cb
 * @match_destroy: (destroy match_data): Destroy notify for @match_data
 * @callback: the function to call on completion
 * @user_data: the data to pass to @callback
@ -1374,8 +1377,8 @@ fp_device_verify_finish (FpDevice     *device,
 * @device: a #FpDevice
 * @prints: (element-type FpPrint) (transfer none): #GPtrArray of #FpPrint
 * @cancellable: (nullable): a #GCancellable, or %NULL
- * @match_cb: (nullable) (scope notified): match reporting callback
- * @match_data: (closure match_cb): user data for @match_cb
+ * @match_cb: (nullable) (scope notified) (closure match_data): match reporting callback
+ * @match_data: user data for @match_cb
 * @match_destroy: (destroy match_data): Destroy notify for @match_data
 * @callback: the function to call on completion
 * @user_data: the data to pass to @callback
@ -1943,8 +1946,8 @@ fp_device_enroll_sync (FpDevice        *device,
 * @device: a #FpDevice
 * @enrolled_print: a #FpPrint to verify
 * @cancellable: (nullable): a #GCancellable, or %NULL
- * @match_cb: (nullable) (scope call): match reporting callback
- * @match_data: (closure match_cb): user data for @match_cb
+ * @match_cb: (nullable) (scope call) (closure match_data): match reporting callback
+ * @match_data: user data for @match_cb
 * @match: (out): Whether the user presented the correct finger
 * @print: (out) (transfer full) (nullable): Location to store the scanned print, or %NULL to ignore
 * @error: Return location for errors, or %NULL to ignore
@ -1983,8 +1986,8 @@ fp_device_verify_sync (FpDevice     *device,
 * @device: a #FpDevice
 * @prints: (element-type FpPrint) (transfer none): #GPtrArray of #FpPrint
 * @cancellable: (nullable): a #GCancellable, or %NULL
- * @match_cb: (nullable) (scope call): match reporting callback
- * @match_data: (closure match_cb): user data for @match_cb
+ * @match_cb: (nullable) (scope call) (closure match_data): match reporting callback
+ * @match_data: user data for @match_cb
 * @match: (out) (transfer full) (nullable): Location for the matched #FpPrint, or %NULL
 * @print: (out) (transfer full) (nullable): Location for the new #FpPrint, or %NULL
 * @error: Return location for errors, or %NULL to ignore
--- a/libfprint/fp-device.h
+++ b/libfprint/fp-device.h
@ -113,6 +113,8 @@ typedef enum {
 * @FP_DEVICE_RETRY_REMOVE_FINGER: The scan did not succeed due to quality or
 *   pressure problems; the user should remove their finger from the scanner
 *   before retrying.
+ * @FP_DEVICE_RETRY_TOO_FAST: The scan did not succeed because the finger
+ *   swipe or touch was too fast.
 *
 * Error codes representing scan failures resulting in the user needing to
 * retry.
@ -122,6 +124,7 @@ typedef enum {
  FP_DEVICE_RETRY_TOO_SHORT,
  FP_DEVICE_RETRY_CENTER_FINGER,
  FP_DEVICE_RETRY_REMOVE_FINGER,
+  FP_DEVICE_RETRY_TOO_FAST,
 } FpDeviceRetry;

 /**
--- a/libfprint/fp-print.h
+++ b/libfprint/fp-print.h
@ -29,7 +29,7 @@ G_BEGIN_DECLS
 G_DECLARE_FINAL_TYPE (FpPrint, fp_print, FP, PRINT, GInitiallyUnowned)

 #define FP_FINGER_IS_VALID(finger) \
-        ((finger) >= FP_FINGER_FIRST && (finger) <= FP_FINGER_LAST)
+  ((finger) >= FP_FINGER_FIRST && (finger) <= FP_FINGER_LAST)

 #include "fp-device.h"

--- a/libfprint/fpi-device.c
+++ b/libfprint/fpi-device.c
@ -117,6 +117,10 @@ fpi_device_retry_new (FpDeviceRetry error)
      msg = "Please try again after removing the finger first.";
      break;

+    case FP_DEVICE_RETRY_TOO_FAST:
+      msg = "The swipe was too fast, please try again.";
+      break;
+
    default:
      g_warning ("Unsupported error, returning general error instead!");
      error = FP_DEVICE_RETRY_GENERAL;
--- a/libfprint/fpi-log.h
+++ b/libfprint/fpi-log.h
@ -79,13 +79,16 @@
 *
 * Uses fp_err() to print an error if the @condition is true.
 */
-#define BUG_ON(condition) G_STMT_START          \
-        if (condition) {                        \
-            char *s;                        \
-            s = g_strconcat ("BUG: (", #condition, ")", NULL); \
-            fp_err ("%s: %s() %s:%d", s, G_STRFUNC, __FILE__, __LINE__); \
-            g_free (s);                     \
-          } G_STMT_END
+#define BUG_ON(condition) \
+  G_STMT_START          \
+  if (condition) \
+    {                        \
+      char *s;                        \
+      s = g_strconcat ("BUG: (", #condition, ")", NULL); \
+      fp_err ("%s: %s() %s:%d", s, G_STRFUNC, __FILE__, __LINE__); \
+      g_free (s);                     \
+    } \
+  G_STMT_END

 /**
 * BUG:
--- a/libfprint/fpi-ssm.h
+++ b/libfprint/fpi-ssm.h
@ -60,7 +60,7 @@ 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, #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,
--- a/libfprint/fprint-list-metainfo.c
+++ b/libfprint/fprint-list-metainfo.c
@ -0,0 +1,107 @@
+/*
+ * Copyright (C) 2025 Marco Trevisan <marco.trevisan@canonical.com>
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+#include "glib.h"
+#include "fpi-context.h"
+#include "fpi-device.h"
+
+#define METAINFO_BASE \
+  "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n" \
+  "<component>\n" \
+  "  <id>org.freedesktop.libfprint</id>\n" \
+  "  <name>libfprint</name>\n" \
+  "  <metadata_license>CC0-1.0</metadata_license>\n" \
+  "  <project_license>LGPL-2.1-or-later</project_license>\n" \
+  "  <url type=\"homepage\">https://fprint.freedesktop.org</url>\n" \
+  "  <url type=\"vcs-browser\">https://gitlab.freedesktop.org/libfprint/libfprint</url>\n" \
+  "  <url type=\"help\">https://fprint.freedesktop.org/libfprint-dev</url>\n" \
+  "  <url type=\"bugtracker\">https://gitlab.freedesktop.org/libfprint/libfprint/-/issues</url>\n" \
+  "  <summary>Async fingerprint readers library</summary>\n" \
+  "  <description>\n" \
+  "    <p>\n" \
+  "      The fprint project aims to support for consumer fingerprint reader devices.\n" \
+  "    </p>\n" \
+  "  </description>\n" \
+  "  <provides>\n" \
+  "%s\n" \
+  "  </provides>\n" \
+  "</component>\n"
+
+static int
+driver_compare (gconstpointer p1, gconstpointer p2)
+{
+  g_autoptr(FpDeviceClass) cls1 = g_type_class_ref (*(GType *) p1);
+  g_autoptr(FpDeviceClass) cls2 = g_type_class_ref (*(GType *) p2);
+
+  return g_strcmp0 (cls1->id, cls2->id);
+}
+
+static void
+usb_driver_devices_append (GPtrArray           *devices_list,
+                           const FpDeviceClass *cls)
+{
+  const FpIdEntry *entry;
+
+  if (cls->type != FP_DEVICE_TYPE_USB)
+    return;
+
+  for (entry = cls->id_table; entry->vid != 0; entry++)
+    {
+      if (entry->vid == 0 || entry->pid == 0)
+        continue;
+
+      g_ptr_array_add (devices_list,
+                       g_strdup_printf ("v%04xp%04x", entry->vid, entry->pid));
+    }
+}
+
+int
+main (void)
+{
+  g_autoptr(GPtrArray) devices_list = g_ptr_array_new_with_free_func (g_free);
+  g_autoptr(GArray) drivers = fpi_get_driver_types ();
+  g_autoptr(GString) provided_modules = g_string_new (NULL);
+  g_autoptr(GError) error = NULL;
+
+  g_array_sort (drivers, driver_compare);
+
+  for (guint i = 0; i < drivers->len; ++i)
+    {
+      GType driver = g_array_index (drivers, GType, i);
+      g_autoptr(FpDeviceClass) cls = g_type_class_ref (driver);
+
+      if (cls->type != FP_DEVICE_TYPE_USB)
+        continue;
+
+      usb_driver_devices_append (devices_list, cls);
+    }
+
+  for (guint i = 0; i < devices_list->len; ++i)
+    {
+      const char *device_id = g_ptr_array_index (devices_list, i);
+
+      g_string_append (provided_modules, "    ");
+      g_string_append_printf (provided_modules, "<modalias>usb:%s*</modalias>",
+                              device_id);
+
+      if (i < devices_list->len - 1)
+        g_string_append_c (provided_modules, '\n');
+    }
+
+  g_print (METAINFO_BASE, provided_modules->str);
+}
--- a/libfprint/fprint-list-udev-hwdb.c
+++ b/libfprint/fprint-list-udev-hwdb.c
@ -29,7 +29,10 @@ static const FpIdEntry allowlist_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 = 0x0a5c, .pid = 0x5802 },
  { .vid = 0x047d, .pid = 0x00f2 },
+  { .vid = 0x047d, .pid = 0x8054 },
+  { .vid = 0x047d, .pid = 0x8055 },
  { .vid = 0x04e8, .pid = 0x730b },
  { .vid = 0x04f3, .pid = 0x036b },
  { .vid = 0x04f3, .pid = 0x0c00 },
@ -37,25 +40,36 @@ static const FpIdEntry allowlist_id_table[] = {
  { .vid = 0x04f3, .pid = 0x0c57 },
  { .vid = 0x04f3, .pid = 0x0c5e },
  { .vid = 0x04f3, .pid = 0x0c5a },
+  { .vid = 0x04f3, .pid = 0x0c60 },
  { .vid = 0x04f3, .pid = 0x0c6c },
  { .vid = 0x04f3, .pid = 0x0c70 },
  { .vid = 0x04f3, .pid = 0x0c72 },
  { .vid = 0x04f3, .pid = 0x0c77 },
+  { .vid = 0x04f3, .pid = 0x0c7c },
+  { .vid = 0x04f3, .pid = 0x0c7f },
+  { .vid = 0x04f3, .pid = 0x0c80 },
+  { .vid = 0x04f3, .pid = 0x0c85 },
+  { .vid = 0x04f3, .pid = 0x0c90 },
  { .vid = 0x04f3, .pid = 0x2706 },
  { .vid = 0x04f3, .pid = 0x3032 },
  { .vid = 0x04f3, .pid = 0x3057 },
  { .vid = 0x04f3, .pid = 0x3104 },
  { .vid = 0x04f3, .pid = 0x310d },
  { .vid = 0x04f3, .pid = 0x3128 },
+  { .vid = 0x04f3, .pid = 0x0c8a },
+  { .vid = 0x05ba, .pid = 0x000e },
+  { .vid = 0x06cb, .pid = 0x0051 },
  { .vid = 0x06cb, .pid = 0x0081 },
  { .vid = 0x06cb, .pid = 0x0088 },
  { .vid = 0x06cb, .pid = 0x008a },
  { .vid = 0x06cb, .pid = 0x009a },
  { .vid = 0x06cb, .pid = 0x009b },
+  { .vid = 0x06cb, .pid = 0x00a1 },
  { .vid = 0x06cb, .pid = 0x00a2 },
  { .vid = 0x06cb, .pid = 0x00a8 },
  { .vid = 0x06cb, .pid = 0x00b7 },
  { .vid = 0x06cb, .pid = 0x00bb },
+  { .vid = 0x06cb, .pid = 0x00bc },
  { .vid = 0x06cb, .pid = 0x00be },
  { .vid = 0x06cb, .pid = 0x00cb },
  { .vid = 0x06cb, .pid = 0x00c9 },
@ -64,8 +78,8 @@ static const FpIdEntry allowlist_id_table[] = {
  { .vid = 0x06cb, .pid = 0x00dc },
  { .vid = 0x06cb, .pid = 0x00e4 },
  { .vid = 0x06cb, .pid = 0x00e7 },
-  { .vid = 0x06cb, .pid = 0x00e9 },
  { .vid = 0x06cb, .pid = 0x00fd },
+  { .vid = 0x06cb, .pid = 0x00ff },
  { .vid = 0x0a5c, .pid = 0x5801 },
  { .vid = 0x0a5c, .pid = 0x5805 },
  { .vid = 0x0a5c, .pid = 0x5834 },
@ -84,7 +98,11 @@ static const FpIdEntry allowlist_id_table[] = {
  { .vid = 0x0bda, .pid = 0x5812 },
  { .vid = 0x10a5, .pid = 0x0007 },
  { .vid = 0x10a5, .pid = 0x9200 },
+  { .vid = 0x10a5, .pid = 0x9201 },
  { .vid = 0x10a5, .pid = 0x9800 },
+  { .vid = 0x10a5, .pid = 0xa120 },
+  { .vid = 0x10a5, .pid = 0xa900 },
+  { .vid = 0x10a5, .pid = 0xa921 },
  { .vid = 0x10a5, .pid = 0xe340 },
  { .vid = 0x1188, .pid = 0x9545 },
  { .vid = 0x138a, .pid = 0x0007 },
@ -106,6 +124,9 @@ static const FpIdEntry allowlist_id_table[] = {
  { .vid = 0x1c7a, .pid = 0x0575 },
  { .vid = 0x1c7a, .pid = 0x0576 },
  { .vid = 0x1c7a, .pid = 0x0577 },
+  { .vid = 0x1c7a, .pid = 0x057e },
+  { .vid = 0x2541, .pid = 0x0236 },
+  { .vid = 0x2541, .pid = 0x9711 },
  { .vid = 0x27c6, .pid = 0x5042 },
  { .vid = 0x27c6, .pid = 0x5110 },
  { .vid = 0x27c6, .pid = 0x5117 },
@ -134,11 +155,19 @@ static const FpIdEntry allowlist_id_table[] = {
  { .vid = 0x27c6, .pid = 0x5e0a },
  { .vid = 0x27c6, .pid = 0x581a },
  { .vid = 0x27c6, .pid = 0x589a },
+  { .vid = 0x27c6, .pid = 0x5f10 },
+  { .vid = 0x27c6, .pid = 0x5f91 },
  { .vid = 0x27c6, .pid = 0x6382 },
  { .vid = 0x2808, .pid = 0x9338 },
+  { .vid = 0x2808, .pid = 0x9348 },
  { .vid = 0x2808, .pid = 0x93a9 },
+  { .vid = 0x2808, .pid = 0xa658 },
+  { .vid = 0x2808, .pid = 0xc652 },
+  { .vid = 0x2808, .pid = 0xa553 },
  { .vid = 0x298d, .pid = 0x2020 },
  { .vid = 0x298d, .pid = 0x2033 },
+  { .vid = 0x2df0, .pid = 0x0003 },
+  { .vid = 0x3274, .pid = 0x8012 },
  { .vid = 0x3538, .pid = 0x0930 },
  { .vid = 0 },
 };
--- a/libfprint/meson.build
+++ b/libfprint/meson.build
@ -24,8 +24,7 @@ libfprint_private_sources = [
    'fpi-print.c',
    'fpi-ssm.c',
    'fpi-usb-transfer.c',
-    spi_sources,
-]
+] + spi_sources

 libfprint_public_headers = [
    'fp-context.h',
@ -49,9 +48,8 @@ libfprint_private_headers = [
    'fpi-minutiae.h',
    'fpi-print.h',
    'fpi-usb-transfer.h',
-    spi_headers,
    'fpi-ssm.h',
-]
+] + spi_headers

 nbis_sources = [
    'nbis/bozorth3/bozorth3.c',
@ -164,7 +162,7 @@ helper_sources = {
        [ 'drivers/aesx660.c' ],
    'aes3k' :
        [ 'drivers/aes3k.c' ],
-    'nss' :
+    'openssl' :
        [ ],
    'udev' :
        [ ],
@ -257,6 +255,7 @@ libnbis = static_library('nbis',
        '-Wno-discarded-qualifiers',
        '-Wno-array-bounds',
        '-Wno-array-parameter',
+        '-Wno-unused-but-set-variable',
    ]),
    install: false)

@ -276,8 +275,13 @@ libfprint_drivers = static_library('fprint-drivers',
    link_with: libfprint_private,
    install: false)

-mapfile = files('libfprint.ver')
-vflag = '-Wl,--version-script,@0@/@1@'.format(meson.project_source_root(), mapfile[0])
+mapfile = files('libfprint.ver')[0]
+if meson.version().version_compare('>=1.4')
+    mapfile_path = mapfile.full_path()
+else
+    mapfile_path = meson.project_source_root() / '@0@'.format(mapfile)
+endif
+vflag = '-Wl,--version-script,@0@'.format(mapfile_path)

 libfprint = shared_library(versioned_libname.split('lib')[1],
    sources: [
@ -329,6 +333,21 @@ udev_hwdb_generator = custom_target('udev-hwdb',
    install: false,
 )

+metainfo = executable('fprint-list-metainfo',
+    'fprint-list-metainfo.c',
+    dependencies: libfprint_private_dep,
+    link_with: libfprint_drivers,
+    install: false)
+
+metainfo_generator = custom_target('metainfo',
+    output: 'org.freedesktop.libfprint.metainfo.xml',
+    depend_files: drivers_sources,
+    capture: true,
+    command: [ metainfo ],
+    install: true,
+    install_dir: datadir / 'metainfo'
+)
+
 if install_udev_rules
    udev_rules = executable('fprint-list-udev-rules',
        'fprint-list-udev-rules.c',
@ -392,6 +411,7 @@ if get_option('introspection')
            'GObject-2.0',
            'GUsb-1.0',
        ],
+        fatal_warnings: true,
        install : true)
    libfprint_gir = libfprint_girtarget[0]
    libfprint_typelib = libfprint_girtarget[1]
--- a/meson.build
+++ b/meson.build
@ -1,13 +1,14 @@
 project('libfprint', [ 'c', 'cpp' ],
-    version: '1.94.8',
+    version: '1.94.10',
    license: 'LGPLv2.1+',
    default_options: [
        'buildtype=debugoptimized',
        'warning_level=1',
        'c_std=gnu99',
    ],
-    meson_version: '>= 0.56.0')
+    meson_version: '>= 0.59.0')

+fs = import('fs')
 gnome = import('gnome')

 libfprint_conf = configuration_data()
@ -21,12 +22,17 @@ datadir = prefix / get_option('datadir')
 cc = meson.get_compiler('c')
 cpp = meson.get_compiler('cpp')
 host_system = host_machine.system()
+
+libfprint_sanitizers = get_option('b_sanitize').split(',')
+if libfprint_sanitizers == ['none']
+  libfprint_sanitizers = []
+endif
+
 glib_min_version = '2.68'

 glib_version_def = 'GLIB_VERSION_@0@_@1@'.format(
    glib_min_version.split('.')[0], glib_min_version.split('.')[1])
 common_cflags = cc.get_supported_arguments([
-    '-Wall',
    '-Wcast-align',
    '-Wformat-nonliteral',
    '-Wformat-security',
@ -203,7 +209,7 @@ driver_helper_mapping = {
    'aes2660' : [ 'aeslib', 'aesx660' ],
    'aes3500' : [ 'aeslib', 'aes3k' ],
    'aes4000' : [ 'aeslib', 'aes3k' ],
-    'uru4000' : [ 'nss' ],
+    'uru4000' : [ 'openssl' ],
    'elanspi' : [ 'udev' ],
    'virtual_image'          : [ 'virtual' ],
    'virtual_device'         : [ 'virtual' ],
@ -260,13 +266,13 @@ foreach i : driver_helpers

        libfprint_conf.set10('HAVE_PIXMAN', true)
        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))
+    elif i == 'openssl'
+        openssl_dep = dependency('openssl', version: '>= 3.0', required: false)
+        if not openssl_dep.found()
+            error('OpenSSL is required for @0@ and possibly others'.format(driver))
        endif

-        optional_deps += nss_dep
+        optional_deps += openssl_dep
    elif i == 'udev'
        install_udev_rules = true

--- a/scripts/uncrustify.cfg
+++ b/scripts/uncrustify.cfg
@ -19,6 +19,7 @@ indent_func_proto_param false
 indent_switch_case      0
 indent_case_brace       2
 indent_paren_close      1
+pp_multiline_define_body_indent 2

 # spacing
 sp_arith                        Add
@ -114,6 +115,7 @@ nl_create_for_one_liner         False
 nl_create_while_one_liner       False
 nl_after_semicolon              True
 nl_multi_line_cond              true
+nl_multi_line_define            true

 # mod
 # I'd like these to be remove, but that removes brackets in if { if { foo } }, which i dislike
--- a/tests/fpcmoc/device
+++ b/tests/fpcmoc/device
@ -3,7 +3,7 @@ N: bus/usb/001/019=1201000200000040A510E0FF10000102000109021900010104A0320904000
 E: DEVNAME=/dev/bus/usb/001/019
 E: DEVTYPE=usb_device
 E: DRIVER=usb
-E: PRODUCT=10a5/ffe0/10
+E: PRODUCT=10a5/a306/10
 E: TYPE=0/0/0
 E: BUSNUM=001
 E: DEVNUM=019
@ -13,11 +13,11 @@ E: SUBSYSTEM=usb
 E: ID_VENDOR=FPC
 E: ID_VENDOR_ENC=FPC
 E: ID_VENDOR_ID=10a5
-E: ID_MODEL=FPC_L:0001_FW:127010
-E: ID_MODEL_ENC=FPC\x20L:0001\x20FW:127010
-E: ID_MODEL_ID=ffe0
+E: ID_MODEL=FPC_L:0001_FW:222709
+E: ID_MODEL_ENC=FPC\x20L:0001\x20FW:222709
+E: ID_MODEL_ID=a306
 E: ID_REVISION=0010
-E: ID_SERIAL=FPC_FPC_L:0001_FW:127010
+E: ID_SERIAL=FPC_FPC_L:0001_FW:222709
 E: ID_BUS=usb
 E: ID_USB_INTERFACES=:ffffff:
 E: ID_PATH=pci-0000:00:14.0-usb-0:1
@ -45,7 +45,7 @@ A: devnum=19\n
 A: devpath=1\n
 L: driver=../../../../../bus/usb/drivers/usb
 L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:1c/device:1d/device:1e
-A: idProduct=ffe0\n
+A: idProduct=a306\n
 A: idVendor=10a5\n
 A: ltm_capable=no\n
 A: manufacturer=FPC\n
@ -74,7 +74,7 @@ A: power/wakeup_expire_count=\n
 A: power/wakeup_last_time_ms=\n
 A: power/wakeup_max_time_ms=\n
 A: power/wakeup_total_time_ms=\n
-A: product=FPC L:0001 FW:127010\n
+A: product=FPC L:0001 FW:222709\n
 A: quirks=0x0\n
 A: removable=removable\n
 A: rx_lanes=1\n
--- a/tests/goodixmoc/custom.pcapng
+++ b/tests/goodixmoc/custom.pcapng
--- a/tests/goodixmoc/custom.py
+++ b/tests/goodixmoc/custom.py
@ -53,17 +53,20 @@ assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
 p = d.enroll_sync(template, None, enroll_progress, None)
 assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
 print("enroll done")
+assert p.get_description() == 'FP1-00000000-0-00000000-nobody'

 print("listing")
 stored = d.list_prints_sync()
 print("listing done")
 assert len(stored) == 1
 assert stored[0].equal(p)
+assert stored[0].get_description() == 'FP1-00000000-0-00000000-nobody'
 print("verifying")
 assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
 verify_res, verify_print = d.verify_sync(p)
 assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
 print("verify done")
+assert verify_print.get_description() == 'FP1-00000000-0-00000000-nobody'
 del p
 assert verify_res == True

--- a/tests/goodixmoc/device
+++ b/tests/goodixmoc/device
--- a/tests/libfprint.supp
+++ b/tests/libfprint.supp
@ -24,3 +24,12 @@
   ...
   fun:g_thread_new
 }
+
+{
+   <ignore-libusb-context>
+   Memcheck:Leak
+   match-leak-kinds: possible
+   fun:calloc
+   ...
+   fun:libusb_init_context
+}
--- a/tests/meson.build
+++ b/tests/meson.build
@ -145,8 +145,7 @@ if get_option('introspection')
                    output: vdtest + '.test',
                    install_dir: installed_tests_testdir,
                    configuration: {
-                        # FIXME: use fs.name() on meson 0.58
-                        'exec': installed_tests_execdir / '@0@'.format(base_args[0]).split('/')[-1],
+                        'exec': installed_tests_execdir / fs.name(base_args[0]),
                        'env': ' '.join([
                            envs_str,
                            'LD_LIBRARY_PATH=' + installed_tests_libdir,
@ -325,13 +324,25 @@ endforeach
 # Run udev rule generator with fatal warnings
 envs.set('UDEV_HWDB', udev_hwdb.full_path())
 envs.set('UDEV_HWDB_CHECK_CONTENTS', default_drivers_are_enabled ? '1' : '0')
+envs.set('G_MESSAGES_DEBUG', '')
 test('udev-hwdb',
     find_program('test-generated-hwdb.sh'),
     depends: udev_hwdb,
+     suite: ['data', 'no-valgrind'],
     env: envs)

+appstreamcli = find_program('appstreamcli', required: false)
+if appstreamcli.found()
+    test('metainfo-validate',
+        appstreamcli,
+        args: ['validate', metainfo_generator],
+        depends: metainfo_generator,
+        suite: ['data', 'no-valgrind'],
+    )
+endif
+
 gdb = find_program('gdb', required: false)
-if gdb.found()
+if gdb.found() and libfprint_sanitizers.length() == 0
    libfprint_wrapper = [
        gdb.full_path(),
        '-batch',
@ -346,14 +357,32 @@ if gdb.found()
        ])
 endif

+if ('address' in libfprint_sanitizers or
+    'undefined' in libfprint_sanitizers or
+    'leak' in libfprint_sanitizers)
+    add_test_setup('sanitizers',
+        is_default: true,
+        timeout_multiplier: 3,
+        env: [
+            'ASAN_OPTIONS=verify_asan_link_order=0',
+        ])
+endif
+
 valgrind = find_program('valgrind', required: false)
-if valgrind.found()
+if valgrind.found() and libfprint_sanitizers.length() == 0
    glib_share = glib_dep.get_variable(pkgconfig: 'prefix') / 'share' / glib_dep.name()
    glib_suppressions = glib_share + '/valgrind/glib.supp'
-    libfprint_suppressions = '@0@/@1@'.format(meson.project_source_root(),
-        files('libfprint.supp')[0])
-    python_suppressions = '@0@/@1@'.format(meson.project_source_root(),
-        files('valgrind-python.supp')[0])
+    libfprint_suppressions = files('libfprint.supp')[0]
+    python_suppressions = files('valgrind-python.supp')[0]
+
+    if meson.version().version_compare('>=1.4')
+        libfprint_suppressions = libfprint_suppressions.full_path()
+        python_suppressions = python_suppressions.full_path()
+    else
+        libfprint_suppressions = meson.project_source_root() / '@0@'.format(libfprint_suppressions)
+        python_suppressions = meson.project_source_root() / '@0@'.format(python_suppressions)
+    endif
+
    libfprint_wrapper = [
        valgrind.full_path(),
        '--tool=memcheck',
@ -370,11 +399,14 @@ if valgrind.found()
        '--suppressions=' + python_suppressions,
    ]
    add_test_setup('valgrind',
-        timeout_multiplier: 15,
+        timeout_multiplier: 20,
        exe_wrapper: libfprint_wrapper,
+        exclude_suites: ['no-valgrind'],
        env: [
            'G_SLICE=always-malloc',
            'UNDER_VALGRIND=1',
+            'FP_VIRTUAL_IMAGE_HOT_SECONDS=-1',
+            'FP_VIRTUAL_DEVICE_HOT_SECONDS=-1',
            'LIBFPRINT_TEST_WRAPPER=' + ' '.join(libfprint_wrapper),
        ])
 endif
--- a/tests/valgrind-python.supp
+++ b/tests/valgrind-python.supp
@ -67,3 +67,52 @@
   ...
   fun:_Py*
 }
+
+{
+   ignore__libpython_leaks
+   Memcheck:Leak
+   fun:malloc
+   obj:/usr/lib*/libpython3*.so.*
+}
+
+{
+   ignore__libpython_leaks
+   Memcheck:Leak
+   fun:malloc
+   obj:/usr/lib/*/libpython3*.so.*
+}
+
+{
+   ignore__libpython_leaks
+   Memcheck:Leak
+   fun:realloc
+   obj:/usr/lib*/libpython3*.so.*
+}
+
+{
+   ignore__libpython_leaks
+   Memcheck:Leak
+   fun:realloc
+   obj:/usr/lib/*/libpython3*.so.*
+}
+
+{
+   ignore__pygobject_possible_leaks
+   Memcheck:Leak
+   match-leak-kinds: possible
+   ...
+   obj:/usr/lib*/python*/site-packages/gi/_gi.cpython-*.so
+   obj:/usr/lib*/libpython3.*.so.*
+}
+
+{
+   ignore__pygobject_instance_leaks
+   Memcheck:Leak
+   match-leak-kinds: definite
+   ...
+   fun:g_type_create_instance
+   fun:gi_info_new_full
+   ...
+   obj:/usr/lib*/python*/site-packages/gi/_gi.cpython-*.so
+   obj:/usr/lib*/libpython3.*.so.*
+}
--- a/tests/virtual-image.py
+++ b/tests/virtual-image.py
@ -140,6 +140,24 @@ class VirtualImage(unittest.TestCase):
        while iterate and ctx.pending():
            ctx.iteration(False)

+    def wait_for_finger_status(self, finger_status, timeout=5000):
+        done = False
+        def on_timeout_reached():
+            nonlocal done
+            done = True
+
+        if 'UNDER_VALGRIND' in os.environ:
+            timeout = timeout * 3
+
+        source = GLib.timeout_add(timeout, on_timeout_reached)
+        while not done:
+            if self.dev.get_finger_status() & finger_status:
+                GLib.source_remove(source)
+                return
+            ctx.iteration(True)
+
+        self.assertFalse(done)
+
    def test_features(self):
        self.assertTrue(self.dev.has_feature(FPrint.DeviceFeature.CAPTURE))
        self.assertTrue(self.dev.has_feature(FPrint.DeviceFeature.IDENTIFY))
@ -204,6 +222,7 @@ class VirtualImage(unittest.TestCase):
        self.dev.enroll(template, None, progress_cb, tuple(), done_cb)

        # Note: Assumes 5 enroll steps for this device!
+        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image(image)
        while self._step < 1:
            ctx.iteration(True)
@ -262,6 +281,7 @@ class VirtualImage(unittest.TestCase):
        self._verify_match = None
        self._verify_fp = None
        self.dev.verify(fp_whorl, callback=verify_cb)
+        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('whorl')
        while self._verify_match is None:
            ctx.iteration(True)
@ -271,6 +291,7 @@ class VirtualImage(unittest.TestCase):
        self._verify_match = None
        self._verify_fp = None
        self.dev.verify(fp_whorl, callback=verify_cb)
+        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('tented_arch')
        while self._verify_match is None:
            ctx.iteration(True)
@ -284,6 +305,7 @@ class VirtualImage(unittest.TestCase):
        self._verify_match = None
        self._verify_fp = None
        self.dev.verify(fp_whorl_tended_arch, callback=verify_cb)
+        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('whorl')
        while self._verify_match is None:
            ctx.iteration(True)
@ -293,6 +315,7 @@ class VirtualImage(unittest.TestCase):
        self._verify_match = None
        self._verify_fp = None
        self.dev.verify(fp_whorl_tended_arch, callback=verify_cb)
+        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('tented_arch')
        while self._verify_match is None:
            ctx.iteration(True)
@ -302,6 +325,7 @@ class VirtualImage(unittest.TestCase):
        self._verify_fp = None
        self._verify_error = None
        self.dev.verify(fp_whorl, callback=verify_cb)
+        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_retry()
        while self._verify_fp is None and self._verify_error is None:
            ctx.iteration(True)
@ -311,6 +335,7 @@ class VirtualImage(unittest.TestCase):
        self._verify_fp = None
        self._verify_error = None
        self.dev.verify(fp_whorl, callback=verify_cb)
+        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_error()
        while self._verify_fp is None and self._verify_error is None:
            ctx.iteration(True)
@ -334,6 +359,7 @@ class VirtualImage(unittest.TestCase):

        self._identify_fp = None
        self.dev.identify([fp_whorl, fp_tented_arch], callback=identify_cb)
+        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('tented_arch')
        while self._identify_fp is None:
            ctx.iteration(True)
@ -341,6 +367,7 @@ class VirtualImage(unittest.TestCase):

        self._identify_fp = None
        self.dev.identify([fp_whorl, fp_tented_arch], callback=identify_cb)
+        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('whorl')
        while self._identify_fp is None:
            ctx.iteration(True)
@ -350,6 +377,7 @@ class VirtualImage(unittest.TestCase):
        self._identify_fp = None
        self._identify_error = None
        self.dev.identify([fp_whorl, fp_tented_arch], callback=identify_cb)
+        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_retry()
        while self._identify_fp is None and self._identify_error is None:
            ctx.iteration(True)
@ -393,6 +421,7 @@ class VirtualImage(unittest.TestCase):
        self._verify_match = None
        self._verify_fp = None
        self.dev.verify(fp_whorl_new, callback=verify_cb)
+        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('whorl')
        while self._verify_match is None:
            ctx.iteration(True)
@ -401,6 +430,7 @@ class VirtualImage(unittest.TestCase):
        self._verify_match = None
        self._verify_fp = None
        self.dev.verify(fp_whorl_new, callback=verify_cb)
+        self.wait_for_finger_status(FPrint.FingerStatusFlags.NEEDED)
        self.send_image('tented_arch')
        while self._verify_match is None:
            ctx.iteration(True)
				`@ -0,0 +1 @@`
				`gcov-ignore-parse-errors = suspicious_hits.warn`