Release 1.94.8

realtek: add support for rts5816
Signed-off-by: huan_huang <huan_huang@realsil.com.cn>
2026-09-10 21:06:51 +00:00 · 2024-09-03 05:14:11 +02:00 · 2024-09-03 04:44:04 +02:00 · 2024-08-30 04:42:56 +02:00 · 2024-08-30 04:42:56 +02:00 · 2024-08-30 04:42:56 +02:00
33 changed files with 1992 additions and 361 deletions
@@ -35,6 +35,7 @@ stages:
  - build
  - test
  - flatpak
+  - deploy

 image: $FEDORA_IMAGE

@@ -256,3 +257,18 @@ container_fedora_build_on_deps_changed:
      - merge_requests
    changes:
      - .gitlab-ci/libfprint-image-variables.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
@@ -1,6 +1,20 @@
 This file lists notable changes in each release. For the full history of all
 changes, see ChangeLog.

+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:
@@ -46,6 +46,12 @@ We include **Bozorth3** from the **[US Export Controlled]**
 distribution, which we have determined to be fine
 being shipped in an open source project.

+## Get in *touch*
+
+ - [IRC] - `#fprint` @ `irc.oftc.net`
+ - [Matrix] - `#fprint:matrix.org` bridged to the IRC channel
+ - [MailingList] - low traffic, not much used these days
+
 <br/>

 <div align="right">
@@ -62,6 +68,9 @@ being shipped in an open source project.
 [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
@@ -79,6 +79,9 @@ usb:v1C7Ap0571*

 # Supported by libfprint driver egismoc
 usb:v1C7Ap0582*
+usb:v1C7Ap0583*
+usb:v1C7Ap0586*
+usb:v1C7Ap0587*
 usb:v1C7Ap05A1*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0
@@ -156,6 +159,7 @@ usb:v04F3p0C88*
 usb:v04F3p0C8C*
 usb:v04F3p0C8D*
 usb:v04F3p0C99*
+usb:v04F3p0C9F*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

@@ -177,6 +181,8 @@ usb:v10A5pA305*
 usb:v10A5pDA04*
 usb:v10A5pD805*
 usb:v10A5pD205*
+usb:v10A5p9524*
+usb:v10A5p9544*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

@@ -185,6 +191,7 @@ usb:v27C6p5840*
 usb:v27C6p6014*
 usb:v27C6p6092*
 usb:v27C6p6094*
+usb:v27C6p609A*
 usb:v27C6p609C*
 usb:v27C6p60A2*
 usb:v27C6p60A4*
@@ -199,6 +206,8 @@ usb:v27C6p63AC*
 usb:v27C6p63BC*
 usb:v27C6p63CC*
 usb:v27C6p6496*
+usb:v27C6p650A*
+usb:v27C6p650C*
 usb:v27C6p6582*
 usb:v27C6p6584*
 usb:v27C6p658C*
@@ -207,6 +216,7 @@ usb:v27C6p6594*
 usb:v27C6p659A*
 usb:v27C6p659C*
 usb:v27C6p6A94*
+usb:v27C6p6512*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

@@ -217,6 +227,7 @@ usb:v298Dp1010*

 # Supported by libfprint driver realtek
 usb:v0BDAp5813*
+usb:v0BDAp5816*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

@@ -226,6 +237,7 @@ usb:v06CBp00DF*
 usb:v06CBp00F9*
 usb:v06CBp00FC*
 usb:v06CBp00C2*
+usb:v06CBp00C4*
 usb:v06CBp0100*
 usb:v06CBp00F0*
 usb:v06CBp0103*
@@ -238,6 +250,8 @@ usb:v06CBp015F*
 usb:v06CBp0104*
 usb:v06CBp0173*
 usb:v06CBp0106*
+usb:v06CBp019D*
+usb:v06CBp00C6*
 ID_AUTOSUSPEND=1
 ID_PERSIST=0

@@ -334,7 +348,6 @@ usb:v06CBp00A8*
 usb:v06CBp00B7*
 usb:v06CBp00BB*
 usb:v06CBp00BE*
-usb:v06CBp00C4*
 usb:v06CBp00CB*
 usb:v06CBp00C9*
 usb:v06CBp00D8*
@@ -353,6 +366,12 @@ 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*
@@ -32,6 +32,7 @@
 #include <sys/param.h>

 #include "drivers_api.h"
+#include "fpi-byte-writer.h"

 #include "egismoc.h"

@@ -42,15 +43,17 @@ struct _FpiDeviceEgisMoc
  FpiSsm         *cmd_ssm;
  FpiUsbTransfer *cmd_transfer;
  GCancellable   *interrupt_cancellable;
-
-  int             enrolled_num;
  GPtrArray      *enrolled_ids;
+  gint            max_enroll_stages;
 };

 G_DEFINE_TYPE (FpiDeviceEgisMoc, fpi_device_egismoc, FP_TYPE_DEVICE);

 static const FpIdEntry egismoc_id_table[] = {
  { .vid = 0x1c7a, .pid = 0x0582, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 },
+  { .vid = 0x1c7a, .pid = 0x0583, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 },
+  { .vid = 0x1c7a, .pid = 0x0586, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 | EGISMOC_DRIVER_MAX_ENROLL_STAGES_20 },
+  { .vid = 0x1c7a, .pid = 0x0587, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 | EGISMOC_DRIVER_MAX_ENROLL_STAGES_20 },
  { .vid = 0x1c7a, .pid = 0x05a1, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE2 },
  { .vid = 0,      .pid = 0,      .driver_data = 0 }
 };
@@ -154,8 +157,6 @@ egismoc_task_ssm_done (FpiSsm   *ssm,
  self->task_ssm = NULL;

  g_clear_pointer (&self->enrolled_ids, g_ptr_array_unref);
-  self->enrolled_ids = NULL;
-  self->enrolled_num = -1;

  if (error)
    fpi_device_action_error (device, error);
@@ -273,43 +274,24 @@ egismoc_cmd_ssm_done (FpiSsm   *ssm,
    data->callback (device, NULL, 0, g_steal_pointer (&local_error));
 }

-typedef union
-{
-  guint16 check_value;
-  guchar  check_bytes[EGISMOC_CHECK_BYTES_LENGTH];
-} EgisMocCheckBytes;
-
-G_STATIC_ASSERT (G_SIZEOF_MEMBER (EgisMocCheckBytes, check_value) ==
-                 sizeof (guint8) * EGISMOC_CHECK_BYTES_LENGTH);
-
 /*
 * Derive the 2 "check bytes" for write payloads
 * 32-bit big-endian sum of all 16-bit words (including check bytes) MOD 0xFFFF
 * should be 0, otherwise the device will reject the payload
 */
-static EgisMocCheckBytes
-egismoc_get_check_bytes (const guchar *value,
-                         const gsize   value_length)
+static guint16
+egismoc_get_check_bytes (FpiByteReader *reader)
 {
  fp_dbg ("Get check bytes");
-  EgisMocCheckBytes check_bytes;
-  const size_t steps = (value_length + 1) / 2;
-  guint16 values[steps];
  size_t sum_values = 0;
+  guint16 val;

-  for (int i = 0, j = 0; i < value_length; i += 2, j++)
-    {
-      values[j] = (value[i] << 8 & 0xff00);
+  fpi_byte_reader_set_pos (reader, 0);

-      if (i < value_length - 1)
-        values[j] |= value[i + 1] & 0x00ff;
-    }
+  while (fpi_byte_reader_get_uint16_be (reader, &val))
+    sum_values += val;

-  for (int i = 0; i < steps; i++)
-    sum_values += values[i];
-
-  check_bytes.check_value = GUINT16_TO_BE (0xffff - (sum_values % 0xffff));
-  return check_bytes;
+  return G_MAXUINT16 - (sum_values % G_MAXUINT16);
 }

 static void
@@ -319,22 +301,15 @@ egismoc_exec_cmd (FpDevice         *device,
                  GDestroyNotify    cmd_destroy,
                  SynCmdMsgCallback callback)
 {
-  fp_dbg ("Execute command and get response");
-  FpiDeviceEgisMoc *self = FPI_DEVICE_EGISMOC (device);
-  EgisMocCheckBytes check_bytes;
-  g_autofree guchar *buffer_out = NULL;
-  gsize buffer_out_length = 0;
-
+  g_auto(FpiByteWriter) writer = {0};
  g_autoptr(FpiUsbTransfer) transfer = NULL;
-  CommandData *data = g_new0 (CommandData, 1);
+  FpiDeviceEgisMoc *self = FPI_DEVICE_EGISMOC (device);
+  g_autofree CommandData *data = NULL;
+  gsize buffer_out_length = 0;
+  gboolean written = TRUE;
+  guint16 check_value;

-  g_assert (self->cmd_ssm == NULL);
-  self->cmd_ssm = fpi_ssm_new (device,
-                               egismoc_cmd_run_state,
-                               CMD_STATES);
-
-  transfer = fpi_usb_transfer_new (device);
-  transfer->short_is_error = TRUE;
+  fp_dbg ("Execute command and get response");

  /*
   * buffer_out should be a fully composed command (with prefix, check bytes, etc)
@@ -347,40 +322,60 @@ egismoc_exec_cmd (FpDevice         *device,
  buffer_out_length = egismoc_write_prefix_len
                      + EGISMOC_CHECK_BYTES_LENGTH
                      + cmd_length;
-  buffer_out = g_new0 (guchar, buffer_out_length);
+
+  fpi_byte_writer_init_with_size (&writer, buffer_out_length +
+                                  (buffer_out_length % 2 ? 1 : 0), TRUE);

  /* Prefix */
-  memcpy (buffer_out, egismoc_write_prefix, egismoc_write_prefix_len);
+  written &= fpi_byte_writer_put_data (&writer, egismoc_write_prefix,
+                                       egismoc_write_prefix_len);

  /* Check Bytes - leave them as 00 for now then later generate and copy over
   * the real ones */
+  written &= fpi_byte_writer_change_pos (&writer, EGISMOC_CHECK_BYTES_LENGTH);

  /* Command Payload */
-  memcpy (buffer_out + egismoc_write_prefix_len + EGISMOC_CHECK_BYTES_LENGTH,
-          cmd, cmd_length);
-
-  /* destroy cmd if requested */
-  if (cmd_destroy)
-    cmd_destroy (cmd);
+  written &= fpi_byte_writer_put_data (&writer, cmd, cmd_length);

  /* Now fetch and set the "real" check bytes based on the currently
   * assembled payload */
-  check_bytes = egismoc_get_check_bytes (buffer_out, buffer_out_length);
-  memcpy (buffer_out + egismoc_write_prefix_len, check_bytes.check_bytes,
-          EGISMOC_CHECK_BYTES_LENGTH);
+  check_value = egismoc_get_check_bytes (FPI_BYTE_READER (&writer));
+  fpi_byte_writer_set_pos (&writer, egismoc_write_prefix_len);
+  written &= fpi_byte_writer_put_uint16_be (&writer, check_value);
+
+  /* destroy cmd if requested */
+  if (cmd_destroy)
+    g_clear_pointer (&cmd, cmd_destroy);
+
+  g_assert (self->cmd_ssm == NULL);
+  self->cmd_ssm = fpi_ssm_new (device,
+                               egismoc_cmd_run_state,
+                               CMD_STATES);
+
+  data = g_new0 (CommandData, 1);
+  data->callback = callback;
+  fpi_ssm_set_data (self->cmd_ssm, g_steal_pointer (&data), g_free);
+
+  if (!written)
+    {
+      fpi_ssm_start (self->cmd_ssm, egismoc_cmd_ssm_done);
+      fpi_ssm_mark_failed (self->cmd_ssm,
+                           fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
+      return;
+    }
+
+  transfer = fpi_usb_transfer_new (device);
+  transfer->short_is_error = TRUE;
+  transfer->ssm = self->cmd_ssm;

  fpi_usb_transfer_fill_bulk_full (transfer,
                                   EGISMOC_EP_CMD_OUT,
-                                   g_steal_pointer (&buffer_out),
+                                   fpi_byte_writer_reset_and_get_data (&writer),
                                   buffer_out_length,
                                   g_free);
-  transfer->ssm = self->cmd_ssm;

  g_assert (self->cmd_transfer == NULL);
  self->cmd_transfer = g_steal_pointer (&transfer);
-  data->callback = callback;
-
-  fpi_ssm_set_data (self->cmd_ssm, data, g_free);
  fpi_ssm_start (self->cmd_ssm, egismoc_cmd_ssm_done);
 }

@@ -419,11 +414,13 @@ egismoc_get_enrolled_prints (FpDevice *device)
  FpiDeviceEgisMoc *self = FPI_DEVICE_EGISMOC (device);

  g_autoptr(GPtrArray) result = g_ptr_array_new_with_free_func (g_object_unref);
-  FpPrint *print = NULL;

-  for (int i = 0; i < self->enrolled_num; i++)
+  if (!self->enrolled_ids)
+    return g_steal_pointer (&result);
+
+  for (guint i = 0; i < self->enrolled_ids->len; i++)
    {
-      print = fp_print_new (device);
+      FpPrint *print = fp_print_new (device);
      egismoc_set_print_data (print, g_ptr_array_index (self->enrolled_ids, i), NULL);
      g_ptr_array_add (result, g_object_ref_sink (print));
    }
@@ -448,26 +445,37 @@ egismoc_list_fill_enrolled_ids_cb (FpDevice *device,

  g_clear_pointer (&self->enrolled_ids, g_ptr_array_unref);
  self->enrolled_ids = g_ptr_array_new_with_free_func (g_free);
-  self->enrolled_num = 0;
+
+  FpiByteReader reader;
+  gboolean read = TRUE;
+
+  fpi_byte_reader_init (&reader, buffer_in, length_in);
+
+  read &= fpi_byte_reader_set_pos (&reader, EGISMOC_LIST_RESPONSE_PREFIX_SIZE);

  /*
   * Each fingerprint ID will be returned in this response as a 32 byte array
   * The other stuff in the payload is 16 bytes long, so if there is at least 1
   * print then the length should be at least 16+32=48 bytes long
   */
-  for (int pos = EGISMOC_LIST_RESPONSE_PREFIX_SIZE;
-       pos < length_in - EGISMOC_LIST_RESPONSE_SUFFIX_SIZE;
-       pos += EGISMOC_FINGERPRINT_DATA_SIZE, self->enrolled_num++)
+  while (read)
    {
-      g_autofree gchar *print_id = g_strndup ((gchar *) buffer_in + pos,
-                                              EGISMOC_FINGERPRINT_DATA_SIZE);
-      fp_dbg ("Device fingerprint %0d: %.*s", self->enrolled_num,
+      const guint8 *data;
+      g_autofree gchar *print_id = NULL;
+
+      read &= fpi_byte_reader_get_data (&reader, EGISMOC_FINGERPRINT_DATA_SIZE,
+                                        &data);
+      if (!read)
+        break;
+
+      print_id = g_strndup ((gchar *) data, EGISMOC_FINGERPRINT_DATA_SIZE);
+      fp_dbg ("Device fingerprint %0d: %.*s", self->enrolled_ids->len + 1,
              EGISMOC_FINGERPRINT_DATA_SIZE, print_id);
      g_ptr_array_add (self->enrolled_ids, g_steal_pointer (&print_id));
    }

  fp_info ("Number of currently enrolled fingerprints on the device is %d",
-           self->enrolled_num);
+           self->enrolled_ids->len);

  if (self->task_ssm)
    fpi_ssm_next_state (self->task_ssm);
@@ -514,6 +522,7 @@ egismoc_get_delete_cmd (FpDevice *device,
 {
  fp_dbg ("Get delete command");
  FpiDeviceEgisMoc *self = FPI_DEVICE_EGISMOC (device);
+  g_auto(FpiByteWriter) writer = {0};
  g_autoptr(GVariant) print_data = NULL;
  g_autoptr(GVariant) print_data_id_var = NULL;
  const guchar *print_data_id = NULL;
@@ -521,7 +530,7 @@ egismoc_get_delete_cmd (FpDevice *device,
  g_autofree gchar *print_description = NULL;
  g_autofree guchar *enrolled_print_id = NULL;
  g_autofree guchar *result = NULL;
-  gsize pos = 0;
+  gboolean written = TRUE;

  /*
   * The final command body should contain:
@@ -537,7 +546,12 @@ egismoc_get_delete_cmd (FpDevice *device,
   *    identifiers (enrolled_list)
   */

-  const int num_to_delete = (!delete_print) ? self->enrolled_num : 1;
+  int num_to_delete = 0;
+  if (delete_print)
+    num_to_delete = 1;
+  else if (self->enrolled_ids)
+    num_to_delete = self->enrolled_ids->len;
+
  const gsize body_length = sizeof (guchar) * EGISMOC_FINGERPRINT_DATA_SIZE *
                            num_to_delete;
  /* total_length is the 6 various bytes plus prefix and body payload */
@@ -545,10 +559,10 @@ egismoc_get_delete_cmd (FpDevice *device,
                             body_length;

  /* pre-fill entire payload with 00s */
-  result = g_new0 (guchar, total_length);
+  fpi_byte_writer_init_with_size (&writer, total_length, TRUE);

  /* start with 00 00 (just move starting offset up by 2) */
-  pos = 2;
+  written &= fpi_byte_writer_set_pos (&writer, 2);

  /* Size Counter bytes */
  /* "easiest" way to handle 2-bytes size for counter is to hard-code logic for
@@ -557,37 +571,31 @@ egismoc_get_delete_cmd (FpDevice *device,
   * (assumed max is 10) */
  if (num_to_delete > 7)
    {
-      memset (result + pos, 0x01, sizeof (guchar));
-      pos += sizeof (guchar);
-      memset (result + pos, ((num_to_delete - 8) * 0x20) + 0x07, sizeof (guchar));
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_put_uint8 (&writer, 0x01);
+      written &= fpi_byte_writer_put_uint8 (&writer, ((num_to_delete - 8) * 0x20) + 0x07);
    }
  else
    {
      /* first byte is 0x00, just skip it */
-      pos += sizeof (guchar);
-      memset (result + pos, (num_to_delete * 0x20) + 0x07, sizeof (guchar));
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_change_pos (&writer, 1);
+      written &= fpi_byte_writer_put_uint8 (&writer, (num_to_delete * 0x20) + 0x07);
    }

  /* command prefix */
-  memcpy (result + pos, cmd_delete_prefix, cmd_delete_prefix_len);
-  pos += cmd_delete_prefix_len;
+  written &= fpi_byte_writer_put_data (&writer, cmd_delete_prefix,
+                                       cmd_delete_prefix_len);

  /* 2-bytes size logic for counter again */
  if (num_to_delete > 7)
    {
-      memset (result + pos, 0x01, sizeof (guchar));
-      pos += sizeof (guchar);
-      memset (result + pos, ((num_to_delete - 8) * 0x20), sizeof (guchar));
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_put_uint8 (&writer, 0x01);
+      written &= fpi_byte_writer_put_uint8 (&writer, (num_to_delete - 8) * 0x20);
    }
  else
    {
      /* first byte is 0x00, just skip it */
-      pos += sizeof (guchar);
-      memset (result + pos, (num_to_delete * 0x20), sizeof (guchar));
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_change_pos (&writer, 1);
+      written &= fpi_byte_writer_put_uint8 (&writer, num_to_delete * 0x20);
    }

  /* append desired 32-byte fingerprint IDs */
@@ -614,21 +622,26 @@ egismoc_get_delete_cmd (FpDevice *device,

      fp_info ("Delete fingerprint %s (%s)", print_description, print_data_id);

-      memcpy (result + pos, print_data_id, EGISMOC_FINGERPRINT_DATA_SIZE);
+      written &= fpi_byte_writer_put_data (&writer, print_data_id,
+                                           EGISMOC_FINGERPRINT_DATA_SIZE);
    }
  /* Otherwise assume this is a "clear" - just loop through and append all enrolled IDs */
-  else
+  else if (self->enrolled_ids)
    {
-      for (int i = 0; i < self->enrolled_ids->len; i++)
-        memcpy (result + pos + (EGISMOC_FINGERPRINT_DATA_SIZE * i),
-                g_ptr_array_index (self->enrolled_ids, i),
-                EGISMOC_FINGERPRINT_DATA_SIZE);
+      for (guint i = 0; i < self->enrolled_ids->len && written; i++)
+        {
+          written &= fpi_byte_writer_put_data (&writer,
+                                               g_ptr_array_index (self->enrolled_ids, i),
+                                               EGISMOC_FINGERPRINT_DATA_SIZE);
+        }
    }

+  g_assert (written);
+
  if (length_out)
    *length_out = total_length;

-  return g_steal_pointer (&result);
+  return fpi_byte_writer_reset_and_get_data (&writer);
 }

 static void
@@ -687,9 +700,7 @@ egismoc_delete_run_state (FpiSsm   *ssm,
  switch (fpi_ssm_get_cur_state (ssm))
    {
    case DELETE_GET_ENROLLED_IDS:
-      /* get enrolled_ids and enrolled_num from device for use building
-       * delete payload below
-       */
+      /* get enrolled_ids from device for use building delete payload below */
      egismoc_exec_cmd (device, cmd_list, cmd_list_len, NULL,
                        egismoc_list_fill_enrolled_ids_cb);
      break;
@@ -761,7 +772,7 @@ egismoc_enroll_status_report (FpDevice    *device,
      enroll_print->stage++;
      fp_info ("Partial capture successful. Please touch the sensor again (%d/%d)",
               enroll_print->stage,
-               EGISMOC_MAX_ENROLL_NUM);
+               self->max_enroll_stages);
      fpi_device_enroll_progress (device, enroll_print->stage, enroll_print->print, NULL);
      break;

@@ -841,7 +852,7 @@ egismoc_read_capture_cb (FpDevice *device,
      egismoc_enroll_status_report (device, enroll_print, ENROLL_STATUS_RETRY, error);
    }

-  if (enroll_print->stage == EGISMOC_ENROLL_TIMES)
+  if (enroll_print->stage == self->max_enroll_stages)
    fpi_ssm_next_state (self->task_ssm);
  else
    fpi_ssm_jump_to_state (self->task_ssm, ENROLL_CAPTURE_SENSOR_RESET);
@@ -884,26 +895,28 @@ egismoc_get_check_cmd (FpDevice *device,
 {
  fp_dbg ("Get check command");
  FpiDeviceEgisMoc *self = FPI_DEVICE_EGISMOC (device);
+  g_auto(FpiByteWriter) writer = {0};
  g_autofree guchar *result = NULL;
-  gsize pos = 0;
+  gboolean written = TRUE;

  /*
   * The final command body should contain:
   * 1) hard-coded 00 00
   * 2) 2-byte size indiciator, 20*Number enrolled identifiers plus 9 in form of:
-   *    (enrolled_num + 1) * 0x20 + 0x09
+   *    (enrolled_ids->len + 1) * 0x20 + 0x09
   *    Since max prints can be higher than 7 then this goes up to 2 bytes
   *    (e9 + 9 = 109)
   * 3) Hard-coded prefix (cmd_check_prefix)
   * 4) 2-byte size indiciator, 20*Number of enrolled identifiers without plus 9
-   *    ((enrolled_num + 1) * 0x20)
+   *    ((enrolled_ids->len + 1) * 0x20)
   * 5) Hard-coded 32 * 0x00 bytes
   * 6) All of the currently registered prints in their 32-byte device identifiers
   *    (enrolled_list)
   * 7) Hard-coded suffix (cmd_check_suffix)
   */

-  const gsize body_length = sizeof (guchar) * self->enrolled_num *
+  g_assert (self->enrolled_ids);
+  const gsize body_length = sizeof (guchar) * self->enrolled_ids->len *
                            EGISMOC_FINGERPRINT_DATA_SIZE;

  /* prefix length can depend on the type */
@@ -921,87 +934,82 @@ egismoc_get_check_cmd (FpDevice *device,
                             + cmd_check_suffix_len;

  /* pre-fill entire payload with 00s */
-  result = g_new0 (guchar, total_length);
+  fpi_byte_writer_init_with_size (&writer, total_length, TRUE);

  /* start with 00 00 (just move starting offset up by 2) */
-  pos = 2;
+  written &= fpi_byte_writer_set_pos (&writer, 2);

  /* Size Counter bytes */
  /* "easiest" way to handle 2-bytes size for counter is to hard-code logic for
   * when we go to the 2nd byte
   * note this will not work in case any model ever supports more than 14 prints
   * (assumed max is 10) */
-  if (self->enrolled_num > 6)
+  if (self->enrolled_ids->len > 6)
    {
-      memset (result + pos, 0x01, sizeof (guchar));
-      pos += sizeof (guchar);
-      memset (result + pos, ((self->enrolled_num - 7) * 0x20) + 0x09,
-              sizeof (guchar));
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_put_uint8 (&writer, 0x01);
+      written &= fpi_byte_writer_put_uint8 (&writer,
+                                            ((self->enrolled_ids->len - 7) * 0x20)
+                                            + 0x09);
    }
  else
    {
      /* first byte is 0x00, just skip it */
-      pos += sizeof (guchar);
-      memset (result + pos, ((self->enrolled_num + 1) * 0x20) + 0x09,
-              sizeof (guchar));
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_change_pos (&writer, 1);
+      written &= fpi_byte_writer_put_uint8 (&writer,
+                                            ((self->enrolled_ids->len + 1) * 0x20) +
+                                            0x09);
    }

  /* command prefix */
  if (fpi_device_get_driver_data (device) & EGISMOC_DRIVER_CHECK_PREFIX_TYPE2)
-    {
-      memcpy (result + pos, cmd_check_prefix_type2, cmd_check_prefix_type2_len);
-      pos += cmd_check_prefix_type2_len;
-    }
+    written &= fpi_byte_writer_put_data (&writer, cmd_check_prefix_type2,
+                                         cmd_check_prefix_type2_len);
  else
-    {
-      memcpy (result + pos, cmd_check_prefix_type1, cmd_check_prefix_type1_len);
-      pos += cmd_check_prefix_type1_len;
-    }
+    written &= fpi_byte_writer_put_data (&writer, cmd_check_prefix_type1,
+                                         cmd_check_prefix_type1_len);

  /* 2-bytes size logic for counter again */
-  if (self->enrolled_num > 6)
+  if (self->enrolled_ids->len > 6)
    {
-      memset (result + pos, 0x01, sizeof (guchar));
-      pos += sizeof (guchar);
-      memset (result + pos, (self->enrolled_num - 7) * 0x20, sizeof (guchar));
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_put_uint8 (&writer, 0x01);
+      written &= fpi_byte_writer_put_uint8 (&writer,
+                                            (self->enrolled_ids->len - 7) * 0x20);
    }
  else
    {
      /* first byte is 0x00, just skip it */
-      pos += sizeof (guchar);
-      memset (result + pos, (self->enrolled_num + 1) * 0x20, sizeof (guchar));
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_change_pos (&writer, 1);
+      written &= fpi_byte_writer_put_uint8 (&writer,
+                                            (self->enrolled_ids->len + 1) * 0x20);
    }

  /* add 00s "separator" to offset position */
-  pos += EGISMOC_CMD_CHECK_SEPARATOR_LENGTH;
+  written &= fpi_byte_writer_change_pos (&writer,
+                                         EGISMOC_CMD_CHECK_SEPARATOR_LENGTH);

-  /* append all currently registered 32-byte fingerprint IDs */
-  const gsize print_id_length = sizeof (guchar) * EGISMOC_FINGERPRINT_DATA_SIZE;
-
-  for (int i = 0; i < self->enrolled_num; i++)
+  for (guint i = 0; i < self->enrolled_ids->len && written; i++)
    {
-      gchar *device_print_id = g_ptr_array_index (self->enrolled_ids, i);
-      memcpy (result + pos + (print_id_length * i), device_print_id, print_id_length);
+      written &= fpi_byte_writer_put_data (&writer,
+                                           g_ptr_array_index (self->enrolled_ids, i),
+                                           EGISMOC_FINGERPRINT_DATA_SIZE);
    }
-  pos += body_length;

  /* command suffix */
-  memcpy (result + pos, cmd_check_suffix, cmd_check_suffix_len);
+  written &= fpi_byte_writer_put_data (&writer, cmd_check_suffix,
+                                       cmd_check_suffix_len);
+  g_assert (written);

  if (length_out)
    *length_out = total_length;

-  return g_steal_pointer (&result);
+  return fpi_byte_writer_reset_and_get_data (&writer);
 }

 static void
 egismoc_enroll_run_state (FpiSsm   *ssm,
                          FpDevice *device)
 {
+  g_auto(FpiByteWriter) writer = {0};
  FpiDeviceEgisMoc *self = FPI_DEVICE_EGISMOC (device);
  EnrollPrint *enroll_print = fpi_ssm_get_data (ssm);
  g_autofree guchar *payload = NULL;
@@ -1012,13 +1020,13 @@ egismoc_enroll_run_state (FpiSsm   *ssm,
  switch (fpi_ssm_get_cur_state (ssm))
    {
    case ENROLL_GET_ENROLLED_IDS:
-      /* get enrolled_ids and enrolled_num from device for use in check stages below */
+      /* get enrolled_ids from device for use in check stages below */
      egismoc_exec_cmd (device, cmd_list, cmd_list_len,
                        NULL, egismoc_list_fill_enrolled_ids_cb);
      break;

    case ENROLL_CHECK_ENROLLED_NUM:
-      if (self->enrolled_num >= EGISMOC_MAX_ENROLL_NUM)
+      if (self->enrolled_ids->len >= EGISMOC_MAX_ENROLL_NUM)
        {
          egismoc_enroll_status_report (device, enroll_print, ENROLL_STATUS_DEVICE_FULL,
                                        fpi_device_error_new (FP_DEVICE_ERROR_DATA_FULL));
@@ -1089,14 +1097,23 @@ egismoc_enroll_run_state (FpiSsm   *ssm,
      device_print_id = g_strndup (user_id, EGISMOC_FINGERPRINT_DATA_SIZE);
      egismoc_set_print_data (enroll_print->print, device_print_id, user_id);

-      /* create new dynamic payload of cmd_new_print_prefix + device_print_id */
-      payload_length = cmd_new_print_prefix_len + EGISMOC_FINGERPRINT_DATA_SIZE;
-      payload = g_new0 (guchar, payload_length);
-      memcpy (payload, cmd_new_print_prefix, cmd_new_print_prefix_len);
-      memcpy (payload + cmd_new_print_prefix_len, device_print_id,
-              EGISMOC_FINGERPRINT_DATA_SIZE);
+      fpi_byte_writer_init (&writer);
+      if (!fpi_byte_writer_put_data (&writer, cmd_new_print_prefix,
+                                     cmd_new_print_prefix_len))
+        {
+          fpi_ssm_mark_failed (ssm, fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
+          break;
+        }
+      if (!fpi_byte_writer_put_data (&writer, (guint8 *) device_print_id,
+                                     EGISMOC_FINGERPRINT_DATA_SIZE))
+        {
+          fpi_ssm_mark_failed (ssm, fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
+          break;
+        }

-      egismoc_exec_cmd (device, g_steal_pointer (&payload), payload_length,
+      payload_length = fpi_byte_writer_get_size (&writer);
+      egismoc_exec_cmd (device, fpi_byte_writer_reset_and_get_data (&writer),
+                        payload_length,
                        g_free, egismoc_task_ssm_next_state_cb);
      break;

@@ -1239,13 +1256,13 @@ egismoc_identify_run_state (FpiSsm   *ssm,
  switch (fpi_ssm_get_cur_state (ssm))
    {
    case IDENTIFY_GET_ENROLLED_IDS:
-      /* get enrolled_ids and enrolled_num from device for use in check stages below */
+      /* get enrolled_ids from device for use in check stages below */
      egismoc_exec_cmd (device, cmd_list, cmd_list_len,
                        NULL, egismoc_list_fill_enrolled_ids_cb);
      break;

    case IDENTIFY_CHECK_ENROLLED_NUM:
-      if (self->enrolled_num == 0)
+      if (self->enrolled_ids->len == 0)
        {
          fpi_ssm_mark_failed (g_steal_pointer (&self->task_ssm),
                               fpi_device_error_new (FP_DEVICE_ERROR_DATA_NOT_FOUND));
@@ -1446,6 +1463,71 @@ egismoc_dev_init_handler (FpiSsm   *ssm,
                           NULL);
 }

+static void
+egismoc_probe (FpDevice *device)
+{
+  GUsbDevice *usb_dev;
+  GError *error = NULL;
+  g_autofree gchar *serial = NULL;
+  FpiDeviceEgisMoc *self = FPI_DEVICE_EGISMOC (device);
+
+  fp_dbg ("%s enter --> ", G_STRFUNC);
+
+  /* Claim usb interface */
+  usb_dev = fpi_device_get_usb_device (device);
+  if (!g_usb_device_open (usb_dev, &error))
+    {
+      fp_dbg ("%s g_usb_device_open failed %s", G_STRFUNC, error->message);
+      fpi_device_probe_complete (device, NULL, NULL, error);
+      return;
+    }
+
+  if (!g_usb_device_reset (usb_dev, &error))
+    {
+      fp_dbg ("%s g_usb_device_reset failed %s", G_STRFUNC, error->message);
+      g_usb_device_close (usb_dev, NULL);
+      fpi_device_probe_complete (device, NULL, NULL, error);
+      return;
+    }
+
+  if (!g_usb_device_claim_interface (usb_dev, 0, 0, &error))
+    {
+      fp_dbg ("%s g_usb_device_claim_interface failed %s", G_STRFUNC, error->message);
+      g_usb_device_close (usb_dev, NULL);
+      fpi_device_probe_complete (device, NULL, NULL, error);
+      return;
+    }
+
+  if (g_strcmp0 (g_getenv ("FP_DEVICE_EMULATION"), "1") == 0)
+    serial = g_strdup ("emulated-device");
+  else
+    serial = g_usb_device_get_string_descriptor (usb_dev,
+                                                 g_usb_device_get_serial_number_index (usb_dev),
+                                                 &error);
+
+  if (error)
+    {
+      fp_dbg ("%s g_usb_device_get_string_descriptor failed %s", G_STRFUNC, error->message);
+      g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (device)),
+                                      0, 0, NULL);
+      g_usb_device_close (usb_dev, NULL);
+      fpi_device_probe_complete (device, NULL, NULL, error);
+      return;
+    }
+
+  if (fpi_device_get_driver_data (device) & EGISMOC_DRIVER_MAX_ENROLL_STAGES_20)
+    self->max_enroll_stages = 20;
+  else
+    self->max_enroll_stages = EGISMOC_MAX_ENROLL_STAGES_DEFAULT;
+
+  fpi_device_set_nr_enroll_stages (device, self->max_enroll_stages);
+
+  g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (device)), 0, 0, NULL);
+  g_usb_device_close (usb_dev, NULL);
+
+  fpi_device_probe_complete (device, serial, NULL, error);
+}
+
 static void
 egismoc_open (FpDevice *device)
 {
@@ -1526,10 +1608,11 @@ fpi_device_egismoc_class_init (FpiDeviceEgisMocClass *klass)
  dev_class->type = FP_DEVICE_TYPE_USB;
  dev_class->scan_type = FP_SCAN_TYPE_PRESS;
  dev_class->id_table = egismoc_id_table;
-  dev_class->nr_enroll_stages = EGISMOC_ENROLL_TIMES;
+  dev_class->nr_enroll_stages = EGISMOC_MAX_ENROLL_STAGES_DEFAULT;
  /* device should be "always off" unless being used */
  dev_class->temp_hot_seconds = 0;

+  dev_class->probe = egismoc_probe;
  dev_class->open = egismoc_open;
  dev_class->cancel = egismoc_cancel;
  dev_class->suspend = egismoc_suspend;
@@ -36,6 +36,7 @@ G_DECLARE_FINAL_TYPE (FpiDeviceEgisMoc, fpi_device_egismoc, FPI, DEVICE_EGISMOC,

 #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)
@@ -49,7 +50,7 @@ G_DECLARE_FINAL_TYPE (FpiDeviceEgisMoc, fpi_device_egismoc, FPI, DEVICE_EGISMOC,
 #define EGISMOC_USB_IN_RECV_LENGTH 4096
 #define EGISMOC_USB_INTERRUPT_IN_RECV_LENGTH 64

-#define EGISMOC_ENROLL_TIMES 10
+#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
@@ -100,11 +101,11 @@ static guchar cmd_read_capture[] = {0x00, 0x00, 0x00, 0x07, 0x50, 0x16, 0x02, 0x
 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[] = {0x0a, 0x90, 0x00};
+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[] = {0x0a, 0x64, 0x91};
+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]);
@@ -32,6 +32,7 @@ static const FpIdEntry id_table[] = {
  { .vid = 0x04f3,  .pid = 0x0c8c,  },
  { .vid = 0x04f3,  .pid = 0x0c8d,  },
  { .vid = 0x04f3,  .pid = 0x0c99,  },
+  { .vid = 0x04f3,  .pid = 0x0c9f,  },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };

@@ -21,7 +21,7 @@

 #define FP_COMPONENT "fpcmoc"
 #define MAX_ENROLL_SAMPLES (25)
-#define CTRL_TIMEOUT (1000)
+#define CTRL_TIMEOUT (2000)
 #define DATA_TIMEOUT (5000)

 /* Usb port setting */
@@ -68,6 +68,8 @@ static const FpIdEntry id_table[] = {
  { .vid = 0x10A5,  .pid = 0xDA04,  },
  { .vid = 0x10A5,  .pid = 0xD805,  },
  { .vid = 0x10A5,  .pid = 0xD205,  },
+  { .vid = 0x10A5,  .pid = 0x9524,  },
+  { .vid = 0x10A5,  .pid = 0x9544,  },
  /* terminating entry */
  { .vid = 0,  .pid = 0,  .driver_data = 0 },
 };
@@ -269,6 +271,7 @@ fpc_cmd_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
  FpiDeviceFpcMoc *self = FPI_DEVICE_FPCMOC (dev);
  CommandData *data = fpi_ssm_get_data (ssm);

+  self->cmd_ssm = NULL;
  /* Notify about the SSM failure from here instead. */
  if (error)
    {
@@ -276,8 +279,6 @@ fpc_cmd_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
      if (data->callback)
        data->callback (self, NULL, error);
    }
-
-  self->cmd_ssm = NULL;
 }

 static void
@@ -388,7 +389,7 @@ fpc_dev_release_interface (FpiDeviceFpcMoc *self,
    }

  /* Notify close complete */
-  fpi_device_close_complete (FP_DEVICE (self), release_error);
+  fpi_device_close_complete (FP_DEVICE (self), g_steal_pointer (&release_error));
 }

 static gboolean
@@ -446,10 +447,16 @@ fpc_evt_cb (FpiDeviceFpcMoc *self,
      break;

    case FPC_EVT_FINGER_DWN:
-      fp_dbg ("%s Got finger down event", G_STRFUNC);
+      fp_dbg ("%s Got finger down event (%d)", G_STRFUNC, presp->evt_hdr.status);
      fpi_device_report_finger_status_changes (FP_DEVICE (self),
                                               FP_FINGER_STATUS_PRESENT,
                                               FP_FINGER_STATUS_NONE);
+      if (presp->evt_hdr.status != 0)
+        {
+          /* Redo the current task state if capture failed */
+          fpi_ssm_jump_to_state (self->task_ssm, fpi_ssm_get_cur_state (self->task_ssm));
+          return;
+        }
      break;

    case FPC_EVT_IMG:
@@ -742,15 +749,22 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
      /* here should tips remove finger and try again */
      if (self->max_immobile_stage)
        {
-          if (self->immobile_stage >= self->max_immobile_stage)
+          self->immobile_stage++;
+          if (self->immobile_stage > self->max_immobile_stage)
            {
              fp_dbg ("Skip similar handle due to customer enrollment %d(%d)",
                      self->immobile_stage, self->max_immobile_stage);
              /* Skip too similar handle, treat as normal enroll progress. */
-              fpi_ssm_jump_to_state (self->task_ssm, FPC_ENROL_STATUS_PROGRESS);
+              self->enroll_stage++;
+              fpi_device_enroll_progress (FP_DEVICE (self), self->enroll_stage, NULL, NULL);
+              /* Used for customer enrollment scheme */
+              if (self->enroll_stage >= (self->max_enroll_stage - self->max_immobile_stage))
+                {
+                  fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
+                  return;
+                }
              break;
            }
-          self->immobile_stage++;
        }
      fpi_device_enroll_progress (FP_DEVICE (self),
                                  self->enroll_stage,
@@ -763,7 +777,10 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
      fpi_device_enroll_progress (FP_DEVICE (self), self->enroll_stage, NULL, NULL);
      /* Used for customer enrollment scheme */
      if (self->enroll_stage >= (self->max_enroll_stage - self->max_immobile_stage))
-        fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
+        {
+          fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
+          return;
+        }
      break;

    case FPC_ENROL_STATUS_IMAGE_LOW_COVERAGE:
@@ -1623,6 +1640,8 @@ fpc_dev_probe (FpDevice *device)
    case 0xD805:
    case 0xDA04:
    case 0xD205:
+    case 0x9524:
+    case 0x9544:
      self->max_enroll_stage = MAX_ENROLL_SAMPLES;
      break;

@@ -1363,6 +1363,7 @@ gx_fp_probe (FpDevice *device)
    case 0x6014:
    case 0x6092:
    case 0x6094:
+    case 0x609A:
    case 0x609C:
    case 0x60BC:
    case 0x6304:
@@ -1374,6 +1375,8 @@ gx_fp_probe (FpDevice *device)
    case 0x63AC:
    case 0x63BC:
    case 0x63CC:
+    case 0x650A:
+    case 0x650C:
    case 0x6582:
    case 0x6A94:
    case 0x659A:
@@ -1610,6 +1613,7 @@ static const FpIdEntry id_table[] = {
  { .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,  },
@@ -1624,6 +1628,8 @@ static const FpIdEntry id_table[] = {
  { .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,  },
@@ -1632,6 +1638,7 @@ static const FpIdEntry id_table[] = {
  { .vid = 0x27c6,  .pid = 0x659A,  },
  { .vid = 0x27c6,  .pid = 0x659C,  },
  { .vid = 0x27c6,  .pid = 0x6A94,  },
+  { .vid = 0x27c6,  .pid = 0x6512,  },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };

@@ -28,6 +28,7 @@ G_DEFINE_TYPE (FpiDeviceRealtek, fpi_device_realtek, FP_TYPE_DEVICE)

 static const FpIdEntry id_table[] = {
  { .vid = 0x0bda,  .pid = 0x5813,  },
+  { .vid = 0x0bda,  .pid = 0x5816,  },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };

@@ -92,6 +93,50 @@ fp_task_ssm_generic_cb (FpiDeviceRealtek *self,
  fpi_ssm_next_state (self->task_ssm);
 }

+static void
+fp_get_device_info_cb (FpiDeviceRealtek *self,
+                       uint8_t          *buffer_in,
+                       GError           *error)
+{
+  if (error)
+    {
+      fpi_ssm_mark_failed (self->task_ssm, error);
+      return;
+    }
+
+  self->template_len = TEMPLATE_LEN_COMMON;
+
+  fpi_ssm_next_state (self->task_ssm);
+}
+
+static void
+fp_update_template_cb (FpiDeviceRealtek *self,
+                       uint8_t          *buffer_in,
+                       GError           *error)
+{
+  if (error)
+    {
+      fpi_ssm_mark_failed (self->task_ssm, error);
+      return;
+    }
+
+  fpi_ssm_jump_to_state (self->task_ssm, FP_RTK_VERIFY_NUM_STATES);
+}
+
+static void
+fp_enroll_commit_cb (FpiDeviceRealtek *self,
+                     uint8_t          *buffer_in,
+                     GError           *error)
+{
+  if (error)
+    {
+      fpi_ssm_mark_failed (self->task_ssm, error);
+      return;
+    }
+
+  fpi_ssm_jump_to_state (self->task_ssm, FP_RTK_ENROLL_NUM_STATES);
+}
+
 static void
 fp_finish_capture_cb (FpiDeviceRealtek *self,
                      uint8_t          *buffer_in,
@@ -103,8 +148,17 @@ fp_finish_capture_cb (FpiDeviceRealtek *self,
      return;
    }

-  gint capture_status = buffer_in[0];
+  /* We hope this polling CMD can be completed before the action is cancelled */
+  GCancellable *cancellable = fpi_device_get_cancellable (FP_DEVICE (self));
+  if (g_cancellable_is_cancelled (cancellable))
+    {
+      fpi_ssm_mark_failed (self->task_ssm,
+                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
+                                                     "Action is cancelled!"));
+      return;
+    }

+  gint capture_status = buffer_in[0];
  if (capture_status == 0)
    {
      fpi_device_report_finger_status_changes (FP_DEVICE (self),
@@ -238,7 +292,6 @@ fp_identify_feature_cb (FpiDeviceRealtek *self,
    }

  gint in_status = buffer_in[0];
-
  if (in_status == FP_RTK_CMD_ERR)
    {
      fpi_ssm_mark_failed (self->task_ssm,
@@ -291,7 +344,7 @@ fp_identify_feature_cb (FpiDeviceRealtek *self,
          else
            {
              fpi_device_identify_report (device, print, match, error);
-              fpi_ssm_mark_completed (self->task_ssm);
+              fpi_ssm_jump_to_state (self->task_ssm, FP_RTK_VERIFY_NUM_STATES);
            }
          return;
        }
@@ -340,9 +393,9 @@ fp_get_delete_pos_cb (FpiDeviceRealtek *self,

  for (gint i = 0; i < self->template_num; i++)
    {
-      if (buffer_in[i * TEMPLATE_LEN] != 0)
+      if (buffer_in[i * self->template_len] != 0)
        {
-          memcpy (temp_userid, buffer_in + i * TEMPLATE_LEN + UID_OFFSET, DEFAULT_UID_LEN);
+          memcpy (temp_userid, buffer_in + i * self->template_len + UID_OFFSET, DEFAULT_UID_LEN);
          if (g_strcmp0 (fp_print_get_description (print), (const char *) temp_userid) == 0)
            {
              self->pos_index = i;
@@ -380,10 +433,25 @@ fp_get_enroll_num_cb (FpiDeviceRealtek *self,
 }

 static void
-fp_get_template_cb (FpiDeviceRealtek *self,
-                    uint8_t          *buffer_in,
-                    GError           *error)
+fp_verify_get_template_cb (FpiDeviceRealtek *self,
+                           uint8_t          *buffer_in,
+                           GError           *error)
 {
+  if (error)
+    {
+      fpi_ssm_mark_failed (self->task_ssm, error);
+      return;
+    }
+
+  fpi_ssm_next_state (self->task_ssm);
+}
+
+static void
+fp_enroll_get_template_cb (FpiDeviceRealtek *self,
+                           uint8_t          *buffer_in,
+                           GError           *error)
+{
+  g_autofree guchar *seq_list = NULL;
  gboolean found = FALSE;

  if (error)
@@ -394,7 +462,7 @@ fp_get_template_cb (FpiDeviceRealtek *self,

  for (gint i = 0; i < self->template_num; i++)
    {
-      if (buffer_in[i * TEMPLATE_LEN] == 0)
+      if (buffer_in[i * self->template_len] == 0)
        {
          self->pos_index = i;
          found = TRUE;
@@ -425,7 +493,6 @@ fp_check_duplicate_cb (FpiDeviceRealtek *self,
    }

  gint in_status = buffer_in[0];
-
  if (in_status == FP_RTK_CMD_ERR)
    {
      fpi_ssm_mark_failed (self->task_ssm,
@@ -471,10 +538,10 @@ fp_list_cb (FpiDeviceRealtek *self,

  for (gint i = 0; i < self->template_num; i++)
    {
-      if (buffer_in[i * TEMPLATE_LEN] != 0)
+      if (buffer_in[i * self->template_len] != 0)
        {
          FpPrint *print = NULL;
-          print = fp_print_from_data (self, buffer_in + i * TEMPLATE_LEN + SUBFACTOR_OFFSET);
+          print = fp_print_from_data (self, buffer_in + i * self->template_len + SUBFACTOR_OFFSET);
          g_ptr_array_add (list_result, g_object_ref_sink (print));
          found = TRUE;
        }
@@ -518,11 +585,11 @@ parse_status (guint8 *buffer, gint status_type)
 {
  switch (status_type)
    {
-    case FP_RTK_MSG_PLAINTEXT_NO_STATUS:
+    case FP_RTK_MSG_NO_STATUS:
      return 0;
      break;

-    case FP_RTK_MSG_PLAINTEXT:
+    case FP_RTK_MSG_DEFAULT:
      return buffer[0];
      break;

@@ -621,13 +688,13 @@ fp_cmd_run_state (FpiSsm *ssm, FpDevice *dev)
      break;

    case FP_RTK_CMD_TRANS_DATA:
-      if (self->cmd_type == FP_RTK_CMD_ONLY)
+      if (self->cmd_type == FP_RTK_CMD_BULK_ONLY)
        {
          fpi_ssm_jump_to_state (ssm, FP_RTK_CMD_GET_STATUS);
          break;
        }

-      if (self->cmd_type == FP_RTK_CMD_WRITE)
+      if (self->cmd_type == FP_RTK_CMD_BULK_WRITE)
        {
          if (self->data_transfer)
            {
@@ -688,10 +755,10 @@ fp_cmd_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
 }

 static FpiUsbTransfer *
-prepare_transfer (FpDevice      *dev,
-                  guint8        *data,
-                  gsize          data_len,
-                  GDestroyNotify free_func)
+prepare_bulk_transfer (FpDevice      *dev,
+                       guint8        *data,
+                       gsize          data_len,
+                       GDestroyNotify free_func)
 {
  g_autoptr(FpiUsbTransfer) transfer = NULL;

@@ -708,29 +775,100 @@ prepare_transfer (FpDevice      *dev,
  return g_steal_pointer (&transfer);
 }

+
 static void
-realtek_sensor_cmd (FpiDeviceRealtek *self,
-                    guint8           *cmd,
-                    guint8           *trans_data,
-                    FpRtkMsgType      message_type,
-                    gboolean          bwait_data_delay,
-                    SynCmdMsgCallback callback)
+fp_ctrl_cmd_cb (FpiUsbTransfer *transfer,
+                FpDevice       *device,
+                gpointer        user_data,
+                GError         *error)
+{
+  FpiDeviceRealtek *self = FPI_DEVICE_REALTEK (device);
+  g_autofree CommandData *data = g_steal_pointer (&user_data);
+
+  g_return_if_fail (data != NULL);
+
+  if (error)
+    {
+      fpi_ssm_mark_failed (transfer->ssm, error);
+      return;
+    }
+
+  if (transfer->direction == G_USB_DEVICE_DIRECTION_HOST_TO_DEVICE)
+    {
+      if (data->callback)
+        data->callback (self, NULL, NULL);
+    }
+  else
+    {
+      if (transfer->actual_length == 0)
+        {
+          fp_info ("Control transfer receive data failed!");
+          fpi_ssm_mark_failed (transfer->ssm,
+                               fpi_device_error_new (FP_DEVICE_ERROR_DATA_INVALID));
+          return;
+        }
+
+      if (data->callback)
+        data->callback (self, transfer->buffer, NULL);
+    }
+}
+
+static void
+rtk_send_ctrl_cmd (FpiDeviceRealtek    *self,
+                   struct rtk_cmd_ctrl *ctrl_cmd,
+                   guint8              *cmd_data,
+                   SynCmdMsgCallback    callback)
+{
+  FpiUsbTransfer *transfer = NULL;
+  g_autofree CommandData *data = g_new0 (CommandData, 1);
+
+  data->callback = callback;
+
+  transfer = fpi_usb_transfer_new (FP_DEVICE (self));
+  fpi_usb_transfer_fill_control (transfer,
+                                 ctrl_cmd->direction,
+                                 G_USB_DEVICE_REQUEST_TYPE_VENDOR,
+                                 G_USB_DEVICE_RECIPIENT_DEVICE,
+                                 ctrl_cmd->request,
+                                 ctrl_cmd->value,
+                                 ctrl_cmd->index,
+                                 ctrl_cmd->len);
+
+  transfer->ssm = self->task_ssm;
+  if (ctrl_cmd->direction == G_USB_DEVICE_DIRECTION_DEVICE_TO_HOST &&
+      cmd_data != NULL && ctrl_cmd->len != 0)
+    memcpy (transfer->buffer, cmd_data, ctrl_cmd->len);
+
+  fpi_usb_transfer_submit (transfer,
+                           CMD_TIMEOUT,
+                           NULL,
+                           fp_ctrl_cmd_cb,
+                           g_steal_pointer (&data));
+}
+
+static void
+rtk_sensor_bulk_cmd (FpiDeviceRealtek *self,
+                     guint8           *cmd,
+                     guint8           *trans_data,
+                     FpRtkMsgType      message_type,
+                     gboolean          bwait_data_delay,
+                     SynCmdMsgCallback callback)
 {
  g_autoptr(FpiUsbTransfer) cmd_transfer = NULL;
  g_autoptr(FpiUsbTransfer) data_transfer = NULL;
  CommandData *data = g_new0 (CommandData, 1);

-  self->cmd_type = GET_CMD_TYPE (cmd[0]);
+  self->cmd_type = GET_BULK_CMD_TYPE (cmd[0]);
  self->message_type = message_type;
  self->trans_data_len = GET_TRANS_DATA_LEN (cmd[11], cmd[10]);
  self->cmd_cancellable = bwait_data_delay;

-  cmd_transfer = prepare_transfer (FP_DEVICE (self), cmd, FP_RTK_CMD_TOTAL_LEN, NULL);
+  cmd_transfer = prepare_bulk_transfer (FP_DEVICE (self), cmd, FP_RTK_CMD_BULK_TOTAL_LEN, NULL);
  self->cmd_transfer = g_steal_pointer (&cmd_transfer);

-  if ((self->cmd_type == FP_RTK_CMD_WRITE) && trans_data)
+  if ((self->cmd_type == FP_RTK_CMD_BULK_WRITE) && trans_data)
    {
-      data_transfer = prepare_transfer (FP_DEVICE (self), trans_data, self->trans_data_len, g_free);
+      data_transfer = prepare_bulk_transfer (FP_DEVICE (self), trans_data, self->trans_data_len, g_free);
      self->data_transfer = g_steal_pointer (&data_transfer);
    }

@@ -829,34 +967,49 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)

  switch (fpi_ssm_get_cur_state (ssm))
    {
+    case FP_RTK_VERIFY_GET_TEMPLATE:
+      g_assert (self->template_num > 0);
+
+      co_get_template.data_len[0] = GET_LEN_L (self->template_len * self->template_num);
+      co_get_template.data_len[1] = GET_LEN_H (self->template_len * self->template_num);
+      cmd_buf = (guint8 *) &co_get_template;
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 0, fp_verify_get_template_cb);
+      break;
+
    case FP_RTK_VERIFY_CAPTURE:
      fpi_device_report_finger_status_changes (device,
                                               FP_FINGER_STATUS_NEEDED,
                                               FP_FINGER_STATUS_NONE);

      cmd_buf = (guint8 *) &co_start_capture;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT, 1, fp_task_ssm_generic_cb);
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 0, fp_task_ssm_generic_cb);
      break;

    case FP_RTK_VERIFY_FINISH_CAPTURE:
      cmd_buf = (guint8 *) &co_finish_capture;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT, 1, fp_finish_capture_cb);
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 0, fp_finish_capture_cb);
      break;

    case FP_RTK_VERIFY_ACCEPT_SAMPLE:
      co_accept_sample.param[0] = self->fp_purpose;
      cmd_buf = (guint8 *) &co_accept_sample;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT_NO_STATUS, 1, fp_accept_sample_cb);
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_NO_STATUS, 0, fp_accept_sample_cb);
      break;

    case FP_RTK_VERIFY_INDENTIFY_FEATURE:
-      cmd_buf = (guint8 *) &tls_identify_feature;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT_NO_STATUS, 0, fp_identify_feature_cb);
+      cmd_buf = (guint8 *) &nor_identify_feature;
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_NO_STATUS, 0, fp_identify_feature_cb);
      break;

    case FP_RTK_VERIFY_UPDATE_TEMPLATE:
      cmd_buf = (guint8 *) &co_update_template;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT, 0, fp_task_ssm_generic_cb);
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 0, fp_update_template_cb);
+      break;
+
+    case FP_RTK_VERIFY_CANCEL_CAPTURE:
+      co_cancel_capture.param[0] = self->fp_purpose;
+      cmd_buf = (guint8 *) &co_cancel_capture;
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 0, fp_task_ssm_generic_cb);
      break;
    }
 }
@@ -869,7 +1022,6 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
  FpiDeviceRealtek *self = FPI_DEVICE_REALTEK (device);
  FpPrint *print = NULL;
  guint8 *cmd_buf = NULL;
-  guint8 *trans_id = NULL;
  GVariant *uid = NULL;
  GVariant *data = NULL;
  gsize user_id_len;
@@ -880,17 +1032,17 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
    case FP_RTK_ENROLL_GET_TEMPLATE:
      g_assert (self->template_num > 0);

-      co_get_template.data_len[0] = GET_LEN_L (TEMPLATE_LEN * self->template_num);
-      co_get_template.data_len[1] = GET_LEN_H (TEMPLATE_LEN * self->template_num);
+      co_get_template.data_len[0] = GET_LEN_L (self->template_len * self->template_num);
+      co_get_template.data_len[1] = GET_LEN_H (self->template_len * self->template_num);

      cmd_buf = (guint8 *) &co_get_template;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT, 0, fp_get_template_cb);
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 0, fp_enroll_get_template_cb);
      break;

    case FP_RTK_ENROLL_BEGIN_POS:
-      tls_enroll_begin.param[0] = self->pos_index;
-      cmd_buf = (guint8 *) &tls_enroll_begin;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT, 0, fp_task_ssm_generic_cb);
+      nor_enroll_begin.param[0] = self->pos_index;
+      cmd_buf = (guint8 *) &nor_enroll_begin;
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 0, fp_task_ssm_generic_cb);
      break;

    case FP_RTK_ENROLL_CAPTURE:
@@ -899,32 +1051,37 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                                               FP_FINGER_STATUS_NONE);

      cmd_buf = (guint8 *) &co_start_capture;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT, 1, fp_task_ssm_generic_cb);
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 0, fp_task_ssm_generic_cb);
      break;

    case FP_RTK_ENROLL_FINISH_CAPTURE:
      cmd_buf = (guint8 *) &co_finish_capture;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT, 1, fp_finish_capture_cb);
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 0, fp_finish_capture_cb);
      break;

    case FP_RTK_ENROLL_ACCEPT_SAMPLE:
      co_accept_sample.param[0] = self->fp_purpose;
      cmd_buf = (guint8 *) &co_accept_sample;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT_NO_STATUS, 1, fp_accept_sample_cb);
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_NO_STATUS, 0, fp_accept_sample_cb);
      break;

    case FP_RTK_ENROLL_CHECK_DUPLICATE:
      cmd_buf = (guint8 *) &co_check_duplicate;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT_NO_STATUS, 1, fp_check_duplicate_cb);
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_NO_STATUS, 0, fp_check_duplicate_cb);
      break;

    case FP_RTK_ENROLL_COMMIT:
+      guint8 *trans_id = NULL;
+      gint payload_len;
+
+      payload_len = UID_PAYLOAD_LEN_DEFAULT;
+
      fpi_device_get_enroll_data (device, &print);
      user_id = fpi_print_generate_user_id (print);
      user_id_len = strlen (user_id);
      user_id_len = MIN (DEFAULT_UID_LEN, user_id_len);

-      payload = g_malloc0 (UID_PAYLOAD_LEN);
+      payload = g_malloc0 (payload_len);
      memcpy (payload, user_id, user_id_len);

      trans_id = g_steal_pointer (&payload);
@@ -945,10 +1102,18 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)

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

-      tls_enroll_commit.param[0] = SUB_FINGER_01;
-      cmd_buf = (guint8 *) &tls_enroll_commit;
-      realtek_sensor_cmd (self, cmd_buf, trans_id, FP_RTK_MSG_PLAINTEXT, 0, fp_task_ssm_generic_cb);
+      nor_enroll_commit.param[0] = SUB_FINGER_01;
+      nor_enroll_commit.data_len[0] = GET_LEN_L (payload_len);
+      nor_enroll_commit.data_len[1] = GET_LEN_H (payload_len);
+
+      cmd_buf = (guint8 *) &nor_enroll_commit;
+      rtk_sensor_bulk_cmd (self, cmd_buf, trans_id, FP_RTK_MSG_DEFAULT, 1, fp_enroll_commit_cb);
      break;
+
+    case FP_RTK_ENROLL_CANCEL_CAPTURE:
+      co_cancel_capture.param[0] = self->fp_purpose;
+      cmd_buf = (guint8 *) &co_cancel_capture;
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 0, fp_task_ssm_generic_cb);
    }
 }

@@ -960,15 +1125,19 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)

  switch (fpi_ssm_get_cur_state (ssm))
    {
+    case FP_RTK_INIT_GET_DEVICE_INFO:
+      rtk_send_ctrl_cmd (self, &get_device_info, NULL, fp_get_device_info_cb);
+      break;
+
    case FP_RTK_INIT_SELECT_OS:
      co_select_system.param[0] = 0x01;
      cmd_buf = (guint8 *) &co_select_system;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT, 0, fp_task_ssm_generic_cb);
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 0, fp_task_ssm_generic_cb);
      break;

    case FP_RTK_INIT_GET_ENROLL_NUM:
      cmd_buf = (guint8 *) &co_get_enroll_num;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT, 0, fp_get_enroll_num_cb);
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 0, fp_get_enroll_num_cb);
      break;
    }
 }
@@ -984,17 +1153,17 @@ fp_delete_sm_run_state (FpiSsm *ssm, FpDevice *device)
    case FP_RTK_DELETE_GET_POS:
      g_assert (self->template_num > 0);

-      co_get_template.data_len[0] = GET_LEN_L (TEMPLATE_LEN * self->template_num);
-      co_get_template.data_len[1] = GET_LEN_H (TEMPLATE_LEN * self->template_num);
+      co_get_template.data_len[0] = GET_LEN_L (self->template_len * self->template_num);
+      co_get_template.data_len[1] = GET_LEN_H (self->template_len * self->template_num);

      cmd_buf = (guint8 *) &co_get_template;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT, 0, fp_get_delete_pos_cb);
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 0, fp_get_delete_pos_cb);
      break;

    case FP_RTK_DELETE_PRINT:
      co_delete_record.param[0] = self->pos_index;
      cmd_buf = (guint8 *) &co_delete_record;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT, 0, fp_task_ssm_generic_cb);
+      rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 0, fp_task_ssm_generic_cb);
      break;
    }
 }
@@ -1012,17 +1181,14 @@ identify_verify (FpDevice *device)
  g_assert (current_action == FPI_DEVICE_ACTION_VERIFY ||
            current_action == FPI_DEVICE_ACTION_IDENTIFY);

-  if (current_action == FPI_DEVICE_ACTION_IDENTIFY)
-    self->fp_purpose = FP_RTK_PURPOSE_IDENTIFY;
-  else
-    self->fp_purpose = FP_RTK_PURPOSE_VERIFY;
+  self->fp_purpose = FP_RTK_PURPOSE_IDENTIFY;

  g_assert (!self->task_ssm);

  self->task_ssm = fpi_ssm_new_full (device,
                                     fp_verify_sm_run_state,
                                     FP_RTK_VERIFY_NUM_STATES,
-                                     FP_RTK_VERIFY_NUM_STATES,
+                                     FP_RTK_VERIFY_CANCEL_CAPTURE,
                                     "Verify & Identify");

  fpi_ssm_start (self->task_ssm, fp_verify_ssm_done);
@@ -1042,7 +1208,7 @@ enroll (FpDevice *device)
  self->task_ssm = fpi_ssm_new_full (device,
                                     fp_enroll_sm_run_state,
                                     FP_RTK_ENROLL_NUM_STATES,
-                                     FP_RTK_ENROLL_NUM_STATES,
+                                     FP_RTK_ENROLL_CANCEL_CAPTURE,
                                     "Enroll");

  fpi_ssm_start (self->task_ssm, fp_enroll_ssm_done);
@@ -1167,7 +1333,7 @@ clear_storage (FpDevice *device)
  G_DEBUG_HERE ();
  co_delete_record.param[0] = 0xff;
  cmd_buf = (guint8 *) &co_delete_record;
-  realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT, 0, fp_clear_storage_cb);
+  rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 0, fp_clear_storage_cb);
 }

 static void
@@ -1179,11 +1345,11 @@ list_print (FpDevice *device)
  G_DEBUG_HERE ();
  g_assert (self->template_num > 0);

-  co_get_template.data_len[0] = GET_LEN_L (TEMPLATE_LEN * self->template_num);
-  co_get_template.data_len[1] = GET_LEN_H (TEMPLATE_LEN * self->template_num);
+  co_get_template.data_len[0] = GET_LEN_L (self->template_len * self->template_num);
+  co_get_template.data_len[1] = GET_LEN_H (self->template_len * self->template_num);

  cmd_buf = (guint8 *) &co_get_template;
-  realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT, 1, fp_list_cb);
+  rtk_sensor_bulk_cmd (self, cmd_buf, NULL, FP_RTK_MSG_DEFAULT, 1, fp_list_cb);
 }

 static void
@@ -30,16 +30,17 @@

 #define EP_IN_MAX_BUF_SIZE 2048

-#define FP_RTK_CMD_TOTAL_LEN 12
-#define FP_RTK_CMD_LEN 2
-#define FP_RTK_CMD_PARAM_LEN 4
-#define FP_RTK_CMD_ADDR_LEN 4
-#define FP_RTK_CMD_DATA_LEN 2
+#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 TEMPLATE_LEN 35
 #define SUBFACTOR_OFFSET 2
 #define UID_OFFSET 3
-#define UID_PAYLOAD_LEN 32
+#define UID_PAYLOAD_LEN_DEFAULT 32

 /* Command transfer timeout :ms*/
 #define CMD_TIMEOUT 1000
@@ -50,7 +51,7 @@
 #define DEFAULT_UID_LEN 28
 #define SUB_FINGER_01 0xFF

-#define GET_CMD_TYPE(val)                   ((val & 0xC0) >> 6)
+#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)
@@ -67,19 +68,19 @@ typedef struct
 } CommandData;

 typedef enum {
-  FP_RTK_CMD_ONLY = 0,
-  FP_RTK_CMD_READ,
-  FP_RTK_CMD_WRITE,
+  FP_RTK_CMD_BULK_ONLY = 0,
+  FP_RTK_CMD_BULK_READ,
+  FP_RTK_CMD_BULK_WRITE,
 } FpRtkCmdType;

 typedef enum {
-  FP_RTK_MSG_PLAINTEXT = 0,
-  FP_RTK_MSG_PLAINTEXT_NO_STATUS,
+  FP_RTK_MSG_DEFAULT = 0,
+  FP_RTK_MSG_NO_STATUS,
 } FpRtkMsgType;

 typedef enum {
-  FP_RTK_PURPOSE_IDENTIFY = 0x01,     /* identify before enroll */
-  FP_RTK_PURPOSE_VERIFY   = 0x02,
+  FP_RTK_PURPOSE_VERIFY   = 0x01,
+  FP_RTK_PURPOSE_IDENTIFY = 0x02,
  FP_RTK_PURPOSE_ENROLL   = 0x04,
 } FpRtkPurpose;

@@ -107,15 +108,18 @@ typedef enum {
  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_CAPTURE = 0,
+  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;

@@ -126,7 +130,8 @@ typedef enum {
 } FpRtkDeleteState;

 typedef enum {
-  FP_RTK_INIT_SELECT_OS = 0,
+  FP_RTK_INIT_GET_DEVICE_INFO = 0,
+  FP_RTK_INIT_SELECT_OS,
  FP_RTK_INIT_GET_ENROLL_NUM,
  FP_RTK_INIT_NUM_STATES,
 } FpRtkInitState;
@@ -155,66 +160,87 @@ struct _FpiDeviceRealtek
  FpRtkPurpose    fp_purpose;
  gint            pos_index;
  gint            template_num;
+  gint            template_len;
 };

-struct realtek_fp_cmd
+struct rtk_cmd_bulk
 {
-  uint8_t cmd[FP_RTK_CMD_LEN];
-  uint8_t param[FP_RTK_CMD_PARAM_LEN];
-  uint8_t addr[FP_RTK_CMD_ADDR_LEN];
-  uint8_t data_len[FP_RTK_CMD_DATA_LEN];
+  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];
 };

-static struct realtek_fp_cmd co_start_capture = {
+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 realtek_fp_cmd co_finish_capture = {
+static struct rtk_cmd_bulk co_finish_capture = {
  .cmd = {0x45, 0x06},
  .data_len = {0x05},
 };

-static struct realtek_fp_cmd co_accept_sample = {
+static struct rtk_cmd_bulk co_accept_sample = {
  .cmd = {0x45, 0x08},
  .data_len = {0x09},
 };

-static struct realtek_fp_cmd tls_identify_feature = {
+static struct rtk_cmd_bulk nor_identify_feature = {
  .cmd = {0x45, 0x22},
  .data_len = {0x2A},
 };

-static struct realtek_fp_cmd co_get_enroll_num = {
+static struct rtk_cmd_bulk co_get_enroll_num = {
  .cmd = {0x45, 0x0d},
  .data_len = {0x02},
 };

-static struct realtek_fp_cmd co_get_template = {
+static struct rtk_cmd_bulk co_get_template = {
  .cmd = {0x45, 0x0E},
 };

-static struct realtek_fp_cmd tls_enroll_begin = {
+static struct rtk_cmd_bulk nor_enroll_begin = {
  .cmd = {0x05, 0x20},
 };

-static struct realtek_fp_cmd co_check_duplicate = {
+static struct rtk_cmd_bulk co_check_duplicate = {
  .cmd = {0x45, 0x10},
  .data_len = {0x22},
 };

-static struct realtek_fp_cmd tls_enroll_commit = {
+static struct rtk_cmd_bulk nor_enroll_commit = {
  .cmd = {0x85, 0x21},
-  .data_len = {0x20},
 };

-static struct realtek_fp_cmd co_update_template = {
+static struct rtk_cmd_bulk co_update_template = {
  .cmd = {0x05, 0x11},
 };

-static struct realtek_fp_cmd co_delete_record = {
+static struct rtk_cmd_bulk co_delete_record = {
  .cmd = {0x05, 0x0F},
 };

-static struct realtek_fp_cmd co_select_system = {
+static struct rtk_cmd_bulk co_select_system = {
  .cmd = {0x05, 0x13},
 };
+
+static struct rtk_cmd_bulk co_cancel_capture = {
+  .cmd = {0x05, 0x07},
+};
@@ -36,6 +36,7 @@ static const FpIdEntry id_table[] = {
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F9,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00FC,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C2,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C4,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0100,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F0,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0103,  },
@@ -48,6 +49,8 @@ static const FpIdEntry id_table[] = {
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0104,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0173,  },
  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0106,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x019D,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C6,  },
  { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };

@@ -292,14 +292,14 @@ fp_device_get_property (GObject    *object,

    case PROP_FPI_UDEV_DATA_SPIDEV:
      if (cls->type == FP_DEVICE_TYPE_UDEV)
-        g_value_set_string (value, g_strdup (priv->udev_data.spidev_path));
+        g_value_set_string (value, 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, g_strdup (priv->udev_data.hidraw_path));
+        g_value_set_string (value, priv->udev_data.hidraw_path);
      else
        g_value_set_string (value, NULL);
      break;
@@ -675,4 +675,6 @@ 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
@@ -75,7 +75,8 @@ fpi_byte_writer_new_with_size (guint size, gboolean fixed)
  FpiByteWriter *ret = fpi_byte_writer_new ();

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

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

  fpi_byte_writer_init (writer);

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

  g_return_val_if_fail (writer != NULL, NULL);

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

  return data;
@@ -111,6 +111,17 @@ 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)
 {
@@ -407,4 +418,7 @@ 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
@@ -1042,34 +1042,41 @@ fp_device_task_return_in_idle_cb (gpointer user_data)
 static void
 fpi_device_task_return_data_free (FpDeviceTaskReturnData *data)
 {
-  if (data->result)
+  switch (data->type)
    {
-      switch (data->type)
-        {
-        case FP_DEVICE_TASK_RETURN_INT:
-        case FP_DEVICE_TASK_RETURN_BOOL:
-          break;
+    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,
@@ -1101,7 +1108,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: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
 *
 * Finish an ongoing probe operation. If error is %NULL success is assumed.
 */
@@ -1147,7 +1154,7 @@ fpi_device_probe_complete (FpDevice    *device,
 /**
 * fpi_device_open_complete:
 * @device: The #FpDevice
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
 *
 * Finish an ongoing open operation. If error is %NULL success is assumed.
 */
@@ -1174,7 +1181,7 @@ fpi_device_open_complete (FpDevice *device, GError *error)
 /**
 * fpi_device_close_complete:
 * @device: The #FpDevice
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
 *
 * Finish an ongoing close operation. If error is %NULL success is assumed.
 */
@@ -1226,7 +1233,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: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
 *
 * Finish an ongoing enroll operation. The #FpPrint can be stored by the
 * caller for later verification.
@@ -1355,7 +1362,7 @@ fpi_device_verify_complete (FpDevice *device,
 /**
 * fpi_device_identify_complete:
 * @device: The #FpDevice
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
 *
 * Finish an ongoing identify operation.
 *
@@ -1421,7 +1428,7 @@ fpi_device_identify_complete (FpDevice *device,
 * fpi_device_capture_complete:
 * @device: The #FpDevice
 * @image: The #FpImage, or %NULL on error
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
 *
 * Finish an ongoing capture operation.
 */
@@ -1468,7 +1475,7 @@ fpi_device_capture_complete (FpDevice *device,
 /**
 * fpi_device_delete_complete:
 * @device: The #FpDevice
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
 *
 * Finish an ongoing delete operation.
 */
@@ -1497,7 +1504,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: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
 *
 * Finish an ongoing list operation.
 *
@@ -1775,7 +1782,7 @@ fpi_device_suspend_completed (FpDevice *device)
 /**
 * fpi_device_suspend_complete:
 * @device: The #FpDevice
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): 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
@@ -1826,7 +1833,7 @@ fpi_device_suspend_complete (FpDevice *device,
 /**
 * fpi_device_resume_complete:
 * @device: The #FpDevice
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
 *
 * Finish a resume request.
 */
@@ -1854,7 +1861,7 @@ fpi_device_resume_complete (FpDevice *device,
 /**
 * fpi_device_clear_storage_complete:
 * @device: The #FpDevice
- * @error: The #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
 *
 * Finish an ongoing clear_storage operation.
 */
@@ -1885,7 +1892,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: (transfer full): The #GError or %NULL on success
+ * @error: (nullable) (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().
@@ -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: The #GError to report
+ * @error: (nullable) (transfer full): 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: A #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #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: A #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #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: A #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #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: A #GError or %NULL on success
+ * @error: (nullable) (transfer full): The #GError or %NULL on success
 *
 * Reports completion of close operation.
 */
@@ -57,7 +57,6 @@ 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 },
@@ -76,6 +75,12 @@ 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 },
@@ -1,3 +1,11 @@
+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',
@@ -16,7 +24,7 @@ libfprint_private_sources = [
    'fpi-print.c',
    'fpi-ssm.c',
    'fpi-usb-transfer.c',
-    'fpi-spi-transfer.c',
+    spi_sources,
 ]

 libfprint_public_headers = [
@@ -41,7 +49,7 @@ libfprint_private_headers = [
    'fpi-minutiae.h',
    'fpi-print.h',
    'fpi-usb-transfer.h',
-    'fpi-spi-transfer.h',
+    spi_headers,
    'fpi-ssm.h',
 ]

@@ -1,5 +1,5 @@
 project('libfprint', [ 'c', 'cpp' ],
-    version: '1.94.7',
+    version: '1.94.8',
    license: 'LGPLv2.1+',
    default_options: [
        'buildtype=debugoptimized',
@@ -91,11 +91,15 @@ 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 = [
@@ -134,11 +138,16 @@ default_drivers = [
    'fpcmoc',
    'realtek',
    'focaltech_moc',
-
-    # SPI
-    'elanspi',
 ]

+spi_drivers = [
+    '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 + [
@@ -175,6 +184,17 @@ 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' ],
@@ -0,0 +1,156 @@
+#!/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
@@ -0,0 +1,255 @@
+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
@@ -0,0 +1,156 @@
+#!/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
@@ -0,0 +1,270 @@
+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
+
@@ -53,8 +53,11 @@ drivers_tests = [
    'egis0570',
    'egismoc',
    'egismoc-05a1',
+    'egismoc-0586',
+    'egismoc-0587',
    'fpcmoc',
-    'realtek',
+	'realtek',
+	'realtek-5816',
    'focaltech_moc',
 ]

@@ -100,11 +103,17 @@ if get_option('introspection')
            base_args = files(vdtest + '.py')
            suite = ['virtual-driver']

-            r = run_command(unittest_inspector, files(vdtest + '.py'), check: true)
+            r = run_command(unittest_inspector, files(vdtest + '.py'), check: false)
            unit_tests = r.stdout().strip().split('\n')

            if r.returncode() == 0 and unit_tests.length() > 0
                suite += vdtest
+            elif r.returncode() == 77
+                test(vdtest,
+                    sh,
+                    args: ['-c', 'exit 77']
+                )
+                continue
            else
                unit_tests = [vdtest]
            endif
@@ -151,7 +160,7 @@ if get_option('introspection')
            endif
        else
            test(vdtest,
-                find_program('sh'),
+                sh,
                args: ['-c', 'exit 77']
            )
        endif
@@ -205,7 +214,7 @@ if get_option('introspection')
            endif
        else
            test(driver_test,
-                find_program('sh'),
+                sh,
                args: ['-c', 'exit 77']
            )
        endif
@@ -224,13 +233,13 @@ if get_option('introspection')
 else
    warning('Skipping all driver tests as introspection bindings are missing')
    test('virtual-image',
-        find_program('sh'),
+        sh,
        args: ['-c', 'exit 77']
    )

    foreach driver_test: drivers_tests
        test(driver_test,
-            find_program('sh'),
+            sh,
            args: ['-c', 'exit 77']
        )
    endforeach
@@ -273,7 +282,7 @@ foreach test_name: unit_tests
            # Create a dummy test that always skips instead
            warning('Test @0@ cannot be compiled due to missing dependencies'.format(test_name))
            test(test_name,
-                find_program('sh'),
+                sh,
                suite: ['unit-tests'],
                args: ['-c', 'exit 77'],
            )
@@ -0,0 +1,110 @@
+#!/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() == "realtek"
+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 d.has_feature(FPrint.DeviceFeature.STORAGE_CLEAR)
+
+d.open_sync()
+
+# 1. verify clear storage command, 2. make sure later asserts are good
+d.clear_storage_sync()
+
+template = FPrint.Print.new(d)
+
+def enroll_progress(*args):
+    # assert d.get_finger_status() & FPrint.FingerStatusFlags.NEEDED
+    print('enroll progress: ' + str(args))
+
+def identify_done(dev, res):
+    global identified
+    identified = True
+    try:
+        identify_match, identify_print = dev.identify_finish(res)
+    except gi.repository.GLib.GError as e:
+        print("Please try again")
+    else:
+        print('indentification_done: ', identify_match, identify_print)
+        assert identify_match.equal(identify_print)
+
+def start_identify_async(prints):
+    global identified
+    print('async identifying')
+    d.identify(prints, callback=identify_done)
+    del prints
+
+    while not identified:
+        ctx.iteration(True)
+
+    identified = False
+
+# 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")
+try:
+    assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+    verify_res, verify_print = d.verify_sync(p)
+    assert d.get_finger_status() == FPrint.FingerStatusFlags.NONE
+except gi.repository.GLib.GError as e:
+    print("Please try again")
+else:
+    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
@@ -0,0 +1,250 @@
+P: /devices/pci0000:00/0000:00:14.0/usb1/1-6
+N: bus/usb/001/006=12010102EF020140DA0B165800000301020109022E00010104A0FA0904000004FF02000507050102000200070583034000080705840340000807058202000200
+E: DEVNAME=/dev/bus/usb/001/006
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: PRODUCT=bda/5816/0
+E: TYPE=239/2/1
+E: BUSNUM=001
+E: DEVNUM=006
+E: MAJOR=189
+E: MINOR=5
+E: SUBSYSTEM=usb
+E: ID_VENDOR=Generic
+E: ID_VENDOR_ENC=Generic
+E: ID_VENDOR_ID=0bda
+E: ID_MODEL=Realtek_USB2.0_Finger_Print_Bridge
+E: ID_MODEL_ENC=Realtek\x20USB2.0\x20Finger\x20Print\x20Bridge
+E: ID_MODEL_ID=5816
+E: ID_REVISION=0000
+E: ID_SERIAL=Generic_Realtek_USB2.0_Finger_Print_Bridge_201801010001
+E: ID_SERIAL_SHORT=201801010001
+E: ID_BUS=usb
+E: ID_USB_INTERFACES=:ff0200:
+E: ID_VENDOR_FROM_DATABASE=Realtek Semiconductor Corp.
+E: ID_PATH=pci-0000:00:14.0-usb-0:6
+E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_6
+A: authorized=1\n
+A: avoid_reset_quirk=0\n
+A: bConfigurationValue=1\n
+A: bDeviceClass=ef\n
+A: bDeviceProtocol=01\n
+A: bDeviceSubClass=02\n
+A: bMaxPacketSize0=64\n
+A: bMaxPower=500mA\n
+A: bNumConfigurations=1\n
+A: bNumInterfaces= 1\n
+A: bcdDevice=0000\n
+A: bmAttributes=a0\n
+A: busnum=1\n
+A: configuration=Realtek USB2.0 Finger Print Bridge\n
+H: descriptors=12010102EF020140DA0B165800000301020109022E00010104A0FA0904000004FF02000507050102000200070583034000080705840340000807058202000200
+A: dev=189:5\n
+A: devnum=6\n
+A: devpath=6\n
+L: driver=../../../../../bus/usb/drivers/usb
+L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4b/device:4c/device:52
+A: idProduct=5816\n
+A: idVendor=0bda\n
+A: ltm_capable=no\n
+A: manufacturer=Generic\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=../1-0:1.0/usb1-port6
+A: power/active_duration=37699\n
+A: power/async=enabled\n
+A: power/autosuspend=2\n
+A: power/autosuspend_delay_ms=2000\n
+A: power/connected_duration=37699\n
+A: power/control=on\n
+A: power/level=on\n
+A: power/persist=1\n
+A: power/runtime_active_kids=0\n
+A: power/runtime_active_time=37457\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=Realtek USB2.0 Finger Print Bridge\n
+A: quirks=0x0\n
+A: removable=removable\n
+A: rx_lanes=1\n
+A: serial=201801010001\n
+A: speed=480\n
+A: tx_lanes=1\n
+A: urbnum=22\n
+A: version= 2.01\n
+
+P: /devices/pci0000:00/0000:00:14.0/usb1
+N: bus/usb/001/001=12010002090001406B1D020008060302010109021900010100E0000904000001090000000705810304000C
+E: DEVNAME=/dev/bus/usb/001/001
+E: DEVTYPE=usb_device
+E: DRIVER=usb
+E: PRODUCT=1d6b/2/608
+E: TYPE=9/0/1
+E: BUSNUM=001
+E: DEVNUM=001
+E: MAJOR=189
+E: MINOR=0
+E: SUBSYSTEM=usb
+E: ID_VENDOR=Linux_6.8.0-40-generic_xhci-hcd
+E: ID_VENDOR_ENC=Linux\x206.8.0-40-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=0608
+E: ID_SERIAL=Linux_6.8.0-40-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
+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:4b/device:4c
+A: idProduct=0002\n
+A: idVendor=1d6b\n
+A: interface_authorized_default=1\n
+A: ltm_capable=no\n
+A: manufacturer=Linux 6.8.0-40-generic xhci-hcd\n
+A: maxchild=16\n
+A: power/active_duration=1096259\n
+A: power/async=enabled\n
+A: power/autosuspend=0\n
+A: power/autosuspend_delay_ms=0\n
+A: power/connected_duration=1096259\n
+A: power/control=auto\n
+A: power/level=auto\n
+A: power/runtime_active_kids=3\n
+A: power/runtime_active_time=1096256\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=229\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:A36D
+E: PCI_SUBSYS_ID=1028:085C
+E: PCI_SLOT_NAME=0000:00:14.0
+E: MODALIAS=pci:v00008086d0000A36Dsv00001028sd0000085Cbc0Csc03i30
+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=Cannon Lake PCH USB 3.1 xHCI Host Controller
+A: ari_enabled=0\n
+A: broken_parity_status=0\n
+A: class=0x0c0330\n
+H: config=86806DA3060590021030030C00008000040030D200000000000000000000000000000000000000000000000028105C08000000007000000000000000FF010000FD0134808FC6FF8300000000000000007F6DDC0F000000005B17C10300000000316000000000000000000000000000000180C2C10800000000000000000000000590B7001803E0FE0000000000000000090014F01000400100000000C10A080000080E00001800008F40020000010000030000000C00000000000000C000000000000000000100003000000000000000030000000C0000000000000000000000000000000000000000000000000000000000000000000000B50F120112000000
+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=0xa36d\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:4b
+A: index=4\n
+L: iommu=../../virtual/iommu/dmar1
+L: iommu_group=../../../kernel/iommu_groups/4
+A: irq=125\n
+A: label=Onboard - Other\n
+A: local_cpulist=0-3\n
+A: local_cpus=f\n
+A: modalias=pci:v00008086d0000A36Dsv00001028sd0000085Cbc0Csc03i30\n
+A: msi_bus=1\n
+A: msi_irqs/125=msi\n
+A: msi_irqs/126=msi\n
+A: msi_irqs/127=msi\n
+A: msi_irqs/128=msi\n
+A: msi_irqs/129=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   25   25 4096 25\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128         12   32  128  1\nbuffer-32           0    0   32  0\n
+A: power/async=enabled\n
+A: power/control=on\n
+A: power/runtime_active_kids=1\n
+A: power/runtime_active_time=1096935\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=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=0x00000000d2300000 0x00000000d230ffff 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=0x10\n
+A: subsystem_device=0x085c\n
+A: subsystem_vendor=0x1028\n
+A: vendor=0x8086\n
+
@@ -1,14 +1,14 @@
-P: /devices/pci0000:00/0000:00:14.0/usb1/1-4
-N: bus/usb/001/005=12010102EF020140DA0B135801210301020109022E00010104A0FA0904000004FF02000507050102000200070583031000080705840310000807058202000200
-E: DEVNAME=/dev/bus/usb/001/005
+P: /devices/pci0000:00/0000:00:14.0/usb1/1-8
+N: bus/usb/001/025=12010102EF020140DA0B135801210301020109022E00010104A0FA0904000004FF02000507050102000200070583031000080705840310000807058202000200
+E: DEVNAME=/dev/bus/usb/001/025
 E: DEVTYPE=usb_device
 E: DRIVER=usb
 E: PRODUCT=bda/5813/2101
 E: TYPE=239/2/1
 E: BUSNUM=001
-E: DEVNUM=005
+E: DEVNUM=025
 E: MAJOR=189
-E: MINOR=4
+E: MINOR=24
 E: SUBSYSTEM=usb
 E: ID_VENDOR=Generic
 E: ID_VENDOR_ENC=Generic
@@ -22,8 +22,8 @@ E: ID_SERIAL_SHORT=201801010001
 E: ID_BUS=usb
 E: ID_USB_INTERFACES=:ff0200:
 E: ID_VENDOR_FROM_DATABASE=Realtek Semiconductor Corp.
-E: ID_PATH=pci-0000:00:14.0-usb-0:4
-E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_4
+E: ID_PATH=pci-0000:00:14.0-usb-0:8
+E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_8
 A: authorized=1\n
 A: avoid_reset_quirk=0\n
 A: bConfigurationValue=1\n
@@ -39,11 +39,11 @@ A: bmAttributes=a0\n
 A: busnum=1\n
 A: configuration=Realtek USB2.0 Finger Print Bridge\n
 H: descriptors=12010102EF020140DA0B135801210301020109022E00010104A0FA0904000004FF02000507050102000200070583031000080705840310000807058202000200
-A: dev=189:4\n
-A: devnum=5\n
-A: devpath=4\n
+A: dev=189:24\n
+A: devnum=25\n
+A: devpath=8\n
 L: driver=../../../../../bus/usb/drivers/usb
-L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4b/device:4c/device:50
+L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4b/device:4c/device:54
 A: idProduct=5813\n
 A: idVendor=0bda\n
 A: ltm_capable=no\n
@@ -54,21 +54,21 @@ 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=../1-0:1.0/usb1-port4
-A: power/active_duration=91232868\n
+L: port=../1-0:1.0/usb1-port8
+A: power/active_duration=271844\n
 A: power/async=enabled\n
 A: power/autosuspend=2\n
 A: power/autosuspend_delay_ms=2000\n
-A: power/connected_duration=91232868\n
+A: power/connected_duration=271844\n
 A: power/control=on\n
 A: power/level=on\n
 A: power/persist=1\n
 A: power/runtime_active_kids=0\n
-A: power/runtime_active_time=91232594\n
+A: power/runtime_active_time=271564\n
 A: power/runtime_enabled=forbidden\n
 A: power/runtime_status=active\n
 A: power/runtime_suspended_time=0\n
-A: power/runtime_usage=7\n
+A: power/runtime_usage=1\n
 A: power/wakeup=disabled\n
 A: power/wakeup_abort_count=\n
 A: power/wakeup_active=\n
@@ -85,29 +85,29 @@ A: rx_lanes=1\n
 A: serial=201801010001\n
 A: speed=480\n
 A: tx_lanes=1\n
-A: urbnum=15076313\n
+A: urbnum=297176\n
 A: version= 2.01\n

 P: /devices/pci0000:00/0000:00:14.0/usb1
-N: bus/usb/001/001=12010002090001406B1D020002060302010109021900010100E0000904000001090000000705810304000C
+N: bus/usb/001/001=12010002090001406B1D020005060302010109021900010100E0000904000001090000000705810304000C
 E: DEVNAME=/dev/bus/usb/001/001
 E: DEVTYPE=usb_device
 E: DRIVER=usb
-E: PRODUCT=1d6b/2/602
+E: PRODUCT=1d6b/2/605
 E: TYPE=9/0/1
 E: BUSNUM=001
 E: DEVNUM=001
 E: MAJOR=189
 E: MINOR=0
 E: SUBSYSTEM=usb
-E: ID_VENDOR=Linux_6.2.0-35-generic_xhci-hcd
-E: ID_VENDOR_ENC=Linux\x206.2.0-35-generic\x20xhci-hcd
+E: ID_VENDOR=Linux_6.5.0-18-generic_xhci-hcd
+E: ID_VENDOR_ENC=Linux\x206.5.0-18-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=0602
-E: ID_SERIAL=Linux_6.2.0-35-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+E: ID_REVISION=0605
+E: ID_SERIAL=Linux_6.5.0-18-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:
@@ -130,11 +130,11 @@ A: bMaxPacketSize0=64\n
 A: bMaxPower=0mA\n
 A: bNumConfigurations=1\n
 A: bNumInterfaces= 1\n
-A: bcdDevice=0602\n
+A: bcdDevice=0605\n
 A: bmAttributes=e0\n
 A: busnum=1\n
 A: configuration=
-H: descriptors=12010002090001406B1D020002060302010109021900010100E0000904000001090000000705810304000C
+H: descriptors=12010002090001406B1D020005060302010109021900010100E0000904000001090000000705810304000C
 A: dev=189:0\n
 A: devnum=1\n
 A: devpath=0\n
@@ -144,17 +144,17 @@ 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-35-generic xhci-hcd\n
+A: manufacturer=Linux 6.5.0-18-generic xhci-hcd\n
 A: maxchild=16\n
-A: power/active_duration=264747968\n
+A: power/active_duration=351477916\n
 A: power/async=enabled\n
 A: power/autosuspend=0\n
 A: power/autosuspend_delay_ms=0\n
-A: power/connected_duration=264747968\n
+A: power/connected_duration=351477916\n
 A: power/control=auto\n
 A: power/level=auto\n
 A: power/runtime_active_kids=3\n
-A: power/runtime_active_time=264747968\n
+A: power/runtime_active_time=351477912\n
 A: power/runtime_enabled=enabled\n
 A: power/runtime_status=active\n
 A: power/runtime_suspended_time=0\n
@@ -175,7 +175,7 @@ A: rx_lanes=1\n
 A: serial=0000:00:14.0\n
 A: speed=480\n
 A: tx_lanes=1\n
-A: urbnum=3177\n
+A: urbnum=2135\n
 A: version= 2.00\n

 P: /devices/pci0000:00/0000:00:14.0
@@ -194,10 +194,14 @@ E: ID_MODEL_FROM_DATABASE=Cannon Lake PCH USB 3.1 xHCI Host Controller
 A: ari_enabled=0\n
 A: broken_parity_status=0\n
 A: class=0x0c0330\n
-H: config=86806DA3060590021030030C00008000040030D200000000000000000000000000000000000000000000000028105C08000000007000000000000000FF010000FD0134808FC6FF8300000000000000007F6DDC0F000000005919041B00000000316000000000000000000000000000000180C2C108000000000000000000000005908700D802E0FE0000000000000000090014F01000400100000000C10A080000080E00001800008F40020000010000030000000C00000000000000C000000000000000000100003000000000000000030000000C0000000000000000000000000000000000000000000000000000000000000000000000B50F120112000000
+H: config=86806DA3060590021030030C00008000040030D200000000000000000000000000000000000000000000000028105C08000000007000000000000000FF010000FD0134808FC6FF8300000000000000007F6DDC0F000000004505531F00000000316000000000000000000000000000000180C2C108000000000000000000000005908700D802E0FE0000000000000000090014F01000400100000000C10A080000080E00001800008F40020000010000030000000C00000000000000C000000000000000000100003000000000000000030000000C0000000000000000000000000000000000000000000000000000000000000000000000B50F120112000000
 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=0xa36d\n
 A: dma_mask_bits=64\n
 L: driver=../../../bus/pci/drivers/xhci_hcd
@@ -205,19 +209,19 @@ A: driver_override=(null)\n
 A: enable=1\n
 L: firmware_node=../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:4b
 A: index=4\n
-A: irq=125\n
+A: irq=126\n
 A: label=Onboard - Other\n
 A: local_cpulist=0-3\n
 A: local_cpus=f\n
 A: modalias=pci:v00008086d0000A36Dsv00001028sd0000085Cbc0Csc03i30\n
 A: msi_bus=1\n
-A: msi_irqs/125=msi\n
+A: msi_irqs/126=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   24   24 4096 24\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128         12   32  128  1\nbuffer-32           0    0   32  0\n
 A: power/async=enabled\n
 A: power/control=on\n
 A: power/runtime_active_kids=1\n
-A: power/runtime_active_time=264748677\n
+A: power/runtime_active_time=351478612\n
 A: power/runtime_enabled=forbidden\n
 A: power/runtime_status=active\n
 A: power/runtime_suspended_time=0\n
Author	SHA1	Message	Date
Marco Trevisan (Treviño)	e57bab2f1e	Release 1.94.8	2024-09-03 05:14:11 +02:00
huan_huangandMarco Trevisan (Treviño)	a88582761f	realtek: add support for rts5816 Signed-off-by: huan_huang <huan_huang@realsil.com.cn>	2024-09-03 04:44:04 +02:00
Marco Trevisan (Treviño)	75adfd37d1	egismoc: Add PID 0x0583 As per comment: - https://gitlab.freedesktop.org/libfprint/libfprint/-/issues/630#note_2547528	2024-08-30 04:42:56 +02:00
Tamer HassanandMarco Trevisan (Treviño)	990bd40cbf	egismoc: add 0586 support	2024-08-30 04:42:56 +02:00
Tamer HassanandMarco Trevisan (Treviño)	c7e95bb41f	egismoc: add 0587 support (also supports 0586 but missing device file)	2024-08-30 04:42:56 +02:00
NkaspersandMarco Trevisan (Treviño)	4611cc4a1b	Synaptics: add new PID 0x00C4 And drop it from the unsupported list	2024-08-30 04:34:34 +02:00
Marco Trevisan (Treviño)	78c78432b9	build: Generalize spi drivers detection Don't be limited to elan only	2024-08-30 04:16:48 +02:00
Daniel SchaeferandMarco Trevisan (Treviño)	10e1cd76aa	Don't build SPI driver on non-Linux Doesn't build on other operating systems. With auto-detection we don't have to manually select all other drivers. Signed-off-by: Daniel Schaefer <dhs@frame.work>	2024-08-30 04:06:43 +02:00
Daniel SchaeferandMarco Trevisan	c84d3774cf	libfprint: Don't build SPI backend if not SPI driver The SPI backend only builds on Linux, this makes it work non non-Linux platforms, such as FreeBSD. Signed-off-by: Daniel Schaefer <dhs@frame.work>	2024-08-30 02:00:16 +00:00
Haowei LoandMarco Trevisan	04a167b09b	fpcmoc: Add PID 0x9524 and 0x9544 Change-Id: Id85116df233308297cf3d7b56146582a79f5fcdd	2024-08-30 01:33:03 +00:00
Aris LinandMarco Trevisan	538a18cf17	synaptics: Add new PID 0x00C6	2024-08-30 00:57:29 +00:00
Aris LinandMarco Trevisan	2e766904f0	synaptics: Add new PID 0x019D	2024-08-30 00:57:29 +00:00
haoweiloandMarco Trevisan	9f55ef690d	fpcmoc: fixed the error jumping to wrong state at end of custom enroll	2024-08-30 00:47:01 +00:00
herman lin	b6061c0af8	elanmoc: Add new PID 0x0C9F	2024-08-08 14:08:19 +08:00
Marco Trevisan (Treviño)	3f70bde21c	fp-device: Do not duplicate udev paths strings This is happening already internally when using g_value_set_string	2024-06-17 19:08:16 +00:00
Timo SchraderandMarco Trevisan	dd6f020378	goodixmoc: Add PID 0x609A	2024-06-17 17:57:29 +00:00
craigcabrey	2a4c05662a	goodixmoc: Add PID 0x6512	2024-06-15 12:17:34 -05:00
Marco Trevisan (Treviño)	eaec2339cc	libfprint-fprint-list-udev-hwdb: Add new broadcom device IDs	2024-05-22 17:09:38 +02:00
Marco Trevisan (Treviño)	83035be830	README: Add contact information	2024-05-03 15:35:11 +02:00
Marco Trevisan (Treviño)	4709efc678	fpi-device: Clarify transfer of errors in device complete tasks	2024-04-17 17:00:47 +00:00
Marco Trevisan (Treviño)	37ded921fd	fpi-device: Simplify logic of fpi_device_task_return_data_free The clear functions will do NULL checks already, so there's no need to duplicate such effort	2024-04-17 17:00:47 +00:00
Haowei Lo	b7f3544e98	fpcmoc: Transfer error from autoptr before fpi_device_close_complete Fixed coredump because of trying to free a null space Change-Id: If5a23ba7b4f307580593712612e150d1ab893826	2024-04-18 00:38:44 +08:00
steven.chenandMarco Trevisan	093f2fc0a6	fpcmoc: Modify ctrl timeout to fix identify return failed	2024-04-17 15:05:06 +00:00
Lee Jiajun	c5def9a528	goodixmoc: Add PID 0x609A	2024-04-17 09:37:25 +00:00
haoweiloandMarco Trevisan	e71f3de786	fpcmoc: add error handling to evt_finger_dwn Redo the current task state if we got failed status from evt_finger_dwn	2024-04-17 08:33:24 +00:00
haoweiloandMarco Trevisan	420fd7416d	fpcmoc: fix incorrect immobile handling during enrollment For the custom enrollment, if the number of immobile touches have reached the maximum, we should treat this touch as normal (valid) and increase the enrollment progress.	2024-04-17 08:33:24 +00:00
Haowei Lo	f505158c04	fpcmoc: clean cmd_ssm before callback fixed assertion of "cmd_ssm is not null" Change-Id: I8f914468dc0e40c6cac33d680411a2d957cf2296	2024-04-16 21:46:19 +08:00
Jichi Zhang	fb13722629	goodixmoc: Add PID 0x650C	2024-03-13 05:16:16 -07:00
Marco Trevisan (Treviño)	666cd0c08d	egismoc: Use FpiByteReader to compute the check bytes We can read the values in the proper format without having to deal with endianness ourself, so let's do this instead of manual labor.	2024-02-20 18:07:18 +01:00
Marco Trevisan (Treviño)	e055781006	egismoc: Use FpiByteWriter to allocate the commit payload	2024-02-20 17:57:46 +01:00
Marco Trevisan (Treviño)	48c8c539c7	egismoc: Use FpiByteWriter to generate the get check command	2024-02-20 17:57:46 +01:00
Marco Trevisan (Treviño)	40c7599fb1	egismoc: Compute the delete command using FpiByteWriter	2024-02-20 17:57:46 +01:00
Marco Trevisan (Treviño)	28c26c7d7e	egismoc: Use FpiByteReader to read the enrolled IDs	2024-02-20 17:57:46 +01:00
Marco Trevisan (Treviño)	dd5a71695f	egismoc: Use FpiByteWriter to prepare the command message	2024-02-20 17:57:46 +01:00
Marco Trevisan (Treviño)	977d324970	egismoc: Do not store twice the number of enrolled IDs We already store it in the array, so let's just use that value	2024-02-20 17:57:46 +01:00
Marco Trevisan (Treviño)	4992110829	fpi-byte-writer: Zero-init the allocated data by default This could have been done via fill method + pos reset, but it's just something we normally want to do for safety, so let's do it all the times.	2024-02-20 17:57:46 +01:00
Marco Trevisan (Treviño)	53f2539b6a	fpi-byte-writer: Use nicer API to unset the parent data	2024-02-20 17:57:46 +01:00
Marco Trevisan (Treviño)	18e2906d62	fpi-byte-writer: Initialize the parent size when initializing with size	2024-02-20 17:57:46 +01:00
Marco Trevisan (Treviño)	19806546a2	fpi-byte-writer: Add change pos method It allows to move the position of the cursor with a relative position.	2024-02-20 17:57:46 +01:00
Marco Trevisan (Treviño)	75559415fe	fpi-byte-writer/reader: Add autopointers definitions	2024-02-20 17:57:46 +01:00
Marco Trevisan (Treviño)	7dbb21e77a	build/tests: Skip a test if the test requires it during inspection In case we don't have dependencies, we should skip the test, otherwise we can just fail at test time	2024-02-20 08:25:53 +01:00
Marco Trevisan (Treviño)	4b72f27de6	build: Look for sh just once	2024-02-20 08:22:42 +01:00
Marco Trevisan (Treviño)	5ada931ede	ci: Export coverage to pages So that we can link it outside	2024-02-20 01:55:11 +01:00