summaryrefslogtreecommitdiff
path: root/backend/umax1220u-common.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
commit6e9c41a892ed0e0da326e0278b3221ce3f5713b8 (patch)
tree2e301d871bbeeb44aa57ff9cc070fcf3be484487 /backend/umax1220u-common.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/umax1220u-common.c')
-rw-r--r--backend/umax1220u-common.c2386
1 files changed, 2386 insertions, 0 deletions
diff --git a/backend/umax1220u-common.c b/backend/umax1220u-common.c
new file mode 100644
index 0000000..43a4a6f
--- /dev/null
+++ b/backend/umax1220u-common.c
@@ -0,0 +1,2386 @@
+/* sane - Scanner Access Now Easy.
+
+ Copyright (C) 1999 Paul Mackerras
+ Copyright (C) 2000 Adrian Perez Jorge
+ Copyright (C) 2001 Frank Zago
+ Copyright (C) 2001 Marcio Teixeira
+ Parts copyright (C) 2006 Patrick Lessard
+
+ 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.
+
+ Defines a driver and API for accessing the UMAX Astra 1220U
+ USB scanner. Based on the original command line tool by Paul
+ Mackerras.
+
+ The UMAX Astra 1220U scanner uses the PowerVision PV8630
+ Parallel Port to USB bridge. This chip is also used
+ by the HP4200C flatbed scanner. Adrian Perez Jorge wrote
+ a nice interface file for that chip and Frank Zago adapted
+ it to use the sanei_usb interface. Thanks, guys, for making
+ my life easier! :)
+
+ */
+
+
+#include <string.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <sys/ioctl.h>
+#include <math.h>
+
+/*
+ * The backend performs test scans in order to calibrate
+ * the CCD and to find the zero location. If you would like
+ * to look at those scans, define DEBUG_CALIBRATION to have
+ * the backend save "find_zero.pgm" and "calibration.pgm" to
+ * disk.
+ */
+/* #define DEBUG_CALIBRATION */
+
+/*
+ * Define DEBUG_BOUNDS to insert paranoid array bounds
+ * overrun detection into the code.
+ */
+/* #define DEBUG_BOUNDS */
+
+/* These values are empirically determined and are given
+ * in 1/600 inch units. If UMAX_MAX_HEIGHT is too large,
+ * the scanner may grind its gears. I assume there is a
+ * physical limit to UMAX_MAX_WIDTH as well (based on the
+ * sensor size) but I do not know what it is. The current
+ * value can be increased beyond what it is now, but you
+ * gain nothing in usuable scan area (you only scan more
+ * of the underside of the scanner's plastic lid).
+ */
+
+
+#define UMAX_MAX_WIDTH 5400
+#define UMAX_MAX_HEIGHT 7040
+
+/* Buffer size. Specifies the size of the buffer that is
+ * used to copy data from the scanner. The old command
+ * line driver had this set at 0x80000 which is likely
+ * the largest possible chunck of data that can be.
+ * at once. This is probably most efficient, but using
+ * a lower value for the SANE driver makes the driver
+ * more responsive to interaction.
+ */
+#define BUFFER_SIZE 0x80000
+
+/* Constants that can be used with set_lamp_state to
+ * control the state of the scanner's lamp
+ */
+typedef enum
+{
+ UMAX_LAMP_OFF = 0,
+ UMAX_LAMP_ON = 1
+}
+UMAX_Lamp_State;
+
+/* Constants that can be used with move to control
+ * the rate of scanner head movement
+ */
+typedef enum
+{
+ UMAX_NOT_FINE = 0,
+ UMAX_FINE = 1
+}
+UMAX_Speed;
+
+/* If anyone knows some descriptive names for these,
+ * please update
+ */
+typedef enum
+{
+ CMD_0 = 0x00,
+ CMD_1 = 0x01,
+ CMD_2 = 0x02,
+ CMD_4 = 0x04,
+ CMD_8 = 0x08,
+ CMD_40 = 0x40,
+ CMD_WRITE = 0x80,
+ CMD_READ = 0xc0
+}
+UMAX_Cmd;
+
+/* Product IDs for Astra scanners
+ */
+typedef enum
+{
+ ASTRA_1220U = 0x0010,
+ ASTRA_2000U = 0x0030,
+ ASTRA_2100U = 0x0130
+}
+UMAX_Model;
+
+/* The bytes UMAX_SYNC1 and UMAX_SYNC2 serve as a
+ * synchronization signal. Unintentional sync bytes
+ * in the data stream are escaped with UMAX_ESCAPE
+ * character
+ */
+
+#define UMAX_SYNC1 0x55
+#define UMAX_SYNC2 0xaa
+#define UMAX_ESCAPE 0x1b
+
+/* Status bits. These bits are active low.
+ * In umax_pp, UMAX_REVERSE_BIT is called
+ * MOTOR_BIT.
+ */
+
+#define UMAX_FORWARD_BIT 0x40
+#define UMAX_ERROR_BIT 0x20
+#define UMAX_MOTOR_OFF_BIT 0x08
+
+#define UMAX_OK 0x48 /* Used to be 0xC8 */
+#define UMAX_OK_WITH_MOTOR 0x40 /* Used to be 0xD0 */
+
+#define UMAX_STATUS_MASK 0x68
+
+/* This byte is used as a placeholder for bytes that are parameterized
+ * in the opcode strings */
+
+#define XXXX 0x00
+
+/* This macro is used to check the return code of
+ * functions
+ */
+#define CHK(A) {if( (res = A) != SANE_STATUS_GOOD ) { \
+ DBG( 1, "Failure on line of %s: %d\n", __FILE__, \
+ __LINE__ ); return A; }}
+
+/* Macros that are used for array overrun detection
+ * (when DEBUG_BOUNDS is defined)
+ */
+#ifdef DEBUG_BOUNDS
+#define PAD 10
+#define PAD_ARRAY( A, len ) {int i; \
+ for( i = 0; i < PAD; i++ ) {A[len+i]=0x55;}}
+
+#define CHK_ARRAY( A, len ) {int i;for( i = 0; i < PAD; i++ ) {\
+ if(A[len+i]!=0x55) { \
+ DBG( 1, "Array overrun detected on line %d\n", __LINE__ ); \
+ }}}
+#else
+#define PAD 0
+#define PAD_ARRAY( A, len )
+#define CHK_ARRAY( A, len )
+#endif
+
+
+/* This data structure contains data related
+ * to the scanning process.
+ */
+typedef struct
+{
+ /* Constant data */
+
+ int color;
+ int w;
+ int h;
+ int xo;
+ int yo;
+ int xdpi; /* Physical x dpi */
+ int ydpi; /* Physical y dpi */
+ int xsamp;
+ int ysamp;
+
+ int xskip;
+ int yskip;
+
+ int fd; /* Device file handle */
+ UMAX_Model model;
+
+ /* Raw scan data buffer */
+
+ unsigned char *p;
+ int bh; /* Size of buffer in lines */
+ int hexp; /* Scan lines yet to be read */
+
+ /* Decoding logic */
+
+ int x, y, maxh;
+ int done; /* Boolean, all lines decoded */
+
+ /* Calibration data */
+
+ unsigned char caldata[16070 + PAD];
+
+ /* Scan head position */
+
+ int scanner_ypos;
+ int scanner_yorg;
+}
+UMAX_Handle;
+
+typedef unsigned char UMAX_Status_Byte;
+
+
+#if 0
+static void
+unused_operations ()
+{
+ /* These operations are unused anywhere in the driver */
+
+ unsigned char opb8[35] = {
+ 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x04,
+ 0x40, 0x01, 0x00, 0x00, 0x04, 0x00, 0x6e, 0x18, 0x10, 0x03,
+ 0x06, 0x00, 0x00, 0x00, 0x46, 0xa0, 0x00, 0x8b, 0x49, 0x4a,
+ 0xd0, 0x68, 0xdf, 0x13, 0x1a
+ };
+
+ unsigned char opb9[35] = {
+ 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x04,
+ 0x40, 0x01, 0x00, 0x00, 0x04, 0x00, 0x6e, 0x41, 0x20, 0x24,
+ 0x06, 0x00, 0x00, 0x00, 0x46, 0xa0, 0x00, 0x8b, 0x49, 0x4a,
+ 0xd0, 0x68, 0xdf, 0x13, 0x1a
+ };
+
+ unsigned char opb10[35] = {
+ 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x04,
+ 0x40, 0x01, 0x00, 0x00, 0x04, 0x00, 0x6e, 0x41, 0x60, 0x4f,
+ 0x06, 0x00, 0x00, 0x00, 0x46, 0xa0, 0x00, 0x8b, 0x49, 0x4a,
+ 0xd0, 0x68, 0xdf, 0x93, 0x1a
+ };
+
+ unsigned char opc5[16] = {
+ 0x05, 0x00, 0x00, 0x70, 0x00, 0x00, 0x60, 0x2f, 0x2f, 0x00,
+ 0x00, 0x30, 0x0c, 0xc3, 0xa4, 0x00
+ };
+
+ unsigned char opc6[16] = {
+ 0x01, 0x00, 0x00, 0x70, 0x00, 0x00, 0x60, 0x2f, 0x2f, 0x00,
+ 0x88, 0x48, 0x0c, 0x83, 0xa4, 0x00
+ };
+
+ unsigned char opc7[16] = {
+ 0x05, 0x00, 0x00, 0x70, 0x00, 0x00, 0x60, 0x2f, 0x2f, 0x00,
+ 0xec, 0x4e, 0x0c, 0xc3, 0xa4, 0x00
+ };
+
+ unsigned char opd2[8] = {
+ 0x06, 0xf4, 0xff, 0x81, 0x3d, 0x00, 0x00, 0x30
+ };
+}
+#endif
+
+#if 0
+static SANE_Status
+calib (UMAX_Handle * scan)
+{
+ unsigned char buf[65536];
+ opc5[11] = 0x30;
+ opd2[7] = 0x30;
+ CHK (get_pixels (scan, opc5, opb8, opd2, ope, 24, 0, buff));
+
+ opc5[11] = 0x40;
+ opd2[7] = 0x40;
+ CHK (get_pixels (scan, opc5, opb8, opd2, ope, 24, 0, buff));
+
+ opd2[6] = 8;
+ opd2[7] = 0x30;
+ CHK (get_pixels (scan, opc6, opb9, opd2, ope, 0x200, 1, buff));
+
+ opc7[10] = 0xec;
+ opd2[6] = 0xc;
+ opd2[7] = 0x40;
+ CHK (get_pixels (scan, opc7, opb10, opd2, ope, 5300, 1, buff));
+
+ opc7[10] = 0xed;
+ opd2[6] = 0xd;
+ CHK (get_pixels (scan, opc7, opb10, opd2, ope, 5300, 0, buff));
+ return SANE_STATUS_GOOD;
+}
+#endif
+
+
+/* This seems to configure the pv8630 chip somehow. I wish
+ * all the magic numbers were defined as self-descriptive
+ * constants somewhere. I made some guesses based on what
+ * I found in "pv8630.c", but alas there wasn't enough in
+ * there. If you know what this does, please let me know!
+ */
+static SANE_Status
+xxxops (UMAX_Handle * scan)
+{
+ SANE_Status res;
+
+ DBG (9, "doing xxxops\n");
+
+ CHK (sanei_pv8630_write_byte (scan->fd, PV8630_RMODE, 0x02));
+
+ CHK (sanei_pv8630_write_byte (scan->fd, PV8630_UNKNOWN, 0x0E));
+ CHK (sanei_pv8630_write_byte (scan->fd, PV8630_RDATA, 0x40));
+ CHK (sanei_pv8630_write_byte (scan->fd, PV8630_UNKNOWN, 0x06));
+ CHK (sanei_pv8630_xpect_byte (scan->fd, PV8630_RSTATUS, 0x38, 0xFF));
+
+ CHK (sanei_pv8630_write_byte (scan->fd, PV8630_UNKNOWN, 0x07));
+ CHK (sanei_pv8630_xpect_byte (scan->fd, PV8630_RSTATUS, 0x38, 0xFF));
+
+ CHK (sanei_pv8630_write_byte (scan->fd, PV8630_UNKNOWN, 0x04));
+ CHK (sanei_pv8630_xpect_byte (scan->fd, PV8630_RSTATUS, 0xF8, 0xFF));
+
+ CHK (sanei_pv8630_write_byte (scan->fd, PV8630_UNKNOWN, 0x05));
+ CHK (sanei_pv8630_xpect_byte (scan->fd, PV8630_UNKNOWN, 0x05, 0xFF));
+
+ CHK (sanei_pv8630_write_byte (scan->fd, PV8630_UNKNOWN, 0x04));
+
+ CHK (sanei_pv8630_write_byte (scan->fd, PV8630_RMODE, 0x1E));
+
+ return res;
+}
+
+/*
+Apparently sends the two syncronization characters followed
+by the command length, followed by the command number
+*/
+static SANE_Status
+usync (UMAX_Handle * scan, UMAX_Cmd cmd, int len)
+{
+ UMAX_Status_Byte s0, s4;
+ SANE_Status res;
+ unsigned char buf[4];
+ size_t nb;
+
+ DBG (80, "usync: len = %d, cmd = %d\n", len, cmd);
+
+ buf[0] = UMAX_SYNC1;
+ buf[1] = UMAX_SYNC2;
+
+ nb = 2;
+ CHK (sanei_pv8630_flush_buffer (scan->fd));
+ CHK (sanei_pv8630_prep_bulkwrite (scan->fd, nb));
+ CHK (sanei_pv8630_bulkwrite (scan->fd, buf, &nb));
+
+ CHK (sanei_pv8630_wait_byte
+ (scan->fd, PV8630_RSTATUS, UMAX_OK, UMAX_STATUS_MASK, 20));
+
+ buf[0] = len >> 16;
+ buf[1] = len >> 8;
+ buf[2] = len;
+ buf[3] = cmd;
+
+ nb = 4;
+ CHK (sanei_pv8630_flush_buffer (scan->fd));
+ CHK (sanei_pv8630_prep_bulkwrite (scan->fd, nb));
+ CHK (sanei_pv8630_bulkwrite (scan->fd, buf, &nb));
+
+ CHK (sanei_pv8630_read_byte (scan->fd, PV8630_RDATA, &s0));
+ CHK (sanei_pv8630_read_byte (scan->fd, PV8630_RSTATUS, &s4));
+
+ DBG (90, "usync: s0 = %#x s4 = %#x\n", s0, s4);
+
+ return SANE_STATUS_GOOD;
+}
+
+/*
+This function escapes any syncronization sequence that may be
+in data, storing the result in buf. In the worst case where
+every character gets escaped buf must be at least twice as
+large as dlen.
+*/
+static int
+bescape (const unsigned char *data, int dlen, unsigned char *buf, int blen)
+{
+ const unsigned char *p;
+ unsigned char *q;
+ int i, c;
+ i = blen; /* Eliminate compiler warning about unused param */
+
+ p = data;
+ q = buf;
+ for (i = 0; i < dlen; ++i)
+ {
+ c = *p++;
+ if (c == UMAX_ESCAPE
+ || (c == UMAX_SYNC2 && i > 0 && p[-2] == UMAX_SYNC1))
+ *q++ = UMAX_ESCAPE;
+ *q++ = c;
+ }
+ return q - buf;
+}
+
+
+
+/* Write */
+
+static SANE_Status
+cwrite (UMAX_Handle * scan, UMAX_Cmd cmd, size_t len, const unsigned char *data,
+ UMAX_Status_Byte * s)
+{
+ SANE_Status res;
+ UMAX_Status_Byte s0, s4;
+
+ static unsigned char *escaped = NULL;
+ static size_t escaped_size = 0;
+
+ DBG (80, "cwrite: cmd = %d, len = %lu\n", cmd, (u_long) len);
+
+ CHK (usync (scan, cmd | CMD_WRITE, len));
+
+ if (len <= 0)
+ return SANE_STATUS_GOOD;
+
+ if (escaped_size < len * 2)
+ {
+ escaped_size = len * 2;
+ if (escaped)
+ free (escaped);
+ escaped = malloc (escaped_size);
+ if (escaped == NULL)
+ return SANE_STATUS_NO_MEM;
+ }
+
+ len = bescape (data, len, escaped, len * 2);
+
+ CHK (sanei_pv8630_wait_byte
+ (scan->fd, PV8630_RSTATUS, UMAX_OK, UMAX_STATUS_MASK, 20));
+
+ CHK (sanei_pv8630_flush_buffer (scan->fd));
+ CHK (sanei_pv8630_prep_bulkwrite (scan->fd, len));
+ CHK (sanei_pv8630_bulkwrite (scan->fd, escaped, &len));
+
+ CHK (sanei_pv8630_read_byte (scan->fd, PV8630_RSTATUS, &s4));
+ CHK (sanei_pv8630_read_byte (scan->fd, PV8630_RDATA, &s0));
+
+ DBG (90, "cwrite: s0 = %#x s4 = %#x\n", s0, s4);
+
+ if (s)
+ *s = s0;
+
+ return SANE_STATUS_GOOD;
+}
+
+/* Read */
+
+static SANE_Status
+cread (UMAX_Handle * scan, UMAX_Cmd cmd, size_t len, unsigned char *data,
+ UMAX_Status_Byte * s)
+{
+ SANE_Status res;
+ UMAX_Status_Byte s0, s4;
+
+ DBG (80, "cread: cmd = %d, len = %lu\n", cmd, (u_long) len);
+
+ CHK (usync (scan, cmd | CMD_READ, len));
+
+ if (len > 0)
+ {
+ CHK (sanei_pv8630_wait_byte
+ (scan->fd, PV8630_RSTATUS, UMAX_OK_WITH_MOTOR, UMAX_STATUS_MASK,
+ 2000));
+
+ while (len > 0)
+ {
+ size_t req, n;
+
+ req = n = (len > 0xf000) ? 0xf000 : len;
+ CHK (sanei_pv8630_prep_bulkread (scan->fd, n));
+ CHK (sanei_pv8630_bulkread (scan->fd, data, &n));
+ if (n < req)
+ {
+ DBG (1, "qread: Expecting to read %lu, only got %lu\n", (u_long) req, (u_long) n);
+ return SANE_STATUS_IO_ERROR;
+ }
+ data += n;
+ len -= n;
+ }
+ }
+
+ CHK (sanei_pv8630_read_byte (scan->fd, PV8630_RSTATUS, &s4));
+ CHK (sanei_pv8630_read_byte (scan->fd, PV8630_RDATA, &s0));
+
+ DBG (90, "cwrite: s0 = %#x s4 = %#x\n", s0, s4);
+
+ if (s)
+ *s = s0;
+
+ return SANE_STATUS_GOOD;
+}
+
+
+
+/* Seems to be like cwrite, with a verification option */
+
+static SANE_Status
+cwritev (UMAX_Handle * scan, UMAX_Cmd cmd, size_t len, const unsigned char *data,
+ UMAX_Status_Byte * s)
+{
+ SANE_Status res;
+ unsigned char buf[16384];
+
+ /* Write out the opcode */
+
+ CHK (cwrite (scan, cmd, len, data, s));
+ if (len <= 0)
+ return SANE_STATUS_GOOD;
+
+ /* Read the opcode back */
+
+ CHK (cread (scan, cmd, len, buf, NULL));
+ if (bcmp (buf, data, len))
+ {
+ DBG (1, "cwritev: verification failed\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+ return SANE_STATUS_GOOD;
+}
+
+
+/* Send command */
+
+static SANE_Status
+csend (UMAX_Handle * scan, UMAX_Cmd cmd)
+{
+ DBG (80, "csend: cmd = %d\n", cmd);
+
+ return usync (scan, cmd, 0);
+}
+
+/* Lamp control */
+
+static SANE_Status
+cwritev_opc1_lamp_ctrl (UMAX_Handle * scan, UMAX_Lamp_State state)
+{
+ unsigned char opc1[16] = {
+ 0x01, 0x00, 0x01, 0x70, 0x00, 0x00, 0x60, 0x2f, 0x13, 0x05,
+ 0x00, 0x00, 0x00, 0x80, 0xf0, 0x00
+ };
+
+ DBG (9, "cwritev_opc1: set lamp state = %s\n",
+ (state == UMAX_LAMP_OFF) ? "off" : "on");
+ opc1[14] = (state == UMAX_LAMP_OFF) ? 0x90 : 0xf0;
+ return cwritev (scan, CMD_2, 16, opc1, NULL);
+}
+
+
+/* Restore Head 1220U */
+
+static SANE_Status
+cwritev_opb3_restore (UMAX_Handle * scan)
+{
+ unsigned char opb3[35] = {
+ 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x03,
+ 0xc1, 0x80, 0x00, 0x00, 0x04, 0x00, 0x16, 0x80, 0x15, 0x78,
+ 0x03, 0x03, 0x00, 0x00, 0x46, 0xa0, 0x00, 0x8b, 0x49, 0x4a,
+ 0xd0, 0x68, 0xdf, 0x1b, 0x1a,
+ };
+
+ SANE_Status res;
+
+ DBG (9, "cwritev_opb3_restore:\n");
+ CHK (cwritev (scan, CMD_8, 35, opb3, NULL));
+ CHK (csend (scan, CMD_40));
+ return SANE_STATUS_GOOD;
+}
+
+
+/* Restore Head 2100U */
+
+static SANE_Status
+cwritev_opb3_restore_2100U (UMAX_Handle * scan)
+{
+ unsigned char opb3[36] = {
+ 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x03,
+ 0xc1, 0x80, 0x00, 0x00, 0x04, 0x00, 0x16, 0x80, 0x15, 0x78,
+ 0x03, 0x03, 0x00, 0x00, 0x46, 0xa0, 0x00, 0x8b, 0x49, 0x2a,
+ 0xe9, 0x68, 0xdf, 0x0b, 0x1a, 0x00
+ };
+
+ SANE_Status res;
+
+ DBG (9, "cwritev_opb3_restore:\n");
+ CHK (cwritev (scan, CMD_8, 36, opb3, NULL));
+ CHK (csend (scan, CMD_40));
+ return SANE_STATUS_GOOD;
+}
+
+
+/* Initialize and turn lamp on 1220U */
+
+/*
+This function seems to perform various things. First, it loads a default
+gamma information (which is used for the calibration scan), returns the
+head to the park position, and turns the lamp on. This function used to
+be split up into two parts, umaxinit and umaxinit2.
+*/
+
+static SANE_Status
+umaxinit (UMAX_Handle * scan)
+{
+ unsigned char opb[34] = {
+ 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x03,
+ 0xc1, 0x80, 0x60, 0x20, 0x00, 0x00, 0x16, 0x41, 0xe0, 0xac,
+ 0x03, 0x03, 0x00, 0x00, 0x46, 0xa0, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0xf0
+ };
+ unsigned char opb1[35] = {
+ 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x03,
+ 0xc1, 0x80, 0x00, 0x20, 0x02, 0x00, 0x16, 0x41, 0xe0, 0xac,
+ 0x03, 0x03, 0x00, 0x00, 0x46, 0xa0, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x10, 0x1a
+ };
+ unsigned char opb2[35] = {
+ 0x00, 0x00, 0x06, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x03,
+ 0xc1, 0x80, 0x00, 0x20, 0x02, 0x00, 0x16, 0x41, 0xe0, 0xac,
+ 0x03, 0x03, 0x00, 0x00, 0x46, 0xa0, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x10, 0x1a
+ };
+ unsigned char opb4[35] = {
+ 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x03,
+ 0xc1, 0x80, 0x60, 0x20, 0x00, 0x00, 0x16, 0x41, 0xe0, 0xac,
+ 0x03, 0x03, 0x00, 0x00, 0x46, 0xa0, 0x00, 0x8b, 0x49, 0x4a,
+ 0xd0, 0x68, 0xdf, 0xf3, 0x1b
+ };
+ unsigned char opbx[35];
+ unsigned char opc[16] = {
+ 0x02, 0x80, 0x00, 0x70, 0x00, 0x00, 0x60, 0x2f, 0x2f, 0x07,
+ 0x00, 0x00, 0x00, 0x80, 0xf0, 0x00
+ };
+ unsigned char opcx[16];
+ unsigned char opd[8] = {
+ 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa, 0x55, 0xaa
+ };
+
+ SANE_Status res;
+ UMAX_Status_Byte s;
+ unsigned char ramp[800];
+ int i;
+ unsigned char *p;
+
+ DBG (3, "umaxinit called\n");
+
+ CHK (csend (scan, CMD_0));
+ CHK (xxxops (scan));
+
+ CHK (cwritev (scan, CMD_8, 34, opb, &s));
+ CHK (cread (scan, CMD_8, 35, opbx, &s));
+
+ CHK (cwritev (scan, CMD_8, 35, opb1, &s));
+
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+
+ DBG (4, "umaxinit: checkpoint 2:\n");
+
+ /* The following code appears to send three 256 entry, 8-bit gamma tables
+ * to the scanner
+ */
+ p = ramp;
+ *p++ = 0;
+ *p++ = 0;
+ *p++ = 0;
+ for (i = 0; i < 256; ++i)
+ *p++ = i;
+ for (i = 0; i < 256; ++i)
+ *p++ = i;
+ for (i = 0; i < 256; ++i)
+ *p++ = i;
+ *p++ = 0xaa;
+ *p++ = 0xaa;
+
+ res = cwritev (scan, CMD_4, p - ramp, ramp, &s);
+ if (res != SANE_STATUS_GOOD)
+ {
+ DBG (4, "umaxinit: Writing ramp 1 failed (is this a 2000U?)\n");
+ }
+ CHK (cwritev (scan, CMD_8, 35, opb1, &s));
+
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+
+ DBG (4, "umaxinit: checkpoint 3:\n");
+
+ /* The following code appears to send a 256 entry, 16-bit gamma table
+ * to the scanner
+ */
+ p = ramp;
+ for (i = 0; i < 256; ++i)
+ {
+ *p++ = i;
+ *p++ = 0;
+ }
+
+ res = cwrite (scan, CMD_4, p - ramp, ramp, &s);
+ if (res != SANE_STATUS_GOOD)
+ {
+ DBG (4, "umaxinit: Writing ramp 2 failed (is this a 2000U?)\n");
+ }
+ CHK (cwritev (scan, CMD_8, 35, opb2, &s));
+
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+
+ DBG (4, "umaxinit: checkpoint 4:\n");
+
+ /* The following code appears to send a 256 entry, 16-bit gamma table
+ * to the scanner.
+ */
+ p = ramp;
+ for (i = 0; i < 256; ++i)
+ {
+ *p++ = i;
+ *p++ = 4;
+ }
+
+ res = cwritev (scan, CMD_4, p - ramp, ramp, &s);
+ if (res != SANE_STATUS_GOOD)
+ {
+ DBG (4, "umaxinit: Writing ramp 3 failed (is this a 2000U?)\n");
+ }
+ CHK (cwritev (scan, CMD_8, 35, opb1, &s));
+
+ CHK (cwritev (scan, CMD_2, 16, opc, NULL));
+ CHK (cwritev (scan, CMD_1, 8, opd, NULL));
+ CHK (csend (scan, CMD_0));
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+
+ DBG (4, "umaxinit: checkpoint 5: s = %#x\n", s);
+
+ if ((s & 0x40) == 0)
+ {
+ DBG (4, "umaxinit: turning on lamp and restoring\n");
+ CHK (cwritev_opc1_lamp_ctrl (scan, UMAX_LAMP_ON));
+ CHK (cwritev_opb3_restore (scan));
+
+ for (i = 0; i < 60; ++i)
+ {
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+ DBG (4, "umaxinit: s = %#x\n", s);
+ if ((s & 0x40) != 0)
+ break;
+ DBG (4, "umaxinit: sleeping\n");
+ usleep (500000);
+ }
+ }
+
+ DBG (4, "umaxinit: checkpoint 6\n");
+
+ CHK (csend (scan, CMD_0));
+
+ /* The following stuff used to be in umaxinit2() */
+
+ DBG (4, "umaxinit: checkpoint 7\n");
+
+ CHK (xxxops (scan));
+ CHK (csend (scan, CMD_0));
+ CHK (xxxops (scan));
+
+ CHK (cwritev (scan, CMD_8, 34, opb4, &s));
+ CHK (cread (scan, CMD_8, 35, opbx, &s));
+ CHK (cread (scan, CMD_2, 16, opcx, &s));
+
+ CHK (cwritev (scan, CMD_2, 16, opc, NULL));
+ CHK (cwritev (scan, CMD_1, 8, opd, NULL));
+ CHK (csend (scan, CMD_0));
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+
+ DBG (4, "umaxinit: checkpoint 8: s = %d\n", s);
+
+ return SANE_STATUS_GOOD;
+}
+
+/* Initialize and turn lamp on 2100U */
+
+static SANE_Status
+umaxinit_2100U (UMAX_Handle * scan)
+{
+
+ unsigned char opx[36];
+ unsigned char opy[16];
+
+
+ SANE_Status res;
+ UMAX_Status_Byte s;
+
+ DBG (3, "umaxinit called\n");
+
+ CHK (xxxops (scan));
+ CHK (csend (scan, CMD_0));
+
+ /* Turn lamp on */
+
+ cwritev_opc1_lamp_ctrl (scan, UMAX_LAMP_ON);
+
+ CHK (cread (scan, CMD_8, 36, opx, &s));
+ CHK (cread (scan, CMD_2, 16, opy, &s));
+ CHK (csend (scan, CMD_0));
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+ CHK (csend (scan, CMD_0));
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/* Move head 1220U */
+
+static SANE_Status
+move (UMAX_Handle * scan, int distance, UMAX_Speed fine)
+{
+ unsigned char opc4[16] = {
+ 0x01, XXXX, XXXX, XXXX, 0x00, 0x00, 0x60, 0x2f, XXXX, XXXX,
+ 0x00, 0x00, 0x00, 0x80, XXXX, 0x00
+ };
+ unsigned char opb5[35] = {
+ 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x04,
+ 0x40, 0x01, 0x00, 0x00, 0x04, 0x00, 0x6e, 0xf6, 0x79, 0xbf,
+ 0x06, 0x00, 0x00, 0x00, 0x46, 0xa0, 0x00, 0x8b, 0x49, 0x4a,
+ 0xd0, 0x68, 0xdf, 0x13, 0x1a
+ };
+ unsigned char opb7[35] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x6e, 0xf6, 0x79, 0xbf,
+ 0x01, 0x00, 0x00, 0x00, 0x46, 0xa0, 0x00, 0x8b, 0x49, 0x4a,
+ 0xd0, 0x68, 0xdf, 0x13, 0x1a
+ };
+
+ unsigned char ope[8] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff
+ };
+
+ unsigned char ope2[3] = {
+ 0x00, 0xff, 0x8f
+ };
+ unsigned char buf[512 + PAD];
+
+ SANE_Status res;
+ UMAX_Status_Byte s;
+
+ SANE_Bool rev = distance < 0;
+ int skip = (rev ? -distance : distance) - 1;
+
+ DBG (9, "move: distance = %d, scanner_ypos = %d\n", distance,
+ scan->scanner_ypos);
+
+ PAD_ARRAY (buf, 512);
+
+ if (distance == 0)
+ return SANE_STATUS_GOOD;
+
+ opc4[1] = skip << 6;
+ opc4[2] = skip >> 2;
+ opc4[3] = (rev ? 0x20 : 0x70) + ((skip >> 10) & 0xf);
+ opc4[9] = rev ? 0x01 : 0x05;
+
+ if (fine == UMAX_FINE)
+ {
+ opc4[8] = 0x2f;
+ opc4[14] = 0xa4;
+ }
+ else
+ {
+ opc4[8] = 0x17;
+ opc4[14] = 0xac;
+ }
+
+ scan->scanner_ypos +=
+ (fine == UMAX_FINE ? distance : 2 * distance + (rev ? -1 : 1));
+ scan->scanner_ypos = (scan->scanner_ypos + (rev ? 0 : 3)) & ~3;
+
+ CHK (cwrite (scan, CMD_2, 16, opc4, &s));
+ CHK (cwrite (scan, CMD_8, 35, rev ? opb7 : opb5, &s));
+
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+ DBG (10, "move: checkpoint 1: s = %d\n", s);
+
+ CHK (csend (scan, CMD_0));
+ if (rev)
+ CHK (cwrite (scan, CMD_4, 3, ope2, &s))
+ else
+ CHK (cwrite (scan, CMD_4, 8, ope, &s));
+
+
+ CHK (csend (scan, CMD_40));
+
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+
+ DBG (10, "move: checkpoint 2: s = %d\n", s);
+
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+ DBG (10, "move: checkpoint 3: s = %d\n", s);
+
+ CHK (cread (scan, CMD_4, 512, buf, &s));
+
+ CHK_ARRAY (buf, 512);
+
+ return res;
+}
+
+
+
+/* Move head 2100U */
+
+static SANE_Status
+move_2100U (UMAX_Handle * scan, int distance, UMAX_Speed fine)
+{
+
+
+ unsigned char opc4[16] = {
+ 0x01, XXXX, XXXX, XXXX, 0x00, 0x00, 0x60, 0x2f, XXXX, XXXX,
+ 0x00, 0x00, 0x00, 0x80, XXXX, 0x00
+ };
+ unsigned char opb5[36] = {
+ 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x04,
+ 0x40, 0x01, 0x00, 0x00, 0x04, 0x00, 0x6e, 0xf6, 0x79, 0xbf,
+ 0x06, 0x00, 0x00, 0x00, 0x46, 0xa0, 0x00, 0x8b, 0x49, 0x2a,
+ 0xe9, 0x68, 0xdf, 0x03, 0x1a, 0x00
+ };
+ unsigned char opb7[36] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+ 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x6e, 0xf6, 0x79, 0xbf,
+ 0x01, 0x00, 0x00, 0x00, 0x46, 0xa0, 0x00, 0x8b, 0x49, 0x2a,
+ 0xe9, 0x68, 0xdf, 0x03, 0x1a, 0x00
+ };
+ unsigned char ope[8] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff
+ };
+ unsigned char ope2[3] = {
+ 0x00, 0xff, 0xff
+ };
+ unsigned char buf[512];
+
+
+ SANE_Status res;
+ UMAX_Status_Byte s;
+
+ SANE_Bool rev = distance < 0;
+ int skip = (rev ? -distance : distance) - 1;
+
+ DBG (9, "move: distance = %d, scanner_ypos = %d\n", distance,
+ scan->scanner_ypos);
+
+ PAD_ARRAY (buf, 512);
+
+ if (distance == 0)
+ return SANE_STATUS_GOOD;
+
+ opc4[1] = skip << 6;
+ opc4[2] = skip >> 2;
+ opc4[3] = (rev ? 0x20 : 0x70) + ((skip >> 10) & 0x0f);
+ opc4[9] = rev ? 0x01 : 0x05;
+
+ if (fine == UMAX_FINE)
+ {
+ opc4[8] = 0x2b;
+ opc4[14] = 0xa4;
+ }
+ else
+ {
+ opc4[8] = 0x15;
+ opc4[14] = 0xac;
+ }
+
+ scan->scanner_ypos +=
+ (fine == UMAX_FINE ? distance : 2 * distance + (rev ? -1 : 1));
+ scan->scanner_ypos = (scan->scanner_ypos + (rev ? 0 : 3)) & ~3;
+
+ CHK (cwrite (scan, CMD_2, 16, opc4, &s));
+ CHK (cwrite (scan, CMD_8, 36, rev ? opb7 : opb5, &s));
+
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+ DBG (10, "move: checkpoint 1: s = %d\n", s);
+
+ CHK (csend (scan, CMD_0));
+
+ if (rev)
+ CHK (cwrite (scan, CMD_4, 3, ope2, &s))
+ else
+ CHK (cwrite (scan, CMD_4, 8, ope, &s));
+
+ CHK (csend (scan, CMD_40));
+
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+
+ DBG (10, "move: checkpoint 2: s = %d\n", s);
+
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+ DBG (10, "move: checkpoint 3: s = %d\n", s);
+
+ CHK (cread (scan, CMD_4, 512, buf, &s));
+
+ CHK_ARRAY (buf, 512);
+
+ return res;
+}
+
+
+/* Get pixel image 1220U */
+
+static SANE_Status
+get_pixels (UMAX_Handle * scan, unsigned char *op2, unsigned char *op8,
+ unsigned char *op1, unsigned char *op4, int len, int zpos,
+ unsigned char *buf)
+{
+ SANE_Status res;
+ UMAX_Status_Byte s;
+
+ DBG (9, "get_pixels: len = %d, zpos = %d\n", len, zpos);
+
+ if (zpos == 0)
+ CHK (csend (scan, CMD_0));
+
+ CHK (cwrite (scan, CMD_2, 16, op2, &s));
+ CHK (cwrite (scan, CMD_8, 35, op8, &s));
+ CHK (cwrite (scan, CMD_1, 8, op1, &s));
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+
+ if (zpos == 1)
+ CHK (csend (scan, CMD_0));
+
+ CHK (cwrite (scan, CMD_4, 8, op4, &s));
+ CHK (csend (scan, CMD_40));
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+
+ CHK (cread (scan, CMD_4, len, buf, &s));
+ return SANE_STATUS_GOOD;
+}
+
+
+/* Get pixel image 2100U */
+
+static SANE_Status
+get_pixels_2100U (UMAX_Handle * scan, unsigned char *op2, unsigned char *op8,
+ unsigned char *op1, unsigned char *op4, int len, int zpos,
+ unsigned char *buf)
+{
+ SANE_Status res;
+ UMAX_Status_Byte s;
+
+ DBG (9, "get_pixels: len = %d, zpos = %d\n", len, zpos);
+
+ CHK (cwrite (scan, CMD_2, 16, op2, &s));
+ CHK (cwrite (scan, CMD_8, 36, op8, &s));
+
+ if (zpos == 1)
+ CHK (cwritev (scan, CMD_1, 8, op1, &s))
+ else
+ CHK (cwrite (scan, CMD_1, 8, op1, &s));
+
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+
+ if (zpos == 1)
+ CHK (csend (scan, CMD_0));
+
+ CHK (cwrite (scan, CMD_4, 8, op4, &s));
+ CHK (csend (scan, CMD_40));
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+
+ CHK (cread (scan, CMD_4, len, buf, &s));
+ return SANE_STATUS_GOOD;
+}
+
+
+/* This function locates the black stripe under scanner lid */
+
+static int
+locate_black_stripe (unsigned char *img, int w, int h)
+{
+ int epos, ecnt, x, y;
+ unsigned char *p;
+
+ epos = 0;
+ ecnt = 0;
+ p = img;
+ for (x = 0; x < w; ++x, ++p)
+ {
+ int d, dmax = 0, dpos = 0;
+ unsigned char *q = img + x;
+ for (y = 1; y < h; ++y, q += w)
+ {
+ d = q[0] - q[w];
+ if (d > dmax)
+ {
+ dmax = d;
+ dpos = y;
+ }
+ }
+ if (dmax > 0)
+ {
+ epos += dpos;
+ ++ecnt;
+ }
+ }
+ if (ecnt == 0)
+ epos = 70;
+ else
+ epos = (epos + ecnt / 2) / ecnt;
+ return epos;
+}
+
+
+/* To find the lowest head position 1220U */
+
+static SANE_Status
+find_zero (UMAX_Handle * scan)
+{
+ unsigned char opc3[16] = {
+ 0xb4, 0x00, 0x00, 0x70, 0x00, 0x00, 0x60, 0x2f, 0x2f, 0x05,
+ 0x00, 0x00, 0x00, 0x80, 0xa4, 0x00
+ };
+ unsigned char ope1[8] = {
+ 0x00, 0x00, 0x00, 0xaa, 0xcc, 0xee, 0x80, 0xff
+ };
+ unsigned char opb6[35] = {
+ 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x04,
+ 0x40, 0x01, 0x00, 0x00, 0x04, 0x00, 0x6e, 0xfb, 0xc4, 0xe5,
+ 0x06, 0x00, 0x00, 0x60, 0x4d, 0xa0, 0x00, 0x8b, 0x49, 0x4a,
+ 0xd0, 0x68, 0xdf, 0x13, 0x1a
+ };
+ unsigned char opd1[8] = {
+ 0x06, 0xf4, 0xff, 0x81, 0x3d, 0x00, 0x08, 0x00
+ };
+
+ SANE_Status res;
+ int s;
+ unsigned char *img;
+
+ DBG (9, "find_zero:\n");
+
+ img = malloc (54000);
+ if (img == 0)
+ {
+ DBG (1, "out of memory (need 54000)\n");
+ return SANE_STATUS_NO_MEM;
+ }
+
+ CHK (csend (scan, CMD_0));
+ CHK (get_pixels (scan, opc3, opb6, opd1, ope1, 54000, 1, img));
+
+#ifdef DEBUG_CALIBRATION
+ {
+ int w = 300, h = 180;
+ FILE *f2 = fopen ("find_zero.pgm", "wb");
+ fprintf (f2, "P5\n%d %d\n255\n", w, h);
+ fwrite (img, 1, w * h, f2);
+ fclose (f2);
+ }
+#endif
+
+ s = locate_black_stripe (img, 300, 180);
+ scan->scanner_yorg = scan->scanner_ypos + s + 64;
+ scan->scanner_ypos += 180 + 3;
+ scan->scanner_ypos &= ~3;
+
+ free (img);
+ return SANE_STATUS_GOOD;
+}
+
+
+/* To find the lowest head position 2100U */
+
+static SANE_Status
+find_zero_2100U (UMAX_Handle * scan)
+{
+ unsigned char opc3[16] = {
+ 0xb4, 0x00, 0x00, 0x70, 0x00, 0x00, 0x60, 0x2f, 0x2b, 0x05,
+ 0x00, 0x00, 0x00, 0x80, 0xa4, 0x00
+ };
+ unsigned char ope1[8] = {
+ 0x00, 0x00, 0x00, 0xaa, 0xcc, 0xee, 0x80, 0xff
+ };
+ unsigned char opb6[36] = {
+ 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x04,
+ 0x40, 0x01, 0x00, 0x00, 0x04, 0x00, 0x6e, 0xfb, 0xc4, 0xe5,
+ 0x06, 0x00, 0x00, 0x60, 0x4d, 0xa0, 0x00, 0x8b, 0x49, 0x2a,
+ 0xe9, 0x68, 0xdf, 0x03, 0x1a, 0x00
+ };
+ unsigned char opd1[8] = {
+ 0x06, 0xf4, 0xff, 0x81, 0x1b, 0x00, 0x08, 0x00
+ };
+
+ SANE_Status res;
+ int s;
+ unsigned char *img;
+
+ DBG (9, "find_zero:\n");
+
+ img = malloc (54000);
+ if (img == 0)
+ {
+ DBG (1, "out of memory (need 54000)\n");
+ return SANE_STATUS_NO_MEM;
+ }
+
+ CHK (csend (scan, CMD_0));
+ CHK (get_pixels_2100U (scan, opc3, opb6, opd1, ope1, 54000, 1, img));
+
+#ifdef DEBUG_CALIBRATION
+ {
+ int w = 300, h = 180;
+ FILE *f2 = fopen ("find_zero.pgm", "wb");
+ fprintf (f2, "P5\n%d %d\n255\n", w, h);
+ fwrite (img, 1, w * h, f2);
+ fclose (f2);
+ }
+#endif
+
+ s = locate_black_stripe (img, 300, 180);
+ scan->scanner_yorg = scan->scanner_ypos + s + 64;
+ scan->scanner_ypos += 180 + 3;
+ scan->scanner_ypos &= ~3;
+
+ free (img);
+ return SANE_STATUS_GOOD;
+}
+
+
+/* Calibration 1220U */
+
+/*
+Format of caldata:
+
+ 5100 bytes of CCD calibration values
+ 5100 bytes of CCD calibration values
+ 5100 bytes of CCD calibration values
+ 256 bytes of gamma data for blue
+ 256 bytes of gamma data for green
+ 256 bytes of gamma data for red
+ 2 bytes of extra information
+
+*/
+static SANE_Status
+get_caldata (UMAX_Handle * scan, int color)
+{
+ unsigned char opc9[16] = {
+ XXXX, 0x00, 0x00, 0x70, 0x00, 0x00, 0x60, 0x00, 0x17, 0x05,
+ 0xec, 0x4e, 0x0c, XXXX, 0xac
+ };
+ unsigned char opb11[35] = {
+ 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x04,
+ 0x40, 0x01, 0x00, 0x00, 0x04, 0x00, 0x6e, 0xad, 0xa0, 0x49,
+ 0x06, 0x00, 0x00, XXXX, XXXX, 0xa0, 0x00, 0x8b, 0x49, 0x4a,
+ 0xd0, 0x68, 0xdf, 0x93, 0x1b
+ };
+
+ unsigned char ope[8] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff
+ };
+
+ unsigned char opd4[8] = {
+ 0x06, 0xf4, 0xff, 0x81, 0x3d, 0x00, XXXX, XXXX
+ };
+ SANE_Status res;
+
+ unsigned char *p;
+ int h = 66;
+ int w = color ? 3 * 5100 : 5100;
+ int x0 = color ? 0 : 5100;
+ int l = w * h;
+ int i, x, y;
+
+ PAD_ARRAY (scan->caldata, 16070);
+
+ DBG (9, "get_caldata: color = %d\n", color);
+
+ p = malloc (l);
+ if (p == 0)
+ {
+ DBG (1, "out of memory (need %d)\n", l);
+ return SANE_STATUS_NO_MEM;
+ }
+ memset (scan->caldata, 0, 3 * 5100);
+
+ CHK (csend (scan, CMD_0));
+ opc9[0] = h + 4;
+ if (color)
+ {
+ opc9[13] = 0x03;
+ opb11[23] = 0xc4;
+ opb11[24] = 0x5c;
+ opd4[6] = 0x08;
+ opd4[7] = 0x00;
+ }
+ else
+ {
+ opc9[13] = 0xc3;
+ opb11[23] = 0xec;
+ opb11[24] = 0x54;
+ opd4[6] = 0x0c;
+ opd4[7] = 0x40;
+ }
+
+ /* Do a test scan of the calibration strip (which is located
+ * under the scanner's lid */
+
+ CHK (get_pixels (scan, opc9, opb11, opd4, ope, l, 0, p));
+
+#ifdef DEBUG_CALIBRATION
+ {
+ FILE *f2 = fopen ("calibration.pgm", "wb");
+ fprintf (f2, "P5\n%d %d\n255\n", w, h);
+ fwrite (p, 1, w * h, f2);
+ fclose (f2);
+ }
+#endif
+
+ scan->scanner_ypos += (h + 4) * 2 + 3;
+ scan->scanner_ypos &= ~3;
+
+ /* The following loop computes the gain for each of the CCD pixel
+ * elements.
+ */
+ for (x = 0; x < w; ++x)
+ {
+ int t = 0, gn;
+ double av, gain;
+
+ for (y = 0; y < h; ++y)
+ t += p[x + y * w];
+ av = (double) t / h;
+ gain = 250 / av;
+ gn = (int) ((gain - 0.984) * 102.547 + 0.5);
+ if (gn < 0)
+ gn = 0;
+ else if (gn > 255)
+ gn = 255;
+ scan->caldata[x + x0] = gn;
+ }
+
+ /* Gamma table for blue */
+
+ for (i = 0; i < 256; ++i)
+ scan->caldata[i + 3 * 5100 + 0] = i;
+
+ /* Gamma table for green */
+
+ for (i = 0; i < 256; ++i)
+ scan->caldata[i + 3 * 5100 + 256] = i;
+
+ /* Gamma table for red */
+
+ for (i = 0; i < 256; ++i)
+ scan->caldata[i + 3 * 5100 + 512] = i;
+
+ free (p);
+
+ CHK_ARRAY (scan->caldata, 16070);
+ return SANE_STATUS_GOOD;
+}
+
+/* Calibration 2100U */
+
+/*
+Format of caldata:
+
+ 5100 bytes of CCD calibration values
+ 5100 bytes of CCD calibration values
+ 5100 bytes of CCD calibration values
+ 256 bytes of gamma data for blue
+ 256 bytes of gamma data for green
+ 256 bytes of gamma data for red
+ 2 bytes of extra information
+
+*/
+static SANE_Status
+get_caldata_2100U (UMAX_Handle * scan, int color)
+{
+ unsigned char opc9[16] = {
+ XXXX, 0x00, 0x00, 0x70, 0x00, 0x00, 0x60, 0x00, 0x15, 0x05,
+ XXXX, XXXX, XXXX, XXXX, 0xac, 0x00
+ };
+ unsigned char opb11[36] = {
+ 0x00, 0x00, 0x04, 0x00, 0x02, 0x00, 0x00, 0x0c, 0x00, 0x04,
+ 0x40, 0x01, 0x00, 0x00, 0x04, 0x00, 0x6e, XXXX, XXXX, 0x46,
+ 0x06, 0x00, 0x00, XXXX, XXXX, 0xa0, 0x00, 0x8b, 0x49, 0x2a,
+ 0xe9, 0x68, 0xdf, 0x83, XXXX, 0x00
+ };
+ unsigned char opd4[8] = {
+ 0x06, 0xf4, 0xff, 0x81, 0x1b, 0x00, XXXX, XXXX
+ };
+ unsigned char ope[8] = {
+ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff
+ };
+
+
+/* default gamma translation table */
+ unsigned char ggamma[256] = {
+ 0x00, 0x06, 0x0A, 0x0D, 0x10, 0x12, 0x14, 0x17, 0x19, 0x1B, 0x1D,
+ 0x1F, 0x21, 0x23, 0x24, 0x26, 0x28, 0x2A, 0x2B, 0x2D, 0x2E, 0x30,
+ 0x31, 0x33, 0x34, 0x36, 0x37, 0x39, 0x3A, 0x3B, 0x3D, 0x3E, 0x40,
+ 0x41, 0x42, 0x43, 0x45, 0x46, 0x47, 0x49, 0x4A, 0x4B, 0x4C, 0x4D,
+ 0x4F, 0x50, 0x51, 0x52, 0x53, 0x55, 0x56, 0x57, 0x58, 0x59, 0x5A,
+ 0x5B, 0x5C, 0x5E, 0x5F, 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66,
+ 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, 0x70, 0x71,
+ 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A, 0x7B, 0x7C,
+ 0x7D, 0x7E, 0x7F, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x86,
+ 0x87, 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, 0x90, 0x90,
+ 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x97, 0x98, 0x99, 0x9A,
+ 0x9B, 0x9C, 0x9D, 0x9D, 0x9E, 0x9F, 0xA0, 0xA1, 0xA2, 0xA2, 0xA3,
+ 0xA4, 0xA5, 0xA6, 0xA7, 0xA7, 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAC,
+ 0xAD, 0xAE, 0xAF, 0xB0, 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB4, 0xB5,
+ 0xB6, 0xB7, 0xB8, 0xB8, 0xB9, 0xBA, 0xBB, 0xBB, 0xBC, 0xBD, 0xBE,
+ 0xBF, 0xBF, 0xC0, 0xC1, 0xC2, 0xC2, 0xC3, 0xC4, 0xC5, 0xC5, 0xC6,
+ 0xC7, 0xC8, 0xC8, 0xC9, 0xCA, 0xCB, 0xCB, 0xCC, 0xCD, 0xCE, 0xCE,
+ 0xCF, 0xD0, 0xD1, 0xD1, 0xD2, 0xD3, 0xD4, 0xD4, 0xD5, 0xD6, 0xD6,
+ 0xD7, 0xD8, 0xD9, 0xD9, 0xDA, 0xDB, 0xDC, 0xDC, 0xDD, 0xDE, 0xDE,
+ 0xDF, 0xE0, 0xE1, 0xE1, 0xE2, 0xE3, 0xE3, 0xE4, 0xE5, 0xE6, 0xE6,
+ 0xE7, 0xE8, 0xE8, 0xE9, 0xEA, 0xEA, 0xEB, 0xEC, 0xEC, 0xED, 0xEE,
+ 0xEF, 0xEF, 0xF0, 0xF1, 0xF1, 0xF2, 0xF3, 0xF3, 0xF4, 0xF5, 0xF5,
+ 0xF6, 0xF7, 0xF7, 0xF8, 0xF9, 0xF9, 0xFA, 0xFB, 0xFB, 0xFC, 0xFD,
+ 0xFE, 0xFE, 0xFF
+ };
+
+
+ SANE_Status res;
+
+ unsigned char *p;
+ int h = 66;
+ int w = color ? 3 * 5100 : 5100;
+ int x0 = color ? 0 : 5100;
+ int l = w * h;
+ int i, x, y;
+ int t, gn;
+ double av, pct;
+
+ PAD_ARRAY (scan->caldata, 16070);
+
+ DBG (9, "get_caldata: color = %d\n", color);
+
+ p = malloc (l);
+ if (p == 0)
+ {
+ DBG (1, "out of memory (need %d)\n", l);
+ return SANE_STATUS_NO_MEM;
+ }
+ memset (scan->caldata, 0, 3 * 5100);
+
+ CHK (csend (scan, CMD_0));
+ CHK (csend (scan, CMD_0));
+
+ opc9[0] = h + 4;
+
+ if (color)
+ {
+ opc9[10] = 0xb6;
+ opc9[11] = 0x3b;
+ opc9[12] = 0x0c;
+ opc9[13] = 0x03;
+ opb11[17] = 0x7e;
+ opb11[18] = 0xb0;
+ opb11[23] = 0xc4;
+ opb11[24] = 0x5c;
+ opb11[34] = 0x1b;
+ opd4[6] = 0x0f;
+ opd4[7] = 0x40;
+ }
+ else
+ {
+ opc9[10] = 0xa6;
+ opc9[11] = 0x2a;
+ opc9[12] = 0x08;
+ opc9[13] = 0xc2;
+ opb11[17] = 0x7f;
+ opb11[18] = 0xc0;
+ opb11[23] = 0xec;
+ opb11[24] = 0x54;
+ opb11[34] = 0x1a;
+ opd4[6] = 0x06;
+ opd4[7] = 0x20;
+ }
+
+ /* Do a test scan of the calibration strip (which is located
+ * under the scanner's lid */
+ CHK (get_pixels_2100U (scan, opc9, opb11, opd4, ope, l, 0, p));
+
+#ifdef DEBUG_CALIBRATION
+ {
+ FILE *f2 = fopen ("calibration.pgm", "wb");
+ fprintf (f2, "P5\n%d %d\n255\n", w, h);
+ fwrite (p, 1, w * h, f2);
+ fclose (f2);
+ }
+#endif
+
+ scan->scanner_ypos += (h + 4) * 2 + 3;
+ scan->scanner_ypos &= ~3;
+
+ /* The following loop computes the gain for each of the CCD pixel
+ * elements.
+ */
+ for (x = 0; x < w; x++)
+ {
+ t = 0;
+ for (y = 0; y < h; y++)
+ t += p[x + y * w];
+ av = (double) t / h;
+ pct = 100.0 - (av * 100.0) / 250;
+ gn = (int) (pct / 0.57);
+
+ pct = gn;
+ av = exp((-pct)/50)*2.5+0.9;
+ gn = gn * av;
+
+
+ if (gn < 0)
+ gn = 0;
+ else if (gn > 127)
+ gn = 127;
+ scan->caldata[x + x0] = gn;
+ }
+
+ /* Gamma table for blue */
+
+ for (i = 0; i < 256; i++)
+ scan->caldata[i + 3 * 5100 + 0] = ggamma[i];
+
+ /* Gamma table for green */
+
+ for (i = 0; i < 256; i++)
+ scan->caldata[i + 3 * 5100 + 256] = ggamma[i];
+
+ /* Gamma table for red */
+
+ for (i = 0; i < 256; i++)
+ scan->caldata[i + 3 * 5100 + 512] = ggamma[i];
+
+ free (p);
+
+ CHK_ARRAY (scan->caldata, 16070);
+ return SANE_STATUS_GOOD;
+}
+
+
+
+/* Sends scan user parameters from frontend 1220U */
+
+static SANE_Status
+send_scan_parameters (UMAX_Handle * scan)
+{
+ SANE_Status res;
+ UMAX_Status_Byte s;
+
+ /* Appears to correspond to opscan in umax_pp_low.c */
+ unsigned char opbgo[35] = {
+ 0x00, 0x00, 0xb0, 0x4f, 0xd8, 0xe7, 0xfa, 0x10, 0xef, 0xc4,
+ 0x3c, 0x71, 0x0f, 0x00, 0x04, 0x00, 0x6e, XXXX, XXXX, XXXX,
+ 0xc4, 0x7e, 0x00, XXXX, XXXX, 0xa0, 0x0a, 0x8b, 0x49, 0x4a,
+ 0xd0, 0x68, 0xdf, XXXX, 0x1a
+ };
+
+ /* Appears to correspond to opsc53 in umax_pp_low.c */
+ unsigned char opcgo[16] = {
+ XXXX, XXXX, XXXX, XXXX, 0xec, 0x03, XXXX, XXXX, XXXX, XXXX,
+ 0xec, 0x4e, XXXX, XXXX, XXXX
+ };
+
+ /* Appears to correspond to opsc04 in umax_pp_low.c */
+ unsigned char opdgo[8] = {
+ 0x06, 0xf4, 0xff, 0x81, 0x3d, 0x00, XXXX, XXXX
+ };
+
+ unsigned char subsamp[9] = {
+ 0xff, 0xff, 0xaa, 0xaa, 0x88, 0x88, 0x88, 0x88, 0x80
+ };
+
+ const int xend =
+ scan->xskip + scan->w * scan->xsamp + (scan->xsamp + 1) / 2;
+ const int ytot = scan->hexp * scan->ysamp + 12;
+
+ opbgo[17] = scan->xskip % 256;
+ opbgo[18] = ((scan->xskip >> 8) & 0xf) + (xend << 4);
+ opbgo[19] = xend >> 4;
+ opbgo[33] = 0x33 + ((xend & 0x1000) >> 5) + ((scan->xskip & 0x1000) >> 6);
+
+ /* bytes per line */
+
+ opbgo[23] = scan->color ? 0xc6 : 0x77;
+ opbgo[24] = scan->color ? 0x5b : 0x4a;
+
+ /* Scan height */
+
+ opcgo[0] = ytot;
+ opcgo[1] = ((ytot >> 8) & 0x3f) + (scan->yskip << 6);
+ opcgo[2] = scan->yskip >> 2;
+ opcgo[3] = 0x50 + ((scan->yskip >> 10) & 0xf);
+
+ /* This is what used to be here:
+
+ opcgo[6] = bh == h? 0: 0x60; // a guess
+
+ I replaced it with what umax_pp_low.c uses, since it
+ made more sense
+ */
+ opcgo[6] = (scan->ydpi <= 300) ? 0x00 : 0x60;
+ opcgo[8] = (scan->ydpi <= 300) ? 0x17 : 0x2F;
+ opcgo[9] = (scan->ydpi >= 300) ? 0x05 : 0x07;
+ opcgo[14] = (scan->ydpi == 600) ? 0xa4 : 0xac;
+
+ opcgo[7] = scan->color ? 0x2F : 0x40;
+ opcgo[12] = scan->color ? 0x10 : 0x0C;
+ opcgo[13] = scan->color ? 0x04 : 0xc3;
+
+ opdgo[6] = scan->color ? 0x88 : 0x8c;
+ opdgo[7] = scan->color ? 0x00 : 0x40;
+
+ DBG (3, "send_scan_parameters: xskip = %d, yskip = %d\n", scan->xskip,
+ scan->yskip);
+
+ CHK (csend (scan, CMD_0));
+ CHK (csend (scan, CMD_0));
+ CHK (cwritev (scan, CMD_2, 16, opcgo, &s));
+ CHK (cwritev (scan, CMD_8, 35, opbgo, &s));
+ CHK (cwritev (scan, CMD_1, 8, opdgo, &s));
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+ DBG (4, "send_scan_parameters: checkpoint 1: s = %d\n", s);
+
+ /* Loads the new calibration data (that was computed by get_caldata) into the
+ scanner */
+
+ scan->caldata[16068] = subsamp[scan->xsamp];
+ scan->caldata[16069] = subsamp[scan->ysamp];
+ CHK (cwrite (scan, CMD_4, 16070, scan->caldata, &s));
+
+ CHK (csend (scan, CMD_40));
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+
+ DBG (4, "send_scan_parameters: checkpoint 2: s = %d\n", s);
+
+ return SANE_STATUS_GOOD;
+}
+
+/* Sends scan user parameters from frontend 2100U */
+
+static SANE_Status
+send_scan_parameters_2100U (UMAX_Handle * scan)
+{
+ SANE_Status res;
+ UMAX_Status_Byte s;
+ int bpl;
+
+ /* Appears to correspond to opscan in umax_pp_low.c */
+ unsigned char opbgo[36] = {
+ 0x00, 0x00, 0xb0, 0x4f, 0xd8, 0xe7, 0xfa, 0x10, 0xef, 0xc4,
+ 0x3c, 0x71, 0x0f, 0x00, 0x04, 0x00, 0x6e, XXXX, XXXX, XXXX,
+ 0xc4, 0x7e, 0x00, XXXX, XXXX, 0xa0, 0x0a, 0x8b, 0x49, 0x2a,
+ 0xe9, 0x68, 0xdf, XXXX, 0x1a, 0x00
+ };
+
+ /* Appears to correspond to opsc53 in umax_pp_low.c */
+ unsigned char opcgo[16] = {
+ XXXX, XXXX, XXXX, XXXX, 0xec, 0x03, 0x60, XXXX, XXXX, XXXX,
+ XXXX, XXXX, XXXX, XXXX, XXXX, 0x00
+ };
+
+ /* Appears to correspond to opsc04 in umax_pp_low.c */
+ unsigned char opdgo[8] = {
+ 0x06, 0xf4, 0xff, 0x81, 0x1b, 0x00, XXXX, XXXX
+ };
+
+ unsigned char subsamp[9] = {
+ 0xff, 0xff, 0xaa, 0xaa, 0x88, 0x88, 0x88, 0x88, 0x80
+ };
+
+ const int xend =
+ scan->xskip + scan->w * scan->xsamp + (scan->xsamp + 1) / 2;
+ const int ytot = scan->hexp * scan->ysamp + 12;
+
+ opbgo[17] = scan->xskip % 256;
+ opbgo[18] = ((scan->xskip >> 8) & 0x0f) + (xend << 4);
+ opbgo[19] = xend >> 4;
+ opbgo[33] = 0x23 + ((xend & 0x1000) >> 5) + ((scan->xskip & 0x1000) >> 6);
+
+ /* bytes per line */
+
+ bpl = (scan->color ? 3 : 1) * scan->w * scan->xdpi;
+ opbgo[23] = bpl % 256;
+ opbgo[24] = 0x41 + ((bpl / 256) & 0x1f);
+
+ /* Scan height */
+
+ opcgo[0] = ytot;
+ opcgo[1] = ((ytot >> 8) & 0x3f) + (scan->yskip << 6);
+ opcgo[2] = (scan->yskip >> 2);
+ opcgo[3] = 0x50 + ((scan->yskip >> 10) & 0x0f);
+
+
+ opcgo[6] = (scan->ydpi <= 300) ? 0x00 : 0x60;
+ opcgo[8] = (scan->ydpi <= 300) ? 0x17 : 0x2F;
+ opcgo[9] = (scan->ydpi >= 300) ? 0x05 : 0x07;
+ opcgo[14] = (scan->ydpi == 600) ? 0xa4 : 0xac;
+
+
+ opcgo[7] = scan->color ? 0x2f : 0x40;
+ opcgo[10] = scan->color ? 0xb6 : 0xa6;
+ opcgo[11] = scan->color ? 0x3b : 0x2a;
+ opcgo[12] = scan->color ? 0x0c : 0x08;
+ opcgo[13] = scan->color ? 0x03 : 0xc2;
+
+ opdgo[6] = scan->color ? 0x8f : 0x86;
+ opdgo[7] = scan->color ? 0x40 : 0x20;
+
+ DBG (3, "send_scan_parameters: xskip = %d, yskip = %d\n", scan->xskip,
+ scan->yskip);
+
+ CHK (csend (scan, CMD_0));
+ CHK (csend (scan, CMD_0));
+ CHK (cwritev (scan, CMD_2, 16, opcgo, &s));
+ CHK (cwritev (scan, CMD_8, 36, opbgo, &s));
+ CHK (cwritev (scan, CMD_1, 8, opdgo, &s));
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+ DBG (4, "send_scan_parameters: checkpoint 1: s = %d\n", s);
+
+ /* Loads the new calibration data (that was computed by get_caldata) into the
+ scanner */
+
+ scan->caldata[16068] = subsamp[scan->xsamp];
+ scan->caldata[16069] = subsamp[scan->ysamp];
+ CHK (cwrite (scan, CMD_4, 16070, scan->caldata, &s));
+
+ CHK (csend (scan, CMD_40));
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+
+ DBG (4, "send_scan_parameters: checkpoint 2: s = %d\n", s);
+
+ return SANE_STATUS_GOOD;
+}
+
+/* Read raw data */
+
+static SANE_Status
+read_raw_data (UMAX_Handle * scan, unsigned char *data, int len)
+{
+ SANE_Status res;
+ UMAX_Status_Byte s;
+
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+ CHK (cread (scan, CMD_4, len, data, &s));
+
+ return SANE_STATUS_GOOD;
+}
+
+/* Read raw strip color */
+
+static SANE_Status
+read_raw_strip_color (UMAX_Handle * scan)
+{
+ /**
+ yres = 75 => ydpi = 150 => ysamp = 2 => yoff_scale = 8
+ yres = 150 => ydpi = 150 => ysamp = 1 => yoff_scale = 4
+ yres = 300 => ydpi = 300 => ysamp = 1 => yoff_scale = 2
+ yres = 600 => ydpi = 600 => ysamp = 1 => yoff_scale = 1
+ */
+
+ const int yoff_scale = 600 * scan->ysamp / scan->ydpi;
+ const int linelen = 3 * scan->w;
+
+ /*
+ yoff_scale = 8 => roff = 5 * w, goff = 1 * w, boff = 0 * w, hextra = 1
+ yoff_scale = 4 => roff = 8 * w, goff = 4 * w, boff = 0 * w, hextra = 2
+ yoff_scale = 2 => roff = 14 * w, goff = 7 * w, boff = 0 * w, hextra = 4
+ yoff_scale = 1 => roff = 26 * w, goff = 13 * w, boff = 0 * w, hextra = 8
+ */
+
+ const int hextra = 8 / yoff_scale;
+
+ SANE_Status res;
+ int lines_to_read = scan->hexp;
+
+ DBG (9, "read_raw_strip_color: hexp = %d, bh = %d\n", scan->hexp, scan->bh);
+
+ if (scan->maxh == -1)
+ {
+ DBG (10, "read_raw_strip_color: filling buffer for the first time\n");
+ if (lines_to_read > scan->bh)
+ lines_to_read = scan->bh;
+
+ CHK (read_raw_data (scan, scan->p, lines_to_read * linelen));
+ scan->maxh = lines_to_read - hextra;
+ }
+ else
+ {
+ DBG (10, "read_raw_strip_color: reading new rows into buffer\n");
+ memmove (scan->p, scan->p + (scan->bh - hextra) * linelen,
+ hextra * linelen);
+
+ if (lines_to_read > (scan->bh - hextra))
+ lines_to_read = scan->bh - hextra;
+
+ CHK (read_raw_data
+ (scan, scan->p + hextra * linelen, lines_to_read * linelen));
+ scan->maxh = lines_to_read;
+ }
+
+ scan->hexp -= lines_to_read;
+ scan->x = 0;
+ scan->y = 0;
+
+ return SANE_STATUS_GOOD;
+}
+
+/* Read raw strip grey */
+
+static SANE_Status
+read_raw_strip_gray (UMAX_Handle * scan)
+{
+ const int linelen = scan->w;
+
+ SANE_Status res;
+
+ int lines_to_read = scan->bh;
+
+ DBG (9, "read_raw_strip_gray: hexp = %d\n", scan->hexp);
+
+ if (lines_to_read > scan->hexp)
+ lines_to_read = scan->hexp;
+ scan->hexp -= lines_to_read;
+
+ CHK (read_raw_data (scan, scan->p, lines_to_read * linelen));
+
+ scan->maxh = lines_to_read;
+ scan->x = 0;
+ scan->y = 0;
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/* Read raw strip */
+
+static SANE_Status
+read_raw_strip (UMAX_Handle * scan)
+{
+ if (scan->color)
+ return read_raw_strip_color (scan);
+ else
+ return read_raw_strip_gray (scan);
+}
+
+/* Set scan user pamaters Frontend */
+
+static SANE_Status
+UMAX_set_scan_parameters (UMAX_Handle * scan,
+ const int color,
+ const int xo,
+ const int yo,
+ const int w,
+ const int h, const int xres, const int yres)
+{
+
+ /* Validate the input parameters */
+
+ int left = xo;
+ int top = yo;
+ int right = xo + w * 600 / xres;
+ int bottom = yo + h * 600 / yres;
+
+ DBG (2, "UMAX_set_scan_parameters:\n");
+ DBG (2, "color = %d \n", color);
+ DBG (2, "xo = %d, yo = %d\n", xo, yo);
+ DBG (2, "w = %d, h = %d\n", w, h);
+ DBG (2, "xres = %d, yres = %d\n", xres, yres);
+ DBG (2, "left = %d, top = %d\n", left, top);
+ DBG (2, "right = %d, bottom = %d\n", right, bottom);
+
+ if ((left < 0) || (right > UMAX_MAX_WIDTH))
+ return SANE_STATUS_INVAL;
+
+ if ((top < 0) || (bottom > UMAX_MAX_HEIGHT))
+ return SANE_STATUS_INVAL;
+
+ if (((right - left) < 10) || ((bottom - top) < 10))
+ return SANE_STATUS_INVAL;
+
+ if ((xres != 75) && (xres != 150) && (xres != 300) && (xres != 600))
+ return SANE_STATUS_INVAL;
+
+ if ((yres != 75) && (yres != 150) && (yres != 300) && (yres != 600))
+ return SANE_STATUS_INVAL;
+
+ /* If we get this far, begin initializing the data
+ structure
+ */
+
+ scan->color = color;
+ scan->w = w;
+ scan->h = h;
+ scan->xo = xo;
+ scan->yo = yo;
+
+ /*
+ The scanner has a fixed X resolution of 600 dpi, but
+ supports three choices for the Y resolution. We must
+ choose an appropriate physical resolution and the
+ corresponding sampling value.
+
+ It is not clear to me why the choice depends on
+ whether we are scanning in color or not, but the
+ original code did this and I didn't want to mess
+ with it.
+
+ Physical X resolution choice:
+ xres = 75 => xdpi = 600 (xsamp = 8)
+ xres = 150 => xdpi = 600 (xsamp = 4)
+ xres = 300 => xdpi = 600 (xsamp = 2)
+ xres = 600 => xdpi = 600 (xsamp = 1)
+
+ Physical Y resolution choice (if color):
+ yres = 75 => ydpi = 150 (ysamp = 2)
+ yres = 150 => ydpi = 150 (ysamp = 1)
+ yres = 300 => ydpi = 300 (ysamp = 1)
+ yres = 600 => ydpi = 600 (ysamp = 1)
+
+ Physical Y resolution choice (if not color):
+ yres = 75 => ydpi = 300 (ysamp = 4)
+ yres = 150 => ydpi = 300 (ysamp = 2)
+ yres = 300 => ydpi = 300 (ysamp = 1)
+ yres = 600 => ydpi = 600 (ysamp = 1)
+ */
+
+ scan->xdpi = 600;
+ if (yres <= 150 && color)
+ scan->ydpi = 150;
+ else if (yres > 300)
+ scan->ydpi = 600;
+ else
+ scan->ydpi = 300;
+
+ scan->xsamp = scan->xdpi / xres;
+ scan->ysamp = scan->ydpi / yres;
+
+ return SANE_STATUS_GOOD;
+}
+
+/* Start actual scan 1220U */
+
+static SANE_Status
+UMAX_start_scan (UMAX_Handle * scan)
+{
+ SANE_Status res;
+ int linelen;
+ int yd;
+
+ DBG (3, "UMAX_start_scan called\n");
+
+ if (scan->color)
+ {
+ const int yoff_scale = 600 * scan->ysamp / scan->ydpi;
+ const int hextra = 8 / yoff_scale;
+
+ linelen = 3 * scan->w;
+ scan->hexp = scan->h + hextra;
+ }
+ else
+ {
+ linelen = scan->w;
+ scan->hexp = scan->h;
+ }
+
+ scan->bh = BUFFER_SIZE / linelen;
+
+ scan->p = malloc (scan->bh * linelen);
+ if (scan->p == 0)
+ return SANE_STATUS_NO_MEM;
+
+ DBG (4, "UMAX_start_scan: bh = %d, linelen = %d\n", scan->bh, linelen);
+
+ scan->maxh = -1;
+ scan->done = 0;
+
+ /* Initialize the scanner and position the scan head */
+
+ CHK (umaxinit (scan));
+
+ /* This scans in the black and white calibration strip that
+ * is located under the scanner's lid. The scan of that strip
+ * is used to pick correct values for the CCD calibration
+ * values
+ */
+
+ scan->scanner_ypos = 0;
+ CHK (move (scan, 196, UMAX_NOT_FINE));
+ CHK (find_zero (scan));
+ CHK (move (scan, scan->scanner_yorg - 232 - scan->scanner_ypos, UMAX_FINE));
+ CHK (get_caldata (scan, scan->color));
+
+ /* This moves the head back to the starting position */
+
+ yd = scan->scanner_yorg + scan->yo - scan->scanner_ypos;
+ if (yd < 0)
+ CHK (move (scan, yd, UMAX_FINE));
+ if (yd > 300)
+ CHK (move (scan, (yd - 20) / 2, UMAX_NOT_FINE));
+ yd = scan->scanner_yorg + scan->yo - scan->scanner_ypos;
+
+ scan->yskip = yd / (600 / scan->ydpi);
+ scan->xskip = scan->xo / (600 / scan->xdpi);
+
+ /* Read in the first chunk of raw data */
+
+ CHK (send_scan_parameters (scan));
+ CHK (read_raw_strip (scan));
+
+ DBG (4, "UMAX_start_scan successful\n");
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/* Start actual scan 2100U */
+
+static SANE_Status
+UMAX_start_scan_2100U (UMAX_Handle * scan)
+{
+ SANE_Status res;
+ int linelen;
+ int yd;
+
+ DBG (3, "UMAX_start_scan called\n");
+
+ if (scan->color)
+ {
+ const int yoff_scale = 600 * scan->ysamp / scan->ydpi;
+ const int hextra = 8 / yoff_scale;
+
+ linelen = 3 * scan->w;
+ scan->hexp = scan->h + hextra;
+ }
+ else
+ {
+ linelen = scan->w;
+ scan->hexp = scan->h;
+ }
+
+ scan->bh = BUFFER_SIZE / linelen;
+
+ scan->p = malloc (scan->bh * linelen);
+ if (scan->p == 0)
+ return SANE_STATUS_NO_MEM;
+
+ DBG (4, "UMAX_start_scan: bh = %d, linelen = %d\n", scan->bh, linelen);
+
+ scan->maxh = -1;
+ scan->done = 0;
+
+ /* Initialize the scanner and position the scan head */
+
+ CHK (umaxinit_2100U (scan));
+
+ /* This scans in the black and white calibration strip that
+ * is located under the scanner's lid. The scan of that strip
+ * is used to pick correct values for the CCD calibration
+ * values
+ */
+
+ scan->scanner_ypos = 0;
+ CHK (move_2100U (scan, 196, UMAX_NOT_FINE));
+ CHK (find_zero_2100U (scan));
+ CHK (move_2100U (scan, scan->scanner_yorg - 232 - scan->scanner_ypos, UMAX_FINE));
+ CHK (get_caldata_2100U (scan, scan->color));
+
+ /* This moves the head back to the starting position */
+
+ yd = scan->scanner_yorg + scan->yo - scan->scanner_ypos;
+ if (yd < 0)
+ CHK (move_2100U (scan, yd, UMAX_FINE));
+ if (yd > 300)
+ CHK (move_2100U (scan, (yd - 20) / 2, UMAX_NOT_FINE));
+ yd = scan->scanner_yorg + scan->yo - scan->scanner_ypos;
+
+ scan->yskip = yd / (600 / scan->ydpi);
+ scan->xskip = scan->xo / (600 / scan->xdpi);
+
+ /* Read in the first chunk of raw data */
+
+ CHK (send_scan_parameters_2100U (scan));
+ CHK (read_raw_strip (scan));
+
+ DBG (4, "UMAX_start_scan successful\n");
+
+ return SANE_STATUS_GOOD;
+}
+
+/* Set lamp state */
+
+static SANE_Status
+UMAX_set_lamp_state (UMAX_Handle * scan, UMAX_Lamp_State state)
+{
+ SANE_Status res;
+
+ DBG (3, "UMAX_set_lamp_state: state = %d\n", (int) state);
+
+ CHK (csend (scan, CMD_0));
+ CHK (cwritev_opc1_lamp_ctrl (scan, state));
+ return SANE_STATUS_GOOD;
+}
+
+/* Park head 1220U */
+
+static SANE_Status
+UMAX_park_head (UMAX_Handle * scan)
+{
+ SANE_Status res;
+ UMAX_Status_Byte s;
+ int i;
+
+ DBG (3, "UMAX_park_head called\n");
+
+ CHK (csend (scan, CMD_0));
+ /* WARNING: Must call cwritev_opc1_lamp_ctrl before cwritev_opb3_restore,
+ * otherwise the head moves the wrong way and makes ugly grinding noises. */
+
+ CHK (cwritev_opc1_lamp_ctrl (scan, UMAX_LAMP_ON));
+ CHK (cwritev_opb3_restore (scan));
+
+ for (i = 0; i < 60; ++i)
+ {
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+ DBG (4, "UMAX_park_head: s = %#x\n", s);
+ if ((s & 0x40) != 0)
+ break;
+ DBG (4, "UMAX_park_head: sleeping\n");
+ usleep (500000);
+ }
+
+ scan->scanner_ypos = 0;
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/* Park head 2100U */
+
+static SANE_Status
+UMAX_park_head_2100U (UMAX_Handle * scan)
+{
+ SANE_Status res;
+ UMAX_Status_Byte s;
+ int i;
+
+ DBG (3, "UMAX_park_head called\n");
+
+ CHK (csend (scan, CMD_0));
+ /* WARNING: Must call cwritev_opc1_lamp_ctrl before cwritev_opb3_restore,
+ * otherwise the head moves the wrong way and makes ugly grinding noises. */
+
+ CHK (cwritev_opc1_lamp_ctrl (scan, UMAX_LAMP_ON));
+ CHK (cwritev_opb3_restore_2100U (scan));
+
+ for (i = 0; i < 60; ++i)
+ {
+ CHK (cread (scan, CMD_2, 0, NULL, &s));
+ DBG (4, "UMAX_park_head: s = %#x\n", s);
+ if ((s & 0x40) != 0)
+ break;
+ DBG (4, "UMAX_park_head: sleeping\n");
+ usleep (500000);
+ }
+
+ /* CHK (csend (scan, CMD_0));
+ CHK (csend (scan, CMD_0)); */
+
+ scan->scanner_ypos = 0;
+
+ return SANE_STATUS_GOOD;
+}
+
+
+/* Finish scan */
+
+static SANE_Status
+UMAX_finish_scan (UMAX_Handle * scan)
+{
+ DBG (3, "UMAX_finish_scan:\n");
+
+ if (scan->p)
+ free (scan->p);
+ scan->p = NULL;
+ return SANE_STATUS_GOOD;
+}
+
+
+/* RGB decoding for a color scan */
+
+static SANE_Status
+UMAX_get_rgb (UMAX_Handle * scan, unsigned char *rgb)
+{
+
+ if (scan->color)
+ {
+ const int linelen = 3 * scan->w;
+ const int yoff_scale = 600 * scan->ysamp / scan->ydpi;
+ const int roff = (8 / yoff_scale * 3 + 2) * scan->w;
+ const int goff = (4 / yoff_scale * 3 + 1) * scan->w;
+ const int boff = 0;
+
+ unsigned char *base = scan->p + (scan->y * linelen) + scan->x;
+
+ rgb[0] = base[roff];
+ rgb[1] = base[goff];
+ rgb[2] = base[boff];
+ }
+ else
+ {
+ const int linelen = scan->w;
+ unsigned char *base = scan->p + (scan->y * linelen) + (scan->x);
+
+ rgb[0] = base[0];
+ rgb[1] = base[0];
+ rgb[2] = base[0];
+ }
+
+ if (!(((scan->x + 1) == scan->w) && ((scan->y + 1) == scan->maxh)))
+ {
+ ++scan->x;
+ if (scan->x == scan->w)
+ {
+ ++scan->y;
+ scan->x = 0;
+ }
+ return SANE_STATUS_GOOD;
+ }
+
+ if (scan->hexp <= 0)
+ {
+ DBG (4, "UMAX_get_rgb: setting done flag\n");
+ scan->done = 1;
+ return SANE_STATUS_GOOD;
+ }
+
+ return read_raw_strip (scan);
+}
+
+/* Close device */
+
+static SANE_Status
+UMAX_close_device (UMAX_Handle * scan)
+{
+ DBG (3, "UMAX_close_device:\n");
+ sanei_usb_close (scan->fd);
+ return SANE_STATUS_GOOD;
+}
+
+/* Open device */
+
+static SANE_Status
+UMAX_open_device (UMAX_Handle * scan, const char *dev)
+{
+ SANE_Word vendor;
+ SANE_Word product;
+ SANE_Status res;
+
+ DBG (3, "UMAX_open_device: `%s'\n", dev);
+
+ res = sanei_usb_open (dev, &scan->fd);
+ if (res != SANE_STATUS_GOOD)
+ {
+ DBG (1, "UMAX_open_device: couldn't open device `%s': %s\n", dev,
+ sane_strstatus (res));
+ return res;
+ }
+
+#ifndef NO_AUTODETECT
+ /* We have opened the device. Check that it is a USB scanner. */
+ if (sanei_usb_get_vendor_product (scan->fd, &vendor, &product) !=
+ SANE_STATUS_GOOD)
+ {
+ DBG (1, "UMAX_open_device: sanei_usb_get_vendor_product failed\n");
+ /* This is not a USB scanner, or SANE or the OS doesn't support it. */
+ sanei_usb_close (scan->fd);
+ scan->fd = -1;
+ return SANE_STATUS_UNSUPPORTED;
+ }
+
+ /* Make sure we have a UMAX scanner */
+ if (vendor != 0x1606)
+ {
+ DBG (1, "UMAX_open_device: incorrect vendor\n");
+ sanei_usb_close (scan->fd);
+ scan->fd = -1;
+ return SANE_STATUS_UNSUPPORTED;
+ }
+
+ /* Now check whether it is a scanner we know about */
+ switch (product)
+ {
+ case ASTRA_2000U:
+ /* The UMAX Astra 2000U is only partially supported by
+ this driver. Expect severe color problems! :)
+ */
+ DBG (1,
+ "UMAX_open_device: Scanner is a 2000U. Expect color problems :)\n");
+ scan->model = ASTRA_2000U;
+ break;
+ case ASTRA_2100U:
+ scan->model = ASTRA_2100U;
+ break;
+ case ASTRA_1220U:
+ scan->model = ASTRA_1220U;
+ break;
+ default:
+ DBG (1, "UMAX_open_device: unknown product number\n");
+ sanei_usb_close (scan->fd);
+ scan->fd = -1;
+ return SANE_STATUS_UNSUPPORTED;
+ }
+#endif
+
+ res = csend (scan, CMD_0);
+ if (res != SANE_STATUS_GOOD)
+ UMAX_close_device (scan);
+ CHK (res);
+
+ res = xxxops (scan);
+ if (res != SANE_STATUS_GOOD)
+ UMAX_close_device (scan);
+ CHK (res);
+
+ return SANE_STATUS_GOOD;
+}
+
+/* Get scanner model name */
+
+static const char *
+UMAX_get_device_name (UMAX_Handle * scan)
+{
+ switch (scan->model)
+ {
+ case ASTRA_1220U:
+ return "Astra 1220U";
+ case ASTRA_2000U:
+ return "Astra 2000U";
+ case ASTRA_2100U:
+ return "Astra 2100U";
+ }
+ return "Unknown";
+}
+
+/* End */