2002-04-17 18:50:39 +00:00
|
|
|
#ifndef FUJITSU_SCSI_H
|
|
|
|
#define FUJITSU_SCSI_H
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Part of SANE - Scanner Access Now Easy.
|
|
|
|
*
|
|
|
|
* Please see to opening comments in fujitsu.c
|
|
|
|
*/
|
|
|
|
|
|
|
|
/****************************************************/
|
|
|
|
|
2006-05-14 15:29:08 +00:00
|
|
|
#define USB_COMMAND_CODE 0x43
|
|
|
|
#define USB_COMMAND_LEN 0x1F
|
|
|
|
#define USB_COMMAND_OFFSET 0x13
|
2006-05-17 18:58:41 +00:00
|
|
|
#define USB_COMMAND_TIME 10000
|
|
|
|
#define USB_DATA_TIME 10000
|
2006-05-14 15:29:08 +00:00
|
|
|
#define USB_STATUS_CODE 0x53
|
|
|
|
#define USB_STATUS_LEN 0x0D
|
|
|
|
#define USB_STATUS_OFFSET 0x09
|
2006-05-17 18:58:41 +00:00
|
|
|
#define USB_STATUS_TIME 10000
|
2006-05-14 15:29:08 +00:00
|
|
|
|
2002-04-17 18:50:39 +00:00
|
|
|
/*static inline void */
|
|
|
|
static void
|
|
|
|
setbitfield (unsigned char *pageaddr, int mask, int shift, int val)
|
|
|
|
{
|
|
|
|
*pageaddr = (*pageaddr & ~(mask << shift)) | ((val & mask) << shift);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/*static inline void */
|
|
|
|
/*static void
|
|
|
|
resetbitfield (unsigned char *pageaddr, int mask, int shift, int val) \
|
|
|
|
{
|
|
|
|
*pageaddr = (*pageaddr & ~(mask << shift)) | (((!val) & mask) << shift);
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/*static inline int */
|
|
|
|
static int
|
|
|
|
getbitfield (unsigned char *pageaddr, int mask, int shift)
|
|
|
|
{
|
|
|
|
return ((*pageaddr >> shift) & mask);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
static int
|
|
|
|
getnbyte (unsigned char *pnt, int nbytes)
|
|
|
|
{
|
|
|
|
unsigned int result = 0;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
assert (nbytes < 5);
|
|
|
|
#endif
|
|
|
|
for (i = 0; i < nbytes; i++)
|
|
|
|
result = (result << 8) | (pnt[i] & 0xff);
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* ------------------------------------------------------------------------- */
|
|
|
|
|
|
|
|
/*static inline void */
|
|
|
|
static void
|
|
|
|
putnbyte (unsigned char *pnt, unsigned int value, unsigned int nbytes)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
#ifdef DEBUG
|
|
|
|
assert (nbytes < 5);
|
|
|
|
#endif
|
|
|
|
for (i = nbytes - 1; i >= 0; i--)
|
|
|
|
|
|
|
|
{
|
|
|
|
pnt[i] = value & 0xff;
|
|
|
|
value = value >> 8;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
/* SCSI commands */
|
|
|
|
|
|
|
|
typedef struct
|
|
|
|
{
|
|
|
|
unsigned char *cmd;
|
|
|
|
int size;
|
|
|
|
}
|
|
|
|
scsiblk;
|
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
|
|
|
|
#define RESERVE_UNIT 0x16
|
|
|
|
#define RELEASE_UNIT 0x17
|
|
|
|
#define INQUIRY 0x12
|
|
|
|
#define REQUEST_SENSE 0x03
|
|
|
|
#define SEND_DIAGNOSTIC 0x1d
|
|
|
|
#define TEST_UNIT_READY 0x00
|
|
|
|
#define SET_WINDOW 0x24
|
|
|
|
#define SET_SUBWINDOW 0xc0
|
|
|
|
#define OBJECT_POSITION 0x31
|
|
|
|
#define SEND 0x2a
|
|
|
|
#define READ 0x28
|
|
|
|
#define MODE_SELECT 0x15
|
|
|
|
#define MODE_SENSE 0x1a
|
|
|
|
#define SCAN 0x1b
|
2002-06-06 08:35:42 +00:00
|
|
|
#define IMPRINTER 0xc1
|
2002-04-17 18:50:39 +00:00
|
|
|
#define HW_STATUS 0xc2
|
2006-05-14 15:29:08 +00:00
|
|
|
#define SCANNER_CONTROL 0xf1
|
2002-04-17 18:50:39 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* ==================================================================== */
|
2006-05-19 21:12:41 +00:00
|
|
|
/*
|
2002-04-17 18:50:39 +00:00
|
|
|
static unsigned char reserve_unitC[] =
|
|
|
|
{ RESERVE_UNIT, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
|
|
|
static scsiblk reserve_unitB = { reserve_unitC, sizeof (reserve_unitC) };
|
|
|
|
|
|
|
|
static unsigned char release_unitC[] =
|
|
|
|
{ RELEASE_UNIT, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
|
|
|
static scsiblk release_unitB = { release_unitC, sizeof (release_unitC) };
|
2006-05-19 21:12:41 +00:00
|
|
|
*/
|
2002-04-17 18:50:39 +00:00
|
|
|
/* ==================================================================== */
|
|
|
|
|
2006-05-14 15:29:08 +00:00
|
|
|
static unsigned char scanner_controlC[] =
|
|
|
|
{ SCANNER_CONTROL, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
|
|
|
static scsiblk scanner_controlB = { scanner_controlC, sizeof (scanner_controlC) };
|
|
|
|
|
|
|
|
#define set_SC_function(icb, val) setbitfield(icb + 1, 7, 0, val)
|
|
|
|
#define SC_function_cancel 0x04
|
|
|
|
#define SC_function_lamp_on 0x05
|
|
|
|
#define SC_function_lamp_off 0x03
|
|
|
|
#define SC_function_lamp_normal 0x06
|
|
|
|
#define SC_function_lamp_saving 0x07
|
2002-09-16 12:19:56 +00:00
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
|
2002-04-17 18:50:39 +00:00
|
|
|
static unsigned char inquiryC[] = { INQUIRY, 0x00, 0x00, 0x00, 0x1f, 0x00 };
|
|
|
|
static scsiblk inquiryB = { inquiryC, sizeof (inquiryC) };
|
|
|
|
|
|
|
|
#define set_IN_evpd(icb, val) setbitfield(icb + 1, 1, 0, val)
|
|
|
|
#define set_IN_page_code(icb, val) icb[0x02]=val
|
|
|
|
#define set_IN_return_size(icb,val) icb[0x04]=val
|
|
|
|
#define set_IN_length(out,n) out[0x04]=n-5
|
|
|
|
|
|
|
|
#define get_IN_periph_qual(in) getbitfield(in, 0x07, 5)
|
|
|
|
#define IN_periph_qual_lun 0x00
|
|
|
|
#define IN_periph_qual_nolun 0x03
|
|
|
|
#define get_IN_periph_devtype(in) getbitfield(in, 0x1f, 0)
|
|
|
|
#define IN_periph_devtype_scanner 0x06
|
|
|
|
#define IN_periph_devtype_unknown 0x1f
|
|
|
|
#define get_IN_response_format(in) getbitfield(in + 0x03, 0x07, 0)
|
|
|
|
#define IN_recognized 0x02
|
|
|
|
#define get_IN_additional_length(in) in[0x04]
|
2006-06-04 03:59:48 +00:00
|
|
|
#define get_IN_vendor(in, buf) strncpy(buf, (char *)in + 0x08, 0x08)
|
|
|
|
#define get_IN_product(in, buf) strncpy(buf, (char *)in + 0x10, 0x010)
|
|
|
|
#define get_IN_version(in, buf) strncpy(buf, (char *)in + 0x20, 0x04)
|
2002-04-17 18:50:39 +00:00
|
|
|
#define get_IN_raster(in) getnbyte (in+0x2A, 2) /* offset between colors */
|
2006-05-14 15:29:08 +00:00
|
|
|
|
|
|
|
/* these two only in some scanners */
|
|
|
|
#define get_IN_duplex_3091(in) getnbyte (in+0x2D, 1) /* duplex available */
|
2002-04-17 18:50:39 +00:00
|
|
|
#define get_IN_frontback(in) getnbyte (in+0x2E, 2) /* offset between front and back for duplex */
|
|
|
|
|
2006-05-14 15:29:08 +00:00
|
|
|
/* the VPD response */
|
2002-04-17 18:50:39 +00:00
|
|
|
#define get_IN_page_length(in) getnbyte(in + 0x04, 1)
|
|
|
|
#define get_IN_basic_x_res(in) getnbyte(in + 0x05, 2)
|
|
|
|
#define get_IN_basic_y_res(in) getnbyte(in + 0x07, 2)
|
|
|
|
#define get_IN_step_x_res(in) getbitfield(in+0x09, 1, 0)
|
|
|
|
#define get_IN_step_y_res(in) getbitfield(in+0x09, 1, 4)
|
|
|
|
#define get_IN_max_x_res(in) getnbyte(in + 0x0a, 2)
|
|
|
|
#define get_IN_max_y_res(in) getnbyte(in + 0x0c, 2)
|
|
|
|
#define get_IN_min_x_res(in) getnbyte(in + 0x0e, 2)
|
|
|
|
#define get_IN_min_y_res(in) getnbyte(in + 0x10, 2)
|
|
|
|
#define get_IN_std_res_200(in) getbitfield(in+ 0x12, 1, 0)
|
|
|
|
#define get_IN_std_res_180(in) getbitfield(in+ 0x12, 1, 1)
|
|
|
|
#define get_IN_std_res_160(in) getbitfield(in+ 0x12, 1, 2)
|
|
|
|
#define get_IN_std_res_150(in) getbitfield(in+ 0x12, 1, 3)
|
|
|
|
#define get_IN_std_res_120(in) getbitfield(in+ 0x12, 1, 4)
|
|
|
|
#define get_IN_std_res_100(in) getbitfield(in+ 0x12, 1, 5)
|
|
|
|
#define get_IN_std_res_75(in) getbitfield(in+ 0x12, 1, 6)
|
|
|
|
#define get_IN_std_res_60(in) getbitfield(in+ 0x12, 1, 7)
|
|
|
|
#define get_IN_std_res_1200(in) getbitfield(in+ 0x13, 1, 0)
|
|
|
|
#define get_IN_std_res_800(in) getbitfield(in+ 0x13, 1, 1)
|
|
|
|
#define get_IN_std_res_600(in) getbitfield(in+ 0x13, 1, 2)
|
|
|
|
#define get_IN_std_res_480(in) getbitfield(in+ 0x13, 1, 3)
|
|
|
|
#define get_IN_std_res_400(in) getbitfield(in+ 0x13, 1, 4)
|
|
|
|
#define get_IN_std_res_320(in) getbitfield(in+ 0x13, 1, 5)
|
|
|
|
#define get_IN_std_res_300(in) getbitfield(in+ 0x13, 1, 6)
|
|
|
|
#define get_IN_std_res_240(in) getbitfield(in+ 0x13, 1, 7)
|
|
|
|
#define get_IN_window_width(in) getnbyte(in + 0x14, 4)
|
|
|
|
#define get_IN_window_length(in) getnbyte(in + 0x18, 4)
|
|
|
|
#define get_IN_overflow(in) getbitfield(in+0x1c, 1, 0)
|
|
|
|
#define get_IN_monochrome(in) getbitfield(in+0x1c, 1, 1)
|
|
|
|
#define get_IN_half_tone(in) getbitfield(in+0x1c, 1, 2)
|
|
|
|
#define get_IN_multilevel(in) getbitfield(in+0x1c, 1, 3)
|
|
|
|
#define get_IN_monochrome_rgb(in) getbitfield(in+0x1c, 1, 5)
|
|
|
|
#define get_IN_half_tone_rgb(in) getbitfield(in+0x1c, 1, 6)
|
|
|
|
#define get_IN_multilevel_rgb(in) getbitfield(in+0x1c, 1, 7)
|
2006-05-14 15:29:08 +00:00
|
|
|
|
|
|
|
/* vendor unique section */
|
2002-04-17 18:50:39 +00:00
|
|
|
#define get_IN_operator_panel(in) getbitfield(in+0x20, 1, 1)
|
|
|
|
#define get_IN_barcode(in) getbitfield(in+0x20, 1, 2)
|
2006-05-14 15:29:08 +00:00
|
|
|
#define get_IN_imprinter(in) getbitfield(in+0x20, 1, 3)
|
2002-04-17 18:50:39 +00:00
|
|
|
#define get_IN_duplex(in) getbitfield(in+0x20, 1, 4)
|
2006-05-14 15:29:08 +00:00
|
|
|
#define get_IN_transparency(in) getbitfield(in+0x20, 1, 5)
|
2002-04-17 18:50:39 +00:00
|
|
|
#define get_IN_flatbed(in) getbitfield(in+0x20, 1, 6)
|
|
|
|
#define get_IN_adf(in) getbitfield(in+0x20, 1, 7)
|
2006-05-14 15:29:08 +00:00
|
|
|
|
|
|
|
#define get_IN_adbits(in) getbitfield(in+0x21, 0x0f, 0)
|
2002-09-16 12:19:56 +00:00
|
|
|
#define get_IN_buffer_bytes(in) getnbyte(in + 0x22, 4)
|
2006-05-14 15:29:08 +00:00
|
|
|
|
|
|
|
/* more stuff here (std supported commands) */
|
|
|
|
|
|
|
|
#define get_IN_has_subwindow(in) getbitfield(in+0x2b, 1, 0)
|
|
|
|
#define get_IN_has_endorser(in) getbitfield(in+0x2b, 1, 1)
|
|
|
|
#define get_IN_has_hw_status(in) getbitfield(in+0x2b, 1, 2)
|
|
|
|
#define get_IN_has_scanner_ctl(in) getbitfield(in+0x31, 1, 1)
|
|
|
|
|
2002-06-06 08:35:42 +00:00
|
|
|
#define get_IN_brightness_steps(in) getnbyte(in+0x52, 1)
|
|
|
|
#define get_IN_threshold_steps(in) getnbyte(in+0x53, 1)
|
|
|
|
#define get_IN_contrast_steps(in) getnbyte(in+0x54, 1)
|
2006-05-14 15:29:08 +00:00
|
|
|
|
|
|
|
#define get_IN_num_dither_internal(in) getbitfield(in+0x56, 15, 4)
|
|
|
|
#define get_IN_num_dither_download(in) getbitfield(in+0x56, 15, 0)
|
|
|
|
|
|
|
|
#define get_IN_num_gamma_internal(in) getbitfield(in+0x57, 15, 4)
|
2003-03-28 14:46:17 +00:00
|
|
|
#define get_IN_num_gamma_download(in) getbitfield(in+0x57, 15, 0)
|
2006-05-14 15:29:08 +00:00
|
|
|
|
|
|
|
#define get_IN_ipc_bw_rif(in) getbitfield(in+0x58, 1, 7)
|
2002-09-16 12:19:56 +00:00
|
|
|
#define get_IN_ipc_auto1(in) getbitfield(in+0x58, 1, 6)
|
2002-06-06 08:35:42 +00:00
|
|
|
#define get_IN_ipc_auto2(in) getbitfield(in+0x58, 1, 5)
|
2002-04-17 18:50:39 +00:00
|
|
|
#define get_IN_ipc_outline_extraction(in) getbitfield(in+0x58, 1, 4)
|
|
|
|
#define get_IN_ipc_image_emphasis(in) getbitfield(in+0x58, 1, 3)
|
|
|
|
#define get_IN_ipc_auto_separation(in) getbitfield(in+0x58, 1, 2)
|
|
|
|
#define get_IN_ipc_mirroring(in) getbitfield(in+0x58, 1, 1)
|
|
|
|
#define get_IN_ipc_white_level_follow(in) getbitfield(in+0x58, 1, 0)
|
2006-05-14 15:29:08 +00:00
|
|
|
|
2002-04-17 18:50:39 +00:00
|
|
|
#define get_IN_ipc_subwindow(in) getbitfield(in+0x59, 1, 7)
|
|
|
|
#define get_IN_ipc_error_diffusion(in) getbitfield(in+0x59, 1, 6)
|
2006-05-14 15:29:08 +00:00
|
|
|
|
2002-04-17 18:50:39 +00:00
|
|
|
#define get_IN_compression_MH(in) getbitfield(in+0x5a, 1, 7)
|
|
|
|
#define get_IN_compression_MR(in) getbitfield(in+0x5a, 1, 6)
|
|
|
|
#define get_IN_compression_MMR(in) getbitfield(in+0x5a, 1, 5)
|
|
|
|
#define get_IN_compression_JBIG(in) getbitfield(in+0x5a, 1, 4)
|
|
|
|
#define get_IN_compression_JPG_BASE(in) getbitfield(in+0x5a, 1, 3)
|
|
|
|
#define get_IN_compression_JPG_EXT(in) getbitfield(in+0x5a, 1, 2)
|
|
|
|
#define get_IN_compression_JPG_INDEP(in) getbitfield(in+0x5a, 1, 1)
|
2006-05-14 15:29:08 +00:00
|
|
|
|
|
|
|
#define get_IN_imprinter2(in) getbitfield(in+0x5c, 1, 7)
|
|
|
|
#define get_IN_imprinter2_stamp(in) getbitfield(in+0x5c, 1, 6)
|
|
|
|
#define get_IN_imprinter2_electrical(in) getbitfield(in+0x5c, 1, 5)
|
2002-04-17 18:50:39 +00:00
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
|
|
|
|
static unsigned char test_unit_readyC[] =
|
|
|
|
{ TEST_UNIT_READY, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
|
|
|
static scsiblk test_unit_readyB =
|
|
|
|
{ test_unit_readyC, sizeof (test_unit_readyC) };
|
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
|
|
|
|
static unsigned char set_windowC[] =
|
|
|
|
{ SET_WINDOW, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, };
|
|
|
|
/* opcode, lun, _____4 X reserved____, transfer length, control byte */
|
|
|
|
static scsiblk set_windowB = { set_windowC, sizeof (set_windowC) };
|
|
|
|
#define set_SW_xferlen(sb, len) putnbyte(sb + 0x06, len, 3)
|
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
|
|
|
|
static unsigned char object_positionC[] =
|
|
|
|
{ OBJECT_POSITION, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
|
|
|
/* ADF, _____Count_____, ________Reserved______, Ctl */
|
|
|
|
static scsiblk object_positionB =
|
|
|
|
{ object_positionC, sizeof (object_positionC) };
|
|
|
|
|
|
|
|
#define set_OP_autofeed(b,val) setbitfield(b+0x01, 0x07, 0, val)
|
|
|
|
#define OP_Discharge 0x00
|
2006-05-14 15:29:08 +00:00
|
|
|
#define OP_Feed 0x01
|
2002-04-17 18:50:39 +00:00
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
|
2002-06-06 08:35:42 +00:00
|
|
|
|
|
|
|
static unsigned char sendC[] =
|
2002-04-17 18:50:39 +00:00
|
|
|
{SEND, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
|
2002-06-06 08:35:42 +00:00
|
|
|
static scsiblk sendB =
|
2002-04-17 18:50:39 +00:00
|
|
|
{sendC, sizeof (sendC)};
|
2002-06-06 08:35:42 +00:00
|
|
|
|
2002-04-17 18:50:39 +00:00
|
|
|
|
|
|
|
#define set_S_datatype_code(sb, val) sb[0x02] = (unsigned char)val
|
|
|
|
#define S_datatype_imagedatai 0x00
|
2002-06-06 08:35:42 +00:00
|
|
|
#define S_datatype_halftone_mask 0x02
|
|
|
|
#define S_datatype_gamma_function 0x03
|
|
|
|
#define S_datatype_LUT_data 0x83
|
|
|
|
#define S_datatype_jpg_q_table 0x88
|
|
|
|
#define S_datatype_imprinter_data 0x90
|
|
|
|
#define S_EX_datatype_LUT 0x01 /* Experiment code */
|
2002-04-17 18:50:39 +00:00
|
|
|
#define S_EX_datatype_shading_data 0xa0 /* Experiment code */
|
2002-06-06 08:35:42 +00:00
|
|
|
#define S_user_reg_gamma 0xc0
|
2002-04-17 18:50:39 +00:00
|
|
|
#define S_device_internal_info 0x03
|
|
|
|
#define set_S_datatype_qual_upper(sb, val) sb[0x04] = (unsigned char)val
|
|
|
|
#define S_DQ_none 0x00
|
|
|
|
#define S_DQ_Rcomp 0x06
|
|
|
|
#define S_DQ_Gcomp 0x07
|
|
|
|
#define S_DQ_Bcomp 0x08
|
|
|
|
#define S_DQ_Reg1 0x01
|
|
|
|
#define S_DQ_Reg2 0x02
|
|
|
|
#define S_DQ_Reg3 0x03
|
|
|
|
#define set_S_xfer_length(sb, val) putnbyte(sb + 0x06, val, 3)
|
|
|
|
|
2006-05-19 21:12:41 +00:00
|
|
|
/*
|
2002-06-06 08:35:42 +00:00
|
|
|
static unsigned char send_imprinterC[] =
|
|
|
|
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00};
|
|
|
|
static scsiblk send_imprinterB =
|
|
|
|
{send_imprinterC, sizeof(send_imprinterC)};
|
2006-05-19 21:12:41 +00:00
|
|
|
*/
|
2002-06-06 08:35:42 +00:00
|
|
|
/* imprinter counter
|
|
|
|
* 0 = increase counter
|
|
|
|
* 1 = decrease counter
|
|
|
|
*/
|
|
|
|
#define set_imprinter_cnt_dir(sb, val) setbitfield(sb + 0x01, 1, 5, val)
|
|
|
|
#define S_im_dir_inc 0
|
|
|
|
#define S_im_dir_dec 1
|
|
|
|
/* counter value
|
|
|
|
* 1 = 24 bit
|
|
|
|
* 0 = 16 bit
|
|
|
|
*/
|
|
|
|
#define set_imprinter_lap24(sb, val) setbitfield(sb + 0x01, 1, 4, val)
|
|
|
|
#define S_im_ctr_24bit 1
|
|
|
|
#define S_im_ctr_16bit 0
|
|
|
|
/* stepping of the imprinter counter
|
|
|
|
* 0..2 allowed
|
|
|
|
*/
|
|
|
|
#define set_imprinter_cstep(sb, val) setbitfield(sb + 0x01, 0x03, 0, val)
|
|
|
|
#define set_imprinter_uly(sb, val) putnbyte(sb + 0x06, val, 4)
|
|
|
|
|
|
|
|
/* specifies the way of printing direction of the strings.
|
|
|
|
*/
|
|
|
|
#define set_imprinter_dirs(sb, val) setbitfield(sb + 0x0c, 0x03, 0, val)
|
|
|
|
#define S_im_dir_left_right 0
|
|
|
|
#define S_im_dir_top_bottom 1
|
|
|
|
#define S_im_dir_right_left 2
|
|
|
|
#define S_im_dir_bottom_top 3
|
|
|
|
|
|
|
|
#define set_imprinter_string_length(sb, len) putnbyte(sb + 0x11, len, 1)
|
|
|
|
#define max_imprinter_string_length 40
|
|
|
|
|
2002-04-17 18:50:39 +00:00
|
|
|
/*
|
|
|
|
static unsigned char gamma_user_LUT_LS1K[512] = { 0x00 };
|
|
|
|
static scsiblk gamma_user_LUT_LS1K_LS1K = {
|
|
|
|
gamma_user_LUT_LS1K, sizeof(gamma_user_LUT_LS1K)
|
|
|
|
};
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* ==================================================================== */
|
2006-05-19 21:12:41 +00:00
|
|
|
/*
|
2002-06-06 08:35:42 +00:00
|
|
|
static unsigned char imprinterC[] =
|
|
|
|
{ IMPRINTER, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
|
|
|
static scsiblk imprinterB = { imprinterC, sizeof (imprinterC) };
|
|
|
|
|
|
|
|
#define set_IM_xfer_length(sb, val) putnbyte(sb + 0x7, val, 2)
|
|
|
|
|
|
|
|
static unsigned char imprinter_descC[] =
|
|
|
|
{ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
|
|
|
static scsiblk imprinter_descB = {imprinter_descC, sizeof(imprinter_descC) };
|
2006-05-19 21:12:41 +00:00
|
|
|
*/
|
2002-06-06 08:35:42 +00:00
|
|
|
/* enable/disable imprinter printing*/
|
|
|
|
#define set_IMD_enable(sb, val) setbitfield(sb + 0x01, 1, 7, val)
|
|
|
|
#define IMD_enable 0
|
|
|
|
#define IMD_disable 1
|
|
|
|
/* specifies thes side of a document to be printed */
|
|
|
|
#define set_IMD_side(sb, val) setbitfield(sb + 0x01, 1, 6, val)
|
|
|
|
#define IMD_front 0
|
|
|
|
#define IMD_back 1
|
|
|
|
/* format of the counter 16/24 bit*/
|
|
|
|
#define set_IMD_format(sb, val) setbitfield(sb + 0x01, 1, 5, val)
|
|
|
|
#define IMD_16_bit 0
|
|
|
|
#define IMD_24_bit 1
|
|
|
|
/* initial count */
|
|
|
|
#define set_IMD_initial_count_16(sb, val) putnbyte(sb + 0x02, val, 2)
|
|
|
|
#define set_IMD_initial_count_24(sb, val) putnbyte(sb + 0x03, val, 3)
|
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
|
2002-04-17 18:50:39 +00:00
|
|
|
static unsigned char readC[] =
|
|
|
|
{ READ, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
|
|
|
/* Type, rsvd, type qual, __xfer length__, Ctl */
|
|
|
|
static scsiblk readB = { readC, sizeof (readC) };
|
|
|
|
|
|
|
|
#define set_R_datatype_code(sb, val) sb[0x02] = val
|
|
|
|
#define R_datatype_imagedata 0x00
|
|
|
|
#define R_pixel_size 0x80
|
|
|
|
#define set_R_xfer_length(sb, val) putnbyte(sb + 0x06, val, 3)
|
|
|
|
#define set_R_window_id(sb, val) sb[0x05] = val
|
|
|
|
#define set_R_xfer_length(sb, val) putnbyte(sb + 0x06, val, 3)
|
|
|
|
#define get_PSIZE_num_x(in) getnbyte(in + 0x00, 4)
|
|
|
|
#define get_PSIZE_num_y(in) getnbyte(in + 0x04, 4)
|
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
|
|
|
|
static unsigned char mode_selectC[] =
|
|
|
|
{ MODE_SELECT, 0x10, 0x00, 0x00, 0x00, 0x00 };
|
|
|
|
static scsiblk mode_selectB = { mode_selectC, sizeof (mode_selectC) };
|
|
|
|
|
|
|
|
#define set_MSEL_xfer_length(sb, val) sb[0x04] = (unsigned char)val
|
|
|
|
|
2006-05-14 15:29:08 +00:00
|
|
|
/* combined 4 byte header and 8 byte page
|
|
|
|
* PageCodes: (most scanners know a few of these)
|
2002-04-17 18:50:39 +00:00
|
|
|
* 0x34 = Sleep mode
|
|
|
|
* 0x35 = ADF duplex reading transfer mode
|
|
|
|
* 0x36 = All sorts of device controls switching
|
|
|
|
* 0x37 = Backing switch control
|
|
|
|
* 0x38 = Double feed detection
|
|
|
|
* 0x39 = Drop out color
|
2006-05-14 15:29:08 +00:00
|
|
|
* 0x3c = Auto paper size detection
|
2002-04-17 18:50:39 +00:00
|
|
|
* 0x3d = Lamp light timer set
|
2006-05-14 15:29:08 +00:00
|
|
|
* 0x3e = Detect job separation sheet
|
|
|
|
* there is also possibly a 'descriptor block'
|
|
|
|
* and a 'vendor-specific block'
|
|
|
|
* fujitsu's seem not to use these two
|
2002-04-17 18:50:39 +00:00
|
|
|
*/
|
|
|
|
|
2006-05-14 15:29:08 +00:00
|
|
|
static unsigned char mode_select_sleepC[] = {
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x34, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
|
|
};
|
|
|
|
static scsiblk mode_select_sleepB = {
|
|
|
|
mode_select_sleepC, sizeof (mode_select_sleepC)
|
|
|
|
};
|
2002-04-17 18:50:39 +00:00
|
|
|
/* time until the device internal power supply switches to Sleep Mode
|
|
|
|
* 0 = Default (15 min)
|
|
|
|
* 1 = 1 min
|
|
|
|
* 2 = 2 min
|
|
|
|
* 0x3c ..0xff = 60 min
|
|
|
|
*/
|
2006-05-14 15:29:08 +00:00
|
|
|
#define set_MSEL_sleep_mode(sb, val) sb[0x06]=val
|
2006-05-19 21:12:41 +00:00
|
|
|
/*
|
2006-05-14 15:29:08 +00:00
|
|
|
static unsigned char mode_select_duplexC[] = {
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x35, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
|
|
};
|
|
|
|
static scsiblk mode_select_duplexB = {
|
|
|
|
mode_select_duplexC, sizeof (mode_select_duplexC)
|
|
|
|
};
|
2006-05-19 21:12:41 +00:00
|
|
|
*/
|
2002-04-17 18:50:39 +00:00
|
|
|
/* adf duplex reading transfer method
|
|
|
|
* 0 = front side - back side sequential transfer
|
|
|
|
* 1 = front side - back side alternate transfer
|
|
|
|
*/
|
|
|
|
#define set_MSEL_transfer_mode(sb, val) setbitfield(sb + 0x02, 0x01, 0, val)
|
2006-05-19 21:12:41 +00:00
|
|
|
/*
|
2006-05-14 15:29:08 +00:00
|
|
|
static unsigned char mode_select_randC[] = {
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x36, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
|
|
};
|
|
|
|
static scsiblk mode_select_randB = {
|
|
|
|
mode_select_randC, sizeof (mode_select_randC)
|
|
|
|
};
|
|
|
|
|
|
|
|
static unsigned char mode_select_backingC[] = {
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x37, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
|
|
};
|
|
|
|
static scsiblk mode_select_backingB = {
|
|
|
|
mode_select_backingC, sizeof (mode_select_backingC)
|
|
|
|
};
|
2006-05-19 21:12:41 +00:00
|
|
|
*/
|
|
|
|
/*
|
2006-05-14 15:29:08 +00:00
|
|
|
static unsigned char mode_select_dfeedC[] = {
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x38, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
|
|
};
|
|
|
|
static scsiblk mode_select_dfeedB = {
|
|
|
|
mode_select_dfeedC, sizeof (mode_select_dfeedC)
|
|
|
|
};
|
2006-05-19 21:12:41 +00:00
|
|
|
*/
|
2006-05-14 15:29:08 +00:00
|
|
|
/*byte 0x06 is bitmask controlling monochrome color*/
|
|
|
|
static unsigned char mode_select_dropoutC[] = {
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x39, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
|
|
};
|
|
|
|
static scsiblk mode_select_dropoutB = {
|
|
|
|
mode_select_dropoutC, sizeof (mode_select_dropoutC)
|
|
|
|
};
|
|
|
|
#define set_MSEL_dropout_front(sb, val) setbitfield(sb + 0x06, 0x0f, 0, val)
|
|
|
|
#define set_MSEL_dropout_back(sb, val) setbitfield(sb + 0x06, 0x0f, 4, val)
|
2002-04-17 18:50:39 +00:00
|
|
|
#define MSEL_dropout_DEFAULT 0
|
|
|
|
#define MSEL_dropout_GREEN 8
|
|
|
|
#define MSEL_dropout_RED 9
|
|
|
|
#define MSEL_dropout_BLUE 11
|
|
|
|
#define MSEL_dropout_CUSTOM 12
|
2006-05-14 15:29:08 +00:00
|
|
|
|
|
|
|
/*bytes 0x06-07 and 0x09 control paper size detection*/
|
2006-05-19 21:12:41 +00:00
|
|
|
/*
|
2006-05-14 15:29:08 +00:00
|
|
|
static unsigned char mode_select_autoC[] = {
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x3C, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
|
|
};
|
|
|
|
static scsiblk mode_select_autoB = {
|
|
|
|
mode_select_autoC, sizeof (mode_select_autoC)
|
|
|
|
};
|
|
|
|
static unsigned char mode_select_lampC[] = {
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
0x3D, 0x06, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
|
|
|
|
};
|
|
|
|
static scsiblk mode_select_lampB= {
|
|
|
|
mode_select_lampC, sizeof (mode_select_lampC)
|
|
|
|
};
|
2006-05-19 21:12:41 +00:00
|
|
|
*/
|
2002-04-17 18:50:39 +00:00
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
#if 0
|
|
|
|
/* currently not used */
|
|
|
|
static unsigned char mode_senseC[] =
|
|
|
|
{ MODE_SENSE, 0x18, 0x03, 0x00, 0x00, 0x00, /* PF set, page type 03 */ };
|
|
|
|
static scsiblk mode_senseB = { mode_senseC, sizeof (mode_senseC) };
|
|
|
|
|
|
|
|
#define set_MS_DBD(b, val) setbitfield(b, 0x01, 3, (val?1:0))
|
|
|
|
#define set_MS_len(b, val) putnbyte(b+0x04, val, 1)
|
|
|
|
#define get_MS_MUD(b) getnbyte(b+(0x04+((int)*(b+0x3)))+0x4,2)
|
|
|
|
#endif
|
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
|
|
|
|
static unsigned char scanC[] = { SCAN, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
|
|
|
static scsiblk scanB = { scanC, sizeof (scanC) };
|
|
|
|
|
|
|
|
#define set_SC_xfer_length(sb, val) sb[0x04] = (unsigned char)val
|
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
|
|
|
|
static unsigned char hw_statusC[] =
|
|
|
|
{ HW_STATUS, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
|
|
|
|
static scsiblk hw_statusB = { hw_statusC, sizeof (hw_statusC) };
|
|
|
|
|
2002-06-06 08:35:42 +00:00
|
|
|
#define set_HW_allocation_length(sb, len) putnbyte(sb + 0x07, len, 2)
|
2002-04-17 18:50:39 +00:00
|
|
|
|
2006-05-14 15:29:08 +00:00
|
|
|
#define get_HW_top(in) getbitfield(in+0x02, 1, 7)
|
|
|
|
#define get_HW_A3(in) getbitfield(in+0x02, 1, 3)
|
|
|
|
#define get_HW_B4(in) getbitfield(in+0x02, 1, 2)
|
|
|
|
#define get_HW_A4(in) getbitfield(in+0x02, 1, 1)
|
|
|
|
#define get_HW_B5(in) getbitfield(in+0x02, 1, 0)
|
|
|
|
|
|
|
|
#define get_HW_hopper(in) !getbitfield(in+0x03, 1, 7)
|
|
|
|
#define get_HW_omr(in) getbitfield(in+0x03, 1, 6)
|
|
|
|
#define get_HW_adf_open(in) getbitfield(in+0x03, 1, 5)
|
2002-04-17 18:50:39 +00:00
|
|
|
|
2006-05-14 15:29:08 +00:00
|
|
|
#define get_HW_sleep(in) getbitfield(in+0x04, 1, 7)
|
|
|
|
#define get_HW_send_sw(in) getbitfield(in+0x04, 1, 2)
|
|
|
|
#define get_HW_manual_feed(in) getbitfield(in+0x04, 1, 1)
|
|
|
|
#define get_HW_scan_sw(in) getbitfield(in+0x04, 1, 0)
|
|
|
|
|
|
|
|
#define get_HW_function(in) getbitfield(in+0x05, 0x0f, 0)
|
|
|
|
|
|
|
|
#define get_HW_ink_empty(in) getbitfield(in+0x06, 1, 7)
|
|
|
|
#define get_HW_double_feed(in) getbitfield(in+0x06, 1, 0)
|
|
|
|
|
|
|
|
#define get_HW_error_code(in) in[0x07]
|
|
|
|
|
|
|
|
#define get_HW_skew_angle(in) getnbyte(in+0x08, 2)
|
|
|
|
|
|
|
|
#define get_HW_ink_remain(in) in[0x0a]
|
2002-04-17 18:50:39 +00:00
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
|
|
|
|
/* We use the same structure for both SET WINDOW and GET WINDOW. */
|
2006-05-14 15:29:08 +00:00
|
|
|
static unsigned char window_descriptor_headerC[] = {
|
2002-04-17 18:50:39 +00:00
|
|
|
0x00, 0x00, 0x00,
|
|
|
|
0x00, 0x00, 0x00, /* reserved */
|
|
|
|
0x00, 0x00, /* Window Descriptor Length */
|
|
|
|
};
|
2006-05-14 15:29:08 +00:00
|
|
|
static scsiblk window_descriptor_headerB=
|
|
|
|
{ window_descriptor_headerC, sizeof (window_descriptor_headerC) };
|
2002-04-17 18:50:39 +00:00
|
|
|
#define set_WPDB_wdblen(sb, len) putnbyte(sb + 0x06, len, 2)
|
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
|
|
|
|
static unsigned char window_descriptor_blockC[] = {
|
|
|
|
/* 0x00 - Window Identifier
|
|
|
|
* 0x00 for 3096
|
|
|
|
* 0x00 (front) or 0x80 (back) for 3091
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_wid(sb, val) sb[0] = val
|
|
|
|
#define WD_wid_front 0x00
|
|
|
|
#define WD_wid_back 0x80
|
|
|
|
|
|
|
|
/* 0x01 - Reserved (bits 7-1), AUTO (bit 0)
|
|
|
|
* Use 0x00 for 3091, 3096
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_auto(sb, val) setbitfield(sb + 0x01, 1, 0, val)
|
|
|
|
#define get_WD_auto(sb) getbitfield(sb + 0x01, 1, 0)
|
|
|
|
|
|
|
|
/* 0x02,0x03 - X resolution in dpi
|
|
|
|
* 3091 supports 50-300 in steps of 1
|
|
|
|
* 3096 suppors 200,240,300,400; or 100-1600 in steps of 4
|
|
|
|
* if image processiong option installed
|
|
|
|
*/
|
|
|
|
0x00, 0x00,
|
|
|
|
#define set_WD_Xres(sb, val) putnbyte(sb + 0x02, val, 2)
|
|
|
|
#define get_WD_Xres(sb) getnbyte(sb + 0x02, 2)
|
|
|
|
|
|
|
|
/* 0x04,0x05 - X resolution in dpi
|
|
|
|
* 3091 supports 50-600 in steps of 1; 75,150,300,600 only
|
|
|
|
* in color mode
|
|
|
|
* 3096 suppors 200,240,300,400; or 100-1600 in steps of 4
|
|
|
|
* if image processiong option installed
|
|
|
|
*/
|
|
|
|
0x00, 0x00,
|
|
|
|
#define set_WD_Yres(sb, val) putnbyte(sb + 0x04, val, 2)
|
|
|
|
#define get_WD_Yres(sb) getnbyte(sb + 0x04, 2)
|
|
|
|
|
|
|
|
/* 0x06-0x09 - Upper Left X in 1/1200 inch
|
|
|
|
*/
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
#define set_WD_ULX(sb, val) putnbyte(sb + 0x06, val, 4)
|
|
|
|
#define get_WD_ULX(sb) getnbyte(sb + 0x06, 4)
|
|
|
|
|
|
|
|
/* 0x0a-0x0d - Upper Left Y in 1/1200 inch
|
|
|
|
*/
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
#define set_WD_ULY(sb, val) putnbyte(sb + 0x0a, val, 4)
|
|
|
|
#define get_WD_ULY(sb) getnbyte(sb + 0x0a, 4)
|
|
|
|
|
|
|
|
/* 0x0e-0x11 - Width in 1/1200 inch
|
|
|
|
* 3091 left+width max 10200
|
|
|
|
* 3096 left+width max 14592
|
|
|
|
* also limited to page size, see bytes 0x35ff.
|
|
|
|
*/
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
#define set_WD_width(sb, val) putnbyte(sb + 0x0e, val, 4)
|
|
|
|
#define get_WD_width(sb) getnbyte(sb + 0x0e, 4)
|
|
|
|
|
|
|
|
/* 0x12-0x15 - Height in 1/1200 inch
|
|
|
|
* 3091 top+height max 16832
|
|
|
|
* 3096 top+height max 20736, also if left+width>13199,
|
|
|
|
* top+height has to be less than 19843
|
|
|
|
*/
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
#define set_WD_length(sb, val) putnbyte(sb + 0x12, val, 4)
|
|
|
|
#define get_WD_length(sb) getnbyte(sb + 0x12, 4)
|
|
|
|
|
|
|
|
/* 0x16 - Brightness
|
|
|
|
* 3091 always use 0x00
|
|
|
|
* 3096 if in halftone mode, 8 levels supported (01-1F, 20-3F,
|
|
|
|
..., E0-FF)
|
|
|
|
* use 0x00 for user defined dither pattern
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_brightness(sb, val) sb[0x16] = val
|
|
|
|
#define get_WD_brightness(sb) sb[0x16]
|
|
|
|
|
|
|
|
/* 0x17 - Threshold
|
|
|
|
* 3091 0x00 = use floating slice; 0x01..0xff fixed slice
|
|
|
|
* with 0x01=brightest, 0x80=medium, 0xff=darkest;
|
|
|
|
* only effective for line art mode.
|
|
|
|
* 3096 0x00 = use "simplified dynamic treshold", otherwise
|
|
|
|
* same as above but resolution is only 64 steps.
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_threshold(sb, val) sb[0x17] = val
|
|
|
|
#define get_WD_threshold(sb) sb[0x17]
|
|
|
|
|
|
|
|
/* 0x18 - Contrast
|
|
|
|
* 3091 - not supported, always use 0x00
|
|
|
|
* 3096 - the same
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_contrast(sb, val) sb[0x18] = val
|
|
|
|
#define get_WD_contrast(sb) sb[0x18]
|
|
|
|
|
|
|
|
/* 0x19 - Image Composition (color mode)
|
|
|
|
* 3091 - use 0x00 for line art, 0x01 for halftone,
|
|
|
|
* 0x02 for grayscale, 0x05 for color.
|
|
|
|
* 3096 - same but minus color.
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_composition(sb, val) sb[0x19] = val
|
|
|
|
#define get_WD_composition(sb) sb[0x19]
|
|
|
|
#define WD_comp_LA 0
|
|
|
|
#define WD_comp_HT 1
|
|
|
|
#define WD_comp_GS 2
|
2006-05-14 15:29:08 +00:00
|
|
|
#define WD_comp_CL 3
|
|
|
|
#define WD_comp_CH 4
|
|
|
|
#define WD_comp_CG 5
|
2002-04-17 18:50:39 +00:00
|
|
|
|
|
|
|
/* 0x1a - Depth
|
|
|
|
* 3091 - use 0x01 for b/w or 0x08 for gray/color
|
|
|
|
* 3096 - use 0x01 for b/w or 0x08 for gray
|
|
|
|
*/
|
|
|
|
0x08,
|
|
|
|
#define set_WD_bitsperpixel(sb, val) sb[0x1a] = val
|
|
|
|
#define get_WD_bitsperpixel(sb) sb[0x1a]
|
|
|
|
|
|
|
|
/* 0x1b,0x1c - Halftone Pattern
|
|
|
|
* 3091 byte 1b: 00h default(=dither), 01h dither,
|
|
|
|
* 02h error dispersion
|
|
|
|
* 1c: 00 dark images, 01h dark text+images,
|
|
|
|
* 02h light images,
|
|
|
|
* 03h light text+images, 80h download pattern
|
|
|
|
* 3096: 1b unused; 1c bit 7=1: use downloadable pattern,
|
|
|
|
* bit 7=0: use builtin pattern; rest of byte 1b denotes
|
|
|
|
* pattern number, three builtin and five downloadable
|
|
|
|
* supported; higher numbers = error.
|
|
|
|
*/
|
|
|
|
0x00, 0x00,
|
|
|
|
#define set_WD_halftone(sb, val) putnbyte(sb + 0x1b, val, 2)
|
|
|
|
#define get_WD_halftone(sb) getnbyte(sb + 0x1b, 2)
|
|
|
|
|
|
|
|
/* 0x1d - Reverse image, padding type
|
|
|
|
* 3091: bit 7=1: reverse black&white
|
|
|
|
* bits 0-2: padding type, must be 0
|
|
|
|
* 3096: the same; bit 7 must be set for gray and not
|
|
|
|
* set for b/w.
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_rif(sb, val) setbitfield(sb + 0x1d, 1, 7, val)
|
|
|
|
#define get_WD_rif(sb) getbitfield(sb + 0x1d, 1, 7)
|
|
|
|
|
|
|
|
/* 0x1e,0x1f - Bit ordering
|
|
|
|
* 3091 not supported, use 0x00
|
|
|
|
* 3096 not supported, use 0x00
|
|
|
|
*/
|
|
|
|
0x00, 0x00, /* 0x1e *//* bit ordering */
|
|
|
|
#define set_WD_bitorder(sb, val) putnbyte(sb + 0x1e, val, 2)
|
|
|
|
#define get_WD_bitorder(sb) getnbyte(sb + 0x1e, 2)
|
|
|
|
|
|
|
|
/* 0x20 - compression type
|
|
|
|
* 3091 - not supported, use 0x00
|
|
|
|
* 3096 - only allowed with CMP option and not in gray
|
|
|
|
* mode; use 0x01=MH,0x02=MR,0x03=MMR
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_compress_type(sb, val) sb[0x20] = val
|
|
|
|
#define get_WD_compress_type(sb) sb[0x20]
|
|
|
|
#define WD_cmp_NONE 0
|
|
|
|
#define WD_cmp_MH 1
|
|
|
|
#define WD_cmp_MR 2
|
|
|
|
#define WD_cmp_MMR 3
|
|
|
|
#define WD_cmp_JBIG 0x80
|
2004-02-20 17:12:47 +00:00
|
|
|
#define WD_cmp_JPG1 0x81
|
|
|
|
#define WD_cmp_JPG2 0x82
|
|
|
|
#define WD_cmp_JPG3 0x83
|
|
|
|
|
2002-04-17 18:50:39 +00:00
|
|
|
|
|
|
|
/* 0x21 - compression argument
|
|
|
|
* 3091 - not supported, use 0x00
|
|
|
|
* 3096 - only allowed with 0x02 ar byte 0x20 (MR compress),
|
|
|
|
* use this to specify "k" parameter
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_compress_arg(sb, val) sb[0x21] = val
|
|
|
|
#define get_WD_compress_arg(sb) sb[0x21]
|
|
|
|
|
|
|
|
/* 0x22-0x27 - reserved */
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
|
|
|
|
|
|
/* 0x28 - vendor id code
|
|
|
|
* 3091 - use 0xc0
|
|
|
|
* 3096 - use 0xc0
|
|
|
|
*/
|
2006-05-14 15:29:08 +00:00
|
|
|
0x00,
|
2002-04-17 18:50:39 +00:00
|
|
|
#define set_WD_vendor_id_code(sb, val) sb[0x28] = val
|
|
|
|
#define get_WD_vendor_id_code(sb) sb[0x28]
|
|
|
|
|
|
|
|
/* 0x29 - pattern setting
|
|
|
|
* 3091 - use 0x00
|
|
|
|
* 3096 - reserved, use 0x00
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_gamma(sb, val) sb[0x29] = val
|
|
|
|
#define get_WD_gamma(sb) sb[0x29]
|
|
|
|
#define WD_gamma_DEFAULT 0
|
|
|
|
#define WD_gamma_NORMAL 1
|
|
|
|
#define WD_gamma_SOFT 2
|
|
|
|
#define WD_gamma_SHARP 3
|
|
|
|
|
|
|
|
/* 0x2a - outline/scanning order
|
|
|
|
* 3091 - scanning order. Only 0x00 (line order) supported
|
|
|
|
* 3096 - outlining. 0x00=off, 0x80=on. 0x80 only permitted
|
|
|
|
* when image processing option fitted.
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_outline(sb, val) sb[0x2a] = val
|
|
|
|
#define get_WD_outline(sb) sb[0x2a]
|
|
|
|
#define set_WD_scanning_order(sb, val) sb[0x2a] = val
|
|
|
|
#define get_WD_scanning_order(sb) sb[0x2a]
|
|
|
|
|
|
|
|
/* 0x2b - emphasis/scanning order argument
|
|
|
|
* 3091 - scanning order argument. Only 0x00 (RGB) supported
|
|
|
|
* 3096 - emphasis. 0x00=off, others only permitted when
|
|
|
|
* image processing option fitted:
|
|
|
|
* 0x2F=low emphasis, 0x4F=medium emphasis,
|
|
|
|
* 0x7F=high emphasis, 0xFF=smoothing
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_emphasis(sb, val) sb[0x2b] = val
|
|
|
|
#define get_WD_emphasis(sb) sb[0x2b]
|
|
|
|
#define WD_emphasis_NONE 0x00
|
|
|
|
#define WD_emphasis_LOW 0x01
|
|
|
|
#define WD_emphasis_MEDIUM 0x30
|
|
|
|
#define WD_emphasis_HIGH 0x50
|
|
|
|
#define WD_emphasis_SMOOTH 0x80
|
|
|
|
|
|
|
|
/* 0x2c - auto separation
|
|
|
|
* 3091 - reserved, use 0x00
|
|
|
|
* 3096 - auto separation. 0x00=off, 0x80=on. 0x80 only
|
|
|
|
* permitted when image processing option fitted.
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_auto_sep(sb, val) setbitfield(sb + 0x2c, 1, 7, val)
|
|
|
|
#define get_WD_auto_sep(sb) getbitfield(sb + 0x2c, 1, 7)
|
|
|
|
|
|
|
|
/* 0x2d - mirroring/single color
|
|
|
|
* 3091 - determines which color is used in monochrome
|
|
|
|
* scans: 0x00/0x04=G,0x01=B,0x02=R
|
|
|
|
* 3096 - window mirroring. 0x00=off, 0x80=on. 0x80 only
|
|
|
|
* permitted when image processing option fitted.
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_mirroring(sb, val) setbitfield(sb + 0x2d, 1, 7, val)
|
|
|
|
#define get_WD_mirroring(sb) getbitfield(sb + 0x2d, 1, 7)
|
|
|
|
#define set_WD_lamp_color(sb, val) sb[0x2d] = val
|
|
|
|
#define get_WD_lamp_color(sb) sb[0x2d]
|
2006-05-14 15:29:08 +00:00
|
|
|
#define WD_LAMP_DEFAULT 0x00
|
|
|
|
#define WD_LAMP_BLUE 0x01
|
|
|
|
#define WD_LAMP_RED 0x02
|
|
|
|
#define WD_LAMP_GREEN 0x04
|
2002-04-17 18:50:39 +00:00
|
|
|
|
|
|
|
/* 0x2e - variance/bit padding
|
|
|
|
* 3091 - unsupported, use 0x00
|
|
|
|
* 3096 - variance rate for dynamic treshold. 0x00=default,
|
|
|
|
* 0x1f, 0x3f, ... 0xff = small...large
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_var_rate_dyn_thresh(sb, val) sb[0x2e] = val
|
|
|
|
#define get_WD_var_rate_dyn_thresh(sb) sb[0x2e]
|
|
|
|
|
|
|
|
0x00, /* 0x2f *//* DTC mode */
|
|
|
|
#define set_WD_dtc_threshold_curve(sb, val) setbitfield(sb + 0x2f, 7, 0, val)
|
|
|
|
#define get_WD_dtc_threshold_curve(sb) getbitfield(sb + 0x2f, 7, 0)
|
|
|
|
#define set_WD_gradation(sb, val) setbitfield(sb + 0x2f, 3, 3, val)
|
|
|
|
#define get_WD_gradation(sb) getbitfield(sb + 0x2f, 3, 3)
|
|
|
|
#define WD_gradation_ORDINARY 0
|
|
|
|
#define WD_gradation_HIGH 2
|
|
|
|
#define set_WD_smoothing_mode(sb, val) setbitfield(sb + 0x2f, 3, 5, val)
|
|
|
|
#define get_WD_smoothing_mode(sb) getbitfield(sb + 0x2f, 3, 5)
|
|
|
|
#define WD_smoothing_OCR 0
|
|
|
|
#define WD_smoothing_IMAGE 1
|
|
|
|
#define set_WD_filtering(sb, val) setbitfield(sb + 0x2f, 1, 7, val)
|
|
|
|
#define get_WD_filtering(sb) getbitfield(sb + 0x2f, 1, 7)
|
|
|
|
#define WD_filtering_BALLPOINT 0
|
|
|
|
#define WD_filtering_ORDINARY 1
|
|
|
|
|
|
|
|
0x00, /* 0x30 *//* DTC mode 2 */
|
|
|
|
#define set_WD_background(sb, val) setbitfield(sb + 0x30, 1, 0, val)
|
|
|
|
#define get_WD_background(sb) getbitfield(sb + 0x30, 1, 0)
|
|
|
|
#define WD_background_WHITE 0
|
|
|
|
#define WD_background_BLACK 1
|
|
|
|
#define set_WD_matrix2x2(sb, val) setbitfield(sb + 0x30, 1, 1, val)
|
|
|
|
#define get_WD_matrix2x2(sb) getbitfield(sb + 0x30, 1, 1)
|
|
|
|
#define set_WD_matrix3x3(sb, val) setbitfield(sb + 0x30, 1, 2, val)
|
|
|
|
#define get_WD_matrix3x3(sb) getbitfield(sb + 0x30, 1, 2)
|
|
|
|
#define set_WD_matrix4x4(sb, val) setbitfield(sb + 0x30, 1, 3, val)
|
|
|
|
#define get_WD_matrix4x4(sb) getbitfield(sb + 0x30, 1, 3)
|
|
|
|
#define set_WD_matrix5x5(sb, val) setbitfield(sb + 0x30, 1, 4, val)
|
|
|
|
#define get_WD_matrix5x5(sb) getbitfield(sb + 0x30, 1, 4)
|
|
|
|
#define set_WD_noise_removal(sb, val) setbitfield(sb + 0x30, 1, 5, !val)
|
|
|
|
#define get_WD_noise_removal(sb) !getbitfield(sb + 0x30, 1, 5)
|
|
|
|
|
|
|
|
0x00, /* 0x31 *//* reserved */
|
|
|
|
|
|
|
|
|
|
|
|
/* 0x32 - scanning mode/white level follower
|
|
|
|
* 3091 - scan mode 0x00=normal, 0x02=high quality
|
|
|
|
* 3096 - white level follower, 0x00=default,
|
|
|
|
* 0x80 enable (line mode), 0xc0 disable (photo mode)
|
|
|
|
*/
|
|
|
|
0x00,
|
|
|
|
#define set_WD_white_level_follow(sb, val) sb[0x32] = val
|
|
|
|
#define get_WD_white_level_follow(sb) sb[0x32]
|
|
|
|
#define set_WD_quality(sb, val) sb[0x32] = val
|
|
|
|
#define get_WD_quality(sb) sb[0x32]
|
|
|
|
#define WD_white_level_follow_DEFAULT 0x00
|
|
|
|
#define WD_white_level_follow_ENABLED 0x80
|
|
|
|
#define WD_white_level_follow_DISABLED 0xC0
|
|
|
|
|
|
|
|
/* 0x33,0x34 - subwindow list
|
|
|
|
* 3091 reserved, use 0x00
|
|
|
|
* 3096 bits 0-3 of byte 34 denote use of subwindows 1...4
|
|
|
|
*/
|
|
|
|
0x00, 0x00,
|
|
|
|
#define set_WD_subwindow_list(sb, val) putnbyte(sb + 0x33, val, 2)
|
|
|
|
#define get_WD_subwindow_list(sb) getnbyte(sb + 0x33, 2)
|
|
|
|
|
2006-05-14 15:29:08 +00:00
|
|
|
/* 0x35 - paper size
|
2002-04-17 18:50:39 +00:00
|
|
|
* 3091 unsupported, always use 0xc0
|
|
|
|
* 3096 if bits 6-7 both set, custom paper size enabled,
|
|
|
|
* bytes 0x36-0x3d used. Otherwise, a number of
|
|
|
|
* valid fixed values denote common paper formats.
|
|
|
|
*/
|
|
|
|
0xC0,
|
2006-05-14 15:29:08 +00:00
|
|
|
#define set_WD_paper_selection(sb, val) setbitfield(sb + 0x35, 3, 6, val)
|
|
|
|
#define WD_paper_SEL_UNDEFINED 0
|
|
|
|
#define WD_paper_SEL_NON_STANDARD 3
|
|
|
|
|
|
|
|
/* we no longer use these, custom size (0xc0) overrides,
|
|
|
|
and more recent scanners only use custom size anyway
|
|
|
|
#define get_WD_paper_selection(sb) getbitfield(sb + 0x35, 3, 6)
|
|
|
|
#define WD_paper_SEL_STANDARD 2
|
|
|
|
|
|
|
|
#define set_WD_paper_orientation(sb, val) setbitfield(sb + 0x35, 1, 4, val)
|
|
|
|
#define get_WD_paper_orientation(sb) getbitfield(sb + 0x35, 1, 4)
|
|
|
|
#define WD_paper_PORTRAIT 0
|
|
|
|
#define WD_paper_LANDSCAPE 1
|
|
|
|
|
2002-04-17 18:50:39 +00:00
|
|
|
#define set_WD_paper_size(sb, val) setbitfield(sb + 0x35, 0x0f, 0, val)
|
|
|
|
#define get_WD_paper_size(sb) getbitfield(sb + 0x35, 0x0f, 0)
|
|
|
|
#define WD_paper_UNDEFINED 0
|
|
|
|
#define WD_paper_A3 3
|
|
|
|
#define WD_paper_A4 4
|
|
|
|
#define WD_paper_A5 5
|
|
|
|
#define WD_paper_DOUBLE 6
|
|
|
|
#define WD_paper_LETTER 7
|
|
|
|
#define WD_paper_B4 12
|
|
|
|
#define WD_paper_B5 13
|
|
|
|
#define WD_paper_LEGAL 15
|
|
|
|
#define WD_paper_CUSTOM 14
|
2006-05-14 15:29:08 +00:00
|
|
|
*/
|
2002-04-17 18:50:39 +00:00
|
|
|
|
|
|
|
/* 0x36-0x39 - custom paper width
|
|
|
|
* 3091 0<w<=10200
|
|
|
|
* 3096 0<w<=14592
|
|
|
|
*/
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
#define set_WD_paper_width_X(sb, val) putnbyte(sb + 0x36, val, 4)
|
|
|
|
#define get_WD_paper_width_X(sb) getnbyte(sb + 0x36, 4)
|
|
|
|
|
|
|
|
/* 0x3a-0x3d - custom paper length
|
|
|
|
* 3091 0<w<=16832
|
|
|
|
* 3096 0<w<=20736
|
|
|
|
*/
|
|
|
|
0x00, 0x00, 0x00, 0x00,
|
|
|
|
#define set_WD_paper_length_Y(sb, val) putnbyte(sb+0x3a, val, 4)
|
|
|
|
#define get_WD_paper_length_Y(sb) getnbyte(sb+0x3a, 4)
|
|
|
|
|
|
|
|
0X00, /* 0x3e *//* DTC selection (3091: reserved) */
|
|
|
|
#define set_WD_dtc_selection(sb, val) setbitfield(sb + 0x3e, 3, 6, val)
|
|
|
|
#define get_WD_dtc_selection(sb) getbitfield(sb + 0x3e, 3, 6)
|
|
|
|
#define WD_dtc_selection_DEFAULT 0
|
|
|
|
#define WD_dtc_selection_DYNAMIC 1
|
|
|
|
#define WD_dtc_selection_SIMPLIFIED 2
|
|
|
|
/* - the rest of this is all zeroes, comments from the 3091 docs. */
|
|
|
|
|
|
|
|
0x00, /* 0x3f reserved */
|
|
|
|
0x00, /* 0x40 intial slice (floating slice parameter) */
|
|
|
|
0x00, /* 0x41 paper color ratio (white level slice ratio) (floating slice parameter) */
|
|
|
|
0x00, /* 0x42 black/white ratio (black/white slice) (floating slice parameter) */
|
|
|
|
0x00, /* 0x43 Up (+UP count setting) (floating slice parameter) */
|
|
|
|
0x00, /* 0x44 Down (+Down count setting) (floating slice parameter) */
|
|
|
|
0x00, /* 0x45 Lower Limit Slice (floating slice parameter) */
|
|
|
|
0x00, /* 0x46 Compensation Line Interval (floating slice parameter) */
|
|
|
|
0x00, /* 0x47 Reserved */
|
|
|
|
0x00, /* 0x48 Error Diffusion upper limit slice (error diffusion parameter) */
|
|
|
|
0x00, /* 0x49 Error Diffusion lower limit slice (error diffusion parameter) */
|
|
|
|
0x00, /* 0x4a Reserved */
|
|
|
|
0x00, /* 0x4b Reserved */
|
|
|
|
0x00, /* 0x4c Enhancement Setting */
|
|
|
|
0x00, /* 0x4d Laplacian Gradient Coefficient (enhancement parameter) */
|
|
|
|
0x00, /* 0x4e Gradient Coefficient (enhancement parameter) */
|
|
|
|
0x00, /* 0x4f Laplacian Slice (enhancement parameter) */
|
|
|
|
0x00, /* 0x50 Gradient Slice (enhancement parameter) */
|
|
|
|
0x00, /* 0x51 Reserved */
|
|
|
|
0x00, /* 0x52 Primary Scan Ratio Compensation */
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, /* 0x53 - 0x57 reserved */
|
|
|
|
0x00, 0x00, 0x00, 0x00, 0x00, /* 0x58 - 0x5c reserved */
|
|
|
|
0x00, 0x00, 0x00 /* 0x5d - 0x5f reserved */
|
|
|
|
};
|
|
|
|
static scsiblk window_descriptor_blockB =
|
|
|
|
{ window_descriptor_blockC, sizeof (window_descriptor_blockC) };
|
2006-05-14 15:29:08 +00:00
|
|
|
#define max_WDB_size 0xc8
|
2002-04-17 18:50:39 +00:00
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
|
2006-05-14 15:29:08 +00:00
|
|
|
#define RS_return_size 0x12
|
2002-04-17 18:50:39 +00:00
|
|
|
|
2006-05-14 15:29:08 +00:00
|
|
|
static unsigned char request_senseC[] =
|
|
|
|
{REQUEST_SENSE, 0x00, 0x00, 0x00, RS_return_size, 0x00};
|
|
|
|
static scsiblk request_senseB = {request_senseC, sizeof (request_senseC)};
|
2002-04-17 18:50:39 +00:00
|
|
|
|
|
|
|
/* 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) /* normally 0 */
|
|
|
|
#define get_RS_additional_length(b) b[0x07] /* always 10 */
|
|
|
|
#define get_RS_ASC(b) b[0x0c]
|
|
|
|
#define get_RS_ASCQ(b) b[0x0d]
|
2006-05-14 15:29:08 +00:00
|
|
|
#define get_RS_SKSV(b) getbitfield(b+0x0f,1,7) /* valid=0 */
|
|
|
|
#define get_RS_SKSB(b) getnbyte(b+0x0f, 3)
|
2002-04-17 18:50:39 +00:00
|
|
|
|
2006-05-14 15:29:08 +00:00
|
|
|
/* when RS is 0x05/0x26 bad bytes listed in sksb */
|
|
|
|
#define get_RS_offending_byte(b) getnbyte(b+0x10, 2)
|
2002-04-17 18:50:39 +00:00
|
|
|
|
2006-05-14 15:29:08 +00:00
|
|
|
/* 3091 and 3092 use RS instead of ghs. RS must be 0x00/0x80 */
|
|
|
|
/* in ascq */
|
|
|
|
#define get_RS_adf_open(in) getbitfield(in+0x0d, 1, 7)
|
|
|
|
#define get_RS_send_sw(in) getbitfield(in+0x0d, 1, 5)
|
|
|
|
#define get_RS_scan_sw(in) getbitfield(in+0x0d, 1, 4)
|
|
|
|
#define get_RS_duplex_sw(in) getbitfield(in+0x0d, 1, 2)
|
|
|
|
#define get_RS_top(in) getbitfield(in+0x0d, 1, 1)
|
|
|
|
#define get_RS_hopper(in) getbitfield(in+0x0d, 1, 0)
|
|
|
|
|
|
|
|
/* in sksb */
|
|
|
|
#define get_RS_function(in) getbitfield(in+0x0f, 0x0f, 3)
|
|
|
|
#define get_RS_density(in) getbitfield(in+0x0f, 0x07, 0)
|
2002-04-17 18:50:39 +00:00
|
|
|
|
|
|
|
/* ==================================================================== */
|
|
|
|
|
|
|
|
#endif
|