Update upstream source from tag 'upstream/1.0.29'

Update to upstream version '1.0.29'
with Debian dir 2d358af604988ebe4348e38096245d66036fe5ed

1 files changed, 2434 insertions, 0 deletions

diff --git a/backend/pixma/pixma_mp800.c b/backend/pixma/pixma_mp800.c
new file mode 100644
index 0000000..feef611
--- /dev/null
+++ b/backend/pixma/pixma_mp800.c
@@ -0,0 +1,2434 @@
+/* SANE - Scanner Access Now Easy.
+
+ Copyright (C) 2011-2019 Rolf Bensch <rolf at bensch hyphen online dot de>
+ Copyright (C) 2007-2009 Nicolas Martin, <nicols-guest at alioth dot debian dot org>
+ Copyright (C) 2006-2007 Wittawat Yamwong <wittawat@web.de>
+
+ 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.
+ */
+/* test cases
+ 1. short USB packet (must be no -ETIMEDOUT)
+ 2. cancel using button on the printer (look for abort command)
+ 3. start scan while busy (status 0x1414)
+ 4. cancel using ctrl-c (must send abort command)
+ */
+
+#define TPU_48             /* uncomment to activate TPU scan at 48 bits */
+/*#define DEBUG_TPU_48*//* uncomment to debug 48 bits TPU on a non TPU device */
+/*#define DEBUG_TPU_24*//* uncomment to debug 24 bits TPU on a non TPU device */
+
+/*#define TPUIR_USE_RGB*/      /* uncomment to use RGB channels and convert them to gray; otherwise use R channel only */
+
+#include "../include/sane/config.h"
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>		/* localtime(C90) */
+
+#include "pixma_rename.h"
+#include "pixma_common.h"
+#include "pixma_io.h"
+
+/* Some macro code to enhance readability */
+#define RET_IF_ERR(x) do {	\
+    if ((error = (x)) < 0)	\
+      return error;		\
+  } while(0)
+
+#define WAIT_INTERRUPT(x) do {			\
+    error = handle_interrupt (s, x);		\
+    if (s->cancel)				\
+      return PIXMA_ECANCELED;			\
+    if (error != PIXMA_ECANCELED && error < 0)	\
+      return error;				\
+  } while(0)
+
+#ifdef __GNUC__
+# define UNUSED(v) (void) v
+#else
+# define UNUSED(v)
+#endif
+
+/* Size of the command buffer should be multiple of wMaxPacketLength and
+ greater than 4096+24.
+ 4096 = size of gamma table. 24 = header + checksum */
+#define IMAGE_BLOCK_SIZE (512*1024)
+#define CMDBUF_SIZE (4096 + 24)
+#define DEFAULT_GAMMA 2.0	/***** Gamma different from 1.0 is potentially impacting color profile generation *****/
+#define UNKNOWN_PID 0xffff
+
+#define CANON_VID 0x04a9
+
+/* Generation 1 */
+#define MP800_PID 0x170d
+#define MP800R_PID 0x170e
+#define MP830_PID 0x1713
+
+/* Generation 2 */
+#define MP810_PID 0x171a
+#define MP960_PID 0x171b
+
+/* Generation 3 */
+/* PIXMA 2007 vintage */
+#define MP970_PID 0x1726
+
+/* Flatbed scanner CCD (2007) */
+#define CS8800F_PID 0x1901
+
+/* PIXMA 2008 vintage */
+#define MP980_PID 0x172d
+
+/* Generation 4 */
+#define MP990_PID 0x1740
+
+/* Flatbed scanner CCD (2010) */
+#define CS9000F_PID 0x1908
+
+/* 2010 new device (untested) */
+#define MG8100_PID 0x174b /* CCD */
+
+/* 2011 new device (untested) */
+#define MG8200_PID 0x1756 /* CCD */
+
+/* 2013 new device */
+#define CS9000F_MII_PID 0x190d
+
+/* Generation 4 XML messages that encapsulates the Pixma protocol messages */
+#define XML_START_1   \
+"<?xml version=\"1.0\" encoding=\"utf-8\" ?>\
+<cmd xmlns:ivec=\"http://www.canon.com/ns/cmd/2008/07/common/\">\
+<ivec:contents><ivec:operation>StartJob</ivec:operation>\
+<ivec:param_set servicetype=\"scan\"><ivec:jobID>00000001</ivec:jobID>\
+<ivec:bidi>1</ivec:bidi></ivec:param_set></ivec:contents></cmd>"
+
+#define XML_START_2   \
+"<?xml version=\"1.0\" encoding=\"utf-8\" ?>\
+<cmd xmlns:ivec=\"http://www.canon.com/ns/cmd/2008/07/common/\" xmlns:vcn=\"http://www.canon.com/ns/cmd/2008/07/canon/\">\
+<ivec:contents><ivec:operation>VendorCmd</ivec:operation>\
+<ivec:param_set servicetype=\"scan\"><ivec:jobID>00000001</ivec:jobID>\
+<vcn:ijoperation>ModeShift</vcn:ijoperation><vcn:ijmode>1</vcn:ijmode>\
+</ivec:param_set></ivec:contents></cmd>"
+
+#define XML_END   \
+"<?xml version=\"1.0\" encoding=\"utf-8\" ?>\
+<cmd xmlns:ivec=\"http://www.canon.com/ns/cmd/2008/07/common/\">\
+<ivec:contents><ivec:operation>EndJob</ivec:operation>\
+<ivec:param_set servicetype=\"scan\"><ivec:jobID>00000001</ivec:jobID>\
+</ivec:param_set></ivec:contents></cmd>"
+
+#define XML_OK   "<ivec:response>OK</ivec:response>"
+
+enum mp810_state_t
+{
+  state_idle,
+  state_warmup,
+  state_scanning,
+  state_transfering,
+  state_finished
+};
+
+enum mp810_cmd_t
+{
+  cmd_start_session = 0xdb20,
+  cmd_select_source = 0xdd20,
+  cmd_gamma = 0xee20,
+  cmd_scan_param = 0xde20,
+  cmd_status = 0xf320,
+  cmd_abort_session = 0xef20,
+  cmd_time = 0xeb80,
+  cmd_read_image = 0xd420,
+  cmd_error_info = 0xff20,
+
+  cmd_start_calibrate_ccd_3 = 0xd520,
+  cmd_end_calibrate_ccd_3 = 0xd720,
+  cmd_scan_param_3 = 0xd820,
+  cmd_scan_start_3 = 0xd920,
+  cmd_status_3 = 0xda20,
+  cmd_get_tpu_info_3 = 0xf520,
+  cmd_set_tpu_info_3 = 0xea20,
+
+  cmd_e920 = 0xe920 /* seen in MP800 */
+};
+
+typedef struct mp810_t
+{
+  enum mp810_state_t state;
+  pixma_cmdbuf_t cb;
+  uint8_t *imgbuf;
+  uint8_t current_status[16];
+  unsigned last_block;
+  uint8_t generation;
+  /* for Generation 3 and CCD shift */
+  uint8_t *linebuf;
+  uint8_t *data_left_ofs;
+  unsigned data_left_len;
+  int shift[3];
+  unsigned color_shift;
+  unsigned stripe_shift;
+  unsigned stripe_shift2; /* added for MP810, MP960 at 4800dpi & 9000F at 9600dpi */
+  unsigned jumplines; /* added for MP810, MP960 at 4800dpi & 9000F at 9600dpi */
+  uint8_t tpu_datalen;
+  uint8_t tpu_data[0x40];
+} mp810_t;
+
+/*
+ STAT:  0x0606 = ok,
+ 0x1515 = failed (PIXMA_ECANCELED),
+ 0x1414 = busy (PIXMA_EBUSY)
+
+ Transaction scheme
+ 1. command_header/data | result_header
+ 2. command_header      | result_header/data
+ 3. command_header      | result_header/image_data
+
+ - data has checksum in the last byte.
+ - image_data has no checksum.
+ - data and image_data begins in the same USB packet as
+ command_header or result_header.
+
+ command format #1:
+ u16be      cmd
+ u8[6]      0
+ u8[4]      0
+ u32be      PLEN parameter length
+ u8[PLEN-1] parameter
+ u8         parameter check sum
+ result:
+ u16be      STAT
+ u8         0
+ u8         0 or 0x21 if STAT == 0x1414
+ u8[4]      0
+
+ command format #2:
+ u16be      cmd
+ u8[6]      0
+ u8[4]      0
+ u32be      RLEN result length
+ result:
+ u16be      STAT
+ u8[6]      0
+ u8[RLEN-1] result
+ u8         result check sum
+
+ command format #3: (only used by read_image_block)
+ u16be      0xd420
+ u8[6]      0
+ u8[4]      0
+ u32be      max. block size + 8
+ result:
+ u16be      STAT
+ u8[6]      0
+ u8         block info bitfield: 0x8 = end of scan, 0x10 = no more paper, 0x20 = no more data
+ u8[3]      0
+ u32be      ILEN image data size
+ u8[ILEN]   image data
+ */
+
+static void mp810_finish_scan (pixma_t * s);
+
+static int is_scanning_from_adf (pixma_t * s)
+{
+  return (s->param->source == PIXMA_SOURCE_ADF
+           || s->param->source == PIXMA_SOURCE_ADFDUP);
+}
+
+static int is_scanning_from_adfdup (pixma_t * s)
+{
+  return (s->param->source == PIXMA_SOURCE_ADFDUP);
+}
+
+static int is_scanning_from_tpu (pixma_t * s)
+{
+  return (s->param->source == PIXMA_SOURCE_TPU);
+}
+
+static int send_xml_dialog (pixma_t * s, const char * xml_message)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  int datalen;
+
+  datalen = pixma_cmd_transaction (s, xml_message, strlen (xml_message),
+                                   mp->cb.buf, 1024);
+  if (datalen < 0)
+    return datalen;
+
+  mp->cb.buf[datalen] = 0;
+
+  PDBG(pixma_dbg (10, "XML message sent to scanner:\n%s\n", xml_message));
+  PDBG(pixma_dbg (10, "XML response back from scanner:\n%s\n", mp->cb.buf));
+
+  return (strcasestr ((const char *) mp->cb.buf, XML_OK) != NULL);
+}
+
+static void new_cmd_tpu_msg (pixma_t *s, pixma_cmdbuf_t * cb, uint16_t cmd)
+{
+  pixma_newcmd (cb, cmd, 0, 0);
+  cb->buf[3] = (is_scanning_from_tpu (s)) ? 0x01 : 0x00;
+}
+
+static int start_session (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+
+  new_cmd_tpu_msg (s, &mp->cb, cmd_start_session);
+  return pixma_exec (s, &mp->cb);
+}
+
+static int start_scan_3 (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+
+  new_cmd_tpu_msg (s, &mp->cb, cmd_scan_start_3);
+  return pixma_exec (s, &mp->cb);
+}
+
+static int send_cmd_start_calibrate_ccd_3 (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+
+  pixma_newcmd (&mp->cb, cmd_start_calibrate_ccd_3, 0, 0);
+  mp->cb.buf[3] = 0x01;
+  return pixma_exec (s, &mp->cb);
+}
+
+static int is_calibrated (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  if (mp->generation >= 3)
+  {
+    return ((mp->current_status[0] & 0x01) == 1);
+  }
+  if (mp->generation == 1)
+  {
+    return (mp->current_status[8] == 1);
+  }
+  else
+  {
+    return (mp->current_status[9] == 1);
+  }
+}
+
+static int has_paper (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+
+  if (is_scanning_from_adfdup (s))
+    return (mp->current_status[1] == 0 || mp->current_status[2] == 0);
+  else
+    return (mp->current_status[1] == 0);
+}
+
+static void drain_bulk_in (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  while (pixma_read (s->io, mp->imgbuf, IMAGE_BLOCK_SIZE) >= 0)
+    ;
+}
+
+static int abort_session (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  return pixma_exec_short_cmd (s, &mp->cb, cmd_abort_session);
+}
+
+static int send_cmd_e920 (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  return pixma_exec_short_cmd (s, &mp->cb, cmd_e920);
+}
+
+static int select_source (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  uint8_t *data;
+
+  data = pixma_newcmd (&mp->cb, cmd_select_source, 12, 0);
+  data[5] = ((mp->generation == 2) ? 1 : 0);
+  switch (s->param->source)
+  {
+    case PIXMA_SOURCE_FLATBED:
+      data[0] = 1;
+      data[1] = 1;
+      break;
+
+    case PIXMA_SOURCE_ADF:
+      data[0] = 2;
+      data[5] = 1;
+      data[6] = 1;
+      break;
+
+    case PIXMA_SOURCE_ADFDUP:
+      data[0] = 2;
+      data[5] = 3;
+      data[6] = 3;
+      break;
+
+    case PIXMA_SOURCE_TPU:
+      data[0] = 4;
+      data[1] = 2;
+      break;
+  }
+  return pixma_exec (s, &mp->cb);
+}
+
+static int send_get_tpu_info_3 (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  uint8_t *data;
+  int error;
+
+  data = pixma_newcmd (&mp->cb, cmd_get_tpu_info_3, 0, 0x34);
+  RET_IF_ERR(pixma_exec (s, &mp->cb));
+  memcpy (mp->tpu_data, data, 0x34);
+  return error;
+}
+
+static int send_set_tpu_info (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  uint8_t *data;
+
+  if (mp->tpu_datalen == 0)
+    return 0;
+  data = pixma_newcmd (&mp->cb, cmd_set_tpu_info_3, 0x34, 0);
+  memcpy (data, mp->tpu_data, 0x34);
+  return pixma_exec (s, &mp->cb);
+}
+
+static int send_gamma_table (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  const uint8_t *lut = s->param->gamma_table;
+  uint8_t *data;
+
+  if (mp->generation == 1)
+  {
+    data = pixma_newcmd (&mp->cb, cmd_gamma, 4096 + 8, 0);
+    data[0] = (s->param->channels == 3) ? 0x10 : 0x01;
+    pixma_set_be16 (0x1004, data + 2);
+    if (lut)
+      memcpy (data + 4, lut, 4096);
+    else
+      pixma_fill_gamma_table (DEFAULT_GAMMA, data + 4, 4096);
+  }
+  else
+  {
+    /* FIXME: Gamma table for 2nd generation: 1024 * uint16_le */
+    data = pixma_newcmd (&mp->cb, cmd_gamma, 2048 + 8, 0);
+    data[0] = 0x10;
+    pixma_set_be16 (0x0804, data + 2);
+    if (lut)
+    {
+      int i;
+      for (i = 0; i < 1024; i++)
+      {
+        int j = (i << 2) + (i >> 8);
+        data[4 + 2 * i + 0] = lut[j];
+        data[4 + 2 * i + 1] = lut[j];
+      }
+    }
+    else
+    {
+      int i;
+      pixma_fill_gamma_table (DEFAULT_GAMMA, data + 4, 2048);
+      for (i = 0; i < 1024; i++)
+      {
+        int j = (i << 1) + (i >> 9);
+        data[4 + 2 * i + 0] = data[4 + j];
+        data[4 + 2 * i + 1] = data[4 + j];
+      }
+    }
+  }
+  return pixma_exec (s, &mp->cb);
+}
+
+static unsigned calc_raw_width (const mp810_t * mp,
+                                const pixma_scan_param_t * param)
+{
+  unsigned raw_width;
+  /* NOTE: Actually, we can send arbitary width to MP810. Lines returned
+     are always padded to multiple of 4 or 12 pixels. Is this valid for
+     other models, too? */
+  if (mp->generation >= 2)
+  {
+    raw_width = ALIGN_SUP (param->w + param->xs, 32);
+    /* PDBG (pixma_dbg (4, "*calc_raw_width***** width %u extended by %u and rounded to %u *****\n", param->w, param->xs, raw_width)); */
+  }
+  else if (param->channels == 1)
+  {
+    raw_width = ALIGN_SUP (param->w + param->xs, 12);
+  }
+  else
+  {
+    raw_width = ALIGN_SUP (param->w + param->xs, 4);
+  }
+  return raw_width;
+}
+
+static int has_ccd_sensor (pixma_t * s)
+{
+  return ((s->cfg->cap & PIXMA_CAP_CCD) != 0);
+}
+
+#if 0
+static int is_color (pixma_t * s)
+{
+  return (s->param->mode == PIXMA_SCAN_MODE_COLOR);
+}
+
+static int is_color_48 (pixma_t * s)
+{
+  return (s->param->mode == PIXMA_SCAN_MODE_COLOR_48);
+}
+
+static int is_color_negative (pixma_t * s)
+{
+  return (s->param->mode == PIXMA_SCAN_MODE_NEGATIVE_COLOR);
+}
+
+static int is_color_all (pixma_t * s)
+{
+  return (is_color (s) || is_color_48 (s) || is_color_negative (s));
+}
+#endif
+
+static int is_gray (pixma_t * s)
+{
+  return (s->param->mode == PIXMA_SCAN_MODE_GRAY);
+}
+
+static int is_gray_16 (pixma_t * s)
+{
+  return (s->param->mode == PIXMA_SCAN_MODE_GRAY_16);
+}
+
+static int is_gray_negative (pixma_t * s)
+{
+  return (s->param->mode == PIXMA_SCAN_MODE_NEGATIVE_GRAY);
+}
+
+static int is_gray_all (pixma_t * s)
+{
+  return (is_gray (s) || is_gray_16 (s) || is_gray_negative (s));
+}
+
+static int is_lineart (pixma_t * s)
+{
+  return (s->param->mode == PIXMA_SCAN_MODE_LINEART);
+}
+
+static int is_tpuir (pixma_t * s)
+{
+  return (s->param->mode == PIXMA_SCAN_MODE_TPUIR);
+}
+
+/* CCD sensors don't have neither a Grayscale mode nor a Lineart mode,
+ * but use color mode instead */
+static unsigned get_cis_ccd_line_size (pixma_t * s)
+{
+  return ((
+      s->param->wx ? s->param->line_size / s->param->w * s->param->wx
+                   : s->param->line_size)
+      * ((is_tpuir (s) || is_gray_all (s) || is_lineart (s)) ? 3 : 1));
+}
+
+static unsigned calc_shifting (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+
+  /* If stripes shift needed (CCD devices), how many pixels shift */
+  mp->stripe_shift = 0;
+  mp->stripe_shift2 = 0;
+  mp->jumplines = 0;
+
+  switch (s->cfg->pid)
+  {
+    case MP800_PID:
+    case MP800R_PID:
+    case MP830_PID:
+      if (s->param->xdpi == 2400)
+        {
+          if (is_scanning_from_tpu(s))
+            mp->stripe_shift = 6;
+          else
+            mp->stripe_shift = 3;
+        }
+      if (s->param->ydpi > 75)
+        {
+          mp->color_shift = s->param->ydpi / ((s->param->ydpi < 1200) ? 150 : 75);
+
+          if (is_scanning_from_tpu (s))
+            mp->color_shift = s->param->ydpi / 75;
+
+          /* If you're trying to decipher this color-shifting code,
+             the following line is where the magic is revealed. */
+          mp->shift[1] = mp->color_shift * get_cis_ccd_line_size (s);
+          if (is_scanning_from_adf (s))
+            {  /* ADF */
+              mp->shift[0] = 0;
+              mp->shift[2] = 2 * mp->shift[1];
+            }
+          else
+            {  /* Flatbed or TPU */
+              mp->shift[0] = 2 * mp->shift[1];
+              mp->shift[2] = 0;
+            }
+        }
+      break;
+
+    case MP970_PID: /* MP970 at 4800 dpi */
+    case CS8800F_PID: /* CanoScan 8800F at 4800 dpi */
+      if (s->param->xdpi == 4800)
+      {
+        if (is_scanning_from_tpu (s))
+          mp->stripe_shift = 6;
+        else
+          mp->stripe_shift = 3;
+      }
+      break;
+
+    case CS9000F_PID: /* CanoScan 9000F at 4800 dpi */
+    case CS9000F_MII_PID:
+      if (s->param->xdpi == 4800)
+      {
+        if (is_scanning_from_tpu (s))
+          mp->stripe_shift = 6; /* should work for CS9000F same as manual */
+        else
+          mp->stripe_shift = 3;
+      }
+      if (s->param->xdpi == 9600)
+      {
+        if (is_scanning_from_tpu (s))
+        {
+          /* need to double up for TPU */
+          mp->stripe_shift = 6; /* for 1st set of 4 images */
+          /* unfortunately there are 2 stripe shifts */
+          mp->stripe_shift2 = 6; /* for 2nd set of 4 images */
+          mp->jumplines = 32; /* try 33 or 34 */
+        }
+        /* there is no 9600dpi support in flatbed mode */
+      }
+      break;
+
+    case MP960_PID:
+      if (s->param->xdpi == 2400)
+      {
+        if (is_scanning_from_tpu (s))
+          mp->stripe_shift = 6;
+        else
+          mp->stripe_shift = 3;
+      }
+      if (s->param->xdpi == 4800)
+      {
+        if (is_scanning_from_tpu (s))
+        {
+          mp->stripe_shift = 6;
+          mp->stripe_shift2 = 6;
+        }
+        else
+        {
+          mp->stripe_shift = 3;
+          mp->stripe_shift2 = 3;
+        }
+        mp->jumplines = 33; /* better than 32 or 34 : applies to flatbed & TPU */
+      }
+      break;
+
+    case MP810_PID:
+      if (s->param->xdpi == 2400)
+      {
+        if (is_scanning_from_tpu (s))
+          mp->stripe_shift = 6;
+        else
+          mp->stripe_shift = 3;
+      }
+      if (s->param->xdpi == 4800)
+      {
+        if (is_scanning_from_tpu (s))
+        {
+          mp->stripe_shift = 6;
+          mp->stripe_shift2 = 6;
+        }
+        else
+        {
+          mp->stripe_shift = 3;
+          mp->stripe_shift2 = 3;
+        }
+        mp->jumplines = 33; /* better than 32 or 34 : applies to flatbed & TPU */
+      }
+      break;
+
+    case MP990_PID:
+      if (s->param->xdpi == 4800)
+      {
+        if (is_scanning_from_tpu (s))
+        {
+          mp->stripe_shift = 6;
+          mp->stripe_shift2 = 6;
+        }
+        else
+        {
+          mp->stripe_shift = 3;
+          mp->stripe_shift2 = 3;
+        }
+        mp->jumplines = 34; /* better than 32 or 34 : applies to flatbed & TPU */
+      }
+      break;
+
+    default: /* Default, and all CIS devices */
+      break;
+  }
+  /* If color plane shift (CCD devices), how many pixels shift */
+  mp->color_shift = mp->shift[0] = mp->shift[1] = mp->shift[2] = 0;
+  if (s->param->ydpi > 75)
+  {
+    switch (s->cfg->pid)
+    {
+      case MP970_PID:
+      case CS8800F_PID: /* CanoScan 8800F */
+        mp->color_shift = s->param->ydpi / 50;
+        mp->shift[1] = mp->color_shift * get_cis_ccd_line_size (s);
+        mp->shift[0] = 0;
+        mp->shift[2] = 2 * mp->shift[1];
+        break;
+
+      case CS9000F_PID: /* CanoScan 9000F */
+      case CS9000F_MII_PID:
+        mp->color_shift = s->param->ydpi / 30;
+        mp->shift[1] = mp->color_shift * get_cis_ccd_line_size (s);
+        mp->shift[0] = 0;
+        mp->shift[2] = 2 * mp->shift[1];
+        break;
+
+      case MP980_PID:
+      case MP990_PID:
+      case MG8200_PID:
+        if (s->param->ydpi > 150)
+        {
+          mp->color_shift = s->param->ydpi / 75;
+          mp->shift[1] = mp->color_shift * get_cis_ccd_line_size (s);
+          mp->shift[0] = 0;
+          mp->shift[2] = 2 * mp->shift[1];
+        }
+        break;
+
+      case MP810_PID:
+      case MP960_PID:
+        mp->color_shift = s->param->ydpi / 50;
+        if (is_scanning_from_tpu (s))
+          mp->color_shift = s->param->ydpi / 50;
+        mp->shift[1] = mp->color_shift * get_cis_ccd_line_size (s);
+        mp->shift[0] = 2 * mp->shift[1];
+        mp->shift[2] = 0;
+        break;
+
+      default:
+        break;
+    }
+  }
+  /* special settings for 16 bit flatbed mode @ 75 dpi
+   * minimum of 150 dpi is used yet */
+  /* else if (!is_scanning_from_tpu (s))
+    {
+      switch (s->cfg->pid)
+      {
+        case CS9000F_PID:
+        case CS9000F_MII_PID:
+          if (is_color_48 (s) || is_gray_16 (s))
+          {
+            mp->color_shift = 5;
+            mp->shift[1] = 0;
+            mp->shift[0] = 0;
+            mp->shift[2] = 0;
+          }
+          break;
+       }
+    } */
+  /* PDBG (pixma_dbg (4, "*calc_shifing***** color_shift = %u, stripe_shift = %u, jumplines = %u  *****\n",
+                   mp->color_shift, mp->stripe_shift, mp->jumplines)); */
+  return (2 * mp->color_shift + mp->stripe_shift + mp->jumplines); /* note impact of stripe shift2 later if needed! */
+}
+
+static int send_scan_param (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  uint8_t *data;
+  unsigned raw_width = calc_raw_width (mp, s->param);
+  unsigned h, h1, h2, shifting;
+
+  /* TPU scan does not support lineart */
+  if (is_scanning_from_tpu (s) && is_lineart (s))
+  {
+    return PIXMA_ENOTSUP;
+  }
+
+  shifting = calc_shifting (s);
+  h1 = s->param->h + shifting; /* add lines for color shifting */
+  /* PDBG (pixma_dbg (4, "* send_scan_param: height calc (choose lesser) 1 %u \n", h1 )); */
+  if (mp->generation >= 4) /* use most global condition */
+  {
+    /* tested for MP960, 9000F */
+    /* add lines for color shifting */
+    /* otherwise you cannot scan all lines defined for flatbed mode */
+    /* this shouldn't affect TPU mode */
+    h2 = s->cfg->height * s->param->ydpi / 75 + shifting;
+    /* PDBG (pixma_dbg (4, "* send_scan_param: height calc (choose lesser) 2 %u = %u max. lines for scanner + %u lines for color shifting \n", h2, s->cfg->height * s->param->ydpi / 75, shifting )); */
+  }
+  else
+  {
+    /* TODO: Check for other scanners. */
+    h2 = s->cfg->height * s->param->ydpi / 75; /* this might be causing problems for generation 1 devices */
+    /* PDBG (pixma_dbg (4, "* send_scan_param: height calc (choose lesser) 2 %u \n", h2 )); */
+  }
+  h = MIN (h1, h2);
+
+  if (mp->generation <= 2)
+  {
+    data = pixma_newcmd (&mp->cb, cmd_scan_param, 0x30, 0);
+    pixma_set_be16 (s->param->xdpi | 0x8000, data + 0x04);
+    pixma_set_be16 (s->param->ydpi | 0x8000, data + 0x06);
+    pixma_set_be32 (s->param->x, data + 0x08);
+    if (mp->generation == 2)
+      pixma_set_be32 (s->param->x - s->param->xs, data + 0x08);
+    pixma_set_be32 (s->param->y, data + 0x0c);
+    pixma_set_be32 (raw_width, data + 0x10);
+    pixma_set_be32 (h, data + 0x14);
+    data[0x18] =
+        ((s->param->channels != 1) || is_gray_all (s) || is_lineart (s)) ?
+            0x08 : 0x04;
+    data[0x19] = ((s->param->software_lineart) ? 8 : s->param->depth)
+                  * ((is_gray_all (s) || is_lineart (s)) ? 3 : s->param->channels); /* bits per pixel */
+    data[0x1a] = (is_scanning_from_tpu (s) ? 1 : 0);
+    data[0x20] = 0xff;
+    data[0x23] = 0x81;
+    data[0x26] = 0x02;
+    data[0x27] = 0x01;
+  }
+  else
+  {
+    /* scan parameters:
+     * ================
+     *
+     * byte | # of  |  mode   | value / description
+     *      | bytes |         |
+     * -----+-------+---------+---------------------------
+     * 0x00 |   1   | default | 0x01
+     *      |       |   adf   | 0x02
+     *      |       |   tpu   | 0x04
+     *      |       |  tpuir  | cs9000f: 0x03
+     * -----+-------+---------+---------------------------
+     * 0x01 |   1   | default | 0x00
+     *      |       |   tpu   | 0x02
+     * -----+-------+---------+---------------------------
+     * 0x02 |   1   | default | 0x01
+     *      |       | adfdup  | 0x03
+     * -----+-------+---------+---------------------------
+     * 0x03 |   1   | default | 0x00
+     *      |       | adfdup  | 0x03
+     * -----+-------+---------+---------------------------
+     * 0x04 |   1   |   all   | 0x00
+     * -----+-------+---------+---------------------------
+     * 0x05 |   1   |   all   | 0x01: This one also seen at 0. Don't know yet what's used for.
+     * -----+-------+---------+---------------------------
+     *  ... |   1   |   all   | 0x00
+     * -----+-------+---------+---------------------------
+     * 0x08 |   2   |   all   | xdpi | 0x8000
+     * -----+-------+---------+---------------------------
+     * 0x0a |   2   |   all   | ydpi | 0x8000: Must be the same as xdpi.
+     * -----+-------+---------+---------------------------
+     * 0x0c |   4   |   all   | x position of start pixel
+     * -----+-------+---------+---------------------------
+     * 0x10 |   4   |   all   | y position of start pixel
+     * -----+-------+---------+---------------------------
+     * 0x14 |   4   |   all   | # of pixels in 1 line
+     * -----+-------+---------+---------------------------
+     * 0x18 |   4   |   all   | # of scan lines
+     * -----+-------+---------+---------------------------
+     * 0x1c |   1   |   all   | 0x08
+     *      |       |         | 0x04 = relict from cis scanners?
+     * -----+-------+---------+---------------------------
+     * 0x1d |   1   |   all   | # of bits per pixel
+     * -----+-------+---------+---------------------------
+     * 0x1e |   1   | default | 0x00: paper
+     *      |       |   tpu   | 0x01: positives
+     *      |       |   tpu   | 0x02: negatives
+     *      |       |  tpuir  | 0x01: positives
+     * -----+-------+---------+---------------------------
+     * 0x1f |   1   |   all   | 0x01
+     *      |       |         | cs9000f: 0x00: Not sure if that is because of positives.
+     * -----+-------+---------+---------------------------
+     * 0x20 |   1   |   all   | 0xff
+     * -----+-------+---------+---------------------------
+     * 0x21 |   1   |   all   | 0x81
+     * -----+-------+---------+---------------------------
+     * 0x22 |   1   |   all   | 0x00
+     * -----+-------+---------+---------------------------
+     * 0x23 |   1   |   all   | 0x02
+     * -----+-------+---------+---------------------------
+     * 0x24 |   1   |   all   | 0x01
+     * -----+-------+---------+---------------------------
+     * 0x25 |   1   | default | 0x00; cs8800f: 0x01
+     *      |       |   tpu   | 0x00; cs9000f, mg8200, mp990: 0x01
+     *      |       |  tpuir  | cs9000f: 0x00
+     * -----+-------+---------+---------------------------
+     *  ... |   1   |   all   | 0x00
+     * -----+-------+---------+---------------------------
+     * 0x30 |   1   |   all   | 0x01
+     *
+     */
+
+    data = pixma_newcmd (&mp->cb, cmd_scan_param_3, 0x38, 0);
+    data[0x00] = is_scanning_from_adf (s) ? 0x02 : 0x01;
+    data[0x01] = 0x01;
+    if (is_scanning_from_tpu (s))
+    {
+      data[0x00] = is_tpuir (s) ? 0x03 : 0x04;
+      data[0x01] = 0x02;
+      data[0x1e] = 0x02; /* NB: CanoScan 8800F: 0x02->negatives, 0x01->positives, paper->0x00 */
+    }
+    data[0x02] = 0x01;
+    if (is_scanning_from_adfdup (s))
+    {
+      data[0x02] = 0x03;
+      data[0x03] = 0x03;
+    }
+    if (s->cfg->pid != MG8200_PID)
+      data[0x05] = 0x01; /* This one also seen at 0. Don't know yet what's used for */
+    /* the scanner controls the scan */
+    /* no software control needed */
+    pixma_set_be16 (s->param->xdpi | 0x8000, data + 0x08);
+    pixma_set_be16 (s->param->ydpi | 0x8000, data + 0x0a);
+    /*PDBG (pixma_dbg (4, "*send_scan_param***** Setting: xdpi=%hi ydpi=%hi  x=%u y=%u  w=%u h=%u ***** \n",
+     s->param->xdpi,s->param->ydpi,(s->param->x)-(s->param->xs),s->param->y,raw_width,h));*/
+    pixma_set_be32 (s->param->x - s->param->xs, data + 0x0c);
+    pixma_set_be32 (s->param->y, data + 0x10);
+    pixma_set_be32 (raw_width, data + 0x14);
+    pixma_set_be32 (h, data + 0x18);
+    data[0x1c] = ((s->param->channels != 1) || is_tpuir (s) || is_gray_all (s) || is_lineart (s)) ? 0x08 : 0x04;
+
+#ifdef DEBUG_TPU_48
+    data[0x1d] = 24;
+#else
+    data[0x1d] = (is_scanning_from_tpu (s)) ? 48
+                                            : (((s->param->software_lineart) ? 8 : s->param->depth)
+                                               * ((is_tpuir (s) || is_gray_all (s) || is_lineart (s)) ? 3 : s->param->channels)); /* bits per pixel */
+#endif
+
+    data[0x1f] = 0x01; /* for 9000F this appears to be 0x00, not sure if that is because of positives */
+
+    if (s->cfg->pid == CS9000F_PID || s->cfg->pid == CS9000F_MII_PID || s->cfg->pid == MG8200_PID)
+    {
+      data[0x1f] = 0x00;
+    }
+
+    data[0x20] = 0xff;
+    data[0x21] = 0x81;
+    data[0x23] = 0x02;
+    data[0x24] = 0x01;
+
+    /* MG8200 & MP990 addition */
+    if (s->cfg->pid == MG8200_PID || s->cfg->pid == MP990_PID)
+    {
+      if (is_scanning_from_tpu (s))
+      {
+        data[0x25] = 0x01;
+      }
+    }
+
+    /* CS8800F & CS9000F addition */
+    if (s->cfg->pid == CS8800F_PID || s->cfg->pid == CS9000F_PID || s->cfg->pid == CS9000F_MII_PID)
+    {
+      if (is_scanning_from_tpu (s))
+      { /* TPU */
+        /* 0x02->negatives, 0x01->positives, paper->0x00
+         * no paper in TPU mode */
+        if (s->param->mode == PIXMA_SCAN_MODE_NEGATIVE_COLOR
+            || s->param->mode == PIXMA_SCAN_MODE_NEGATIVE_GRAY)
+        {
+          PDBG(
+              pixma_dbg (4, "*send_scan_param***** TPU scan negatives *****\n"));
+          data[0x1e] = 0x02;
+        }
+        else
+        {
+          PDBG(
+              pixma_dbg (4, "*send_scan_param***** TPU scan positives *****\n"));
+          data[0x1e] = 0x01;
+        }
+        /* CS8800F: 0x00 for TPU color management */
+        if (s->cfg->pid == CS8800F_PID)
+          data[0x25] = 0x00;
+        /* CS9000F: 0x01 for TPU */
+        if (s->cfg->pid == CS9000F_PID || s->cfg->pid == CS9000F_MII_PID)
+          data[0x25] = 0x01;
+        if (s->param->mode == PIXMA_SCAN_MODE_TPUIR)
+          data[0x25] = 0x00;
+      }
+      else
+      { /* flatbed and ADF */
+        /* paper->0x00 */
+        data[0x1e] = 0x00;
+        /* CS8800F: 0x01 normally */
+        if (s->cfg->pid == CS8800F_PID)
+          data[0x25] = 0x01;
+        /* CS9000F: 0x00 normally */
+        if (s->cfg->pid == CS9000F_PID || s->cfg->pid == CS9000F_MII_PID)
+          data[0x25] = 0x00;
+      }
+    }
+
+    data[0x30] = 0x01;
+  }
+  return pixma_exec (s, &mp->cb);
+}
+
+static int query_status_3 (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  uint8_t *data;
+  int error, status_len;
+
+  status_len = 8;
+  data = pixma_newcmd (&mp->cb, cmd_status_3, 0, status_len);
+  RET_IF_ERR(pixma_exec (s, &mp->cb));
+  memcpy (mp->current_status, data, status_len);
+  return error;
+}
+
+static int query_status (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  uint8_t *data;
+  int error, status_len;
+
+  status_len = (mp->generation == 1) ? 12 : 16;
+  data = pixma_newcmd (&mp->cb, cmd_status, 0, status_len);
+  RET_IF_ERR(pixma_exec (s, &mp->cb));
+  memcpy (mp->current_status, data, status_len);
+  PDBG(
+      pixma_dbg (3, "Current status: paper=%u cal=%u lamp=%u busy=%u\n", data[1], data[8], data[7], data[9]));
+  return error;
+}
+
+#if 0
+static int send_time (pixma_t * s)
+{
+  /* Why does a scanner need a time? */
+  time_t now;
+  struct tm *t;
+  uint8_t *data;
+  mp810_t *mp = (mp810_t *) s->subdriver;
+
+  data = pixma_newcmd (&mp->cb, cmd_time, 20, 0);
+  pixma_get_time (&now, NULL);
+  t = localtime (&now);
+  strftime ((char *) data, 16, "%y/%m/%d %H:%M", t);
+  PDBG(pixma_dbg (3, "Sending time: '%s'\n", (char *) data));
+  return pixma_exec (s, &mp->cb);
+}
+#endif
+
+/* TODO: Simplify this function. Read the whole data packet in one shot. */
+static int read_image_block (pixma_t * s, uint8_t * header, uint8_t * data)
+{
+  uint8_t cmd[16];
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  const int hlen = 8 + 8;
+  int error, datalen;
+
+  memset (cmd, 0, sizeof(cmd));
+  /* PDBG (pixma_dbg (4, "* read_image_block: last_block\n", mp->last_block)); */
+  pixma_set_be16 (cmd_read_image, cmd);
+  if ((mp->last_block & 0x20) == 0)
+    pixma_set_be32 ((IMAGE_BLOCK_SIZE / 65536) * 65536 + 8, cmd + 0xc);
+  else
+    pixma_set_be32 (32 + 8, cmd + 0xc);
+
+  mp->state = state_transfering;
+  mp->cb.reslen = pixma_cmd_transaction (s, cmd, sizeof(cmd), mp->cb.buf, 512); /* read 1st 512 bytes of image block */
+  datalen = mp->cb.reslen;
+  if (datalen < 0)
+    return datalen;
+
+  memcpy (header, mp->cb.buf, hlen);
+  /* PDBG (pixma_dbg (4, "* read_image_block: datalen %i\n", datalen)); */
+  /* PDBG (pixma_dbg (4, "* read_image_block: hlen %i\n", hlen)); */
+  if (datalen >= hlen)
+  {
+    datalen -= hlen;
+    memcpy (data, mp->cb.buf + hlen, datalen);
+    data += datalen;
+    if (mp->cb.reslen == 512)
+    { /* read the rest of the image block */
+      error = pixma_read (s->io, data, IMAGE_BLOCK_SIZE - 512 + hlen);
+      RET_IF_ERR(error);
+      datalen += error;
+    }
+  }
+
+  mp->state = state_scanning;
+  mp->cb.expected_reslen = 0;
+  RET_IF_ERR(pixma_check_result (&mp->cb));
+  if (mp->cb.reslen < hlen)
+    return PIXMA_EPROTO;
+  return datalen;
+}
+
+static int read_error_info (pixma_t * s, void *buf, unsigned size)
+{
+  unsigned len = 16;
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  uint8_t *data;
+  int error;
+
+  data = pixma_newcmd (&mp->cb, cmd_error_info, 0, len);
+  RET_IF_ERR(pixma_exec (s, &mp->cb));
+  if (buf && len < size)
+  {
+    size = len;
+    /* NOTE: I've absolutely no idea what the returned data mean. */
+    memcpy (buf, data, size);
+    error = len;
+  }
+  return error;
+}
+
+/*
+ handle_interrupt() waits until it receives an interrupt packet or times out.
+ It calls send_time() and query_status() if necessary. Therefore, make sure
+ that handle_interrupt() is only called from a safe context for send_time()
+ and query_status().
+
+ Returns:
+ 0     timed out
+ 1     an interrupt packet received
+ PIXMA_ECANCELED interrupted by signal
+ <0    error
+ */
+static int handle_interrupt (pixma_t * s, int timeout)
+{
+  uint8_t buf[64];      /* check max. packet size with 'lsusb -v' for "EP 9 IN" */
+  int len;
+
+  len = pixma_wait_interrupt (s->io, buf, sizeof(buf), timeout);
+  if (len == PIXMA_ETIMEDOUT)
+    return 0;
+  if (len < 0)
+    return len;
+  if (len%16)           /* len must be a multiple of 16 bytes */
+  {
+    PDBG(pixma_dbg (1, "WARNING:unexpected interrupt packet length %d\n", len));
+    return PIXMA_EPROTO;
+  }
+
+  /* s->event = 0x0brroott
+   * b:  button
+   * oo: original
+   * tt: target
+   * rr: scan resolution
+   * poll event with 'scanimage -A' */
+  if (s->cfg->pid == MG8200_PID)
+  /* button no. in buf[7]
+   * size in buf[10] 01=A4; 02=Letter; 08=10x15; 09=13x18; 0b=auto
+   * format in buf[11] 01=JPEG; 02=TIFF; 03=PDF; 04=Kompakt-PDF
+   * dpi in buf[12] 01=75; 02=150; 03=300; 04=600
+   * target = format; original = size; scan-resolution = dpi */
+  {
+    if (buf[7] & 1)
+      s->events = PIXMA_EV_BUTTON1 | buf[11] | buf[10]<<8 | buf[12]<<16;    /* color scan */
+    if (buf[7] & 2)
+      s->events = PIXMA_EV_BUTTON2 | buf[11] | buf[10]<<8 | buf[12]<<16;    /* b/w scan */
+  }
+  else if (s->cfg->pid == CS8800F_PID
+            || s->cfg->pid == CS9000F_PID
+            || s->cfg->pid == CS9000F_MII_PID)
+  /* button no. in buf[1]
+   * target = button no.
+   * "Finish PDF" is Button-2, all others are Button-1 */
+  {
+    if ((s->cfg->pid == CS8800F_PID && buf[1] == 0x70)
+        || (s->cfg->pid != CS8800F_PID && buf[1] == 0x50))
+      s->events = PIXMA_EV_BUTTON2 | buf[1] >> 4;  /* button 2 = cancel / end scan */
+    else
+      s->events = PIXMA_EV_BUTTON1 | buf[1] >> 4;  /* button 1 = start scan */
+  }
+  else
+  /* button no. in buf[0]
+   * original in buf[0]
+   * target in buf[1] */
+  {
+    /* More than one event can be reported at the same time. */
+    if (buf[3] & 1)
+      /* FIXME: This function makes trouble with a lot of scanners
+      send_time (s);
+       */
+      PDBG (pixma_dbg (1, "WARNING:send_time() disabled!\n"));
+    if (buf[9] & 2)
+      query_status (s);
+
+    if (buf[0] & 2)
+      s->events = PIXMA_EV_BUTTON2 | buf[1] | ((buf[0] & 0xf0) << 4); /* b/w scan */
+    if (buf[0] & 1)
+      s->events = PIXMA_EV_BUTTON1 | buf[1] | ((buf[0] & 0xf0) << 4); /* color scan */
+  }
+  return 1;
+}
+
+static int init_ccd_lamp_3 (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  uint8_t *data;
+  int error, status_len, tmo;
+
+  status_len = 8;
+  RET_IF_ERR(query_status (s));
+  RET_IF_ERR(query_status (s));
+  RET_IF_ERR(send_cmd_start_calibrate_ccd_3 (s));
+  RET_IF_ERR(query_status (s));
+  tmo = 20; /* like Windows driver, CCD lamp adjustment */
+  while (--tmo >= 0)
+  {
+    data = pixma_newcmd (&mp->cb, cmd_end_calibrate_ccd_3, 0, status_len);
+    RET_IF_ERR(pixma_exec (s, &mp->cb));
+    memcpy (mp->current_status, data, status_len);
+    PDBG(pixma_dbg (3, "Lamp status: %u , timeout in: %u\n", data[0], tmo));
+    if (mp->current_status[0] == 3 || !is_scanning_from_tpu (s))
+      break;
+    WAIT_INTERRUPT(1000);
+  }
+  return error;
+}
+
+static int wait_until_ready (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  int error, tmo = 60;
+
+  RET_IF_ERR((mp->generation >= 3) ? query_status_3 (s) : query_status (s));
+  while (!is_calibrated (s))
+  {
+    WAIT_INTERRUPT(1000);
+    if (mp->generation >= 3)
+      RET_IF_ERR(query_status_3 (s));
+    else if (s->cfg->pid == MP800R_PID)
+      RET_IF_ERR (query_status (s));
+    if (--tmo == 0)
+    {
+      PDBG(pixma_dbg (1, "WARNING: Timed out in wait_until_ready()\n"));
+      PDBG(query_status (s));
+      return PIXMA_ETIMEDOUT;
+    }
+  }
+  return 0;
+}
+
+/* the RGB images are shifted by # of lines              */
+/* the R image is shifted by colshift[0]                 */
+/* the G image is shifted by colshift[1]                 */
+/* the B image is shifted by colshift[2]                 */
+/* usually one of the RGB images must not be shifted     */
+/* which one depends on the scanner                      */
+/* some scanners have an additional stripe shift         */
+/* e.g. colshift[0]=0, colshift[1]=1, colshift[2]=2      */
+/* R image is OK: RGBRGBRGB...                           */
+/*                 ^^ ^^ ^^                              */
+/*                 || || ||                              */
+/* shift G image: RG|RG|RG|...                           */
+/*                  |  |  |                              */
+/* shift B image: RGBRGBRGB...                           */
+/* this doesn't affect the G and B images                */
+/* G image will become the R image in the next run       */
+/* B image will become the G image in the next run       */
+/* the next line will become the B image in the next run */
+static uint8_t *
+shift_colors (uint8_t * dptr, uint8_t * sptr, unsigned w, unsigned dpi,
+              unsigned pid, unsigned c, int * colshft, unsigned strshft)
+{
+  unsigned i, sr, sg, sb, st;
+  UNUSED(dpi);
+  UNUSED(pid);
+  sr = colshft[0];
+  sg = colshft[1];
+  sb = colshft[2];
+
+  /* PDBG (pixma_dbg (4, "*shift_colors***** c=%u, w=%i, sr=%u, sg=%u, sb=%u, strshft=%u ***** \n",
+        c, w, sr, sg, sb, strshft)); */
+
+  for (i = 0; i < w; i++)
+  {
+    /* stripes shift for MP970 at 4800 dpi, MP810 at 2400 dpi */
+    st = (i % 2 == 0) ? strshft : 0;
+
+    *sptr++ = *(dptr++ + sr + st);
+    if (c == 6)
+      *sptr++ = *(dptr++ + sr + st);
+    *sptr++ = *(dptr++ + sg + st);
+    if (c == 6)
+      *sptr++ = *(dptr++ + sg + st);
+    *sptr++ = *(dptr++ + sb + st);
+    if (c == 6)
+      *sptr++ = *(dptr++ + sb + st);
+  }
+
+  return dptr;
+}
+
+static uint8_t *
+shift_colorsCS9000 (uint8_t * dptr, uint8_t * sptr, unsigned w, unsigned dpi,
+                    unsigned pid, unsigned c, int * colshft, unsigned strshft,
+                    unsigned strshft2, unsigned jump)
+
+{
+  unsigned i, sr, sg, sb, st, st2;
+  UNUSED(dpi);
+  UNUSED(pid);
+  sr = colshft[0];
+  sg = colshft[1];
+  sb = colshft[2];
+
+  for (i = 0; i < w; i++)
+  {
+    if (i < (w / 2))
+    {
+      /* stripes shift for 1st 4 images for Canoscan 9000F at 9600dpi */
+      st = (i % 2 == 0) ? strshft : 0;
+      *sptr++ = *(dptr++ + sr + st);
+      if (c == 6)
+        *sptr++ = *(dptr++ + sr + st);
+      *sptr++ = *(dptr++ + sg + st);
+      if (c == 6)
+        *sptr++ = *(dptr++ + sg + st);
+      *sptr++ = *(dptr++ + sb + st);
+      if (c == 6)
+        *sptr++ = *(dptr++ + sb + st);
+    }
+    if (i >= (w / 2))
+    {
+      /* stripes shift for 2nd 4 images for Canoscan 9000F at 9600dpi */
+      st2 = (i % 2 == 0) ? strshft2 : 0;
+      *sptr++ = *(dptr++ + sr + jump + st2);
+      if (c == 6)
+        *sptr++ = *(dptr++ + sr + jump + st2);
+      *sptr++ = *(dptr++ + sg + jump + st2);
+      if (c == 6)
+        *sptr++ = *(dptr++ + sg + jump + st2);
+      *sptr++ = *(dptr++ + sb + jump + st2);
+      if (c == 6)
+        *sptr++ = *(dptr++ + sb + jump + st2);
+    }
+  }
+  return dptr;
+}
+
+static uint8_t *
+shift_colorsCS9000_4800 (uint8_t * dptr, uint8_t * sptr, unsigned w,
+                         unsigned dpi, unsigned pid, unsigned c, int * colshft,
+                         unsigned strshft, unsigned strshft2, unsigned jump)
+
+{
+  unsigned i, sr, sg, sb, st2;
+  UNUSED(dpi);
+  UNUSED(pid);
+  UNUSED(strshft);
+  sr = colshft[0];
+  sg = colshft[1];
+  sb = colshft[2];
+
+  for (i = 0; i < w; i++)
+  {
+    /* stripes shift for 2nd 4 images
+     * for Canoscan 9000F with 16 bit flatbed scans at 4800dpi */
+    st2 = (i % 2 == 0) ? strshft2 : 0;
+    *sptr++ = *(dptr++ + sr + jump + st2);
+    if (c == 6)
+      *sptr++ = *(dptr++ + sr + jump + st2);
+    *sptr++ = *(dptr++ + sg + jump + st2);
+    if (c == 6)
+      *sptr++ = *(dptr++ + sg + jump + st2);
+    *sptr++ = *(dptr++ + sb + jump + st2);
+    if (c == 6)
+      *sptr++ = *(dptr++ + sb + jump + st2);
+  }
+  return dptr;
+}
+
+/* under some conditions some scanners have sub images in one line */
+/* e.g. doubled image, line size = 8				   */
+/* line before reordering: px1 px3 px5 px7 px2 px4 px6 px8         */
+/* line after reordering:  px1 px2 px3 px4 px5 px6 px7 px8         */
+static void reorder_pixels (uint8_t * linebuf, uint8_t * sptr, unsigned c,
+                            unsigned n, unsigned m, unsigned w,
+                            unsigned line_size)
+{
+  unsigned i;
+
+  for (i = 0; i < w; i++)
+  { /* process complete line */
+    memcpy (linebuf + c * (n * (i % m) + i / m), sptr + c * i, c);
+  }
+  memcpy (sptr, linebuf, line_size);
+}
+
+/* special reorder matrix for mp960 */
+static void mp960_reorder_pixels (uint8_t * linebuf, uint8_t * sptr, unsigned c,
+                                      unsigned n, unsigned m, unsigned w,
+                                      unsigned line_size)
+{
+  unsigned i, i2;
+
+  /* try and copy 2 px at once */
+  for (i = 0; i < w; i++)
+  { /* process complete line */
+    i2 = i % 2;
+    if (i < w / 2)
+    {
+      if (i2 == 0)
+        memcpy (linebuf + c * (n * ((i) % m) + ((i) / m)), sptr + c * i, c);
+      else
+        memcpy (linebuf + c * (n * ((i - 1) % m) + 1 + ((i) / m)), sptr + c * i, c);
+    }
+    else
+    {
+      if (i2 == 0)
+        memcpy (linebuf + c * (n * ((i) % m) + ((i) / m) + 1), sptr + c * i, c);
+      else
+        memcpy (linebuf + c * (n * ((i - 1) % m) + 1 + ((i) / m) + 1), sptr + c * i, c);
+    }
+  }
+
+  memcpy (sptr, linebuf, line_size);
+}
+
+/* special reorder matrix for mp970 */
+static void mp970_reorder_pixels (uint8_t * linebuf, uint8_t * sptr, unsigned c,
+                                      unsigned w, unsigned line_size)
+{
+  unsigned i, i8;
+
+  for (i = 0; i < w; i++)
+  { /* process complete line */
+    i8 = i % 8;
+    memcpy (linebuf + c * (i + i8 - ((i8 > 3) ? 7 : 0)), sptr + c * i, c);
+  }
+  memcpy (sptr, linebuf, line_size);
+}
+
+/* special reorder matrix for CS9000F */
+static void cs9000f_initial_reorder_pixels (uint8_t * linebuf, uint8_t * sptr,
+                                                 unsigned c, unsigned n, unsigned m,
+                                                 unsigned w, unsigned line_size)
+{
+  unsigned i, i2;
+
+  /* try and copy 2 px at once */
+  for (i = 0; i < w; i++)
+  { /* process complete line */
+    i2 = i % 2;
+    if (i < w / 8)
+    {
+      if (i2 == 0)
+        memcpy (linebuf + c * (n * ((i) % m) + ((i) / m)), sptr + c * i, c);
+      else
+        memcpy (linebuf + c * (n * ((i - 1) % m) + 1 + ((i) / m)), sptr + c * i, c);
+    }
+    else if (i >= w / 8 && i < w / 4)
+    {
+      if (i2 == 0)
+        memcpy (linebuf + c * (n * ((i) % m) + ((i) / m) + 1), sptr + c * i, c);
+      else
+        memcpy (linebuf + c * (n * ((i - 1) % m) + 1 + ((i) / m) + 1), sptr + c * i, c);
+    }
+    else if (i >= w / 4 && i < 3 * w / 8)
+    {
+      if (i2 == 0)
+        memcpy (linebuf + c * (n * ((i) % m) + ((i) / m) + 2), sptr + c * i, c);
+      else
+        memcpy (linebuf + c * (n * ((i - 1) % m) + 1 + ((i) / m) + 2), sptr + c * i, c);
+    }
+    else if (i >= 3 * w / 8 && i < w / 2)
+    {
+      if (i2 == 0)
+        memcpy (linebuf + c * (n * ((i) % m) + ((i) / m) + 3), sptr + c * i, c);
+      else
+        memcpy (linebuf + c * (n * ((i - 1) % m) + 1 + ((i) / m) + 3), sptr + c * i, c);
+    }
+    else if (i >= w / 2 && i < 5 * w / 8)
+    {
+      if (i2 == 0)
+        memcpy (linebuf + c * (n * ((i) % m) + ((i) / m) + 4), sptr + c * i, c);
+      else
+        memcpy (linebuf + c * (n * ((i - 1) % m) + 1 + ((i) / m) + 4), sptr + c * i, c);
+    }
+    else if (i >= 5 * w / 8 && i < 3 * w / 4)
+    {
+      if (i2 == 0)
+        memcpy (linebuf + c * (n * ((i) % m) + ((i) / m) + 5), sptr + c * i, c);
+      else
+        memcpy (linebuf + c * (n * ((i - 1) % m) + 1 + ((i) / m) + 5), sptr + c * i, c);
+    }
+    else if (i >= 3 * w / 4 && i < 7 * w / 8)
+    {
+      if (i2 == 0)
+        memcpy (linebuf + c * (n * ((i) % m) + ((i) / m) + 6), sptr + c * i, c);
+      else
+        memcpy (linebuf + c * (n * ((i - 1) % m) + 1 + ((i) / m) + 6), sptr + c * i, c);
+    }
+    else
+    {
+      if (i2 == 0)
+        memcpy (linebuf + c * (n * ((i) % m) + ((i) / m) + 7), sptr + c * i, c);
+      else
+        memcpy (linebuf + c * (n * ((i - 1) % m) + 1 + ((i) / m) + 7), sptr + c * i, c);
+    }
+  }
+
+  memcpy (sptr, linebuf, line_size);
+}
+
+/* CS9000F 9600dpi reorder: actually 4800dpi since each pixel is doubled      */
+/* need to rearrange each sequence of 16 pairs of pixels as follows:          */
+/* start px : 0   2   4   6   8   10  12  14  16  18  20  22  24  26  28  30  */
+/* before   : p1a p1b p1c p1d p2a p2b p2c p2d p3a p3b p3c p3d p4a p4b p4c p4d */
+/* after    : p1a p3a p1b p3b p1c p3c p1d p3d p2a p4a p2b p4b p2c p4c p2d p4d */
+/* start px : 0   16  2   18  4   20  6   22  8   24  10  26  12  28  14  30  */
+/* change   :      *   *   *   *   *   *   *   *   *   *   *   *   *   *      */
+/* no change:  *                                                           *  */
+/* so the 1st and the 3rd set are interleaved, followed by the 2nd and 4th sets interleaved */
+static void cs9000f_second_reorder_pixels (uint8_t * linebuf, uint8_t * sptr,
+                                                unsigned c, unsigned w,
+                                                unsigned line_size)
+{
+  unsigned i, i8;
+  static const int shifts[8] =
+  { 2, 4, 6, 8, -8, -6, -4, -2 };
+
+  for (i = 0; i < w; i += 2)
+  { /* process complete line */
+    i8 = (i >> 1) & 0x7;
+    /* Copy 2 pixels at once */
+    memcpy (linebuf + c * (i + shifts[i8]), sptr + c * i, c * 2);
+  }
+
+  memcpy (sptr, linebuf, line_size);
+}
+
+#ifndef TPU_48
+static unsigned
+pack_48_24_bpc (uint8_t * sptr, unsigned n)
+{
+  unsigned i;
+  uint8_t *cptr, lsb;
+  static uint8_t offset = 0;
+
+  cptr = sptr;
+  if (n % 2 != 0)
+  PDBG (pixma_dbg (3, "WARNING: misaligned image.\n"));
+  for (i = 0; i < n; i += 2)
+  {
+    /* offset = 1 + (offset % 3); */
+    lsb = *sptr++;
+    *cptr++ = ((*sptr++) << offset) | lsb >> (8 - offset);
+  }
+  return (n / 2);
+}
+#endif
+
+/* This function deals both with PIXMA CCD sensors producing shifted color
+ * planes images, Grayscale CCD scan and Generation >= 3 high dpi images.
+ * Each complete line in mp->imgbuf is processed for shifting CCD sensor
+ * color planes, reordering pixels above 600 dpi for Generation >= 3, and
+ * converting to Grayscale for CCD sensors. */
+static unsigned post_process_image_data (pixma_t * s, pixma_imagebuf_t * ib)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  unsigned c, lines, line_size, n, m, cw, cx, reducelines;
+  uint8_t *sptr, *dptr, *gptr, *cptr;
+  unsigned /*color_shift, stripe_shift, stripe_shift2,*/ jumplines /*, height*/;
+  int test;
+
+  /* For testers: */
+  /* set this to 1 in order to get unprocessed images next to one another at 9600dpi */
+  /* other resolutions should not be affected */
+  /* set this to 2 if you want to see the same with jumplines=0 */
+  test = 0;
+  jumplines = 0;
+
+  c = ((is_tpuir (s) || is_gray_all (s) || is_lineart (s)) ? 3 : s->param->channels)
+      * ((s->param->software_lineart) ? 8 : s->param->depth) / 8;
+  cw = c * s->param->w;
+  cx = c * s->param->xs;
+
+  /* PDBG (pixma_dbg (4, "*post_process_image_data***** c = %u, cw = %u, cx = %u  *****\n", c, cw, cx)); */
+
+  if (mp->generation >= 3)
+    n = s->param->xdpi / 600;
+  else
+    /* FIXME: maybe need different values for CIS and CCD sensors */
+    n = s->param->xdpi / 2400;
+
+  /* Some exceptions to global rules here */
+  if (s->cfg->pid == MP970_PID || s->cfg->pid == MP990_PID || s->cfg->pid == MG8200_PID
+      || s->cfg->pid == CS8800F_PID || s->cfg->pid == CS9000F_PID || s->cfg->pid == CS9000F_MII_PID)
+    n = MIN (n, 4);
+
+  /* exception for 9600dpi on Canoscan 9000F */
+  if ((s->cfg->pid == CS9000F_PID || s->cfg->pid == CS9000F_MII_PID) && (s->param->xdpi == 9600))
+  {
+    n = 8;
+    if (test > 0)
+      n = 1; /* test if 8 images are next to one another */
+  }
+
+  /* test if 2 images are next to one another */
+  if ((s->cfg->pid == MP960_PID) && (s->param->xdpi == 4800) && (test > 0))
+  {
+    n = 1;
+  }
+
+  m = (n > 0) ? s->param->wx / n : 1;
+
+  sptr = dptr = gptr = cptr = mp->imgbuf;
+  line_size = get_cis_ccd_line_size (s);
+  /* PDBG (pixma_dbg (4, "*post_process_image_data***** ----- Set n=%u, m=%u, line_size=%u ----- ***** \n", n, m, line_size)); */
+  /* PDBG (pixma_dbg (4, "*post_process_image_data***** ----- spr=dpr=%u, linebuf=%u ----- ***** \n", sptr, mp->linebuf)); */
+
+  lines = (mp->data_left_ofs - mp->imgbuf) / line_size;
+  /* PDBG (pixma_dbg (4, "*post_process_image_data***** lines = %i > 2 * mp->color_shift + mp->stripe_shift = %i ***** \n",
+               lines, 2 * mp->color_shift + mp->stripe_shift)); */
+  /* PDBG (pixma_dbg (4, "*post_process_image_data***** mp->color_shift = %u, mp->stripe_shift = %u, , mp->stripe_shift2 = %u ***** \n",
+               mp->color_shift, mp->stripe_shift, mp->stripe_shift2)); */
+
+  /*color_shift = mp->color_shift;*/
+  /*stripe_shift = mp->stripe_shift;*/
+  /*stripe_shift2 = mp->stripe_shift2;*/
+  jumplines = mp->jumplines;
+
+  /* height not needed here! */
+  /* removed to avoid confusion */
+  /* height = MIN (s->param->h + calc_shifting (s),
+                    s->cfg->height * s->param->ydpi / 75); */
+
+  /* have to test if rounding down is OK or not -- currently 0.5 lines is rounded down */
+  /* note stripe shifts doubled already in definitions */
+  if ((s->cfg->pid == CS9000F_PID || s->cfg->pid == CS9000F_MII_PID) && (s->param->xdpi == 9600) && (test > 0))
+  {
+    /* using test==2 you can check in GIMP the required offset, and
+       use the below line (uncommented) and replace XXX with that
+       number, and then compile again with test set to 1. */
+
+    jumplines = 32;
+    if (test == 2)
+      jumplines = 0;
+  }
+
+  /* mp960 test */
+  if ((s->cfg->pid == MP960_PID) && (s->param->xdpi == 4800) && (test > 0))
+  {
+    jumplines = 32;
+    if (test == 2)
+      jumplines = 0;
+  }
+
+  reducelines = ((2 * mp->color_shift + mp->stripe_shift) + jumplines);
+  /* PDBG (pixma_dbg (4, "*post_process_image_data: lines %u, reducelines %u \n", lines, reducelines)); */
+  if (lines > reducelines)
+  { /* (line - reducelines) of image lines can be converted */
+    unsigned i;
+
+    lines -= reducelines;
+
+    for (i = 0; i < lines; i++, sptr += line_size)
+    { /* convert only full image lines */
+      /* Color plane and stripes shift needed by e.g. CCD */
+      /* PDBG (pixma_dbg (4, "*post_process_image_data***** Processing with c=%u, n=%u, m=%u, w=%i, line_size=%u ***** \n",
+       c, n, m, s->param->wx, line_size)); */
+      if (c >= 3)
+      {
+        if (((s->cfg->pid == CS9000F_PID || s->cfg->pid == CS9000F_MII_PID) && (s->param->xdpi == 9600))
+            || ((s->cfg->pid == MP960_PID) && (s->param->xdpi == 4800))
+            || ((s->cfg->pid == MP810_PID) && (s->param->xdpi == 4800)))
+        {
+          dptr = shift_colorsCS9000 (dptr, sptr, s->param->wx, s->param->xdpi,
+                                     s->cfg->pid, c, mp->shift,
+                                     mp->stripe_shift, mp->stripe_shift2,
+                                     jumplines * line_size);
+        }
+
+        else if ((s->cfg->pid == CS9000F_PID || s->cfg->pid == CS9000F_MII_PID) /* 9000F: 16 bit flatbed scan at 4800dpi */
+                  && ((s->param->mode == PIXMA_SCAN_MODE_COLOR_48)
+                      || (s->param->mode == PIXMA_SCAN_MODE_GRAY_16))
+                  && (s->param->xdpi == 4800)
+                  && (s->param->source == PIXMA_SOURCE_FLATBED))
+          dptr = shift_colorsCS9000_4800 (dptr, sptr, s->param->wx,
+                                          s->param->xdpi, s->cfg->pid, c,
+                                          mp->shift, mp->stripe_shift,
+                                          mp->stripe_shift2,
+                                          jumplines * line_size);
+
+        else
+          /* all except 9000F at 9600dpi */
+          dptr = shift_colors (dptr, sptr, s->param->wx, s->param->xdpi,
+                               s->cfg->pid, c, mp->shift, mp->stripe_shift);
+      }
+
+      /*PDBG (pixma_dbg (4, "*post_process_image_data***** test = %i  *****\n", test)); */
+
+      /*--comment out all between this line and the one below for 9000F tests at 9600dpi or MP960 at 4800dpi ------*/
+      /* if ( 0 ) */
+      if ((((s->cfg->pid != CS9000F_PID && s->cfg->pid != CS9000F_MII_PID) || (s->param->xdpi < 9600))
+          && ((s->cfg->pid != MP960_PID) || (s->param->xdpi < 4800))
+          && ((s->cfg->pid != MP810_PID) || (s->param->xdpi < 4800)))
+          || (test == 0))
+      {
+        /* PDBG (pixma_dbg (4, "*post_process_image_data***** MUST GET HERE WHEN TEST == 0  *****\n")); */
+
+        if (!((s->cfg->pid == MP810_PID) && (s->param->xdpi == 4800))
+            && !((s->cfg->pid == MP960_PID) && (s->param->xdpi == 4800))
+            && !((s->cfg->pid == CS9000F_PID || s->cfg->pid == CS9000F_MII_PID) && (s->param->xdpi == 9600)))
+        { /* for both flatbed & TPU */
+          /* PDBG (pixma_dbg (4, "*post_process_image_data***** reordering pixels normal n = %i  *****\n", n)); */
+          reorder_pixels (mp->linebuf, sptr, c, n, m, s->param->wx, line_size);
+        }
+
+        if ((s->cfg->pid == CS9000F_PID || s->cfg->pid == CS9000F_MII_PID) && (s->param->xdpi == 9600))
+        {
+          /* PDBG (pixma_dbg (4, "*post_process_image_data***** cs900f_initial_reorder_pixels n = %i  *****\n", n)); */
+          /* this combines pixels from 8 images 2px at a time from left to right: 1122334455667788... */
+          cs9000f_initial_reorder_pixels (mp->linebuf, sptr, c, n, m,
+                                          s->param->wx, line_size);
+          /* final interleaving */
+          cs9000f_second_reorder_pixels (mp->linebuf, sptr, c, s->param->wx,
+                                         line_size);
+        }
+
+        /* comment: special image format for MP960 in flatbed mode
+         at 4800dpi. It is actually 2400dpi, with each pixel
+         doubled. The TPU mode has proper pixel ordering */
+        if ((((s->cfg->pid == MP960_PID) || (s->cfg->pid == MP810_PID)) && (s->param->xdpi == 4800))
+            && (n > 0))
+        {
+          /* for both flatbed & TPU */
+          /* PDBG (pixma_dbg (4, "*post_process_image_data***** flatbed mp960_reordering pixels n = %i  *****\n", n)); */
+          mp960_reorder_pixels (mp->linebuf, sptr, c, n, m, s->param->wx,
+                                line_size);
+        }
+
+        /* comment: MP970, CS8800F, CS9000F specific reordering for 4800 dpi */
+        if ((s->cfg->pid == MP970_PID || s->cfg->pid == CS8800F_PID
+            || s->cfg->pid == CS9000F_PID || s->cfg->pid == CS9000F_MII_PID
+            || s->cfg->pid == MP990_PID) && (s->param->xdpi == 4800))
+        {
+          /*PDBG (pixma_dbg (4, "*post_process_image_data***** mp970_reordering pixels n = %i  *****\n", n)); */
+          mp970_reorder_pixels (mp->linebuf, sptr, c, s->param->wx, line_size);
+        }
+
+      }
+      /*-------------------------------------------------------*/
+
+      /* PDBG (pixma_dbg (4, "*post_process_image_data: sptr=%u, dptr=%u \n", sptr, dptr)); */
+
+      /* Crop line to selected borders */
+      memmove (cptr, sptr + cx, cw);
+      /* PDBG (pixma_dbg (4, "*post_process_image_data***** crop line: cx=%u, cw=%u ***** \n", cx, cw)); */
+
+      /* Color to Lineart convert for CCD sensor */
+      if (is_lineart (s))
+        cptr = gptr = pixma_binarize_line (s->param, gptr, cptr, s->param->w, c);
+#ifndef TPUIR_USE_RGB
+      /* save IR only for CCD sensor */
+      else if (is_tpuir (s))
+        cptr = gptr = pixma_r_to_ir (gptr, cptr, s->param->w, c);
+      /* Color to Grayscale convert for CCD sensor */
+      else if (is_gray_all (s))
+#else
+      /* IR *and* Color to Grayscale convert for CCD sensor */
+      else if (is_tpuir (s) || is_gray_all (s))
+#endif
+        cptr = gptr = pixma_rgb_to_gray (gptr, cptr, s->param->w, c);
+      else
+        cptr += cw;
+    }
+    /* PDBG (pixma_dbg (4, "*post_process_image_data: sptr=%u, dptr=%u \n", sptr, dptr)); */
+  }
+  ib->rptr = mp->imgbuf;
+  ib->rend = cptr;
+  return mp->data_left_ofs - sptr; /* # of non processed bytes */
+  /* contains shift color data for new lines */
+  /* and already received data for the next line */
+}
+
+static int mp810_open (pixma_t * s)
+{
+  mp810_t *mp;
+  uint8_t *buf;
+
+  mp = (mp810_t *) calloc (1, sizeof(*mp));
+  if (!mp)
+    return PIXMA_ENOMEM;
+
+  buf = (uint8_t *) malloc (CMDBUF_SIZE + IMAGE_BLOCK_SIZE);
+  if (!buf)
+  {
+    free (mp);
+    return PIXMA_ENOMEM;
+  }
+
+  s->subdriver = mp;
+  mp->state = state_idle;
+
+  mp->cb.buf = buf;
+  mp->cb.size = CMDBUF_SIZE;
+  mp->cb.res_header_len = 8;
+  mp->cb.cmd_header_len = 16;
+  mp->cb.cmd_len_field_ofs = 14;
+
+  mp->imgbuf = buf + CMDBUF_SIZE;
+
+  /* General rules for setting Pixma protocol generation # */
+  mp->generation = (s->cfg->pid >= MP810_PID) ? 2 : 1;
+
+  if (s->cfg->pid >= MP970_PID)
+    mp->generation = 3;
+
+  if (s->cfg->pid >= MP990_PID)
+    mp->generation = 4;
+
+  /* And exceptions to be added here */
+  if (s->cfg->pid == CS8800F_PID)
+    mp->generation = 3;
+
+  if (s->cfg->pid == CS9000F_PID || s->cfg->pid == CS9000F_MII_PID)
+    mp->generation = 4;
+
+  /* TPU info data setup */
+  mp->tpu_datalen = 0;
+
+  if (mp->generation < 4)
+  {
+    /* Canoscan 8800F ignores commands if not initialized */
+    if (s->cfg->pid == CS8800F_PID)
+      abort_session (s);
+    else
+    {
+      query_status (s);
+      handle_interrupt (s, 200);
+      if (mp->generation == 3 && has_ccd_sensor (s))
+        send_cmd_start_calibrate_ccd_3 (s);
+    }
+  }
+  return 0;
+}
+
+static void mp810_close (pixma_t * s)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+
+  mp810_finish_scan (s);
+  free (mp->cb.buf);
+  free (mp);
+  s->subdriver = NULL;
+}
+
+static int mp810_check_param (pixma_t * s, pixma_scan_param_t * sp)
+{
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  unsigned w_max;
+
+  /* PDBG (pixma_dbg (4, "*mp810_check_param***** Initially: channels=%u, depth=%u, x=%u, y=%u, w=%u, h=%u, xs=%u, wx=%u *****\n",
+                   sp->channels, sp->depth, sp->x, sp->y, sp->w, sp->h, sp->xs, sp->wx)); */
+
+  sp->channels = 3;
+  sp->software_lineart = 0;
+  switch (sp->mode)
+  {
+    /* standard scan modes
+     * 8 bit per channel in color and grayscale mode
+     * 16 bit per channel with TPU */
+    case PIXMA_SCAN_MODE_GRAY:
+    case PIXMA_SCAN_MODE_NEGATIVE_GRAY:
+    case PIXMA_SCAN_MODE_TPUIR:
+      sp->channels = 1;
+      /* fall through */
+    case PIXMA_SCAN_MODE_COLOR:
+    case PIXMA_SCAN_MODE_NEGATIVE_COLOR:
+      sp->depth = 8;
+#ifdef TPU_48
+#ifndef DEBUG_TPU_48
+      if (sp->source == PIXMA_SOURCE_TPU)
+#endif
+        sp->depth = 16; /* TPU in 16 bits mode */
+#endif
+      break;
+      /* extended scan modes for 48 bit flatbed scanners
+       * 16 bit per channel in color and grayscale mode */
+    case PIXMA_SCAN_MODE_GRAY_16:
+      sp->channels = 1;
+      sp->depth = 16;
+      break;
+    case PIXMA_SCAN_MODE_COLOR_48:
+      sp->channels = 3;
+      sp->depth = 16;
+      break;
+      /* software lineart
+       * 1 bit per channel */
+    case PIXMA_SCAN_MODE_LINEART:
+      sp->software_lineart = 1;
+      sp->channels = 1;
+      sp->depth = 1;
+      break;
+  }
+
+  /* for software lineart w must be a multiple of 8
+   * I don't know why is_lineart(s) doesn't work here */
+  if (sp->software_lineart == 1 && sp->w % 8)
+  {
+    sp->w += 8 - (sp->w % 8);
+
+    /* do not exceed the scanner capability */
+    w_max = s->cfg->width * s->cfg->xdpi / 75;
+    w_max -= w_max % 8;
+    if (sp->w > w_max)
+      sp->w = w_max;
+  }
+
+  if (sp->source == PIXMA_SOURCE_TPU && !sp->tpu_offset_added)
+  {
+    unsigned fixed_offset_y; /* TPU offsets for CanoScan 8800F, or other CCD at 300dpi. */
+    unsigned max_y; /* max TPU height for CS9000F at 75 dpi */
+
+    /* CanoScan 8800F and others adding an offset depending on resolution */
+    /* CS9000F and others maximum TPU height */
+    switch (s->cfg->pid)
+    {
+      case CS8800F_PID:
+        fixed_offset_y = 140;
+        max_y = MIN (740, s->cfg->height);
+        break;
+      case CS9000F_PID:
+      case CS9000F_MII_PID:
+        fixed_offset_y = 146;
+        max_y = MIN (740, s->cfg->height);
+        break;
+      default:
+        fixed_offset_y = 0;
+        max_y = s->cfg->height;
+        break;
+    }
+
+    /* cropping y and h to scanable area */
+    max_y *= (sp->ydpi) / 75;
+    sp->y = MIN(sp->y, max_y);
+    sp->h = MIN(sp->h, max_y - sp->y);
+    /* PDBG (pixma_dbg (4, "*mp810_check_param***** Cropping: y=%u, h=%u *****\n",
+     sp->y, sp->h)); */
+    if (!sp->h)
+      return SANE_STATUS_INVAL; /* no lines */
+
+    /* Convert the offsets from 300dpi to actual resolution */
+    fixed_offset_y = fixed_offset_y * (sp->xdpi) / 300;
+
+    /* In TPU mode, the CS9000F appears to always subtract 146 from the
+     vertical starting position, but clamps its at 0. Therefore vertical
+     offsets 0 through 146 (@300 dpi) get all mapped onto the same
+     physical starting position: line 0. Then, starting from 147, the
+     offsets get mapped onto successive physical lines:
+     y    line
+     0 ->  0
+     1 ->  0
+     2 ->  0
+     ...
+     146 ->  0
+     147 ->  1
+     148 ->  2
+     ...
+     Since a preview scan is typically made starting from y = 0, but
+     partial image scans usually start at y >> 147, this results in a
+     discontinuity in the y to line mapping, resulting in wrong offsets.
+     To prevent this, we must always add (at least) 146 to the y
+     offset before it is sent to the scanner. The scanner will then
+     map y = 0 (146) to the first line, y = 1 (147) to the second line,
+     and so on. Any distance that is then measured on the preview scan,
+     can be translated without any discontinuity.
+
+     However, there is one complication: during a preview scan, which
+     normally covers the whole scan area of the scanner, we should _not_
+     add the offset because it will result in a reduced number of lines
+     being returned (the scan height is clamped in
+     pixma_check_scan_param()). Since the frontend has no way of telling
+     that the scan area has been reduced, it would derive an incorrect
+     effective scan resolution, and any position calculations based on
+     this would therefore be inaccurate.
+
+     To prevent this, we don't add the offset in case y = 0, which is
+     typically the case during a preview scan (the scanner effectively
+     adds the offset for us, see above). In that way we keep the
+     linearity and we don't affect the scan area during previews.
+     */
+
+    if (sp->y > 0)
+      sp->y += fixed_offset_y;
+
+    /* Prevent repeated corrections as check_param may be called multiple times */
+    sp->tpu_offset_added = 1;
+  }
+
+  if (mp->generation >= 2)
+  {
+    /* mod 32 and expansion of the X scan limits */
+    /* PDBG (pixma_dbg (4, "*mp810_check_param***** (gen>=2) xs=mod32 ----- Initially: x=%u, y=%u, w=%u, h=%u *****\n", sp->x, sp->y, sp->w, sp->h)); */
+    sp->xs = (sp->x) % 32;
+  }
+  else
+  {
+    sp->xs = 0;
+    /* PDBG (pixma_dbg (4, "*mp810_check_param***** (else) xs=0 Selected origin, origin shift: %u, %u *****\n", sp->x, sp->xs)); */
+  }
+  sp->wx = calc_raw_width (mp, sp);
+  sp->line_size = sp->w * sp->channels * (((sp->software_lineart) ? 8 : sp->depth) / 8); /* bytes per line per color after cropping */
+  /* PDBG (pixma_dbg (4, "*mp810_check_param***** (else) Final scan width and line-size: %u, %"PRIu64" *****\n", sp->wx, sp->line_size)); */
+
+  /* highest res is 600, 2400, 4800 or 9600 dpi */
+  {
+    uint8_t k;
+
+    if ((sp->source == PIXMA_SOURCE_ADF || sp->source == PIXMA_SOURCE_ADFDUP)
+        && mp->generation >= 4)
+      /* ADF/ADF duplex mode: max scan res is 600 dpi, at least for generation 4 */
+      k = sp->xdpi / MIN (sp->xdpi, 600);
+    else if (sp->source == PIXMA_SOURCE_TPU && sp->mode == PIXMA_SCAN_MODE_TPUIR)
+      /* TPUIR mode: max scan res is 2400 dpi */
+      k = sp->xdpi / MIN (sp->xdpi, 2400);
+    else if (sp->source == PIXMA_SOURCE_TPU && (s->cfg->pid == CS9000F_PID || s->cfg->pid == CS9000F_MII_PID))
+      /* CS9000F in TPU mode */
+      k = sp->xdpi / MIN (sp->xdpi, 9600);
+    else
+      /* default */
+      k = sp->xdpi / MIN (sp->xdpi, 4800);
+
+    sp->x /= k;
+    sp->xs /= k;
+    sp->y /= k;
+    sp->w /= k;
+    sp->wx /= k;
+    sp->h /= k;
+    sp->xdpi /= k;
+    sp->ydpi = sp->xdpi;
+  }
+
+  /* lowest res is 75, 150, 300 or 600 dpi */
+  {
+    uint8_t k;
+
+    if (sp->source == PIXMA_SOURCE_TPU && sp->mode == PIXMA_SCAN_MODE_TPUIR)
+      /* TPUIR mode */
+      k = MAX (sp->xdpi, 600) / sp->xdpi;
+    else if (sp->source == PIXMA_SOURCE_TPU
+              && ((mp->generation >= 3) || (s->cfg->pid == MP810_PID) || (s->cfg->pid == MP960_PID)))
+      /* TPU mode for generation 3+ scanners
+       * MP810, MP960 appear to have a 200dpi mode for low-res scans, not 150 dpi */
+      k = MAX (sp->xdpi, 300) / sp->xdpi;
+    else if (sp->source == PIXMA_SOURCE_TPU
+              || sp->mode == PIXMA_SCAN_MODE_COLOR_48 || sp->mode == PIXMA_SCAN_MODE_GRAY_16)
+      /* TPU mode and 16 bit flatbed scans
+       * TODO: either the frontend (xsane) cannot handle 48 bit flatbed scans @ 75 dpi (prescan)
+       *       or there is a bug in this subdriver */
+      k = MAX (sp->xdpi, 150) / sp->xdpi;
+    else
+      /* default */
+      k = MAX (sp->xdpi, 75) / sp->xdpi;
+
+    sp->x *= k;
+    sp->xs *= k;
+    sp->y *= k;
+    sp->w *= k;
+    sp->wx *= k;
+    sp->h *= k;
+    sp->xdpi *= k;
+    sp->ydpi = sp->xdpi;
+  }
+
+  /* PDBG (pixma_dbg (4, "*mp810_check_param***** Finally: channels=%u, depth=%u, x=%u, y=%u, w=%u, h=%u, xs=%u, wx=%u *****\n",
+                   sp->channels, sp->depth, sp->x, sp->y, sp->w, sp->h, sp->xs, sp->wx)); */
+
+  return 0;
+}
+
+static int mp810_scan (pixma_t * s)
+{
+  int error = 0, tmo;
+  mp810_t *mp = (mp810_t *) s->subdriver;
+
+  if (mp->state != state_idle)
+    return PIXMA_EBUSY;
+
+  /* Generation 4: send XML dialog */
+  if (mp->generation == 4 && s->param->adf_pageid == 0)
+  {
+    if (!send_xml_dialog (s, XML_START_1))
+      return PIXMA_EPROTO;
+    if (!send_xml_dialog (s, XML_START_2))
+      return PIXMA_EPROTO;
+  }
+
+  /* clear interrupt packets buffer */
+  while (handle_interrupt (s, 0) > 0)
+  {
+  }
+
+  /* FIXME: Duplex ADF: check paper status only before odd pages (1,3,5,...). */
+  if (is_scanning_from_adf (s))
+  {
+    if ((error = query_status (s)) < 0)
+      return error;
+    tmo = 10;
+    while (!has_paper (s) && --tmo >= 0)
+    {
+      WAIT_INTERRUPT(1000);
+      PDBG(pixma_dbg (2, "No paper in ADF. Timed out in %d sec.\n", tmo));
+    }
+    if (!has_paper (s))
+      return PIXMA_ENO_PAPER;
+  }
+
+  if (has_ccd_sensor (s) && (mp->generation <= 2))
+  {
+    error = send_cmd_e920 (s);
+    switch (error)
+    {
+      case PIXMA_ECANCELED:
+      case PIXMA_EBUSY:
+        PDBG(pixma_dbg (2, "cmd e920 or d520 returned %s\n", pixma_strerror (error)));
+        /* fall through */
+      case 0:
+        query_status (s);
+        break;
+      default:
+        PDBG(pixma_dbg (1, "WARNING: cmd e920 or d520 failed %s\n", pixma_strerror (error)));
+        return error;
+    }
+    tmo = 3; /* like Windows driver, CCD calibration ? */
+    while (--tmo >= 0)
+    {
+      WAIT_INTERRUPT(1000);
+      PDBG(pixma_dbg (2, "CCD Calibration ends in %d sec.\n", tmo));
+    }
+    /* pixma_sleep(2000000); */
+  }
+
+  tmo = 10;
+  if (s->param->adf_pageid == 0 || mp->generation <= 2)
+  {
+    error = start_session (s);
+    while (error == PIXMA_EBUSY && --tmo >= 0)
+    {
+      if (s->cancel)
+      {
+        error = PIXMA_ECANCELED;
+        break;
+      }
+      PDBG(pixma_dbg (2, "Scanner is busy. Timed out in %d sec.\n", tmo + 1));
+      pixma_sleep (1000000);
+      error = start_session (s);
+    }
+    if (error == PIXMA_EBUSY || error == PIXMA_ETIMEDOUT)
+    {
+      /* The scanner maybe hangs. We try to empty output buffer of the
+       * scanner and issue the cancel command. */
+      PDBG(pixma_dbg (2, "Scanner hangs? Sending abort_session command.\n"));
+      drain_bulk_in (s);
+      abort_session (s);
+      pixma_sleep (500000);
+      error = start_session (s);
+    }
+    if ((error >= 0) || (mp->generation >= 3))
+      mp->state = state_warmup;
+    if ((error >= 0) && (mp->generation <= 2))
+      error = select_source (s);
+    if ((error >= 0) && (mp->generation >= 3) && has_ccd_sensor (s))
+      error = init_ccd_lamp_3 (s);
+    if ((error >= 0) && !is_scanning_from_tpu (s))
+    {
+      int i;
+      /* FIXME: 48 bit flatbed scans don't need gamma tables
+       *        the code below doesn't run */
+      /*if (is_color_48 (s) || is_gray_16 (s))
+       error = 0;
+       else*/
+      for (i = (mp->generation >= 3) ? 3 : 1; i > 0 && error >= 0; i--)
+        error = send_gamma_table (s);
+    }
+    else if (error >= 0) /* in TPU mode, for gen 1, 2, and 3 */
+      error = send_set_tpu_info (s);
+  }
+  else
+    /* ADF pageid != 0 and gen3 or above */
+    pixma_sleep (1000000);
+
+  if ((error >= 0) || (mp->generation >= 3))
+    mp->state = state_warmup;
+  if (error >= 0)
+    error = send_scan_param (s);
+  if ((error >= 0) && (mp->generation >= 3))
+    error = start_scan_3 (s);
+  if (error < 0)
+  {
+    mp->last_block = 0x38; /* Force abort session if ADF scan */
+    mp810_finish_scan (s);
+    return error;
+  }
+  return 0;
+}
+
+static int mp810_fill_buffer (pixma_t * s, pixma_imagebuf_t * ib)
+{
+  int error;
+  mp810_t *mp = (mp810_t *) s->subdriver;
+  unsigned block_size, bytes_received, proc_buf_size, line_size;
+  uint8_t header[16];
+
+  if (mp->state == state_warmup)
+  { /* prepare read image data */
+    /* PDBG (pixma_dbg (4, "**mp810_fill_buffer***** warmup *****\n")); */
+
+    RET_IF_ERR(wait_until_ready (s));
+    pixma_sleep (1000000); /* No need to sleep, actually, but Window's driver
+                            * sleep 1.5 sec. */
+    mp->state = state_scanning;
+    mp->last_block = 0;
+
+    line_size = get_cis_ccd_line_size (s);
+    proc_buf_size = (2 * calc_shifting (s) + 2) * line_size;
+    mp->cb.buf = realloc (mp->cb.buf, CMDBUF_SIZE + IMAGE_BLOCK_SIZE + proc_buf_size);
+    if (!mp->cb.buf)
+      return PIXMA_ENOMEM;
+    mp->linebuf = mp->cb.buf + CMDBUF_SIZE;
+    mp->imgbuf = mp->data_left_ofs = mp->linebuf + line_size;
+    mp->data_left_len = 0;
+  }
+
+  do
+  { /* read complete image data from the scanner */
+    if (s->cancel)
+      return PIXMA_ECANCELED;
+    if ((mp->last_block & 0x28) == 0x28)
+    { /* end of image */
+      mp->state = state_finished;
+      /* PDBG (pixma_dbg (4, "**mp810_fill_buffer***** end of image *****\n")); */
+      return 0;
+    }
+    /* PDBG (pixma_dbg (4, "*mp810_fill_buffer***** moving %u bytes into buffer *****\n", mp->data_left_len)); */
+    memmove (mp->imgbuf, mp->data_left_ofs, mp->data_left_len);
+    error = read_image_block (s, header, mp->imgbuf + mp->data_left_len);
+    if (error < 0)
+    {
+      if (error == PIXMA_ECANCELED)
+      {
+        /* NOTE: I see this in traffic logs but I don't know its meaning. */
+        read_error_info (s, NULL, 0);
+      }
+      return error;
+    }
+
+    bytes_received = error;
+    /*PDBG (pixma_dbg (4, "*mp810_fill_buffer***** %u bytes received by read_image_block *****\n", bytes_received));*/
+    block_size = pixma_get_be32 (header + 12);
+    mp->last_block = header[8] & 0x38;
+    if ((header[8] & ~0x38) != 0)
+    {
+      PDBG(pixma_dbg (1, "WARNING: Unexpected result header\n"));
+      PDBG(pixma_hexdump (1, header, 16));
+    }
+    PASSERT(bytes_received == block_size);
+
+    if (block_size == 0)
+    { /* no image data at this moment. */
+      pixma_sleep (10000);
+    }
+    /* For TPU at 48 bits/pixel to output at 24 bits/pixel */
+#ifndef DEBUG_TPU_48
+#ifndef TPU_48
+    PDBG (pixma_dbg (1, "WARNING: 9000F using 24 instead of 48 bit processing \n"));
+#ifndef DEBUG_TPU_24
+    if (is_scanning_from_tpu (s))
+#endif
+    bytes_received = pack_48_24_bpc (mp->imgbuf + mp->data_left_len, bytes_received);
+#endif
+#endif
+    /* Post-process the image data */
+    mp->data_left_ofs = mp->imgbuf + mp->data_left_len + bytes_received;
+    mp->data_left_len = post_process_image_data (s, ib);
+    mp->data_left_ofs -= mp->data_left_len;
+    /* PDBG (pixma_dbg (4, "* mp810_fill_buffer: data_left_len %u \n", mp->data_left_len)); */
+    /* PDBG (pixma_dbg (4, "* mp810_fill_buffer: data_left_ofs %u \n", mp->data_left_ofs)); */
+  }
+  while (ib->rend == ib->rptr);
+
+  return ib->rend - ib->rptr;
+}
+
+static void mp810_finish_scan (pixma_t * s)
+{
+  int error;
+  mp810_t *mp = (mp810_t *) s->subdriver;
+
+  switch (mp->state)
+  {
+    case state_transfering:
+      drain_bulk_in (s);
+      /* fall through */
+    case state_scanning:
+    case state_warmup:
+    case state_finished:
+      /* Send the get TPU info message */
+      if (is_scanning_from_tpu (s) && mp->tpu_datalen == 0)
+        send_get_tpu_info_3 (s);
+      /* FIXME: to process several pages ADF scan, must not send
+       * abort_session and start_session between pages (last_block=0x28) */
+      if (mp->generation <= 2 || !is_scanning_from_adf (s)
+          || mp->last_block == 0x38)
+      {
+        error = abort_session (s); /* FIXME: it probably doesn't work in duplex mode! */
+        if (error < 0)
+          PDBG(pixma_dbg (1, "WARNING:abort_session() failed %d\n", error));
+
+        /* Generation 4: send XML end of scan dialog */
+        if (mp->generation == 4)
+        {
+          if (!send_xml_dialog (s, XML_END))
+            PDBG(pixma_dbg (1, "WARNING:XML_END dialog failed \n"));
+        }
+      }
+      mp->state = state_idle;
+      /* fall through */
+    case state_idle:
+      break;
+  }
+}
+
+static void mp810_wait_event (pixma_t * s, int timeout)
+{
+  /* FIXME: timeout is not correct. See usbGetCompleteUrbNoIntr() for
+   * instance. */
+  while (s->events == 0 && handle_interrupt (s, timeout) > 0)
+  {
+  }
+}
+
+static int mp810_get_status (pixma_t * s, pixma_device_status_t * status)
+{
+  int error;
+
+  RET_IF_ERR(query_status (s));
+  status->hardware = PIXMA_HARDWARE_OK;
+  status->adf = (has_paper (s)) ? PIXMA_ADF_OK : PIXMA_ADF_NO_PAPER;
+  status->cal =
+      (is_calibrated (s)) ? PIXMA_CALIBRATION_OK : PIXMA_CALIBRATION_OFF;
+  return 0;
+}
+
+static const pixma_scan_ops_t pixma_mp800_ops =
+{
+  mp810_open,
+  mp810_close,
+  mp810_scan,
+  mp810_fill_buffer,
+  mp810_finish_scan,
+  mp810_wait_event,
+  mp810_check_param,
+  mp810_get_status
+};
+
+#define DEVICE(name, model, pid, dpi, adftpu_min_dpi, adftpu_max_dpi, tpuir_min_dpi, tpuir_max_dpi, w, h, cap) { \
+        name,              /* name */               \
+        model,             /* model */              \
+        CANON_VID, pid,    /* vid pid */            \
+        0,                 /* iface */              \
+        &pixma_mp800_ops,  /* ops */                \
+        0,                 /* min_xdpi not used in this subdriver */ \
+        dpi, 2*(dpi),      /* xdpi, ydpi */         \
+        adftpu_min_dpi, adftpu_max_dpi,  /* adftpu_min_dpi, adftpu_max_dpi */ \
+        tpuir_min_dpi, tpuir_max_dpi,    /* tpuir_min_dpi, tpuir_max_dpi */   \
+        w, h,              /* width, height */      \
+        PIXMA_CAP_CCD|     /* all scanners with CCD*/ \
+        PIXMA_CAP_EASY_RGB|                         \
+        PIXMA_CAP_GRAY|    /* all scanners with software grayscale */ \
+        PIXMA_CAP_LINEART| /* all scanners with software lineart */ \
+        PIXMA_CAP_GAMMA_TABLE|PIXMA_CAP_EVENTS|cap  \
+}
+
+#define END_OF_DEVICE_LIST DEVICE(NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0, 0)
+
+const pixma_config_t pixma_mp800_devices[] =
+{
+  /* Generation 1: CCD */
+  DEVICE ("Canon PIXMA MP800", "MP800", MP800_PID, 2400, 150, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+  DEVICE ("Canon PIXMA MP800R", "MP800R", MP800R_PID, 2400, 150, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+  DEVICE ("Canon PIXMA MP830", "MP830", MP830_PID, 2400, 150, 0, 0, 0, 638, 877, PIXMA_CAP_ADFDUP),
+
+  /* Generation 2: CCD */
+  DEVICE ("Canon PIXMA MP810", "MP810", MP810_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+  DEVICE ("Canon PIXMA MP960", "MP960", MP960_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+
+  /* Generation 3 CCD not managed as Generation 2 */
+  DEVICE ("Canon Pixma MP970", "MP970", MP970_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+
+  /* Flatbed scanner CCD (2007) */
+  DEVICE ("Canoscan 8800F", "8800F", CS8800F_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU /*| PIXMA_CAP_NEGATIVE*/ | PIXMA_CAP_48BIT),
+
+  /* PIXMA 2008 vintage CCD */
+  DEVICE ("Canon MP980 series", "MP980", MP980_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+
+  /* Generation 4 CCD */
+  DEVICE ("Canon MP990 series", "MP990", MP990_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+
+  /* Flatbed scanner (2010) */
+  DEVICE ("Canoscan 9000F", "9000F", CS9000F_PID, 4800, 300, 9600, 600, 2400, 638, 877, PIXMA_CAP_TPUIR /*| PIXMA_CAP_NEGATIVE*/ | PIXMA_CAP_48BIT),
+
+  /* Latest devices (2010) Generation 4 CCD untested */
+  DEVICE ("Canon PIXMA MG8100", "MG8100", MG8100_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+
+  /* Latest devices (2011) Generation 4 CCD untested */
+  DEVICE ("Canon PIXMA MG8200", "MG8200", MG8200_PID, 4800, 300, 0, 0, 0, 638, 877, PIXMA_CAP_TPU),
+
+  /* Flatbed scanner (2013) */
+  DEVICE ("Canoscan 9000F Mark II", "9000FMarkII", CS9000F_MII_PID, 4800, 300, 9600, 600, 2400, 638, 877, PIXMA_CAP_TPUIR | PIXMA_CAP_48BIT),
+
+  END_OF_DEVICE_LIST
+};