Initial import of sane-backends version 1.0.24-1.2

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;
+}