elanspi: Do not allow image captures to be interrupted

Avoid unexpected state changes during image capture. This also means
that the old line handler does not need to check for cancellation.

NEWS

@@ -1,6 +1,13 @@
 This file lists notable changes in each release. For the full history of all
 changes, see ChangeLog.
 
+2021-11-02: v1.94.2 release
+
+Highlights:
+ * goodixmoc: Fix protocol error with certain username lengths
+ * elanmoc: New PID 0x0c7d
+ * goodixmoc: New PID 0x63cc
+
 2021-09-24: v1.94.1 release
 
 Highlights:

data/autosuspend.hwdb

@@ -142,6 +142,7 @@ usb:v04F3p0C58*
  ID_PERSIST=0
 
 # Supported by libfprint driver elanmoc
+usb:v04F3p0C7D*
 usb:v04F3p0C7E*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
@@ -158,6 +159,7 @@ usb:v27C6p60A2*
 usb:v27C6p639C*
 usb:v27C6p63AC*
 usb:v27C6p63BC*
+usb:v27C6p63CC*
 usb:v27C6p6496*
 usb:v27C6p6584*
 usb:v27C6p658C*
@@ -284,6 +286,7 @@ usb:v0A5Cp5842*
 usb:v0A5Cp5843*
 usb:v0A5Cp5844*
 usb:v0A5Cp5845*
+usb:v0BDAp5812*
 usb:v10A5p0007*
 usb:v1188p9545*
 usb:v138Ap0007*

doc/libfprint-2-sections.txt

@@ -179,6 +179,7 @@ fpi_device_enroll_complete
 fpi_device_verify_complete
 fpi_device_identify_complete
 fpi_device_capture_complete
+fpi_device_clear_storage_complete
 fpi_device_delete_complete
 fpi_device_list_complete
 fpi_device_suspend_complete
@@ -246,6 +247,7 @@ fpi_ssm_new_full
 fpi_ssm_free
 fpi_ssm_start
 fpi_ssm_start_subsm
+fpi_ssm_set_critical
 fpi_ssm_next_state
 fpi_ssm_next_state_delayed
 fpi_ssm_jump_to_state
@@ -259,7 +261,11 @@ fpi_ssm_get_device
 fpi_ssm_get_error
 fpi_ssm_dup_error
 fpi_ssm_get_cur_state
+fpi_ssm_silence_debug
+fpi_ssm_spi_transfer_cb
+fpi_ssm_spi_transfer_with_weak_pointer_cb
 fpi_ssm_usb_transfer_cb
+fpi_ssm_usb_transfer_with_weak_pointer_cb
 FpiSsm
 </SECTION>
 
@@ -286,3 +292,20 @@ FPI_TYPE_USB_TRANSFER
 fpi_usb_transfer_get_type
 </SECTION>
 
+<SECTION>
+<FILE>fpi-spi-transfer</FILE>
+FpiSpiTransferCallback
+FpiSpiTransfer
+fpi_spi_transfer_new
+fpi_spi_transfer_ref
+fpi_spi_transfer_unref
+fpi_spi_transfer_write
+fpi_spi_transfer_write_full
+fpi_spi_transfer_read
+fpi_spi_transfer_read_full
+fpi_spi_transfer_submit
+fpi_spi_transfer_submit_sync
+<SUBSECTION Standard>
+FPI_TYPE_SPI_TRANSFER
+fpi_spi_transfer_get_type
+</SECTION>

doc/libfprint-docs.xml

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

examples/enroll.c

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

examples/storage.c

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

examples/storage.h

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

libfprint/drivers/elanmoc/elanmoc.c

@@ -25,6 +25,7 @@
 G_DEFINE_TYPE (FpiDeviceElanmoc, fpi_device_elanmoc, FP_TYPE_DEVICE)
 
 static const FpIdEntry id_table[] = {
+  { .vid = 0x04f3,  .pid = 0x0c7d,  },
   { .vid = 0x04f3,  .pid = 0x0c7e,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };

libfprint/drivers/elanspi.c

@@ -434,21 +434,9 @@ elanspi_capture_old_line_handler (FpiSpiTransfer *transfer, FpDevice *dev, gpoin
   self->old_data.line_ptr += 1;
   /* if there is still data, continue from check lineready */
   if (self->old_data.line_ptr < self->sensor_height)
-    {
+    fpi_ssm_jump_to_state (transfer->ssm, ELANSPI_CAPTOLD_CHECK_LINEREADY);
-      fpi_ssm_jump_to_state (transfer->ssm, ELANSPI_CAPTOLD_CHECK_LINEREADY);
-    }
   else
-    {
+    fpi_ssm_mark_completed (transfer->ssm);
-      /* check for cancellation */
-      if (fpi_device_action_is_cancelled (dev))
-        {
-          g_cancellable_set_error_if_cancelled (fpi_device_get_cancellable (dev), &error);
-          fpi_ssm_mark_failed (transfer->ssm, error);
-          return;
-        }
-      /* otherwise finish succesfully */
-      fpi_ssm_mark_completed (transfer->ssm);
-    }
 }
 
 static void
@@ -606,6 +594,8 @@ elanspi_calibrate_old_handler (FpiSsm *ssm, FpDevice *dev)
     case ELANSPI_CALIBOLD_CHECKFIN_CAPTURE:
     case ELANSPI_CALIBOLD_DACFINE_CAPTURE:
       chld = fpi_ssm_new (dev, elanspi_capture_old_handler, ELANSPI_CAPTOLD_NSTATES);
+      fpi_ssm_silence_debug (chld);
+      fpi_ssm_set_critical (chld);
       fpi_ssm_start_subsm (ssm, chld);
       return;
 
@@ -860,6 +850,8 @@ elanspi_calibrate_hv_handler (FpiSsm *ssm, FpDevice *dev)
 
     case ELANSPI_CALIBHV_CAPTURE:
       chld = fpi_ssm_new (dev, elanspi_capture_hv_handler, ELANSPI_CAPTHV_NSTATES);
+      fpi_ssm_silence_debug (chld);
+      fpi_ssm_set_critical (chld);
       fpi_ssm_start_subsm (ssm, chld);
       return;
 
@@ -1115,6 +1107,8 @@ do_sw_reset:
         chld = fpi_ssm_new_full (dev, elanspi_calibrate_hv_handler, ELANSPI_CALIBHV_NSTATES, ELANSPI_CALIBHV_PROTECT, "HV calibrate");
       else
         chld = fpi_ssm_new_full (dev, elanspi_calibrate_old_handler, ELANSPI_CALIBOLD_NSTATES, ELANSPI_CALIBOLD_PROTECT, "old calibrate");
+      fpi_ssm_silence_debug (chld);
+      fpi_ssm_set_critical (chld);
       fpi_ssm_start_subsm (ssm, chld);
       return;
 
@@ -1123,6 +1117,8 @@ do_sw_reset:
         chld = fpi_ssm_new (dev, elanspi_capture_hv_handler, ELANSPI_CAPTHV_NSTATES);
       else
         chld = fpi_ssm_new (dev, elanspi_capture_old_handler, ELANSPI_CAPTOLD_NSTATES);
+      fpi_ssm_silence_debug (chld);
+      fpi_ssm_set_critical (chld);
       fpi_ssm_start_subsm (ssm, chld);
       return;
 
@@ -1219,8 +1215,6 @@ elanspi_guess_image (FpiDeviceElanSpi *self, guint16 *raw_image)
 
   sq_stddev /= (frame_width * frame_height);
 
-  fp_dbg ("<guess> stddev=%" G_GUINT64_FORMAT "d, ip=%d, is_fp=%d, is_empty=%d", sq_stddev, invalid_percent, is_fp, is_empty);
-
   if (invalid_percent < ELANSPI_MAX_REAL_INVALID_PERCENT)
     is_fp += 1;
   if (invalid_percent > ELANSPI_MIN_EMPTY_INVALID_PERCENT)
@@ -1231,6 +1225,8 @@ elanspi_guess_image (FpiDeviceElanSpi *self, guint16 *raw_image)
   if (sq_stddev < ELANSPI_MAX_EMPTY_STDDEV)
     is_empty += 1;
 
+  fp_dbg ("<guess> stddev=%" G_GUINT64_FORMAT "d, ip=%d, is_fp=%d, is_empty=%d", sq_stddev, invalid_percent, is_fp, is_empty);
+
   if (is_fp > is_empty)
     return ELANSPI_GUESS_FINGERPRINT;
   else if (is_empty > is_fp)
@@ -1495,6 +1491,8 @@ elanspi_fp_capture_ssm_handler (FpiSsm *ssm, FpDevice *dev)
         chld = fpi_ssm_new (dev, elanspi_capture_hv_handler, ELANSPI_CAPTHV_NSTATES);
       else
         chld = fpi_ssm_new (dev, elanspi_capture_old_handler, ELANSPI_CAPTOLD_NSTATES);
+      fpi_ssm_silence_debug (chld);
+      fpi_ssm_set_critical (chld);
       fpi_ssm_start_subsm (ssm, chld);
       return;
 

libfprint/drivers/goodixmoc/goodix.c

@@ -1282,6 +1282,7 @@ gx_fp_probe (FpDevice *device)
     case 0x639C:
     case 0x63AC:
     case 0x63BC:
+    case 0x63CC:
     case 0x6A94:
       self->max_enroll_stage = 12;
       break;
@@ -1505,6 +1506,7 @@ static const FpIdEntry id_table[] = {
   { .vid = 0x27c6,  .pid = 0x639C,  },
   { .vid = 0x27c6,  .pid = 0x63AC,  },
   { .vid = 0x27c6,  .pid = 0x63BC,  },
+  { .vid = 0x27c6,  .pid = 0x63CC,  },
   { .vid = 0x27c6,  .pid = 0x6496,  },
   { .vid = 0x27c6,  .pid = 0x6584,  },
   { .vid = 0x27c6,  .pid = 0x658C,  },

libfprint/drivers/goodixmoc/goodix_proto.h

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

libfprint/fp-context.c

@@ -426,6 +426,7 @@ void
 fp_context_enumerate (FpContext *context)
 {
   FpContextPrivate *priv = fp_context_get_instance_private (context);
+  gboolean dispatched;
   gint i;
 
   g_return_if_fail (FP_IS_CONTEXT (context));
@@ -564,8 +565,19 @@ fp_context_enumerate (FpContext *context)
   }
 #endif
 
-  while (priv->pending_devices)
+  /* Iterate until 1. we have no pending devices, and 2. the mainloop is idle
-    g_main_context_iteration (NULL, TRUE);
+   * This takes care of processing hotplug events that happened during
+   * enumeration.
+   * This is important due to USB `persist` being turned off. At resume time,
+   * devices will disappear and immediately re-appear. In this situation,
+   * enumerate could first see the old state with a removed device resulting
+   * in it to not be discovered.
+   * As a hotplug event is seemingly emitted by the kernel immediately, we can
+   * simply make sure to process all events before returning from enumerate.
+   */
+  dispatched = TRUE;
+  while (priv->pending_devices || dispatched)
+    dispatched = g_main_context_iteration (NULL, !!priv->pending_devices);
 }
 
 /**

libfprint/fp-device.c

@@ -1189,10 +1189,11 @@ fp_device_resume_finish (FpDevice     *device,
  * fp_device_enroll_finish().
  *
  * The @template_print parameter is a #FpPrint with available metadata filled
- * in. The driver may make use of this metadata, when e.g. storing the print on
+ * in and, optionally, with existing fingerprint data to be updated with newly
- * device memory. It is undefined whether this print is filled in by the driver
+ * enrolled fingerprints if a device driver supports it. The driver may make use
- * and returned, or whether the driver will return a newly created print after
+ * of the metadata, when e.g. storing the print on device memory. It is undefined
- * enrollment succeeded.
+ * whether this print is filled in by the driver and returned, or whether the
+ * driver will return a newly created print after enrollment succeeded.
  */
 void
 fp_device_enroll (FpDevice           *device,
@@ -1229,19 +1230,30 @@ fp_device_enroll (FpDevice           *device,
 
   if (!FP_IS_PRINT (template_print))
     {
-      g_warning ("User did not pass a print template!");
       g_task_return_error (task,
-                           fpi_device_error_new (FP_DEVICE_ERROR_DATA_INVALID));
+                           fpi_device_error_new_msg (FP_DEVICE_ERROR_DATA_INVALID,
+                                                     "User did not pass a print template!"));
       return;
     }
 
   g_object_get (template_print, "fpi-type", &print_type, NULL);
   if (print_type != FPI_PRINT_UNDEFINED)
     {
-      g_warning ("Passed print template must be newly created and blank!");
+      if (!fp_device_has_feature (device, FP_DEVICE_FEATURE_UPDATE_PRINT))
-      g_task_return_error (task,
+        {
-                           fpi_device_error_new (FP_DEVICE_ERROR_DATA_INVALID));
+          g_task_return_error (task,
-      return;
+                               fpi_device_error_new_msg (FP_DEVICE_ERROR_DATA_INVALID,
+                                                         "A device does not support print updates!"));
+          return;
+        }
+      if (!fp_print_compatible (template_print, device))
+        {
+          g_task_return_error (task,
+                               fpi_device_error_new_msg (FP_DEVICE_ERROR_DATA_INVALID,
+                                                         "The print and device must have a matching driver and device id"
+                                                         " for a fingerprint update to succeed"));
+          return;
+        }
     }
 
   priv->current_action = FPI_DEVICE_ACTION_ENROLL;

libfprint/fp-device.h

@@ -59,6 +59,7 @@ typedef enum {
  * @FP_DEVICE_FEATURE_STORAGE_CLEAR: Supports clearing the whole storage
  * @FP_DEVICE_FEATURE_DUPLICATES_CHECK: Natively supports duplicates detection
  * @FP_DEVICE_FEATURE_ALWAYS_ON: Whether the device can run continuously
+ * @FP_DEVICE_FEATURE_UPDATE_PRINT: Supports updating an existing print record using new scans
  */
 typedef enum /*< flags >*/ {
   FP_DEVICE_FEATURE_NONE = 0,
@@ -71,6 +72,7 @@ typedef enum /*< flags >*/ {
   FP_DEVICE_FEATURE_STORAGE_CLEAR = 1 << 6,
   FP_DEVICE_FEATURE_DUPLICATES_CHECK = 1 << 7,
   FP_DEVICE_FEATURE_ALWAYS_ON = 1 << 8,
+  FP_DEVICE_FEATURE_UPDATE_PRINT = 1 << 9,
 } FpDeviceFeature;
 
 /**

libfprint/fp-image-device.c

@@ -101,6 +101,7 @@ fp_image_device_start_capture_action (FpDevice *device)
   FpImageDevice *self = FP_IMAGE_DEVICE (device);
   FpImageDevicePrivate *priv = fp_image_device_get_instance_private (self);
   FpiDeviceAction action;
+  FpiPrintType print_type;
 
   /* There is just one action that we cannot support out
    * of the box, which is a capture without first waiting
@@ -124,7 +125,9 @@ fp_image_device_start_capture_action (FpDevice *device)
       FpPrint *enroll_print = NULL;
 
       fpi_device_get_enroll_data (device, &enroll_print);
-      fpi_print_set_type (enroll_print, FPI_PRINT_NBIS);
+      g_object_get (enroll_print, "fpi-type", &print_type, NULL);
+      if (print_type != FPI_PRINT_NBIS)
+        fpi_print_set_type (enroll_print, FPI_PRINT_NBIS);
     }
 
   priv->enroll_stage = 0;
@@ -221,6 +224,7 @@ fp_image_device_class_init (FpImageDeviceClass *klass)
   fp_device_class->cancel = fp_image_device_cancel_action;
 
   fpi_device_class_auto_initialize_features (fp_device_class);
+  fp_device_class->features |= FP_DEVICE_FEATURE_UPDATE_PRINT;
 
   /* Default implementations */
   klass->activate = fp_image_device_default_activate;

libfprint/fp-print.c

@@ -61,6 +61,7 @@ enum {
   /* Private property*/
   PROP_FPI_TYPE,
   PROP_FPI_DATA,
+  PROP_FPI_PRINTS,
   N_PROPS
 };
 
@@ -133,6 +134,10 @@ fp_print_get_property (GObject    *object,
       g_value_set_variant (value, self->data);
       break;
 
+    case PROP_FPI_PRINTS:
+      g_value_set_pointer (value, self->prints);
+      break;
+
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     }
@@ -188,6 +193,11 @@ fp_print_set_property (GObject      *object,
       self->data = g_value_dup_variant (value);
       break;
 
+    case PROP_FPI_PRINTS:
+      g_clear_pointer (&self->prints, g_ptr_array_unref);
+      self->prints = g_value_get_pointer (value);
+      break;
+
     default:
       G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
     }
@@ -299,6 +309,19 @@ fp_print_class_init (FpPrintClass *klass)
                           NULL,
                           G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
 
+  /**
+   * FpPrint::fpi-prints: (skip)
+   *
+   * This property is only for internal purposes.
+   *
+   * Stability: private
+   */
+  properties[PROP_FPI_PRINTS] =
+    g_param_spec_pointer ("fpi-prints",
+                          "Prints",
+                          "Prints for internal use only",
+                          G_PARAM_STATIC_STRINGS | G_PARAM_READWRITE);
+
   g_object_class_install_properties (object_class, N_PROPS, properties);
 }
 

libfprint/fpi-device.h

@@ -25,9 +25,11 @@
 #include "fpi-print.h"
 
 /**
- * FpiDeviceUdevSubtype:
+ * FpiDeviceUdevSubtypeFlags:
  * @FPI_DEVICE_UDEV_SUBTYPE_SPIDEV: The device requires an spidev node
  * @FPI_DEVICE_UDEV_SUBTYPE_HIDRAW: The device requires a hidraw node
+ *
+ * Bitfield of required hardware resources for a udev-backed device.
  */
 typedef enum {
   FPI_DEVICE_UDEV_SUBTYPE_SPIDEV = 1 << 0,

libfprint/fpi-ssm.c

@@ -81,6 +81,8 @@ struct _FpiSsm
   int                     start_cleanup;
   int                     cur_state;
   gboolean                completed;
+  gboolean                critical;
+  gboolean                silence;
   GSource                *timeout;
   GError                 *error;
   FpiSsmCompletedCallback callback;
@@ -245,10 +247,11 @@ fpi_ssm_free (FpiSsm *machine)
 
 /* Invoke the state handler */
 static void
-__ssm_call_handler (FpiSsm *machine)
+__ssm_call_handler (FpiSsm *machine, gboolean force_msg)
 {
-  fp_dbg ("[%s] %s entering state %d", fp_device_get_driver (machine->dev),
+  if (force_msg || !machine->silence)
-          machine->name, machine->cur_state);
+    fp_dbg ("[%s] %s entering state %d", fp_device_get_driver (machine->dev),
+            machine->name, machine->cur_state);
   machine->handler (machine, machine->dev);
 }
 
@@ -275,7 +278,11 @@ fpi_ssm_start (FpiSsm *ssm, FpiSsmCompletedCallback callback)
   ssm->cur_state = 0;
   ssm->completed = FALSE;
   ssm->error = NULL;
-  __ssm_call_handler (ssm);
+
+  if (ssm->critical)
+    fpi_device_critical_enter (ssm->dev);
+
+  __ssm_call_handler (ssm, TRUE);
 }
 
 static void
@@ -346,7 +353,7 @@ fpi_ssm_mark_completed (FpiSsm *machine)
   if (next_state < machine->nr_states)
     {
       machine->cur_state = next_state;
-      __ssm_call_handler (machine);
+      __ssm_call_handler (machine, TRUE);
       return;
     }
 
@@ -364,6 +371,10 @@ fpi_ssm_mark_completed (FpiSsm *machine)
 
       machine->callback (machine, machine->dev, error);
     }
+
+  if (machine->critical)
+    fpi_device_critical_leave (machine->dev);
+
   fpi_ssm_free (machine);
 }
 
@@ -460,7 +471,7 @@ fpi_ssm_next_state (FpiSsm *machine)
   if (machine->cur_state == machine->nr_states)
     fpi_ssm_mark_completed (machine);
   else
-    __ssm_call_handler (machine);
+    __ssm_call_handler (machine, FALSE);
 }
 
 void
@@ -537,7 +548,7 @@ fpi_ssm_jump_to_state (FpiSsm *machine, int state)
   if (machine->cur_state == machine->nr_states)
     fpi_ssm_mark_completed (machine);
   else
-    __ssm_call_handler (machine);
+    __ssm_call_handler (machine, FALSE);
 }
 
 typedef struct
@@ -642,6 +653,39 @@ fpi_ssm_dup_error (FpiSsm *machine)
   return NULL;
 }
 
+/**
+ * fpi_ssm_silence_debug:
+ * @machine: an #FpiSsm state machine
+ *
+ * Turn off state change debug messages from this SSM. This does not disable
+ * all messages, as e.g. the initial state, SSM completion and cleanup states
+ * are still printed out.
+ *
+ * Use if the SSM loops and would flood the debug log otherwise.
+ */
+void
+fpi_ssm_silence_debug (FpiSsm *machine)
+{
+  machine->silence = TRUE;
+}
+
+/**
+ * fpi_ssm_set_critical:
+ * @machine: an #FpiSsm state machine
+ *
+ * Sets up the SSM to hold a critical section in the driver code. See
+ * fpi_device_critical_enter() for more details. This is useful if the SSM must
+ * not be interrupted in order to keep the device in a good state. You can e.g.
+ * guarantee that an image transfer is completed.
+ *
+ * This function must be called before starting the SSM.
+ */
+void
+fpi_ssm_set_critical (FpiSsm *machine)
+{
+  machine->critical = TRUE;
+}
+
 /**
  * fpi_ssm_usb_transfer_cb:
  * @transfer: a #FpiUsbTransfer

libfprint/fpi-ssm.h

@@ -96,6 +96,9 @@ GError * fpi_ssm_get_error (FpiSsm *machine);
 GError * fpi_ssm_dup_error (FpiSsm *machine);
 int fpi_ssm_get_cur_state (FpiSsm *machine);
 
+void fpi_ssm_silence_debug (FpiSsm *machine);
+void fpi_ssm_set_critical (FpiSsm *machine);
+
 /* Callbacks to be used by the driver instead of implementing their own
  * logic.
  */

libfprint/fprint-list-udev-hwdb.c

@@ -60,6 +60,7 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0x0a5c, .pid = 0x5843 },
   { .vid = 0x0a5c, .pid = 0x5844 },
   { .vid = 0x0a5c, .pid = 0x5845 },
+  { .vid = 0x0bda, .pid = 0x5812 },
   { .vid = 0x10a5, .pid = 0x0007 },
   { .vid = 0x1188, .pid = 0x9545 },
   { .vid = 0x138a, .pid = 0x0007 },

meson.build

@@ -1,5 +1,5 @@
 project('libfprint', [ 'c', 'cpp' ],
-    version: '1.94.1',
+    version: '1.94.2',
     license: 'LGPLv2.1+',
     default_options: [
         'buildtype=debugoptimized',

tests/egis0570/device

@@ -25,63 +25,63 @@ E: ID_VENDOR_FROM_DATABASE=LighTuning Technology Inc.
 E: ID_PATH=pci-0000:00:14.0-usb-0:9
 E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_9
 E: LIBFPRINT_DRIVER=Hardcoded whitelist
-A: authorized=1
+A: authorized=1\n
-A: avoid_reset_quirk=0
+A: avoid_reset_quirk=0\n
-A: bConfigurationValue=1
+A: bConfigurationValue=1\n
-A: bDeviceClass=00
+A: bDeviceClass=00\n
-A: bDeviceProtocol=00
+A: bDeviceProtocol=00\n
-A: bDeviceSubClass=00
+A: bDeviceSubClass=00\n
-A: bMaxPacketSize0=8
+A: bMaxPacketSize0=8\n
-A: bMaxPower=100mA
+A: bMaxPower=100mA\n
-A: bNumConfigurations=1
+A: bNumConfigurations=1\n
-A: bNumInterfaces= 1
+A: bNumInterfaces= 1\n
-A: bcdDevice=1041
+A: bcdDevice=1041\n
-A: bmAttributes=a0
+A: bmAttributes=a0\n
-A: busnum=1
+A: busnum=1\n
-A: configuration=
+A: configuration=\n
 H: descriptors=12011001000000087A1C700541100102030109022000010100A0320904000002FF0000000705830240000007050402400003
-A: dev=189:4
+A: dev=189:4\n
-A: devnum=5
+A: devnum=5\n
-A: devpath=9
+A: devpath=9\n
 L: driver=../../../../../bus/usb/drivers/usb
-A: idProduct=0570
+A: idProduct=0570\n
-A: idVendor=1c7a
+A: idVendor=1c7a\n
-A: ltm_capable=no
+A: ltm_capable=no\n
-A: manufacturer=EgisTec
+A: manufacturer=EgisTec\n
-A: maxchild=0
+A: maxchild=0\n
 L: port=../1-0:1.0/usb1-port9
-A: power/active_duration=362352
+A: power/active_duration=362352\n
-A: power/async=enabled
+A: power/async=enabled\n
-A: power/autosuspend=2
+A: power/autosuspend=2\n
-A: power/autosuspend_delay_ms=2000
+A: power/autosuspend_delay_ms=2000\n
-A: power/connected_duration=5526124
+A: power/connected_duration=5526124\n
-A: power/control=auto
+A: power/control=auto\n
-A: power/level=auto
+A: power/level=auto\n
-A: power/persist=1
+A: power/persist=1\n
-A: power/runtime_active_kids=0
+A: power/runtime_active_kids=0\n
-A: power/runtime_active_time=365097
+A: power/runtime_active_time=365097\n
-A: power/runtime_enabled=enabled
+A: power/runtime_enabled=enabled\n
-A: power/runtime_status=active
+A: power/runtime_status=active\n
-A: power/runtime_suspended_time=5160752
+A: power/runtime_suspended_time=5160752\n
-A: power/runtime_usage=0
+A: power/runtime_usage=0\n
-A: power/wakeup=disabled
+A: power/wakeup=disabled\n
-A: power/wakeup_abort_count=
+A: power/wakeup_abort_count=\n
-A: power/wakeup_active=
+A: power/wakeup_active=\n
-A: power/wakeup_active_count=
+A: power/wakeup_active_count=\n
-A: power/wakeup_count=
+A: power/wakeup_count=\n
-A: power/wakeup_expire_count=
+A: power/wakeup_expire_count=\n
-A: power/wakeup_last_time_ms=
+A: power/wakeup_last_time_ms=\n
-A: power/wakeup_max_time_ms=
+A: power/wakeup_max_time_ms=\n
-A: power/wakeup_total_time_ms=
+A: power/wakeup_total_time_ms=\n
-A: product=EgisTec Touch Fingerprint Sensor
+A: product=EgisTec Touch Fingerprint Sensor\n
-A: quirks=0x0
+A: quirks=0x0\n
-A: removable=fixed
+A: removable=fixed\n
-A: rx_lanes=1
+A: rx_lanes=1\n
-A: serial=W700B41B
+A: serial=W700B41B\n
-A: speed=12
+A: speed=12\n
-A: tx_lanes=1
+A: tx_lanes=1\n
-A: urbnum=8040
+A: urbnum=8040\n
-A: version= 1.10
+A: version= 1.10\n
 
 P: /devices/pci0000:00/0000:00:14.0/usb1
 N: bus/usb/001/001=12010002090001406B1D020008050302010109021900010100E0000904000001090000000705810304000C
@@ -112,63 +112,63 @@ 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:
-A: authorized=1
+A: authorized=1\n
-A: authorized_default=1
+A: authorized_default=1\n
-A: avoid_reset_quirk=0
+A: avoid_reset_quirk=0\n
-A: bConfigurationValue=1
+A: bConfigurationValue=1\n
-A: bDeviceClass=09
+A: bDeviceClass=09\n
-A: bDeviceProtocol=01
+A: bDeviceProtocol=01\n
-A: bDeviceSubClass=00
+A: bDeviceSubClass=00\n
-A: bMaxPacketSize0=64
+A: bMaxPacketSize0=64\n
-A: bMaxPower=0mA
+A: bMaxPower=0mA\n
-A: bNumConfigurations=1
+A: bNumConfigurations=1\n
-A: bNumInterfaces= 1
+A: bNumInterfaces= 1\n
-A: bcdDevice=0508
+A: bcdDevice=0508\n
-A: bmAttributes=e0
+A: bmAttributes=e0\n
-A: busnum=1
+A: busnum=1\n
-A: configuration=
+A: configuration=\n
 H: descriptors=12010002090001406B1D020008050302010109021900010100E0000904000001090000000705810304000C
-A: dev=189:0
+A: dev=189:0\n
-A: devnum=1
+A: devnum=1\n
-A: devpath=0
+A: devpath=0\n
 L: driver=../../../../bus/usb/drivers/usb
-A: idProduct=0002
+A: idProduct=0002\n
-A: idVendor=1d6b
+A: idVendor=1d6b\n
-A: interface_authorized_default=1
+A: interface_authorized_default=1\n
-A: ltm_capable=no
+A: ltm_capable=no\n
-A: manufacturer=Linux 5.8.0-59-generic xhci-hcd
+A: manufacturer=Linux 5.8.0-59-generic xhci-hcd\n
-A: maxchild=12
+A: maxchild=12\n
-A: power/active_duration=378024
+A: power/active_duration=378024\n
-A: power/async=enabled
+A: power/async=enabled\n
-A: power/autosuspend=0
+A: power/autosuspend=0\n
-A: power/autosuspend_delay_ms=0
+A: power/autosuspend_delay_ms=0\n
-A: power/connected_duration=5527220
+A: power/connected_duration=5527220\n
-A: power/control=auto
+A: power/control=auto\n
-A: power/level=auto
+A: power/level=auto\n
-A: power/runtime_active_kids=1
+A: power/runtime_active_kids=1\n
-A: power/runtime_active_time=377962
+A: power/runtime_active_time=377962\n
-A: power/runtime_enabled=enabled
+A: power/runtime_enabled=enabled\n
-A: power/runtime_status=active
+A: power/runtime_status=active\n
-A: power/runtime_suspended_time=5149253
+A: power/runtime_suspended_time=5149253\n
-A: power/runtime_usage=0
+A: power/runtime_usage=0\n
-A: power/wakeup=disabled
+A: power/wakeup=disabled\n
-A: power/wakeup_abort_count=
+A: power/wakeup_abort_count=\n
-A: power/wakeup_active=
+A: power/wakeup_active=\n
-A: power/wakeup_active_count=
+A: power/wakeup_active_count=\n
-A: power/wakeup_count=
+A: power/wakeup_count=\n
-A: power/wakeup_expire_count=
+A: power/wakeup_expire_count=\n
-A: power/wakeup_last_time_ms=
+A: power/wakeup_last_time_ms=\n
-A: power/wakeup_max_time_ms=
+A: power/wakeup_max_time_ms=\n
-A: power/wakeup_total_time_ms=
+A: power/wakeup_total_time_ms=\n
-A: product=xHCI Host Controller
+A: product=xHCI Host Controller\n
-A: quirks=0x0
+A: quirks=0x0\n
-A: removable=unknown
+A: removable=unknown\n
-A: rx_lanes=1
+A: rx_lanes=1\n
-A: serial=0000:00:14.0
+A: serial=0000:00:14.0\n
-A: speed=480
+A: speed=480\n
-A: tx_lanes=1
+A: tx_lanes=1\n
-A: urbnum=956
+A: urbnum=956\n
-A: version= 2.00
+A: version= 2.00\n
 
 P: /devices/pci0000:00/0000:00:14.0
 E: DRIVER=xhci_hcd
@@ -183,46 +183,46 @@ 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=Sunrise Point-LP USB 3.0 xHCI Controller
-A: ari_enabled=0
+A: ari_enabled=0\n
-A: broken_parity_status=0
+A: broken_parity_status=0\n
-A: class=0x0c0330
+A: class=0x0c0330\n
 H: config=86802F9D060490022130030C00008000040021A400000000000000000000000000000000000000000000000025108E11000000007000000000000000FF010000
-A: consistent_dma_mask_bits=64
+A: consistent_dma_mask_bits=64\n
-A: d3cold_allowed=1
+A: d3cold_allowed=1\n
-A: dbc=disabled
+A: dbc=disabled\n
-A: device=0x9d2f
+A: device=0x9d2f\n
-A: dma_mask_bits=64
+A: dma_mask_bits=64\n
 L: driver=../../../bus/pci/drivers/xhci_hcd
-A: driver_override=(null)
+A: driver_override=(null)\n
-A: enable=1
+A: enable=1\n
-A: irq=127
+A: irq=127\n
-A: local_cpulist=0-7
+A: local_cpulist=0-7\n
-A: local_cpus=ff
+A: local_cpus=ff\n
-A: modalias=pci:v00008086d00009D2Fsv00001025sd0000118Ebc0Csc03i30
+A: modalias=pci:v00008086d00009D2Fsv00001025sd0000118Ebc0Csc03i30\n
-A: msi_bus=1
+A: msi_bus=1\n
-A: msi_irqs/127=msi
+A: msi_irqs/127=msi\n
-A: numa_node=-1
+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    9   10 2112 10\nxHCI ring segments   32   36 4096 36\nbuffer-2048         1    2 2048  1\nbuffer-512          0    0  512  0\nbuffer-128          0    0  128  0\nbuffer-32           0    0   32  0
+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    9   10 2112 10\nxHCI ring segments   32   36 4096 36\nbuffer-2048         1    2 2048  1\nbuffer-512          0    0  512  0\nbuffer-128          0    0  128  0\nbuffer-32           0    0   32  0\n
-A: power/async=enabled
+A: power/async=enabled\n
-A: power/control=on
+A: power/control=on\n
-A: power/runtime_active_kids=1
+A: power/runtime_active_kids=1\n
-A: power/runtime_active_time=5524703
+A: power/runtime_active_time=5524703\n
-A: power/runtime_enabled=forbidden
+A: power/runtime_enabled=forbidden\n
-A: power/runtime_status=active
+A: power/runtime_status=active\n
-A: power/runtime_suspended_time=3373
+A: power/runtime_suspended_time=3373\n
-A: power/runtime_usage=1
+A: power/runtime_usage=1\n
-A: power/wakeup=enabled
+A: power/wakeup=enabled\n
-A: power/wakeup_abort_count=0
+A: power/wakeup_abort_count=0\n
-A: power/wakeup_active=0
+A: power/wakeup_active=0\n
-A: power/wakeup_active_count=0
+A: power/wakeup_active_count=0\n
-A: power/wakeup_count=0
+A: power/wakeup_count=0\n
-A: power/wakeup_expire_count=0
+A: power/wakeup_expire_count=0\n
-A: power/wakeup_last_time_ms=0
+A: power/wakeup_last_time_ms=0\n
-A: power/wakeup_max_time_ms=0
+A: power/wakeup_max_time_ms=0\n
-A: power/wakeup_total_time_ms=0
+A: power/wakeup_total_time_ms=0\n
-A: resource=0x00000000a4210000 0x00000000a421ffff 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
+A: resource=0x00000000a4210000 0x00000000a421ffff 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=0x21
+A: revision=0x21\n
-A: subsystem_device=0x118e
+A: subsystem_device=0x118e\n
-A: subsystem_vendor=0x1025
+A: subsystem_vendor=0x1025\n
-A: vendor=0x8086
+A: vendor=0x8086\n
 

tests/elanmoc/device

@@ -23,62 +23,62 @@ E: ID_USB_INTERFACES=:ff0000:
 E: ID_VENDOR_FROM_DATABASE=Elan Microelectronics Corp.
 E: ID_PATH=pci-0000:00:14.0-usb-0:1
 E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_1
-A: authorized=1
+A: authorized=1\n
-A: avoid_reset_quirk=0
+A: avoid_reset_quirk=0\n
-A: bConfigurationValue=1
+A: bConfigurationValue=1\n
-A: bDeviceClass=00
+A: bDeviceClass=00\n
-A: bDeviceProtocol=00
+A: bDeviceProtocol=00\n
-A: bDeviceSubClass=00
+A: bDeviceSubClass=00\n
-A: bMaxPacketSize0=64
+A: bMaxPacketSize0=64\n
-A: bMaxPower=100mA
+A: bMaxPower=100mA\n
-A: bNumConfigurations=1
+A: bNumConfigurations=1\n
-A: bNumInterfaces= 1
+A: bNumInterfaces= 1\n
-A: bcdDevice=0305
+A: bcdDevice=0305\n
-A: bmAttributes=a0
+A: bmAttributes=a0\n
-A: busnum=1
+A: busnum=1\n
-A: configuration=add909c9-e67e-4126-a6f7-1e31179e27d9
+A: configuration=add909c9-e67e-4126-a6f7-1e31179e27d9\n
 H: descriptors=1201000200000040F3047E0C05030102000109025300010103A0320904000008FF0000000921100100012215000705810240000107050102400001070582024000010705020240000107058302400001070503024000010705840240000107050402400001
-A: dev=189:9
+A: dev=189:9\n
-A: devnum=10
+A: devnum=10\n
-A: devpath=1
+A: devpath=1\n
 L: driver=../../../../../bus/usb/drivers/usb
-A: idProduct=0c7e
+A: idProduct=0c7e\n
-A: idVendor=04f3
+A: idVendor=04f3\n
-A: ltm_capable=no
+A: ltm_capable=no\n
-A: manufacturer=ELAN
+A: manufacturer=ELAN\n
-A: maxchild=0
+A: maxchild=0\n
 L: port=../1-0:1.0/usb1-port1
-A: power/active_duration=94712
+A: power/active_duration=94712\n
-A: power/async=enabled
+A: power/async=enabled\n
-A: power/autosuspend=2
+A: power/autosuspend=2\n
-A: power/autosuspend_delay_ms=2000
+A: power/autosuspend_delay_ms=2000\n
-A: power/connected_duration=94712
+A: power/connected_duration=94712\n
-A: power/control=on
+A: power/control=on\n
-A: power/level=on
+A: power/level=on\n
-A: power/persist=1
+A: power/persist=1\n
-A: power/runtime_active_kids=0
+A: power/runtime_active_kids=0\n
-A: power/runtime_active_time=94436
+A: power/runtime_active_time=94436\n
-A: power/runtime_enabled=forbidden
+A: power/runtime_enabled=forbidden\n
-A: power/runtime_status=active
+A: power/runtime_status=active\n
-A: power/runtime_suspended_time=0
+A: power/runtime_suspended_time=0\n
-A: power/runtime_usage=1
+A: power/runtime_usage=1\n
-A: power/wakeup=disabled
+A: power/wakeup=disabled\n
-A: power/wakeup_abort_count=
+A: power/wakeup_abort_count=\n
-A: power/wakeup_active=
+A: power/wakeup_active=\n
-A: power/wakeup_active_count=
+A: power/wakeup_active_count=\n
-A: power/wakeup_count=
+A: power/wakeup_count=\n
-A: power/wakeup_expire_count=
+A: power/wakeup_expire_count=\n
-A: power/wakeup_last_time_ms=
+A: power/wakeup_last_time_ms=\n
-A: power/wakeup_max_time_ms=
+A: power/wakeup_max_time_ms=\n
-A: power/wakeup_total_time_ms=
+A: power/wakeup_total_time_ms=\n
-A: product=ELAN:ARM-M4
+A: product=ELAN:ARM-M4\n
-A: quirks=0x0
+A: quirks=0x0\n
-A: removable=removable
+A: removable=removable\n
-A: rx_lanes=1
+A: rx_lanes=1\n
-A: speed=12
+A: speed=12\n
-A: tx_lanes=1
+A: tx_lanes=1\n
-A: urbnum=12
+A: urbnum=12\n
-A: version= 2.00
+A: version= 2.00\n
 
 P: /devices/pci0000:00/0000:00:14.0/usb1
 N: bus/usb/001/001=12010002090001406B1D020004050302010109021900010100E0000904000001090000000705810304000C
@@ -109,63 +109,63 @@ 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:
-A: authorized=1
+A: authorized=1\n
-A: authorized_default=1
+A: authorized_default=1\n
-A: avoid_reset_quirk=0
+A: avoid_reset_quirk=0\n
-A: bConfigurationValue=1
+A: bConfigurationValue=1\n
-A: bDeviceClass=09
+A: bDeviceClass=09\n
-A: bDeviceProtocol=01
+A: bDeviceProtocol=01\n
-A: bDeviceSubClass=00
+A: bDeviceSubClass=00\n
-A: bMaxPacketSize0=64
+A: bMaxPacketSize0=64\n
-A: bMaxPower=0mA
+A: bMaxPower=0mA\n
-A: bNumConfigurations=1
+A: bNumConfigurations=1\n
-A: bNumInterfaces= 1
+A: bNumInterfaces= 1\n
-A: bcdDevice=0504
+A: bcdDevice=0504\n
-A: bmAttributes=e0
+A: bmAttributes=e0\n
-A: busnum=1
+A: busnum=1\n
-A: configuration=
+A: configuration=\n
 H: descriptors=12010002090001406B1D020004050302010109021900010100E0000904000001090000000705810304000C
-A: dev=189:0
+A: dev=189:0\n
-A: devnum=1
+A: devnum=1\n
-A: devpath=0
+A: devpath=0\n
 L: driver=../../../../bus/usb/drivers/usb
-A: idProduct=0002
+A: idProduct=0002\n
-A: idVendor=1d6b
+A: idVendor=1d6b\n
-A: interface_authorized_default=1
+A: interface_authorized_default=1\n
-A: ltm_capable=no
+A: ltm_capable=no\n
-A: manufacturer=Linux 5.4.0-42-generic xhci-hcd
+A: manufacturer=Linux 5.4.0-42-generic xhci-hcd\n
-A: maxchild=12
+A: maxchild=12\n
-A: power/active_duration=74604360
+A: power/active_duration=74604360\n
-A: power/async=enabled
+A: power/async=enabled\n
-A: power/autosuspend=0
+A: power/autosuspend=0\n
-A: power/autosuspend_delay_ms=0
+A: power/autosuspend_delay_ms=0\n
-A: power/connected_duration=74606456
+A: power/connected_duration=74606456\n
-A: power/control=auto
+A: power/control=auto\n
-A: power/level=auto
+A: power/level=auto\n
-A: power/runtime_active_kids=4
+A: power/runtime_active_kids=4\n
-A: power/runtime_active_time=74605838
+A: power/runtime_active_time=74605838\n
-A: power/runtime_enabled=enabled
+A: power/runtime_enabled=enabled\n
-A: power/runtime_status=active
+A: power/runtime_status=active\n
-A: power/runtime_suspended_time=0
+A: power/runtime_suspended_time=0\n
-A: power/runtime_usage=0
+A: power/runtime_usage=0\n
-A: power/wakeup=disabled
+A: power/wakeup=disabled\n
-A: power/wakeup_abort_count=
+A: power/wakeup_abort_count=\n
-A: power/wakeup_active=
+A: power/wakeup_active=\n
-A: power/wakeup_active_count=
+A: power/wakeup_active_count=\n
-A: power/wakeup_count=
+A: power/wakeup_count=\n
-A: power/wakeup_expire_count=
+A: power/wakeup_expire_count=\n
-A: power/wakeup_last_time_ms=
+A: power/wakeup_last_time_ms=\n
-A: power/wakeup_max_time_ms=
+A: power/wakeup_max_time_ms=\n
-A: power/wakeup_total_time_ms=
+A: power/wakeup_total_time_ms=\n
-A: product=xHCI Host Controller
+A: product=xHCI Host Controller\n
-A: quirks=0x0
+A: quirks=0x0\n
-A: removable=unknown
+A: removable=unknown\n
-A: rx_lanes=1
+A: rx_lanes=1\n
-A: serial=0000:00:14.0
+A: serial=0000:00:14.0\n
-A: speed=480
+A: speed=480\n
-A: tx_lanes=1
+A: tx_lanes=1\n
-A: urbnum=490
+A: urbnum=490\n
-A: version= 2.00
+A: version= 2.00\n
 
 P: /devices/pci0000:00/0000:00:14.0
 E: DRIVER=xhci_hcd
@@ -180,46 +180,46 @@ 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 Point-LP USB 3.1 xHCI Controller
-A: ari_enabled=0
+A: ari_enabled=0\n
-A: broken_parity_status=0
+A: broken_parity_status=0\n
-A: class=0x0c0330
+A: class=0x0c0330\n
 H: config=8680ED9D060490023030030C00008000040030A10000000000000000000000000000000000000000000000003C10EF85000000007000000000000000FF010000FD0134808FC6FF8300000000000000007F6DDC0F00000000181C030400000000316000000000000000000000000000000180C2C1080000000000000000000000059087007802E0FE0000000000000000090014F01000400100000000C10A080000080E00001800008F40020000010000010000000000000000000000000000000000000000000000000000000000000001000000000000000000000000000000000000000000000000000000000000000000000000000000B50F300112000000
-A: consistent_dma_mask_bits=64
+A: consistent_dma_mask_bits=64\n
-A: d3cold_allowed=1
+A: d3cold_allowed=1\n
-A: dbc=disabled
+A: dbc=disabled\n
-A: device=0x9ded
+A: device=0x9ded\n
-A: dma_mask_bits=64
+A: dma_mask_bits=64\n
 L: driver=../../../bus/pci/drivers/xhci_hcd
-A: driver_override=(null)
+A: driver_override=(null)\n
-A: enable=1
+A: enable=1\n
-A: irq=124
+A: irq=124\n
-A: local_cpulist=0-3
+A: local_cpulist=0-3\n
-A: local_cpus=f
+A: local_cpus=f\n
-A: modalias=pci:v00008086d00009DEDsv0000103Csd000085EFbc0Csc03i30
+A: modalias=pci:v00008086d00009DEDsv0000103Csd000085EFbc0Csc03i30\n
-A: msi_bus=1
+A: msi_bus=1\n
-A: msi_irqs/124=msi
+A: msi_irqs/124=msi\n
-A: numa_node=-1
+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   32  128  1\nbuffer-32           0    0   32  0\nxHCI 1KB stream ctx arrays    0    0 1024  0\nxHCI 256 byte stream ctx arrays    0    0  256  0\nxHCI input/output contexts   11   12 2112 12\nxHCI ring segments   54   54 4096 54\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          9   32  128  1\nbuffer-32           0    0   32  0
+A: pools=poolinfo - 0.1\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          0   32  128  1\nbuffer-32           0    0   32  0\nxHCI 1KB stream ctx arrays    0    0 1024  0\nxHCI 256 byte stream ctx arrays    0    0  256  0\nxHCI input/output contexts   11   12 2112 12\nxHCI ring segments   54   54 4096 54\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          9   32  128  1\nbuffer-32           0    0   32  0\n
-A: power/async=enabled
+A: power/async=enabled\n
-A: power/control=auto
+A: power/control=auto\n
-A: power/runtime_active_kids=1
+A: power/runtime_active_kids=1\n
-A: power/runtime_active_time=74606194
+A: power/runtime_active_time=74606194\n
-A: power/runtime_enabled=enabled
+A: power/runtime_enabled=enabled\n
-A: power/runtime_status=active
+A: power/runtime_status=active\n
-A: power/runtime_suspended_time=0
+A: power/runtime_suspended_time=0\n
-A: power/runtime_usage=0
+A: power/runtime_usage=0\n
-A: power/wakeup=enabled
+A: power/wakeup=enabled\n
-A: power/wakeup_abort_count=0
+A: power/wakeup_abort_count=0\n
-A: power/wakeup_active=0
+A: power/wakeup_active=0\n
-A: power/wakeup_active_count=0
+A: power/wakeup_active_count=0\n
-A: power/wakeup_count=0
+A: power/wakeup_count=0\n
-A: power/wakeup_expire_count=0
+A: power/wakeup_expire_count=0\n
-A: power/wakeup_last_time_ms=0
+A: power/wakeup_last_time_ms=0\n
-A: power/wakeup_max_time_ms=0
+A: power/wakeup_max_time_ms=0\n
-A: power/wakeup_total_time_ms=0
+A: power/wakeup_total_time_ms=0\n
-A: resource=0x00000000a1300000 0x00000000a130ffff 0x0000000000140204\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000
+A: resource=0x00000000a1300000 0x00000000a130ffff 0x0000000000140204\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n0x0000000000000000 0x0000000000000000 0x0000000000000000\n
-A: revision=0x30
+A: revision=0x30\n
-A: subsystem_device=0x85ef
+A: subsystem_device=0x85ef\n
-A: subsystem_vendor=0x103c
+A: subsystem_vendor=0x103c\n
-A: vendor=0x8086
+A: vendor=0x8086\n
 

tests/goodixmoc/device

@@ -25,60 +25,60 @@ E: ID_VENDOR_FROM_DATABASE=Shenzhen Goodix Technology Co.,Ltd.
 E: ID_AUTOSUSPEND=1
 E: ID_PATH=pci-0000:00:14.0-usb-0:3
 E: ID_PATH_TAG=pci-0000_00_14_0-usb-0_3
-A: authorized=1
+A: authorized=1\n
-A: avoid_reset_quirk=0
+A: avoid_reset_quirk=0\n
-A: bConfigurationValue=1
+A: bConfigurationValue=1\n
-A: bDeviceClass=ef
+A: bDeviceClass=ef\n
-A: bDeviceProtocol=00
+A: bDeviceProtocol=00\n
-A: bDeviceSubClass=00
+A: bDeviceSubClass=00\n
-A: bMaxPacketSize0=64
+A: bMaxPacketSize0=64\n
-A: bMaxPower=100mA
+A: bMaxPower=100mA\n
-A: bNumConfigurations=1
+A: bNumConfigurations=1\n
-A: bNumInterfaces= 1
+A: bNumInterfaces= 1\n
-A: bcdDevice=0100
+A: bcdDevice=0100\n
-A: bmAttributes=a0
+A: bmAttributes=a0\n
-A: busnum=1
+A: busnum=1\n
-A: configuration=XXXX_MOC_B0
+A: configuration=XXXX_MOC_B0\n
 H: descriptors=12010002EF000040C627966400010102030109022000010103A0320904000002FF0000040705830240000007050102400000
-A: dev=189:52
+A: dev=189:52\n
-A: devnum=53
+A: devnum=53\n
-A: devpath=3
+A: devpath=3\n
 L: driver=../../../../../bus/usb/drivers/usb
 L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:1c/device:1d/device:20
-A: idProduct=6496
+A: idProduct=6496\n
-A: idVendor=27c6
+A: idVendor=27c6\n
-A: ltm_capable=no
+A: ltm_capable=no\n
-A: manufacturer=Goodix Technology Co., Ltd.
+A: manufacturer=Goodix Technology Co., Ltd.\n
-A: maxchild=0
+A: maxchild=0\n
 L: port=../1-0:1.0/usb1-port3
-A: power/active_duration=29262
+A: power/active_duration=29262\n
-A: power/autosuspend=2
+A: power/autosuspend=2\n
-A: power/autosuspend_delay_ms=2000
+A: power/autosuspend_delay_ms=2000\n
-A: power/connected_duration=57399
+A: power/connected_duration=57399\n
-A: power/control=auto
+A: power/control=auto\n
-A: power/level=auto
+A: power/level=auto\n
-A: power/persist=1
+A: power/persist=1\n
-A: power/runtime_active_time=29308
+A: power/runtime_active_time=29308\n
-A: power/runtime_status=active
+A: power/runtime_status=active\n
-A: power/runtime_suspended_time=27850
+A: power/runtime_suspended_time=27850\n
-A: power/wakeup=disabled
+A: power/wakeup=disabled\n
-A: power/wakeup_abort_count=
+A: power/wakeup_abort_count=\n
-A: power/wakeup_active=
+A: power/wakeup_active=\n
-A: power/wakeup_active_count=
+A: power/wakeup_active_count=\n
-A: power/wakeup_count=
+A: power/wakeup_count=\n
-A: power/wakeup_expire_count=
+A: power/wakeup_expire_count=\n
-A: power/wakeup_last_time_ms=
+A: power/wakeup_last_time_ms=\n
-A: power/wakeup_max_time_ms=
+A: power/wakeup_max_time_ms=\n
-A: power/wakeup_total_time_ms=
+A: power/wakeup_total_time_ms=\n
-A: product=Goodix USB2.0 MISC
+A: product=Goodix USB2.0 MISC\n
-A: quirks=0x0
+A: quirks=0x0\n
-A: removable=removable
+A: removable=removable\n
-A: rx_lanes=1
+A: rx_lanes=1\n
-A: serial=XXXX_MOC_B0
+A: serial=XXXX_MOC_B0\n
-A: speed=12
+A: speed=12\n
-A: tx_lanes=1
+A: tx_lanes=1\n
-A: urbnum=394
+A: urbnum=394\n
-A: version= 2.00
+A: version= 2.00\n
 
 P: /devices/pci0000:00/0000:00:14.0/usb1
 N: bus/usb/001/001=12010002090001406B1D020013050302010109021900010100E0000904000001090000000705810304000C
@@ -111,66 +111,66 @@ 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
+A: authorized=1\n
-A: authorized_default=1
+A: authorized_default=1\n
-A: avoid_reset_quirk=0
+A: avoid_reset_quirk=0\n
-A: bConfigurationValue=1
+A: bConfigurationValue=1\n
-A: bDeviceClass=09
+A: bDeviceClass=09\n
-A: bDeviceProtocol=01
+A: bDeviceProtocol=01\n
-A: bDeviceSubClass=00
+A: bDeviceSubClass=00\n
-A: bMaxPacketSize0=64
+A: bMaxPacketSize0=64\n
-A: bMaxPower=0mA
+A: bMaxPower=0mA\n
-A: bNumConfigurations=1
+A: bNumConfigurations=1\n
-A: bNumInterfaces= 1
+A: bNumInterfaces= 1\n
-A: bcdDevice=0513
+A: bcdDevice=0513\n
-A: bmAttributes=e0
+A: bmAttributes=e0\n
-A: busnum=1
+A: busnum=1\n
-A: configuration=
+A: configuration=\n
 H: descriptors=12010002090001406B1D020013050302010109021900010100E0000904000001090000000705810304000C
-A: dev=189:0
+A: dev=189:0\n
-A: devnum=1
+A: devnum=1\n
-A: devpath=0
+A: devpath=0\n
 L: driver=../../../../bus/usb/drivers/usb
 L: firmware_node=../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:1c/device:1d
-A: idProduct=0002
+A: idProduct=0002\n
-A: idVendor=1d6b
+A: idVendor=1d6b\n
-A: interface_authorized_default=1
+A: interface_authorized_default=1\n
-A: ltm_capable=no
+A: ltm_capable=no\n
-A: manufacturer=Linux 5.13.15-200.fc34.x86_64 xhci-hcd
+A: manufacturer=Linux 5.13.15-200.fc34.x86_64 xhci-hcd\n
-A: maxchild=12
+A: maxchild=12\n
-A: power/active_duration=219578717
+A: power/active_duration=219578717\n
-A: power/autosuspend=0
+A: power/autosuspend=0\n
-A: power/autosuspend_delay_ms=0
+A: power/autosuspend_delay_ms=0\n
-A: power/connected_duration=219649620
+A: power/connected_duration=219649620\n
-A: power/control=auto
+A: power/control=auto\n
-A: power/level=auto
+A: power/level=auto\n
-A: power/runtime_active_time=219589127
+A: power/runtime_active_time=219589127\n
-A: power/runtime_status=active
+A: power/runtime_status=active\n
-A: power/runtime_suspended_time=0
+A: power/runtime_suspended_time=0\n
-A: power/wakeup=disabled
+A: power/wakeup=disabled\n
-A: power/wakeup_abort_count=
+A: power/wakeup_abort_count=\n
-A: power/wakeup_active=
+A: power/wakeup_active=\n
-A: power/wakeup_active_count=
+A: power/wakeup_active_count=\n
-A: power/wakeup_count=
+A: power/wakeup_count=\n
-A: power/wakeup_expire_count=
+A: power/wakeup_expire_count=\n
-A: power/wakeup_last_time_ms=
+A: power/wakeup_last_time_ms=\n
-A: power/wakeup_max_time_ms=
+A: power/wakeup_max_time_ms=\n
-A: power/wakeup_total_time_ms=
+A: power/wakeup_total_time_ms=\n
-A: product=xHCI Host Controller
+A: product=xHCI Host Controller\n
-A: quirks=0x0
+A: quirks=0x0\n
-A: removable=unknown
+A: removable=unknown\n
-A: rx_lanes=1
+A: rx_lanes=1\n
-A: serial=0000:00:14.0
+A: serial=0000:00:14.0\n
-A: speed=480
+A: speed=480\n
-A: tx_lanes=1
+A: tx_lanes=1\n
-A: urbnum=4325
+A: urbnum=4325\n
-A: version= 2.00
+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:9DED
-E: PCI_SUBSYS_ID=17AA:2292
+E: PCI_SUBSYS_ID=17AA:2292\n
 E: PCI_SLOT_NAME=0000:00:14.0
 E: MODALIAS=pci:v00008086d00009DEDsv000017AAsd00002292bc0Csc03i30
 E: SUBSYSTEM=pci
@@ -180,44 +180,44 @@ E: ID_PCI_INTERFACE_FROM_DATABASE=XHCI
 E: ID_VENDOR_FROM_DATABASE=Intel Corporation
 E: ID_AUTOSUSPEND=1
 E: ID_MODEL_FROM_DATABASE=Cannon Point-LP USB 3.1 xHCI Controller
-A: ari_enabled=0
+A: ari_enabled=0\n
-A: broken_parity_status=0
+A: broken_parity_status=0\n
-A: class=0x0c0330
+A: class=0x0c0330\n
 H: config=8680ED9D060490021130030C00008000040022EA000000000000000000000000000000000000000000000000AA179222000000007000000000000000FF010000FD0134808FC6FF8300000000000000007F6DDC0F000000004C084B0100000000316000000000000000000000000000000180C2C1080000000000000000000000059087001803E0FE0000000000000000090014F01000400100000000C10A080000080E00001800008F40020000010000000000000000000008000000040000000000000000000000000000000000000000000000000000000800000004000000000000000000000000000000000000000000000000000000B50F320112000000
-A: consistent_dma_mask_bits=64
+A: consistent_dma_mask_bits=64\n
-A: d3cold_allowed=1
+A: d3cold_allowed=1\n
-A: dbc=disabled
+A: dbc=disabled\n
-A: device=0x9ded
+A: device=0x9ded\n
-A: dma_mask_bits=64
+A: dma_mask_bits=64\n
 L: driver=../../../bus/pci/drivers/xhci_hcd
-A: driver_override=(null)
+A: driver_override=(null)\n
-A: enable=1
+A: enable=1\n
 L: firmware_node=../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:1c
-A: irq=128
+A: irq=128\n
-A: local_cpulist=0-7
+A: local_cpulist=0-7\n
-A: local_cpus=ff
+A: local_cpus=ff\n
-A: modalias=pci:v00008086d00009DEDsv000017AAsd00002292bc0Csc03i30
+A: modalias=pci:v00008086d00009DEDsv000017AAsd00002292bc0Csc03i30\n
-A: msi_bus=1
+A: msi_bus=1\n
-A: msi_irqs/128=msi
+A: msi_irqs/128=msi\n
-A: numa_node=-1
+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   11   12 2112 12\nxHCI ring segments   46   50 4096 50\nbuffer-2048         0    0 2048  0\nbuffer-512          0    0  512  0\nbuffer-128          6   32  128  1\nbuffer-32           0    0   32  0
+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   11   12 2112 12\nxHCI ring segments   46   50 4096 50\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/control=on
+A: power/control=on\n
-A: power/runtime_active_time=219589302
+A: power/runtime_active_time=219589302\n
-A: power/runtime_status=active
+A: power/runtime_status=active\n
-A: power/runtime_suspended_time=0
+A: power/runtime_suspended_time=0\n
-A: power/wakeup=enabled
+A: power/wakeup=enabled\n
-A: power/wakeup_abort_count=0
+A: power/wakeup_abort_count=0\n
-A: power/wakeup_active=0
+A: power/wakeup_active=0\n
-A: power/wakeup_active_count=0
+A: power/wakeup_active_count=0\n
-A: power/wakeup_count=0
+A: power/wakeup_count=0\n
-A: power/wakeup_expire_count=0
+A: power/wakeup_expire_count=0\n
-A: power/wakeup_last_time_ms=0
+A: power/wakeup_last_time_ms=0\n
-A: power/wakeup_max_time_ms=0
+A: power/wakeup_max_time_ms=0\n
-A: power/wakeup_total_time_ms=0
+A: power/wakeup_total_time_ms=0\n
-A: power_state=D0
+A: power_state=D0\n
-A: resource=0x00000000ea220000 0x00000000ea22ffff 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
+A: resource=0x00000000ea220000 0x00000000ea22ffff 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=0x11
+A: revision=0x11\n
-A: subsystem_device=0x2292
+A: subsystem_device=0x2292\n
-A: subsystem_vendor=0x17aa
+A: subsystem_vendor=0x17aa\n
-A: vendor=0x8086
+A: vendor=0x8086\n
 

tests/test-fpi-device.c

@@ -27,6 +27,7 @@
 #include "fpi-compat.h"
 #include "fpi-log.h"
 #include "test-device-fake.h"
+#include "fp-print-private.h"
 
 /* Utility functions */
 
@@ -142,6 +143,16 @@ make_fake_print (FpDevice *device,
   return enrolled_print;
 }
 
+static FpPrint *
+make_fake_nbis_print (FpDevice *device)
+{
+  FpPrint *enrolled_print = fp_print_new (device);
+
+  fpi_print_set_type (enrolled_print, FPI_PRINT_NBIS);
+
+  return enrolled_print;
+}
+
 static FpPrint *
 make_fake_print_reffed (FpDevice *device,
                         GVariant *print_data)
@@ -1045,7 +1056,6 @@ test_driver_enroll_error_no_print (void)
   out_print =
     fp_device_enroll_sync (device, fp_print_new (device), NULL, NULL, NULL, &error);
 
-  g_test_assert_expected_messages ();
   g_assert (fake_dev->last_called_function == dev_class->enroll);
   g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_GENERAL);
   g_assert_null (out_print);
@@ -1053,6 +1063,111 @@ test_driver_enroll_error_no_print (void)
   g_clear_error (&error);
 }
 
+static void
+test_driver_enroll_update_nbis (void)
+{
+  g_autoptr(GError) error = NULL;
+  g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
+  g_autoptr(FpAutoCloseDevice) device = NULL;
+  g_autoptr(FpPrint) template_print = NULL;
+  FpiDeviceFake *fake_dev = NULL;
+  FpPrint *out_print = NULL;
+
+  dev_class->features |= FP_DEVICE_FEATURE_UPDATE_PRINT;
+  device = auto_close_fake_device_new ();
+  fake_dev = FPI_DEVICE_FAKE (device);
+
+  template_print = make_fake_nbis_print (device);
+  fake_dev->ret_print = template_print;
+
+  out_print =
+    fp_device_enroll_sync (device, template_print, NULL, NULL, NULL, &error);
+
+  g_assert (fake_dev->last_called_function == dev_class->enroll);
+  g_assert (fake_dev->action_data == template_print);
+
+  g_assert_no_error (error);
+  g_assert (out_print == template_print);
+}
+
+static void
+test_driver_enroll_update_nbis_wrong_device (void)
+{
+  g_autoptr(GError) error = NULL;
+  g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
+  g_autoptr(FpAutoCloseDevice) device = NULL;
+  g_autoptr(FpPrint) template_print = NULL;
+  FpiDeviceFake *fake_dev = NULL;
+  FpPrint *out_print = NULL;
+
+  dev_class->features |= FP_DEVICE_FEATURE_UPDATE_PRINT;
+
+  device = auto_close_fake_device_new ();
+  fake_dev = FPI_DEVICE_FAKE (device);
+
+  template_print = make_fake_nbis_print (device);
+  template_print->device_id = g_strdup ("wrong_device");
+  fake_dev->ret_print = template_print;
+
+  out_print =
+    fp_device_enroll_sync (device, template_print, NULL, NULL, NULL, &error);
+
+  g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_DATA_INVALID);
+  g_assert (out_print == NULL);
+}
+
+static void
+test_driver_enroll_update_nbis_wrong_driver (void)
+{
+  g_autoptr(GError) error = NULL;
+  g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
+  g_autoptr(FpAutoCloseDevice) device = NULL;
+  g_autoptr(FpPrint) template_print = NULL;
+  FpiDeviceFake *fake_dev = NULL;
+  FpPrint *out_print = NULL;
+
+  dev_class->features |= FP_DEVICE_FEATURE_UPDATE_PRINT;
+
+  device = auto_close_fake_device_new ();
+  fake_dev = FPI_DEVICE_FAKE (device);
+
+  template_print = make_fake_nbis_print (device);
+  template_print->driver = g_strdup ("wrong_driver");
+  fake_dev->ret_print = template_print;
+
+  out_print =
+    fp_device_enroll_sync (device, template_print, NULL, NULL, NULL, &error);
+
+  g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_DATA_INVALID);
+  g_assert (out_print == NULL);
+}
+
+static void
+test_driver_enroll_update_nbis_missing_feature (void)
+{
+  g_autoptr(GError) error = NULL;
+  g_autoptr(FpAutoResetClass) dev_class = auto_reset_device_class ();
+  g_autoptr(FpAutoCloseDevice) device = NULL;
+  g_autoptr(FpPrint) template_print = NULL;
+  FpiDeviceFake *fake_dev = NULL;
+  FpPrint *out_print = NULL;
+
+  device = auto_close_fake_device_new ();
+  fake_dev = FPI_DEVICE_FAKE (device);
+
+  template_print = make_fake_nbis_print (device);
+  fake_dev->ret_print = template_print;
+
+  out_print =
+    fp_device_enroll_sync (device, template_print, NULL, NULL, NULL, &error);
+
+  g_assert (fake_dev->last_called_function == dev_class->open);
+  g_assert (fake_dev->action_data == NULL);
+
+  g_assert_error (error, FP_DEVICE_ERROR, FP_DEVICE_ERROR_DATA_INVALID);
+  g_assert (out_print == NULL);
+}
+
 typedef struct
 {
   gint     completed_stages;
@@ -3306,6 +3421,13 @@ main (int argc, char *argv[])
   g_test_add_func ("/driver/enroll/error", test_driver_enroll_error);
   g_test_add_func ("/driver/enroll/error/no_print", test_driver_enroll_error_no_print);
   g_test_add_func ("/driver/enroll/progress", test_driver_enroll_progress);
+  g_test_add_func ("/driver/enroll/update_nbis", test_driver_enroll_update_nbis);
+  g_test_add_func ("/driver/enroll/update_nbis_wrong_device",
+                   test_driver_enroll_update_nbis_wrong_device);
+  g_test_add_func ("/driver/enroll/update_nbis_wrong_driver",
+                   test_driver_enroll_update_nbis_wrong_driver);
+  g_test_add_func ("/driver/enroll/update_nbis_missing_feature",
+                   test_driver_enroll_update_nbis_missing_feature);
   g_test_add_func ("/driver/verify", test_driver_verify);
   g_test_add_func ("/driver/verify/fail", test_driver_verify_fail);
   g_test_add_func ("/driver/verify/retry", test_driver_verify_retry);

tests/virtual-image.py

@@ -136,6 +136,7 @@ class VirtualImage(unittest.TestCase):
         self.assertTrue(self.dev.has_feature(FPrint.DeviceFeature.CAPTURE))
         self.assertTrue(self.dev.has_feature(FPrint.DeviceFeature.IDENTIFY))
         self.assertTrue(self.dev.has_feature(FPrint.DeviceFeature.VERIFY))
+        self.assertTrue(self.dev.has_feature(FPrint.DeviceFeature.UPDATE_PRINT))
         self.assertFalse(self.dev.has_feature(FPrint.DeviceFeature.DUPLICATES_CHECK))
         self.assertFalse(self.dev.has_feature(FPrint.DeviceFeature.STORAGE))
         self.assertFalse(self.dev.has_feature(FPrint.DeviceFeature.STORAGE_LIST))
@@ -144,7 +145,8 @@ class VirtualImage(unittest.TestCase):
         self.assertEqual(self.dev.get_features(),
                          FPrint.DeviceFeature.CAPTURE |
                          FPrint.DeviceFeature.IDENTIFY |
-                         FPrint.DeviceFeature.VERIFY)
+                         FPrint.DeviceFeature.VERIFY |
+                         FPrint.DeviceFeature.UPDATE_PRINT)
 
     def test_capture_prevents_close(self):
         cancel = Gio.Cancellable()
@@ -167,7 +169,7 @@ class VirtualImage(unittest.TestCase):
         while not self._cancelled:
             ctx.iteration(True)
 
-    def enroll_print(self, image):
+    def enroll_print(self, image, template=None):
         self._step = 0
         self._enrolled = None
 
@@ -181,14 +183,15 @@ class VirtualImage(unittest.TestCase):
             self.assertEqual(self.dev.get_finger_status(), FPrint.FingerStatusFlags.NONE)
             self._enrolled = fp
 
-        template = FPrint.Print.new(self.dev)
+        if template is None:
-        template.props.finger = FPrint.Finger.LEFT_THUMB
+            template = FPrint.Print.new(self.dev)
-        template.props.username = "testuser"
+            template.props.finger = FPrint.Finger.LEFT_THUMB
-        template.props.description = "test print"
+            template.props.username = "testuser"
-        datetime = GLib.DateTime.new_now_local()
+            template.props.description = "test print"
-        date = GLib.Date()
+            datetime = GLib.DateTime.new_now_local()
-        date.set_dmy(*datetime.get_ymd()[::-1])
+            date = GLib.Date()
-        template.props.enroll_date = date
+            date.set_dmy(*datetime.get_ymd()[::-1])
+            template.props.enroll_date = date
         self.assertEqual(self.dev.get_finger_status(), FPrint.FingerStatusFlags.NONE)
         self.dev.enroll(template, None, progress_cb, tuple(), done_cb)
 
@@ -264,6 +267,28 @@ class VirtualImage(unittest.TestCase):
             ctx.iteration(True)
         assert(not self._verify_match)
 
+        # Test fingerprint updates
+        # Enroll a second print
+        fp_whorl_tended_arch = self.enroll_print('tented_arch', fp_whorl)
+
+        # Make sure the first print verifies successfully after the update
+        self._verify_match = None
+        self._verify_fp = None
+        self.dev.verify(fp_whorl_tended_arch, callback=verify_cb)
+        self.send_image('whorl')
+        while self._verify_match is None:
+            ctx.iteration(True)
+        assert(self._verify_match)
+
+        # Make sure the second print verifies successfully after the update
+        self._verify_match = None
+        self._verify_fp = None
+        self.dev.verify(fp_whorl_tended_arch, callback=verify_cb)
+        self.send_image('tented_arch')
+        while self._verify_match is None:
+            ctx.iteration(True)
+        assert(self._verify_match)
+
         # Test verify error cases
         self._verify_fp = None
         self._verify_error = None