summaryrefslogtreecommitdiff
path: root/backend/canon630u-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/canon630u-common.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/canon630u-common.c')
-rw-r--r--backend/canon630u-common.c1656
1 files changed, 1656 insertions, 0 deletions
diff --git a/backend/canon630u-common.c b/backend/canon630u-common.c
new file mode 100644
index 0000000..4417141
--- /dev/null
+++ b/backend/canon630u-common.c
@@ -0,0 +1,1656 @@
+/*
+ (c) 2001,2002 Nathan Rutman nathan@gordian.com 10/17/01
+
+ 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.
+*/
+
+/*
+ Communication, calibration, and scanning with the Canon CanoScan FB630U
+ flatbed scanner under linux.
+
+ Reworked into SANE-compatible format.
+
+ The usb-parallel port interface chip is GL640usb, on the far side of
+ which is an LM9830 parallel-port scanner-on-a-chip.
+
+ This code has not been tested on anything other than Linux/i386.
+*/
+
+#include <errno.h>
+#include <fcntl.h> /* open */
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h> /* usleep */
+#include <time.h>
+#include <math.h> /* exp() */
+#ifdef HAVE_OS2_H
+#include <sys/types.h> /* mode_t */
+#endif
+#include <sys/stat.h>
+#include "lm9830.h"
+
+#define USB_TYPE_VENDOR (0x02 << 5)
+#define USB_RECIP_DEVICE 0x00
+#define USB_DIR_OUT 0x00
+#define USB_DIR_IN 0x80
+
+/* Assign status and verify a good return code */
+#define CHK(A) {if( (status = A) != SANE_STATUS_GOOD ) { \
+ DBG( 1, "Failure on line of %s: %d\n", __FILE__, \
+ __LINE__ ); return A; }}
+
+
+typedef SANE_Byte byte;
+
+
+/*****************************************************
+ GL640 communication primitives
+ Provides I/O routines to Genesys Logic GL640USB USB-IEEE1284 parallel
+ port bridge. Used in HP3300c, Canon FB630u.
+******************************************************/
+
+/* Register codes for the bridge. These are NOT the registers for the
+ scanner chip on the other side of the bridge. */
+typedef enum
+{
+ GL640_BULK_SETUP = 0x82,
+ GL640_EPP_ADDR = 0x83,
+ GL640_EPP_DATA_READ = 0x84,
+ GL640_EPP_DATA_WRITE = 0x85,
+ GL640_SPP_STATUS = 0x86,
+ GL640_SPP_CONTROL = 0x87,
+ GL640_SPP_DATA = 0x88,
+ GL640_GPIO_OE = 0x89,
+ GL640_GPIO_READ = 0x8a,
+ GL640_GPIO_WRITE = 0x8b
+}
+GL640_Request;
+
+/* Write to the usb-parallel port bridge. */
+static SANE_Status
+gl640WriteControl (int fd, GL640_Request req, byte * data, unsigned int size)
+{
+ SANE_Status status;
+ status = sanei_usb_control_msg (fd,
+ /* rqttype */ USB_TYPE_VENDOR |
+ USB_RECIP_DEVICE | USB_DIR_OUT /*0x40? */ ,
+ /* rqt */ (size > 1) ? 0x04 : 0x0C,
+ /* val */ (SANE_Int) req,
+ /* ind */ 0,
+ /* len */ size,
+ /* dat */ data);
+ if (status != SANE_STATUS_GOOD)
+ DBG (1, "gl640WriteControl error\n");
+ return status;
+}
+
+
+/* Read from the usb-parallel port bridge. */
+static SANE_Status
+gl640ReadControl (int fd, GL640_Request req, byte * data, unsigned int size)
+{
+ SANE_Status status;
+ status = sanei_usb_control_msg (fd,
+ /* rqttype */ USB_TYPE_VENDOR |
+ USB_RECIP_DEVICE | USB_DIR_IN /*0xc0? */ ,
+ /* rqt */ (size > 1) ? 0x04 : 0x0C,
+ /* val */ (SANE_Int) req,
+ /* ind */ 0,
+ /* len */ size,
+ /* dat */ data);
+ if (status != SANE_STATUS_GOOD)
+ DBG (1, "gl640ReadControl error\n");
+ return status;
+}
+
+
+/* Wrappers to read or write a single byte to the bridge */
+static inline SANE_Status
+gl640WriteReq (int fd, GL640_Request req, byte data)
+{
+ return gl640WriteControl (fd, req, &data, 1);
+}
+
+static inline SANE_Status
+gl640ReadReq (int fd, GL640_Request req, byte * data)
+{
+ return gl640ReadControl (fd, req, data, 1);
+}
+
+
+/* Write USB bulk data
+ setup is an apparently scanner-specific sequence:
+ {(0=read, 1=write), 0x00, 0x00, 0x00, sizelo, sizehi, 0x00, 0x00}
+ hp3400: setup[1] = 0x01
+ fb630u: setup[2] = 0x80
+*/
+static SANE_Status
+gl640WriteBulk (int fd, byte * setup, byte * data, size_t size)
+{
+ SANE_Status status;
+ setup[0] = 1;
+ setup[4] = (size) & 0xFF;
+ setup[5] = (size >> 8) & 0xFF;
+
+ CHK (gl640WriteControl (fd, GL640_BULK_SETUP, setup, 8));
+
+ status = sanei_usb_write_bulk (fd, data, &size);
+ if (status != SANE_STATUS_GOOD)
+ DBG (1, "gl640WriteBulk error\n");
+
+ return status;
+}
+
+
+/* Read USB bulk data
+ setup is an apparently scanner-specific sequence:
+ {(0=read, 1=write), 0x00, 0x00, 0x00, sizelo, sizehi, 0x00, 0x00}
+ fb630u: setup[2] = 0x80
+*/
+static SANE_Status
+gl640ReadBulk (int fd, byte * setup, byte * data, size_t size)
+{
+ SANE_Status status;
+ setup[0] = 0;
+ setup[4] = (size) & 0xFF;
+ setup[5] = (size >> 8) & 0xFF;
+
+ CHK (gl640WriteControl (fd, GL640_BULK_SETUP, setup, 8));
+
+ status = sanei_usb_read_bulk (fd, data, &size);
+ if (status != SANE_STATUS_GOOD)
+ DBG (1, "gl640ReadBulk error\n");
+
+ return status;
+}
+
+
+/*****************************************************
+ LM9830 communication primitives
+ parallel-port scanner-on-a-chip.
+******************************************************/
+
+/* write 1 byte to a LM9830 register address */
+static SANE_Status
+write_byte (int fd, byte addr, byte val)
+{
+ SANE_Status status;
+ DBG (14, "write_byte(fd, 0x%02x, 0x%02x);\n", addr, val);
+ CHK (gl640WriteReq (fd, GL640_EPP_ADDR, addr));
+ CHK (gl640WriteReq (fd, GL640_EPP_DATA_WRITE, val));
+ return status;
+}
+
+
+/* read 1 byte from a LM9830 register address */
+static SANE_Status
+read_byte (int fd, byte addr, byte * val)
+{
+ SANE_Status status;
+ CHK (gl640WriteReq (fd, GL640_EPP_ADDR, addr));
+ CHK (gl640ReadReq (fd, GL640_EPP_DATA_READ, val));
+ DBG (14, "read_byte(fd, 0x%02x, &result); /* got %02x */\n", addr, *val);
+ return status;
+}
+
+
+static byte bulk_setup_data[] = { 0, 0, 0x80, 0, 0, 0, 0, 0 };
+
+/* Bulk write */
+static SANE_Status
+write_bulk (int fd, unsigned int addr, void *src, size_t count)
+{
+ SANE_Status status;
+
+ DBG (13, "write_bulk(fd, 0x%02x, buf, 0x%04lx);\n", addr, (u_long) count);
+
+ if (!src)
+ {
+ DBG (1, "write_bulk: bad src\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ /* destination address */
+ CHK (gl640WriteReq (fd, GL640_EPP_ADDR, addr));
+ /* write */
+ CHK (gl640WriteBulk (fd, bulk_setup_data, src, count));
+ return status;
+}
+
+
+/* Bulk read */
+static SANE_Status
+read_bulk (int fd, unsigned int addr, void *dst, size_t count)
+{
+ SANE_Status status;
+
+ DBG (13, "read_bulk(fd, 0x%02x, buf, 0x%04lx);\n", addr, (u_long) count);
+
+ if (!dst)
+ {
+ DBG (1, "read_bulk: bad dest\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ /* destination address */
+ CHK (gl640WriteReq (fd, GL640_EPP_ADDR, addr));
+ /* read */
+ CHK (gl640ReadBulk (fd, bulk_setup_data, dst, count));
+ return status;
+}
+
+
+
+/*****************************************************
+ useful macro routines
+******************************************************/
+
+/* write a 16-bit int to two sequential registers */
+static SANE_Status
+write_word (int fd, unsigned int addr, unsigned int data)
+{
+ SANE_Status status;
+ /* MSB */
+ CHK (write_byte (fd, addr, (data >> 8) & 0xff));
+ /* LSB */
+ CHK (write_byte (fd, addr + 1, data & 0xff));
+ return status;
+}
+
+
+/* write multiple bytes, one at a time (non-bulk) */
+static SANE_Status
+write_many (int fd, unsigned int addr, void *src, size_t count)
+{
+ SANE_Status status;
+ size_t i;
+
+ DBG (14, "multi write %lu\n", (u_long) count);
+ for (i = 0; i < count; i++)
+ {
+ DBG (15, " %04lx:%02x", (u_long) (addr + i), ((byte *) src)[i]);
+ status = write_byte (fd, addr + i, ((byte *) src)[i]);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (15, "\n");
+ return status;
+ }
+ }
+ DBG (15, "\n");
+ return SANE_STATUS_GOOD;
+}
+
+
+/* read multiple bytes, one at a time (non-bulk) */
+static SANE_Status
+read_many (int fd, unsigned int addr, void *dst, size_t count)
+{
+ SANE_Status status;
+ size_t i;
+ byte val;
+
+ DBG (14, "multi read %lu\n", (u_long) count);
+ for (i = 0; i < count; i++)
+ {
+ status = read_byte (fd, addr + i, &val);
+ ((byte *) dst)[i] = val;
+ DBG (15, " %04lx:%02x", (u_long) (addr + i), ((byte *) dst)[i]);
+ /* on err, return number of success */
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (15, "\n");
+ return status;
+ }
+ }
+ DBG (15, "\n");
+ return SANE_STATUS_GOOD;
+}
+
+
+/* Poll addr until result & mask = val */
+static int
+read_poll_flag (int fd,
+ unsigned int addr, unsigned int mask, unsigned int val)
+{
+ SANE_Status status;
+ byte result = 0;
+ time_t start_time = time (NULL);
+
+ DBG (12, "read_poll_flag...\n");
+ do
+ {
+ status = read_byte (fd, addr, &result);
+ if (status != SANE_STATUS_GOOD)
+ return -1;
+ /* Give it a minute */
+ if ((time (NULL) - start_time) > 60)
+ {
+ DBG (1, "read_poll_flag: timed out (%d)\n", result);
+ return -1;
+ }
+ usleep (100000);
+ }
+ while ((result & mask) != val);
+ return result;
+}
+
+
+/* Keep reading addr until results >= min */
+static int
+read_poll_min (int fd, unsigned int addr, unsigned int min)
+{
+ SANE_Status status;
+ byte result;
+ time_t start_time = time (NULL);
+
+ DBG (12, "waiting...\n");
+ do
+ {
+ status = read_byte (fd, addr, &result);
+ if (status != SANE_STATUS_GOOD)
+ return -1;
+ /* Give it a minute */
+ if ((time (NULL) - start_time) > 60)
+ {
+ DBG (1, "read_poll_min: timed out (%d < %d)\n", result, min);
+ return -1;
+ }
+ /* no sleep here, or calibration gets unhappy. */
+ }
+ while (result < min);
+ return result;
+}
+
+
+/* Bulk read "ks" kilobytes + "remainder" bytes of data, to a buffer if the
+ buffer is valid. */
+static int
+read_bulk_size (int fd, int ks, int remainder, byte * dest, int destsize)
+{
+ byte *buf;
+ int bytes = (ks - 1) * 1024 + remainder;
+ int dropdata = ((dest == 0) || (destsize < bytes));
+
+ if (bytes < 0)
+ {
+ DBG (1, "read_bulk_size: invalid size %02x (%d)\n", ks, bytes);
+ return -1;
+ }
+ if (destsize && (destsize < bytes))
+ {
+ DBG (3, "read_bulk_size: more data than buffer (%d/%d)\n",
+ destsize, bytes);
+ bytes = destsize;
+ }
+
+ if (bytes == 0)
+ return 0;
+
+ if (dropdata)
+ {
+ buf = malloc (bytes);
+ DBG (3, " ignoring data ");
+ }
+ else
+ buf = dest;
+
+ read_bulk (fd, 0x00, buf, bytes);
+
+ if (dropdata)
+ free (buf);
+ return bytes;
+}
+
+
+
+/*****************************************************
+
+ fb630u calibration and scan
+
+******************************************************/
+
+/* data structures and constants */
+
+typedef struct CANON_Handle
+{
+ int fd; /* scanner fd */
+ int x1, x2, y1, y2; /* in pixels, 600 dpi */
+ int width, height; /* at scan resolution */
+ int resolution; /* dpi */
+ char *fname; /* output file name */
+ FILE *fp; /* output file pointer (for reading) */
+ char *buf, *ptr; /* data buffer */
+ unsigned char gain; /* static analog gain, 0 - 31 */
+ double gamma; /* gamma correction */
+ int flags;
+#define FLG_GRAY 0x01 /* grayscale */
+#define FLG_FORCE_CAL 0x02 /* force calibration */
+#define FLG_BUF 0x04 /* save scan to buffer instead of file */
+#define FLG_NO_INTERLEAVE 0x08 /* don't interleave r,g,b pixels; leave them
+ in row format */
+#define FLG_PPM_HEADER 0x10 /* include PPM header in scan file */
+}
+CANON_Handle;
+
+
+/* offset/gain calibration file name */
+#define CAL_FILE_OGN "/tmp/canon.cal"
+
+/* at 600 dpi */
+#define CANON_MAX_WIDTH 5100 /* 8.5in */
+/* this may not be right */
+#define CANON_MAX_HEIGHT 7000 /* 11.66in */
+
+/* scanline end-of-line data byte, returned after each r,g,b segment,
+ specific to the FB630u */
+#define SCANLINE_END 0x0c
+
+
+static const byte seq002[] =
+ { /*r08 */ 0x04, /*300 dpi */ 0x1a, 0x00, 0x0d, 0x4c, 0x2f, 0x00, 0x01,
+/*r10 */ 0x07, 0x04, 0x05, 0x06, 0x07, 0x00, 0x00, 0x00, 0x03, 0x00, 0x00, 0x00, 0x03, 0x25, 0x00,
+0x4b, /*r20 */ 0x15, 0xe0, /*data px start */ 0x00, 0x4b, /*data px end */ 0x14, 0x37, 0x15, 0x00 };
+
+static const byte seq003[] =
+ { 0x02, 0x00, 0x00, /*lights out */ 0x03, 0xff, 0x00, 0x01, 0x03, 0xff,
+0x00, 0x01, 0x03, 0xff, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x01, 0x01, 0x00, 0x00, 0x00, 0x00, 0x06,
+0x1d, 0x00, 0x13, 0x04, 0x1a, 0x01, 0x04, 0x00, 0x00, 0x00, 0x00, 0x57, 0x02, 0x00, 0x3c, 0x35, 0x94,
+0x00, 0x10, 0x08, 0x3f, 0x2b, 0x91, 0x00, 0x00, 0x01, 0x00, 0x80, 0x00 };
+
+
+/* Scanner init, called at calibration and scan time. Returns 1 if this
+ was the first time the scanner was plugged in, 0 afterward, and
+ -1 on error. */
+static int
+init (int fd)
+{
+ byte result, rv;
+
+ if (gl640WriteReq (fd, GL640_GPIO_OE, 0x71) != SANE_STATUS_GOOD) {
+ DBG(1, "Initial write request failed.\n");
+ return -1;
+ }
+ /* Gets 0x04 or 0x05 first run, gets 0x64 subsequent runs. */
+ if (gl640ReadReq (fd, GL640_GPIO_READ, &rv) != SANE_STATUS_GOOD) {
+ DBG(1, "Initial read request failed.\n");
+ return -1;
+ }
+ gl640WriteReq (fd, GL640_GPIO_OE, 0x70);
+
+ DBG (2, "init query: %x\n", rv);
+ if (rv != 0x64)
+ {
+ gl640WriteReq (fd, GL640_GPIO_WRITE, 0x00);
+ gl640WriteReq (fd, GL640_GPIO_WRITE, 0x40);
+ }
+
+ gl640WriteReq (fd, GL640_SPP_DATA, 0x99);
+ gl640WriteReq (fd, GL640_SPP_DATA, 0x66);
+ gl640WriteReq (fd, GL640_SPP_DATA, 0xcc);
+ gl640WriteReq (fd, GL640_SPP_DATA, 0x33);
+ /* parallel port setting */
+ write_byte (fd, PARALLEL_PORT, 0x06);
+ /* sensor control settings */
+ write_byte (fd, 0x0b, 0x0d);
+ write_byte (fd, 0x0c, 0x4c);
+ write_byte (fd, 0x0d, 0x2f);
+ read_byte (fd, 0x0b, &result); /* wants 0d */
+ read_byte (fd, 0x0c, &result); /* wants 4c */
+ read_byte (fd, 0x0d, &result); /* wants 2f */
+ /* parallel port noise filter */
+ write_byte (fd, 0x70, 0x73);
+
+ DBG (2, "init post-reset: %x\n", rv);
+ /* Returns 1 if this was the first time the scanner was plugged in. */
+ return (rv != 0x64);
+}
+
+
+/* Turn off the lamps */
+static void
+lights_out (int fd)
+{
+ write_word (fd, LAMP_R_ON, 0x3fff);
+ write_word (fd, LAMP_R_OFF, 0x0001);
+ write_word (fd, LAMP_G_ON, 0x3fff);
+ write_word (fd, LAMP_G_OFF, 0x0001);
+ write_word (fd, LAMP_B_ON, 0x3fff);
+ write_word (fd, LAMP_B_OFF, 0x0001);
+}
+
+
+/* Do the scan and save the resulting image as r,g,b interleaved PPM
+ file. */
+static SANE_Status
+do_scan (CANON_Handle * s)
+{
+ SANE_Status status = SANE_STATUS_GOOD;
+ int numbytes, datasize, level = 0, line = 0, pixel = 0;
+ byte *buf, *ptr, *redptr;
+ FILE *fp;
+
+#define BUFSIZE 0xf000
+ buf = malloc (BUFSIZE);
+ if (!buf)
+ return SANE_STATUS_NO_MEM;
+
+ if (s->flags & FLG_BUF)
+ {
+ /* read the whole thing into buf */
+ if (!s->buf)
+ return SANE_STATUS_NO_MEM;
+ s->ptr = s->buf;
+ fp = NULL;
+ }
+ else
+ {
+ fp = fopen (s->fname, "w");
+ if (!fp)
+ {
+ free (buf);
+ DBG (1, "err:%s when opening %s\n", strerror (errno), s->fname);
+ return SANE_STATUS_IO_ERROR;
+ }
+ }
+ if (fp && (s->flags & FLG_PPM_HEADER))
+ /* PPM format header */
+ fprintf (fp, "P6\n%d %d\n255\n", s->width, s->height);
+
+ /* lights off */
+ write_byte (s->fd, COMMAND, 0x08);
+ /* lights on */
+ write_byte (s->fd, COMMAND, 0x00);
+ /* begin scan */
+ write_byte (s->fd, COMMAND, 0x03);
+
+ ptr = redptr = buf;
+ while (line < s->height)
+ {
+ datasize = read_poll_min (s->fd, IMAGE_DATA_AVAIL, 2);
+ if (datasize < 0)
+ {
+ DBG (1, "no data\n");
+ break;
+ }
+ DBG (12, "scan line %d %dk\n", line, datasize - 1);
+ /* Read may cause scan head to move */
+ numbytes = read_bulk_size (s->fd, datasize, 0, ptr, BUFSIZE - level);
+ if (numbytes < 0)
+ {
+ status = SANE_STATUS_INVAL;
+ break;
+ }
+ /* Data coming back is "width" bytes Red data followed by 0x0c,
+ width bytes Green, 0x0c, width bytes Blue, 0x0c, repeat for
+ "height" lines. */
+ if (s->flags & FLG_NO_INTERLEAVE)
+ {
+ /* number of full lines */
+ line += (numbytes + level) / (s->width * 3);
+ /* remainder (partial line) */
+ level = (numbytes + level) % (s->width * 3);
+ /* but if last line, don't store extra */
+ if (line >= s->height)
+ numbytes -= (line - s->height) * s->width * 3 + level;
+ if (fp)
+ fwrite (buf, 1, numbytes, fp);
+ else
+ {
+ memcpy (s->ptr, buf, numbytes);
+ s->ptr += numbytes;
+ }
+ }
+ else
+ {
+ /* Contorsions to convert data from line-by-line RGB to
+ byte-by-byte RGB, without reading in the whole buffer first.
+ We use the sliding window redptr with the temp buffer buf. */
+ ptr += numbytes; /* point to the end of data */
+ /* while we have RGB triple data */
+ while (redptr + s->width + s->width <= ptr)
+ {
+ if (*redptr == SCANLINE_END)
+ DBG (13, "-%d- ", pixel);
+ if (fp)
+ {
+ /* for PPM binary (P6), 3-byte RGB pixel */
+ fwrite (redptr, 1, 1, fp); /* Red */
+ fwrite (redptr + s->width, 1, 1, fp); /* Green */
+ fwrite (redptr + s->width + s->width, 1, 1, fp); /* Blue */
+ /* for PPM ascii (P3)
+ fprintf(fp, "%3d %3d %3d\n", *redptr,
+ *(redptr + s->width),
+ *(redptr + s->width + s->width));
+ */
+ }
+ else
+ {
+ /* R */ *s->ptr = *redptr;
+ s->ptr++;
+ /* G */ *s->ptr = *(redptr + s->width);
+ s->ptr++;
+ /* B */ *s->ptr = *(redptr + s->width + s->width);
+ s->ptr++;
+ }
+ redptr++;
+ pixel++;
+ if (pixel && !(pixel % s->width))
+ {
+ /* end of a line, move redptr to the next Red section */
+ line++;
+ redptr += s->width + s->width;
+#if 0
+ /* progress */
+ printf ("%2d%%\r", line * 100 / s->height);
+ fflush (stdout);
+#endif
+ /* don't record any extra */
+ if (line >= s->height)
+ break;
+ }
+ }
+ /* keep the extra around for next time */
+ level = ptr - redptr;
+ if (level < 0)
+ level = 0;
+ memmove (buf, redptr, level);
+ ptr = buf + level;
+ redptr = buf;
+ }
+ }
+
+ if (fp)
+ {
+ fclose (fp);
+ DBG (6, "created scan file %s\n", s->fname);
+ }
+ free (buf);
+ DBG (6, "%d lines, %d pixels, %d extra bytes\n", line, pixel, level);
+
+ /* motor off */
+ write_byte (s->fd, COMMAND, 0x00);
+
+ return status;
+}
+
+
+static int
+wait_for_return (int fd)
+{
+ return read_poll_flag (fd, STATUS, STATUS_HOME, STATUS_HOME);
+}
+
+
+static SANE_Status compute_ogn (char *calfilename);
+
+
+/* This is the calibration rountine Win2k goes through when the scanner is
+ first plugged in.
+ Original usb trace from Win2k with USBSnoopy ("usb sniffer for w2k"
+ http://benoit.papillault.free.fr/speedtouch/sniff-2000.en.php3)
+ */
+static int
+plugin_cal (CANON_Handle * s)
+{
+ SANE_Status status;
+ unsigned int temp;
+ byte result;
+ byte *buf;
+ int fd = s->fd;
+
+ DBG (6, "Calibrating\n");
+
+ /* reserved? */
+ read_byte (fd, 0x69, &result); /* wants 02 */
+
+ /* parallel port setting */
+ write_byte (fd, PARALLEL_PORT, 0x06);
+
+ write_many (fd, 0x08, (byte *) seq002, sizeof (seq002));
+ /* addr 0x28 isn't written */
+ write_many (fd, 0x29, (byte *) seq003, sizeof (seq003));
+ /* Verification */
+ buf = malloc (0x400);
+ read_many (fd, 0x08, buf, sizeof (seq002));
+ if (memcmp (seq002, buf, sizeof (seq002)))
+ DBG (1, "seq002 verification error\n");
+ /* addr 0x28 isn't read */
+ read_many (fd, 0x29, buf, sizeof (seq003));
+ if (memcmp (seq003, buf, sizeof (seq003)))
+ DBG (1, "seq003 verification error\n");
+
+ /* parallel port noise filter */
+ write_byte (fd, 0x70, 0x73);
+
+ lights_out (fd);
+
+ /* Home motor */
+ read_byte (fd, STATUS, &result); /* wants 2f or 2d */
+ if (!(result & STATUS_HOME) /*0x2d */ )
+ write_byte (fd, COMMAND, 0x02);
+
+ wait_for_return (fd);
+
+ /* Motor forward */
+ write_byte (fd, COMMAND, 0x01);
+ usleep (600000);
+ read_byte (fd, STATUS, &result); /* wants 0c or 2c */
+ read_byte (fd, STATUS, &result); /* wants 0c */
+ /* Return home */
+ write_byte (fd, COMMAND, 0x02);
+
+ /* Gamma tables */
+ /* Linear gamma */
+ for (temp = 0; temp < 0x0400; temp++)
+ buf[temp] = temp / 4;
+ /* Gamma Red */
+ write_byte (fd, DATAPORT_TARGET, DP_R | DP_GAMMA);
+ write_word (fd, DATAPORT_ADDR, DP_WRITE);
+ write_bulk (fd, DATAPORT, buf, 0x0400);
+ /* Gamma Green */
+ write_byte (fd, DATAPORT_TARGET, DP_G | DP_GAMMA);
+ write_word (fd, DATAPORT_ADDR, DP_WRITE);
+ write_bulk (fd, DATAPORT, buf, 0x0400);
+ /* Gamma Blue */
+ write_byte (fd, DATAPORT_TARGET, DP_B | DP_GAMMA);
+ write_word (fd, DATAPORT_ADDR, DP_WRITE);
+ write_bulk (fd, DATAPORT, buf, 0x0400);
+
+ /* Read back gamma tables. I suppose I should check results... */
+ /* Gamma Red */
+ write_byte (fd, DATAPORT_TARGET, DP_R | DP_GAMMA);
+ write_word (fd, DATAPORT_ADDR, DP_READ);
+ read_bulk (fd, DATAPORT, buf, 0x0400);
+ /* Gamma Green */
+ write_byte (fd, DATAPORT_TARGET, DP_G | DP_GAMMA);
+ write_word (fd, DATAPORT_ADDR, DP_READ);
+ read_bulk (fd, DATAPORT, buf, 0x0400);
+ /* Gamma Blue */
+ write_byte (fd, DATAPORT_TARGET, DP_B | DP_GAMMA);
+ write_word (fd, DATAPORT_ADDR, DP_READ);
+ read_bulk (fd, DATAPORT, buf, 0x0400);
+ free (buf);
+
+ /* Make sure STATUS_HOME */
+ read_byte (fd, STATUS, &result); /* wants 0e */
+ /* stepper forward */
+ write_byte (fd, COMMAND, 0x01);
+ read_byte (fd, STATUS, &result); /* wants 0c */
+ /* not sure if this rigid read/write pattern is required */
+ read_byte (fd, CLOCK_DIV, &result); /* wants 04 */
+ write_byte (fd, CLOCK_DIV, 0x04);
+ read_byte (fd, STEP_SIZE, &result); /* wants 04 */
+ write_byte (fd, STEP_SIZE, 0x3f);
+ read_byte (fd, 0x47, &result); /* wants 1a */
+ write_byte (fd, 0x47, 0xff);
+ read_byte (fd, FAST_STEP, &result); /* wants 01 */
+ write_byte (fd, FAST_STEP, 0x01);
+ read_byte (fd, 0x49, &result); /* wants 04 */
+ write_byte (fd, 0x49, 0x04);
+ read_byte (fd, SKIP_STEPS, &result); /* wants 00 */
+ write_byte (fd, SKIP_STEPS, 0x00);
+ read_byte (fd, 0x4b, &result); /* wants 00 */
+ write_byte (fd, 0x4b, 0xc8);
+ read_byte (fd, BUFFER_LIMIT, &result); /* wants 57 */
+ write_byte (fd, BUFFER_LIMIT, 0x04);
+ read_byte (fd, BUFFER_RESUME, &result); /* wants 02 */
+ write_byte (fd, BUFFER_RESUME, 0x02);
+ read_byte (fd, REVERSE_STEPS, &result); /* wants 00 */
+ write_byte (fd, REVERSE_STEPS, 0x00);
+ write_byte (fd, STEP_PWM, 0x1f);
+
+ /* Reset motor */
+ write_byte (fd, COMMAND, 0x08);
+ write_byte (fd, COMMAND, 0x00);
+ /* Scan */
+ write_byte (fd, COMMAND, 0x03);
+ /* Wants 02 or 03, gets a bunch of 0's first */
+ read_poll_min (fd, IMAGE_DATA_AVAIL, 2);
+ write_byte (fd, COMMAND, 0x00);
+
+ write_byte (fd, STEP_PWM, 0x3f);
+ write_byte (fd, CLOCK_DIV, 0x04);
+ /* 300 dpi */
+ write_word (fd, STEP_SIZE, 0x041a);
+ write_word (fd, FAST_STEP, 0x0104);
+ /* Don't skip the black/white calibration area at the bottom of the
+ scanner. */
+ write_word (fd, SKIP_STEPS, 0x0000);
+ write_byte (fd, BUFFER_LIMIT, 0x57);
+ write_byte (fd, BUFFER_RESUME, 0x02);
+ write_byte (fd, REVERSE_STEPS, 0x00);
+ write_byte (fd, BUFFER_LIMIT, 0x09);
+ write_byte (fd, STEP_PWM, 0x1f);
+ read_byte (fd, MICROSTEP, &result); /* wants 13, active */
+ write_byte (fd, MICROSTEP, 0x03 /* tristate */ );
+
+ /* Calibration data taken under 3 different lighting conditions */
+ /* dark */
+ write_word (fd, LAMP_R_ON, 0x0017);
+ write_word (fd, LAMP_R_OFF, 0x0100);
+ write_word (fd, LAMP_G_ON, 0x0017);
+ write_word (fd, LAMP_G_OFF, 0x0100);
+ write_word (fd, LAMP_B_ON, 0x0017);
+ write_word (fd, LAMP_B_OFF, 0x0100);
+ /* coming in, we've got 300dpi,
+ data px start : 0x004b
+ data px end : 0x1437 for a total of 5100(13ec) 600-dpi pixels,
+ (8.5 inches) or 2550 300-dpi pixels (7653 bytes).
+ Interestingly, the scan head never moves, no matter how many rows
+ are read. */
+ s->width = 2551;
+ s->height = 1;
+ s->flags = FLG_BUF | FLG_NO_INTERLEAVE;
+ s->buf = malloc (s->width * s->height * 3);
+ /* FIXME do something with this data */
+ CHK (do_scan (s));
+
+ /* Lighting */
+ /* medium */
+ write_word (fd, LAMP_R_ON, 0x0017);
+ write_word (fd, LAMP_R_OFF, 0x0200);
+ write_word (fd, LAMP_G_ON, 0x0017);
+ write_word (fd, LAMP_G_OFF, 0x01d7 /* also 01db */ );
+ write_word (fd, LAMP_B_ON, 0x0017);
+ write_word (fd, LAMP_B_OFF, 0x01af /* also 01b2 */ );
+ /* FIXME do something with this data */
+ CHK (do_scan (s));
+
+ /* Lighting */
+ /* bright */
+ write_word (fd, LAMP_R_ON, 0x0017);
+ write_word (fd, LAMP_R_OFF, 0x0e8e /* also 1040 */ );
+ write_word (fd, LAMP_G_ON, 0x0017);
+ write_word (fd, LAMP_G_OFF, 0x0753 /* also 0718 */ );
+ write_word (fd, LAMP_B_ON, 0x0017);
+ write_word (fd, LAMP_B_OFF, 0x03f8 /* also 040d */ );
+ /* FIXME do something with this data */
+ CHK (do_scan (s));
+ free (s->buf);
+ s->buf = NULL;
+
+ /* The trace gets a little iffy from here on out since the log files
+ are missing different urb's. This is kind of a puzzled-out
+ compilation. */
+
+ write_byte (fd, MICROSTEP, 0x13 /* pins active */ );
+ write_byte (fd, STEP_PWM, 0x3f);
+ read_byte (fd, STATUS, &result); /* wants 0c */
+
+ /* Stepper home */
+ write_byte (fd, COMMAND, 0x02);
+ /* Step size */
+ write_word (fd, STEP_SIZE, 0x041a /* 300 dpi */ );
+ /* Skip steps */
+ write_word (fd, SKIP_STEPS, 0x0000);
+ /* Pause buffer levels */
+ write_byte (fd, BUFFER_LIMIT, 0x57);
+ /* Resume buffer levels */
+ write_byte (fd, BUFFER_RESUME, 0x02);
+
+ wait_for_return (fd);
+ /* stepper forward small */
+ write_byte (fd, COMMAND, 0x01);
+ read_byte (fd, STATUS, &result); /* wants 0c */
+ usleep (200000);
+ write_byte (fd, STEP_PWM, 0x1f);
+
+ /* Read in cal strip at bottom of scanner (to adjust gain/offset
+ tables. Note that this isn't the brightest lighting condition.)
+ At 300 dpi: black rows 0-25; white rows 30-75; beginning
+ of glass 90.
+ This produces 574k of data, so save it to a temp file. */
+ if (!s->fname)
+ {
+ DBG (1, "No temp filename!\n");
+ s->fname = strdup ("/tmp/cal.XXXXXX");
+ mktemp (s->fname);
+ }
+ s->width = 2551;
+ s->height = 75;
+ s->flags = FLG_PPM_HEADER | FLG_NO_INTERLEAVE;
+ CHK (do_scan (s));
+ compute_ogn (s->fname);
+ unlink (s->fname);
+
+ write_byte (fd, STEP_PWM, 0x3f);
+ /* stepper home */
+ write_byte (fd, COMMAND, 0x02);
+
+ /* discard the remaining data */
+ read_byte (fd, IMAGE_DATA_AVAIL, &result); /* wants 42,4c */
+ if (result > 1)
+ {
+ read_bulk_size (fd, result, 0, 0, 0);
+ DBG (11, "read %dk extra\n", result);
+ }
+ read_byte (fd, 0x69, &result); /* wants 02 */
+ write_byte (fd, 0x69, 0x0a);
+
+ lights_out (fd);
+ init (fd);
+
+#if 0
+ /* Repeatedly send this every 1 second. Button scan? FIXME */
+ gl640ReadReq (fd, GL640_GPIO_READ, &result); /* wants 00 */
+#endif
+
+ return 0;
+}
+
+
+/* The number of regions in the calibration strip (black & white). */
+#define NREGIONS 2
+
+/* Compute the offset/gain table from the calibration strip. This is
+ somewhat more complicated than necessary because I don't hard-code the
+ strip widths; I try to figure out the regions based on the scan data.
+ Theoretically, the region-finder should work for any number of distinct
+ regions (but there are only 2 on this scanner.)
+ This produces the CAL_FILE_OGN file, the final offset/gain table. */
+static SANE_Status
+compute_ogn (char *calfilename)
+{
+ byte *linebuf, *oldline, *newline;
+ mode_t oldmask;
+ FILE *fp;
+ int width, height, nlines = 0, region = -1, i, transition = 1, badcnt;
+ int pct;
+ int reglines[NREGIONS];
+ float *avg;
+ float max_range[3], tmp1, tmp2;
+
+ fp = fopen (calfilename, "r");
+ if (!fp)
+ {
+ DBG (1, "open %s\n", calfilename);
+ return SANE_STATUS_EOF;
+ }
+ fscanf (fp, "P6 %d %d %*d ", &width, &height);
+ DBG (12, "cal file %s %dx%d\n", calfilename, width, height);
+ width = width * 3; /* 1 byte each of r, g, b */
+ /* make a buffer holding 2 lines of data */
+ linebuf = calloc (width * 2, sizeof (linebuf[0]));
+ /* first line is data read buffer */
+ newline = linebuf;
+ /* second line is a temporary holding spot in case the next line read
+ is the black/white transition, in which case we'll disregard this
+ one. */
+ oldline = linebuf + width;
+ /* column averages per region */
+ avg = calloc (width * NREGIONS, sizeof (avg[0]));
+
+ while (nlines < height)
+ {
+ if (fread (newline, 1, width, fp) != (size_t) width)
+ break;
+ nlines++;
+ /* Check if new line is majorly different than old.
+ Criteria is 10 pixels differing by more than 10%. */
+ badcnt = 0;
+ for (i = 0; i < width; i++)
+ {
+ pct = newline[i] - oldline[i];
+ /* Fix by M.Reinelt <reinelt@eunet.at>
+ * do NOT use 10% (think of a dark area with
+ * oldline=4 and newline=5, which is a change of 20% !!
+ * Use an absolute difference of 10 as criteria
+ */
+ if (pct < -10 || pct > 10)
+ {
+ badcnt++;
+ DBG (16, "pix%d[%d/%d] ", i, newline[i], oldline[i]);
+ }
+ }
+ DBG (13, "line %d changed %d\n", nlines, badcnt);
+ if ((badcnt > 10) || (nlines == height))
+ {
+ /* End of region. Lines are different or end of data. */
+ transition++;
+ if (transition == 1)
+ DBG (12, "Region %d lines %d-%d\n",
+ region, nlines - reglines[region], nlines - 1);
+ }
+ else
+ {
+ /* Lines are similar, so still in region. */
+ if (transition)
+ {
+ /* There was just a transition, so this is the start of a
+ new region. */
+ region++;
+ if (region >= NREGIONS)
+ /* Too many regions detected. Err below. */
+ break;
+ transition = 0;
+ reglines[region] = 0;
+ }
+ /* Add oldline to the current region's average */
+ for (i = 0; i < width; i++)
+ avg[i + region * width] += oldline[i];
+ reglines[region]++;
+ }
+ /* And newline becomes old */
+ memcpy (oldline, newline, width);
+ }
+ fclose (fp);
+ free (linebuf);
+ region++; /* now call it number of regions instead of index */
+ DBG (11, "read %d lines as %d regions\n", nlines, region);
+
+ /* Check to see if we screwed up */
+ if (region != NREGIONS)
+ {
+ DBG (1, "Warning: gain/offset compute failed.\n"
+ "Found %d regions instead of %d.\n", region, NREGIONS);
+ for (i = 0; i < region; i++)
+ DBG (1, " Region %d: %d lines\n",
+ i, (i >= NREGIONS) ? -1 : reglines[i]);
+ free (avg);
+ return SANE_STATUS_UNSUPPORTED;
+ }
+
+ /* Now we've got regions and sums. Find averages and range. */
+ max_range[0] = max_range[1] = max_range[2] = 0.0;
+ for (i = 0; i < width; i++)
+ {
+ /* Convert sums to averages */
+ /* black region */
+ tmp1 = avg[i] /= reglines[0];
+ /* white region */
+ tmp2 = avg[i + width] /= reglines[1];
+ /* Track largest range for each color.
+ If image is interleaved, use 'i%3', if not, 'i/(width/3)' */
+ if ((tmp2 - tmp1) > max_range[i / (width / 3)])
+ {
+ max_range[i / (width / 3)] = tmp2 - tmp1;
+ DBG (14, "max %d@%d %f-%f=%f\n",
+ i / (width / 3), i, tmp2, tmp1, tmp2 - tmp1);
+ }
+ }
+ DBG (13, "max range r %f\n", max_range[0]);
+ DBG (13, "max range g %f\n", max_range[1]);
+ DBG (13, "max range b %f\n", max_range[2]);
+
+ /* Set umask to world r/w so other users can overwrite common cal... */
+ oldmask = umask (0);
+ fp = fopen (CAL_FILE_OGN, "w");
+ /* ... and set it back. */
+ umask (oldmask);
+ if (!fp)
+ {
+ DBG (1, "open " CAL_FILE_OGN);
+ free (avg);
+ return SANE_STATUS_IO_ERROR;
+ }
+
+ /* Finally, compute offset and gain */
+ for (i = 0; i < width; i++)
+ {
+ int gain, offset;
+ byte ogn[2];
+
+ /* skip line termination flags */
+ if (!((i + 1) % (width / 3)))
+ {
+ DBG (13, "skip scanline EOL %d/%d\n", i, width);
+ continue;
+ }
+
+ /* Gain multiplier:
+ 255 : 1.5 times brighter
+ 511 : 2 times brighter
+ 1023: 3 times brighter */
+#if 1
+ /* Original gain/offset */
+ gain = 512 * ((max_range[i / (width / 3)] /
+ (avg[i + width] - avg[i])) - 1);
+ offset = avg[i];
+#else
+ /* This doesn't work for some people. For instance, a negative
+ offset would be bad. */
+
+ /* Enhanced offset and gain calculation by M.Reinelt <reinelt@eunet.at>
+ * These expressions were found by an iterative calibration process,
+ * by changing gain and offset values for every pixel until the desired
+ * values for black and white were reached, and finding an approximation
+ * formula.
+ * Note that offset is linear, but gain isn't!
+ */
+ offset = (double)3.53 * avg[i] - 125;
+ gain = (double)3861.0 * exp(-0.0168 * (avg[i + width] - avg[i]));
+#endif
+
+ DBG (14, "%d wht=%f blk=%f diff=%f gain=%d offset=%d\n", i,
+ avg[i + width], avg[i], avg[i + width] - avg[i], gain, offset);
+ /* 10-bit gain, 6-bit offset (subtractor) in two bytes */
+ ogn[0] = (byte) (((offset << 2) + (gain >> 8)) & 0xFF);
+ ogn[1] = (byte) (gain & 0xFF);
+ fwrite (ogn, sizeof (byte), 2, fp);
+ /* Annoyingly, we seem to use ogn data at 600dpi, while we scanned
+ at 300, so double our file. Much easier than doubling at the
+ read. */
+ fwrite (ogn, sizeof (byte), 2, fp);
+ }
+
+ fclose (fp);
+ free (avg);
+ return SANE_STATUS_GOOD;
+}
+
+static int
+check_ogn_file (void)
+{
+ FILE *fp;
+ fp = fopen (CAL_FILE_OGN, "r");
+ if (fp)
+ {
+ fclose (fp);
+ return 1;
+ }
+ return 0;
+}
+
+/* Load or fake the offset/gain table */
+static void
+install_ogn (int fd)
+{
+ int temp;
+ byte *buf;
+ FILE *fp;
+
+ /* 8.5in at 600dpi = 5104 pixels in scan head
+ 10-bit gain + 6-bit offset = 2 bytes per pixel, so 10208 bytes */
+ buf = malloc (10208);
+
+ fp = fopen (CAL_FILE_OGN, "r");
+ if (fp)
+ {
+ fread (buf, 2, 5100, fp);
+ /* screw the last 4 pixels */
+ }
+ else
+ {
+ /* Make up the gain/offset data. */
+#define GAIN 256 /* 1.5x */
+#define OFFSET 0
+ for (temp = 0; temp < 10208; temp += 2)
+ {
+ buf[temp] = (byte) ((OFFSET << 2) + (GAIN >> 8));
+ buf[temp + 1] = (byte) (GAIN & 0xFF);
+ }
+ }
+ /* Gain/offset table (r,g,b) */
+ write_byte (fd, DATAPORT_TARGET, DP_R | DP_OFFSET);
+ write_word (fd, DATAPORT_ADDR, DP_WRITE);
+ write_bulk (fd, DATAPORT, buf, 10208);
+ if (fp)
+ fread (buf, 2, 5100, fp);
+ write_byte (fd, DATAPORT_TARGET, DP_G | DP_OFFSET);
+ write_word (fd, DATAPORT_ADDR, DP_WRITE);
+ write_bulk (fd, DATAPORT, buf, 10208);
+ if (fp)
+ {
+ fread (buf, 2, 5100, fp);
+ fclose (fp);
+ }
+ write_byte (fd, DATAPORT_TARGET, DP_B | DP_OFFSET);
+ write_word (fd, DATAPORT_ADDR, DP_WRITE);
+ write_bulk (fd, DATAPORT, buf, 10208);
+
+ free (buf);
+ return;
+}
+
+
+/* Scan sequence */
+/* resolution is 75,150,300,600,1200
+ scan coordinates in 600-dpi pixels */
+static SANE_Status
+scan (CANON_Handle * opt)
+{
+ SANE_Status status;
+ const int left_edge = 0x004b; /* Just for my scanner, or is this
+ universal? Calibrate? */
+ int temp;
+ int fd = opt->fd;
+ byte result;
+ byte *buf;
+
+ /* Check status. (not in w2k driver) */
+ read_byte (fd, STATUS, &result); /* wants 2f or 2d */
+ if (!(result & STATUS_HOME) /*0x2d */ )
+ return SANE_STATUS_DEVICE_BUSY;
+ /* or force it to return?
+ write_byte(fd, COMMAND, 0x02);
+ wait_for_return(fd);
+ */
+
+ /* reserved? */
+ read_byte (fd, 0x69, &result); /* wants 0a */
+
+ read_byte (fd, STATUS, &result); /* wants 0e */
+ read_byte (fd, PAPER_SENSOR, &result); /* wants 2b */
+ write_byte (fd, PAPER_SENSOR, 0x2b);
+ /* Color mode:
+ 1-Channel Line Rate Color 0x15.
+ 1-Channel Grayscale 0x14 (and we skip some of these tables) */
+ write_byte (fd, COLOR_MODE, 0x15);
+
+ /* install the offset/gain table */
+ install_ogn (fd);
+
+ read_byte (fd, STATUS, &result); /* wants 0e */
+ /* move forward to "glass 0" */
+ write_byte (fd, COMMAND, 0x01);
+ read_byte (fd, STATUS, &result); /* wants 0c */
+
+ /* create gamma table */
+ buf = malloc (0x400);
+ for (temp = 0; temp < 0x0400; temp++)
+ /* gamma calculation by M.Reinelt <reinelt@eunet.at> */
+ buf[temp] = (double) 255.0 * exp(log((temp + 0.5) / 1023.0) / opt->gamma)
+ + 0.5;
+
+ /* Gamma R, write and verify */
+ write_byte (fd, DATAPORT_TARGET, DP_R | DP_GAMMA);
+ write_word (fd, DATAPORT_ADDR, DP_WRITE);
+ write_bulk (fd, DATAPORT, buf, 0x0400);
+ write_byte (fd, DATAPORT_TARGET, DP_R | DP_GAMMA);
+ write_word (fd, DATAPORT_ADDR, DP_READ);
+ read_bulk (fd, DATAPORT, buf, 0x0400);
+ /* Gamma G */
+ write_byte (fd, DATAPORT_TARGET, DP_G | DP_GAMMA);
+ write_word (fd, DATAPORT_ADDR, DP_WRITE);
+ write_bulk (fd, DATAPORT, buf, 0x0400);
+ write_byte (fd, DATAPORT_TARGET, DP_G | DP_GAMMA);
+ write_word (fd, DATAPORT_ADDR, DP_READ);
+ read_bulk (fd, DATAPORT, buf, 0x0400);
+ /* Gamma B */
+ write_byte (fd, DATAPORT_TARGET, DP_B | DP_GAMMA);
+ write_word (fd, DATAPORT_ADDR, DP_WRITE);
+ write_bulk (fd, DATAPORT, buf, 0x0400);
+ write_byte (fd, DATAPORT_TARGET, DP_B | DP_GAMMA);
+ write_word (fd, DATAPORT_ADDR, DP_READ);
+ read_bulk (fd, DATAPORT, buf, 0x0400);
+ free (buf);
+
+ write_byte (fd, CLOCK_DIV, 0x04);
+ /* Resolution: dpi 75(ie) 100,150(1c) 200,300(1a) 600,1200(18) */
+ switch (opt->resolution)
+ {
+ case 150:
+ write_byte (fd, 0x09, 0x1c);
+ break;
+ case 300:
+ write_byte (fd, 0x09, 0x1a);
+ break;
+ case 600:
+ case 1200:
+ /* actually 600 dpi horiz max */
+ write_byte (fd, 0x09, 0x18);
+ break;
+ default: /* 75 */
+ write_byte (fd, 0x09, 0x1e);
+ opt->resolution = 75;
+ }
+
+ write_word (fd, ACTIVE_PX_START, left_edge);
+ /* Data pixel start. Measured at 600dpi regardless of
+ scan resolution. 0-position is 0x004b */
+ write_word (fd, DATA_PX_START, left_edge + opt->x1);
+ /* Data pixel end. Measured at 600dpi regardless of scan
+ resolution. */
+ write_word (fd, DATA_PX_END, left_edge + opt->x2);
+ /* greyscale has 14,03, different lights */
+ write_byte (fd, COLOR_MODE, 0x15);
+ write_byte (fd, 0x29, 0x02);
+ /* Lights */
+ write_word (fd, LAMP_R_ON, 0x0017);
+ /* "Hi-low color" selection from windows driver. low(1437) hi(1481) */
+ write_word (fd, LAMP_R_OFF, 0x1437);
+ write_word (fd, LAMP_G_ON, 0x0017);
+ write_word (fd, LAMP_G_OFF, 0x094e);
+ write_word (fd, LAMP_B_ON, 0x0017);
+ write_word (fd, LAMP_B_OFF, 0x0543);
+
+ /* Analog static offset R,G,B. Greyscale has 0,0,0 */
+ write_byte (fd, 0x38, 0x3f);
+ write_byte (fd, 0x39, 0x3f);
+ write_byte (fd, 0x3a, 0x3f);
+ /* Analog static gain R,G,B (normally 0x01) */
+ write_byte (fd, 0x3b, opt->gain);
+ write_byte (fd, 0x3c, opt->gain);
+ write_byte (fd, 0x3d, opt->gain);
+ /* Digital gain/offset settings. Greyscale has 0 */
+ write_byte (fd, 0x3e, 0x1a);
+
+ {
+ /* Stepper motion setup. */
+ int stepsize, faststep = 0x0104, reverse = 0x28, phase, pwm = 0x1f;
+ switch (opt->resolution)
+ {
+ case 75:
+ stepsize = 0x0106;
+ faststep = 0x0106;
+ reverse = 0;
+ phase = 0x39a8;
+ pwm = 0x3f;
+ break;
+ case 150:
+ stepsize = 0x020d;
+ phase = 0x3198;
+ break;
+ case 300:
+ stepsize = 0x041a;
+ phase = 0x2184;
+ break;
+ case 600:
+ stepsize = 0x0835;
+ phase = 0x0074;
+ break;
+ case 1200:
+ /* 1200 dpi y only, x is 600 dpi */
+ stepsize = 0x106b;
+ phase = 0x41ac;
+ break;
+ default:
+ DBG (1, "BAD RESOLUTION");
+ return SANE_STATUS_UNSUPPORTED;
+ }
+
+ write_word (fd, STEP_SIZE, stepsize);
+ write_word (fd, FAST_STEP, faststep);
+ /* There sounds like a weird step disjoint at the end of skipsteps
+ at 75dpi, so I think that's why skipsteps=0 at 75dpi in the
+ Windows driver. It still works at the normal 0x017a though. */
+ /* cal strip is 0x17a steps, plus 2 300dpi microsteps per pixel */
+ write_word (fd, SKIP_STEPS, 0x017a /* cal strip */ + opt->y1 * 2);
+ /* FIXME could be 0x57, why not? */
+ write_byte (fd, BUFFER_LIMIT, 0x20);
+ write_byte (fd, BUFFER_RESUME, 0x02);
+ write_byte (fd, REVERSE_STEPS, reverse);
+ /* motor resume phasing */
+ write_word (fd, 0x52, phase);
+ write_byte (fd, STEP_PWM, pwm);
+ }
+
+ read_byte (fd, PAPER_SENSOR, &result); /* wants 2b */
+ write_byte (fd, PAPER_SENSOR, 0x0b);
+
+ opt->width = (opt->x2 - opt->x1) * opt->resolution / 600 + 1;
+ opt->height = (opt->y2 - opt->y1) * opt->resolution / 600;
+ opt->flags = 0;
+ DBG (1, "width=%d height=%d dpi=%d\n", opt->width, opt->height,
+ opt->resolution);
+ CHK (do_scan (opt));
+
+ read_byte (fd, PAPER_SENSOR, &result); /* wants 0b */
+ write_byte (fd, PAPER_SENSOR, 0x2b);
+ write_byte (fd, STEP_PWM, 0x3f);
+
+ lights_out (fd);
+ /* home */
+ write_byte (fd, COMMAND, 0x02);
+
+ return status;
+}
+
+
+static SANE_Status
+CANON_set_scan_parameters (CANON_Handle * scan,
+ const int forceCal,
+ const int gray,
+ const int left,
+ const int top,
+ const int right,
+ const int bottom,
+ const int res,
+ const int gain,
+ const double gamma)
+{
+ DBG (2, "CANON_set_scan_parameters:\n");
+ DBG (2, "cal = %d\n", forceCal);
+ DBG (2, "gray = %d (ignored)\n", gray);
+ DBG (2, "res = %d\n", res);
+ DBG (2, "gain = %d\n", gain);
+ DBG (2, "gamma = %f\n", gamma);
+ DBG (2, "in 600dpi pixels:\n");
+ DBG (2, "left = %d, top = %d\n", left, top);
+ DBG (2, "right = %d, bottom = %d\n", right, bottom);
+
+ /* Validate the input parameters */
+ if ((left < 0) || (right > CANON_MAX_WIDTH))
+ return SANE_STATUS_INVAL;
+
+ if ((top < 0) || (bottom > CANON_MAX_HEIGHT))
+ return SANE_STATUS_INVAL;
+
+ if (((right - left) < 10) || ((bottom - top) < 10))
+ return SANE_STATUS_INVAL;
+
+ if ((res != 75) && (res != 150) && (res != 300)
+ && (res != 600) && (res != 1200))
+ return SANE_STATUS_INVAL;
+
+ if ((gain < 0) || (gain > 64))
+ return SANE_STATUS_INVAL;
+
+ if (gamma <= 0.0)
+ return SANE_STATUS_INVAL;
+
+ /* Store params */
+ scan->resolution = res;
+ scan->x1 = left;
+ scan->x2 = right - /* subtract 1 pixel */ 600 / scan->resolution;
+ scan->y1 = top;
+ scan->y2 = bottom;
+ scan->gain = gain;
+ scan->gamma = gamma;
+ scan->flags = forceCal ? FLG_FORCE_CAL : 0;
+
+ return SANE_STATUS_GOOD;
+}
+
+
+static SANE_Status
+CANON_close_device (CANON_Handle * scan)
+{
+ DBG (3, "CANON_close_device:\n");
+ sanei_usb_close (scan->fd);
+ return SANE_STATUS_GOOD;
+}
+
+
+static SANE_Status
+CANON_open_device (CANON_Handle * scan, const char *dev)
+{
+ SANE_Word vendor;
+ SANE_Word product;
+ SANE_Status res;
+
+ DBG (3, "CANON_open_device: `%s'\n", dev);
+
+ scan->fname = NULL;
+ scan->fp = NULL;
+ scan->flags = 0;
+
+ res = sanei_usb_open (dev, &scan->fd);
+ if (res != SANE_STATUS_GOOD)
+ {
+ DBG (1, "CANON_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, "CANON_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 CANON scanner */
+ if ((vendor != 0x04a9) || (product != 0x2204))
+ {
+ DBG (1, "CANON_open_device: incorrect vendor/product (0x%x/0x%x)\n",
+ vendor, product);
+ sanei_usb_close (scan->fd);
+ scan->fd = -1;
+ return SANE_STATUS_UNSUPPORTED;
+ }
+#endif
+
+ return SANE_STATUS_GOOD;
+}
+
+
+static const char *
+CANON_get_device_name (CANON_Handle * scanner)
+{
+ scanner = scanner; /* Eliminate warning about unused parameters */
+ return "Canoscan FB630U";
+}
+
+
+static SANE_Status
+CANON_finish_scan (CANON_Handle * scanner)
+{
+ DBG (3, "CANON_finish_scan:\n");
+ if (scanner->fp)
+ fclose (scanner->fp);
+ scanner->fp = NULL;
+
+ /* remove temp file */
+ if (scanner->fname)
+ {
+ DBG (4, "removing temp file %s\n", scanner->fname);
+ unlink (scanner->fname);
+ free (scanner->fname);
+ }
+ scanner->fname = NULL;
+
+ return SANE_STATUS_GOOD;
+}
+
+
+static SANE_Status
+CANON_start_scan (CANON_Handle * scanner)
+{
+ int rv;
+ SANE_Status status;
+ DBG (3, "CANON_start_scan called\n");
+
+ /* choose a temp file name for scan data */
+ scanner->fname = strdup ("/tmp/scan.XXXXXX");
+ if (!mktemp (scanner->fname))
+ return SANE_STATUS_IO_ERROR;
+
+ /* calibrate if needed */
+ rv = init (scanner->fd);
+ if (rv < 0) {
+ DBG(1, "Can't talk on USB.\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+ if ((rv == 1)
+ || !check_ogn_file ()
+ || (scanner->flags & FLG_FORCE_CAL)) {
+ plugin_cal (scanner);
+ wait_for_return (scanner->fd);
+ }
+
+ /* scan */
+ if ((status = scan (scanner)) != SANE_STATUS_GOOD)
+ {
+ CANON_finish_scan (scanner);
+ return status;
+ }
+
+ /* read the temp file back out */
+ scanner->fp = fopen (scanner->fname, "r");
+ DBG (4, "reading %s\n", scanner->fname);
+ if (!scanner->fp)
+ {
+ DBG (1, "open %s", scanner->fname);
+ return SANE_STATUS_IO_ERROR;
+ }
+ return SANE_STATUS_GOOD;
+}
+
+
+static SANE_Status
+CANON_read (CANON_Handle * scanner, SANE_Byte * data,
+ SANE_Int max_length, SANE_Int * length)
+{
+ SANE_Status status;
+ int red_len;
+
+ DBG (5, "CANON_read called\n");
+ if (!scanner->fp)
+ return SANE_STATUS_INVAL;
+ red_len = fread (data, 1, max_length, scanner->fp);
+ /* return some data */
+ if (red_len > 0)
+ {
+ *length = red_len;
+ DBG (5, "CANON_read returned (%d/%d)\n", *length, max_length);
+ return SANE_STATUS_GOOD;
+ }
+
+ /* EOF or file err */
+ *length = 0;
+ if (feof (scanner->fp))
+ {
+ DBG (4, "EOF\n");
+ status = SANE_STATUS_EOF;
+ }
+ else
+ {
+ DBG (4, "IO ERR\n");
+ status = SANE_STATUS_IO_ERROR;
+ }
+
+ CANON_finish_scan (scanner);
+ DBG (5, "CANON_read returned (%d/%d)\n", *length, max_length);
+ return status;
+}