summaryrefslogtreecommitdiff
path: root/backend/hs2p.h
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
commit6e9c41a892ed0e0da326e0278b3221ce3f5713b8 (patch)
tree2e301d871bbeeb44aa57ff9cc070fcf3be484487 /backend/hs2p.h
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/hs2p.h')
-rw-r--r--backend/hs2p.h516
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 */