libfprint/libfprint/drivers/upektc.c

/*
 * UPEK TouchChip driver for libfprint
 * Copyright (C) 2007 Jan-Michael Brummer <buzz2@gmx.de>
 * Copyright (C) 2012 Vasily Khoruzhick <anarsoul@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 "upektc"

#include "drivers_api.h"
#include "upektc.h"

#define UPEKTC_EP_IN (2 | FPI_USB_ENDPOINT_IN)
#define UPEKTC_EP_OUT (3 | FPI_USB_ENDPOINT_OUT)
#define UPEKET_EP_IN (1 | FPI_USB_ENDPOINT_IN)
#define UPEKET_EP_OUT (2 | FPI_USB_ENDPOINT_OUT)
#define BULK_TIMEOUT 4000

struct _FpiDeviceUpektc {
	FpImageDevice parent;

	gboolean deactivating;
	const struct setup_cmd *setup_commands;
	size_t setup_commands_len;
	int ep_in;
	int ep_out;
	int init_idx;
	int sum_threshold;
};
G_DECLARE_FINAL_TYPE(FpiDeviceUpektc, fpi_device_upektc, FPI, DEVICE_UPEKTC,
		     FpImageDevice);
G_DEFINE_TYPE(FpiDeviceUpektc, fpi_device_upektc, FP_TYPE_IMAGE_DEVICE);

enum upektc_driver_data {
	UPEKTC_2015,
	UPEKTC_3001,
};

static void start_capture(FpImageDevice *dev);
static void complete_deactivation(FpImageDevice *dev, GError *error);
static void start_finger_detection(FpImageDevice *dev);

/****** INITIALIZATION/DEINITIALIZATION ******/

enum activate_states {
	WRITE_INIT,
	READ_DATA,
	ACTIVATE_NUM_STATES,
};

static void
upektc_next_init_cmd(FpiSsm           *ssm,
		     FpImageDevice *dev)
{
	FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC(dev);

	self->init_idx += 1;
	if (self->init_idx == self->setup_commands_len)
		fpi_ssm_mark_completed(ssm);
	else
		fpi_ssm_jump_to_state(ssm, WRITE_INIT);
}

static void write_init_cb(FpiUsbTransfer *transfer, FpDevice *device,
			  gpointer user_data, GError *error)
{
	FpImageDevice *dev = FP_IMAGE_DEVICE(device);
	FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC(dev);

	if (!error) {
		if (self->setup_commands[self->init_idx].response_len)
			fpi_ssm_next_state(transfer->ssm);
		else
			upektc_next_init_cmd(transfer->ssm, dev);
	} else {
		fpi_ssm_mark_failed(transfer->ssm, error);
	}
}

static void read_init_data_cb(FpiUsbTransfer *transfer, FpDevice *device,
			      gpointer user_data, GError *error)
{
	FpImageDevice *dev = FP_IMAGE_DEVICE(device);

	if (!error)
		upektc_next_init_cmd(transfer->ssm, dev);
	else
		fpi_ssm_mark_failed(transfer->ssm, error);
}

static void activate_run_state(FpiSsm *ssm, FpDevice *dev, void *user_data)
{
	FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC(dev);

	switch (fpi_ssm_get_cur_state(ssm)) {
	case WRITE_INIT:
	{
		FpiUsbTransfer *transfer = fpi_usb_transfer_new(dev);

		fpi_usb_transfer_fill_bulk_full(transfer,
						self->ep_out,
						(unsigned char *) self->setup_commands[self->init_idx].cmd,
						UPEKTC_CMD_LEN,
						NULL);
		transfer->ssm = ssm;
		transfer->short_is_error = TRUE;
		fpi_usb_transfer_submit(transfer, BULK_TIMEOUT, NULL,
					write_init_cb, NULL);
		fpi_usb_transfer_unref(transfer);
	}
	break;
	case READ_DATA:
	{
		FpiUsbTransfer *transfer = fpi_usb_transfer_new(dev);

		fpi_usb_transfer_fill_bulk (transfer,
					    self->ep_in,
					    self->setup_commands[self->init_idx].response_len);
		transfer->ssm = ssm;
		fpi_usb_transfer_submit(transfer, BULK_TIMEOUT, NULL,
					read_init_data_cb, NULL);
		fpi_usb_transfer_unref(transfer);
	}
	break;
	}
}

static void activate_sm_complete(FpiSsm *ssm, FpDevice *_dev,
				 void *user_data, GError *error)
{
	FpImageDevice *dev = FP_IMAGE_DEVICE(_dev);

	fpi_image_device_activate_complete(dev, error);

	if (!error)
		start_finger_detection(dev);
	fpi_ssm_free(ssm);
}


/****** FINGER PRESENCE DETECTION ******/

static int finger_present(unsigned char *img, size_t len, int sum_threshold)
{
	int i, sum;

	sum = 0;

	for (i = 0; i < len; i++) {
		if (img[i] < 160) {
			sum++;
		}
	}

	fp_dbg("finger_present: sum is %d\n", sum);
	return sum < sum_threshold ? 0 : 1;
}

static void finger_det_data_cb(FpiUsbTransfer *transfer, FpDevice *device,
			       gpointer user_data, GError *error)
{
	FpImageDevice *dev = FP_IMAGE_DEVICE(device);
	FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC(dev);

	if (error) {
		fp_dbg("data transfer status %s\n", error->message);
		fpi_image_device_session_error(dev, error);
		return;
	}

	if (finger_present(transfer->buffer, IMAGE_SIZE, self->sum_threshold)) {
		/* 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_cmd_cb(FpiUsbTransfer *t, FpDevice *device,
			      gpointer user_data, GError *error)
{
	FpiUsbTransfer *transfer;
	FpImageDevice *dev = FP_IMAGE_DEVICE (device);
	FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC(dev);

	if (error) {
		fp_dbg("req transfer status %s\n", error->message);
		fpi_image_device_session_error(dev, error);
		return;
	}

	transfer = fpi_usb_transfer_new (device);
	transfer->short_is_error = TRUE;
	fpi_usb_transfer_fill_bulk(transfer, self->ep_in,
				   IMAGE_SIZE);
	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)
{
	FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC(dev);
	FpiUsbTransfer *transfer;
	G_DEBUG_HERE();

	if (self->deactivating) {
		complete_deactivation(dev, NULL);
		return;
	}

	transfer = fpi_usb_transfer_new(FP_DEVICE(dev));
	transfer->short_is_error = TRUE;
	fpi_usb_transfer_fill_bulk_full(transfer, self->ep_out,
				       (unsigned char *)scan_cmd,
				       UPEKTC_CMD_LEN, NULL);
	fpi_usb_transfer_submit(transfer, BULK_TIMEOUT, NULL,
			       finger_det_cmd_cb, NULL);
	fpi_usb_transfer_unref(transfer);
}

/****** CAPTURE ******/

enum capture_states {
	CAPTURE_WRITE_CMD,
	CAPTURE_READ_DATA,
	CAPTURE_NUM_STATES,
};

static void capture_cmd_cb(FpiUsbTransfer *transfer, FpDevice *device,
			   gpointer user_data, GError *error)
{
	if (!error) {
		fpi_ssm_next_state(transfer->ssm);
	} else {
		fpi_ssm_mark_failed(transfer->ssm, error);
	}
}

static void capture_read_data_cb(FpiUsbTransfer *transfer, FpDevice *device,
				 gpointer user_data, GError *error)
{
	FpImageDevice *dev = FP_IMAGE_DEVICE(device);
	FpImage *img;

	if (error) {
		fp_dbg("request is not completed, %s", error->message);
		fpi_ssm_mark_failed(transfer->ssm, error);
		return;
	}

	img = fp_image_new(IMAGE_WIDTH, IMAGE_HEIGHT);
	memcpy(img->data, transfer->buffer, IMAGE_SIZE);
	fpi_image_device_image_captured(dev, img);
	fpi_image_device_report_finger_status(dev, FALSE);
	fpi_ssm_mark_completed(transfer->ssm);
}

static void capture_run_state(FpiSsm *ssm, FpDevice *_dev, void *user_data)
{
	FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC(_dev);

	switch (fpi_ssm_get_cur_state(ssm)) {
	case CAPTURE_WRITE_CMD:
	{
		FpiUsbTransfer *transfer = fpi_usb_transfer_new(_dev);

		fpi_usb_transfer_fill_bulk_full(transfer, self->ep_out,
					       (unsigned char *)scan_cmd,
					       UPEKTC_CMD_LEN, NULL);
		transfer->ssm = ssm;
		transfer->short_is_error = TRUE;
		fpi_usb_transfer_submit(transfer, BULK_TIMEOUT, NULL,
					capture_cmd_cb, NULL);
		fpi_usb_transfer_unref(transfer);
	}
	break;
	case CAPTURE_READ_DATA:
	{
		FpiUsbTransfer *transfer = fpi_usb_transfer_new(_dev);

		fpi_usb_transfer_fill_bulk(transfer, self->ep_in,
					   IMAGE_SIZE);
		transfer->ssm = ssm;
		transfer->short_is_error = TRUE;
		fpi_usb_transfer_submit(transfer, BULK_TIMEOUT, NULL,
				        capture_read_data_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;
	FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC(_dev);

	fp_dbg("Capture completed");
	if (self->deactivating)
		complete_deactivation(dev, error);
	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)
{
	FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC(dev);
	FpiSsm *ssm;

	if (self->deactivating) {
		complete_deactivation(dev, NULL);
		return;
	}

	ssm = fpi_ssm_new(FP_DEVICE(dev), capture_run_state,
			  CAPTURE_NUM_STATES, dev);
	G_DEBUG_HERE();
	fpi_ssm_start(ssm, capture_sm_complete);
}

static void dev_activate(FpImageDevice *dev)
{
	FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC(dev);
	FpiSsm *ssm = fpi_ssm_new(FP_DEVICE(dev), activate_run_state,
				  ACTIVATE_NUM_STATES, dev);
	self->init_idx = 0;
	fpi_ssm_start(ssm, activate_sm_complete);
}

static void dev_deactivate(FpImageDevice *dev)
{
	FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC(dev);

	self->deactivating = TRUE;
}

static void complete_deactivation(FpImageDevice *dev, GError *error)
{
	FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC(dev);
	G_DEBUG_HERE();

	self->deactivating = FALSE;
	fpi_image_device_deactivate_complete(dev, error);
}

static void dev_init(FpImageDevice *dev)
{
	GError *error = NULL;
	FpiDeviceUpektc *self = FPI_DEVICE_UPEKTC(dev);
	guint64 driver_data = fpi_device_get_driver_data (FP_DEVICE (dev));

	/* TODO check that device has endpoints we're using */

	if (!g_usb_device_claim_interface(fpi_device_get_usb_device(FP_DEVICE(dev)), 0, 0, &error)) {
		fpi_image_device_open_complete(dev, error);
		return;
	}

	switch (driver_data) {
	case UPEKTC_2015:
		self->ep_in = UPEKTC_EP_IN;
		self->ep_out = UPEKTC_EP_OUT;
		self->setup_commands = upektc_setup_commands;
		self->setup_commands_len = G_N_ELEMENTS(upektc_setup_commands);
		self->sum_threshold = UPEKTC_SUM_THRESHOLD;
		break;
	case UPEKTC_3001:
		self->ep_in = UPEKET_EP_IN;
		self->ep_out = UPEKET_EP_OUT;
		self->setup_commands = upeket_setup_commands;
		self->setup_commands_len = G_N_ELEMENTS(upeket_setup_commands);
		self->sum_threshold = UPEKET_SUM_THRESHOLD;
		break;
	default:
		fp_err("Device variant %lu is not known\n", driver_data);
		g_assert_not_reached ();
		fpi_image_device_open_complete(dev, fpi_device_error_new (FP_DEVICE_ERROR_GENERAL));
		return;
	}
	fpi_image_device_open_complete(dev, NULL);
}

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 = 0x0483,  .pid = 0x2015, .driver_data = UPEKTC_2015 },
	{ .vid = 0x147e,  .pid = 0x3001, .driver_data = UPEKTC_3001 },
	{ .vid = 0,  .pid = 0,  .driver_data = 0 },
};

static void fpi_device_upektc_init(FpiDeviceUpektc *self) {
}
static void fpi_device_upektc_class_init(FpiDeviceUpektcClass *klass) {
	FpDeviceClass *dev_class = FP_DEVICE_CLASS(klass);
	FpImageDeviceClass *img_class = FP_IMAGE_DEVICE_CLASS(klass);

	dev_class->id = "upektc";
	dev_class->full_name = "UPEK TouchChip/Eikon Touch 300";
	dev_class->type = FP_DEVICE_TYPE_USB;
	dev_class->id_table = id_table;
	dev_class->scan_type = FP_SCAN_TYPE_PRESS;

	img_class->img_open = dev_init;
	img_class->img_close = dev_deinit;
	img_class->activate = dev_activate;
	img_class->deactivate = dev_deactivate;

	img_class->bz3_threshold = 30;

	img_class->img_width = IMAGE_WIDTH;
	img_class->img_height = IMAGE_HEIGHT;
}