Attachment 58282 Details for Bug 47198 – es603 driver

es603 driver

es603.c (text/x-csrc), 22.45 KB, created by Alex Prokofiev on 2012-03-11 03:13:44 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Alex Prokofiev

Created: 2012-03-11 03:13:44 UTC

Size: 22.45 KB

patch

obsolete

>
>#define FP_COMPONENT "es603"
>
>#include <errno.h>
>#include <string.h>
>#include <stdlib.h>
>#include <stdio.h>
>#include <unistd.h>
>
>#include <glib.h>
>#include <libusb.h>
>
>#include <fp_internal.h>
>
>/*
>
>Protocol (from USB traces):
>
>Request: EGIS 0x09 <operation> <params>
>Reply:   SIGE 0x0a 0x01 <data>
>
>Operations:
>	0x01: read reg, parameters: <number of regs to read> <reg1> <reg2> ...
>		in reply, values of register are returned after 0x0a 0x01
>	0x02: write reg, <number of regs> <reg1> <reg1 value> <reg2> <reg2 value> ...
>	0x03: read sensor area, <0x01> <width = 0xc0> <0x01> <value for reg 0xe0> <value for 0xe1> <value for 0xe2>
>		if last 4 bytes are 0, regs are used for gain values
>	0x06: read fingerprint, parameters <0x01> <number of 128-byte lines to read (unsigned short)> <0x01> <0x64>
>	0x60: unknown
>
>Registers:
>	0xe0-0xe2, 0xe3, 0xe5 - control sensor gain (contrast)
>	0xe6 - noise offset
>	0x03 - seems to be status register
>
>*/
>
>
>#define EP_IN (1 | LIBUSB_ENDPOINT_IN)
>#define EP_OUT (2 | LIBUSB_ENDPOINT_OUT)
>#define USB_TIMEOUT 5000
>
>#define SCANLINE_BYTES 128
>#define SCANLINES_PER_IMG 500
>/* Number of full images to read. Windows app reads 2 */
>#define IMG_NUM 2
>
>#define EMPTY_LINES_THRESH 10
>
>struct es603_dev {
>
>	gboolean	need_reset;
>	gboolean	active, deactivate;
>
>	gboolean	check_reply; // when set, es603_send_async also receives reply and checks
>	
>	int		error;
>	int		i;
>
>	unsigned char	gain_e0_0, gain_e1_0, gain_e2_0, dc_off_e6_0;	// Gain settings for finger detection
>	unsigned char	gain_e0_1, gain_e1_1, gain_e2_1, dc_off_e6_1;	// Gain settings for actual scanning
>	unsigned char	gain_e3, gain_e5;	// Maybe gain, maybe something else
>	
>	int images_received;
>	unsigned char *image_buffer;
>	struct fp_img *captured_img;
>
>	int reply_len;
>	unsigned char reply_buffer[384];
>};
>
>enum {
>	ERR_OK,
>	ERR_CALIBRATE = -EINVAL,
>	ERR_USB = -EIO,
>};
>
>static unsigned char init_req[] = {
>	0xe6, 0x36,
>
>	0xe0, 0x04,
>
>	0xe3, 0x08,
>
>	0x51, 0x30,
>	0xe5, 0x13,
>	0xf0, 0x01,
>	0xf2, 0x4e,
>	0x50, 0x8f,
>	0x59, 0x18,
>	0x5a, 0x08,
>	0x5b, 0x10,
>	0x02, 0x31,
>};
>
>static unsigned char scan_req[] = { 0xc0, 0x00, 0x00, 0x00, 0x00 };
>static unsigned char image_req[] = { 0xf4, 0x02, 0x01, 0x64, };
>// When calibrating, first these sparse values are checked, then fine tuned 
>static unsigned char dc_off_vals[] = { 0x1a, 0x27, 0x2e, 0x31, 0x33, 0x34, 0x35, 0x36 };
>// For 0xe3, only this values are tried
>static unsigned char e3_vals[] = { 0x3a, 0x35, 0x30, 0x2b, 0x26, 0x21, 0x1c, 0x17, 0x0d, 0x08, 0x06, 0x04, 0x02, 0x00 };
>
>static void es603_send_async(struct fpi_ssm *, int op, int num, char *data, int len);
>static void es603_set_reg_async(struct fpi_ssm *, int reg, int val);
>static void es603_get_reg_async(struct fpi_ssm *, int reg);
>static void es603_status_async(struct fpi_ssm *);
>
>static void es603_send_cb(struct libusb_transfer *);
>static void es603_reply_cb(struct libusb_transfer *);
>
>static void dev_activate_ssm(struct fpi_ssm *);
>static void dev_activate_completed(struct fpi_ssm *);
>
>static void wait_finger_async(struct fpi_ssm *);
>static void wait_image_async(struct fpi_ssm *);
>static void check_prepare_image(struct fpi_ssm *);
>
>static void dump(char*,int,unsigned char*);
>
>#ifdef ENABLE_DEBUG_LOGGING
>#	define	dbg_dump(a,b,c) dump(a,b,c)
>#else
>#	define dbg_dump(a,b,c)
>#endif
>
>/*
> * Count number of non-zero bytes in scan
> */
>static int _unclear_num(unsigned char *b, int len)
>{
>	int i;
>	int x = 0;
>
>	for (i = 0; i < len; ++i)
>		if (b[i] != 0) ++ x;
>
>	return x;
>}
>
>static gboolean _is_clear(unsigned char *b, int len)
>{
>	int x = _unclear_num(b, len);
>
>	if (x <= (len >> 5)) return 1;
>	return 0;
>}
>
>static int dev_activate(struct fp_img_dev *dev, enum fp_imgdev_state state)
>{
>	struct es603_dev *xdev = dev->priv;
>	struct fpi_ssm *ssm = fpi_ssm_new(dev->dev, dev_activate_ssm, 100);
>
>	ssm->priv = dev;
>	xdev->deactivate = FALSE;
>	xdev->active = TRUE;
>	xdev->captured_img = NULL;
>
>	fpi_imgdev_activate_complete(dev, 0); // Advances device state to finger detection
>	fpi_ssm_start(ssm, dev_activate_completed);
>
>	return 0;
>}
>
>static void dev_deactivate(struct fp_img_dev *dev)
>{
>	struct es603_dev *xdev = dev->priv;
>
>	if (xdev->active)
>		xdev->deactivate = TRUE;
>	else
>		fpi_imgdev_deactivate_complete(dev);
>}
>
>
>#define SSM_START \
>	switch(ssm->cur_state) {
>
>#define SSM_ENTRY(idx) \
>	case idx: {
>
>#define SSM_ENTRY_END } break;
>#define SSM_SET_REG(idx, reg, val) \
>	case idx: es603_set_reg_async(ssm, reg, val); break;
>#define SSM_GET_REG(idx, reg) \
>	case idx: es603_get_reg_async(ssm, reg); break;
>
>#define SSM_NEXT fpi_ssm_next_state(ssm);
>#define SSM_JUMP(idx) fpi_ssm_jump_to_state(ssm,idx);
>
>#define SSM_END(idx) \
>	case idx: fpi_ssm_mark_completed(ssm); break; \
>	default: \
>		if (ssm->cur_state < idx) \
>			fpi_ssm_next_state(ssm); \
>		else    \
>			fpi_ssm_mark_aborted(ssm, -1); \
>	}
>
>#define SSM_SUB_CALL(func) { \
>	struct fpi_ssm* sub_ssm = fpi_ssm_new(dev->dev, func, 100); \
>	sub_ssm->priv = dev; \
>	fpi_ssm_start_subsm(ssm, sub_ssm); \
>}
>
>
>static void dev_activate_ssm(struct fpi_ssm *ssm)
>{
>	struct fp_img_dev *dev = ssm->priv;
>	struct es603_dev *xdev = dev->priv;
>
>	SSM_START
>
>		SSM_ENTRY(0)
>			if (xdev->need_reset) {
>				libusb_reset_device(dev->udev);
>				xdev->need_reset = 0;
>			}
>			SSM_SUB_CALL(wait_finger_async);
>		SSM_ENTRY_END
>		
>		SSM_ENTRY(1)
>			fpi_imgdev_report_finger_status(dev, TRUE);
>			SSM_SUB_CALL(wait_image_async);
>		SSM_ENTRY_END
>		
>		SSM_ENTRY(2)
>			check_prepare_image(ssm);
>		SSM_ENTRY_END
>
>	SSM_END(3)
>}
>
>static void dev_activate_completed(struct fpi_ssm *ssm)
>{
>	struct fp_img_dev *dev = ssm->priv;
>	struct es603_dev *xdev = dev->priv;
>	int err = ssm->error;
>
>	xdev->active = FALSE;
>
>	if (err) {
>		fpi_imgdev_session_error(dev, err);
>		if (xdev->captured_img)
>			fp_img_free(xdev->captured_img);
>		xdev->captured_img = NULL;
>	}
>
>	if (xdev->image_buffer)
>		g_free(xdev->image_buffer);
>	xdev->image_buffer = NULL;
>
>	fpi_ssm_free(ssm);
>
>	if (xdev->deactivate)
>		fpi_imgdev_deactivate_complete(dev);
>}
>
>static void wait_finger_async(struct fpi_ssm *ssm)
>{
>	struct fp_img_dev *dev = ssm->priv;
>	struct es603_dev *xdev = dev->priv;
>	libusb_device_handle *h = dev->udev;
>	unsigned char r[] = { 0x01 };
>
>	SSM_START
>	
>	/*
>	 * This cycle is possibly power on sequence
>	 */
>	// ------------------------------
>	SSM_ENTRY(0) xdev->i = 0; SSM_NEXT; SSM_ENTRY_END
>
>		SSM_SET_REG(1, 0x93, 0x40);
>		SSM_SET_REG(2, 0x94, 0x0f);
>		SSM_ENTRY(3) es603_send_async(ssm, 0x60, 1, NULL, 0); SSM_ENTRY_END
>		SSM_ENTRY(4) es603_status_async(ssm); SSM_ENTRY_END
>		
>		SSM_ENTRY(5)
>			if (xdev->i == 2) r[0] = 0x21;
>			xdev->check_reply = TRUE;
>			es603_send_async(ssm, 0x60, 2, r, 1);
>		SSM_ENTRY_END
>
>  		SSM_ENTRY(6)
>  			++ xdev->i;
>  			if (xdev->i < 2)
>  				SSM_JUMP(1)
>  			else
>  				SSM_NEXT
>  		SSM_ENTRY_END
>
>	SSM_SET_REG(7, 0x02, 0x30);
>	// ------------------------------
>
>	SSM_SET_REG(8, 0xe0, xdev->gain_e0_0);
>	SSM_SET_REG(9, 0xe1, xdev->gain_e1_0);
>	SSM_SET_REG(10, 0xe2, xdev->gain_e2_0);
>
>	SSM_SET_REG(11, 0xe5, xdev->gain_e5);
>	SSM_SET_REG(12, 0x04, 0x01);
>	SSM_SET_REG(13, 0x02, 0x33);
>
>	SSM_SET_REG(14, 0xe6, xdev->dc_off_e6_0);
>
>	SSM_ENTRY(15) es603_send_async(ssm, 3, 1, scan_req, 5); SSM_ENTRY_END
>
>	SSM_ENTRY(16)
>		struct libusb_transfer *tr = libusb_alloc_transfer(0);
>		libusb_fill_bulk_transfer(tr, h, EP_IN, xdev->reply_buffer, 384, es603_reply_cb, ssm, USB_TIMEOUT);
>		libusb_submit_transfer(tr);
>	SSM_ENTRY_END
>
>	SSM_ENTRY(17)
>		// check for image
>		if (_is_clear(xdev->reply_buffer, 384))
>			SSM_JUMP(15)
>		else
>			SSM_NEXT
>	SSM_ENTRY_END
>
>	SSM_END(18)
>}
>
>static void wait_image_async(struct fpi_ssm *ssm)
>{
>	struct fp_img_dev *dev = ssm->priv;
>	struct es603_dev *xdev = dev->priv;
>	libusb_device_handle *h = dev->udev;
>
>	SSM_START
>
>	SSM_ENTRY(0)
>		xdev->images_received = 0;
>		xdev->image_buffer = g_malloc(64000 * IMG_NUM);
>		SSM_NEXT
>        SSM_ENTRY_END
>
>	SSM_SET_REG(1, 0xe6, xdev->dc_off_e6_1);
>
>	/*
>	 * This code runs before getting images, so it must be some check when motion detected
>	 */
>	// -------------------
>	SSM_SET_REG(2, 0x03, 0x02);
>	SSM_SET_REG(3, 0x02, 0x33);
>
>		SSM_GET_REG(4, 0x03);
>		SSM_ENTRY(5)
>			int r = xdev->reply_buffer[6];
>			if (r & 0x02)
>				SSM_NEXT
>			else
>				SSM_JUMP(4)
>		SSM_ENTRY_END
>	// -------------------
>
>	SSM_SET_REG(6, 0x02, 0x30);
>
>	SSM_SET_REG(7, 0x02, 0x34);
>
>	SSM_SET_REG(8, 0xe0, xdev->gain_e0_1);
>	SSM_SET_REG(9, 0xe1, xdev->gain_e1_1);
>	SSM_SET_REG(10, 0xe2, xdev->gain_e2_1);
>
>	SSM_SET_REG(11, 0x10, 0x92);
>	SSM_SET_REG(12, 0x1a, 0x04);
>	SSM_SET_REG(13, 0x02, 0x34);
>
>	SSM_ENTRY(14) es603_send_async(ssm, 6, 1, image_req, 4); SSM_ENTRY_END
>
>        SSM_ENTRY(15)
>		struct libusb_transfer *tr = libusb_alloc_transfer(0);
>		libusb_fill_bulk_transfer(tr, h, EP_IN, xdev->image_buffer + 64000*xdev->images_received, 64000, es603_reply_cb, ssm, USB_TIMEOUT);
>		libusb_submit_transfer(tr);
>	SSM_ENTRY_END
>
>	SSM_ENTRY(16)
>		if (xdev->reply_len != 64000) {
>			fpi_ssm_mark_aborted(ssm, -EIO);
>		} else if (xdev->images_received < IMG_NUM-1) {
>			++ xdev->images_received;
>			SSM_JUMP(14)
>		} else {
>			SSM_NEXT
>		}
>	SSM_ENTRY_END
>
>	SSM_END(17)
>}
>
>static int _cmp_lines(unsigned char *a, unsigned char *b)
>{
>	int i;
>	int x = 0;
>
>	for (i = 0; i < SCANLINE_BYTES; ++i) {
>		x += abs( (a[i] & 0x0f) - (b[i] & 0x0f) );
>		x += abs( (a[i] >> 4) - (b[i] >> 4) );
>	}
>
>	return x;
>}
>
>/*
> * Convert buffer to fp_img
> * ES603 returns 4-bit image, with 2 pixels in every byte
> */
>static struct fp_img * convert_to_img(unsigned char *buf, int start_row, int end_row)
>{
>	struct fp_img *img;
>	unsigned char *img_buf;
>	int i;
>
>	img = fpi_img_new( (end_row - start_row)*SCANLINE_BYTES*2);
>	img->height = end_row - start_row;
>	img->width = SCANLINE_BYTES*2;
>	img->flags |= FP_IMG_COLORS_INVERTED | FP_IMG_V_FLIPPED;
>
>	buf += start_row*SCANLINE_BYTES;
>	img_buf = img->data;
>	
>	for (i = 0; i < (end_row - start_row)*SCANLINE_BYTES; ++ i) {
>		*img_buf = *buf & 0xf0;
>		++ img_buf;
>		*img_buf = *buf << 4;
>		++ img_buf;
>		++ buf;
>	}
>	return img;
>}
>
>#define CMP_LINES_THRESH 4
>
>/*
> * Detect finger in image.
> * Drop identical lines at start and at end and see if enough lines are left.
> * To make detection more reliable, more than EMPTY_LINES_THRESH should be different/identical to be fingerprint start/end
> * First line of second scan sometimes contains garbage so it is ignored in comparisons
> */
>static void check_prepare_image(struct fpi_ssm *ssm)
>{
>	struct fp_img_dev *dev = ssm->priv;
>	struct es603_dev *xdev = dev->priv;
>	unsigned char *buf = xdev->image_buffer;
>	int img_start = 0;
>	int img_end, run_lines;
>
>        run_lines = 0;
>	while (img_start < 2*SCANLINES_PER_IMG - 1) {
>		if (_cmp_lines(buf, buf + SCANLINE_BYTES) > CMP_LINES_THRESH) {
>			++ run_lines;
>         	} else if (img_start != SCANLINES_PER_IMG -1) {
>         		run_lines = 0;
>         	}
>
>         	if (run_lines > EMPTY_LINES_THRESH) {
>         		img_start -= run_lines-1;
>         		break;
>         	}
>
>		++ img_start;
>		buf += SCANLINE_BYTES;
>	}
>
>	img_end = img_start + run_lines;
>	while (img_end < 2*SCANLINES_PER_IMG - 1) {
>
>		if (_cmp_lines(buf, buf + SCANLINE_BYTES) < CMP_LINES_THRESH) {
>			++ run_lines;
>         	} else {
>         		run_lines = 0;
>         	}
>         	if (run_lines > EMPTY_LINES_THRESH) {
>         		img_end -= run_lines-1;
>         		break;
>         	}
>
>		++ img_end;
>		buf += SCANLINE_BYTES;
>        }
>
>	fp_dbg("fingerprint rows: %i-%i", img_start, img_end);
>
>	if (img_start > img_end - 100) {
>#ifdef ENABLE_DEBUG_LOGGING
>		struct fp_img *x = convert_to_img(xdev->image_buffer, 0, 999);
>		fp_img_save_to_file(x, "debug.pgm");
>		fp_img_free(x);
>#endif
>		fp_err("Failed to detect finger image");
>		fpi_ssm_mark_aborted(ssm, -EIO);
>		goto ret;
>	}
>
>	xdev->captured_img = convert_to_img(xdev->image_buffer, img_start, img_end);
>
>	fpi_imgdev_image_captured(dev, xdev->captured_img);
>	fpi_ssm_mark_completed(ssm);
>
>ret:
>	fpi_imgdev_report_finger_status(dev, FALSE);
>}
>
>
>static void es603_send_async(struct fpi_ssm *ssm, int op, int num, char *data, int len)
>{
>	struct fp_img_dev *dev = ssm->priv;
>	unsigned char *buf = g_malloc(len + 7);
>	struct libusb_transfer *tr;
>	int rc;
>
>	if (buf == NULL) {
>		fpi_ssm_mark_aborted(ssm, -ENOMEM);
>		return;
>	}
>
>	strcpy(buf, "EGIS\x09");
>	buf[5] = op; buf[6] = num;
>	memcpy(buf + 7, data, len);
>	dbg_dump("Send(A): ", len+7, buf);
>
>	tr = libusb_alloc_transfer(0);
>	libusb_fill_bulk_transfer(tr, dev->udev, EP_OUT, buf, len+7, es603_send_cb, ssm, USB_TIMEOUT);
>	rc = libusb_submit_transfer(tr);
>	if (rc) {
>		fp_err("Request send submit failed: %i", rc);
>		fpi_ssm_mark_aborted(ssm, rc);
>	}
>}
>
>/*
> * Asyncronous interface to sending requests, setting/getting registers
> */
>static void es603_status_async(struct fpi_ssm *ssm)
>{
>	struct fp_img_dev *dev = ssm->priv;
>	struct es603_dev *xdev = dev->priv;
>	struct libusb_transfer *reply;
>	int rc;
>
>	reply = libusb_alloc_transfer(0);
>	libusb_fill_bulk_transfer(reply, dev->udev, EP_IN, xdev->reply_buffer, 16, es603_reply_cb, ssm, USB_TIMEOUT);
>	rc = libusb_submit_transfer(reply);
>	if (rc) {
>		fp_err("Status read submit failed");
>		fpi_ssm_mark_aborted(ssm, rc);
>	}
>}
>
>static void es603_send_cb(struct libusb_transfer *tr)
>{
>	struct fpi_ssm *ssm = tr->user_data;
>	struct fp_img_dev *dev = ssm->priv;
>	struct es603_dev *xdev = dev->priv;
>
>	if (tr->status != LIBUSB_TRANSFER_COMPLETED || tr->actual_length != tr->length) {
>		fp_err("Request transfer failed or short");
>		fpi_ssm_mark_aborted(ssm, -EIO);
>		goto ret;
>	}
>
>	if (xdev->check_reply) {
>		es603_status_async(ssm);
>	} else {
>		fpi_ssm_next_state(ssm);
>	}
>ret:
>	g_free(tr->buffer);
>	libusb_free_transfer(tr);
>}
>
>
>static void es603_reply_cb(struct libusb_transfer *tr)
>{
>	struct fpi_ssm *ssm = tr->user_data;
>	struct fp_img_dev *dev = ssm->priv;
>	struct es603_dev *xdev = dev->priv;
>	unsigned char *buf = xdev->reply_buffer;
>	int rc;
>
>	if (tr->status != LIBUSB_TRANSFER_COMPLETED || tr->actual_length < 5) {
>		fp_err("Reply transfer is failed or short");
>		rc = -EIO;
>		goto ret_err;
>	}
>
>	if (tr->actual_length < 100) {
>	dbg_dump("Recv(A): ", tr->actual_length, buf);
>        } else {
>        	fp_dbg("Recv(A): %i bytes", tr->actual_length);
>        }
>
>	if (xdev->check_reply) {
>		xdev->check_reply = FALSE;
>        	if (strncmp(buf, "SIGE", 4) != 0 || buf[4] != 0x0a || buf[5] != 0x01) {
>			fp_err("Invalid reply");
>			rc = -EIO;
>			goto ret_err;
>		}
>        }
>
>	// Check if deactivation requested
>	if (xdev->deactivate)
>		goto ret_err;
>
>	xdev->reply_len = tr->actual_length;
>	fpi_ssm_next_state(ssm);
>	goto ret;
>
>ret_err:
>	fpi_ssm_mark_aborted(ssm, rc);
>ret:
>	libusb_free_transfer(tr);
>}
>
>static void es603_set_reg_async(struct fpi_ssm *ssm, int reg, int val)
>{
>	struct fp_img_dev *dev = ssm->priv;
>	struct es603_dev *xdev = dev->priv;
>	unsigned char req[2];
>
>	req[0] = reg; req[1] = val;
>	xdev->check_reply = TRUE;
>	es603_send_async(ssm, 2, 1, req, 2);
>}
>
>static void es603_get_reg_async(struct fpi_ssm *ssm, int reg)
>{
>	struct fp_img_dev *dev = ssm->priv;
>	struct es603_dev *xdev = dev->priv;
>	unsigned char bReg = reg;
>
>	xdev->check_reply = TRUE;
>	es603_send_async(ssm, 1, 1, & bReg, 1);
>}
>
>/*
> * Synchronous interface
> * Used for calibration for now
> */
>static int es603_send(libusb_device_handle *h, int op, int num, char *data, int len)
>{
>	int rc, actual;
>	unsigned char *buf = malloc(len + 7);
>	
>	if (buf == NULL)
>		return ENOMEM;
>	
>	strcpy(buf, "EGIS\x09");
>	buf[5] = op; buf[6] = num;
>	memcpy(buf + 7, data, len);
>
>	dbg_dump("Send(S): ", len+7, buf);
>	rc = libusb_bulk_transfer(h, EP_OUT, buf, len+7, & actual, USB_TIMEOUT);
>	free(buf);
>	return rc || actual != len+7;
>}
>
>/*
> * Check reply packet and status code
> * Returns one byte from reply at given position (handy for functions receiving 1 byte)
> * On error return value < 0
> */
>static int es603_status_byte(libusb_device_handle *h, int idx)
>{
>	int rc, len;
>	unsigned char buf[16];
>
>	rc = libusb_bulk_transfer(h, EP_IN, buf, 16, & len, 5000);
>	dbg_dump("Recv(S): ", len, buf);
>
>	if (rc != 0)
>		return -1;
>
>	if (len < 5)
>		return -2;
>	if (strncmp(buf, "SIGE", 4) != 0 || buf[4] != 0x0a || buf[5] != 0x01)
>		return -3;
>	if (len < idx)
>		return -4;
>	return buf[idx];
>}
>
>static int es603_status(libusb_device_handle *h)
>{
>	int rc = es603_status_byte(h, 0);
>	return (rc < 0) ? rc : 0;
>}
>
>/*
> * Set one register on device
> */
>static void es603_set_reg(libusb_device_handle *h, int reg, int val)
>{
>	unsigned char req[2];
>
>	req[0] = reg;
>	req[1] = val;
>	es603_send(h, 2, 1, req, 2);
>	es603_status(h);
>}
>
>/*
> * Get one register
> */
>static int es603_get_reg(libusb_device_handle *h, int reg)
>{
>	unsigned char req[2];
>	int val;
>	
>	req[0] = reg;
>	es603_send(h, 1, 1, req, 1);
>	val = es603_status_byte(h, 6);
>	return val;
>}
>
>/*
> * Calibration
> */
>static int _calibrate_at_gain(libusb_device_handle *h, unsigned char *req, unsigned char *buf)
>{
>	int state, rc, actual;
>	unsigned char *dc_off = dc_off_vals, v;
>
>	while (*dc_off < 0x36)
>	{
>		es603_set_reg(h, 0xe6, *dc_off);
>		es603_send(h, 3, 1, req, 5);
>                rc = libusb_bulk_transfer(h, EP_IN, buf, 384, & actual, USB_TIMEOUT);
>                if (rc)
>                	return -2;
>
>                if (_unclear_num(buf, 384) == 0) {
>                	state = 1;
>                	break;
>                }
>                ++ dc_off;
>	}
>
>	if (state != 1)
>		return -1;
>
>	-- dc_off;
>	state = 0;
>	for (v = *dc_off + 1; v <= dc_off[1]; ++ v)
>	{
>		es603_set_reg(h, 0xe6, v);
>		es603_send(h, 3, 1, req, 5);
>                rc = libusb_bulk_transfer(h, EP_IN, buf, 384, & actual, USB_TIMEOUT);
>                if (rc)
>                	return -2;
>                if (_unclear_num(buf, 384) == 0) {
>                	state = 1;
>                	break;
>                }
>	}
>
>	if (state != 1)
>		return -1;
>
>	return v;
>}
>
>static int _calibrate_e1e2(libusb_device_handle *h, unsigned char *req, unsigned char *buf)
>{
>	int state, rc, actual;
>
>	state = 0;
>	do 
>	{
>		es603_send(h, 3, 1, req, 5);
>                rc = libusb_bulk_transfer(h, EP_IN, buf, 384, & actual, USB_TIMEOUT);
>                if (rc)
>                	return -2;
>
>                if (_unclear_num(buf, 384) == 0)
>                	++ state;
>                else
>                	state = 0;
>
>		if (state > 3)
>			break;
>
>                if (state == 0) {
>	                ++ req[3];
>         	       ++ req[4];
>                }
>	}
>	while (req[3] < 0x20);
>
>	if (state < 3)
>		return -1;
>
>	return 0;
>}
>
>
>static int _calibrate_e3(libusb_device_handle *h)
>{
>	int r;
>	unsigned char *v = e3_vals;
>
>	es603_set_reg(h, 0x51, 0x30);
>	es603_set_reg(h, 0x59, 0x18);
>	es603_set_reg(h, 0x5a, 0x08);
>	es603_set_reg(h, 0x5b, 0x00);
>
>	es603_set_reg(h, 0xe3, *v);
>	es603_set_reg(h, 0x50, 0x8f);
>	es603_set_reg(h, 0x02, 0x31);
>
>	do {
>		es603_set_reg(h, 0xe3, *v);
>		r = es603_get_reg(h, 0x03);
>		if (r & 0x10)
>			break;
>		++ v;
>	}
>	while(*v > 0);
>
>	es603_set_reg(h, 0x02, 0x30);
>
>	es603_set_reg(h, 0x50, 0x0f);
>	es603_set_reg(h, 0x51, 0x30);
>
>	es603_set_reg(h, 0x59, 0x18);
>	es603_set_reg(h, 0x5a, 0x08);
>	es603_set_reg(h, 0x5b, 0x10);
>
>	if (*v == 0)
>		return -1;
>	-- v;
>	return *v;
>}
>
>
>static void calibrate(struct fp_img_dev *dev)
>{
>	struct es603_dev *xdev = dev->priv;
>	libusb_device_handle *h = dev->udev;
>	unsigned char scan_req_[5], *buf;
>	int rc, tries, dc_off, v;
>
>	xdev->error = 0;
>
>	memcpy(scan_req_, scan_req, sizeof(scan_req_));
>	
>	scan_req_[1] = 0x01;
>	scan_req_[3] = 0x15;
>	scan_req_[4] = 0x10;
>	
>	xdev->gain_e5 = 0x14;
>
>	buf = malloc(384);
>
>	es603_set_reg(h, 0xe5, xdev->gain_e5);
>
>	// Retry several times if calibration fails first time
>	tries = 0;
>	do
>	{
>		// Scan gains
>		scan_req_[2] = 0x23;
>		do
>		{
>			// Find value for 0xe6 reg at given gain
>			dc_off = _calibrate_at_gain(h, scan_req_, buf);
>			if (dc_off > 0)
>				break;
>			if (dc_off < -1) {
>				xdev->error = ERR_CALIBRATE;
>				goto ret;
>			}
>        	        -- scan_req_[2];
>		}
>		while (scan_req_[2] > 0x10);
>
>		if (dc_off <= 0) {
>			xdev->error = ERR_CALIBRATE;
>			goto ret;
>		}
>
>		// Check calibration again
>                v = _calibrate_at_gain(h, scan_req_, buf);
>                if (v > 0 && dc_off == v)
>                	break;
>
>		++ tries;
>	}
>	while (tries < 3);
>
>	if (tries == 3) {
>		xdev->error = ERR_CALIBRATE;
>		goto ret;
>	}
>
>	xdev->gain_e0_0 = scan_req_[2];
>	xdev->dc_off_e6_0 = dc_off;
>
>	es603_set_reg(h, 0xe0, xdev->gain_e0_0);
>	es603_set_reg(h, 0xe1, 0x15);
>	es603_set_reg(h, 0xe2, 0x10);
>	es603_set_reg(h, 0xe6, xdev->dc_off_e6_0);
>
>	es603_set_reg(h, 0x02, 0x30);
>	es603_set_reg(h, 0xe5, xdev->gain_e5 - 1);
>
>        rc = _calibrate_e3(h);
>        if (rc < 0) {
>		xdev->error = ERR_CALIBRATE;
>		goto ret;
>        }
>	xdev->gain_e3 = rc;
>	es603_set_reg(h, 0xe3, xdev->gain_e3);
>	es603_set_reg(h, 0xe5, xdev->gain_e5);
>
>	// Do several tries
>	tries = 0;
>	do
>	{
>		// Scan gains
>		scan_req_[3] = 0x0a;
>		scan_req_[4] = 0x10;
>		rc = _calibrate_e1e2(h, scan_req_, buf);
>		if (rc < -1) {
>			xdev->error = ERR_USB;
>			goto ret;
>		} 
>		if (rc == 0)
>			break;
>		++ tries;
>	}
>	while (tries < 3);
>
>	es603_set_reg(h, 0x02, 0x31);
>
>	if (tries == 3) {
>		xdev->error = ERR_CALIBRATE;
>		goto ret;
>	}
>
>	xdev->gain_e1_0 = scan_req_[3] + 1;
>	xdev->gain_e2_0 = scan_req_[4] + 1;
>
>	xdev->gain_e0_1 = scan_req_[2];
>	xdev->gain_e1_1 = scan_req_[3];
>	xdev->gain_e2_1 = scan_req_[4] + 1;
>	xdev->dc_off_e6_1 = dc_off + 2;
>	
>	fp_dbg("calibrate result: 0=%02x,%02x,%02x,%02x 1=%02x,%02x,%02x,%02x",
>		xdev->dc_off_e6_0, xdev->gain_e0_0, xdev->gain_e1_0, xdev->gain_e2_0,
>		xdev->dc_off_e6_1, xdev->gain_e0_1, xdev->gain_e1_1, xdev->gain_e2_1
>	);
>	
>ret:
>	free(buf);
>}
>
>
>
>
>
>/*
> * Not sure what this snippet does, 
> * but possibly this is power on sequence
> */
>
>
>static int es603_init(libusb_device_handle *h)
>{
>	int rc;
>        int tries = 0;
>	
>        do {
>		rc = es603_send(h, 2, sizeof(init_req)/2, init_req, sizeof(init_req));
>		if (!rc) {
>			rc = es603_status(h);
>			if (!rc) break;
>		}
>
>		libusb_reset_device(h);
>		++ tries;
>	}
>	while (tries < 3);
>
>	if (tries == 3)
>		return ERR_USB;
>	return 0;
>}
>
>
>static void dump(char *msg, int len, unsigned char *p)
>{
>	if (msg)
>		printf("%s", msg);
>	
>	if (len > 0)
>	while (len) {
>		printf("%02x ", (unsigned int) *p);
>		++ p;
>		-- len;
>	}
>	printf("\n");
>}
>
>static int dev_init(struct fp_img_dev *dev, unsigned long driver_data)
>{
>	struct es603_dev *xdev = NULL;
>	int rc;
>
>	xdev = g_malloc0(sizeof(struct es603_dev));
>
>	rc = libusb_claim_interface(dev->udev, 0);
>	if (rc < 0)
>		goto ret;
>
>	dev->priv = xdev;
>
>	rc = es603_init(dev->udev);
>	if (rc < 0)
>		goto ret;
>
>	calibrate(dev);
>	rc = xdev->error;
>ret:
>	fpi_imgdev_open_complete(dev, rc);
>	if (rc) {
>		g_free(xdev);
>	}
>	return rc;
>}
>
>static void dev_exit(struct fp_img_dev *dev)
>{
>	libusb_release_interface(dev->udev, 0);
>	g_free(dev->priv);
>	fpi_imgdev_close_complete(dev);
>}
>
>static const struct usb_id id_table[] = {
>	{ .vendor = 0x1c7a, .product = 0x0603 },
>	{ 0, 0, 0, },
>};
>
>struct fp_img_driver es603_driver = {
>	.driver = {
>		.id = 11,
>		.name = FP_COMPONENT,
>		.full_name = "EGISTec ES603",
>		.id_table = id_table,
>		.scan_type = FP_SCAN_TYPE_SWIPE,
>	},
>	.open = dev_init,
>	.close = dev_exit,
>	.activate = dev_activate,
>	.deactivate = dev_deactivate,
>};

Actions: View

Attachments on bug 47198: 58282 | 70927 | 71404 | 71853 | 73161 | 73382 | 77033 | 79746

Use of freedesktop.org services, including Bugzilla, is subject to our Code of Conduct. How we collect and use information is described in our Privacy Policy.