Initial import of sane-backends version 1.0.24-1.2

1 files changed, 2979 insertions, 0 deletions

diff --git a/backend/hp4200.c b/backend/hp4200.c
new file mode 100644
index 0000000..a069be6
--- /dev/null
+++ b/backend/hp4200.c
@@ -0,0 +1,2979 @@
+/*
+  Copyright (C) 2000 by Adrian Perez Jorge
+
+  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.  
+ */
+
+/* Developers:
+
+       Adrian Perez Jorge (APJ) - 
+            Creator of the original HP4200C backend code.
+	    adrianpj@easynews.com
+				  
+       Andrew John Lewis  (AJL) - 
+	    lewi0235@tc.umn.edu
+
+       Arnar Mar Hrafnkelsson (AMH) -
+            addi@umich.edu
+
+       Frank Zago
+            some cleanups and integration into SANE
+
+       Henning Meier-Geinitz <henning@meier-geinitz.de>
+            more cleanups, bug fixes
+
+TODO:
+
+   - support more scanning resolutions.
+   - support different color depths.
+   - support gray and lineart.
+   - improve scanning speed. Compute scanning parameters based on the
+     image size and the scanner-to-host bandwidth.
+   - improve image quality.
+   - fix problem concerning mangled images
+  
+*/
+
+#define BUILD 2
+#define BACKEND_NAME hp4200
+
+#include "../include/sane/config.h"
+
+#include <sys/ioctl.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <math.h>
+#include <sys/time.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <ctype.h>
+#include <assert.h>
+
+#include "../include/sane/sane.h"
+#include "../include/sane/sanei.h"
+#include "../include/sane/sanei_debug.h"
+#include "../include/sane/sanei_config.h"
+#include "../include/sane/sanei_usb.h"
+#include "../include/sane/sanei_pv8630.h"
+#include "../include/sane/saneopts.h"
+#include "../include/sane/sanei_backend.h"
+#include "hp4200.h"
+
+#include "hp4200_lm9830.c"
+
+#define HP4200_CONFIG_FILE "hp4200.conf"
+
+/*--------------------------------------------------------------------------*/
+
+#if 0
+/* Some of these resolution need work in color shifting. */
+static const SANE_Int dpi_list[] =
+  { 8, 50, 75, 100, 150, 200, 300, 400, 600 };
+#else
+static const SANE_Int dpi_list[] = { 4, 75, 150, 300, 600 };
+#endif
+static SANE_Range x_range = { SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0 };
+static SANE_Range y_range =
+  { SANE_FIX (0), SANE_FIX (11.75 * MM_PER_INCH), 0 };
+static const SANE_Range u8_range = { 0, 255, 0 };
+
+struct coarse_t
+{
+  int min_red;
+  int min_green;
+  int min_blue;
+  int max_red;
+  int max_green;
+  int max_blue;
+  int red_gain;
+  int red_offset;
+  int green_gain;
+  int green_offset;
+  int blue_gain;
+  int blue_offset;
+};
+
+static const double hdpi_mapping[8] = { 1, 1.5, 2, 3, 4, 6, 8, 12 };
+
+static HP4200_Device *first_device = NULL;	/* device list head */
+static int n_devices = 0;	/* the device count */
+static const SANE_Device **devlist = NULL;
+
+static unsigned char
+getreg (HP4200_Scanner * s, unsigned char reg)
+{
+  unsigned char reg_value;
+
+  if ((reg > 0x08) && (reg < 0x5b))
+    return (unsigned char) LOBYTE (s->regs[reg]);
+  else
+    {
+      lm9830_read_register (s->fd, reg, &reg_value);
+      return reg_value;
+    }
+}
+
+static void
+setreg (HP4200_Scanner * s, unsigned char reg, unsigned char reg_value)
+{
+  s->regs[reg] = reg_value;	/* dirty bit should be clear with this */
+  if ((reg < 0x08) || (reg > 0x5b))
+    {
+      lm9830_write_register (s->fd, reg, reg_value);
+    }
+}
+
+static void
+setbits (HP4200_Scanner * s, unsigned char reg, unsigned char bitmap)
+{
+  s->regs[reg] = (s->regs[reg] & 0xff) | bitmap;
+  if ((reg < 0x08) || (reg > 0x5b))
+    {
+      lm9830_write_register (s->fd, reg, LOBYTE (s->regs[reg]));
+    }
+}
+
+static void
+clearbits (HP4200_Scanner * s, unsigned char reg, unsigned char mask)
+{
+  s->regs[reg] = (s->regs[reg] & ~mask) & 0xff;
+  if ((reg < 0x08) || (reg > 0x5b))
+    {
+      lm9830_write_register (s->fd, reg, LOBYTE (s->regs[reg]));
+    }
+}
+
+static int
+cache_write (HP4200_Scanner * s)
+{
+  int i;
+#ifdef DEBUG_REG_CACHE
+  int counter = 0;
+#endif
+
+  DBG (DBG_proc, "Writing registers\n");
+
+  for (i = 0; i < 0x80; i++)
+    if (!(s->regs[i] & 0x100))
+      {				/* modified register */
+#ifdef DEBUG_REG_CACHE
+	fprintf (stderr, "%.2x", i);
+	if (counter == 8)
+	  fprintf (stderr, "\n");
+	else
+	  fprintf (stderr, ", ");
+	counter = (counter + 1) % 9;
+#endif
+	lm9830_write_register (s->fd, i, s->regs[i]);
+	s->regs[i] |= 0x100;	/* register is updated */
+      }
+  return 0;
+}
+
+/*
+ * HP4200-dependent register initialization.
+ */
+
+static int
+hp4200_init_registers (HP4200_Scanner * s)
+{
+  /* set up hardware parameters */
+
+  s->hw_parms.crystal_frequency = 48000000;
+  s->hw_parms.SRAM_size = 128;	/* Kb */
+  s->hw_parms.scan_area_width = 5100;	/* pixels */
+  s->hw_parms.scan_area_length = 11;	/* inches */
+  s->hw_parms.min_pixel_data_buffer_limit = 1024;	/* bytes */
+  s->hw_parms.sensor_line_separation = 4;	/* lines */
+  s->hw_parms.sensor_max_integration_time = 12;	/* milliseconds */
+  s->hw_parms.home_sensor = 2;
+  s->hw_parms.sensor_resolution = 1;	/* 600 dpi */
+  s->hw_parms.motor_full_steps_per_inch = 300;
+  s->hw_parms.motor_max_speed = 1.4;	/* inches/second */
+  s->hw_parms.num_tr_pulses = 1;
+  s->hw_parms.guard_band_duration = 1;
+  s->hw_parms.pulse_duration = 3;
+  s->hw_parms.fsteps_25_speed = 3;
+  s->hw_parms.fsteps_50_speed = 3;
+  s->hw_parms.target_value.red = 1000;
+  s->hw_parms.target_value.green = 1000;
+  s->hw_parms.target_value.blue = 1000;
+
+  {
+    int i;
+
+    /*
+     * we are using a cache-like data structure so registers whose
+     * values were written to the lm9830 and aren't volatile, have
+     * bit 0x100 activated.  This bit must be cleared if you want the
+     * value to be written to the chip once cache_write() is called.
+     */
+
+    /* clears the registers cache */
+    memset (s->regs, 0, sizeof (s->regs));
+
+    /*
+     * registers 0x00 - 0x07 are non-cacheable/volatile, so don't
+     * read the values using the cache.  Instead use direct functions
+     * to read/write registers.
+     */
+
+    for (i = 0; i < 0x08; i++)
+      s->regs[i] = 0x100;
+  }
+
+  setreg (s, 0x70, 0x70);	/* noise filter */
+
+  setreg (s, 0x0b,
+	  INPUT_SIGNAL_POLARITY_NEGATIVE |
+	  CDS_ON |
+	  SENSOR_STANDARD |
+	  SENSOR_RESOLUTION_600 | LINE_SKIPPING_COLOR_PHASE_DELAY (0));
+
+  setreg (s, 0x0c,
+	  PHI1_POLARITY_POSITIVE |
+	  PHI2_POLARITY_POSITIVE |
+	  RS_POLARITY_POSITIVE |
+	  CP1_POLARITY_POSITIVE |
+	  CP2_POLARITY_POSITIVE |
+	  TR1_POLARITY_NEGATIVE | TR2_POLARITY_NEGATIVE);
+
+  setreg (s, 0x0d,
+	  PHI1_ACTIVE |
+	  PHI2_ACTIVE |
+	  RS_ACTIVE |
+	  CP1_ACTIVE |
+	  CP2_OFF |
+	  TR1_ACTIVE |
+	  TR2_OFF | NUMBER_OF_TR_PULSES (s->hw_parms.num_tr_pulses));
+
+  setreg (s, 0x0e,
+	  TR_PULSE_DURATION (s->hw_parms.pulse_duration) |
+	  TR_PHI1_GUARDBAND_DURATION (s->hw_parms.guard_band_duration));
+
+  /* for pixel rate timing */
+  setreg (s, 0x0f, 6);
+  setreg (s, 0x10, 23);
+  setreg (s, 0x11, 1);
+  setreg (s, 0x12, 3);
+  setreg (s, 0x13, 3);		/* 0 */
+  setreg (s, 0x14, 5);		/* 0 */
+  setreg (s, 0x15, 0);
+  setreg (s, 0x16, 0);
+  setreg (s, 0x17, 11);
+  setreg (s, 0x18, 2);		/* 1 */
+
+  setreg (s, 0x19, CIS_TR1_TIMING_OFF | FAKE_OPTICAL_BLACK_PIXELS_OFF);
+
+  setreg (s, 0x1a, 0);
+  setreg (s, 0x1b, 0);
+
+  setreg (s, 0x1c, 0x0d);
+  setreg (s, 0x1d, 0x21);
+
+  setreg (s, 0x27, TR_RED_DROP (0) | TR_GREEN_DROP (0) | TR_BLUE_DROP (0));
+
+  setreg (s, 0x28, 0x00);
+
+  setreg (s, 0x29, ILLUMINATION_MODE (1));
+  setreg (s, 0x2a, HIBYTE (0));	/* 0 */
+  setreg (s, 0x2b, LOBYTE (0));	/* 0 */
+
+  setreg (s, 0x2c, HIBYTE (16383));
+  setreg (s, 0x2d, LOBYTE (16383));
+
+  setreg (s, 0x2e, HIBYTE (2));	/* 2 */
+  setreg (s, 0x2f, LOBYTE (2));	/* 1 */
+
+  setreg (s, 0x30, HIBYTE (0));
+  setreg (s, 0x31, LOBYTE (0));
+
+  setreg (s, 0x32, HIBYTE (0));
+  setreg (s, 0x33, LOBYTE (0));
+
+  setreg (s, 0x34, HIBYTE (32));
+  setreg (s, 0x35, LOBYTE (32));
+
+  setreg (s, 0x36, HIBYTE (48));
+  setreg (s, 0x37, LOBYTE (48));
+
+  setreg (s, 0x42, EPP_MODE | PPORT_DRIVE_CURRENT (3));
+
+  setreg (s, 0x43,
+	  RAM_SIZE_128 |
+	  SRAM_DRIVER_CURRENT (3) | SRAM_BANDWIDTH_8 | SCANNING_FULL_DUPLEX);
+
+  setreg (s, 0x45,
+	  MICRO_STEPPING |
+	  CURRENT_SENSING_PHASES (2) |
+	  PHASE_A_POLARITY_POSITIVE |
+	  PHASE_B_POLARITY_POSITIVE | STEPPER_MOTOR_OUTPUT);
+
+  setreg (s, 0x4a, HIBYTE (100));
+  setreg (s, 0x4b, LOBYTE (100));
+
+  setreg (s, 0x4c, HIBYTE (0));
+  setreg (s, 0x4d, LOBYTE (0));
+
+  /* resume scan threshold */
+  setreg (s, 0x4f, 64);
+  /* steps to reverse */
+  setreg (s, 0x50, 40);
+  setreg (s, 0x51,
+	  ACCELERATION_PROFILE_STOPPED (3) |
+	  ACCELERATION_PROFILE_25P (s->hw_parms.fsteps_25_speed) |
+	  ACCELERATION_PROFILE_50P (s->hw_parms.fsteps_50_speed));
+  setreg (s, 0x54, NON_REVERSING_EXTRA_LINES (0) | FIRST_LINE_TO_PROCESS (0));
+  setreg (s, 0x55, KICKSTART_STEPS (0) | HOLD_CURRENT_TIMEOUT (2));
+
+  /* stepper PWM frequency */
+  setreg (s, 0x56, 8);
+  /* stepper pwm duty cycle */
+  setreg (s, 0x57, 23);
+
+  setreg (s, 0x58,
+	  PAPER_SENSOR_1_POLARITY_HIGH |
+	  PAPER_SENSOR_1_TRIGGER_EDGE |
+	  PAPER_SENSOR_1_NO_STOP_SCAN |
+	  PAPER_SENSOR_2_POLARITY_HIGH |
+	  PAPER_SENSOR_2_TRIGGER_EDGE | PAPER_SENSOR_2_STOP_SCAN);
+  setreg (s, 0x59,
+	  MISCIO_1_TYPE_OUTPUT |
+	  MISCIO_1_POLARITY_HIGH |
+	  MISCIO_1_TRIGGER_EDGE |
+	  MISCIO_1_OUTPUT_STATE_HIGH |
+	  MISCIO_2_TYPE_OUTPUT |
+	  MISCIO_2_POLARITY_HIGH |
+	  MISCIO_2_TRIGGER_EDGE | MISCIO_2_OUTPUT_STATE_HIGH);
+
+  return 0;
+}
+
+#ifdef DEBUG
+static int
+dump_register_cache (HP4200_Scanner * s)
+{
+  int i;
+
+  for (i = 0; i < 0x80; i++)
+    {
+      fprintf (stderr, "%.2x:0x%.2x", i, s->regs[i]);
+      if ((i + 1) % 8)
+	fprintf (stderr, ", ");
+      else
+	fprintf (stderr, "\n");
+    }
+  fputs ("", stderr);
+  return 0;
+}
+#endif
+
+/*
+ * returns the scanner head to home position
+ */
+
+static int
+hp4200_goto_home (HP4200_Scanner * s)
+{
+  unsigned char cmd_reg;
+  unsigned char status_reg;
+  unsigned char old_paper_sensor_reg;
+
+  cmd_reg = getreg (s, 0x07);
+  if (cmd_reg != 2)
+    {
+      unsigned char paper_sensor_reg;
+      unsigned char sensor_bit[2] = { 0x02, 0x10 };
+      /* sensor head is not returning */
+
+      /* let's see if it's already at home */
+      /* first put paper (head) sensor level sensitive */
+      paper_sensor_reg = getreg (s, 0x58);
+      old_paper_sensor_reg = paper_sensor_reg;
+      paper_sensor_reg &= ~sensor_bit[s->hw_parms.home_sensor - 1];
+      setreg (s, 0x58, paper_sensor_reg);
+      cache_write (s);
+
+      /* if the scan head is not at home then move motor backwards */
+      status_reg = getreg (s, 0x02);
+      setreg (s, 0x58, old_paper_sensor_reg);
+      cache_write (s);
+      if (!(status_reg & s->hw_parms.home_sensor))
+	{
+	  setreg (s, 0x07, 0x08);
+	  usleep (10 * 1000);
+	  setreg (s, 0x07, 0x00);
+	  usleep (10 * 1000);
+	  setreg (s, 0x07, 0x02);
+	}
+    }
+  return 0;
+}
+
+#define HP4200_CHECK_INTERVAL 1000	/* usecs between status checks */
+static int
+hp4200_wait_homed (HP4200_Scanner * s)
+{
+  unsigned char cmd_reg;
+
+  cmd_reg = getreg (s, 0x07);
+  while (cmd_reg != 0)
+    {
+      usleep (HP4200_CHECK_INTERVAL);
+      cmd_reg = getreg (s, 0x07);
+    }
+  return 0;
+}
+
+static int
+compute_fastfeed_step_size (unsigned long crystal_freq, int mclk,
+			    float max_speed, int steps_per_inch,
+			    int color_mode)
+{
+  int aux;
+  int r;
+
+  if (color_mode == 0)
+    r = 24;
+  else
+    r = 8;
+
+  aux = floor (crystal_freq / ((double) mclk * max_speed * 4.0 *
+			       steps_per_inch * r));
+
+
+  if (aux < 2)
+    aux = 2;
+  return aux;
+}
+
+static SANE_Status
+read_available_data (HP4200_Scanner * s, SANE_Byte * buffer,
+		     size_t * byte_count)
+{
+  SANE_Status status;
+  unsigned char scankb1;
+  unsigned char scankb2;
+  size_t to_read;
+  size_t really_read;
+  size_t chunk;
+
+  assert (buffer != NULL);
+
+  *byte_count = 0;
+  do
+    {
+      scankb1 = getreg (s, 0x01);
+      scankb2 = getreg (s, 0x01);
+      if (s->aborted_by_user)
+	return SANE_STATUS_CANCELLED;
+    }
+  while ((scankb1 != scankb2) || (scankb1 < 12));
+
+  to_read = scankb1 * 1024;
+
+  while (to_read)
+    {
+      if (s->aborted_by_user)
+	return SANE_STATUS_CANCELLED;
+      chunk = (to_read > 0xffff) ? 0xffff : to_read;
+
+      sanei_pv8630_write_byte (s->fd, PV8630_REPPADDRESS, 0x00);
+      sanei_pv8630_prep_bulkread (s->fd, chunk);
+      really_read = chunk;
+      if ((status = sanei_usb_read_bulk (s->fd, buffer, &really_read)) !=
+	  SANE_STATUS_GOOD)
+	{
+	  DBG (DBG_error, "sanei_usb_read_bulk failed (%s)\n",
+	       sane_strstatus (status));
+	  return status;
+	}
+      if (really_read > to_read)
+	{
+	  DBG (DBG_error, "USB stack read more bytes than requested!\n");
+	  return SANE_STATUS_IO_ERROR;
+	}
+      *byte_count += really_read;
+      buffer += really_read;
+      to_read -= really_read;
+#ifdef DEBUG
+      fprintf (stderr, "read %d bytes\n", really_read);
+#endif
+    }
+  return SANE_STATUS_GOOD;
+}
+
+#ifdef unused
+static int
+compute_datalink_bandwidth (HP4200_Scanner * s)
+{
+  int line_size;
+  int pause_limit;
+  unsigned int color_mode;
+
+  /*
+   * Line size for 8 bpp, the entire scan area width (plus the
+   * status byte) at optical resolution.
+   */
+
+  if (s->user_parms.color)
+    {
+      line_size = 3 * s->hw_parms.scan_area_width + 1;
+      color_mode = 0;
+      setreg (s, 0x26, color_mode);	/* 3 channel pixel rate color */
+    }
+  else
+    {
+      line_size = s->hw_parms.scan_area_width + 1;
+      color_mode = 4;
+      setreg (s, 0x26, 0x08 | color_mode);	/* 1 channel mode A (green) */
+    }
+  setreg (s, 0x09, (3 << 3));	/* h-divider = 1, 8 bpp */
+
+  {
+    int first_white_pixel;
+    unsigned int line_end;
+
+    first_white_pixel = s->hw_parms.sensor_pixel_end - 10;
+    line_end = first_white_pixel + s->hw_parms.scan_area_width;
+    if (line_end > (s->hw_parms.sensor_num_pixels - 20))
+      line_end = s->hw_parms.sensor_num_pixels - 20;
+
+    setreg (s, 0x1c, HIBYTE (s->hw_parms.sensor_pixel_start));
+    setreg (s, 0x1d, LOBYTE (s->hw_parms.sensor_pixel_end));
+    setreg (s, 0x1e, HIBYTE (first_white_pixel));
+    setreg (s, 0x1f, LOBYTE (first_white_pixel));
+    setreg (s, 0x20, HIBYTE (s->hw_parms.sensor_num_pixels));
+    setreg (s, 0x21, LOBYTE (s->hw_parms.sensor_num_pixels));
+    setreg (s, 0x22, getreg (s, 0x1e));
+    setreg (s, 0x23, getreg (s, 0x1f));
+    setreg (s, 0x24, HIBYTE (line_end));
+    setreg (s, 0x25, LOBYTE (line_end));
+  }
+
+  /*
+   * During transfer rate calculation don't forward scanner sensor.
+   * Stay in the calibration region.
+   */
+
+  setreg (s, 0x4f, 0);
+  clearbits (s, 0x45, 0x10);
+
+  /*
+   * Pause the scan when memory is full.
+   */
+
+  pause_limit = s->hw_parms.SRAM_size - (line_size / 1024) - 1;
+  setreg (s, 0x4e, pause_limit & 0xff);
+
+  s->mclk = compute_min_mclk (s->hw_parms.SRAM_bandwidth,
+			      s->hw_parms.crystal_frequency);
+
+
+  /*
+   * Set step size to fast speed.
+   */
+
+  {
+    int step_size;
+
+    step_size =
+      compute_fastfeed_step_size (s->hw_parms.crystal_frequency,
+				  s->mclk,
+				  s->hw_parms.scan_bar_max_speed,
+				  s->hw_parms.motor_full_steps_per_inch,
+				  color_mode);
+
+    setreg (s, 0x46, HIBYTE (step_size));
+    setreg (s, 0x47, LOBYTE (step_size));
+    setreg (s, 0x48, HIBYTE (step_size));
+    setreg (s, 0x49, LOBYTE (step_size));
+  }
+
+  cache_write (s);
+
+  /*  dump_register_cache (s); */
+
+  /*
+   * scan during 1 sec. aprox.
+   */
+
+  setreg (s, 0x07, 0x08);
+  setreg (s, 0x07, 0x03);
+
+  {
+    struct timeval tv_before;
+    struct timeval tv_after;
+    int elapsed_time_ms = 0;
+    long bytes_read_total;
+    SANE_Byte *buffer;
+
+    buffer = malloc (2 * 98304);	/* check this */
+    if (!buffer)
+      {
+	DBG (DBG_error, "compute_datalink_bandwidth: malloc failed\n");
+	return 0;
+      }
+    bytes_read_total = 0;
+    gettimeofday (&tv_before, NULL);
+    do
+      {
+	size_t bytes_read;
+	SANE_Status status;
+
+	status = read_available_data (s, buffer, &bytes_read);
+	if (status != SANE_STATUS_GOOD)
+	  {
+	    DBG (DBG_error, "read_available_data failed (%s)\n",
+		 sane_strstatus (status));
+	    return 0;
+	  }
+	bytes_read_total += bytes_read;
+	gettimeofday (&tv_after, NULL);
+	elapsed_time_ms = (tv_after.tv_sec - tv_before.tv_sec) * 1000;
+	elapsed_time_ms += (tv_after.tv_usec - tv_before.tv_usec) / 1000;
+      }
+    while (elapsed_time_ms < 1000);
+
+    setreg (s, 0x07, 0x00);
+    free (buffer);
+
+    s->msrd_parms.datalink_bandwidth = bytes_read_total /
+      (elapsed_time_ms / 1000);
+
+#ifdef DEBUG
+    fprintf (stderr, "PC Transfer rate = %d bytes/sec. (%ld/%d)\n",
+	     s->msrd_parms.datalink_bandwidth, bytes_read_total,
+	     elapsed_time_ms);
+#endif
+  }
+  return 0;
+}
+#endif
+
+static void
+compute_first_gain_offset (int target, int max, int min, int *gain,
+			   int *offset, int *max_gain, int *min_offset)
+{
+  *gain = (int) 15.0 *(target / (max - min) - 0.933);
+  *offset = (int) (-1.0 * min / (512.0 * 0.0195));
+  if (*gain >= 32)
+    {
+      *gain = (int) 15.0 *(target / 3.0 / (max - min) - 0.933);
+      *offset = (int) -3.0 * min / (512.0 * 0.0195);
+    }
+  if (*gain < 0)
+    *gain = 0;
+  else if (*gain > 63)
+    *gain = 63;
+
+  if (*offset < -31)
+    *offset = -31;
+  else if (*offset > 31)
+    *offset = 31;
+
+  *max_gain = 63;
+  *min_offset = -31;
+}
+
+#define DATA_PORT_READ (1 << 5)
+#define DATA_PORT_WRITE 0
+
+static int
+write_gamma (HP4200_Scanner * s)
+{
+  SANE_Status status;
+  int color;
+  int i;
+  unsigned char gamma[1024];
+  unsigned char read_gamma[1024];
+  int retval;
+  size_t to_read;
+  size_t to_write;
+
+  for (color = 0; color < 3; color++)
+    {
+      for (i = 0; i < 1024; i++)
+	gamma[i] = s->user_parms.gamma[color][i];
+
+      setreg (s, 0x03, color << 1);
+      setreg (s, 0x04, DATA_PORT_WRITE);
+      setreg (s, 0x05, 0x00);
+      sanei_pv8630_write_byte (s->fd, PV8630_REPPADDRESS, 0x06);
+      sanei_pv8630_prep_bulkwrite (s->fd, sizeof (gamma));
+      to_write = sizeof (gamma);
+      sanei_usb_write_bulk (s->fd, gamma, &to_write);
+
+      /* check if gamma vector was correctly written */
+
+      setreg (s, 0x03, color << 1);
+      setreg (s, 0x04, DATA_PORT_READ);
+      setreg (s, 0x05, 0x00);
+      sanei_pv8630_write_byte (s->fd, PV8630_REPPADDRESS, 0x06);
+      sanei_pv8630_prep_bulkread (s->fd, sizeof (read_gamma));
+      to_read = sizeof (read_gamma);
+      status = sanei_usb_read_bulk (s->fd, read_gamma, &to_read);
+      retval = memcmp (read_gamma, gamma, sizeof (read_gamma));
+      if (retval != 0)
+	{
+	  DBG (DBG_error, "error: color %d has bad gamma table\n", color);
+	}
+#ifdef DEBUG
+      else
+	fprintf (stderr, "color %d gamma table is good\n", color);
+#endif
+    }
+
+  return 0;
+}
+
+static int
+write_default_offset_gain (HP4200_Scanner * s, SANE_Byte * gain_offset,
+			   int size, int color)
+{
+  SANE_Byte *check_data;
+  int retval;
+  size_t to_read;
+  size_t to_write;
+
+  setreg (s, 0x03, (color << 1) | 1);
+  setreg (s, 0x04, DATA_PORT_WRITE);
+  setreg (s, 0x05, 0x00);
+  sanei_pv8630_write_byte (s->fd, PV8630_REPPADDRESS, 0x06);
+  sanei_pv8630_prep_bulkwrite (s->fd, size);
+  to_write = size;
+  sanei_usb_write_bulk (s->fd, gain_offset, &to_write);
+
+  check_data = malloc (size);
+  setreg (s, 0x03, (color << 1) | 1);
+  setreg (s, 0x04, DATA_PORT_READ);
+  setreg (s, 0x05, 0x00);
+  sanei_pv8630_write_byte (s->fd, PV8630_REPPADDRESS, 0x06);
+  sanei_pv8630_prep_bulkread (s->fd, size);
+  to_read = size;
+  sanei_usb_read_bulk (s->fd, check_data, &to_read);
+  retval = memcmp (gain_offset, check_data, size);
+  free (check_data);
+  if (retval != 0)
+    {
+      DBG (DBG_error, "error: color %d has bad gain/offset table\n", color);
+    }
+#ifdef DEBUG
+  else
+    fprintf (stderr, "color %d gain/offset table is good\n", color);
+#endif
+
+  return 0;
+}
+
+static int
+compute_gain_offset (int target, int max, int min, int *gain,
+		     int *offset, int *max_gain, int *min_offset)
+{
+  int gain_stable;
+  int is_unstable;
+
+  gain_stable = 1;		/* unless the opposite is said */
+  is_unstable = 0;
+
+  if (max > target)
+    {
+      if (*gain > 0)
+	{
+	  (*gain)--;
+	  *max_gain = *gain;
+	  gain_stable = 0;
+	  is_unstable |= 1;
+	}
+      else
+	{
+	  DBG (DBG_error, "error: integration time too long.\n");
+	  return -1;
+	}
+    }
+  else
+    {
+      if (*gain < *max_gain)
+	{
+	  (*gain)++;
+	  gain_stable = 0;
+	  is_unstable |= 1;
+	}
+    }
+
+  if (min == 0)
+    {
+      if (*offset < 31)
+	{
+	  (*offset)++;
+	  if (gain_stable)
+	    *min_offset = *offset;
+	  is_unstable |= 1;
+	}
+      else
+	{
+	  DBG (DBG_error, "error: max static has pixel value == 0\n");
+	  return -1;
+	}
+    }
+  else
+    {
+      if (*offset > *min_offset)
+	{
+	  (*offset)--;
+	  is_unstable |= 1;
+	}
+    }
+  return is_unstable;
+}
+
+static int
+compute_bytes_per_line (int width_in_pixels, unsigned char hdpi_code,
+			unsigned char pixel_packing,
+			unsigned char data_mode,
+			unsigned char AFE_operation, int m)
+{
+  const int dpi_qot_mul[] = { 1, 2, 1, 1, 1, 1, 1, 1 };
+  const int dpi_qot_div[] = { 1, 3, 2, 3, 4, 6, 8, 12 };
+  int pixels_per_line;
+  int bytes_per_line;
+  int pixels_per_byte;
+  int status_bytes;
+  const int pixels_per_byte_mapping[] = { 8, 4, 2, 1 };
+
+  assert (hdpi_code <= 7);
+  pixels_per_line = (width_in_pixels * dpi_qot_mul[hdpi_code]) /
+    dpi_qot_div[hdpi_code];
+  if ((width_in_pixels * dpi_qot_mul[hdpi_code]) % dpi_qot_div[hdpi_code])
+    pixels_per_line++;
+
+
+  status_bytes = (m == 0) ? 1 : m;
+
+  if (data_mode == 1)
+    pixels_per_byte = 1;	/* should be 0.5 but later
+				   bytes_per_line will be multiplied
+				   by 2, and also the number of status
+				   bytes, that in this case should be
+				   2.
+				   umm.. maybe this should be done in
+				   the cleaner way.
+				 */
+  else
+    {
+      assert (pixel_packing <= 3);
+      pixels_per_byte = pixels_per_byte_mapping[pixel_packing];
+    }
+
+  switch (AFE_operation)
+    {
+    case PIXEL_RATE_3_CHANNELS:
+      bytes_per_line = ((pixels_per_line * 3) / pixels_per_byte) +
+	status_bytes;
+      break;
+    case MODEA_1_CHANNEL:
+      bytes_per_line = (pixels_per_line / pixels_per_byte) + status_bytes;
+      break;
+    default:
+      /* Not implemented! (yet?) and not used.
+       * This case should not happen. */
+      assert (0);
+    }
+
+  if (data_mode == 1)		/* see big note above */
+    bytes_per_line *= 2;
+
+  return bytes_per_line;
+}
+
+static int
+compute_pause_limit (hardware_parameters_t * hw_parms, int bytes_per_line)
+{
+  int coef_size;
+  const int coef_mapping[] = { 16, 32 };
+  int pause_limit;
+
+  coef_size = coef_mapping[hw_parms->sensor_resolution & 0x01];
+  pause_limit = hw_parms->SRAM_size - coef_size - (bytes_per_line / 1024) - 1;
+
+  if (pause_limit > 2)
+    pause_limit -= 2;
+
+  return pause_limit;
+}
+
+static int
+compute_dpd (HP4200_Scanner * s, int step_size, int line_end)
+{
+  int tr, dpd;
+
+  tr = 1 /* color mode */  *
+    (line_end + ((s->hw_parms.num_tr_pulses + 1) *
+		 (2 * s->hw_parms.guard_band_duration +
+		  s->hw_parms.pulse_duration + 1) +
+		 3 - s->hw_parms.num_tr_pulses));
+
+  if (tr == 0)
+    return 0;
+
+  dpd = (((s->hw_parms.fsteps_25_speed * 4) +
+	  (s->hw_parms.fsteps_50_speed * 2) +
+	  s->hw_parms.steps_to_reverse) * 4 * step_size) % tr;
+  dpd = tr - dpd;
+
+  return dpd;
+}
+
+static SANE_Status
+read_required_bytes (HP4200_Scanner * s, int required, SANE_Byte * buffer)
+{
+  int read_count = 0;
+  unsigned char scankb1;
+  unsigned char scankb2;
+  size_t to_read;
+  size_t really_read;
+  size_t chunk;
+  SANE_Status status;
+
+  assert (buffer != NULL);
+
+  while (required)
+    {
+      do
+	{
+	  scankb1 = getreg (s, 0x01);
+	  scankb2 = getreg (s, 0x01);
+	  if (s->aborted_by_user)
+	    return SANE_STATUS_CANCELLED;
+	}
+      while ((scankb1 != scankb2) || (scankb1 < 12));
+
+      to_read = min (required, (scankb1 * 1024));
+      while (to_read)
+	{
+	  if (s->aborted_by_user)
+	    return SANE_STATUS_CANCELLED;
+	  chunk = (to_read > 0xffff) ? 0xffff : to_read;
+
+	  sanei_pv8630_write_byte (s->fd, PV8630_REPPADDRESS, 0x00);
+	  sanei_pv8630_prep_bulkread (s->fd, chunk);
+	  really_read = chunk;
+	  if ((status = sanei_usb_read_bulk (s->fd, buffer, &really_read)) !=
+	      SANE_STATUS_GOOD)
+	    {
+	      DBG (DBG_error, "sanei_usb_read_bulk failed (%s)\n",
+		   sane_strstatus (status));
+	      return status;
+	    }
+	  if (really_read > chunk)
+	    {
+	      DBG (DBG_error, "USB stack read more bytes than requested!\n");
+	      return SANE_STATUS_IO_ERROR;
+	    }
+	  buffer += really_read;
+	  required -= really_read;
+	  to_read -= really_read;
+	  read_count += really_read;
+	}
+    }
+
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+scanner_buffer_init (scanner_buffer_t * sb, int size_in_kb)
+{
+
+  sb->size = size_in_kb * 1024 + 3;
+  sb->buffer = malloc (sb->size);
+  if (!sb->buffer)
+    return SANE_STATUS_NO_MEM;
+  sb->num_bytes = 0;
+  sb->data_ptr = sb->buffer;
+
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+scanner_buffer_read (HP4200_Scanner * s)
+{
+  SANE_Status status;
+  size_t num_bytes_read_now;
+
+  assert (s->scanner_buffer.num_bytes <= 3);
+
+  memcpy (s->scanner_buffer.buffer, s->scanner_buffer.data_ptr, 3);
+
+  status = read_available_data (s, s->scanner_buffer.buffer +
+				s->scanner_buffer.num_bytes,
+				&num_bytes_read_now);
+  s->scanner_buffer.data_ptr = s->scanner_buffer.buffer;
+  s->scanner_buffer.num_bytes += num_bytes_read_now;
+  return status;
+}
+
+#define OFFSET_CODE_SIGN(off) (((off) < 0) ? (-(off) & 0x1f) | 0x20 : (off))
+#define OFFSET_DECODE_SIGN(off) (((off) & 0x20) ? -(off & 0x1f) : (off))
+
+static SANE_Status
+do_coarse_calibration (HP4200_Scanner * s, struct coarse_t *coarse)
+{
+  SANE_Status status;
+  unsigned char *cal_line = NULL;
+  unsigned char *cal_line_ptr;
+  int cal_line_size;
+  /* local scanning params */
+  int active_pixels_start;
+  int line_end;
+  int data_pixels_start;
+  int data_pixels_end;
+  int dpd;
+  int step_size;
+  int ff_step_size;
+  char steps_to_reverse;
+  char hdpi_div;
+  char line_rate_color;
+  int vdpi;			/* vertical dots per inch */
+  int hdpi_code;
+  int calibrated;
+  int first_time;
+
+  int red_offset = 0;
+  int green_offset = 0;
+  int blue_offset = 0;
+
+  int red_gain = 1;
+  int green_gain = 1;
+  int blue_gain = 1;
+
+  int min_red_offset = -31;
+  int min_green_offset = -31;
+  int min_blue_offset = -31;
+
+  int max_red_gain = 63;
+  int max_green_gain = 63;
+  int max_blue_gain = 63;
+
+  int max_red;
+  int min_red;
+  int max_green;
+  int min_green;
+  int max_blue;
+  int min_blue;
+  static char me[] = "do_coarse_calibration";
+
+  DBG (DBG_proc, "%s\n", me);
+
+  setreg (s, 0x07, 0x00);
+  usleep (10 * 1000);
+
+  vdpi = 150;
+  hdpi_code = 0;
+  hdpi_div = hdpi_mapping[hdpi_code];
+  active_pixels_start = 0x40;
+  line_end = 0x2ee0;
+  s->mclk_div = 2;
+  data_pixels_start = 0x40;
+  data_pixels_end = (int) (data_pixels_start + s->hw_parms.scan_area_width);
+  data_pixels_end = min (data_pixels_end, line_end - 20);
+
+  cal_line_size = s->hw_parms.scan_area_width * 3 * 2 + 2;
+
+  setreg (s, 0x1e, HIBYTE (active_pixels_start));
+  setreg (s, 0x1f, LOBYTE (active_pixels_start));
+  setreg (s, 0x20, HIBYTE (line_end));
+  setreg (s, 0x21, LOBYTE (line_end));
+  setreg (s, 0x22, HIBYTE (data_pixels_start));
+  setreg (s, 0x23, LOBYTE (data_pixels_start));
+  setreg (s, 0x24, HIBYTE (data_pixels_end));
+  setreg (s, 0x25, LOBYTE (data_pixels_end));
+
+  setreg (s, 0x26,
+	  PIXEL_RATE_3_CHANNELS |
+	  GRAY_CHANNEL_RED | TR_RED (0) | TR_GREEN (0) | TR_BLUE (0));
+
+
+  setreg (s, 0x08, (s->mclk_div - 1) * 2);
+  setreg (s, 0x09, hdpi_code | PIXEL_PACKING (3) | DATAMODE (1));
+  setreg (s, 0x0a, 0);		/* reserved and strange register */
+
+  setreg (s, 0x38, red_offset);
+  setreg (s, 0x39, green_offset);
+  setreg (s, 0x3a, blue_offset);
+  setreg (s, 0x3b, red_gain);
+  setreg (s, 0x3c, green_gain);
+  setreg (s, 0x3d, blue_gain);
+
+  setreg (s, 0x5e, 0x80);
+
+  setreg (s, 0x3e, 0x00);	/* 1.5:1, 6/10 bits, 2*fixed */
+  setreg (s, 0x3f, 0x00);
+  setreg (s, 0x40, 0x00);
+  setreg (s, 0x41, 0x00);
+
+  setreg (s, 0x4e, 0x5b - 0x3c);	/* max Kb to pause */
+  setreg (s, 0x4f, 0x02);	/* min Kb to resume */
+
+  line_rate_color = 1;
+  step_size = (vdpi * line_end * line_rate_color) /
+    (4 * s->hw_parms.motor_full_steps_per_inch);
+
+  dpd = compute_dpd (s, step_size, line_end);	/* 0x0ada; */
+#ifdef DEBUG
+  fprintf (stderr, "dpd = %d\n", dpd);
+#endif
+  setreg (s, 0x52, HIBYTE (dpd));
+  setreg (s, 0x53, LOBYTE (dpd));
+
+  setreg (s, 0x46, HIBYTE (step_size));
+  setreg (s, 0x47, LOBYTE (step_size));
+
+  ff_step_size = compute_fastfeed_step_size (s->hw_parms.crystal_frequency, s->mclk_div, s->hw_parms.motor_max_speed, s->hw_parms.motor_full_steps_per_inch, 0);	/* 0x0190; */
+  setreg (s, 0x48, HIBYTE (ff_step_size));
+  setreg (s, 0x49, LOBYTE (ff_step_size));
+  setreg (s, 0x4b, 0x15);
+  steps_to_reverse = 0x3f;
+  setreg (s, 0x50, steps_to_reverse);
+  setreg (s, 0x51, 0x15);	/* accel profile */
+
+  /* this is to stay the motor stopped */
+  clearbits (s, 0x45, (1 << 4));
+
+  cache_write (s);
+
+  calibrated = 0;
+  first_time = 1;
+  cal_line = malloc (cal_line_size + 1024);
+
+  do
+    {
+      unsigned char cmd_reg;
+
+      /* resets the lm9830 before start scanning */
+      setreg (s, 0x07, 0x08);
+      do
+	{
+	  setreg (s, 0x07, 0x03);
+	  cmd_reg = getreg (s, 0x07);
+	}
+      while (cmd_reg != 0x03);
+
+      cal_line_ptr = cal_line;
+      status = read_required_bytes (s, cal_line_size, cal_line_ptr);
+      if (status != SANE_STATUS_GOOD)
+	goto done;
+
+      setreg (s, 0x07, 0x00);
+      {
+	unsigned int i;
+	min_red = max_red = (cal_line[0] * 256 + cal_line[1]) >> 2;
+	min_green = max_green = (cal_line[2] * 256 + cal_line[3]) >> 2;
+	min_blue = max_blue = (cal_line[4] * 256 + cal_line[5]) >> 2;
+	for (i = 6; i < (s->hw_parms.scan_area_width * 3 * 2); i += 6)
+	  {
+	    int value;
+
+	    value = cal_line[i] * 256 + cal_line[i + 1];
+	    value >>= 2;
+	    if (value > max_red)
+	      max_red = value;
+	    value = cal_line[i + 2] * 256 + cal_line[i + 3];
+	    value >>= 2;
+	    if (value > max_green)
+	      max_green = value;
+	    value = cal_line[i + 4] * 256 + cal_line[i + 5];
+	    value >>= 2;
+	    if (value > max_blue)
+	      max_blue = value;
+	    value = cal_line[i] * 256 + cal_line[i + 1];
+	    value >>= 2;
+	    if (value < min_red)
+	      min_red = value;
+	    value = cal_line[i + 2] * 256 + cal_line[i + 3];
+	    value >>= 2;
+	    if (value < min_green)
+	      min_green = value;
+	    value = cal_line[i + 4] * 256 + cal_line[i + 5];
+	    value >>= 2;
+	    if (value < min_blue)
+	      min_blue = value;
+	  }
+#ifdef DEBUG
+	fprintf (stderr, "max_red:%d max_green:%d max_blue:%d\n",
+		 max_red, max_green, max_blue);
+	fprintf (stderr, "min_red:%d min_green:%d min_blue:%d\n",
+		 min_red, min_green, min_blue);
+#endif
+
+	if (first_time)
+	  {
+	    first_time = 0;
+	    compute_first_gain_offset (s->hw_parms.target_value.red,
+				       max_red, min_red,
+				       &red_gain, &red_offset,
+				       &max_red_gain, &min_red_offset);
+	    compute_first_gain_offset (s->hw_parms.target_value.green,
+				       max_green, min_green,
+				       &green_gain, &green_offset,
+				       &max_green_gain, &min_green_offset);
+	    compute_first_gain_offset (s->hw_parms.target_value.blue,
+				       max_blue, min_blue, &blue_gain,
+				       &blue_offset, &max_blue_gain,
+				       &min_blue_offset);
+	  }
+	else
+	  {
+	    int retval;
+
+	    /* this code should check return value -1 for error */
+
+	    retval = compute_gain_offset (s->hw_parms.target_value.red,
+					  max_red, min_red,
+					  &red_gain, &red_offset,
+					  &max_red_gain, &min_red_offset);
+	    if (retval < 0)
+	      break;
+	    retval |= compute_gain_offset (s->hw_parms.target_value.green,
+					   max_green, min_green,
+					   &green_gain, &green_offset,
+					   &max_green_gain,
+					   &min_green_offset);
+	    if (retval < 0)
+	      break;
+	    retval |= compute_gain_offset (s->hw_parms.target_value.blue,
+					   max_blue, min_blue,
+					   &blue_gain, &blue_offset,
+					   &max_blue_gain, &min_blue_offset);
+	    if (retval < 0)
+	      break;
+	    calibrated = !retval;
+	  }
+
+	setreg (s, 0x3b, red_gain);
+	setreg (s, 0x3c, green_gain);
+	setreg (s, 0x3d, blue_gain);
+
+	setreg (s, 0x38, OFFSET_CODE_SIGN (red_offset));
+	setreg (s, 0x39, OFFSET_CODE_SIGN (green_offset));
+	setreg (s, 0x3a, OFFSET_CODE_SIGN (blue_offset));
+
+#ifdef DEBUG
+	fprintf (stderr, "%d, %d, %d   %d, %d, %d\n", red_gain,
+		 green_gain, blue_gain, red_offset, green_offset,
+		 blue_offset);
+#endif
+	cache_write (s);
+      }
+    }
+  while (!calibrated);
+  coarse->min_red = min_red;
+  coarse->min_green = min_green;
+  coarse->min_blue = min_blue;
+  coarse->max_red = max_red;
+  coarse->max_green = max_green;
+  coarse->max_blue = max_blue;
+  coarse->red_gain = red_gain;
+  coarse->green_gain = green_gain;
+  coarse->blue_gain = blue_gain;
+  coarse->red_offset = red_offset;
+  coarse->green_offset = green_offset;
+  coarse->blue_offset = blue_offset;
+
+  status = SANE_STATUS_GOOD;
+
+done:
+  if (cal_line)
+    free (cal_line);
+
+  return status;
+}
+
+static int
+compute_corr_code (int average, int min_color, int range, int target)
+{
+  int value;
+  int corr_code;
+
+  value = average - min_color;
+  if (value > 0)
+    corr_code =
+      (int) (range * ((double) target / (double) value - 1.0) + 0.5);
+  else
+    corr_code = 0;
+  if (corr_code < 0)
+    corr_code = 0;
+  else if (corr_code > 2048)
+    corr_code = 0;
+  else if (corr_code > 1023)
+    corr_code = 1023;
+  return corr_code;
+}
+
+static int
+compute_hdpi_code (int hres)
+{
+  int hdpi_code;
+
+  /* Calculate the horizontal DPI code based on the requested
+     horizontal resolution.  Defaults to 150dpi.  */
+  switch (hres)
+    {
+    case 600:
+      hdpi_code = 0;
+      break;
+    case 400:
+      hdpi_code = 1;
+      break;
+    case 300:
+      hdpi_code = 2;
+      break;
+    case 200:
+      hdpi_code = 3;
+      break;
+    case 150:
+      hdpi_code = 4;
+      break;
+    case 100:
+      hdpi_code = 5;
+      break;
+    case 75:
+      hdpi_code = 6;
+      break;
+    case 50:
+      hdpi_code = 7;
+      break;
+    default:
+      hdpi_code = 4;
+    }
+  return hdpi_code;
+}
+
+
+static SANE_Status
+do_fine_calibration (HP4200_Scanner * s, struct coarse_t *coarse)
+{
+  SANE_Status status;
+  unsigned char *cal_line;
+  unsigned char *cal_line_ptr;
+  int *average;
+  SANE_Byte red_gain_offset[5460 * 2];
+  SANE_Byte green_gain_offset[5460 * 2];
+  SANE_Byte blue_gain_offset[5460 * 2];
+  int *corr_red = NULL;
+  int *corr_green = NULL;
+  int *corr_blue = NULL;
+  int registro[30][5460 * 3];
+  int cal_line_size;
+  /* local scanning params */
+  int active_pixels_start;
+  int line_end;
+  int line_length;
+  int data_pixels_start;
+  int data_pixels_end;
+  int dpd;
+  int step_size;
+  int ff_step_size;
+  char steps_to_reverse;
+  char hdpi_div;
+  char line_rate_color;
+  int vdpi;			/* vertical dots per inch */
+  int hdpi_code;
+  int calibrated;
+  int first_time;
+  int lines_to_process;
+
+  static char me[] = "do_fine_calibration";
+
+  DBG (DBG_proc, "%s\n", me);
+
+  setreg (s, 0x07, 0x00);
+  usleep (10 * 1000);
+
+  vdpi = 150;
+  hdpi_code = compute_hdpi_code (s->user_parms.horizontal_resolution);
+
+  /* figure out which horizontal divider to use based on the
+     calculated horizontal dpi code */
+  hdpi_div = hdpi_mapping[hdpi_code];
+  active_pixels_start = 0x40;
+  line_end = 0x2ee0;
+  line_length = s->user_parms.image_width * hdpi_div;
+  s->mclk_div = 2;
+  data_pixels_start = 0x72 + s->runtime_parms.first_pixel * hdpi_div;
+  data_pixels_end =
+    (int) (data_pixels_start + s->user_parms.image_width * hdpi_div);
+  data_pixels_end = min (data_pixels_end, line_end - 20);
+
+  cal_line_size = line_length * 3 * 2 + 2;
+
+  setreg (s, 0x1e, HIBYTE (active_pixels_start));
+  setreg (s, 0x1f, LOBYTE (active_pixels_start));
+  setreg (s, 0x20, HIBYTE (line_end));
+  setreg (s, 0x21, LOBYTE (line_end));
+  setreg (s, 0x22, HIBYTE (data_pixels_start));
+  setreg (s, 0x23, LOBYTE (data_pixels_start));
+  setreg (s, 0x24, HIBYTE (data_pixels_end));
+  setreg (s, 0x25, LOBYTE (data_pixels_end));
+
+  setreg (s, 0x26,
+	  PIXEL_RATE_3_CHANNELS |
+	  GRAY_CHANNEL_RED | TR_RED (0) | TR_GREEN (0) | TR_BLUE (0));
+
+
+  setreg (s, 0x08, (s->mclk_div - 1) * 2);
+  setreg (s, 0x09, 0 | PIXEL_PACKING (3) | DATAMODE (1));
+  setreg (s, 0x0a, 0);		/* reserved and strange register */
+
+  setreg (s, 0x38, 1);
+  setreg (s, 0x39, 1);
+  setreg (s, 0x3a, 1);
+  setreg (s, 0x3b, coarse->red_gain);
+  setreg (s, 0x3c, coarse->green_gain);
+  setreg (s, 0x3d, coarse->blue_gain);
+
+  setreg (s, 0x5e, 0x80);
+
+  setreg (s, 0x3e, 0x00);	/* 1.5:1, 6/10 bits, 2*fixed */
+  setreg (s, 0x3f, 0x00);
+  setreg (s, 0x40, 0x00);
+  setreg (s, 0x41, 0x00);
+
+  setreg (s, 0x4e, 0x5b - 0x3c);	/* max Kb to pause */
+  setreg (s, 0x4f, 0x02);	/* min Kb to resume */
+
+  line_rate_color = 1;
+  step_size = (vdpi * line_end * line_rate_color) /
+    (4 * s->hw_parms.motor_full_steps_per_inch);
+
+  dpd = compute_dpd (s, step_size, line_end);	/* 0x0ada; */
+#ifdef DEBUG
+  fprintf (stderr, "dpd = %d\n", dpd);
+#endif
+  setreg (s, 0x52, HIBYTE (dpd));
+  setreg (s, 0x53, LOBYTE (dpd));
+
+  setreg (s, 0x46, HIBYTE (step_size));
+  setreg (s, 0x47, LOBYTE (step_size));
+
+  ff_step_size = compute_fastfeed_step_size (s->hw_parms.crystal_frequency, s->mclk_div, s->hw_parms.motor_max_speed, s->hw_parms.motor_full_steps_per_inch, 0);	/* 0x0190; */
+  setreg (s, 0x48, HIBYTE (ff_step_size));
+  setreg (s, 0x49, LOBYTE (ff_step_size));
+  setreg (s, 0x4b, 0x15);
+  steps_to_reverse = 0x3f;
+  setreg (s, 0x50, steps_to_reverse);
+  setreg (s, 0x51, 0x15);	/* accel profile */
+
+  /* this is to activate the motor */
+  setbits (s, 0x45, (1 << 4));
+
+  lines_to_process = 8 * step_size * 4 / line_end;
+  if (lines_to_process < 1)
+    lines_to_process = 1;
+
+#ifdef DEBUG
+  fprintf (stderr, "lines to process = %d\n", lines_to_process);
+#endif
+
+  setreg (s, 0x58, 0);
+
+  cache_write (s);
+
+  calibrated = 0;
+  first_time = 1;
+  cal_line = malloc (cal_line_size + 1024);
+  average = malloc (sizeof (int) * line_length * 3);
+  memset (average, 0, sizeof (int) * line_length * 3);
+  {
+    int i;
+    for (i = 0; i < 12; i++)
+      {
+	memset (registro[i], 0, 5460 * 3);
+      }
+  }
+
+  /* resets the lm9830 before start scanning */
+  setreg (s, 0x07, 0x08);
+  setreg (s, 0x07, 0x03);
+
+  usleep (100);
+
+  do
+    {
+
+      cal_line_ptr = cal_line;
+
+      status = read_required_bytes (s, cal_line_size, cal_line_ptr);
+      if (status != SANE_STATUS_GOOD)
+	goto done;
+      {
+	int i, j;
+
+	if (calibrated == 0)
+	  for (j = 0, i = 0; i < (line_length * 3); i++, j += 2)
+	    {
+	      average[i] = (cal_line[j] * 256 + cal_line[j + 1]) >> 2;
+	      registro[calibrated][i] = average[i];
+	    }
+	else
+	  for (j = 0, i = 0; i < (line_length * 3); i++, j += 2)
+	    {
+	      int value;
+	      value = (cal_line[j] * 256 + cal_line[j + 1]) >> 2;
+	      average[i] += value;
+	      average[i] /= 2;
+	      registro[calibrated][i] = value;
+	    }
+      }
+      calibrated++;
+    }
+  while (calibrated < lines_to_process);
+  lm9830_write_register (s->fd, 0x07, 0x00);
+  usleep (10 * 1000);
+
+#if 0
+  {
+    int i;
+    int j = 0;
+    do
+      {
+	for (i = 3; (i + 6) < (line_length * 3); i += 3)
+	  {
+	    average[i] =
+	      (2 * average[i - 3] + average[i] + 2 * average[i + 3]) / 5;
+	    average[i + 1] =
+	      (2 * average[i - 2] + average[i + 1] + 2 * average[i + 4]) / 5;
+	    average[i + 2] =
+	      (2 * average[i - 1] + average[i + 2] + 2 * average[i + 5]) / 5;
+	  }
+	j++;
+      }
+    while (j < 3);
+  }
+#endif
+  {
+    int i;
+    int max_red;
+    int min_red;
+    int max_green;
+    int min_green;
+    int max_blue;
+    int min_blue;
+    min_red = max_red = average[0];
+    min_green = max_green = average[1];
+    min_blue = max_blue = average[2];
+    for (i = 3; i < (line_length * 3); i += 3)
+      {
+	int value;
+
+	value = average[i];
+	if (value > max_red)
+	  max_red = value;
+	value = average[i + 1];
+	if (value > max_green)
+	  max_green = value;
+	value = average[i + 2];
+	if (value > max_blue)
+	  max_blue = value;
+	value = average[i];
+	if (value < min_red)
+	  min_red = value;
+	value = average[i + 1];
+	if (value < min_green)
+	  min_green = value;
+	value = average[i + 2];
+	if (value < min_blue)
+	  min_blue = value;
+      }
+#ifdef DEBUG
+    fprintf (stderr, "max_red:%d max_green:%d max_blue:%d\n",
+	     max_red, max_green, max_blue);
+    fprintf (stderr, "min_red:%d min_green:%d min_blue:%d\n",
+	     min_red, min_green, min_blue);
+#endif
+
+    /* do fine calibration */
+    {
+      int min_white_red;
+      int min_white_green;
+      int min_white_blue;
+      double ratio;
+      int range;
+      double aux;
+      int min_white_err;
+      int j;
+
+      min_white_red = min_white_green = min_white_blue = 0x3ff;
+      for (i = 0; i < (line_length * 3); i += 3)
+	{
+	  int value;
+
+	  value = average[i] - coarse->min_red;
+	  if ((value > 0) && (value < min_white_red))
+	    min_white_red = value;
+	  value = average[i + 1] - coarse->min_green;
+	  if ((value > 0) && (value < min_white_green))
+	    min_white_green = value;
+	  value = average[i + 2] - coarse->min_blue;
+	  if ((value > 0) && (value < min_white_blue))
+	    min_white_blue = value;
+	}
+
+      ratio = 0;
+      min_white_err = 0x3ff;
+
+      aux = (double) s->hw_parms.target_value.red / min_white_red;
+      if (aux > ratio)
+	ratio = aux;
+      if (min_white_err > min_white_red)
+	min_white_err = min_white_red;
+      aux = (double) s->hw_parms.target_value.green / min_white_green;
+      if (aux > ratio)
+	ratio = aux;
+      if (min_white_err > min_white_green)
+	min_white_err = min_white_green;
+      aux = (double) s->hw_parms.target_value.blue / min_white_blue;
+      if (aux > ratio)
+	ratio = aux;
+      if (min_white_err > min_white_blue)
+	min_white_err = min_white_blue;
+
+#ifdef DEBUG
+      fprintf (stderr, "min_white_err = %d, ratio = %f\n",
+	       min_white_err, ratio);
+#endif
+      if (ratio <= 1.5)
+	range = 2048;
+      else if (ratio <= 2.0)
+	range = 1024;
+      else
+	range = 512;
+
+      corr_red = malloc (sizeof (int) * line_length);
+      corr_green = malloc (sizeof (int) * line_length);
+      corr_blue = malloc (sizeof (int) * line_length);
+
+      for (i = 0, j = 0; i < (line_length * 3); i += 3, j++)
+	{
+	  corr_red[j] = compute_corr_code (average[i],
+					   coarse->min_red,
+					   range,
+					   s->hw_parms.target_value.red);
+	  corr_green[j] =
+	    compute_corr_code (average[i + 1], coarse->min_green,
+			       range, s->hw_parms.target_value.green);
+	  corr_blue[j] =
+	    compute_corr_code (average[i + 2], coarse->min_blue,
+			       range, s->hw_parms.target_value.blue);
+	}
+#ifdef DEBUG
+      {
+	FILE *kaka;
+	int i;
+	kaka = fopen ("corr.raw", "w");
+	for (i = 0; i < line_length; i++)
+	  {
+	    fprintf (kaka, "%d %d %d %d %d %d ",
+		     corr_red[i], corr_green[i], corr_blue[i],
+		     average[3 * i], average[3 * i + 1], average[3 * i + 2]);
+	    fprintf (kaka, "%d %d %d  %d %d %d  %d %d %d ",
+		     registro[0][3 * i], registro[0][3 * i + 1],
+		     registro[0][3 * i + 2], registro[1][3 * i],
+		     registro[1][3 * i + 1], registro[1][3 * i + 2],
+		     registro[2][3 * i], registro[2][3 * i + 1],
+		     registro[2][3 * i + 2]);
+	    fprintf (kaka, "%d %d %d  %d %d %d  %d %d %d\n",
+		     registro[3][3 * i], registro[3][3 * i + 1],
+		     registro[3][3 * i + 2], registro[4][3 * i],
+		     registro[4][3 * i + 1], registro[4][3 * i + 2],
+		     registro[5][3 * i], registro[5][3 * i + 1],
+		     registro[5][3 * i + 2]);
+	  }
+	fclose (kaka);
+      }
+#endif
+      {
+	int max_black;
+	int use_six_eight_bits;
+
+	max_black = max (coarse->min_red, coarse->min_green);
+	max_black = max (max_black, coarse->min_blue);
+	use_six_eight_bits = (max_black < 64);
+
+	if (use_six_eight_bits)
+	  {
+	    setreg (s, 0x3e, (1 << 4) | (1 << 3) | (1024 / range));
+	  }
+	else
+	  {
+	    setreg (s, 0x3e, (1 << 4) | (1 << 3) | (1 << 2) | (1024 / range));
+	  }
+	memset (red_gain_offset, 0, sizeof (red_gain_offset));
+	memset (green_gain_offset, 0, sizeof (green_gain_offset));
+	memset (blue_gain_offset, 0, sizeof (blue_gain_offset));
+	for (i = 0, j = (data_pixels_start - active_pixels_start) * 2;
+	     i < line_length; i++, j += 2)
+	  {
+	    if (use_six_eight_bits)
+	      {
+		red_gain_offset[j] = (coarse->min_red << 2) |
+		  ((corr_red[i] >> 8) & 0x03);
+		red_gain_offset[j + 1] = corr_red[i] & 0xff;
+		green_gain_offset[j] = (coarse->min_green << 2) |
+		  ((corr_green[i] >> 8) & 0x03);
+		green_gain_offset[j + 1] = corr_green[i] & 0xff;
+		blue_gain_offset[j] = (coarse->min_blue << 2) |
+		  ((corr_blue[i] >> 8) & 0x03);
+		blue_gain_offset[j + 1] = corr_blue[i] & 0xff;
+	      }
+	    else
+	      {
+		red_gain_offset[j] = coarse->min_red;
+		red_gain_offset[j + 1] = corr_red[j] >> 2;
+		green_gain_offset[j] = coarse->min_green;
+		green_gain_offset[j + 1] = corr_green[j] >> 2;
+		blue_gain_offset[j] = coarse->min_blue;
+		blue_gain_offset[j + 1] = corr_blue[j] >> 2;
+	      }
+	  }
+	write_default_offset_gain (s, red_gain_offset, 5460 * 2, 0);
+	write_default_offset_gain (s, green_gain_offset, 5460 * 2, 1);
+	write_default_offset_gain (s, blue_gain_offset, 5460 * 2, 2);
+      }
+    }
+  }
+
+  status = SANE_STATUS_GOOD;
+
+done:
+  if (corr_red)
+    free (corr_red);
+  if (corr_green)
+    free (corr_green);
+  if (corr_blue)
+    free (corr_blue);
+  if (cal_line)
+    free (cal_line);
+  if (average)
+    free (average);
+
+  return status;
+}
+
+static void
+ciclic_buffer_init_offset_correction (ciclic_buffer_t * cb, int vres)
+{
+  cb->blue_idx = 0;
+  switch (vres)
+    {
+    case 600:
+      cb->green_idx = 4;
+      cb->red_idx = 8;
+      cb->first_good_line = 8;
+      break;
+    case 400:
+      cb->green_idx = 3;
+      cb->red_idx = 6;
+      cb->first_good_line = 6;
+      break;
+    case 300:
+      cb->green_idx = 2;
+      cb->red_idx = 4;
+      cb->first_good_line = 4;
+      break;
+    case 200:
+      cb->blue_idx = 0;
+      cb->green_idx = 1;
+      cb->red_idx = 2;
+      cb->first_good_line = 4;
+      break;
+    case 150:
+      cb->green_idx = 1;
+      cb->red_idx = 2;
+      cb->first_good_line = 2;
+      break;
+    case 75:
+      cb->green_idx = 1;
+      cb->red_idx = 2;
+      cb->first_good_line = 2;
+      break;
+    default:
+      cb->green_idx = 0;
+      cb->red_idx = 0;
+      cb->first_good_line = 0;
+      break;
+    }
+
+  cb->buffer_position = cb->buffer_ptrs[cb->first_good_line];
+}
+
+static SANE_Status
+ciclic_buffer_init (ciclic_buffer_t * cb, SANE_Int bytes_per_line,
+		    int vres, int status_bytes)
+{
+  cb->good_bytes = 0;
+  cb->num_lines = 12;
+  cb->size = bytes_per_line * cb->num_lines;
+  cb->can_consume = cb->size + cb->num_lines * status_bytes;
+
+  cb->buffer = malloc (cb->size);
+  if (!cb->buffer)
+    return SANE_STATUS_NO_MEM;
+
+  {
+    int i;
+    unsigned char *buffer;
+    unsigned char **ptrs;
+
+    ptrs = cb->buffer_ptrs = (unsigned char **)
+      malloc (sizeof (unsigned char *) * cb->num_lines);
+    if (!cb->buffer_ptrs)
+      return SANE_STATUS_NO_MEM;
+
+    buffer = cb->buffer;
+    for (i = 0; i < cb->num_lines; i++)
+      {
+	ptrs[i] = buffer;
+	buffer += bytes_per_line;
+      }
+  }
+
+  cb->current_line = 0;
+  cb->pixel_position = 0;
+  ciclic_buffer_init_offset_correction (cb, vres);
+
+  return SANE_STATUS_GOOD;
+}
+
+static int
+prepare_for_a_scan (HP4200_Scanner * s)
+{
+  /* local scanning params */
+  int active_pixels_start;
+  int line_end;
+  int data_pixels_start;
+  int data_pixels_end;
+  int ff_step_size;
+  int dpd;
+  int step_size;
+  char steps_to_reverse;
+  char hdpi_div;
+  char line_rate_color;
+  int hdpi_code;
+  unsigned char pixel_packing;
+  unsigned char data_mode;
+  unsigned char AFE_operation;
+  int pause_limit;
+  int n = 0, m = 0;
+
+  setreg (s, 0x07, 0x00);
+  usleep (10 * 1000);
+
+  hdpi_code = compute_hdpi_code (s->user_parms.horizontal_resolution);
+  /* figure out which horizontal divider to use based on the
+     calculated horizontal dpi code */
+  hdpi_div = hdpi_mapping[hdpi_code];
+
+  /* image_width is set to the correct number of pixels by calling 
+     fxn.  This might be the reason we can't do high res full width
+     scans though...not sure.  */
+  /*s->user_parms.image_width /= 4; */
+  active_pixels_start = 0x40;
+  line_end = 0x2ee0;		/* 2ee0 */
+  s->mclk_div = 2;
+  data_pixels_start = 0x72 + s->runtime_parms.first_pixel * hdpi_div;
+  data_pixels_end =
+    (int) (data_pixels_start + s->user_parms.image_width * hdpi_div);
+  data_pixels_end = min (data_pixels_end, line_end - 20);
+  setreg (s, 0x1e, HIBYTE (active_pixels_start));
+  setreg (s, 0x1f, LOBYTE (active_pixels_start));
+  setreg (s, 0x20, HIBYTE (line_end));
+  setreg (s, 0x21, LOBYTE (line_end));
+  setreg (s, 0x22, HIBYTE (data_pixels_start));
+  setreg (s, 0x23, LOBYTE (data_pixels_start));
+  setreg (s, 0x24, HIBYTE (data_pixels_end));
+  setreg (s, 0x25, LOBYTE (data_pixels_end));
+
+  AFE_operation = PIXEL_RATE_3_CHANNELS;
+  setreg (s, 0x26,
+	  AFE_operation |
+	  GRAY_CHANNEL_RED | TR_RED (0) | TR_GREEN (0) | TR_BLUE (0));
+
+  setreg (s, 0x08, (s->mclk_div - 1) * 2);
+  pixel_packing = 3;
+  data_mode = 0;
+  setreg (s, 0x09, hdpi_code | PIXEL_PACKING (pixel_packing) |
+	  DATAMODE (data_mode));
+  setreg (s, 0x0a, 0);		/* reserved and strange register */
+
+  setreg (s, 0x5c, 0x00);
+  setreg (s, 0x5d, 0x00);
+  setreg (s, 0x5e, 0x00);
+
+  if (s->user_parms.vertical_resolution == 1200)
+    {
+      /* 1 out of 2 */
+      n = 1;
+      m = 2;
+    }
+  setreg (s, 0x44, (256 - n) & 0xff);
+  setreg (s, 0x5a, m);
+  s->runtime_parms.status_bytes = (m == 0) ? 1 : m;
+  if (data_mode == 1)
+    s->runtime_parms.status_bytes *= 2;
+
+  s->runtime_parms.scanner_line_size =
+    compute_bytes_per_line (data_pixels_end - data_pixels_start,
+			    hdpi_code, pixel_packing, data_mode,
+			    AFE_operation, m);
+  pause_limit = compute_pause_limit (&(s->hw_parms),
+				     s->runtime_parms.scanner_line_size);
+
+#ifdef DEBUG
+  fprintf (stderr, "scanner_line_size = %d\npause_limit = %d\n",
+	   s->runtime_parms.scanner_line_size, pause_limit);
+#endif
+
+  setreg (s, 0x4e, pause_limit);	/* max Kb to pause */
+  setreg (s, 0x4f, 0x02);	/* min Kb to resume */
+
+  line_rate_color = 1;
+  step_size =
+    (s->user_parms.vertical_resolution * line_end * line_rate_color) /
+    (4 * s->hw_parms.motor_full_steps_per_inch);
+
+  if (s->val[OPT_BACKTRACK].b)
+    {
+      steps_to_reverse = 0x3f;
+      setreg (s, 0x50, steps_to_reverse);
+      setreg (s, 0x51, 0x15);	/* accel profile */
+    }
+  else
+    {
+      s->hw_parms.steps_to_reverse = 0;
+      setreg (s, 0x50, s->hw_parms.steps_to_reverse);
+      setreg (s, 0x51, 0);	/* accel profile */
+      s->hw_parms.fsteps_25_speed = 0;
+      s->hw_parms.fsteps_50_speed = 0;
+    }
+
+  dpd = compute_dpd (s, step_size, line_end);	/* 0x0ada; */
+#ifdef DEBUG
+  fprintf (stderr, "dpd = %d\n", dpd);
+#endif
+  setreg (s, 0x52, HIBYTE (dpd));
+  setreg (s, 0x53, LOBYTE (dpd));
+
+  setreg (s, 0x46, HIBYTE (step_size));
+  setreg (s, 0x47, LOBYTE (step_size));
+
+  ff_step_size = compute_fastfeed_step_size (s->hw_parms.crystal_frequency,
+					     s->mclk_div,
+					     s->hw_parms.motor_max_speed,
+					     s->hw_parms.
+					     motor_full_steps_per_inch, 0);
+  setreg (s, 0x48, HIBYTE (ff_step_size));
+  setreg (s, 0x49, LOBYTE (ff_step_size));
+  setreg (s, 0x4b, 0x15);
+  /* this is to stay the motor running */
+  setbits (s, 0x45, (1 << 4));
+
+  setreg (s, 0x4a, HIBYTE (47 + s->runtime_parms.steps_to_skip));
+  setreg (s, 0x4b, LOBYTE (47 + s->runtime_parms.steps_to_skip));
+
+  setreg (s, 0x58, 0);
+
+  ciclic_buffer_init (&(s->ciclic_buffer),
+		      s->runtime_parms.image_line_size,
+		      s->user_parms.vertical_resolution,
+		      s->runtime_parms.status_bytes);
+
+  s->runtime_parms.num_bytes_left_to_scan =
+    s->user_parms.lines_to_scan * s->runtime_parms.image_line_size;
+
+#ifdef DEBUG
+  fprintf (stderr, "bytes to scan = %ld\n",
+	   s->runtime_parms.num_bytes_left_to_scan);
+#endif
+
+  cache_write (s);
+
+#ifdef DEBUG
+  lm9830_dump_registers (s->fd);
+#endif
+
+  lm9830_reset (s->fd);
+
+  setreg (s, 0x07, 0x03);
+  usleep (100);
+
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+end_scan (HP4200_Scanner * s)
+{
+  s->scanning = SANE_FALSE;
+  setreg (s, 0x07, 0x00);
+  lm9830_reset (s->fd);
+  setbits (s, 0x58, PAPER_SENSOR_2_STOP_SCAN);
+  cache_write (s);
+  setreg (s, 0x07, 0x02);
+
+  /* Free some buffers */
+  if (s->ciclic_buffer.buffer)
+    {
+      free (s->ciclic_buffer.buffer);
+      s->ciclic_buffer.buffer = NULL;
+    }
+  if (s->ciclic_buffer.buffer_ptrs)
+    {
+      free (s->ciclic_buffer.buffer_ptrs);
+      s->ciclic_buffer.buffer_ptrs = NULL;
+    }
+  if (s->scanner_buffer.buffer)
+    {
+      free (s->scanner_buffer.buffer);
+      s->scanner_buffer.buffer = NULL;
+    }
+
+  return SANE_STATUS_GOOD;
+}
+
+static int
+hp4200_init_scanner (HP4200_Scanner * s)
+{
+  int ff_step_size;
+  int mclk_div;
+
+  lm9830_ini_scanner (s->fd, NULL);
+  hp4200_init_registers (s);
+  scanner_buffer_init (&(s->scanner_buffer), s->hw_parms.SRAM_size);
+  setreg (s, 0x07, 0x08);
+  usleep (10 * 1000);
+  setreg (s, 0x07, 0x00);
+  usleep (10 * 1000);
+  mclk_div = 2;
+
+  setreg (s, 0x08, (mclk_div - 1) * 2);
+  ff_step_size =
+    compute_fastfeed_step_size (s->hw_parms.crystal_frequency,
+				mclk_div,
+				s->hw_parms.motor_max_speed,
+				s->hw_parms.motor_full_steps_per_inch, 0);
+  setreg (s, 0x48, HIBYTE (ff_step_size));
+  setreg (s, 0x49, LOBYTE (ff_step_size));
+  setbits (s, 0x45, (1 << 4));
+  cache_write (s);
+  return 0;
+}
+
+static void
+ciclic_buffer_copy (ciclic_buffer_t * cb, SANE_Byte * buf,
+		    SANE_Int num_bytes, int image_line_size, int status_bytes)
+{
+  int biggest_upper_block_size;
+  int upper_block_size;
+  int lower_block_size;
+  int bytes_to_be_a_entire_line;
+
+  /* copy the upper block */
+  biggest_upper_block_size = cb->size - (cb->buffer_position - cb->buffer);
+  upper_block_size = min (biggest_upper_block_size, num_bytes);
+  memcpy (buf, cb->buffer_position, upper_block_size);
+  cb->good_bytes -= upper_block_size;
+
+  bytes_to_be_a_entire_line = (cb->buffer_position - cb->buffer) %
+    image_line_size;
+  cb->can_consume += upper_block_size +
+    status_bytes * (((bytes_to_be_a_entire_line + upper_block_size) /
+		     image_line_size) - 1);
+
+  if (num_bytes < biggest_upper_block_size)
+    {
+      cb->buffer_position += num_bytes;
+      return;
+    }
+
+  /* copy the lower block */
+  lower_block_size = num_bytes - biggest_upper_block_size;
+  if (lower_block_size > 0)
+    {
+      memcpy (buf + biggest_upper_block_size, cb->buffer, lower_block_size);
+      cb->good_bytes -= lower_block_size;
+      cb->can_consume += lower_block_size + status_bytes *
+	(lower_block_size / image_line_size);
+      cb->buffer_position = cb->buffer + lower_block_size;
+    }
+  else
+    {
+      cb->buffer_position = cb->buffer;
+    }
+  assert (cb->good_bytes >= 0);
+  assert (lower_block_size >= 0);
+}
+
+static void
+ciclic_buffer_consume (ciclic_buffer_t * cb,
+		       scanner_buffer_t * scanner_buffer,
+		       int image_width, int status_bytes)
+{
+  int to_consume;
+  int to_consume_now;
+  int i;
+  int processed;
+
+  to_consume = min (cb->can_consume, scanner_buffer->num_bytes);
+
+  while (to_consume)
+    {
+
+      if (cb->pixel_position == image_width)
+	{
+	  if (scanner_buffer->num_bytes >= status_bytes)
+	    {
+	      /* forget status bytes */
+	      scanner_buffer->data_ptr += status_bytes;
+	      scanner_buffer->num_bytes -= status_bytes;
+	      cb->can_consume -= status_bytes;
+	      to_consume -= status_bytes;
+
+	      cb->pixel_position = 0;	/* back to the start pixel */
+
+	      cb->red_idx = (cb->red_idx + 1) % cb->num_lines;
+	      cb->green_idx = (cb->green_idx + 1) % cb->num_lines;
+	      cb->blue_idx = (cb->blue_idx + 1) % cb->num_lines;
+	      cb->current_line++;
+	    }
+	  else
+	    break;
+	}
+
+      to_consume_now = min ((image_width - cb->pixel_position) * 3,
+			    to_consume);
+
+      if (to_consume_now < 3)
+	break;
+
+      for (i = cb->pixel_position * 3; to_consume_now >= 3;
+	   i += 3, to_consume_now -= 3)
+	{
+	  cb->buffer_ptrs[cb->red_idx][i] = scanner_buffer->data_ptr[0];
+	  cb->buffer_ptrs[cb->green_idx][i + 1] = scanner_buffer->data_ptr[1];
+	  cb->buffer_ptrs[cb->blue_idx][i + 2] = scanner_buffer->data_ptr[2];
+	  scanner_buffer->data_ptr += 3;
+	}
+      processed = i - (cb->pixel_position * 3);
+      cb->pixel_position = i / 3;
+      to_consume -= processed;
+      cb->can_consume -= processed;
+      scanner_buffer->num_bytes -= processed;
+      if (cb->current_line > cb->first_good_line)
+	cb->good_bytes += processed;
+    }
+}
+
+SANE_Status
+sane_read (SANE_Handle h, SANE_Byte * buf, SANE_Int maxlen, SANE_Int * len)
+{
+  SANE_Status status;
+  int to_copy_now;
+  int bytes_to_copy_to_frontend;
+  HP4200_Scanner *s = h;
+
+  static char me[] = "sane_read";
+  DBG (DBG_proc, "%s\n", me);
+
+  if (!(s->scanning))
+    {
+      /* OOPS, not scanning */
+      return SANE_STATUS_CANCELLED;
+    }
+
+  if (!buf || !len)
+    return SANE_STATUS_INVAL;
+
+  *len = 0;
+
+  if (s->runtime_parms.num_bytes_left_to_scan == 0)
+    {
+      end_scan (s);
+      return SANE_STATUS_EOF;
+    }
+
+  bytes_to_copy_to_frontend = min (s->runtime_parms.num_bytes_left_to_scan,
+				   maxlen);
+
+  /* first copy available data from the ciclic buffer */
+  to_copy_now = min (s->ciclic_buffer.good_bytes, bytes_to_copy_to_frontend);
+
+  if (to_copy_now > 0)
+    {
+      ciclic_buffer_copy (&(s->ciclic_buffer), buf, to_copy_now,
+			  s->runtime_parms.image_line_size,
+			  s->runtime_parms.status_bytes);
+      buf += to_copy_now;
+      bytes_to_copy_to_frontend -= to_copy_now;
+      *len += to_copy_now;
+    }
+
+  /* if not enough bytes, get data from the scanner */
+  while (bytes_to_copy_to_frontend)
+    {
+      if (s->scanner_buffer.num_bytes < 3)
+	{			/* cicl buf consumes modulo 3
+				   bytes at least now for rgb
+				   color 8 bpp fixme: but this
+				   is ugly and not generic
+				 */
+	  status = scanner_buffer_read (s);
+
+	  if (status == SANE_STATUS_CANCELLED)
+	    {
+	      end_scan (s);
+	      s->aborted_by_user = SANE_FALSE;
+	      return status;
+	    }
+	  if (status != SANE_STATUS_GOOD)
+	    return status;
+	}
+
+      while ((s->scanner_buffer.num_bytes > 3) && bytes_to_copy_to_frontend)
+	{
+	  ciclic_buffer_consume (&(s->ciclic_buffer), &(s->scanner_buffer),
+				 s->user_parms.image_width,
+				 s->runtime_parms.status_bytes);
+	  to_copy_now = min (s->ciclic_buffer.good_bytes,
+			     bytes_to_copy_to_frontend);
+
+	  if (to_copy_now > 0)
+	    {
+	      ciclic_buffer_copy (&(s->ciclic_buffer), buf, to_copy_now,
+				  s->runtime_parms.image_line_size,
+				  s->runtime_parms.status_bytes);
+	      buf += to_copy_now;
+	      bytes_to_copy_to_frontend -= to_copy_now;
+	      *len += to_copy_now;
+	    }
+	}
+    }
+
+  s->runtime_parms.num_bytes_left_to_scan -= *len;
+
+  if (s->runtime_parms.num_bytes_left_to_scan < 0)
+    *len += s->runtime_parms.num_bytes_left_to_scan;
+
+  return SANE_STATUS_GOOD;
+}
+
+static HP4200_Device *
+find_device (SANE_String_Const name)
+{
+  static char me[] = "find_device";
+  HP4200_Device *dev;
+
+  DBG (DBG_proc, "%s\n", me);
+
+  for (dev = first_device; dev; dev = dev->next)
+    {
+      if (strcmp (dev->dev.name, name) == 0)
+	{
+	  return dev;
+	}
+    }
+  return NULL;
+}
+
+static SANE_Status
+add_device (SANE_String_Const name, HP4200_Device ** argpd)
+{
+  int fd;
+  HP4200_Device *pd;
+  static const char me[] = "add_device";
+  SANE_Status status;
+
+  DBG (DBG_proc, "%s(%s)\n", me, name);
+
+  /* Avoid adding the same device more than once */
+  if ((pd = find_device (name)))
+    {
+      if (argpd)
+	*argpd = pd;
+      return SANE_STATUS_GOOD;
+    }
+
+  /* open the device file, but read only or read/write to perform
+     ioctl's ? */
+  if ((status = sanei_usb_open (name, &fd)) != SANE_STATUS_GOOD)
+    {
+      DBG (DBG_error, "%s: open(%s) failed: %s\n", me, name,
+	   sane_strstatus (status));
+      return SANE_STATUS_INVAL;
+    }
+
+  /* put here some code to probe that the device attached to the
+     device file is a supported scanner. Maybe some ioctl */
+  sanei_usb_close (fd);
+
+  pd = (HP4200_Device *) calloc (1, sizeof (HP4200_Device));
+  if (!pd)
+    {
+      DBG (DBG_error, "%s: out of memory allocating device.\n", me);
+      return SANE_STATUS_NO_MEM;
+    }
+
+  pd->dev.name = strdup (name);
+  pd->dev.vendor = "Hewlett-Packard";
+  pd->dev.model = "HP-4200";
+  pd->dev.type = "flatbed scanner";
+
+  if (!pd->dev.name || !pd->dev.vendor || !pd->dev.model || !pd->dev.type)
+    {
+      DBG (DBG_error,
+	   "%s: out of memory allocating device descriptor strings.\n", me);
+      free (pd);
+      return SANE_STATUS_NO_MEM;
+    }
+
+  pd->handle = NULL;
+  pd->next = first_device;
+  first_device = pd;
+  n_devices++;
+  if (argpd)
+    *argpd = pd;
+
+  return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+attach (SANE_String_Const name)
+{
+  static char me[] = "attach";
+  DBG (DBG_proc, "%s\n", me);
+  return add_device (name, NULL);
+}
+
+SANE_Status
+sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
+{
+  static const char me[] = "sane_hp4200_init";
+  char dev_name[PATH_MAX];
+  FILE *fp;
+
+  authorize = authorize;	/* keep gcc quiet */
+
+  DBG_INIT ();
+
+  DBG (DBG_proc, "%s\n", me);
+  DBG (DBG_error, "SANE hp4200 backend version %d.%d build %d from %s\n",
+       SANE_CURRENT_MAJOR, V_MINOR, BUILD, PACKAGE_STRING);
+  /* put some version_code checks here */
+
+  if (NULL != version_code)
+    {
+      *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0);
+    }
+
+  sanei_usb_init ();
+  sanei_pv8630_init ();
+
+  fp = sanei_config_open (HP4200_CONFIG_FILE);
+  if (!fp)
+    {
+      DBG (DBG_error, "%s: configuration file not found!\n", me);
+
+      return SANE_STATUS_INVAL;
+    }
+  else
+    {
+      while (sanei_config_read (dev_name, sizeof (dev_name), fp))
+	{
+	  if (dev_name[0] == '#')	/* ignore line comments */
+	    continue;
+
+	  if (strlen (dev_name) == 0)
+	    continue;		/* ignore empty lines */
+
+	  DBG (DBG_info, "%s: looking for devices matching %s\n",
+	       me, dev_name);
+
+	  sanei_usb_attach_matching_devices (dev_name, attach);
+	}
+
+      fclose (fp);
+    }
+
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_exit (void)
+{
+  HP4200_Device *device, *next;
+
+  DBG (DBG_proc, "sane_hp4200_exit\n");
+
+  for (device = first_device; device; device = next)
+    {
+      next = device->next;
+      if (device->handle)
+	{
+	  sane_close (device->handle);
+	}
+      if (device->dev.name)
+	{
+	  free (device->dev.name);
+	}
+      free (device);
+    }
+  first_device = NULL;
+
+  if (devlist)
+    {
+      free (devlist);
+      devlist = NULL;
+    }
+
+  n_devices = 0;
+
+  DBG (DBG_proc, "sane_exit: exit\n");
+}
+
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
+{
+  int i;
+  HP4200_Device *pdev;
+
+  DBG (DBG_proc, "sane_get_devices (%p, %d)\n", (void *) device_list,
+       local_only);
+
+  /* Waste the last list returned from this function */
+  if (devlist)
+    free (devlist);
+
+  devlist = (const SANE_Device **)
+    malloc ((n_devices + 1) * sizeof (SANE_Device *));
+
+  if (!devlist)
+    {
+      DBG (DBG_error, "sane_get_devices: out of memory\n");
+      return SANE_STATUS_NO_MEM;
+    }
+
+  for (i = 0, pdev = first_device; pdev; i++, pdev = pdev->next)
+    {
+      devlist[i] = &(pdev->dev);
+    }
+  devlist[i] = NULL;
+
+  *device_list = devlist;
+
+  DBG (DBG_proc, "sane_get_devices: exit\n");
+
+  return SANE_STATUS_GOOD;
+}
+
+static void
+init_options (HP4200_Scanner * s)
+{
+  s->opt[OPT_NUM_OPTS].name = "";
+  s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
+  s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
+  s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
+  s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
+  s->opt[OPT_NUM_OPTS].unit = SANE_UNIT_NONE;
+  s->opt[OPT_NUM_OPTS].size = sizeof (SANE_Word);
+  s->opt[OPT_NUM_OPTS].constraint_type = SANE_CONSTRAINT_NONE;
+  s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
+
+  s->opt[OPT_RES].name = SANE_NAME_SCAN_RESOLUTION;
+  s->opt[OPT_RES].title = SANE_TITLE_SCAN_RESOLUTION;
+  s->opt[OPT_RES].desc = SANE_DESC_SCAN_RESOLUTION;
+  s->opt[OPT_RES].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+  s->opt[OPT_RES].type = SANE_TYPE_INT;
+  s->opt[OPT_RES].size = sizeof (SANE_Word);
+  s->opt[OPT_RES].unit = SANE_UNIT_DPI;
+  s->opt[OPT_RES].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+  s->opt[OPT_RES].constraint.word_list = dpi_list;
+  s->val[OPT_RES].w = 150;
+
+  s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
+  s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
+  s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
+  s->opt[OPT_TL_X].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+  s->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
+  s->opt[OPT_TL_X].size = sizeof (SANE_Fixed);
+  s->opt[OPT_TL_X].unit = SANE_UNIT_MM;
+  s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_TL_X].constraint.range = &x_range;
+  s->val[OPT_TL_X].w = x_range.min;
+
+  s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
+  s->opt[OPT_TL_Y].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+  s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
+  s->opt[OPT_TL_Y].size = sizeof (SANE_Fixed);
+  s->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
+  s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_TL_Y].constraint.range = &y_range;
+  s->val[OPT_TL_Y].w = y_range.min;
+
+  s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
+  s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
+  s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
+  s->opt[OPT_BR_X].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+  s->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
+  s->opt[OPT_BR_X].size = sizeof (SANE_Fixed);
+  s->opt[OPT_BR_X].unit = SANE_UNIT_MM;
+  s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BR_X].constraint.range = &x_range;
+  s->val[OPT_BR_X].w = x_range.max;
+
+  s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
+  s->opt[OPT_BR_Y].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+  s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
+  s->opt[OPT_BR_Y].size = sizeof (SANE_Fixed);
+  s->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
+  s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_BR_Y].constraint.range = &y_range;
+  s->val[OPT_BR_Y].w = y_range.max;
+
+  s->opt[OPT_BACKTRACK].name = SANE_NAME_BACKTRACK;
+  s->opt[OPT_BACKTRACK].title = SANE_TITLE_BACKTRACK;
+  s->opt[OPT_BACKTRACK].desc = SANE_DESC_BACKTRACK;
+  s->opt[OPT_BACKTRACK].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+  s->opt[OPT_BACKTRACK].type = SANE_TYPE_BOOL;
+  s->opt[OPT_BACKTRACK].size = sizeof (SANE_Bool);
+  s->opt[OPT_BACKTRACK].unit = SANE_UNIT_NONE;
+  s->opt[OPT_BACKTRACK].constraint_type = SANE_CONSTRAINT_NONE;
+  s->val[OPT_BACKTRACK].b = SANE_TRUE;
+
+  s->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
+  s->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
+  s->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
+  s->opt[OPT_GAMMA_VECTOR_R].cap =
+    SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+  s->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
+  s->opt[OPT_GAMMA_VECTOR_R].size = 1024 * sizeof (SANE_Word);
+  s->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
+  s->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_GAMMA_VECTOR_R].constraint.range = &u8_range;
+  s->val[OPT_GAMMA_VECTOR_R].wa = s->user_parms.gamma[0];
+
+  s->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
+  s->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
+  s->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
+  s->opt[OPT_GAMMA_VECTOR_G].cap =
+    SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+  s->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
+  s->opt[OPT_GAMMA_VECTOR_G].size = 1024 * sizeof (SANE_Word);
+  s->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
+  s->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_GAMMA_VECTOR_G].constraint.range = &u8_range;
+  s->val[OPT_GAMMA_VECTOR_G].wa = s->user_parms.gamma[1];
+
+  s->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
+  s->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
+  s->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
+  s->opt[OPT_GAMMA_VECTOR_B].cap =
+    SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+  s->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
+  s->opt[OPT_GAMMA_VECTOR_B].size = 1024 * sizeof (SANE_Word);
+  s->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
+  s->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
+  s->opt[OPT_GAMMA_VECTOR_B].constraint.range = &u8_range;
+  s->val[OPT_GAMMA_VECTOR_B].wa = s->user_parms.gamma[2];
+
+  {
+    int i;
+    double gamma = 2.0;
+    for (i = 0; i < 1024; i++)
+      {
+	s->user_parms.gamma[0][i] =
+	  255 * pow (((double) i + 1) / 1024, 1.0 / gamma);
+	s->user_parms.gamma[1][i] =	s->user_parms.gamma[0][i];
+	s->user_parms.gamma[2][i] =	s->user_parms.gamma[0][i];
+#ifdef DEBUG
+	printf ("%d %d\n", i, s->user_parms.gamma[0][i]);
+#endif
+      }
+  }
+
+  /* preview */
+  s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
+  s->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
+  s->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
+  s->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
+  s->opt[OPT_PREVIEW].size = sizeof (SANE_Word);
+  s->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
+  s->val[OPT_PREVIEW].w = SANE_FALSE;
+}
+
+SANE_Status
+sane_open (SANE_String_Const name, SANE_Handle * h)
+{
+  static const char me[] = "sane_hp4200_open";
+  SANE_Status status;
+  HP4200_Device *dev;
+  HP4200_Scanner *s;
+
+  DBG (DBG_proc, "%s (%s, %p)\n", me, name, (void *) h);
+
+  if (name && name[0])
+    {
+      dev = find_device (name);
+      if (!dev)
+	{
+	  status = add_device (name, &dev);
+	  if (status != SANE_STATUS_GOOD)
+	    return status;
+	}
+    }
+  else
+    {
+      dev = first_device;
+    }
+  if (!dev)
+    return SANE_STATUS_INVAL;
+
+  if (!h)
+    return SANE_STATUS_INVAL;
+
+  s = *h = (HP4200_Scanner *) calloc (1, sizeof (HP4200_Scanner));
+  if (!s)
+    {
+      DBG (DBG_error, "%s: out of memory creating scanner structure.\n", me);
+      return SANE_STATUS_NO_MEM;
+    }
+
+  dev->handle = s;
+  s->aborted_by_user = SANE_FALSE;
+  s->ciclic_buffer.buffer = NULL;
+  s->scanner_buffer.buffer = NULL;
+  s->dev = dev;
+  s->user_parms.image_width = 0;
+  s->user_parms.lines_to_scan = 0;
+  s->user_parms.vertical_resolution = 0;
+  s->scanning = SANE_FALSE;
+  s->fd = -1;
+
+  init_options (s);
+
+  if ((sanei_usb_open (dev->dev.name, &s->fd) != SANE_STATUS_GOOD))
+    {
+      DBG (DBG_error, "%s: Can't open %s.\n", me, dev->dev.name);
+      return SANE_STATUS_IO_ERROR;	/* fixme: return busy when file is
+					   being accessed already */
+    }
+
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_close (SANE_Handle h)
+{
+  HP4200_Scanner *s = (HP4200_Scanner *) h;
+  DBG (DBG_proc, "sane_hp4200_close (%p)\n", (void *) h);
+
+  if (s)
+    {
+      s->dev->handle = NULL;
+      if (s->fd != -1)
+	{
+	  sanei_usb_close (s->fd);
+	}
+      free (s);
+    }
+}
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle h, SANE_Int n)
+{
+  static char me[] = "sane_get_option_descriptor";
+  HP4200_Scanner *s = (HP4200_Scanner *) h;
+
+  DBG (DBG_proc, "%s\n", me);
+
+  if ((n < 0) || (n >= NUM_OPTIONS))
+    return NULL;
+
+  return s->opt + n;
+}
+
+SANE_Status
+sane_control_option (SANE_Handle handle, SANE_Int option,
+		     SANE_Action action, void *val, SANE_Int * info)
+{
+  HP4200_Scanner *s = (HP4200_Scanner *) handle;
+  SANE_Status status;
+  SANE_Int myinfo = 0;
+  SANE_Word cap;
+
+  DBG (DBG_proc, "sane_control_option\n");
+
+  if (info)
+    *info = 0;
+
+  if (s->scanning)
+    {
+      return SANE_STATUS_DEVICE_BUSY;
+    }
+
+  if (option < 0 || option >= NUM_OPTIONS)
+    {
+      return SANE_STATUS_INVAL;
+    }
+
+  cap = s->opt[option].cap;
+  if (!SANE_OPTION_IS_ACTIVE (cap))
+    {
+      return SANE_STATUS_INVAL;
+    }
+
+  if (action == SANE_ACTION_GET_VALUE)
+    {
+
+      switch (option)
+	{
+	case OPT_NUM_OPTS:
+	case OPT_RES:
+	case OPT_TL_X:
+	case OPT_TL_Y:
+	case OPT_BR_X:
+	case OPT_BR_Y:
+	case OPT_PREVIEW:
+	  *(SANE_Word *) val = s->val[option].w;
+	  break;
+
+	case OPT_BACKTRACK:
+	  *(SANE_Bool *) val = s->val[option].b;
+	  break;
+
+	case OPT_GAMMA_VECTOR_R:
+	case OPT_GAMMA_VECTOR_G:
+	case OPT_GAMMA_VECTOR_B:
+	  memcpy (val, s->val[option].wa, s->opt[option].size);
+	  break;
+	default:
+	  return SANE_STATUS_UNSUPPORTED;
+	}
+    }
+  else if (action == SANE_ACTION_SET_VALUE)
+    {
+
+      if (!SANE_OPTION_IS_SETTABLE (cap))
+	{
+	  DBG (DBG_error, "could not set option, not settable\n");
+	  return SANE_STATUS_INVAL;
+	}
+
+      status = sanei_constrain_value (s->opt + option, val, &myinfo);
+      if (status != SANE_STATUS_GOOD)
+	return status;
+
+      switch (option)
+	{
+
+	  /* Numeric side-effect free options */
+	case OPT_PREVIEW:
+	  s->val[option].w = *(SANE_Word *) val;
+	  return SANE_STATUS_GOOD;
+
+	  /* Numeric side-effect options */
+	case OPT_RES:
+	case OPT_TL_X:
+	case OPT_TL_Y:
+	case OPT_BR_X:
+	case OPT_BR_Y:
+	  myinfo |= SANE_INFO_RELOAD_PARAMS;
+	  s->val[option].w = *(SANE_Word *) val;
+	  break;
+
+	case OPT_BACKTRACK:
+	  s->val[option].b = *(SANE_Bool *) val;
+	  break;
+
+	case OPT_GAMMA_VECTOR_R:
+	case OPT_GAMMA_VECTOR_G:
+	case OPT_GAMMA_VECTOR_B:
+	  memcpy (s->val[option].wa, val, s->opt[option].size);
+	  break;
+	default:
+	  return SANE_STATUS_UNSUPPORTED;
+	}
+    }
+  else
+    {
+      return SANE_STATUS_UNSUPPORTED;
+    }
+
+  if (info)
+    *info = myinfo;
+
+  return SANE_STATUS_GOOD;
+}
+
+static void
+compute_parameters (HP4200_Scanner * s)
+{
+  int resolution;
+  int opt_tl_x;
+  int opt_br_x;
+  int opt_tl_y;
+  int opt_br_y;
+
+  if (s->val[OPT_PREVIEW].w == SANE_TRUE)
+    {
+      resolution = 50;
+      opt_tl_x = SANE_UNFIX (x_range.min);
+      opt_tl_y = SANE_UNFIX (y_range.min);
+      opt_br_x = SANE_UNFIX (x_range.max);
+      opt_br_y = SANE_UNFIX (y_range.max);
+    }
+  else
+    {
+      resolution = s->val[OPT_RES].w;
+      opt_tl_x = SANE_UNFIX (s->val[OPT_TL_X].w);
+      opt_tl_y = SANE_UNFIX (s->val[OPT_TL_Y].w);
+      opt_br_x = SANE_UNFIX (s->val[OPT_BR_X].w);
+      opt_br_y = SANE_UNFIX (s->val[OPT_BR_Y].w);
+    }
+
+  s->user_parms.horizontal_resolution = resolution;
+  s->user_parms.vertical_resolution = resolution;
+
+  s->runtime_parms.steps_to_skip = floor (300.0 / MM_PER_INCH * opt_tl_y);
+  s->user_parms.lines_to_scan =
+    floor ((opt_br_y - opt_tl_y) / MM_PER_INCH * resolution);
+  s->user_parms.image_width =
+    floor ((opt_br_x - opt_tl_x) / MM_PER_INCH * resolution);
+  s->runtime_parms.first_pixel = floor (opt_tl_x / MM_PER_INCH * resolution);
+
+  /* fixme: add support for more depth's and bpp's. */
+  s->runtime_parms.image_line_size = s->user_parms.image_width * 3;
+}
+
+SANE_Status
+sane_get_parameters (SANE_Handle h, SANE_Parameters * p)
+{
+  static char me[] = "sane_get_parameters";
+  HP4200_Scanner *s = (HP4200_Scanner *) h;
+
+  DBG (DBG_proc, "%s\n", me);
+  if (!p)
+    return SANE_STATUS_INVAL;
+
+  p->format = SANE_FRAME_RGB;
+  p->last_frame = SANE_TRUE;
+  p->depth = 8;
+  if (!s->scanning)
+    {
+      compute_parameters (s);
+    }
+
+  p->lines = s->user_parms.lines_to_scan;
+  p->pixels_per_line = s->user_parms.image_width;
+  p->bytes_per_line = s->runtime_parms.image_line_size;
+
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_start (SANE_Handle h)
+{
+  HP4200_Scanner *s = (HP4200_Scanner *) h;
+  struct coarse_t coarse;
+
+  static char me[] = "sane_start";
+  DBG (DBG_proc, "%s\n", me);
+
+  s->scanning = SANE_TRUE;
+  s->aborted_by_user = SANE_FALSE;
+  s->user_parms.color = SANE_TRUE;
+
+  compute_parameters (s);
+
+  hp4200_init_scanner (s);
+  hp4200_goto_home (s);
+  hp4200_wait_homed (s);
+  /* restore default register values here... */
+  write_gamma (s);
+  hp4200_init_registers (s);
+  lm9830_ini_scanner (s->fd, NULL);
+  /* um... do not call cache_write() here, don't know why :( */
+  do_coarse_calibration (s, &coarse);
+  do_fine_calibration (s, &coarse);
+  prepare_for_a_scan (s);
+
+  return SANE_STATUS_GOOD;
+}
+
+void
+sane_cancel (SANE_Handle h)
+{
+  static char me[] = "sane_cancel";
+  HP4200_Scanner *s = (HP4200_Scanner *) h;
+  DBG (DBG_proc, "%s\n", me);
+
+  s->aborted_by_user = SANE_TRUE;
+
+  end_scan (s);
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
+{
+  HP4200_Scanner *dev = handle;
+  SANE_Status status;
+
+  non_blocking = non_blocking;	/* silence gcc */
+
+  if (dev->scanning == SANE_FALSE)
+    {
+      return SANE_STATUS_INVAL;
+    }
+
+  if (non_blocking == SANE_FALSE)
+    {
+      status = SANE_STATUS_GOOD;
+    }
+  else
+    {
+      status = SANE_STATUS_UNSUPPORTED;
+    }
+
+  DBG (DBG_proc, "sane_set_io_mode: exit\n");
+
+  return status;
+}
+
+SANE_Status
+sane_get_select_fd (SANE_Handle h, SANE_Int * fd)
+{
+  static char me[] = "sane_get_select_fd";
+
+  h = h;			/* keep gcc quiet */
+  fd = fd;			/* keep gcc quiet */
+
+  DBG (DBG_proc, "%s\n", me);
+  return SANE_STATUS_UNSUPPORTED;
+}