Initial import of sane-backends version 1.0.24-1.2

1 files changed, 2751 insertions, 0 deletions

diff --git a/backend/mustek_usb_high.c b/backend/mustek_usb_high.c
new file mode 100644
index 0000000..f6a0125
--- /dev/null
+++ b/backend/mustek_usb_high.c
@@ -0,0 +1,2751 @@
+/* sane - Scanner Access Now Easy.
+
+   Copyright (C) 2000 Mustek.
+   Originally maintained by Tom Wang <tom.wang@mustek.com.tw>
+
+   Copyright (C) 2001, 2002 by Henning Meier-Geinitz.
+
+   This file is part of the SANE package.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful, but
+   WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+   MA 02111-1307, USA.
+
+   As a special exception, the authors of SANE give permission for
+   additional uses of the libraries contained in this release of SANE.
+
+   The exception is that, if you link a SANE library with other files
+   to produce an executable, this does not by itself cause the
+   resulting executable to be covered by the GNU General Public
+   License.  Your use of that executable is in no way restricted on
+   account of linking the SANE library code into it.
+
+   This exception does not, however, invalidate any other reasons why
+   the executable file might be covered by the GNU General Public
+   License.
+
+   If you submit changes to SANE to the maintainers to be included in
+   a subsequent release, you agree by submitting the changes that
+   those changes may be distributed with this exception intact.
+
+   If you write modifications of your own for SANE, it is your choice
+   whether to permit this exception to apply to your modifications.
+   If you do not wish that, delete this exception notice.
+
+   This file implements a SANE backend for Mustek 1200UB and similar 
+   USB flatbed scanners.  */
+
+#include "mustek_usb_high.h"
+#include "mustek_usb_mid.c"
+
+/* ------------------------ calibration functions ------------------------- */
+
+static SANE_Byte gray_map[8] = {
+  0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01
+};
+
+static inline double
+filter_lower_end (SANE_Int * buffer, SANE_Word total_count,
+		  SANE_Word filter_count)
+{
+  SANE_Word bound = total_count - 1;
+  SANE_Word left_count = total_count - filter_count;
+  SANE_Int temp = 0;
+  SANE_Word i, j;
+  SANE_Int sum = 0;
+
+  for (i = 0; i < bound; i++)
+    {
+      for (j = 0; j < bound - i; j++)
+	{
+	  if (buffer[j + 1] > buffer[j])
+	    {
+	      temp = buffer[j];
+	      buffer[j] = buffer[j + 1];
+	      buffer[j + 1] = temp;
+	    }
+	}
+    }
+  for (i = 0; i < left_count; i++)
+    sum += buffer[i];
+  return (double) sum;
+}
+
+SANE_Status
+usb_high_cal_init (Calibrator * cal, SANE_Byte type, SANE_Word target_white,
+		   SANE_Word target_dark)
+{
+  DBG (5, "usb_high_cal_init: start, cal=%p, type=%d, target_white=%d "
+       "target_dark=%d\n", (void *) cal, type, target_white, target_dark);
+  cal->is_prepared = SANE_FALSE;
+  cal->k_white = NULL;
+  cal->k_dark = NULL;
+  /* Working Buffer */
+  cal->white_line = NULL;
+  cal->dark_line = NULL;
+  cal->white_buffer = NULL;
+  /* Necessary Parameters */
+  cal->k_white_level = 240 << 8;
+  cal->k_dark_level = 0;
+  cal->threshold = 2048;
+  cal->major_average = 0;
+  cal->minor_average = 0;
+  cal->filter = 0;
+  cal->white_needed = 0;
+  cal->dark_needed = 0;
+  cal->max_width = 0;
+  cal->width = 100;
+  cal->gamma_table = 0;
+  cal->calibrator_type = type;
+  cal->k_white_level = target_white / 16;
+  cal->k_dark_level = 0;
+  DBG (5, "usb_high_cal_init: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_cal_exit (Calibrator * cal)
+{
+  DBG (5, "usb_high_cal_exit: start\n");
+
+  if (!cal)
+    {
+      DBG (3, "usb_high_cal_exit: cal == NULL\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  if (!cal->is_prepared)
+    {
+      DBG (3, "usb_high_cal_exit: !is_prepared\n");
+      return SANE_STATUS_INVAL;
+    }
+  DBG (5, "usb_high_cal_exit: 1\n");
+
+  if (cal->k_dark)
+    {
+      free (cal->k_dark);
+    }
+  cal->k_dark = NULL;
+  DBG (5, "usb_high_cal_exit: 2\n");
+  if (cal->k_white)
+    {
+      free (cal->k_white);
+    }
+  cal->k_white = NULL;
+  DBG (5, "usb_high_cal_exit: 3\n");
+
+  cal->is_prepared = SANE_FALSE;
+  DBG (5, "usb_high_cal_exit: 4\n");
+  DBG (5, "usb_high_cal_exit: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_cal_embed_gamma (Calibrator * cal, SANE_Word * gamma_table)
+{
+  DBG (5, "usb_high_cal_embed_gamma: start\n");
+  cal->gamma_table = gamma_table;
+  DBG (5, "usb_high_cal_embed_gamma: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_cal_prepare (Calibrator * cal, SANE_Word max_width)
+{
+  DBG (5, "usb_high_cal_Parepare: start\n");
+
+  if (cal->is_prepared)
+    {
+      DBG (3, "usb_high_cal_Parepare: is_prepared\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  if (cal->k_white)
+    {
+      free (cal->k_white);
+    }
+  cal->k_white = (SANE_Word *) malloc (max_width * sizeof (SANE_Word));
+  if (!cal->k_white)
+    return SANE_STATUS_NO_MEM;
+
+  if (cal->k_dark)
+    {
+      free (cal->k_dark);
+    }
+  cal->k_dark = (SANE_Word *) malloc (max_width * sizeof (SANE_Word));
+  if (!cal->k_dark)
+    return SANE_STATUS_NO_MEM;
+
+  cal->max_width = max_width;
+
+  cal->is_prepared = SANE_TRUE;
+
+  DBG (5, "usb_high_cal_Parepare: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+
+SANE_Status
+usb_high_cal_setup (Calibrator * cal, SANE_Word major_average,
+		    SANE_Word minor_average, SANE_Word filter,
+		    SANE_Word width, SANE_Word * white_needed,
+		    SANE_Word * dark_needed)
+{
+  SANE_Int i;
+
+  DBG (5, "usb_high_cal_setup: start\n");
+
+  if (!cal->is_prepared)
+    {
+      DBG (3, "usb_high_cal_setup: !is_prepared\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (major_average == 0)
+    {
+      DBG (3, "usb_high_cal_setup: major_average==0\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (minor_average == 0)
+    {
+      DBG (3, "usb_high_cal_setup: minor_average==0\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (width > cal->max_width)
+    {
+      DBG (3, "usb_high_cal_setup: width>max_width\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  cal->major_average = major_average;
+  cal->minor_average = minor_average;
+  cal->filter = filter;
+  cal->width = width;
+  cal->white_needed = major_average * 16 + filter;
+  cal->dark_needed = major_average * 16;
+  *white_needed = cal->white_needed;
+  *dark_needed = cal->dark_needed;
+
+  if (cal->white_line)
+    {
+      free (cal->white_line);
+    }
+  cal->white_line = (double *) malloc (cal->width * sizeof (double));
+  if (!cal->white_line)
+    return SANE_STATUS_NO_MEM;
+
+  if (cal->dark_line)
+    {
+      free (cal->dark_line);
+    }
+  cal->dark_line = (double *) malloc (cal->width * sizeof (double));
+  if (!cal->dark_line)
+    return SANE_STATUS_NO_MEM;
+
+  for (i = 0; i < cal->width; i++)
+    {
+      cal->white_line[i] = 0.0;
+      cal->dark_line[i] = 0.0;
+    }
+
+  if (cal->white_buffer)
+    {
+      free (cal->white_buffer);
+    }
+  cal->white_buffer =
+    (SANE_Int *) malloc (cal->white_needed * cal->width * sizeof (SANE_Int));
+  if (!cal->white_buffer)
+    return SANE_STATUS_NO_MEM;
+
+  for (i = 0; i < cal->white_needed * cal->width; i++)
+    {
+      *(cal->white_buffer + i) = 0;
+    }
+
+  return SANE_STATUS_GOOD;
+  DBG (5, "usb_high_cal_setup: start\n");
+}
+
+SANE_Status
+usb_high_cal_evaluate_white (Calibrator * cal, double factor)
+{
+  /* Caculate white_line */
+  double loop_division;
+  double average;
+  SANE_Int *buffer;
+  SANE_Word i, j;
+
+  DBG (5, "usb_high_cal_evaluate_white: start\n");
+  loop_division = (double) (cal->major_average * cal->minor_average);
+  buffer = (SANE_Int *) malloc (cal->white_needed * sizeof (SANE_Int));
+  if (!buffer)
+    return SANE_STATUS_NO_MEM;
+
+  if (cal->white_buffer == NULL)
+    {
+      DBG (3, "usb_high_cal_evaluate_white: white_buffer==NULL\n");
+      return SANE_STATUS_NO_MEM;
+    }
+
+  for (i = 0; i < cal->width; i++)
+    {
+      for (j = 0; j < cal->white_needed; j++)
+	{
+	  *(buffer + j) = *(cal->white_buffer + j * cal->width + i);
+	}
+      average =
+	filter_lower_end (buffer, cal->white_needed,
+			  cal->filter) * factor / loop_division;
+      if (average >= 4096.0)
+	cal->white_line[i] = 4095.9999;
+      else if (average < 0.0)
+	cal->white_line[i] = 0.0;
+      else
+	cal->white_line[i] = average;
+    }
+  free (buffer);
+  buffer = NULL;
+  free (cal->white_buffer);
+  cal->white_buffer = NULL;
+  DBG (5, "usb_high_cal_evaluate_white: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_cal_evaluate_dark (Calibrator * cal, double factor)
+{
+  SANE_Word i;
+  double loop_division;
+
+  DBG (5, "usb_high_cal_evaluate_dark: start\n");
+  /* Caculate dark_line */
+  factor *= 16.0;
+  loop_division = (double) (cal->major_average * cal->minor_average);
+  for (i = 0; i < cal->width; i++)
+    {
+      cal->dark_line[i] /= loop_division;
+      cal->dark_line[i] -= factor;
+      if (cal->dark_line[i] < 0.0)
+	cal->dark_line[i] = 0.0;
+    }
+  DBG (5, "usb_high_cal_evaluate_dark: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_cal_evaluate_calibrator (Calibrator * cal)
+{
+  SANE_Int average = 0;
+  SANE_Word i;
+
+  DBG (5, "usb_high_cal_evaluate_calibrator: start\n");
+  if (cal->white_line == NULL)
+    {
+      DBG (3, "usb_high_cal_evaluate_calibrator: white_line==NULL\n");
+      return SANE_FALSE;
+    }
+  if (cal->dark_line == NULL)
+    {
+      DBG (3, "usb_high_cal_evaluate_calibrator: dark_line==NULL\n");
+      return SANE_FALSE;
+    }
+
+  for (i = 0; i < cal->width; i++)
+    {
+      average = (SANE_Int) (cal->white_line[i])
+	- (SANE_Int) (cal->dark_line[i]);
+      if (average <= 0)
+	average = 1;
+      else if (average >= 4096)
+	average = 4095;
+      cal->k_white[i] = (SANE_Word) (average);
+      cal->k_dark[i] = (SANE_Word) (cal->dark_line[i]);
+    }
+  free (cal->dark_line);
+  cal->dark_line = NULL;
+  free (cal->white_line);
+  cal->white_line = NULL;
+
+  DBG (5, "usb_high_cal_evaluate_calibrator: start\n");
+  return SANE_STATUS_GOOD;
+}
+
+/* virtual function switcher */
+SANE_Status
+usb_high_cal_fill_in_white (Calibrator * cal, SANE_Word major,
+			    SANE_Word minor, void *white_pattern)
+{
+  DBG (5, "usb_high_cal_fill_in_white: start\n");
+  switch (cal->calibrator_type)
+    {
+    case I8O8RGB:
+    case I8O8MONO:
+      return usb_high_cal_i8o8_fill_in_white (cal, major, minor,
+					      white_pattern);
+      break;
+    case I4O1MONO:
+      return usb_high_cal_i4o1_fill_in_white (cal, major, minor,
+					      white_pattern);
+      break;
+    }
+  DBG (5, "usb_high_cal_fill_in_white: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_cal_fill_in_dark (Calibrator * cal, SANE_Word major, SANE_Word minor,
+			   void *dark_pattern)
+{
+  DBG (5, "usb_high_cal_fill_in_dark: start\n");
+  switch (cal->calibrator_type)
+    {
+    case I8O8RGB:
+    case I8O8MONO:
+      return usb_high_cal_i8o8_fill_in_dark (cal, major, minor, dark_pattern);
+      break;
+    case I4O1MONO:
+      return usb_high_cal_i4o1_fill_in_dark (cal, major, minor, dark_pattern);
+      break;
+    }
+  DBG (5, "usb_high_cal_fill_in_dark: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_cal_calibrate (Calibrator * cal, void *src, void *target)
+{
+  DBG (5, "usb_high_cal_calibrate: start\n");
+  switch (cal->calibrator_type)
+    {
+    case I8O8RGB:
+      return usb_high_cal_i8o8_rgb_calibrate (cal, src, target);
+      break;
+    case I8O8MONO:
+      return usb_high_cal_i8o8_mono_calibrate (cal, src, target);
+      break;
+    case I4O1MONO:
+      return usb_high_cal_i4o1_calibrate (cal, src, target);
+      break;
+    }
+  DBG (5, "usb_high_cal_calibrate: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_cal_i8o8_fill_in_white (Calibrator * cal, SANE_Word major,
+				 SANE_Word minor, void *white_pattern)
+{
+  SANE_Byte *pattern;
+  SANE_Word j;
+
+  pattern = (SANE_Byte *) white_pattern;
+
+  DBG (5, "usb_high_cal_i8o8_fill_in_white: start, minor=%d\n", minor);
+  if (!cal->is_prepared)
+    {
+      DBG (3, "usb_high_cal_i8o8_fill_in_white: !is_prepared\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (cal->white_needed == 0)
+    {
+      DBG (3, "usb_high_cal_i8o8_fill_in_white: white_needed==0\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  for (j = 0; j < cal->width; j++)
+    {
+      *(cal->white_buffer + major * cal->width + j) +=
+	(SANE_Int) (pattern[j]);
+    }
+  DBG (5, "usb_high_cal_i8o8_fill_in_white: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_cal_i8o8_fill_in_dark (Calibrator * cal, SANE_Word major,
+				SANE_Word minor, void *dark_pattern)
+{
+  SANE_Byte *pattern = (SANE_Byte *) dark_pattern;
+  SANE_Word j;
+
+  DBG (5, "usb_high_cal_i8o8_fill_in_dark: start, major=%d, minor=%d\n",
+       major, minor);
+  if (!cal->is_prepared)
+    {
+      DBG (3, "usb_high_cal_i8o8_fill_in_dark: !is_prepared\n");
+      return SANE_FALSE;
+    }
+  if (cal->dark_needed == 0)
+    {
+      DBG (3, "usb_high_cal_i8o8_fill_in_dark: dark_needed==0\n");
+      return SANE_FALSE;
+    }
+
+  for (j = 0; j < cal->width; j++)
+    {
+      cal->dark_line[j] += (double) (pattern[j]);
+    }
+  DBG (5, "usb_high_cal_i8o8_fill_in_dark: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_cal_i4o1_fill_in_white (Calibrator * cal, SANE_Word major,
+				 SANE_Word minor, void *white_pattern)
+{
+  SANE_Byte *pattern;
+  SANE_Word j = 0;
+
+  pattern = (SANE_Byte *) white_pattern;
+
+  DBG (5, "usb_high_cal_i4o1_fill_in_white: minor=%d\n", minor);
+  if (!cal->is_prepared)
+    {
+      DBG (3, "usb_high_cal_i4o1_fill_in_white: !is_prepared\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (cal->white_needed == 0)
+    {
+      DBG (3, "usb_high_cal_i4o1_fill_in_white: white_needed==0\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  while (j < cal->width)
+    {
+      *(cal->white_buffer + major * cal->width + j) +=
+	(SANE_Int) (*(pattern) & 0xf0);
+      j++;
+      if (j >= cal->width)
+	break;
+      *(cal->white_buffer + major * cal->width + j) +=
+	(SANE_Int) ((SANE_Byte) (*(pattern++) << 4));
+      j++;
+    }
+  DBG (5, "usb_high_cal_i8o8_fill_in_white: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_cal_i4o1_fill_in_dark (Calibrator * cal, SANE_Word major,
+				SANE_Word minor, void *dark_pattern)
+{
+  SANE_Byte *pattern;
+  SANE_Word j = 0;
+
+  pattern = (SANE_Byte *) dark_pattern;
+
+  DBG (5, "usb_high_cal_i4o1_fill_in_dark: start, major=%d, minor=%d\n",
+       major, minor);
+  if (!cal->is_prepared)
+    {
+      DBG (3, "usb_high_cal_i4o1_fill_in_dark: !is_prepared\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (cal->dark_needed == 0)
+    {
+      DBG (5, "usb_high_cal_i4o1_fill_in_dark: dark_needed==0\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  while (j < cal->width)
+    {
+      cal->dark_line[j++] += (double) (*(pattern) & 0xf0);
+      if (j >= cal->width)
+	break;
+      cal->dark_line[j++] += (double) ((SANE_Byte) (*(pattern++) << 4));
+    }
+  DBG (5, "usb_high_cal_i4o1_fill_in_dark: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_cal_i8o8_mono_calibrate (Calibrator * cal, void *src, void *target)
+{
+  SANE_Byte *gray_src;
+  SANE_Byte *gray_target;
+  SANE_Int base = 0;
+  SANE_Word value = 0;
+  SANE_Word i;
+
+  DBG (5, "usb_high_cal_i8o8_mono_calibrate: start\n");
+
+  gray_src = (SANE_Byte *) src;
+  gray_target = (SANE_Byte *) target;
+
+  if (cal->gamma_table == NULL)
+    {
+      SANE_Word k_white_level = cal->k_white_level >> 4;
+      for (i = 0; i < cal->width; i++)
+	{
+	  base = (SANE_Int) ((SANE_Word) (gray_src[i]) << 4)
+	    - (SANE_Int) (cal->k_dark[i]);
+	  if (base < 0)
+	    base = 0;
+	  value = ((SANE_Word) (base) * k_white_level) / cal->k_white[i];
+	  if (value > 0x00ff)
+	    value = 0x00ff;
+	  gray_target[i] = (SANE_Byte) (value);
+	}
+    }
+  else
+    {
+      for (i = 0; i < cal->width; i++)
+	{
+	  base = (SANE_Int) ((SANE_Word) (gray_src[i]) << 4)
+	    - (SANE_Int) (cal->k_dark[i]);
+	  if (base < 0)
+	    base = 0;
+	  value = ((SANE_Word) (base) * cal->k_white_level) / cal->k_white[i];
+	  if (value > 0x0fff)
+	    value = 0x0fff;
+	  gray_target[i] = (SANE_Byte) (cal->gamma_table[value]);
+	}
+    }
+  DBG (5, "usb_high_cal_i8o8_mono_calibrate: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_cal_i8o8_rgb_calibrate (Calibrator * cal, void *src, void *target)
+{
+  SANE_Byte *gray_src;
+  SANE_Byte *rgb_target;
+  SANE_Int base = 0;
+  SANE_Word value = 0;
+  SANE_Word i;
+
+  DBG (5, "usb_high_cal_i8o8_rgb_calibrate: start\n");
+  gray_src = (SANE_Byte *) src;
+  rgb_target = (SANE_Byte *) target;
+
+  if (cal->gamma_table == NULL)
+    {
+      SANE_Word k_white_level = cal->k_white_level >> 4;
+      for (i = 0; i < cal->width; i++)
+	{
+	  base = (SANE_Int) ((SANE_Word) (gray_src[i]) << 4)
+	    - (SANE_Int) (cal->k_dark[i]);
+	  if (base < 0)
+	    base = 0;
+	  value = ((SANE_Word) (base) * k_white_level) / cal->k_white[i];
+	  if (value > 0x00ff)
+	    value = 0x00ff;
+	  *rgb_target = (SANE_Byte) (value);
+	  rgb_target += 3;
+	}
+    }
+  else
+    {
+      for (i = 0; i < cal->width; i++)
+	{
+	  base = (SANE_Int) ((SANE_Word) (gray_src[i]) << 4)
+	    - (SANE_Int) (cal->k_dark[i]);
+	  if (base < 0)
+	    base = 0;
+	  value = ((SANE_Word) (base) * cal->k_white_level) / cal->k_white[i];
+	  if (value > 0x0fff)
+	    value = 0x0fff;
+	  *(rgb_target) = (SANE_Byte) (cal->gamma_table[value]);
+	  rgb_target += 3;
+	}
+    }
+  DBG (5, "usb_high_cal_i8o8_rgb_calibrate: start\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_cal_i4o1_calibrate (Calibrator * cal, void *src, void *target)
+{
+  SANE_Byte *local_src;
+  SANE_Byte *local_target;
+  SANE_Int base = 0;
+  SANE_Word value = 0;
+  SANE_Word j = 0;
+  SANE_Int count = 0;
+
+  DBG (5, "usb_high_cal_i4o1_calibrate: start\n");
+  local_src = (SANE_Byte *) src;
+  local_target = (SANE_Byte *) target;
+
+  *local_target = 0;
+  while (j < cal->width)
+    {
+      base =
+	(SANE_Int) ((SANE_Word) (*local_src & 0xf0) << 4)
+	- (SANE_Int) (cal->k_dark[j]);
+      if (base < 0)
+	base = 0;
+      value = ((SANE_Word) (base) * cal->k_white_level) / cal->k_white[j];
+      if (value > 0x0fff)
+	value = 0x0fff;
+      if (value >= cal->threshold)
+	*(local_target) |= gray_map[count];
+      count++;
+      j++;
+      if (j >= cal->width)
+	break;
+      base = (SANE_Int) ((SANE_Word) (*(local_src++) & 0x0f) << 8) -
+	(SANE_Int) (cal->k_dark[j]);
+      if (base < 0)
+	base = 0;
+      value = ((SANE_Word) (base) * cal->k_white_level) / cal->k_white[j];
+      if (value > 0x0fff)
+	value = 0x0fff;
+      if (value >= cal->threshold)
+	*(local_target) |= gray_map[count];
+      count++;
+      if (count >= 8)
+	{
+	  local_target++;
+	  *local_target = 0;
+	  count = 0;
+	}
+      j++;
+    }
+  DBG (5, "usb_high_cal_i4o1_calibrate: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+
+/* --------------------------- scan functions ----------------------------- */
+
+
+SANE_Status
+usb_high_scan_init (Mustek_Usb_Device * dev)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_init: start\n");
+
+  dev->init_bytes_per_strip = 8 * 1024;
+  dev->adjust_length_300 = 2560;
+  dev->adjust_length_600 = 5120;
+  dev->init_min_expose_time = 4992;
+  dev->init_skips_per_row_300 = 56;	/* this value must be times of 6 */
+  dev->init_skips_per_row_600 = 72;	/* this value must be times of 6 */
+  dev->init_j_lines = 154;
+  dev->init_k_lines = 16;
+  dev->init_k_filter = 8;
+  dev->init_k_loops = 2;
+  dev->init_pixel_rate_lines = 50;
+  dev->init_pixel_rate_filts = 37;
+  dev->init_powerdelay_lines = 2;
+  dev->init_home_lines = 160;
+  dev->init_dark_lines = 50;
+  dev->init_k_level = 245;
+  dev->init_max_power_delay = 240;
+  dev->init_min_power_delay = 136;
+  dev->init_adjust_way = 1;
+  dev->init_green_black_factor = 0.0;
+  dev->init_blue_black_factor = 0.0;
+  dev->init_red_black_factor = 0.0;
+  dev->init_gray_black_factor = 0.0;
+  dev->init_green_factor = 0.82004;
+  dev->init_blue_factor = 0.84954;
+  dev->init_red_factor = 0.826375;
+  dev->init_gray_factor = 0.833375;
+
+  dev->init_red_rgb_600_pga = 8;
+  dev->init_green_rgb_600_pga = 8;
+  dev->init_blue_rgb_600_pga = 8;
+  dev->init_mono_600_pga = 8;
+  dev->init_red_rgb_300_pga = 8;
+  dev->init_green_rgb_300_pga = 8;
+  dev->init_blue_rgb_300_pga = 8;
+  dev->init_mono_300_pga = 8;
+  dev->init_expose_time = 9024;
+  dev->init_red_rgb_600_power_delay = 80;
+  dev->init_green_rgb_600_power_delay = 80;
+  dev->init_blue_rgb_600_power_delay = 80;
+  dev->init_red_mono_600_power_delay = 80;
+  dev->init_green_mono_600_power_delay = 80;
+  dev->init_blue_mono_600_power_delay = 80;
+  dev->init_red_rgb_300_power_delay = 80;
+  dev->init_green_rgb_300_power_delay = 80;
+  dev->init_blue_rgb_300_power_delay = 80;
+  dev->init_red_mono_300_power_delay = 80;
+  dev->init_green_mono_300_power_delay = 80;
+  dev->init_blue_mono_300_power_delay = 80;
+  dev->init_threshold = 128;
+
+  dev->init_top_ref = 128;
+  dev->init_front_end = 16;
+  dev->init_red_offset = 0;
+  dev->init_green_offset = 0;
+  dev->init_blue_offset = 0;
+
+  dev->init_rgb_24_back_track = 80;
+  dev->init_mono_8_back_track = 80;
+
+  dev->is_open = SANE_FALSE;
+  dev->is_prepared = SANE_FALSE;
+  dev->expose_time = 4000;
+  dev->width = 2550;
+  dev->x_dpi = 300;
+  dev->y_dpi = 300;
+  dev->scan_mode = RGB24EXT;
+  dev->bytes_per_row = 2550 * 3;
+  dev->dummy = 0;
+  dev->bytes_per_strip = 2550;
+  dev->image_buffer = NULL;
+  dev->red = NULL;
+  dev->green = NULL;
+  dev->blue = NULL;
+  dev->get_line = NULL;
+  dev->backtrack = NULL;
+  dev->is_adjusted_rgb_600_power_delay = SANE_FALSE;
+  dev->is_adjusted_mono_600_power_delay = SANE_FALSE;
+  dev->is_adjusted_rgb_300_power_delay = SANE_FALSE;
+  dev->is_adjusted_mono_300_power_delay = SANE_FALSE;
+  dev->is_evaluate_pixel_rate = SANE_FALSE;
+  dev->red_rgb_600_pga = 0;
+  dev->green_rgb_600_pga = 0;
+  dev->blue_rgb_600_pga = 0;
+  dev->mono_600_pga = 0;
+  dev->red_rgb_600_power_delay = 0;
+  dev->green_rgb_600_power_delay = 0;
+  dev->blue_rgb_600_power_delay = 0;
+  dev->red_mono_600_power_delay = 0;
+  dev->green_mono_600_power_delay = 0;
+  dev->blue_mono_600_power_delay = 0;
+  dev->red_rgb_300_pga = 0;
+  dev->green_rgb_300_pga = 0;
+  dev->blue_rgb_300_pga = 0;
+  dev->mono_300_pga = 0;
+  dev->red_rgb_300_power_delay = 0;
+  dev->green_rgb_300_power_delay = 0;
+  dev->blue_rgb_300_power_delay = 0;
+  dev->red_mono_300_power_delay = 0;
+  dev->green_mono_300_power_delay = 0;
+  dev->blue_mono_300_power_delay = 0;
+  dev->pixel_rate = 2000;
+  dev->threshold = 128;
+  dev->gamma_table = 0;
+  dev->skips_per_row = 0;
+
+
+  dev->red_calibrator = NULL;
+  dev->green_calibrator = NULL;
+  dev->blue_calibrator = NULL;
+  dev->mono_calibrator = NULL;
+
+  dev->is_cis_detected = SANE_FALSE;
+  dev->is_sensor_detected = SANE_FALSE;
+
+  RIE (usb_low_init (&dev->chip));
+
+  DBG (5, "usb_high_scan_init: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_exit (Mustek_Usb_Device * dev)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_exit: start\n");
+  if (!dev->chip)
+    {
+      DBG (5, "usb_high_scan_exit: already exited (`%s')\n", dev->name);
+      return SANE_STATUS_INVAL;
+    }
+
+  RIE (usb_low_exit (dev->chip));
+  dev->chip = 0;
+  DBG (5, "usb_high_scan_exit: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_prepare (Mustek_Usb_Device * dev)
+{
+  DBG (5, "usb_high_scan_prepare: start dev=%p\n", (void *) dev);
+  if (dev->is_prepared)
+    {
+      DBG (5, "usb_high_scan_prepare: is already prepared\n");
+      return SANE_STATUS_GOOD;
+    }
+  if (dev->image_buffer)
+    {
+      free (dev->image_buffer);
+    }
+  dev->image_buffer = (SANE_Byte *) malloc (dev->init_bytes_per_strip * 3);
+  if (!dev->image_buffer)
+    return SANE_STATUS_NO_MEM;
+
+  dev->red = dev->image_buffer;
+  dev->green = dev->image_buffer + dev->init_bytes_per_strip;
+  dev->blue = dev->image_buffer + dev->init_bytes_per_strip * 2;
+
+  dev->is_prepared = SANE_TRUE;
+  DBG (5, "usb_high_scan_prepare: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_clearup (Mustek_Usb_Device * dev)
+{
+  DBG (5, "usb_high_scan_clearup: start, dev=%p\n", (void *) dev);
+  if (!dev->is_prepared)
+    {
+      DBG (3, "usb_high_scan_clearup: is not prepared\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (dev->image_buffer)
+    {
+      free (dev->image_buffer);
+    }
+  dev->image_buffer = NULL;
+  dev->red = NULL;
+  dev->green = NULL;
+  dev->blue = NULL;
+
+  dev->is_prepared = SANE_FALSE;
+  DBG (5, "usb_high_scan_clearup: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_turn_power (Mustek_Usb_Device * dev, SANE_Bool is_on)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_turn_power: start, turn %s power\n",
+       is_on ? "on" : "off");
+
+  if (is_on)
+    {
+      if (dev->is_open)
+	{
+	  DBG (3, "usb_high_scan_turn_power: wanted to turn on power, "
+	       "but scanner already open\n");
+	  return SANE_STATUS_INVAL;
+	}
+      RIE (usb_low_open (dev->chip, dev->device_name));
+      dev->is_open = SANE_TRUE;
+      RIE (usb_low_turn_peripheral_power (dev->chip, SANE_TRUE));
+      RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE));
+    }
+  else
+    {
+      if (!dev->is_open)
+	{
+	  DBG (3, "usb_high_scan_turn_power: wanted to turn off power, "
+	       "but scanner already closed\n");
+	  return SANE_STATUS_INVAL;
+	}
+      RIE (usb_low_turn_lamp_power (dev->chip, SANE_FALSE));
+      RIE (usb_low_close (dev->chip));
+      dev->is_open = SANE_FALSE;
+    }
+
+  DBG (5, "usb_high_scan_turn_power: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_back_home (Mustek_Usb_Device * dev)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_back_home: start\n");
+
+  if (!dev->is_open)
+    {
+      DBG (3, "usb_high_scan_back_home: not open\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  RIE (usb_low_set_ccd_width (dev->chip, dev->init_min_expose_time));
+  RIE (usb_mid_motor_prepare_home (dev->chip));
+
+  DBG (5, "usb_high_scan_back_home: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_set_threshold (Mustek_Usb_Device * dev, SANE_Byte threshold)
+{
+  DBG (5, "usb_high_scan_set_threshold: start, dev=%p, threshold=%d\n",
+       (void *) dev, threshold);
+
+  dev->threshold = threshold;
+  DBG (5, "usb_high_scan_set_threshold: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_embed_gamma (Mustek_Usb_Device * dev, SANE_Word * gamma_table)
+{
+  DBG (5, "usb_high_scan_embed_gamma: start, dev=%p, gamma_table=%p\n",
+       (void *) dev, (void *) gamma_table);
+  if (!dev->is_prepared)
+    {
+      DBG (5, "usb_high_scan_embed_gamma !is_prepared\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  dev->gamma_table = gamma_table;
+  DBG (5, "usb_high_scan_embed_gamma: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_reset (Mustek_Usb_Device * dev)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_reset: start\n");
+
+  if (!dev->is_open)
+    {
+      DBG (3, "usb_high_scan_reset: not open\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (!dev->is_prepared)
+    {
+      DBG (3, "usb_high_scan_reset: !is_prepared\n");
+      return SANE_STATUS_INVAL;
+    }
+  RIE (usb_high_scan_init_asic (dev, dev->chip->sensor));
+  RIE (usb_low_set_ccd_width (dev->chip, dev->init_min_expose_time));
+  RIE (usb_mid_motor_prepare_home (dev->chip));
+  RIE (usb_high_scan_set_threshold (dev, dev->init_threshold));
+  RIE (usb_high_scan_embed_gamma (dev, NULL));
+  dev->is_adjusted_rgb_600_power_delay = SANE_FALSE;
+  dev->is_adjusted_mono_600_power_delay = SANE_FALSE;
+  dev->is_adjusted_rgb_300_power_delay = SANE_FALSE;
+  dev->is_adjusted_mono_300_power_delay = SANE_FALSE;
+  dev->is_evaluate_pixel_rate = SANE_FALSE;
+  DBG (5, "usb_high_scan_reset: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_wait_carriage_home (Mustek_Usb_Device * dev)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_wait_carriage_home: start\n");
+
+  status = usb_low_get_home_sensor (dev->chip);
+
+  if (status != SANE_STATUS_GOOD)
+    {
+      RIE (usb_low_set_ccd_width (dev->chip, dev->init_min_expose_time));
+      RIE (usb_mid_motor_prepare_home (dev->chip));
+      do
+	{
+	  status = usb_low_get_home_sensor (dev->chip);
+	  if (status != SANE_STATUS_GOOD)
+	    usleep (18 * 1000);
+	}
+      while (status != SANE_STATUS_GOOD);
+    }
+
+  /* No Motor & Forward */
+  RIE (usb_low_move_motor_home (dev->chip, SANE_FALSE, SANE_FALSE));
+  DBG (5, "usb_high_scan_wait_carriage_home: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_hardware_calibration (Mustek_Usb_Device * dev)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_hardware_calibration: start\n");
+
+  if (dev->is_cis_detected)
+    RIE (usb_high_scan_safe_forward (dev, dev->init_home_lines));
+
+  switch (dev->init_adjust_way)
+    {
+    case 1:			/* CIS */
+      switch (dev->scan_mode)
+	{
+	case RGB24EXT:
+	  if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi))
+	    {
+	      dev->expose_time = dev->init_expose_time;
+	      dev->red_rgb_600_pga = dev->init_red_rgb_600_pga;
+	      dev->green_rgb_600_pga = dev->init_green_rgb_600_pga;
+	      dev->blue_rgb_600_pga = dev->init_blue_rgb_600_pga;
+	      RIE (usb_high_scan_adjust_rgb_600_power_delay (dev));
+	    }
+	  else
+	    {
+	      dev->expose_time = dev->init_expose_time;
+	      dev->red_rgb_300_pga = dev->init_red_rgb_300_pga;
+	      dev->green_rgb_300_pga = dev->init_green_rgb_300_pga;
+	      dev->blue_rgb_300_pga = dev->init_blue_rgb_300_pga;
+	      RIE (usb_high_scan_adjust_rgb_300_power_delay (dev));
+	    }
+	  break;
+	case GRAY8EXT:
+	  if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi))
+	    {
+	      dev->expose_time = dev->init_expose_time;
+	      dev->mono_600_pga = dev->init_mono_600_pga;
+	      RIE (usb_high_scan_evaluate_pixel_rate (dev));
+	      RIE (usb_high_scan_adjust_mono_600_power_delay (dev));
+	    }
+	  else
+	    {
+	      dev->expose_time = dev->init_expose_time;
+	      dev->mono_300_pga = dev->init_mono_300_pga;
+	      RIE (usb_high_scan_evaluate_pixel_rate (dev));
+	      RIE (usb_high_scan_adjust_mono_300_power_delay (dev));
+	    }
+	  break;
+	default:
+	  break;
+	}
+      break;
+    case 3:			/* CCD */
+      switch (dev->scan_mode)
+	{
+	case RGB24EXT:
+	  dev->red_rgb_600_pga = dev->init_red_rgb_600_pga;
+	  dev->green_rgb_600_pga = dev->init_green_rgb_600_pga;
+	  dev->blue_rgb_600_pga = dev->init_blue_rgb_600_pga;
+	  dev->skips_per_row = dev->init_skips_per_row_600;
+	  /* RIE(usb_high_scan_adjust_rgb_600_exposure (dev); fixme */
+	  /* RIE(usb_high_scan_adjust_rgb_600_offset (dev); fixme */
+	  /* RIE(usb_high_scan_adjust_rgb_600_pga (dev); fixme */
+	  /*    m_isAdjustedRgb600Offset=FALSE; */
+	  /* RIE(usb_high_scan_adjust_rgb_600_offset (dev); fixme */
+	  /* RIE(usb_high_scan_adjust_rgb_600_skips_per_row (dev); fixme */
+	  break;
+	case GRAY8EXT:
+	  dev->mono_600_pga = dev->init_mono_600_pga;
+	  dev->skips_per_row = dev->init_skips_per_row_600;
+	  RIE (usb_high_scan_adjust_mono_600_exposure (dev));
+	  /* RIE(usb_high_scan_adjust_mono_600_offset (dev); fixme */
+	  /* RIE(usb_high_scan_adjust_mono_600_pga (dev); fixme */
+	  dev->is_adjusted_mono_600_offset = SANE_FALSE;
+	  /* RIE(usb_high_scan_adjust_mono_600_offset (dev); fixme */
+	  /* RIE(usb_high_scan_adjust_mono_600_skips_per_row (dev); fixme */
+	  break;
+	default:
+	  break;
+	}
+      break;
+    default:
+      dev->expose_time = dev->init_expose_time;
+      dev->red_rgb_600_power_delay = dev->init_red_rgb_600_power_delay;
+      dev->green_rgb_600_power_delay = dev->init_green_rgb_600_power_delay;
+      dev->blue_rgb_600_power_delay = dev->init_blue_rgb_600_power_delay;
+      dev->red_mono_600_power_delay = dev->init_red_mono_600_power_delay;
+      dev->green_mono_600_power_delay = dev->init_green_mono_600_power_delay;
+      dev->blue_mono_600_power_delay = dev->init_blue_mono_600_power_delay;
+      dev->red_rgb_600_pga = dev->init_red_rgb_600_pga;
+      dev->green_rgb_600_pga = dev->init_green_rgb_600_pga;
+      dev->blue_rgb_600_pga = dev->init_blue_rgb_600_pga;
+      dev->mono_600_pga = dev->init_mono_600_pga;
+      dev->red_rgb_300_power_delay = dev->init_red_rgb_300_power_delay;
+      dev->green_rgb_300_power_delay = dev->init_green_rgb_300_power_delay;
+      dev->blue_rgb_300_power_delay = dev->init_blue_rgb_300_power_delay;
+      dev->red_mono_300_power_delay = dev->init_red_mono_300_power_delay;
+      dev->green_mono_300_power_delay = dev->init_green_mono_300_power_delay;
+      dev->blue_mono_300_power_delay = dev->init_blue_mono_300_power_delay;
+      dev->red_rgb_300_pga = dev->init_red_rgb_300_pga;
+      dev->green_rgb_300_pga = dev->init_green_rgb_300_pga;
+      dev->blue_rgb_300_pga = dev->init_blue_rgb_300_pga;
+      dev->mono_300_pga = dev->init_mono_300_pga;
+      break;
+    }
+  DBG (5, "usb_high_scan_hardware_calibration: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_line_calibration (Mustek_Usb_Device * dev)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_line_calibration: start\n");
+  switch (dev->scan_mode)
+    {
+    case RGB24EXT:
+      RIE (usb_high_scan_prepare_rgb_24 (dev));
+      if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi))
+	RIE (usb_high_scan_prepare_rgb_signal_600_dpi (dev));
+      else
+	RIE (usb_high_scan_prepare_rgb_signal_300_dpi (dev));
+      RIE (usb_mid_sensor_prepare_rgb (dev->chip, dev->x_dpi));
+      RIE (usb_high_scan_calibration_rgb_24 (dev));
+      break;
+    case GRAY8EXT:
+      RIE (usb_high_scan_prepare_mono_8 (dev));
+      if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi))
+	RIE (usb_high_scan_prepare_mono_signal_600_dpi (dev));
+      else
+	RIE (usb_high_scan_prepare_mono_signal_300_dpi (dev));
+      RIE (usb_mid_sensor_prepare_mono (dev->chip, dev->x_dpi));
+      RIE (usb_high_scan_calibration_mono_8 (dev));
+      break;
+    default:
+      DBG (3, "usb_high_scan_line_calibration: mode not matched\n");
+      return SANE_STATUS_INVAL;
+      break;
+    }
+  DBG (5, "usb_high_scan_line_calibration: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_prepare_scan (Mustek_Usb_Device * dev)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_prepare_scan: start\n");
+  switch (dev->scan_mode)
+    {
+    case RGB24EXT:
+      RIE (usb_high_scan_prepare_rgb_24 (dev));
+      dev->get_line = &usb_high_scan_get_rgb_24_bit_line;
+      dev->backtrack = &usb_high_scan_backtrack_rgb_24;
+
+      if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi))
+	RIE (usb_high_scan_prepare_rgb_signal_600_dpi (dev));
+      else
+	RIE (usb_high_scan_prepare_rgb_signal_300_dpi (dev));
+      RIE (usb_mid_sensor_prepare_rgb (dev->chip, dev->x_dpi));
+      RIE (usb_mid_motor_prepare_rgb (dev->chip, dev->y_dpi));
+      break;
+    case GRAY8EXT:
+      RIE (usb_high_scan_prepare_mono_8 (dev));
+      dev->get_line = &usb_high_scan_get_mono_8_bit_line;
+      dev->backtrack = &usb_high_scan_backtrack_mono_8;
+      if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi))
+	RIE (usb_high_scan_prepare_mono_signal_600_dpi (dev));
+      else
+	RIE (usb_high_scan_prepare_mono_signal_300_dpi (dev));
+      RIE (usb_mid_sensor_prepare_mono (dev->chip, dev->x_dpi));
+      RIE (usb_mid_motor_prepare_mono (dev->chip, dev->y_dpi));
+      break;
+    default:
+      DBG (5, "usb_high_scan_prepare_scan: unmatched mode\n");
+      return SANE_STATUS_INVAL;
+      break;
+    }
+  DBG (5, "usb_high_scan_prepare_scan: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_suggest_parameters (Mustek_Usb_Device * dev, SANE_Word dpi,
+				  SANE_Word x, SANE_Word y, SANE_Word width,
+				  SANE_Word height, Colormode color_mode)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_suggest_parameters: start\n");
+
+  RIE (usb_high_scan_detect_sensor (dev));
+  /* Looking up Optical Y Resolution */
+  RIE (usb_mid_motor_get_dpi (dev->chip, dpi, &dev->y_dpi));
+  /* Looking up Optical X Resolution */
+  RIE (usb_mid_sensor_get_dpi (dev->chip, dpi, &dev->x_dpi));
+
+  dev->x = x * dev->x_dpi / dpi;
+  dev->y = y * dev->y_dpi / dpi;
+  dev->width = width * dev->x_dpi / dpi;
+  dev->height = height * dev->y_dpi / dpi;
+
+  switch (color_mode)
+    {
+    case RGB24:
+      dev->scan_mode = RGB24EXT;
+      dev->bytes_per_row = dev->width * 3;
+      dev->bpp = 24;
+      break;
+    case GRAY8:
+      dev->scan_mode = GRAY8EXT;
+      dev->bpp = 8;
+      dev->bytes_per_row = dev->width;
+      break;
+    default:
+      DBG (3, "usb_high_scan_suggest_parameters: unmatched mode\n");
+      return SANE_STATUS_INVAL;
+      break;
+    }
+  DBG (5, "usb_high_scan_suggest_parameters: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_detect_sensor (Mustek_Usb_Device * dev)
+{
+  if (dev->is_sensor_detected)
+    {
+      DBG (5, "usb_high_scan_detect_sensor: sensor already detected\n");
+      return SANE_STATUS_GOOD;
+    }
+  dev->is_sensor_detected = SANE_TRUE;
+
+  switch (dev->chip->scanner_type)
+    {
+    case MT_600CU:
+      dev->chip->sensor = ST_CANON300;
+      dev->chip->motor = MT_600;
+      dev->is_cis_detected = SANE_TRUE;
+      DBG (4, "usb_high_scan_detect_sensor: sensor=Canon 300 dpi, motor="
+	   "600 dpi\n");
+      break;
+    case MT_1200USB:
+      dev->chip->sensor = ST_NEC600;
+      dev->chip->motor = MT_1200;
+      dev->init_min_expose_time = 2250;
+      dev->init_skips_per_row_600 = 0;
+      dev->init_home_lines = 32;
+      dev->init_dark_lines = 10;
+      dev->init_max_power_delay = 220;
+      dev->init_min_power_delay = 220;
+      dev->init_adjust_way = 3;
+      dev->init_red_rgb_600_pga = 30;
+      dev->init_green_rgb_600_pga = 30;
+      dev->init_blue_rgb_600_pga = 30;
+      dev->init_mono_600_pga = 30;
+      dev->init_expose_time = 16000;
+
+      dev->init_top_ref = 6;
+      dev->init_front_end = 12;
+      dev->init_red_offset = 128;
+      dev->init_green_offset = 128;
+      dev->init_blue_offset = 128;
+
+      dev->init_rgb_24_back_track = 0;
+      dev->init_mono_8_back_track = 40;
+
+      dev->is_cis_detected = SANE_FALSE;
+
+      DBG (4, "usb_high_scan_detect_sensor: sensor=Canon 600 dpi, motor="
+	   "1200 dpi\n");
+      break;
+    case MT_1200UB:
+    case MT_1200CU_PLUS:
+    case MT_1200CU:		/* need to check if it's a 300600 or 600 dpi sensor */
+      {
+	SANE_Byte *buffer;
+	static SANE_Word l_temp = 0, r_temp = 0;
+	SANE_Int i;
+	SANE_Status status;
+	SANE_Word lines_left;
+
+	dev->chip->motor = MT_1200;
+	dev->is_cis_detected = SANE_TRUE;
+
+	buffer = NULL;
+	l_temp = 0;
+	r_temp = 0;
+
+	buffer = (SANE_Byte *) malloc (dev->init_bytes_per_strip);
+
+	if (!buffer)
+	  return SANE_STATUS_NO_MEM;
+
+	for (i = 0; i < 5400; i++)
+	  buffer[i] = 0xaa;
+
+	dev->scan_mode = GRAY8EXT;
+	dev->x_dpi = 600;
+	dev->y_dpi = 1200;
+	dev->width = 5400;
+
+	RIE (usb_high_scan_init_asic (dev, ST_CANON600));
+	RIE (usb_low_turn_peripheral_power (dev->chip, SANE_TRUE));
+	RIE (usb_low_enable_motor (dev->chip, SANE_TRUE));	/* Enable Motor */
+	RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE));
+	RIE (usb_low_invert_image (dev->chip, SANE_FALSE));
+	RIE (usb_low_set_image_dpi (dev->chip, SANE_TRUE, SW_P6P6));
+	dev->bytes_per_strip = dev->adjust_length_600;
+	dev->bytes_per_row = 5400;
+	dev->dummy = 0;
+
+	RIE (usb_high_scan_wait_carriage_home (dev));
+	RIE (usb_high_scan_hardware_calibration (dev));
+	RIE (usb_high_scan_prepare_scan (dev));
+
+	/* Get Data */
+	RIE (usb_low_start_rowing (dev->chip));
+	RIE (usb_low_get_row (dev->chip, buffer, &lines_left));
+	RIE (usb_low_stop_rowing (dev->chip));
+	/* Calculate */
+	for (i = 0; i < 256; i++)
+	  l_temp = l_temp + buffer[512 + i];
+	for (i = 0; i < 256; i++)
+	  r_temp = r_temp + buffer[3500 + i];
+
+	l_temp = l_temp / 256;
+	r_temp = r_temp / 256;
+
+	/* 300/600 switch CIS or 600 CIS */
+	DBG (5, "usb_high_scan_detect_sensor: l_temp=%d, r_temp=%d\n",
+	     l_temp, r_temp);
+	if (r_temp > 50)
+	  {
+	    dev->chip->sensor = ST_CANON600;
+	    DBG (4,
+		 "usb_high_scan_detect_sensor: sensor=Canon 600 dpi, motor="
+		 "1200 dpi\n");
+	  }
+	else
+	  {
+	    DBG (4, "usb_high_scan_detect_sensor: sensor=Canon 300/600 dpi, "
+		 "motor=1200 dpi\n");
+	    dev->chip->sensor = ST_CANON300600;
+	  }
+
+	/* Release Resource */
+	free (buffer);
+	buffer = NULL;
+
+	break;
+      }
+    default:
+      DBG (5, "usb_high_scan_detect_sensor: I don't know this scanner type "
+	   "(%d)\n", dev->chip->scanner_type);
+      return SANE_STATUS_INVAL;
+    }
+
+  return SANE_STATUS_GOOD;
+}
+
+
+SANE_Status
+usb_high_scan_setup_scan (Mustek_Usb_Device * dev, Colormode color_mode,
+			  SANE_Word x_dpi, SANE_Word y_dpi,
+			  SANE_Bool is_invert, SANE_Word x, SANE_Word y,
+			  SANE_Word width)
+{
+  SANE_Status status;
+  SANE_Word upper_bound;
+  SANE_Word left_bound;
+
+  DBG (5, "usb_high_scan_setup_scan: start, is_invert=%d\n", is_invert);
+  if (!dev->is_open)
+    {
+      DBG (5, "usb_high_scan_setup_scan: not open\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (!dev->is_prepared)
+    {
+      DBG (5, "usb_high_scan_setup_scan: !is_prepared\n");
+      return SANE_STATUS_INVAL;
+    }
+
+  RIE (usb_high_scan_init_asic (dev, dev->chip->sensor));
+  RIE (usb_low_turn_peripheral_power (dev->chip, SANE_TRUE));
+  RIE (usb_low_enable_motor (dev->chip, SANE_TRUE));	/* Enable Motor */
+  RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE));
+  RIE (usb_low_invert_image (dev->chip, SANE_FALSE));
+  if (!dev->is_cis_detected)
+    {
+      usb_mid_front_set_front_end_mode (dev->chip, 16);
+      usb_mid_front_enable (dev->chip, SANE_TRUE);
+      usb_mid_front_set_top_reference (dev->chip, 244);
+      usb_mid_front_set_rgb_signal (dev->chip);
+    }
+
+  /* Compute necessary variables */
+  dev->scan_mode = color_mode;
+  dev->x_dpi = x_dpi;
+  dev->y_dpi = y_dpi;
+  dev->width = width;
+
+  switch (dev->scan_mode)
+    {
+    case RGB24EXT:
+      dev->bytes_per_row = 3 * dev->width;
+      upper_bound = ((y * 600) / dev->y_dpi) + dev->init_j_lines;
+      break;
+    case GRAY8EXT:
+      dev->bytes_per_row = dev->width;
+      upper_bound = ((y * 600) / dev->y_dpi) + dev->init_j_lines + 4;
+      /* fixme */
+      break;
+    default:
+      upper_bound = ((y * 600) / dev->y_dpi) + dev->init_j_lines + 4;
+      break;
+    }
+
+  if (usb_mid_sensor_is600_mode (dev->chip, dev->x_dpi))
+    {
+      /* in 600dpi */
+      left_bound = (x * 600 / dev->x_dpi) + dev->init_skips_per_row_600;
+      dev->skips_per_row = (((left_bound % 32) * dev->x_dpi + 300) / 600);
+    }
+  else
+    {
+      /* in 300dpi */
+      left_bound = (x * 300 / dev->x_dpi) + dev->init_skips_per_row_300;
+      dev->skips_per_row = (((left_bound % 32) * dev->x_dpi + 150) / 300);
+    }
+
+  dev->dummy = (left_bound / 32) * 32;
+
+  switch (dev->scan_mode)
+    {
+    case RGB24EXT:
+      dev->bytes_per_strip = dev->skips_per_row + dev->width;
+      break;
+    case GRAY8EXT:
+      dev->bytes_per_strip = dev->skips_per_row + dev->width;
+      break;
+    default:
+      break;
+    }
+
+  dev->bytes_per_strip = ((dev->bytes_per_strip + 1) / 2) * 2;
+  /* make bytes_per_strip is as 2n to advoid 64n+1 */
+
+  RIE (usb_high_scan_wait_carriage_home (dev));
+  RIE (usb_high_scan_hardware_calibration (dev));
+  RIE (usb_high_scan_line_calibration (dev));
+  RIE (usb_high_scan_step_forward (dev, upper_bound));
+  RIE (usb_high_scan_prepare_scan (dev));
+  RIE (usb_low_start_rowing (dev->chip));
+  /* pat_chromator fixme (init for calibration?) */
+  DBG (5, "usb_high_scan_setup_scan: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_get_rows (Mustek_Usb_Device * dev, SANE_Byte * block,
+			SANE_Word rows, SANE_Bool is_order_invert)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_get_rows: start, %d rows\n", rows);
+  if (!dev->is_open)
+    {
+      DBG (3, "usb_high_scan_get_rows: not open\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (!dev->is_prepared)
+    {
+      DBG (3, "usb_high_scan_get_rows: !is_prepared\n");
+      return SANE_STATUS_INVAL;
+    }
+  while (rows > 0)
+    {
+      RIE ((*dev->get_line) (dev, block, is_order_invert));
+      block += dev->bytes_per_row;
+      rows--;
+    }
+  DBG (5, "usb_high_scan_get_rows: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_stop_scan (Mustek_Usb_Device * dev)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_stop_scan: start\n");
+  if (!dev->is_open)
+    {
+      DBG (3, "usb_high_scan_stop_scan: not open\n");
+      return SANE_STATUS_INVAL;
+    }
+  if (!dev->is_prepared)
+    {
+      DBG (3, "usb_high_scan_stop_scan: !is_prepared\n");
+      return SANE_STATUS_INVAL;
+    }
+  switch (dev->scan_mode)
+    {
+    case RGB24EXT:
+      RIE (usb_high_cal_exit (dev->blue_calibrator));
+      if (dev->blue_calibrator)
+	free (dev->blue_calibrator);
+      dev->blue_calibrator = NULL;
+      RIE (usb_high_cal_exit (dev->green_calibrator));
+      if (dev->green_calibrator)
+	free (dev->green_calibrator);
+      dev->green_calibrator = NULL;
+      RIE (usb_high_cal_exit (dev->red_calibrator));
+      if (dev->red_calibrator)
+	free (dev->red_calibrator);
+      dev->red_calibrator = NULL;
+      break;
+    case GRAY8EXT:
+      RIE (usb_high_cal_exit (dev->mono_calibrator));
+      if (dev->mono_calibrator)
+	free (dev->mono_calibrator);
+      dev->mono_calibrator = NULL;
+      break;
+    default:
+      break;
+    }
+
+  RIE (usb_low_stop_rowing (dev->chip));
+  if (!dev->is_cis_detected)
+    RIE (usb_low_turn_lamp_power (dev->chip, SANE_FALSE));
+
+  DBG (5, "usb_high_scan_stop_scan: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_init_asic (Mustek_Usb_Device * dev, Sensor_Type sensor)
+{
+  SANE_Byte ccd_dpi = 0;
+  SANE_Byte select = 0;
+  SANE_Byte adjust = 0;
+  SANE_Byte pin = 0;
+  SANE_Byte motor = 0;
+  SANE_Bool fix_pattern = SANE_FALSE;
+  SANE_Byte ad_timing = 0;
+  Banksize bank_size;
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_init_asic: start\n");
+  switch (sensor)
+    {
+    case ST_TOSHIBA600:
+      ccd_dpi = 32;
+      select = 240;
+      adjust = 0;
+      pin = 18;
+      motor = 0;
+      fix_pattern = SANE_FALSE;
+      ad_timing = 0;
+      bank_size = BS_16K;
+      DBG (5, "usb_high_scan_init_asic: sensor is set to TOSHIBA600\n");
+      break;
+    case ST_CANON300:
+      ccd_dpi = 232;
+      select = 232;
+      adjust = 0;
+      pin = 18;
+      motor = 0;
+      fix_pattern = SANE_FALSE;
+      ad_timing = 1;
+      bank_size = BS_4K;
+      DBG (5, "usb_high_scan_init_asic: sensor is set to CANON300\n");
+      break;
+    case ST_CANON300600:
+      ccd_dpi = 232;
+      select = 232;
+      adjust = 64;
+      pin = 18;
+      motor = 0;
+      fix_pattern = SANE_FALSE;
+      ad_timing = 1;
+      bank_size = BS_16K;
+      DBG (5, "usb_high_scan_init_asic: sensor is set to CANON300600\n");
+      break;
+    case ST_CANON600:
+      ccd_dpi = 232;
+      select = 232;
+      adjust = 64;
+      pin = 18;
+      motor = 0;
+      fix_pattern = SANE_FALSE;
+      ad_timing = 1;
+      bank_size = BS_16K;
+      DBG (5, "usb_high_scan_init_asic: sensor is set to CANON600\n");
+      break;
+    case ST_NEC600:		/* fixme */
+      ccd_dpi = 32;
+      select = 224;
+      adjust = 112;
+      pin = 18;
+      motor = 0;
+      fix_pattern = SANE_FALSE;
+      ad_timing = 0;
+      bank_size = BS_16K;
+      DBG (5, "usb_high_scan_init_asic: sensor is set to NEC600\n");
+      break;
+    default:
+      DBG (5, "usb_high_scan_init_asic: unknown sensor\n");
+      return SANE_STATUS_INVAL;
+      break;
+    }
+  RIE (usb_low_adjust_timing (dev->chip, adjust));
+  RIE (usb_low_select_timing (dev->chip, select));
+  RIE (usb_low_set_timing (dev->chip, ccd_dpi));
+  RIE (usb_low_set_sram_bank (dev->chip, bank_size));
+  RIE (usb_low_set_asic_io_pins (dev->chip, pin));
+  RIE (usb_low_set_rgb_sel_pins (dev->chip, pin));
+  RIE (usb_low_set_motor_signal (dev->chip, motor));
+  RIE (usb_low_set_test_sram_mode (dev->chip, SANE_FALSE));
+  RIE (usb_low_set_fix_pattern (dev->chip, fix_pattern));
+  RIE (usb_low_set_ad_timing (dev->chip, ad_timing));
+
+  DBG (5, "usb_high_scan_init_asic: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_evaluate_max_level (Mustek_Usb_Device * dev,
+				  SANE_Word sample_lines,
+				  SANE_Int sample_length,
+				  SANE_Byte * ret_max_level)
+{
+  SANE_Byte max_level = 0;
+  SANE_Word i;
+  SANE_Int j;
+  SANE_Status status;
+  SANE_Word lines_left;
+
+  DBG (5, "usb_high_scan_evaluate_max_level: start\n");
+
+  sample_length -= 20;
+  RIE (usb_low_start_rowing (dev->chip));
+  for (i = 0; i < sample_lines; i++)
+    {
+      RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
+      for (j = 20; j < sample_length; j++)
+	{
+	  if (max_level < dev->green[j])
+	    max_level = dev->green[j];
+	}
+    }
+  RIE (usb_low_stop_rowing (dev->chip));
+  if (ret_max_level)
+    *ret_max_level = max_level;
+  DBG (5, "usb_high_scan_evaluate_max_level: exit, max_level = %d\n",
+       max_level);
+  return SANE_STATUS_GOOD;
+}
+
+/* Binary Search for Single Channel Power Delay */
+SANE_Status
+usb_high_scan_bssc_power_delay (Mustek_Usb_Device * dev,
+				Powerdelay_Function set_power_delay,
+				Signal_State * signal_state,
+				SANE_Byte * target, SANE_Byte max,
+				SANE_Byte min, SANE_Byte threshold,
+				SANE_Int length)
+{
+  SANE_Byte max_level;
+  SANE_Byte max_max = max;
+  SANE_Byte min_min = min;
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_bssc_power_delay: start\n");
+
+  *target = (max + min) / 2;
+  RIE ((*set_power_delay) (dev->chip, *target));
+  while (*target != min)
+    {
+      RIE (usb_high_scan_evaluate_max_level (dev, dev->init_powerdelay_lines,
+					     length, &max_level));
+      if (max_level > threshold)
+	{
+	  min = *target;
+	  *target = (max + min) / 2;
+	  *signal_state = SS_BRIGHTER;
+	}
+      else if (max_level < threshold)
+	{
+	  max = *target;
+	  *target = (max + min) / 2;
+	  *signal_state = SS_DARKER;
+	}
+      else if (max_level == threshold)
+	{			/* Found. */
+	  *signal_state = SS_EQUAL;
+	  return SANE_STATUS_GOOD;
+	}
+      RIE ((*set_power_delay) (dev->chip, *target));
+    }
+  /* Fail... */
+  if (max == max_max || min == min_min)
+    {				/* Boundary check */
+      if (max == max_max)	/*target on max side */
+	*target = max_max;
+      else
+	*target = min_min;
+      RIE ((*set_power_delay) (dev->chip, *target));
+      RIE (usb_high_scan_evaluate_max_level (dev, dev->init_powerdelay_lines,
+					     length, &max_level));
+
+      if (max_level > threshold)
+	{
+	  *signal_state = SS_BRIGHTER;
+	}
+      else if (max_level < threshold)
+	{
+	  *signal_state = SS_DARKER;
+	}
+      else if (max_level == threshold)
+	{
+	  *signal_state = SS_EQUAL;
+	}
+    }
+  else
+    {				/* Fail... will always on mimnum side, make it darker */
+      target++;
+      *signal_state = SS_DARKER;
+    }
+  DBG (5, "usb_high_scan_bssc_power_delay: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_adjust_rgb_600_power_delay (Mustek_Usb_Device * dev)
+{
+  SANE_Status status;
+  SANE_Byte max_power_delay;
+  Signal_State signal_state = SS_UNKNOWN;
+
+  DBG (5, "usb_high_scan_adjust_rgb_600_power_delay: start\n");
+  max_power_delay = (SANE_Byte) (dev->expose_time / 64);
+
+  if (dev->is_adjusted_rgb_600_power_delay)
+    return SANE_STATUS_GOOD;
+  /* Setup Initial State */
+  dev->red_rgb_600_power_delay = max_power_delay;
+  dev->green_rgb_600_power_delay = max_power_delay;
+  dev->blue_rgb_600_power_delay = max_power_delay;
+
+  RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time));
+  RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
+  RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
+  RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
+  RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
+  RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
+  RIE (usb_mid_front_set_rgb_signal (dev->chip));
+  RIE (usb_low_set_dummy (dev->chip, dev->init_skips_per_row_600));
+  RIE (usb_low_set_image_byte_width (dev->chip, dev->adjust_length_600));
+  RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT));
+
+  /* adjust GreenPD */
+  RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_GREEN));
+  RIE (usb_mid_sensor_prepare_rgb (dev->chip, 600));
+  signal_state = SS_UNKNOWN;
+  RIE (usb_mid_front_set_green_pga (dev->chip, dev->green_rgb_600_pga));
+  RIE (usb_high_scan_bssc_power_delay
+       (dev, &usb_low_set_green_pd, &signal_state,
+	&dev->green_rgb_600_power_delay,
+	max_power_delay, 0, dev->init_max_power_delay,
+	dev->adjust_length_600));
+
+  /* adjust BluePD */
+  RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_BLUE));
+  RIE (usb_mid_sensor_prepare_rgb (dev->chip, 600));
+  signal_state = SS_UNKNOWN;
+  RIE (usb_mid_front_set_blue_pga (dev->chip, dev->blue_rgb_600_pga));
+  RIE (usb_high_scan_bssc_power_delay
+       (dev, &usb_low_set_blue_pd, &signal_state,
+	&dev->blue_rgb_600_power_delay,
+	max_power_delay, 0, dev->init_max_power_delay,
+	dev->adjust_length_600));
+
+  /* adjust RedPD */
+  RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_RED));
+  RIE (usb_mid_sensor_prepare_rgb (dev->chip, 600));
+  signal_state = SS_UNKNOWN;
+  RIE (usb_mid_front_set_red_pga (dev->chip, dev->red_rgb_600_pga));
+  RIE (usb_high_scan_bssc_power_delay
+       (dev, &usb_low_set_red_pd, &signal_state,
+	&dev->red_rgb_600_power_delay, max_power_delay, 0,
+	dev->init_max_power_delay, dev->adjust_length_600));
+
+  dev->is_adjusted_rgb_600_power_delay = SANE_TRUE;
+  DBG (5, "usb_high_scan_adjust_rgb_600_power_delay: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_adjust_mono_600_power_delay (Mustek_Usb_Device * dev)
+{
+  SANE_Byte max_power_delay;
+  Signal_State signal_state = SS_UNKNOWN;
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_adjust_mono_600_power_delay: start\n");
+  max_power_delay = (SANE_Byte) (dev->expose_time / 64);
+  if (dev->is_adjusted_mono_600_power_delay)
+    return SANE_STATUS_GOOD;
+  /* Setup Initial State */
+  dev->red_mono_600_power_delay = max_power_delay;
+  dev->green_mono_600_power_delay = max_power_delay;
+  dev->blue_mono_600_power_delay = max_power_delay;
+
+  /* Compute Gray PD */
+  RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time));
+  RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
+  RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
+  RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
+  RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
+  RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
+  RIE (usb_mid_front_set_rgb_signal (dev->chip));
+  RIE (usb_low_set_dummy (dev->chip, dev->init_skips_per_row_600));
+  RIE (usb_low_set_image_byte_width (dev->chip, dev->adjust_length_600));
+  RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT));
+
+  /* adjust GreenGrayPD */
+  RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_GREEN));
+  RIE (usb_mid_sensor_prepare_rgb (dev->chip, 600));
+  signal_state = SS_UNKNOWN;
+  RIE (usb_mid_front_set_red_pga (dev->chip, dev->mono_600_pga));
+  RIE (usb_mid_front_set_green_pga (dev->chip, dev->mono_600_pga));
+  RIE (usb_mid_front_set_blue_pga (dev->chip, dev->mono_600_pga));
+  RIE (usb_high_scan_bssc_power_delay
+       (dev, &usb_low_set_green_pd, &signal_state,
+	&dev->green_mono_600_power_delay,
+	max_power_delay, 0, dev->init_max_power_delay,
+	dev->adjust_length_600));
+
+  dev->is_adjusted_mono_600_power_delay = SANE_TRUE;
+  DBG (5, "usb_high_scan_adjust_mono_600_power_delay: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+/* CCD */
+SANE_Status
+usb_high_scan_adjust_mono_600_exposure (Mustek_Usb_Device * dev)
+{
+  SANE_Word transfer_time;
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_adjust_mono_600_exposure: start\n");
+  if (dev->is_adjusted_mono_600_exposure)
+    return SANE_STATUS_GOOD;
+
+  RIE (usb_high_scan_evaluate_pixel_rate (dev));
+  transfer_time = dev->pixel_rate * dev->x_dpi / 600;
+  if (transfer_time > 16000)
+    transfer_time = 16000;
+
+  dev->mono_600_exposure =
+    MAX (5504, MAX (transfer_time,
+		    usb_mid_motor_mono_capability (dev->chip, dev->y_dpi)));
+  dev->mono_600_exposure = ((dev->mono_600_exposure + 63) / 64) * 64;
+  dev->is_adjusted_mono_600_exposure = SANE_TRUE;
+  DBG (5, "usb_high_scan_adjust_mono_600_exposure: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+#if 0
+/* CCD */
+SANE_Status
+usb_high_scan_adjust_mono_600_offset (Mustek_Usb_Device * dev)
+{
+  DBG (5, "usb_high_scan_adjust_mono_600_offset: start\n");
+  if (dev->is_adjusted_mono_600_offset)
+    return SANE_STATUS_GOOD;
+
+  DBG (5, "usb_high_scan_adjust_mono_600_offset: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+/* CCD */
+SANE_Status
+usb_high_scan_adjust_mono_600_pga (Mustek_Usb_Device * dev)
+{
+  DBG (5, "usb_high_scan_adjust_mono_600_pga: start (dev = %p)\n", dev);
+  DBG (5, "usb_high_scan_adjust_mono_600_pga: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+/* CCD */
+SANE_Status
+usb_high_scan_adjust_mono_600_skips_per_row (Mustek_Usb_Device * dev)
+{
+  DBG (5, "usb_high_scan_adjust_mono_600_skips_per_row: start (dev = %p)\n",
+       dev);
+  DBG (5, "usb_high_scan_adjust_mono_600_skips_per_row: exit\n");
+  return SANE_STATUS_GOOD;
+}
+#endif
+
+SANE_Status
+usb_high_scan_adjust_rgb_300_power_delay (Mustek_Usb_Device * dev)
+{
+  /* Setup Initial State */
+  SANE_Byte max_power_delay;
+  Signal_State signal_state = SS_UNKNOWN;
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_adjust_rgb_300_power_delay: start\n");
+  max_power_delay = (SANE_Byte) (dev->expose_time / 64);
+  if (dev->is_adjusted_rgb_300_power_delay)
+    return SANE_STATUS_GOOD;
+
+  dev->red_rgb_300_power_delay = max_power_delay;
+  dev->green_rgb_300_power_delay = max_power_delay;
+  dev->blue_rgb_300_power_delay = max_power_delay;
+
+  RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time));
+  RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
+  RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
+  RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
+  RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
+  RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
+  RIE (usb_mid_front_set_rgb_signal (dev->chip));
+  RIE (usb_low_set_dummy (dev->chip, dev->init_skips_per_row_300));
+  RIE (usb_low_set_image_byte_width (dev->chip, dev->adjust_length_300));
+  RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT));
+
+  /* adjust GreenPD */
+  RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_GREEN));
+  RIE (usb_mid_sensor_prepare_rgb (dev->chip, 300));
+
+  signal_state = SS_UNKNOWN;
+  RIE (usb_mid_front_set_green_pga (dev->chip, dev->green_rgb_300_pga));
+  RIE (usb_high_scan_bssc_power_delay
+       (dev, &usb_low_set_green_pd, &signal_state,
+	&dev->green_rgb_300_power_delay,
+	max_power_delay, 0, dev->init_max_power_delay,
+	dev->adjust_length_300));
+
+  /* adjust BluePD */
+  RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_BLUE));
+  RIE (usb_mid_sensor_prepare_rgb (dev->chip, 300));
+
+  signal_state = SS_UNKNOWN;
+  RIE (usb_mid_front_set_blue_pga (dev->chip, dev->blue_rgb_300_pga));
+  RIE (usb_high_scan_bssc_power_delay
+       (dev, &usb_low_set_blue_pd, &signal_state,
+	&dev->blue_rgb_300_power_delay, max_power_delay, 0,
+	dev->init_max_power_delay, dev->adjust_length_300));
+
+  /* adjust RedPD */
+  RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_RED));
+  RIE (usb_mid_sensor_prepare_rgb (dev->chip, 300));
+
+  signal_state = SS_UNKNOWN;
+  RIE (usb_mid_front_set_red_pga (dev->chip, dev->red_rgb_300_pga));
+  RIE (usb_high_scan_bssc_power_delay
+       (dev, &usb_low_set_red_pd, &signal_state,
+	&dev->red_rgb_300_power_delay, max_power_delay, 0,
+	dev->init_max_power_delay, dev->adjust_length_300));
+  dev->is_adjusted_rgb_300_power_delay = SANE_TRUE;
+  DBG (5, "usb_high_scan_adjust_rgb_300_power_delay: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_adjust_mono_300_power_delay (Mustek_Usb_Device * dev)
+{
+  SANE_Byte max_power_delay;
+  Signal_State signal_state = SS_UNKNOWN;
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_adjust_mono_300_power_delay: start\n");
+  max_power_delay = (SANE_Byte) (dev->expose_time / 64);
+  if (dev->is_adjusted_mono_300_power_delay)
+    return SANE_STATUS_GOOD;
+  /* Setup Initial State */
+  dev->red_mono_300_power_delay = max_power_delay;
+  dev->green_mono_300_power_delay = max_power_delay;
+  dev->blue_mono_300_power_delay = max_power_delay;
+
+  /* Compute Gray PD */
+  RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time));
+  RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
+  RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
+  RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
+  RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
+  RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
+  RIE (usb_mid_front_set_rgb_signal (dev->chip));
+  RIE (usb_low_set_dummy (dev->chip, dev->init_skips_per_row_300));
+  RIE (usb_low_set_image_byte_width (dev->chip, dev->adjust_length_300));
+  RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT));
+
+  /* adjust GreenGrayPD */
+  RIE (usb_mid_motor_prepare_adjust (dev->chip, CH_GREEN));
+  RIE (usb_mid_sensor_prepare_rgb (dev->chip, 300));
+
+  signal_state = SS_UNKNOWN;
+  RIE (usb_mid_front_set_red_pga (dev->chip, dev->mono_300_pga));
+  RIE (usb_mid_front_set_green_pga (dev->chip, dev->mono_300_pga));
+  RIE (usb_mid_front_set_blue_pga (dev->chip, dev->mono_300_pga));
+  RIE (usb_high_scan_bssc_power_delay
+       (dev, &usb_low_set_green_pd, &signal_state,
+	&dev->green_mono_300_power_delay,
+	max_power_delay, 0, dev->init_max_power_delay,
+	dev->adjust_length_300));
+
+  dev->is_adjusted_mono_300_power_delay = SANE_TRUE;
+  DBG (5, "usb_high_scan_adjust_mono_300_power_delay: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_evaluate_pixel_rate (Mustek_Usb_Device * dev)
+{
+  DBG (5, "usb_high_scan_evaluate_pixel_rate: start, dev=%p\n", (void *) dev);
+
+  /* fixme: new for CCD */
+  dev->pixel_rate = 2000;
+  dev->is_evaluate_pixel_rate = SANE_TRUE;
+  DBG (5, "usb_high_scan_evaluate_pixel_rate: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_calibration_rgb_24 (Mustek_Usb_Device * dev)
+{
+  SANE_Word white_need;
+  SANE_Word dark_need;
+  SANE_Word i;
+  SANE_Status status;
+  SANE_Word lines_left;
+  SANE_Word minor_average;
+
+  DBG (5, "usb_high_scan_calibration_rgb_24: start, dev=%p\n", (void *) dev);
+  if (dev->is_cis_detected)
+    {
+      RIE (usb_mid_motor_prepare_calibrate_rgb (dev->chip, dev->y_dpi));
+      RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE));
+      minor_average = 2;
+    }
+  else
+    {
+      minor_average = 1;
+    }
+
+  dev->red_calibrator = (Calibrator *) malloc (sizeof (Calibrator));
+  if (!dev->red_calibrator)
+    return SANE_STATUS_NO_MEM;
+
+  RIE (usb_high_cal_init (dev->red_calibrator, I8O8RGB,
+			  dev->init_k_level << 8, 0));
+  RIE (usb_high_cal_prepare (dev->red_calibrator, dev->width));
+  RIE (usb_high_cal_embed_gamma (dev->red_calibrator, dev->gamma_table));
+  RIE (usb_high_cal_setup
+       (dev->red_calibrator, 1, minor_average, 8, dev->width, &white_need,
+	&dark_need));
+
+  dev->green_calibrator = (Calibrator *) malloc (sizeof (Calibrator));
+  if (!dev->green_calibrator)
+    return SANE_STATUS_NO_MEM;
+  RIE (usb_high_cal_init (dev->green_calibrator, I8O8RGB,
+			  dev->init_k_level << 8, 0));
+  RIE (usb_high_cal_prepare (dev->green_calibrator, dev->width));
+  RIE (usb_high_cal_embed_gamma (dev->green_calibrator, dev->gamma_table));
+  RIE (usb_high_cal_setup (dev->green_calibrator, 1, minor_average, 8,
+			   dev->width, &white_need, &dark_need));
+
+  dev->blue_calibrator = (Calibrator *) malloc (sizeof (Calibrator));
+  if (!dev->blue_calibrator)
+    return SANE_STATUS_NO_MEM;
+
+  RIE (usb_high_cal_init (dev->blue_calibrator, I8O8RGB,
+			  dev->init_k_level << 8, 0));
+  RIE (usb_high_cal_prepare (dev->blue_calibrator, dev->width));
+  RIE (usb_high_cal_embed_gamma (dev->blue_calibrator, dev->gamma_table));
+  RIE (usb_high_cal_setup (dev->blue_calibrator, 1, minor_average, 8,
+			   dev->width, &white_need, &dark_need));
+
+  /* K White */
+  RIE (usb_low_start_rowing (dev->chip));
+  for (i = 0; i < white_need; i++)
+    {
+      /* Read Green Channel */
+      RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
+      RIE (usb_high_cal_fill_in_white (dev->green_calibrator, i, 0,
+				       (void *) (dev->green +
+						 dev->skips_per_row)));
+      RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
+      RIE (usb_high_cal_fill_in_white (dev->green_calibrator, i, 1,
+				       (void *) (dev->green +
+						 dev->skips_per_row)));
+      /* Read Blue Channel */
+      RIE (usb_low_get_row (dev->chip, dev->blue, &lines_left));
+      RIE (usb_high_cal_fill_in_white (dev->blue_calibrator, i, 0,
+				       (void *) (dev->blue +
+						 dev->skips_per_row)));
+      RIE (usb_low_get_row (dev->chip, dev->blue, &lines_left));
+      RIE (usb_high_cal_fill_in_white (dev->blue_calibrator, i, 1,
+				       (void *) (dev->blue +
+						 dev->skips_per_row)));
+      /* Read Red Channel */
+      RIE (usb_low_get_row (dev->chip, dev->red, &lines_left));
+      RIE (usb_high_cal_fill_in_white (dev->red_calibrator, i, 0,
+				       (void *) (dev->red +
+						 dev->skips_per_row)));
+      RIE (usb_low_get_row (dev->chip, dev->red, &lines_left));
+      RIE (usb_high_cal_fill_in_white (dev->red_calibrator, i, 1,
+				       (void *) (dev->red +
+						 dev->skips_per_row)));
+    }
+  RIE (usb_low_stop_rowing (dev->chip));
+  /* Caculate average */
+  RIE (usb_high_cal_evaluate_white (dev->green_calibrator,
+				    dev->init_green_factor));
+  RIE (usb_high_cal_evaluate_white (dev->blue_calibrator,
+				    dev->init_blue_factor));
+  RIE (usb_high_cal_evaluate_white (dev->red_calibrator,
+				    dev->init_red_factor));
+
+  RIE (usb_mid_motor_prepare_calibrate_rgb (dev->chip, dev->y_dpi));
+  RIE (usb_low_enable_motor (dev->chip, SANE_FALSE));
+  RIE (usb_low_turn_lamp_power (dev->chip, SANE_FALSE));
+
+  /* K Black */
+  RIE (usb_low_start_rowing (dev->chip));
+  for (i = 0; i < dark_need; i++)
+    {
+      /* Read Green Channel */
+      RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
+      RIE (usb_high_cal_fill_in_dark (dev->green_calibrator, i, 0,
+				      (void *) (dev->green +
+						dev->skips_per_row)));
+      RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
+      RIE (usb_high_cal_fill_in_dark (dev->green_calibrator, i, 1,
+				      (void *) (dev->green +
+						dev->skips_per_row)));
+      /* Read Blue Channel */
+      RIE (usb_low_get_row (dev->chip, dev->blue, &lines_left));
+      RIE (usb_high_cal_fill_in_dark (dev->blue_calibrator, i, 0,
+				      (void *) (dev->blue +
+						dev->skips_per_row)));
+      RIE (usb_low_get_row (dev->chip, dev->blue, &lines_left));
+      RIE (usb_high_cal_fill_in_dark (dev->blue_calibrator, i, 1,
+				      (void *) (dev->blue +
+						dev->skips_per_row)));
+      /* Read Red Channel */
+      RIE (usb_low_get_row (dev->chip, dev->red, &lines_left));
+      RIE (usb_high_cal_fill_in_dark (dev->red_calibrator, i, 0,
+				      (void *) (dev->red +
+						dev->skips_per_row)));
+      RIE (usb_low_get_row (dev->chip, dev->red, &lines_left));
+      RIE (usb_high_cal_fill_in_dark (dev->red_calibrator, i, 1,
+				      (void *) (dev->red +
+						dev->skips_per_row)));
+    }
+  RIE (usb_low_stop_rowing (dev->chip));
+  RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE));
+  /* Calculate average */
+  RIE (usb_high_cal_evaluate_dark (dev->green_calibrator,
+				   dev->init_green_black_factor));
+  RIE (usb_high_cal_evaluate_dark (dev->blue_calibrator,
+				   dev->init_blue_black_factor));
+  RIE (usb_high_cal_evaluate_dark (dev->red_calibrator,
+				   dev->init_red_black_factor));
+  /* Calculate Mapping */
+  RIE (usb_high_cal_evaluate_calibrator (dev->green_calibrator));
+  RIE (usb_high_cal_evaluate_calibrator (dev->blue_calibrator));
+  RIE (usb_high_cal_evaluate_calibrator (dev->red_calibrator));
+  DBG (5, "usb_high_scan_calibration_rgb_24: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_calibration_mono_8 (Mustek_Usb_Device * dev)
+{
+  SANE_Word white_need;
+  SANE_Word dark_need;
+  SANE_Word i;
+  SANE_Status status;
+  SANE_Word lines_left;
+
+  DBG (5, "usb_high_scan_calibration_mono_8: start\n");
+  RIE (usb_mid_motor_prepare_calibrate_mono (dev->chip, dev->y_dpi));
+  RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE));
+
+  dev->mono_calibrator = (Calibrator *) malloc (sizeof (Calibrator));
+  if (!dev->mono_calibrator)
+    return SANE_STATUS_NO_MEM;
+
+  RIE (usb_high_cal_init (dev->mono_calibrator, I8O8MONO,
+			  dev->init_k_level << 8, 0));
+  RIE (usb_high_cal_prepare (dev->mono_calibrator, dev->width));
+  RIE (usb_high_cal_embed_gamma (dev->mono_calibrator, dev->gamma_table));
+  RIE (usb_high_cal_setup (dev->mono_calibrator, 1, 1, 8,
+			   dev->width, &white_need, &dark_need));
+
+  /* K White */
+  RIE (usb_low_start_rowing (dev->chip));
+  for (i = 0; i < white_need; i++)
+    {
+      /* Read Green Channel */
+      RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
+      RIE (usb_high_cal_fill_in_white (dev->mono_calibrator, i, 0,
+				       (void *) (dev->green +
+						 dev->skips_per_row)));
+    }
+  RIE (usb_low_stop_rowing (dev->chip));
+  /* Caculate average */
+  RIE (usb_high_cal_evaluate_white (dev->mono_calibrator,
+				    dev->init_gray_factor));
+
+  RIE (usb_mid_motor_prepare_calibrate_mono (dev->chip, dev->y_dpi));
+  RIE (usb_low_enable_motor (dev->chip, SANE_FALSE));
+  RIE (usb_low_turn_lamp_power (dev->chip, SANE_FALSE));
+
+  /* K Black */
+  RIE (usb_low_start_rowing (dev->chip));
+  for (i = 0; i < dark_need; i++)
+    {
+      /* Read Green Channel */
+      RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
+      RIE (usb_high_cal_fill_in_dark (dev->mono_calibrator, i, 0,
+				      (void *) (dev->green +
+						dev->skips_per_row)));
+    }
+  RIE (usb_low_stop_rowing (dev->chip));
+  RIE (usb_low_turn_lamp_power (dev->chip, SANE_TRUE));
+  /* Caculate Green Black */
+  RIE (usb_high_cal_evaluate_dark (dev->mono_calibrator,
+				   dev->init_gray_black_factor));
+  /* Caculate Mapping */
+  RIE (usb_high_cal_evaluate_calibrator (dev->mono_calibrator));
+  DBG (5, "usb_high_scan_calibration_mono_8: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_step_forward (Mustek_Usb_Device * dev, SANE_Int step_count)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_step_forward: start\n");
+
+  if (step_count <= 0)
+    return SANE_STATUS_INVAL;
+  /* Initialize */
+  RIE (usb_low_set_ccd_width (dev->chip, dev->init_min_expose_time));
+  RIE (usb_low_set_motor_direction (dev->chip, SANE_FALSE));
+  RIE (usb_mid_motor_prepare_step (dev->chip, (SANE_Word) step_count));
+  /* Startup */
+  RIE (usb_low_start_rowing (dev->chip));
+  /* Wait for stop */
+  /* Linux USB seems buggy on timeout... sleep before really try  */
+  /* to read the flag from scanner */
+  usleep (step_count * 2 * 1000);
+  RIE (usb_low_wait_rowing_stop (dev->chip));
+  if (!dev->is_cis_detected)
+    RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time));
+
+  DBG (5, "usb_high_scan_step_forward: start\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_safe_forward (Mustek_Usb_Device * dev, SANE_Int step_count)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_safe_forward: start\n");
+  if (step_count <= 0)
+    return SANE_STATUS_INVAL;
+  /* Initialize */
+  RIE (usb_low_set_ccd_width (dev->chip, 5400));
+  RIE (usb_low_set_motor_direction (dev->chip, SANE_FALSE));
+  RIE (usb_mid_motor_prepare_step (dev->chip, (SANE_Word) step_count));
+  /* Startup */
+  RIE (usb_low_start_rowing (dev->chip));
+  /* Wait to Stop */
+  RIE (usb_low_wait_rowing_stop (dev->chip));
+  RIE (usb_low_set_ccd_width (dev->chip, dev->expose_time));
+  DBG (5, "usb_high_scan_safe_forward: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Word
+usb_high_scan_calculate_max_rgb_600_expose (Mustek_Usb_Device * dev,
+					    SANE_Byte * ideal_red_pd,
+					    SANE_Byte * ideal_green_pd,
+					    SANE_Byte * ideal_blue_pd)
+{
+  SANE_Word red_light_up;
+  SANE_Word green_light_up;
+  SANE_Word blue_light_up;
+  SANE_Word max_light_up;
+  SANE_Word ideal_expose_time;
+
+  DBG (5, "usb_high_scan_calculate_max_rgb_600_expose: dev=%p\n", (void *) dev);
+
+  red_light_up = dev->expose_time - dev->red_rgb_600_power_delay * 64;
+  green_light_up = dev->expose_time - dev->green_rgb_600_power_delay * 64;
+  blue_light_up = dev->expose_time - dev->blue_rgb_600_power_delay * 64;
+  max_light_up = MAX (red_light_up, MAX (green_light_up, blue_light_up));
+  if (dev->chip->sensor == ST_NEC600)
+    {
+      ideal_expose_time
+	= MAX (MAX (5504, max_light_up),
+	       usb_mid_motor_rgb_capability (dev->chip, dev->y_dpi));
+    }
+  else
+    {
+      ideal_expose_time
+	= MAX (MAX (5376, max_light_up),
+	       usb_mid_motor_rgb_capability (dev->chip, dev->y_dpi));
+    }
+  ideal_expose_time = (ideal_expose_time + 63) / 64 * 64;
+  *ideal_red_pd = (SANE_Byte) ((ideal_expose_time - red_light_up) / 64);
+  *ideal_green_pd = (SANE_Byte) ((ideal_expose_time - green_light_up) / 64);
+  *ideal_blue_pd = (SANE_Byte) ((ideal_expose_time - blue_light_up) / 64);
+  DBG (5, "usb_high_scan_calculate_max_rgb_600_expose: exit\n");
+  return ideal_expose_time;
+}
+
+SANE_Word
+usb_high_scan_calculate_max_mono_600_expose (Mustek_Usb_Device * dev,
+					     SANE_Byte * ideal_red_pd,
+					     SANE_Byte * ideal_green_pd,
+					     SANE_Byte * ideal_blue_pd)
+{
+  SANE_Word max_light_up;
+  SANE_Word ideal_expose_time;
+  SANE_Word transfer_time;
+
+  DBG (5, "usb_high_scan_calculate_max_mono_600_expose: dev=%p\n", (void *) dev);
+
+  max_light_up = dev->expose_time - dev->green_mono_600_power_delay * 64;
+  transfer_time = (SANE_Word) ((SANE_Word) (dev->pixel_rate)
+			       * (SANE_Word) (dev->x_dpi) / 600);
+  /* base on 600, but double it. */
+
+  if (transfer_time > 16000)
+    transfer_time = 16000;
+  if (dev->chip->sensor == ST_NEC600)
+    {
+      ideal_expose_time
+	= MAX (MAX (5504, max_light_up),
+	       MAX (transfer_time, usb_mid_motor_mono_capability
+		    (dev->chip, dev->y_dpi)));
+    }
+  else
+    {
+      ideal_expose_time
+	= MAX (MAX (5376, max_light_up),
+	       MAX (transfer_time, usb_mid_motor_mono_capability
+		    (dev->chip, dev->y_dpi)));
+    }
+  ideal_expose_time = (ideal_expose_time + 63) / 64 * 64;
+  *ideal_red_pd = (SANE_Byte) ((ideal_expose_time) / 64);
+  *ideal_green_pd = (SANE_Byte) ((ideal_expose_time - max_light_up) / 64);
+  *ideal_blue_pd = (SANE_Byte) ((ideal_expose_time) / 64);
+  DBG (5, "usb_high_scan_calculate_max_mono_600_expose: exit\n");
+  return ideal_expose_time;
+}
+
+SANE_Word
+usb_high_scan_calculate_max_rgb_300_expose (Mustek_Usb_Device * dev,
+					    SANE_Byte * ideal_red_pd,
+					    SANE_Byte * ideal_green_pd,
+					    SANE_Byte * ideal_blue_pd)
+{
+  SANE_Word red_light_up;
+  SANE_Word green_light_up;
+  SANE_Word blue_light_up;
+  SANE_Word max_light_up;
+  SANE_Word ideal_expose_time;
+
+  DBG (5, "usb_high_scan_calculate_max_rgb_300_expose: start\n");
+  red_light_up = dev->expose_time - dev->red_rgb_300_power_delay * 64;
+  green_light_up = dev->expose_time - dev->green_rgb_300_power_delay * 64;
+  blue_light_up = dev->expose_time - dev->blue_rgb_300_power_delay * 64;
+  max_light_up = MAX (red_light_up, MAX (green_light_up, blue_light_up));
+
+  if (dev->chip->sensor == ST_CANON300600)
+    {
+      ideal_expose_time =
+	MAX (MAX (2624, max_light_up),
+	     usb_mid_motor_rgb_capability (dev->chip, dev->y_dpi));
+    }
+  else if (dev->chip->sensor == ST_CANON300)
+    {
+      ideal_expose_time = MAX (MAX (2624, max_light_up),	/* fixme? */
+			       usb_mid_motor_rgb_capability (dev->chip,
+							     dev->y_dpi));
+    }
+  else
+    {
+      ideal_expose_time =
+	MAX (MAX (5376, max_light_up),
+	     usb_mid_motor_rgb_capability (dev->chip, dev->y_dpi));
+    }
+
+  ideal_expose_time = (ideal_expose_time + 63) / 64 * 64;
+  *ideal_red_pd = (SANE_Byte) ((ideal_expose_time - red_light_up) / 64);
+  *ideal_green_pd = (SANE_Byte) ((ideal_expose_time - green_light_up) / 64);
+  *ideal_blue_pd = (SANE_Byte) ((ideal_expose_time - blue_light_up) / 64);
+  DBG (5, "usb_high_scan_calculate_max_rgb_300_expose: exit\n");
+  return ideal_expose_time;
+}
+
+SANE_Word
+usb_high_scan_calculate_max_mono_300_expose (Mustek_Usb_Device * dev,
+					     SANE_Byte * ideal_red_pd,
+					     SANE_Byte * ideal_green_pd,
+					     SANE_Byte * ideal_blue_pd)
+{
+  SANE_Word max_light_up;
+  SANE_Word transfer_time;
+  SANE_Word ideal_expose_time;
+
+  DBG (5, "usb_high_scan_calculate_max_mono_300_expose: start\n");
+  max_light_up = dev->expose_time - dev->green_mono_300_power_delay * 64;
+  transfer_time =
+    (SANE_Word) ((SANE_Word) (dev->pixel_rate) *
+		 (SANE_Word) (dev->x_dpi) / 600);
+  /* base on 600, but double it. */
+
+  if (transfer_time > 16000)
+    transfer_time = 16000;
+  if (dev->chip->sensor == ST_CANON300600)
+    {
+      ideal_expose_time =
+	MAX (MAX (2688, max_light_up),
+	     MAX (transfer_time,
+		  usb_mid_motor_mono_capability (dev->chip, dev->y_dpi)));
+    }
+  else if (dev->chip->sensor == ST_CANON300)
+    {
+      ideal_expose_time = MAX (MAX (2688, max_light_up),	/* fixme? */
+			       MAX (transfer_time,
+				    usb_mid_motor_mono_capability (dev->chip,
+								   dev->
+								   y_dpi)));
+    }
+  else
+    {
+      ideal_expose_time =
+	MAX (MAX (5376, max_light_up),
+	     MAX (transfer_time,
+		  usb_mid_motor_mono_capability (dev->chip, dev->y_dpi)));
+    }
+
+  ideal_expose_time = (ideal_expose_time + 63) / 64 * 64;
+  *ideal_red_pd = (SANE_Byte) ((ideal_expose_time) / 64);
+  *ideal_green_pd = (SANE_Byte) ((ideal_expose_time - max_light_up) / 64);
+  *ideal_blue_pd = (SANE_Byte) ((ideal_expose_time) / 64);
+  DBG (5, "usb_high_scan_calculate_max_mono_300_expose: exit\n");
+  return ideal_expose_time;
+}
+
+SANE_Status
+usb_high_scan_prepare_rgb_signal_600_dpi (Mustek_Usb_Device * dev)
+{
+  SANE_Byte ideal_red_pd, ideal_green_pd, ideal_blue_pd;
+  SANE_Word ideal_expose_time;
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_prepare_rgb_signal_600_dpi: start\n");
+  ideal_expose_time = usb_high_scan_calculate_max_rgb_600_expose
+    (dev, &ideal_red_pd, &ideal_green_pd, &ideal_blue_pd);
+
+  RIE (usb_low_set_ccd_width (dev->chip, ideal_expose_time));
+  RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
+  RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
+  RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
+  RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
+  RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
+  RIE (usb_mid_front_set_red_pga (dev->chip, dev->red_rgb_600_pga));
+  RIE (usb_mid_front_set_green_pga (dev->chip, dev->green_rgb_600_pga));
+  RIE (usb_mid_front_set_blue_pga (dev->chip, dev->blue_rgb_600_pga));
+  RIE (usb_mid_front_set_rgb_signal (dev->chip));
+  RIE (usb_low_set_red_pd (dev->chip, ideal_red_pd));
+  RIE (usb_low_set_green_pd (dev->chip, ideal_green_pd));
+  RIE (usb_low_set_blue_pd (dev->chip, ideal_blue_pd));
+  DBG (5, "usb_high_scan_prepare_rgb_signal_600_dpi: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_prepare_mono_signal_600_dpi (Mustek_Usb_Device * dev)
+{
+  SANE_Byte ideal_red_pd, ideal_green_pd, ideal_blue_pd;
+  SANE_Word ideal_expose_time;
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_prepare_mono_signal_600_dpi: start\n");
+  ideal_expose_time = usb_high_scan_calculate_max_mono_600_expose
+    (dev, &ideal_red_pd, &ideal_green_pd, &ideal_blue_pd);
+
+  RIE (usb_low_set_ccd_width (dev->chip, ideal_expose_time));
+  RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
+  RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
+  RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
+  RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
+  RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
+  RIE (usb_mid_front_set_red_pga (dev->chip, dev->mono_600_pga));
+  RIE (usb_mid_front_set_green_pga (dev->chip, dev->mono_600_pga));
+  RIE (usb_mid_front_set_blue_pga (dev->chip, dev->mono_600_pga));
+  RIE (usb_mid_front_set_rgb_signal (dev->chip));
+  RIE (usb_low_set_red_pd (dev->chip, ideal_red_pd));
+  RIE (usb_low_set_green_pd (dev->chip, ideal_green_pd));
+  RIE (usb_low_set_blue_pd (dev->chip, ideal_blue_pd));
+  DBG (5, "usb_high_scan_prepare_mono_signal_600_dpi: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_prepare_rgb_signal_300_dpi (Mustek_Usb_Device * dev)
+{
+  SANE_Byte ideal_red_pd, ideal_green_pd, ideal_blue_pd;
+  SANE_Word ideal_expose_time;
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_prepare_rgb_signal_300_dpi: start\n");
+
+  ideal_expose_time = usb_high_scan_calculate_max_rgb_300_expose
+    (dev, &ideal_red_pd, &ideal_green_pd, &ideal_blue_pd);
+
+  RIE (usb_low_set_ccd_width (dev->chip, ideal_expose_time));
+  RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
+  RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
+  RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
+  RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
+  RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
+  RIE (usb_mid_front_set_red_pga (dev->chip, dev->red_rgb_300_pga));
+  RIE (usb_mid_front_set_green_pga (dev->chip, dev->green_rgb_300_pga));
+  RIE (usb_mid_front_set_blue_pga (dev->chip, dev->blue_rgb_300_pga));
+  RIE (usb_mid_front_set_rgb_signal (dev->chip));
+  RIE (usb_low_set_red_pd (dev->chip, ideal_red_pd));
+  RIE (usb_low_set_green_pd (dev->chip, ideal_green_pd));
+  RIE (usb_low_set_blue_pd (dev->chip, ideal_blue_pd));
+  DBG (5, "usb_high_scan_prepare_rgb_signal_300_dpi: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_prepare_mono_signal_300_dpi (Mustek_Usb_Device * dev)
+{
+  /* Setup Scan Here */
+  SANE_Byte ideal_red_pd, ideal_green_pd, ideal_blue_pd;
+  SANE_Word ideal_expose_time;
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_prepare_mono_signal_300_dpi: start\n");
+  ideal_expose_time = usb_high_scan_calculate_max_mono_300_expose
+    (dev, &ideal_red_pd, &ideal_green_pd, &ideal_blue_pd);
+
+  RIE (usb_low_set_ccd_width (dev->chip, ideal_expose_time));
+  RIE (usb_mid_front_set_front_end_mode (dev->chip, dev->init_front_end));
+  RIE (usb_mid_front_set_top_reference (dev->chip, dev->init_top_ref));
+  RIE (usb_mid_front_set_red_offset (dev->chip, dev->init_red_offset));
+  RIE (usb_mid_front_set_green_offset (dev->chip, dev->init_green_offset));
+  RIE (usb_mid_front_set_blue_offset (dev->chip, dev->init_blue_offset));
+  RIE (usb_mid_front_set_red_pga (dev->chip, dev->mono_300_pga));
+  RIE (usb_mid_front_set_green_pga (dev->chip, dev->mono_300_pga));
+  RIE (usb_mid_front_set_blue_pga (dev->chip, dev->mono_300_pga));
+  RIE (usb_mid_front_set_rgb_signal (dev->chip));
+  RIE (usb_low_set_red_pd (dev->chip, ideal_red_pd));
+  RIE (usb_low_set_green_pd (dev->chip, ideal_green_pd));
+  RIE (usb_low_set_blue_pd (dev->chip, ideal_blue_pd));
+  DBG (5, "usb_high_scan_prepare_mono_signal_300_dpi: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_prepare_rgb_24 (Mustek_Usb_Device * dev)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_prepare_rgb_24: start\n");
+  RIE (usb_low_set_image_byte_width (dev->chip, dev->bytes_per_strip));
+  RIE (usb_low_set_dummy (dev->chip, dev->dummy));
+  RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT));
+  DBG (5, "usb_high_scan_prepare_rgb_24: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_prepare_mono_8 (Mustek_Usb_Device * dev)
+{
+  SANE_Status status;
+
+  DBG (5, "usb_high_scan_prepare_mono_8: start\n");
+  RIE (usb_low_set_image_byte_width (dev->chip, dev->bytes_per_strip));
+  RIE (usb_low_set_dummy (dev->chip, dev->dummy));
+  RIE (usb_low_set_pixel_depth (dev->chip, PD_8BIT));
+  DBG (5, "usb_high_scan_prepare_mono_8: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_get_rgb_24_bit_line (Mustek_Usb_Device * dev, SANE_Byte * line,
+				   SANE_Bool is_order_invert)
+{
+  SANE_Status status;
+  SANE_Word lines_left;
+
+  DBG (5, "usb_high_scan_get_rgb_24_bit_line: start, dev=%p, line=%p, "
+       "is_order_invert=%d\n", (void *) dev, line, is_order_invert);
+
+  RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
+
+  RIE (usb_low_get_row (dev->chip, dev->blue, &lines_left));
+
+  RIE (usb_low_get_row (dev->chip, dev->red, &lines_left));
+  RIE (usb_high_cal_calibrate (dev->green_calibrator,
+			       dev->green + dev->skips_per_row, line + 1));
+  RIE (usb_high_cal_calibrate (dev->blue_calibrator,
+			       dev->blue + dev->skips_per_row,
+			       line + ((is_order_invert) ? 0 : 2)));
+  RIE (usb_high_cal_calibrate (dev->red_calibrator,
+			       dev->red + dev->skips_per_row,
+			       line + ((is_order_invert) ? 2 : 0)));
+
+  DBG (5, "usb_high_scan_get_rgb_24_bit_line: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+
+SANE_Status
+usb_high_scan_get_mono_8_bit_line (Mustek_Usb_Device * dev, SANE_Byte * line,
+				   SANE_Bool is_order_invert)
+{
+  SANE_Status status;
+  SANE_Word lines_left;
+
+  DBG (5, "usb_high_scan_get_mono_8_bit_line: start, dev=%p, line=%p, "
+       "is_order_invert=%d\n", (void *) dev, line, is_order_invert);
+
+  RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
+  RIE (usb_high_cal_calibrate (dev->mono_calibrator, dev->green +
+			       dev->skips_per_row, line));
+  DBG (5, "usb_high_scan_get_mono_8_bit_line: exit\n");
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_backtrack_rgb_24 (Mustek_Usb_Device * dev)
+{
+  DBG (5, "usb_high_scan_backtrack_rgb_24: noop, dev=%p\n", (void *) dev);
+  return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+usb_high_scan_backtrack_mono_8 (Mustek_Usb_Device * dev)
+{
+  SANE_Int i;
+  SANE_Status status;
+  SANE_Word lines_left;
+
+  DBG (5, "usb_high_scan_backtrack_mono_8: start, dev=%p\n", (void *) dev);
+
+  if (dev->y_dpi >= 300)
+    {
+      RIE (usb_low_stop_rowing (dev->chip));
+      RIE (usb_low_set_motor_direction (dev->chip, SANE_TRUE));
+      RIE (usb_low_start_rowing (dev->chip));
+      for (i = 0; i < dev->init_mono_8_back_track; i++)
+	{
+	  RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
+	}
+      usleep (100 * 1000);
+      RIE (usb_low_stop_rowing (dev->chip));
+      RIE (usb_low_set_motor_direction (dev->chip, SANE_FALSE));
+      RIE (usb_low_start_rowing (dev->chip));
+      for (i = 0; i < dev->init_mono_8_back_track; i++)
+	{
+	  RIE (usb_low_get_row (dev->chip, dev->green, &lines_left));
+	}
+    }
+  DBG (5, "usb_high_scan_backtrack_mono_8: exit\n");
+  return SANE_STATUS_GOOD;
+}