Release 1.94.10

Tested working on an HP x360 1040 G8

Reverts: 0edae7b641

.gitlab-ci.yml

@@ -4,7 +4,7 @@ include:
   - project: 'freedesktop/ci-templates'
     ref: master
     file: '/templates/fedora.yml'
-  - remote: 'https://gitlab.gnome.org/GNOME/citemplates/-/raw/master/flatpak/flatpak_ci_initiative.yml'
+  - remote: 'https://gitlab.gnome.org/GNOME/citemplates/-/raw/71e636e012ae0ab04c5e0fe40ca73ada91ae6bde/flatpak/flatpak_ci_initiative.yml'
 
 default:
   # Auto-retry jobs in case of infra failures
@@ -19,7 +19,7 @@ default:
 variables:
   extends: .libfprint_common_variables
   FDO_DISTRIBUTION_TAG: $LIBFPRINT_IMAGE_TAG
-  FDO_DISTRIBUTION_VERSION: 41
+  FDO_DISTRIBUTION_VERSION: rawhide
   FDO_UPSTREAM_REPO: "libfprint/$CI_PROJECT_NAME"
   FEDORA_IMAGE: "$CI_REGISTRY/libfprint/$CI_PROJECT_NAME/fedora/$FDO_DISTRIBUTION_VERSION:$FDO_DISTRIBUTION_TAG"
   LAST_ABI_BREAK: "056ea541ddc97f5806cffbd99a12dc87e4da3546"
@@ -88,7 +88,7 @@ test:
   script:
     - meson setup _build --werror -Ddrivers=all -Db_coverage=true
     - meson test -C _build --print-errorlogs --no-stdsplit --timeout-multiplier 3
-    - ninja -C _build coverage
+    - ninja -C _build coverage || true
     - cat _build/meson-logs/coverage.txt || true
   artifacts:
     reports:
@@ -293,4 +293,4 @@ pages:
     paths:
       - public
   rules:
-    - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH
+    - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH && $CI_PIPELINE_SOURCE == "push"

NEWS

@@ -1,6 +1,22 @@
 This file lists notable changes in each release. For the full history of all
 changes, see ChangeLog.
 
+2026-02-10: v1.94.10 release
+
+Highlights:
+  * synaptics: Add USB reset in probe to recover stall condition
+  * synaptics: New PIDs 0x0169, 0x019F, 0x00E9, 0x01A0, 0x0109, 0x010A
+  * goodixmoc: New PID 0x66A9
+  * goodixmoc: Fix crash in exit callback handler
+  * fpcmoc: New PID 0xA306
+  * fpcmoc: Fix interrupt cancellable leak
+  * elanmoc: New PIDs 0x0CA7, 0x0CA8, 0x0CB0
+  * egismoc: New PIDs 0x0584, 0x0588
+  * focaltech_moc: New PIDs 0xA27A, 0x1579
+  * realtek: New PID 0xFA03
+  * fp-device: Clarify getter for open property
+  * libfprint: Use fatal-warnings on g-i-scanner
+
 2025-02-20: v1.94.9 release
 
 Highlights:

data/autosuspend.hwdb

@@ -80,8 +80,10 @@ usb:v1C7Ap0571*
 # Supported by libfprint driver egismoc
 usb:v1C7Ap0582*
 usb:v1C7Ap0583*
+usb:v1C7Ap0584*
 usb:v1C7Ap0586*
 usb:v1C7Ap0587*
+usb:v1C7Ap0588*
 usb:v1C7Ap05A1*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
@@ -163,6 +165,9 @@ usb:v04F3p0C99*
 usb:v04F3p0C9D*
 usb:v04F3p0C9F*
 usb:v04F3p0CA3*
+usb:v04F3p0CA7*
+usb:v04F3p0CA8*
+usb:v04F3p0CB0*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
@@ -174,16 +179,19 @@ usb:v1C7Ap0603*
 # Supported by libfprint driver focaltech_moc
 usb:v2808p9E48*
 usb:v2808pD979*
+usb:v2808pA27A*
 usb:v2808pA959*
 usb:v2808pA99A*
 usb:v2808pA57A*
 usb:v2808pA78A*
+usb:v2808p1579*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
 # Supported by libfprint driver fpcmoc
 usb:v10A5pFFE0*
 usb:v10A5pA305*
+usb:v10A5pA306*
 usb:v10A5pDA04*
 usb:v10A5pD805*
 usb:v10A5pD205*
@@ -226,6 +234,7 @@ usb:v27C6p659C*
 usb:v27C6p6A94*
 usb:v27C6p6512*
 usb:v27C6p689A*
+usb:v27C6p66A9*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
@@ -237,6 +246,7 @@ usb:v298Dp1010*
 # Supported by libfprint driver realtek
 usb:v0BDAp5813*
 usb:v0BDAp5816*
+usb:v2541pFA03*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
@@ -246,6 +256,7 @@ usb:v06CBp00C2*
 usb:v06CBp00C4*
 usb:v06CBp00C6*
 usb:v06CBp00DF*
+usb:v06CBp00E9*
 usb:v06CBp00F0*
 usb:v06CBp00F9*
 usb:v06CBp00FC*
@@ -255,16 +266,21 @@ usb:v06CBp0104*
 usb:v06CBp0106*
 usb:v06CBp0107*
 usb:v06CBp0108*
+usb:v06CBp0109*
+usb:v06CBp010A*
 usb:v06CBp0123*
 usb:v06CBp0124*
 usb:v06CBp0126*
 usb:v06CBp0129*
 usb:v06CBp015F*
 usb:v06CBp0168*
+usb:v06CBp0169*
 usb:v06CBp016C*
 usb:v06CBp0173*
 usb:v06CBp0174*
 usb:v06CBp019D*
+usb:v06CBp019F*
+usb:v06CBp01A0*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
@@ -380,7 +396,6 @@ usb:v06CBp00DA*
 usb:v06CBp00DC*
 usb:v06CBp00E4*
 usb:v06CBp00E7*
-usb:v06CBp00E9*
 usb:v06CBp00FD*
 usb:v06CBp00FF*
 usb:v0A5Cp5801*
@@ -424,7 +439,6 @@ usb:v16D1p1027*
 usb:v1C7Ap0300*
 usb:v1C7Ap0575*
 usb:v1C7Ap0576*
-usb:v1C7Ap0584*
 usb:v1C7Ap0577*
 usb:v1C7Ap057E*
 usb:v2541p0236*

gcovr.cfg

@@ -0,0 +1 @@
+gcov-ignore-parse-errors = suspicious_hits.warn

libfprint/drivers/egismoc/egismoc.c

@@ -52,8 +52,10 @@ G_DEFINE_TYPE (FpiDeviceEgisMoc, fpi_device_egismoc, FP_TYPE_DEVICE);
 static const FpIdEntry egismoc_id_table[] = {
   { .vid = 0x1c7a, .pid = 0x0582, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 },
   { .vid = 0x1c7a, .pid = 0x0583, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 },
+  { .vid = 0x1c7a, .pid = 0x0584, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 | EGISMOC_DRIVER_MAX_ENROLL_STAGES_20 },
   { .vid = 0x1c7a, .pid = 0x0586, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 | EGISMOC_DRIVER_MAX_ENROLL_STAGES_20 },
   { .vid = 0x1c7a, .pid = 0x0587, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 | EGISMOC_DRIVER_MAX_ENROLL_STAGES_20 },
+  { .vid = 0x1c7a, .pid = 0x0588, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 | EGISMOC_DRIVER_MAX_ENROLL_STAGES_20 },
   { .vid = 0x1c7a, .pid = 0x05a1, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE2 },
   { .vid = 0,      .pid = 0,      .driver_data = 0 }
 };

libfprint/drivers/elanmoc/elanmoc.c

@@ -36,6 +36,9 @@ static const FpIdEntry id_table[] = {
   { .vid = 0x04f3,  .pid = 0x0c9d,  },
   { .vid = 0x04f3,  .pid = 0x0c9f,  },
   { .vid = 0x04f3,  .pid = 0x0ca3,  },
+  { .vid = 0x04f3,  .pid = 0x0ca7,  },
+  { .vid = 0x04f3,  .pid = 0x0ca8,  },
+  { .vid = 0x04f3,  .pid = 0x0cb0,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 
@@ -132,10 +135,10 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
 }
 
 typedef enum {
-  FP_CMD_SEND = 0,
-  FP_CMD_GET,
-  FP_CMD_NUM_STATES,
-} FpCmdState;
+  ELAN_MOC_CMD_SEND = 0,
+  ELAN_MOC_CMD_GET,
+  ELAN_MOC_CMD_NUM_STATES,
+} ElanMocCmdState;
 
 static void
 fp_cmd_run_state (FpiSsm   *ssm,
@@ -146,7 +149,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FP_CMD_SEND:
+    case ELAN_MOC_CMD_SEND:
       if (self->cmd_transfer)
         {
           self->cmd_transfer->ssm = ssm;
@@ -162,7 +165,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
         }
       break;
 
-    case FP_CMD_GET:
+    case ELAN_MOC_CMD_GET:
       if (self->cmd_len_in == 0)
         {
           CommandData *data = fpi_ssm_get_data (ssm);
@@ -229,7 +232,7 @@ elanmoc_get_cmd (FpDevice *device, guint8 *buffer_out,
 
   self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
                                fp_cmd_run_state,
-                               FP_CMD_NUM_STATES);
+                               ELAN_MOC_CMD_NUM_STATES);
 
   fpi_ssm_set_data (self->cmd_ssm, data, (GDestroyNotify) fp_cmd_ssm_done_data_free);
 

libfprint/drivers/focaltech_moc/focaltech_moc.c

@@ -29,10 +29,12 @@ G_DEFINE_TYPE (FpiDeviceFocaltechMoc, fpi_device_focaltech_moc, FP_TYPE_DEVICE)
 static const FpIdEntry id_table[] = {
   { .vid = 0x2808,  .pid = 0x9e48,  },
   { .vid = 0x2808,  .pid = 0xd979,  },
+  { .vid = 0x2808,  .pid = 0xa27a,  },
   { .vid = 0x2808,  .pid = 0xa959,  },
   { .vid = 0x2808,  .pid = 0xa99a,  },
   { .vid = 0x2808,  .pid = 0xa57a,  },
   { .vid = 0x2808,  .pid = 0xa78a,  },
+  { .vid = 0x2808,  .pid = 0x1579,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 
@@ -235,10 +237,10 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
 }
 
 typedef enum {
-  FP_CMD_SEND = 0,
-  FP_CMD_GET,
-  FP_CMD_NUM_STATES,
-} FpCmdState;
+  FOCALTECH_CMD_SEND = 0,
+  FOCALTECH_CMD_GET,
+  FOCALTECH_CMD_NUM_STATES,
+} FocaltechCmdState;
 
 static void
 fp_cmd_run_state (FpiSsm   *ssm,
@@ -249,7 +251,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FP_CMD_SEND:
+    case FOCALTECH_CMD_SEND:
       if (self->cmd_transfer)
         {
           self->cmd_transfer->ssm = ssm;
@@ -266,7 +268,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
 
       break;
 
-    case FP_CMD_GET:
+    case FOCALTECH_CMD_GET:
       if (self->cmd_len_in == 0)
         {
           CommandData *data = fpi_ssm_get_data (ssm);
@@ -334,7 +336,7 @@ focaltech_moc_get_cmd (FpDevice *device, guint8 *buffer_out,
 
   self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
                                fp_cmd_run_state,
-                               FP_CMD_NUM_STATES);
+                               FOCALTECH_CMD_NUM_STATES);
 
   fpi_ssm_set_data (self->cmd_ssm, data, (GDestroyNotify) fp_cmd_ssm_done_data_free);
 

libfprint/drivers/fpcmoc/fpc.c

@@ -65,6 +65,7 @@ typedef struct
 static const FpIdEntry id_table[] = {
   { .vid = 0x10A5,  .pid = 0xFFE0,  },
   { .vid = 0x10A5,  .pid = 0xA305,  },
+  { .vid = 0x10A5,  .pid = 0xA306,  },
   { .vid = 0x10A5,  .pid = 0xDA04,  },
   { .vid = 0x10A5,  .pid = 0xD805,  },
   { .vid = 0x10A5,  .pid = 0xD205,  },
@@ -85,7 +86,7 @@ fpc_suspend_resume_cb (FpiUsbTransfer *transfer,
 
   fp_dbg ("%s current ssm state: %d", G_STRFUNC, ssm_state);
 
-  if (ssm_state == FP_CMD_SUSPENDED)
+  if (ssm_state == FPC_CMD_SUSPENDED)
     {
       if (error)
         fpi_ssm_mark_failed (transfer->ssm, error);
@@ -93,12 +94,12 @@ fpc_suspend_resume_cb (FpiUsbTransfer *transfer,
       fpi_device_suspend_complete (device, error);
       /* The resume handler continues to the next state! */
     }
-  else if (ssm_state == FP_CMD_RESUME)
+  else if (ssm_state == FPC_CMD_RESUME)
     {
       if (error)
         fpi_ssm_mark_failed (transfer->ssm, error);
       else
-        fpi_ssm_jump_to_state (transfer->ssm, FP_CMD_GET_DATA);
+        fpi_ssm_jump_to_state (transfer->ssm, FPC_CMD_GET_DATA);
 
       fpi_device_resume_complete (device, error);
     }
@@ -117,7 +118,7 @@ fpc_cmd_receive_cb (FpiUsbTransfer *transfer,
   if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) && (self->cmd_suspended))
     {
       g_error_free (error);
-      fpi_ssm_jump_to_state (transfer->ssm, FP_CMD_SUSPENDED);
+      fpi_ssm_jump_to_state (transfer->ssm, FPC_CMD_SUSPENDED);
       return;
     }
 
@@ -138,7 +139,7 @@ fpc_cmd_receive_cb (FpiUsbTransfer *transfer,
   fp_dbg ("%s current ssm request: %d state: %d", G_STRFUNC, data->request, ssm_state);
 
   /* clean cmd_ssm except capture command for suspend/resume case */
-  if (ssm_state != FP_CMD_SEND || data->request != FPC_CMD_ARM)
+  if (ssm_state != FPC_CMD_SEND || data->request != FPC_CMD_ARM)
     self->cmd_ssm = NULL;
 
   if (data->cmdtype == FPC_CMDTYPE_TO_DEVICE)
@@ -152,13 +153,13 @@ fpc_cmd_receive_cb (FpiUsbTransfer *transfer,
     }
   else if (data->cmdtype == FPC_CMDTYPE_TO_DEVICE_EVTDATA)
     {
-      if (ssm_state == FP_CMD_SEND)
+      if (ssm_state == FPC_CMD_SEND)
         {
           fpi_ssm_next_state (transfer->ssm);
           return;
         }
 
-      if (ssm_state == FP_CMD_GET_DATA)
+      if (ssm_state == FPC_CMD_GET_DATA)
         {
           fpc_cmd_response_t evt_data = {0};
           fp_dbg ("%s recv evt data length: %ld", G_STRFUNC, transfer->actual_length);
@@ -291,11 +292,11 @@ fpc_cmd_run_state (FpiSsm   *ssm,
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FP_CMD_SEND:
+    case FPC_CMD_SEND:
       fpc_send_ctrl_cmd (dev);
       break;
 
-    case FP_CMD_GET_DATA:
+    case FPC_CMD_GET_DATA:
       transfer = fpi_usb_transfer_new (dev);
       transfer->ssm = ssm;
       fpi_usb_transfer_fill_bulk (transfer, EP_IN, EP_IN_MAX_BUF_SIZE);
@@ -306,7 +307,7 @@ fpc_cmd_run_state (FpiSsm   *ssm,
                                fpi_ssm_get_data (ssm));
       break;
 
-    case FP_CMD_SUSPENDED:
+    case FPC_CMD_SUSPENDED:
       transfer = fpi_usb_transfer_new (dev);
       transfer->ssm = ssm;
       fpi_usb_transfer_fill_control (transfer,
@@ -322,7 +323,7 @@ fpc_cmd_run_state (FpiSsm   *ssm,
                                fpc_suspend_resume_cb, NULL);
       break;
 
-    case FP_CMD_RESUME:
+    case FPC_CMD_RESUME:
       transfer = fpi_usb_transfer_new (dev);
       transfer->ssm = ssm;
       fpi_usb_transfer_fill_control (transfer,
@@ -353,21 +354,22 @@ fpc_sensor_cmd (FpiDeviceFpcMoc *self,
 
   data = g_memdup2 (cmd_data, sizeof (CommandData));
 
+  g_clear_object (&self->interrupt_cancellable);
+
   if (wait_data_delay)
     {
       self->cmd_data_timeout = 0;
-      g_set_object (&self->interrupt_cancellable, g_cancellable_new ());
+      self->interrupt_cancellable = g_cancellable_new ();
     }
   else
     {
       self->cmd_data_timeout = DATA_TIMEOUT;
-      g_clear_object (&self->interrupt_cancellable);
     }
 
   g_assert (self->cmd_ssm == NULL);
   self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
                                fpc_cmd_run_state,
-                               FP_CMD_NUM_STATES);
+                               FPC_CMD_NUM_STATES);
 
   fpi_ssm_set_data (self->cmd_ssm, data, g_free);
   fpi_ssm_start (self->cmd_ssm, fpc_cmd_ssm_done);
@@ -742,7 +744,7 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
     case FPC_ENROL_STATUS_COMPLETED:
       self->enroll_stage++;
       fpi_device_enroll_progress (FP_DEVICE (self), self->enroll_stage, NULL, NULL);
-      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
+      fpi_ssm_jump_to_state (self->task_ssm, FPC_ENROLL_COMPLETE);
       return;
 
     case FPC_ENROL_STATUS_IMAGE_TOO_SIMILAR:
@@ -761,7 +763,7 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
               /* Used for customer enrollment scheme */
               if (self->enroll_stage >= (self->max_enroll_stage - self->max_immobile_stage))
                 {
-                  fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
+                  fpi_ssm_jump_to_state (self->task_ssm, FPC_ENROLL_COMPLETE);
                   return;
                 }
               break;
@@ -779,7 +781,7 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
       /* Used for customer enrollment scheme */
       if (self->enroll_stage >= (self->max_enroll_stage - self->max_immobile_stage))
         {
-          fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
+          fpi_ssm_jump_to_state (self->task_ssm, FPC_ENROLL_COMPLETE);
           return;
         }
       break;
@@ -814,7 +816,7 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
     }
   else
     {
-      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, FPC_ENROLL_CAPTURE);
     }
 }
 
@@ -942,7 +944,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FP_ENROLL_ENUM:
+    case FPC_ENROLL_ENUM:
       {
         FPC_FID_DATA pquery_data = {0};
         gsize query_data_len = 0;
@@ -967,7 +969,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_ENROLL_CREATE:
+    case FPC_ENROLL_CREATE:
       {
         recv_data_len = sizeof (FPC_BEGIN_ENROL);
         cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -982,7 +984,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_ENROLL_CAPTURE:
+    case FPC_ENROLL_CAPTURE:
       {
         guint32 capture_id = FPC_CAPTUREID_RESERVED;
         fpi_device_report_finger_status_changes (device,
@@ -1000,7 +1002,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_ENROLL_GET_IMG:
+    case FPC_ENROLL_GET_IMG:
       {
         cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA;
         cmd_data.request = FPC_CMD_GET_IMG;
@@ -1014,7 +1016,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_ENROLL_UPDATE:
+    case FPC_ENROLL_UPDATE:
       {
         recv_data_len = sizeof (FPC_ENROL);
         cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1029,7 +1031,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_ENROLL_COMPLETE:
+    case FPC_ENROLL_COMPLETE:
       {
         recv_data_len = sizeof (FPC_END_ENROL);
         cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1044,7 +1046,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_ENROLL_CHECK_DUPLICATE:
+    case FPC_ENROLL_CHECK_DUPLICATE:
       {
         recv_data_len = sizeof (FPC_IDENTIFY);
         cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1059,7 +1061,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_ENROLL_BINDID:
+    case FPC_ENROLL_BINDID:
       {
         FPC_FID_DATA data = {0};
         gsize data_len = 0;
@@ -1113,7 +1115,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_ENROLL_COMMIT:
+    case FPC_ENROLL_COMMIT:
       {
         recv_data_len = sizeof (gint32);
         cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1128,7 +1130,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_ENROLL_DICARD:
+    case FPC_ENROLL_DICARD:
       {
         cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE;
         cmd_data.request = FPC_CMD_ABORT;
@@ -1141,7 +1143,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_ENROLL_CLEANUP:
+    case FPC_ENROLL_CLEANUP:
       {
         if (self->do_cleanup == TRUE)
           {
@@ -1286,7 +1288,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FP_VERIFY_CAPTURE:
+    case FPC_VERIFY_CAPTURE:
       {
         guint32 capture_id = FPC_CAPTUREID_RESERVED;
         fpi_device_report_finger_status_changes (device,
@@ -1304,7 +1306,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_VERIFY_GET_IMG:
+    case FPC_VERIFY_GET_IMG:
       {
         cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA;
         cmd_data.request = FPC_CMD_GET_IMG;
@@ -1318,7 +1320,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_VERIFY_IDENTIFY:
+    case FPC_VERIFY_IDENTIFY:
       {
         gsize recv_data_len = sizeof (FPC_IDENTIFY);
         cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1333,7 +1335,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_VERIFY_CANCEL:
+    case FPC_VERIFY_CANCEL:
       {
         cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE;
         cmd_data.request = FPC_CMD_ABORT;
@@ -1403,7 +1405,7 @@ fpc_clear_sm_run_state (FpiSsm *ssm, FpDevice *device)
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FP_CLEAR_DELETE_DB:
+    case FPC_CLEAR_DELETE_DB:
       {
         if (self->dbid)
           {
@@ -1430,7 +1432,7 @@ fpc_clear_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_CLEAR_CREATE_DB:
+    case FPC_CLEAR_CREATE_DB:
       {
         if (self->dbid)
           {
@@ -1535,7 +1537,7 @@ fpc_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FP_INIT:
+    case FPC_INIT:
       cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA;
       cmd_data.request = FPC_CMD_INIT;
       cmd_data.value = 0x1;
@@ -1547,7 +1549,7 @@ fpc_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
       fpc_sensor_cmd (self, FALSE, &cmd_data);
       break;
 
-    case FP_LOAD_DB:
+    case FPC_INIT_LOAD_DB:
       {
         gsize recv_data_len = sizeof (FPC_LOAD_DB);
         cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1638,6 +1640,7 @@ fpc_dev_probe (FpDevice *device)
     {
     case 0xFFE0:
     case 0xA305:
+    case 0xA306:
     case 0xD805:
     case 0xDA04:
     case 0xD205:
@@ -1680,7 +1683,7 @@ fpc_dev_open (FpDevice *device)
     }
 
   self->task_ssm = fpi_ssm_new (device, fpc_init_sm_run_state,
-                                FP_INIT_NUM_STATES);
+                                FPC_INIT_NUM_STATES);
 
   fpi_ssm_start (self->task_ssm, fpc_init_ssm_done);
 }
@@ -1692,6 +1695,7 @@ fpc_dev_close (FpDevice *device)
 
   fp_dbg ("%s enter -->", G_STRFUNC);
   g_clear_pointer (&self->dbid, g_free);
+  g_cancellable_cancel (self->interrupt_cancellable);
   g_clear_object (&self->interrupt_cancellable);
   fpc_dev_release_interface (self, NULL);
 }
@@ -1703,8 +1707,8 @@ fpc_dev_verify_identify (FpDevice *device)
 
   fp_dbg ("%s enter -->", G_STRFUNC);
   self->task_ssm = fpi_ssm_new_full (device, fpc_verify_sm_run_state,
-                                     FP_VERIFY_NUM_STATES,
-                                     FP_VERIFY_CANCEL,
+                                     FPC_VERIFY_NUM_STATES,
+                                     FPC_VERIFY_CANCEL,
                                      "verify_identify");
 
   fpi_ssm_start (self->task_ssm, fpc_verify_ssm_done);
@@ -1720,8 +1724,8 @@ fpc_dev_enroll (FpDevice *device)
   self->enroll_stage = 0;
   self->immobile_stage = 0;
   self->task_ssm = fpi_ssm_new_full (device, fpc_enroll_sm_run_state,
-                                     FP_ENROLL_NUM_STATES,
-                                     FP_ENROLL_DICARD,
+                                     FPC_ENROLL_NUM_STATES,
+                                     FPC_ENROLL_DICARD,
                                      "enroll");
 
   fpi_ssm_start (self->task_ssm, fpc_enroll_ssm_done);
@@ -1772,7 +1776,7 @@ fpc_dev_suspend (FpDevice *device)
     }
 
   g_assert (self->cmd_ssm);
-  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == FP_CMD_GET_DATA);
+  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == FPC_CMD_GET_DATA);
   self->cmd_suspended = TRUE;
   g_cancellable_cancel (self->interrupt_cancellable);
 }
@@ -1794,10 +1798,12 @@ fpc_dev_resume (FpDevice *device)
 
   g_assert (self->cmd_ssm);
   g_assert (self->cmd_suspended);
-  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == FP_CMD_SUSPENDED);
+  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == FPC_CMD_SUSPENDED);
   self->cmd_suspended = FALSE;
-  g_set_object (&self->interrupt_cancellable, g_cancellable_new ());
-  fpi_ssm_jump_to_state (self->cmd_ssm, FP_CMD_RESUME);
+
+  g_clear_object (&self->interrupt_cancellable);
+  self->interrupt_cancellable = g_cancellable_new ();
+  fpi_ssm_jump_to_state (self->cmd_ssm, FPC_CMD_RESUME);
 }
 
 static void
@@ -1861,8 +1867,8 @@ fpc_dev_clear_storage (FpDevice *device)
 
   fp_dbg ("%s enter -->", G_STRFUNC);
   self->task_ssm = fpi_ssm_new_full (device, fpc_clear_sm_run_state,
-                                     FP_CLEAR_NUM_STATES,
-                                     FP_CLEAR_NUM_STATES,
+                                     FPC_CLEAR_NUM_STATES,
+                                     FPC_CLEAR_NUM_STATES,
                                      "Clear storage");
 
   fpi_ssm_start (self->task_ssm, fpc_clear_ssm_done);

libfprint/drivers/fpcmoc/fpc.h

@@ -178,44 +178,44 @@ typedef enum {
 } FpcCmdType;
 
 typedef enum {
-  FP_CMD_SEND = 0,
-  FP_CMD_GET_DATA,
-  FP_CMD_SUSPENDED,
-  FP_CMD_RESUME,
-  FP_CMD_NUM_STATES,
-} FpCmdState;
+  FPC_CMD_SEND = 0,
+  FPC_CMD_GET_DATA,
+  FPC_CMD_SUSPENDED,
+  FPC_CMD_RESUME,
+  FPC_CMD_NUM_STATES,
+} FpcCmdState;
 
 typedef enum {
-  FP_INIT = 0,
-  FP_LOAD_DB,
-  FP_INIT_NUM_STATES,
-} FpInitState;
+  FPC_INIT = 0,
+  FPC_INIT_LOAD_DB,
+  FPC_INIT_NUM_STATES,
+} FpcInitState;
 
 typedef enum {
-  FP_ENROLL_ENUM = 0,
-  FP_ENROLL_CREATE,
-  FP_ENROLL_CAPTURE,
-  FP_ENROLL_GET_IMG,
-  FP_ENROLL_UPDATE,
-  FP_ENROLL_COMPLETE,
-  FP_ENROLL_CHECK_DUPLICATE,
-  FP_ENROLL_BINDID,
-  FP_ENROLL_COMMIT,
-  FP_ENROLL_DICARD,
-  FP_ENROLL_CLEANUP,
-  FP_ENROLL_NUM_STATES,
-} FpEnrollState;
+  FPC_ENROLL_ENUM = 0,
+  FPC_ENROLL_CREATE,
+  FPC_ENROLL_CAPTURE,
+  FPC_ENROLL_GET_IMG,
+  FPC_ENROLL_UPDATE,
+  FPC_ENROLL_COMPLETE,
+  FPC_ENROLL_CHECK_DUPLICATE,
+  FPC_ENROLL_BINDID,
+  FPC_ENROLL_COMMIT,
+  FPC_ENROLL_DICARD,
+  FPC_ENROLL_CLEANUP,
+  FPC_ENROLL_NUM_STATES,
+} FpcEnrollState;
 
 typedef enum {
-  FP_VERIFY_CAPTURE = 0,
-  FP_VERIFY_GET_IMG,
-  FP_VERIFY_IDENTIFY,
-  FP_VERIFY_CANCEL,
-  FP_VERIFY_NUM_STATES,
-} FpVerifyState;
+  FPC_VERIFY_CAPTURE = 0,
+  FPC_VERIFY_GET_IMG,
+  FPC_VERIFY_IDENTIFY,
+  FPC_VERIFY_CANCEL,
+  FPC_VERIFY_NUM_STATES,
+} FpcVerifyState;
 
 typedef enum {
-  FP_CLEAR_DELETE_DB = 0,
-  FP_CLEAR_CREATE_DB,
-  FP_CLEAR_NUM_STATES,
+  FPC_CLEAR_DELETE_DB = 0,
+  FPC_CLEAR_CREATE_DB,
+  FPC_CLEAR_NUM_STATES,
 } FpClearState;

libfprint/drivers/goodixmoc/goodix.c

@@ -238,7 +238,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FP_CMD_SEND:
+    case GOODIX_CMD_SEND:
       if (self->cmd_transfer)
         {
           self->cmd_transfer->ssm = ssm;
@@ -254,7 +254,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
         }
       break;
 
-    case FP_CMD_GET_ACK:
+    case GOODIX_CMD_GET_ACK:
       transfer = fpi_usb_transfer_new (dev);
       transfer->ssm = ssm;
       fpi_usb_transfer_fill_bulk (transfer, EP_IN, EP_IN_MAX_BUF_SIZE);
@@ -266,7 +266,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
 
       break;
 
-    case FP_CMD_GET_DATA:
+    case GOODIX_CMD_GET_DATA:
       transfer = fpi_usb_transfer_new (dev);
       transfer->ssm = ssm;
       fpi_usb_transfer_fill_bulk (transfer, EP_IN, EP_IN_MAX_BUF_SIZE);
@@ -354,7 +354,7 @@ goodix_sensor_cmd (FpiDeviceGoodixMoc *self,
 
   self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
                                fp_cmd_run_state,
-                               FP_CMD_NUM_STATES);
+                               GOODIX_CMD_NUM_STATES);
 
   fpi_ssm_set_data (self->cmd_ssm, data, (GDestroyNotify) fp_cmd_ssm_done_data_free);
 
@@ -493,7 +493,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FP_VERIFY_PWR_BTN_SHIELD_ON:
+    case GOODIX_VERIFY_PWR_BTN_SHIELD_ON:
       goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_ON,
                          false,
                          NULL,
@@ -501,7 +501,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_pwr_btn_shield_cb);
       break;
 
-    case FP_VERIFY_CAPTURE:
+    case GOODIX_VERIFY_CAPTURE:
       fpi_device_report_finger_status_changes (device,
                                                FP_FINGER_STATUS_NEEDED,
                                                FP_FINGER_STATUS_NONE);
@@ -512,7 +512,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_verify_capture_cb);
       break;
 
-    case FP_VERIFY_IDENTIFY:
+    case GOODIX_VERIFY_IDENTIFY:
       goodix_sensor_cmd (self, MOC_CMD0_IDENTIFY, MOC_CMD1_DEFAULT,
                          false,
                          (const guint8 *) nonce,
@@ -520,7 +520,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_verify_cb);
       break;
 
-    case FP_VERIFY_PWR_BTN_SHIELD_OFF:
+    case GOODIX_VERIFY_PWR_BTN_SHIELD_OFF:
       goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_OFF,
                          false,
                          NULL,
@@ -682,7 +682,7 @@ fp_enroll_capture_cb (FpiDeviceGoodixMoc  *self,
                                   self->enroll_stage,
                                   NULL,
                                   fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL));
-      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_CAPTURE);
       return;
     }
   fpi_device_report_finger_status_changes (FP_DEVICE (self),
@@ -700,7 +700,7 @@ fp_enroll_capture_cb (FpiDeviceGoodixMoc  *self,
                                   self->enroll_stage,
                                   NULL,
                                   fpi_device_retry_new (FP_DEVICE_RETRY_CENTER_FINGER));
-      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_CAPTURE);
       return;
     }
   else
@@ -746,7 +746,7 @@ fp_enroll_update_cb (FpiDeviceGoodixMoc  *self,
   /* if enroll complete, no need to wait finger up */
   if (self->enroll_stage >= self->max_enroll_stage)
     {
-      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CHECK_DUPLICATE);
+      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_CHECK_DUPLICATE);
       return;
     }
 
@@ -812,7 +812,7 @@ fp_finger_mode_cb (FpiDeviceGoodixMoc  *self,
   /* if reach max timeout(5sec) finger not up, switch to finger up again */
   if (resp->finger_status.status == GX_ERROR_WAIT_FINGER_UP_TIMEOUT)
     {
-      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_WAIT_FINGER_UP);
+      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_WAIT_FINGER_UP);
       return;
     }
   else if (resp->finger_status.status != GX_SUCCESS)
@@ -827,7 +827,7 @@ fp_finger_mode_cb (FpiDeviceGoodixMoc  *self,
                                            FP_FINGER_STATUS_PRESENT);
   if (self->enroll_stage < self->max_enroll_stage)
     {
-      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_CAPTURE);
       return;
     }
   fpi_ssm_next_state (self->task_ssm);
@@ -853,7 +853,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FP_ENROLL_PWR_BTN_SHIELD_ON:
+    case GOODIX_ENROLL_PWR_BTN_SHIELD_ON:
       {
         goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_ON,
                            false,
@@ -863,7 +863,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_ENROLL_ENUM:
+    case GOODIX_ENROLL_ENUM:
       {
         goodix_sensor_cmd (self, MOC_CMD0_GETFINGERLIST, MOC_CMD1_DEFAULT,
                            false,
@@ -873,7 +873,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_ENROLL_CREATE:
+    case GOODIX_ENROLL_CREATE:
       {
         goodix_sensor_cmd (self, MOC_CMD0_ENROLL_INIT, MOC_CMD1_DEFAULT,
                            false,
@@ -883,7 +883,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_ENROLL_CAPTURE:
+    case GOODIX_ENROLL_CAPTURE:
       fpi_device_report_finger_status_changes (device,
                                                FP_FINGER_STATUS_NEEDED,
                                                FP_FINGER_STATUS_NONE);
@@ -894,7 +894,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_enroll_capture_cb);
       break;
 
-    case FP_ENROLL_UPDATE:
+    case GOODIX_ENROLL_UPDATE:
       dummy[0] = 1;
       dummy[1] = self->sensorcfg->config[2];
       dummy[2] = self->sensorcfg->config[3];
@@ -905,7 +905,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_enroll_update_cb);
       break;
 
-    case FP_ENROLL_WAIT_FINGER_UP:
+    case GOODIX_ENROLL_WAIT_FINGER_UP:
       dummy[0] = 0;
       goodix_sensor_cmd (self, MOC_CMD0_FINGER_MODE, MOC_CMD1_SET_FINGER_UP,
                          true,
@@ -914,7 +914,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_finger_mode_cb);
       break;
 
-    case FP_ENROLL_CHECK_DUPLICATE:
+    case GOODIX_ENROLL_CHECK_DUPLICATE:
       goodix_sensor_cmd (self, MOC_CMD0_CHECK4DUPLICATE, MOC_CMD1_DEFAULT,
                          false,
                          (const guint8 *) &dummy,
@@ -922,7 +922,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_enroll_check_duplicate_cb);
       break;
 
-    case FP_ENROLL_COMMIT:
+    case GOODIX_ENROLL_COMMIT:
       {
         fpi_device_get_enroll_data (device, &print);
         user_id = fpi_print_generate_user_id (print);
@@ -975,7 +975,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FP_ENROLL_PWR_BTN_SHIELD_OFF:
+    case GOODIX_ENROLL_PWR_BTN_SHIELD_OFF:
       {
         goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_OFF,
                            false,
@@ -1066,7 +1066,7 @@ fp_init_cb_reset_or_complete (FpiDeviceGoodixMoc  *self,
     {
       fp_warn ("Template storage appears to have been corrupted! Error was: %s", error->message);
       fp_warn ("A known reason for this to happen is a firmware bug triggered by another storage area being initialized.");
-      fpi_ssm_jump_to_state (self->task_ssm, FP_INIT_RESET_DEVICE);
+      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_INIT_RESET_DEVICE);
     }
   else
     {
@@ -1107,7 +1107,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FP_INIT_VERSION:
+    case GOODIX_INIT_VERSION:
       goodix_sensor_cmd (self, MOC_CMD0_GET_VERSION, MOC_CMD1_DEFAULT,
                          false,
                          &dummy,
@@ -1115,7 +1115,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_init_version_cb);
       break;
 
-    case FP_INIT_CONFIG:
+    case GOODIX_INIT_CONFIG:
       goodix_sensor_cmd (self, MOC_CMD0_UPDATE_CONFIG, MOC_CMD1_WRITE_CFG_TO_FLASH,
                          false,
                          (guint8 *) self->sensorcfg,
@@ -1123,7 +1123,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_init_config_cb);
       break;
 
-    case FP_INIT_TEMPLATE_LIST:
+    case GOODIX_INIT_TEMPLATE_LIST:
       /* List prints to check whether the template DB was corrupted.
        * As of 2022-06-13 there is a known firmware issue that can cause the
        * stored templates for Linux to be corrupted when the Windows storage
@@ -1138,7 +1138,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_init_cb_reset_or_complete);
       break;
 
-    case FP_INIT_RESET_DEVICE:
+    case GOODIX_INIT_RESET_DEVICE:
       fp_warn ("Resetting device storage, you will need to enroll all prints again!");
       goodix_sensor_cmd (self, MOC_CMD0_DELETETEMPLATE, MOC_CMD1_DELETE_ALL,
                          FALSE,
@@ -1452,7 +1452,7 @@ gx_fp_init (FpDevice *device)
     }
 
   self->task_ssm = fpi_ssm_new (device, fp_init_sm_run_state,
-                                FP_INIT_NUM_STATES);
+                                GOODIX_INIT_NUM_STATES);
 
   fpi_ssm_start (self->task_ssm, fp_init_ssm_done);
 
@@ -1483,9 +1483,7 @@ gx_fp_exit_cb (FpiDeviceGoodixMoc  *self,
                gxfp_cmd_response_t *resp,
                GError              *error)
 {
-
-
-  if (resp->result >= GX_FAILED)
+  if (resp && resp->result >= GX_FAILED)
     fp_dbg ("Setting power button shield failed, result: 0x%x", resp->result);
   self->is_power_button_shield_on = false;
   gx_fp_release_interface (self, error);
@@ -1520,8 +1518,8 @@ gx_fp_verify_identify (FpDevice *device)
   FpiDeviceGoodixMoc *self = FPI_DEVICE_GOODIXMOC (device);
 
   self->task_ssm = fpi_ssm_new_full (device, fp_verify_sm_run_state,
-                                     FP_VERIFY_NUM_STATES,
-                                     FP_VERIFY_PWR_BTN_SHIELD_OFF,
+                                     GOODIX_VERIFY_NUM_STATES,
+                                     GOODIX_VERIFY_PWR_BTN_SHIELD_OFF,
                                      "verify");
 
   fpi_ssm_start (self->task_ssm, fp_verify_ssm_done);
@@ -1537,8 +1535,8 @@ gx_fp_enroll (FpDevice *device)
   self->enroll_stage = 0;
 
   self->task_ssm = fpi_ssm_new_full (device, fp_enroll_sm_run_state,
-                                     FP_ENROLL_NUM_STATES,
-                                     FP_ENROLL_PWR_BTN_SHIELD_OFF,
+                                     GOODIX_ENROLL_NUM_STATES,
+                                     GOODIX_ENROLL_PWR_BTN_SHIELD_OFF,
                                      "enroll");
 
   fpi_ssm_start (self->task_ssm, fp_enroll_ssm_done);
@@ -1658,6 +1656,7 @@ static const FpIdEntry id_table[] = {
   { .vid = 0x27c6,  .pid = 0x6A94,  },
   { .vid = 0x27c6,  .pid = 0x6512,  },
   { .vid = 0x27c6,  .pid = 0x689A,  },
+  { .vid = 0x27c6,  .pid = 0x66A9,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 

libfprint/drivers/goodixmoc/goodix.h

@@ -25,39 +25,39 @@
 G_DECLARE_FINAL_TYPE (FpiDeviceGoodixMoc, fpi_device_goodixmoc, FPI, DEVICE_GOODIXMOC, FpDevice)
 
 typedef enum {
-  FP_CMD_SEND = 0,
-  FP_CMD_GET_ACK,
-  FP_CMD_GET_DATA,
-  FP_CMD_NUM_STATES,
-} FpCmdState;
+  GOODIX_CMD_SEND = 0,
+  GOODIX_CMD_GET_ACK,
+  GOODIX_CMD_GET_DATA,
+  GOODIX_CMD_NUM_STATES,
+} GoodixCmdState;
 
 
 typedef enum {
-  FP_INIT_VERSION = 0,
-  FP_INIT_CONFIG,
-  FP_INIT_TEMPLATE_LIST,
-  FP_INIT_RESET_DEVICE,
-  FP_INIT_NUM_STATES,
-} FpInitState;
+  GOODIX_INIT_VERSION = 0,
+  GOODIX_INIT_CONFIG,
+  GOODIX_INIT_TEMPLATE_LIST,
+  GOODIX_INIT_RESET_DEVICE,
+  GOODIX_INIT_NUM_STATES,
+} GoodixInitState;
 
 
 typedef enum {
-  FP_ENROLL_PWR_BTN_SHIELD_ON = 0,
-  FP_ENROLL_ENUM,
-  FP_ENROLL_CREATE,
-  FP_ENROLL_CAPTURE,
-  FP_ENROLL_UPDATE,
-  FP_ENROLL_WAIT_FINGER_UP,
-  FP_ENROLL_CHECK_DUPLICATE,
-  FP_ENROLL_COMMIT,
-  FP_ENROLL_PWR_BTN_SHIELD_OFF,
-  FP_ENROLL_NUM_STATES,
-} FpEnrollState;
+  GOODIX_ENROLL_PWR_BTN_SHIELD_ON = 0,
+  GOODIX_ENROLL_ENUM,
+  GOODIX_ENROLL_CREATE,
+  GOODIX_ENROLL_CAPTURE,
+  GOODIX_ENROLL_UPDATE,
+  GOODIX_ENROLL_WAIT_FINGER_UP,
+  GOODIX_ENROLL_CHECK_DUPLICATE,
+  GOODIX_ENROLL_COMMIT,
+  GOODIX_ENROLL_PWR_BTN_SHIELD_OFF,
+  GOODIX_ENROLL_NUM_STATES,
+} GoodixEnrollState;
 
 typedef enum {
-  FP_VERIFY_PWR_BTN_SHIELD_ON = 0,
-  FP_VERIFY_CAPTURE,
-  FP_VERIFY_IDENTIFY,
-  FP_VERIFY_PWR_BTN_SHIELD_OFF,
-  FP_VERIFY_NUM_STATES,
-} FpVerifyState;
+  GOODIX_VERIFY_PWR_BTN_SHIELD_ON = 0,
+  GOODIX_VERIFY_CAPTURE,
+  GOODIX_VERIFY_IDENTIFY,
+  GOODIX_VERIFY_PWR_BTN_SHIELD_OFF,
+  GOODIX_VERIFY_NUM_STATES,
+} GoodixVerifyState;

libfprint/drivers/realtek/realtek.c

@@ -29,6 +29,7 @@ G_DEFINE_TYPE (FpiDeviceRealtek, fpi_device_realtek, FP_TYPE_DEVICE)
 static const FpIdEntry id_table[] = {
   { .vid = 0x0bda,  .pid = 0x5813,  },
   { .vid = 0x0bda,  .pid = 0x5816,  },
+  { .vid = 0x2541,  .pid = 0xfa03,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 

libfprint/drivers/synaptics/synaptics.c

@@ -36,6 +36,7 @@ static const FpIdEntry id_table[] = {
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C4,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C6,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00DF,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00E9,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F0,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F9,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00FC,  },
@@ -45,16 +46,21 @@ static const FpIdEntry id_table[] = {
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0106,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0107,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0108,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0109,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x010A,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0123,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0124,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0126,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0129,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x015F,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0168,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0169,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x016C,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0173,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0174,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x019D,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x019F,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x01A0,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 
@@ -1254,6 +1260,12 @@ dev_probe (FpDevice *device)
       return;
     }
 
+  if (!g_usb_device_reset (usb_dev, &error))
+    {
+      fp_dbg ("%s g_usb_device_reset failed %s", G_STRFUNC, error->message);
+      goto err_close;
+    }
+
   if (!g_usb_device_claim_interface (usb_dev, 0, 0, &error))
     goto err_close;
 

libfprint/fp-device.c

@@ -483,6 +483,9 @@ fp_device_class_init (FpDeviceClass *klass)
                          NULL,
                          G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
 
+  /**
+   * FpDevice:open: (getter is_open):
+   */
   properties[PROP_OPEN] =
     g_param_spec_boolean ("open",
                           "Opened",

libfprint/fprint-list-udev-hwdb.c

@@ -76,7 +76,6 @@ static const FpIdEntry allowlist_id_table[] = {
   { .vid = 0x06cb, .pid = 0x00dc },
   { .vid = 0x06cb, .pid = 0x00e4 },
   { .vid = 0x06cb, .pid = 0x00e7 },
-  { .vid = 0x06cb, .pid = 0x00e9 },
   { .vid = 0x06cb, .pid = 0x00fd },
   { .vid = 0x06cb, .pid = 0x00ff },
   { .vid = 0x0a5c, .pid = 0x5801 },
@@ -120,7 +119,6 @@ static const FpIdEntry allowlist_id_table[] = {
   { .vid = 0x1c7a, .pid = 0x0300 },
   { .vid = 0x1c7a, .pid = 0x0575 },
   { .vid = 0x1c7a, .pid = 0x0576 },
-  { .vid = 0x1c7a, .pid = 0x0584 },
   { .vid = 0x1c7a, .pid = 0x0577 },
   { .vid = 0x1c7a, .pid = 0x057e },
   { .vid = 0x2541, .pid = 0x0236 },

libfprint/meson.build

@@ -410,6 +410,7 @@ if get_option('introspection')
             'GObject-2.0',
             'GUsb-1.0',
         ],
+        fatal_warnings: true,
         install : true)
     libfprint_gir = libfprint_girtarget[0]
     libfprint_typelib = libfprint_girtarget[1]

meson.build

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

tests/fpcmoc/device

@@ -3,7 +3,7 @@ N: bus/usb/001/019=1201000200000040A510E0FF10000102000109021900010104A0320904000
 E: DEVNAME=/dev/bus/usb/001/019
 E: DEVTYPE=usb_device
 E: DRIVER=usb
-E: PRODUCT=10a5/ffe0/10
+E: PRODUCT=10a5/a306/10
 E: TYPE=0/0/0
 E: BUSNUM=001
 E: DEVNUM=019
@@ -13,11 +13,11 @@ E: SUBSYSTEM=usb
 E: ID_VENDOR=FPC
 E: ID_VENDOR_ENC=FPC
 E: ID_VENDOR_ID=10a5
-E: ID_MODEL=FPC_L:0001_FW:127010
-E: ID_MODEL_ENC=FPC\x20L:0001\x20FW:127010
-E: ID_MODEL_ID=ffe0
+E: ID_MODEL=FPC_L:0001_FW:222709
+E: ID_MODEL_ENC=FPC\x20L:0001\x20FW:222709
+E: ID_MODEL_ID=a306
 E: ID_REVISION=0010
-E: ID_SERIAL=FPC_FPC_L:0001_FW:127010
+E: ID_SERIAL=FPC_FPC_L:0001_FW:222709
 E: ID_BUS=usb
 E: ID_USB_INTERFACES=:ffffff:
 E: ID_PATH=pci-0000:00:14.0-usb-0:1
@@ -45,7 +45,7 @@ A: devnum=19\n
 A: devpath=1\n
 L: driver=../../../../../bus/usb/drivers/usb
 L: firmware_node=../../../../LNXSYSTM:00/LNXSYBUS:00/PNP0A08:00/device:1c/device:1d/device:1e
-A: idProduct=ffe0\n
+A: idProduct=a306\n
 A: idVendor=10a5\n
 A: ltm_capable=no\n
 A: manufacturer=FPC\n
@@ -74,7 +74,7 @@ A: power/wakeup_expire_count=\n
 A: power/wakeup_last_time_ms=\n
 A: power/wakeup_max_time_ms=\n
 A: power/wakeup_total_time_ms=\n
-A: product=FPC L:0001 FW:127010\n
+A: product=FPC L:0001 FW:222709\n
 A: quirks=0x0\n
 A: removable=removable\n
 A: rx_lanes=1\n