Initial import of sane-backends version 1.0.24-1.2

1 files changed, 3717 insertions, 0 deletions

diff --git a/backend/nec.c b/backend/nec.c
new file mode 100644
index 0000000..c7af955
--- /dev/null
+++ b/backend/nec.c
@@ -0,0 +1,3717 @@
+/* sane - Scanner Access Now Easy.
+
+   Copyright (C) 2000-2001 Kazuya Fukuda, based on sharp.c, which is 
+   based on canon.c.
+
+   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 NEC flatbed scanners.  */
+
+/*
+   Version 0.12
+   - Remove references to sharp backend (grep for "JX").
+   - Check for HAVE_SYS_SHM_H before including sys/shm.h and
+     disable shared memory support if necessary.
+   - free devlist allocated in sane_get_devices() in sane_exit()
+   - resolution setting bug fixed(PC-IN500/4C 10dpi step)
+   - remove resolution list
+   Version 0.11
+   - get_data_buffer_status is not called in sane_get_parameter and 
+     sane_read_direct, sane_read_shuffled.
+   - change some #include <> to ""
+   Version 0.10
+   - First release!
+   - suppoted scanner
+     PC-IN500/4C                    available
+     MultiReder 300U/300S series    not available
+     MultiReder 600U/600S series    not available
+     MultiReader PetiScan series    not available
+*/
+#include "../include/sane/config.h"
+
+#include <limits.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <unistd.h>
+#include <errno.h>
+#include <math.h>
+
+#include "../include/sane/sane.h"
+#include "../include/sane/saneopts.h"
+#include "../include/sane/sanei_scsi.h"
+
+/* QUEUEDEBUG should be undefined unless you want to play
+   with the sanei_scsi.c under Linux and/or with the Linux's SG driver,
+   or your suspect problems with command queueing
+*/
+#define QUEUEDEBUG
+/*#define DEBUG*/
+#ifdef DEBUG
+#include <unistd.h>
+#include <sys/time.h>
+#endif
+
+/* USE_FORK: fork a special reader process
+   disable shared memory support.
+*/
+#if 0
+#ifdef HAVE_SYS_SHM_H
+#define USE_FORK
+#endif
+#endif
+
+#ifdef USE_FORK
+#include <signal.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+
+#include <sys/ipc.h>
+#include <sys/shm.h>
+
+#endif /* USE_FORK */
+
+#ifndef USE_CUSTOM_GAMMA
+#define USE_CUSTOM_GAMMA
+#endif
+#ifndef USE_COLOR_THRESHOLD
+#define USE_COLOR_THRESHOLD
+#endif
+/* enable a short list of some standard resolutions. XSane provides 
+   its own resolution list; therefore its is generally not reasonable
+   to enable this list, if you mainly using XSane. But it might be handy
+   if you are working with xscanimage
+*/
+/* #define USE_RESOLUTION_LIST */ 
+
+#define BACKEND_NAME nec
+#include "../include/sane/sanei_backend.h"
+
+#ifndef PATH_MAX
+#define PATH_MAX	1024
+#endif
+
+#define DEFAULT_MUD_1200 1200
+
+#define PIX_TO_MM(x, mud) ((x) * 25.4 / mud)
+#define MM_TO_PIX(x, mud) ((x) * mud / 25.4)
+
+#include "../include/sane/sanei_config.h"
+#define NEC_CONFIG_FILE "nec.conf"
+
+#include "nec.h"
+
+static int num_devices = 0;
+static NEC_Device *first_dev = NULL;
+static NEC_Scanner *first_handle = NULL;
+static const SANE_Device **devlist = 0;
+
+typedef enum
+  {
+    MODES_LINEART  = 0,
+    MODES_GRAY,
+    MODES_COLOR,
+    MODES_LINEART_COLOR
+  }
+Modes;
+
+#define M_LINEART            SANE_VALUE_SCAN_MODE_LINEART
+#define M_GRAY               SANE_VALUE_SCAN_MODE_GRAY
+#define M_LINEART_COLOR      "Lineart Color"
+#define M_COLOR              SANE_VALUE_SCAN_MODE_COLOR
+static const SANE_String_Const mode_list[] =
+{
+#if 0
+  M_LINEART, M_GRAY, M_LINEART_COLOR, M_COLOR,
+#endif
+  M_LINEART, M_GRAY, M_COLOR,
+  0
+};
+
+#define M_BILEVEL        "none"
+#define M_BAYER          "Dither Bayer"
+#define M_SPIRAL         "Dither Spiral"
+#define M_DISPERSED      "Dither Dispersed"
+#define M_ERRDIFFUSION   "Error Diffusion"
+
+#define M_DITHER1        "Dither 1"
+#define M_DITHER2        "Dither 2"
+#define M_DITHER3        "Dither 3"
+#define M_DITHERUSER     "User defined"
+
+static const SANE_String_Const halftone_list[] =
+{
+  M_BILEVEL, M_DITHER1, M_DITHER2, M_DITHER3,
+  0
+};
+
+#define LIGHT_GREEN "green"
+#define LIGHT_RED   "red"
+#define LIGHT_BLUE  "blue"
+#define LIGHT_NONE  "none"
+#define LIGHT_WHITE "white"
+
+static const SANE_String_Const light_color_list[] =
+{
+  LIGHT_GREEN, LIGHT_RED, LIGHT_BLUE, LIGHT_NONE,
+  0
+};
+
+/* possible values for ADF/FSU selection */
+static SANE_String use_adf = "Automatic Document Feeder";
+static SANE_String use_fsu = "Transparency Adapter";
+static SANE_String use_simple = "Flatbed";
+
+#define HAVE_FSU 1
+#define HAVE_ADF 2
+
+/* The follow #defines are used in NEC_Scanner.adf_fsu_mode 
+   and as indexes for the arrays x_ranges, y_ranges in NEC_Device 
+*/
+#define SCAN_SIMPLE 0
+#define SCAN_WITH_FSU 1
+#define SCAN_WITH_ADF 2
+
+#define LOAD_PAPER 1
+#define UNLOAD_PAPER 0
+
+#define PAPER_MAX  10
+#define W_LETTER "11\"x17\""
+#define INVOICE  "8.5\"x5.5\""
+static const SANE_String_Const paper_list_pcinxxx[] =
+{
+  "A3", "A4", "A5", "A6", "B4", "B5",
+  W_LETTER, "Legal", "Letter", INVOICE,
+  0
+};
+
+static const SANE_String_Const paper_list_pcin500[] =
+{
+  "A4", "A5", "A6", "B5",
+  0
+};
+
+
+#define CRT1    "CRT1"
+#define CRT2    "CRT2"
+#define PRINTER1 "PRINTER1"
+#define PRINTER2 "PRINTER2"
+#define NONE    "NONE"
+/* #define CUSTOM  "CUSTOM" */
+static const SANE_String_Const gamma_list[] =
+{
+  CRT1, CRT2, PRINTER1, PRINTER2, NONE,
+  0
+};
+
+#if 0
+#define SPEED_NORMAL    "Normal"
+#define SPEED_FAST      "Fast"
+static const SANE_String_Const speed_list[] =
+{
+  SPEED_NORMAL, SPEED_FAST,
+  0
+};
+#endif
+
+#ifdef USE_RESOLUTION_LIST
+#define RESOLUTION_MAX_PCINXXX 8
+static const SANE_String_Const resolution_list_pcinxxx[] =
+{
+  "50", "75", "100", "150", "200", "300", "400", "600", "Select",
+  0
+};
+
+#define RESOLUTION_MAX_PCIN500 8
+static const SANE_String_Const resolution_list_pcin500[] =
+{
+  "50", "75", "100", "150", "200", "300", "400", "480", "Select",
+  0
+};
+#endif
+
+#define EDGE_NONE    "None"
+#define EDGE_MIDDLE  "Middle"
+#define EDGE_STRONG  "Strong"
+#define EDGE_BLUR    "Blur"
+static const SANE_String_Const edge_emphasis_list[] =
+{
+  EDGE_NONE, EDGE_MIDDLE, EDGE_STRONG, EDGE_BLUR,
+  0
+};
+
+#ifdef USE_CUSTOM_GAMMA
+static const SANE_Range u8_range =
+  {
+      0,				/* minimum */
+    255,				/* maximum */
+      0				/* quantization */
+  };
+#endif
+
+static SANE_Status
+sense_handler(int fd, u_char *sense_buffer, void *ss)
+{
+  int sense_key;
+  NEC_Sense_Data *sdat = (NEC_Sense_Data *) ss;
+  
+  fd = fd; /* silence compilation warnings */
+
+  #define add_sense_code sense_buffer[12]
+  #define add_sense_qual sense_buffer[13]
+
+  memcpy(sdat->sb, sense_buffer, 16);
+  
+  DBG(10, "sense code: %02x %02x %02x %02x %02x %02x %02x %02x "
+          "%02x %02x %02x %02x %02x %02x %02x %02x\n",
+          sense_buffer[0], sense_buffer[1], sense_buffer[2], sense_buffer[3], 
+          sense_buffer[4], sense_buffer[5], sense_buffer[6], sense_buffer[7], 
+          sense_buffer[8], sense_buffer[9], sense_buffer[10], sense_buffer[11], 
+          sense_buffer[12], sense_buffer[13], sense_buffer[14], sense_buffer[15]);
+
+  sense_key = sense_buffer[1] & 0x0F;
+  /* do we have additional information ? */
+  if (sense_buffer[7] >= 5)
+    {
+      if (sdat->model == PCIN500)
+        {
+          switch (sense_key)
+            {
+              case 0x02: /* not ready */
+                switch (add_sense_code)
+                  {
+                    case 0x80:
+                      switch (add_sense_qual & 0xf0)
+                        {
+                          case 0x10:
+                            DBG(1, "Scanner not ready: memory error\n");
+                            return SANE_STATUS_IO_ERROR;
+                          case 0x20:
+                            DBG(1, "Scanner not ready: hardware error\n");
+                            return SANE_STATUS_IO_ERROR;
+                          case 0x30:
+                            DBG(1, "Scanner not ready: optical error\n");
+                            return SANE_STATUS_IO_ERROR;
+                          case 0x40:
+                            DBG(1, "Scanner not ready: optical error\n");
+                            return SANE_STATUS_IO_ERROR;
+                          case 0x50:
+                            DBG(1, "Scanner not ready: marker error\n");
+                            return SANE_STATUS_IO_ERROR;
+                          case 0x60:
+                            DBG(1, "Scanner not ready: mechanical error\n");
+                            return SANE_STATUS_IO_ERROR;
+                          case 0x70:
+                            DBG(1, "Scanner not ready: hardware error\n");
+                            return SANE_STATUS_IO_ERROR;
+                          case 0x80:
+                            DBG(1, "Scanner not ready: hardware error\n");
+                            return SANE_STATUS_IO_ERROR;
+                          case 0x90:
+                          default:
+                            DBG(5, "Scanner not ready: undocumented reason\n");
+                            return SANE_STATUS_IO_ERROR;
+                        }
+                  }
+              case 0x03: /* medium error */
+		DBG(5, "medium error: undocumented reason\n");
+		return SANE_STATUS_IO_ERROR;
+              case 0x04: /* hardware error */
+		DBG(1, "general hardware error\n");
+		return SANE_STATUS_IO_ERROR;
+              case 0x05: /* illegal request */
+                DBG(10, "error: illegal request\n");
+                return SANE_STATUS_IO_ERROR;
+              case 0x06: /* unit attention */
+		DBG(5, "unit attention: exact reason not documented\n");
+		return SANE_STATUS_IO_ERROR;
+              case 0x0B: /* data remains */
+                DBG(5, "error: aborted command\n");
+                return SANE_STATUS_IO_ERROR;
+              default:
+                DBG(5, "error: sense code not documented\n");
+                return SANE_STATUS_IO_ERROR;
+            }
+        }
+    }
+  return SANE_STATUS_IO_ERROR;
+}
+
+static SANE_Status
+test_unit_ready (int fd)
+{
+  static u_char cmd[] = {TEST_UNIT_READY, 0, 0, 0, 0, 0};
+  SANE_Status status;
+  DBG (11, "<< test_unit_ready ");
+
+  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+  DBG (11, ">>\n");
+  return (status);
+}
+
+#if 0
+static SANE_Status
+request_sense (int fd, void *sense_buf, size_t *sense_size)
+{
+  static u_char cmd[] = {REQUEST_SENSE, 0, 0, 0, SENSE_LEN, 0};
+  SANE_Status status;
+  DBG (11, "<< request_sense ");
+
+  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), sense_buf, sense_size);
+
+  DBG (11, ">>\n");
+  return (status);
+}
+#endif
+
+static SANE_Status
+inquiry (int fd, void *inq_buf, size_t *inq_size)
+{
+  static u_char cmd[] = {INQUIRY, 0, 0, 0, INQUIRY_LEN, 0};
+  SANE_Status status;
+  DBG (11, "<< inquiry ");
+
+  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), inq_buf, inq_size);
+
+  DBG (11, ">>\n");
+  return (status);
+}
+
+static SANE_Status
+mode_select_mud (int fd, int mud)
+{
+  static u_char cmd[6 + MODEPARAM_LEN] = 
+  {MODE_SELECT6, 0x10, 0, 0, MODEPARAM_LEN, 0};
+  mode_select_param *mp;
+  SANE_Status status;
+  DBG (11, "<< mode_select_mud ");
+
+  mp = (mode_select_param *)(cmd + 6);
+  memset (mp, 0, MODEPARAM_LEN);
+  mp->mode_param_header1 = 11;
+  mp->page_code = 3;
+  mp->page_length = 6;
+  mp->mud[0] = mud >> 8;
+  mp->mud[1] = mud & 0xFF;
+
+  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+  DBG (11, ">>\n");
+  return (status);
+}
+
+#if 0
+static SANE_Status
+mode_select_adf_fsu (int fd, int mode)
+{
+  static u_char cmd[6 + MODE_SUBDEV_LEN] = 
+                        {MODE_SELECT6, 0x10, 0, 0, MODE_SUBDEV_LEN, 0};
+  mode_select_subdevice *mp;
+  SANE_Status status;
+  DBG (11, "<< mode_select_adf_fsu ");
+
+  mp = (mode_select_subdevice *)(cmd + 6);
+  memset (mp, 0, MODE_SUBDEV_LEN);
+  mp->page_code = 0x20;
+  mp->page_length = 26;
+  switch (mode)
+    {
+      case SCAN_SIMPLE:
+        mp->a_mode = 0x40;
+        mp->f_mode = 0x40;
+        break;
+      case SCAN_WITH_FSU:
+        mp->a_mode = 0;
+        mp->f_mode = 0x40;
+        break;
+      case SCAN_WITH_ADF:
+        mp->a_mode = 0x40;
+        mp->f_mode = 0;
+        break;
+    }
+
+  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+  DBG (11, ">>\n");
+  return (status);
+}
+#endif
+
+static SANE_Status wait_ready(int fd);
+
+static SANE_Status
+mode_sense (int fd, void *modeparam_buf, size_t * modeparam_size, 
+            int page)
+{
+  static u_char cmd[6] = {MODE_SENSE6, 0, 0, 0, 0, 0};
+  SANE_Status status;
+  DBG (11, "<< mode_sense ");
+  cmd[0] = 0x1a;
+  cmd[2] = page;
+  cmd[4] = *modeparam_size;
+  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), modeparam_buf, 
+			   modeparam_size);
+
+  DBG (11, ">>\n");
+  return (status);
+}
+
+static SANE_Status
+scan (int fd)
+{
+  static u_char cmd[] = {SCAN, 0, 0, 0, 0, 0};
+  SANE_Status status;
+  DBG (11, "<< scan ");
+
+  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+  DBG (11, ">>\n");
+  return (status);
+}
+
+#if 0
+static SANE_Status
+send_diagnostics (int fd)
+{
+  static u_char cmd[] = {SEND_DIAGNOSTIC, 0x04, 0, 0, 0, 0};
+  SANE_Status status;
+  DBG (11, "<< send_diagnostics ");
+
+  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+  DBG (11, ">>\n");
+  return (status);
+}
+#endif
+
+static SANE_Status
+set_window (int fd, window_param *wp, int len)
+{
+  static u_char cmd[10 + WINDOW_LEN] = 
+                        {SET_WINDOW, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  window_param *winp;
+  SANE_Status status;
+  DBG (11, "<< set_window ");
+
+  cmd[8] = len;
+  winp = (window_param *)(cmd + 10);
+  memset (winp, 0, WINDOW_LEN);
+  memcpy (winp, wp, len);
+  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), 0, 0);
+
+  DBG (11, ">>\n");
+  return (status);
+
+}
+
+static SANE_Status
+get_window (int fd, void *buf, size_t * buf_size)
+{
+  static u_char cmd[10] = {GET_WINDOW, 0, 0, 0, 0, 0, 0, 0, WINDOW_LEN, 0};
+  SANE_Status status;
+  DBG (11, "<< get_window ");
+
+  cmd[8] = *buf_size;
+  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), buf, buf_size);
+
+  DBG (11, ">>\n");
+  return (status);
+}
+
+#if 0
+static SANE_Status
+get_data_buffer_status (int fd, void *buf, size_t *buf_size)
+{
+  static u_char cmd[10] = 
+                        {GET_DATA_BUFFER_STATUS, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  SANE_Status status;
+  DBG (11, "<< get_data_buffer_status ");
+
+  cmd[8] = *buf_size;
+  status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), buf, buf_size);
+
+  DBG (11, ">>\n");
+  return (status);
+}
+#endif
+
+#ifdef USE_FORK
+
+/* the following four functions serve simply the purpose
+   to avoid "over-optimised" code when reader_process and 
+   read_data wait for the buffer to become ready. The simple 
+   while-loops in these functions which check the buffer 
+   status may be optimised so that the machine code only 
+   operates with registers instead of using the variable 
+   values stored in memory. (This is only a workaround - 
+   it would be better to set a compiler pragma, which ensures
+   that the program looks into the RAM in these while loops --
+   but unfortunately I could not find appropriate information
+   about this at least for gcc, not to speak about other 
+   compilers... 
+   Abel)
+*/
+
+static int
+cancel_requested(NEC_Scanner *s)
+{
+  return s->rdr_ctl->cancel;
+}
+
+static SANE_Status 
+rdr_status(NEC_Scanner *s)
+{
+  return s->rdr_ctl->status;
+}
+
+static int
+buf_status(NEC_shmem_ctl *s)
+{
+  return s->shm_status;
+}
+
+static int
+reader_running(NEC_Scanner *s)
+{
+  return s->rdr_ctl->running;
+}
+
+static int
+reader_process(NEC_Scanner *s)
+{
+  SANE_Status status;
+  sigset_t sigterm_set;
+  static u_char cmd[] = {READ, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  int full_count = 0, counted;
+  size_t waitindex, cmdindex;
+  size_t bytes_to_queue;
+  size_t nread;
+  size_t max_bytes_per_read;
+  int max_queue;
+  int i;
+  NEC_shmem_ctl *bc;
+
+  s->rdr_ctl->running = 1;
+  DBG(11, "<< reader_process\n");
+
+  sigemptyset (&sigterm_set);
+  
+  bytes_to_queue = s->bytes_to_read;
+  
+  max_bytes_per_read = s->dev->info.bufsize / s->params.bytes_per_line;
+  if (max_bytes_per_read)
+    max_bytes_per_read *= s->params.bytes_per_line;
+  else
+    /* this is a really tiny buffer..*/
+    max_bytes_per_read = s->dev->info.bufsize;
+  
+  /*  wait_ready(s->fd); */
+  
+  if (s->dev->info.queued_reads <= s->dev->info.buffers)
+    max_queue = s->dev->info.queued_reads;
+  else
+    max_queue = s->dev->info.buffers;
+  for (i = 0; i < max_queue; i++)
+    {
+      bc = &s->rdr_ctl->buf_ctl[i];
+      if (bytes_to_queue)
+        {
+          nread = bytes_to_queue;
+          if (nread > max_bytes_per_read)
+            nread = max_bytes_per_read;
+          bc->used = nread;
+          cmd[6] = nread >> 16;
+          cmd[7] = nread >> 8;
+          cmd[8] = nread;
+#ifdef QUEUEDEBUG
+          DBG(2, "reader: req_enter...\n");
+#endif
+          status = sanei_scsi_req_enter (s->fd, cmd, sizeof (cmd), 
+                     bc->buffer, 
+                    &bc->used, 
+                    &bc->qid);
+#ifdef QUEUEDEBUG
+          DBG(2, "reader: req_enter ok\n");
+#endif
+          if (status != SANE_STATUS_GOOD)
+            {
+              DBG(1, "reader_process: read command failed: %s", 
+                  sane_strstatus(status));
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+              sanei_scsi_req_flush_all_extended(s->fd);
+#else
+               sanei_scsi_req_flush_all();
+#endif
+              s->rdr_ctl->status = status;
+              s->rdr_ctl->running = 0;
+              return 2;
+            }
+          bc->shm_status = SHM_BUSY;
+          bc->nreq = bc->used;
+          bytes_to_queue -= bc->nreq;
+        }
+      else
+        {
+          bc->used = 0;
+          bc->shm_status = SHM_EMPTY;
+        }
+    }
+  waitindex = 0;
+  cmdindex = i % s->dev->info.buffers;
+
+  while(s->bytes_to_read > 0) 
+    {
+      if (cancel_requested(s)) 
+        {
+#ifdef QUEUEDEBUG
+          DBG(2, "reader: flushing requests...\n");
+#endif
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+          sanei_scsi_req_flush_all_extended(s->fd);
+#else
+          sanei_scsi_req_flush_all();
+#endif
+#ifdef QUEUEDEBUG
+          DBG(2, "reader: flushing requests ok\n");
+#endif
+          s->rdr_ctl->cancel = 0;
+          s->rdr_ctl->status = SANE_STATUS_CANCELLED;
+          s->rdr_ctl->running = 0;
+          DBG(11, " reader_process (cancelled) >>\n");
+          return 1;
+        }
+
+      bc = &s->rdr_ctl->buf_ctl[waitindex];
+      if (bc->shm_status == SHM_BUSY) 
+        {
+#ifdef DEBUG
+          {
+            struct timeval t;
+            gettimeofday(&t, 0);
+            DBG(2, "rd: waiting for data %li.%06li\n", t.tv_sec, t.tv_usec);
+          }
+#endif
+#ifdef QUEUEDEBUG
+          DBG(2, "reader: req_wait...\n");
+#endif
+          status = sanei_scsi_req_wait(bc->qid);
+#ifdef QUEUEDEBUG
+          DBG(2, "reader: req_wait ok\n");
+#endif
+#ifdef DEBUG
+          {
+            struct timeval t;
+            gettimeofday(&t, 0);
+            DBG(2, "rd: data received    %li.%06li\n", t.tv_sec, t.tv_usec);
+          }
+#endif
+          if (status != SANE_STATUS_GOOD)
+            {
+              DBG(1, "reader_process: read command failed: %s", 
+                  sane_strstatus(status));
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+              sanei_scsi_req_flush_all_extended(s->fd);
+#else
+              sanei_scsi_req_flush_all();
+#endif
+              s->rdr_ctl->status = status;
+              s->rdr_ctl->running = 0;
+              return 2;
+            }
+          s->bytes_to_read -= bc->used;
+          bytes_to_queue += bc->nreq - bc->used;
+          bc->start = 0;
+          bc->shm_status = SHM_FULL;
+
+          waitindex++;
+          if (waitindex == s->dev->info.buffers)
+            waitindex = 0;
+
+        }
+      
+      if (bytes_to_queue)
+        {
+          /* wait until the next buffer is completely read via read_data */
+          bc = &s->rdr_ctl->buf_ctl[cmdindex];
+          counted = 0;
+          while (buf_status(bc) != SHM_EMPTY)
+            {
+              if (!counted)
+                {
+                  counted = 1;
+                  full_count++;
+                }
+              if (cancel_requested(s))
+                {
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+                  sanei_scsi_req_flush_all_extended(s->fd);
+#else
+                  sanei_scsi_req_flush_all();
+#endif
+                  s->rdr_ctl->cancel = 0;
+                  s->rdr_ctl->status = SANE_STATUS_CANCELLED;
+                  s->rdr_ctl->running = 0;
+                  DBG(11, " reader_process (cancelled) >>\n");
+                  return 1;
+                }
+            }
+
+          nread = bytes_to_queue;
+          if (nread > max_bytes_per_read)
+            nread = max_bytes_per_read;
+          bc->used = nread;
+          cmd[6] = nread >> 16;
+          cmd[7] = nread >> 8;
+          cmd[8] = nread;
+          status = sanei_scsi_req_enter (s->fd, cmd, sizeof (cmd), 
+                    bc->buffer, &bc->used, &bc->qid);
+          if (status != SANE_STATUS_GOOD)
+            {
+              DBG(1, "reader_process: read command failed: %s", 
+                  sane_strstatus(status));
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+              sanei_scsi_req_flush_all_extended(s->fd);
+#else
+              sanei_scsi_req_flush_all();
+#endif
+              s->rdr_ctl->status = status;
+              s->rdr_ctl->running = 0;
+              return 2;
+            }
+          bc->shm_status = SHM_BUSY;
+          bc->nreq = nread;
+          bytes_to_queue -= nread;
+          
+          cmdindex++;
+          if (cmdindex == s->dev->info.buffers)
+            cmdindex = 0;
+        }
+      
+      if (cancel_requested(s)) 
+        {
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+          sanei_scsi_req_flush_all_extended(s->fd);
+#else
+          sanei_scsi_req_flush_all();
+#endif
+          s->rdr_ctl->cancel = 0;
+          s->rdr_ctl->status = SANE_STATUS_CANCELLED;
+          s->rdr_ctl->running = 0;
+          DBG(11, " reader_process (cancelled) >>\n");
+          return 1;
+        }
+    }
+      
+  DBG(1, "buffer full conditions: %i\n", full_count);
+  DBG(11, " reader_process>>\n");
+
+  s->rdr_ctl->running = 0;
+  return 0;
+}
+
+static SANE_Status
+read_data (NEC_Scanner *s, SANE_Byte *buf, size_t * buf_size)
+{
+  size_t copysize, copied = 0;
+  NEC_shmem_ctl *bc;
+  
+  DBG(11, "<< read_data ");
+
+  bc = &s->rdr_ctl->buf_ctl[s->read_buff];
+
+  while (copied < *buf_size)
+    {
+      /* wait until the reader process delivers data or a scanner error occurs: */
+      while (   buf_status(bc) != SHM_FULL
+             && rdr_status(s) == SANE_STATUS_GOOD) 
+        {
+          usleep(10); /* could perhaps be longer. make this user configurable?? */
+        }
+
+      if (rdr_status(s) != SANE_STATUS_GOOD)
+        {
+          return rdr_status(s);
+          DBG(11, ">>\n");
+        }
+
+      copysize = bc->used - bc->start;
+      
+      if (copysize > *buf_size - copied )
+        copysize = *buf_size - copied;
+        
+      memcpy(buf, &(bc->buffer[bc->start]), copysize);
+
+      copied += copysize;
+      buf = &buf[copysize];
+
+      bc->start += copysize;
+      if (bc->start >= bc->used)
+        {
+          bc->start = 0;
+          bc->shm_status = SHM_EMPTY;
+          s->read_buff++;
+          if (s->read_buff == s->dev->info.buffers)
+            s->read_buff = 0;
+          bc = &s->rdr_ctl->buf_ctl[s->read_buff];
+        }
+    }
+
+  DBG(11, ">>\n");
+  return SANE_STATUS_GOOD;
+}
+
+#else /* don't USE_FORK: */
+
+static SANE_Status
+read_data (NEC_Scanner *s, SANE_Byte *buf, size_t * buf_size)
+{
+  static u_char cmd[] = {READ, 0, 0, 0, 0, 0, 0, 0, 0, 0};
+  SANE_Status status = SANE_STATUS_GOOD;
+  size_t remain = *buf_size;
+  size_t nread;
+  DBG (11, "<< read_data ");
+
+  /* sane_read_shuffled requires that read_data returns
+     exactly *buf_size bytes, so it must be guaranteed here.
+     Further make sure that not more bytes are read in than 
+     sanei_scsi_max_request_size allows, to avoid a failure 
+     of the read command
+  */
+  while (remain > 0)
+    {
+      nread = remain;
+      if (nread > s->dev->info.bufsize)
+        nread = s->dev->info.bufsize;
+      cmd[6] = nread >> 16;
+      cmd[7] = nread >> 8;
+      cmd[8] = nread;
+      status = sanei_scsi_cmd (s->fd, cmd, sizeof (cmd), 
+                 &buf[*buf_size - remain], &nread);
+      if (status != SANE_STATUS_GOOD)
+        {
+          DBG(11, ">>\n");
+          return(status);
+        }
+      remain -= nread;
+    }
+  DBG (11, ">>\n");
+  return (status);
+}
+#endif
+
+static size_t
+max_string_size (const SANE_String_Const strings[])
+{
+  size_t size, max_size = 0;
+  int i;
+  DBG (10, "<< max_string_size ");
+
+  for (i = 0; strings[i]; ++i)
+    {
+      size = strlen (strings[i]) + 1;
+      if (size > max_size)
+	max_size = size;
+    }
+
+  DBG (10, ">>\n");
+  return max_size;
+}
+
+static SANE_Status
+wait_ready(int fd)
+{
+  SANE_Status status;
+  int retry = 0;
+
+  while ((status = test_unit_ready (fd)) != SANE_STATUS_GOOD)
+  {
+    DBG (5, "wait_ready failed (%d)\n", retry);
+    DBG (5, "wait_ready status = (%d)\n", status);
+    if (retry++ > 15){
+	return SANE_STATUS_IO_ERROR;
+    }
+    sleep(3);
+  }
+  return (status);
+    
+}
+
+static SANE_Status
+attach (const char *devnam, NEC_Device ** devp)
+{
+  SANE_Status status;
+  NEC_Device *dev;
+  NEC_Sense_Data sensedat;
+
+  int fd;
+  unsigned char inquiry_data[INQUIRY_LEN];
+  const unsigned char *model_name;
+  mode_sense_param msp;
+  size_t buf_size;
+  DBG (10, "<< attach ");
+
+  for (dev = first_dev; dev; dev = dev->next)
+    {
+      if (strcmp (dev->sane.name, devnam) == 0)
+	{
+	  if (devp)
+	    *devp = dev;
+	  return (SANE_STATUS_GOOD);
+	}
+    }
+
+  sensedat.model = unknown;
+  sensedat.complain_on_adf_error = 0;
+  DBG (3, "attach: opening %s\n", devnam);
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+  {
+    int bufsize = 4096;
+    status = sanei_scsi_open_extended (devnam, &fd, &sense_handler, &sensedat, &bufsize);
+    if (status != SANE_STATUS_GOOD)
+      {
+        DBG (1, "attach: open failed: %s\n", sane_strstatus (status));
+        return (status);
+      }
+    if (bufsize < 4096)
+      {
+        DBG(1, "attach: open failed. no memory\n");
+        sanei_scsi_close(fd);
+        return SANE_STATUS_NO_MEM;
+      }
+  }
+#else
+  status = sanei_scsi_open (devnam, &fd, &sense_handler, &sensedat);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: open failed: %s\n", sane_strstatus (status));
+      return (status);
+    }
+#endif
+
+  DBG (3, "attach: sending INQUIRY\n");
+  memset (inquiry_data, 0, sizeof (inquiry_data));
+  buf_size = sizeof (inquiry_data);
+  status = inquiry (fd, inquiry_data, &buf_size);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: inquiry failed: %s\n", sane_strstatus (status));
+      sanei_scsi_close (fd);
+      return (status);
+    }
+
+  if (inquiry_data[0] == 6 && strncmp ((char *)inquiry_data + 8, "NEC", 3) == 0)
+    {
+      if (strncmp ((char *)inquiry_data + 16, "PC-IN500/4C", 11) == 0)
+        sensedat.model = PCIN500;
+      else
+        sensedat.model = unknown;
+    }
+
+  if (sensedat.model == unknown)
+    {
+      DBG (1, "attach: device doesn't look like a NEC scanner\n");
+      DBG (1, "      : Only PC-IN500/4C is supported.\n");
+      sanei_scsi_close (fd);
+      return (SANE_STATUS_INVAL);
+    }
+
+  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 MODE SELECT\n");
+
+  if (sensedat.model == PCIN500)
+    status = mode_select_mud (fd, DEFAULT_MUD_1200);
+
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: MODE_SELECT_MUD failed\n");
+      sanei_scsi_close (fd);
+      return (SANE_STATUS_INVAL);
+    }
+
+  DBG (3, "attach: sending MODE SENSE/MUP page\n");
+  memset (&msp, 0, sizeof (msp));
+  buf_size = sizeof (msp);
+  status = mode_sense (fd, &msp, &buf_size, 3);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "attach: MODE_SENSE/MUP page failed\n");
+      sanei_scsi_close (fd);
+      return (SANE_STATUS_INVAL);
+    }
+#ifdef DEBUG_NEC
+  DBG (3,"attach: MODE SENSE parameter\n");
+      DBG(11, "%02x %02x %02x %02x "
+              "%02x %02x %02x %02x %02x %02x %02x %02x\n",
+              msp.mode_data_length,
+	      msp.mode_param_header2,
+	      msp.mode_param_header3,
+	      msp.mode_desciptor_length,
+	      msp.page_code,
+	      msp.page_length,
+	      msp.bmu,
+	      msp.res2,
+	      msp.mud[0],
+	      msp.mud[1],
+	      msp.res3,
+	      msp.res4);
+#endif
+  dev = malloc (sizeof (*dev));
+  if (!dev)
+    return (SANE_STATUS_NO_MEM);
+  memset (dev, 0, sizeof (*dev));
+
+  dev->sane.name = (SANE_String) strdup (devnam);
+  dev->sane.vendor = "NEC";
+  model_name = inquiry_data + 16;
+  dev->sane.model  = strndup ((const char *)model_name, 10);
+  dev->sane.type = "flatbed scanner";
+  
+  dev->sensedat.model = sensedat.model;
+
+  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);
+
+  if (sensedat.model == PCIN500)
+    dev->info.res_range.quant = 10;
+  else
+    dev->info.res_range.quant = 0;
+
+  dev->info.tl_x_ranges[SCAN_SIMPLE].min = SANE_FIX(0);
+  dev->info.br_x_ranges[SCAN_SIMPLE].min = SANE_FIX(1);
+  dev->info.tl_y_ranges[SCAN_SIMPLE].min = SANE_FIX(0);
+  dev->info.br_y_ranges[SCAN_SIMPLE].min = SANE_FIX(1);
+  dev->info.tl_x_ranges[SCAN_SIMPLE].quant = SANE_FIX(0);
+  dev->info.br_x_ranges[SCAN_SIMPLE].quant = SANE_FIX(0);
+  dev->info.tl_y_ranges[SCAN_SIMPLE].quant = SANE_FIX(0);
+  dev->info.br_y_ranges[SCAN_SIMPLE].quant = SANE_FIX(0);
+
+  if (sensedat.model == PCIN500)
+    dev->info.res_default = 15;
+  else
+    dev->info.res_default = 150;
+  dev->info.tl_x_ranges[SCAN_SIMPLE].max = SANE_FIX(209);
+  dev->info.br_x_ranges[SCAN_SIMPLE].max = SANE_FIX(210);
+  dev->info.tl_y_ranges[SCAN_SIMPLE].max = SANE_FIX(296);
+  dev->info.br_y_ranges[SCAN_SIMPLE].max = SANE_FIX(297);
+
+  dev->info.bmu = msp.bmu;
+  dev->info.mud = (msp.mud[0] << 8) + msp.mud[1];
+  
+  dev->info.adf_fsu_installed = 0;
+  if (dev->sensedat.model == PCIN500)
+    {
+      dev->info.res_range.max = 48;
+      dev->info.res_range.min = 5;
+
+      dev->info.x_default = SANE_FIX(210);
+      dev->info.tl_x_ranges[SCAN_SIMPLE].max = SANE_FIX(210); /* 304.8mm is the real max */
+      dev->info.br_x_ranges[SCAN_SIMPLE].max = SANE_FIX(210); /* 304.8mm is the real max */
+
+      dev->info.y_default = SANE_FIX(297);
+      dev->info.tl_y_ranges[SCAN_SIMPLE].max = SANE_FIX(297); /* 431.8 is the real max */
+      dev->info.br_y_ranges[SCAN_SIMPLE].max = SANE_FIX(297); /* 431.8 is the real max */
+    }
+  else
+    {
+      dev->info.res_range.max = 400;
+      dev->info.res_range.min = 50;
+
+      dev->info.x_default = SANE_FIX(210);
+      dev->info.tl_x_ranges[SCAN_SIMPLE].max = SANE_FIX(210); /* 304.8mm is the real max */
+      dev->info.br_x_ranges[SCAN_SIMPLE].max = SANE_FIX(210); /* 304.8mm is the real max */
+
+      dev->info.y_default = SANE_FIX(297);
+      dev->info.tl_y_ranges[SCAN_SIMPLE].max = SANE_FIX(297); /* 431.8 is the real max */
+      dev->info.br_y_ranges[SCAN_SIMPLE].max = SANE_FIX(297); /* 431.8 is the real max */
+    }
+  sanei_scsi_close (fd);
+  
+  dev->info.threshold_range.min = 1;
+  dev->info.threshold_range.max = 255;
+  dev->info.threshold_range.quant = 0;
+
+  dev->info.tint_range.min = 1;
+  dev->info.tint_range.max = 255;
+  dev->info.tint_range.quant = 0;
+
+  dev->info.color_range.min = 1;
+  dev->info.color_range.max = 255;
+  dev->info.color_range.quant = 0;
+
+  DBG (5, "res_default=%d\n", dev->info.res_default);
+  DBG (5, "res_range.max=%d\n", dev->info.res_range.max);
+  DBG (5, "res_range.min=%d\n", dev->info.res_range.min);
+  DBG (5, "res_range.quant=%d\n", dev->info.res_range.quant);
+
+  DBG (5, "x_default=%f\n", SANE_UNFIX(dev->info.x_default));
+  DBG (5, "tl_x_range[0].max=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_SIMPLE].max));
+  DBG (5, "tl_x_range[0].min=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_SIMPLE].min));
+  DBG (5, "tl_x_range[0].quant=%d\n", dev->info.tl_x_ranges[SCAN_SIMPLE].quant);
+  DBG (5, "br_x_range[0].max=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_SIMPLE].max));
+  DBG (5, "br_x_range[0].min=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_SIMPLE].min));
+  DBG (5, "br_x_range[0].quant=%d\n", dev->info.br_x_ranges[SCAN_SIMPLE].quant);
+  DBG (5, "y_default=%f\n", SANE_UNFIX(dev->info.y_default));
+  DBG (5, "tl_y_range[0].max=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_SIMPLE].max));
+  DBG (5, "tl_y_range[0].min=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_SIMPLE].min));
+  DBG (5, "tl_y_range[0].quant=%d\n", dev->info.tl_y_ranges[SCAN_SIMPLE].quant);
+  DBG (5, "br_y_range[0].max=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_SIMPLE].max));
+  DBG (5, "br_y_range[0].min=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_SIMPLE].min));
+  DBG (5, "br_y_range[0].quant=%d\n", dev->info.br_y_ranges[SCAN_SIMPLE].quant);
+
+  if (dev->info.adf_fsu_installed & HAVE_FSU)
+    {
+      DBG (5, "tl_x_range[1].max=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_WITH_FSU].max));
+      DBG (5, "tl_x_range[1].min=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_WITH_FSU].min));
+      DBG (5, "tl_x_range[1].quant=%d\n", dev->info.tl_x_ranges[SCAN_WITH_FSU].quant);
+      DBG (5, "br_x_range[1].max=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_WITH_FSU].max));
+      DBG (5, "br_x_range[1].min=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_WITH_FSU].min));
+      DBG (5, "br_x_range[1].quant=%d\n", dev->info.br_x_ranges[SCAN_WITH_FSU].quant);
+      DBG (5, "tl_y_range[1].max=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_WITH_FSU].max));
+      DBG (5, "tl_y_range[1].min=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_WITH_FSU].min));
+      DBG (5, "tl_y_range[1].quant=%d\n", dev->info.tl_y_ranges[SCAN_WITH_FSU].quant);
+      DBG (5, "br_y_range[1].max=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_WITH_FSU].max));
+      DBG (5, "br_y_range[1].min=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_WITH_FSU].min));
+      DBG (5, "br_y_range[1].quant=%d\n", dev->info.br_y_ranges[SCAN_WITH_FSU].quant);
+    }
+
+  if (dev->info.adf_fsu_installed & HAVE_ADF)
+    {
+      DBG (5, "tl_x_range[2].max=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_WITH_ADF].max));
+      DBG (5, "tl_x_range[2].min=%f\n", SANE_UNFIX(dev->info.tl_x_ranges[SCAN_WITH_ADF].min));
+      DBG (5, "tl_x_range[2].quant=%d\n", dev->info.tl_x_ranges[SCAN_WITH_ADF].quant);
+      DBG (5, "br_x_range[2].max=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_WITH_ADF].max));
+      DBG (5, "br_x_range[2].min=%f\n", SANE_UNFIX(dev->info.br_x_ranges[SCAN_WITH_ADF].min));
+      DBG (5, "br_x_range[2].quant=%d\n", dev->info.br_x_ranges[SCAN_WITH_ADF].quant);
+      DBG (5, "tl_y_range[2].max=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_WITH_ADF].max));
+      DBG (5, "tl_y_range[2].min=%f\n", SANE_UNFIX(dev->info.tl_y_ranges[SCAN_WITH_ADF].min));
+      DBG (5, "tl_y_range[2].quant=%d\n", dev->info.tl_y_ranges[SCAN_WITH_ADF].quant);
+      DBG (5, "br_y_range[2].max=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_WITH_ADF].max));
+      DBG (5, "br_y_range[2].min=%f\n", SANE_UNFIX(dev->info.br_y_ranges[SCAN_WITH_ADF].min));
+      DBG (5, "br_y_range[2].quant=%d\n", dev->info.br_y_ranges[SCAN_WITH_ADF].quant);
+    }
+
+  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 (10, ">>\n");
+  return (SANE_STATUS_GOOD);
+}
+
+/* Enabling / disabling of gamma options.
+   Depends on many user settable options, so lets put it into 
+   one function to be called by init_options and by sane_control_option
+
+*/
+#ifdef USE_CUSTOM_GAMMA
+static void 
+set_gamma_caps(NEC_Scanner *s)
+{
+  /* neither fixed nor custom gamma for line art modes */
+  if (   strcmp(s->val[OPT_MODE].s, M_LINEART) == 0
+      || strcmp(s->val[OPT_MODE].s, M_LINEART_COLOR) == 0)
+    {
+      s->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE;
+      s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
+      s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
+      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;
+    }
+  else if (strcmp(s->val[OPT_MODE].s, M_GRAY) == 0)
+    {
+      s->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
+      if (s->val[OPT_CUSTOM_GAMMA].w == SANE_FALSE)
+        {
+          s->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE;
+          s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
+        }
+      else
+        {
+          s->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE;
+          s->opt[OPT_GAMMA_VECTOR].cap &= ~SANE_CAP_INACTIVE;
+        }
+      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;
+    }
+  else
+    {
+      /* color mode */
+      s->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
+      if (s->val[OPT_CUSTOM_GAMMA].w == SANE_FALSE)
+        {
+          s->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE;
+          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;
+        }
+      else
+        {
+          s->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE;
+          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_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
+    }
+}
+#endif /* USE_CUSTOM_GAMMA */
+
+/* The next function is a slightly modified version of sanei_constrain_value
+   Instead of returning status information like STATUS_INVAL, it adjusts
+   an invaild value to the nearest allowed one.
+*/
+static void
+clip_value (const SANE_Option_Descriptor * opt, void * value)
+{
+  const SANE_String_Const * string_list;
+  const SANE_Word * word_list;
+  int i, num_matches, match;
+  const SANE_Range * range;
+  SANE_Word w, v;
+  size_t len;
+
+  switch (opt->constraint_type)
+    {
+    case SANE_CONSTRAINT_RANGE:
+      w = *(SANE_Word *) value;
+      range = opt->constraint.range;
+
+      if (w < range->min)
+        w = range->min;
+      else if (w > range->max)
+	w = range->max;
+
+      if (range->quant)
+	{
+	  v = (w - range->min + range->quant/2) / range->quant;
+	  w = v * range->quant + range->min;
+	  *(SANE_Word*) value = w;
+	}
+      break;
+
+    case SANE_CONSTRAINT_WORD_LIST:
+      w = *(SANE_Word *) value;
+      word_list = opt->constraint.word_list;
+      for (i = 1; w != word_list[i]; ++i)
+	if (i >= word_list[0])
+	  /* somewhat arbitrary... Would be better to have a default value
+	     explicitly defined.
+	  */
+	  *(SANE_Word*) value = word_list[1];
+      break;
+
+    case SANE_CONSTRAINT_STRING_LIST:
+      /* Matching algorithm: take the longest unique match ignoring
+	 case.  If there is an exact match, it is admissible even if
+	 the same string is a prefix of a longer option name. */
+      string_list = opt->constraint.string_list;
+      len = strlen (value);
+
+      /* count how many matches of length LEN characters we have: */
+      num_matches = 0;
+      match = -1;
+      for (i = 0; string_list[i]; ++i)
+	if (strncasecmp (value, string_list[i], len) == 0
+	    && len <= strlen (string_list[i]))
+	  {
+	    match = i;
+	    if (len == strlen (string_list[i]))
+	      {
+		/* exact match... */
+		if (strcmp (value, string_list[i]) != 0)
+		  /* ...but case differs */
+		  strcpy (value, string_list[match]);
+	      }
+	    ++num_matches;
+	  }
+
+      if (num_matches > 1)
+        /* xxx quite arbitrary... We could also choose the first match
+        */
+        strcpy(value, string_list[match]);
+      else if (num_matches == 1)
+        strcpy (value, string_list[match]);
+      else
+        strcpy (value, string_list[0]);
+
+    default:
+      break;
+    }
+}
+
+/* make sure that enough memory is allocated for each string,
+   so that the strcpy in sane_control_option / set value cannot
+   write behind the end of the allocated memory. 
+*/
+static SANE_Status
+init_string_option(NEC_Scanner *s, SANE_String_Const name, 
+   SANE_String_Const title, SANE_String_Const desc, 
+   const SANE_String_Const *string_list, int option, int default_index)
+{
+  int i;
+
+  s->opt[option].name = name;
+  s->opt[option].title = title;
+  s->opt[option].desc = desc;
+  s->opt[option].type = SANE_TYPE_STRING;
+  s->opt[option].size = max_string_size (string_list);
+  s->opt[option].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+  s->opt[option].constraint.string_list = string_list;
+  s->val[option].s = malloc(s->opt[option].size);
+  if (s->val[option].s == 0)
+    {
+      for (i = 1; i < NUM_OPTIONS; i++)
+        {
+          if (s->val[i].s && s->opt[i].type == SANE_TYPE_STRING)
+            free(s->val[i].s);
+        }
+      return SANE_STATUS_NO_MEM;
+    }
+  strcpy(s->val[option].s, string_list[default_index]);
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+init_options (NEC_Scanner * s)
+{
+  int i, default_source;
+  SANE_Word scalar;
+  DBG (10, "<< init_options ");
+
+  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->val[i].s = 0;
+    }
+
+  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 */
+  init_string_option(s, SANE_NAME_SCAN_MODE, SANE_TITLE_SCAN_MODE,
+    SANE_DESC_SCAN_MODE, mode_list, OPT_MODE, MODES_COLOR);
+
+  /* half tone */
+  init_string_option(s, SANE_NAME_HALFTONE_PATTERN, SANE_TITLE_HALFTONE_PATTERN,
+    SANE_DESC_HALFTONE " (not support)", halftone_list, OPT_HALFTONE, 0);
+
+  if (s->dev->sensedat.model == PCIN500)
+    s->opt[OPT_HALFTONE].cap |= SANE_CAP_INACTIVE;
+
+  i = 0;
+  default_source = -1;
+
+  if (s->dev->info.adf_fsu_installed & HAVE_ADF)
+    {
+      s->dev->info.scansources[i++] = use_adf;
+      default_source = SCAN_WITH_ADF;
+    }
+  if (s->dev->info.adf_fsu_installed & HAVE_FSU)
+    {
+      s->dev->info.scansources[i++] = use_fsu;
+      if (default_source < 0)
+        default_source = SCAN_WITH_FSU;
+    }
+  s->dev->info.scansources[i++] = use_simple;
+    if (default_source < 0)
+      default_source = SCAN_SIMPLE;
+  s->dev->info.scansources[i] = 0;
+  
+  init_string_option(s, SANE_NAME_SCAN_SOURCE, SANE_TITLE_SCAN_SOURCE,
+    SANE_DESC_SCAN_SOURCE, (SANE_String_Const*)s->dev->info.scansources,
+    OPT_SCANSOURCE, 0);
+
+  if (i < 2)
+    s->opt[OPT_SCANSOURCE].cap |= SANE_CAP_INACTIVE;
+
+  if (s->dev->sensedat.model == PCIN500)
+    init_string_option(s, "Paper size", "Paper size",
+      "Paper size", paper_list_pcin500, OPT_PAPER, 0);
+  else
+    init_string_option(s, "Paper size", "Paper size",
+      "Paper size", paper_list_pcinxxx, OPT_PAPER, 1);
+
+  /* gamma */
+  init_string_option(s, "Gamma", "Gamma", "Gamma", gamma_list, OPT_GAMMA, 0);
+
+  /* Resolution Group */
+  s->opt[OPT_RESOLUTION_GROUP].title = "Resolution";
+  s->opt[OPT_RESOLUTION_GROUP].desc = "";
+  s->opt[OPT_RESOLUTION_GROUP].type = SANE_TYPE_GROUP;
+  s->opt[OPT_RESOLUTION_GROUP].cap = 0;
+  s->opt[OPT_RESOLUTION_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+#ifdef USE_RESOLUTION_LIST
+  /* select resolution */
+  if (s->dev->sensedat.model == PCIN500)
+    init_string_option(s, "Resolution", "Resolution", "Resolution", 
+      resolution_list_pcin500, OPT_RESOLUTION_LIST, RESOLUTION_MAX_PCIN500);
+  else
+    init_string_option(s, "Resolution", "Resolution", "Resolution", 
+      resolution_list_pcinxxx, OPT_RESOLUTION_LIST, RESOLUTION_MAX_PCINXXX);
+#endif
+  
+  /* x & y resolution */
+  s->opt[OPT_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
+  if (s->dev->sensedat.model == PCIN500)
+      s->opt[OPT_RESOLUTION].title = SANE_TITLE_SCAN_RESOLUTION"(x 10)";
+  else
+      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_RANGE;
+  s->opt[OPT_RESOLUTION].constraint.range = &s->dev->info.res_range;
+  s->val[OPT_RESOLUTION].w = s->dev->info.res_default;
+
+  /* "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_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->dev->info.tl_x_ranges[default_source];
+  s->val[OPT_TL_X].w = s->dev->info.tl_x_ranges[default_source].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->dev->info.tl_y_ranges[default_source];
+  s->val[OPT_TL_Y].w = s->dev->info.tl_y_ranges[default_source].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->dev->info.br_x_ranges[default_source];
+  scalar = s->dev->info.x_default;
+  clip_value (&s->opt[OPT_BR_X], &scalar);
+  s->val[OPT_BR_X].w = scalar;
+
+  /* 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->dev->info.br_y_ranges[default_source];
+  scalar = s->dev->info.y_default;
+  clip_value (&s->opt[OPT_BR_X], &scalar);
+  s->val[OPT_BR_Y].w = scalar;
+
+  /* "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;
+
+  /* edge emphasis */
+  init_string_option(s, "Edge emphasis", "Edge emphasis",
+    "Edge emphasis", edge_emphasis_list,
+    OPT_EDGE_EMPHASIS, 0);
+
+  if (s->dev->sensedat.model == PCIN500)
+    s->opt[OPT_EDGE_EMPHASIS].cap |= SANE_CAP_INACTIVE;
+
+  /* OR */
+  s->opt[OPT_OR].name = "OR";
+  s->opt[OPT_OR].title = "OR";
+  s->opt[OPT_OR].desc = "Select OR emphancement";
+  s->opt[OPT_OR].type = SANE_TYPE_BOOL;
+  s->val[OPT_OR].w = SANE_FALSE;
+
+  /* EDGE */
+  s->opt[OPT_EDGE].name = "edge";
+  s->opt[OPT_EDGE].title = "Edge";
+  s->opt[OPT_EDGE].desc = "Select Edge emphancement";
+  s->opt[OPT_EDGE].type = SANE_TYPE_BOOL;
+  s->val[OPT_EDGE].w = SANE_FALSE;
+
+  /* NR */
+  s->opt[OPT_NR].name = "NR";
+  s->opt[OPT_NR].title = "NR";
+  s->opt[OPT_NR].desc = "Select noise reduction";
+  s->opt[OPT_NR].type = SANE_TYPE_BOOL;
+  s->val[OPT_NR].w = SANE_FALSE;
+
+  if (s->dev->sensedat.model != PCIN500)
+    {
+      s->opt[OPT_EDGE].cap |= SANE_CAP_INACTIVE;
+      s->opt[OPT_NR].cap |= SANE_CAP_INACTIVE;
+      s->opt[OPT_OR].cap |= SANE_CAP_INACTIVE;
+    }
+  /* tint */
+  s->opt[OPT_TINT].name = "tint";
+  s->opt[OPT_TINT].title = "Tint";
+  s->opt[OPT_TINT].desc = "Select tint";
+  s->opt[OPT_TINT].type = SANE_TYPE_INT;
+  s->opt[OPT_TINT].unit = SANE_UNIT_NONE;
+  s->opt[OPT_TINT].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_TINT].constraint.range = &s->dev->info.tint_range;
+  s->val[OPT_TINT].w = 128;
+  if (s->dev->sensedat.model != PCIN500)
+    s->opt[OPT_TINT].cap |= SANE_CAP_INACTIVE;
+
+  /* color */
+  s->opt[OPT_COLOR].name = "color";
+  s->opt[OPT_COLOR].title = "Color";
+  s->opt[OPT_COLOR].desc = "Select color";
+  s->opt[OPT_COLOR].type = SANE_TYPE_INT;
+  s->opt[OPT_COLOR].unit = SANE_UNIT_NONE;
+  s->opt[OPT_COLOR].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_COLOR].constraint.range = &s->dev->info.color_range;
+  s->val[OPT_COLOR].w = 128;
+  if (s->dev->sensedat.model != PCIN500)
+    s->opt[OPT_COLOR].cap |= SANE_CAP_INACTIVE;
+
+  /* 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 = &s->dev->info.threshold_range;
+  s->val[OPT_THRESHOLD].w = 128;
+  s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
+
+#ifdef USE_COLOR_THRESHOLD
+  s->opt[OPT_THRESHOLD_R].name = SANE_NAME_THRESHOLD "-red";
+  /* xxx the titles and decriptions are confusing:
+     "set white point (red)" 
+     Any idea? maybe "threshold to get the red component on"
+  */
+  s->opt[OPT_THRESHOLD_R].title = SANE_TITLE_THRESHOLD " (red)";
+  s->opt[OPT_THRESHOLD_R].desc = SANE_DESC_THRESHOLD " (red)";
+  s->opt[OPT_THRESHOLD_R].type = SANE_TYPE_INT;
+  s->opt[OPT_THRESHOLD_R].unit = SANE_UNIT_NONE;
+  s->opt[OPT_THRESHOLD_R].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_THRESHOLD_R].constraint.range = &s->dev->info.threshold_range;
+  s->val[OPT_THRESHOLD_R].w = 128;
+  s->opt[OPT_THRESHOLD_R].cap |= SANE_CAP_INACTIVE;
+
+  s->opt[OPT_THRESHOLD_G].name = SANE_NAME_THRESHOLD "-green";
+  s->opt[OPT_THRESHOLD_G].title = SANE_TITLE_THRESHOLD " (green)";
+  s->opt[OPT_THRESHOLD_G].desc = SANE_DESC_THRESHOLD " (green)";
+  s->opt[OPT_THRESHOLD_G].type = SANE_TYPE_INT;
+  s->opt[OPT_THRESHOLD_G].unit = SANE_UNIT_NONE;
+  s->opt[OPT_THRESHOLD_G].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_THRESHOLD_G].constraint.range = &s->dev->info.threshold_range;
+  s->val[OPT_THRESHOLD_G].w = 128;
+  s->opt[OPT_THRESHOLD_G].cap |= SANE_CAP_INACTIVE;
+
+  s->opt[OPT_THRESHOLD_B].name = SANE_NAME_THRESHOLD "-blue";
+  s->opt[OPT_THRESHOLD_B].title = SANE_TITLE_THRESHOLD " (blue)";
+  s->opt[OPT_THRESHOLD_B].desc = SANE_DESC_THRESHOLD " (blue)";
+  s->opt[OPT_THRESHOLD_B].type = SANE_TYPE_INT;
+  s->opt[OPT_THRESHOLD_B].unit = SANE_UNIT_NONE;
+  s->opt[OPT_THRESHOLD_B].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_THRESHOLD_B].constraint.range = &s->dev->info.threshold_range;
+  s->val[OPT_THRESHOLD_B].w = 128;
+  s->opt[OPT_THRESHOLD_B].cap |= SANE_CAP_INACTIVE;
+
+#endif
+
+  /* light color (for gray scale and line art scans) */
+  init_string_option(s, "LightColor", "LightColor", "LightColor",
+    light_color_list, OPT_LIGHTCOLOR, 3);
+  s->opt[OPT_LIGHTCOLOR].cap |= SANE_CAP_INACTIVE;
+
+  s->opt[OPT_PREVIEW].name  = SANE_NAME_PREVIEW;
+  s->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
+  s->opt[OPT_PREVIEW].desc  = SANE_DESC_PREVIEW;
+  s->opt[OPT_PREVIEW].type  = SANE_TYPE_BOOL;
+  s->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
+  s->val[OPT_PREVIEW].w     = SANE_FALSE;
+          
+
+#ifdef USE_CUSTOM_GAMMA
+  /* 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;
+
+  /* grayscale gamma vector */
+  s->opt[OPT_GAMMA_VECTOR].name = SANE_NAME_GAMMA_VECTOR;
+  s->opt[OPT_GAMMA_VECTOR].title = SANE_TITLE_GAMMA_VECTOR;
+  s->opt[OPT_GAMMA_VECTOR].desc = SANE_DESC_GAMMA_VECTOR;
+  s->opt[OPT_GAMMA_VECTOR].type = SANE_TYPE_INT;
+#if 0
+  s->opt[OPT_GAMMA_VECTOR].cap |= SANE_CAP_INACTIVE;
+#endif
+  s->opt[OPT_GAMMA_VECTOR].unit = SANE_UNIT_NONE;
+  s->opt[OPT_GAMMA_VECTOR].size = 256 * sizeof (SANE_Word);
+  s->opt[OPT_GAMMA_VECTOR].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_GAMMA_VECTOR].constraint.range = &u8_range;
+  s->val[OPT_GAMMA_VECTOR].wa = &s->gamma_table[0][0];
+
+  /* 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;
+#if 0
+  s->opt[OPT_GAMMA_VECTOR_R].cap |= SANE_CAP_INACTIVE;
+#endif
+  s->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
+  s->opt[OPT_GAMMA_VECTOR_R].size = 256 * sizeof (SANE_Word);
+  s->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_GAMMA_VECTOR_R].constraint.range = &u8_range;
+  s->val[OPT_GAMMA_VECTOR_R].wa = &s->gamma_table[1][0];
+
+  /* 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;
+#if 0
+  s->opt[OPT_GAMMA_VECTOR_G].cap |= SANE_CAP_INACTIVE;
+#endif
+  s->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
+  s->opt[OPT_GAMMA_VECTOR_G].size = 256 * sizeof (SANE_Word);
+  s->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_GAMMA_VECTOR_G].constraint.range = &u8_range;
+  s->val[OPT_GAMMA_VECTOR_G].wa = &s->gamma_table[2][0];
+
+  /* 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;
+#if 0
+  s->opt[OPT_GAMMA_VECTOR_B].cap |= SANE_CAP_INACTIVE;
+#endif
+  s->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
+  s->opt[OPT_GAMMA_VECTOR_B].size = 256 * sizeof (SANE_Word);
+  s->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_GAMMA_VECTOR_B].constraint.range = &u8_range;
+  s->val[OPT_GAMMA_VECTOR_B].wa = &s->gamma_table[3][0];
+  set_gamma_caps(s);
+#endif
+
+  DBG (10, ">>\n");
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+do_cancel (NEC_Scanner * s)
+{
+  DBG (10, "<< do_cancel ");
+
+#ifdef USE_FORK
+  if (s->reader_pid > 0)
+    {
+      int exit_status;
+      int count = 0;
+      /* ensure child knows it's time to stop: */
+
+      DBG(11, "stopping reader process\n");
+      s->rdr_ctl->cancel = 1;
+      while(reader_running(s) && count < 100) 
+        {
+          usleep(100000);
+          count++;
+        };
+      if (reader_running(s))
+        {
+          kill(s->reader_pid, SIGKILL);
+        }
+      wait(&exit_status);
+      DBG(11, "reader process stopped\n");
+
+      s->reader_pid = 0;
+    }
+
+#endif
+  s->scanning = SANE_FALSE;
+
+  if (s->fd >= 0)
+    {
+      sanei_scsi_close (s->fd);
+      s->fd = -1;
+    }
+#ifdef USE_FORK
+  {
+    struct shmid_ds ds;
+    if (s->shmid != -1)
+      shmctl(s->shmid, IPC_RMID, &ds);
+    s->shmid = -1;
+  }
+#endif
+  if (s->buffer)
+    free(s->buffer);
+  s->buffer = 0;
+
+  DBG (10, ">>\n");
+  return (SANE_STATUS_CANCELLED);
+}
+
+static NEC_New_Device *new_devs = 0;
+static NEC_New_Device *new_dev_pool = 0;
+
+static SANE_Status 
+attach_and_list(const char *devnam)
+{
+  SANE_Status res;
+  NEC_Device *devp;
+  NEC_New_Device *np;
+  
+  res = attach(devnam, &devp);
+  if (res == SANE_STATUS_GOOD)
+    {
+      if (new_dev_pool)
+        {
+          np = new_dev_pool;
+          new_dev_pool = np->next;
+        }
+      else
+        {
+          np = malloc(sizeof(NEC_New_Device));
+          if (np == 0)
+            return SANE_STATUS_NO_MEM;
+        }
+      np->next =new_devs;
+      np->dev = devp;
+      new_devs = np;
+    }
+  return res;
+}
+
+SANE_Status
+sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
+{
+  char devnam[PATH_MAX] = "/dev/scanner";
+  char line[PATH_MAX];
+  const char *lp;
+  char *word;
+  char *end;
+  FILE *fp;
+  int opt_index = 0;
+  int buffers[2] = {DEFAULT_BUFFERS, DEFAULT_BUFFERS};
+  int bufsize[2] = {DEFAULT_BUFSIZE, DEFAULT_BUFSIZE};
+  int queued_reads[2] = {DEFAULT_QUEUED_READS, DEFAULT_QUEUED_READS};
+  int linecount = 0;
+#if 1
+  NEC_Device nd;
+  NEC_Device *dp = &nd;
+#else
+  NEC_Device *dp;
+#endif
+  NEC_New_Device *np;
+  int i;
+
+  authorize = authorize; /* silence compilation warnings */
+
+  DBG_INIT ();
+  DBG (10, "<< sane_init ");
+
+  DBG (1, "sane_init: NEC (Ver %d.%d)\n", NEC_MAJOR, NEC_MINOR);
+
+  if (version_code)
+    *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0);
+
+  fp = sanei_config_open (NEC_CONFIG_FILE);
+  if (!fp)
+    {
+      /* use "/dev/scanner" as the default device name if no
+         config file is available
+      */
+      attach (devnam, &dp);
+      /* make sure that there are at least two buffers */
+      if (DEFAULT_BUFFERS < 2)
+        dp->info.buffers = DEFAULT_BUFFERS;
+      else
+        dp->info.buffers = 2;
+      dp->info.wanted_bufsize = DEFAULT_BUFSIZE;
+      dp->info.queued_reads = DEFAULT_QUEUED_READS;
+      return SANE_STATUS_GOOD;
+    }
+
+  while (fgets(line, PATH_MAX, fp))
+    {
+      linecount++;
+      word = 0;
+      lp = sanei_config_get_string(line, &word);
+      if (word)
+        {
+          if (word[0] != '#')
+            {
+              if (strcmp(word, "option") == 0)
+                {
+                  free(word);
+                  word = 0;
+                  lp = sanei_config_get_string(lp, &word);
+                  if (strcmp(word, "buffers") == 0)
+                    {
+                      free(word);
+                      word = 0;
+                      sanei_config_get_string(lp, &word);
+                      i = strtol(word, &end, 0);
+                      if (end == word)
+                        {
+                          DBG(1, "error in config file, line %i: number expected:\n",
+                              linecount);
+                          DBG(1, "%s\n", line);
+                        }
+                      else
+                        if (i > 2)
+                          buffers[opt_index] = i;
+                        else
+                          buffers[opt_index] = 2;
+                    }
+                  else if (strcmp(word, "buffersize") == 0)
+                    {
+                      free(word);
+                      word = 0;
+                      sanei_config_get_string(lp, &word);
+                      i = strtol(word, &end, 0);
+                      if (word == end)
+                        {
+                          DBG(1, "error in config file, line %i: number expected:\n",
+                              linecount);
+                          DBG(1, "%s\n", line);
+                        }
+                      else
+                        bufsize[opt_index] = i;
+                    }
+                  else if (strcmp(word, "readqueue") == 0)
+                    {
+                      free(word);
+                      word = 0;
+                      sanei_config_get_string(lp, &word);
+                      i = strtol(word, &end, 0);
+                      if (word == end)
+                        {
+                          DBG(1, "error in config file, line %i: number expected:\n",
+                              linecount);
+                          DBG(1, "%s\n", line);
+                        }
+                      else 
+                        queued_reads[opt_index] = i;
+                    }
+                  else
+                    {
+                      DBG(1, "error in config file, line %i: unknown option\n",
+                          linecount);
+                      DBG(1, "%s\n", line);
+                    }
+                }
+              else
+                {
+                  while (new_devs)
+                    {
+                      if (buffers[1] >= 2) 
+                        new_devs->dev->info.buffers = buffers[1];
+                      else
+                        new_devs->dev->info.buffers = 2;
+                      if (bufsize[1] > 0)
+                        new_devs->dev->info.wanted_bufsize = bufsize[1];
+                      else
+                        new_devs->dev->info.wanted_bufsize = DEFAULT_BUFSIZE;
+                      if (queued_reads[1] >= 0)
+                        new_devs->dev->info.queued_reads = queued_reads[1];
+                      else
+                        new_devs->dev->info.queued_reads = 0;
+                      np = new_devs->next;
+                      new_devs->next = new_dev_pool;
+                      new_dev_pool = new_devs;
+                      new_devs = np;
+                    }
+                  if (line[strlen(line)-1] == '\n')
+                    line[strlen(line)-1] = 0;
+                  sanei_config_attach_matching_devices(line, &attach_and_list);
+                  buffers[1] = buffers[0];
+                  bufsize[1] = bufsize[0];
+                  queued_reads[1] = queued_reads[0];
+                  opt_index = 1;
+                }
+            }
+          if (word) free(word);
+        }
+    }
+
+  while (new_devs)
+    {
+      if (buffers[1] >= 2) 
+        new_devs->dev->info.buffers = buffers[1];
+      else
+        new_devs->dev->info.buffers = 2;
+      if (bufsize[1] > 0)
+        new_devs->dev->info.wanted_bufsize = bufsize[1];
+      else
+        new_devs->dev->info.wanted_bufsize = DEFAULT_BUFSIZE;
+      if (queued_reads[1] >= 0)
+        new_devs->dev->info.queued_reads = queued_reads[1];
+      else
+        new_devs->dev->info.queued_reads = 0;
+      if (line[strlen(line)-1] == '\n')
+        line[strlen(line)-1] = 0;
+      np = new_devs->next;
+      free(new_devs);
+      new_devs = np;
+    }
+  while (new_dev_pool)
+    {
+      np = new_dev_pool->next;
+      free(new_dev_pool);
+      new_dev_pool = np;
+    }
+  fclose(fp);
+  DBG (10, ">>\n");
+  return (SANE_STATUS_GOOD);
+}
+
+void
+sane_exit (void)
+{
+  NEC_Device *dev, *next;
+  DBG (10, "<< sane_exit ");
+
+  for (dev = first_dev; dev; dev = next)
+    {
+      next = dev->next;
+      free ((void *) dev->sane.name);
+      free ((void *) dev->sane.model);
+      free (dev);
+    }
+  first_dev = 0;
+
+  if (devlist)
+    free(devlist);
+
+  DBG (10, ">>\n");
+}
+
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
+{
+  NEC_Device *dev;
+  int i;
+  DBG (10, "<< sane_get_devices ");
+
+  local_only = local_only; /* silence compilation warnings */
+
+  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 (10, ">>\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_open (SANE_String_Const devnam, SANE_Handle * handle)
+{
+  SANE_Status status;
+  NEC_Device *dev;
+  NEC_Scanner *s;
+#ifdef USE_CUSTOM_GAMMA
+  int i, j;
+#endif
+
+  DBG (10, "<< sane_open ");
+
+  if (devnam[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->dev = dev;
+  
+  s->buffer = 0;  
+#ifdef USE_CUSTOM_GAMMA
+  for (i = 0; i < 4; ++i)
+    for (j = 0; j < 256; ++j)
+      s->gamma_table[i][j] = j;
+#endif
+  status = init_options (s);
+  if (status != SANE_STATUS_GOOD)
+    {
+      /* xxx clean up mallocs */
+      return status;
+    }
+
+  s->next = first_handle;
+  first_handle = s;
+
+  *handle = s;
+
+  DBG (10, ">>\n");
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_close (SANE_Handle handle)
+{
+  NEC_Scanner *s = (NEC_Scanner *) handle;
+  DBG (10, "<< sane_close ");
+
+  if (s->fd != -1)
+    sanei_scsi_close (s->fd);
+#ifdef USE_FORK
+  {
+    struct shmid_ds ds;
+    if (s->shmid != -1)
+      shmctl(s->shmid, IPC_RMID, &ds);
+  }
+#endif
+  if (s->buffer)
+    free(s->buffer);
+  free (s);
+
+  DBG (10, ">>\n");
+}
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+  NEC_Scanner *s = handle;
+  DBG (10, "<< sane_get_option_descriptor ");
+
+  if ((unsigned) option >= NUM_OPTIONS)
+    return (0);
+
+  DBG (10, ">>\n");
+  return (s->opt + option);
+}
+
+SANE_Status
+sane_control_option (SANE_Handle handle, SANE_Int option,
+		     SANE_Action action, void *val, SANE_Int * info)
+{
+  NEC_Scanner *s = handle;
+  SANE_Status status;
+#ifdef USE_CUSTOM_GAMMA
+  SANE_Word w, cap;
+#else
+  SANE_Word cap;
+#endif
+  int range_index;
+  DBG (10, "<< sane_control_option %i", option);
+
+  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_RESOLUTION:
+	case OPT_TL_X:
+	case OPT_TL_Y:
+	case OPT_BR_X:
+	case OPT_BR_Y:
+	case OPT_NUM_OPTS:
+	case OPT_THRESHOLD:
+	case OPT_TINT:
+	case OPT_COLOR:
+#ifdef USE_COLOR_THRESHOLD
+	case OPT_THRESHOLD_R:
+	case OPT_THRESHOLD_G:
+	case OPT_THRESHOLD_B:
+#endif
+	case OPT_OR:
+	case OPT_NR:
+	case OPT_EDGE:
+	case OPT_PREVIEW:
+#ifdef USE_CUSTOM_GAMMA
+	case OPT_CUSTOM_GAMMA:
+#endif
+	  *(SANE_Word *) val = s->val[option].w;
+#if 0 /* here, values are read; reload should not be necessary */
+	  if (info)
+	    *info |= SANE_INFO_RELOAD_PARAMS;
+#endif
+	  return (SANE_STATUS_GOOD);
+
+#ifdef USE_CUSTOM_GAMMA
+	  /* word-array options: */
+	case OPT_GAMMA_VECTOR:
+	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;
+#endif
+
+	  /* string options: */
+	case OPT_MODE:
+	case OPT_HALFTONE:
+	case OPT_PAPER:
+	case OPT_GAMMA:
+#ifdef USE_RESOLUTION_LIST
+	case OPT_RESOLUTION_LIST:
+#endif
+	case OPT_EDGE_EMPHASIS:
+	case OPT_LIGHTCOLOR:
+	case OPT_SCANSOURCE:
+	  strcpy (val, s->val[option].s);
+#if 0
+	  if (info)
+	    *info |= SANE_INFO_RELOAD_PARAMS;
+#endif
+
+	  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_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;
+	case OPT_NUM_OPTS:
+	case OPT_THRESHOLD:
+	  /* xxx theoretically, we could use OPT_THRESHOLD in 
+	     bi-level color mode to adjust all three other
+	     threshold together. But this would require to set
+	     the bit SANE_INFO_RELOAD_OPTIONS in *info, and that
+	     would unfortunately cause a crash in both xscanimage
+	     and xsane... Therefore, OPT_THRESHOLD is disabled
+	     for bi-level color scan right now.
+	  */
+	case OPT_TINT:
+	case OPT_COLOR:
+#ifdef USE_COLOR_THRESHOLD
+	case OPT_THRESHOLD_R:
+	case OPT_THRESHOLD_G:
+	case OPT_THRESHOLD_B:
+#endif
+	case OPT_OR:
+	case OPT_NR:
+	case OPT_EDGE:
+	case OPT_PREVIEW:
+	  s->val[option].w = *(SANE_Word *) val;
+	  return (SANE_STATUS_GOOD);
+
+	case OPT_MODE:
+	  if (strcmp (val, M_LINEART) == 0)
+	    {
+	      s->opt[OPT_LIGHTCOLOR].cap &= ~SANE_CAP_INACTIVE;
+	      s->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE;
+	      s->opt[OPT_TINT].cap |= SANE_CAP_INACTIVE;
+	      s->opt[OPT_COLOR].cap |= SANE_CAP_INACTIVE;
+#ifdef USE_COLOR_THRESHOLD
+	      s->opt[OPT_THRESHOLD_R].cap |= SANE_CAP_INACTIVE;
+	      s->opt[OPT_THRESHOLD_G].cap |= SANE_CAP_INACTIVE;
+	      s->opt[OPT_THRESHOLD_B].cap |= SANE_CAP_INACTIVE;
+#endif
+	      if (s->dev->sensedat.model == PCIN500)
+                s->opt[OPT_HALFTONE].cap &= ~SANE_CAP_INACTIVE;
+	    }
+	  else if (strcmp (val, M_LINEART_COLOR) == 0)
+	    {
+	      s->opt[OPT_LIGHTCOLOR].cap |= SANE_CAP_INACTIVE;
+	      s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
+	      s->opt[OPT_TINT].cap |= SANE_CAP_INACTIVE;
+	      s->opt[OPT_COLOR].cap |= SANE_CAP_INACTIVE;
+#ifdef USE_COLOR_THRESHOLD
+	      s->opt[OPT_THRESHOLD_R].cap &= ~SANE_CAP_INACTIVE;
+	      s->opt[OPT_THRESHOLD_G].cap &= ~SANE_CAP_INACTIVE;
+	      s->opt[OPT_THRESHOLD_B].cap &= ~SANE_CAP_INACTIVE;
+#endif
+	      if (s->dev->sensedat.model == PCIN500)
+                s->opt[OPT_HALFTONE].cap &= ~SANE_CAP_INACTIVE;
+	    }
+	  else if (strcmp (val, M_GRAY) == 0)
+	    {
+	      s->opt[OPT_LIGHTCOLOR].cap &= ~SANE_CAP_INACTIVE;
+	      s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
+	      s->opt[OPT_TINT].cap |= SANE_CAP_INACTIVE;
+	      s->opt[OPT_COLOR].cap |= SANE_CAP_INACTIVE;
+#ifdef USE_COLOR_THRESHOLD
+	      s->opt[OPT_THRESHOLD_R].cap |= SANE_CAP_INACTIVE;
+	      s->opt[OPT_THRESHOLD_G].cap |= SANE_CAP_INACTIVE;
+	      s->opt[OPT_THRESHOLD_B].cap |= SANE_CAP_INACTIVE;
+#endif
+              s->opt[OPT_HALFTONE].cap |= SANE_CAP_INACTIVE;
+	    }
+	  else
+	    {
+	      s->opt[OPT_LIGHTCOLOR].cap |= SANE_CAP_INACTIVE;
+	      s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE;
+	      s->opt[OPT_TINT].cap &= ~SANE_CAP_INACTIVE;
+	      s->opt[OPT_COLOR].cap &= ~SANE_CAP_INACTIVE;
+#ifdef USE_COLOR_THRESHOLD
+	      s->opt[OPT_THRESHOLD_R].cap |= SANE_CAP_INACTIVE;
+	      s->opt[OPT_THRESHOLD_G].cap |= SANE_CAP_INACTIVE;
+	      s->opt[OPT_THRESHOLD_B].cap |= SANE_CAP_INACTIVE;
+#endif
+              s->opt[OPT_HALFTONE].cap |= SANE_CAP_INACTIVE;
+            }
+#if 0          
+	  if (   strcmp (val, M_LINEART) == 0 
+	      || strcmp (val, M_GRAY) == 0)
+            {
+	      s->opt[OPT_LIGHTCOLOR].cap &= ~SANE_CAP_INACTIVE;
+            }
+          else
+            {
+	      s->opt[OPT_LIGHTCOLOR].cap |= SANE_CAP_INACTIVE;
+            }
+#endif            
+          strcpy(s->val[option].s, val);
+#ifdef USE_CUSTOM_GAMMA
+          set_gamma_caps(s);
+#endif
+          if (info)
+	    *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
+	  return (SANE_STATUS_GOOD);
+
+	case OPT_GAMMA:
+	case OPT_HALFTONE:
+	case OPT_EDGE_EMPHASIS:
+	case OPT_LIGHTCOLOR:
+#if 0
+	  if (s->val[option].s)
+	    free (s->val[option].s);
+	  s->val[option].s = strdup (val);
+#endif
+          strcpy(s->val[option].s, val);
+	  return (SANE_STATUS_GOOD);
+
+	case OPT_SCANSOURCE:
+	  if (info && strcmp (s->val[option].s, (SANE_String) val))
+	    *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
+#if 0
+	  if (s->val[option].s)
+	    free (s->val[option].s);
+	  s->val[option].s = strdup (val);
+#endif
+          strcpy(s->val[option].s, val);
+	  if (strcmp(val, use_fsu) == 0)
+	    range_index = SCAN_WITH_FSU;
+	  else if (strcmp(val, use_adf) == 0)
+	    range_index = SCAN_WITH_ADF;
+	  else
+	    range_index = SCAN_SIMPLE;
+
+          s->opt[OPT_TL_X].constraint.range 
+            = &s->dev->info.tl_x_ranges[range_index];
+          clip_value (&s->opt[OPT_TL_X], &s->val[OPT_TL_X].w);
+
+          s->opt[OPT_TL_Y].constraint.range 
+            = &s->dev->info.tl_y_ranges[range_index];
+          clip_value (&s->opt[OPT_TL_Y], &s->val[OPT_TL_Y].w);
+
+          s->opt[OPT_BR_X].constraint.range 
+            = &s->dev->info.br_x_ranges[range_index];
+          clip_value (&s->opt[OPT_BR_X], &s->val[OPT_BR_X].w);
+
+          s->opt[OPT_BR_Y].constraint.range 
+            = &s->dev->info.br_y_ranges[range_index];
+          clip_value (&s->opt[OPT_BR_Y], &s->val[OPT_BR_Y].w);
+
+	  return (SANE_STATUS_GOOD);
+
+	case OPT_PAPER:
+          if (info)
+	    *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
+#if 0
+	  if (s->val[option].s)
+	    free (s->val[option].s);
+	  s->val[option].s = strdup (val);
+#endif
+          strcpy(s->val[option].s, val);
+	  s->val[OPT_TL_X].w = SANE_FIX(0);
+	  s->val[OPT_TL_Y].w = SANE_FIX(0);
+	  if (strcmp (s->val[option].s, "A3") == 0){
+	      s->val[OPT_BR_X].w = SANE_FIX(297);
+	      s->val[OPT_BR_Y].w = SANE_FIX(420);
+	  }else if (strcmp (s->val[option].s, "A4") == 0){
+	      s->val[OPT_BR_X].w = SANE_FIX(210);
+	      s->val[OPT_BR_Y].w = SANE_FIX(297);
+	  }else if (strcmp (s->val[option].s, "A5") == 0){
+	      s->val[OPT_BR_X].w = SANE_FIX(148.5);
+	      s->val[OPT_BR_Y].w = SANE_FIX(210);
+	  }else if (strcmp (s->val[option].s, "A6") == 0){
+	      s->val[OPT_BR_X].w = SANE_FIX(105);
+	      s->val[OPT_BR_Y].w = SANE_FIX(148.5);
+	  }else if (strcmp (s->val[option].s, "B4") == 0){
+	      s->val[OPT_BR_X].w = SANE_FIX(250);
+	      s->val[OPT_BR_Y].w = SANE_FIX(353);
+	  }else if (strcmp (s->val[option].s, "B5") == 0){
+	      s->val[OPT_BR_X].w = SANE_FIX(182);
+	      s->val[OPT_BR_Y].w = SANE_FIX(257);
+	  }else if (strcmp (s->val[option].s, W_LETTER) == 0){
+	      s->val[OPT_BR_X].w = SANE_FIX(279.4);
+	      s->val[OPT_BR_Y].w = SANE_FIX(431.8);
+	  }else if (strcmp (s->val[option].s, "Legal") == 0){
+	      s->val[OPT_BR_X].w = SANE_FIX(215.9);
+	      s->val[OPT_BR_Y].w = SANE_FIX(355.6);
+	  }else if (strcmp (s->val[option].s, "Letter") == 0){
+	      s->val[OPT_BR_X].w = SANE_FIX(215.9);
+	      s->val[OPT_BR_Y].w = SANE_FIX(279.4);
+	  }else if (strcmp (s->val[option].s, INVOICE) == 0){
+	      s->val[OPT_BR_X].w = SANE_FIX(215.9);
+	      s->val[OPT_BR_Y].w = SANE_FIX(139.7);
+	  }else{
+	  }
+	  return (SANE_STATUS_GOOD);
+
+#ifdef USE_RESOLUTION_LIST
+	case OPT_RESOLUTION_LIST:
+	  if (info)
+	    *info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
+#if 0
+	  if (s->val[option].s)
+	    free (s->val[option].s);
+	  s->val[option].s = strdup (val);
+#endif
+	  for (i = 0; s->opt[OPT_RESOLUTION_LIST].constraint.string_list[i]; i++) {
+	    if (strcmp (val, 
+	          s->opt[OPT_RESOLUTION_LIST].constraint.string_list[i]) == 0){
+	      s->val[OPT_RESOLUTION].w 
+	        = atoi(s->opt[OPT_RESOLUTION_LIST].constraint.string_list[i]);
+	      if (info)
+	        *info |= SANE_INFO_RELOAD_PARAMS;
+	      break;
+	    }
+	  }
+	  return (SANE_STATUS_GOOD);
+#endif
+
+#ifdef USE_CUSTOM_GAMMA
+	  /* side-effect-free word-array options: */
+	case OPT_GAMMA_VECTOR:
+	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_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;
+          set_gamma_caps(s);
+	  return SANE_STATUS_GOOD;
+#endif
+	}
+    }
+
+  DBG (10, ">>\n");
+  return (SANE_STATUS_INVAL);
+}
+
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
+{
+  int width, length, res;
+  const char *mode;
+  NEC_Scanner *s = handle;
+  DBG (10, "<< sane_get_parameters ");
+
+  res = s->val[OPT_RESOLUTION].w * s->dev->info.res_range.quant;
+  if (!s->scanning)
+    {
+      /* make best-effort guess at what parameters will look like once
+         scanning starts.  */
+      memset (&s->params, 0, sizeof (s->params));
+
+      width = MM_TO_PIX(  SANE_UNFIX(s->val[OPT_BR_X].w) 
+                        - SANE_UNFIX(s->val[OPT_TL_X].w),
+			s->dev->info.mud);
+      length = MM_TO_PIX(  SANE_UNFIX(s->val[OPT_BR_Y].w)
+                          - SANE_UNFIX(s->val[OPT_TL_Y].w),
+			 s->dev->info.mud);
+
+      s->width = width;
+      s->length = length;
+      s->params.pixels_per_line = width * res / s->dev->info.mud;
+      s->params.lines = length * res / s->dev->info.mud;
+
+      if (s->dev->sensedat.model == PCIN500)
+	{
+	  s->params.pixels_per_line += 1;
+	  s->params.lines += 1;
+	}
+      s->unscanned_lines = s->params.lines;
+    }
+#if 0
+  else
+    {
+      buffer_status bs;
+      SANE_Status status;
+      size_t len = sizeof (buffer_status);
+      status = get_data_buffer_status (s->fd, &bs, &len);
+      DBG (11, "<< get_data_buffer_status ");
+
+      if (status != SANE_STATUS_GOOD)
+	{
+	  do_cancel(s);
+	  return (status);
+	}
+      DBG (11, ">>\n ");
+      {
+#ifdef DEBUG_NEC
+	int i;
+	u_char *buf = &bs;
+	DBG(11, "get data buffer status(debug):\n");
+	for (i = 0; i < len; i += 16)
+	  {
+	    DBG(1, "%2x %2x %2x %2x %2x %2x %2x %2x - %2x %2x %2x %2x \n",
+		buf[i], buf[i+1], buf[i+2], buf[i+3], buf[i+4], buf[i+5], buf[i+6], buf[i+7], buf[i+8],
+		buf[i+9], buf[i+10], buf[i+11]);
+	  }
+#endif
+      }
+    }
+#endif
+  res = s->val[OPT_RESOLUTION].w * s->dev->info.res_range.quant;
+
+  mode = s->val[OPT_MODE].s;
+
+  if (strcmp (mode, M_LINEART) == 0)
+     {
+       s->params.format = SANE_FRAME_GRAY;
+       s->params.bytes_per_line = (s->params.pixels_per_line + 7) / 8;
+       s->params.depth = 1;
+       s->modes = MODES_LINEART;
+     }
+  else if (strcmp (mode, M_GRAY) == 0)
+     {
+       s->params.format = SANE_FRAME_GRAY;
+       s->params.bytes_per_line = s->params.pixels_per_line;
+       s->params.depth = 8;
+       s->modes = MODES_GRAY;
+     }
+  else if (strcmp (mode, M_LINEART_COLOR) == 0)
+    {
+       s->params.format = SANE_FRAME_RGB;
+       s->params.bytes_per_line = 3 * (s->params.pixels_per_line + 7) / 8;
+       s->params.depth = 8;
+       s->modes = MODES_LINEART_COLOR;
+    }
+  else
+     {
+       s->params.format = SANE_FRAME_RGB;
+       s->params.bytes_per_line = 3 * s->params.pixels_per_line;
+       s->params.depth = 8;
+       s->modes = MODES_COLOR;
+     }
+  s->params.last_frame = SANE_TRUE;
+
+  if (params)
+    *params = s->params;
+
+  DBG (10, ">>\n");
+  return (SANE_STATUS_GOOD);
+}
+
+#ifdef USE_CUSTOM_GAMMA
+
+static int
+sprint_gamma(Option_Value val, SANE_Byte *dst)
+{
+  int i;
+  SANE_Byte *p = dst;
+  
+  p += sprintf((char *) p, "%i", val.wa[0]);
+  for (i = 1; i < 256; i++)
+    p += sprintf((char *) p, ",%i", val.wa[i] > 255 ? 255 : val.wa[i]);
+  return p - dst;
+}
+
+static SANE_Status
+send_ascii_gamma_tables (NEC_Scanner *s)
+{
+  SANE_Status status;
+  int i;
+  
+  DBG(11, "<< send_ascii_gamma_tables ");
+    
+  /* we need: 4 bytes for each gamma value (3 digits + delimiter)
+             + 10 bytes for the command header
+     i.e. 4 * 4 * 256 + 10 = 4106 bytes
+  */
+  
+  if (s->dev->info.bufsize < 4106)
+    return SANE_STATUS_NO_MEM;
+  
+  memset(s->buffer, 0, 4106);
+
+  i = sprint_gamma(s->val[OPT_GAMMA_VECTOR_R], &s->buffer[10]);
+  s->buffer[10+i++] = '/';
+  i += sprint_gamma(s->val[OPT_GAMMA_VECTOR_G], &s->buffer[10+i]);
+  s->buffer[10+i++] = '/';
+  i += sprint_gamma(s->val[OPT_GAMMA_VECTOR_B], &s->buffer[10+i]);
+  s->buffer[10+i++] = '/';
+  i += sprint_gamma(s->val[OPT_GAMMA_VECTOR], &s->buffer[10+i]);
+  
+  DBG(12, "%s\n", &s->buffer[10]);
+
+  s->buffer[0] = SEND;
+  s->buffer[2] = 0x03;
+  s->buffer[7] = i >> 8;
+  s->buffer[8] = i & 0xff;
+  
+  wait_ready(s->fd);
+  status = sanei_scsi_cmd (s->fd, s->buffer, i+10, 0, 0);
+
+  DBG(11, ">>\n");
+  
+  return status;
+}
+#endif
+
+static SANE_Status
+send_binary_g_table(NEC_Scanner *s, SANE_Word *a, int dtq)
+{
+  SANE_Status status;
+  unsigned int i, j;
+  
+  dtq = dtq; /* silence compilation warnings */
+  
+  DBG(11, "<< send_binary_g_table\n");
+
+  i = 256;
+  if (s->dev->info.bufsize < i)
+    return SANE_STATUS_NO_MEM;
+  memset(s->buffer, 0, i+10);
+
+  s->buffer[0] = SEND;
+  s->buffer[2] = 0x03;
+  s->buffer[7] = i >> 8;
+  s->buffer[8] = i & 0xff;
+  
+  for (i = 0; i < 256; i++)
+    {
+      s->buffer[i+11] = a[i&0xff] & 0xff;
+    }
+  
+  for (j = 0; j < 256; j += 16)
+    {
+      DBG(11, "%02x %02x %02x %02x %02x %02x %02x %02x "
+              "%02x %02x %02x %02x %02x %02x %02x %02x\n",
+              a[j  ], a[j+1], a[j+2], a[j+3], 
+              a[j+4], a[j+5], a[j+6], a[j+7],
+              a[j+8], a[j+9], a[j+10], a[j+11], 
+              a[j+12], a[j+13], a[j+14], a[j+15]);
+    }
+  DBG(12, "transfer length = %d\n", i);
+  DBG(12, "buffer[7] = %d\n", s->buffer[7]);
+  DBG(12, "buffer[8] = %d\n", s->buffer[8]);
+
+  /*  wait_ready(s->fd); */
+  status = sanei_scsi_cmd (s->fd, s->buffer, i+10, 0, 0);
+
+  DBG(11, ">>\n");
+
+  return status;
+}
+
+#ifdef USE_CUSTOM_GAMMA
+static SANE_Status
+send_binary_gamma_tables (NEC_Scanner *s)
+{
+  SANE_Status status;
+  
+  status = send_binary_g_table(s, s->val[OPT_GAMMA_VECTOR].wa, 0x10);
+  if (status != SANE_STATUS_GOOD)
+    return status;
+  DBG(11, "send_binary_gamma_tables\n");
+#if 0  
+  status = send_binary_g_table(s, s->val[OPT_GAMMA_VECTOR_R].wa, 0x11);
+  if (status != SANE_STATUS_GOOD)
+    return status;
+  
+  status = send_binary_g_table(s, s->val[OPT_GAMMA_VECTOR_G].wa, 0x12);
+  if (status != SANE_STATUS_GOOD)
+    return status;
+  
+  status = send_binary_g_table(s, s->val[OPT_GAMMA_VECTOR_B].wa, 0x13);
+#endif
+  return status;
+}
+
+static SANE_Status
+send_gamma_tables (NEC_Scanner *s)
+{
+  if (s->dev->sensedat.model == PCIN500)
+    {
+      return send_binary_gamma_tables(s);
+    }
+  else
+    {
+      return send_ascii_gamma_tables(s);
+    }
+  
+}
+#endif
+
+#ifdef USE_COLOR_THRESHOLD
+/* not used? */
+#if 0
+static SANE_Status
+send_threshold_data(NEC_Scanner *s)
+{
+  SANE_Status status;
+  SANE_Byte cmd[26] = {SEND, 0, 0x82, 0, 0, 0, 0, 0, 0, 0};
+  int len;
+  
+  memset(cmd, 0, sizeof(cmd));
+  /* maximum string length: 3 bytes for each number (they are 
+     restricted to the range 0..255), 3 '/' and the null-byte,
+     total: 16 bytes.
+  */
+  len = sprintf((char *) &cmd[10], "%i/%i/%i/%i", 
+                s->val[OPT_THRESHOLD_R].w,
+                s->val[OPT_THRESHOLD_G].w,
+                s->val[OPT_THRESHOLD_B].w,
+                s->val[OPT_THRESHOLD].w);
+  cmd[8] = len;
+  
+  wait_ready(s->fd);
+  status = sanei_scsi_cmd(s->fd, cmd, len + 10, 0, 0);
+  return status;
+}
+#endif
+#endif
+
+SANE_Status
+sane_start (SANE_Handle handle)
+{
+  char *mode, *halftone, *paper, *gamma, *edge, *lightcolor, *adf_fsu;
+  NEC_Scanner *s = handle;
+  SANE_Status status;
+  size_t buf_size;
+  window_param wp;
+
+  DBG (10, "<< sane_start ");
+
+  /* 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;
+
+  s->dev->sensedat.complain_on_adf_error = 1;
+
+#ifdef HAVE_SANEI_SCSI_OPEN_EXTENDED
+  s->dev->info.bufsize = s->dev->info.wanted_bufsize;
+  if (s->dev->info.bufsize < 32 * 1024)
+    s->dev->info.bufsize = 32 * 1024;
+  {
+    int bsize = s->dev->info.bufsize;
+    status = sanei_scsi_open_extended (s->dev->sane.name, &s->fd, 
+              &sense_handler, &s->dev->sensedat, &bsize);
+    s->dev->info.bufsize = bsize;
+  }
+
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "open of %s failed: %s\n",
+         s->dev->sane.name, sane_strstatus (status));
+      return (status);
+    }
+
+  /* make sure that we got at least 32 kB. Even then, the scan will be
+     awfully slow. 
+     
+  */
+  if (s->dev->info.bufsize < 32 * 1024)
+    {
+      sanei_scsi_close(s->fd);
+      s->fd = -1;
+      return SANE_STATUS_NO_MEM;
+    }
+#else
+  status = sanei_scsi_open(s->dev->sane.name, &s->fd, &sense_handler, 
+              &s->dev->sensedat);
+  if (s->dev->info.wanted_bufsize < sanei_scsi_max_request_size)
+    s->dev->info.bufsize = s->dev->info.wanted_bufsize;
+  else
+    s->dev->info.bufsize = sanei_scsi_max_request_size;
+    
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "open of %s failed: %s\n",
+         s->dev->sane.name, sane_strstatus (status));
+      return (status);
+    }
+#endif
+
+  s->buffer = malloc(s->dev->info.bufsize);
+  if (!s->buffer) {
+    sanei_scsi_close(s->fd);
+    s->fd = -1;
+    free(s);
+    return SANE_STATUS_NO_MEM;
+  }
+
+#ifdef USE_FORK
+  {
+    struct shmid_ds ds;
+    size_t n;
+
+    s->shmid = shmget(IPC_PRIVATE,
+       sizeof(NEC_rdr_ctl)
+       + s->dev->info.buffers *
+         (sizeof(NEC_shmem_ctl) + s->dev->info.bufsize),
+       IPC_CREAT | 0600);
+    if (s->shmid == -1)
+      {
+        free(s->buffer);
+        s->buffer = 0;
+        sanei_scsi_close(s->fd);
+        s->fd = -1;
+        return SANE_STATUS_NO_MEM;
+      }
+    s->rdr_ctl = (NEC_rdr_ctl*) shmat(s->shmid, 0, 0);
+    if ((int)s->rdr_ctl == -1)
+     {
+       shmctl(s->shmid, IPC_RMID, &ds);
+       free(s->buffer);
+       s->buffer = 0;
+       sanei_scsi_close(s->fd);
+       s->fd = -1;
+       return SANE_STATUS_NO_MEM;
+     }
+
+    s->rdr_ctl->buf_ctl = (NEC_shmem_ctl*) &s->rdr_ctl[1];
+    for (n = 0; n < s->dev->info.buffers; n++)
+      {
+        s->rdr_ctl->buf_ctl[n].buffer =
+          (SANE_Byte*) &s->rdr_ctl->buf_ctl[s->dev->info.buffers]
+            + n * s->dev->info.bufsize;
+      }
+  }
+#endif /* USE_FORK */
+
+  DBG (5, "start: TEST_UNIT_READY\n");
+  status = test_unit_ready (s->fd);
+  
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "TEST UNIT READY failed: %s\n", sane_strstatus (status));
+      sanei_scsi_close (s->fd);
+      s->fd = -1;
+      return (status);
+    }
+
+  DBG (3, "start: sending MODE SELECT\n");
+  status = mode_select_mud (s->fd, s->dev->info.mud);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "start: MODE_SELECT6 failed\n");
+      sanei_scsi_close (s->fd);
+      s->fd = -1;
+      return (status);
+    }
+
+  mode = s->val[OPT_MODE].s;
+  halftone = s->val[OPT_HALFTONE].s;
+  paper = s->val[OPT_PAPER].s;
+  gamma = s->val[OPT_GAMMA].s;
+  edge = s->val[OPT_EDGE_EMPHASIS].s;
+  lightcolor = s->val[OPT_LIGHTCOLOR].s;
+  adf_fsu = s->val[OPT_SCANSOURCE].s;
+
+  if (s->val[OPT_PREVIEW].w == SANE_FALSE)
+    {
+      s->res = s->val[OPT_RESOLUTION].w * s->dev->info.res_range.quant;
+    }
+  else
+    {
+      s->res = 75;
+    }
+  s->ulx = MM_TO_PIX(SANE_UNFIX(s->val[OPT_TL_X].w), s->dev->info.mud);
+  s->uly = MM_TO_PIX(SANE_UNFIX(s->val[OPT_TL_Y].w), s->dev->info.mud);
+  s->threshold = s->val[OPT_THRESHOLD].w;
+
+  if (strcmp (mode, M_LINEART_COLOR) == 0)
+    s->bpp = 1;
+  else
+    s->bpp = s->params.depth;
+
+  s->adf_fsu_mode = SCAN_SIMPLE; /* default: scan without ADF and FSU */
+
+  if (strcmp(adf_fsu, use_fsu) == 0)
+    s->adf_fsu_mode = SCAN_WITH_FSU;
+  else if (strcmp(adf_fsu, use_adf) == 0)
+    s->adf_fsu_mode = SCAN_WITH_ADF;
+  else if (strcmp(adf_fsu, use_adf) == 0)
+    s->adf_fsu_mode = SCAN_SIMPLE;
+
+  /* halftone must not set to be zero PC-IN500 */
+  s->halftone = 0x01;
+  if (strcmp (mode, M_LINEART) == 0)
+    {
+      s->reverse = 0;
+      s->image_composition = 1;
+      if (strcmp(halftone, M_BILEVEL) == 0)
+	{
+	  s->image_composition = 0;
+	  s->halftone = 0x01;
+	}
+      else if (strcmp(halftone, M_DITHER1) == 0)
+	s->halftone = 0x01;
+      else if (strcmp(halftone, M_DITHER2) == 0)
+	s->halftone = 0x10;
+      else if (strcmp(halftone, M_DITHER3) == 0)
+	s->halftone = 0x20;
+    }
+  else if (strcmp (mode, M_GRAY) == 0)
+    {
+      s->image_composition = 2;
+      s->reverse = 1;
+    }
+  else if (strcmp (mode, M_LINEART_COLOR) == 0)
+    {
+      s->reverse = 1;
+      s->image_composition = 4;
+      if (strcmp(halftone, M_BILEVEL) == 0)
+	{
+	  s->image_composition = 3;
+	  s->halftone = 0x01;
+	}
+      else if (strcmp(halftone, M_DITHER1) == 0)
+	s->halftone = 0x01;
+      else if (strcmp(halftone, M_DITHER2) == 0)
+	s->halftone = 0x10;
+      else if (strcmp(halftone, M_DITHER3) == 0)
+	s->halftone = 0x20;
+    }
+  else if (strcmp (mode, M_COLOR) == 0)
+    {
+      s->image_composition = 5;
+      s->reverse = 1;
+    }
+
+  if (s->dev->sensedat.model == PCIN500)
+    {
+      s->or = s->val[OPT_OR].w;
+      s->nr = s->val[OPT_NR].w;
+      s->edge = s->val[OPT_EDGE].w;
+    }
+  else
+    {
+      if (strcmp (edge, EDGE_NONE) == 0)
+	s->edge = 0;
+      else if (strcmp (edge, EDGE_MIDDLE) == 0)
+	s->edge = 1;
+      else if (strcmp (edge, EDGE_STRONG) == 0)
+	s->edge = 2;
+      else if (strcmp (edge, EDGE_BLUR) == 0)
+	s->edge = 3;
+    }
+  
+  s->lightcolor = 3;
+  if (strcmp(lightcolor, LIGHT_GREEN) == 0)
+    s->lightcolor = 0;
+  else if (strcmp(lightcolor, LIGHT_RED) == 0)
+    s->lightcolor = 1;
+  else if (strcmp(lightcolor, LIGHT_BLUE) == 0)
+    s->lightcolor = 2;
+  else if (strcmp(lightcolor, LIGHT_NONE) == 0)
+    s->lightcolor = 3;
+
+  s->adf_scan = 0;
+  
+#ifdef USE_CUSTOM_GAMMA
+  if (s->val[OPT_CUSTOM_GAMMA].w == SANE_FALSE)
+    {
+#endif
+      if (s->dev->sensedat.model == PCIN500)
+	{
+	  if (strcmp (gamma, CRT1))
+	    s->gamma = 1;
+	  else if (strcmp (gamma, CRT2))
+	    s->gamma = 2;
+	  else if (strcmp (gamma, PRINTER1))
+	    s->gamma = 3;
+	  else if (strcmp (gamma, PRINTER2))
+	    s->gamma = 4;
+	  else if (strcmp (gamma, NONE))
+	    s->gamma = 5;
+	}
+#if 0
+      if (s->dev->sensedat.model != PCIN500)
+        {
+          ss.dtc = 0x03;
+          if (strcmp (gamma, GAMMA10) == 0)
+	    ss.dtq = 0x01;
+          else
+	    ss.dtq = 0x02;
+          ss.length = 0;
+          DBG (5, "start: SEND\n");
+          status = send (s->fd,  &ss);
+          if (status != SANE_STATUS_GOOD)
+            {
+              DBG (1, "send failed: %s\n", sane_strstatus (status));
+              sanei_scsi_close (s->fd);
+              s->fd = -1;
+              return (status);
+            }
+       }
+     else
+#else
+       {
+         int i;
+         SANE_Word gtbl[256];
+#if 0
+         if (strcmp (gamma, GAMMA10) == 0)
+           for (i = 0; i < 256; i++)
+             gtbl[i] = i;
+         else
+#endif
+           {
+             gtbl[0] = 0;
+             for (i = 1; i < 256; i++)
+               gtbl[i] = 255 * exp(0.45 * log(i/255.0));
+           }
+         send_binary_g_table(s, gtbl, 0x10);
+         send_binary_g_table(s, gtbl, 0x11);
+         send_binary_g_table(s, gtbl, 0x12);
+         send_binary_g_table(s, gtbl, 0x13);
+       }
+#endif /* DEBUG_NEC */
+#ifdef USE_CUSTOM_GAMMA
+    }
+  else
+    {
+      s->gamma = 9;
+      status = send_gamma_tables(s);
+    }
+  if (status != SANE_STATUS_GOOD)
+    {
+      sanei_scsi_close (s->fd);
+      s->fd = -1;
+      return (status);
+    }
+#endif
+
+  s->tint = s->val[OPT_TINT].w;
+  s->color = s->val[OPT_COLOR].w;
+
+  memset (&wp, 0, sizeof (wp));
+  /* every NEC scanner seems to have a different 
+     window descriptor block...
+  */
+  if (s->dev->sensedat.model == PCIN500)
+    buf_size = sizeof(WDB) + sizeof(WDBX500);
+  else
+    buf_size = sizeof(WDB);
+    
+  wp.wpdh.wdl[0] = buf_size >> 8;
+  wp.wpdh.wdl[1] = buf_size;
+  wp.wdb.x_res[0] = s->res >> 8;
+  wp.wdb.x_res[1] = s->res;
+  wp.wdb.y_res[0] = s->res >> 8;
+  wp.wdb.y_res[1] = s->res;
+  wp.wdb.x_ul[0] = s->ulx >> 24;
+  wp.wdb.x_ul[1] = s->ulx >> 16;
+  wp.wdb.x_ul[2] = s->ulx >> 8;
+  wp.wdb.x_ul[3] = s->ulx;
+  wp.wdb.y_ul[0] = s->uly >> 24;
+  wp.wdb.y_ul[1] = s->uly >> 16;
+  wp.wdb.y_ul[2] = s->uly >> 8;
+  wp.wdb.y_ul[3] = s->uly;
+  wp.wdb.width[0] = s->width >> 24;
+  wp.wdb.width[1] = s->width >> 16;
+  wp.wdb.width[2] = s->width >> 8;
+  wp.wdb.width[3] = s->width;
+  wp.wdb.length[0] = s->length >> 24;
+  wp.wdb.length[1] = s->length >> 16;
+  wp.wdb.length[2] = s->length >> 8;
+  wp.wdb.length[3] = s->length;
+  wp.wdb.brightness = 0;
+  wp.wdb.threshold = s->threshold;
+  wp.wdb.brightness = 128;
+  wp.wdb.contrast = 128;
+  wp.wdb.image_composition = s->image_composition;
+  if (s->image_composition <= 2 || s->image_composition >= 5)
+    wp.wdb.bpp = s->bpp;
+  else
+    wp.wdb.bpp = 1;
+  wp.wdb.ht_pattern[0] = 0;
+  wp.wdb.ht_pattern[1] = 0;
+  if (s->dev->sensedat.model == PCIN500)
+    wp.wdb.ht_pattern[1] = s->halftone;
+  wp.wdb.rif_padding = (s->reverse * 128) + 0;
+
+  if (s->dev->sensedat.model == PCIN500)
+    {
+      wp.wdbx500.data_length = 0x07;
+      wp.wdbx500.control = 0 | (s->or << 7) | (s->edge << 6) | (s->nr << 5) |
+	                   (s->lightcolor << 2);
+      wp.wdbx500.format = 0;
+      wp.wdbx500.gamma = s->gamma;
+      wp.wdbx500.tint = s->tint;
+      wp.wdbx500.color = s->color;
+      wp.wdbx500.reserved1 = 0;
+      wp.wdbx500.reserved2 = 0;
+    }
+
+  DBG (5, "wdl=%d\n", (wp.wpdh.wdl[0] << 8) + wp.wpdh.wdl[1]);
+  DBG (5, "xres=%d\n", (wp.wdb.x_res[0] << 8) + wp.wdb.x_res[1]);
+  DBG (5, "yres=%d\n", (wp.wdb.y_res[0] << 8) + wp.wdb.y_res[1]);
+  DBG (5, "ulx=%d\n", (wp.wdb.x_ul[0] << 24) + (wp.wdb.x_ul[1] << 16) +
+                      (wp.wdb.x_ul[2] << 8) + wp.wdb.x_ul[3]);
+  DBG (5, "uly=%d\n", (wp.wdb.y_ul[0] << 24) + (wp.wdb.y_ul[1] << 16) +
+                      (wp.wdb.y_ul[2] << 8) + wp.wdb.y_ul[3]);
+  DBG (5, "width=%d\n", (wp.wdb.width[0] << 8) + (wp.wdb.width[1] << 16) +
+                        (wp.wdb.width[2] << 8) + wp.wdb.width[3]);
+  DBG (5, "length=%d\n", (wp.wdb.length[0] << 16) + (wp.wdb.length[1] << 16) +
+                         (wp.wdb.length[2] << 8) + wp.wdb.length[3]);
+
+  DBG (5, "threshold=%d\n", wp.wdb.threshold);
+  DBG (5, "image_composition=%d\n", wp.wdb.image_composition);
+  DBG (5, "bpp=%d\n", wp.wdb.bpp);
+  DBG (5, "rif_padding=%d\n", wp.wdb.rif_padding);
+
+#ifdef DEBUG_NEC
+  {
+    window_param foo;
+    size_t len = buf_size;
+    len += sizeof(WPDH);
+  DBG (5, "start: GET WINDOW\n");
+  status = get_window (s->fd, &foo, &len);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "GET WINDOW failed: %s\n", sane_strstatus (status));
+      sanei_scsi_close (s->fd);
+      s->fd = -1;
+      return (status);
+    }
+#if 1
+  {
+    unsigned char *p = (unsigned char*) &foo;
+    int i;
+    DBG(11, "get window(debug):\n");
+    for (i = 0; i < len; i += 16)
+     {
+      DBG(1, "%2x %2x %2x %2x %2x %2x %2x %2x - %2x %2x %2x %2x %2x %2x %2x %2x\n",
+      p[i], p[i+1], p[i+2], p[i+3], p[i+4], p[i+5], p[i+6], p[i+7], p[i+8],
+      p[i+9], p[i+10], p[i+11], p[i+12], p[i+13], p[i+14], p[i+15]);
+     }
+  }
+#endif
+  foo.wpdh.wpdh[1] = 0;
+  status = set_window (s->fd, &foo, len);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "SET WINDOW failed: %s\n", sane_strstatus (status));
+      sanei_scsi_close (s->fd);
+      s->fd = -1;
+      return (status);
+    }
+#if 1
+  {
+    unsigned char *p = (unsigned char*) &foo;
+    int i;
+    DBG(11, "set window(debug):\n");
+    for (i = 0; i < len; i += 16)
+     {
+      DBG(1, "%2x %2x %2x %2x %2x %2x %2x %2x - %2x %2x %2x %2x %2x %2x %2x %2x\n",
+      p[i], p[i+1], p[i+2], p[i+3], p[i+4], p[i+5], p[i+6], p[i+7], p[i+8],
+      p[i+9], p[i+10], p[i+11], p[i+12], p[i+13], p[i+14], p[i+15]);
+     }
+  }
+#endif
+  }
+#endif /* debug_nec */
+
+#ifdef DEBUG_NEC
+  {
+    unsigned char *p = (unsigned char*) &wp;
+    int i;
+    DBG(11, "set window(debug):\n");
+    for (i = 0; i < sizeof(wp.wdb) + sizeof(wp.wdbx500); i += 16)
+     {
+      DBG(1, "%2x %2x %2x %2x %2x %2x %2x %2x - %2x %2x %2x %2x %2x %2x %2x %2x\n",
+      p[i], p[i+1], p[i+2], p[i+3], p[i+4], p[i+5], p[i+6], p[i+7], p[i+8],
+      p[i+9], p[i+10], p[i+11], p[i+12], p[i+13], p[i+14], p[i+15]);
+     }
+  }
+#endif /* debug_nec */
+
+  buf_size += sizeof(WPDH);
+  DBG (5, "start: SET WINDOW\n");
+  status = set_window (s->fd, &wp, buf_size);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "SET WINDOW failed: %s\n", sane_strstatus (status));
+      sanei_scsi_close (s->fd);
+      s->fd = -1;
+      return (status);
+    }
+
+  memset (&wp, 0, buf_size);
+  DBG (5, "start: GET WINDOW\n");
+  status = get_window (s->fd, &wp, &buf_size);
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "GET WINDOW failed: %s\n", sane_strstatus (status));
+      sanei_scsi_close (s->fd);
+      s->fd = -1;
+      return (status);
+    }
+#ifdef DEBUG_NEC
+  {
+    unsigned char *p = (unsigned char*) &wp;
+    int i;
+    DBG(11, "get window(debug):\n");
+    for (i = 0; i < buf_size; i += 16)
+     {
+      DBG(1, "%2x %2x %2x %2x %2x %2x %2x %2x - %2x %2x %2x %2x %2x %2x %2x %2x\n",
+      p[i], p[i+1], p[i+2], p[i+3], p[i+4], p[i+5], p[i+6], p[i+7], p[i+8],
+      p[i+9], p[i+10], p[i+11], p[i+12], p[i+13], p[i+14], p[i+15]);
+     }
+  }
+#endif
+  DBG (5, "xres=%d\n", (wp.wdb.x_res[0] << 8) + wp.wdb.x_res[1]);
+  DBG (5, "yres=%d\n", (wp.wdb.y_res[0] << 8) + wp.wdb.y_res[1]);
+  DBG (5, "ulx=%d\n", (wp.wdb.x_ul[0] << 24) + (wp.wdb.x_ul[1] << 16) +
+                      (wp.wdb.x_ul[2] << 8) + wp.wdb.x_ul[3]);
+  DBG (5, "uly=%d\n", (wp.wdb.y_ul[0] << 24) + (wp.wdb.y_ul[1] << 16) +
+       (wp.wdb.y_ul[2] << 8) + wp.wdb.y_ul[3]);
+  DBG (5, "width=%d\n", (wp.wdb.width[0] << 24) + (wp.wdb.width[1] << 16) +
+                        (wp.wdb.width[2] << 8) + wp.wdb.width[3]);
+  DBG (5, "length=%d\n", (wp.wdb.length[0] << 24) + (wp.wdb.length[1] << 16) +
+                         (wp.wdb.length[2] << 8) + wp.wdb.length[3]);
+  DBG (5, "start: SCAN\n");
+  s->scanning = SANE_TRUE;
+  s->busy = SANE_TRUE;
+  s->cancel = SANE_FALSE;
+  s->get_params_called = 0;
+
+  status = scan (s->fd);
+#ifdef DEBUG
+          {
+            struct timeval t;
+            gettimeofday(&t, 0);
+            DBG(2, "rd: scan started        %li.%06li\n", t.tv_sec, t.tv_usec);
+          }
+#endif
+  if (status != SANE_STATUS_GOOD)
+    {
+      DBG (1, "start of scan failed: %s\n", sane_strstatus (status));
+      sanei_scsi_close (s->fd);
+      s->fd = -1;
+      s->busy = SANE_FALSE;
+      s->cancel = SANE_FALSE;
+      return (status);
+    }
+
+  /* ask the scanner for the scan size */
+  /* wait_ready(s->fd); */
+#ifdef DEBUG
+          {
+            struct timeval t;
+            gettimeofday(&t, 0);
+            DBG(2, "rd: wait_ready ok       %li.%06li\n", t.tv_sec, t.tv_usec);
+          }
+#endif
+  sane_get_parameters(s, 0);
+#ifdef DEBUG
+          {
+            struct timeval t;
+            gettimeofday(&t, 0);
+            DBG(2, "rd: get_params ok       %li.%06li\n", t.tv_sec, t.tv_usec);
+          }
+#endif
+  if (strcmp (mode, M_LINEART_COLOR) != 0)
+    s->bytes_to_read = s->params.bytes_per_line * s->params.lines;
+  else
+    {
+      s->bytes_to_read = s->params.bytes_per_line * s->params.lines;
+    }
+
+#ifdef USE_FORK
+  {
+    size_t i;
+    for (i = 0; i < s->dev->info.buffers; i++) 
+      s->rdr_ctl->buf_ctl[i].shm_status = SHM_EMPTY;
+    s->read_buff = 0;
+    s->rdr_ctl->cancel = 0;
+    s->rdr_ctl->running = 0;
+    s->rdr_ctl->status  = SANE_STATUS_GOOD;
+  }
+  s->reader_pid = fork();
+#ifdef DEBUG
+          {
+            struct timeval t;
+            gettimeofday(&t, 0);
+            DBG(2, "rd: forked              %li.%06li %i\n", t.tv_sec, t.tv_usec,
+              s->reader_pid);
+          }
+#endif
+  if (s->reader_pid == 0) 
+    {
+      sigset_t ignore_set;
+      struct SIGACTION act;
+
+      sigfillset (&ignore_set);
+      sigdelset (&ignore_set, SIGTERM);
+      sigprocmask (SIG_SETMASK, &ignore_set, 0);
+
+      memset (&act, 0, sizeof (act));
+      sigaction (SIGTERM, &act, 0);
+
+      /* don't use exit() since that would run the atexit() handlers... */
+      _exit (reader_process (s));
+    }
+  else if (s->reader_pid == -1)
+    {
+      s->busy = SANE_FALSE;
+      do_cancel(s);
+      return SANE_STATUS_NO_MEM;
+    }
+   
+#endif /* USE_FORK */
+  
+
+  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_RESOLUTION].w);
+
+  s->busy = SANE_FALSE;
+  s->buf_used = 0;
+  s->buf_pos = 0;
+
+  if (s->cancel == SANE_TRUE) 
+    {
+      do_cancel(s);
+      DBG (10, ">>\n");
+      return(SANE_STATUS_CANCELLED);
+    }
+
+  DBG (10, ">>\n");
+  return (SANE_STATUS_GOOD);
+
+}
+
+static SANE_Status
+sane_read_direct (SANE_Handle handle, SANE_Byte *dst_buf, SANE_Int max_len,
+	   SANE_Int * len)
+{
+  NEC_Scanner *s = handle;
+  SANE_Status status;
+  size_t nread;
+  DBG (10, "<< sane_read_direct ");
+
+#if 0
+  {
+    buffer_status bs;
+    size_t len = sizeof (buffer_status);
+    get_data_buffer_status (s->fd, &bs, &len);
+    DBG (20, "buffer_status: %i ", bs.fdb[0]*256*256 + bs.fdb[1]*256 + bs.fdb[2]); 
+  }
+#endif
+  DBG (20, "remaining: %lu ", (u_long)  s->bytes_to_read);
+  *len = 0;
+
+  if (s->bytes_to_read == 0)
+    {
+      do_cancel (s);
+      return (SANE_STATUS_EOF);
+    }
+
+  if (!s->scanning)
+    return (do_cancel (s));
+  nread = max_len;
+  if (nread > s->bytes_to_read)
+    nread = s->bytes_to_read;
+  if (nread > s->dev->info.bufsize)
+    nread = s->dev->info.bufsize;
+
+#ifdef USE_FORK
+  status = read_data(s, dst_buf, &nread);
+#else
+#ifdef NOTUSE_PCIN500
+  wait_ready(s->fd);
+#endif
+  status = read_data (s, dst_buf, &nread);
+#endif
+  if (status != SANE_STATUS_GOOD)
+    {
+      do_cancel (s);
+      return (SANE_STATUS_IO_ERROR);
+    }
+  *len = nread;
+  s->bytes_to_read -= nread;
+  DBG (20, "remaining: %lu ", (u_long) s->bytes_to_read);
+
+  DBG (10, ">>\n");
+  return (SANE_STATUS_GOOD);
+}
+
+static SANE_Status
+sane_read_shuffled (SANE_Handle handle, SANE_Byte *dst_buf, SANE_Int max_len,
+	   SANE_Int * len, int eight_bit_data)
+{
+  NEC_Scanner *s = handle;
+  SANE_Status status;
+  SANE_Byte *dest, *red, *green, *blue, mask;
+  SANE_Int transfer;
+  size_t nread, ntest, pixel, max_pixel, line, max_line;
+  size_t start_input, bytes_per_line_in;
+  DBG (10, "<< sane_read_shuffled ");
+
+#if 0
+  {
+    buffer_status bs;
+    size_t len = sizeof (buffer_status);
+    get_data_buffer_status (s->fd, &bs, &len);
+    DBG (20, "buffer_status: %i ", bs.fdb[0]*256*256 + bs.fdb[1]*256 + bs.fdb[2]); 
+  }
+#endif
+  *len = 0;
+  if (s->bytes_to_read == 0 && s->buf_pos == s->buf_used) 
+    {
+      do_cancel (s);
+      DBG (10, ">>\n");
+      return (SANE_STATUS_EOF);
+    }
+    
+  if (!s->scanning) 
+    {
+      DBG (10, ">>\n");
+      return(do_cancel(s));
+    }
+
+  if (s->buf_pos < s->buf_used)
+    {
+      transfer = s->buf_used - s->buf_pos;
+      if (transfer > max_len)
+        transfer = max_len;
+      
+      memcpy(dst_buf, &(s->buffer[s->buf_pos]), transfer);
+      s->buf_pos += transfer;
+      max_len -= transfer;
+      *len = transfer;
+    }
+
+  while (max_len > 0 && s->bytes_to_read > 0) 
+    {
+      if (eight_bit_data)
+        {
+          nread = s->dev->info.bufsize / s->params.bytes_per_line - 1;
+          nread *= s->params.bytes_per_line;
+          if (nread > s->bytes_to_read)
+            nread = s->bytes_to_read;
+          max_line = nread / s->params.bytes_per_line;
+          start_input = s->params.bytes_per_line;
+          bytes_per_line_in = s->params.bytes_per_line;
+        }
+      else
+        {
+          bytes_per_line_in = (s->params.pixels_per_line + 7) / 8;
+          bytes_per_line_in *= 3;
+          max_line = s->params.bytes_per_line + bytes_per_line_in;
+          max_line = s->dev->info.bufsize / max_line;
+          nread = max_line * bytes_per_line_in;
+          if (nread > s->bytes_to_read)
+            {
+              nread = s->bytes_to_read;
+              max_line = nread / bytes_per_line_in;
+            }
+          start_input = s->dev->info.bufsize - nread;
+        }
+      ntest = nread;
+      
+#ifdef USE_FORK
+      status = read_data (s, &(s->buffer[start_input]), &nread);
+#else
+      status = read_data (s, &(s->buffer[start_input]), &nread);
+#endif
+      if (status != SANE_STATUS_GOOD)
+        {
+          do_cancel (s);
+          DBG (10, ">>\n");
+          return (SANE_STATUS_IO_ERROR);
+        }
+      
+      if (nread != ntest) 
+        {
+          /* if this happens, something is wrong in the input buffer
+             management...
+          */
+          DBG(1, "Warning: could not read an integral number of scan lines\n");
+          DBG(1, "         image will be scrambled\n");
+        }
+      
+      
+      s->buf_used = max_line * s->params.bytes_per_line;
+      s->buf_pos = 0;
+      s->bytes_to_read -= nread;
+      dest = s->buffer;
+      max_pixel = s->params.pixels_per_line;
+
+      if (eight_bit_data)
+        for (line = 1; line <= max_line; line++)
+          {
+            red = &(s->buffer[line * s->params.bytes_per_line]);
+            green = &(red[max_pixel]);
+            blue = &(green[max_pixel]);
+            for (pixel = 0; pixel < max_pixel; pixel++)
+              {
+                *dest++ = *red++;
+                *dest++ = *green++;
+                *dest++ = *blue++;
+              }
+          }
+      else
+        for (line = 0; line < max_line; line++)
+          {
+            red = &(s->buffer[start_input + line * bytes_per_line_in]);
+            green = &(red[(max_pixel+7)/8]);
+            blue = &(green[(max_pixel+7)/8]);
+            mask = 0x80;
+            for (pixel = 0; pixel < max_pixel; pixel++)
+              {
+                *dest++ = (*red & mask)   ? 0xff : 0;
+                *dest++ = (*green & mask) ? 0xff : 0;
+                *dest++ = (*blue & mask)  ? 0xff : 0;
+                mask = mask >> 1;
+                if (mask == 0)
+                  {
+                    mask = 0x80;
+                    red++;
+                    green++;
+                    blue++;
+                  }
+              }
+          }
+      
+      transfer = max_len;
+      if (transfer > s->buf_used)
+        transfer = s->buf_used;
+      memcpy(&(dst_buf[*len]), s->buffer, transfer);
+      
+      max_len -= transfer;
+      s->buf_pos += transfer;
+      *len += transfer;
+    }
+
+  if (s->bytes_to_read == 0 && s->buf_pos == s->buf_used)
+    do_cancel (s);
+  DBG (10, ">>\n");
+  return (SANE_STATUS_GOOD);
+}
+
+SANE_Status
+sane_read (SANE_Handle handle, SANE_Byte *dst_buf, SANE_Int max_len,
+	   SANE_Int * len)
+{
+  NEC_Scanner *s = handle;
+  SANE_Status status;
+
+  DBG (10, "<< sane_read ");
+  s->busy = SANE_TRUE;
+  if (s->cancel == SANE_TRUE) 
+    {
+      do_cancel(s);
+      *len = 0;
+      return (SANE_STATUS_CANCELLED);
+    }
+  
+  if (s->image_composition <= 2)
+    status = sane_read_direct(handle, dst_buf, max_len, len);
+  else if (s->image_composition <= 4)
+    status = sane_read_shuffled(handle, dst_buf, max_len, len, 0);
+  else if (s->dev->sensedat.model == PCIN500)
+    status = sane_read_direct(handle, dst_buf, max_len, len);
+  else
+    status = sane_read_shuffled(handle, dst_buf, max_len, len, 1);
+
+  s->busy = SANE_FALSE;
+  if (s->cancel == SANE_TRUE)
+    {
+      do_cancel(s);
+      return (SANE_STATUS_CANCELLED);
+    }
+
+  DBG (10, ">> \n");
+  return (status);
+}
+
+void
+sane_cancel (SANE_Handle handle)
+{
+  NEC_Scanner *s = handle;
+  DBG (10, "<< sane_cancel ");
+
+  s->cancel = SANE_TRUE;
+  if (s->busy == SANE_FALSE)
+      do_cancel(s);
+
+  DBG (10, ">>\n");
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
+{
+  handle = handle;
+  non_blocking = non_blocking; /* silence compilation warnings */
+
+  DBG (10, "<< sane_set_io_mode");
+  DBG (10, ">>\n");
+
+  return SANE_STATUS_UNSUPPORTED;
+}
+
+SANE_Status
+sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
+{
+  handle = handle;
+  fd = fd; /* silence compilation warnings */
+  
+  DBG (10, "<< sane_get_select_fd");
+  DBG (10, ">>\n");
+
+  return SANE_STATUS_UNSUPPORTED;
+}