mirrors/libfprint
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libfprint/libfprint.git synced 2026-04-26 15:01:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'origin/master' into feature/sdcp-v2

Browse Source
This commit is contained in:
Joshua Grisham
2026-04-06 16:23:29 +02:00
parent d878136546 66b1ada0d6
commit 6cdcb3a8e9
20 changed files with 602 additions and 265 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
.gitlab-ci.yml
View File

@@ -7,6 +7,7 @@ include:
- remote: 'https://gitlab.gnome.org/GNOME/citemplates/-/raw/71e636e012ae0ab04c5e0fe40ca73ada91ae6bde/flatpak/flatpak_ci_initiative.yml'
default:
interruptible: true
# Auto-retry jobs in case of infra failures
retry:
max: 1
@@ -19,7 +20,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"

4
.gitlab-ci/libfprint-templates.yaml
View File

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

16
NEWS
View File

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

20
data/autosuspend.hwdb
View File

@@ -83,6 +83,7 @@ usb:v1C7Ap0583*
usb:v1C7Ap0584*
usb:v1C7Ap0586*
usb:v1C7Ap0587*
usb:v1C7Ap0588*
usb:v1C7Ap05A1*
usb:v1C7Ap05A5*
ID_AUTOSUSPEND=1
@@ -165,6 +166,9 @@ usb:v04F3p0C99*
usb:v04F3p0C9D*
usb:v04F3p0C9F*
usb:v04F3p0CA3*
usb:v04F3p0CA7*
usb:v04F3p0CA8*
usb:v04F3p0CB0*
ID_AUTOSUSPEND=1
ID_PERSIST=0
@@ -176,10 +180,14 @@ 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
@@ -229,6 +237,7 @@ usb:v27C6p659C*
usb:v27C6p6A94*
usb:v27C6p6512*
usb:v27C6p689A*
usb:v27C6p66A9*
ID_AUTOSUSPEND=1
ID_PERSIST=0
@@ -240,6 +249,7 @@ usb:v298Dp1010*
# Supported by libfprint driver realtek
usb:v0BDAp5813*
usb:v0BDAp5816*
usb:v2541pFA03*
ID_AUTOSUSPEND=1
ID_PERSIST=0
@@ -249,6 +259,7 @@ usb:v06CBp00C2*
usb:v06CBp00C4*
usb:v06CBp00C6*
usb:v06CBp00DF*
usb:v06CBp00E9*
usb:v06CBp00F0*
usb:v06CBp00F9*
usb:v06CBp00FC*
@@ -266,11 +277,13 @@ 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
@@ -374,10 +387,12 @@ 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*
@@ -386,7 +401,6 @@ usb:v06CBp00DA*
usb:v06CBp00DC*
usb:v06CBp00E4*
usb:v06CBp00E7*
usb:v06CBp00E9*
usb:v06CBp00FD*
usb:v06CBp00FF*
usb:v0A5Cp5801*
@@ -407,9 +421,11 @@ usb:v0A5Cp5867*
usb:v0BDAp5812*
usb:v10A5p0007*
usb:v10A5p9200*
usb:v10A5p9201*
usb:v10A5p9800*
usb:v10A5pA120*
usb:v10A5pA900*
usb:v10A5pA921*
usb:v10A5pE340*
usb:v1188p9545*
usb:v138Ap0007*
@@ -463,12 +479,14 @@ 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*

5
libfprint/drivers/egismoc/egismoc.c
View File

@@ -50,12 +50,13 @@ struct _FpiDeviceEgisMoc
G_DEFINE_TYPE (FpiDeviceEgisMoc, fpi_device_egismoc, FP_TYPE_SDCP_DEVICE);
static const FpIdEntry egismoc_id_table[] = {
{ .vid = 0x1c7a, .pid = 0x0582, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 },
{ .vid = 0x1c7a, .pid = 0x0582, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 | EGISMOC_DRIVER_MAX_ENROLL_STAGES_15 },
{ .vid = 0x1c7a, .pid = 0x0583, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE1 | EGISMOC_DRIVER_MAX_ENROLL_STAGES_15 },
{ .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 = 0x05a1, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE2 },
{ .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 | EGISMOC_DRIVER_MAX_ENROLL_STAGES_15 },
{ .vid = 0x1c7a, .pid = 0x05a5, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE2 | EGISMOC_DRIVER_MAX_ENROLL_STAGES_15 },
{ .vid = 0, .pid = 0, .driver_data = 0 }
};

17
libfprint/drivers/elanmoc/elanmoc.c
View File

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

18
libfprint/drivers/focaltech_moc/focaltech_moc.c
View File

@@ -29,10 +29,14 @@ 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 */
};
@@ -235,10 +239,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 +253,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 +270,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 +338,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);

100
libfprint/drivers/fpcmoc/fpc.c
View File

@@ -86,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);
@@ -94,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);
}
@@ -118,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;
}
@@ -139,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)
@@ -153,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);
@@ -292,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);
@@ -307,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,
@@ -323,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,
@@ -354,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);
@@ -743,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:
@@ -762,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;
@@ -780,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;
@@ -815,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);
}
}
@@ -943,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;
@@ -968,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;
@@ -983,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,
@@ -1001,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;
@@ -1015,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;
@@ -1030,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;
@@ -1045,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;
@@ -1060,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;
@@ -1114,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;
@@ -1129,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;
@@ -1142,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)
{
@@ -1287,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,
@@ -1305,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;
@@ -1319,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;
@@ -1334,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;
@@ -1404,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)
{
@@ -1431,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)
{
@@ -1536,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;
@@ -1548,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;
@@ -1682,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);
}
@@ -1694,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);
}
@@ -1705,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);
@@ -1722,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);
@@ -1774,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);
}
@@ -1796,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
@@ -1863,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);

64
libfprint/drivers/fpcmoc/fpc.h
View File

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

105
libfprint/drivers/goodixmoc/goodix.c
View File

@@ -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);
@@ -480,6 +480,35 @@ 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)
{
@@ -493,7 +522,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 +530,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 +541,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 +549,18 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
fp_verify_cb);
break;
case FP_VERIFY_PWR_BTN_SHIELD_OFF:
case GOODIX_VERIFY_WAIT_FINGER_UP:
{
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,
@@ -682,7 +722,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 +740,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 +786,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 +852,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 +867,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 +893,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 +903,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 +913,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 +923,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 +934,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 +945,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 +954,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 +962,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 +1015,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 +1106,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 +1147,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 +1155,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 +1163,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 +1178,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 +1492,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);
@@ -1518,8 +1558,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);
@@ -1535,8 +1575,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);
@@ -1656,6 +1696,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 */
};

57
libfprint/drivers/goodixmoc/goodix.h
View File

@@ -25,39 +25,40 @@
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_WAIT_FINGER_UP,
GOODIX_VERIFY_PWR_BTN_SHIELD_OFF,
GOODIX_VERIFY_NUM_STATES,
} GoodixVerifyState;

1
libfprint/drivers/realtek/realtek.c
View File

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

3
libfprint/drivers/synaptics/synaptics.c
View File

@@ -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, },
@@ -53,11 +54,13 @@ static const FpIdEntry id_table[] = {
{ .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 */
};

3
libfprint/fp-device.c
View File

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

8
libfprint/fprint-list-udev-hwdb.c
View File

@@ -64,10 +64,12 @@ 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 },
@@ -76,7 +78,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 },
@@ -97,9 +98,11 @@ 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 },
@@ -120,7 +123,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 },
@@ -154,12 +156,14 @@ 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 },

2
libfprint/meson.build
View File

@@ -278,6 +278,7 @@ libnbis = static_library('nbis',
'-Wno-discarded-qualifiers',
'-Wno-array-bounds',
'-Wno-array-parameter',
'-Wno-unused-but-set-variable',
]),
install: false)
@@ -433,6 +434,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]

2
meson.build
View File

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

BIN
tests/goodixmoc/custom.pcapng
View File

Binary file not shown.

418
tests/goodixmoc/device
View File

File diff suppressed because one or more lines are too long

21
tests/valgrind-python.supp
View File

@@ -95,3 +95,24 @@
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.*
}