depau/libfprint
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
libfprint/libfprint/drivers/vfs101.c
Marco Trevisan (Treviño) d1fb1e26f3 Uncrustify everything except for nbis
2019-11-20 20:38:06 +01:00

1390 lines
35 KiB
C
Raw Blame History

/*
* Validity VFS101 driver for libfprint
* Copyright (C) 2011 Sergio Cerlesi <sergio.cerlesi@gmail.com>
*
* 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 "vfs101"
#include "drivers_api.h"
/* Input-Output usb endpoint */
#define EP_IN(n) (n | FPI_USB_ENDPOINT_IN)
#define EP_OUT(n) (n | FPI_USB_ENDPOINT_OUT)
/* Usb bulk timeout */
#define BULK_TIMEOUT 100
/* The device send back the image into block of 16 frames of 292 bytes */
#define VFS_FRAME_SIZE 292
#define VFS_BLOCK_SIZE 16 * VFS_FRAME_SIZE
/* Buffer height */
#define VFS_BUFFER_HEIGHT 5000
/* Buffer size */
#define VFS_BUFFER_SIZE (VFS_BUFFER_HEIGHT * VFS_FRAME_SIZE)
/* Image width */
#define VFS_IMG_WIDTH 200
/* Maximum image height */
#define VFS_IMG_MAX_HEIGHT 1023
/* Minimum image height */
#define VFS_IMG_MIN_HEIGHT 200
/* Scan level threshold */
#define VFS_IMG_SLT_BEGIN 768
#define VFS_IMG_SLT_END 64
#define VFS_IMG_SLT_LINES 4
/* Minimum image level */
#define VFS_IMG_MIN_IMAGE_LEVEL 144
/* Best image contrast */
#define VFS_IMG_BEST_CONTRAST 128
/* Device parameters address */
#define VFS_PAR_000E 0x000e
#define VFS_PAR_0011 0x0011
#define VFS_PAR_THRESHOLD 0x0057
#define VFS_PAR_STATE_3 0x005e
#define VFS_PAR_STATE_5 0x005f
#define VFS_PAR_INFO_RATE 0x0062
#define VFS_PAR_0076 0x0076
#define VFS_PAR_INFO_CONTRAST 0x0077
#define VFS_PAR_0078 0x0078
/* Device regiones address */
#define VFS_REG_IMG_EXPOSURE 0xff500e
#define VFS_REG_IMG_CONTRAST 0xff5038
/* Device settings */
#define VFS_VAL_000E 0x0001
#define VFS_VAL_0011 0x0008
#define VFS_VAL_THRESHOLD 0x0096
#define VFS_VAL_STATE_3 0x0064
#define VFS_VAL_STATE_5 0x00c8
#define VFS_VAL_INFO_RATE 0x0001
#define VFS_VAL_0076 0x0012
#define VFS_VAL_0078 0x2230
#define VFS_VAL_IMG_EXPOSURE 0x21c0
/* Structure for Validity device */
struct _FpDeviceVfs101
{
FpImageDevice parent;
/* Action state */
gboolean active;
gboolean deactivate;
/* Sequential number */
unsigned int seqnum;
/* Buffer for input/output */
unsigned char *buffer;
/* Length of data to send or received */
unsigned int length;
/* Ignore usb error */
int ignore_error;
/* Loop counter */
int counter;
/* Image contrast */
int contrast;
/* Best contrast */
int best_contrast;
/* Best contrast level */
int best_clevel;
/* Bottom line of image */
int bottom;
/* Image height */
int height;
};
G_DECLARE_FINAL_TYPE (FpDeviceVfs101, fpi_device_vfs101, FPI, DEVICE_VFS101,
FpImageDevice);
G_DEFINE_TYPE (FpDeviceVfs101, fpi_device_vfs101, FP_TYPE_IMAGE_DEVICE);
/* Return byte at specified position */
static inline unsigned char
byte (int position, int value)
{
return (value >> (position * 8)) & 0xff;
}
/* Return sequential number */
static inline unsigned short
get_seqnum (int h, int l)
{
return (h << 8) | l;
}
/* Check sequential number */
static inline int
check_seqnum (FpDeviceVfs101 *vdev)
{
if ((byte (0, vdev->seqnum) == vdev->buffer[0]) &&
(byte (1, vdev->seqnum) == vdev->buffer[1]))
return 0;
else
return 1;
}
/* Internal result codes */
enum {
RESULT_RETRY,
RESULT_RETRY_SHORT,
RESULT_RETRY_REMOVE,
RESULT_COUNT,
};
/* Dump buffer for debug */
#define dump_buffer(buf) \
fp_dbg ("%02x %02x %02x %02x %02x %02x %02x %02x", \
buf[6], buf[7], buf[8], buf[9], buf[10], buf[11], buf[12], buf[13] \
)
/* Callback of asynchronous send */
static void
async_send_cb (FpiUsbTransfer *transfer, FpDevice *device,
gpointer user_data, GError *error)
{
FpImageDevice *dev = FP_IMAGE_DEVICE (device);
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev);
/* Skip error check if ignore_error is set */
if (error)
{
if (!self->ignore_error)
{
fpi_ssm_mark_failed (transfer->ssm, error);
return;
}
else
{
g_error_free (error);
fp_dbg ("Ignoring send error: %s", error->message);
}
}
/* Reset ignore_error flag */
self->ignore_error = FALSE;
/* Dump buffer for debug */
dump_buffer (self->buffer);
fpi_ssm_next_state (transfer->ssm);
}
/* Submit asynchronous send */
static void
async_send (FpiSsm *ssm,
FpImageDevice *dev)
{
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev);
FpiUsbTransfer *transfer;
transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
/* Put sequential number into the buffer */
self->seqnum++;
self->buffer[0] = byte (0, self->seqnum);
self->buffer[1] = byte (1, self->seqnum);
/* Prepare bulk transfer */
fpi_usb_transfer_fill_bulk_full (transfer, EP_OUT (1),
self->buffer, self->length, NULL);
transfer->ssm = ssm;
transfer->short_is_error = TRUE;
fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
async_send_cb, NULL);
fpi_usb_transfer_unref (transfer);
}
/* Callback of asynchronous recv */
static void
async_recv_cb (FpiUsbTransfer *transfer, FpDevice *device,
gpointer user_data, GError *error)
{
FpImageDevice *dev = FP_IMAGE_DEVICE (device);
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev);
/* Skip error check if ignore_error is set */
if (!self->ignore_error)
{
if (error)
{
/* Transfer not completed, return IO error */
fpi_ssm_mark_failed (transfer->ssm, error);
return;
}
if (check_seqnum (self))
{
/* Sequential number received mismatch, return protocol error */
fp_err ("seqnum mismatch, got %04x, expected %04x",
get_seqnum (self->buffer[1], self->buffer[0]),
self->seqnum);
fpi_ssm_mark_failed (transfer->ssm, fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
return;
}
}
g_clear_pointer (&error, g_error_free);
/* Reset ignore_error flag */
self->ignore_error = FALSE;
/* Dump buffer for debug */
dump_buffer (self->buffer);
/* Set length of received data */
self->length = transfer->actual_length;
fpi_ssm_next_state (transfer->ssm);
}
/* Submit asynchronous recv */
static void
async_recv (FpiSsm *ssm,
FpImageDevice *dev)
{
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev);
FpiUsbTransfer *transfer;
/* Allocation of transfer */
transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
/* Prepare bulk transfer */
fpi_usb_transfer_fill_bulk_full (transfer, EP_IN (1), self->buffer,
0x0f, NULL);
transfer->ssm = ssm;
fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
async_recv_cb, NULL);
fpi_usb_transfer_unref (transfer);
}
static void async_load (FpiSsm *ssm,
FpImageDevice *dev);
/* Callback of asynchronous load */
static void
async_load_cb (FpiUsbTransfer *transfer, FpDevice *device,
gpointer user_data, GError *error)
{
FpImageDevice *dev = FP_IMAGE_DEVICE (device);
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev);
/* Skip error check if ignore_error is set */
if (!self->ignore_error)
{
if (error)
{
/* Transfer not completed */
fpi_ssm_mark_failed (transfer->ssm, error);
return;
}
if (transfer->actual_length % VFS_FRAME_SIZE)
{
/* Received incomplete frame, return protocol error */
fp_err ("received incomplete frame");
fpi_ssm_mark_failed (transfer->ssm, fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
return;
}
}
/* Any error has been ignored. */
g_clear_pointer (&error, g_error_free);
/* Increase image length */
self->length += transfer->actual_length;
if (transfer->actual_length == VFS_BLOCK_SIZE)
{
if ((VFS_BUFFER_SIZE - self->length) < VFS_BLOCK_SIZE)
{
/* Buffer full, image too large, return no memory error */
fp_err ("buffer full, image too large");
fpi_ssm_mark_failed (transfer->ssm, fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
return;
}
else
{
/* Image load not completed, submit another asynchronous load */
async_load (transfer->ssm, dev);
}
}
else
{
/* Reset ignore_error flag */
self->ignore_error = FALSE;
/* Image load completed, go to next state */
self->height = self->length / VFS_FRAME_SIZE;
fp_dbg ("image loaded, height = %d", self->height);
fpi_ssm_next_state (transfer->ssm);
}
}
/* Submit asynchronous load */
static void
async_load (FpiSsm *ssm,
FpImageDevice *dev)
{
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev);
FpiUsbTransfer *transfer;
unsigned char *buffer;
/* Allocation of transfer */
transfer = fpi_usb_transfer_new (FP_DEVICE (dev));
/* Append new data into the buffer */
buffer = self->buffer + self->length;
/* Prepare bulk transfer */
fpi_usb_transfer_fill_bulk_full (transfer, EP_IN (2), buffer,
VFS_BLOCK_SIZE, NULL);
transfer->ssm = ssm;
fpi_usb_transfer_submit (transfer, BULK_TIMEOUT, NULL,
async_load_cb, NULL);
fpi_usb_transfer_unref (transfer);
}
/* Submit asynchronous sleep */
static void
async_sleep (unsigned int msec,
FpiSsm *ssm,
FpImageDevice *dev)
{
fpi_device_add_timeout (FP_DEVICE (dev), msec,
fpi_ssm_next_state_timeout_cb, ssm);
}
/* Swap ssm states */
enum {
M_SWAP_SEND,
M_SWAP_RECV,
M_SWAP_NUM_STATES,
};
/* Exec swap sequential state machine */
static void
m_swap_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
{
switch (fpi_ssm_get_cur_state (ssm))
{
case M_SWAP_SEND:
/* Send data */
async_send (ssm, user_data);
break;
case M_SWAP_RECV:
/* Recv response */
async_recv (ssm, user_data);
break;
}
}
/* Start swap sequential state machine */
static void
m_swap (FpiSsm *ssm,
FpImageDevice *dev,
unsigned char *data,
size_t length)
{
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev);
FpiSsm *subsm;
/* Prepare data for sending */
memcpy (self->buffer, data, length);
memset (self->buffer + length, 0, 16 - length);
self->length = length;
/* Start swap ssm */
subsm = fpi_ssm_new (FP_DEVICE (dev), m_swap_state, M_SWAP_NUM_STATES,
dev);
fpi_ssm_start_subsm (ssm, subsm);
}
/* Retrieve fingerprint image */
static void
vfs_get_print (FpiSsm *ssm,
FpImageDevice *dev,
unsigned int param,
int type)
{
unsigned char data[2][0x0e] = {
{ 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01 },
{ 0x00, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00,
0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01 }
};
fp_dbg ("param = %04x, type = %d", param, type);
/* Prepare data for sending */
data[type][6] = byte (0, param);
data[type][7] = byte (1, param);
/* Run swap sequential state machine */
m_swap (ssm, dev, data[type], 0x0e);
}
/* Set a parameter value on the device */
static void
vfs_set_param (FpiSsm *ssm,
FpImageDevice *dev,
unsigned int param,
unsigned int value)
{
unsigned char data[0x0a] = { 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00 };
fp_dbg ("param = %04x, value = %04x", param, value);
/* Prepare data for sending */
data[6] = byte (0, param);
data[7] = byte (1, param);
data[8] = byte (0, value);
data[9] = byte (1, value);
/* Run swap sequential state machine */
m_swap (ssm, dev, data, 0x0a);
}
/* Abort previous print */
static void
vfs_abort_print (FpiSsm *ssm,
FpImageDevice *dev)
{
unsigned char data[0x06] = { 0x00, 0x00, 0x00, 0x00, 0x0E, 0x00 };
G_DEBUG_HERE ();
/* Run swap sequential state machine */
m_swap (ssm, dev, data, 0x06);
}
/* Poke a value on a region */
static void
vfs_poke (FpiSsm *ssm,
FpImageDevice *dev,
unsigned int addr,
unsigned int value,
unsigned int size)
{
unsigned char data[0x0f] = { 0x00, 0x00, 0x00, 0x00, 0x13, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
fp_dbg ("addr = %04x, value = %04x", addr, value);
/* Prepare data for sending */
data[6] = byte (0, addr);
data[7] = byte (1, addr);
data[8] = byte (2, addr);
data[9] = byte (3, addr);
data[10] = byte (0, value);
data[11] = byte (1, value);
data[12] = byte (2, value);
data[13] = byte (3, value);
data[14] = byte (0, size);
/* Run swap sequential state machine */
m_swap (ssm, dev, data, 0x0f);
}
/* Get current finger state */
static void
vfs_get_finger_state (FpiSsm *ssm,
FpImageDevice *dev)
{
unsigned char data[0x06] = { 0x00, 0x00, 0x00, 0x00, 0x16, 0x00 };
G_DEBUG_HERE ();
/* Run swap sequential state machine */
m_swap (ssm, dev, data, 0x06);
}
/* Load raw image from reader */
static void
vfs_img_load (FpiSsm *ssm,
FpImageDevice *dev)
{
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev);
G_DEBUG_HERE ();
/* Reset buffer length */
self->length = 0;
/* Reset image properties */
self->bottom = 0;
self->height = -1;
/* Asynchronous load */
async_load (ssm, dev);
}
#define offset(x, y) ((x) + ((y) * VFS_FRAME_SIZE))
/* Screen image to remove noise and find bottom line and height of image */
static void
img_screen (FpDeviceVfs101 *vdev)
{
int y, x, count, top;
long int level;
int last_line = vdev->height - 1;
fp_dbg ("image height before screen = %d", vdev->height);
count = 0;
/* Image returned from sensor can contain many empty lines,
* for remove these lines compare byte 282-283 (scan level information)
* with two different thresholds, one for the begin of finger image and
* one for the end. To increase stability of the code use a counter
* of lines that satisfy the threshold.
*/
for (y = last_line, top = last_line; y >= 0; y--)
{
/* Take image scan level */
level = vdev->buffer[offset (283, y)] * 256 +
vdev->buffer[offset (282, y)];
fp_dbg ("line = %d, scan level = %ld", y, level);
if (level >= VFS_IMG_SLT_BEGIN && top == last_line)
{
/* Begin threshold satisfied */
if (count < VFS_IMG_SLT_LINES)
{
/* Increase count */
count++;
}
else
{
/* Found top fingerprint line */
top = y + VFS_IMG_SLT_LINES;
count = 0;
}
}
else if ((level < VFS_IMG_SLT_END || level >= 65535) &&
top != last_line)
{
/* End threshold satisfied */
if (count < VFS_IMG_SLT_LINES)
{
/* Increase count */
count++;
}
else
{
/* Found bottom fingerprint line */
vdev->bottom = y + VFS_IMG_SLT_LINES + 1;
break;
}
}
else
{
/* Not threshold satisfied, reset count */
count = 0;
}
}
vdev->height = top - vdev->bottom + 1;
/* Check max height */
if (vdev->height > VFS_IMG_MAX_HEIGHT)
vdev->height = VFS_IMG_MAX_HEIGHT;
fp_dbg ("image height after screen = %d", vdev->height);
/* Scan image and remove noise */
for (y = vdev->bottom; y <= top; y++)
for (x = 6; x < VFS_IMG_WIDTH + 6; x++)
if (vdev->buffer[offset (x, y)] > VFS_IMG_MIN_IMAGE_LEVEL)
vdev->buffer[offset (x, y)] = 255;
};
/* Copy image from reader buffer and put it into image data */
static void
img_copy (FpDeviceVfs101 *self, FpImage *img)
{
unsigned int line;
unsigned char *img_buffer = img->data;
unsigned char *vdev_buffer = self->buffer + (self->bottom * VFS_FRAME_SIZE) + 6;
for (line = 0; line < img->height; line++)
{
/* Copy image line from reader buffer to image data */
memcpy (img_buffer, vdev_buffer, VFS_IMG_WIDTH);
/* Next line of reader buffer */
vdev_buffer = vdev_buffer + VFS_FRAME_SIZE;
/* Next line of image buffer */
img_buffer = img_buffer + VFS_IMG_WIDTH;
}
}
/* Extract fingerpint image from raw data */
static void
img_extract (FpiSsm *ssm,
FpImageDevice *dev)
{
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev);
FpImage *img;
/* Screen image to remove noise and find top and bottom line */
img_screen (self);
/* Check image height */
if (self->height < VFS_IMG_MIN_HEIGHT)
{
/* Image too short */
self->height = 0;
fpi_image_device_retry_scan (dev, FP_DEVICE_RETRY_TOO_SHORT);
return;
}
/* Create new image */
img = fp_image_new (self->height, VFS_IMG_WIDTH);
img->width = VFS_IMG_WIDTH;
img->height = self->height;
img->flags = FPI_IMAGE_V_FLIPPED;
/* Copy data into image */
img_copy (self, img);
/* Notify image captured */
fpi_image_device_image_captured (dev, img);
};
/* Finger states */
enum {
VFS_FINGER_EMPTY,
VFS_FINGER_PRESENT,
VFS_FINGER_UNKNOWN,
};
/* Return finger state */
static inline int
vfs_finger_state (FpDeviceVfs101 *vdev)
{
/* Check finger state */
switch (vdev->buffer[0x0a])
{
case 0x00:
case 0x01:
/* Finger is empty */
return VFS_FINGER_EMPTY;
break;
case 0x02:
case 0x03:
case 0x04:
case 0x05:
case 0x06:
/* Finger is present */
return VFS_FINGER_PRESENT;
break;
default:
return VFS_FINGER_UNKNOWN;
}
};
/* Check contrast of image */
static void
vfs_check_contrast (FpDeviceVfs101 *vdev)
{
int y;
long int count = 0;
/* Check difference from byte 4 to byte 5 for verify contrast of image */
for (y = 0; y < vdev->height; y++)
count = count + vdev->buffer[offset (5, y)] - vdev->buffer[offset (4, y)];
count = count / vdev->height;
if (count < 16)
{
/* Contrast not valid, retry */
vdev->contrast++;
return;
}
fp_dbg ("contrast = %d, level = %ld", vdev->contrast, count);
if (labs (count - VFS_IMG_BEST_CONTRAST) < abs (vdev->best_clevel - VFS_IMG_BEST_CONTRAST))
{
/* Better contrast found, use it */
vdev->best_contrast = vdev->contrast;
vdev->best_clevel = count;
}
}
/* Loop ssm states */
enum {
/* Step 0 - Scan finger */
M_LOOP_0_GET_PRINT,
M_LOOP_0_SLEEP,
M_LOOP_0_GET_STATE,
M_LOOP_0_LOAD_IMAGE,
M_LOOP_0_EXTRACT_IMAGE,
M_LOOP_0_CHECK_ACTION,
/* Step 1 - Scan failed */
M_LOOP_1_GET_STATE,
M_LOOP_1_CHECK_STATE,
M_LOOP_1_GET_PRINT,
M_LOOP_1_LOAD_IMAGE,
M_LOOP_1_LOOP,
M_LOOP_1_SLEEP,
/* Step 2 - Abort print */
M_LOOP_2_ABORT_PRINT,
M_LOOP_2_LOAD_IMAGE,
/* Step 3 - Wait aborting */
M_LOOP_3_GET_PRINT,
M_LOOP_3_LOAD_IMAGE,
M_LOOP_3_CHECK_IMAGE,
M_LOOP_3_LOOP,
/* Number of states */
M_LOOP_NUM_STATES,
};
/* Exec loop sequential state machine */
static void
m_loop_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
{
FpImageDevice *dev = user_data;
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (_dev);
/* Complete if deactivation was requested */
if (self->deactivate)
{
fpi_ssm_mark_completed (ssm);
return;
}
switch (fpi_ssm_get_cur_state (ssm))
{
case M_LOOP_0_GET_PRINT:
/* Send get print command to the reader */
vfs_get_print (ssm, dev, VFS_BUFFER_HEIGHT, 1);
break;
case M_LOOP_0_SLEEP:
/* Wait fingerprint scanning */
async_sleep (50, ssm, dev);
break;
case M_LOOP_0_GET_STATE:
/* Get finger state */
vfs_get_finger_state (ssm, dev);
break;
case M_LOOP_0_LOAD_IMAGE:
/* Check finger state */
switch (vfs_finger_state (self))
{
case VFS_FINGER_EMPTY:
fpi_image_device_report_finger_status (dev, FALSE);
/* Finger isn't present, loop */
fpi_ssm_jump_to_state (ssm, M_LOOP_0_SLEEP);
break;
case VFS_FINGER_PRESENT:
fpi_image_device_report_finger_status (dev, TRUE);
/* Load image from reader */
self->ignore_error = TRUE;
vfs_img_load (ssm, dev);
break;
default:
fpi_image_device_report_finger_status (dev, FALSE);
/* Unknown state */
fp_err ("unknown device state 0x%02x",
self->buffer[0x0a]);
fpi_ssm_mark_failed (ssm, fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
break;
}
break;
case M_LOOP_0_EXTRACT_IMAGE:
/* Fingerprint is loaded, extract image from raw data */
img_extract (ssm, dev);
/* Wait handling image */
async_sleep (10, ssm, dev);
break;
case M_LOOP_0_CHECK_ACTION:
/* Action not completed */
if (self->height > 0)
/* Continue loop */
fpi_ssm_jump_to_state (ssm, M_LOOP_2_ABORT_PRINT);
else
/* Error found */
fpi_ssm_next_state (ssm);
break;
case M_LOOP_1_GET_STATE:
/* Get finger state */
vfs_get_finger_state (ssm, dev);
break;
case M_LOOP_1_CHECK_STATE:
/* Check finger state */
if (vfs_finger_state (self) == VFS_FINGER_PRESENT)
{
fpi_image_device_report_finger_status (dev, TRUE);
async_sleep (250, ssm, dev);
}
else
{
/* Finger not present */
fpi_image_device_report_finger_status (dev, FALSE);
/* Continue */
fpi_ssm_jump_to_state (ssm, M_LOOP_1_SLEEP);
}
break;
case M_LOOP_1_GET_PRINT:
/* Send get print command to the reader */
vfs_get_print (ssm, dev, VFS_BUFFER_HEIGHT, 1);
break;
case M_LOOP_1_LOAD_IMAGE:
/* Load image */
self->ignore_error = TRUE;
vfs_img_load (ssm, dev);
break;
case M_LOOP_1_LOOP:
/* Loop */
fpi_ssm_jump_to_state (ssm, M_LOOP_1_GET_STATE);
break;
case M_LOOP_1_SLEEP:
/* Wait fingerprint scanning */
async_sleep (10, ssm, dev);
break;
case M_LOOP_2_ABORT_PRINT:
/* Abort print command */
vfs_abort_print (ssm, dev);
break;
case M_LOOP_2_LOAD_IMAGE:
/* Load abort image */
self->ignore_error = TRUE;
vfs_img_load (ssm, dev);
break;
case M_LOOP_3_GET_PRINT:
/* Get empty image */
vfs_get_print (ssm, dev, 0x000a, 0);
break;
case M_LOOP_3_LOAD_IMAGE:
/* Load abort image */
self->ignore_error = TRUE;
vfs_img_load (ssm, dev);
break;
case M_LOOP_3_CHECK_IMAGE:
if (self->height == 10)
{
/* Image load correctly, jump to step 0 */
self->counter = 0;
fpi_ssm_jump_to_state (ssm, M_LOOP_0_GET_PRINT);
}
else if (self->counter < 10)
{
/* Wait aborting */
self->counter++;
async_sleep (100, ssm, dev);
}
else
{
/* reach max loop counter, return protocol error */
fp_err ("waiting abort reach max loop counter");
fpi_ssm_mark_failed (ssm, fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
}
break;
case M_LOOP_3_LOOP:
/* Loop */
fpi_ssm_jump_to_state (ssm, M_LOOP_3_GET_PRINT);
break;
}
}
/* Complete loop sequential state machine */
static void
m_loop_complete (FpiSsm *ssm, FpDevice *dev, void *user_data,
GError *error)
{
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev);
/* When the loop completes, we have (successfully) deactivated */
if (self->active)
fpi_image_device_deactivate_complete (FP_IMAGE_DEVICE (dev),
error);
self->active = FALSE;
fpi_ssm_free (ssm);
}
/* Init ssm states */
enum {
/* Step 0 - Cleanup device buffer */
M_INIT_0_RECV_DIRTY,
M_INIT_0_ABORT_PRINT,
M_INIT_0_LOAD_IMAGE,
/* Step 1 - Wait aborting */
M_INIT_1_GET_PRINT,
M_INIT_1_LOAD_IMAGE,
M_INIT_1_CHECK_IMAGE,
M_INIT_1_LOOP,
/* Step 2 - Handle unexpected finger presence */
M_INIT_2_GET_STATE,
M_INIT_2_CHECK_STATE,
M_INIT_2_GET_PRINT,
M_INIT_2_LOAD_IMAGE,
M_INIT_2_LOOP,
/* Step 3 - Set parameters */
M_INIT_3_SET_000E,
M_INIT_3_SET_0011,
M_INIT_3_SET_0076,
M_INIT_3_SET_0078,
M_INIT_3_SET_THRESHOLD,
M_INIT_3_SET_STATE3_COUNT,
M_INIT_3_SET_STATE5_COUNT,
M_INIT_3_SET_INFO_CONTRAST,
M_INIT_3_SET_INFO_RATE,
/* Step 4 - Autocalibrate contrast */
M_INIT_4_SET_EXPOSURE,
M_INIT_4_SET_CONTRAST,
M_INIT_4_GET_PRINT,
M_INIT_4_LOAD_IMAGE,
M_INIT_4_CHECK_CONTRAST,
/* Step 5 - Set info line parameters */
M_INIT_5_SET_EXPOSURE,
M_INIT_5_SET_CONTRAST,
M_INIT_5_SET_INFO_CONTRAST,
M_INIT_5_SET_INFO_RATE,
/* Number of states */
M_INIT_NUM_STATES,
};
/* Exec init sequential state machine */
static void
m_init_state (FpiSsm *ssm, FpDevice *_dev, void *user_data)
{
FpImageDevice *dev = user_data;
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (_dev);
/* Mark as cancelled when activation collides with deactivation. */
if (self->deactivate)
{
fpi_ssm_mark_failed (ssm,
g_error_new (G_IO_ERROR,
G_IO_ERROR_CANCELLED,
"Initialisation was cancelled"));
return;
}
switch (fpi_ssm_get_cur_state (ssm))
{
case M_INIT_0_RECV_DIRTY:
/* Recv eventually dirty data */
self->ignore_error = TRUE;
async_recv (ssm, dev);
break;
case M_INIT_0_ABORT_PRINT:
/* Abort print command */
vfs_abort_print (ssm, dev);
break;
case M_INIT_0_LOAD_IMAGE:
/* Load abort image */
self->ignore_error = TRUE;
vfs_img_load (ssm, dev);
break;
case M_INIT_1_GET_PRINT:
/* Get empty image */
vfs_get_print (ssm, dev, 0x000a, 0);
break;
case M_INIT_1_LOAD_IMAGE:
/* Load abort image */
self->ignore_error = TRUE;
vfs_img_load (ssm, dev);
break;
case M_INIT_1_CHECK_IMAGE:
if (self->height == 10)
{
/* Image load correctly, jump to step 2 */
self->counter = 0;
fpi_ssm_jump_to_state (ssm, M_INIT_2_GET_STATE);
}
else if (self->counter < 10)
{
/* Wait aborting */
self->counter++;
async_sleep (100, ssm, dev);
}
else
{
/* reach max loop counter, return protocol error */
fp_err ("waiting abort reach max loop counter");
fpi_ssm_mark_failed (ssm, fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
}
break;
case M_INIT_1_LOOP:
/* Loop */
fpi_ssm_jump_to_state (ssm, M_INIT_1_GET_PRINT);
break;
case M_INIT_2_GET_STATE:
/* Get finger state */
vfs_get_finger_state (ssm, dev);
break;
case M_INIT_2_CHECK_STATE:
/* Check finger state */
if (vfs_finger_state (self) == VFS_FINGER_PRESENT)
{
/* Wait a bit for finger removal; if it doesn't happen, prompt */
if (self->counter < 2)
{
/* Wait removing finger */
self->counter++;
async_sleep (250, ssm, dev);
}
else
{
/* The user should remove their finger from the scanner */
fp_warn ("unexpected finger find, remove finger from the scanner");
fpi_ssm_mark_failed (ssm, fpi_device_retry_new (FP_DEVICE_RETRY_REMOVE_FINGER));
}
}
else
{
/* Finger not present */
if (self->counter == 0)
{
/* Continue */
fpi_ssm_jump_to_state (ssm, M_INIT_3_SET_000E);
}
else
{
/* Finger removed, jump to abort */
self->counter = 0;
fpi_ssm_jump_to_state (ssm, M_INIT_0_ABORT_PRINT);
}
}
break;
case M_INIT_2_GET_PRINT:
/* Send get print command to the reader */
vfs_get_print (ssm, dev, VFS_BUFFER_HEIGHT, 1);
break;
case M_INIT_2_LOAD_IMAGE:
/* Load unexpected image */
self->ignore_error = TRUE;
vfs_img_load (ssm, dev);
break;
case M_INIT_2_LOOP:
/* Loop */
fpi_ssm_jump_to_state (ssm, M_INIT_2_GET_STATE);
break;
case M_INIT_3_SET_000E:
/* Set param 0x000e, required for take image */
vfs_set_param (ssm, dev, VFS_PAR_000E, VFS_VAL_000E);
break;
case M_INIT_3_SET_0011:
/* Set param 0x0011, required for take image */
vfs_set_param (ssm, dev, VFS_PAR_0011, VFS_VAL_0011);
break;
case M_INIT_3_SET_0076:
/* Set param 0x0076, required for use info line */
vfs_set_param (ssm, dev, VFS_PAR_0076, VFS_VAL_0076);
break;
case M_INIT_3_SET_0078:
/* Set param 0x0078, required for use info line */
vfs_set_param (ssm, dev, VFS_PAR_0078, VFS_VAL_0078);
break;
case M_INIT_3_SET_THRESHOLD:
/* Set threshold */
vfs_set_param (ssm, dev, VFS_PAR_THRESHOLD, VFS_VAL_THRESHOLD);
break;
case M_INIT_3_SET_STATE3_COUNT:
/* Set state 3 count */
vfs_set_param (ssm, dev, VFS_PAR_STATE_3, VFS_VAL_STATE_3);
break;
case M_INIT_3_SET_STATE5_COUNT:
/* Set state 5 count */
vfs_set_param (ssm, dev, VFS_PAR_STATE_5, VFS_VAL_STATE_5);
break;
case M_INIT_3_SET_INFO_CONTRAST:
/* Set info line contrast */
vfs_set_param (ssm, dev, VFS_PAR_INFO_CONTRAST, 10);
break;
case M_INIT_3_SET_INFO_RATE:
/* Set info line rate */
vfs_set_param (ssm, dev, VFS_PAR_INFO_RATE, 32);
break;
case M_INIT_4_SET_EXPOSURE:
/* Set exposure level of reader */
vfs_poke (ssm, dev, VFS_REG_IMG_EXPOSURE, 0x4000, 0x02);
self->counter = 1;
break;
case M_INIT_4_SET_CONTRAST:
/* Set contrast level of reader */
vfs_poke (ssm, dev, VFS_REG_IMG_CONTRAST, self->contrast, 0x01);
break;
case M_INIT_4_GET_PRINT:
/* Get empty image */
vfs_get_print (ssm, dev, 0x000a, 0);
break;
case M_INIT_4_LOAD_IMAGE:
/* Load empty image */
vfs_img_load (ssm, dev);
break;
case M_INIT_4_CHECK_CONTRAST:
/* Check contrast */
vfs_check_contrast (self);
if (self->contrast <= 6 || self->counter >= 12)
{
/* End contrast scan, continue */
self->contrast = self->best_contrast;
self->counter = 0;
fp_dbg ("use contrast value = %d", self->contrast);
fpi_ssm_next_state (ssm);
}
else
{
/* Continue contrast scan, loop */
self->contrast--;
self->counter++;
fpi_ssm_jump_to_state (ssm, M_INIT_4_SET_CONTRAST);
}
break;
case M_INIT_5_SET_EXPOSURE:
/* Set exposure level of reader */
vfs_poke (ssm, dev, VFS_REG_IMG_EXPOSURE, VFS_VAL_IMG_EXPOSURE, 0x02);
break;
case M_INIT_5_SET_CONTRAST:
/* Set contrast level of reader */
vfs_poke (ssm, dev, VFS_REG_IMG_CONTRAST, self->contrast, 0x01);
break;
case M_INIT_5_SET_INFO_CONTRAST:
/* Set info line contrast */
vfs_set_param (ssm, dev, VFS_PAR_INFO_CONTRAST, self->contrast);
break;
case M_INIT_5_SET_INFO_RATE:
/* Set info line rate */
vfs_set_param (ssm, dev, VFS_PAR_INFO_RATE, VFS_VAL_INFO_RATE);
break;
}
}
/* Complete init sequential state machine */
static void
m_init_complete (FpiSsm *ssm, FpDevice *_dev, void *user_data,
GError *error)
{
FpImageDevice *dev = user_data;
/* Notify activate complete */
fpi_image_device_activate_complete (dev, error);
if (!error)
{
FpiSsm *ssm_loop;
/* Start loop ssm */
ssm_loop = fpi_ssm_new (FP_DEVICE (dev), m_loop_state,
M_LOOP_NUM_STATES, dev);
fpi_ssm_start (ssm_loop, m_loop_complete);
}
/* Free sequential state machine */
fpi_ssm_free (ssm);
}
/* Activate device */
static void
dev_activate (FpImageDevice *dev)
{
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev);
FpiSsm *ssm;
/* Check if already active */
g_assert (!self->active);
/* Set active state */
self->active = TRUE;
self->deactivate = FALSE;
/* Set contrast */
self->contrast = 15;
self->best_clevel = -1;
/* Reset loop counter */
self->counter = 0;
/* Start init ssm */
ssm = fpi_ssm_new (FP_DEVICE (dev), m_init_state, M_INIT_NUM_STATES, dev);
fpi_ssm_start (ssm, m_init_complete);
}
/* Deactivate device */
static void
dev_deactivate (FpImageDevice *dev)
{
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev);
/* Device already deactivated, likely due to an error */
if (!self->active)
{
fpi_image_device_deactivate_complete (dev, NULL);
return;
}
/* Signal deactivation, deactivation will happen from the SSM
* completion handler. */
self->deactivate = TRUE;
}
/* Open device */
static void
dev_open (FpImageDevice *dev)
{
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev);
GError *error = NULL;
/* Claim usb interface */
g_usb_device_claim_interface (fpi_device_get_usb_device (FP_DEVICE (dev)), 0, 0, &error);
/* Initialize private structure */
self->seqnum = -1;
self->buffer = g_malloc0 (VFS_BUFFER_SIZE);
/* Notify open complete */
fpi_image_device_open_complete (dev, error);
}
/* Close device */
static void
dev_close (FpImageDevice *dev)
{
FpDeviceVfs101 *self = FPI_DEVICE_VFS101 (dev);
GError *error = NULL;
/* Release usb interface */
g_usb_device_release_interface (fpi_device_get_usb_device (FP_DEVICE (dev)),
0, 0, &error);
g_clear_pointer (&self->buffer, g_free);
/* Notify close complete */
fpi_image_device_close_complete (dev, error);
}
/* Usb id table of device */
static const FpIdEntry id_table[] = {
{ .vid = 0x138a, .pid = 0x0001, },
{ .vid = 0, .pid = 0, .driver_data = 0 },
};
static void
fpi_device_vfs101_init (FpDeviceVfs101 *self)
{
}
static void
fpi_device_vfs101_class_init (FpDeviceVfs101Class *klass)
{
FpDeviceClass *dev_class = FP_DEVICE_CLASS (klass);
FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS (klass);
dev_class->id = "vfs101";
dev_class->full_name = "Validity VFS101";
dev_class->type = FP_DEVICE_TYPE_USB;
dev_class->id_table = id_table;
dev_class->scan_type = FP_SCAN_TYPE_SWIPE;
img_class->img_open = dev_open;
img_class->img_close = dev_close;
img_class->activate = dev_activate;
img_class->deactivate = dev_deactivate;
img_class->bz3_threshold = 24;
img_class->img_width = VFS_IMG_WIDTH;
img_class->img_height = -1;
}
Reference in a new issue View git blame Copy permalink