Initial import of sane-backends version 1.0.24-1.2

1 files changed, 1362 insertions, 0 deletions

diff --git a/backend/niash_core.c b/backend/niash_core.c
new file mode 100644
index 0000000..e3ae2b8
--- /dev/null
+++ b/backend/niash_core.c
@@ -0,0 +1,1362 @@
+/*
+  Copyright (C) 2001 Bertrik Sikken (bertrik@zonnet.nl)
+
+  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.
+
+  $Id$
+*/
+
+/*
+    Core NIASH chip functions.
+*/
+
+#include <stdio.h>		/* fopen, fread, fwrite, fclose etc */
+#include <stdarg.h>		/* va_list for vfprintf */
+#include <string.h>		/* memcpy, memset */
+#include <unistd.h>		/* unlink */
+#include <stdlib.h>		/* malloc, free */
+#include <math.h>		/* exp, pow */
+
+#include "niash_xfer.h"
+#include "niash_core.h"
+
+
+#ifndef MIN
+#define MIN(a,b) (((a) < (b)) ? (a) : (b))
+#endif
+
+#ifndef MAX
+#define MAX(a,b) (((a) > (b)) ? (a) : (b))
+#endif
+
+
+#define XFER_BUF_SIZE  0xF000
+
+
+/* HP3400 firmware data */
+static unsigned char abData0000[] = {
+  0xfe, 0x9f, 0x58, 0x1b, 0x00, 0x03, 0xa4, 0x02, 0x63, 0x02, 0x33, 0x02,
+  0x0d, 0x02, 0xf0, 0x01,
+  0xd8, 0x01, 0xc5, 0x01, 0xb5, 0x01, 0xa8, 0x01, 0x9d, 0x01, 0x93, 0x01,
+  0x8b, 0x01, 0x84, 0x01,
+  0x7e, 0x01, 0x79, 0x01, 0x74, 0x01, 0x70, 0x01, 0x6d, 0x01, 0x69, 0x01,
+  0x67, 0x01, 0x64, 0x01,
+  0x62, 0x01, 0x60, 0x01, 0x5f, 0x01, 0x5d, 0x01, 0x5c, 0x01, 0x5b, 0x01,
+  0x5a, 0x01, 0x59, 0x01,
+  0x58, 0x01, 0x57, 0x01, 0x57, 0x01, 0x56, 0x01, 0x56, 0x01, 0x55, 0x01,
+  0x55, 0x01, 0x54, 0x01,
+  0x54, 0x01, 0x54, 0x01, 0x54, 0x01, 0x53, 0x01, 0x53, 0x01, 0x53, 0x01,
+  0x53, 0x01, 0x52, 0x81
+};
+
+/*  1st word : 0x9ffe = 40958, strip 15th bit: 0x1ffe = 8190
+    2nd word : 0x1b58 = 7000 -> coincidence ?
+    other words: formula: y = 676 / (2 - exp(0.113 * (1-x)) ), where x = 0 for first entry
+*/
+
+/* more HP3400 firmware data */
+static unsigned char abData0400[] = {
+  0xa4, 0x82, 0x00, 0x80, 0xa4, 0x82, 0xaa, 0x02, 0xc0, 0x02, 0xe8, 0x02,
+  0x3e, 0x03, 0xc8, 0x03,
+  0x58, 0x1b, 0xfe, 0x9f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00,
+  0x00, 0x00, 0x00, 0x00
+};
+
+
+
+static void
+_ConvertMotorTable (unsigned char *pabOld, unsigned char *pabNew, int iSize,
+		    int iLpi)
+{
+  int iData, i, iBit15;
+
+  for (i = 0; i < (iSize / 2); i++)
+    {
+      iData = pabOld[2 * i + 0] + (pabOld[2 * i + 1] << 8);
+      iBit15 = (iData & 0x8000);
+      iData = (iData & 0x7FFF);
+      if (iData <= 0x400)
+	{
+	  iData = iData * iLpi / 300;
+	}
+      if (iBit15 != 0)
+	{
+	  iData |= 0x8000;
+	}
+      pabNew[2 * i + 0] = iData & 255;
+      pabNew[2 * i + 1] = (iData >> 8) & 255;
+    }
+}
+
+
+/*************************************************************************
+  _ProbeRegisters
+  ===============
+    Tries to determine certain hardware properties.
+
+  This is done by checking the writeability of some scanner registers.
+  We cannot rely simply on the scanner model to contain a specific
+  chip. The HP3300c for example uses one of at least three slightly
+  different scanner ASICs (NIASH00012, NIASH00013 and NIASH00014).
+
+  OUT pHWParams     Hardware parameters, updated fields:
+        fGamma16    TRUE if 16 bit gamma tables can be used
+        fReg07      TRUE if reg07 is writeable
+        iBufferSize Size of scanner's internal buffer
+
+  Returns TRUE if a NIASH chipset was found.
+*************************************************************************/
+static SANE_Bool
+_ProbeRegisters (THWParams * pHWParams)
+{
+  unsigned char bData1, bData2;
+  int iHandle;
+
+  iHandle = pHWParams->iXferHandle;
+
+  DBG (DBG_MSG, "Probing scanner...\n");
+
+  /* check register 0x04 */
+  NiashWriteReg (iHandle, 0x04, 0x55);
+  NiashReadReg (iHandle, 0x04, &bData1);
+  NiashWriteReg (iHandle, 0x04, 0xAA);
+  NiashReadReg (iHandle, 0x04, &bData2);
+  NiashWriteReg (iHandle, 0x04, 0x07);
+  if ((bData1 != 0x55) || (bData2 != 0xAA))
+    {
+      DBG (DBG_ERR, "  No NIASH chipset found!\n");
+      return SANE_FALSE;
+    }
+
+  /* check writeability of register 3 bit 1 */
+  NiashReadReg (iHandle, 0x03, &bData1);
+  NiashWriteReg (iHandle, 0x03, bData1 | 0x02);
+  NiashReadReg (iHandle, 0x03, &bData2);
+  NiashWriteReg (iHandle, 0x03, bData1);
+  pHWParams->fGamma16 = ((bData2 & 0x02) != 0);
+  DBG (DBG_MSG, "  Gamma table entries are %d bit\n",
+       pHWParams->fGamma16 ? 16 : 8);
+
+  /* check register 0x07 */
+  NiashReadReg (iHandle, 0x07, &bData1);
+  NiashWriteReg (iHandle, 0x07, 0x1C);
+  NiashReadReg (iHandle, 0x07, &bData2);
+  NiashWriteReg (iHandle, 0x07, bData1);
+  pHWParams->fReg07 = (bData2 == 0x1C);
+
+  if (!pHWParams->fGamma16)
+    {
+      /* internal scan buffer size is an educated guess, but seems to correlate
+         well with the size calculated from several windows driver log files
+         size = 128kB - 44088 unsigned chars (space required for gamma/calibration table)
+       */
+      pHWParams->iBufferSize = 86984L;
+      DBG (DBG_MSG, "  NIASH version < 00014\n");
+    }
+  else
+    {
+      pHWParams->iBufferSize = 0x60000L;
+      if (!pHWParams->fReg07)
+	{
+	  DBG (DBG_MSG, "  NIASH version = 00014\n");
+	}
+      else
+	{
+	  DBG (DBG_MSG, "  NIASH version > 00014\n");
+	}
+    }
+
+  return SANE_TRUE;
+}
+
+
+/* returns 0 on success, < 0 otherwise */
+STATIC int
+NiashOpen (THWParams * pHWParams, const char *pszName)
+{
+  int iXferHandle;
+
+  iXferHandle = NiashXferOpen (pszName, &pHWParams->eModel);
+  if (iXferHandle < 0)
+    {
+      DBG (DBG_ERR, "NiashXferOpen failed for '%s'\n", pszName);
+      return -1;
+    }
+
+  pHWParams->iXferHandle = iXferHandle;
+
+  NiashWakeup (pHWParams->iXferHandle);
+
+  /* default HW params */
+  pHWParams->iSensorSkew = 8;
+  pHWParams->iTopLeftX = 0;
+  pHWParams->iTopLeftY = 3;
+  pHWParams->fReg07 = SANE_FALSE;
+  pHWParams->iSkipLines = 0;
+  pHWParams->iExpTime = 5408;
+  pHWParams->iReversedHead = SANE_TRUE;
+
+  switch (pHWParams->eModel)
+    {
+
+    case eHp3300c:
+      DBG (DBG_MSG, "Setting params for Hp3300\n");
+      pHWParams->iTopLeftX = 4;
+      pHWParams->iTopLeftY = 11;
+      pHWParams->iSkipLines = 14;
+      break;
+
+    case eHp3400c:
+    case eHp4300c:
+      DBG (DBG_MSG, "Setting params for Hp3400c/Hp4300c\n");
+      pHWParams->iTopLeftX = 3;
+      pHWParams->iTopLeftY = 14;
+      pHWParams->fReg07 = SANE_TRUE;
+      break;
+
+    case eAgfaTouch:
+      DBG (DBG_MSG, "Setting params for AgfaTouch\n");
+      pHWParams->iReversedHead = SANE_FALSE;	/* head not reversed on Agfa Touch */
+      pHWParams->iTopLeftX = 3;
+      pHWParams->iTopLeftY = 10;
+      pHWParams->iSkipLines = 7;
+      break;
+
+    case eUnknownModel:
+      DBG (DBG_MSG, "Setting params for UnknownModel\n");
+      break;
+
+    default:
+      DBG (DBG_ERR, "ERROR: internal error! (%d)\n", (int) pHWParams->eModel);
+      return -1;
+    }
+
+  /* autodetect some hardware properties */
+  if (!_ProbeRegisters (pHWParams))
+    {
+      DBG (DBG_ERR, "_ProbeRegisters failed!\n");
+      return -1;
+    }
+
+  return 0;
+}
+
+
+STATIC void
+NiashClose (THWParams * pHWPar)
+{
+  NiashXferClose (pHWPar->iXferHandle);
+  pHWPar->iXferHandle = 0;
+}
+
+
+static void
+WriteRegWord (int iHandle, unsigned char bReg, SANE_Word wData)
+{
+  NiashWriteReg (iHandle, bReg, wData & 0xFF);
+  NiashWriteReg (iHandle, bReg + 1, (wData >> 8) & 0xFF);
+}
+
+
+/* calculate a 4096 unsigned char gamma table */
+STATIC void
+CalcGamma (unsigned char *pabTable, double Gamma)
+{
+  int i, iData;
+
+  /* fill gamma table */
+  for (i = 0; i < 4096; i++)
+    {
+      iData = floor (256.0 * pow (((double) i / 4096.0), 1.0 / Gamma));
+      pabTable[i] = iData;
+    }
+}
+
+
+/*
+  Hp3400WriteFw
+  =============
+    Writes data to scanners with a NIASH00019 chipset, e.g.
+    gamma, calibration and motor control data.
+
+  IN  pabData   pointer to firmware data
+      iLen      Size of firmware date (unsigned chars)
+      iAddr     Scanner address to write to
+*/
+static void
+Hp3400cWriteFW (int iXferHandle, unsigned char *pabData, int iLen, int iAddr)
+{
+  iAddr--;
+  NiashWriteReg (iXferHandle, 0x21, iAddr & 0xFF);
+  NiashWriteReg (iXferHandle, 0x22, (iAddr >> 8) & 0xFF);
+  NiashWriteReg (iXferHandle, 0x23, (iAddr >> 16) & 0xFF);
+  NiashWriteBulk (iXferHandle, pabData, iLen);
+}
+
+
+/* Writes the gamma and offset/gain tables to the scanner.
+   In case a calibration file exist, it will be used for offset/gain */
+STATIC void
+WriteGammaCalibTable (unsigned char *pabGammaR, unsigned char *pabGammaG,
+		      unsigned char *pabGammaB, unsigned char *pabCalibTable,
+		      int iGain, int iOffset, THWParams * pHWPar)
+{
+  int i, j, k;
+  static unsigned char abGamma[60000];
+  int iData;
+  int iHandle;
+
+  iHandle = pHWPar->iXferHandle;
+
+  j = 0;
+  /* fill gamma table for red component */
+  /* pad entries with 0 for 16-bit gamma table */
+  for (i = 0; i < 4096; i++)
+    {
+      if (pHWPar->fGamma16)
+	{
+	  abGamma[j++] = 0;
+	}
+      abGamma[j++] = pabGammaR[i];
+    }
+  /* fill gamma table for green component */
+  for (i = 0; i < 4096; i++)
+    {
+      if (pHWPar->fGamma16)
+	{
+	  abGamma[j++] = 0;
+	}
+      abGamma[j++] = pabGammaG[i];
+    }
+  /* fill gamma table for blue component */
+  for (i = 0; i < 4096; i++)
+    {
+      if (pHWPar->fGamma16)
+	{
+	  abGamma[j++] = 0;
+	}
+      abGamma[j++] = pabGammaB[i];
+    }
+
+  if (pabCalibTable == NULL)
+    {
+      iData = (iGain << 6) + iOffset;
+      for (i = 0; i < HW_PIXELS; i++)
+	{
+	  for (k = 0; k < 3; k++)
+	    {
+	      abGamma[j++] = (iData) & 255;
+	      abGamma[j++] = (iData >> 8) & 255;
+	    }
+	}
+    }
+  else
+    {
+      memcpy (&abGamma[j], pabCalibTable, HW_PIXELS * 6);
+      j += HW_PIXELS * 6;
+    }
+
+  NiashWriteReg (iHandle, 0x02, 0x80);
+  NiashWriteReg (iHandle, 0x03, 0x01);
+  NiashWriteReg (iHandle, 0x03, 0x11);
+  NiashWriteReg (iHandle, 0x02, 0x84);
+
+  if (pHWPar->fReg07)
+    {
+      Hp3400cWriteFW (iHandle, abGamma, j, 0x2000);
+    }
+  else
+    {
+      NiashWriteBulk (iHandle, abGamma, j);
+    }
+
+  NiashWriteReg (iHandle, 0x02, 0x80);
+}
+
+
+static void
+WriteAFEReg (int iHandle, int iReg, int iData)
+{
+  NiashWriteReg (iHandle, 0x25, iReg);
+  NiashWriteReg (iHandle, 0x26, iData);
+}
+
+
+/* setup the analog front-end -> coarse calibration */
+static void
+WriteAFE (int iHandle)
+{
+  /* see WM8143 datasheet */
+
+  WriteAFEReg (iHandle, 0x04, 0x00);
+  WriteAFEReg (iHandle, 0x03, 0x12);
+  WriteAFEReg (iHandle, 0x02, 0x04);
+  WriteAFEReg (iHandle, 0x05, 0x10);
+  WriteAFEReg (iHandle, 0x01, 0x03);
+
+  WriteAFEReg (iHandle, 0x20, 0xc0);	/*c8 *//* red offset */
+  WriteAFEReg (iHandle, 0x21, 0xc0);	/*c8 *//* green offset */
+  WriteAFEReg (iHandle, 0x22, 0xc0);	/*d0 *//* blue offset */
+
+  WriteAFEReg (iHandle, 0x28, 0x05);	/*5 *//* red gain */
+  WriteAFEReg (iHandle, 0x29, 0x03);	/*3 *//* green gain */
+  WriteAFEReg (iHandle, 0x2A, 0x04);	/*4 *//* blue gain */
+}
+
+
+/* wait for the carriage to return */
+static void
+WaitReadyBit (int iHandle)
+{
+  unsigned char bData;
+
+  do
+    {
+      NiashReadReg (iHandle, 0x03, &bData);
+    }
+  while ((bData & 8) == 0);
+}
+
+
+/*
+  Initialisation specific for NIASH00014 and lower chips
+*/
+static void
+InitNiash00014 (TScanParams * pParams, THWParams * pHWParams)
+{
+  int iHandle, iLpiCode;
+
+  iHandle = pHWParams->iXferHandle;
+
+  /* exposure time (in units 24/Fcrystal)? */
+  WriteRegWord (iHandle, 0x08, pHWParams->iExpTime - 1);
+
+  /* width in pixels */
+  WriteRegWord (iHandle, 0x12, pParams->iWidth - 1);
+
+  /* top */
+  WriteRegWord (iHandle, 0x17, pParams->iTop);
+  WriteRegWord (iHandle, 0x19, pParams->iTop);
+
+  /* time between stepper motor steps (in units of 24/Fcrystal)? */
+  iLpiCode = pParams->iLpi * pHWParams->iExpTime / 1200L;
+
+  if (!pHWParams->fGamma16)
+    {
+      /* NIASH 00012 / 00013 init */
+
+      /* LPI specific settings */
+      if (pParams->iLpi < 600)
+	{
+	  /* set halfres bit */
+	  NiashWriteReg (iHandle, 0x06, 0x01);
+	  /* double lpi code because of halfres bit */
+	  iLpiCode *= 2;
+	}
+      else
+	{
+	  /* clear halfres bit */
+	  NiashWriteReg (iHandle, 0x06, 0x00);
+	  /* add exptime to make it scan slower */
+	  iLpiCode += pHWParams->iExpTime;
+	}
+
+      /* unknown setting */
+      WriteRegWord (iHandle, 0x27, 0x7FD2);
+      WriteRegWord (iHandle, 0x29, 0x6421);
+
+    }
+  else
+    {
+      /* NIASH 00014 init */
+
+      /* halfres bit always cleared */
+      NiashWriteReg (iHandle, 0x06, 0x00);
+
+      /* LPI specific settings */
+      if (pParams->iLpi >= 600)
+	{
+	  /* add exptime to make it scan slower */
+	  iLpiCode += pHWParams->iExpTime;
+	}
+
+      /* unknown setting */
+      WriteRegWord (iHandle, 0x27, 0xc862);	/*c862 */
+      WriteRegWord (iHandle, 0x29, 0xb853);	/*b853 */
+    }
+
+  /* LPI code */
+  WriteRegWord (iHandle, 0x0A, iLpiCode - 1);
+
+  /* backtrack reversing speed */
+  NiashWriteReg (iHandle, 0x1E, (iLpiCode - 1) / 32);
+}
+
+
+/*
+  Initialisation specific for NIASH00019 chips
+*/
+static void
+InitNiash00019 (TScanParams * pParams, THWParams * pHWParams)
+{
+  int iHandle, iLpiCode;
+  static unsigned char abMotor[512];
+
+
+  iHandle = pHWParams->iXferHandle;
+
+  /* exposure time (in units 24/Fcrystal)? */
+  WriteRegWord (iHandle, 0x08, pHWParams->iExpTime);
+
+  /* width in pixels */
+  WriteRegWord (iHandle, 0x12, pParams->iWidth);
+
+  /* ? */
+  WriteRegWord (iHandle, 0x27, 0xc862);	/*c862 */
+  WriteRegWord (iHandle, 0x29, 0xb853);	/*b853 */
+
+  /* specific handling of 150 dpi resolution */
+  if (pParams->iLpi == 150)
+    {
+      /* use 300 LPI but skip every other line */
+      pParams->iLpi = 300;
+      NiashWriteReg (iHandle, 0x06, 0x01);
+    }
+  else
+    {
+      NiashWriteReg (iHandle, 0x06, 0x00);
+    }
+
+  /* DPI and position table */
+  NiashWriteReg (iHandle, 0x07, 0x02);
+  _ConvertMotorTable (abData0000, abMotor, sizeof (abData0000),
+		      pParams->iLpi);
+  Hp3400cWriteFW (iHandle, abMotor, sizeof (abData0000), 0x000);
+  _ConvertMotorTable (abData0400, abMotor, sizeof (abData0400),
+		      pParams->iLpi);
+  Hp3400cWriteFW (iHandle, abMotor, sizeof (abData0400), 0x400);
+
+  /* backtrack reversing speed */
+  iLpiCode = pParams->iLpi * pHWParams->iExpTime / 1200L;
+  NiashWriteReg (iHandle, 0x1E, (iLpiCode - 1) / 32);
+}
+
+
+/*
+  Scanner initialisation common to all NIASH chips
+*/
+static void
+InitNiashCommon (TScanParams * pParams, THWParams * pHWParams)
+{
+  int iWidthHW, iHandle, iMaxLevel;
+
+
+  iHandle = pHWParams->iXferHandle;
+
+  NiashWriteReg (iHandle, 0x02, 0x80);
+  NiashWriteReg (iHandle, 0x03, 0x11);
+  NiashWriteReg (iHandle, 0x01, 0x8B);
+  NiashWriteReg (iHandle, 0x05, 0x01);
+
+  /* dpi */
+  WriteRegWord (iHandle, 0x0C, pParams->iDpi);
+
+  /* calculate width in units of HW resolution */
+  iWidthHW = pParams->iWidth * (HW_DPI / pParams->iDpi);
+
+  /* set left and right limits */
+  if (pHWParams->iReversedHead)
+    {
+      /* head is reversed */
+      /* right */
+      WriteRegWord (iHandle, 0x0E,
+		    3 * (HW_PIXELS - (pParams->iLeft + iWidthHW)));
+
+      /* left */
+      WriteRegWord (iHandle, 0x10, 3 * (HW_PIXELS - pParams->iLeft) - 1);
+    }
+  else
+    {
+      /* head is not reversed */
+      /*left  */
+      WriteRegWord (iHandle, 0x0E, 3 * pParams->iLeft);
+
+      /* right */
+      WriteRegWord (iHandle, 0x10, 3 * (pParams->iLeft + iWidthHW) - 1);
+    }
+
+  /* bottom */
+  WriteRegWord (iHandle, 0x1B, pParams->iBottom);	/* 0x393C); */
+
+  /* forward jogging speed */
+  NiashWriteReg (iHandle, 0x1D, 0x60);
+
+  /* backtrack reversing speed? */
+  NiashWriteReg (iHandle, 0x2B, 0x15);
+
+  /* backtrack distance */
+  if (pParams->iLpi < 600)
+    {
+      NiashWriteReg (iHandle, 0x1F, 0x30);
+    }
+  else
+    {
+      NiashWriteReg (iHandle, 0x1F, 0x18);
+    }
+
+  /* max buffer level before backtrace */
+  iMaxLevel = MIN (pHWParams->iBufferSize / pParams->iWidth, 250);
+  NiashWriteReg (iHandle, 0x14, iMaxLevel - 1);
+
+  /* lamp PWM, max = 0x1ff? */
+  WriteRegWord (iHandle, 0x2C, 0x01FF);
+
+  /* not needed? */
+  NiashWriteReg (iHandle, 0x15, 0x90);	/* 90 */
+  NiashWriteReg (iHandle, 0x16, 0x70);	/* 70 */
+
+  WriteAFE (iHandle);
+
+  WaitReadyBit (iHandle);
+
+  NiashWriteReg (iHandle, 0x03, 0x05);
+
+  NiashWriteReg (iHandle, 0x02, pParams->fCalib ? 0x88 : 0xA8);
+}
+
+
+/* write registers */
+STATIC SANE_Bool
+InitScan (TScanParams * pParams, THWParams * pHWParams)
+{
+  int iHeight;
+  int iExpTime;
+  TScanParams Params;
+  int iHandle;
+
+  iHandle = pHWParams->iXferHandle;
+
+  /* check validity of scanparameters */
+  switch (pParams->iDpi)
+    {
+    case 150:
+    case 300:
+    case 600:
+      break;
+    default:
+      DBG (DBG_ERR, "Invalid dpi (%d)\n", pParams->iDpi);
+      return SANE_FALSE;
+    }
+
+  iHeight = (pParams->iBottom - pParams->iTop + 1);
+  if (iHeight <= 0)
+    {
+      DBG (DBG_ERR, "Invalid height (%d)\n", iHeight);
+      return SANE_FALSE;
+    }
+
+  if (pParams->iWidth <= 0)
+    {
+      DBG (DBG_ERR, "Invalid width (%d)\n", pParams->iWidth);
+      return SANE_FALSE;
+    }
+
+  switch (pParams->iLpi)
+    {
+    case 150:
+    case 300:
+    case 600:
+      break;
+    default:
+      DBG (DBG_ERR, "Invalid lpi (%d)\n", pParams->iLpi);
+      return SANE_FALSE;
+    }
+
+  /* exposure time (in units of 24/Fcrystal?), must be divisible by 8 !!! */
+  iExpTime = 5408;
+  if ((iExpTime % 8) != 0)
+    {
+      DBG (DBG_ERR, "Invalid exposure time (%d)\n", iExpTime);
+      return SANE_FALSE;
+    }
+
+  /*
+   *** Done checking scan parameters validity ***
+   */
+
+  /*
+     copy the parameters locally and make pParams point to the local copy
+   */
+  memcpy (&Params, pParams, sizeof (Params));
+  pParams = &Params;
+
+  if (!pHWParams->fReg07)
+    {
+      /* init NIASH00014 and lower */
+      InitNiash00014 (pParams, pHWParams);
+    }
+  else
+    {
+      /* init NIASH00019 */
+      InitNiash00019 (pParams, pHWParams);
+    }
+
+  /* common NIASH init */
+  InitNiashCommon (pParams, pHWParams);
+
+  return SANE_TRUE;
+}
+
+
+/************************************************************************/
+
+static SANE_Bool
+XferBufferGetLine (int iHandle, TDataPipe * p, unsigned char *pabLine,
+		   SANE_Bool fReturn)
+{
+  unsigned char bData, bData2;
+  SANE_Bool fJustDone = SANE_FALSE;
+  /* all calculated transfers done ? */
+  if (p->iLinesLeft == 0)
+    return SANE_FALSE;
+
+  /* time for a fresh read? */
+  if (p->iCurLine == 0)
+    {
+      int iLines;
+      iLines = p->iLinesPerXferBuf;
+      /* read only as many lines as needed */
+      if (p->iLinesLeft > 0 && p->iLinesLeft <= iLines)
+	{
+	  iLines = p->iLinesLeft;
+	  DBG (DBG_MSG, "\n");
+	  DBG (DBG_MSG, "last bulk read\n");
+	  if (iLines < p->iLinesPerXferBuf)
+	    {
+	      DBG (DBG_MSG,
+		   "reading reduced number of lines: %d instead of %d\n",
+		   iLines, p->iLinesPerXferBuf);
+	    }
+	  fJustDone = SANE_TRUE;
+	}
+      /* reading old buffer level */
+      NiashReadReg (iHandle, 0x20, &bData);
+      NiashReadBulk (iHandle, p->pabXferBuf, iLines * p->iBytesPerLine);
+      /* reding new buffer level */
+      NiashReadReg (iHandle, 0x20, &bData2);
+      if (fJustDone && fReturn)
+	{
+	  NiashWriteReg (iHandle, 0x02, 0x80);
+	  DBG (DBG_MSG, "returning scanner head\n");
+	}
+      DBG (DBG_MSG,
+	   "buffer level = %3d, <reading %5d unsigned chars>, buffer level = %3d\r",
+	   (int) bData, iLines * p->iBytesPerLine, (int) bData2);
+      fflush (stdout);
+    }
+  /* copy one line */
+  if (pabLine != NULL)
+    {
+      memcpy (pabLine, &p->pabXferBuf[p->iCurLine * p->iBytesPerLine],
+	      p->iBytesPerLine);
+    }
+  /* advance pointer */
+  p->iCurLine = (p->iCurLine + 1) % p->iLinesPerXferBuf;
+
+  /* one transfer line less to the XFerBuffer */
+  if (p->iLinesLeft > 0)
+    --(p->iLinesLeft);
+  return SANE_TRUE;
+}
+
+
+static void
+XferBufferInit (int iHandle, TDataPipe * p)
+{
+  int i;
+
+  p->pabXferBuf = (unsigned char *) malloc (XFER_BUF_SIZE);
+  p->iCurLine = 0;
+
+  /* skip garbage lines */
+  for (i = 0; i < p->iSkipLines; i++)
+    {
+      XferBufferGetLine (iHandle, p, NULL, SANE_FALSE);
+    }
+}
+
+/* static procedure that fills the circular buffer in advance to any
+   circular buffer data retrieval */
+static void
+CircBufferFill (int iHandle, TDataPipe * p, SANE_Bool iReversedHead)
+{
+  int i;
+  for (i = 0; i < p->iLinesPerCircBuf; i++)
+    {
+      if (iReversedHead)
+	{
+	  XferBufferGetLine (iHandle, p,
+			     &p->pabCircBuf[p->iRedLine * p->iBytesPerLine],
+			     SANE_FALSE);
+	}
+      else
+	{
+	  XferBufferGetLine (iHandle, p,
+			     &p->pabCircBuf[p->iBluLine * p->iBytesPerLine],
+			     SANE_FALSE);
+	}
+      /* advance pointers */
+      p->iRedLine = (p->iRedLine + 1) % p->iLinesPerCircBuf;
+      p->iGrnLine = (p->iGrnLine + 1) % p->iLinesPerCircBuf;
+      p->iBluLine = (p->iBluLine + 1) % p->iLinesPerCircBuf;
+    }
+}
+
+static void
+XferBufferExit (TDataPipe * p)
+{
+  if (p->pabXferBuf != NULL)
+    {
+      free (p->pabXferBuf);
+      p->pabXferBuf = NULL;
+    }
+  else
+    {
+      DBG (DBG_ERR, "XferBufExit: Xfer buffer not initialised!\n");
+    }
+}
+
+
+/* unscrambles a line:
+   - combining the proper R, G and B lines and converting them to interpixel RGB
+   - mirroring left to right
+*/
+static void
+_UnscrambleLine (unsigned char *pabLine,
+		 unsigned char *pabRed, unsigned char *pabGrn,
+		 unsigned char *pabBlu, int iWidth, SANE_Bool iReversedHead,
+		 int iScaleDownDpi, int iBufWeight)
+{
+  /* never change an approved algorithm ...
+     so take Bertriks original source for this special case */
+  if (iScaleDownDpi == 1 && iBufWeight == 0)
+    {
+      int i, j;
+      if (iReversedHead)
+	{
+	  /* reversed */
+	  for (i = 0; i < iWidth; i++)
+	    {
+	      j = (iWidth - i) * 3;
+	      pabLine[j - 3] = pabRed[i];
+	      pabLine[j - 2] = pabGrn[i + iWidth];
+	      pabLine[j - 1] = pabBlu[i + iWidth * 2];
+	    }
+	}
+      else
+	{
+	  /* not reversed */
+	  for (i = 0; i < iWidth; i++)
+	    {
+	      pabLine[3 * i] = pabRed[i];
+	      pabLine[3 * i + 1] = pabGrn[i + iWidth];
+	      pabLine[3 * i + 2] = pabBlu[i + iWidth * 2];
+	    }
+	}
+    }
+  else
+    {
+      int i, j;			/* loop variables */
+      int c;			/* color buffer accumulator for horizontal avarage */
+
+      /* initialize for incremental color buffer access */
+      int iInc = 1;
+      int iStart = 0;
+
+      /* set for "from the end to the front" of the circular color buffers */
+      if (iReversedHead)
+	{
+	  iStart = iWidth - iScaleDownDpi;
+	  iInc = -1;
+	}
+
+      /* each pixel is the mean of iScaleDownDpi
+         so set the skip width accordingly */
+      iInc *= iScaleDownDpi;
+
+      for (i = iStart; i >= 0 && i < iWidth; i += iInc)
+	{
+	  /* collect the red pixels */
+	  for (c = j = 0; j < iScaleDownDpi; ++j)
+	    c += pabRed[i + j];
+	  *pabLine =
+	    (*pabLine * iBufWeight + c / iScaleDownDpi) / (iBufWeight + 1);
+	  pabLine++;
+
+	  /* collect the green pixels */
+	  for (c = j = 0; j < iScaleDownDpi; ++j)
+	    c += pabGrn[i + iWidth + j];
+	  *pabLine =
+	    (*pabLine * iBufWeight + c / iScaleDownDpi) / (iBufWeight + 1);
+	  pabLine++;
+
+	  /* collect the blue pixels */
+	  for (c = j = 0; j < iScaleDownDpi; ++j)
+	    c += pabBlu[i + 2 * iWidth + j];
+	  *pabLine =
+	    (*pabLine * iBufWeight + c / iScaleDownDpi) / (iBufWeight + 1);
+	  pabLine++;
+	}
+    }
+
+}
+
+
+/* gets an unscrambled line from the circular buffer. the first couple of lines contain garbage,
+   if fReturn==SANE_TRUE, the head will return automatically on an end of scan */
+STATIC SANE_Bool
+CircBufferGetLineEx (int iHandle, TDataPipe * p, unsigned char *pabLine,
+		     SANE_Bool iReversedHead, SANE_Bool fReturn)
+{
+  int iLineCount;
+  for (iLineCount = 0; iLineCount < p->iScaleDownLpi; ++iLineCount)
+    {
+      if (iReversedHead)
+	{
+	  if (!XferBufferGetLine (iHandle, p,
+				  &p->pabCircBuf[p->iRedLine *
+						 p->iBytesPerLine], fReturn))
+	    return SANE_FALSE;
+	}
+      else
+	{
+	  if (!XferBufferGetLine (iHandle, p,
+				  &p->pabCircBuf[p->iBluLine *
+						 p->iBytesPerLine], fReturn))
+	    return SANE_FALSE;
+	}
+      if (pabLine != NULL)
+	{
+	  _UnscrambleLine (pabLine,
+			   &p->pabCircBuf[p->iRedLine * p->iBytesPerLine],
+			   &p->pabCircBuf[p->iGrnLine * p->iBytesPerLine],
+			   &p->pabCircBuf[p->iBluLine * p->iBytesPerLine],
+			   p->iWidth * p->iScaleDownDpi, iReversedHead,
+			   p->iScaleDownDpi, iLineCount);
+	}
+
+      /* advance pointers */
+      p->iRedLine = (p->iRedLine + 1) % p->iLinesPerCircBuf;
+      p->iGrnLine = (p->iGrnLine + 1) % p->iLinesPerCircBuf;
+      p->iBluLine = (p->iBluLine + 1) % p->iLinesPerCircBuf;
+    }
+  return SANE_TRUE;
+}
+
+
+/* gets an unscrambled line from the circular buffer. the first couple of lines contain garbage */
+STATIC SANE_Bool
+CircBufferGetLine (int iHandle, TDataPipe * p, unsigned char *pabLine,
+		   SANE_Bool iReversedHead)
+{
+  return CircBufferGetLineEx (iHandle, p, pabLine, iReversedHead, SANE_FALSE);
+}
+
+
+/* try to keep the number of transfers the same, but make them all 
+   as good as possible the same size to avoid cranking in critical
+   situations
+*/
+static int
+_OptimizeXferSize (int iLines, int iLinesPerXfer)
+{
+  int iXfers;
+  iXfers = (iLines + iLinesPerXfer - 1) / iLinesPerXfer;
+  while (--iLinesPerXfer > 0
+	 && (iLines + iLinesPerXfer - 1) / iLinesPerXfer == iXfers);
+  return iLinesPerXfer + 1;
+}
+
+STATIC void
+CircBufferInit (int iHandle, TDataPipe * p,
+		int iWidth, int iHeight,
+		int iMisAlignment, SANE_Bool iReversedHead,
+		int iScaleDownDpi, int iScaleDownLpi)
+{
+
+  /* relevant for internal read and write functions */
+  p->iScaleDownLpi = iScaleDownLpi;
+  p->iScaleDownDpi = iScaleDownDpi;
+  p->iWidth = iWidth;
+  p->iBytesPerLine = iWidth * iScaleDownDpi * BYTES_PER_PIXEL;
+  p->iSaneBytesPerLine = iWidth * BYTES_PER_PIXEL;
+  if (iMisAlignment == 0)
+    {
+      p->iLinesPerCircBuf = 1;
+    }
+  else
+    {
+      p->iLinesPerCircBuf = 3 * iMisAlignment;
+    }
+
+  DBG (DBG_MSG, "_iScaleDown (Dpi,Lpi) = (%d,%d)\n", p->iScaleDownDpi,
+       p->iScaleDownLpi);
+  DBG (DBG_MSG, "_iBytesPerLine = %d\n", p->iBytesPerLine);
+  DBG (DBG_MSG, "_iLinesPerCircBuf = %d\n", p->iLinesPerCircBuf);
+  p->pabCircBuf =
+    (unsigned char *) malloc (p->iBytesPerLine * p->iLinesPerCircBuf);
+  if (p->pabCircBuf == NULL)
+    {
+      DBG (DBG_ERR,
+	   "Unable to allocate %d unsigned chars for circular buffer\n",
+	   (int) (p->iBytesPerLine * p->iLinesPerCircBuf));
+      return;
+    }
+  DBG (DBG_MSG, "Allocated %d unsigned chars for circular buffer\n",
+       p->iBytesPerLine * p->iLinesPerCircBuf);
+
+  if (iReversedHead)
+    {
+      p->iBluLine = 0;
+      p->iGrnLine = iMisAlignment;
+      p->iRedLine = iMisAlignment * 2;
+    }
+  else
+    {
+      p->iRedLine = 0;
+      p->iGrnLine = iMisAlignment;
+      p->iBluLine = iMisAlignment * 2;
+    }
+
+  /* negative height is an indication for "no Check" */
+  if (iHeight < 0)
+    {
+      p->iLinesLeft = -1;
+      p->iLinesPerXferBuf = XFER_BUF_SIZE / p->iBytesPerLine;
+      DBG (DBG_MSG, "using unchecked XFER_BUF_SIZE\n");
+      DBG (DBG_MSG, "_iXFerSize = %d\n",
+	   p->iBytesPerLine * p->iLinesPerXferBuf);
+    }
+  else
+    {
+#define SAFETY_LINES 0
+#define MAX_LINES_PER_XFERBUF 800
+      /* estimate of number of unsigned chars to transfer at all via the USB */
+      /* add some lines for securtiy */
+
+      p->iLinesLeft =
+	iHeight + p->iSkipLines + p->iLinesPerCircBuf + SAFETY_LINES;
+      p->iLinesPerXferBuf = XFER_BUF_SIZE / p->iBytesPerLine;
+      /* with more than 800 lines the timing is spoiled */
+      if (p->iLinesPerXferBuf > MAX_LINES_PER_XFERBUF)
+	{
+	  p->iLinesPerXferBuf = MAX_LINES_PER_XFERBUF;
+	}
+      /* final optimization to keep critical scans smooth */
+      p->iLinesPerXferBuf =
+	_OptimizeXferSize (p->iLinesLeft, p->iLinesPerXferBuf);
+
+      DBG (DBG_MSG, "_iXFerSize = %d for %d transfer(s)\n",
+	   (int) p->iLinesPerXferBuf * p->iBytesPerLine,
+	   (p->iLinesLeft + p->iLinesPerXferBuf - 1) / p->iLinesPerXferBuf);
+    }
+  DBG (DBG_MSG, "_iLinesPerXferBuf = %d\n", p->iLinesPerXferBuf);
+
+  /* init transfer buffer */
+  XferBufferInit (iHandle, p);
+
+  /* fill circular buffer */
+  CircBufferFill (iHandle, p, iReversedHead);
+}
+
+
+STATIC void
+CircBufferExit (TDataPipe * p)
+{
+  XferBufferExit (p);
+  if (p->pabCircBuf != NULL)
+    {
+      DBG (DBG_MSG, "\n");
+      free (p->pabCircBuf);
+      p->pabCircBuf = NULL;
+    }
+  else
+    {
+      DBG (DBG_ERR, "CircBufferExit: Circular buffer not initialised!\n");
+    }
+}
+
+
+/************************************************************************/
+
+
+
+static int
+_CalcAvg (unsigned char *pabBuf, int n, int iStep)
+{
+  int i, j, x;
+
+  for (i = j = x = 0; i < n; i++)
+    {
+      x += pabBuf[j];
+      j += iStep;
+    }
+  return (x / n);
+}
+
+
+/* converts white line data and black point data into a calibration table */
+static void
+CreateCalibTable (unsigned char *abWhite, unsigned char bBlackR,
+		  unsigned char bBlackG, unsigned char bBlackB,
+		  int iReversedHead, unsigned char *pabCalibTable)
+{
+  int i, j, iGain, iOffset, iData;
+  unsigned char *pabPixel;
+
+  j = 0;
+  for (i = 0; i < HW_PIXELS; i++)
+    {
+      if (iReversedHead)
+	{
+	  pabPixel = &abWhite[(HW_PIXELS - i - 1) * 3];
+	}
+      else
+	{
+	  pabPixel = &abWhite[i * 3];
+	}
+      /* red */
+      if (bBlackR > 16)
+	bBlackR = 16;
+      iGain = 65536 / MAX (1, pabPixel[0] - bBlackR);
+      iOffset = bBlackR * 4;
+      if (iOffset > 63)
+	iOffset = 63;
+      iData = (iGain << 6) + iOffset;
+      pabCalibTable[j++] = (iData) & 255;
+      pabCalibTable[j++] = (iData >> 8) & 255;
+      /* green */
+      if (bBlackG > 16)
+	bBlackG = 16;
+      iGain = 65536 / MAX (1, pabPixel[1] - bBlackG);
+      iOffset = bBlackG * 4;
+      if (iOffset > 63)
+	iOffset = 63;
+      iData = (iGain << 6) + iOffset;
+      pabCalibTable[j++] = (iData) & 255;
+      pabCalibTable[j++] = (iData >> 8) & 255;
+      /* blue */
+      if (bBlackB > 16)
+	bBlackB = 16;
+      iGain = 65536 / MAX (1, pabPixel[2] - bBlackB);
+      iOffset = bBlackB * 4;
+      if (iOffset > 63)
+	iOffset = 63;
+      iData = (iGain << 6) + iOffset;
+      pabCalibTable[j++] = (iData) & 255;
+      pabCalibTable[j++] = (iData >> 8) & 255;
+    }
+}
+
+
+/*************************************************************************
+  Lamp control functions
+*************************************************************************/
+STATIC SANE_Bool
+GetLamp (THWParams * pHWParams, SANE_Bool * pfLampIsOn)
+{
+  unsigned char bData;
+
+  NiashReadReg (pHWParams->iXferHandle, 0x03, &bData);
+  *pfLampIsOn = ((bData & 0x01) != 0);
+  return SANE_TRUE;
+}
+
+
+STATIC SANE_Bool
+SetLamp (THWParams * pHWParams, SANE_Bool fLampOn)
+{
+  unsigned char bData;
+  int iHandle;
+
+  iHandle = pHWParams->iXferHandle;
+
+  NiashReadReg (iHandle, 0x03, &bData);
+  if (fLampOn)
+    {
+      NiashWriteReg (iHandle, 0x03, bData | 0x01);
+    }
+  else
+    {
+      NiashWriteReg (iHandle, 0x03, bData & ~0x01);
+    }
+  return SANE_TRUE;
+}
+
+
+/*************************************************************************
+  Experimental simple calibration, but also returning the white levels
+*************************************************************************/
+STATIC SANE_Bool
+SimpleCalibExt (THWParams * pHWPar, unsigned char *pabCalibTable,
+		unsigned char *pabCalWhite)
+{
+  unsigned char bMinR, bMinG, bMinB;
+  TDataPipe DataPipe;
+  TScanParams Params;
+  unsigned char abGamma[4096];
+  int i, j;
+  static unsigned char abBuf[HW_PIXELS * 3 * 71];	/* Carefull : see startWhite and endWhite below */
+  static unsigned char abLine[HW_PIXELS * 3];
+  static unsigned char abWhite[HW_PIXELS * 3];
+  unsigned char *pabWhite;
+  int iWhiteR, iWhiteG, iWhiteB;
+  int iHandle;
+  SANE_Bool iReversedHead;
+  int startWhiteY, endWhiteY;
+  int startBlackY, endBlackY;
+  int startBlackX, endBlackX;
+
+  iHandle = pHWPar->iXferHandle;
+  iReversedHead = pHWPar->iReversedHead;
+
+  DataPipe.iSkipLines = pHWPar->iSkipLines;
+
+  Params.iDpi = HW_DPI;
+  Params.iLpi = HW_DPI;
+  if (iReversedHead)		/* hp scanners */
+    Params.iTop = 60;
+  else				/* agfa scanners */
+    Params.iTop = 30;
+  Params.iBottom = HP3300C_BOTTOM;
+  Params.iLeft = 0;
+  Params.iWidth = HW_PIXELS;
+  Params.iHeight = 54;
+  Params.fCalib = SANE_TRUE;
+
+  /* write gamma table with neutral gain / offset */
+  CalcGamma (abGamma, 1.0);
+  WriteGammaCalibTable (abGamma, abGamma, abGamma, NULL, 256, 0, pHWPar);
+
+  if (!InitScan (&Params, pHWPar))
+    {
+      if (pabCalWhite)
+	pabCalWhite[0] = pabCalWhite[1] = pabCalWhite[2] = 0;
+      return SANE_FALSE;
+    }
+
+  /* Definition of white and black areas */
+  if (iReversedHead)
+    {				/* hp scanners */
+      startWhiteY = 0;
+      endWhiteY = 15;
+      startBlackY = 16;
+      endBlackY = 135;
+      startBlackX = 0;
+      endBlackX = HW_PIXELS;
+    }
+  else
+    {				/* agfa scanners */
+      startWhiteY = 0;
+      endWhiteY = 70;
+      startBlackY = 86;
+      endBlackY = 135;
+      startBlackX = 1666;
+      endBlackX = 3374;
+    }
+
+  CircBufferInit (iHandle, &DataPipe, HW_PIXELS, -1, Params.iLpi / 150,
+		  iReversedHead, 1, 1);
+  /* white level */
+  /* skip some lines */
+  for (i = 0; i < startWhiteY; i++)
+    {
+      CircBufferGetLine (iHandle, &DataPipe, abLine, iReversedHead);
+    }
+  /* Get white lines */
+  for (i = 0; i < endWhiteY - startWhiteY + 1; i++)
+    {
+      CircBufferGetLine (iHandle, &DataPipe, &abBuf[i * HW_PIXELS * 3],
+			 iReversedHead);
+    }
+  /* black level */
+  bMinR = 255;
+  bMinG = 255;
+  bMinB = 255;
+  /* Skip some lines */
+  for (i = 0; i < startBlackY; i++)
+    {
+      CircBufferGetLine (iHandle, &DataPipe, abLine, iReversedHead);
+    }
+  for (i = 0; i < endBlackY - startBlackY + 1; i++)
+    {
+      CircBufferGetLine (iHandle, &DataPipe, abLine, iReversedHead);
+      for (j = 0; j < endBlackX; j++)
+	{
+	  bMinR = MIN (abLine[j * 3 + 0], bMinR);
+	  bMinG = MIN (abLine[j * 3 + 1], bMinG);
+	  bMinB = MIN (abLine[j * 3 + 2], bMinB);
+	}
+    }
+  CircBufferExit (&DataPipe);
+  FinishScan (pHWPar);
+
+  /* calc average white level */
+  pabWhite = abBuf;
+  for (i = 0; i < HW_PIXELS; i++)
+    {
+      abWhite[i * 3 + 0] =
+	_CalcAvg (&pabWhite[i * 3 + 0], endWhiteY - startWhiteY + 1,
+		  HW_PIXELS * 3);
+      abWhite[i * 3 + 1] =
+	_CalcAvg (&pabWhite[i * 3 + 1], endWhiteY - startWhiteY + 1,
+		  HW_PIXELS * 3);
+      abWhite[i * 3 + 2] =
+	_CalcAvg (&pabWhite[i * 3 + 2], endWhiteY - startWhiteY + 1,
+		  HW_PIXELS * 3);
+    }
+  iWhiteR = _CalcAvg (&abWhite[0], HW_PIXELS, 3);
+  iWhiteG = _CalcAvg (&abWhite[1], HW_PIXELS, 3);
+  iWhiteB = _CalcAvg (&abWhite[2], HW_PIXELS, 3);
+
+  DBG (DBG_MSG, "Black level (%d,%d,%d), White level (%d,%d,%d)\n",
+       (int) bMinR, (int) bMinG, (int) bMinB, iWhiteR, iWhiteG, iWhiteB);
+
+  /* convert the white line and black point into a calibration table */
+  CreateCalibTable (abWhite, bMinR, bMinG, bMinB, iReversedHead,
+		    pabCalibTable);
+  /* assign the White Levels */
+  if (pabCalWhite)
+    {
+      pabCalWhite[0] = iWhiteR;
+      pabCalWhite[1] = iWhiteG;
+      pabCalWhite[2] = iWhiteB;
+    }
+  return SANE_TRUE;
+}
+
+
+/*************************************************************************
+  FinishScan
+  ==========
+    Finishes the scan. Makes the scanner head move back to the home position.
+
+*************************************************************************/
+STATIC void
+FinishScan (THWParams * pHWParams)
+{
+  NiashWriteReg (pHWParams->iXferHandle, 0x02, 0x80);
+}