depau/libfprint
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
libfprint/libfprint/drivers/aes2501.c
Benjamin Berg 441b1238a5 aes2501: Port aes2501 to new API
2019-11-20 13:53:45 +01:00

824 lines
24 KiB
C
Raw Blame History

/*
* AuthenTec AES2501 driver for libfprint
* Copyright (C) 2007-2008 Daniel Drake <dsd@gentoo.org>
* Copyright (C) 2007 Cyrille Bagard
* Copyright (C) 2007-2008, 2012 Vasily Khoruzhick <anarsoul@gmail.com>
*
* Based on code from http://home.gna.org/aes2501, relicensed with permission
*
* 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 "aes2501"
#include "drivers_api.h"
#include "aeslib.h"
#include "aes2501.h"
static void start_capture(FpImageDevice *dev);
static void complete_deactivation(FpImageDevice *dev);
/* FIXME these need checking */
#define EP_IN (1 | FPI_USB_ENDPOINT_IN)
#define EP_OUT (2 | FPI_USB_ENDPOINT_OUT)
#define BULK_TIMEOUT 4000
#define FINGER_DETECTION_LEN 20
#define READ_REGS_LEN 126
#define READ_REGS_RESP_LEN 159
#define STRIP_CAPTURE_LEN 1705
/*
* The AES2501 is an imaging device using a swipe-type sensor. It samples
* the finger at preprogrammed intervals, sending a 192x16 frame to the
* computer.
* Unless the user is scanning their finger unreasonably fast, the frames
* *will* overlap. The implementation below detects this overlap and produces
* a contiguous image as the end result.
* The fact that the user determines the length of the swipe (and hence the
* number of useful frames) and also the fact that overlap varies means that
* images returned from this driver vary in height.
*/
#define FRAME_WIDTH 192
#define FRAME_HEIGHT 16
#define FRAME_SIZE (FRAME_WIDTH * FRAME_HEIGHT)
#define IMAGE_WIDTH (FRAME_WIDTH + (FRAME_WIDTH / 2))
/* maximum number of frames to read during a scan */
/* FIXME reduce substantially */
#define MAX_FRAMES 150
/****** GENERAL FUNCTIONS ******/
struct _FpiDeviceAes2501 {
FpImageDevice parent;
guint8 read_regs_retry_count;
GSList *strips;
size_t strips_len;
gboolean deactivating;
int no_finger_cnt;
};
G_DECLARE_FINAL_TYPE(FpiDeviceAes2501, fpi_device_aes2501, FPI, DEVICE_AES2501,
FpImageDevice);
G_DEFINE_TYPE(FpiDeviceAes2501, fpi_device_aes2501, FP_TYPE_IMAGE_DEVICE);
static struct fpi_frame_asmbl_ctx assembling_ctx = {
.frame_width = FRAME_WIDTH,
.frame_height = FRAME_HEIGHT,
.image_width = IMAGE_WIDTH,
.get_pixel = aes_get_pixel,
};
typedef void (*aes2501_read_regs_cb)(FpImageDevice *dev, GError *error,
unsigned char *regs, void *user_data);
struct aes2501_read_regs {
FpImageDevice *dev;
aes2501_read_regs_cb callback;
struct aes_regwrite *regwrite;
void *user_data;
};
static void read_regs_data_cb(FpiUsbTransfer *transfer, FpDevice *dev,
gpointer user_data, GError *error)
{
struct aes2501_read_regs *rdata = user_data;
rdata->callback(rdata->dev, error, transfer->buffer, rdata->user_data);
g_free(rdata);
}
static void read_regs_rq_cb(FpImageDevice *dev, GError *error, void *user_data)
{
struct aes2501_read_regs *rdata = user_data;
FpiUsbTransfer *transfer;
g_free(rdata->regwrite);
if (error) {
rdata->callback(dev, error, NULL, rdata->user_data);
g_free (rdata);
return;
}
transfer = fpi_usb_transfer_new(FP_DEVICE(dev));
transfer->short_is_error = TRUE;
fpi_usb_transfer_fill_bulk(transfer, EP_IN, READ_REGS_LEN);
fpi_usb_transfer_submit(transfer, BULK_TIMEOUT, NULL,
read_regs_data_cb, rdata);
fpi_usb_transfer_unref(transfer);
}
static void read_regs(FpImageDevice *dev, aes2501_read_regs_cb callback,
void *user_data)
{
/* FIXME: regwrite is dynamic because of asynchronity. is this really
* required? */
struct aes_regwrite *regwrite = g_malloc(sizeof(*regwrite));
struct aes2501_read_regs *rdata = g_malloc(sizeof(*rdata));
G_DEBUG_HERE();
regwrite->reg = AES2501_REG_CTRL2;
regwrite->value = AES2501_CTRL2_READ_REGS;
rdata->dev = dev;
rdata->callback = callback;
rdata->user_data = user_data;
rdata->regwrite = regwrite;
aes_write_regv(dev, (const struct aes_regwrite *) regwrite, 1,
read_regs_rq_cb, rdata);
}
/* Read the value of a specific register from a register dump */
static int regval_from_dump(unsigned char *data, guint8 target)
{
if (*data != FIRST_AES2501_REG) {
fp_err("not a register dump");
return -1;
}
if (!(FIRST_AES2501_REG <= target && target <= LAST_AES2501_REG)) {
fp_err("out of range");
return -1;
}
target -= FIRST_AES2501_REG;
target *= 2;
return data[target + 1];
}
static void generic_write_regv_cb(FpImageDevice *dev, GError *error,
void *user_data)
{
FpiSsm *ssm = user_data;
if (!error)
fpi_ssm_next_state(ssm);
else
fpi_ssm_mark_failed(ssm, error);
}
/* check that read succeeded but ignore all data */
static void generic_ignore_data_cb(FpiUsbTransfer *transfer, FpDevice *dev,
gpointer user_data, GError *error)
{
FpiSsm *ssm = transfer->ssm;
if (error)
fpi_ssm_mark_failed(ssm, error);
else
fpi_ssm_next_state(ssm);
}
/* read the specified number of bytes from the IN endpoint but throw them
* away, then increment the SSM */
static void generic_read_ignore_data(FpiSsm *ssm, FpDevice *dev,
size_t bytes)
{
FpiUsbTransfer *transfer;
transfer = fpi_usb_transfer_new(dev);
transfer->ssm = ssm;
transfer->short_is_error = TRUE;
fpi_usb_transfer_fill_bulk(transfer, EP_IN, bytes);
fpi_usb_transfer_submit(transfer, BULK_TIMEOUT, NULL,
generic_ignore_data_cb, NULL);
fpi_usb_transfer_unref(transfer);
}
/****** IMAGE PROCESSING ******/
static int sum_histogram_values(unsigned char *data, guint8 threshold)
{
int r = 0;
int i;
guint16 *histogram = (guint16 *)(data + 1);
if (*data != 0xde)
return -1;
if (threshold > 0x0f)
return -1;
/* FIXME endianness */
for (i = threshold; i < 16; i++)
r += histogram[i];
return r;
}
/****** FINGER PRESENCE DETECTION ******/
static const struct aes_regwrite finger_det_reqs[] = {
{ AES2501_REG_CTRL1, AES2501_CTRL1_MASTER_RESET },
{ AES2501_REG_EXCITCTRL, 0x40 },
{ AES2501_REG_DETCTRL,
AES2501_DETCTRL_DRATE_CONTINUOUS | AES2501_DETCTRL_SDELAY_31_MS },
{ AES2501_REG_COLSCAN, AES2501_COLSCAN_SRATE_128_US },
{ AES2501_REG_MEASDRV, AES2501_MEASDRV_MDRIVE_0_325 | AES2501_MEASDRV_MEASURE_SQUARE },
{ AES2501_REG_MEASFREQ, AES2501_MEASFREQ_2M },
{ AES2501_REG_DEMODPHASE1, DEMODPHASE_NONE },
{ AES2501_REG_DEMODPHASE2, DEMODPHASE_NONE },
{ AES2501_REG_CHANGAIN,
AES2501_CHANGAIN_STAGE2_4X | AES2501_CHANGAIN_STAGE1_16X },
{ AES2501_REG_ADREFHI, 0x44 },
{ AES2501_REG_ADREFLO, 0x34 },
{ AES2501_REG_STRTCOL, 0x16 },
{ AES2501_REG_ENDCOL, 0x16 },
{ AES2501_REG_DATFMT, AES2501_DATFMT_BIN_IMG | 0x08 },
{ AES2501_REG_TREG1, 0x70 },
{ 0xa2, 0x02 },
{ 0xa7, 0x00 },
{ AES2501_REG_TREGC, AES2501_TREGC_ENABLE },
{ AES2501_REG_TREGD, 0x1a },
{ 0, 0 },
{ AES2501_REG_CTRL1, AES2501_CTRL1_REG_UPDATE },
{ AES2501_REG_CTRL2, AES2501_CTRL2_SET_ONE_SHOT },
{ AES2501_REG_LPONT, AES2501_LPONT_MIN_VALUE },
};
static void start_finger_detection(FpImageDevice *dev);
static void finger_det_data_cb(FpiUsbTransfer *transfer, FpDevice *_dev,
gpointer user_data, GError *error)
{
FpImageDevice *dev = FP_IMAGE_DEVICE(_dev);
unsigned char *data = transfer->buffer;
int i;
int sum = 0;
if (error) {
fpi_image_device_session_error(dev, error);
return;
}
/* examine histogram to determine finger presence */
for (i = 1; i < 9; i++)
sum += (data[i] & 0xf) + (data[i] >> 4);
if (sum > 20) {
/* finger present, start capturing */
fpi_image_device_report_finger_status(dev, TRUE);
start_capture(dev);
} else {
/* no finger, poll for a new histogram */
start_finger_detection(dev);
}
}
static void finger_det_reqs_cb(FpImageDevice *dev, GError *error,
void *user_data)
{
FpiUsbTransfer *transfer;
if (error) {
fpi_image_device_session_error (dev, error);
return;
}
transfer = fpi_usb_transfer_new(FP_DEVICE(dev));
transfer->short_is_error = TRUE;
fpi_usb_transfer_fill_bulk(transfer, EP_IN, FINGER_DETECTION_LEN);
fpi_usb_transfer_submit(transfer, BULK_TIMEOUT, NULL,
finger_det_data_cb, NULL);
fpi_usb_transfer_unref(transfer);
}
static void start_finger_detection(FpImageDevice *dev)
{
FpiDeviceAes2501 *self = FPI_DEVICE_AES2501(dev);
G_DEBUG_HERE();
if (self->deactivating) {
complete_deactivation(dev);
return;
}
aes_write_regv(dev, finger_det_reqs, G_N_ELEMENTS(finger_det_reqs),
finger_det_reqs_cb, NULL);
}
/****** CAPTURE ******/
static const struct aes_regwrite capture_reqs_1[] = {
{ AES2501_REG_CTRL1, AES2501_CTRL1_MASTER_RESET },
{ 0, 0 },
{ AES2501_REG_EXCITCTRL, 0x40 },
{ AES2501_REG_DETCTRL,
AES2501_DETCTRL_SDELAY_31_MS | AES2501_DETCTRL_DRATE_CONTINUOUS },
{ AES2501_REG_COLSCAN, AES2501_COLSCAN_SRATE_128_US },
{ AES2501_REG_DEMODPHASE2, 0x7c },
{ AES2501_REG_MEASDRV,
AES2501_MEASDRV_MEASURE_SQUARE | AES2501_MEASDRV_MDRIVE_0_325 },
{ AES2501_REG_DEMODPHASE1, 0x24 },
{ AES2501_REG_CHWORD1, 0x00 },
{ AES2501_REG_CHWORD2, 0x6c },
{ AES2501_REG_CHWORD3, 0x09 },
{ AES2501_REG_CHWORD4, 0x54 },
{ AES2501_REG_CHWORD5, 0x78 },
{ 0xa2, 0x02 },
{ 0xa7, 0x00 },
{ 0xb6, 0x26 },
{ 0xb7, 0x1a },
{ AES2501_REG_CTRL1, AES2501_CTRL1_REG_UPDATE },
{ AES2501_REG_IMAGCTRL,
AES2501_IMAGCTRL_TST_REG_ENABLE | AES2501_IMAGCTRL_HISTO_DATA_ENABLE |
AES2501_IMAGCTRL_IMG_DATA_DISABLE },
{ AES2501_REG_STRTCOL, 0x10 },
{ AES2501_REG_ENDCOL, 0x1f },
{ AES2501_REG_CHANGAIN,
AES2501_CHANGAIN_STAGE1_2X | AES2501_CHANGAIN_STAGE2_2X },
{ AES2501_REG_ADREFHI, 0x70 },
{ AES2501_REG_ADREFLO, 0x20 },
{ AES2501_REG_CTRL2, AES2501_CTRL2_SET_ONE_SHOT },
{ AES2501_REG_LPONT, AES2501_LPONT_MIN_VALUE },
};
static const struct aes_regwrite capture_reqs_2[] = {
{ AES2501_REG_IMAGCTRL,
AES2501_IMAGCTRL_TST_REG_ENABLE | AES2501_IMAGCTRL_HISTO_DATA_ENABLE |
AES2501_IMAGCTRL_IMG_DATA_DISABLE },
{ AES2501_REG_STRTCOL, 0x10 },
{ AES2501_REG_ENDCOL, 0x1f },
{ AES2501_REG_CHANGAIN, AES2501_CHANGAIN_STAGE1_16X },
{ AES2501_REG_ADREFHI, 0x70 },
{ AES2501_REG_ADREFLO, 0x20 },
{ AES2501_REG_CTRL2, AES2501_CTRL2_SET_ONE_SHOT },
};
static struct aes_regwrite strip_scan_reqs[] = {
{ AES2501_REG_IMAGCTRL,
AES2501_IMAGCTRL_TST_REG_ENABLE | AES2501_IMAGCTRL_HISTO_DATA_ENABLE },
{ AES2501_REG_STRTCOL, 0x00 },
{ AES2501_REG_ENDCOL, 0x2f },
{ AES2501_REG_CHANGAIN, AES2501_CHANGAIN_STAGE1_16X },
{ AES2501_REG_ADREFHI, AES2501_ADREFHI_MAX_VALUE },
{ AES2501_REG_ADREFLO, 0x20 },
{ AES2501_REG_CTRL2, AES2501_CTRL2_SET_ONE_SHOT },
};
/* capture SM movement:
* write reqs and read data 1 + 2,
* request and read strip,
* jump back to request UNLESS there's no finger, in which case exit SM,
* report lack of finger presence, and move to finger detection */
enum capture_states {
CAPTURE_WRITE_REQS_1,
CAPTURE_READ_DATA_1,
CAPTURE_WRITE_REQS_2,
CAPTURE_READ_DATA_2,
CAPTURE_REQUEST_STRIP,
CAPTURE_READ_STRIP,
CAPTURE_NUM_STATES,
};
static void capture_read_strip_cb(FpiUsbTransfer *transfer, FpDevice *_dev,
gpointer user_data, GError *error)
{
FpiSsm *ssm = transfer->ssm;
unsigned char *stripdata;
FpImageDevice *dev = FP_IMAGE_DEVICE(_dev);
FpiDeviceAes2501 *self = FPI_DEVICE_AES2501(_dev);
unsigned char *data = transfer->buffer;
int sum;
int threshold;
if (error) {
fpi_ssm_mark_failed(ssm, error);
return;
}
threshold = regval_from_dump(data + 1 + 192*8 + 1 + 16*2 + 1 + 8,
AES2501_REG_DATFMT);
if (threshold < 0) {
fpi_ssm_mark_failed(ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
return;
}
sum = sum_histogram_values(data + 1 + 192*8, threshold & 0x0f);
if (sum < 0) {
fpi_ssm_mark_failed(ssm,
fpi_device_error_new (FP_DEVICE_ERROR_PROTO));
return;
}
fp_dbg("sum=%d", sum);
if (sum < AES2501_SUM_LOW_THRESH) {
strip_scan_reqs[4].value -= 0x8;
if (strip_scan_reqs[4].value < AES2501_ADREFHI_MIN_VALUE)
strip_scan_reqs[4].value = AES2501_ADREFHI_MIN_VALUE;
} else if (sum > AES2501_SUM_HIGH_THRESH) {
strip_scan_reqs[4].value += 0x8;
if (strip_scan_reqs[4].value > AES2501_ADREFHI_MAX_VALUE)
strip_scan_reqs[4].value = AES2501_ADREFHI_MAX_VALUE;
}
fp_dbg("ADREFHI is %.2x", strip_scan_reqs[4].value);
/* Sum is 0, maybe finger was removed? Wait for 3 empty frames
* to ensure
*/
if (sum == 0) {
self->no_finger_cnt++;
if (self->no_finger_cnt == 3) {
FpImage *img;
self->strips = g_slist_reverse(self->strips);
fpi_do_movement_estimation(&assembling_ctx,
self->strips, self->strips_len);
img = fpi_assemble_frames(&assembling_ctx,
self->strips,
self->strips_len);
g_slist_free_full(self->strips, g_free);
self->strips = NULL;
self->strips_len = 0;
fpi_image_device_image_captured(dev, img);
fpi_image_device_report_finger_status(dev, FALSE);
/* marking machine complete will re-trigger finger detection loop */
fpi_ssm_mark_completed(ssm);
} else {
fpi_ssm_jump_to_state(ssm, CAPTURE_REQUEST_STRIP);
}
} else {
/* obtain next strip */
/* FIXME: would preallocating strip buffers be a decent optimization? */
struct fpi_frame *stripe = g_malloc(FRAME_WIDTH * FRAME_HEIGHT / 2 + sizeof(struct fpi_frame));
stripe->delta_x = 0;
stripe->delta_y = 0;
stripdata = stripe->data;
memcpy(stripdata, data + 1, 192*8);
self->no_finger_cnt = 0;
self->strips = g_slist_prepend(self->strips, stripe);
self->strips_len++;
fpi_ssm_jump_to_state(ssm, CAPTURE_REQUEST_STRIP);
}
}
static void capture_run_state(FpiSsm *ssm, FpDevice *device, void *user_data)
{
FpImageDevice *dev = user_data;
FpiDeviceAes2501 *self = FPI_DEVICE_AES2501(device);
switch (fpi_ssm_get_cur_state(ssm)) {
case CAPTURE_WRITE_REQS_1:
aes_write_regv(dev, capture_reqs_1, G_N_ELEMENTS(capture_reqs_1),
generic_write_regv_cb, ssm);
break;
case CAPTURE_READ_DATA_1:
generic_read_ignore_data(ssm, device, READ_REGS_RESP_LEN);
break;
case CAPTURE_WRITE_REQS_2:
aes_write_regv(dev, capture_reqs_2, G_N_ELEMENTS(capture_reqs_2),
generic_write_regv_cb, ssm);
break;
case CAPTURE_READ_DATA_2:
generic_read_ignore_data(ssm, device, READ_REGS_RESP_LEN);
break;
case CAPTURE_REQUEST_STRIP:
if (self->deactivating)
fpi_ssm_mark_completed(ssm);
else
aes_write_regv(dev, strip_scan_reqs, G_N_ELEMENTS(strip_scan_reqs),
generic_write_regv_cb, ssm);
break;
case CAPTURE_READ_STRIP: {
FpiUsbTransfer *transfer;
transfer = fpi_usb_transfer_new(device);
transfer->ssm = ssm;
transfer->short_is_error = TRUE;
fpi_usb_transfer_fill_bulk(transfer, EP_IN, STRIP_CAPTURE_LEN);
fpi_usb_transfer_submit(transfer, BULK_TIMEOUT, NULL,
capture_read_strip_cb, NULL);
fpi_usb_transfer_unref(transfer);
break;
}
};
}
static void capture_sm_complete(FpiSsm *ssm, FpDevice *_dev, void *user_data,
GError *error)
{
FpImageDevice *dev = user_data;
FpiDeviceAes2501 *self = FPI_DEVICE_AES2501(_dev);
G_DEBUG_HERE();
if (self->deactivating) {
complete_deactivation(dev);
g_clear_pointer (&error, g_error_free);
} else if (error) {
fpi_image_device_session_error(dev, error);
} else {
start_finger_detection(dev);
}
fpi_ssm_free(ssm);
}
static void start_capture(FpImageDevice *dev)
{
FpiDeviceAes2501 *self = FPI_DEVICE_AES2501(dev);
FpiSsm *ssm;
if (self->deactivating) {
complete_deactivation(dev);
return;
}
self->no_finger_cnt = 0;
/* Reset gain */
strip_scan_reqs[4].value = AES2501_ADREFHI_MAX_VALUE;
ssm = fpi_ssm_new(FP_DEVICE(dev), capture_run_state,
CAPTURE_NUM_STATES, dev);
G_DEBUG_HERE();
fpi_ssm_start(ssm, capture_sm_complete);
}
/****** INITIALIZATION/DEINITIALIZATION ******/
static const struct aes_regwrite init_1[] = {
{ AES2501_REG_CTRL1, AES2501_CTRL1_MASTER_RESET },
{ 0, 0 },
{ 0xb0, 0x27 }, /* Reserved? */
{ AES2501_REG_CTRL1, AES2501_CTRL1_MASTER_RESET },
{ AES2501_REG_EXCITCTRL, 0x40 },
{ 0xff, 0x00 }, /* Reserved? */
{ 0xff, 0x00 }, /* Reserved? */
{ 0xff, 0x00 }, /* Reserved? */
{ 0xff, 0x00 }, /* Reserved? */
{ 0xff, 0x00 }, /* Reserved? */
{ 0xff, 0x00 }, /* Reserved? */
{ 0xff, 0x00 }, /* Reserved? */
{ 0xff, 0x00 }, /* Reserved? */
{ 0xff, 0x00 }, /* Reserved? */
{ 0xff, 0x00 }, /* Reserved? */
{ 0xff, 0x00 }, /* Reserved? */
{ AES2501_REG_CTRL1, AES2501_CTRL1_MASTER_RESET },
{ AES2501_REG_EXCITCTRL, 0x40 },
{ AES2501_REG_DETCTRL,
AES2501_DETCTRL_DRATE_CONTINUOUS | AES2501_DETCTRL_SDELAY_31_MS },
{ AES2501_REG_COLSCAN, AES2501_COLSCAN_SRATE_128_US },
{ AES2501_REG_MEASDRV,
AES2501_MEASDRV_MDRIVE_0_325 | AES2501_MEASDRV_MEASURE_SQUARE },
{ AES2501_REG_MEASFREQ, AES2501_MEASFREQ_2M },
{ AES2501_REG_DEMODPHASE1, DEMODPHASE_NONE },
{ AES2501_REG_DEMODPHASE2, DEMODPHASE_NONE },
{ AES2501_REG_CHANGAIN,
AES2501_CHANGAIN_STAGE2_4X | AES2501_CHANGAIN_STAGE1_16X },
{ AES2501_REG_ADREFHI, 0x44 },
{ AES2501_REG_ADREFLO, 0x34 },
{ AES2501_REG_STRTCOL, 0x16 },
{ AES2501_REG_ENDCOL, 0x16 },
{ AES2501_REG_DATFMT, AES2501_DATFMT_BIN_IMG | 0x08 },
{ AES2501_REG_TREG1, 0x70 },
{ 0xa2, 0x02 },
{ 0xa7, 0x00 },
{ AES2501_REG_TREGC, AES2501_TREGC_ENABLE },
{ AES2501_REG_TREGD, 0x1a },
{ AES2501_REG_CTRL1, AES2501_CTRL1_REG_UPDATE },
{ AES2501_REG_CTRL2, AES2501_CTRL2_SET_ONE_SHOT },
{ AES2501_REG_LPONT, AES2501_LPONT_MIN_VALUE },
};
static const struct aes_regwrite init_2[] = {
{ AES2501_REG_CTRL1, AES2501_CTRL1_MASTER_RESET },
{ AES2501_REG_EXCITCTRL, 0x40 },
{ AES2501_REG_CTRL1, AES2501_CTRL1_MASTER_RESET },
{ AES2501_REG_AUTOCALOFFSET, 0x41 },
{ AES2501_REG_EXCITCTRL, 0x42 },
{ AES2501_REG_DETCTRL, 0x53 },
{ AES2501_REG_CTRL1, AES2501_CTRL1_REG_UPDATE },
};
static const struct aes_regwrite init_3[] = {
{ 0xff, 0x00 },
{ AES2501_REG_CTRL1, AES2501_CTRL1_MASTER_RESET },
{ AES2501_REG_AUTOCALOFFSET, 0x41 },
{ AES2501_REG_EXCITCTRL, 0x42 },
{ AES2501_REG_DETCTRL, 0x53 },
{ AES2501_REG_CTRL1, AES2501_CTRL1_REG_UPDATE },
};
static const struct aes_regwrite init_4[] = {
{ AES2501_REG_CTRL1, AES2501_CTRL1_MASTER_RESET },
{ AES2501_REG_EXCITCTRL, 0x40 },
{ 0xb0, 0x27 },
{ AES2501_REG_ENDROW, 0x0a },
{ AES2501_REG_CTRL1, AES2501_CTRL1_REG_UPDATE },
{ AES2501_REG_DETCTRL, 0x45 },
{ AES2501_REG_AUTOCALOFFSET, 0x41 },
};
static const struct aes_regwrite init_5[] = {
{ 0xb0, 0x27 },
{ AES2501_REG_CTRL1, AES2501_CTRL1_MASTER_RESET },
{ AES2501_REG_EXCITCTRL, 0x40 },
{ 0xff, 0x00 },
{ AES2501_REG_CTRL1, AES2501_CTRL1_MASTER_RESET },
{ AES2501_REG_EXCITCTRL, 0x40 },
{ AES2501_REG_CTRL1, AES2501_CTRL1_MASTER_RESET },
{ AES2501_REG_EXCITCTRL, 0x40 },
{ AES2501_REG_CTRL1, AES2501_CTRL1_MASTER_RESET },
{ AES2501_REG_EXCITCTRL, 0x40 },
{ AES2501_REG_CTRL1, AES2501_CTRL1_MASTER_RESET },
{ AES2501_REG_EXCITCTRL, 0x40 },
{ AES2501_REG_CTRL1, AES2501_CTRL1_MASTER_RESET },
{ AES2501_REG_EXCITCTRL, 0x40 },
{ AES2501_REG_CTRL1, AES2501_CTRL1_SCAN_RESET },
{ AES2501_REG_CTRL1, AES2501_CTRL1_SCAN_RESET },
};
enum activate_states {
WRITE_INIT_1,
READ_DATA_1,
WRITE_INIT_2,
READ_REGS,
WRITE_INIT_3,
WRITE_INIT_4,
WRITE_INIT_5,
ACTIVATE_NUM_STATES,
};
void activate_read_regs_cb(FpImageDevice *dev, GError *error,
unsigned char *regs, void *user_data)
{
FpiSsm *ssm = user_data;
FpiDeviceAes2501 *self = FPI_DEVICE_AES2501(dev);
if (error) {
fpi_ssm_mark_failed(ssm, error);
} else {
fp_dbg("reg 0xaf = %x", regs[0x5f]);
if (regs[0x5f] != 0x6b || ++self->read_regs_retry_count == 13)
fpi_ssm_jump_to_state(ssm, WRITE_INIT_4);
else
fpi_ssm_next_state(ssm);
}
}
static void activate_init3_cb(FpImageDevice *dev, GError *error,
void *user_data)
{
FpiSsm *ssm = user_data;
if (!error)
fpi_ssm_jump_to_state(ssm, READ_REGS);
else
fpi_ssm_mark_failed(ssm, error);
}
static void activate_run_state(FpiSsm *ssm, FpDevice *_dev, void *user_data)
{
FpImageDevice *dev = user_data;
/* 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
* waiting for a specific value. READ_REGS checks the register value, and
* if we're ready to move on, we jump to init4. Otherwise, we write init3
* and then jump back to READ_REGS. In a synchronous model:
[...]
aes_write_regv(init_2);
read_regs(into buffer);
i = 0;
while (buffer[0x5f] == 0x6b) {
aes_write_regv(init_3);
read_regs(into buffer);
if (++i == 13)
break;
}
aes_write_regv(init_4);
*/
switch (fpi_ssm_get_cur_state(ssm)) {
case WRITE_INIT_1:
aes_write_regv(dev, init_1, G_N_ELEMENTS(init_1),
generic_write_regv_cb, ssm);
break;
case READ_DATA_1:
fp_dbg("read data 1");
generic_read_ignore_data(ssm, _dev, FINGER_DETECTION_LEN);
break;
case WRITE_INIT_2:
aes_write_regv(dev, init_2, G_N_ELEMENTS(init_2),
generic_write_regv_cb, ssm);
break;
case READ_REGS:
read_regs(dev, activate_read_regs_cb, ssm);
break;
case WRITE_INIT_3:
aes_write_regv(dev, init_3, G_N_ELEMENTS(init_3),
activate_init3_cb, ssm);
break;
case WRITE_INIT_4:
aes_write_regv(dev, init_4, G_N_ELEMENTS(init_4),
generic_write_regv_cb, ssm);
break;
case WRITE_INIT_5:
aes_write_regv(dev, init_5, G_N_ELEMENTS(init_5),
generic_write_regv_cb, ssm);
break;
}
}
static void activate_sm_complete(FpiSsm *ssm, FpDevice *dev,
void *user_data, GError *error)
{
fpi_image_device_activate_complete(FP_IMAGE_DEVICE (dev), error);
if (!error)
start_finger_detection(FP_IMAGE_DEVICE (dev));
fpi_ssm_free(ssm);
}
static void dev_activate(FpImageDevice *dev)
{
FpiDeviceAes2501 *self = FPI_DEVICE_AES2501(dev);
FpiSsm *ssm = fpi_ssm_new(FP_DEVICE(dev), activate_run_state,
ACTIVATE_NUM_STATES, dev);
self->read_regs_retry_count = 0;
fpi_ssm_start(ssm, activate_sm_complete);
}
static void dev_deactivate(FpImageDevice *dev)
{
FpiDeviceAes2501 *self = FPI_DEVICE_AES2501(dev);
/* FIXME: audit cancellation points, probably need more, specifically
* in error handling paths? */
self->deactivating = TRUE;
}
static void complete_deactivation(FpImageDevice *dev)
{
FpiDeviceAes2501 *self = FPI_DEVICE_AES2501(dev);
G_DEBUG_HERE();
/* FIXME: if we're in the middle of a scan, we should cancel the scan.
* maybe we can do this with a master reset, unconditionally? */
self->deactivating = FALSE;
g_slist_free(self->strips);
self->strips = NULL;
self->strips_len = 0;
fpi_image_device_deactivate_complete(dev, NULL);
}
static void dev_init(FpImageDevice *dev)
{
GError *error = NULL;
/* FIXME check endpoints */
g_usb_device_claim_interface(fpi_device_get_usb_device(FP_DEVICE(dev)), 0, 0, &error);
fpi_image_device_open_complete(dev, error);
}
static void dev_deinit(FpImageDevice *dev)
{
GError *error = NULL;
g_usb_device_release_interface(fpi_device_get_usb_device(FP_DEVICE(dev)),
0, 0, &error);
fpi_image_device_close_complete(dev, error);
}
static const FpIdEntry id_table [ ] = {
{ .vid = 0x08ff, .pid = 0x2500,
}, /* AES2500 */
{ .vid = 0x08ff, .pid = 0x2580,
}, /* AES2501 */
{ .vid = 0, .pid = 0, .driver_data = 0 },
};
static void fpi_device_aes2501_init(FpiDeviceAes2501 *self) {
}
static void fpi_device_aes2501_class_init(FpiDeviceAes2501Class *klass) {
FpDeviceClass *dev_class = FP_DEVICE_CLASS(klass);
FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS(klass);
dev_class->id = "aes2501";
dev_class->full_name = "AuthenTec AES2501";
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_init;
img_class->img_close = dev_deinit;
img_class->activate = dev_activate;
img_class->deactivate = dev_deactivate;
img_class->img_width = IMAGE_WIDTH;
img_class->img_height = -1;
}
Reference in a new issue View git blame Copy permalink