Initial import of sane-backends version 1.0.24-1.2

1 files changed, 1025 insertions, 0 deletions

diff --git a/backend/ricoh.c b/backend/ricoh.c
new file mode 100644
index 0000000..a349179
--- /dev/null
+++ b/backend/ricoh.c
@@ -0,0 +1,1025 @@
+/* sane - Scanner Access Now Easy.
+   Copyright (C) 1998, Feico W. Dillema
+   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.
+*/
+
+/*
+	$Id$
+        This file implements a SANE backend for Ricoh flatbed scanners.  
+*/
+
+#include "../include/sane/config.h"
+
+#include <limits.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <time.h>
+#include <sys/time.h>
+#include <unistd.h>
+#include <ctype.h>
+
+#include "../include/sane/sane.h"
+#include "../include/sane/saneopts.h"
+#include "../include/sane/sanei_scsi.h"
+
+#define BACKEND_NAME ricoh
+#include "../include/sane/sanei_backend.h"
+
+#ifndef PATH_MAX
+# define PATH_MAX	1024
+#endif
+
+#include "../include/sane/sanei_config.h"
+#define RICOH_CONFIG_FILE "ricoh.conf"
+
+#include "ricoh.h"
+
+#define MAX(a,b)	((a) > (b) ? (a) : (b))
+
+static int num_devices = 0;
+static Ricoh_Device *first_dev = NULL;
+static Ricoh_Scanner *first_handle = NULL;
+static int is50 = 0;
+
+#include "ricoh-scsi.c"
+
+static size_t
+max_string_size (const SANE_String_Const strings[])
+{
+  size_t size, max_size = 0;
+  int i;
+  DBG (11, ">> max_string_size\n");
+
+  for (i = 0; strings[i]; ++i)
+    {
+      size = strlen (strings[i]) + 1;
+      if (size > max_size)
+        max_size = size;
+    }
+
+  DBG (11, "<< max_string_size\n");
+  return max_size;
+}
+
+static SANE_Status
+attach (const char *devnam, Ricoh_Device ** devp)
+{
+  SANE_Status status;
+  Ricoh_Device *dev;
+
+  int fd;
+  struct inquiry_data ibuf;
+  struct measurements_units_page mup;
+  struct ricoh_window_data wbuf;
+  size_t buf_size;
+  char *str;
+  DBG (11, ">> attach\n");
+
+  for (dev = first_dev; dev; dev = dev->next)
+    {
+      if (strcmp (dev->sane.name, devnam) == 0)
+        {
+          if (devp)
+            *devp = dev;
+          return (SANE_STATUS_GOOD);
+        }
+    }
+
+  DBG (3, "attach: opening %s\n", devnam);
+  status = sanei_scsi_open (devnam, &fd, NULL, NULL);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: open failed: %s\n", sane_strstatus (status));
+      return (status);
+    }
+
+  DBG (3, "attach: sending INQUIRY\n");
+  memset (&ibuf, 0, sizeof (ibuf));
+  buf_size = sizeof(ibuf);
+  status = inquiry (fd, &ibuf, &buf_size);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: inquiry failed: %s\n", sane_strstatus (status));
+      sanei_scsi_close (fd);
+      return (status);
+    }
+
+  if (ibuf.devtype != 6
+      || strncmp ((char *)ibuf.vendor, "RICOH", 5) != 0
+      || (strncmp ((char *)ibuf.product, "IS50", 4) != 0
+	  && strncmp ((char *)ibuf.product, "IS60", 4) != 0))
+    {
+      DBG (1, "attach: device doesn't look like the Ricoh scanner I know\n");
+      sanei_scsi_close (fd);
+      return (SANE_STATUS_INVAL);
+    }
+  is50 = (strncmp ((char *)ibuf.product, "IS50", 4) == 0);
+
+  DBG (3, "attach: sending TEST_UNIT_READY\n");
+  status = test_unit_ready (fd);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: test unit ready failed (%s)\n",
+           sane_strstatus (status));
+      sanei_scsi_close (fd);
+      return (status);
+    }
+
+  DBG (3, "attach: sending OBJECT POSITION\n");
+  status = object_position (fd);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: OBJECT POSTITION failed\n");
+      sanei_scsi_close (fd);
+      return (SANE_STATUS_INVAL);
+    }
+
+  memset (&mup, 0, sizeof (mup));
+  mup.page_code = MEASUREMENTS_PAGE;
+  mup.parameter_length = 0x06;
+  mup.bmu = INCHES;
+  mup.mud[0] = (DEFAULT_MUD >> 8) & 0xff;
+  mup.mud[1] = (DEFAULT_MUD & 0xff);
+
+#if 0
+  DBG (3, "attach: sending MODE SELECT\n");
+  status = mode_select (fd, (struct mode_pages *) &mup);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: MODE_SELECT failed\n");
+      sanei_scsi_close (fd);
+      return (SANE_STATUS_INVAL);
+    } 
+#endif
+
+#if 0
+  DBG (3, "attach: sending MODE SENSE\n");
+  memset (&mup, 0, sizeof (mup));
+  status = mode_sense (fd, (struct mode_pages *) &mup, PC_CURRENT | MEASUREMENTS_PAGE);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: MODE_SENSE failed\n");
+      sanei_scsi_close (fd);
+      return (SANE_STATUS_INVAL);
+    }
+#endif
+
+  DBG (3, "attach: sending GET WINDOW\n");
+  memset (&wbuf, 0, sizeof (wbuf));
+  status = get_window (fd, &wbuf);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: GET_WINDOW failed %d\n", status);
+      sanei_scsi_close (fd);
+      DBG (11, "<< attach\n");
+      return (SANE_STATUS_INVAL);
+    }
+
+  sanei_scsi_close (fd);
+
+  dev = malloc (sizeof (*dev));
+  if (!dev)
+    return (SANE_STATUS_NO_MEM);
+  memset (dev, 0, sizeof (*dev));
+
+  dev->sane.name = strdup (devnam);
+  dev->sane.vendor = "RICOH";
+  str = malloc (16 + 1);
+  memset (str, 0, sizeof (str));
+  strncpy (str, (char *)ibuf.product, sizeof(ibuf.product));
+  strncpy (str + sizeof(ibuf.revision), (char *)ibuf.revision, sizeof(ibuf.revision));
+  str[sizeof(ibuf.product) + sizeof(ibuf.revision)] = '\0';
+  dev->sane.model = str;
+  dev->sane.type = "flatbed scanner";
+
+  DBG (5, "dev->sane.name = %s\n", dev->sane.name);
+  DBG (5, "dev->sane.vendor = %s\n", dev->sane.vendor);
+  DBG (5, "dev->sane.model = %s\n", dev->sane.model);
+  DBG (5, "dev->sane.type = %s\n", dev->sane.type);
+
+  dev->info.xres_default = _2btol(wbuf.x_res);
+  dev->info.yres_default = _2btol(wbuf.y_res);
+  dev->info.image_mode_default = wbuf.image_comp;
+
+  /* if you throw the MRIF bit the brighness control reverses too */
+  /* so I reverse the reversal in software for symmetry's sake */
+  /* I should make this into an option */
+
+  if (wbuf.image_comp == RICOH_GRAYSCALE || wbuf.image_comp == RICOH_DITHERED_MONOCHROME)
+    {
+      dev->info.brightness_default = 256 - wbuf.brightness;
+      if (is50)
+	dev->info.contrast_default = wbuf.contrast;
+      else
+	dev->info.contrast_default = 256 - wbuf.contrast;
+    }
+  else /* wbuf.image_comp == RICOH_BINARY_MONOCHROME */
+    {
+      dev->info.brightness_default = wbuf.brightness;
+      dev->info.contrast_default = wbuf.contrast;
+    }
+
+#if 1
+  dev->info.bmu = mup.bmu;
+  dev->info.mud = _2btol(mup.mud);
+  if (dev->info.mud == 0) {
+    /* The RICOH says it uses points as default Basic Measurement Unit */
+    /* but gives a Measurement Unit Divisor of zero */
+    /* So, we set it to the default (SCSI-standard) of 1200 */
+    /* with BMU in inches, i.e. 1200 points equal 1 inch */
+    dev->info.bmu = INCHES;
+    dev->info.mud = DEFAULT_MUD;
+  }
+#else
+    dev->info.bmu = INCHES;
+    dev->info.mud = DEFAULT_MUD;
+#endif
+
+  DBG (5, "xres_default=%d\n", dev->info.xres_default);
+  DBG (5, "xres_range.max=%d\n", dev->info.xres_range.max);
+  DBG (5, "xres_range.min=%d\n", dev->info.xres_range.min);
+
+  DBG (5, "yres_default=%d\n", dev->info.yres_default);
+  DBG (5, "yres_range.max=%d\n", dev->info.yres_range.max);
+  DBG (5, "yres_range.min=%d\n", dev->info.yres_range.min);
+
+  DBG (5, "x_range.max=%d\n", dev->info.x_range.max);
+  DBG (5, "y_range.max=%d\n", dev->info.y_range.max);
+
+  DBG (5, "image_mode=%d\n", dev->info.image_mode_default);
+
+  DBG (5, "brightness=%d\n", dev->info.brightness_default);
+  DBG (5, "contrast=%d\n", dev->info.contrast_default);
+
+  DBG (5, "bmu=%d\n", dev->info.bmu);
+  DBG (5, "mud=%d\n", dev->info.mud);
+
+  ++num_devices;
+  dev->next = first_dev;
+  first_dev = dev;
+
+  if (devp)
+    *devp = dev;
+
+  DBG (11, "<< attach\n");
+  return (SANE_STATUS_GOOD);
+}
+
+static SANE_Status
+attach_one(const char *devnam)
+{
+  attach (devnam, NULL);
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+init_options (Ricoh_Scanner * s)
+{
+  int i;
+  DBG (11, ">> init_options\n");
+
+  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].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 = "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].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].size = max_string_size (mode_list);
+  s->opt[OPT_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  s->opt[OPT_MODE].constraint.string_list = mode_list;
+  s->val[OPT_MODE].s = strdup (mode_list[s->hw->info.image_mode_default]);
+
+  /* x resolution */
+  s->opt[OPT_X_RESOLUTION].name = "X" SANE_NAME_SCAN_RESOLUTION;
+  s->opt[OPT_X_RESOLUTION].title = "X " SANE_TITLE_SCAN_RESOLUTION;
+  s->opt[OPT_X_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
+  s->opt[OPT_X_RESOLUTION].type = SANE_TYPE_INT;
+  s->opt[OPT_X_RESOLUTION].unit = SANE_UNIT_DPI;
+  s->opt[OPT_X_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_X_RESOLUTION].constraint.range = &is60_res_range;
+  s->val[OPT_X_RESOLUTION].w = s->hw->info.xres_default;
+  if (is50)
+    s->opt[OPT_X_RESOLUTION].constraint.range = &is50_res_range;
+  else
+    s->opt[OPT_X_RESOLUTION].constraint.range = &is60_res_range;
+
+  /* y resolution */
+  s->opt[OPT_Y_RESOLUTION].name = "Y" SANE_NAME_SCAN_RESOLUTION;
+  s->opt[OPT_Y_RESOLUTION].title = "Y " SANE_TITLE_SCAN_RESOLUTION;
+  s->opt[OPT_Y_RESOLUTION].desc = SANE_DESC_SCAN_RESOLUTION;
+  s->opt[OPT_Y_RESOLUTION].type = SANE_TYPE_INT;
+  s->opt[OPT_Y_RESOLUTION].unit = SANE_UNIT_DPI;
+  s->opt[OPT_Y_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->val[OPT_Y_RESOLUTION].w =  s->hw->info.yres_default;
+  if (is50)
+    s->opt[OPT_Y_RESOLUTION].constraint.range = &is50_res_range;
+  else
+    s->opt[OPT_Y_RESOLUTION].constraint.range = &is60_res_range;
+
+  /* "Geometry" group: */
+  s->opt[OPT_GEOMETRY_GROUP].title = "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].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_INT;
+  s->opt[OPT_TL_X].unit = SANE_UNIT_PIXEL;
+  s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_TL_X].constraint.range = &default_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_INT;
+  s->opt[OPT_TL_Y].unit = SANE_UNIT_PIXEL;
+  s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_TL_Y].constraint.range = &default_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_INT;
+  s->opt[OPT_BR_X].unit = SANE_UNIT_PIXEL;
+  s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BR_X].constraint.range = &default_x_range;
+  s->val[OPT_BR_X].w = default_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_INT;
+  s->opt[OPT_BR_Y].unit = SANE_UNIT_PIXEL;
+  s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BR_Y].constraint.range = &default_y_range;
+  s->val[OPT_BR_Y].w = default_y_range.max;
+
+  /* "Enhancement" group: */
+  s->opt[OPT_ENHANCEMENT_GROUP].title = "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].constraint_type = SANE_CONSTRAINT_NONE;
+
+  /* brightness */
+  s->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
+  s->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
+  s->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS;
+  s->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
+  s->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE;
+  s->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BRIGHTNESS].constraint.range = &u8_range;
+  s->val[OPT_BRIGHTNESS].w =  s->hw->info.brightness_default;
+
+  /* contrast */
+  s->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
+  s->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
+  s->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST;
+  s->opt[OPT_CONTRAST].type = SANE_TYPE_INT;
+  s->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE;
+  s->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_CONTRAST].constraint.range = &u8_range;
+  s->val[OPT_CONTRAST].w =  s->hw->info.contrast_default;
+
+  DBG (11, "<< init_options\n");
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+do_cancel (Ricoh_Scanner * s)
+{
+  SANE_Status status;
+  DBG (11, ">> do_cancel\n");
+
+  DBG (3, "cancel: sending OBJECT POSITION\n");
+  status = object_position (s->fd);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "cancel: OBJECT POSTITION failed\n");
+    }
+
+  s->scanning = SANE_FALSE;
+
+  if (s->fd >= 0)
+    {
+      sanei_scsi_close (s->fd);
+      s->fd = -1;
+    }
+
+  DBG (11, "<< do_cancel\n");
+  return (SANE_STATUS_CANCELLED);
+}
+
+SANE_Status
+sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
+{
+  char devnam[PATH_MAX] = "/dev/scanner";
+  FILE *fp;
+
+  authorize = authorize;		/* silence gcc */
+
+  DBG_INIT ();
+  DBG (11, ">> sane_init\n");
+
+#if defined PACKAGE && defined VERSION
+  DBG (2, "sane_init: " PACKAGE " " VERSION "\n");
+#endif
+
+  if (version_code)
+    *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0);
+
+  fp = sanei_config_open(RICOH_CONFIG_FILE);
+  if (fp)
+    {
+      char line[PATH_MAX], *lp;
+      size_t len;
+
+      /* read config file */
+      while (sanei_config_read (line, sizeof (line), fp))
+        {
+          if (line[0] == '#')           /* ignore line comments */
+            continue;
+          len = strlen (line);
+  
+          if (!len)
+            continue;                   /* ignore empty lines */
+
+	  /* skip white space: */
+	  for (lp = line; isspace(*lp); ++lp);
+          strcpy (devnam, lp);
+        }
+      fclose (fp);
+    }
+  sanei_config_attach_matching_devices (devnam, attach_one);
+  DBG (11, "<< sane_init\n");
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_exit (void)
+{
+  Ricoh_Device *dev, *next;
+  DBG (11, ">> sane_exit\n");
+
+  for (dev = first_dev; dev; dev = next)
+    {
+      next = dev->next;
+      free ((void *) dev->sane.name);
+      free ((void *) dev->sane.model);
+      free (dev);
+    }
+
+  DBG (11, "<< sane_exit\n");
+}
+
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
+{
+  static const SANE_Device **devlist = 0;
+  Ricoh_Device *dev;
+  int i;
+
+  local_only = local_only;		/* silence gcc */
+
+  DBG (11, ">> sane_get_devices\n");
+
+  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; dev; dev = dev->next)
+    devlist[i++] = &dev->sane;
+  devlist[i++] = 0;
+
+  *device_list = devlist;
+
+  DBG (11, "<< sane_get_devices\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_open (SANE_String_Const devnam, SANE_Handle * handle)
+{
+  SANE_Status status;
+  Ricoh_Device *dev;
+  Ricoh_Scanner *s;
+  DBG (11, ">> sane_open\n");
+
+  if (devnam[0] == '\0')
+    {
+      for (dev = first_dev; dev; dev = dev->next)
+        {
+          if (strcmp (dev->sane.name, devnam) == 0)
+            break;
+        }
+
+      if (!dev)
+        {
+          status = attach (devnam, &dev);
+          if (status != SANE_STATUS_GOOD)
+            return (status);
+        }
+    }
+  else
+    {
+      dev = first_dev;
+    }
+
+  if (!dev)
+    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);
+
+  s->next = first_handle;
+  first_handle = s;
+
+  *handle = s;
+
+  DBG (11, "<< sane_open\n");
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_close (SANE_Handle handle)
+{
+  Ricoh_Scanner *s = (Ricoh_Scanner *) handle;
+  DBG (11, ">> sane_close\n");
+
+  if (s->fd != -1)
+    sanei_scsi_close (s->fd);
+  free (s);
+
+  DBG (11, ">> sane_close\n");
+}
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+  Ricoh_Scanner *s = handle;
+  DBG (11, ">> sane_get_option_descriptor\n");
+
+  if ((unsigned) option >= NUM_OPTIONS)
+    return (0);
+
+  DBG (11, "<< sane_get_option_descriptor\n");
+  return (s->opt + option);
+}
+
+SANE_Status
+sane_control_option (SANE_Handle handle, SANE_Int option,
+                     SANE_Action action, void *val, SANE_Int * info)
+{
+  Ricoh_Scanner *s = handle;
+  SANE_Status status;
+  SANE_Word cap;
+  DBG (11, ">> sane_control_option\n");
+
+  if (info)
+    *info = 0;
+
+  if (s->scanning)
+    return (SANE_STATUS_DEVICE_BUSY);
+  if (option >= NUM_OPTIONS)
+    return (SANE_STATUS_INVAL);
+
+  cap = s->opt[option].cap;
+  if (!SANE_OPTION_IS_ACTIVE (cap))
+    return (SANE_STATUS_INVAL);
+
+  if (action == SANE_ACTION_GET_VALUE)
+    {
+      switch (option)
+        {
+          /* word options: */
+        case OPT_X_RESOLUTION:
+        case OPT_Y_RESOLUTION:
+        case OPT_TL_X:
+        case OPT_TL_Y:
+        case OPT_BR_X:
+        case OPT_BR_Y:
+        case OPT_NUM_OPTS:
+        case OPT_BRIGHTNESS:
+        case OPT_CONTRAST:
+          *(SANE_Word *) val = s->val[option].w;
+          return (SANE_STATUS_GOOD);
+
+          /* string options: */
+        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))
+        return (SANE_STATUS_INVAL);
+
+      status = sanei_constrain_value (s->opt + option, val, info);
+      if (status != SANE_STATUS_GOOD)
+        return status;
+
+      switch (option)
+        {
+          /* (mostly) side-effect-free word options: */
+        case OPT_X_RESOLUTION:
+        case OPT_Y_RESOLUTION:
+        case OPT_TL_X:
+        case OPT_TL_Y:
+        case OPT_BR_X:
+        case OPT_BR_Y:
+          if (info && s->val[option].w != *(SANE_Word *) val)
+            *info |= SANE_INFO_RELOAD_PARAMS;
+          /* fall through */
+        case OPT_NUM_OPTS:
+        case OPT_BRIGHTNESS:
+        case OPT_CONTRAST:
+          s->val[option].w = *(SANE_Word *) val;
+          return (SANE_STATUS_GOOD);
+
+        case OPT_MODE:
+          if (info && strcmp (s->val[option].s, (SANE_String) val))
+            *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
+          if (s->val[option].s)
+            free (s->val[option].s);
+          s->val[option].s = strdup (val);
+          return (SANE_STATUS_GOOD);
+        }
+    }
+
+  DBG (11, "<< sane_control_option\n");
+  return (SANE_STATUS_INVAL);
+}
+
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
+{
+  Ricoh_Scanner *s = handle;
+  DBG (11, ">> sane_get_parameters\n");
+
+  if (!s->scanning)
+    {
+      int width, length, xres, yres;
+      const char *mode;
+
+      memset (&s->params, 0, sizeof (s->params));
+
+      width = s->val[OPT_BR_X].w - s->val[OPT_TL_X].w;
+      length = s->val[OPT_BR_Y].w - s->val[OPT_TL_Y].w;
+      xres = s->val[OPT_X_RESOLUTION].w;
+      yres = s->val[OPT_Y_RESOLUTION].w;
+
+      /* make best-effort guess at what parameters will look like once
+         scanning starts.  */
+      if (xres > 0 && yres > 0 && width > 0 && length > 0)
+        {
+          s->params.pixels_per_line = width * xres / s->hw->info.mud;
+          s->params.lines = length * yres / s->hw->info.mud;
+        }
+
+      mode = s->val[OPT_MODE].s;
+      if (strcmp (mode, SANE_VALUE_SCAN_MODE_LINEART) == 0 || strcmp (mode, SANE_VALUE_SCAN_MODE_HALFTONE) == 0)
+        {
+          s->params.format = SANE_FRAME_GRAY;
+          s->params.bytes_per_line = s->params.pixels_per_line / 8;
+	  /* the Ricoh truncates to the byte boundary, so: chop! */
+          s->params.pixels_per_line = s->params.bytes_per_line * 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;
+        }
+      s->params.last_frame = SANE_TRUE;
+    }
+
+  if (params)
+    *params = s->params;
+
+  DBG (1, "%d pixels per line, %d bytes, %d lines high, total %lu bytes, "
+       "dpi=%d\n", s->params.pixels_per_line, s->params.bytes_per_line,
+       s->params.lines, (u_long) s->bytes_to_read, s->val[OPT_Y_RESOLUTION].w);
+
+  DBG (11, "<< sane_get_parameters\n");
+  return (SANE_STATUS_GOOD);
+}
+
+
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+  char *mode_str;
+  Ricoh_Scanner *s = handle;
+  SANE_Status status;
+  struct ricoh_window_data wbuf;
+  struct measurements_units_page mup;
+
+  DBG (11, ">> sane_start\n");
+
+  /* First make sure we have a current parameter set.  Some of the
+     parameters will be overwritten below, but that's OK.  */
+  status = sane_get_parameters (s, 0);
+  if (status != SANE_STATUS_GOOD)
+    return status;
+
+  status = sanei_scsi_open (s->hw->sane.name, &s->fd, 0, 0);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "open of %s failed: %s\n",
+           s->hw->sane.name, sane_strstatus (status));
+      return (status);
+    }
+
+  mode_str = s->val[OPT_MODE].s;
+  s->xres = s->val[OPT_X_RESOLUTION].w;
+  s->yres = s->val[OPT_Y_RESOLUTION].w;
+  s->ulx = s->val[OPT_TL_X].w;
+  s->uly = s->val[OPT_TL_Y].w;
+  s->width = s->val[OPT_BR_X].w - s->val[OPT_TL_X].w;
+  s->length = s->val[OPT_BR_Y].w - s->val[OPT_TL_Y].w;
+  s->brightness = s->val[OPT_BRIGHTNESS].w;
+  s->contrast = s->val[OPT_CONTRAST].w;
+  s->bpp = s->params.depth;
+  if (strcmp (mode_str, SANE_VALUE_SCAN_MODE_LINEART) == 0) 
+    {
+      s->image_composition = RICOH_BINARY_MONOCHROME;
+    }
+  else if (strcmp (mode_str, SANE_VALUE_SCAN_MODE_HALFTONE) == 0)
+    {
+      s->image_composition = RICOH_DITHERED_MONOCHROME;
+    }
+  else if (strcmp (mode_str, SANE_VALUE_SCAN_MODE_GRAY) == 0)
+    {
+      s->image_composition = RICOH_GRAYSCALE;
+    }
+
+  memset (&wbuf, 0, sizeof (wbuf));
+  _lto2b(sizeof(wbuf) - 8, wbuf.len);
+  _lto2b(s->xres, wbuf.x_res);
+  _lto2b(s->yres, wbuf.y_res);
+  _lto4b(s->ulx, wbuf.x_org);
+  _lto4b(s->uly, wbuf.y_org);
+  _lto4b(s->width, wbuf.width);
+  _lto4b(s->length, wbuf.length);
+
+  wbuf.image_comp = s->image_composition;
+  /* if you throw the MRIF bit the brighness control reverses too */
+  /* so I reverse the reversal in software for symmetry's sake */
+  if (wbuf.image_comp == RICOH_GRAYSCALE || wbuf.image_comp == RICOH_DITHERED_MONOCHROME) 
+    {
+      if (wbuf.image_comp == RICOH_GRAYSCALE) 
+	wbuf.mrif_filtering_gamma_id = (SANE_Byte) 0x90;
+      if (wbuf.image_comp == RICOH_DITHERED_MONOCHROME) 
+	wbuf.mrif_filtering_gamma_id = (SANE_Byte) 0x10;
+      wbuf.brightness = 256 - (SANE_Byte) s->brightness;
+      if (is50)
+        wbuf.contrast = (SANE_Byte) s->contrast;
+      else
+        wbuf.contrast = 256 - (SANE_Byte) s->contrast;
+    }
+  else /* wbuf.image_comp == RICOH_BINARY_MONOCHROME */
+    {
+      wbuf.mrif_filtering_gamma_id = (SANE_Byte) 0x00;
+      wbuf.brightness = (SANE_Byte) s->brightness;
+      wbuf.contrast = (SANE_Byte) s->contrast;
+    }
+
+  wbuf.threshold = 0;
+  wbuf.bits_per_pixel = s->bpp;
+
+  wbuf.halftone_pattern[0] = 2;
+  wbuf.halftone_pattern[1] = 0;
+  wbuf.pad_type = 3;
+  wbuf.bit_ordering[0] = 0;
+  wbuf.bit_ordering[1] = 3;
+
+  DBG (5, "xres=%d\n", _2btol(wbuf.x_res));
+  DBG (5, "yres=%d\n", _2btol(wbuf.y_res));
+  DBG (5, "ulx=%d\n", _4btol(wbuf.x_org));
+  DBG (5, "uly=%d\n", _4btol(wbuf.y_org));
+  DBG (5, "width=%d\n", _4btol(wbuf.width));
+  DBG (5, "length=%d\n", _4btol(wbuf.length));
+  DBG (5, "image_comp=%d\n", wbuf.image_comp);
+
+  DBG (11, "sane_start: sending SET WINDOW\n");
+  status = set_window (s->fd, &wbuf);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "SET WINDOW failed: %s\n", sane_strstatus (status));
+      return (status);
+    }
+
+  DBG (11, "sane_start: sending GET WINDOW\n");
+  memset (&wbuf, 0, sizeof (wbuf));
+  status = get_window (s->fd, &wbuf);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "GET WINDOW failed: %s\n", sane_strstatus (status));
+      return (status); 
+    }
+  DBG (5, "xres=%d\n", _2btol(wbuf.x_res));
+  DBG (5, "yres=%d\n", _2btol(wbuf.y_res));
+  DBG (5, "ulx=%d\n", _4btol(wbuf.x_org));
+  DBG (5, "uly=%d\n", _4btol(wbuf.y_org));
+  DBG (5, "width=%d\n", _4btol(wbuf.width));
+  DBG (5, "length=%d\n", _4btol(wbuf.length));
+  DBG (5, "image_comp=%d\n", wbuf.image_comp);
+
+  DBG (11, "sane_start: sending MODE SELECT\n");
+  memset (&mup, 0, sizeof (mup));
+  mup.page_code = MEASUREMENTS_PAGE;
+  mup.parameter_length = 0x06;
+  mup.bmu = INCHES;
+  mup.mud[0] = (DEFAULT_MUD >> 8) & 0xff;
+  mup.mud[1] = (DEFAULT_MUD & 0xff);
+
+  status = mode_select (s->fd, (struct mode_pages *) &mup);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: MODE_SELECT failed\n");
+      return (SANE_STATUS_INVAL);
+    }
+
+  status = trigger_scan (s->fd);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "start of scan failed: %s\n", sane_strstatus (status));
+      return (status);
+    }
+
+  /* Wait for scanner to become ready to transmit data */
+  status = ricoh_wait_ready (s);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "GET DATA STATUS failed: %s\n", sane_strstatus (status));
+      return (status);
+    } 
+
+  s->bytes_to_read = s->params.bytes_per_line * s->params.lines;
+
+  DBG (1, "%d pixels per line, %d bytes, %d lines high, total %lu bytes, "
+       "dpi=%d\n", s->params.pixels_per_line, s->params.bytes_per_line,
+       s->params.lines, (u_long) s->bytes_to_read, s->val[OPT_Y_RESOLUTION].w);
+ 
+  s->scanning = SANE_TRUE;
+
+  DBG (11, "<< sane_start\n"); 
+  return (SANE_STATUS_GOOD); 
+}
+
+SANE_Status
+sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
+           SANE_Int * len)
+{
+  Ricoh_Scanner *s = handle;
+  SANE_Status status;
+  size_t nread;
+  DBG (11, ">> sane_read\n");
+
+  *len = 0;
+
+  DBG (11, "sane_read: bytes left to read: %ld\n", (u_long) s->bytes_to_read);
+  
+  if (s->bytes_to_read == 0)
+    {
+      do_cancel (s);
+      return (SANE_STATUS_EOF);
+    }
+
+  if (!s->scanning) {
+    DBG (11, "sane_read: scanning is false!\n");
+    return (do_cancel (s));
+  } 
+
+  nread = max_len;
+  if (nread > s->bytes_to_read)
+    nread = s->bytes_to_read;
+
+  DBG (11, "sane_read: read %ld bytes\n", (u_long) nread);
+  status = read_data (s->fd, buf, &nread);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (11, "sane_read: read error\n");
+      do_cancel (s);
+      return (SANE_STATUS_IO_ERROR);
+    }
+  *len = nread;
+  s->bytes_to_read -= nread;
+
+  DBG (11, "<< sane_read\n");
+  return (SANE_STATUS_GOOD);
+}
+
+void
+sane_cancel (SANE_Handle handle)
+{
+  Ricoh_Scanner *s = handle;
+  DBG (11, ">> sane_cancel\n");
+
+  s->scanning = SANE_FALSE;
+
+  DBG (11, "<< sane_cancel\n");
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
+{
+  handle = handle;				/* silence gcc */
+  non_blocking = non_blocking;	/* silence gcc */
+
+  DBG (5, ">> sane_set_io_mode\n");
+  DBG (5, "<< sane_set_io_mode\n");
+
+  return SANE_STATUS_UNSUPPORTED;
+}
+
+SANE_Status
+sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
+{
+  handle = handle;				/* silence gcc */
+  fd = fd;						/* silence gcc */
+
+  DBG (5, ">> sane_get_select_fd\n");
+  DBG (5, "<< sane_get_select_fd\n");
+
+  return SANE_STATUS_UNSUPPORTED;
+}