Release 1.94.8

Signed-off-by: huan_huang <huan_huang@realsil.com.cn>

.gitlab-ci.yml

@@ -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

NEWS

@@ -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:

README.md

@@ -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

data/autosuspend.hwdb

@@ -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*

libfprint/drivers/egismoc/egismoc.c

@@ -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
+static guint16
-egismoc_get_check_bytes (const guchar *value,
+egismoc_get_check_bytes (FpiByteReader *reader)
-                         const gsize   value_length)
 {
   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++)
+  fpi_byte_reader_set_pos (reader, 0);
-    {
-      values[j] = (value[i] << 8 & 0xff00);
 
-      if (i < value_length - 1)
+  while (fpi_byte_reader_get_uint16_be (reader, &val))
-        values[j] |= value[i + 1] & 0x00ff;
+    sum_values += val;
-    }
 
-  for (int i = 0; i < steps; i++)
+  return G_MAXUINT16 - (sum_values % G_MAXUINT16);
-    sum_values += values[i];
-
-  check_bytes.check_value = GUINT16_TO_BE (0xffff - (sum_values % 0xffff));
-  return check_bytes;
 }
 
 static void
@@ -319,22 +301,15 @@ egismoc_exec_cmd (FpDevice         *device,
                   GDestroyNotify    cmd_destroy,
                   SynCmdMsgCallback callback)
 {
-  fp_dbg ("Execute command and get response");
+  g_auto(FpiByteWriter) writer = {0};
-  FpiDeviceEgisMoc *self = FPI_DEVICE_EGISMOC (device);
-  EgisMocCheckBytes check_bytes;
-  g_autofree guchar *buffer_out = NULL;
-  gsize buffer_out_length = 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);
+  fp_dbg ("Execute command and get response");
-  self->cmd_ssm = fpi_ssm_new (device,
-                               egismoc_cmd_run_state,
-                               CMD_STATES);
-
-  transfer = fpi_usb_transfer_new (device);
-  transfer->short_is_error = TRUE;
 
   /*
    * 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,
+  written &= fpi_byte_writer_put_data (&writer, cmd, cmd_length);
-          cmd, cmd_length);
-
-  /* destroy cmd if requested */
-  if (cmd_destroy)
-    cmd_destroy (cmd);
 
   /* 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);
+  check_value = egismoc_get_check_bytes (FPI_BYTE_READER (&writer));
-  memcpy (buffer_out + egismoc_write_prefix_len, check_bytes.check_bytes,
+  fpi_byte_writer_set_pos (&writer, egismoc_write_prefix_len);
-          EGISMOC_CHECK_BYTES_LENGTH);
+  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;
+  while (read)
-       pos < length_in - EGISMOC_LIST_RESPONSE_SUFFIX_SIZE;
-       pos += EGISMOC_FINGERPRINT_DATA_SIZE, self->enrolled_num++)
     {
-      g_autofree gchar *print_id = g_strndup ((gchar *) buffer_in + pos,
+      const guint8 *data;
-                                              EGISMOC_FINGERPRINT_DATA_SIZE);
+      g_autofree gchar *print_id = NULL;
-      fp_dbg ("Device fingerprint %0d: %.*s", self->enrolled_num,
+
+      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));
+      written &= fpi_byte_writer_put_uint8 (&writer, 0x01);
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_put_uint8 (&writer, ((num_to_delete - 8) * 0x20) + 0x07);
-      memset (result + pos, ((num_to_delete - 8) * 0x20) + 0x07, sizeof (guchar));
-      pos += sizeof (guchar);
     }
   else
     {
       /* first byte is 0x00, just skip it */
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_change_pos (&writer, 1);
-      memset (result + pos, (num_to_delete * 0x20) + 0x07, sizeof (guchar));
+      written &= fpi_byte_writer_put_uint8 (&writer, (num_to_delete * 0x20) + 0x07);
-      pos += sizeof (guchar);
     }
 
   /* command prefix */
-  memcpy (result + pos, cmd_delete_prefix, cmd_delete_prefix_len);
+  written &= fpi_byte_writer_put_data (&writer, cmd_delete_prefix,
-  pos += cmd_delete_prefix_len;
+                                       cmd_delete_prefix_len);
 
   /* 2-bytes size logic for counter again */
   if (num_to_delete > 7)
     {
-      memset (result + pos, 0x01, sizeof (guchar));
+      written &= fpi_byte_writer_put_uint8 (&writer, 0x01);
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_put_uint8 (&writer, (num_to_delete - 8) * 0x20);
-      memset (result + pos, ((num_to_delete - 8) * 0x20), sizeof (guchar));
-      pos += sizeof (guchar);
     }
   else
     {
       /* first byte is 0x00, just skip it */
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_change_pos (&writer, 1);
-      memset (result + pos, (num_to_delete * 0x20), sizeof (guchar));
+      written &= fpi_byte_writer_put_uint8 (&writer, num_to_delete * 0x20);
-      pos += sizeof (guchar);
     }
 
   /* 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++)
+      for (guint i = 0; i < self->enrolled_ids->len && written; i++)
-        memcpy (result + pos + (EGISMOC_FINGERPRINT_DATA_SIZE * i),
+        {
-                g_ptr_array_index (self->enrolled_ids, i),
+          written &= fpi_byte_writer_put_data (&writer,
-                EGISMOC_FINGERPRINT_DATA_SIZE);
+                                               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
+      /* get enrolled_ids from device for use building delete payload below */
-       * 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));
+      written &= fpi_byte_writer_put_uint8 (&writer, 0x01);
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_put_uint8 (&writer,
-      memset (result + pos, ((self->enrolled_num - 7) * 0x20) + 0x09,
+                                            ((self->enrolled_ids->len - 7) * 0x20)
-              sizeof (guchar));
+                                            + 0x09);
-      pos += sizeof (guchar);
     }
   else
     {
       /* first byte is 0x00, just skip it */
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_change_pos (&writer, 1);
-      memset (result + pos, ((self->enrolled_num + 1) * 0x20) + 0x09,
+      written &= fpi_byte_writer_put_uint8 (&writer,
-              sizeof (guchar));
+                                            ((self->enrolled_ids->len + 1) * 0x20) +
-      pos += sizeof (guchar);
+                                            0x09);
     }
 
   /* command prefix */
   if (fpi_device_get_driver_data (device) & EGISMOC_DRIVER_CHECK_PREFIX_TYPE2)
-    {
+    written &= fpi_byte_writer_put_data (&writer, cmd_check_prefix_type2,
-      memcpy (result + pos, cmd_check_prefix_type2, cmd_check_prefix_type2_len);
+                                         cmd_check_prefix_type2_len);
-      pos += cmd_check_prefix_type2_len;
-    }
   else
-    {
+    written &= fpi_byte_writer_put_data (&writer, cmd_check_prefix_type1,
-      memcpy (result + pos, cmd_check_prefix_type1, cmd_check_prefix_type1_len);
+                                         cmd_check_prefix_type1_len);
-      pos += 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));
+      written &= fpi_byte_writer_put_uint8 (&writer, 0x01);
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_put_uint8 (&writer,
-      memset (result + pos, (self->enrolled_num - 7) * 0x20, sizeof (guchar));
+                                            (self->enrolled_ids->len - 7) * 0x20);
-      pos += sizeof (guchar);
     }
   else
     {
       /* first byte is 0x00, just skip it */
-      pos += sizeof (guchar);
+      written &= fpi_byte_writer_change_pos (&writer, 1);
-      memset (result + pos, (self->enrolled_num + 1) * 0x20, sizeof (guchar));
+      written &= fpi_byte_writer_put_uint8 (&writer,
-      pos += sizeof (guchar);
+                                            (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 */
+  for (guint i = 0; i < self->enrolled_ids->len && written; i++)
-  const gsize print_id_length = sizeof (guchar) * EGISMOC_FINGERPRINT_DATA_SIZE;
-
-  for (int i = 0; i < self->enrolled_num; i++)
     {
-      gchar *device_print_id = g_ptr_array_index (self->enrolled_ids, i);
+      written &= fpi_byte_writer_put_data (&writer,
-      memcpy (result + pos + (print_id_length * i), device_print_id, print_id_length);
+                                           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 */
+      fpi_byte_writer_init (&writer);
-      payload_length = cmd_new_print_prefix_len + EGISMOC_FINGERPRINT_DATA_SIZE;
+      if (!fpi_byte_writer_put_data (&writer, cmd_new_print_prefix,
-      payload = g_new0 (guchar, payload_length);
+                                     cmd_new_print_prefix_len))
-      memcpy (payload, cmd_new_print_prefix, cmd_new_print_prefix_len);
+        {
-      memcpy (payload + cmd_new_print_prefix_len, device_print_id,
+          fpi_ssm_mark_failed (ssm, fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
-              EGISMOC_FINGERPRINT_DATA_SIZE);
+          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;

libfprint/drivers/egismoc/egismoc.h

@@ -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]);

libfprint/drivers/elanmoc/elanmoc.c

@@ -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 */
 };
 

libfprint/drivers/fpcmoc/fpc.c

@@ -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;
 

libfprint/drivers/goodixmoc/goodix.c

@@ -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 */
 };
 

libfprint/drivers/realtek/realtek.c

@@ -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,
+fp_verify_get_template_cb (FpiDeviceRealtek *self,
-                    uint8_t          *buffer_in,
+                           uint8_t          *buffer_in,
-                    GError           *error)
+                           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,
+prepare_bulk_transfer (FpDevice      *dev,
-                  guint8        *data,
+                       guint8        *data,
-                  gsize          data_len,
+                       gsize          data_len,
-                  GDestroyNotify free_func)
+                       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,
+fp_ctrl_cmd_cb (FpiUsbTransfer *transfer,
-                    guint8           *cmd,
+                FpDevice       *device,
-                    guint8           *trans_data,
+                gpointer        user_data,
-                    FpRtkMsgType      message_type,
+                GError         *error)
-                    gboolean          bwait_data_delay,
+{
-                    SynCmdMsgCallback callback)
+  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;
+      cmd_buf = (guint8 *) &nor_identify_feature;
-      realtek_sensor_cmd (self, cmd_buf, NULL, FP_RTK_MSG_PLAINTEXT_NO_STATUS, 0, fp_identify_feature_cb);
+      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[0] = GET_LEN_L (self->template_len * self->template_num);
-      co_get_template.data_len[1] = GET_LEN_H (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;
+      nor_enroll_begin.param[0] = self->pos_index;
-      cmd_buf = (guint8 *) &tls_enroll_begin;
+      cmd_buf = (guint8 *) &nor_enroll_begin;
-      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_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;
+      nor_enroll_commit.param[0] = SUB_FINGER_01;
-      cmd_buf = (guint8 *) &tls_enroll_commit;
+      nor_enroll_commit.data_len[0] = GET_LEN_L (payload_len);
-      realtek_sensor_cmd (self, cmd_buf, trans_id, FP_RTK_MSG_PLAINTEXT, 0, fp_task_ssm_generic_cb);
+      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[0] = GET_LEN_L (self->template_len * self->template_num);
-      co_get_template.data_len[1] = GET_LEN_H (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;
-    self->fp_purpose = FP_RTK_PURPOSE_IDENTIFY;
-  else
-    self->fp_purpose = FP_RTK_PURPOSE_VERIFY;
 
   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[0] = GET_LEN_L (self->template_len * self->template_num);
-  co_get_template.data_len[1] = GET_LEN_H (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

libfprint/drivers/realtek/realtek.h

@@ -30,16 +30,17 @@
 
 #define EP_IN_MAX_BUF_SIZE 2048
 
-#define FP_RTK_CMD_TOTAL_LEN 12
+#define FP_RTK_CMD_BULK_TOTAL_LEN 12
-#define FP_RTK_CMD_LEN 2
+#define FP_RTK_CMD_BULK_LEN 2
-#define FP_RTK_CMD_PARAM_LEN 4
+#define FP_RTK_CMD_BULK_PARAM_LEN 4
-#define FP_RTK_CMD_ADDR_LEN 4
+#define FP_RTK_CMD_BULK_ADDR_LEN 4
-#define FP_RTK_CMD_DATA_LEN 2
+#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_BULK_ONLY = 0,
-  FP_RTK_CMD_READ,
+  FP_RTK_CMD_BULK_READ,
-  FP_RTK_CMD_WRITE,
+  FP_RTK_CMD_BULK_WRITE,
 } FpRtkCmdType;
 
 typedef enum {
-  FP_RTK_MSG_PLAINTEXT = 0,
+  FP_RTK_MSG_DEFAULT = 0,
-  FP_RTK_MSG_PLAINTEXT_NO_STATUS,
+  FP_RTK_MSG_NO_STATUS,
 } FpRtkMsgType;
 
 typedef enum {
-  FP_RTK_PURPOSE_IDENTIFY = 0x01,     /* identify before enroll */
+  FP_RTK_PURPOSE_VERIFY   = 0x01,
-  FP_RTK_PURPOSE_VERIFY   = 0x02,
+  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 cmd[FP_RTK_CMD_BULK_LEN];
-  uint8_t param[FP_RTK_CMD_PARAM_LEN];
+  uint8_t param[FP_RTK_CMD_BULK_PARAM_LEN];
-  uint8_t addr[FP_RTK_CMD_ADDR_LEN];
+  uint8_t addr[FP_RTK_CMD_BULK_ADDR_LEN];
-  uint8_t data_len[FP_RTK_CMD_DATA_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},
+};

libfprint/drivers/synaptics/synaptics.c

@@ -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 */
 };
 

libfprint/fp-device.c

@@ -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;

libfprint/fpi-byte-reader.h

@@ -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

libfprint/fpi-byte-writer.c

@@ -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;

libfprint/fpi-byte-writer.h

@@ -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

libfprint/fpi-device.c

@@ -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:
-        case FP_DEVICE_TASK_RETURN_INT:
+      break;
-        case FP_DEVICE_TASK_RETURN_BOOL:
-          break;
 
-        case FP_DEVICE_TASK_RETURN_OBJECT:
+    case FP_DEVICE_TASK_RETURN_OBJECT:
-          g_clear_object ((GObject **) &data->result);
+      g_clear_object ((GObject **) &data->result);
-          break;
+      break;
 
-        case FP_DEVICE_TASK_RETURN_PTR_ARRAY:
+    case FP_DEVICE_TASK_RETURN_PTR_ARRAY:
-          g_clear_pointer ((GPtrArray **) &data->result, g_ptr_array_unref);
+      g_clear_pointer ((GPtrArray **) &data->result, g_ptr_array_unref);
-          break;
+      break;
 
-        case FP_DEVICE_TASK_RETURN_ERROR:
+    case FP_DEVICE_TASK_RETURN_ERROR:
-          g_clear_error ((GError **) &data->result);
+      g_clear_error ((GError **) &data->result);
-          break;
+      break;
 
-        default:
+    default:
-          g_assert_not_reached ();
+      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().

libfprint/fpi-image-device.c

@@ -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.
  */

libfprint/fprint-list-udev-hwdb.c

@@ -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 },

libfprint/meson.build

@@ -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',
 ]
 

meson.build

@@ -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' ],

tests/egismoc-0586/custom.py

@@ -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

tests/egismoc-0586/device

@@ -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

tests/egismoc-0587/custom.py

@@ -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

tests/egismoc-0587/device

@@ -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
+

tests/meson.build

@@ -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'],
             )

tests/realtek-5816/custom.py

@@ -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

tests/realtek-5816/device

@@ -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
+

tests/realtek/device

@@ -1,14 +1,14 @@
-P: /devices/pci0000:00/0000:00:14.0/usb1/1-4
+P: /devices/pci0000:00/0000:00:14.0/usb1/1-8
-N: bus/usb/001/005=12010102EF020140DA0B135801210301020109022E00010104A0FA0904000004FF02000507050102000200070583031000080705840310000807058202000200
+N: bus/usb/001/025=12010102EF020140DA0B135801210301020109022E00010104A0FA0904000004FF02000507050102000200070583031000080705840310000807058202000200
-E: DEVNAME=/dev/bus/usb/001/005
+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=pci-0000:00:14.0-usb-0:8
-E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_4
+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: dev=189:24\n
-A: devnum=5\n
+A: devnum=25\n
-A: devpath=4\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
+L: port=../1-0:1.0/usb1-port8
-A: power/active_duration=91232868\n
+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=Linux_6.5.0-18-generic_xhci-hcd
-E: ID_VENDOR_ENC=Linux\x206.2.0-35-generic\x20xhci-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_REVISION=0605
-E: ID_SERIAL=Linux_6.2.0-35-generic_xhci-hcd_xHCI_Host_Controller_0000:00:14.0
+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