.gitlab-ci.yml

@@ -4,10 +4,9 @@ include:
   - project: 'freedesktop/ci-templates'
     ref: master
     file: '/templates/fedora.yml'
-  - remote: 'https://gitlab.gnome.org/GNOME/citemplates/-/raw/71e636e012ae0ab04c5e0fe40ca73ada91ae6bde/flatpak/flatpak_ci_initiative.yml'
+  - remote: 'https://gitlab.gnome.org/GNOME/citemplates/-/raw/master/flatpak/flatpak_ci_initiative.yml'
 
 default:
-  interruptible: true
   # Auto-retry jobs in case of infra failures
   retry:
     max: 1
@@ -20,7 +19,7 @@ default:
 variables:
   extends: .libfprint_common_variables
   FDO_DISTRIBUTION_TAG: $LIBFPRINT_IMAGE_TAG
-  FDO_DISTRIBUTION_VERSION: rawhide
+  FDO_DISTRIBUTION_VERSION: 41
   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"
@@ -89,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 || true
+    - ninja -C _build coverage
     - cat _build/meson-logs/coverage.txt || true
   artifacts:
     reports:
@@ -294,4 +293,4 @@ pages:
     paths:
       - public
   rules:
-    - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH && $CI_PIPELINE_SOURCE == "push"
+    - if: $CI_COMMIT_REF_NAME == $CI_DEFAULT_BRANCH

.gitlab-ci/libfprint-templates.yaml

@@ -44,6 +44,4 @@
       libgusb \
       libusb \
       openssl \
-      pixman \
+      pixman
-      python3-gobject \
-      python3-gobject-base

NEWS

@@ -1,22 +1,6 @@
 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,10 +80,8 @@ 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
@@ -165,10 +163,6 @@ usb:v04F3p0C99*
 usb:v04F3p0C9D*
 usb:v04F3p0C9F*
 usb:v04F3p0CA3*
-usb:v04F3p0CA7*
-usb:v04F3p0CA8*
-usb:v04F3p0CB0*
-usb:v04F3p0CB2*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
@@ -180,35 +174,28 @@ usb:v1C7Ap0603*
 # Supported by libfprint driver focaltech_moc
 usb:v2808p9E48*
 usb:v2808pD979*
-usb:v2808pA27A*
 usb:v2808pA959*
 usb:v2808pA99A*
 usb:v2808pA57A*
 usb:v2808pA78A*
-usb:v2808p1579*
-usb:v2808p077A*
-usb:v2808p079A*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
 # Supported by libfprint driver fpcmoc
 usb:v10A5pFFE0*
 usb:v10A5pA305*
-usb:v10A5pA306*
 usb:v10A5pDA04*
 usb:v10A5pD805*
 usb:v10A5pD205*
 usb:v10A5p9524*
 usb:v10A5p9544*
 usb:v10A5pC844*
-usb:v10A5p9B24*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
 # Supported by libfprint driver goodixmoc
 usb:v27C6p5840*
 usb:v27C6p6014*
-usb:v27C6p6090*
 usb:v27C6p6092*
 usb:v27C6p6094*
 usb:v27C6p609A*
@@ -238,9 +225,7 @@ usb:v27C6p659A*
 usb:v27C6p659C*
 usb:v27C6p6A94*
 usb:v27C6p6512*
-usb:v27C6p6890*
 usb:v27C6p689A*
-usb:v27C6p66A9*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
@@ -252,7 +237,6 @@ usb:v298Dp1010*
 # Supported by libfprint driver realtek
 usb:v0BDAp5813*
 usb:v0BDAp5816*
-usb:v2541pFA03*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
@@ -262,7 +246,6 @@ usb:v06CBp00C2*
 usb:v06CBp00C4*
 usb:v06CBp00C6*
 usb:v06CBp00DF*
-usb:v06CBp00E9*
 usb:v06CBp00F0*
 usb:v06CBp00F9*
 usb:v06CBp00FC*
@@ -272,21 +255,16 @@ 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
 
@@ -390,12 +368,10 @@ usb:v06CBp0088*
 usb:v06CBp008A*
 usb:v06CBp009A*
 usb:v06CBp009B*
-usb:v06CBp00A1*
 usb:v06CBp00A2*
 usb:v06CBp00A8*
 usb:v06CBp00B7*
 usb:v06CBp00BB*
-usb:v06CBp00BC*
 usb:v06CBp00BE*
 usb:v06CBp00CB*
 usb:v06CBp00C9*
@@ -404,6 +380,7 @@ usb:v06CBp00DA*
 usb:v06CBp00DC*
 usb:v06CBp00E4*
 usb:v06CBp00E7*
+usb:v06CBp00E9*
 usb:v06CBp00FD*
 usb:v06CBp00FF*
 usb:v0A5Cp5801*
@@ -424,11 +401,9 @@ usb:v0A5Cp5867*
 usb:v0BDAp5812*
 usb:v10A5p0007*
 usb:v10A5p9200*
-usb:v10A5p9201*
 usb:v10A5p9800*
 usb:v10A5pA120*
 usb:v10A5pA900*
-usb:v10A5pA921*
 usb:v10A5pE340*
 usb:v1188p9545*
 usb:v138Ap0007*
@@ -449,6 +424,7 @@ usb:v16D1p1027*
 usb:v1C7Ap0300*
 usb:v1C7Ap0575*
 usb:v1C7Ap0576*
+usb:v1C7Ap0584*
 usb:v1C7Ap0577*
 usb:v1C7Ap057E*
 usb:v2541p0236*
@@ -482,14 +458,12 @@ usb:v27C6p5E0A*
 usb:v27C6p581A*
 usb:v27C6p589A*
 usb:v27C6p5F10*
-usb:v27C6p5F91*
 usb:v27C6p6382*
 usb:v2808p9338*
 usb:v2808p9348*
 usb:v2808p93A9*
 usb:v2808pA658*
 usb:v2808pC652*
-usb:v2808pA553*
 usb:v298Dp2020*
 usb:v298Dp2033*
 usb:v2DF0p0003*

gcovr.cfg

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

libfprint/drivers/egismoc/egismoc.c

@@ -52,10 +52,8 @@ 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,10 +36,6 @@ 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 = 0x04f3,  .pid = 0x0cb2,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 
@@ -136,10 +132,10 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
 }
 
 typedef enum {
-  ELAN_MOC_CMD_SEND = 0,
+  FP_CMD_SEND = 0,
-  ELAN_MOC_CMD_GET,
+  FP_CMD_GET,
-  ELAN_MOC_CMD_NUM_STATES,
+  FP_CMD_NUM_STATES,
-} ElanMocCmdState;
+} FpCmdState;
 
 static void
 fp_cmd_run_state (FpiSsm   *ssm,
@@ -150,7 +146,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case ELAN_MOC_CMD_SEND:
+    case FP_CMD_SEND:
       if (self->cmd_transfer)
         {
           self->cmd_transfer->ssm = ssm;
@@ -166,7 +162,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
         }
       break;
 
-    case ELAN_MOC_CMD_GET:
+    case FP_CMD_GET:
       if (self->cmd_len_in == 0)
         {
           CommandData *data = fpi_ssm_get_data (ssm);
@@ -233,7 +229,7 @@ elanmoc_get_cmd (FpDevice *device, guint8 *buffer_out,
 
   self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
                                fp_cmd_run_state,
-                               ELAN_MOC_CMD_NUM_STATES);
+                               FP_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,14 +29,10 @@ 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 = 0x2808,  .pid = 0x077A,  },
-  { .vid = 0x2808,  .pid = 0x079A,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 
@@ -239,10 +235,10 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
 }
 
 typedef enum {
-  FOCALTECH_CMD_SEND = 0,
+  FP_CMD_SEND = 0,
-  FOCALTECH_CMD_GET,
+  FP_CMD_GET,
-  FOCALTECH_CMD_NUM_STATES,
+  FP_CMD_NUM_STATES,
-} FocaltechCmdState;
+} FpCmdState;
 
 static void
 fp_cmd_run_state (FpiSsm   *ssm,
@@ -253,7 +249,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FOCALTECH_CMD_SEND:
+    case FP_CMD_SEND:
       if (self->cmd_transfer)
         {
           self->cmd_transfer->ssm = ssm;
@@ -270,7 +266,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
 
       break;
 
-    case FOCALTECH_CMD_GET:
+    case FP_CMD_GET:
       if (self->cmd_len_in == 0)
         {
           CommandData *data = fpi_ssm_get_data (ssm);
@@ -338,7 +334,7 @@ focaltech_moc_get_cmd (FpDevice *device, guint8 *buffer_out,
 
   self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
                                fp_cmd_run_state,
-                               FOCALTECH_CMD_NUM_STATES);
+                               FP_CMD_NUM_STATES);
 
   fpi_ssm_set_data (self->cmd_ssm, data, (GDestroyNotify) fp_cmd_ssm_done_data_free);
 

libfprint/drivers/fpcmoc/fpc.c

@@ -65,14 +65,12 @@ 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,  },
   { .vid = 0x10A5,  .pid = 0x9524,  },
   { .vid = 0x10A5,  .pid = 0x9544,  },
   { .vid = 0x10A5,  .pid = 0xC844,  },
-  { .vid = 0x10A5,  .pid = 0x9B24,  },
   /* terminating entry */
   { .vid = 0,  .pid = 0,  .driver_data = 0 },
 };
@@ -87,7 +85,7 @@ fpc_suspend_resume_cb (FpiUsbTransfer *transfer,
 
   fp_dbg ("%s current ssm state: %d", G_STRFUNC, ssm_state);
 
-  if (ssm_state == FPC_CMD_SUSPENDED)
+  if (ssm_state == FP_CMD_SUSPENDED)
     {
       if (error)
         fpi_ssm_mark_failed (transfer->ssm, error);
@@ -95,12 +93,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 == FPC_CMD_RESUME)
+  else if (ssm_state == FP_CMD_RESUME)
     {
       if (error)
         fpi_ssm_mark_failed (transfer->ssm, error);
       else
-        fpi_ssm_jump_to_state (transfer->ssm, FPC_CMD_GET_DATA);
+        fpi_ssm_jump_to_state (transfer->ssm, FP_CMD_GET_DATA);
 
       fpi_device_resume_complete (device, error);
     }
@@ -119,7 +117,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, FPC_CMD_SUSPENDED);
+      fpi_ssm_jump_to_state (transfer->ssm, FP_CMD_SUSPENDED);
       return;
     }
 
@@ -140,7 +138,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 != FPC_CMD_SEND || data->request != FPC_CMD_ARM)
+  if (ssm_state != FP_CMD_SEND || data->request != FPC_CMD_ARM)
     self->cmd_ssm = NULL;
 
   if (data->cmdtype == FPC_CMDTYPE_TO_DEVICE)
@@ -154,13 +152,13 @@ fpc_cmd_receive_cb (FpiUsbTransfer *transfer,
     }
   else if (data->cmdtype == FPC_CMDTYPE_TO_DEVICE_EVTDATA)
     {
-      if (ssm_state == FPC_CMD_SEND)
+      if (ssm_state == FP_CMD_SEND)
         {
           fpi_ssm_next_state (transfer->ssm);
           return;
         }
 
-      if (ssm_state == FPC_CMD_GET_DATA)
+      if (ssm_state == FP_CMD_GET_DATA)
         {
           fpc_cmd_response_t evt_data = {0};
           fp_dbg ("%s recv evt data length: %ld", G_STRFUNC, transfer->actual_length);
@@ -293,11 +291,11 @@ fpc_cmd_run_state (FpiSsm   *ssm,
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FPC_CMD_SEND:
+    case FP_CMD_SEND:
       fpc_send_ctrl_cmd (dev);
       break;
 
-    case FPC_CMD_GET_DATA:
+    case FP_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);
@@ -308,7 +306,7 @@ fpc_cmd_run_state (FpiSsm   *ssm,
                                fpi_ssm_get_data (ssm));
       break;
 
-    case FPC_CMD_SUSPENDED:
+    case FP_CMD_SUSPENDED:
       transfer = fpi_usb_transfer_new (dev);
       transfer->ssm = ssm;
       fpi_usb_transfer_fill_control (transfer,
@@ -324,7 +322,7 @@ fpc_cmd_run_state (FpiSsm   *ssm,
                                fpc_suspend_resume_cb, NULL);
       break;
 
-    case FPC_CMD_RESUME:
+    case FP_CMD_RESUME:
       transfer = fpi_usb_transfer_new (dev);
       transfer->ssm = ssm;
       fpi_usb_transfer_fill_control (transfer,
@@ -355,22 +353,21 @@ 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;
-      self->interrupt_cancellable = g_cancellable_new ();
+      g_set_object (&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,
-                               FPC_CMD_NUM_STATES);
+                               FP_CMD_NUM_STATES);
 
   fpi_ssm_set_data (self->cmd_ssm, data, g_free);
   fpi_ssm_start (self->cmd_ssm, fpc_cmd_ssm_done);
@@ -745,7 +742,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, FPC_ENROLL_COMPLETE);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
       return;
 
     case FPC_ENROL_STATUS_IMAGE_TOO_SIMILAR:
@@ -764,7 +761,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, FPC_ENROLL_COMPLETE);
+                  fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
                   return;
                 }
               break;
@@ -782,7 +779,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, FPC_ENROLL_COMPLETE);
+          fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_COMPLETE);
           return;
         }
       break;
@@ -817,7 +814,7 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
     }
   else
     {
-      fpi_ssm_jump_to_state (self->task_ssm, FPC_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
     }
 }
 
@@ -945,7 +942,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FPC_ENROLL_ENUM:
+    case FP_ENROLL_ENUM:
       {
         FPC_FID_DATA pquery_data = {0};
         gsize query_data_len = 0;
@@ -970,7 +967,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FPC_ENROLL_CREATE:
+    case FP_ENROLL_CREATE:
       {
         recv_data_len = sizeof (FPC_BEGIN_ENROL);
         cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -985,7 +982,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FPC_ENROLL_CAPTURE:
+    case FP_ENROLL_CAPTURE:
       {
         guint32 capture_id = FPC_CAPTUREID_RESERVED;
         fpi_device_report_finger_status_changes (device,
@@ -1003,7 +1000,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FPC_ENROLL_GET_IMG:
+    case FP_ENROLL_GET_IMG:
       {
         cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA;
         cmd_data.request = FPC_CMD_GET_IMG;
@@ -1017,7 +1014,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FPC_ENROLL_UPDATE:
+    case FP_ENROLL_UPDATE:
       {
         recv_data_len = sizeof (FPC_ENROL);
         cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1032,7 +1029,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FPC_ENROLL_COMPLETE:
+    case FP_ENROLL_COMPLETE:
       {
         recv_data_len = sizeof (FPC_END_ENROL);
         cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1047,7 +1044,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FPC_ENROLL_CHECK_DUPLICATE:
+    case FP_ENROLL_CHECK_DUPLICATE:
       {
         recv_data_len = sizeof (FPC_IDENTIFY);
         cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1062,7 +1059,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FPC_ENROLL_BINDID:
+    case FP_ENROLL_BINDID:
       {
         FPC_FID_DATA data = {0};
         gsize data_len = 0;
@@ -1116,7 +1113,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FPC_ENROLL_COMMIT:
+    case FP_ENROLL_COMMIT:
       {
         recv_data_len = sizeof (gint32);
         cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1131,7 +1128,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FPC_ENROLL_DICARD:
+    case FP_ENROLL_DICARD:
       {
         cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE;
         cmd_data.request = FPC_CMD_ABORT;
@@ -1144,7 +1141,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FPC_ENROLL_CLEANUP:
+    case FP_ENROLL_CLEANUP:
       {
         if (self->do_cleanup == TRUE)
           {
@@ -1289,7 +1286,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FPC_VERIFY_CAPTURE:
+    case FP_VERIFY_CAPTURE:
       {
         guint32 capture_id = FPC_CAPTUREID_RESERVED;
         fpi_device_report_finger_status_changes (device,
@@ -1307,7 +1304,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FPC_VERIFY_GET_IMG:
+    case FP_VERIFY_GET_IMG:
       {
         cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA;
         cmd_data.request = FPC_CMD_GET_IMG;
@@ -1321,7 +1318,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FPC_VERIFY_IDENTIFY:
+    case FP_VERIFY_IDENTIFY:
       {
         gsize recv_data_len = sizeof (FPC_IDENTIFY);
         cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1336,7 +1333,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FPC_VERIFY_CANCEL:
+    case FP_VERIFY_CANCEL:
       {
         cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE;
         cmd_data.request = FPC_CMD_ABORT;
@@ -1406,7 +1403,7 @@ fpc_clear_sm_run_state (FpiSsm *ssm, FpDevice *device)
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FPC_CLEAR_DELETE_DB:
+    case FP_CLEAR_DELETE_DB:
       {
         if (self->dbid)
           {
@@ -1433,7 +1430,7 @@ fpc_clear_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case FPC_CLEAR_CREATE_DB:
+    case FP_CLEAR_CREATE_DB:
       {
         if (self->dbid)
           {
@@ -1538,7 +1535,7 @@ fpc_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case FPC_INIT:
+    case FP_INIT:
       cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA;
       cmd_data.request = FPC_CMD_INIT;
       cmd_data.value = 0x1;
@@ -1550,7 +1547,7 @@ fpc_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
       fpc_sensor_cmd (self, FALSE, &cmd_data);
       break;
 
-    case FPC_INIT_LOAD_DB:
+    case FP_LOAD_DB:
       {
         gsize recv_data_len = sizeof (FPC_LOAD_DB);
         cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1641,7 +1638,6 @@ fpc_dev_probe (FpDevice *device)
     {
     case 0xFFE0:
     case 0xA305:
-    case 0xA306:
     case 0xD805:
     case 0xDA04:
     case 0xD205:
@@ -1684,7 +1680,7 @@ fpc_dev_open (FpDevice *device)
     }
 
   self->task_ssm = fpi_ssm_new (device, fpc_init_sm_run_state,
-                                FPC_INIT_NUM_STATES);
+                                FP_INIT_NUM_STATES);
 
   fpi_ssm_start (self->task_ssm, fpc_init_ssm_done);
 }
@@ -1696,7 +1692,6 @@ 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);
 }
@@ -1708,8 +1703,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,
-                                     FPC_VERIFY_NUM_STATES,
+                                     FP_VERIFY_NUM_STATES,
-                                     FPC_VERIFY_CANCEL,
+                                     FP_VERIFY_CANCEL,
                                      "verify_identify");
 
   fpi_ssm_start (self->task_ssm, fpc_verify_ssm_done);
@@ -1725,8 +1720,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,
-                                     FPC_ENROLL_NUM_STATES,
+                                     FP_ENROLL_NUM_STATES,
-                                     FPC_ENROLL_DICARD,
+                                     FP_ENROLL_DICARD,
                                      "enroll");
 
   fpi_ssm_start (self->task_ssm, fpc_enroll_ssm_done);
@@ -1777,7 +1772,7 @@ fpc_dev_suspend (FpDevice *device)
     }
 
   g_assert (self->cmd_ssm);
-  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == FPC_CMD_GET_DATA);
+  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == FP_CMD_GET_DATA);
   self->cmd_suspended = TRUE;
   g_cancellable_cancel (self->interrupt_cancellable);
 }
@@ -1799,12 +1794,10 @@ 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) == FPC_CMD_SUSPENDED);
+  g_assert (fpi_ssm_get_cur_state (self->cmd_ssm) == FP_CMD_SUSPENDED);
   self->cmd_suspended = FALSE;
-
+  g_set_object (&self->interrupt_cancellable, g_cancellable_new ());
-  g_clear_object (&self->interrupt_cancellable);
+  fpi_ssm_jump_to_state (self->cmd_ssm, FP_CMD_RESUME);
-  self->interrupt_cancellable = g_cancellable_new ();
-  fpi_ssm_jump_to_state (self->cmd_ssm, FPC_CMD_RESUME);
 }
 
 static void
@@ -1868,8 +1861,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,
-                                     FPC_CLEAR_NUM_STATES,
+                                     FP_CLEAR_NUM_STATES,
-                                     FPC_CLEAR_NUM_STATES,
+                                     FP_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 {
-  FPC_CMD_SEND = 0,
+  FP_CMD_SEND = 0,
-  FPC_CMD_GET_DATA,
+  FP_CMD_GET_DATA,
-  FPC_CMD_SUSPENDED,
+  FP_CMD_SUSPENDED,
-  FPC_CMD_RESUME,
+  FP_CMD_RESUME,
-  FPC_CMD_NUM_STATES,
+  FP_CMD_NUM_STATES,
-} FpcCmdState;
+} FpCmdState;
 
 typedef enum {
-  FPC_INIT = 0,
+  FP_INIT = 0,
-  FPC_INIT_LOAD_DB,
+  FP_LOAD_DB,
-  FPC_INIT_NUM_STATES,
+  FP_INIT_NUM_STATES,
-} FpcInitState;
+} FpInitState;
 
 typedef enum {
-  FPC_ENROLL_ENUM = 0,
+  FP_ENROLL_ENUM = 0,
-  FPC_ENROLL_CREATE,
+  FP_ENROLL_CREATE,
-  FPC_ENROLL_CAPTURE,
+  FP_ENROLL_CAPTURE,
-  FPC_ENROLL_GET_IMG,
+  FP_ENROLL_GET_IMG,
-  FPC_ENROLL_UPDATE,
+  FP_ENROLL_UPDATE,
-  FPC_ENROLL_COMPLETE,
+  FP_ENROLL_COMPLETE,
-  FPC_ENROLL_CHECK_DUPLICATE,
+  FP_ENROLL_CHECK_DUPLICATE,
-  FPC_ENROLL_BINDID,
+  FP_ENROLL_BINDID,
-  FPC_ENROLL_COMMIT,
+  FP_ENROLL_COMMIT,
-  FPC_ENROLL_DICARD,
+  FP_ENROLL_DICARD,
-  FPC_ENROLL_CLEANUP,
+  FP_ENROLL_CLEANUP,
-  FPC_ENROLL_NUM_STATES,
+  FP_ENROLL_NUM_STATES,
-} FpcEnrollState;
+} FpEnrollState;
 
 typedef enum {
-  FPC_VERIFY_CAPTURE = 0,
+  FP_VERIFY_CAPTURE = 0,
-  FPC_VERIFY_GET_IMG,
+  FP_VERIFY_GET_IMG,
-  FPC_VERIFY_IDENTIFY,
+  FP_VERIFY_IDENTIFY,
-  FPC_VERIFY_CANCEL,
+  FP_VERIFY_CANCEL,
-  FPC_VERIFY_NUM_STATES,
+  FP_VERIFY_NUM_STATES,
-} FpcVerifyState;
+} FpVerifyState;
 
 typedef enum {
-  FPC_CLEAR_DELETE_DB = 0,
+  FP_CLEAR_DELETE_DB = 0,
-  FPC_CLEAR_CREATE_DB,
+  FP_CLEAR_CREATE_DB,
-  FPC_CLEAR_NUM_STATES,
+  FP_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 GOODIX_CMD_SEND:
+    case FP_CMD_SEND:
       if (self->cmd_transfer)
         {
           self->cmd_transfer->ssm = ssm;
@@ -254,7 +254,7 @@ fp_cmd_run_state (FpiSsm   *ssm,
         }
       break;
 
-    case GOODIX_CMD_GET_ACK:
+    case FP_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 GOODIX_CMD_GET_DATA:
+    case FP_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,
-                               GOODIX_CMD_NUM_STATES);
+                               FP_CMD_NUM_STATES);
 
   fpi_ssm_set_data (self->cmd_ssm, data, (GDestroyNotify) fp_cmd_ssm_done_data_free);
 
@@ -480,35 +480,6 @@ fp_verify_cb (FpiDeviceGoodixMoc  *self,
 
 }
 
-static void
-fp_verify_finger_mode_cb (FpiDeviceGoodixMoc  *self,
-                          gxfp_cmd_response_t *resp,
-                          GError              *error)
-{
-  if (error)
-    {
-      fpi_ssm_mark_failed (self->task_ssm, error);
-      return;
-    }
-  /* if reach max timeout(5sec) finger not up, try again */
-  if (resp->finger_status.status == GX_ERROR_WAIT_FINGER_UP_TIMEOUT)
-    {
-      fpi_ssm_jump_to_state (self->task_ssm, GOODIX_VERIFY_WAIT_FINGER_UP);
-      return;
-    }
-  else if (resp->finger_status.status != GX_SUCCESS)
-    {
-      fpi_ssm_mark_failed (self->task_ssm,
-                           fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                                     "Switch finger mode failed"));
-      return;
-    }
-  fpi_device_report_finger_status_changes (FP_DEVICE (self),
-                                           FP_FINGER_STATUS_NONE,
-                                           FP_FINGER_STATUS_PRESENT);
-  fpi_ssm_next_state (self->task_ssm);
-}
-
 static void
 fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
 {
@@ -522,7 +493,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case GOODIX_VERIFY_PWR_BTN_SHIELD_ON:
+    case FP_VERIFY_PWR_BTN_SHIELD_ON:
       goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_ON,
                          false,
                          NULL,
@@ -530,7 +501,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_pwr_btn_shield_cb);
       break;
 
-    case GOODIX_VERIFY_CAPTURE:
+    case FP_VERIFY_CAPTURE:
       fpi_device_report_finger_status_changes (device,
                                                FP_FINGER_STATUS_NEEDED,
                                                FP_FINGER_STATUS_NONE);
@@ -541,7 +512,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_verify_capture_cb);
       break;
 
-    case GOODIX_VERIFY_IDENTIFY:
+    case FP_VERIFY_IDENTIFY:
       goodix_sensor_cmd (self, MOC_CMD0_IDENTIFY, MOC_CMD1_DEFAULT,
                          false,
                          (const guint8 *) nonce,
@@ -549,18 +520,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_verify_cb);
       break;
 
-    case GOODIX_VERIFY_WAIT_FINGER_UP:
+    case FP_VERIFY_PWR_BTN_SHIELD_OFF:
-      {
-        guint8 dummy = 0;
-        goodix_sensor_cmd (self, MOC_CMD0_FINGER_MODE, MOC_CMD1_SET_FINGER_UP,
-                           true,
-                           &dummy,
-                           1,
-                           fp_verify_finger_mode_cb);
-      }
-      break;
-
-    case GOODIX_VERIFY_PWR_BTN_SHIELD_OFF:
       goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_OFF,
                          false,
                          NULL,
@@ -722,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, GOODIX_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
       return;
     }
   fpi_device_report_finger_status_changes (FP_DEVICE (self),
@@ -740,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, GOODIX_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
       return;
     }
   else
@@ -786,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, GOODIX_ENROLL_CHECK_DUPLICATE);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CHECK_DUPLICATE);
       return;
     }
 
@@ -852,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, GOODIX_ENROLL_WAIT_FINGER_UP);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_WAIT_FINGER_UP);
       return;
     }
   else if (resp->finger_status.status != GX_SUCCESS)
@@ -867,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, GOODIX_ENROLL_CAPTURE);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
       return;
     }
   fpi_ssm_next_state (self->task_ssm);
@@ -893,7 +853,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case GOODIX_ENROLL_PWR_BTN_SHIELD_ON:
+    case FP_ENROLL_PWR_BTN_SHIELD_ON:
       {
         goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_ON,
                            false,
@@ -903,7 +863,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case GOODIX_ENROLL_ENUM:
+    case FP_ENROLL_ENUM:
       {
         goodix_sensor_cmd (self, MOC_CMD0_GETFINGERLIST, MOC_CMD1_DEFAULT,
                            false,
@@ -913,7 +873,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case GOODIX_ENROLL_CREATE:
+    case FP_ENROLL_CREATE:
       {
         goodix_sensor_cmd (self, MOC_CMD0_ENROLL_INIT, MOC_CMD1_DEFAULT,
                            false,
@@ -923,7 +883,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case GOODIX_ENROLL_CAPTURE:
+    case FP_ENROLL_CAPTURE:
       fpi_device_report_finger_status_changes (device,
                                                FP_FINGER_STATUS_NEEDED,
                                                FP_FINGER_STATUS_NONE);
@@ -934,7 +894,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_enroll_capture_cb);
       break;
 
-    case GOODIX_ENROLL_UPDATE:
+    case FP_ENROLL_UPDATE:
       dummy[0] = 1;
       dummy[1] = self->sensorcfg->config[2];
       dummy[2] = self->sensorcfg->config[3];
@@ -945,7 +905,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_enroll_update_cb);
       break;
 
-    case GOODIX_ENROLL_WAIT_FINGER_UP:
+    case FP_ENROLL_WAIT_FINGER_UP:
       dummy[0] = 0;
       goodix_sensor_cmd (self, MOC_CMD0_FINGER_MODE, MOC_CMD1_SET_FINGER_UP,
                          true,
@@ -954,7 +914,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_finger_mode_cb);
       break;
 
-    case GOODIX_ENROLL_CHECK_DUPLICATE:
+    case FP_ENROLL_CHECK_DUPLICATE:
       goodix_sensor_cmd (self, MOC_CMD0_CHECK4DUPLICATE, MOC_CMD1_DEFAULT,
                          false,
                          (const guint8 *) &dummy,
@@ -962,7 +922,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_enroll_check_duplicate_cb);
       break;
 
-    case GOODIX_ENROLL_COMMIT:
+    case FP_ENROLL_COMMIT:
       {
         fpi_device_get_enroll_data (device, &print);
         user_id = fpi_print_generate_user_id (print);
@@ -1015,7 +975,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
       }
       break;
 
-    case GOODIX_ENROLL_PWR_BTN_SHIELD_OFF:
+    case FP_ENROLL_PWR_BTN_SHIELD_OFF:
       {
         goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_OFF,
                            false,
@@ -1106,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, GOODIX_INIT_RESET_DEVICE);
+      fpi_ssm_jump_to_state (self->task_ssm, FP_INIT_RESET_DEVICE);
     }
   else
     {
@@ -1147,7 +1107,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
 
   switch (fpi_ssm_get_cur_state (ssm))
     {
-    case GOODIX_INIT_VERSION:
+    case FP_INIT_VERSION:
       goodix_sensor_cmd (self, MOC_CMD0_GET_VERSION, MOC_CMD1_DEFAULT,
                          false,
                          &dummy,
@@ -1155,7 +1115,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_init_version_cb);
       break;
 
-    case GOODIX_INIT_CONFIG:
+    case FP_INIT_CONFIG:
       goodix_sensor_cmd (self, MOC_CMD0_UPDATE_CONFIG, MOC_CMD1_WRITE_CFG_TO_FLASH,
                          false,
                          (guint8 *) self->sensorcfg,
@@ -1163,7 +1123,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_init_config_cb);
       break;
 
-    case GOODIX_INIT_TEMPLATE_LIST:
+    case FP_INIT_TEMPLATE_LIST:
       /* List prints to check whether the template DB was corrupted.
        * As of 2022-06-13 there is a known firmware issue that can cause the
        * stored templates for Linux to be corrupted when the Windows storage
@@ -1178,7 +1138,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
                          fp_init_cb_reset_or_complete);
       break;
 
-    case GOODIX_INIT_RESET_DEVICE:
+    case FP_INIT_RESET_DEVICE:
       fp_warn ("Resetting device storage, you will need to enroll all prints again!");
       goodix_sensor_cmd (self, MOC_CMD0_DELETETEMPLATE, MOC_CMD1_DELETE_ALL,
                          FALSE,
@@ -1417,7 +1377,6 @@ gx_fp_probe (FpDevice *device)
     case 0x60A2:
     case 0x60A4:
     case 0x6014:
-    case 0x6090:
     case 0x6092:
     case 0x6094:
     case 0x609A:
@@ -1438,7 +1397,6 @@ gx_fp_probe (FpDevice *device)
     case 0x6582:
     case 0x6A94:
     case 0x659A:
-    case 0x6890:
       self->max_enroll_stage = 12;
       break;
 
@@ -1494,7 +1452,7 @@ gx_fp_init (FpDevice *device)
     }
 
   self->task_ssm = fpi_ssm_new (device, fp_init_sm_run_state,
-                                GOODIX_INIT_NUM_STATES);
+                                FP_INIT_NUM_STATES);
 
   fpi_ssm_start (self->task_ssm, fp_init_ssm_done);
 
@@ -1525,7 +1483,9 @@ gx_fp_exit_cb (FpiDeviceGoodixMoc  *self,
                gxfp_cmd_response_t *resp,
                GError              *error)
 {
-  if (resp && resp->result >= GX_FAILED)
+
+
+  if (resp->result >= GX_FAILED)
     fp_dbg ("Setting power button shield failed, result: 0x%x", resp->result);
   self->is_power_button_shield_on = false;
   gx_fp_release_interface (self, error);
@@ -1560,8 +1520,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,
-                                     GOODIX_VERIFY_NUM_STATES,
+                                     FP_VERIFY_NUM_STATES,
-                                     GOODIX_VERIFY_PWR_BTN_SHIELD_OFF,
+                                     FP_VERIFY_PWR_BTN_SHIELD_OFF,
                                      "verify");
 
   fpi_ssm_start (self->task_ssm, fp_verify_ssm_done);
@@ -1577,8 +1537,8 @@ gx_fp_enroll (FpDevice *device)
   self->enroll_stage = 0;
 
   self->task_ssm = fpi_ssm_new_full (device, fp_enroll_sm_run_state,
-                                     GOODIX_ENROLL_NUM_STATES,
+                                     FP_ENROLL_NUM_STATES,
-                                     GOODIX_ENROLL_PWR_BTN_SHIELD_OFF,
+                                     FP_ENROLL_PWR_BTN_SHIELD_OFF,
                                      "enroll");
 
   fpi_ssm_start (self->task_ssm, fp_enroll_ssm_done);
@@ -1668,7 +1628,6 @@ fpi_device_goodixmoc_init (FpiDeviceGoodixMoc *self)
 static const FpIdEntry id_table[] = {
   { .vid = 0x27c6,  .pid = 0x5840,  },
   { .vid = 0x27c6,  .pid = 0x6014,  },
-  { .vid = 0x27c6,  .pid = 0x6090,  },
   { .vid = 0x27c6,  .pid = 0x6092,  },
   { .vid = 0x27c6,  .pid = 0x6094,  },
   { .vid = 0x27c6,  .pid = 0x609A,  },
@@ -1698,9 +1657,7 @@ static const FpIdEntry id_table[] = {
   { .vid = 0x27c6,  .pid = 0x659C,  },
   { .vid = 0x27c6,  .pid = 0x6A94,  },
   { .vid = 0x27c6,  .pid = 0x6512,  },
-  { .vid = 0x27c6,  .pid = 0x6890,  },
   { .vid = 0x27c6,  .pid = 0x689A,  },
-  { .vid = 0x27c6,  .pid = 0x66A9,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 

libfprint/drivers/goodixmoc/goodix.h

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

libfprint/drivers/realtek/realtek.c

@@ -29,7 +29,6 @@ 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,7 +36,6 @@ 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,  },
@@ -46,21 +45,16 @@ 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 */
 };
 
@@ -1260,12 +1254,6 @@ dev_probe (FpDevice *device)
       return;
     }
 
-  if (!g_usb_device_reset (usb_dev, &error))
-    {
-      fp_dbg ("%s g_usb_device_reset failed %s", G_STRFUNC, error->message);
-      goto err_close;
-    }
-
   if (!g_usb_device_claim_interface (usb_dev, 0, 0, &error))
     goto err_close;
 

libfprint/fp-device.c

@@ -483,9 +483,6 @@ 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

@@ -64,12 +64,10 @@ static const FpIdEntry allowlist_id_table[] = {
   { .vid = 0x06cb, .pid = 0x008a },
   { .vid = 0x06cb, .pid = 0x009a },
   { .vid = 0x06cb, .pid = 0x009b },
-  { .vid = 0x06cb, .pid = 0x00a1 },
   { .vid = 0x06cb, .pid = 0x00a2 },
   { .vid = 0x06cb, .pid = 0x00a8 },
   { .vid = 0x06cb, .pid = 0x00b7 },
   { .vid = 0x06cb, .pid = 0x00bb },
-  { .vid = 0x06cb, .pid = 0x00bc },
   { .vid = 0x06cb, .pid = 0x00be },
   { .vid = 0x06cb, .pid = 0x00cb },
   { .vid = 0x06cb, .pid = 0x00c9 },
@@ -78,6 +76,7 @@ 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 },
@@ -98,11 +97,9 @@ static const FpIdEntry allowlist_id_table[] = {
   { .vid = 0x0bda, .pid = 0x5812 },
   { .vid = 0x10a5, .pid = 0x0007 },
   { .vid = 0x10a5, .pid = 0x9200 },
-  { .vid = 0x10a5, .pid = 0x9201 },
   { .vid = 0x10a5, .pid = 0x9800 },
   { .vid = 0x10a5, .pid = 0xa120 },
   { .vid = 0x10a5, .pid = 0xa900 },
-  { .vid = 0x10a5, .pid = 0xa921 },
   { .vid = 0x10a5, .pid = 0xe340 },
   { .vid = 0x1188, .pid = 0x9545 },
   { .vid = 0x138a, .pid = 0x0007 },
@@ -123,6 +120,7 @@ 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 },
@@ -156,14 +154,12 @@ static const FpIdEntry allowlist_id_table[] = {
   { .vid = 0x27c6, .pid = 0x581a },
   { .vid = 0x27c6, .pid = 0x589a },
   { .vid = 0x27c6, .pid = 0x5f10 },
-  { .vid = 0x27c6, .pid = 0x5f91 },
   { .vid = 0x27c6, .pid = 0x6382 },
   { .vid = 0x2808, .pid = 0x9338 },
   { .vid = 0x2808, .pid = 0x9348 },
   { .vid = 0x2808, .pid = 0x93a9 },
   { .vid = 0x2808, .pid = 0xa658 },
   { .vid = 0x2808, .pid = 0xc652 },
-  { .vid = 0x2808, .pid = 0xa553 },
   { .vid = 0x298d, .pid = 0x2020 },
   { .vid = 0x298d, .pid = 0x2033 },
   { .vid = 0x2df0, .pid = 0x0003 },

libfprint/meson.build

@@ -255,7 +255,6 @@ libnbis = static_library('nbis',
         '-Wno-discarded-qualifiers',
         '-Wno-array-bounds',
         '-Wno-array-parameter',
-        '-Wno-unused-but-set-variable',
     ]),
     install: false)
 
@@ -411,7 +410,6 @@ 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.10',
+    version: '1.94.9',
     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/a306/10
+E: PRODUCT=10a5/ffe0/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:222709
+E: ID_MODEL=FPC_L:0001_FW:127010
-E: ID_MODEL_ENC=FPC\x20L:0001\x20FW:222709
+E: ID_MODEL_ENC=FPC\x20L:0001\x20FW:127010
-E: ID_MODEL_ID=a306
+E: ID_MODEL_ID=ffe0
 E: ID_REVISION=0010
-E: ID_SERIAL=FPC_FPC_L:0001_FW:222709
+E: ID_SERIAL=FPC_FPC_L:0001_FW:127010
 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=a306\n
+A: idProduct=ffe0\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:222709\n
+A: product=FPC L:0001 FW:127010\n
 A: quirks=0x0\n
 A: removable=removable\n
 A: rx_lanes=1\n

tests/valgrind-python.supp

@@ -95,24 +95,3 @@
    fun:realloc
    obj:/usr/lib/*/libpython3*.so.*
 }
-
-{
-   ignore__pygobject_possible_leaks
-   Memcheck:Leak
-   match-leak-kinds: possible
-   ...
-   obj:/usr/lib*/python*/site-packages/gi/_gi.cpython-*.so
-   obj:/usr/lib*/libpython3.*.so.*
-}
-
-{
-   ignore__pygobject_instance_leaks
-   Memcheck:Leak
-   match-leak-kinds: definite
-   ...
-   fun:g_type_create_instance
-   fun:gi_info_new_full
-   ...
-   obj:/usr/lib*/python*/site-packages/gi/_gi.cpython-*.so
-   obj:/usr/lib*/libpython3.*.so.*
-}