fdo-mirrors/libfprint
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/libfprint/libfprint.git synced 2025-12-20 08:10: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 {
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 +146,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 +162,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 +229,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);

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

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

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

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))
{
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);
@ -493,7 +493,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 +501,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 +512,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 +520,7 @@ fp_verify_sm_run_state (FpiSsm *ssm, FpDevice *device)
fp_verify_cb);
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,
false,
NULL,
@ -682,7 +682,7 @@ fp_enroll_capture_cb (FpiDeviceGoodixMoc *self,
self->enroll_stage,
NULL,
fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL));
fpi_ssm_jump_to_state (self->task_ssm, 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 +700,7 @@ fp_enroll_capture_cb (FpiDeviceGoodixMoc *self,
self->enroll_stage,
NULL,
fpi_device_retry_new (FP_DEVICE_RETRY_CENTER_FINGER));
fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_CAPTURE);
return;
}
else
@ -746,7 +746,7 @@ fp_enroll_update_cb (FpiDeviceGoodixMoc *self,
/* if enroll complete, no need to wait finger up */
if (self->enroll_stage >= self->max_enroll_stage)
{
fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CHECK_DUPLICATE);
fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_CHECK_DUPLICATE);
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 (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 +827,7 @@ fp_finger_mode_cb (FpiDeviceGoodixMoc *self,
FP_FINGER_STATUS_PRESENT);
if (self->enroll_stage < self->max_enroll_stage)
{
fpi_ssm_jump_to_state (self->task_ssm, FP_ENROLL_CAPTURE);
fpi_ssm_jump_to_state (self->task_ssm, GOODIX_ENROLL_CAPTURE);
return;
}
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))
{
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 +863,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 +873,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 +883,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 +894,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 +905,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 +914,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 +922,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 +975,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 +1066,7 @@ fp_init_cb_reset_or_complete (FpiDeviceGoodixMoc *self,
{
fp_warn ("Template storage appears to have been corrupted! Error was: %s", error->message);
fp_warn ("A known reason for this to happen is a firmware bug triggered by another storage area being initialized.");
fpi_ssm_jump_to_state (self->task_ssm, FP_INIT_RESET_DEVICE);
fpi_ssm_jump_to_state (self->task_ssm, GOODIX_INIT_RESET_DEVICE);
}
else
{
@ -1107,7 +1107,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 +1115,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 +1123,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 +1138,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 +1452,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 +1518,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 +1535,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);

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

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