New upstream version 1.0.28upstream/1.0.28

1 files changed, 971 insertions, 0 deletions

diff --git a/backend/ricoh2.c b/backend/ricoh2.c
new file mode 100644
index 0000000..8aa938e
--- /dev/null
+++ b/backend/ricoh2.c
@@ -0,0 +1,971 @@
+/* sane - Scanner Access Now Easy.
+
+   Copyright (C) 2018 Stanislav Yuzvinsky
+   Based on the work done by viruxx
+
+   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.
+*/
+
+#include "../include/sane/config.h"
+
+#include <string.h>
+
+#include "../include/sane/sane.h"
+#include "../include/sane/sanei.h"
+#include "../include/sane/sanei_usb.h"
+#include "../include/sane/saneopts.h"
+#include "../include/sane/sanei_backend.h"
+#include "../include/sane/sanei_debug.h"
+
+#include "ricoh2_buffer.c"
+
+#define MAX_OPTION_STRING_SIZE  255
+#define MAX_LINE_SIZE           240 * 256 /* = 61440 */
+#define HEIGHT_PIXELS_300DPI    3508
+#define WIDTH_BYTES_300DPI      2560
+#define WIDTH_PIXELS_300DPI     2550
+#define INFO_SIZE               (WIDTH_BYTES_300DPI - WIDTH_PIXELS_300DPI)
+#define USB_TIMEOUT_MS          20000
+#define MAX_COMMAND_SIZE        64
+
+#define CHECK_IF(x) if (!(x)) return SANE_STATUS_INVAL
+
+typedef enum
+{
+  OPT_NUM_OPTS = 0,
+  OPT_MODE,
+  OPT_RESOLUTION,
+
+  /* must come last: */
+  NUM_OPTIONS
+}
+Ricoh_Options;
+
+typedef enum
+{
+  SCAN_MODE_COLOR,
+  SCAN_MODE_GRAY
+}
+Scan_Mode;
+
+
+typedef struct Ricoh2_Device {
+  struct Ricoh2_Device *next;
+  SANE_Device           sane;
+  SANE_Bool             active;
+
+  /* options */
+  SANE_Option_Descriptor opt[NUM_OPTIONS];
+  Option_Value           val[NUM_OPTIONS];
+
+  /* acquiring session */
+  SANE_Int       dn;
+  SANE_Bool      cancelled;
+  Scan_Mode      mode;
+  SANE_Int       resolution;
+  SANE_Bool      eof;
+  size_t         bytes_to_read;
+  ricoh2_buffer *buffer;
+
+}
+Ricoh2_Device;
+
+typedef struct Ricoh2_device_info {
+  SANE_Int          product_id;
+  SANE_String_Const device_name;
+}
+Ricoh2_device_info;
+
+static Ricoh2_device_info supported_devices[] = {
+  { 0x042c, "Aficio SP100SU"   },
+  { 0x0438, "Aficio SG3100SNw" },
+  { 0x0448, "Aficio SP111SU"   }
+};
+
+static SANE_String_Const mode_list[] = {
+  SANE_VALUE_SCAN_MODE_COLOR,
+  SANE_VALUE_SCAN_MODE_GRAY,
+  NULL
+};
+static SANE_String_Const default_mode = SANE_VALUE_SCAN_MODE_COLOR;
+
+static SANE_Int resolution_list[] = {
+  2, 300, 600
+};
+static SANE_Int default_resolution = 300;
+
+static SANE_Bool initialized = SANE_FALSE;
+static Ricoh2_Device *ricoh2_devices = NULL;
+static const SANE_Device **sane_devices = NULL;
+static SANE_Int num_devices = 0;
+
+static Ricoh2_Device *
+lookup_handle(SANE_Handle handle)
+{
+  Ricoh2_Device *device;
+
+  for (device = ricoh2_devices; device; device = device->next)
+    {
+      if (device == handle)
+        return device;
+    }
+
+  return NULL;
+}
+
+static SANE_String_Const get_model_by_productid(SANE_Int id)
+{
+  size_t i = 0;
+  for (; i < sizeof (supported_devices) / sizeof (supported_devices[0]); ++i)
+    {
+      if (supported_devices[i].product_id == id)
+        {
+          return supported_devices[i].device_name;
+        }
+    }
+
+  return "Unidentified device";
+}
+
+static SANE_Status
+attach (SANE_String_Const devname)
+{
+  SANE_Int dn = -1;
+  SANE_Status status = SANE_STATUS_GOOD;
+  Ricoh2_Device *device = NULL;
+  SANE_Int vendor, product;
+
+  for (device = ricoh2_devices; device; device = device->next)
+    {
+      if (strcmp (device->sane.name, devname) == 0)
+        {
+          device->active = SANE_TRUE;
+          return SANE_STATUS_GOOD;
+        }
+    }
+
+  device = (Ricoh2_Device *) malloc (sizeof (Ricoh2_Device));
+  if (!device)
+    {
+      return SANE_STATUS_NO_MEM;
+    }
+
+  DBG (8, "attach %s\n", devname);
+  status = sanei_usb_open (devname, &dn);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: couldn't open device `%s': %s\n", devname,
+           sane_strstatus (status));
+      return status;
+    }
+
+  status = sanei_usb_get_vendor_product (dn, &vendor, &product);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1,
+           "attach: couldn't get vendor and product ids of device `%s': %s\n",
+           devname, sane_strstatus (status));
+      sanei_usb_close (dn);
+      return status;
+    }
+
+  sanei_usb_close (dn);
+  device->sane.name = strdup (devname);
+  device->sane.vendor = "Ricoh";
+  device->sane.model = get_model_by_productid (product);
+  device->sane.type = "flatbed scanner";
+  device->active = SANE_TRUE;
+  device->buffer = NULL;
+
+  device->next = ricoh2_devices;
+  ricoh2_devices = device;
+
+  DBG (2, "Found device %s\n", device->sane.name);
+  ++num_devices;
+
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+init_options(Ricoh2_Device *dev)
+{
+  SANE_Option_Descriptor *od;
+
+  DBG (8, "init_options: dev = %p\n", (void *) dev);
+
+  /* number of options */
+  od = &(dev->opt[OPT_NUM_OPTS]);
+  od->name = SANE_NAME_NUM_OPTIONS;
+  od->title = SANE_TITLE_NUM_OPTIONS;
+  od->desc = SANE_DESC_NUM_OPTIONS;
+  od->type = SANE_TYPE_INT;
+  od->unit = SANE_UNIT_NONE;
+  od->size = sizeof (SANE_Word);
+  od->cap = SANE_CAP_SOFT_DETECT;
+  od->constraint_type = SANE_CONSTRAINT_NONE;
+  od->constraint.range = 0;
+  dev->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
+
+  /* mode - sets the scan mode: Color, Gray */
+  od = &(dev->opt[OPT_MODE]);
+  od->name = SANE_NAME_SCAN_MODE;
+  od->title = SANE_TITLE_SCAN_MODE;
+  od->desc = SANE_DESC_SCAN_MODE;
+  od->type = SANE_TYPE_STRING;
+  od->unit = SANE_UNIT_NONE;
+  od->size = MAX_OPTION_STRING_SIZE;
+  od->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
+  od->constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  od->constraint.string_list = mode_list;
+  dev->val[OPT_MODE].s = malloc (od->size);
+  if (!dev->val[OPT_MODE].s)
+    return SANE_STATUS_NO_MEM;
+  strcpy (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR);
+
+  /* resolution */
+  od = &(dev->opt[OPT_RESOLUTION]);
+  od->name = SANE_NAME_SCAN_RESOLUTION;
+  od->title = SANE_TITLE_SCAN_RESOLUTION;
+  od->desc = SANE_DESC_SCAN_RESOLUTION;
+  od->type = SANE_TYPE_INT;
+  od->unit = SANE_UNIT_DPI;
+  od->size = sizeof (SANE_Word);
+  od->cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
+  od->constraint_type = SANE_CONSTRAINT_WORD_LIST;
+  od->constraint.word_list = resolution_list;
+  dev->val[OPT_RESOLUTION].w = 300;
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_init (SANE_Int *vc, SANE_Auth_Callback __sane_unused__ cb)
+{
+  size_t i = 0;
+
+  DBG_INIT ();
+
+  DBG(8, ">sane_init\n");
+
+  sanei_usb_init ();
+  sanei_usb_set_timeout (USB_TIMEOUT_MS);
+
+  num_devices = 0;
+
+  for (; i < sizeof (supported_devices) / sizeof (supported_devices[0]); ++i)
+    {
+      sanei_usb_find_devices (0x5ca, supported_devices[i].product_id, attach);
+    }
+
+  if (vc)
+    *vc = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0);
+  DBG(8, "<sane_init\n");
+
+  initialized = SANE_TRUE;
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_get_devices (const SANE_Device ***dl,
+                  SANE_Bool __sane_unused__ local)
+{
+  Ricoh2_Device *device = NULL;
+  SANE_Int i = 0;
+
+  DBG(8, ">sane_get_devices\n");
+
+  num_devices = 0;
+  sanei_usb_find_devices (0x5ca, 0x042c, attach);
+  sanei_usb_find_devices (0x5ca, 0x0448, attach);
+
+  if (sane_devices)
+    free (sane_devices);
+
+  sane_devices = (const SANE_Device **) malloc (sizeof (const SANE_Device *)
+                                               * (num_devices + 1));
+  if (!sane_devices)
+    return SANE_STATUS_NO_MEM;
+
+  for (device = ricoh2_devices; device; device = device->next)
+    if (device->active)
+      {
+        sane_devices[i++] = &(device->sane);
+      }
+
+  sane_devices[i] = NULL;
+  *dl = sane_devices;
+
+  DBG(2, "found %i devices\n", i);
+  DBG(8, "<sane_get_devices\n");
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_open (SANE_String_Const name, SANE_Handle *handle)
+{
+  Ricoh2_Device *device;
+  SANE_Status status;
+
+  DBG (8, ">sane_open: devicename=\"%s\", handle=%p\n", name,
+       (void *) handle);
+
+  CHECK_IF (initialized);
+  CHECK_IF (handle);
+
+  /* walk the linked list of scanner device until there is a match
+   * with the device name */
+  for (device = ricoh2_devices; device; device = device->next)
+    {
+      DBG (2, "sane_open: devname from list: %s\n",
+           device->sane.name);
+      if (strcmp (name, "") == 0
+          || strcmp (name, "ricoh") == 0
+          || strcmp (name, device->sane.name) == 0)
+        break;
+    }
+
+  *handle = device;
+
+  if (!device)
+    {
+      DBG (1, "sane_open: Not a Ricoh device\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  status = init_options (device);
+  if (status != SANE_STATUS_GOOD)
+    return status;
+
+  DBG (8, "<sane_open\n");
+
+  return SANE_STATUS_GOOD;
+}
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+  Ricoh2_Device *device;
+
+  DBG (8, "<sane_get_option_descriptor: handle=%p, option = %d\n",
+       (void *) handle, option);
+
+  if (!initialized)
+    return NULL;
+
+  /* Check for valid option number */
+  if ((option < 0) || (option >= NUM_OPTIONS))
+    return NULL;
+
+ if (!(device = lookup_handle(handle)))
+    return NULL;
+
+  if (device->opt[option].name)
+    {
+      DBG (8, ">sane_get_option_descriptor: name=%s\n",
+           device->opt[option].name);
+    }
+
+  return &(device->opt[option]);
+}
+
+SANE_Status
+sane_control_option (SANE_Handle handle,
+                     SANE_Int    option,
+                     SANE_Action action,
+                     void       *value,
+                     SANE_Word  *info)
+{
+  Ricoh2_Device *device;
+  SANE_Status status;
+
+  DBG (8,
+       ">sane_control_option: handle=%p, opt=%d, act=%d, val=%p, info=%p\n",
+       (void *) handle, option, action, (void *) value, (void *) info);
+
+  CHECK_IF (initialized);
+  device = lookup_handle (handle);
+  CHECK_IF (device);
+  CHECK_IF (value);
+  CHECK_IF (option >= 0 && option < NUM_OPTIONS);
+  CHECK_IF (device->opt[option].type != SANE_TYPE_GROUP);
+
+  switch (action)
+    {
+    case SANE_ACTION_SET_AUTO:
+      CHECK_IF (SANE_OPTION_IS_SETTABLE (device->opt[option].cap));
+      CHECK_IF (device->opt[option].cap & SANE_CAP_AUTOMATIC);
+
+      switch (option)
+        {
+        case OPT_RESOLUTION:
+          DBG (2,
+               "Setting value to default value of '%d' for option '%s'\n",
+               default_resolution,
+               device->opt[option].name);
+          device->val[option].w = default_resolution;
+          break;
+
+        case OPT_MODE:
+          DBG (2,
+               "Setting value to default value of '%s' for option '%s'\n",
+               (SANE_String_Const) default_mode,
+               device->opt[option].name);
+          strcpy (device->val[option].s, default_mode);
+          break;
+
+        default:
+          return SANE_STATUS_INVAL;
+        }
+      break;
+
+    case SANE_ACTION_SET_VALUE:
+      CHECK_IF (SANE_OPTION_IS_SETTABLE (device->opt[option].cap));
+
+      if (device->opt[option].type == SANE_TYPE_BOOL)
+        {
+          SANE_Bool bool_value = *(SANE_Bool *) value;
+          CHECK_IF (bool_value == SANE_TRUE || bool_value == SANE_FALSE);
+        }
+
+      if (device->opt[option].constraint_type == SANE_CONSTRAINT_RANGE)
+        {
+          status = sanei_constrain_value (&(device->opt[option]), value, info);
+          CHECK_IF (status == SANE_STATUS_GOOD);
+        }
+
+
+      switch (option)
+        {
+        case OPT_RESOLUTION:
+          DBG (2,
+               "Setting value to '%d' for option '%s'\n",
+               *(SANE_Word *) value,
+               device->opt[option].name);
+          device->val[option].w = *(SANE_Word *) value;
+          break;
+
+        case OPT_MODE:
+          DBG (2,
+               "Setting value to '%s' for option '%s'\n",
+               (SANE_String_Const)value,
+               device->opt[option].name);
+          strcpy (device->val[option].s, value);
+          break;
+
+        default:
+          return SANE_STATUS_INVAL;
+        }
+      break;
+
+    case SANE_ACTION_GET_VALUE:
+
+      switch (option)
+        {
+        case OPT_NUM_OPTS:
+        case OPT_RESOLUTION:
+          *(SANE_Word *) value = device->val[option].w;
+          DBG (2, "Option value = %d (%s)\n", *(SANE_Word *) value,
+               device->opt[option].name);
+          break;
+        case OPT_MODE:
+          strcpy (value, device->val[option].s);
+          break;
+        default:
+          return SANE_STATUS_INVAL;
+        }
+      break;
+
+    default:
+      return SANE_STATUS_INVAL;
+    }
+
+  DBG (8, "<sane_control_option\n");
+  return SANE_STATUS_GOOD;
+}
+
+static void
+update_scan_params (Ricoh2_Device *device)
+{
+  /* Scan mode: color or grayscale */
+  if (strcmp(device->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0)
+    {
+      device->mode = SCAN_MODE_COLOR;
+    }
+  else
+    {
+      device->mode = SCAN_MODE_GRAY;
+    }
+
+  /* resolution: 300 or 600dpi */
+  device->resolution = device->val[OPT_RESOLUTION].w;
+}
+
+
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters *params)
+{
+  Ricoh2_Device *device;
+
+  DBG (8, "sane_get_parameters: handle=%p, params=%p\n", (void *) handle,
+       (void *) params);
+
+  CHECK_IF (initialized);
+  device = lookup_handle (handle);
+  CHECK_IF (device);
+  CHECK_IF (params);
+
+  update_scan_params (device);
+
+  params->format =
+    device->mode == SCAN_MODE_COLOR ? SANE_FRAME_RGB : SANE_FRAME_GRAY;
+  params->last_frame = SANE_TRUE;
+
+  params->pixels_per_line = WIDTH_PIXELS_300DPI;
+  params->bytes_per_line = params->pixels_per_line;
+  params->lines = HEIGHT_PIXELS_300DPI;
+  params->depth = 8;
+
+  if (device->resolution == 600)
+    {
+      params->bytes_per_line *= 2;
+      params->pixels_per_line *= 2;
+      params->lines *= 2;
+    }
+
+  if (device->mode == SCAN_MODE_COLOR)
+    {
+      params->bytes_per_line *= 3;
+    }
+
+  DBG (8, ">sane_get_parameters: format = %s bytes_per_line = %d "
+          "depth = %d "
+          "pixels_per_line = %d "
+          "lines = %d\n",
+       (params->format == SANE_FRAME_RGB ? "rgb" : "gray"),
+       params->bytes_per_line,
+       params->depth,
+       params->pixels_per_line,
+       params->lines);
+
+  return SANE_STATUS_GOOD;
+}
+
+typedef struct
+{
+  SANE_Byte *send_buffer;
+  size_t     to_send;
+  SANE_Byte *receive_buffer;
+  size_t     to_receive;
+}
+Send_Receive_Pair;
+
+static SANE_Status
+send_receive (SANE_Int dn, Send_Receive_Pair *transfer)
+{
+  SANE_Status status;
+  size_t io_size;
+  SANE_Byte send_buffer[MAX_COMMAND_SIZE];
+
+  assert(transfer->to_send <= MAX_COMMAND_SIZE);
+
+  memset(send_buffer, 0, MAX_COMMAND_SIZE);
+
+  /* send a command */
+  io_size = MAX_COMMAND_SIZE;
+  DBG (128, "sending a packet of size %lu\n", io_size);
+  memcpy (send_buffer, transfer->send_buffer, transfer->to_send);
+  status = sanei_usb_write_bulk (dn, send_buffer, &io_size);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "could not send packet: %s\n", sane_strstatus (status));
+      return status;
+    }
+
+  /* receive a result */
+  io_size = transfer->to_receive;
+  DBG (128, "receiving a packet of size %lu\n", io_size);
+  if (io_size)
+    {
+      status = sanei_usb_read_bulk (dn, transfer->receive_buffer, &io_size);
+      if (status != SANE_STATUS_GOOD)
+        {
+          DBG (1, "could not get a response for packet: %s\n",
+               sane_strstatus (status));
+          return status;
+        }
+      if (io_size != transfer->to_receive)
+        {
+          DBG (1, "unexpected size of received packet: expected %lu, "
+                  "received %lu\n", transfer->to_receive, io_size);
+          return SANE_STATUS_IO_ERROR;
+        }
+    }
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+init_scan(SANE_Int dn, Scan_Mode mode, SANE_Int resolution)
+{
+  SANE_Status status = SANE_STATUS_GOOD;
+  SANE_Byte dummy_buffer[11]; /* the longest expected reply */
+  size_t i;
+
+  SANE_Byte urb_init[] = { 0x03, 0x09, 0x01 };
+  SANE_Byte magic0[] = { 0x03, 0x0d, 0x0b };
+  SANE_Byte magic1[] = {
+    0x03, 0x0c, 0x11, 0x00, 0x00, 0x00, 0x01, 0x02, 0x05,
+    0xff, 0x00, 0x00, 0x00, 0x00, 0xec, 0x13, 0x6c, 0x1b };
+  SANE_Byte magic2[] = { 0x03, 0x0b, 0x08 };
+  SANE_Byte magic3[] = {
+    0x03, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00, 0x50, 0x6d, 0x06, 0x01 };
+
+  Send_Receive_Pair transfer[] =
+  {
+    { urb_init, sizeof (urb_init), dummy_buffer,  1 },
+    { magic0,   sizeof (magic0),   dummy_buffer, 11 },
+    { magic1,   sizeof (magic1),   dummy_buffer,  0 },
+    { magic2,   sizeof (magic2),   dummy_buffer,  8 },
+    { magic3,   sizeof (magic3),   dummy_buffer,  0 }
+  };
+
+  if (resolution == 600)
+    magic1[6] = 0x02;
+
+  if (mode == SCAN_MODE_COLOR)
+    magic1[7] = 0x03;
+
+  for (i = 0;
+       i < sizeof (transfer) / sizeof (transfer[0])
+       && (status == SANE_STATUS_GOOD);
+       ++i)
+    {
+      DBG (128, "sending initialization packet %zi\n", i);
+      status = send_receive (dn, transfer + i);
+    }
+
+  return status;
+}
+
+void
+teardown_scan(SANE_Int dn)
+{
+  SANE_Byte cancel_command[] = { 0x03, 0x0a };
+  SANE_Byte end_command[]    = { 0x03, 0x09, 0x01 };
+  SANE_Byte dummy_buffer;
+  Send_Receive_Pair transfer;
+
+  DBG (128, "Sending cancel command\n");
+  transfer.send_buffer = cancel_command;
+  transfer.to_send = sizeof (cancel_command);
+  transfer.receive_buffer = &dummy_buffer;
+  transfer.to_receive = 0;
+  send_receive (dn, &transfer);
+
+  transfer.send_buffer = end_command;
+  transfer.to_send = sizeof (end_command);
+  transfer.receive_buffer = &dummy_buffer;
+  transfer.to_receive = 1;
+  send_receive (dn, &transfer);
+}
+
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+  Ricoh2_Device *device;
+  SANE_Status status;
+  SANE_Int pixels_per_line;
+  SANE_Int resolution_factor = 1;
+
+  DBG (8, ">sane_start: handle=%p\n", (void *) handle);
+
+  CHECK_IF (initialized);
+  device = lookup_handle (handle);
+  CHECK_IF (device);
+
+  update_scan_params (device);
+  device->cancelled = SANE_FALSE;
+
+  status = sanei_usb_open (device->sane.name, &(device->dn));
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "could not open device %s: %s\n",
+           device->sane.name, sane_strstatus (status));
+      return status;
+    }
+
+  DBG (2, "usb device %s opened, device number is %d\n",
+      device->sane.name, device->dn);
+
+  status = sanei_usb_claim_interface (device->dn, 0);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "could not claim interface 0: %s\n",
+           sane_strstatus (status));
+      sanei_usb_close (device->dn);
+      return status;
+    }
+
+  sanei_usb_set_endpoint (device->dn,
+                          USB_DIR_OUT | USB_ENDPOINT_TYPE_BULK,
+                          0x03);
+
+  sanei_usb_set_endpoint (device->dn,
+                          USB_DIR_IN | USB_ENDPOINT_TYPE_BULK,
+                          0x85);
+
+  status = sanei_usb_reset (device->dn);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "could not reset device %s: %s\n",
+           device->sane.name, sane_strstatus (status));
+      sanei_usb_close (device->dn);
+      return status;
+    }
+
+
+  status = init_scan (device->dn, device->mode, device->resolution);
+  if (status != SANE_STATUS_GOOD)
+    {
+      sanei_usb_close (device->dn);
+      return status;
+    }
+
+  resolution_factor = device->resolution == 600 ? 2 : 1;
+
+  pixels_per_line = WIDTH_PIXELS_300DPI * resolution_factor;
+
+  device->bytes_to_read =
+        WIDTH_PIXELS_300DPI * resolution_factor
+      * HEIGHT_PIXELS_300DPI * resolution_factor
+      * (device->mode == SCAN_MODE_COLOR ? 3 : 1);
+
+  device->buffer =
+      ricoh2_buffer_create (MAX_LINE_SIZE,
+                            pixels_per_line,
+                            INFO_SIZE * resolution_factor,
+                            device->mode == SCAN_MODE_COLOR);
+
+  DBG (8, "<sane_start: %lu bytes to read\n", device->bytes_to_read);
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_read (SANE_Handle handle,
+           SANE_Byte  *data,
+           SANE_Int    maxlen,
+           SANE_Int   *length)
+{
+  SANE_Byte read_next_command[] = { 0x03, 0x0E, 0x04, 0, 0, 0, 0, 240 };
+
+  Ricoh2_Device *device;
+  SANE_Status status;
+  Send_Receive_Pair transfer;
+
+  DBG (16, ">sane_read: handle=%p, data=%p, maxlen = %d, length=%p\n",
+       (void *) handle, (void *) data, maxlen, (void *) length);
+
+  CHECK_IF (initialized);
+  device = lookup_handle (handle);
+  CHECK_IF (device);
+  CHECK_IF (length);
+  CHECK_IF (maxlen);
+
+  /*
+  EOF has already been reached before or acquisition process hasn't
+  been initiated at all
+  */
+  if (device->bytes_to_read <= 0)
+    {
+      return SANE_STATUS_EOF;
+    }
+
+  if (!ricoh2_buffer_get_bytes_remain (device->buffer))
+    {
+      transfer.send_buffer = read_next_command;
+      transfer.to_send = sizeof (read_next_command);
+      transfer.receive_buffer =
+          ricoh2_buffer_get_internal_buffer (device->buffer);
+      transfer.to_receive = MAX_LINE_SIZE;
+      read_next_command[7] = transfer.to_receive / 256;
+
+      DBG (128, "Receiving data of size %zi\n", transfer.to_receive);
+
+      status = send_receive (device->dn, &transfer);
+      if (status != SANE_STATUS_GOOD)
+        {
+          device->bytes_to_read = 0;
+          return status;
+        }
+    }
+
+  *length = ricoh2_buffer_get_data (device->buffer,
+                                    data,
+                                    min(maxlen, device->bytes_to_read));
+
+  device->bytes_to_read -= *length;
+
+  DBG (128,
+       "Read length %d, left to read %lu\n",
+       *length,
+       device->bytes_to_read);
+
+  DBG (128,
+       "%d bytes remain in the buffer\n",
+       ricoh2_buffer_get_bytes_remain(device->buffer));
+
+  /* we've just reached expected data size */
+  if (device->bytes_to_read <= 0)
+    {
+      ricoh2_buffer_dispose(device->buffer);
+      device->buffer = NULL;
+      return SANE_STATUS_EOF;
+    }
+
+  DBG (16, "<sane_read\n");
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
+{
+  Ricoh2_Device *device;
+  DBG (8, "sane_set_io_mode: handle = %p, non_blocking = %d\n",
+       (void *) handle, non_blocking);
+
+  CHECK_IF (initialized);
+  device = lookup_handle (handle);
+  CHECK_IF (device);
+
+  if (non_blocking)
+    return SANE_STATUS_UNSUPPORTED;
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_get_select_fd (SANE_Handle handle, SANE_Int *fd)
+{
+  Ricoh2_Device *device;
+  DBG (8, "sane_get_select_fd: handle = %p, fd %s 0\n", (void *) handle,
+       fd ? "!=" : "=");
+
+  CHECK_IF (initialized);
+  device = lookup_handle (handle);
+  CHECK_IF (device);
+
+  return SANE_STATUS_UNSUPPORTED;
+}
+
+void
+sane_cancel (SANE_Handle handle)
+{
+  Ricoh2_Device *device;
+
+  DBG (8, ">sane_cancel: handle = %p\n", (void *) handle);
+
+  if (!initialized)
+    return;
+
+  if (!(device = lookup_handle (handle)))
+    return;
+
+  if (device->cancelled)
+	return;
+
+  device->cancelled = SANE_TRUE;
+
+  teardown_scan (device->dn);
+  if (device->buffer)
+    {
+      ricoh2_buffer_dispose (device->buffer);
+      device->buffer = NULL;
+    }
+
+  sanei_usb_close(device->dn);
+
+  DBG (8, "<sane_cancel\n");
+}
+
+void
+sane_close (SANE_Handle handle)
+{
+  Ricoh2_Device *device;
+
+  DBG (8, ">sane_close\n");
+
+  if (!initialized)
+    return;
+
+  device = lookup_handle (handle);
+  if (!device)
+    return;
+
+  /* noop */
+
+  DBG (8, "<sane_close\n");
+}
+
+void
+sane_exit (void)
+{
+  Ricoh2_Device *device, *next;
+
+  DBG (8, ">sane_exit\n");
+
+  if (!initialized)
+    return;
+
+  for (device = ricoh2_devices, next = device; device; device = next)
+    {
+      next = device->next;
+      free (device);
+    }
+
+  if (sane_devices)
+    free (sane_devices);
+
+  sanei_usb_exit ();
+  initialized = SANE_FALSE;
+
+  DBG (8, "<sane_exit\n");
+}