/* --------------------------------------------------------------------------------------------------------- */

/* 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, see <https://www.gnu.org/licenses/>.

    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 coordinate 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
