Initial import of sane-backends version 1.0.24-1.2

1 files changed, 1091 insertions, 0 deletions

diff --git a/backend/umax-scsidef.h b/backend/umax-scsidef.h
new file mode 100644
index 0000000..f192e2c
--- /dev/null
+++ b/backend/umax-scsidef.h
@@ -0,0 +1,1091 @@
+/* --------------------------------------------------------------------------------------------------------- */
+
+/* umax-scsidef.h: scsi-definiton header file for UMAX scanner driver.
+
+    Copyright (C) 1996-1997 Michael K. Johnson
+    Copyright (C) 1997-2002 Oliver Rauch
+
+    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 UMAX_SCSIDEF_H
+#define UMAX_SCSIDEF_H
+
+#include "umax.h"
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+/* I'm using functions derived from Eric Youngdale's scsiinfo
+ * program here for dealing with parts of SCSI commands.
+ */
+
+static inline void setbitfield(unsigned char * pageaddr, int mask, int shift, int val) \
+{ *pageaddr = (*pageaddr & ~(mask << shift)) | ((val & mask) << shift); }
+
+static inline void resetbitfield(unsigned char * pageaddr, int mask, int shift, int val) \
+{ *pageaddr = (*pageaddr & ~(mask << shift)) | (((!val) & mask) << shift); }
+
+static inline int getbitfield(unsigned char * pageaddr, int mask, int shift) \
+{ return ((*pageaddr >> shift) & mask); }
+
+/* ------------------------------------------------------------------------- */
+
+static inline int getnbyte(unsigned char * pnt, int nbytes) \
+{
+ unsigned int result = 0;
+ int i;
+
+  for(i=0; i<nbytes; i++)
+    result = (result << 8) | (pnt[i] & 0xff);
+  return result;
+}
+
+/* ------------------------------------------------------------------------- */
+
+static inline void putnbyte(unsigned char * pnt, unsigned int value, unsigned int nbytes) \
+{
+  int i;
+
+  for(i=nbytes-1; i>= 0; i--) \
+  {
+    pnt[i] = value & 0xff;
+    value = value >> 8;
+  }
+}
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+/* Not all of these are defined in scsi.h, so we'll make sure
+ * we agree about them here...
+ */
+#define TEST_UNIT_READY         0x00
+#define REQUEST_SENSE           0x03
+#define INQUIRY                 0x12
+#define RESERVE_UNIT            0x16
+#define RELEASE_UNIT            0x17
+#define SCAN                    0x1B
+#define SET_WINDOW              0x24
+#define READ                    0x28
+#define SEND                    0x2A
+#define OBJECT_POSITION         0x31
+#define GET_DATA_BUFFER_STATUS  0x34
+#undef  WRITE_BUFFER							 /* correct write_buffer for scanner */
+#define WRITE_BUFFER            0x3B
+#define GET_LAMP_STATUS         0x5E
+#define SET_LAMP_STATUS         0x5F
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+#define STD_WDB_LEN 0x28					     /* wdb_len if nothing is set by inquiry */
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+/* SCSI commands */
+
+typedef struct
+{
+  unsigned char *cmd;
+  size_t size;
+} scsiblk;
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+#define set_inquiry_return_size(icb,val)			icb[0x04]=val
+static unsigned char inquiryC[] = { INQUIRY, 0x00, 0x02, 0x00, 0xff, 0x00 };
+static scsiblk inquiry = { inquiryC, sizeof(inquiryC) };
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+#define get_inquiry_periph_qual(in)				getbitfield(in, 0x07, 5)
+#  define IN_periph_qual_lun		0x00
+#  define IN_periph_qual_nolun		0x03
+#define get_inquiry_periph_devtype(in)				getbitfield(in, 0x1f, 0)
+#  define IN_periph_devtype_scanner	0x06
+#  define IN_periph_devtype_unknown	0x1f
+
+#define get_inquiry_rmb(in)					getbitfield(in + 0x01, 0x01, 7)
+#define get_inquiry_0x01_bit6(in)				getbitfield(in + 0x01, 0x01, 6)
+#define get_inquiry_0x01_bit5(in)				getbitfield(in + 0x01, 0x01, 5)
+#define get_inquiry_CBHS(in)					getbitfield(in + 0x01, 0x03, 3)
+#define set_inquiry_CBHS(in, val)				setbitfield(in + 0x01, 0x03, 3, val)
+#  define IN_CBHS_50			0x00
+#  define IN_CBHS_255			0x01
+#  define IN_CBHS_auto			0x02
+#define get_inquiry_translamp(in)				getbitfield(in + 0x01, 0x01, 2)
+#define get_inquiry_transavail(in)				getbitfield(in + 0x01, 0x01, 1)
+#define get_inquiry_scanmode(in)				getbitfield(in + 0x01, 0x01, 0)
+#  define IN_flatbed			0x00
+#  define IN_adf			0x01
+
+#define get_inquiry_iso_version(in)				getbitfield(in + 0x02, 0x03, 6)
+#define get_inquiry_ecma_version(in)				getbitfield(in + 0x02, 0x07, 3)
+#define get_inquiry_ansi_version(in)				getbitfield(in + 0x02, 0x07, 0)
+
+#define get_inquiry_aenc(in)					getbitfield(in + 0x03, 0x01, 7)
+#define get_inquiry_tmiop(in)					getbitfield(in + 0x03, 0x01, 6)
+#define get_inquiry_0x03_bit5(in)				getbitfield(in + 0x03, 0x01, 5)
+#define get_inquiry_0x03_bit4(in)				getbitfield(in + 0x03, 0x01, 4)
+#define get_inquiry_response_format(in)				getbitfield(in + 0x03, 0x0f, 0)
+#  define IN_recognized			0x02
+
+#define get_inquiry_additional_length(in)			in[0x04]
+#define set_inquiry_length(out,n)				out[0x04]=n-5
+
+#define get_inquiry_0x05(in)					in[0x05]
+#define get_inquiry_0x06(in)					in[0x06]
+
+#define get_inquiry_scsi_byte(in)				in[0x07]
+#define get_inquiry_scsi_reladr(in)				getbitfield(in + 0x07, 0x01, 7)
+#define get_inquiry_scsi_wbus32(in)				getbitfield(in + 0x07, 0x01, 6)
+#define get_inquiry_scsi_wbus16(in)				getbitfield(in + 0x07, 0x01, 5)
+#define get_inquiry_scsi_sync(in)				getbitfield(in + 0x07, 0x01, 4)
+#define get_inquiry_scsi_linked(in)				getbitfield(in + 0x07, 0x01, 3)
+#define get_inquiry_scsi_R(in)					getbitfield(in + 0x07, 0x01, 2)
+#define get_inquiry_scsi_cmdqueue(in)				getbitfield(in + 0x07, 0x01, 1)
+#define get_inquiry_scsi_sftre(in)				getbitfield(in + 0x07, 0x01, 0)
+
+#define get_inquiry_vendor(in, buf)				strncpy(buf, in + 0x08, 0x08)
+#define get_inquiry_product(in, buf)				strncpy(buf, in + 0x10, 0x010)
+#define get_inquiry_version(in, buf)				strncpy(buf, in + 0x20, 0x04)
+
+#define set_inquiry_fw_quality(in, val)				setbitfield(in + 0x24, 1, 0, val)
+#define get_inquiry_fw_quality(in)				getbitfield(in + 0x24, 1, 0)
+#define get_inquiry_fw_fast_preview(in)				getbitfield(in + 0x24, 1, 1)
+#define get_inquiry_fw_shadow_comp(in)				getbitfield(in + 0x24, 1, 2)
+#define get_inquiry_fw_reselection(in)				getbitfield(in + 0x24, 1, 3)
+#define get_inquiry_fw_lamp_int_cont(in)			getbitfield(in + 0x24, 1, 4)
+#define get_inquiry_fw_batch_scan(in)				getbitfield(in + 0x24, 1, 5)
+#define get_inquiry_fw_calibration(in)				getbitfield(in + 0x24, 1, 6)
+#define get_inquiry_fw_adjust_exposure_tf(in)			getbitfield(in + 0x24, 1, 7)
+
+#define get_inquiry_exposure_time_step_unit(in)			in[0x25]
+#define get_inquiry_exposure_time_max(in)			getnbyte(in + 0x26, 2)
+#define get_inquiry_exposure_time_lhg_min(in)			in[0x2a]
+#define get_inquiry_exposure_time_color_min(in)			in[0x2b]
+#define get_inquiry_exposure_time_lh_def_fb(in)			in[0x2c]
+#define get_inquiry_exposure_time_lh_def_uta(in)		in[0x2d]
+#define get_inquiry_exposure_time_gray_def_fb(in)		in[0x2e]
+#define get_inquiry_exposure_time_gray_def_uta(in)		in[0x2f]
+#define get_inquiry_exposure_time_def_r_fb(in)			in[0x30]
+#define get_inquiry_exposure_time_def_g_fb(in)			in[0x31]
+#define get_inquiry_exposure_time_def_b_fb(in)			in[0x32]
+#define get_inquiry_exposure_time_def_r_uta(in)			in[0x33]
+#define get_inquiry_exposure_time_def_g_uta(in)			in[0x34]
+#define get_inquiry_exposure_time_def_b_uta(in)			in[0x35]
+
+#define get_inquiry_0x36(in)					in[0x36]
+#define get_inquiry_0x37(in)					in[0x37]
+
+/* bytes 0x38 - 0x5f reserved by SCSI */
+
+#define get_inquiry_sc_feature_byte0(in)			in[0x60]
+#define get_inquiry_sc_three_pass_color(in)			getbitfield(in + 0x60, 1, 0)
+#define get_inquiry_sc_one_pass_color(in)			getbitfield(in + 0x60, 1, 1)
+#define get_inquiry_sc_lineart(in)				getbitfield(in + 0x60, 1, 2)
+#define get_inquiry_sc_halftone(in)				getbitfield(in + 0x60, 1, 3)
+#define get_inquiry_sc_gray(in)					getbitfield(in + 0x60, 1, 4)
+#define get_inquiry_sc_color(in)				getbitfield(in + 0x60, 1, 5)
+#define get_inquiry_sc_uta(in)					getbitfield(in + 0x60, 1, 6)
+#define get_inquiry_sc_adf(in)					getbitfield(in + 0x60, 1, 7)
+
+#define set_inquiry_sc_three_pass_color(in,val)			setbitfield(in + 0x60, 1, 0, val)
+#define set_inquiry_sc_one_pass_color(in,val)			setbitfield(in + 0x60, 1, 1, val)
+#define set_inquiry_sc_lineart(in,val)				setbitfield(in + 0x60, 1, 2, val)
+#define set_inquiry_sc_halftone(in,val)				setbitfield(in + 0x60, 1, 3, val)
+#define set_inquiry_sc_gray(in,val)				setbitfield(in + 0x60, 1, 4, val)
+#define set_inquiry_sc_color(in,val)				setbitfield(in + 0x60, 1, 5, val)
+#define set_inquiry_sc_uta(in,val)				setbitfield(in + 0x60, 1, 6, val)
+#define set_inquiry_sc_adf(in,val)				setbitfield(in + 0x60, 1, 7, val)
+
+#define get_inquiry_sc_feature_byte1(in)			in[0x61]
+#define get_inquiry_sc_double_res(in)				getbitfield(in + 0x61, 1, 0)
+#define get_inquiry_sc_high_byte_first(in)			getbitfield(in + 0x61, 1, 1)
+#define get_inquiry_sc_bi_image_reverse(in)			getbitfield(in + 0x61, 1, 2)
+#define get_inquiry_sc_multi_image_reverse(in)			getbitfield(in + 0x61, 1, 3)
+#define get_inquiry_sc_no_shadow(in)				getbitfield(in + 0x61, 1, 4)
+#define get_inquiry_sc_no_highlight(in)				getbitfield(in + 0x61, 1, 5)
+#define get_inquiry_sc_downloadable_fw(in)			getbitfield(in + 0x61, 1, 6)
+#define get_inquiry_sc_paper_length_14(in)			getbitfield(in + 0x61, 1, 7)
+
+#define get_inquiry_sc_feature_byte2(in)			in[0x62]
+#define get_inquiry_sc_uploadable_shade(in)			getbitfield(in + 0x62, 1, 0)
+#define get_inquiry_fw_support_color(in)			getbitfield(in + 0x62, 1, 1)
+#define get_inquiry_analog_gamma(in)				getbitfield(in + 0x62, 1, 2)
+#define get_inquiry_xy_coordinate_base(in)			getbitfield(in + 0x62, 1, 3)
+#define get_inquiry_lineart_order(in)				getbitfield(in + 0x62, 1, 4)
+#define get_inquiry_start_density(in)				getbitfield(in + 0x62, 1, 5)
+#define get_inquiry_hw_x_scaling(in)				getbitfield(in + 0x62, 1, 6)
+#define get_inquiry_hw_y_scaling(in)				getbitfield(in + 0x62, 1, 7)
+
+#define get_inquiry_sc_feature_byte3(in)			in[0x63]
+#define get_inquiry_ADF_no_paper(in)				getbitfield(in + 0x63, 1, 0)
+#define get_inquiry_ADF_cover_open(in)				getbitfield(in + 0x63, 1, 1)
+#define get_inquiry_ADF_paper_jam(in)				getbitfield(in + 0x63, 1, 2)
+#define get_inquiry_0x63_bit3(in)				getbitfield(in + 0x63, 1, 3)
+#define get_inquiry_0x63_bit4(in)				getbitfield(in + 0x63, 1, 4)
+#define get_inquiry_lens_cal_in_doc_pos(in)			getbitfield(in + 0x63, 1, 5)
+#define get_inquiry_manual_focus(in)				getbitfield(in + 0x63, 1, 6)
+#define get_inquiry_sel_uta_lens_cal_pos(in)			getbitfield(in + 0x63, 1, 7)
+
+#define get_inquiry_gamma_download_available(in)		getbitfield(in + 0x64, 1, 7)
+#define get_inquiry_0x64_bit6(in)				getbitfield(in + 0x64, 1, 6)
+#define get_inquiry_gamma_type_2(in)				getbitfield(in + 0x64, 1, 5)
+#define get_inquiry_0x64_bit4(in)				getbitfield(in + 0x64, 1, 4)
+#define get_inquiry_0x64_bit3(in)				getbitfield(in + 0x64, 1, 3)
+#define get_inquiry_0x64_bit2(in)				getbitfield(in + 0x64, 1, 2)
+#define get_inquiry_gamma_lines(in)				getbitfield(in + 0x64, 0x03, 0)
+#  define IN_3_pass			0x01
+#  define IN_3_line			0x03
+
+#define get_inquiry_0x65(in)					in[0x65]
+
+#define get_inquiry_gib(in)					in[0x66]
+#define get_inquiry_gib_8bpp(in)				getbitfield(in + 0x66, 1, 0) 
+#define get_inquiry_gib_9bpp(in)				getbitfield(in + 0x66, 1, 1)
+#define get_inquiry_gib_10bpp(in)				getbitfield(in + 0x66, 1, 2) 
+#define get_inquiry_gib_12bpp(in)				getbitfield(in + 0x66, 1, 3)
+#define get_inquiry_gib_14bpp(in)				getbitfield(in + 0x66, 1, 4)
+#define get_inquiry_gib_16bpp(in)				getbitfield(in + 0x66, 1, 5)
+#define get_inquiry_0x66_bit6(in)				getbitfield(in + 0x66, 1, 6)
+#define get_inquiry_0x66_bit7(in)				getbitfield(in + 0x66, 1, 7)
+#  define IN_gib_8bpp			0x01
+#  define IN_gib_10bpp			0x04
+
+#define get_inquiry_0x67(in)					in[0x67]
+
+#define get_inquiry_gob(in)					in[0x68]
+#define get_inquiry_gob_8bpp(in)				getbitfield(in + 0x68, 1, 0) 
+#define get_inquiry_gob_9bpp(in)				getbitfield(in + 0x68, 1, 1)
+#define get_inquiry_gob_10bpp(in)				getbitfield(in + 0x68, 1, 2) 
+#define get_inquiry_gob_12bpp(in)				getbitfield(in + 0x68, 1, 3)
+#define get_inquiry_gob_14bpp(in)				getbitfield(in + 0x68, 1, 4)
+#define get_inquiry_gob_16bpp(in)				getbitfield(in + 0x68, 1, 5)
+#define get_inquiry_0x68_bit6(in)				getbitfield(in + 0x68, 1, 6)
+#define get_inquiry_0x68_bit7(in)				getbitfield(in + 0x68, 1, 7)
+#  define IN_gob_8bpp			0x01
+#  define IN_gob_10bpp			0x04
+
+#define get_inquiry_hda(in)					getbitfield(in + 0x69, 0x01, 7)
+#define get_inquiry_max_halftone_matrix(in)			getbitfield(in + 0x69, 0x7f, 0)
+#define get_inquiry_halftones_supported(in)			in[0x6a]
+#define get_inquiry_halftones_2x2(in)				getbitfield(in + 0x6a, 1, 0)
+#define get_inquiry_halftones_4x4(in)				getbitfield(in + 0x6a, 1, 1)
+#define get_inquiry_halftones_6x6(in)				getbitfield(in + 0x6a, 1, 2)
+#define get_inquiry_halftones_8x8(in)				getbitfield(in + 0x6a, 1, 3)
+#define get_inquiry_halftones_12x12(in)				getbitfield(in + 0x6a, 1, 5)
+#  define IN_halftone_2x2		0x01
+#  define IN_halftone_4x4		0x02
+#  define IN_halftone_6x6		0x04
+#  define IN_halftone_8x8		0x08
+#  define IN_halftone_12x12		0x20
+
+#define get_inquiry_0x6b(in)					in[0x6b]
+#define get_inquiry_0x6c(in)					in[0x6c]
+
+#define get_inquiry_colorseq(in)				getbitfield(in + 0x6d, 0x07, 5)
+#  define IN_color_sequence_RGB		0x00
+#  define IN_color_sequence_RBG		0x01
+#  define IN_color_sequence_GBR		0x02
+#  define IN_color_sequence_GRB		0x03
+#  define IN_color_sequence_BRG		0x04
+#  define IN_color_sequence_BGR		0x05
+#  define IN_color_sequence_all		0x07
+#define get_inquiry_color_order(in)				getbitfield(in + 0x6d, 0x1f, 0)
+#define set_inquiry_color_order(in,val)				setbitfield(in + 0x6d, 0x1f, 0, val)
+#define get_inquiry_color_order_pixel(in)			getbitfield(in + 0x6d, 1, 0)
+#define get_inquiry_color_order_line_no_ccd(in)			getbitfield(in + 0x6d, 1, 1)
+#define get_inquiry_color_order_plane(in)			getbitfield(in + 0x6d, 1, 2)
+#define get_inquiry_color_order_line_w_ccd(in)			getbitfield(in + 0x6d, 1, 3)
+#define get_inquiry_color_order_reserved(in)			getbitfield(in + 0x6d, 1, 4)
+#  define IN_color_ordering_pixel	0x01
+#  define IN_color_ordering_line_no_ccd	0x02
+#  define IN_color_ordering_plane	0x04
+#  define IN_color_ordering_line_w_ccd	0x08
+
+#define get_inquiry_max_vidmem(in)				getnbyte(in + 0x6e, 4)
+
+#define get_inquiry_0x72(in)					in[0x72]
+#define get_inquiry_max_opt_res(in)				in[0x73]
+#define get_inquiry_max_x_res(in)				in[0x74]
+#define get_inquiry_max_y_res(in)				in[0x75]
+#define get_inquiry_fb_max_scan_width(in)			getnbyte(in + 0x76, 2)
+#define get_inquiry_fb_max_scan_length(in)			getnbyte(in + 0x78, 2)
+#define get_inquiry_uta_x_original_point(in)			getnbyte(in + 0x7a, 2)
+#define get_inquiry_uta_y_original_point(in)			getnbyte(in + 0x7c, 2)
+#define get_inquiry_uta_max_scan_width(in)			getnbyte(in + 0x7e, 2)
+#define get_inquiry_uta_max_scan_length(in)			getnbyte(in + 0x80, 2)
+
+#define get_inquiry_0x82(in)					in[0x82]
+
+#define get_inquiry_dor_max_opt_res(in)				in[0x83]
+#define get_inquiry_dor_max_x_res(in)				in[0x84]
+#define get_inquiry_dor_max_y_res(in)				in[0x85]
+
+#define get_inquiry_dor_x_original_point(in)			getnbyte(in + 0x86, 2)
+#define get_inquiry_dor_y_original_point(in)			getnbyte(in + 0x88, 2)
+#define get_inquiry_dor_max_scan_width(in)			getnbyte(in + 0x8a, 2)
+#define get_inquiry_dor_max_scan_length(in)			getnbyte(in + 0x8c, 2)
+
+#define get_inquiry_0x8e(in)					in[0x8e]
+
+#define get_inquiry_last_calibration_lamp_density(in)		in[0x8f]
+#  define IN_min_lamp_density		0x01
+#  define IN_max_lamp_density		0xff
+
+#define get_inquiry_0x90(in)					in[0x90]
+
+#define get_inquiry_lamp_warmup_maximum_time(in)		in[0x91]
+#define get_inquiry_wdb_length(in)				getnbyte(in + 0x92, 2)
+#define get_inquiry_optical_resolution_residue(in)		in[0x94]
+#define get_inquiry_x_resolution_residue(in)			in[0x95]
+#define get_inquiry_y_resolution_residue(in)			in[0x96]
+#define get_inquiry_analog_gamma_table(in)			in[0x97]
+
+#define get_inquiry_0x98(in)					in[0x98]
+#define get_inquiry_0x99(in)					in[0x99]
+
+#define get_inquiry_max_calibration_data_lines(in)		in[0x9a]
+#define get_inquiry_fb_uta_line_arrangement_mode(in)		in[0x9b]
+#define get_inquiry_adf_line_arrangement_mode(in)		in[0x9c]
+#define get_inquiry_CCD_line_distance(in)			in[0x9d]
+
+#define set_inquiry_max_calibration_data_lines(out,val)		out[0x9a]=val
+#define set_inquiry_fb_uta_line_arrangement_mode(out,val)	out[0x9b]=val
+#define set_inquiry_adf_line_arrangement_mode(out,val)		out[0x9c]=val
+#define set_inquiry_CCD_line_distance(out,val)			out[0x9d]=val
+
+#define get_inquiry_0x9e(in)					in[0x9e]
+
+#define get_inquiry_dor_optical_resolution_residue(in)		in[0xa0]
+#define get_inquiry_dor_x_resolution_residue(in)		in[0xa1]
+#define get_inquiry_dor_y_resolution_residue(in)		in[0xa2]
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+/* although the command is defined with 6 bytes length in the doc, 10 bytes seems to be the correct length */
+static unsigned char get_lamp_statusC[] = { GET_LAMP_STATUS, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+static scsiblk get_lamp_status = { get_lamp_statusC,sizeof(get_lamp_statusC) };
+#define get_lamp_status_lamp_on(in)		getbitfield(in, 1, 0)
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+/* although the command is defined with 6 bytes length in the doc, 10 bytes seems to be the correct length */
+static unsigned char set_lamp_statusC[] = { SET_LAMP_STATUS, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+static scsiblk set_lamp_status = { set_lamp_statusC,sizeof(set_lamp_statusC) };
+#define set_lamp_status_lamp_on(in,val)		setbitfield(in + 0x03, 1, 7, val)
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+static unsigned char test_unit_readyC[] = { TEST_UNIT_READY, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+static scsiblk test_unit_ready = { test_unit_readyC,sizeof(test_unit_readyC) };
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+static unsigned char reserve_unitC[] = { RESERVE_UNIT, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+static scsiblk reserve_unit = { reserve_unitC, sizeof(reserve_unitC) };
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+static unsigned char release_unitC[] = { RELEASE_UNIT, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+static scsiblk release_unit = { release_unitC, sizeof(release_unitC) };
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+static unsigned char set_windowC[] =
+{
+  SET_WINDOW, 0x00,		/* opcode, lun */
+  0x00, 0x00, 0x00, 0x00,	/* reserved */
+  0x00, 0x00, 0x00,		/* transfer length; needs to be set */
+  0x00				/* control byte */
+};
+
+#define set_SW_xferlen(sb, len)				putnbyte(sb + 0x06, len, 3)
+
+static scsiblk set_window = { set_windowC, sizeof(set_windowC) };
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+static unsigned char window_parameter_data_blockC[] =
+{
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,	/* reserved */
+  0x00, 0x00				/* Window Descriptor Length, value must be set by SHORT_WDB define */
+};
+
+#define set_WPDB_wdblen(sb, len)			putnbyte(sb + 0x06, len, 2)
+
+
+static scsiblk window_parameter_data_block =
+{ window_parameter_data_blockC, sizeof(window_parameter_data_blockC) };
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+static unsigned char window_descriptor_blockC[] =
+{
+#define max_WDB_size 0xff
+#define used_WDB_size 0x53
+
+/* 0x00 */  0x00,									/* Window Identifier */
+#define set_WD_wid(sb, val)				sb[0] = val
+#  define WD_wid_bw			0x00
+#  define WD_wid_red			0x01
+#  define WD_wid_green			0x02
+#  define WD_wid_blue			0x03
+#  define WD_wid_all			0x00
+/* 0x01 */  0x00,									   /* reserved, AUTO */
+#define set_WD_auto(sb, val)				setbitfield(sb + 0x01, 1, 0, val)
+
+/* 0x02 */  0x00, 0x00,								      /* X Resolution in dpi */
+#define set_WD_Xres(sb, val)				putnbyte(sb + 0x02, val, 2)
+
+/* 0x04 */  0x00, 0x00,								      /* Y Resolution in dpi */
+#define set_WD_Yres(sb, val)				putnbyte(sb + 0x04, val, 2)
+
+/* 0x06 */  0x00, 0x00, 0x00, 0x00,					      /* Upper Left X in 1200pt/inch */
+#define set_WD_ULX(sb, val)				putnbyte(sb + 0x06, val, 4)
+
+/* 0x0a */  0x00, 0x00, 0x00, 0x00,					      /* Upper Left Y in 1200pt/inch */
+#define set_WD_ULY(sb, val)				putnbyte(sb + 0x0a, val, 4)
+
+/* 0x0e */  0x00, 0x00, 0x00, 0x00,							/* Width 1200pt/inch */
+#define set_WD_width(sb, val)				putnbyte(sb + 0x0e, val, 4)
+
+/* 0x12 */  0x00, 0x00, 0x00, 0x00,						       /* Length 1200pt/inch */
+#define set_WD_length(sb, val)				putnbyte(sb + 0x12, val, 4)
+
+/* 0x16 */  0xff,									       /* Brightness */
+#define set_WD_brightness(sb, val)			sb[0x16] = val
+
+/* 0x17 */  0x80,										/* Threshold */
+#define set_WD_threshold(sb, val)			sb[0x17] = val
+
+/* 0x18 */  0x80,										 /* Contrast */
+#define set_WD_contrast(sb, val)			sb[0x18] = val
+
+/* 0x19 */  0x05,									/* Image Composition */
+#define set_WD_composition(sb, val)			sb[0x19] = val
+#  define WD_comp_lineart		0x00
+#  define WD_comp_dithered		0x01
+#  define WD_comp_gray			0x02
+#  define WD_comp_gray			0x02
+#  define WD_comp_rgb_bilevel		0x03
+#  define WD_comp_rgb_dithered		0x04
+#  define WD_comp_rgb_full      	0x05
+
+/* 0x1a */  0x08,									       /* Bits/Pixel */
+#define set_WD_bitsperpixel(sb, val)			sb[0x1a] = val
+#  define WD_bits_1			0x01
+#  define WD_bits_8			0x08
+#  define WD_bits_10			0x0a
+
+/* 0x1b */  0x00, 0x03,									 /* Halftone pattern */
+#define set_WD_halftone(sb, val)			putnbyte(sb + 0x1b, val, 2)
+#  define WD_halftone_download		0x00
+#  define WD_halftone_12x12_1		0x01
+#  define WD_halftone_12x12_2		0x02
+#  define WD_halftone_8x8_1		0x03
+#  define WD_halftone_8x8_2		0x04
+#  define WD_halftone_8x8_3		0x05
+#  define WD_halftone_8x8_4		0x06
+#  define WD_halftone_8x8_5		0x07
+#  define WD_halftone_6x6_1		0x08
+#  define WD_halftone_6x6_2		0x09
+#  define WD_halftone_6x6_3		0x0a
+#  define WD_halftone_4x4_1		0x0b
+#  define WD_halftone_4x4_2		0x0c
+#  define WD_halftone_4x4_3		0x0d
+#  define WD_halftone_2x2_1		0x0e
+#  define WD_halftone_2x2_2		0x0f
+
+/* 0x1d */  0x03,							      /* RIF, reserved, padding type */
+#define set_WD_RIF(sb, val)				setbitfield(sb + 0x1d, 1, 7, val)
+#define set_WD_padding_type(sb,val)			setbitfield(sb + 0x1d, 0x07, 0, val)
+#  define WD_padding_byte		0x03
+#  define WD_padding_word		0x07
+
+/* 0x1e */  0x00, 0x00,							/* Bit Ordering (0 = left to right;) */
+/* 0x20 */  0x00,							      /* Compression Type (reserved) */
+/* 0x21 */  0x00,							       /* Compr. Argument (reserved) */
+/* 0x22 */  0x00, 0x00, 0x00, 0x00, 0x00, 0x00,							 /* Reserved */
+/* 0x28 */  0x01,										    /* Speed */
+#define set_WD_speed(sb, val)				sb[0x28] = val
+#  define WD_speed_fastsmear		0x81
+#  define WD_speed_slowsmear		0x82
+#  define WD_speed_fastclear		0x01
+#  define WD_speed_slowclear		0x02
+#  define WD_speed_speedbit		0x03
+#  define WD_speed_smearbit		0x80
+#    define WD_speed_fast		0x01
+#    define WD_speed_slow		0x02
+#    define WD_speed_smear		0x80
+
+/* 0x29 */  0x00,									     /* Select Color */
+#define set_WD_select_color(sb,val)			setbitfield(sb+0x29, 0x07, 5, val)
+#  define WD_color_gray			0x00
+#  define WD_color_red			0x04
+#  define WD_color_green		0x02
+#  define WD_color_blue			0x01
+
+/* 0x2a */  0xff,										/* Highlight */
+#define set_WD_highlight(sb, val)			sb[0x2a] = val
+
+/* 0x2b */  0x00,										   /* Shadow */
+#define set_WD_shadow(sb, val)				sb[0x2b] = val
+
+/* 0x2c */  0x00, 0x00,									     /* Paper Length */
+#define set_WD_paperlength(sb, val)			putnbyte(sb + 0x2c, val, 2)
+
+/* 0x2e */  0x0f,									   /* Gamma Function */
+#define set_WD_gamma(sb, val)				sb[0x2e] = val
+#  define WD_gamma_download		0x00
+#  define WD_gamma_builtin1		0x01
+#  define WD_gamma_builtin2		0x02
+#  define WD_gamma_builtin3		0x03
+#  define WD_gamma_builtin4		0x04
+#  define WD_gamma_normal		0x0f
+
+/* 0x2f */  0x11,									      /* Scan Module */
+#define set_WD_module(sb, val)				sb[0x2f] = val
+#  define WD_module_flatbed		0x11
+#  define WD_module_transparency	0xff
+
+/* 0x30 */  0x01,						      /* HBT, DOR, reserved, RMIF, CBHS Type */
+							   /* CBHS = Contrast, Brightness, Highlight, Shadow */
+#define set_WD_CBHS(sb, val)				setbitfield(sb + 0x30, 1, 0, val)
+#  define WD_CBHS_50			0
+#  define WD_CBHS_255			1
+#define set_WD_FF(sb, val)				setbitfield(sb + 0x30, 1, 1, val) /* FF = Fix Focus position */
+#define set_WD_RMIF(sb, val)				setbitfield(sb + 0x30, 1, 2, val) /* Reverse Multil Image Frmt */
+#define set_WD_FDC(sb, val)				setbitfield(sb + 0x30, 1, 3, val) /* document calibration */
+#define set_WD_PF(sb, val)				setbitfield(sb + 0x30, 1, 4, val) /* PF pre focus */
+#define set_WD_LCL(sb, val)				setbitfield(sb + 0x30, 1, 5, val) /* LCL (focus position) */
+#define set_WD_DOR(sb, val)				setbitfield(sb + 0x30, 1, 6, val) /* Double Optical Resolution */
+#define set_WD_HBT(sb, val)				setbitfield(sb + 0x30, 1, 7, val) /* High Byte Transfer */
+#  define WD_HBT_HBF			0x00
+#  define WD_HBT_LBF			0x01
+
+/* 0x31 */  0x00, 0x00,								      /* scan exposure level */
+#define set_WD_scan_exposure_level(sb, val)		putnbyte(sb+0x31, val, 2)
+
+/* 0x33 */  0x00, 0x00,							       /* calibration exposure level */
+#define set_WD_calibration_exposure_level(sb, val)	putnbyte(sb+0x33, val, 2)
+
+/* 0x35 */  0x00,										 /* reserved */
+/* 0x36 */  0x00,										 /* reserved */
+/* 0x37 */  0x00,										 /* reserved */
+/* 0x38 */  0x00,							      /* reserved (For Autoexposure) */
+
+/* 0x39 */  0x00,							   /* BS, reserved, Calibration Mode */
+#define set_WD_batch(sb, val)				setbitfield(sb + 0x39, 1, 7, val)
+#define set_WD_MF(sb, val)				setbitfield(sb + 0x39, 1, 6, val) /* manual focus */
+#define set_WD_line_arrangement(sb, val)		setbitfield(sb + 0x39, 1, 5, val)
+#  define WD_line_arrengement_by_driver	0x01
+#  define WD_line_arrengement_by_fw	0x00
+#define set_WD_warmup(sb, val)				setbitfield(sb + 0x39, 1, 4, val)
+#define set_WD_calibration(sb, val)			setbitfield(sb + 0x39, 0x0f, 0, val)
+#  define WD_calibration_image		0x00
+#  define WD_calibration_lineart	0x0f
+#  define WD_calibration_dither		0x0e
+#  define WD_calibration_gray		0x0d
+#  define WD_calibration_rgb		0x0a 
+#  define WD_calibration_ignore		0x09
+
+/* 0x3a */  0x01,						   /* Color Sequence, Color Ordering Support */
+#define set_WD_color_sequence(sb,val)			setbitfield(sb+0x3a,0x07,5, val)
+#  define WD_color_sequence_RGB  0x00
+#  define WD_color_sequence_RBG  0x01
+#  define WD_color_sequence_GBR  0x02
+#  define WD_color_sequence_GRB  0x03
+#  define WD_color_sequence_BRG  0x04
+#  define WD_color_sequence_BGR  0x05
+
+#define set_WD_color_ordering(sb,val)			setbitfield(sb+0x3a,0x1f,0, val)
+#  define WD_color_ordering_pixel       0x01
+#  define WD_color_ordering_line_no_ccd 0x02
+#  define WD_color_ordering_plane       0x04
+#  define WD_color_ordering_line_w_ccd  0x08
+
+/* 0x3b */  0x00,							   /* analog gamma code (set to 1.0) */
+#define set_WD_analog_gamma(sb, gamma)			sb[0x3b] = gamma	   /* see analog_gamma_table */
+
+/* 0x3c */  0x00,										 /* Reserved */
+
+/* 0x3d */  0x00,							    /* Next Calibration Lamp Density */
+#define set_WD_lamp_c_density(sb, val)			sb[0x3d] = val
+#  define WD_lamp_c_density_auto	0x00
+#  define WD_lamp_c_density_min		0x01
+#  define WD_lamp_c_density_max		0xff
+
+/* 0x3e */  0x00,										 /* Reserved */
+
+/* 0x3f */  0x00,								   /* Next Scan Lamp Density */
+#define set_WD_lamp_s_density(sb, val)			sb[0x3f] = val
+#  define WD_lamp_s_density_auto	0x00
+#  define WD_lamp_s_density_min		0x01
+#  define WD_lamp_s_density_max		0xff
+
+/* 0x40 */  0x00, 0x00, 0x00, 0x00,				       /* Next Upper Left Y in 1200 dpt/inch */
+#define set_WD_next_upper_left(sb, val)			putnbyte(sb + 0x40, val, 4)
+
+/* 0x44 */  0x00, 0x00, 0x00, 0x00,							      /* Pixel Count */
+#define set_WD_pixel_count(sb, val)			putnbyte(sb + 0x44, val, 4)
+
+/* 0x48 */  0x00, 0x00, 0x00, 0x00,							       /* Line Count */
+#define set_WD_line_count(sb, val)			putnbyte(sb + 0x48, val, 4)
+
+/* 0x4c */  4, 176,							/* x coordiante base 1200 (pts/inch) */
+#define set_WD_x_coordinate_base(sb, val)		putnbyte(sb + 0x4c, val, 2)
+
+/* 0x4e */  4, 176,							/* y coordinate base 1200 (pts/inch) */
+#define set_WD_y_coordinate_base(sb, val)		putnbyte(sb + 0x4e, val, 2)
+
+/* 0x50 */  0x00,										 /* reserved */
+
+/* 0x51 */  0x00,						 /* driver calibration need image data lines */
+#define set_WD_calibration_data_lines(sb, val)		sb[0x51] = val
+
+/* 0x52 */  0x00									    /* start density */
+#define set_WD_start_density(sb, val)			sb[0x52] = val
+
+/* if somone adds here anything, please change used_WDB_size in this file !! */
+};
+
+
+static scsiblk window_descriptor_block = { window_descriptor_blockC, sizeof(window_descriptor_blockC) };
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+ 
+#define set_WDB_length(length)				(window_descriptor_block.size = (length))
+
+#define WPDB_OFF(b)					(b + set_window.size)
+
+#define WDB_OFF(b, n)					(b + set_window.size + \
+							window_parameter_data_block.size + \
+							( window_descriptor_block.size * (n - 1) ) )
+
+#define set_WPDB_wdbnum(sb,n)				set_WPDB_wdblen(sb,window_descriptor_block.size*n)
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+static unsigned char scanC[] = { SCAN, 0x00, 0x00, 0x00, 0x01, 0x20, 0x00, 0x00, 0x00 };
+
+static scsiblk scan = { scanC, sizeof(scanC) - 3 };
+#define set_SC_xfer_length(sb, val)			sb[0x04] = val
+#define set_SC_quality(sb, val)				setbitfield(sb + 0x05, 1, 5, val)
+#define set_SC_adf(sb, val)				setbitfield(sb + 0x05, 1, 6, val)
+#define set_SC_preview(sb, val)				setbitfield(sb + 0x05, 1, 7, val)
+#define set_SC_wid(sb, n, val)				sb[0x05 + n] = val 
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+/* sread instead of read because read is a libc primitive */
+static unsigned char sreadC[] = { READ, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+static scsiblk sread = { sreadC, sizeof(sreadC) };
+
+#define set_R_datatype_code(sb, val)			sb[0x02] = val
+#  define R_datatype_imagedata		0x00
+#  define R_datatype_vendorspecific	0x01
+#  define R_datatype_halftone		0x02
+#  define R_datatype_gamma		0x03
+#  define R_datatype_shading		0x80
+#  define R_datatype_gain		0x81
+
+#define set_R_datatype_qual_winid(sb, val)		sb[0x05] = val
+#define set_R_xfer_length(sb, val)			putnbyte(sb + 0x06, val, 3)
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+static unsigned char sendC[] = { SEND, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+static scsiblk send = { sendC, sizeof(sendC) };
+
+#define set_S_datatype_code(sb, val)			sb[0x02] = val
+#  define S_datatype_imagedata		0x00
+#  define S_datatype_vendorspecific	0x01
+#  define S_datatype_halftone		0x02
+#  define S_datatype_gamma		0x03
+#  define S_datatype_shading		0x80
+#  define S_datatype_gain		0x81
+
+#define set_S_datatype_qual_winid(sb, val)		sb[0x05] = val
+
+#define set_S_xfer_length(sb, val)			putnbyte(sb + 0x06, val, 3)
+#  define S_xfer_length_gamma(l)	((l * (1024 + 1)) + 1)
+#  define S_xfer_length_1line		0x0402
+#  define S_xfer_length_2line		0x0803
+#  define S_xfer_length_3line		0x0c04
+
+/* FIXME: add Type 0 download curve format */
+/* FIXME: add Type 1 download curve format */
+
+
+static unsigned char gamma_DCF0C[] = { 0x00 };
+static scsiblk gamma_DCF0 = { gamma_DCF0C, sizeof(gamma_DCF0C) };
+#define set_DCF0_gamma_color(dc,col,val)		dc[1 + (1025 * col)] = val
+#  define DCF0_gamma_color_gray		0
+#  define DCF0_gamma_color_red		1
+#  define DCF0_gamma_color_green	2
+#  define DCF0_gamma_color_blue		3
+
+#define set_DCF0_gamma_lines(dc,val)			setbitfield(dc + 0x00, 3, 0, val)
+#  define DCF0_gamma_one_line		1
+#  define DCF0_gamma_three_lines	3
+
+
+static unsigned char gamma_DCF1C[] = { 0x00, 0x00 };
+static scsiblk gamma_DCF1 = { gamma_DCF1C, sizeof(gamma_DCF1C) };
+#define set_DCF1_gamma_color(dc,val)			dc[1] = val
+#  define DCF1_gamma_color_gray		0
+#  define DCF1_gamma_color_red		1
+#  define DCF1_gamma_color_green	2
+#  define DCF1_gamma_color_blue		3
+
+
+static unsigned char gamma_DCF2C[] = { 0x21, 0x00, 0x01, 0x00, 0x01, 0x00 };
+static scsiblk gamma_DCF2 = { gamma_DCF2C, sizeof(gamma_DCF2C) };
+
+#define set_DCF2_gamma_color(dc,val)			setbitfield(dc + 0x00, 3, 2, val)
+#  define DCF2_gamma_color_gray		0
+#  define DCF2_gamma_color_red		1
+#  define DCF2_gamma_color_green	2
+#  define DCF2_gamma_color_blue		3
+
+#define set_DCF2_gamma_lines(dc,val)			setbitfield(dc + 0x00, 3, 0, val)
+#  define DCF2_gamma_one_line		1
+#  define DCF2_gamma_three_lines	3
+
+#define set_DCF2_gamma_input_bits(dc,val)		dc[0x02]=val
+#define set_DCF2_gamma_output_bits(dc,val)		dc[0x04]=val
+#  define DCF2_gamma_8_bits		1
+#  define DCF2_gamma_10_bits		4
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+static unsigned char object_positionC[] =
+{ OBJECT_POSITION, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+static scsiblk object_position = { object_positionC, sizeof(object_positionC) };
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+#ifndef UMAX_HIDE_UNUSED
+static unsigned char get_data_buffer_statusC[] =
+{
+  GET_DATA_BUFFER_STATUS, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x00 };
+
+#define set_GDBS_wait(sb, val)				setbitfield(sb + 0x01, 1, 0, val)
+#define set_GDBS_len(sb, nwins)				putnbyte(sb + 0x07, (4 + (nwins * 8)), 2)
+
+static scsiblk get_data_buffer_status = { get_data_buffer_statusC, sizeof(get_data_buffer_statusC) };
+
+  /* DBS is Data Buffer Status, the header that is returned */
+#define get_DBS_data_buffer_status_length(sb)		getnbyte(sb, 3)
+#define get_DBSD_block_bit(sb)				getbitfield(sb + 3, 1, 0)
+
+  /* DBSD are the Data Buffer Status Descriptors, the records that
+   * are returned following the DBS header. */
+  /* order is the number of the DBSD, from 1 to (length/8) */
+#define get_DBSD_winid(sb, order)			sb[4 + ((order - 1) * 8)]
+#define get_DBSD_available_data_buffer(sb,order)	getnbyte(sb+4+((order-1)*8)+2,3)
+#define get_DBSD_filled_data_buffer(sb,order)		getnbyte(sb+4+((order-1)*8)+5,3)
+
+#define gdbs_return_block_size 12
+#endif
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+#ifndef UMAX_HIDE_UNUSED
+ static unsigned char write_bufferC[] =
+ { WRITE_BUFFER, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
+
+ static scsiblk write_buffer = { write_bufferC, sizeof(write_bufferC) };
+#endif
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+static double analog_gamma_table[16]={1.0000, 1.0434, 1.0887, 1.1361, \
+                                     1.1859, 1.2382, 1.2933, 1.3516, \
+                                     1.4134, 1.4792, 1.5495, 1.6251, \
+                                     1.7067, 1.7954, 1.8926, 2.0000 };
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+static unsigned char request_senseC[] = { REQUEST_SENSE, 0x00, 0x00, 0x00, 0x00, 0x00 };
+#define set_RS_allocation_length(sb,val)		sb[0x04]=val
+#define set_RS_LUN(sb,val)				setbitfield(sb + 0x01, 7, 5) /* ??? */
+
+static scsiblk request_sense = { request_senseC, sizeof(request_senseC) };
+
+/* defines for request sense return block */
+#define get_RS_information_valid(b)			getbitfield(b + 0x00, 1, 7)
+#define get_RS_error_code(b)				getbitfield(b + 0x00, 0x7f, 0)
+#define get_RS_filemark(b)				getbitfield(b + 0x02, 1, 7)
+#define get_RS_EOM(b)					getbitfield(b + 0x02, 1, 6)
+#define get_RS_ILI(b)					getbitfield(b + 0x02, 1, 5)
+#define get_RS_sense_key(b)				getbitfield(b + 0x02, 0x0f, 0) 
+#define get_RS_information(b)				getnbyte(b+0x03, 4) 
+#define get_RS_additional_length(b)			b[0x07]
+#define get_RS_ASC(b)					b[0x0c]
+#define get_RS_ASCQ(b)					b[0x0d]
+#define get_RS_SKSV(b)					getbitfield(b+0x0f,1,7)   /* valid */ 
+#define get_RS_CD(b)					getbitfield(b+0x0f,1,6)   /* 1=CDB */
+#define get_RS_field_pointer(b)				getnbyte(b+0x10, 2)
+
+#define get_RS_additional_sense(b)			getnbyte(b+0x12, 2)
+#define get_RS_asb_dim_light(b)				getbitfield(b+0x12,1,7)
+#define get_RS_asb_no_light(b)				getbitfield(b+0x12,1,6)
+#define get_RS_asb_sensor_motor(b)			getbitfield(b+0x12,1,5)
+#define get_RS_asb_too_light(b)				getbitfield(b+0x12,1,4)
+#define get_RS_asb_calibration(b)			getbitfield(b+0x12,1,3)
+#define get_RS_asb_rom(b)				getbitfield(b+0x12,1,2)
+#define get_RS_asb_ram(b)				getbitfield(b+0x12,1,1)
+#define get_RS_asb_cpu(b)				getbitfield(b+0x12,1,0)
+#define get_RS_asb_scsi(b)				getbitfield(b+0x13,1,7)
+#define get_RS_asb_timer(b)				getbitfield(b+0x13,1,6)
+#define get_RS_asb_filter_motor(b)			getbitfield(b+0x13,1,5)
+#define get_RS_asb_dc_adjust(b)				getbitfield(b+0x13,1,1)
+#define get_RS_asb_uta_sensor(b)			getbitfield(b+0x13,1,0)
+
+#define get_RS_scanner_error_code(b)			b[0x15]
+#define get_RS_SCC_condition_code(b)			b[0x17]
+#define get_RS_SCC_calibration_bytesperline(b)		getnbyte(b+0x18, 4)
+#define get_RS_SCC_calibration_lines(b)			getnbyte(b+0x1c, 2)
+#define get_RS_SCC_calibration_bytespp(b)		b[0x1e]
+
+#define rs_return_block_size		0x1f
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+static char *cbhs_str[]       = { "0-50","0-255", "0-255 autoexposure", "reserved" };
+
+static char *scanmode_str[]   = { "flatbed (FB)", "automatic document feeder (ADF)" };
+
+static char *gamma_lines_str[]= { "reserved",
+                            "one line (gray), three pass (color) download",
+                            "reserved",
+                            "one line (gray), three lines (color) download" };
+
+static char *color_sequence_str[]= { "R->G->B","R->B->G",
+                                     "G->B->R","G->R->B",
+                                     "B->R->G","B->G->R",
+                                     "reserved","all supported"};
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+static char *sense_str[] = {"NO SENSE",
+                            "RECOVERED ERROR",
+                            "NOT READY",
+                            "MEDIUM ERROR",
+                            "HARDWARE ERROR",
+                            "ILLEGAL REQUEST",
+                            "UNIT ATTENTION",
+                            "DATA PROTECT",
+                            "BLANK CHECK",
+                            "VENDOR SPECIFIC",
+			    "COPY ABORTED",
+                            "ABORTED COMMAND",
+                            "EQUAL",
+                            "VOLUME OVERFLOW",
+                            "MISCOMPARE",
+                            "??? - SENSE 0FH" };
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+static char *scanner_error_str[] =
+{"no error",      /* 0 */
+ "CPU error",
+ "err 2",
+ "err 3",
+ "ROM error",
+ "err 5",
+ "err 6",
+ "err 7",
+ "err 8",
+ "err 9",
+ "buffer error",        /* 10 */
+ "system buffer error",
+ "shading buffer error",
+ "video buffer error",
+ "stack buffer error",
+ "control buffer error",
+ "gamma buffer error",
+ "err 17",
+ "err 18",
+ "err 19",
+ "lamp error",          /* 20 */
+ "dark error",
+ "dim error",
+ "light error",
+ "lamp adjust control error (by darken)",
+ "err 25",
+ "err 26",
+ "err 27",
+ "err 28",
+ "err 29",
+ "calibration error",   /* 30 */
+ "dc offset error",
+ "gain error",
+ "auto focus error",
+ "err 34",
+ "err 35",
+ "err 36",
+ "err 37",
+ "err 38",
+ "err 39",
+ "scsi error",          /* 40 */
+ "err 41",
+ "asic error",
+ "timer error",
+ "ccd error",
+ "err 45",
+ "err 46",
+ "err 47",
+ "err 48",
+ "err 49",
+ "uta error",           /* 50 */
+ "uta home or motor sensor error",
+ "err 52",
+ "err 53",
+ "err 54",
+ "err 55",
+ "err 56",
+ "err 57",
+ "err 58",
+ "err 59",
+ "adf error",           /* 60 */
+ "adf paper jam",
+ "adf no paper",
+ "adf cover open",
+ "err 64",
+ "err 65",
+ "err 66",
+ "err 67",
+ "err 68",
+ "err 69",
+ "fb sensor error",     /* 70 */
+ "fb home or motor sensor error",
+ "fb filter or motor sensor error",
+ "fb lens or motor sensor error"
+ "first line position error (LER error, vertical)",
+ "first pixel position error (SER error, horizontal)",
+ "first pixel position error for lens 2 (SER2 error, horizontal)",
+ "err 77",
+ "err 78",
+ "err 79",
+ "err",      /* 80 */
+ "err",
+ "err",
+ "err",
+ "err",
+ "err",
+ "err",
+ "err",
+ "err",
+ "err",
+ "err",      /* 90 */
+ "err",
+ "err",
+ "err",
+ "err",
+ "err",
+ "err",
+ "err",
+ "err",
+ "err"       /* 99 */
+};
+
+
+/* --------------------------------------------------------------------------------------------------------- */
+
+
+#endif