Initial import of sane-backends version 1.0.24-1.2

1 files changed, 2351 insertions, 0 deletions

diff --git a/backend/epson2.c b/backend/epson2.c
new file mode 100644
index 0000000..9f39c68
--- /dev/null
+++ b/backend/epson2.c
@@ -0,0 +1,2351 @@
+/*
+ * epson2.c - SANE library for Epson scanners.
+ *
+ * Based on Kazuhiro Sasayama previous
+ * Work on epson.[ch] file from the SANE package.
+ * Please see those files for additional copyrights.
+ *
+ * Copyright (C) 2006-10 Tower Technologies
+ * Author: Alessandro Zummo <a.zummo@towertech.it>
+ *
+ * This file is part of the SANE package.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation, version 2.
+ */
+
+#define EPSON2_VERSION	1
+#define EPSON2_REVISION	0
+#define EPSON2_BUILD	124
+
+/* debugging levels:
+ *
+ *     127	e2_recv buffer
+ *     125	e2_send buffer
+ *	32	more network progression
+ *	24	network header
+ *	23	network info
+ *	20	usb cmd counters
+ *	18	sane_read
+ *	17	setvalue, getvalue, control_option
+ *	15	e2_send, e2_recv calls
+ *	13	e2_cmd_info_block
+ *	12	epson_cmd_simple
+ *	11	even more
+ *	10	more debug in ESC/I commands
+ *	 9	ESC x/FS x in e2_send
+ *	 8	ESC/I commands
+ *	 7	open/close/attach
+ *	 6	print_params
+ *	 5	basic functions
+ *	 3	status information
+ *	 1	scanner info and capabilities
+ *		warnings
+ */
+
+#include "sane/config.h"
+
+#include "epson2.h"
+
+#include <limits.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#ifdef HAVE_SYS_SOCKET_H
+#include <sys/socket.h>
+#endif
+
+#include "sane/saneopts.h"
+#include "sane/sanei_scsi.h"
+#include "sane/sanei_usb.h"
+#include "sane/sanei_pio.h"
+#include "sane/sanei_tcp.h"
+#include "sane/sanei_udp.h"
+#include "sane/sanei_backend.h"
+#include "sane/sanei_config.h"
+
+#include "epson2-io.h"
+#include "epson2-commands.h"
+#include "epson2-ops.h"
+
+#include "epson2_scsi.h"
+#include "epson_usb.h"
+#include "epson2_net.h"
+
+/*
+ * Definition of the mode_param struct, that is used to
+ * specify the valid parameters for the different scan modes.
+ *
+ * The depth variable gets updated when the bit depth is modified.
+ */
+
+struct mode_param mode_params[] = {
+	{0, 0x00, 0x30, 1},
+	{0, 0x00, 0x30, 8},
+	{1, 0x02, 0x00, 8},
+	{0, 0x00, 0x30, 1}
+};
+
+static SANE_String_Const mode_list[] = {
+	SANE_VALUE_SCAN_MODE_LINEART,
+	SANE_VALUE_SCAN_MODE_GRAY,
+	SANE_VALUE_SCAN_MODE_COLOR,
+#ifdef SANE_FRAME_IR
+	SANE_I18N("Infrared"),
+#endif
+	NULL
+};
+
+static const SANE_String_Const adf_mode_list[] = {
+	SANE_I18N("Simplex"),
+	SANE_I18N("Duplex"),
+	NULL
+};
+
+/* Define the different scan sources */
+
+#define FBF_STR	SANE_I18N("Flatbed")
+#define TPU_STR	SANE_I18N("Transparency Unit")
+#define TPU_STR2 SANE_I18N("TPU8x10")
+#define ADF_STR	SANE_I18N("Automatic Document Feeder")
+
+/*
+ * source list need one dummy entry (save device settings is crashing).
+ * NOTE: no const - this list gets created while exploring the capabilities
+ * of the scanner.
+ */
+
+SANE_String_Const source_list[] = {
+	FBF_STR,
+	NULL,
+	NULL,
+	NULL
+};
+
+static const SANE_String_Const film_list[] = {
+	SANE_I18N("Positive Film"),
+	SANE_I18N("Negative Film"),
+	SANE_I18N("Positive Slide"),
+	SANE_I18N("Negative Slide"),
+	NULL
+};
+
+static const SANE_String_Const focus_list[] = {
+	SANE_I18N("Focus on glass"),
+	SANE_I18N("Focus 2.5mm above glass"),
+	NULL
+};
+
+#define HALFTONE_NONE 0x01
+#define HALFTONE_TET 0x03
+
+const int halftone_params[] = {
+	HALFTONE_NONE,
+	0x00,
+	0x10,
+	0x20,
+	0x80,
+	0x90,
+	0xa0,
+	0xb0,
+	HALFTONE_TET,
+	0xc0,
+	0xd0
+};
+
+static const SANE_String_Const halftone_list[] = {
+	SANE_I18N("None"),
+	SANE_I18N("Halftone A (Hard Tone)"),
+	SANE_I18N("Halftone B (Soft Tone)"),
+	SANE_I18N("Halftone C (Net Screen)"),
+	NULL
+};
+
+static const SANE_String_Const halftone_list_4[] = {
+	SANE_I18N("None"),
+	SANE_I18N("Halftone A (Hard Tone)"),
+	SANE_I18N("Halftone B (Soft Tone)"),
+	SANE_I18N("Halftone C (Net Screen)"),
+	SANE_I18N("Dither A (4x4 Bayer)"),
+	SANE_I18N("Dither B (4x4 Spiral)"),
+	SANE_I18N("Dither C (4x4 Net Screen)"),
+	SANE_I18N("Dither D (8x4 Net Screen)"),
+	NULL
+};
+
+static const SANE_String_Const halftone_list_7[] = {
+	SANE_I18N("None"),
+	SANE_I18N("Halftone A (Hard Tone)"),
+	SANE_I18N("Halftone B (Soft Tone)"),
+	SANE_I18N("Halftone C (Net Screen)"),
+	SANE_I18N("Dither A (4x4 Bayer)"),
+	SANE_I18N("Dither B (4x4 Spiral)"),
+	SANE_I18N("Dither C (4x4 Net Screen)"),
+	SANE_I18N("Dither D (8x4 Net Screen)"),
+	SANE_I18N("Text Enhanced Technology"),
+	SANE_I18N("Download pattern A"),
+	SANE_I18N("Download pattern B"),
+	NULL
+};
+
+static const SANE_String_Const dropout_list[] = {
+	SANE_I18N("None"),
+	SANE_I18N("Red"),
+	SANE_I18N("Green"),
+	SANE_I18N("Blue"),
+	NULL
+};
+
+static const SANE_Bool correction_userdefined[] = {
+	SANE_FALSE,
+	SANE_TRUE,
+	SANE_TRUE,
+};
+
+static const SANE_String_Const correction_list[] = {
+	SANE_I18N("None"),
+	SANE_I18N("Built in CCT profile"),
+	SANE_I18N("User defined CCT profile"),
+	NULL
+};
+
+enum {
+	CORR_NONE, CORR_AUTO, CORR_USER
+};
+
+static const SANE_String_Const cct_mode_list[] = {
+        "Automatic",
+        "Reflective",
+        "Colour negatives",
+        "Monochrome negatives",
+        "Colour positives",
+        NULL
+};
+
+enum {
+	CCT_AUTO, CCT_REFLECTIVE, CCT_COLORNEG, CCT_MONONEG,
+	CCT_COLORPOS
+};
+
+/*
+ * Gamma correction:
+ * The A and B level scanners work differently than the D level scanners,
+ * therefore I define two different sets of arrays, plus one set of
+ * variables that get set to the actally used params and list arrays at runtime.
+ */
+ 
+static int gamma_params_ab[] = {
+	0x01,
+	0x03,
+	0x00,
+	0x10,
+	0x20
+};
+
+static const SANE_String_Const gamma_list_ab[] = {
+	SANE_I18N("Default"),
+	SANE_I18N("User defined"),
+	SANE_I18N("High density printing"),
+	SANE_I18N("Low density printing"),
+	SANE_I18N("High contrast printing"),
+	NULL
+};
+
+static SANE_Bool gamma_userdefined_ab[] = {
+	SANE_FALSE,
+	SANE_TRUE,
+	SANE_FALSE,
+	SANE_FALSE,
+	SANE_FALSE,
+};
+
+static int gamma_params_d[] = {
+	0x03,
+	0x04
+};
+
+static const SANE_String_Const gamma_list_d[] = {
+	SANE_I18N("User defined (Gamma=1.0)"),
+	SANE_I18N("User defined (Gamma=1.8)"),
+	NULL
+};
+
+static SANE_Bool gamma_userdefined_d[] = {
+	SANE_TRUE,
+	SANE_TRUE
+};
+
+static SANE_Bool *gamma_userdefined;
+int *gamma_params;
+
+/* Bay list:
+ * this is used for the FilmScan
+ * XXX Add APS loader support
+ */
+
+static const SANE_String_Const bay_list[] = {
+	"1",
+	"2",
+	"3",
+	"4",
+	"5",
+	"6",
+	NULL
+};
+
+/* minimum, maximum, quantization */
+static const SANE_Range u8_range = { 0, 255, 0 };
+static const SANE_Range s8_range = { -127, 127, 0 };
+static const SANE_Range fx_range = { SANE_FIX(-2.0), SANE_FIX(2.0), 0 };
+
+static const SANE_Range outline_emphasis_range = { -2, 2, 0 };
+
+
+/*
+ * List of pointers to devices - will be dynamically allocated depending
+ * on the number of devices found.
+ */
+static const SANE_Device **devlist;
+
+
+/* Some utility functions */
+
+static size_t
+max_string_size(const SANE_String_Const strings[])
+{
+	size_t size, max_size = 0;
+	int i;
+
+	for (i = 0; strings[i]; i++) {
+		size = strlen(strings[i]) + 1;
+		if (size > max_size)
+			max_size = size;
+	}
+	return max_size;
+}
+
+static SANE_Status attach_one_usb(SANE_String_Const devname);
+static SANE_Status attach_one_net(SANE_String_Const devname);
+
+static void
+print_params(const SANE_Parameters params)
+{
+	DBG(6, "params.format          = %d\n", params.format);
+	DBG(6, "params.last_frame      = %d\n", params.last_frame);
+	DBG(6, "params.bytes_per_line  = %d\n", params.bytes_per_line);
+	DBG(6, "params.pixels_per_line = %d\n", params.pixels_per_line);
+	DBG(6, "params.lines           = %d\n", params.lines);
+	DBG(6, "params.depth           = %d\n", params.depth);
+}
+
+/*
+ * close_scanner()
+ *
+ * Close the open scanner. Depending on the connection method, a different
+ * close function is called.
+ */
+
+static void
+close_scanner(Epson_Scanner *s)
+{
+	DBG(7, "%s: fd = %d\n", __func__, s->fd);
+
+	if (s->fd == -1)
+		return;
+
+	/* send a request_status. This toggles w_cmd_count and r_cmd_count */
+	if (r_cmd_count % 2)
+		esci_request_status(s, NULL);
+
+	/* request extended status. This toggles w_cmd_count only */
+	if (w_cmd_count % 2)
+		esci_request_extended_status(s, NULL, NULL);
+
+	if (s->hw->connection == SANE_EPSON_NET) {
+		sanei_epson_net_unlock(s);
+		sanei_tcp_close(s->fd);
+	} else if (s->hw->connection == SANE_EPSON_SCSI) {
+		sanei_scsi_close(s->fd);
+	} else if (s->hw->connection == SANE_EPSON_PIO) {
+		sanei_pio_close(s->fd);
+	} else if (s->hw->connection == SANE_EPSON_USB) {
+		sanei_usb_close(s->fd);
+	}
+
+	s->fd = -1;
+}
+
+static void
+e2_network_discovery(void)
+{
+	fd_set rfds;
+	int fd, len;
+	SANE_Status status;
+
+	char *ip, *query = "EPSONP\x00\xff\x00\x00\x00\x00\x00\x00\x00";
+	unsigned char buf[76];
+
+	struct timeval to;
+
+	status = sanei_udp_open_broadcast(&fd);
+	if (status != SANE_STATUS_GOOD)
+		return;
+
+	sanei_udp_write_broadcast(fd, 3289, (unsigned char *) query, 15);
+
+	DBG(5, "%s, sent discovery packet\n", __func__);
+
+	to.tv_sec = 1;
+	to.tv_usec = 0;
+
+	FD_ZERO(&rfds);
+	FD_SET(fd, &rfds);
+
+	sanei_udp_set_nonblock(fd, SANE_TRUE);
+	if (select(fd + 1, &rfds, NULL, NULL, &to) > 0) {
+		while ((len = sanei_udp_recvfrom(fd, buf, 76, &ip)) == 76) {
+			DBG(5, " response from %s\n", ip);
+
+			/* minimal check, protocol unknown */
+			if (strncmp((char *) buf, "EPSON", 5) == 0)
+				attach_one_net(ip);
+		}
+	}
+
+	DBG(5, "%s, end\n", __func__);
+
+	sanei_udp_close(fd);
+}
+
+/*
+ * open_scanner()
+ *
+ * Open the scanner device. Depending on the connection method,
+ * different open functions are called.
+ */
+
+static SANE_Status
+open_scanner(Epson_Scanner *s)
+{
+	SANE_Status status = 0;
+
+	DBG(7, "%s: %s\n", __func__, s->hw->sane.name);
+
+	if (s->fd != -1) {
+		DBG(5, "scanner is already open: fd = %d\n", s->fd);
+		return SANE_STATUS_GOOD;	/* no need to open the scanner */
+	}
+
+	if (s->hw->connection == SANE_EPSON_NET) {
+		unsigned char buf[5];
+
+		/* device name has the form net:ipaddr */
+		status = sanei_tcp_open(&s->hw->sane.name[4], 1865, &s->fd);
+		if (status == SANE_STATUS_GOOD) {
+
+			ssize_t read;
+			struct timeval tv;
+
+			tv.tv_sec = 5;
+			tv.tv_usec = 0;
+
+			setsockopt(s->fd, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv,  sizeof(tv));
+
+			s->netlen = 0;
+
+			DBG(32, "awaiting welcome message\n");
+
+			/* the scanner sends a kind of welcome msg */
+			read = e2_recv(s, buf, 5, &status);
+			if (read != 5) {
+				sanei_tcp_close(s->fd);
+				s->fd = -1;
+				return SANE_STATUS_IO_ERROR;
+			}
+
+			DBG(32, "welcome message received, locking the scanner...\n");
+
+			/* lock the scanner for use by sane */
+			status = sanei_epson_net_lock(s);
+			if (status != SANE_STATUS_GOOD) {
+				DBG(1, "%s cannot lock scanner: %s\n", s->hw->sane.name,
+					sane_strstatus(status));
+
+				sanei_tcp_close(s->fd);
+				s->fd = -1;
+
+				return status;
+			}
+
+			DBG(32, "scanner locked\n");
+		}
+		
+	} else if (s->hw->connection == SANE_EPSON_SCSI)
+		status = sanei_scsi_open(s->hw->sane.name, &s->fd,
+					 sanei_epson2_scsi_sense_handler,
+					 NULL);
+	else if (s->hw->connection == SANE_EPSON_PIO)
+		/* device name has the form pio:0xnnn */
+		status = sanei_pio_open(&s->hw->sane.name[4], &s->fd);
+
+	else if (s->hw->connection == SANE_EPSON_USB)
+		status = sanei_usb_open(s->hw->sane.name, &s->fd);
+
+	if (status == SANE_STATUS_ACCESS_DENIED) {
+		DBG(1, "please check that you have permissions on the device.\n");
+		DBG(1, "if this is a multi-function device with a printer,\n");
+		DBG(1, "disable any conflicting driver (like usblp).\n");
+	}
+
+	if (status != SANE_STATUS_GOOD) 
+		DBG(1, "%s open failed: %s\n", s->hw->sane.name,
+			sane_strstatus(status));
+	else
+		DBG(5, "scanner opened\n");
+
+	return status;
+}
+
+static SANE_Status detect_scsi(struct Epson_Scanner *s)
+{
+	SANE_Status status;
+	struct Epson_Device *dev = s->hw;
+
+	char buf[INQUIRY_BUF_SIZE + 1];
+	size_t buf_size = INQUIRY_BUF_SIZE;
+
+	char *vendor = buf + 8;
+	char *model = buf + 16;
+	char *rev = buf + 32;
+
+	status = sanei_epson2_scsi_inquiry(s->fd, buf, &buf_size);
+	if (status != SANE_STATUS_GOOD) {
+		DBG(1, "%s: inquiry failed: %s\n", __func__,
+		    sane_strstatus(status));
+		return status;
+	}
+
+	buf[INQUIRY_BUF_SIZE] = 0;
+	DBG(1, "inquiry data:\n");
+	DBG(1, " vendor  : %.8s\n", vendor);
+	DBG(1, " model   : %.16s\n", model);
+	DBG(1, " revision: %.4s\n", rev);
+
+	if (buf[0] != TYPE_PROCESSOR) {
+		DBG(1, "%s: device is not of processor type (%d)\n",
+		    __func__, buf[0]);
+		return SANE_STATUS_INVAL;
+	}
+
+	if (strncmp(vendor, "EPSON", 5) != 0) {
+		DBG(1,
+		    "%s: device doesn't look like an EPSON scanner\n",
+		    __func__);
+		return SANE_STATUS_INVAL;
+	}
+
+	if (strncmp(model, "SCANNER ", 8) != 0
+	    && strncmp(model, "FilmScan 200", 12) != 0
+	    && strncmp(model, "Perfection", 10) != 0
+	    && strncmp(model, "Expression", 10) != 0
+	    && strncmp(model, "GT", 2) != 0) {
+		DBG(1, "%s: this EPSON scanner is not supported\n",
+		    __func__);
+		return SANE_STATUS_INVAL;
+	}
+
+	if (strncmp(model, "FilmScan 200", 12) == 0) {
+		dev->sane.type = "film scanner";
+		e2_set_model(s, (unsigned char *) model, 12);
+	}
+
+	/* Issue a test unit ready SCSI command. The FilmScan 200
+	 * requires it for a sort of "wake up". We might eventually
+	 * get the return code and reissue it in case of failure.
+	 */
+	sanei_epson2_scsi_test_unit_ready(s->fd);
+
+	return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+detect_usb(struct Epson_Scanner *s)
+{
+	SANE_Status status;
+	int vendor, product;
+	int i, numIds;
+	SANE_Bool is_valid;
+
+	/* if the sanei_usb_get_vendor_product call is not supported,
+	 * then we just ignore this and rely on the user to config
+	 * the correct device.
+	 */
+
+	status = sanei_usb_get_vendor_product(s->fd, &vendor, &product);
+	if (status != SANE_STATUS_GOOD) {
+		DBG(1, "the device cannot be verified - will continue\n");
+	 	return SANE_STATUS_GOOD;
+	}
+	
+	/* check the vendor ID to see if we are dealing with an EPSON device */
+	if (vendor != SANE_EPSON_VENDOR_ID) {
+		/* this is not a supported vendor ID */
+		DBG(1, "not an Epson device at %s (vendor id=0x%x)\n",
+			s->hw->sane.name, vendor);
+		return SANE_STATUS_INVAL;
+	}
+
+	numIds = sanei_epson_getNumberOfUSBProductIds();
+	is_valid = SANE_FALSE;
+	i = 0;
+
+	/* check all known product IDs to verify that we know
+	   about the device */
+	while (i != numIds && !is_valid) {
+		if (product == sanei_epson_usb_product_ids[i])
+			is_valid = SANE_TRUE;
+		i++;
+	}
+
+	if (is_valid == SANE_FALSE) {
+		DBG(1, "the device at %s is not a supported (product id=0x%x)\n",
+			s->hw->sane.name, product);
+		return SANE_STATUS_INVAL;
+	}
+	
+	DBG(1, "found valid Epson scanner: 0x%x/0x%x (vendorID/productID)\n",
+		vendor, product);
+
+	return SANE_STATUS_GOOD;	    
+}
+
+static int num_devices;		/* number of scanners attached to backend */
+static Epson_Device *first_dev;	/* first EPSON scanner in list */
+
+static struct Epson_Scanner *
+scanner_create(struct Epson_Device *dev, SANE_Status *status)
+{
+	struct Epson_Scanner *s;
+
+	s = malloc(sizeof(struct Epson_Scanner));
+	if (s == NULL) {
+		*status = SANE_STATUS_NO_MEM;
+		return NULL;
+	}
+
+	memset(s, 0x00, sizeof(struct Epson_Scanner));
+
+	s->fd = -1;
+	s->hw = dev;
+
+	return s;
+}
+
+static struct Epson_Scanner *
+device_detect(const char *name, int type, SANE_Status *status)
+{
+	struct Epson_Scanner *s;
+	struct Epson_Device *dev;
+
+	/* try to find the device in our list */
+	for (dev = first_dev; dev; dev = dev->next) {
+		if (strcmp(dev->sane.name, name) == 0) {
+
+			/* the device might have been just probed,
+			 * sleep a bit.
+			 */
+			if (dev->connection == SANE_EPSON_NET)
+				sleep(1);
+
+			return scanner_create(dev, status);
+		}
+	}
+
+	if (type == SANE_EPSON_NODEV) {
+		*status = SANE_STATUS_INVAL;
+		return NULL;
+	}
+	
+	/* alloc and clear our device structure */
+	dev = malloc(sizeof(*dev));
+	if (!dev) {
+		*status = SANE_STATUS_NO_MEM;
+		return NULL;
+	}
+	memset(dev, 0x00, sizeof(struct Epson_Device));
+
+	s = scanner_create(dev, status);
+	if (s == NULL)
+		return NULL;
+
+	e2_dev_init(dev, name, type);
+
+	*status = open_scanner(s);
+	if (*status != SANE_STATUS_GOOD) {
+		free(s);
+		return NULL;
+	}
+
+	/* from now on, close_scanner() must be called */
+
+	/* SCSI and USB requires special care */
+	if (dev->connection == SANE_EPSON_SCSI) {
+
+		*status = detect_scsi(s);
+
+	} else if (dev->connection == SANE_EPSON_USB) {
+
+		*status = detect_usb(s);
+	}
+
+	if (*status != SANE_STATUS_GOOD)
+		goto close;
+
+	/* set name and model (if not already set) */
+	if (dev->model == NULL)
+		e2_set_model(s, (unsigned char *) "generic", 7);
+
+	dev->name = strdup(name);
+	dev->sane.name = dev->name;
+
+	/* ESC @, reset */
+	*status = esci_reset(s);
+	if (*status != SANE_STATUS_GOOD)
+		goto close;
+
+	*status = e2_discover_capabilities(s);
+	if (*status != SANE_STATUS_GOOD)
+		goto close;
+
+	if (source_list[0] == NULL || dev->dpi_range.min == 0) {
+		DBG(1, "something is wrong in the discovery process, aborting.\n");
+		*status = SANE_STATUS_IO_ERROR;
+		goto close;
+	}
+
+	e2_dev_post_init(dev);
+
+	*status = esci_reset(s);
+	if (*status != SANE_STATUS_GOOD)
+		goto close;
+
+	DBG(1, "scanner model: %s\n", dev->model);
+
+	/* add this scanner to the device list */
+
+	num_devices++;
+	dev->next = first_dev;
+	first_dev = dev;
+
+	return s;
+
+close:
+      	close_scanner(s);
+	free(s);
+	return NULL;
+}
+
+
+static SANE_Status
+attach(const char *name, int type)
+{
+	SANE_Status status;
+	Epson_Scanner *s;
+
+	DBG(7, "%s: devname = %s, type = %d\n", __func__, name, type);
+
+	s = device_detect(name, type, &status);
+	if(s == NULL)
+		return status;
+
+      	close_scanner(s);
+	free(s);
+	return status;
+}
+
+static SANE_Status
+attach_one_scsi(const char *dev)
+{
+	DBG(7, "%s: dev = %s\n", __func__, dev);
+	return attach(dev, SANE_EPSON_SCSI);
+}
+
+SANE_Status
+attach_one_usb(const char *dev)
+{
+	DBG(7, "%s: dev = %s\n", __func__, dev);
+	return attach(dev, SANE_EPSON_USB);
+}
+
+static SANE_Status
+attach_one_net(const char *dev)
+{
+        char name[39+4]; 
+
+	DBG(7, "%s: dev = %s\n", __func__, dev);
+
+	strcpy(name, "net:");
+	strcat(name, dev);
+	return attach(name, SANE_EPSON_NET);
+}
+
+static SANE_Status
+attach_one_pio(const char *dev)
+{
+	DBG(7, "%s: dev = %s\n", __func__, dev);
+	return attach(dev, SANE_EPSON_PIO);
+}
+
+static SANE_Status
+attach_one_config(SANEI_Config __sane_unused__ *config, const char *line)
+{
+	int vendor, product;
+
+	int len = strlen(line);
+
+	DBG(7, "%s: len = %d, line = %s\n", __func__, len, line);
+	
+	if (sscanf(line, "usb %i %i", &vendor, &product) == 2) {
+		/* add the vendor and product IDs to the list of
+		   known devices before we call the attach function */
+
+		int numIds = sanei_epson_getNumberOfUSBProductIds();
+
+		if (vendor != 0x4b8)
+			return SANE_STATUS_INVAL; /* this is not an EPSON device */
+
+		sanei_epson_usb_product_ids[numIds - 1] = product;
+		sanei_usb_attach_matching_devices(line, attach_one_usb);
+
+	} else if (strncmp(line, "usb", 3) == 0 && len == 3) {
+
+		int i, numIds;
+
+		numIds = sanei_epson_getNumberOfUSBProductIds();
+
+		for (i = 0; i < numIds; i++) {
+			sanei_usb_find_devices(0x4b8,
+					sanei_epson_usb_product_ids[i], attach_one_usb);
+		}
+
+	} else if (strncmp(line, "net", 3) == 0) {
+
+		/* remove the "net" sub string */
+		const char *name = sanei_config_skip_whitespace(line + 3);
+
+		if (strncmp(name, "autodiscovery", 13) == 0)
+			e2_network_discovery();
+		else
+			attach_one_net(name);
+
+	} else if (strncmp(line, "pio", 3) == 0) {
+
+		/* remove the "pio" sub string */
+		const char *name = sanei_config_skip_whitespace(line + 3);
+
+		attach_one_pio(name);
+
+	} else {
+		sanei_config_attach_matching_devices(line, attach_one_scsi);
+	}
+
+	return SANE_STATUS_GOOD;
+}
+
+static void
+free_devices(void)
+{
+	Epson_Device *dev, *next;
+
+	DBG(5, "%s\n", __func__);
+
+	for (dev = first_dev; dev; dev = next) {
+		next = dev->next;
+		free(dev->name);
+		free(dev->model);
+		free(dev);
+	}
+
+	free(devlist);
+
+	first_dev = NULL;
+}
+
+static void
+probe_devices(void)
+{
+	DBG(5, "%s\n", __func__);
+
+	free_devices();
+
+	sanei_configure_attach(EPSON2_CONFIG_FILE, NULL,
+		attach_one_config);
+}
+
+SANE_Status
+sane_init(SANE_Int *version_code, SANE_Auth_Callback __sane_unused__ authorize)
+{
+	DBG_INIT();
+	DBG(2, "%s: " PACKAGE " " VERSION "\n", __func__);
+
+	DBG(1, "epson2 backend, version %i.%i.%i\n",
+		EPSON2_VERSION, EPSON2_REVISION, EPSON2_BUILD);
+
+	if (version_code != NULL)
+		*version_code = SANE_VERSION_CODE(SANE_CURRENT_MAJOR, V_MINOR,
+					  EPSON2_BUILD);
+
+	sanei_usb_init();
+
+	return SANE_STATUS_GOOD;
+}
+
+/* Clean up the list of attached scanners. */
+void
+sane_exit(void)
+{
+	DBG(5, "%s\n", __func__);
+	free_devices();
+}
+
+SANE_Status
+sane_get_devices(const SANE_Device ***device_list, SANE_Bool __sane_unused__ local_only)
+{
+	Epson_Device *dev;
+	int i;
+
+	DBG(5, "%s\n", __func__);
+
+	probe_devices();
+
+	devlist = malloc((num_devices + 1) * sizeof(devlist[0]));
+	if (!devlist) {
+		DBG(1, "out of memory (line %d)\n", __LINE__);
+		return SANE_STATUS_NO_MEM;
+	}
+
+	DBG(5, "%s - results:\n", __func__);
+
+	for (i = 0, dev = first_dev; i < num_devices && dev; dev = dev->next, i++) {
+		DBG(1, " %d (%d): %s\n", i, dev->connection, dev->model);
+		devlist[i] = &dev->sane;
+	}
+
+	devlist[i] = NULL;
+
+	*device_list = devlist;
+
+	return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+init_options(Epson_Scanner *s)
+{
+	int i;
+
+	for (i = 0; i < NUM_OPTIONS; i++) {
+		s->opt[i].size = sizeof(SANE_Word);
+		s->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+	}
+
+	s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
+	s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
+	s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
+	s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
+	s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
+
+	/* "Scan Mode" group: */
+
+	s->opt[OPT_MODE_GROUP].title = SANE_I18N("Scan Mode");
+	s->opt[OPT_MODE_GROUP].desc = "";
+	s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
+	s->opt[OPT_MODE_GROUP].cap = 0;
+
+	/* scan mode */
+	s->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
+	s->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
+	s->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
+	s->opt[OPT_MODE].type = SANE_TYPE_STRING;
+	s->opt[OPT_MODE].size = max_string_size(mode_list);
+	s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+	s->opt[OPT_MODE].constraint.string_list = mode_list;
+	s->val[OPT_MODE].w = 0;	/* Binary */
+
+	/* disable infrared on unsupported scanners */
+	if (!e2_model(s, "GT-X800") && !e2_model(s, "GT-X700") && !e2_model(s, "GT-X900"))
+		mode_list[MODE_INFRARED] = NULL;
+
+	/* bit depth */
+	s->opt[OPT_BIT_DEPTH].name = SANE_NAME_BIT_DEPTH;
+	s->opt[OPT_BIT_DEPTH].title = SANE_TITLE_BIT_DEPTH;
+	s->opt[OPT_BIT_DEPTH].desc = SANE_DESC_BIT_DEPTH;
+	s->opt[OPT_BIT_DEPTH].type = SANE_TYPE_INT;
+	s->opt[OPT_BIT_DEPTH].unit = SANE_UNIT_NONE;
+	s->opt[OPT_BIT_DEPTH].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+	s->opt[OPT_BIT_DEPTH].constraint.word_list = s->hw->depth_list;
+	s->opt[OPT_BIT_DEPTH].cap |= SANE_CAP_INACTIVE;
+	s->val[OPT_BIT_DEPTH].w = s->hw->depth_list[1];	/* the first "real" element is the default */
+
+	if (s->hw->depth_list[0] == 1)	/* only one element in the list -> hide the option */
+		s->opt[OPT_BIT_DEPTH].cap |= SANE_CAP_INACTIVE;
+
+	/* halftone */
+	s->opt[OPT_HALFTONE].name = SANE_NAME_HALFTONE;
+	s->opt[OPT_HALFTONE].title = SANE_TITLE_HALFTONE;
+	s->opt[OPT_HALFTONE].desc = SANE_I18N("Selects the halftone.");
+
+	s->opt[OPT_HALFTONE].type = SANE_TYPE_STRING;
+	s->opt[OPT_HALFTONE].size = max_string_size(halftone_list_7);
+	s->opt[OPT_HALFTONE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+
+	/* XXX use defines */
+	if (s->hw->level >= 7)
+		s->opt[OPT_HALFTONE].constraint.string_list = halftone_list_7;
+	else if (s->hw->level >= 4)
+		s->opt[OPT_HALFTONE].constraint.string_list = halftone_list_4;
+	else
+		s->opt[OPT_HALFTONE].constraint.string_list = halftone_list;
+
+	s->val[OPT_HALFTONE].w = 1;	/* Halftone A */
+
+	if (!s->hw->cmd->set_halftoning)
+		s->opt[OPT_HALFTONE].cap |= SANE_CAP_INACTIVE;
+
+	/* dropout */
+	s->opt[OPT_DROPOUT].name = "dropout";
+	s->opt[OPT_DROPOUT].title = SANE_I18N("Dropout");
+	s->opt[OPT_DROPOUT].desc = SANE_I18N("Selects the dropout.");
+
+	s->opt[OPT_DROPOUT].type = SANE_TYPE_STRING;
+	s->opt[OPT_DROPOUT].size = max_string_size(dropout_list);
+	s->opt[OPT_DROPOUT].cap |= SANE_CAP_ADVANCED;
+	s->opt[OPT_DROPOUT].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+	s->opt[OPT_DROPOUT].constraint.string_list = dropout_list;
+	s->val[OPT_DROPOUT].w = 0;	/* None */
+
+	/* brightness */
+	s->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
+	s->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
+	s->opt[OPT_BRIGHTNESS].desc = SANE_I18N("Selects the brightness.");
+
+	s->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
+	s->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE;
+	s->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
+	s->opt[OPT_BRIGHTNESS].constraint.range = &s->hw->cmd->bright_range;
+	s->val[OPT_BRIGHTNESS].w = 0;	/* Normal */
+
+	if (!s->hw->cmd->set_bright)
+		s->opt[OPT_BRIGHTNESS].cap |= SANE_CAP_INACTIVE;
+
+	/* sharpness */
+	s->opt[OPT_SHARPNESS].name = "sharpness";
+	s->opt[OPT_SHARPNESS].title = SANE_I18N("Sharpness");
+	s->opt[OPT_SHARPNESS].desc = "";
+
+	s->opt[OPT_SHARPNESS].type = SANE_TYPE_INT;
+	s->opt[OPT_SHARPNESS].unit = SANE_UNIT_NONE;
+	s->opt[OPT_SHARPNESS].constraint_type = SANE_CONSTRAINT_RANGE;
+	s->opt[OPT_SHARPNESS].constraint.range = &outline_emphasis_range;
+	s->val[OPT_SHARPNESS].w = 0;	/* Normal */
+
+	if (!s->hw->cmd->set_outline_emphasis)
+		s->opt[OPT_SHARPNESS].cap |= SANE_CAP_INACTIVE;
+
+	/* gamma */
+	s->opt[OPT_GAMMA_CORRECTION].name = SANE_NAME_GAMMA_CORRECTION;
+	s->opt[OPT_GAMMA_CORRECTION].title = SANE_TITLE_GAMMA_CORRECTION;
+	s->opt[OPT_GAMMA_CORRECTION].desc = SANE_DESC_GAMMA_CORRECTION;
+
+	s->opt[OPT_GAMMA_CORRECTION].type = SANE_TYPE_STRING;
+	s->opt[OPT_GAMMA_CORRECTION].constraint_type =
+		SANE_CONSTRAINT_STRING_LIST;
+
+	/*
+	 * special handling for D1 function level - at this time I'm not
+	 * testing for D1, I'm just assuming that all D level scanners will
+	 * behave the same way. This has to be confirmed with the next D-level
+	 * scanner
+	 */
+	if (s->hw->cmd->level[0] == 'D') {
+		s->opt[OPT_GAMMA_CORRECTION].size =
+			max_string_size(gamma_list_d);
+		s->opt[OPT_GAMMA_CORRECTION].constraint.string_list =
+			gamma_list_d;
+		s->val[OPT_GAMMA_CORRECTION].w = 1;	/* Default */
+		gamma_userdefined = gamma_userdefined_d;
+		gamma_params = gamma_params_d;
+	} else {
+		s->opt[OPT_GAMMA_CORRECTION].size =
+			max_string_size(gamma_list_ab);
+		s->opt[OPT_GAMMA_CORRECTION].constraint.string_list =
+			gamma_list_ab;
+		s->val[OPT_GAMMA_CORRECTION].w = 0;	/* Default */
+		gamma_userdefined = gamma_userdefined_ab;
+		gamma_params = gamma_params_ab;
+	}
+
+	if (!s->hw->cmd->set_gamma)
+		s->opt[OPT_GAMMA_CORRECTION].cap |= SANE_CAP_INACTIVE;
+
+	/* red gamma vector */
+	s->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
+	s->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
+	s->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
+
+	s->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
+	s->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
+	s->opt[OPT_GAMMA_VECTOR_R].size = 256 * sizeof(SANE_Word);
+	s->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
+	s->opt[OPT_GAMMA_VECTOR_R].constraint.range = &u8_range;
+	s->val[OPT_GAMMA_VECTOR_R].wa = &s->gamma_table[0][0];
+
+	/* green gamma vector */
+	s->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
+	s->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
+	s->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
+
+	s->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
+	s->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
+	s->opt[OPT_GAMMA_VECTOR_G].size = 256 * sizeof(SANE_Word);
+	s->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
+	s->opt[OPT_GAMMA_VECTOR_G].constraint.range = &u8_range;
+	s->val[OPT_GAMMA_VECTOR_G].wa = &s->gamma_table[1][0];
+
+
+	/* red gamma vector */
+	s->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
+	s->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
+	s->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
+
+	s->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
+	s->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
+	s->opt[OPT_GAMMA_VECTOR_B].size = 256 * sizeof(SANE_Word);
+	s->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
+	s->opt[OPT_GAMMA_VECTOR_B].constraint.range = &u8_range;
+	s->val[OPT_GAMMA_VECTOR_B].wa = &s->gamma_table[2][0];
+
+	if (s->hw->cmd->set_gamma_table
+	    && gamma_userdefined[s->val[OPT_GAMMA_CORRECTION].w] ==
+	    SANE_TRUE) {
+
+		s->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
+		s->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
+		s->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
+	} else {
+
+		s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
+		s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
+		s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
+	}
+
+	/* initialize the Gamma tables */
+	memset(&s->gamma_table[0], 0, 256 * sizeof(SANE_Word));
+	memset(&s->gamma_table[1], 0, 256 * sizeof(SANE_Word));
+	memset(&s->gamma_table[2], 0, 256 * sizeof(SANE_Word));
+
+/*	memset(&s->gamma_table[3], 0, 256 * sizeof(SANE_Word)); */
+	for (i = 0; i < 256; i++) {
+		s->gamma_table[0][i] = i;
+		s->gamma_table[1][i] = i;
+		s->gamma_table[2][i] = i;
+
+/*		s->gamma_table[3][i] = i; */
+	}
+
+
+	/* color correction */
+	s->opt[OPT_COLOR_CORRECTION].name = "color-correction";
+	s->opt[OPT_COLOR_CORRECTION].title = SANE_I18N("Color correction");
+	s->opt[OPT_COLOR_CORRECTION].desc =
+		SANE_I18N("Sets the color correction table for the selected output device.");
+
+	s->opt[OPT_COLOR_CORRECTION].type = SANE_TYPE_STRING;
+	s->opt[OPT_COLOR_CORRECTION].size = max_string_size(correction_list);
+	s->opt[OPT_COLOR_CORRECTION].cap |= SANE_CAP_ADVANCED;
+	s->opt[OPT_COLOR_CORRECTION].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+	s->opt[OPT_COLOR_CORRECTION].constraint.string_list = correction_list;
+	s->val[OPT_COLOR_CORRECTION].w = CORR_AUTO;
+
+	if (!s->hw->cmd->set_color_correction)
+		s->opt[OPT_COLOR_CORRECTION].cap |= SANE_CAP_INACTIVE;
+
+	/* resolution */
+	s->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
+	s->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
+	s->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
+
+	s->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
+	s->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
+	s->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+	s->opt[OPT_RESOLUTION].constraint.word_list = s->hw->resolution_list;
+	s->val[OPT_RESOLUTION].w = s->hw->dpi_range.min;
+
+	/* threshold */
+	s->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD;
+	s->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
+	s->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD;
+
+	s->opt[OPT_THRESHOLD].type = SANE_TYPE_INT;
+	s->opt[OPT_THRESHOLD].unit = SANE_UNIT_NONE;
+	s->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
+	s->opt[OPT_THRESHOLD].constraint.range = &u8_range;
+	s->val[OPT_THRESHOLD].w = 0x80;
+
+	if (!s->hw->cmd->set_threshold)
+		s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
+
+
+	/* "Advanced" group: */
+	s->opt[OPT_ADVANCED_GROUP].title = SANE_I18N("Advanced");
+	s->opt[OPT_ADVANCED_GROUP].desc = "";
+	s->opt[OPT_ADVANCED_GROUP].type = SANE_TYPE_GROUP;
+	s->opt[OPT_ADVANCED_GROUP].cap = SANE_CAP_ADVANCED;
+
+	/* "Color correction" group: */
+	s->opt[OPT_CCT_GROUP].title = SANE_I18N("Color correction");
+	s->opt[OPT_CCT_GROUP].desc = "";
+	s->opt[OPT_CCT_GROUP].type = SANE_TYPE_GROUP;
+	s->opt[OPT_CCT_GROUP].cap = SANE_CAP_ADVANCED;
+
+	/* XXX disabled for now */
+	s->opt[OPT_CCT_MODE].name = "cct-type";
+	s->opt[OPT_CCT_MODE].title = "CCT Profile Type";
+	s->opt[OPT_CCT_MODE].desc = "Color correction profile type";
+	s->opt[OPT_CCT_MODE].type = SANE_TYPE_STRING;
+	s->opt[OPT_CCT_MODE].cap  |= SANE_CAP_ADVANCED | SANE_CAP_INACTIVE;
+	s->opt[OPT_CCT_MODE].size = max_string_size(cct_mode_list);
+	s->opt[OPT_CCT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+	s->opt[OPT_CCT_MODE].constraint.string_list = cct_mode_list;
+	s->val[OPT_CCT_MODE].w = CCT_AUTO;
+
+	s->opt[OPT_CCT_PROFILE].name = "cct-profile";
+	s->opt[OPT_CCT_PROFILE].title = "CCT Profile";
+	s->opt[OPT_CCT_PROFILE].desc = "Color correction profile data";
+	s->opt[OPT_CCT_PROFILE].type = SANE_TYPE_FIXED;
+	s->opt[OPT_CCT_PROFILE].cap  |= SANE_CAP_ADVANCED;
+	s->opt[OPT_CCT_PROFILE].unit = SANE_UNIT_NONE;
+	s->opt[OPT_CCT_PROFILE].constraint_type = SANE_CONSTRAINT_RANGE;
+	s->opt[OPT_CCT_PROFILE].constraint.range = &fx_range;
+	s->opt[OPT_CCT_PROFILE].size = 9 * sizeof(SANE_Word);
+	s->val[OPT_CCT_PROFILE].wa = s->cct_table;
+
+/*	if (!s->hw->cmd->set_color_correction)
+		s->opt[OPT_FILM_TYPE].cap |= SANE_CAP_INACTIVE;
+*/	
+
+	/* mirror */
+	s->opt[OPT_MIRROR].name = "mirror";
+	s->opt[OPT_MIRROR].title = SANE_I18N("Mirror image");
+	s->opt[OPT_MIRROR].desc = SANE_I18N("Mirror the image.");
+
+	s->opt[OPT_MIRROR].type = SANE_TYPE_BOOL;
+	s->val[OPT_MIRROR].w = SANE_FALSE;
+
+	if (!s->hw->cmd->mirror_image)
+		s->opt[OPT_MIRROR].cap |= SANE_CAP_INACTIVE;
+
+	/* auto area segmentation */
+	s->opt[OPT_AAS].name = "auto-area-segmentation";
+	s->opt[OPT_AAS].title = SANE_I18N("Auto area segmentation");
+	s->opt[OPT_AAS].desc =
+		"Enables different dithering modes in image and text areas";
+
+	s->opt[OPT_AAS].type = SANE_TYPE_BOOL;
+	s->val[OPT_AAS].w = SANE_TRUE;
+
+	if (!s->hw->cmd->control_auto_area_segmentation)
+		s->opt[OPT_AAS].cap |= SANE_CAP_INACTIVE;
+
+	/* "Preview settings" group: */
+	s->opt[OPT_PREVIEW_GROUP].title = SANE_TITLE_PREVIEW;
+	s->opt[OPT_PREVIEW_GROUP].desc = "";
+	s->opt[OPT_PREVIEW_GROUP].type = SANE_TYPE_GROUP;
+	s->opt[OPT_PREVIEW_GROUP].cap = SANE_CAP_ADVANCED;
+
+	/* preview */
+	s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
+	s->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
+	s->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
+
+	s->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
+	s->val[OPT_PREVIEW].w = SANE_FALSE;
+
+	/* "Geometry" group: */
+	s->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N("Geometry");
+	s->opt[OPT_GEOMETRY_GROUP].desc = "";
+	s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
+	s->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
+
+	/* top-left x */
+	s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
+	s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
+	s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
+
+	s->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
+	s->opt[OPT_TL_X].unit = SANE_UNIT_MM;
+	s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
+	s->opt[OPT_TL_X].constraint.range = s->hw->x_range;
+	s->val[OPT_TL_X].w = 0;
+
+	/* top-left y */
+	s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
+	s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
+	s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
+
+	s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
+	s->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
+	s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+	s->opt[OPT_TL_Y].constraint.range = s->hw->y_range;
+	s->val[OPT_TL_Y].w = 0;
+
+	/* bottom-right x */
+	s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
+	s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
+	s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
+
+	s->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
+	s->opt[OPT_BR_X].unit = SANE_UNIT_MM;
+	s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
+	s->opt[OPT_BR_X].constraint.range = s->hw->x_range;
+	s->val[OPT_BR_X].w = s->hw->x_range->max;
+
+	/* bottom-right y */
+	s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
+	s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
+	s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
+
+	s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
+	s->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
+	s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+	s->opt[OPT_BR_Y].constraint.range = s->hw->y_range;
+	s->val[OPT_BR_Y].w = s->hw->y_range->max;
+
+	/* "Optional equipment" group: */
+	s->opt[OPT_EQU_GROUP].title = SANE_I18N("Optional equipment");
+	s->opt[OPT_EQU_GROUP].desc = "";
+	s->opt[OPT_EQU_GROUP].type = SANE_TYPE_GROUP;
+	s->opt[OPT_EQU_GROUP].cap = SANE_CAP_ADVANCED;
+
+	/* source */
+	s->opt[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE;
+	s->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE;
+	s->opt[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE;
+
+	s->opt[OPT_SOURCE].type = SANE_TYPE_STRING;
+	s->opt[OPT_SOURCE].size = max_string_size(source_list);
+
+	s->opt[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+	s->opt[OPT_SOURCE].constraint.string_list = source_list;
+
+	if (!s->hw->extension)
+		s->opt[OPT_SOURCE].cap |= SANE_CAP_INACTIVE;
+
+	s->val[OPT_SOURCE].w = 0;	/* always use Flatbed as default */
+
+
+	/* film type */
+	s->opt[OPT_FILM_TYPE].name = "film-type";
+	s->opt[OPT_FILM_TYPE].title = SANE_I18N("Film type");
+	s->opt[OPT_FILM_TYPE].desc = "";
+	s->opt[OPT_FILM_TYPE].type = SANE_TYPE_STRING;
+	s->opt[OPT_FILM_TYPE].size = max_string_size(film_list);
+	s->opt[OPT_FILM_TYPE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+	s->opt[OPT_FILM_TYPE].constraint.string_list = film_list;
+	s->val[OPT_FILM_TYPE].w = 0;
+
+	if (!s->hw->cmd->set_bay)
+		s->opt[OPT_FILM_TYPE].cap |= SANE_CAP_INACTIVE;
+
+	/* focus position */
+	s->opt[OPT_FOCUS].name = SANE_EPSON_FOCUS_NAME;
+	s->opt[OPT_FOCUS].title = SANE_EPSON_FOCUS_TITLE;
+	s->opt[OPT_FOCUS].desc = SANE_EPSON_FOCUS_DESC;
+	s->opt[OPT_FOCUS].type = SANE_TYPE_STRING;
+	s->opt[OPT_FOCUS].size = max_string_size(focus_list);
+	s->opt[OPT_FOCUS].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+	s->opt[OPT_FOCUS].constraint.string_list = focus_list;
+	s->val[OPT_FOCUS].w = 0;
+	s->opt[OPT_FOCUS].cap |= SANE_CAP_ADVANCED;
+
+	if (s->hw->focusSupport == SANE_TRUE)
+		s->opt[OPT_FOCUS].cap &= ~SANE_CAP_INACTIVE;
+	else
+		s->opt[OPT_FOCUS].cap |= SANE_CAP_INACTIVE;
+
+	/* forward feed / eject */
+	s->opt[OPT_EJECT].name = "eject";
+	s->opt[OPT_EJECT].title = SANE_I18N("Eject");
+	s->opt[OPT_EJECT].desc = SANE_I18N("Eject the sheet in the ADF");
+	s->opt[OPT_EJECT].type = SANE_TYPE_BUTTON;
+
+	if ((!s->hw->ADF) && (!s->hw->cmd->set_bay)) {	/* Hack: Using set_bay to indicate. */
+		s->opt[OPT_EJECT].cap |= SANE_CAP_INACTIVE;
+	}
+
+
+	/* auto forward feed / eject */
+	s->opt[OPT_AUTO_EJECT].name = "auto-eject";
+	s->opt[OPT_AUTO_EJECT].title = SANE_I18N("Auto eject");
+	s->opt[OPT_AUTO_EJECT].desc =
+		SANE_I18N("Eject document after scanning");
+
+	s->opt[OPT_AUTO_EJECT].type = SANE_TYPE_BOOL;
+	s->val[OPT_AUTO_EJECT].w = SANE_FALSE;
+
+	if (!s->hw->ADF)
+		s->opt[OPT_AUTO_EJECT].cap |= SANE_CAP_INACTIVE;
+
+
+	s->opt[OPT_ADF_MODE].name = "adf-mode";
+	s->opt[OPT_ADF_MODE].title = SANE_I18N("ADF Mode");
+	s->opt[OPT_ADF_MODE].desc =
+		SANE_I18N("Selects the ADF mode (simplex/duplex)");
+	s->opt[OPT_ADF_MODE].type = SANE_TYPE_STRING;
+	s->opt[OPT_ADF_MODE].size = max_string_size(adf_mode_list);
+	s->opt[OPT_ADF_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+	s->opt[OPT_ADF_MODE].constraint.string_list = adf_mode_list;
+	s->val[OPT_ADF_MODE].w = 0;	/* simplex */
+
+	if ((!s->hw->ADF) || (s->hw->duplex == SANE_FALSE))
+		s->opt[OPT_ADF_MODE].cap |= SANE_CAP_INACTIVE;
+
+	/* select bay */
+	s->opt[OPT_BAY].name = "bay";
+	s->opt[OPT_BAY].title = SANE_I18N("Bay");
+	s->opt[OPT_BAY].desc = SANE_I18N("Select bay to scan");
+	s->opt[OPT_BAY].type = SANE_TYPE_STRING;
+	s->opt[OPT_BAY].size = max_string_size(bay_list);
+	s->opt[OPT_BAY].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+	s->opt[OPT_BAY].constraint.string_list = bay_list;
+	s->val[OPT_BAY].w = 0;	/* Bay 1 */
+
+	if (!s->hw->cmd->set_bay)
+		s->opt[OPT_BAY].cap |= SANE_CAP_INACTIVE;
+
+
+	s->opt[OPT_WAIT_FOR_BUTTON].name = SANE_EPSON_WAIT_FOR_BUTTON_NAME;
+	s->opt[OPT_WAIT_FOR_BUTTON].title = SANE_EPSON_WAIT_FOR_BUTTON_TITLE;
+	s->opt[OPT_WAIT_FOR_BUTTON].desc = SANE_EPSON_WAIT_FOR_BUTTON_DESC;
+
+	s->opt[OPT_WAIT_FOR_BUTTON].type = SANE_TYPE_BOOL;
+	s->opt[OPT_WAIT_FOR_BUTTON].unit = SANE_UNIT_NONE;
+	s->opt[OPT_WAIT_FOR_BUTTON].constraint_type = SANE_CONSTRAINT_NONE;
+	s->opt[OPT_WAIT_FOR_BUTTON].constraint.range = NULL;
+	s->opt[OPT_WAIT_FOR_BUTTON].cap |= SANE_CAP_ADVANCED;
+
+	if (!s->hw->cmd->request_push_button_status)
+		s->opt[OPT_WAIT_FOR_BUTTON].cap |= SANE_CAP_INACTIVE;
+
+	return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_open(SANE_String_Const name, SANE_Handle *handle)
+{
+	SANE_Status status;
+	Epson_Scanner *s = NULL;
+
+	int l = strlen(name);
+
+	DBG(7, "%s: name = %s\n", __func__, name);
+
+	/* probe if empty device name provided */
+	if (l == 0) {
+
+		probe_devices();
+
+		if (first_dev == NULL) {
+			DBG(1, "no device detected\n");
+			return SANE_STATUS_INVAL;
+		}
+
+		s = device_detect(first_dev->sane.name, first_dev->connection,
+					&status);
+		if (s == NULL) {
+			DBG(1, "cannot open a perfectly valid device (%s),"
+				" please report to the authors\n", name);
+			return SANE_STATUS_INVAL;
+		}
+
+	} else {
+
+		if (strncmp(name, "net:", 4) == 0) {
+			s = device_detect(name, SANE_EPSON_NET, &status);
+			if (s == NULL)
+				return status;
+		} else if (strncmp(name, "libusb:", 7) == 0) {
+			s = device_detect(name, SANE_EPSON_USB, &status);
+			if (s == NULL)
+				return status;
+		} else if (strncmp(name, "pio:", 4) == 0) {
+			s = device_detect(name, SANE_EPSON_PIO, &status);
+			if (s == NULL)
+				return status;
+		} else {
+		
+			/* as a last resort, check for a match
+			 * in the device list. This should handle SCSI
+			 * devices and platforms without libusb.
+			 */
+			
+			if (first_dev == NULL)
+				probe_devices();
+
+			s = device_detect(name, SANE_EPSON_NODEV, &status);
+			if (s == NULL) {
+				DBG(1, "invalid device name: %s\n", name);
+				return SANE_STATUS_INVAL;
+			}
+		}		
+	}
+
+
+	/* s is always valid here */
+
+	DBG(1, "handle obtained\n");
+
+	init_options(s);
+
+	*handle = (SANE_Handle) s;
+
+	status = open_scanner(s);
+	if (status != SANE_STATUS_GOOD) {
+		free(s);
+		return status;
+	}
+
+	status = esci_reset(s);
+	if (status != SANE_STATUS_GOOD)
+		close_scanner(s);
+	
+	return status;
+}
+
+void
+sane_close(SANE_Handle handle)
+{
+	int i;
+	Epson_Scanner *s;
+
+	/*
+	 * XXX Test if there is still data pending from
+	 * the scanner. If so, then do a cancel
+	 */
+
+	s = (Epson_Scanner *) handle;
+
+	if (s->fd != -1)
+		close_scanner(s);
+
+	for (i = 0; i < LINES_SHUFFLE_MAX; i++) {
+		if (s->line_buffer[i] != NULL)
+			free(s->line_buffer[i]);
+	}
+
+	free(s);
+}
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor(SANE_Handle handle, SANE_Int option)
+{
+	Epson_Scanner *s = (Epson_Scanner *) handle;
+
+	if (option < 0 || option >= NUM_OPTIONS)
+		return NULL;
+
+	return s->opt + option;
+}
+
+static const SANE_String_Const *
+search_string_list(const SANE_String_Const *list, SANE_String value)
+{
+	while (*list != NULL && strcmp(value, *list) != 0)
+		list++;
+
+	return ((*list == NULL) ? NULL : list);
+}
+
+/*
+    Activate, deactivate an option. Subroutines so we can add
+    debugging info if we want. The change flag is set to TRUE
+    if we changed an option. If we did not change an option,
+    then the value of the changed flag is not modified.
+*/
+
+static void
+activateOption(Epson_Scanner *s, SANE_Int option, SANE_Bool *change)
+{
+	if (!SANE_OPTION_IS_ACTIVE(s->opt[option].cap)) {
+		s->opt[option].cap &= ~SANE_CAP_INACTIVE;
+		*change = SANE_TRUE;
+	}
+}
+
+static void
+deactivateOption(Epson_Scanner *s, SANE_Int option, SANE_Bool *change)
+{
+	if (SANE_OPTION_IS_ACTIVE(s->opt[option].cap)) {
+		s->opt[option].cap |= SANE_CAP_INACTIVE;
+		*change = SANE_TRUE;
+	}
+}
+
+static void
+setOptionState(Epson_Scanner *s, SANE_Bool state, SANE_Int option,
+	       SANE_Bool *change)
+{
+	if (state)
+		activateOption(s, option, change);
+	else
+		deactivateOption(s, option, change);
+}
+
+static SANE_Status
+getvalue(SANE_Handle handle, SANE_Int option, void *value)
+{
+	Epson_Scanner *s = (Epson_Scanner *) handle;
+	SANE_Option_Descriptor *sopt = &(s->opt[option]);
+	Option_Value *sval = &(s->val[option]);
+
+	DBG(17, "%s: option = %d\n", __func__, option);
+
+	switch (option) {
+
+	case OPT_GAMMA_VECTOR_R:
+	case OPT_GAMMA_VECTOR_G:
+	case OPT_GAMMA_VECTOR_B:
+	case OPT_CCT_PROFILE:
+		memcpy(value, sval->wa, sopt->size);
+		break;
+
+	case OPT_NUM_OPTS:
+	case OPT_RESOLUTION:
+	case OPT_TL_X:
+	case OPT_TL_Y:
+	case OPT_BR_X:
+	case OPT_BR_Y:
+	case OPT_MIRROR:
+	case OPT_AAS:
+	case OPT_PREVIEW:
+	case OPT_BRIGHTNESS:
+	case OPT_SHARPNESS:
+	case OPT_AUTO_EJECT:
+	case OPT_THRESHOLD:
+	case OPT_BIT_DEPTH:
+	case OPT_WAIT_FOR_BUTTON:
+		*((SANE_Word *) value) = sval->w;
+		break;
+
+	case OPT_MODE:
+	case OPT_CCT_MODE:
+	case OPT_ADF_MODE:
+	case OPT_HALFTONE:
+	case OPT_DROPOUT:
+	case OPT_SOURCE:
+	case OPT_FILM_TYPE:
+	case OPT_GAMMA_CORRECTION:
+	case OPT_COLOR_CORRECTION:
+	case OPT_BAY:
+	case OPT_FOCUS:
+		strcpy((char *) value, sopt->constraint.string_list[sval->w]);
+		break;
+
+	default:
+		return SANE_STATUS_INVAL;
+	}
+
+	return SANE_STATUS_GOOD;
+}
+
+/*
+ * This routine handles common options between OPT_MODE and
+ * OPT_HALFTONE.  These options are TET (a HALFTONE mode), AAS
+ * - auto area segmentation, and threshold.  Apparently AAS
+ * is some method to differentiate between text and photos.
+ * Or something like that.
+ *
+ * AAS is available when the scan color depth is 1 and the
+ * halftone method is not TET.
+ *
+ * Threshold is available when halftone is NONE, and depth is 1.
+ */
+static void
+handle_depth_halftone(Epson_Scanner *s, SANE_Bool *reload)
+{
+	int hti = s->val[OPT_HALFTONE].w;
+	int mdi = s->val[OPT_MODE].w;
+	SANE_Bool aas = SANE_FALSE;
+	SANE_Bool thresh = SANE_FALSE;
+
+	/* this defaults to false */
+	setOptionState(s, thresh, OPT_THRESHOLD, reload);
+
+	if (!s->hw->cmd->control_auto_area_segmentation)
+		return;
+
+	if (mode_params[mdi].depth == 1) {
+
+		if (halftone_params[hti] != HALFTONE_TET)
+			aas = SANE_TRUE;
+
+		if (halftone_params[hti] == HALFTONE_NONE)
+			thresh = SANE_TRUE;
+	}
+	setOptionState(s, aas, OPT_AAS, reload);
+	setOptionState(s, thresh, OPT_THRESHOLD, reload);
+}
+
+/*
+ * Handles setting the source (flatbed, transparency adapter (TPU),
+ * or auto document feeder (ADF)).
+ *
+ * For newer scanners it also sets the focus according to the
+ * glass / TPU settings.
+ */
+
+static void
+change_source(Epson_Scanner *s, SANE_Int optindex, char *value)
+{
+	int force_max = SANE_FALSE;
+	SANE_Bool dummy;
+
+	DBG(1, "%s: optindex = %d, source = '%s'\n", __func__, optindex,
+	    value);
+
+	/* reset the scanner when we are changing the source setting -
+	   this is necessary for the Perfection 1650 */
+	if (s->hw->need_reset_on_source_change)
+		esci_reset(s);
+
+	s->focusOnGlass = SANE_TRUE;	/* this is the default */
+
+	if (s->val[OPT_SOURCE].w == optindex)
+		return;
+
+	s->val[OPT_SOURCE].w = optindex;
+
+	if (s->val[OPT_TL_X].w == s->hw->x_range->min
+	    && s->val[OPT_TL_Y].w == s->hw->y_range->min
+	    && s->val[OPT_BR_X].w == s->hw->x_range->max
+	    && s->val[OPT_BR_Y].w == s->hw->y_range->max) {
+		force_max = SANE_TRUE;
+	}
+
+	if (strcmp(ADF_STR, value) == 0) {
+		s->hw->x_range = &s->hw->adf_x_range;
+		s->hw->y_range = &s->hw->adf_y_range;
+		s->hw->use_extension = SANE_TRUE;
+		/* disable film type option */
+		deactivateOption(s, OPT_FILM_TYPE, &dummy);
+		s->val[OPT_FOCUS].w = 0;
+		if (s->hw->duplex) {
+			activateOption(s, OPT_ADF_MODE, &dummy);
+		} else {
+			deactivateOption(s, OPT_ADF_MODE, &dummy);
+			s->val[OPT_ADF_MODE].w = 0;
+		}
+
+		DBG(1, "adf activated (%d %d)\n", s->hw->use_extension,
+		    s->hw->duplex);
+
+	} else if (strcmp(TPU_STR, value) == 0 || strcmp(TPU_STR2, value) == 0) {
+	        if (strcmp(TPU_STR, value) == 0) {
+	  	        s->hw->x_range = &s->hw->tpu_x_range;
+		        s->hw->y_range = &s->hw->tpu_y_range;
+			s->hw->TPU2 = SANE_FALSE;
+                }
+	        if (strcmp(TPU_STR2, value) == 0) {
+	  	        s->hw->x_range = &s->hw->tpu2_x_range;
+		        s->hw->y_range = &s->hw->tpu2_y_range;
+			s->hw->TPU2 = SANE_TRUE;
+                }
+		s->hw->use_extension = SANE_TRUE;
+
+		/* enable film type option only if the scanner supports it */
+		if (s->hw->cmd->set_film_type != 0)
+			activateOption(s, OPT_FILM_TYPE, &dummy);
+		else
+			deactivateOption(s, OPT_FILM_TYPE, &dummy);
+
+		/* enable focus position if the scanner supports it */
+		if (s->hw->cmd->set_focus_position != 0) {
+			s->val[OPT_FOCUS].w = 1;
+			s->focusOnGlass = SANE_FALSE;
+		}
+
+		deactivateOption(s, OPT_ADF_MODE, &dummy);
+		deactivateOption(s, OPT_EJECT, &dummy);
+		deactivateOption(s, OPT_AUTO_EJECT, &dummy);
+	} else {
+		/* neither ADF nor TPU active */
+		s->hw->x_range = &s->hw->fbf_x_range;
+		s->hw->y_range = &s->hw->fbf_y_range;
+		s->hw->use_extension = SANE_FALSE;
+
+		/* disable film type option */
+		deactivateOption(s, OPT_FILM_TYPE, &dummy);
+		s->val[OPT_FOCUS].w = 0;
+		deactivateOption(s, OPT_ADF_MODE, &dummy);
+	}
+
+	/* special handling for FilmScan 200 */
+	if (s->hw->cmd->level[0] == 'F')
+		activateOption(s, OPT_FILM_TYPE, &dummy);
+
+	s->opt[OPT_BR_X].constraint.range = s->hw->x_range;
+	s->opt[OPT_BR_Y].constraint.range = s->hw->y_range;
+
+	if (s->val[OPT_TL_X].w < s->hw->x_range->min || force_max)
+		s->val[OPT_TL_X].w = s->hw->x_range->min;
+
+	if (s->val[OPT_TL_Y].w < s->hw->y_range->min || force_max)
+		s->val[OPT_TL_Y].w = s->hw->y_range->min;
+
+	if (s->val[OPT_BR_X].w > s->hw->x_range->max || force_max)
+		s->val[OPT_BR_X].w = s->hw->x_range->max;
+
+	if (s->val[OPT_BR_Y].w > s->hw->y_range->max || force_max)
+		s->val[OPT_BR_Y].w = s->hw->y_range->max;
+
+	setOptionState(s, s->hw->ADF
+		       && s->hw->use_extension, OPT_AUTO_EJECT, &dummy);
+	setOptionState(s, s->hw->ADF
+		       && s->hw->use_extension, OPT_EJECT, &dummy);
+}
+
+static SANE_Status
+setvalue(SANE_Handle handle, SANE_Int option, void *value, SANE_Int *info)
+{
+	Epson_Scanner *s = (Epson_Scanner *) handle;
+	SANE_Option_Descriptor *sopt = &(s->opt[option]);
+	Option_Value *sval = &(s->val[option]);
+
+	SANE_Status status;
+	const SANE_String_Const *optval = NULL;
+	int optindex = 0;
+	SANE_Bool reload = SANE_FALSE;
+
+	DBG(17, "%s: option = %d, value = %p\n", __func__, option, value);
+
+	status = sanei_constrain_value(sopt, value, info);
+	if (status != SANE_STATUS_GOOD)
+		return status;
+
+	if (info && value && (*info & SANE_INFO_INEXACT)
+	    && sopt->type == SANE_TYPE_INT)
+		DBG(17, "%s: constrained val = %d\n", __func__,
+		    *(SANE_Word *) value);
+
+	if (sopt->constraint_type == SANE_CONSTRAINT_STRING_LIST) {
+		optval = search_string_list(sopt->constraint.string_list,
+					    (char *) value);
+		if (optval == NULL)
+			return SANE_STATUS_INVAL;
+		optindex = optval - sopt->constraint.string_list;
+	}
+
+	switch (option) {
+
+	case OPT_GAMMA_VECTOR_R:
+	case OPT_GAMMA_VECTOR_G:
+	case OPT_GAMMA_VECTOR_B:
+	case OPT_CCT_PROFILE:
+		memcpy(sval->wa, value, sopt->size);	/* Word arrays */
+		break;
+
+	case OPT_CCT_MODE:
+	case OPT_ADF_MODE:
+	case OPT_DROPOUT:
+	case OPT_FILM_TYPE:
+	case OPT_BAY:
+	case OPT_FOCUS:
+		sval->w = optindex;	/* Simple lists */
+		break;
+
+	case OPT_EJECT:
+		/* XXX required?  control_extension(s, 1); */
+		esci_eject(s);
+		break;
+
+	case OPT_RESOLUTION:
+		sval->w = *((SANE_Word *) value);
+		DBG(17, "setting resolution to %d\n", sval->w);
+		reload = SANE_TRUE;
+		break;
+
+	case OPT_BR_X:
+	case OPT_BR_Y:
+		sval->w = *((SANE_Word *) value);
+		if (SANE_UNFIX(sval->w) == 0) {
+			DBG(17, "invalid br-x or br-y\n");
+			return SANE_STATUS_INVAL;
+		}
+		/* passthru */
+	case OPT_TL_X:
+	case OPT_TL_Y:
+		sval->w = *((SANE_Word *) value);
+		DBG(17, "setting size to %f\n", SANE_UNFIX(sval->w));
+		if (NULL != info)
+			*info |= SANE_INFO_RELOAD_PARAMS;
+		break;
+
+	case OPT_SOURCE:
+		change_source(s, optindex, (char *) value);
+		reload = SANE_TRUE;
+		break;
+
+	case OPT_MODE:
+	{
+		SANE_Bool isColor = mode_params[optindex].color;
+
+		sval->w = optindex;
+
+		/* halftoning available only on bw scans */
+		if (s->hw->cmd->set_halftoning != 0)
+			setOptionState(s, mode_params[optindex].depth == 1,
+				       OPT_HALFTONE, &reload);
+
+		/* disable dropout on non-color scans */
+		setOptionState(s, !isColor, OPT_DROPOUT, &reload);
+
+		if (s->hw->cmd->set_color_correction)
+			setOptionState(s, isColor,
+				       OPT_COLOR_CORRECTION, &reload);
+
+		/* if binary, then disable the bit depth selection */
+		if (optindex == 0) {
+			s->opt[OPT_BIT_DEPTH].cap |= SANE_CAP_INACTIVE;
+		} else {
+			if (s->hw->depth_list[0] == 1)
+				s->opt[OPT_BIT_DEPTH].cap |=
+					SANE_CAP_INACTIVE;
+			else {
+				s->opt[OPT_BIT_DEPTH].cap &=
+					~SANE_CAP_INACTIVE;
+				s->val[OPT_BIT_DEPTH].w =
+					mode_params[optindex].depth;
+			}
+		}
+
+		handle_depth_halftone(s, &reload);
+		reload = SANE_TRUE;
+
+		break;
+	}
+
+	case OPT_BIT_DEPTH:
+		sval->w = *((SANE_Word *) value);
+		mode_params[s->val[OPT_MODE].w].depth = sval->w;
+		reload = SANE_TRUE;
+		break;
+
+	case OPT_HALFTONE:
+		sval->w = optindex;
+		handle_depth_halftone(s, &reload);
+		break;
+
+	case OPT_COLOR_CORRECTION:
+	{
+		sval->w = optindex;
+		break;
+	}
+
+	case OPT_GAMMA_CORRECTION:
+	{
+		SANE_Bool f = gamma_userdefined[optindex];
+
+		sval->w = optindex;
+
+		setOptionState(s, f, OPT_GAMMA_VECTOR_R, &reload);
+		setOptionState(s, f, OPT_GAMMA_VECTOR_G, &reload);
+		setOptionState(s, f, OPT_GAMMA_VECTOR_B, &reload);
+		setOptionState(s, !f, OPT_BRIGHTNESS, &reload);	/* Note... */
+
+		break;
+	}
+
+	case OPT_MIRROR:
+	case OPT_AAS:
+	case OPT_PREVIEW:	/* needed? */
+	case OPT_BRIGHTNESS:
+	case OPT_SHARPNESS:
+	case OPT_AUTO_EJECT:
+	case OPT_THRESHOLD:
+	case OPT_WAIT_FOR_BUTTON:
+		sval->w = *((SANE_Word *) value);
+		break;
+
+	default:
+		return SANE_STATUS_INVAL;
+	}
+
+	if (reload && info != NULL)
+		*info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
+
+	DBG(17, "%s: end\n", __func__);
+
+	return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_control_option(SANE_Handle handle, SANE_Int option, SANE_Action action,
+		    void *value, SANE_Int *info)
+{
+	DBG(17, "%s: action = %x, option = %d\n", __func__, action, option);
+
+	if (option < 0 || option >= NUM_OPTIONS)
+		return SANE_STATUS_INVAL;
+
+	if (info != NULL)
+		*info = 0;
+
+	switch (action) {
+	case SANE_ACTION_GET_VALUE:
+		return getvalue(handle, option, value);
+
+	case SANE_ACTION_SET_VALUE:
+		return setvalue(handle, option, value, info);
+
+	default:
+		return SANE_STATUS_INVAL;
+	}
+
+	return SANE_STATUS_INVAL;
+}
+
+SANE_Status
+sane_get_parameters(SANE_Handle handle, SANE_Parameters *params)
+{
+	Epson_Scanner *s = (Epson_Scanner *) handle;
+
+	DBG(5, "%s\n", __func__);
+
+	if (params == NULL)
+		DBG(1, "%s: params is NULL\n", __func__);
+
+	/*
+	 * If sane_start was already called, then just retrieve the parameters
+	 * from the scanner data structure
+	 */
+
+	if (!s->eof && s->ptr != NULL) {
+		DBG(5, "scan in progress, returning saved params structure\n");
+	} else {
+		/* otherwise initialize the params structure and gather the data */
+		e2_init_parameters(s);
+	}
+
+	if (params != NULL)
+		*params = s->params;
+
+	print_params(s->params);
+
+	return SANE_STATUS_GOOD;
+}
+
+static void e2_load_cct_profile(struct Epson_Scanner *s, unsigned int index)
+{
+        s->cct_table[0] = SANE_FIX(s->hw->cct_profile->cct[index][0]);
+        s->cct_table[1] = SANE_FIX(s->hw->cct_profile->cct[index][1]);
+        s->cct_table[2] = SANE_FIX(s->hw->cct_profile->cct[index][2]);
+        s->cct_table[3] = SANE_FIX(s->hw->cct_profile->cct[index][3]);
+        s->cct_table[4] = SANE_FIX(s->hw->cct_profile->cct[index][4]);
+        s->cct_table[5] = SANE_FIX(s->hw->cct_profile->cct[index][5]);
+        s->cct_table[6] = SANE_FIX(s->hw->cct_profile->cct[index][6]);
+        s->cct_table[7] = SANE_FIX(s->hw->cct_profile->cct[index][7]);
+        s->cct_table[8] = SANE_FIX(s->hw->cct_profile->cct[index][8]);
+}
+
+/*
+ * This function is part of the SANE API and gets called from the front end to
+ * start the scan process.
+ */
+
+SANE_Status
+sane_start(SANE_Handle handle)
+{
+	Epson_Scanner *s = (Epson_Scanner *) handle;
+	Epson_Device *dev = s->hw;
+	SANE_Status status;
+
+	DBG(5, "%s\n", __func__);
+
+	/* check if we just have finished working with the ADF */
+	status = e2_check_adf(s);
+	if (status != SANE_STATUS_GOOD)
+		return status;
+
+	/* calc scanning parameters */
+	status = e2_init_parameters(s);
+	if (status != SANE_STATUS_GOOD)
+		return status;
+
+	print_params(s->params);
+
+	/* enable infrared */
+	if (s->val[OPT_MODE].w == MODE_INFRARED)
+		esci_enable_infrared(handle);
+
+	/* ESC , bay */
+	if (SANE_OPTION_IS_ACTIVE(s->opt[OPT_BAY].cap)) {
+		status = esci_set_bay(s, s->val[OPT_BAY].w);
+		if (status != SANE_STATUS_GOOD)
+			return status;
+	}
+
+	/* set scanning parameters */
+	if (dev->extended_commands)
+		status = e2_set_extended_scanning_parameters(s);
+	else
+		status = e2_set_scanning_parameters(s);
+
+	if (status != SANE_STATUS_GOOD)
+		return status;
+
+	/* ESC z, user defined gamma table */
+	if (dev->cmd->set_gamma_table
+	    && gamma_userdefined[s->val[OPT_GAMMA_CORRECTION].w]) {
+		status = esci_set_gamma_table(s);
+		if (status != SANE_STATUS_GOOD)
+			return status;
+	}
+
+	
+	if (s->val[OPT_COLOR_CORRECTION].w == CORR_AUTO) { /* Automatic */
+
+		DBG(1, "using built in CCT profile\n");
+
+		if (dev->model_id == 0)
+			DBG(1, " specific profile not available, using default\n");
+
+
+		if (0) { /* XXX TPU */
+ 
+		        /* XXX check this */
+			if (s->val[OPT_FILM_TYPE].w == 0)
+				e2_load_cct_profile(s, CCTP_COLORPOS);
+			else
+				e2_load_cct_profile(s, CCTP_COLORNEG);
+
+		} else {
+			e2_load_cct_profile(s, CCTP_REFLECTIVE);
+		}
+	}
+                                                    
+	/* ESC m, user defined color correction */
+	if (s->hw->cmd->set_color_correction_coefficients
+		&& correction_userdefined[s->val[OPT_COLOR_CORRECTION].w]) {
+
+		status = esci_set_color_correction_coefficients(s,
+                                                        s->cct_table);
+		if (status != SANE_STATUS_GOOD)
+			return status;
+	}
+
+	/* check if we just have finished working with the ADF.
+	 * this seems to work only after the scanner has been
+	 * set up with scanning parameters
+	 */
+	status = e2_check_adf(s);
+	if (status != SANE_STATUS_GOOD)
+		return status;
+
+	/*
+	 * If WAIT_FOR_BUTTON is active, then do just that:
+	 * Wait until the button is pressed. If the button was already
+	 * pressed, then we will get the button pressed event right away.
+	 */
+	if (s->val[OPT_WAIT_FOR_BUTTON].w == SANE_TRUE)
+		e2_wait_button(s);
+
+	/* for debug, request command parameter */
+/*	if (DBG_LEVEL) {
+		unsigned char buf[45];
+		request_command_parameter(s, buf);
+	}
+*/
+	/* set the retry count to 0 */
+	s->retry_count = 0;
+
+	/* allocate buffers for color shuffling */
+	if (dev->color_shuffle == SANE_TRUE) {
+		int i;
+		/* initialize the line buffers */
+		for (i = 0; i < s->line_distance * 2 + 1; i++) {
+
+			if (s->line_buffer[i] != NULL)
+				free(s->line_buffer[i]);
+
+			s->line_buffer[i] = malloc(s->params.bytes_per_line);
+			if (s->line_buffer[i] == NULL) {
+				DBG(1, "out of memory (line %d)\n", __LINE__);
+				return SANE_STATUS_NO_MEM;
+			}
+		}
+	}
+
+	/* prepare buffer here so that a memory allocation failure
+	 * will leave the scanner in a sane state.
+	 * the buffer will have to hold the image data plus
+	 * an error code in the extended handshaking mode.
+	 */
+	s->buf = realloc(s->buf, (s->lcount * s->params.bytes_per_line) + 1);
+	if (s->buf == NULL)
+		return SANE_STATUS_NO_MEM;
+
+	s->eof = SANE_FALSE;
+	s->ptr = s->end = s->buf;
+	s->canceling = SANE_FALSE;
+
+	/* feed the first sheet in the ADF */
+	if (dev->ADF && dev->use_extension && dev->cmd->feed) {
+		status = esci_feed(s);
+		if (status != SANE_STATUS_GOOD)
+			return status;
+	}
+
+	/* this seems to work only for some devices */
+	status = e2_wait_warm_up(s);
+	if (status != SANE_STATUS_GOOD)
+		return status;
+
+	/* start scanning */
+	DBG(1, "%s: scanning...\n", __func__);
+
+	if (dev->extended_commands) {
+		status = e2_start_ext_scan(s);
+
+		/* sometimes the scanner gives an io error when
+		 * it's warming up.
+		 */
+		if (status == SANE_STATUS_IO_ERROR) {
+			status = e2_wait_warm_up(s);
+			if (status == SANE_STATUS_GOOD)
+				status = e2_start_ext_scan(s);
+		}
+	} else
+		status = e2_start_std_scan(s);
+
+	if (status != SANE_STATUS_GOOD) {
+		DBG(1, "%s: start failed: %s\n", __func__,
+		    sane_strstatus(status));
+
+		return status;
+	}
+
+	/* this is a kind of read request */
+	if (dev->connection == SANE_EPSON_NET) {
+		sanei_epson_net_write(s, 0x2000, NULL, 0,
+		      s->ext_block_len + 1, &status);
+	}
+
+	return status;
+}
+
+static inline int
+get_color(int status)
+{
+	switch ((status >> 2) & 0x03) {
+	case 1:
+		return 1;
+	case 2:
+		return 0;
+	case 3:
+		return 2;
+	default:
+		return 0;	/* required to make the compiler happy */
+	}
+}
+
+/* this moves data from our buffers to SANE */
+
+SANE_Status
+sane_read(SANE_Handle handle, SANE_Byte *data, SANE_Int max_length,
+	  SANE_Int *length)
+{
+	SANE_Status status;
+	Epson_Scanner *s = (Epson_Scanner *) handle;
+
+	if (s->buf == NULL || s->canceling)
+		return SANE_STATUS_CANCELLED;
+
+	*length = 0;
+
+	if (s->hw->extended_commands)
+		status = e2_ext_read(s);
+	else
+		status = e2_block_read(s);
+
+	if (status == SANE_STATUS_CANCELLED) {
+		e2_scan_finish(s);
+		return status;
+	}
+
+	/* XXX if FS G and STATUS_IOERR, use e2_check_extended_status */
+
+	DBG(18, "moving data %p %p, %d (%d lines)\n",
+		s->ptr, s->end,
+		max_length, max_length / s->params.bytes_per_line);
+
+	e2_copy_image_data(s, data, max_length, length);
+
+	DBG(18, "%d lines read, eof: %d, status: %d\n",
+		*length / s->params.bytes_per_line,
+		s->eof, status);
+
+	/* continue reading if appropriate */
+	if (status == SANE_STATUS_GOOD)
+		return status;
+
+	e2_scan_finish(s);
+
+	return status;
+}
+
+/*
+ * void sane_cancel(SANE_Handle handle)
+ *
+ * Set the cancel flag to true. The next time the backend requests data
+ * from the scanner the CAN message will be sent.
+ */
+
+void
+sane_cancel(SANE_Handle handle)
+{
+	Epson_Scanner *s = (Epson_Scanner *) handle;
+
+	s->canceling = SANE_TRUE;
+}
+
+/*
+ * SANE_Status sane_set_io_mode()
+ *
+ * not supported - for asynchronous I/O
+ */
+
+SANE_Status
+sane_set_io_mode(SANE_Handle __sane_unused__ handle,
+	SANE_Bool __sane_unused__ non_blocking)
+{
+	return SANE_STATUS_UNSUPPORTED;
+}
+
+/*
+ * SANE_Status sane_get_select_fd()
+ *
+ * not supported - for asynchronous I/O
+ */
+
+SANE_Status
+sane_get_select_fd(SANE_Handle __sane_unused__ handle,
+	SANE_Int __sane_unused__ *fd)
+{
+	return SANE_STATUS_UNSUPPORTED;
+}