summaryrefslogtreecommitdiff
path: root/backend/umax-scsidef.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/umax-scsidef.h
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/umax-scsidef.h')
-rw-r--r--backend/umax-scsidef.h1091
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