Initial import of sane-backends version 1.0.24-1.2

1 files changed, 2389 insertions, 0 deletions

diff --git a/backend/gt68xx.c b/backend/gt68xx.c
new file mode 100644
index 0000000..ea71d91
--- /dev/null
+++ b/backend/gt68xx.c
@@ -0,0 +1,2389 @@
+/* sane - Scanner Access Now Easy.
+
+   Copyright (C) 2002 Sergey Vlasov <vsu@altlinux.ru>
+   Copyright (C) 2002 - 2007 Henning Geinitz <sane@geinitz.org>
+   Copyright (C) 2009 Stéphane Voltz <stef.dev@free.fr> for sheetfed
+                      calibration code.
+
+   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. 
+*/
+
+/*
+ * SANE backend for Grandtech GT-6801 and GT-6816 based scanners
+ */
+
+#include "../include/sane/config.h"
+
+#define BUILD 84
+#define MAX_DEBUG
+#define WARMUP_TIME 60
+#define CALIBRATION_HEIGHT 2.5
+#define SHORT_TIMEOUT (1 * 1000)
+#define LONG_TIMEOUT (30 * 1000)
+
+/* Use a reader process if possible (usually faster) */
+#if defined (HAVE_SYS_SHM_H) && (!defined (USE_PTHREAD)) && (!defined (HAVE_OS2_H))
+#define USE_FORK
+#define SHM_BUFFERS 10
+#endif
+
+#define TUNE_CALIBRATOR
+
+/* Send coarse white or black calibration to stdout */
+#if 0
+#define SAVE_WHITE_CALIBRATION
+#endif
+#if 0
+#define SAVE_BLACK_CALIBRATION
+#endif
+
+/* Debug calibration, print total brightness of the scanned image */
+#if 0
+#define DEBUG_BRIGHTNESS
+#endif
+
+/* Debug calibration, print black mark values */
+#if 0
+#define DEBUG_BLACK
+#endif
+
+#include <ctype.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <limits.h>
+#include <signal.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <sys/time.h>
+#include <time.h>
+#include <math.h>
+#include <dirent.h>
+
+#include "../include/_stdint.h"
+
+#include "../include/sane/sane.h"
+#include "../include/sane/sanei.h"
+#include "../include/sane/saneopts.h"
+
+#define BACKEND_NAME gt68xx
+
+#include "../include/sane/sanei_backend.h"
+#include "../include/sane/sanei_config.h"
+
+#ifndef SANE_I18N
+#define SANE_I18N(text) text
+#endif
+
+#include "gt68xx.h"
+#include "gt68xx_high.c"
+#include "gt68xx_devices.c"
+
+static SANE_Int num_devices = 0;
+static GT68xx_Device *first_dev = 0;
+static GT68xx_Scanner *first_handle = 0;
+static const SANE_Device **devlist = 0;
+/* Array of newly attached devices */
+static GT68xx_Device **new_dev = 0;
+/* Length of new_dev array */
+static SANE_Int new_dev_len = 0;
+/* Number of entries alloced for new_dev */
+static SANE_Int new_dev_alloced = 0;
+/* Is this computer little-endian ?*/
+SANE_Bool little_endian;
+SANE_Bool debug_options = SANE_FALSE;
+
+static SANE_String_Const mode_list[] = {
+  SANE_VALUE_SCAN_MODE_COLOR,
+  SANE_VALUE_SCAN_MODE_GRAY,
+  SANE_VALUE_SCAN_MODE_LINEART,
+  0
+};
+
+static SANE_String_Const gray_mode_list[] = {
+  GT68XX_COLOR_RED,
+  GT68XX_COLOR_GREEN,
+  GT68XX_COLOR_BLUE,
+  0
+};
+
+static SANE_String_Const source_list[] = {
+  SANE_I18N ("Flatbed"),
+  SANE_I18N ("Transparency Adapter"),
+  0
+};
+
+static SANE_Range x_range = {
+  SANE_FIX (0.0),               /* minimum */
+  SANE_FIX (216.0),             /* maximum */
+  SANE_FIX (0.0)                /* quantization */
+};
+
+static SANE_Range y_range = {
+  SANE_FIX (0.0),               /* minimum */
+  SANE_FIX (299.0),             /* maximum */
+  SANE_FIX (0.0)                /* quantization */
+};
+
+
+static const SANE_Range offset_range = {
+  -63,                          /* minimum */
+  63,                           /* maximum */
+  1                             /* quantization */
+};
+
+static SANE_Range gamma_range = {
+  SANE_FIX (0.01),              /* minimum */
+  SANE_FIX (5.0),               /* maximum */
+  SANE_FIX (0.01)               /* quantization */
+};
+
+static const SANE_Range u8_range = {
+  0,                            /* minimum */
+  255,                          /* maximum */
+  0                             /* quantization */
+};
+
+/* Test if this machine is little endian (from coolscan.c) */
+static SANE_Bool
+calc_little_endian (void)
+{
+  SANE_Int testvalue = 255;
+  uint8_t *firstbyte = (uint8_t *) & testvalue;
+
+  if (*firstbyte == 255)
+    return SANE_TRUE;
+  return SANE_FALSE;
+}
+
+static size_t
+max_string_size (const SANE_String_Const strings[])
+{
+  size_t size, max_size = 0;
+  SANE_Int i;
+
+  for (i = 0; strings[i]; ++i)
+    {
+      size = strlen (strings[i]) + 1;
+      if (size > max_size)
+        max_size = size;
+    }
+  return max_size;
+}
+
+static SANE_Status
+get_afe_values (SANE_String_Const cp, GT68xx_AFE_Parameters * afe)
+{
+  SANE_Char *word, *end;
+  int i;
+
+  for (i = 0; i < 6; i++)
+    {
+      cp = sanei_config_get_string (cp, &word);
+      if (word && *word)
+        {
+          long int long_value;
+          errno = 0;
+          long_value = strtol (word, &end, 0);
+
+          if (end == word)
+            {
+              DBG (5, "get_afe_values: can't parse %d. parameter `%s'\n",
+                   i + 1, word);
+              free (word);
+              word = 0;
+              return SANE_STATUS_INVAL;
+            }
+          else if (errno)
+            {
+              DBG (5, "get_afe_values: can't parse %d. parameter `%s' "
+                   "(%s)\n", i + 1, word, strerror (errno));
+              free (word);
+              word = 0;
+              return SANE_STATUS_INVAL;
+            }
+          else if (long_value < 0)
+            {
+              DBG (5, "get_afe_values: %d. parameter < 0 (%d)\n", i + 1,
+                   (int) long_value);
+              free (word);
+              word = 0;
+              return SANE_STATUS_INVAL;
+            }
+          else if (long_value > 0x3f)
+            {
+              DBG (5, "get_afe_values: %d. parameter > 0x3f (%d)\n", i + 1,
+                   (int) long_value);
+              free (word);
+              word = 0;
+              return SANE_STATUS_INVAL;
+            }
+          else
+            {
+              DBG (5, "get_afe_values: %d. parameter set to 0x%02x\n", i + 1,
+                   (int) long_value);
+              switch (i)
+                {
+                case 0:
+                  afe->r_offset = (SANE_Byte) long_value;
+                  break;
+                case 1:
+                  afe->r_pga = (SANE_Byte) long_value;
+                  break;
+                case 2:
+                  afe->g_offset = (SANE_Byte) long_value;
+                  break;
+                case 3:
+                  afe->g_pga = (SANE_Byte) long_value;
+                  break;
+                case 4:
+                  afe->b_offset = (SANE_Byte) long_value;
+                  break;
+                case 5:
+                  afe->b_pga = (SANE_Byte) long_value;
+                  break;
+                }
+              free (word);
+              word = 0;
+            }
+        }
+      else
+        {
+          DBG (5, "get_afe_values: option `afe' needs 6  parameters\n");
+          return SANE_STATUS_INVAL;
+        }
+    }
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+setup_scan_request (GT68xx_Scanner * s, GT68xx_Scan_Request * scan_request)
+{
+
+  if (s->dev->model->flags & GT68XX_FLAG_MIRROR_X)
+    scan_request->x0 =
+      s->opt[OPT_TL_X].constraint.range->max - s->val[OPT_BR_X].w;
+  else
+    scan_request->x0 = s->val[OPT_TL_X].w;
+  scan_request->y0 = s->val[OPT_TL_Y].w;
+  scan_request->xs = s->val[OPT_BR_X].w - s->val[OPT_TL_X].w;
+  scan_request->ys = s->val[OPT_BR_Y].w - s->val[OPT_TL_Y].w;
+
+  if (s->val[OPT_FULL_SCAN].w == SANE_TRUE)
+    {
+      scan_request->x0 -= s->dev->model->x_offset;
+      scan_request->y0 -= (s->dev->model->y_offset);
+      scan_request->xs += s->dev->model->x_offset;
+      scan_request->ys += s->dev->model->y_offset;
+    }
+
+  scan_request->xdpi = s->val[OPT_RESOLUTION].w;
+  if (scan_request->xdpi > s->dev->model->optical_xdpi)
+    scan_request->xdpi = s->dev->model->optical_xdpi;
+  scan_request->ydpi = s->val[OPT_RESOLUTION].w;
+
+  if (IS_ACTIVE (OPT_BIT_DEPTH) && !s->val[OPT_PREVIEW].w)
+    scan_request->depth = s->val[OPT_BIT_DEPTH].w;
+  else
+    scan_request->depth = 8;
+
+  if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0)
+    scan_request->color = SANE_TRUE;
+  else
+    scan_request->color = SANE_FALSE;
+
+  if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) == 0)
+    {
+      SANE_Int xs =
+        SANE_UNFIX (scan_request->xs) * scan_request->xdpi / MM_PER_INCH +
+        0.5;
+
+      if (xs % 8)
+        {
+          scan_request->xs =
+            SANE_FIX ((xs - (xs % 8)) * MM_PER_INCH / scan_request->xdpi);
+          DBG (5, "setup_scan_request: lineart mode, %d pixels %% 8 = %d\n",
+               xs, xs % 8);
+        }
+    }
+
+  scan_request->calculate = SANE_FALSE;
+  scan_request->lamp = SANE_TRUE;
+  scan_request->mbs = SANE_FALSE;
+
+  if (strcmp (s->val[OPT_SOURCE].s, "Transparency Adapter") == 0)
+    scan_request->use_ta = SANE_TRUE;
+  else
+    scan_request->use_ta = SANE_FALSE;
+
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+calc_parameters (GT68xx_Scanner * s)
+{
+  SANE_String val;
+  SANE_Status status = SANE_STATUS_GOOD;
+  GT68xx_Scan_Request scan_request;
+  GT68xx_Scan_Parameters scan_params;
+
+  DBG (5, "calc_parameters: start\n");
+  val = s->val[OPT_MODE].s;
+
+  s->params.last_frame = SANE_TRUE;
+  if (strcmp (val, SANE_VALUE_SCAN_MODE_GRAY) == 0
+      || strcmp (val, SANE_VALUE_SCAN_MODE_LINEART) == 0)
+    s->params.format = SANE_FRAME_GRAY;
+  else                          /* Color */
+    s->params.format = SANE_FRAME_RGB;
+
+  setup_scan_request (s, &scan_request);
+  scan_request.calculate = SANE_TRUE;
+
+  status = gt68xx_device_setup_scan (s->dev, &scan_request, SA_SCAN,
+                                     &scan_params);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "calc_parameters: gt68xx_device_setup_scan returned: %s\n",
+           sane_strstatus (status));
+      return status;
+    }
+
+  if (strcmp (val, SANE_VALUE_SCAN_MODE_LINEART) == 0)
+    s->params.depth = 1;
+  else
+    s->params.depth = scan_params.depth;
+
+  s->params.lines = scan_params.pixel_ys;
+  s->params.pixels_per_line = scan_params.pixel_xs;
+  /* Inflate X if necessary */
+  if (s->val[OPT_RESOLUTION].w > s->dev->model->optical_xdpi)
+    s->params.pixels_per_line *=
+      (s->val[OPT_RESOLUTION].w / s->dev->model->optical_xdpi);
+  s->params.bytes_per_line = s->params.pixels_per_line;
+  if (s->params.depth > 8)
+    {
+      s->params.depth = 16;
+      s->params.bytes_per_line *= 2;
+    }
+  else if (s->params.depth == 1)
+    s->params.bytes_per_line /= 8;
+
+  if (s->params.format == SANE_FRAME_RGB)
+    s->params.bytes_per_line *= 3;
+
+  DBG (5, "calc_parameters: exit\n");
+  return status;
+}
+
+static SANE_Status
+create_bpp_list (GT68xx_Scanner * s, SANE_Int * bpp)
+{
+  int count;
+
+  for (count = 0; bpp[count] != 0; count++)
+    ;
+  s->bpp_list[0] = count;
+  for (count = 0; bpp[count] != 0; count++)
+    {
+      s->bpp_list[s->bpp_list[0] - count] = bpp[count];
+    }
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+init_options (GT68xx_Scanner * s)
+{
+  SANE_Int option, count;
+  SANE_Status status;
+  SANE_Word *dpi_list;
+  GT68xx_Model *model = s->dev->model;
+  SANE_Bool has_ta = SANE_FALSE;
+
+  DBG (5, "init_options: start\n");
+
+  memset (s->opt, 0, sizeof (s->opt));
+  memset (s->val, 0, sizeof (s->val));
+
+  for (option = 0; option < NUM_OPTIONS; ++option)
+    {
+      s->opt[option].size = sizeof (SANE_Word);
+      s->opt[option].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+    }
+  s->opt[OPT_NUM_OPTS].name = SANE_NAME_NUM_OPTIONS;
+  s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
+  s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
+  s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
+  s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
+  s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
+
+  /* "Mode" group: */
+  s->opt[OPT_MODE_GROUP].title = SANE_I18N ("Scan Mode");
+  s->opt[OPT_MODE_GROUP].desc = "";
+  s->opt[OPT_MODE_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_MODE_GROUP].size = 0;
+  s->opt[OPT_MODE_GROUP].cap = 0;
+  s->opt[OPT_MODE_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* scan mode */
+  s->opt[OPT_MODE].name = SANE_NAME_SCAN_MODE;
+  s->opt[OPT_MODE].title = SANE_TITLE_SCAN_MODE;
+  s->opt[OPT_MODE].desc = SANE_DESC_SCAN_MODE;
+  s->opt[OPT_MODE].type = SANE_TYPE_STRING;
+  s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  s->opt[OPT_MODE].size = max_string_size (mode_list);
+  s->opt[OPT_MODE].constraint.string_list = mode_list;
+  s->val[OPT_MODE].s = strdup (SANE_VALUE_SCAN_MODE_GRAY);
+
+  /* scan mode */
+  s->opt[OPT_GRAY_MODE_COLOR].name = "gray-mode-color";
+  s->opt[OPT_GRAY_MODE_COLOR].title = SANE_I18N ("Gray mode color");
+  s->opt[OPT_GRAY_MODE_COLOR].desc =
+    SANE_I18N ("Selects which scan color is used "
+               "gray mode (default: green).");
+  s->opt[OPT_GRAY_MODE_COLOR].type = SANE_TYPE_STRING;
+  s->opt[OPT_GRAY_MODE_COLOR].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  s->opt[OPT_GRAY_MODE_COLOR].size = max_string_size (gray_mode_list);
+  s->opt[OPT_GRAY_MODE_COLOR].constraint.string_list = gray_mode_list;
+  s->val[OPT_GRAY_MODE_COLOR].s = strdup (GT68XX_COLOR_GREEN);
+
+  /* scan source */
+  s->opt[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE;
+  s->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE;
+  s->opt[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE;
+  s->opt[OPT_SOURCE].type = SANE_TYPE_STRING;
+  s->opt[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  s->opt[OPT_SOURCE].size = max_string_size (source_list);
+  s->opt[OPT_SOURCE].constraint.string_list = source_list;
+  s->val[OPT_SOURCE].s = strdup ("Flatbed");
+  status = gt68xx_device_get_ta_status (s->dev, &has_ta);
+  if (status != SANE_STATUS_GOOD || !has_ta)
+    DISABLE (OPT_SOURCE);
+
+  /* preview */
+  s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
+  s->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
+  s->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
+  s->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
+  s->opt[OPT_PREVIEW].unit = SANE_UNIT_NONE;
+  s->opt[OPT_PREVIEW].constraint_type = SANE_CONSTRAINT_NONE;
+  s->val[OPT_PREVIEW].w = SANE_FALSE;
+
+  /* lamp on */
+  s->opt[OPT_LAMP_OFF_AT_EXIT].name = SANE_NAME_LAMP_OFF_AT_EXIT;
+  s->opt[OPT_LAMP_OFF_AT_EXIT].title = SANE_TITLE_LAMP_OFF_AT_EXIT;
+  s->opt[OPT_LAMP_OFF_AT_EXIT].desc = SANE_DESC_LAMP_OFF_AT_EXIT;
+  s->opt[OPT_LAMP_OFF_AT_EXIT].type = SANE_TYPE_BOOL;
+  s->opt[OPT_LAMP_OFF_AT_EXIT].unit = SANE_UNIT_NONE;
+  s->opt[OPT_LAMP_OFF_AT_EXIT].constraint_type = SANE_CONSTRAINT_NONE;
+  s->val[OPT_LAMP_OFF_AT_EXIT].w = SANE_TRUE;
+  if (s->dev->model->is_cis && !(s->dev->model->flags & GT68XX_FLAG_CIS_LAMP))
+    DISABLE (OPT_LAMP_OFF_AT_EXIT);
+
+  /* bit depth */
+  s->opt[OPT_BIT_DEPTH].name = SANE_NAME_BIT_DEPTH;
+  s->opt[OPT_BIT_DEPTH].title = SANE_TITLE_BIT_DEPTH;
+  s->opt[OPT_BIT_DEPTH].desc = SANE_DESC_BIT_DEPTH;
+  s->opt[OPT_BIT_DEPTH].type = SANE_TYPE_INT;
+  s->opt[OPT_BIT_DEPTH].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+  s->opt[OPT_BIT_DEPTH].size = sizeof (SANE_Word);
+  s->opt[OPT_BIT_DEPTH].constraint.word_list = 0;
+  s->opt[OPT_BIT_DEPTH].constraint.word_list = s->bpp_list;
+  RIE (create_bpp_list (s, s->dev->model->bpp_gray_values));
+  s->val[OPT_BIT_DEPTH].w = 8;
+  if (s->opt[OPT_BIT_DEPTH].constraint.word_list[0] < 2)
+    DISABLE (OPT_BIT_DEPTH);
+
+  /* resolution */
+  for (count = 0; model->ydpi_values[count] != 0; count++)
+    ;
+  dpi_list = malloc ((count + 1) * sizeof (SANE_Word));
+  if (!dpi_list)
+    return SANE_STATUS_NO_MEM;
+  dpi_list[0] = count;
+  for (count = 0; model->ydpi_values[count] != 0; count++)
+    dpi_list[dpi_list[0] - count] = model->ydpi_values[count];
+  s->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
+  s->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
+  s->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
+  s->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
+  s->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
+  s->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+  s->opt[OPT_RESOLUTION].constraint.word_list = dpi_list;
+  s->val[OPT_RESOLUTION].w = 300;
+
+  /* backtrack */
+  s->opt[OPT_BACKTRACK].name = SANE_NAME_BACKTRACK;
+  s->opt[OPT_BACKTRACK].title = SANE_TITLE_BACKTRACK;
+  s->opt[OPT_BACKTRACK].desc = SANE_DESC_BACKTRACK;
+  s->opt[OPT_BACKTRACK].type = SANE_TYPE_BOOL;
+  s->val[OPT_BACKTRACK].w = SANE_FALSE;
+
+  /* "Debug" group: */
+  s->opt[OPT_DEBUG_GROUP].title = SANE_I18N ("Debugging Options");
+  s->opt[OPT_DEBUG_GROUP].desc = "";
+  s->opt[OPT_DEBUG_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_DEBUG_GROUP].size = 0;
+  s->opt[OPT_DEBUG_GROUP].cap = 0;
+  s->opt[OPT_DEBUG_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+  if (!debug_options)
+    DISABLE (OPT_DEBUG_GROUP);
+
+  /* auto warmup */
+  s->opt[OPT_AUTO_WARMUP].name = "auto-warmup";
+  s->opt[OPT_AUTO_WARMUP].title = SANE_I18N ("Automatic warmup");
+  s->opt[OPT_AUTO_WARMUP].desc =
+    SANE_I18N ("Warm-up until the lamp's brightness is constant "
+               "instead of insisting on 60 seconds warm-up time.");
+  s->opt[OPT_AUTO_WARMUP].type = SANE_TYPE_BOOL;
+  s->opt[OPT_AUTO_WARMUP].unit = SANE_UNIT_NONE;
+  s->opt[OPT_AUTO_WARMUP].constraint_type = SANE_CONSTRAINT_NONE;
+  s->val[OPT_AUTO_WARMUP].w = SANE_TRUE;
+  if ((s->dev->model->is_cis
+       && !(s->dev->model->flags & GT68XX_FLAG_CIS_LAMP)) || !debug_options)
+    DISABLE (OPT_AUTO_WARMUP);
+
+  /* full scan */
+  s->opt[OPT_FULL_SCAN].name = "full-scan";
+  s->opt[OPT_FULL_SCAN].title = SANE_I18N ("Full scan");
+  s->opt[OPT_FULL_SCAN].desc =
+    SANE_I18N ("Scan the complete scanning area including calibration strip. "
+               "Be careful. Don't select the full height. For testing only.");
+  s->opt[OPT_FULL_SCAN].type = SANE_TYPE_BOOL;
+  s->opt[OPT_FULL_SCAN].unit = SANE_UNIT_NONE;
+  s->opt[OPT_FULL_SCAN].constraint_type = SANE_CONSTRAINT_NONE;
+  s->val[OPT_FULL_SCAN].w = SANE_FALSE;
+  if (!debug_options)
+    DISABLE (OPT_FULL_SCAN);
+
+  /* coarse calibration */
+  s->opt[OPT_COARSE_CAL].name = "coarse-calibration";
+  s->opt[OPT_COARSE_CAL].title = SANE_I18N ("Coarse calibration");
+  s->opt[OPT_COARSE_CAL].desc =
+    SANE_I18N ("Setup gain and offset for scanning automatically. If this "
+               "option is disabled, options for setting the analog frontend "
+               "parameters manually are provided. This option is enabled "
+               "by default. For testing only.");
+  s->opt[OPT_COARSE_CAL].type = SANE_TYPE_BOOL;
+  s->opt[OPT_COARSE_CAL].unit = SANE_UNIT_NONE;
+  s->opt[OPT_COARSE_CAL].constraint_type = SANE_CONSTRAINT_NONE;
+  s->val[OPT_COARSE_CAL].w = SANE_TRUE;
+  if (!debug_options)
+    DISABLE (OPT_COARSE_CAL);
+  if (s->dev->model->flags & GT68XX_FLAG_SHEET_FED)
+    {
+      s->val[OPT_COARSE_CAL].w = SANE_FALSE;
+      DISABLE (OPT_COARSE_CAL);
+    }
+
+  /* coarse calibration only once */
+  s->opt[OPT_COARSE_CAL_ONCE].name = "coarse-calibration-once";
+  s->opt[OPT_COARSE_CAL_ONCE].title =
+    SANE_I18N ("Coarse calibration for first scan only");
+  s->opt[OPT_COARSE_CAL_ONCE].desc =
+    SANE_I18N ("Coarse calibration is only done for the first scan. Works "
+               "with most scanners and can save scanning time. If the image "
+               "brightness is different with each scan, disable this option. "
+               "For testing only.");
+  s->opt[OPT_COARSE_CAL_ONCE].type = SANE_TYPE_BOOL;
+  s->opt[OPT_COARSE_CAL_ONCE].unit = SANE_UNIT_NONE;
+  s->opt[OPT_COARSE_CAL_ONCE].constraint_type = SANE_CONSTRAINT_NONE;
+  s->val[OPT_COARSE_CAL_ONCE].w = SANE_FALSE;
+  if (!debug_options)
+    DISABLE (OPT_COARSE_CAL_ONCE);
+  if (s->dev->model->flags & GT68XX_FLAG_SHEET_FED)
+    DISABLE (OPT_COARSE_CAL_ONCE);
+
+  /* calibration */
+  s->opt[OPT_QUALITY_CAL].name = SANE_NAME_QUALITY_CAL;
+  s->opt[OPT_QUALITY_CAL].title = SANE_TITLE_QUALITY_CAL;
+  s->opt[OPT_QUALITY_CAL].desc = SANE_TITLE_QUALITY_CAL;
+  s->opt[OPT_QUALITY_CAL].type = SANE_TYPE_BOOL;
+  s->opt[OPT_QUALITY_CAL].unit = SANE_UNIT_NONE;
+  s->opt[OPT_QUALITY_CAL].constraint_type = SANE_CONSTRAINT_NONE;
+  s->val[OPT_QUALITY_CAL].w = SANE_TRUE;
+  if (!debug_options)
+    DISABLE (OPT_QUALITY_CAL);
+  /* we disable image correction for scanners that can't calibrate */
+  if ((s->dev->model->flags & GT68XX_FLAG_SHEET_FED)
+    &&(!(s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE)))
+    {
+      s->val[OPT_QUALITY_CAL].w = SANE_FALSE;
+      DISABLE (OPT_QUALITY_CAL);
+    }
+
+  /* backtrack lines */
+  s->opt[OPT_BACKTRACK_LINES].name = "backtrack-lines";
+  s->opt[OPT_BACKTRACK_LINES].title = SANE_I18N ("Backtrack lines");
+  s->opt[OPT_BACKTRACK_LINES].desc =
+    SANE_I18N ("Number of lines the scan slider moves back when backtracking "
+               "occurs. That happens when the scanner scans faster than the "
+               "computer can receive the data. Low values cause faster scans "
+               "but increase the risk of omitting lines.");
+  s->opt[OPT_BACKTRACK_LINES].type = SANE_TYPE_INT;
+  s->opt[OPT_BACKTRACK_LINES].unit = SANE_UNIT_NONE;
+  s->opt[OPT_BACKTRACK_LINES].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BACKTRACK_LINES].constraint.range = &u8_range;
+  if (s->dev->model->is_cis && !(s->dev->model->flags & GT68XX_FLAG_SHEET_FED))
+    s->val[OPT_BACKTRACK_LINES].w = 0x10;
+  else
+    s->val[OPT_BACKTRACK_LINES].w = 0x3f;
+  if (!debug_options)
+    DISABLE (OPT_BACKTRACK_LINES);
+
+  /* "Enhancement" group: */
+  s->opt[OPT_ENHANCEMENT_GROUP].title = SANE_I18N ("Enhancement");
+  s->opt[OPT_ENHANCEMENT_GROUP].desc = "";
+  s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
+  s->opt[OPT_ENHANCEMENT_GROUP].size = 0;
+  s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* internal gamma value */
+  s->opt[OPT_GAMMA_VALUE].name = "gamma-value";
+  s->opt[OPT_GAMMA_VALUE].title = SANE_I18N ("Gamma value");
+  s->opt[OPT_GAMMA_VALUE].desc =
+    SANE_I18N ("Sets the gamma value of all channels.");
+  s->opt[OPT_GAMMA_VALUE].type = SANE_TYPE_FIXED;
+  s->opt[OPT_GAMMA_VALUE].unit = SANE_UNIT_NONE;
+  s->opt[OPT_GAMMA_VALUE].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_GAMMA_VALUE].constraint.range = &gamma_range;
+  s->opt[OPT_GAMMA_VALUE].cap |= SANE_CAP_EMULATED;
+  s->val[OPT_GAMMA_VALUE].w = s->dev->gamma_value;
+
+  /* threshold */
+  s->opt[OPT_THRESHOLD].name = SANE_NAME_THRESHOLD;
+  s->opt[OPT_THRESHOLD].title = SANE_TITLE_THRESHOLD;
+  s->opt[OPT_THRESHOLD].desc = SANE_DESC_THRESHOLD;
+  s->opt[OPT_THRESHOLD].type = SANE_TYPE_INT;
+  s->opt[OPT_THRESHOLD].unit = SANE_UNIT_NONE;
+  s->opt[OPT_THRESHOLD].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_THRESHOLD].constraint.range = &u8_range;
+  s->val[OPT_THRESHOLD].w = 128;
+  DISABLE (OPT_THRESHOLD);
+
+  /* "Geometry" group: */
+  s->opt[OPT_GEOMETRY_GROUP].title = SANE_I18N ("Geometry");
+  s->opt[OPT_GEOMETRY_GROUP].desc = "";
+  s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_GEOMETRY_GROUP].cap = SANE_CAP_ADVANCED;
+  s->opt[OPT_GEOMETRY_GROUP].size = 0;
+  s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  x_range.max = model->x_size;
+  y_range.max = model->y_size;
+
+  /* top-left x */
+  s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
+  s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
+  s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
+  s->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
+  s->opt[OPT_TL_X].unit = SANE_UNIT_MM;
+  s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_TL_X].constraint.range = &x_range;
+  s->val[OPT_TL_X].w = 0;
+
+  /* top-left y */
+  s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
+  s->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
+  s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_TL_Y].constraint.range = &y_range;
+  s->val[OPT_TL_Y].w = 0;
+
+  /* bottom-right x */
+  s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
+  s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
+  s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
+  s->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
+  s->opt[OPT_BR_X].unit = SANE_UNIT_MM;
+  s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BR_X].constraint.range = &x_range;
+  s->val[OPT_BR_X].w = x_range.max;
+
+  /* bottom-right y */
+  s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
+  s->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
+  s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BR_Y].constraint.range = &y_range;
+  s->val[OPT_BR_Y].w = y_range.max;
+
+  /* sensor group */
+  s->opt[OPT_SENSOR_GROUP].name = SANE_NAME_SENSORS;
+  s->opt[OPT_SENSOR_GROUP].title = SANE_TITLE_SENSORS;
+  s->opt[OPT_SENSOR_GROUP].desc = SANE_DESC_SENSORS;
+  s->opt[OPT_SENSOR_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_SENSOR_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+  
+  /* calibration needed */
+  s->opt[OPT_NEED_CALIBRATION_SW].name = "need-calibration";
+  s->opt[OPT_NEED_CALIBRATION_SW].title = SANE_I18N ("Need calibration");
+  s->opt[OPT_NEED_CALIBRATION_SW].desc = SANE_I18N ("The scanner needs calibration for the current settings");
+  s->opt[OPT_NEED_CALIBRATION_SW].type = SANE_TYPE_BOOL;
+  s->opt[OPT_NEED_CALIBRATION_SW].unit = SANE_UNIT_NONE;
+  if (s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE)
+    s->opt[OPT_NEED_CALIBRATION_SW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
+  else
+    s->opt[OPT_NEED_CALIBRATION_SW].cap = SANE_CAP_INACTIVE;
+  s->val[OPT_NEED_CALIBRATION_SW].b = 0;
+
+  /* document present sensor */
+  s->opt[OPT_PAGE_LOADED_SW].name = SANE_NAME_PAGE_LOADED;
+  s->opt[OPT_PAGE_LOADED_SW].title = SANE_TITLE_PAGE_LOADED;
+  s->opt[OPT_PAGE_LOADED_SW].desc = SANE_DESC_PAGE_LOADED;
+  s->opt[OPT_PAGE_LOADED_SW].type = SANE_TYPE_BOOL;
+  s->opt[OPT_PAGE_LOADED_SW].unit = SANE_UNIT_NONE;
+  if (s->dev->model->command_set->document_present)
+    s->opt[OPT_PAGE_LOADED_SW].cap =
+      SANE_CAP_SOFT_DETECT | SANE_CAP_HARD_SELECT | SANE_CAP_ADVANCED;
+  else
+    s->opt[OPT_PAGE_LOADED_SW].cap = SANE_CAP_INACTIVE;
+  s->val[OPT_PAGE_LOADED_SW].b = 0;
+
+  /* button group */
+  s->opt[OPT_BUTTON_GROUP].name = "Buttons";
+  s->opt[OPT_BUTTON_GROUP].title = SANE_I18N ("Buttons");
+  s->opt[OPT_BUTTON_GROUP].desc = SANE_I18N ("Buttons");
+  s->opt[OPT_BUTTON_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_BUTTON_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* calibrate button */
+  s->opt[OPT_CALIBRATE].name = "calibrate";
+  s->opt[OPT_CALIBRATE].title = SANE_I18N ("Calibrate");
+  s->opt[OPT_CALIBRATE].desc =
+    SANE_I18N ("Start calibration using special sheet");
+  s->opt[OPT_CALIBRATE].type = SANE_TYPE_BUTTON;
+  s->opt[OPT_CALIBRATE].unit = SANE_UNIT_NONE;
+  if (s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE)
+  s->opt[OPT_CALIBRATE].cap =
+      SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_ADVANCED |
+      SANE_CAP_AUTOMATIC;
+  else
+    s->opt[OPT_CALIBRATE].cap = SANE_CAP_INACTIVE;
+  s->val[OPT_CALIBRATE].b = 0;
+
+  /* clear calibration cache button */
+  s->opt[OPT_CLEAR_CALIBRATION].name = "clear";
+  s->opt[OPT_CLEAR_CALIBRATION].title = SANE_I18N ("Clear calibration");
+  s->opt[OPT_CLEAR_CALIBRATION].desc = SANE_I18N ("Clear calibration cache");
+  s->opt[OPT_CLEAR_CALIBRATION].type = SANE_TYPE_BUTTON;
+  s->opt[OPT_CLEAR_CALIBRATION].unit = SANE_UNIT_NONE;
+  if (s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE)
+  s->opt[OPT_CLEAR_CALIBRATION].cap =
+    SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT | SANE_CAP_ADVANCED |
+    SANE_CAP_AUTOMATIC;
+  else
+    s->opt[OPT_CLEAR_CALIBRATION].cap = SANE_CAP_INACTIVE;
+  s->val[OPT_CLEAR_CALIBRATION].b = 0;
+
+
+  RIE (calc_parameters (s));
+
+  DBG (5, "init_options: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+attach (SANE_String_Const devname, GT68xx_Device ** devp, SANE_Bool may_wait)
+{
+  GT68xx_Device *dev;
+  SANE_Status status;
+
+  DBG (5, "attach: start: devp %s NULL, may_wait = %d\n", devp ? "!=" : "==",
+       may_wait);
+  if (!devname)
+    {
+      DBG (1, "attach: devname == NULL\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  for (dev = first_dev; dev; dev = dev->next)
+    {
+      if (strcmp (dev->file_name, devname) == 0)
+        {
+          if (devp)
+            *devp = dev;
+          dev->missing = SANE_FALSE;
+          DBG (4, "attach: device `%s' was already in device list\n",
+               devname);
+          return SANE_STATUS_GOOD;
+        }
+    }
+
+  DBG (4, "attach: trying to open device `%s'\n", devname);
+  RIE (gt68xx_device_new (&dev));
+  status = gt68xx_device_open (dev, devname);
+  if (status == SANE_STATUS_GOOD)
+    DBG (4, "attach: device `%s' successfully opened\n", devname);
+  else
+    {
+      DBG (4, "attach: couldn't open device `%s': %s\n", devname,
+           sane_strstatus (status));
+      gt68xx_device_free (dev);
+      if (devp)
+        *devp = 0;
+      return status;
+    }
+
+  if (!gt68xx_device_is_configured (dev))
+    {
+      GT68xx_Model *model = NULL;
+      DBG (2, "attach: Warning: device `%s' is not listed in device table\n",
+           devname);
+      DBG (2,
+           "attach: If you have manually added it, use override in gt68xx.conf\n");
+      gt68xx_device_get_model ("unknown-scanner", &model);
+      status = gt68xx_device_set_model (dev, model);
+      if (status != SANE_STATUS_GOOD)
+        {
+          DBG (4, "attach: couldn't set model: %s\n",
+               sane_strstatus (status));
+          gt68xx_device_free (dev);
+          if (devp)
+            *devp = 0;
+          return status;
+        }
+      dev->manual_selection = SANE_TRUE;
+    }
+
+  dev->file_name = strdup (devname);
+  dev->missing = SANE_FALSE;
+  if (!dev->file_name)
+    return SANE_STATUS_NO_MEM;
+  DBG (2, "attach: found %s flatbed scanner %s at %s\n", dev->model->vendor,
+       dev->model->model, dev->file_name);
+  ++num_devices;
+  dev->next = first_dev;
+  first_dev = dev;
+
+  if (devp)
+    *devp = dev;
+  gt68xx_device_close (dev);
+  DBG (5, "attach: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+attach_one_device (SANE_String_Const devname)
+{
+  GT68xx_Device *dev;
+  SANE_Status status;
+
+  RIE (attach (devname, &dev, SANE_FALSE));
+
+  if (dev)
+    {
+      /* Keep track of newly attached devices so we can set options as
+         necessary.  */
+      if (new_dev_len >= new_dev_alloced)
+        {
+          new_dev_alloced += 4;
+          if (new_dev)
+            new_dev =
+              realloc (new_dev, new_dev_alloced * sizeof (new_dev[0]));
+          else
+            new_dev = malloc (new_dev_alloced * sizeof (new_dev[0]));
+          if (!new_dev)
+            {
+              DBG (1, "attach_one_device: out of memory\n");
+              return SANE_STATUS_NO_MEM;
+            }
+        }
+      new_dev[new_dev_len++] = dev;
+    }
+  return SANE_STATUS_GOOD;
+}
+
+#if defined(_WIN32) || defined(HAVE_OS2_H)
+# define PATH_SEP       "\\"
+#else
+# define PATH_SEP       "/"
+#endif
+
+static SANE_Status
+download_firmware_file (GT68xx_Device * dev)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+  SANE_Byte *buf = NULL;
+  int size = -1;
+  SANE_Char filename[PATH_MAX], dirname[PATH_MAX], basename[PATH_MAX];
+  FILE *f;
+
+  if (strncmp (dev->model->firmware_name, PATH_SEP, 1) != 0)
+    {
+      /* probably filename only */
+      snprintf (filename, PATH_MAX, "%s%s%s%s%s%s%s",
+                STRINGIFY (PATH_SANE_DATA_DIR),
+                PATH_SEP, "sane", PATH_SEP, "gt68xx", PATH_SEP,
+                dev->model->firmware_name);
+      snprintf (dirname, PATH_MAX, "%s%s%s%s%s",
+                STRINGIFY (PATH_SANE_DATA_DIR),
+                PATH_SEP, "sane", PATH_SEP, "gt68xx");
+      strncpy (basename, dev->model->firmware_name, PATH_MAX);
+    }
+  else
+    {
+      /* absolute path */
+      char *pos;
+      strncpy (filename, dev->model->firmware_name, PATH_MAX);
+      strncpy (dirname, dev->model->firmware_name, PATH_MAX);
+      pos = strrchr (dirname, PATH_SEP[0]);
+      if (pos)
+        pos[0] = '\0';
+      strncpy (basename, pos + 1, PATH_MAX);
+    }
+
+  /* first, try to open with exact case */
+  DBG (5, "download_firmware: trying %s\n", filename);
+  f = fopen (filename, "rb");
+  if (!f)
+    {
+      /* and now any case */
+      DIR *dir;
+      struct dirent *direntry;
+
+      DBG (5,
+           "download_firmware_file: Couldn't open firmware file `%s': %s\n",
+           filename, strerror (errno));
+
+      dir = opendir (dirname);
+      if (!dir)
+        {
+          DBG (5, "download_firmware: couldn't open directory `%s': %s\n",
+               dirname, strerror (errno));
+          status = SANE_STATUS_INVAL;
+        }
+      if (status == SANE_STATUS_GOOD)
+        {
+          do
+            {
+              direntry = readdir (dir);
+              if (direntry
+                  && (strncasecmp (direntry->d_name, basename, PATH_MAX) ==
+                      0))
+                {
+                  snprintf (filename, PATH_MAX, "%s%s%s",
+                            dirname, PATH_SEP, direntry->d_name);
+                  break;
+                }
+            }
+          while (direntry != 0);
+          if (direntry == 0)
+            {
+              DBG (5, "download_firmware: file `%s' not found\n", filename);
+              status = SANE_STATUS_INVAL;
+            }
+          closedir (dir);
+        }
+      if (status == SANE_STATUS_GOOD)
+        {
+          DBG (5, "download_firmware: trying %s\n", filename);
+          f = fopen (filename, "rb");
+          if (!f)
+            {
+              DBG (5,
+                   "download_firmware_file: Couldn't open firmware file `%s': %s\n",
+                   filename, strerror (errno));
+              status = SANE_STATUS_INVAL;
+            }
+        }
+
+      if (status != SANE_STATUS_GOOD)
+        {
+          DBG (0, "Couldn't open firmware file (`%s'): %s\n",
+               filename, strerror (errno));
+        }
+    }
+
+  if (status == SANE_STATUS_GOOD)
+    {
+      fseek (f, 0, SEEK_END);
+      size = ftell (f);
+      fseek (f, 0, SEEK_SET);
+      if (size == -1)
+        {
+          DBG (1, "download_firmware_file: error getting size of "
+               "firmware file \"%s\": %s\n", filename, strerror (errno));
+          status = SANE_STATUS_INVAL;
+        }
+    }
+
+  if (status == SANE_STATUS_GOOD)
+    {
+      DBG (5, "firmware size: %d\n", size);
+      buf = (SANE_Byte *) malloc (size);
+      if (!buf)
+        {
+          DBG (1, "download_firmware_file: cannot allocate %d bytes "
+               "for firmware\n", size);
+          status = SANE_STATUS_NO_MEM;
+        }
+    }
+
+  if (status == SANE_STATUS_GOOD)
+    {
+      int bytes_read = fread (buf, 1, size, f);
+      if (bytes_read != size)
+        {
+          DBG (1, "download_firmware_file: problem reading firmware "
+               "file \"%s\": %s\n", filename, strerror (errno));
+          status = SANE_STATUS_INVAL;
+        }
+    }
+
+  if (f)
+    fclose (f);
+
+  if (status == SANE_STATUS_GOOD)
+    {
+      status = gt68xx_device_download_firmware (dev, buf, size);
+      if (status != SANE_STATUS_GOOD)
+        {
+          DBG (1, "download_firmware_file: firmware download failed: %s\n",
+               sane_strstatus (status));
+        }
+    }
+
+  if (buf)
+    free (buf);
+
+  return status;
+}
+
+/** probe for gt68xx devices
+ * This function scan usb and try to attached to scanner
+ * configured in gt68xx.conf .
+ */
+static SANE_Status probe_gt68xx_devices(void)
+{
+  SANE_Char line[PATH_MAX];
+  SANE_Char *word;
+  SANE_String_Const cp;
+  SANE_Int linenumber;
+  GT68xx_Device *dev;
+  FILE *fp;
+
+  /* set up for no new devices detected at first */
+  new_dev = 0;
+  new_dev_len = 0;
+  new_dev_alloced = 0;
+
+  /* mark already detected devices as missing, during device probe
+   * detected devices will clear this flag */
+  dev = first_dev;
+  while(dev!=NULL)
+    {
+      dev->missing = SANE_TRUE;
+      dev = dev->next;
+    }
+
+  fp = sanei_config_open (GT68XX_CONFIG_FILE);
+  if (!fp)
+    {
+      /* default to /dev/usb/scanner instead of insisting on config file */
+      DBG (3, "sane_init: couldn't open config file `%s': %s. Using "
+           "/dev/usb/scanner directly\n", GT68XX_CONFIG_FILE,
+           strerror (errno));
+      attach ("/dev/usb/scanner", 0, SANE_FALSE);
+      return SANE_STATUS_GOOD;
+    }
+
+  little_endian = calc_little_endian ();
+  DBG (5, "sane_init: %s endian machine\n", little_endian ? "little" : "big");
+
+  linenumber = 0;
+  DBG (4, "sane_init: reading config file `%s'\n", GT68XX_CONFIG_FILE);
+  while (sanei_config_read (line, sizeof (line), fp))
+    {
+      word = 0;
+      linenumber++;
+
+      cp = sanei_config_get_string (line, &word);
+      if (!word || cp == line)
+        {
+          DBG (6, "sane_init: config file line %d: ignoring empty line\n",
+               linenumber);
+          if (word)
+            free (word);
+          continue;
+        }
+      if (word[0] == '#')
+        {
+          DBG (6, "sane_init: config file line %d: ignoring comment line\n",
+               linenumber);
+          free (word);
+          continue;
+        }
+
+      if (strcmp (word, "firmware") == 0)
+        {
+          free (word);
+          word = 0;
+          cp = sanei_config_get_string (cp, &word);
+          if (word)
+            {
+              int i;
+              for (i = 0; i < new_dev_len; i++)
+                {
+                  new_dev[i]->model->firmware_name = word;
+                  DBG (5, "sane_init: device %s: firmware will be loaded "
+                       "from %s\n", new_dev[i]->model->name,
+                       new_dev[i]->model->firmware_name);
+                }
+              if (i == 0)
+                DBG (5, "sane_init: firmware %s can't be loaded, set device "
+                     "first\n", word);
+            }
+          else
+            {
+              DBG (3, "sane_init: option `firmware' needs a parameter\n");
+            }
+        }
+      else if (strcmp (word, "vendor") == 0)
+        {
+          free (word);
+          word = 0;
+          cp = sanei_config_get_string (cp, &word);
+          if (word)
+            {
+              int i;
+
+              for (i = 0; i < new_dev_len; i++)
+                {
+                  new_dev[i]->model->vendor = word;
+                  DBG (5, "sane_init: device %s: vendor name set to %s\n",
+                       new_dev[i]->model->name, new_dev[i]->model->vendor);
+                }
+              if (i == 0)
+                DBG (5, "sane_init: can't set vendor name %s, set device "
+                     "first\n", word);
+            }
+          else
+            {
+              DBG (3, "sane_init: option `vendor' needs a parameter\n");
+            }
+        }
+      else if (strcmp (word, "model") == 0)
+        {
+          free (word);
+          word = 0;
+          cp = sanei_config_get_string (cp, &word);
+          if (word)
+            {
+              int i;
+              for (i = 0; i < new_dev_len; i++)
+                {
+                  new_dev[i]->model->model = word;
+                  DBG (5, "sane_init: device %s: model name set to %s\n",
+                       new_dev[i]->model->name, new_dev[i]->model->model);
+                }
+              if (i == 0)
+                DBG (5, "sane_init: can't set model name %s, set device "
+                     "first\n", word);
+              free (word);
+            }
+          else
+            {
+              DBG (3, "sane_init: option `model' needs a parameter\n");
+            }
+        }
+      else if (strcmp (word, "override") == 0)
+        {
+          free (word);
+          word = 0;
+          cp = sanei_config_get_string (cp, &word);
+          if (word)
+            {
+              int i;
+              for (i = 0; i < new_dev_len; i++)
+                {
+                  SANE_Status status;
+                  GT68xx_Device *dev = new_dev[i];
+                  GT68xx_Model *model;
+                  if (gt68xx_device_get_model (word, &model) == SANE_TRUE)
+                    {
+                      status = gt68xx_device_set_model (dev, model);
+                      if (status != SANE_STATUS_GOOD)
+                        DBG (1, "sane_init: couldn't override model: %s\n",
+                             sane_strstatus (status));
+                      else
+                        DBG (5, "sane_init: new model set to %s\n",
+                             dev->model->name);
+                    }
+                  else
+                    {
+                      DBG (1, "sane_init: override: model %s not found\n",
+                           word);
+                    }
+                }
+              if (i == 0)
+                DBG (5, "sane_init: can't override model to %s, set device "
+                     "first\n", word);
+              free (word);
+            }
+          else
+            {
+              DBG (3, "sane_init: option `override' needs a parameter\n");
+            }
+        }
+      else if (strcmp (word, "afe") == 0)
+        {
+          GT68xx_AFE_Parameters afe = {0, 0, 0, 0, 0, 0};
+          SANE_Status status;
+
+          free (word);
+          word = 0;
+
+          status = get_afe_values (cp, &afe);
+          if (status == SANE_STATUS_GOOD)
+            {
+              int i;
+              for (i = 0; i < new_dev_len; i++)
+                {
+                  new_dev[i]->model->afe_params = afe;
+                  DBG (5, "sane_init: device %s: setting new afe values\n",
+                       new_dev[i]->model->name);
+                }
+              if (i == 0)
+                DBG (5,
+                     "sane_init: can't set afe values, set device first\n");
+            }
+          else
+            DBG (3, "sane_init: can't set afe values\n");
+        }
+      else
+        {
+          new_dev_len = 0;
+          DBG (4, "sane_init: config file line %d: trying to attach `%s'\n",
+               linenumber, line);
+          sanei_usb_attach_matching_devices (line, attach_one_device);
+          if (word)
+            free (word);
+          word = 0;
+        }
+    }
+
+  if (new_dev_alloced > 0)
+    {
+      new_dev_len = new_dev_alloced = 0;
+      free (new_dev);
+    }
+
+  fclose (fp);
+  return SANE_STATUS_GOOD;
+}
+
+/* -------------------------- SANE API functions ------------------------- */
+
+SANE_Status
+sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
+{
+  SANE_Status status;
+
+  DBG_INIT ();
+#ifdef DBG_LEVEL
+  if (DBG_LEVEL > 0)
+    {
+      DBG (5, "sane_init: debug options are enabled, handle with care\n");
+      debug_options = SANE_TRUE;
+    }
+#endif
+  DBG (2, "SANE GT68xx backend version %d.%d build %d from %s\n", SANE_CURRENT_MAJOR,
+       V_MINOR, BUILD, PACKAGE_STRING);
+
+  if (version_code)
+    *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, BUILD);
+
+  DBG (5, "sane_init: authorize %s null\n", authorize ? "!=" : "==");
+
+  sanei_usb_init ();
+
+  num_devices = 0;
+  first_dev = 0;
+  first_handle = 0;
+  devlist = 0;
+  new_dev = 0;
+  new_dev_len = 0;
+  new_dev_alloced = 0;
+
+  status = probe_gt68xx_devices ();
+  DBG (5, "sane_init: exit\n");
+
+  return status;
+}
+
+void
+sane_exit (void)
+{
+  GT68xx_Device *dev, *next;
+
+  DBG (5, "sane_exit: start\n");
+  sanei_usb_exit();
+  for (dev = first_dev; dev; dev = next)
+    {
+      next = dev->next;
+      gt68xx_device_free (dev);
+    }
+  first_dev = 0;
+  first_handle = 0;
+  if (devlist)
+    free (devlist);
+  devlist = 0;
+
+  DBG (5, "sane_exit: exit\n");
+}
+
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
+{
+  GT68xx_Device *dev;
+  SANE_Int dev_num;
+
+  DBG (5, "sane_get_devices: start: local_only = %s\n",
+       local_only == SANE_TRUE ? "true" : "false");
+
+  /* hot-plug case : detection of newly connected scanners */
+  sanei_usb_scan_devices ();
+  probe_gt68xx_devices ();
+
+  if (devlist)
+    free (devlist);
+
+  devlist = malloc ((num_devices + 1) * sizeof (devlist[0]));
+  if (!devlist)
+    return SANE_STATUS_NO_MEM;
+
+  dev_num = 0;
+  dev = first_dev;
+  while(dev!=NULL)
+    {
+      SANE_Device *sane_device;
+
+      /* don't return devices that have been unplugged */
+      if(dev->missing==SANE_FALSE)
+        {
+          sane_device = malloc (sizeof (*sane_device));
+          if (!sane_device)
+            return SANE_STATUS_NO_MEM;
+          sane_device->name = dev->file_name;
+          sane_device->vendor = dev->model->vendor;
+          sane_device->model = dev->model->model;
+          sane_device->type = strdup ("flatbed scanner");
+          devlist[dev_num] = sane_device;
+          dev_num++;
+        }
+
+      /* next device */
+      dev = dev->next;
+    }
+  devlist[dev_num] = 0;
+
+  *device_list = devlist;
+
+  DBG (5, "sane_get_devices: exit\n");
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_open (SANE_String_Const devicename, SANE_Handle * handle)
+{
+  GT68xx_Device *dev;
+  SANE_Status status;
+  GT68xx_Scanner *s;
+  SANE_Bool power_ok;
+
+  DBG (5, "sane_open: start (devicename = `%s')\n", devicename);
+
+  if (devicename[0])
+    {
+      /* test for gt68xx short hand name */
+      if(strcmp(devicename,"gt68xx")!=0)
+        {
+          for (dev = first_dev; dev; dev = dev->next)
+            if (strcmp (dev->file_name, devicename) == 0)
+              break;
+
+          if (!dev)
+            {
+              DBG (5, "sane_open: couldn't find `%s' in devlist, trying attach\n",
+                   devicename);
+              RIE (attach (devicename, &dev, SANE_TRUE));
+            }
+          else
+            DBG (5, "sane_open: found `%s' in devlist\n", dev->model->name);
+        }
+      else
+        {
+          dev = first_dev;
+          if (dev)
+            {
+              devicename = dev->file_name;
+              DBG (5, "sane_open: default empty devicename, using first device `%s'\n", devicename);
+            }
+        }
+    }
+  else
+    {
+      /* empty devicname -> use first device */
+      dev = first_dev;
+      if (dev)
+        {
+          devicename = dev->file_name;
+          DBG (5, "sane_open: empty devicename, trying `%s'\n", devicename);
+        }
+    }
+
+  if (!dev)
+    return SANE_STATUS_INVAL;
+
+  RIE (gt68xx_device_open (dev, devicename));
+  RIE (gt68xx_device_activate (dev));
+
+  if (dev->model->flags & GT68XX_FLAG_UNTESTED)
+    {
+      DBG (0, "WARNING: Your scanner is not fully supported or at least \n");
+      DBG (0, "         had only limited testing. Please be careful and \n");
+      DBG (0, "         report any failure/success to \n");
+      DBG (0, "         sane-devel@lists.alioth.debian.org. Please provide as many\n");
+      DBG (0, "         details as possible, e.g. the exact name of your\n");
+      DBG (0, "         scanner and what does (not) work.\n");
+    }
+
+  if (dev->manual_selection)
+    {
+      DBG (0, "WARNING: You have manually added the ids of your scanner \n");
+      DBG (0,
+           "         to gt68xx.conf. Please use an appropriate override \n");
+      DBG (0,
+           "         for your scanner. Use extreme care and switch off \n");
+      DBG (0,
+           "         the scanner immediately if you hear unusual noise. \n");
+      DBG (0, "         Please report any success to \n");
+      DBG (0, "         sane-devel@lists.alioth.debian.org. Please provide as many\n");
+      DBG (0, "         details as possible, e.g. the exact name of your\n");
+      DBG (0, "         scanner, ids, settings etc.\n");
+
+      if (strcmp (dev->model->name, "unknown-scanner") == 0)
+        {
+          GT68xx_USB_Device_Entry *entry;
+
+          DBG (0,
+               "ERROR: You haven't chosen an override in gt68xx.conf. Please use \n");
+          DBG (0, "       one of the following: \n");
+
+          for (entry = gt68xx_usb_device_list; entry->model; ++entry)
+            {
+              if (strcmp (entry->model->name, "unknown-scanner") != 0)
+                DBG (0, "       %s\n", entry->model->name);
+            }
+          return SANE_STATUS_UNSUPPORTED;
+        }
+    }
+
+  /* The firmware check is disabled by default because it may confuse
+     some scanners: So the firmware is loaded everytime. */
+#if 0
+  RIE (gt68xx_device_check_firmware (dev, &firmware_loaded));
+  firmware_loaded = SANE_FALSE;
+  if (firmware_loaded)
+    DBG (3, "sane_open: firmware already loaded, skipping load\n");
+  else
+    RIE (download_firmware_file (dev));
+  /*  RIE (gt68xx_device_check_firmware (dev, &firmware_loaded)); */
+  if (!firmware_loaded)
+    {
+      DBG (1, "sane_open: firmware still not loaded? Proceeding anyway\n");
+      /* return SANE_STATUS_IO_ERROR; */
+    }
+#else
+  RIE (download_firmware_file (dev));
+#endif
+
+  RIE (gt68xx_device_get_id (dev));
+
+  if (!(dev->model->flags & GT68XX_FLAG_NO_STOP))
+    RIE (gt68xx_device_stop_scan (dev));
+
+  RIE (gt68xx_device_get_power_status (dev, &power_ok));
+  if (power_ok)
+    {
+      DBG (5, "sane_open: power ok\n");
+    }
+  else
+    {
+      DBG (0, "sane_open: power control failure: check power plug!\n");
+      return SANE_STATUS_IO_ERROR;
+    }
+
+  RIE (gt68xx_scanner_new (dev, &s));
+  RIE (gt68xx_device_lamp_control (s->dev, SANE_TRUE, SANE_FALSE));
+  gettimeofday (&s->lamp_on_time, 0);
+
+  /* insert newly opened handle into list of open handles: */
+  s->next = first_handle;
+  first_handle = s;
+  *handle = s;
+  s->scanning = SANE_FALSE;
+  s->first_scan = SANE_TRUE;
+  s->gamma_table = 0;
+  s->calibrated = SANE_FALSE;
+  RIE (init_options (s));
+  dev->gray_mode_color = 0x02;
+
+  /* try to restore calibration from file */
+  if((s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE))
+    {
+      /* error restoring calibration is non blocking */
+      gt68xx_read_calibration(s);
+    }
+
+  DBG (5, "sane_open: exit\n");
+
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_close (SANE_Handle handle)
+{
+  GT68xx_Scanner *prev, *s;
+  GT68xx_Device *dev;
+
+  DBG (5, "sane_close: start\n");
+
+  /* remove handle from list of open handles: */
+  prev = 0;
+  for (s = first_handle; s; s = s->next)
+    {
+      if (s == handle)
+        break;
+      prev = s;
+    }
+  if (!s)
+    {
+      DBG (5, "close: invalid handle %p\n", handle);
+      return;                   /* oops, not a handle we know about */
+    }
+
+  if (prev)
+    prev->next = s->next;
+  else
+    first_handle = s->next;
+
+  if (s->val[OPT_LAMP_OFF_AT_EXIT].w == SANE_TRUE)
+    gt68xx_device_lamp_control (s->dev, SANE_FALSE, SANE_FALSE);
+
+  dev = s->dev;
+  
+  free (s->val[OPT_MODE].s);
+  free (s->val[OPT_GRAY_MODE_COLOR].s);
+  free (s->val[OPT_SOURCE].s);
+  free (dev->file_name);
+  free ((void *)(size_t)s->opt[OPT_RESOLUTION].constraint.word_list);
+
+  gt68xx_scanner_free (s);
+  
+  gt68xx_device_fix_descriptor (dev);
+
+  gt68xx_device_deactivate (dev);
+  gt68xx_device_close (dev);
+
+  DBG (5, "sane_close: exit\n");
+}
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+  GT68xx_Scanner *s = handle;
+
+  if ((unsigned) option >= NUM_OPTIONS)
+    return 0;
+  DBG (5, "sane_get_option_descriptor: option = %s (%d)\n",
+       s->opt[option].name, option);
+  return s->opt + option;
+}
+
+SANE_Status
+sane_control_option (SANE_Handle handle, SANE_Int option,
+                     SANE_Action action, void *val, SANE_Int * info)
+{
+  GT68xx_Scanner *s = handle;
+  SANE_Status status = SANE_STATUS_GOOD;
+  SANE_Word cap;
+  SANE_Int myinfo = 0;
+
+  DBG (5, "sane_control_option: start: action = %s, option = %s (%d)\n",
+       (action == SANE_ACTION_GET_VALUE) ? "get" :
+       (action == SANE_ACTION_SET_VALUE) ? "set" :
+       (action == SANE_ACTION_SET_AUTO) ? "set_auto" : "unknown",
+       s->opt[option].name, option);
+
+  if (info)
+    *info = 0;
+
+  if (s->scanning)
+    {
+      DBG (1, "sane_control_option: don't call this function while "
+           "scanning (option = %s (%d))\n", s->opt[option].name, option);
+
+      return SANE_STATUS_DEVICE_BUSY;
+    }
+  if (option >= NUM_OPTIONS || option < 0)
+    {
+      DBG (1, "sane_control_option: option %d >= NUM_OPTIONS || option < 0\n",
+           option);
+      return SANE_STATUS_INVAL;
+    }
+
+  cap = s->opt[option].cap;
+
+  if (!SANE_OPTION_IS_ACTIVE (cap))
+    {
+      DBG (2, "sane_control_option: option %d is inactive\n", option);
+      return SANE_STATUS_INVAL;
+    }
+
+  if (action == SANE_ACTION_GET_VALUE)
+    {
+      switch (option)
+        {
+          /* word options: */
+        case OPT_NUM_OPTS:
+        case OPT_RESOLUTION:
+        case OPT_BIT_DEPTH:
+        case OPT_FULL_SCAN:
+        case OPT_COARSE_CAL:
+        case OPT_COARSE_CAL_ONCE:
+        case OPT_QUALITY_CAL:
+        case OPT_BACKTRACK:
+        case OPT_BACKTRACK_LINES:
+        case OPT_PREVIEW:
+        case OPT_LAMP_OFF_AT_EXIT:
+        case OPT_AUTO_WARMUP:
+        case OPT_GAMMA_VALUE:
+        case OPT_THRESHOLD:
+        case OPT_TL_X:
+        case OPT_TL_Y:
+        case OPT_BR_X:
+        case OPT_BR_Y:
+          *(SANE_Word *) val = s->val[option].w;
+          break;
+          /* string options: */
+        case OPT_MODE:
+        case OPT_GRAY_MODE_COLOR:
+        case OPT_SOURCE:
+          strcpy (val, s->val[option].s);
+          break;
+        case OPT_NEED_CALIBRATION_SW:
+          *(SANE_Bool *) val = !s->calibrated;
+          break;
+        case OPT_PAGE_LOADED_SW:
+          s->dev->model->command_set->document_present (s->dev, val);
+          break;
+        default:
+          DBG (2, "sane_control_option: can't get unknown option %d\n",
+               option);
+        }
+    }
+  else if (action == SANE_ACTION_SET_VALUE)
+    {
+      if (!SANE_OPTION_IS_SETTABLE (cap))
+        {
+          DBG (2, "sane_control_option: option %d is not settable\n", option);
+          return SANE_STATUS_INVAL;
+        }
+
+      status = sanei_constrain_value (s->opt + option, val, &myinfo);
+
+      if (status != SANE_STATUS_GOOD)
+        {
+          DBG (2, "sane_control_option: sanei_constrain_value returned %s\n",
+               sane_strstatus (status));
+          return status;
+        }
+
+      switch (option)
+        {
+        case OPT_RESOLUTION:
+        case OPT_BIT_DEPTH:
+        case OPT_FULL_SCAN:
+        case OPT_PREVIEW:
+        case OPT_TL_X:
+        case OPT_TL_Y:
+        case OPT_BR_X:
+        case OPT_BR_Y:
+          s->val[option].w = *(SANE_Word *) val;
+          RIE (calc_parameters (s));
+          myinfo |= SANE_INFO_RELOAD_PARAMS;
+          break;
+        case OPT_LAMP_OFF_AT_EXIT:
+        case OPT_AUTO_WARMUP:
+        case OPT_COARSE_CAL_ONCE:
+        case OPT_BACKTRACK_LINES:
+        case OPT_QUALITY_CAL:
+        case OPT_GAMMA_VALUE:
+        case OPT_THRESHOLD:
+          s->val[option].w = *(SANE_Word *) val;
+          break;
+        case OPT_GRAY_MODE_COLOR:
+          if (strcmp (s->val[option].s, val) != 0)
+            {                   /* something changed */
+              if (s->val[option].s)
+                free (s->val[option].s);
+              s->val[option].s = strdup (val);
+            }
+          break;
+        case OPT_SOURCE:
+          if (strcmp (s->val[option].s, val) != 0)
+            {                   /* something changed */
+              if (s->val[option].s)
+                free (s->val[option].s);
+              s->val[option].s = strdup (val);
+              if (strcmp (s->val[option].s, "Transparency Adapter") == 0)
+                {
+                  RIE (gt68xx_device_lamp_control
+                       (s->dev, SANE_FALSE, SANE_TRUE));
+                  x_range.max = s->dev->model->x_size_ta;
+                  y_range.max = s->dev->model->y_size_ta;
+                }
+              else
+                {
+                  RIE (gt68xx_device_lamp_control
+                       (s->dev, SANE_TRUE, SANE_FALSE));
+                  x_range.max = s->dev->model->x_size;
+                  y_range.max = s->dev->model->y_size;
+                }
+              s->first_scan = SANE_TRUE;
+              myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+              gettimeofday (&s->lamp_on_time, 0);
+            }
+          break;
+        case OPT_MODE:
+          if (s->val[option].s)
+            free (s->val[option].s);
+          s->val[option].s = strdup (val);
+          if (strcmp (s->val[option].s, SANE_VALUE_SCAN_MODE_LINEART) == 0)
+            {
+              ENABLE (OPT_THRESHOLD);
+              DISABLE (OPT_BIT_DEPTH);
+              ENABLE (OPT_GRAY_MODE_COLOR);
+            }
+          else
+            {
+              DISABLE (OPT_THRESHOLD);
+              if (strcmp (s->val[option].s, SANE_VALUE_SCAN_MODE_GRAY) == 0)
+                {
+                  RIE (create_bpp_list (s, s->dev->model->bpp_gray_values));
+                  ENABLE (OPT_GRAY_MODE_COLOR);
+                }
+              else
+                {
+                  RIE (create_bpp_list (s, s->dev->model->bpp_color_values));
+                  DISABLE (OPT_GRAY_MODE_COLOR);
+                }
+              if (s->bpp_list[0] < 2)
+                DISABLE (OPT_BIT_DEPTH);
+              else
+                ENABLE (OPT_BIT_DEPTH);
+            }
+          RIE (calc_parameters (s));
+          myinfo |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+          break;
+
+        case OPT_COARSE_CAL:
+          s->val[option].w = *(SANE_Word *) val;
+          if (s->val[option].w == SANE_TRUE)
+            {
+              ENABLE (OPT_COARSE_CAL_ONCE);
+              s->first_scan = SANE_TRUE;
+            }
+          else
+            {
+              DISABLE (OPT_COARSE_CAL_ONCE);
+            }
+          myinfo |= SANE_INFO_RELOAD_OPTIONS;
+          break;
+
+        case OPT_BACKTRACK:
+          s->val[option].w = *(SANE_Word *) val;
+          if (s->val[option].w == SANE_TRUE)
+            ENABLE (OPT_BACKTRACK_LINES);
+          else
+            DISABLE (OPT_BACKTRACK_LINES);
+          myinfo |= SANE_INFO_RELOAD_OPTIONS;
+          break;
+
+        case OPT_CALIBRATE:
+          status = gt68xx_sheetfed_scanner_calibrate (s);
+          myinfo |= SANE_INFO_RELOAD_OPTIONS;
+          break;
+    
+        case OPT_CLEAR_CALIBRATION:
+          gt68xx_clear_calibration (s);
+          myinfo |= SANE_INFO_RELOAD_OPTIONS;
+          break;
+
+        default:
+          DBG (2, "sane_control_option: can't set unknown option %d\n",
+               option);
+        }
+    }
+  else
+    {
+      DBG (2, "sane_control_option: unknown action %d for option %d\n",
+           action, option);
+      return SANE_STATUS_INVAL;
+    }
+  if (info)
+    *info = myinfo;
+
+  DBG (5, "sane_control_option: exit\n");
+  return status;
+}
+
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
+{
+  GT68xx_Scanner *s = handle;
+  SANE_Status status;
+
+  DBG (5, "sane_get_parameters: start\n");
+
+  RIE (calc_parameters (s));
+  if (params)
+    *params = s->params;
+
+  DBG (4, "sane_get_parameters: format=%d, last_frame=%d, lines=%d\n",
+       s->params.format, s->params.last_frame, s->params.lines);
+  DBG (4, "sane_get_parameters: pixels_per_line=%d, bytes per line=%d\n",
+       s->params.pixels_per_line, s->params.bytes_per_line);
+  DBG (3, "sane_get_parameters: pixels %dx%dx%d\n",
+       s->params.pixels_per_line, s->params.lines, 1 << s->params.depth);
+
+  DBG (5, "sane_get_parameters: exit\n");
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+  GT68xx_Scanner *s = handle;
+  GT68xx_Scan_Request scan_request;
+  GT68xx_Scan_Parameters scan_params;
+  SANE_Status status;
+  SANE_Int i, gamma_size;
+  unsigned int *buffer_pointers[3];
+  SANE_Bool document;
+
+  DBG (5, "sane_start: start\n");
+
+  /* First make sure we have a current parameter set.  Some of the
+     parameters will be overwritten below, but that's OK.  */
+  RIE (calc_parameters (s));
+
+  if (s->val[OPT_TL_X].w >= s->val[OPT_BR_X].w)
+    {
+      DBG (0, "sane_start: top left x >= bottom right x --- exiting\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (s->val[OPT_TL_Y].w >= s->val[OPT_BR_Y].w)
+    {
+      DBG (0, "sane_start: top left y >= bottom right y --- exiting\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  if (strcmp (s->val[OPT_GRAY_MODE_COLOR].s, GT68XX_COLOR_BLUE) == 0)
+    s->dev->gray_mode_color = 0x01;
+  else if (strcmp (s->val[OPT_GRAY_MODE_COLOR].s, GT68XX_COLOR_GREEN) == 0)
+    s->dev->gray_mode_color = 0x02;
+  else
+    s->dev->gray_mode_color = 0x03;
+
+  setup_scan_request (s, &scan_request);
+  if (!s->first_scan && s->val[OPT_COARSE_CAL_ONCE].w == SANE_TRUE)
+    s->auto_afe = SANE_FALSE;
+  else
+    s->auto_afe = s->val[OPT_COARSE_CAL].w;
+
+  s->dev->gamma_value = s->val[OPT_GAMMA_VALUE].w;
+  gamma_size = s->params.depth == 16 ? 65536 : 256;
+  s->gamma_table = malloc (sizeof (SANE_Int) * gamma_size);
+  if (!s->gamma_table)
+    {
+      DBG (1, "sane_start: couldn't malloc %d bytes for gamma table\n",
+           gamma_size);
+      return SANE_STATUS_NO_MEM;
+    }
+  for (i = 0; i < gamma_size; i++)
+    {
+      s->gamma_table[i] =
+        (gamma_size - 1) * pow (((double) i + 1) / (gamma_size),
+                                1.0 / SANE_UNFIX (s->dev->gamma_value)) + 0.5;
+      if (s->gamma_table[i] > (gamma_size - 1))
+        s->gamma_table[i] = (gamma_size - 1);
+      if (s->gamma_table[i] < 0)
+        s->gamma_table[i] = 0;
+#if 0
+      printf ("%d %d\n", i, s->gamma_table[i]);
+#endif
+    }
+
+  if(!(s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE))
+    {
+      s->calib = s->val[OPT_QUALITY_CAL].w;
+    }
+
+  if (!(s->dev->model->flags & GT68XX_FLAG_NO_STOP))
+    RIE (gt68xx_device_stop_scan (s->dev));
+
+  if (!(s->dev->model->flags & GT68XX_FLAG_SHEET_FED))
+    RIE (gt68xx_device_carriage_home (s->dev));
+
+  gt68xx_scanner_wait_for_positioning (s);
+  gettimeofday (&s->start_time, 0);
+
+  if (s->val[OPT_BACKTRACK].w == SANE_TRUE)
+    scan_request.backtrack = SANE_TRUE;
+  else
+    {
+      if (s->val[OPT_RESOLUTION].w >= s->dev->model->ydpi_no_backtrack)
+        scan_request.backtrack = SANE_FALSE;
+      else
+        scan_request.backtrack = SANE_TRUE;
+    }
+
+  if (scan_request.backtrack)
+    scan_request.backtrack_lines = s->val[OPT_BACKTRACK_LINES].w;
+  else
+    scan_request.backtrack_lines = 0;
+
+  /* don't call calibration for scanners that use sheetfed_calibrate */
+  if(!(s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE))
+    {
+      RIE (gt68xx_scanner_calibrate (s, &scan_request));
+    }
+  else
+    {
+      s->calib = s->calibrated;
+    }
+
+  /* is possible, wait for document to be inserted before scanning */
+  /* wait for 5 secondes max */
+  if (s->dev->model->flags & GT68XX_FLAG_SHEET_FED
+   && s->dev->model->command_set->document_present)
+    {
+      i=0;
+      do
+        {
+          RIE(s->dev->model->command_set->document_present(s->dev,&document));
+          if(document==SANE_FALSE)
+            {
+              i++;
+              sleep(1);
+            }
+        } while ((i<5) && (document==SANE_FALSE));
+      if(document==SANE_FALSE)
+        {
+          DBG (4, "sane_start: no doucment detected after %d s\n",i);
+          return SANE_STATUS_NO_DOCS;
+        }
+    }
+
+  /* some sheetfed scanners need a special operation to move
+   * paper before starting real scan */
+  if (s->dev->model->flags & GT68XX_FLAG_SHEET_FED)
+    {
+      RIE (gt68xx_sheetfed_move_to_scan_area (s, &scan_request));
+    }
+
+  /* restore calibration */
+  if(  (s->dev->model->flags & GT68XX_FLAG_HAS_CALIBRATE)
+     &&(s->calibrated == SANE_TRUE))
+    {
+      /* compute scan parameters */
+      scan_request.calculate = SANE_TRUE;
+      gt68xx_device_setup_scan (s->dev, &scan_request, SA_SCAN, &scan_params); 
+
+      /* restore settings from calibration stored */
+      memcpy(s->dev->afe,&(s->afe_params), sizeof(GT68xx_AFE_Parameters));
+      RIE (gt68xx_assign_calibration (s, scan_params));
+      scan_request.calculate = SANE_FALSE;
+    }
+ 
+  /* send scan request to the scanner */
+  RIE (gt68xx_scanner_start_scan (s, &scan_request, &scan_params));
+
+  for (i = 0; i < scan_params.overscan_lines; ++i)
+    RIE (gt68xx_scanner_read_line (s, buffer_pointers));
+  DBG (4, "sane_start: wanted: dpi=%d, x=%.1f, y=%.1f, width=%.1f, "
+       "height=%.1f, color=%s\n", scan_request.xdpi,
+       SANE_UNFIX (scan_request.x0),
+       SANE_UNFIX (scan_request.y0), SANE_UNFIX (scan_request.xs),
+       SANE_UNFIX (scan_request.ys), scan_request.color ? "color" : "gray");
+
+  s->line = 0;
+  s->byte_count = s->reader->params.pixel_xs;
+  s->total_bytes = 0;
+  s->first_scan = SANE_FALSE;
+
+#ifdef DEBUG_BRIGHTNESS
+  s->average_white = 0;
+  s->max_white = 0;
+  s->min_black = 255;
+#endif
+
+  s->scanning = SANE_TRUE;
+
+  DBG (5, "sane_start: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
+           SANE_Int * len)
+{
+  GT68xx_Scanner *s = handle;
+  SANE_Status status;
+  static unsigned int *buffer_pointers[3];
+  SANE_Int inflate_x;
+  SANE_Bool lineart;
+  SANE_Int i, color, colors;
+
+  if (!s)
+    {
+      DBG (1, "sane_read: handle is null!\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  if (!buf)
+    {
+      DBG (1, "sane_read: buf is null!\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  if (!len)
+    {
+      DBG (1, "sane_read: len is null!\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  *len = 0;
+
+  if (!s->scanning)
+    {
+      DBG (3, "sane_read: scan was cancelled, is over or has not been "
+           "initiated yet\n");
+      return SANE_STATUS_CANCELLED;
+    }
+
+  DBG (5, "sane_read: start (line %d of %d, byte_count %d of %d)\n",
+       s->line, s->reader->params.pixel_ys, s->byte_count,
+       s->reader->params.pixel_xs);
+
+  if (s->line >= s->reader->params.pixel_ys
+      && s->byte_count >= s->reader->params.pixel_xs)
+    {
+      DBG (4, "sane_read: nothing more to scan: EOF\n");
+      return SANE_STATUS_EOF;
+    }
+
+  inflate_x = s->val[OPT_RESOLUTION].w / s->dev->model->optical_xdpi;
+  if (inflate_x > 1)
+    DBG (5, "sane_read: inflating x by factor %d\n", inflate_x);
+  else
+    inflate_x = 1;
+
+  lineart = (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) == 0)
+    ? SANE_TRUE : SANE_FALSE;
+
+  if (s->reader->params.color)
+    colors = 3;
+  else
+    colors = 1;
+
+  while ((*len) < max_len)
+    {
+      if (s->byte_count >= s->reader->params.pixel_xs)
+        {
+          if (s->line >= s->reader->params.pixel_ys)
+            {
+              DBG (4, "sane_read: scan complete: %d bytes, %d total\n",
+                   *len, s->total_bytes);
+              return SANE_STATUS_GOOD;
+            }
+          DBG (5, "sane_read: getting line %d of %d\n", s->line,
+               s->reader->params.pixel_ys);
+          RIE (gt68xx_scanner_read_line (s, buffer_pointers));
+          s->line++;
+          s->byte_count = 0;
+
+          /* Apply gamma */
+          for (color = 0; color < colors; color++)
+            for (i = 0; i < s->reader->pixels_per_line; i++)
+              {
+                if (s->reader->params.depth > 8)
+                  buffer_pointers[color][i] =
+                    s->gamma_table[buffer_pointers[color][i]];
+                else
+                  buffer_pointers[color][i] =
+                    (s->gamma_table[buffer_pointers[color][i] >> 8] << 8) +
+                    (s->gamma_table[buffer_pointers[color][i] >> 8]);
+              }
+          /* mirror lines */
+          if (s->dev->model->flags & GT68XX_FLAG_MIRROR_X)
+            {
+              unsigned int swap;
+
+              for (color = 0; color < colors; color++)
+                {
+                  for (i = 0; i < s->reader->pixels_per_line / 2; i++)
+                    {
+                      swap = buffer_pointers[color][i];
+                      buffer_pointers[color][i] =
+                        buffer_pointers[color][s->reader->pixels_per_line -
+                                               1 - i];
+                      buffer_pointers[color][s->reader->pixels_per_line - 1 -
+                                             i] = swap;
+                    }
+                }
+            }
+        }
+      if (lineart)
+        {
+          SANE_Int bit;
+          SANE_Byte threshold = s->val[OPT_THRESHOLD].w;
+
+          buf[*len] = 0;
+          for (bit = 7; bit >= 0; bit--)
+            {
+              SANE_Byte is_black =
+                (((buffer_pointers[0][s->byte_count] >> 8) & 0xff) >
+                 threshold) ? 0 : 1;
+              buf[*len] |= (is_black << bit);
+              if ((7 - bit) % inflate_x == (inflate_x - 1))
+                s->byte_count++;
+            }
+        }
+      else if (s->reader->params.color)
+        {
+          /* color */
+          if (s->reader->params.depth > 8)
+            {
+              SANE_Int color = (s->total_bytes / 2) % 3;
+              if ((s->total_bytes % 2) == 0)
+                {
+                  if (little_endian)
+                    buf[*len] = buffer_pointers[color][s->byte_count] & 0xff;
+                  else
+                    buf[*len] =
+                      (buffer_pointers[color][s->byte_count] >> 8) & 0xff;
+                }
+              else
+                {
+                  if (little_endian)
+                    buf[*len] =
+                      (buffer_pointers[color][s->byte_count] >> 8) & 0xff;
+                  else
+                    buf[*len] = buffer_pointers[color][s->byte_count] & 0xff;
+
+                  if (s->total_bytes % (inflate_x * 6) == (inflate_x * 6 - 1))
+                    s->byte_count++;
+                }
+            }
+          else
+            {
+              SANE_Int color = s->total_bytes % 3;
+              buf[*len] = (buffer_pointers[color][s->byte_count] >> 8) & 0xff;
+              if (s->total_bytes % (inflate_x * 3) == (inflate_x * 3 - 1))
+                s->byte_count++;
+#ifdef DEBUG_BRIGHTNESS
+              s->average_white += buf[*len];
+              s->max_white =
+                (buf[*len] > s->max_white) ? buf[*len] : s->max_white;
+              s->min_black =
+                (buf[*len] < s->min_black) ? buf[*len] : s->min_black;
+#endif
+            }
+        }
+      else
+        {
+          /* gray */
+          if (s->reader->params.depth > 8)
+            {
+              if ((s->total_bytes % 2) == 0)
+                {
+                  if (little_endian)
+                    buf[*len] = buffer_pointers[0][s->byte_count] & 0xff;
+                  else
+                    buf[*len] =
+                      (buffer_pointers[0][s->byte_count] >> 8) & 0xff;
+                }
+              else
+                {
+                  if (little_endian)
+                    buf[*len] =
+                      (buffer_pointers[0][s->byte_count] >> 8) & 0xff;
+                  else
+                    buf[*len] = buffer_pointers[0][s->byte_count] & 0xff;
+                  if (s->total_bytes % (2 * inflate_x) == (2 * inflate_x - 1))
+                    s->byte_count++;
+                }
+            }
+          else
+            {
+              buf[*len] = (buffer_pointers[0][s->byte_count] >> 8) & 0xff;
+              if (s->total_bytes % inflate_x == (inflate_x - 1))
+                s->byte_count++;
+            }
+        }
+      (*len)++;
+      s->total_bytes++;
+    }
+
+  DBG (4, "sane_read: exit (line %d of %d, byte_count %d of %d, %d bytes, "
+       "%d total)\n",
+       s->line, s->reader->params.pixel_ys, s->byte_count,
+       s->reader->params.pixel_xs, *len, s->total_bytes);
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_cancel (SANE_Handle handle)
+{
+  GT68xx_Scanner *s = handle;
+
+  DBG (5, "sane_cancel: start\n");
+
+  if (s->scanning)
+    {
+      s->scanning = SANE_FALSE;
+      if (s->total_bytes != (s->params.bytes_per_line * s->params.lines))
+        DBG (1, "sane_cancel: warning: scanned %d bytes, expected %d "
+             "bytes\n", s->total_bytes,
+             s->params.bytes_per_line * s->params.lines);
+      else
+        {
+          struct timeval now;
+          int secs;
+
+          gettimeofday (&now, 0);
+          secs = now.tv_sec - s->start_time.tv_sec;
+
+          DBG (3,
+               "sane_cancel: scan finished, scanned %d bytes in %d seconds\n",
+               s->total_bytes, secs);
+#ifdef DEBUG_BRIGHTNESS
+          DBG (1,
+               "sane_cancel: average white: %d, max_white=%d, min_black=%d\n",
+               s->average_white / s->total_bytes, s->max_white, s->min_black);
+#endif
+
+        }
+      /* some scanners don't like this command when cancelling a scan */
+      sanei_usb_set_timeout (SHORT_TIMEOUT);
+      gt68xx_device_fix_descriptor (s->dev);
+      gt68xx_scanner_stop_scan (s);
+      sanei_usb_set_timeout (LONG_TIMEOUT);
+
+      if (s->dev->model->flags & GT68XX_FLAG_SHEET_FED)
+        {
+          gt68xx_device_paperfeed (s->dev);
+        } 
+      else
+        {
+          sanei_usb_set_timeout (SHORT_TIMEOUT);
+          gt68xx_scanner_wait_for_positioning (s);
+          sanei_usb_set_timeout (LONG_TIMEOUT);
+          gt68xx_device_carriage_home (s->dev);
+        }
+      if (s->gamma_table)
+        free (s->gamma_table);
+      s->gamma_table = 0;
+    }
+  else
+    {
+      DBG (4, "sane_cancel: scan has not been initiated yet, "
+           "or it is allready aborted\n");
+    }
+
+  DBG (5, "sane_cancel: exit\n");
+  return;
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
+{
+  GT68xx_Scanner *s = handle;
+
+  DBG (5, "sane_set_io_mode: handle = %p, non_blocking = %s\n",
+       handle, non_blocking == SANE_TRUE ? "true" : "false");
+
+  if (!s->scanning)
+    {
+      DBG (1, "sane_set_io_mode: not scanning\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (non_blocking)
+    return SANE_STATUS_UNSUPPORTED;
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
+{
+  GT68xx_Scanner *s = handle;
+
+  DBG (5, "sane_get_select_fd: handle = %p, fd = %p\n", handle, (void *) fd);
+
+  if (!s->scanning)
+    {
+      DBG (1, "sane_get_select_fd: not scanning\n");
+      return SANE_STATUS_INVAL;
+    }
+  return SANE_STATUS_UNSUPPORTED;
+}
+
+/* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */