depau/libfprint
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

ssm: Make possible to set data via function

Browse source 
Use the same approach of GTask, making possible to set the data from a
function. Givent the fact that a SSM has now a device parameter, it's
generally not needed to pass an extra data value.

In such case make it possible to set it and to define a destroy-notify
function to handle its destruction when freeing the SSM.
This commit is contained in:
Marco Trevisan (Treviño) 2019-11-20 18:05:46 +01:00 committed by Benjamin Berg
parent 1319daba54
commit 7bc62821ee
20 changed files with 277 additions and 330 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
doc/libfprint-sections.txt
View file

@ -218,7 +218,8 @@ fpi_ssm_next_state
fpi_ssm_jump_to_state fpi_ssm_jump_to_state
fpi_ssm_mark_completed fpi_ssm_mark_completed
fpi_ssm_mark_failed fpi_ssm_mark_failed
fpi_ssm_get_user_data fpi_ssm_set_data
fpi_ssm_get_data
fpi_ssm_get_error fpi_ssm_get_error
fpi_ssm_dup_error fpi_ssm_dup_error
fpi_ssm_get_cur_state fpi_ssm_get_cur_state

22
libfprint/drivers/aes1610.c
View file

@ -648,9 +648,9 @@ capture_read_strip_cb (FpiUsbTransfer *transfer, FpDevice *device,
} }
static void static void
capture_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) capture_run_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceAes1610 *self = FPI_DEVICE_AES1610 (_dev); FpiDeviceAes1610 *self = FPI_DEVICE_AES1610 (_dev);
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
@ -690,10 +690,9 @@ capture_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
} }
static void static void
capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data, capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
GError *error)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceAes1610 *self = FPI_DEVICE_AES1610 (_dev); FpiDeviceAes1610 *self = FPI_DEVICE_AES1610 (_dev);
G_DEBUG_HERE (); G_DEBUG_HERE ();
@ -727,7 +726,7 @@ start_capture (FpImageDevice *dev)
} }
ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state, ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state,
CAPTURE_NUM_STATES, dev); CAPTURE_NUM_STATES);
G_DEBUG_HERE (); G_DEBUG_HERE ();
fpi_ssm_start (ssm, capture_sm_complete); fpi_ssm_start (ssm, capture_sm_complete);
} }
@ -750,9 +749,9 @@ enum activate_states {
}; };
static void static void
activate_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) activate_run_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
/* activation on aes1610 seems much more straightforward compared to aes2501 */ /* activation on aes1610 seems much more straightforward compared to aes2501 */
/* verify there's anything missing here */ /* verify there's anything missing here */
@ -767,10 +766,9 @@ activate_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
/* jump to finger detection */ /* jump to finger detection */
static void static void
activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
void *user_data, GError *error)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
fpi_image_device_activate_complete (dev, error); fpi_image_device_activate_complete (dev, error);
@ -784,7 +782,7 @@ dev_activate (FpImageDevice *dev)
{ {
FpiDeviceAes1610 *self = FPI_DEVICE_AES1610 (dev); FpiDeviceAes1610 *self = FPI_DEVICE_AES1610 (dev);
FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state, FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state,
ACTIVATE_NUM_STATES, dev); ACTIVATE_NUM_STATES);
self->read_regs_retry_count = 0; self->read_regs_retry_count = 0;
fpi_ssm_start (ssm, activate_sm_complete); fpi_ssm_start (ssm, activate_sm_complete);

20
libfprint/drivers/aes2501.c
View file

@ -505,9 +505,9 @@ capture_read_strip_cb (FpiUsbTransfer *transfer, FpDevice *_dev,
} }
static void static void
capture_run_state (FpiSsm *ssm, FpDevice *device, void *user_data) capture_run_state (FpiSsm *ssm, FpDevice *device)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (device);
FpiDeviceAes2501 *self = FPI_DEVICE_AES2501 (device); FpiDeviceAes2501 *self = FPI_DEVICE_AES2501 (device);
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
@ -555,10 +555,9 @@ capture_run_state (FpiSsm *ssm, FpDevice *device, void *user_data)
} }
static void static void
capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data, capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
GError *error)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceAes2501 *self = FPI_DEVICE_AES2501 (_dev); FpiDeviceAes2501 *self = FPI_DEVICE_AES2501 (_dev);
G_DEBUG_HERE (); G_DEBUG_HERE ();
@ -595,7 +594,7 @@ start_capture (FpImageDevice *dev)
/* Reset gain */ /* Reset gain */
strip_scan_reqs[4].value = AES2501_ADREFHI_MAX_VALUE; strip_scan_reqs[4].value = AES2501_ADREFHI_MAX_VALUE;
ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state, ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state,
CAPTURE_NUM_STATES, dev); CAPTURE_NUM_STATES);
G_DEBUG_HERE (); G_DEBUG_HERE ();
fpi_ssm_start (ssm, capture_sm_complete); fpi_ssm_start (ssm, capture_sm_complete);
} }
@ -739,9 +738,9 @@ activate_init3_cb (FpImageDevice *dev, GError *error,
} }
static void static void
activate_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) activate_run_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
/* This state machine isn't as linear as it may appear. After doing init1 /* This state machine isn't as linear as it may appear. After doing init1
* and init2 register configuration writes, we have to poll a register * and init2 register configuration writes, we have to poll a register
@ -801,8 +800,7 @@ activate_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
} }
static void static void
activate_sm_complete (FpiSsm *ssm, FpDevice *dev, activate_sm_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
void *user_data, GError *error)
{ {
fpi_image_device_activate_complete (FP_IMAGE_DEVICE (dev), error); fpi_image_device_activate_complete (FP_IMAGE_DEVICE (dev), error);
@ -816,7 +814,7 @@ dev_activate (FpImageDevice *dev)
{ {
FpiDeviceAes2501 *self = FPI_DEVICE_AES2501 (dev); FpiDeviceAes2501 *self = FPI_DEVICE_AES2501 (dev);
FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state, FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state,
ACTIVATE_NUM_STATES, dev); ACTIVATE_NUM_STATES);
self->read_regs_retry_count = 0; self->read_regs_retry_count = 0;
fpi_ssm_start (ssm, activate_sm_complete); fpi_ssm_start (ssm, activate_sm_complete);

21
libfprint/drivers/aes2550.c
View file

@ -121,7 +121,7 @@ finger_det_reqs_cb (FpiUsbTransfer *t, FpDevice *device,
gpointer user_data, GError *error) gpointer user_data, GError *error)
{ {
FpiUsbTransfer *transfer; FpiUsbTransfer *transfer;
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (device);
if (error) if (error)
{ {
@ -321,7 +321,7 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
} }
static void static void
capture_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data) capture_run_state (FpiSsm *ssm, FpDevice *dev)
{ {
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
{ {
@ -371,11 +371,10 @@ capture_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data)
} }
static void static void
capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data, capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
GError *error)
{ {
FpImageDevice *dev = user_data;
FpiDeviceAes2550 *self = FPI_DEVICE_AES2550 (_dev); FpiDeviceAes2550 *self = FPI_DEVICE_AES2550 (_dev);
FpImageDevice *dev = FP_IMAGE_DEVICE (self);
fp_dbg ("Capture completed"); fp_dbg ("Capture completed");
@ -408,8 +407,7 @@ start_capture (FpImageDevice *dev)
} }
self->heartbeat_cnt = 0; self->heartbeat_cnt = 0;
ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state, ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state, CAPTURE_NUM_STATES);
CAPTURE_NUM_STATES, dev);
G_DEBUG_HERE (); G_DEBUG_HERE ();
fpi_ssm_start (ssm, capture_sm_complete); fpi_ssm_start (ssm, capture_sm_complete);
} }
@ -471,7 +469,7 @@ calibrate_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
} }
static void static void
activate_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data) activate_run_state (FpiSsm *ssm, FpDevice *dev)
{ {
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
{ {
@ -531,10 +529,9 @@ activate_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data)
} }
static void static void
activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
void *user_data, GError *error)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
fpi_image_device_activate_complete (dev, error); fpi_image_device_activate_complete (dev, error);
@ -547,7 +544,7 @@ static void
dev_activate (FpImageDevice *dev) dev_activate (FpImageDevice *dev)
{ {
FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state, FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state,
ACTIVATE_NUM_STATES, dev); ACTIVATE_NUM_STATES);
fpi_ssm_start (ssm, activate_sm_complete); fpi_ssm_start (ssm, activate_sm_complete);
} }

22
libfprint/drivers/aesx660.c
View file

@ -204,8 +204,7 @@ finger_det_set_idle_cmd_cb (FpiUsbTransfer *transfer,
} }
static void static void
finger_det_sm_complete (FpiSsm *ssm, FpDevice *_dev, finger_det_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
void *user_data, GError *error)
{ {
FpImageDevice *dev = FP_IMAGE_DEVICE (_dev); FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceAesX660 *self = FPI_DEVICE_AES_X660 (_dev); FpiDeviceAesX660 *self = FPI_DEVICE_AES_X660 (_dev);
@ -233,7 +232,7 @@ finger_det_sm_complete (FpiSsm *ssm, FpDevice *_dev,
} }
static void static void
finger_det_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data) finger_det_run_state (FpiSsm *ssm, FpDevice *dev)
{ {
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
{ {
@ -272,7 +271,7 @@ start_finger_detection (FpImageDevice *dev)
} }
ssm = fpi_ssm_new (FP_DEVICE (dev), finger_det_run_state, ssm = fpi_ssm_new (FP_DEVICE (dev), finger_det_run_state,
FINGER_DET_NUM_STATES, dev); FINGER_DET_NUM_STATES);
fpi_ssm_start (ssm, finger_det_sm_complete); fpi_ssm_start (ssm, finger_det_sm_complete);
} }
@ -424,7 +423,7 @@ capture_read_stripe_data_cb (FpiUsbTransfer *transfer,
} }
static void static void
capture_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) capture_run_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpiDeviceAesX660 *self = FPI_DEVICE_AES_X660 (_dev); FpiDeviceAesX660 *self = FPI_DEVICE_AES_X660 (_dev);
FpiDeviceAesX660Private *priv = fpi_device_aes_x660_get_instance_private (self); FpiDeviceAesX660Private *priv = fpi_device_aes_x660_get_instance_private (self);
@ -458,8 +457,7 @@ capture_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
} }
static void static void
capture_sm_complete (FpiSsm *ssm, FpDevice *device, void *user_data, capture_sm_complete (FpiSsm *ssm, FpDevice *device, GError *error)
GError *error)
{ {
FpiDeviceAesX660 *self = FPI_DEVICE_AES_X660 (device); FpiDeviceAesX660 *self = FPI_DEVICE_AES_X660 (device);
FpiDeviceAesX660Private *priv = fpi_device_aes_x660_get_instance_private (self); FpiDeviceAesX660Private *priv = fpi_device_aes_x660_get_instance_private (self);
@ -496,8 +494,7 @@ start_capture (FpImageDevice *dev)
return; return;
} }
ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state, ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state, CAPTURE_NUM_STATES);
CAPTURE_NUM_STATES, dev);
G_DEBUG_HERE (); G_DEBUG_HERE ();
fpi_ssm_start (ssm, capture_sm_complete); fpi_ssm_start (ssm, capture_sm_complete);
} }
@ -615,7 +612,7 @@ activate_read_init_cb (FpiUsbTransfer *transfer, FpDevice *device,
} }
static void static void
activate_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) activate_run_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpiDeviceAesX660 *self = FPI_DEVICE_AES_X660 (_dev); FpiDeviceAesX660 *self = FPI_DEVICE_AES_X660 (_dev);
FpiDeviceAesX660Private *priv = fpi_device_aes_x660_get_instance_private (self); FpiDeviceAesX660Private *priv = fpi_device_aes_x660_get_instance_private (self);
@ -666,8 +663,7 @@ activate_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
} }
static void static void
activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
void *user_data, GError *error)
{ {
fpi_image_device_activate_complete (FP_IMAGE_DEVICE (_dev), error); fpi_image_device_activate_complete (FP_IMAGE_DEVICE (_dev), error);
fpi_ssm_free (ssm); fpi_ssm_free (ssm);
@ -680,7 +676,7 @@ static void
aesX660_dev_activate (FpImageDevice *dev) aesX660_dev_activate (FpImageDevice *dev)
{ {
FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state, FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state,
ACTIVATE_NUM_STATES, dev); ACTIVATE_NUM_STATES);
fpi_ssm_start (ssm, activate_sm_complete); fpi_ssm_start (ssm, activate_sm_complete);
} }

35
libfprint/drivers/elan.c
View file

@ -457,8 +457,7 @@ enum stop_capture_states {
}; };
static void static void
stop_capture_run_state (FpiSsm *ssm, FpDevice *dev, stop_capture_run_state (FpiSsm *ssm, FpDevice *dev)
void *user_data)
{ {
G_DEBUG_HERE (); G_DEBUG_HERE ();
@ -472,10 +471,9 @@ stop_capture_run_state (FpiSsm *ssm, FpDevice *dev,
} }
static void static void
stop_capture_complete (FpiSsm *ssm, FpDevice *_dev, stop_capture_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
void *user_data, GError *error)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceElan *self = FPI_DEVICE_ELAN (dev); FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
G_DEBUG_HERE (); G_DEBUG_HERE ();
@ -510,8 +508,7 @@ elan_stop_capture (FpDevice *dev)
elan_dev_reset_state (self); elan_dev_reset_state (self);
FpiSsm *ssm = FpiSsm *ssm =
fpi_ssm_new (dev, stop_capture_run_state, fpi_ssm_new (dev, stop_capture_run_state, STOP_CAPTURE_NUM_STATES);
STOP_CAPTURE_NUM_STATES, dev);
fpi_ssm_start (ssm, stop_capture_complete); fpi_ssm_start (ssm, stop_capture_complete);
} }
@ -524,7 +521,7 @@ enum capture_states {
}; };
static void static void
capture_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data) capture_run_state (FpiSsm *ssm, FpDevice *dev)
{ {
FpImageDevice *idev = FP_IMAGE_DEVICE (dev); FpImageDevice *idev = FP_IMAGE_DEVICE (dev);
FpiDeviceElan *self = FPI_DEVICE_ELAN (dev); FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
@ -577,10 +574,9 @@ capture_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data)
} }
static void static void
capture_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data, capture_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
GError *error)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceElan *self = FPI_DEVICE_ELAN (_dev); FpiDeviceElan *self = FPI_DEVICE_ELAN (_dev);
G_DEBUG_HERE (); G_DEBUG_HERE ();
@ -621,8 +617,7 @@ elan_capture (FpDevice *dev)
elan_dev_reset_state (self); elan_dev_reset_state (self);
FpiSsm *ssm = FpiSsm *ssm =
fpi_ssm_new (dev, capture_run_state, CAPTURE_NUM_STATES, fpi_ssm_new (dev, capture_run_state, CAPTURE_NUM_STATES);
dev);
fpi_ssm_start (ssm, capture_complete); fpi_ssm_start (ssm, capture_complete);
} }
@ -684,7 +679,7 @@ elan_supports_calibration (FpiDeviceElan *elandev)
} }
static void static void
calibrate_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data) calibrate_run_state (FpiSsm *ssm, FpDevice *dev)
{ {
FpiDeviceElan *self = FPI_DEVICE_ELAN (dev); FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
@ -776,8 +771,7 @@ calibrate_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data)
} }
static void static void
calibrate_complete (FpiSsm *ssm, FpDevice *dev, void *user_data, calibrate_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
GError *error)
{ {
FpiDeviceElan *self = FPI_DEVICE_ELAN (dev); FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
@ -808,7 +802,7 @@ elan_calibrate (FpDevice *dev)
self->calib_atts_left = ELAN_CALIBRATION_ATTEMPTS; self->calib_atts_left = ELAN_CALIBRATION_ATTEMPTS;
FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), calibrate_run_state, FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), calibrate_run_state,
CALIBRATE_NUM_STATES, dev); CALIBRATE_NUM_STATES);
fpi_ssm_start (ssm, calibrate_complete); fpi_ssm_start (ssm, calibrate_complete);
} }
@ -822,7 +816,7 @@ enum activate_states {
}; };
static void static void
activate_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data) activate_run_state (FpiSsm *ssm, FpDevice *dev)
{ {
FpiDeviceElan *self = FPI_DEVICE_ELAN (dev); FpiDeviceElan *self = FPI_DEVICE_ELAN (dev);
@ -883,8 +877,7 @@ activate_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data)
} }
static void static void
activate_complete (FpiSsm *ssm, FpDevice *dev, void *user_data, activate_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
GError *error)
{ {
FpImageDevice *idev = FP_IMAGE_DEVICE (dev); FpImageDevice *idev = FP_IMAGE_DEVICE (dev);
@ -905,7 +898,7 @@ elan_activate (FpImageDevice *dev)
FpiSsm *ssm = FpiSsm *ssm =
fpi_ssm_new (FP_DEVICE (dev), activate_run_state, fpi_ssm_new (FP_DEVICE (dev), activate_run_state,
ACTIVATE_NUM_STATES, dev); ACTIVATE_NUM_STATES);
fpi_ssm_start (ssm, activate_complete); fpi_ssm_start (ssm, activate_complete);
} }

49
libfprint/drivers/etes603.c
View file

@ -751,7 +751,7 @@ async_tx_cb (FpiUsbTransfer *transfer, FpDevice *device,
} }
static void static void
m_exit_state (FpiSsm *ssm, FpDevice *dev, void *user_data) m_exit_state (FpiSsm *ssm, FpDevice *dev)
{ {
FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev); FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev);
@ -780,8 +780,7 @@ err:
} }
static void static void
m_exit_complete (FpiSsm *ssm, FpDevice *dev, void *user_data, m_exit_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
GError *error)
{ {
FpImageDevice *idev = FP_IMAGE_DEVICE (dev); FpImageDevice *idev = FP_IMAGE_DEVICE (dev);
@ -797,8 +796,7 @@ static void
m_exit_start (FpImageDevice *idev) m_exit_start (FpImageDevice *idev)
{ {
FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (idev); FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (idev);
FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (idev), m_exit_state, FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (idev), m_exit_state, EXIT_NUM_STATES);
EXIT_NUM_STATES, idev);
self->is_active = FALSE; self->is_active = FALSE;
fp_dbg ("Switching device to idle mode"); fp_dbg ("Switching device to idle mode");
@ -806,7 +804,7 @@ m_exit_start (FpImageDevice *idev)
} }
static void static void
m_capture_state (FpiSsm *ssm, FpDevice *dev, void *user_data) m_capture_state (FpiSsm *ssm, FpDevice *dev)
{ {
FpImageDevice *idev = FP_IMAGE_DEVICE (dev); FpImageDevice *idev = FP_IMAGE_DEVICE (dev);
FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev); FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev);
@ -895,8 +893,7 @@ err:
} }
static void static void
m_capture_complete (FpiSsm *ssm, FpDevice *dev, void *user_data, m_capture_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
GError *error)
{ {
FpImageDevice *idev = FP_IMAGE_DEVICE (dev); FpImageDevice *idev = FP_IMAGE_DEVICE (dev);
FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev); FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev);
@ -929,7 +926,7 @@ m_capture_complete (FpiSsm *ssm, FpDevice *dev, void *user_data,
} }
static void static void
m_finger_state (FpiSsm *ssm, FpDevice *dev, void *user_data) m_finger_state (FpiSsm *ssm, FpDevice *dev)
{ {
FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev); FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev);
@ -1037,8 +1034,7 @@ err:
} }
static void static void
m_finger_complete (FpiSsm *ssm, FpDevice *dev, void *user_data, m_finger_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
GError *error)
{ {
FpImageDevice *idev = FP_IMAGE_DEVICE (dev); FpImageDevice *idev = FP_IMAGE_DEVICE (dev);
FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev); FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev);
@ -1046,8 +1042,7 @@ m_finger_complete (FpiSsm *ssm, FpDevice *dev, void *user_data,
if (!error) if (!error)
{ {
FpiSsm *ssm_cap; FpiSsm *ssm_cap;
ssm_cap = fpi_ssm_new (dev, m_capture_state, ssm_cap = fpi_ssm_new (dev, m_capture_state, CAP_NUM_STATES);
CAP_NUM_STATES, NULL);
fpi_ssm_start (ssm_cap, m_capture_complete); fpi_ssm_start (ssm_cap, m_capture_complete);
} }
else else
@ -1074,8 +1069,7 @@ m_start_fingerdetect (FpImageDevice *idev)
{ {
FpiSsm *ssmf; FpiSsm *ssmf;
ssmf = fpi_ssm_new (FP_DEVICE (idev), m_finger_state, FGR_NUM_STATES, ssmf = fpi_ssm_new (FP_DEVICE (idev), m_finger_state, FGR_NUM_STATES);
idev);
fpi_ssm_start (ssmf, m_finger_complete); fpi_ssm_start (ssmf, m_finger_complete);
} }
@ -1083,7 +1077,7 @@ m_start_fingerdetect (FpImageDevice *idev)
* Tune value of VRT and VRB for contrast and brightness. * Tune value of VRT and VRB for contrast and brightness.
*/ */
static void static void
m_tunevrb_state (FpiSsm *ssm, FpDevice *dev, void *user_data) m_tunevrb_state (FpiSsm *ssm, FpDevice *dev)
{ {
FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev); FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev);
float hist[5]; float hist[5];
@ -1256,8 +1250,7 @@ err:
} }
static void static void
m_tunevrb_complete (FpiSsm *ssm, FpDevice *dev, void *user_data, m_tunevrb_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
GError *error)
{ {
FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev); FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev);
FpImageDevice *idev = FP_IMAGE_DEVICE (dev); FpImageDevice *idev = FP_IMAGE_DEVICE (dev);
@ -1280,7 +1273,7 @@ m_tunevrb_complete (FpiSsm *ssm, FpDevice *dev, void *user_data,
* required. * required.
*/ */
static void static void
m_tunedc_state (FpiSsm *ssm, FpDevice *dev, void *user_data) m_tunedc_state (FpiSsm *ssm, FpDevice *dev)
{ {
FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev); FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev);
@ -1394,8 +1387,7 @@ err:
} }
static void static void
m_tunedc_complete (FpiSsm *ssm, FpDevice *dev, void *user_data, m_tunedc_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
GError *error)
{ {
FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev); FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev);
FpImageDevice *idev = FP_IMAGE_DEVICE (dev); FpImageDevice *idev = FP_IMAGE_DEVICE (dev);
@ -1404,7 +1396,7 @@ m_tunedc_complete (FpiSsm *ssm, FpDevice *dev, void *user_data,
{ {
FpiSsm *ssm_tune; FpiSsm *ssm_tune;
ssm_tune = fpi_ssm_new (FP_DEVICE (idev), m_tunevrb_state, ssm_tune = fpi_ssm_new (FP_DEVICE (idev), m_tunevrb_state,
TUNEVRB_NUM_STATES, idev); TUNEVRB_NUM_STATES);
fpi_ssm_start (ssm_tune, m_tunevrb_complete); fpi_ssm_start (ssm_tune, m_tunevrb_complete);
} }
else else
@ -1421,7 +1413,7 @@ m_tunedc_complete (FpiSsm *ssm, FpDevice *dev, void *user_data,
} }
static void static void
m_init_state (FpiSsm *ssm, FpDevice *dev, void *user_data) m_init_state (FpiSsm *ssm, FpDevice *dev)
{ {
FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev); FpiDeviceEtes603 *self = FPI_DEVICE_ETES603 (dev);
@ -1534,8 +1526,7 @@ err:
} }
static void static void
m_init_complete (FpiSsm *ssm, FpDevice *dev, void *user_data, m_init_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
GError *error)
{ {
FpImageDevice *idev = FP_IMAGE_DEVICE (dev); FpImageDevice *idev = FP_IMAGE_DEVICE (dev);
@ -1543,7 +1534,7 @@ m_init_complete (FpiSsm *ssm, FpDevice *dev, void *user_data,
{ {
FpiSsm *ssm_tune; FpiSsm *ssm_tune;
ssm_tune = fpi_ssm_new (FP_DEVICE (idev), m_tunedc_state, ssm_tune = fpi_ssm_new (FP_DEVICE (idev), m_tunedc_state,
TUNEDC_NUM_STATES, idev); TUNEDC_NUM_STATES);
fpi_ssm_start (ssm_tune, m_tunedc_complete); fpi_ssm_start (ssm_tune, m_tunedc_complete);
} }
else else
@ -1569,8 +1560,7 @@ dev_activate (FpImageDevice *idev)
if (self->dcoffset == 0) if (self->dcoffset == 0)
{ {
fp_dbg ("Tuning device..."); fp_dbg ("Tuning device...");
ssm = fpi_ssm_new (FP_DEVICE (idev), m_init_state, ssm = fpi_ssm_new (FP_DEVICE (idev), m_init_state, INIT_NUM_STATES);
INIT_NUM_STATES, idev);
fpi_ssm_start (ssm, m_init_complete); fpi_ssm_start (ssm, m_init_complete);
} }
else else
@ -1579,8 +1569,7 @@ dev_activate (FpImageDevice *idev)
"VRB=0x%02X,GAIN=0x%02X).", self->dcoffset, self->vrt, "VRB=0x%02X,GAIN=0x%02X).", self->dcoffset, self->vrt,
self->vrb, self->gain); self->vrb, self->gain);
fpi_image_device_activate_complete (idev, NULL); fpi_image_device_activate_complete (idev, NULL);
ssm = fpi_ssm_new (FP_DEVICE (idev), m_finger_state, ssm = fpi_ssm_new (FP_DEVICE (idev), m_finger_state, FGR_NUM_STATES);
FGR_NUM_STATES, idev);
fpi_ssm_start (ssm, m_finger_complete); fpi_ssm_start (ssm, m_finger_complete);
} }
} }

16
libfprint/drivers/synaptics/synaptics.c
View file

@ -202,8 +202,7 @@ cmd_interrupt_cb (FpiUsbTransfer *transfer,
static void static void
synaptics_cmd_run_state (FpiSsm *ssm, synaptics_cmd_run_state (FpiSsm *ssm,
FpDevice *dev, FpDevice *dev)
void *user_data)
{ {
g_autoptr(FpiUsbTransfer) transfer = NULL; g_autoptr(FpiUsbTransfer) transfer = NULL;
FpiDeviceSynaptics *self = FPI_DEVICE_SYNAPTICS (dev); FpiDeviceSynaptics *self = FPI_DEVICE_SYNAPTICS (dev);
@ -235,7 +234,7 @@ synaptics_cmd_run_state (FpiSsm *ssm,
5000, 5000,
NULL, NULL,
cmd_recieve_cb, cmd_recieve_cb,
user_data); fpi_ssm_get_data (ssm));
break; break;
@ -271,13 +270,10 @@ synaptics_cmd_run_state (FpiSsm *ssm,
} }
static void static void
cmd_ssm_done (FpiSsm *ssm, cmd_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
FpDevice *dev,
void *user_data,
GError *error)
{ {
FpiDeviceSynaptics *self = FPI_DEVICE_SYNAPTICS (dev); FpiDeviceSynaptics *self = FPI_DEVICE_SYNAPTICS (dev);
SynCmdMsgCallback callback = user_data; SynCmdMsgCallback callback = fpi_ssm_get_data (ssm);
self->cmd_ssm = NULL; self->cmd_ssm = NULL;
@ -399,8 +395,8 @@ synaptics_sensor_cmd (FpiDeviceSynaptics *self,
self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self), self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self),
synaptics_cmd_run_state, synaptics_cmd_run_state,
SYNAPTICS_CMD_NUM_STATES, SYNAPTICS_CMD_NUM_STATES);
callback); fpi_ssm_set_data (self->cmd_ssm, callback, NULL);
fpi_ssm_start (self->cmd_ssm, cmd_ssm_done); fpi_ssm_start (self->cmd_ssm, cmd_ssm_done);
} }

78
libfprint/drivers/upeksonly.c
View file

@ -808,10 +808,9 @@ enum awfsm_1000_states {
}; };
static void static void
awfsm_2016_run_state (FpiSsm *ssm, FpDevice *_dev, awfsm_2016_run_state (FpiSsm *ssm, FpDevice *_dev)
void *user_data)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev); FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev);
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
@ -867,8 +866,7 @@ awfsm_2016_run_state (FpiSsm *ssm, FpDevice *_dev,
} }
static void static void
awfsm_1000_run_state (FpiSsm *ssm, FpDevice *_dev, awfsm_1000_run_state (FpiSsm *ssm, FpDevice *_dev)
void *user_data)
{ {
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
{ {
@ -936,10 +934,9 @@ capsm_fire_bulk (FpiSsm *ssm,
} }
static void static void
capsm_2016_run_state (FpiSsm *ssm, FpDevice *_dev, capsm_2016_run_state (FpiSsm *ssm, FpDevice *_dev)
void *user_data)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev); FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev);
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
@ -975,8 +972,7 @@ capsm_2016_run_state (FpiSsm *ssm, FpDevice *_dev,
} }
static void static void
capsm_1000_run_state (FpiSsm *ssm, FpDevice *_dev, capsm_1000_run_state (FpiSsm *ssm, FpDevice *_dev)
void *user_data)
{ {
FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev); FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev);
@ -1005,8 +1001,7 @@ capsm_1000_run_state (FpiSsm *ssm, FpDevice *_dev,
} }
static void static void
capsm_1001_run_state (FpiSsm *ssm, FpDevice *_dev, capsm_1001_run_state (FpiSsm *ssm, FpDevice *_dev)
void *user_data)
{ {
FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev); FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev);
@ -1068,8 +1063,7 @@ enum deinitsm_1001_states {
}; };
static void static void
deinitsm_2016_run_state (FpiSsm *ssm, FpDevice *_dev, deinitsm_2016_run_state (FpiSsm *ssm, FpDevice *_dev)
void *user_data)
{ {
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
{ {
@ -1080,8 +1074,7 @@ deinitsm_2016_run_state (FpiSsm *ssm, FpDevice *_dev,
} }
static void static void
deinitsm_1000_run_state (FpiSsm *ssm, FpDevice *_dev, deinitsm_1000_run_state (FpiSsm *ssm, FpDevice *_dev)
void *user_data)
{ {
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
{ {
@ -1092,8 +1085,7 @@ deinitsm_1000_run_state (FpiSsm *ssm, FpDevice *_dev,
} }
static void static void
deinitsm_1001_run_state (FpiSsm *ssm, FpDevice *_dev, deinitsm_1001_run_state (FpiSsm *ssm, FpDevice *_dev)
void *user_data)
{ {
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
{ {
@ -1131,10 +1123,9 @@ enum initsm_1001_states {
}; };
static void static void
initsm_2016_run_state (FpiSsm *ssm, FpDevice *_dev, initsm_2016_run_state (FpiSsm *ssm, FpDevice *_dev)
void *user_data)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev); FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev);
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
@ -1170,8 +1161,7 @@ initsm_2016_run_state (FpiSsm *ssm, FpDevice *_dev,
} }
static void static void
initsm_1000_run_state (FpiSsm *ssm, FpDevice *_dev, initsm_1000_run_state (FpiSsm *ssm, FpDevice *_dev)
void *user_data)
{ {
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
{ {
@ -1182,8 +1172,7 @@ initsm_1000_run_state (FpiSsm *ssm, FpDevice *_dev,
} }
static void static void
initsm_1001_run_state (FpiSsm *ssm, FpDevice *_dev, initsm_1001_run_state (FpiSsm *ssm, FpDevice *_dev)
void *user_data)
{ {
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
{ {
@ -1222,9 +1211,9 @@ enum loopsm_states {
}; };
static void static void
loopsm_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) loopsm_run_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev); FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev);
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
@ -1252,15 +1241,13 @@ loopsm_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
case UPEKSONLY_2016: case UPEKSONLY_2016:
awfsm = fpi_ssm_new (FP_DEVICE (dev), awfsm = fpi_ssm_new (FP_DEVICE (dev),
awfsm_2016_run_state, awfsm_2016_run_state,
AWFSM_2016_NUM_STATES, AWFSM_2016_NUM_STATES);
dev);
break; break;
case UPEKSONLY_1000: case UPEKSONLY_1000:
awfsm = fpi_ssm_new (FP_DEVICE (dev), awfsm = fpi_ssm_new (FP_DEVICE (dev),
awfsm_1000_run_state, awfsm_1000_run_state,
AWFSM_1000_NUM_STATES, AWFSM_1000_NUM_STATES);
dev);
break; break;
} }
fpi_ssm_start_subsm (ssm, awfsm); fpi_ssm_start_subsm (ssm, awfsm);
@ -1289,19 +1276,19 @@ loopsm_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
case UPEKSONLY_2016: case UPEKSONLY_2016:
capsm = fpi_ssm_new (FP_DEVICE (dev), capsm = fpi_ssm_new (FP_DEVICE (dev),
capsm_2016_run_state, capsm_2016_run_state,
CAPSM_2016_NUM_STATES, dev); CAPSM_2016_NUM_STATES);
break; break;
case UPEKSONLY_1000: case UPEKSONLY_1000:
capsm = fpi_ssm_new (FP_DEVICE (dev), capsm = fpi_ssm_new (FP_DEVICE (dev),
capsm_1000_run_state, capsm_1000_run_state,
CAPSM_1000_NUM_STATES, dev); CAPSM_1000_NUM_STATES);
break; break;
case UPEKSONLY_1001: case UPEKSONLY_1001:
capsm = fpi_ssm_new (FP_DEVICE (dev), capsm = fpi_ssm_new (FP_DEVICE (dev),
capsm_1001_run_state, capsm_1001_run_state,
CAPSM_1001_NUM_STATES, dev); CAPSM_1001_NUM_STATES);
break; break;
} }
fpi_ssm_start_subsm (ssm, capsm); fpi_ssm_start_subsm (ssm, capsm);
@ -1317,19 +1304,19 @@ loopsm_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
case UPEKSONLY_2016: case UPEKSONLY_2016:
deinitsm = fpi_ssm_new (FP_DEVICE (dev), deinitsm = fpi_ssm_new (FP_DEVICE (dev),
deinitsm_2016_run_state, deinitsm_2016_run_state,
DEINITSM_2016_NUM_STATES, dev); DEINITSM_2016_NUM_STATES);
break; break;
case UPEKSONLY_1000: case UPEKSONLY_1000:
deinitsm = fpi_ssm_new (FP_DEVICE (dev), deinitsm = fpi_ssm_new (FP_DEVICE (dev),
deinitsm_1000_run_state, deinitsm_1000_run_state,
DEINITSM_1000_NUM_STATES, dev); DEINITSM_1000_NUM_STATES);
break; break;
case UPEKSONLY_1001: case UPEKSONLY_1001:
deinitsm = fpi_ssm_new (FP_DEVICE (dev), deinitsm = fpi_ssm_new (FP_DEVICE (dev),
deinitsm_1001_run_state, deinitsm_1001_run_state,
DEINITSM_1001_NUM_STATES, dev); DEINITSM_1001_NUM_STATES);
break; break;
} }
self->capturing = FALSE; self->capturing = FALSE;
@ -1379,9 +1366,9 @@ dev_deactivate (FpImageDevice *dev)
} }
static void static void
loopsm_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data, GError *error) loopsm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev); FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev);
fpi_ssm_free (ssm); fpi_ssm_free (ssm);
@ -1400,10 +1387,9 @@ loopsm_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data, GError *error)
} }
static void static void
initsm_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data, initsm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
GError *error)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev); FpiDeviceUpeksonly *self = FPI_DEVICE_UPEKSONLY (_dev);
fpi_ssm_free (ssm); fpi_ssm_free (ssm);
@ -1412,7 +1398,7 @@ initsm_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data,
return; return;
self->loopsm = fpi_ssm_new (FP_DEVICE (dev), loopsm_run_state, self->loopsm = fpi_ssm_new (FP_DEVICE (dev), loopsm_run_state,
LOOPSM_NUM_STATES, dev); LOOPSM_NUM_STATES);
fpi_ssm_start (self->loopsm, loopsm_complete); fpi_ssm_start (self->loopsm, loopsm_complete);
} }
@ -1443,17 +1429,17 @@ dev_activate (FpImageDevice *dev)
{ {
case UPEKSONLY_2016: case UPEKSONLY_2016:
ssm = fpi_ssm_new (FP_DEVICE (dev), initsm_2016_run_state, ssm = fpi_ssm_new (FP_DEVICE (dev), initsm_2016_run_state,
INITSM_2016_NUM_STATES, dev); INITSM_2016_NUM_STATES);
break; break;
case UPEKSONLY_1000: case UPEKSONLY_1000:
ssm = fpi_ssm_new (FP_DEVICE (dev), initsm_1000_run_state, ssm = fpi_ssm_new (FP_DEVICE (dev), initsm_1000_run_state,
INITSM_1000_NUM_STATES, dev); INITSM_1000_NUM_STATES);
break; break;
case UPEKSONLY_1001: case UPEKSONLY_1001:
ssm = fpi_ssm_new (FP_DEVICE (dev), initsm_1001_run_state, ssm = fpi_ssm_new (FP_DEVICE (dev), initsm_1001_run_state,
INITSM_1001_NUM_STATES, dev); INITSM_1001_NUM_STATES);
break; break;
} }
fpi_ssm_start (ssm, initsm_complete); fpi_ssm_start (ssm, initsm_complete);

17
libfprint/drivers/upektc.c
View file

@ -109,7 +109,7 @@ read_init_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
} }
static void static void
activate_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data) activate_run_state (FpiSsm *ssm, FpDevice *dev)
{ {
FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (dev); FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (dev);
@ -149,8 +149,7 @@ activate_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data)
} }
static void static void
activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
void *user_data, GError *error)
{ {
FpImageDevice *dev = FP_IMAGE_DEVICE (_dev); FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
@ -294,7 +293,7 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
} }
static void static void
capture_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) capture_run_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (_dev); FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (_dev);
@ -333,10 +332,9 @@ capture_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
} }
static void static void
capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data, capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
GError *error)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (_dev); FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (_dev);
fp_dbg ("Capture completed"); fp_dbg ("Capture completed");
@ -362,8 +360,7 @@ start_capture (FpImageDevice *dev)
return; return;
} }
ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state, ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state, CAPTURE_NUM_STATES);
CAPTURE_NUM_STATES, dev);
G_DEBUG_HERE (); G_DEBUG_HERE ();
fpi_ssm_start (ssm, capture_sm_complete); fpi_ssm_start (ssm, capture_sm_complete);
} }
@ -373,7 +370,7 @@ dev_activate (FpImageDevice *dev)
{ {
FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (dev); FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC (dev);
FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state, FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state,
ACTIVATE_NUM_STATES, dev); ACTIVATE_NUM_STATES);
self->init_idx = 0; self->init_idx = 0;
fpi_ssm_start (ssm, activate_sm_complete); fpi_ssm_start (ssm, activate_sm_complete);

33
libfprint/drivers/upektc_img.c
View file

@ -338,9 +338,9 @@ capture_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
} }
static void static void
capture_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) capture_run_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev); FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev);
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
@ -382,9 +382,9 @@ capture_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
} }
static void static void
capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data, GError *error_arg) capture_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error_arg)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev); FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev);
g_autoptr(GError) error = error_arg; g_autoptr(GError) error = error_arg;
@ -409,7 +409,7 @@ start_capture (FpImageDevice *dev)
self->image_size = 0; self->image_size = 0;
ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state, ssm = fpi_ssm_new (FP_DEVICE (dev), capture_run_state,
CAPTURE_NUM_STATES, dev); CAPTURE_NUM_STATES);
fpi_ssm_start (ssm, capture_sm_complete); fpi_ssm_start (ssm, capture_sm_complete);
} }
@ -443,10 +443,9 @@ deactivate_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
} }
static void static void
deactivate_run_state (FpiSsm *ssm, FpDevice *_dev, deactivate_run_state (FpiSsm *ssm, FpDevice *_dev)
void *user_data)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev); FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev);
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
@ -465,10 +464,9 @@ deactivate_run_state (FpiSsm *ssm, FpDevice *_dev,
} }
static void static void
deactivate_sm_complete (FpiSsm *ssm, FpDevice *_dev, deactivate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
void *user_data, GError *error)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev); FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (_dev);
fp_dbg ("Deactivate completed"); fp_dbg ("Deactivate completed");
@ -487,7 +485,7 @@ start_deactivation (FpImageDevice *dev)
self->image_size = 0; self->image_size = 0;
ssm = fpi_ssm_new (FP_DEVICE (dev), deactivate_run_state, ssm = fpi_ssm_new (FP_DEVICE (dev), deactivate_run_state,
DEACTIVATE_NUM_STATES, dev); DEACTIVATE_NUM_STATES);
fpi_ssm_start (ssm, deactivate_sm_complete); fpi_ssm_start (ssm, deactivate_sm_complete);
} }
@ -539,10 +537,10 @@ init_read_data_cb (FpiUsbTransfer *transfer, FpDevice *device,
} }
static void static void
activate_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data) activate_run_state (FpiSsm *ssm, FpDevice *dev)
{ {
FpiUsbTransfer *transfer; FpiUsbTransfer *transfer;
FpImageDevice *idev = user_data; FpImageDevice *idev = FP_IMAGE_DEVICE (dev);
FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev); FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
@ -599,10 +597,9 @@ activate_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data)
} }
static void static void
activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, activate_sm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
void *user_data, GError *error)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
fpi_ssm_free (ssm); fpi_ssm_free (ssm);
fpi_image_device_activate_complete (dev, error); fpi_image_device_activate_complete (dev, error);
@ -616,7 +613,7 @@ dev_activate (FpImageDevice *dev)
{ {
FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev); FpiDeviceUpektcImg *self = FPI_DEVICE_UPEKTC_IMG (dev);
FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state, FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), activate_run_state,
ACTIVATE_NUM_STATES, dev); ACTIVATE_NUM_STATES);
self->seq = 0; self->seq = 0;
fpi_ssm_start (ssm, activate_sm_complete); fpi_ssm_start (ssm, activate_sm_complete);

75
libfprint/drivers/upekts.c
View file

@ -679,7 +679,7 @@ initsm_send_msg28_handler (FpiSsm *ssm,
} }
static void static void
initsm_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data) initsm_run_state (FpiSsm *ssm, FpDevice *dev)
{ {
FpiDeviceUpekts *upekdev = FPI_DEVICE_UPEKTS (dev); FpiDeviceUpekts *upekdev = FPI_DEVICE_UPEKTS (dev);
FpiUsbTransfer *transfer; FpiUsbTransfer *transfer;
@ -763,7 +763,7 @@ initsm_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data)
static FpiSsm * static FpiSsm *
initsm_new (FpDevice *dev) initsm_new (FpDevice *dev)
{ {
return fpi_ssm_new (dev, initsm_run_state, INITSM_NUM_STATES, NULL); return fpi_ssm_new (dev, initsm_run_state, INITSM_NUM_STATES);
} }
enum deinitsm_states { enum deinitsm_states {
@ -806,8 +806,7 @@ read_msg01_cb (FpDevice *dev, enum read_msg_type type,
} }
static void static void
deinitsm_state_handler (FpiSsm *ssm, FpDevice *dev, deinitsm_state_handler (FpiSsm *ssm, FpDevice *dev)
void *user_data)
{ {
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
{ {
@ -829,7 +828,7 @@ deinitsm_state_handler (FpiSsm *ssm, FpDevice *dev,
} }
static void static void
initsm_done (FpiSsm *ssm, FpDevice *dev, void *user_data, GError *error) initsm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
{ {
if (error) if (error)
g_usb_device_release_interface (fpi_device_get_usb_device (dev), 0, 0, NULL); g_usb_device_release_interface (fpi_device_get_usb_device (dev), 0, 0, NULL);
@ -840,7 +839,7 @@ initsm_done (FpiSsm *ssm, FpDevice *dev, void *user_data, GError *error)
static FpiSsm * static FpiSsm *
deinitsm_new (FpDevice *dev, void *user_data) deinitsm_new (FpDevice *dev, void *user_data)
{ {
return fpi_ssm_new (dev, deinitsm_state_handler, DEINITSM_NUM_STATES, user_data); return fpi_ssm_new (dev, deinitsm_state_handler, DEINITSM_NUM_STATES);
} }
static void static void
@ -858,12 +857,12 @@ dev_init (FpDevice *dev)
upekdev->seq = 0xf0; /* incremented to 0x00 before first cmd */ upekdev->seq = 0xf0; /* incremented to 0x00 before first cmd */
ssm = fpi_ssm_new (dev, initsm_run_state, INITSM_NUM_STATES, NULL); ssm = fpi_ssm_new (dev, initsm_run_state, INITSM_NUM_STATES);
fpi_ssm_start (ssm, initsm_done); fpi_ssm_start (ssm, initsm_done);
} }
static void static void
deinitsm_done (FpiSsm *ssm, FpDevice *dev, void *user_data, GError *error) deinitsm_done (FpiSsm *ssm, FpDevice *dev, GError *error)
{ {
g_usb_device_release_interface (fpi_device_get_usb_device (dev), 0, 0, NULL); g_usb_device_release_interface (fpi_device_get_usb_device (dev), 0, 0, NULL);
@ -875,7 +874,7 @@ dev_exit (FpDevice *dev)
{ {
FpiSsm *ssm; FpiSsm *ssm;
ssm = fpi_ssm_new (dev, deinitsm_state_handler, DEINITSM_NUM_STATES, NULL); ssm = fpi_ssm_new (dev, deinitsm_state_handler, DEINITSM_NUM_STATES);
fpi_ssm_start (ssm, deinitsm_done); fpi_ssm_start (ssm, deinitsm_done);
} }
@ -936,8 +935,7 @@ enroll_start_sm_cb_msg28 (FpDevice *dev,
} }
static void static void
enroll_start_sm_run_state (FpiSsm *ssm, FpDevice *dev, enroll_start_sm_run_state (FpiSsm *ssm, FpDevice *dev)
void *user_data)
{ {
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
{ {
@ -973,20 +971,23 @@ typedef struct
} EnrollStopData; } EnrollStopData;
static void static void
enroll_stop_deinit_cb (FpiSsm *ssm, FpDevice *dev, enroll_stop_data_free (EnrollStopData *data)
void *user_data, GError *error)
{ {
EnrollStopData *data = user_data; g_clear_object (&data->print);
g_clear_error (&data->error);
g_free (data);
}
static void
enroll_stop_deinit_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
{
EnrollStopData *data = fpi_ssm_get_data (ssm);
/* don't really care about errors */ /* don't really care about errors */
if (error) if (error)
{ fp_warn ("Error deinitializing: %s", error->message);
fp_warn ("Error deinitializing: %s", error->message);
g_error_free (error);
}
fpi_device_enroll_complete (dev, data->print, data->error); fpi_device_enroll_complete (dev, data->print, data->error);
g_free (data);
fpi_ssm_free (ssm); fpi_ssm_free (ssm);
} }
@ -996,10 +997,11 @@ do_enroll_stop (FpDevice *dev, FpPrint *print, GError *error)
EnrollStopData *data = g_new0 (EnrollStopData, 1); EnrollStopData *data = g_new0 (EnrollStopData, 1);
FpiSsm *ssm = deinitsm_new (dev, data); FpiSsm *ssm = deinitsm_new (dev, data);
data->print = print; data->print = g_object_ref (print);
data->error = error; data->error = error;
fpi_ssm_start (ssm, enroll_stop_deinit_cb); fpi_ssm_start (ssm, enroll_stop_deinit_cb);
fpi_ssm_set_data (ssm, data, (GDestroyNotify) enroll_stop_data_free);
} }
static void enroll_iterate (FpDevice *dev); static void enroll_iterate (FpDevice *dev);
@ -1206,8 +1208,7 @@ enroll_iterate (FpDevice *dev)
} }
static void static void
enroll_started (FpiSsm *ssm, FpDevice *dev, void *user_data, enroll_started (FpiSsm *ssm, FpDevice *dev, GError *error)
GError *error)
{ {
if (error) if (error)
do_enroll_stop (dev, NULL, error); do_enroll_stop (dev, NULL, error);
@ -1224,7 +1225,7 @@ enroll (FpDevice *dev)
/* do_init state machine first */ /* do_init state machine first */
FpiSsm *ssm = fpi_ssm_new (dev, enroll_start_sm_run_state, FpiSsm *ssm = fpi_ssm_new (dev, enroll_start_sm_run_state,
ENROLL_START_NUM_STATES, NULL); ENROLL_START_NUM_STATES);
upekdev->enroll_passed = FALSE; upekdev->enroll_passed = FALSE;
upekdev->enroll_stage = 0; upekdev->enroll_stage = 0;
@ -1238,19 +1239,21 @@ typedef struct
} VerifyStopData; } VerifyStopData;
static void static void
verify_stop_deinit_cb (FpiSsm *ssm, FpDevice *dev, verify_stop_data_free (VerifyStopData *data)
void *user_data, GError *error)
{ {
VerifyStopData *data = user_data; g_clear_error (&data->error);
g_free (data);
}
static void
verify_stop_deinit_cb (FpiSsm *ssm, FpDevice *dev, GError *error)
{
VerifyStopData *data = fpi_ssm_get_data (ssm);
if (error) if (error)
{ fp_warn ("Error deinitializing: %s", error->message);
fp_warn ("Error deinitializing: %s", error->message);
g_error_free (error);
}
fpi_device_verify_complete (dev, data->res, NULL, data->error); fpi_device_verify_complete (dev, data->res, NULL, data->error);
g_free (data);
fpi_ssm_free (ssm); fpi_ssm_free (ssm);
} }
@ -1264,6 +1267,7 @@ do_verify_stop (FpDevice *dev, FpiMatchResult res, GError *error)
data->error = error; data->error = error;
fpi_ssm_start (ssm, verify_stop_deinit_cb); fpi_ssm_start (ssm, verify_stop_deinit_cb);
fpi_ssm_set_data (ssm, data, (GDestroyNotify) verify_stop_data_free);
} }
static const unsigned char verify_hdr[] = { static const unsigned char verify_hdr[] = {
@ -1279,8 +1283,7 @@ enum {
}; };
static void static void
verify_start_sm_run_state (FpiSsm *ssm, FpDevice *dev, verify_start_sm_run_state (FpiSsm *ssm, FpDevice *dev)
void *user_data)
{ {
FpPrint *print; FpPrint *print;
@ -1522,8 +1525,7 @@ verify_iterate (FpDevice *dev)
} }
static void static void
verify_started (FpiSsm *ssm, FpDevice *dev, void *user_data, verify_started (FpiSsm *ssm, FpDevice *dev, GError *error)
GError *error)
{ {
FpiDeviceUpekts *upekdev = FPI_DEVICE_UPEKTS (dev); FpiDeviceUpekts *upekdev = FPI_DEVICE_UPEKTS (dev);
@ -1542,8 +1544,7 @@ verify_started (FpiSsm *ssm, FpDevice *dev, void *user_data,
static void static void
verify (FpDevice *dev) verify (FpDevice *dev)
{ {
FpiSsm *ssm = fpi_ssm_new (dev, verify_start_sm_run_state, FpiSsm *ssm = fpi_ssm_new (dev, verify_start_sm_run_state, VERIFY_NUM_STATES);
VERIFY_NUM_STATES, NULL);
fpi_ssm_start (ssm, verify_started); fpi_ssm_start (ssm, verify_started);
} }

30
libfprint/drivers/uru4000.c
View file

@ -650,9 +650,9 @@ calc_dev2 (struct uru4k_image *img)
} }
static void static void
imaging_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) imaging_run_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (_dev); FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (_dev);
struct uru4k_image *img = self->img_data; struct uru4k_image *img = self->img_data;
FpImage *fpimg; FpImage *fpimg;
@ -785,8 +785,7 @@ imaging_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
} }
static void static void
imaging_complete (FpiSsm *ssm, FpDevice *dev, void *user_data, imaging_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
GError *error)
{ {
FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev); FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (dev);
@ -855,9 +854,9 @@ rebootpwr_pause_cb (FpDevice *dev,
} }
static void static void
rebootpwr_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) rebootpwr_run_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (_dev); FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (_dev);
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
@ -946,9 +945,9 @@ powerup_pause_cb (FpDevice *dev,
} }
static void static void
powerup_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) powerup_run_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (_dev); FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (_dev);
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
@ -1073,9 +1072,9 @@ init_scanpwr_timeout (FpDevice *dev,
} }
static void static void
init_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) init_run_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (_dev); FpiDeviceUru4000 *self = FPI_DEVICE_URU4000 (_dev);
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
@ -1095,7 +1094,7 @@ init_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
case INIT_REBOOT_POWER:; case INIT_REBOOT_POWER:;
FpiSsm *rebootsm = fpi_ssm_new (FP_DEVICE (dev), FpiSsm *rebootsm = fpi_ssm_new (FP_DEVICE (dev),
rebootpwr_run_state, rebootpwr_run_state,
REBOOTPWR_NUM_STATES, dev); REBOOTPWR_NUM_STATES);
fpi_ssm_start_subsm (ssm, rebootsm); fpi_ssm_start_subsm (ssm, rebootsm);
break; break;
@ -1118,7 +1117,7 @@ init_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
FpiSsm *powerupsm = fpi_ssm_new (FP_DEVICE (dev), FpiSsm *powerupsm = fpi_ssm_new (FP_DEVICE (dev),
powerup_run_state, powerup_run_state,
POWERUP_NUM_STATES, dev); POWERUP_NUM_STATES);
fpi_ssm_start_subsm (ssm, powerupsm); fpi_ssm_start_subsm (ssm, powerupsm);
break; break;
@ -1165,8 +1164,7 @@ init_run_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
} }
static void static void
activate_initsm_complete (FpiSsm *ssm, FpDevice *dev, activate_initsm_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
void *user_data, GError *error)
{ {
fpi_image_device_activate_complete (FP_IMAGE_DEVICE (dev), error); fpi_image_device_activate_complete (FP_IMAGE_DEVICE (dev), error);
} }
@ -1180,7 +1178,7 @@ dev_activate (FpImageDevice *dev)
start_irq_handler (dev); start_irq_handler (dev);
self->scanpwr_irq_timeouts = 0; self->scanpwr_irq_timeouts = 0;
ssm = fpi_ssm_new (FP_DEVICE (dev), init_run_state, INIT_NUM_STATES, NULL); ssm = fpi_ssm_new (FP_DEVICE (dev), init_run_state, INIT_NUM_STATES);
fpi_ssm_start (ssm, activate_initsm_complete); fpi_ssm_start (ssm, activate_initsm_complete);
} }
@ -1240,7 +1238,7 @@ execute_state_change (FpImageDevice *dev)
self->irq_cb = NULL; self->irq_cb = NULL;
ssm = fpi_ssm_new (FP_DEVICE (dev), imaging_run_state, ssm = fpi_ssm_new (FP_DEVICE (dev), imaging_run_state,
IMAGING_NUM_STATES, dev); IMAGING_NUM_STATES);
self->img_enc_seed = rand (); self->img_enc_seed = rand ();
self->img_transfer = fpi_usb_transfer_new (FP_DEVICE (dev)); self->img_transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
self->img_transfer->ssm = ssm; self->img_transfer->ssm = ssm;

8
libfprint/drivers/vcom5s.c
View file

@ -256,7 +256,7 @@ enum loop_states {
}; };
static void static void
loop_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data) loop_run_state (FpiSsm *ssm, FpDevice *dev)
{ {
FpDeviceVcom5s *self = FPI_DEVICE_VCOM5S (dev); FpDeviceVcom5s *self = FPI_DEVICE_VCOM5S (dev);
@ -296,8 +296,7 @@ loop_run_state (FpiSsm *ssm, FpDevice *dev, void *user_data)
} }
static void static void
loopsm_complete (FpiSsm *ssm, FpDevice *dev, void *user_data, loopsm_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
GError *error)
{ {
FpImageDevice *imgdev = FP_IMAGE_DEVICE (dev); FpImageDevice *imgdev = FP_IMAGE_DEVICE (dev);
FpDeviceVcom5s *self = FPI_DEVICE_VCOM5S (dev); FpDeviceVcom5s *self = FPI_DEVICE_VCOM5S (dev);
@ -320,8 +319,7 @@ static void
dev_activate (FpImageDevice *dev) dev_activate (FpImageDevice *dev)
{ {
FpDeviceVcom5s *self = FPI_DEVICE_VCOM5S (dev); FpDeviceVcom5s *self = FPI_DEVICE_VCOM5S (dev);
FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), loop_run_state, FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (dev), loop_run_state, LOOP_NUM_STATES);
LOOP_NUM_STATES, dev);
self->deactivating = FALSE; self->deactivating = FALSE;
fpi_ssm_start (ssm, loopsm_complete); fpi_ssm_start (ssm, loopsm_complete);

24
libfprint/drivers/vfs0050.c
View file

@ -278,7 +278,7 @@ submit_image (FpDeviceVfs0050 *self)
/* SSM loop for clear_ep2 */ /* SSM loop for clear_ep2 */
static void static void
clear_ep2_ssm (FpiSsm *ssm, FpDevice *dev, void *user_data) clear_ep2_ssm (FpiSsm *ssm, FpDevice *dev)
{ {
char command04 = 0x04; char command04 = 0x04;
@ -307,15 +307,13 @@ static void
clear_ep2 (FpDevice *dev, clear_ep2 (FpDevice *dev,
FpiSsm *ssm) FpiSsm *ssm)
{ {
FpiSsm *subsm = FpiSsm *subsm = fpi_ssm_new (dev, clear_ep2_ssm, SUBSM1_STATES);
fpi_ssm_new (dev, clear_ep2_ssm, SUBSM1_STATES, NULL);
fpi_ssm_start_subsm (ssm, subsm); fpi_ssm_start_subsm (ssm, subsm);
} }
static void static void
send_control_packet_ssm (FpiSsm *ssm, FpDevice *dev, send_control_packet_ssm (FpiSsm *ssm, FpDevice *dev)
void *user_data)
{ {
FpDeviceVfs0050 *self = FPI_DEVICE_VFS0050 (dev); FpDeviceVfs0050 *self = FPI_DEVICE_VFS0050 (dev);
@ -384,8 +382,7 @@ send_control_packet (FpiSsm *ssm,
FpDevice *dev) FpDevice *dev)
{ {
FpiSsm *subsm = FpiSsm *subsm =
fpi_ssm_new (dev, send_control_packet_ssm, fpi_ssm_new (dev, send_control_packet_ssm, SUBSM2_STATES);
SUBSM2_STATES, NULL);
fpi_ssm_start_subsm (ssm, subsm); fpi_ssm_start_subsm (ssm, subsm);
} }
@ -497,7 +494,7 @@ another_scan (FpDevice *dev,
/* Main SSM loop */ /* Main SSM loop */
static void static void
activate_ssm (FpiSsm *ssm, FpDevice *dev, void *user_data) activate_ssm (FpiSsm *ssm, FpDevice *dev)
{ {
FpImageDevice *idev = FP_IMAGE_DEVICE (dev); FpImageDevice *idev = FP_IMAGE_DEVICE (dev);
FpDeviceVfs0050 *self = FPI_DEVICE_VFS0050 (dev); FpDeviceVfs0050 *self = FPI_DEVICE_VFS0050 (dev);
@ -660,8 +657,7 @@ activate_ssm (FpiSsm *ssm, FpDevice *dev, void *user_data)
/* Callback for dev_activate ssm */ /* Callback for dev_activate ssm */
static void static void
dev_activate_callback (FpiSsm *ssm, FpDevice *dev, dev_activate_callback (FpiSsm *ssm, FpDevice *dev, GError *error)
void *user_data, GError *error)
{ {
FpDeviceVfs0050 *self = FPI_DEVICE_VFS0050 (dev); FpDeviceVfs0050 *self = FPI_DEVICE_VFS0050 (dev);
@ -687,8 +683,7 @@ dev_activate (FpImageDevice *idev)
self->need_report = 1; self->need_report = 1;
self->ssm_active = 1; self->ssm_active = 1;
FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (idev), activate_ssm, SSM_STATES, FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (idev), activate_ssm, SSM_STATES);
idev);
fpi_ssm_start (ssm, dev_activate_callback); fpi_ssm_start (ssm, dev_activate_callback);
} }
@ -711,8 +706,7 @@ dev_deactivate (FpImageDevice *idev)
/* Callback for dev_open ssm */ /* Callback for dev_open ssm */
static void static void
dev_open_callback (FpiSsm *ssm, FpDevice *dev, void *user_data, dev_open_callback (FpiSsm *ssm, FpDevice *dev, GError *error)
GError *error)
{ {
/* Notify open complete */ /* Notify open complete */
fpi_image_device_open_complete (FP_IMAGE_DEVICE (dev), error); fpi_image_device_open_complete (FP_IMAGE_DEVICE (dev), error);
@ -733,7 +727,7 @@ dev_open (FpImageDevice *idev)
} }
/* Clearing previous device state */ /* Clearing previous device state */
FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (idev), activate_ssm, SSM_STATES, NULL); FpiSsm *ssm = fpi_ssm_new (FP_DEVICE (idev), activate_ssm, SSM_STATES);
fpi_ssm_start (ssm, dev_open_callback); fpi_ssm_start (ssm, dev_open_callback);
} }

30
libfprint/drivers/vfs101.c
View file

@ -391,18 +391,18 @@ enum {
/* Exec swap sequential state machine */ /* Exec swap sequential state machine */
static void static void
m_swap_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) m_swap_state (FpiSsm *ssm, FpDevice *dev)
{ {
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
{ {
case M_SWAP_SEND: case M_SWAP_SEND:
/* Send data */ /* Send data */
async_send (ssm, user_data); async_send (ssm, FP_IMAGE_DEVICE (dev));
break; break;
case M_SWAP_RECV: case M_SWAP_RECV:
/* Recv response */ /* Recv response */
async_recv (ssm, user_data); async_recv (ssm, FP_IMAGE_DEVICE (dev));
break; break;
} }
} }
@ -423,8 +423,7 @@ m_swap (FpiSsm *ssm,
self->length = length; self->length = length;
/* Start swap ssm */ /* Start swap ssm */
subsm = fpi_ssm_new (FP_DEVICE (dev), m_swap_state, M_SWAP_NUM_STATES, subsm = fpi_ssm_new (FP_DEVICE (dev), m_swap_state, M_SWAP_NUM_STATES);
dev);
fpi_ssm_start_subsm (ssm, subsm); fpi_ssm_start_subsm (ssm, subsm);
} }
@ -778,9 +777,9 @@ enum {
/* Exec loop sequential state machine */ /* Exec loop sequential state machine */
static void static void
m_loop_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) m_loop_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (_dev); FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (_dev);
/* Complete if deactivation was requested */ /* Complete if deactivation was requested */
@ -950,8 +949,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
/* Complete loop sequential state machine */ /* Complete loop sequential state machine */
static void static void
m_loop_complete (FpiSsm *ssm, FpDevice *dev, void *user_data, m_loop_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
GError *error)
{ {
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev); FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev);
@ -1015,9 +1013,9 @@ enum {
/* Exec init sequential state machine */ /* Exec init sequential state machine */
static void static void
m_init_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) m_init_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (_dev); FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (_dev);
/* Mark as cancelled when activation collides with deactivation. */ /* Mark as cancelled when activation collides with deactivation. */
@ -1253,10 +1251,9 @@ m_init_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
/* Complete init sequential state machine */ /* Complete init sequential state machine */
static void static void
m_init_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data, m_init_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
GError *error)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
/* Notify activate complete */ /* Notify activate complete */
fpi_image_device_activate_complete (dev, error); fpi_image_device_activate_complete (dev, error);
@ -1266,8 +1263,7 @@ m_init_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data,
FpiSsm *ssm_loop; FpiSsm *ssm_loop;
/* Start loop ssm */ /* Start loop ssm */
ssm_loop = fpi_ssm_new (FP_DEVICE (dev), m_loop_state, ssm_loop = fpi_ssm_new (FP_DEVICE (dev), m_loop_state, M_LOOP_NUM_STATES);
M_LOOP_NUM_STATES, dev);
fpi_ssm_start (ssm_loop, m_loop_complete); fpi_ssm_start (ssm_loop, m_loop_complete);
} }
@ -1297,7 +1293,7 @@ dev_activate (FpImageDevice *dev)
self->counter = 0; self->counter = 0;
/* Start init ssm */ /* Start init ssm */
ssm = fpi_ssm_new (FP_DEVICE (dev), m_init_state, M_INIT_NUM_STATES, dev); ssm = fpi_ssm_new (FP_DEVICE (dev), m_init_state, M_INIT_NUM_STATES);
fpi_ssm_start (ssm, m_init_complete); fpi_ssm_start (ssm, m_init_complete);
} }

17
libfprint/drivers/vfs301.c
View file

@ -94,9 +94,9 @@ enum {
/* Exec loop sequential state machine */ /* Exec loop sequential state machine */
static void static void
m_loop_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) m_loop_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpDeviceVfs301 *self = FPI_DEVICE_VFS301 (_dev); FpDeviceVfs301 *self = FPI_DEVICE_VFS301 (_dev);
switch (fpi_ssm_get_cur_state (ssm)) switch (fpi_ssm_get_cur_state (ssm))
@ -160,8 +160,7 @@ m_loop_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
/* Complete loop sequential state machine */ /* Complete loop sequential state machine */
static void static void
m_loop_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data, m_loop_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
GError *error)
{ {
if (error) if (error)
{ {
@ -174,7 +173,7 @@ m_loop_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data,
/* Exec init sequential state machine */ /* Exec init sequential state machine */
static void static void
m_init_state (FpiSsm *ssm, FpDevice *_dev, void *user_data) m_init_state (FpiSsm *ssm, FpDevice *_dev)
{ {
FpDeviceVfs301 *self = FPI_DEVICE_VFS301 (_dev); FpDeviceVfs301 *self = FPI_DEVICE_VFS301 (_dev);
@ -187,8 +186,7 @@ m_init_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
/* Complete init sequential state machine */ /* Complete init sequential state machine */
static void static void
m_init_complete (FpiSsm *ssm, FpDevice *dev, void *user_data, m_init_complete (FpiSsm *ssm, FpDevice *dev, GError *error)
GError *error)
{ {
FpiSsm *ssm_loop; FpiSsm *ssm_loop;
@ -198,8 +196,7 @@ m_init_complete (FpiSsm *ssm, FpDevice *dev, void *user_data,
/* Notify activate complete */ /* Notify activate complete */
/* Start loop ssm */ /* Start loop ssm */
ssm_loop = fpi_ssm_new (dev, m_loop_state, ssm_loop = fpi_ssm_new (dev, m_loop_state, M_LOOP_NUM_STATES);
M_LOOP_NUM_STATES, dev);
fpi_ssm_start (ssm_loop, m_loop_complete); fpi_ssm_start (ssm_loop, m_loop_complete);
} }
@ -214,7 +211,7 @@ dev_activate (FpImageDevice *dev)
FpiSsm *ssm; FpiSsm *ssm;
/* Start init ssm */ /* Start init ssm */
ssm = fpi_ssm_new (FP_DEVICE (dev), m_init_state, 1, dev); ssm = fpi_ssm_new (FP_DEVICE (dev), m_init_state, 1);
fpi_ssm_start (ssm, m_init_complete); fpi_ssm_start (ssm, m_init_complete);
} }

35
libfprint/drivers/vfs5011.c
View file

@ -81,7 +81,7 @@ static void
async_send_cb (FpiUsbTransfer *transfer, FpDevice *device, async_send_cb (FpiUsbTransfer *transfer, FpDevice *device,
gpointer user_data, GError *error) gpointer user_data, GError *error)
{ {
struct usbexchange_data *data = fpi_ssm_get_user_data (transfer->ssm); struct usbexchange_data *data = fpi_ssm_get_data (transfer->ssm);
struct usb_action *action; struct usb_action *action;
g_assert (!(fpi_ssm_get_cur_state (transfer->ssm) >= data->stepcount)); g_assert (!(fpi_ssm_get_cur_state (transfer->ssm) >= data->stepcount));
@ -104,7 +104,7 @@ static void
async_recv_cb (FpiUsbTransfer *transfer, FpDevice *device, async_recv_cb (FpiUsbTransfer *transfer, FpDevice *device,
gpointer user_data, GError *error) gpointer user_data, GError *error)
{ {
struct usbexchange_data *data = fpi_ssm_get_user_data (transfer->ssm); struct usbexchange_data *data = fpi_ssm_get_data (transfer->ssm);
struct usb_action *action; struct usb_action *action;
if (error) if (error)
@ -148,9 +148,9 @@ async_recv_cb (FpiUsbTransfer *transfer, FpDevice *device,
} }
static void static void
usbexchange_loop (FpiSsm *ssm, FpDevice *_dev, void *user_data) usbexchange_loop (FpiSsm *ssm, FpDevice *_dev)
{ {
struct usbexchange_data *data = user_data; struct usbexchange_data *data = fpi_ssm_get_data (ssm);
struct usb_action *action = &data->actions[fpi_ssm_get_cur_state (ssm)]; struct usb_action *action = &data->actions[fpi_ssm_get_cur_state (ssm)];
FpiUsbTransfer *transfer; FpiUsbTransfer *transfer;
@ -196,9 +196,9 @@ usb_exchange_async (FpiSsm *ssm,
{ {
FpiSsm *subsm = fpi_ssm_new (FP_DEVICE (data->device), FpiSsm *subsm = fpi_ssm_new (FP_DEVICE (data->device),
usbexchange_loop, usbexchange_loop,
data->stepcount, data->stepcount);
data);
fpi_ssm_set_data (subsm, data, NULL);
fpi_ssm_start_subsm (ssm, subsm); fpi_ssm_start_subsm (ssm, subsm);
} }
@ -658,11 +658,11 @@ struct usb_action vfs5011_initiate_capture[] = {
/* ====================== lifprint interface ======================= */ /* ====================== lifprint interface ======================= */
static void static void
activate_loop (FpiSsm *ssm, FpDevice *_dev, void *user_data) activate_loop (FpiSsm *ssm, FpDevice *_dev)
{ {
enum {READ_TIMEOUT = 0}; enum {READ_TIMEOUT = 0};
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpDeviceVfs5011 *self; FpDeviceVfs5011 *self;
self = FPI_DEVICE_VFS5011 (_dev); self = FPI_DEVICE_VFS5011 (_dev);
@ -729,10 +729,9 @@ activate_loop (FpiSsm *ssm, FpDevice *_dev, void *user_data)
} }
static void static void
activate_loop_complete (FpiSsm *ssm, FpDevice *_dev, activate_loop_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
void *user_data, GError *error)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpDeviceVfs5011 *self; FpDeviceVfs5011 *self;
self = FPI_DEVICE_VFS5011 (_dev); self = FPI_DEVICE_VFS5011 (_dev);
@ -760,9 +759,9 @@ activate_loop_complete (FpiSsm *ssm, FpDevice *_dev,
static void static void
open_loop (FpiSsm *ssm, FpDevice *_dev, void *user_data) open_loop (FpiSsm *ssm, FpDevice *_dev)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpDeviceVfs5011 *self; FpDeviceVfs5011 *self;
self = FPI_DEVICE_VFS5011 (_dev); self = FPI_DEVICE_VFS5011 (_dev);
@ -784,10 +783,9 @@ open_loop (FpiSsm *ssm, FpDevice *_dev, void *user_data)
} }
static void static void
open_loop_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data, open_loop_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
GError *error)
{ {
FpImageDevice *dev = user_data; FpImageDevice *dev = FP_IMAGE_DEVICE (_dev);
FpDeviceVfs5011 *self; FpDeviceVfs5011 *self;
self = FPI_DEVICE_VFS5011 (_dev); self = FPI_DEVICE_VFS5011 (_dev);
@ -814,7 +812,7 @@ dev_open (FpImageDevice *dev)
return; return;
} }
ssm = fpi_ssm_new (FP_DEVICE (dev), open_loop, DEV_OPEN_NUM_STATES, dev); ssm = fpi_ssm_new (FP_DEVICE (dev), open_loop, DEV_OPEN_NUM_STATES);
fpi_ssm_start (ssm, open_loop_complete); fpi_ssm_start (ssm, open_loop_complete);
} }
@ -844,8 +842,7 @@ start_scan (FpImageDevice *dev)
self = FPI_DEVICE_VFS5011 (dev); self = FPI_DEVICE_VFS5011 (dev);
self->loop_running = TRUE; self->loop_running = TRUE;
fp_dbg ("creating ssm"); fp_dbg ("creating ssm");
ssm = fpi_ssm_new (FP_DEVICE (dev), activate_loop, ssm = fpi_ssm_new (FP_DEVICE (dev), activate_loop, DEV_ACTIVATE_NUM_STATES);
DEV_ACTIVATE_NUM_STATES, dev);
fp_dbg ("starting ssm"); fp_dbg ("starting ssm");
fpi_ssm_start (ssm, activate_loop_complete); fpi_ssm_start (ssm, activate_loop_complete);
fp_dbg ("ssm done, getting out"); fp_dbg ("ssm done, getting out");

56
libfprint/fpi-ssm.c
View file

@ -45,7 +45,7 @@
* implicit edges linking one state to every other state. * implicit edges linking one state to every other state.
* *
* To create an #fpi_ssm, you pass a state handler function and the total number of * To create an #fpi_ssm, you pass a state handler function and the total number of
* states (4 in the above example) to fpi_ssm_new(). Note that the state numbers * states (4 in the above example) to fpi_ssm_new (). Note that the state numbers
* start at zero, making them match the first value in a C enumeration. * start at zero, making them match the first value in a C enumeration.
* *
* To start a ssm, you pass in a completion callback function to fpi_ssm_start() * To start a ssm, you pass in a completion callback function to fpi_ssm_start()
@ -79,7 +79,8 @@ struct _FpiSsm
{ {
FpDevice *dev; FpDevice *dev;
FpiSsm *parentsm; FpiSsm *parentsm;
void *user_data; gpointer ssm_data;
GDestroyNotify ssm_data_destroy;
int nr_states; int nr_states;
int cur_state; int cur_state;
gboolean completed; gboolean completed;
@ -93,7 +94,6 @@ struct _FpiSsm
* @dev: a #fp_dev fingerprint device * @dev: a #fp_dev fingerprint device
* @handler: the callback function * @handler: the callback function
* @nr_states: the number of states * @nr_states: the number of states
* @user_data: the user data to pass to callbacks
* *
* Allocate a new ssm, with @nr_states states. The @handler callback * Allocate a new ssm, with @nr_states states. The @handler callback
* will be called after each state transition. * will be called after each state transition.
@ -103,8 +103,7 @@ struct _FpiSsm
FpiSsm * FpiSsm *
fpi_ssm_new (FpDevice *dev, fpi_ssm_new (FpDevice *dev,
FpiSsmHandlerCallback handler, FpiSsmHandlerCallback handler,
int nr_states, int nr_states)
void *user_data)
{ {
FpiSsm *machine; FpiSsm *machine;
@ -115,23 +114,42 @@ fpi_ssm_new (FpDevice *dev,
machine->nr_states = nr_states; machine->nr_states = nr_states;
machine->dev = dev; machine->dev = dev;
machine->completed = TRUE; machine->completed = TRUE;
machine->user_data = user_data;
return machine; return machine;
} }
/** /**
* fpi_ssm_get_user_data: * fpi_ssm_set_data:
* @machine: an #FpiSsm state machine
* @ssm_data: (nullable): a pointer to machine data
* @ssm_data_destroy: (nullable): #GDestroyNotify for @ssm_data
*
* Sets @machine's data (freeing the existing data, if any).
*
*/
void
fpi_ssm_set_data (FpiSsm *machine,
gpointer ssm_data,
GDestroyNotify ssm_data_destroy)
{
if (machine->ssm_data_destroy && machine->ssm_data)
machine->ssm_data_destroy (machine->ssm_data);
machine->ssm_data = ssm_data;
machine->ssm_data_destroy = ssm_data_destroy;
}
/**
* fpi_ssm_get_data:
* @machine: an #FpiSsm state machine * @machine: an #FpiSsm state machine
* *
* Retrieve the pointer to user data set when fpi_ssm_new() * Retrieve the pointer to SSM data set with fpi_ssm_set_ssm_data()
* is called.
* *
* Returns: a pointer * Returns: a pointer
*/ */
void * void *
fpi_ssm_get_user_data (FpiSsm *machine) fpi_ssm_get_data (FpiSsm *machine)
{ {
return machine->user_data; return machine->ssm_data;
} }
/** /**
@ -147,6 +165,8 @@ fpi_ssm_free (FpiSsm *machine)
if (!machine) if (!machine)
return; return;
if (machine->ssm_data_destroy)
g_clear_pointer (&machine->ssm_data, machine->ssm_data_destroy);
g_clear_pointer (&machine->error, g_error_free); g_clear_pointer (&machine->error, g_error_free);
g_free (machine); g_free (machine);
} }
@ -156,7 +176,7 @@ static void
__ssm_call_handler (FpiSsm *machine) __ssm_call_handler (FpiSsm *machine)
{ {
fp_dbg ("%p entering state %d", machine, machine->cur_state); fp_dbg ("%p entering state %d", machine, machine->cur_state);
machine->handler (machine, machine->dev, machine->user_data); machine->handler (machine, machine->dev);
} }
/** /**
@ -180,7 +200,7 @@ fpi_ssm_start (FpiSsm *ssm, FpiSsmCompletedCallback callback)
} }
static void static void
__subsm_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data, GError *error) __subsm_complete (FpiSsm *ssm, FpDevice *_dev, GError *error)
{ {
FpiSsm *parent = ssm->parentsm; FpiSsm *parent = ssm->parentsm;
@ -215,7 +235,7 @@ fpi_ssm_start_subsm (FpiSsm *parent, FpiSsm *child)
* @machine: an #FpiSsm state machine * @machine: an #FpiSsm state machine
* *
* Mark a ssm as completed successfully. The callback set when creating * Mark a ssm as completed successfully. The callback set when creating
* the state machine with fpi_ssm_new() will be called synchronously. * the state machine with fpi_ssm_new () will be called synchronously.
*/ */
void void
fpi_ssm_mark_completed (FpiSsm *machine) fpi_ssm_mark_completed (FpiSsm *machine)
@ -230,7 +250,7 @@ fpi_ssm_mark_completed (FpiSsm *machine)
{ {
GError *error = machine->error ? g_error_copy (machine->error) : NULL; GError *error = machine->error ? g_error_copy (machine->error) : NULL;
machine->callback (machine, machine->dev, machine->user_data, error); machine->callback (machine, machine->dev, error);
} }
} }
@ -349,7 +369,7 @@ fpi_ssm_dup_error (FpiSsm *machine)
* for an fpi_timeout_add() callback, when the state change needs * for an fpi_timeout_add() callback, when the state change needs
* to happen after a timeout. * to happen after a timeout.
* *
* Make sure to pass the #FpiSsm as the `user_data` argument * Make sure to pass the #FpiSsm as the `ssm_data` argument
* for that fpi_timeout_add() call. * for that fpi_timeout_add() call.
*/ */
void void
@ -366,7 +386,7 @@ fpi_ssm_next_state_timeout_cb (FpDevice *dev,
* fpi_ssm_usb_transfer_cb: * fpi_ssm_usb_transfer_cb:
* @transfer: a #FpiUsbTransfer * @transfer: a #FpiUsbTransfer
* @device: a #FpDevice * @device: a #FpDevice
* @user_data: User data (unused) * @ssm_data: User data (unused)
* @error: The #GError or %NULL * @error: The #GError or %NULL
* *
* Can be used in as a #FpiUsbTransfer callback handler to automatically * Can be used in as a #FpiUsbTransfer callback handler to automatically
@ -376,7 +396,7 @@ fpi_ssm_next_state_timeout_cb (FpDevice *dev,
*/ */
void void
fpi_ssm_usb_transfer_cb (FpiUsbTransfer *transfer, FpDevice *device, fpi_ssm_usb_transfer_cb (FpiUsbTransfer *transfer, FpDevice *device,
gpointer user_data, GError *error) gpointer ssm_data, GError *error)
{ {
g_return_if_fail (transfer->ssm); g_return_if_fail (transfer->ssm);

16
libfprint/fpi-ssm.h
View file

@ -38,7 +38,6 @@ typedef struct _FpiSsm FpiSsm;
* FpiSsmCompletedCallback: * FpiSsmCompletedCallback:
* @ssm: a #FpiSsm state machine * @ssm: a #FpiSsm state machine
* @dev: the #fp_dev fingerprint device * @dev: the #fp_dev fingerprint device
* @user_data: the user data passed to fpi_ssm_new()
* @error: The #GError or %NULL on successful completion * @error: The #GError or %NULL on successful completion
* *
* The callback called when a state machine completes successfully, * The callback called when a state machine completes successfully,
@ -46,27 +45,23 @@ typedef struct _FpiSsm FpiSsm;
*/ */
typedef void (*FpiSsmCompletedCallback)(FpiSsm *ssm, typedef void (*FpiSsmCompletedCallback)(FpiSsm *ssm,
FpDevice *dev, FpDevice *dev,
void *user_data,
GError *error); GError *error);
/** /**
* FpiSsmHandlerCallback: * FpiSsmHandlerCallback:
* @ssm: a #FpiSsm state machine * @ssm: a #FpiSsm state machine
* @dev: the #fp_dev fingerprint device * @dev: the #fp_dev fingerprint device
* @user_data: the user data passed to fpi_ssm_new()
* *
* The callback called when a state machine transitions from one * The callback called when a state machine transitions from one
* state to the next, as set when calling fpi_ssm_new(). * state to the next, as set when calling fpi_ssm_new ().
*/ */
typedef void (*FpiSsmHandlerCallback)(FpiSsm *ssm, typedef void (*FpiSsmHandlerCallback)(FpiSsm *ssm,
FpDevice *dev, FpDevice *dev);
void *user_data);
/* for library and drivers */ /* for library and drivers */
FpiSsm *fpi_ssm_new (FpDevice *dev, FpiSsm *fpi_ssm_new (FpDevice *dev,
FpiSsmHandlerCallback handler, FpiSsmHandlerCallback handler,
int nr_states, int nr_states);
void *user_data);
void fpi_ssm_free (FpiSsm *machine); void fpi_ssm_free (FpiSsm *machine);
void fpi_ssm_start (FpiSsm *ssm, void fpi_ssm_start (FpiSsm *ssm,
FpiSsmCompletedCallback callback); FpiSsmCompletedCallback callback);
@ -80,7 +75,10 @@ void fpi_ssm_jump_to_state (FpiSsm *machine,
void fpi_ssm_mark_completed (FpiSsm *machine); void fpi_ssm_mark_completed (FpiSsm *machine);
void fpi_ssm_mark_failed (FpiSsm *machine, void fpi_ssm_mark_failed (FpiSsm *machine,
GError *error); GError *error);
void *fpi_ssm_get_user_data (FpiSsm *machine); void fpi_ssm_set_data (FpiSsm *machine,
gpointer ssm_data,
GDestroyNotify ssm_data_destroy);
gpointer fpi_ssm_get_data (FpiSsm *machine);
GError * fpi_ssm_get_error (FpiSsm *machine); GError * fpi_ssm_get_error (FpiSsm *machine);
GError * fpi_ssm_dup_error (FpiSsm *machine); GError * fpi_ssm_dup_error (FpiSsm *machine);
int fpi_ssm_get_cur_state (FpiSsm *machine); int fpi_ssm_get_cur_state (FpiSsm *machine);