2 * libusb example program to manipulate U.are.U 4000B fingerprint scanner.
3 * Copyright (C) 2007 Daniel Drake <dsd@gentoo.org>
5 * Basic image capture program only, does not consider the powerup quirks or
6 * the fact that image encryption may be enabled. Not expected to work
7 * flawlessly all of the time.
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
30 #include <libusb/libusb.h>
32 #define EP_INTR (1 | LIBUSB_ENDPOINT_IN)
33 #define EP_DATA (2 | LIBUSB_ENDPOINT_IN)
34 #define CTRL_IN (LIBUSB_TYPE_VENDOR | LIBUSB_ENDPOINT_IN)
35 #define CTRL_OUT (LIBUSB_TYPE_VENDOR | LIBUSB_ENDPOINT_OUT)
37 #define INTR_LENGTH 64
41 MODE_AWAIT_FINGER_ON = 0x10,
42 MODE_AWAIT_FINGER_OFF = 0x12,
48 static int next_state(void);
49 static int submit_irq_transfer(void);
50 static int submit_img_transfer(void);
53 STATE_AWAIT_MODE_CHANGE_AWAIT_FINGER_ON = 1,
54 STATE_AWAIT_IRQ_FINGER_DETECTED,
55 STATE_AWAIT_MODE_CHANGE_CAPTURE,
57 STATE_AWAIT_MODE_CHANGE_AWAIT_FINGER_OFF,
58 STATE_AWAIT_IRQ_FINGER_REMOVED,
62 static struct libusb_device_handle *devh = NULL;
63 static unsigned char imgbuf[0x1b340];
64 static unsigned char irqbuf[INTR_LENGTH];
65 static struct libusb_transfer *img_transfer = NULL;
66 static struct libusb_transfer *irq_transfer = NULL;
67 static int img_idx = 0;
68 static int do_exit = 0;
70 static int find_dpfp_device(void)
72 devh = libusb_open_device_with_vid_pid(0x05ba, 0x000a);
73 return devh ? 0 : -EIO;
76 static int print_f0_data(void)
78 unsigned char data[0x10];
82 r = libusb_control_transfer(devh, CTRL_IN, USB_RQ, 0xf0, 0, data,
85 fprintf(stderr, "F0 error %d\n", r);
88 if ((unsigned int) r < sizeof(data)) {
89 fprintf(stderr, "short read (%d)\n", r);
94 for (i = 0; i < sizeof(data); i++)
95 printf("%02x ", data[i]);
100 static int get_hwstat(unsigned char *status)
104 r = libusb_control_transfer(devh, CTRL_IN, USB_RQ, 0x07, 0, status, 1, 0);
106 fprintf(stderr, "read hwstat error %d\n", r);
109 if ((unsigned int) r < 1) {
110 fprintf(stderr, "short read (%d)\n", r);
114 printf("hwstat reads %02x\n", *status);
118 static int set_hwstat(unsigned char data)
122 printf("set hwstat to %02x\n", data);
123 r = libusb_control_transfer(devh, CTRL_OUT, USB_RQ, 0x07, 0, &data, 1, 0);
125 fprintf(stderr, "set hwstat error %d\n", r);
128 if ((unsigned int) r < 1) {
129 fprintf(stderr, "short write (%d)", r);
136 static int set_mode(unsigned char data)
139 printf("set mode %02x\n", data);
141 r = libusb_control_transfer(devh, CTRL_OUT, USB_RQ, 0x4e, 0, &data, 1, 0);
143 fprintf(stderr, "set mode error %d\n", r);
146 if ((unsigned int) r < 1) {
147 fprintf(stderr, "short write (%d)", r);
154 static void cb_mode_changed(struct libusb_transfer *transfer)
156 if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
157 fprintf(stderr, "mode change transfer not completed!\n");
161 printf("async cb_mode_changed length=%d actual_length=%d\n",
162 transfer->length, transfer->actual_length);
163 if (next_state() < 0)
165 free(transfer->buffer);
166 libusb_free_transfer(transfer);
169 static int set_mode_async(unsigned char data)
171 int bufsize = LIBUSB_CONTROL_SETUP_SIZE + 1;
172 unsigned char *buf = malloc(bufsize);
173 struct libusb_transfer *transfer;
178 transfer = libusb_alloc_transfer();
184 printf("async set mode %02x\n", data);
185 libusb_fill_control_setup(buf, CTRL_OUT, USB_RQ, 0x4e, 0, 1);
186 buf[LIBUSB_CONTROL_SETUP_SIZE] = data;
187 libusb_fill_control_transfer(transfer, devh, buf, bufsize,
188 cb_mode_changed, NULL, 1000);
190 return libusb_submit_transfer(transfer);
193 static int do_sync_intr(unsigned char *data)
198 r = libusb_interrupt_transfer(devh, EP_INTR, data, INTR_LENGTH,
201 fprintf(stderr, "intr error %d\n", r);
204 if (transferred < INTR_LENGTH) {
205 fprintf(stderr, "short read (%d)\n", r);
209 printf("recv interrupt %04x\n", *((uint16_t *) data));
213 static int sync_intr(unsigned char type)
216 unsigned char data[INTR_LENGTH];
219 r = do_sync_intr(data);
227 static int save_to_file(unsigned char *data)
232 sprintf(filename, "finger%d.pgm", img_idx++);
233 fd = fopen(filename, "w");
237 fputs("P5 384 289 255 ", fd);
238 fwrite(data + 64, 1, 384*289, fd);
240 printf("saved image to %s\n", filename);
244 static int next_state(void)
247 printf("old state: %d\n", state);
249 case STATE_AWAIT_IRQ_FINGER_REMOVED:
250 state = STATE_AWAIT_MODE_CHANGE_AWAIT_FINGER_ON;
251 r = set_mode_async(MODE_AWAIT_FINGER_ON);
253 case STATE_AWAIT_MODE_CHANGE_AWAIT_FINGER_ON:
254 state = STATE_AWAIT_IRQ_FINGER_DETECTED;
256 case STATE_AWAIT_IRQ_FINGER_DETECTED:
257 state = STATE_AWAIT_MODE_CHANGE_CAPTURE;
258 r = set_mode_async(MODE_CAPTURE);
260 case STATE_AWAIT_MODE_CHANGE_CAPTURE:
261 state = STATE_AWAIT_IMAGE;
263 case STATE_AWAIT_IMAGE:
264 state = STATE_AWAIT_MODE_CHANGE_AWAIT_FINGER_OFF;
265 r = set_mode_async(MODE_AWAIT_FINGER_OFF);
267 case STATE_AWAIT_MODE_CHANGE_AWAIT_FINGER_OFF:
268 state = STATE_AWAIT_IRQ_FINGER_REMOVED;
271 printf("unrecognised state %d\n", state);
274 fprintf(stderr, "error detected changing state");
278 printf("new state: %d\n", state);
282 static void cb_irq(struct libusb_transfer *transfer)
284 unsigned char irqtype = transfer->buffer[0];
286 if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
287 fprintf(stderr, "irq transfer status %d?\n", transfer->status);
292 printf("IRQ callback %02x\n", irqtype);
294 case STATE_AWAIT_IRQ_FINGER_DETECTED:
295 if (irqtype == 0x01) {
296 if (next_state() < 0) {
301 printf("finger-on-sensor detected in wrong state!\n");
304 case STATE_AWAIT_IRQ_FINGER_REMOVED:
305 if (irqtype == 0x02) {
306 if (next_state() < 0) {
311 printf("finger-on-sensor detected in wrong state!\n");
315 if (submit_irq_transfer() < 0)
319 static void cb_img(struct libusb_transfer *transfer)
321 if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
322 fprintf(stderr, "img transfer status %d?\n", transfer->status);
327 printf("Image callback\n");
328 save_to_file(imgbuf);
329 if (next_state() < 0) {
333 if (submit_img_transfer() < 0)
337 static int submit_irq_transfer(void)
339 return libusb_submit_transfer(irq_transfer);
342 static int submit_img_transfer(void)
344 return libusb_submit_transfer(img_transfer);
347 static int init_capture(void)
351 r = submit_irq_transfer();
355 r = submit_img_transfer();
357 libusb_cancel_transfer_sync(img_transfer);
361 /* start state machine */
362 state = STATE_AWAIT_IRQ_FINGER_REMOVED;
366 static int do_init(void)
368 unsigned char status;
371 r = get_hwstat(&status);
375 if (!(status & 0x80)) {
376 r = set_hwstat(status | 0x80);
379 r = get_hwstat(&status);
385 r = set_hwstat(status);
389 r = get_hwstat(&status);
400 static int alloc_transfers(void)
402 img_transfer = libusb_alloc_transfer();
406 irq_transfer = libusb_alloc_transfer();
410 libusb_fill_bulk_transfer(img_transfer, devh, EP_DATA, imgbuf,
411 sizeof(imgbuf), cb_img, NULL, 0);
412 libusb_fill_interrupt_transfer(irq_transfer, devh, EP_INTR, irqbuf,
413 sizeof(irqbuf), cb_irq, NULL, 0);
418 static void sighandler(int signum)
425 struct sigaction sigact;
430 fprintf(stderr, "failed to initialise libusb\n");
434 r = find_dpfp_device();
436 fprintf(stderr, "Could not find/open device\n");
440 r = libusb_claim_interface(devh, 0);
442 fprintf(stderr, "usb_claim_interface error %d %s\n", r, strerror(-r));
445 printf("claimed interface\n");
455 /* async from here onwards */
457 r = alloc_transfers();
465 sigact.sa_handler = sighandler;
466 sigemptyset(&sigact.sa_mask);
468 sigaction(SIGINT, &sigact, NULL);
469 sigaction(SIGTERM, &sigact, NULL);
470 sigaction(SIGQUIT, &sigact, NULL);
478 printf("shutting down...\n");
480 r = libusb_cancel_transfer_sync(irq_transfer);
484 r = libusb_cancel_transfer_sync(img_transfer);
494 libusb_free_transfer(img_transfer);
495 libusb_free_transfer(irq_transfer);
499 libusb_release_interface(devh, 0);
503 return r >= 0 ? r : -r;