print: Reject enroll images that can't be matched

If the score of a print matching itself is too low to match, then reject it. It can never match and it is therefore completely useless. Also change this into a non-fatal error, the user is free to retry the enroll step in the hope that more minutiae is found (e.g. longer swipe).
2025-11-15 07:38:12 +00:00 · 2022-05-17 19:16:32 +00:00
129 changed files with 1042 additions and 15599 deletions
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
@@ -1,74 +1,50 @@
 include:
-  - local: '.gitlab-ci/libfprint-image-variables.yaml'
  - local: '.gitlab-ci/libfprint-templates.yaml'
  - project: 'freedesktop/ci-templates'
    ref: master
    file: '/templates/fedora.yml'
-  - remote: 'https://gitlab.gnome.org/GNOME/citemplates/-/raw/71e636e012ae0ab04c5e0fe40ca73ada91ae6bde/flatpak/flatpak_ci_initiative.yml'
-
-default:
-  # Auto-retry jobs in case of infra failures
-  retry:
-    max: 1
-    when:
-      - 'runner_system_failure'
-      - 'stuck_or_timeout_failure'
-      - 'scheduler_failure'
-      - 'api_failure'
+  - remote: 'https://gitlab.gnome.org/GNOME/citemplates/-/raw/master/flatpak/flatpak_ci_initiative.yml'

 variables:
  extends: .libfprint_common_variables
-  FDO_DISTRIBUTION_TAG: $LIBFPRINT_IMAGE_TAG
-  FDO_DISTRIBUTION_VERSION: 41
+  FDO_DISTRIBUTION_TAG: latest
+  FDO_DISTRIBUTION_VERSION: rawhide
  FDO_UPSTREAM_REPO: "libfprint/$CI_PROJECT_NAME"
  FEDORA_IMAGE: "$CI_REGISTRY/libfprint/$CI_PROJECT_NAME/fedora/$FDO_DISTRIBUTION_VERSION:$FDO_DISTRIBUTION_TAG"
+  BUNDLE: "org.freedesktop.libfprint.Demo.flatpak"
  LAST_ABI_BREAK: "056ea541ddc97f5806cffbd99a12dc87e4da3546"

-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
  - check-source
  - build
  - test
  - flatpak
-  - deploy

 image: $FEDORA_IMAGE

 .build_one_driver_template: &build_one_driver
  script:
-    # Build with a driver that doesn't need imaging, or openssl
-    - meson setup _build --werror -Ddrivers=$driver
-    - meson compile -C _build
+    # Build with a driver that doesn't need imaging, or nss
+    - meson --werror -Ddrivers=$driver . _build
+    - ninja -C _build
    - rm -rf _build/

 .build_template: &build
  script:
    # And build with everything
-    - meson setup _build --werror -Ddrivers=all
-    - meson compile -C _build
-    - meson install -C _build
+    - meson --werror -Ddrivers=all . _build
+    - ninja -C _build
+    - ninja -C _build install

 .build_template: &check_abi
  script:
    - ./.ci/check-abi ${LAST_ABI_BREAK} $(git rev-parse HEAD)

-.standard_job:
-  rules:
-    - when: on_success
-    - if: $CI_PIPELINE_SOURCE == "schedule"
-      when: never
-
 build:
  stage: build
-  extends:
-    - .standard_job
+  except:
+    variables:
+      - $CI_PIPELINE_SOURCE == "schedule"
  variables:
    driver: virtual_image
  <<: *build_one_driver
@@ -83,19 +59,16 @@ build:

 test:
  stage: test
-  extends:
-    - .standard_job
+  except:
+    variables:
+      - $CI_PIPELINE_SOURCE == "schedule"
  script:
-    - meson setup _build --werror -Ddrivers=all -Db_coverage=true
+    - meson --werror -Ddrivers=all -Db_coverage=true . _build
+    - ninja -C _build
    - meson test -C _build --print-errorlogs --no-stdsplit --timeout-multiplier 3
-    - ninja -C _build coverage || true
-    - cat _build/meson-logs/coverage.txt || true
+    - ninja -C _build coverage
+    - cat _build/meson-logs/coverage.txt
  artifacts:
-    reports:
-      junit: "_build/meson-logs/testlog.junit.xml"
-      coverage_report:
-        coverage_format: cobertura
-        path: _build/meson-logs/coverage.xml
    expose_as: 'Coverage Report'
    when: always
    paths:
@@ -106,15 +79,14 @@ test:

 test_valgrind:
  stage: test
-  extends:
-    - .standard_job
+  except:
+    variables:
+      - $CI_PIPELINE_SOURCE == "schedule"
  script:
-    - meson setup _build -Ddrivers=all
-    - meson compile -C _build
+    - meson -Ddrivers=all . _build
+    - ninja -C _build
    - meson test -C _build --print-errorlogs --no-stdsplit --setup=valgrind
  artifacts:
-    reports:
-      junit: "_build/meson-logs/testlog-valgrind.junit.xml"
    expose_as: 'Valgrind test logs'
    when: always
    paths:
@@ -122,123 +94,73 @@ 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
-  extends:
-    - .standard_job
-  script:
-    - meson setup _build --prefix=/usr -Ddrivers=all
-    - meson install -C _build
-    - mv _build _build_dir
-    - rm -rf tests
-    - gnome-desktop-testing-runner --list libfprint-2
-    - gnome-desktop-testing-runner libfprint-2
-        --report-directory=_installed-tests-report/failed/
-        --log-directory=_installed-tests-report/logs/
-        --parallel=0
-  artifacts:
-    expose_as: 'GNOME Tests Runner logs'
-    when: always
-    paths:
-      - _build_dir/meson-logs
-      - _installed-tests-report
-    expire_in: 1 week
-

 test_scan_build:
  stage: test
-  extends:
-    - .standard_job
+  except:
+    variables:
+      - $CI_PIPELINE_SOURCE == "schedule"
  allow_failure: true
  script:
-    - meson setup _build -Ddrivers=all
+    - meson -Ddrivers=all . _build
    # Wrapper to add --status-bugs and disable malloc checker
-    - SCANBUILD=$CI_PROJECT_DIR/.gitlab-ci/scan-build
-      ninja -C _build scan-build
+    - SCANBUILD=$CI_PROJECT_DIR/.gitlab-ci/scan-build ninja -C _build scan-build
  artifacts:
-    when: on_failure
    paths:
      - _build/meson-logs
    expire_in: 1 week

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

 test_unsupported_list:
  stage: check-source
-  extends:
-    - .standard_job
+  except:
+    variables:
+      - $CI_PIPELINE_SOURCE == "schedule"
  allow_failure: true
  script:
    - tests/hwdb-check-unsupported.py

 flatpak:
  stage: flatpak
-  extends: .flatpak@x86_64
+  extends: .flatpak
+  image: registry.gitlab.gnome.org/gnome/gnome-runtime-images/gnome:3.36
  variables:
    MANIFEST_PATH: "demo/org.freedesktop.libfprint.Demo.json"
    FLATPAK_MODULE: "libfprint"
    APP_ID: "org.freedesktop.libfprint.Demo"
-    BUNDLE: "org.freedesktop.libfprint.Demo.flatpak"
-    RUNTIME_REPO: "https://nightly.gnome.org/gnome-nightly.flatpakrepo"
-  # Build with any builder
-  tags: []
  rules:
    - if: '$CI_PROJECT_PATH != "libfprint/libfprint"'
-      when: manual
-      allow_failure: true
-    - if: $CI_PIPELINE_SOURCE == "schedule"
+      when: never
+    - if: '$CI_PIPELINE_SOURCE == "schedule"'
      when: never
    - if: '$CI_COMMIT_BRANCH == "master"'
-      allow_failure: true
      when: always
    - if: '$CI_COMMIT_TAG'
-      allow_failure: true
      when: always
    # For any other (commit), allow manual run.
    # This excludes MRs which would create a duplicate pipeline
    - if: '$CI_COMMIT_BRANCH'
      when: manual
      allow_failure: true
-    - if: '$CI_MERGE_REQUEST_ID'
-      when: manual
-      allow_failure: true

 # CONTAINERS creation stage
-.container_fedora_build_base:
+container_fedora_build:
  extends: .fdo.container-build@fedora
-  stage: image-build
+  only:
+    variables:
+      - $CI_PIPELINE_SOURCE == "schedule" && $CRON_TASK == "BUILD_CI_IMAGES"
  variables:
    GIT_STRATEGY: none # no need to pull the whole tree for rebuilding the image
+    FDO_FORCE_REBUILD: 1
    # a list of packages to install
    FDO_DISTRIBUTION_PACKAGES:
      $LIBFPRINT_DEPENDENCIES
@@ -246,51 +168,7 @@ flatpak:
      libpcap-devel
      libudev-devel
    FDO_DISTRIBUTION_EXEC: |
-      $LIBFPRINT_EXEC
-  rules:
-    - when: never
-
-.container_fedora_build_forced:
-  variables:
-    FDO_FORCE_REBUILD: 1
-
-container_fedora_build_schedule:
-  extends:
-    - .container_fedora_build_base
-    - .container_fedora_build_forced
-  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
-  rules:
-    - if: $LIBFPRINT_CI_ACTION == "build-image"
-      when: always
-
-container_fedora_build_on_deps_changed:
-  extends: .container_fedora_build_base
-  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
-  stage: deploy
-  needs:
-    - job: test
-      artifacts: true
-  script:
-    - mkdir public
-    - mv _build/meson-logs/coveragereport public/coverage
-  artifacts:
-    paths:
-      - public
-  rules:
-    - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH && $CI_PIPELINE_SOURCE == "push"
+      git clone https://github.com/martinpitt/umockdev.git && \
+        cd umockdev && \
+        meson _build --prefix=/usr && \
+        ninja -C _build && ninja -C _build install
--- a/.gitlab-ci/libfprint-image-variables.yaml
+++ b/.gitlab-ci/libfprint-image-variables.yaml
@@ -1,2 +0,0 @@
-variables:
-  LIBFPRINT_IMAGE_TAG: v6
--- a/.gitlab-ci/libfprint-templates.yaml
+++ b/.gitlab-ci/libfprint-templates.yaml
@@ -1,11 +1,6 @@
-# Bump image version on .gitlab-ci/libfprint-image-variables.yaml to trigger
-# a rebuild on changes to this file
-
 .libfprint_common_variables:
  LIBFPRINT_DEPENDENCIES:
-    appstream
    doxygen
-    dnf-plugins-core
    flatpak-builder
    gcc
    gcc-c++
@@ -14,18 +9,15 @@
    glib2-devel
    glibc-devel
    gobject-introspection-devel
-    gnome-desktop-testing
    gtk-doc
    gtk3-devel
    libabigail
-    libasan
    libgusb-devel
    libgudev-devel
-    libubsan
    libX11-devel
    libXv-devel
    meson
-    openssl-devel
+    nss-devel
    pixman-devel
    python3-cairo
    python3-gobject
@@ -35,13 +27,3 @@
    valgrind
    clang-analyzer
    diffutils
-
-  LIBFPRINT_EXEC: |
-    dnf -y install dnf-utils
-    debuginfo-install -y \
-      glib2 \
-      glibc \
-      libgusb \
-      libusb \
-      openssl \
-      pixman
--- 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 --exclude "_build/meson-private" "$@"
+exec /usr/bin/scan-build --status-bugs -disable-checker unix.Malloc "$@"
--- a/86
+++ b/86
@@ -1,88 +1,6 @@
 This file lists notable changes in each release. For the full history of all
 changes, see ChangeLog.

-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:
- * build: Support building in non-linux unix environments (tested in FreeBSD)
- * egismoc: New PIDs 0x0583, 0x0586, 0x0587.
- * elanmoc: New PID 0x0C9F.
- * fpcmoc: New PIDs 0x9524, 0x9544.
- * goodixmoc: New PIDs 0x609A, 0x650A, 0x650C, 0x6512.
- * realtek: New PID 0x5816.
- * synaptics: New PIDs 0x00C4, 0x019D, 0x00C6.
- * fpcmoc: fix incorrect immobile handling during enrollment.
- * fpcmoc: fixed jumping to wrong state at end of custom enroll.
- * egismoc: various code cleanups.
-
-2024-02-20: v1.94.7 release
-
-Highlights:
- * synaptics: fix enroll identify problem after user reset database.
- * synaptics: New PIDs 0x0173, 0x0106, 0x0124.
- * goodixmoc: New PID 0x6582.
- * build: Do not require bash to build, only posix sh.
- * fp-image: Simplify minutiae detection tasks.
- * GLib 2.68 is now required to build libfprint.
-
-New drivers:
- * realtek (PID 0x5813).
- * focaltech_moc (PIDs 0x9E48, 0xD979, 0xA959).
- * egismoc (PIDs 0x0582, 0x05a1).
-
-2023-08-17: v1.94.6 release
-
-Highlights:
- * goodixmoc: New PIDs 0x60A4, 0x60BC, 0x6092, 0x633C and 0x6304.
- * goodixmoc: Fix missing "enroll create" state.
- * elanmoc: New PID 0x0C99.
- * upektc: Improve compatibility with sensors 147e:2016.
- * aes4000: Actually support 08FF:5501 devices.
- * virtual-device-listener: Fix failing tests with GLib 2.76
- * tests: Add installed tests
-
-Bugs fixed:
- * #526 libfprint: fpcmoc: use after free if enrollment or identification is
-   cancelled (Vasily Khoruzhick)
-
-2022-10-13: v1.94.5 release
-
-Highlights:
- * New driver: fpcmoc, supporting various FPC MOC Fingerprint Sensors
- * goodixmoc: New PIDs 0x6014, 0x6094, 0x631C, 0x634C, 0x6384, 0x659A.
- * goodixmoc: Support resetting device on firmware failure due to corrupted DB.
- * elanmoc: New PIDs 0x0c88, 0x0c8c, 0x0c8d.
- * synaptics: New PID 0x0104.
- * upektc: New PID 0x2017.
- * Fixed various memory leaks
- * More tests
-
-2022-05-24: v1.94.4 release
-
-Highlights:
- * synaptics: New PIDs 0x0168, 0x015f
- * elan: New PID 0x0c4b
- * elanspi: New PID 0x241f
- * synaptics: Minor fix to interrupt transfer resubmission
- * Avoid sysfs writes if value is already expected
- * Improvements to the testing setup
- * Fixes to the internal critical section API
-
 2021-11-02: v1.94.3 release

 Highlights:
@@ -401,7 +319,7 @@ tests of the drivers using umockdev.
  - Mark fp_dscv_print functions as deprecated

 * Udev rules:
-  - Add some unsupported devices to the allowlist
+  - Add some unsupported devices to the whitelist

 2017-05-14: v0.7.0 release
 * Drivers:
@@ -451,7 +369,7 @@ tests of the drivers using umockdev.
  - Fix possible race condition, and cancellation in uru4000 driver

 * Udev rules:
-  - Add Microsoft keyboard to the suspend denylist
+  - Add Microsoft keyboard to the suspend blacklist

 * Plenty of build fixes

--- a/README.md
+++ b/README.md
@@ -1,95 +1,54 @@
+# libfprint

-
-<div align="center">
-
-# LibFPrint
-
-*LibFPrint is part of the **[FPrint][Website]** project.*
-
-<br/>
-
-[![Button Website]][Website]
-[![Button Documentation]][Documentation]
-
-[![Button Supported]][Supported]
-[![Button Unsupported]][Unsupported]
-
-[![Button Contribute]][Contribute]
-[![Button Contributors]][Contributors]
-
-</div>
+libfprint is part of the fprint project:
+https://fprint.freedesktop.org/

 ## History

-**LibFPrint** was originally developed as part of an
-academic project at the **[University Of Manchester]**.
+libfprint was originally developed as part of an academic project at the
+University of Manchester with the aim of hiding differences between different
+consumer fingerprint scanners and providing a single uniform API to application
+developers. The ultimate goal of the fprint project is to make fingerprint
+scanners widely and easily usable under common Linux environments.

-It aimed to hide the differences between consumer
-fingerprint scanners and provide a single uniform
-API to application developers.
-
-## Goal
-
-The ultimate goal of the **FPrint** project is to make
-fingerprint scanners widely and easily usable under
-common Linux environments.
+The academic university project runs off a codebase maintained separately
+from this one, although I try to keep them as similar as possible (I'm not
+hiding anything in the academic branch, it's just the open source release
+contains some commits excluded from the academic project).

 ## License

-`Section 6` of the license states that for compiled works that use
-this library, such works must include **LibFPrint** copyright notices
-alongside the copyright notices for the other parts of the work.
+THE UNIVERSITY OF MANCHESTER DOES NOT ENDORSE THIS THIS SOFTWARE RELEASE AND
+IS IN NO WAY RESPONSIBLE FOR THE CODE CONTAINED WITHIN, OR ANY DAMAGES CAUSED
+BY USING OR DISTRIBUTING THE SOFTWARE. Development does not happen on
+university computers and the project is not hosted at the university either.

-**LibFPrint** includes code from **NIST's** **[NBIS]** software distribution.
+For more information on libfprint, supported devices, API documentation, etc.,
+see the homepage:
+https://fprint.freedesktop.org/

-We include **Bozorth3** from the **[US Export Controlled]**
-distribution, which we have determined to be fine
-being shipped in an open source project.
+libfprint is licensed under the GNU LGPL version 2.1. See the COPYING file
+for the license text.

-## Get in *touch*
+Section 6 of the license states that for compiled works that use this
+library, such works must include libfprint copyright notices alongside the
+copyright notices for the other parts of the work. We have attempted to
+make this process slightly easier for you by grouping these all in one place:
+the AUTHORS file.

- - [IRC] - `#fprint` @ `irc.oftc.net`
- - [Matrix] - `#fprint:matrix.org` bridged to the IRC channel
- - [MailingList] - low traffic, not much used these days
+libfprint includes code from NIST's NBIS software distribution:
+http://fingerprint.nist.gov/NBIS/index.html
+We include bozorth3 from the US export controlled distribution. We have
+determined that it is fine to ship bozorth3 in an open source project,
+see https://fprint.freedesktop.org/us-export-control.html

-<br/>
+## Historical links

-<div align="right">
+Older versions of libfprint are available at:
+https://sourceforge.net/projects/fprint/files/

-[![Badge License]][License]
+Historical mailing-list archives:
+http://www.reactivated.net/fprint_list_archives/

-</div>
-
-
-<!----------------------------------------------------------------------------->
-
-[Documentation]: https://fprint.freedesktop.org/libfprint-dev/
-[Contributors]: https://gitlab.freedesktop.org/libfprint/libfprint/-/graphs/master
-[Unsupported]: https://gitlab.freedesktop.org/libfprint/wiki/-/wikis/Unsupported-Devices
-[Supported]: https://fprint.freedesktop.org/supported-devices.html
-[Website]: https://fprint.freedesktop.org/
-[MailingList]: https://lists.freedesktop.org/mailman/listinfo/fprint
-[IRC]: ircs://irc.oftc.net:6697/#fprint
-[Matrix]: https://matrix.to/#/#fprint:matrix.org
-
-[Contribute]: ./HACKING.md
-[License]: ./COPYING
-
-[University Of Manchester]: https://www.manchester.ac.uk/
-[US Export Controlled]: https://fprint.freedesktop.org/us-export-control.html
-[NBIS]: http://fingerprint.nist.gov/NBIS/index.html
-
-
-<!---------------------------------[ Badges ]---------------------------------->
-
-[Badge License]: https://img.shields.io/badge/License-LGPL2.1-015d93.svg?style=for-the-badge&labelColor=blue
-
-
-<!---------------------------------[ Buttons ]--------------------------------->
-
-[Button Documentation]: https://img.shields.io/badge/Documentation-04ACE6?style=for-the-badge&logoColor=white&logo=BookStack
-[Button Contributors]: https://img.shields.io/badge/Contributors-FF4F8B?style=for-the-badge&logoColor=white&logo=ActiGraph
-[Button Unsupported]: https://img.shields.io/badge/Unsupported_Devices-EF2D5E?style=for-the-badge&logoColor=white&logo=AdBlock
-[Button Contribute]: https://img.shields.io/badge/Contribute-66459B?style=for-the-badge&logoColor=white&logo=Git
-[Button Supported]: https://img.shields.io/badge/Supported_Devices-428813?style=for-the-badge&logoColor=white&logo=AdGuard
-[Button Website]: https://img.shields.io/badge/Homepage-3B80AE?style=for-the-badge&logoColor=white&logo=freedesktopDotOrg
+Historical website:
+http://web.archive.org/web/*/https://www.freedesktop.org/wiki/Software/fprint/
--- a/data/autosuspend.hwdb
+++ b/data/autosuspend.hwdb
@@ -67,7 +67,7 @@ usb:v08FFp5731*
 ID_PERSIST=0

 # Supported by libfprint driver aes4000
-usb:v08FFp5501*
+usb:v5501p08FF*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

@@ -77,15 +77,6 @@ usb:v1C7Ap0571*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

-# Supported by libfprint driver egismoc
-usb:v1C7Ap0582*
-usb:v1C7Ap0583*
-usb:v1C7Ap0586*
-usb:v1C7Ap0587*
-usb:v1C7Ap05A1*
- ID_AUTOSUSPEND=1
- ID_PERSIST=0
-
 # Supported by libfprint driver elan
 usb:v04F3p0903*
 usb:v04F3p0907*
@@ -155,14 +146,6 @@ usb:v04F3p0C58*
 usb:v04F3p0C7D*
 usb:v04F3p0C7E*
 usb:v04F3p0C82*
-usb:v04F3p0C88*
-usb:v04F3p0C8C*
-usb:v04F3p0C8D*
-usb:v04F3p0C98*
-usb:v04F3p0C99*
-usb:v04F3p0C9D*
-usb:v04F3p0C9F*
-usb:v04F3p0CA3*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

@@ -171,62 +154,21 @@ usb:v1C7Ap0603*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

-# Supported by libfprint driver focaltech_moc
-usb:v2808p9E48*
-usb:v2808pD979*
-usb:v2808pA959*
-usb:v2808pA99A*
-usb:v2808pA57A*
-usb:v2808pA78A*
- 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*
- ID_AUTOSUSPEND=1
- ID_PERSIST=0
-
 # Supported by libfprint driver goodixmoc
 usb:v27C6p5840*
-usb:v27C6p6014*
-usb:v27C6p6092*
-usb:v27C6p6094*
-usb:v27C6p609A*
 usb:v27C6p609C*
 usb:v27C6p60A2*
-usb:v27C6p60A4*
-usb:v27C6p60BC*
-usb:v27C6p60C2*
-usb:v27C6p6304*
-usb:v27C6p631C*
-usb:v27C6p633C*
-usb:v27C6p634C*
-usb:v27C6p6384*
 usb:v27C6p639C*
 usb:v27C6p63AC*
 usb:v27C6p63BC*
 usb:v27C6p63CC*
 usb:v27C6p6496*
-usb:v27C6p650A*
-usb:v27C6p650C*
-usb:v27C6p6582*
 usb:v27C6p6584*
 usb:v27C6p658C*
 usb:v27C6p6592*
 usb:v27C6p6594*
-usb:v27C6p659A*
 usb:v27C6p659C*
 usb:v27C6p6A94*
-usb:v27C6p6512*
-usb:v27C6p689A*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

@@ -235,40 +177,19 @@ usb:v298Dp1010*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

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

@@ -281,7 +202,6 @@ usb:v147Ep1001*

 # Supported by libfprint driver upektc
 usb:v0483p2015*
-usb:v0483p2017*
 usb:v147Ep3001*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0
@@ -337,36 +257,12 @@ usb:v138Ap0091*
 ID_PERSIST=0

 # Known unsupported devices
-usb:v0A5Cp5802*
-usb:v047Dp00F2*
-usb:v047Dp8054*
-usb:v047Dp8055*
-usb:v04E8p730B*
 usb:v04F3p036B*
 usb:v04F3p0C00*
 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*
@@ -377,16 +273,15 @@ usb:v06CBp00A8*
 usb:v06CBp00B7*
 usb:v06CBp00BB*
 usb:v06CBp00BE*
+usb:v06CBp00C4*
 usb:v06CBp00CB*
 usb:v06CBp00C9*
 usb:v06CBp00D8*
 usb:v06CBp00DA*
 usb:v06CBp00DC*
-usb:v06CBp00E4*
 usb:v06CBp00E7*
 usb:v06CBp00E9*
 usb:v06CBp00FD*
-usb:v06CBp00FF*
 usb:v0A5Cp5801*
 usb:v0A5Cp5805*
 usb:v0A5Cp5834*
@@ -396,19 +291,9 @@ usb:v0A5Cp5842*
 usb:v0A5Cp5843*
 usb:v0A5Cp5844*
 usb:v0A5Cp5845*
-usb:v0A5Cp5860*
-usb:v0A5Cp5863*
-usb:v0A5Cp5864*
-usb:v0A5Cp5865*
-usb:v0A5Cp5866*
-usb:v0A5Cp5867*
 usb:v0BDAp5812*
 usb:v10A5p0007*
 usb:v10A5p9200*
-usb:v10A5p9800*
-usb:v10A5pA120*
-usb:v10A5pA900*
-usb:v10A5pE340*
 usb:v1188p9545*
 usb:v138Ap0007*
 usb:v138Ap003A*
@@ -421,57 +306,35 @@ usb:v138Ap0094*
 usb:v138Ap0097*
 usb:v138Ap009D*
 usb:v138Ap00AB*
-usb:v138Ap00A6*
 usb:v147Ep1002*
 usb:v1491p0088*
 usb:v16D1p1027*
 usb:v1C7Ap0300*
 usb:v1C7Ap0575*
 usb:v1C7Ap0576*
-usb:v1C7Ap0584*
-usb:v1C7Ap0577*
-usb:v1C7Ap057E*
-usb:v2541p0236*
-usb:v2541p9711*
 usb:v27C6p5042*
 usb:v27C6p5110*
 usb:v27C6p5117*
-usb:v27C6p5120*
-usb:v27C6p5125*
 usb:v27C6p5201*
 usb:v27C6p521D*
 usb:v27C6p5301*
 usb:v27C6p530C*
 usb:v27C6p532D*
-usb:v27C6p5335*
 usb:v27C6p533C*
 usb:v27C6p5381*
 usb:v27C6p5385*
 usb:v27C6p538C*
 usb:v27C6p538D*
 usb:v27C6p5395*
-usb:v27C6p5503*
-usb:v27C6p550A*
-usb:v27C6p550C*
 usb:v27C6p5584*
 usb:v27C6p55A2*
 usb:v27C6p55A4*
 usb:v27C6p55B4*
 usb:v27C6p5740*
 usb:v27C6p5E0A*
-usb:v27C6p581A*
-usb:v27C6p589A*
-usb:v27C6p5F10*
-usb:v27C6p6382*
 usb:v2808p9338*
-usb:v2808p9348*
-usb:v2808p93A9*
-usb:v2808pA658*
-usb:v2808pC652*
 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,14 +101,11 @@ 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/demo/org.freedesktop.libfprint.Demo.json
+++ b/demo/org.freedesktop.libfprint.Demo.json
@@ -1,12 +1,12 @@
 {
    "app-id": "org.freedesktop.libfprint.Demo",
    "runtime": "org.gnome.Platform",
-    "runtime-version": "master",
+    "runtime-version": "3.36",
    "sdk": "org.gnome.Sdk",
    "command": "gtk-libfprint-test",
    "finish-args": [
        /* X11 + XShm access */
-        "--share=ipc", "--socket=fallback-x11",
+        "--share=ipc", "--socket=x11",
        /* Wayland access */
        "--socket=wayland",
        /* OpenGL access */
@@ -18,7 +18,7 @@
    "modules": [
        {
            "name": "libusb",
-            "config-opts": [ "--disable-static" ],
+            "config-opts": [ "--disable-static", "--disable-udev" ],
            "cleanup": [
                "/lib/*.la",
                "/lib/pkgconfig",
@@ -26,47 +26,48 @@
            ],
            "sources": [
                {
-                   "type": "archive",
-                   "url": "https://github.com/libusb/libusb/releases/download/v1.0.26/libusb-1.0.26.tar.bz2",
-                   "sha256": "12ce7a61fc9854d1d2a1ffe095f7b5fac19ddba095c259e6067a46500381b5a5"
+                    "type": "archive",
+                    "url": "https://github.com/libusb/libusb/archive/v1.0.22.tar.gz",
+                    "sha256": "3500f7b182750cd9ccf9be8b1df998f83df56a39ab264976bdb3307773e16f48"
                }
            ],
            "post-install": [
-                "install -Dm644 COPYING /app/share/licenses/libusb/COPYING"
+                "install -Dm644 COPYING /app/share/licenses/libgusb/COPYING"
            ]
        },
        {
            "name": "libgusb",
            "buildsystem": "meson",
-            "config-opts": [ "-Dtests=false", "-Dvapi=false", "-Ddocs=false" ],
+            "config-opts": [ "-Dtests=false", "-Dvapi=false", "-Ddocs=false", "-Dintrospection=false" ],
            "sources": [
                {
                    "type": "archive",
-                    "url": "https://github.com/hughsie/libgusb/releases/download/0.4.6/libgusb-0.4.6.tar.xz",
-                    "sha256": "1b0422bdcd72183272ac42eec9398c5a0bc48a02f618fa3242c468cbbd003049"
+                    "url": "https://github.com/hughsie/libgusb/archive/0.3.0.tar.gz",
+                    "sha256": "b36310f8405d5fd68f6caf4a829f7ab4c627b38fd3d02a139d411fce0f3a49f1"
                }
            ]
        },
        {
            "name": "gudev",
            "buildsystem": "meson",
-            "config-opts": [ "-Dtests=disabled", "-Dintrospection=disabled", "-Dvapi=disabled" ],
+            "config-opts": [ "-Dtests=disabled", "-Dintrospection=disabled" ],
            "sources": [
                {
                    "type": "archive",
-                    "url": "https://download.gnome.org/sources/libgudev/238/libgudev-238.tar.xz",
-                    "sha256": "61266ab1afc9d73dbc60a8b2af73e99d2fdff47d99544d085760e4fa667b5dd1"
+                    "url": "https://download.gnome.org/sources/libgudev/236/libgudev-236.tar.xz",
+                    "sha256": "e50369d06d594bae615eb7aeb787de304ebaad07a26d1043cef8e9c7ab7c9524"
                }
            ]
        },
        {
            "name": "libfprint",
            "buildsystem": "meson",
-            "config-opts": [ "-Dudev_hwdb=disabled", "-Dudev_rules=disabled", "-Dgtk-examples=true", "-Ddrivers=all" ],
+            "config-opts": [ "-Dudev_hwdb=disabled", "-Dudev_rules=disabled", "-Dx11-examples=false", "-Dgtk-examples=true", "-Ddrivers=all" ],
            "sources": [
                {
                    "type": "git",
-                    "url": "https://gitlab.freedesktop.org/libfprint/libfprint.git"
+                    "url": "https://gitlab.freedesktop.org/libfprint/libfprint.git",
+                    "branch": "wip/benzea/v2"
                }
            ]
        }
--- a/doc/libfprint-2-sections.txt
+++ b/doc/libfprint-2-sections.txt
@@ -40,8 +40,6 @@ fp_device_has_feature
 fp_device_has_storage
 fp_device_supports_identify
 fp_device_supports_capture
-fp_device_get_persistent_data
-fp_device_set_persistent_data
 fp_device_is_open
 fp_device_open
 fp_device_close
--- a/doc/meson.build
+++ b/doc/meson.build
@@ -19,13 +19,13 @@ content_files = [

 expand_content_files = content_files

-glib_prefix = dependency('glib-2.0').get_variable(pkgconfig: 'prefix')
+glib_prefix = dependency('glib-2.0').get_pkgconfig_variable('prefix')
 glib_docpath = join_paths(glib_prefix, 'share', 'gtk-doc', 'html')
 docpath = join_paths(get_option('datadir'), 'gtk-doc', 'html')

 gnome.gtkdoc(versioned_libname,
    main_xml: 'libfprint-docs.xml',
-    src_dir: join_paths(meson.project_source_root(), 'libfprint'),
+    src_dir: join_paths(meson.source_root(), 'libfprint'),
    include_directories: include_directories('../libfprint'),
    dependencies: libfprint_dep,
    content_files: content_files,
--- a/examples/clear-storage.c
+++ b/examples/clear-storage.c
@@ -1,208 +0,0 @@
-/*
- * 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,7 +5,6 @@ examples = [
    'img-capture',
    'manage-prints',
    'verify',
-    'clear-storage',
 ]

 foreach example: examples
@@ -22,8 +21,3 @@ executable('cpp-test',
    'cpp-test.cpp',
    dependencies: libfprint_dep,
 )
-
-if installed_tests
-    install_subdir('prints',
-        install_dir: installed_tests_testdir)
-endif
--- a/examples/storage.c
+++ b/examples/storage.c
@@ -26,7 +26,6 @@
 #include "storage.h"

 #include <errno.h>
-#include <glib/gstdio.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <unistd.h>
@@ -56,18 +55,6 @@ 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)
 {
@@ -182,6 +169,8 @@ 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;
@@ -189,7 +178,9 @@ 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);
-  dev_prefix = get_print_prefix_for_device (dev);
+  driver = fp_device_get_driver (dev);
+  dev_id = fp_device_get_device_id (dev);
+  dev_prefix = g_strdup_printf ("%s/%s/", driver, dev_id);

  g_variant_iter_init (&iter, dict_variant);
  while (g_variant_iter_loop (&iter, "{sv}", &key, &value))
@@ -217,55 +208,6 @@ 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,17 +20,12 @@

 #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
@@ -1 +0,0 @@
-gcov-ignore-parse-errors = suspicious_hits.warn
--- a/libfprint/drivers/aes4000.c
+++ b/libfprint/drivers/aes4000.c
@@ -124,7 +124,7 @@ G_DEFINE_TYPE (FpiDeviceAes4000, fpi_device_aes4000, FPI_TYPE_DEVICE_AES3K);


 static const FpIdEntry id_table[] = {
-  { .vid = 0x08ff, .pid = 0x5501 },
+  { .pid = 0x08ff, .vid = 0x5501 },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },
 };

--- a/libfprint/drivers/egis0570.c
+++ b/libfprint/drivers/egis0570.c
--- a/libfprint/drivers/egis0570.h
+++ b/libfprint/drivers/egis0570.h
@@ -18,13 +18,10 @@
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

-#include "drivers_api.h"
-
 #ifndef __EGIS0570_H

 #define __EGIS0570_H 1

-
 /*
 * Device data
 */
@@ -57,33 +54,6 @@

 #define EGIS0570_INIT_TOTAL (sizeof ((init_pkts)) / sizeof ((init_pkts[0])))

-// static unsigned char init_pkts[][EGIS0570_PKTSIZE] =
-// {
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x20, 0x3f },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x58, 0x3f },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x21, 0x09 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x57, 0x09 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x22, 0x03 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x56, 0x03 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x23, 0x01 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x55, 0x01 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x24, 0x01 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x54, 0x01 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x3e },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x0b },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x03 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x0f },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x10, 0x00 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x11, 0x38 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x12, 0x00 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x13, 0x71 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x03, 0x80 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x00, 0x02, 0x80 },
-//   { 0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x2f },
-//   { 0x45, 0x47, 0x49, 0x53, 0x06, 0x00, 0xfe }        /* image returned after this packet */
-// };
-
 static unsigned char init_pkts[][EGIS0570_PKTSIZE] =
 {
  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x20, 0x3f },
@@ -96,8 +66,6 @@ static unsigned char init_pkts[][EGIS0570_PKTSIZE] =
  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x55, 0x01 },
  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x24, 0x01 },
  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x54, 0x01 },
-  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x25, 0x00 },
-  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x53, 0x00 },
  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x3e },
  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x0b },
  { 0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x03 },
@@ -207,386 +175,3 @@ static unsigned char repeat_pkts[][EGIS0570_PKTSIZE] =
 #define EGIS0570_RESIZE 2

 #endif
-
-
-// Calibration
-
-enum driver_version {
-  PACKET_CALIBRATION,
-  PACKET_VERSION_1,
-  NONE,
-};
-
-#define PRESISTENT_DATA_LENGTH 9
-#define EGIS0570_CAL_IMG_TOT 22 //124
-#define EGIS0570_CAL_INPSIZE 6528
-#define EGIS0570_CAL_BS_ELM 7
-
-
-#define IMG_COL_IGNORE 23
-#define TARGET_UPPER 80
-#define TARGET_LOWER 70
-// #define SIDE_DIFF (-10)
-#define SIDE_DIFF (+5)
-
-/* static pkts */
-static guint8 EGIS0570_CAL_CONFIGURATION_MODE_PKT[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x0d, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x0e, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x1f},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x05, 0x08},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x03, 0xff}
-};
-
-static guint8 EGIS0570_CAL_PKT_ZERO_RANGE[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x01, 0x10},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x03, 0x80},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x04, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x05, 0x08},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x06, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x07, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x08, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x0a},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x0a, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x0b, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x0c, 0xff},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x0d, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x0e, 0x00}
-};
-
-
-static guint8 EGIS0570_CAL_CAPTURING_AREA[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x10, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x11, 0x38},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x12, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x13, 0x71}
-};
-
-static guint8 EGIS0570_CAL_SENSOR_AND_EMITTER[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x15},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x08}
-};
-
-
-static guint8 EGIS0570_CAL_WHITE_SETTING[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x0f},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x3f},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x00, 0x02, 0x00}
-};
-
-static guint8 EGIS0570_CAL_BLACK_WHITE_GET_IMAGE[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x20},
-  {0x45, 0x47, 0x49, 0x53, 0x06, 0x00, 0x33}
-};
-
-static guint8 EGIS0570_CAL_BLACK_WHITE_AFTER_IMAGE[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x00}
-};
-
-static guint8 EGIS0570_CAL_BLACK_SETTING[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x03},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0xff},
-  {0x45, 0x47, 0x49, 0x53, 0x00, 0x02, 0xff}
-};
-
-static guint8 EGIS0570_CAL_BLACK_WHITE_CLEAR[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x0f},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x03, 0x80},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x00}
-};
-
-
-static guint8 EGIS0570_CAL_MIDDLE_BLACK_SETTING[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x0a},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x7f},
-  {0x45, 0x47, 0x49, 0x53, 0x00, 0x02, 0x7f},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x2f}
-};
-
-static guint8 EGIS0570_CAL_GET_IMAGE[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x06, 0x00, 0x33}
-};
-
-static guint8 EGIS0570_CAL_AFTER_IMAGE[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x0f}
-};
-
-static guint8 EGIS0570_CAL_REPEAT[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x00, 0x02, 0x0f},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x2f}
-};
-
-static guint8 EGIS0570_CAL_BORDER_WHITE_SETTING[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x0a},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x3f},
-  {0x45, 0x47, 0x49, 0x53, 0x00, 0x02, 0x3f},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x2f}
-};
-
-
-static guint8 EGIS0570_CAL_FIRST_BS_SETTING[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x00},
-};
-
-static guint8 EGIS0570_CAL_BEFORE_GET_IMAGE[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x2f}
-};
-
-static guint8 EGIS0570_CAL_NO_IMAGE_CAPTURING_AREA[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x10, 0x1c},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x11, 0x1c},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x12, 0x31},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x13, 0x40}
-};
-
-static guint8 EGIS0570_CAL_NO_IMAGE_SETTING_0[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x09, 0x05},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x14, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x15, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x16, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x08, 0x1c}
-};
-
-static guint8 EGIS0570_CAL_NO_IMAGE_BINARY_14_SETTING[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x0b, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x0c, 0xff},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x0d, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x0e, 0xff},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x02, 0x1d},
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x04, 0x00}
-};
-
-static guint8 EGIS0570_CAL_NO_IMAGE_PRE_FIRST[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x01, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x00, 0x01, 0x00}
-};
-
-
-static guint8 EGIS0570_CAL_NO_IMAGE_REQUEST[][EGIS0570_PKTSIZE] =
-{
-  {0x45, 0x47, 0x49, 0x53, 0x01, 0x01, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x00, 0x01, 0x00},
-  {0x45, 0x47, 0x49, 0x53, 0x00, 0x01, 0x00}
-};
-
-
-#define EGIS0570_CAL_STATIC_LIST_SIZEOF (sizeof ((EGIS0570_CAL_STATIC_LIST)) / sizeof ((EGIS0570_CAL_STATIC_LIST[0])))
-
-static guint8 * EGIS0570_CAL_STATIC_LIST[] = {
-  *EGIS0570_CAL_CONFIGURATION_MODE_PKT,
-  *EGIS0570_CAL_PKT_ZERO_RANGE,
-  *EGIS0570_CAL_CAPTURING_AREA,
-  *EGIS0570_CAL_SENSOR_AND_EMITTER,
-  *EGIS0570_CAL_WHITE_SETTING,
-  *EGIS0570_CAL_BLACK_WHITE_GET_IMAGE,
-  *EGIS0570_CAL_BLACK_WHITE_AFTER_IMAGE,
-  *EGIS0570_CAL_BLACK_SETTING,
-  *EGIS0570_CAL_BLACK_WHITE_CLEAR,
-  *EGIS0570_CAL_MIDDLE_BLACK_SETTING,
-  *EGIS0570_CAL_GET_IMAGE,
-  *EGIS0570_CAL_AFTER_IMAGE,
-  *EGIS0570_CAL_REPEAT,
-  *EGIS0570_CAL_BORDER_WHITE_SETTING,
-  *EGIS0570_CAL_FIRST_BS_SETTING,
-  *EGIS0570_CAL_BEFORE_GET_IMAGE,
-  *EGIS0570_CAL_NO_IMAGE_CAPTURING_AREA,
-  *EGIS0570_CAL_NO_IMAGE_SETTING_0,
-  *EGIS0570_CAL_NO_IMAGE_BINARY_14_SETTING,
-  *EGIS0570_CAL_NO_IMAGE_PRE_FIRST,
-  *EGIS0570_CAL_NO_IMAGE_REQUEST,
-};
-
-
-#define EGIS0570_HELPER_PKT_SIZEOF(x) (sizeof (x) / sizeof (x[0]))
-
-static guint8 EGIS0570_CAL_STATIC_LIST_SIZE[] = {
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_CONFIGURATION_MODE_PKT),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_PKT_ZERO_RANGE),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_CAPTURING_AREA),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_SENSOR_AND_EMITTER),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_WHITE_SETTING),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_BLACK_WHITE_GET_IMAGE),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_BLACK_WHITE_AFTER_IMAGE),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_BLACK_SETTING),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_BLACK_WHITE_CLEAR),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_MIDDLE_BLACK_SETTING),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_GET_IMAGE),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_AFTER_IMAGE),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_REPEAT),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_BORDER_WHITE_SETTING),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_FIRST_BS_SETTING),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_BEFORE_GET_IMAGE),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_NO_IMAGE_CAPTURING_AREA),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_NO_IMAGE_SETTING_0),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_NO_IMAGE_BINARY_14_SETTING),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_NO_IMAGE_PRE_FIRST),
-  EGIS0570_HELPER_PKT_SIZEOF (EGIS0570_CAL_NO_IMAGE_REQUEST),
-};
-
-
-/* Calibration logic */
-enum cal_proc_en {
-  CAL_CONF_PKT,
-  CAL_PKT_ZERO_RNG,
-  CAL_CAPT_AREA,
-  CAL_SENS_AND_EMIT,
-  CAL_RNG_20_58,
-  CAL_RNG_60_D0,
-  CAL_WHITE_SET,
-  CAL_BLACK_WHITE_GET_IMG,
-  CAL_BLACK_WHITE_AFTER_IMAGE,
-  CAL_BLACK_SET,
-  CAL_CHECK_BLACK_WHITE,
-  CAL_5_ROWS_ZEROS,
-  CAL_BLACK_WHITE_CLEAR,
-  CAL_RNG_60_D1,
-  CAL_MID_BLACK_SET,
-  CAL_GET_IMG,
-  CAL_AFTER_IMG,
-  CAL_GET_9,
-  CAL_BORDER_WHITE_SET,
-  CAL_FIRST_BS_SET,
-  CAL_BS_CHK_SET,
-  CAL_PKT_02,
-  CAL_BEFORE_IMG,
-  CAL_BS_JUMP,
-  CAL_BS_END,
-  CAL_PKT_15_0,
-  CAL_PKT_16_3C,
-  CAL_CHK_NEW_CONF,
-  CAL_GET_21,
-  CAL_NO_IMG_CAP_AREA,
-  CAL_NO_IMG_SET_0,
-  CAL_NO_IMG_03_1C,
-  CAL_NO_CHK_03_80,
-  CAL_NO_SET_03_80,
-  CAL_NO_IMG_14_BS_SET,
-  CAL_NO_IMG_14_BS_CHK_SET,
-  CAL_NO_IMG_PRE_FIRST,
-  CAL_NO_IMG_GET_8,
-  CAL_NO_IMG_14_BS_JUMP,
-  CAL_NO_IMG_14_BS_END,
-  CAL_NO_IMG_16_BS_SET,
-  CAL_NO_IMG_16_BS_CHK_SET_15,
-  CAL_NO_IMG_16_BS_SET_16,
-  CAL_NO_IMG_16_BS_JUMP,
-  CAL_NO_IMG_16_BS_END,
-
-
-  CAL_END,
-};
-
-
-#define EGIS0570_CAL_PROC_SIZEOF (sizeof ((calibration_procedure)) / sizeof ((calibration_procedure[0])))
-
-static guint8 calibration_procedure[] = {
-  // conf
-  CAL_CONF_PKT,
-  // sensor check
-  CAL_PKT_ZERO_RNG,
-  CAL_CAPT_AREA,
-  CAL_SENS_AND_EMIT,
-  CAL_RNG_20_58,
-  CAL_RNG_60_D0,
-  CAL_WHITE_SET,
-  CAL_BLACK_WHITE_GET_IMG,
-  CAL_BLACK_WHITE_AFTER_IMAGE,
-  CAL_BLACK_SET,
-  CAL_BLACK_WHITE_GET_IMG,
-  CAL_BLACK_WHITE_AFTER_IMAGE,
-  CAL_CHECK_BLACK_WHITE,
-  // not binary 16
-  CAL_CAPT_AREA,
-  CAL_5_ROWS_ZEROS,
-  CAL_BLACK_WHITE_CLEAR,
-  CAL_RNG_20_58,
-  CAL_RNG_60_D1,
-  CAL_MID_BLACK_SET,
-  CAL_GET_IMG,
-  CAL_AFTER_IMG,
-  CAL_GET_9,
-  CAL_BORDER_WHITE_SET,
-  CAL_GET_IMG,
-  CAL_AFTER_IMG,
-  CAL_GET_9,
-  // binary
-  CAL_FIRST_BS_SET,
-  CAL_BS_CHK_SET,        // 0
-  CAL_PKT_02,            // 1
-  CAL_BEFORE_IMG,        // 2
-  CAL_GET_IMG,           // 3
-  CAL_AFTER_IMG,         // 4
-  CAL_GET_9,             // 5
-  CAL_BS_JUMP,           // 6
-  CAL_BS_END,            // 7
-  // check pictures.
-  CAL_PKT_15_0,
-  CAL_PKT_16_3C,
-  CAL_CHK_NEW_CONF,
-  CAL_PKT_02,
-  CAL_BEFORE_IMG,
-  CAL_GET_IMG,
-  CAL_AFTER_IMG,
-  CAL_GET_21,
-  // no image 14
-  CAL_NO_IMG_CAP_AREA,
-  CAL_NO_IMG_SET_0,
-  CAL_NO_IMG_03_1C,
-  CAL_NO_CHK_03_80,
-  CAL_NO_SET_03_80,
-  CAL_NO_IMG_14_BS_SET,
-  CAL_NO_IMG_14_BS_CHK_SET,   // 0
-  CAL_NO_IMG_PRE_FIRST,       // 1
-  CAL_NO_IMG_GET_8,           // 2
-  CAL_NO_IMG_14_BS_JUMP,      // 3
-  CAL_NO_IMG_14_BS_END,       // 4
-  // no image 16
-  CAL_NO_IMG_16_BS_SET,
-  CAL_NO_IMG_16_BS_CHK_SET_15,   // 0
-  CAL_NO_IMG_16_BS_SET_16,       // 1
-  CAL_NO_IMG_PRE_FIRST,          // 2
-  CAL_NO_IMG_GET_8,              // 3
-  CAL_NO_IMG_16_BS_JUMP,         // 4
-  CAL_NO_IMG_16_BS_END,          // 5
-  // end
-  CAL_CONF_PKT,
-  CAL_CONF_PKT,
-
-  CAL_END,
-};
--- a/libfprint/drivers/egismoc/egismoc.c
+++ b/libfprint/drivers/egismoc/egismoc.c
--- a/libfprint/drivers/egismoc/egismoc.h
+++ b/libfprint/drivers/egismoc/egismoc.h
@@ -1,223 +0,0 @@
-/*
- * Driver for Egis Technology (LighTuning) Match-On-Chip sensors
- * Originally authored 2023 by Joshua Grisham <josh@joshuagrisham.com>
- *
- * Portions of code and logic inspired from the elanmoc libfprint driver
- * which is copyright (C) 2021 Elan Microelectronics Inc (see elanmoc.c)
- *
- * Based on original reverse-engineering work by Joshua Grisham. The protocol has
- * been reverse-engineered from captures of the official Windows driver, and by
- * testing commands on the sensor with a multiplatform Python prototype driver:
- * https://github.com/joshuagrisham/galaxy-book2-pro-linux/tree/main/fingerprint/
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#pragma once
-
-#include "fpi-device.h"
-#include "fpi-ssm.h"
-
-G_DECLARE_FINAL_TYPE (FpiDeviceEgisMoc, fpi_device_egismoc, FPI, DEVICE_EGISMOC, FpDevice)
-
-#define EGISMOC_DRIVER_FULLNAME "Egis Technology (LighTuning) Match-on-Chip"
-
-#define EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 (1 << 0)
-#define EGISMOC_DRIVER_CHECK_PREFIX_TYPE2 (1 << 1)
-#define EGISMOC_DRIVER_MAX_ENROLL_STAGES_20 (1 << 2)
-
-#define EGISMOC_EP_CMD_OUT (0x02 | FPI_USB_ENDPOINT_OUT)
-#define EGISMOC_EP_CMD_IN (0x81 | FPI_USB_ENDPOINT_IN)
-#define EGISMOC_EP_CMD_INTERRUPT_IN 0x83
-
-#define EGISMOC_USB_CONTROL_TIMEOUT 5000
-#define EGISMOC_USB_SEND_TIMEOUT 5000
-#define EGISMOC_USB_RECV_TIMEOUT 5000
-#define EGISMOC_USB_INTERRUPT_TIMEOUT 60000
-
-#define EGISMOC_USB_IN_RECV_LENGTH 4096
-#define EGISMOC_USB_INTERRUPT_IN_RECV_LENGTH 64
-
-#define EGISMOC_MAX_ENROLL_STAGES_DEFAULT 10
-#define EGISMOC_MAX_ENROLL_NUM 10
-#define EGISMOC_FINGERPRINT_DATA_SIZE 32
-#define EGISMOC_LIST_RESPONSE_PREFIX_SIZE 14
-#define EGISMOC_LIST_RESPONSE_SUFFIX_SIZE 2
-
-/* standard prefixes for all read/writes */
-
-static guchar egismoc_write_prefix[] = {'E', 'G', 'I', 'S', 0x00, 0x00, 0x00, 0x01};
-static gsize egismoc_write_prefix_len = sizeof (egismoc_write_prefix) / sizeof (egismoc_write_prefix[0]);
-
-static guchar egismoc_read_prefix[] = {'S', 'I', 'G', 'E', 0x00, 0x00, 0x00, 0x01};
-static gsize egismoc_read_prefix_len = sizeof (egismoc_read_prefix) / sizeof (egismoc_read_prefix[0]);
-
-
-/* hard-coded command payloads */
-
-static guchar cmd_fw_version[] = {0x00, 0x00, 0x00, 0x07, 0x50, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x0c};
-static gsize cmd_fw_version_len = sizeof (cmd_fw_version) / sizeof (cmd_fw_version[0]);
-static guchar rsp_fw_version_suffix[] = {0x90, 0x00};
-static gsize rsp_fw_version_suffix_len = sizeof (rsp_fw_version_suffix) / sizeof (rsp_fw_version_suffix[0]);
-
-static guchar cmd_list[] = {0x00, 0x00, 0x00, 0x07, 0x50, 0x19, 0x04, 0x00, 0x00, 0x01, 0x40};
-static gsize cmd_list_len = sizeof (cmd_list) / sizeof (cmd_list[0]);
-
-static guchar cmd_sensor_reset[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x1a, 0x00, 0x00};
-static gsize cmd_sensor_reset_len = sizeof (cmd_sensor_reset) / sizeof (cmd_sensor_reset[0]);
-
-static guchar cmd_sensor_check[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x17, 0x02, 0x00};
-static gsize cmd_sensor_check_len = sizeof (cmd_sensor_check) / sizeof (cmd_sensor_check[0]);
-
-static guchar cmd_sensor_identify[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x17, 0x01, 0x01};
-static gsize cmd_sensor_identify_len = sizeof (cmd_sensor_identify) / sizeof (cmd_sensor_identify[0]);
-static guchar rsp_identify_match_suffix[] = {0x90, 0x00};
-static gsize rsp_identify_match_suffix_len = sizeof (rsp_identify_match_suffix) / sizeof (rsp_identify_match_suffix[0]);
-static guchar rsp_identify_notmatch_suffix[] = {0x90, 0x04};
-static gsize rsp_identify_notmatch_suffix_len = sizeof (rsp_identify_notmatch_suffix) / sizeof (rsp_identify_notmatch_suffix[0]);
-
-static guchar cmd_sensor_enroll[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x17, 0x01, 0x00};
-static gsize cmd_sensor_enroll_len = sizeof (cmd_sensor_enroll) / sizeof (cmd_sensor_enroll[0]);
-
-static guchar cmd_enroll_starting[] = {0x00, 0x00, 0x00, 0x07, 0x50, 0x16, 0x01, 0x00, 0x00, 0x00, 0x20};
-static gsize cmd_enroll_starting_len = sizeof (cmd_enroll_starting) / sizeof (cmd_enroll_starting[0]);
-
-static guchar cmd_sensor_start_capture[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x16, 0x02, 0x01};
-static gsize cmd_sensor_start_capture_len = sizeof (cmd_sensor_start_capture) / sizeof (cmd_sensor_start_capture[0]);
-
-static guchar cmd_read_capture[] = {0x00, 0x00, 0x00, 0x07, 0x50, 0x16, 0x02, 0x02, 0x00, 0x00, 0x02};
-static gsize cmd_read_capture_len = sizeof (cmd_read_capture) / sizeof (cmd_read_capture[0]);
-static guchar rsp_read_success_prefix[] = {0x00, 0x00, 0x00, 0x04};
-static gsize rsp_read_success_prefix_len = sizeof (rsp_read_success_prefix) / sizeof (rsp_read_success_prefix[0]);
-static guchar rsp_read_success_suffix[] = {0x90, 0x00};
-static gsize rsp_read_success_suffix_len = sizeof (rsp_read_success_suffix) / sizeof (rsp_read_success_suffix[0]);
-static guchar rsp_read_offcenter_prefix[] = {0x00, 0x00, 0x00, 0x04};
-static gsize rsp_read_offcenter_prefix_len = sizeof (rsp_read_offcenter_prefix) / sizeof (rsp_read_offcenter_prefix[0]);
-static guchar rsp_read_offcenter_suffix[] = {0x64, 0x91};
-static gsize rsp_read_offcenter_suffix_len = sizeof (rsp_read_offcenter_suffix) / sizeof (rsp_read_offcenter_suffix[0]);
-static guchar rsp_read_dirty_prefix[] = {0x00, 0x00, 0x00, 0x02, 0x64};
-static gsize rsp_read_dirty_prefix_len = sizeof (rsp_read_dirty_prefix) / sizeof (rsp_read_dirty_prefix[0]);
-
-static guchar cmd_commit_starting[] = {0x00, 0x00, 0x00, 0x07, 0x50, 0x16, 0x05, 0x00, 0x00, 0x00, 0x20};
-static gsize cmd_commit_starting_len = sizeof (cmd_commit_starting) / sizeof (cmd_commit_starting[0]);
-
-
-/* commands which exist on the device but are currently not used */
-/*
-   static guchar cmd_sensor_cancel[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x16, 0x04, 0x00};
-   static gsize cmd_sensor_cancel_len = sizeof(cmd_sensor_cancel) / sizeof(cmd_sensor_cancel[0]);
-
-   static guchar cmd_sensor_verify[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x04, 0x01, 0x00};
-   static gsize cmd_sensor_verify_len = sizeof(cmd_sensor_verify) / sizeof(cmd_sensor_verify[0]);
-
-   static guchar cmd_read_verify[] = {0x00, 0x00, 0x00, 0x04, 0x50, 0x04, 0x02, 0x00};
-   static gsize cmd_read_verify_len = sizeof(cmd_read_verify) / sizeof(cmd_read_verify[0]);
- */
-
-
-/* prefixes/suffixes and other things for dynamically created command payloads */
-
-#define EGISMOC_CHECK_BYTES_LENGTH 2
-#define EGISMOC_IDENTIFY_RESPONSE_PRINT_ID_OFFSET 46
-#define EGISMOC_CMD_CHECK_SEPARATOR_LENGTH 32
-
-static guchar cmd_new_print_prefix[] = {0x00, 0x00, 0x00, 0x27, 0x50, 0x16, 0x03, 0x00, 0x00, 0x00, 0x20};
-static gsize cmd_new_print_prefix_len = sizeof (cmd_new_print_prefix) / sizeof (cmd_new_print_prefix[0]);
-
-static guchar cmd_delete_prefix[] = {0x50, 0x18, 0x04, 0x00, 0x00};
-static gsize cmd_delete_prefix_len = sizeof (cmd_delete_prefix) / sizeof (cmd_delete_prefix[0]);
-static guchar rsp_delete_success_prefix[] = {0x00, 0x00, 0x00, 0x02, 0x90, 0x00};
-static gsize rsp_delete_success_prefix_len = sizeof (rsp_delete_success_prefix) / sizeof (rsp_delete_success_prefix[0]);
-
-static guchar cmd_check_prefix_type1[] = {0x50, 0x17, 0x03, 0x00, 0x00};
-static gsize cmd_check_prefix_type1_len = sizeof (cmd_check_prefix_type1) / sizeof (cmd_check_prefix_type1[0]);
-static guchar cmd_check_prefix_type2[] = {0x50, 0x17, 0x03, 0x80, 0x00};
-static gsize cmd_check_prefix_type2_len = sizeof (cmd_check_prefix_type2) / sizeof (cmd_check_prefix_type2[0]);
-static guchar cmd_check_suffix[] = {0x00, 0x40};
-static gsize cmd_check_suffix_len = sizeof (cmd_check_suffix) / sizeof (cmd_check_suffix[0]);
-static guchar rsp_check_not_yet_enrolled_suffix[] = {0x90, 0x04};
-static gsize rsp_check_not_yet_enrolled_suffix_len = sizeof (rsp_check_not_yet_enrolled_suffix) / sizeof (rsp_check_not_yet_enrolled_suffix[0]);
-
-
-/* SSM task states and various status enums */
-
-typedef enum {
-  CMD_SEND,
-  CMD_GET,
-  CMD_STATES,
-} CommandStates;
-
-typedef enum {
-  DEV_INIT_CONTROL1,
-  DEV_INIT_CONTROL2,
-  DEV_INIT_CONTROL3,
-  DEV_INIT_CONTROL4,
-  DEV_INIT_CONTROL5,
-  DEV_GET_FW_VERSION,
-  DEV_INIT_STATES,
-} DeviceInitStates;
-
-typedef enum {
-  IDENTIFY_GET_ENROLLED_IDS,
-  IDENTIFY_CHECK_ENROLLED_NUM,
-  IDENTIFY_SENSOR_RESET,
-  IDENTIFY_SENSOR_IDENTIFY,
-  IDENTIFY_WAIT_FINGER,
-  IDENTIFY_SENSOR_CHECK,
-  IDENTIFY_CHECK,
-  IDENTIFY_COMPLETE_SENSOR_RESET,
-  IDENTIFY_COMPLETE,
-  IDENTIFY_STATES,
-} IdentifyStates;
-
-typedef enum {
-  ENROLL_GET_ENROLLED_IDS,
-  ENROLL_CHECK_ENROLLED_NUM,
-  ENROLL_SENSOR_RESET,
-  ENROLL_SENSOR_ENROLL,
-  ENROLL_WAIT_FINGER,
-  ENROLL_SENSOR_CHECK,
-  ENROLL_CHECK,
-  ENROLL_START,
-  ENROLL_CAPTURE_SENSOR_RESET,
-  ENROLL_CAPTURE_SENSOR_START_CAPTURE,
-  ENROLL_CAPTURE_WAIT_FINGER,
-  ENROLL_CAPTURE_READ_RESPONSE,
-  ENROLL_COMMIT_START,
-  ENROLL_COMMIT,
-  ENROLL_COMMIT_SENSOR_RESET,
-  ENROLL_COMPLETE,
-  ENROLL_STATES,
-} EnrollStates;
-
-typedef enum {
-  ENROLL_STATUS_DEVICE_FULL,
-  ENROLL_STATUS_DUPLICATE,
-  ENROLL_STATUS_PARTIAL_OK,
-  ENROLL_STATUS_RETRY,
-  ENROLL_STATUS_COMPLETE,
-} EnrollStatus;
-
-typedef enum {
-  LIST_GET_ENROLLED_IDS,
-  LIST_RETURN_ENROLLED_PRINTS,
-  LIST_STATES,
-} ListStates;
-
-typedef enum {
-  DELETE_GET_ENROLLED_IDS,
-  DELETE_DELETE,
-  DELETE_STATES,
-} DeleteStates;
--- a/libfprint/drivers/elan.c
+++ b/libfprint/drivers/elan.c
@@ -357,7 +357,7 @@ elan_cmd_cb (FpiUsbTransfer *transfer, FpDevice *dev,
  if (transfer->endpoint & FPI_USB_ENDPOINT_IN)
    {
      /* just finished receiving */
-      self->last_read = g_memdup2 (transfer->buffer, transfer->actual_length);
+      self->last_read = g_memdup (transfer->buffer, transfer->actual_length);
      elan_cmd_done (ssm);
    }
  else
--- a/libfprint/drivers/elanmoc/elanmoc.c
+++ b/libfprint/drivers/elanmoc/elanmoc.c
@@ -28,14 +28,6 @@ static const FpIdEntry id_table[] = {
  { .vid = 0x04f3,  .pid = 0x0c7d,  },
  { .vid = 0x04f3,  .pid = 0x0c7e,  },
  { .vid = 0x04f3,  .pid = 0x0c82,  },
-  { .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 = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };

@@ -54,9 +46,9 @@ elanmoc_compose_cmd (
  const struct elanmoc_cmd *cmd_info
                    )
 {
-  g_autofree uint8_t *cmd_buf = NULL;
+  g_autofree char *cmd_buf = NULL;

-  cmd_buf = g_new0 (uint8_t, cmd_info->cmd_len);
+  cmd_buf = g_malloc0 (cmd_info->cmd_len);
  if(cmd_info->cmd_len < ELAN_MAX_HDR_LEN)
    memcpy (cmd_buf, &cmd_info->cmd_header, cmd_info->cmd_len);
  else
@@ -384,9 +376,9 @@ elanmoc_enroll_cb (FpiDeviceElanmoc *self,
          enroll_status_report (self, ENROLL_RSP_RETRY, self->num_frames, NULL);
        }

-      if (self->num_frames == self->max_moc_enroll_time && buffer_in[1] == ELAN_MSG_OK)
+      if (self->num_frames == ELAN_MOC_ENROLL_TIMES && buffer_in[1] == ELAN_MSG_OK)
        fpi_ssm_next_state (self->task_ssm);
-      else if (self->num_frames < self->max_moc_enroll_time)
+      else if (self->num_frames < ELAN_MOC_ENROLL_TIMES)
        fpi_ssm_jump_to_state (self->task_ssm, MOC_ENROLL_WAIT_FINGER);
      else
        fpi_ssm_mark_failed (self->task_ssm, error);
@@ -449,7 +441,7 @@ elan_enroll_run_state (FpiSsm *ssm, FpDevice *dev)
    case MOC_ENROLL_WAIT_FINGER:
      cmd_buf = elanmoc_compose_cmd (&elanmoc_enroll_cmd);
      cmd_buf[3] = self->curr_enrolled;
-      cmd_buf[4] = self->max_moc_enroll_time;
+      cmd_buf[4] = ELAN_MOC_ENROLL_TIMES;
      cmd_buf[5] = self->num_frames;
      elanmoc_get_cmd (dev, cmd_buf, elanmoc_enroll_cmd.cmd_len, elanmoc_enroll_cmd.resp_len, 1, elanmoc_enroll_cb);
      break;
@@ -514,7 +506,7 @@ create_print_from_response (FpiDeviceElanmoc *self,
      return NULL;
    }

-  userid = g_memdup2 (&buffer_in[5], userid_len);
+  userid = g_memdup (&buffer_in[5], userid_len);
  userid_safe = g_strndup ((const char *) &buffer_in[5], userid_len);
  print = fp_print_new (FP_DEVICE (self));
  uid = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, userid, userid_len, 1);
@@ -766,7 +758,6 @@ identify_status_report (FpiDeviceElanmoc *self, int verify_status_id,
 }

 enum identify_states {
-  IDENTIFY_SET_MODE,
  IDENTIFY_WAIT_FINGER,
  IDENTIFY_NUM_STATES,
 };
@@ -802,13 +793,6 @@ elan_identify_run_state (FpiSsm *ssm, FpDevice *dev)
  fp_info ("elanmoc %s ", __func__);
  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case IDENTIFY_SET_MODE:
-      fp_info ("elanmoc %s IDENTIFY_SET_MODE", __func__);
-      cmd_buf = elanmoc_compose_cmd (&elanmoc_set_mod_cmd);
-      cmd_buf[3] = 0x03;
-      elanmoc_get_cmd (dev, cmd_buf, elanmoc_set_mod_cmd.cmd_len, elanmoc_set_mod_cmd.resp_len, 0, elanmoc_cmd_ack_cb);
-      break;
-
    case IDENTIFY_WAIT_FINGER:
      fp_info ("elanmoc %s VERIFY_WAIT_FINGER", __func__);
      cmd_buf = elanmoc_compose_cmd (&elanmoc_verify_cmd);
@@ -1015,12 +999,6 @@ elanmoc_get_status_cb (FpiDeviceElanmoc *self,
    }

  if (buffer_in[1] != 0x03 && self->cmd_retry_cnt != 0)
-    {
-      self->cmd_retry_cnt--;
-      cmd_buf = elanmoc_compose_cmd (&cal_status_cmd);
-      elanmoc_get_cmd (FP_DEVICE (self), cmd_buf, cal_status_cmd.cmd_len, cal_status_cmd.resp_len, 0, elanmoc_get_status_cb);
-    }
-  else
    {
      if(self->cmd_retry_cnt == 0)
        {
@@ -1029,6 +1007,12 @@ elanmoc_get_status_cb (FpiDeviceElanmoc *self,
                                                         "Sensor not ready"));
          return;
        }
+      self->cmd_retry_cnt--;
+      cmd_buf = elanmoc_compose_cmd (&cal_status_cmd);
+      elanmoc_get_cmd (FP_DEVICE (self), cmd_buf, cal_status_cmd.cmd_len, cal_status_cmd.resp_len, 0, elanmoc_get_status_cb);
+    }
+  else
+    {
      fpi_ssm_next_state (self->task_ssm);
    }
 }
@@ -1076,7 +1060,6 @@ elanmoc_open (FpDevice *device)
 {
  FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (device);
  GError *error = NULL;
-  gint productid = 0;

  if (!g_usb_device_reset (fpi_device_get_usb_device (device), &error))
    goto error;
@@ -1084,28 +1067,6 @@ elanmoc_open (FpDevice *device)
  if (!g_usb_device_claim_interface (fpi_device_get_usb_device (device), 0, 0, &error))
    goto error;

-  productid = g_usb_device_get_pid (fpi_device_get_usb_device (device));
-  switch (productid)
-    {
-    case 0x0c8c:
-      self->max_moc_enroll_time = 11;
-      break;
-
-    case 0x0c99:
-      self->max_moc_enroll_time = 14;
-      break;
-
-    case 0x0c8d:
-      self->max_moc_enroll_time = 17;
-      break;
-
-    default:
-      self->max_moc_enroll_time = ELAN_MOC_ENROLL_TIMES;
-      break;
-    }
-
-  fpi_device_set_nr_enroll_stages (device, self->max_moc_enroll_time);
-
  self->task_ssm = fpi_ssm_new (FP_DEVICE (self), dev_init_handler, DEV_INIT_STATES);
  fpi_ssm_start (self->task_ssm, task_ssm_init_done);
  return;
--- a/libfprint/drivers/elanmoc/elanmoc.h
+++ b/libfprint/drivers/elanmoc/elanmoc.h
@@ -188,7 +188,6 @@ struct _FpiDeviceElanmoc
  unsigned char   y_trace;
  int             num_frames;
  int             curr_enrolled;
-  int             max_moc_enroll_time;
  int             cancel_result;
  int             cmd_retry_cnt;
  int             list_index;
--- a/libfprint/drivers/elanspi.h
+++ b/libfprint/drivers/elanspi.h
@@ -340,11 +340,9 @@ 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
--- a/libfprint/drivers/focaltech_moc/focaltech_moc.h
+++ b/libfprint/drivers/focaltech_moc/focaltech_moc.h
@@ -1,52 +0,0 @@
-/*
- * Copyright (C) 2021 Focaltech Microelectronics
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#pragma once
-
-#include "fpi-device.h"
-#include "fpi-ssm.h"
-#include <libusb.h>
-
-#include <stdio.h>
-#include <stdlib.h>
-
-G_DECLARE_FINAL_TYPE (FpiDeviceFocaltechMoc, fpi_device_focaltech_moc, FPI, DEVICE_FOCALTECH_MOC, FpDevice)
-
-#define FOCALTECH_MOC_DRIVER_FULLNAME "Focaltech MOC Sensors"
-
-#define FOCALTECH_MOC_CMD_TIMEOUT 1000
-#define FOCALTECH_MOC_MAX_FINGERS 10
-#define FOCALTECH_MOC_UID_PREFIX_LENGTH 8
-#define FOCALTECH_MOC_USER_ID_LENGTH 64
-
-typedef void (*FocaltechCmdMsgCallback) (FpiDeviceFocaltechMoc *self,
-                                         GError                *error);
-
-struct _FpiDeviceFocaltechMoc
-{
-  FpDevice        parent;
-  FpiSsm         *task_ssm;
-  FpiSsm         *cmd_ssm;
-  FpiUsbTransfer *cmd_transfer;
-  gboolean        cmd_cancelable;
-  gsize           cmd_len_in;
-  int             num_frames;
-  int             delete_slot;
-  guint8          bulk_in_ep;
-  guint8          bulk_out_ep;
-};
--- a/libfprint/drivers/fpcmoc/fpc.c
+++ b/libfprint/drivers/fpcmoc/fpc.c
--- a/libfprint/drivers/fpcmoc/fpc.h
+++ b/libfprint/drivers/fpcmoc/fpc.h
@@ -1,221 +0,0 @@
-/*
- * Copyright (c) 2022 Fingerprint Cards AB <tech@fingerprints.com>
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#pragma once
-
-#include "fpi-device.h"
-#include "fpi-ssm.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-
-#define TEMPLATE_ID_SIZE (32)
-#define MAX_FW_VERSION_STR_LEN (16)
-#define FPC_CMD_INIT (0x01)
-#define FPC_CMD_ARM (0x02)
-#define FPC_CMD_ABORT (0x03)
-#define FPC_CMD_INDICATE_S_STATE (0x08)
-#define FPC_CMD_GET_IMG (0x09)
-#define FPC_CMD_GET_KPI (0x0C)
-#define FPC_CMD_LOAD_DB (0x60)
-#define FPC_CMD_STORE_DB (0x61)
-#define FPC_CMD_DELETE_DB (0x62)
-#define FPC_CMD_DELETE_TEMPLATE (0x63)
-#define FPC_CMD_BEGIN_ENROL (0x67)
-#define FPC_CMD_ENROL (0x68)
-#define FPC_CMD_END_ENROL (0x69)
-#define FPC_CMD_BIND_IDENTITY (0x6A)
-#define FPC_CMD_IDENTIFY (0x6B)
-#define FPC_CMD_ENUM (0x70)
-#define FPC_EVT_INIT_RESULT (0x02)
-#define FPC_EVT_FINGER_DWN (0x06)
-#define FPC_EVT_IMG (0x08)
-#define FPC_EVT_FID_DATA (0x31)
-#define FPC_DB_ID_LEN (16)
-#define FPC_IDENTITY_TYPE_WILDCARD (0x1)
-#define FPC_IDENTITY_TYPE_RESERVED (0x3)
-#define FPC_IDENTITY_WILDCARD (0x25066282)
-#define FPC_SUBTYPE_ANY (0xFF)
-#define FPC_SUBTYPE_RESERVED (0xF5)
-#define FPC_SUBTYPE_NOINFORMATION (0x00)
-#define FPC_CAPTUREID_RESERVED (0x701100F)
-#define FPC_SESSIONID_RESERVED (0x0077FF12)
-#define FPC_TEMPLATES_MAX (10)
-#define SECURITY_MAX_SID_SIZE (68)
-#define FPC_HOST_MS_S0 (0x10)
-#define FPC_HOST_MS_SX (0x11)
-
-G_DECLARE_FINAL_TYPE (FpiDeviceFpcMoc, fpi_device_fpcmoc, FPI,
-                      DEVICE_FPCMOC, FpDevice);
-
-typedef struct _FPC_FID_DATA
-{
-  guint32 identity_type;
-  guint32 reserved;
-  guint32 identity_size;
-  guint32 subfactor;
-  guint8  data[SECURITY_MAX_SID_SIZE];
-} FPC_FID_DATA, *PFPC_FID_DATA;
-
-typedef struct _FPC_LOAD_DB
-{
-  gint32  status;
-  guint32 reserved;
-  guint32 database_id_size;
-  guint8  data[FPC_DB_ID_LEN];
-} FPC_LOAD_DB, *PFPC_LOAD_DB;
-
-typedef union _FPC_DELETE_DB
-{
-  guint32 reserved;
-  guint32 database_id_size;
-  guint8  data[FPC_DB_ID_LEN];
-} FPC_DB_OP, *PFPC_DB_OP;
-
-typedef struct _FPC_BEGIN_ENROL
-{
-  gint32  status;
-  guint32 reserved1;
-  guint32 reserved2;
-} FPC_BEGIN_ENROL, *PFPC_BEGIN_ENROL;
-
-typedef struct _FPC_ENROL
-{
-  gint32  status;
-  guint32 remaining;
-} FPC_ENROL, *PFPC_ENROL;
-
-typedef struct _FPC_END_ENROL
-{
-  gint32  status;
-  guint32 fid;
-} FPC_END_ENROL, *PFPC_END_ENROL;
-
-typedef struct _FPC_IDENTIFY
-{
-  gint32  status;
-  guint32 identity_type;
-  guint32 identity_offset;
-  guint32 identity_size;
-  guint32 subfactor;
-  guint8  data[SECURITY_MAX_SID_SIZE];
-} FPC_IDENTIFY, *PFPC_IDENTIFY;
-
-typedef struct
-{
-  guint32 cmdid;
-  guint32 length;
-  guint32 status;
-} evt_hdr_t;
-
-typedef struct
-{
-  evt_hdr_t hdr;
-  guint16   sensor;
-  guint16   hw_id;
-  guint16   img_w;
-  guint16   img_h;
-  guint8    fw_version[MAX_FW_VERSION_STR_LEN];
-  guint16   fw_capabilities;
-} evt_initiated_t;
-
-typedef struct
-{
-  guint8  subfactor;
-  guint32 identity_type;
-  guint32 identity_size;
-  guint8  identity[SECURITY_MAX_SID_SIZE];
-} __attribute__((packed)) fpc_fid_data_t;
-
-typedef struct
-{
-  evt_hdr_t      hdr;
-  gint           status;
-  guint32        num_ids;
-  fpc_fid_data_t fid_data[FPC_TEMPLATES_MAX];
-} __attribute__((packed)) evt_enum_fids_t;
-
-typedef struct _fp_cmd_response
-{
-  union
-  {
-    evt_hdr_t       evt_hdr;
-    evt_initiated_t evt_inited;
-    evt_enum_fids_t evt_enum_fids;
-  };
-} fpc_cmd_response_t, *pfpc_cmd_response_t;
-
-enum {
-  FPC_ENROL_STATUS_COMPLETED = 0,
-  FPC_ENROL_STATUS_PROGRESS = 1,
-  FPC_ENROL_STATUS_FAILED_COULD_NOT_COMPLETE = 2,
-  FPC_ENROL_STATUS_FAILED_ALREADY_ENROLED = 3,
-  FPC_ENROL_STATUS_IMAGE_LOW_COVERAGE = 4,
-  FPC_ENROL_STATUS_IMAGE_TOO_SIMILAR = 5,
-  FPC_ENROL_STATUS_IMAGE_LOW_QUALITY = 6,
-};
-
-typedef enum {
-  FPC_CMDTYPE_UNKNOWN = 0,
-  FPC_CMDTYPE_TO_DEVICE,
-  FPC_CMDTYPE_TO_DEVICE_EVTDATA,
-  FPC_CMDTYPE_FROM_DEVICE,
-} FpcCmdType;
-
-typedef enum {
-  FP_CMD_SEND = 0,
-  FP_CMD_GET_DATA,
-  FP_CMD_SUSPENDED,
-  FP_CMD_RESUME,
-  FP_CMD_NUM_STATES,
-} FpCmdState;
-
-typedef enum {
-  FP_INIT = 0,
-  FP_LOAD_DB,
-  FP_INIT_NUM_STATES,
-} FpInitState;
-
-typedef enum {
-  FP_ENROLL_ENUM = 0,
-  FP_ENROLL_CREATE,
-  FP_ENROLL_CAPTURE,
-  FP_ENROLL_GET_IMG,
-  FP_ENROLL_UPDATE,
-  FP_ENROLL_COMPLETE,
-  FP_ENROLL_CHECK_DUPLICATE,
-  FP_ENROLL_BINDID,
-  FP_ENROLL_COMMIT,
-  FP_ENROLL_DICARD,
-  FP_ENROLL_CLEANUP,
-  FP_ENROLL_NUM_STATES,
-} FpEnrollState;
-
-typedef enum {
-  FP_VERIFY_CAPTURE = 0,
-  FP_VERIFY_GET_IMG,
-  FP_VERIFY_IDENTIFY,
-  FP_VERIFY_CANCEL,
-  FP_VERIFY_NUM_STATES,
-} FpVerifyState;
-
-typedef enum {
-  FP_CLEAR_DELETE_DB = 0,
-  FP_CLEAR_CREATE_DB,
-  FP_CLEAR_NUM_STATES,
-} FpClearState;
--- a/libfprint/drivers/goodixmoc/goodix.c
+++ b/libfprint/drivers/goodixmoc/goodix.c
@@ -128,13 +128,11 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
                   GError         *error)
 {
  FpiDeviceGoodixMoc *self = FPI_DEVICE_GOODIXMOC (device);
-  FpiByteReader reader = {0};
  CommandData *data = user_data;
-  int ssm_state = 0;
+  int ret = -1, 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)
@@ -156,10 +154,8 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
      return;
    }

-  reader.data = transfer->buffer;
-  reader.size = transfer->actual_length;
-
-  if (gx_proto_parse_header (&reader, &header) != 0)
+  ret = gx_proto_parse_header (transfer->buffer, transfer->actual_length, &header);
+  if (ret != 0)
    {
      fpi_ssm_mark_failed (transfer->ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
@@ -167,17 +163,8 @@ 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 (!fpi_byte_reader_get_uint32_le (&reader, &crc32) ||
-      crc32_calc != crc32)
+  if(crc32_calc != GUINT32_FROM_LE (*(uint32_t *) (transfer->buffer + PACKAGE_HEADER_SIZE + header.len)))
    {
      fpi_ssm_mark_failed (transfer->ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
@@ -187,11 +174,8 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,

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

-  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)
+  ret = gx_proto_parse_body (cmd, &transfer->buffer[PACKAGE_HEADER_SIZE], header.len, &cmd_reponse);
+  if (ret != 0)
    {
      fpi_ssm_mark_failed (transfer->ssm,
                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
@@ -647,20 +631,20 @@ fp_enroll_enum_cb (FpiDeviceGoodixMoc  *self,
      return;
    }

-  fpi_ssm_next_state (self->task_ssm);
+  fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
 }

 static void
-fp_enroll_create_cb (FpiDeviceGoodixMoc  *self,
-                     gxfp_cmd_response_t *resp,
-                     GError              *error)
+fp_enroll_init_cb (FpiDeviceGoodixMoc  *self,
+                   gxfp_cmd_response_t *resp,
+                   GError              *error)
 {
  if (error)
    {
      fpi_ssm_mark_failed (self->task_ssm, error);
      return;
    }
-  memcpy (self->template_id, resp->enroll_create.tid, TEMPLATE_ID_SIZE);
+  memcpy (self->template_id, resp->enroll_init.tid, TEMPLATE_ID_SIZE);
  fpi_ssm_next_state (self->task_ssm);
 }

@@ -677,7 +661,7 @@ fp_enroll_capture_cb (FpiDeviceGoodixMoc  *self,
  /* */
  if (resp->result >= GX_FAILED)
    {
-      fp_info ("Capture sample failed, result: 0x%x", resp->result);
+      fp_warn ("Capture sample failed, result: 0x%x", resp->result);
      fpi_device_enroll_progress (FP_DEVICE (self),
                                  self->enroll_stage,
                                  NULL,
@@ -691,7 +675,7 @@ fp_enroll_capture_cb (FpiDeviceGoodixMoc  *self,
  if ((resp->capture_data_resp.img_quality < self->sensorcfg->config[4]) ||
      (resp->capture_data_resp.img_coverage < self->sensorcfg->config[5]))
    {
-      fp_info ("Capture sample poor quality(%d): %d or coverage(%d): %d",
+      fp_warn ("Capture sample poor quality(%d): %d or coverage(%d): %d",
               self->sensorcfg->config[4],
               resp->capture_data_resp.img_quality,
               self->sensorcfg->config[5],
@@ -853,16 +837,6 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)

  switch (fpi_ssm_get_cur_state (ssm))
    {
-    case FP_ENROLL_PWR_BTN_SHIELD_ON:
-      {
-        goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_ON,
-                           false,
-                           NULL,
-                           0,
-                           fp_pwr_btn_shield_cb);
-      }
-      break;
-
    case FP_ENROLL_ENUM:
      {
        goodix_sensor_cmd (self, MOC_CMD0_GETFINGERLIST, MOC_CMD1_DEFAULT,
@@ -873,13 +847,23 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
      }
      break;

+    case FP_ENROLL_PWR_BTN_SHIELD_ON:
+      {
+        goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_ON,
+                           false,
+                           NULL,
+                           0,
+                           fp_pwr_btn_shield_cb);
+      }
+      break;
+
    case FP_ENROLL_CREATE:
      {
        goodix_sensor_cmd (self, MOC_CMD0_ENROLL_INIT, MOC_CMD1_DEFAULT,
                           false,
                           (const guint8 *) &dummy,
                           1,
-                           fp_enroll_create_cb);
+                           fp_enroll_init_cb);
      }
      break;

@@ -1057,47 +1041,6 @@ fp_init_config_cb (FpiDeviceGoodixMoc  *self,
  fpi_ssm_next_state (self->task_ssm);
 }

-static void
-fp_init_cb_reset_or_complete (FpiDeviceGoodixMoc  *self,
-                              gxfp_cmd_response_t *resp,
-                              GError              *error)
-{
-  if (error)
-    {
-      fp_warn ("Template storage appears to have been corrupted! Error was: %s", error->message);
-      fp_warn ("A known reason for this to happen is a firmware bug triggered by another storage area being initialized.");
-      fpi_ssm_jump_to_state (self->task_ssm, FP_INIT_RESET_DEVICE);
-    }
-  else
-    {
-      fpi_ssm_mark_completed (self->task_ssm);
-    }
-}
-
-static void
-fp_init_reset_device_cb (FpiDeviceGoodixMoc  *self,
-                         gxfp_cmd_response_t *resp,
-                         GError              *error)
-{
-  if (error)
-    {
-      fp_warn ("Reset failed: %s", error->message);
-      fpi_ssm_mark_failed (self->task_ssm, error);
-      return;
-    }
-  if ((resp->result >= GX_FAILED) && (resp->result != GX_ERROR_FINGER_ID_NOEXIST))
-    {
-      fp_warn ("Reset failed, device reported: 0x%x", resp->result);
-      fpi_ssm_mark_failed (self->task_ssm,
-                           fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
-                                                     "Failed clear storage, result: 0x%x",
-                                                     resp->result));
-      return;
-    }
-
-  fp_warn ("Reset completed");
-  fpi_ssm_mark_completed (self->task_ssm);
-}

 static void
 fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
@@ -1122,30 +1065,6 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
                         sizeof (gxfp_sensor_cfg_t),
                         fp_init_config_cb);
      break;
-
-    case FP_INIT_TEMPLATE_LIST:
-      /* List prints to check whether the template DB was corrupted.
-       * As of 2022-06-13 there is a known firmware issue that can cause the
-       * stored templates for Linux to be corrupted when the Windows storage
-       * area is initialized.
-       * In that case, we'll get a protocol failure trying to retrieve the
-       * list of prints.
-       */
-      goodix_sensor_cmd (self, MOC_CMD0_GETFINGERLIST, MOC_CMD1_DEFAULT,
-                         FALSE,
-                         (const guint8 *) &dummy,
-                         1,
-                         fp_init_cb_reset_or_complete);
-      break;
-
-    case FP_INIT_RESET_DEVICE:
-      fp_warn ("Resetting device storage, you will need to enroll all prints again!");
-      goodix_sensor_cmd (self, MOC_CMD0_DELETETEMPLATE, MOC_CMD1_DELETE_ALL,
-                         FALSE,
-                         NULL,
-                         0,
-                         fp_init_reset_device_cb);
-      break;
    }


@@ -1375,28 +1294,12 @@ gx_fp_probe (FpDevice *device)
    {
    case 0x6496:
    case 0x60A2:
-    case 0x60A4:
-    case 0x6014:
-    case 0x6092:
-    case 0x6094:
-    case 0x609A:
    case 0x609C:
-    case 0x60BC:
-    case 0x60C2:
-    case 0x6304:
-    case 0x631C:
-    case 0x633C:
-    case 0x634C:
-    case 0x6384:
    case 0x639C:
    case 0x63AC:
    case 0x63BC:
    case 0x63CC:
-    case 0x650A:
-    case 0x650C:
-    case 0x6582:
    case 0x6A94:
-    case 0x659A:
      self->max_enroll_stage = 12;
      break;

@@ -1483,7 +1386,9 @@ gx_fp_exit_cb (FpiDeviceGoodixMoc  *self,
               gxfp_cmd_response_t *resp,
               GError              *error)
 {
-  if (resp && resp->result >= GX_FAILED)
+
+
+  if (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);
@@ -1625,37 +1530,19 @@ fpi_device_goodixmoc_init (FpiDeviceGoodixMoc *self)

 static const FpIdEntry id_table[] = {
  { .vid = 0x27c6,  .pid = 0x5840,  },
-  { .vid = 0x27c6,  .pid = 0x6014,  },
-  { .vid = 0x27c6,  .pid = 0x6092,  },
-  { .vid = 0x27c6,  .pid = 0x6094,  },
-  { .vid = 0x27c6,  .pid = 0x609A,  },
  { .vid = 0x27c6,  .pid = 0x609C,  },
  { .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,  },
-  { .vid = 0x27c6,  .pid = 0x634C,  },
-  { .vid = 0x27c6,  .pid = 0x6384,  },
  { .vid = 0x27c6,  .pid = 0x639C,  },
  { .vid = 0x27c6,  .pid = 0x63AC,  },
  { .vid = 0x27c6,  .pid = 0x63BC,  },
  { .vid = 0x27c6,  .pid = 0x63CC,  },
  { .vid = 0x27c6,  .pid = 0x6496,  },
-  { .vid = 0x27c6,  .pid = 0x650A,  },
-  { .vid = 0x27c6,  .pid = 0x650C,  },
-  { .vid = 0x27c6,  .pid = 0x6582,  },
  { .vid = 0x27c6,  .pid = 0x6584,  },
  { .vid = 0x27c6,  .pid = 0x658C,  },
  { .vid = 0x27c6,  .pid = 0x6592,  },
  { .vid = 0x27c6,  .pid = 0x6594,  },
-  { .vid = 0x27c6,  .pid = 0x659A,  },
  { .vid = 0x27c6,  .pid = 0x659C,  },
  { .vid = 0x27c6,  .pid = 0x6A94,  },
-  { .vid = 0x27c6,  .pid = 0x6512,  },
-  { .vid = 0x27c6,  .pid = 0x689A,  },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };

--- a/libfprint/drivers/goodixmoc/goodix.h
+++ b/libfprint/drivers/goodixmoc/goodix.h
@@ -35,8 +35,6 @@ typedef enum {
 typedef enum {
  FP_INIT_VERSION = 0,
  FP_INIT_CONFIG,
-  FP_INIT_TEMPLATE_LIST,
-  FP_INIT_RESET_DEVICE,
  FP_INIT_NUM_STATES,
 } FpInitState;

@@ -44,6 +42,7 @@ typedef enum {
 typedef enum {
  FP_ENROLL_PWR_BTN_SHIELD_ON = 0,
  FP_ENROLL_ENUM,
+  FP_ENROLL_IDENTIFY,
  FP_ENROLL_CREATE,
  FP_ENROLL_CAPTURE,
  FP_ENROLL_UPDATE,
--- a/libfprint/drivers/goodixmoc/goodix_proto.c
+++ b/libfprint/drivers/goodixmoc/goodix_proto.c
@@ -18,8 +18,6 @@
 */

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

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

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

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

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

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


 int
-gx_proto_parse_header (FpiByteReader *reader,
-                       pack_header   *pheader)
+gx_proto_parse_header (
+  uint8_t     *buffer,
+  uint32_t     buffer_len,
+  pack_header *pheader)
 {
-  if (!pheader)
+  if (!buffer || !pheader)
+    return -1;
+  if (buffer_len < PACKAGE_HEADER_SIZE + PACKAGE_CRC_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);
-
+  memcpy (pheader, buffer, sizeof (pack_header));
+  pheader->len = GUINT16_FROM_LE (pheader->len);
+  if (buffer_len < pheader->len + PACKAGE_HEADER_SIZE)
+    return -1;
  pheader->len -= PACKAGE_CRC_SIZE;
-
  return 0;
 }

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

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

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

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

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

-  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);
+  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);

  return 0;
 }

 int
-gx_proto_parse_body (uint16_t cmd, FpiByteReader *byte_reader, pgxfp_cmd_response_t presp)
+gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_cmd_response_t presp)
 {
-  if (!presp)
+  uint16_t offset = 0;
+  uint8_t *fingerlist = NULL;
+
+  if (!buffer || !presp)
    return -1;
-
-  if (!fpi_byte_reader_get_uint8 (byte_reader, &presp->result))
-    g_return_val_if_reached (-1);
-
+  if (buffer_len < 1)
+    return -1;
+  presp->result = buffer[0];
  switch (HIBYTE (cmd))
    {
    case RESPONSE_PACKAGE_CMD:
      {
-        if (!fpi_byte_reader_get_uint8 (byte_reader, &presp->parse_msg.ack_cmd))
-          g_return_val_if_reached (-1);
+        if (buffer_len < sizeof (gxfp_parse_msg_t) + 1)
+          return -1;
+        presp->parse_msg.ack_cmd = buffer[1];
      }
      break;

    case MOC_CMD0_UPDATE_CONFIG:
      {
-        presp->finger_config.status = presp->result;
-        /* to compatiable old version firmware */
-        presp->finger_config.max_stored_prints = FP_MAX_FINGERNUM;
+        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;

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

@@ -338,99 +318,87 @@ gx_proto_parse_body (uint16_t cmd, FpiByteReader *byte_reader, pgxfp_cmd_respons

    case MOC_CMD0_PWR_BTN_SHIELD:
      presp->power_button_shield_resp.resp_cmd1 = LOBYTE (cmd);
-      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");
+      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");
+        }
      break;

    case MOC_CMD0_GET_VERSION:
-      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));
+      if (buffer_len < sizeof (gxfp_version_info_t) + 1)
+        return -1;
+      memcpy (&presp->version_info, buffer + 1, sizeof (gxfp_version_info_t));
      break;

    case MOC_CMD0_CAPTURE_DATA:
      if (LOBYTE (cmd) == MOC_CMD1_DEFAULT)
        {
-          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);
+          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];
        }
      break;

    case MOC_CMD0_ENROLL_INIT:
-      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);
+      if (buffer_len < sizeof (gxfp_enroll_init_t) + 1)
+        return -1;
+      if (presp->result == GX_SUCCESS)
+        memcpy (&presp->enroll_init.tid, &buffer[1], TEMPLATE_ID_SIZE);
      break;

    case MOC_CMD0_ENROLL:
-      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);
+      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];
      break;

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

-          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);
+          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;
        }
      break;

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

@@ -439,32 +407,23 @@ gx_proto_parse_body (uint16_t cmd, FpiByteReader *byte_reader, pgxfp_cmd_respons
        uint32_t score = 0;
        uint8_t study = 0;
        uint16_t fingerid_size = 0;
-
-        presp->verify.match = (presp->result == 0) ? true : false;
-
+        presp->verify.match = (buffer[0] == 0) ? true : false;
        if (presp->verify.match)
          {
-            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)
+            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)
              {
                presp->result = GX_FAILED;
                break;
@@ -475,7 +434,7 @@ gx_proto_parse_body (uint16_t cmd, FpiByteReader *byte_reader, pgxfp_cmd_respons
      break;

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

    default:
@@ -508,4 +467,4 @@ gx_proto_init_sensor_config (pgxfp_sensor_cfg_t pconfig)
  memcpy (pconfig->crc_value, &crc32_calc, PACKAGE_CRC_SIZE);

  return 0;
-}
+}
--- a/libfprint/drivers/goodixmoc/goodix_proto.h
+++ b/libfprint/drivers/goodixmoc/goodix_proto.h
@@ -22,8 +22,6 @@
 #include <stdbool.h>
 #include <string.h>

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

@@ -107,10 +105,10 @@ typedef struct _gxfp_parse_msg
 } gxfp_parse_msg_t, *pgxfp_parse_msg_t;


-typedef struct _gxfp_enroll_create
+typedef struct _gxfp_enroll_init
 {
  uint8_t tid[TEMPLATE_ID_SIZE];
-} gxfp_enroll_create_t, *pgxfp_enroll_create_t;
+} gxfp_enroll_init_t, *pgxfp_enroll_init_t;

 #pragma pack(push, 1)
 typedef struct _template_format
@@ -135,7 +133,7 @@ typedef struct _template_format
 typedef struct _gxfp_verify
 {
  bool     match;
-  uint16_t rejectdetail;
+  uint32_t rejectdetail;
  template_format_t  template;
 } gxfp_verify_t, *pgxfp_verify_t;

@@ -194,7 +192,7 @@ typedef struct _fp_cmd_response
  {
    gxfp_parse_msg_t       parse_msg;
    gxfp_verify_t          verify;
-    gxfp_enroll_create_t   enroll_create;
+    gxfp_enroll_init_t     enroll_init;
    gxfp_capturedata_t     capture_data_resp;
    gxfp_check_duplicate_t check_duplicate_resp;
    gxfp_enroll_commit_t   enroll_commit;
@@ -234,11 +232,13 @@ int gx_proto_build_package (uint8_t       *ppackage,
                            const uint8_t *payload,
                            uint32_t       payload_size);

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

 int gx_proto_parse_body (uint16_t             cmd,
-                         FpiByteReader       *byte_reader,
+                         uint8_t             *buffer,
+                         uint16_t             buffer_len,
                         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
--- a/libfprint/drivers/realtek/realtek.h
+++ b/libfprint/drivers/realtek/realtek.h
@@ -1,246 +0,0 @@
-/*
- * Copyright (C) 2022-2023 Realtek Corp.
- *
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation; either
- * version 2.1 of the License, or (at your option) any later version.
- *
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-#pragma once
-
-#include "fpi-device.h"
-#include "fpi-ssm.h"
-
-#include <stdio.h>
-#include <stdlib.h>
-#include <stdint.h>
-
-#define EP_IN (2 | FPI_USB_ENDPOINT_IN)
-#define EP_OUT (1 | FPI_USB_ENDPOINT_OUT)
-
-#define EP_IN_MAX_BUF_SIZE 2048
-
-#define FP_RTK_CMD_BULK_TOTAL_LEN 12
-#define FP_RTK_CMD_BULK_LEN 2
-#define FP_RTK_CMD_BULK_PARAM_LEN 4
-#define FP_RTK_CMD_BULK_ADDR_LEN 4
-#define FP_RTK_CMD_BULK_DATA_LEN 2
-
-#define TEMPLATE_LEN_COMMON 35
-
-#define SUBFACTOR_OFFSET 2
-#define UID_OFFSET 3
-#define UID_PAYLOAD_LEN_DEFAULT 32
-
-/* Command transfer timeout :ms*/
-#define CMD_TIMEOUT 1000
-#define DATA_TIMEOUT 5000
-#define STATUS_TIMEOUT 2000
-
-#define MAX_ENROLL_SAMPLES 8
-#define DEFAULT_UID_LEN 28
-#define SUB_FINGER_01 0xFF
-
-#define GET_BULK_CMD_TYPE(val)              ((val & 0xC0) >> 6)
-#define GET_TRANS_DATA_LEN(len_h, len_l)    ((len_h << 8) | len_l)
-#define GET_LEN_L(total_data_len)           ((total_data_len) & 0xff)
-#define GET_LEN_H(total_data_len)           ((total_data_len) >> 8)
-
-G_DECLARE_FINAL_TYPE (FpiDeviceRealtek, fpi_device_realtek, FPI, DEVICE_REALTEK, FpDevice)
-
-typedef void (*SynCmdMsgCallback) (FpiDeviceRealtek *self,
-                                   uint8_t          *buffer_in,
-                                   GError           *error);
-
-typedef struct
-{
-  SynCmdMsgCallback callback;
-} CommandData;
-
-typedef enum {
-  FP_RTK_CMD_BULK_ONLY = 0,
-  FP_RTK_CMD_BULK_READ,
-  FP_RTK_CMD_BULK_WRITE,
-} FpRtkCmdType;
-
-typedef enum {
-  FP_RTK_MSG_DEFAULT = 0,
-  FP_RTK_MSG_NO_STATUS,
-} FpRtkMsgType;
-
-typedef enum {
-  FP_RTK_PURPOSE_VERIFY   = 0x01,
-  FP_RTK_PURPOSE_IDENTIFY = 0x02,
-  FP_RTK_PURPOSE_ENROLL   = 0x04,
-} FpRtkPurpose;
-
-typedef enum {
-  FP_RTK_SUCCESS = 0x0,
-  FP_RTK_TOO_HIGH,
-  FP_RTK_TOO_LOW,
-  FP_RTK_TOO_LEFT,
-  FP_RTK_TOO_RIGHT,
-  FP_RTK_TOO_FAST,
-  FP_RTK_TOO_SLOW,
-  FP_RTK_POOR_QUALITY,
-  FP_RTK_TOO_SKEWED,
-  FP_RTK_TOO_SHORT,
-  FP_RTK_MERGE_FAILURE,
-  FP_RTK_MATCH_FAIL,
-  FP_RTK_CMD_ERR,
-} FpRtkInStatus;
-
-typedef enum {
-  FP_RTK_ENROLL_GET_TEMPLATE = 0,
-  FP_RTK_ENROLL_BEGIN_POS,
-  FP_RTK_ENROLL_CAPTURE,
-  FP_RTK_ENROLL_FINISH_CAPTURE,
-  FP_RTK_ENROLL_ACCEPT_SAMPLE,
-  FP_RTK_ENROLL_CHECK_DUPLICATE,
-  FP_RTK_ENROLL_COMMIT,
-  FP_RTK_ENROLL_CANCEL_CAPTURE,
-  FP_RTK_ENROLL_NUM_STATES,
-} FpRtkEnrollState;
-
-typedef enum {
-  FP_RTK_VERIFY_GET_TEMPLATE = 0,
-  FP_RTK_VERIFY_CAPTURE,
-  FP_RTK_VERIFY_FINISH_CAPTURE,
-  FP_RTK_VERIFY_ACCEPT_SAMPLE,
-  FP_RTK_VERIFY_INDENTIFY_FEATURE,
-  FP_RTK_VERIFY_UPDATE_TEMPLATE,
-  FP_RTK_VERIFY_CANCEL_CAPTURE,
-  FP_RTK_VERIFY_NUM_STATES,
-} FpRtkVerifyState;
-
-typedef enum {
-  FP_RTK_DELETE_GET_POS = 0,
-  FP_RTK_DELETE_PRINT,
-  FP_RTK_DELETE_NUM_STATES,
-} FpRtkDeleteState;
-
-typedef enum {
-  FP_RTK_INIT_GET_DEVICE_INFO = 0,
-  FP_RTK_INIT_SELECT_OS,
-  FP_RTK_INIT_GET_ENROLL_NUM,
-  FP_RTK_INIT_NUM_STATES,
-} FpRtkInitState;
-
-typedef enum {
-  FP_RTK_CMD_SEND = 0,
-  FP_RTK_CMD_TRANS_DATA,
-  FP_RTK_CMD_GET_STATUS,
-  FP_RTK_CMD_NUM_STATES,
-} FpRtkCmdState;
-
-struct _FpiDeviceRealtek
-{
-  FpDevice        parent;
-  FpiSsm         *task_ssm;
-  FpiSsm         *cmd_ssm;
-  FpiUsbTransfer *cmd_transfer;
-  FpiUsbTransfer *data_transfer;
-  gint            cmd_type;
-  FpRtkMsgType    message_type;
-  gboolean        cmd_cancellable;
-  gint            enroll_stage;
-  gint            max_enroll_stage;
-  guchar         *read_data;
-  gsize           trans_data_len;
-  FpRtkPurpose    fp_purpose;
-  gint            pos_index;
-  gint            template_num;
-  gint            template_len;
-};
-
-struct rtk_cmd_bulk
-{
-  uint8_t cmd[FP_RTK_CMD_BULK_LEN];
-  uint8_t param[FP_RTK_CMD_BULK_PARAM_LEN];
-  uint8_t addr[FP_RTK_CMD_BULK_ADDR_LEN];
-  uint8_t data_len[FP_RTK_CMD_BULK_DATA_LEN];
-};
-
-struct rtk_cmd_ctrl
-{
-  int      direction;
-  uint8_t  request;
-  uint16_t value;
-  uint16_t index;
-  uint16_t len;
-};
-
-static struct rtk_cmd_ctrl get_device_info = {
-  .direction = G_USB_DEVICE_DIRECTION_DEVICE_TO_HOST,
-  .request = 0x07,
-  .value = 0x000D,
-  .index = 0x0000,
-  .len = 0x0008,
-};
-
-static struct rtk_cmd_bulk co_start_capture = {
-  .cmd = {0x05, 0x05},
-};
-
-static struct rtk_cmd_bulk co_finish_capture = {
-  .cmd = {0x45, 0x06},
-  .data_len = {0x05},
-};
-
-static struct rtk_cmd_bulk co_accept_sample = {
-  .cmd = {0x45, 0x08},
-  .data_len = {0x09},
-};
-
-static struct rtk_cmd_bulk nor_identify_feature = {
-  .cmd = {0x45, 0x22},
-  .data_len = {0x2A},
-};
-
-static struct rtk_cmd_bulk co_get_enroll_num = {
-  .cmd = {0x45, 0x0d},
-  .data_len = {0x02},
-};
-
-static struct rtk_cmd_bulk co_get_template = {
-  .cmd = {0x45, 0x0E},
-};
-
-static struct rtk_cmd_bulk nor_enroll_begin = {
-  .cmd = {0x05, 0x20},
-};
-
-static struct rtk_cmd_bulk co_check_duplicate = {
-  .cmd = {0x45, 0x10},
-  .data_len = {0x22},
-};
-
-static struct rtk_cmd_bulk nor_enroll_commit = {
-  .cmd = {0x85, 0x21},
-};
-
-static struct rtk_cmd_bulk co_update_template = {
-  .cmd = {0x05, 0x11},
-};
-
-static struct rtk_cmd_bulk co_delete_record = {
-  .cmd = {0x05, 0x0F},
-};
-
-static struct rtk_cmd_bulk co_select_system = {
-  .cmd = {0x05, 0x13},
-};
-
-static struct rtk_cmd_bulk co_cancel_capture = {
-  .cmd = {0x05, 0x07},
-};
--- a/libfprint/drivers/synaptics/bmkt_message.c
+++ b/libfprint/drivers/synaptics/bmkt_message.c
@@ -256,8 +256,7 @@ 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;
-  if (payload_size > 0)
-    memcpy (&cmd[BMKT_MESSAGE_PAYLOAD_FIELD], payload, payload_size);
+  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,32 +32,17 @@ 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 = 0x00C2,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C4,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C6,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00DF,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F0,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F9,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00FC,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C2,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0100,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F0,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0103,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 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 = 0x015F,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0168,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x016C,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0173,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0174,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x019D,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x019F,  },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };

@@ -119,11 +104,7 @@ cmd_receive_cb (FpiUsbTransfer *transfer,

          if (self->cmd_complete_on_removal)
            {
-              if (self->delay_error)
-                fpi_ssm_mark_failed (transfer->ssm,
-                                     g_steal_pointer (&self->delay_error));
-              else
-                fpi_ssm_mark_completed (transfer->ssm);
+              fpi_ssm_mark_completed (transfer->ssm);
              return;
            }
        }
@@ -658,21 +639,18 @@ verify (FpDevice *device)
 }

 static void
-identify_complete_after_finger_removal (FpiDeviceSynaptics *self, GError *error)
+identify_complete_after_finger_removal (FpiDeviceSynaptics *self)
 {
  FpDevice *device = FP_DEVICE (self);

  if (self->finger_on_sensor)
    {
      fp_dbg ("delaying identify report until after finger removal!");
-      if (error)
-        g_propagate_error (&self->delay_error, error);
-
      self->cmd_complete_on_removal = TRUE;
    }
  else
    {
-      fpi_device_identify_complete (device, error);
+      fpi_device_identify_complete (device, NULL);
    }
 }

@@ -722,18 +700,19 @@ identify_msg_cb (FpiDeviceSynaptics *self,
          fp_info ("Match error occurred");
          fpi_device_identify_report (device, NULL, NULL,
                                      fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL));
-          identify_complete_after_finger_removal (self, NULL);
+          identify_complete_after_finger_removal (self);
        }
      else if (resp->result == BMKT_FP_NO_MATCH)
        {
          fp_info ("Print didn't match");
          fpi_device_identify_report (device, NULL, NULL, NULL);
-          identify_complete_after_finger_removal (self, NULL);
+          identify_complete_after_finger_removal (self);
        }
-      else if (resp->result == BMKT_FP_DATABASE_NO_RECORD_EXISTS || resp->result == BMKT_FP_DATABASE_EMPTY)
+      else if (resp->result == BMKT_FP_DATABASE_NO_RECORD_EXISTS)
        {
          fp_info ("Print is not in database");
-          identify_complete_after_finger_removal (self, fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
+          fpi_device_identify_complete (device,
+                                        fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
        }
      else
        {
@@ -769,7 +748,7 @@ identify_msg_cb (FpiDeviceSynaptics *self,
        else
          fpi_device_identify_report (device, NULL, print, NULL);

-        identify_complete_after_finger_removal (self, NULL);
+        identify_complete_after_finger_removal (self);
      }
    }
 }
@@ -1257,12 +1236,6 @@ 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/synaptics/synaptics.h
+++ b/libfprint/drivers/synaptics/synaptics.h
@@ -127,5 +127,4 @@ struct _FpiDeviceSynaptics

  struct syna_enroll_resp_data enroll_resp_data;
  syna_state_t                 state;
-  GError                      *delay_error;
 };
--- a/libfprint/drivers/upeksonly.c
+++ b/libfprint/drivers/upeksonly.c
@@ -74,26 +74,26 @@ struct _FpiDeviceUpeksonly
  FpiSsm       *loopsm;

  /* Do we really need multiple concurrent transfers? */
-  GCancellable  *img_cancellable;
-  GPtrArray     *img_transfers;
-  int            num_flying;
+  GCancellable                    *img_cancellable;
+  GPtrArray                       *img_transfers;
+  int                              num_flying;

-  GSList        *rows;
-  unsigned       num_rows;
-  unsigned char *rowbuf;
-  int            rowbuf_offset;
+  GSList                          *rows;
+  unsigned                         num_rows;
+  unsigned char                   *rowbuf;
+  int                              rowbuf_offset;

-  int            wraparounds;
-  int            num_blank;
-  int            num_nonblank;
-  enum sonly_fs finger_state;
-  int            last_seqnum;
+  int                              wraparounds;
+  int                              num_blank;
+  int                              num_nonblank;
+  enum sonly_fs                    finger_state;
+  int                              last_seqnum;

  enum sonly_kill_transfers_action killing_transfers;
-  GError                   *kill_error;
-  FpiSsm                   *kill_ssm;
+  GError                          *kill_error;
+  FpiSsm                          *kill_ssm;

-  struct fpi_line_asmbl_ctx assembling_ctx;
+  struct fpi_line_asmbl_ctx        assembling_ctx;
 };
 G_DECLARE_FINAL_TYPE (FpiDeviceUpeksonly, fpi_device_upeksonly, FPI,
                      DEVICE_UPEKSONLY, FpImageDevice);
--- a/libfprint/drivers/upektc.c
+++ b/libfprint/drivers/upektc.c
@@ -431,7 +431,6 @@ dev_deinit (FpImageDevice *dev)

 static const FpIdEntry id_table[] = {
  { .vid = 0x0483,  .pid = 0x2015, .driver_data = UPEKTC_2015 },
-  { .vid = 0x0483,  .pid = 0x2017, .driver_data = UPEKTC_2015 },
  { .vid = 0x147e,  .pid = 0x3001, .driver_data = UPEKTC_3001 },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },
 };
--- a/libfprint/drivers/upektc_img.c
+++ b/libfprint/drivers/upektc_img.c
@@ -31,6 +31,10 @@ static void start_deactivation (FpImageDevice *dev);
 #define CTRL_TIMEOUT 4000
 #define BULK_TIMEOUT 4000

+#define IMAGE_WIDTH 144
+#define IMAGE_HEIGHT 384
+#define IMAGE_SIZE (IMAGE_WIDTH * IMAGE_HEIGHT)
+
 #define MAX_CMD_SIZE 64
 #define MAX_RESPONSE_SIZE 2052
 #define SHORT_RESPONSE_SIZE 64
@@ -43,10 +47,8 @@ struct _FpiDeviceUpektcImg
  unsigned char  response[MAX_RESPONSE_SIZE];
  unsigned char *image_bits;
  unsigned char  seq;
-  size_t         expected_image_size;
  size_t         image_size;
  size_t         response_rest;
-  gboolean       area_sensor;
  gboolean       deactivating;
 };
 G_DECLARE_FINAL_TYPE (FpiDeviceUpektcImg, fpi_device_upektc_img, FPI,
@@ -178,7 +180,6 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
                      gpointer user_data, GError *error)
 {
  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
-  FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_GET_CLASS (dev);
  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
  unsigned char *data = self->response;
  FpImage *img;
@@ -246,30 +247,8 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
                                     CAPTURE_ACK_00_28);
              break;

-            case 0x13:
-              /* finger is present keep your finger on reader */
-              fpi_device_report_finger_status_changes (device,
-                                                       FP_FINGER_STATUS_NEEDED,
-                                                       FP_FINGER_STATUS_NONE);
-              fpi_ssm_jump_to_state (transfer->ssm,
-                                     self->area_sensor ?
-                                     CAPTURE_ACK_00_28 : CAPTURE_ACK_00_28_TERM);
-              break;
-
            case 0x00:
              /* finger is present! */
-              fpi_device_report_finger_status_changes (device,
-                                                       FP_FINGER_STATUS_PRESENT,
-                                                       FP_FINGER_STATUS_NONE);
-              fpi_ssm_jump_to_state (transfer->ssm,
-                                     CAPTURE_ACK_00_28);
-              break;
-
-            case 0x01:
-              /* no finger! */
-              fpi_device_report_finger_status_changes (device,
-                                                       FP_FINGER_STATUS_NONE,
-                                                       FP_FINGER_STATUS_PRESENT);
              fpi_ssm_jump_to_state (transfer->ssm,
                                     CAPTURE_ACK_00_28);
              break;
@@ -282,20 +261,18 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
              fpi_image_device_report_finger_status (dev,
                                                     FALSE);
              fpi_ssm_jump_to_state (transfer->ssm,
-                                     self->area_sensor ?
-                                     CAPTURE_ACK_00_28 : CAPTURE_ACK_00_28_TERM);
+                                     CAPTURE_ACK_00_28_TERM);
              break;

            case 0x1d:
-              /* too much horizontal movement */
-              fp_err ("too much horizontal movement, aborting");
+              /* too much horisontal movement */
+              fp_err ("too much horisontal movement, aborting");
              fpi_image_device_retry_scan (dev,
                                           FP_DEVICE_RETRY_CENTER_FINGER);
              fpi_image_device_report_finger_status (dev,
                                                     FALSE);
              fpi_ssm_jump_to_state (transfer->ssm,
-                                     self->area_sensor ?
-                                     CAPTURE_ACK_00_28 : CAPTURE_ACK_00_28_TERM);
+                                     CAPTURE_ACK_00_28_TERM);
              break;

            default:
@@ -306,8 +283,7 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
              fpi_image_device_report_finger_status (dev,
                                                     FALSE);
              fpi_ssm_jump_to_state (transfer->ssm,
-                                     self->area_sensor ?
-                                     CAPTURE_ACK_00_28 : CAPTURE_ACK_00_28_TERM);
+                                     CAPTURE_ACK_00_28_TERM);
              break;
            }
          break;
@@ -331,13 +307,13 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
          self->image_size +=
            upektc_img_process_image_frame (self->image_bits + self->image_size,
                                            data);
-          BUG_ON (self->image_size != self->expected_image_size);
+          BUG_ON (self->image_size != IMAGE_SIZE);
          fp_dbg ("Image size is %lu",
                  (gulong) self->image_size);
-          img = fp_image_new (img_class->img_width, img_class->img_height);
+          img = fp_image_new (IMAGE_WIDTH, IMAGE_HEIGHT);
          img->flags |= FPI_IMAGE_PARTIAL;
          memcpy (img->data, self->image_bits,
-                  self->image_size);
+                  IMAGE_SIZE);
          fpi_image_device_image_captured (dev, img);
          fpi_image_device_report_finger_status (dev,
                                                 FALSE);
@@ -370,12 +346,8 @@ capture_run_state (FpiSsm *ssm, FpDevice *_dev)
  switch (fpi_ssm_get_cur_state (ssm))
    {
    case CAPTURE_INIT_CAPTURE:
-      if (self->area_sensor)
-        upektc_img_submit_req (ssm, dev, upek2020_init_capture_press, sizeof (upek2020_init_capture_press),
-                               self->seq, capture_reqs_cb);
-      else
-        upektc_img_submit_req (ssm, dev, upek2020_init_capture, sizeof (upek2020_init_capture),
-                               self->seq, capture_reqs_cb);
+      upektc_img_submit_req (ssm, dev, upek2020_init_capture, sizeof (upek2020_init_capture),
+                             self->seq, capture_reqs_cb);
      self->seq++;
      break;

@@ -541,81 +513,15 @@ init_reqs_cb (FpiUsbTransfer *transfer, FpDevice *device,
    fpi_ssm_mark_failed (transfer->ssm, error);
 }

+/* TODO: process response properly */
 static void
 init_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
                   gpointer user_data, GError *error)
 {
-  FpImageDevice *dev = FP_IMAGE_DEVICE (device);
-  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
-  unsigned char *data = self->response;
-
-  if (error)
-    {
-      fpi_ssm_mark_failed (transfer->ssm, error);
-      return;
-    }
-
-  if (data[12] == 0x06 && data[13] == 0x14)  /* if get_info */
-    {
-      FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_GET_CLASS (dev);
-      uint16_t width = (data[51] << 8) | data[50];
-      uint16_t height = (data[53] << 8) | data[52];
-
-      self->area_sensor = !(data[49] & 0x80);
-
-      switch (width)
-        {
-        case 256:
-          fp_dbg ("Sensor type : TCS1x, width x height: %hu x %hu", width, height); /* 360x256 --- 270x192 must be set */
-          BUG_ON (height != 360);
-          img_class->img_width = 192;
-          img_class->img_height = 270;
-          break;
-
-        case 208:
-          fp_dbg ("Sensor type : TCS2, width x height: %hu x %hu", width, height); /* 288x208 --- 216x156 must be set */
-          BUG_ON (height != 288);
-          img_class->img_width = 156;
-          img_class->img_height = 216;
-          break;
-
-        case 248:
-          fp_dbg ("Sensor type : TCS3, width x height: %hu x %hu", width, height); /* 360x248 --- 270x186 must be set */
-          BUG_ON (height != 360);
-          img_class->img_width = 186;
-          img_class->img_height = 270;
-          break;
-
-        case 192:
-          fp_dbg ("Sensor type : TCS4x, width x height: %hu x %hu", width, height); /* 512x192 --- 384x144 must be set */
-          BUG_ON (height != 512);
-          img_class->img_width = 144;
-          img_class->img_height = 384;
-          break;
-
-        case 144:
-          fp_dbg ("Sensor type : TCS5x, width x height: %hu x %hu", width, height); /* 512x144 --- 384x108 must be set */
-          BUG_ON (height != 512);
-          img_class->img_width = 108;
-          img_class->img_height = 384;
-          break;
-
-        default:
-          fp_dbg ("Sensor type : Unknown");
-
-          fpi_ssm_mark_failed (transfer->ssm,
-                               fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                                         "Unknown sensor type (reported size %dx%d)",
-                                                         width, height));
-
-          return;
-        }
-
-      self->expected_image_size = img_class->img_width * img_class->img_height;
-      self->image_bits = g_malloc0 (self->expected_image_size * 2);
-    }
-
-  fpi_ssm_next_state (transfer->ssm);
+  if (!error)
+    fpi_ssm_next_state (transfer->ssm);
+  else
+    fpi_ssm_mark_failed (transfer->ssm, error);
 }

 static void
@@ -710,6 +616,7 @@ dev_deactivate (FpImageDevice *dev)
 static void
 dev_init (FpImageDevice *dev)
 {
+  FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
  GError *error = NULL;

  /* TODO check that device has endpoints we're using */
@@ -720,6 +627,7 @@ dev_init (FpImageDevice *dev)
      return;
    }

+  self->image_bits = g_malloc0 (IMAGE_SIZE * 2);
  fpi_image_device_open_complete (dev, NULL);
 }

@@ -779,6 +687,6 @@ fpi_device_upektc_img_class_init (FpiDeviceUpektcImgClass *klass)

  img_class->bz3_threshold = 20;

-  img_class->img_width = -1;
-  img_class->img_height = -1;
+  img_class->img_width = IMAGE_WIDTH;
+  img_class->img_height = IMAGE_HEIGHT;
 }
--- a/libfprint/drivers/upektc_img.h
+++ b/libfprint/drivers/upektc_img.h
@@ -75,22 +75,6 @@ static const unsigned char upek2020_init_capture[] = {
  0x02,
  0x00, /* Wait for acceptable finger */
  0x02,
-  0x25, 0xa9 /* CRC */
-};
-
-static const unsigned char upek2020_init_capture_press[] = {
-  'C', 'i', 'a', 'o',
-  0x00,
-  0x00, 0x0e, /* Seq = 7, len = 0x00e */
-  0x28, /* CMD = 0x28 */
-  0x0b, 0x00, /* Inner len = 0x000b */
-  0x00, 0x00,
-  0x0e, /* SUBCMD = 0x0e */
-  0x02,
-  0xfe, 0xff, 0xff, 0xff, /* timeout = -2 = 0xfffffffe = infinite time */
-  0x02,
-  0x01, /* Wait for finger */
-  0x02,
  0x14, 0x9a /* CRC */
 };

--- a/libfprint/drivers/upekts.c
+++ b/libfprint/drivers/upekts.c
@@ -196,9 +196,8 @@ 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,
@@ -1244,7 +1243,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;
@@ -1296,7 +1295,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, msg, msg_len);
+      transfer = alloc_send_cmd28_transfer (dev, 0x03, data, data_len);

      g_free (msg);

@@ -1342,6 +1341,7 @@ 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,14 +1351,6 @@ 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;
@@ -1447,7 +1439,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 had wrong command sequence"));
+                                                "Response hat wrong command sequence"));
      return;
    }

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

 #define FP_COMPONENT "uru4000"

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

 #include "drivers_api.h"

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

-  EVP_CIPHER_CTX                 *cipher_ctx;
+  CK_MECHANISM_TYPE               cipher;
+  PK11SlotInfo                   *slot;
+  PK11SymKey                     *symkey;
+  SECItem                        *param;
 };
 G_DECLARE_FINAL_TYPE (FpiDeviceUru4000, fpi_device_uru4000, FPI, DEVICE_URU4000,
                      FpImageDevice);
@@ -243,29 +246,13 @@ 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 * 2];
+  unsigned char respdata[CR_LENGTH];
+  PK11Context *ctx;
  int outlen;

  if (error)
@@ -274,39 +261,17 @@ 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 */
-  if (!EVP_EncryptUpdate (self->cipher_ctx, respdata, &outlen, transfer->buffer, CR_LENGTH))
+  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)
    {
-      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;
+      fp_err ("Failed to encrypt challenge data");
+      error = fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, "Failed to encrypt challenge data");
    }
+  PK11_DestroyContext (ctx, PR_TRUE);

  if (!error)
    write_regs (FP_IMAGE_DEVICE (dev), REG_RESPONSE, CR_LENGTH, respdata, response_cb, ssm);
@@ -352,7 +317,6 @@ irq_handler (FpiUsbTransfer *transfer,
      if (urudev->irqs_stopped_cb)
        urudev->irqs_stopped_cb (imgdev);
      urudev->irqs_stopped_cb = NULL;
-      g_clear_error (&error);
      return;
    }
  else if (error)
@@ -587,7 +551,7 @@ image_transfer_cb (FpiUsbTransfer *transfer, FpDevice *dev,
    }
  else
    {
-      self->img_data = g_memdup2 (transfer->buffer, sizeof (struct uru4k_image));
+      self->img_data = g_memdup (transfer->buffer, sizeof (struct uru4k_image));
      self->img_data_actual_length = transfer->actual_length;
      fpi_ssm_next_state (ssm);
    }
@@ -738,9 +702,9 @@ imaging_run_state (FpiSsm *ssm, FpDevice *_dev)

    case IMAGING_DECODE:
      key  = self->last_reg_rd[0];
-      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->last_reg_rd[1] << 8;
+      key |= self->last_reg_rd[2] << 16;
+      key |= self->last_reg_rd[3] << 24;
      key ^= self->img_enc_seed;

      fp_dbg ("encryption id %02x -> key %08x", img->key_number, key);
@@ -1305,6 +1269,8 @@ 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);
@@ -1376,6 +1342,20 @@ 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);
@@ -1388,17 +1368,35 @@ dev_init (FpImageDevice *dev)
  self->interface = g_usb_interface_get_number (iface);

  /* Set up encryption */
-  if (!(self->cipher_ctx = EVP_CIPHER_CTX_new ()))
+  self->cipher = CKM_AES_ECB;
+  self->slot = PK11_GetBestSlot (self->cipher, NULL);
+  if (self->slot == NULL)
    {
-      fpi_image_device_open_complete (dev, openssl_device_error ());
+      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"));
      return;
    }
-
-  if (!EVP_EncryptInit_ex (self->cipher_ctx, EVP_aes_128_ecb (), NULL, crkey, NULL))
+  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)
    {
-      fpi_image_device_open_complete (dev, openssl_device_error ());
+      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"));
      return;
    }
+  self->param = PK11_ParamFromIV (self->cipher, NULL);

  fpi_image_device_open_complete (dev, NULL);
 }
@@ -1409,8 +1407,12 @@ dev_deinit (FpImageDevice *dev)
  GError *error = NULL;
  FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev);

-  g_clear_pointer (&self->cipher_ctx, EVP_CIPHER_CTX_free);
-
+  if (self->symkey)
+    PK11_FreeSymKey (self->symkey);
+  if (self->param)
+    SECITEM_FreeItem (self->param, PR_TRUE);
+  if (self->slot)
+    PK11_FreeSlot (self->slot);
  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)),
                                  self->interface, 0, &error);
  g_clear_pointer (&self->rand, g_rand_free);
--- a/libfprint/drivers/vfs0050.c
+++ b/libfprint/drivers/vfs0050.c
@@ -581,7 +581,7 @@ activate_ssm (FpiSsm *ssm, FpDevice *dev)
            /* Initialize fingerprint buffer */
            g_free (self->lines_buffer);
            self->memory = VFS_USB_BUFFER_SIZE;
-            self->lines_buffer = g_malloc0 (self->memory);
+            self->lines_buffer = g_malloc (self->memory);
            self->bytes = 0;

            /* Finger is on the scanner */
@@ -589,15 +589,12 @@ activate_ssm (FpiSsm *ssm, FpDevice *dev)
          }

        /* Increase buffer size while it's insufficient */
-        while (self->memory < self->bytes + VFS_USB_BUFFER_SIZE)
+        while (self->bytes + VFS_USB_BUFFER_SIZE > self->memory)
          {
-            int pre_memory = self->memory;
-            self->memory += VFS_USB_BUFFER_SIZE;
+            self->memory <<= 1;
            self->lines_buffer =
              (struct vfs_line *) g_realloc (self->lines_buffer,
                                             self->memory);
-            memset ((guint8 *) self->lines_buffer + pre_memory, 0,
-                    VFS_USB_BUFFER_SIZE);
          }

        /* Receive chunk of data */
--- a/libfprint/drivers/vfs301_proto.c
+++ b/libfprint/drivers/vfs301_proto.c
@@ -432,7 +432,7 @@ img_process_data (int first_block, FpDeviceVfs301 *dev, const guint8 *buf, int l
    usb_send (dev, data, len, NULL); \
  }

-#define RAW_DATA(x) g_memdup2 (x, sizeof (x)), sizeof (x)
+#define RAW_DATA(x) g_memdup (x, sizeof (x)), sizeof (x)

 #define IS_VFS301_FP_SEQ_START(b) ((b[0] == 0x01) && (b[1] == 0xfe))

--- a/libfprint/drivers/virtual-device-listener.c
+++ b/libfprint/drivers/virtual-device-listener.c
@@ -273,8 +273,7 @@ on_stream_read_cb (GObject      *source_object,
        }
      else
        {
-          g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
-                                   "Got empty data");
+          // g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_INVALID_DATA, "Got empty data");
          return;
        }
    }
--- a/libfprint/drivers/virtual-device.c
+++ b/libfprint/drivers/virtual-device.c
@@ -526,8 +526,8 @@ dev_verify (FpDevice *dev)

  if (scan_id)
    {
-      g_autoptr(FpPrint) new_scan = NULL;
      GVariant *data = NULL;
+      FpPrint *new_scan;
      FpPrint *print;
      gboolean success;

@@ -556,7 +556,7 @@ dev_verify (FpDevice *dev)
          self->match_reported = TRUE;
          fpi_device_verify_report (dev,
                                    success ? FPI_MATCH_SUCCESS : FPI_MATCH_FAIL,
-                                    g_steal_pointer (&new_scan),
+                                    new_scan,
                                    NULL);
        }
    }
@@ -733,13 +733,7 @@ dev_deinit (FpDevice *dev)
    }

  if (!self->keep_alive)
-    {
-      stop_listener (self);
-      self->supports_cancellation = TRUE;
-    }
-
-  self->enroll_stages_passed = 0;
-  self->match_reported = FALSE;
+    stop_listener (self);

  fpi_device_close_complete (dev, NULL);
 }
@@ -772,7 +766,6 @@ 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;

@@ -788,18 +781,5 @@ 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,7 +310,6 @@ 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";
@@ -322,17 +321,4 @@ 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-context.c
+++ b/libfprint/fp-context.c
@@ -67,26 +67,32 @@ enum {
 static guint signals[LAST_SIGNAL] = { 0 };

 static const char *
-get_drivers_allowlist_env (void)
+get_drivers_whitelist_env (void)
 {
-  return g_getenv ("FP_DRIVERS_ALLOWLIST");
+  return g_getenv ("FP_DRIVERS_WHITELIST");
 }

 static gboolean
 is_driver_allowed (const gchar *driver)
 {
-  g_auto(GStrv) allowlisted_drivers = NULL;
-  const char *fp_drivers_allowlist_env;
+  g_auto(GStrv) whitelisted_drivers = NULL;
+  const char *fp_drivers_whitelist_env;
+  int i;

  g_return_val_if_fail (driver, TRUE);

-  fp_drivers_allowlist_env = get_drivers_allowlist_env ();
+  fp_drivers_whitelist_env = get_drivers_whitelist_env ();

-  if (!fp_drivers_allowlist_env)
+  if (!fp_drivers_whitelist_env)
    return TRUE;

-  allowlisted_drivers = g_strsplit (fp_drivers_allowlist_env, ":", -1);
-  return g_strv_contains ((const gchar * const *) allowlisted_drivers, driver);
+  whitelisted_drivers = g_strsplit (fp_drivers_whitelist_env, ":", -1);
+
+  for (i = 0; whitelisted_drivers[i]; ++i)
+    if (g_strcmp0 (driver, whitelisted_drivers[i]) == 0)
+      return TRUE;
+
+  return FALSE;
 }

 typedef struct
@@ -285,10 +291,11 @@ fp_context_finalize (GObject *object)
  FpContext *self = (FpContext *) object;
  FpContextPrivate *priv = fp_context_get_instance_private (self);

+  g_clear_pointer (&priv->devices, g_ptr_array_unref);
+
  g_cancellable_cancel (priv->cancellable);
  g_clear_object (&priv->cancellable);
  g_clear_pointer (&priv->drivers, g_array_unref);
-  g_clear_pointer (&priv->devices, g_ptr_array_unref);

  g_slist_free_full (g_steal_pointer (&priv->sources), (GDestroyNotify) g_source_destroy);

@@ -358,7 +365,7 @@ fp_context_init (FpContext *self)

  priv->drivers = fpi_get_driver_types ();

-  if (get_drivers_allowlist_env ())
+  if (get_drivers_whitelist_env ())
    {
      for (i = 0; i < priv->drivers->len;)
        {
--- a/libfprint/fp-device-private.h
+++ b/libfprint/fp-device-private.h
@@ -44,7 +44,7 @@ typedef struct
  FpDeviceType type;

  GUsbDevice  *usb_device;
-  gchar       *virtual_env;
+  const gchar *virtual_env;
  struct
  {
    gchar *spidev_path;
@@ -61,7 +61,6 @@ typedef struct
  FpDeviceFeature features;

  guint64         driver_data;
-  GVariant       *persistent_data;

  gint            nr_enroll_stages;
  GSList         *sources;
@@ -112,6 +111,8 @@ typedef struct
  GDestroyNotify   enroll_progress_destroy;
 } FpEnrollData;

+void enroll_data_free (FpEnrollData *enroll_data);
+
 typedef struct
 {
  FpPrint       *enrolled_print;   /* verify */
@@ -127,6 +128,7 @@ typedef struct
  GDestroyNotify match_destroy;
 } FpMatchData;

+void match_data_free (FpMatchData *match_data);

 void fpi_device_suspend (FpDevice *device);
 void fpi_device_resume (FpDevice *device);
--- a/libfprint/fp-device.c
+++ b/libfprint/fp-device.c
@@ -54,7 +54,6 @@ enum {
  PROP_FPI_UDEV_DATA_SPIDEV,
  PROP_FPI_UDEV_DATA_HIDRAW,
  PROP_FPI_DRIVER_DATA,
-  PROP_FPI_PERSISTENT_DATA,
  N_PROPS
 };

@@ -236,8 +235,6 @@ fp_device_finalize (GObject *object)
  g_clear_pointer (&priv->udev_data.spidev_path, g_free);
  g_clear_pointer (&priv->udev_data.hidraw_path, g_free);

-  g_clear_pointer (&priv->persistent_data, g_variant_unref);
-
  G_OBJECT_CLASS (fp_device_parent_class)->finalize (object);
 }

@@ -295,22 +292,18 @@ fp_device_get_property (GObject    *object,

    case PROP_FPI_UDEV_DATA_SPIDEV:
      if (cls->type == FP_DEVICE_TYPE_UDEV)
-        g_value_set_string (value, priv->udev_data.spidev_path);
+        g_value_set_string (value, g_strdup (priv->udev_data.spidev_path));
      else
        g_value_set_string (value, NULL);
      break;

    case PROP_FPI_UDEV_DATA_HIDRAW:
      if (cls->type == FP_DEVICE_TYPE_UDEV)
-        g_value_set_string (value, priv->udev_data.hidraw_path);
+        g_value_set_string (value, g_strdup (priv->udev_data.hidraw_path));
      else
        g_value_set_string (value, NULL);
      break;

-    case PROP_FPI_PERSISTENT_DATA:
-      g_value_set_variant (value, priv->persistent_data);
-      break;
-
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
@@ -361,11 +354,6 @@ fp_device_set_property (GObject      *object,
      priv->driver_data = g_value_get_uint64 (value);
      break;

-    case PROP_FPI_PERSISTENT_DATA:
-      g_clear_pointer (&priv->persistent_data, g_variant_unref);
-      priv->persistent_data = g_value_dup_variant (value);
-      break;
-
    default:
      G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
    }
@@ -606,21 +594,6 @@ fp_device_class_init (FpDeviceClass *klass)
                         0,
                         G_PARAM_STATIC_STRINGS | G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY);

-  /**
-   * FpDevice::fpi-persistent-data: (skip)
-   *
-   * This property is only for internal purposes.
-   *
-   * Stability: private
-   */
-  properties[PROP_FPI_PERSISTENT_DATA] =
-    g_param_spec_variant ("fpi-persistent-data",
-                          "Persistent Driver Data",
-                          "Private: Previously stored data for the device",
-                          G_VARIANT_TYPE_ANY,
-                          NULL,
-                          G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
-
  g_object_class_install_properties (object_class, N_PROPS, properties);
 }

@@ -766,139 +739,6 @@ fp_device_get_temperature (FpDevice *device)
  return priv->temp_current;
 }

-/**
- * fp_device_get_persistent_data:
- * @device: A #FpDevice
- * @data: (array length=length) (transfer full) (out): Return location for data pointer
- * @length: (transfer full) (out): Length of @data
- * @error: Return location for error
- *
- * Retrieves persistent data that should be stored for this device. Storage
- * needs to be device specific, i.e. device ID and driver must match when
- * restored.
- *
- * Returns: (type void): %TRUE on success
- */
-gboolean
-fp_device_get_persistent_data (FpDevice *device,
-                               guchar  **data,
-                               gsize    *length,
-                               GError  **error)
-{
-  g_autoptr(GVariant) res = NULL;
-  FpDevicePrivate *priv = fp_device_get_instance_private (device);
-
-  g_assert (data);
-  g_assert (length);
-
-  if (priv->persistent_data == NULL)
-    {
-      *data = NULL;
-      *length = 0;
-
-      return TRUE;
-    }
-
-  /* Version + variant from driver */
-  res = g_variant_new ("(issv)",
-                       1,
-                       fp_device_get_driver (device),
-                       priv->device_id,
-                       priv->persistent_data);
-
-  *length = g_variant_get_size (res);
-  *data = g_malloc (*length);
-  g_variant_store (res, *data);
-
-  return TRUE;
-}
-
-/**
- * fp_device_get_persistent_data:
- * @device: A #FpDevice
- * @data: (array length=length) (transfer none): Persistent Data
- * @length: (transfer none): Length of @data
- * @error: Return location for error
- *
- * Load persistent data from storage. This function should be called after
- * a device was discovered and before it is opened for the first time. It is
- * an error to call it if data has already been set (or generated by the
- * driver).
- *
- * Note that the driver may update the data. The API user should retrieve the
- * value when done with the device and store it in a persistent location.
- *
- * Returns: (type void): %TRUE on success
- */
-gboolean
-fp_device_set_persistent_data (FpDevice *device,
-                               guchar   *data,
-                               gsize     length,
-                               GError  **error)
-{
-  g_autoptr(GVariant) stored = NULL;
-  g_autoptr(GVariant) loaded = NULL;
-  FpDevicePrivate *priv = fp_device_get_instance_private (device);
-  guchar *copy;
-  gint version;
-  const gchar *device_id;
-  const gchar *driver;
-
-  if (priv->is_open)
-    {
-      g_set_error (error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
-                   "Data can only be set right after device creation");
-      return FALSE;
-    }
-
-  if (priv->persistent_data)
-    {
-      g_set_error (error, G_IO_ERROR, G_IO_ERROR_EXISTS,
-                   "Data has already been set");
-      return FALSE;
-    }
-
-  if (length == 0)
-    {
-      g_clear_pointer (&priv->persistent_data, g_variant_unref);
-      g_object_notify_by_pspec (G_OBJECT (device), properties[PROP_FPI_PERSISTENT_DATA]);
-      return TRUE;
-    }
-  g_assert (data);
-
-  copy = g_memdup2 (data, length);
-  stored = g_variant_new_from_data (G_VARIANT_TYPE ("(issv)"), copy, length, FALSE, g_free, copy);
-
-  if (!stored)
-    {
-      g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
-                   "Data could not be parsed");
-      return FALSE;
-    }
-
-  g_variant_get (stored, "(issv)", &version, &driver, &device_id, &loaded);
-  if (version != 1)
-    {
-      g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
-                   "Unknown data storage version");
-      return FALSE;
-    }
-
-  if (g_strcmp0 (device_id, priv->device_id) != 0 ||
-      g_strcmp0 (driver, fp_device_get_driver (device)) != 0)
-    {
-      g_set_error (error, G_IO_ERROR, G_IO_ERROR_INVALID_DATA,
-                   "Driver or device ID mismatch!");
-      return FALSE;
-    }
-
-  g_clear_pointer (&priv->persistent_data, g_variant_unref);
-  priv->persistent_data = g_steal_pointer (&loaded);
-  g_object_notify_by_pspec (G_OBJECT (device), properties[PROP_FPI_PERSISTENT_DATA]);
-
-  return TRUE;
-}
-
 /**
 * fp_device_supports_identify:
 * @device: A #FpDevice
@@ -1248,23 +1088,14 @@ fp_device_resume_finish (FpDevice     *device,
  return g_task_propagate_boolean (G_TASK (result), error);
 }

-static void
-enroll_data_free (FpEnrollData *data)
-{
-  if (data->enroll_progress_destroy)
-    data->enroll_progress_destroy (data->enroll_progress_data);
-  data->enroll_progress_data = NULL;
-  g_clear_object (&data->print);
-  g_free (data);
-}

 /**
 * fp_device_enroll:
 * @device: a #FpDevice
 * @template_print: (transfer floating): a #FpPrint
 * @cancellable: (nullable): a #GCancellable, or %NULL
- * @progress_cb: (nullable) (closure progress_data) (scope notified): progress reporting callback
- * @progress_data: user data for @progress_cb
+ * @progress_cb: (nullable) (scope notified): progress reporting callback
+ * @progress_data: (closure progress_cb): 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
@@ -1341,6 +1172,10 @@ fp_device_enroll (FpDevice           *device,
        }
    }

+  priv->current_action = FPI_DEVICE_ACTION_ENROLL;
+  priv->current_task = g_steal_pointer (&task);
+  setup_task_cancellable (device);
+
  fpi_device_update_temp (device, TRUE);
  if (priv->temp_current == FP_TEMPERATURE_HOT)
    {
@@ -1349,10 +1184,6 @@ fp_device_enroll (FpDevice           *device,
      return;
    }

-  priv->current_action = FPI_DEVICE_ACTION_ENROLL;
-  priv->current_task = g_steal_pointer (&task);
-  setup_task_cancellable (device);
-
  data = g_new0 (FpEnrollData, 1);
  data->print = g_object_ref_sink (template_print);
  data->enroll_progress_cb = progress_cb;
@@ -1386,30 +1217,13 @@ fp_device_enroll_finish (FpDevice     *device,
  return g_task_propagate_pointer (G_TASK (result), error);
 }

-static void
-match_data_free (FpMatchData *data)
-{
-  g_clear_object (&data->print);
-  g_clear_object (&data->match);
-  g_clear_error (&data->error);
-
-  if (data->match_destroy)
-    data->match_destroy (data->match_data);
-  data->match_data = NULL;
-
-  g_clear_object (&data->enrolled_print);
-  g_clear_pointer (&data->gallery, g_ptr_array_unref);
-
-  g_free (data);
-}
-
 /**
 * fp_device_verify:
 * @device: a #FpDevice
 * @enrolled_print: a #FpPrint to verify
 * @cancellable: (nullable): a #GCancellable, or %NULL
- * @match_cb: (nullable) (scope notified) (closure match_data): match reporting callback
- * @match_data: user data for @match_cb
+ * @match_cb: (nullable) (scope notified): match reporting callback
+ * @match_data: (closure match_cb): 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
@@ -1459,6 +1273,10 @@ fp_device_verify (FpDevice           *device,
      return;
    }

+  priv->current_action = FPI_DEVICE_ACTION_VERIFY;
+  priv->current_task = g_steal_pointer (&task);
+  setup_task_cancellable (device);
+
  fpi_device_update_temp (device, TRUE);
  if (priv->temp_current == FP_TEMPERATURE_HOT)
    {
@@ -1467,10 +1285,6 @@ fp_device_verify (FpDevice           *device,
      return;
    }

-  priv->current_action = FPI_DEVICE_ACTION_VERIFY;
-  priv->current_task = g_steal_pointer (&task);
-  setup_task_cancellable (device);
-
  data = g_new0 (FpMatchData, 1);
  data->enrolled_print = g_object_ref (enrolled_print);
  data->match_cb = match_cb;
@@ -1534,8 +1348,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) (closure match_data): match reporting callback
- * @match_data: user data for @match_cb
+ * @match_cb: (nullable) (scope notified): match reporting callback
+ * @match_data: (closure match_cb): 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
@@ -1586,13 +1400,9 @@ fp_device_identify (FpDevice           *device,
      return;
    }

-  if (prints == NULL)
-    {
-      g_task_return_error (task,
-                           fpi_device_error_new_msg (FP_DEVICE_ERROR_DATA_INVALID,
-                                                     "Invalid gallery array"));
-      return;
-    }
+  priv->current_action = FPI_DEVICE_ACTION_IDENTIFY;
+  priv->current_task = g_steal_pointer (&task);
+  setup_task_cancellable (device);

  fpi_device_update_temp (device, TRUE);
  if (priv->temp_current == FP_TEMPERATURE_HOT)
@@ -1602,10 +1412,6 @@ fp_device_identify (FpDevice           *device,
      return;
    }

-  priv->current_action = FPI_DEVICE_ACTION_IDENTIFY;
-  priv->current_task = g_steal_pointer (&task);
-  setup_task_cancellable (device);
-
  data = g_new0 (FpMatchData, 1);
  /* We cannot store the gallery directly, because the ptr array may not own
   * a reference to each print. Also, the caller could in principle modify the
@@ -1719,6 +1525,10 @@ fp_device_capture (FpDevice           *device,
      return;
    }

+  priv->current_action = FPI_DEVICE_ACTION_CAPTURE;
+  priv->current_task = g_steal_pointer (&task);
+  setup_task_cancellable (device);
+
  fpi_device_update_temp (device, TRUE);
  if (priv->temp_current == FP_TEMPERATURE_HOT)
    {
@@ -1727,10 +1537,6 @@ fp_device_capture (FpDevice           *device,
      return;
    }

-  priv->current_action = FPI_DEVICE_ACTION_CAPTURE;
-  priv->current_task = g_steal_pointer (&task);
-  setup_task_cancellable (device);
-
  priv->wait_for_finger = wait_for_finger;

  cls->capture (device);
@@ -2103,8 +1909,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) (closure match_data): match reporting callback
- * @match_data: user data for @match_cb
+ * @match_cb: (nullable) (scope call): match reporting callback
+ * @match_data: (closure match_cb): 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
@@ -2143,8 +1949,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) (closure match_data): match reporting callback
- * @match_data: user data for @match_cb
+ * @match_cb: (nullable) (scope call): match reporting callback
+ * @match_data: (closure match_cb): 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,8 +113,6 @@ 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.
@@ -124,7 +122,6 @@ typedef enum {
  FP_DEVICE_RETRY_TOO_SHORT,
  FP_DEVICE_RETRY_CENTER_FINGER,
  FP_DEVICE_RETRY_REMOVE_FINGER,
-  FP_DEVICE_RETRY_TOO_FAST,
 } FpDeviceRetry;

 /**
@@ -233,15 +230,6 @@ FpDeviceFeature     fp_device_get_features (FpDevice *device);
 gboolean            fp_device_has_feature (FpDevice       *device,
                                           FpDeviceFeature feature);

-gboolean fp_device_get_persistent_data (FpDevice *device,
-                                        guchar  **data,
-                                        gsize    *length,
-                                        GError  **error);
-gboolean fp_device_set_persistent_data (FpDevice *device,
-                                        guchar   *data,
-                                        gsize     length,
-                                        GError  **error);
-
 /* Opening the device */
 void fp_device_open (FpDevice           *device,
                     GCancellable       *cancellable,
--- a/libfprint/fp-image.c
+++ b/libfprint/fp-image.c
@@ -20,11 +20,9 @@

 #define FP_COMPONENT "image"

-#include "fpi-compat.h"
 #include "fpi-image.h"
 #include "fpi-log.h"

-#include <config.h>
 #include <nbis.h>

 /**
@@ -160,65 +158,60 @@ fp_image_init (FpImage *self)

 typedef struct
 {
+  GAsyncReadyCallback user_cb;
  struct fp_minutiae *minutiae;
-  guchar             *binarized;
+  gint                width, height;
+  gdouble             ppmm;
  FpiImageFlags       flags;
-  unsigned char      *image;
-  gboolean            image_changed;
-} DetectMinutiaeNbisData;
+  guchar             *image;
+  guchar             *binarized;
+} DetectMinutiaeData;

 static void
-fp_image_detect_minutiae_free (DetectMinutiaeNbisData *data)
+fp_image_detect_minutiae_free (DetectMinutiaeData *data)
 {
+  g_clear_pointer (&data->image, g_free);
  g_clear_pointer (&data->minutiae, free_minutiae);
  g_clear_pointer (&data->binarized, g_free);
-
-  if (data->image_changed)
-    g_clear_pointer (&data->image, g_free);
-
  g_free (data);
 }

-G_DEFINE_AUTOPTR_CLEANUP_FUNC (DetectMinutiaeNbisData, fp_image_detect_minutiae_free)
-
-
-static gboolean
-fp_image_detect_minutiae_nbis_finish (FpImage *self,
-                                      GTask   *task,
-                                      GError **error)
+static void
+fp_image_detect_minutiae_cb (GObject      *source_object,
+                             GAsyncResult *res,
+                             gpointer      user_data)
 {
-  g_autoptr(DetectMinutiaeNbisData) data = NULL;
+  GTask *task = G_TASK (res);
+  FpImage *image;
+  DetectMinutiaeData *data = g_task_get_task_data (task);

-  data = g_task_propagate_pointer (task, error);
-
-  if (data != NULL)
+  if (!g_task_had_error (task))
    {
-      self->flags = data->flags;
+      gint i;
+      image = FP_IMAGE (source_object);

-      if (data->image_changed)
-        {
-          g_clear_pointer (&self->data, g_free);
-          self->data = g_steal_pointer (&data->image);
-        }
+      image->flags = data->flags;

-      g_clear_pointer (&self->binarized, g_free);
-      self->binarized = g_steal_pointer (&data->binarized);
+      g_clear_pointer (&image->data, g_free);
+      image->data = g_steal_pointer (&data->image);

-      g_clear_pointer (&self->minutiae, g_ptr_array_unref);
-      self->minutiae = g_ptr_array_new_full (data->minutiae->num,
-                                             (GDestroyNotify) free_minutia);
+      g_clear_pointer (&image->binarized, g_free);
+      image->binarized = g_steal_pointer (&data->binarized);

-      for (int i = 0; i < data->minutiae->num; i++)
-        g_ptr_array_add (self->minutiae,
+      g_clear_pointer (&image->minutiae, g_ptr_array_unref);
+      image->minutiae = g_ptr_array_new_full (data->minutiae->num,
+                                              (GDestroyNotify) free_minutia);
+
+      for (i = 0; i < data->minutiae->num; i++)
+        g_ptr_array_add (image->minutiae,
                         g_steal_pointer (&data->minutiae->list[i]));

-      /* Don't let free_minutiae delete the minutiae that we now own. */
+      /* Don't let it delete anything. */
      data->minutiae->num = 0;
-
-      return TRUE;
    }

-  return FALSE;
+  if (data->user_cb)
+    data->user_cb (source_object, res, user_data);
 }

 static void
@@ -271,83 +264,70 @@ invert_colors (guint8 *data, gint width, gint height)
 }

 static void
-fp_image_detect_minutiae_nbis_thread_func (GTask        *task,
-                                           gpointer      source_object,
-                                           gpointer      task_data,
-                                           GCancellable *cancellable)
+fp_image_detect_minutiae_thread_func (GTask        *task,
+                                      gpointer      source_object,
+                                      gpointer      task_data,
+                                      GCancellable *cancellable)
 {
  g_autoptr(GTimer) timer = NULL;
-  g_autoptr(DetectMinutiaeNbisData) ret_data = NULL;
-  g_autoptr(GTask) thread_task = g_steal_pointer (&task);
+  DetectMinutiaeData *data = task_data;
+  struct fp_minutiae *minutiae = NULL;
  g_autofree gint *direction_map = NULL;
  g_autofree gint *low_contrast_map = NULL;
  g_autofree gint *low_flow_map = NULL;
  g_autofree gint *high_curve_map = NULL;
  g_autofree gint *quality_map = NULL;
-  g_autofree LFSPARMS *lfsparms = NULL;
-  FpImage *self = source_object;
-  FpiImageFlags minutiae_flags;
-  unsigned char *image;
+  g_autofree guchar *bdata = NULL;
  gint map_w, map_h;
  gint bw, bh, bd;
  gint r;
-
-  image = self->data;
-  minutiae_flags = self->flags & ~(FPI_IMAGE_H_FLIPPED |
-                                   FPI_IMAGE_V_FLIPPED |
-                                   FPI_IMAGE_COLORS_INVERTED);
-
-  if (minutiae_flags != FPI_IMAGE_NONE)
-    image = g_memdup2 (self->data, self->width * self->height);
-
-  ret_data = g_new0 (DetectMinutiaeNbisData, 1);
-  ret_data->flags = minutiae_flags;
-  ret_data->image = image;
-  ret_data->image_changed = image != self->data;
+  g_autofree LFSPARMS *lfsparms = NULL;

  /* Normalize the image first */
-  if (self->flags & FPI_IMAGE_H_FLIPPED)
-    hflip (image, self->width, self->height);
+  if (data->flags & FPI_IMAGE_H_FLIPPED)
+    hflip (data->image, data->width, data->height);

-  if (self->flags & FPI_IMAGE_V_FLIPPED)
-    vflip (image, self->width, self->height);
+  if (data->flags & FPI_IMAGE_V_FLIPPED)
+    vflip (data->image, data->width, data->height);

-  if (self->flags & FPI_IMAGE_COLORS_INVERTED)
-    invert_colors (image, self->width, self->height);
+  if (data->flags & FPI_IMAGE_COLORS_INVERTED)
+    invert_colors (data->image, data->width, data->height);

-  lfsparms = g_memdup2 (&g_lfsparms_V2, sizeof (LFSPARMS));
-  lfsparms->remove_perimeter_pts = minutiae_flags & FPI_IMAGE_PARTIAL ? TRUE : FALSE;
+  data->flags &= ~(FPI_IMAGE_H_FLIPPED | FPI_IMAGE_V_FLIPPED | FPI_IMAGE_COLORS_INVERTED);
+
+  lfsparms = g_memdup (&g_lfsparms_V2, sizeof (LFSPARMS));
+  lfsparms->remove_perimeter_pts = data->flags & FPI_IMAGE_PARTIAL ? TRUE : FALSE;

  timer = g_timer_new ();
-  r = get_minutiae (&ret_data->minutiae, &quality_map, &direction_map,
+  r = get_minutiae (&minutiae, &quality_map, &direction_map,
                    &low_contrast_map, &low_flow_map, &high_curve_map,
-                    &map_w, &map_h, &ret_data->binarized, &bw, &bh, &bd,
-                    image, self->width, self->height, 8,
-                    self->ppmm, lfsparms);
+                    &map_w, &map_h, &bdata, &bw, &bh, &bd,
+                    data->image, data->width, data->height, 8,
+                    data->ppmm, lfsparms);
  g_timer_stop (timer);
  fp_dbg ("Minutiae scan completed in %f secs", g_timer_elapsed (timer, NULL));

-  if (g_task_had_error (thread_task))
-    return;
+  data->binarized = g_steal_pointer (&bdata);
+  data->minutiae = minutiae;

  if (r)
    {
      fp_err ("get minutiae failed, code %d", r);
-      g_task_return_new_error (thread_task, G_IO_ERROR,
-                               G_IO_ERROR_FAILED,
-                               "Minutiae scan failed with code %d", r);
+      g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED, "Minutiae scan failed with code %d", r);
+      g_object_unref (task);
      return;
    }

-  if (!ret_data->minutiae || ret_data->minutiae->num == 0)
+  if (!data->minutiae || data->minutiae->num == 0)
    {
-      g_task_return_new_error (thread_task, G_IO_ERROR, G_IO_ERROR_FAILED,
+      g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_FAILED,
                               "No minutiae found");
+      g_object_unref (task);
      return;
    }

-  g_task_return_pointer (thread_task, g_steal_pointer (&ret_data),
-                         (GDestroyNotify) fp_image_detect_minutiae_free);
+  g_task_return_boolean (task, TRUE);
+  g_object_unref (task);
 }

 /**
@@ -463,25 +443,21 @@ fp_image_detect_minutiae (FpImage            *self,
                          GAsyncReadyCallback callback,
                          gpointer            user_data)
 {
-  g_autoptr(GTask) task = NULL;
+  GTask *task;
+  DetectMinutiaeData *data = g_new0 (DetectMinutiaeData, 1);

-  g_return_if_fail (FP_IS_IMAGE (self));
-  g_return_if_fail (callback != NULL);
+  task = g_task_new (self, cancellable, fp_image_detect_minutiae_cb, user_data);

-  task = g_task_new (self, cancellable, callback, user_data);
-  g_task_set_source_tag (task, fp_image_detect_minutiae);
-  g_task_set_check_cancellable (task, TRUE);
+  data->image = g_malloc (self->width * self->height);
+  memcpy (data->image, self->data, self->width * self->height);
+  data->flags = self->flags;
+  data->width = self->width;
+  data->height = self->height;
+  data->ppmm = self->ppmm;
+  data->user_cb = callback;

-  if (!g_atomic_int_compare_and_exchange (&self->detection_in_progress,
-                                          FALSE, TRUE))
-    {
-      g_task_return_new_error (task, G_IO_ERROR, G_IO_ERROR_ADDRESS_IN_USE,
-                               "Minutiae detection is already in progress");
-      return;
-    }
-
-  g_task_run_in_thread (g_steal_pointer (&task),
-                        fp_image_detect_minutiae_nbis_thread_func);
+  g_task_set_task_data (task, data, (GDestroyNotify) fp_image_detect_minutiae_free);
+  g_task_run_in_thread (task, fp_image_detect_minutiae_thread_func);
 }

 /**
@@ -499,27 +475,7 @@ fp_image_detect_minutiae_finish (FpImage      *self,
                                 GAsyncResult *result,
                                 GError      **error)
 {
-  GTask *task;
-  gboolean changed;
-
-  g_return_val_if_fail (FP_IS_IMAGE (self), FALSE);
-  g_return_val_if_fail (g_task_is_valid (result, self), FALSE);
-  g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) ==
-                        fp_image_detect_minutiae, FALSE);
-
-  task = G_TASK (result);
-  changed = g_atomic_int_compare_and_exchange (&self->detection_in_progress,
-                                               TRUE, FALSE);
-  g_assert (changed);
-
-  if (g_task_had_error (task))
-    {
-      gpointer data = g_task_propagate_pointer (task, error);
-      g_assert (data == NULL);
-      return FALSE;
-    }
-
-  return fp_image_detect_minutiae_nbis_finish (self, task, error);
+  return g_task_propagate_boolean (G_TASK (result), error);
 }

 /**
--- a/libfprint/fp-print.c
+++ b/libfprint/fp-print.c
@@ -339,7 +339,7 @@ fp_print_init (FpPrint *self)
 * create a new print, fill in the relevant metadata, and then start
 * enrollment.
 *
- * Returns: (transfer floating): A newly created #FpPrint
+ * Returns: (transfer floating): A newyl created #FpPrint
 */
 FpPrint *
 fp_print_new (FpDevice *device)
@@ -721,12 +721,13 @@ fp_print_serialize (FpPrint *print,

  result = g_variant_builder_end (&builder);

-#if (G_BYTE_ORDER == G_BIG_ENDIAN)
-  GVariant *tmp;
-  tmp = g_variant_byteswap (result);
-  g_variant_unref (result);
-  result = tmp;
-#endif
+  if (G_BYTE_ORDER == G_BIG_ENDIAN)
+    {
+      GVariant *tmp;
+      tmp = g_variant_byteswap (result);
+      g_variant_unref (result);
+      result = tmp;
+    }

  len = g_variant_get_size (result);
  /* Add 3 bytes of header */
@@ -799,11 +800,10 @@ fp_print_deserialize (const guchar *data,
  if (!raw_value)
    goto invalid_format;

-#if (G_BYTE_ORDER == G_BIG_ENDIAN)
-  value = g_variant_byteswap (raw_value);
-#else
-  value = g_variant_get_normal_form (raw_value);
-#endif
+  if (G_BYTE_ORDER == G_BIG_ENDIAN)
+    value = g_variant_byteswap (raw_value);
+  else
+    value = g_variant_get_normal_form (raw_value);

  g_variant_get (value,
                 "(i&s&sbymsmsi@a{sv}v)",
--- a/libfprint/fpi-byte-reader.c
+++ b/libfprint/fpi-byte-reader.c
@@ -1181,7 +1181,7 @@ fpi_byte_reader_dup_string_utf##bits (FpiByteReader * reader, type ** str) \
    *str = NULL; \
    return FALSE; \
  } \
-  *str = g_memdup2 (reader->data + reader->byte, size); \
+  *str = g_memdup (reader->data + reader->byte, size); \
  reader->byte += size; \
  return TRUE; \
 }
--- a/libfprint/fpi-byte-reader.h
+++ b/libfprint/fpi-byte-reader.h
@@ -22,7 +22,6 @@
 #pragma once

 #include <glib.h>
-#include "fpi-compat.h"
 #include "fpi-byte-utils.h"

 G_BEGIN_DECLS
@@ -361,7 +360,7 @@ static inline guint8 *
 fpi_byte_reader_dup_data_unchecked (FpiByteReader * reader, guint size)
 {
  gconstpointer data = fpi_byte_reader_get_data_unchecked (reader, size);
-  return (guint8 *) g_memdup2 (data, size);
+  return (guint8 *) g_memdup (data, size);
 }

 /* Unchecked variants that should not be used */
@@ -675,6 +674,4 @@ fpi_byte_reader_skip_inline (FpiByteReader * reader, guint nbytes)

 #endif /* FPI_BYTE_READER_DISABLE_INLINES */

-G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpiByteReader, fpi_byte_reader_free);
-
 G_END_DECLS
--- a/libfprint/fpi-byte-writer.c
+++ b/libfprint/fpi-byte-writer.c
@@ -75,8 +75,7 @@ fpi_byte_writer_new_with_size (guint size, gboolean fixed)
  FpiByteWriter *ret = fpi_byte_writer_new ();

  ret->alloc_size = size;
-  ret->parent.data = g_malloc0 (ret->alloc_size);
-  ret->parent.size = size;
+  ret->parent.data = g_malloc (ret->alloc_size);
  ret->fixed = fixed;
  ret->owned = TRUE;

@@ -143,8 +142,7 @@ fpi_byte_writer_init_with_size (FpiByteWriter * writer, guint size,

  fpi_byte_writer_init (writer);

-  writer->parent.data = g_malloc0 (size);
-  writer->parent.size = size;
+  writer->parent.data = g_malloc (size);
  writer->alloc_size = size;
  writer->fixed = fixed;
  writer->owned = TRUE;
@@ -211,9 +209,10 @@ fpi_byte_writer_reset_and_get_data (FpiByteWriter * writer)

  g_return_val_if_fail (writer != NULL, NULL);

-  data = (guint8 *) g_steal_pointer (&writer->parent.data);
+  data = (guint8 *) writer->parent.data;
  if (!writer->owned)
-    data = g_memdup2 (data, writer->parent.size);
+    data = g_memdup (data, writer->parent.size);
+  writer->parent.data = NULL;
  fpi_byte_writer_reset (writer);

  return data;
--- a/libfprint/fpi-byte-writer.h
+++ b/libfprint/fpi-byte-writer.h
@@ -111,17 +111,6 @@ fpi_byte_writer_set_pos (FpiByteWriter *writer, guint pos)
  return fpi_byte_reader_set_pos (FPI_BYTE_READER (writer), pos);
 }

-static inline gboolean
-fpi_byte_writer_change_pos (FpiByteWriter *writer, gint pos)
-{
-  pos = fpi_byte_writer_get_pos (writer) + pos;
-
-  if (pos < 0)
-    return FALSE;
-
-  return fpi_byte_reader_set_pos (FPI_BYTE_READER (writer), pos);
-}
-
 static inline guint
 fpi_byte_writer_get_size (const FpiByteWriter *writer)
 {
@@ -418,7 +407,4 @@ fpi_byte_writer_fill_inline (FpiByteWriter * writer, guint8 value, guint size)

 #endif

-G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpiByteWriter, fpi_byte_writer_free);
-G_DEFINE_AUTO_CLEANUP_CLEAR_FUNC (FpiByteWriter, fpi_byte_writer_reset);
-
 G_END_DECLS
--- a/libfprint/fpi-compat.h
+++ b/libfprint/fpi-compat.h
@@ -20,6 +20,25 @@

 #include <glib-object.h>

+#if !GLIB_CHECK_VERSION (2, 57, 0)
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (GTypeClass, g_type_class_unref);
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (GEnumClass, g_type_class_unref);
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (GFlagsClass, g_type_class_unref);
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (GParamSpec, g_param_spec_unref);
+#else
+/* Re-define G_SOURCE_FUNC as we are technically not allowed to use it with
+ * the version we depend on currently. */
+#undef G_SOURCE_FUNC
+#endif
+
+#define G_SOURCE_FUNC(f) ((GSourceFunc) (void (*)(void))(f))
+
+#if !GLIB_CHECK_VERSION (2, 63, 3)
+typedef struct _FpDeviceClass FpDeviceClass;
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpDeviceClass, g_type_class_unref);
+G_DEFINE_AUTOPTR_CLEANUP_FUNC (GDate, g_date_free);
+#endif
+
 #if  __GNUC__ > 10 || (__GNUC__ == 10 && __GNUC_MINOR__ >= 1)
 #define FP_GNUC_ACCESS(m, p, s) __attribute__((access (m, p, s)))
 #else
--- a/libfprint/fpi-device.c
+++ b/libfprint/fpi-device.c
@@ -21,7 +21,6 @@
 #define FP_COMPONENT "device"
 #include <math.h>
 #include <fcntl.h>
-#include <errno.h>

 #include "fpi-log.h"

@@ -117,10 +116,6 @@ 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;
@@ -526,6 +521,33 @@ fpi_device_get_driver_data (FpDevice *device)
  return priv->driver_data;
 }

+void
+enroll_data_free (FpEnrollData *data)
+{
+  if (data->enroll_progress_destroy)
+    data->enroll_progress_destroy (data->enroll_progress_data);
+  data->enroll_progress_data = NULL;
+  g_clear_object (&data->print);
+  g_free (data);
+}
+
+void
+match_data_free (FpMatchData *data)
+{
+  g_clear_object (&data->print);
+  g_clear_object (&data->match);
+  g_clear_error (&data->error);
+
+  if (data->match_destroy)
+    data->match_destroy (data->match_data);
+  data->match_data = NULL;
+
+  g_clear_object (&data->enrolled_print);
+  g_clear_pointer (&data->gallery, g_ptr_array_unref);
+
+  g_free (data);
+}
+
 /**
 * fpi_device_get_enroll_data:
 * @device: The #FpDevice
@@ -599,14 +621,7 @@ fpi_device_get_verify_data (FpDevice *device,
 * @device: The #FpDevice
 * @prints: (out) (transfer none) (element-type FpPrint): The gallery of prints
 *
- * Get prints gallery for identification.
- *
- * The @prints array is always non-%NULL and may contain a list of #FpPrint's
- * that the device should match against.
- *
- * Note that @prints can be an empty array, in such case the device is expected
- * to report the scanned print matching the one in its internal storage, if any.
- *
+ * Get data for identify.
 */
 void
 fpi_device_get_identify_data (FpDevice   *device,
@@ -1046,41 +1061,34 @@ fp_device_task_return_in_idle_cb (gpointer user_data)
 static void
 fpi_device_task_return_data_free (FpDeviceTaskReturnData *data)
 {
-  switch (data->type)
+  if (data->result)
    {
-    case FP_DEVICE_TASK_RETURN_INT:
-    case FP_DEVICE_TASK_RETURN_BOOL:
-      break;
+      switch (data->type)
+        {
+        case FP_DEVICE_TASK_RETURN_INT:
+        case FP_DEVICE_TASK_RETURN_BOOL:
+          break;

-    case FP_DEVICE_TASK_RETURN_OBJECT:
-      g_clear_object ((GObject **) &data->result);
-      break;
+        case FP_DEVICE_TASK_RETURN_OBJECT:
+          g_clear_object ((GObject **) &data->result);
+          break;

-    case FP_DEVICE_TASK_RETURN_PTR_ARRAY:
-      g_clear_pointer ((GPtrArray **) &data->result, g_ptr_array_unref);
-      break;
+        case FP_DEVICE_TASK_RETURN_PTR_ARRAY:
+          g_clear_pointer ((GPtrArray **) &data->result, g_ptr_array_unref);
+          break;

-    case FP_DEVICE_TASK_RETURN_ERROR:
-      g_clear_error ((GError **) &data->result);
-      break;
+        case FP_DEVICE_TASK_RETURN_ERROR:
+          g_clear_error ((GError **) &data->result);
+          break;

-    default:
-      g_assert_not_reached ();
+        default:
+          g_assert_not_reached ();
+        }
    }
-
  g_object_unref (data->device);
  g_free (data);
 }

-/**
- * fpi_device_return_task_in_idle:
- * @device: The #FpDevice
- * @return_type: The #FpDeviceTaskReturnType of @return_data
- * @return_data: (nullable) (transfer full): The data to return.
- *
- * Completes a #FpDevice task in an idle source, stealing the ownership of
- * the passed @returned_data.
- */
 static void
 fpi_device_return_task_in_idle (FpDevice              *device,
                                FpDeviceTaskReturnType return_type,
@@ -1112,7 +1120,7 @@ fpi_device_return_task_in_idle (FpDevice              *device,
 * @device: The #FpDevice
 * @device_id: Unique ID for the device or %NULL
 * @device_name: Human readable name or %NULL for driver name
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing probe operation. If error is %NULL success is assumed.
 */
@@ -1158,7 +1166,7 @@ fpi_device_probe_complete (FpDevice    *device,
 /**
 * fpi_device_open_complete:
 * @device: The #FpDevice
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing open operation. If error is %NULL success is assumed.
 */
@@ -1185,7 +1193,7 @@ fpi_device_open_complete (FpDevice *device, GError *error)
 /**
 * fpi_device_close_complete:
 * @device: The #FpDevice
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing close operation. If error is %NULL success is assumed.
 */
@@ -1237,7 +1245,7 @@ fpi_device_close_complete (FpDevice *device, GError *error)
 * fpi_device_enroll_complete:
 * @device: The #FpDevice
 * @print: (nullable) (transfer full): The #FpPrint or %NULL on failure
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing enroll operation. The #FpPrint can be stored by the
 * caller for later verification.
@@ -1303,14 +1311,12 @@ fpi_device_enroll_complete (FpDevice *device, FpPrint *print, GError *error)
 * @device: The #FpDevice
 * @error: A #GError if result is %FPI_MATCH_ERROR
 *
- * Finish an ongoing verify operation.
+ * Finish an ongoing verify operation. The returned print should be
+ * representing the new scan and not the one passed for verification.
 *
 * Note that @error should only be set for actual errors. In the case
 * of retry errors, report these using fpi_device_verify_report()
 * and then call this function without any error argument.
- *
- * If @error is not set, we expect that a result (and print, in case)
- * have been already reported via fpi_device_verify_report().
 */
 void
 fpi_device_verify_complete (FpDevice *device,
@@ -1366,16 +1372,11 @@ fpi_device_verify_complete (FpDevice *device,
 /**
 * fpi_device_identify_complete:
 * @device: The #FpDevice
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
- * Finish an ongoing identify operation.
- *
- * Note that @error should only be set for actual errors. In the case
- * of retry errors, report these using fpi_device_identify_report()
- * and then call this function without any error argument.
- *
- * If @error is not set, we expect that a match and / or a print have been
- * already reported via fpi_device_identify_report()
+ * Finish an ongoing identify operation. The match that was identified is
+ * returned in @match. The @print parameter returns the newly created scan
+ * that was used for matching.
 */
 void
 fpi_device_identify_complete (FpDevice *device,
@@ -1432,7 +1433,7 @@ fpi_device_identify_complete (FpDevice *device,
 * fpi_device_capture_complete:
 * @device: The #FpDevice
 * @image: The #FpImage, or %NULL on error
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing capture operation.
 */
@@ -1479,7 +1480,7 @@ fpi_device_capture_complete (FpDevice *device,
 /**
 * fpi_device_delete_complete:
 * @device: The #FpDevice
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing delete operation.
 */
@@ -1508,7 +1509,7 @@ fpi_device_delete_complete (FpDevice *device,
 * fpi_device_list_complete:
 * @device: The #FpDevice
 * @prints: (element-type FpPrint) (transfer container): Possibly empty array of prints or %NULL on error
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing list operation.
 *
@@ -1594,13 +1595,11 @@ update_attr (const char *attr, const char *value)
 static void
 complete_suspend_resume_task (FpDevice *device)
 {
-  g_autoptr(GTask) task = NULL;
  FpDevicePrivate *priv = fp_device_get_instance_private (device);

  g_assert (priv->suspend_resume_task);
-  task = g_steal_pointer (&priv->suspend_resume_task);

-  g_task_return_boolean (task, TRUE);
+  g_task_return_boolean (g_steal_pointer (&priv->suspend_resume_task), TRUE);
 }

 void
@@ -1704,9 +1703,9 @@ fpi_device_configure_wakeup (FpDevice *device, gboolean enabled)
    case FP_DEVICE_TYPE_USB:
      {
        g_autoptr(GString) ports = NULL;
-        g_autoptr(GUsbDevice) dev = NULL;
+        GUsbDevice *dev, *parent;
        const char *wakeup_command = enabled ? "enabled" : "disabled";
-        guint8 bus;
+        guint8 bus, port;
        g_autofree gchar *sysfs_wakeup = NULL;
        g_autofree gchar *sysfs_persist = NULL;
        int res;
@@ -1715,20 +1714,12 @@ fpi_device_configure_wakeup (FpDevice *device, gboolean enabled)
        bus = g_usb_device_get_bus (priv->usb_device);

        /* Walk up, skipping the root hub. */
-        g_set_object (&dev, priv->usb_device);
-        while (TRUE)
+        dev = priv->usb_device;
+        while ((parent = g_usb_device_get_parent (dev)))
          {
-            g_autoptr(GUsbDevice) parent = g_usb_device_get_parent (dev);
-            g_autofree gchar *port_str = NULL;
-            guint8 port;
-
-            if (!parent)
-              break;
-
            port = g_usb_device_get_port_number (dev);
-            port_str = g_strdup_printf ("%d.", port);
-            g_string_prepend (ports, port_str);
-            g_set_object (&dev, parent);
+            g_string_prepend (ports, g_strdup_printf ("%d.", port));
+            dev = parent;
          }
        g_string_set_size (ports, ports->len - 1);

@@ -1765,7 +1756,6 @@ fpi_device_configure_wakeup (FpDevice *device, gboolean enabled)
 static void
 fpi_device_suspend_completed (FpDevice *device)
 {
-  g_autoptr(GTask) task = NULL;
  FpDevicePrivate *priv = fp_device_get_instance_private (device);

  /* We have an ongoing operation, allow the device to wake up the machine. */
@@ -1775,18 +1765,17 @@ fpi_device_suspend_completed (FpDevice *device)
  if (priv->critical_section)
    g_warning ("Driver was in a critical section at suspend time. It likely deadlocked!");

-  task = g_steal_pointer (&priv->suspend_resume_task);
-
  if (priv->suspend_error)
-    g_task_return_error (task, g_steal_pointer (&priv->suspend_error));
+    g_task_return_error (g_steal_pointer (&priv->suspend_resume_task),
+                         g_steal_pointer (&priv->suspend_error));
  else
-    g_task_return_boolean (task, TRUE);
+    g_task_return_boolean (g_steal_pointer (&priv->suspend_resume_task), TRUE);
 }

 /**
 * fpi_device_suspend_complete:
 * @device: The #FpDevice
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish a suspend request. Only return a %NULL error if suspend has been
 * correctly configured and the current action as returned by
@@ -1808,12 +1797,11 @@ fpi_device_suspend_complete (FpDevice *device,
  g_return_if_fail (priv->suspend_resume_task);
  g_return_if_fail (priv->suspend_error == NULL);

-  priv->suspend_error = g_steal_pointer (&error);
+  priv->suspend_error = error;
  priv->is_suspended = TRUE;

  /* If there is no error, we have no running task, return immediately. */
-  if (!priv->suspend_error || !priv->current_task ||
-      g_task_get_completed (priv->current_task))
+  if (error == NULL || !priv->current_task || g_task_get_completed (priv->current_task))
    {
      fpi_device_suspend_completed (device);
      return;
@@ -1837,7 +1825,7 @@ fpi_device_suspend_complete (FpDevice *device,
 /**
 * fpi_device_resume_complete:
 * @device: The #FpDevice
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish a resume request.
 */
@@ -1845,7 +1833,6 @@ void
 fpi_device_resume_complete (FpDevice *device,
                            GError   *error)
 {
-  g_autoptr(GTask) task = NULL;
  FpDevicePrivate *priv = fp_device_get_instance_private (device);

  g_return_if_fail (FP_IS_DEVICE (device));
@@ -1854,18 +1841,16 @@ fpi_device_resume_complete (FpDevice *device,
  priv->is_suspended = FALSE;
  fpi_device_configure_wakeup (device, FALSE);

-  task = g_steal_pointer (&priv->suspend_resume_task);
-
  if (error)
-    g_task_return_error (task, error);
+    g_task_return_error (g_steal_pointer (&priv->suspend_resume_task), error);
  else
-    g_task_return_boolean (task, TRUE);
+    g_task_return_boolean (g_steal_pointer (&priv->suspend_resume_task), TRUE);
 }

 /**
 * fpi_device_clear_storage_complete:
 * @device: The #FpDevice
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: The #GError or %NULL on success
 *
 * Finish an ongoing clear_storage operation.
 */
@@ -1896,7 +1881,7 @@ fpi_device_clear_storage_complete (FpDevice *device,
 * @device: The #FpDevice
 * @completed_stages: The number of stages that are completed at this point
 * @print: (transfer floating): The #FpPrint for the newly completed stage or %NULL on failure
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: (transfer full): The #GError or %NULL on success
 *
 * Notify about the progress of the enroll operation. This is important for UI interaction.
 * The passed error may be used if a scan needs to be retried, use fpi_device_retry_new().
@@ -2016,26 +2001,12 @@ fpi_device_verify_report (FpDevice      *device,
 * fpi_device_identify_report:
 * @device: The #FpDevice
 * @match: (transfer none): The #FpPrint from the gallery that matched
- * @print: (transfer floating): The scanned #FpPrint, set in the absence
- *   of an error.
- * @error: A #GError of %FP_DEVICE_RETRY type if @match and @print are unset.
+ * @print: (transfer floating): The scanned #FpPrint
+ * @error: A #GError if result is %FPI_MATCH_ERROR
 *
- * Report the results of an identify operation.
- *
- * In case of successful identification @match is expected to be set to a
- * #FpPrint that matches one from the provided gallery, while @print
- * represents the scanned print and will be different.
- *
- * If there are no errors, it's expected that the device always reports the
- * recognized @print even if there is no @match with the provided gallery (that
- * can be potentially empty). This is required for application logic further
- * up in the stack, such as for enroll-duplicate checking. @print needs to be
- * sufficiently filled to do a comparison.
- *
- * In case of error, both @match and @print are expected to be %NULL.
- * Note that the passed @error must be a retry error from the %FP_DEVICE_RETRY
- * domain. For all other error cases, the error should passed to
- * fpi_device_identify_complete().
+ * Report the result of a identify operation. Note that the passed @error must be
+ * a retry error with the %FP_DEVICE_RETRY domain. For all other error cases,
+ * the error should passed to fpi_device_identify_complete().
 */
 void
 fpi_device_identify_report (FpDevice *device,
--- a/libfprint/fpi-image-device.c
+++ b/libfprint/fpi-image-device.c
@@ -277,7 +277,7 @@ fpi_image_device_minutiae_detected (GObject *source_object, GAsyncResult *res, g
    {
      print = fp_print_new (device);
      fpi_print_set_type (print, FPI_PRINT_NBIS);
-      if (!fpi_print_add_from_image (print, image, &error))
+      if (!fpi_print_add_from_image (print, image, priv->bz3_threshold, &error))
        {
          g_clear_object (&print);

@@ -565,7 +565,7 @@ fpi_image_device_retry_scan (FpImageDevice *self, FpDeviceRetry retry)
 /**
 * fpi_image_device_session_error:
 * @self: a #FpImageDevice imaging fingerprint device
- * @error: (nullable) (transfer full): The #GError to report.
+ * @error: The #GError to report
 *
 * Report an error while interacting with the device. This effectively
 * aborts the current ongoing action. Note that doing so will result in
@@ -624,7 +624,7 @@ fpi_image_device_session_error (FpImageDevice *self, GError *error)
 /**
 * fpi_image_device_activate_complete:
 * @self: a #FpImageDevice imaging fingerprint device
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: A #GError or %NULL on success
 *
 * Reports completion of device activation.
 */
@@ -663,7 +663,7 @@ fpi_image_device_activate_complete (FpImageDevice *self, GError *error)
 /**
 * fpi_image_device_deactivate_complete:
 * @self: a #FpImageDevice imaging fingerprint device
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: A #GError or %NULL on success
 *
 * Reports completion of device deactivation.
 */
@@ -690,7 +690,7 @@ fpi_image_device_deactivate_complete (FpImageDevice *self, GError *error)
 /**
 * fpi_image_device_open_complete:
 * @self: a #FpImageDevice imaging fingerprint device
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: A #GError or %NULL on success
 *
 * Reports completion of open operation.
 */
@@ -718,7 +718,7 @@ fpi_image_device_open_complete (FpImageDevice *self, GError *error)
 /**
 * fpi_image_device_close_complete:
 * @self: a #FpImageDevice imaging fingerprint device
- * @error: (nullable) (transfer full): The #GError or %NULL on success
+ * @error: A #GError or %NULL on success
 *
 * Reports completion of close operation.
 */
--- a/libfprint/fpi-image.c
+++ b/libfprint/fpi-image.c
@@ -24,9 +24,8 @@
 #include "fpi-log.h"

 #include <nbis.h>
-#include <config.h>

-#ifdef HAVE_PIXMAN
+#if HAVE_PIXMAN
 #include <pixman.h>
 #endif

@@ -108,12 +107,12 @@ fpi_mean_sq_diff_norm (const guint8 *buf1,
  return res / size;
 }

+#if HAVE_PIXMAN
 FpImage *
 fpi_image_resize (FpImage *orig_img,
                  guint    w_factor,
                  guint    h_factor)
 {
-#ifdef HAVE_PIXMAN
  int new_width = orig_img->width * w_factor;
  int new_height = orig_img->height * h_factor;
  pixman_image_t *orig, *resized;
@@ -146,9 +145,5 @@ fpi_image_resize (FpImage *orig_img,
  pixman_image_unref (resized);

  return newimg;
-#else
-  fp_err ("Libfprint compiled without pixman support, impossible to resize");
-
-  return g_object_ref (orig_img);
-#endif
 }
+#endif
--- a/libfprint/fpi-image.h
+++ b/libfprint/fpi-image.h
@@ -20,6 +20,7 @@

 #pragma once

+#include <config.h>
 #include "fp-image.h"

 /**
@@ -33,7 +34,6 @@
 * rely on the image to be normalized by libfprint before further processing.
 */
 typedef enum {
-  FPI_IMAGE_NONE            = 0,
  FPI_IMAGE_V_FLIPPED       = 1 << 0,
  FPI_IMAGE_H_FLIPPED       = 1 << 1,
  FPI_IMAGE_COLORS_INVERTED = 1 << 2,
@@ -68,8 +68,7 @@ struct _FpImage
  guint8    *binarized;

  GPtrArray *minutiae;
-
-  gboolean   detection_in_progress;
+  guint      ref_count;
 };

 gint fpi_std_sq_dev (const guint8 *buf,
@@ -78,6 +77,8 @@ gint fpi_mean_sq_diff_norm (const guint8 *buf1,
                            const guint8 *buf2,
                            gint          size);

+#if HAVE_PIXMAN
 FpImage *fpi_image_resize (FpImage *orig,
                           guint    w_factor,
                           guint    h_factor);
+#endif
--- a/libfprint/fpi-log.h
+++ b/libfprint/fpi-log.h
@@ -79,16 +79,13 @@
 *
 * Uses fp_err() to print an error if the @condition is true.
 */
-#define BUG_ON(condition) \
-  G_STMT_START          \
-  if (condition) \
-    {                        \
+#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
+    } G_STMT_END

 /**
 * BUG:
--- a/libfprint/fpi-print.c
+++ b/libfprint/fpi-print.c
@@ -50,7 +50,7 @@ fpi_print_add_print (FpPrint *print, FpPrint *add)
  g_return_if_fail (add->type == FPI_PRINT_NBIS);

  g_assert (add->prints->len == 1);
-  g_ptr_array_add (print->prints, g_memdup2 (add->prints->pdata[0], sizeof (struct xyt_struct)));
+  g_ptr_array_add (print->prints, g_memdup (add->prints->pdata[0], sizeof (struct xyt_struct)));
 }

 /**
@@ -154,11 +154,14 @@ minutiae_to_xyt (struct fp_minutiae *minutiae,
 gboolean
 fpi_print_add_from_image (FpPrint *print,
                          FpImage *image,
+                          gint     bz3_threshold,
                          GError **error)
 {
+  g_autofree struct xyt_struct *xyt = NULL;
  GPtrArray *minutiae;
  struct fp_minutiae _minutiae;
-  struct xyt_struct *xyt;
+  gint probe_len;
+  gint score;

  if (print->type != FPI_PRINT_NBIS || !image)
    {
@@ -173,8 +176,8 @@ fpi_print_add_from_image (FpPrint *print,
  if (!minutiae || minutiae->len == 0)
    {
      g_set_error (error,
-                   G_IO_ERROR,
-                   G_IO_ERROR_INVALID_DATA,
+                   FP_DEVICE_RETRY,
+                   FP_DEVICE_RETRY_GENERAL,
                   "No minutiae found in image or not yet detected!");
      return FALSE;
    }
@@ -185,7 +188,20 @@ fpi_print_add_from_image (FpPrint *print,

  xyt = g_new0 (struct xyt_struct, 1);
  minutiae_to_xyt (&_minutiae, image->width, image->height, xyt);
-  g_ptr_array_add (print->prints, xyt);
+
+  probe_len = bozorth_probe_init (xyt);
+  score = bozorth_to_gallery (probe_len, xyt, xyt);
+  fp_dbg ("self-match score %d/%d", score, bz3_threshold);
+  if (score <= bz3_threshold)
+    {
+      g_set_error (error,
+                   FP_DEVICE_RETRY,
+                   FP_DEVICE_RETRY_GENERAL,
+                   "Not enough minutiae to generate a match!");
+      return FPI_MATCH_SUCCESS;
+    }
+
+  g_ptr_array_add (print->prints, g_steal_pointer (&xyt));

  g_clear_object (&print->image);
  print->image = g_object_ref (image);
--- a/libfprint/fpi-print.h
+++ b/libfprint/fpi-print.h
@@ -40,11 +40,12 @@ void     fpi_print_set_device_stored (FpPrint *print,

 gboolean fpi_print_add_from_image (FpPrint *print,
                                   FpImage *image,
+                                   gint     bz3_threshold,
                                   GError **error);

-FpiMatchResult fpi_print_bz3_match (FpPrint *temp,
-                                    FpPrint *print,
-                                    gint     bz3_threshold,
+FpiMatchResult fpi_print_bz3_match (FpPrint * template,
+                                    FpPrint * print,
+                                    gint bz3_threshold,
                                    GError **error);

 /* Helpers to encode metadata into user ID strings. */
--- a/libfprint/fpi-ssm.c
+++ b/libfprint/fpi-ssm.c
@@ -73,7 +73,7 @@
 struct _FpiSsm
 {
  FpDevice               *dev;
-  char                   *name;
+  const char             *name;
  FpiSsm                 *parentsm;
  gpointer                ssm_data;
  GDestroyNotify          ssm_data_destroy;
--- a/libfprint/fprint-list-metainfo.c
+++ b/libfprint/fprint-list-metainfo.c
@@ -1,107 +0,0 @@
-/*
- * 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-supported-devices.c
+++ b/libfprint/fprint-list-supported-devices.c
@@ -110,7 +110,7 @@ main (int argc, char **argv)

  printed = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);

-  g_print ("%% libfprint — Supported Devices\n");
+  g_print ("%% lifprint — Supported Devices\n");
  g_print ("%% Bastien Nocera, Daniel Drake\n");
  g_print ("%% 2018\n");
  g_print ("\n");
@@ -132,7 +132,7 @@ main (int argc, char **argv)
    g_print ("%s", (char *) l->data);
  g_print ("\n");

-  g_list_free_full (g_steal_pointer (&usb_list), g_free);
+  g_list_free_full (usb_list, g_free);

  g_print ("## SPI devices\n");
  g_print ("\n");
@@ -146,7 +146,7 @@ main (int argc, char **argv)
    g_print ("%s", (char *) l->data);
  g_print ("\n");

-  g_list_free_full (g_steal_pointer (&spi_list), g_free);
+  g_list_free_full (usb_list, g_free);


  g_hash_table_destroy (printed);
--- a/libfprint/fprint-list-udev-hwdb.c
+++ b/libfprint/fprint-list-udev-hwdb.c
@@ -24,41 +24,17 @@
 #include "fpi-context.h"
 #include "fpi-device.h"

-static const FpIdEntry allowlist_id_table[] = {
+static const FpIdEntry whitelist_id_table[] = {
  /* Currently known and unsupported devices.
   * 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 },
  { .vid = 0x04f3, .pid = 0x0c4c },
  { .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 },
@@ -69,16 +45,15 @@ static const FpIdEntry allowlist_id_table[] = {
  { .vid = 0x06cb, .pid = 0x00b7 },
  { .vid = 0x06cb, .pid = 0x00bb },
  { .vid = 0x06cb, .pid = 0x00be },
+  { .vid = 0x06cb, .pid = 0x00c4 },
  { .vid = 0x06cb, .pid = 0x00cb },
  { .vid = 0x06cb, .pid = 0x00c9 },
  { .vid = 0x06cb, .pid = 0x00d8 },
  { .vid = 0x06cb, .pid = 0x00da },
  { .vid = 0x06cb, .pid = 0x00dc },
-  { .vid = 0x06cb, .pid = 0x00e4 },
  { .vid = 0x06cb, .pid = 0x00e7 },
  { .vid = 0x06cb, .pid = 0x00e9 },
  { .vid = 0x06cb, .pid = 0x00fd },
-  { .vid = 0x06cb, .pid = 0x00ff },
  { .vid = 0x0a5c, .pid = 0x5801 },
  { .vid = 0x0a5c, .pid = 0x5805 },
  { .vid = 0x0a5c, .pid = 0x5834 },
@@ -88,19 +63,9 @@ static const FpIdEntry allowlist_id_table[] = {
  { .vid = 0x0a5c, .pid = 0x5843 },
  { .vid = 0x0a5c, .pid = 0x5844 },
  { .vid = 0x0a5c, .pid = 0x5845 },
-  { .vid = 0x0a5c, .pid = 0x5860 },
-  { .vid = 0x0a5c, .pid = 0x5863 },
-  { .vid = 0x0a5c, .pid = 0x5864 },
-  { .vid = 0x0a5c, .pid = 0x5865 },
-  { .vid = 0x0a5c, .pid = 0x5866 },
-  { .vid = 0x0a5c, .pid = 0x5867 },
  { .vid = 0x0bda, .pid = 0x5812 },
  { .vid = 0x10a5, .pid = 0x0007 },
  { .vid = 0x10a5, .pid = 0x9200 },
-  { .vid = 0x10a5, .pid = 0x9800 },
-  { .vid = 0x10a5, .pid = 0xa120 },
-  { .vid = 0x10a5, .pid = 0xa900 },
-  { .vid = 0x10a5, .pid = 0xe340 },
  { .vid = 0x1188, .pid = 0x9545 },
  { .vid = 0x138a, .pid = 0x0007 },
  { .vid = 0x138a, .pid = 0x003a },
@@ -113,73 +78,51 @@ static const FpIdEntry allowlist_id_table[] = {
  { .vid = 0x138a, .pid = 0x0097 },
  { .vid = 0x138a, .pid = 0x009d },
  { .vid = 0x138a, .pid = 0x00ab },
-  { .vid = 0x138a, .pid = 0x00a6 },
  { .vid = 0x147e, .pid = 0x1002 },
  { .vid = 0x1491, .pid = 0x0088 },
  { .vid = 0x16d1, .pid = 0x1027 },
  { .vid = 0x1c7a, .pid = 0x0300 },
  { .vid = 0x1c7a, .pid = 0x0575 },
  { .vid = 0x1c7a, .pid = 0x0576 },
-  { .vid = 0x1c7a, .pid = 0x0584 },
-  { .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 },
-  { .vid = 0x27c6, .pid = 0x5120 },
-  { .vid = 0x27c6, .pid = 0x5125 },
  { .vid = 0x27c6, .pid = 0x5201 },
  { .vid = 0x27c6, .pid = 0x521d },
  { .vid = 0x27c6, .pid = 0x5301 },
  { .vid = 0x27c6, .pid = 0x530c },
  { .vid = 0x27c6, .pid = 0x532d },
-  { .vid = 0x27c6, .pid = 0x5335 },
  { .vid = 0x27c6, .pid = 0x533c },
  { .vid = 0x27c6, .pid = 0x5381 },
  { .vid = 0x27c6, .pid = 0x5385 },
  { .vid = 0x27c6, .pid = 0x538c },
  { .vid = 0x27c6, .pid = 0x538d },
  { .vid = 0x27c6, .pid = 0x5395 },
-  { .vid = 0x27c6, .pid = 0x5503 },
-  { .vid = 0x27c6, .pid = 0x550a },
-  { .vid = 0x27c6, .pid = 0x550c },
  { .vid = 0x27c6, .pid = 0x5584 },
  { .vid = 0x27c6, .pid = 0x55a2 },
  { .vid = 0x27c6, .pid = 0x55a4 },
  { .vid = 0x27c6, .pid = 0x55b4 },
  { .vid = 0x27c6, .pid = 0x5740 },
  { .vid = 0x27c6, .pid = 0x5e0a },
-  { .vid = 0x27c6, .pid = 0x581a },
-  { .vid = 0x27c6, .pid = 0x589a },
-  { .vid = 0x27c6, .pid = 0x5f10 },
-  { .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 = 0x298d, .pid = 0x2020 },
  { .vid = 0x298d, .pid = 0x2033 },
-  { .vid = 0x2df0, .pid = 0x0003 },
-  { .vid = 0x3274, .pid = 0x8012 },
  { .vid = 0x3538, .pid = 0x0930 },
  { .vid = 0 },
 };

-static const FpIdEntry denylist_id_table[] = {
+static const FpIdEntry blacklist_id_table[] = {
  { .vid = 0x0483, .pid = 0x2016 },
  /* https://bugs.freedesktop.org/show_bug.cgi?id=66659 */
  { .vid = 0x045e, .pid = 0x00bb },
  { .vid = 0 },
 };

-static const FpDeviceClass allowlist = {
+static const FpDeviceClass whitelist = {
  .type = FP_DEVICE_TYPE_USB,
-  .id_table = allowlist_id_table,
-  .id = "allowlist",
-  .full_name = "Hardcoded allowlist"
+  .id_table = whitelist_id_table,
+  .id = "whitelist",
+  .full_name = "Hardcoded whitelist"
 };

 GHashTable *printed = NULL;
@@ -198,7 +141,7 @@ print_driver (const FpDeviceClass *cls)
      const FpIdEntry *bl_entry;
      char *key;

-      for (bl_entry = denylist_id_table; bl_entry->vid != 0; bl_entry++)
+      for (bl_entry = blacklist_id_table; bl_entry->vid != 0; bl_entry++)
        if (entry->vid == bl_entry->vid && entry->pid == bl_entry->pid)
          break;

@@ -209,7 +152,7 @@ print_driver (const FpDeviceClass *cls)

      if (g_hash_table_lookup (printed, key) != NULL)
        {
-          if (cls == &allowlist)
+          if (cls == &whitelist)
            g_warning ("%s implemented by driver %s",
                       key, (const char *) g_hash_table_lookup (printed, key));
          g_free (key);
@@ -220,7 +163,7 @@ print_driver (const FpDeviceClass *cls)

      if (num_printed == 0)
        {
-          if (cls != &allowlist)
+          if (cls != &whitelist)
            g_print ("\n# Supported by libfprint driver %s\n", cls->id);
          else
            g_print ("\n# Known unsupported devices\n");
@@ -274,7 +217,7 @@ main (int argc, char **argv)
      print_driver (cls);
    }

-  print_driver (&allowlist);
+  print_driver (&whitelist);

  g_hash_table_destroy (printed);

--- a/libfprint/meson.build
+++ b/libfprint/meson.build
@@ -1,11 +1,3 @@
-spi_sources = []
-spi_headers = []
-
-if enabled_spi_drivers.length() > 0
-  spi_headers = ['fpi-spi-transfer.h']
-  spi_sources = ['fpi-spi-transfer.c']
-endif
-
 libfprint_sources = [
    'fp-context.c',
    'fp-device.c',
@@ -24,7 +16,8 @@ libfprint_private_sources = [
    'fpi-print.c',
    'fpi-ssm.c',
    'fpi-usb-transfer.c',
-] + spi_sources
+    'fpi-spi-transfer.c',
+]

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

 nbis_sources = [
    'nbis/bozorth3/bozorth3.c',
@@ -125,8 +119,6 @@ driver_sources = {
        [ 'drivers/etes603.c' ],
    'egis0570' :
        [ 'drivers/egis0570.c' ],
-    'egismoc' :
-        [ 'drivers/egismoc/egismoc.c' ],
    'vfs0050' :
        [ 'drivers/vfs0050.c' ],
    'elan' :
@@ -147,12 +139,6 @@ driver_sources = {
        [ 'drivers/synaptics/synaptics.c', 'drivers/synaptics/bmkt_message.c' ],
    'goodixmoc' :
        [ 'drivers/goodixmoc/goodix.c', 'drivers/goodixmoc/goodix_proto.c' ],
-    'fpcmoc' :
-        [ 'drivers/fpcmoc/fpc.c' ],
-    'realtek' :
-        [ 'drivers/realtek/realtek.c' ],
-    'focaltech_moc' :
-        [ 'drivers/focaltech_moc/focaltech_moc.c' ],
 }

 helper_sources = {
@@ -162,7 +148,7 @@ helper_sources = {
        [ 'drivers/aesx660.c' ],
    'aes3k' :
        [ 'drivers/aes3k.c' ],
-    'openssl' :
+    'nss' :
        [ ],
    'udev' :
        [ ],
@@ -274,13 +260,8 @@ libfprint_drivers = static_library('fprint-drivers',
    link_with: libfprint_private,
    install: false)

-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)
+mapfile = files('libfprint.ver')
+vflag = '-Wl,--version-script,@0@/@1@'.format(meson.source_root(), mapfile[0])

 libfprint = shared_library(versioned_libname.split('lib')[1],
    sources: [
@@ -332,21 +313,6 @@ 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',
@@ -364,19 +330,17 @@ if install_udev_rules
    )
 endif

-sync_udev_udb = custom_target('sync-udev-hwdb',
+custom_target('sync-udev-hwdb',
    depends: udev_hwdb_generator,
    output: 'sync-udev-hwdb',
    install: false,
    command: [
        'cp', '-v',
        udev_hwdb_generator.full_path(),
-        meson.project_source_root() / 'data'
+        meson.source_root() / 'data'
    ]
 )

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

 /**************************************************************************/
 /* In: BZ_GBLS.C */
--- a/libfprint/nbis/update-from-nbis.sh
+++ b/libfprint/nbis/update-from-nbis.sh
@@ -198,6 +198,3 @@ patch -p0 < fix-scan-build-reports.patch

 # Add pass to remove perimeter points
 patch -p0 < remove-perimeter-pts.patch
-
-# Fix build on musl by dropping unnecessary redeclaration of stderr
-patch -p0 < fix-musl-build.patch
--- a/meson.build
+++ b/meson.build
@@ -1,38 +1,27 @@
 project('libfprint', [ 'c', 'cpp' ],
-    version: '1.94.9',
+    version: '1.94.3',
    license: 'LGPLv2.1+',
    default_options: [
        'buildtype=debugoptimized',
        'warning_level=1',
        'c_std=gnu99',
    ],
-    meson_version: '>= 0.59.0')
+    meson_version: '>= 0.49.0')

-fs = import('fs')
 gnome = import('gnome')

 libfprint_conf = configuration_data()
 libfprint_conf.set_quoted('LIBFPRINT_VERSION', meson.project_version())

-prefix = get_option('prefix')
-libdir = prefix / get_option('libdir')
-libexecdir = prefix / get_option('libexecdir')
-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_min_version = '2.56'

 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',
@@ -97,15 +86,11 @@ gusb_dep = dependency('gusb', version: '>= 0.2.0')
 mathlib_dep = cc.find_library('m', required: false)

 # The following dependencies are only used for tests
-sh = find_program('sh', required: true)
 cairo_dep = dependency('cairo', required: false)

 # introspection scanning and Gio-2.0.gir
 gobject_introspection = dependency('gobject-introspection-1.0', required: get_option('introspection'))

-# SPI
-have_spi = host_machine.system() == 'linux'
-
 # Drivers
 drivers = get_option('drivers').split(',')
 virtual_drivers = [
@@ -130,7 +115,6 @@ default_drivers = [
    'vfs0050',
    'etes603',
    'egis0570',
-    'egismoc',
    'vcom5s',
    'synaptics',
    'elan',
@@ -141,43 +125,16 @@ default_drivers = [
    'upekts',
    'goodixmoc',
    'nb1010',
-    'fpcmoc',
-    'realtek',
-    'focaltech_moc',
-]

-spi_drivers = [
-    'elanspi'
+    # SPI
+    'elanspi',
 ]

-if have_spi
-    default_drivers += spi_drivers
-endif
-
 # FIXME: All the drivers should be fixed by adjusting the byte order.
 # See https://gitlab.freedesktop.org/libfprint/libfprint/-/issues/236
 endian_independent_drivers = virtual_drivers + [
-    'aes1610',
-    'aes1660',
-    'aes2550',
-    'aes2660',
    'aes3500',
-    'aes4000',
-    'egis0570',
-    'egismoc',
-    'elanmoc',
-    'etes603',
-    'focaltech_moc',
-    'nb1010',
-    'realtek',
    'synaptics',
-    'upeksonly',
-    'upektc',
-    'upektc_img',
-    'upekts',
-    'vcom5s',
-    'vfs101',
-    'vfs7552',
 ]

 all_drivers = default_drivers + virtual_drivers
@@ -190,17 +147,6 @@ if drivers == [ 'default' ]
    drivers = default_drivers
 endif

-enabled_spi_drivers = []
-foreach driver : spi_drivers
-    if driver in drivers
-        enabled_spi_drivers += driver
-    endif
-endforeach
-
-if enabled_spi_drivers.length() > 0 and not have_spi
-    error('SPI drivers @0@ are not supported'.format(enabled_spi_drivers))
-endif
-
 driver_helper_mapping = {
    'aes1610' : [ 'aeslib' ],
    'aes1660' : [ 'aeslib', 'aesx660' ],
@@ -209,7 +155,7 @@ driver_helper_mapping = {
    'aes2660' : [ 'aeslib', 'aesx660' ],
    'aes3500' : [ 'aeslib', 'aes3k' ],
    'aes4000' : [ 'aeslib', 'aes3k' ],
-    'uru4000' : [ 'openssl' ],
+    'uru4000' : [ 'nss' ],
    'elanspi' : [ 'udev' ],
    'virtual_image'          : [ 'virtual' ],
    'virtual_device'         : [ 'virtual' ],
@@ -266,13 +212,13 @@ foreach i : driver_helpers

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

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

@@ -295,7 +241,7 @@ if install_udev_rules
    udev_rules_dir = get_option('udev_rules_dir')
    if udev_rules_dir == 'auto'
        udev_dep = dependency('udev')
-        udev_rules_dir = udev_dep.get_variable(pkgconfig: 'udevdir') + '/rules.d'
+        udev_rules_dir = udev_dep.get_pkgconfig_variable('udevdir') + '/rules.d'
    endif
 endif

@@ -332,13 +278,15 @@ if not udev_hwdb.disabled()

    if udev_hwdb_dir == 'auto'
        udev_dep = dependency('udev')
-        udev_hwdb_dir = udev_dep.get_variable(pkgconfig: 'udevdir') + '/hwdb.d'
+        udev_hwdb_dir = udev_dep.get_pkgconfig_variable('udevdir') + '/hwdb.d'
    endif
 else
    udev_hwdb_dir = ''
 endif

 if get_option('gtk-examples')
+    gnome = import('gnome')
+
    gtk_dep = dependency('gtk+-3.0', required: false)
    if not gtk_dep.found()
        error('GTK+ 3.x is required for GTK+ examples')
@@ -350,7 +298,9 @@ subdir('libfprint')

 configure_file(output: 'config.h', configuration: libfprint_conf)

+subdir('examples')
 if get_option('doc')
+    gnome = import('gnome')
    subdir('doc')
 endif
 if get_option('gtk-examples')
@@ -360,8 +310,6 @@ endif
 subdir('data')
 subdir('tests')

-subdir('examples')
-
 pkgconfig = import('pkgconfig')
 pkgconfig.generate(
    name: versioned_libname,
@@ -372,5 +320,3 @@ pkgconfig.generate(
    subdirs: versioned_libname,
    filebase: versioned_libname,
 )
-
-summary({'Drivers': drivers, }, section: 'Drivers')
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -30,7 +30,3 @@ option('doc',
       description: 'Whether to build the API documentation',
       type: 'boolean',
       value: true)
-option('installed-tests',
-       description: 'Whether to install the installed tests',
-       type: 'boolean',
-       value: true)
--- a/scripts/uncrustify.cfg
+++ b/scripts/uncrustify.cfg
@@ -19,7 +19,6 @@ 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
@@ -115,14 +114,13 @@ 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
 # Not clear what to do about that...
 mod_full_brace_for              Remove
 mod_full_brace_if               Remove
-mod_full_brace_if_chain         1
+mod_full_brace_if_chain         True
 mod_full_brace_while            Remove
 mod_full_brace_do               Remove
 mod_full_brace_nl               3
--- a/tests/capture.py
+++ b/tests/capture.py
@@ -1,15 +1,10 @@
 #!/usr/bin/python3

-import cairo
-import sys
-import traceback
 import gi
-
 gi.require_version('FPrint', '2.0')
 from gi.repository import FPrint, GLib
-
-# Exit with error on any exception, included those happening in async callbacks
-sys.excepthook = lambda *args: (traceback.print_exception(*args), sys.exit(1))
+import cairo
+import sys

 if len(sys.argv) != 2:
    print("Please specify exactly one argument, the output location for the capture image")
--- a/tests/create-driver-test.py.in
+++ b/tests/create-driver-test.py.in
@@ -44,7 +44,7 @@ if len(sys.argv) > 3:
    sys.exit(1)

 driver_name = sys.argv[1]
-os.environ['FP_DRIVERS_ALLOWLIST'] = driver_name
+os.environ['FP_DRIVERS_WHITELIST'] = driver_name

 test_variant = None
 if len(sys.argv) == 3:
--- a/tests/driver.test.in
+++ b/tests/driver.test.in
@@ -1,5 +0,0 @@
-[Test]
-Type=session
-# We can't use TestEnvironment as per
-#  https://gitlab.gnome.org/GNOME/gnome-desktop-testing/-/issues/1
-Exec=env @driver_env@ @installed_tests_execdir@/@umockdev_test_name@ @installed_tests_testdir@/@driver_test@
--- a/tests/egis0570/capture.pcapng
+++ b/tests/egis0570/capture.pcapng
--- a/tests/egis0570/device
+++ b/tests/egis0570/device
@@ -24,7 +24,7 @@ E: ID_USB_INTERFACES=:ff0000:
 E: ID_VENDOR_FROM_DATABASE=LighTuning Technology Inc.
 E: ID_PATH=pci-0000:00:14.0-usb-0:9
 E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_9
-E: LIBFPRINT_DRIVER=Hardcoded allowlist
+E: LIBFPRINT_DRIVER=Hardcoded whitelist
 A: authorized=1\n
 A: avoid_reset_quirk=0\n
 A: bConfigurationValue=1\n
--- a/tests/egismoc-0586/custom.pcapng
+++ b/tests/egismoc-0586/custom.pcapng
--- a/tests/egismoc-0586/custom.py
+++ b/tests/egismoc-0586/custom.py
@@ -1,156 +0,0 @@
-#!/usr/bin/python3
-
-import traceback
-import sys
-import time
-import gi
-
-gi.require_version('FPrint', '2.0')
-from gi.repository import FPrint, GLib
-
-# Exit with error on any exception, included those happening in async callbacks
-sys.excepthook = lambda *args: (traceback.print_exception(*args), sys.exit(1))
-
-ctx = GLib.main_context_default()
-
-c = FPrint.Context()
-c.enumerate()
-devices = c.get_devices()
-
-d = devices[0]
-del devices
-
-d.open_sync()
-
-assert d.get_driver() == "egismoc"
-assert not d.has_feature(FPrint.DeviceFeature.CAPTURE)
-assert d.has_feature(FPrint.DeviceFeature.IDENTIFY)
-assert d.has_feature(FPrint.DeviceFeature.VERIFY)
-assert d.has_feature(FPrint.DeviceFeature.DUPLICATES_CHECK)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE_LIST)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE_DELETE)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE_CLEAR)
-
-def enroll_progress(*args):
-    print("finger status: ", d.get_finger_status())
-    print('enroll progress: ' + str(args))
-
-def identify_done(dev, res):
-    global identified
-    identified = True
-    identify_match, identify_print = dev.identify_finish(res)
-    print('indentification_done: ', identify_match, identify_print)
-    assert identify_match.equal(identify_print)
-
-# Beginning with list and clear assumes you begin with >0 prints enrolled before capturing
-
-print("listing - device should have prints")
-stored = d.list_prints_sync()
-assert len(stored) > 0
-del stored
-
-print("clear device storage")
-d.clear_storage_sync()
-print("clear done")
-
-print("listing - device should be empty")
-stored = d.list_prints_sync()
-assert len(stored) == 0
-del stored
-
-print("enrolling")
-template = FPrint.Print.new(d)
-template.set_finger(FPrint.Finger.LEFT_INDEX)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-p1 = d.enroll_sync(template, None, enroll_progress, None)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("enroll done")
-del template
-
-print("listing - device should have 1 print")
-stored = d.list_prints_sync()
-assert len(stored) == 1
-assert stored[0].equal(p1)
-
-print("verifying")
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-verify_res, verify_print = d.verify_sync(p1)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("verify done")
-assert verify_res == True
-
-identified = False
-deserialized_prints = []
-for p in stored:
-    deserialized_prints.append(FPrint.Print.deserialize(p.serialize()))
-    assert deserialized_prints[-1].equal(p)
-del stored
-
-print('async identifying')
-d.identify(deserialized_prints, callback=identify_done)
-del deserialized_prints
-
-while not identified:
-    ctx.iteration(True)
-
-print("try to enroll duplicate")
-template = FPrint.Print.new(d)
-template.set_finger(FPrint.Finger.RIGHT_INDEX)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-try:
-    d.enroll_sync(template, None, enroll_progress, None)
-except GLib.Error as error:
-    assert error.matches(FPrint.DeviceError.quark(),
-                         FPrint.DeviceError.DATA_DUPLICATE)
-except Exception as exc:
-    raise
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("duplicate enroll attempt done")
-
-print("listing - device should still only have 1 print")
-stored = d.list_prints_sync()
-assert len(stored) == 1
-assert stored[0].equal(p1)
-del stored
-
-print("enroll new finger")
-template = FPrint.Print.new(d)
-template.set_finger(FPrint.Finger.RIGHT_INDEX)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-p2 = d.enroll_sync(template, None, enroll_progress, None)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("enroll new finger done")
-del template
-
-print("listing - device should have 2 prints")
-stored = d.list_prints_sync()
-assert len(stored) == 2
-assert (stored[0].equal(p1) and stored[1].equal(p2)) or (stored[0].equal(p2) and stored[1].equal(p1))
-del stored
-
-print("deleting first print")
-d.delete_print_sync(p1)
-print("delete done")
-del p1
-
-print("listing - device should only have second print")
-stored = d.list_prints_sync()
-assert len(stored) == 1
-assert stored[0].equal(p2)
-del stored
-del p2
-
-print("clear device storage")
-d.clear_storage_sync()
-print("clear done")
-
-print("listing - device should be empty")
-stored = d.list_prints_sync()
-assert len(stored) == 0
-del stored
-
-d.close_sync()
-
-del d
-del c
--- a/tests/egismoc-0586/device
+++ b/tests/egismoc-0586/device
@@ -1,255 +0,0 @@
-P: /devices/pci0000:00/0000:00:14.0/usb1/1-7
-N: bus/usb/001/021=12010002FF0000407A1C860556620102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
-E: BUSNUM=001
-E: DEVNAME=/dev/bus/usb/001/021
-E: DEVNUM=021
-E: DEVTYPE=usb_device
-E: DRIVER=usb
-E: ID_AUTOSUSPEND=1
-E: ID_BUS=usb
-E: ID_MODEL=ETU905A88-E
-E: ID_MODEL_ENC=ETU905A88-E
-E: ID_MODEL_ID=0586
-E: ID_PATH=pci-0000:00:14.0-usb-0:7
-E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_7
-E: ID_PATH_WITH_USB_REVISION=pci-0000:00:14.0-usbv2-0:7
-E: ID_PERSIST=0
-E: ID_REVISION=6256
-E: ID_SERIAL=EGIS_ETU905A88-E_0A5743PCU834
-E: ID_SERIAL_SHORT=0A5743PCU834
-E: ID_USB_INTERFACES=:ff0000:
-E: ID_USB_MODEL=ETU905A88-E
-E: ID_USB_MODEL_ENC=ETU905A88-E
-E: ID_USB_MODEL_ID=0586
-E: ID_USB_REVISION=6256
-E: ID_USB_SERIAL=EGIS_ETU905A88-E_0A5743PCU834
-E: ID_USB_SERIAL_SHORT=0A5743PCU834
-E: ID_USB_VENDOR=EGIS
-E: ID_USB_VENDOR_ENC=EGIS
-E: ID_USB_VENDOR_ID=1c7a
-E: ID_VENDOR=EGIS
-E: ID_VENDOR_ENC=EGIS
-E: ID_VENDOR_FROM_DATABASE=LighTuning Technology Inc.
-E: ID_VENDOR_ID=1c7a
-E: MAJOR=189
-E: MINOR=20
-E: PRODUCT=1c7a/586/6256
-E: SUBSYSTEM=usb
-E: TYPE=255/0/0
-A: authorized=1\n
-A: avoid_reset_quirk=0\n
-A: bConfigurationValue=1\n
-A: bDeviceClass=ff\n
-A: bDeviceProtocol=00\n
-A: bDeviceSubClass=00\n
-A: bMaxPacketSize0=64\n
-A: bMaxPower=100mA\n
-A: bNumConfigurations=1\n
-A: bNumInterfaces= 1\n
-A: bcdDevice=6256\n
-A: bmAttributes=a0\n
-A: busnum=1\n
-A: configuration=
-H: descriptors=12010002FF0000407A1C860556620102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
-A: dev=189:20\n
-A: devnum=21\n
-A: devpath=7\n
-L: driver=../../../../../bus/usb/drivers/usb
-L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4e/device:4f/device:56
-A: idProduct=0586\n
-A: idVendor=1c7a\n
-A: ltm_capable=no\n
-A: manufacturer=EGIS\n
-A: maxchild=0\n
-A: physical_location/dock=no\n
-A: physical_location/horizontal_position=center\n
-A: physical_location/lid=no\n
-A: physical_location/panel=front\n
-A: physical_location/vertical_position=center\n
-L: port=../1-0:1.0/usb1-port7
-A: power/active_duration=12644\n
-A: power/autosuspend=2\n
-A: power/autosuspend_delay_ms=2000\n
-A: power/connected_duration=230907\n
-A: power/control=auto\n
-A: power/level=auto\n
-A: power/persist=0\n
-A: power/runtime_active_time=12929\n
-A: power/runtime_status=active\n
-A: power/runtime_suspended_time=217715\n
-A: power/wakeup=disabled\n
-A: power/wakeup_abort_count=\n
-A: power/wakeup_active=\n
-A: power/wakeup_active_count=\n
-A: power/wakeup_count=\n
-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=ETU905A88-E\n
-A: quirks=0x0\n
-A: removable=fixed\n
-A: rx_lanes=1\n
-A: serial=0A5743PCU834\n
-A: speed=480\n
-A: tx_lanes=1\n
-A: urbnum=18\n
-A: version= 2.00\n
-
-P: /devices/pci0000:00/0000:00:14.0/usb1
-N: bus/usb/001/001=12010002090001406B1D020008060302010109021900010100E0000904000001090000000705810304000C
-E: BUSNUM=001
-E: CURRENT_TAGS=:seat:
-E: DEVNAME=/dev/bus/usb/001/001
-E: DEVNUM=001
-E: DEVTYPE=usb_device
-E: DRIVER=usb
-E: ID_AUTOSUSPEND=1
-E: ID_BUS=usb
-E: ID_FOR_SEAT=usb-pci-0000_00_14_0
-E: ID_MODEL=xHCI_Host_Controller
-E: ID_MODEL_ENC=xHCI\x20Host\x20Controller
-E: ID_MODEL_FROM_DATABASE=2.0 root hub
-E: ID_MODEL_ID=0002
-E: ID_PATH=pci-0000:00:14.0
-E: ID_PATH_TAG=pci-0000_00_14_0
-E: ID_REVISION=0608
-E: ID_SERIAL=Linux_6.8.5-arch1-1_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
-E: ID_SERIAL_SHORT=0000:00:14.0
-E: ID_USB_INTERFACES=:090000:
-E: ID_USB_MODEL=xHCI_Host_Controller
-E: ID_USB_MODEL_ENC=xHCI\x20Host\x20Controller
-E: ID_USB_MODEL_ID=0002
-E: ID_USB_REVISION=0608
-E: ID_USB_SERIAL=Linux_6.8.5-arch1-1_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
-E: ID_USB_SERIAL_SHORT=0000:00:14.0
-E: ID_USB_VENDOR=Linux_6.8.5-arch1-1_xhci-hcd
-E: ID_USB_VENDOR_ENC=Linux\x206.8.5-arch1-1\x20xhci-hcd
-E: ID_USB_VENDOR_ID=1d6b
-E: ID_VENDOR=Linux_6.8.5-arch1-1_xhci-hcd
-E: ID_VENDOR_ENC=Linux\x206.8.5-arch1-1\x20xhci-hcd
-E: ID_VENDOR_FROM_DATABASE=Linux Foundation
-E: ID_VENDOR_ID=1d6b
-E: MAJOR=189
-E: MINOR=0
-E: PRODUCT=1d6b/2/608
-E: SUBSYSTEM=usb
-E: TAGS=:seat:
-E: TYPE=9/0/1
-A: authorized=1\n
-A: authorized_default=1\n
-A: avoid_reset_quirk=0\n
-A: bConfigurationValue=1\n
-A: bDeviceClass=09\n
-A: bDeviceProtocol=01\n
-A: bDeviceSubClass=00\n
-A: bMaxPacketSize0=64\n
-A: bMaxPower=0mA\n
-A: bNumConfigurations=1\n
-A: bNumInterfaces= 1\n
-A: bcdDevice=0608\n
-A: bmAttributes=e0\n
-A: busnum=1\n
-A: configuration=
-H: descriptors=12010002090001406B1D020008060302010109021900010100E0000904000001090000000705810304000C
-A: dev=189:0\n
-A: devnum=1\n
-A: devpath=0\n
-L: driver=../../../../bus/usb/drivers/usb
-L: firmware_node=../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4e/device:4f
-A: idProduct=0002\n
-A: idVendor=1d6b\n
-A: interface_authorized_default=1\n
-A: ltm_capable=no\n
-A: manufacturer=Linux 6.8.5-arch1-1 xhci-hcd\n
-A: maxchild=12\n
-A: power/active_duration=73066477\n
-A: power/autosuspend=0\n
-A: power/autosuspend_delay_ms=0\n
-A: power/connected_duration=73071614\n
-A: power/control=auto\n
-A: power/level=auto\n
-A: power/runtime_active_time=73070027\n
-A: power/runtime_status=active\n
-A: power/runtime_suspended_time=0\n
-A: power/wakeup=disabled\n
-A: power/wakeup_abort_count=\n
-A: power/wakeup_active=\n
-A: power/wakeup_active_count=\n
-A: power/wakeup_count=\n
-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=xHCI Host Controller\n
-A: quirks=0x0\n
-A: removable=unknown\n
-A: rx_lanes=1\n
-A: serial=0000:00:14.0\n
-A: speed=480\n
-A: tx_lanes=1\n
-A: urbnum=1111\n
-A: version= 2.00\n
-
-P: /devices/pci0000:00/0000:00:14.0
-E: DRIVER=xhci_hcd
-E: ID_AUTOSUSPEND=1
-E: ID_MODEL_FROM_DATABASE=Alder Lake PCH USB 3.2 xHCI Host Controller
-E: ID_PATH=pci-0000:00:14.0
-E: ID_PATH_TAG=pci-0000_00_14_0
-E: ID_PCI_CLASS_FROM_DATABASE=Serial bus controller
-E: ID_PCI_INTERFACE_FROM_DATABASE=XHCI
-E: ID_PCI_SUBCLASS_FROM_DATABASE=USB controller
-E: ID_VENDOR_FROM_DATABASE=Intel Corporation
-E: MODALIAS=pci:v00008086d000051EDsv00001043sd0000201Fbc0Csc03i30
-E: PCI_CLASS=C0330
-E: PCI_ID=8086:51ED
-E: PCI_SLOT_NAME=0000:00:14.0
-E: PCI_SUBSYS_ID=1043:201F
-E: SUBSYSTEM=pci
-A: ari_enabled=0\n
-A: broken_parity_status=0\n
-A: class=0x0c0330\n
-H: config=8680ED51060490020130030C000080000400220560000000000000000000000000000000000000000000000043101F20000000007000000000000000FF010000FD0134A089C27F8000000000000000003F6DD80F000000000000000000000000316000000000000000000000000000000180C2C10800000000000000000000000590B7001805E0FE000000000000000009B014F01000400100000000C10A080000080E00001800008F50020000010000090000018680C00009001014000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B50F110112000000
-A: consistent_dma_mask_bits=64\n
-A: d3cold_allowed=1\n
-A: device=0x51ed\n
-A: dma_mask_bits=64\n
-L: driver=../../../bus/pci/drivers/xhci_hcd
-A: driver_override=(null)\n
-A: enable=1\n
-L: firmware_node=../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4e
-A: irq=143\n
-A: local_cpulist=0-15\n
-A: local_cpus=ffff\n
-A: modalias=pci:v00008086d000051EDsv00001043sd0000201Fbc0Csc03i30\n
-A: msi_bus=1\n
-A: msi_irqs/143=msi\n
-A: msi_irqs/144=msi\n
-A: msi_irqs/145=msi\n
-A: msi_irqs/146=msi\n
-A: msi_irqs/147=msi\n
-A: msi_irqs/148=msi\n
-A: msi_irqs/149=msi\n
-A: msi_irqs/150=msi\n
-A: numa_node=-1\n
-A: pools=poolinfo - 0.1\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          0    0  128  0\nbuffer-32           0    0   32  0\nxHCI 1KB stream ctx arrays    0    0 1024  0\nxHCI 256 byte stream ctx arrays    0    0  256  0\nxHCI input/output contexts    8    9 2112  9\nxHCI ring segments   43   53 4096 53\nbuffer-2048         0   16 2048  8\nbuffer-512          0    0  512  0\nbuffer-128          0    0  128  0\nbuffer-32           0  128   32  1\n
-A: power/control=auto\n
-A: power/runtime_active_time=73070690\n
-A: power/runtime_status=active\n
-A: power/runtime_suspended_time=0\n
-A: power/wakeup=enabled\n
-A: power/wakeup_abort_count=0\n
-A: power/wakeup_active=0\n
-A: power/wakeup_active_count=0\n
-A: power/wakeup_count=0\n
-A: power/wakeup_expire_count=0\n
-A: power/wakeup_last_time_ms=0\n
-A: power/wakeup_max_time_ms=0\n
-A: power/wakeup_total_time_ms=0\n
-A: power_state=D0\n
-A: resource=0x0000006005220000 0x000000600522ffff 0x0000000000140204\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n
-A: revision=0x01\n
-A: subsystem_device=0x201f\n
-A: subsystem_vendor=0x1043\n
-A: vendor=0x8086\n
--- a/tests/egismoc-0587/custom.pcapng
+++ b/tests/egismoc-0587/custom.pcapng
--- a/tests/egismoc-0587/custom.py
+++ b/tests/egismoc-0587/custom.py
@@ -1,156 +0,0 @@
-#!/usr/bin/python3
-
-import traceback
-import sys
-import time
-import gi
-
-gi.require_version('FPrint', '2.0')
-from gi.repository import FPrint, GLib
-
-# Exit with error on any exception, included those happening in async callbacks
-sys.excepthook = lambda *args: (traceback.print_exception(*args), sys.exit(1))
-
-ctx = GLib.main_context_default()
-
-c = FPrint.Context()
-c.enumerate()
-devices = c.get_devices()
-
-d = devices[0]
-del devices
-
-d.open_sync()
-
-assert d.get_driver() == "egismoc"
-assert not d.has_feature(FPrint.DeviceFeature.CAPTURE)
-assert d.has_feature(FPrint.DeviceFeature.IDENTIFY)
-assert d.has_feature(FPrint.DeviceFeature.VERIFY)
-assert d.has_feature(FPrint.DeviceFeature.DUPLICATES_CHECK)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE_LIST)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE_DELETE)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE_CLEAR)
-
-def enroll_progress(*args):
-    print("finger status: ", d.get_finger_status())
-    print('enroll progress: ' + str(args))
-
-def identify_done(dev, res):
-    global identified
-    identified = True
-    identify_match, identify_print = dev.identify_finish(res)
-    print('indentification_done: ', identify_match, identify_print)
-    assert identify_match.equal(identify_print)
-
-# Beginning with list and clear assumes you begin with >0 prints enrolled before capturing
-
-print("listing - device should have prints")
-stored = d.list_prints_sync()
-assert len(stored) > 0
-del stored
-
-print("clear device storage")
-d.clear_storage_sync()
-print("clear done")
-
-print("listing - device should be empty")
-stored = d.list_prints_sync()
-assert len(stored) == 0
-del stored
-
-print("enrolling")
-template = FPrint.Print.new(d)
-template.set_finger(FPrint.Finger.LEFT_INDEX)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-p1 = d.enroll_sync(template, None, enroll_progress, None)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("enroll done")
-del template
-
-print("listing - device should have 1 print")
-stored = d.list_prints_sync()
-assert len(stored) == 1
-assert stored[0].equal(p1)
-
-print("verifying")
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-verify_res, verify_print = d.verify_sync(p1)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("verify done")
-assert verify_res == True
-
-identified = False
-deserialized_prints = []
-for p in stored:
-    deserialized_prints.append(FPrint.Print.deserialize(p.serialize()))
-    assert deserialized_prints[-1].equal(p)
-del stored
-
-print('async identifying')
-d.identify(deserialized_prints, callback=identify_done)
-del deserialized_prints
-
-while not identified:
-    ctx.iteration(True)
-
-print("try to enroll duplicate")
-template = FPrint.Print.new(d)
-template.set_finger(FPrint.Finger.RIGHT_INDEX)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-try:
-    d.enroll_sync(template, None, enroll_progress, None)
-except GLib.Error as error:
-    assert error.matches(FPrint.DeviceError.quark(),
-                         FPrint.DeviceError.DATA_DUPLICATE)
-except Exception as exc:
-    raise
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("duplicate enroll attempt done")
-
-print("listing - device should still only have 1 print")
-stored = d.list_prints_sync()
-assert len(stored) == 1
-assert stored[0].equal(p1)
-del stored
-
-print("enroll new finger")
-template = FPrint.Print.new(d)
-template.set_finger(FPrint.Finger.RIGHT_INDEX)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-p2 = d.enroll_sync(template, None, enroll_progress, None)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("enroll new finger done")
-del template
-
-print("listing - device should have 2 prints")
-stored = d.list_prints_sync()
-assert len(stored) == 2
-assert (stored[0].equal(p1) and stored[1].equal(p2)) or (stored[0].equal(p2) and stored[1].equal(p1))
-del stored
-
-print("deleting first print")
-d.delete_print_sync(p1)
-print("delete done")
-del p1
-
-print("listing - device should only have second print")
-stored = d.list_prints_sync()
-assert len(stored) == 1
-assert stored[0].equal(p2)
-del stored
-del p2
-
-print("clear device storage")
-d.clear_storage_sync()
-print("clear done")
-
-print("listing - device should be empty")
-stored = d.list_prints_sync()
-assert len(stored) == 0
-del stored
-
-d.close_sync()
-
-del d
-del c
--- a/tests/egismoc-0587/device
+++ b/tests/egismoc-0587/device
@@ -1,270 +0,0 @@
-P: /devices/pci0000:00/0000:00:14.0/usb3/3-5
-N: bus/usb/003/009=12010002FF0000407A1C870567640102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
-E: BUSNUM=003
-E: DEVNAME=/dev/bus/usb/003/009
-E: DEVNUM=009
-E: DEVTYPE=usb_device
-E: DRIVER=usb
-E: ID_AUTOSUSPEND=1
-E: ID_BUS=usb
-E: ID_MODEL=ETU905A88-E
-E: ID_MODEL_ENC=ETU905A88-E
-E: ID_MODEL_ID=0587
-E: ID_PATH=pci-0000:00:14.0-usb-0:5
-E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_5
-E: ID_PATH_WITH_USB_REVISION=pci-0000:00:14.0-usbv2-0:5
-E: ID_PERSIST=0
-E: ID_REVISION=6467
-E: ID_SERIAL=EGIS_ETU905A88-E_198427PCU834
-E: ID_SERIAL_SHORT=198427PCU834
-E: ID_USB_INTERFACES=:ff0000:
-E: ID_USB_MODEL=ETU905A88-E
-E: ID_USB_MODEL_ENC=ETU905A88-E
-E: ID_USB_MODEL_ID=0587
-E: ID_USB_REVISION=6467
-E: ID_USB_SERIAL=EGIS_ETU905A88-E_198427PCU834
-E: ID_USB_SERIAL_SHORT=198427PCU834
-E: ID_USB_VENDOR=EGIS
-E: ID_USB_VENDOR_ENC=EGIS
-E: ID_USB_VENDOR_ID=1c7a
-E: ID_VENDOR=EGIS
-E: ID_VENDOR_ENC=EGIS
-E: ID_VENDOR_FROM_DATABASE=LighTuning Technology Inc.
-E: ID_VENDOR_ID=1c7a
-E: MAJOR=189
-E: MINOR=264
-E: PRODUCT=1c7a/587/6467
-E: SUBSYSTEM=usb
-E: TYPE=255/0/0
-A: authorized=1\n
-A: avoid_reset_quirk=0\n
-A: bConfigurationValue=1\n
-A: bDeviceClass=ff\n
-A: bDeviceProtocol=00\n
-A: bDeviceSubClass=00\n
-A: bMaxPacketSize0=64\n
-A: bMaxPower=100mA\n
-A: bNumConfigurations=1\n
-A: bNumInterfaces= 1\n
-A: bcdDevice=6467\n
-A: bmAttributes=a0\n
-A: busnum=3\n
-A: configuration=
-H: descriptors=12010002FF0000407A1C870567640102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
-A: dev=189:264\n
-A: devnum=9\n
-A: devpath=5\n
-L: driver=../../../../../bus/usb/drivers/usb
-L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4e/device:4f/device:54
-A: idProduct=0587\n
-A: idVendor=1c7a\n
-A: ltm_capable=no\n
-A: manufacturer=EGIS\n
-A: maxchild=0\n
-A: physical_location/dock=no\n
-A: physical_location/horizontal_position=left\n
-A: physical_location/lid=no\n
-A: physical_location/panel=top\n
-A: physical_location/vertical_position=upper\n
-L: port=../3-0:1.0/usb3-port5
-A: power/active_duration=58096\n
-A: power/async=enabled\n
-A: power/autosuspend=2\n
-A: power/autosuspend_delay_ms=2000\n
-A: power/connected_duration=183928\n
-A: power/control=auto\n
-A: power/level=auto\n
-A: power/persist=0\n
-A: power/runtime_active_kids=0\n
-A: power/runtime_active_time=58510\n
-A: power/runtime_enabled=enabled\n
-A: power/runtime_status=active\n
-A: power/runtime_suspended_time=125136\n
-A: power/runtime_usage=0\n
-A: power/wakeup=disabled\n
-A: power/wakeup_abort_count=\n
-A: power/wakeup_active=\n
-A: power/wakeup_active_count=\n
-A: power/wakeup_count=\n
-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=ETU905A88-E\n
-A: quirks=0x0\n
-A: removable=fixed\n
-A: rx_lanes=1\n
-A: serial=198427PCU834\n
-A: speed=480\n
-A: tx_lanes=1\n
-A: urbnum=547\n
-A: version= 2.00\n
-
-P: /devices/pci0000:00/0000:00:14.0/usb3
-N: bus/usb/003/001=12010002090001406B1D020006060302010109021900010100E0000904000001090000000705810304000C
-E: BUSNUM=003
-E: CURRENT_TAGS=:seat:
-E: DEVNAME=/dev/bus/usb/003/001
-E: DEVNUM=001
-E: DEVTYPE=usb_device
-E: DRIVER=usb
-E: ID_AUTOSUSPEND=1
-E: ID_BUS=usb
-E: ID_FOR_SEAT=usb-pci-0000_00_14_0
-E: ID_MODEL=xHCI_Host_Controller
-E: ID_MODEL_ENC=xHCI\x20Host\x20Controller
-E: ID_MODEL_FROM_DATABASE=2.0 root hub
-E: ID_MODEL_ID=0002
-E: ID_PATH=pci-0000:00:14.0
-E: ID_PATH_TAG=pci-0000_00_14_0
-E: ID_REVISION=0606
-E: ID_SERIAL=Linux_6.6.0-14-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
-E: ID_SERIAL_SHORT=0000:00:14.0
-E: ID_USB_INTERFACES=:090000:
-E: ID_USB_MODEL=xHCI_Host_Controller
-E: ID_USB_MODEL_ENC=xHCI\x20Host\x20Controller
-E: ID_USB_MODEL_ID=0002
-E: ID_USB_REVISION=0606
-E: ID_USB_SERIAL=Linux_6.6.0-14-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
-E: ID_USB_SERIAL_SHORT=0000:00:14.0
-E: ID_USB_VENDOR=Linux_6.6.0-14-generic_xhci-hcd
-E: ID_USB_VENDOR_ENC=Linux\x206.6.0-14-generic\x20xhci-hcd
-E: ID_USB_VENDOR_ID=1d6b
-E: ID_VENDOR=Linux_6.6.0-14-generic_xhci-hcd
-E: ID_VENDOR_ENC=Linux\x206.6.0-14-generic\x20xhci-hcd
-E: ID_VENDOR_FROM_DATABASE=Linux Foundation
-E: ID_VENDOR_ID=1d6b
-E: MAJOR=189
-E: MINOR=256
-E: PRODUCT=1d6b/2/606
-E: SUBSYSTEM=usb
-E: TAGS=:seat:
-E: TYPE=9/0/1
-A: authorized=1\n
-A: authorized_default=1\n
-A: avoid_reset_quirk=0\n
-A: bConfigurationValue=1\n
-A: bDeviceClass=09\n
-A: bDeviceProtocol=01\n
-A: bDeviceSubClass=00\n
-A: bMaxPacketSize0=64\n
-A: bMaxPower=0mA\n
-A: bNumConfigurations=1\n
-A: bNumInterfaces= 1\n
-A: bcdDevice=0606\n
-A: bmAttributes=e0\n
-A: busnum=3\n
-A: configuration=
-H: descriptors=12010002090001406B1D020006060302010109021900010100E0000904000001090000000705810304000C
-A: dev=189:256\n
-A: devnum=1\n
-A: devpath=0\n
-L: driver=../../../../bus/usb/drivers/usb
-L: firmware_node=../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4e/device:4f
-A: idProduct=0002\n
-A: idVendor=1d6b\n
-A: interface_authorized_default=1\n
-A: ltm_capable=no\n
-A: manufacturer=Linux 6.6.0-14-generic xhci-hcd\n
-A: maxchild=12\n
-A: power/active_duration=5145268\n
-A: power/async=enabled\n
-A: power/autosuspend=0\n
-A: power/autosuspend_delay_ms=0\n
-A: power/connected_duration=5191200\n
-A: power/control=auto\n
-A: power/level=auto\n
-A: power/runtime_active_kids=2\n
-A: power/runtime_active_time=5145262\n
-A: power/runtime_enabled=enabled\n
-A: power/runtime_status=active\n
-A: power/runtime_suspended_time=45937\n
-A: power/runtime_usage=0\n
-A: power/wakeup=disabled\n
-A: power/wakeup_abort_count=\n
-A: power/wakeup_active=\n
-A: power/wakeup_active_count=\n
-A: power/wakeup_count=\n
-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=xHCI Host Controller\n
-A: quirks=0x0\n
-A: removable=unknown\n
-A: rx_lanes=1\n
-A: serial=0000:00:14.0\n
-A: speed=480\n
-A: tx_lanes=1\n
-A: urbnum=637\n
-A: version= 2.00\n
-
-P: /devices/pci0000:00/0000:00:14.0
-E: DRIVER=xhci_hcd
-E: ID_AUTOSUSPEND=1
-E: ID_MODEL_FROM_DATABASE=Alder Lake PCH USB 3.2 xHCI Host Controller
-E: ID_PATH=pci-0000:00:14.0
-E: ID_PATH_TAG=pci-0000_00_14_0
-E: ID_PCI_CLASS_FROM_DATABASE=Serial bus controller
-E: ID_PCI_INTERFACE_FROM_DATABASE=XHCI
-E: ID_PCI_SUBCLASS_FROM_DATABASE=USB controller
-E: ID_VENDOR_FROM_DATABASE=Intel Corporation
-E: MODALIAS=pci:v00008086d000051EDsv00001043sd0000201Fbc0Csc03i30
-E: PCI_CLASS=C0330
-E: PCI_ID=8086:51ED
-E: PCI_SLOT_NAME=0000:00:14.0
-E: PCI_SUBSYS_ID=1043:201F
-E: SUBSYSTEM=pci
-A: ari_enabled=0\n
-A: broken_parity_status=0\n
-A: class=0x0c0330\n
-H: config=8680ED51060490020130030C000080000400262F62000000000000000000000000000000000000000000000043101F20000000007000000000000000FF010000FD0134A089C27F8000000000000000003F6DD80F000000000000000000000000316000000000000000000000000000000180C2C1080000000000000000000000059087001805E0FE000000000000000009B014F01000400100000000C10A080000080E00001800008F50020000010000090000018680C00009001014000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B50F110112000000
-A: consistent_dma_mask_bits=64\n
-A: d3cold_allowed=1\n
-A: dbc=disabled\n
-A: dbc_bInterfaceProtocol=01\n
-A: dbc_bcdDevice=0010\n
-A: dbc_idProduct=0010\n
-A: dbc_idVendor=1d6b\n
-A: device=0x51ed\n
-A: dma_mask_bits=64\n
-L: driver=../../../bus/pci/drivers/xhci_hcd
-A: driver_override=(null)\n
-A: enable=1\n
-L: firmware_node=../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4e
-A: index=10\n
-L: iommu=../../virtual/iommu/dmar1
-L: iommu_group=../../../kernel/iommu_groups/11
-A: irq=145\n
-A: label=Onboard - Other\n
-A: local_cpulist=0-19\n
-A: local_cpus=fffff\n
-A: modalias=pci:v00008086d000051EDsv00001043sd0000201Fbc0Csc03i30\n
-A: msi_bus=1\n
-A: msi_irqs/145=msi\n
-A: numa_node=-1\n
-A: pools=poolinfo - 0.1\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          1   32  128  1\nbuffer-32           0    0   32  0\nxHCI 1KB stream ctx arrays    0    0 1024  0\nxHCI 256 byte stream ctx arrays    0    0  256  0\nxHCI input/output contexts   10   11 2112 11\nxHCI ring segments   38   38 4096 38\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          6   32  128  1\nbuffer-32           0    0   32  0\n
-A: power/async=enabled\n
-A: power/control=auto\n
-A: power/runtime_active_kids=2\n
-A: power/runtime_active_time=5192072\n
-A: power/runtime_enabled=enabled\n
-A: power/runtime_status=active\n
-A: power/runtime_suspended_time=0\n
-A: power/runtime_usage=0\n
-A: power/wakeup=enabled\n
-A: power/wakeup_abort_count=0\n
-A: power/wakeup_active=0\n
-A: power/wakeup_active_count=0\n
-A: power/wakeup_count=0\n
-A: power/wakeup_expire_count=0\n
-A: power/wakeup_last_time_ms=0\n
-A: power/wakeup_max_time_ms=0\n
-A: power/wakeup_total_time_ms=0\n
-A: power_state=D0\n
-A: resource=0x000000622f260000 0x000000622f26ffff 0x0000000000140204\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n
-A: revision=0x01\n
-A: subsystem_device=0x201f\n
-A: subsystem_vendor=0x1043\n
-A: vendor=0x8086\n
-
--- a/tests/egismoc-05a1/custom.pcapng
+++ b/tests/egismoc-05a1/custom.pcapng
--- a/tests/egismoc-05a1/custom.py
+++ b/tests/egismoc-05a1/custom.py
@@ -1,156 +0,0 @@
-#!/usr/bin/python3
-
-import traceback
-import sys
-import time
-import gi
-
-gi.require_version('FPrint', '2.0')
-from gi.repository import FPrint, GLib
-
-# Exit with error on any exception, included those happening in async callbacks
-sys.excepthook = lambda *args: (traceback.print_exception(*args), sys.exit(1))
-
-ctx = GLib.main_context_default()
-
-c = FPrint.Context()
-c.enumerate()
-devices = c.get_devices()
-
-d = devices[0]
-del devices
-
-d.open_sync()
-
-assert d.get_driver() == "egismoc"
-assert not d.has_feature(FPrint.DeviceFeature.CAPTURE)
-assert d.has_feature(FPrint.DeviceFeature.IDENTIFY)
-assert d.has_feature(FPrint.DeviceFeature.VERIFY)
-assert d.has_feature(FPrint.DeviceFeature.DUPLICATES_CHECK)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE_LIST)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE_DELETE)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE_CLEAR)
-
-def enroll_progress(*args):
-    print("finger status: ", d.get_finger_status())
-    print('enroll progress: ' + str(args))
-
-def identify_done(dev, res):
-    global identified
-    identified = True
-    identify_match, identify_print = dev.identify_finish(res)
-    print('indentification_done: ', identify_match, identify_print)
-    assert identify_match.equal(identify_print)
-
-# Beginning with list and clear assumes you begin with >0 prints enrolled before capturing
-
-print("listing - device should have prints")
-stored = d.list_prints_sync()
-assert len(stored) > 0
-del stored
-
-print("clear device storage")
-d.clear_storage_sync()
-print("clear done")
-
-print("listing - device should be empty")
-stored = d.list_prints_sync()
-assert len(stored) == 0
-del stored
-
-print("enrolling")
-template = FPrint.Print.new(d)
-template.set_finger(FPrint.Finger.LEFT_INDEX)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-p1 = d.enroll_sync(template, None, enroll_progress, None)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("enroll done")
-del template
-
-print("listing - device should have 1 print")
-stored = d.list_prints_sync()
-assert len(stored) == 1
-assert stored[0].equal(p1)
-
-print("verifying")
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-verify_res, verify_print = d.verify_sync(p1)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("verify done")
-assert verify_res == True
-
-identified = False
-deserialized_prints = []
-for p in stored:
-    deserialized_prints.append(FPrint.Print.deserialize(p.serialize()))
-    assert deserialized_prints[-1].equal(p)
-del stored
-
-print('async identifying')
-d.identify(deserialized_prints, callback=identify_done)
-del deserialized_prints
-
-while not identified:
-    ctx.iteration(True)
-
-print("try to enroll duplicate")
-template = FPrint.Print.new(d)
-template.set_finger(FPrint.Finger.RIGHT_INDEX)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-try:
-    d.enroll_sync(template, None, enroll_progress, None)
-except GLib.Error as error:
-    assert error.matches(FPrint.DeviceError.quark(),
-                         FPrint.DeviceError.DATA_DUPLICATE)
-except Exception as exc:
-    raise
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("duplicate enroll attempt done")
-
-print("listing - device should still only have 1 print")
-stored = d.list_prints_sync()
-assert len(stored) == 1
-assert stored[0].equal(p1)
-del stored
-
-print("enroll new finger")
-template = FPrint.Print.new(d)
-template.set_finger(FPrint.Finger.RIGHT_INDEX)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-p2 = d.enroll_sync(template, None, enroll_progress, None)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("enroll new finger done")
-del template
-
-print("listing - device should have 2 prints")
-stored = d.list_prints_sync()
-assert len(stored) == 2
-assert (stored[0].equal(p1) and stored[1].equal(p2)) or (stored[0].equal(p2) and stored[1].equal(p1))
-del stored
-
-print("deleting first print")
-d.delete_print_sync(p1)
-print("delete done")
-del p1
-
-print("listing - device should only have second print")
-stored = d.list_prints_sync()
-assert len(stored) == 1
-assert stored[0].equal(p2)
-del stored
-del p2
-
-print("clear device storage")
-d.clear_storage_sync()
-print("clear done")
-
-print("listing - device should be empty")
-stored = d.list_prints_sync()
-assert len(stored) == 0
-del stored
-
-d.close_sync()
-
-del d
-del c
--- a/tests/egismoc-05a1/device
+++ b/tests/egismoc-05a1/device
@@ -1,262 +0,0 @@
-P: /devices/pci0000:00/0000:00:14.0/usb1/1-5
-N: bus/usb/001/003=12010002FF0000407A1CA10513120102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
-E: BUSNUM=001
-E: DEVNAME=/dev/bus/usb/001/003
-E: DEVNUM=003
-E: DEVTYPE=usb_device
-E: DRIVER=usb
-E: ID_BUS=usb
-E: ID_MODEL=ETU905A80-E
-E: ID_MODEL_ENC=ETU905A80-E
-E: ID_MODEL_ID=05a1
-E: ID_REVISION=1213
-E: ID_SERIAL=EGIS_ETU905A80-E_0C5A44PCU833
-E: ID_SERIAL_SHORT=0C5A44PCU833
-E: ID_USB_INTERFACES=:ff0000:
-E: ID_USB_MODEL=ETU905A80-E
-E: ID_USB_MODEL_ENC=ETU905A80-E
-E: ID_USB_MODEL_ID=05a1
-E: ID_USB_REVISION=1213
-E: ID_USB_SERIAL=EGIS_ETU905A80-E_0C5A44PCU833
-E: ID_USB_SERIAL_SHORT=0C5A44PCU833
-E: ID_USB_VENDOR=EGIS
-E: ID_USB_VENDOR_ENC=EGIS
-E: ID_USB_VENDOR_ID=1c7a
-E: ID_VENDOR=EGIS
-E: ID_VENDOR_ENC=EGIS
-E: ID_VENDOR_FROM_DATABASE=LighTuning Technology Inc.
-E: ID_VENDOR_ID=1c7a
-E: MAJOR=189
-E: MINOR=2
-E: PRODUCT=1c7a/5a1/1213
-E: SUBSYSTEM=usb
-E: TYPE=255/0/0
-A: authorized=1\n
-A: avoid_reset_quirk=0\n
-A: bConfigurationValue=1\n
-A: bDeviceClass=ff\n
-A: bDeviceProtocol=00\n
-A: bDeviceSubClass=00\n
-A: bMaxPacketSize0=64\n
-A: bMaxPower=100mA\n
-A: bNumConfigurations=1\n
-A: bNumInterfaces= 1\n
-A: bcdDevice=1213\n
-A: bmAttributes=a0\n
-A: busnum=1\n
-A: configuration=
-H: descriptors=12010002FF0000407A1CA10513120102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
-A: dev=189:2\n
-A: devnum=3\n
-A: devpath=5\n
-L: driver=../../../../../bus/usb/drivers/usb
-L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:51/device:52/device:57
-A: idProduct=05a1\n
-A: idVendor=1c7a\n
-A: ltm_capable=no\n
-A: manufacturer=EGIS\n
-A: maxchild=0\n
-A: physical_location/dock=no\n
-A: physical_location/horizontal_position=center\n
-A: physical_location/lid=no\n
-A: physical_location/panel=unknown\n
-A: physical_location/vertical_position=center\n
-L: port=../1-0:1.0/usb1-port5
-A: power/active_duration=955612\n
-A: power/async=enabled\n
-A: power/autosuspend=2\n
-A: power/autosuspend_delay_ms=2000\n
-A: power/connected_duration=955612\n
-A: power/control=on\n
-A: power/level=on\n
-A: power/persist=0\n
-A: power/runtime_active_kids=0\n
-A: power/runtime_active_time=955338\n
-A: power/runtime_enabled=forbidden\n
-A: power/runtime_status=active\n
-A: power/runtime_suspended_time=0\n
-A: power/runtime_usage=1\n
-A: power/wakeup=disabled\n
-A: power/wakeup_abort_count=\n
-A: power/wakeup_active=\n
-A: power/wakeup_active_count=\n
-A: power/wakeup_count=\n
-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=ETU905A80-E\n
-A: quirks=0x0\n
-A: removable=fixed\n
-A: rx_lanes=1\n
-A: serial=0C5A44PCU833\n
-A: speed=480\n
-A: tx_lanes=1\n
-A: urbnum=491\n
-A: version= 2.00\n
-
-P: /devices/pci0000:00/0000:00:14.0/usb1
-N: bus/usb/001/001=12010002090001406B1D020005060302010109021900010100E0000904000001090000000705810304000C
-E: BUSNUM=001
-E: CURRENT_TAGS=:seat:
-E: DEVNAME=/dev/bus/usb/001/001
-E: DEVNUM=001
-E: DEVTYPE=usb_device
-E: DRIVER=usb
-E: ID_AUTOSUSPEND=1
-E: ID_BUS=usb
-E: ID_FOR_SEAT=usb-pci-0000_00_14_0
-E: ID_MODEL=xHCI_Host_Controller
-E: ID_MODEL_ENC=xHCI\x20Host\x20Controller
-E: ID_MODEL_FROM_DATABASE=2.0 root hub
-E: ID_MODEL_ID=0002
-E: ID_PATH=pci-0000:00:14.0
-E: ID_PATH_TAG=pci-0000_00_14_0
-E: ID_REVISION=0605
-E: ID_SERIAL=Linux_6.5.0-9-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
-E: ID_SERIAL_SHORT=0000:00:14.0
-E: ID_USB_INTERFACES=:090000:
-E: ID_USB_MODEL=xHCI_Host_Controller
-E: ID_USB_MODEL_ENC=xHCI\x20Host\x20Controller
-E: ID_USB_MODEL_ID=0002
-E: ID_USB_REVISION=0605
-E: ID_USB_SERIAL=Linux_6.5.0-9-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
-E: ID_USB_SERIAL_SHORT=0000:00:14.0
-E: ID_USB_VENDOR=Linux_6.5.0-9-generic_xhci-hcd
-E: ID_USB_VENDOR_ENC=Linux\x206.5.0-9-generic\x20xhci-hcd
-E: ID_USB_VENDOR_ID=1d6b
-E: ID_VENDOR=Linux_6.5.0-9-generic_xhci-hcd
-E: ID_VENDOR_ENC=Linux\x206.5.0-9-generic\x20xhci-hcd
-E: ID_VENDOR_FROM_DATABASE=Linux Foundation
-E: ID_VENDOR_ID=1d6b
-E: MAJOR=189
-E: MINOR=0
-E: PRODUCT=1d6b/2/605
-E: SUBSYSTEM=usb
-E: TAGS=:seat:
-E: TYPE=9/0/1
-A: authorized=1\n
-A: authorized_default=1\n
-A: avoid_reset_quirk=0\n
-A: bConfigurationValue=1\n
-A: bDeviceClass=09\n
-A: bDeviceProtocol=01\n
-A: bDeviceSubClass=00\n
-A: bMaxPacketSize0=64\n
-A: bMaxPower=0mA\n
-A: bNumConfigurations=1\n
-A: bNumInterfaces= 1\n
-A: bcdDevice=0605\n
-A: bmAttributes=e0\n
-A: busnum=1\n
-A: configuration=
-H: descriptors=12010002090001406B1D020005060302010109021900010100E0000904000001090000000705810304000C
-A: dev=189:0\n
-A: devnum=1\n
-A: devpath=0\n
-L: driver=../../../../bus/usb/drivers/usb
-L: firmware_node=../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:51/device:52
-A: idProduct=0002\n
-A: idVendor=1d6b\n
-A: interface_authorized_default=1\n
-A: ltm_capable=no\n
-A: manufacturer=Linux 6.5.0-9-generic xhci-hcd\n
-A: maxchild=12\n
-A: power/active_duration=956044\n
-A: power/async=enabled\n
-A: power/autosuspend=0\n
-A: power/autosuspend_delay_ms=0\n
-A: power/connected_duration=956044\n
-A: power/control=auto\n
-A: power/level=auto\n
-A: power/runtime_active_kids=2\n
-A: power/runtime_active_time=956041\n
-A: power/runtime_enabled=enabled\n
-A: power/runtime_status=active\n
-A: power/runtime_suspended_time=0\n
-A: power/runtime_usage=0\n
-A: power/wakeup=disabled\n
-A: power/wakeup_abort_count=\n
-A: power/wakeup_active=\n
-A: power/wakeup_active_count=\n
-A: power/wakeup_count=\n
-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=xHCI Host Controller\n
-A: quirks=0x0\n
-A: removable=unknown\n
-A: rx_lanes=1\n
-A: serial=0000:00:14.0\n
-A: speed=480\n
-A: tx_lanes=1\n
-A: urbnum=181\n
-A: version= 2.00\n
-
-P: /devices/pci0000:00/0000:00:14.0
-E: DRIVER=xhci_hcd
-E: ID_MODEL_FROM_DATABASE=Alder Lake PCH USB 3.2 xHCI Host Controller
-E: ID_PCI_CLASS_FROM_DATABASE=Serial bus controller
-E: ID_PCI_INTERFACE_FROM_DATABASE=XHCI
-E: ID_PCI_SUBCLASS_FROM_DATABASE=USB controller
-E: ID_VENDOR_FROM_DATABASE=Intel Corporation
-E: MODALIAS=pci:v00008086d000051EDsv0000144Dsd0000C1CAbc0Csc03i30
-E: PCI_CLASS=C0330
-E: PCI_ID=8086:51ED
-E: PCI_SLOT_NAME=0000:00:14.0
-E: PCI_SUBSYS_ID=144D:C1CA
-E: SUBSYSTEM=pci
-A: ari_enabled=0\n
-A: broken_parity_status=0\n
-A: class=0x0c0330\n
-H: config=8680ED51060490020130030C0000800004001A3E6000000000000000000000000000000000000000000000004D14CAC1000000007000000000000000FF010000FD0134A089C27F8000000000000000003F6DD80F000000000000000000000000316000000000000000000000000000000180C2C108000000000000000000000005908700D804E0FE000000000000000009B014F01000400100000000C10A080000080E00001800008F50020000010000090000018680C00009001014000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B50F110112000000
-A: consistent_dma_mask_bits=64\n
-A: d3cold_allowed=1\n
-A: dbc=disabled\n
-A: dbc_bInterfaceProtocol=01\n
-A: dbc_bcdDevice=0010\n
-A: dbc_idProduct=0010\n
-A: dbc_idVendor=1d6b\n
-A: device=0x51ed\n
-A: dma_mask_bits=64\n
-L: driver=../../../bus/pci/drivers/xhci_hcd
-A: driver_override=(null)\n
-A: enable=1\n
-L: firmware_node=../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:51
-A: index=9\n
-L: iommu=../../virtual/iommu/dmar2
-L: iommu_group=../../../kernel/iommu_groups/11
-A: irq=142\n
-A: label=Onboard - Other\n
-A: local_cpulist=0-15\n
-A: local_cpus=ffff\n
-A: modalias=pci:v00008086d000051EDsv0000144Dsd0000C1CAbc0Csc03i30\n
-A: msi_bus=1\n
-A: msi_irqs/142=msi\n
-A: numa_node=-1\n
-A: pools=poolinfo - 0.1\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          0    0  128  0\nbuffer-32           0    0   32  0\nxHCI 1KB stream ctx arrays    0    0 1024  0\nxHCI 256 byte stream ctx arrays    0    0  256  0\nxHCI input/output contexts    6    7 2112  7\nxHCI ring segments   28   28 4096 28\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          1   32  128  1\nbuffer-32           0    0   32  0\n
-A: power/async=enabled\n
-A: power/control=auto\n
-A: power/runtime_active_kids=1\n
-A: power/runtime_active_time=957198\n
-A: power/runtime_enabled=enabled\n
-A: power/runtime_status=active\n
-A: power/runtime_suspended_time=0\n
-A: power/runtime_usage=0\n
-A: power/wakeup=enabled\n
-A: power/wakeup_abort_count=0\n
-A: power/wakeup_active=0\n
-A: power/wakeup_active_count=0\n
-A: power/wakeup_count=0\n
-A: power/wakeup_expire_count=0\n
-A: power/wakeup_last_time_ms=0\n
-A: power/wakeup_max_time_ms=0\n
-A: power/wakeup_total_time_ms=0\n
-A: power_state=D0\n
-A: resource=0x000000603e1a0000 0x000000603e1affff 0x0000000000140204\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n
-A: revision=0x01\n
-A: subsystem_device=0xc1ca\n
-A: subsystem_vendor=0x144d\n
-A: vendor=0x8086\n
-
--- a/tests/egismoc/custom.pcapng
+++ b/tests/egismoc/custom.pcapng
--- a/tests/egismoc/custom.py
+++ b/tests/egismoc/custom.py
@@ -1,156 +0,0 @@
-#!/usr/bin/python3
-
-import traceback
-import sys
-import time
-import gi
-
-gi.require_version('FPrint', '2.0')
-from gi.repository import FPrint, GLib
-
-# Exit with error on any exception, included those happening in async callbacks
-sys.excepthook = lambda *args: (traceback.print_exception(*args), sys.exit(1))
-
-ctx = GLib.main_context_default()
-
-c = FPrint.Context()
-c.enumerate()
-devices = c.get_devices()
-
-d = devices[0]
-del devices
-
-d.open_sync()
-
-assert d.get_driver() == "egismoc"
-assert not d.has_feature(FPrint.DeviceFeature.CAPTURE)
-assert d.has_feature(FPrint.DeviceFeature.IDENTIFY)
-assert d.has_feature(FPrint.DeviceFeature.VERIFY)
-assert d.has_feature(FPrint.DeviceFeature.DUPLICATES_CHECK)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE_LIST)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE_DELETE)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE_CLEAR)
-
-def enroll_progress(*args):
-    print("finger status: ", d.get_finger_status())
-    print('enroll progress: ' + str(args))
-
-def identify_done(dev, res):
-    global identified
-    identified = True
-    identify_match, identify_print = dev.identify_finish(res)
-    print('indentification_done: ', identify_match, identify_print)
-    assert identify_match.equal(identify_print)
-
-# Beginning with list and clear assumes you begin with >0 prints enrolled before capturing
-
-print("listing - device should have prints")
-stored = d.list_prints_sync()
-assert len(stored) > 0
-del stored
-
-print("clear device storage")
-d.clear_storage_sync()
-print("clear done")
-
-print("listing - device should be empty")
-stored = d.list_prints_sync()
-assert len(stored) == 0
-del stored
-
-print("enrolling")
-template = FPrint.Print.new(d)
-template.set_finger(FPrint.Finger.LEFT_INDEX)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-p1 = d.enroll_sync(template, None, enroll_progress, None)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("enroll done")
-del template
-
-print("listing - device should have 1 print")
-stored = d.list_prints_sync()
-assert len(stored) == 1
-assert stored[0].equal(p1)
-
-print("verifying")
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-verify_res, verify_print = d.verify_sync(p1)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("verify done")
-assert verify_res == True
-
-identified = False
-deserialized_prints = []
-for p in stored:
-    deserialized_prints.append(FPrint.Print.deserialize(p.serialize()))
-    assert deserialized_prints[-1].equal(p)
-del stored
-
-print('async identifying')
-d.identify(deserialized_prints, callback=identify_done)
-del deserialized_prints
-
-while not identified:
-    ctx.iteration(True)
-
-print("try to enroll duplicate")
-template = FPrint.Print.new(d)
-template.set_finger(FPrint.Finger.RIGHT_INDEX)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-try:
-    d.enroll_sync(template, None, enroll_progress, None)
-except GLib.Error as error:
-    assert error.matches(FPrint.DeviceError.quark(),
-                         FPrint.DeviceError.DATA_DUPLICATE)
-except Exception as exc:
-    raise
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("duplicate enroll attempt done")
-
-print("listing - device should still only have 1 print")
-stored = d.list_prints_sync()
-assert len(stored) == 1
-assert stored[0].equal(p1)
-del stored
-
-print("enroll new finger")
-template = FPrint.Print.new(d)
-template.set_finger(FPrint.Finger.RIGHT_INDEX)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-p2 = d.enroll_sync(template, None, enroll_progress, None)
-assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
-print("enroll new finger done")
-del template
-
-print("listing - device should have 2 prints")
-stored = d.list_prints_sync()
-assert len(stored) == 2
-assert (stored[0].equal(p1) and stored[1].equal(p2)) or (stored[0].equal(p2) and stored[1].equal(p1))
-del stored
-
-print("deleting first print")
-d.delete_print_sync(p1)
-print("delete done")
-del p1
-
-print("listing - device should only have second print")
-stored = d.list_prints_sync()
-assert len(stored) == 1
-assert stored[0].equal(p2)
-del stored
-del p2
-
-print("clear device storage")
-d.clear_storage_sync()
-print("clear done")
-
-print("listing - device should be empty")
-stored = d.list_prints_sync()
-assert len(stored) == 0
-del stored
-
-d.close_sync()
-
-del d
-del c
--- a/tests/egismoc/device
+++ b/tests/egismoc/device
@@ -1,262 +0,0 @@
-P: /devices/pci0000:00/0000:00:14.0/usb3/3-5
-N: bus/usb/003/012=12010002FF0000407A1C820581110102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
-E: BUSNUM=003
-E: CURRENT_TAGS=:snap_cups_ippeveprinter:snap_cups_cupsd:
-E: DEVNAME=/dev/bus/usb/003/012
-E: DEVNUM=012
-E: DEVTYPE=usb_device
-E: DRIVER=usb
-E: ID_BUS=usb
-E: ID_MODEL=ETU905A80-E
-E: ID_MODEL_ENC=ETU905A80-E
-E: ID_MODEL_ID=0582
-E: ID_PATH=pci-0000:00:14.0-usb-0:5
-E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_5
-E: ID_REVISION=1181
-E: ID_SERIAL=EGIS_ETU905A80-E_0E7828PBS393
-E: ID_SERIAL_SHORT=0E7828PBS393
-E: ID_USB_INTERFACES=:ff0000:
-E: ID_USB_MODEL=ETU905A80-E
-E: ID_USB_MODEL_ENC=ETU905A80-E
-E: ID_USB_MODEL_ID=0582
-E: ID_USB_REVISION=1181
-E: ID_USB_SERIAL=EGIS_ETU905A80-E_0E7828PBS393
-E: ID_USB_SERIAL_SHORT=0E7828PBS393
-E: ID_USB_VENDOR=EGIS
-E: ID_USB_VENDOR_ENC=EGIS
-E: ID_USB_VENDOR_ID=1c7a
-E: ID_VENDOR=EGIS
-E: ID_VENDOR_ENC=EGIS
-E: ID_VENDOR_FROM_DATABASE=LighTuning Technology Inc.
-E: ID_VENDOR_ID=1c7a
-E: MAJOR=189
-E: MINOR=267
-E: PRODUCT=1c7a/582/1181
-E: SUBSYSTEM=usb
-E: TAGS=:snap_cups_ippeveprinter:snap_cups_cupsd:
-E: TYPE=255/0/0
-A: authorized=1\n
-A: avoid_reset_quirk=0\n
-A: bConfigurationValue=1\n
-A: bDeviceClass=ff\n
-A: bDeviceProtocol=00\n
-A: bDeviceSubClass=00\n
-A: bMaxPacketSize0=64\n
-A: bMaxPower=100mA\n
-A: bNumConfigurations=1\n
-A: bNumInterfaces= 1\n
-A: bcdDevice=1181\n
-A: bmAttributes=a0\n
-A: busnum=3\n
-A: configuration=
-H: descriptors=12010002FF0000407A1C820581110102030109022700010100A0320904000003FF000000070581020002000705020200020007058303400005
-A: dev=189:267\n
-A: devnum=12\n
-A: devpath=5\n
-L: driver=../../../../../bus/usb/drivers/usb
-L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:51/device:52/device:57
-A: idProduct=0582\n
-A: idVendor=1c7a\n
-A: ltm_capable=no\n
-A: manufacturer=EGIS\n
-A: maxchild=0\n
-A: physical_location/dock=no\n
-A: physical_location/horizontal_position=center\n
-A: physical_location/lid=no\n
-A: physical_location/panel=unknown\n
-A: physical_location/vertical_position=center\n
-L: port=../3-0:1.0/usb3-port5
-A: power/active_duration=1425996\n
-A: power/async=enabled\n
-A: power/autosuspend=2\n
-A: power/autosuspend_delay_ms=2000\n
-A: power/connected_duration=1426656\n
-A: power/control=on\n
-A: power/level=on\n
-A: power/persist=0\n
-A: power/runtime_active_kids=0\n
-A: power/runtime_active_time=1426124\n
-A: power/runtime_enabled=forbidden\n
-A: power/runtime_status=active\n
-A: power/runtime_suspended_time=0\n
-A: power/runtime_usage=1\n
-A: power/wakeup=disabled\n
-A: power/wakeup_abort_count=\n
-A: power/wakeup_active=\n
-A: power/wakeup_active_count=\n
-A: power/wakeup_count=\n
-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=ETU905A80-E\n
-A: quirks=0x0\n
-A: removable=fixed\n
-A: rx_lanes=1\n
-A: serial=0E7828PBS393\n
-A: speed=480\n
-A: tx_lanes=1\n
-A: urbnum=2803\n
-A: version= 2.00\n
-
-P: /devices/pci0000:00/0000:00:14.0/usb3
-N: bus/usb/003/001=12010002090001406B1D020002060302010109021900010100E0000904000001090000000705810304000C
-E: BUSNUM=003
-E: CURRENT_TAGS=:seat:snap_cups_cupsd:snap_cups_ippeveprinter:
-E: DEVNAME=/dev/bus/usb/003/001
-E: DEVNUM=001
-E: DEVTYPE=usb_device
-E: DRIVER=usb
-E: ID_AUTOSUSPEND=1
-E: ID_BUS=usb
-E: ID_FOR_SEAT=usb-pci-0000_00_14_0
-E: ID_MODEL=xHCI_Host_Controller
-E: ID_MODEL_ENC=xHCI\x20Host\x20Controller
-E: ID_MODEL_FROM_DATABASE=2.0 root hub
-E: ID_MODEL_ID=0002
-E: ID_PATH=pci-0000:00:14.0
-E: ID_PATH_TAG=pci-0000_00_14_0
-E: ID_REVISION=0602
-E: ID_SERIAL=Linux_6.2.0-34-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
-E: ID_SERIAL_SHORT=0000:00:14.0
-E: ID_USB_INTERFACES=:090000:
-E: ID_USB_MODEL=xHCI_Host_Controller
-E: ID_USB_MODEL_ENC=xHCI\x20Host\x20Controller
-E: ID_USB_MODEL_ID=0002
-E: ID_USB_REVISION=0602
-E: ID_USB_SERIAL=Linux_6.2.0-34-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
-E: ID_USB_SERIAL_SHORT=0000:00:14.0
-E: ID_USB_VENDOR=Linux_6.2.0-34-generic_xhci-hcd
-E: ID_USB_VENDOR_ENC=Linux\x206.2.0-34-generic\x20xhci-hcd
-E: ID_USB_VENDOR_ID=1d6b
-E: ID_VENDOR=Linux_6.2.0-34-generic_xhci-hcd
-E: ID_VENDOR_ENC=Linux\x206.2.0-34-generic\x20xhci-hcd
-E: ID_VENDOR_FROM_DATABASE=Linux Foundation
-E: ID_VENDOR_ID=1d6b
-E: MAJOR=189
-E: MINOR=256
-E: PRODUCT=1d6b/2/602
-E: SUBSYSTEM=usb
-E: TAGS=:snap_cups_cupsd:seat:snap_cups_ippeveprinter:
-E: TYPE=9/0/1
-A: authorized=1\n
-A: authorized_default=1\n
-A: avoid_reset_quirk=0\n
-A: bConfigurationValue=1\n
-A: bDeviceClass=09\n
-A: bDeviceProtocol=01\n
-A: bDeviceSubClass=00\n
-A: bMaxPacketSize0=64\n
-A: bMaxPower=0mA\n
-A: bNumConfigurations=1\n
-A: bNumInterfaces= 1\n
-A: bcdDevice=0602\n
-A: bmAttributes=e0\n
-A: busnum=3\n
-A: configuration=
-H: descriptors=12010002090001406B1D020002060302010109021900010100E0000904000001090000000705810304000C
-A: dev=189:256\n
-A: devnum=1\n
-A: devpath=0\n
-L: driver=../../../../bus/usb/drivers/usb
-L: firmware_node=../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:51/device:52
-A: idProduct=0002\n
-A: idVendor=1d6b\n
-A: interface_authorized_default=1\n
-A: ltm_capable=no\n
-A: manufacturer=Linux 6.2.0-34-generic xhci-hcd\n
-A: maxchild=12\n
-A: power/active_duration=337953872\n
-A: power/async=enabled\n
-A: power/autosuspend=0\n
-A: power/autosuspend_delay_ms=0\n
-A: power/connected_duration=337978524\n
-A: power/control=auto\n
-A: power/level=auto\n
-A: power/runtime_active_kids=1\n
-A: power/runtime_active_time=337962424\n
-A: power/runtime_enabled=enabled\n
-A: power/runtime_status=active\n
-A: power/runtime_suspended_time=616\n
-A: power/runtime_usage=0\n
-A: power/wakeup=disabled\n
-A: power/wakeup_abort_count=\n
-A: power/wakeup_active=\n
-A: power/wakeup_active_count=\n
-A: power/wakeup_count=\n
-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=xHCI Host Controller\n
-A: quirks=0x0\n
-A: removable=unknown\n
-A: rx_lanes=1\n
-A: serial=0000:00:14.0\n
-A: speed=480\n
-A: tx_lanes=1\n
-A: urbnum=4969\n
-A: version= 2.00\n
-
-P: /devices/pci0000:00/0000:00:14.0
-E: DRIVER=xhci_hcd
-E: ID_MODEL_FROM_DATABASE=Alder Lake PCH USB 3.2 xHCI Host Controller
-E: ID_PCI_CLASS_FROM_DATABASE=Serial bus controller
-E: ID_PCI_INTERFACE_FROM_DATABASE=XHCI
-E: ID_PCI_SUBCLASS_FROM_DATABASE=USB controller
-E: ID_VENDOR_FROM_DATABASE=Intel Corporation
-E: MODALIAS=pci:v00008086d000051EDsv0000144Dsd0000C870bc0Csc03i30
-E: PCI_CLASS=C0330
-E: PCI_ID=8086:51ED
-E: PCI_SLOT_NAME=0000:00:14.0
-E: PCI_SUBSYS_ID=144D:C870
-E: SUBSYSTEM=pci
-A: ari_enabled=0\n
-A: broken_parity_status=0\n
-A: class=0x0c0330\n
-H: config=8680ED51060490020130030C000080000400161D6000000000000000000000000000000000000000000000004D1470C8000000007000000000000000FF010000FD0134A089C27F8000000000000000003F6DD80F000000000000000000000000316000000000000000000000000000000180C2C1080000000000000000000000059087007805E0FE000000000000000009B014F01000400100000000C10A080000080E00001800008F50020000010000090000018680C00009001014000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000B50F010112000000
-A: consistent_dma_mask_bits=64\n
-A: d3cold_allowed=1\n
-A: dbc=disabled\n
-A: device=0x51ed\n
-A: dma_mask_bits=64\n
-L: driver=../../../bus/pci/drivers/xhci_hcd
-A: driver_override=(null)\n
-A: enable=1\n
-L: firmware_node=../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:51
-A: index=7\n
-L: iommu=../../virtual/iommu/dmar1
-L: iommu_group=../../../kernel/iommu_groups/8
-A: irq=145\n
-A: label=Onboard - Other\n
-A: local_cpulist=0-15\n
-A: local_cpus=ffff\n
-A: modalias=pci:v00008086d000051EDsv0000144Dsd0000C870bc0Csc03i30\n
-A: msi_bus=1\n
-A: msi_irqs/145=msi\n
-A: numa_node=-1\n
-A: pools=poolinfo - 0.1\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          0    0  128  0\nbuffer-32           0    0   32  0\nxHCI 1KB stream ctx arrays    0    0 1024  0\nxHCI 256 byte stream ctx arrays    0    0  256  0\nxHCI input/output contexts    6    9 2112  9\nxHCI ring segments   26   34 4096 34\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          0   32  128  1\nbuffer-32           0    0   32  0\n
-A: power/async=enabled\n
-A: power/control=auto\n
-A: power/runtime_active_kids=1\n
-A: power/runtime_active_time=337964621\n
-A: power/runtime_enabled=enabled\n
-A: power/runtime_status=active\n
-A: power/runtime_suspended_time=438\n
-A: power/runtime_usage=0\n
-A: power/wakeup=enabled\n
-A: power/wakeup_abort_count=0\n
-A: power/wakeup_active=0\n
-A: power/wakeup_active_count=7\n
-A: power/wakeup_count=0\n
-A: power/wakeup_expire_count=7\n
-A: power/wakeup_last_time_ms=336554844\n
-A: power/wakeup_max_time_ms=105\n
-A: power/wakeup_total_time_ms=721\n
-A: power_state=D0\n
-A: resource=0x000000601d160000 0x000000601d16ffff 0x0000000000140204\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n
-A: revision=0x01\n
-A: subsystem_device=0xc870\n
-A: subsystem_vendor=0x144d\n
-A: vendor=0x8086\n
-
--- a/tests/elanmoc/custom.pcapng
+++ b/tests/elanmoc/custom.pcapng
--- a/tests/elanmoc/custom.py
+++ b/tests/elanmoc/custom.py
@@ -1,15 +1,9 @@
 #!/usr/bin/python3

-import traceback
-import sys
 import gi
-
 gi.require_version('FPrint', '2.0')
 from gi.repository import FPrint, GLib

-# Exit with error on any exception, included those happening in async callbacks
-sys.excepthook = lambda *args: (traceback.print_exception(*args), sys.exit(1))
-
 ctx = GLib.main_context_default()

 c = FPrint.Context()
--- a/tests/elanmoc/device
+++ b/tests/elanmoc/device
@@ -1,67 +1,63 @@
-P: /devices/pci0000:00/0000:00:14.0/usb1/1-9
-N: bus/usb/001/003=1201000200000008F304880C04800102000109025300010100A0320904000008FF0000000921100100012215000705810240000107050102400001070582024000010705020240000107058302400001070503024000010705840240000107050402400001
-E: DEVNAME=/dev/bus/usb/001/003
+P: /devices/pci0000:00/0000:00:14.0/usb1/1-1
+N: bus/usb/001/010=1201000200000040F3047E0C05030102000109025300010103A0320904000008FF0000000921100100012215000705810240000107050102400001070582024000010705020240000107058302400001070503024000010705840240000107050402400001
+E: DEVNAME=/dev/bus/usb/001/010
 E: DEVTYPE=usb_device
 E: DRIVER=usb
-E: PRODUCT=4f3/c88/8004
+E: PRODUCT=4f3/c7e/305
 E: TYPE=0/0/0
 E: BUSNUM=001
-E: DEVNUM=003
+E: DEVNUM=010
 E: MAJOR=189
-E: MINOR=2
+E: MINOR=9
 E: SUBSYSTEM=usb
 E: ID_VENDOR=ELAN
 E: ID_VENDOR_ENC=ELAN
 E: ID_VENDOR_ID=04f3
 E: ID_MODEL=ELAN:ARM-M4
 E: ID_MODEL_ENC=ELAN:ARM-M4
-E: ID_MODEL_ID=0c88
-E: ID_REVISION=8004
+E: ID_MODEL_ID=0c7e
+E: ID_REVISION=0305
 E: ID_SERIAL=ELAN_ELAN:ARM-M4
 E: ID_BUS=usb
 E: ID_USB_INTERFACES=:ff0000:
 E: ID_VENDOR_FROM_DATABASE=Elan Microelectronics Corp.
-E: ID_PATH=pci-0000:00:14.0-usb-0:9
-E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_9
-E: ID_FOR_SEAT=usb-pci-0000_00_14_0-usb-0_9
-E: TAGS=:seat:
-E: CURRENT_TAGS=:seat:
+E: ID_PATH=pci-0000:00:14.0-usb-0:1
+E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_1
 A: authorized=1\n
 A: avoid_reset_quirk=0\n
 A: bConfigurationValue=1\n
 A: bDeviceClass=00\n
 A: bDeviceProtocol=00\n
 A: bDeviceSubClass=00\n
-A: bMaxPacketSize0=8\n
+A: bMaxPacketSize0=64\n
 A: bMaxPower=100mA\n
 A: bNumConfigurations=1\n
 A: bNumInterfaces= 1\n
-A: bcdDevice=8004\n
+A: bcdDevice=0305\n
 A: bmAttributes=a0\n
 A: busnum=1\n
-A: configuration=
-H: descriptors=1201000200000008F304880C04800102000109025300010100A0320904000008FF0000000921100100012215000705810240000107050102400001070582024000010705020240000107058302400001070503024000010705840240000107050402400001
-A: dev=189:2\n
-A: devnum=3\n
-A: devpath=9\n
+A: configuration=add909c9-e67e-4126-a6f7-1e31179e27d9\n
+H: descriptors=1201000200000040F3047E0C05030102000109025300010103A0320904000008FF0000000921100100012215000705810240000107050102400001070582024000010705020240000107058302400001070503024000010705840240000107050402400001
+A: dev=189:9\n
+A: devnum=10\n
+A: devpath=1\n
 L: driver=../../../../../bus/usb/drivers/usb
-L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:3d/device:3e/device:47
-A: idProduct=0c88\n
+A: idProduct=0c7e\n
 A: idVendor=04f3\n
 A: ltm_capable=no\n
 A: manufacturer=ELAN\n
 A: maxchild=0\n
-L: port=../1-0:1.0/usb1-port9
-A: power/active_duration=35269124\n
+L: port=../1-0:1.0/usb1-port1
+A: power/active_duration=94712\n
 A: power/async=enabled\n
 A: power/autosuspend=2\n
 A: power/autosuspend_delay_ms=2000\n
-A: power/connected_duration=35283788\n
+A: power/connected_duration=94712\n
 A: power/control=on\n
 A: power/level=on\n
-A: power/persist=0\n
+A: power/persist=1\n
 A: power/runtime_active_kids=0\n
-A: power/runtime_active_time=35276624\n
+A: power/runtime_active_time=94436\n
 A: power/runtime_enabled=forbidden\n
 A: power/runtime_status=active\n
 A: power/runtime_suspended_time=0\n
@@ -81,40 +77,38 @@ A: removable=removable\n
 A: rx_lanes=1\n
 A: speed=12\n
 A: tx_lanes=1\n
-A: urbnum=2773\n
+A: urbnum=12\n
 A: version= 2.00\n

 P: /devices/pci0000:00/0000:00:14.0/usb1
-N: bus/usb/001/001=12010002090001406B1D020015050302010109021900010100E0000904000001090000000705810304000C
+N: bus/usb/001/001=12010002090001406B1D020004050302010109021900010100E0000904000001090000000705810304000C
 E: DEVNAME=/dev/bus/usb/001/001
 E: DEVTYPE=usb_device
 E: DRIVER=usb
-E: PRODUCT=1d6b/2/515
+E: PRODUCT=1d6b/2/504
 E: TYPE=9/0/1
 E: BUSNUM=001
 E: DEVNUM=001
 E: MAJOR=189
 E: MINOR=0
 E: SUBSYSTEM=usb
-E: ID_VENDOR=Linux_5.15.0-39-generic_xhci-hcd
-E: ID_VENDOR_ENC=Linux\x205.15.0-39-generic\x20xhci-hcd
+E: ID_VENDOR=Linux_5.4.0-42-generic_xhci-hcd
+E: ID_VENDOR_ENC=Linux\x205.4.0-42-generic\x20xhci-hcd
 E: ID_VENDOR_ID=1d6b
 E: ID_MODEL=xHCI_Host_Controller
 E: ID_MODEL_ENC=xHCI\x20Host\x20Controller
 E: ID_MODEL_ID=0002
-E: ID_REVISION=0515
-E: ID_SERIAL=Linux_5.15.0-39-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+E: ID_REVISION=0504
+E: ID_SERIAL=Linux_5.4.0-42-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
 E: ID_SERIAL_SHORT=0000:00:14.0
 E: ID_BUS=usb
 E: ID_USB_INTERFACES=:090000:
 E: ID_VENDOR_FROM_DATABASE=Linux Foundation
-E: ID_AUTOSUSPEND=1
 E: ID_MODEL_FROM_DATABASE=2.0 root hub
 E: ID_PATH=pci-0000:00:14.0
 E: ID_PATH_TAG=pci-0000_00_14_0
 E: ID_FOR_SEAT=usb-pci-0000_00_14_0
 E: TAGS=:seat:
-E: CURRENT_TAGS=:seat:
 A: authorized=1\n
 A: authorized_default=1\n
 A: avoid_reset_quirk=0\n
@@ -126,31 +120,30 @@ A: bMaxPacketSize0=64\n
 A: bMaxPower=0mA\n
 A: bNumConfigurations=1\n
 A: bNumInterfaces= 1\n
-A: bcdDevice=0515\n
+A: bcdDevice=0504\n
 A: bmAttributes=e0\n
 A: busnum=1\n
-A: configuration=
-H: descriptors=12010002090001406B1D020015050302010109021900010100E0000904000001090000000705810304000C
+A: configuration=\n
+H: descriptors=12010002090001406B1D020004050302010109021900010100E0000904000001090000000705810304000C
 A: dev=189:0\n
 A: devnum=1\n
 A: devpath=0\n
 L: driver=../../../../bus/usb/drivers/usb
-L: firmware_node=../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:3d/device:3e
 A: idProduct=0002\n
 A: idVendor=1d6b\n
 A: interface_authorized_default=1\n
 A: ltm_capable=no\n
-A: manufacturer=Linux 5.15.0-39-generic xhci-hcd\n
-A: maxchild=14\n
-A: power/active_duration=35270364\n
+A: manufacturer=Linux 5.4.0-42-generic xhci-hcd\n
+A: maxchild=12\n
+A: power/active_duration=74604360\n
 A: power/async=enabled\n
 A: power/autosuspend=0\n
 A: power/autosuspend_delay_ms=0\n
-A: power/connected_duration=35284300\n
+A: power/connected_duration=74606456\n
 A: power/control=auto\n
 A: power/level=auto\n
-A: power/runtime_active_kids=2\n
-A: power/runtime_active_time=35277420\n
+A: power/runtime_active_kids=4\n
+A: power/runtime_active_time=74605838\n
 A: power/runtime_enabled=enabled\n
 A: power/runtime_status=active\n
 A: power/runtime_suspended_time=0\n
@@ -171,63 +164,62 @@ A: rx_lanes=1\n
 A: serial=0000:00:14.0\n
 A: speed=480\n
 A: tx_lanes=1\n
-A: urbnum=549\n
+A: urbnum=490\n
 A: version= 2.00\n

 P: /devices/pci0000:00/0000:00:14.0
 E: DRIVER=xhci_hcd
 E: PCI_CLASS=C0330
-E: PCI_ID=8086:8C31
-E: PCI_SUBSYS_ID=1043:201F
+E: PCI_ID=8086:9DED
+E: PCI_SUBSYS_ID=103C:85EF
 E: PCI_SLOT_NAME=0000:00:14.0
-E: MODALIAS=pci:v00008086d00008C31sv00001043sd0000201Fbc0Csc03i30
+E: MODALIAS=pci:v00008086d00009DEDsv0000103Csd000085EFbc0Csc03i30
 E: SUBSYSTEM=pci
 E: ID_PCI_CLASS_FROM_DATABASE=Serial bus controller
 E: ID_PCI_SUBCLASS_FROM_DATABASE=USB controller
 E: ID_PCI_INTERFACE_FROM_DATABASE=XHCI
 E: ID_VENDOR_FROM_DATABASE=Intel Corporation
-E: ID_MODEL_FROM_DATABASE=8 Series/C220 Series Chipset Family USB xHCI
+E: ID_MODEL_FROM_DATABASE=Cannon Point-LP USB 3.1 xHCI Controller
 A: ari_enabled=0\n
 A: broken_parity_status=0\n
 A: class=0x0c0330\n
-H: config=8680318C060490020530030C000000000400A0F700000000000000000000000000000000000000000000000043101F200000000070000000000000000B010000FD01368089C60F8000000000000000009F6E8807000000000000000000000000302000000000000000000000000000000180C2C1080000000000000000000000050087000410E0FE000000002F00000000000000000000000000000000000000400100000000000000000000000000000F000100000000000000000000000000030420C0030C3000030C300000000000FF1A0000FF1A00003F0000003F000000A00000000000000000000000D8D8D8080000000000000000B10F060800000000
+H: config=8680ED9D060490023030030C00008000040030A10000000000000000000000000000000000000000000000003C10EF85000000007000000000000000FF010000FD0134808FC6FF8300000000000000007F6DDC0F00000000181C030400000000316000000000000000000000000000000180C2C1080000000000000000000000059087007802E0FE0000000000000000090014F01000400100000000C10A080000080E00001800008F40020000010000010000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000B50F300112000000
 A: consistent_dma_mask_bits=64\n
 A: d3cold_allowed=1\n
-A: device=0x8c31\n
+A: dbc=disabled\n
+A: device=0x9ded\n
 A: dma_mask_bits=64\n
 L: driver=../../../bus/pci/drivers/xhci_hcd
 A: driver_override=(null)\n
 A: enable=1\n
-L: firmware_node=../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:3d
-A: irq=31\n
+A: irq=124\n
 A: local_cpulist=0-3\n
 A: local_cpus=f\n
-A: modalias=pci:v00008086d00008C31sv00001043sd0000201Fbc0Csc03i30\n
+A: modalias=pci:v00008086d00009DEDsv0000103Csd000085EFbc0Csc03i30\n
 A: msi_bus=1\n
-A: msi_irqs/31=msi\n
+A: msi_irqs/124=msi\n
 A: numa_node=-1\n
-A: pools=poolinfo - 0.1\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          0    0  128  0\nbuffer-32           0    0   32  0\nxHCI 1KB stream ctx arrays    0    0 1024  0\nxHCI 256 byte stream ctx arrays    0    0  256  0\nxHCI input/output contexts    5    6 2112  6\nxHCI ring segments   24   24 4096 24\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          3   32  128  1\nbuffer-32           0    0   32  0\n
+A: pools=poolinfo - 0.1\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          0   32  128  1\nbuffer-32           0    0   32  0\nxHCI 1KB stream ctx arrays    0    0 1024  0\nxHCI 256 byte stream ctx arrays    0    0  256  0\nxHCI input/output contexts   11   12 2112 12\nxHCI ring segments   54   54 4096 54\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          9   32  128  1\nbuffer-32           0    0   32  0\n
 A: power/async=enabled\n
-A: power/control=on\n
+A: power/control=auto\n
 A: power/runtime_active_kids=1\n
-A: power/runtime_active_time=35278060\n
-A: power/runtime_enabled=forbidden\n
+A: power/runtime_active_time=74606194\n
+A: power/runtime_enabled=enabled\n
 A: power/runtime_status=active\n
 A: power/runtime_suspended_time=0\n
-A: power/runtime_usage=1\n
+A: power/runtime_usage=0\n
 A: power/wakeup=enabled\n
 A: power/wakeup_abort_count=0\n
 A: power/wakeup_active=0\n
-A: power/wakeup_active_count=5\n
+A: power/wakeup_active_count=0\n
 A: power/wakeup_count=0\n
-A: power/wakeup_expire_count=5\n
-A: power/wakeup_last_time_ms=12694896\n
-A: power/wakeup_max_time_ms=103\n
-A: power/wakeup_total_time_ms=518\n
-A: power_state=D0\n
-A: resource=0x00000000f7a00000 0x00000000f7a0ffff 0x0000000000140204\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n
-A: revision=0x05\n
-A: subsystem_device=0x201f\n
-A: subsystem_vendor=0x1043\n
+A: power/wakeup_expire_count=0\n
+A: power/wakeup_last_time_ms=0\n
+A: power/wakeup_max_time_ms=0\n
+A: power/wakeup_total_time_ms=0\n
+A: resource=0x00000000a1300000 0x00000000a130ffff 0x0000000000140204\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n
+A: revision=0x30\n
+A: subsystem_device=0x85ef\n
+A: subsystem_vendor=0x103c\n
 A: vendor=0x8086\n

--- a/tests/focaltech_moc/custom.pcapng
+++ b/tests/focaltech_moc/custom.pcapng
--- a/tests/focaltech_moc/custom.py
+++ b/tests/focaltech_moc/custom.py
@@ -1,89 +0,0 @@
-#!/usr/bin/python3
-
-import traceback
-import sys
-import gi
-
-gi.require_version('FPrint', '2.0')
-from gi.repository import FPrint, GLib
-
-# Exit with error on any exception, included those happening in async callbacks
-sys.excepthook = lambda *args: (traceback.print_exception(*args), sys.exit(1))
-
-ctx = GLib.main_context_default()
-
-c = FPrint.Context()
-c.enumerate()
-devices = c.get_devices()
-
-d = devices[0]
-del devices
-
-assert d.get_driver() == "focaltech_moc"
-assert not d.has_feature(FPrint.DeviceFeature.CAPTURE)
-assert d.has_feature(FPrint.DeviceFeature.IDENTIFY)
-assert d.has_feature(FPrint.DeviceFeature.VERIFY)
-assert not d.has_feature(FPrint.DeviceFeature.DUPLICATES_CHECK)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE_LIST)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE_DELETE)
-assert not d.has_feature(FPrint.DeviceFeature.STORAGE_CLEAR)
-
-d.open_sync()
-
-template = FPrint.Print.new(d)
-
-def enroll_progress(*args):
-    #assert d.get_finger_status() == FPrint.FingerStatusFlags.NEEDED
-    print("finger status: ", d.get_finger_status())
-    print('enroll progress: ' + str(args))
-
-def identify_done(dev, res):
-    global identified
-    identified = True
-    identify_match, identify_print = dev.identify_finish(res)
-    print('indentification_done: ', identify_match, identify_print)
-    assert identify_match.equal(identify_print)
-
-# List, enroll, list, verify, identify, delete
-print("enrolling")
-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")
-
-print("listing")
-stored = d.list_prints_sync()
-print("listing done")
-assert len(stored) == 1
-assert stored[0].equal(p)
-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")
-del p
-assert verify_res == True
-
-identified = False
-deserialized_prints = []
-for p in stored:
-    deserialized_prints.append(FPrint.Print.deserialize(p.serialize()))
-    assert deserialized_prints[-1].equal(p)
-del stored
-
-print('async identifying')
-d.identify(deserialized_prints, callback=identify_done)
-del deserialized_prints
-
-while not identified:
-    ctx.iteration(True)
-
-print("deleting")
-d.delete_print_sync(p)
-print("delete done")
-
-d.close_sync()
-
-del d
-del c
--- a/Show More
+++ b/Show More
				`@@ -1 +0,0 @@`
				`gcov-ignore-parse-errors = suspicious_hits.warn`