diff options
Diffstat (limited to 'backend/hs2p.c')
| -rw-r--r-- | backend/hs2p.c | 3332 |
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 +} |