mirrors/libfprint
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libfprint/libfprint.git synced 2026-04-26 23:01:37 +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' - remote: 'https://gitlab.gnome.org/GNOME/citemplates/-/raw/71e636e012ae0ab04c5e0fe40ca73ada91ae6bde/flatpak/flatpak_ci_initiative.yml'
default: default:
interruptible: true
# Auto-retry jobs in case of infra failures # Auto-retry jobs in case of infra failures
retry: retry:
max: 1 max: 1
@@ -19,7 +20,7 @@ default:
variables: variables:
extends: .libfprint_common_variables extends: .libfprint_common_variables
FDO_DISTRIBUTION_TAG: $LIBFPRINT_IMAGE_TAG FDO_DISTRIBUTION_TAG: $LIBFPRINT_IMAGE_TAG
FDO_DISTRIBUTION_VERSION: 41 FDO_DISTRIBUTION_VERSION: rawhide
FDO_UPSTREAM_REPO: "libfprint/$CI_PROJECT_NAME" FDO_UPSTREAM_REPO: "libfprint/$CI_PROJECT_NAME"
FEDORA_IMAGE: "$CI_REGISTRY/libfprint/$CI_PROJECT_NAME/fedora/$FDO_DISTRIBUTION_VERSION:$FDO_DISTRIBUTION_TAG" FEDORA_IMAGE: "$CI_REGISTRY/libfprint/$CI_PROJECT_NAME/fedora/$FDO_DISTRIBUTION_VERSION:$FDO_DISTRIBUTION_TAG"
LAST_ABI_BREAK: "056ea541ddc97f5806cffbd99a12dc87e4da3546" LAST_ABI_BREAK: "056ea541ddc97f5806cffbd99a12dc87e4da3546"

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

@@ -44,4 +44,6 @@
libgusb \ libgusb \
libusb \ libusb \
openssl \ 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 This file lists notable changes in each release. For the full history of all
changes, see ChangeLog. 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 2025-02-20: v1.94.9 release
Highlights: Highlights:

20
data/autosuspend.hwdb
View File

@@ -83,6 +83,7 @@ usb:v1C7Ap0583*
usb:v1C7Ap0584* usb:v1C7Ap0584*
usb:v1C7Ap0586* usb:v1C7Ap0586*
usb:v1C7Ap0587* usb:v1C7Ap0587*
usb:v1C7Ap0588*
usb:v1C7Ap05A1* usb:v1C7Ap05A1*
usb:v1C7Ap05A5* usb:v1C7Ap05A5*
ID_AUTOSUSPEND=1 ID_AUTOSUSPEND=1
@@ -165,6 +166,9 @@ usb:v04F3p0C99*
usb:v04F3p0C9D* usb:v04F3p0C9D*
usb:v04F3p0C9F* usb:v04F3p0C9F*
usb:v04F3p0CA3* usb:v04F3p0CA3*
usb:v04F3p0CA7*
usb:v04F3p0CA8*
usb:v04F3p0CB0*
ID_AUTOSUSPEND=1 ID_AUTOSUSPEND=1
ID_PERSIST=0 ID_PERSIST=0
@@ -176,10 +180,14 @@ usb:v1C7Ap0603*
# Supported by libfprint driver focaltech_moc # Supported by libfprint driver focaltech_moc
usb:v2808p9E48* usb:v2808p9E48*
usb:v2808pD979* usb:v2808pD979*
usb:v2808pA27A*
usb:v2808pA959* usb:v2808pA959*
usb:v2808pA99A* usb:v2808pA99A*
usb:v2808pA57A* usb:v2808pA57A*
usb:v2808pA78A* usb:v2808pA78A*
usb:v2808p1579*
usb:v2808p077A*
usb:v2808p079A*
ID_AUTOSUSPEND=1 ID_AUTOSUSPEND=1
ID_PERSIST=0 ID_PERSIST=0
@@ -229,6 +237,7 @@ usb:v27C6p659C*
usb:v27C6p6A94* usb:v27C6p6A94*
usb:v27C6p6512* usb:v27C6p6512*
usb:v27C6p689A* usb:v27C6p689A*
usb:v27C6p66A9*
ID_AUTOSUSPEND=1 ID_AUTOSUSPEND=1
ID_PERSIST=0 ID_PERSIST=0
@@ -240,6 +249,7 @@ usb:v298Dp1010*
# Supported by libfprint driver realtek # Supported by libfprint driver realtek
usb:v0BDAp5813* usb:v0BDAp5813*
usb:v0BDAp5816* usb:v0BDAp5816*
usb:v2541pFA03*
ID_AUTOSUSPEND=1 ID_AUTOSUSPEND=1
ID_PERSIST=0 ID_PERSIST=0
@@ -249,6 +259,7 @@ usb:v06CBp00C2*
usb:v06CBp00C4* usb:v06CBp00C4*
usb:v06CBp00C6* usb:v06CBp00C6*
usb:v06CBp00DF* usb:v06CBp00DF*
usb:v06CBp00E9*
usb:v06CBp00F0* usb:v06CBp00F0*
usb:v06CBp00F9* usb:v06CBp00F9*
usb:v06CBp00FC* usb:v06CBp00FC*
@@ -266,11 +277,13 @@ usb:v06CBp0126*
usb:v06CBp0129* usb:v06CBp0129*
usb:v06CBp015F* usb:v06CBp015F*
usb:v06CBp0168* usb:v06CBp0168*
usb:v06CBp0169*
usb:v06CBp016C* usb:v06CBp016C*
usb:v06CBp0173* usb:v06CBp0173*
usb:v06CBp0174* usb:v06CBp0174*
usb:v06CBp019D* usb:v06CBp019D*
usb:v06CBp019F* usb:v06CBp019F*
usb:v06CBp01A0*
ID_AUTOSUSPEND=1 ID_AUTOSUSPEND=1
ID_PERSIST=0 ID_PERSIST=0
@@ -374,10 +387,12 @@ usb:v06CBp0088*
usb:v06CBp008A* usb:v06CBp008A*
usb:v06CBp009A* usb:v06CBp009A*
usb:v06CBp009B* usb:v06CBp009B*
usb:v06CBp00A1*
usb:v06CBp00A2* usb:v06CBp00A2*
usb:v06CBp00A8* usb:v06CBp00A8*
usb:v06CBp00B7* usb:v06CBp00B7*
usb:v06CBp00BB* usb:v06CBp00BB*
usb:v06CBp00BC*
usb:v06CBp00BE* usb:v06CBp00BE*
usb:v06CBp00CB* usb:v06CBp00CB*
usb:v06CBp00C9* usb:v06CBp00C9*
@@ -386,7 +401,6 @@ usb:v06CBp00DA*
usb:v06CBp00DC* usb:v06CBp00DC*
usb:v06CBp00E4* usb:v06CBp00E4*
usb:v06CBp00E7* usb:v06CBp00E7*
usb:v06CBp00E9*
usb:v06CBp00FD* usb:v06CBp00FD*
usb:v06CBp00FF* usb:v06CBp00FF*
usb:v0A5Cp5801* usb:v0A5Cp5801*
@@ -407,9 +421,11 @@ usb:v0A5Cp5867*
usb:v0BDAp5812* usb:v0BDAp5812*
usb:v10A5p0007* usb:v10A5p0007*
usb:v10A5p9200* usb:v10A5p9200*
usb:v10A5p9201*
usb:v10A5p9800* usb:v10A5p9800*
usb:v10A5pA120* usb:v10A5pA120*
usb:v10A5pA900* usb:v10A5pA900*
usb:v10A5pA921*
usb:v10A5pE340* usb:v10A5pE340*
usb:v1188p9545* usb:v1188p9545*
usb:v138Ap0007* usb:v138Ap0007*
@@ -463,12 +479,14 @@ usb:v27C6p5E0A*
usb:v27C6p581A* usb:v27C6p581A*
usb:v27C6p589A* usb:v27C6p589A*
usb:v27C6p5F10* usb:v27C6p5F10*
usb:v27C6p5F91*
usb:v27C6p6382* usb:v27C6p6382*
usb:v2808p9338* usb:v2808p9338*
usb:v2808p9348* usb:v2808p9348*
usb:v2808p93A9* usb:v2808p93A9*
usb:v2808pA658* usb:v2808pA658*
usb:v2808pC652* usb:v2808pC652*
usb:v2808pA553*
usb:v298Dp2020* usb:v298Dp2020*
usb:v298Dp2033* usb:v298Dp2033*
usb:v2DF0p0003* 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); G_DEFINE_TYPE (FpiDeviceEgisMoc, fpi_device_egismoc, FP_TYPE_SDCP_DEVICE);
static const FpIdEntry egismoc_id_table[] = { 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 = 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 = 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 = 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 = 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 = 0x1c7a, .pid = 0x05a5, .driver_data = EGISMOC_DRIVER_CHECK_PREFIX_TYPE2 | EGISMOC_DRIVER_MAX_ENROLL_STAGES_15 },
{ .vid = 0, .pid = 0, .driver_data = 0 } { .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 = 0x0c9d, },
{ .vid = 0x04f3, .pid = 0x0c9f, }, { .vid = 0x04f3, .pid = 0x0c9f, },
{ .vid = 0x04f3, .pid = 0x0ca3, }, { .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 */ { .vid = 0, .pid = 0, .driver_data = 0 }, /* terminating entry */
}; };
@@ -132,10 +135,10 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
} }
typedef enum { typedef enum {
FP_CMD_SEND = 0, ELAN_MOC_CMD_SEND = 0,
FP_CMD_GET, ELAN_MOC_CMD_GET,
FP_CMD_NUM_STATES, ELAN_MOC_CMD_NUM_STATES,
} FpCmdState; } ElanMocCmdState;
static void static void
fp_cmd_run_state (FpiSsm *ssm, fp_cmd_run_state (FpiSsm *ssm,
@@ -146,7 +149,7 @@ fp_cmd_run_state (FpiSsm *ssm,
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
{ {
case FP_CMD_SEND: case ELAN_MOC_CMD_SEND:
if (self->cmd_transfer) if (self->cmd_transfer)
{ {
self->cmd_transfer->ssm = ssm; self->cmd_transfer->ssm = ssm;
@@ -162,7 +165,7 @@ fp_cmd_run_state (FpiSsm *ssm,
} }
break; break;
case FP_CMD_GET: case ELAN_MOC_CMD_GET:
if (self->cmd_len_in == 0) if (self->cmd_len_in == 0)
{ {
CommandData *data = fpi_ssm_get_data (ssm); 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), self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
fp_cmd_run_state, 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); 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[] = { static const FpIdEntry id_table[] = {
{ .vid = 0x2808, .pid = 0x9e48, }, { .vid = 0x2808, .pid = 0x9e48, },
{ .vid = 0x2808, .pid = 0xd979, }, { .vid = 0x2808, .pid = 0xd979, },
{ .vid = 0x2808, .pid = 0xa27a, },
{ .vid = 0x2808, .pid = 0xa959, }, { .vid = 0x2808, .pid = 0xa959, },
{ .vid = 0x2808, .pid = 0xa99a, }, { .vid = 0x2808, .pid = 0xa99a, },
{ .vid = 0x2808, .pid = 0xa57a, }, { .vid = 0x2808, .pid = 0xa57a, },
{ .vid = 0x2808, .pid = 0xa78a, }, { .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 */ { .vid = 0, .pid = 0, .driver_data = 0 }, /* terminating entry */
}; };
@@ -235,10 +239,10 @@ fp_cmd_receive_cb (FpiUsbTransfer *transfer,
} }
typedef enum { typedef enum {
FP_CMD_SEND = 0, FOCALTECH_CMD_SEND = 0,
FP_CMD_GET, FOCALTECH_CMD_GET,
FP_CMD_NUM_STATES, FOCALTECH_CMD_NUM_STATES,
} FpCmdState; } FocaltechCmdState;
static void static void
fp_cmd_run_state (FpiSsm *ssm, fp_cmd_run_state (FpiSsm *ssm,
@@ -249,7 +253,7 @@ fp_cmd_run_state (FpiSsm *ssm,
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
{ {
case FP_CMD_SEND: case FOCALTECH_CMD_SEND:
if (self->cmd_transfer) if (self->cmd_transfer)
{ {
self->cmd_transfer->ssm = ssm; self->cmd_transfer->ssm = ssm;
@@ -266,7 +270,7 @@ fp_cmd_run_state (FpiSsm *ssm,
break; break;
case FP_CMD_GET: case FOCALTECH_CMD_GET:
if (self->cmd_len_in == 0) if (self->cmd_len_in == 0)
{ {
CommandData *data = fpi_ssm_get_data (ssm); 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), self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
fp_cmd_run_state, 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); 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); 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) if (error)
fpi_ssm_mark_failed (transfer->ssm, error); fpi_ssm_mark_failed (transfer->ssm, error);
@@ -94,12 +94,12 @@ fpc_suspend_resume_cb (FpiUsbTransfer *transfer,
fpi_device_suspend_complete (device, error); fpi_device_suspend_complete (device, error);
/* The resume handler continues to the next state! */ /* The resume handler continues to the next state! */
} }
else if (ssm_state == FP_CMD_RESUME) else if (ssm_state == FPC_CMD_RESUME)
{ {
if (error) if (error)
fpi_ssm_mark_failed (transfer->ssm, error); fpi_ssm_mark_failed (transfer->ssm, error);
else 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); 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)) if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED) && (self->cmd_suspended))
{ {
g_error_free (error); 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; 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); 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 */ /* 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; self->cmd_ssm = NULL;
if (data->cmdtype == FPC_CMDTYPE_TO_DEVICE) 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) 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); fpi_ssm_next_state (transfer->ssm);
return; return;
} }
if (ssm_state == FP_CMD_GET_DATA) if (ssm_state == FPC_CMD_GET_DATA)
{ {
fpc_cmd_response_t evt_data = {0}; fpc_cmd_response_t evt_data = {0};
fp_dbg ("%s recv evt data length: %ld", G_STRFUNC, transfer->actual_length); 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)) switch (fpi_ssm_get_cur_state (ssm))
{ {
case FP_CMD_SEND: case FPC_CMD_SEND:
fpc_send_ctrl_cmd (dev); fpc_send_ctrl_cmd (dev);
break; break;
case FP_CMD_GET_DATA: case FPC_CMD_GET_DATA:
transfer = fpi_usb_transfer_new (dev); transfer = fpi_usb_transfer_new (dev);
transfer->ssm = ssm; transfer->ssm = ssm;
fpi_usb_transfer_fill_bulk (transfer, EP_IN, EP_IN_MAX_BUF_SIZE); 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)); fpi_ssm_get_data (ssm));
break; break;
case FP_CMD_SUSPENDED: case FPC_CMD_SUSPENDED:
transfer = fpi_usb_transfer_new (dev); transfer = fpi_usb_transfer_new (dev);
transfer->ssm = ssm; transfer->ssm = ssm;
fpi_usb_transfer_fill_control (transfer, fpi_usb_transfer_fill_control (transfer,
@@ -323,7 +323,7 @@ fpc_cmd_run_state (FpiSsm *ssm,
fpc_suspend_resume_cb, NULL); fpc_suspend_resume_cb, NULL);
break; break;
case FP_CMD_RESUME: case FPC_CMD_RESUME:
transfer = fpi_usb_transfer_new (dev); transfer = fpi_usb_transfer_new (dev);
transfer->ssm = ssm; transfer->ssm = ssm;
fpi_usb_transfer_fill_control (transfer, fpi_usb_transfer_fill_control (transfer,
@@ -354,21 +354,22 @@ fpc_sensor_cmd (FpiDeviceFpcMoc *self,
data = g_memdup2 (cmd_data, sizeof (CommandData)); data = g_memdup2 (cmd_data, sizeof (CommandData));
g_clear_object (&self->interrupt_cancellable);
if (wait_data_delay) if (wait_data_delay)
{ {
self->cmd_data_timeout = 0; self->cmd_data_timeout = 0;
g_set_object (&self->interrupt_cancellable, g_cancellable_new ()); self->interrupt_cancellable = g_cancellable_new ();
} }
else else
{ {
self->cmd_data_timeout = DATA_TIMEOUT; self->cmd_data_timeout = DATA_TIMEOUT;
g_clear_object (&self->interrupt_cancellable);
} }
g_assert (self->cmd_ssm == NULL); g_assert (self->cmd_ssm == NULL);
self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self), self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
fpc_cmd_run_state, fpc_cmd_run_state,
FP_CMD_NUM_STATES); FPC_CMD_NUM_STATES);
fpi_ssm_set_data (self->cmd_ssm, data, g_free); fpi_ssm_set_data (self->cmd_ssm, data, g_free);
fpi_ssm_start (self->cmd_ssm, fpc_cmd_ssm_done); 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: case FPC_ENROL_STATUS_COMPLETED:
self->enroll_stage++; self->enroll_stage++;
fpi_device_enroll_progress (FP_DEVICE (self), self->enroll_stage, NULL, NULL); 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; return;
case FPC_ENROL_STATUS_IMAGE_TOO_SIMILAR: case FPC_ENROL_STATUS_IMAGE_TOO_SIMILAR:
@@ -762,7 +763,7 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
/* Used for customer enrollment scheme */ /* Used for customer enrollment scheme */
if (self->enroll_stage >= (self->max_enroll_stage - self->max_immobile_stage)) 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; return;
} }
break; break;
@@ -780,7 +781,7 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
/* Used for customer enrollment scheme */ /* Used for customer enrollment scheme */
if (self->enroll_stage >= (self->max_enroll_stage - self->max_immobile_stage)) 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; return;
} }
break; break;
@@ -815,7 +816,7 @@ fpc_enroll_update_cb (FpiDeviceFpcMoc *self,
} }
else 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)) switch (fpi_ssm_get_cur_state (ssm))
{ {
case FP_ENROLL_ENUM: case FPC_ENROLL_ENUM:
{ {
FPC_FID_DATA pquery_data = {0}; FPC_FID_DATA pquery_data = {0};
gsize query_data_len = 0; gsize query_data_len = 0;
@@ -968,7 +969,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_ENROLL_CREATE: case FPC_ENROLL_CREATE:
{ {
recv_data_len = sizeof (FPC_BEGIN_ENROL); recv_data_len = sizeof (FPC_BEGIN_ENROL);
cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE; cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -983,7 +984,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_ENROLL_CAPTURE: case FPC_ENROLL_CAPTURE:
{ {
guint32 capture_id = FPC_CAPTUREID_RESERVED; guint32 capture_id = FPC_CAPTUREID_RESERVED;
fpi_device_report_finger_status_changes (device, fpi_device_report_finger_status_changes (device,
@@ -1001,7 +1002,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_ENROLL_GET_IMG: case FPC_ENROLL_GET_IMG:
{ {
cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA; cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA;
cmd_data.request = FPC_CMD_GET_IMG; cmd_data.request = FPC_CMD_GET_IMG;
@@ -1015,7 +1016,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_ENROLL_UPDATE: case FPC_ENROLL_UPDATE:
{ {
recv_data_len = sizeof (FPC_ENROL); recv_data_len = sizeof (FPC_ENROL);
cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE; cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1030,7 +1031,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_ENROLL_COMPLETE: case FPC_ENROLL_COMPLETE:
{ {
recv_data_len = sizeof (FPC_END_ENROL); recv_data_len = sizeof (FPC_END_ENROL);
cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE; cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1045,7 +1046,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_ENROLL_CHECK_DUPLICATE: case FPC_ENROLL_CHECK_DUPLICATE:
{ {
recv_data_len = sizeof (FPC_IDENTIFY); recv_data_len = sizeof (FPC_IDENTIFY);
cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE; cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1060,7 +1061,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_ENROLL_BINDID: case FPC_ENROLL_BINDID:
{ {
FPC_FID_DATA data = {0}; FPC_FID_DATA data = {0};
gsize data_len = 0; gsize data_len = 0;
@@ -1114,7 +1115,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_ENROLL_COMMIT: case FPC_ENROLL_COMMIT:
{ {
recv_data_len = sizeof (gint32); recv_data_len = sizeof (gint32);
cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE; cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1129,7 +1130,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_ENROLL_DICARD: case FPC_ENROLL_DICARD:
{ {
cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE; cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE;
cmd_data.request = FPC_CMD_ABORT; cmd_data.request = FPC_CMD_ABORT;
@@ -1142,7 +1143,7 @@ fpc_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_ENROLL_CLEANUP: case FPC_ENROLL_CLEANUP:
{ {
if (self->do_cleanup == TRUE) 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)) switch (fpi_ssm_get_cur_state (ssm))
{ {
case FP_VERIFY_CAPTURE: case FPC_VERIFY_CAPTURE:
{ {
guint32 capture_id = FPC_CAPTUREID_RESERVED; guint32 capture_id = FPC_CAPTUREID_RESERVED;
fpi_device_report_finger_status_changes (device, fpi_device_report_finger_status_changes (device,
@@ -1305,7 +1306,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_VERIFY_GET_IMG: case FPC_VERIFY_GET_IMG:
{ {
cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA; cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA;
cmd_data.request = FPC_CMD_GET_IMG; cmd_data.request = FPC_CMD_GET_IMG;
@@ -1319,7 +1320,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_VERIFY_IDENTIFY: case FPC_VERIFY_IDENTIFY:
{ {
gsize recv_data_len = sizeof (FPC_IDENTIFY); gsize recv_data_len = sizeof (FPC_IDENTIFY);
cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE; cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE;
@@ -1334,7 +1335,7 @@ fpc_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_VERIFY_CANCEL: case FPC_VERIFY_CANCEL:
{ {
cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE; cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE;
cmd_data.request = FPC_CMD_ABORT; 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)) switch (fpi_ssm_get_cur_state (ssm))
{ {
case FP_CLEAR_DELETE_DB: case FPC_CLEAR_DELETE_DB:
{ {
if (self->dbid) if (self->dbid)
{ {
@@ -1431,7 +1432,7 @@ fpc_clear_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_CLEAR_CREATE_DB: case FPC_CLEAR_CREATE_DB:
{ {
if (self->dbid) if (self->dbid)
{ {
@@ -1536,7 +1537,7 @@ fpc_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
{ {
case FP_INIT: case FPC_INIT:
cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA; cmd_data.cmdtype = FPC_CMDTYPE_TO_DEVICE_EVTDATA;
cmd_data.request = FPC_CMD_INIT; cmd_data.request = FPC_CMD_INIT;
cmd_data.value = 0x1; cmd_data.value = 0x1;
@@ -1548,7 +1549,7 @@ fpc_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
fpc_sensor_cmd (self, FALSE, &cmd_data); fpc_sensor_cmd (self, FALSE, &cmd_data);
break; break;
case FP_LOAD_DB: case FPC_INIT_LOAD_DB:
{ {
gsize recv_data_len = sizeof (FPC_LOAD_DB); gsize recv_data_len = sizeof (FPC_LOAD_DB);
cmd_data.cmdtype = FPC_CMDTYPE_FROM_DEVICE; 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, 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); 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); fp_dbg ("%s enter -->", G_STRFUNC);
g_clear_pointer (&self->dbid, g_free); g_clear_pointer (&self->dbid, g_free);
g_cancellable_cancel (self->interrupt_cancellable);
g_clear_object (&self->interrupt_cancellable); g_clear_object (&self->interrupt_cancellable);
fpc_dev_release_interface (self, NULL); fpc_dev_release_interface (self, NULL);
} }
@@ -1705,8 +1707,8 @@ fpc_dev_verify_identify (FpDevice *device)
fp_dbg ("%s enter -->", G_STRFUNC); fp_dbg ("%s enter -->", G_STRFUNC);
self->task_ssm = fpi_ssm_new_full (device, fpc_verify_sm_run_state, self->task_ssm = fpi_ssm_new_full (device, fpc_verify_sm_run_state,
FP_VERIFY_NUM_STATES, FPC_VERIFY_NUM_STATES,
FP_VERIFY_CANCEL, FPC_VERIFY_CANCEL,
"verify_identify"); "verify_identify");
fpi_ssm_start (self->task_ssm, fpc_verify_ssm_done); fpi_ssm_start (self->task_ssm, fpc_verify_ssm_done);
@@ -1722,8 +1724,8 @@ fpc_dev_enroll (FpDevice *device)
self->enroll_stage = 0; self->enroll_stage = 0;
self->immobile_stage = 0; self->immobile_stage = 0;
self->task_ssm = fpi_ssm_new_full (device, fpc_enroll_sm_run_state, self->task_ssm = fpi_ssm_new_full (device, fpc_enroll_sm_run_state,
FP_ENROLL_NUM_STATES, FPC_ENROLL_NUM_STATES,
FP_ENROLL_DICARD, FPC_ENROLL_DICARD,
"enroll"); "enroll");
fpi_ssm_start (self->task_ssm, fpc_enroll_ssm_done); 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 (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; self->cmd_suspended = TRUE;
g_cancellable_cancel (self->interrupt_cancellable); g_cancellable_cancel (self->interrupt_cancellable);
} }
@@ -1796,10 +1798,12 @@ fpc_dev_resume (FpDevice *device)
g_assert (self->cmd_ssm); g_assert (self->cmd_ssm);
g_assert (self->cmd_suspended); 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; 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 static void
@@ -1863,8 +1867,8 @@ fpc_dev_clear_storage (FpDevice *device)
fp_dbg ("%s enter -->", G_STRFUNC); fp_dbg ("%s enter -->", G_STRFUNC);
self->task_ssm = fpi_ssm_new_full (device, fpc_clear_sm_run_state, self->task_ssm = fpi_ssm_new_full (device, fpc_clear_sm_run_state,
FP_CLEAR_NUM_STATES, FPC_CLEAR_NUM_STATES,
FP_CLEAR_NUM_STATES, FPC_CLEAR_NUM_STATES,
"Clear storage"); "Clear storage");
fpi_ssm_start (self->task_ssm, fpc_clear_ssm_done); 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; } FpcCmdType;
typedef enum { typedef enum {
FP_CMD_SEND = 0, FPC_CMD_SEND = 0,
FP_CMD_GET_DATA, FPC_CMD_GET_DATA,
FP_CMD_SUSPENDED, FPC_CMD_SUSPENDED,
FP_CMD_RESUME, FPC_CMD_RESUME,
FP_CMD_NUM_STATES, FPC_CMD_NUM_STATES,
} FpCmdState; } FpcCmdState;
typedef enum { typedef enum {
FP_INIT = 0, FPC_INIT = 0,
FP_LOAD_DB, FPC_INIT_LOAD_DB,
FP_INIT_NUM_STATES, FPC_INIT_NUM_STATES,
} FpInitState; } FpcInitState;
typedef enum { typedef enum {
FP_ENROLL_ENUM = 0, FPC_ENROLL_ENUM = 0,
FP_ENROLL_CREATE, FPC_ENROLL_CREATE,
FP_ENROLL_CAPTURE, FPC_ENROLL_CAPTURE,
FP_ENROLL_GET_IMG, FPC_ENROLL_GET_IMG,
FP_ENROLL_UPDATE, FPC_ENROLL_UPDATE,
FP_ENROLL_COMPLETE, FPC_ENROLL_COMPLETE,
FP_ENROLL_CHECK_DUPLICATE, FPC_ENROLL_CHECK_DUPLICATE,
FP_ENROLL_BINDID, FPC_ENROLL_BINDID,
FP_ENROLL_COMMIT, FPC_ENROLL_COMMIT,
FP_ENROLL_DICARD, FPC_ENROLL_DICARD,
FP_ENROLL_CLEANUP, FPC_ENROLL_CLEANUP,
FP_ENROLL_NUM_STATES, FPC_ENROLL_NUM_STATES,
} FpEnrollState; } FpcEnrollState;
typedef enum { typedef enum {
FP_VERIFY_CAPTURE = 0, FPC_VERIFY_CAPTURE = 0,
FP_VERIFY_GET_IMG, FPC_VERIFY_GET_IMG,
FP_VERIFY_IDENTIFY, FPC_VERIFY_IDENTIFY,
FP_VERIFY_CANCEL, FPC_VERIFY_CANCEL,
FP_VERIFY_NUM_STATES, FPC_VERIFY_NUM_STATES,
} FpVerifyState; } FpcVerifyState;
typedef enum { typedef enum {
FP_CLEAR_DELETE_DB = 0, FPC_CLEAR_DELETE_DB = 0,
FP_CLEAR_CREATE_DB, FPC_CLEAR_CREATE_DB,
FP_CLEAR_NUM_STATES, FPC_CLEAR_NUM_STATES,
} FpClearState; } 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)) switch (fpi_ssm_get_cur_state (ssm))
{ {
case FP_CMD_SEND: case GOODIX_CMD_SEND:
if (self->cmd_transfer) if (self->cmd_transfer)
{ {
self->cmd_transfer->ssm = ssm; self->cmd_transfer->ssm = ssm;
@@ -254,7 +254,7 @@ fp_cmd_run_state (FpiSsm *ssm,
} }
break; break;
case FP_CMD_GET_ACK: case GOODIX_CMD_GET_ACK:
transfer = fpi_usb_transfer_new (dev); transfer = fpi_usb_transfer_new (dev);
transfer->ssm = ssm; transfer->ssm = ssm;
fpi_usb_transfer_fill_bulk (transfer, EP_IN, EP_IN_MAX_BUF_SIZE); fpi_usb_transfer_fill_bulk (transfer, EP_IN, EP_IN_MAX_BUF_SIZE);
@@ -266,7 +266,7 @@ fp_cmd_run_state (FpiSsm *ssm,
break; break;
case FP_CMD_GET_DATA: case GOODIX_CMD_GET_DATA:
transfer = fpi_usb_transfer_new (dev); transfer = fpi_usb_transfer_new (dev);
transfer->ssm = ssm; transfer->ssm = ssm;
fpi_usb_transfer_fill_bulk (transfer, EP_IN, EP_IN_MAX_BUF_SIZE); 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), self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
fp_cmd_run_state, 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); 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 static void
fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device) 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)) 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, goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_ON,
false, false,
NULL, NULL,
@@ -501,7 +530,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
fp_pwr_btn_shield_cb); fp_pwr_btn_shield_cb);
break; break;
case FP_VERIFY_CAPTURE: case GOODIX_VERIFY_CAPTURE:
fpi_device_report_finger_status_changes (device, fpi_device_report_finger_status_changes (device,
FP_FINGER_STATUS_NEEDED, FP_FINGER_STATUS_NEEDED,
FP_FINGER_STATUS_NONE); FP_FINGER_STATUS_NONE);
@@ -512,7 +541,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
fp_verify_capture_cb); fp_verify_capture_cb);
break; break;
case FP_VERIFY_IDENTIFY: case GOODIX_VERIFY_IDENTIFY:
goodix_sensor_cmd (self, MOC_CMD0_IDENTIFY, MOC_CMD1_DEFAULT, goodix_sensor_cmd (self, MOC_CMD0_IDENTIFY, MOC_CMD1_DEFAULT,
false, false,
(const guint8 *) nonce, (const guint8 *) nonce,
@@ -520,7 +549,18 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
fp_verify_cb); fp_verify_cb);
break; 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, goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_OFF,
false, false,
NULL, NULL,
@@ -682,7 +722,7 @@ fp_enroll_capture_cb (FpiDeviceGoodixMoc *self,
self->enroll_stage, self->enroll_stage,
NULL, NULL,
fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL)); 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; return;
} }
fpi_device_report_finger_status_changes (FP_DEVICE (self), fpi_device_report_finger_status_changes (FP_DEVICE (self),
@@ -700,7 +740,7 @@ fp_enroll_capture_cb (FpiDeviceGoodixMoc *self,
self->enroll_stage, self->enroll_stage,
NULL, NULL,
fpi_device_retry_new (FP_DEVICE_RETRY_CENTER_FINGER)); 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; return;
} }
else else
@@ -746,7 +786,7 @@ fp_enroll_update_cb (FpiDeviceGoodixMoc *self,
/* if enroll complete, no need to wait finger up */ /* if enroll complete, no need to wait finger up */
if (self->enroll_stage >= self->max_enroll_stage) 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; 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 reach max timeout(5sec) finger not up, switch to finger up again */
if (resp->finger_status.status == GX_ERROR_WAIT_FINGER_UP_TIMEOUT) 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; return;
} }
else if (resp->finger_status.status != GX_SUCCESS) else if (resp->finger_status.status != GX_SUCCESS)
@@ -827,7 +867,7 @@ fp_finger_mode_cb (FpiDeviceGoodixMoc *self,
FP_FINGER_STATUS_PRESENT); FP_FINGER_STATUS_PRESENT);
if (self->enroll_stage < self->max_enroll_stage) 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; return;
} }
fpi_ssm_next_state (self->task_ssm); 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)) 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, goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_ON,
false, false,
@@ -863,7 +903,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_ENROLL_ENUM: case GOODIX_ENROLL_ENUM:
{ {
goodix_sensor_cmd (self, MOC_CMD0_GETFINGERLIST, MOC_CMD1_DEFAULT, goodix_sensor_cmd (self, MOC_CMD0_GETFINGERLIST, MOC_CMD1_DEFAULT,
false, false,
@@ -873,7 +913,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_ENROLL_CREATE: case GOODIX_ENROLL_CREATE:
{ {
goodix_sensor_cmd (self, MOC_CMD0_ENROLL_INIT, MOC_CMD1_DEFAULT, goodix_sensor_cmd (self, MOC_CMD0_ENROLL_INIT, MOC_CMD1_DEFAULT,
false, false,
@@ -883,7 +923,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; break;
case FP_ENROLL_CAPTURE: case GOODIX_ENROLL_CAPTURE:
fpi_device_report_finger_status_changes (device, fpi_device_report_finger_status_changes (device,
FP_FINGER_STATUS_NEEDED, FP_FINGER_STATUS_NEEDED,
FP_FINGER_STATUS_NONE); FP_FINGER_STATUS_NONE);
@@ -894,7 +934,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
fp_enroll_capture_cb); fp_enroll_capture_cb);
break; break;
case FP_ENROLL_UPDATE: case GOODIX_ENROLL_UPDATE:
dummy[0] = 1; dummy[0] = 1;
dummy[1] = self->sensorcfg->config[2]; dummy[1] = self->sensorcfg->config[2];
dummy[2] = self->sensorcfg->config[3]; dummy[2] = self->sensorcfg->config[3];
@@ -905,7 +945,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
fp_enroll_update_cb); fp_enroll_update_cb);
break; break;
case FP_ENROLL_WAIT_FINGER_UP: case GOODIX_ENROLL_WAIT_FINGER_UP:
dummy[0] = 0; dummy[0] = 0;
goodix_sensor_cmd (self, MOC_CMD0_FINGER_MODE, MOC_CMD1_SET_FINGER_UP, goodix_sensor_cmd (self, MOC_CMD0_FINGER_MODE, MOC_CMD1_SET_FINGER_UP,
true, true,
@@ -914,7 +954,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
fp_finger_mode_cb); fp_finger_mode_cb);
break; break;
case FP_ENROLL_CHECK_DUPLICATE: case GOODIX_ENROLL_CHECK_DUPLICATE:
goodix_sensor_cmd (self, MOC_CMD0_CHECK4DUPLICATE, MOC_CMD1_DEFAULT, goodix_sensor_cmd (self, MOC_CMD0_CHECK4DUPLICATE, MOC_CMD1_DEFAULT,
false, false,
(const guint8 *) &dummy, (const guint8 *) &dummy,
@@ -922,7 +962,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
fp_enroll_check_duplicate_cb); fp_enroll_check_duplicate_cb);
break; break;
case FP_ENROLL_COMMIT: case GOODIX_ENROLL_COMMIT:
{ {
fpi_device_get_enroll_data (device, &print); fpi_device_get_enroll_data (device, &print);
user_id = fpi_print_generate_user_id (print); user_id = fpi_print_generate_user_id (print);
@@ -975,7 +1015,7 @@ fp_enroll_sm_run_state (FpiSsm *ssm, FpDevice *device)
} }
break; 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, goodix_sensor_cmd (self, MOC_CMD0_PWR_BTN_SHIELD, MOC_CMD1_PWR_BTN_SHIELD_OFF,
false, 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 ("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."); 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 else
{ {
@@ -1107,7 +1147,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
switch (fpi_ssm_get_cur_state (ssm)) 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, goodix_sensor_cmd (self, MOC_CMD0_GET_VERSION, MOC_CMD1_DEFAULT,
false, false,
&dummy, &dummy,
@@ -1115,7 +1155,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
fp_init_version_cb); fp_init_version_cb);
break; break;
case FP_INIT_CONFIG: case GOODIX_INIT_CONFIG:
goodix_sensor_cmd (self, MOC_CMD0_UPDATE_CONFIG, MOC_CMD1_WRITE_CFG_TO_FLASH, goodix_sensor_cmd (self, MOC_CMD0_UPDATE_CONFIG, MOC_CMD1_WRITE_CFG_TO_FLASH,
false, false,
(guint8 *) self->sensorcfg, (guint8 *) self->sensorcfg,
@@ -1123,7 +1163,7 @@ fp_init_sm_run_state (FpiSsm *ssm, FpDevice *device)
fp_init_config_cb); fp_init_config_cb);
break; break;
case FP_INIT_TEMPLATE_LIST: case GOODIX_INIT_TEMPLATE_LIST:
/* List prints to check whether the template DB was corrupted. /* 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 * 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 * 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); fp_init_cb_reset_or_complete);
break; break;
case FP_INIT_RESET_DEVICE: case GOODIX_INIT_RESET_DEVICE:
fp_warn ("Resetting device storage, you will need to enroll all prints again!"); fp_warn ("Resetting device storage, you will need to enroll all prints again!");
goodix_sensor_cmd (self, MOC_CMD0_DELETETEMPLATE, MOC_CMD1_DELETE_ALL, goodix_sensor_cmd (self, MOC_CMD0_DELETETEMPLATE, MOC_CMD1_DELETE_ALL,
FALSE, FALSE,
@@ -1452,7 +1492,7 @@ gx_fp_init (FpDevice *device)
} }
self->task_ssm = fpi_ssm_new (device, fp_init_sm_run_state, 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); 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); FpiDeviceGoodixMoc *self = FPI_DEVICE_GOODIXMOC (device);
self->task_ssm = fpi_ssm_new_full (device, fp_verify_sm_run_state, self->task_ssm = fpi_ssm_new_full (device, fp_verify_sm_run_state,
FP_VERIFY_NUM_STATES, GOODIX_VERIFY_NUM_STATES,
FP_VERIFY_PWR_BTN_SHIELD_OFF, GOODIX_VERIFY_PWR_BTN_SHIELD_OFF,
"verify"); "verify");
fpi_ssm_start (self->task_ssm, fp_verify_ssm_done); fpi_ssm_start (self->task_ssm, fp_verify_ssm_done);
@@ -1535,8 +1575,8 @@ gx_fp_enroll (FpDevice *device)
self->enroll_stage = 0; self->enroll_stage = 0;
self->task_ssm = fpi_ssm_new_full (device, fp_enroll_sm_run_state, self->task_ssm = fpi_ssm_new_full (device, fp_enroll_sm_run_state,
FP_ENROLL_NUM_STATES, GOODIX_ENROLL_NUM_STATES,
FP_ENROLL_PWR_BTN_SHIELD_OFF, GOODIX_ENROLL_PWR_BTN_SHIELD_OFF,
"enroll"); "enroll");
fpi_ssm_start (self->task_ssm, fp_enroll_ssm_done); 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 = 0x6A94, },
{ .vid = 0x27c6, .pid = 0x6512, }, { .vid = 0x27c6, .pid = 0x6512, },
{ .vid = 0x27c6, .pid = 0x689A, }, { .vid = 0x27c6, .pid = 0x689A, },
{ .vid = 0x27c6, .pid = 0x66A9, },
{ .vid = 0, .pid = 0, .driver_data = 0 }, /* terminating entry */ { .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) G_DECLARE_FINAL_TYPE (FpiDeviceGoodixMoc, fpi_device_goodixmoc, FPI, DEVICE_GOODIXMOC, FpDevice)
typedef enum { typedef enum {
FP_CMD_SEND = 0, GOODIX_CMD_SEND = 0,
FP_CMD_GET_ACK, GOODIX_CMD_GET_ACK,
FP_CMD_GET_DATA, GOODIX_CMD_GET_DATA,
FP_CMD_NUM_STATES, GOODIX_CMD_NUM_STATES,
} FpCmdState; } GoodixCmdState;
typedef enum { typedef enum {
FP_INIT_VERSION = 0, GOODIX_INIT_VERSION = 0,
FP_INIT_CONFIG, GOODIX_INIT_CONFIG,
FP_INIT_TEMPLATE_LIST, GOODIX_INIT_TEMPLATE_LIST,
FP_INIT_RESET_DEVICE, GOODIX_INIT_RESET_DEVICE,
FP_INIT_NUM_STATES, GOODIX_INIT_NUM_STATES,
} FpInitState; } GoodixInitState;
typedef enum { typedef enum {
FP_ENROLL_PWR_BTN_SHIELD_ON = 0, GOODIX_ENROLL_PWR_BTN_SHIELD_ON = 0,
FP_ENROLL_ENUM, GOODIX_ENROLL_ENUM,
FP_ENROLL_CREATE, GOODIX_ENROLL_CREATE,
FP_ENROLL_CAPTURE, GOODIX_ENROLL_CAPTURE,
FP_ENROLL_UPDATE, GOODIX_ENROLL_UPDATE,
FP_ENROLL_WAIT_FINGER_UP, GOODIX_ENROLL_WAIT_FINGER_UP,
FP_ENROLL_CHECK_DUPLICATE, GOODIX_ENROLL_CHECK_DUPLICATE,
FP_ENROLL_COMMIT, GOODIX_ENROLL_COMMIT,
FP_ENROLL_PWR_BTN_SHIELD_OFF, GOODIX_ENROLL_PWR_BTN_SHIELD_OFF,
FP_ENROLL_NUM_STATES, GOODIX_ENROLL_NUM_STATES,
} FpEnrollState; } GoodixEnrollState;
typedef enum { typedef enum {
FP_VERIFY_PWR_BTN_SHIELD_ON = 0, GOODIX_VERIFY_PWR_BTN_SHIELD_ON = 0,
FP_VERIFY_CAPTURE, GOODIX_VERIFY_CAPTURE,
FP_VERIFY_IDENTIFY, GOODIX_VERIFY_IDENTIFY,
FP_VERIFY_PWR_BTN_SHIELD_OFF, GOODIX_VERIFY_WAIT_FINGER_UP,
FP_VERIFY_NUM_STATES, GOODIX_VERIFY_PWR_BTN_SHIELD_OFF,
} FpVerifyState; 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[] = { static const FpIdEntry id_table[] = {
{ .vid = 0x0bda, .pid = 0x5813, }, { .vid = 0x0bda, .pid = 0x5813, },
{ .vid = 0x0bda, .pid = 0x5816, }, { .vid = 0x0bda, .pid = 0x5816, },
{ .vid = 0x2541, .pid = 0xfa03, },
{ .vid = 0, .pid = 0, .driver_data = 0 }, /* terminating entry */ { .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 = 0x00C4, },
{ .vid = SYNAPTICS_VENDOR_ID, .pid = 0x00C6, }, { .vid = SYNAPTICS_VENDOR_ID, .pid = 0x00C6, },
{ .vid = SYNAPTICS_VENDOR_ID, .pid = 0x00DF, }, { .vid = SYNAPTICS_VENDOR_ID, .pid = 0x00DF, },
{ .vid = SYNAPTICS_VENDOR_ID, .pid = 0x00E9, },
{ .vid = SYNAPTICS_VENDOR_ID, .pid = 0x00F0, }, { .vid = SYNAPTICS_VENDOR_ID, .pid = 0x00F0, },
{ .vid = SYNAPTICS_VENDOR_ID, .pid = 0x00F9, }, { .vid = SYNAPTICS_VENDOR_ID, .pid = 0x00F9, },
{ .vid = SYNAPTICS_VENDOR_ID, .pid = 0x00FC, }, { .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 = 0x0129, },
{ .vid = SYNAPTICS_VENDOR_ID, .pid = 0x015F, }, { .vid = SYNAPTICS_VENDOR_ID, .pid = 0x015F, },
{ .vid = SYNAPTICS_VENDOR_ID, .pid = 0x0168, }, { .vid = SYNAPTICS_VENDOR_ID, .pid = 0x0168, },
{ .vid = SYNAPTICS_VENDOR_ID, .pid = 0x0169, },
{ .vid = SYNAPTICS_VENDOR_ID, .pid = 0x016C, }, { .vid = SYNAPTICS_VENDOR_ID, .pid = 0x016C, },
{ .vid = SYNAPTICS_VENDOR_ID, .pid = 0x0173, }, { .vid = SYNAPTICS_VENDOR_ID, .pid = 0x0173, },
{ .vid = SYNAPTICS_VENDOR_ID, .pid = 0x0174, }, { .vid = SYNAPTICS_VENDOR_ID, .pid = 0x0174, },
{ .vid = SYNAPTICS_VENDOR_ID, .pid = 0x019D, }, { .vid = SYNAPTICS_VENDOR_ID, .pid = 0x019D, },
{ .vid = SYNAPTICS_VENDOR_ID, .pid = 0x019F, }, { .vid = SYNAPTICS_VENDOR_ID, .pid = 0x019F, },
{ .vid = SYNAPTICS_VENDOR_ID, .pid = 0x01A0, },
{ .vid = 0, .pid = 0, .driver_data = 0 }, /* terminating entry */ { .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, NULL,
G_PARAM_STATIC_STRINGS | G_PARAM_READABLE); G_PARAM_STATIC_STRINGS | G_PARAM_READABLE);
/**
* FpDevice:open: (getter is_open):
*/
properties[PROP_OPEN] = properties[PROP_OPEN] =
g_param_spec_boolean ("open", g_param_spec_boolean ("open",
"Opened", "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 = 0x008a },
{ .vid = 0x06cb, .pid = 0x009a }, { .vid = 0x06cb, .pid = 0x009a },
{ .vid = 0x06cb, .pid = 0x009b }, { .vid = 0x06cb, .pid = 0x009b },
{ .vid = 0x06cb, .pid = 0x00a1 },
{ .vid = 0x06cb, .pid = 0x00a2 }, { .vid = 0x06cb, .pid = 0x00a2 },
{ .vid = 0x06cb, .pid = 0x00a8 }, { .vid = 0x06cb, .pid = 0x00a8 },
{ .vid = 0x06cb, .pid = 0x00b7 }, { .vid = 0x06cb, .pid = 0x00b7 },
{ .vid = 0x06cb, .pid = 0x00bb }, { .vid = 0x06cb, .pid = 0x00bb },
{ .vid = 0x06cb, .pid = 0x00bc },
{ .vid = 0x06cb, .pid = 0x00be }, { .vid = 0x06cb, .pid = 0x00be },
{ .vid = 0x06cb, .pid = 0x00cb }, { .vid = 0x06cb, .pid = 0x00cb },
{ .vid = 0x06cb, .pid = 0x00c9 }, { .vid = 0x06cb, .pid = 0x00c9 },
@@ -76,7 +78,6 @@ static const FpIdEntry allowlist_id_table[] = {
{ .vid = 0x06cb, .pid = 0x00dc }, { .vid = 0x06cb, .pid = 0x00dc },
{ .vid = 0x06cb, .pid = 0x00e4 }, { .vid = 0x06cb, .pid = 0x00e4 },
{ .vid = 0x06cb, .pid = 0x00e7 }, { .vid = 0x06cb, .pid = 0x00e7 },
{ .vid = 0x06cb, .pid = 0x00e9 },
{ .vid = 0x06cb, .pid = 0x00fd }, { .vid = 0x06cb, .pid = 0x00fd },
{ .vid = 0x06cb, .pid = 0x00ff }, { .vid = 0x06cb, .pid = 0x00ff },
{ .vid = 0x0a5c, .pid = 0x5801 }, { .vid = 0x0a5c, .pid = 0x5801 },
@@ -97,9 +98,11 @@ static const FpIdEntry allowlist_id_table[] = {
{ .vid = 0x0bda, .pid = 0x5812 }, { .vid = 0x0bda, .pid = 0x5812 },
{ .vid = 0x10a5, .pid = 0x0007 }, { .vid = 0x10a5, .pid = 0x0007 },
{ .vid = 0x10a5, .pid = 0x9200 }, { .vid = 0x10a5, .pid = 0x9200 },
{ .vid = 0x10a5, .pid = 0x9201 },
{ .vid = 0x10a5, .pid = 0x9800 }, { .vid = 0x10a5, .pid = 0x9800 },
{ .vid = 0x10a5, .pid = 0xa120 }, { .vid = 0x10a5, .pid = 0xa120 },
{ .vid = 0x10a5, .pid = 0xa900 }, { .vid = 0x10a5, .pid = 0xa900 },
{ .vid = 0x10a5, .pid = 0xa921 },
{ .vid = 0x10a5, .pid = 0xe340 }, { .vid = 0x10a5, .pid = 0xe340 },
{ .vid = 0x1188, .pid = 0x9545 }, { .vid = 0x1188, .pid = 0x9545 },
{ .vid = 0x138a, .pid = 0x0007 }, { .vid = 0x138a, .pid = 0x0007 },
@@ -120,7 +123,6 @@ static const FpIdEntry allowlist_id_table[] = {
{ .vid = 0x1c7a, .pid = 0x0300 }, { .vid = 0x1c7a, .pid = 0x0300 },
{ .vid = 0x1c7a, .pid = 0x0575 }, { .vid = 0x1c7a, .pid = 0x0575 },
{ .vid = 0x1c7a, .pid = 0x0576 }, { .vid = 0x1c7a, .pid = 0x0576 },
{ .vid = 0x1c7a, .pid = 0x0584 },
{ .vid = 0x1c7a, .pid = 0x0577 }, { .vid = 0x1c7a, .pid = 0x0577 },
{ .vid = 0x1c7a, .pid = 0x057e }, { .vid = 0x1c7a, .pid = 0x057e },
{ .vid = 0x2541, .pid = 0x0236 }, { .vid = 0x2541, .pid = 0x0236 },
@@ -154,12 +156,14 @@ static const FpIdEntry allowlist_id_table[] = {
{ .vid = 0x27c6, .pid = 0x581a }, { .vid = 0x27c6, .pid = 0x581a },
{ .vid = 0x27c6, .pid = 0x589a }, { .vid = 0x27c6, .pid = 0x589a },
{ .vid = 0x27c6, .pid = 0x5f10 }, { .vid = 0x27c6, .pid = 0x5f10 },
{ .vid = 0x27c6, .pid = 0x5f91 },
{ .vid = 0x27c6, .pid = 0x6382 }, { .vid = 0x27c6, .pid = 0x6382 },
{ .vid = 0x2808, .pid = 0x9338 }, { .vid = 0x2808, .pid = 0x9338 },
{ .vid = 0x2808, .pid = 0x9348 }, { .vid = 0x2808, .pid = 0x9348 },
{ .vid = 0x2808, .pid = 0x93a9 }, { .vid = 0x2808, .pid = 0x93a9 },
{ .vid = 0x2808, .pid = 0xa658 }, { .vid = 0x2808, .pid = 0xa658 },
{ .vid = 0x2808, .pid = 0xc652 }, { .vid = 0x2808, .pid = 0xc652 },
{ .vid = 0x2808, .pid = 0xa553 },
{ .vid = 0x298d, .pid = 0x2020 }, { .vid = 0x298d, .pid = 0x2020 },
{ .vid = 0x298d, .pid = 0x2033 }, { .vid = 0x298d, .pid = 0x2033 },
{ .vid = 0x2df0, .pid = 0x0003 }, { .vid = 0x2df0, .pid = 0x0003 },

2
libfprint/meson.build
View File

@@ -278,6 +278,7 @@ libnbis = static_library('nbis',
'-Wno-discarded-qualifiers', '-Wno-discarded-qualifiers',
'-Wno-array-bounds', '-Wno-array-bounds',
'-Wno-array-parameter', '-Wno-array-parameter',
'-Wno-unused-but-set-variable',
]), ]),
install: false) install: false)
@@ -433,6 +434,7 @@ if get_option('introspection')
'GObject-2.0', 'GObject-2.0',
'GUsb-1.0', 'GUsb-1.0',
], ],
fatal_warnings: true,
install : true) install : true)
libfprint_gir = libfprint_girtarget[0] libfprint_gir = libfprint_girtarget[0]
libfprint_typelib = libfprint_girtarget[1] libfprint_typelib = libfprint_girtarget[1]

2
meson.build
View File

@@ -1,5 +1,5 @@
project('libfprint', [ 'c', 'cpp' ], project('libfprint', [ 'c', 'cpp' ],
version: '1.94.9', version: '1.94.10',
license: 'LGPLv2.1+', license: 'LGPLv2.1+',
default_options: [ default_options: [
'buildtype=debugoptimized', '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 fun:realloc
obj:/usr/lib/*/libpython3*.so.* 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.*
}