Initial import of sane-backends version 1.0.24-1.2

1 files changed, 516 insertions, 0 deletions

diff --git a/backend/hs2p.h b/backend/hs2p.h
new file mode 100644
index 0000000..091fce2
--- /dev/null
+++ b/backend/hs2p.h
@@ -0,0 +1,516 @@
+/* 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. */
+
+#ifndef HS2P_H
+#define HS2P_H 1
+
+#include <sys/types.h>
+#include "../include/sane/config.h"
+
+#include "hs2p-scsi.h"
+#include "hs2p-saneopts.h"
+
+#define HS2P_CONFIG_FILE "hs2p.conf"
+
+#define DBG_error0       0
+#define DBG_error        1
+#define DBG_sense        2
+#define DBG_warning      3
+#define DBG_inquiry      4
+#define DBG_info         5
+#define DBG_info2        6
+#define DBG_proc         7
+#define DBG_read         8
+#define DBG_sane_init   10
+#define DBG_sane_proc   11
+#define DBG_sane_info   12
+#define DBG_sane_option 13
+
+typedef struct
+{
+  const char *mfg;
+  const char *model;
+} HS2P_HWEntry;
+
+enum CONNECTION_TYPES
+{ CONNECTION_SCSI = 0, CONNECTION_USB };
+
+enum media
+{ FLATBED = 0x00, SIMPLEX, DUPLEX };
+
+
+typedef struct data
+{
+  size_t bufsize;
+  /* 00H IMAGE */
+  /* 01H RESERVED */
+  /* 02H Halftone Mask  */
+  SANE_Byte gamma[256];		/* 03H Gamma Function */
+  /* 04H - 7FH Reserved */
+  SANE_Byte endorser[19];	/* 80H Endorser */
+  SANE_Byte size;		/* 81H startpos(4bits) + width(4bits) */
+  /* 82H Reserved */
+  /* 83H Reserved (Vendor Unique) */
+  SANE_Byte nlines[5];		/* 84H Page Length */
+  MAINTENANCE_DATA maintenance;	/* 85H */
+  SANE_Byte adf_status;		/* 86H */
+  /* 87H Reserved (Skew Data) */
+  /* 88H-91H Reserved (Vendor Unique) */
+  /* 92H Reserved (Scanner Extension I/O Access) */
+  /* 93H Reserved (Vendor Unique) */
+  /* 94H-FFH Reserved (Vendor Unique) */
+} HS2P_DATA;
+
+typedef struct
+{
+  SANE_Range xres_range;
+  SANE_Range yres_range;
+  SANE_Range x_range;
+  SANE_Range y_range;
+
+  SANE_Int window_width;
+  SANE_Int window_height;
+
+  SANE_Range brightness_range;
+  SANE_Range contrast_range;
+  SANE_Range threshold_range;
+
+  char inquiry_data[256];
+
+  SANE_Byte max_win_sections;	/* Number of supported window subsections 
+				   IS450 supports max of 4 sections 
+				   IS420 supports max of 6 sections
+				 */
+
+  /* Defaults */
+  SANE_Int default_res;
+  SANE_Int default_xres;
+  SANE_Int default_yres;
+  SANE_Int default_imagecomposition;	/* [lineart], halftone, grayscale, color */
+  SANE_Int default_media;	/* [flatbed], simplex, duplex */
+  SANE_Int default_paper_size;	/* [letter], legal, ledger, ... */
+  SANE_Int default_brightness;
+  SANE_Int default_contrast;
+  SANE_Int default_gamma;	/* Normal, Soft, Sharp, Linear, User */
+  SANE_Bool default_adf;
+  SANE_Bool default_duplex;
+  /*
+     SANE_Bool default_border;
+     SANE_Bool default_batch;
+     SANE_Bool default_deskew;
+     SANE_Bool default_check_adf;
+     SANE_Int  default_timeout_adf;
+     SANE_Int  default_timeout_manual;
+     SANE_Bool default_control_panel;
+   */
+
+  /* Mode Page Parameters */
+  MP_CXN cxn;			/* hdr + Connection Parameters */
+
+  SANE_Int bmu;
+  SANE_Int mud;
+  SANE_Int white_balance;	/* 00H Relative, 01H Absolute; power on default is relative */
+  /* Lamp Timer not supported */
+  SANE_Int adf_control;		/* 00H None, 01H Book, 01H Simplex, 02H Duplex */
+  SANE_Int adf_mode_control;	/* bit2: prefeed mode invalid: "0" : valid "1" */
+  /* Medium Wait Timer not supported */
+  SANE_Int endorser_control;	/* Default Off when power on */
+  SANE_Char endorser_string[20];
+  SANE_Bool scan_wait_mode;	/* wait for operator panel start button to be pressed */
+  SANE_Bool service_mode;	/* power on default self_diagnostics 00H; 01H optical_adjustment */
+
+  /* standard information: EVPD bit is 0 */
+  SANE_Byte devtype;		/* devtype[6]="scanner" */
+  SANE_Char vendor[9];		/* model name 8+1 */
+  SANE_Char product[17];	/* product name 16+1 */
+  SANE_Char revision[5];	/* revision 4+1 */
+
+  /* VPD information: EVPD bit is 1, Page Code=C0H */
+  /* adf_id: 0: No ADF
+   *         1: Single-sided ADF
+   *         2: Double-sided ADF
+   *         3: ARDF (Reverse double-sided ADF)
+   *         4: Reserved
+   */
+
+  SANE_Bool hasADF;		/* If YES; can either be one of Simplex,Duplex,ARDF */
+  SANE_Bool hasSimplex;
+  SANE_Bool hasDuplex;
+  SANE_Bool hasARDF;
+
+  SANE_Bool hasEndorser;
+
+  SANE_Bool hasIPU;
+  SANE_Bool hasXBD;
+
+  /* VPD Image Composition */
+  SANE_Bool supports_lineart;
+  SANE_Bool supports_dithering;
+  SANE_Bool supports_errordiffusion;
+  SANE_Bool supports_color;
+  SANE_Bool supports_4bitgray;
+  SANE_Bool supports_8bitgray;
+
+  /* VPD Image Data Processing ACE (supported for IS420) */
+  SANE_Bool supports_whiteframing;
+  SANE_Bool supports_blackframing;
+  SANE_Bool supports_edgeextraction;
+  SANE_Bool supports_noiseremoval;	/* supported for IS450 if IPU installed */
+  SANE_Bool supports_smoothing;	/* supported for IS450 if IPU installed */
+  SANE_Bool supports_linebolding;
+
+  /* VPD Compression (not supported for IS450) */
+  SANE_Bool supports_MH;
+  SANE_Bool supports_MR;
+  SANE_Bool supports_MMR;
+  SANE_Bool supports_MHB;
+
+  /* VPD Marker Recognition (not supported for IS450) */
+  SANE_Bool supports_markerrecognition;
+
+  /* VPD Size Recognition (supported for IS450 if IPU installed) */
+  SANE_Bool supports_sizerecognition;
+
+  /* VPD X Maximum Output Pixel: IS450:4960   IS420:4880 */
+  SANE_Int xmaxoutputpixels;
+
+  /* jis information VPD IDENTIFIER Page Code F0H */
+  SANE_Int resBasicX;		/* basic X resolution */
+  SANE_Int resBasicY;		/* basic Y resolution */
+  SANE_Int resXstep;		/* resolution step in main scan direction */
+  SANE_Int resYstep;		/* resolution step in sub scan direction */
+  SANE_Int resMaxX;		/* maximum X resolution */
+  SANE_Int resMaxY;		/* maximum Y resolution */
+  SANE_Int resMinX;		/* minimum X resolution */
+  SANE_Int resMinY;		/* minimum Y resolution */
+  SANE_Int resStdList[16 + 1];	/* list of available standard resolutions (first slot is the length) */
+  SANE_Int winWidth;		/* length of window (in BasicX res DPI) */
+  SANE_Int winHeight;		/* height of window (in BasicY res DPI) */
+  /* jis.functions duplicates vpd.imagecomposition lineart/dither/grayscale */
+  SANE_Bool overflow_support;
+  SANE_Bool lineart_support;
+  SANE_Bool dither_support;
+  SANE_Bool grayscale_support;
+
+} HS2P_Info;
+
+typedef struct HS2P_Device
+{
+  struct HS2P_Device *next;
+  /*
+   * struct with pointers to device/vendor/model names, and a type value
+   * used to inform sane frontend about the device 
+   */
+  SANE_Device sane;
+  HS2P_Info info;
+  SENSE_DATA sense_data;
+} HS2P_Device;
+
+#define GAMMA_LENGTH 256
+typedef struct HS2P_Scanner
+{
+  /* all the state needed to define a scan request: */
+  struct HS2P_Scanner *next;	/* linked list for housekeeping */
+  int fd;			/* SCSI filedescriptor */
+
+  /* --------------------------------------------------------------------- */
+  /* immutable values which are set during reading of config file.         */
+  int buffer_size;		/* for sanei_open */
+  int connection;		/* hardware interface type */
+
+
+  /* SANE option descriptors and values */
+  SANE_Option_Descriptor opt[NUM_OPTIONS];
+  Option_Value val[NUM_OPTIONS];
+  SANE_Parameters params;	/* SANE image parameters */
+  /* additional values that don't fit into Option_Value representation */
+  SANE_Word gamma_table[GAMMA_LENGTH];	/* Custom Gray Gamma Table */
+
+  /* state information - not options */
+
+  /* scanner dependent/low-level state: */
+  HS2P_Device *hw;
+
+  SANE_Int bmu;			/* Basic Measurement Unit       */
+  SANE_Int mud;			/* Measurement Unit Divisor     */
+  SANE_Byte image_composition;	/* LINEART, HALFTONE, GRAYSCALE */
+  SANE_Byte bpp;		/* 1,4,6,or 8 Bits Per Pixel    */
+
+
+  u_long InvalidBytes;
+  size_t bytes_to_read;
+  SANE_Bool cancelled;
+  /*SANE_Bool backpage; */
+  SANE_Bool scanning;
+  SANE_Bool another_side;
+  SANE_Bool EOM;
+
+  HS2P_DATA data;
+} HS2P_Scanner;
+
+static const SANE_Range u8_range = {
+  0,				/* minimum */
+  255,				/* maximum */
+  0				/* quantization */
+};
+static const SANE_Range u16_range = {
+  0,				/* minimum */
+  65535,			/* maximum */
+  0				/* quantization */
+};
+
+#define SM_LINEART        SANE_VALUE_SCAN_MODE_LINEART
+#define SM_HALFTONE       SANE_VALUE_SCAN_MODE_HALFTONE
+#define SM_DITHER         "Dither"
+#define SM_ERRORDIFFUSION "Error Diffusion"
+#define SM_COLOR          SANE_VALUE_SCAN_MODE_COLOR
+#define SM_4BITGRAY       "4-Bit Gray"
+#define SM_6BITGRAY       "6-Bit Gray"
+#define SM_8BITGRAY       "8-Bit Gray"
+static SANE_String scan_mode_list[9];
+enum
+{ FB, ADF };
+static SANE_String_Const scan_source_list[] = {
+  "FB",				/* Flatbed */
+  "ADF",			/* Automatic Document Feeder */
+  NULL
+};
+static SANE_String compression_list[6];	/* "none", "g31d MH", "g32d MR", "g42d MMR", "MH byte boundary", NULL} */
+
+typedef struct
+{
+  SANE_String name;
+  double width, length;		/* paper dimensions in mm */
+} HS2P_Paper;
+/* list of support paper sizes */
+/* 'custom' MUST be item 0; otherwise a width or length of 0 indicates
+ * the maximum value supported by the scanner
+ */
+static const HS2P_Paper paper_sizes[] = {	/* Name, Width, Height in mm */
+  {"Custom", 0.0, 0.0},
+  {"Letter", 215.9, 279.4},
+  {"Legal", 215.9, 355.6},
+  {"Ledger", 279.4, 431.8},
+  {"A3", 297, 420},
+  {"A4", 210, 297},
+  {"A4R", 297, 210},
+  {"A5", 148.5, 210},
+  {"A5R", 210, 148.5},
+  {"A6", 105, 148.5},
+  {"B4", 250, 353},
+  {"B5", 182, 257},
+  {"Full", 0.0, 0.0},
+};
+
+#define PORTRAIT "Portait"
+#define LANDSCAPE "Landscape"
+static SANE_String_Const orientation_list[] = {
+  PORTRAIT,
+  LANDSCAPE,
+  NULL				/* sentinel */
+};
+
+/* MUST be kept in sync with paper_sizes */
+static SANE_String_Const paper_list[] = {
+  "Custom",
+  "Letter",
+  "Legal",
+  "Ledger",
+  "A3",
+  "A4", "A4R",
+  "A5", "A5R",
+  "A6",
+  "B4",
+  "B5",
+  "Full",
+  NULL				/* (not the same as "") sentinel */
+};
+
+#if 0
+static /* inline */ int _is_host_little_endian (void);
+static /* inline */ int
+_is_host_little_endian ()
+{
+  SANE_Int val = 255;
+  unsigned char *firstbyte = (unsigned char *) &val;
+
+  return (*firstbyte == 255) ? SANE_TRUE : SANE_FALSE;
+}
+#endif
+
+static /* inline */ void
+_lto2b (u_long val, SANE_Byte * bytes)
+{
+  bytes[0] = (val >> 8) & 0xff;
+  bytes[1] = val & 0xff;
+}
+
+static /* inline */ void
+_lto3b (u_long val, SANE_Byte * bytes)
+{
+  bytes[0] = (val >> 16) & 0xff;
+  bytes[1] = (val >> 8) & 0xff;
+  bytes[2] = val & 0xff;
+}
+
+static /* inline */ void
+_lto4b (u_long val, SANE_Byte * bytes)
+{
+  bytes[0] = (val >> 24) & 0xff;
+  bytes[1] = (val >> 16) & 0xff;
+  bytes[2] = (val >> 8) & 0xff;
+  bytes[3] = val & 0xff;
+}
+
+static /* inline */ u_long
+_2btol (SANE_Byte * bytes)
+{
+  u_long rv;
+
+  rv = (bytes[0] << 8) | bytes[1];
+
+  return rv;
+}
+
+static /* inline */ u_long
+_4btol (SANE_Byte * bytes)
+{
+  u_long rv;
+
+  rv = (bytes[0] << 24) | (bytes[1] << 16) | (bytes[2] << 8) | bytes[3];
+
+  return rv;
+}
+
+/*
+static inline SANE_Int
+_2btol(SANE_Byte *bytes)
+{
+  SANE_Int rv;
+
+  rv = (bytes[0] << 8) | bytes[1];
+  return (rv);
+}
+*/
+static inline SANE_Int
+_3btol (SANE_Byte * bytes)
+{
+  SANE_Int rv;
+
+  rv = (bytes[0] << 16) | (bytes[1] << 8) | bytes[2];
+  return (rv);
+}
+
+/*
+static inline SANE_Int
+_4btol(SANE_Byte *bytes)
+{
+        SANE_Int rv;
+
+        rv = (bytes[0] << 24) |
+             (bytes[1] << 16) |
+             (bytes[2] << 8) |
+             bytes[3];
+        return (rv);
+}
+*/
+enum adf_ret_bytes
+{ ADF_SELECTION = 2, ADF_MODE_CONTROL, MEDIUM_WAIT_TIMER };
+
+#define get_paddingtype_id(s)  (get_list_index( paddingtype_list, (char *)(s) ))
+#define get_paddingtype_val(i) (paddingtype[ get_paddingtype_id( (i) ) ].val)
+#define get_paddingtype_strndx(v) (get_val_id_strndx(&paddingtype[0], NELEMS(paddingtype), (v)))
+
+#define get_halftone_code_id(s)  (get_list_index( halftone_code, (char *)(s) ))
+#define get_halftone_code_val(i) (halftone[get_halftone_code_id( (i) ) ].val)
+
+#define get_halftone_pattern_id(s)  (get_list_index( halftone_pattern_list, (char *)(s) ))
+#define get_halftone_pattern_val(i) (halftone[get_halftone_pattern_id( (i) ) ].val)
+
+#define get_auto_binarization_id(s)  (get_list_index( auto_binarization_list, (char *)(s) ))
+#define get_auto_binarization_val(i) (auto_binarization[ get_auto_binarization_id( (i) ) ].val)
+
+#define get_auto_separation_id(s)  (get_list_index( auto_separation_list, (char *)(s) ))
+#define get_auto_separation_val(i) (auto_separation[ get_auto_separation_id( (i) ) ].val)
+
+#define get_noisematrix_id(s)    (get_list_index( noisematrix_list, (char *)(s) ))
+#define get_noisematrix_val(i)   (noisematrix[ get_noisematrix_id( (i) ) ].val)
+
+#define get_grayfilter_id(s)    (get_list_index( grayfilter_list, (char *)(s) ))
+#define get_grayfilter_val(i)   (grayfilter[ get_grayfilter_id( (i) ) ].val)
+
+#define get_paper_id(s)       (get_list_index( paper_list, (char *)(s) ))
+#define get_compression_id(s) (get_list_index( (const char **)compression_list, (char *)(s) ))
+#define get_scan_source_id(s) (get_list_index( (const char **)scan_source_list, (char *)(s) ))
+
+#define reserve_unit(fd) (unit_cmd((fd),HS2P_SCSI_RESERVE_UNIT))
+#define release_unit(fd) (unit_cmd((fd),HS2P_SCSI_RELEASE_UNIT))
+
+#define GET SANE_TRUE
+#define SET SANE_FALSE
+
+#define get_endorser_control(fd,val)  (endorser_control( (fd), (val), GET ))
+#define set_endorser_control(fd,val)  (endorser_control( (fd), (val), SET ))
+
+#define get_connection_parameters(fd,parm)  (connection_parameters( (fd), (parm), GET ))
+#define set_connection_parameters(fd,parm)  (connection_parameters( (fd), (parm), SET ))
+
+#define get_adf_control(fd, a, b, c)      (adf_control( (fd), GET, (a), (b), (c) ))
+#define set_adf_control(fd, a, b, c)      (adf_control( (fd), SET, (a), (b), (c) ))
+
+#define RELATIVE_WHITE 0x00
+#define ABSOLUTE_WHITE 0x01
+#define get_white_balance(fd,val)  (white_balance( (fd), (val), GET ))
+#define set_white_balance(fd,val)  (white_balance( (fd), (val), SET ))
+
+#define get_scan_wait_mode(fd)      (scan_wait_mode( (fd),     0, GET ))
+#define set_scan_wait_mode(fd,val)  (scan_wait_mode( (fd), (val), SET ))
+
+#define get_service_mode(fd)      (service_mode( (fd),     0, GET ))
+#define set_service_mode(fd,val)  (service_mode( (fd), (val), SET ))
+
+#define isset_ILI(sd) ( ((sd).sense_key & 0x20) != 0)
+#define isset_EOM(sd) ( ((sd).sense_key & 0x40) != 0)
+
+
+#endif /* HS2P_H */