Initial import of sane-backends version 1.0.24-1.2

1 files changed, 8131 insertions, 0 deletions

diff --git a/backend/umax.c b/backend/umax.c
new file mode 100644
index 0000000..b2ceb00
--- /dev/null
+++ b/backend/umax.c
@@ -0,0 +1,8131 @@
+/* --------------------------------------------------------------------------------------------------------- */
+
+/* sane - Scanner Access Now Easy.
+
+   umax.c 
+
+   (C) 1997-2007 Oliver Rauch
+
+   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; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+   MA 02111-1307, USA.
+
+   As a special exception, the authors of SANE give permission for
+   additional uses of the libraries contained in this release of SANE.
+
+   The exception is that, if you link a SANE library with other files
+   to produce an executable, this does not by itself cause the
+   resulting executable to be covered by the GNU General Public
+   License.  Your use of that executable is in no way restricted on
+   account of linking the SANE library code into it.
+
+   This exception does not, however, invalidate any other reasons why
+   the executable file might be covered by the GNU General Public
+   License.
+
+   If you submit changes to SANE to the maintainers to be included in
+   a subsequent release, you agree by submitting the changes that
+   those changes may be distributed with this exception intact.
+
+   If you write modifications of your own for SANE, it is your choice
+   whether to permit this exception to apply to your modifications.
+   If you do not wish that, delete this exception notice.
+
+   This file implements a SANE backend for UMAX flatbed scanners.  */
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+#define BUILD 45
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+/* SANE-FLOW-DIAGRAMM
+
+	- sane_init() : initialize backend, attach scanners(devicename,0)
+	. - sane_get_devices() : query list of scanner-devices
+	. - sane_open() : open a particular scanner-device and attach_scanner(devicename,&dev)
+	. . - sane_set_io_mode : set blocking-mode
+	. . - sane_get_select_fd : get scanner-fd
+	. . - sane_get_option_descriptor() : get option information
+	. . - sane_control_option() : change option values
+	. .
+	. . - sane_start() : start image aquisition
+	. .   - sane_get_parameters() : returns actual scan-parameters
+	. .   - sane_read() : read image-data (from pipe)
+in ADF mode this is done often:
+	. . - sane_start() : start image aquisition
+	. .   - sane_get_parameters() : returns actual scan-parameters
+	. .   - sane_read() : read image-data (from pipe)
+
+	. . - sane_cancel() : cancel operation, kill reader_process
+
+	. - sane_close() : close opened scanner-device, do_cancel, free buffer and handle
+	- sane_exit() : terminate use of backend, free devicename and device-struture
+*/
+
+
+/* ------------------------------------------------------------ DBG OUTPUT LEVELS -------------------------- */
+
+
+#define DBG_error0  0
+#define DBG_error   1
+#define DBG_sense   2
+#define DBG_warning 3
+#define DBG_inquiry 4
+#define DBG_info    5
+#define DBG_info2   6
+#define DBG_proc    7
+#define DBG_read    8
+#define DBG_sane_init   10
+#define DBG_sane_proc   11
+#define DBG_sane_info   12
+#define DBG_sane_option 13
+
+
+/* ------------------------------------------------------------ SANE DEFINES ------------------------------- */
+
+#define BACKEND_NAME     umax
+#define UMAX_CONFIG_FILE "umax.conf"
+
+/* ------------------------------------------------------------ SANE INTERNATIONALISATION ------------------ */
+
+#ifndef SANE_I18N
+#define SANE_I18N(text) text
+#endif 
+
+/* ------------------------------------------------------------ INCLUDES ----------------------------------- */
+
+#include "../include/sane/config.h"
+
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include <unistd.h>
+
+#include "../include/sane/sane.h"
+#include "../include/sane/sanei.h"
+#include "../include/sane/saneopts.h"
+#include "../include/sane/sanei_scsi.h"
+#include "../include/sane/sanei_debug.h"
+#include "../include/sane/sanei_backend.h"
+#include "../include/sane/sanei_config.h"
+#include "../include/sane/sanei_thread.h"
+
+#ifdef UMAX_ENABLE_USB
+# include "sane/sanei_usb.h"
+#endif
+
+#include <math.h>
+#include <string.h>
+
+#include "umax-scsidef.h"
+#include "umax-scanner.c"
+
+#ifdef UMAX_ENABLE_USB
+# include "umax-usb.c"
+#endif
+
+#include "umax.h"
+
+/* ------------------------------------------------------------ SANE DEFINES ------------------------------- */
+
+#ifndef PATH_MAX
+#define PATH_MAX         1024
+#endif
+
+/* ------------------------------------------------------------ OPTION DEFINITIONS ------------------------- */
+
+#define SANE_NAME_BATCH_SCAN_START	"batch-scan-start"
+#define SANE_TITLE_BATCH_SCAN_START	"Batch scan start"
+#define SANE_DESC_BATCH_SCAN_START	"set for first scan of batch"
+
+#define SANE_NAME_BATCH_SCAN_LOOP	"batch-scan-loop"
+#define SANE_TITLE_BATCH_SCAN_LOOP	"Batch scan loop"
+#define SANE_DESC_BATCH_SCAN_LOOP	"set for middle scans of batch"
+
+#define SANE_NAME_BATCH_SCAN_END	"batch-scan-end"
+#define SANE_TITLE_BATCH_SCAN_END	"Batch scan end"
+#define SANE_DESC_BATCH_SCAN_END	"set for last scan of batch"
+
+#define SANE_NAME_BATCH_NEXT_TL_Y	"batch-scan-next-tl-y"
+#define SANE_TITLE_BATCH_NEXT_TL_Y	"Batch scan next top left Y"
+#define SANE_DESC_BATCH_NEXT_TL_Y	"Set top left Y position for next scan"
+
+#define SANE_UMAX_NAME_SELECT_CALIBRATON_EXPOSURE_TIME		"select-calibration-exposure-time"
+#define SANE_UMAX_TITLE_SELECT_CALIBRATION_EXPOSURE_TIME	"Set calibration exposure time"
+#define SANE_UMAX_DESC_SELECT_CALIBRATION_EXPOSURE_TIME		"Allow different settings for calibration and scan exposure times"
+
+/* ------------------------------------------------------------ STRING DEFINITIONS ------------------------- */
+
+#define FLB_STR			SANE_I18N("Flatbed")
+#define UTA_STR			SANE_I18N("Transparency Adapter")
+#define ADF_STR 		SANE_I18N("Automatic Document Feeder")
+
+#define LINEART_STR		SANE_VALUE_SCAN_MODE_LINEART
+#define HALFTONE_STR		SANE_VALUE_SCAN_MODE_HALFTONE
+#define GRAY_STR		SANE_VALUE_SCAN_MODE_GRAY
+#define COLOR_LINEART_STR	SANE_VALUE_SCAN_MODE_COLOR_LINEART
+#define COLOR_HALFTONE_STR	SANE_VALUE_SCAN_MODE_COLOR_HALFTONE
+#define COLOR_STR		SANE_VALUE_SCAN_MODE_COLOR
+
+/* ------------------------------------------------------------ DEFINITIONS -------------------------------- */
+
+#define P_200_TO_255(per) ( (SANE_UNFIX(per) + 100) * 255/200 )
+#define P_100_TO_255(per) SANE_UNFIX(per * 255/100 )
+#define P_100_TO_254(per) 1+SANE_UNFIX(per * 254/100 )
+
+/* ------------------------------------------------------------ GLOBAL VARIABLES --------------------------- */
+
+
+static SANE_String scan_mode_list[7];
+static SANE_String_Const source_list[4];
+static SANE_Int bit_depth_list[9];
+static SANE_Auth_Callback frontend_authorize_callback;
+
+static int umax_scsi_buffer_size_min = 32768;  /* default: minimum scsi buffer size: 32 KB */
+static int umax_scsi_buffer_size_max = 131072; /* default: maximum scsi buffer size: 128 KB */
+
+/* number of lines that shall be scanned in one buffer for preview if possible */
+/* this value should not be too large because it defines the step size in which */
+/* the scanned parts are displayed while preview scan is in progress */
+static int umax_preview_lines                  = 10; /* default: 10 preview lines */
+/* number of lines that shall be scanned in one buffer for scan if possible */
+static int umax_scan_lines                     = 40; /* default: 40 scan lines */
+static int umax_scsi_maxqueue                  = 2; /* use command queueing depth 2 as default */
+static int umax_handle_bad_sense_error         = 0; /* default: handle bad sense error code as device busy */
+static int umax_execute_request_sense          = 0; /* default: do not use request sense in do_calibration */
+static int umax_force_preview_bit_rgb          = 0; /* default: do not force preview bit in real color scan */
+static int umax_slow                           = -1; /* don`t use slow scanning speed */
+static int umax_smear                          = -1; /* don`t care about image smearing problem */
+static int umax_calibration_area               = -1;   /* -1=auto, 0=calibration on image, 1=calibration for full ccd */
+static int umax_calibration_width_offset       = -99999; /* -99999=auto */
+static int umax_calibration_width_offset_batch = -99999; /* -99999=auto */
+static int umax_calibration_bytespp            = -1;   /* -1=auto */
+static int umax_exposure_time_rgb_bind         = -1;   /* -1=auto */
+static int umax_invert_shading_data            = -1;   /* -1=auto */
+static int umax_lamp_control_available         = 0;    /* 0=disabled */
+static int umax_gamma_lsb_padded               = -1;   /* -1=auto */
+static int umax_connection_type                = 1;    /* 1=scsi, 2=usb */
+
+/* ------------------------------------------------------------ CALIBRATION MODE --------------------------- */
+
+#ifdef UMAX_CALIBRATION_MODE_SELECTABLE
+
+#define CALIB_MODE_0000		SANE_I18N("Use Image Composition")
+#define CALIB_MODE_1111		SANE_I18N("Bi-level black and white (lineart mode)")
+#define CALIB_MODE_1110		SANE_I18N("Dithered/halftone black & white (halftone mode)")
+#define CALIB_MODE_1101		SANE_I18N("Multi-level black & white (grayscale mode)")
+#define CALIB_MODE_1010		SANE_I18N("Multi-level RGB color (one pass color)")
+#define CALIB_MODE_1001		SANE_I18N("Ignore calibration")
+
+static SANE_String_Const calibration_list[] =
+{
+    CALIB_MODE_0000,
+    CALIB_MODE_1111,
+    CALIB_MODE_1110,
+    CALIB_MODE_1101,
+    CALIB_MODE_1010,
+    CALIB_MODE_1001,
+    0
+};
+
+#endif
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+enum
+{
+    UMAX_CALIBRATION_AREA_IMAGE = 0,
+    UMAX_CALIBRATION_AREA_CCD
+};
+
+static const SANE_Int pattern_dim_list[] =
+{
+  5, /* # of elements */
+  2, 4, 6, 8, 12
+};
+
+static const SANE_Range u8_range =
+{
+    0, /* minimum */
+  255, /* maximum */
+    0  /* quantization */
+};
+
+static const SANE_Range percentage_range =
+{
+  -100 << SANE_FIXED_SCALE_SHIFT, /* minimum */
+   100 << SANE_FIXED_SCALE_SHIFT, /* maximum */
+     1 << SANE_FIXED_SCALE_SHIFT  /* quantization */
+};
+
+static const SANE_Range percentage_range_100 =
+{
+     0 << SANE_FIXED_SCALE_SHIFT, /* minimum */
+   100 << SANE_FIXED_SCALE_SHIFT, /* maximum */
+     0 << SANE_FIXED_SCALE_SHIFT  /* quantization */
+};
+
+static int num_devices = 0;
+static const SANE_Device **devlist = NULL;
+static Umax_Device *first_dev      = NULL;
+static Umax_Scanner *first_handle  = NULL;
+
+
+/* ------------------------------------------------------------ MATH-HELPERS ------------------------------- */
+
+
+#define min(a, b) (((a)<(b))?(a):(b))
+#define max(a, b) (((a)>(b))?(a):(b))
+#define inrange(minimum, val, maximum) (min(maximum, max(val, minimum)))
+
+
+/* ------------------------------------------------------------ umax_test_little_endian -------------------- */
+
+static SANE_Bool umax_test_little_endian(void)
+{
+  SANE_Int testvalue = 255;
+  unsigned char *firstbyte = (unsigned char *) &testvalue;
+
+  if (*firstbyte == 255)
+  {
+    return SANE_TRUE;
+  }
+
+  return SANE_FALSE;
+}
+
+/* ------------------------------------------------------------ DBG_inq_nz --------------------------------- */
+
+
+static void DBG_inq_nz(char *text, int flag)
+{
+  if (flag != 0) { DBG(DBG_inquiry,"%s", text); }
+}
+
+
+/*------------------------------------------------------------- DBG_sense_nz ------------------------------- */
+
+
+static void DBG_sense_nz(char *text, int flag)
+{
+  if (flag != 0) { DBG(DBG_sense,"%s", text); }
+}
+
+
+/* ------------------------------------------------------------ UMAX PRINT INQUIRY ------------------------- */
+
+
+static void umax_print_inquiry(Umax_Device *dev)
+{
+ unsigned char *inquiry_block;
+ int i;
+
+  inquiry_block=dev->buffer[0];
+
+  DBG(DBG_inquiry,"INQUIRY:\n");
+  DBG(DBG_inquiry,"========\n");
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"vendor........................: '%s'\n", dev->vendor);
+  DBG(DBG_inquiry,"product.......................: '%s'\n", dev->product);
+  DBG(DBG_inquiry,"version.......................: '%s'\n", dev->version);
+
+  DBG(DBG_inquiry,"peripheral qualifier..........: %d\n", get_inquiry_periph_qual(inquiry_block));
+  DBG(DBG_inquiry,"peripheral device type........: %d\n", get_inquiry_periph_devtype(inquiry_block));
+
+  DBG_inq_nz("RMB bit set (reserved)\n", get_inquiry_rmb(inquiry_block));
+  DBG_inq_nz("0x01 bit 6\n", get_inquiry_0x01_bit6(inquiry_block));
+  DBG_inq_nz("0x01 bit 5\n", get_inquiry_0x01_bit5(inquiry_block));
+
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"CBHS value range..............: %s\n", cbhs_str[dev->inquiry_cbhs]);
+  DBG(DBG_inquiry,"scanmode......................: %s\n", scanmode_str[get_inquiry_scanmode(inquiry_block)]);
+  if (dev->inquiry_transavail)
+  {
+    DBG(DBG_inquiry,"UTA (transparency)............: available\n");
+
+    if (get_inquiry_translamp(inquiry_block) == 0)
+    { DBG(DBG_inquiry,"UTA lamp status ..............: off\n"); }
+    else
+    { DBG(DBG_inquiry,"UTA lamp status ..............: on\n"); }
+
+    DBG(DBG_inquiry,"\n");
+  }
+
+  DBG(DBG_inquiry,"inquiry block length..........: %d bytes\n", dev->inquiry_len);
+  if (dev->inquiry_len<=0x8e)
+  {
+    DBG(DBG_inquiry, "Inquiry block is unexpected short, should be at least 147 bytes\n");
+  } 
+
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"ISO  Version (reserved).......: %d\n", get_inquiry_iso_version(inquiry_block));
+  DBG(DBG_inquiry,"ECMA Version (reserved).......: %d\n", get_inquiry_ecma_version(inquiry_block));
+  DBG(DBG_inquiry,"ANSI Version .................: %d\n", get_inquiry_ansi_version(inquiry_block));
+  DBG(DBG_inquiry,"\n");
+
+  DBG_inq_nz("AENC bit set (reserved)\n",  get_inquiry_aenc(inquiry_block));
+  DBG_inq_nz("TmIOP bit set (reserved)\n", get_inquiry_tmiop(inquiry_block));
+  DBG_inq_nz("0x03 bit 5\n",               get_inquiry_0x03_bit5(inquiry_block));
+  DBG_inq_nz("0x03 bit 4\n",               get_inquiry_0x03_bit4(inquiry_block));
+
+  DBG(DBG_inquiry,"reserved byte 0x05 = %d\n", get_inquiry_0x05(inquiry_block));
+  DBG(DBG_inquiry,"reserved byte 0x06 = %d\n", get_inquiry_0x06(inquiry_block));
+
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"scsi features (%02x):\n", get_inquiry_scsi_byte(inquiry_block));
+  DBG(DBG_inquiry,"-------------------\n");
+  DBG_inq_nz(" - relative address\n", get_inquiry_scsi_reladr(inquiry_block));
+  DBG_inq_nz(" - wide bus 32 bit\n",  get_inquiry_scsi_wbus32(inquiry_block));
+  DBG_inq_nz(" - wide bus 16 bit\n",  get_inquiry_scsi_wbus16(inquiry_block));
+  DBG_inq_nz(" - syncronous neg.\n",  get_inquiry_scsi_sync(inquiry_block));
+  DBG_inq_nz(" - linked commands\n",  get_inquiry_scsi_linked(inquiry_block));
+  DBG_inq_nz(" - (reserved)\n",       get_inquiry_scsi_R(inquiry_block));
+  DBG_inq_nz(" - command queueing\n", get_inquiry_scsi_cmdqueue(inquiry_block));
+  DBG_inq_nz(" - sftre\n",            get_inquiry_scsi_sftre(inquiry_block));
+
+  /* 0x24 */
+  if (dev->inquiry_len<=0x24)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"f/w support function:\n");
+  DBG(DBG_inquiry,"---------------------\n");
+  DBG_inq_nz(" - quality calibration\n", dev->inquiry_quality_ctrl);
+  DBG_inq_nz(" - fast preview function\n", dev->inquiry_preview);
+  DBG_inq_nz(" - shadow compensation by f/w\n", get_inquiry_fw_shadow_comp(inquiry_block));
+  DBG_inq_nz(" - reselection phase\n", get_inquiry_fw_reselection(inquiry_block));
+  DBG_inq_nz(" - lamp intensity control\n", dev->inquiry_lamp_ctrl);
+  DBG_inq_nz(" - batch scan function\n", get_inquiry_fw_batch_scan(inquiry_block));
+  DBG_inq_nz(" - calibration mode control by driver\n", get_inquiry_fw_calibration(inquiry_block));
+
+  /* 0x36, 0x37 */
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"reserved byte 0x36 = %d\n", get_inquiry_0x36(inquiry_block));
+  DBG(DBG_inquiry,"reserved byte 0x37 = %d\n", get_inquiry_0x37(inquiry_block));
+
+  if (get_inquiry_fw_adjust_exposure_tf(inquiry_block))
+  {
+    int unit;
+
+    DBG(DBG_inquiry,"\n");
+    DBG(DBG_inquiry,"adjust exposure time function\n");
+    unit=get_inquiry_exposure_time_step_unit(inquiry_block);
+    DBG(DBG_inquiry,"exposure time step units......: %d micro-sec\n", unit);
+    DBG(DBG_inquiry,"exposure time maximum.........: %d micro-sec\n",
+            unit*get_inquiry_exposure_time_max(inquiry_block));
+    DBG(DBG_inquiry,"exposure time minimum (LHG)...: %d micro-sec\n",
+            unit*get_inquiry_exposure_time_lhg_min(inquiry_block));
+    DBG(DBG_inquiry,"exposure time minimum color...: %d micro-sec\n",
+            unit*get_inquiry_exposure_time_color_min(inquiry_block));
+    DBG(DBG_inquiry,"exposure time default FB (LH).: %d micro-sec\n",
+            unit*get_inquiry_exposure_time_lh_def_fb(inquiry_block));
+    DBG(DBG_inquiry,"exposure time default UTA (LH): %d micro-sec\n",
+            unit*get_inquiry_exposure_time_lh_def_uta(inquiry_block));
+    DBG(DBG_inquiry,"exposure time default FB gray.: %d micro-sec\n",
+            unit*get_inquiry_exposure_time_gray_def_fb(inquiry_block));
+    DBG(DBG_inquiry,"exposure time default UTA gray: %d micro-sec\n",
+            unit*get_inquiry_exposure_time_gray_def_uta(inquiry_block));
+    DBG(DBG_inquiry,"exposure time default FB red..: %d micro-sec\n",
+            unit*get_inquiry_exposure_time_def_r_fb(inquiry_block));
+    DBG(DBG_inquiry,"exposure time default FB grn..: %d micro-sec\n",
+            unit*get_inquiry_exposure_time_def_g_fb(inquiry_block));
+    DBG(DBG_inquiry,"exposure time default FB blue.: %d micro-sec\n",
+            unit*get_inquiry_exposure_time_def_b_fb(inquiry_block));
+    DBG(DBG_inquiry,"exposure time default UTA red.: %d micro-sec\n",
+            unit*get_inquiry_exposure_time_def_r_uta(inquiry_block));
+    DBG(DBG_inquiry,"exposure time default UTA grn.: %d micro-sec\n",
+            unit*get_inquiry_exposure_time_def_g_uta(inquiry_block));
+    DBG(DBG_inquiry,"exposure time default UTA blue: %d micro-sec\n",
+            unit*get_inquiry_exposure_time_def_b_uta(inquiry_block));
+  }
+
+
+  /* 0x60 */
+  if (dev->inquiry_len<=0x60)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"scan modes (%02x):\n", get_inquiry_sc_feature_byte0(inquiry_block));
+  DBG(DBG_inquiry,"----------------\n");
+  DBG_inq_nz(" - three passes color mode\n",		get_inquiry_sc_three_pass_color(inquiry_block));
+  DBG_inq_nz(" - single pass color mode\n",		get_inquiry_sc_one_pass_color(inquiry_block));
+  DBG_inq_nz(" - lineart mode\n",			dev->inquiry_lineart);
+  DBG_inq_nz(" - halftone mode\n",			dev->inquiry_halftone);
+  DBG_inq_nz(" - gray mode\n",				dev->inquiry_gray);
+  DBG_inq_nz(" - color mode\n",				dev->inquiry_color);
+  DBG_inq_nz(" - transparency (UTA)\n",			dev->inquiry_uta);
+  DBG_inq_nz(" - automatic document feeder (ADF)\n",	dev->inquiry_adf);
+
+  /* 0x61 */
+  if (dev->inquiry_len<=0x61)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"scanner capability (%02x, %02x, %02x):\n",
+      get_inquiry_sc_feature_byte1(inquiry_block),
+      get_inquiry_sc_feature_byte2(inquiry_block),
+      get_inquiry_sc_feature_byte3(inquiry_block));
+  DBG(DBG_inquiry,"--------------------------------\n");
+  DBG_inq_nz(" - double resolution\n",			dev->inquiry_dor);
+  DBG_inq_nz(" - send high byte first\n",		get_inquiry_sc_high_byte_first(inquiry_block));
+  DBG_inq_nz(" - bi-level image reverse\n",		dev->inquiry_reverse);
+  DBG_inq_nz(" - multi-level image reverse\n",		dev->inquiry_reverse_multi);
+  DBG_inq_nz(" - support shadow function\n",		dev->inquiry_shadow);
+  DBG_inq_nz(" - support highlight function\n",		dev->inquiry_highlight);
+  DBG_inq_nz(" - f/w downloadable\n",			get_inquiry_sc_downloadable_fw(inquiry_block));
+  DBG_inq_nz(" - paper length can reach to 14 inch\n",	get_inquiry_sc_paper_length_14(inquiry_block));
+
+  /* 0x62 */
+  if (dev->inquiry_len<=0x62)
+  {
+    return;
+  }
+
+  DBG_inq_nz(" - shading data/gain uploadable\n",	get_inquiry_sc_uploadable_shade(inquiry_block));
+  DBG_inq_nz(" - analog gamma correction\n",		dev->inquiry_analog_gamma);
+  DBG_inq_nz(" - x, y coordinate base\n",		get_inquiry_xy_coordinate_base(inquiry_block));
+  DBG_inq_nz(" - lineart starts with LSB\n",		get_inquiry_lineart_order(inquiry_block));
+  DBG_inq_nz(" - start density \n",			get_inquiry_start_density(inquiry_block));
+  DBG_inq_nz(" - hardware x scaling\n",			get_inquiry_hw_x_scaling(inquiry_block));
+  DBG_inq_nz(" - hardware y scaling\n",			get_inquiry_hw_y_scaling(inquiry_block));
+
+  /* 0x63 */
+  if (dev->inquiry_len<=0x63)
+  {
+    return;
+  }
+
+  DBG_inq_nz(" + ADF: no paper\n",			get_inquiry_ADF_no_paper(inquiry_block));
+  DBG_inq_nz(" + ADF: cover open\n",			get_inquiry_ADF_cover_open(inquiry_block));
+  DBG_inq_nz(" + ADF: paper jam\n",			get_inquiry_ADF_paper_jam(inquiry_block));
+  DBG_inq_nz(" - unknwon flag; 0x63 bit 3\n",		get_inquiry_0x63_bit3(inquiry_block));
+  DBG_inq_nz(" - unknown lfag: 0x63 bit 4\n",		get_inquiry_0x63_bit4(inquiry_block));
+  DBG_inq_nz(" - lens calib in doc pos\n",		get_inquiry_lens_cal_in_doc_pos(inquiry_block));
+  DBG_inq_nz(" - manual focus\n",			get_inquiry_manual_focus(inquiry_block));
+  DBG_inq_nz(" - UTA lens calib pos selectable\n",	get_inquiry_sel_uta_lens_cal_pos(inquiry_block));
+
+  /* 0x64 - 0x68*/
+  if (dev->inquiry_len<=0x68)
+  {
+    return;
+  }
+
+  if (dev->inquiry_gamma_dwload)
+  {
+    DBG(DBG_inquiry,"\n");
+    DBG(DBG_inquiry,"gamma download available\n");
+    DBG_inq_nz("gamma download type 2\n", get_inquiry_gamma_type_2(inquiry_block));
+    DBG(DBG_inquiry,"lines of gamma curve: %s\n", gamma_lines_str[get_inquiry_gamma_lines(inquiry_block)]);
+
+    /* 0x66 */
+    DBG_inq_nz("gamma input   8 bits/pixel support\n", get_inquiry_gib_8bpp(inquiry_block));
+    DBG_inq_nz("gamma input   9 bits/pixel support\n", get_inquiry_gib_9bpp(inquiry_block));
+    DBG_inq_nz("gamma input  10 bits/pixel support\n", get_inquiry_gib_10bpp(inquiry_block));
+    DBG_inq_nz("gamma input  12 bits/pixel support\n", get_inquiry_gib_12bpp(inquiry_block));
+    DBG_inq_nz("gamma input  14 bits/pixel support\n", get_inquiry_gib_14bpp(inquiry_block));
+    DBG_inq_nz("gamma input  16 bits/pixel support\n", get_inquiry_gib_16bpp(inquiry_block));
+    DBG_inq_nz("0x66 bit 6\n", get_inquiry_0x66_bit6(inquiry_block));
+    DBG_inq_nz("0x66 bit 7\n", get_inquiry_0x66_bit7(inquiry_block));
+
+    /* 0x68 */
+    DBG_inq_nz("gamma output  8 bits/pixel support\n", get_inquiry_gob_8bpp(inquiry_block));
+    DBG_inq_nz("gamma output  9 bits/pixel support\n", get_inquiry_gob_9bpp(inquiry_block));
+    DBG_inq_nz("gamma output 10 bits/pixel support\n", get_inquiry_gob_10bpp(inquiry_block));
+    DBG_inq_nz("gamma output 12 bits/pixel support\n", get_inquiry_gob_12bpp(inquiry_block));
+    DBG_inq_nz("gamma output 14 bits/pixel support\n", get_inquiry_gob_14bpp(inquiry_block));
+    DBG_inq_nz("gamma output 16 bits/pixel support\n", get_inquiry_gob_16bpp(inquiry_block));
+    DBG_inq_nz("0x68 bit 6\n", get_inquiry_0x68_bit6(inquiry_block));
+    DBG_inq_nz("0x68 bit 7\n", get_inquiry_0x68_bit7(inquiry_block));
+  }
+
+  /* 0x64 - 0x68 reserved bits */
+  DBG_inq_nz("0x64 bit 2\n", get_inquiry_0x64_bit2(inquiry_block));
+  DBG_inq_nz("0x64 bit 3\n", get_inquiry_0x64_bit3(inquiry_block));
+  DBG_inq_nz("0x64 bit 4\n", get_inquiry_0x64_bit4(inquiry_block));
+  DBG_inq_nz("0x64 bit 6\n", get_inquiry_0x64_bit6(inquiry_block));
+
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"reserved byte 0x65 = %d\n", get_inquiry_0x65(inquiry_block));
+  DBG(DBG_inquiry,"reserved byte 0x67 = %d\n", get_inquiry_0x67(inquiry_block));
+
+
+  /* 0x69 */
+  if (dev->inquiry_len<=0x69)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"\n");
+  if (get_inquiry_hda(inquiry_block))
+  {
+    DBG(DBG_inquiry,"halftone download available\n");
+    DBG(DBG_inquiry,"halftone pattern download max matrix %dx%d\n",
+                    get_inquiry_max_halftone_matrix(inquiry_block),
+                    get_inquiry_max_halftone_matrix(inquiry_block));
+  }
+
+  /* 0x6a */
+  if (dev->inquiry_len<=0x6a)
+  {
+    return;
+  }
+
+  DBG_inq_nz("built-in halftone patterns:\n", get_inquiry_halftones_supported(inquiry_block));
+  DBG_inq_nz("built-in halftone pattern size ............: 2x2\n", get_inquiry_halftones_2x2(inquiry_block));
+  DBG_inq_nz("built-in halftone pattern size ............: 4x4\n", get_inquiry_halftones_4x4(inquiry_block));
+  DBG_inq_nz("built-in halftone pattern size ............: 6x6\n", get_inquiry_halftones_6x6(inquiry_block));
+  DBG_inq_nz("built-in halftone pattern size ............: 8x8\n", get_inquiry_halftones_8x8(inquiry_block));
+  DBG_inq_nz("built-in halftone pattern size ............: 12x12\n", get_inquiry_halftones_12x12(inquiry_block));
+
+  /* 0x6b, 0x6c */
+  DBG(DBG_inquiry,"reserved byte 0x6b = %d\n", get_inquiry_0x6b(inquiry_block));
+  DBG(DBG_inquiry,"reserved byte 0x6c = %d\n", get_inquiry_0x6c(inquiry_block));
+
+
+  /* 0x6d */
+  if (dev->inquiry_len<=0x6d)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"color sequence............................: %s\n",
+      color_sequence_str[get_inquiry_colorseq(inquiry_block)]);
+  DBG_inq_nz("color ordering support....................: pixel\n",
+             get_inquiry_color_order_pixel(inquiry_block));
+  DBG_inq_nz("color ordering support....................: line without CCD distance\n",
+             get_inquiry_color_order_line_no_ccd(inquiry_block));
+  DBG_inq_nz("color ordering support....................: plane\n",
+             get_inquiry_color_order_plane(inquiry_block));
+  DBG_inq_nz("color ordering support....................: line with CCD distance\n",
+             get_inquiry_color_order_line_w_ccd(inquiry_block));
+  DBG_inq_nz("color ordering support....................: (reserved)\n",
+             get_inquiry_color_order_reserved(inquiry_block));
+
+  /* 0x6e */
+  if (dev->inquiry_len<=0x71)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"maximum video memory......................: %d KB\n", dev->inquiry_vidmem/1024);
+
+  /* 0x72 */
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"reserved byte 0x72 = %d\n", get_inquiry_0x72(inquiry_block));
+  DBG(DBG_inquiry,"\n");
+
+  /* 0x73/0x94 - 0x75/0x96 */
+  if (dev->inquiry_len<=0x75)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"optical resolution........................: %d dpi\n", dev->inquiry_optical_res);
+  DBG(DBG_inquiry,"maximum x-resolution......................: %d dpi\n", dev->inquiry_x_res);
+  DBG(DBG_inquiry,"maximum y-resolution......................: %d dpi\n", dev->inquiry_y_res);
+
+  /* ---------- */
+
+  /* 0x76 0x77 */
+  if (dev->inquiry_len<=0x77)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"FB (flatbed-mode):\n");
+  DBG(DBG_inquiry,"FB maximum scan width.....................: %2.2f inch\n", dev->inquiry_fb_width);
+  DBG(DBG_inquiry,"FB maximum scan length....................: %2.2f inch\n", dev->inquiry_fb_length);
+
+  /* ---------- */
+  
+  /* 0x7a - 0x81 */
+  if (dev->inquiry_len<=0x81)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"UTA (transparency-mode):\n");
+  DBG(DBG_inquiry,"UTA x-original point......................: %2.2f inch\n", dev->inquiry_uta_x_off);
+  DBG(DBG_inquiry,"UTA y-original point......................: %2.2f inch\n", dev->inquiry_uta_y_off);
+  DBG(DBG_inquiry,"UTA maximum scan width....................: %2.2f inch\n", dev->inquiry_uta_width); 
+  DBG(DBG_inquiry,"UTA maximum scan length...................: %2.2f inch\n", dev->inquiry_uta_length);
+ 
+  /* ---------- */
+
+  /* 0x82-0x85 */
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"reserved byte 0x82 = %d\n", get_inquiry_0x82(inquiry_block));
+
+  /* ---------- */
+
+  /* 0x83/0xa0 - 0x85/0xa2 */
+  if (dev->inquiry_len<=0x85)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"DOR (double optical resolution-mode):\n");
+  DBG(DBG_inquiry,"DOR optical resolution....................: %d dpi\n", dev->inquiry_dor_optical_res);
+  DBG(DBG_inquiry,"DOR maximum x-resolution..................: %d dpi\n", dev->inquiry_dor_x_res);
+  DBG(DBG_inquiry,"DOR maximum y-resolution..................: %d dpi\n", dev->inquiry_dor_y_res);
+
+  /* 0x86 - 0x8d */
+  if (dev->inquiry_len<=0x8d)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"DOR x-original point......................: %2.2f inch\n", dev->inquiry_dor_x_off);
+  DBG(DBG_inquiry,"DOR y-original point......................: %2.2f inch\n", dev->inquiry_dor_y_off);
+  DBG(DBG_inquiry,"DOR maximum scan width....................: %2.2f inch\n", dev->inquiry_dor_width);
+  DBG(DBG_inquiry,"DOR maximum scan length...................: %2.2f inch\n", dev->inquiry_dor_length);
+  DBG(DBG_inquiry,"\n");
+
+  /* ---------- */
+
+  /* 0x8e */
+  DBG(DBG_inquiry,"reserved byte 0x8e = %d\n", get_inquiry_0x8e(inquiry_block));
+  DBG(DBG_inquiry,"\n");
+
+  /* ---------- */
+
+  /* 0x8f */
+  if (dev->inquiry_len<=0x8f)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"last calibration lamp density.............: %d\n",
+      get_inquiry_last_calibration_lamp_density(inquiry_block));
+
+  /* 0x90 */
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"reserved byte 0x90 = %d\n", get_inquiry_0x90(inquiry_block));
+  DBG(DBG_inquiry,"\n");
+
+  /* 0x91 */
+  if (dev->inquiry_len<=0x91)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"lamp warmup maximum time..................: %d sec\n", dev->inquiry_max_warmup_time);
+ 
+  /* 0x92 0x93 */
+  if (dev->inquiry_len<=0x93)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"window descriptor block length............: %d bytes\n", get_inquiry_wdb_length(inquiry_block));
+
+  /* ----------------- */
+
+  /* 0x97 */
+  if (dev->inquiry_len<=0x97)
+  {
+    return;
+  }
+
+  if (get_inquiry_analog_gamma_table(inquiry_block) == 0)
+  {
+    DBG(DBG_inquiry,"no analog gamma function\n");
+  }
+  else
+  {
+    DBG(DBG_inquiry,"mp 8832 analog gamma table\n");
+  }
+
+  /* 0x98, 0x99 */
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"reserved byte 0x98 = %d\n", get_inquiry_0x98(inquiry_block));
+  DBG(DBG_inquiry,"reserved byte 0x99 = %d\n", get_inquiry_0x99(inquiry_block));
+  DBG(DBG_inquiry,"\n");
+
+  /* 0x9a */
+  if (dev->inquiry_len<=0x9a)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"maximum calibration data lines for shading: %d\n",
+      get_inquiry_max_calibration_data_lines(inquiry_block));
+
+  /* 0x9b */
+  if (dev->inquiry_len<=0x9b)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"fb/uta: color line arrangement mode.......: %d\n",
+      get_inquiry_fb_uta_line_arrangement_mode(inquiry_block));
+
+  /* 0x9c */
+  if (dev->inquiry_len<=0x9c)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"adf:    color line arrangement mode.......: %d\n",
+      get_inquiry_adf_line_arrangement_mode(inquiry_block));
+
+  /* 0x9d */
+  if (dev->inquiry_len<=0x9d)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"CCD line distance.........................: %d\n",
+      get_inquiry_CCD_line_distance(inquiry_block));
+
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"reserved byte 0x9e = %d\n", get_inquiry_0x9e(inquiry_block));
+
+  /* 0xa2 following */
+  if (dev->inquiry_len<=0xa2)
+  {
+    return;
+  }
+
+  DBG(DBG_inquiry,"\n");
+  for(i=0xa3; i<dev->inquiry_len; i++)
+  {
+    DBG(DBG_inquiry,"unknown reserved byte 0x%x = %d\n", i, inquiry_block[i]);
+  }
+}
+
+
+/* ------------------------------------------------------------ CBHS_CORRECT ------------------------------- */
+
+
+static int umax_cbhs_correct(int minimum, int cbhs, int maximum)
+{
+ int range = maximum - minimum + 1;
+
+  if (range == 256)
+  {
+    return cbhs;
+  }
+
+ return (int)( (cbhs/256.0)*range + minimum );
+}
+
+
+/* ------------------------------------------------------------ SENSE_HANDLER ------------------------------ */
+
+
+static SANE_Status sense_handler(int scsi_fd, unsigned char *result, void *arg)	  /* is called by sanei_scsi */
+{
+ unsigned char asc, ascq, sensekey;
+ int           asc_ascq, len;
+ Umax_Device   *dev = arg;
+
+  DBG(DBG_proc, "check condition sense handler (scsi_fd = %d)\n", scsi_fd);
+
+  sensekey = get_RS_sense_key(result);
+  asc      = get_RS_ASC(result);
+  ascq     = get_RS_ASCQ(result);
+  asc_ascq = (int)(256 * asc + ascq);
+  len      = 7 + get_RS_additional_length(result);
+
+  if ( get_RS_error_code(result) != 0x70 ) 
+  {
+    DBG(DBG_error, "invalid sense key error code (%d)\n", get_RS_error_code(result));
+
+    switch (dev->handle_bad_sense_error)
+    {
+      default:
+      case 0:
+        DBG(DBG_error, "=> handled as DEVICE BUSY!\n");
+       return SANE_STATUS_DEVICE_BUSY;
+
+      case 1:
+        DBG(DBG_error, "=> handled as ok!\n");
+       return SANE_STATUS_GOOD;
+
+      case 2:
+        DBG(DBG_error, "=> handled as i/o error!\n");
+       return SANE_STATUS_IO_ERROR;
+
+      case 3:
+        DBG(DBG_error, "=> ignored, sense handler does continue\n");
+    }
+  }
+
+  DBG(DBG_sense, "check condition sense: %s\n", sense_str[sensekey]);
+
+  /* when we reach here then we have no valid data in buffer[0] */
+  /* but it may be helpful to have the result data in buffer[0] */
+  memset(dev->buffer[0], 0, rs_return_block_size);  /* clear sense data buffer */
+  memcpy(dev->buffer[0], result, len+1); /* copy sense data to buffer */
+
+  if (len > 0x15)
+  {
+   int scanner_error = get_RS_scanner_error_code(result);
+
+    if (scanner_error < 100)
+    {
+      DBG(DBG_sense, "-> %s (#%d)\n", scanner_error_str[scanner_error], scanner_error);
+    }
+    else
+    {
+      DBG(DBG_sense, "-> error %d\n", scanner_error);
+    }
+  }
+
+  if (get_RS_ILI(result) != 0)
+  {
+    DBG(DBG_sense, "-> ILI-ERROR: requested data length is larger than actual length\n");
+  }
+
+  switch(sensekey)
+  {
+    case 0x00:											 /* no sense */
+      return SANE_STATUS_GOOD;
+     break;
+
+
+    case 0x03:										     /* medium error */
+      if (asc_ascq == 0x1400)
+      {
+        DBG(DBG_sense, "-> misfeed, paper jam\n");
+        return SANE_STATUS_JAMMED;
+      }
+      else if (asc_ascq == 0x1401)
+      {
+        DBG(DBG_sense, "-> adf not ready\n");
+        return SANE_STATUS_NO_DOCS;
+      }
+      else
+      {
+        DBG(DBG_sense, "-> unknown medium error: asc=%d, ascq=%d\n", asc, ascq);
+      }
+     break;
+
+
+    case 0x04:										   /* hardware error */
+      if (asc_ascq == 0x4000)
+      {
+        DBG(DBG_sense, "-> diagnostic error:\n");
+        if (len >= 0x13)
+	{
+	  DBG_sense_nz("   dim light\n",			get_RS_asb_dim_light(result));
+	  DBG_sense_nz("   no light\n",				get_RS_asb_no_light(result));
+	  DBG_sense_nz("   sensor or motor error\n",		get_RS_asb_sensor_motor(result));
+	  DBG_sense_nz("   too light\n",			get_RS_asb_too_light(result));
+	  DBG_sense_nz("   calibration error\n",		get_RS_asb_calibration(result));
+	  DBG_sense_nz("   rom error\n",			get_RS_asb_rom(result));
+	  DBG_sense_nz("   ram error\n",			get_RS_asb_ram(result));
+	  DBG_sense_nz("   cpu error\n",			get_RS_asb_cpu(result));
+	  DBG_sense_nz("   scsi error\n",			get_RS_asb_scsi(result));
+	  DBG_sense_nz("   timer error\n",			get_RS_asb_timer(result));
+	  DBG_sense_nz("   filter motor error\n",		get_RS_asb_filter_motor(result));
+	  DBG_sense_nz("   dc adjust error\n",			get_RS_asb_dc_adjust(result));
+	  DBG_sense_nz("   uta home sensor or motor error\n",	get_RS_asb_uta_sensor(result));
+	}
+      }
+      else
+      {
+        DBG(DBG_sense, "-> unknown hardware error: asc=%d, ascq=%d\n", asc, ascq);
+      }
+      return SANE_STATUS_IO_ERROR;
+     break;
+
+
+    case 0x05:										  /* illegal request */
+      if (asc_ascq == 0x2000)
+      {
+        DBG(DBG_sense, "-> invalid command operation code\n");
+      }
+      else if (asc_ascq == 0x2400)
+      {
+        DBG(DBG_sense, "-> illegal field in CDB\n");
+       }
+      else if (asc_ascq == 0x2500)
+      {
+        DBG(DBG_sense, "-> logical unit not supported\n");
+      }
+      else if (asc_ascq == 0x2600)
+      {
+        DBG(DBG_sense, "-> invalid field in parameter list\n");
+      }
+      else if (asc_ascq == 0x2c01)
+      {
+        DBG(DBG_sense, "-> too many windows specified\n");
+      }
+      else if (asc_ascq == 0x2c02)
+      {
+        DBG(DBG_sense, "-> invalid combination of windows specified\n");
+      }
+      else
+      {
+        DBG(DBG_sense, "-> illegal request: asc=%d, ascq=%d\n", asc, ascq);
+      }
+
+      if (len >= 0x11)
+      {
+        if (get_RS_SKSV(result) != 0)
+        {
+          if (get_RS_CD(result) == 0)
+          {
+            DBG(DBG_sense, "-> illegal parameter in CDB\n");
+          }
+          else
+          {
+            DBG(DBG_sense, "-> illegal parameter is in the data parameters sent during data out phase\n");
+          }
+
+          DBG(DBG_sense, "-> error detected in byte %d\n", get_RS_field_pointer(result));
+         }
+      }
+      return SANE_STATUS_IO_ERROR;
+     break;
+
+
+    case 0x06:										   /* unit attention */
+      if (asc_ascq == 0x2900)
+      {
+        DBG(DBG_sense, "-> power on, reset or bus device reset\n");
+      }
+      else if (asc_ascq == 0x3f01)
+      {
+        DBG(DBG_sense, "-> microcode has been changed\n");
+       }
+      else
+      {
+        DBG(DBG_sense, "-> unit attention: asc=%d, ascq=%d\n", asc, ascq);
+      }
+     break;
+
+
+    case 0x09:										  /* vendor specific */
+
+      if (asc == 0x00)
+      {
+        DBG(DBG_sense, "-> button protocoll\n");
+        if (ascq & 1)
+        {
+          dev->button0_pressed = 1;
+          DBG(DBG_sense, "-> button 0 pressed\n");
+        }
+
+        if (ascq & 2)
+        {
+          dev->button1_pressed = 1;
+          DBG(DBG_sense, "-> button 1 pressed\n");
+        }
+
+        if (ascq & 4)
+        {
+          dev->button2_pressed = 1;
+          DBG(DBG_sense, "-> button 2 pressed\n");
+        }
+        return SANE_STATUS_GOOD;
+      }
+      else if (asc_ascq == 0x8001)
+      {
+        DBG(DBG_sense, "-> lamp warmup\n");
+        return SANE_STATUS_DEVICE_BUSY;
+      }
+      else if (asc_ascq == 0x8002)
+      {
+        DBG(DBG_sense, "-> calibration by driver\n");
+        if (dev)
+	{
+          dev->do_calibration = 1;				       /* set flag for calibration by driver */
+        }
+        return SANE_STATUS_GOOD;
+      }
+      else
+      {
+        DBG(DBG_sense, "-> vendor specific sense-code: asc=%d, ascq=%d\n", asc, ascq);
+      }
+     break;
+
+  }
+ return SANE_STATUS_GOOD;
+}
+
+/* ------------------------------------------------------------ UMAX SET RGB BIND -------------------------- */
+
+static void umax_set_rgb_bind(Umax_Scanner *scanner)
+{
+  if ( (scanner->val[OPT_RGB_BIND].w == SANE_FALSE) &&
+       (strcmp(scanner->val[OPT_MODE].s, COLOR_STR) == 0) ) /* enable rgb options */
+  {
+    if (scanner->device->inquiry_analog_gamma)
+    {
+      scanner->opt[OPT_ANALOG_GAMMA].cap   |= SANE_CAP_INACTIVE;
+      scanner->opt[OPT_ANALOG_GAMMA_R].cap &= ~SANE_CAP_INACTIVE;
+      scanner->opt[OPT_ANALOG_GAMMA_G].cap &= ~SANE_CAP_INACTIVE;
+      scanner->opt[OPT_ANALOG_GAMMA_B].cap &= ~SANE_CAP_INACTIVE;
+    }
+    if (scanner->device->inquiry_highlight)
+    {
+      scanner->opt[OPT_HIGHLIGHT].cap   |= SANE_CAP_INACTIVE;
+      scanner->opt[OPT_HIGHLIGHT_R].cap &= ~SANE_CAP_INACTIVE;
+      scanner->opt[OPT_HIGHLIGHT_G].cap &= ~SANE_CAP_INACTIVE;
+      scanner->opt[OPT_HIGHLIGHT_B].cap &= ~SANE_CAP_INACTIVE;
+    }
+    if (scanner->device->inquiry_shadow)
+    {
+      scanner->opt[OPT_SHADOW].cap   |= SANE_CAP_INACTIVE;
+      scanner->opt[OPT_SHADOW_R].cap &= ~SANE_CAP_INACTIVE;
+      scanner->opt[OPT_SHADOW_G].cap &= ~SANE_CAP_INACTIVE;
+      scanner->opt[OPT_SHADOW_B].cap &= ~SANE_CAP_INACTIVE;
+    }
+  }
+  else /* only show gray options */
+  {
+    if (scanner->device->inquiry_analog_gamma)
+    {
+      scanner->opt[OPT_ANALOG_GAMMA].cap   &= ~SANE_CAP_INACTIVE;
+      scanner->opt[OPT_ANALOG_GAMMA_R].cap |= SANE_CAP_INACTIVE;
+      scanner->opt[OPT_ANALOG_GAMMA_G].cap |= SANE_CAP_INACTIVE;
+      scanner->opt[OPT_ANALOG_GAMMA_B].cap |= SANE_CAP_INACTIVE;
+    }
+    if (scanner->device->inquiry_highlight)
+    {
+      scanner->opt[OPT_HIGHLIGHT].cap   &= ~SANE_CAP_INACTIVE;
+      scanner->opt[OPT_HIGHLIGHT_R].cap |= SANE_CAP_INACTIVE;
+      scanner->opt[OPT_HIGHLIGHT_G].cap |= SANE_CAP_INACTIVE;
+      scanner->opt[OPT_HIGHLIGHT_B].cap |= SANE_CAP_INACTIVE;
+    }
+    if (scanner->device->inquiry_shadow)
+    {
+      scanner->opt[OPT_SHADOW].cap   &= ~SANE_CAP_INACTIVE;
+      scanner->opt[OPT_SHADOW_R].cap |= SANE_CAP_INACTIVE;
+      scanner->opt[OPT_SHADOW_G].cap |= SANE_CAP_INACTIVE;
+      scanner->opt[OPT_SHADOW_B].cap |= SANE_CAP_INACTIVE;
+    }
+  }
+
+  if ( (scanner->device->inquiry_exposure_adj) && (scanner->val[OPT_SELECT_EXPOSURE_TIME].w) )
+  {
+    if ( (scanner->val[OPT_RGB_BIND].w == SANE_FALSE) &&
+         (!scanner->device->exposure_time_rgb_bind) &&
+         (strcmp(scanner->val[OPT_MODE].s, COLOR_STR) == 0) ) /* enable rgb exposure time options */
+    {
+      if (scanner->val[OPT_SELECT_CAL_EXPOSURE_TIME].w) /* exposure time setting for calibration enabled */
+      {
+        scanner->opt[OPT_CAL_EXPOS_TIME].cap    |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_CAL_EXPOS_TIME_R].cap  &= ~SANE_CAP_INACTIVE;
+        scanner->opt[OPT_CAL_EXPOS_TIME_G].cap  &= ~SANE_CAP_INACTIVE;
+        scanner->opt[OPT_CAL_EXPOS_TIME_B].cap  &= ~SANE_CAP_INACTIVE;
+      }
+      else /* no separate settings for calibration exposure times */
+      {
+        scanner->opt[OPT_CAL_EXPOS_TIME].cap    |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_CAL_EXPOS_TIME_R].cap  |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_CAL_EXPOS_TIME_G].cap  |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_CAL_EXPOS_TIME_B].cap  |= SANE_CAP_INACTIVE;
+      }
+
+      scanner->opt[OPT_SCAN_EXPOS_TIME].cap   |= SANE_CAP_INACTIVE;
+      scanner->opt[OPT_SCAN_EXPOS_TIME_R].cap &= ~SANE_CAP_INACTIVE;
+      scanner->opt[OPT_SCAN_EXPOS_TIME_G].cap &= ~SANE_CAP_INACTIVE;
+      scanner->opt[OPT_SCAN_EXPOS_TIME_B].cap &= ~SANE_CAP_INACTIVE;
+    }
+    else /* enable gray exposure time options */
+    {
+      if (scanner->val[OPT_SELECT_CAL_EXPOSURE_TIME].w) /* exposure time setting for calibration enabled */
+      {
+        scanner->opt[OPT_CAL_EXPOS_TIME].cap  &= ~SANE_CAP_INACTIVE;
+      }
+      else /* no separate settings for calibration exposure times */
+      {
+        scanner->opt[OPT_CAL_EXPOS_TIME].cap  |= SANE_CAP_INACTIVE;
+      }
+      scanner->opt[OPT_CAL_EXPOS_TIME_R].cap  |= SANE_CAP_INACTIVE;
+      scanner->opt[OPT_CAL_EXPOS_TIME_G].cap  |= SANE_CAP_INACTIVE;
+      scanner->opt[OPT_CAL_EXPOS_TIME_B].cap  |= SANE_CAP_INACTIVE;
+
+      scanner->opt[OPT_SCAN_EXPOS_TIME].cap   &= ~SANE_CAP_INACTIVE;
+      scanner->opt[OPT_SCAN_EXPOS_TIME_R].cap |= SANE_CAP_INACTIVE;
+      scanner->opt[OPT_SCAN_EXPOS_TIME_G].cap |= SANE_CAP_INACTIVE;
+      scanner->opt[OPT_SCAN_EXPOS_TIME_B].cap |= SANE_CAP_INACTIVE;
+    }
+  }
+}
+
+/* ------------------------------------------------------------ UMAX CALCULATE PIXELS ---------------------- */
+
+static int umax_calculate_pixels(int scansize_pixel, int resolution, int resolution_base, int coordinate_base)
+/* scansize_pixel	= size in pixels at 1200 dpi */
+/* resolution		= scan resolution */
+/* resolution_base	= this is the optical resolution * 1 or * 2 */
+/* coordinate_base	= this is 1200 dpi */
+{
+ unsigned int intsize_inch, intsize_pixel, diffsize_pixel, missing_pixels, del_pixel_1, pix;
+ int toomuch;
+
+  intsize_inch   = scansize_pixel / coordinate_base;	/* full inches */
+  intsize_pixel  = intsize_inch * resolution;		/* pixels in full inches */
+
+  diffsize_pixel  = scansize_pixel % coordinate_base;	/* missing pixels in last inch at 1200 dpi */
+  missing_pixels  = diffsize_pixel * resolution_base / coordinate_base; /* missing pixels at resolution_base dpi */
+  del_pixel_1     = resolution_base - resolution;	/* pixels to erase in one inch */
+  toomuch         = 0;					/* number of pixels that must be deleted in last inch  */
+
+  if (del_pixel_1 != 0)					/* search the number of pixels that must deleted */
+  {
+    pix = 0;
+    while (pix <= missing_pixels)
+    {
+      toomuch++;
+      pix = toomuch * resolution_base/del_pixel_1;
+    }
+
+    if (pix > missing_pixels)
+    {
+      toomuch--;
+    }
+  }
+
+  return (intsize_pixel + missing_pixels - toomuch);
+}
+
+/* ------------------------------------------------------------ UMAX FORGET LINE --------------------------- */
+
+
+static int umax_forget_line(Umax_Device *dev, int color)
+/* tests if line related to optical resolution has to be skipped for selected resolution */
+/* returns 0 if line is ok, -1 if line has to be skipped */
+{
+ unsigned int opt_res = dev->relevant_optical_res * dev->scale_y;
+ unsigned int forget;
+
+  dev->pixelline_opt_res++;					 /* increment number of lines in optical res */
+
+  if (opt_res != dev->y_resolution)					    /* are there any lines to skip ? */
+  {
+
+    forget = (dev->pixelline_del[color] * opt_res)/(opt_res - dev->y_resolution);
+
+    if (dev->pixelline_optic[color]++ == forget)
+    {
+      dev->pixelline_del[color]++;					 /* inc pointer to next line to skip */
+      return(-1);										/* skip line */
+    }
+  }
+
+ return(0);									      /* ok, order this line */
+}
+
+
+/* ------------------------------------------------------------ UMAX ORDER LINE TO PIXEL ------------------- */
+
+
+static void umax_order_line_to_pixel(Umax_Device *dev, unsigned char *source, int color)
+/* reads a one-color line and writes it into a pixel-ordered-buffer if line */
+/* is not skipped */
+/* color = 0:red, 1:green, 2:blue */
+{
+ unsigned int i;
+ unsigned int line = dev->pixelline_next[color];					 /* bufferlinenumber */
+ unsigned char *dest = dev->pixelbuffer;
+
+  if (dest != NULL)
+  {
+    if (dev->bits_per_pixel_code == 1)								   /* 24 bpp */
+    {
+      dest += line * dev->width_in_pixels * 3 + color;
+
+      for (i=0; i<dev->width_in_pixels; i++)				   /* cp each pixel into pixelbuffer */
+      {
+        *dest++ = *source++;
+	dest++;
+	dest++;
+      }
+    }
+    else											 /* > 24 bpp */
+    {
+      dest += line * dev->width_in_pixels * 6 + color * 2;
+
+      for(i=0; i<dev->width_in_pixels; i++)				   /* cp each pixel into pixelbuffer */
+      {
+        *dest++ = *source++;					      /* byte order correct ? , don't know ! */
+        *dest++ = *source++;
+
+        dest++; dest++;
+        dest++; dest++;
+      }
+    }
+
+    line++;
+    if (line >= dev->pixelline_max)
+    {
+      line = 0;
+    }
+
+    dev->pixelline_next[color] = line;						  /* next line of this color */
+    dev->pixelline_ready[color]++;					  /* number of ready lines for color */
+
+    DBG(DBG_read, "merged line as color %d to line %d\n", color, dev->pixelline_ready[color]);
+  }
+}
+
+
+/* ------------------------------------------------------------ UMAX ORDER LINE ---------------------------- */
+
+
+static void umax_order_line(Umax_Device *dev, unsigned char *source)
+{
+ unsigned int CCD_distance = dev->CCD_distance * dev->scale_y;
+ unsigned int length = (dev->scanlength * dev->scale_y * dev->relevant_optical_res) / dev->y_coordinate_base;
+ unsigned int color;
+
+  do										   /* search next valid line */
+  {
+    if (dev->pixelline_opt_res < CCD_distance)
+    {
+      color = dev->CCD_color[0];								  /* color 0 */
+    }
+    else if (dev->pixelline_opt_res < CCD_distance * 3)
+    {
+      color = dev->CCD_color[1 + ((dev->pixelline_opt_res - CCD_distance) % 2)];	 	/* color 1,2 */
+    }
+    else if (dev->pixelline_opt_res < length * 3 - CCD_distance * 3) 
+    {
+      color = dev->CCD_color[3 + (dev->pixelline_opt_res % 3)];				      /* color 3,4,5 */
+    }
+    else if (dev->pixelline_opt_res < length * 3 - CCD_distance) 
+    {
+      color = dev->CCD_color[6 + ((dev->pixelline_opt_res - length*3 + CCD_distance*3) % 2)];	/* color 6,7 */
+    }
+    else 
+    {
+      color = dev->CCD_color[8];								  /* color 8 */
+    } 
+  } while(umax_forget_line(dev, color) != 0);					 /* until found correct line */
+
+  umax_order_line_to_pixel(dev, source, color);
+}
+
+
+/* ------------------------------------------------------------ UMAX GET PIXEL LINE ------------------------ */
+
+
+static unsigned char * umax_get_pixel_line(Umax_Device *dev)
+{
+ unsigned char *source = NULL;
+
+  if (dev->pixelbuffer != NULL)
+  {
+    if ( (dev->pixelline_ready[0] > dev->pixelline_written) &&
+         (dev->pixelline_ready[1] > dev->pixelline_written) &&
+         (dev->pixelline_ready[2] > dev->pixelline_written) )
+    {
+      source = dev->pixelbuffer + dev->pixelline_read * dev->width_in_pixels * 3;
+
+      dev->pixelline_written++;
+      dev->pixelline_read++;
+
+      if (dev->pixelline_read >= dev->pixelline_max)
+      {
+        dev->pixelline_read = 0;
+      }
+    }
+  }
+
+  return source;
+}
+
+
+/* ============================================================ Switches between the SCSI and USB commands = */
+
+/* ------------------------------------------------------------ UMAX SCSI CMD ------------------------------ */
+
+static SANE_Status umax_scsi_cmd(Umax_Device *dev, const void *src, size_t src_size, void *dst, size_t * dst_size)
+{
+  switch (dev->connection_type)
+  {
+    case SANE_UMAX_SCSI:
+      return sanei_scsi_cmd(dev->sfd, src, src_size, dst, dst_size);
+     break;
+
+#ifdef UMAX_ENABLE_USB
+    case SANE_UMAX_USB:
+      return sanei_umaxusb_cmd(dev->sfd, src, src_size, dst, dst_size);
+     break;
+#endif
+
+    default:
+      return(SANE_STATUS_INVAL);
+  }
+}
+
+/* ------------------------------------------------------------ UMAX SCSI OPEN EXTENDED -------------------- */
+
+static SANE_Status umax_scsi_open_extended(const char *devicename, Umax_Device *dev,
+                                           SANEI_SCSI_Sense_Handler handler, void *handler_arg, int *buffersize)
+{
+  switch (dev->connection_type) 
+  {
+    case SANE_UMAX_SCSI:
+      return sanei_scsi_open_extended(devicename, &dev->sfd, handler, handler_arg, buffersize);
+     break;
+
+#ifdef UMAX_ENABLE_USB
+    case SANE_UMAX_USB:
+      return sanei_umaxusb_open_extended(devicename, &dev->sfd, handler, handler_arg, buffersize);
+     break;
+#endif
+
+    default:
+      return(SANE_STATUS_INVAL);
+  }
+}
+
+/* ------------------------------------------------------------ UMAX SCSI OPEN ----------------------------- */
+
+static SANE_Status umax_scsi_open(const char *devicename, Umax_Device *dev,
+                                  SANEI_SCSI_Sense_Handler handler, void *handler_arg)
+{
+  switch (dev->connection_type)
+  {
+    case SANE_UMAX_SCSI:
+      return sanei_scsi_open(devicename, &dev->sfd, handler, handler_arg);
+     break;
+
+#ifdef UMAX_ENABLE_USB
+    case SANE_UMAX_USB:
+      return sanei_umaxusb_open(devicename, &dev->sfd, handler, handler_arg);
+     break;
+#endif
+
+    default:
+      return(SANE_STATUS_INVAL);
+  }
+}
+
+/* ------------------------------------------------------------ UMAX SCSI CLOSE ---------------------------- */
+
+static void umax_scsi_close(Umax_Device *dev)
+{
+  switch (dev->connection_type)
+  {
+    case SANE_UMAX_SCSI:
+      sanei_scsi_close(dev->sfd);
+      dev->sfd=-1;
+     break;
+
+#ifdef UMAX_ENABLE_USB
+    case SANE_UMAX_USB:
+      sanei_umaxusb_close(dev->sfd);
+      dev->sfd=-1;
+     break;
+#endif
+  }	
+}
+
+/* ------------------------------------------------------------ UMAX SCSI REQ ENTER ------------------------ */
+
+static SANE_Status umax_scsi_req_enter(Umax_Device *dev, const void *src, size_t src_size,
+                                       void *dst, size_t * dst_size, void **idp)
+{
+  switch (dev->connection_type)
+  {
+    case SANE_UMAX_SCSI:
+      return sanei_scsi_req_enter (dev->sfd, src, src_size, dst, dst_size, idp);
+     break;
+
+#ifdef UMAX_ENABLE_USB
+    case SANE_UMAX_USB:
+      return sanei_umaxusb_req_enter (dev->sfd, src, src_size, dst, dst_size, idp);
+     break;
+#endif
+
+    default:
+      return(SANE_STATUS_INVAL);
+  }
+}
+
+/* ------------------------------------------------------------ UMAX SCSI REQ WAIT ------------------------- */
+
+static SANE_Status umax_scsi_req_wait(Umax_Device *dev, void *id)
+{
+  switch (dev->connection_type)
+  {
+    case SANE_UMAX_SCSI:
+      return sanei_scsi_req_wait(id);
+     break;
+
+#ifdef UMAX_ENABLE_USB
+    case SANE_UMAX_USB:
+      return sanei_umaxusb_req_wait(id);
+     break;
+#endif
+
+    default:
+      return(SANE_STATUS_INVAL);
+  }
+}
+
+/* ------------------------------------------------------------ UMAX SCSI GET LAMP STATUS ------------------ */
+
+
+static SANE_Status umax_scsi_get_lamp_status(Umax_Device *dev, int *lamp_on)
+{
+ SANE_Status status;
+ size_t size = 1;
+
+  DBG(DBG_proc, "umax_scsi_get_lamp_status\n");
+
+  status = umax_scsi_cmd(dev, get_lamp_status.cmd, get_lamp_status.size, dev->buffer[0], &size);
+  if (status)
+  {
+    DBG(DBG_error, "umax_scsi_get_lamp_status: command returned status %s\n", sane_strstatus(status));
+   return status;
+  }
+
+  *lamp_on = get_lamp_status_lamp_on(dev->buffer[0]);
+
+  DBG(DBG_info, "lamp_status = %d\n", *lamp_on);
+
+ return status;
+}
+
+/* ------------------------------------------------------------ UMAX SCSI SET LAMP STATUS ------------------ */
+
+
+static SANE_Status umax_scsi_set_lamp_status(Umax_Device *dev, int lamp_on)
+{
+ SANE_Status status;
+
+  DBG(DBG_proc, "umax_scsi_set_lamp_status\n");
+  DBG(DBG_info, "lamp_status=%d\n", lamp_on);
+
+  set_lamp_status_lamp_on(set_lamp_status.cmd, lamp_on);
+  status = umax_scsi_cmd(dev, set_lamp_status.cmd, set_lamp_status.size, NULL, NULL);
+
+  if (status)
+  {
+    DBG(DBG_error, "umax_scsi_set_lamp_status: command returned status %s\n", sane_strstatus(status));
+  }
+
+ return status;
+}
+
+/* ------------------------------------------------------------ UMAX SET LAMP STATUS ----------------------- */
+
+static SANE_Status umax_set_lamp_status(SANE_Handle handle, int lamp_on)
+{
+ Umax_Scanner *scanner = handle;
+ int lamp_status;
+ SANE_Status status;
+
+  DBG(DBG_proc, "umax_set_lamp_status\n");
+
+  if (umax_scsi_open(scanner->device->sane.name, scanner->device, sense_handler,
+                     scanner->device) != SANE_STATUS_GOOD )
+  {
+     DBG(DBG_error, "ERROR: umax_set_lamp_status: open of %s failed:\n", scanner->device->sane.name);
+     return SANE_STATUS_INVAL;
+  }
+
+  status = umax_scsi_get_lamp_status(scanner->device, &lamp_status);
+
+  if (!status)
+  {
+    status = umax_scsi_set_lamp_status(scanner->device, lamp_on);
+  }
+
+  umax_scsi_close(scanner->device);
+
+ return status;
+}
+
+/* ------------------------------------------------------------ UMAX GET DATA BUFFER STATUS ---------------- */
+
+
+#ifndef UMAX_HIDE_UNUSED									 /* NOT USED */
+static SANE_Status umax_get_data_buffer_status(Umax_Device *dev)
+{
+ SANE_Status status;
+
+  DBG(DBG_proc, "get_data_buffer_status\n");
+  set_GDBS_wait(get_data_buffer_status.cmd,1);					    /* wait for scanned data */
+  status = umax_scsi_cmd(dev, get_data_buffer_status.cmd, get_data_buffer_status.size, NULL, NULL);
+  if (status)
+  {
+    DBG(DBG_error, "umax_get_data_buffer_status: command returned status %s\n", sane_strstatus(status));
+  }  
+
+ return status;
+}
+#endif
+
+
+/* ------------------------------------------------------------ UMAX DO REQUEST SENSE ---------------------- */
+
+
+static void umax_do_request_sense(Umax_Device *dev)
+{
+ size_t size = rs_return_block_size;
+ SANE_Status status;
+
+  DBG(DBG_proc, "do_request_sense\n");
+  set_RS_allocation_length(request_sense.cmd, rs_return_block_size); 
+  status = umax_scsi_cmd(dev, request_sense.cmd, request_sense.size, dev->buffer[0], &size);
+  if (status)
+  {
+    DBG(DBG_error, "umax_do_request_sense: command returned status %s\n", sane_strstatus(status));
+  }  
+}
+
+
+/* ------------------------------------------------------------ UMAX WAIT SCANNER -------------------------- */
+
+
+static SANE_Status umax_wait_scanner(Umax_Device *dev)
+{
+ SANE_Status status;
+ int cnt = 0;
+
+  DBG(DBG_proc, "wait_scanner\n");
+
+  do
+  {
+    if (cnt > 100)							   /* maximal 100 * 0.5 sec = 50 sec */
+    {
+      DBG(DBG_warning, "scanner does not get ready\n");
+      return -1;
+    }
+											  /* test unit ready */
+    status = umax_scsi_cmd(dev, test_unit_ready.cmd, test_unit_ready.size, NULL, NULL);
+    cnt++;
+
+    if (status)
+    {
+      if (cnt == 1)
+      {
+        DBG(DBG_info2, "scanner reports %s, waiting ...\n", sane_strstatus(status));
+      }
+
+      usleep(500000);									 /* wait 0.5 seconds */
+    }
+  } while (status != SANE_STATUS_GOOD );
+
+  DBG(DBG_info, "scanner ready\n");
+
+  return status;
+}
+
+#define WAIT_SCANNER { int status = umax_wait_scanner(dev); if (status) return status; }
+
+
+/* ------------------------------------------------------------ UMAX GRAB SCANNER -------------------------- */
+
+
+static int umax_grab_scanner(Umax_Device *dev)
+{
+ int status;
+
+  DBG(DBG_proc, "grab_scanner\n");
+
+  WAIT_SCANNER;									   /* wait for scanner ready */
+  status = umax_scsi_cmd(dev, reserve_unit.cmd, reserve_unit.size, NULL, NULL);
+
+  if (status)
+  {
+    DBG(DBG_error, "umax_grab_scanner: command returned status %s\n", sane_strstatus(status));
+  }  
+  else
+  {
+    DBG(DBG_info, "scanner reserved\n");
+  }
+
+  return status;
+}
+
+
+/* ------------------------------------------------------------ UMAX REPOSITION SCANNER -------------------- */
+
+
+static int umax_reposition_scanner(Umax_Device *dev)
+{
+ int status;
+ int pause;
+
+  pause = dev->pause_after_reposition + dev->pause_for_moving * (dev->upper_left_y + dev->scanlength) / 
+                                        ( (dev->inquiry_fb_length * dev->y_coordinate_base) );
+
+  DBG(DBG_info2, "trying to reposition scanner ...\n");
+  status = umax_scsi_cmd(dev, object_position.cmd, object_position.size, NULL, NULL);
+  if (status)
+  {
+    DBG(DBG_error, "umax_reposition_scanner: command returned status %s\n", sane_strstatus(status));
+    return status;
+  }
+
+  if (pause > 0) /* predefined time to wait (Astra 2400S) */
+  {
+    DBG(DBG_info2, "pause for repositioning %d msec ...\n", pause);
+    usleep(((long) pause) * 1000);
+    DBG(DBG_info, "repositioning pause done\n");
+  }
+  else if (pause == 0) /* use TEST UNIT READY */
+  {
+    WAIT_SCANNER;
+    DBG(DBG_info, "scanner repositioned\n");
+  }
+  else /* pause < 0 : return without any pause */
+  {
+    DBG(DBG_info, "not waiting for finishing reposition scanner\n");
+  }
+
+  return SANE_STATUS_GOOD;
+}
+
+
+/* ------------------------------------------------------------ UMAX GIVE SCANNER -------------------------- */
+
+
+static int umax_give_scanner(Umax_Device *dev)
+{
+ int status;
+
+  DBG(DBG_info2, "trying to release scanner ...\n");
+  status = umax_scsi_cmd(dev, release_unit.cmd, release_unit.size, NULL, NULL);
+  if (status)
+  {
+    DBG(DBG_error, "umax_give_scanner: command returned status %s\n", sane_strstatus(status));
+  }  
+  else
+  {
+    DBG(DBG_info, "scanner released\n");
+  }
+
+  if (!dev->batch_scan || dev->batch_end)
+  {
+    umax_reposition_scanner(dev);
+  }
+  else
+  {
+    usleep(200000); /* 200 ms pause to make sure program does not exit before scanner is ready */
+  }
+
+  return status;
+}
+
+
+/* ------------------------------------------------------------ UMAX SEND GAMMA DATA ----------------------- */
+
+
+static void umax_send_gamma_data(Umax_Device *dev, void *gamma_data, int color)
+{
+ unsigned char *data = gamma_data;
+ unsigned char *dest;
+ int length;
+ SANE_Status status;
+
+  DBG(DBG_proc, "send_gamma_data\n");
+
+  if (dev->inquiry_gamma_dwload == 0)
+  {
+    DBG(DBG_error, "ERROR: gamma download not available\n");
+    return;
+  }
+  
+  memcpy(dev->buffer[0], send.cmd, send.size);							     /* send */
+  set_S_datatype_code(dev->buffer[0], S_datatype_gamma);					      /* gamma curve */
+
+  dest = dev->buffer[0] + send.size;
+
+  if (dev->inquiry_gamma_DCF == 0)						      /* gamma format type 0 */
+  {
+    DBG(DBG_info, "using gamma download curve format type 0\n");
+
+    memcpy(dest, gamma_DCF0.cmd, gamma_DCF0.size);
+
+    if (color == 1)										/* one color */
+    {
+      set_DCF0_gamma_lines(dest, DCF0_gamma_one_line);
+
+      set_DCF0_gamma_color(dest, 0, DCF0_gamma_color_gray);				        /* grayscale */
+      if ( (dev->colormode == RGB) && (dev->three_pass != 0) )				     /* 3 pass color */
+      {
+        set_DCF0_gamma_color(dest, 0,  dev->three_pass_color);					/* set color */
+      }
+
+      dest = dest + 2;
+      memcpy(dest, data, 1024);								/* copy data */
+
+      set_S_xfer_length(dev->buffer[0], 1026);						       /* set length */
+      status = umax_scsi_cmd(dev, dev->buffer[0], send.size + 1026, NULL, NULL);
+      if (status)
+      {
+        DBG(DBG_error, "umax_send_gamma_data(DCF=0, one color): command returned status %s\n", sane_strstatus(status));
+      }  
+    }
+    else										     /* three colors */
+    {
+      set_DCF0_gamma_lines(dest, DCF0_gamma_three_lines);
+
+      set_DCF0_gamma_color(dest, 0, DCF0_gamma_color_red);					      /* red */
+      set_DCF0_gamma_color(dest, 1, DCF0_gamma_color_green);					    /* green */
+      set_DCF0_gamma_color(dest, 2, DCF0_gamma_color_blue);					     /* blue */
+
+      dest = dest + 2;
+      memcpy(dest, data, 1024);								    /* copy red data */
+
+      dest = dest + 1025;
+      data = data + 1024;
+      memcpy(dest, data, 1024);								  /* copy green data */
+
+      dest = dest + 1025;
+      data = data + 1024;
+      memcpy(dest, data, 1024);								   /* copy blue data */
+
+      set_S_xfer_length(dev->buffer[0], 3076);						       /* set length */
+      status = umax_scsi_cmd(dev, dev->buffer[0], send.size + 3076, NULL, NULL);
+      if (status)
+      {
+        DBG(DBG_error, "umax_send_gamma_data(DCF=0, RGB): command returned status %s\n", sane_strstatus(status));
+      }  
+    }
+  }
+  else if (dev->inquiry_gamma_DCF == 1)						      /* gamma format type 1 */
+  {
+    DBG(DBG_info, "using gamma download curve format type 1\n");
+
+    memcpy(dest, gamma_DCF1.cmd, gamma_DCF1.size);
+
+    set_DCF1_gamma_color(dest, DCF1_gamma_color_gray);					        /* grayscale */
+    if ( (dev->colormode == RGB) && (dev->three_pass != 0) )				     /* 3 pass color */
+    {
+      set_DCF1_gamma_color(dest,  dev->three_pass_color);					/* set color */
+    }
+
+    dest = dest + 2;
+    memcpy(dest, data, 256);									/* copy data */
+
+    set_S_xfer_length(dev->buffer[0], 258);						       /* set length */
+    status = umax_scsi_cmd(dev, dev->buffer[0], send.size + 258, NULL, NULL);
+    if (status)
+    {
+      DBG(DBG_error, "umax_send_gamma_data(DCF=1): command returned status %s\n", sane_strstatus(status));
+    }  
+  }
+  else if (dev->inquiry_gamma_DCF == 2)						      /* gamma format type 2 */
+  {
+    DBG(DBG_info, "using gamma download curve format type 2\n");
+
+    memcpy(dest, gamma_DCF2.cmd, gamma_DCF2.size);
+
+    set_DCF2_gamma_color(dest, DCF2_gamma_color_gray);					        /* grayscale */
+    if ( (dev->colormode == RGB) && (dev->three_pass != 0) )				     /* 3 pass color */
+    { set_DCF2_gamma_color(dest, dev->three_pass_color); }				        /* set color */
+
+    if (color == 1)
+    {
+      set_DCF2_gamma_lines(dest, DCF2_gamma_one_line);
+    }
+    else
+    {
+      set_DCF2_gamma_lines(dest, DCF2_gamma_three_lines);
+    }
+
+    set_DCF2_gamma_input_bits(dest, dev->gamma_input_bits_code);
+    set_DCF2_gamma_output_bits(dest, dev->bits_per_pixel_code);
+
+    dest = dev->buffer[0] + send.size + gamma_DCF2.size;					    /* write to dest */
+
+    if (dev->gamma_input_bits_code & 32)
+    {
+      length = 65536; /* 16 input bits */
+    }
+    else if (dev->gamma_input_bits_code & 16)
+    {
+      length = 16384; /* 14 input bits */
+    }
+    else if (dev->gamma_input_bits_code & 8)
+    {
+      length = 4096; /* 12 input bits */
+    }
+    else if (dev->gamma_input_bits_code & 4)
+    {
+      length = 1024; /* 10 input bits */
+    }
+    else if (dev->gamma_input_bits_code & 2)
+    {
+      length = 512; /* 9 input bits */
+    }
+    else
+    {
+      length = 256; /* 8 input bits */
+    }
+
+    if (dev->bits_per_pixel_code != 1)					/* more than 8 output bits per pixel */
+    {
+      length = length * 2; /* = 2 output bytes */
+    }
+
+    if (dev->bufsize >= color*length+gamma_DCF2.size)
+    {
+      set_S_xfer_length(dev->buffer[0], color*length+gamma_DCF2.size);			       /* set length */
+      memcpy(dest, data, color*length);								/* copy data */
+
+      status = umax_scsi_cmd(dev, dev->buffer[0], send.size+gamma_DCF2.size + length * color, NULL, NULL);
+      if (status)
+      {
+        DBG(DBG_error, "umax_send_gamma_data(DCF=2): command returned status %s\n", sane_strstatus(status));
+      }  
+    }
+    else
+    {
+      DBG(DBG_error, "ERROR: too small scsi buffer (%d bytes) to send gamma data\n", dev->bufsize);
+    }
+  }
+  else
+  {
+    DBG(DBG_error, "ERROR: unknown gamma download curve type for this scanner\n");
+  }
+}
+
+
+/* ------------------------------------------------------------ UMAX SEND DATA  ---------------------------- */
+
+
+static void umax_send_data(Umax_Device *dev, void *data, int size, int datatype)
+{
+ unsigned char *dest;
+ SANE_Status status;
+
+  memcpy(dev->buffer[0], send.cmd, send.size);							     /* send */
+  set_S_datatype_code(dev->buffer[0], datatype);						     /* set datatype */
+  set_S_xfer_length(dev->buffer[0], size);								    /* bytes */
+
+  dest=dev->buffer[0] + send.size;
+  memcpy(dest, data, size);									/* copy data */
+
+  status = umax_scsi_cmd(dev, dev->buffer[0], send.size + size, NULL, NULL);
+  if (status)
+  {
+    DBG(DBG_error, "umax_send_data: command returned status %s\n", sane_strstatus(status));
+  }  
+}
+
+
+/* ------------------------------------------------------------ UMAX SEND HALFTONE PATTERN ----------------- */
+
+
+#ifndef UMAX_HIDE_UNUSED
+static void umax_send_halftone_pattern(Umax_Device *dev, void *data, int size)
+{
+  DBG(DBG_proc,"send_halftone_pattern\n");
+  umax_send_data(dev, data, size*size, S_datatype_halftone);
+}
+#endif
+
+
+/* ------------------------------------------------------------ UMAX SEND SHADING DATA  -------------------- */
+
+
+static void umax_send_shading_data(Umax_Device *dev, void *data, int size)
+{
+  DBG(DBG_proc,"send_shading_data\n");
+  umax_send_data(dev, data, size, S_datatype_shading);
+}
+
+
+/* ------------------------------------------------------------ UMAX SEND GAIN DATA  ----------------------- */
+
+#ifndef UMAX_HIDE_UNUSED
+static void umax_send_gain_data(Umax_Device *dev, void *data, int size)
+{
+  DBG(DBG_proc,"send_gain_data\n");
+  umax_send_data(dev, data, size, S_datatype_gain);
+}
+#endif
+
+
+/* ------------------------------------------------------------ UMAX QUEUE READ IMAGE DATA REQ ------------- */
+
+static SANE_Status umax_queue_read_image_data_req(Umax_Device *dev, unsigned int length, int bufnr)
+{
+ SANE_Status status;
+
+  DBG(DBG_proc, "umax_queue_read_image_data_req for buffer[%d], length = %d\n", bufnr, length);
+
+  set_R_xfer_length(sread.cmd, length);							       /* set length */
+  set_R_datatype_code(sread.cmd, R_datatype_imagedata);					     /* set datatype */
+
+  dev->length_queued[bufnr] = length; /* set length request */
+  dev->length_read[bufnr]   = length; /* set length request, can be changed asyncronous by umax_scsi_req_enter */
+
+  status = umax_scsi_req_enter(dev, sread.cmd, sread.size, dev->buffer[bufnr], &(dev->length_read[bufnr]), &(dev->queue_id[bufnr]));
+  if (status)
+  {
+    DBG(DBG_error, "umax_queue_read_image_data_req: command returned status %s\n", sane_strstatus(status));
+    return -1;
+  }
+  else
+  {
+    DBG(DBG_info2, "umax_queue_read_image_data_req: id for buffer[%d] is %p\n", bufnr, dev->queue_id[bufnr]);
+  }
+
+  return length;
+}
+
+/* ------------------------------------------------------------ UMAX WAIT QUEUED IMAGE DATA ---------------- */
+
+
+static int umax_wait_queued_image_data(Umax_Device *dev, int bufnr)
+{
+ SANE_Status status;
+
+  DBG(DBG_proc, "umax_wait_queued_image_data for buffer[%d] (id=%p)\n", bufnr, dev->queue_id[bufnr]);
+
+  status = umax_scsi_req_wait(dev, dev->queue_id[bufnr]);
+  if (status)
+  {
+    DBG(DBG_error, "umax_wait_queued_image_data: wait returned status %s\n", sane_strstatus(status));
+    return -1;
+  }
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/* ------------------------------------------------------------ UMAX READ DATA ----------------------------- */
+
+
+static int umax_read_data(Umax_Device *dev, size_t length, int datatype)
+{
+ SANE_Status status;
+
+  set_R_xfer_length(sread.cmd, length);							       /* set length */
+  set_R_datatype_code(sread.cmd, datatype);						     /* set datatype */
+
+  status = umax_scsi_cmd(dev, sread.cmd, sread.size, dev->buffer[0], &length);
+  if (status)
+  {
+    DBG(DBG_error, "umax_read_data: command returned status %s\n", sane_strstatus(status));
+    return -1;
+  }  
+
+ return length;
+}
+
+
+/* ------------------------------------------------------------ UMAX READ SHADING DATA  -------------------- */
+
+
+static int umax_read_shading_data(Umax_Device *dev, unsigned int length)
+{
+  DBG(DBG_proc,"read_shading_data\n");
+  return umax_read_data(dev, length, R_datatype_shading);
+}
+
+
+/* ------------------------------------------------------------ UMAX READ GAIN DATA  ----------------------- */
+
+
+#ifndef UMAX_HIDE_UNUSED
+static int umax_read_gain_data(Umax_Device *dev, unsigned int length)
+{
+  DBG(DBG_proc,"read_gain_data\n");
+  return umax_read_data(dev, length, R_datatype_gain);
+}
+#endif
+
+
+/* ------------------------------------------------------------ UMAX READ IMAGE DATA  ---------------------- */
+
+
+#ifndef UMAX_HIDE_UNUSED
+static int umax_read_image_data(Umax_Device *dev, unsigned int length)
+{
+  DBG(DBG_proc,"read_image_data\n");
+  WAIT_SCANNER;
+  return umax_read_data(dev, length, R_datatype_imagedata);
+}
+#endif
+
+
+/* ------------------------------------------------------------ UMAX CORRECT LIGHT ------------------------- */
+
+
+static int umax_correct_light(int light, int analog_gamma_byte)  /* correct highlight/shadow if analog gamma is set */
+{ 
+  double analog_gamma;
+  analog_gamma=analog_gamma_table[analog_gamma_byte];
+  return( (int) 255 * pow(  ((double) light)/255.0 , (1.0/analog_gamma) )+.5 );
+}
+
+
+/* ------------------------------------------------------------ UMAX SET WINDOW PARAM ---------------------- */
+
+
+/* set_window_param sets all the window parameters. This means building a */
+/* fairly complicated SCSI command before sending it...  */
+
+static SANE_Status umax_set_window_param(Umax_Device *dev)
+{
+ SANE_Status status;
+ int num_dblocks = 1;		 		       /* number of window descriptor blocks, usually 1 or 3 */
+ unsigned char buffer_r[max_WDB_size], buffer_g[max_WDB_size], buffer_b[max_WDB_size];
+
+  DBG(DBG_proc, "set_window_param\n");
+  memset(buffer_r, '\0', max_WDB_size);							     /* clear buffer */
+  set_WDB_length(dev->wdb_len);						   /* length of win descriptor block */
+  memcpy(buffer_r, window_descriptor_block.cmd, window_descriptor_block.size);		 /* copy preset data */
+
+  set_WD_wid(buffer_r, 0);								/* window identifier */
+  set_WD_auto(buffer_r, dev->set_auto);					    /* 0 or 1: don't know what it is */
+
+												  /* geometry */
+  set_WD_Xres(buffer_r, dev->x_resolution);					      /* x resolution in dpi */
+  set_WD_Yres(buffer_r, dev->y_resolution);					      /* y resolution in dpi */
+  set_WD_ULX(buffer_r, dev->upper_left_x);						      /* left_edge x */
+  set_WD_ULY(buffer_r, dev->upper_left_y);						     /* upper_edge y */
+  set_WD_width(buffer_r, dev->scanwidth);							    /* width */
+  set_WD_length(buffer_r, dev->scanlength);							   /* length */
+
+												       /* BTC */
+  set_WD_brightness(buffer_r, dev->brightness);					/* brightness, only halftone */
+  set_WD_threshold(buffer_r, dev->threshold);					  /* threshold, only lineart */
+  set_WD_contrast(buffer_r, dev->contrast);					  /* contrast, only halftone */
+    
+									       /* scanmode, preset to LINEART */
+  set_WD_composition(buffer_r, WD_comp_lineart);					/* image composition */
+											     /* = (scan-mode) */
+  set_WD_bitsperpixel(buffer_r, WD_bits_1);				   /* bits/pixel (1,8,9,10,12,14,16) */
+  set_WD_halftone(buffer_r, dev->halftone);					  /* select halftone-pattern */
+  set_WD_RIF(buffer_r, dev->reverse);					  /* reverse, invert black and white */
+  set_WD_speed(buffer_r, dev->WD_speed);						        /* set speed */
+  set_WD_select_color(buffer_r, WD_color_gray);					   /* color for window-block */
+
+						   /* set highlight and shadow in dependence of analog gamma */
+  set_WD_highlight(buffer_r, umax_correct_light(dev->highlight_r, dev->analog_gamma_r));
+  set_WD_shadow(buffer_r, umax_correct_light(dev->shadow_r, dev->analog_gamma_r));
+
+											      /* scan options */
+  set_WD_gamma(buffer_r, dev->digital_gamma_r);						/* set digital gamma */ 
+  set_WD_module(buffer_r, dev->module);						  /* flatbed or transparency */ 
+  set_WD_CBHS(buffer_r, dev->cbhs_range);							/* 50 or 255 */ 
+  set_WD_FF(buffer_r, dev->fix_focus_position);					       /* fix focus position */
+  set_WD_RMIF(buffer_r, dev->reverse_multi);					     /* reverse color-values */
+  set_WD_FDC(buffer_r, dev->lens_cal_in_doc_pos);		    /* lens calibration in document position */
+  set_WD_PF(buffer_r, dev->disable_pre_focus);						/* disable pre focus */
+  set_WD_LCL(buffer_r, dev->holder_focus_pos_0mm);		    /* 0.6mm <-> 0.0mm holder focus position */
+  set_WD_HBT(buffer_r, dev->low_byte_first);			       /* set byte order for 16 bit scanners */
+  set_WD_DOR(buffer_r, dev->dor);						   /* double-resolution-mode */ 
+  set_WD_scan_exposure_level(buffer_r, dev->exposure_time_scan_r);		       /* scan exposure time */
+  set_WD_calibration_exposure_level(buffer_r, dev->exposure_time_calibration_r);/* calibration exposure time */
+
+  set_WD_batch(buffer_r, dev->batch_scan);					     /* batch or normal scan */
+  set_WD_MF(buffer_r, dev->manual_focus);				       /* automatic <-> manual focus */
+  set_WD_line_arrangement(buffer_r, WD_line_arrengement_by_fw);		      /* line arrangement by scanner */
+  set_WD_warmup(buffer_r, dev->warmup);								   /* warmup */
+
+  set_WD_calibration(buffer_r, dev->calibration); 				        /* image calibration */
+
+  set_WD_color_sequence(buffer_r, WD_color_sequence_RGB);				     /* sequence RGB */
+  set_WD_color_ordering(buffer_r, WD_color_ordering_pixel);	      /* set to pixel for pbm, pgm, pnm-file */
+  set_WD_analog_gamma(buffer_r, dev->analog_gamma_r );					     /* analog gamma */
+  set_WD_lamp_c_density(buffer_r, dev->c_density);				   /* calibrat. lamp density */
+  set_WD_lamp_s_density(buffer_r, dev->s_density);					/* scan lamp density */
+  set_WD_next_upper_left(buffer_r, dev->batch_next_tl_y);	      /* batch scan next top left y position */
+  set_WD_pixel_count(buffer_r, dev->width_in_pixels);					      /* pixel count */
+  set_WD_line_count(buffer_r, dev->length_in_pixels);					       /* line count */
+  set_WD_x_coordinate_base(buffer_r, dev->x_coordinate_base);				       /* dpi (1200) */
+  set_WD_y_coordinate_base(buffer_r, dev->y_coordinate_base);				       /* dpi (1200) */
+  set_WD_calibration_data_lines(buffer_r, dev->calib_lines);     /* required lines for calibration by driver */
+
+
+  switch(dev->colormode)
+  {
+     case LINEART:										   /* LINEART */
+      set_WD_composition(buffer_r, WD_comp_lineart);
+      set_WD_bitsperpixel(buffer_r, WD_bits_1);
+
+      set_WD_select_color(buffer_r, WD_color_gray);
+     break;
+
+     case HALFTONE:										  /* HALFTONE */
+      set_WD_composition(buffer_r, WD_comp_dithered);
+      set_WD_bitsperpixel(buffer_r, WD_bits_1);
+
+      set_WD_select_color(buffer_r, WD_color_gray);
+     break;
+
+     case GRAYSCALE:										 /* GRAYSCALE */
+      set_WD_composition(buffer_r, WD_comp_gray);
+      set_WD_bitsperpixel(buffer_r, dev->bits_per_pixel);
+
+      set_WD_select_color(buffer_r, WD_color_gray);
+     break;
+
+     case RGB_LINEART:								              /* COLOR MODES */
+     case RGB_HALFTONE:
+     case RGB:
+      if (dev->colormode == RGB_LINEART )
+      {
+        set_WD_composition(buffer_r, WD_comp_rgb_bilevel);
+        set_WD_bitsperpixel(buffer_r, WD_bits_1);
+      }
+      else if (dev->colormode == RGB_HALFTONE )
+      {
+        set_WD_composition(buffer_r, WD_comp_rgb_dithered);
+        set_WD_bitsperpixel(buffer_r, WD_bits_1);
+      }
+      else /* RGB */
+      {
+        set_WD_composition(buffer_r, WD_comp_rgb_full);
+        set_WD_bitsperpixel(buffer_r, dev->bits_per_pixel);
+      }
+
+      if (dev->three_pass == 0)
+      {											       /* singlepass */
+        num_dblocks = 3;
+
+        if (dev->do_color_ordering != 0)
+	{
+          set_WD_line_arrangement(buffer_r, WD_line_arrengement_by_driver); 
+
+	  if (dev->CCD_distance == 0)
+	  {
+            set_WD_color_ordering(buffer_r, WD_color_ordering_line_no_ccd);
+          }
+	  else
+	  {
+            set_WD_color_ordering(buffer_r, WD_color_ordering_line_w_ccd);
+          }
+        }
+
+        memcpy(buffer_g, buffer_r, max_WDB_size);				       /* copy WDB for green */
+        memcpy(buffer_b, buffer_r, max_WDB_size);					/* copy WDB for blue */
+
+        set_WD_wid(buffer_r, WD_wid_red);					    /* window identifier red */
+        set_WD_wid(buffer_g, WD_wid_green);					  /* window identifier green */
+        set_WD_wid(buffer_b, WD_wid_blue);					   /* window identifier blue */
+
+        set_WD_select_color(buffer_r, WD_color_red);			       /* select red for this window */
+        set_WD_select_color(buffer_g, WD_color_green);			     /* select green for this window */
+        set_WD_select_color(buffer_b, WD_color_blue);			      /* select blue for this window */
+
+        set_WD_gamma(buffer_r, dev->digital_gamma_r);					    /* digital gamma */
+        set_WD_gamma(buffer_g, dev->digital_gamma_g);
+        set_WD_gamma(buffer_b, dev->digital_gamma_b);
+
+        set_WD_analog_gamma(buffer_r, dev->analog_gamma_r);				     /* analog gamma */
+        set_WD_analog_gamma(buffer_g, dev->analog_gamma_g);
+        set_WD_analog_gamma(buffer_b, dev->analog_gamma_b);
+
+							      /* set highlight in dependence of analog gamma */ 
+        set_WD_highlight(buffer_r, umax_correct_light(dev->highlight_r, dev->analog_gamma_r));
+        set_WD_highlight(buffer_g, umax_correct_light(dev->highlight_g, dev->analog_gamma_g));
+        set_WD_highlight(buffer_b, umax_correct_light(dev->highlight_b, dev->analog_gamma_b));
+
+								 /* set shadow in dependence of analog gamma */ 
+        set_WD_shadow(buffer_r, umax_correct_light(dev->shadow_r, dev->analog_gamma_r));
+        set_WD_shadow(buffer_g, umax_correct_light(dev->shadow_g, dev->analog_gamma_g));
+        set_WD_shadow(buffer_b, umax_correct_light(dev->shadow_b, dev->analog_gamma_b));
+
+        set_WD_scan_exposure_level(buffer_r, dev->exposure_time_scan_r);	  /* set scan exposure times */ 
+        set_WD_scan_exposure_level(buffer_g, dev->exposure_time_scan_g);
+        set_WD_scan_exposure_level(buffer_b, dev->exposure_time_scan_b);
+
+        set_WD_calibration_exposure_level(buffer_r, dev->exposure_time_calibration_r);/* set calib exp times */
+        set_WD_calibration_exposure_level(buffer_g, dev->exposure_time_calibration_g);
+        set_WD_calibration_exposure_level(buffer_b, dev->exposure_time_calibration_b);
+      }
+      else
+      {												/* threepass */
+        set_WD_wid(buffer_r, 0);							/* window identifier */
+        set_WD_color_ordering(buffer_r, WD_color_ordering_plane);				     /* ???? */
+
+        if (dev->colormode == RGB_LINEART )
+        {
+          set_WD_composition(buffer_r, WD_comp_lineart);			       /* color-lineart-mode */
+        }
+        else if (dev->colormode == RGB_HALFTONE )
+        {
+          set_WD_composition(buffer_r, WD_comp_dithered);			      /* color-halftone-mode */
+        }
+        else /* RGB */
+        {
+          set_WD_composition(buffer_r, WD_comp_gray);					       /* color-mode */
+        }
+
+        switch (dev->three_pass_color)
+        {
+        case WD_wid_red:
+           set_WD_select_color(buffer_r, WD_color_red);					        /* color red */
+           set_WD_gamma(buffer_r, dev->digital_gamma_r);
+           set_WD_analog_gamma(buffer_r, dev->analog_gamma_r);
+           set_WD_highlight(buffer_r, umax_correct_light(dev->highlight_r, dev->analog_gamma_r));
+           set_WD_shadow(buffer_r, umax_correct_light(dev->shadow_r, dev->analog_gamma_r)); 
+           set_WD_scan_exposure_level(buffer_r, dev->exposure_time_scan_r);
+           set_WD_calibration_exposure_level(buffer_r, dev->exposure_time_calibration_r);
+           break;
+
+        case WD_wid_green:
+           set_WD_select_color(buffer_r, WD_color_green);				      /* color green */
+           set_WD_gamma(buffer_r, dev->digital_gamma_g);
+           set_WD_analog_gamma(buffer_r, dev->analog_gamma_g);
+           set_WD_highlight(buffer_r, umax_correct_light(dev->highlight_g, dev->analog_gamma_g));
+           set_WD_shadow(buffer_r, umax_correct_light(dev->shadow_g, dev->analog_gamma_g));
+           set_WD_scan_exposure_level(buffer_r, dev->exposure_time_scan_g);
+           set_WD_calibration_exposure_level(buffer_r, dev->exposure_time_calibration_g);
+           break;
+
+        case WD_wid_blue:
+           set_WD_select_color(buffer_r, WD_color_blue);				       /* color blue */
+           set_WD_gamma(buffer_r, dev->digital_gamma_b);
+           set_WD_analog_gamma(buffer_r, dev->analog_gamma_b);
+           set_WD_highlight(buffer_r, umax_correct_light(dev->highlight_b, dev->analog_gamma_b));
+           set_WD_shadow(buffer_r, umax_correct_light(dev->shadow_b, dev->analog_gamma_b));
+           set_WD_scan_exposure_level(buffer_r, dev->exposure_time_scan_b);
+           set_WD_calibration_exposure_level(buffer_r, dev->exposure_time_calibration_b);
+           break;
+
+        } /* switch dev->three_pass_color */
+
+      } /* if (single_pass) else (three_pass) */
+     break;
+  } /* switch dev->colormode, case RGB */
+
+										       /* prepare SCSI-BUFFER */
+  memcpy(dev->buffer[0], set_window.cmd, set_window.size);					   /* SET-WINDOW cmd */
+  memcpy(WPDB_OFF(dev->buffer[0]), window_parameter_data_block.cmd, window_parameter_data_block.size);   /* WPDB */
+  set_WPDB_wdbnum(WPDB_OFF(dev->buffer[0]), num_dblocks);					       /* set WD_len */
+  memcpy(WDB_OFF(dev->buffer[0],1), buffer_r, window_descriptor_block.size);		     /* add WD_block */
+
+  if ( num_dblocks == 3)								/* if singelpass RGB */
+  {
+     memcpy(WDB_OFF(dev->buffer[0],2), buffer_g, window_descriptor_block.size);			/* add green */
+     memcpy(WDB_OFF(dev->buffer[0],3), buffer_b, window_descriptor_block.size);			 /* add blue */
+  }
+
+
+  DBG(DBG_info2, "window descriptor block created with %d bytes\n", dev->wdb_len);
+
+  set_SW_xferlen(dev->buffer[0], (window_parameter_data_block.size + (window_descriptor_block.size * num_dblocks)));
+
+  status = umax_scsi_cmd(dev, dev->buffer[0], set_window.size + window_parameter_data_block.size +
+                                              (window_descriptor_block.size * num_dblocks), NULL, NULL);
+  if (status)
+  {
+    DBG(DBG_error, "umax_set_window_param: command returned status %s\n", sane_strstatus(status));
+  }  
+  else
+  {
+    DBG(DBG_info, "window(s) set\n"); 
+  }
+
+ return status;
+}
+
+
+/* ------------------------------------------------------------ UMAX DO INQUIRY ---------------------------- */
+
+
+static void umax_do_inquiry(Umax_Device *dev)
+{
+ size_t size;
+ SANE_Status status;
+
+  DBG(DBG_proc,"do_inquiry\n");
+  memset(dev->buffer[0], '\0', 256);							     /* clear buffer */
+
+  size = 5;
+
+  set_inquiry_return_size(inquiry.cmd, size);  /* first get only 5 bytes to get size of inquiry_return_block */
+  status = umax_scsi_cmd(dev, inquiry.cmd, inquiry.size, dev->buffer[0], &size);
+  if (status)
+  {
+    DBG(DBG_error, "umax_do_inquiry: command returned status %s\n", sane_strstatus(status));
+  }  
+
+  size = get_inquiry_additional_length(dev->buffer[0]) + 5;
+
+  set_inquiry_return_size(inquiry.cmd, size);			        /* then get inquiry with actual size */
+  status = umax_scsi_cmd(dev, inquiry.cmd, inquiry.size, dev->buffer[0], &size);
+  if (status)
+  {
+    DBG(DBG_error, "umax_do_inquiry: command returned status %s\n", sane_strstatus(status));
+  }  
+}
+
+
+/* ------------------------------------------------------------ UMAX START SCAN ---------------------------- */
+
+
+static SANE_Status umax_start_scan(Umax_Device *dev)
+{
+ int size = 1;
+ SANE_Status status;
+
+  DBG(DBG_proc,"start_scan\n");
+
+  if (dev->adf) 							/* ADF selected: test for ADF errors */
+  {
+    umax_do_inquiry(dev);								      /* get inquiry */
+
+    if (get_inquiry_ADF_paper_jam(dev->buffer[0]))					   /* test for ADF paper jam */
+    {
+      DBG(DBG_error,"ERROR: umax_start_scan: ADF paper jam\n");
+      return SANE_STATUS_JAMMED;
+    }
+    else if (get_inquiry_ADF_cover_open(dev->buffer[0]))				  /* test for ADF cover open */
+    {
+      DBG(DBG_error,"ERROR: umax_start_scan: ADF cover open\n");
+      return SANE_STATUS_COVER_OPEN;
+    }
+    else if (get_inquiry_ADF_no_paper(dev->buffer[0]))				    /* test for ADF no paper */
+    {
+      DBG(DBG_error,"ERROR: umax_start_scan: ADF no paper\n");
+      return SANE_STATUS_NO_DOCS;
+    }
+  }
+
+  set_SC_quality(scan.cmd, dev->quality);						  /*  1=qual, 0=fast */
+  set_SC_adf(    scan.cmd, dev->adf);							/* ADF, 0=off, 1=use */
+  set_SC_preview(scan.cmd, dev->preview);							/* 1=preview */
+  
+  set_SC_wid(scan.cmd, 1, 0);								/* Window-Identifier */
+
+  set_SC_xfer_length(scan.cmd, size);							  /* following Bytes */
+
+  DBG(DBG_info,"starting scan\n");
+
+  status = umax_scsi_cmd(dev, scan.cmd, scan.size + size, NULL, NULL);
+  if (status)
+  {
+    DBG(DBG_error, "umax_start_scan: command returned status %s\n", sane_strstatus(status));
+  }  
+
+ return status;
+}
+
+
+/* ------------------------------------------------------------ UMAX DO CALIBRATION ------------------------ */
+
+
+static SANE_Status umax_do_calibration(Umax_Device *dev)
+{
+ SANE_Status status;
+ unsigned int width   = 0;
+ unsigned int lines   = 0;
+ unsigned int bytespp = 0;
+
+  DBG(DBG_proc,"do_calibration\n");
+
+  status = umax_wait_scanner(dev);
+
+  if ((status == SANE_STATUS_GOOD) && (dev->do_calibration != 0))			    /* calibration by driver */
+  {
+   unsigned char *shading_data = 0;
+   unsigned int i, j;
+   long *average;
+
+
+    DBG(DBG_info,"driver is doing calibration\n");
+
+
+    if (umax_execute_request_sense)
+    {
+      DBG(DBG_info,"request sense call is enabled\n");
+      memset(dev->buffer[0], 0, rs_return_block_size);					  /* clear sense data buffer */
+      umax_do_request_sense(dev);					   /* new request-sense call to get all data */
+    }
+    else
+    {
+      DBG(DBG_info,"request sense call is disabled\n");
+    }
+
+    if (get_RS_SCC_condition_code(dev->buffer[0]) != 1)
+    {
+      DBG(DBG_warning,"WARNING: missing information about shading-data\n");
+      DBG(DBG_warning,"         driver tries to guess missing values!\n");
+
+      if ((dev->calibration_area != UMAX_CALIBRATION_AREA_CCD) && (!dev->batch_scan))
+      /* calibration is done with image geometry and depth */
+      {
+        DBG(DBG_warning,"         Calibration is done with selected image geometry and depth!\n");
+
+        width = dev->scanwidth * dev->relevant_optical_res / dev->x_coordinate_base;
+
+        if (dev->calibration_width_offset > -99999) /* driver or user (umax.conf) define an offset */
+        {
+          width = width + dev->calibration_width_offset; 
+          DBG(DBG_warning,"         Using calibration width offset of %d\n", dev->calibration_width_offset);
+        }
+
+        if (dev->colormode == RGB)
+        {
+          width = width * 3;
+        }
+
+        lines   = dev->calib_lines;
+
+        if (dev->gamma_input_bits_code <= 1)
+        {
+          bytespp = 1; /* 8 bit mode */
+        }
+        else
+        {
+          bytespp = 2; /* 16 bit mode */
+        }
+      }
+      else /*  calibration is done with full scanarea and full depth */
+      {
+        DBG(DBG_warning,"         Calibration is done for each CCD pixel with full depth!\n");
+
+        width = (int)(dev->inquiry_fb_width * dev->inquiry_optical_res);
+
+        if (dev->batch_scan)
+        {
+          if (dev->calibration_width_offset_batch > -99999) /* driver or user (umax.conf) define an offset for batch scanning */
+          {
+            width = width + dev->calibration_width_offset_batch; 
+            DBG(DBG_warning,"         Using calibration width offset for batch scanning of %d\n", dev->calibration_width_offset_batch);
+          }
+        }
+        else /* normal scan */
+        {
+          if (dev->calibration_width_offset > -99999) /* driver or user (umax.conf) define an offset */
+          {
+            width = width + dev->calibration_width_offset; 
+            DBG(DBG_warning,"         Using calibration width offset of %d\n", dev->calibration_width_offset);
+          }
+        }
+
+        if (dev->colormode == RGB)
+        {
+          width = width * 3;
+        }
+
+        lines = dev->calib_lines;
+
+        if (dev->gamma_input_bits_code <= 1)
+        {
+          bytespp = 1; /* 8 bit mode */
+         }
+        else
+        {
+          bytespp = 2; /* 16 bit mode */
+        }
+      }
+    }
+    else
+    {
+      lines   =  get_RS_SCC_calibration_lines(dev->buffer[0]);
+      bytespp =  get_RS_SCC_calibration_bytespp(dev->buffer[0]);
+      width   =  get_RS_SCC_calibration_bytesperline(dev->buffer[0]) / bytespp;
+    }
+
+    if (dev->calibration_bytespp > 0) /* correct bytespp if necessary and driver knows about it or user did select it */
+    {
+      bytespp = dev->calibration_bytespp;
+    }
+
+    DBG(DBG_info,"scanner sends %d lines with %d pixels and %d bytes/pixel\n", lines, width, bytespp);
+
+    if (width * bytespp > dev->bufsize)
+    {
+      DBG(DBG_error,"ERROR: scsi buffer is to small for one shading line, calibration aborted\n");
+      DBG(DBG_error,"=> change umax.conf options scsi-buffer-size-min and scsi-buffer-size-max\n");
+     return SANE_STATUS_NO_MEM;
+    }
+
+    /* UMAX S12 sends a kind of uncalibrated image data, bright -> 255, dark -> 0 */
+    /* (although 0 is not black) my scanner sends values around 220 */
+    /* for some scanners the data is simply sent back, other scanners want 255-value as awnswer */
+
+    average = calloc(width, sizeof(long));
+    if (average == 0)
+    {
+      DBG(DBG_error,"ERROR: could not allocate memory for averaging shading data: calibration aborted\n");
+     return SANE_STATUS_NO_MEM;
+    }
+
+    shading_data = calloc(width, bytespp);
+    if (shading_data == 0)
+    {
+      DBG(DBG_error,"ERROR: could not allocate memory for shading data: calibration aborted\n");
+     return SANE_STATUS_NO_MEM;
+    }
+
+    if (bytespp == 1)					 /* 1 byte per pixel */
+    {
+      DBG(DBG_info,"calculating average value for 8 bit shading data!\n");
+
+      for (i=0; i<lines; i++)
+      {
+        umax_read_shading_data(dev, width * bytespp);
+
+        for (j=0; j<width; j++)
+        {
+          average[j] += (long) dev->buffer[0][j];
+        }
+
+        DBG(DBG_read,"8 bit shading-line %d read\n", i+1);
+      }
+
+      for (j=0; j<width; j++)
+      {
+        shading_data[j] = (unsigned char) (average[j] / lines);
+      }
+    }
+    else if (dev->low_byte_first) /* 2 bytes per pixel with low byte first */
+    {
+      DBG(DBG_info,"calculating average value for 16 bit shading data (low byte first)!\n");
+      for (i=0; i<lines; i++)
+      {
+        umax_read_shading_data(dev, width * bytespp);
+
+        for (j=0; j<width; j++)
+        {
+          average[j] += (long) 256 * dev->buffer[0][2*j+1] + dev->buffer[0][2*j] ;
+        }
+
+        DBG(DBG_read,"16 bit shading-line %d read\n", i+1);
+      }
+
+      for (j=0; j<width; j++)
+      {
+        shading_data[2*j+1] = (unsigned char) (average[j] / (256 * lines));
+        shading_data[2*j]   = (unsigned char) (average[j] / lines);
+      }
+    }
+    else					/* 2 bytes per pixel with highbyte first */
+    {
+      DBG(DBG_info,"calculating average value for 16 bit shading data (high byte first)!\n");
+      for (i=0; i<lines; i++)
+      {
+        umax_read_shading_data(dev, width * bytespp);
+
+        for (j=0; j<width; j++)
+        {
+          average[j] += (long) 256 * dev->buffer[0][2*j] + dev->buffer[0][2*j + 1] ;
+        }
+
+        DBG(DBG_read,"16 bit shading-line %d read\n", i+1);
+      }
+
+      for (j=0; j<width; j++)
+      {
+        shading_data[2*j]   = (unsigned char) (average[j] / (256 * lines));
+        shading_data[2*j+1] = (unsigned char) (average[j] / lines);
+      }
+    }
+
+    free(average);
+
+    if ( (dev->invert_shading_data) ) /* invert data */
+    {
+      if (bytespp == 1)
+      {
+        DBG(DBG_info,"inverting 8 bit shading data\n");
+
+        for (j=0; j<width; j++)
+        {
+          shading_data[j] = 255 - shading_data[j];
+        }
+      }
+      else
+      {
+       unsigned int value;
+
+        DBG(DBG_info,"inverting 16 bit shading data\n");
+
+        for (j=0; j<width; j++)
+        {
+          value = shading_data[2*j] + shading_data[2*j+1] * 256;
+          value = 65535 - value;
+          shading_data[2*j]   = (unsigned char) value/256;
+          shading_data[2*j+1] = (unsigned char) value & 255;
+        }
+      }
+    }
+
+    umax_send_shading_data(dev, shading_data, width * bytespp);
+    DBG(DBG_info,"shading-data sent\n");
+    free(shading_data);
+
+    status = umax_start_scan(dev);						      /* now start real scan */
+
+    dev->do_calibration = 0;
+  }
+
+ return status;
+}
+
+
+/* ------------------------------------------------------------ UMAX DO NEW INQUIRY ------------------------ */
+
+
+static void umax_do_new_inquiry(Umax_Device *dev, size_t size)	       /* call inquiry again if wrong length */
+{
+ SANE_Status status;
+
+  DBG(DBG_proc,"do_new_inquiry\n");
+  memset(dev->buffer[0], '\0', 256);							     /* clear buffer */
+
+  set_inquiry_return_size(inquiry.cmd, size);
+  status = umax_scsi_cmd(dev, inquiry.cmd, inquiry.size, dev->buffer[0], &size);
+  if (status)
+  {
+    DBG(DBG_error, "umax_do_new_inquiry: command returned status %s\n", sane_strstatus(status));
+  }  
+}
+
+
+/* ------------------------------------------------------------ UMAX CORRECT INQUIRY ----------------------- */
+
+
+static void umax_correct_inquiry(Umax_Device *dev, char *vendor, char *product, char *version)
+{
+  DBG(DBG_info, "umax_correct_inquiry(\"%s %s %s\")\n", vendor, product, version);
+
+  if (!strncmp(vendor, "UMAX ", 5))
+  {
+    if (!strncmp(product, "Astra 600S ", 11))
+    {
+     int add_len = get_inquiry_additional_length(dev->buffer[0]);
+
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+
+      if (add_len == 0x8f)
+      {
+        DBG(DBG_warning," - correcting wrong inquiry data\n");
+	umax_do_new_inquiry(dev, 0x9b);		  /* get inquiry with correct length */
+        set_inquiry_length(dev->buffer[0], 0x9e); /* correct inquiry len */
+					      /* correct color-ordering from pixel to line_with_ccd_distance */
+        set_inquiry_color_order(dev->buffer[0], IN_color_ordering_line_w_ccd);
+	set_inquiry_fb_uta_line_arrangement_mode(dev->buffer[0], 32);
+	set_inquiry_CCD_line_distance(dev->buffer[0], 8);
+        /* we should reset ADF-bit here too */
+
+        if (dev->invert_shading_data == -1) /* nothing defined in umax.conf */
+        {
+          DBG(DBG_warning," - activating inversion of shading data\n");
+          dev->invert_shading_data = 1;
+        }
+      }
+    }
+    else if (!strncmp(product, "Astra 610S ", 11))
+    {
+     int add_len = get_inquiry_additional_length(dev->buffer[0]);
+
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+
+      if (add_len == 0x8f)
+      {
+        DBG(DBG_warning," - correcting wrong inquiry data\n");
+	umax_do_new_inquiry(dev, 0x9b);		  /* get inquiry with correct length */
+        set_inquiry_length(dev->buffer[0], 0x9e); /* correct inquiry len */
+					      /* correct color-ordering from pixel to line_with_ccd_distance */
+        set_inquiry_color_order(dev->buffer[0], IN_color_ordering_line_w_ccd);
+	set_inquiry_fb_uta_line_arrangement_mode(dev->buffer[0], 33);
+	set_inquiry_CCD_line_distance(dev->buffer[0], 8);
+
+        if (dev->invert_shading_data == -1) /* nothing defined in umax.conf */
+        {
+          DBG(DBG_warning," - activating inversion of shading data\n");
+          dev->invert_shading_data = 1;
+        }
+      }
+    }
+    else if ( (!strncmp(product, "Astra 1200S ", 12)) ||
+              (!strncmp(product, "Perfection600 ", 14)) )
+    {
+      DBG(DBG_warning,"using standard options for %s\n", product);
+    }
+    else if (!strncmp(product, "Astra 1220S ", 12))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+
+      if (dev->gamma_lsb_padded == -1) /* nothing defined in umax.conf and not by backend */
+      {
+        DBG(DBG_warning," - 16 bit gamma table is created lsb padded\n");
+        dev->gamma_lsb_padded = 1;
+      }
+
+      if (!strncmp(version, "V1.5 ", 4))
+      {
+        DBG(DBG_warning," - lamp control enabled for version %s\n", version);
+        dev->lamp_control_available = 1;
+      }
+    }
+    else if (!strncmp(product, "Astra 2100S ", 12))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+      DBG(DBG_warning," - lamp control enabled\n");
+      dev->lamp_control_available = 1;
+
+      if (dev->calibration_bytespp == -1) /* no calibration-bytespp defined in umax.conf */
+      {
+        DBG(DBG_warning," - setting calibration_bytespp = 1\n");
+        dev->calibration_bytespp = 1; /* scanner says 2 bytespp for calibration but 1 bytepp is correct */
+      }
+    }
+    else if (!strncmp(product, "Astra 2200 ", 11))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+      DBG(DBG_warning," - lamp control enabled\n");
+      dev->lamp_control_available = 1;
+
+      if (dev->calibration_area == -1) /* no calibration area defined in umax.conf */
+      {
+        DBG(DBG_warning," - calibration by driver is done for each CCD pixel\n");
+        dev->calibration_area = UMAX_CALIBRATION_AREA_CCD;
+      }
+
+      if (dev->calibration_bytespp == -1) /* no calibration-bytespp defined in umax.conf */
+      {
+        DBG(DBG_warning," - setting calibration_bytespp = 2\n");
+        dev->calibration_bytespp = 2;
+      }
+
+      DBG(DBG_warning," - common x and y resolution\n");
+      dev->common_xy_resolutions = 1;
+
+      if (dev->connection_type == SANE_UMAX_USB)
+      {
+        DBG(DBG_warning," - disabling quality calibration for USB connection\n");
+	set_inquiry_fw_quality(dev->buffer[0], 0);
+      }
+    }
+    else if (!strncmp(product, "Astra 2400S ", 12))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+      DBG(DBG_warning," - defining pauses\n");
+      dev->pause_for_color_calibration = 7000;		/* pause between start_scan and do_calibration in ms */
+      dev->pause_for_gray_calibration = 4000;		/* pause between start_scan and do_calibration in ms */
+      dev->pause_after_calibration = 0000;		 /* pause between do_calibration and read data in ms */
+      dev->pause_after_reposition = 3000;			      /* pause after repostion scanner in ms */
+      dev->pause_for_moving = 3000;			         /* pause for moving scanhead over full area */
+
+      DBG(DBG_warning," - correcting ADF bit in inquiry\n");
+      set_inquiry_sc_adf(dev->buffer[0], 1);		   /* set second bit that indicates ADF is supported */
+    }
+    else if (!strncmp(product, "Vista-T630 ", 11))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+
+      if (dev->slow == -1) /* option is not predefined in umax.conf */
+      {
+        DBG(DBG_warning," - activating slow option\n");
+        dev->slow = 1;
+      }
+    }
+    else if (!strncmp(product, "UC630 ", 6))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+      DBG(DBG_warning," - reposition_scanner waits until move of scan head has finished\n");
+      dev->pause_after_reposition = 0;	    /* call wait_scanner */
+    }
+    else if (!strncmp(product, "UC840 ", 6))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+      DBG(DBG_warning," - reposition_scanner waits until move of scan head has finished\n");
+      dev->pause_after_reposition = 0;	    /* call wait_scanner */
+    }
+    else if (!strncmp(product, "UC1260 ", 7))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+      DBG(DBG_warning," - setting gamma download curve format to type 1\n");
+      dev->inquiry_gamma_DCF = 1;				       /* define gamma download curve format */
+      DBG(DBG_warning," - reposition_scanner waits until move of scan head has finished\n");
+      dev->pause_after_reposition = 0;     /* call wait_scanner */
+    }
+    else if (!strncmp(product, "UC1200S ", 8))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+      DBG(DBG_warning," - setting gamma download curve format to type 1\n");
+      dev->inquiry_gamma_DCF = 1;				       /* define gamma download curve format */
+    }
+    else if (!strncmp(product, "UC1200SE ", 9))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+      DBG(DBG_warning," - setting gamma download curve format to type 0\n");
+      dev->inquiry_gamma_DCF = 0;				       /* define gamma download curve format */
+    }
+    else if (!strncmp(product, "ARCUS PLUS ", 11))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+      DBG(DBG_warning," - setting gamma download curve format to type 0\n");
+      dev->inquiry_gamma_DCF = 0;				       /* define gamma download curve format */
+    }
+    else if ( (!strncmp(product, "UMAX S-12G ", 11)) ||
+              (!strncmp(product, "UMAX S-12 ", 10)) ||
+              (!strncmp(product, "SuperVista S-12 ", 16)) )
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+
+      DBG(DBG_warning," - setting maximum calibration data lines to 66\n");
+      set_inquiry_max_calibration_data_lines(dev->buffer[0], 66);
+
+      if (dev->calibration_width_offset == -99999) /* no calibration-width-offset defined in umax.conf */
+      {
+        dev->calibration_width_offset = -1;
+        DBG(DBG_warning," - adding calibration width offset of %d pixels\n", dev->calibration_width_offset);
+      }
+
+      if (dev->calibration_area == -1) /* no calibration area defined in umax.conf */
+      {
+        DBG(DBG_warning," - calibration by driver is done for each CCD pixel\n");
+        dev->calibration_area = UMAX_CALIBRATION_AREA_CCD;
+      }
+    }
+    else if (!strncmp(product, "Mirage D-16L ", 13))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+      if (dev->calibration_area == -1) /* no calibration area defined in umax.conf */
+      {
+        DBG(DBG_warning," - calibration by driver is done for each CCD pixel\n");
+        dev->calibration_area = UMAX_CALIBRATION_AREA_CCD;
+      }
+
+      if (dev->calibration_width_offset == -99999) /* no calibration-width-offset defined in umax.conf */
+      {
+        dev->calibration_width_offset = 308;
+        DBG(DBG_warning," - adding calibration width offset of %d pixels\n", dev->calibration_width_offset);
+      }
+    }
+    else if (!strncmp(product, "PowerLook III ", 14))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+
+      if (dev->calibration_width_offset == -99999) /* no calibration-width-offset defined in umax.conf */
+      {
+        dev->calibration_width_offset = 28;
+        DBG(DBG_warning," - adding calibration width offset of %d pixels\n", dev->calibration_width_offset);
+      }
+      /* calibration_area = image */
+
+      if (dev->calibration_width_offset_batch == -99999) /* no calibration-width-offset for batch scanning defined in umax.conf */
+      {
+        dev->calibration_width_offset_batch = 828;
+        DBG(DBG_warning," - adding calibration width offset for batch scanning of %d pixels\n", dev->calibration_width_offset_batch);
+      }
+    }
+    else if (!strncmp(product, "Power Look 2000", 15))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+
+      if (dev->calibration_width_offset == -99999) /* no calibration-width-offset defined in umax.conf */
+      {
+        dev->calibration_width_offset = 22;
+        DBG(DBG_warning," - adding calibration width offset of %d pixels\n", dev->calibration_width_offset);
+      }
+      /* calibration_area = image */
+
+      if (dev->calibration_width_offset_batch == -99999) /* no calibration-width-offset for batch scanning defined in umax.conf */
+      {
+        dev->calibration_width_offset_batch = 24;
+        DBG(DBG_warning," - adding calibration width offset for batch scanning of %d pixels\n", dev->calibration_width_offset_batch);
+      }
+    }
+    else if (!strncmp(product, "PowerLook 2100XL", 16))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+
+      if (dev->calibration_width_offset == -99999) /* no calibration-width-offset defined in umax.conf */
+      {
+        dev->calibration_width_offset = 52;
+        DBG(DBG_warning," - adding calibration width offset of %d pixels\n", dev->calibration_width_offset);
+      }
+      /* calibration_area = image */
+
+      if (dev->calibration_width_offset_batch == -99999) /* no calibration-width-offset for batch scanning defined in umax.conf */
+      {
+        dev->calibration_width_offset_batch = 1052;
+        DBG(DBG_warning," - adding calibration width offset for batch scanning of %d pixels\n", dev->calibration_width_offset_batch);
+      }
+
+      dev->force_quality_calibration = 1;
+      DBG(DBG_warning," - always set quality calibration\n");
+
+      /* the scanner uses the same exposure times for red, green and blue exposure_time_rgb_bind = 1 */
+    }
+    else if (!strncmp(product, "PowerLook 3000 ", 15))
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+
+      if (dev->calibration_width_offset == -99999) /* no calibration-width-offset defined in umax.conf */
+      {
+        dev->calibration_width_offset = 52;
+        DBG(DBG_warning," - adding calibration width offset of %d pixels\n", dev->calibration_width_offset);
+      }
+      /* calibration_area = image */
+
+      if (dev->calibration_width_offset_batch == -99999) /* no calibration-width-offset for batch scanning defined in umax.conf */
+      {
+        /* not tested */
+        dev->calibration_width_offset_batch = 1052;
+        DBG(DBG_warning," - adding calibration width offset for batch scanning of %d pixels\n", dev->calibration_width_offset_batch);
+      }
+    }
+    else
+    {
+      DBG(DBG_warning,"using standard options for %s\n", product);
+    }
+  }
+  else if (!strncmp(vendor, "LinoHell ", 9))
+  {
+    if ( (!strncmp(product, "Office ", 7)) || (!strncmp(product, "JADE ", 5)) ) /* is a Supervista S-12 */
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+
+      DBG(DBG_warning," - setting maximum calibration data lines to 66\n");
+      set_inquiry_max_calibration_data_lines(dev->buffer[0], 66);
+
+      if (dev->calibration_width_offset == -99999) /* no calibration-width-offset defined in umax.conf */
+      {
+        dev->calibration_width_offset = -1;
+        DBG(DBG_warning," - adding calibration width offset of %d pixels\n", dev->calibration_width_offset);
+      }
+
+      if (dev->calibration_area == -1) /* no calibration area defined in umax.conf */
+      {
+        DBG(DBG_warning," - calibration by driver is done for each CCD pixel\n");
+        dev->calibration_area = UMAX_CALIBRATION_AREA_CCD;
+      }
+    }
+    else if (!strncmp(product, "OPAL2 ", 6)) /* looks like a Mirage II */
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+
+      if (dev->gamma_lsb_padded == -1) /* nothing defined in umax.conf and not by backend */
+      {
+        DBG(DBG_warning," - 16 bit gamma table is created lsb padded\n");
+        dev->gamma_lsb_padded = 1;
+      }
+    }
+  }
+  else if (!strncmp(vendor, "Linotype ", 9))
+  {
+    if (!strncmp(product, "SAPHIR4 ", 8)) /* is a Powerlook III */
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+
+      if (dev->calibration_width_offset == -99999) /* no calibration-width-offset defined in umax.conf */
+      {
+        dev->calibration_width_offset = 28;
+        DBG(DBG_warning," - adding calibration width offset of %d pixels\n", dev->calibration_width_offset);
+      }
+      /* calibration_area = image */
+
+      if (dev->calibration_width_offset_batch == -99999) /* no calibration-width-offset for batch scanning defined in umax.conf */
+      {
+        dev->calibration_width_offset_batch = 828;
+        DBG(DBG_warning," - adding calibration width offset for batch scanning of %d pixels\n", dev->calibration_width_offset_batch);
+      }
+    }
+  }
+  else if (!strncmp(vendor, "HDM ", 4))
+  {
+    if (!strncmp(product, "LS4H1S ", 7)) /* is a Powerlook III */
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+
+      if (dev->calibration_width_offset == -99999) /* no calibration-width-offset defined in umax.conf */
+      {
+        dev->calibration_width_offset = 28;
+        DBG(DBG_warning," - adding calibration width offset of %d pixels\n", dev->calibration_width_offset);
+      }
+      /* calibration_area = image */
+
+      if (dev->calibration_width_offset_batch == -99999) /* no calibration-width-offset for batch scanning defined in umax.conf */
+      {
+        dev->calibration_width_offset_batch = 828;
+        DBG(DBG_warning," - adding calibration width offset for batch scanning of %d pixels\n", dev->calibration_width_offset_batch);
+      }
+    }
+  }
+  else if (!strncmp(vendor, "ESCORT ", 7))
+  {
+    if (!strncmp(product, "Galleria 600S ", 14)) /* this is an Astra 600S */
+    {
+     int add_len = get_inquiry_additional_length(dev->buffer[0]);
+
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+
+      if (add_len == 0x8f)
+      {
+        DBG(DBG_warning," - correcting wrong inquiry data\n");
+	umax_do_new_inquiry(dev, 0x9b);		  /* get inquiry with correct length */
+        set_inquiry_length(dev->buffer[0], 0x9e); /* correct inquiry len */
+					      /* correct color-ordering from pixel to line_with_ccd_distance */
+        set_inquiry_color_order(dev->buffer[0], IN_color_ordering_line_w_ccd);
+	set_inquiry_fb_uta_line_arrangement_mode(dev->buffer[0], 32);
+	set_inquiry_CCD_line_distance(dev->buffer[0], 8);
+        /* we should reset ADF-bit here too */
+
+        if (dev->invert_shading_data == -1) /* nothing defined in umax.conf */
+        {
+          DBG(DBG_warning," - activating inversion of shading data\n");
+          dev->invert_shading_data = 1;
+        }
+      }
+    }
+  }
+  else if (!strncmp(vendor, "TriGem ", 7))
+  {
+    if (!strncmp(product, "PowerScanII ", 12)) /* is a Supervista S-12 */
+    {
+      DBG(DBG_warning,"setting up special options for %s\n", product);
+
+      DBG(DBG_warning," - setting maximum calibration data lines to 66\n");
+      set_inquiry_max_calibration_data_lines(dev->buffer[0], 66);
+
+      if (dev->calibration_width_offset == -99999) /* no calibration-width-offset defined in umax.conf */
+      {
+        dev->calibration_width_offset = -1;
+        DBG(DBG_warning," - adding calibration width offset of %d pixels\n", dev->calibration_width_offset);
+      }
+
+      if (dev->calibration_area == -1) /* no calibration area defined in umax.conf */
+      {
+        DBG(DBG_warning," - calibration by driver is done for each CCD pixel\n");
+        dev->calibration_area = UMAX_CALIBRATION_AREA_CCD;
+      }
+    }
+  }
+}
+
+
+/* ------------------------------------------------------------ UMAX IDENTIFY SCANNER ---------------------- */
+
+
+static int umax_identify_scanner(Umax_Device *dev)
+{
+ char vendor[10];
+ char product[0x12];
+ char version[6];
+ char *pp;
+
+  DBG(DBG_proc,"identify_scanner\n");
+  umax_do_inquiry(dev);									      /* get inquiry */
+  if (get_inquiry_periph_devtype(dev->buffer[0]) != IN_periph_devtype_scanner) { return 1; }      /* no scanner */
+
+  get_inquiry_vendor( (char *)dev->buffer[0], vendor);  vendor[8]   = ' '; vendor[9]   = '\0';
+  get_inquiry_product((char *)dev->buffer[0], product); product[16] = ' '; product[17] = '\0';
+  get_inquiry_version((char *)dev->buffer[0], version); version[4]  = ' '; version[5]  = '\0';
+
+  pp = &vendor[8];
+  while (*(pp-1) == ' ')
+  {
+    *pp-- = '\0';
+  }
+
+  pp = &product[0x10];
+  while (*(pp-1) == ' ')
+  {
+    *pp-- = '\0';
+  }
+  
+  pp = &version[4];
+  while (*pp == ' ')
+  {
+    *pp-- = '\0';
+  }
+
+  DBG(DBG_info, "Found %s scanner %sversion %s on device %s\n", vendor, product, version, dev->devicename);
+
+					      /* look for scanners that do not give all inquiry-information */
+							   /* and if possible use driver-known inquiry-data  */
+
+  if (get_inquiry_additional_length(dev->buffer[0])>=0x8f)
+  {
+    int i = 0;
+    while (strncmp("END_OF_LIST", scanner_str[2*i], 11) != 0)	     /* Now identify full supported scanners */
+    {
+      if (!strncmp(vendor, scanner_str[2*i], strlen(scanner_str[2*i])) )
+      { 
+        if (!strncmp(product, scanner_str[2*i+1], strlen(scanner_str[2*i+1])) )
+        {
+	  umax_correct_inquiry(dev, vendor, product, version);
+          return 0;
+        } 
+      }
+      i++;
+    }
+
+    if (strncmp(vendor, "UMAX ", 5)) { return 1; }				      /* not UMAX then abort */
+
+    DBG(DBG_error0, "WARNING: %s scanner %s version %s on device %s\n"
+     "is currently an unrecognized device for this backend version.\n"
+     "Please make sure you use the most recent version of the umax backend.\n"
+     "You can download new umax-backend versions from:\n"
+     "http://www.rauch-domain.de/sane-umax\n",
+     vendor, product, version, dev->devicename);
+
+    DBG(DBG_error0,
+     "Inquiry seems to be ok.\n"
+     "******************************************************************\n"
+     "***             !!!! CONTINUE AT YOUR OWN RISK !!!!            ***\n"
+     "******************************************************************\n"
+     "If you already use the most recent umax-backend version\n"
+     "then please contact me: Oliver.Rauch@rauch-domain.de\n");
+
+    return 0; 
+  }
+  else									        /* inquiry-data not complete */
+  if (!strncmp(vendor, "UMAX ", 5)) /* test UMAX-scanners with short inquiry */
+  {
+   inquiry_blk inq_data;
+   int  i;
+
+    for(i=0; i < known_inquiry; i++)
+    {
+      inq_data = *inquiry_table[i];
+      if (!strncmp(product, inq_data.scanner, strlen(inq_data.scanner))) 
+      {
+	DBG(DBG_warning, "inquiry-block-length: %d\n", get_inquiry_additional_length(dev->buffer[0])+5);
+	DBG(DBG_warning, "using driver-internal inquiry-data for this scanner!\n");
+
+						      /* copy driver-defined inquiry-data into inquiry-block */
+        memcpy(dev->buffer[0]+0x24, inq_data.inquiry, inq_data.inquiry_len-0x24);
+
+        /* correct variables */
+        set_inquiry_sc_uta(dev->buffer[0], get_inquiry_transavail(dev->buffer[0]));	/* transparancy available ? */
+        set_inquiry_sc_adf(dev->buffer[0], get_inquiry_scanmode(dev->buffer[0]));	/* automatic document feeder available ? */
+
+        set_inquiry_length(dev->buffer[0], inq_data.inquiry_len); 
+        umax_correct_inquiry(dev, vendor, product, version);
+
+        return 0;										       /* ok */
+      }
+    }
+    DBG(DBG_error0, "ERROR: %s scanner %s version %s on device %s\n"
+         "is currently an unrecognized device, and inquiry is too short,\n"
+         "so we are not able to continue!\n"
+         "Please make sure you use the most recent version of the umax backend.\n"
+         "You can download new umax-backend versions from:\n"
+         "http://www.rauch-domain.de/sane-umax\n"
+         "You already use the most recent umax-backend version:\n"
+         "Please contact me: Oliver.Rauch@rauch-domain.de\n",
+         vendor, product, version, dev->devicename);
+  }
+
+ return 1;				    /* NO SUPPORTED SCANNER: short inquiry-block and unknown scanner */
+}
+
+
+/* ------------------------------------------------------------ UMAX TRIM BUFSIZE -------------------------- */
+
+
+static void umax_trim_rowbufsize(Umax_Device *dev)
+{
+ unsigned int lines=0;
+
+  if (dev->row_bufsize > dev->row_len)
+  {
+    lines = dev->row_bufsize / dev->row_len;
+
+    if (lines > dev->lines_max) /* reduce number of lines to scan if set up in config file */
+    {
+      lines = dev->lines_max;
+    }
+
+    dev->row_bufsize = lines * dev->row_len;
+  }
+
+  DBG(DBG_proc,"trim_rowbufsize: row_bufsize = %d bytes = %d lines\n", dev->row_bufsize, lines);
+}
+
+
+/* ------------------------------------------------------------ UMAX CALCULATE EXPOSURE TIME --------------- */
+
+  
+static void umax_calculate_exposure_time(Umax_Device *dev, int def, int *value)
+{
+ int level;
+
+  DBG(DBG_proc,"calculate_exposure_time\n");
+  if ( (*value))
+  {
+    if ( (*value) == -1 ) { (*value) = def; }
+    else
+    {
+      level = (*value) / dev->inquiry_exposure_time_step_unit;
+      (*value) = inrange(dev->use_exposure_time_min, level, dev->inquiry_exposure_time_max);
+    }
+  }
+}
+
+			  
+/* ------------------------------------------------------------ UMAX CHECK VALUES -------------------------- */
+
+
+static int umax_check_values(Umax_Device *dev)
+{
+ double inquiry_x_orig;
+ double inquiry_y_orig;
+ double inquiry_width;
+ double inquiry_length;
+ unsigned int maxwidth;
+ unsigned int maxlength;
+
+  DBG(DBG_proc,"check_values\n");
+
+  /* ------------------------------- flatbed ------------------------------- */
+
+  dev->module = WD_module_flatbed;					  /* reset scanmode to flatbed first */
+
+  /* --------------------------------- uta --------------------------------- */
+
+  if (dev->uta != 0) 
+  {
+    dev->module = WD_module_transparency;
+    if ( (dev->inquiry_uta == 0) || (dev->inquiry_transavail == 0) )
+    {
+      DBG(DBG_error, "ERROR: transparency mode not supported by scanner\n");
+     return(1);
+    }
+  }
+
+  /* --------------------------------- adf --------------------------------- */
+
+  if (dev->adf != 0) 
+  {
+    if (dev->inquiry_adf == 0)
+    {
+      DBG(DBG_error,"ERROR: adf mode not supported by scanner\n");
+     return(1);
+    }
+  }
+
+  /* --------------------------------- dor --------------------------------- */
+
+  if (dev->dor != 0)
+  {
+    if (dev->inquiry_dor == 0)
+    {
+      DBG(DBG_error, "ERROR: double optical resolution not supported by scanner\n");
+     return(1); 
+    }
+  }
+
+  /* ------------------------------- resolution ------------------------ */
+
+  if (dev->dor == 0) /* standard (FB) */
+  {
+    dev->relevant_optical_res = dev->inquiry_optical_res;
+    dev->relevant_max_x_res   = dev->inquiry_x_res;
+    dev->relevant_max_y_res   = dev->inquiry_y_res;
+  }
+  else /* DOR mode */
+  {
+    dev->relevant_optical_res = dev->inquiry_dor_optical_res;
+    dev->relevant_max_x_res   = dev->inquiry_dor_x_res;
+    dev->relevant_max_y_res   = dev->inquiry_dor_y_res;
+  }
+
+  if (dev->x_resolution <= 0)
+  {
+    DBG(DBG_error,"ERROR: no x-resolution given\n");
+    return(1);
+  }
+
+  if (dev->x_resolution > dev->relevant_max_x_res)
+  {
+    dev->x_resolution = dev->relevant_max_x_res;
+  }
+
+  if (dev->x_resolution > dev->relevant_optical_res)
+  {
+    dev->scale_x = 2;
+  }
+  else
+  {
+    dev->scale_x = 1;
+  }
+
+  if (dev->y_resolution <= 0)
+  {
+    DBG(DBG_error,"ERROR: no y-resolution given\n");
+    return(1);
+  }
+
+  if (dev->y_resolution > dev->relevant_max_y_res)
+  {
+    dev->y_resolution = dev->relevant_max_y_res;
+  }
+
+  if (dev->y_resolution > dev->relevant_optical_res)
+  {
+    dev->scale_y = 2;
+  }
+  else if (dev->y_resolution > dev->relevant_optical_res/2)
+  {
+    dev->scale_y = 1;
+  }
+  else
+  {
+    /* astra 600S and 610S need this in umax_forget_line */
+    dev->scale_y = 0.5;
+  }
+
+
+  /* ------------------------------- scanarea ------------------------ */
+
+  if (dev->module == WD_module_flatbed)							     /* flatbed mode */
+  {
+    inquiry_x_orig = 0;								   /* flatbed origin */
+    inquiry_y_orig = 0;
+    inquiry_width  = dev->inquiry_fb_width;						    /* flatbed width */
+    inquiry_length = dev->inquiry_fb_length;
+  }
+  else										        /* transparency mode */
+  {
+    inquiry_x_orig = dev->inquiry_uta_x_off;						       /* uta origin */
+    inquiry_y_orig = dev->inquiry_uta_y_off;
+    inquiry_width  = dev->inquiry_uta_x_off + dev->inquiry_uta_width;				/* uta width */
+    inquiry_length = dev->inquiry_uta_y_off + dev->inquiry_uta_length;
+  }
+
+  if (dev->dor != 0)
+  {
+    inquiry_x_orig = dev->inquiry_dor_x_off;						       /* dor origin */
+    inquiry_y_orig = dev->inquiry_dor_y_off;
+    inquiry_width  = dev->inquiry_dor_x_off + dev->inquiry_dor_width;				/* dor width */
+    inquiry_length = dev->inquiry_dor_y_off + dev->inquiry_dor_length;
+  }
+
+							     /* limit the size to what the scanner can scan. */
+					   /* this is particularly important because the scanners don't have */
+				  /* built-in checks and will happily grind their gears if this is exceeded. */
+
+
+  maxwidth = inquiry_width  * dev->x_coordinate_base - dev->upper_left_x - 1;
+
+  if ( (dev->scanwidth <= 0) || (dev->scanwidth > maxwidth) )
+  {
+    dev->scanwidth = maxwidth;
+  }
+
+  if (dev->upper_left_x < inquiry_x_orig)
+  {
+    dev->upper_left_x = inquiry_x_orig;
+  }
+
+
+  maxlength = inquiry_length * dev->y_coordinate_base - dev->upper_left_y - 1;
+
+  if ( (dev->scanlength <= 0) || (dev->scanlength > maxlength) )
+  {
+    dev->scanlength = maxlength;
+  }
+
+  if (dev->upper_left_y < inquiry_y_orig)
+  {
+    dev->upper_left_y = inquiry_y_orig;
+  }
+
+
+  /* Now calculate width and length in pixels */
+  dev->width_in_pixels  = umax_calculate_pixels(dev->scanwidth,  dev->x_resolution,
+                                                dev->relevant_optical_res * dev->scale_x, dev->x_coordinate_base);
+
+  dev->length_in_pixels = umax_calculate_pixels(dev->scanlength, dev->y_resolution,
+                                                dev->relevant_optical_res * dev->scale_y, dev->y_coordinate_base);
+
+  if ((dev->scanwidth <= 0) || (dev->scanlength <= 0))
+  {
+    DBG(DBG_error,"ERROR: scanwidth or scanlength not given\n");
+    return(1);
+  }
+
+  if (dev->bits_per_pixel_code == 1)
+  {
+    dev->bytes_per_color = 1;
+  }
+  else
+  {
+    dev->bytes_per_color = 2;
+  }
+
+  switch(dev->colormode)
+  {
+   case LINEART:
+     dev->width_in_pixels -= dev->width_in_pixels % 8;
+     dev->row_len = (dev->width_in_pixels / 8);
+    break;
+
+   case HALFTONE:
+     dev->width_in_pixels -= dev->width_in_pixels % 8;
+     dev->row_len = (dev->width_in_pixels / 8);
+    break;
+
+   case GRAYSCALE:
+     dev->row_len = dev->width_in_pixels * dev->bytes_per_color;
+    break;
+
+   case RGB_LINEART:
+   case RGB_HALFTONE:
+     if (dev->three_pass)
+     {
+       dev->row_len = dev->width_in_pixels / 8 ;
+     }
+     else
+     {
+       dev->row_len = (dev->width_in_pixels / 8 ) * 3;
+     }
+    break;
+
+   case RGB:
+     if (dev->three_pass)				     /* three (24bpp) or six (30bpp) bytes per pixel */
+     {
+       dev->row_len = dev->width_in_pixels * dev->bytes_per_color;
+     }
+     else
+     {
+       dev->row_len = dev->width_in_pixels * 3 * dev->bytes_per_color;
+     }
+    break;
+  }
+
+
+  /* ------------------------------- wdb length ------------------------ */
+
+  if (dev->wdb_len <= 0)
+  {
+    dev->wdb_len = dev->inquiry_wdb_len; 
+    if (dev->wdb_len <= 0)
+    {
+      DBG(DBG_error,"ERROR: wdb-length not given\n");
+      return(1);
+    }
+  }
+
+  if (dev->wdb_len > used_WDB_size)
+  {
+    DBG(DBG_warning,"WARNING:window descriptor block too long, will be shortned!\n");
+    dev->wdb_len = used_WDB_size;
+  }
+
+  /* ----------------------------- cbhs-range ----------------------------- */
+
+  dev->threshold   = umax_cbhs_correct(dev->inquiry_threshold_min,  dev->threshold , dev->inquiry_threshold_max);
+  dev->contrast    = umax_cbhs_correct(dev->inquiry_contrast_min,   dev->contrast  , dev->inquiry_contrast_max);
+  dev->brightness  = umax_cbhs_correct(dev->inquiry_brightness_min, dev->brightness, dev->inquiry_brightness_max);
+
+  dev->highlight_r = umax_cbhs_correct(dev->inquiry_highlight_min, dev->highlight_r, dev->inquiry_highlight_max);
+  dev->highlight_g = umax_cbhs_correct(dev->inquiry_highlight_min, dev->highlight_g, dev->inquiry_highlight_max);
+  dev->highlight_b = umax_cbhs_correct(dev->inquiry_highlight_min, dev->highlight_b, dev->inquiry_highlight_max);
+
+  dev->shadow_r    = umax_cbhs_correct(dev->inquiry_shadow_min, dev->shadow_r, dev->inquiry_shadow_max-1);
+  dev->shadow_g    = umax_cbhs_correct(dev->inquiry_shadow_min, dev->shadow_g, dev->inquiry_shadow_max-1);
+  dev->shadow_b    = umax_cbhs_correct(dev->inquiry_shadow_min, dev->shadow_b, dev->inquiry_shadow_max-1);
+
+  if (dev->shadow_r >= dev->highlight_r)
+  {
+    dev->shadow_r = dev->highlight_r-1;
+  }
+  if (dev->shadow_g >= dev->highlight_g)
+  {
+    dev->shadow_g = dev->highlight_g-1;
+  }
+  if (dev->shadow_b >= dev->highlight_b)
+  {
+    dev->shadow_b = dev->highlight_b-1;
+  }
+
+  /* ----------------------- quality calibration and preview -------------- */
+
+  if (dev->inquiry_preview == 0)
+  {
+    if (dev->preview)
+    {
+      DBG(DBG_warning, "WARNING: fast preview function not supported by scanner\n");
+      dev->preview = 0;
+    }
+  }
+
+  /* always set calibration lines because we also need this value if the scanner
+     requeires calibration by driver */
+  dev->calib_lines = dev->inquiry_max_calib_lines;
+
+  if (dev->force_quality_calibration)
+  {
+    dev->quality = 1; /* always use quality calibration */
+  }
+  else if (dev->inquiry_quality_ctrl == 0)
+  {
+    if (dev->quality)
+    {
+      DBG(DBG_warning, "WARNING: quality calibration not supported by scanner\n");
+      dev->quality = 0;
+    }
+  }
+  else
+  {
+    if (dev->preview != 0)
+    {
+      DBG(DBG_info, "quality calibration disabled in preview mode\n");
+      dev->quality = 0; /* do not use quality calibration in preview mode */
+    }
+  }
+
+  /* --------------------------- lamp intensity control ------------------- */
+
+  if (dev->inquiry_lamp_ctrl == 0)
+  {
+    if (dev->c_density || dev->s_density)
+    {
+      DBG(DBG_warning, "WARNING: scanner doesn't support lamp intensity control\n");
+    }
+    dev->c_density = dev->s_density = 0;
+  }
+
+
+  /* --------------------------- reverse (negative) ----------------------- */
+
+  if (dev->reverse != 0)
+  {
+    if ( (dev->colormode == LINEART)     || (dev->colormode == HALFTONE) ||
+         (dev->colormode == RGB_LINEART) || (dev->colormode == RGB_HALFTONE) )
+    {
+      if (dev->inquiry_reverse == 0)
+      {
+         DBG(DBG_error, "ERROR: reverse for bi-level-image not supported\n");
+         return(1);
+      }
+    }
+    else
+    { dev->reverse = 0; }
+  }
+
+  if (dev->reverse_multi != 0)
+  {
+    if ((dev->colormode == RGB) || (dev->colormode == GRAYSCALE) )
+    {
+      if (dev->inquiry_reverse_multi == 0)
+      {
+         DBG(DBG_error, "ERROR: reverse for multi-level-image not supported\n");
+         return(1);
+      }
+    }
+    else
+    {
+      dev->reverse_multi = 0;
+    }
+  }
+
+  /* ----------------------------- analog gamma ---------------------------- */
+
+  if (dev->inquiry_analog_gamma == 0)
+  {
+    if (dev->analog_gamma_r + dev->analog_gamma_g + dev->analog_gamma_b != 0)
+    {
+      DBG(DBG_warning,"WARNING: analog gamma correction not supported by scanner!\n");
+    }
+    dev->analog_gamma_r = dev->analog_gamma_g = dev->analog_gamma_b = 0;
+  }
+
+  /* ---------------------------- digital gamma ---------------------------- */
+
+  if ( (dev->digital_gamma_r == 0) || (dev->digital_gamma_g == 0) ||
+       (dev->digital_gamma_b == 0) )
+  {
+    if (dev->inquiry_gamma_dwload == 0)
+    {
+      DBG(DBG_warning, "WARNING: gamma download not available\n");
+      dev->digital_gamma_r = dev->digital_gamma_g = dev->digital_gamma_b = 15;
+    }
+  }
+
+  /* ---------------------------- speed and smear  ------------------------- */
+  
+  if (dev->slow == 1)
+  {
+    dev->WD_speed = WD_speed_slow;
+  }
+  else
+  {
+    dev->WD_speed = WD_speed_fast;
+  }
+
+  if (dev->smear == 1)
+  {
+    dev->WD_speed += WD_speed_smear;
+  }
+
+  /* ---------------------- test bits per pixel  --------------------------- */
+  
+  if ( ( (dev->inquiry_GIB | 1) & dev->gamma_input_bits_code) == 0 )
+  {
+    DBG(DBG_warning,"WARNING: selected gamma input bits not supported, gamma ignored\n");
+    dev->gamma_input_bits_code = 1;
+    dev->digital_gamma_r = dev->digital_gamma_g = dev->digital_gamma_b = 15;
+  }
+
+  if ( ( (dev->inquiry_GOB | 1) & dev->bits_per_pixel_code) == 0 )
+  {
+    DBG(DBG_error,"ERROR: selected bits per pixel not supported\n");
+    return(1);
+  }
+  
+  /* ----------------------- scan mode dependencies ------------------------ */
+
+  switch(dev->colormode)
+  {
+    case LINEART:							       /* ------------ LINEART ------------- */
+    case RGB_LINEART:						       /* ---------- RGB_LINEART ----------- */
+      dev->use_exposure_time_min = dev->inquiry_exposure_time_l_min;
+
+      if (dev->module == WD_module_flatbed) 
+      {
+        dev->use_exposure_time_def_r = dev->inquiry_exposure_time_l_fb_def;
+      }
+      else
+      {
+        dev->use_exposure_time_def_r = dev->inquiry_exposure_time_l_uta_def;
+      }
+
+      if (dev->inquiry_lineart == 0)
+      {
+        DBG(DBG_error,"ERROR: lineart mode not supported by scanner\n");
+       return(1);
+      }
+     break;
+
+    case HALFTONE:							 /* ----------- HALFTONE------------ */
+    case RGB_HALFTONE:							 /* --------- RGB_HALFTONE---------- */
+      dev->use_exposure_time_min = dev->inquiry_exposure_time_h_min;
+      if (dev->module == WD_module_flatbed) 
+      {
+        dev->use_exposure_time_def_r = dev->inquiry_exposure_time_h_fb_def;
+      }
+      else
+      {
+        dev->use_exposure_time_def_r = dev->inquiry_exposure_time_h_uta_def;
+      }
+
+      if (dev->inquiry_halftone == 0)
+      {
+        DBG(DBG_error,"ERROR: halftone mode not supported by scanner\n");
+        return(1);
+      }
+     break;
+
+    case GRAYSCALE:						       /* ---------- GRAYSCALE ------------- */
+      dev->use_exposure_time_min = dev->inquiry_exposure_time_g_min;
+
+      if (dev->module == WD_module_flatbed) 
+      {
+        dev->use_exposure_time_def_r = dev->inquiry_exposure_time_g_fb_def;
+      }
+      else
+      {
+        dev->use_exposure_time_def_r = dev->inquiry_exposure_time_g_uta_def;
+      }
+
+      if (dev->inquiry_gray == 0)
+      {
+        DBG(DBG_error, "ERROR: grayscale mode not supported by scanner\n");
+       return(1);
+      }
+     break;
+
+    case RGB:							       /* ----------------- COLOR ---------- */
+      dev->use_exposure_time_min = dev->inquiry_exposure_time_c_min;
+      if (dev->module == WD_module_flatbed) 
+      {
+        dev->use_exposure_time_def_r = dev->inquiry_exposure_time_c_fb_def_r;
+        dev->use_exposure_time_def_g = dev->inquiry_exposure_time_c_fb_def_g;
+        dev->use_exposure_time_def_b = dev->inquiry_exposure_time_c_fb_def_b;
+      }
+      else
+      {
+        dev->use_exposure_time_def_r = dev->inquiry_exposure_time_c_uta_def_r;
+        dev->use_exposure_time_def_g = dev->inquiry_exposure_time_c_uta_def_g;
+        dev->use_exposure_time_def_b = dev->inquiry_exposure_time_c_uta_def_b;
+      }
+
+      if (dev->inquiry_color == 0)
+      {
+        DBG(DBG_error,"ERROR: color mode not supported by scanner\n");
+       return(1);
+      }
+
+      if (dev->inquiry_one_pass_color)
+      {
+        DBG(DBG_info,"using one pass scanning mode\n");
+
+        if (dev->inquiry_color_order & IN_color_ordering_pixel)
+        {
+          DBG(DBG_info,"scanner uses color-pixel-ordering\n");
+        }
+        else if (dev->inquiry_color_order & IN_color_ordering_line_no_ccd)
+        {
+          dev->CCD_distance = 0;
+          dev->do_color_ordering = 1;
+          DBG(DBG_info,"scanner uses color-line-ordering without CCD-distance\n");
+        }
+        else if (dev->inquiry_color_order & IN_color_ordering_line_w_ccd)
+        {
+          dev->CCD_distance = dev->inquiry_CCD_line_distance;
+          dev->do_color_ordering = 1;
+          switch (dev->inquiry_fb_uta_color_arrangement)		     /* define color order for line ordering */
+          {
+            case 1:
+              dev->CCD_color[0] = CCD_color_green;
+
+              dev->CCD_color[1] = CCD_color_blue;
+              dev->CCD_color[2] = CCD_color_green;
+
+              dev->CCD_color[3] = CCD_color_blue;
+              dev->CCD_color[4] = CCD_color_red;
+              dev->CCD_color[5] = CCD_color_green;
+
+              dev->CCD_color[6] = CCD_color_blue;
+              dev->CCD_color[7] = CCD_color_red;
+
+              dev->CCD_color[8] = CCD_color_red;
+             break;
+
+            case 2:
+              dev->CCD_color[0] = CCD_color_blue;
+
+              dev->CCD_color[1] = CCD_color_green;
+              dev->CCD_color[2] = CCD_color_blue;
+
+              dev->CCD_color[3] = CCD_color_green;
+              dev->CCD_color[4] = CCD_color_red;
+              dev->CCD_color[5] = CCD_color_blue;
+
+              dev->CCD_color[6] = CCD_color_green;
+              dev->CCD_color[7] = CCD_color_red;
+
+              dev->CCD_color[8] = CCD_color_red;
+             break;
+
+            case 3:
+              dev->CCD_color[0] = CCD_color_red;
+
+              dev->CCD_color[1] = CCD_color_blue;
+              dev->CCD_color[2] = CCD_color_red;
+ 
+              dev->CCD_color[3] = CCD_color_blue;
+              dev->CCD_color[4] = CCD_color_green;
+              dev->CCD_color[5] = CCD_color_red;
+
+              dev->CCD_color[6] = CCD_color_blue;
+              dev->CCD_color[7] = CCD_color_green;
+
+              dev->CCD_color[8] = CCD_color_green;
+             break;
+
+            case 4:										 /* may be wrong !!! */
+              dev->CCD_color[0] = CCD_color_red;
+
+              dev->CCD_color[1] = CCD_color_green;
+              dev->CCD_color[2] = CCD_color_red;
+
+              dev->CCD_color[3] = CCD_color_green;
+              dev->CCD_color[4] = CCD_color_red;
+              dev->CCD_color[5] = CCD_color_blue;
+
+              dev->CCD_color[6] = CCD_color_green;
+              dev->CCD_color[7] = CCD_color_blue;
+
+              dev->CCD_color[8] = CCD_color_blue;
+             break;
+
+            case 32:						    /* not defined from UMAX, for Astra 600S */
+              dev->CCD_color[0] = CCD_color_green;
+
+              dev->CCD_color[1] = CCD_color_green;
+              dev->CCD_color[2] = CCD_color_blue;
+
+              dev->CCD_color[3] = CCD_color_green;
+              dev->CCD_color[4] = CCD_color_red;
+              dev->CCD_color[5] = CCD_color_blue;
+
+              dev->CCD_color[6] = CCD_color_red;
+              dev->CCD_color[7] = CCD_color_blue;
+
+              dev->CCD_color[8] = CCD_color_red;
+             break;
+
+            case 33:						    /* not defined from UMAX, for Astra 610S */
+              dev->CCD_color[0] = CCD_color_red;
+
+              dev->CCD_color[1] = CCD_color_red;
+              dev->CCD_color[2] = CCD_color_blue;
+
+              dev->CCD_color[3] = CCD_color_red;
+              dev->CCD_color[4] = CCD_color_green;
+              dev->CCD_color[5] = CCD_color_blue;
+
+              dev->CCD_color[6] = CCD_color_green;
+              dev->CCD_color[7] = CCD_color_blue;
+ 
+              dev->CCD_color[8] = CCD_color_green;
+             break;
+
+            default:
+              dev->CCD_color[0] = CCD_color_green;
+ 
+              dev->CCD_color[1] = CCD_color_blue;
+              dev->CCD_color[2] = CCD_color_green;
+
+              dev->CCD_color[3] = CCD_color_blue;
+              dev->CCD_color[4] = CCD_color_red;
+              dev->CCD_color[5] = CCD_color_green;
+
+              dev->CCD_color[6] = CCD_color_blue;
+              dev->CCD_color[7] = CCD_color_red;
+
+              dev->CCD_color[8] = CCD_color_red;
+          }
+          DBG(DBG_info,"scanner uses color-line-ordering with CCD-distance of %d lines\n", dev->CCD_distance);
+        }
+        else
+        { 
+          DBG(DBG_error,"ERROR: color-ordering-type not supported \n");
+         return(1);
+        }
+      }
+      else 
+      {
+        DBG(DBG_info,"using three pass scanning mode\n");
+        dev->three_pass=1;
+      }
+     break;
+  } /* switch */
+
+  /* ----------------------------- color ordering  ------------------------ */
+
+  if (dev->do_color_ordering != 0)
+  {
+    if ( (dev->colormode != RGB) || (dev->three_pass != 0) )
+    {
+      dev->do_color_ordering = 0; /* color ordering not necessery */
+    }
+  }
+
+ return(0);
+}
+
+
+/* ------------------------------------------------------------ UMAX GET INQUIRY VALUES -------------------- */
+
+
+static void umax_get_inquiry_values(Umax_Device *dev)
+{
+ unsigned char * inquiry_block;
+
+  DBG(DBG_proc,"get_inquiry_values\n");
+
+  inquiry_block   = dev->buffer[0];
+  dev->inquiry_len = get_inquiry_additional_length(dev->buffer[0])+5;
+  dev->cbhs_range  = dev->inquiry_cbhs = get_inquiry_CBHS(inquiry_block);
+
+  if (dev->cbhs_range > IN_CBHS_255)
+  {
+    dev->cbhs_range = IN_CBHS_255;
+  }
+
+  if (dev->cbhs_range == IN_CBHS_50)
+  {
+    dev->inquiry_contrast_min   = 103;	      /* minimum value for c */
+    dev->inquiry_contrast_max   = 153;	      /* maximum value for c */
+    dev->inquiry_brightness_min = 78;	      /* minimum value for b */
+    dev->inquiry_brightness_max = 178;	      /* maximum value for b */
+    dev->inquiry_threshold_min  = 78;	      /* minimum value for t */
+    dev->inquiry_threshold_max  = 178;	      /* maximum value for t */
+    dev->inquiry_highlight_min  = 1;	      /* minimum value for h */
+    dev->inquiry_highlight_max  = 50;	      /* maximum value for h */
+    dev->inquiry_shadow_min     = 0;	      /* minimum value for s */
+    dev->inquiry_shadow_max     = 49;	      /* maximum value for s */ 
+  }
+
+  get_inquiry_vendor( (char *)inquiry_block, dev->vendor);  dev->vendor[8]  ='\0';
+  get_inquiry_product((char *)inquiry_block, dev->product); dev->product[16]='\0';
+  get_inquiry_version((char *)inquiry_block, dev->version); dev->version[4] ='\0';
+
+  dev->inquiry_batch_scan       = get_inquiry_fw_batch_scan(inquiry_block);
+  dev->inquiry_quality_ctrl     = get_inquiry_fw_quality(inquiry_block);
+  dev->inquiry_preview          = get_inquiry_fw_fast_preview(inquiry_block);
+  dev->inquiry_lamp_ctrl        = get_inquiry_fw_lamp_int_cont(inquiry_block);
+  dev->inquiry_calibration      = get_inquiry_fw_calibration(inquiry_block);
+  dev->inquiry_transavail       = get_inquiry_transavail(inquiry_block);
+  dev->inquiry_adfmode          = get_inquiry_scanmode(inquiry_block);
+
+  if (dev->inquiry_len<=0x8f)
+  {
+    DBG(DBG_warning, "WARNING: inquiry return block is unexpected short.\n");
+  }
+
+  dev->inquiry_uta              = get_inquiry_sc_uta(inquiry_block);
+  dev->inquiry_adf              = get_inquiry_sc_adf(inquiry_block);
+
+  dev->inquiry_one_pass_color   = get_inquiry_sc_one_pass_color(inquiry_block);
+  dev->inquiry_three_pass_color = get_inquiry_sc_three_pass_color(inquiry_block);
+  dev->inquiry_color            = get_inquiry_sc_color(inquiry_block);
+  dev->inquiry_gray             = get_inquiry_sc_gray(inquiry_block);
+  dev->inquiry_halftone         = get_inquiry_sc_halftone(inquiry_block);
+  dev->inquiry_lineart          = get_inquiry_sc_lineart(inquiry_block);
+
+  dev->inquiry_exposure_adj              = get_inquiry_fw_adjust_exposure_tf(inquiry_block);
+  dev->inquiry_exposure_time_step_unit   = get_inquiry_exposure_time_step_unit(inquiry_block);
+  dev->inquiry_exposure_time_max         = get_inquiry_exposure_time_max(inquiry_block);
+
+             /* --- lineart --- */
+  dev->inquiry_exposure_time_l_min       = get_inquiry_exposure_time_lhg_min(inquiry_block);
+  dev->inquiry_exposure_time_l_fb_def    = get_inquiry_exposure_time_lh_def_fb(inquiry_block);
+  dev->inquiry_exposure_time_l_uta_def   = get_inquiry_exposure_time_lh_def_uta(inquiry_block);
+
+             /* --- halftone --- */
+  dev->inquiry_exposure_time_h_min       = get_inquiry_exposure_time_lhg_min(inquiry_block);
+  dev->inquiry_exposure_time_h_fb_def    = get_inquiry_exposure_time_lh_def_fb(inquiry_block);
+  dev->inquiry_exposure_time_h_uta_def   = get_inquiry_exposure_time_lh_def_uta(inquiry_block);
+
+             /* --- grayscale --- */
+  dev->inquiry_exposure_time_g_min       = get_inquiry_exposure_time_lhg_min(inquiry_block);
+  dev->inquiry_exposure_time_g_fb_def    = get_inquiry_exposure_time_gray_def_fb(inquiry_block);
+  dev->inquiry_exposure_time_g_uta_def   = get_inquiry_exposure_time_gray_def_uta(inquiry_block);
+
+             /* --- color --- */
+  dev->inquiry_exposure_time_c_min       = get_inquiry_exposure_time_color_min(inquiry_block);
+  dev->inquiry_exposure_time_c_fb_def_r  = get_inquiry_exposure_time_def_r_fb(inquiry_block);
+  dev->inquiry_exposure_time_c_fb_def_g  = get_inquiry_exposure_time_def_g_fb(inquiry_block);
+  dev->inquiry_exposure_time_c_fb_def_b  = get_inquiry_exposure_time_def_g_fb(inquiry_block);
+  dev->inquiry_exposure_time_c_uta_def_r = get_inquiry_exposure_time_def_r_uta(inquiry_block);
+  dev->inquiry_exposure_time_c_uta_def_g = get_inquiry_exposure_time_def_g_uta(inquiry_block);
+  dev->inquiry_exposure_time_c_uta_def_b = get_inquiry_exposure_time_def_b_uta(inquiry_block);
+
+
+  dev->inquiry_dor           = get_inquiry_sc_double_res(inquiry_block);
+  dev->inquiry_reverse       = get_inquiry_sc_bi_image_reverse(inquiry_block);
+  dev->inquiry_reverse_multi = get_inquiry_sc_multi_image_reverse(inquiry_block);
+  dev->inquiry_shadow        = 1 - get_inquiry_sc_no_shadow(inquiry_block);
+  dev->inquiry_highlight     = 1 - get_inquiry_sc_no_highlight(inquiry_block);
+  dev->inquiry_analog_gamma  = get_inquiry_analog_gamma(inquiry_block);
+  dev->inquiry_lineart_order = get_inquiry_lineart_order(inquiry_block);
+
+  dev->inquiry_lens_cal_in_doc_pos  = get_inquiry_manual_focus(inquiry_block);
+  dev->inquiry_manual_focus         = get_inquiry_manual_focus(inquiry_block);
+  dev->inquiry_sel_uta_lens_cal_pos = get_inquiry_manual_focus(inquiry_block);
+
+  dev->inquiry_gamma_dwload  = get_inquiry_gamma_download_available(inquiry_block);
+
+  if (get_inquiry_gamma_type_2(inquiry_block) != 0)
+  {
+    dev->inquiry_gamma_DCF = 2;
+  }
+
+  dev->inquiry_GIB           = get_inquiry_gib(inquiry_block);
+  dev->inquiry_GOB           = get_inquiry_gob(inquiry_block);
+  dev->inquiry_color_order   = get_inquiry_color_order(inquiry_block);
+  dev->inquiry_vidmem        = get_inquiry_max_vidmem(inquiry_block);
+
+  /* optical resolution = [0x73] * 100 + [0x94] , 0x94 is not always defined */
+  dev->inquiry_optical_res = 100 * get_inquiry_max_opt_res(inquiry_block);
+  if (dev->inquiry_len > 0x94)
+  {
+    dev->inquiry_optical_res += get_inquiry_optical_resolution_residue(inquiry_block);
+  }
+
+  /* x resolution = [0x74] * 100 + [0x95] , 0x95 is not always defined */
+  dev->inquiry_x_res = 100 * get_inquiry_max_x_res(inquiry_block);
+  if (dev->inquiry_len > 0x95)
+  {
+    dev->inquiry_x_res+= get_inquiry_x_resolution_residue(inquiry_block);
+  };
+
+  /* y resolution = [0x75] * 100 + [0x96] , 0x96 is not always defined */
+  dev->inquiry_y_res = 100 * get_inquiry_max_y_res(inquiry_block);
+  if (dev->inquiry_len > 0x96)
+  {
+    dev->inquiry_y_res+= get_inquiry_y_resolution_residue(inquiry_block);
+  }
+
+
+  /* optical resolution = [0x83] * 100 + [0xa0] , 0xa0 is not always defined */
+  dev->inquiry_dor_optical_res = 100 * get_inquiry_dor_max_opt_res(inquiry_block);
+  if (dev->inquiry_len > 0xa0)
+  {
+    dev->inquiry_dor_optical_res += get_inquiry_dor_optical_resolution_residue(inquiry_block);
+  }
+
+  /* x resolution = [0x84] * 100 + [0xa1] , 0xa1 is not always defined */
+  dev->inquiry_dor_x_res = 100 * get_inquiry_dor_max_x_res(inquiry_block);
+  if (dev->inquiry_len > 0xa1)
+  {
+    dev->inquiry_dor_x_res+= get_inquiry_dor_x_resolution_residue(inquiry_block);
+  }
+
+  /* y resolution = [0x85] * 100 + [0xa2] , 0xa2 is not always defined */
+  dev->inquiry_dor_y_res = 100 * get_inquiry_dor_max_y_res(inquiry_block);
+  if (dev->inquiry_len > 0xa2)
+  {
+    dev->inquiry_dor_y_res+= get_inquiry_dor_y_resolution_residue(inquiry_block);
+  }
+
+  if (dev->inquiry_dor) /* DOR mode available ? */
+  {
+    /* if DOR resolutions are not defined, use double of standard resolution */
+
+    if (dev->inquiry_dor_optical_res == 0)
+    {
+      dev->inquiry_dor_optical_res = dev->inquiry_optical_res * 2;
+    }
+
+    if (dev->inquiry_dor_x_res == 0)
+    {
+      dev->inquiry_dor_x_res = dev->inquiry_x_res * 2;
+    }
+
+    if (dev->inquiry_dor_y_res == 0)
+    {
+      dev->inquiry_dor_y_res = dev->inquiry_y_res * 2;
+    }
+  }
+
+  dev->inquiry_fb_width   = (double)get_inquiry_fb_max_scan_width(inquiry_block)  * 0.01;
+  dev->inquiry_fb_length  = (double)get_inquiry_fb_max_scan_length(inquiry_block) * 0.01;
+
+  dev->inquiry_uta_width  = (double)get_inquiry_uta_max_scan_width(inquiry_block)  * 0.01;
+  dev->inquiry_uta_length = (double)get_inquiry_uta_max_scan_length(inquiry_block) * 0.01;
+  dev->inquiry_uta_x_off  = (double)get_inquiry_uta_x_original_point(inquiry_block) * 0.01;
+  dev->inquiry_uta_y_off  = (double)get_inquiry_uta_y_original_point(inquiry_block) * 0.01;
+
+  dev->inquiry_dor_width  = (double)get_inquiry_dor_max_scan_width(inquiry_block)  * 0.01;
+  dev->inquiry_dor_length = (double)get_inquiry_dor_max_scan_length(inquiry_block) * 0.01;
+  dev->inquiry_dor_x_off  = (double)get_inquiry_dor_x_original_point(inquiry_block) * 0.01;
+  dev->inquiry_dor_y_off  = (double)get_inquiry_dor_y_original_point(inquiry_block) * 0.01;
+
+  dev->inquiry_max_warmup_time          = get_inquiry_lamp_warmup_maximum_time(inquiry_block) * 2;
+
+  dev->inquiry_wdb_len                  = get_inquiry_wdb_length(inquiry_block);
+
+  /* it is not guaranteed that the following values are in the inquiry return block */
+
+  /* 0x9a */
+  if (dev->inquiry_len<=0x9a)
+  {
+    return;
+  }
+  dev->inquiry_max_calib_lines          = get_inquiry_max_calibration_data_lines(inquiry_block);
+
+  /* 0x9b */
+  if (dev->inquiry_len<=0x9b)
+  {
+    return;
+  }
+  dev->inquiry_fb_uta_color_arrangement = get_inquiry_fb_uta_line_arrangement_mode(inquiry_block);
+
+  /* 0x9c */
+  if (dev->inquiry_len<=0x9c)
+  {
+    return;
+  }
+  dev->inquiry_adf_color_arrangement    = get_inquiry_adf_line_arrangement_mode(inquiry_block);
+
+  /* 0x9d */
+  if (dev->inquiry_len<=0x9d)
+  {
+    return;
+  } 
+  dev->inquiry_CCD_line_distance        = get_inquiry_CCD_line_distance(inquiry_block);
+
+  return;
+}
+
+
+/* ------------------------------------------------------------ UMAX CALCULATE ANALOG GAMMA ---------------- */
+
+
+static int umax_calculate_analog_gamma(double value)
+{
+ int gamma;
+
+  if (value < 1.0)
+   { value=1.0; }
+
+  if (value > 2.0)
+   { value=2.0; }
+
+  gamma=0;						       /* select gamma_value from analog_gamma_table */
+  while (value>analog_gamma_table[gamma])
+  {
+    gamma++;
+  } 
+
+  if (gamma)
+  {
+    if ((analog_gamma_table[gamma-1] + analog_gamma_table[gamma]) /2 > value)
+    {
+      gamma--;
+    }
+  }
+  
+ return(gamma);
+}
+
+/* ------------------------------------------------------------ UMAX OUTPUT IMAGE DATA  -------------------- */
+
+static void umax_output_image_data(Umax_Device *dev, FILE *fp, unsigned int data_to_read, int bufnr)
+{
+    if (dev->do_color_ordering == 0)							   /* pixel ordering */
+    {
+      if ((dev->inquiry_lineart_order) && (dev->colormode == LINEART)) /* lineart with LSB first */
+      {
+       unsigned int i, j;
+       int new, old;
+
+        for (i=0; i<data_to_read; i++)
+        {
+          old = dev->buffer[bufnr][i];    
+          new = 0;
+          for (j=0; j<8; j++)  /* reverse bit order of 1 byte */
+          {
+            new = (new << 1) + (old & 1);
+            old = old >> 1;
+          }
+          dev->buffer[bufnr][i]=new;
+        }
+      }
+      fwrite(dev->buffer[bufnr], 1, data_to_read, fp);
+    }
+    else										    /* line ordering */
+    {
+     unsigned char *linesource = dev->buffer[bufnr];
+     unsigned char *pixelsource;
+     int bytes = 1;
+     int lines;
+     int i;
+
+      if (dev->bits_per_pixel_code != 1)							  /* >24 bpp */
+      {
+        bytes = 2;
+      }
+
+      lines = data_to_read / (dev->width_in_pixels * bytes);
+
+      for(i=0; i<lines; i++)
+      {
+        umax_order_line(dev, linesource);
+        linesource += dev->width_in_pixels * bytes;
+
+        pixelsource = umax_get_pixel_line(dev);
+        if (pixelsource != NULL)
+        {
+          fwrite(pixelsource, bytes, dev->width_in_pixels * 3, fp);
+        }
+      }
+    }
+}
+
+/* ------------------------------------------------------------ UMAX READER PROCESS ------------------------ */
+
+
+static int umax_reader_process(Umax_Device *dev, FILE *fp, unsigned int image_size)
+{
+ int status;
+ int bytes        = 1;
+ int queue_filled = 0;
+ unsigned int bufnr_queue  = 0;
+ unsigned int bufnr_read   = 0;
+ unsigned int data_left_to_read  = image_size;
+ unsigned int data_left_to_queue = image_size;
+ unsigned int data_to_read;
+ unsigned int data_to_queue;
+
+  dev->row_bufsize = dev->bufsize;
+  umax_trim_rowbufsize(dev);								     /* trim bufsize */
+
+  if (dev->bits_per_pixel_code != 1) /* >24 bpp */
+  {
+    bytes = 2;
+  }
+
+  DBG(DBG_read,"reading %u bytes in blocks of %u bytes\n", image_size, dev->row_bufsize);
+
+  if (dev->pixelbuffer != NULL)								   /* buffer exists? */
+  {
+    free(dev->pixelbuffer);
+    dev->pixelbuffer = NULL;
+  }
+
+  if (dev->do_color_ordering != 0)
+  {
+    DBG(DBG_info,"ordering from line-order to pixel-order\n");
+
+    dev->pixelline_max = 3 *  dev->CCD_distance * dev->scale_y + 2;
+
+    dev->pixelbuffer = malloc(dev->width_in_pixels * dev->pixelline_max * bytes * 3);
+
+    if (dev->pixelbuffer == NULL) /* NO MEMORY */
+    {
+      return -1;
+    }
+  }
+
+  WAIT_SCANNER;
+
+  do
+  {
+    if (data_left_to_queue)
+    {
+      data_to_queue = (data_left_to_queue < dev->row_bufsize) ? data_left_to_queue : dev->row_bufsize;
+
+      /* umax_get_data_buffer_status(dev); */
+
+      status = umax_queue_read_image_data_req(dev, data_to_queue, bufnr_queue);
+
+      if (status == 0) /* no error but nothing queued */
+      {
+        continue;
+      }
+
+      if (status == -1) /* error */
+      {
+        DBG(DBG_error,"ERROR: umax_reader_process: unable to queue read image data request!\n");
+        free(dev->pixelbuffer);
+        dev->pixelbuffer = NULL;
+        return(-1);
+      }
+
+      data_left_to_queue -= data_to_queue;
+      DBG(DBG_read, "umax_reader_process: read image data queued for buffer[%d] \n", bufnr_queue);
+
+      bufnr_queue++;
+      if (bufnr_queue >= dev->scsi_maxqueue)
+      {
+        bufnr_queue = 0;
+        queue_filled = 1; /* ok, we can start to read the queued buffers - if not already started */
+      }
+
+      if (!data_left_to_queue)
+      {
+        queue_filled = 1; /* ok, we can start to read the queued buffer(s) - all read requests are send */
+      }
+    }
+
+    if (queue_filled) /* queue filled, ok we can read data */
+    {
+      status = umax_wait_queued_image_data(dev, bufnr_read);
+
+      if (status == -1)
+      {
+        DBG(DBG_error,"ERROR: umax_reader_process: unable to get image data from scanner!\n");
+        free(dev->pixelbuffer);
+        dev->pixelbuffer = NULL;
+        return(-1);
+      }
+
+      data_to_read = dev->length_read[bufnr_read]; /* number of bytes in buffer */
+      umax_output_image_data(dev, fp, data_to_read, bufnr_read);
+
+      data_left_to_read -= data_to_read;
+      DBG(DBG_read, "umax_reader_process: buffer of %d bytes read; %d bytes to go\n", data_to_read, data_left_to_read);
+
+      /* if we did not get all requested data increase data_left_to_queue so that we get all needed data */
+      if (dev->length_read[bufnr_read] != dev->length_queued[bufnr_read])
+      {
+        data_left_to_queue += dev->length_queued[bufnr_read] - dev->length_read[bufnr_read];
+      }
+
+      bufnr_read++;
+      if (bufnr_read >= dev->scsi_maxqueue)
+      {
+        bufnr_read = 0;
+      }
+    }
+  } while (data_left_to_read);
+
+  free(dev->pixelbuffer);
+  dev->pixelbuffer = NULL;
+
+ return 0;
+}
+
+
+/* ------------------------------------------------------------ UMAX INITIALIZE VALUES --------------------- */
+
+
+static void umax_initialize_values(Umax_Device *dev)	      /* called each time before setting scan-values */
+{										 /* Initialize dev structure */
+  DBG(DBG_proc,"initialize_values\n");
+
+  dev->three_pass            = 0;						  /* 1 if threepas_mode only */
+  dev->row_len               = -1;
+  dev->max_value             = 255;							    /* maximum value */
+
+  dev->wdb_len               = 0;
+  dev->width_in_pixels       = 0;						     /* scan width in pixels */
+  dev->length_in_pixels      = 0;						    /* scan length in pixels */
+  dev->scanwidth             = 0;			           /* width in inch at x_coordinate_base dpi */
+  dev->scanlength            = 0;				  /* length in inch at y_coordinate_base dpi */
+  dev->x_resolution          = 0;
+  dev->y_resolution          = 0;
+  dev->upper_left_x          = 0;							   /* at 1200pt/inch */
+  dev->upper_left_y          = 0;							   /* at 1200pt/inch */
+  dev->bytes_per_color       = 0;						     /* bytes for each color */
+
+  dev->bits_per_pixel        = 8;						 /* number of bits per pixel */
+  dev->bits_per_pixel_code   = 1;			    /* 1 =  8/24 bpp,  2 =  9/27 bpp,  4 = 10/30 bpp */
+  dev->gamma_input_bits_code = 1;			    /* 8 = 12/36 bpp, 16 = 14/42 bpp, 32 = 16/48 bpp */
+  dev->set_auto              = 0;								   /* 0 or 1 */
+  dev->preview               = 0;							    /* 1 for preview */
+  dev->quality               = 0;						      /* quality calibration */
+  dev->warmup                = 0;							       /* warmup-bit */
+  dev->fix_focus_position    = 0;						       /* fix focus position */
+  dev->lens_cal_in_doc_pos   = 0;				    /* lens calibration in document position */
+  dev->disable_pre_focus     = 0;							/* disable pre focus */
+  dev->holder_focus_pos_0mm  = 0;				    /* 0.6mm <-> 0.0mm holder focus position */
+  dev->manual_focus          = 0;					       /* automatic <-> manual focus */
+  dev->colormode             = 0;				      /* LINEART, HALFTONE, GRAYSCALE or RGB */
+  dev->adf                   = 0;						   /* 1 if adf shall be used */
+  dev->uta                   = 0;						   /* 1 if uta shall be used */
+  dev->module                = WD_module_flatbed;
+  dev->cbhs_range            = WD_CBHS_255;
+  dev->dor                   = 0;
+  dev->halftone              = WD_halftone_8x8_1;
+  dev->reverse               = 0;
+  dev->reverse_multi         = 0;
+  dev->calibration           = 0;
+
+  dev->exposure_time_calibration_r = 0;						 /* use this for calibration */
+  dev->exposure_time_calibration_g = 0;						 /* use this for calibration */
+  dev->exposure_time_calibration_b = 0;						 /* use this for calibration */
+  dev->exposure_time_scan_r        = 0;							/* use this for scan */
+  dev->exposure_time_scan_g        = 0;							/* use this for scan */
+  dev->exposure_time_scan_b        = 0;							/* use this for scan */
+
+  dev->c_density           = WD_lamp_c_density_auto;				 /* calibration lamp density */
+  dev->s_density           = WD_lamp_s_density_auto;				   /* next scan lamp density */
+
+  dev->threshold           = 128;					       /* threshold for lineart mode */
+  dev->brightness          = 128;					     /* brightness for halftone mode */
+  dev->contrast            = 128;					       /* contrast for halftone mode */
+  dev->highlight_r         = 255;						       /* highlight gray/red */
+  dev->highlight_g         = 255;							  /* highlight green */
+  dev->highlight_b         = 255;						  	   /* highlight blue */
+  dev->shadow_r            = 0;							     	  /* shadow gray/red */
+  dev->shadow_g            = 0;								     /* shadow green */
+  dev->shadow_b            = 0;								      /* shadow blue */
+
+  dev->digital_gamma_r     = WD_gamma_normal;
+  dev->digital_gamma_g     = WD_gamma_normal;
+  dev->digital_gamma_b     = WD_gamma_normal;
+
+  dev->analog_gamma_r      = 0;					     /* analog gamma for red and gray to 1.0 */
+  dev->analog_gamma_g      = 0;						    /* analog gamma for green to 1.0 */
+  dev->analog_gamma_b      = 0;						     /* analog gamma for blue to 1.0 */
+
+
+  dev->pixelline_ready[0]  = 0;					      /* reset all values for color ordering */
+  dev->pixelline_ready[1]  = 0;
+  dev->pixelline_ready[2]  = 0;
+  dev->pixelline_next[0]   = 0;
+  dev->pixelline_next[1]   = 0;
+  dev->pixelline_next[2]   = 0;
+  dev->pixelline_del[0]    = 1;
+  dev->pixelline_del[1]    = 1;
+  dev->pixelline_del[2]    = 1;
+  dev->pixelline_optic[0]  = 1;
+  dev->pixelline_optic[1]  = 1;
+  dev->pixelline_optic[2]  = 1;
+  dev->pixelline_max       = 0;        
+  dev->pixelline_opt_res   = 0;        
+  dev->pixelline_read      = 0;        
+  dev->pixelline_written   = 0;        
+  dev->CCD_distance        = 0;        
+
+  dev->calib_lines         = 0;							/* request calibration lines */
+  dev->do_calibration      = 0;							 /* no calibration by driver */
+  dev->do_color_ordering   = 0;						  /* no line- to pixel-mode ordering */
+
+  dev->button0_pressed     = 0;						      /* reset button 0 pressed flag */
+  dev->button1_pressed     = 0;						      /* reset button 1 pressed flag */
+  dev->button2_pressed     = 0;						      /* reset button 2 pressed flag */
+}
+
+
+/* ------------------------------------------------------------ UMAX INIT ---------------------------------- */
+
+
+static void umax_init(Umax_Device *dev)		     /* umax_init is called once while driver-initialization */
+{
+  DBG(DBG_proc,"init\n");
+
+  dev->devicename  = NULL;
+  dev->pixelbuffer = NULL;
+
+  /* config file or predefined settings */
+  if (dev->connection_type == SANE_UMAX_SCSI)
+  {
+    dev->request_scsi_maxqueue  = umax_scsi_maxqueue;
+  }
+  else /* SANE_UMAX_USB, USB does not support command queueing */
+  {
+    DBG(DBG_info2, "setting request_scsi_maxqueue = 1 for USB connection\n");
+    dev->request_scsi_maxqueue  = 1;	  
+  }
+
+  dev->request_preview_lines          = umax_preview_lines;
+  dev->request_scan_lines             = umax_scan_lines;
+  dev->handle_bad_sense_error         = umax_handle_bad_sense_error;
+  dev->execute_request_sense          = umax_execute_request_sense;
+  dev->scsi_buffer_size_min           = umax_scsi_buffer_size_min;
+  dev->scsi_buffer_size_max           = umax_scsi_buffer_size_max;
+  dev->force_preview_bit_rgb          = umax_force_preview_bit_rgb;
+  dev->slow                           = umax_slow;
+  dev->smear                          = umax_smear;
+  dev->calibration_area               = umax_calibration_area;
+  dev->calibration_width_offset       = umax_calibration_width_offset;
+  dev->calibration_width_offset_batch = umax_calibration_width_offset_batch;
+  dev->calibration_bytespp            = umax_calibration_bytespp;
+  dev->exposure_time_rgb_bind         = umax_exposure_time_rgb_bind;
+  dev->invert_shading_data            = umax_invert_shading_data;
+  dev->lamp_control_available         = umax_lamp_control_available;
+  dev->gamma_lsb_padded               = umax_gamma_lsb_padded;
+
+  DBG(DBG_info, "request_scsi_maxqueue          = %d\n", dev->request_scsi_maxqueue);
+  DBG(DBG_info, "request_preview_lines          = %d\n", dev->request_preview_lines);
+  DBG(DBG_info, "request_scan_lines             = %d\n", dev->request_scan_lines);
+  DBG(DBG_info, "handle_bad_sense_error         = %d\n", dev->handle_bad_sense_error);
+  DBG(DBG_info, "execute_request_sense          = %d\n", dev->execute_request_sense);
+  DBG(DBG_info, "scsi_buffer_size_min           = %d\n", dev->scsi_buffer_size_min);
+  DBG(DBG_info, "scsi_buffer_size_max           = %d\n", dev->scsi_buffer_size_max);
+  DBG(DBG_info, "force_preview_bit_rgb          = %d\n", dev->force_preview_bit_rgb);
+  DBG(DBG_info, "slow                           = %d\n", dev->slow);
+  DBG(DBG_info, "smear                          = %d\n", dev->smear);
+  DBG(DBG_info, "calibration_area               = %d\n", dev->calibration_area);
+  DBG(DBG_info, "calibration_width_offset       = %d\n", dev->calibration_width_offset);
+  DBG(DBG_info, "calibration_width_offset_batch = %d\n", dev->calibration_width_offset_batch);
+  DBG(DBG_info, "calibration_bytespp            = %d\n", dev->calibration_bytespp);
+  DBG(DBG_info, "exposure_time_rgb_bind         = %d\n", dev->exposure_time_rgb_bind);
+  DBG(DBG_info, "invert_shading_data            = %d\n", dev->invert_shading_data);
+  DBG(DBG_info, "lamp_control_available         = %d\n", dev->lamp_control_available);
+
+
+  dev->inquiry_len                       = 0;
+  dev->inquiry_wdb_len                   = -1;
+  dev->inquiry_optical_res               = -1;
+  dev->inquiry_x_res                     = -1;
+  dev->inquiry_y_res                     = -1;
+  dev->inquiry_fb_width                  = -1;
+  dev->inquiry_fb_length                 = -1;
+  dev->inquiry_uta_width                 = -1;
+  dev->inquiry_uta_length                = -1;
+  dev->inquiry_dor_width                 = -1;
+  dev->inquiry_dor_length                = -1;
+  dev->inquiry_exposure_adj              = 0;
+  dev->inquiry_exposure_time_step_unit   = -1;				  /* exposure time unit in micro sec */
+  dev->inquiry_exposure_time_max         = -1;					    /* exposure time maximum */
+  dev->inquiry_exposure_time_l_min       = -1;			       /*  exposure time minimum for lineart */
+  dev->inquiry_exposure_time_l_fb_def    = -1;			/* exposure time default for lineart flatbed */
+  dev->inquiry_exposure_time_l_uta_def   = -1;			    /* exposure time default for lineart uta */
+  dev->inquiry_exposure_time_h_min       = -1;			      /*  exposure time minimum for halftone */
+  dev->inquiry_exposure_time_h_fb_def    = -1;		       /* exposure time default for halftone flatbed */
+  dev->inquiry_exposure_time_h_uta_def   = -1;			   /* exposure time default for halftone uta */
+  dev->inquiry_exposure_time_g_min       = -1;			     /*  exposure time minimum for grayscale */
+  dev->inquiry_exposure_time_g_fb_def    = -1;		      /* exposure time default for grayscale flatbed */
+  dev->inquiry_exposure_time_g_uta_def   = -1;			  /* exposure time default for grayscale uta */
+  dev->inquiry_exposure_time_c_min       = -1;				  /* exposure time minimum for color */
+  dev->inquiry_exposure_time_c_fb_def_r  = -1;		      /* exposure time default for color flatbed red */
+  dev->inquiry_exposure_time_c_fb_def_g  = -1;		    /* exposure time default for color flatbed green */
+  dev->inquiry_exposure_time_c_fb_def_b  = -1;		     /* exposure time default for color flatbed blue */
+  dev->inquiry_exposure_time_c_uta_def_r = -1;			  /* exposure time default for color uta red */
+  dev->inquiry_exposure_time_c_uta_def_g = -1;			/* exposure time default for color uta green */
+  dev->inquiry_exposure_time_c_uta_def_b = -1;			 /* exposure time default for color uta blue */
+  dev->inquiry_max_warmup_time           = 0;					      /* maximum warmup time */
+  dev->inquiry_cbhs                      = WD_CBHS_255;
+  dev->inquiry_contrast_min              = 1;					      /* minimum value for c */
+  dev->inquiry_contrast_max              = 255;					      /* maximum value for c */
+  dev->inquiry_brightness_min            = 1;					      /* minimum value for b */
+  dev->inquiry_brightness_max            = 255;					      /* maximum value for b */
+  dev->inquiry_threshold_min             = 1;					      /* minimum value for t */
+  dev->inquiry_threshold_max             = 255;					      /* maximum value for t */
+  dev->inquiry_highlight_min             = 1;					      /* minimum value for h */
+  dev->inquiry_highlight_max             = 255;					      /* maximum value for h */
+  dev->inquiry_shadow_min                = 0;					      /* minimum value for s */
+  dev->inquiry_shadow_max                = 254;					      /* maximum value for s */ 
+  dev->inquiry_quality_ctrl              = 0;
+  dev->inquiry_preview                   = 0;
+  dev->inquiry_lamp_ctrl                 = 0;
+  dev->inquiry_transavail                = 0;
+  dev->inquiry_uta                       = 0;
+  dev->inquiry_adfmode                   = 0;
+  dev->inquiry_adf                       = 0;
+  dev->inquiry_dor                       = 0;
+  dev->inquiry_reverse                   = 0;
+  dev->inquiry_reverse_multi             = 0;
+  dev->inquiry_analog_gamma              = 0;
+  dev->inquiry_gamma_dwload              = 0;
+  dev->inquiry_one_pass_color            = 0;
+  dev->inquiry_three_pass_color          = 0;
+  dev->inquiry_color                     = 0;
+  dev->inquiry_gray                      = 0;
+  dev->inquiry_halftone                  = 0;
+  dev->inquiry_lineart                   = 0;
+  dev->inquiry_calibration               = 1;
+  dev->inquiry_shadow                    = 0;
+  dev->inquiry_highlight                 = 0;
+  dev->inquiry_gamma_DCF                 = -1;
+  dev->inquiry_max_calib_lines           = 66;	 /* most scanners use 66 lines, so lets define it as default */
+
+  dev->common_xy_resolutions             = 0;
+
+  dev->x_coordinate_base = 1200;						/* these are the 1200pt/inch */
+  dev->y_coordinate_base = 1200;						/* these are the 1200pt/inch */
+
+  dev->button0_pressed   = 0;						      /* reset button 0 pressed flag */
+  dev->button1_pressed   = 0;						      /* reset button 1 pressed flag */
+  dev->button2_pressed   = 0;						      /* reset button 2 pressed flag */
+
+  dev->pause_for_color_calibration = 0;			/* pause between start_scan and do_calibration in ms */
+  dev->pause_for_gray_calibration  = 0;			/* pause between start_scan and do_calibration in ms */
+  dev->pause_after_calibration     = 0;			 /* pause between do_calibration and read data in ms */
+  dev->pause_after_reposition      = -1;	    /* pause after repostion scanner in ms, -1 = do not wait */
+  dev->pause_for_moving            = 0;			         /* pause for moving scanhead over full area */
+
+  if (umax_test_little_endian() == SANE_TRUE)
+  {
+    dev->low_byte_first = 1;					        /* in 2 byte mode send lowbyte first */
+    DBG(DBG_info, "backend runs on little endian machine\n");
+  }
+  else
+  {
+    dev->low_byte_first = 0;					       /* in 2 byte mode send highbyte first */
+    DBG(DBG_info, "backend runs on big endian machine\n");
+  }
+
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+  DBG(DBG_info,"variable scsi buffer size (usage of sanei_scsi_open_extended)\n");
+#else
+  DBG(DBG_info,"fixed scsi buffer size = %d bytes\n", sanei_scsi_max_request_size);
+#endif
+}
+
+
+/* ------------------------------------------------------------ MAX STRING SIZE ---------------------------- */
+
+
+static size_t max_string_size(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;
+}
+
+
+/* ------------------------------------------------------------ DO CANCEL ---------------------------------- */
+
+
+static SANE_Status do_cancel(Umax_Scanner *scanner)
+{
+  SANE_Pid pid;
+  int status;
+
+  DBG(DBG_sane_proc,"do_cancel\n");
+
+  scanner->scanning = SANE_FALSE;
+
+  if (scanner->reader_pid != -1)
+  {
+    DBG(DBG_sane_info,"killing reader_process\n");
+
+    sanei_thread_kill(scanner->reader_pid);
+    pid = sanei_thread_waitpid(scanner->reader_pid, &status);
+
+    if (pid == -1)
+    {
+      DBG(DBG_sane_info, "do_cancel: sanei_thread_waitpid failed, already terminated ? (%s)\n", strerror(errno));
+    }
+    else
+    {
+      DBG(DBG_sane_info, "do_cancel: reader_process terminated with status: %s\n", sane_strstatus(status));
+    }
+
+    scanner->reader_pid = -1;
+
+    if (scanner->device->pixelbuffer != NULL)					      /* pixelbuffer exists? */
+    {
+      free(scanner->device->pixelbuffer);						 /* free pixelbuffer */
+      scanner->device->pixelbuffer = NULL;
+    }
+  }
+
+  sanei_scsi_req_flush_all(); /* flush SCSI queue, when we do not do this then sanei_scsi crashes next time */
+
+  if (scanner->device->sfd != -1) /* make sure we have a working filedescriptor */
+  {
+    umax_give_scanner(scanner->device); /* reposition and release scanner */
+    DBG(DBG_sane_info,"closing scannerdevice filedescriptor\n");
+    umax_scsi_close(scanner->device);
+  }
+
+  scanner->device->three_pass_color = 1; /* reset color in color scanning */
+
+ return SANE_STATUS_CANCELLED;
+}
+
+
+/* ------------------------------------------------------------ ATTACH SCANNER ----------------------------- */
+
+
+static SANE_Status attach_scanner(const char *devicename, Umax_Device **devp, int connection_type)
+{
+ Umax_Device *dev;
+ int i;
+
+  DBG(DBG_sane_proc,"attach_scanner: %s, connection_type %d\n", devicename, connection_type);
+
+  for (dev = first_dev; dev; dev = dev->next) /* search is scanner already is listed in devicelist */
+  {
+    if (strcmp(dev->sane.name, devicename) == 0) /* scanner is already listed */
+    {
+      if (devp)
+      {
+        *devp = dev; /* return pointer to device */
+      }
+     return SANE_STATUS_GOOD;
+    }
+  }
+
+  /* scanner has not been attached yet */
+
+  dev = malloc( sizeof(*dev) );
+  if (!dev)
+  {
+     return SANE_STATUS_NO_MEM;
+  }
+  memset(dev, '\0', sizeof(Umax_Device)); /* clear structure */
+
+  /* If connection type is not known (==0) then try to open the device as an USB device. */
+  /* If it fails, try the SCSI method. */
+
+#ifdef UMAX_ENABLE_USB
+  dev->connection_type = connection_type; /* 0 = unknown, 1=scsi, 2=usb */
+
+  if (dev->connection_type != SANE_UMAX_SCSI)
+  {
+    dev->bufsize = 16384; /* 16KB */
+    DBG(DBG_info, "attach_scanner: opening usb device %s\n", devicename);
+
+    if (sanei_umaxusb_open(devicename, &dev->sfd, sense_handler, dev) == SANE_STATUS_GOOD)
+    {
+      dev->connection_type = SANE_UMAX_USB;
+    }
+    else /* opening usb device failed */
+    {
+      if (dev->connection_type == SANE_UMAX_USB) /* we know it is not a scsi device: error */
+      {
+        DBG(DBG_error, "ERROR: attach_scanner: opening usb device %s failed\n", devicename);
+        free(dev);
+       return SANE_STATUS_INVAL;
+      }
+
+      DBG(DBG_info, "attach_scanner: failed to open %s as usb device\n", devicename);
+    }
+  }
+#else
+  dev->connection_type = SANE_UMAX_SCSI;
+#endif
+
+  if (dev->connection_type != SANE_UMAX_USB) /* not an USB device, then try as SCSI */
+  {
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+    dev->bufsize = 16384; /* 16KB */
+    DBG(DBG_info, "attach_scanner: opening scsi device %s\n", devicename);
+
+    if (sanei_scsi_open_extended(devicename, &dev->sfd, sense_handler, dev, (int *) &dev->bufsize) != 0)
+    {
+      DBG(DBG_error, "ERROR: attach_scanner: opening scsi device %s failed\n", devicename);
+      free(dev);
+     return SANE_STATUS_INVAL;
+    }
+
+    if (dev->bufsize < 4096) /* < 4KB */
+    {
+      DBG(DBG_error, "ERROR: attach_scanner: sanei_scsi_open_extended returned too small scsi buffer\n");
+      umax_scsi_close(dev);
+      free(dev);
+     return SANE_STATUS_NO_MEM;
+    }
+
+    DBG(DBG_info, "attach_scanner: sanei_scsi_open_extended returned scsi buffer size = %d\n", dev->bufsize);
+#else
+    dev->bufsize = sanei_scsi_max_request_size;
+
+    if (sanei_scsi_open(devicename, dev, sense_handler, dev) != 0)
+    {
+      DBG(DBG_error, "ERROR: attach_scanner: opening scsi device %s failed\n", devicename);
+      free(dev);
+     return SANE_STATUS_INVAL;
+    }
+#endif
+    dev->connection_type = SANE_UMAX_SCSI; /* set connection type (may have been unknown == 0) */
+  }
+
+  DBG(DBG_info, "attach_scanner: allocating SCSI buffer[0]\n");
+  dev->buffer[0] = malloc(dev->bufsize);								/* allocate buffer */
+
+  for (i=1; i<SANE_UMAX_SCSI_MAXQUEUE; i++)
+  {
+    dev->buffer[i] = NULL;
+  }
+
+  if (!dev->buffer[0]) /* malloc failed */
+  {
+    DBG(DBG_error, "ERROR: attach scanner: could not allocate buffer[0]\n");
+    umax_scsi_close(dev);
+    free(dev);
+    return SANE_STATUS_NO_MEM;
+  }
+
+  dev->scsi_maxqueue = 1; /* only one buffer outside the reader process */
+
+  umax_init(dev);									 /* preset values in structure dev */
+  umax_initialize_values(dev);										   /* reset values */
+
+  dev->devicename = strdup(devicename);
+
+  if (umax_identify_scanner(dev) != 0)
+  {
+    DBG(DBG_error, "ERROR: attach_scanner: scanner-identification failed\n");
+    umax_scsi_close(dev);
+    free(dev->buffer[0]);
+    free(dev);
+    return SANE_STATUS_INVAL;
+  }
+
+  if (dev->slow == -1) /* option is not predefined in umax.conf and not by backend */
+  {
+    dev->slow = 0;
+  }
+
+  if (dev->smear == -1) /* option is not predefined in umax.conf and not by backend */
+  {
+    dev->smear = 0;
+  }
+
+  if (dev->invert_shading_data == -1) /* nothing defined in umax.conf and not by backend */
+  {
+    dev->invert_shading_data = 0;
+  }
+
+  if (dev->gamma_lsb_padded == -1) /* nothing defined in umax.conf and not by backend */
+  {
+    dev->gamma_lsb_padded = 0;
+  }
+
+  umax_get_inquiry_values(dev);
+  umax_print_inquiry(dev);
+  DBG(DBG_inquiry,"\n");
+  DBG(DBG_inquiry,"==================== end of inquiry ====================\n");
+  DBG(DBG_inquiry,"\n");
+
+  umax_scsi_close(dev);
+
+  dev->sane.name   = dev->devicename;
+  dev->sane.vendor = dev->vendor;
+  dev->sane.model  = dev->product;
+  dev->sane.type   = "flatbed scanner"; 
+
+  if (strcmp(dev->sane.model,"PSD ") == 0)
+  {
+    dev->sane.type = "page scanner";
+  }
+
+  dev->x_range.min               = SANE_FIX(0);
+  dev->x_range.quant             = SANE_FIX(0);
+  dev->x_range.max               = SANE_FIX(dev->inquiry_fb_width  * MM_PER_INCH);
+
+  dev->y_range.min               = SANE_FIX(0);
+  dev->y_range.quant             = SANE_FIX(0);
+  dev->y_range.max               = SANE_FIX(dev->inquiry_fb_length * MM_PER_INCH);
+
+#if UMAX_RESOLUTION_PERCENT_STEP
+  dev->x_dpi_range.min           = SANE_FIX(dev->inquiry_optical_res/100);
+  dev->x_dpi_range.quant         = SANE_FIX(dev->inquiry_optical_res/100);
+#else
+  dev->x_dpi_range.min           = SANE_FIX(5);
+  dev->x_dpi_range.quant         = SANE_FIX(5);
+#endif
+  dev->x_dpi_range.max           = SANE_FIX(dev->inquiry_x_res);
+
+#if UMAX_RESOLUTION_PERCENT_STEP
+  dev->y_dpi_range.min           = SANE_FIX(dev->inquiry_optical_res/100);
+  dev->y_dpi_range.quant         = SANE_FIX(dev->inquiry_optical_res/100);
+#else
+  dev->y_dpi_range.min           = SANE_FIX(5);
+  dev->y_dpi_range.quant         = SANE_FIX(5);
+#endif
+  dev->y_dpi_range.max           = SANE_FIX(dev->inquiry_y_res);
+
+  dev->analog_gamma_range.min    = SANE_FIX(1.0);
+  dev->analog_gamma_range.quant  = SANE_FIX(0.01);
+  dev->analog_gamma_range.max    = SANE_FIX(2.0);
+
+  DBG(DBG_info,"x_range.max     = %f\n", SANE_UNFIX(dev->x_range.max));
+  DBG(DBG_info,"y_range.max     = %f\n", SANE_UNFIX(dev->y_range.max));
+  DBG(DBG_info,"x_dpi_range.max = %f\n", SANE_UNFIX(dev->x_dpi_range.max));
+  DBG(DBG_info,"y_dpi_range.max = %f\n", SANE_UNFIX(dev->y_dpi_range.max));
+
+  ++num_devices;
+  dev->next = first_dev;
+  first_dev = dev;
+
+  if (devp)
+  {
+    *devp = dev;
+  }
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/* ------------------------------------------------------------ READER PROCESS SIGTERM HANDLER  ------------ */
+
+
+static RETSIGTYPE reader_process_sigterm_handler(int signal)
+{
+  DBG(DBG_sane_info,"reader_process: terminated by signal %d\n", signal);
+
+  sanei_scsi_req_flush_all(); /* flush SCSI queue */
+
+  _exit (SANE_STATUS_GOOD);
+}
+
+
+/* ------------------------------------------------------------ READER PROCESS ----------------------------- */
+
+
+static int reader_process(void *data) /* executed as a child process or as thread */
+{
+ Umax_Scanner *scanner = (Umax_Scanner *)data;
+ FILE *fp;
+ int status;
+ unsigned int data_length;
+ struct SIGACTION act;
+ unsigned int i;
+
+  if (sanei_thread_is_forked())
+  {
+    DBG(DBG_sane_proc,"reader_process started (forked)\n");
+    close(scanner->pipe_read_fd);
+    scanner->pipe_read_fd = -1;
+
+    /* sanei_scsi crashes when the scsi commands are not flushed, done in reader_process_sigterm_handler */
+    memset(&act, 0, sizeof (act));						   /* define SIGTERM-handler */
+    act.sa_handler = reader_process_sigterm_handler;
+    sigaction(SIGTERM, &act, 0);
+  }
+  else
+  {
+    DBG(DBG_sane_proc,"reader_process started (as thread)\n");
+  }
+
+
+  scanner->device->scsi_maxqueue = scanner->device->request_scsi_maxqueue;
+
+  if (scanner->device->request_scsi_maxqueue > 1)
+  {
+    for (i = 1; i<SANE_UMAX_SCSI_MAXQUEUE; i++)
+    {
+      if (scanner->device->buffer[i])
+      {
+        DBG(DBG_info, "reader_process: freeing SCSI buffer[%d]\n", i);
+        free(scanner->device->buffer[i]);									     /* free buffer */
+        scanner->device->buffer[i] = NULL;
+      }
+    }
+
+    for (i = 1; i<scanner->device->request_scsi_maxqueue; i++)
+    {
+      DBG(DBG_info, "reader_process: allocating SCSI buffer[%d]\n", i);
+      scanner->device->buffer[i]  = malloc(scanner->device->bufsize);			  /* allocate buffer */
+
+      if (!scanner->device->buffer[i]) /* malloc failed */
+      {
+        DBG(DBG_warning, "WARNING: reader_process: only allocated %d/%d scsi buffers\n", i, scanner->device->request_scsi_maxqueue);
+        scanner->device->scsi_maxqueue = i;
+        break; /* leave for loop */
+      }
+    }
+  }
+
+  data_length = scanner->params.lines * scanner->params.bytes_per_line;
+
+  fp = fdopen(scanner->pipe_write_fd, "w");
+  if (!fp)
+  {
+    return SANE_STATUS_IO_ERROR;
+  } 
+
+  DBG(DBG_sane_info,"reader_process: starting to READ data\n");
+
+  status = umax_reader_process(scanner->device, fp, data_length);
+  fclose(fp); /* close write end of pipe */
+
+  for (i = 1; i<scanner->device->request_scsi_maxqueue; i++)
+  {
+    if (scanner->device->buffer[i])
+    {
+      DBG(DBG_info, "reader_process: freeing SCSI buffer[%d]\n", i);
+      free(scanner->device->buffer[i]);									     /* free buffer */
+      scanner->device->buffer[i] = NULL;
+    }
+  }
+  DBG(DBG_sane_info,"reader_process: finished reading data\n");
+
+ return status;
+}
+
+
+/* ------------------------------------------------------------ INIT OPTIONS ------------------------------- */
+
+
+static SANE_Status init_options(Umax_Scanner *scanner)
+{
+ int i;
+ int scan_modes;
+ int bit_depths;
+
+  DBG(DBG_sane_proc,"init_options\n");
+
+  memset(scanner->opt, 0, sizeof (scanner->opt));
+  memset(scanner->val, 0, sizeof (scanner->val));
+
+  for (i = 0; i < NUM_OPTIONS; ++i)
+  {
+    scanner->opt[i].size = sizeof (SANE_Word);
+    scanner->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+  }
+
+  scanner->opt[OPT_NUM_OPTS].name  = SANE_NAME_NUM_OPTIONS; /* empty string */
+  scanner->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
+  scanner->opt[OPT_NUM_OPTS].desc  = SANE_DESC_NUM_OPTIONS;
+  scanner->opt[OPT_NUM_OPTS].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_NUM_OPTS].cap   = SANE_CAP_SOFT_DETECT;
+  scanner->val[OPT_NUM_OPTS].w     = NUM_OPTIONS;
+
+  /* "Mode" group: */
+  scanner->opt[OPT_MODE_GROUP].title = SANE_I18N("Scan Mode");
+  scanner->opt[OPT_MODE_GROUP].desc  = "";
+  scanner->opt[OPT_MODE_GROUP].type  = SANE_TYPE_GROUP;
+  scanner->opt[OPT_MODE_GROUP].cap   = 0;
+  scanner->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  scan_modes = -1;
+
+  if (scanner->device->inquiry_lineart)
+  {
+    scan_mode_list[++scan_modes] = LINEART_STR;
+  }
+
+  if (scanner->device->inquiry_halftone)
+  {
+    scan_mode_list[++scan_modes]= HALFTONE_STR;
+  }
+
+  if (scanner->device->inquiry_gray)
+  {
+    scan_mode_list[++scan_modes]= GRAY_STR;
+  }
+
+  if (scanner->device->inquiry_color)
+  {
+/*  
+    if (scanner->device->inquiry_lineart)
+    { scan_mode_list[++scan_modes]= COLOR_LINEART_STR; }
+
+    if (scanner->device->inquiry_halftone) 
+    { scan_mode_list[++scan_modes]= COLOR_HALFTONE_STR; }
+*/
+    scan_mode_list[++scan_modes]= COLOR_STR; 
+  }
+
+  scan_mode_list[scan_modes + 1] = 0; 
+
+  {
+   int i=0;
+    source_list[i++]= FLB_STR;
+
+    if (scanner->device->inquiry_adfmode)
+    {
+      source_list[i++] = ADF_STR;
+    }
+
+    if (scanner->device->inquiry_transavail)
+    {
+      source_list[i++] = UTA_STR;
+    }
+
+    source_list[i] = 0;
+  }
+  
+  /* scan mode */
+  scanner->opt[OPT_MODE].name  = SANE_NAME_SCAN_MODE;
+  scanner->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
+  scanner->opt[OPT_MODE].desc  = SANE_DESC_SCAN_MODE;
+  scanner->opt[OPT_MODE].type  = SANE_TYPE_STRING;
+  scanner->opt[OPT_MODE].size  = max_string_size((SANE_String_Const *) scan_mode_list);
+  scanner->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  scanner->opt[OPT_MODE].constraint.string_list = (SANE_String_Const *) scan_mode_list;
+  scanner->val[OPT_MODE].s     = (SANE_Char*)strdup(scan_mode_list[0]);
+
+  /* source */
+  scanner->opt[OPT_SOURCE].name  = SANE_NAME_SCAN_SOURCE;
+  scanner->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE;
+  scanner->opt[OPT_SOURCE].desc  = SANE_DESC_SCAN_SOURCE;
+  scanner->opt[OPT_SOURCE].type  = SANE_TYPE_STRING;
+  scanner->opt[OPT_SOURCE].size  = max_string_size(source_list);
+  scanner->opt[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  scanner->opt[OPT_SOURCE].constraint.string_list = source_list;
+  scanner->val[OPT_SOURCE].s     = (SANE_Char*)strdup(source_list[0]);
+  
+  /* x-resolution */
+  scanner->opt[OPT_X_RESOLUTION].name  = SANE_NAME_SCAN_RESOLUTION;
+  scanner->opt[OPT_X_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
+  scanner->opt[OPT_X_RESOLUTION].desc  = SANE_DESC_SCAN_RESOLUTION;
+  scanner->opt[OPT_X_RESOLUTION].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_X_RESOLUTION].unit  = SANE_UNIT_DPI;
+  scanner->opt[OPT_X_RESOLUTION].constraint_type  = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_X_RESOLUTION].constraint.range = &scanner->device->x_dpi_range;
+  scanner->val[OPT_X_RESOLUTION].w     = 100 << SANE_FIXED_SCALE_SHIFT;
+
+  /* y-resolution */
+  scanner->opt[OPT_Y_RESOLUTION].name  = SANE_NAME_SCAN_Y_RESOLUTION;
+  scanner->opt[OPT_Y_RESOLUTION].title = SANE_TITLE_SCAN_Y_RESOLUTION;
+  scanner->opt[OPT_Y_RESOLUTION].desc  = SANE_DESC_SCAN_Y_RESOLUTION;
+  scanner->opt[OPT_Y_RESOLUTION].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_Y_RESOLUTION].unit  = SANE_UNIT_DPI;
+  scanner->opt[OPT_Y_RESOLUTION].constraint_type  = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_Y_RESOLUTION].constraint.range = &scanner->device->y_dpi_range;
+  scanner->val[OPT_Y_RESOLUTION].w     = 100 << SANE_FIXED_SCALE_SHIFT;
+  scanner->opt[OPT_Y_RESOLUTION].cap  |= SANE_CAP_INACTIVE;
+
+  /* bind resolution */
+  scanner->opt[OPT_RESOLUTION_BIND].name  = SANE_NAME_RESOLUTION_BIND;
+  scanner->opt[OPT_RESOLUTION_BIND].title = SANE_TITLE_RESOLUTION_BIND;
+  scanner->opt[OPT_RESOLUTION_BIND].desc  = SANE_DESC_RESOLUTION_BIND;
+  scanner->opt[OPT_RESOLUTION_BIND].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_RESOLUTION_BIND].w     = SANE_TRUE;
+  if (scanner->device->common_xy_resolutions)	/* disable bind if x and y res have to be the same */
+  {
+    scanner->opt[OPT_RESOLUTION_BIND].cap  |= SANE_CAP_INACTIVE;
+  }
+
+
+  /* negative */
+  scanner->opt[OPT_NEGATIVE].name  = SANE_NAME_NEGATIVE;
+  scanner->opt[OPT_NEGATIVE].title = SANE_TITLE_NEGATIVE;
+  scanner->opt[OPT_NEGATIVE].desc  = SANE_DESC_NEGATIVE;
+  scanner->opt[OPT_NEGATIVE].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_NEGATIVE].w     = SANE_FALSE;
+
+  if (scanner->device->inquiry_reverse_multi == 0)
+  {
+    scanner->opt[OPT_NEGATIVE].cap  |= SANE_CAP_INACTIVE;
+  }
+
+  /* ------------------------------ */
+
+  /* "Geometry" group: */
+  scanner->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N("Geometry");
+  scanner->opt[OPT_GEOMETRY_GROUP].desc  = "";
+  scanner->opt[OPT_GEOMETRY_GROUP].type  = SANE_TYPE_GROUP;
+  scanner->opt[OPT_GEOMETRY_GROUP].cap   = SANE_CAP_ADVANCED;
+  scanner->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* top-left x */
+  scanner->opt[OPT_TL_X].name  = SANE_NAME_SCAN_TL_X;
+  scanner->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
+  scanner->opt[OPT_TL_X].desc  = SANE_DESC_SCAN_TL_X;
+  scanner->opt[OPT_TL_X].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_TL_X].unit  = SANE_UNIT_MM;
+  scanner->opt[OPT_TL_X].constraint_type  = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_TL_X].constraint.range = &(scanner->device->x_range);
+  scanner->val[OPT_TL_X].w     = 0;
+
+  /* top-left y */
+  scanner->opt[OPT_TL_Y].name  = SANE_NAME_SCAN_TL_Y;
+  scanner->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
+  scanner->opt[OPT_TL_Y].desc  = SANE_DESC_SCAN_TL_Y;
+  scanner->opt[OPT_TL_Y].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_TL_Y].unit  = SANE_UNIT_MM;
+  scanner->opt[OPT_TL_Y].constraint_type  = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_TL_Y].constraint.range = &(scanner->device->y_range);
+  scanner->val[OPT_TL_Y].w     = 0;
+
+  /* bottom-right x */
+  scanner->opt[OPT_BR_X].name  = SANE_NAME_SCAN_BR_X;
+  scanner->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
+  scanner->opt[OPT_BR_X].desc  = SANE_DESC_SCAN_BR_X;
+  scanner->opt[OPT_BR_X].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_BR_X].unit  = SANE_UNIT_MM;
+  scanner->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_BR_X].constraint.range = &(scanner->device->x_range);
+  scanner->val[OPT_BR_X].w     = scanner->device->x_range.max;
+
+  /* bottom-right y */
+  scanner->opt[OPT_BR_Y].name  = SANE_NAME_SCAN_BR_Y;
+  scanner->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
+  scanner->opt[OPT_BR_Y].desc  = SANE_DESC_SCAN_BR_Y;
+  scanner->opt[OPT_BR_Y].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_BR_Y].unit  = SANE_UNIT_MM;
+  scanner->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_BR_Y].constraint.range = &(scanner->device->y_range);
+  scanner->val[OPT_BR_Y].w     = scanner->device->y_range.max;
+
+  /* ------------------------------ */
+
+
+  /* "Enhancement" group: */
+  scanner->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N("Enhancement");
+  scanner->opt[OPT_ENHANCEMENT_GROUP].desc  = "";
+  scanner->opt[OPT_ENHANCEMENT_GROUP].type  = SANE_TYPE_GROUP;
+  scanner->opt[OPT_ENHANCEMENT_GROUP].cap   = 0;
+  scanner->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+
+  /* bit depth */
+  bit_depths = 0;
+
+  if (scanner->device->inquiry_GOB & 1)
+  {
+    bit_depth_list[++bit_depths] = 8;
+  }
+
+  if (scanner->device->inquiry_GOB & 2)
+  {
+    bit_depth_list[++bit_depths] = 9;
+  }
+
+  if (scanner->device->inquiry_GOB & 4)
+  {
+    bit_depth_list[++bit_depths] = 10;
+  }
+
+  if (scanner->device->inquiry_GOB & 8)
+  {
+    bit_depth_list[++bit_depths] = 12;
+  }
+
+  if (scanner->device->inquiry_GOB & 16)
+  {
+    bit_depth_list[++bit_depths] = 14;
+  }
+
+  if (scanner->device->inquiry_GOB & 32)
+  {
+    bit_depth_list[++bit_depths] = 16;
+  }
+
+  bit_depth_list[0] = bit_depths;
+
+  scanner->opt[OPT_BIT_DEPTH].name  = SANE_NAME_BIT_DEPTH;
+  scanner->opt[OPT_BIT_DEPTH].title = SANE_TITLE_BIT_DEPTH;
+  scanner->opt[OPT_BIT_DEPTH].desc  = SANE_DESC_BIT_DEPTH;
+  scanner->opt[OPT_BIT_DEPTH].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_BIT_DEPTH].unit  = SANE_UNIT_BIT;
+  scanner->opt[OPT_BIT_DEPTH].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+  scanner->opt[OPT_BIT_DEPTH].constraint.word_list = bit_depth_list;
+  scanner->val[OPT_BIT_DEPTH].w     = bit_depth_list[1];
+
+
+  /* quality-calibration */
+  scanner->opt[OPT_QUALITY].name  = SANE_NAME_QUALITY_CAL;
+  scanner->opt[OPT_QUALITY].title = SANE_TITLE_QUALITY_CAL;
+  scanner->opt[OPT_QUALITY].desc  = SANE_DESC_QUALITY_CAL;
+  scanner->opt[OPT_QUALITY].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_QUALITY].w     = SANE_FALSE;
+
+  if ((scanner->device->inquiry_quality_ctrl == 0) || (scanner->device->force_quality_calibration) )
+  {
+    scanner->opt[OPT_QUALITY].cap  |= SANE_CAP_INACTIVE;
+  }
+  else /* enable quality calibration when available */
+  {
+    scanner->val[OPT_QUALITY].w = SANE_TRUE;
+  }
+
+
+  /* double optical resolution */
+  scanner->opt[OPT_DOR].name  = SANE_NAME_DOR;
+  scanner->opt[OPT_DOR].title = SANE_TITLE_DOR;
+  scanner->opt[OPT_DOR].desc  = SANE_DESC_DOR;
+  scanner->opt[OPT_DOR].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_DOR].w     = SANE_FALSE;
+
+  if (scanner->device->inquiry_dor == 0)
+  {
+    scanner->opt[OPT_DOR].cap  |= SANE_CAP_INACTIVE;
+  }
+
+
+  /* warmup */
+  scanner->opt[OPT_WARMUP].name  = SANE_NAME_WARMUP;
+  scanner->opt[OPT_WARMUP].title = SANE_TITLE_WARMUP;
+  scanner->opt[OPT_WARMUP].desc  = SANE_DESC_WARMUP;
+  scanner->opt[OPT_WARMUP].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_WARMUP].w     = SANE_FALSE;
+
+  if (scanner->device->inquiry_max_warmup_time == 0)
+  {
+    scanner->opt[OPT_WARMUP].cap  |= SANE_CAP_INACTIVE;
+  }
+
+  scanner->opt[OPT_RGB_BIND].name  = SANE_NAME_RGB_BIND;
+  scanner->opt[OPT_RGB_BIND].title = SANE_TITLE_RGB_BIND;
+  scanner->opt[OPT_RGB_BIND].desc  = SANE_DESC_RGB_BIND;
+  scanner->opt[OPT_RGB_BIND].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_RGB_BIND].w     = SANE_FALSE;
+
+  /* brightness */
+  scanner->opt[OPT_BRIGHTNESS].name  = SANE_NAME_BRIGHTNESS;
+  scanner->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
+  scanner->opt[OPT_BRIGHTNESS].desc  = SANE_DESC_BRIGHTNESS;
+  scanner->opt[OPT_BRIGHTNESS].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_BRIGHTNESS].unit  = SANE_UNIT_PERCENT;
+  scanner->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_BRIGHTNESS].constraint.range = &percentage_range;
+  scanner->val[OPT_BRIGHTNESS].w     = 0;
+
+  /* contrast */
+  scanner->opt[OPT_CONTRAST].name  = SANE_NAME_CONTRAST;
+  scanner->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
+  scanner->opt[OPT_CONTRAST].desc  = SANE_DESC_CONTRAST;
+  scanner->opt[OPT_CONTRAST].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_CONTRAST].unit  = SANE_UNIT_PERCENT;
+  scanner->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_CONTRAST].constraint.range = &percentage_range;
+  scanner->val[OPT_CONTRAST].w     = 0;
+
+
+  /* threshold */
+  scanner->opt[OPT_THRESHOLD].name  = SANE_NAME_THRESHOLD;
+  scanner->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
+  scanner->opt[OPT_THRESHOLD].desc  = SANE_DESC_THRESHOLD;
+  scanner->opt[OPT_THRESHOLD].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_THRESHOLD].unit  = SANE_UNIT_PERCENT;
+  scanner->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_THRESHOLD].constraint.range = &percentage_range_100;
+  scanner->val[OPT_THRESHOLD].w     = SANE_FIX(50);
+
+
+  /* ------------------------------ */
+
+
+  /* highlight, white level */
+  scanner->opt[OPT_HIGHLIGHT].name  = SANE_NAME_HIGHLIGHT;
+  scanner->opt[OPT_HIGHLIGHT].title = SANE_TITLE_HIGHLIGHT;
+  scanner->opt[OPT_HIGHLIGHT].desc  = SANE_DESC_HIGHLIGHT;
+  scanner->opt[OPT_HIGHLIGHT].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_HIGHLIGHT].unit  = SANE_UNIT_PERCENT;
+  scanner->opt[OPT_HIGHLIGHT].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_HIGHLIGHT].constraint.range = &percentage_range_100;
+  scanner->val[OPT_HIGHLIGHT].w     = SANE_FIX(100);
+
+  scanner->opt[OPT_HIGHLIGHT_R].name  = SANE_NAME_HIGHLIGHT_R;
+  scanner->opt[OPT_HIGHLIGHT_R].title = SANE_TITLE_HIGHLIGHT_R;
+  scanner->opt[OPT_HIGHLIGHT_R].desc  = SANE_DESC_HIGHLIGHT_R;
+  scanner->opt[OPT_HIGHLIGHT_R].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_HIGHLIGHT_R].unit  = SANE_UNIT_PERCENT;
+  scanner->opt[OPT_HIGHLIGHT_R].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_HIGHLIGHT_R].constraint.range = &percentage_range_100;
+  scanner->val[OPT_HIGHLIGHT_R].w     = SANE_FIX(100);
+
+  scanner->opt[OPT_HIGHLIGHT_G].name  = SANE_NAME_HIGHLIGHT_G;
+  scanner->opt[OPT_HIGHLIGHT_G].title = SANE_TITLE_HIGHLIGHT_G;
+  scanner->opt[OPT_HIGHLIGHT_G].desc  = SANE_DESC_HIGHLIGHT_G;
+  scanner->opt[OPT_HIGHLIGHT_G].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_HIGHLIGHT_G].unit  = SANE_UNIT_PERCENT;
+  scanner->opt[OPT_HIGHLIGHT_G].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_HIGHLIGHT_G].constraint.range = &percentage_range_100;
+  scanner->val[OPT_HIGHLIGHT_G].w     = SANE_FIX(100);
+
+  scanner->opt[OPT_HIGHLIGHT_B].name  = SANE_NAME_HIGHLIGHT_B;
+  scanner->opt[OPT_HIGHLIGHT_B].title = SANE_TITLE_HIGHLIGHT_B;
+  scanner->opt[OPT_HIGHLIGHT_B].desc  = SANE_DESC_HIGHLIGHT_B;
+  scanner->opt[OPT_HIGHLIGHT_B].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_HIGHLIGHT_B].unit  = SANE_UNIT_PERCENT;
+  scanner->opt[OPT_HIGHLIGHT_B].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_HIGHLIGHT_B].constraint.range = &percentage_range_100;
+  scanner->val[OPT_HIGHLIGHT_B].w     = SANE_FIX(100);
+
+
+  /* shadow, black level */
+  scanner->opt[OPT_SHADOW].name  = SANE_NAME_SHADOW;
+  scanner->opt[OPT_SHADOW].title = SANE_TITLE_SHADOW;
+  scanner->opt[OPT_SHADOW].desc  = SANE_DESC_SHADOW;
+  scanner->opt[OPT_SHADOW].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_SHADOW].unit  = SANE_UNIT_PERCENT;
+  scanner->opt[OPT_SHADOW].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_SHADOW].constraint.range = &percentage_range_100;
+  scanner->val[OPT_SHADOW].w     = 0;
+
+  scanner->opt[OPT_SHADOW_R].name  = SANE_NAME_SHADOW_R;
+  scanner->opt[OPT_SHADOW_R].title = SANE_TITLE_SHADOW_R;
+  scanner->opt[OPT_SHADOW_R].desc  = SANE_DESC_SHADOW_R;
+  scanner->opt[OPT_SHADOW_R].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_SHADOW_R].unit  = SANE_UNIT_PERCENT;
+  scanner->opt[OPT_SHADOW_R].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_SHADOW_R].constraint.range = &percentage_range_100;
+  scanner->val[OPT_SHADOW_R].w     = 0;
+
+  scanner->opt[OPT_SHADOW_G].name  = SANE_NAME_SHADOW_G;
+  scanner->opt[OPT_SHADOW_G].title = SANE_TITLE_SHADOW_G;
+  scanner->opt[OPT_SHADOW_G].desc  = SANE_DESC_SHADOW_G;
+  scanner->opt[OPT_SHADOW_G].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_SHADOW_G].unit  = SANE_UNIT_PERCENT;
+  scanner->opt[OPT_SHADOW_G].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_SHADOW_G].constraint.range = &percentage_range_100;
+  scanner->val[OPT_SHADOW_G].w     = 0;
+
+  scanner->opt[OPT_SHADOW_B].name  = SANE_NAME_SHADOW_B;
+  scanner->opt[OPT_SHADOW_B].title = SANE_TITLE_SHADOW_B;
+  scanner->opt[OPT_SHADOW_B].desc  = SANE_DESC_SHADOW_B;
+  scanner->opt[OPT_SHADOW_B].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_SHADOW_B].unit  = SANE_UNIT_PERCENT;
+  scanner->opt[OPT_SHADOW_B].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_SHADOW_B].constraint.range = &percentage_range_100;
+  scanner->val[OPT_SHADOW_B].w     = 0;
+
+
+
+  /* analog-gamma */
+  scanner->opt[OPT_ANALOG_GAMMA].name  = SANE_NAME_ANALOG_GAMMA;
+  scanner->opt[OPT_ANALOG_GAMMA].title = SANE_TITLE_ANALOG_GAMMA;
+  scanner->opt[OPT_ANALOG_GAMMA].desc  = SANE_DESC_ANALOG_GAMMA;
+  scanner->opt[OPT_ANALOG_GAMMA].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_ANALOG_GAMMA].unit  = SANE_UNIT_NONE;
+  scanner->opt[OPT_ANALOG_GAMMA].constraint_type  = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_ANALOG_GAMMA].constraint.range = &(scanner->device->analog_gamma_range);
+  scanner->val[OPT_ANALOG_GAMMA].w     = 1 << SANE_FIXED_SCALE_SHIFT;
+
+  scanner->opt[OPT_ANALOG_GAMMA_R].name  = SANE_NAME_ANALOG_GAMMA_R;
+  scanner->opt[OPT_ANALOG_GAMMA_R].title = SANE_TITLE_ANALOG_GAMMA_R;
+  scanner->opt[OPT_ANALOG_GAMMA_R].desc  = SANE_DESC_ANALOG_GAMMA_R;
+  scanner->opt[OPT_ANALOG_GAMMA_R].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_ANALOG_GAMMA_R].unit  = SANE_UNIT_NONE;
+  scanner->opt[OPT_ANALOG_GAMMA_R].constraint_type  = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_ANALOG_GAMMA_R].constraint.range = &(scanner->device->analog_gamma_range);
+  scanner->val[OPT_ANALOG_GAMMA_R].w     = 1 << SANE_FIXED_SCALE_SHIFT;
+
+  scanner->opt[OPT_ANALOG_GAMMA_G].name  = SANE_NAME_ANALOG_GAMMA_G;
+  scanner->opt[OPT_ANALOG_GAMMA_G].title = SANE_TITLE_ANALOG_GAMMA_G;
+  scanner->opt[OPT_ANALOG_GAMMA_G].desc  = SANE_DESC_ANALOG_GAMMA_G;
+  scanner->opt[OPT_ANALOG_GAMMA_G].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_ANALOG_GAMMA_G].unit  = SANE_UNIT_NONE;
+  scanner->opt[OPT_ANALOG_GAMMA_G].constraint_type  = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_ANALOG_GAMMA_G].constraint.range = &(scanner->device->analog_gamma_range);
+  scanner->val[OPT_ANALOG_GAMMA_G].w     = 1 << SANE_FIXED_SCALE_SHIFT;
+
+  scanner->opt[OPT_ANALOG_GAMMA_B].name  = SANE_NAME_ANALOG_GAMMA_B;
+  scanner->opt[OPT_ANALOG_GAMMA_B].title = SANE_TITLE_ANALOG_GAMMA_B;
+  scanner->opt[OPT_ANALOG_GAMMA_B].desc  = SANE_DESC_ANALOG_GAMMA_B;
+  scanner->opt[OPT_ANALOG_GAMMA_B].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_ANALOG_GAMMA_B].unit  = SANE_UNIT_NONE;
+  scanner->opt[OPT_ANALOG_GAMMA_B].constraint_type  = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_ANALOG_GAMMA_B].constraint.range = &(scanner->device->analog_gamma_range);
+  scanner->val[OPT_ANALOG_GAMMA_B].w     = 1 << SANE_FIXED_SCALE_SHIFT;
+
+
+  /* custom-gamma table */
+  scanner->opt[OPT_CUSTOM_GAMMA].name  = SANE_NAME_CUSTOM_GAMMA;
+  scanner->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
+  scanner->opt[OPT_CUSTOM_GAMMA].desc  = SANE_DESC_CUSTOM_GAMMA;
+  scanner->opt[OPT_CUSTOM_GAMMA].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_CUSTOM_GAMMA].w     = SANE_TRUE;
+
+  /* grayscale gamma vector */
+  scanner->opt[OPT_GAMMA_VECTOR].name  = SANE_NAME_GAMMA_VECTOR;
+  scanner->opt[OPT_GAMMA_VECTOR].title = SANE_TITLE_GAMMA_VECTOR;
+  scanner->opt[OPT_GAMMA_VECTOR].desc  = SANE_DESC_GAMMA_VECTOR;
+  scanner->opt[OPT_GAMMA_VECTOR].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_GAMMA_VECTOR].unit  = SANE_UNIT_NONE;
+  scanner->opt[OPT_GAMMA_VECTOR].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->val[OPT_GAMMA_VECTOR].wa    = scanner->gamma_table[0];
+  scanner->opt[OPT_GAMMA_VECTOR].constraint.range = &scanner->output_range;
+  scanner->opt[OPT_GAMMA_VECTOR].size  = scanner->gamma_length * sizeof(SANE_Word);
+
+  scanner->output_range.min   = 0;
+
+  if (bit_depth_list[1] == 8)
+  {
+    scanner->output_range.max = 255;    /* 8 bits/pixel */
+  }
+  else
+  {
+    scanner->output_range.max = 65535;  /* 9-16 bits/pixel */
+  }
+
+  scanner->output_range.quant = 0;
+
+  /* red gamma vector */
+  scanner->opt[OPT_GAMMA_VECTOR_R].name  = SANE_NAME_GAMMA_VECTOR_R;
+  scanner->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
+  scanner->opt[OPT_GAMMA_VECTOR_R].desc  = SANE_DESC_GAMMA_VECTOR_R;
+  scanner->opt[OPT_GAMMA_VECTOR_R].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_GAMMA_VECTOR_R].unit  = SANE_UNIT_NONE;
+  scanner->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->val[OPT_GAMMA_VECTOR_R].wa    = scanner->gamma_table[1];
+  scanner->opt[OPT_GAMMA_VECTOR_R].constraint.range = &(scanner->gamma_range);
+  scanner->opt[OPT_GAMMA_VECTOR_R].size  = scanner->gamma_length * sizeof(SANE_Word);
+
+  /* green gamma vector */
+  scanner->opt[OPT_GAMMA_VECTOR_G].name  = SANE_NAME_GAMMA_VECTOR_G;
+  scanner->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
+  scanner->opt[OPT_GAMMA_VECTOR_G].desc  = SANE_DESC_GAMMA_VECTOR_G;
+  scanner->opt[OPT_GAMMA_VECTOR_G].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_GAMMA_VECTOR_G].unit  = SANE_UNIT_NONE;
+  scanner->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->val[OPT_GAMMA_VECTOR_G].wa    = scanner->gamma_table[2];
+  scanner->opt[OPT_GAMMA_VECTOR_G].constraint.range = &(scanner->gamma_range);
+  scanner->opt[OPT_GAMMA_VECTOR_G].size  = scanner->gamma_length * sizeof(SANE_Word);
+
+  /* blue gamma vector */
+  scanner->opt[OPT_GAMMA_VECTOR_B].name  = SANE_NAME_GAMMA_VECTOR_B;
+  scanner->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
+  scanner->opt[OPT_GAMMA_VECTOR_B].desc  = SANE_DESC_GAMMA_VECTOR_B;
+  scanner->opt[OPT_GAMMA_VECTOR_B].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_GAMMA_VECTOR_B].unit  = SANE_UNIT_NONE;
+  scanner->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->val[OPT_GAMMA_VECTOR_B].wa    = scanner->gamma_table[3];
+  scanner->opt[OPT_GAMMA_VECTOR_B].constraint.range = &(scanner->gamma_range);
+  scanner->opt[OPT_GAMMA_VECTOR_B].size  = scanner->gamma_length * sizeof(SANE_Word);
+
+  /* halftone dimension */
+  scanner->opt[OPT_HALFTONE_DIMENSION].name  = SANE_NAME_HALFTONE_DIMENSION;
+  scanner->opt[OPT_HALFTONE_DIMENSION].title = SANE_TITLE_HALFTONE_DIMENSION;
+  scanner->opt[OPT_HALFTONE_DIMENSION].desc  = SANE_DESC_HALFTONE_DIMENSION;
+  scanner->opt[OPT_HALFTONE_DIMENSION].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_HALFTONE_DIMENSION].unit  = SANE_UNIT_PIXEL;
+  scanner->opt[OPT_HALFTONE_DIMENSION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+  scanner->opt[OPT_HALFTONE_DIMENSION].constraint.word_list = pattern_dim_list;
+  scanner->val[OPT_HALFTONE_DIMENSION].w     = pattern_dim_list[1];
+
+  /* halftone pattern */
+  scanner->opt[OPT_HALFTONE_PATTERN].name  = SANE_NAME_HALFTONE_PATTERN;
+  scanner->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN;
+  scanner->opt[OPT_HALFTONE_PATTERN].desc  = SANE_DESC_HALFTONE_PATTERN;
+  scanner->opt[OPT_HALFTONE_PATTERN].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_HALFTONE_PATTERN].size  = 0;
+  scanner->opt[OPT_HALFTONE_PATTERN].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_HALFTONE_PATTERN].constraint.range = &u8_range;
+  scanner->val[OPT_HALFTONE_PATTERN].wa    = scanner->halftone_pattern;
+
+
+  /* ------------------------------ */
+
+
+  /* "Advanced" group: */
+  scanner->opt[OPT_ADVANCED_GROUP].title = SANE_I18N("Advanced");
+  scanner->opt[OPT_ADVANCED_GROUP].desc  = "";
+  scanner->opt[OPT_ADVANCED_GROUP].type  = SANE_TYPE_GROUP;
+  scanner->opt[OPT_ADVANCED_GROUP].cap   = SANE_CAP_ADVANCED;
+  scanner->opt[OPT_ADVANCED_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+
+  /* ------------------------------ */
+
+
+  /* select exposure time */
+  scanner->opt[OPT_SELECT_EXPOSURE_TIME].name  = SANE_NAME_SELECT_EXPOSURE_TIME;
+  scanner->opt[OPT_SELECT_EXPOSURE_TIME].title = SANE_TITLE_SELECT_EXPOSURE_TIME;
+  scanner->opt[OPT_SELECT_EXPOSURE_TIME].desc  = SANE_DESC_SELECT_EXPOSURE_TIME;
+  scanner->opt[OPT_SELECT_EXPOSURE_TIME].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_SELECT_EXPOSURE_TIME].w     = SANE_FALSE;
+
+  /* select calibration exposure time */
+  scanner->opt[OPT_SELECT_CAL_EXPOSURE_TIME].name  = SANE_UMAX_NAME_SELECT_CALIBRATON_EXPOSURE_TIME;
+  scanner->opt[OPT_SELECT_CAL_EXPOSURE_TIME].title = SANE_UMAX_TITLE_SELECT_CALIBRATION_EXPOSURE_TIME;
+  scanner->opt[OPT_SELECT_CAL_EXPOSURE_TIME].desc  = SANE_UMAX_DESC_SELECT_CALIBRATION_EXPOSURE_TIME;
+  scanner->opt[OPT_SELECT_CAL_EXPOSURE_TIME].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_SELECT_CAL_EXPOSURE_TIME].w     = SANE_FALSE;
+  scanner->opt[OPT_SELECT_CAL_EXPOSURE_TIME].cap  |= SANE_CAP_INACTIVE;
+
+  /* calibration exposure time */
+  scanner->opt[OPT_CAL_EXPOS_TIME].name  = SANE_NAME_CAL_EXPOS_TIME;
+  scanner->opt[OPT_CAL_EXPOS_TIME].title = SANE_TITLE_CAL_EXPOS_TIME;
+  scanner->opt[OPT_CAL_EXPOS_TIME].desc  = SANE_DESC_CAL_EXPOS_TIME;
+  scanner->opt[OPT_CAL_EXPOS_TIME].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_CAL_EXPOS_TIME].unit  = SANE_UNIT_MICROSECOND;
+  scanner->opt[OPT_CAL_EXPOS_TIME].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_CAL_EXPOS_TIME].constraint.range = &(scanner->exposure_time_range);
+  scanner->val[OPT_CAL_EXPOS_TIME].w     = scanner->device->inquiry_exposure_time_g_fb_def *
+                                           scanner->device->inquiry_exposure_time_step_unit;
+  scanner->opt[OPT_CAL_EXPOS_TIME].cap  |= SANE_CAP_INACTIVE;
+
+  /* calibration exposure time red */
+  scanner->opt[OPT_CAL_EXPOS_TIME_R].name  = SANE_NAME_CAL_EXPOS_TIME_R;
+  scanner->opt[OPT_CAL_EXPOS_TIME_R].title = SANE_TITLE_CAL_EXPOS_TIME_R;
+  scanner->opt[OPT_CAL_EXPOS_TIME_R].desc  = SANE_DESC_CAL_EXPOS_TIME_R;
+  scanner->opt[OPT_CAL_EXPOS_TIME_R].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_CAL_EXPOS_TIME_R].unit  = SANE_UNIT_MICROSECOND;
+  scanner->opt[OPT_CAL_EXPOS_TIME_R].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_CAL_EXPOS_TIME_R].constraint.range = &(scanner->exposure_time_range);
+  scanner->val[OPT_CAL_EXPOS_TIME_R].w     = scanner->device->inquiry_exposure_time_c_fb_def_r *
+                                             scanner->device->inquiry_exposure_time_step_unit;
+  scanner->opt[OPT_CAL_EXPOS_TIME_R].cap  |= SANE_CAP_INACTIVE;
+
+  /* calibration exposure time green */
+  scanner->opt[OPT_CAL_EXPOS_TIME_G].name  = SANE_NAME_CAL_EXPOS_TIME_G;
+  scanner->opt[OPT_CAL_EXPOS_TIME_G].title = SANE_TITLE_CAL_EXPOS_TIME_G;
+  scanner->opt[OPT_CAL_EXPOS_TIME_G].desc  = SANE_DESC_CAL_EXPOS_TIME_G;
+  scanner->opt[OPT_CAL_EXPOS_TIME_G].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_CAL_EXPOS_TIME_G].unit  = SANE_UNIT_MICROSECOND;
+  scanner->opt[OPT_CAL_EXPOS_TIME_G].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_CAL_EXPOS_TIME_G].constraint.range = &(scanner->exposure_time_range);
+  scanner->val[OPT_CAL_EXPOS_TIME_G].w     = scanner->device->inquiry_exposure_time_c_fb_def_g *
+                                             scanner->device->inquiry_exposure_time_step_unit;
+  scanner->opt[OPT_CAL_EXPOS_TIME_G].cap  |= SANE_CAP_INACTIVE;
+
+  /* calibration exposure time blue */
+  scanner->opt[OPT_CAL_EXPOS_TIME_B].name  = SANE_NAME_CAL_EXPOS_TIME_B;
+  scanner->opt[OPT_CAL_EXPOS_TIME_B].title = SANE_TITLE_CAL_EXPOS_TIME_B;
+  scanner->opt[OPT_CAL_EXPOS_TIME_B].desc  = SANE_DESC_CAL_EXPOS_TIME_B;
+  scanner->opt[OPT_CAL_EXPOS_TIME_B].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_CAL_EXPOS_TIME_B].unit  = SANE_UNIT_MICROSECOND;
+  scanner->opt[OPT_CAL_EXPOS_TIME_B].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_CAL_EXPOS_TIME_B].constraint.range = &(scanner->exposure_time_range);
+  scanner->val[OPT_CAL_EXPOS_TIME_B].w     = scanner->device->inquiry_exposure_time_c_fb_def_b *
+                                             scanner->device->inquiry_exposure_time_step_unit;
+  scanner->opt[OPT_CAL_EXPOS_TIME_B].cap  |= SANE_CAP_INACTIVE;
+
+  /* scan exposure time */
+  scanner->opt[OPT_SCAN_EXPOS_TIME].name  = SANE_NAME_SCAN_EXPOS_TIME;
+  scanner->opt[OPT_SCAN_EXPOS_TIME].title = SANE_TITLE_SCAN_EXPOS_TIME;
+  scanner->opt[OPT_SCAN_EXPOS_TIME].desc  = SANE_DESC_SCAN_EXPOS_TIME;
+  scanner->opt[OPT_SCAN_EXPOS_TIME].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_SCAN_EXPOS_TIME].unit  = SANE_UNIT_MICROSECOND;
+  scanner->opt[OPT_SCAN_EXPOS_TIME].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_SCAN_EXPOS_TIME].constraint.range = &(scanner->exposure_time_range);
+  scanner->val[OPT_SCAN_EXPOS_TIME].w     = scanner->device->inquiry_exposure_time_g_fb_def *
+                                            scanner->device->inquiry_exposure_time_step_unit;
+  scanner->opt[OPT_SCAN_EXPOS_TIME].cap  |= SANE_CAP_INACTIVE;
+
+  /* scan exposure time red */
+  scanner->opt[OPT_SCAN_EXPOS_TIME_R].name  = SANE_NAME_SCAN_EXPOS_TIME_R;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_R].title = SANE_TITLE_SCAN_EXPOS_TIME_R;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_R].desc  = SANE_DESC_SCAN_EXPOS_TIME_R;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_R].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_R].unit  = SANE_UNIT_MICROSECOND;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_R].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_R].constraint.range = &(scanner->exposure_time_range);
+  scanner->val[OPT_SCAN_EXPOS_TIME_R].w     = scanner->device->inquiry_exposure_time_c_fb_def_r *
+                                              scanner->device->inquiry_exposure_time_step_unit;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_R].cap  |= SANE_CAP_INACTIVE;
+
+  /* scan exposure time green */
+  scanner->opt[OPT_SCAN_EXPOS_TIME_G].name  = SANE_NAME_SCAN_EXPOS_TIME_G;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_G].title = SANE_TITLE_SCAN_EXPOS_TIME_G;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_G].desc  = SANE_DESC_SCAN_EXPOS_TIME_G;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_G].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_G].unit  = SANE_UNIT_MICROSECOND;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_G].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_G].constraint.range = &(scanner->exposure_time_range);
+  scanner->val[OPT_SCAN_EXPOS_TIME_G].w     = scanner->device->inquiry_exposure_time_c_fb_def_g *
+                                              scanner->device->inquiry_exposure_time_step_unit;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_G].cap  |= SANE_CAP_INACTIVE;
+
+  /* scan exposure time blue */
+  scanner->opt[OPT_SCAN_EXPOS_TIME_B].name  = SANE_NAME_SCAN_EXPOS_TIME_B;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_B].title = SANE_TITLE_SCAN_EXPOS_TIME_B;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_B].desc  = SANE_DESC_SCAN_EXPOS_TIME_B;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_B].type  = SANE_TYPE_INT;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_B].unit  = SANE_UNIT_MICROSECOND;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_B].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_B].constraint.range = &(scanner->exposure_time_range);
+  scanner->val[OPT_SCAN_EXPOS_TIME_B].w     = scanner->device->inquiry_exposure_time_c_fb_def_b *
+                                              scanner->device->inquiry_exposure_time_step_unit;
+  scanner->opt[OPT_SCAN_EXPOS_TIME_B].cap  |= SANE_CAP_INACTIVE;
+
+  if (scanner->device->inquiry_exposure_adj == 0)
+  {
+    scanner->opt[OPT_SELECT_EXPOSURE_TIME].cap   |= SANE_CAP_INACTIVE;
+  }
+
+
+  /* ------------------------------ */
+
+
+  /* select calibration lamp density */
+  scanner->opt[OPT_SELECT_LAMP_DENSITY].name  = SANE_NAME_SELECT_LAMP_DENSITY;
+  scanner->opt[OPT_SELECT_LAMP_DENSITY].title = SANE_TITLE_SELECT_LAMP_DENSITY;
+  scanner->opt[OPT_SELECT_LAMP_DENSITY].desc  = SANE_DESC_SELECT_LAMP_DENSITY;
+  scanner->opt[OPT_SELECT_LAMP_DENSITY].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_SELECT_LAMP_DENSITY].w     = SANE_FALSE;
+
+  /* calibration lamp density */
+  scanner->opt[OPT_CAL_LAMP_DEN].name  = SANE_NAME_CAL_LAMP_DEN;
+  scanner->opt[OPT_CAL_LAMP_DEN].title = SANE_TITLE_CAL_LAMP_DEN;
+  scanner->opt[OPT_CAL_LAMP_DEN].desc  = SANE_DESC_CAL_LAMP_DEN;
+  scanner->opt[OPT_CAL_LAMP_DEN].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_CAL_LAMP_DEN].unit  = SANE_UNIT_PERCENT;
+  scanner->opt[OPT_CAL_LAMP_DEN].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_CAL_LAMP_DEN].constraint.range = &percentage_range_100;
+  scanner->val[OPT_CAL_LAMP_DEN].w     = SANE_FIX(50);
+  scanner->opt[OPT_CAL_LAMP_DEN].cap  |= SANE_CAP_INACTIVE;
+
+  /* scan lamp density */
+  scanner->opt[OPT_SCAN_LAMP_DEN].name  = SANE_NAME_SCAN_LAMP_DEN;
+  scanner->opt[OPT_SCAN_LAMP_DEN].title = SANE_TITLE_SCAN_LAMP_DEN;
+  scanner->opt[OPT_SCAN_LAMP_DEN].desc  = SANE_DESC_SCAN_LAMP_DEN;
+  scanner->opt[OPT_SCAN_LAMP_DEN].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_SCAN_LAMP_DEN].unit  = SANE_UNIT_PERCENT;
+  scanner->opt[OPT_SCAN_LAMP_DEN].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_SCAN_LAMP_DEN].constraint.range = &percentage_range_100;
+  scanner->val[OPT_SCAN_LAMP_DEN].w     = SANE_FIX(50);
+  scanner->opt[OPT_SCAN_LAMP_DEN].cap  |= SANE_CAP_INACTIVE;
+
+  if (scanner->device->inquiry_lamp_ctrl == 0)
+  {
+    scanner->opt[OPT_SELECT_LAMP_DENSITY].cap  |= SANE_CAP_INACTIVE;
+  }
+
+  /* ------------------------------ */
+
+  /* disable pre focus */
+  scanner->opt[OPT_DISABLE_PRE_FOCUS].name  = "disable-pre-focus";
+  scanner->opt[OPT_DISABLE_PRE_FOCUS].title = SANE_I18N("Disable pre focus");
+  scanner->opt[OPT_DISABLE_PRE_FOCUS].desc  = SANE_I18N("Do not calibrate focus");
+  scanner->opt[OPT_DISABLE_PRE_FOCUS].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_DISABLE_PRE_FOCUS].w     = SANE_FALSE;
+
+  if (scanner->device->inquiry_manual_focus == 0)
+  {
+    scanner->opt[OPT_DISABLE_PRE_FOCUS].cap  |= SANE_CAP_INACTIVE;
+  }
+
+  /* manual pre focus */
+  scanner->opt[OPT_MANUAL_PRE_FOCUS].name  = "manual-pre-focus";
+  scanner->opt[OPT_MANUAL_PRE_FOCUS].title = SANE_I18N("Manual pre focus");
+  scanner->opt[OPT_MANUAL_PRE_FOCUS].desc  = "";
+  scanner->opt[OPT_MANUAL_PRE_FOCUS].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_MANUAL_PRE_FOCUS].w     = SANE_FALSE;
+
+  if (scanner->device->inquiry_manual_focus == 0)
+  {
+    scanner->opt[OPT_MANUAL_PRE_FOCUS].cap  |= SANE_CAP_INACTIVE;
+  }
+
+  /* fix focus position */
+  scanner->opt[OPT_FIX_FOCUS_POSITION].name  = "fix-focus-position";
+  scanner->opt[OPT_FIX_FOCUS_POSITION].title = SANE_I18N("Fix focus position");
+  scanner->opt[OPT_FIX_FOCUS_POSITION].desc  = "";
+  scanner->opt[OPT_FIX_FOCUS_POSITION].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_FIX_FOCUS_POSITION].w     = SANE_FALSE;
+
+  if (scanner->device->inquiry_manual_focus == 0)
+  {
+    scanner->opt[OPT_FIX_FOCUS_POSITION].cap  |= SANE_CAP_INACTIVE;
+  }
+
+  /* lens calibration in doc position */
+  scanner->opt[OPT_LENS_CALIBRATION_DOC_POS].name  = "lens-calibration-in-doc-position";
+  scanner->opt[OPT_LENS_CALIBRATION_DOC_POS].title = SANE_I18N("Lens calibration in doc position");
+  scanner->opt[OPT_LENS_CALIBRATION_DOC_POS].desc  = SANE_I18N("Calibrate lens focus in document position");
+  scanner->opt[OPT_LENS_CALIBRATION_DOC_POS].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_LENS_CALIBRATION_DOC_POS].w     = SANE_FALSE;
+
+  if (scanner->device->inquiry_lens_cal_in_doc_pos == 0)
+  {
+    scanner->opt[OPT_LENS_CALIBRATION_DOC_POS].cap  |= SANE_CAP_INACTIVE;
+  }
+
+  /* 0mm holder focus position */
+  scanner->opt[OPT_HOLDER_FOCUS_POS_0MM].name  = "holder-focus-position-0mm";
+  scanner->opt[OPT_HOLDER_FOCUS_POS_0MM].title = SANE_I18N("Holder focus position 0mm");
+  scanner->opt[OPT_HOLDER_FOCUS_POS_0MM].desc  = SANE_I18N("Use 0mm holder focus position instead of 0.6mm");
+  scanner->opt[OPT_HOLDER_FOCUS_POS_0MM].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_HOLDER_FOCUS_POS_0MM].w     = SANE_FALSE;
+
+  if (scanner->device->inquiry_sel_uta_lens_cal_pos == 0)
+  {
+    scanner->opt[OPT_HOLDER_FOCUS_POS_0MM].cap  |= SANE_CAP_INACTIVE;
+  }
+
+  /* ------------------------------ */
+
+  /* lamp on */
+  scanner->opt[OPT_LAMP_ON].name  = "lamp-on";
+  scanner->opt[OPT_LAMP_ON].title = SANE_I18N("Lamp on");
+  scanner->opt[OPT_LAMP_ON].desc  = SANE_I18N("Turn on scanner lamp");
+  scanner->opt[OPT_LAMP_ON].type  = SANE_TYPE_BUTTON;
+  scanner->opt[OPT_LAMP_ON].unit  = SANE_UNIT_NONE;
+  scanner->opt[OPT_LAMP_ON].size  = 0;
+  scanner->opt[OPT_LAMP_ON].constraint_type  = SANE_CONSTRAINT_NONE;
+  scanner->val[OPT_LAMP_ON].w     = 0;
+
+  if (!scanner->device->lamp_control_available)		/* lamp state can not be controlled by driver */
+  {
+    scanner->opt[OPT_LAMP_ON].cap  |= SANE_CAP_INACTIVE;
+  }
+
+  /* ------------------------------ */
+
+  /* lamp off */
+  scanner->opt[OPT_LAMP_OFF].name  = "lamp-off";
+  scanner->opt[OPT_LAMP_OFF].title = SANE_I18N("Lamp off");
+  scanner->opt[OPT_LAMP_OFF].desc  = SANE_I18N("Turn off scanner lamp");
+  scanner->opt[OPT_LAMP_OFF].type  = SANE_TYPE_BUTTON;
+  scanner->opt[OPT_LAMP_OFF].unit  = SANE_UNIT_NONE;
+  scanner->opt[OPT_LAMP_OFF].size  = 0;
+  scanner->opt[OPT_LAMP_OFF].constraint_type  = SANE_CONSTRAINT_NONE;
+  scanner->val[OPT_LAMP_OFF].w     = 0;
+
+  if (!scanner->device->lamp_control_available)		/* lamp state can not be controlled by driver */
+  {
+    scanner->opt[OPT_LAMP_OFF].cap  |= SANE_CAP_INACTIVE;
+  }
+
+  /* ------------------------------ */
+
+  /* lamp off at exit */
+  scanner->opt[OPT_LAMP_OFF_AT_EXIT].name  = "lamp-off-at-exit";
+  scanner->opt[OPT_LAMP_OFF_AT_EXIT].title = SANE_I18N("Lamp off at exit");
+  scanner->opt[OPT_LAMP_OFF_AT_EXIT].desc  = SANE_I18N("Turn off lamp when program exits");
+  scanner->opt[OPT_LAMP_OFF_AT_EXIT].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_LAMP_OFF_AT_EXIT].w     = SANE_FALSE;
+
+  if (!scanner->device->lamp_control_available)		/* lamp state can not be controlled by driver */
+  {
+    scanner->opt[OPT_LAMP_OFF_AT_EXIT].cap  |= SANE_CAP_INACTIVE;
+  }
+
+  /* ------------------------------ */
+
+  /* batch-scan-start */
+  scanner->opt[OPT_BATCH_SCAN_START].name  = SANE_NAME_BATCH_SCAN_START;
+  scanner->opt[OPT_BATCH_SCAN_START].title = SANE_TITLE_BATCH_SCAN_START;
+  scanner->opt[OPT_BATCH_SCAN_START].desc  = SANE_DESC_BATCH_SCAN_START;
+  scanner->opt[OPT_BATCH_SCAN_START].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_BATCH_SCAN_START].w     = SANE_FALSE;
+
+  /* batch-scan-loop */
+  scanner->opt[OPT_BATCH_SCAN_LOOP].name  = SANE_NAME_BATCH_SCAN_LOOP;
+  scanner->opt[OPT_BATCH_SCAN_LOOP].title = SANE_TITLE_BATCH_SCAN_LOOP;
+  scanner->opt[OPT_BATCH_SCAN_LOOP].desc  = SANE_DESC_BATCH_SCAN_LOOP;
+  scanner->opt[OPT_BATCH_SCAN_LOOP].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_BATCH_SCAN_LOOP].w     = SANE_FALSE;
+
+  /* batch-scan-end */
+  scanner->opt[OPT_BATCH_SCAN_END].name  = SANE_NAME_BATCH_SCAN_END;
+  scanner->opt[OPT_BATCH_SCAN_END].title = SANE_TITLE_BATCH_SCAN_END;
+  scanner->opt[OPT_BATCH_SCAN_END].desc  = SANE_DESC_BATCH_SCAN_END;
+  scanner->opt[OPT_BATCH_SCAN_END].type  = SANE_TYPE_BOOL;
+  scanner->val[OPT_BATCH_SCAN_END].w     = SANE_FALSE;
+
+  /* batch-scan-next-y */
+  scanner->opt[OPT_BATCH_NEXT_TL_Y].name  = SANE_NAME_BATCH_NEXT_TL_Y;
+  scanner->opt[OPT_BATCH_NEXT_TL_Y].title = SANE_TITLE_BATCH_NEXT_TL_Y;
+  scanner->opt[OPT_BATCH_NEXT_TL_Y].desc  = SANE_DESC_BATCH_NEXT_TL_Y;
+  scanner->opt[OPT_BATCH_NEXT_TL_Y].type  = SANE_TYPE_FIXED;
+  scanner->opt[OPT_BATCH_NEXT_TL_Y].unit  = SANE_UNIT_MM;
+  scanner->opt[OPT_BATCH_NEXT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  scanner->opt[OPT_BATCH_NEXT_TL_Y].constraint.range = &(scanner->device->y_range);
+  scanner->val[OPT_BATCH_NEXT_TL_Y].w     = 0xFFFF; /* mark value as not touched */
+
+  if (scanner->device->inquiry_batch_scan == 0)
+  {
+    scanner->opt[OPT_BATCH_SCAN_START].cap  |= SANE_CAP_INACTIVE;
+    scanner->opt[OPT_BATCH_SCAN_LOOP].cap   |= SANE_CAP_INACTIVE;
+    scanner->opt[OPT_BATCH_SCAN_END].cap    |= SANE_CAP_INACTIVE;
+    scanner->opt[OPT_BATCH_NEXT_TL_Y].cap      |= SANE_CAP_INACTIVE;
+  }
+
+  /* ------------------------------ */
+
+#ifdef UMAX_CALIBRATION_MODE_SELECTABLE
+  /* calibration mode */
+  scanner->opt[OPT_CALIB_MODE].name  = "calibrationmode";
+  scanner->opt[OPT_CALIB_MODE].title = SANE_I18N("Calibration mode");
+  scanner->opt[OPT_CALIB_MODE].desc  = SANE_I18N("Define calibration mode");
+  scanner->opt[OPT_CALIB_MODE].type  = SANE_TYPE_STRING;
+  scanner->opt[OPT_CALIB_MODE].size  = max_string_size(calibration_list);
+  scanner->opt[OPT_CALIB_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  scanner->opt[OPT_CALIB_MODE].constraint.string_list = calibration_list;
+  scanner->val[OPT_CALIB_MODE].s     = (SANE_Char*)strdup(calibration_list[0]);
+
+  if (scanner->device->inquiry_calibration == 0)
+  {
+    scanner->opt[OPT_CALIB_MODE].cap  |= SANE_CAP_INACTIVE;
+  }
+#endif
+
+  /* preview */
+  scanner->opt[OPT_PREVIEW].name  = SANE_NAME_PREVIEW;
+  scanner->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
+  scanner->opt[OPT_PREVIEW].desc  = SANE_DESC_PREVIEW;
+  scanner->opt[OPT_PREVIEW].type  = SANE_TYPE_BOOL;
+  scanner->opt[OPT_PREVIEW].cap   = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
+  scanner->val[OPT_PREVIEW].w     = SANE_FALSE;
+
+  sane_control_option(scanner, OPT_MODE, SANE_ACTION_SET_VALUE,
+                      (SANE_String *) scan_mode_list[scan_modes], NULL );
+  
+ return SANE_STATUS_GOOD;
+}
+
+
+/* ------------------------------------------------------------ ATTACH ONE SCSI ----------------------------- */
+
+/* callback function for sanei_config_attach_matching_devices(dev_name, attach_one_scsi) */
+static SANE_Status attach_one_scsi(const char *name)
+{
+  attach_scanner(name, 0, SANE_UMAX_SCSI);
+ return SANE_STATUS_GOOD;
+}
+
+/* ------------------------------------------------------------ ATTACH ONE USB ------------------------------ */
+
+/* callback function for sanei_usb_attach_matching_devices(dev_name, attach_one_usb) */
+static SANE_Status attach_one_usb(const char *name)
+{
+  attach_scanner(name, 0, SANE_UMAX_USB);
+ return SANE_STATUS_GOOD;
+}
+
+/* ------------------------------------------------------------ UMAX TEST CONFIGURE OPTION ------------------ */
+
+static SANE_Status umax_test_configure_option(const char *option_str, char *test_name, int *test_value, int test_min, int test_max)
+/* returns with 1 if option was found, 0 if option was not found */
+{
+ const char *value_str;
+ char *end_ptr;
+ int value;
+
+  if (strncmp(option_str, test_name, strlen(test_name)) == 0)
+  {
+    value_str = sanei_config_skip_whitespace(option_str+strlen(test_name));
+
+    errno = 0;
+    value = strtol(value_str, &end_ptr, 10);
+    if (end_ptr == value_str || errno) 
+    {
+      DBG(DBG_error, "ERROR: invalid value \"%s\" for option %s in %s\n", value_str, test_name, UMAX_CONFIG_FILE);
+    }
+    else
+    {
+      if (value < test_min)
+      {
+        DBG(DBG_error, "ERROR: value \"%d\" is too small for option %s in %s\n", value, test_name, UMAX_CONFIG_FILE);
+        value = test_min;
+      }
+      else if (value > test_max)
+      {
+        DBG(DBG_error, "ERROR: value \"%d\" is too large for option %s in %s\n", value, test_name, UMAX_CONFIG_FILE);
+        value = test_max;
+      }
+
+      *test_value = value;
+
+      DBG(DBG_info, "option %s = %d\n", test_name, *test_value);
+    }
+    return 1;
+  }
+ return 0;
+}
+
+/* ------------------------------------------------------------ SANE INIT ---------------------------------- */
+
+
+SANE_Status sane_init(SANE_Int *version_code, SANE_Auth_Callback authorize)
+{
+ char config_line[PATH_MAX];
+ const char *option_str;
+ size_t len;
+ FILE *fp;
+
+  /* we have to initialize these global variables here because sane_init can be called several times */
+  num_devices  = 0;
+  devlist      = NULL;
+  first_dev    = NULL;
+  first_handle = NULL;
+
+  DBG_INIT();
+
+  DBG(DBG_sane_init,"sane_init\n");
+  DBG(DBG_error,"This is sane-umax version %d.%d build %d\n", SANE_CURRENT_MAJOR, V_MINOR, BUILD);
+#ifdef UMAX_ENABLE_USB
+  DBG(DBG_error,"compiled with USB support for Astra 2200\n");
+#else
+  DBG(DBG_error,"no USB support for Astra 2200\n");
+#endif
+  DBG(DBG_error,"(C) 1997-2002 by Oliver Rauch\n");
+  DBG(DBG_error,"EMAIL: Oliver.Rauch@rauch-domain.de\n");
+
+  if (version_code)
+  {
+    *version_code = SANE_VERSION_CODE(SANE_CURRENT_MAJOR, V_MINOR, BUILD);
+  }
+
+  frontend_authorize_callback = authorize; /* store frontend authorize callback */
+
+  sanei_thread_init(); /* must be called before any other sanei_thread call */
+
+#ifdef UMAX_ENABLE_USB
+  sanei_usb_init();
+  sanei_pv8630_init();
+#endif
+
+  fp = sanei_config_open(UMAX_CONFIG_FILE);
+  if (!fp) 
+  {
+    /* no config-file: try /dev/scanner and /dev/usbscanner. */
+    attach_scanner("/dev/scanner",    0, SANE_UMAX_SCSI);
+#ifdef UMAX_ENABLE_USB
+    attach_scanner("/dev/usbscanner", 0, SANE_UMAX_USB);
+#endif
+   return SANE_STATUS_GOOD;
+  }
+
+  DBG(DBG_info, "reading configure file %s\n", UMAX_CONFIG_FILE);
+
+  while(sanei_config_read(config_line, sizeof(config_line), fp))
+  {
+    if (config_line[0] == '#')
+    {
+      continue; /* ignore line comments */
+    }
+
+    if (strncmp(config_line, "option", 6) == 0)
+    {
+      option_str = sanei_config_skip_whitespace(config_line+6);
+
+      if      (umax_test_configure_option(option_str, "scsi-maxqueue",                  &umax_scsi_maxqueue, 1, SANE_UMAX_SCSI_MAXQUEUE));
+      else if (umax_test_configure_option(option_str, "scsi-buffer-size-min",           &umax_scsi_buffer_size_min,   4096, 1048576));
+      else if (umax_test_configure_option(option_str, "scsi-buffer-size-max",           &umax_scsi_buffer_size_max,   4096, 1048576));
+      else if (umax_test_configure_option(option_str, "preview-lines",                  &umax_preview_lines,             1,   65535));
+      else if (umax_test_configure_option(option_str, "scan-lines",                     &umax_scan_lines,                1,   65535));
+      else if (umax_test_configure_option(option_str, "handle-bad-sense-error",         &umax_handle_bad_sense_error,    0,   3));
+      else if (umax_test_configure_option(option_str, "execute-request-sense",          &umax_execute_request_sense,     0,   1));
+      else if (umax_test_configure_option(option_str, "force-preview-bit-rgb",          &umax_force_preview_bit_rgb,     0,   1));
+      else if (umax_test_configure_option(option_str, "slow-speed",                     &umax_slow,                     -1,   1));
+      else if (umax_test_configure_option(option_str, "care-about-smearing",            &umax_smear,                    -1,   1));
+      else if (umax_test_configure_option(option_str, "calibration-full-ccd",           &umax_calibration_area,         -1,   1));
+      else if (umax_test_configure_option(option_str, "calibration-width-offset-batch", &umax_calibration_width_offset_batch, -99999, 65535));
+      else if (umax_test_configure_option(option_str, "calibration-width-offset",       &umax_calibration_width_offset, -99999, 65535));
+      else if (umax_test_configure_option(option_str, "calibration-bytes-pixel",        &umax_calibration_bytespp,      -1,   2));
+      else if (umax_test_configure_option(option_str, "exposure-time-rgb-bind",         &umax_exposure_time_rgb_bind,   -1,   1));
+      else if (umax_test_configure_option(option_str, "invert-shading-data",            &umax_invert_shading_data,      -1,   1));
+      else if (umax_test_configure_option(option_str, "lamp-control-available",         &umax_lamp_control_available,    0,   1));
+      else if (umax_test_configure_option(option_str, "gamma-lsb-padded",               &umax_gamma_lsb_padded,         -1,   1));
+      else if (umax_test_configure_option(option_str, "connection-type",                &umax_connection_type,           1,   2));
+      else
+      {
+        DBG(DBG_error,"ERROR: unknown option \"%s\" in %s\n", option_str, UMAX_CONFIG_FILE);
+      }
+      continue;
+    }
+    else if (strncmp(config_line, "scsi", 4) == 0)
+    {
+      DBG(DBG_info,"sanei_config_attach_matching_devices(%s)\n", config_line);
+      sanei_config_attach_matching_devices(config_line, attach_one_scsi);
+      continue;
+    }
+    else if (strncmp(config_line, "usb", 3) == 0)
+    {
+#ifdef UMAX_ENABLE_USB
+      DBG(DBG_info,"sanei_usb_attach_matching_devices(%s)\n", config_line);
+      sanei_usb_attach_matching_devices(config_line, attach_one_usb);
+#else
+      DBG(DBG_info,"USB not supported, ignoring config line: %s\n", config_line);
+#endif
+      continue;
+    }
+
+    len = strlen(config_line);
+
+    if (!len) /* ignore empty lines */
+    {
+      continue;
+    }
+
+    /* umax_connection_type is set by umax.conf: 1=scsi, 2=usb */
+    attach_scanner(config_line, 0, umax_connection_type); /* try to open as devicename */
+  }
+
+  DBG(DBG_info, "finished reading configure file\n");
+
+  fclose(fp);
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/* ------------------------------------------------------------ SANE EXIT ---------------------------------- */
+
+
+void sane_exit(void)
+{
+ Umax_Device *dev, *next;
+
+  DBG(DBG_sane_init,"sane_exit\n");
+
+  for (dev = first_dev; dev; dev = next)
+  {
+    next = dev->next;
+    free(dev->devicename);
+    free(dev);
+  }
+
+  if (devlist)
+  {
+    free(devlist);
+  }
+}
+
+
+/* ------------------------------------------------------------ SANE GET DEVICES --------------------------- */
+
+
+SANE_Status sane_get_devices(const SANE_Device ***device_list, SANE_Bool local_only)
+{
+ Umax_Device *dev;
+ int i;
+
+  DBG(DBG_sane_init,"sane_get_devices(local_only = %d)\n", local_only);
+
+  if (devlist)
+  {
+    free(devlist);
+  }
+
+  devlist = malloc((num_devices + 1) * sizeof (devlist[0]));
+  if (!devlist)
+  {
+    return SANE_STATUS_NO_MEM;
+  }
+
+  i = 0;
+
+  for (dev = first_dev; i < num_devices; dev = dev->next)
+  {
+    devlist[i++] = &dev->sane;
+  }
+
+  devlist[i++] = 0;
+
+  *device_list = devlist;
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/* ------------------------------------------------------------ SANE OPEN ---------------------------------- */
+
+
+SANE_Status sane_open(SANE_String_Const devicename, SANE_Handle *handle)
+{
+ Umax_Device *dev;
+ SANE_Status status;
+ Umax_Scanner *scanner;
+ unsigned int i, j;
+
+  DBG(DBG_sane_init,"sane_open\n");
+
+  if (devicename[0])   /* search for devicename */
+  {
+    DBG(DBG_sane_info,"sane_open: devicename=%s\n", devicename);
+
+    for (dev = first_dev; dev; dev = dev->next)
+    {
+      if (strcmp(dev->sane.name, devicename) == 0)
+      {
+        break; /* device found, exit for loop */
+      }
+    }
+
+    if (!dev) /* no device found */
+    {
+      status = attach_scanner(devicename, &dev, 0 /* connection-type not known */); /* try to open devicename and set dev */
+      if (status != SANE_STATUS_GOOD)
+      {
+        return status;
+      }
+    }
+  }
+  else
+  {
+    DBG(DBG_sane_info,"sane_open: no devicename, opening first device\n");
+    dev = first_dev; 							/* empty devicename -> use first device */
+  }
+
+  if (!dev) /* no device found */
+  {
+    return SANE_STATUS_INVAL;
+  }
+
+  scanner = malloc(sizeof (*scanner));
+  if (!scanner)
+  {
+    return SANE_STATUS_NO_MEM;
+  }
+
+  memset(scanner, 0, sizeof (*scanner));
+
+  scanner->device = dev;
+
+  if (scanner->device->inquiry_GIB & 32)
+  {
+    scanner->gamma_length = 65536;							    /* 16 bits input */
+    DBG(DBG_sane_info, "Using 16 bits for gamma input\n");
+  }
+  else if (scanner->device->inquiry_GIB & 16)
+  {
+    scanner->gamma_length = 16384;							    /* 14 bits input */
+    DBG(DBG_sane_info, "Using 14 bits for gamma input\n");
+  }
+  else if (scanner->device->inquiry_GIB & 8)
+  {
+    scanner->gamma_length = 4096;							    /* 12 bits input */
+    DBG(DBG_sane_info, "Using 12 bits for gamma input\n");
+  }
+  else if (scanner->device->inquiry_GIB & 4)
+  {
+    scanner->gamma_length = 1024;							    /* 10 bits input */
+    DBG(DBG_sane_info, "Using 10 bits for gamma input\n");
+  }
+  else if (scanner->device->inquiry_GIB & 2)
+  {
+    scanner->gamma_length = 512;							     /* 9 bits input */
+    DBG(DBG_sane_info, "Using 9 bits for gamma input\n");
+  }
+  else
+  {
+    scanner->gamma_length = 256;							     /* 8 bits input */
+    DBG(DBG_sane_info, "Using 8 bits for gamma input\n");
+  }
+
+  scanner->output_bytes = 1;								    /* 8 bits output */
+
+  scanner->gamma_range.min   = 0;
+  scanner->gamma_range.max   = scanner->gamma_length-1;
+  scanner->gamma_range.quant = 0;
+
+  scanner->gamma_table[0] = (SANE_Int *) malloc(scanner->gamma_length * sizeof(SANE_Int));
+  scanner->gamma_table[1] = (SANE_Int *) malloc(scanner->gamma_length * sizeof(SANE_Int));
+  scanner->gamma_table[2] = (SANE_Int *) malloc(scanner->gamma_length * sizeof(SANE_Int));
+  scanner->gamma_table[3] = (SANE_Int *) malloc(scanner->gamma_length * sizeof(SANE_Int));
+
+  for (j = 0; j < scanner->gamma_length; ++j)			     /* gamma_table[0] : converts GIB to GOB */
+  {
+    scanner->gamma_table[0][j] = j * scanner->device->max_value / scanner->gamma_length;
+  }
+
+  for (i = 1; i < 4; ++i)			 /* gamma_table[1,2,3] : doesn't convert anything (GIB->GIB) */
+  {
+    for (j = 0; j < scanner->gamma_length; ++j)
+    {
+      scanner->gamma_table[i][j] = j;
+    }
+  }
+
+  scanner->exposure_time_range.min   = scanner->device->inquiry_exposure_time_c_min *
+                                       scanner->device->inquiry_exposure_time_step_unit;
+  scanner->exposure_time_range.quant = scanner->device->inquiry_exposure_time_step_unit;
+  scanner->exposure_time_range.max   = scanner->device->inquiry_exposure_time_max *
+                                       scanner->device->inquiry_exposure_time_step_unit;
+
+  init_options(scanner);
+
+  scanner->next = first_handle;			    /* insert newly opened handle into list of open handles: */
+  first_handle = scanner;
+
+  *handle = scanner;
+ return SANE_STATUS_GOOD;
+}
+
+
+/* ------------------------------------------------------------ SANE CLOSE --------------------------------- */
+
+
+void sane_close(SANE_Handle handle)
+{
+ Umax_Scanner *prev, *scanner;
+
+  DBG(DBG_sane_init,"sane_close\n");
+
+  if (!first_handle)
+  {
+    DBG(DBG_error, "ERROR: sane_close: no handles opened\n");
+    return;
+  }
+
+								 /* remove handle from list of open handles: */
+  prev = 0;
+
+  for (scanner = first_handle; scanner; scanner = scanner->next)
+  {
+    if (scanner == handle)
+    {
+      break;
+    }
+
+    prev = scanner;
+  }
+  
+  if (!scanner)
+  {
+    DBG(DBG_error, "ERROR: sane_close: invalid handle %p\n", handle);
+    return;								 /* oops, not a handle we know about */
+  }
+
+  if (scanner->scanning)						      /* stop scan if still scanning */
+  {
+    do_cancel(handle);
+  } 
+
+  if (scanner->device->lamp_control_available)			   /* lamp state can be controlled by driver */
+  {
+    if (scanner->val[OPT_LAMP_OFF_AT_EXIT].w)			      /* turn off scanner lamp on sane_close */
+    {
+      umax_set_lamp_status(handle, 0 /* lamp off */);
+    }
+  }
+
+  if (prev)
+  {
+    prev->next = scanner->next;
+  }
+  else
+  {
+    first_handle = scanner->next;
+  }
+
+  free(scanner->gamma_table[0]);						 /* free custom gamma tables */
+  free(scanner->gamma_table[1]);
+  free(scanner->gamma_table[2]);
+  free(scanner->gamma_table[3]);
+
+  free(scanner->device->buffer[0]);			  /* free buffer allocated by umax_initialize_values */
+  scanner->device->buffer[0]  = NULL;
+  scanner->device->bufsize = 0;
+
+  free(scanner);									     /* free scanner */
+}
+
+
+/* ------------------------------------------------------------ SANE GET OPTION DESCRIPTOR ----------------- */
+
+
+const SANE_Option_Descriptor *sane_get_option_descriptor(SANE_Handle handle, SANE_Int option)
+{
+ Umax_Scanner *scanner = handle;
+
+  DBG(DBG_sane_option,"sane_get_option_descriptor %d\n", option);
+
+  if ((unsigned) option >= NUM_OPTIONS)
+  {
+    return 0;
+  }
+
+ return scanner->opt + option;
+}
+
+/* ------------------------------------------------------------ UMAX SET MAX GEOMETRY ---------------------- */
+
+static void umax_set_max_geometry(Umax_Scanner *scanner)
+{
+
+  if (scanner->val[OPT_DOR].w)
+  {
+    scanner->device->x_range.min = SANE_FIX(scanner->device->inquiry_dor_x_off * MM_PER_INCH);
+    scanner->device->x_range.max = SANE_FIX( (scanner->device->inquiry_dor_x_off + scanner->device->inquiry_dor_width)  * MM_PER_INCH);
+    scanner->device->y_range.min = SANE_FIX(scanner->device->inquiry_dor_y_off * MM_PER_INCH);
+    scanner->device->y_range.max = SANE_FIX( (scanner->device->inquiry_dor_y_off + scanner->device->inquiry_dor_length) * MM_PER_INCH);
+
+    scanner->device->x_dpi_range.max = SANE_FIX(scanner->device->inquiry_dor_x_res);
+    scanner->device->y_dpi_range.max = SANE_FIX(scanner->device->inquiry_dor_y_res);      
+  }
+  else if ( (strcmp(scanner->val[OPT_SOURCE].s, FLB_STR) == 0) || (strcmp(scanner->val[OPT_SOURCE].s, ADF_STR) == 0) )
+  {
+    scanner->device->x_range.min = 0;
+    scanner->device->x_range.max = SANE_FIX(scanner->device->inquiry_fb_width  * MM_PER_INCH);
+    scanner->device->y_range.min = 0;
+    scanner->device->y_range.max = SANE_FIX(scanner->device->inquiry_fb_length * MM_PER_INCH);
+
+    scanner->device->x_dpi_range.max = SANE_FIX(scanner->device->inquiry_x_res);
+    scanner->device->y_dpi_range.max = SANE_FIX(scanner->device->inquiry_y_res);      
+  }
+  else if (strcmp(scanner->val[OPT_SOURCE].s, UTA_STR) == 0)
+  {
+    scanner->device->x_range.min = SANE_FIX(scanner->device->inquiry_uta_x_off  * MM_PER_INCH);
+    scanner->device->x_range.max = SANE_FIX( (scanner->device->inquiry_uta_x_off + scanner->device->inquiry_uta_width) * MM_PER_INCH);
+    scanner->device->y_range.min = SANE_FIX(scanner->device->inquiry_uta_y_off  * MM_PER_INCH);
+    scanner->device->y_range.max = SANE_FIX( ( scanner->device->inquiry_uta_y_off + scanner->device->inquiry_uta_length) * MM_PER_INCH);
+
+    scanner->device->x_dpi_range.max = SANE_FIX(scanner->device->inquiry_x_res);
+    scanner->device->y_dpi_range.max = SANE_FIX(scanner->device->inquiry_y_res);      
+  }
+
+  DBG(DBG_info,"x_range     = [%f .. %f]\n", SANE_UNFIX(scanner->device->x_range.min), SANE_UNFIX(scanner->device->x_range.max));
+  DBG(DBG_info,"y_range     = [%f .. %f]\n", SANE_UNFIX(scanner->device->y_range.min), SANE_UNFIX(scanner->device->y_range.max));
+  DBG(DBG_info,"x_dpi_range = [1 .. %f]\n", SANE_UNFIX(scanner->device->x_dpi_range.max));
+  DBG(DBG_info,"y_dpi_range = [1 .. %f]\n", SANE_UNFIX(scanner->device->y_dpi_range.max));
+
+  /* make sure geometry selection is in bounds */
+
+  if ( scanner->val[OPT_TL_X].w < scanner->device->x_range.min)
+  {
+    scanner->val[OPT_TL_X].w = scanner->device->x_range.min;
+  }
+ 
+  if (scanner->val[OPT_TL_Y].w < scanner->device->y_range.min)
+  {
+    scanner->val[OPT_TL_Y].w = scanner->device->y_range.min;
+  }
+
+  if ( scanner->val[OPT_BR_X].w > scanner->device->x_range.max)
+  {
+    scanner->val[OPT_BR_X].w = scanner->device->x_range.max;
+  }
+ 
+  if (scanner->val[OPT_BR_Y].w > scanner->device->y_range.max)
+  {
+    scanner->val[OPT_BR_Y].w = scanner->device->y_range.max;
+  }
+}
+
+/* ------------------------------------------------------------ SANE CONTROL OPTION ------------------------ */
+
+
+SANE_Status sane_control_option(SANE_Handle handle, SANE_Int option, SANE_Action action,
+                                void *val, SANE_Int *info)
+{
+ Umax_Scanner *scanner = handle;
+ SANE_Status status;
+ SANE_Word w, cap;
+ SANE_String_Const name;
+
+  if (info)
+  {
+    *info = 0;
+  }
+
+  if (scanner->scanning)
+  {
+    return SANE_STATUS_DEVICE_BUSY;
+  }
+
+  if ((unsigned) option >= NUM_OPTIONS)
+  {
+    return SANE_STATUS_INVAL;
+  }
+
+  cap = scanner->opt[option].cap;
+  if (!SANE_OPTION_IS_ACTIVE (cap))
+  {
+    return SANE_STATUS_INVAL;
+  }
+
+  name = scanner->opt[option].name;
+  if (!name)
+  {
+    name = "(no name)";
+  }
+
+  if (action == SANE_ACTION_GET_VALUE)
+  {
+    DBG(DBG_sane_option,"get %s [#%d]\n", name, option);
+
+    switch (option)
+    {
+       /* word options: */
+      case OPT_NUM_OPTS:
+      case OPT_RESOLUTION_BIND:
+      case OPT_X_RESOLUTION:
+      case OPT_Y_RESOLUTION:
+      case OPT_TL_X:
+      case OPT_TL_Y:
+      case OPT_BR_X:
+      case OPT_BR_Y:
+      case OPT_PREVIEW:
+      case OPT_BIT_DEPTH:
+      case OPT_NEGATIVE:
+      case OPT_BATCH_SCAN_START:
+      case OPT_BATCH_SCAN_LOOP:
+      case OPT_BATCH_SCAN_END:
+      case OPT_BATCH_NEXT_TL_Y:
+      case OPT_QUALITY:
+      case OPT_DOR:
+      case OPT_WARMUP:
+      case OPT_RGB_BIND:
+      case OPT_ANALOG_GAMMA:
+      case OPT_ANALOG_GAMMA_R:
+      case OPT_ANALOG_GAMMA_G:
+      case OPT_ANALOG_GAMMA_B:
+      case OPT_BRIGHTNESS:
+      case OPT_CONTRAST:
+      case OPT_THRESHOLD:
+      case OPT_HIGHLIGHT:
+      case OPT_HIGHLIGHT_R:
+      case OPT_HIGHLIGHT_G:
+      case OPT_HIGHLIGHT_B:
+      case OPT_SHADOW:
+      case OPT_SHADOW_R:
+      case OPT_SHADOW_G:
+      case OPT_SHADOW_B:
+      case OPT_CUSTOM_GAMMA:
+      case OPT_HALFTONE_DIMENSION:
+      case OPT_SELECT_EXPOSURE_TIME:
+      case OPT_SELECT_CAL_EXPOSURE_TIME:
+      case OPT_CAL_EXPOS_TIME:
+      case OPT_CAL_EXPOS_TIME_R:
+      case OPT_CAL_EXPOS_TIME_G:
+      case OPT_CAL_EXPOS_TIME_B:
+      case OPT_SCAN_EXPOS_TIME:
+      case OPT_SCAN_EXPOS_TIME_R:
+      case OPT_SCAN_EXPOS_TIME_G:
+      case OPT_SCAN_EXPOS_TIME_B:
+      case OPT_CAL_LAMP_DEN:
+      case OPT_SCAN_LAMP_DEN:
+      case OPT_DISABLE_PRE_FOCUS:
+      case OPT_MANUAL_PRE_FOCUS:
+      case OPT_FIX_FOCUS_POSITION:
+      case OPT_LENS_CALIBRATION_DOC_POS:
+      case OPT_HOLDER_FOCUS_POS_0MM: 
+      case OPT_LAMP_OFF_AT_EXIT:
+      case OPT_SELECT_LAMP_DENSITY:
+        *(SANE_Word *) val = scanner->val[option].w;
+       return SANE_STATUS_GOOD;
+
+      /* word-array options: */
+      case OPT_GAMMA_VECTOR:
+      case OPT_GAMMA_VECTOR_R:
+      case OPT_GAMMA_VECTOR_G:
+      case OPT_GAMMA_VECTOR_B:
+      case OPT_HALFTONE_PATTERN:
+        memcpy (val, scanner->val[option].wa, scanner->opt[option].size);
+       return SANE_STATUS_GOOD;
+
+      /* string options: */
+      case OPT_SOURCE:
+      /* fall through */
+      case OPT_MODE:
+      /* fall through */
+#ifdef UMAX_CALIBRATION_MODE_SELECTABLE
+      case OPT_CALIB_MODE:
+      /* fall through */
+#endif
+        strcpy (val, scanner->val[option].s);
+       return SANE_STATUS_GOOD;
+    }
+  }
+  else if (action == SANE_ACTION_SET_VALUE)
+  {
+    switch (scanner->opt[option].type)
+    {
+      case SANE_TYPE_INT:
+        DBG(DBG_sane_option, "set %s [#%d] to %d\n", name, option, *(SANE_Word *) val);
+       break;
+
+      case SANE_TYPE_FIXED:
+        DBG(DBG_sane_option, "set %s [#%d] to %f\n", name, option, SANE_UNFIX(*(SANE_Word *) val));
+       break;
+
+      case SANE_TYPE_STRING:
+        DBG(DBG_sane_option, "set %s [#%d] to %s\n", name, option, (char *) val);
+       break;
+
+      case SANE_TYPE_BOOL:
+        DBG(DBG_sane_option, "set %s [#%d] to %d\n", name, option, *(SANE_Word *) val);
+       break;
+
+      default:
+        DBG(DBG_sane_option, "set %s [#%d]\n", name, option);
+    }
+
+    if (!SANE_OPTION_IS_SETTABLE(cap))
+    {
+      DBG(DBG_error, "could not set option, not settable\n");
+     return SANE_STATUS_INVAL;
+    }
+
+    status = sanei_constrain_value(scanner->opt+option, val, info);
+    if (status != SANE_STATUS_GOOD)
+    {
+      DBG(DBG_error, "could not set option, invalid value\n");
+     return status;
+    }
+
+    switch (option)
+    {
+      /* (mostly) side-effect-free word options: */
+      case OPT_X_RESOLUTION:
+      case OPT_Y_RESOLUTION:
+      case OPT_TL_X:
+      case OPT_TL_Y:
+      case OPT_BR_X:
+      case OPT_BR_Y:
+        if (info)
+        {
+          *info |= SANE_INFO_RELOAD_PARAMS;
+        }
+        /* fall through */
+      case OPT_NUM_OPTS:
+      case OPT_NEGATIVE:
+      case OPT_BATCH_SCAN_START:
+      case OPT_BATCH_SCAN_LOOP:
+      case OPT_BATCH_SCAN_END:
+      case OPT_BATCH_NEXT_TL_Y:
+      case OPT_QUALITY:
+      case OPT_WARMUP:
+      case OPT_PREVIEW:
+      case OPT_ANALOG_GAMMA:
+      case OPT_ANALOG_GAMMA_R:
+      case OPT_ANALOG_GAMMA_G:
+      case OPT_ANALOG_GAMMA_B:
+      case OPT_BRIGHTNESS:
+      case OPT_CONTRAST:
+      case OPT_THRESHOLD:
+      case OPT_HIGHLIGHT:
+      case OPT_HIGHLIGHT_R:
+      case OPT_HIGHLIGHT_G:
+      case OPT_HIGHLIGHT_B:
+      case OPT_SHADOW:
+      case OPT_SHADOW_R:
+      case OPT_SHADOW_G:
+      case OPT_SHADOW_B:
+      case OPT_CAL_EXPOS_TIME:
+      case OPT_CAL_EXPOS_TIME_R:
+      case OPT_CAL_EXPOS_TIME_G:
+      case OPT_CAL_EXPOS_TIME_B:
+      case OPT_SCAN_EXPOS_TIME:
+      case OPT_SCAN_EXPOS_TIME_R:
+      case OPT_SCAN_EXPOS_TIME_G:
+      case OPT_SCAN_EXPOS_TIME_B:
+      case OPT_CAL_LAMP_DEN:
+      case OPT_SCAN_LAMP_DEN:
+      case OPT_DISABLE_PRE_FOCUS:
+      case OPT_MANUAL_PRE_FOCUS:
+      case OPT_FIX_FOCUS_POSITION:
+      case OPT_LENS_CALIBRATION_DOC_POS:
+      case OPT_HOLDER_FOCUS_POS_0MM: 
+      case OPT_LAMP_OFF_AT_EXIT:
+        scanner->val[option].w = *(SANE_Word *) val;
+       return SANE_STATUS_GOOD;
+
+      case OPT_DOR:
+      {
+        if (scanner->val[option].w != *(SANE_Word *) val)
+        {
+          scanner->val[option].w = *(SANE_Word *) val; /* update valure for umax_set_max_geometry */
+
+          if (info)
+          {
+            *info |= SANE_INFO_RELOAD_PARAMS;
+            *info |= SANE_INFO_RELOAD_OPTIONS;
+          }
+
+          DBG(DBG_info,"sane_control_option: set DOR = %d\n", scanner->val[option].w);
+          umax_set_max_geometry(scanner); 
+        }
+       return SANE_STATUS_GOOD;
+      }
+
+      case OPT_BIT_DEPTH:
+      {
+        if (scanner->val[option].w != *(SANE_Word *) val)
+        {
+          scanner->val[option].w = *(SANE_Word *) val;
+
+          if (info)
+          {
+            *info |= SANE_INFO_RELOAD_OPTIONS;
+          }
+
+          scanner->output_range.min   = 0;
+          scanner->output_range.quant = 0;
+
+          if (scanner->val[option].w == 8)						       /* 8 bit mode */
+          {
+            scanner->output_bytes  = 1;							    /* 1 bytes output */
+            scanner->output_range.max = 255;
+          }
+          else										      /* > 8 bit mode */
+          {
+            scanner->output_bytes  = 2;							    /* 2 bytes output */
+
+            if (scanner->device->gamma_lsb_padded) /* e.g. astra 1220s need lsb padded data */
+            {
+              scanner->output_range.max   = (int) pow(2, scanner->val[option].w) - 1;
+            }
+            else
+            {
+              scanner->output_range.max = 65535; /* define maxval for msb padded data */
+            }
+          }
+
+
+          if (info)
+          {
+            *info |= SANE_INFO_RELOAD_PARAMS;
+          }
+        }
+       return SANE_STATUS_GOOD;
+      }
+
+      case OPT_RGB_BIND:
+      {
+        if (scanner->val[option].w != *(SANE_Word *) val)
+        {
+          scanner->val[option].w = *(SANE_Word *) val;
+          if (info)
+          {
+            *info |= SANE_INFO_RELOAD_OPTIONS;
+          }
+
+          umax_set_rgb_bind(scanner);
+        }
+       return SANE_STATUS_GOOD;
+      }
+
+      case OPT_RESOLUTION_BIND:
+      {
+        if (scanner->val[option].w != *(SANE_Word *) val)
+	{
+          scanner->val[option].w = *(SANE_Word *) val;
+
+          if (info)
+          {
+            *info |= SANE_INFO_RELOAD_OPTIONS;
+          }
+          if (scanner->val[option].w == SANE_FALSE)
+          { /* don't bind */
+            scanner->opt[OPT_Y_RESOLUTION].cap &= ~SANE_CAP_INACTIVE;
+            scanner->opt[OPT_X_RESOLUTION].title = SANE_TITLE_SCAN_X_RESOLUTION;
+            scanner->opt[OPT_X_RESOLUTION].name  = SANE_NAME_SCAN_RESOLUTION;
+            scanner->opt[OPT_X_RESOLUTION].desc  = SANE_DESC_SCAN_X_RESOLUTION;
+          }
+          else
+          { /* bind */
+            scanner->opt[OPT_Y_RESOLUTION].cap |= SANE_CAP_INACTIVE;
+            scanner->opt[OPT_X_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
+            scanner->opt[OPT_X_RESOLUTION].name  = SANE_NAME_SCAN_RESOLUTION;
+            scanner->opt[OPT_X_RESOLUTION].desc  = SANE_DESC_SCAN_RESOLUTION;
+          }
+	}
+       return SANE_STATUS_GOOD;
+      }
+
+      case OPT_SELECT_EXPOSURE_TIME:
+      case OPT_SELECT_CAL_EXPOSURE_TIME:
+      {
+        if (scanner->val[option].w != *(SANE_Word *) val)
+	{
+          scanner->val[option].w = *(SANE_Word *) val;
+
+          if (info)
+          {
+            *info |= SANE_INFO_RELOAD_OPTIONS;
+          }
+
+          if (scanner->val[OPT_SELECT_EXPOSURE_TIME].w == SANE_FALSE)
+	  {
+            scanner->opt[OPT_SELECT_CAL_EXPOSURE_TIME].cap |= SANE_CAP_INACTIVE;
+
+            scanner->opt[OPT_CAL_EXPOS_TIME].cap    |= SANE_CAP_INACTIVE;
+            scanner->opt[OPT_CAL_EXPOS_TIME_R].cap  |= SANE_CAP_INACTIVE;
+            scanner->opt[OPT_CAL_EXPOS_TIME_G].cap  |= SANE_CAP_INACTIVE;
+            scanner->opt[OPT_CAL_EXPOS_TIME_B].cap  |= SANE_CAP_INACTIVE;
+
+            scanner->opt[OPT_SCAN_EXPOS_TIME].cap   |= SANE_CAP_INACTIVE;
+            scanner->opt[OPT_SCAN_EXPOS_TIME_R].cap |= SANE_CAP_INACTIVE;
+            scanner->opt[OPT_SCAN_EXPOS_TIME_G].cap |= SANE_CAP_INACTIVE;
+            scanner->opt[OPT_SCAN_EXPOS_TIME_B].cap |= SANE_CAP_INACTIVE;
+	  }
+	  else /* exposure time selection active */
+	  {
+            scanner->opt[OPT_SELECT_CAL_EXPOSURE_TIME].cap &= ~SANE_CAP_INACTIVE;
+
+            if ( (strcmp(scanner->val[OPT_MODE].s, COLOR_STR) != 0) ||
+	         (scanner->val[OPT_RGB_BIND].w == SANE_TRUE) ||
+                 (scanner->device->exposure_time_rgb_bind) ) /* RGB bind */
+            {
+              if (scanner->val[OPT_SELECT_CAL_EXPOSURE_TIME].w)
+              {
+                scanner->opt[OPT_CAL_EXPOS_TIME].cap &= ~SANE_CAP_INACTIVE;
+              }
+              else
+              {
+                scanner->opt[OPT_CAL_EXPOS_TIME].cap |= SANE_CAP_INACTIVE;
+              }
+
+              scanner->opt[OPT_SCAN_EXPOS_TIME].cap &= ~SANE_CAP_INACTIVE;
+            }
+            else /* no RGB bind */
+            {
+              if (scanner->val[OPT_SELECT_CAL_EXPOSURE_TIME].w)
+              {
+                scanner->opt[OPT_CAL_EXPOS_TIME_R].cap &= ~SANE_CAP_INACTIVE;
+                scanner->opt[OPT_CAL_EXPOS_TIME_G].cap &= ~SANE_CAP_INACTIVE;
+                scanner->opt[OPT_CAL_EXPOS_TIME_B].cap &= ~SANE_CAP_INACTIVE;
+              }
+              else
+              {
+                scanner->opt[OPT_CAL_EXPOS_TIME_R].cap |= SANE_CAP_INACTIVE;
+                scanner->opt[OPT_CAL_EXPOS_TIME_G].cap |= SANE_CAP_INACTIVE;
+                scanner->opt[OPT_CAL_EXPOS_TIME_B].cap |= SANE_CAP_INACTIVE;
+              }
+
+              scanner->opt[OPT_SCAN_EXPOS_TIME_R].cap &= ~SANE_CAP_INACTIVE;
+              scanner->opt[OPT_SCAN_EXPOS_TIME_G].cap &= ~SANE_CAP_INACTIVE;
+              scanner->opt[OPT_SCAN_EXPOS_TIME_B].cap &= ~SANE_CAP_INACTIVE;
+            }
+	  }
+	}
+       return SANE_STATUS_GOOD;
+      }
+
+      case OPT_SELECT_LAMP_DENSITY:
+      {
+        if (scanner->val[option].w != *(SANE_Word *) val)
+	{
+          scanner->val[option].w = *(SANE_Word *) val;
+
+          if (info)
+          {
+            *info |= SANE_INFO_RELOAD_OPTIONS;
+          }
+          if (scanner->val[option].w == SANE_FALSE)
+	  {
+            scanner->opt[OPT_CAL_LAMP_DEN].cap  |= SANE_CAP_INACTIVE;
+            scanner->opt[OPT_SCAN_LAMP_DEN].cap |= SANE_CAP_INACTIVE;
+	  }
+	  else
+	  {
+            scanner->opt[OPT_CAL_LAMP_DEN].cap  &= ~SANE_CAP_INACTIVE;
+            scanner->opt[OPT_SCAN_LAMP_DEN].cap &= ~SANE_CAP_INACTIVE;
+	  }
+	}
+       return SANE_STATUS_GOOD;
+      }
+
+      /* side-effect-free word-array options: */
+      case OPT_HALFTONE_PATTERN:
+      case OPT_GAMMA_VECTOR:
+      case OPT_GAMMA_VECTOR_R:
+      case OPT_GAMMA_VECTOR_G:
+      case OPT_GAMMA_VECTOR_B:
+        memcpy (scanner->val[option].wa, val, scanner->opt[option].size);
+       return SANE_STATUS_GOOD;
+
+      /* single string-option with side-effect: */
+      case OPT_SOURCE:
+      {
+        if (scanner->val[option].s)
+        {
+          free(scanner->val[option].s);
+        }
+        scanner->val[option].s = (SANE_Char *) strdup(val); /* update string for umax_set_max_geometry */
+
+        DBG(DBG_info,"sane_control_option: set SOURCE = %s\n", (SANE_Char *) val);
+        umax_set_max_geometry(scanner);
+
+        if (info)
+        {
+          *info |= SANE_INFO_RELOAD_PARAMS;
+          *info |= SANE_INFO_RELOAD_OPTIONS;
+        }
+       return SANE_STATUS_GOOD;
+      }
+      break;
+
+      /* side-effect-free single-string options: */
+#ifdef UMAX_CALIBRATION_MODE_SELECTABLE
+      case OPT_CALIB_MODE:
+      /* fall through */
+#endif
+      {
+        if (scanner->val[option].s)
+        {
+          free (scanner->val[option].s);
+        }
+        scanner->val[option].s = (SANE_Char*)strdup(val);
+       return SANE_STATUS_GOOD;
+      }
+
+      /* options with side-effects: */
+
+      case OPT_CUSTOM_GAMMA:
+      {
+        w = *(SANE_Word *) val;
+        if (w == scanner->val[OPT_CUSTOM_GAMMA].w) { return SANE_STATUS_GOOD; } 
+
+        scanner->val[OPT_CUSTOM_GAMMA].w = w;
+        if (w)									   /* use custom_gamma_table */
+        {
+           const char *mode = scanner->val[OPT_MODE].s;
+
+           if ( (strcmp(mode, LINEART_STR) == 0) ||
+                (strcmp(mode, HALFTONE_STR) == 0) ||
+                (strcmp(mode, GRAY_STR) == 0) )
+           { scanner->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE; }
+           else if (strcmp(mode, COLOR_STR) == 0)
+           {
+             scanner->opt[OPT_GAMMA_VECTOR].cap   &= ~SANE_CAP_INACTIVE;
+             scanner->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
+             scanner->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
+             scanner->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
+           }
+        }
+        else								     /* don't use custom_gamma_table */
+        {
+          scanner->opt[OPT_GAMMA_VECTOR].cap   |= SANE_CAP_INACTIVE;
+          scanner->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
+          scanner->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
+          scanner->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
+        }
+        if (info)
+        {
+          *info |= SANE_INFO_RELOAD_OPTIONS;
+        }
+       return SANE_STATUS_GOOD;
+      }
+
+      case OPT_MODE:
+      {
+       int halftoning;
+
+        if (scanner->val[option].s)
+        {
+          free (scanner->val[option].s);
+        }
+
+        scanner->val[option].s = (SANE_Char*)strdup(val);
+
+        if (info)
+        {
+          *info |=SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
+        }
+
+        scanner->opt[OPT_NEGATIVE].cap           |= SANE_CAP_INACTIVE; 
+
+        scanner->opt[OPT_BIT_DEPTH].cap          |= SANE_CAP_INACTIVE;
+
+        scanner->opt[OPT_CUSTOM_GAMMA].cap       |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_GAMMA_VECTOR].cap       |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_GAMMA_VECTOR_R].cap     |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_GAMMA_VECTOR_G].cap     |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_GAMMA_VECTOR_B].cap     |= SANE_CAP_INACTIVE;
+
+        scanner->opt[OPT_CONTRAST].cap           |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_BRIGHTNESS].cap         |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_THRESHOLD].cap          |= SANE_CAP_INACTIVE;
+
+        scanner->opt[OPT_RGB_BIND].cap           |= SANE_CAP_INACTIVE;
+
+        scanner->opt[OPT_ANALOG_GAMMA].cap       |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_ANALOG_GAMMA_R].cap     |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_ANALOG_GAMMA_G].cap     |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_ANALOG_GAMMA_B].cap     |= SANE_CAP_INACTIVE;
+
+        scanner->opt[OPT_HIGHLIGHT].cap          |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_HIGHLIGHT_R].cap        |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_HIGHLIGHT_G].cap        |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_HIGHLIGHT_B].cap        |= SANE_CAP_INACTIVE;
+
+        scanner->opt[OPT_SHADOW].cap             |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_SHADOW_R].cap           |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_SHADOW_G].cap           |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_SHADOW_B].cap           |= SANE_CAP_INACTIVE;
+
+        scanner->opt[OPT_CAL_EXPOS_TIME].cap     |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_CAL_EXPOS_TIME_R].cap   |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_CAL_EXPOS_TIME_G].cap   |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_CAL_EXPOS_TIME_B].cap   |= SANE_CAP_INACTIVE;
+
+        scanner->opt[OPT_SCAN_EXPOS_TIME].cap    |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_SCAN_EXPOS_TIME_R].cap  |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_SCAN_EXPOS_TIME_G].cap  |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_SCAN_EXPOS_TIME_B].cap  |= SANE_CAP_INACTIVE;
+
+        scanner->opt[OPT_HALFTONE_DIMENSION].cap |= SANE_CAP_INACTIVE;
+        scanner->opt[OPT_HALFTONE_PATTERN].cap   |= SANE_CAP_INACTIVE;
+
+
+        halftoning = (strcmp(val, HALFTONE_STR) == 0 || strcmp(val, COLOR_HALFTONE_STR) == 0);
+
+        if (halftoning || strcmp(val, LINEART_STR) == 0 || strcmp(val, COLOR_LINEART_STR) == 0)
+        {										    /* one bit modes */
+          if (scanner->device->inquiry_reverse)
+          {
+            scanner->opt[OPT_NEGATIVE].cap  &= ~SANE_CAP_INACTIVE;
+          }
+
+          if (halftoning)
+          {										 /* halftoning modes */
+            scanner->opt[OPT_CONTRAST].cap   &= ~SANE_CAP_INACTIVE;
+            scanner->opt[OPT_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE;
+
+	    if (scanner->device->inquiry_highlight)
+            {
+              scanner->opt[OPT_HIGHLIGHT].cap &= ~SANE_CAP_INACTIVE;
+            }
+
+	    if (scanner->device->inquiry_shadow)
+            {
+              scanner->opt[OPT_SHADOW].cap &= ~SANE_CAP_INACTIVE;
+            }
+
+/* disable halftone pattern download options */
+#if 0
+            scanner->opt[OPT_HALFTONE_DIMENSION].cap &= ~SANE_CAP_INACTIVE;
+
+            if (scanner->val[OPT_HALFTONE_DIMENSION].w)
+            {
+              scanner->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE;
+            }
+#endif
+
+            if (scanner->val[OPT_SELECT_EXPOSURE_TIME].w == SANE_TRUE)
+            {
+              scanner->opt[OPT_CAL_EXPOS_TIME].cap   &= ~SANE_CAP_INACTIVE; 
+              scanner->opt[OPT_SCAN_EXPOS_TIME].cap  &= ~SANE_CAP_INACTIVE;
+            }
+
+            scanner->exposure_time_range.min = scanner->device->inquiry_exposure_time_h_min
+	                                       * scanner->device->inquiry_exposure_time_step_unit;
+          }
+	  else
+	  {										    /* lineart modes */
+            scanner->opt[OPT_THRESHOLD].cap  &= ~SANE_CAP_INACTIVE;
+
+            if (scanner->val[OPT_SELECT_EXPOSURE_TIME].w == SANE_TRUE)
+            {
+              scanner->opt[OPT_CAL_EXPOS_TIME].cap   &= ~SANE_CAP_INACTIVE;
+              scanner->opt[OPT_SCAN_EXPOS_TIME].cap   &= ~SANE_CAP_INACTIVE;
+            }
+
+            scanner->exposure_time_range.min = scanner->device->inquiry_exposure_time_l_min
+	                                       * scanner->device->inquiry_exposure_time_step_unit;
+	  }
+        }
+        else
+        {								   /* multi-bit modes(gray or color) */
+          scanner->opt[OPT_BIT_DEPTH].cap &= ~SANE_CAP_INACTIVE;
+
+          if (scanner->device->inquiry_highlight)
+          {
+            scanner->opt[OPT_HIGHLIGHT].cap &= ~SANE_CAP_INACTIVE;
+          }
+
+          if (scanner->device->inquiry_shadow)
+          {
+            scanner->opt[OPT_SHADOW].cap &= ~SANE_CAP_INACTIVE;
+          }
+
+          if (scanner->device->inquiry_reverse_multi)
+          {
+            scanner->opt[OPT_NEGATIVE].cap &= ~SANE_CAP_INACTIVE; 
+          }
+
+          if (scanner->device->inquiry_gamma_dwload)
+          {
+            scanner->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
+          }
+          else
+          {
+            scanner->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;
+          }
+
+          if (scanner->device->inquiry_analog_gamma)
+          {
+            scanner->opt[OPT_ANALOG_GAMMA].cap &= ~SANE_CAP_INACTIVE;
+          }
+
+          if (scanner->val[OPT_SELECT_EXPOSURE_TIME].w == SANE_TRUE)
+          {
+            scanner->opt[OPT_CAL_EXPOS_TIME].cap  &= ~SANE_CAP_INACTIVE;
+            scanner->opt[OPT_SCAN_EXPOS_TIME].cap &= ~SANE_CAP_INACTIVE;
+          }
+
+          if (strcmp(val, COLOR_STR) == 0)
+          {
+            if ( (scanner->device->inquiry_analog_gamma) ||
+                 (scanner->device->inquiry_highlight)    ||
+                 (scanner->device->inquiry_shadow)       ||
+                 (scanner->device->inquiry_exposure_adj) )
+            {
+              scanner->opt[OPT_RGB_BIND].cap &= ~SANE_CAP_INACTIVE;
+            }
+
+            scanner->exposure_time_range.min = scanner->device->inquiry_exposure_time_c_min
+	                                       * scanner->device->inquiry_exposure_time_step_unit;
+          }
+	  else /* grayscale */
+	  {
+            scanner->exposure_time_range.min = scanner->device->inquiry_exposure_time_g_min
+	                                       * scanner->device->inquiry_exposure_time_step_unit;
+	  }
+	}
+
+        umax_set_rgb_bind(scanner);
+
+        if (scanner->val[OPT_CUSTOM_GAMMA].w)
+        {
+          if (strcmp(val, GRAY_STR) == 0)
+          {
+            scanner->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
+          }
+          else if (strcmp(val, COLOR_STR) == 0)
+          {
+            scanner->opt[OPT_GAMMA_VECTOR].cap   &= ~SANE_CAP_INACTIVE;
+            scanner->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
+            scanner->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
+            scanner->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
+          }
+	}
+       return SANE_STATUS_GOOD;
+      }
+
+      case OPT_HALFTONE_DIMENSION: /* halftone pattern dimension affects halftone pattern option: */
+      {
+        unsigned dim = *(SANE_Word *) val;
+
+         scanner->val[option].w = dim;
+
+         if (info)
+         {
+           *info |= SANE_INFO_RELOAD_OPTIONS;
+         }
+
+         scanner->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE;
+
+         if (dim > 0)
+         {
+           scanner->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE;
+           scanner->opt[OPT_HALFTONE_PATTERN].size = dim * sizeof (SANE_Word);
+         }
+        return SANE_STATUS_GOOD;
+      }
+
+      case OPT_LAMP_ON:
+      {
+        if (!umax_set_lamp_status(handle, 1 /* lamp on */))
+        {
+          return SANE_STATUS_GOOD;
+        }
+        else
+        {
+          return SANE_STATUS_UNSUPPORTED;
+        }
+      }
+
+      case OPT_LAMP_OFF:
+      {
+        if (!umax_set_lamp_status(handle, 0 /* lamp off */))
+        {
+          return SANE_STATUS_GOOD;
+        }
+        else
+        {
+          return SANE_STATUS_UNSUPPORTED;
+        }
+      }
+    }
+  } /* else */
+ return SANE_STATUS_INVAL;
+}
+
+
+/* ------------------------------------------------------------ SANE GET PARAMETERS ------------------------ */
+
+
+SANE_Status sane_get_parameters(SANE_Handle handle, SANE_Parameters *params)
+{
+ Umax_Scanner *scanner = handle;
+ const char *mode;
+
+  DBG(DBG_sane_info,"sane_get_parameters\n");
+
+  if (!scanner->scanning)
+  {								  /* not scanning, so lets use recent values */
+    double width, length, x_dpi, y_dpi;
+
+    memset(&scanner->params, 0, sizeof (scanner->params));
+
+    width  = SANE_UNFIX(scanner->val[OPT_BR_X].w - scanner->val[OPT_TL_X].w);
+    length = SANE_UNFIX(scanner->val[OPT_BR_Y].w - scanner->val[OPT_TL_Y].w);
+    x_dpi  = SANE_UNFIX(scanner->val[OPT_X_RESOLUTION].w);
+    y_dpi  = SANE_UNFIX(scanner->val[OPT_Y_RESOLUTION].w);
+
+    if ( (scanner->val[OPT_RESOLUTION_BIND].w == SANE_TRUE) || (scanner->val[OPT_PREVIEW].w == SANE_TRUE) )
+    {
+      y_dpi = x_dpi;
+    }
+
+    if (x_dpi > 0.0 && y_dpi > 0.0 && width > 0.0 && length > 0.0)
+    {
+      double x_dots_per_mm = x_dpi / MM_PER_INCH;
+      double y_dots_per_mm = y_dpi / MM_PER_INCH;
+
+      scanner->params.pixels_per_line = width *  x_dots_per_mm;
+      scanner->params.lines           = length * y_dots_per_mm;
+    }
+  }
+
+  mode = scanner->val[OPT_MODE].s;
+
+  if (strcmp(mode, LINEART_STR) == 0 || strcmp(mode, HALFTONE_STR) == 0)
+  {
+    scanner->params.format         = SANE_FRAME_GRAY;
+    scanner->params.bytes_per_line = (scanner->params.pixels_per_line + 7) / 8;
+    scanner->params.depth          = 1;
+  }
+  else if (strcmp(mode, GRAY_STR) == 0)
+  {
+    scanner->params.format         = SANE_FRAME_GRAY;
+    scanner->params.bytes_per_line = scanner->params.pixels_per_line * scanner->output_bytes;
+    scanner->params.depth          = 8 * scanner->output_bytes;
+  }
+  else if (strcmp(mode, COLOR_LINEART_STR) == 0 || strcmp(mode, COLOR_HALFTONE_STR) == 0 )
+  {
+    if (scanner->device->inquiry_one_pass_color)
+    {
+      scanner->device->three_pass = 0;
+      scanner->params.format         = SANE_FRAME_RGB;
+      scanner->params.bytes_per_line = 3 * scanner->params.pixels_per_line;
+      scanner->params.depth          = 8;
+    }
+    else										 /* three pass color */
+    {
+      scanner->device->three_pass = 1;
+      scanner->params.format         = SANE_FRAME_RED + scanner->device->three_pass_color - 1;
+      scanner->params.bytes_per_line = scanner->params.pixels_per_line;
+      scanner->params.depth          = 8;
+    }
+  }
+  else												      /* RGB */
+  {
+    if (scanner->device->inquiry_one_pass_color)
+    {
+      scanner->device->three_pass = 0;
+      scanner->params.format         = SANE_FRAME_RGB;
+      scanner->params.bytes_per_line = 3 * scanner->params.pixels_per_line * scanner->output_bytes;
+      scanner->params.depth          = 8 * scanner->output_bytes;
+    }
+    else										 /* three pass color */
+    {
+      scanner->device->three_pass = 1;
+      scanner->params.format         = SANE_FRAME_RED + scanner->device->three_pass_color - 1;
+      scanner->params.bytes_per_line = scanner->params.pixels_per_line * scanner->output_bytes;
+      scanner->params.depth          = 8 * scanner->output_bytes;
+    }
+  }
+
+  scanner->params.last_frame = (scanner->params.format != SANE_FRAME_RED && scanner->params.format != SANE_FRAME_GREEN);
+
+  if (params)
+  {
+    *params = scanner->params;
+  }
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/* ------------------------------------------------------------ SANE START --------------------------------- */
+
+
+SANE_Status sane_start(SANE_Handle handle)
+{
+ Umax_Scanner *scanner = handle;
+ const char *mode;
+ double xbasedots, ybasedots;
+ const char *scan_source;
+ int pause;
+ int status;
+ int fds[2];
+
+  DBG(DBG_sane_init,"sane_start\n");
+
+  /* Initialize reader_pid to invalid so a subsequent error and following call
+   * to do_cancel() won't trip over it. */
+  scanner->reader_pid = -1;
+
+  mode = scanner->val[OPT_MODE].s;
+
+  if (scanner->device->sfd == -1)   /* first call, don`t run this routine again on multi frame or multi image scan */
+  {
+    umax_initialize_values(scanner->device);								    /* reset values */
+
+    scanner->device->three_pass_color = 1;
+
+    /* test for adf and uta */
+    scan_source = scanner->val[OPT_SOURCE].s;
+
+    if (strcmp(scan_source, UTA_STR) == 0)
+    {
+      if ( (scanner->device->inquiry_uta != 0) && (scanner->device->inquiry_transavail != 0) )
+      {
+        scanner->device->uta = 1;
+      }
+      else
+      {
+        DBG(DBG_error,"ERROR: Transparency Adapter not available\n");
+        umax_scsi_close(scanner->device);
+       return SANE_STATUS_INVAL;
+      }
+    }
+    else /* Test if ADF is selected */
+    {
+      scanner->device->uta = 0;
+
+      if (strcmp(scan_source, ADF_STR) == 0)
+      {
+        if ( (scanner->device->inquiry_adf) && (scanner->device->inquiry_adfmode) )
+        {
+          scanner->device->adf = 1;
+        }
+        else
+        {
+          DBG(DBG_error,"ERROR: Automatic Document Feeder not available\n");
+         umax_scsi_close(scanner->device);
+         return SANE_STATUS_INVAL;
+        }
+      }
+      else
+      {
+        scanner->device->adf = 0;
+      }
+    }
+
+    if (scanner->device->inquiry_GIB & 32)						/* 16 bit input mode */
+    {
+      scanner->device->gamma_input_bits_code = 32;
+      DBG(DBG_sane_info, "Using 16 bits for gamma input\n");
+    }
+    else if (scanner->device->inquiry_GIB & 16)						/* 14 bit input mode */
+    {
+      scanner->device->gamma_input_bits_code = 16;
+      DBG(DBG_sane_info, "Using 14 bits for gamma input\n");
+    }
+    else if (scanner->device->inquiry_GIB & 8)						/* 12 bit input mode */
+    {
+      scanner->device->gamma_input_bits_code = 8;
+      DBG(DBG_sane_info, "Using 12 bits for gamma input\n");
+    }
+    else if (scanner->device->inquiry_GIB & 4)						/* 10 bit input mode */
+    {
+      scanner->device->gamma_input_bits_code = 4;
+      DBG(DBG_sane_info, "Using 10 bits for gamma input\n");
+    }
+    else if (scanner->device->inquiry_GIB & 2)						 /* 9 bit input mode */
+    {
+      scanner->device->gamma_input_bits_code = 2;
+      DBG(DBG_sane_info, "Using 9 bits for gamma input\n");
+    }
+    else										 /* 8 bit input mode */
+    {
+      scanner->device->gamma_input_bits_code = 1;
+      DBG(DBG_sane_info, "Using 8 bits for gamma input\n");
+    }
+
+    if (scanner->val[OPT_BIT_DEPTH].w == 16)					       /* 16 bit output mode */
+    {
+      scanner->device->bits_per_pixel      = 16;
+      scanner->device->bits_per_pixel_code = 32;
+      scanner->device->max_value      = 65535;
+      DBG(DBG_sane_info,"Using 16 bits for output\n");
+    }
+    else if (scanner->val[OPT_BIT_DEPTH].w == 14)				       /* 14 bit output mode */
+    {
+      scanner->device->bits_per_pixel      = 14;
+      scanner->device->bits_per_pixel_code = 16;
+      scanner->device->max_value      = 16383;
+      DBG(DBG_sane_info,"Using 14 bits for output\n");
+    }
+    else if (scanner->val[OPT_BIT_DEPTH].w == 12)				       /* 12 bit output mode */
+    {
+      scanner->device->bits_per_pixel      = 12;
+      scanner->device->bits_per_pixel_code = 8;
+      scanner->device->max_value      = 4095;
+      DBG(DBG_sane_info,"Using 12 bits for output\n");
+    }
+    else if (scanner->val[OPT_BIT_DEPTH].w == 10)				       /* 10 bit output mode */
+    {
+      scanner->device->bits_per_pixel      = 10;
+      scanner->device->bits_per_pixel_code = 4;
+      scanner->device->max_value      = 1023;
+      DBG(DBG_sane_info,"Using 10 bits for output\n");
+    }
+    else if (scanner->val[OPT_BIT_DEPTH].w == 9)				        /* 9 bit output mode */
+    {
+      scanner->device->bits_per_pixel      = 9;
+      scanner->device->bits_per_pixel_code = 2;
+      scanner->device->max_value      = 511;
+      DBG(DBG_sane_info,"Using 9 bits for output\n");
+    }
+    else										/* 8 bit output mode */
+    {
+      scanner->device->bits_per_pixel      = 8;
+      scanner->device->bits_per_pixel_code = 1;
+      scanner->device->max_value      = 255;
+      DBG(DBG_sane_info,"Using 8 bits for output\n");
+    }
+
+    scanner->device->reverse = scanner->device->reverse_multi = scanner->val[OPT_NEGATIVE].w;
+
+    scanner->device->threshold         = P_100_TO_255(scanner->val[OPT_THRESHOLD].w);
+    scanner->device->brightness        = P_200_TO_255(scanner->val[OPT_BRIGHTNESS].w);
+    scanner->device->contrast          = P_200_TO_255(scanner->val[OPT_CONTRAST].w);
+
+    scanner->device->batch_scan        = ( scanner->val[OPT_BATCH_SCAN_START].w ||
+                                           scanner->val[OPT_BATCH_SCAN_LOOP].w ||
+                                           scanner->val[OPT_BATCH_SCAN_END].w );
+    scanner->device->batch_end         = scanner->val[OPT_BATCH_SCAN_END].w;
+    scanner->device->batch_next_tl_y   = SANE_UNFIX(scanner->val[OPT_BATCH_NEXT_TL_Y].w) * scanner->device->y_coordinate_base / MM_PER_INCH;
+
+    if (scanner->val[OPT_BATCH_NEXT_TL_Y].w == 0xFFFF)  /* option not set: use br_y => scanhead stops at end of batch area */
+    {
+      scanner->device->batch_next_tl_y = SANE_UNFIX(scanner->val[OPT_BR_Y].w) * scanner->device->y_coordinate_base / MM_PER_INCH;
+    }
+
+    if ((scanner->device->batch_scan) && !scanner->val[OPT_BATCH_SCAN_START].w)
+    {
+      scanner->device->calibration = 9; /* no calibration - otherwise the scanhead will go into calibration position */
+    }
+    else
+    {
+      scanner->device->calibration = 0; /* calibration defined by image type */
+    }
+
+    scanner->device->quality           = scanner->val[OPT_QUALITY].w;
+    scanner->device->dor               = scanner->val[OPT_DOR].w;
+    scanner->device->preview           = scanner->val[OPT_PREVIEW].w;
+    scanner->device->warmup            = scanner->val[OPT_WARMUP].w;
+
+    scanner->device->fix_focus_position   = scanner->val[OPT_FIX_FOCUS_POSITION].w;
+    scanner->device->lens_cal_in_doc_pos  = scanner->val[OPT_LENS_CALIBRATION_DOC_POS].w;
+    scanner->device->disable_pre_focus    = scanner->val[OPT_DISABLE_PRE_FOCUS].w;
+    scanner->device->holder_focus_pos_0mm = scanner->val[OPT_HOLDER_FOCUS_POS_0MM].w;
+    scanner->device->manual_focus         = scanner->val[OPT_MANUAL_PRE_FOCUS].w;
+
+    scanner->device->analog_gamma_r =
+    scanner->device->analog_gamma_g =
+    scanner->device->analog_gamma_b = umax_calculate_analog_gamma(SANE_UNFIX(scanner->val[OPT_ANALOG_GAMMA].w));
+
+    scanner->device->highlight_r =
+    scanner->device->highlight_g = 
+    scanner->device->highlight_b = P_100_TO_255(scanner->val[OPT_HIGHLIGHT].w);
+
+    scanner->device->shadow_r =
+    scanner->device->shadow_g = 
+    scanner->device->shadow_b = P_100_TO_255(scanner->val[OPT_SHADOW].w);
+
+    if (scanner->val[OPT_SELECT_EXPOSURE_TIME].w == SANE_TRUE)
+    {
+      if (scanner->val[OPT_SELECT_CAL_EXPOSURE_TIME].w) /* separate calibration exposure time */
+      {
+        scanner->device->exposure_time_calibration_r =
+        scanner->device->exposure_time_calibration_g =
+        scanner->device->exposure_time_calibration_b = scanner->val[OPT_CAL_EXPOS_TIME].w;
+      }
+      else /* same exposure times for calibration as for scanning */
+      {
+        scanner->device->exposure_time_calibration_r =
+        scanner->device->exposure_time_calibration_g =
+        scanner->device->exposure_time_calibration_b = scanner->val[OPT_SCAN_EXPOS_TIME].w;
+      }
+
+      scanner->device->exposure_time_scan_r =
+      scanner->device->exposure_time_scan_g =
+      scanner->device->exposure_time_scan_b = scanner->val[OPT_SCAN_EXPOS_TIME].w;
+    }
+
+    if (scanner->val[OPT_SELECT_LAMP_DENSITY].w == SANE_TRUE)
+    {
+      scanner->device->c_density = P_100_TO_254(scanner->val[OPT_CAL_LAMP_DEN].w);
+      scanner->device->s_density = P_100_TO_254(scanner->val[OPT_SCAN_LAMP_DEN].w);
+    }
+
+    if (strcmp(mode, LINEART_STR) == 0)
+    {
+      scanner->device->colormode = LINEART;
+    }
+    else if (strcmp(mode, HALFTONE_STR) == 0)
+    {
+      scanner->device->colormode = HALFTONE;
+    }
+    else if (strcmp(mode, GRAY_STR) == 0)
+    {
+      scanner->device->colormode = GRAYSCALE;
+    }
+    else if (strcmp(mode, COLOR_LINEART_STR) == 0)
+    {
+      scanner->device->colormode = RGB_LINEART;
+    }
+    else if (strcmp(mode, COLOR_HALFTONE_STR) == 0)
+    {
+      scanner->device->colormode = RGB_HALFTONE;
+    }
+    else if (strcmp(mode, COLOR_STR) == 0)
+    {
+      scanner->device->colormode = RGB;
+      if (scanner->val[OPT_RGB_BIND].w == SANE_FALSE)
+      {
+        scanner->device->analog_gamma_r =
+                 umax_calculate_analog_gamma( SANE_UNFIX(scanner->val[OPT_ANALOG_GAMMA_R].w) );
+        scanner->device->analog_gamma_g =
+                 umax_calculate_analog_gamma( SANE_UNFIX(scanner->val[OPT_ANALOG_GAMMA_G].w) );
+        scanner->device->analog_gamma_b =
+                 umax_calculate_analog_gamma( SANE_UNFIX(scanner->val[OPT_ANALOG_GAMMA_B].w) );
+
+        scanner->device->highlight_r = P_100_TO_255(scanner->val[OPT_HIGHLIGHT_R].w);
+        scanner->device->highlight_g = P_100_TO_255(scanner->val[OPT_HIGHLIGHT_G].w);
+        scanner->device->highlight_b = P_100_TO_255(scanner->val[OPT_HIGHLIGHT_B].w);
+
+        scanner->device->shadow_r = P_100_TO_255(scanner->val[OPT_SHADOW_R].w);
+        scanner->device->shadow_g = P_100_TO_255(scanner->val[OPT_SHADOW_G].w);
+        scanner->device->shadow_b = P_100_TO_255(scanner->val[OPT_SHADOW_B].w);
+
+        if ((scanner->val[OPT_SELECT_EXPOSURE_TIME].w == SANE_TRUE) && (!scanner->device->exposure_time_rgb_bind))
+        {
+          if (scanner->val[OPT_SELECT_CAL_EXPOSURE_TIME].w) /* separate calibration exposure time */
+          {
+            scanner->device->exposure_time_calibration_r = scanner->val[OPT_CAL_EXPOS_TIME_R].w;
+            scanner->device->exposure_time_calibration_g = scanner->val[OPT_CAL_EXPOS_TIME_G].w;
+            scanner->device->exposure_time_calibration_b = scanner->val[OPT_CAL_EXPOS_TIME_B].w;
+          }
+          else /* same exposure times for calibration as for scanning */
+          {
+            scanner->device->exposure_time_calibration_r = scanner->val[OPT_SCAN_EXPOS_TIME_R].w;
+            scanner->device->exposure_time_calibration_g = scanner->val[OPT_SCAN_EXPOS_TIME_G].w;
+            scanner->device->exposure_time_calibration_b = scanner->val[OPT_SCAN_EXPOS_TIME_B].w;
+          }
+
+          scanner->device->exposure_time_scan_r = scanner->val[OPT_SCAN_EXPOS_TIME_R].w;
+          scanner->device->exposure_time_scan_g = scanner->val[OPT_SCAN_EXPOS_TIME_G].w;
+          scanner->device->exposure_time_scan_b = scanner->val[OPT_SCAN_EXPOS_TIME_B].w;
+        }
+      }
+    }
+
+    if (scanner->device->force_preview_bit_rgb != 0)          /* in RGB-mode set preview bit, eg. for UMAX S6E */
+    {
+      if (scanner->device->colormode == RGB)
+      {
+        DBG(DBG_sane_info,"setting preview bit = 1 (option force-preview-bit-rgb)\n");
+        scanner->device->preview = SANE_TRUE;
+      }
+    }
+
+
+#ifdef UMAX_CALIBRATION_MODE_SELECTABLE
+    if (strcmp(scanner->val[OPT_CALIB_MODE].s, CALIB_MODE_0000) == 0)
+    {
+      scanner->device->calibration = 0;
+    }
+    else if (strcmp(scanner->val[OPT_CALIB_MODE].s, CALIB_MODE_1111) == 0)
+    {
+      scanner->device->calibration = 15;
+    }
+    else if (strcmp(scanner->val[OPT_CALIB_MODE].s, CALIB_MODE_1110) == 0)
+    {
+      scanner->device->calibration = 14;
+    }
+    else if (strcmp(scanner->val[OPT_CALIB_MODE].s, CALIB_MODE_1101) == 0)
+    {
+      scanner->device->calibration = 13;
+    }
+    else if (strcmp(scanner->val[OPT_CALIB_MODE].s, CALIB_MODE_1010) == 0)
+    {
+      scanner->device->calibration = 10;
+    }
+    else if (strcmp(scanner->val[OPT_CALIB_MODE].s, CALIB_MODE_1001) == 0)
+    {
+      scanner->device->calibration = 9;
+    }
+#endif
+
+    /* get and set geometric values for scanning */
+    scanner->device->x_resolution = SANE_UNFIX(scanner->val[OPT_X_RESOLUTION].w);
+    scanner->device->y_resolution = SANE_UNFIX(scanner->val[OPT_Y_RESOLUTION].w);
+
+    if ( (scanner->val[OPT_RESOLUTION_BIND].w == SANE_TRUE) || (scanner->val[OPT_PREVIEW].w == SANE_TRUE) )
+    {
+      scanner->device->y_resolution = scanner->device->x_resolution;
+    }
+
+    xbasedots = scanner->device->x_coordinate_base / MM_PER_INCH;
+    ybasedots = scanner->device->y_coordinate_base / MM_PER_INCH;
+
+#if 0
+    scanner->device->upper_left_x = ((int) (SANE_UNFIX(scanner->val[OPT_TL_X].w) * xbasedots)) & 65534;
+    scanner->device->upper_left_y = ((int) (SANE_UNFIX(scanner->val[OPT_TL_Y].w) * ybasedots)) & 65534;
+
+    scanner->device->scanwidth    = ((int)((SANE_UNFIX(scanner->val[OPT_BR_X].w - scanner->val[OPT_TL_X].w)) * xbasedots)) & 65534;
+    scanner->device->scanlength   = ((int)((SANE_UNFIX(scanner->val[OPT_BR_Y].w - scanner->val[OPT_TL_Y].w)) * ybasedots)) & 65534;
+#endif
+
+    scanner->device->upper_left_x = (int) (SANE_UNFIX(scanner->val[OPT_TL_X].w) * xbasedots);
+    scanner->device->upper_left_y = (int) (SANE_UNFIX(scanner->val[OPT_TL_Y].w) * ybasedots);
+
+    scanner->device->scanwidth    = (int)((SANE_UNFIX(scanner->val[OPT_BR_X].w - scanner->val[OPT_TL_X].w)) * xbasedots);
+    scanner->device->scanlength   = (int)((SANE_UNFIX(scanner->val[OPT_BR_Y].w - scanner->val[OPT_TL_Y].w)) * ybasedots);
+
+
+    if (umax_check_values(scanner->device) != 0)
+    {
+      DBG(DBG_error,"ERROR: invalid scan-values\n");
+      scanner->scanning = SANE_FALSE;
+     return SANE_STATUS_INVAL;
+    }
+
+    /* The scanner defines a x-origin-offset for DOR mode, this offset is used for the */
+    /* x range in this backend, so the frontend/user knows the correct positions related to */
+    /* scanner's surface. But the scanner wants x values from origin 0 instead */
+    /* of the x-origin defined by the scanner`s inquiry */
+    if (scanner->device->dor != 0) /* dor mode active */
+    {
+      DBG(DBG_info,"substracting DOR x-origin-offset from upper left x\n");
+      scanner->device->upper_left_x -= scanner->device->inquiry_dor_x_off * scanner->device->x_coordinate_base; /* correct DOR x-origin */
+
+      if (scanner->device->upper_left_x < 0) /* rounding errors may create a negative value */
+      {
+        scanner->device->upper_left_x = 0; /* but negative values are not allowed */
+      }
+    }
+
+    scanner->params.bytes_per_line  = scanner->device->row_len;
+    scanner->params.pixels_per_line = scanner->device->width_in_pixels; 
+    scanner->params.lines           = scanner->device->length_in_pixels;
+
+
+    /* set exposure times */
+    if ( scanner->device->inquiry_exposure_adj )
+    {
+      umax_calculate_exposure_time(scanner->device, scanner->device->use_exposure_time_def_r, &scanner->device->exposure_time_calibration_r);
+      umax_calculate_exposure_time(scanner->device, scanner->device->use_exposure_time_def_g, &scanner->device->exposure_time_calibration_g);
+      umax_calculate_exposure_time(scanner->device, scanner->device->use_exposure_time_def_b, &scanner->device->exposure_time_calibration_b);
+
+      umax_calculate_exposure_time(scanner->device, scanner->device->use_exposure_time_def_r, &scanner->device->exposure_time_scan_r);
+      umax_calculate_exposure_time(scanner->device, scanner->device->use_exposure_time_def_g, &scanner->device->exposure_time_scan_g);
+      umax_calculate_exposure_time(scanner->device, scanner->device->use_exposure_time_def_b, &scanner->device->exposure_time_scan_b);
+    }
+    else
+    {
+      scanner->device->exposure_time_calibration_r = scanner->device->exposure_time_calibration_g = scanner->device->exposure_time_calibration_b =
+      scanner->device->exposure_time_scan_r = scanner->device->exposure_time_scan_g = scanner->device->exposure_time_scan_b = 0;
+    }
+
+
+    scanner->scanning = SANE_TRUE;
+    sane_get_parameters(scanner, 0);
+
+    DBG(DBG_sane_info,"x_resolution (dpi)      = %u\n", scanner->device->x_resolution);
+    DBG(DBG_sane_info,"y_resolution (dpi)      = %u\n", scanner->device->y_resolution);
+    DBG(DBG_sane_info,"x_coordinate_base (dpi) = %u\n", scanner->device->x_coordinate_base);
+    DBG(DBG_sane_info,"y_coordinate_base (dpi) = %u\n", scanner->device->y_coordinate_base);
+    DBG(DBG_sane_info,"upper_left_x (xbase)    = %d\n", scanner->device->upper_left_x);
+    DBG(DBG_sane_info,"upper_left_y (ybase)    = %d\n", scanner->device->upper_left_y);
+    DBG(DBG_sane_info,"scanwidth    (xbase)    = %u\n", scanner->device->scanwidth);
+    DBG(DBG_sane_info,"scanlength   (ybase)    = %u\n", scanner->device->scanlength);
+    DBG(DBG_sane_info,"width in pixels         = %u\n", scanner->device->width_in_pixels);
+    DBG(DBG_sane_info,"length in pixels        = %u\n", scanner->device->length_in_pixels);
+    DBG(DBG_sane_info,"bits per pixel/color    = %u\n", scanner->device->bits_per_pixel);
+    DBG(DBG_sane_info,"bytes per line          = %d\n", scanner->params.bytes_per_line);
+    DBG(DBG_sane_info,"pixels_per_line         = %d\n", scanner->params.pixels_per_line);
+    DBG(DBG_sane_info,"lines                   = %d\n", scanner->params.lines);
+    DBG(DBG_sane_info,"negative                = %d\n", scanner->device->reverse);
+    DBG(DBG_sane_info,"threshold  (lineart)    = %d\n", scanner->device->threshold);
+    DBG(DBG_sane_info,"brightness (halftone)   = %d\n", scanner->device->brightness);
+    DBG(DBG_sane_info,"contrast   (halftone)   = %d\n", scanner->device->contrast);
+
+    DBG(DBG_sane_info,"analog_gamma            = %d %d %d\n",
+            scanner->device->analog_gamma_r,
+            scanner->device->analog_gamma_g,
+            scanner->device->analog_gamma_b);
+    DBG(DBG_sane_info,"highlight               = %d %d %d\n",
+            scanner->device->highlight_r,
+            scanner->device->highlight_g,
+            scanner->device->highlight_b);
+    DBG(DBG_sane_info,"shadow                  = %d %d %d\n",
+            scanner->device->shadow_r,
+            scanner->device->shadow_g,
+            scanner->device->shadow_b);
+    DBG(DBG_sane_info,"calibrat. exposure time = %d %d %d\n",
+            scanner->device->exposure_time_calibration_r,
+            scanner->device->exposure_time_calibration_g,
+            scanner->device->exposure_time_calibration_b);
+    DBG(DBG_sane_info,"scan exposure time      = %d %d %d\n",
+            scanner->device->exposure_time_scan_r,
+            scanner->device->exposure_time_scan_g,
+            scanner->device->exposure_time_scan_b);
+
+#ifdef UMAX_CALIBRATION_MODE_SELECTABLE
+    DBG(DBG_sane_info,"calibration             = %s\n", scanner->val[OPT_CALIB_MODE].s);
+#endif
+    DBG(DBG_sane_info,"calibration mode number = %d\n", scanner->device->calibration);
+
+    DBG(DBG_sane_info,"batch scan              = %d\n", scanner->device->batch_scan);
+    DBG(DBG_sane_info,"batch end               = %d\n", scanner->device->batch_end);
+    DBG(DBG_sane_info,"batch next top left y   = %d\n", scanner->device->batch_next_tl_y);
+    DBG(DBG_sane_info,"quality calibration     = %d\n", scanner->device->quality);
+    DBG(DBG_sane_info,"warm up                 = %d\n", scanner->device->warmup);
+    DBG(DBG_sane_info,"fast preview function   = %d\n", scanner->device->preview);
+    DBG(DBG_sane_info,"DOR                     = %d\n", scanner->device->dor);
+    DBG(DBG_sane_info,"ADF                     = %d\n", scanner->device->adf);
+    DBG(DBG_sane_info,"manual focus            = %d\n", scanner->device->manual_focus);
+    DBG(DBG_sane_info,"fix focus position      = %d\n", scanner->device->fix_focus_position);
+    DBG(DBG_sane_info,"disable pre focus       = %d\n", scanner->device->disable_pre_focus);
+    DBG(DBG_sane_info,"lens cal in doc pos     = %d\n", scanner->device->lens_cal_in_doc_pos);
+    DBG(DBG_sane_info,"holder focus pos 0mm    = %d\n", scanner->device->holder_focus_pos_0mm);
+
+    if (scanner->val[OPT_PREVIEW].w) /* preview mode */
+    {
+      scanner->device->lines_max = scanner->device->request_preview_lines;
+    }
+    else /* scan mode */
+    {
+      scanner->device->lines_max = scanner->device->request_scan_lines;
+    }
+
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+    {
+     unsigned int scsi_bufsize  = 0;
+
+      scsi_bufsize = scanner->device->width_in_pixels * scanner->device->lines_max;
+
+      if (scsi_bufsize == 0) /* no scsi buffer size, take scanner buffer size */
+      {
+        scsi_bufsize = scanner->device->inquiry_vidmem;
+      }
+
+      if (scsi_bufsize < scanner->device->scsi_buffer_size_min) /* make sure buffer has at least minimum size */
+      {
+        scsi_bufsize = scanner->device->scsi_buffer_size_min;
+      }
+      else if (scsi_bufsize > scanner->device->scsi_buffer_size_max) /* make sure buffer does not exceed maximum size */
+      {
+        scsi_bufsize = scanner->device->scsi_buffer_size_max;
+      }
+
+      if (umax_scsi_open_extended(scanner->device->sane.name, scanner->device, sense_handler,
+                                   scanner->device, (int *) &scsi_bufsize) != 0)
+      {
+        DBG(DBG_error, "ERROR: sane_start: open failed\n");
+        scanner->scanning = SANE_FALSE;
+        return SANE_STATUS_INVAL;
+      }
+
+      if (scsi_bufsize < scanner->device->scsi_buffer_size_min) /* minimum size must be available */
+      {
+        DBG(DBG_error, "ERROR: sane_start: umax_scsi_open_extended returned too small scsi buffer\n");
+        umax_scsi_close((scanner->device));
+        scanner->scanning = SANE_FALSE;
+        return SANE_STATUS_NO_MEM;
+      }
+      DBG(DBG_info, "sane_start: umax_scsi_open_extended returned scsi buffer size = %d\n", scsi_bufsize);
+
+      if (scsi_bufsize < scanner->device->width_in_pixels) /* print warning when buffer is smaller than one scanline */
+      {
+        DBG(DBG_warning, "WARNING: sane_start: scsi buffer is smaller than one scanline\n");
+      }
+
+      if (scsi_bufsize != scanner->device->bufsize)
+      {
+        DBG(DBG_info, "sane_start: buffer size has changed, reallocating buffer\n");
+
+        if (scanner->device->buffer[0])
+        {
+          DBG(DBG_info, "sane_start: freeing SCSI buffer[0]\n");
+          free(scanner->device->buffer[0]);									     /* free buffer */
+        }
+
+        scanner->device->bufsize = scsi_bufsize;
+
+        DBG(DBG_info, "sane_start: allocating SCSI buffer[0]\n");
+        scanner->device->buffer[0]  = malloc(scanner->device->bufsize);					  /* allocate buffer */
+
+        if (!scanner->device->buffer[0]) /* malloc failed */
+        {
+          DBG(DBG_error, "ERROR: sane_start: could not allocate buffer[0]\n");
+          umax_scsi_close(scanner->device);
+          scanner->device->bufsize = 0;
+          scanner->scanning = SANE_FALSE;
+         return SANE_STATUS_NO_MEM;
+        }
+      }
+    }
+#else
+    if ( umax_scsi_open(scanner->device->sane.name, scanner->device, sense_handler,
+                         scanner->device) != SANE_STATUS_GOOD )
+    {
+      scanner->scanning = SANE_FALSE;
+      DBG(DBG_error, "ERROR: sane_start: open of %s failed:\n", scanner->device->sane.name);
+      return SANE_STATUS_INVAL;
+    }
+
+    /* there is no need to reallocate the buffer because the size is fixed */
+#endif
+
+    /* grab scanner */
+    if (umax_grab_scanner(scanner->device))
+    {
+      umax_scsi_close(scanner->device);
+      scanner->scanning = SANE_FALSE;
+      DBG(DBG_warning,"WARNING: unable to reserve scanner: device busy\n");
+     return SANE_STATUS_DEVICE_BUSY;
+    }
+
+/* halftone pattern download is not ready in this version */
+#if 0
+										     /* send halftonepattern */
+    if ( (strcmp(mode, HALFTONE_STR) == 0) || (strcmp(mode, COLOR_HALFTONE_STR) == 0) )
+    {
+      umax_send_halftone_pattern(scanner->device, (char *) &(scanner->halftone_pattern[0]),
+                                 scanner->val[OPT_HALFTONE_DIMENSION].w );
+      scanner->device->halftone = WD_halftone_download;
+    }									      /* end of send halftonepattern */
+#endif
+ 
+  } /* ------------ end of first call -------------- */
+
+
+  /* send gammacurves */
+  if (scanner->val[OPT_CUSTOM_GAMMA].w == SANE_TRUE)
+  {
+    if (strcmp(mode, COLOR_STR) == 0)
+    {
+      if (scanner->device->three_pass == 0)					      /* one pass color scan */
+      {
+       unsigned int i, dest, color, value;
+       char *gamma;
+
+        gamma = malloc( (size_t) (3 * scanner->gamma_length * scanner->output_bytes) );
+        if (gamma == NULL)
+        {
+          DBG(DBG_warning,"WARNING: not able to allocate memory for gamma table, gamma ignored !!!\n");
+        }
+        else
+        {
+          dest=0;
+          for(color=1; color <= 3; color++)
+          {
+            for(i=0; i < scanner->gamma_length; i++)
+            {
+              value = scanner->gamma_table[color][i];
+              if (scanner->output_bytes == 2)
+              {
+                gamma[dest++] = scanner->gamma_table[0][value] / 256;
+              }
+              gamma[dest++] = (scanner->gamma_table[0][value] & 255);
+            }
+          }
+
+          DBG(DBG_sane_info,"sending 3 * %d bytes of gamma data for RGB\n",
+              scanner->gamma_length * scanner->output_bytes);
+
+          umax_send_gamma_data(scanner->device, &gamma[0], 3);
+          scanner->device->digital_gamma_r =
+          scanner->device->digital_gamma_g =
+          scanner->device->digital_gamma_b = WD_gamma_download;
+          free(gamma);
+        }
+      }
+      else									    /* three pass color scan */
+      {
+       unsigned int i, dest, color, value;
+       char *gamma;
+
+        gamma = malloc( (size_t) (scanner->gamma_length * scanner->output_bytes) );
+        if (gamma == NULL)
+        {
+          DBG(DBG_warning,"not able to allocate memory for gamma table, gamma ignored !!!\n");
+        }
+        else
+        {
+          dest  = 0;
+          color = scanner->device->three_pass_color;
+
+          for(i = 0; i < scanner->gamma_length; i++)
+          {
+            value = scanner->gamma_table[color][i];
+
+            if (scanner->output_bytes == 2)
+            {
+              gamma[dest++] = scanner->gamma_table[0][value] / 256;
+            }
+            gamma[dest++] = (scanner->gamma_table[0][value] & 255);
+          }
+
+          DBG(DBG_sane_info,"sending %d bytes of gamma data for color %d\n",
+              scanner->gamma_length * scanner->output_bytes, color);
+
+          umax_send_gamma_data(scanner->device, &gamma[0], 1);
+          scanner->device->digital_gamma_r =
+          scanner->device->digital_gamma_g =
+          scanner->device->digital_gamma_b = WD_gamma_download;
+          free(gamma);
+        }
+      }
+    }
+    else if (strcmp(mode, GRAY_STR) == 0) /* grayscale scan */
+    {
+     unsigned int i, dest;
+     char *gamma;
+
+      gamma = malloc( (size_t) (scanner->gamma_length * scanner->output_bytes) );
+      if (gamma == NULL)
+      {
+        DBG(DBG_warning,"WARNING: not able to allocate memory for gamma table, gamma ignored !!!\n");
+      }
+      else
+      {
+        dest=0;
+        for(i=0; i < scanner->gamma_length; i++)
+        {
+            if (scanner->output_bytes == 2)
+            {
+              gamma[dest++] = scanner->gamma_table[0][i] / 256;
+            }
+            gamma[dest++] = (scanner->gamma_table[0][i] & 255);
+        }
+
+        DBG(DBG_sane_info,"sending %d bytes of gamma data for gray\n",
+            scanner->gamma_length * scanner->output_bytes);
+
+        umax_send_gamma_data(scanner->device, &gamma[0], 1);
+        scanner->device->digital_gamma_r = WD_gamma_download;
+	free(gamma);
+      }
+    }
+  }										  /* end of send gammacurves */
+
+  if ( scanner->device->three_pass_color > WD_wid_red) /* three pass scan, not first pass */
+  {
+    umax_reposition_scanner(scanner->device);
+  }
+
+  umax_set_window_param(scanner->device);
+  status = umax_start_scan(scanner->device);
+  if (status) /* errror */
+  {
+    umax_give_scanner(scanner->device); /* reposition and release scanner */
+    return status;
+  }
+
+  pause = scanner->device->pause_for_color_calibration;
+
+  if (scanner->device->colormode != RGB)
+  {
+    pause = scanner->device->pause_for_gray_calibration;
+  }
+
+  if (pause) /* Astra 2400S needs this pause (7sec in color, 4sec in gray mode) */
+  {
+    DBG(DBG_info2,"pause for calibration %d msec ...\n", pause);
+    usleep(((long) pause) * 1000); /* time in ms */
+    DBG(DBG_info2,"pause done\n");
+  }
+
+  status = umax_do_calibration(scanner->device);
+  if (status) /* errror */
+  {
+    umax_give_scanner(scanner->device); /* reposition and release scanner */
+    return status;
+  }
+
+  if (scanner->device->pause_after_calibration) /* may be usefull */
+  {
+    DBG(DBG_info2,"pause after calibration %d msec ...\n", scanner->device->pause_after_calibration);
+    usleep(((long) scanner->device->pause_after_calibration) * 1000); /* time in ms */
+    DBG(DBG_info2,"pause done\n");
+  }
+
+
+  if (pipe(fds) < 0)
+  {
+    DBG(DBG_error,"ERROR: could not create pipe\n");
+    scanner->scanning = SANE_FALSE;
+    umax_give_scanner(scanner->device); /* reposition and release scanner */
+    umax_scsi_close(scanner->device);
+   return SANE_STATUS_IO_ERROR;
+  }
+
+  scanner->pipe_read_fd  = fds[0]; 
+  scanner->pipe_write_fd = fds[1];
+
+  /* start reader_process, deponds on OS if fork() or threads are used */
+  scanner->reader_pid = sanei_thread_begin(reader_process, (void *) scanner);
+
+  if (scanner->reader_pid == -1)
+  {
+    DBG(DBG_error, "ERROR: sanei_thread_begin failed (%s)\n", strerror(errno));
+    scanner->scanning = SANE_FALSE;
+    umax_give_scanner(scanner->device); /* reposition and release scanner */
+    umax_scsi_close(scanner->device);
+    return SANE_STATUS_NO_MEM; /* any other reason than no memory possible ? */
+  }
+
+  if (sanei_thread_is_forked())
+  {
+    close(scanner->pipe_write_fd);
+    scanner->pipe_write_fd = -1;
+  }
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/* ------------------------------------------------------------ SANE READ ---------------------------------- */
+
+
+SANE_Status sane_read(SANE_Handle handle, SANE_Byte *buf, SANE_Int max_len, SANE_Int *len)
+{
+ Umax_Scanner *scanner = handle;
+ ssize_t nread;
+
+  *len = 0;
+
+  nread = read(scanner->pipe_read_fd, buf, max_len);
+
+  DBG(DBG_sane_info, "sane_read: read %ld bytes\n", (long) nread);
+
+  if (!(scanner->scanning)) /* OOPS, not scanning */
+  {
+    return do_cancel(scanner);
+  }
+
+  if (nread < 0)
+  {
+    if (errno == EAGAIN)
+    {
+      DBG(DBG_sane_info, "sane_read: EAGAIN\n");
+      return SANE_STATUS_GOOD;
+    }
+    else
+    {
+      do_cancel(scanner); /* we had an error, stop scanner */
+     return SANE_STATUS_IO_ERROR;
+    }
+  }
+
+  *len = nread;
+
+  if (nread == 0) /* EOF */
+  {
+    if ( (scanner->device->three_pass == 0) ||
+         (scanner->device->colormode <= RGB_LINEART) ||
+         (++(scanner->device->three_pass_color) > 3) )
+    {
+      do_cancel(scanner);
+    }
+
+    DBG(DBG_sane_proc,"closing read end of pipe\n");
+
+    if (scanner->pipe_read_fd >= 0)
+    {
+      close(scanner->pipe_read_fd);
+      scanner->pipe_read_fd = -1;
+    }
+
+    return SANE_STATUS_EOF;    
+  }
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/* ------------------------------------------------------------ SANE CANCEL -------------------------------- */
+
+
+void sane_cancel(SANE_Handle handle)
+{
+ Umax_Scanner *scanner = handle;
+
+  DBG(DBG_sane_init,"sane_cancel\n");
+
+  if (scanner->scanning)
+  {
+    do_cancel(scanner);
+  }
+}
+
+
+/* ------------------------------------------------------------ SANE SET IO MODE --------------------------- */
+
+
+SANE_Status sane_set_io_mode(SANE_Handle handle, SANE_Bool non_blocking)
+{
+ Umax_Scanner *scanner = handle;
+
+  DBG(DBG_sane_init,"sane_set_io_mode: non_blocking=%d\n", non_blocking);
+
+  if (!scanner->scanning) { return SANE_STATUS_INVAL; }
+
+  if (fcntl(scanner->pipe_read_fd, F_SETFL, non_blocking ? O_NONBLOCK : 0) < 0)
+  {
+    return SANE_STATUS_IO_ERROR;
+  }  
+ return SANE_STATUS_GOOD;  
+}
+
+
+/* ------------------------------------------------------------ SANE GET SELECT FD ------------------------- */
+
+
+SANE_Status sane_get_select_fd(SANE_Handle handle, SANE_Int *fd)
+{
+ Umax_Scanner *scanner = handle;
+
+  DBG(DBG_sane_init,"sane_get_select_fd\n");
+
+  if (!scanner->scanning)
+  {
+    return SANE_STATUS_INVAL;
+  }
+
+  *fd = scanner->pipe_read_fd;
+
+ return SANE_STATUS_GOOD;
+}
+
+/* ------------------------------------------------------------ EOF ---------------------------------------- */