diff options
Diffstat (limited to 'backend/lexmark_low.c')
| -rw-r--r-- | backend/lexmark_low.c | 6106 |
1 files changed, 6106 insertions, 0 deletions
diff --git a/backend/lexmark_low.c b/backend/lexmark_low.c new file mode 100644 index 0000000..ae0db2c --- /dev/null +++ b/backend/lexmark_low.c @@ -0,0 +1,6106 @@ +/* lexmark-low.c: scanner-interface file for low Lexmark scanners. + + (C) 2005 Fred Odendaal + (C) 2006-2013 Stéphane Voltz <stef.dev@free.fr> + (C) 2010 "Torsten Houwaart" <ToHo@gmx.de> X74 support + + This file is part of the SANE package. + + This program is free software; you can redistribute it and/or + modify it under the terms of the GNU General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. + + This program is distributed in the hope that it will be useful, but + WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place - Suite 330, Boston, + MA 02111-1307, USA. + + As a special exception, the authors of SANE give permission for + additional uses of the libraries contained in this release of SANE. + + The exception is that, if you link a SANE library with other files + to produce an executable, this does not by itself cause the + resulting executable to be covered by the GNU General Public + License. Your use of that executable is in no way restricted on + account of linking the SANE library code into it. + + This exception does not, however, invalidate any other reasons why + the executable file might be covered by the GNU General Public + License. + + If you submit changes to SANE to the maintainers to be included in + a subsequent release, you agree by submitting the changes that + those changes may be distributed with this exception intact. + + If you write modifications of your own for SANE, it is your choice + whether to permit this exception to apply to your modifications. + If you do not wish that, delete this exception notice. + + **************************************************************************/ + +#undef BACKEND_NAME +#define BACKEND_NAME lexmark_low + +#include "lexmark.h" + +#include "lexmark_sensors.c" +#include "lexmark_models.c" + +/* numbre of ranges for offset */ +#define OFFSET_RANGES 5 + +typedef enum +{ + black = 0, + white +} +region_type; + +#define HomeTolerance 32 + + +#define LOBYTE(x) ((uint8_t)((x) & 0xFF)) +#define HIBYTE(x) ((uint8_t)((x) >> 8)) + +/* Static low function proto-types */ +static SANE_Status low_usb_bulk_write (SANE_Int devnum, + SANE_Byte * cmd, size_t * size); +static SANE_Status low_usb_bulk_read (SANE_Int devnum, + SANE_Byte * buf, size_t * size); +static SANE_Status low_write_all_regs (SANE_Int devnum, SANE_Byte * regs); +static SANE_Bool low_is_home_line (Lexmark_Device * dev, + unsigned char *buffer); +static SANE_Status low_get_start_loc (SANE_Int resolution, + SANE_Int * vert_start, + SANE_Int * hor_start, SANE_Int offset, + Lexmark_Device * dev); +static void low_rewind (Lexmark_Device * dev, SANE_Byte * regs); +static SANE_Status low_start_mvmt (SANE_Int devnum); +static SANE_Status low_stop_mvmt (SANE_Int devnum); +static SANE_Status low_clr_c6 (SANE_Int devnum); +static SANE_Status low_simple_scan (Lexmark_Device * dev, + SANE_Byte * regs, + int xoffset, + int pixels, + int yoffset, + int lines, SANE_Byte ** data); +static void low_set_scan_area (SANE_Int res, + SANE_Int tlx, + SANE_Int tly, + SANE_Int brx, + SANE_Int bry, + SANE_Int offset, + SANE_Bool half_step, + SANE_Byte * regs, Lexmark_Device * dev); + +/* Static Read Buffer Proto-types */ +static SANE_Status read_buffer_init (Lexmark_Device * dev, int bytesperline); +static SANE_Status read_buffer_free (Read_Buffer * rb); +static size_t read_buffer_bytes_available (Read_Buffer * rb); +static SANE_Status read_buffer_add_byte (Read_Buffer * rb, + SANE_Byte * byte_pointer); +static SANE_Status read_buffer_add_byte_gray (Read_Buffer * rb, + SANE_Byte * byte_pointer); +static SANE_Status read_buffer_add_bit_lineart (Read_Buffer * rb, + SANE_Byte * byte_pointer, + SANE_Byte threshold); +static size_t read_buffer_get_bytes (Read_Buffer * rb, SANE_Byte * buffer, + size_t rqst_size); +static SANE_Bool read_buffer_is_empty (Read_Buffer * rb); + + +/* + * RTS88XX START + * + * these rts88xx functions will be spin off in a separate lib + * so that they can be reused. + */ + +/* + * registers helpers to avoid direct access + */ +static SANE_Bool +rts88xx_is_color (SANE_Byte * regs) +{ + if ((regs[0x2f] & 0x11) == 0x11) + return SANE_TRUE; + return SANE_FALSE; +} + +static void +rts88xx_set_gray_scan (SANE_Byte * regs) +{ + regs[0x2f] = (regs[0x2f] & 0x0f) | 0x20; +} + +#if 0 +static void +rts88xx_set_color_scan (SANE_Byte * regs) +{ + regs[0x2f] = (regs[0x2f] & 0x0f) | 0x10; +} +#endif + +static void +rts88xx_set_offset (SANE_Byte * regs, SANE_Byte red, SANE_Byte green, + SANE_Byte blue) +{ + /* offset for odd pixels */ + regs[0x02] = red; + regs[0x03] = green; + regs[0x04] = blue; + + /* offset for even pixels */ + regs[0x05] = red; + regs[0x06] = green; + regs[0x07] = blue; +} + +static void +rts88xx_set_gain (SANE_Byte * regs, SANE_Byte red, SANE_Byte green, + SANE_Byte blue) +{ + regs[0x08] = red; + regs[0x09] = green; + regs[0x0a] = blue; +} + +/* set # of head moves per CIS read */ +static int +rts88xx_set_scan_frequency (SANE_Byte * regs, int frequency) +{ + regs[0x64] = (regs[0x64] & 0xf0) | (frequency & 0x0f); + return 0; +} + +/* + * read one register at given index + */ +static SANE_Status +rts88xx_read_reg (SANE_Int devnum, SANE_Int index, SANE_Byte * reg) +{ + SANE_Status status = SANE_STATUS_GOOD; + unsigned char cmd[] = { 0x80, 0x00, 0x00, 0x01 }; + size_t size; + + cmd[1] = index; + + size = 4; +#ifdef FAKE_USB + status = SANE_STATUS_GOOD; +#else + status = sanei_usb_write_bulk (devnum, cmd, &size); +#endif + if (status != SANE_STATUS_GOOD) + { + DBG (5, "rts88xx_read_reg: bulk write failed\n"); + return status; + } + size = 1; +#ifdef FAKE_USB + status = SANE_STATUS_GOOD; +#else + status = sanei_usb_read_bulk (devnum, reg, &size); +#endif + if (status != SANE_STATUS_GOOD) + { + DBG (5, "rts88xx_read_reg: bulk read failed\n"); + return status; + } + DBG (15, "rts88xx_read_reg: reg[0x%02x]=0x%02x\n", index, *reg); + return status; +} + +/* + * write one register at given index + */ +static SANE_Status +rts88xx_write_reg (SANE_Int devnum, SANE_Int index, SANE_Byte * reg) +{ + SANE_Status status = SANE_STATUS_GOOD; + unsigned char cmd[] = { 0x88, 0x00, 0x00, 0x01 }; + size_t size; + + cmd[1] = index; + + size = 4; +#ifdef FAKE_USB + status = SANE_STATUS_GOOD; +#else + status = sanei_usb_write_bulk (devnum, cmd, &size); +#endif + if (status != SANE_STATUS_GOOD) + { + DBG (5, "rts88xx_write_reg: bulk write failed\n"); + return status; + } + size = 1; +#ifdef FAKE_USB + status = SANE_STATUS_GOOD; +#else + status = sanei_usb_write_bulk (devnum, reg, &size); +#endif + if (status != SANE_STATUS_GOOD) + { + DBG (5, "rts88xx_write_reg: bulk write failed\n"); + return status; + } + DBG (15, "rts88xx_write_reg: reg[0x%02x]=0x%02x\n", index, *reg); + return status; +} + +/* + * write length consecutive registers, starting at index + * register 0xb3 is never wrote in bulk register write, so we split + * write if it belongs to the register set sent + */ +static SANE_Status +rts88xx_write_regs (SANE_Int devnum, SANE_Int start, SANE_Byte * source, + SANE_Int length) +{ + size_t size = 0; + + /* when writing several registers at a time, we avoid writing 0xb3 + register */ + if ((start + length > 0xb3) && (length > 1)) + { + size = 0xb3 - start; + if (low_usb_bulk_write (devnum, source, &size) != SANE_STATUS_GOOD) + { + DBG (5, "rts88xx_write_regs : write registers part 1 failed ...\n"); + return SANE_STATUS_IO_ERROR; + } + + /* skip 0xB3 register */ + size++; + start = 0xb4; + source = source + size; + } + size = length - size; + if (low_usb_bulk_write (devnum, source, &size) != SANE_STATUS_GOOD) + { + DBG (5, "rts88xx_write_regs : write registers part 2 failed ...\n"); + return SANE_STATUS_IO_ERROR; + } + + return SANE_STATUS_GOOD; + +} + +/* + * reads 'needed' bytes of scanned data into 'data'. Actual number of bytes get + * is retruned in 'size' + */ +static SANE_Status +rts88xx_read_data (SANE_Int devnum, size_t needed, SANE_Byte * data, + size_t * size) +{ + SANE_Byte read_cmd[] = { 0x91, 0x00, 0x00, 0x00 }; + size_t cmd_size; + SANE_Status status = SANE_STATUS_GOOD; + + /* this block would deserve to be a function */ + if (needed > MAX_XFER_SIZE) + *size = MAX_XFER_SIZE; + else + *size = needed; + read_cmd[3] = (*size) & 0xff; + read_cmd[2] = (*size >> 8) & 0xff; + read_cmd[1] = (*size >> 16) & 0xff; + + /* send header for 'get scanned data' */ + cmd_size = 4; + status = low_usb_bulk_write (devnum, read_cmd, &cmd_size); + if (status != SANE_STATUS_GOOD) + { + *size = 0; + DBG (5, "rts88xx_read_data : header sending failed ...\n"); + return status; + } + /* get actual scanned data */ + status = low_usb_bulk_read (devnum, data, size); + if (status != SANE_STATUS_GOOD) + { + *size = 0; + DBG (5, "rts88xx_read_data : data reading failed ...\n"); + } + return status; +} + +/* starts scan by sending color depth, stopping head, the starting it */ +static SANE_Status +rts88xx_commit (SANE_Int devnum, SANE_Byte depth) +{ + SANE_Status status; + SANE_Byte reg; + + DBG (2, "rts88xx_commit: start\n"); + + /* send color depth depth ?? + * X1100 -> 0x0f + * X1100/B2 -> 0x0d + * X1200 -> 0x01 */ + reg = depth; + rts88xx_write_reg (devnum, 0x2c, ®); + + /* stop before starting */ + low_stop_mvmt (devnum); + + /* effective start */ + status = low_start_mvmt (devnum); + + DBG (2, "rts88xx_commit: end\n"); + + return status; +} + +/* + * RTS88XX END + */ + + + +/* + * sets the scanner idle + */ +static SANE_Status +lexmark_low_set_idle (SANE_Int devnum) +{ + SANE_Byte regs[14] = + { 0x00, 0x00, 0xff, 0xff, 0x00, 0x00, 0x07, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x60 + }; + if (rts88xx_write_regs (devnum, 16, regs, 14) != SANE_STATUS_GOOD) + { + DBG (5, "lexmark_low_set_idle : register write failed ...\n"); + return SANE_STATUS_IO_ERROR; + } + return SANE_STATUS_GOOD; +} + + +/* wake up scanner */ +#if 0 +static SANE_Status +lexmark_low_wake_up (Lexmark_Device * dev) +{ + SANE_Byte regs[5] = { 0x12, 0x14, 0x16, 0x18, 0x1a }; + SANE_Byte values[5] = { 0x0f, 0x00, 0x07, 0x00, 0x00 }; + int i; + + /* send the wake-up sequence, one reg at at time */ + for (i = 0; i < 10; i++) + { + if (rts88xx_write_reg (dev->devnum, regs[i], values + i) != + SANE_STATUS_GOOD) + { + DBG (5, + "lexmark_low_wake_up : register write pass %d failed ...\n", + i); + return SANE_STATUS_IO_ERROR; + } + } + return SANE_STATUS_GOOD; +} +#endif + + +/** + * + */ +#ifdef DEEP_DEBUG +static void +write_pnm_file (char *title, int pixels, int lines, int color, + unsigned char *data) +{ + FILE *fdbg; + int x, y; + + fdbg = fopen (title, "wb"); + if (fdbg == NULL) + return; + + if (color) + { + fprintf (fdbg, "P6\n%d %d\n255\n", pixels, lines); + for (y = 0; y < lines; y++) + { + for (x = 0; x < pixels; x += 2) + { + fputc (data[y * pixels * 3 + x + 1], fdbg); + fputc (data[y * pixels * 3 + x + 1 + pixels], fdbg); + fputc (data[y * pixels * 3 + x + 1 + pixels * 2], fdbg); + fputc (data[y * pixels * 3 + x], fdbg); + fputc (data[y * pixels * 3 + x + pixels], fdbg); + fputc (data[y * pixels * 3 + x + pixels * 2], fdbg); + } + } + } + else + { + fprintf (fdbg, "P5\n%d %d\n255\n", pixels, lines); + fwrite (data, pixels, lines, fdbg); + } + fclose (fdbg); +} +#endif + +/* + * mid level hardware functions + */ +/* + * model init + */ +SANE_Status +sanei_lexmark_low_init (Lexmark_Device * dev) +{ + int i; + SANE_Status status; + + DBG_INIT (); + + status = SANE_STATUS_UNSUPPORTED; + DBG (2, "low_init: start\n"); + + /* clear all registers first */ + for (i = 0; i < 255; i++) + { + dev->shadow_regs[i] = 0; + } + + /* set up per model constant values */ + dev->shadow_regs[0xf3] = 0xf8; + dev->shadow_regs[0xf4] = 0x7f; + + switch (dev->model.sensor_type) + { + case X74_SENSOR: + dev->shadow_regs[0x00] = 0x04; + dev->shadow_regs[0x01] = 0x43; + dev->shadow_regs[0x0b] = 0x70; + dev->shadow_regs[0x12] = 0x0f; + dev->shadow_regs[0x16] = 0x07; + dev->shadow_regs[0x1d] = 0x20; + dev->shadow_regs[0x28] = 0xe0; + dev->shadow_regs[0x29] = 0xe3; + dev->shadow_regs[0x2a] = 0xeb; + dev->shadow_regs[0x2b] = 0x0d; + dev->shadow_regs[0x2e] = 0x40; + dev->shadow_regs[0x2e] = 0x86; + dev->shadow_regs[0x2f] = 0x01; + dev->shadow_regs[0x30] = 0x48; + dev->shadow_regs[0x31] = 0x06; + dev->shadow_regs[0x33] = 0x01; + dev->shadow_regs[0x34] = 0x50; + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x36] = 0x50; + dev->shadow_regs[0x37] = 0x01; + dev->shadow_regs[0x38] = 0x50; + dev->shadow_regs[0x3a] = 0x20; + dev->shadow_regs[0x3c] = 0x88; + dev->shadow_regs[0x3d] = 0x08; + dev->shadow_regs[0x65] = 0x80; + dev->shadow_regs[0x66] = 0x64; + dev->shadow_regs[0x6c] = 0xc8; + dev->shadow_regs[0x72] = 0x1a; + dev->shadow_regs[0x74] = 0x23; + dev->shadow_regs[0x75] = 0x03; + dev->shadow_regs[0x79] = 0x40; + dev->shadow_regs[0x7A] = 0x01; + dev->shadow_regs[0x8d] = 0x01; + dev->shadow_regs[0x8e] = 0x60; + dev->shadow_regs[0x8f] = 0x80; + dev->shadow_regs[0x93] = 0x02; + dev->shadow_regs[0x94] = 0x0e; + dev->shadow_regs[0xa3] = 0xcc; + dev->shadow_regs[0xa4] = 0x27; + dev->shadow_regs[0xa5] = 0x24; + dev->shadow_regs[0xc2] = 0x80; + dev->shadow_regs[0xc3] = 0x01; + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc5] = 0x0a; + dev->shadow_regs[0xc8] = 0x04; + dev->shadow_regs[0xc9] = 0x39; + dev->shadow_regs[0xca] = 0x0a; + dev->shadow_regs[0xe2] = 0x70; + dev->shadow_regs[0xe3] = 0x17; + dev->shadow_regs[0xf3] = 0xe0; + dev->shadow_regs[0xf4] = 0xff; + dev->shadow_regs[0xf5] = 0x01; + status = SANE_STATUS_GOOD; + break; + case X1100_B2_SENSOR: + dev->shadow_regs[0x01] = 0x43; + dev->shadow_regs[0x0b] = 0x70; + dev->shadow_regs[0x11] = 0x01; + dev->shadow_regs[0x12] = 0x0f; + dev->shadow_regs[0x13] = 0x01; + dev->shadow_regs[0x15] = 0x01; + dev->shadow_regs[0x16] = 0x0f; + dev->shadow_regs[0x1d] = 0x20; + dev->shadow_regs[0x28] = 0xeb; + dev->shadow_regs[0x29] = 0xee; + dev->shadow_regs[0x2a] = 0xf7; + dev->shadow_regs[0x2b] = 0x01; + dev->shadow_regs[0x2e] = 0x86; + dev->shadow_regs[0x30] = 0x48; + dev->shadow_regs[0x33] = 0x01; + dev->shadow_regs[0x3a] = 0x20; + dev->shadow_regs[0x3b] = 0x37; + dev->shadow_regs[0x3c] = 0x88; + dev->shadow_regs[0x3d] = 0x08; + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x72] = 0x05; + dev->shadow_regs[0x74] = 0x0e; + dev->shadow_regs[0x8b] = 0xff; + dev->shadow_regs[0x8c] = 0x02; + dev->shadow_regs[0x8d] = 0x01; + dev->shadow_regs[0x8e] = 0x60; + dev->shadow_regs[0x8f] = 0x80; + dev->shadow_regs[0x94] = 0x0e; + dev->shadow_regs[0xa3] = 0xcc; + dev->shadow_regs[0xa4] = 0x27; + dev->shadow_regs[0xa5] = 0x24; + dev->shadow_regs[0xb0] = 0xb2; + dev->shadow_regs[0xb2] = 0x04; + dev->shadow_regs[0xc2] = 0x80; + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc8] = 0x04; + dev->shadow_regs[0xc9] = 0x3b; + dev->shadow_regs[0xed] = 0xc2; + dev->shadow_regs[0xee] = 0x02; + status = SANE_STATUS_GOOD; + break; + case X1100_2C_SENSOR: + dev->shadow_regs[0x00] = 0x00; + dev->shadow_regs[0x01] = 0x43; + dev->shadow_regs[0x0b] = 0x70; + dev->shadow_regs[0x0c] = 0x28; + dev->shadow_regs[0x0d] = 0xa4; + dev->shadow_regs[0x11] = 0x01; + dev->shadow_regs[0x12] = 0x0f; + dev->shadow_regs[0x13] = 0x01; + dev->shadow_regs[0x15] = 0x01; + dev->shadow_regs[0x16] = 0x0f; + dev->shadow_regs[0x17] = 0x00; + dev->shadow_regs[0x1d] = 0x20; + dev->shadow_regs[0x28] = 0xf5; + dev->shadow_regs[0x29] = 0xf7; + dev->shadow_regs[0x2a] = 0xf5; + dev->shadow_regs[0x2b] = 0x17; + dev->shadow_regs[0x2d] = 0x41; + dev->shadow_regs[0x2e] = 0x86; + dev->shadow_regs[0x2f] = 0x11; + dev->shadow_regs[0x30] = 0x48; + dev->shadow_regs[0x31] = 0x01; + dev->shadow_regs[0x33] = 0x01; + dev->shadow_regs[0x34] = 0x50; + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x36] = 0x50; + dev->shadow_regs[0x37] = 0x01; + dev->shadow_regs[0x38] = 0x50; + dev->shadow_regs[0x3a] = 0x20; + dev->shadow_regs[0x3b] = 0x37; + dev->shadow_regs[0x3c] = 0x88; + dev->shadow_regs[0x3d] = 0x08; + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x47] = 0x01; + dev->shadow_regs[0x48] = 0x1a; + dev->shadow_regs[0x49] = 0x5b; + dev->shadow_regs[0x4a] = 0x1b; + dev->shadow_regs[0x4b] = 0x5b; + dev->shadow_regs[0x4c] = 0x05; + dev->shadow_regs[0x4d] = 0x3f; + dev->shadow_regs[0x60] = 0x2f; + dev->shadow_regs[0x61] = 0x36; + dev->shadow_regs[0x62] = 0x30; + dev->shadow_regs[0x63] = 0x36; + dev->shadow_regs[0x65] = 0x80; + dev->shadow_regs[0x66] = 0x64; + dev->shadow_regs[0x6c] = 0xc8; + dev->shadow_regs[0x6d] = 0x00; + dev->shadow_regs[0x72] = 0x35; + dev->shadow_regs[0x74] = 0x4e; + dev->shadow_regs[0x75] = 0x03; + dev->shadow_regs[0x79] = 0x40; + dev->shadow_regs[0x7a] = 0x01; + dev->shadow_regs[0x85] = 0x02; + dev->shadow_regs[0x86] = 0x33; + dev->shadow_regs[0x87] = 0x0f; + dev->shadow_regs[0x88] = 0x24; + dev->shadow_regs[0x8b] = 0xff; + dev->shadow_regs[0x8c] = 0x02; + dev->shadow_regs[0x8d] = 0x01; + dev->shadow_regs[0x8e] = 0x60; + dev->shadow_regs[0x8f] = 0x80; + dev->shadow_regs[0x91] = 0x19; + dev->shadow_regs[0x92] = 0x20; + dev->shadow_regs[0x93] = 0x02; + dev->shadow_regs[0x94] = 0x0e; + dev->shadow_regs[0xa3] = 0x0d; + dev->shadow_regs[0xa4] = 0x5e; + dev->shadow_regs[0xa5] = 0x23; + dev->shadow_regs[0xb0] = 0x2c; + dev->shadow_regs[0xb1] = 0x07; + dev->shadow_regs[0xb2] = 0x04; + dev->shadow_regs[0xc2] = 0x80; + dev->shadow_regs[0xc3] = 0x01; + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc5] = 0x0a; + dev->shadow_regs[0xc8] = 0x04; + dev->shadow_regs[0xc9] = 0x3b; + dev->shadow_regs[0xca] = 0x0a; + dev->shadow_regs[0xe2] = 0xf8; + dev->shadow_regs[0xe3] = 0x2a; + status = SANE_STATUS_GOOD; + break; + case X1200_USB2_SENSOR: + dev->shadow_regs[0x01] = 0x43; + dev->shadow_regs[0x11] = 0x01; + dev->shadow_regs[0x12] = 0x0f; + dev->shadow_regs[0x13] = 0x01; + dev->shadow_regs[0x15] = 0x01; + dev->shadow_regs[0x16] = 0x0f; + dev->shadow_regs[0x17] = 0x00; + dev->shadow_regs[0x1d] = 0x20; + dev->shadow_regs[0x28] = 0xf5; + dev->shadow_regs[0x29] = 0xf7; + dev->shadow_regs[0x2a] = 0xf5; + dev->shadow_regs[0x2b] = 0x17; + dev->shadow_regs[0x2d] = 0x41; + dev->shadow_regs[0x2e] = 0x86; + dev->shadow_regs[0x30] = 0x48; + dev->shadow_regs[0x31] = 0x01; + dev->shadow_regs[0x33] = 0x01; + dev->shadow_regs[0x34] = 0x50; + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x36] = 0x50; + dev->shadow_regs[0x37] = 0x01; + dev->shadow_regs[0x38] = 0x50; + dev->shadow_regs[0x3c] = 0x88; + dev->shadow_regs[0x3d] = 0x08; + dev->shadow_regs[0x66] = 0x64; + dev->shadow_regs[0x67] = 0x00; + dev->shadow_regs[0x6c] = 0xc8; + dev->shadow_regs[0x6d] = 0x00; + dev->shadow_regs[0x72] = 0x35; + dev->shadow_regs[0x74] = 0x4e; + dev->shadow_regs[0x75] = 0x03; + dev->shadow_regs[0x7a] = 0x01; + dev->shadow_regs[0x93] = 0x0a; + dev->shadow_regs[0x94] = 0x0e; + + dev->shadow_regs[0xc3] = 0x01; + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc5] = 0x0a; + dev->shadow_regs[0xc8] = 0x04; + dev->shadow_regs[0xc9] = 0x3b; + dev->shadow_regs[0xca] = 0x0a; + dev->shadow_regs[0xe2] = 0xf8; + dev->shadow_regs[0xe3] = 0x2a; + status = SANE_STATUS_GOOD; + break; + case A920_SENSOR: + dev->shadow_regs[0x01] = 0x43; + dev->shadow_regs[0x0b] = 0x70; + dev->shadow_regs[0x0c] = 0x28; + dev->shadow_regs[0x0d] = 0xa4; + dev->shadow_regs[0x11] = 0x01; + dev->shadow_regs[0x12] = 0x0f; + dev->shadow_regs[0x13] = 0x01; + dev->shadow_regs[0x15] = 0x01; + dev->shadow_regs[0x16] = 0x07; + dev->shadow_regs[0x1d] = 0x20; + dev->shadow_regs[0x28] = 0xf5; + dev->shadow_regs[0x29] = 0xf7; + dev->shadow_regs[0x2a] = 0xf5; + dev->shadow_regs[0x2b] = 0x17; + dev->shadow_regs[0x2e] = 0x86; + dev->shadow_regs[0x30] = 0x48; + dev->shadow_regs[0x31] = 0x01; + dev->shadow_regs[0x33] = 0x01; + dev->shadow_regs[0x3a] = 0x20; + dev->shadow_regs[0x3b] = 0x37; + dev->shadow_regs[0x3c] = 0x88; + dev->shadow_regs[0x3d] = 0x08; + dev->shadow_regs[0x47] = 0x21; + dev->shadow_regs[0x48] = 0x1a; + dev->shadow_regs[0x49] = 0x5b; + dev->shadow_regs[0x4a] = 0x1b; + dev->shadow_regs[0x4b] = 0x5b; + dev->shadow_regs[0x4c] = 0x05; + dev->shadow_regs[0x4d] = 0x3f; + dev->shadow_regs[0x65] = 0x80; + dev->shadow_regs[0x86] = 0x14; + dev->shadow_regs[0x87] = 0x06; + dev->shadow_regs[0x89] = 0xf5; + dev->shadow_regs[0x8d] = 0x01; + dev->shadow_regs[0x8e] = 0x60; + dev->shadow_regs[0x8f] = 0x80; + dev->shadow_regs[0x94] = 0x0e; + dev->shadow_regs[0xa3] = 0x0d; + dev->shadow_regs[0xa4] = 0x5e; + dev->shadow_regs[0xa5] = 0x23; + dev->shadow_regs[0xb0] = 0x2c; + dev->shadow_regs[0xb1] = 0x0f; + dev->shadow_regs[0xc2] = 0x80; + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc8] = 0x04; + status = SANE_STATUS_GOOD; + break; + case X1200_SENSOR: + dev->shadow_regs[0x01] = 0x43; + dev->shadow_regs[0x0b] = 0x70; + dev->shadow_regs[0x0c] = 0x28; + dev->shadow_regs[0x0d] = 0xa4; + dev->shadow_regs[0x11] = 0x01; + dev->shadow_regs[0x12] = 0x0f; + dev->shadow_regs[0x13] = 0x01; + dev->shadow_regs[0x15] = 0x01; + dev->shadow_regs[0x16] = 0x0f; + dev->shadow_regs[0x1d] = 0x20; + dev->shadow_regs[0x28] = 0xe9; + dev->shadow_regs[0x29] = 0xeb; + dev->shadow_regs[0x2a] = 0xe9; + dev->shadow_regs[0x2b] = 0x0b; + dev->shadow_regs[0x2d] = 0x01; + dev->shadow_regs[0x2e] = 0x86; + dev->shadow_regs[0x2f] = 0x11; + dev->shadow_regs[0x30] = 0x48; + dev->shadow_regs[0x33] = 0x01; + dev->shadow_regs[0x34] = 0x50; + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x36] = 0x50; + dev->shadow_regs[0x37] = 0x01; + dev->shadow_regs[0x38] = 0x50; + dev->shadow_regs[0x3a] = 0x20; + dev->shadow_regs[0x3b] = 0x37; + dev->shadow_regs[0x3c] = 0x88; + dev->shadow_regs[0x3d] = 0x08; + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x47] = 0x01; + dev->shadow_regs[0x48] = 0x1a; + dev->shadow_regs[0x49] = 0x5b; + dev->shadow_regs[0x4a] = 0x1b; + dev->shadow_regs[0x4b] = 0x5b; + dev->shadow_regs[0x4c] = 0x05; + dev->shadow_regs[0x4d] = 0x3f; + dev->shadow_regs[0x60] = 0x12; + dev->shadow_regs[0x62] = 0x81; + dev->shadow_regs[0x63] = 0x03; + dev->shadow_regs[0x65] = 0x80; + dev->shadow_regs[0x66] = 0x64; + dev->shadow_regs[0x6c] = 0xc8; + dev->shadow_regs[0x72] = 0x1e; + dev->shadow_regs[0x74] = 0x3c; + dev->shadow_regs[0x75] = 0x03; + dev->shadow_regs[0x79] = 0x40; + dev->shadow_regs[0x7a] = 0x01; + dev->shadow_regs[0x85] = 0x20; + dev->shadow_regs[0x86] = 0x1e; + dev->shadow_regs[0x87] = 0x39; + dev->shadow_regs[0x8b] = 0xff; + dev->shadow_regs[0x8c] = 0x02; + dev->shadow_regs[0x8d] = 0x01; + dev->shadow_regs[0x8e] = 0x60; + dev->shadow_regs[0x8f] = 0x80; + dev->shadow_regs[0x92] = 0x92; + dev->shadow_regs[0x93] = 0x02; + dev->shadow_regs[0x94] = 0x0e; + dev->shadow_regs[0xa3] = 0x0d; + dev->shadow_regs[0xa4] = 0x5e; + dev->shadow_regs[0xa5] = 0x23; + dev->shadow_regs[0xb0] = 0x2c; + dev->shadow_regs[0xb1] = 0x07; + dev->shadow_regs[0xb2] = 0x04; + dev->shadow_regs[0xc2] = 0x80; + dev->shadow_regs[0xc3] = 0x01; + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc5] = 0x0a; + dev->shadow_regs[0xc8] = 0x04; + dev->shadow_regs[0xc9] = 0x3b; + dev->shadow_regs[0xca] = 0x0a; + dev->shadow_regs[0xe2] = 0xf8; + dev->shadow_regs[0xe3] = 0x2a; + dev->shadow_regs[0xf3] = 0xff; + dev->shadow_regs[0xf4] = 0x0f; + break; + } + DBG (5, "sanei_lexmark_low_init: init done for model %s/%s\n", + dev->model.model, dev->model.name); + DBG (2, "low_init: done\n"); + return status; +} + +void +sanei_lexmark_low_destroy (Lexmark_Device * dev) +{ + /* free the read buffer */ + if (dev->read_buffer != NULL) + read_buffer_free (dev->read_buffer); +} + + +SANE_Status +low_usb_bulk_write (SANE_Int devnum, SANE_Byte * cmd, size_t * size) +{ + SANE_Status status; + size_t cmd_size; + + cmd_size = *size; +#ifdef FAKE_USB + status = SANE_STATUS_GOOD; +#else + status = sanei_usb_write_bulk (devnum, cmd, size); +#endif + if (status != SANE_STATUS_GOOD) + { + DBG (5, + "low_usb_bulk_write: returned %s (size = %lu, expected %lu)\n", + sane_strstatus (status), (u_long) * size, (u_long) cmd_size); + /* F.O. should reset the pipe here... */ + } + return status; +} + +SANE_Status +low_usb_bulk_read (SANE_Int devnum, SANE_Byte * buf, size_t * size) +{ + SANE_Status status; + size_t exp_size; + + exp_size = *size; +#ifdef FAKE_USB + status = SANE_STATUS_GOOD; +#else + status = sanei_usb_read_bulk (devnum, buf, size); +#endif + if (status != SANE_STATUS_GOOD) + { + DBG (5, + "low_usb_bulk_read: returned %s (size = %lu, expected %lu)\n", + sane_strstatus (status), (u_long) * size, (u_long) exp_size); + /* F.O. should reset the pipe here... */ + } + DBG (7, "low_usb_bulk_read: returned size = %lu (required %lu)\n", + (u_long) * size, (u_long) exp_size); + return status; +} + + +SANE_Status +low_start_mvmt (SANE_Int devnum) +{ + SANE_Status status; + SANE_Byte reg; + + reg = 0x68; + rts88xx_write_reg (devnum, 0xb3, ®); + status = rts88xx_write_reg (devnum, 0xb3, ®); + return status; +} + +SANE_Status +low_stop_mvmt (SANE_Int devnum) +{ + SANE_Status status; + SANE_Byte reg; + + /* Stop scanner - clear reg 0xb3: */ + reg = 0x02; + rts88xx_write_reg (devnum, 0xb3, ®); + rts88xx_write_reg (devnum, 0xb3, ®); + reg = 0x00; + rts88xx_write_reg (devnum, 0xb3, ®); + status = rts88xx_write_reg (devnum, 0xb3, ®); + return status; +} + +SANE_Status +low_clr_c6 (SANE_Int devnum) +{ + SANE_Status status; + SANE_Byte reg; + + /* Clear register 0xC6 */ + /* cmd_size = 0x05; + return low_usb_bulk_write (devnum, clearC6_command_block, &cmd_size); */ + + reg = 0x00; + status = rts88xx_write_reg (devnum, 0xc6, ®); + return status; +} + +/* stops current scan */ +static SANE_Status +low_cancel (SANE_Int devnum) +{ + SANE_Status status; + + DBG (2, "low_cancel: start\n"); + status = low_stop_mvmt (devnum); + if (status != SANE_STATUS_GOOD) + return status; + status = low_clr_c6 (devnum); + if (status != SANE_STATUS_GOOD) + return status; + DBG (2, "low_cancel: end.\n"); + return status; +} + +static SANE_Status +low_start_scan (SANE_Int devnum, SANE_Byte * regs) +{ + SANE_Status status; + + DBG (2, "low_start_scan: start\n"); + + /* writes registers to scanner */ + regs[0x32] = 0x00; + status = low_write_all_regs (devnum, regs); + if (status != SANE_STATUS_GOOD) + return status; + regs[0x32] = 0x40; + status = low_write_all_regs (devnum, regs); + if (status != SANE_STATUS_GOOD) + return status; + + /* Stop scanner - clear reg 0xb3: */ + /* status = low_stop_mvmt (devnum); + if (status != SANE_STATUS_GOOD) + return status; */ + + /* then start */ + status = rts88xx_commit (devnum, regs[0x2c]); + DBG (2, "low_start_scan: end.\n"); + return status; +} + +/* wait for scan data being available */ +static SANE_Status +low_poll_data (SANE_Int devnum) +{ + SANE_Status status; + int loops = 0; + size_t size; + static SANE_Byte command4_block[] = { 0x90, 0x00, 0x00, 0x03 }; + SANE_Byte result[3]; + SANE_Word count; + + /* Poll the available byte count until not 0 */ + while (loops < 1000) + { + /* 10 ms sleep */ + usleep (10000); + + /* as stated in sanei_lexmark_low_search_home_bwd, we read + * available data count twice */ + size = 4; + status = low_usb_bulk_write (devnum, command4_block, &size); + if (status != SANE_STATUS_GOOD) + return status; + size = 0x3; + status = low_usb_bulk_read (devnum, result, &size); + if (status != SANE_STATUS_GOOD) + return status; + size = 4; + /* read availbale data size again */ + status = low_usb_bulk_write (devnum, command4_block, &size); + if (status != SANE_STATUS_GOOD) + return status; + size = 0x3; + status = low_usb_bulk_read (devnum, result, &size); + if (status != SANE_STATUS_GOOD) + return status; + count = result[0] + (result[1] << 8) + (result[2] << 16); + if (count != 0) + { + DBG (15, "low_poll_data: %d bytes available\n", count); + return SANE_STATUS_GOOD; + } + loops++; + } + return SANE_STATUS_IO_ERROR; +} + +/** + * do a simple scan with the given registers. data buffer is allocated within + * the function + */ +static SANE_Status +low_simple_scan (Lexmark_Device * dev, SANE_Byte * regs, int xoffset, + int pixels, int yoffset, int lines, SANE_Byte ** data) +{ + SANE_Status status = SANE_STATUS_GOOD; + static SANE_Byte reg; + size_t size, read, needed; + int i, bpl, yend; + + DBG (2, "low_simple_scan: start\n"); + DBG (15, "low_simple_scan: x=%d, pixels=%d (ex=%d), y=%d, lines=%d\n", + xoffset, pixels, xoffset + pixels * regs[0x7a], yoffset, lines); + + /* set up registers */ + regs[0x60] = LOBYTE (yoffset); + regs[0x61] = HIBYTE (yoffset); + yend = yoffset + lines; + if ((dev->model.motor_type == A920_MOTOR + || dev->model.motor_type == X74_MOTOR) && rts88xx_is_color (regs) + && dev->val[OPT_RESOLUTION].w == 600) + yend *= 2; + regs[0x62] = LOBYTE (yend); + regs[0x63] = HIBYTE (yend); + + regs[0x66] = LOBYTE (xoffset); + regs[0x67] = HIBYTE (xoffset); + + regs[0x6c] = LOBYTE (xoffset + pixels * regs[0x7a]); + regs[0x6d] = HIBYTE (xoffset + pixels * regs[0x7a]); + + /* allocate memory */ + if (rts88xx_is_color (regs)) + bpl = 3 * pixels; + else + bpl = pixels; + *data = (SANE_Byte *) malloc (bpl * lines); + if (*data == NULL) + { + DBG (2, + "low_simple_scan: failed to allocate %d bytes !\n", bpl * lines); + return SANE_STATUS_NO_MEM; + } + + /* start scan */ + status = low_cancel (dev->devnum); + if (status != SANE_STATUS_GOOD) + return status; + + + status = low_start_scan (dev->devnum, regs); + if (status != SANE_STATUS_GOOD) + return status; + + /* wait for data */ + status = low_poll_data (dev->devnum); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "low_simple_scan: time-out while waiting for data.\n"); + return status; + } + + /* data reading loop */ + needed = bpl * lines; + DBG (1, "low_simple_scan: bpl=%d, lines=%d, needed=%lu.\n", bpl, lines, + (u_long) needed); + read = 0; + do + { + /* this block would deserve to be a function */ + status = + rts88xx_read_data (dev->devnum, needed - read, (*data) + read, &size); + if (status != SANE_STATUS_GOOD) + return status; + read += size; + } + while (read < needed); + + /* if needed, wait for motor to stop */ + if (regs[0xc3] & 0x80) + { + i = 0; + do + { + if (rts88xx_read_reg (dev->devnum, 0xb3, ®) != SANE_STATUS_GOOD) + { + DBG (5, "low_simple_scan: register read failed ...\n"); + return SANE_STATUS_IO_ERROR; + } + usleep (100000); + i++; + } + while ((reg & 0x08) && (i < 100)); + if (reg & 0x08) + { + DBG (5, + "low_simple_scan : timeout waiting for motor to stop ...\n"); + return SANE_STATUS_IO_ERROR; + } + } + + /* stop scan */ + status = low_cancel (dev->devnum); + if (status != SANE_STATUS_GOOD) + { + DBG (1, "low_simple_scan: cancel failed.\n"); + return status; + } + + DBG (2, "low_simple_scan: end.\n"); + return status; +} + +/* + * open USB device ,read initial registers values and probe sensor + */ +SANE_Status +sanei_lexmark_low_open_device (Lexmark_Device * dev) +{ + /* This function calls the Sane Interface to open this usb device. + It also needlessly does what the Windows driver does and reads + the entire register set - this may be removed. */ + + SANE_Status result; + static SANE_Byte command_block[] = { 0x80, 0, 0x00, 0xFF }; + size_t size; + SANE_Byte variant = 0; + SANE_Byte shadow_regs[255]; + int sx, ex; + int sy, ey; + int i; + char msg[2048]; + + +#ifdef FAKE_USB + result = SANE_STATUS_GOOD; + shadow_regs[0x00] = 0x91; + shadow_regs[0xb0] = 0x2c; + shadow_regs[0x10] = 0x97; + shadow_regs[0x10] = 0x87; + shadow_regs[0xf3] = 0xf8; + shadow_regs[0xf4] = 0x7f; +#else + result = sanei_usb_open (dev->sane.name, &(dev->devnum)); +#endif + DBG (2, "sanei_lexmark_low_open_device: devnum=%d\n", dev->devnum); + + size = 4; + low_usb_bulk_write (dev->devnum, command_block, &size); + size = 0xFF; + memset (shadow_regs, 0, sizeof (shadow_regs)); + low_usb_bulk_read (dev->devnum, shadow_regs, &size); + + if (DBG_LEVEL > 2) + { + DBG (2, "sanei_lexmark_low_open_device: initial registers values\n"); + for (i = 0; i < 255; i++) + { + sprintf (msg + i * 5, "0x%02x ", shadow_regs[i]); + } + DBG (3, "%s\n", msg); + } + + /* it seems that at first read after reset, registers hold information + * about the scanner. Register 0x00 is overwritten with 0, so only first read + * after USB plug-in gives this value */ + if (shadow_regs[0] == 0x91) + { + sx = shadow_regs[0x67] * 256 + shadow_regs[0x66]; + ex = shadow_regs[0x6d] * 256 + shadow_regs[0x6c]; + DBG (7, "startx=%d, endx=%d, pixels=%d, coef=%d, r2f=0x%02x\n", sx, ex, + ex - sx, dev->shadow_regs[0x7a], shadow_regs[0x2f]); + sy = shadow_regs[0x61] * 256 + shadow_regs[0x60]; + ey = shadow_regs[0x63] * 256 + shadow_regs[0x62]; + DBG (7, "starty=%d, endy=%d, lines=%d\n", sy, ey, ey - sy); + } + + /* we use register 0xb0 to identify details about models */ + /* this register isn't overwritten during normal operation */ + if (shadow_regs[0xb0] == 0x2c && dev->model.sensor_type == X1100_B2_SENSOR) + { + variant = shadow_regs[0xb0]; + } + /* now the same with register 0x10 */ + /* which most likely signals USB2.0/USB1.1 */ + if ((dev->model.sensor_type == X1200_SENSOR) && (shadow_regs[0x10] == 0x97)) + { + variant = shadow_regs[0x10]; + } + + /* if find a case where default model given is inappropriate, reassign it + * since we have now the informations to get the real one. + * We could avoid this if attach() did open and read registers, not init */ + if (variant != 0) + { + DBG (3, + "sanei_lexmark_low_open_device: reassign model/sensor for variant 0x%02x\n", + variant); + sanei_lexmark_low_assign_model (dev, dev->sane.name, + dev->model.vendor_id, + dev->model.product_id, variant); + /* since model has changed, run init again */ + sanei_lexmark_low_init (dev); + } + DBG (2, "sanei_lexmark_low_open_device: end\n"); + return result; +} + +void +sanei_lexmark_low_close_device (Lexmark_Device * dev) +{ + /* put scanner in idle state */ + lexmark_low_set_idle (dev->devnum); + + /* This function calls the Sane USB library to close this usb device */ +#ifndef FAKE_USB + sanei_usb_close (dev->devnum); +#endif + return; +} + + +/* This function writes the contents of the given registers to the + scanner. */ +SANE_Status +low_write_all_regs (SANE_Int devnum, SANE_Byte * regs) +{ + int i; + SANE_Status status; + size_t size; + static SANE_Byte command_block1[0xb7]; + static SANE_Byte command_block2[0x4f]; + command_block1[0] = 0x88; + command_block1[1] = 0x00; + command_block1[2] = 0x00; + command_block1[3] = 0xb3; + for (i = 0; i < 0xb3; i++) + { + command_block1[i + 4] = regs[i]; + } + command_block2[0] = 0x88; + command_block2[1] = 0xb4; + command_block2[2] = 0x00; + command_block2[3] = 0x4b; + for (i = 0; i < 0x4b; i++) + { + command_block2[i + 4] = regs[i + 0xb4]; + } + size = 0xb7; + +#ifdef DEEP_DEBUG + fprintf (stderr, "write_all(0x00,255)="); + for (i = 0; i < 255; i++) + { + fprintf (stderr, "0x%02x ", regs[i]); + } + fprintf (stderr, "\n"); +#endif + + status = low_usb_bulk_write (devnum, command_block1, &size); + if (status != SANE_STATUS_GOOD) + return status; + size = 0x4f; + status = low_usb_bulk_write (devnum, command_block2, &size); + if (status != SANE_STATUS_GOOD) + return status; + return SANE_STATUS_GOOD; +} + + +SANE_Bool +low_is_home_line (Lexmark_Device * dev, unsigned char *buffer) +{ + /* + This function assumes the buffer has a size of 2500 bytes.It is + destructive to the buffer. + + Here is what it does: + + Go through the buffer finding low and high values, which are computed by + comparing to the average: + average = (lowest value + highest value)/2 + High bytes are changed to 0xFF (white), lower or equal bytes are changed + to 0x00 (black),so that the buffer only contains white (0xFF) or black + (0x00) values. + + Next, we go through the buffer. We use a tolerance of 5 bytes on each end + of the buffer and check a region from bytes 5 to 2495. We start assuming + we are in a white region and look for the start of a black region. We save + this index as the transition from white to black. We also save where we + change from black back to white. We continue checking for transitions + until the end of the check region. If we don't have exactly two + transitions when we reach the end we return SANE_FALSE. + + The final check compares the transition indices to the nominal values + plus or minus the tolerence. For the first transition (white to black + index) the value must lie in the range 1235-30 (1205) to 1235+30 (1265). + For the second transition (black to white) the value must lie in the range + 1258-30 (1228) to 1258+30 (1288). If the indices are out of range we + return SANE_FALSE. Otherwise, we return SANE_TRUE. + */ + + + unsigned char max_byte = 0; + unsigned char min_byte = 0xFF; + unsigned char average; + int i; + int home_point1; + int home_point2; + region_type region; + int transition_counter; + int index1 = 0; + int index2 = 0; + int low_range, high_range; + +#ifdef DEEP_DEBUG + static int numero = 0; + char titre[80]; + FILE *trace = NULL; + sprintf (titre, "lgn%03d.pnm", numero); + trace = fopen (titre, "wb"); + if (trace) + { + fprintf (trace, "P5\n2500 1\n255\n"); + fwrite (buffer, 2500, 1, trace); + fclose (trace); + } + numero++; +#endif + + DBG (15, "low_is_home_line: start\n"); + /* Find the max and the min */ + for (i = 0; i < 2500; i++) + { + if (*(buffer + i) > max_byte) + max_byte = *(buffer + i); + if (*(buffer + i) < min_byte) + min_byte = *(buffer + i); + } + + /* The average */ + average = ((max_byte + min_byte) / 2); + + /* Set bytes as white (0xFF) or black (0x00) */ + for (i = 0; i < 2500; i++) + { + if (*(buffer + i) > average) + *(buffer + i) = 0xFF; + else + *(buffer + i) = 0x00; + } + + region = white; + transition_counter = 0; + + /* Go through the check region - bytes 5 to 2495 */ + /* XXX STEF XXX shrink the area to where the dot should be + * +-100 around the 1250 expected location */ + for (i = 1150; i <= 1350; i++) + { + /* Check for transition to black */ + if ((region == white) && (*(buffer + i) == 0)) + { + if (transition_counter < 2) + { + region = black; + index1 = i; + transition_counter++; + } + else + { + DBG (15, "low_is_home_line: no transition to black \n"); + return SANE_FALSE; + } + } + /* Check for transition to white */ + else if ((region == black) && (*(buffer + i) == 0xFF)) + { + if (transition_counter < 2) + { + region = white; + index2 = i; + transition_counter++; + } + else + { + DBG (15, "low_is_home_line: no transition to white \n"); + return SANE_FALSE; + } + } + } + + /* Check that the number of transitions is 2 */ + if (transition_counter != 2) + { + DBG (15, "low_is_home_line: transitions!=2 (%d)\n", transition_counter); + return SANE_FALSE; + } + + + + + /* Check that the 1st index is in range */ + home_point1 = dev->model.HomeEdgePoint1; + low_range = home_point1 - HomeTolerance; + high_range = home_point1 + HomeTolerance; + + if ((index1 < low_range) || (index1 > high_range)) + { + DBG (15, "low_is_home_line: index1=%d out of range\n", index1); + return SANE_FALSE; + } + + + /* Check that the 2nd index is in range */ + home_point2 = dev->model.HomeEdgePoint2; + low_range = home_point2 - HomeTolerance; + high_range = home_point2 + HomeTolerance; + + if ((index2 < low_range) || (index2 > high_range)) + { + DBG (15, "low_is_home_line: index2=%d out of range.\n", index2); + return SANE_FALSE; + } + + /* We made it this far, so its a good home line. Return True */ + DBG (15, "low_is_home_line: success\n"); + return SANE_TRUE; +} + +void +sanei_lexmark_low_move_fwd (SANE_Int distance, Lexmark_Device * dev, + SANE_Byte * regs) +{ + /* + This function moves the scan head forward with the highest vertical + resolution of 1200dpi. The distance moved is given by the distance + parameter. + + As an example, given a distance parameter of 600, the scan head will + move 600/1200", or 1/2" forward. + */ + + static SANE_Byte pollstopmoving_command_block[] = + { 0x80, 0xb3, 0x00, 0x01 }; + + + size_t cmd_size; + SANE_Int devnum; + SANE_Bool scan_head_moving; + SANE_Byte read_result; + + DBG (2, "sanei_lexmark_low_move_fwd: \n"); + devnum = dev->devnum; + + + /* registers set-up */ + regs[0x2c] = 0x00; + regs[0x2d] = 0x41; + regs[0x65] = 0x80; + switch (dev->model.sensor_type) + { + case X74_SENSOR: + rts88xx_set_scan_frequency (regs, 0); + regs[0x93] = 0x06; + break; + case X1100_B2_SENSOR: + regs[0x8b] = 0x00; + regs[0x8c] = 0x00; + regs[0x93] = 0x06; + break; + case X1100_2C_SENSOR: + rts88xx_set_scan_frequency (regs, 0); + regs[0x93] = 0x06; + break; + case A920_SENSOR: + rts88xx_set_scan_frequency (regs, 0); + regs[0x8b] = 0xff; + regs[0x8c] = 0x02; + regs[0x93] = 0x0e; + break; + case X1200_SENSOR: + dev->shadow_regs[0x2d] = 0x01; + rts88xx_set_scan_frequency (regs, 0); + break; + case X1200_USB2_SENSOR: + dev->shadow_regs[0x2d] = 0x4f; + rts88xx_set_scan_frequency (regs, 0); + break; + } + + /* set grayscale scan + nodata/nochannel? */ + regs[0x2f] = 0xa1; + + /* set ? */ + regs[0x34] = 0x50; + regs[0x35] = 0x01; + regs[0x36] = 0x50; + regs[0x37] = 0x01; + regs[0x38] = 0x50; + /* set motor resolution divisor */ + regs[0x39] = 0x00; + /* set vertical start/end positions */ + regs[0x60] = LOBYTE (distance - 1); + regs[0x61] = HIBYTE (distance - 1); + regs[0x62] = LOBYTE (distance); + regs[0x63] = HIBYTE (distance); + /* set horizontal start position */ + regs[0x66] = 0x64; + regs[0x67] = 0x00; + /* set horizontal end position */ + regs[0x6c] = 0xc8; + regs[0x6d] = 0x00; + /* set horizontal resolution */ + regs[0x79] = 0x40; + regs[0x7a] = 0x01; + /* don't buffer data for this scan */ + regs[0xb2] = 0x04; + /* Motor enable & Coordinate space denominator */ + regs[0xc3] = 0x81; + /* Movement direction & step size */ + regs[0xc6] = 0x09; + /* ? */ + regs[0x80] = 0x00; + regs[0x81] = 0x00; + regs[0x82] = 0x00; + regs[0xc5] = 0x0a; + + + switch (dev->model.motor_type) + { + case X1100_MOTOR: + case A920_MOTOR: + /* step size range2 */ + regs[0xc9] = 0x3b; + /* ? */ + regs[0xca] = 0x0a; + /* motor curve stuff */ + regs[0xe0] = 0x00; + regs[0xe1] = 0x00; + regs[0xe4] = 0x00; + regs[0xe5] = 0x00; + regs[0xe7] = 0x00; + regs[0xe8] = 0x00; + regs[0xe2] = 0x09; + regs[0xe3] = 0x1a; + regs[0xe6] = 0xdc; + regs[0xe9] = 0x1b; + regs[0xec] = 0x07; + regs[0xef] = 0x03; + break; + case X74_MOTOR: + regs[0xc5] = 0x41; + /* step size range2 */ + regs[0xc9] = 0x39; + /* ? */ + regs[0xca] = 0x40; + /* motor curve stuff */ + regs[0xe0] = 0x00; + regs[0xe1] = 0x00; + regs[0xe2] = 0x09; + regs[0xe3] = 0x1a; + regs[0xe4] = 0x00; + regs[0xe5] = 0x00; + regs[0xe6] = 0x64; + regs[0xe7] = 0x00; + regs[0xe8] = 0x00; + regs[0xe9] = 0x32; + regs[0xec] = 0x0c; + regs[0xef] = 0x08; + break; + } + + + /* prepare for register write */ + low_clr_c6 (devnum); + low_stop_mvmt (devnum); + +/* Move Forward without scanning: */ + regs[0x32] = 0x00; + low_write_all_regs (devnum, regs); + regs[0x32] = 0x40; + low_write_all_regs (devnum, regs); + + /* Stop scanner - clear reg 0xb3: */ + /* low_stop_mvmt (devnum); */ + + rts88xx_commit (devnum, regs[0x2c]); + + /* Poll for scanner stopped - return value(3:0) = 0: */ + scan_head_moving = SANE_TRUE; + while (scan_head_moving) + { +#ifdef FAKE_USB + scan_head_moving = SANE_FALSE; +#else + cmd_size = 0x04; + low_usb_bulk_write (devnum, pollstopmoving_command_block, &cmd_size); + cmd_size = 0x1; + low_usb_bulk_read (devnum, &read_result, &cmd_size); + if ((read_result & 0xF) == 0x0) + { + scan_head_moving = SANE_FALSE; + } +#endif + } + + /* this is needed to find the start line properly */ + if (dev->model.sensor_type == X74_SENSOR) + low_stop_mvmt (devnum); + + DBG (2, "sanei_lexmark_low_move_fwd: end.\n"); +} + +SANE_Bool +sanei_lexmark_low_search_home_fwd (Lexmark_Device * dev) +{ + /* This function actually searches backwards one line looking for home */ + + SANE_Int devnum; + int i; + SANE_Byte poll_result[3]; + SANE_Byte *buffer; + SANE_Byte temp_byte; + + static SANE_Byte command4_block[] = { 0x90, 0x00, 0x00, 0x03 }; + + static SANE_Byte command5_block[] = { 0x91, 0x00, 0x09, 0xc4 }; + + size_t cmd_size; + SANE_Bool got_line; + SANE_Bool ret_val; + + devnum = dev->devnum; + + DBG (2, "sanei_lexmark_low_search_home_fwd:\n"); + + /* set up registers according to the sensor type */ + switch (dev->model.sensor_type) + { + case X74_SENSOR: + dev->shadow_regs[0x2c] = 0x03; + dev->shadow_regs[0x2d] = 0x45; + dev->shadow_regs[0x2f] = 0x21; + dev->shadow_regs[0x30] = 0x48; + dev->shadow_regs[0x31] = 0x06; + dev->shadow_regs[0x34] = 0x05; + dev->shadow_regs[0x35] = 0x05; + dev->shadow_regs[0x36] = 0x09; + dev->shadow_regs[0x37] = 0x09; + dev->shadow_regs[0x38] = 0x0d; + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x75] = 0x00; + dev->shadow_regs[0x8b] = 0xff; + dev->shadow_regs[0x93] = 0x06; + break; + case X1100_B2_SENSOR: + dev->shadow_regs[0x2c] = 0x0f; + dev->shadow_regs[0x2d] = 0x51; + dev->shadow_regs[0x2f] = 0x21; + dev->shadow_regs[0x34] = 0x04; + dev->shadow_regs[0x35] = 0x04; + dev->shadow_regs[0x36] = 0x08; + dev->shadow_regs[0x37] = 0x08; + dev->shadow_regs[0x38] = 0x0b; + dev->shadow_regs[0x93] = 0x06; + break; + case X1100_2C_SENSOR: + dev->shadow_regs[0x2c] = 0x0d; + dev->shadow_regs[0x2d] = 0x4f; + dev->shadow_regs[0x34] = 0x05; + dev->shadow_regs[0x35] = 0x05; + dev->shadow_regs[0x36] = 0x09; + dev->shadow_regs[0x37] = 0x09; + dev->shadow_regs[0x38] = 0x0d; + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x72] = 0x35; + dev->shadow_regs[0x74] = 0x4e; + + dev->shadow_regs[0x85] = 0x20; /* 05 */ + dev->shadow_regs[0x86] = 0x00; /* 05 */ + dev->shadow_regs[0x87] = 0x00; /* 05 */ + dev->shadow_regs[0x88] = 0x00; /* 45 */ + dev->shadow_regs[0x89] = 0x00; + dev->shadow_regs[0x8b] = 0xff; + + dev->shadow_regs[0x93] = 0x06; /* 0e */ + + dev->shadow_regs[0x75] = 0x00; /* */ + dev->shadow_regs[0x91] = 0x00; /* 60 */ + dev->shadow_regs[0x92] = 0x00; /* 8d */ + dev->shadow_regs[0xb1] = 0x00; /* */ + dev->shadow_regs[0xc5] = 0x00; /* */ + dev->shadow_regs[0xca] = 0x00; /* */ + dev->shadow_regs[0xc3] = 0x01; /* */ + break; + case A920_SENSOR: + dev->shadow_regs[0x2c] = 0x0d; + dev->shadow_regs[0x2d] = 0x4f; + dev->shadow_regs[0x34] = 0x05; + dev->shadow_regs[0x35] = 0x05; + dev->shadow_regs[0x36] = 0x09; + dev->shadow_regs[0x37] = 0x09; + dev->shadow_regs[0x38] = 0x0d; + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x72] = 0x35; + dev->shadow_regs[0x74] = 0x4e; + dev->shadow_regs[0x85] = 0x05; + dev->shadow_regs[0x88] = 0x45; + dev->shadow_regs[0x89] = 0x00; + dev->shadow_regs[0x8b] = 0xff; + dev->shadow_regs[0x91] = 0x60; + dev->shadow_regs[0x92] = 0x8d; + dev->shadow_regs[0x93] = 0x0e; + break; + case X1200_SENSOR: + dev->shadow_regs[0x2c] = 0x01; + dev->shadow_regs[0x2d] = 0x03; + dev->shadow_regs[0x34] = 0x04; + dev->shadow_regs[0x35] = 0x04; + dev->shadow_regs[0x36] = 0x08; + dev->shadow_regs[0x37] = 0x08; + dev->shadow_regs[0x38] = 0x0b; + dev->shadow_regs[0x66] = 0x88; + dev->shadow_regs[0x6c] = 0x10; + dev->shadow_regs[0x6d] = 0x14; + dev->shadow_regs[0x75] = 0x00; + dev->shadow_regs[0x93] = 0x06; + dev->shadow_regs[0xc5] = 0x00; + dev->shadow_regs[0xca] = 0x00; + break; + case X1200_USB2_SENSOR: + dev->shadow_regs[0x0b] = 0x70; + dev->shadow_regs[0x0c] = 0x28; + dev->shadow_regs[0x0d] = 0xa4; + dev->shadow_regs[0x2c] = 0x0d; + dev->shadow_regs[0x2d] = 0x4f; + dev->shadow_regs[0x2f] = 0x21; + dev->shadow_regs[0x32] = 0x40; + dev->shadow_regs[0x34] = 0x05; + dev->shadow_regs[0x35] = 0x05; + dev->shadow_regs[0x36] = 0x09; + dev->shadow_regs[0x37] = 0x09; + dev->shadow_regs[0x38] = 0x0d; + dev->shadow_regs[0x3a] = 0x20; + dev->shadow_regs[0x3b] = 0x37; + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x47] = 0x01; + dev->shadow_regs[0x48] = 0x1a; + dev->shadow_regs[0x49] = 0x5b; + dev->shadow_regs[0x4a] = 0x1b; + dev->shadow_regs[0x4b] = 0x5b; + dev->shadow_regs[0x4c] = 0x05; + dev->shadow_regs[0x4d] = 0x3f; + dev->shadow_regs[0x75] = 0x00; + dev->shadow_regs[0x85] = 0x03; + dev->shadow_regs[0x86] = 0x33; + dev->shadow_regs[0x87] = 0x8f; + dev->shadow_regs[0x88] = 0x34; + dev->shadow_regs[0x8b] = 0xff; + dev->shadow_regs[0x8e] = 0x60; + dev->shadow_regs[0x8f] = 0x80; + dev->shadow_regs[0x91] = 0x59; + dev->shadow_regs[0x92] = 0x10; + dev->shadow_regs[0x93] = 0x06; + dev->shadow_regs[0xa3] = 0x0d; + dev->shadow_regs[0xa4] = 0x5e; + dev->shadow_regs[0xa5] = 0x23; + dev->shadow_regs[0xb1] = 0x07; + dev->shadow_regs[0xc2] = 0x80; + dev->shadow_regs[0xc5] = 0x00; + dev->shadow_regs[0xca] = 0x00; + break; + } + dev->shadow_regs[0x65] = 0x80; + dev->shadow_regs[0x8c] = 0x02; + dev->shadow_regs[0x8d] = 0x01; + dev->shadow_regs[0xb2] = 0x00; + dev->shadow_regs[0xed] = 0x00; + dev->shadow_regs[0xee] = 0x00; + + rts88xx_set_gain (dev->shadow_regs, dev->sensor->default_gain, + dev->sensor->default_gain, dev->sensor->default_gain); + rts88xx_set_offset (dev->shadow_regs, 0x80, 0x80, 0x80); + + /* set grayscale scan */ + rts88xx_set_gray_scan (dev->shadow_regs); + + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x07; + + /* set vertical start/end positions */ + dev->shadow_regs[0x60] = 0x01; + dev->shadow_regs[0x61] = 0x00; + dev->shadow_regs[0x62] = 0x02; + dev->shadow_regs[0x63] = 0x00; + + /* set # of head moves per CIS read */ + rts88xx_set_scan_frequency (dev->shadow_regs, 1); + + /* set horizontal start position */ + dev->shadow_regs[0x66] = 0x6a; /* 0x88 for X1200 */ + dev->shadow_regs[0x67] = 0x00; + /* set horizontal end position */ + dev->shadow_regs[0x6c] = 0xf2; /* 0x1410 for X1200 */ + dev->shadow_regs[0x6d] = 0x13; + /* set horizontal resolution */ + dev->shadow_regs[0x79] = 0x40; + dev->shadow_regs[0x7a] = 0x02; + /* Motor disable & Coordinate space denominator */ + dev->shadow_regs[0xc3] = 0x01; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x01; + + switch (dev->model.motor_type) + { + case A920_MOTOR: + case X1100_MOTOR: + /* step size range2 */ + dev->shadow_regs[0xc9] = 0x3b; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0x01; + /* ? */ + dev->shadow_regs[0xe3] = 0x03; + break; + case X74_MOTOR: + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc5] = 0x00; + dev->shadow_regs[0xc8] = 0x04; + /* step size range2 */ + dev->shadow_regs[0xc9] = 0x39; + dev->shadow_regs[0xca] = 0x00; + /* motor curve stuff */ + dev->shadow_regs[0xe0] = 0x29; + dev->shadow_regs[0xe1] = 0x17; + dev->shadow_regs[0xe2] = 0x8f; + dev->shadow_regs[0xe3] = 0x06; + dev->shadow_regs[0xe4] = 0x61; + dev->shadow_regs[0xe5] = 0x16; + dev->shadow_regs[0xe6] = 0x64; + dev->shadow_regs[0xe7] = 0xb5; + dev->shadow_regs[0xe8] = 0x08; + dev->shadow_regs[0xe9] = 0x32; + dev->shadow_regs[0xec] = 0x0c; + dev->shadow_regs[0xef] = 0x08; + break; + } + + /* Stop the scanner */ + low_stop_mvmt (devnum); + + /* write regs out twice */ + dev->shadow_regs[0x32] = 0x00; + low_write_all_regs (devnum, dev->shadow_regs); + dev->shadow_regs[0x32] = 0x40; + low_write_all_regs (devnum, dev->shadow_regs); + + /* Start Scan */ + rts88xx_commit (devnum, dev->shadow_regs[0x2c]); + + /* Poll the available byte count until not 0 */ + got_line = SANE_FALSE; + while (!got_line) + { + cmd_size = 4; + low_usb_bulk_write (devnum, command4_block, &cmd_size); + cmd_size = 0x3; + low_usb_bulk_read (devnum, poll_result, &cmd_size); + if (! + (poll_result[0] == 0 && poll_result[1] == 0 && poll_result[2] == 0)) + { + /* if result != 00 00 00 we got data */ + got_line = SANE_TRUE; + } + } + + /* create buffer for scan data */ + buffer = calloc (2500, sizeof (char)); + if (buffer == NULL) + { + return SANE_FALSE; + } + + /* Tell the scanner to send the data */ + /* Write: 91 00 09 c4 */ + cmd_size = 4; + low_usb_bulk_write (devnum, command5_block, &cmd_size); + /* Read it */ + cmd_size = 0x09c4; + low_usb_bulk_read (devnum, buffer, &cmd_size); + + /* Reverse order of bytes in words of buffer */ + for (i = 0; i < 2500; i = i + 2) + { + temp_byte = *(buffer + i); + *(buffer + i) = *(buffer + i + 1); + *(buffer + i + 1) = temp_byte; + } + + /* check for home position */ + ret_val = low_is_home_line (dev, buffer); + + if (ret_val) + DBG (2, "sanei_lexmark_low_search_home_fwd: !!!HOME POSITION!!!\n"); + + /* free the buffer */ + free (buffer); + DBG (2, "sanei_lexmark_low_search_home_fwd: end.\n"); + + return ret_val; +} + +SANE_Bool +sanei_lexmark_low_search_home_bwd (Lexmark_Device * dev) +{ +/* This function must only be called if the scan head is past the home dot. + It could damage the scanner if not. + + This function tells the scanner to do a grayscale scan backwards with a + 300dpi resolution. It reads 2500 bytes of data between horizontal + co-ordinates 0x6a and 0x13f2. + + The scan is set to read between vertical co-ordinates from 0x0a to 0x0f46, + or 3900 lines. This equates to 13" at 300dpi, so we must stop the scan + before it bangs against the end. A line limit is set so that a maximum of + 0x0F3C (13"*300dpi) lines can be read. + + To read the scan data we create a buffer space large enough to hold 10 + lines of data. For each read we poll twice, ignoring the first poll. This + is required for timing. We repeat the double poll until there is data + available. The number of lines (or number of buffers in our buffer space) + is calculated from the size of the data available from the scanner. The + number of buffers is calculated as the space required to hold 1.5 times + the the size of the data available from the scanner. + + After data is read from the scanner each line is checked if it is on the + home dot. Lines are continued to be read until we are no longer on the home + dot. */ + + + SANE_Int devnum; + SANE_Status status; + int i, j; + SANE_Byte poll_result[3]; + SANE_Byte *buffer; + SANE_Byte *buffer_start; + SANE_Byte temp_byte; + + SANE_Int buffer_count = 0; + SANE_Int size_requested; + SANE_Int size_returned; + SANE_Int no_of_buffers; + SANE_Int buffer_limit = 0xF3C; + + SANE_Int high_byte, mid_byte, low_byte; + SANE_Int home_line_count; + SANE_Bool in_home_region; + + static SANE_Byte command4_block[] = { 0x90, 0x00, 0x00, 0x03 }; + + static SANE_Byte command5_block[] = { 0x91, 0x00, 0xff, 0xc0 }; +#ifdef DEEP_DEBUG + FILE *img = NULL; +#endif + + size_t cmd_size; + SANE_Bool got_line; + + devnum = dev->devnum; + + DBG (2, "sanei_lexmark_low_search_home_bwd:\n"); + + /* set up registers */ + switch (dev->model.sensor_type) + { + case X74_SENSOR: + dev->shadow_regs[0x2c] = 0x03; + dev->shadow_regs[0x2d] = 0x45; + dev->shadow_regs[0x34] = 0x09; + dev->shadow_regs[0x35] = 0x09; + dev->shadow_regs[0x36] = 0x11; + dev->shadow_regs[0x37] = 0x11; + dev->shadow_regs[0x38] = 0x19; + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x93] = 0x06; + dev->shadow_regs[0x40] = 0x80; + /* important for detection of b/w transitions */ + dev->shadow_regs[0x75] = 0x00; + dev->shadow_regs[0x8b] = 0xff; + break; + case X1100_B2_SENSOR: + dev->shadow_regs[0x2c] = 0x0f; + dev->shadow_regs[0x2d] = 0x51; + dev->shadow_regs[0x34] = 0x07; + dev->shadow_regs[0x35] = 0x07; + dev->shadow_regs[0x36] = 0x0f; + dev->shadow_regs[0x37] = 0x0f; + dev->shadow_regs[0x38] = 0x15; + dev->shadow_regs[0x85] = 0x20; + dev->shadow_regs[0x93] = 0x06; + break; + case X1100_2C_SENSOR: + dev->shadow_regs[0x2c] = 0x0d; + dev->shadow_regs[0x2d] = 0x4f; + dev->shadow_regs[0x34] = 0x09; + dev->shadow_regs[0x35] = 0x09; + dev->shadow_regs[0x36] = 0x11; + dev->shadow_regs[0x37] = 0x11; + dev->shadow_regs[0x38] = 0x19; + dev->shadow_regs[0x85] = 0x20; + dev->shadow_regs[0x93] = 0x06; + break; + case A920_SENSOR: + dev->shadow_regs[0x2c] = 0x0d; + dev->shadow_regs[0x2d] = 0x4f; + dev->shadow_regs[0x34] = 0x09; + dev->shadow_regs[0x35] = 0x09; + dev->shadow_regs[0x36] = 0x11; + dev->shadow_regs[0x37] = 0x11; + dev->shadow_regs[0x38] = 0x19; + dev->shadow_regs[0x85] = 0x05; + dev->shadow_regs[0x93] = 0x0e; + break; + case X1200_SENSOR: + dev->shadow_regs[0x2c] = 0x01; + dev->shadow_regs[0x2d] = 0x03; + dev->shadow_regs[0x34] = 0x07; + dev->shadow_regs[0x35] = 0x07; + dev->shadow_regs[0x36] = 0x0f; + dev->shadow_regs[0x37] = 0x0f; + dev->shadow_regs[0x38] = 0x15; + break; + + case X1200_USB2_SENSOR: + dev->shadow_regs[0x2c] = 0x0d; + dev->shadow_regs[0x2d] = 0x4f; + dev->shadow_regs[0x34] = 0x09; + dev->shadow_regs[0x35] = 0x09; + dev->shadow_regs[0x36] = 0x11; + dev->shadow_regs[0x37] = 0x11; + dev->shadow_regs[0x38] = 0x19; + dev->shadow_regs[0x85] = 0x03; + dev->shadow_regs[0x93] = 0x06; + break; + } + rts88xx_set_gain (dev->shadow_regs, dev->sensor->default_gain, + dev->sensor->default_gain, dev->sensor->default_gain); + dev->shadow_regs[0x65] = 0x80; + dev->shadow_regs[0x8b] = 0xff; + dev->shadow_regs[0x8c] = 0x02; + dev->shadow_regs[0xb2] = 0x00; + + /* set calibration */ + rts88xx_set_offset (dev->shadow_regs, 0x80, 0x80, 0x80); + + /* set grayscale scan */ + dev->shadow_regs[0x2f] = 0x21; + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x03; + /* set vertical start/end positions */ + dev->shadow_regs[0x60] = 0x0a; + dev->shadow_regs[0x61] = 0x00; + dev->shadow_regs[0x62] = 0x46; + dev->shadow_regs[0x63] = 0x0f; + /* set # of head moves per CIS read */ + rts88xx_set_scan_frequency (dev->shadow_regs, 2); + /* set horizontal start position */ + dev->shadow_regs[0x66] = 0x6a; /* 0x88 for X1200 */ + dev->shadow_regs[0x67] = 0x00; + /* set horizontal end position */ + dev->shadow_regs[0x6c] = 0xf2; /* 0x1410 for X1200, 13f2 for X1200/rev. 97 */ + dev->shadow_regs[0x6d] = 0x13; + /* set horizontal resolution */ + dev->shadow_regs[0x79] = 0x40; + dev->shadow_regs[0x7a] = 0x02; + + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x01; + /* Motor enable & Coordinate space denominator */ + dev->shadow_regs[0xc3] = 0x81; + + switch (dev->model.motor_type) + { + case X74_MOTOR: + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc5] = 0x00; + dev->shadow_regs[0xc8] = 0x04; + /* step size range2 */ + dev->shadow_regs[0xc9] = 0x39; + dev->shadow_regs[0xca] = 0x00; + /* motor curve stuff */ + dev->shadow_regs[0xe0] = 0x29; + dev->shadow_regs[0xe1] = 0x17; + dev->shadow_regs[0xe2] = 0x8f; + dev->shadow_regs[0xe3] = 0x06; + dev->shadow_regs[0xe4] = 0x61; + dev->shadow_regs[0xe5] = 0x16; + dev->shadow_regs[0xe6] = 0x64; + dev->shadow_regs[0xe7] = 0xb5; + dev->shadow_regs[0xe8] = 0x08; + dev->shadow_regs[0xe9] = 0x32; + dev->shadow_regs[0xec] = 0x0c; + dev->shadow_regs[0xef] = 0x08; + break; + case A920_MOTOR: + case X1100_MOTOR: + /* ? */ + dev->shadow_regs[0xc5] = 0x19; + /* step size range2 */ + dev->shadow_regs[0xc9] = 0x3a; + /* ? */ + dev->shadow_regs[0xca] = 0x08; + /* motor curve stuff */ + dev->shadow_regs[0xe0] = 0xe3; + dev->shadow_regs[0xe1] = 0x18; + dev->shadow_regs[0xe2] = 0x03; + dev->shadow_regs[0xe3] = 0x06; + dev->shadow_regs[0xe4] = 0x2b; + dev->shadow_regs[0xe5] = 0x17; + dev->shadow_regs[0xe6] = 0xdc; + dev->shadow_regs[0xe7] = 0xb3; + dev->shadow_regs[0xe8] = 0x07; + dev->shadow_regs[0xe9] = 0x1b; + dev->shadow_regs[0xec] = 0x07; + dev->shadow_regs[0xef] = 0x03; + break; + } + + /* Stop the scanner */ + low_stop_mvmt (devnum); + + /* write regs out twice */ + dev->shadow_regs[0x32] = 0x00; + low_write_all_regs (devnum, dev->shadow_regs); + dev->shadow_regs[0x32] = 0x40; + low_write_all_regs (devnum, dev->shadow_regs); + + /* Start Scan */ + status = rts88xx_commit (devnum, dev->shadow_regs[0x2c]); + + /* create buffer to hold up to 10 lines of scan data */ + buffer = calloc (10 * 2500, sizeof (char)); + if (buffer == NULL) + { + return SANE_FALSE; + } + + home_line_count = 0; + in_home_region = SANE_FALSE; + +#ifdef DEEP_DEBUG + img = fopen ("find_bwd.pnm", "wb"); + fprintf (img, "P5\n2500 100\n255\n"); +#endif + while (buffer_count < buffer_limit) + { + size_returned = 0; + got_line = SANE_FALSE; + while (!got_line) + { + /* always poll twice (needed for timing) - disregard 1st poll */ + cmd_size = 4; + status = low_usb_bulk_write (devnum, command4_block, &cmd_size); + if (status != SANE_STATUS_GOOD) + return SANE_FALSE; + cmd_size = 0x3; + status = low_usb_bulk_read (devnum, poll_result, &cmd_size); + if (status != SANE_STATUS_GOOD) + return SANE_FALSE; + cmd_size = 4; + status = low_usb_bulk_write (devnum, command4_block, &cmd_size); + if (status != SANE_STATUS_GOOD) + return SANE_FALSE; + cmd_size = 0x3; + status = low_usb_bulk_read (devnum, poll_result, &cmd_size); + if (status != SANE_STATUS_GOOD) + return SANE_FALSE; + if (! + (poll_result[0] == 0 && poll_result[1] == 0 + && poll_result[2] == 0)) + { + /* if result != 00 00 00 we got data */ + got_line = SANE_TRUE; + high_byte = poll_result[2] << 16; + mid_byte = poll_result[1] << 8; + low_byte = poll_result[0]; + size_returned = high_byte + mid_byte + low_byte; + } + } + + /*size_requested = size_returned;*/ + size_requested = 2500; + no_of_buffers = size_returned * 3; + no_of_buffers = no_of_buffers / 2500; + no_of_buffers = no_of_buffers >> 1; + /* force 1 buffer at a time to improve accuray, which slow downs search */ + no_of_buffers = 1; + + if (no_of_buffers < 1) + no_of_buffers = 1; + else if (no_of_buffers > 10) + no_of_buffers = 10; + buffer_count = buffer_count + no_of_buffers; + + size_requested = no_of_buffers * 2500; + + /* Tell the scanner to send the data */ + /* Write: 91 <size_requested> */ + command5_block[1] = (SANE_Byte) (size_requested >> 16); + command5_block[2] = (SANE_Byte) (size_requested >> 8); + command5_block[3] = (SANE_Byte) (size_requested & 0xFF); + + cmd_size = 4; + status = low_usb_bulk_write (devnum, command5_block, &cmd_size); + if (status != SANE_STATUS_GOOD) + return SANE_FALSE; + /* Read it */ + cmd_size = size_requested; + status = low_usb_bulk_read (devnum, buffer, &cmd_size); + if (status != SANE_STATUS_GOOD) + return SANE_FALSE; + for (i = 0; i < no_of_buffers; i++) + { + buffer_start = buffer + (i * 2500); + /* Reverse order of bytes in words of buffer */ + for (j = 0; j < 2500; j = j + 2) + { + temp_byte = *(buffer_start + j); + *(buffer_start + j) = *(buffer_start + j + 1); + *(buffer_start + j + 1) = temp_byte; + } +#ifdef DEEP_DEBUG + fwrite (buffer + (i * 2500), 2500, 1, img); +#endif + if (low_is_home_line (dev, buffer_start)) + { + home_line_count++; + if (home_line_count > 7) + in_home_region = SANE_TRUE; + } + if (in_home_region) + { + /* slow down scanning : on purpose backtracking */ + if (home_line_count) + sleep (1); + free (buffer); +#ifdef DEEP_DEBUG + fflush (img); + i = ftell (img) / 2500; + rewind (img); + DBG (2, "sanei_lexmark_low_search_home_bwd: offset=%d\n", i); + fprintf (img, "P5\n2500 %03d\n", i); + fclose (img); +#endif + low_stop_mvmt (devnum); + DBG (2, + "sanei_lexmark_low_search_home_bwd: in home region, end.\n"); + return SANE_TRUE; + } + } + } /* end while (buffer_count > buffer_limit); */ + free (buffer); +#ifdef DEEP_DEBUG + fflush (img); + i = ftell (img) / 2500; + rewind (img); + fprintf (img, "P5\n2500 %03d\n", i); + fclose (img); +#endif + low_stop_mvmt (devnum); + + DBG (2, "sanei_lexmark_low_search_home_bwd: end.\n"); + + return SANE_FALSE; +} + +SANE_Status +low_get_start_loc (SANE_Int resolution, SANE_Int * vert_start, + SANE_Int * hor_start, SANE_Int offset, + Lexmark_Device * dev) +{ + SANE_Int start_600; + + switch (dev->model.sensor_type) + { + case X1100_2C_SENSOR: + case X1200_USB2_SENSOR: + case A920_SENSOR: + case X1200_SENSOR: + start_600 = 195 - offset; + *hor_start = 0x68; + break; + case X1100_B2_SENSOR: + start_600 = 195 - offset; + switch (resolution) + { + case 75: + *hor_start = 0x68; + break; + case 150: + *hor_start = 0x68; + break; + case 300: + *hor_start = 0x6a; + break; + case 600: + *hor_start = 0x6b; + break; + case 1200: + *hor_start = 0x6b; + break; + default: + /* If we're here we have an invalid resolution */ + return SANE_STATUS_INVAL; + } + break; + case X74_SENSOR: + start_600 = 268 - offset; + switch (resolution) + { + case 75: + *hor_start = 0x48; + break; + case 150: + *hor_start = 0x48; + break; + case 300: + *hor_start = 0x4a; + break; + case 600: + *hor_start = 0x4b; + break; + default: + /* If we're here we have an invalid resolution */ + return SANE_STATUS_INVAL; + } + break; + } + /* Calculate vertical start distance at 600dpi */ + switch (resolution) + { + case 75: + *vert_start = start_600 / 8; + break; + case 150: + *vert_start = start_600 / 4; + break; + case 300: + *vert_start = start_600 / 2; + break; + case 600: + *vert_start = start_600; + break; + case 1200: + *vert_start = start_600 * 2; + break; + default: + /* If we're here we have an invalid resolution */ + return SANE_STATUS_INVAL; + } + + return SANE_STATUS_GOOD; +} + +void +low_set_scan_area (SANE_Int res, + SANE_Int tlx, + SANE_Int tly, + SANE_Int brx, + SANE_Int bry, + SANE_Int offset, + SANE_Bool half_step, + SANE_Byte * regs, Lexmark_Device * dev) +{ + + SANE_Int vert_start = 0; + SANE_Int hor_start = 0; + SANE_Int vert_end; + SANE_Int hor_end; + + low_get_start_loc (res, &vert_start, &hor_start, offset, dev); + + /* convert pixel height to vertical location coordinates */ + vert_end = vert_start + (bry * res) / 600; + vert_start += (tly * res) / 600; + + /* scan area size : for A920, 600 color scans are done at 1200 y dpi */ + /* this follow what was found in usb logs */ + if (half_step) + { + vert_end = vert_end * 2; + vert_start = vert_start * 2; + } + + /* set vertical start position registers */ + regs[0x60] = LOBYTE (vert_start); + regs[0x61] = HIBYTE (vert_start); + /* set vertical end position registers */ + regs[0x62] = LOBYTE (vert_end); + regs[0x63] = HIBYTE (vert_end); + + /* convert pixel width to horizontal location coordinates */ + + hor_end = hor_start + brx; + hor_start += tlx; + + regs[0x66] = LOBYTE (hor_start); + regs[0x67] = HIBYTE (hor_start); + /* set horizontal end position registers */ + regs[0x6c] = LOBYTE (hor_end); + regs[0x6d] = HIBYTE (hor_end); + + /* Debug */ + DBG (2, "low_set_scan_area: vert_start: %d (tly=%d)\n", vert_start, tly); + DBG (2, "low_set_scan_area: vert_end: %d\n", vert_end); + DBG (2, "low_set_scan_area: hor_start: %d\n", hor_start); + DBG (2, "low_set_scan_area: hor_end: %d\n", hor_end); + +} + +SANE_Int +sanei_lexmark_low_find_start_line (Lexmark_Device * dev) +{ + /* + This function scans forward 59 lines, reading 88 bytes per line from the + middle of the horizontal line: pixel 0xa84 to pixel 0x9d4. It scans with + the following parameters: + dir=fwd + mode=grayscale + h.res=300 dpi + v.res=600 dpi + hor. pixels = (0xa84 - 0x9d4)/2 = 0x58 = 88 + vert. pixels = 0x3e - 0x03 = 0x3b = 59 + data = 88x59=5192=0x1448 + + It assumes we are in the start dot, or just before it. We are reading + enough lines at 600dpi to read past the dot. We return the number of + entirely white lines read consecutively, so we know how far past the + dot we are. + + To find the number of consecutive white lines we do the following: + + Byte swap the order of the bytes in the buffer. + + Go through the buffer finding low and high values, which are computed by + comparing to the weighted average: + weighted_average = (lowest value + (highest value - lowest value)/4) + Low bytes are changed to 0xFF (white), higher of equal bytes are changed + to 0x00 (black),so that the buffer only contains white (0xFF) or black + (0x00) values. + + Next, we go through the buffer a line (88 bytes) at a time for 59 lines + to read the entire buffer. For each byte in a line we check if the + byte is black. If it is we increment the black byte counter. + + After each line we check the black byte counter. If it is greater than 0 + we increment the black line count and set the white line count to 0. If + there were no black bytes in the line we set the black line count to 0 + and increment the white line count. + + When all lines have been processed we return the white line count. + */ + + + int blackLineCount = 0; + int whiteLineCount = 0; + int blackByteCounter = 0; + unsigned char max_byte = 0; + unsigned char min_byte = 0xFF; + unsigned char weighted_average; + int i, j; +#ifdef DEEP_DEBUG + FILE *fdbg = NULL; +#endif + + SANE_Byte poll_result[3]; + SANE_Byte *buffer; + SANE_Byte temp_byte; + + static SANE_Byte command4_block[] = { 0x90, 0x00, 0x00, 0x03 }; + + static SANE_Byte command5_block[] = { 0x91, 0x00, 0x14, 0x48 }; + + size_t cmd_size; + SANE_Bool got_line; + + DBG (2, "sanei_lexmark_low_find_start_line:\n"); + + + /* set up registers */ + switch (dev->model.sensor_type) + { + case X74_SENSOR: + dev->shadow_regs[0x2c] = 0x04; + dev->shadow_regs[0x2d] = 0x46; + dev->shadow_regs[0x34] = 0x05; + dev->shadow_regs[0x35] = 0x05; + dev->shadow_regs[0x36] = 0x0b; + dev->shadow_regs[0x37] = 0x0b; + dev->shadow_regs[0x38] = 0x11; + dev->shadow_regs[0x40] = 0x40; + rts88xx_set_gain (dev->shadow_regs, 6, 6, 6); + break; + case X1100_B2_SENSOR: + dev->shadow_regs[0x2c] = 0x0f; + dev->shadow_regs[0x2d] = 0x51; + dev->shadow_regs[0x34] = 0x0d; + dev->shadow_regs[0x35] = 0x0d; + dev->shadow_regs[0x36] = 0x1d; + dev->shadow_regs[0x37] = 0x1d; + dev->shadow_regs[0x38] = 0x29; + dev->shadow_regs[0x65] = 0x80; + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x93] = 0x06; + rts88xx_set_gain (dev->shadow_regs, 6, 6, 6); + break; + case X1100_2C_SENSOR: + rts88xx_set_gain (dev->shadow_regs, 10, 10, 10); + dev->shadow_regs[0x28] = 0xf5; + dev->shadow_regs[0x29] = 0xf7; + dev->shadow_regs[0x2a] = 0xf5; + dev->shadow_regs[0x2b] = 0x17; + + dev->shadow_regs[0x2c] = 0x0d; + dev->shadow_regs[0x2d] = 0x4f; + dev->shadow_regs[0x31] = 0x01; + dev->shadow_regs[0x34] = 0x11; + dev->shadow_regs[0x35] = 0x11; + dev->shadow_regs[0x36] = 0x21; + dev->shadow_regs[0x37] = 0x21; + dev->shadow_regs[0x38] = 0x31; + dev->shadow_regs[0x72] = 0x35; + dev->shadow_regs[0x74] = 0x4e; + dev->shadow_regs[0x85] = 0x02; + dev->shadow_regs[0x86] = 0x33; + dev->shadow_regs[0x87] = 0x0f; + dev->shadow_regs[0x88] = 0x24; + dev->shadow_regs[0x91] = 0x19; + dev->shadow_regs[0x92] = 0x20; + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + break; + case A920_SENSOR: + dev->shadow_regs[0x2c] = 0x0d; + dev->shadow_regs[0x2d] = 0x4f; + dev->shadow_regs[0x34] = 0x11; + dev->shadow_regs[0x35] = 0x11; + dev->shadow_regs[0x36] = 0x21; + dev->shadow_regs[0x37] = 0x21; + dev->shadow_regs[0x38] = 0x31; + dev->shadow_regs[0x85] = 0x05; + dev->shadow_regs[0x88] = 0x44; + dev->shadow_regs[0x92] = 0x85; + dev->shadow_regs[0x93] = 0x0e; + rts88xx_set_gain (dev->shadow_regs, 6, 6, 6); + break; + case X1200_SENSOR: + dev->shadow_regs[0x2c] = 0x01; + dev->shadow_regs[0x2d] = 0x03; + dev->shadow_regs[0x34] = 0x0d; + dev->shadow_regs[0x35] = 0x0d; + dev->shadow_regs[0x36] = 0x1d; + dev->shadow_regs[0x37] = 0x1d; + dev->shadow_regs[0x38] = 0x29; + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x50] = 0x00; + dev->shadow_regs[0x81] = 0x00; + dev->shadow_regs[0x82] = 0x00; + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0xff; + dev->shadow_regs[0x88] = 0x02; + dev->shadow_regs[0x92] = 0x00; + rts88xx_set_gain (dev->shadow_regs, 10, 10, 10); + break; + case X1200_USB2_SENSOR: + dev->shadow_regs[0x2c] = 0x01; + dev->shadow_regs[0x2d] = 0x03; + dev->shadow_regs[0x34] = 0x0d; + dev->shadow_regs[0x35] = 0x0d; + dev->shadow_regs[0x36] = 0x1d; + dev->shadow_regs[0x37] = 0x1d; + dev->shadow_regs[0x38] = 0x29; + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + rts88xx_set_gain (dev->shadow_regs, 10, 10, 10); + break; + } + + /* set offset to a safe value */ + rts88xx_set_offset (dev->shadow_regs, 0x80, 0x80, 0x80); + /* set grayscale scan */ + dev->shadow_regs[0x2f] = 0x21; + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x01; + /* set vertical start/end positions */ + dev->shadow_regs[0x60] = 0x03; + dev->shadow_regs[0x61] = 0x00; + dev->shadow_regs[0x62] = 0x3e; + dev->shadow_regs[0x63] = 0x00; + /* set # of head moves per CIS read */ + rts88xx_set_scan_frequency (dev->shadow_regs, 1); + /* set horizontal start position */ + dev->shadow_regs[0x66] = 0xd4; /* 0xf2 for X1200 */ + dev->shadow_regs[0x67] = 0x09; + /* set horizontal end position */ + dev->shadow_regs[0x6c] = 0x84; /* 0xa2 for X1200 */ + dev->shadow_regs[0x6d] = 0x0a; + /* set horizontal resolution */ + dev->shadow_regs[0x79] = 0x40; + dev->shadow_regs[0x7a] = 0x02; + /* set for ? */ + /* Motor enable & Coordinate space denominator */ + dev->shadow_regs[0xc3] = 0x81; + + + + + + switch (dev->model.motor_type) + { + case X1100_MOTOR: + case A920_MOTOR: + /* set for ? */ + dev->shadow_regs[0xc5] = 0x22; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x09; + /* step size range2 */ + dev->shadow_regs[0xc9] = 0x3b; + /* set for ? */ + dev->shadow_regs[0xca] = 0x1f; + dev->shadow_regs[0xe0] = 0xf7; + dev->shadow_regs[0xe1] = 0x16; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0x87; + /* ? */ + dev->shadow_regs[0xe3] = 0x13; + dev->shadow_regs[0xe4] = 0x1b; + dev->shadow_regs[0xe5] = 0x16; + dev->shadow_regs[0xe6] = 0xdc; + dev->shadow_regs[0xe7] = 0x00; + dev->shadow_regs[0xe8] = 0x00; + dev->shadow_regs[0xe9] = 0x1b; + dev->shadow_regs[0xec] = 0x07; + dev->shadow_regs[0xef] = 0x03; + break; + case X74_MOTOR: + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc5] = 0x22; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x0b; + + dev->shadow_regs[0xc8] = 0x04; + dev->shadow_regs[0xc9] = 0x39; + dev->shadow_regs[0xca] = 0x1f; + + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x2f; + dev->shadow_regs[0xe1] = 0x11; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0x9f; + /* ? */ + dev->shadow_regs[0xe3] = 0x0f; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0xcb; + + dev->shadow_regs[0xe5] = 0x10; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0x64; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0x00; + dev->shadow_regs[0xe8] = 0x00; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x32; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x0c; + /* bounds of movement range4 -only for 75dpi grayscale */ + dev->shadow_regs[0xed] = 0x00; + dev->shadow_regs[0xee] = 0x00; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x08; + break; + } + + + /* Stop the scanner */ + low_stop_mvmt (dev->devnum); + + /* write regs out twice */ + dev->shadow_regs[0x32] = 0x00; + low_write_all_regs (dev->devnum, dev->shadow_regs); + dev->shadow_regs[0x32] = 0x40; + low_write_all_regs (dev->devnum, dev->shadow_regs); + + /* Start Scan */ + rts88xx_commit (dev->devnum, dev->shadow_regs[0x2c]); + + /* Poll the available byte count until not 0 */ + got_line = SANE_FALSE; + while (!got_line) + { + cmd_size = 4; + low_usb_bulk_write (dev->devnum, command4_block, &cmd_size); + cmd_size = 0x3; + low_usb_bulk_read (dev->devnum, poll_result, &cmd_size); + if (! + (poll_result[0] == 0 && poll_result[1] == 0 && poll_result[2] == 0)) + { + /* if result != 00 00 00 we got data */ + got_line = SANE_TRUE; + } +#ifdef FAKE_USB + got_line = SANE_TRUE; +#endif + } + + + /* create buffer for scan data */ + buffer = calloc (5192, sizeof (char)); + if (buffer == NULL) + { + return -1; + } + + /* Tell the scanner to send the data */ + /* Write: 91 00 14 48 */ + cmd_size = 4; + low_usb_bulk_write (dev->devnum, command5_block, &cmd_size); + /* Read it */ + cmd_size = 0x1448; + low_usb_bulk_read (dev->devnum, buffer, &cmd_size); + + /* Stop the scanner */ + low_stop_mvmt (dev->devnum); + + + /* Reverse order of bytes in words of buffer */ + for (i = 0; i < 5192; i = i + 2) + { + temp_byte = *(buffer + i); + *(buffer + i) = *(buffer + i + 1); + *(buffer + i + 1) = temp_byte; + } + +#ifdef DEEP_DEBUG + fdbg = fopen ("find_start.pnm", "wb"); + if (fdbg != NULL) + { + fprintf (fdbg, "P5\n%d %d\n255\n", 88, 59); + fwrite (buffer, 5192, 1, fdbg); + fclose (fdbg); + } +#endif + + /* Find the max and the min */ + for (i = 0; i < 5192; i++) + { + if (*(buffer + i) > max_byte) + max_byte = *(buffer + i); + if (*(buffer + i) < min_byte) + min_byte = *(buffer + i); + } + + weighted_average = min_byte + ((max_byte - min_byte) / 4); + + /* Set bytes as black (0x00) or white (0xFF) */ + for (i = 0; i < 5192; i++) + { + if (*(buffer + i) > weighted_average) + *(buffer + i) = 0xFF; + else + *(buffer + i) = 0x00; + } + +#ifdef DEEP_DEBUG + fdbg = fopen ("find_start_after.pnm", "wb"); + if (fdbg != NULL) + { + fprintf (fdbg, "P5\n%d %d\n255\n", 88, 59); + fwrite (buffer, 5192, 1, fdbg); + fclose (fdbg); + } +#endif + + /* Go through 59 lines */ + for (j = 0; j < 59; j++) + { + blackByteCounter = 0; + /* Go through 88 bytes per line */ + for (i = 0; i < 88; i++) + { + /* Is byte black? */ + if (*(buffer + (j * 88) + i) == 0) + { + blackByteCounter++; + } + } /* end for line */ + if (blackByteCounter > 0) + { + /* This was a black line */ + blackLineCount++; + whiteLineCount = 0; + } + else + { + /* This is a white line */ + whiteLineCount++; + blackLineCount = 0; + } + } /* end for buffer */ + + free (buffer); + /* Stop the scanner. + This is needed to get the right distance to the scanning area */ + if (dev->model.sensor_type == X74_SENSOR) + low_stop_mvmt (dev->devnum); + + DBG (2, "sanei_lexmark_low_find_start_line: end.\n"); + return whiteLineCount; +} + + +SANE_Status +sanei_lexmark_low_set_scan_regs (Lexmark_Device * dev, SANE_Int resolution, + SANE_Int offset, SANE_Bool calibrated) +{ + SANE_Bool isColourScan; + + DBG (2, "sanei_lexmark_low_set_scan_regs:\n"); + + DBG (7, "sanei_lexmark_low_set_scan_regs: resolution=%d DPI\n", resolution); + + /* colour mode */ + if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0) + isColourScan = SANE_TRUE; + else + isColourScan = SANE_FALSE; + + /* set up registers */ + switch (dev->model.sensor_type) + { + case X74_SENSOR: + dev->shadow_regs[0x2c] = 0x03; + dev->shadow_regs[0x2d] = 0x45; + break; + case X1100_B2_SENSOR: + dev->shadow_regs[0x2c] = 0x0f; + dev->shadow_regs[0x2d] = 0x51; + break; + case X1100_2C_SENSOR: + dev->shadow_regs[0x2c] = 0x0d; + dev->shadow_regs[0x2d] = 0x4f; + break; + case A920_SENSOR: + dev->shadow_regs[0x2c] = 0x0d; + dev->shadow_regs[0x2d] = 0x4f; + break; + case X1200_SENSOR: + dev->shadow_regs[0x2c] = 0x01; + dev->shadow_regs[0x2d] = 0x03; + break; + case X1200_USB2_SENSOR: + dev->shadow_regs[0x2c] = 0x01; + dev->shadow_regs[0x2d] = 0x03; + break; + } + + low_set_scan_area (resolution, + dev->val[OPT_TL_X].w, + dev->val[OPT_TL_Y].w, + dev->val[OPT_BR_X].w, + dev->val[OPT_BR_Y].w, + offset, + (dev->model.motor_type == A920_MOTOR + || dev->model.motor_type == X74_MOTOR) && isColourScan + && (resolution == 600), dev->shadow_regs, dev); + + /* may be we could use a sensor descriptor that would held the max horiz dpi */ + if (dev->val[OPT_RESOLUTION].w < 600) + dev->shadow_regs[0x7a] = 600 / dev->val[OPT_RESOLUTION].w; + else + dev->shadow_regs[0x7a] = 1; + + /* 75dpi x 75dpi */ + if (resolution == 75) + { + DBG (5, "sanei_lexmark_low_set_scan_regs(): 75 DPI resolution\n"); + + if (isColourScan) + { + switch (dev->model.sensor_type) + { + case X74_SENSOR: + + dev->shadow_regs[0x34] = 0x04; + dev->shadow_regs[0x36] = 0x03; + dev->shadow_regs[0x38] = 0x03; + + dev->shadow_regs[0x79] = 0x08; + + dev->shadow_regs[0x80] = 0x0d; + dev->shadow_regs[0x81] = 0x0e; + dev->shadow_regs[0x82] = 0x02; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06;; + + break; + + case X1100_B2_SENSOR: + dev->shadow_regs[0x34] = 0x05; + dev->shadow_regs[0x36] = 0x05; + dev->shadow_regs[0x38] = 0x05; + + dev->shadow_regs[0x80] = 0x0c; + dev->shadow_regs[0x81] = 0x0c; + dev->shadow_regs[0x82] = 0x09; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x8c; + dev->shadow_regs[0x92] = 0x40; + dev->shadow_regs[0x93] = 0x06; + break; + + case X1100_2C_SENSOR: + dev->shadow_regs[0x34] = 0x03; + dev->shadow_regs[0x36] = 0x04; + dev->shadow_regs[0x38] = 0x03; + + dev->shadow_regs[0x80] = 0x00; + dev->shadow_regs[0x81] = 0x02; + dev->shadow_regs[0x82] = 0x03; + + dev->shadow_regs[0x85] = 0x20; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + + case A920_SENSOR: + dev->shadow_regs[0x34] = 0x02; + dev->shadow_regs[0x36] = 0x04; + dev->shadow_regs[0x38] = 0x03; + + dev->shadow_regs[0x80] = 0x07; + dev->shadow_regs[0x81] = 0x0f; + dev->shadow_regs[0x82] = 0x03; + + dev->shadow_regs[0x85] = 0x05; + dev->shadow_regs[0x86] = 0x14; + dev->shadow_regs[0x87] = 0x06; + dev->shadow_regs[0x88] = 0x44; + + dev->shadow_regs[0x91] = 0x60; + dev->shadow_regs[0x92] = 0x85; + dev->shadow_regs[0x93] = 0x0e; + break; + + case X1200_SENSOR: + dev->shadow_regs[0x34] = 0x02; + dev->shadow_regs[0x36] = 0x03; + dev->shadow_regs[0x38] = 0x01; + + dev->shadow_regs[0x79] = 0x20; + + dev->shadow_regs[0x80] = 0x08; + dev->shadow_regs[0x81] = 0x02; + dev->shadow_regs[0x82] = 0x0d; + + dev->shadow_regs[0x85] = 0x20; + dev->shadow_regs[0x86] = 0x1e; + dev->shadow_regs[0x87] = 0x39; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + /* dev->shadow_regs[0x92] = 0x92; */ + dev->shadow_regs[0x93] = 0x06; + break; + + case X1200_USB2_SENSOR: + dev->shadow_regs[0x34] = 0x04; + dev->shadow_regs[0x36] = 0x05; + dev->shadow_regs[0x38] = 0x04; + + dev->shadow_regs[0x80] = 0x01; + dev->shadow_regs[0x81] = 0x0a; + dev->shadow_regs[0x82] = 0x0b; + break; + } + + switch (dev->model.motor_type) + { + case X74_MOTOR: + dev->shadow_regs[0xc2] = 0x80; + /* ? */ + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc5] = 0x0c; + dev->shadow_regs[0xc6] = 0x0b; + + dev->shadow_regs[0xc8] = 0x04; + dev->shadow_regs[0xc9] = 0x39; + dev->shadow_regs[0xca] = 0x01; + + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x1b; + dev->shadow_regs[0xe1] = 0x0a; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0x4f; + /* ? */ + dev->shadow_regs[0xe3] = 0x01; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0xb3; + + dev->shadow_regs[0xe5] = 0x09; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0x0d; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0xe5; + dev->shadow_regs[0xe8] = 0x02; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x05; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0xa0; + dev->shadow_regs[0xeb] = 0x01; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x01; + /* bounds of movement range4 */ + dev->shadow_regs[0xed] = 0x00; + dev->shadow_regs[0xee] = 0x00; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x01; + break; + case A920_MOTOR: + case X1100_MOTOR: + /* ? */ + dev->shadow_regs[0xc5] = 0x0a; + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x2b; + dev->shadow_regs[0xe1] = 0x0a; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0x7f; + /* ? */ + dev->shadow_regs[0xe3] = 0x01; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0xbb; + dev->shadow_regs[0xe5] = 0x09; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0x0e; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0x2b; + dev->shadow_regs[0xe8] = 0x03; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x05; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0xa0; + dev->shadow_regs[0xeb] = 0x01; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x01; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x01; + break; + } + + /* set colour scan */ + dev->shadow_regs[0x2f] = 0x11; + + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x37] = 0x01; + /* Motor enable & Coordinate space denominator */ + dev->shadow_regs[0xc3] = 0x83; + } + else /* 75 dpi gray */ + { + switch (dev->model.sensor_type) + { + case X74_SENSOR: + + dev->shadow_regs[0x34] = 0x01; + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x36] = 0x02; + dev->shadow_regs[0x37] = 0x02; + dev->shadow_regs[0x38] = 0x03; + dev->shadow_regs[0x39] = 0x0f; + + dev->shadow_regs[0x40] = 0x80; + + dev->shadow_regs[0x79] = 0x08; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x8c] = 0x02; + dev->shadow_regs[0x8d] = 0x01; + dev->shadow_regs[0x8e] = 0x60; + dev->shadow_regs[0x8f] = 0x80; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + + break; + + case X1100_B2_SENSOR: + dev->shadow_regs[0x34] = 0x02; + dev->shadow_regs[0x35] = 0x02; + dev->shadow_regs[0x36] = 0x04; + dev->shadow_regs[0x37] = 0x04; + dev->shadow_regs[0x38] = 0x06; + + dev->shadow_regs[0x85] = 0x20; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case X1100_2C_SENSOR: + dev->shadow_regs[0x34] = 0x01; + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x36] = 0x02; + dev->shadow_regs[0x37] = 0x02; + dev->shadow_regs[0x38] = 0x03; /* these are half of B2 sensor */ + + dev->shadow_regs[0x85] = 0x20; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case A920_SENSOR: + dev->shadow_regs[0x34] = 0x01; + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x36] = 0x02; + dev->shadow_regs[0x37] = 0x02; + dev->shadow_regs[0x38] = 0x03; + + dev->shadow_regs[0x85] = 0x0d; + dev->shadow_regs[0x86] = 0x14; + dev->shadow_regs[0x87] = 0x06; + dev->shadow_regs[0x88] = 0x45; + + dev->shadow_regs[0x91] = 0x60; + dev->shadow_regs[0x92] = 0x8d; + dev->shadow_regs[0x93] = 0x0e; + break; + case X1200_SENSOR: + dev->shadow_regs[0x34] = 0x01; + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x36] = 0x02; + dev->shadow_regs[0x37] = 0x02; + dev->shadow_regs[0x38] = 0x02; + + dev->shadow_regs[0x79] = 0x20; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0xff; + dev->shadow_regs[0x88] = 0x02; + + dev->shadow_regs[0x92] = 0x00; + break; + case X1200_USB2_SENSOR: + dev->shadow_regs[0x34] = 0x01; + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x36] = 0x02; + dev->shadow_regs[0x37] = 0x02; + dev->shadow_regs[0x38] = 0x02; + + dev->shadow_regs[0x79] = 0x20; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0xff; + dev->shadow_regs[0x88] = 0x02; + + dev->shadow_regs[0x92] = 0x00; + break; + } + switch (dev->model.motor_type) + { + case X74_MOTOR: + /* ? */ + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc5] = 0x0a; + dev->shadow_regs[0xc6] = 0x0b; + + dev->shadow_regs[0xc8] = 0x04; + dev->shadow_regs[0xc9] = 0x39; + dev->shadow_regs[0xca] = 0x01; + + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x07; + dev->shadow_regs[0xe1] = 0x18; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0xe7; + /* ? */ + dev->shadow_regs[0xe3] = 0x03; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0xe7; + dev->shadow_regs[0xe5] = 0x14; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0x64; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0xcb; + dev->shadow_regs[0xe8] = 0x08; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x32; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0xe3; + dev->shadow_regs[0xeb] = 0x04; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x0c; + /* bounds of movement range4 */ + dev->shadow_regs[0xed] = 0x00; + dev->shadow_regs[0xee] = 0x00; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x08; + break; + case A920_MOTOR: + case X1100_MOTOR: + /* ? */ + dev->shadow_regs[0xc5] = 0x10; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x09; + + dev->shadow_regs[0xc9] = 0x3b; + dev->shadow_regs[0xca] = 0x01; + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x4d; + dev->shadow_regs[0xe1] = 0x1c; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0x71; + /* ? */ + dev->shadow_regs[0xe3] = 0x02; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0x6d; + dev->shadow_regs[0xe5] = 0x15; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0xdc; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0xad; + dev->shadow_regs[0xe8] = 0x07; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x1b; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0xe1; + dev->shadow_regs[0xeb] = 0x03; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x07; + /* bounds of movement range4 -only for 75dpi grayscale */ + dev->shadow_regs[0xed] = 0xc2; + dev->shadow_regs[0xee] = 0x02; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x03; + break; + } + + /* set grayscale scan */ + dev->shadow_regs[0x2f] = 0x21; + + /* set ? only for colour? */ + dev->shadow_regs[0x80] = 0x00; + dev->shadow_regs[0x81] = 0x00; + dev->shadow_regs[0x82] = 0x00; + /* Motor enable & Coordinate space denominator */ + dev->shadow_regs[0xc3] = 0x81; + + } + + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x0f; + + /* set # of head moves per CIS read */ + rts88xx_set_scan_frequency (dev->shadow_regs, 1); + + /* set horizontal resolution */ + if (dev->model.sensor_type != X1200_SENSOR) + dev->shadow_regs[0x79] = 0x08; + + } + + /* 150dpi x 150dpi */ + if (resolution == 150) + { + DBG (5, "sanei_lexmark_low_set_scan_regs(): 150 DPI resolution\n"); + + if (isColourScan) + { + + switch (dev->model.sensor_type) + { + case X74_SENSOR: + dev->shadow_regs[0x34] = 0x08; + dev->shadow_regs[0x36] = 0x06; + dev->shadow_regs[0x38] = 0x05; + dev->shadow_regs[0x39] = 0x07; + + /* resolution divisor */ + dev->shadow_regs[0x79] = 0x08; + + dev->shadow_regs[0x80] = 0x0a; + dev->shadow_regs[0x81] = 0x0c; + dev->shadow_regs[0x82] = 0x04; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case X1100_B2_SENSOR: + dev->shadow_regs[0x34] = 0x0b; + dev->shadow_regs[0x36] = 0x0b; + dev->shadow_regs[0x38] = 0x0a; + + dev->shadow_regs[0x80] = 0x05; + dev->shadow_regs[0x81] = 0x05; + dev->shadow_regs[0x82] = 0x0a; + + dev->shadow_regs[0x85] = 0x83; + dev->shadow_regs[0x86] = 0x7e; + dev->shadow_regs[0x87] = 0xad; + dev->shadow_regs[0x88] = 0x35; + + dev->shadow_regs[0x91] = 0xfe; + dev->shadow_regs[0x92] = 0xdf; + dev->shadow_regs[0x93] = 0x0e; + break; + case X1100_2C_SENSOR: + dev->shadow_regs[0x34] = 0x05; + dev->shadow_regs[0x36] = 0x07; + dev->shadow_regs[0x38] = 0x05; + + dev->shadow_regs[0x80] = 0x00; + dev->shadow_regs[0x81] = 0x02; + dev->shadow_regs[0x82] = 0x06; + + dev->shadow_regs[0x85] = 0x20; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case A920_SENSOR: + dev->shadow_regs[0x34] = 0x03; + dev->shadow_regs[0x36] = 0x08; + dev->shadow_regs[0x38] = 0x05; + + dev->shadow_regs[0x80] = 0x0e; + dev->shadow_regs[0x81] = 0x07; + dev->shadow_regs[0x82] = 0x02; + + dev->shadow_regs[0x85] = 0x05; + dev->shadow_regs[0x86] = 0x14; + dev->shadow_regs[0x87] = 0x06; + dev->shadow_regs[0x88] = 0x04; + + dev->shadow_regs[0x91] = 0xe0; + dev->shadow_regs[0x92] = 0x85; + dev->shadow_regs[0x93] = 0x0e; + break; + case X1200_SENSOR: + dev->shadow_regs[0x34] = 0x04; + dev->shadow_regs[0x36] = 0x05; + dev->shadow_regs[0x38] = 0x02; + /* data compression + dev->shadow_regs[0x40] = 0x90; + dev->shadow_regs[0x50] = 0x20; */ + /* no data compression */ + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x50] = 0x00; + + dev->shadow_regs[0x79] = 0x20; + + dev->shadow_regs[0x80] = 0x00; + dev->shadow_regs[0x81] = 0x07; + dev->shadow_regs[0x82] = 0x0b; + + dev->shadow_regs[0x85] = 0x20; + dev->shadow_regs[0x86] = 0x1e; + dev->shadow_regs[0x87] = 0x39; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x92] = 0x92; + + break; + case X1200_USB2_SENSOR: + dev->shadow_regs[0x34] = 0x04; + dev->shadow_regs[0x36] = 0x05; + dev->shadow_regs[0x38] = 0x02; + + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x50] = 0x00; + + dev->shadow_regs[0x79] = 0x20; + + dev->shadow_regs[0x80] = 0x00; + dev->shadow_regs[0x81] = 0x07; + dev->shadow_regs[0x82] = 0x0b; + + dev->shadow_regs[0x85] = 0x20; + dev->shadow_regs[0x86] = 0x1e; + dev->shadow_regs[0x87] = 0x39; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x92] = 0x92; + break; + } /* switch */ + switch (dev->model.motor_type) + { + case X74_MOTOR: + dev->shadow_regs[0xc2] = 0x80; + /* ? */ + dev->shadow_regs[0xc4] = 0x20; + + dev->shadow_regs[0xc5] = 0x0e; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x0b; + dev->shadow_regs[0xc7] = 0x00; + dev->shadow_regs[0xc8] = 0x04; + dev->shadow_regs[0xc9] = 0x39; + dev->shadow_regs[0xca] = 0x03; + + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x41; + dev->shadow_regs[0xe1] = 0x09; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0x89; + /* ? */ + dev->shadow_regs[0xe3] = 0x02; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0x0d; + + dev->shadow_regs[0xe5] = 0x09; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0x0d; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0xe8; + dev->shadow_regs[0xe8] = 0x02; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x05; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x01; + /* bounds of movement range4 */ + dev->shadow_regs[0xed] = 0x00; + dev->shadow_regs[0xee] = 0x00; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x01; + break; + case X1100_MOTOR: + case A920_MOTOR: + /* ? */ + dev->shadow_regs[0xc5] = 0x0e; + /* ? */ + dev->shadow_regs[0xc9] = 0x3a; + dev->shadow_regs[0xca] = 0x03; + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x61; + dev->shadow_regs[0xe1] = 0x0a; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0xed; + /* ? */ + dev->shadow_regs[0xe3] = 0x02; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0x29; + dev->shadow_regs[0xe5] = 0x0a; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0x0e; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0x29; + dev->shadow_regs[0xe8] = 0x03; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x05; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x01; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x01; + break; + } + /* set colour scan */ + dev->shadow_regs[0x2f] = 0x11; + + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x37] = 0x01; + /* Motor enable & Coordinate space denominator */ + dev->shadow_regs[0xc3] = 0x83; + + } /* if (isColourScan) */ + else + { + switch (dev->model.sensor_type) + { + case X74_SENSOR: + + dev->shadow_regs[0x34] = 0x02; + dev->shadow_regs[0x35] = 0x02; + dev->shadow_regs[0x36] = 0x04; + dev->shadow_regs[0x37] = 0x04; + dev->shadow_regs[0x38] = 0x06; + dev->shadow_regs[0x39] = 0x07; + /* Motor enable & Coordinate space denominator */ + dev->shadow_regs[0x40] = 0x40; + + /* resolution divisor */ + dev->shadow_regs[0x79] = 0x08; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case X1100_B2_SENSOR: + dev->shadow_regs[0x34] = 0x04; + dev->shadow_regs[0x35] = 0x04; + dev->shadow_regs[0x36] = 0x07; + dev->shadow_regs[0x37] = 0x07; + dev->shadow_regs[0x38] = 0x0a; + + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case X1100_2C_SENSOR: + dev->shadow_regs[0x34] = 0x02; + dev->shadow_regs[0x35] = 0x02; + dev->shadow_regs[0x36] = 0x04; + dev->shadow_regs[0x37] = 0x04; + dev->shadow_regs[0x38] = 0x05; + + dev->shadow_regs[0x85] = 0x20; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case A920_SENSOR: + dev->shadow_regs[0x34] = 0x02; + dev->shadow_regs[0x35] = 0x02; + dev->shadow_regs[0x36] = 0x04; + dev->shadow_regs[0x37] = 0x04; + dev->shadow_regs[0x38] = 0x05; + + dev->shadow_regs[0x85] = 0x0d; + dev->shadow_regs[0x86] = 0x14; + dev->shadow_regs[0x87] = 0x06; + dev->shadow_regs[0x88] = 0x45; + + dev->shadow_regs[0x91] = 0x60; + dev->shadow_regs[0x92] = 0x8d; + dev->shadow_regs[0x93] = 0x0e; + break; + case X1200_SENSOR: + dev->shadow_regs[0x34] = 0x01; + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x36] = 0x02; + dev->shadow_regs[0x37] = 0x02; + dev->shadow_regs[0x38] = 0x03; + + /* dev->shadow_regs[0x40] = 0x90; + dev->shadow_regs[0x50] = 0x20; */ + /* no data compression */ + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x50] = 0x00; + + dev->shadow_regs[0x79] = 0x20; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0xff; + dev->shadow_regs[0x88] = 0x02; + + dev->shadow_regs[0x92] = 0x92; + break; + case X1200_USB2_SENSOR: + dev->shadow_regs[0x34] = 0x01; + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x36] = 0x02; + dev->shadow_regs[0x37] = 0x02; + dev->shadow_regs[0x38] = 0x03; + + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x50] = 0x00; + + dev->shadow_regs[0x79] = 0x20; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0xff; + dev->shadow_regs[0x88] = 0x02; + + dev->shadow_regs[0x92] = 0x92; + break; + } /* switch */ + switch (dev->model.motor_type) + { + case X74_MOTOR: + /* ? */ + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc5] = 0x14; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x0b; + + dev->shadow_regs[0xc8] = 0x04; + dev->shadow_regs[0xc9] = 0x39; + dev->shadow_regs[0xca] = 0x01; + + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x09; + dev->shadow_regs[0xe1] = 0x18; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0xe9; + /* ? */ + dev->shadow_regs[0xe3] = 0x03; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0x79; + + dev->shadow_regs[0xe5] = 0x16; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0x64; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0xcd; + dev->shadow_regs[0xe8] = 0x08; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x32; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0xe5; + dev->shadow_regs[0xeb] = 0x04; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x0c; + /* bounds of movement range4 */ + dev->shadow_regs[0xed] = 0x00; + dev->shadow_regs[0xee] = 0x00; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x08; + break; + case X1100_MOTOR: + case A920_MOTOR: + /* ? */ + dev->shadow_regs[0xc5] = 0x16; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x09; + /* ? */ + dev->shadow_regs[0xc9] = 0x3b; + dev->shadow_regs[0xca] = 0x01; + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0xdd; + dev->shadow_regs[0xe1] = 0x18; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0x01; + /* ? */ + dev->shadow_regs[0xe3] = 0x03; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0x6d; + dev->shadow_regs[0xe5] = 0x15; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0xdc; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0xad; + dev->shadow_regs[0xe8] = 0x07; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x1b; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0xe1; + dev->shadow_regs[0xeb] = 0x03; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x07; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x03; + break; + } + + /* set grayscale scan */ + dev->shadow_regs[0x2f] = 0x21; + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x07; + /* set ? only for colour? */ + dev->shadow_regs[0x80] = 0x00; + dev->shadow_regs[0x81] = 0x00; + dev->shadow_regs[0x82] = 0x00; + + /* Motor enable & Coordinate space denominator */ + dev->shadow_regs[0xc3] = 0x81; + } /* else (greyscale) */ + + + + + /* set # of head moves per CIS read */ + rts88xx_set_scan_frequency (dev->shadow_regs, 1); + + /* hum, horizontal resolution different for X1200 ? */ + /* if (dev->model.sensor_type != X1200_SENSOR) + dev->shadow_regs[0x79] = 0x20; */ + + } + + /*300dpi x 300dpi */ + if (resolution == 300) + { + DBG (5, "sanei_lexmark_low_set_scan_regs(): 300 DPI resolution\n"); + + if (isColourScan) + { + + switch (dev->model.sensor_type) + { + case X74_SENSOR: + dev->shadow_regs[0x34] = 0x08; + dev->shadow_regs[0x36] = 0x06; + dev->shadow_regs[0x38] = 0x05; + dev->shadow_regs[0x39] = 0x07; + + dev->shadow_regs[0x80] = 0x08; + dev->shadow_regs[0x81] = 0x0a; + dev->shadow_regs[0x82] = 0x03; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case X1100_B2_SENSOR: + dev->shadow_regs[0x34] = 0x15; + dev->shadow_regs[0x36] = 0x15; + dev->shadow_regs[0x38] = 0x14; + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x03; + + dev->shadow_regs[0x80] = 0x0a; + dev->shadow_regs[0x81] = 0x0a; + dev->shadow_regs[0x82] = 0x06; + + dev->shadow_regs[0x85] = 0x83; + dev->shadow_regs[0x86] = 0x7e; + dev->shadow_regs[0x87] = 0xad; + dev->shadow_regs[0x88] = 0x35; + + dev->shadow_regs[0x91] = 0xfe; + dev->shadow_regs[0x92] = 0xdf; + dev->shadow_regs[0x93] = 0x0e; + break; + case X1100_2C_SENSOR: + dev->shadow_regs[0x34] = 0x08; + dev->shadow_regs[0x36] = 0x0d; + dev->shadow_regs[0x38] = 0x09; + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x03; + + dev->shadow_regs[0x80] = 0x0e; + dev->shadow_regs[0x81] = 0x04; + dev->shadow_regs[0x82] = 0x0a; + + dev->shadow_regs[0x85] = 0x20; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case A920_SENSOR: + dev->shadow_regs[0x34] = 0x06; + dev->shadow_regs[0x36] = 0x10; + dev->shadow_regs[0x38] = 0x09; + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x03; + + dev->shadow_regs[0x80] = 0x0c; + dev->shadow_regs[0x81] = 0x02; + dev->shadow_regs[0x82] = 0x04; + + dev->shadow_regs[0x85] = 0x05; + dev->shadow_regs[0x86] = 0x14; + dev->shadow_regs[0x87] = 0x06; + dev->shadow_regs[0x88] = 0x04; + + dev->shadow_regs[0x91] = 0xe0; + dev->shadow_regs[0x92] = 0x85; + dev->shadow_regs[0x93] = 0x0e; + break; + case X1200_SENSOR: + dev->shadow_regs[0x34] = 0x07; + dev->shadow_regs[0x36] = 0x09; + dev->shadow_regs[0x38] = 0x04; + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x03; + + /* data compression + dev->shadow_regs[0x40] = 0x90; + dev->shadow_regs[0x50] = 0x20; */ + /* no data compression */ + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x50] = 0x00; + + dev->shadow_regs[0x80] = 0x00; + dev->shadow_regs[0x81] = 0x0e; + dev->shadow_regs[0x82] = 0x06; + break; + case X1200_USB2_SENSOR: + dev->shadow_regs[0x34] = 0x07; + dev->shadow_regs[0x36] = 0x09; + dev->shadow_regs[0x38] = 0x04; + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x03; + + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x50] = 0x00; + + dev->shadow_regs[0x80] = 0x00; + dev->shadow_regs[0x81] = 0x0e; + dev->shadow_regs[0x82] = 0x06; + break; + } + switch (dev->model.motor_type) + { + case X74_MOTOR: + /* ? */ + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc5] = 0x12; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x09; + + dev->shadow_regs[0xc8] = 0x04; + dev->shadow_regs[0xc9] = 0x39; + dev->shadow_regs[0xca] = 0x0f; + + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x5d; + dev->shadow_regs[0xe1] = 0x05; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0xed; + /* ? */ + dev->shadow_regs[0xe3] = 0x02; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0x29; + dev->shadow_regs[0xe5] = 0x05; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0x0d; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0x00; + dev->shadow_regs[0xe8] = 0x00; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x05; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x01; + /* bounds of movement range4 -only for 75dpi grayscale */ + dev->shadow_regs[0xed] = 0x00; + dev->shadow_regs[0xee] = 0x00; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x01; + break; + case A920_MOTOR: + case X1100_MOTOR: + /* ? */ + dev->shadow_regs[0xc5] = 0x17; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x09; + /* ? */ + dev->shadow_regs[0xc9] = 0x3a; + dev->shadow_regs[0xca] = 0x0a; + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x75; + dev->shadow_regs[0xe1] = 0x0a; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0xdd; + /* ? */ + dev->shadow_regs[0xe3] = 0x05; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0x59; + dev->shadow_regs[0xe5] = 0x0a; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0x0e; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0x00; + dev->shadow_regs[0xe8] = 0x00; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x05; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x01; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x01; + break; + } + + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x37] = 0x01; + + /* set colour scan */ + dev->shadow_regs[0x2f] = 0x11; + + /* Motor enable & Coordinate space denominator */ + dev->shadow_regs[0xc3] = 0x83; + + } + else /* greyscale */ + { + + switch (dev->model.sensor_type) + { + case X74_SENSOR: + dev->shadow_regs[0x34] = 0x04; + dev->shadow_regs[0x35] = 0x04; + dev->shadow_regs[0x36] = 0x08; + dev->shadow_regs[0x37] = 0x08; + dev->shadow_regs[0x38] = 0x0c; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case X1100_B2_SENSOR: + dev->shadow_regs[0x34] = 0x08; + dev->shadow_regs[0x35] = 0x08; + dev->shadow_regs[0x36] = 0x0f; + dev->shadow_regs[0x37] = 0x0f; + dev->shadow_regs[0x38] = 0x16; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case X1100_2C_SENSOR: + dev->shadow_regs[0x34] = 0x04; + dev->shadow_regs[0x35] = 0x04; + dev->shadow_regs[0x36] = 0x07; + dev->shadow_regs[0x37] = 0x07; + dev->shadow_regs[0x38] = 0x0a; + + dev->shadow_regs[0x85] = 0x20; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case A920_SENSOR: + dev->shadow_regs[0x34] = 0x03; + dev->shadow_regs[0x35] = 0x03; + dev->shadow_regs[0x36] = 0x06; + dev->shadow_regs[0x37] = 0x06; + dev->shadow_regs[0x38] = 0x09; + + dev->shadow_regs[0x85] = 0x05; + dev->shadow_regs[0x86] = 0x14; + dev->shadow_regs[0x87] = 0x06; + dev->shadow_regs[0x88] = 0x04; + + dev->shadow_regs[0x91] = 0xe0; + dev->shadow_regs[0x92] = 0x85; + dev->shadow_regs[0x93] = 0x0e; + break; + case X1200_SENSOR: + dev->shadow_regs[0x34] = 0x02; + dev->shadow_regs[0x35] = 0x02; + dev->shadow_regs[0x36] = 0x04; + dev->shadow_regs[0x37] = 0x04; + dev->shadow_regs[0x38] = 0x06; + break; + case X1200_USB2_SENSOR: + dev->shadow_regs[0x34] = 0x02; + dev->shadow_regs[0x35] = 0x02; + dev->shadow_regs[0x36] = 0x04; + dev->shadow_regs[0x37] = 0x04; + dev->shadow_regs[0x38] = 0x06; + break; + } + switch (dev->model.motor_type) + { + case X74_MOTOR: + /* ? */ + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc5] = 0x1c; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x0b; + + dev->shadow_regs[0xc8] = 0x04; + dev->shadow_regs[0xc9] = 0x39; + dev->shadow_regs[0xca] = 0x05; + + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x29; + dev->shadow_regs[0xe1] = 0x17; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0x8f; + /* ? */ + dev->shadow_regs[0xe3] = 0x06; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0x61; + + dev->shadow_regs[0xe5] = 0x16; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0x64; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0xb5; + dev->shadow_regs[0xe8] = 0x08; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x32; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x0c; + /* bounds of movement range4 -only for 75dpi grayscale */ + dev->shadow_regs[0xed] = 0x00; + dev->shadow_regs[0xee] = 0x00; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x08; + break; + case A920_MOTOR: + case X1100_MOTOR: + /* ? */ + dev->shadow_regs[0xc5] = 0x19; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x09; + /* ? */ + dev->shadow_regs[0xc9] = 0x3a; + dev->shadow_regs[0xca] = 0x08; + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0xe3; + dev->shadow_regs[0xe1] = 0x18; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0x03; + /* ? */ + dev->shadow_regs[0xe3] = 0x06; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0x2b; + dev->shadow_regs[0xe5] = 0x17; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0xdc; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0xb3; + dev->shadow_regs[0xe8] = 0x07; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x1b; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x07; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x03; + break; + } /* switch motortype */ + /* set grayscale scan */ + dev->shadow_regs[0x2f] = 0x21; + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x03; + + /* set ? only for colour? */ + dev->shadow_regs[0x80] = 0x00; + dev->shadow_regs[0x81] = 0x00; + dev->shadow_regs[0x82] = 0x00; + /* Motor enable & Coordinate space denominator */ + dev->shadow_regs[0xc3] = 0x81; + + + } /* else (gray) */ + + /* set # of head moves per CIS read */ + rts88xx_set_scan_frequency (dev->shadow_regs, 1); + /* set horizontal resolution */ + dev->shadow_regs[0x79] = 0x20; + } + + /* 600dpi x 600dpi */ + if (resolution == 600) + { + DBG (5, "sanei_lexmark_low_set_scan_regs(): 600 DPI resolution\n"); + + + + if (isColourScan) + { + /* 600 dpi color doesn't work for X74 yet */ + if (dev->model.sensor_type == X74_SENSOR) + return SANE_STATUS_INVAL; + + switch (dev->model.sensor_type) + { + case X74_SENSOR: + dev->shadow_regs[0x34] = 0x10; + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x36] = 0x0c; + dev->shadow_regs[0x37] = 0x01; + dev->shadow_regs[0x38] = 0x09; + + dev->shadow_regs[0x80] = 0x02; + dev->shadow_regs[0x81] = 0x08; + dev->shadow_regs[0x82] = 0x08; + + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + + /*dev->shadow_regs[0x34] = 0x08; + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x36] = 0x06; + dev->shadow_regs[0x37] = 0x01; + dev->shadow_regs[0x38] = 0x05; + + + dev->shadow_regs[0x80] = 0x09; + dev->shadow_regs[0x81] = 0x0c; + dev->shadow_regs[0x82] = 0x04; + + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; */ + + + + case X1100_B2_SENSOR: + dev->shadow_regs[0x34] = 0x15; + dev->shadow_regs[0x36] = 0x15; + dev->shadow_regs[0x38] = 0x14; + + dev->shadow_regs[0x80] = 0x02; + dev->shadow_regs[0x81] = 0x02; + dev->shadow_regs[0x82] = 0x08; + + dev->shadow_regs[0x85] = 0x83; + dev->shadow_regs[0x86] = 0x7e; + dev->shadow_regs[0x87] = 0xad; + dev->shadow_regs[0x88] = 0x35; + + dev->shadow_regs[0x91] = 0xfe; + dev->shadow_regs[0x92] = 0xdf; + dev->shadow_regs[0x93] = 0x0e; + break; + case X1100_2C_SENSOR: + dev->shadow_regs[0x34] = 0x08; + dev->shadow_regs[0x36] = 0x0d; + dev->shadow_regs[0x38] = 0x09; + + dev->shadow_regs[0x80] = 0x0e; + dev->shadow_regs[0x81] = 0x02; + dev->shadow_regs[0x82] = 0x0a; + + dev->shadow_regs[0x85] = 0x20; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case A920_SENSOR: + dev->shadow_regs[0x34] = 0x06; + dev->shadow_regs[0x36] = 0x0f; + dev->shadow_regs[0x38] = 0x09; + + dev->shadow_regs[0x79] = 0x40; + + dev->shadow_regs[0x80] = 0x0e; + dev->shadow_regs[0x81] = 0x0e; + dev->shadow_regs[0x82] = 0x00; + + dev->shadow_regs[0x85] = 0x05; + dev->shadow_regs[0x86] = 0x14; + dev->shadow_regs[0x87] = 0x06; + dev->shadow_regs[0x88] = 0x04; + + dev->shadow_regs[0x91] = 0x60; + dev->shadow_regs[0x92] = 0x85; + dev->shadow_regs[0x93] = 0x0e; + break; + case X1200_SENSOR: + dev->shadow_regs[0x34] = 0x07; + dev->shadow_regs[0x36] = 0x0a; + dev->shadow_regs[0x38] = 0x04; + + /* data compression + dev->shadow_regs[0x40] = 0x90; + dev->shadow_regs[0x50] = 0x20; */ + + /* no data compression */ + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x50] = 0x00; + + dev->shadow_regs[0x80] = 0x02; + dev->shadow_regs[0x81] = 0x00; + dev->shadow_regs[0x82] = 0x06; + break; + case X1200_USB2_SENSOR: + dev->shadow_regs[0x34] = 0x0d; + dev->shadow_regs[0x36] = 0x13; + dev->shadow_regs[0x38] = 0x10; + + dev->shadow_regs[0x80] = 0x04; + dev->shadow_regs[0x81] = 0x0e; + dev->shadow_regs[0x82] = 0x08; + + dev->shadow_regs[0x85] = 0x02; + dev->shadow_regs[0x86] = 0x3b; + dev->shadow_regs[0x87] = 0x0f; + dev->shadow_regs[0x88] = 0x24; + + dev->shadow_regs[0x91] = 0x19; + dev->shadow_regs[0x92] = 0x30; + dev->shadow_regs[0x93] = 0x0e; + dev->shadow_regs[0xc5] = 0x17; + dev->shadow_regs[0xc6] = 0x09; + dev->shadow_regs[0xca] = 0x0a; + break; + } + switch (dev->model.motor_type) + { + case X74_MOTOR: + /* Motor enable & Coordinate space denominator */ + dev->shadow_regs[0xc3] = 0x81; + /* ? */ + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc5] = 0x21; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x09; + dev->shadow_regs[0xc8] = 0x04; + dev->shadow_regs[0xc9] = 0x39; + dev->shadow_regs[0xca] = 0x20; + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x00; + dev->shadow_regs[0xe1] = 0x00; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0xbf; + /* ? */ + dev->shadow_regs[0xe3] = 0x05; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0x00; + dev->shadow_regs[0xe5] = 0x00; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0x0d; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0x00; + dev->shadow_regs[0xe8] = 0x00; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x05; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x01; + /* bounds of movement range4 -only for 75dpi grayscale */ + dev->shadow_regs[0xed] = 0x00; + dev->shadow_regs[0xee] = 0x00; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x01; + break; + case A920_MOTOR: + case X1100_MOTOR: + /* Motor enable & Coordinate space denominator */ + dev->shadow_regs[0xc3] = 0x86; + /* ? */ + dev->shadow_regs[0xc5] = 0x27; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x0c; + /* ? */ + dev->shadow_regs[0xc9] = 0x3a; + dev->shadow_regs[0xca] = 0x1a; + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x57; + dev->shadow_regs[0xe1] = 0x0a; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0xbf; + /* ? */ + dev->shadow_regs[0xe3] = 0x05; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0x3b; + dev->shadow_regs[0xe5] = 0x0a; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0x0e; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0x00; + dev->shadow_regs[0xe8] = 0x00; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x05; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x01; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x01; + break; + } + /* set colour scan */ + dev->shadow_regs[0x2f] = 0x11; + + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x37] = 0x01; + + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x03; + /* set # of head moves per CIS read */ + rts88xx_set_scan_frequency (dev->shadow_regs, 2); + + + } + else + { + switch (dev->model.sensor_type) + { + case X74_SENSOR: + dev->shadow_regs[0x2c] = 0x04; + dev->shadow_regs[0x2d] = 0x46; + dev->shadow_regs[0x34] = 0x05; + dev->shadow_regs[0x35] = 0x05; + dev->shadow_regs[0x36] = 0x0b; + dev->shadow_regs[0x37] = 0x0b; + dev->shadow_regs[0x38] = 0x11; + dev->shadow_regs[0x40] = 0x40; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case X1100_B2_SENSOR: + dev->shadow_regs[0x34] = 0x11; + dev->shadow_regs[0x35] = 0x11; + dev->shadow_regs[0x36] = 0x21; + dev->shadow_regs[0x37] = 0x21; + dev->shadow_regs[0x38] = 0x31; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case X1100_2C_SENSOR: + dev->shadow_regs[0x34] = 0x07; + dev->shadow_regs[0x35] = 0x07; + dev->shadow_regs[0x36] = 0x0d; + dev->shadow_regs[0x37] = 0x0d; + dev->shadow_regs[0x38] = 0x13; + + dev->shadow_regs[0x85] = 0x20; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + break; + case A920_SENSOR: + dev->shadow_regs[0x34] = 0x05; + dev->shadow_regs[0x35] = 0x05; + dev->shadow_regs[0x36] = 0x0b; + dev->shadow_regs[0x37] = 0x0b; + dev->shadow_regs[0x38] = 0x11; + + dev->shadow_regs[0x85] = 0x05; + dev->shadow_regs[0x86] = 0x14; + dev->shadow_regs[0x87] = 0x06; + dev->shadow_regs[0x88] = 0x04; + + dev->shadow_regs[0x91] = 0xe0; + dev->shadow_regs[0x92] = 0x85; + dev->shadow_regs[0x93] = 0x0e; + break; + case X1200_SENSOR: + dev->shadow_regs[0x34] = 0x03; + dev->shadow_regs[0x35] = 0x03; + dev->shadow_regs[0x36] = 0x07; + dev->shadow_regs[0x37] = 0x07; + dev->shadow_regs[0x38] = 0x0b; + + /* data compression + dev->shadow_regs[0x40] = 0x90; + dev->shadow_regs[0x50] = 0x20; */ + /* no data compression */ + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x50] = 0x00; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0xff; + dev->shadow_regs[0x88] = 0x02; + + dev->shadow_regs[0x92] = 0x00; + + break; + case X1200_USB2_SENSOR: + dev->shadow_regs[0x34] = 0x03; + dev->shadow_regs[0x35] = 0x03; + dev->shadow_regs[0x36] = 0x07; + dev->shadow_regs[0x37] = 0x07; + dev->shadow_regs[0x38] = 0x0b; + + dev->shadow_regs[0x40] = 0x80; + dev->shadow_regs[0x50] = 0x00; + + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0xff; + dev->shadow_regs[0x88] = 0x02; + + dev->shadow_regs[0x92] = 0x00; + break; + } + switch (dev->model.motor_type) + { + case X74_MOTOR: + /* set # of head moves per CIS read */ + rts88xx_set_scan_frequency (dev->shadow_regs, 1); + /* ? */ + dev->shadow_regs[0xc4] = 0x20; + dev->shadow_regs[0xc5] = 0x22; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x0b; + + dev->shadow_regs[0xc8] = 0x04; + dev->shadow_regs[0xc9] = 0x39; + dev->shadow_regs[0xca] = 0x1f; + + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x2f; + dev->shadow_regs[0xe1] = 0x11; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0x9f; + /* ? */ + dev->shadow_regs[0xe3] = 0x0f; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0xcb; + + dev->shadow_regs[0xe5] = 0x10; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0x64; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0x00; + dev->shadow_regs[0xe8] = 0x00; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x32; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x0c; + /* bounds of movement range4 -only for 75dpi grayscale */ + dev->shadow_regs[0xed] = 0x00; + dev->shadow_regs[0xee] = 0x00; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x08; + break; + case X1100_MOTOR: + case A920_MOTOR: + /* set ? only for colour? */ + dev->shadow_regs[0x80] = 0x00; + dev->shadow_regs[0x81] = 0x00; + dev->shadow_regs[0x82] = 0x00; + /* ? */ + dev->shadow_regs[0xc5] = 0x22; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x09; + /* ? */ + dev->shadow_regs[0xc9] = 0x3b; + dev->shadow_regs[0xca] = 0x1f; + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0xf7; + dev->shadow_regs[0xe1] = 0x16; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0x87; + /* ? */ + dev->shadow_regs[0xe3] = 0x13; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0x1b; + dev->shadow_regs[0xe5] = 0x16; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0xdc; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0x00; + dev->shadow_regs[0xe8] = 0x00; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x1b; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x07; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x03; + break; + } + + /* set grayscale scan */ + dev->shadow_regs[0x2f] = 0x21; + + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x01; + + /* set # of head moves per CIS read */ + rts88xx_set_scan_frequency (dev->shadow_regs, 1); + + /* Motor enable & Coordinate space denominator */ + dev->shadow_regs[0xc3] = 0x81; + } /* else (grayscale) */ + + /* set horizontal resolution */ + dev->shadow_regs[0x79] = 0x40; + + } + /*600dpi x 1200dpi */ + if (resolution == 1200) + { + DBG (5, "sanei_lexmark_low_set_scan_regs(): 1200 DPI resolution\n"); + + /* 1200 dpi doesn't work for X74 yet */ + if (dev->model.sensor_type == X74_SENSOR) + return SANE_STATUS_INVAL; + + if (isColourScan) + { + /* set colour scan */ + dev->shadow_regs[0x2f] = 0x11; + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x01; + /* set # of head moves per CIS read */ + rts88xx_set_scan_frequency (dev->shadow_regs, 2); + + if (dev->model.sensor_type == X1100_B2_SENSOR) + { + /* set ? */ + dev->shadow_regs[0x34] = 0x29; + dev->shadow_regs[0x36] = 0x29; + dev->shadow_regs[0x38] = 0x28; + /* set ? */ + dev->shadow_regs[0x80] = 0x04; + dev->shadow_regs[0x81] = 0x04; + dev->shadow_regs[0x82] = 0x08; + dev->shadow_regs[0x85] = 0x83; + dev->shadow_regs[0x86] = 0x7e; + dev->shadow_regs[0x87] = 0xad; + dev->shadow_regs[0x88] = 0x35; + dev->shadow_regs[0x91] = 0xfe; + dev->shadow_regs[0x92] = 0xdf; + } + else + { /* A920 case */ + dev->shadow_regs[0x34] = 0x0c; + dev->shadow_regs[0x36] = 0x1e; + dev->shadow_regs[0x38] = 0x10; + + dev->shadow_regs[0x80] = 0x0c; + dev->shadow_regs[0x81] = 0x08; + dev->shadow_regs[0x82] = 0x0c; + + dev->shadow_regs[0x85] = 0x05; + dev->shadow_regs[0x86] = 0x14; + dev->shadow_regs[0x87] = 0x06; + dev->shadow_regs[0x88] = 0x04; + + dev->shadow_regs[0x91] = 0x60; + dev->shadow_regs[0x92] = 0x85; + } + + dev->shadow_regs[0x35] = 0x01; + dev->shadow_regs[0x37] = 0x01; + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x01; + dev->shadow_regs[0x93] = 0x0e; + + /* Motor enable & Coordinate space denominator */ + dev->shadow_regs[0xc3] = 0x86; + /* ? */ + dev->shadow_regs[0xc5] = 0x41; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x0c; + /* ? */ + dev->shadow_regs[0xc9] = 0x3a; + dev->shadow_regs[0xca] = 0x40; + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x00; + dev->shadow_regs[0xe1] = 0x00; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0x85; + /* ? */ + dev->shadow_regs[0xe3] = 0x0b; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0x00; + dev->shadow_regs[0xe5] = 0x00; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0x0e; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0x00; + dev->shadow_regs[0xe8] = 0x00; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x05; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x01; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x01; + } + else + { + /* set grayscale scan */ + dev->shadow_regs[0x2f] = 0x21; + /* set ? */ + dev->shadow_regs[0x34] = 0x22; + dev->shadow_regs[0x35] = 0x22; + dev->shadow_regs[0x36] = 0x42; + dev->shadow_regs[0x37] = 0x42; + dev->shadow_regs[0x38] = 0x62; + /* set motor resolution divisor */ + dev->shadow_regs[0x39] = 0x01; + /* set # of head moves per CIS read */ + rts88xx_set_scan_frequency (dev->shadow_regs, 0); + + /* set ? only for colour? */ + dev->shadow_regs[0x80] = 0x00; + dev->shadow_regs[0x81] = 0x00; + dev->shadow_regs[0x82] = 0x00; + dev->shadow_regs[0x85] = 0x00; + dev->shadow_regs[0x86] = 0x00; + dev->shadow_regs[0x87] = 0x00; + dev->shadow_regs[0x88] = 0x00; + dev->shadow_regs[0x91] = 0x00; + dev->shadow_regs[0x92] = 0x00; + dev->shadow_regs[0x93] = 0x06; + /* Motor enable & Coordinate space denominator */ + dev->shadow_regs[0xc3] = 0x81; + /* ? */ + dev->shadow_regs[0xc5] = 0x41; + /* Movement direction & step size */ + dev->shadow_regs[0xc6] = 0x09; + /* ? */ + dev->shadow_regs[0xc9] = 0x3a; + dev->shadow_regs[0xca] = 0x40; + /* bounds of movement range0 */ + dev->shadow_regs[0xe0] = 0x00; + dev->shadow_regs[0xe1] = 0x00; + /* step size range0 */ + dev->shadow_regs[0xe2] = 0xc7; + /* ? */ + dev->shadow_regs[0xe3] = 0x29; + /* bounds of movement range1 */ + dev->shadow_regs[0xe4] = 0x00; + dev->shadow_regs[0xe5] = 0x00; + /* step size range1 */ + dev->shadow_regs[0xe6] = 0xdc; + /* bounds of movement range2 */ + dev->shadow_regs[0xe7] = 0x00; + dev->shadow_regs[0xe8] = 0x00; + /* step size range2 */ + dev->shadow_regs[0xe9] = 0x1b; + /* bounds of movement range3 */ + dev->shadow_regs[0xea] = 0x00; + dev->shadow_regs[0xeb] = 0x00; + /* step size range3 */ + dev->shadow_regs[0xec] = 0x07; + /* step size range4 */ + dev->shadow_regs[0xef] = 0x03; + } + + /* set horizontal resolution */ + dev->shadow_regs[0x79] = 0x40; + } + + /* is calibration has been done, we override fixed settings with detected ones */ + if (calibrated) + { + /* override fixed values with ones from calibration */ + if (rts88xx_is_color (dev->shadow_regs)) + { + rts88xx_set_offset (dev->shadow_regs, + dev->offset.red, + dev->offset.green, dev->offset.blue); + rts88xx_set_gain (dev->shadow_regs, + dev->gain.red, dev->gain.green, dev->gain.blue); + } + else + { + rts88xx_set_offset (dev->shadow_regs, + dev->offset.gray, + dev->offset.gray, dev->offset.gray); + rts88xx_set_gain (dev->shadow_regs, + dev->gain.gray, dev->gain.gray, dev->gain.gray); + } + } + DBG (2, "sanei_lexmark_low_set_scan_regs: end.\n"); + return SANE_STATUS_GOOD; +} + +SANE_Status +sanei_lexmark_low_start_scan (Lexmark_Device * dev) +{ + SANE_Int devnum; + + static SANE_Byte command4_block[] = { 0x90, 0x00, 0x00, 0x03 }; + + static SANE_Byte command5_block[] = { 0x80, 0xb3, 0x00, 0x01 }; + + SANE_Byte poll_result[3]; + SANE_Byte read_result; + SANE_Bool scan_head_moving; + size_t size; + + devnum = dev->devnum; + + dev->transfer_buffer = NULL; /* No data xferred yet */ + DBG (2, "sanei_lexmark_low_start_scan:\n"); + + + /* 80 b3 00 01 - poll for scanner not moving */ + scan_head_moving = SANE_TRUE; + while (scan_head_moving) + { + size = 4; + low_usb_bulk_write (devnum, command5_block, &size); + size = 0x1; + low_usb_bulk_read (devnum, &read_result, &size); + if ((read_result & 0xF) == 0x0) + { + scan_head_moving = SANE_FALSE; + } + /* F.O. Should be a timeout here so we don't hang if something breaks */ +#ifdef FAKE_USB + scan_head_moving = SANE_FALSE; +#endif + } + + /* Clear C6 */ + low_clr_c6 (devnum); + /* Stop the scanner */ + low_stop_mvmt (devnum); + + /*Set regs x2 */ + dev->shadow_regs[0x32] = 0x00; + low_write_all_regs (devnum, dev->shadow_regs); + dev->shadow_regs[0x32] = 0x40; + low_write_all_regs (devnum, dev->shadow_regs); + + /* Start Scan */ + rts88xx_commit (devnum, dev->shadow_regs[0x2c]); + + /* We start with 0 bytes remaining to be read */ + dev->bytes_remaining = 0; + /* and 0 bytes in the transfer buffer */ + dev->bytes_in_buffer = 0; + dev->bytes_read = 0; + + /* Poll the available byte count until not 0 */ + while (1) + { + size = 4; + low_usb_bulk_write (devnum, command4_block, &size); + size = 0x3; + low_usb_bulk_read (devnum, poll_result, &size); + if (! + (poll_result[0] == 0 && poll_result[1] == 0 && poll_result[2] == 0)) + { + /* if result != 00 00 00 we got data */ + + /* data_size should be used to set bytes_remaining */ + /* data_size is set from sane_get_parameters () */ + dev->bytes_remaining = dev->data_size; + /* Initialize the read buffer */ + read_buffer_init (dev, dev->params.bytes_per_line); + return SANE_STATUS_GOOD; + + } + size = 4; + /* I'm not sure why the Windows driver does this - probably a timeout? */ + low_usb_bulk_write (devnum, command5_block, &size); + size = 0x1; + low_usb_bulk_read (devnum, &read_result, &size); + if (read_result != 0x68) + { + dev->bytes_remaining = 0; + return SANE_STATUS_IO_ERROR; + } + } + + DBG (2, "sanei_lexmark_low_start_scan: end.\n"); + return SANE_STATUS_GOOD; +} + +long +sanei_lexmark_low_read_scan_data (SANE_Byte * data, SANE_Int size, + Lexmark_Device * dev) +{ + SANE_Bool isColourScan, isGrayScan; + static SANE_Byte command1_block[] = { 0x91, 0x00, 0xff, 0xc0 }; + size_t cmd_size, xfer_request; + long bytes_read; + SANE_Bool even_byte; + SANE_Status status; + int i, k, val; + + DBG (2, "sanei_lexmark_low_read_scan_data:\n"); + + /* colour mode */ + isGrayScan = SANE_FALSE; + if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_COLOR) == 0) + isColourScan = SANE_TRUE; + else + { + isColourScan = SANE_FALSE; + /* grayscale mode */ + if (strcmp (dev->val[OPT_MODE].s, SANE_VALUE_SCAN_MODE_GRAY) == 0) + isGrayScan = SANE_TRUE; + } + + /* Check if we have a transfer buffer. Create one and fill it if we don't */ + if (dev->transfer_buffer == NULL) + { + if (dev->bytes_remaining > 0) + { + if (dev->bytes_remaining > MAX_XFER_SIZE) + xfer_request = MAX_XFER_SIZE; + else + xfer_request = dev->bytes_remaining; + + command1_block[2] = (SANE_Byte) (xfer_request >> 8); + command1_block[3] = (SANE_Byte) (xfer_request & 0xFF); + + /* wait for data */ + status = low_poll_data (dev->devnum); + if (status != SANE_STATUS_GOOD) + { + DBG (1, + "sanei_lexmark_low_read_scan_data: time-out while waiting for data.\n"); + return status; + } + + /* Create buffer to hold the amount we will request */ + dev->transfer_buffer = (SANE_Byte *) malloc (MAX_XFER_SIZE); + if (dev->transfer_buffer == NULL) + return SANE_STATUS_NO_MEM; + + /* Fill it */ + /* Write: 91 00 (xfer_size) */ + cmd_size = 4; + low_usb_bulk_write (dev->devnum, command1_block, &cmd_size); + + /* Read: xfer_size bytes */ + cmd_size = xfer_request; + low_usb_bulk_read (dev->devnum, dev->transfer_buffer, &cmd_size); + + /* apply shading coefficients */ + k = dev->bytes_read % dev->read_buffer->linesize; + for (i = 0; i < (int) cmd_size; i++) + { + val = dev->transfer_buffer[i]; + val = (int) ((float) val * dev->shading_coeff[k] + 0.5); + if (val > 255) + val = 255; + dev->transfer_buffer[i] = val; + k++; + if ((size_t) k == dev->read_buffer->linesize) + k = 0; + } + + /* advance by the amount actually read from device */ + dev->bytes_read += cmd_size; + dev->bytes_remaining -= cmd_size; + dev->bytes_in_buffer = cmd_size; + dev->read_pointer = dev->transfer_buffer; + DBG (2, "sanei_lexmark_low_read_scan_data:\n"); + DBG (2, " Filled a buffer from the scanner\n"); + DBG (2, " bytes_remaining: %lu\n", (u_long) dev->bytes_remaining); + DBG (2, " bytes_in_buffer: %lu\n", (u_long) dev->bytes_in_buffer); + DBG (2, " read_pointer: %p\n", dev->read_pointer); + } + } + + DBG (5, "READ BUFFER INFO: \n"); + DBG (5, " write ptr: %p\n", dev->read_buffer->writeptr); + DBG (5, " read ptr: %p\n", dev->read_buffer->readptr); + DBG (5, " max write ptr: %p\n", dev->read_buffer->max_writeptr); + DBG (5, " buffer size: %lu\n", (u_long) dev->read_buffer->size); + DBG (5, " line size: %lu\n", (u_long) dev->read_buffer->linesize); + DBG (5, " empty: %d\n", dev->read_buffer->empty); + DBG (5, " line no: %d\n", dev->read_buffer->image_line_no); + + + /* If there is space in the read buffer, copy the transfer buffer over */ + if (read_buffer_bytes_available (dev->read_buffer) >= dev->bytes_in_buffer) + { + even_byte = SANE_TRUE; + while (dev->bytes_in_buffer) + { + + /* Colour Scan */ + if (isColourScan) + { + if (even_byte) + read_buffer_add_byte (dev->read_buffer, + dev->read_pointer + 1); + else + read_buffer_add_byte (dev->read_buffer, + dev->read_pointer - 1); + even_byte = !even_byte; + } + /* Gray Scan */ + else if (isGrayScan) + { + if (even_byte) + read_buffer_add_byte_gray (dev->read_buffer, + dev->read_pointer + 1); + else + read_buffer_add_byte_gray (dev->read_buffer, + dev->read_pointer - 1); + even_byte = !even_byte; + } + /* Lineart Scan */ + else + { + if (even_byte) + read_buffer_add_bit_lineart (dev->read_buffer, + dev->read_pointer + 1, + dev->threshold); + else + read_buffer_add_bit_lineart (dev->read_buffer, + dev->read_pointer - 1, + dev->threshold); + even_byte = !even_byte; + } + dev->read_pointer = dev->read_pointer + sizeof (SANE_Byte); + dev->bytes_in_buffer--; + } + /* free the transfer buffer */ + free (dev->transfer_buffer); + dev->transfer_buffer = NULL; + } + + DBG (5, "READ BUFFER INFO: \n"); + DBG (5, " write ptr: %p\n", dev->read_buffer->writeptr); + DBG (5, " read ptr: %p\n", dev->read_buffer->readptr); + DBG (5, " max write ptr: %p\n", dev->read_buffer->max_writeptr); + DBG (5, " buffer size: %lu\n", (u_long) dev->read_buffer->size); + DBG (5, " line size: %lu\n", (u_long) dev->read_buffer->linesize); + DBG (5, " empty: %d\n", dev->read_buffer->empty); + DBG (5, " line no: %d\n", dev->read_buffer->image_line_no); + + /* Read blocks out of read buffer */ + bytes_read = read_buffer_get_bytes (dev->read_buffer, data, size); + + DBG (2, "sanei_lexmark_low_read_scan_data:\n"); + DBG (2, " Copying lines from buffer to data\n"); + DBG (2, " bytes_remaining: %lu\n", (u_long) dev->bytes_remaining); + DBG (2, " bytes_in_buffer: %lu\n", (u_long) dev->bytes_in_buffer); + DBG (2, " read_pointer: %p\n", dev->read_buffer->readptr); + DBG (2, " bytes_read %lu\n", (u_long) bytes_read); + + /* if no more bytes to xfer and read buffer empty we're at the end */ + if ((dev->bytes_remaining == 0) && read_buffer_is_empty (dev->read_buffer)) + { + if (!dev->eof) + { + DBG (2, + "sanei_lexmark_low_read_scan_data: EOF- parking the scanner\n"); + dev->eof = SANE_TRUE; + low_rewind (dev, dev->shadow_regs); + } + else + { + DBG (2, "ERROR: Why are we trying to set eof more than once?\n"); + } + } + + DBG (2, "sanei_lexmark_low_read_scan_data: end.\n"); + return bytes_read; +} + +void +low_rewind (Lexmark_Device * dev, SANE_Byte * regs) +{ + SANE_Int new_location; + SANE_Int location; + SANE_Int scale; + + DBG (2, "low_rewind: \n"); + + /* We rewind at 1200dpi resolution. We rely on content of shadow registers + to compute the number of lines at 1200 dpi to go back */ + + /* first move to start of scanning area */ + scale = 600 / dev->val[OPT_RESOLUTION].w; + new_location = ((dev->val[OPT_BR_Y].w / scale) * scale) * 2; + + /* then add distance to go to the "origin dot" */ + if (rts88xx_is_color (regs)) + new_location += 400; + else + new_location += 420; + + if (dev->model.sensor_type == X74_SENSOR) + new_location += 150; + + + location = new_location - 1; + DBG (2, "low_rewind: %d=>new_location=%d\n", dev->val[OPT_BR_Y].w, + new_location); + + /* stops any pending scan */ + low_clr_c6 (dev->devnum); + low_cancel (dev->devnum); + + /* set regs for rewind */ + regs[0x2f] = 0xa1; + regs[0x32] = 0x00; + regs[0x39] = 0x00; + + /* all other regs are always the same. these ones change with parameters */ + /* the following 4 regs are the location 61,60 and the location+1 63,62 */ + + regs[0x60] = LOBYTE (location); + regs[0x61] = HIBYTE (location); + regs[0x62] = LOBYTE (new_location); + regs[0x63] = HIBYTE (new_location); + + switch (dev->model.motor_type) + { + case X74_MOTOR: + regs[0xc3] = 0x81; + regs[0xc6] = 0x03; + regs[0xc9] = 0x39; + regs[0xe0] = 0x81; + regs[0xe1] = 0x16; + regs[0xe2] = 0xe1; + regs[0xe3] = 0x04; + regs[0xe4] = 0xe7; + regs[0xe5] = 0x14; + regs[0xe6] = 0x64; + regs[0xe7] = 0xd5; + regs[0xe8] = 0x08; + regs[0xe9] = 0x32; + regs[0xea] = 0xed; + regs[0xeb] = 0x04; + regs[0xec] = 0x0c; + regs[0xef] = 0x08; + break; + case X1100_MOTOR: + case A920_MOTOR: + /* set regs for rewind */ + regs[0x79] = 0x40; + regs[0xb2] = 0x04; + regs[0xc3] = 0x81; + regs[0xc6] = 0x01; + regs[0xc9] = 0x3b; + regs[0xe0] = 0x2b; + regs[0xe1] = 0x17; + regs[0xe2] = 0xe7; + regs[0xe3] = 0x03; + regs[0xe6] = 0xdc; + regs[0xe7] = 0xb3; + regs[0xe8] = 0x07; + regs[0xe9] = 0x1b; + regs[0xea] = 0x00; + regs[0xeb] = 0x00; + regs[0xec] = 0x07; + regs[0xef] = 0x03; + break; + } + + + /* starts scan */ + low_start_scan (dev->devnum, regs); + DBG (2, "low_rewind: end.\n"); +} + + +SANE_Status +read_buffer_init (Lexmark_Device * dev, int bytesperline) +{ + size_t no_lines_in_buffer; + + DBG (2, "read_buffer_init: Start\n"); + + dev->read_buffer = (Read_Buffer *) malloc (sizeof (Read_Buffer)); + if (dev->read_buffer == NULL) + return SANE_STATUS_NO_MEM; + dev->read_buffer->linesize = bytesperline; + dev->read_buffer->gray_offset = 0; + dev->read_buffer->max_gray_offset = bytesperline - 1; + dev->read_buffer->region = RED; + dev->read_buffer->red_offset = 0; + dev->read_buffer->green_offset = 1; + dev->read_buffer->blue_offset = 2; + dev->read_buffer->max_red_offset = bytesperline - 3; + dev->read_buffer->max_green_offset = bytesperline - 2; + dev->read_buffer->max_blue_offset = bytesperline - 1; + no_lines_in_buffer = 3 * MAX_XFER_SIZE / bytesperline; + dev->read_buffer->size = bytesperline * no_lines_in_buffer; + dev->read_buffer->data = (SANE_Byte *) malloc (dev->read_buffer->size); + if (dev->read_buffer->data == NULL) + return SANE_STATUS_NO_MEM; + dev->read_buffer->readptr = dev->read_buffer->data; + dev->read_buffer->writeptr = dev->read_buffer->data; + dev->read_buffer->max_writeptr = dev->read_buffer->data + + (no_lines_in_buffer - 1) * bytesperline; + dev->read_buffer->empty = SANE_TRUE; + dev->read_buffer->image_line_no = 0; + dev->read_buffer->bit_counter = 0; + dev->read_buffer->max_lineart_offset = dev->params.pixels_per_line - 1; + return SANE_STATUS_GOOD; +} + +SANE_Status +read_buffer_free (Read_Buffer * read_buffer) +{ + DBG (2, "read_buffer_free:\n"); + if (read_buffer) + { + free (read_buffer->data); + free (read_buffer); + read_buffer = NULL; + } + return SANE_STATUS_GOOD; +} + +size_t +read_buffer_bytes_available (Read_Buffer * rb) +{ + + DBG (2, "read_buffer_bytes_available:\n"); + + if (rb->empty) + return rb->size; + else if ((size_t) abs (rb->writeptr - rb->readptr) < rb->linesize) + return 0; /* ptrs are less than one line apart */ + else if (rb->writeptr < rb->readptr) + return (rb->readptr - rb->writeptr - rb->linesize); + else + return (rb->size + rb->readptr - rb->writeptr - rb->linesize); +} + +SANE_Status +read_buffer_add_byte (Read_Buffer * rb, SANE_Byte * byte_pointer) +{ + + /* DBG(2, "read_buffer_add_byte:\n"); */ + /* F.O. Need to fix the endian byte ordering here */ + + switch (rb->region) + { + case RED: + *(rb->writeptr + rb->red_offset) = *byte_pointer; + if (rb->red_offset == rb->max_red_offset) + { + rb->red_offset = 0; + rb->region = GREEN; + } + else + rb->red_offset = rb->red_offset + (3 * sizeof (SANE_Byte)); + return SANE_STATUS_GOOD; + case GREEN: + *(rb->writeptr + rb->green_offset) = *byte_pointer; + if (rb->green_offset == rb->max_green_offset) + { + rb->green_offset = 1; + rb->region = BLUE; + } + else + rb->green_offset = rb->green_offset + (3 * sizeof (SANE_Byte)); + return SANE_STATUS_GOOD; + case BLUE: + *(rb->writeptr + rb->blue_offset) = *byte_pointer; + if (rb->blue_offset == rb->max_blue_offset) + { + rb->image_line_no++; + /* finished a line. read_buffer no longer empty */ + rb->empty = SANE_FALSE; + rb->blue_offset = 2; + rb->region = RED; + if (rb->writeptr == rb->max_writeptr) + rb->writeptr = rb->data; /* back to beginning of buffer */ + else + rb->writeptr = rb->writeptr + rb->linesize; /* next line */ + } + else + rb->blue_offset = rb->blue_offset + (3 * sizeof (SANE_Byte)); + return SANE_STATUS_GOOD; + } + return SANE_STATUS_GOOD; +} + +SANE_Status +read_buffer_add_byte_gray (Read_Buffer * rb, SANE_Byte * byte_pointer) +{ + + /* DBG(2, "read_buffer_add_byte_gray:\n"); */ + + *(rb->writeptr + rb->gray_offset) = *byte_pointer; + + if (rb->gray_offset == rb->max_gray_offset) + { + rb->image_line_no++; + /* finished a line. read_buffer no longer empty */ + rb->empty = SANE_FALSE; + rb->gray_offset = 0; + + if (rb->writeptr == rb->max_writeptr) + rb->writeptr = rb->data; /* back to beginning of buffer */ + else + rb->writeptr = rb->writeptr + rb->linesize; /* next line */ + } + else + rb->gray_offset = rb->gray_offset + (1 * sizeof (SANE_Byte)); + return SANE_STATUS_GOOD; +} + +SANE_Status +read_buffer_add_bit_lineart (Read_Buffer * rb, SANE_Byte * byte_pointer, + SANE_Byte threshold) +{ + SANE_Byte tmpByte; + SANE_Byte *currentBytePtr; + SANE_Int bitIndex; + + /* DBG(2, "read_buffer_add_bit_lineart:\n"); */ + + /* threshold = 0x80; */ + tmpByte = 0; + /* Create a bit by comparing incoming byte to threshold */ + if (*byte_pointer <= threshold) + { + tmpByte = 128; + } + + /* Calculate the bit index in the current byte */ + bitIndex = rb->bit_counter % 8; + /* Move the bit to its correct position in the temporary byte */ + tmpByte = tmpByte >> bitIndex; + /* Get the pointer to the current byte */ + currentBytePtr = rb->writeptr + rb->gray_offset; + + /* If this is the first write to this byte, clear the byte */ + if (bitIndex == 0) + *currentBytePtr = 0; + /* Set the value of the bit in the current byte */ + *currentBytePtr = *currentBytePtr | tmpByte; + + /* last bit in the line? */ + if (rb->bit_counter == rb->max_lineart_offset) + { + /* Check if we're at the last byte of the line - error if not */ + if (rb->gray_offset != rb->max_gray_offset) + { + DBG (5, "read_buffer_add_bit_lineart:\n"); + DBG (5, " Last bit of line is not last byte.\n"); + DBG (5, " Bit Index: %d, Byte Index: %d. \n", rb->bit_counter, + rb->max_gray_offset); + return SANE_STATUS_INVAL; + } + rb->image_line_no++; + /* line finished read_buffer no longer empty */ + rb->empty = SANE_FALSE; + rb->gray_offset = 0; + /* are we at the last line in the read buffer ? */ + if (rb->writeptr == rb->max_writeptr) + rb->writeptr = rb->data; /* back to beginning of buffer */ + else + rb->writeptr = rb->writeptr + rb->linesize; /* next line */ + /* clear the bit counter */ + rb->bit_counter = 0; + } + /* last bit in the byte? */ + else if (bitIndex == 7) + { + /* Not at the end of the line, but byte done. Increment byte offset */ + rb->gray_offset = rb->gray_offset + (1 * sizeof (SANE_Byte)); + /* increment bit counter */ + rb->bit_counter++; + } + else + { + /* else increment bit counter */ + rb->bit_counter++; + } + + return SANE_STATUS_GOOD; +} + + +size_t +read_buffer_get_bytes (Read_Buffer * rb, SANE_Byte * buffer, size_t rqst_size) +{ + /* Read_Buffer *rb; */ + size_t available_bytes; + + /* rb = read_buffer; */ + if (rb->empty) + return 0; + else if (rb->writeptr > rb->readptr) + { + available_bytes = rb->writeptr - rb->readptr; + if (available_bytes <= rqst_size) + { + /* We can read from the read pointer up to the write pointer */ + memcpy (buffer, rb->readptr, available_bytes); + rb->readptr = rb->writeptr; + rb->empty = SANE_TRUE; + return available_bytes; + } + else + { + /* We can read from the full request size */ + memcpy (buffer, rb->readptr, rqst_size); + rb->readptr = rb->readptr + rqst_size; + return rqst_size; + } + } + else + { + /* The read pointer is ahead of the write pointer. Its wrapped around. */ + /* We can read to the end of the buffer and make a recursive call to */ + /* read any available lines at the beginning of the buffer */ + available_bytes = rb->data + rb->size - rb->readptr; + if (available_bytes <= rqst_size) + { + /* We can read from the read pointer up to the end of the buffer */ + memcpy (buffer, rb->readptr, available_bytes); + rb->readptr = rb->data; + if (rb->writeptr == rb->readptr) + rb->empty = SANE_TRUE; + return available_bytes + + read_buffer_get_bytes (rb, buffer + available_bytes, + rqst_size - available_bytes); + } + else + { + /* We can read from the full request size */ + memcpy (buffer, rb->readptr, rqst_size); + rb->readptr = rb->readptr + rqst_size; + return rqst_size; + } + } +} + +SANE_Bool +read_buffer_is_empty (Read_Buffer * read_buffer) +{ + return read_buffer->empty; +} + +/* + * average a width*height rgb/monochrome area + * return values in given pointers + */ +static int +average_area (SANE_Byte * regs, SANE_Byte * data, int width, int height, + int *ra, int *ga, int *ba) +{ + int x, y; + int global = 0; + int rc, gc, bc; + + *ra = 0; + *ga = 0; + *ba = 0; + rc = 0; + gc = 0; + bc = 0; + if (rts88xx_is_color (regs)) + { + for (x = 0; x < width; x++) + for (y = 0; y < height; y++) + { + rc += data[3 * width * y + x]; + gc += data[3 * width * y + width + x]; + bc += data[3 * width * y + 2 * width + x]; + } + global = (rc + gc + bc) / (3 * width * height); + *ra = rc / (width * height); + *ga = gc / (width * height); + *ba = bc / (width * height); + } + else + { + for (x = 0; x < width; x++) + for (y = 0; y < height; y++) + { + gc += data[width * y + x]; + } + global = gc / (width * height); + *ga = gc / (width * height); + } + DBG (7, "average_area: global=%d, red=%d, green=%d, blue=%d\n", global, *ra, + *ga, *ba); + return global; +} + +/** + * we scan a dark area with gain minimum to detect offset + */ +SANE_Status +sanei_lexmark_low_offset_calibration (Lexmark_Device * dev) +{ + SANE_Byte regs[255]; /* we have our own copy of shadow registers */ + SANE_Status status = SANE_STATUS_GOOD; + int i, lines = 8, yoffset = 2; + int pixels; + int failed = 0; + /* offsets */ + int ro = 0, go = 0, bo = 0; + /* averages */ + int ra, ga, ba, average; + SANE_Byte *data = NULL; + SANE_Byte top[OFFSET_RANGES] = { 0, 0x7f, 0x9f, 0xbf, 0xff }; +#ifdef DEEP_DEBUG + char title[20]; +#endif + + DBG (2, "sanei_lexmark_low_offset_calibration: start\n"); + /* copy registers */ + for (i = 0; i < 255; i++) + regs[i] = dev->shadow_regs[i]; + + /* we clear movement bit */ + regs[0xc3] = regs[0xc3] & 0x7f; + + pixels = + (dev->sensor->offset_endx - dev->sensor->offset_startx) / regs[0x7a]; + + /* there are 4 ranges of offset: + 00-7F : almost no offset + 80-9F : high noise + A0-BF : high noise + C0-FF : high noise + we start with the highest one and decrease until + overall offset is ok + First loop may have such an high offset that scanned data overflow + and gives a low average. So we allways skip its results + */ + + /* minimal gains */ + DBG (3, + "sanei_lexmark_low_offset_calibration: setting gains to (1,1,1).\n"); + rts88xx_set_gain (regs, 1, 1, 1); + + i = OFFSET_RANGES; + average = 255; + + /* loop on ranges until one fits. Then adjust offset, first loop is + * always done. TODO detect overflow by 'noise looking' data pattern */ + while (((i > 0) && (average > dev->sensor->offset_threshold)) + || (i == OFFSET_RANGES)) + { + /* next range */ + i--; + + /* sets to top of range */ + ro = top[i]; + go = top[i]; + bo = top[i]; + rts88xx_set_offset (regs, ro, ro, ro); + DBG (3, + "sanei_lexmark_low_offset_calibration: setting offsets to (%d,%d,%d).\n", + ro, ro, ro); + + status = + low_simple_scan (dev, regs, dev->sensor->offset_startx, pixels, + yoffset, lines, &data); + if (status != SANE_STATUS_GOOD) + { + DBG (1, + "sanei_lexmark_low_offset_calibration: low_simple_scan failed!\n"); + if (data != NULL) + free (data); + return status; + } +#ifdef DEEP_DEBUG + sprintf (title, "offset%02x.pnm", ro); + write_pnm_file (title, pixels, lines, rts88xx_is_color (regs), data); +#endif + average = average_area (regs, data, pixels, lines, &ra, &ga, &ba); + free (data); + } + if (i == 0) + { + DBG (2, "sanei_lexmark_low_offset_calibration: failed !\n"); + failed = 1; + } + + /* increase gain and scan again */ + /* increase gain for fine offset tuning */ + rts88xx_set_gain (regs, 6, 6, 6); + status = + low_simple_scan (dev, regs, dev->sensor->offset_startx, pixels, yoffset, + lines, &data); + if (status != SANE_STATUS_GOOD) + { + DBG (1, + "sanei_lexmark_low_offset_calibration: low_simple_scan failed!\n"); + if (data != NULL) + free (data); + return status; + } + average_area (regs, data, pixels, lines, &ra, &ga, &ba); +#ifdef DEEP_DEBUG + write_pnm_file ("offset-final.pnm", pixels, lines, rts88xx_is_color (regs), + data); +#endif + + /* this "law" is a guess, may (should?) be changed ... */ + if (!failed) + { + if (ro > ra) + dev->offset.red = ro - ra; + if (go > ga) + { + dev->offset.green = go - ga; + dev->offset.gray = go - ga; + } + if (bo > ba) + dev->offset.blue = bo - ba; + } + else + { + dev->offset.red = dev->sensor->offset_fallback; + dev->offset.green = dev->sensor->offset_fallback; + dev->offset.blue = dev->sensor->offset_fallback; + } + DBG (7, + "sanei_lexmark_low_offset_calibration: offset=(0x%02x,0x%02x,0x%02x).\n", + dev->offset.red, dev->offset.green, dev->offset.blue); + + DBG (2, "sanei_lexmark_low_offset_calibration: end.\n"); + free (data); + return status; +} + +/* + * we scan a white area until average is good enough + * level is good enough when it maximize the range value of output: + * ie max-min is maximum + */ +SANE_Status +sanei_lexmark_low_gain_calibration (Lexmark_Device * dev) +{ + SANE_Byte regs[255]; /* we have our own copy of shadow registers */ + SANE_Status status = SANE_STATUS_GOOD; + int i, lines = 4, yoffset = 1; + int sx, ex; + int pixels; + /* averages */ + int ra, ga, ba; + SANE_Byte *data = NULL; + int red, green, blue; +#ifdef DEEP_DEBUG + char title[20]; +#endif + + DBG (2, "sanei_lexmark_low_gain_calibration: start\n"); + /* copy registers */ + for (i = 0; i < 255; i++) + regs[i] = dev->shadow_regs[i]; + + /* we clear movement bit */ + regs[0xc3] = regs[0xc3] & 0x7f; + sx = regs[0x67] * 256 + regs[0x66]; + ex = regs[0x6d] * 256 + regs[0x6c]; + pixels = (ex - sx) / regs[0x7a]; + + + /* set up inital gains */ + red = 6; + green = 6; + blue = 6; + rts88xx_set_gain (regs, red, green, blue); + + /* init loop */ + i = 0; + ra = 0; + ba = 0; + ga = 0; + + status = low_cancel (dev->devnum); + if (status != SANE_STATUS_GOOD) + return status; + + /* we do a simple scan all 3 averages give the choosen level */ + while (((rts88xx_is_color (regs) + && ((ra < dev->sensor->red_gain_target) + || (ga < dev->sensor->green_gain_target) + || (ba < dev->sensor->blue_gain_target))) + || (!rts88xx_is_color (regs) + && (ga < dev->sensor->gray_gain_target))) && (i < 25)) + { + status = low_simple_scan (dev, regs, sx, pixels, yoffset, lines, &data); + if (status != SANE_STATUS_GOOD) + { + DBG (1, + "sanei_lexmark_low_gain_calibration: low_simple_scan failed!\n"); + if (data != NULL) + free (data); + return status; + } +#ifdef DEEP_DEBUG + sprintf (title, "gain%02d.pnm", i); + write_pnm_file (title, pixels, lines, rts88xx_is_color (regs), data); +#endif + average_area (regs, data, pixels, lines, &ra, &ga, &ba); + free (data); + if (ra < dev->sensor->red_gain_target) + red++; + if (ga < dev->sensor->green_gain_target + || (dev->sensor->gray_gain_target && !rts88xx_is_color (regs))) + green++; + if (ba < dev->sensor->blue_gain_target) + blue++; + rts88xx_set_gain (regs, red, green, blue); + i++; + } + dev->gain.red = red; + dev->gain.green = green; + dev->gain.blue = blue; + dev->gain.gray = green; + DBG (7, + "sanei_lexmark_low_gain_calibration: gain=(0x%02x,0x%02x,0x%02x).\n", + dev->gain.red, dev->gain.green, dev->gain.blue); + DBG (2, "sanei_lexmark_low_gain_calibration: end.\n"); + return status; +} + +/** + * there is no hardware shading correction. So we have to do it in software. + * We do it by scanning a pure white area which is before scanning area. Then + * we compute per pixel coefficient to move the scanned value to the target + * value. These coefficients are used later to correct scanned data. + * The scan is done with all the final scan settings but the heigth and vertical + * start position. + */ +SANE_Status +sanei_lexmark_low_shading_calibration (Lexmark_Device * dev) +{ + SANE_Byte regs[255]; /* we have our own copy of shadow registers */ + int i, j, pixels, bpl; + int sx, ex; + SANE_Byte *data = NULL; + SANE_Status status; + /* enough 75 dpi lines to "go off" home position dot, + and include shading area */ + int lines = 4 + 4; + int lineoffset = 1; + int linetotal = lines + lineoffset; + int yoffset; + int x, y; + float rtarget, btarget, gtarget; + + DBG (2, "sanei_lexmark_low_shading_calibration: start\n"); + /* copy registers */ + for (i = 0; i < 255; i++) + regs[i] = dev->shadow_regs[i]; + + /* allocate memory for scan */ + sx = regs[0x67] * 256 + regs[0x66]; + ex = regs[0x6d] * 256 + regs[0x6c]; + + + DBG (7, "startx=%d, endx=%d, coef=%d, r2f=0x%02x\n", + sx, ex, regs[0x7a], regs[0x2f]); + + pixels = (ex - sx) / regs[0x7a]; + if (rts88xx_is_color (regs)) + bpl = 3 * pixels; + else + bpl = pixels; + + /* adjust the target area to the scanning resolution */ + lines = (8 * lines) / regs[0x7a]; + lineoffset = (8 * lineoffset) / regs[0x7a]; + linetotal = (8 * linetotal) / regs[0x7a]; + + data = (SANE_Byte *) malloc (bpl * lines); + DBG (7, "pixels=%d, lines=%d, size=%d\n", pixels, lines, bpl * lines); + if (data == NULL) + { + DBG (2, + "sanei_lexmark_low_shading_calibration: failed to allocate %d bytes !\n", + bpl * lines); + return SANE_STATUS_NO_MEM; + } + if (dev->shading_coeff != NULL) + free (dev->shading_coeff); + dev->shading_coeff = (float *) malloc (bpl * sizeof (float)); + if (dev->shading_coeff == NULL) + { + DBG (2, + "sanei_lexmark_low_shading_calibration: failed to allocate %d floats !\n", + bpl); + free (data); + return SANE_STATUS_NO_MEM; + } + + /* we set movement bit this time */ + regs[0xc3] = regs[0xc3] | 0x80; + + /* execute scan */ + status = low_simple_scan (dev, regs, sx, pixels, lineoffset, lines, &data); + if (status != SANE_STATUS_GOOD) + { + DBG (1, + "sanei_lexmark_low_shading_calibration: low_simple_scan failed!\n"); + if (data != NULL) + free (data); + return status; + } + + yoffset = -1; + /* the very first lines of the scan may include the dark dot used + * locate park position. We find the first line free of it in the scan. + * We can't use is_home_line since it modifies data. + */ + for (y = 0; (y < lines) && (yoffset == y - 1); y++) + { + if (rts88xx_is_color (regs)) + { + for (x = 0; x < 3 * pixels; x++) + { + if (data[x + y * 3 * pixels] < 30) + yoffset = y; + } + } + else + { + for (x = 0; x < pixels; x++) + { + if (data[x + y * pixels] < 30) + yoffset = y; + } + } + } + /* make sure we are really out of the dot */ + yoffset++; + + /* yoffset is index of last dot line, go to first white line */ + if (yoffset >= lines - 1) + { + DBG (7, + "sanei_lexmark_low_shading_calibration: failed to detect yoffset.\n"); + /* fail safe fallback, picture will be altered at dot position, + but scanner is safe */ + yoffset = lines - 2; + } + else + yoffset++; + DBG (7, "sanei_lexmark_low_shading_calibration: yoffset=%d.\n", yoffset); + +#ifdef DEEP_DEBUG + write_pnm_file ("shading.pnm", pixels, lines, rts88xx_is_color (regs), + data); +#endif + + /* computes coefficients */ + /* there are 8 lines usable for shading calibration at 150 dpi, between + bottom of "home position" dot and the start of the scanner's window + assembly, we only use 7 of them */ + if (yoffset + (8 * 4) / regs[0x7a] < lines) + lines = yoffset + (8 * 4) / regs[0x7a]; + rtarget = dev->sensor->red_shading_target; + gtarget = dev->sensor->green_shading_target; + btarget = dev->sensor->blue_shading_target; + for (i = 0; i < pixels; i++) + { + /* we computes the coefficient needed to move the scanned value to + the target value */ + if (rts88xx_is_color (dev->shadow_regs)) + { + /* RED */ + dev->shading_coeff[i] = 0; + for (j = yoffset; j < lines; j++) + dev->shading_coeff[i] += data[i + j * bpl]; + dev->shading_coeff[i] = + (rtarget / (dev->shading_coeff[i] / (lines - yoffset))); + + /* GREEN */ + dev->shading_coeff[i + pixels] = 0; + for (j = yoffset; j < lines; j++) + dev->shading_coeff[i + pixels] += data[i + j * bpl + pixels]; + dev->shading_coeff[i + pixels] = + ((gtarget / dev->shading_coeff[i + pixels]) * (lines - yoffset)); + + /* BLUE */ + dev->shading_coeff[i + 2 * pixels] = 0; + for (j = yoffset; j < lines; j++) + dev->shading_coeff[i + 2 * pixels] += + data[i + j * bpl + 2 * pixels]; + dev->shading_coeff[i + 2 * pixels] = + ((btarget / dev->shading_coeff[i + 2 * pixels]) * + (lines - yoffset)); + } + else + { + dev->shading_coeff[i] = 0; + for (j = yoffset; j < lines; j++) + { + dev->shading_coeff[i] += data[i + j * bpl]; + } + dev->shading_coeff[i] = + (rtarget / dev->shading_coeff[i]) * (lines - yoffset); + } + } + free(data); + + /* do the scan backward to go back to start position */ + regs[0xc6] &= 0xF7; + lines = (8 * 8) / regs[0x7a]; + /* it shoud use linetotal to account for the lineoffset */ + if (dev->model.sensor_type == X74_SENSOR) + lines = linetotal; + + /* execute scan */ + status = low_simple_scan (dev, regs, sx, pixels, 1, lines, &data); + if (status != SANE_STATUS_GOOD) + { + DBG (1, + "sanei_lexmark_low_shading_calibration: low_simple_scan failed!\n"); + if(data!=NULL) + free(data); + return status; + } + +#ifdef DEEP_DEBUG + write_pnm_file ("shading_bwd.pnm", pixels, lines, rts88xx_is_color (regs), + data); +#endif + free (data); + + DBG (2, "sanei_lexmark_low_shading_calibration: end.\n"); + return status; +} + + +SANE_Status +sanei_lexmark_low_calibration (Lexmark_Device * dev) +{ + SANE_Status status; + + DBG (2, "sanei_lexmark_low_calibration: start.\n"); + status = sanei_lexmark_low_offset_calibration (dev); + if (status != SANE_STATUS_GOOD) + return status; + + /* we put the offset just computed in scanning regs */ + if (rts88xx_is_color (dev->shadow_regs)) + { + rts88xx_set_offset (dev->shadow_regs, + dev->offset.red, + dev->offset.green, dev->offset.blue); + } + else + { + rts88xx_set_offset (dev->shadow_regs, + dev->offset.gray, + dev->offset.gray, dev->offset.gray); + } + + /* if manual gain settings, no gain calibration */ + if (dev->val[OPT_MANUAL_GAIN].w == SANE_TRUE) + { + if (rts88xx_is_color (dev->shadow_regs)) + { + dev->gain.red = dev->val[OPT_RED_GAIN].w; + dev->gain.green = dev->val[OPT_GREEN_GAIN].w; + dev->gain.blue = dev->val[OPT_BLUE_GAIN].w; + } + else + dev->gain.gray = dev->val[OPT_GRAY_GAIN].w; + } + else + { + status = sanei_lexmark_low_gain_calibration (dev); + if (status != SANE_STATUS_GOOD) + return status; + } + + /* put the calibrated or manual settings before shading calibration + which must be done with final setting values */ + if (rts88xx_is_color (dev->shadow_regs)) + { + rts88xx_set_gain (dev->shadow_regs, dev->gain.red, dev->gain.green, + dev->gain.blue); + } + else + { + rts88xx_set_gain (dev->shadow_regs, dev->gain.gray, dev->gain.gray, + dev->gain.gray); + } + + status = sanei_lexmark_low_shading_calibration (dev); + + if (status != SANE_STATUS_GOOD) + return status; + + DBG (2, "sanei_lexmark_low_calibration: end.\n"); + return SANE_STATUS_GOOD; +} + +/* assign sensor data */ +static SANE_Status +sanei_lexmark_low_assign_sensor (Lexmark_Device * dev) +{ + int dn; + + /* init sensor data */ + dn = 0; + while (sensor_list[dn].id != 0 + && sensor_list[dn].id != dev->model.sensor_type) + dn++; + if (sensor_list[dn].id == 0) + { + DBG (1, + "sanei_lexmark_low_assign_sensor: unknown sensor %d\n", + dev->model.sensor_type); + return SANE_STATUS_UNSUPPORTED; + } + dev->sensor = &(sensor_list[dn]); + DBG (1, "sanei_lexmark_low_assign_sensor: assigned sensor number %d\n", + dev->model.sensor_type); + return SANE_STATUS_GOOD; +} + +/* assign model description, based on USB id, and register content when + * available */ +SANE_Status +sanei_lexmark_low_assign_model (Lexmark_Device * dev, + SANE_String_Const devname, SANE_Int vendor, + SANE_Int product, SANE_Byte mainboard) +{ + int dn; + SANE_Bool found = SANE_FALSE; + + DBG_INIT (); + + DBG (2, "sanei_lexmark_low_assign_model: start\n"); + DBG (3, + "sanei_lexmark_low_assign_model: assigning %04x:%04x, variant %d\n", + vendor, product, mainboard); + + dn = 0; + /* walk the list of known devices */ + while (!found && model_list[dn].vendor_id != 0) + { + /* no mainboard id given (at attach time) */ + if (mainboard == 0 + && vendor == model_list[dn].vendor_id + && product == model_list[dn].product_id) + found = SANE_TRUE; + /* mainboard given (init time) */ + if (mainboard != 0 + && mainboard == model_list[dn].mainboard_id + && vendor == model_list[dn].vendor_id + && product == model_list[dn].product_id) + found = SANE_TRUE; + + if (!found) + dn++; + } + + /* we hit the end of list, so we don't know about the current model */ + if (!found) + { + DBG (1, + "sanei_lexmark_low_assign_model: unknown device 0x%04x:0x%04x\n", + vendor, product); + return SANE_STATUS_UNSUPPORTED; + } + + dev->sane.name = strdup (devname); + dev->sane.vendor = model_list[dn].vendor; + dev->sane.model = model_list[dn].model; + dev->model = model_list[dn]; + dev->sane.type = "flatbed scanner"; + + DBG (3, "sanei_lexmark_low_assign_model: assigned %s\n", dev->model.model); + + /* init sensor data */ + DBG (2, "sanei_lexmark_low_assign_model: end.\n"); + return sanei_lexmark_low_assign_sensor (dev); +} |