elan: Make 0c3d not rotate before assembling

NEWS

@@ -1,16 +1,6 @@
 This file lists notable changes in each release. For the full history of all
 changes, see ChangeLog.
 
-2021-11-02: v1.94.3 release
-
-Highlights:
- * Ensure idle mainloop before completing enumeration (fprintd#119)
- * It is now possible to extend already enrolled prints
- * elanspi: Fix timeout error with some hardware (#438)
- * elanspi: Fix cancellation issues
- * goodixmoc: Return matching device print; fixes duplicate checking (#444)
- * goodixmoc: Support clearing the storage (usually unused)
-
 2021-11-02: v1.94.2 release
 
 Highlights:

README

@@ -1,10 +1,9 @@
-# libfprint
+libfprint
+=========
 
 libfprint is part of the fprint project:
 https://fprint.freedesktop.org/
 
-## History
-
 libfprint was originally developed as part of an academic project at the
 University of Manchester with the aim of hiding differences between different
 consumer fingerprint scanners and providing a single uniform API to application
@@ -16,8 +15,6 @@ from this one, although I try to keep them as similar as possible (I'm not
 hiding anything in the academic branch, it's just the open source release
 contains some commits excluded from the academic project).
 
-## License
-
 THE UNIVERSITY OF MANCHESTER DOES NOT ENDORSE THIS THIS SOFTWARE RELEASE AND
 IS IN NO WAY RESPONSIBLE FOR THE CODE CONTAINED WITHIN, OR ANY DAMAGES CAUSED
 BY USING OR DISTRIBUTING THE SOFTWARE. Development does not happen on

TODO

@@ -0,0 +1,30 @@
+LIBRARY
+=======
+test suite against NFIQ compliance set
+make library optionally asynchronous and maybe thread-safe
+nbis cleanups
+API function to determine if img device supports uncond. capture
+race-free way of saying "save this print but don't overwrite"
+
+NEW DRIVERS
+===========
+Sunplus 895 driver
+AES3400/3500 driver
+ID Mouse driver
+Support for 2nd generation MS devices
+Support for 2nd generation UPEK devices
+
+IMAGING
+=======
+ignore first frame or two with aes2501
+aes2501: increase threshold "sum" for end-of-image detection
+aes2501 gain calibration
+aes4000 gain calibration
+aes4000 resampling
+PPMM parameter to get_minutiae seems to have no effect
+nbis minutiae should be stored in endian-independent format
+
+PORTABILITY
+===========
+OpenBSD can't do -Wshadow or visibility
+OpenBSD: add compat codes for ENOTSUP ENODATA and EPROTO

data/autosuspend.hwdb

@@ -133,7 +133,6 @@ usb:v04F3p0C32*
 usb:v04F3p0C33*
 usb:v04F3p0C3D*
 usb:v04F3p0C42*
-usb:v04F3p0C4B*
 usb:v04F3p0C4D*
 usb:v04F3p0C4F*
 usb:v04F3p0C63*
@@ -145,7 +144,6 @@ usb:v04F3p0C58*
 # Supported by libfprint driver elanmoc
 usb:v04F3p0C7D*
 usb:v04F3p0C7E*
-usb:v04F3p0C82*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
@@ -183,13 +181,13 @@ usb:v06CBp00DF*
 usb:v06CBp00F9*
 usb:v06CBp00FC*
 usb:v06CBp00C2*
+usb:v06CBp00C9*
 usb:v06CBp0100*
 usb:v06CBp00F0*
 usb:v06CBp0103*
 usb:v06CBp0123*
 usb:v06CBp0126*
 usb:v06CBp0129*
-usb:v06CBp0168*
  ID_AUTOSUSPEND=1
  ID_PERSIST=0
 
@@ -259,6 +257,7 @@ usb:v138Ap0091*
 # Known unsupported devices
 usb:v04F3p036B*
 usb:v04F3p0C00*
+usb:v04F3p0C4B*
 usb:v04F3p0C4C*
 usb:v04F3p0C57*
 usb:v04F3p0C5E*
@@ -269,19 +268,15 @@ usb:v06CBp008A*
 usb:v06CBp009A*
 usb:v06CBp009B*
 usb:v06CBp00A2*
-usb:v06CBp00A8*
 usb:v06CBp00B7*
 usb:v06CBp00BB*
 usb:v06CBp00BE*
 usb:v06CBp00C4*
 usb:v06CBp00CB*
-usb:v06CBp00C9*
 usb:v06CBp00D8*
 usb:v06CBp00DA*
-usb:v06CBp00DC*
 usb:v06CBp00E7*
 usb:v06CBp00E9*
-usb:v06CBp00FD*
 usb:v0A5Cp5801*
 usb:v0A5Cp5805*
 usb:v0A5Cp5834*
@@ -293,7 +288,6 @@ usb:v0A5Cp5844*
 usb:v0A5Cp5845*
 usb:v0BDAp5812*
 usb:v10A5p0007*
-usb:v10A5p9200*
 usb:v1188p9545*
 usb:v138Ap0007*
 usb:v138Ap003A*
@@ -311,7 +305,6 @@ usb:v1491p0088*
 usb:v16D1p1027*
 usb:v1C7Ap0300*
 usb:v1C7Ap0575*
-usb:v1C7Ap0576*
 usb:v27C6p5042*
 usb:v27C6p5110*
 usb:v27C6p5117*
@@ -331,9 +324,7 @@ usb:v27C6p55A2*
 usb:v27C6p55A4*
 usb:v27C6p55B4*
 usb:v27C6p5740*
-usb:v27C6p5E0A*
 usb:v2808p9338*
-usb:v298Dp2020*
 usb:v298Dp2033*
 usb:v3538p0930*
  ID_AUTOSUSPEND=1

examples/identify.c

@@ -143,7 +143,6 @@ on_identify_cb (FpDevice *dev, FpPrint *match, FpPrint *print,
   if (match)
     {
       g_autoptr(FpPrint) matched_print = g_object_ref (match);
-      const GDate *date;
       char date_str[128] = {};
 
       identify_data->ret_value = EXIT_SUCCESS;
@@ -156,8 +155,7 @@ on_identify_cb (FpDevice *dev, FpPrint *match, FpPrint *print,
             matched_print = g_steal_pointer (&stored_print);
         }
 
-      date = fp_print_get_enroll_date (matched_print);
+      if (fp_print_get_enroll_date (matched_print))
-      if (date && g_date_valid (date))
         g_date_strftime (date_str, G_N_ELEMENTS (date_str), "%Y-%m-%d\0",
                          fp_print_get_enroll_date (matched_print));
       else

examples/manage-prints.c

@@ -161,7 +161,7 @@ on_list_completed (FpDevice     *dev,
                    finger_to_string (fp_print_get_finger (print)),
                    fp_print_get_username (print));
 
-          if (date && g_date_valid (date))
+          if (date)
             {
               g_date_strftime (buf, G_N_ELEMENTS (buf), "%Y-%m-%d\0", date);
               g_print (", enrolled on %s", buf);

examples/verify.c

@@ -130,14 +130,12 @@ on_match_cb (FpDevice *dev, FpPrint *match, FpPrint *print,
 
   if (match)
     {
-      const GDate *date = fp_print_get_enroll_date (match);
+      char date_str[128];
-      char date_str[128] = "<unknown>";
 
       verify_data->ret_value = EXIT_SUCCESS;
 
-      if (date && g_date_valid (date))
+      g_date_strftime (date_str, G_N_ELEMENTS (date_str), "%Y-%m-%d\0",
-        g_date_strftime (date_str, G_N_ELEMENTS (date_str), "%Y-%m-%d\0",
+                       fp_print_get_enroll_date (match));
-                         fp_print_get_enroll_date (match));
       g_debug ("Match report: device %s matched finger %s successifully "
                "with print %s, enrolled on date %s by user %s",
                fp_device_get_name (dev),

libfprint/drivers/elan.h

@@ -31,9 +31,10 @@
 #define ELAN_0907 (1 << 0)
 #define ELAN_0C03 (1 << 1)
 #define ELAN_0C42 (1 << 2)
+#define ELAN_0C3D (1 << 3)
 
 /* devices which don't require frame rotation before assembling */
-#define ELAN_NOT_ROTATED ELAN_0C03
+#define ELAN_NOT_ROTATED (ELAN_0C03 | ELAN_0C3D)
 
 /* min FW version that supports calibration */
 #define ELAN_MIN_CALIBRATION_FW 0x0138
@@ -213,9 +214,8 @@ static const FpIdEntry elan_id_table[] = {
   {.vid = ELAN_VEND_ID,  .pid = 0x0c31, .driver_data = ELAN_ALL_DEV},
   {.vid = ELAN_VEND_ID,  .pid = 0x0c32, .driver_data = ELAN_ALL_DEV},
   {.vid = ELAN_VEND_ID,  .pid = 0x0c33, .driver_data = ELAN_ALL_DEV},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c3d, .driver_data = ELAN_ALL_DEV},
+  {.vid = ELAN_VEND_ID,  .pid = 0x0c3d, .driver_data = ELAN_0C3D},
   {.vid = ELAN_VEND_ID,  .pid = 0x0c42, .driver_data = ELAN_0C42},
-  {.vid = ELAN_VEND_ID,  .pid = 0x0c4b, .driver_data = ELAN_ALL_DEV},
   {.vid = ELAN_VEND_ID,  .pid = 0x0c4d, .driver_data = ELAN_ALL_DEV},
   {.vid = ELAN_VEND_ID,  .pid = 0x0c4f, .driver_data = ELAN_ALL_DEV},
   {.vid = ELAN_VEND_ID,  .pid = 0x0c63, .driver_data = ELAN_ALL_DEV},

libfprint/drivers/elanmoc/elanmoc.c

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

libfprint/drivers/elanspi.c

@@ -63,7 +63,6 @@ struct _FpiDeviceElanSpi
       guint16 gdac_step;
       guint16 best_gdac;
       guint16 best_meandiff;
-      guint16 target_mean;
     } hv_data;
   };
 
@@ -409,10 +408,6 @@ elanspi_determine_sensor (FpiDeviceElanSpi *self, GError **err)
       self->frame_width = self->sensor_width;
       self->frame_height = self->sensor_height > ELANSPI_MAX_FRAME_HEIGHT ? ELANSPI_MAX_FRAME_HEIGHT : self->sensor_height;
     }
-
-  /* check x571 flag */
-  if (self->sensor_id == 0xe)
-    self->hv_data.target_mean = (fpi_device_get_driver_data (FP_DEVICE (self)) & ELANSPI_QUIRK_X571 ? ELANSPI_HV_X571_CALIBRATION_TARGET_MEAN : ELANSPI_HV_CALIBRATION_TARGET_MEAN);
 }
 
 static void
@@ -547,7 +542,7 @@ elanspi_write_regtable (FpiDeviceElanSpi *self, const struct elanspi_regtable *
 
   for (int i = 0; table->entries[i].table; i += 1)
     {
-      if (table->entries[i].sid == self->sensor_id && table->entries[i].quirk == (fpi_device_get_driver_data (FP_DEVICE (self)) & ELANSPI_QUIRK_MASK))
+      if (table->entries[i].sid == self->sensor_id)
         {
           starting_entry = table->entries[i].table;
           break;
@@ -697,8 +692,6 @@ static void
 elanspi_capture_hv_image_handler (FpiSpiTransfer *transfer, FpDevice *dev, gpointer unused_data, GError *error)
 {
   FpiDeviceElanSpi *self = FPI_DEVICE_ELANSPI (dev);
-  ptrdiff_t outptr = 0, inptr = 0;
-  guint16 value = 0;
 
   if (error)
     {
@@ -706,39 +699,24 @@ elanspi_capture_hv_image_handler (FpiSpiTransfer *transfer, FpDevice *dev, gpoin
       return;
     }
 
-  if (fpi_device_get_driver_data (dev) & ELANSPI_QUIRK_X571)
+  int i, outptr;
+  guint16 value = 0;
+
+  for (i = 0, outptr = 0; i < transfer->length_rd && outptr < (self->sensor_height * self->sensor_width * 2); i += 1)
     {
-      /* decode image in x571 mode (just copy and fix endian) */
+      if (transfer->buffer_rd[i] != 0xff)
-      for (int y = 0; y < self->sensor_height; y += 1)
         {
-          inptr += 2; /* 2 dummy bytes per line at start */
+          if (outptr % 2)
-          for (int x = 0; x < self->sensor_width; x += 1)
             {
-              self->last_image[outptr / 2] = transfer->buffer_rd[inptr] + transfer->buffer_rd[inptr + 1] * 0x100;
+              value <<= 8;
-              inptr += 2;
+              value |= transfer->buffer_rd[i];
-              outptr += 2;
+              self->last_image[outptr / 2] = value;
             }
-        }
+          else
-    }
-  else
-    {
-      /* decode image (normal case; with weird 0xff checks) */
-      for (inptr = 0, outptr = 0; inptr < transfer->length_rd && outptr < (self->sensor_height * self->sensor_width * 2); inptr += 1)
-        {
-          if (transfer->buffer_rd[inptr] != 0xff)
             {
-              if (outptr % 2)
+              value = transfer->buffer_rd[i];
-                {
-                  value <<= 8;
-                  value |= transfer->buffer_rd[inptr];
-                  self->last_image[outptr / 2] = value;
-                }
-              else
-                {
-                  value = transfer->buffer_rd[inptr];
-                }
-              outptr += 1;
             }
+          outptr += 1;
         }
     }
 
@@ -796,17 +774,12 @@ elanspi_capture_hv_handler (FpiSsm *ssm, FpDevice *dev)
           return;
         }
       /* otherwise, read the image
-       * the hv sensors seem to use variable-length padding(?) this is only tested on the 0xe sensors
+       * the hv sensors seem to  use 128 bytes of padding(?) this is only tested on the 0xe sensors */
-       *
-       * in the x571 mode, the padding appears to be disabled and it just has 2 bytes of junk */
       xfer = fpi_spi_transfer_new (dev, self->spi_fd);
       xfer->ssm = ssm;
       fpi_spi_transfer_write (xfer, 2);
-      xfer->buffer_wr[0] = 0x10;                   /* receieve line/image */
+      xfer->buffer_wr[0] = 0x10;                   /* receieve line */
-      if (fpi_device_get_driver_data (dev) & ELANSPI_QUIRK_X571)
+      fpi_spi_transfer_read (xfer, self->sensor_height * (self->sensor_width * 2 + 48));
-        fpi_spi_transfer_read (xfer, self->sensor_height * (self->sensor_width * 2 + 2) - 2);
-      else
-        fpi_spi_transfer_read (xfer, self->sensor_height * (self->sensor_width * 2 + 48));
       fpi_spi_transfer_submit (xfer, fpi_device_get_cancellable (dev), elanspi_capture_hv_image_handler, NULL);
       return;
     }
@@ -900,7 +873,7 @@ elanspi_calibrate_hv_handler (FpiSsm *ssm, FpDevice *dev)
 
     case ELANSPI_CALIBHV_PROCESS:
       /* compute mean */
-      mean_diff = abs (elanspi_mean_image (self, self->last_image) - self->hv_data.target_mean);
+      mean_diff = abs (elanspi_mean_image (self, self->last_image) - ELANSPI_HV_CALIBRATION_TARGET_MEAN);
       if (mean_diff < 100)
         {
           fp_dbg ("<calibhv> calibration ok (mdiff < 100 w/ gdac=%04x)", self->hv_data.gdac_value);
@@ -923,7 +896,7 @@ elanspi_calibrate_hv_handler (FpiSsm *ssm, FpDevice *dev)
           return;
         }
       /* update gdac */
-      if (elanspi_mean_image (self, self->last_image) < self->hv_data.target_mean)
+      if (elanspi_mean_image (self, self->last_image) < ELANSPI_HV_CALIBRATION_TARGET_MEAN)
         self->hv_data.gdac_value -= self->hv_data.gdac_step;
       else
         self->hv_data.gdac_value += self->hv_data.gdac_step;

libfprint/drivers/elanspi.h

@@ -71,7 +71,6 @@ struct elanspi_regtable
   struct
   {
     unsigned char                   sid;
-    unsigned                        quirk;
     const struct elanspi_reg_entry *table;
   } entries[];
 };
@@ -173,11 +172,11 @@ static const struct elanspi_reg_entry elanspi_calibration_table_id0[] = {
 static const struct elanspi_regtable elanspi_calibration_table_old = {
   .other = elanspi_calibration_table_default,
   .entries = {
-    { .sid = 0x0, .quirk = 0, .table = elanspi_calibration_table_id0 },
+    { .sid = 0x0, .table = elanspi_calibration_table_id0 },
-    { .sid = 0x5, .quirk = 0, .table = elanspi_calibration_table_id57 },
+    { .sid = 0x5, .table = elanspi_calibration_table_id57 },
-    { .sid = 0x6, .quirk = 0, .table = elanspi_calibration_table_id6 },
+    { .sid = 0x6, .table = elanspi_calibration_table_id6 },
-    { .sid = 0x7, .quirk = 0, .table = elanspi_calibration_table_id57 },
+    { .sid = 0x7, .table = elanspi_calibration_table_id57 },
-    { .sid = 0x0, .quirk = 0, .table = NULL }
+    { .sid = 0x0, .table = NULL }
   }
 };
 
@@ -313,133 +312,20 @@ static const struct elanspi_reg_entry elanspi_calibration_table_page1_id14[] = {
   {0xff, 0xff}
 };
 
-static const struct elanspi_reg_entry elanspi_calibration_table_page0_id14_x571[] = {
+static const struct elanspi_regtable elanspi_calibration_table_new_page0 = {
-  {0x00, 0x5a},
+  .other = NULL,
-  {0x01, 0x00},
+  .entries = {
-  {0x02, 0x4f},
+    { .sid = 0xe, .table = elanspi_calibration_table_page0_id14 },
-  {0x03, 0x00},
+    { .sid = 0x0, .table = NULL }
-  {0x09, 0x04},
+  }
-  {0x04, 0x4f},
-  {0x05, 0xa0},
-  {0x06, 0x57},
-  {0x07, 0x02},
-  {0x08, 0x00},
-  {0x0a, 0x63},
-  {0x0b, 0x01},
-  {0x0c, 0x08},
-  {0x0d, 0x00},
-  {0x0e, 0x00},
-  {0x0f, 0x13},
-  {0x10, 0x38},
-  {0x11, 0x01},
-  {0x12, 0x04},
-  {0x13, 0x00},
-  {0x14, 0x00},
-  {0x15, 0x04},
-  {0x16, 0x02},
-  {0x17, 0x00},
-  {0x18, 0x01},
-  {0x19, 0xf4},
-  {0x1a, 0x00},
-  {0x1b, 0x00},
-  {0x1c, 0x00},
-  {0x1d, 0x00},
-  {0x1e, 0x00},
-  {0x1f, 0x00},
-  {0x20, 0x00},
-  {0x21, 0x00},
-  {0x22, 0x06},
-  {0x23, 0x00},
-  {0x24, 0x00},
-  {0x25, 0x00},
-  {0x26, 0x00},
-  {0x27, 0xff},
-  {0x28, 0x00},
-  {0x29, 0x04},
-  {0x2b, 0xe2},
-  {0x2e, 0xd0},
-  {0x2f, 0x40},
-  {0x30, 0x01},
-  {0x31, 0x38},
-  {0x32, 0x00},
-  {0x33, 0x00},
-  {0x34, 0x00},
-  {0x35, 0x1f},
-  {0x36, 0xff},
-  {0x37, 0x00},
-  {0x38, 0x00},
-  {0x39, 0x00},
-  {0x3a, 0x00},
-  {0x2a, 0x5f},
-  {0x2c, 0x10},
-  {0xff, 0xff}
 };
 
-static const struct elanspi_reg_entry elanspi_calibration_table_page1_id14_x571[] = {
+static const struct elanspi_regtable elanspi_calibration_table_new_page1 = {
-  {0x00, 0xfb},
+  .other = NULL,
-  {0x01, 0xff},
+  .entries = {
-  {0x02, 0x7f},
+    { .sid = 0xe, .table = elanspi_calibration_table_page1_id14 },
-  {0x03, 0xd4},
+    { .sid = 0x0, .table = NULL }
-  {0x04, 0x7d},
+  }
-  {0x05, 0x19},
-  {0x06, 0x80},
-  {0x07, 0x40},
-  {0x08, 0x11},
-  {0x09, 0x00},
-  {0x0a, 0x00},
-  {0x0b, 0x00},
-  {0x0c, 0x00},
-  {0x0d, 0x00},
-  {0x0e, 0x32},
-  {0x0f, 0x00},
-  {0x10, 0x00},
-  {0x11, 0x32},
-  {0x12, 0x02},
-  {0x13, 0x08},
-  {0x14, 0x5c},
-  {0x15, 0x01},
-  {0x16, 0x15},
-  {0x17, 0x01},
-  {0x18, 0x14},
-  {0x19, 0x01},
-  {0x1a, 0x14},
-  {0x1b, 0x01},
-  {0x1c, 0x16},
-  {0x1d, 0x01},
-  {0x1e, 0x0b},
-  {0x1f, 0x01},
-  {0x20, 0x0b},
-  {0x21, 0x02},
-  {0x22, 0x08},
-  {0x23, 0x29},
-  {0x24, 0x00},
-  {0x25, 0x0c},
-  {0x26, 0x1b},
-  {0x27, 0x15},
-  {0x28, 0x1b},
-  {0x29, 0x15},
-  {0x2a, 0x00},
-  {0x2b, 0x00},
-  {0x2c, 0x01},
-  {0x2d, 0x16},
-  {0x2e, 0x01},
-  {0x2f, 0x16},
-  {0x30, 0x04},
-  {0x31, 0x44},
-  {0x32, 0x04},
-  {0x33, 0x44},
-  {0x34, 0x14},
-  {0x35, 0x00},
-  {0x36, 0x00},
-  {0x37, 0x00},
-  {0x38, 0x00},
-  {0x39, 0x03},
-  {0x3a, 0xfe},
-  {0x3b, 0x00},
-  {0x3c, 0x00},
-  {0x3d, 0x02},
-  {0x3e, 0x00},
-  {0x3f, 0x00}
 };
 
 #define ELANSPI_NO_ROTATE 0
@@ -449,33 +335,10 @@ static const struct elanspi_reg_entry elanspi_calibration_table_page1_id14_x571[
 
 #define ELANSPI_HV_FLIPPED 1
 
-#define ELANSPI_ROTATE_MASK 3
-
-#define ELANSPI_QUIRK_X571 (1 << 2)
-
-#define ELANSPI_QUIRK_MASK (ELANSPI_QUIRK_X571)
-
 #define ELANSPI_UDEV_TYPES FPI_DEVICE_UDEV_SUBTYPE_SPIDEV | FPI_DEVICE_UDEV_SUBTYPE_HIDRAW
 #define ELANSPI_TP_VID 0x04f3
 
-static const struct elanspi_regtable elanspi_calibration_table_new_page0 = {
+// using checkargs ACPI:HIDPID
-  .other = NULL,
-  .entries = {
-    { .sid = 0xe, .quirk = 0, .table = elanspi_calibration_table_page0_id14 },
-    { .sid = 0xe, .quirk = ELANSPI_QUIRK_X571, .table = elanspi_calibration_table_page0_id14_x571 },
-    { .sid = 0x0, .table = NULL }
-  }
-};
-
-static const struct elanspi_regtable elanspi_calibration_table_new_page1 = {
-  .other = NULL,
-  .entries = {
-    { .sid = 0xe, .quirk = 0, .table = elanspi_calibration_table_page1_id14 },
-    { .sid = 0xe, .quirk = ELANSPI_QUIRK_X571, .table = elanspi_calibration_table_page1_id14_x571 },
-    { .sid = 0x0, .table = NULL }
-  }
-};
-
 static const FpIdEntry elanspi_id_table[] = {
   {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x3057}, .driver_data = ELANSPI_180_ROTATE},
   {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x3087}, .driver_data = ELANSPI_180_ROTATE},
@@ -485,7 +348,6 @@ static const FpIdEntry elanspi_id_table[] = {
   {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x30b2}, .driver_data = ELANSPI_NO_ROTATE},
   {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN70A1", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x30b2}, .driver_data = ELANSPI_NO_ROTATE},
   {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x309f}, .driver_data = ELANSPI_180_ROTATE},
-  {.udev_types = ELANSPI_UDEV_TYPES, .spi_acpi_id = "ELAN7001", .hid_id = {.vid = ELANSPI_TP_VID, .pid = 0x3104}, .driver_data = ELANSPI_QUIRK_X571 | ELANSPI_90RIGHT_ROTATE},
   {.udev_types = 0}
 };
 
@@ -495,7 +357,6 @@ static const FpIdEntry elanspi_id_table[] = {
 #define ELANSPI_MAX_OLD_STAGE2_CALBIRATION_MEAN 8000
 
 #define ELANSPI_HV_CALIBRATION_TARGET_MEAN 3000
-#define ELANSPI_HV_X571_CALIBRATION_TARGET_MEAN 7000
 
 #define ELANSPI_MIN_EMPTY_INVALID_PERCENT 6
 #define ELANSPI_MAX_REAL_INVALID_PERCENT 3

libfprint/drivers/goodixmoc/goodix.c

@@ -159,7 +159,7 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
     {
       fpi_ssm_mark_failed (transfer->ssm,
                            fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO,
-                                                     "Corrupted message header received"));
+                                                     "Corrupted message received"));
       return;
     }
 
@@ -420,9 +420,12 @@ fp_verify_cb (FpiDeviceGoodixMoc  *self,
               gxfp_cmd_response_t *resp,
               GError              *error)
 {
+  g_autoptr(GPtrArray) templates = NULL;
   FpDevice *device = FP_DEVICE (self);
-  FpPrint *new_scan = NULL;
+  FpPrint *match = NULL;
-  FpPrint *matching = NULL;
+  FpPrint *print = NULL;
+  gint cnt = 0;
+  gboolean find = false;
 
   if (error)
     {
@@ -431,34 +434,46 @@ fp_verify_cb (FpiDeviceGoodixMoc  *self,
     }
   if (resp->verify.match)
     {
-      new_scan = fp_print_from_template (self, &resp->verify.template);
+      match = fp_print_from_template (self, &resp->verify.template);
 
       if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY)
         {
-          fpi_device_get_verify_data (device, &matching);
+          templates = g_ptr_array_sized_new (1);
-          if (!fp_print_equal (matching, new_scan))
+          fpi_device_get_verify_data (device, &print);
-            matching = NULL;
+          g_ptr_array_add (templates, print);
         }
       else
         {
-          GPtrArray *templates = NULL;
           fpi_device_get_identify_data (device, &templates);
+          g_ptr_array_ref (templates);
+        }
+      for (cnt = 0; cnt < templates->len; cnt++)
+        {
+          print = g_ptr_array_index (templates, cnt);
 
-          for (gint i = 0; i < templates->len; i++)
+          if (fp_print_equal (print, match))
             {
-              if (fp_print_equal (g_ptr_array_index (templates, i), new_scan))
+              find = true;
-                {
+              break;
-                  matching = g_ptr_array_index (templates, i);
-                  break;
-                }
             }
+
+        }
+      if (find)
+        {
+          if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY)
+            fpi_device_verify_report (device, FPI_MATCH_SUCCESS, match, error);
+          else
+            fpi_device_identify_report (device, print, match, error);
         }
     }
 
-  if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY)
+  if (!find)
-    fpi_device_verify_report (device, matching ? FPI_MATCH_SUCCESS : FPI_MATCH_FAIL, new_scan, error);
+    {
-  else
+      if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY)
-    fpi_device_identify_report (device, matching, new_scan, error);
+        fpi_device_verify_report (device, FPI_MATCH_FAIL, NULL, error);
+      else
+        fpi_device_identify_report (device, NULL, NULL, error);
+    }
 
   fpi_ssm_next_state (self->task_ssm);
 
@@ -749,14 +764,9 @@ fp_enroll_check_duplicate_cb (FpiDeviceGoodixMoc  *self,
     }
   if (resp->check_duplicate_resp.duplicate)
     {
-      g_autoptr(FpPrint) print = NULL;
-
-      print = g_object_ref_sink (fp_print_from_template (self, &resp->check_duplicate_resp.template));
-
       fpi_ssm_mark_failed (self->task_ssm,
                            fpi_device_error_new_msg (FP_DEVICE_ERROR_DATA_DUPLICATE,
-                                                     "Finger was already enrolled as '%s'",
+                                                     "Finger has already enrolled"));
-                                                     fp_print_get_description (print)));
       return;
     }
 
@@ -1160,32 +1170,6 @@ fp_template_delete_cb (FpiDeviceGoodixMoc  *self,
   fp_info ("Successfully deleted enrolled user");
   fpi_device_delete_complete (device, NULL);
 }
-
-static void
-fp_template_delete_all_cb (FpiDeviceGoodixMoc  *self,
-                           gxfp_cmd_response_t *resp,
-                           GError              *error)
-{
-  FpDevice *device = FP_DEVICE (self);
-
-  if (error)
-    {
-      fpi_device_clear_storage_complete (device, error);
-      return;
-    }
-  if ((resp->result >= GX_FAILED) && (resp->result != GX_ERROR_FINGER_ID_NOEXIST))
-    {
-      fpi_device_clear_storage_complete (FP_DEVICE (self),
-                                         fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL,
-                                                                   "Failed clear storage, result: 0x%x",
-                                                                   resp->result));
-      return;
-    }
-
-  fp_info ("Successfully cleared storage");
-  fpi_device_clear_storage_complete (device, NULL);
-}
-
 /******************************************************************************
  *
  *  fp_template_list Function
@@ -1509,19 +1493,6 @@ gx_fp_template_delete (FpDevice *device)
 
 }
 
-static void
-gx_fp_template_delete_all (FpDevice *device)
-{
-  FpiDeviceGoodixMoc *self = FPI_DEVICE_GOODIXMOC (device);
-
-  goodix_sensor_cmd (self, MOC_CMD0_DELETETEMPLATE, MOC_CMD1_DELETE_ALL,
-                     false,
-                     NULL,
-                     0,
-                     fp_template_delete_all_cb);
-
-}
-
 static void
 fpi_device_goodixmoc_init (FpiDeviceGoodixMoc *self)
 {
@@ -1565,7 +1536,6 @@ fpi_device_goodixmoc_class_init (FpiDeviceGoodixMocClass *klass)
   dev_class->probe  = gx_fp_probe;
   dev_class->enroll = gx_fp_enroll;
   dev_class->delete = gx_fp_template_delete;
-  dev_class->clear_storage = gx_fp_template_delete_all;
   dev_class->list   = gx_fp_template_list;
   dev_class->verify   = gx_fp_verify_identify;
   dev_class->identify = gx_fp_verify_identify;

libfprint/drivers/goodixmoc/goodix_proto.c

@@ -259,9 +259,12 @@ gx_proto_parse_fingerid (
 
   if (buffer[Offset++] != 67)
     return -1;
+  fid_buffer_size--;
 
   template->type = buffer[Offset++];
+  fid_buffer_size--;
   template->finger_index = buffer[Offset++];
+  fid_buffer_size--;
   Offset++;
   memcpy (template->accountid, &buffer[Offset], sizeof (template->accountid));
   Offset += sizeof (template->accountid);
@@ -270,8 +273,6 @@ gx_proto_parse_fingerid (
   template->payload.size = buffer[Offset++];
   if (template->payload.size > sizeof (template->payload.data))
     return -1;
-  if (template->payload.size + Offset > fid_buffer_size)
-    return -1;
   memset (template->payload.data, 0, template->payload.size);
   memcpy (template->payload.data, &buffer[Offset], template->payload.size);
 
@@ -364,12 +365,9 @@ gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_c
           if (buffer_len < 3)
             return -1;
           uint16_t tid_size = GUINT16_FROM_LE (*(uint16_t *) (buffer + 1));
-          offset += 3;
+          if ((buffer_len < tid_size + 3) || (buffer_len > sizeof (template_format_t)) + 3)
-
-          if (buffer_len < tid_size + offset)
-            return -1;
-          if (gx_proto_parse_fingerid (buffer + offset, tid_size, &presp->check_duplicate_resp.template) != 0)
             return -1;
+          memcpy (&presp->check_duplicate_resp.template, buffer + 3, tid_size);
         }
       break;
 
@@ -382,12 +380,9 @@ gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_c
       fingerlist = buffer + 2;
       for(uint8_t num = 0; num < presp->finger_list_resp.finger_num; num++)
         {
-          uint16_t fingerid_length;
+          uint16_t fingerid_length = GUINT16_FROM_LE (*(uint16_t *) (fingerlist + offset));
-          if (buffer_len < offset + 2)
-            return -1;
-          fingerid_length = GUINT16_FROM_LE (*(uint16_t *) (fingerlist + offset));
           offset += 2;
-          if (buffer_len < fingerid_length + offset)
+          if (buffer_len < fingerid_length + offset + 2)
             return -1;
           if (gx_proto_parse_fingerid (fingerlist + offset,
                                        fingerid_length,
@@ -410,7 +405,7 @@ gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_c
         presp->verify.match = (buffer[0] == 0) ? true : false;
         if (presp->verify.match)
           {
-            if (buffer_len < 10)
+            if (buffer_len < sizeof (template_format_t) + 10)
               return -1;
             offset += 1;
             presp->verify.rejectdetail = GUINT16_FROM_LE (*(uint16_t *) (buffer + offset));
@@ -421,8 +416,6 @@ gx_proto_parse_body (uint16_t cmd, uint8_t *buffer, uint16_t buffer_len, pgxfp_c
             offset += 1;
             fingerid_size = GUINT16_FROM_LE (*(uint16_t *) (buffer + offset));
             offset += 2;
-            if (buffer_len < fingerid_size + offset)
-              return -1;
             if (gx_proto_parse_fingerid (buffer + offset, fingerid_size, &presp->verify.template) != 0)
               {
                 presp->result = GX_FAILED;

libfprint/drivers/synaptics/synaptics.c

@@ -36,13 +36,13 @@ static const FpIdEntry id_table[] = {
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F9,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00FC,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C2,  },
+  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00C9,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0100,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x00F0,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0103,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0123,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0126,  },
   { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0129,  },
-  { .vid = SYNAPTICS_VENDOR_ID,  .pid = 0x0168,  },
   { .vid = 0,  .pid = 0,  .driver_data = 0 },   /* terminating entry */
 };
 

libfprint/fp-context.c

@@ -361,8 +361,6 @@ fp_context_init (FpContext *self)
   FpContextPrivate *priv = fp_context_get_instance_private (self);
   guint i;
 
-  g_debug ("Initializing FpContext (libfprint version " LIBFPRINT_VERSION ")");
-
   priv->drivers = fpi_get_driver_types ();
 
   if (get_drivers_whitelist_env ())

libfprint/fp-device.c

@@ -225,7 +225,6 @@ fp_device_finalize (GObject *object)
 
   g_clear_pointer (&priv->current_idle_cancel_source, g_source_destroy);
   g_clear_pointer (&priv->current_task_idle_return_source, g_source_destroy);
-  g_clear_pointer (&priv->critical_section_flush_source, g_source_destroy);
 
   g_clear_pointer (&priv->device_id, g_free);
   g_clear_pointer (&priv->device_name, g_free);

libfprint/fprint-list-udev-hwdb.c

@@ -31,6 +31,7 @@ static const FpIdEntry whitelist_id_table[] = {
    */
   { .vid = 0x04f3, .pid = 0x036b },
   { .vid = 0x04f3, .pid = 0x0c00 },
+  { .vid = 0x04f3, .pid = 0x0c4b },
   { .vid = 0x04f3, .pid = 0x0c4c },
   { .vid = 0x04f3, .pid = 0x0c57 },
   { .vid = 0x04f3, .pid = 0x0c5e },
@@ -41,19 +42,15 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0x06cb, .pid = 0x009a },
   { .vid = 0x06cb, .pid = 0x009b },
   { .vid = 0x06cb, .pid = 0x00a2 },
-  { .vid = 0x06cb, .pid = 0x00a8 },
   { .vid = 0x06cb, .pid = 0x00b7 },
   { .vid = 0x06cb, .pid = 0x00bb },
   { .vid = 0x06cb, .pid = 0x00be },
   { .vid = 0x06cb, .pid = 0x00c4 },
   { .vid = 0x06cb, .pid = 0x00cb },
-  { .vid = 0x06cb, .pid = 0x00c9 },
   { .vid = 0x06cb, .pid = 0x00d8 },
   { .vid = 0x06cb, .pid = 0x00da },
-  { .vid = 0x06cb, .pid = 0x00dc },
   { .vid = 0x06cb, .pid = 0x00e7 },
   { .vid = 0x06cb, .pid = 0x00e9 },
-  { .vid = 0x06cb, .pid = 0x00fd },
   { .vid = 0x0a5c, .pid = 0x5801 },
   { .vid = 0x0a5c, .pid = 0x5805 },
   { .vid = 0x0a5c, .pid = 0x5834 },
@@ -65,7 +62,6 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0x0a5c, .pid = 0x5845 },
   { .vid = 0x0bda, .pid = 0x5812 },
   { .vid = 0x10a5, .pid = 0x0007 },
-  { .vid = 0x10a5, .pid = 0x9200 },
   { .vid = 0x1188, .pid = 0x9545 },
   { .vid = 0x138a, .pid = 0x0007 },
   { .vid = 0x138a, .pid = 0x003a },
@@ -83,7 +79,6 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0x16d1, .pid = 0x1027 },
   { .vid = 0x1c7a, .pid = 0x0300 },
   { .vid = 0x1c7a, .pid = 0x0575 },
-  { .vid = 0x1c7a, .pid = 0x0576 },
   { .vid = 0x27c6, .pid = 0x5042 },
   { .vid = 0x27c6, .pid = 0x5110 },
   { .vid = 0x27c6, .pid = 0x5117 },
@@ -103,9 +98,7 @@ static const FpIdEntry whitelist_id_table[] = {
   { .vid = 0x27c6, .pid = 0x55a4 },
   { .vid = 0x27c6, .pid = 0x55b4 },
   { .vid = 0x27c6, .pid = 0x5740 },
-  { .vid = 0x27c6, .pid = 0x5e0a },
   { .vid = 0x2808, .pid = 0x9338 },
-  { .vid = 0x298d, .pid = 0x2020 },
   { .vid = 0x298d, .pid = 0x2033 },
   { .vid = 0x3538, .pid = 0x0930 },
   { .vid = 0 },

meson.build

@@ -1,5 +1,5 @@
 project('libfprint', [ 'c', 'cpp' ],
-    version: '1.94.3',
+    version: '1.94.2',
     license: 'LGPLv2.1+',
     default_options: [
         'buildtype=debugoptimized',
@@ -11,7 +11,6 @@ project('libfprint', [ 'c', 'cpp' ],
 gnome = import('gnome')
 
 libfprint_conf = configuration_data()
-libfprint_conf.set_quoted('LIBFPRINT_VERSION', meson.project_version())
 
 cc = meson.get_compiler('c')
 cpp = meson.get_compiler('cpp')

tests/goodixmoc/custom.py

@@ -21,7 +21,7 @@ assert d.has_feature(FPrint.DeviceFeature.DUPLICATES_CHECK)
 assert d.has_feature(FPrint.DeviceFeature.STORAGE)
 assert d.has_feature(FPrint.DeviceFeature.STORAGE_LIST)
 assert d.has_feature(FPrint.DeviceFeature.STORAGE_DELETE)
-assert d.has_feature(FPrint.DeviceFeature.STORAGE_CLEAR)
+assert not d.has_feature(FPrint.DeviceFeature.STORAGE_CLEAR)
 
 d.open_sync()
 

tests/test-fpi-device.c

@@ -29,10 +29,6 @@
 #include "test-device-fake.h"
 #include "fp-print-private.h"
 
-/* gcc 12.0.1 is complaining about dangling pointers in the auto_close* functions */
-#pragma GCC diagnostic push
-#pragma GCC diagnostic ignored "-Wdangling-pointer"
-
 /* Utility functions */
 
 typedef FpDevice FpAutoCloseDevice;
@@ -69,8 +65,6 @@ auto_close_fake_device_free (FpAutoCloseDevice *device)
 }
 G_DEFINE_AUTOPTR_CLEANUP_FUNC (FpAutoCloseDevice, auto_close_fake_device_free)
 
-#pragma GCC diagnostic pop
-
 typedef FpDeviceClass FpAutoResetClass;
 static FpAutoResetClass default_fake_dev_class = {0};