diff --git a/data/autosuspend.hwdb b/data/autosuspend.hwdb index 802312d..7057c47 100644 --- a/data/autosuspend.hwdb +++ b/data/autosuspend.hwdb @@ -125,6 +125,10 @@ usb:v04F3p0C4F* usb:v04F3p0C63* ID_AUTOSUSPEND=1 +# Supported by libfprint driver elanmoc +usb:v04F3p0C7E* + ID_AUTOSUSPEND=1 + # Supported by libfprint driver etes603 usb:v1C7Ap0603* ID_AUTOSUSPEND=1 diff --git a/libfprint/drivers/elanmoc/elanmoc.c b/libfprint/drivers/elanmoc/elanmoc.c new file mode 100644 index 0000000..712af90 --- /dev/null +++ b/libfprint/drivers/elanmoc/elanmoc.c @@ -0,0 +1,1134 @@ +/* + * Copyright (C) 2021 Elan Microelectronics Inc + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#define FP_COMPONENT "elanmoc" + +#include "drivers_api.h" +#include "fpi-byte-reader.h" +#include "elanmoc.h" + +G_DEFINE_TYPE (FpiDeviceElanmoc, fpi_device_elanmoc, FP_TYPE_DEVICE) + +static const FpIdEntry id_table[] = { + { .vid = 0x04f3, .pid = 0x0c7e, }, + { .vid = 0, .pid = 0, .driver_data = 0 }, /* terminating entry */ +}; + +typedef void (*SynCmdMsgCallback) (FpiDeviceElanmoc *self, + uint8_t *buffer_in, + gsize length_in, + GError *error); + +typedef struct +{ + SynCmdMsgCallback callback; +} CommandData; + +static uint8_t * +elanmoc_compose_cmd ( + const struct elanmoc_cmd *cmd_info + ) +{ + g_autofree char *cmd_buf = NULL; + + cmd_buf = g_malloc0 (cmd_info->cmd_len); + if(cmd_info->cmd_len < ELAN_MAX_HDR_LEN) + memcpy (cmd_buf, &cmd_info->cmd_header, cmd_info->cmd_len); + else + memcpy (cmd_buf, &cmd_info->cmd_header, ELAN_MAX_HDR_LEN); + + return g_steal_pointer (&cmd_buf); +} + +static void +elanmoc_cmd_ack_cb (FpiDeviceElanmoc *self, + uint8_t *buffer_in, + gsize length_in, + GError *error) +{ + if (error) + { + fpi_ssm_mark_failed (self->task_ssm, error); + return; + } + + if (length_in == 0) + { + fpi_ssm_next_state (self->task_ssm); + return; + } + + if (buffer_in[0] != 0x40 && buffer_in[1] != 0x00 ) + { + fpi_ssm_mark_failed (self->task_ssm, + fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, + "Can't get response!!")); + } + else + { + fpi_ssm_next_state (self->task_ssm); + } +} + +static void +fp_cmd_receive_cb (FpiUsbTransfer *transfer, + FpDevice *device, + gpointer userdata, + GError *error) +{ + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (device); + CommandData *data = userdata; + int ssm_state = 0; + + if (error) + { + fpi_ssm_mark_failed (transfer->ssm, error); + return; + } + if (data == NULL) + { + fpi_ssm_mark_failed (transfer->ssm, + fpi_device_error_new (FP_DEVICE_ERROR_GENERAL)); + return; + } + ssm_state = fpi_ssm_get_cur_state (transfer->ssm); + + /* skip zero length package */ + if (transfer->actual_length == 0) + { + fpi_ssm_jump_to_state (transfer->ssm, ssm_state); + return; + } + + if (data->callback) + data->callback (self, transfer->buffer, transfer->actual_length, NULL); + + fpi_ssm_mark_completed (transfer->ssm); +} + +typedef enum { + FP_CMD_SEND = 0, + FP_CMD_GET, + FP_CMD_NUM_STATES, +} FpCmdState; + +static void +fp_cmd_run_state (FpiSsm *ssm, + FpDevice *dev) +{ + FpiUsbTransfer *transfer; + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (dev); + + switch (fpi_ssm_get_cur_state (ssm)) + { + case FP_CMD_SEND: + if (self->cmd_transfer) + { + self->cmd_transfer->ssm = ssm; + fpi_usb_transfer_submit (g_steal_pointer (&self->cmd_transfer), + ELAN_MOC_CMD_TIMEOUT, + NULL, + fpi_ssm_usb_transfer_cb, + NULL); + } + else + { + fpi_ssm_next_state (ssm); + } + break; + + case FP_CMD_GET: + if (self->cmd_len_in == 0) + { + CommandData *data = fpi_ssm_get_data (ssm); + if (data->callback) + data->callback (self, NULL, 0, 0); + fpi_ssm_mark_completed (ssm); + return; + } + transfer = fpi_usb_transfer_new (dev); + transfer->ssm = ssm; + fpi_usb_transfer_fill_bulk (transfer, self->cmd_cancelable ? ELAN_EP_MOC_CMD_IN : ELAN_EP_CMD_IN, self->cmd_len_in); + fpi_usb_transfer_submit (transfer, + self->cmd_cancelable ? 0 : ELAN_MOC_CMD_TIMEOUT, + self->cmd_cancelable ? fpi_device_get_cancellable (dev) : NULL, + fp_cmd_receive_cb, + fpi_ssm_get_data (ssm)); + break; + + } + +} + +static void +fp_cmd_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error) +{ + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (dev); + CommandData *data = fpi_ssm_get_data (ssm); + + self->cmd_ssm = NULL; + + if (error) + { + if (data->callback) + data->callback (self, NULL, 0, error); + else + g_error_free (error); + } +} + +static void +fp_cmd_ssm_done_data_free (CommandData *data) +{ + g_free (data); +} + +static void +elanmoc_get_cmd (FpDevice *device, guint8 *buffer_out, + gsize length_out, gsize length_in, gboolean cancelable, SynCmdMsgCallback callback) +{ + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (device); + + g_autoptr(FpiUsbTransfer) transfer = NULL; + CommandData *data = g_new0 (CommandData, 1); + + transfer = fpi_usb_transfer_new (device); + transfer->short_is_error = TRUE; + fpi_usb_transfer_fill_bulk_full (transfer, ELAN_EP_CMD_OUT, buffer_out, + length_out, g_free); + data->callback = callback; + + self->cmd_transfer = g_steal_pointer (&transfer); + self->cmd_len_in = length_in; + self->cmd_cancelable = cancelable; + + self->cmd_ssm = fpi_ssm_new (FP_DEVICE (self), + fp_cmd_run_state, + FP_CMD_NUM_STATES); + + fpi_ssm_set_data (self->cmd_ssm, data, (GDestroyNotify) fp_cmd_ssm_done_data_free); + + fpi_ssm_start (self->cmd_ssm, fp_cmd_ssm_done); +} + +enum enroll_states { + ENROLL_RSP_RETRY, + ENROLL_RSP_ENROLL_REPORT, + ENROLL_RSP_ENROLL_OK, + ENROLL_RSP_ENROLL_CANCEL_REPORT, + ENROLL_NUM_STATES, +}; + +static void +enroll_status_report (FpiDeviceElanmoc *self, int enroll_status_id, + int data, GError *error) +{ + FpDevice *device = FP_DEVICE (self); + + if (error) + { + fpi_device_enroll_complete (device, NULL, error); + return; + } + + switch (enroll_status_id) + { + case ENROLL_RSP_RETRY: + { + fpi_device_enroll_progress (device, self->num_frames, NULL, + fpi_device_retry_new (FP_DEVICE_RETRY_CENTER_FINGER)); + break; + } + + case ENROLL_RSP_ENROLL_REPORT: + { + fpi_device_enroll_progress (device, self->num_frames, NULL, NULL); + break; + } + + case ENROLL_RSP_ENROLL_OK: + { + FpPrint *print = NULL; + fp_info ("Enrollment was successful!"); + fpi_device_get_enroll_data (device, &print); + fpi_device_enroll_complete (device, g_object_ref (print), NULL); + break; + } + + case ENROLL_RSP_ENROLL_CANCEL_REPORT: + { + fpi_device_enroll_complete (device, NULL, + fpi_device_error_new_msg (FP_DEVICE_ERROR_GENERAL, + "Enrollment failed (%d) (ENROLL_RSP_ENROLL_CANCEL_REPORT)", + data)); + } + } +} + +static void +elanmoc_get_enrolled_cb (FpiDeviceElanmoc *self, + uint8_t *buffer_in, + gsize length_in, + GError *error) +{ + if (error) + { + fpi_ssm_mark_failed (self->task_ssm, error); + return; + } + + if (buffer_in[0] != 0x40) + { + fpi_ssm_mark_failed (self->task_ssm, + fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, + "Can't get response!!")); + } + else + { + fp_info ("elanmoc Current enrolled fingers in the Chipset: %d (0x%.2X 0x%.2X)", buffer_in[1], + buffer_in[0], + buffer_in[1]); + self->curr_enrolled = buffer_in[1]; + fpi_ssm_next_state (self->task_ssm); + } +} + +static void +elanmoc_reenroll_cb (FpiDeviceElanmoc *self, + uint8_t *buffer_in, + gsize length_in, + GError *error) +{ + if (error) + { + fpi_ssm_mark_failed (self->task_ssm, error); + return; + } + + if (buffer_in[0] != 0x40) + { + fpi_ssm_mark_failed (self->task_ssm, + fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, + "Can't get response!!")); + } + else + { + if ((self->curr_enrolled == (ELAN_MAX_ENROLL_NUM + 1)) && (buffer_in[1] == 0x00)) + { + fp_warn ("elanmoc_reenroll_cb over enroll max"); + fpi_ssm_mark_completed (self->task_ssm); + return; + } + if (buffer_in[1] == 0x00) + fp_info ("##### Normal Enrollment Case! #####"); + else if (buffer_in[1] == 0x01) + fp_info ("##### Re-Enrollment Case! #####"); + self->num_frames = 0; + fpi_ssm_next_state (self->task_ssm); + } +} + +static void +elanmoc_enroll_cb (FpiDeviceElanmoc *self, + uint8_t *buffer_in, + gsize length_in, + GError *error) +{ + if (error) + { + fpi_ssm_mark_failed (self->task_ssm, error); + return; + } + + if (buffer_in[0] != 0x40) + { + fpi_ssm_mark_failed (self->task_ssm, + fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, + "Can't get response!!")); + } + else + { + if (buffer_in[1] == ELAN_MSG_OK) + { + self->num_frames += 1; + enroll_status_report (self, ENROLL_RSP_ENROLL_REPORT, self->num_frames, NULL); + } + else + { + enroll_status_report (self, ENROLL_RSP_RETRY, self->num_frames, NULL); + } + + if (self->num_frames == ELAN_MOC_ENROLL_TIMES && buffer_in[1] == ELAN_MSG_OK) + fpi_ssm_next_state (self->task_ssm); + else if (self->num_frames < ELAN_MOC_ENROLL_TIMES) + fpi_ssm_jump_to_state (self->task_ssm, MOC_ENROLL_WAIT_FINGER); + else + fpi_ssm_mark_failed (self->task_ssm, error); + } +} + +static void +elanmoc_commit_cb (FpiDeviceElanmoc *self, + uint8_t *buffer_in, + gsize length_in, + GError *error) +{ + if (error) + { + fpi_ssm_mark_failed (self->task_ssm, error); + return; + } + + if (length_in == 0) + { + fpi_ssm_next_state (self->task_ssm); + return; + } + + if (buffer_in[0] != 0x40 && buffer_in[1] != 0x00 ) + { + fpi_ssm_mark_failed (self->task_ssm, + fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, + "Can't get response!!")); + } + else + { + fp_info ("elanmoc_commit_cb success"); + enroll_status_report (self, ENROLL_RSP_ENROLL_OK, self->num_frames, NULL); + fpi_ssm_next_state (self->task_ssm); + } +} + +static void +elan_enroll_run_state (FpiSsm *ssm, FpDevice *dev) +{ + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (dev); + guint8 *cmd_buf = NULL; + guint8 *data = NULL; + + switch (fpi_ssm_get_cur_state (ssm)) + { + case MOC_ENROLL_GET_ENROLLED_NUM: + cmd_buf = elanmoc_compose_cmd (&enrolled_number_cmd); + elanmoc_get_cmd (dev, cmd_buf, enrolled_number_cmd.cmd_len, enrolled_number_cmd.resp_len, 0, elanmoc_get_enrolled_cb); + break; + + case MOC_ENROLL_REENROLL_CHECK: + data = fpi_ssm_get_data (ssm); + cmd_buf = elanmoc_compose_cmd (&elanmoc_check_reenroll_cmd); + cmd_buf[4] = data[16]; + elanmoc_get_cmd (dev, cmd_buf, elanmoc_check_reenroll_cmd.cmd_len, elanmoc_check_reenroll_cmd.resp_len, 0, elanmoc_reenroll_cb); + break; + + case MOC_ENROLL_WAIT_FINGER: + cmd_buf = elanmoc_compose_cmd (&elanmoc_enroll_cmd); + cmd_buf[3] = self->curr_enrolled; + cmd_buf[4] = ELAN_MOC_ENROLL_TIMES; + cmd_buf[5] = self->num_frames; + elanmoc_get_cmd (dev, cmd_buf, elanmoc_enroll_cmd.cmd_len, elanmoc_enroll_cmd.resp_len, 1, elanmoc_enroll_cb); + break; + + case MOC_ENROLL_COMMIT_RESULT: + data = fpi_ssm_get_data (ssm); + cmd_buf = elanmoc_compose_cmd (&elanmoc_enroll_commit_cmd); + memcpy (cmd_buf + 5, data, ELAN_USERDATE_SIZE); + elanmoc_get_cmd (dev, cmd_buf, elanmoc_enroll_commit_cmd.cmd_len, elanmoc_enroll_commit_cmd.resp_len, 0, elanmoc_commit_cb); + break; + } +} + +static void +task_ssm_done (FpiSsm *ssm, FpDevice *dev, GError *error) +{ + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (dev); + + self->task_ssm = NULL; + g_clear_pointer (&self->list_result, g_ptr_array_unref); + + if (error) + fpi_device_action_error (dev, error); +} + +static FpPrint * +create_print_from_response (FpiDeviceElanmoc *self, + uint8_t *buffer_in, + gsize length_in, + GError **error) +{ + FpPrint *print; + GVariant *data; + GVariant *uid; + g_autofree gchar *userid = NULL; + g_autofree gchar *userid_safe = NULL; + int userid_len = 0; + + if (buffer_in[0] != 0x43) + { + g_propagate_error (error, + fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, + "Can't get response!!")); + return NULL; + } + + if (buffer_in[1] != ELAN_MSG_OK) + { + g_propagate_error (error, + fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, + "Device returned error %d rather than print!", buffer_in[1])); + return NULL; + } + + userid_len = buffer_in[4]; + + if (userid_len > length_in - 5) + { + g_propagate_error (error, + fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, + "Packet too short for payload length!")); + return NULL; + } + + userid = g_memdup (&buffer_in[5], userid_len); + userid_safe = g_strndup ((const char *) &buffer_in[5], userid_len); + print = fp_print_new (FP_DEVICE (self)); + uid = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, userid, userid_len, 1); + + /* The first two bytes are meant to store a UUID, + * but will always be zero for prints created by libfprint. + */ + data = g_variant_new ("(yy@ay)", + buffer_in[2], + buffer_in[3], + uid); + + fpi_print_set_type (print, FPI_PRINT_RAW); + fpi_print_set_device_stored (print, TRUE); + g_object_set (print, "fpi-data", data, NULL); + g_object_set (print, "description", userid_safe, NULL); + + fpi_print_fill_from_user_id (print, userid_safe); + + return print; +} + +static void +elanmoc_get_userid_cb (FpiDeviceElanmoc *self, + uint8_t *buffer_in, + gsize length_in, + GError *error) +{ + FpPrint *print; + + if (error) + { + fpi_ssm_mark_failed (self->task_ssm, error); + return; + } + + if (buffer_in[0] != 0x43) + { + fpi_ssm_mark_failed (self->task_ssm, + fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, + "Can't get response!!")); + return; + } + + self->list_index++; + + /* Skip 0xfe messages */ + if (buffer_in[1] != 0xfe) + { + print = create_print_from_response (self, buffer_in, length_in, &error); + + if (!print) + { + fpi_ssm_mark_failed (self->task_ssm, error); + return; + } + + g_ptr_array_add (self->list_result, g_object_ref_sink (print)); + } + + if(self->list_index <= ELAN_MAX_ENROLL_NUM) + { + fpi_ssm_jump_to_state (self->task_ssm, MOC_LIST_GET_FINGER); + } + else + { + fpi_device_list_complete (FP_DEVICE (self), g_steal_pointer (&self->list_result), NULL); + fpi_ssm_next_state (self->task_ssm); + } +} + +static void +elan_list_run_state (FpiSsm *ssm, FpDevice *dev) +{ + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (dev); + guint8 *cmd_buf = NULL; + + switch (fpi_ssm_get_cur_state (ssm)) + { + case MOC_LIST_GET_ENROLLED: + cmd_buf = elanmoc_compose_cmd (&enrolled_number_cmd); + elanmoc_get_cmd (dev, cmd_buf, enrolled_number_cmd.cmd_len, enrolled_number_cmd.resp_len, 0, elanmoc_get_enrolled_cb); + self->list_index = 0; + break; + + case MOC_LIST_GET_FINGER: + cmd_buf = elanmoc_compose_cmd (&elanmoc_get_userid_cmd); + cmd_buf[2] = self->list_index; + elanmoc_get_cmd (dev, cmd_buf, elanmoc_get_userid_cmd.cmd_len, elanmoc_get_userid_cmd.resp_len, 0, elanmoc_get_userid_cb); + break; + } +} + +static void +elanmoc_list (FpDevice *device) +{ + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (device); + + self->list_result = g_ptr_array_new_with_free_func (g_object_unref); + self->task_ssm = fpi_ssm_new (FP_DEVICE (self), + elan_list_run_state, + MOC_LIST_NUM_STATES); + fpi_ssm_start (self->task_ssm, task_ssm_done); +} + +enum verify_status { + RSP_VERIFY_FAIL, + RSP_VERIFY_OK, + RSP_VERIFY_STATES, +}; + +static void +elanmoc_match_report_cb (FpiDeviceElanmoc *self, + uint8_t *buffer_in, + gsize length_in, + GError *error) +{ + FpDevice *device = FP_DEVICE (self); + FpPrint *print = NULL; + FpPrint *verify_print = NULL; + GPtrArray *prints; + gboolean found = FALSE; + guint index; + + if (error) + { + fpi_ssm_mark_failed (self->task_ssm, error); + return; + } + + if (buffer_in[0] != 0x43) + { + fpi_ssm_mark_failed (self->task_ssm, + fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, + "Can't get response!!")); + return; + } + + print = create_print_from_response (self, buffer_in, length_in, &error); + + if (!print) + { + fpi_ssm_mark_failed (self->task_ssm, error); + return; + } + + fp_info ("Verify/Identify successful for: %s", fp_print_get_description (print)); + + if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_IDENTIFY) + { + fpi_device_get_identify_data (device, &prints); + found = g_ptr_array_find_with_equal_func (prints, + print, + (GEqualFunc) fp_print_equal, + &index); + + if (found) + fpi_device_identify_report (device, g_ptr_array_index (prints, index), print, NULL); + else + fpi_device_identify_report (device, NULL, print, NULL); + + fpi_device_identify_complete (device, NULL); + } + else + { + fpi_device_get_verify_data (device, &verify_print); + + if (fp_print_equal (verify_print, print)) + fpi_device_verify_report (device, FPI_MATCH_SUCCESS, print, NULL); + else + fpi_device_verify_report (device, FPI_MATCH_FAIL, print, NULL); + fpi_device_verify_complete (device, NULL); + } +} + +static void +identify_status_report (FpiDeviceElanmoc *self, int verify_status_id, + int data, GError *error) +{ + FpDevice *device = FP_DEVICE (self); + guint8 *cmd_buf = NULL; + + if (error) + { + fpi_device_enroll_complete (device, NULL, error); + return; + } + + switch (verify_status_id) + { + case RSP_VERIFY_FAIL: + { + if (data == ELAN_MSG_VERIFY_ERR) + { + if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY) + { + fpi_device_verify_report (device, FPI_MATCH_FAIL, NULL, NULL); + fpi_device_verify_complete (device, NULL); + } + else + { + fpi_device_identify_report (device, NULL, NULL, NULL); + fpi_device_identify_complete (device, NULL); + } + } + else + { + GError *retry_error; + + switch (data) + { + case ELAN_MSG_TOO_HIGH: + case ELAN_MSG_TOO_LOW: + case ELAN_MSG_TOO_RIGHT: + case ELAN_MSG_TOO_LEFT: + retry_error = fpi_device_retry_new (FP_DEVICE_RETRY_CENTER_FINGER); + break; + + default: + retry_error = fpi_device_retry_new (FP_DEVICE_RETRY_GENERAL); + } + + if (fpi_device_get_current_action (device) == FPI_DEVICE_ACTION_VERIFY) + { + fpi_device_verify_report (device, FPI_MATCH_ERROR, NULL, retry_error); + fpi_device_verify_complete (device, NULL); + } + else + { + fpi_device_identify_report (device, NULL, NULL, retry_error); + fpi_device_identify_complete (device, NULL); + } + } + break; + } + + case RSP_VERIFY_OK: + { + fp_dbg ("Verify was successful! for user: %d mesg_code: %d ", data, verify_status_id); + cmd_buf = elanmoc_compose_cmd (&elanmoc_get_userid_cmd); + cmd_buf[2] = data; + elanmoc_get_cmd (device, cmd_buf, elanmoc_get_userid_cmd.cmd_len, elanmoc_get_userid_cmd.resp_len, 0, elanmoc_match_report_cb); + break; + } + } +} + +enum identify_states { + IDENTIFY_WAIT_FINGER, + IDENTIFY_NUM_STATES, +}; + +static void +elanmoc_identify_cb (FpiDeviceElanmoc *self, + uint8_t *buffer_in, + gsize length_in, + GError *error) +{ + if (error) + { + fpi_ssm_mark_failed (self->task_ssm, error); + return; + } + + if (buffer_in[1] == ELAN_MSG_VERIFY_ERR) + identify_status_report (self, RSP_VERIFY_FAIL, + buffer_in[1], error); + else if (buffer_in[1] <= ELAN_MAX_ENROLL_NUM) + identify_status_report (self, RSP_VERIFY_OK, buffer_in[1], error); + else + identify_status_report (self, RSP_VERIFY_FAIL, buffer_in[1], error); + fpi_ssm_next_state (self->task_ssm); + +} + +static void +elan_identify_run_state (FpiSsm *ssm, FpDevice *dev) +{ + guint8 *cmd_buf = NULL; + + fp_info ("elanmoc %s ", __func__); + switch (fpi_ssm_get_cur_state (ssm)) + { + case IDENTIFY_WAIT_FINGER: + fp_info ("elanmoc %s VERIFY_WAIT_FINGER", __func__); + cmd_buf = elanmoc_compose_cmd (&elanmoc_verify_cmd); + elanmoc_get_cmd (dev, cmd_buf, elanmoc_verify_cmd.cmd_len, elanmoc_verify_cmd.resp_len, 1, elanmoc_identify_cb); + break; + } +} + +static void +elanmoc_enroll (FpDevice *device) +{ + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (device); + FpPrint *print = NULL; + GVariant *data = NULL; + GVariant *uid = NULL; + g_autofree gchar *user_id; + gsize user_id_len; + guint8 *userdata = g_malloc0 (ELAN_USERDATE_SIZE); + + fpi_device_get_enroll_data (device, &print); + user_id = fpi_print_generate_user_id (print); + user_id_len = strlen (user_id); + user_id_len = MIN (ELAN_MAX_USER_ID_LEN, user_id_len); + + uid = g_variant_new_fixed_array (G_VARIANT_TYPE_BYTE, + user_id, + user_id_len, 1); + + data = g_variant_new ("(yy@ay)", + 0, 0, + uid); + + fpi_print_set_type (print, FPI_PRINT_RAW); + fpi_print_set_device_stored (print, TRUE); + g_object_set (print, "fpi-data", data, NULL); + g_object_set (print, "description", user_id, NULL); + + userdata[0] = 0; + userdata[1] = 0; + userdata[2] = user_id_len; + + memcpy (userdata + 3, user_id, user_id_len); + self->task_ssm = fpi_ssm_new (FP_DEVICE (self), + elan_enroll_run_state, + MOC_ENROLL_NUM_STATES); + fpi_ssm_set_data (self->task_ssm, userdata, (GDestroyNotify) fp_cmd_ssm_done_data_free); + fpi_ssm_start (self->task_ssm, task_ssm_done); +} + +static void +elanmoc_delete_cb (FpiDeviceElanmoc *self, + uint8_t *buffer_in, + gsize length_in, + GError *error) +{ + if (error) + { + fpi_ssm_mark_failed (self->task_ssm, error); + return; + } + if (buffer_in[0] != 0x40 && buffer_in[1] != 0x00) + { + fpi_ssm_mark_failed (self->task_ssm, + fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, + "Can't get response!!")); + } + else + { + fpi_device_delete_complete (FP_DEVICE (self), NULL); + fpi_ssm_next_state (self->task_ssm); + } +} + +static void +elan_delete_run_state (FpiSsm *ssm, FpDevice *dev) +{ + guint8 *cmd_buf = NULL; + guint8 *data = fpi_ssm_get_data (ssm); + + switch (fpi_ssm_get_cur_state (ssm)) + { + case DELETE_SEND_CMD: + cmd_buf = elanmoc_compose_cmd (&elanmoc_delete_cmd); + memcpy (cmd_buf + 3, data, ELAN_USERDATE_SIZE); + elanmoc_get_cmd (dev, cmd_buf, elanmoc_delete_cmd.cmd_len, elanmoc_delete_cmd.resp_len, 0, elanmoc_delete_cb); + break; + } +} + +static void +elanmoc_delete_print (FpDevice *device) +{ + g_autoptr(GVariant) data = NULL; + g_autoptr(GVariant) user_id_var = NULL; + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (device); + FpPrint *print = NULL; + const guint8 *user_id; + g_autofree char *user_id_safe = NULL; + gsize user_id_len = 0; + guint8 *userid_buf = NULL; + + fpi_device_get_delete_data (device, &print); + g_object_get (print, "fpi-data", &data, NULL); + + if (!g_variant_check_format_string (data, "(yy@ay)", FALSE)) + { + fpi_device_delete_complete (device, + fpi_device_error_new (FP_DEVICE_ERROR_DATA_INVALID)); + return; + } + + userid_buf = g_malloc0 (ELAN_USERDATE_SIZE); + + g_variant_get (data, + "(yy@ay)", + &userid_buf[0], + &userid_buf[1], + &user_id_var); + user_id = g_variant_get_fixed_array (user_id_var, &user_id_len, 1); + user_id_safe = g_strndup ((const char *) user_id, user_id_len); + user_id_len = MIN (ELAN_MAX_USER_ID_LEN, user_id_len); + userid_buf[2] = user_id_len; + memcpy (userid_buf + 3, user_id, user_id_len); + + fp_info ("Delete Finger, user_id = %s!", user_id_safe); + self->task_ssm = fpi_ssm_new (device, + elan_delete_run_state, + DELETE_NUM_STATES); + fpi_ssm_set_data (self->task_ssm, userid_buf, g_free); + fpi_ssm_start (self->task_ssm, task_ssm_done); +} + +static void +elanmoc_identify (FpDevice *device) +{ + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (device); + + self->task_ssm = fpi_ssm_new (device, + elan_identify_run_state, + IDENTIFY_NUM_STATES); + fpi_ssm_start (self->task_ssm, task_ssm_done); +} + +static void +task_ssm_init_done (FpiSsm *ssm, FpDevice *dev, GError *error) +{ + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (dev); + + if (error) + g_usb_device_release_interface (fpi_device_get_usb_device (dev), + 0, 0, NULL); + + fpi_device_open_complete (FP_DEVICE (self), error); +} + +static void +elanmoc_cmd_ver_cb (FpiDeviceElanmoc *self, + uint8_t *buffer_in, + gsize length_in, + GError *error) +{ + if (error) + { + fpi_ssm_mark_failed (self->task_ssm, error); + return; + } + + self->fw_ver = (buffer_in[0] << 8 | buffer_in[1]); + fp_info ("elanmoc FW Version %x ", self->fw_ver); + fpi_ssm_next_state (self->task_ssm); +} + +static void +elanmoc_cmd_dim_cb (FpiDeviceElanmoc *self, + uint8_t *buffer_in, + gsize length_in, + GError *error) +{ + if (error) + { + fpi_ssm_mark_failed (self->task_ssm, error); + return; + } + + self->x_trace = buffer_in[0]; + self->y_trace = buffer_in[2]; + fp_info ("elanmoc last_read DIM 0x%.2X(%d) 0x%.2X(%d)", self->x_trace, self->x_trace, + self->y_trace, self->y_trace); + fpi_ssm_next_state (self->task_ssm); +} + +static void +elanmoc_get_status_cb (FpiDeviceElanmoc *self, + uint8_t *buffer_in, + gsize length_in, + GError *error) +{ + guint8 *cmd_buf = NULL; + + if (error) + { + fpi_ssm_mark_failed (self->task_ssm, error); + return; + } + + if (buffer_in[1] != 0x03 && self->cmd_retry_cnt != 0) + { + if(self->cmd_retry_cnt == 0) + { + fpi_ssm_mark_failed (self->task_ssm, + fpi_device_error_new_msg (FP_DEVICE_ERROR_PROTO, + "Sensor not ready")); + return; + } + self->cmd_retry_cnt--; + cmd_buf = elanmoc_compose_cmd (&cal_status_cmd); + elanmoc_get_cmd (FP_DEVICE (self), cmd_buf, cal_status_cmd.cmd_len, cal_status_cmd.resp_len, 0, elanmoc_get_status_cb); + } + else + { + fpi_ssm_next_state (self->task_ssm); + } +} + +static void +dev_init_handler (FpiSsm *ssm, FpDevice *dev) +{ + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (dev); + guint8 *cmd_buf = NULL; + + switch (fpi_ssm_get_cur_state (ssm)) + { + case DEV_WAIT_READY: + self->cmd_retry_cnt = ELAN_MOC_CAL_RETRY; + cmd_buf = elanmoc_compose_cmd (&cal_status_cmd); + elanmoc_get_cmd (dev, cmd_buf, cal_status_cmd.cmd_len, cal_status_cmd.resp_len, 0, elanmoc_get_status_cb); + break; + + case DEV_SET_MODE: + cmd_buf = elanmoc_compose_cmd (&elanmoc_set_mod_cmd); + cmd_buf[3] = 0x03; + elanmoc_get_cmd (dev, cmd_buf, elanmoc_set_mod_cmd.cmd_len, elanmoc_set_mod_cmd.resp_len, 0, elanmoc_cmd_ack_cb); + break; + + case DEV_GET_VER: + cmd_buf = elanmoc_compose_cmd (&fw_ver_cmd); + elanmoc_get_cmd (dev, cmd_buf, fw_ver_cmd.cmd_len, fw_ver_cmd.resp_len, 0, elanmoc_cmd_ver_cb); + break; + + case DEV_GET_DIM: + cmd_buf = elanmoc_compose_cmd (&sensor_dim_cmd); + elanmoc_get_cmd (dev, cmd_buf, sensor_dim_cmd.cmd_len, sensor_dim_cmd.resp_len, 0, elanmoc_cmd_dim_cb); + break; + + case DEV_GET_ENROLLED: + cmd_buf = elanmoc_compose_cmd (&enrolled_number_cmd); + elanmoc_get_cmd (dev, cmd_buf, enrolled_number_cmd.cmd_len, enrolled_number_cmd.resp_len, 0, elanmoc_get_enrolled_cb); + break; + + } +} + +static void +elanmoc_open (FpDevice *device) +{ + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (device); + GError *error = NULL; + + if (!g_usb_device_reset (fpi_device_get_usb_device (device), &error)) + goto error; + + if (!g_usb_device_claim_interface (fpi_device_get_usb_device (device), 0, 0, &error)) + goto error; + + self->task_ssm = fpi_ssm_new (FP_DEVICE (self), dev_init_handler, DEV_INIT_STATES); + fpi_ssm_start (self->task_ssm, task_ssm_init_done); + return; + +error: + fpi_device_open_complete (FP_DEVICE (self), error); +} + +static void +task_ssm_exit_done (FpiSsm *ssm, FpDevice *dev, GError *error) +{ + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (dev); + + g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (self)), 0, 0, &error); + fpi_device_close_complete (FP_DEVICE (self), error); + self->task_ssm = NULL; +} + +static void +dev_exit_handler (FpiSsm *ssm, FpDevice *dev) +{ + guint8 *cmd_buf = NULL; + + switch (fpi_ssm_get_cur_state (ssm)) + { + case DEV_EXIT_ABOVE: + cmd_buf = elanmoc_compose_cmd (&elanmoc_above_cmd); + elanmoc_get_cmd (dev, cmd_buf, elanmoc_above_cmd.cmd_len, elanmoc_above_cmd.resp_len, 0, elanmoc_cmd_ack_cb); + break; + } +} + +static void +elanmoc_close (FpDevice *device) +{ + FpiDeviceElanmoc *self = FPI_DEVICE_ELANMOC (device); + + fp_info ("Elanmoc dev_exit"); + self->task_ssm = fpi_ssm_new (FP_DEVICE (self), dev_exit_handler, DEV_EXIT_STATES); + fpi_ssm_start (self->task_ssm, task_ssm_exit_done); +} + +static void +fpi_device_elanmoc_init (FpiDeviceElanmoc *self) +{ + G_DEBUG_HERE (); +} + +static void +fpi_device_elanmoc_class_init (FpiDeviceElanmocClass *klass) +{ + FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass); + + dev_class->id = FP_COMPONENT; + dev_class->full_name = ELAN_MOC_DRIVER_FULLNAME; + + dev_class->type = FP_DEVICE_TYPE_USB; + dev_class->scan_type = FP_SCAN_TYPE_PRESS; + dev_class->id_table = id_table; + dev_class->nr_enroll_stages = ELAN_MOC_ENROLL_TIMES; + + dev_class->open = elanmoc_open; + dev_class->close = elanmoc_close; + dev_class->verify = elanmoc_identify; + dev_class->enroll = elanmoc_enroll; + dev_class->identify = elanmoc_identify; + dev_class->delete = elanmoc_delete_print; + dev_class->list = elanmoc_list; + + fpi_device_class_auto_initialize_features (dev_class); +} diff --git a/libfprint/drivers/elanmoc/elanmoc.h b/libfprint/drivers/elanmoc/elanmoc.h new file mode 100644 index 0000000..84eed7e --- /dev/null +++ b/libfprint/drivers/elanmoc/elanmoc.h @@ -0,0 +1,195 @@ +/* + * Copyright (C) 2021 Elan Microelectronics + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + */ + +#pragma once + +#include "fpi-device.h" +#include "fpi-ssm.h" +#include + +#include +#include + +G_DECLARE_FINAL_TYPE (FpiDeviceElanmoc, fpi_device_elanmoc, FPI, DEVICE_ELANMOC, FpDevice) + +#define ELAN_MOC_DRIVER_FULLNAME "Elan MOC Sensors" +#define ELAN_M0C_CMD_LEN 0x3 +#define ELAN_EP_CMD_OUT (0x1 | LIBUSB_ENDPOINT_OUT) +#define ELAN_EP_CMD_IN (0x3 | LIBUSB_ENDPOINT_IN) +#define ELAN_EP_MOC_CMD_IN (0x4 | LIBUSB_ENDPOINT_IN) +#define ELAN_EP_IMG_IN (0x2 | LIBUSB_ENDPOINT_IN) + +#define ELAN_MOC_CMD_TIMEOUT 2000 +#define ELAN_MOC_CAL_RETRY 500 +#define ELAN_MOC_ENROLL_TIMES 9 +#define ELAN_MAX_USER_ID_LEN 92 +#define ELAN_MAX_ENROLL_NUM 9 + +#define ELAN_MSG_VERIFY_ERR 0xfd +#define ELAN_MSG_DIRTY 0xfb +#define ELAN_MSG_AREA_NOT_ENOUGH 0xfe +#define ELAN_MSG_TOO_HIGH 0x41 +#define ELAN_MSG_TOO_LEFT 0x42 +#define ELAN_MSG_TOO_LOW 0x43 +#define ELAN_MSG_TOO_RIGHT 0x44 +#define ELAN_MSG_OK 0x00 + +#define ELAN_MAX_HDR_LEN 3 +#define ELAN_USERDATE_SIZE (ELAN_MAX_USER_ID_LEN + 3) + +#define ELAN_MSG_DRIVER_VERSION "1004" + +struct elanmoc_cmd +{ + unsigned char cmd_header[ELAN_MAX_HDR_LEN]; + int cmd_len; + int resp_len; +}; + +static const struct elanmoc_cmd fw_ver_cmd = { + .cmd_header = {0x40, 0x19}, + .cmd_len = 2, + .resp_len = 2, +}; + +static const struct elanmoc_cmd sensor_dim_cmd = { + .cmd_header = {0x00, 0x0c}, + .cmd_len = 2, + .resp_len = 4, +}; + +static const struct elanmoc_cmd cal_status_cmd = { + .cmd_header = {0x40, 0xff, 0x00}, + .cmd_len = 3, + .resp_len = 2, +}; + +static const struct elanmoc_cmd enrolled_number_cmd = { + .cmd_header = {0x40, 0xff, 0x04}, + .cmd_len = 3, + .resp_len = 2, +}; + +static const struct elanmoc_cmd elanmoc_verify_cmd = { + .cmd_header = {0x40, 0xff, 0x73}, + .cmd_len = 5, + .resp_len = 2, +}; + +static const struct elanmoc_cmd elanmoc_above_cmd = { + .cmd_header = {0x40, 0xff, 0x02}, + .cmd_len = 3, + .resp_len = 0, +}; + +static const struct elanmoc_cmd elanmoc_enroll_cmd = { + .cmd_header = {0x40, 0xff, 0x01}, + .cmd_len = 7, + .resp_len = 2, +}; + +static const struct elanmoc_cmd elanmoc_delete_cmd = { + .cmd_header = {0x40, 0xff, 0x13}, + .cmd_len = 128, + .resp_len = 2, +}; + +static const struct elanmoc_cmd elanmoc_enroll_commit_cmd = { + .cmd_header = {0x40, 0xff, 0x11}, + .cmd_len = 128, + .resp_len = 2, +}; + +static const struct elanmoc_cmd elanmoc_remove_all_cmd = { + .cmd_header = {0x40, 0xff, 0x98}, + .cmd_len = 3, + .resp_len = 2, +}; + +static const struct elanmoc_cmd elanmoc_get_userid_cmd = { + .cmd_header = {0x43, 0x21, 0x00}, + .cmd_len = 3, + .resp_len = 97, +}; + +static const struct elanmoc_cmd elanmoc_set_mod_cmd = { + .cmd_header = {0x40, 0xff, 0x14}, + .cmd_len = 4, + .resp_len = 2, +}; + +static const struct elanmoc_cmd elanmoc_check_reenroll_cmd = { + .cmd_header = {0x40, 0xff, 0x22}, + .cmd_len = 5, + .resp_len = 2, +}; + +typedef void (*ElanCmdMsgCallback) (FpiDeviceElanmoc *self, + GError *error); + +enum moc_enroll_states { + MOC_ENROLL_GET_ENROLLED_NUM, + MOC_ENROLL_REENROLL_CHECK, + MOC_ENROLL_WAIT_FINGER, + MOC_ENROLL_COMMIT_RESULT, + MOC_ENROLL_NUM_STATES, +}; + +enum moc_list_states { + MOC_LIST_GET_ENROLLED, + MOC_LIST_GET_FINGER, + MOC_LIST_NUM_STATES, +}; + +enum delete_states { + DELETE_SEND_CMD, + DELETE_NUM_STATES, +}; + +enum dev_init_states { + DEV_WAIT_READY, + DEV_SET_MODE, + DEV_GET_VER, + DEV_GET_DIM, + DEV_GET_ENROLLED, + DEV_INIT_STATES, +}; + +enum dev_exit_states { + DEV_EXIT_ABOVE, + DEV_EXIT_STATES, +}; + +struct _FpiDeviceElanmoc +{ + FpDevice parent; + FpiSsm *task_ssm; + FpiSsm *cmd_ssm; + FpiUsbTransfer *cmd_transfer; + gboolean cmd_cancelable; + gsize cmd_len_in; + unsigned short fw_ver; + unsigned char x_trace; + unsigned char y_trace; + int num_frames; + int curr_enrolled; + int cancel_result; + int cmd_retry_cnt; + int list_index; + GPtrArray *list_result; +}; diff --git a/libfprint/meson.build b/libfprint/meson.build index 6855f1e..ef287f6 100644 --- a/libfprint/meson.build +++ b/libfprint/meson.build @@ -121,6 +121,8 @@ driver_sources = { [ 'drivers/vfs0050.c' ], 'elan' : [ 'drivers/elan.c' ], + 'elanmoc' : + [ 'drivers/elanmoc/elanmoc.c' ], 'elanspi' : [ 'drivers/elanspi.c' ], 'nb1010' : diff --git a/meson.build b/meson.build index d2bc8e8..72dee50 100644 --- a/meson.build +++ b/meson.build @@ -116,6 +116,7 @@ default_drivers = [ 'vcom5s', 'synaptics', 'elan', + 'elanmoc', 'uru4000', 'upektc', 'upeksonly',