fdo-mirrors/libfprint
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libfprint/libfprint.git synced 2025-12-20 14:00:06 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

drivers: Do not use Fp-prefix for driver-specific types

Browse source 
It's a libfprint specific prefix, so let's avoid confusion.
This commit is contained in:
Marco Trevisan (Treviño) 2025-02-24 23:10:52 +01:00 • committed by Marco Trevisan
parent 9a4faf378e
commit c2988ae33d
6 changed files with 151 additions and 151 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

14
libfprint/drivers/elanmoc/elanmoc.c
View file

@ -132,10 +132,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 +146,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 +162,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 +229,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);

14
libfprint/drivers/focaltech_moc/focaltech_moc.c
View file

@ -235,10 +235,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 +249,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 +266,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 +334,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);

90
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,
@ -368,7 +368,7 @@ fpc_sensor_cmd (FpiDeviceFpcMoc *self,
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 +743,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 +762,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 +780,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 +815,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 +943,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 +968,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 +983,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 +1001,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 +1015,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 +1030,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 +1045,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 +1060,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 +1114,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 +1129,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 +1142,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 +1287,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 +1305,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 +1319,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 +1334,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 +1404,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 +1431,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 +1536,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 +1548,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 +1682,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);
} }
@ -1705,8 +1705,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 +1722,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 +1774,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 +1796,10 @@ 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 ()); g_set_object (&self->interrupt_cancellable, g_cancellable_new ());
fpi_ssm_jump_to_state (self->cmd_ssm, FP_CMD_RESUME); fpi_ssm_jump_to_state (self->cmd_ssm, FPC_CMD_RESUME);
} }
static void static void
@ -1863,8 +1863,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;

64
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);
@ -493,7 +493,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 +501,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 +512,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 +520,7 @@ 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_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 +682,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 +700,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 +746,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 +812,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 +827,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 +853,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 +863,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 +873,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 +883,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 +894,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 +905,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 +914,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 +922,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 +975,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 +1066,7 @@ fp_init_cb_reset_or_complete (FpiDeviceGoodixMoc *self,
{ {
fp_warn ("Template storage appears to have been corrupted! Error was: %s", error->message); fp_warn ("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 +1107,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 +1115,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 +1123,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 +1138,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 +1452,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 +1518,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 +1535,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);

56
libfprint/drivers/goodixmoc/goodix.h
View file

@ -25,39 +25,39 @@
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_PWR_BTN_SHIELD_OFF,
FP_VERIFY_NUM_STATES, GOODIX_VERIFY_NUM_STATES,
} FpVerifyState; } GoodixVerifyState;