diff options
Diffstat (limited to 'backend/umax1220u-common.c')
| -rw-r--r-- | backend/umax1220u-common.c | 2386 |
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 */ |