Initial import of sane-backends version 1.0.24-1.2

1 files changed, 2020 insertions, 0 deletions

diff --git a/backend/ma1509.c b/backend/ma1509.c
new file mode 100644
index 0000000..5fccd1c
--- /dev/null
+++ b/backend/ma1509.c
@@ -0,0 +1,2020 @@
+/* sane - Scanner Access Now Easy.
+   (C) 2003 Henning Meier-Geinitz <henning@meier-geinitz.de>.
+
+   Based on the mustek (SCSI) backend.
+
+   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 scanners based on the Mustek
+   MA-1509 chipset. Currently the Mustek BearPaw 1200F is known to work.
+*/
+
+
+/**************************************************************************/
+/* ma1509 backend version                                                 */
+#define BUILD 3
+/**************************************************************************/
+
+#include "../include/sane/config.h"
+
+#include <ctype.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <limits.h>
+#include <sys/time.h>
+#include <sys/types.h>
+#include <errno.h>
+
+#include "../include/sane/sane.h"
+#include "../include/sane/sanei.h"
+#include "../include/sane/saneopts.h"
+#include "../include/sane/sanei_usb.h"
+
+#define BACKEND_NAME	ma1509
+#include "../include/sane/sanei_backend.h"
+#include "../include/sane/sanei_config.h"
+
+#include "ma1509.h"
+
+#ifndef SANE_I18N
+#define SANE_I18N(text) text
+#endif
+
+/* Debug level from sanei_init_debug */
+static SANE_Int debug_level;
+
+static SANE_Int num_devices;
+static Ma1509_Device *first_dev;
+static Ma1509_Scanner *first_handle;
+static const SANE_Device **devlist = 0;
+
+static int warmup_time = MA1509_WARMUP_TIME;
+
+/* Array of newly attached devices */
+static Ma1509_Device **new_dev;
+
+/* Length of new_dev array */
+static SANE_Int new_dev_len;
+
+/* Number of entries alloced for new_dev */
+static SANE_Int new_dev_alloced;
+
+static SANE_String_Const mode_list[] = {
+  SANE_VALUE_SCAN_MODE_LINEART,
+  SANE_VALUE_SCAN_MODE_GRAY,
+  SANE_VALUE_SCAN_MODE_COLOR,
+  0
+};
+
+static SANE_String_Const ta_source_list[] = {
+  SANE_I18N ("Flatbed"), SANE_I18N ("Transparency Adapter"),
+  0
+};
+
+static SANE_Word resolution_list[] = {
+  9,
+  50, 100, 150, 200, 300, 400, 450, 500, 600
+};
+
+static const SANE_Range u8_range = {
+  0,				/* minimum */
+  255,				/* maximum */
+  0				/* quantization */
+};
+
+
+/* "SCSI" command buffers used by the backend */
+static const SANE_Byte scsi_inquiry[] = {
+  0x12, 0x01, 0x00, 0x00, 0x00, 0x00, INQ_LEN, 0x00
+};
+static const SANE_Byte scsi_test_unit_ready[] = {
+  0x03, 0x01, 0x01, 0x00, 0x00, 0x00, 0x04, 0x00
+};
+static const SANE_Byte scsi_set_window[] = {
+  0x24, 0x00, 0x00, 0x00, 0x00, 0x00, 0x30, 0x00
+};
+
+
+static void
+print_data_buffer (const SANE_Byte * buffer, size_t len)
+{
+  SANE_Byte buffer_byte_list[50];
+  SANE_Byte buffer_byte[5];
+  const SANE_Byte *pp;
+
+  buffer_byte_list[0] = '\0';
+  for (pp = buffer; pp < (buffer + len); pp++)
+    {
+      sprintf ((SANE_String) buffer_byte, " %02x", *pp);
+      strcat ((SANE_String) buffer_byte_list, (SANE_String) buffer_byte);
+      if (((pp - buffer) % 0x10 == 0x0f) || (pp >= (buffer + len - 1)))
+	{
+	  DBG (5, "buffer: %s\n", buffer_byte_list);
+	  buffer_byte_list[0] = '\0';
+	}
+    }
+}
+
+static SANE_Status
+ma1509_cmd (Ma1509_Scanner * s, const SANE_Byte * cmd, SANE_Byte * data,
+	    size_t * data_size)
+{
+  SANE_Status status;
+  size_t size;
+#define MA1509_WRITE_LIMIT (1024 * 64)
+#define MA1509_READ_LIMIT (1024 * 256)
+
+  DBG (5, "ma1509_cmd: fd=%d, cmd=%p, data=%p, data_size=%ld\n",
+       s->fd, cmd, data, (long int) (data_size ? *data_size : 0));
+  DBG (5, "ma1509_cmd: cmd = %02x %02x %02x %02x %02x %02x %02x %02x \n",
+       cmd[0], cmd[1], cmd[2], cmd[3], cmd[4], cmd[5], cmd[6], cmd[7]);
+
+
+  size = MA1509_COMMAND_LENGTH;
+  status = sanei_usb_write_bulk (s->fd, cmd, &size);
+  if (status != SANE_STATUS_GOOD || size != MA1509_COMMAND_LENGTH)
+    {
+      DBG (5,
+	   "ma1509_cmd: sanei_usb_write_bulk returned %s (size = %ld, expected %d)\n",
+	   sane_strstatus (status), (long int) size, MA1509_COMMAND_LENGTH);
+      return status;
+    }
+
+  if (cmd[1] == 1)
+    {
+      /* receive data */
+      if (data && data_size && *data_size)
+	{
+	  size_t bytes_left = *data_size;
+	  DBG (5, "ma1509_cmd: trying to receive %ld bytes of data\n",
+	       (long int) *data_size);
+
+	  while (status == SANE_STATUS_GOOD && bytes_left > 0)
+	    {
+	      size = bytes_left;
+	      if (size > MA1509_READ_LIMIT)
+		size = MA1509_READ_LIMIT;
+
+	      status =
+		sanei_usb_read_bulk (s->fd, data + *data_size - bytes_left,
+				     &size);
+
+	      if (status != SANE_STATUS_GOOD)
+		{
+		  DBG (1, "ma1509_cmd: sanei_usb_read_bulk returned %s\n",
+		       sane_strstatus (status));
+		  return status;
+		}
+	      bytes_left -= size;
+	      DBG (5, "ma1509_cmd: read %ld bytes, %ld bytes to go\n",
+		   (long int) size, (long int) bytes_left);
+	    }
+	  if (debug_level >= 5)
+	    print_data_buffer (data, *data_size);
+	}
+    }
+  else
+    {
+      /* send data */
+      if (data && data_size && *data_size)
+	{
+	  size_t bytes_left = *data_size;
+
+	  DBG (5, "ma1509_cmd: sending %ld bytes of data\n",
+	       (long int) *data_size);
+	  if (debug_level >= 5)
+	    print_data_buffer (data, *data_size);
+
+	  while (status == SANE_STATUS_GOOD && bytes_left > 0)
+	    {
+	      size = bytes_left;
+	      if (size > MA1509_WRITE_LIMIT)
+		size = MA1509_WRITE_LIMIT;
+	      status =
+		sanei_usb_write_bulk (s->fd, data + *data_size - bytes_left,
+				      &size);
+	      if (status != SANE_STATUS_GOOD)
+		{
+		  DBG (1, "ma1509_cmd: sanei_usb_write_bulk returned %s\n",
+		       sane_strstatus (status));
+		  return status;
+		}
+	      bytes_left -= size;
+	      DBG (5, "ma1509_cmd: wrote %ld bytes, %ld bytes to go\n",
+		   (long int) size, (long int) bytes_left);
+	    }
+
+	}
+    }
+
+  DBG (5, "ma1509_cmd: finished: data_size=%ld, status=%s\n",
+       (long int) (data_size ? *data_size : 0), sane_strstatus (status));
+  return status;
+}
+
+static SANE_Status
+test_unit_ready (Ma1509_Scanner * s)
+{
+  SANE_Status status;
+  SANE_Byte buffer[0x04];
+  size_t size = sizeof (buffer);
+
+  status = ma1509_cmd (s, scsi_test_unit_ready, buffer, &size);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "test_unit_ready: ma1509_cmd failed: %s\n",
+	   sane_strstatus (status));
+      return status;
+    }
+  if (buffer[1] == 0x14)
+    s->hw->has_adf = SANE_TRUE;
+  else
+    s->hw->has_adf = SANE_FALSE;
+
+  return status;
+}
+
+static SANE_Status
+attach (SANE_String_Const devname, Ma1509_Device ** devp)
+{
+  SANE_Int fw_revision;
+  SANE_Byte result[INQ_LEN];
+  SANE_Byte inquiry_byte_list[50], inquiry_text_list[17];
+  SANE_Byte inquiry_byte[5], inquiry_text[5];
+  SANE_Byte *model_name = result + 44;
+  Ma1509_Scanner s;
+  Ma1509_Device *dev, new_dev;
+  SANE_Status status;
+  size_t size;
+  SANE_Byte *pp;
+  SANE_Word vendor, product;
+
+  if (devp)
+    *devp = 0;
+
+  for (dev = first_dev; dev; dev = dev->next)
+    if (strcmp (dev->sane.name, devname) == 0)
+      {
+	if (devp)
+	  *devp = dev;
+	return SANE_STATUS_GOOD;
+      }
+
+  memset (&new_dev, 0, sizeof (new_dev));
+  memset (&s, 0, sizeof (s));
+  s.hw = &new_dev;
+
+  DBG (3, "attach: trying device %s\n", devname);
+
+  status = sanei_usb_open (devname, &s.fd);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: sanei_usb_open failed: %s\n", sane_strstatus (status));
+      return status;
+    }
+
+  status = sanei_usb_get_vendor_product (s.fd, &vendor, &product);
+  if (status != SANE_STATUS_GOOD && status != SANE_STATUS_UNSUPPORTED)
+    {
+      DBG (1, "attach: sanei_usb_get_vendor_product failed: %s\n",
+	   sane_strstatus (status));
+      sanei_usb_close (s.fd);
+      return status;
+    }
+  if (status == SANE_STATUS_UNSUPPORTED)
+    {
+      DBG (3, "attach: can't detect vendor/product, trying anyway\n");
+    }
+  else if (vendor != 0x055f || product != 0x0010)
+    {
+      DBG (1, "attach: unknown vendor/product (0x%x/0x%x)\n", vendor,
+	   product);
+      sanei_usb_close (s.fd);
+      return SANE_STATUS_UNSUPPORTED;
+    }
+
+  DBG (4, "attach: sending TEST_UNIT_READY\n");
+  status = test_unit_ready (&s);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: test_unit_ready device %s failed (%s)\n", devname,
+	   sane_strstatus (status));
+      sanei_usb_close (s.fd);
+      return status;
+    }
+
+  DBG (4, "attach: sending INQUIRY\n");
+  size = sizeof (result);
+  memset (result, 0, sizeof (result));
+  status = ma1509_cmd (&s, scsi_inquiry, result, &size);
+  if (status != SANE_STATUS_GOOD || size != INQ_LEN)
+    {
+      DBG (1, "attach: inquiry for device %s failed (%s)\n", devname,
+	   sane_strstatus (status));
+      sanei_usb_close (s.fd);
+      return status;
+    }
+
+  sanei_usb_close (s.fd);
+
+  if ((result[0] & 0x1f) != 0x06)
+    {
+      DBG (1, "attach: device %s doesn't look like a scanner at all (%d)\n",
+	   devname, result[0] & 0x1f);
+      return SANE_STATUS_INVAL;
+    }
+
+  if (debug_level >= 5)
+    {
+      /* print out inquiry */
+      DBG (5, "attach: inquiry output:\n");
+      inquiry_byte_list[0] = '\0';
+      inquiry_text_list[0] = '\0';
+      for (pp = result; pp < (result + INQ_LEN); pp++)
+	{
+	  sprintf ((SANE_String) inquiry_text, "%c",
+		   (*pp < 127) && (*pp > 31) ? *pp : '.');
+	  strcat ((SANE_String) inquiry_text_list,
+		  (SANE_String) inquiry_text);
+	  sprintf ((SANE_String) inquiry_byte, " %02x", *pp);
+	  strcat ((SANE_String) inquiry_byte_list,
+		  (SANE_String) inquiry_byte);
+	  if ((pp - result) % 0x10 == 0x0f)
+	    {
+	      DBG (5, "%s  %s\n", inquiry_byte_list, inquiry_text_list);
+	      inquiry_byte_list[0] = '\0';
+	      inquiry_text_list[0] = '\0';
+	    }
+	}
+    }
+
+  /* get firmware revision as BCD number:             */
+  fw_revision = (result[32] - '0') << 8 | (result[34] - '0') << 4
+    | (result[35] - '0');
+  DBG (4, "attach: firmware revision %d.%02x\n", fw_revision >> 8,
+       fw_revision & 0xff);
+
+  dev = malloc (sizeof (*dev));
+  if (!dev)
+    return SANE_STATUS_NO_MEM;
+
+  memcpy (dev, &new_dev, sizeof (*dev));
+
+  dev->name = strdup (devname);
+  if (!dev->name)
+    return SANE_STATUS_NO_MEM;
+  dev->sane.name = (SANE_String_Const) dev->name;
+  dev->sane.vendor = "Mustek";
+  dev->sane.type = "flatbed scanner";
+
+  dev->x_range.min = 0;
+  dev->y_range.min = 0;
+  dev->x_range.quant = SANE_FIX (0.1);
+  dev->y_range.quant = SANE_FIX (0.1);
+  dev->x_trans_range.min = 0;
+  dev->y_trans_range.min = 0;
+  /* default to something really small to be on the safe side: */
+  dev->x_trans_range.max = SANE_FIX (8.0 * MM_PER_INCH);
+  dev->y_trans_range.max = SANE_FIX (5.0 * MM_PER_INCH);
+  dev->x_trans_range.quant = SANE_FIX (0.1);
+  dev->y_trans_range.quant = SANE_FIX (0.1);
+
+  DBG (3, "attach: scanner id: %.11s\n", model_name);
+
+  /* BearPaw 1200F (SCSI-over-USB) */
+  if (strncmp ((SANE_String) model_name, " B06", 4) == 0)
+    {
+      dev->x_range.max = SANE_FIX (211.3);
+      dev->y_range.min = SANE_FIX (0);
+      dev->y_range.max = SANE_FIX (296.7);
+
+      dev->x_trans_range.min = SANE_FIX (0);
+      dev->y_trans_range.min = SANE_FIX (0);
+      dev->x_trans_range.max = SANE_FIX (150.0);
+      dev->y_trans_range.max = SANE_FIX (175.0);
+
+      dev->sane.model = "BearPaw 1200F";
+    }
+  else
+    {
+      DBG (0, "attach: this scanner (ID: %s) is not supported yet\n",
+	   model_name);
+      DBG (0, "attach: please set the debug level to 5 and send a debug "
+	   "report\n");
+      DBG (0, "attach: to henning@meier-geinitz.de (export "
+	   "SANE_DEBUG_MA1509=5\n");
+      DBG (0, "attach: scanimage -L 2>debug.txt). Thank you.\n");
+      free (dev);
+      return SANE_STATUS_INVAL;
+    }
+
+  DBG (2, "attach: found Mustek %s %s %s%s\n",
+       dev->sane.model, dev->sane.type, dev->has_ta ? "(TA)" : "",
+       dev->has_adf ? "(ADF)" : "");
+
+  ++num_devices;
+  dev->next = first_dev;
+  first_dev = dev;
+
+  if (devp)
+    *devp = dev;
+  return SANE_STATUS_GOOD;
+}
+
+
+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
+init_options (Ma1509_Scanner * s)
+{
+  SANE_Int i;
+
+  memset (s->opt, 0, sizeof (s->opt));
+  memset (s->val, 0, sizeof (s->val));
+
+  for (i = 0; i < NUM_OPTIONS; ++i)
+    {
+      s->opt[i].size = sizeof (SANE_Word);
+      s->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+    }
+
+  s->opt[OPT_NUM_OPTS].name = "";
+  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].cap = 0;
+  s->opt[OPT_MODE_GROUP].size = 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 (mode_list[1]);
+  if (!s->val[OPT_MODE].s)
+    return SANE_STATUS_NO_MEM;
+
+  /* resolution */
+  s->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
+  s->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION;
+  s->opt[OPT_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
+  s->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
+  s->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
+  s->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+  s->opt[OPT_RESOLUTION].constraint.word_list = resolution_list;
+  s->val[OPT_RESOLUTION].w = 50;
+
+  /* source */
+  s->opt[OPT_SOURCE].name = SANE_NAME_SCAN_SOURCE;
+  s->opt[OPT_SOURCE].title = SANE_TITLE_SCAN_SOURCE;
+  s->opt[OPT_SOURCE].desc = SANE_DESC_SCAN_SOURCE;
+  s->opt[OPT_SOURCE].type = SANE_TYPE_STRING;
+  s->opt[OPT_SOURCE].size = max_string_size (ta_source_list);
+  s->opt[OPT_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  s->opt[OPT_SOURCE].constraint.string_list = ta_source_list;
+  s->val[OPT_SOURCE].s = strdup (ta_source_list[0]);
+  if (!s->val[OPT_SOURCE].s)
+    return SANE_STATUS_NO_MEM;
+  s->opt[OPT_SOURCE].cap |= SANE_CAP_INACTIVE;
+
+  /* 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].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
+  s->val[OPT_PREVIEW].w = 0;
+
+  /* "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;
+
+  /* top-left x */
+  s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
+  s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
+  s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
+  s->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
+  s->opt[OPT_TL_X].unit = SANE_UNIT_MM;
+  s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_TL_X].constraint.range = &s->hw->x_range;
+  s->val[OPT_TL_X].w = s->hw->x_range.min;
+
+  /* top-left y */
+  s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
+  s->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
+  s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_TL_Y].constraint.range = &s->hw->y_range;
+  s->val[OPT_TL_Y].w = s->hw->y_range.min;
+
+  /* bottom-right x */
+  s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
+  s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
+  s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
+  s->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
+  s->opt[OPT_BR_X].unit = SANE_UNIT_MM;
+  s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BR_X].constraint.range = &s->hw->x_range;
+  s->val[OPT_BR_X].w = s->hw->x_range.max;
+
+  /* bottom-right y */
+  s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
+  s->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
+  s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BR_Y].constraint.range = &s->hw->y_range;
+  s->val[OPT_BR_Y].w = s->hw->y_range.max;
+
+  /* "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].size = 0;
+  s->opt[OPT_ENHANCEMENT_GROUP].cap = 0;
+  s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* 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->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
+  s->val[OPT_THRESHOLD].w = 128;
+
+  /* custom-gamma table */
+  s->opt[OPT_CUSTOM_GAMMA].name = SANE_NAME_CUSTOM_GAMMA;
+  s->opt[OPT_CUSTOM_GAMMA].title = SANE_TITLE_CUSTOM_GAMMA;
+  s->opt[OPT_CUSTOM_GAMMA].desc = SANE_DESC_CUSTOM_GAMMA;
+  s->opt[OPT_CUSTOM_GAMMA].type = SANE_TYPE_BOOL;
+  s->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;
+
+  /* red gamma vector */
+  s->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
+  s->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
+  s->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
+  s->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
+  s->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
+  s->opt[OPT_GAMMA_VECTOR_R].size = MA1509_GAMMA_SIZE * sizeof (SANE_Word);
+  s->val[OPT_GAMMA_VECTOR_R].wa = &s->red_gamma_table[0];
+  s->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_GAMMA_VECTOR_R].constraint.range = &u8_range;
+  s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
+  for (i = 0; i < MA1509_GAMMA_SIZE; i++)
+    s->red_gamma_table[i] = i * MA1509_GAMMA_SIZE / 256;
+
+  /* green gamma vector */
+  s->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
+  s->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
+  s->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
+  s->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
+  s->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
+  s->opt[OPT_GAMMA_VECTOR_G].size = MA1509_GAMMA_SIZE * sizeof (SANE_Word);
+  s->val[OPT_GAMMA_VECTOR_G].wa = &s->green_gamma_table[0];
+  s->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_GAMMA_VECTOR_G].constraint.range = &u8_range;
+  s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
+  for (i = 0; i < MA1509_GAMMA_SIZE; i++)
+    s->green_gamma_table[i] = i * MA1509_GAMMA_SIZE / 256;
+
+  /* blue gamma vector */
+  s->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
+  s->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
+  s->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
+  s->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
+  s->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
+  s->opt[OPT_GAMMA_VECTOR_B].size = MA1509_GAMMA_SIZE * sizeof (SANE_Word);
+  s->val[OPT_GAMMA_VECTOR_B].wa = &s->blue_gamma_table[0];
+  s->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_GAMMA_VECTOR_B].constraint.range = &u8_range;
+  s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
+  for (i = 0; i < MA1509_GAMMA_SIZE; i++)
+    s->blue_gamma_table[i] = i * MA1509_GAMMA_SIZE / 256;
+
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+attach_one_device (SANE_String_Const devname)
+{
+  Ma1509_Device *dev;
+
+  attach (devname, &dev);
+  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;
+}
+
+static SANE_Status
+set_window (Ma1509_Scanner * s)
+{
+  SANE_Byte buffer[0x30], *cp;
+  double pixels_per_mm;
+  size_t size = sizeof (buffer);
+  SANE_Status status;
+  SANE_Int tlx, tly, width, height;
+  SANE_Int offset = 0;
+  struct timeval now;
+  long remaining_time;
+
+  /* check if lamp is warmed up */
+  gettimeofday (&now, 0);
+  remaining_time = warmup_time - (now.tv_sec - s->lamp_time);
+  if (remaining_time > 0)
+    {
+      DBG (0, "Warm-up in progress: please wait %2ld seconds\n",
+	   remaining_time);
+      sleep (remaining_time);
+    }
+
+  memset (buffer, 0, size);
+  cp = buffer;
+
+  STORE16B (cp, 0);		/* window identifier            */
+  STORE16B (cp, s->val[OPT_RESOLUTION].w);
+  STORE16B (cp, 0);		/* not used acc. to specs       */
+
+  pixels_per_mm = s->val[OPT_RESOLUTION].w / MM_PER_INCH;
+
+  tlx = SANE_UNFIX (s->val[OPT_TL_X].w) * pixels_per_mm + 0.5;
+  tly = SANE_UNFIX (s->val[OPT_TL_Y].w) * pixels_per_mm + 0.5;
+
+  width = (SANE_UNFIX (s->val[OPT_BR_X].w) - SANE_UNFIX (s->val[OPT_TL_X].w))
+    * pixels_per_mm + 0.5;
+  height = (SANE_UNFIX (s->val[OPT_BR_Y].w) - SANE_UNFIX (s->val[OPT_TL_Y].w))
+    * pixels_per_mm + 0.5 + offset;
+
+  if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) == 0)
+    {
+      width /= 64;
+      width *= 64;
+      if (!width)
+	width = 64;
+    }
+  else
+    {
+      width /= 8;
+      width *= 8;
+      if (!width)
+	width = 8;
+    }
+
+
+  DBG (4, "set_window: tlx=%d (%d mm); tly=%d (%d mm); width=%d (%d mm); "
+       "height=%d (%d mm)\n", tlx, (int) (tlx / pixels_per_mm), tly,
+       (int) (tly / pixels_per_mm), width, (int) (width / pixels_per_mm),
+       height, (int) (height / pixels_per_mm));
+
+
+  STORE16B (cp, 0);
+  STORE16B (cp, tlx);
+  STORE16B (cp, 0);
+  STORE16B (cp, tly);
+  *cp++ = 0x14;
+  *cp++ = 0xc0;
+  STORE16B (cp, width);
+  *cp++ = 0x28;
+  *cp++ = 0x20;
+  STORE16B (cp, height);
+
+  s->hw->ppl = width;
+  s->hw->bpl = s->hw->ppl;
+
+  s->hw->lines = height;
+
+  *cp++ = 0x00;			/* brightness, not impl.        */
+  /* threshold */
+  if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) == 0)
+    *cp++ = (SANE_Byte) s->val[OPT_THRESHOLD].w;
+  else
+    *cp++ = 0x80;
+  *cp++ = 0x00;			/* contrast, not impl.          */
+  *cp++ = 0x00;			/* ???               .          */
+
+  /* Note that 'image composition' has no meaning for the SE series     */
+  /* Mode selection is accomplished solely by bits/pixel (1, 8, 24)     */
+  if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0)
+    {
+      *cp++ = 24;		/* 24 bits/pixel in color mode  */
+      s->hw->bpl *= 3;
+    }
+  else if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_GRAY) == 0)
+    *cp++ = 8;			/* 8 bits/pixel in gray mode    */
+  else
+    {
+      *cp++ = 1;		/* 1 bit/pixel in lineart mode  */
+      s->hw->bpl /= 8;
+    }
+
+  cp += 13;			/* skip reserved bytes          */
+  *cp++ = 0x00;			/* lamp mode  */
+  if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) != 0)
+    *cp++ = 0x02;		/* ???  */
+
+  status = ma1509_cmd (s, scsi_set_window, buffer, &size);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "set_window: ma1509_cmd failed: %s\n", sane_strstatus (status));
+      return status;
+    }
+  return status;
+}
+
+static SANE_Status
+calibration (Ma1509_Scanner * s)
+{
+  SANE_Byte cmd[0x08], *buffer, *calibration_buffer;
+  SANE_Status status;
+  SANE_Int ppl = 5312;
+  SANE_Int lines = 40;
+  size_t total_size = lines * ppl;
+  SANE_Int color, column, line;
+
+  buffer = malloc (total_size * 3);
+  if (!buffer)
+    {
+      DBG (1,
+	   "calibration: couldn't malloc %lu bytes for calibration buffer\n",
+	   (u_long) (total_size * 3));
+      return SANE_STATUS_NO_MEM;
+    }
+  memset (buffer, 0x00, total_size);
+
+  memset (cmd, 0, 8);
+  cmd[0] = 0x28;		/* read data */
+  cmd[1] = 0x01;		/* read */
+  cmd[2] = 0x01;		/* calibration */
+  cmd[4] = (total_size >> 16) & 0xff;
+  cmd[5] = (total_size >> 8) & 0xff;
+  cmd[6] = total_size & 0xff;
+  total_size *= 3;
+  status = ma1509_cmd (s, cmd, buffer, &total_size);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "calibration: ma1509_cmd read data failed: %s\n",
+	   sane_strstatus (status));
+      free (buffer);
+      return status;
+    }
+
+  calibration_buffer = malloc (ppl);
+  if (!calibration_buffer)
+    {
+      DBG (1,
+	   "calibration: couldn't malloc %d bytes for calibration buffer\n",
+	   ppl);
+      return SANE_STATUS_NO_MEM;
+    }
+  memset (calibration_buffer, 0x00, ppl);
+
+  memset (cmd, 0, 8);
+  cmd[0] = 0x2a;		/* send data */
+  cmd[1] = 0x00;		/* write */
+  cmd[2] = 0x01;		/* calibration */
+  cmd[5] = (ppl >> 8) & 0xff;
+  cmd[6] = ppl & 0xff;
+
+  for (color = 1; color < 4; color++)
+    {
+      cmd[4] = color;
+
+      for (column = 0; column < ppl; column++)
+	{
+	  SANE_Int average = 0;
+
+	  for (line = 0; line < lines; line++)
+	    average += buffer[line * ppl * 3 + column * 3 + (color - 1)];
+	  average /= lines;
+	  if (average < 1)
+	    average = 1;
+	  if (average > 255)
+	    average = 255;
+
+	  average = (256 * 256) / average - 256;
+	  if (average < 0)
+	    average = 0;
+	  if (average > 255)
+	    average = 255;
+	  calibration_buffer[column] = average;
+	}
+
+      total_size = ppl;
+      status = ma1509_cmd (s, cmd, calibration_buffer, &total_size);
+      if (status != SANE_STATUS_GOOD)
+	{
+	  DBG (1, "calibration: ma1509_cmd send data failed: %s\n",
+	       sane_strstatus (status));
+	  free (buffer);
+	  free (calibration_buffer);
+	  return status;
+	}
+    }
+  free (buffer);
+  free (calibration_buffer);
+  DBG (4, "calibration: done\n");
+  return status;
+}
+
+
+static SANE_Status
+send_gamma (Ma1509_Scanner * s)
+{
+  SANE_Byte cmd[0x08], *buffer;
+  SANE_Status status;
+  size_t total_size = MA1509_GAMMA_SIZE;
+  SANE_Int color;
+
+  buffer = malloc (total_size);
+  if (!buffer)
+    {
+      DBG (1, "send_gamma: couldn't malloc %lu bytes for gamma  buffer\n",
+	   (u_long) total_size);
+      return SANE_STATUS_NO_MEM;
+    }
+
+  memset (cmd, 0, 8);
+  cmd[0] = 0x2a;		/* send data */
+  cmd[1] = 0x00;		/* write */
+  cmd[2] = 0x03;		/* gamma */
+  cmd[5] = (total_size >> 8) & 0xff;
+  cmd[6] = total_size & 0xff;
+  for (color = 1; color < 4; color++)
+    {
+      unsigned int i;
+
+      if (s->val[OPT_CUSTOM_GAMMA].w)
+	{
+	  SANE_Int *int_buffer;
+
+	  if (color == 1)
+	    int_buffer = s->red_gamma_table;
+	  else if (color == 2)
+	    int_buffer = s->green_gamma_table;
+	  else
+	    int_buffer = s->blue_gamma_table;
+	  for (i = 0; i < total_size; i++)
+	    buffer[i] = int_buffer[i];
+	}
+      else
+	{
+	  /* linear tables */
+	  for (i = 0; i < total_size; i++)
+	    buffer[i] = i * 256 / total_size;
+	}
+
+      cmd[4] = color;
+      status = ma1509_cmd (s, cmd, buffer, &total_size);
+      if (status != SANE_STATUS_GOOD)
+	{
+	  DBG (1, "send_gamma: ma1509_cmd send data failed: %s\n",
+	       sane_strstatus (status));
+	  free (buffer);
+	  return status;
+	}
+    }
+  if (!s->val[OPT_CUSTOM_GAMMA].w)
+    free (buffer);
+  DBG (4, "send_gamma: done\n");
+  return status;
+}
+
+
+static SANE_Status
+start_scan (Ma1509_Scanner * s)
+{
+  SANE_Byte cmd[8];
+  SANE_Status status;
+
+  DBG (4, "start_scan\n");
+  memset (cmd, 0, 8);
+
+  cmd[0] = 0x1b;
+  cmd[1] = 0x01;
+  cmd[2] = 0x01;
+
+  status = ma1509_cmd (s, cmd, NULL, NULL);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "start_scan: ma1509_cmd failed: %s\n", sane_strstatus (status));
+      return status;
+    }
+  return status;
+}
+
+static SANE_Status
+turn_lamp (Ma1509_Scanner * s, SANE_Bool is_on)
+{
+  SANE_Status status;
+  SANE_Byte buffer[0x30];
+  size_t size = sizeof (buffer);
+  struct timeval lamp_time;
+
+  DBG (4, "turn_lamp %s\n", is_on ? "on" : "off");
+  memset (buffer, 0, size);
+  if (is_on)
+    buffer[0x28] = 0x01;
+  else
+    buffer[0x28] = 0x02;
+
+  status = ma1509_cmd (s, scsi_set_window, buffer, &size);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "turn_lamp: ma1509_cmd set_window failed: %s\n",
+	   sane_strstatus (status));
+      return status;
+    }
+  gettimeofday (&lamp_time, 0);
+  s->lamp_time = lamp_time.tv_sec;
+  return status;
+}
+
+static SANE_Status
+stop_scan (Ma1509_Scanner * s)
+{
+  SANE_Byte cmd[8];
+  SANE_Status status;
+
+  DBG (4, "stop_scan\n");
+  memset (cmd, 0, 8);
+
+  cmd[0] = 0x1b;
+  cmd[1] = 0x01;
+  cmd[2] = 0x00;
+
+  status = ma1509_cmd (s, cmd, NULL, NULL);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "stop_scan: ma1509_cmd failed: %s\n", sane_strstatus (status));
+      return status;
+    }
+
+  DBG (4, "stop_scan: scan stopped\n");
+  return status;
+}
+
+
+static SANE_Status
+start_read_data (Ma1509_Scanner * s)
+{
+  SANE_Byte cmd[8];
+  SANE_Status status;
+  SANE_Int total_size = s->hw->ppl * s->hw->lines;
+
+  if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) == 0)
+    total_size /= 8;
+
+  memset (cmd, 0, 8);
+
+  cmd[0] = 0x28;		/* read data */
+  cmd[1] = 0x01;		/* read */
+  cmd[2] = 0x00;		/* scan data */
+  cmd[3] = (total_size >> 24) & 0xff;
+  cmd[4] = (total_size >> 16) & 0xff;
+  cmd[5] = (total_size >> 8) & 0xff;
+  cmd[6] = total_size & 0xff;
+  status = ma1509_cmd (s, cmd, NULL, NULL);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "stop_scan: ma1509_cmd failed: %s\n", sane_strstatus (status));
+      return status;
+    }
+  return status;
+}
+
+static SANE_Status
+read_data (Ma1509_Scanner * s, SANE_Byte * buffer, SANE_Int * size)
+{
+  size_t local_size = *size;
+  SANE_Status status;
+
+  status = sanei_usb_read_bulk (s->fd, buffer, &local_size);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "read_data: sanei_usb_read_bulk failed: %s\n",
+	   sane_strstatus (status));
+      return status;
+    }
+  *size = local_size;
+  return status;
+}
+
+
+
+
+/**************************************************************************/
+/*                            SANE API calls                              */
+/**************************************************************************/
+
+SANE_Status
+sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
+{
+  SANE_Char line[PATH_MAX], *word, *end;
+  SANE_String_Const cp;
+  SANE_Int linenumber;
+  FILE *fp;
+
+  DBG_INIT ();
+
+#ifdef DBG_LEVEL
+  debug_level = DBG_LEVEL;
+#else
+  debug_level = 0;
+#endif
+
+  DBG (2, "SANE ma1509 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 (4, "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;
+
+  fp = sanei_config_open (MA1509_CONFIG_FILE);
+  if (!fp)
+    {
+      /* default to /dev/usb/scanner0 instead of insisting on config file */
+      DBG (3, "sane_init: couldn't find config file (%s), trying "
+	   "/dev/usb/scanner0 directly\n", MA1509_CONFIG_FILE);
+      attach ("/dev/usb/scanner0", 0);
+      return SANE_STATUS_GOOD;
+    }
+  linenumber = 0;
+  DBG (4, "sane_init: reading config file `%s'\n", MA1509_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 (5, "sane_init: config file line %d: ignoring empty line\n",
+	       linenumber);
+	  if (word)
+	    free (word);
+	  continue;
+	}
+      if (word[0] == '#')
+	{
+	  DBG (5, "sane_init: config file line %d: ignoring comment line\n",
+	       linenumber);
+	  free (word);
+	  continue;
+	}
+      if (strcmp (word, "option") == 0)
+	{
+	  free (word);
+	  word = 0;
+	  cp = sanei_config_get_string (cp, &word);
+
+	  if (!word)
+	    {
+	      DBG (1, "sane_init: config file line %d: missing quotation mark?\n",
+		   linenumber);
+	      continue;
+	    }
+
+	  if (strcmp (word, "warmup-time") == 0)
+	    {
+	      long local_warmup_time;
+
+	      free (word);
+	      word = 0;
+	      cp = sanei_config_get_string (cp, &word);
+
+	      if (!word)
+		{
+		  DBG (1, "sane_init: config file line %d: missing quotation mark?\n",
+		       linenumber);
+		  continue;
+		}
+
+	      errno = 0;
+	      local_warmup_time = strtol (word, &end, 0);
+
+	      if (end == word)
+		{
+		  DBG (3, "sane-init: config file line %d: warmup-time must "
+		       "have a parameter; using default (%d)\n",
+		       linenumber, warmup_time);
+		}
+	      else if (errno)
+		{
+		  DBG (3, "sane-init: config file line %d: warmup-time `%s' "
+		       "is invalid (%s); using default (%d)\n", linenumber,
+		       word, strerror (errno), warmup_time);
+		}
+	      else
+		{
+		  warmup_time = local_warmup_time;
+		  DBG (4,
+		       "sane_init: config file line %d: warmup-time set "
+		       "to %d seconds\n", linenumber, warmup_time);
+
+		}
+	      if (word)
+		free (word);
+	      word = 0;
+	    }
+	  else
+	    {
+	      DBG (3, "sane_init: config file line %d: ignoring unknown "
+		   "option `%s'\n", linenumber, word);
+	      if (word)
+		free (word);
+	      word = 0;
+	    }
+	}
+      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;
+}
+
+void
+sane_exit (void)
+{
+  Ma1509_Device *dev, *next;
+
+  DBG (4, "sane_exit\n");
+  for (dev = first_dev; dev; dev = next)
+    {
+      next = dev->next;
+      free (dev->name);
+      free (dev);
+    }
+  if (devlist)
+    free (devlist);
+  devlist = 0;
+  first_dev = 0;
+}
+
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
+{
+  Ma1509_Device *dev;
+  SANE_Int i;
+
+  DBG (4, "sane_get_devices: %d devices %s\n", num_devices,
+       local_only ? "(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;
+  DBG (5, "sane_get_devices: end\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_open (SANE_String_Const devicename, SANE_Handle * handle)
+{
+  Ma1509_Device *dev;
+  SANE_Status status;
+  Ma1509_Scanner *s;
+
+  if (!devicename)
+    {
+      DBG (1, "sane_open: devicename is null!\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (!handle)
+    {
+      DBG (1, "sane_open: handle is null!\n");
+      return SANE_STATUS_INVAL;
+    }
+  DBG (4, "sane_open: devicename=%s\n", devicename);
+
+  if (devicename[0])
+    {
+      for (dev = first_dev; dev; dev = dev->next)
+	if (strcmp (dev->sane.name, devicename) == 0)
+	  break;
+
+      if (!dev)
+	{
+	  status = attach (devicename, &dev);
+	  if (status != SANE_STATUS_GOOD)
+	    return status;
+	}
+    }
+  else
+    /* empty devicname -> use first device */
+    dev = first_dev;
+
+  if (!dev)
+    {
+      DBG (1, "sane_open: %s doesn't seem to exist\n", devicename);
+      return SANE_STATUS_INVAL;
+    }
+
+  s = malloc (sizeof (*s));
+  if (!s)
+    return SANE_STATUS_NO_MEM;
+  memset (s, 0, sizeof (*s));
+  s->fd = -1;
+  s->hw = dev;
+  init_options (s);
+
+  /* insert newly opened handle into list of open handles: */
+  s->next = first_handle;
+  first_handle = s;
+
+  status = sanei_usb_open (s->hw->sane.name, &s->fd);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "sane_open: couldn't open %s: %s\n", s->hw->sane.name,
+	   sane_strstatus (status));
+      return status;
+    }
+
+  status = turn_lamp (s, SANE_TRUE);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "sane_open: couldn't turn on lamp: %s\n",
+	   sane_strstatus (status));
+      return status;
+    }
+
+  status = turn_lamp (s, SANE_TRUE);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "sane_open: couldn't turn on lamp: %s\n",
+	   sane_strstatus (status));
+      return status;
+    }
+
+  *handle = s;
+  DBG (5, "sane_open: finished (handle=%p)\n", (void *) s);
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_close (SANE_Handle handle)
+{
+  Ma1509_Scanner *prev, *s;
+  SANE_Status status;
+
+  DBG (4, "sane_close: handle=%p\n", handle);
+
+  /* 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 (1, "sane_close: invalid handle %p\n", handle);
+      return;			/* oops, not a handle we know about */
+    }
+
+  if (s->val[OPT_MODE].s)
+    free (s->val[OPT_MODE].s);
+  if (s->val[OPT_SOURCE].s)
+    free (s->val[OPT_SOURCE].s);
+
+  status = turn_lamp (s, SANE_FALSE);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "sane_close: couldn't turn off lamp: %s\n",
+	   sane_strstatus (status));
+      return;
+    }
+  sanei_usb_close (s->fd);
+
+  if (prev)
+    prev->next = s->next;
+  else
+    first_handle = s->next;
+  free (handle);
+  handle = 0;
+}
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+  Ma1509_Scanner *s = handle;
+
+  if (((unsigned) option >= NUM_OPTIONS) || (option < 0))
+    {
+      DBG (3, "sane_get_option_descriptor: option %d >= NUM_OPTIONS or < 0\n",
+	   option);
+      return 0;
+    }
+  if (!s)
+    {
+      DBG (1, "sane_get_option_descriptor: handle is null!\n");
+      return 0;
+    }
+  if (s->opt[option].name && s->opt[option].name[0] != 0)
+    DBG (4, "sane_get_option_descriptor for option %s (%sactive%s)\n",
+	 s->opt[option].name,
+	 s->opt[option].cap & SANE_CAP_INACTIVE ? "in" : "",
+	 s->opt[option].cap & SANE_CAP_ADVANCED ? ", advanced" : "");
+  else
+    DBG (4, "sane_get_option_descriptor for option \"%s\" (%sactive%s)\n",
+	 s->opt[option].title,
+	 s->opt[option].cap & SANE_CAP_INACTIVE ? "in" : "",
+	 s->opt[option].cap & SANE_CAP_ADVANCED ? ", advanced" : "");
+  return s->opt + option;
+}
+
+SANE_Status
+sane_control_option (SANE_Handle handle, SANE_Int option,
+		     SANE_Action action, void *val, SANE_Int * info)
+{
+  Ma1509_Scanner *s = handle;
+  SANE_Status status;
+  SANE_Word cap;
+  SANE_Word w;
+
+  if (((unsigned) option >= NUM_OPTIONS) || (option < 0))
+    {
+      DBG (3, "sane_control_option: option %d < 0 or >= NUM_OPTIONS\n",
+	   option);
+      return SANE_STATUS_INVAL;
+    }
+  if (!s)
+    {
+      DBG (1, "sane_control_option: handle is null!\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (!val && s->opt[option].type != SANE_TYPE_BUTTON)
+    {
+      DBG (1, "sane_control_option: val is null!\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  if (s->opt[option].name && s->opt[option].name[0] != 0)
+    DBG (4, "sane_control_option (%s option %s)\n",
+	 action == SANE_ACTION_GET_VALUE ? "get" :
+	 (action == SANE_ACTION_SET_VALUE ? "set" : "unknown action with"),
+	 s->opt[option].name);
+  else
+    DBG (4, "sane_control_option (%s option \"%s\")\n",
+	 action == SANE_ACTION_GET_VALUE ? "get" :
+	 (action == SANE_ACTION_SET_VALUE ? "set" : "unknown action with"),
+	 s->opt[option].title);
+
+  if (info)
+    *info = 0;
+
+  if (s->scanning)
+    {
+      DBG (3, "sane_control_option: don't use while scanning (option %s)\n",
+	   s->opt[option].name);
+      return SANE_STATUS_DEVICE_BUSY;
+    }
+
+  cap = s->opt[option].cap;
+
+  if (!SANE_OPTION_IS_ACTIVE (cap))
+    {
+      DBG (3, "sane_control_option: option %s is inactive\n",
+	   s->opt[option].name);
+      return SANE_STATUS_INVAL;
+    }
+
+  if (action == SANE_ACTION_GET_VALUE)
+    {
+      switch (option)
+	{
+	  /* word options: */
+	case OPT_PREVIEW:
+	case OPT_RESOLUTION:
+	case OPT_TL_X:
+	case OPT_TL_Y:
+	case OPT_BR_X:
+	case OPT_BR_Y:
+	case OPT_THRESHOLD:
+	case OPT_CUSTOM_GAMMA:
+	case OPT_NUM_OPTS:
+	  *(SANE_Word *) val = s->val[option].w;
+	  return SANE_STATUS_GOOD;
+
+	  /* word-array options: */
+	case OPT_GAMMA_VECTOR_R:
+	case OPT_GAMMA_VECTOR_G:
+	case OPT_GAMMA_VECTOR_B:
+	  memcpy (val, s->val[option].wa, s->opt[option].size);
+	  return SANE_STATUS_GOOD;
+
+	  /* string options: */
+	case OPT_SOURCE:
+	case OPT_MODE:
+	  strcpy (val, s->val[option].s);
+	  return SANE_STATUS_GOOD;
+	}
+    }
+  else if (action == SANE_ACTION_SET_VALUE)
+    {
+      if (!SANE_OPTION_IS_SETTABLE (cap))
+	{
+	  DBG (3, "sane_control_option: option %s is not setable\n",
+	       s->opt[option].name);
+	  return SANE_STATUS_INVAL;
+	}
+
+      status = sanei_constrain_value (s->opt + option, val, info);
+      if (status != SANE_STATUS_GOOD)
+	{
+	  DBG (4, "sane_control_option: constrain_value error (option %s)\n",
+	       s->opt[option].name);
+	  return status;
+	}
+
+      switch (option)
+	{
+	  /* (mostly) side-effect-free word options: */
+	case OPT_RESOLUTION:
+	case OPT_TL_X:
+	case OPT_BR_X:
+	case OPT_TL_Y:
+	case OPT_BR_Y:
+	  if (info)
+	    *info |= SANE_INFO_RELOAD_PARAMS;
+	  /* fall through */
+	case OPT_THRESHOLD:
+	case OPT_PREVIEW:
+	  s->val[option].w = *(SANE_Word *) val;
+	  return SANE_STATUS_GOOD;
+
+	  /* side-effect-free word-array options: */
+	case OPT_GAMMA_VECTOR_R:
+	case OPT_GAMMA_VECTOR_G:
+	case OPT_GAMMA_VECTOR_B:
+	  memcpy (s->val[option].wa, val, s->opt[option].size);
+	  return SANE_STATUS_GOOD;
+
+	case OPT_MODE:
+	  {
+	    SANE_Char *old_val = s->val[option].s;
+
+	    if (old_val)
+	      {
+		if (strcmp (old_val, val) == 0)
+		  return SANE_STATUS_GOOD;	/* no change */
+		free (old_val);
+	      }
+	    if (info)
+	      *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
+
+	    s->val[option].s = strdup (val);
+	    if (!s->val[option].s)
+	      return SANE_STATUS_NO_MEM;
+
+	    s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
+	    s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
+	    s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
+	    s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
+	    s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
+
+	    if (strcmp (s->val[option].s, SANE_VALUE_SCAN_MODE_LINEART) == 0)
+	      {
+		s->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE;
+	      }
+	    else
+	      {
+		s->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
+		if (s->val[OPT_CUSTOM_GAMMA].w)
+		  {
+		    s->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
+		    s->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
+		    s->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
+		  }
+	      }
+	    return SANE_STATUS_GOOD;
+	  }
+
+	case OPT_SOURCE:
+	  if (info)
+	    *info |= SANE_INFO_RELOAD_OPTIONS;
+	  if (s->val[option].s)
+	    free (s->val[option].s);
+	  s->val[option].s = strdup (val);
+	  if (!s->val[option].s)
+	    return SANE_STATUS_NO_MEM;
+
+	  if (strcmp (val, "Transparency Adapter") == 0)
+	    {
+	      s->opt[OPT_TL_X].constraint.range = &s->hw->x_trans_range;
+	      s->opt[OPT_TL_Y].constraint.range = &s->hw->y_trans_range;
+	      s->opt[OPT_BR_X].constraint.range = &s->hw->x_trans_range;
+	      s->opt[OPT_BR_Y].constraint.range = &s->hw->y_trans_range;
+	    }
+	  else
+	    {
+	      s->opt[OPT_TL_X].constraint.range = &s->hw->x_range;
+	      s->opt[OPT_TL_Y].constraint.range = &s->hw->y_range;
+	      s->opt[OPT_BR_X].constraint.range = &s->hw->x_range;
+	      s->opt[OPT_BR_Y].constraint.range = &s->hw->y_range;
+	    }
+	  return SANE_STATUS_GOOD;
+
+	  /* options with side-effects: */
+	case OPT_CUSTOM_GAMMA:
+	  w = *(SANE_Word *) val;
+
+	  if (w == s->val[OPT_CUSTOM_GAMMA].w)
+	    return SANE_STATUS_GOOD;	/* no change */
+
+	  if (info)
+	    *info |= SANE_INFO_RELOAD_OPTIONS;
+
+	  s->val[OPT_CUSTOM_GAMMA].w = w;
+
+	  s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
+	  s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
+	  s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
+
+	  if (w && strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) != 0)
+	    {
+	      s->opt[OPT_GAMMA_VECTOR_R].cap &= ~SANE_CAP_INACTIVE;
+	      s->opt[OPT_GAMMA_VECTOR_G].cap &= ~SANE_CAP_INACTIVE;
+	      s->opt[OPT_GAMMA_VECTOR_B].cap &= ~SANE_CAP_INACTIVE;
+	    }
+	  return SANE_STATUS_GOOD;
+	}
+
+    }
+  DBG (4, "sane_control_option: unknown action for option %s\n",
+       s->opt[option].name);
+  return SANE_STATUS_INVAL;
+}
+
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
+{
+  Ma1509_Scanner *s = handle;
+  SANE_String_Const mode;
+
+  if (!s)
+    {
+      DBG (1, "sane_get_parameters: handle is null!\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  if (!s->scanning)
+    {
+      double width, height, dpi;
+
+      memset (&s->params, 0, sizeof (s->params));
+
+      width = SANE_UNFIX (s->val[OPT_BR_X].w - s->val[OPT_TL_X].w);
+      height = SANE_UNFIX (s->val[OPT_BR_Y].w - s->val[OPT_TL_Y].w);
+      dpi = s->val[OPT_RESOLUTION].w;
+
+      /* make best-effort guess at what parameters will look like once
+         scanning starts.  */
+      if (dpi > 0.0 && width > 0.0 && height > 0.0)
+	{
+	  double dots_per_mm = dpi / MM_PER_INCH;
+
+	  s->params.pixels_per_line = width * dots_per_mm;
+	  s->params.lines = height * dots_per_mm;
+	}
+      mode = s->val[OPT_MODE].s;
+      if (strcmp (mode, SANE_VALUE_SCAN_MODE_LINEART) == 0)
+	{
+	  s->params.format = SANE_FRAME_GRAY;
+	  s->params.bytes_per_line = (s->params.pixels_per_line + 7) / 8;
+	  s->params.depth = 1;
+	}
+      else if (strcmp (mode, SANE_VALUE_SCAN_MODE_GRAY) == 0)
+	{
+	  s->params.format = SANE_FRAME_GRAY;
+	  s->params.bytes_per_line = s->params.pixels_per_line;
+	  s->params.depth = 8;
+	}
+      else
+	{
+	  /* it's one of the color modes... */
+
+	  s->params.bytes_per_line = 3 * s->params.pixels_per_line;
+	  s->params.depth = 8;
+	  s->params.format = SANE_FRAME_RGB;
+	}
+    }
+  s->params.last_frame = SANE_TRUE;
+  if (params)
+    *params = s->params;
+  DBG (4, "sane_get_parameters: frame = %d; last_frame = %s; depth = %d\n",
+       s->params.format, s->params.last_frame ? "true" : "false",
+       s->params.depth);
+  DBG (4, "sane_get_parameters: lines = %d; ppl = %d; bpl = %d\n",
+       s->params.lines, s->params.pixels_per_line, s->params.bytes_per_line);
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+  Ma1509_Scanner *s = handle;
+  SANE_Status status;
+  SANE_String_Const mode;
+  struct timeval start;
+
+  if (!s)
+    {
+      DBG (1, "sane_start: handle is null!\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  DBG (4, "sane_start\n");
+
+  status = sane_get_parameters (s, 0);
+  if (status != SANE_STATUS_GOOD)
+    return status;
+
+  /* Check for inconsistencies */
+
+  if (s->val[OPT_TL_X].w > s->val[OPT_BR_X].w)
+    {
+      DBG (0, "sane_start: %s (%.1f mm) is bigger than %s (%.1f mm) "
+	   "-- aborting\n",
+	   s->opt[OPT_TL_X].title, SANE_UNFIX (s->val[OPT_TL_X].w),
+	   s->opt[OPT_BR_X].title, SANE_UNFIX (s->val[OPT_BR_X].w));
+      return SANE_STATUS_INVAL;
+    }
+  if (s->val[OPT_TL_Y].w > s->val[OPT_BR_Y].w)
+    {
+      DBG (0, "sane_start: %s (%.1f mm) is bigger than %s (%.1f mm) "
+	   "-- aborting\n",
+	   s->opt[OPT_TL_Y].title, SANE_UNFIX (s->val[OPT_TL_Y].w),
+	   s->opt[OPT_BR_Y].title, SANE_UNFIX (s->val[OPT_BR_Y].w));
+      return SANE_STATUS_INVAL;
+    }
+
+  s->total_bytes = 0;
+  s->read_bytes = 0;
+
+  /* save start time */
+  gettimeofday (&start, 0);
+  s->start_time = start.tv_sec;
+  /* translate options into s->mode for convenient access: */
+  mode = s->val[OPT_MODE].s;
+
+  status = set_window (s);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "sane_start: set window command failed: %s\n",
+	   sane_strstatus (status));
+      goto stop_scanner_and_return;
+    }
+
+  status = test_unit_ready (s);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "sane_start: test_unit_ready failed: %s\n",
+	   sane_strstatus (status));
+      goto stop_scanner_and_return;
+    }
+
+  if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) != 0)
+    {
+      status = calibration (s);
+      if (status != SANE_STATUS_GOOD)
+	{
+	  DBG (1, "sane_start: calibration failed: %s\n",
+	       sane_strstatus (status));
+	  goto stop_scanner_and_return;
+	}
+
+      status = send_gamma (s);
+      if (status != SANE_STATUS_GOOD)
+	{
+	  DBG (1, "sane_start: send_gamma failed: %s\n",
+	       sane_strstatus (status));
+	  goto stop_scanner_and_return;
+	}
+    }
+
+  s->scanning = SANE_TRUE;
+  s->cancelled = SANE_FALSE;
+
+  status = start_scan (s);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "sane_start: start_scan command failed: %s\n",
+	   sane_strstatus (status));
+      goto stop_scanner_and_return;
+    }
+
+  status = start_read_data (s);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "sane_start: start_read_data command failed: %s\n",
+	   sane_strstatus (status));
+      goto stop_scanner_and_return;
+    }
+
+  s->params.bytes_per_line = s->hw->bpl;
+  s->params.pixels_per_line = s->params.bytes_per_line;
+  if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0)
+    s->params.pixels_per_line /= 3;
+  else if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) == 0)
+    s->params.pixels_per_line *= 8;
+
+  s->params.lines = s->hw->lines;
+
+  s->buffer = (SANE_Byte *) malloc (MA1509_BUFFER_SIZE);
+  if (!s->buffer)
+    return SANE_STATUS_NO_MEM;
+  s->buffer_bytes = 0;
+
+  DBG (5, "sane_start: finished\n");
+  return SANE_STATUS_GOOD;
+
+stop_scanner_and_return:
+  sanei_usb_close (s->fd);
+  s->scanning = SANE_FALSE;
+  return status;
+}
+
+SANE_Status
+sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
+	   SANE_Int * len)
+{
+  Ma1509_Scanner *s = handle;
+  SANE_Status status;
+  SANE_Int total_size = s->hw->lines * s->hw->bpl;
+  SANE_Int i;
+
+  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;
+    }
+
+  DBG (5, "sane_read\n");
+  *len = 0;
+
+  if (s->cancelled)
+    {
+      DBG (4, "sane_read: scan was cancelled\n");
+      return SANE_STATUS_CANCELLED;
+    }
+
+  if (!s->scanning)
+    {
+      DBG (1, "sane_read: must call sane_start before sane_read\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  if (total_size - s->read_bytes <= 0)
+    {
+      DBG (4, "sane_read: EOF\n");
+      stop_scan (s);
+      s->scanning = SANE_FALSE;
+      return SANE_STATUS_EOF;
+    }
+
+  if (s->buffer_bytes == 0)
+    {
+      SANE_Int size = MA1509_BUFFER_SIZE;
+      if (size > (total_size - s->total_bytes))
+	size = total_size - s->total_bytes;
+      DBG (4, "sane_read: trying to read %d bytes\n", size);
+      status = read_data (s, s->buffer, &size);
+      if (status != SANE_STATUS_GOOD)
+	{
+	  DBG (1, "sane_read: read_data failed: %s\n",
+	       sane_strstatus (status));
+	  *len = 0;
+	  return status;
+	}
+      s->total_bytes += size;
+      s->buffer_start = s->buffer;
+      s->buffer_bytes = size;
+    }
+
+  *len = max_len;
+  if (*len > s->buffer_bytes)
+    *len = s->buffer_bytes;
+
+  memcpy (buf, s->buffer_start, *len);
+  s->buffer_start += (*len);
+  s->buffer_bytes -= (*len);
+  s->read_bytes += (*len);
+
+  /* invert for lineart mode */
+  if (strcmp (s->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_LINEART) == 0)
+    {
+      for (i = 0; i < *len; i++)
+	buf[i] = ~buf[i];
+    }
+
+  DBG (4, "sane_read: read %d/%d bytes (%d bytes to go, %d total)\n", *len,
+       max_len, total_size - s->read_bytes, total_size);
+
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_cancel (SANE_Handle handle)
+{
+  Ma1509_Scanner *s = handle;
+
+  if (!s)
+    {
+      DBG (1, "sane_cancel: handle is null!\n");
+      return;
+    }
+
+  DBG (4, "sane_cancel\n");
+  if (s->scanning)
+    {
+      s->cancelled = SANE_TRUE;
+      stop_scan (s);
+      free (s->buffer);
+    }
+  s->scanning = SANE_FALSE;
+  DBG (4, "sane_cancel finished\n");
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
+{
+  Ma1509_Scanner *s = handle;
+
+  if (!s)
+    {
+      DBG (1, "sane_set_io_mode: handle is null!\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  DBG (4, "sane_set_io_mode: %s\n",
+       non_blocking ? "non-blocking" : "blocking");
+
+  if (!s->scanning)
+    {
+      DBG (1, "sane_set_io_mode: call sane_start before sane_set_io_mode");
+      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)
+{
+  Ma1509_Scanner *s = handle;
+
+  if (!s)
+    {
+      DBG (1, "sane_get_select_fd: handle is null!\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (!fd)
+    {
+      DBG (1, "sane_get_select_fd: fd is null!\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  DBG (4, "sane_get_select_fd\n");
+  if (!s->scanning)
+    return SANE_STATUS_INVAL;
+
+  return SANE_STATUS_UNSUPPORTED;
+}