summaryrefslogtreecommitdiff
path: root/backend/hs2p.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
commit6e9c41a892ed0e0da326e0278b3221ce3f5713b8 (patch)
tree2e301d871bbeeb44aa57ff9cc070fcf3be484487 /backend/hs2p.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/hs2p.c')
-rw-r--r--backend/hs2p.c3332
1 files changed, 3332 insertions, 0 deletions
diff --git a/backend/hs2p.c b/backend/hs2p.c
new file mode 100644
index 0000000..de3be42
--- /dev/null
+++ b/backend/hs2p.c
@@ -0,0 +1,3332 @@
+/* sane - Scanner Access Now Easy.
+ Copyright (C) 2007 Jeremy Johnson
+ This file is part of a SANE backend for Ricoh IS450
+ and IS420 family of HS2P Scanners using the SCSI controller.
+
+ This file is part of the SANE package.
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License as
+ published by the Free Software Foundation; either version 2 of the
+ License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful, but
+ WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ MA 02111-1307, USA.
+
+ As a special exception, the authors of SANE give permission for
+ additional uses of the libraries contained in this release of SANE.
+
+ The exception is that, if you link a SANE library with other files
+ to produce an executable, this does not by itself cause the
+ resulting executable to be covered by the GNU General Public
+ License. Your use of that executable is in no way restricted on
+ account of linking the SANE library code into it.
+
+ This exception does not, however, invalidate any other reasons why
+ the executable file might be covered by the GNU General Public
+ License.
+
+ If you submit changes to SANE to the maintainers to be included in
+ a subsequent release, you agree by submitting the changes that
+ those changes may be distributed with this exception intact.
+
+ If you write modifications of your own for SANE, it is your choice
+ whether to permit this exception to apply to your modifications.
+ If you do not wish that, delete this exception notice.
+
+*/
+/* SANE-FLOW-DIAGRAM
+
+ - sane_init() : initialize backend, attach scanners
+ . - sane_get_devices() : query list of scanner-devices
+ . - sane_open() : open a particular scanner-device
+ . . - attach : to the device
+ . . . init_options : initialize SANE_OPTIONS array
+ . . - sane_set_io_mode : set blocking-mode
+ . . - sane_get_select_fd : get scanner-fd
+ . . - sane_get_option_descriptor() : get option informations
+ . . - sane_control_option() : change option values
+ . .
+ . . - sane_start() : start image aquisition
+ . . - sane_get_parameters() : returns actual scan-parameters
+ . . - sane_read() : read image-data (from pipe)
+ . .
+ . . - sane_cancel() : cancel operation
+ . - sane_close() : close opened scanner-device
+ - sane_exit() : terminate use of backend
+*/
+#define BUILD 1
+
+/* Begin includes */
+#include "../include/sane/config.h"
+
+#include <limits.h>
+#include <stdlib.h>
+#include <stdarg.h>
+#include <string.h>
+#include <sys/time.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <sys/types.h>
+
+#include "../include/sane/sane.h"
+#include "../include/sane/saneopts.h"
+#include "../include/sane/sanei_scsi.h"
+#include "../include/sane/sanei_config.h"
+#include "../include/sane/sanei_thread.h"
+
+#define BACKEND_NAME hs2p
+#include "../include/sane/sanei_backend.h"
+
+#ifndef PATH_MAX
+# define PATH_MAX 1024
+#endif
+
+#include "hs2p-scsi.c"
+
+/* Begin macros */
+#define MIN(x,y) ((x)<(y) ? (x) : (y))
+#define MAX(x,y) ((x)>(y) ? (x) : (y))
+
+/* Begin static constants */
+static int num_devices = 0;
+static HS2P_Device *first_dev = NULL;
+static HS2P_Scanner *first_handle = NULL;
+
+static SANE_Char inquiry_data[255] = "HS2P scanner";
+/*
+static SANE_Int disable_optional_frames = 0;
+static SANE_Int fake_inquiry = 0;
+*/
+
+static HS2P_HWEntry HS2P_Device_List[] = {
+ {"RICOH", "IS450"},
+ {"RICOH", "IS430"}, /*untested */
+ {"RICOH", "IS420"}, /*untested */
+ {"RICOH", "IS01"}, /*untested */
+ {"RICOH", "IS02"}, /*untested */
+ {NULL, NULL} /*sentinel */
+};
+
+#if 0
+static int
+allblank (const char *s)
+{
+ while (s && *s)
+ if (!isspace (*s++))
+ return 0;
+
+ return 1;
+}
+#endif
+
+static size_t
+max_string_size (SANE_String_Const strings[])
+{
+ size_t size, max_size = 0;
+ int i;
+ DBG (DBG_proc, ">> max_string_size\n");
+
+ for (i = 0; strings[i]; ++i)
+ {
+ size = strlen (strings[i]) + 1;
+ if (size > max_size)
+ max_size = size;
+ }
+
+ DBG (DBG_proc, "<< max_string_size\n");
+ return max_size;
+}
+
+static void
+trim_spaces (char *s, size_t n)
+{
+ for (s += (n - 1); n > 0; n--, s--)
+ {
+ if (*s && !isspace (*s))
+ break;
+ *s = '\0';
+ }
+}
+static SANE_Bool
+is_device_supported (char *device)
+{
+ HS2P_HWEntry *hw;
+
+ for (hw = &HS2P_Device_List[0]; hw->mfg != NULL; hw++)
+ if (strncmp (device, hw->model, strlen (hw->model)) == 0)
+ break; /* found a match */
+
+ return (hw == NULL) ? SANE_FALSE : SANE_TRUE;
+}
+
+static SANE_Int
+get_list_index (const char *list[], char *s) /* sequential search */
+{
+ SANE_Int i;
+
+ for (i = 0; list[i]; i++)
+ if (strcmp (s, list[i]) == 0)
+ return i; /* FOUND */
+
+ /* unknown paper_list strings are treated as 'custom' */
+ /* unknown compression_list strings are treated as 'none' */
+ /* unknown scan_source_list strings are treated as 'ADF' */
+ return 0;
+}
+
+static SANE_Int
+get_val_id_strndx (struct val_id *vi, int len, SANE_Int val)
+{
+ int i;
+ for (i = 0; i < len; i++)
+ if (vi[i].val == val)
+ return vi[i].id; /* FOUND */
+ return vi[0].id; /* NOT FOUND so let's default to first */
+}
+
+static SANE_Status
+init_options (HS2P_Scanner * s)
+{
+ SANE_Int i;
+ DBG (DBG_proc, ">> init_options\n");
+
+ memset (s->opt, 0, sizeof (s->opt));
+ memset (s->val, 0, sizeof (s->val));
+
+ for (i = 0; i < NUM_OPTIONS; ++i)
+ {
+ s->opt[i].size = sizeof (SANE_Word);
+ s->opt[i].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ }
+
+ s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
+ s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
+ s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
+ s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
+
+
+ /*
+ * "Scan Mode" GROUP:
+ */
+ s->opt[OPT_MODE_GROUP].name = "";
+ s->opt[OPT_MODE_GROUP].title = SANE_TITLE_SCAN_MODE_GROUP;
+ 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;
+
+ /* Preview: */
+ s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
+ s->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
+ s->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
+ s->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
+ s->opt[OPT_PREVIEW].constraint_type = SANE_CONSTRAINT_NONE;
+ s->val[OPT_PREVIEW].w = SANE_FALSE;
+
+ /* Inquiry */
+ s->opt[OPT_INQUIRY].name = SANE_NAME_INQUIRY;
+ s->opt[OPT_INQUIRY].title = SANE_TITLE_INQUIRY;
+ s->opt[OPT_INQUIRY].desc = SANE_DESC_INQUIRY;
+ s->opt[OPT_INQUIRY].type = SANE_TYPE_STRING;
+ s->opt[OPT_INQUIRY].size = sizeof (inquiry_data);
+ s->opt[OPT_INQUIRY].constraint_type = SANE_CONSTRAINT_NONE;
+ s->val[OPT_INQUIRY].s = strdup (inquiry_data);
+ s->opt[OPT_INQUIRY].cap = SANE_CAP_SOFT_DETECT; /* Display Only */
+
+ /* Scan mode */
+ s->opt[OPT_SCAN_MODE].name = SANE_NAME_SCAN_MODE;
+ s->opt[OPT_SCAN_MODE].title = SANE_TITLE_SCAN_MODE;
+ s->opt[OPT_SCAN_MODE].desc = SANE_DESC_SCAN_MODE;
+ s->opt[OPT_SCAN_MODE].type = SANE_TYPE_STRING;
+ s->opt[OPT_SCAN_MODE].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_SCAN_MODE].size =
+ max_string_size ((SANE_String_Const *) scan_mode_list);
+ s->opt[OPT_SCAN_MODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_SCAN_MODE].constraint.string_list =
+ (SANE_String_Const *) & scan_mode_list[0];
+ s->val[OPT_SCAN_MODE].s = strdup (scan_mode_list[0]);
+ s->image_composition = LINEART;
+
+ /* Standard resolutions */
+ s->opt[OPT_RESOLUTION].name = "std-" SANE_NAME_SCAN_RESOLUTION;
+ s->opt[OPT_RESOLUTION].title = "Std-" SANE_TITLE_SCAN_RESOLUTION;
+ s->opt[OPT_RESOLUTION].desc = "Std " SANE_DESC_SCAN_RESOLUTION;
+ s->opt[OPT_RESOLUTION].type = SANE_TYPE_INT;
+ s->opt[OPT_RESOLUTION].unit = SANE_UNIT_DPI;
+ s->opt[OPT_RESOLUTION].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+ s->opt[OPT_RESOLUTION].constraint.word_list = s->hw->info.resStdList;
+ s->val[OPT_RESOLUTION].w = s->hw->info.default_res;
+
+ /* X Resolution */
+ s->opt[OPT_X_RESOLUTION].name = SANE_NAME_SCAN_RESOLUTION;
+ s->opt[OPT_X_RESOLUTION].title = SANE_TITLE_SCAN_X_RESOLUTION;
+ s->opt[OPT_X_RESOLUTION].desc = "X " SANE_DESC_SCAN_RESOLUTION;
+ s->opt[OPT_X_RESOLUTION].type = SANE_TYPE_INT;
+ s->opt[OPT_X_RESOLUTION].unit = SANE_UNIT_DPI;
+ s->opt[OPT_X_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_X_RESOLUTION].constraint.range = &(s->hw->info.xres_range);
+ s->val[OPT_X_RESOLUTION].w = s->hw->info.resBasicX;
+
+ /* Y Resolution */
+ s->opt[OPT_Y_RESOLUTION].name = SANE_NAME_SCAN_Y_RESOLUTION;
+ s->opt[OPT_Y_RESOLUTION].title = SANE_TITLE_SCAN_Y_RESOLUTION;
+ s->opt[OPT_Y_RESOLUTION].desc = "Y " SANE_DESC_SCAN_RESOLUTION;
+ s->opt[OPT_Y_RESOLUTION].type = SANE_TYPE_INT;
+ s->opt[OPT_Y_RESOLUTION].unit = SANE_UNIT_DPI;
+ s->opt[OPT_Y_RESOLUTION].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_Y_RESOLUTION].constraint.range = &(s->hw->info.yres_range);
+ s->val[OPT_Y_RESOLUTION].w = s->hw->info.resBasicY;
+
+ /* Compression */
+ s->opt[OPT_COMPRESSION].name = SANE_NAME_COMPRESSION;
+ s->opt[OPT_COMPRESSION].title = SANE_TITLE_COMPRESSION;
+ s->opt[OPT_COMPRESSION].desc = SANE_DESC_COMPRESSION;
+ s->opt[OPT_COMPRESSION].type = SANE_TYPE_STRING;
+ s->opt[OPT_COMPRESSION].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_COMPRESSION].size =
+ max_string_size ((SANE_String_Const *) compression_list);
+ s->opt[OPT_COMPRESSION].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_COMPRESSION].constraint.string_list =
+ (SANE_String_Const *) & compression_list[0];
+ s->val[OPT_COMPRESSION].s = strdup (compression_list[0]);
+ if (s->hw->info.supports_MH == SANE_FALSE || /* MH G3 1-D */
+ s->hw->info.supports_MR == SANE_FALSE || /* MR G3 2-D */
+ s->hw->info.supports_MMR == SANE_FALSE || /* MMR G4 2-D */
+ s->hw->info.supports_MHB == SANE_FALSE) /* MH byte boundary */
+ {
+ s->opt[OPT_COMPRESSION].cap |= SANE_CAP_INACTIVE;
+ }
+
+
+
+ /*
+ * "Geometry" GROUP:
+ */
+ s->opt[OPT_GEOMETRY_GROUP].name = "";
+ s->opt[OPT_GEOMETRY_GROUP].title = SANE_TITLE_GEOMETRY_GROUP;
+ s->opt[OPT_GEOMETRY_GROUP].desc = "";
+ s->opt[OPT_GEOMETRY_GROUP].type = SANE_TYPE_GROUP;
+ s->opt[OPT_GEOMETRY_GROUP].cap = 0;
+ s->opt[OPT_GEOMETRY_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+ /* Auto Size Recognition available if IPU installed */
+ s->opt[OPT_AUTO_SIZE].name = SANE_NAME_AUTO_SIZE;
+ s->opt[OPT_AUTO_SIZE].title = SANE_TITLE_AUTO_SIZE;
+ s->opt[OPT_AUTO_SIZE].desc = SANE_DESC_AUTO_SIZE;
+ s->opt[OPT_AUTO_SIZE].type = SANE_TYPE_BOOL;
+ s->opt[OPT_AUTO_SIZE].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_AUTO_SIZE].constraint_type = SANE_CONSTRAINT_NONE;
+ s->val[OPT_AUTO_SIZE].w = SANE_FALSE;
+ if (!s->hw->info.supports_sizerecognition)
+ s->opt[OPT_AUTO_SIZE].cap |= SANE_CAP_INACTIVE;
+
+ /* Pad short documents to requested length with white space */
+ s->opt[OPT_PADDING].name = SANE_NAME_PADDING;
+ s->opt[OPT_PADDING].title = SANE_TITLE_PADDING;
+ s->opt[OPT_PADDING].desc = SANE_DESC_PADDING;
+ s->opt[OPT_PADDING].type = SANE_TYPE_BOOL;
+ s->opt[OPT_PADDING].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_PADDING].constraint_type = SANE_CONSTRAINT_NONE;
+ s->val[OPT_PADDING].w = SANE_TRUE;
+ /*if (!s->hw->info.hasADF)
+ s->opt[OPT_PADDING].cap |= SANE_CAP_INACTIVE;
+ FIXME: compare to user setting, not the existence of FB?
+ if (!strcmp (scan_source_list, "FB"))
+ s->opt[OPT_PADDING].cap |= SANE_CAP_INACTIVE; */
+ /* Permanently disable OPT_PADDING */
+ s->opt[OPT_PADDING].cap |= SANE_CAP_INACTIVE;
+
+ /* Paper Orientation */
+ s->opt[OPT_PAGE_ORIENTATION].name = SANE_NAME_ORIENTATION;
+ s->opt[OPT_PAGE_ORIENTATION].title = SANE_TITLE_ORIENTATION;
+ s->opt[OPT_PAGE_ORIENTATION].desc = SANE_DESC_ORIENTATION;
+ s->opt[OPT_PAGE_ORIENTATION].type = SANE_TYPE_STRING;
+ s->opt[OPT_PAGE_ORIENTATION].size = max_string_size (orientation_list);
+ s->opt[OPT_PAGE_ORIENTATION].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_PAGE_ORIENTATION].constraint.string_list = &orientation_list[0];
+ s->val[OPT_PAGE_ORIENTATION].s = strdup (orientation_list[0]);
+
+ /* Paper Size */
+ s->opt[OPT_PAPER_SIZE].name = SANE_NAME_PAPER_SIZE;
+ s->opt[OPT_PAPER_SIZE].title = SANE_TITLE_PAPER_SIZE;
+ s->opt[OPT_PAPER_SIZE].desc = SANE_DESC_PAPER_SIZE;
+ s->opt[OPT_PAPER_SIZE].type = SANE_TYPE_STRING;
+ s->opt[OPT_PAPER_SIZE].size = max_string_size (paper_list);
+ s->opt[OPT_PAPER_SIZE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_PAPER_SIZE].constraint.string_list = &paper_list[0];
+ s->val[OPT_PAPER_SIZE].s = strdup (paper_list[0]);
+
+ /* top-left x */
+ s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
+ s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
+ s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
+ s->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
+ s->opt[OPT_TL_X].unit = SANE_UNIT_MM;
+ s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_TL_X].constraint.range = &(s->hw->info.x_range);
+ s->val[OPT_TL_X].w = SANE_FIX (0.0);
+
+ /* top-left y */
+ s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
+ s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
+ s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
+ s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
+ s->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
+ s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_TL_Y].constraint.range = &(s->hw->info.y_range);
+ s->val[OPT_TL_Y].w = SANE_FIX (0.0);
+
+ /* bottom-right x */
+ s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
+ s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
+ s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
+ s->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
+ s->opt[OPT_BR_X].unit = SANE_UNIT_MM;
+ s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_BR_X].constraint.range = &(s->hw->info.x_range);
+ s->val[OPT_BR_X].w = s->hw->info.x_range.max;
+
+ /* bottom-right y */
+ s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
+ s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
+ s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
+ s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
+ s->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
+ s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_BR_Y].constraint.range = &(s->hw->info.y_range);
+ s->val[OPT_BR_Y].w = s->hw->info.y_range.max;
+
+ DBG (DBG_info, "INIT_OPTIONS: ul(x,y) = (%d,%d) br(x,y) = (%d,%d)\n",
+ (unsigned) SANE_UNFIX (s->val[OPT_TL_X].w),
+ (unsigned) SANE_UNFIX (s->val[OPT_TL_Y].w),
+ (unsigned) SANE_UNFIX (s->val[OPT_BR_X].w),
+ (unsigned) SANE_UNFIX (s->val[OPT_BR_Y].w));
+ /* Autoborder */
+ /* Rotation */
+ /* Deskew */
+
+
+
+ /*
+ * "Feeder" GROUP:
+ */
+ s->opt[OPT_FEEDER_GROUP].name = "";
+ s->opt[OPT_FEEDER_GROUP].title = SANE_TITLE_FEEDER_GROUP;
+ s->opt[OPT_FEEDER_GROUP].desc = "";
+ s->opt[OPT_FEEDER_GROUP].type = SANE_TYPE_GROUP;
+ s->opt[OPT_FEEDER_GROUP].cap = SANE_CAP_ADVANCED;
+ s->opt[OPT_FEEDER_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+ /* Scan Source */
+ s->opt[OPT_SCAN_SOURCE].name = SANE_NAME_SCAN_SOURCE;
+ s->opt[OPT_SCAN_SOURCE].title = SANE_TITLE_SCAN_SOURCE;
+ s->opt[OPT_SCAN_SOURCE].desc = SANE_DESC_SCAN_SOURCE;
+ s->opt[OPT_SCAN_SOURCE].type = SANE_TYPE_STRING;
+ s->opt[OPT_SCAN_SOURCE].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_SCAN_SOURCE].size = max_string_size (scan_source_list);
+ s->opt[OPT_SCAN_SOURCE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_SCAN_SOURCE].constraint.string_list =
+ (SANE_String_Const *) & scan_source_list[0];
+ s->val[OPT_SCAN_SOURCE].s = strdup (scan_source_list[0]);
+ if (!s->hw->info.hasADF)
+ s->opt[OPT_SCAN_SOURCE].cap |= SANE_CAP_INACTIVE;
+
+ /* Duplex: */
+ s->opt[OPT_DUPLEX].name = SANE_NAME_DUPLEX;
+ s->opt[OPT_DUPLEX].title = SANE_TITLE_DUPLEX;
+ s->opt[OPT_DUPLEX].desc = SANE_DESC_DUPLEX;
+ s->opt[OPT_DUPLEX].type = SANE_TYPE_BOOL;
+ s->opt[OPT_DUPLEX].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_DUPLEX].constraint_type = SANE_CONSTRAINT_NONE;
+ s->val[OPT_DUPLEX].w = s->hw->info.default_duplex;
+ if (!s->hw->info.hasDuplex)
+ s->opt[OPT_DUPLEX].cap |= SANE_CAP_INACTIVE;
+
+ /* Prefeed: */
+ s->opt[OPT_PREFEED].name = SANE_NAME_PREFEED;
+ s->opt[OPT_PREFEED].title = SANE_TITLE_PREFEED;
+ s->opt[OPT_PREFEED].desc = SANE_DESC_PREFEED;
+ s->opt[OPT_PREFEED].type = SANE_TYPE_BOOL;
+ s->opt[OPT_PREFEED].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_PREFEED].constraint_type = SANE_CONSTRAINT_NONE;
+ s->val[OPT_PREFEED].w = SANE_FALSE;
+ s->opt[OPT_PREFEED].cap |= SANE_CAP_INACTIVE;
+
+ /* Endorser: */
+ s->opt[OPT_ENDORSER].name = SANE_NAME_ENDORSER;
+ s->opt[OPT_ENDORSER].title = SANE_TITLE_ENDORSER;
+ s->opt[OPT_ENDORSER].desc = SANE_DESC_ENDORSER;
+ s->opt[OPT_ENDORSER].type = SANE_TYPE_BOOL;
+ s->opt[OPT_ENDORSER].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_ENDORSER].constraint_type = SANE_CONSTRAINT_NONE;
+ s->val[OPT_ENDORSER].w = s->hw->info.endorser_control;
+ if (!s->hw->info.hasEndorser)
+ s->opt[OPT_ENDORSER].cap |= SANE_CAP_INACTIVE;
+
+ /* Endorser String: */
+ s->opt[OPT_ENDORSER_STRING].name = SANE_NAME_ENDORSER_STRING;
+ s->opt[OPT_ENDORSER_STRING].title = SANE_TITLE_ENDORSER_STRING;
+ s->opt[OPT_ENDORSER_STRING].desc = SANE_DESC_ENDORSER_STRING;
+ s->opt[OPT_ENDORSER_STRING].type = SANE_TYPE_STRING;
+ s->opt[OPT_ENDORSER_STRING].cap =
+ SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_ENDORSER_STRING].size = sizeof (s->hw->info.endorser_string);
+ s->opt[OPT_ENDORSER_STRING].constraint_type = SANE_CONSTRAINT_NONE;
+ s->val[OPT_ENDORSER_STRING].s = strdup (s->hw->info.endorser_string);
+ if (!s->hw->info.hasEndorser)
+ s->opt[OPT_ENDORSER_STRING].cap |= SANE_CAP_INACTIVE;
+
+ /* Batch */
+ /* Check ADF */
+ /* timeout ADF */
+ /* timeout Manual */
+
+ /*
+ * "Enhancement" GROUP:
+ */
+ s->opt[OPT_ENHANCEMENT_GROUP].name = "";
+ s->opt[OPT_ENHANCEMENT_GROUP].title = SANE_TITLE_ENHANCEMENT_GROUP;
+ s->opt[OPT_ENHANCEMENT_GROUP].desc = "";
+ s->opt[OPT_ENHANCEMENT_GROUP].type = SANE_TYPE_GROUP;
+ s->opt[OPT_ENHANCEMENT_GROUP].cap = SANE_CAP_ADVANCED;
+ s->opt[OPT_ENHANCEMENT_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+ /* Halftone Type */
+ s->opt[OPT_HALFTONE_CODE].name = SANE_NAME_HALFTONE_CODE;
+ s->opt[OPT_HALFTONE_CODE].title = SANE_TITLE_HALFTONE_CODE;
+ s->opt[OPT_HALFTONE_CODE].desc = SANE_DESC_HALFTONE_CODE;
+ s->opt[OPT_HALFTONE_CODE].type = SANE_TYPE_STRING;
+ s->opt[OPT_HALFTONE_CODE].size = max_string_size (halftone_code);
+ s->opt[OPT_HALFTONE_CODE].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_HALFTONE_CODE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_HALFTONE_CODE].constraint.string_list =
+ (SANE_String_Const *) & halftone_code[0];
+ s->val[OPT_HALFTONE_CODE].s = strdup (halftone_code[0]);
+ if (s->image_composition == LINEART)
+ s->opt[OPT_HALFTONE_CODE].cap |= SANE_CAP_INACTIVE;
+
+ /* Halftone patterns */
+ s->opt[OPT_HALFTONE_PATTERN].name = SANE_NAME_HALFTONE_PATTERN;
+ s->opt[OPT_HALFTONE_PATTERN].title = SANE_TITLE_HALFTONE_PATTERN;
+ s->opt[OPT_HALFTONE_PATTERN].desc = SANE_DESC_HALFTONE_PATTERN;
+ s->opt[OPT_HALFTONE_PATTERN].type = SANE_TYPE_STRING;
+ s->opt[OPT_HALFTONE_PATTERN].size =
+ max_string_size ((SANE_String_Const *) halftone_pattern_list);
+ s->opt[OPT_HALFTONE_PATTERN].cap =
+ SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_HALFTONE_PATTERN].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_HALFTONE_PATTERN].constraint.string_list =
+ (SANE_String_Const *) & halftone_pattern_list[0];
+ s->val[OPT_HALFTONE_PATTERN].s = strdup (halftone_pattern_list[0]);
+ if (s->image_composition == LINEART)
+ s->opt[OPT_HALFTONE_CODE].cap |= SANE_CAP_INACTIVE;
+
+ /* Gray Filter */
+ s->opt[OPT_GRAYFILTER].name = SANE_NAME_GRAYFILTER;
+ s->opt[OPT_GRAYFILTER].title = SANE_TITLE_GRAYFILTER;
+ s->opt[OPT_GRAYFILTER].desc = SANE_DESC_GRAYFILTER;
+ s->opt[OPT_GRAYFILTER].type = SANE_TYPE_STRING;
+ s->opt[OPT_GRAYFILTER].size = max_string_size (grayfilter_list);
+ s->opt[OPT_GRAYFILTER].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_GRAYFILTER].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_GRAYFILTER].constraint.string_list =
+ (SANE_String_Const *) & grayfilter_list[0];
+ s->val[OPT_GRAYFILTER].s = strdup (grayfilter_list[0]);
+
+ /* Scan Wait Mode */
+ s->opt[OPT_SCAN_WAIT_MODE].name = SANE_NAME_SCAN_WAIT_MODE;
+ s->opt[OPT_SCAN_WAIT_MODE].title = SANE_TITLE_SCAN_WAIT_MODE;
+ s->opt[OPT_SCAN_WAIT_MODE].desc = SANE_DESC_SCAN_WAIT_MODE;
+ s->opt[OPT_SCAN_WAIT_MODE].type = SANE_TYPE_BOOL;
+ s->opt[OPT_SCAN_WAIT_MODE].unit = SANE_UNIT_NONE;
+ s->val[OPT_SCAN_WAIT_MODE].w =
+ (s->hw->info.scan_wait_mode) ? SANE_TRUE : SANE_FALSE;
+
+ /* Brightness */
+ s->opt[OPT_BRIGHTNESS].name = SANE_NAME_BRIGHTNESS;
+ s->opt[OPT_BRIGHTNESS].title = SANE_TITLE_BRIGHTNESS;
+ s->opt[OPT_BRIGHTNESS].desc = SANE_DESC_BRIGHTNESS;
+ s->opt[OPT_BRIGHTNESS].type = SANE_TYPE_INT;
+ s->opt[OPT_BRIGHTNESS].unit = SANE_UNIT_NONE;
+ s->opt[OPT_BRIGHTNESS].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_BRIGHTNESS].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_BRIGHTNESS].constraint.range = &s->hw->info.brightness_range;
+ s->val[OPT_BRIGHTNESS].w = 128;
+
+ /* 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->hw->info.threshold_range;
+ s->val[OPT_THRESHOLD].w = 128;
+
+ /* Contrast */
+ s->opt[OPT_CONTRAST].name = SANE_NAME_CONTRAST;
+ s->opt[OPT_CONTRAST].title = SANE_TITLE_CONTRAST;
+ s->opt[OPT_CONTRAST].desc = SANE_DESC_CONTRAST;
+ s->opt[OPT_CONTRAST].type = SANE_TYPE_INT;
+ s->opt[OPT_CONTRAST].unit = SANE_UNIT_NONE;
+ s->opt[OPT_CONTRAST].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_CONTRAST].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_CONTRAST].constraint.range = &s->hw->info.contrast_range;
+ s->val[OPT_CONTRAST].w = 128;
+
+ /* Gamma */
+ s->opt[OPT_GAMMA].name = SANE_NAME_GAMMA;
+ s->opt[OPT_GAMMA].title = SANE_TITLE_GAMMA;
+ s->opt[OPT_GAMMA].desc = SANE_DESC_GAMMA;
+ s->opt[OPT_GAMMA].type = SANE_TYPE_STRING;
+ s->opt[OPT_GAMMA].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_GAMMA].size = max_string_size ((SANE_String_Const *) gamma_list);
+ /*
+ s->opt[OPT_GAMMA].type = SANE_TYPE_INT;
+ s->opt[OPT_GAMMA].unit = SANE_UNIT_NONE;
+ s->opt[OPT_GAMMA].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_GAMMA].constraint.range = &u8_range;
+ s->val[OPT_GAMMA].w = 0;
+ */
+ s->opt[OPT_GAMMA].type = SANE_TYPE_STRING;
+ s->opt[OPT_GAMMA].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_GAMMA].constraint.string_list =
+ (SANE_String_Const *) & gamma_list[0];
+ s->val[OPT_GAMMA].s = strdup (gamma_list[0]);
+
+ /* 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->opt[OPT_CUSTOM_GAMMA].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->val[OPT_CUSTOM_GAMMA].w = SANE_FALSE;
+ s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
+
+ /* grayscale gamma vector */
+ s->opt[OPT_GAMMA_VECTOR_GRAY].name = SANE_NAME_GAMMA_VECTOR;
+ s->opt[OPT_GAMMA_VECTOR_GRAY].title = SANE_TITLE_GAMMA_VECTOR;
+ s->opt[OPT_GAMMA_VECTOR_GRAY].desc = SANE_DESC_GAMMA_VECTOR;
+ s->opt[OPT_GAMMA_VECTOR_GRAY].type = SANE_TYPE_INT;
+ s->opt[OPT_GAMMA_VECTOR_GRAY].cap |=
+ SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_GAMMA_VECTOR_GRAY].unit = SANE_UNIT_NONE;
+ s->opt[OPT_GAMMA_VECTOR_GRAY].size = GAMMA_LENGTH * sizeof (SANE_Word);
+ s->opt[OPT_GAMMA_VECTOR_GRAY].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_GAMMA_VECTOR_GRAY].constraint.range = &u8_range;
+ s->val[OPT_GAMMA_VECTOR_GRAY].wa = s->gamma_table;
+ s->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE;
+
+
+ /* Control Panel */
+ /* ACE Function */
+ /* ACE Sensitivity */
+
+ /* Binary Smoothing Filter */
+ s->opt[OPT_SMOOTHING].name = SANE_NAME_SMOOTHING;
+ s->opt[OPT_SMOOTHING].title = SANE_TITLE_SMOOTHING;
+ s->opt[OPT_SMOOTHING].desc = SANE_DESC_SMOOTHING;
+ s->opt[OPT_SMOOTHING].type = SANE_TYPE_BOOL;
+ s->opt[OPT_SMOOTHING].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_SMOOTHING].constraint_type = SANE_CONSTRAINT_NONE;
+ s->val[OPT_SMOOTHING].w = SANE_FALSE;
+ if (!s->hw->info.hasIPU)
+ s->opt[OPT_SMOOTHING].cap |= SANE_CAP_INACTIVE;
+
+ /* Binary Noise Removal Filter */
+ s->opt[OPT_NOISEREMOVAL].name = SANE_NAME_NOISEREMOVAL;
+ s->opt[OPT_NOISEREMOVAL].title = SANE_TITLE_NOISEREMOVAL;
+ s->opt[OPT_NOISEREMOVAL].desc = SANE_DESC_NOISEREMOVAL;
+ s->opt[OPT_NOISEREMOVAL].type = SANE_TYPE_STRING;
+ s->opt[OPT_NOISEREMOVAL].size = max_string_size (noisematrix_list);
+ s->opt[OPT_NOISEREMOVAL].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_NOISEREMOVAL].constraint.string_list =
+ (SANE_String_Const *) & noisematrix_list[0];
+ s->val[OPT_NOISEREMOVAL].s = strdup (noisematrix_list[0]);
+ if (!s->hw->info.hasIPU)
+ s->opt[OPT_NOISEREMOVAL].cap |= SANE_CAP_INACTIVE;
+
+ /* Automatic Separation */
+ s->opt[OPT_AUTOSEP].name = SANE_NAME_AUTOSEP;
+ s->opt[OPT_AUTOSEP].title = SANE_TITLE_AUTOSEP;
+ s->opt[OPT_AUTOSEP].desc = SANE_DESC_AUTOSEP;
+ s->opt[OPT_AUTOSEP].type = SANE_TYPE_STRING;
+ s->opt[OPT_AUTOSEP].size = max_string_size (auto_separation_list);
+ s->opt[OPT_AUTOSEP].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_AUTOSEP].constraint.string_list =
+ (SANE_String_Const *) & auto_separation_list[0];
+ s->val[OPT_AUTOSEP].s = strdup (auto_separation_list[0]);
+ if (!s->hw->info.hasIPU)
+ s->opt[OPT_AUTOSEP].cap |= SANE_CAP_INACTIVE;
+
+ /* Automatic Binarization */
+ s->opt[OPT_AUTOBIN].name = SANE_NAME_AUTOBIN;
+ s->opt[OPT_AUTOBIN].title = SANE_TITLE_AUTOBIN;
+ s->opt[OPT_AUTOBIN].desc = SANE_DESC_AUTOBIN;
+ s->opt[OPT_AUTOBIN].type = SANE_TYPE_STRING;
+ s->opt[OPT_AUTOBIN].size = max_string_size (auto_binarization_list);
+ s->opt[OPT_AUTOBIN].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_AUTOBIN].constraint.string_list =
+ (SANE_String_Const *) & auto_binarization_list[0];
+ s->val[OPT_AUTOBIN].s = strdup (auto_binarization_list[0]);
+ if (!s->hw->info.hasIPU)
+ s->opt[OPT_AUTOBIN].cap |= SANE_CAP_INACTIVE;
+
+ /* SECTION
+ * The IS450 supports up to 4 Section; The IS420 supports up to 6 Sections
+ * For each struct window_section[i] we need to fill in ulx,uly,width,height,etc
+ * NOT YET IMPLEMENTED
+ */
+
+ /* Negative */
+ s->opt[OPT_NEGATIVE].name = SANE_NAME_NEGATIVE;
+ s->opt[OPT_NEGATIVE].title = SANE_TITLE_NEGATIVE;
+ s->opt[OPT_NEGATIVE].desc = SANE_DESC_NEGATIVE;
+ s->opt[OPT_NEGATIVE].type = SANE_TYPE_BOOL;
+ s->opt[OPT_NEGATIVE].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_NEGATIVE].constraint_type = SANE_CONSTRAINT_NONE;
+ s->val[OPT_NEGATIVE].w = SANE_FALSE;
+
+ /* White Balance */
+ s->opt[OPT_WHITE_BALANCE].name = SANE_NAME_WHITE_BALANCE;
+ s->opt[OPT_WHITE_BALANCE].title = SANE_TITLE_WHITE_BALANCE;
+ s->opt[OPT_WHITE_BALANCE].desc = SANE_DESC_WHITE_BALANCE;
+ s->opt[OPT_WHITE_BALANCE].type = SANE_TYPE_BOOL;
+ s->opt[OPT_WHITE_BALANCE].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_WHITE_BALANCE].constraint_type = SANE_CONSTRAINT_NONE;
+ s->val[OPT_WHITE_BALANCE].w = SANE_FALSE; /* F/T = Relative/Absolute White */
+
+ /*
+ * "Miscellaneous" GROUP:
+ */
+ s->opt[OPT_MISCELLANEOUS_GROUP].name = "";
+ s->opt[OPT_MISCELLANEOUS_GROUP].title = SANE_TITLE_MISCELLANEOUS_GROUP;
+ s->opt[OPT_MISCELLANEOUS_GROUP].desc = "";
+ s->opt[OPT_MISCELLANEOUS_GROUP].type = SANE_TYPE_GROUP;
+ s->opt[OPT_MISCELLANEOUS_GROUP].cap = SANE_CAP_ADVANCED;
+ s->opt[OPT_MISCELLANEOUS_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+ /* Padding Type: */
+ s->opt[OPT_PADDING_TYPE].name = SANE_NAME_PADDING_TYPE;
+ s->opt[OPT_PADDING_TYPE].title = SANE_TITLE_PADDING_TYPE;
+ s->opt[OPT_PADDING_TYPE].desc = SANE_DESC_PADDING_TYPE;
+ s->opt[OPT_PADDING_TYPE].type = SANE_TYPE_STRING;
+ s->opt[OPT_PADDING_TYPE].cap = SANE_CAP_SOFT_DETECT; /* Display only */
+ s->opt[OPT_PADDING_TYPE].size = max_string_size (paddingtype_list);
+ /*
+ s->opt[OPT_PADDING_TYPE].size = sizeof((paddingtype_list[ get_paddingtype_strndx(TRUNCATE) ]));
+ s->opt[OPT_PADDING_TYPE].constraint_type = SANE_CONSTRAINT_NONE;
+ */
+ s->opt[OPT_PADDING_TYPE].constraint_type = SANE_CONSTRAINT_STRING_LIST;
+ s->opt[OPT_PADDING_TYPE].constraint.string_list =
+ (SANE_String_Const *) & paddingtype_list[0];
+ s->val[OPT_PADDING_TYPE].s =
+ strdup (paddingtype_list[get_paddingtype_strndx (TRUNCATE)]);
+ DBG (DBG_info, "PADDINGTYPE =%s size=%d\n", s->val[OPT_PADDING_TYPE].s,
+ s->opt[OPT_PADDING_TYPE].size);
+
+ /* Bit Order
+ s->opt[OPT_BITORDER].name = SANE_NAME_BITORDER;
+ s->opt[OPT_BITORDER].title = SANE_TITLE_BITORDER;
+ s->opt[OPT_BITORDER].desc = SANE_DESC_BITORDER;
+ s->opt[OPT_BITORDER].type = SANE_TYPE_WORD;
+ s->opt[OPT_BITORDER].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_BITORDER].constraint_type = SANE_CONSTRAINT_NONE
+ s->val[OPT_BITORDER].w = 0x7;
+ */
+
+ /* Self Diagnostics */
+ s->opt[OPT_SELF_DIAGNOSTICS].name = SANE_NAME_SELF_DIAGNOSTICS;
+ s->opt[OPT_SELF_DIAGNOSTICS].title = SANE_TITLE_SELF_DIAGNOSTICS;
+ s->opt[OPT_SELF_DIAGNOSTICS].desc = SANE_DESC_SELF_DIAGNOSTICS;
+ s->opt[OPT_SELF_DIAGNOSTICS].type = SANE_TYPE_BUTTON;
+
+ /* Optical Diagnostics */
+ s->opt[OPT_OPTICAL_ADJUSTMENT].name = SANE_NAME_OPTICAL_ADJUSTMENT;
+ s->opt[OPT_OPTICAL_ADJUSTMENT].title = SANE_TITLE_OPTICAL_ADJUSTMENT;
+ s->opt[OPT_OPTICAL_ADJUSTMENT].desc = SANE_DESC_OPTICAL_ADJUSTMENT;
+ s->opt[OPT_OPTICAL_ADJUSTMENT].type = SANE_TYPE_BUTTON;
+
+ /* MAINTENANCE DATA */
+ s->opt[OPT_DATA_GROUP].name = "";
+ s->opt[OPT_DATA_GROUP].title = "Maintenance Data";
+ s->opt[OPT_DATA_GROUP].desc = "";
+ s->opt[OPT_DATA_GROUP].type = SANE_TYPE_GROUP;
+ s->opt[OPT_DATA_GROUP].cap = SANE_CAP_ADVANCED;
+ s->opt[OPT_DATA_GROUP].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_UPDATE].name = "Update";
+ s->opt[OPT_UPDATE].title = "Update";
+ s->opt[OPT_UPDATE].desc = "Update scanner data";
+ s->opt[OPT_UPDATE].type = SANE_TYPE_BUTTON;
+ s->opt[OPT_NREGX_ADF].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_NREGX_ADF].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_NREGX_ADF].name = "# registers in main-scanning in ADF mode";
+ s->opt[OPT_NREGX_ADF].title = "# registers in main-scanning in ADF mode";
+ s->opt[OPT_NREGX_ADF].desc = "# registers in main-scanning in ADF mode";
+ s->opt[OPT_NREGX_ADF].type = SANE_TYPE_INT;
+ s->opt[OPT_NREGX_ADF].unit = SANE_UNIT_NONE;
+ s->opt[OPT_NREGX_ADF].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_NREGX_ADF].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_NREGY_ADF].name = "# registers in sub-scanning in ADF mode";
+ s->opt[OPT_NREGY_ADF].title = "# registers in sub-scanning in ADF mode";
+ s->opt[OPT_NREGY_ADF].desc = "# registers in sub-scanning in ADF mode";
+ s->opt[OPT_NREGY_ADF].type = SANE_TYPE_INT;
+ s->opt[OPT_NREGY_ADF].unit = SANE_UNIT_NONE;
+ s->opt[OPT_NREGY_ADF].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_NREGY_ADF].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_NREGX_BOOK].name = "# registers in main-scanning in book mode";
+ s->opt[OPT_NREGX_BOOK].title = "# registers in main-scanning in book mode";
+ s->opt[OPT_NREGX_BOOK].desc = "# registers in main-scanning in book mode";
+ s->opt[OPT_NREGX_BOOK].type = SANE_TYPE_INT;
+ s->opt[OPT_NREGX_BOOK].unit = SANE_UNIT_NONE;
+ s->opt[OPT_NREGX_BOOK].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_NREGX_BOOK].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_NREGY_BOOK].name = "# registers in sub-scanning in book mode";
+ s->opt[OPT_NREGY_BOOK].title = "# registers in sub-scanning in book mode";
+ s->opt[OPT_NREGY_BOOK].desc = "# registers in sub-scanning in book mode";
+ s->opt[OPT_NREGY_BOOK].type = SANE_TYPE_INT;
+ s->opt[OPT_NREGY_BOOK].unit = SANE_UNIT_NONE;
+ s->opt[OPT_NREGY_BOOK].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_NREGY_BOOK].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_NSCANS_ADF].name = "# ADF Scans";
+ s->opt[OPT_NSCANS_ADF].title = "# ADF Scans";
+ s->opt[OPT_NSCANS_ADF].desc = "# ADF Scans";
+ s->opt[OPT_NSCANS_ADF].type = SANE_TYPE_INT;
+ s->opt[OPT_NSCANS_ADF].unit = SANE_UNIT_NONE;
+ s->opt[OPT_NSCANS_ADF].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_NSCANS_ADF].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_NSCANS_BOOK].name = "# BOOK Scans";
+ s->opt[OPT_NSCANS_BOOK].title = "# BOOK Scans";
+ s->opt[OPT_NSCANS_BOOK].desc = "# BOOK Scans";
+ s->opt[OPT_NSCANS_BOOK].type = SANE_TYPE_INT;
+ s->opt[OPT_NSCANS_BOOK].unit = SANE_UNIT_NONE;
+ s->opt[OPT_NSCANS_BOOK].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_NSCANS_BOOK].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_LAMP_TIME].name = "LAMP TIME";
+ s->opt[OPT_LAMP_TIME].title = "LAMP TIME";
+ s->opt[OPT_LAMP_TIME].desc = "LAMP TIME";
+ s->opt[OPT_LAMP_TIME].type = SANE_TYPE_INT;
+ s->opt[OPT_LAMP_TIME].unit = SANE_UNIT_NONE;
+ s->opt[OPT_LAMP_TIME].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_LAMP_TIME].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_EO_ODD].name = "E/O Balance ODD";
+ s->opt[OPT_EO_ODD].title = "E/O Balance ODD";
+ s->opt[OPT_EO_ODD].desc = "Adj. of E/O Balance in black level ODD";
+ s->opt[OPT_EO_ODD].type = SANE_TYPE_INT;
+ s->opt[OPT_EO_ODD].unit = SANE_UNIT_NONE;
+ s->opt[OPT_EO_ODD].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_EO_ODD].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_EO_EVEN].name = "E/O Balance EVEN";
+ s->opt[OPT_EO_EVEN].title = "E/O Balance EVEN";
+ s->opt[OPT_EO_EVEN].desc = "Adj. of E/O Balance in black level EVEN";
+ s->opt[OPT_EO_EVEN].type = SANE_TYPE_INT;
+ s->opt[OPT_EO_EVEN].unit = SANE_UNIT_NONE;
+ s->opt[OPT_EO_EVEN].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_EO_EVEN].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_BLACK_LEVEL_ODD].name = "Black Level ODD";
+ s->opt[OPT_BLACK_LEVEL_ODD].title = "Black Level ODD";
+ s->opt[OPT_BLACK_LEVEL_ODD].desc = "Adj. data in black level (ODD)";
+ s->opt[OPT_BLACK_LEVEL_ODD].type = SANE_TYPE_INT;
+ s->opt[OPT_BLACK_LEVEL_ODD].unit = SANE_UNIT_NONE;
+ s->opt[OPT_BLACK_LEVEL_ODD].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_BLACK_LEVEL_ODD].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_BLACK_LEVEL_EVEN].name = "Black Level EVEN";
+ s->opt[OPT_BLACK_LEVEL_EVEN].title = "Black Level EVEN";
+ s->opt[OPT_BLACK_LEVEL_EVEN].desc = "Adj. data in black level (EVEN)";
+ s->opt[OPT_BLACK_LEVEL_EVEN].type = SANE_TYPE_INT;
+ s->opt[OPT_BLACK_LEVEL_EVEN].unit = SANE_UNIT_NONE;
+ s->opt[OPT_BLACK_LEVEL_EVEN].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_BLACK_LEVEL_EVEN].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_WHITE_LEVEL_ODD].name = "White Level ODD";
+ s->opt[OPT_WHITE_LEVEL_ODD].title = "White Level ODD";
+ s->opt[OPT_WHITE_LEVEL_ODD].desc = "Adj. data in White level (ODD)";
+ s->opt[OPT_WHITE_LEVEL_ODD].type = SANE_TYPE_INT;
+ s->opt[OPT_WHITE_LEVEL_ODD].unit = SANE_UNIT_NONE;
+ s->opt[OPT_WHITE_LEVEL_ODD].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_WHITE_LEVEL_ODD].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_WHITE_LEVEL_EVEN].name = "White Level EVEN";
+ s->opt[OPT_WHITE_LEVEL_EVEN].title = "White Level EVEN";
+ s->opt[OPT_WHITE_LEVEL_EVEN].desc = "Adj. data in White level (EVEN)";
+ s->opt[OPT_WHITE_LEVEL_EVEN].type = SANE_TYPE_INT;
+ s->opt[OPT_WHITE_LEVEL_EVEN].unit = SANE_UNIT_NONE;
+ s->opt[OPT_WHITE_LEVEL_EVEN].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_WHITE_LEVEL_EVEN].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_WHITE_LEVEL_EVEN].name = "White Level EVEN";
+ s->opt[OPT_WHITE_LEVEL_EVEN].title = "White Level EVEN";
+ s->opt[OPT_WHITE_LEVEL_EVEN].desc = "Adj. data in White level (EVEN)";
+ s->opt[OPT_WHITE_LEVEL_EVEN].type = SANE_TYPE_INT;
+ s->opt[OPT_WHITE_LEVEL_EVEN].unit = SANE_UNIT_NONE;
+ s->opt[OPT_WHITE_LEVEL_EVEN].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_WHITE_LEVEL_EVEN].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_DENSITY].name = "Density Adjustment";
+ s->opt[OPT_DENSITY].title = "Density Adjustment";
+ s->opt[OPT_DENSITY].desc = "Density adjustment of std. white board";
+ s->opt[OPT_DENSITY].type = SANE_TYPE_INT;
+ s->opt[OPT_DENSITY].unit = SANE_UNIT_NONE;
+ s->opt[OPT_DENSITY].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_DENSITY].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_FIRST_ADJ_WHITE_ODD].name = "1st adj. in white level (ODD)";
+ s->opt[OPT_FIRST_ADJ_WHITE_ODD].title = "1st adj. in white level (ODD)";
+ s->opt[OPT_FIRST_ADJ_WHITE_ODD].desc = "1st adj. in white level (ODD)";
+ s->opt[OPT_FIRST_ADJ_WHITE_ODD].type = SANE_TYPE_INT;
+ s->opt[OPT_FIRST_ADJ_WHITE_ODD].unit = SANE_UNIT_NONE;
+ s->opt[OPT_FIRST_ADJ_WHITE_ODD].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_FIRST_ADJ_WHITE_ODD].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_FIRST_ADJ_WHITE_EVEN].name = "1st adj. in white level (EVEN)";
+ s->opt[OPT_FIRST_ADJ_WHITE_EVEN].title = "1st adj. in white level (EVEN)";
+ s->opt[OPT_FIRST_ADJ_WHITE_EVEN].desc = "1st adj. in white level (EVEN)";
+ s->opt[OPT_FIRST_ADJ_WHITE_EVEN].type = SANE_TYPE_INT;
+ s->opt[OPT_FIRST_ADJ_WHITE_EVEN].unit = SANE_UNIT_NONE;
+ s->opt[OPT_FIRST_ADJ_WHITE_EVEN].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_FIRST_ADJ_WHITE_EVEN].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_NREGX_REVERSE].name = "# registers of main-scanning of backside";
+ s->opt[OPT_NREGX_REVERSE].title =
+ "# registers of main-scanning of backside";
+ s->opt[OPT_NREGX_REVERSE].desc =
+ "# registers of main-scanning of ADF backside";
+ s->opt[OPT_NREGX_REVERSE].type = SANE_TYPE_INT;
+ s->opt[OPT_NREGX_REVERSE].unit = SANE_UNIT_NONE;
+ s->opt[OPT_NREGX_REVERSE].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_NREGX_REVERSE].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_NREGY_REVERSE].name = "# registers of sub-scanning of backside";
+ s->opt[OPT_NREGY_REVERSE].title = "# registers of sub-scanning of backside";
+ s->opt[OPT_NREGY_REVERSE].desc =
+ "# registers of sub-scanning of ADF backside";
+ s->opt[OPT_NREGY_REVERSE].type = SANE_TYPE_INT;
+ s->opt[OPT_NREGY_REVERSE].unit = SANE_UNIT_NONE;
+ s->opt[OPT_NREGY_REVERSE].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_NREGY_REVERSE].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_NSCANS_REVERSE_ADF].name = "# of scans of reverse side in ADF";
+ s->opt[OPT_NSCANS_REVERSE_ADF].title = "# of scans of reverse side in ADF";
+ s->opt[OPT_NSCANS_REVERSE_ADF].desc = "# of scans of reverse side in ADF";
+ s->opt[OPT_NSCANS_REVERSE_ADF].type = SANE_TYPE_INT;
+ s->opt[OPT_NSCANS_REVERSE_ADF].unit = SANE_UNIT_NONE;
+ s->opt[OPT_NSCANS_REVERSE_ADF].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_NSCANS_REVERSE_ADF].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_REVERSE_TIME].name = "LAMP TIME (reverse)";
+ s->opt[OPT_REVERSE_TIME].title = "LAMP TIME (reverse)";
+ s->opt[OPT_REVERSE_TIME].desc = "LAMP TIME (reverse)";
+ s->opt[OPT_REVERSE_TIME].type = SANE_TYPE_INT;
+ s->opt[OPT_REVERSE_TIME].unit = SANE_UNIT_NONE;
+ s->opt[OPT_REVERSE_TIME].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_REVERSE_TIME].constraint_type = SANE_CONSTRAINT_NONE;
+
+ s->opt[OPT_NCHARS].name = "# of endorser characters";
+ s->opt[OPT_NCHARS].title = "# of endorser characters";
+ s->opt[OPT_NCHARS].desc = "# of endorser characters";
+ s->opt[OPT_NCHARS].type = SANE_TYPE_INT;
+ s->opt[OPT_NCHARS].unit = SANE_UNIT_NONE;
+ s->opt[OPT_NCHARS].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_NCHARS].constraint_type = SANE_CONSTRAINT_NONE;
+
+ DBG (DBG_proc, "<< init_options\n");
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+attach (SANE_String_Const devname, int __sane_unused__ connType,
+ HS2P_Device ** devp)
+{
+ SANE_Status status;
+ HS2P_Device *dev;
+ struct inquiry_standard_data ibuf;
+ struct inquiry_vpd_data vbuf;
+ struct inquiry_jis_data jbuf;
+ size_t buf_size;
+ int fd = -1;
+ double mm;
+
+ char device_string[60];
+
+ unsigned int i;
+ SANE_String *str;
+
+
+ DBG (DBG_sane_proc, ">>> attach:\n");
+
+ for (dev = first_dev; dev; dev = dev->next)
+ {
+ if (strcmp (dev->sane.name, devname) == 0)
+ {
+ if (devp)
+ *devp = dev;
+ return SANE_STATUS_GOOD;
+ }
+ }
+ DBG (DBG_sane_proc, ">>> attach: opening \"%s\"\n", devname);
+
+ /* sanei_scsi_open takes an option bufsize argument */
+ status = sanei_scsi_open (devname, &fd, &sense_handler, &(dev->sense_data));
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, ">>> attach: open failed: %s\n",
+ sane_strstatus (status));
+ return (status);
+ }
+
+ DBG (DBG_sane_proc, ">>> attach: opened %s fd=%d\n", devname, fd);
+
+ DBG (DBG_sane_proc, ">>> attach: sending INQUIRY (standard data)\n");
+ memset (&ibuf, 0, sizeof (ibuf));
+ buf_size = sizeof (ibuf);
+ status = inquiry (fd, &ibuf, &buf_size, 0, HS2P_INQUIRY_STANDARD_PAGE_CODE);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, ">>> attach: inquiry failed: %s\n",
+ sane_strstatus (status));
+ sanei_scsi_close (fd);
+ return (status);
+ }
+
+ DBG (DBG_info,
+ ">>> attach: reported devtype='%d', vendor='%.8s', product='%.16s', revision='%.4s'\n",
+ ibuf.devtype, ibuf.vendor, ibuf.product, ibuf.revision);
+ DBG (DBG_info,
+ ">>> attach: reported RMB=%#x Ver=%#x ResponseDataFormat=%#x Length=%#x Byte7=%#x\n",
+ ibuf.rmb_evpd, ibuf.version, ibuf.response_data_format, ibuf.length,
+ ibuf.byte7);
+
+ if (ibuf.devtype != 6 || strncmp ((char *) ibuf.vendor, "RICOH ", 8) != 0)
+ {
+ DBG (DBG_warning, ">>> attach: device is not a RICOH scanner\n");
+ sanei_scsi_close (fd);
+ return SANE_STATUS_INVAL;
+ }
+ else if (!is_device_supported ((char *) ibuf.product))
+ {
+ DBG (DBG_warning,
+ ">>> attach: device %s is not yet a supported RICOH scanner\n",
+ ibuf.product);
+ sanei_scsi_close (fd);
+ return SANE_STATUS_INVAL;
+ }
+
+ /* We should now have an open file descriptor to a supported hs2p scanner */
+ DBG (DBG_sane_proc, ">>> attach: sending TEST_UNIT_READY\n");
+ do
+ {
+ status = test_unit_ready (fd);
+ }
+ while (status == HS2P_SK_UNIT_ATTENTION);
+ if (status != HS2P_SCSI_STATUS_GOOD)
+ {
+ DBG (DBG_error, ">>> attach: test unit ready failed (%s)\n",
+ sane_strstatus (status));
+ sanei_scsi_close (fd);
+ return (status);
+ }
+
+ DBG (DBG_sane_proc, ">>> attach: sending INQUIRY (vpd data)\n");
+ memset (&vbuf, 0, sizeof (vbuf));
+ buf_size = sizeof (vbuf);
+ status = inquiry (fd, &vbuf, &buf_size, 1, HS2P_INQUIRY_VPD_PAGE_CODE);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, ">>> attach: inquiry (vpd data) failed: %s\n",
+ sane_strstatus (status));
+ sanei_scsi_close (fd);
+ return status;
+ }
+ print_vpd_info (&vbuf);
+
+ DBG (DBG_sane_proc, ">>> attach: sending INQUIRY (jis data)\n");
+ memset (&jbuf, 0, sizeof (jbuf));
+ buf_size = sizeof (jbuf);
+ status = inquiry (fd, &jbuf, &buf_size, 1, HS2P_INQUIRY_JIS_PAGE_CODE);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, ">>> attach: inquiry (jis data) failed: %s\n",
+ sane_strstatus (status));
+ sanei_scsi_close (fd);
+ return status;
+ }
+ print_jis_info (&jbuf);
+
+
+ /* Fill in HS2P_Device {sane;info} */
+ dev = malloc (sizeof (*dev));
+ if (!dev)
+ return SANE_STATUS_NO_MEM;
+ memset (dev, 0, sizeof (*dev));
+
+ /* Maximum Number of Sub-Sections of Main Scanning Window */
+ if (strncmp ((char *) ibuf.product, "IS450", 5) == 0)
+ {
+ dev->info.max_win_sections = 4;
+ }
+ else if (strncmp ((char *) ibuf.product, "IS420", 5) == 0)
+ {
+ dev->info.max_win_sections = 6;
+ }
+
+ /* Some MODE SELECT scanner options */
+ DBG (DBG_proc, ">>> attach: get_basic_measurement_unit\n");
+ status =
+ get_basic_measurement_unit (fd, &(dev->info.bmu), &(dev->info.mud));
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, ">>> attach: get_basic_measurement_unit failed (%s)\n",
+ sane_strstatus (status));
+ DBG (DBG_error, ">>> attach: setting to defaults\n");
+ status = set_basic_measurement_unit (fd, MILLIMETERS);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error,
+ ">>> attach: set_basic_measurement_unit failed (%s)\n",
+ sane_strstatus (status));
+ }
+ }
+ if ((status =
+ get_connection_parameters (fd, &(dev->info.cxn))) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, ">>> attach: get_connection_parameters failed\n");
+ }
+ status = get_endorser_control (fd, &dev->info.endorser_control);
+ if (status != SANE_STATUS_GOOD || dev->info.endorser_control != 0x01)
+ {
+ DBG (DBG_error,
+ ">>> attach: get_endorser_control failed: return value=%#02x\n",
+ dev->info.endorser_control);
+ dev->info.endorser_control = 0x00;
+ }
+ if ((dev->info.service_mode = get_service_mode (fd)) != 0x00
+ && dev->info.service_mode != 0x01)
+ {
+ DBG (DBG_error, ">>> attach: get_service_mode failed %#02x\n",
+ dev->info.service_mode);
+ dev->info.service_mode = 0x00;
+ }
+ if ((dev->info.scan_wait_mode = get_scan_wait_mode (fd)) != 0x00
+ && dev->info.scan_wait_mode != 0x01)
+ {
+ DBG (DBG_error,
+ ">>> attach: get_scan_wait_mode failed: return value=%#02x\n",
+ dev->info.scan_wait_mode);
+ dev->info.scan_wait_mode = 0x00;
+ }
+ status = get_white_balance (fd, &dev->info.white_balance);
+ if (status != SANE_STATUS_GOOD && dev->info.white_balance != 0x01)
+ {
+ DBG (DBG_error,
+ ">>> attach: get_white_balance failed: return value=%#02x\n",
+ dev->info.white_balance);
+ dev->info.white_balance = RELATIVE_WHITE;
+ }
+
+ DBG (DBG_info, ">>> attach: flushing and closing fd=%d\n", fd);
+ sanei_scsi_req_flush_all ();
+ sanei_scsi_close (fd);
+
+ dev->info.devtype = ibuf.devtype;
+ snprintf (dev->info.vendor, 9, "%-.5s", ibuf.vendor); /* RICOH */
+ trim_spaces (dev->info.vendor, sizeof (dev->info.vendor));
+ snprintf (dev->info.product, 16, "%-.16s", ibuf.product); /* IS450 */
+ trim_spaces (dev->info.product, sizeof (dev->info.product));
+ snprintf (dev->info.revision, 5, "%-.4s", ibuf.revision); /* 1R04 */
+ trim_spaces (dev->info.revision, sizeof (dev->info.revision));
+
+ /* SANE_Device sane information */
+ dev->sane.name = strdup (devname);
+ dev->sane.vendor =
+ (strcmp (dev->info.vendor, "RICOH") ==
+ 0) ? strdup ("Ricoh") : strdup (dev->info.vendor);
+ dev->sane.model = strdup (dev->info.product);
+ dev->sane.type = strdup ("sheetfed scanner");
+ /*
+ dev->sane.email_backend_author = strdup("<Jeremy Johnson> jeremy@acjlaw.net");
+ dev->sane.backend_website = strdup("http://www.acjlaw.net:8080/~jeremy/Ricoh");
+ */
+ /* read these values from backend configuration file using parse_configuration
+ dev->sane.location = strdup();
+ dev->sane.comment = strdup();
+ dev->sane.backend_version_code = strdup();
+ */
+ /* NOT YET USED */
+ /* dev->sane.backend_capablity_flags = 0x00; */
+
+ /* set capabilities from vpd */
+ /* adf_id: 0=none,1=simplex,2=duplex,3=ARDF,4=reserved; should be 1 or 2 for IS450 family */
+ dev->info.hasADF = vbuf.adf_id == 0 ? SANE_FALSE : SANE_TRUE;
+ dev->info.hasSimplex = vbuf.adf_id == 1 ? SANE_TRUE : SANE_FALSE;
+ dev->info.hasDuplex = vbuf.adf_id == 2 ? SANE_TRUE : SANE_FALSE;
+ dev->info.hasARDF = vbuf.adf_id == 3 ? SANE_TRUE : SANE_FALSE;
+
+ /* end_id 0=none,1=Yes,2=reserved; should always be 0 or 1 */
+ dev->info.hasEndorser = vbuf.end_id == 1 ? SANE_TRUE : SANE_FALSE;
+ for (i = 0; i < 20; i++)
+ dev->info.endorser_string[i] = '\0';
+
+ /* ipu_id: Bit0: '0'-no IPU, '1'-has IPU
+ * Bit1: '0'-no extended board, '1'-has extended board;
+ * should always be 0
+ */
+ dev->info.hasIPU = (vbuf.ipu_id & 0x01) == 0x01 ? SANE_TRUE : SANE_FALSE;
+ dev->info.hasXBD = (vbuf.ipu_id & 0x02) == 0x02 ? SANE_TRUE : SANE_FALSE;
+
+
+ /* Image Composition Byte is set to 0x37 (0011 0111) */
+ dev->info.supports_lineart = (vbuf.imagecomposition & 0x01) == 0x01 ? SANE_TRUE : SANE_FALSE; /* TRUE */
+ dev->info.supports_dithering = (vbuf.imagecomposition & 0x02) == 0x02 ? SANE_TRUE : SANE_FALSE; /* TRUE */
+ dev->info.supports_errordiffusion = (vbuf.imagecomposition & 0x04) == 0x04 ? SANE_TRUE : SANE_FALSE; /* TRUE */
+ dev->info.supports_color = (vbuf.imagecomposition & 0x08) == 0x08 ? SANE_TRUE : SANE_FALSE; /* FALSE */
+ dev->info.supports_4bitgray = (vbuf.imagecomposition & 0x10) == 0x10 ? SANE_TRUE : SANE_FALSE; /* TRUE */
+ dev->info.supports_8bitgray = (vbuf.imagecomposition & 0x20) == 0x20 ? SANE_TRUE : SANE_FALSE; /* TRUE */
+ /* vbuf.imagecomposition & 0x40; FALSE */
+ /* vbuf.imagecomposition & 0x80 FALSE reserved */
+ str = &scan_mode_list[0]; /* array of string pointers */
+ if (dev->info.supports_lineart)
+ *str++ = strdup (SM_LINEART);
+ if (dev->info.supports_dithering || dev->info.supports_errordiffusion)
+ *str++ = strdup (SM_HALFTONE);
+ if (dev->info.supports_color)
+ *str++ = strdup (SM_COLOR);
+ if (dev->info.supports_4bitgray)
+ *str++ = strdup (SM_4BITGRAY);
+ if (dev->info.supports_8bitgray)
+ *str++ = strdup (SM_8BITGRAY);
+ *str = NULL;
+
+ snprintf (device_string, 60, "Flatbed%s%s%s%s%s%s",
+ dev->info.hasADF ? "/ADF" : "",
+ dev->info.hasDuplex ? "/Duplex" : "",
+ dev->info.hasEndorser ? "/Endorser" : "",
+ dev->info.hasIPU ? "/IPU" : "",
+ dev->info.supports_color ? " Color" : " B&W", " Scanner");
+ dev->sane.type = strdup (device_string);
+
+ /* ACE Image Data Processing Binary Filters
+ * For IS450 this is set to 0x18 (0001 1000) if IPU installed, else 0x00
+ * For IS420 this is set to 0x3C (0011 1100) if IPU installed, else 0x00
+ */
+ dev->info.supports_whiteframing =
+ ((vbuf.imagedataprocessing[0] & 0x01) == 0x01) ? SANE_TRUE : SANE_FALSE;
+ dev->info.supports_blackframing =
+ ((vbuf.imagedataprocessing[0] & 0x02) == 0x02) ? SANE_TRUE : SANE_FALSE;
+ dev->info.supports_edgeextraction =
+ ((vbuf.imagedataprocessing[0] & 0x04) == 0x04) ? SANE_TRUE : SANE_FALSE;
+ dev->info.supports_noiseremoval =
+ ((vbuf.imagedataprocessing[0] & 0x08) == 0x08) ? SANE_TRUE : SANE_FALSE;
+ dev->info.supports_smoothing =
+ ((vbuf.imagedataprocessing[0] & 0x10) == 0x10) ? SANE_TRUE : SANE_FALSE;
+ dev->info.supports_linebolding =
+ ((vbuf.imagedataprocessing[0] & 0x20) == 0x20) ? SANE_TRUE : SANE_FALSE;
+
+ /* Compression Method is not supported for IS450
+ * is supported for IS420 */
+ dev->info.supports_MH =
+ ((vbuf.compression & 0x01) == 0x01) ? SANE_TRUE : SANE_FALSE;
+ dev->info.supports_MR =
+ ((vbuf.compression & 0x02) == 0x02) ? SANE_TRUE : SANE_FALSE;
+ dev->info.supports_MMR =
+ ((vbuf.compression & 0x04) == 0x04) ? SANE_TRUE : SANE_FALSE;
+ dev->info.supports_MHB = ((vbuf.compression & 0x08) == 0x08) ? SANE_TRUE : SANE_FALSE; /* MH Byte Boundary */
+
+ /* compression_list[] will have variable number of elements, but the order will be fixed as follows: */
+ str = &compression_list[0];
+ *str++ = strdup ("none");
+ if (dev->info.supports_MH)
+ *str++ = strdup ("G3 1-D MH");
+ if (dev->info.supports_MR)
+ *str++ = strdup ("G3 2-D MR");
+ if (dev->info.supports_MMR)
+ *str++ = strdup ("G4 2-D MMR");
+ if (dev->info.supports_MHB)
+ *str++ = strdup ("MH Byte Boundary");
+ *str = NULL;
+
+ /* Marker Recognition is set to 0x00 */
+ dev->info.supports_markerrecognition =
+ ((vbuf.markerrecognition & 0x01) == 0x01) ? SANE_TRUE : SANE_FALSE;
+
+ /* Size Recognition
+ * For IS450 this is set to 0x01 when IPU installed; else 0x00
+ * For IS420 this is set to 0x01
+ */
+ dev->info.supports_sizerecognition =
+ ((vbuf.sizerecognition & 0x01) == 0x01) ? SANE_TRUE : SANE_FALSE;
+
+ /* X Maximum Output Pixel in main scanning direction
+ * For IS450 this is set to 0x1360 (4960)
+ * For IS420 this is set to (4880)
+ * [MostSignificantByte LeastSignificantByte]
+ */
+ dev->info.xmaxoutputpixels =
+ (vbuf.xmaxoutputpixels[0] << 8) | vbuf.xmaxoutputpixels[1];
+
+ /* Set capabilities from jis VPD IDENTIFIER Page Code F0H */
+ dev->info.resBasicX = _2btol (&jbuf.BasicRes.x[0]); /* set to 400 */
+ dev->info.resBasicY = _2btol (&jbuf.BasicRes.y[0]); /* set to 400 */
+
+ dev->info.resXstep = (jbuf.resolutionstep >> 4) & 0x0F; /* set to 1 */
+ dev->info.resYstep = jbuf.resolutionstep & 0x0F; /* set to 1 */
+ dev->info.resMaxX = _2btol (&jbuf.MaxRes.x[0]); /* set to 800 */
+ dev->info.resMaxY = _2btol (&jbuf.MaxRes.y[0]); /* set to 800 */
+ dev->info.resMinX = _2btol (&jbuf.MinRes.x[0]); /* set to 100 for IS450 and 60 for IS420 */
+ dev->info.resMinY = _2btol (&jbuf.MinRes.y[0]); /* set to 100 for IS450 and 60 for IS420 */
+
+ dev->info.xres_range.min = _2btol (&jbuf.MinRes.x[0]); /* set to 100 for IS450 and 60 for IS420 */
+ dev->info.xres_range.max = _2btol (&jbuf.MaxRes.x[0]); /* set to 800 */
+ dev->info.resXstep = (jbuf.resolutionstep >> 4) & 0x0F; /* set to 1 */
+ dev->info.xres_range.quant = dev->info.resXstep;
+
+ dev->info.yres_range.min = _2btol (&jbuf.MinRes.y[0]); /* set to 100 for IS450 and 60 for IS420 */
+ dev->info.yres_range.max = _2btol (&jbuf.MaxRes.y[0]); /* set to 800 */
+ dev->info.resYstep = jbuf.resolutionstep & 0x0F; /* set to 1 */
+ dev->info.yres_range.quant = dev->info.resYstep;
+
+ /* set the length of the list to zero first, then append standard resolutions */
+ i = 0;
+ if ((jbuf.standardres[0] & 0x80) == 0x80)
+ dev->info.resStdList[++i] = 60;
+ if ((jbuf.standardres[0] & 0x40) == 0x40)
+ dev->info.resStdList[++i] = 75;
+ if ((jbuf.standardres[0] & 0x20) == 0x20)
+ dev->info.resStdList[++i] = 100;
+ if ((jbuf.standardres[0] & 0x10) == 0x10)
+ dev->info.resStdList[++i] = 120;
+ if ((jbuf.standardres[0] & 0x08) == 0x08)
+ dev->info.resStdList[++i] = 150;
+ if ((jbuf.standardres[0] & 0x04) == 0x04)
+ dev->info.resStdList[++i] = 160;
+ if ((jbuf.standardres[0] & 0x02) == 0x02)
+ dev->info.resStdList[++i] = 180;
+ if ((jbuf.standardres[0] & 0x01) == 0x01)
+ dev->info.resStdList[++i] = 200;
+ if ((jbuf.standardres[1] & 0x80) == 0x80)
+ dev->info.resStdList[++i] = 240;
+ if ((jbuf.standardres[1] & 0x40) == 0x40)
+ dev->info.resStdList[++i] = 300;
+ if ((jbuf.standardres[1] & 0x20) == 0x20)
+ dev->info.resStdList[++i] = 320;
+ if ((jbuf.standardres[1] & 0x10) == 0x10)
+ dev->info.resStdList[++i] = 400;
+ if ((jbuf.standardres[1] & 0x08) == 0x08)
+ dev->info.resStdList[++i] = 480;
+ if ((jbuf.standardres[1] & 0x04) == 0x04)
+ dev->info.resStdList[++i] = 600;
+ if ((jbuf.standardres[1] & 0x02) == 0x02)
+ dev->info.resStdList[++i] = 800;
+ if ((jbuf.standardres[1] & 0x01) == 0x01)
+ dev->info.resStdList[++i] = 1200;
+ dev->info.resStdList[0] = i; /* number of resolutions */
+ if (dev->info.resStdList[0] == 0)
+ { /* make a default standard resolutions for 200 and 300dpi */
+ DBG (DBG_warning, "attach: no standard resolutions reported\n");
+ dev->info.resStdList[0] = 2;
+ dev->info.resStdList[1] = 200;
+ dev->info.resStdList[2] = 300;
+ dev->info.resBasicX = dev->info.resBasicY = 300;
+ }
+ DBG (DBG_info, "attach: Window(W/L) = (%lu/%lu)\n",
+ _4btol (&jbuf.Window.width[0]), _4btol (&jbuf.Window.length[0]));
+ dev->info.winWidth = _4btol (&jbuf.Window.width[0]);
+ dev->info.winHeight = _4btol (&jbuf.Window.length[0]);
+ if (dev->info.winWidth <= 0)
+ {
+ dev->info.winWidth = (SANE_Int) (dev->info.resBasicX * 8.5);
+ DBG (DBG_warning, "attach: invalid window width reported, using %d\n",
+ dev->info.winWidth);
+ }
+ if (dev->info.winHeight <= 0)
+ {
+ dev->info.winHeight = dev->info.resBasicY * 14;
+ DBG (DBG_warning, "attach: invalid window height reported, using %d\n",
+ dev->info.winHeight);
+ }
+ /* 4692 / 400 * 25.4 = 297 */
+ mm = (dev->info.resBasicX > 0) ?
+ ((double) dev->info.winWidth / (double) dev->info.resBasicX *
+ MM_PER_INCH) : 0.0;
+ dev->info.x_range.min = SANE_FIX (0.0);
+ dev->info.x_range.max = SANE_FIX (mm);
+ dev->info.x_range.quant = SANE_FIX (0.0);
+ DBG (DBG_info, "attach: winWidth=%d resBasicX=%d mm/in=%f mm=%f\n",
+ dev->info.winWidth, dev->info.resBasicX, MM_PER_INCH, mm);
+
+ mm = (dev->info.resBasicY > 0) ?
+ ((double) dev->info.winHeight / (double) dev->info.resBasicY *
+ MM_PER_INCH) : 0.0;
+ dev->info.y_range.min = SANE_FIX (0.0);
+ dev->info.y_range.max = SANE_FIX (mm);
+ dev->info.y_range.quant = SANE_FIX (0.0);
+
+ DBG (DBG_info, "attach: RANGE x_range.max=%f, y_range.max=%f\n",
+ SANE_UNFIX (dev->info.x_range.max),
+ SANE_UNFIX (dev->info.y_range.max));
+
+ /* min, max, quantization light-dark 1-255, 0 means default 128 */
+ dev->info.brightness_range.min = 1;
+ dev->info.brightness_range.max = 255;
+ dev->info.brightness_range.quant = 1;
+ /* min, max, quantization white-black 1-255, 0 means default 128 */
+ dev->info.contrast_range.min = 1;
+ dev->info.contrast_range.max = 255;
+ dev->info.contrast_range.quant = 1;
+ /* min, max, quantization low-high 1-255, 0 means default 128 */
+ dev->info.threshold_range.min = 1;
+ dev->info.threshold_range.max = 255;
+ dev->info.threshold_range.quant = 1;
+
+ /* jbuf.functions */
+ dev->info.overflow_support =
+ ((jbuf.functions & 0x01) == 0x01) ? SANE_TRUE : SANE_FALSE;
+ dev->info.lineart_support =
+ ((jbuf.functions & 0x02) == 0x02) ? SANE_TRUE : SANE_FALSE;
+ dev->info.dither_support =
+ ((jbuf.functions & 0x04) == 0x04) ? SANE_TRUE : SANE_FALSE;
+ dev->info.grayscale_support =
+ ((jbuf.functions & 0x08) == 0x08) ? SANE_TRUE : SANE_FALSE;
+
+ /* set option defaults */
+ dev->info.default_res = dev->info.resBasicX;
+ dev->info.default_xres = dev->info.resBasicX;
+ dev->info.default_yres = dev->info.resBasicY;
+ dev->info.default_imagecomposition = LINEART;
+ dev->info.default_media = FLATBED;
+ dev->info.default_duplex = SANE_FALSE;
+
+ /* dev->info.autoborder_default = dev->info.canBorderRecog; */
+ /*
+ dev->info.batch_default = SANE_FALSE;
+ dev->info.deskew_default = SANE_FALSE;
+ dev->info.check_adf_default = SANE_FALSE;
+ dev->info.timeout_adf_default = 0;
+ dev->info.timeout_manual_default = 0;
+ */
+ /* dev->info.control_panel_default = dev->info.canACE; Image Data Processing */
+
+ ++num_devices;
+ dev->next = first_dev;
+ first_dev = dev;
+
+ if (devp)
+ *devp = dev;
+
+ DBG (DBG_sane_proc, "<<< attach:\n");
+ return SANE_STATUS_GOOD;
+}
+
+
+
+
+/* SANE callback to attach a SCSI device */
+static SANE_Status
+attach_one_scsi (const char *devname)
+{
+ return attach (devname, CONNECTION_SCSI, NULL);
+ /* return SANE_STATUS_GOOD; */
+}
+
+static void
+parse_configuration_file (FILE * fp)
+{
+ char line[PATH_MAX], *s, *t;
+ int linenumber;
+
+ DBG (DBG_proc, ">> parse_configuration_file\n");
+
+ if (fp == NULL)
+ {
+ DBG (DBG_proc,
+ ">> parse_configuration_file: No config file present!\n");
+ }
+ else
+ { /*parse configuration file */
+ for (linenumber = 0; sanei_config_read (line, sizeof (line), fp);
+ linenumber++)
+ {
+ DBG (DBG_proc,
+ ">> parse_configuration_file: parsing config line \"%s\"\n",
+ line);
+ if (line[0] == '#')
+ continue; /* ignore line comments */
+ for (s = line; isspace (*s); ++s); /* skip white space: */
+ for (t = s; *t != '\0'; t++);
+ for (--t; t > s && isspace (*t); t--);
+ *(++t) = '\0'; /*trim trailing space */
+ if (!strlen (s))
+ continue; /* ignore empty lines */
+ if ((t = strstr (s, "scsi ")) != NULL)
+ {
+ /* scsi VENDOR MODEL TYPE BUS CHANNEL ID LUN */
+ DBG (DBG_proc,
+ ">> parse_configuration_file: config file line %d: trying to attach SCSI: %s'\n",
+ linenumber, line);
+ sanei_config_attach_matching_devices (t, attach_one_scsi);
+ }
+ else if ((t = strstr (s, "/dev/")) != NULL)
+ {
+ /* /dev/scanner /dev/sg0 */
+ DBG (DBG_proc,
+ ">> parse_configuration_file: config file line %d: trying to attach SCSI: %s'\n",
+ linenumber, line);
+ sanei_config_attach_matching_devices (t, attach_one_scsi);
+ }
+ else if ((t = strstr (s, "option")) != NULL)
+ {
+ for (t += 6; isspace (*t); t++); /* skip to flag */
+ /* if(strstr(t,"FLAG_VALUE")!=NULL) FLAG_VALUE=SANE_TRUE; */
+ }
+ else
+ {
+ DBG (DBG_proc,
+ ">> parse_configuration_file: config file line %d: OBSOLETE !! use the scsi keyword!\n",
+ linenumber);
+ DBG (DBG_proc,
+ ">> parse_configuration_file: (see man sane-avision for details): trying to attach SCSI: %s'\n",
+ line);
+ }
+ }
+ fclose (fp);
+ }
+ DBG (DBG_proc, "<< parse_configuration_file\n");
+ return;
+}
+
+static SANE_Status
+do_cancel (HS2P_Scanner * s)
+{
+ SANE_Status status;
+ DBG (DBG_sane_proc, ">> do_cancel\n");
+
+ DBG (DBG_proc, "cancel: sending OBJECT POSITION\n");
+
+ s->scanning = SANE_FALSE;
+ s->cancelled = SANE_TRUE;
+ s->EOM = SANE_FALSE;
+
+ if (s->fd >= 0)
+ {
+ if ((status =
+ object_position (s->fd,
+ OBJECT_POSITION_UNLOAD)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "cancel: OBJECT POSTITION failed\n");
+ }
+ sanei_scsi_req_flush_all ();
+ release_unit (s->fd);
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ }
+ /*
+ if (s->reader_pid > 0){
+ int exit_status;
+ sanei_thread_kill (s->reader_pid);
+ sanei_thread_waitpid (s->reader_pid, &exit_status);
+ s->reader_pid = 0;
+ }
+ */
+
+ DBG (DBG_sane_proc, "<< do_cancel\n");
+ return (SANE_STATUS_CANCELLED);
+}
+
+
+SANE_Status
+sane_init (SANE_Int * version_code,
+ SANE_Auth_Callback __sane_unused__ authorize)
+{
+ FILE *fp;
+
+ DBG_INIT (); /* initialize SANE DEBUG */
+
+ /*DBG (DBG_sane_init, "> sane_init (authorize = %p)\n", (void *) authorize); */
+#if defined PACKAGE && defined VERSION
+ DBG (DBG_sane_init, "> sane_init: hs2p backend version %d.%d-%d ("
+ PACKAGE " " VERSION ")\n", SANE_CURRENT_MAJOR, V_MINOR, BUILD);
+#endif
+ /*
+ sanei_thread_init ();
+ */
+
+ if (version_code)
+ *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0);
+
+
+ if ((fp = sanei_config_open (HS2P_CONFIG_FILE)) != NULL)
+ {
+ parse_configuration_file (fp);
+ }
+ else
+ {
+ DBG (DBG_sane_init, "> sane_init: No config file \"%s\" present!\n",
+ HS2P_CONFIG_FILE);
+ }
+
+#if 0
+ /* avision.c: search for all supported scanners on all scsi busses & channels */
+ for (hw = &HS2P_Device_List[0]; hw->mfg != NULL; hw++)
+ {
+ sanei_scsi_find_devices (hw->mfg, /*vendor */
+ hw->model, /*model */
+ NULL, /*all types */
+ -1, /*all bus */
+ -1, /*all channel */
+ -1, /*all id */
+ -1, /*all lun */
+ attach_one_scsi); /*callback */
+ DBG (2, "sane_init: %s %s\n", hw->mfg, hw->model);
+ }
+#endif
+
+ DBG (DBG_sane_init, "< sane_init\n");
+ return SANE_STATUS_GOOD;
+}
+
+void
+sane_exit (void)
+{
+ HS2P_Device *dev, *next;
+ DBG (DBG_proc, ">> sane_exit\n");
+
+ for (dev = first_dev; dev; dev = next)
+ {
+ next = dev->next;
+ free ((void *) (SANE_String_Const *) dev->sane.name);
+ free ((SANE_String_Const *) dev->sane.model);
+ free (dev);
+ }
+
+ DBG (DBG_proc, "<< sane_exit\n");
+}
+
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
+{
+ static const SANE_Device **devlist = 0;
+ HS2P_Device *dev;
+ int i;
+ DBG (DBG_proc, ">> sane_get_devices (local_only = %d)\n", local_only);
+
+ if (devlist)
+ free (devlist);
+ devlist = malloc ((num_devices + 1) * sizeof (devlist[0]));
+ if (!devlist)
+ return (SANE_STATUS_NO_MEM);
+
+ i = 0;
+ for (dev = first_dev; dev; dev = dev->next)
+ devlist[i++] = &dev->sane;
+ devlist[i++] = 0;
+
+ *device_list = devlist;
+
+ DBG (DBG_proc, "<< sane_get_devices\n");
+ return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_open (SANE_String_Const devnam, SANE_Handle * handle)
+{
+ SANE_Status status;
+ HS2P_Device *dev;
+ HS2P_Scanner *s;
+ DBG (DBG_proc, "> sane_open\n");
+
+ if (devnam[0] == '\0')
+ {
+ for (dev = first_dev; dev; dev = dev->next)
+ {
+ if (strcmp (dev->sane.name, devnam) == 0)
+ break;
+ }
+ if (!dev)
+ {
+ status = attach (devnam, CONNECTION_SCSI, &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)); /* initialize */
+
+ s->fd = -1;
+ s->hw = dev;
+ s->hw->info.bmu = s->bmu = MILLIMETERS; /* 01H */
+ s->hw->info.mud = s->mud = 1; /* If the scale is MM or POINT, mud is fixed to 1 */
+ s->bpp = 1; /* supports 1,4,6,8 so we set to LINEART 1bpp */
+ /*
+ s->scanning = SANE_FALSE;
+ s->cancelled = SANE_FALSE;
+ */
+ /*
+ */
+
+ ScannerDump (s);
+ init_options (s);
+
+ s->next = first_handle; /* insert newly opened handle into list of open handles: */
+ first_handle = s;
+
+ /* initialize our parameters here AND in sane_start?
+ get_parameters(s, 0);
+ */
+
+ *handle = s;
+
+ DBG (DBG_proc, "< sane_open\n");
+ return SANE_STATUS_GOOD;
+}
+
+void
+sane_close (SANE_Handle handle)
+{
+ HS2P_Scanner *s = (HS2P_Scanner *) handle;
+ char **str;
+ DBG (DBG_proc, ">> sane_close\n");
+
+ if (s->fd != -1)
+ sanei_scsi_close (s->fd);
+ free (s);
+
+ for (str = &compression_list[0]; *str; str++);
+ free (*str);
+ for (str = &scan_mode_list[0]; *str; str++);
+ free (*str);
+
+ DBG (DBG_proc, "<< sane_close\n");
+}
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle handle, SANE_Int option)
+{
+ HS2P_Scanner *s = handle;
+ DBG (DBG_proc, ">> sane_get_option_descriptor: %d name=%s\n", option,
+ s->opt[option].name);
+
+ if ((unsigned) option >= NUM_OPTIONS)
+ return (0);
+
+ DBG (DBG_info, "<< sane_get_option_descriptor: name=%s\n",
+ s->opt[option].name);
+ return (s->opt + option);
+}
+
+#if 0
+static SANE_Int
+get_scan_mode_id (char *s) /* sequential search */
+{
+ SANE_Int i;
+
+ for (i = 0; scan_mode_list[i]; i++)
+ if (strcmp (s, scan_mode_list[i]) == 0)
+ break;
+
+ /* unknown strings are treated as 'lineart' */
+ return scan_mode_list[i] ? i : 0;
+}
+#endif
+static SANE_Status
+update_hs2p_data (HS2P_Scanner * s)
+{
+
+ DBG (DBG_proc, ">> update_hs2p_data\n");
+ /* OPT_NREGX_ADF: */
+ DBG (DBG_sane_option, "OPT_NREGX_ADF\n");
+ s->val[OPT_NREGX_ADF].w = (SANE_Word) s->data.maintenance.nregx_adf;
+
+ /* OPT_NREGY_ADF: */
+ DBG (DBG_sane_option, "OPT_NREGY_ADF\n");
+ s->val[OPT_NREGY_ADF].w = (SANE_Word) s->data.maintenance.nregx_book;
+
+ /* OPT_NREGX_BOOK: */
+ DBG (DBG_sane_option, "OPT_NREGX_BOOK\n");
+ s->val[OPT_NREGX_BOOK].w = (SANE_Word) s->data.maintenance.nregx_book;
+
+ /* OPT_NREGY_BOOK: */
+ DBG (DBG_sane_option, "OPT_NREGY_BOOK\n");
+ s->val[OPT_NREGY_BOOK].w = (SANE_Word) s->data.maintenance.nregy_book;
+
+ /* OPT_NSCANS_ADF: */
+ DBG (DBG_sane_option, "OPT_NSCANS_ADF\n");
+ s->val[OPT_NSCANS_ADF].w =
+ (SANE_Word) _4btol (&(s->data.maintenance.nscans_adf[0]));
+
+ /* OPT_NSCANS_BOOK: */
+ DBG (DBG_sane_option, "OPT_NSCANS_BOOK\n");
+ s->val[OPT_NSCANS_BOOK].w =
+ (SANE_Word) _4btol (&(s->data.maintenance.nscans_book[0]));
+
+ /* OPT_LAMP_TIME: */
+ DBG (DBG_sane_option, "OPT_LAMP_TIME\n");
+ s->val[OPT_LAMP_TIME].w =
+ (SANE_Word) _4btol (&(s->data.maintenance.lamp_time[0]));
+
+ /* OPT_EO_ODD: */
+ DBG (DBG_sane_option, "OPT_EO_ODD\n");
+ s->val[OPT_EO_ODD].w = (SANE_Word) s->data.maintenance.eo_odd;
+
+ /* OPT_EO_EVEN: */
+ DBG (DBG_sane_option, "OPT_EO_EVEN\n");
+ s->val[OPT_EO_EVEN].w = (SANE_Word) s->data.maintenance.eo_even;
+
+ /* OPT_BLACK_LEVEL_ODD: */
+ DBG (DBG_sane_option, "OPT_BLACK_LEVEL_ODD\n");
+ s->val[OPT_BLACK_LEVEL_ODD].w =
+ (SANE_Word) s->data.maintenance.black_level_odd;
+
+ /* OPT_BLACK_LEVEL_EVEN: */
+ DBG (DBG_sane_option, "OPT_BLACK_LEVEL_EVEN\n");
+ s->val[OPT_BLACK_LEVEL_EVEN].w =
+ (SANE_Word) s->data.maintenance.black_level_even;
+
+ /* OPT_WHITE_LEVEL_ODD: */
+ DBG (DBG_sane_option, "OPT_WHITE_LEVEL_ODD\n");
+ s->val[OPT_WHITE_LEVEL_ODD].w =
+ (SANE_Word) _2btol (&(s->data.maintenance.white_level_odd[0]));
+
+ /* OPT_WHITE_LEVEL_EVEN: */
+ DBG (DBG_sane_option, "OPT_WHITE_LEVEL_EVEN\n");
+ s->val[OPT_WHITE_LEVEL_EVEN].w =
+ (SANE_Word) _2btol (&(s->data.maintenance.white_level_even[0]));
+
+ /* OPT_FIRST_ADJ_WHITE_ODD: */
+ DBG (DBG_sane_option, "OPT_FIRST_ADJ_WHITE_ODD\n");
+ s->val[OPT_FIRST_ADJ_WHITE_ODD].w =
+ (SANE_Word) _2btol (&(s->data.maintenance.first_adj_white_odd[0]));
+
+ /* OPT_FIRST_ADJ_WHITE_EVEN: */
+ DBG (DBG_sane_option, "OPT_FIRST_ADJ_WHITE_EVEN\n");
+ s->val[OPT_FIRST_ADJ_WHITE_EVEN].w =
+ (SANE_Word) _2btol (&(s->data.maintenance.first_adj_white_even[0]));
+
+ /* OPT_DENSITY: */
+ DBG (DBG_sane_option, "OPT_DENSITY\n");
+ s->val[OPT_DENSITY].w = (SANE_Word) s->data.maintenance.density_adj;
+
+ /* OPT_NREGX_REVERSE: */
+ DBG (DBG_sane_option, "OPT_NREGX_REVERSE\n");
+ s->val[OPT_NREGX_REVERSE].w = (SANE_Word) s->data.maintenance.nregx_reverse;
+
+ /* OPT_NREGY_REVERSE: */
+ DBG (DBG_sane_option, "OPT_NREGY_REVERSE\n");
+ s->val[OPT_NREGY_REVERSE].w = (SANE_Word) s->data.maintenance.nregy_reverse;
+
+ /* OPT_NSCANS_REVERSE_ADF: */
+ DBG (DBG_sane_option, "OPT_NSCANS_REVERSE_ADF\n");
+ s->val[OPT_NSCANS_REVERSE_ADF].w =
+ (SANE_Word) _4btol (&(s->data.maintenance.nscans_reverse_adf[0]));
+
+ /* OPT_REVERSE_TIME: */
+ DBG (DBG_sane_option, "OPT_REVERSE_TIME\n");
+ s->val[OPT_REVERSE_TIME].w =
+ (SANE_Word) _4btol (&(s->data.maintenance.reverse_time[0]));
+
+ /* OPT_NCHARS: */
+ DBG (DBG_sane_option, "OPT_NCHARS\n");
+ s->val[OPT_NCHARS].w =
+ (SANE_Word) _4btol (&(s->data.maintenance.nchars[0]));
+
+ DBG (DBG_proc, "<< update_hs2p_data\n");
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+hs2p_open (HS2P_Scanner * s)
+{
+ SANE_Status status;
+ DBG (DBG_proc, ">> hs2p_open\n");
+ DBG (DBG_info, ">> hs2p_open: trying to open: name=\"%s\" fd=%d\n",
+ s->hw->sane.name, s->fd);
+ if ((status =
+ sanei_scsi_open (s->hw->sane.name, &s->fd, &sense_handler,
+ &(s->hw->sense_data))) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "sane_start: open of %s failed: %d %s\n",
+ s->hw->sane.name, status, sane_strstatus (status));
+ return (status);
+ }
+ DBG (DBG_info, ">>hs2p_open: OPENED \"%s\" fd=%d\n", s->hw->sane.name,
+ s->fd);
+
+ if ((status = test_unit_ready (s->fd)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "hs2p_open: test_unit_ready() failed: %s\n",
+ sane_strstatus (status));
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return status;
+ }
+ DBG (DBG_proc, "<< hs2p_open\n");
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+hs2p_close (HS2P_Scanner * s)
+{
+
+ DBG (DBG_proc, ">> hs2p_close\n");
+
+ release_unit (s->fd);
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+
+ DBG (DBG_proc, "<< hs2p_close\n");
+ return SANE_STATUS_GOOD;
+}
+
+#include <stdarg.h>
+static SANE_Status
+get_hs2p_data (HS2P_Scanner * s, ...)
+{
+ SANE_Status status;
+ SANE_Byte *buf;
+ size_t *len = &(s->data.bufsize);
+ int dtc, fd = s->fd;
+ u_long dtq = 0; /* two bytes */
+ va_list ap;
+
+ DBG (DBG_proc, ">> get_hs2p_data\n");
+ if (fd < 0)
+ {
+ status = hs2p_open (s);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "get_hs2p_data: error opening scanner: %s\n",
+ sane_strstatus (status));
+ return status;
+ }
+ }
+
+ for (va_start (ap, s), dtc = va_arg (ap, int); dtc != DATA_TYPE_EOL;
+ dtc = va_arg (ap, int))
+ {
+ DBG (DBG_proc, ">> get_hs2p_data 0x%2.2x\n", (int) dtc);
+ switch (dtc)
+ {
+ case DATA_TYPE_GAMMA:
+ buf = &(s->data.gamma[0]);
+ *len = sizeof (s->data.gamma);
+ break;
+ case DATA_TYPE_ENDORSER:
+ buf = &(s->data.endorser[0]);
+ *len = sizeof (s->data.endorser);
+ break;
+ case DATA_TYPE_SIZE:
+ buf = &(s->data.size);
+ *len = sizeof (s->data.size);
+ break;
+ case DATA_TYPE_PAGE_LEN:
+ buf = s->data.nlines;
+ *len = sizeof (s->data.nlines);
+ break;
+ case DATA_TYPE_MAINTENANCE:
+ buf = (SANE_Byte *) & (s->data.maintenance);
+ *len = sizeof (s->data.maintenance);
+ break;
+ case DATA_TYPE_ADF_STATUS:
+ buf = &(s->data.adf_status);
+ *len = sizeof (s->data.adf_status);
+ break;
+ case DATA_TYPE_IMAGE:
+ case DATA_TYPE_HALFTONE:
+ default:
+ DBG (DBG_info, "Data Type Code %2.2x not handled.\n", dtc);
+ return SANE_STATUS_INVAL;
+ }
+ DBG (DBG_info,
+ "get_hs2p_data calling read_data for dtc=%2.2x and bufsize=%lu\n",
+ (int) dtc, (u_long) * len);
+ status = read_data (s->fd, buf, len, (SANE_Byte) dtc, dtq);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "get_scanner_data: ERROR %s\n",
+ sane_strstatus (status));
+ }
+ }
+ va_end (ap);
+
+ if (fd < 0)
+ { /* need to return fd to original state */
+ status = hs2p_close (s);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "get_hs2p_data: error closing fd: %s\n",
+ sane_strstatus (status));
+ }
+ }
+ DBG (DBG_proc, "<< get_hs2p_data: %d\n", status);
+ return (status);
+}
+
+static SANE_Status
+print_maintenance_data (MAINTENANCE_DATA * d)
+{
+ DBG (DBG_proc, ">> print_maintenance_data: \n");
+
+ DBG (DBG_LEVEL, "nregx_adf = %d\n", d->nregx_adf);
+ DBG (DBG_LEVEL, "nregy_adf = %d\n", d->nregy_adf);
+
+ DBG (DBG_LEVEL, "nregx_book = %d\n", d->nregx_book);
+ DBG (DBG_LEVEL, "nregy_book = %d\n", d->nregy_book);
+
+ DBG (DBG_LEVEL, "nscans_adf = %lu\n", _4btol (&(d->nscans_adf[0])));
+ DBG (DBG_LEVEL, "nscans_adf = %lu\n", _4btol (&(d->nscans_adf[0])));
+
+ DBG (DBG_LEVEL, "lamp time = %lu\n", _4btol (&(d->lamp_time[0])));
+
+ DBG (DBG_LEVEL, "eo_odd = %d\n", d->eo_odd);
+ DBG (DBG_LEVEL, "eo_even = %d\n", d->eo_even);
+
+ DBG (DBG_LEVEL, "black_level_odd = %d\n", d->black_level_odd);
+ DBG (DBG_LEVEL, "black_level_even = %d\n", d->black_level_even);
+
+ DBG (DBG_LEVEL, "white_level_odd = %lu\n",
+ _2btol (&(d->white_level_odd[0])));
+ DBG (DBG_LEVEL, "white_level_even = %lu\n",
+ _2btol (&(d->white_level_even[0])));
+
+ DBG (DBG_LEVEL, "first_adj_white_odd = %lu\n",
+ _2btol (&(d->first_adj_white_odd[0])));
+ DBG (DBG_LEVEL, "first_adj_white_even = %lu\n",
+ _2btol (&(d->first_adj_white_even[0])));
+
+ DBG (DBG_LEVEL, "density_adj = %d\n", d->density_adj);
+
+ DBG (DBG_LEVEL, "nregx_reverse = %d\n", d->nregx_reverse);
+ DBG (DBG_LEVEL, "nregy_reverse = %d\n", d->nregy_reverse);
+
+ DBG (DBG_LEVEL, "nscans_reverse_adf = %lu\n",
+ _4btol (&(d->nscans_reverse_adf[0])));
+
+ DBG (DBG_LEVEL, "reverse_time = %lu\n", _4btol (&(d->reverse_time[0])));
+
+ DBG (DBG_LEVEL, "nchars = %lu\n", _4btol (&(d->nchars[0])));
+
+ DBG (DBG_proc, "<< print_maintenance_data: \n");
+ return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_control_option (SANE_Handle handle, SANE_Int option,
+ SANE_Action action, void *val, SANE_Int * info)
+{
+ HS2P_Scanner *s = handle;
+ SANE_Status status;
+ SANE_Word cap;
+ SANE_String_Const name;
+ SANE_Int paper_id;
+
+
+
+ name = s->opt[option].name ? s->opt[option].name : "(nil)";
+ if (info)
+ *info = 0;
+ DBG (DBG_proc, ">> sane_control_option: %s option=%d name=%s\n",
+ action == SANE_ACTION_GET_VALUE ? "SET" : "GET", option, name);
+
+ 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)
+ {
+ DBG (DBG_proc, "sane_control_option get_value option=%d\n", option);
+ switch (option)
+ {
+ /* word options: */
+ case OPT_RESOLUTION:
+ case OPT_X_RESOLUTION:
+ case OPT_Y_RESOLUTION:
+ case OPT_TL_X:
+ case OPT_TL_Y:
+ case OPT_BR_X:
+ case OPT_BR_Y:
+ case OPT_BRIGHTNESS:
+ case OPT_THRESHOLD:
+ case OPT_CONTRAST:
+ case OPT_NUM_OPTS:
+ *(SANE_Word *) val = s->val[option].w;
+ return (SANE_STATUS_GOOD);
+
+ /* bool options: */
+ /*case OPT_AUTOBORDER: case OPT_DESKEW: case OPT_CHECK_ADF: case OPT_BATCH: */
+ case OPT_PREVIEW:
+ case OPT_SCAN_WAIT_MODE:
+ case OPT_DUPLEX:
+ case OPT_AUTO_SIZE:
+ case OPT_NEGATIVE:
+ case OPT_ENDORSER:
+ case OPT_SMOOTHING:
+ case OPT_WHITE_BALANCE:
+ case OPT_PREFEED:
+ case OPT_CUSTOM_GAMMA:
+ case OPT_PADDING:
+ *(SANE_Bool *) val = s->val[option].w;
+ return (SANE_STATUS_GOOD);
+
+ /* string options: */
+ /* case OPT_ADF: */
+ /* case OPT_BITORDER: */
+ /* case OPT_ROTATION */
+ /* case OPT_SECTION: */
+ case OPT_INQUIRY:
+ case OPT_SCAN_SOURCE:
+ case OPT_PAGE_ORIENTATION:
+ case OPT_PAPER_SIZE:
+ case OPT_SCAN_MODE:
+ case OPT_ENDORSER_STRING:
+ case OPT_COMPRESSION:
+ case OPT_NOISEREMOVAL:
+ case OPT_GRAYFILTER:
+ case OPT_HALFTONE_CODE:
+ case OPT_HALFTONE_PATTERN:
+ case OPT_GAMMA:
+ case OPT_AUTOSEP:
+ case OPT_AUTOBIN:
+ case OPT_PADDING_TYPE:
+ DBG (DBG_proc, "STRING=%s\n", s->val[option].s);
+ strcpy (val, s->val[option].s);
+ return (SANE_STATUS_GOOD);
+ DBG (DBG_proc, "sizeof(val)=%lu sizeof(s)=%lu\n",
+ (u_long) sizeof (val), (u_long) sizeof (s->val[option].s));
+ return (SANE_STATUS_GOOD);
+
+ /* gamma */
+ case OPT_GAMMA_VECTOR_GRAY:
+ memcpy (val, s->val[option].wa, s->opt[option].size);
+ return SANE_STATUS_GOOD;
+
+ /* MAINTENANCE DATA */
+ case OPT_DATA_GROUP:
+ case OPT_UPDATE:
+ return SANE_STATUS_GOOD;
+ case OPT_NREGX_ADF:
+ DBG (DBG_sane_option, "OPT_NREGX_ADF\n");
+ *(SANE_Word *) val = (SANE_Word) s->data.maintenance.nregx_adf;
+ return SANE_STATUS_GOOD;
+ case OPT_NREGY_ADF:
+ DBG (DBG_sane_option, "OPT_NREGY_ADF\n");
+ *(SANE_Word *) val = (SANE_Word) s->data.maintenance.nregx_book;
+ return SANE_STATUS_GOOD;
+ case OPT_NREGX_BOOK:
+ DBG (DBG_sane_option, "OPT_NREGX_BOOK\n");
+ *(SANE_Word *) val = (SANE_Word) s->data.maintenance.nregx_book;
+ return SANE_STATUS_GOOD;
+ case OPT_NREGY_BOOK:
+ DBG (DBG_sane_option, "OPT_NREGY_BOOK\n");
+ *(SANE_Word *) val = (SANE_Word) s->data.maintenance.nregy_book;
+ return SANE_STATUS_GOOD;
+ case OPT_NSCANS_ADF:
+ DBG (DBG_sane_option, "OPT_NSCANS_ADF\n");
+ *(SANE_Word *) val =
+ (SANE_Word) _4btol (&(s->data.maintenance.nscans_adf[0]));
+ return SANE_STATUS_GOOD;
+ case OPT_NSCANS_BOOK:
+ DBG (DBG_sane_option, "OPT_NSCANS_BOOK\n");
+ *(SANE_Word *) val =
+ (SANE_Word) _4btol (&(s->data.maintenance.nscans_book[0]));
+ return SANE_STATUS_GOOD;
+ case OPT_LAMP_TIME:
+ DBG (DBG_sane_option, "OPT_LAMP_TIME\n");
+ *(SANE_Word *) val =
+ (SANE_Word) _4btol (&(s->data.maintenance.lamp_time[0]));
+ return SANE_STATUS_GOOD;
+ case OPT_EO_ODD:
+ DBG (DBG_sane_option, "OPT_EO_ODD\n");
+ *(SANE_Word *) val = (SANE_Word) s->data.maintenance.eo_odd;
+ return SANE_STATUS_GOOD;
+ case OPT_EO_EVEN:
+ DBG (DBG_sane_option, "OPT_EO_EVEN\n");
+ *(SANE_Word *) val = (SANE_Word) s->data.maintenance.eo_even;
+ return SANE_STATUS_GOOD;
+ case OPT_BLACK_LEVEL_ODD:
+ DBG (DBG_sane_option, "OPT_BLACK_LEVEL_ODD\n");
+ *(SANE_Word *) val =
+ (SANE_Word) s->data.maintenance.black_level_odd;
+ return SANE_STATUS_GOOD;
+ case OPT_BLACK_LEVEL_EVEN:
+ DBG (DBG_sane_option, "OPT_BLACK_LEVEL_EVEN\n");
+ *(SANE_Word *) val =
+ (SANE_Word) s->data.maintenance.black_level_even;
+ return SANE_STATUS_GOOD;
+ case OPT_WHITE_LEVEL_ODD:
+ DBG (DBG_sane_option, "OPT_WHITE_LEVEL_ODD\n");
+ *(SANE_Word *) val =
+ (SANE_Word) _2btol (&(s->data.maintenance.white_level_odd[0]));
+ return SANE_STATUS_GOOD;
+ case OPT_WHITE_LEVEL_EVEN:
+ DBG (DBG_sane_option, "OPT_WHITE_LEVEL_EVEN\n");
+ *(SANE_Word *) val =
+ (SANE_Word) _2btol (&(s->data.maintenance.white_level_even[0]));
+ return SANE_STATUS_GOOD;
+ case OPT_FIRST_ADJ_WHITE_ODD:
+ DBG (DBG_sane_option, "OPT_FIRST_ADJ_WHITE_ODD\n");
+ *(SANE_Word *) val =
+ (SANE_Word)
+ _2btol (&(s->data.maintenance.first_adj_white_odd[0]));
+ return SANE_STATUS_GOOD;
+ case OPT_FIRST_ADJ_WHITE_EVEN:
+ DBG (DBG_sane_option, "OPT_FIRST_ADJ_WHITE_EVEN\n");
+ *(SANE_Word *) val =
+ (SANE_Word)
+ _2btol (&(s->data.maintenance.first_adj_white_even[0]));
+ return SANE_STATUS_GOOD;
+ case OPT_DENSITY:
+ DBG (DBG_sane_option, "OPT_DENSITY\n");
+ *(SANE_Word *) val = (SANE_Word) s->data.maintenance.density_adj;
+ return SANE_STATUS_GOOD;
+ case OPT_NREGX_REVERSE:
+ DBG (DBG_sane_option, "OPT_NREGX_REVERSE\n");
+ *(SANE_Word *) val = (SANE_Word) s->data.maintenance.nregx_reverse;
+ return SANE_STATUS_GOOD;
+ case OPT_NREGY_REVERSE:
+ DBG (DBG_sane_option, "OPT_NREGY_REVERSE\n");
+ *(SANE_Word *) val = (SANE_Word) s->data.maintenance.nregy_reverse;
+ return SANE_STATUS_GOOD;
+ case OPT_NSCANS_REVERSE_ADF:
+ DBG (DBG_sane_option, "OPT_NSCANS_REVERSE_ADF\n");
+ *(SANE_Word *) val =
+ (SANE_Word) _4btol (&(s->data.maintenance.nscans_reverse_adf[0]));
+ return SANE_STATUS_GOOD;
+ case OPT_REVERSE_TIME:
+ DBG (DBG_sane_option, "OPT_REVERSE_TIME\n");
+ *(SANE_Word *) val =
+ (SANE_Word) _4btol (&(s->data.maintenance.reverse_time[0]));
+ return SANE_STATUS_GOOD;
+ case OPT_NCHARS:
+ DBG (DBG_sane_option, "OPT_NCHARS\n");
+ *(SANE_Word *) val =
+ (SANE_Word) _4btol (&(s->data.maintenance.nchars[0]));
+ return (SANE_STATUS_GOOD);
+
+ default:
+ DBG (DBG_proc, "sane_control_option:invalid option number %d\n",
+ option);
+ return SANE_STATUS_INVAL;
+ }
+ }
+ else if (action == SANE_ACTION_SET_VALUE)
+ {
+ DBG (DBG_proc, "sane_control_option set_value\n");
+ switch (s->opt[option].type)
+ {
+ case SANE_TYPE_BOOL:
+ case SANE_TYPE_INT:
+ DBG (DBG_proc, "sane_control_option: set_value %s [#%d] to %d\n",
+ name, option, *(SANE_Word *) val);
+ break;
+ case SANE_TYPE_FIXED:
+ DBG (DBG_proc, "sane_control_option: set_value %s [#%d] to %f\n",
+ name, option, SANE_UNFIX (*(SANE_Word *) val));
+ break;
+ case SANE_TYPE_STRING:
+ DBG (DBG_proc, "sane_control_option: set_value %s [#%d] to %s\n",
+ name, option, (char *) val);
+ break;
+ case SANE_TYPE_BUTTON:
+ DBG (DBG_proc, "sane_control_option: set_value %s [#%d]\n",
+ name, option);
+ update_hs2p_data (s);
+ break;
+ default:
+ DBG (DBG_proc, "sane_control_option: set_value %s [#%d]\n", name,
+ option);
+ }
+
+ if (!SANE_OPTION_IS_SETTABLE (cap))
+ return (SANE_STATUS_INVAL);
+ if ((status =
+ sanei_constrain_value (s->opt + option, val,
+ info)) != SANE_STATUS_GOOD)
+ return status;
+
+ switch (option)
+ {
+ /* (mostly) side-effect-free word options: */
+ case OPT_TL_X:
+ case OPT_TL_Y:
+ case OPT_BR_X:
+ case OPT_BR_Y:
+ s->opt[OPT_AUTO_SIZE].cap |= SANE_CAP_INACTIVE; /* disable auto size */
+ /* make sure that paper-size is set to custom */
+ if (info && s->val[option].w != *(SANE_Word *) val)
+ *info |= SANE_INFO_RELOAD_PARAMS;
+ s->val[option].w = *(SANE_Word *) val;
+ /* resets the paper format to user defined */
+ if (strcmp (s->val[OPT_PAPER_SIZE].s, paper_list[0]) != 0) /* CUSTOM PAPER SIZE */
+ {
+ if (info)
+ *info |= SANE_INFO_RELOAD_OPTIONS;
+ if (s->val[OPT_PAPER_SIZE].s)
+ free (s->val[OPT_PAPER_SIZE].s);
+ s->val[OPT_PAPER_SIZE].s = strdup (paper_list[0]); /* CUSTOM PAPER SIZE */
+ }
+ /* fall through */
+ case OPT_X_RESOLUTION:
+ case OPT_Y_RESOLUTION:
+ if (info && s->val[option].w != *(SANE_Word *) val)
+ *info |= SANE_INFO_RELOAD_PARAMS;
+
+ /* fall through */
+ /*case OPT_ACE_FUNCTION: case OPT_ACE_SENSITIVITY: */
+ case OPT_BRIGHTNESS:
+ case OPT_THRESHOLD:
+ case OPT_CONTRAST:
+ case OPT_NUM_OPTS:
+ s->val[option].w = *(SANE_Word *) val;
+ return (SANE_STATUS_GOOD);
+
+ /* string options */
+ case OPT_NOISEREMOVAL:
+ case OPT_AUTOSEP:
+ case OPT_AUTOBIN:
+ case OPT_COMPRESSION:
+ case OPT_PADDING_TYPE:
+ case OPT_GRAYFILTER:
+ case OPT_HALFTONE_CODE:
+ case OPT_HALFTONE_PATTERN:
+ case OPT_ENDORSER_STRING:
+ if (s->val[option].s)
+ free (s->val[option].s);
+ s->val[option].s = strdup (val);
+ return SANE_STATUS_GOOD;
+
+ /* boolean options: */
+ case OPT_PREVIEW:
+ case OPT_DUPLEX:
+ case OPT_NEGATIVE:
+ case OPT_SCAN_WAIT_MODE:
+ case OPT_ENDORSER:
+ case OPT_SMOOTHING:
+ case OPT_WHITE_BALANCE:
+ case OPT_PREFEED:
+ case OPT_PADDING:
+ s->val[option].w = *(SANE_Word *) val;
+ return SANE_STATUS_GOOD;
+
+ case OPT_GAMMA_VECTOR_GRAY:
+ memcpy (s->val[option].wa, val, s->opt[option].size);
+ return SANE_STATUS_GOOD;
+
+ /* options with side effect */
+ case OPT_GAMMA:
+ if (strcmp (s->val[option].s, (SANE_String) val))
+ {
+ if (!strcmp ((SANE_String) val, "User"))
+ {
+ s->val[OPT_CUSTOM_GAMMA].b = SANE_TRUE;
+ s->opt[OPT_CUSTOM_GAMMA].cap &= ~SANE_CAP_INACTIVE;
+ /* Brightness and Contrast do not work when downloading Gamma Table */
+ s->opt[OPT_BRIGHTNESS].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE;
+ }
+ else
+ {
+ s->val[OPT_CUSTOM_GAMMA].b = SANE_FALSE;
+ s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE;
+ s->opt[OPT_CONTRAST].cap &= ~SANE_CAP_INACTIVE;
+ }
+ if (info)
+ *info |= SANE_INFO_RELOAD_OPTIONS;
+ }
+ if (s->val[option].s)
+ free (s->val[option].s);
+ s->val[option].s = strdup (val);
+ return SANE_STATUS_GOOD;
+
+ case OPT_CUSTOM_GAMMA:
+ s->val[OPT_CUSTOM_GAMMA].w = *(SANE_Word *) val;
+ if (s->val[OPT_CUSTOM_GAMMA].w)
+ {
+ s->opt[OPT_GAMMA_VECTOR_GRAY].cap &= ~SANE_CAP_INACTIVE;
+ }
+ else
+ {
+ s->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE;
+ }
+ if (info)
+ *info |= SANE_INFO_RELOAD_OPTIONS;
+ return SANE_STATUS_GOOD;
+
+ case OPT_RESOLUTION:
+ if (info && s->val[option].w != *(SANE_Word *) val)
+ *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+ s->val[option].w = *(SANE_Word *) val;
+ s->val[OPT_X_RESOLUTION].w = *(SANE_Word *) val;
+ s->val[OPT_Y_RESOLUTION].w = *(SANE_Word *) val;
+ return SANE_STATUS_GOOD;
+ case OPT_SCAN_SOURCE:
+ /* a string option */
+ /* Since the scanner ejects the sheet in ADF mode
+ * it is impossible to scan multiple sections in one document
+ * In ADF mode, because of mechanical limitations:
+ * the minimum document size is (x,y)=(69mm x 120mm)
+ */
+ if (info && strcmp ((char *) s->val[option].s, (char *) val))
+ *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+ if (s->val[option].s)
+ free (s->val[option].s);
+ s->val[option].s = strdup (val);
+ if (!strcmp ("ADF", (SANE_String) val))
+ {
+ s->opt[OPT_ENDORSER].cap &= ~SANE_CAP_INACTIVE;
+ s->opt[OPT_ENDORSER_STRING].cap &= ~SANE_CAP_INACTIVE;
+ s->opt[OPT_PREFEED].cap &= ~SANE_CAP_INACTIVE;
+ s->opt[OPT_DUPLEX].cap &= ~SANE_CAP_INACTIVE;
+ /*s->opt[OPT_PADDING].cap &= ~SANE_CAP_INACTIVE; */
+ }
+ else
+ { /* Flatbed */
+ s->opt[OPT_ENDORSER].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_ENDORSER_STRING].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_PREFEED].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_DUPLEX].cap |= SANE_CAP_INACTIVE;
+ s->opt[OPT_PADDING].cap |= SANE_CAP_INACTIVE;
+ }
+ return SANE_STATUS_GOOD;
+ case OPT_SCAN_MODE:
+ /* a string option */
+ /* scan mode != lineart disables compression, setting it to 'none' */
+ if (strcmp (s->val[option].s, (SANE_String) val))
+ {
+ if (info)
+ *info |= SANE_INFO_RELOAD_OPTIONS;
+ if (!strcmp (SM_LINEART, (SANE_String) val))
+ {
+ s->image_composition = LINEART;
+ s->opt[OPT_COMPRESSION].cap &= ~SANE_CAP_INACTIVE; /* enable compression control */
+ s->opt[OPT_THRESHOLD].cap &= ~SANE_CAP_INACTIVE; /* enable threshold control */
+ s->opt[OPT_BRIGHTNESS].cap |= SANE_CAP_INACTIVE; /* disable brightness control */
+ s->opt[OPT_CONTRAST].cap |= SANE_CAP_INACTIVE; /* disable contrast control */
+ s->opt[OPT_GAMMA].cap |= SANE_CAP_INACTIVE; /* disable gamma */
+ s->opt[OPT_CUSTOM_GAMMA].cap |= SANE_CAP_INACTIVE; /* disable gamma */
+ s->opt[OPT_GAMMA_VECTOR_GRAY].cap |= SANE_CAP_INACTIVE; /* disable gamma */
+ s->opt[OPT_HALFTONE_CODE].cap |= SANE_CAP_INACTIVE; /* disable halftone code */
+ s->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; /* disable halftone pattern */
+ }
+ else
+ {
+ if (!strcmp (SM_HALFTONE, (SANE_String) val))
+ {
+ s->image_composition = HALFTONE;
+ s->opt[OPT_HALFTONE_CODE].cap &= ~SANE_CAP_INACTIVE; /* enable halftone code */
+ s->opt[OPT_HALFTONE_PATTERN].cap &= ~SANE_CAP_INACTIVE; /* enable halftone pattern */
+ }
+ else if (!strcmp (SM_4BITGRAY, (SANE_String) val) ||
+ !strcmp (SM_6BITGRAY, (SANE_String) val) ||
+ !strcmp (SM_8BITGRAY, (SANE_String) val))
+ {
+ s->image_composition = GRAYSCALE;
+ s->opt[OPT_GAMMA].cap &= ~SANE_CAP_INACTIVE; /* enable gamma */
+ s->opt[OPT_BRIGHTNESS].cap &= ~SANE_CAP_INACTIVE; /* enable brightness */
+ s->opt[OPT_CONTRAST].cap &= ~SANE_CAP_INACTIVE; /* enable contrast */
+ s->opt[OPT_THRESHOLD].cap |= SANE_CAP_INACTIVE; /* disable threshold */
+ s->opt[OPT_COMPRESSION].cap |= SANE_CAP_INACTIVE; /* disable compression */
+ s->opt[OPT_HALFTONE_CODE].cap |= SANE_CAP_INACTIVE; /* disable halftone code */
+ s->opt[OPT_HALFTONE_PATTERN].cap |= SANE_CAP_INACTIVE; /* disable halftone pattern */
+ if (s->val[OPT_COMPRESSION].s
+ && get_compression_id (s->val[OPT_COMPRESSION].s) !=
+ 0)
+ {
+ free (s->val[OPT_COMPRESSION].s);
+ s->val[OPT_COMPRESSION].s =
+ strdup (compression_list[0]);
+ }
+ }
+ }
+ free (s->val[option].s);
+ s->val[option].s = strdup (val);
+ }
+ return SANE_STATUS_GOOD;
+
+ case OPT_PAGE_ORIENTATION:
+ if (strcmp (s->val[option].s, (SANE_String) val))
+ {
+ free (s->val[option].s);
+ s->val[option].s = strdup (val);
+ if (info)
+ *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+ }
+ /* set val to current selected paper size */
+ paper_id = get_paper_id ((SANE_String) s->val[OPT_PAPER_SIZE].s);
+ goto paper_id;
+ case OPT_PAPER_SIZE:
+ /* a string option */
+ /* changes geometry options, therefore _RELOAD_PARAMS and _RELOAD_OPTIONS */
+ s->opt[OPT_AUTO_SIZE].cap |= SANE_CAP_INACTIVE; /* disable auto size */
+ if (strcmp (s->val[option].s, (SANE_String) val))
+ {
+ paper_id = get_paper_id ((SANE_String) val);
+
+ /* paper_id 0 is a special case (custom) that
+ * disables the paper size control of geometry
+ */
+ paper_id:
+ if (paper_id != 0)
+ {
+ double x_max, y_max, x, y, temp;
+
+ x_max = SANE_UNFIX (s->hw->info.x_range.max);
+ y_max = SANE_UNFIX (s->hw->info.y_range.max);
+
+ /* a dimension of 0.0 (or less) is replaced with the max value */
+ x = (paper_sizes[paper_id].width <= 0.0) ? x_max :
+ paper_sizes[paper_id].width;
+ y = (paper_sizes[paper_id].length <= 0.0) ? y_max :
+ paper_sizes[paper_id].length;
+
+ if (info)
+ *info |=
+ SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+
+ if (!strcmp (s->val[OPT_PAGE_ORIENTATION].s, LANDSCAPE)) /* swap */
+ {
+ temp = y_max;
+ y_max = x_max;
+ x_max = temp;
+ temp = y;
+ y = x;
+ x = temp;
+ }
+
+ s->val[OPT_TL_X].w = SANE_FIX (0.0);
+ s->val[OPT_TL_Y].w = SANE_FIX (0.0);
+ s->val[OPT_BR_X].w = SANE_FIX (MIN (x, x_max));
+ s->val[OPT_BR_Y].w = SANE_FIX (MIN (y, y_max));
+ }
+ free (s->val[option].s);
+ s->val[option].s = strdup (val);
+ }
+ return SANE_STATUS_GOOD;
+ case OPT_UPDATE: /* SANE_TYPE_BUTTON */
+ DBG (DBG_info,
+ "OPT_UPDATE: ready to call get_hs2p_data: fd=%d\n", s->fd);
+ get_hs2p_data (s,
+ /* DATA_TYPE_GAMMA, */
+ /* DATA_TYPE_ENDORSER, */
+ /* DATA_TYPE_SIZE, */
+ /* DATA_TYPE_PAGE_LEN, */
+ DATA_TYPE_MAINTENANCE,
+ /* DATA_TYPE_ADF_STATUS, */
+ /* DATA_TYPE_IMAGE, */
+ /* DATA_TYPE_HALFTONE, */
+ DATA_TYPE_EOL); /* va_list end */
+ update_hs2p_data (s);
+ if (DBG_LEVEL >= DBG_info)
+ print_maintenance_data (&(s->data.maintenance));
+ if (info)
+ *info |= SANE_INFO_RELOAD_PARAMS | SANE_INFO_RELOAD_OPTIONS;
+ return SANE_STATUS_GOOD;
+ }
+ return (SANE_STATUS_GOOD);
+ }
+
+ DBG (DBG_proc, "<< sane_control_option\n");
+ return (SANE_STATUS_INVAL);
+
+}
+
+SANE_Status
+sane_get_parameters (SANE_Handle handle, SANE_Parameters * params)
+{
+ HS2P_Scanner *s = handle;
+ DBG (DBG_proc, ">> sane_get_parameters\n");
+
+ if (!s->scanning)
+ {
+ int width, length, xres, yres;
+ const char *mode;
+
+ memset (&s->params, 0, sizeof (s->params)); /* CLEAR SANE_Parameters */
+
+ width =
+ (int) (SANE_UNFIX (s->val[OPT_BR_X].w) -
+ SANE_UNFIX (s->val[OPT_TL_X].w));
+ length =
+ (int) (SANE_UNFIX (s->val[OPT_BR_Y].w) -
+ SANE_UNFIX (s->val[OPT_TL_Y].w));
+ xres = s->val[OPT_X_RESOLUTION].w;
+ yres = s->val[OPT_Y_RESOLUTION].w;
+ DBG (DBG_proc,
+ ">>sane_get_parameters: (W/L)=(%d/%d) (xres/yres)=(%d/%d) mud=%d\n",
+ width, length, xres, yres, s->hw->info.mud);
+
+ /* make best-effort guess at what parameters will look like once scanning starts. */
+ if (xres > 0 && yres > 0 && width > 0 && length > 0)
+ { /* convert from mm to pixels */
+ s->params.pixels_per_line =
+ width * xres / s->hw->info.mud / MM_PER_INCH;
+ s->params.lines = length * yres / s->hw->info.mud / MM_PER_INCH;
+ }
+
+ mode = s->val[OPT_SCAN_MODE].s;
+ if ((strcmp (mode, SM_LINEART) == 0) ||
+ (strcmp (mode, SM_HALFTONE)) == 0)
+ {
+ s->params.format = SANE_FRAME_GRAY;
+ s->params.bytes_per_line = s->params.pixels_per_line / 8;
+ /* if the scanner truncates to the byte boundary, so: chop! */
+ s->params.pixels_per_line = s->params.bytes_per_line * 8;
+ s->params.depth = 1;
+ }
+ else /* if (strcmp (mode, SANE_VALUE_SCAN_MODE_GRAY) == 0) */
+ {
+ s->params.format = SANE_FRAME_GRAY;
+ s->params.bytes_per_line = s->params.pixels_per_line;
+ s->params.depth = 8;
+ }
+ s->params.last_frame = SANE_TRUE;
+ }
+ else
+ DBG (DBG_proc, "sane_get_parameters: scanning, so can't get params\n");
+
+ if (params)
+ *params = s->params;
+
+ DBG (DBG_proc,
+ "%d pixels per line, %d bytes per line, %d lines high, total %lu bytes, "
+ "dpi=%ld\n", s->params.pixels_per_line, s->params.bytes_per_line,
+ s->params.lines, (u_long) s->bytes_to_read,
+ (long) SANE_UNFIX (s->val[OPT_Y_RESOLUTION].w));
+
+ DBG (DBG_proc, "<< sane_get_parameters\n");
+ return (SANE_STATUS_GOOD);
+}
+
+static SANE_Status
+set_window_data (HS2P_Scanner * s, SWD * wbuf)
+{
+ struct hs2p_window_data *data;
+ int i, nwin, id, xres, yres, xmax, ymax;
+ long ulx, uly, width, length, number, bytes;
+ double offset;
+
+ DBG (DBG_proc, ">> set_window_data: sizeof(*wbuf)=%lu; window len=%lu\n",
+ (u_long) sizeof (*wbuf), (u_long) sizeof (wbuf->data));
+
+ /* initialize our window buffer with zeros */
+ DBG (DBG_proc, ">> set_window_data: CLEARING wbuf\n");
+ memset (wbuf, 0, sizeof (*wbuf));
+
+ /* Header */
+ DBG (DBG_proc,
+ ">> set_window_data: writing Window Descriptor Length =%lu\n",
+ (u_long) sizeof (wbuf->data));
+ _lto2b (sizeof (wbuf->data), &wbuf->hdr.len[0]);
+
+ /* X-Axis Resolution 100-800dpi in 1 dpi steps */
+ xres = s->val[OPT_X_RESOLUTION].w;
+ if (xres < s->hw->info.resMinX || xres > s->hw->info.resMaxX)
+ {
+ DBG (DBG_error, "XRESOLUTION %d IS NOT WITHIN [%d, %d]\n", xres,
+ s->hw->info.resMinX, s->hw->info.resMaxX);
+ return (SANE_STATUS_INVAL);
+ }
+
+ /* Y-Axis Resolution 100-800dpi in 1 dpi steps */
+ yres = s->val[OPT_Y_RESOLUTION].w;
+ if (yres < s->hw->info.resMinY || yres > s->hw->info.resMaxY)
+ {
+ DBG (DBG_error, "YRESOLUTION %d IS NOT WITHIN [%d, %d]\n", yres,
+ s->hw->info.resMinY, s->hw->info.resMaxY);
+ return (SANE_STATUS_INVAL);
+ }
+
+ ulx = (long) SANE_UNFIX (s->val[OPT_TL_X].w);
+ uly = (long) SANE_UNFIX (s->val[OPT_TL_Y].w);
+ DBG (DBG_info, "set_window_data: upperleft=(%ld,%ld)\n", ulx, uly);
+
+ width = (long) SANE_UNFIX (s->val[OPT_BR_X].w - s->val[OPT_TL_X].w); /* Window Width */
+ length = (long) SANE_UNFIX (s->val[OPT_BR_Y].w - s->val[OPT_TL_Y].w); /* Window Length */
+ DBG (DBG_info, "set_window_data: WxL= %ld x %ld\n", width, length);
+
+ /* NOTE: the width in inches converted to byte unit must be the following values or less
+ * Binary: 620 bytes
+ * 4-bits gray: 2480 bytes
+ * 8-bits gray: 4960 bytes
+ */
+ if (!strcmp (s->val[OPT_SCAN_MODE].s, SM_LINEART))
+ {
+ bytes = (width / MM_PER_INCH) * (s->val[OPT_X_RESOLUTION].w / 8.0);
+ if (bytes > 620)
+ {
+ DBG (DBG_error,
+ "width in pixels too large: width=%ld x-resolution=%d bytes=%ld\n",
+ width, s->val[OPT_X_RESOLUTION].w, bytes);
+ return (SANE_STATUS_INVAL);
+ }
+ }
+ else if (!strcmp (s->val[OPT_SCAN_MODE].s, SM_4BITGRAY))
+ {
+ bytes = (width / MM_PER_INCH) * (s->val[OPT_X_RESOLUTION].w / 2.0);
+ if (bytes > 2480)
+ {
+ DBG (DBG_error,
+ "width in pixels too large: width=%ld x-resolution=%d bytes=%ld\n",
+ width, s->val[OPT_X_RESOLUTION].w, bytes);
+ return (SANE_STATUS_INVAL);
+ }
+ }
+ else if (!strcmp (s->val[OPT_SCAN_MODE].s, SM_8BITGRAY))
+ {
+ bytes = (width / MM_PER_INCH) * (s->val[OPT_X_RESOLUTION].w);
+ if (bytes > 4960)
+ {
+ DBG (DBG_error,
+ "width in pixels too large: width=%ld x-resolution=%d bytes=%ld\n",
+ width, s->val[OPT_X_RESOLUTION].w, bytes);
+ return (SANE_STATUS_INVAL);
+ }
+ }
+
+
+ if (strcmp (s->val[OPT_SCAN_SOURCE].s, scan_source_list[ADF]) == 0)
+ {
+ offset = (SANE_UNFIX (s->hw->info.x_range.max) - width) / 2.0;
+ DBG (DBG_info, "set_window_data: ADF origin offset=%f\n", offset);
+
+ ulx += (long) offset;
+ }
+
+
+ if (strcmp (s->val[OPT_SCAN_SOURCE].s, scan_source_list[FB]) == 0)
+ { /* FB */
+ xmax = 298; /*mm */
+ ymax = 432;
+ }
+ else
+ { /* ADF */
+ xmax = 298;
+ ymax = 2000;
+ }
+
+ /* Boundary Conditions when BMU = MM */
+ number = ulx + width;
+ if (number <= 0 || number > xmax)
+ {
+ DBG (DBG_error, "NOT WITHIN BOUNDS: ulx=%ld width=%ld sum=%ld\n",
+ ulx, width, number);
+ return (SANE_STATUS_INVAL);
+ }
+ number = uly + length;
+ if (number <= 0 || number > ymax)
+ {
+ DBG (DBG_error, "NOT WITHIN BOUNDS: uly=%ld length=%ld sum=%ld\n",
+ uly, length, number);
+ return (SANE_STATUS_INVAL);
+ }
+
+
+
+ /* For each window (up to 2 if we're duplexing) */
+ nwin = (s->val[OPT_DUPLEX].w == SANE_TRUE) ? 2 : 1;
+ for (i = 0; i < nwin; i++)
+ {
+ data = &(wbuf->data[i]);
+ data->window_id = i;
+ data->auto_bit &= 0xFE; /* Auto bit set to 0 since auto function isn't supported */
+
+ _lto2b (xres, &data->xres[0]); /* Set X resolution */
+ _lto2b (yres, &data->yres[0]); /* Set Y resolution */
+
+ _lto4b (ulx, &data->ulx[0]); /* X-Axis Upper Left */
+ _lto4b (uly, &data->uly[0]); /* Y-Axis Upper Left */
+
+ _lto4b (width, &data->width[0]); /* Window Width */
+ _lto4b (length, &data->length[0]); /* Window Length */
+
+
+
+
+
+
+ data->brightness = s->val[OPT_BRIGHTNESS].w; /* black-white: 1-255; 0 is default 128 */
+ data->threshold = s->val[OPT_THRESHOLD].w; /* light-dark: 1-255; 0 is default 128 */
+ data->contrast = s->val[OPT_CONTRAST].w; /* low-high: 1-255: 0 is default 128 */
+ if (data->brightness == 128)
+ data->brightness = 0;
+ if (data->threshold == 128)
+ data->threshold = 0;
+ if (data->contrast == 128)
+ data->contrast = 0;
+
+ data->image_composition = s->image_composition;
+ data->bpp = s->bpp = s->params.depth;
+
+ /* Byte 27, 347 Halftone Code: if HALFTONE, then either DITHER or ERROR_DIFFUSION */
+ if (s->image_composition == HALFTONE)
+ { /* Then let's use pattern selected by user */
+ data->halftone_code =
+ (get_halftone_code_id (s->val[OPT_HALFTONE_CODE].s) ==
+ 0) ? DITHER : ERROR_DIFFUSION;
+ data->halftone_id =
+ get_halftone_pattern_val (s->val[OPT_HALFTONE_PATTERN].s);
+ }
+ else
+ {
+ data->halftone_code = DITHER; /* 00H reserved */
+ data->halftone_id = 0x01; /* 00H reserved */
+ }
+
+
+
+ /* Byte 29, 349: RIF:reserved:padding type */
+ if (data->image_composition == LINEART
+ || data->image_composition == HALFTONE)
+ {
+ if (s->val[OPT_NEGATIVE].w)
+ data->byte29 |= (1 << 7); /* set bit 7 */
+ else
+ data->byte29 &= ~(1 << 7); /* unset bit 7 */
+ }
+ /* Padding Type */
+ data->byte29 |=
+ (paddingtype[get_paddingtype_id (s->val[OPT_PADDING_TYPE].s)].
+ val & 0x07);
+
+ /* Bit Ordering:
+ * Manual Says DEFAULT: [1111 1111][1111 1000]
+ * Bits15-8 reserved;
+ * Bit7: '0'-Normal '1'-Mirroring
+ * Bit6-4: Reserved
+ * Bit3: '0'-arrangement from MSB in grayscale mode
+ * '1'-arrangement from LSB in grayscale mode
+ * 2: '0'-unpacked 4-bits grayscale [DEFAULT]
+ * '1'-packed 4-bits grayscale
+ * 1: '0'-output from LSB of each word [DEFAULT]
+ * '1'-output from MSB of each word
+ * 0: '0'-output from bit 0 of each byte [DEFAULT]
+ * '1'-output from bit 7 of each byte
+ */
+ _lto2b (0x007, &data->bit_ordering[0]); /* Set to Packed4bitGray, MSB, MSbit */
+
+ /* Compression Type and Argument NOT SUPPORTED in this scanner */
+ data->compression_type = 0x00;
+ data->compression_arg = 0x02;
+
+ /* Byte42: MRIF:Filtering:GammaID */
+ if (data->image_composition == GRAYSCALE)
+ {
+ if (s->val[OPT_NEGATIVE].w)
+ data->byte42 &= ~(1 << 7); /* unset bit 7 */
+ else
+ data->byte42 |= (1 << 7); /* set bit 7 */
+ data->byte42 |= (get_grayfilter_val (s->val[OPT_GRAYFILTER].s) & (7 << 4)); /* set bits 6-4 to GRAYFILTER */
+ }
+ else
+ {
+ data->byte42 &= ~(1 << 7); /* unset bit 7 */
+ data->byte42 &= ~(7 << 4); /* unset bits 6-4 */
+ }
+ /* Bytes 45, 365 Binary Filtering for lineart and halftone can be set when option IPU is installed */
+ if ((id = get_noisematrix_id (s->val[OPT_NOISEREMOVAL].s)) != 0)
+ {
+ data->binary_filtering |= (1 << 7); /* set bit 7 */
+ data->binary_filtering |= noisematrix[id].val; /* 00H, 01H, 02H; 03H:Reserved */
+ }
+ if (s->val[OPT_SMOOTHING].w == SANE_TRUE)
+ data->binary_filtering |= (1 << 6); /* set bit 6 */
+
+ /* Automatic separation, automatic binarization, and SECTION is available if Image Processing Unit is installed */
+ if (s->hw->info.hasIPU)
+ {
+ /* Byte 48: Automatic Separation */
+ data->automatic_separation =
+ get_auto_separation_val (s->val[OPT_AUTOSEP].s);
+ /* Byte 50: Automatic Binarization */
+ data->automatic_binarization =
+ get_auto_binarization_val (s->val[OPT_AUTOBIN].s);
+ /* fill in values for each section
+ for(j=0; j<NumSec; j++){
+ wbuf[i].winsec[j].ulx
+ wbuf[i].winsec[j].uly
+ wbuf[i].winsec[j].width
+ wbuf[i].winsec[j].length
+ wbuf[i].winsec[j].binary_filtering
+ wbuf[i].winsec[j].threshold
+ wbuf[i].winsec[j].image_composition
+ wbuf[i].winsec[j].halftone_id
+ wbuf[i].winsec[j].halftone_arg
+ }
+ */
+ }
+ }
+ DBG (DBG_proc, "<< set_window_data\n");
+ return (SANE_STATUS_GOOD);
+}
+
+SANE_Status
+sane_start (SANE_Handle handle) /* begin scanning */
+{
+ HS2P_Scanner *s = handle;
+ SANE_Status status;
+ SWD wbuf; /* Set Window Data: hdr + data */
+ GWD gbuf; /* Get Window Data: hdr + data */
+ SANE_Byte mode, prefeed, mwt = 0;
+
+ DBG (DBG_proc, ">> sane_start\n");
+ s->cancelled = SANE_FALSE;
+
+ if (s->another_side)
+ {
+ /* Number of bytes to read for one side of sheet */
+ s->bytes_to_read = s->params.bytes_per_line * s->params.lines;
+ DBG (DBG_info,
+ "SIDE#2 %d pixels per line, %d bytes, %d lines high, dpi=%d\n",
+ s->params.pixels_per_line, s->params.bytes_per_line,
+ s->params.lines, (int) s->val[OPT_Y_RESOLUTION].w);
+ s->scanning = SANE_TRUE;
+ s->cancelled = SANE_FALSE;
+ s->another_side = SANE_FALSE; /* This is side 2, so no more sides */
+ DBG (DBG_proc, "<< sane_start\n");
+ return (SANE_STATUS_GOOD);
+ }
+
+ if (s->scanning)
+ {
+ DBG (DBG_info, "sane_start: device busy\n");
+ return SANE_STATUS_DEVICE_BUSY;
+ }
+
+ /* Let's start a new scan */
+
+ if ((status = sane_get_parameters (s, 0)) != SANE_STATUS_GOOD)
+ { /* get preliminary parameters */
+ DBG (DBG_error, "sane_start: sane_get_parameters failed: %s\n",
+ sane_strstatus (status));
+ return (status);
+ }
+
+ DBG (DBG_info, ">> sane_start: trying to open: name=\"%s\" fd=%d\n",
+ s->hw->sane.name, s->fd);
+ if ((status =
+ sanei_scsi_open (s->hw->sane.name, &s->fd, &sense_handler,
+ &(s->hw->sense_data))) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "sane_start: open of %s failed: %d %s\n",
+ s->hw->sane.name, status, sane_strstatus (status));
+ return (status);
+ }
+ DBG (DBG_info, ">>sane_start: OPENED \"%s\" fd=%d\n", s->hw->sane.name,
+ s->fd);
+
+ if ((status = test_unit_ready (s->fd)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "sane_start: test_unit_ready() failed: %s\n",
+ sane_strstatus (status));
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return status;
+ }
+
+
+ if ((status = reserve_unit (s->fd)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "sane_start: reserve_unit() failed: %s\n",
+ sane_strstatus (status));
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+
+ /* NOW SET UP SCANNER ONCE PER BATCH */
+
+ DBG (DBG_info, "sane_start: setting basic measurement unit to mm\n");
+ if ((status = set_basic_measurement_unit (s->fd, s->hw->info.bmu)))
+ {
+ DBG (DBG_error, "set_basic_measurment_unit failed: %s\n",
+ sane_strstatus (status));
+ release_unit (s->fd);
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+
+ if (get_scan_source_id (s->val[OPT_SCAN_SOURCE].s) == 0)
+ {
+ mode = FLATBED;
+ }
+ else
+ {
+ mode = (s->val[OPT_DUPLEX].w) ? DUPLEX : SIMPLEX;
+ }
+
+ prefeed = s->val[OPT_PREFEED].w ? 0x04 : 0x00;
+ DBG (DBG_info, "sane_start: setting scan source to %d %s\n", mode,
+ (SANE_String) s->val[OPT_SCAN_SOURCE].s);
+ DBG (DBG_info, "sane_start: setting prefeed to %d\n", prefeed);
+ if ((status =
+ set_adf_control (s->fd, &mode, &prefeed, &mwt)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "sane_start: error set_adf_control: %s\n",
+ sane_strstatus (status));
+ release_unit (s->fd);
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (SANE_STATUS_INVAL);
+ }
+
+
+ DBG (DBG_info, "sane_start: setting endorser control to %d\n",
+ s->val[OPT_ENDORSER].w);
+ if ((status =
+ set_endorser_control (s->fd,
+ &s->val[OPT_ENDORSER].w)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "set_endorser_control failed: %s\n",
+ sane_strstatus (status));
+ release_unit (s->fd);
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+ if (s->val[OPT_ENDORSER].w)
+ {
+ DBG (DBG_info, "sane_start: setting endorser string to %s\n",
+ s->val[OPT_ENDORSER_STRING].s);
+ if ((status =
+ set_endorser_string (s->fd,
+ (SANE_String) s->val[OPT_ENDORSER_STRING].
+ s)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "set_endorser_string failed: %s\n",
+ sane_strstatus (status));
+ release_unit (s->fd);
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+ }
+
+ DBG (DBG_info, "sane_start: setting scan_wait_mode to %d\n",
+ s->val[OPT_SCAN_WAIT_MODE].w);
+ if ((status =
+ set_scan_wait_mode (s->fd,
+ s->val[OPT_SCAN_WAIT_MODE].w)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "set_scan_wait_mode failed: %s\n",
+ sane_strstatus (status));
+ release_unit (s->fd);
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+ DBG (DBG_info, "sane_start: setting white_balance to %d\n",
+ s->val[OPT_WHITE_BALANCE].w);
+ if ((status =
+ set_white_balance (s->fd,
+ &s->val[OPT_WHITE_BALANCE].w)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "set_white_balance failed: %s\n",
+ sane_strstatus (status));
+ release_unit (s->fd);
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+
+ if (s->val[OPT_CUSTOM_GAMMA].b)
+ { /* Custom Gamma needs to be sent to scanner */
+ DBG (DBG_info, "sane_start: setting custom gamma\n");
+ if ((status = hs2p_send_gamma (s)))
+ {
+ DBG (DBG_error, "hs2p_send_gamma failed: %s\n",
+ sane_strstatus (status));
+ release_unit (s->fd);
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+ /* We succeeded, so we don't need to upload this vector again (unless user modifies gamma table) */
+ s->val[OPT_CUSTOM_GAMMA].b = SANE_FALSE;
+ }
+
+
+ DBG (DBG_info, "sane_start: filling in window data buffer \n");
+ if ((status = set_window_data (s, &wbuf)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "set_window_data failed: %s\n",
+ sane_strstatus (status));
+ release_unit (s->fd);
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+ DBG (DBG_info, "sane_start: sending SET WINDOW DATA\n");
+ if ((status = set_window (s->fd, &wbuf)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "SET WINDOW DATA failed: %s\n",
+ sane_strstatus (status));
+ print_window_data (&wbuf);
+ release_unit (s->fd);
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+ DBG (DBG_info, "sane_start: sending GET WINDOW\n");
+ memset (&gbuf, 0, sizeof (gbuf)); /* CLEAR wbuf */
+ if ((status = get_window (s->fd, &gbuf)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "GET WINDOW failed: %s\n", sane_strstatus (status));
+ release_unit (s->fd);
+ sanei_scsi_close (s->fd);
+ s->fd = -1;
+ return (status);
+ }
+
+ /* DONE WITH SETTING UP SCANNER ONCE PER BATCH */
+
+ s->EOM = SANE_FALSE;
+ if (mode != FLATBED)
+ {
+ if ((status =
+ get_hs2p_data (s, DATA_TYPE_ADF_STATUS,
+ DATA_TYPE_EOL)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "sane_start: error reading adf_status: %s\n",
+ sane_strstatus (status));
+ return (status);
+ }
+ if ((s->data.adf_status & 0x00) == 0x01)
+ {
+ DBG (DBG_warning, "sane_start: No document on ADF\n");
+ return (SANE_STATUS_NO_DOCS);
+ }
+ else if ((s->data.adf_status & 0x02) == 0x02)
+ {
+ DBG (DBG_warning, "sane_start: ADF cover open!\n");
+ return (SANE_STATUS_COVER_OPEN);
+ }
+ }
+
+
+ status = trigger_scan (s);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "start of scan failed: %s\n", sane_strstatus (status));
+ print_window_data (&wbuf);
+ /* this line introduced not to freeze xscanimage */
+ /*do_cancel (s); */
+ return status;
+ }
+ /* Wait for scanner to become ready to transmit data */
+ status = hs2p_wait_ready (s);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "GET DATA STATUS failed: %s\n",
+ sane_strstatus (status));
+ return (status);
+ }
+
+ s->another_side = (mode == DUPLEX) ? SANE_TRUE : SANE_FALSE;
+ /* Number of bytes to read for one side of sheet */
+ DBG (DBG_info, "ANOTHER SIDE = %s\n", (s->another_side) ? "TRUE" : "FALSE");
+ s->bytes_to_read = s->params.bytes_per_line * s->params.lines;
+ DBG (DBG_info, "%d pixels per line, %d bytes, %d lines high, dpi=%d\n",
+ s->params.pixels_per_line, s->params.bytes_per_line,
+ s->params.lines, (int) s->val[OPT_Y_RESOLUTION].w);
+ s->scanning = SANE_TRUE;
+ s->cancelled = SANE_FALSE;
+
+ DBG (DBG_proc, "<< sane_start\n");
+ return (SANE_STATUS_GOOD);
+}
+
+SANE_Status
+sane_read (SANE_Handle handle, SANE_Byte * buf, SANE_Int max_len,
+ SANE_Int * len)
+{
+ HS2P_Scanner *s = handle;
+ SANE_Status status;
+ size_t nread, bytes_requested, i, start;
+ SANE_Byte color;
+ DBG (DBG_proc, ">> sane_read\n");
+
+ *len = 0;
+
+ DBG (DBG_info, "sane_read: bytes left to read: %ld\n",
+ (u_long) s->bytes_to_read);
+
+ if (s->bytes_to_read == 0)
+ { /* We've reached the end of one side of sheet */
+ if (!s->another_side)
+ {
+ do_cancel (s);
+ return (SANE_STATUS_EOF);
+ }
+ else
+ {
+ /* let frontend call sane_start again to reset bytes_to_read */
+ DBG (DBG_proc, "<< sane_read: getting another side\n");
+ return (SANE_STATUS_EOF);
+ }
+ }
+
+ if (s->cancelled)
+ {
+ DBG (DBG_info, "sane_read: cancelled!\n");
+ return SANE_STATUS_CANCELLED;
+ }
+ if (!s->scanning)
+ {
+ DBG (DBG_info, "sane_read: scanning is false!\n");
+ return (do_cancel (s));
+ }
+
+ nread = max_len;
+ if (nread > s->bytes_to_read)
+ nread = s->bytes_to_read;
+ bytes_requested = nread;
+ start = 0;
+
+pad:
+ if (s->EOM)
+ {
+ if (s->val[OPT_PADDING].w)
+ {
+ DBG (DBG_info, "sane_read s->EOM padding from %ld to %ld\n",
+ (u_long) start, (u_long) bytes_requested);
+ color = (s->val[OPT_NEGATIVE].w) ? 0 : 255;
+ /* pad to requested length */
+ for (i = start; i < bytes_requested; i++)
+ buf[i] = color;
+ nread = bytes_requested; /* we've padded to bytes_requested */
+ *len = nread;
+ s->bytes_to_read -= nread;
+ }
+ else /* TRUNCATE: should never reach here */
+ {
+ *len = nread;
+ s->bytes_to_read = 0; /* EOM */
+ }
+ }
+ else
+ {
+ DBG (DBG_info, "sane_read: trying to read %ld bytes\n", (u_long) nread);
+ status = read_data (s->fd, buf, &nread, DATA_TYPE_IMAGE, DTQ);
+ switch (status)
+ {
+ case SANE_STATUS_NO_DOCS:
+ DBG (DBG_error, "sane_read: End-Of-Medium detected\n");
+ s->EOM = SANE_TRUE;
+ /*
+ * If status != SANE_STATUS_GOOD, then sense_handler() has already
+ * been called and the sanei_* functions have already gotten the
+ * sense data buffer (which apparently clears the error conditionn)
+ * so the following doesn't work:
+ get_sense_data (s->fd, &(s->hw->sense_data));
+ print_sense_data (&(s->hw->sense_data));
+ */
+ start = (isset_ILI (s->hw->sense_data)) ? /* Invalid Length Indicator */
+ bytes_requested - _4btol (s->hw->sense_data.information) : nread;
+ goto pad;
+ break;
+ case SANE_STATUS_GOOD:
+ *len = nread;
+ s->bytes_to_read -= nread;
+ break;
+ default:
+ DBG (DBG_error, "sane_read: read error\n");
+ do_cancel (s);
+ return (SANE_STATUS_IO_ERROR);
+ }
+ }
+ DBG (DBG_proc, "<< sane_read\n");
+ return (SANE_STATUS_GOOD);
+}
+
+
+void
+sane_cancel (SANE_Handle handle)
+{
+ HS2P_Scanner *s = handle;
+ DBG (DBG_proc, ">> sane_cancel\n");
+
+ if (s->scanning)
+ { /* if batchmode is enabled, then call set_window to abort the batch
+ if (_OPT_VAL_WORD(s, OPT_BATCH) == SANE_TRUE) {
+ DBG(5, "sane_cancel: calling set_window to abort batch\n");
+ set_window(s, BH_BATCH_ABORT);
+ } */
+ do_cancel (s);
+ }
+
+
+
+ DBG (DBG_proc, "<< sane_cancel\n");
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
+{
+ DBG (DBG_proc, ">> sane_set_io_mode (handle = %p, non_blocking = %d)\n",
+ handle, non_blocking);
+ DBG (DBG_proc, "<< sane_set_io_mode\n");
+
+ return SANE_STATUS_UNSUPPORTED;
+}
+
+SANE_Status
+sane_get_select_fd (SANE_Handle handle, SANE_Int * fd)
+{
+#ifdef NONBLOCKSUPPORTED
+ HS2P_Scanner *s = handle;
+#endif
+ DBG (DBG_proc, ">> sane_get_select_fd (handle = %p, fd = %p)\n", handle,
+ (void *) fd);
+
+#ifdef NONBLOCKSUPPORTED
+ if (s->fd < 0)
+ {
+ DBG (DBG_proc, "<< sane_get_select_fd\n");
+ return SANE_STATUS_INVAL;
+ }
+ *fd = s->fd;
+ return SANE_STATUS_GOOD;
+#else
+ handle = handle;
+ fd = fd; /* get rid of compiler warning */
+ DBG (DBG_proc, "<< sane_get_select_fd\n");
+ return SANE_STATUS_UNSUPPORTED;
+#endif
+}