Attachment #172397 for bug #247605

Line 0 Link Here

(-)sane-backends-1.0.19/backend/dll.conf (+1 lines)
	1	hp_rts88xx




   /* sane - Scanner Access Now Easy.
   Copyright (C) 2003 Johannes Hub (JohannesHub@t-online.de)

   This file was initially copied from the hp3300 backend.

   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 exutable, 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.
*/

/*
    Concept for a backend for scanners based on the RTS88xx chipset,
    such as HP4400C, HP4470C, HP3500C, 3530C, and HP ScanJet 3570C.
    Parts of this source were inspired by other backends.

		History:

		Version 0.18  21.11.04 13.alpha,
				- source sorted,
				- now only SANEI_USB_SUPPORT for a better overview(xfermodules removed)
				- read and verify the MainBoardID 
		Version 0.17p 02.11.04 12.alpha, source sorted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17p 02.11.04 12.alpha, source sourted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17b 30.03.04 10.alpha, little fixes and libusb implemented
		Version 0.17  09.03.04 9. alpha, HP3500 included
		Version 0.16  06.02.04 8. alpha, wait counting on LCD
		Version 0.15a 29.01.04 7. alpha, CCD switch moved to config file
		Version 0.15  11.01.04 6. alpha, a second CCD implemented
		Version 0.13a 21.11.04 4. alpha, an little fix included
		Version 0.12  22.10.03 third alpha, Backend name changed to HP_RTS88xx
		Version 0.11  30.08.03 second alpha
		Version 0.10  19.07.03 first alpha
*/

/*
		enable DEDUG output:
		use a nomal shell (konsole) and type
		export SANE_DEBUG_HP_RTS88XX=32
		xsane
*/

#ifndef BACKEND_NAME
#define BACKEND_NAME hp_rts88xx
#endif
#ifndef BUILD
#define BUILD 18
#endif

/*#define STANDALONE*/
/*#define ENABLE_VI8920*/

/* definitions for debug */
#define DEBUG								/* debug output */
/*#define DEBUG_HP3500			* debug switch to test the 3500 code under hp4470c */
/*#define STOP_HP3500_1*/

/*#define DEBUG_SCAN					* debug output about getting the immage datas */
/*#define DEBUG_L							* don't wait for lamp warm up */
/*#define USBDEBUG					* debug output about the USB in/out */
/*#define DEBUG_FILE				* additional write into a pnm file (not allowed as driver)*/

#include <stdlib.h>					/* malloc, free */
#include <string.h>					/* memcpy */
#include <stdio.h>
#include "../include/sane/sane.h"
#include "../include/sane/config.h"
#include "../include/sane/sanei.h"
#include "../include/sane/sanei_config.h"
#include "../include/sane/saneopts.h"

#ifdef STANDALONE
	#define V_MAJOR 1
	#define V_MINOR 15
	#define PATH_MAX 128
	#define DBG          fprintf
	#define DBG_MSG      stdout
	#define DBG_USB      stdout
	#define DBG_OPT      stdout
	#define DBG_SCAN     stdout
	#define DBG_ASSERT   stdout
	#define DBG_ERR      stdout
#else
#include "../include/sane/sanei_backend.h"
	#define DBG_ASSERT  1
	#define DBG_ERR     2
	#define DBG_MSG     16
	#define DBG_SCAN    32
	#define DBG_OPT     64
	#define DBG_USB     128
#endif

#define HP_RTS_CONFIG_FILE "hp_rts88xx.conf"

#include "hp_rts88xx.h"
#include "hp_rts_44x0c.h"
#include "hp_rts_35x0c.h"

/* (source) includes for data transfer methods */
#include "hp_rts_xfer.c"
/* (source) includes for special scanner code */
#include "hp_rts_44x0c.c"
#include "hp_rts_35x0c.c"


/****************************************************************************/
SANE_Bool _InitScan(TScanParams *pParams, THWParams *pHWParams, TDataPipe *pDataPipe)
/****************************************************************************/
{
	SANE_Int	iHandle;
	SANE_Bool result;
	iHandle = pHWParams->iXferHandle;

	result = SANE_FALSE;
	/* check validity of scanparameters */
	switch (pParams->iDpi) {
		case 150:
		case 200:
		case 300:
		case 600:
		break;
	default:
		DBG(DBG_ERR, "InitScan: Invalid dpi (%d)\n", pParams->iDpi);
		return SANE_FALSE;
	}
	switch (pParams->iLpi) {
		case 150:
		case 200:
		case 300:
		case 600:
		break;
	default:
		DBG(DBG_ERR, "InitScan: Invalid lpi (%d)\n", pParams->iLpi);
		return SANE_FALSE;
	}
	/*   *** Done checking scan parameters validity ***  */
	switch (pHWParams->ScannerModel) {
		case eHp3500c: case eHp3530c:
#ifdef ENABLE_VI8920
	  case eVi8920:
#endif
			result = Hp35x0c_init_scan(pHWParams,pParams,pDataPipe);
				if (result)
					DBG(DBG_ERR, "InitScan: OK\n");
				else
					DBG(DBG_ERR, "InitScan: ERROR from Hp35x0_init_scan\n");
			break;
		case eHp4400c: case eHp4470c:
			if (Hp44x0_cal_scanner(pHWParams,pParams) == SANE_TRUE){
				result = Hp44x0_init_scan(pHWParams,pParams,pDataPipe);
				if (result)
					DBG(DBG_ERR, "InitScan: OK\n");
				else
					DBG(DBG_ERR, "InitScan: ERROR from Hp44x0_init_scan\n");
			}
			break;
		case eUnknownModel:
		default:
			DBG(DBG_ERR, "InitScan: ERROR: unknown model! (%d)\n",
					(SANE_Int)pHWParams->ScannerModel);
			result = SANE_FALSE;
			break;
  }
	return result;
}

/****************************************************************************
	_FinishScan
	=================
	Finishes the scan. Makes the scanner head move back to the home position.
****************************************************************************/
SANE_Bool _FinishScan( SANE_Handle h )
{
	TScanner *s;
	THWParams *pHWParams;
	TScanParams *pParams;
	SANE_Int iHandle;
	SANE_Word size;

	s = (TScanner *)h;

	iHandle		= s->HWParams.iXferHandle;
	pHWParams	= &s->HWParams;
	pParams		= &s->ScanParams;

	DBG(DBG_MSG,"Finish scan:\n");
  /* check, if the scanner moving */
	if (Hp_rts_is_moving(iHandle)){
		DBG(DBG_MSG,"Finish scan, scanner is moving, stop it!!!\n");
		Hp_rts_stop_moving(iHandle);
	};
	usleep(100);
	
	/* clean the Scanner Buffer */
	do{
		/*if ( !*/(Hp_rts_data_ready(iHandle,&size));/*) return SANE_FALSE;*/
		if ( size > 0)
			if ( !(Hp_rts_read_data(iHandle,size,s->DataPipe.pabXferBuf))) return SANE_FALSE;
	} while (size != 0);

	DBG(DBG_MSG,"Finish scan, park to home\n");
	switch (pHWParams->ScannerModel) {
		case eHp3500c: case eHp3530c: case eHp3570c:
#ifdef ENABLE_VI8920
	  case eVi8920:
#endif
			Hp35x0c_rewind(pHWParams);
			break;
		case eHp4400c: case eHp4470c:
			Hp44x0_park_to_home(pHWParams,pParams);
			break;
		default:
			DBG(DBG_ERR, "FinishScan: ERROR: unknown model! (%d) %s\n",
					(SANE_Int)pHWParams->ScannerModel, ScannerModels[(SANE_Int)pHWParams->ScannerModel].pszName);
		return SANE_FALSE;
  }
	return SANE_TRUE;
}


/****************************************************************************/
static SANE_Int
_max_string_size (const SANE_String_Const strings[])
/****************************************************************************/
{
	SANE_Int size, max_size = 0;
	SANE_Int i;

	for (i = 0; strings[i]; ++i) {
		size = strlen (strings[i]) + 1;
		if (size > max_size)
			max_size = size;
	}
	return max_size;
}


/****************************************************************************/
SANE_Status _Init_Interface(THWParams *pHWParams, TScanParams *pParams)
/****************************************************************************/
{

	DBG(DBG_SCAN, "Init_Interface....\n");
	/* autodetect some hardware properties */
	if (Hp_rts_ProbeRegisters(pHWParams) != SANE_STATUS_GOOD) {
		DBG(DBG_ERR, "Init_Interface: Hp_rts_ProbeRegisters failed!\n");
		return SANE_STATUS_IO_ERROR;
	}
	/* default HW params */
	pHWParams->iTopLeftX      = 0;
	pHWParams->iTopLeftY      = 3;
	pHWParams->iReversedHead  = SANE_FALSE;
	DBG(DBG_MSG, "Init_Interface: Use scanner (%d) %s\n",
 		(SANE_Int)pHWParams->ScannerModel,ScannerModels[pHWParams->ScannerModel].pszName);
	switch (pHWParams->ScannerModel) {

		case eHp3500c: case eHp3530c:
#ifdef ENABLE_VI8920
		case eVi8920:
#endif
			pHWParams->iTopLeftX    = 7;
#ifndef DEBUG_HP3500
			Hp35x0c_init_power_on(pHWParams);
#else
			if ( !(Hp44x0_Wakeup(pHWParams, pParams))) return SANE_STATUS_IO_ERROR;
			if ( !(Hp44x0_cal_scanner(pHWParams, pParams))) return SANE_STATUS_IO_ERROR;
#endif
			break;
		case eHp4400c: case eHp4470c:
			pHWParams->iTopLeftX    = 7;
			if ( !(Hp44x0_Wakeup(pHWParams, pParams))) return SANE_STATUS_IO_ERROR;
			if ( !(Hp44x0_cal_scanner(pHWParams, pParams))) return SANE_STATUS_IO_ERROR;
			if ( !(Hp44x0_park_to_home(pHWParams, pParams))) return SANE_STATUS_IO_ERROR;
			break;
		case eUnknownModel:
		default:
			DBG(DBG_ERR, "Init_Interface: ERROR: internal error! (%d)\n",
		 		(SANE_Int)pHWParams->ScannerModel);
			return SANE_STATUS_UNSUPPORTED;
	}
	return SANE_STATUS_GOOD;
}


/****************************************************************************/
void _Close_Interface(THWParams *pHWParams)
/****************************************************************************/
{
	DBG(DBG_MSG, "Close_Interface: ..\n");
	switch (pHWParams->ScannerModel) {
		case eHp3500c: case eHp3530c:
#ifdef ENABLE_VI8920
	  case eVi8920:
#endif
			Hp35x0c_turn_off_lamp(pHWParams->iXferHandle);
			Hp35x0c_set_powersave_mode(pHWParams->iXferHandle,1);
			break;
		case eHp4400c: case eHp4470c:
			/* turn of scanner lamp */
			Hp44x0_SetLamp(pHWParams->iXferHandle, SANE_FALSE);
			Hp44x0_Down(pHWParams->iXferHandle);
			break;
		case eUnknownModel:
		default:
			DBG(DBG_ERR, "Close_Interface: ERROR: internal error! (%d)\n", (SANE_Int)pHWParams->ScannerModel);
			return;
	}
	Hp_rts_XferExit(pHWParams->iXferHandle);
	pHWParams->iXferHandle = 0;
}

/****************************************************************************/
static void SANE_InitOptions(TScanner *s)
/****************************************************************************/
{
	SANE_Int i, Model;
	SANE_Option_Descriptor *pDesc;
	TOptionValue *pVal;

	Model = s->HWParams.ScannerModel;
	DBG(DBG_SCAN, "SANE_InitOptions: Use model # %d\n", Model);
	/* set a neutral gamma */
	if( s->aGammaTableR == NULL )   /* Not yet allocated */
	{
		s->aGammaTableR = malloc( NUM_GAMMA_ENTRIES * sizeof( SANE_Int ) );
		s->aGammaTableG = malloc( NUM_GAMMA_ENTRIES * sizeof( SANE_Int ) );
		s->aGammaTableB = malloc( NUM_GAMMA_ENTRIES * sizeof( SANE_Int ) );

		for (i = 0; i < NUM_GAMMA_ENTRIES; i++) {
			s->aGammaTableR[i] = i;
			s->aGammaTableG[i] = i;
			s->aGammaTableB[i] = i;
		}
	}

	if ( (Model==eHp4400c) || (Model==eHp4470c) ){
		DBG(DBG_MSG,"SANE_InitOptions: use HP4x00 mode\n");
/*		mode_list[0]="B/W";*/
		mode_list[0]="Gray";
		mode_list[1]=NULL;
		if (OPT_COLOR){
			mode_list[1]="Color";
			mode_list[2]=NULL;
		}
	}else
	{ /* hp35x0 */
		DBG(DBG_MSG,"SANE_InitOptions: use HP35x0 mode\n");
		/*	mode_list[0]="B/W";*/
		mode_list[0]="Gray"; /**/
		mode_list[1]=NULL;
		if (OPT_COLOR){
			mode_list[1]="Color";
			mode_list[2]=NULL;
		}
	}

	ccd_list[0]="CCDType 0";
	ccd_list[1]="CCDType 1";
	ccd_list[2]=NULL;

	scan_option_list[0]="bed light";
	scan_option_list[1]="XPA";
	scan_option_list[2]=NULL;

	for (i = optCount; i < optLast; i++) {

		pDesc = &s->aOptions[i];
		pVal = &s->aValues[i];

		/* defaults */
		pDesc->name   = "";
		pDesc->title  = "";
		pDesc->desc   = "";
		pDesc->type   = SANE_TYPE_INT;
		pDesc->unit   = SANE_UNIT_NONE;
		pDesc->size   = sizeof(SANE_Word);
		pDesc->constraint_type = SANE_CONSTRAINT_NONE;
		pDesc->cap    = 0;

		switch (i) {

			case optCount:
				pDesc->title  = SANE_TITLE_NUM_OPTIONS;
				pDesc->desc   = SANE_DESC_NUM_OPTIONS;
				pDesc->cap    = SANE_CAP_SOFT_DETECT;
				pVal->w       = (SANE_Word)optLast;
			break;

			case optGroupGeometry:
				pDesc->title  = "Geometry";
				pDesc->type   = SANE_TYPE_GROUP;
				pDesc->size   = 0;
			break;

			case optTLX:
				pDesc->name   = SANE_NAME_SCAN_TL_X;
				pDesc->title  = SANE_TITLE_SCAN_TL_X;
				pDesc->desc   = SANE_DESC_SCAN_TL_X;
				pDesc->unit   = SANE_UNIT_MM;
				pDesc->constraint_type  = SANE_CONSTRAINT_RANGE;
				pDesc->cap    = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
				pDesc->constraint.range = &rangeXmm;
				pVal->w       = rangeXmm.min;
			break;

			case optTLY:
				pDesc->name   = SANE_NAME_SCAN_TL_Y;
				pDesc->title  = SANE_TITLE_SCAN_TL_Y;
				pDesc->desc   = SANE_DESC_SCAN_TL_Y;
				pDesc->unit   = SANE_UNIT_MM;
				pDesc->constraint_type  = SANE_CONSTRAINT_RANGE;
				pDesc->constraint.range = &rangeYmm;
				pDesc->cap    = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
				pVal->w       = rangeYmm.min;
			break;

			case optBRX:
				pDesc->name   = SANE_NAME_SCAN_BR_X;
				pDesc->title  = SANE_TITLE_SCAN_BR_X;
				pDesc->desc   = SANE_DESC_SCAN_BR_X;
				pDesc->unit   = SANE_UNIT_MM;
				pDesc->constraint_type  = SANE_CONSTRAINT_RANGE;
				pDesc->constraint.range = &rangeXmm;
				pDesc->cap    = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
				pVal->w       = rangeXmm.max;
			break;

			case optBRY:
				pDesc->name   = SANE_NAME_SCAN_BR_Y;
				pDesc->title  = SANE_TITLE_SCAN_BR_Y;
				pDesc->desc   = SANE_DESC_SCAN_BR_Y;
				pDesc->unit   = SANE_UNIT_MM;
				pDesc->constraint_type  = SANE_CONSTRAINT_RANGE;
				pDesc->constraint.range = &rangeYmm;
				pDesc->cap    = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
				pVal->w       = rangeYmm.max;
			break;

			case optDPI:
				pDesc->name   = SANE_NAME_SCAN_RESOLUTION;
				pDesc->title  = SANE_TITLE_SCAN_RESOLUTION;
				pDesc->desc   = SANE_DESC_SCAN_RESOLUTION;
				pDesc->unit   = SANE_UNIT_DPI;
				pDesc->constraint_type  = SANE_CONSTRAINT_WORD_LIST;
				pDesc->cap    = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
				if ((Model==eHp4400c) || (Model==eHp4470c) ){
					if (OPT_T_RES) {
						DBG(DBG_MSG,"SANE_InitOptions: use HP4x00 TEST mode \n");
						pDesc->constraint.word_list = Hp44x0c_setResolutions_t;
						pVal->w       = Hp44x0c_setResolutions_t[1];
					} else {
						DBG(DBG_MSG,"SANE_InitOptions: use HP4x00 normal mode \n");
						pDesc->constraint.word_list = Hp44x0c_setResolutions;
						pVal->w       = Hp44x0c_setResolutions[1];
					}
				}else{ /* it's a HP35xx */
					if (OPT_T_RES) {
						DBG(DBG_MSG,"SANE_InitOptions: use HP35x0 TEST mode \n");
						pDesc->constraint.word_list = Hp35x0c_setResolutions_t;
						pVal->w       = Hp35x0c_setResolutions_t[1];
					} else {
						DBG(DBG_MSG,"SANE_InitOptions: use HP35x0 normal mode \n");
						pDesc->constraint.word_list = Hp35x0c_setResolutions;
						pVal->w       = Hp35x0c_setResolutions[1];
				}
				}
			break;

			case optGroupImage:
				pDesc->title  = SANE_I18N("Image");
				pDesc->type   = SANE_TYPE_GROUP;
				pDesc->size   = 0;
			break;

			case optGammaTableRed:
				pDesc->name   = SANE_NAME_GAMMA_VECTOR_R;
				pDesc->title  = SANE_TITLE_GAMMA_VECTOR_R;
				pDesc->desc   = SANE_DESC_GAMMA_VECTOR_R;
				pDesc->size   = NUM_GAMMA_ENTRIES * sizeof( SANE_Int );
				pDesc->constraint_type = SANE_CONSTRAINT_RANGE;
				pDesc->constraint.range = &rangeGammaTable;
				pDesc->cap    = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
				pVal->wa      = s->aGammaTableR;
			break;

			case optGammaTableGreen:
				pDesc->name   = SANE_NAME_GAMMA_VECTOR_G;
				pDesc->title  = SANE_TITLE_GAMMA_VECTOR_G;
				pDesc->desc   = SANE_DESC_GAMMA_VECTOR_G;
				pDesc->size   = NUM_GAMMA_ENTRIES * sizeof( SANE_Int );
				pDesc->constraint_type = SANE_CONSTRAINT_RANGE;
				pDesc->constraint.range = &rangeGammaTable;
				pDesc->cap    = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
				pVal->wa      = s->aGammaTableG;
			break;

			case optGammaTableBlue:
				pDesc->name   = SANE_NAME_GAMMA_VECTOR_B;
				pDesc->title  = SANE_TITLE_GAMMA_VECTOR_B;
				pDesc->desc   = SANE_DESC_GAMMA_VECTOR_B;
				pDesc->size   = NUM_GAMMA_ENTRIES * sizeof( SANE_Int );
				pDesc->constraint_type = SANE_CONSTRAINT_RANGE;
				pDesc->constraint.range = &rangeGammaTable;
				pDesc->cap    = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
				pVal->wa      = s->aGammaTableB;
			break;

			case optGroupMisc:
				pDesc->title = SANE_I18N ("Miscellaneous");
				pDesc->type  = SANE_TYPE_GROUP;
				pDesc->size  = 0;
			break;

			case optBrightness:
				pDesc->name   = SANE_NAME_BRIGHTNESS;
				pDesc->title  = SANE_TITLE_BRIGHTNESS;
				pDesc->desc   = SANE_DESC_BRIGHTNESS;
				pDesc->type   = SANE_TYPE_INT;
				pDesc->size   = sizeof(SANE_Int);
				pDesc->unit   = SANE_UNIT_NONE;
				pDesc->constraint_type  = SANE_CONSTRAINT_RANGE;
				pDesc->constraint.range = &rangeBrightness;
				pDesc->cap    = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
				pVal->w       = 10;
			break;

			case OPT_MODE:
				pDesc->name   = SANE_NAME_SCAN_MODE;
				pDesc->title  = SANE_TITLE_SCAN_MODE;
				pDesc->desc   = SANE_DESC_SCAN_MODE;
				pDesc->type   = SANE_TYPE_STRING;
				pDesc->constraint_type  = SANE_CONSTRAINT_STRING_LIST;
				pDesc->size   = _max_string_size (mode_list);
				pDesc->constraint.string_list = mode_list;
				pVal->s       = strdup (mode_list[0]);
				pDesc->cap    = ~SANE_CAP_INACTIVE;
			break;

			case optXPDA:
				pDesc->name   = SANE_NAME_SCAN_SOURCE;
				pDesc->title  = SANE_TITLE_SCAN_SOURCE;
				pDesc->desc   = SANE_I18N("Switches the scaner source mode (normal/xPDA).");
				pDesc->type   = SANE_TYPE_STRING;
				pDesc->constraint_type  = SANE_CONSTRAINT_STRING_LIST;
				pDesc->size   = _max_string_size (scan_option_list);
				pDesc->constraint.string_list = scan_option_list;
				pVal->s       = strdup (scan_option_list[0]);
				if (Model == eHp4470c)
					pDesc->cap    = ~SANE_CAP_INACTIVE;
				else
					pDesc->cap    = SANE_CAP_INACTIVE;
				s->ScanParams.optXPA = SANE_FALSE;
			break;

			case optCCD:
				pDesc->name   = SANE_NAME_SCAN_SOURCE;
				pDesc->title  = "CCD_Type";
				pDesc->desc   = SANE_I18N("Switches the scaner CCD mode (0/1).");
				pDesc->type   = SANE_TYPE_STRING;
				pDesc->constraint_type  = SANE_CONSTRAINT_STRING_LIST;
				pDesc->size   = _max_string_size (ccd_list);
				pDesc->constraint.string_list = ccd_list;
				pVal->s       = strdup (ccd_list[0]);
				if ((Model==eHp4400c) || (Model==eHp4470c) ){
					if (OPT_CCD){
						pDesc->cap    = ~SANE_CAP_INACTIVE;
						s->ScanParams.oCCD_Type = 0;
					} else
						pDesc->cap    = SANE_CAP_INACTIVE;
				}else
					pDesc->cap    = SANE_CAP_INACTIVE;
			break;

			case optGainR:
				pDesc->name   = "optGainR";
				pDesc->title  = "optGainR";
				pDesc->desc   = SANE_I18N("optGainR");
				pDesc->type   = SANE_TYPE_INT;
				pDesc->size   = sizeof(SANE_Int);
				pDesc->unit   = SANE_UNIT_NONE;
				pDesc->constraint_type  = SANE_CONSTRAINT_RANGE;
				pDesc->constraint.range = &rangeBrightness;
				pDesc->cap    = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
				pVal->w       = 0x0a;
			break;
			case optGainG:
				pDesc->name   = "optGainG";
				pDesc->title  = "optGainG";
				pDesc->desc   = SANE_I18N("optGainG");
				pDesc->type   = SANE_TYPE_INT;
				pDesc->size   = sizeof(SANE_Int);
				pDesc->unit   = SANE_UNIT_NONE;
				pDesc->constraint_type  = SANE_CONSTRAINT_RANGE;
				pDesc->constraint.range = &rangeBrightness;
				pDesc->cap    = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
				pVal->w       = 0x0a;
			break;
			case optGainB:
				pDesc->name   = "optGainB";
				pDesc->title  = "optGainB";
				pDesc->desc   = SANE_I18N("optGainB");
				pDesc->type   = SANE_TYPE_INT;
				pDesc->size   = sizeof(SANE_Int);
				pDesc->unit   = SANE_UNIT_NONE;
				pDesc->constraint_type  = SANE_CONSTRAINT_RANGE;
				pDesc->constraint.range = &rangeBrightness;
				pDesc->cap    = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
				pVal->w       = 0x0a;
			break;

			default:
				DBG(DBG_ERR, "InitOptions: Uninitialised option %d\n", i);
			break;
		}
	}
}

/****************************************************************************/
SANE_Status
sane_init(SANE_Int *piVersion, SANE_Auth_Callback pfnAuth)
/****************************************************************************/
{
	SANE_Char line[PATH_MAX];
	SANE_Char *word;
	SANE_String_Const cp;
	SANE_Int linenumber;
	FILE *conf_fp;
	TScanner *s;

/* prevent compiler from complaing about unused parameters */
	pfnAuth = pfnAuth;
	s = malloc (sizeof (TScanner));
	if (!s)
	{
		DBG (DBG_MSG,"sane_init : malloc failed\n");
		return SANE_STATUS_NO_MEM;
	}

#ifndef STANDALONE
	DBG_INIT();
	DBG (DBG_MSG, "SANE HP_RTS88XX USB backend version %d.%d build %d from %s\n", V_MAJOR,
		V_MINOR, BUILD, PACKAGE_STRING);
#else
	DBG (DBG_MSG, "SANE HP_RTS88XX USB backend version %d.%d build %d from \n", V_MAJOR,
		V_MINOR, BUILD);
#endif

	iNumSaneDev = 0;
	_pFirstSaneDev = 0;

	/* initialise scanner object */
	DBG(DBG_OPT, "Init_Interface: call Hp_rts_XferInit\n");
	if ( Hp_rts_XferInit() != SANE_TRUE) {
		DBG(DBG_ERR, "Init_Interface: Hp_rts_XferInit failed\n");
		/* free scanner object memory */
		free ((void *) s);
		return SANE_STATUS_IO_ERROR;
	}
	/* free scanner object memory */
	free ((void *) s);
	DBG(DBG_OPT, "sane_init: call sanei_config_open\n");
	conf_fp = sanei_config_open (HP_RTS_CONFIG_FILE);
	if (conf_fp) {
		linenumber = 0;
		DBG (DBG_OPT, "sane_init: reading config file '%s'\n",HP_RTS_CONFIG_FILE);
		while (sanei_config_read (line, sizeof (line), conf_fp)) {
			word = 0;
			linenumber++;
			cp = sanei_config_get_string (line, &word);
			/* Discards white lines and comments*/
			if (!word || cp == line) {
				if (word)
					free (word);
				continue;
			}

			if (word[0] == '#') {
					free (word);
					continue;
			}
			if (strcmp (word, "option") == 0) {
				free (word);
				word = 0;
				cp = sanei_config_get_string (cp, &word);
				if (!word) {
					DBG (DBG_ERR,
						"sane_init: config file line %d: missing quotation mark?\n",
						linenumber);
					continue;
				}
				if (strcmp (word, "CCD0") == 0) {
					DBG(DBG_OPT,"sane_init: Find option '%s'\n",line);
					free (word);
					word = 0;
					OPT_CCD = SANE_FALSE;
					s->ScanParams.oCCD_Type = 0;
					continue;
				}
				if (strcmp (word, "CCD1") == 0) {
					DBG(DBG_OPT,"sane_init: Find option '%s'\n",line);
					free (word);
					word = 0;
					OPT_CCD = SANE_FALSE;
					s->ScanParams.oCCD_Type = 1;
					continue;
				}
				if (strcmp (word, "ENABLE_COLOR") == 0) {
					DBG(DBG_OPT,"sane_init: Find option '%s'\n",line);
					free (word);
					word = 0;
					OPT_COLOR = SANE_TRUE;
					continue;
				}
				if (strcmp (word, "ENABLE_T_RES") == 0) {
					DBG(DBG_OPT,"sane_init: Find option '%s'\n",line);
					free (word);
					word = 0;
					OPT_T_RES = SANE_TRUE;
					continue;
				}
			}
		}  /*while*/
		fclose(conf_fp);
	}
	else {
		DBG (DBG_ERR, "sane_init: Unable to read config file \"%s\": %s\n",
		HP_RTS_CONFIG_FILE,strerror(errno));
		DBG (DBG_OPT, "sane_init: Using default built-in values\n");
	}
	if (piVersion != NULL) {
		*piVersion = SANE_VERSION_CODE (V_MAJOR, V_MINOR, BUILD);
	}
	return SANE_STATUS_GOOD;
}


/****************************************************************************/
void
sane_exit(void)
/****************************************************************************/
{
	TDevListEntry *pDev, *pNext;

	DBG(DBG_MSG, "sane_exit\n");

	/* free device list memory */
	if (_pSaneDevList)
	{
		for (pDev = _pFirstSaneDev; pDev; pDev = pNext)
		{
			pNext = pDev->pNext;
			free ((void *) pDev->dev.name);
			free (pDev);
		}
		_pFirstSaneDev = 0;
		free (_pSaneDevList);
		_pSaneDevList = 0;
	}
}

/****************************************************************************/
SANE_Status
sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
/****************************************************************************/
{
	TDevListEntry *pDev;
	SANE_Int i;
#if 0
	DBG (DBG_MSG, "sane_get_devices\n");
#endif
	local_only = local_only;

	if (_pSaneDevList)
	{
		free (_pSaneDevList);
	}

	_pSaneDevList = malloc (sizeof (*_pSaneDevList) * (iNumSaneDev + 1));
	if (!_pSaneDevList)
	{
		DBG (DBG_MSG, "sane_get_devices : no mem\n");
		return SANE_STATUS_NO_MEM;
	}
	i = 0;
	for (pDev = _pFirstSaneDev; pDev; pDev = pDev->pNext)
	{
		_pSaneDevList[i++] = &pDev->dev;
		DBG (DBG_MSG, "sane_get_devices: name %s\n",pDev->dev.name);
	}
	_pSaneDevList[i++] = 0;	/* last entry is 0 */

	 *device_list = _pSaneDevList;

	return SANE_STATUS_GOOD;
}

/****************************************************************************/
SANE_Status
sane_open(SANE_String_Const name, SANE_Handle *h)
/****************************************************************************/
{
	TScanner *s;

	DBG(DBG_MSG, "sane_open: %s\n", name);

	s = malloc (sizeof (TScanner));
	if (!s)
	{
		DBG (DBG_MSG,"sane_open : malloc failed\n");
		return SANE_STATUS_NO_MEM;
	}
	*h = s;

	s->HWParams.iXferHandle = Hp_rts_XferOpen (name,(EScannerModel *) &s->HWParams.ScannerModel);
#if 0
	DBG (DBG_MSG, "sane_open: s->HWParams.ScannerModel = %d\n",s->HWParams.ScannerModel);
#endif
	if (s->HWParams.iXferHandle < 0)
	{
		DBG (DBG_ERR, "sane_open: Hp_rts_XferOpen failed for '%s'\n", name);
		return SANE_STATUS_DEVICE_BUSY;
	}

	/* initialise scanner object */
#if 1 /* only for test, normaly 1 */
	s->HWParams.lamp_warm = SANE_FALSE;
#else
	s->HWParams.lamp_warm = SANE_TRUE; /*only for test */
#endif
	s->fScanning = SANE_FALSE;
  s->fCanceled = SANE_FALSE;

	s->aGammaTableR = NULL;
	s->aGammaTableG = NULL;
	s->aGammaTableB = NULL;

	if (_Init_Interface(&s->HWParams,&s->ScanParams) == SANE_STATUS_GOOD) {
		SANE_InitOptions((TScanner *)s);
	}
	else{
		DBG (DBG_ERR, "sane_open: _Init_Interface failed\n");
		s->HWParams.iXferHandle = -1;
		return SANE_STATUS_IO_ERROR;
	}
	return SANE_STATUS_GOOD;
}


/****************************************************************************/
void
sane_close(SANE_Handle h)
/****************************************************************************/
{
	TScanner *s;

	DBG(DBG_MSG, "sane_close\n");
	s = (TScanner *)h;
	/* close scanner */
	_Close_Interface(&s->HWParams);
	#ifdef DEBUG_FILE
	if ( s->ScanParams.DebugOpen ){
		fclose(s->ScanParams.FD_r);
		s->ScanParams.DebugOpen = SANE_FALSE;
	}
	#endif
	if ( s->aGammaTableR != NULL ){
		free(s->aGammaTableR);
		s->aGammaTableR = NULL;}
	if ( s->aGammaTableG != NULL ){
		free(s->aGammaTableG);
		s->aGammaTableG = NULL;}
	if ( s->aGammaTableB != NULL ){
		free(s->aGammaTableB);
		s->aGammaTableB = NULL;}

	/* free scanner object memory */
	free ((void *) s);
}


/****************************************************************************/
const SANE_Option_Descriptor *
sane_get_option_descriptor(SANE_Handle h, SANE_Int n)
/****************************************************************************/
{
	TScanner *s;

	DBG(DBG_OPT, "sane_get_option_descriptor %d\n", n);
	if ((n < optCount) || (n >= optLast)) {
		return NULL;
	}
	s = (TScanner *)h;
	return &s->aOptions[n];
}


/****************************************************************************/
SANE_Status
sane_control_option(SANE_Handle h, SANE_Int option, SANE_Action Action, void *pVal,
										SANE_Int *pInfo)
/****************************************************************************/
{
	TScanner    *s;
	SANE_Int    info;
	SANE_Status status;

	DBG(DBG_OPT,"sane_control_option: option %d, action %d\n", option, Action);
	s = (TScanner *)h;
	info = 0;

	if (option < 0 || option >= optLast)
		return SANE_STATUS_INVAL;

	if (pInfo != NULL)
		*pInfo = 0;

	/*************************************************/
	switch (Action) {
	/*************************************************/
		case SANE_ACTION_GET_VALUE:
			switch (option) {

				/* Get options of type SANE_Word */
				case optCount: case optDPI:
				case optTLX: case optTLY: case optBRX: case optBRY:
				case optBrightness: case optGainR: case optGainG: case optGainB:
					DBG(DBG_OPT,"sane_control_option: SANE_ACTION_GET_VALUE %d = %d\n", option,
							(SANE_Int)s->aValues[option].w);
					*(SANE_Word*)pVal = s->aValues[option].w;
				break;

				/* Get options of type SANE_Word array */
				case optGammaTableRed: case optGammaTableGreen: case optGammaTableBlue:
					DBG(DBG_OPT, "Reading gamma table\n");
					memcpy (pVal, s->aValues[option].wa, s->aOptions[option].size);
				break;

				/* Get options of type SANE_TYPE STRING */
				case OPT_MODE: case optXPDA: case optCCD:
					DBG(DBG_OPT,"sane_control_option: SANE_ACTION_GET_VALUE %s\n",s->aValues[option].s);
					status = sanei_constrain_value (s->aOptions + option, s->aValues[option].s,
										(SANE_Int *)info);
					strcpy ((char *)pVal, s->aValues[option].s);
					return SANE_STATUS_GOOD;
				break;

				default: ;
					DBG(DBG_ERR,"SANE_ACTION_GET_VALUE: Invalid option (%d)\n", option);
				break;
			}
		break;
		case SANE_ACTION_SET_VALUE:
			/* no changes while in mid-pass! */
			if (s->fScanning){
				DBG(DBG_ERR,"sane_control_option: SANE_ACTION_SET_VALUE not allowed during scan\n");
				return SANE_STATUS_DEVICE_BUSY;
			}
			status = sanei_constrain_value (s->aOptions + option, pVal, pInfo);
			if (status != SANE_STATUS_GOOD)
				return status;
			switch (option) {

				/* Set options of type SANE_Word */
				case optCount:
					return SANE_STATUS_INVAL;
				break;

				case optDPI: case optTLX: case optTLY: case optBRX: case optBRY:
				case optBrightness: case optGainR: case optGainG: case optGainB:
					DBG(DBG_OPT,"sane_control_option: SANE_ACTION_SET_VALUE %d to %d\n",
						option,*(SANE_Word *) pVal);
					info |= SANE_INFO_RELOAD_PARAMS;
					s->aValues[option].w = *(SANE_Word *) pVal;
				break;

				/* Get options of type SANE_Word array */
				case optGammaTableRed: case optGammaTableGreen: case optGammaTableBlue:
					DBG(DBG_OPT, "Writing gamma table\n");
					memcpy (s->aValues[option].wa, pVal, s->aOptions[option].size);
				break;

				/* Set options of type SANE_TYPE_STRING */
				case OPT_MODE: case optXPDA: case optCCD:
					DBG(DBG_OPT,"sane_control_option: SANE_ACTION_SET_String %d to %s\n",
							option,(char *)pVal);
					if (s->aValues[option].s)
						free (s->aValues[option].s);
					s->aValues[option].s = strdup (pVal);
					if (info)
						info |= SANE_INFO_RELOAD_OPTIONS | SANE_INFO_RELOAD_PARAMS;
				break;

				default: ;
					DBG(DBG_ERR,"SANE_ACTION_SET_VALUE: Invalid option (%d)\n", option);
					return SANE_STATUS_INVAL;
			} /* switch option */
			if (pInfo != NULL) {
				*pInfo = info;
			}
			break; /*case SANE_ACTION_SET_VALUE*/
		case SANE_ACTION_SET_AUTO:
			return SANE_STATUS_UNSUPPORTED;
		default: ;
			DBG(DBG_ERR,"sane_control_option: Invalid action (%d)\n", Action);
			return SANE_STATUS_INVAL;
	}
	return SANE_STATUS_GOOD;
}


/****************************************************************************/
SANE_Status
sane_get_parameters(SANE_Handle h, SANE_Parameters *p)
/****************************************************************************/
{
	TScanner *s;
	SANE_String val;

	s = (TScanner *)h;
	val = s->aValues[OPT_MODE].s;

	/* first do some checks */
	if (s->aValues[optTLX].w >= s->aValues[optBRX].w) {
		DBG(DBG_ERR,"sane_get_parameters: TLX should be smaller than BRX\n");
		s->aValues[optTLX].w = s->aValues[optBRX].w; /* new 17.06.03 JoHu */
		/* return SANE_STATUS_INVAL; / proper error code? */
	}
	if (s->aValues[optTLY].w >= s->aValues[optBRY].w) {
		DBG(DBG_ERR,"sane_get_parameters: TLY should be smaller than BRY\n");
		s->aValues[optTLY].w = s->aValues[optBRY].w; /* new 17.06.03 JoHu */
		/* return SANE_STATUS_INVAL; / proper error code? */
	}

	/* return the data */
	p->last_frame = SANE_TRUE;
	s->ScanParams.brightness = s->aValues[optBrightness].w;
	s->ScanParams.GainR = s->aValues[optGainR].w;
	s->ScanParams.GainG = s->aValues[optGainG].w;
	s->ScanParams.GainB = s->aValues[optGainB].w;
	p->depth = 8;

	if (!strcmp (s->aValues[optXPDA].s, "XPA")){
		s->ScanParams.optXPA = SANE_TRUE;
		DBG(DBG_MSG,"sane_get_parameters: set XPA to TRUE\n");
	}else{
		s->ScanParams.optXPA = SANE_FALSE;
		DBG(DBG_MSG,"sane_get_parameters: set XPA to FALSE\n");
	}

	if (s->aOptions[optCCD].cap != SANE_CAP_INACTIVE){
		if (!strcmp (s->aValues[optCCD].s, "CCDType 0")){
			s->ScanParams.oCCD_Type = 0;
			DBG(DBG_MSG,"sane_get_parameters: set CCD to 0\n");
		}
		if (!strcmp (s->aValues[optCCD].s, "CCDType 1")){
			s->ScanParams.oCCD_Type = 1;
			DBG(DBG_MSG,"sane_get_parameters: set CCD to 1\n");
		}
	}

	if (!strcmp (val, "Color")){
		s->ScanParams.mode = COLOR;
		DBG(DBG_MSG,"sane_get_parameters: switch to color 24 bit!\n");
		p->format = SANE_FRAME_RGB;
	}else{
		if (!strcmp (val, "B/W")){
			DBG(DBG_MSG,"sane_get_parameters:  switch to B/W 8 bit\n");
			s->ScanParams.mode = BLACK_WHITE;
			p->format = SANE_FRAME_GRAY;
			p->depth = 1;
		} else {
			DBG(DBG_MSG,"sane_get_parameters:  switch to gray 8 bit\n");
			s->ScanParams.mode = GRAY;
			p->format = SANE_FRAME_GRAY;
		}
	}
	p->lines = MM_TO_PIXEL(s->aValues[optBRY].w - s->aValues[optTLY].w,
													s->aValues[optDPI].w);
	p->pixels_per_line = MM_TO_PIXEL(s->aValues[optBRX].w - s->aValues[optTLX].w,
													s->aValues[optDPI].w);
	p->bytes_per_line = p->pixels_per_line;
	/* fill in the scanparams using the option values */
	s->ScanParams.iLinesLeft = p->lines;
	s->ScanParams.iDpi = s->aValues[optDPI].w;
	s->ScanParams.iLpi = s->aValues[optDPI].w;
	s->ScanParams.iWidth = p->pixels_per_line;
	s->ScanParams.iLenght = p->lines;
	s->ScanParams.fCalib = SANE_FALSE;

	switch (s->ScanParams.iDpi) {
		case 150:
			s->ScanParams.iY =
				MM_TO_PIXEL(s->aValues[optTLY].w + s->HWParams.iTopLeftY, 150);
			s->ScanParams.iX =
				MM_TO_PIXEL(s->aValues[optTLX].w + s->HWParams.iTopLeftX, 150);
		break;
		case 300:
			s->ScanParams.iY =
				MM_TO_PIXEL(s->aValues[optTLY].w + s->HWParams.iTopLeftY, 300);
			s->ScanParams.iX =
				MM_TO_PIXEL(s->aValues[optTLX].w + s->HWParams.iTopLeftX, 300);
		break;
		case 600:
			s->ScanParams.iY =
				MM_TO_PIXEL(s->aValues[optTLY].w + s->HWParams.iTopLeftY, 600);
			s->ScanParams.iX =
				MM_TO_PIXEL(s->aValues[optTLX].w + (s->HWParams.iTopLeftX / 2), 600);
		break;
		default:
		DBG(DBG_MSG,"sane_get_parameters: invalid resolution !");
		return SANE_STATUS_INVAL;
	}
	if (s->ScanParams.mode == COLOR)
		p->bytes_per_line = p->bytes_per_line * 3;

	/* init data pipe */
	s->DataPipe.iBytesLeft = 0;
	s->DataPipe.iScanned   = 0;
	s->DataPipe.iLinesLeft = p->lines;
	s->DataPipe.iLinesInCircBuf = 1;
	DBG(DBG_MSG,
		"sane_get_parameters: lpi %3d; dpi %3d; p->lines %3d; p->pixels_per_line %3d; p->bytes_per_line %3d; Mode %x\n",
		s->ScanParams.iLpi,s->ScanParams.iDpi,p->lines,
		p->pixels_per_line,p->bytes_per_line,
		s->ScanParams.mode);
	return SANE_STATUS_GOOD;
}


/****************************************************************************/
SANE_Status
sane_start(SANE_Handle h)
/****************************************************************************/
{
	TScanner             *s;
	SANE_Parameters      par;
	SANE_Int             pabLineBufSize;
	SANE_Status          State;

	DBG(DBG_MSG,"sane_start\n");
	s = (TScanner *)h;

	if (sane_get_parameters(h, &par) != SANE_STATUS_GOOD) {
		DBG(DBG_MSG," sane_get_parameters,invalid scan parameters\n");
		return SANE_STATUS_INVAL;
	}
	#ifdef DEBUG_FILE
		s->ScanParams.DebugOpen = SANE_FALSE;
		s->ScanParams.DebugSeek0 = SANE_FALSE;
	#endif

	DBG(DBG_MSG,"sane_start: optDPI=%d optTLY=%dmm, optTLX=%dmm, optBRX=%dmm, optBRY=%dmm.\n",
		s->aValues[optDPI].w,
		s->aValues[optTLY].w,
		s->aValues[optTLX].w,
		s->aValues[optBRX].w,
		s->aValues[optBRY].w);

	DBG(DBG_MSG,"sane_start: iDpi=%d iLpi=%d iY=%dpix. iX=%dpix. iWidth=%dpix iLenght=%dpix. mode=0x%x brightness=0x%x\n",
		s->ScanParams.iDpi,      /* horizontal resolution */
		s->ScanParams.iLpi,       /* vertical resolution */
		s->ScanParams.iY,         /* in HW coordsane_readinates */
		s->ScanParams.iX,         /* in HW coordinates */
		s->ScanParams.iWidth,     /* pixels per line*/
		s->ScanParams.iLenght,    /* Pixel lines */
		s->ScanParams.mode,
		s->ScanParams.brightness);

	/* hack */
	pabLineBufSize = par.bytes_per_line * 3;
	DBG(DBG_MSG,"sane_start: pabLineBufSize=%d\n",pabLineBufSize);
	s->DataPipe.pabLineBuf = (SANE_Byte *)malloc(pabLineBufSize);

	s->DataPipe.iZeroLines = 0;

	/* copy gamma table */
	Hp_rts_WriteGammaCalibTable (s->HWParams.iXferHandle, s->aGammaTableR,
			s->aGammaTableG, s->aGammaTableB);

	/* prepare and start the actual scan */
	State = Hp_rts_CircBufferInit( h, &s->DataPipe, par.bytes_per_line,
						s->ScanParams.iWidth, s->ScanParams.mode);
	if ( State == SANE_STATUS_GOOD ){
		State = _InitScan(&s->ScanParams, &s->HWParams, &s->DataPipe);
		if ( !State ) {
/*		if ( State != SANE_STATUS_GOOD ) {*/
			DBG(DBG_MSG,"sane_start: InitScan, invalid scan parameters\n");
			return SANE_STATUS_IO_ERROR;
		}
		s->fScanning = SANE_TRUE;
		return SANE_STATUS_GOOD;
	}
	s->fScanning = SANE_FALSE;
	return State;
}


/****************************************************************************/
SANE_Status
sane_read(SANE_Handle h, SANE_Byte *buf, SANE_Int maxlen, SANE_Int *len)
/* buf have the lenght maxlen; len returns the lenght of the retuned bytes  */
/****************************************************************************/
{
	TScanner  *s;
	TDataPipe *p;

	s = (TScanner *)h;

	DBG(DBG_SCAN,"sane_read: starts here\n");
	/* sane_read only allowed after sane_start */
	if (!s->fScanning) {
		DBG(DBG_ERR," sane_read: sane_read only allowed after sane_start\n");
		return SANE_STATUS_EOF;
	}

	p = &s->DataPipe;

	/* anything left to read? */
	if ((s->ScanParams.iLinesLeft == 0) && (p->iBytesLeft == 0)) {
		DBG(DBG_SCAN," sane_read: end of scan\n");
		_FinishScan(s);
		*len = 0;
		s->fScanning = SANE_FALSE;
		Hp_rts_CircBufferExit( h );
		if (p->pabLineBuf != NULL){
			free(p->pabLineBuf);
			p->pabLineBuf = NULL;
		}
		#ifdef DEBUG_FILE
		if ( s->ScanParams.DebugOpen ){
			fclose(s->ScanParams.FD_r);
			s->ScanParams.DebugOpen = SANE_FALSE;
		}
		#endif
		return SANE_STATUS_EOF;
	}

	/* time to read the next line? */
	*len = 0;
	if (p->iBytesLeft == 0) {
		if (Hp_rts_CircBufferGetLine(h, p, p->pabLineBuf,s->ScanParams.mode)){
			p->iBytesLeft = p->iBytesPerLine;
			s->ScanParams.iLinesLeft--;
			DBG(DBG_SCAN," sane_read: p->iBytesLeft=%3d s->ScanParams.iLinesLeft=%3d\n",
				p->iBytesLeft,s->ScanParams.iLinesLeft);
		}else
		{ /* no data read from the pipe ! */
			s->DataPipe.iZeroLines = s->DataPipe.iZeroLines +1;
			DBG(DBG_SCAN," sane_read: no bytes read from CircBuffer\n");
			if (s->DataPipe.iZeroLines <10){
				*len = 0;
				return SANE_STATUS_GOOD;
			}else /* time over */
			{
				*len = 0;
				return SANE_STATUS_IO_ERROR;
			}
		}
		/* copy (part of) a line */
		*len = MIN(maxlen, p->iBytesLeft);
		memcpy(buf, &p->pabLineBuf[p->iBytesPerLine - p->iBytesLeft], *len);
		p->iBytesLeft -= *len;
	}

	DBG(DBG_SCAN," sane_read: read %d bytes; maxlen = %d\n", *len,maxlen);
	return SANE_STATUS_GOOD;
}


/****************************************************************************/
void
sane_cancel(SANE_Handle h)
/****************************************************************************/
{
	TScanner *s;

	DBG(DBG_MSG,"sane_cancel\n");
	s = (TScanner *)h;

	/* Make sure the scanner head returns home */
	_FinishScan(s);
	Hp_rts_CircBufferExit( h );
	if (s->DataPipe.pabLineBuf != NULL){
		free(s->DataPipe.pabLineBuf);
		s->DataPipe.pabLineBuf = NULL;
	}
	#ifdef DEBUG_FILE
	if ( s->ScanParams.DebugOpen ){
		fclose(s->ScanParams.FD_r);
		s->ScanParams.DebugOpen = SANE_FALSE;
	}
	#endif
	s->fCanceled = SANE_TRUE;
	s->fScanning = SANE_FALSE;
}


/****************************************************************************/
SANE_Status
sane_set_io_mode(SANE_Handle h, SANE_Bool m)
/****************************************************************************/
{
	DBG(DBG_MSG, "sane_set_io_mode: %s\n", m ? "non-blocking" : "blocking");
	/* prevent compiler from complaining about unused parameters */
	h = h;

	if (m) {
		return SANE_STATUS_UNSUPPORTED;
	}
	return SANE_STATUS_GOOD;
}


/****************************************************************************/
SANE_Status
sane_get_select_fd(SANE_Handle h, SANE_Int *fd)
/****************************************************************************/
{
	DBG(DBG_MSG, "sane_select_fd\n");
	/* prevent compiler from complaining about unused parameters */
	h = h;
	fd = fd;
	return SANE_STATUS_UNSUPPORTED;
}


#ifdef STANDALONE
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/

typedef void (*rts8801_callback)(	void	*param,
					unsigned bytes,
					void	*data);

/****************************************************************************/
void
main_UsageError()
/****************************************************************************/
{
	fprintf(stderr,	"SANE HP_RTS88XX  x y width height resolution filename\n"
			"	x, y, width, height: in pixels\n"
			"	resolution: 1200/600/300/200/150/75\n");
	exit(1);
}


/****************************************************************************/
int
main (int argc, char *argv[])
/****************************************************************************/
{
	TScanner *s;
	/*SANE_String_Const name;*/
	SANE_Int piVersion;
	unsigned	x, y, w, h;
	SANE_Word	resolution;
	char const *	filename;
	FILE		*fp;
	int		result = 1;
	int		multiplier;
	/*int	depth;
	SANE_Int i;*/
	SANE_Auth_Callback pfnAuth;
	const SANE_Device **device_list;
	SANE_Bool local;
	SANE_Handle device;
	SANE_Status status;
	SANE_Int num_dev_options;
	SANE_Int info;
	SANE_Byte *buf;
	/*SANE_Int maxlen;*/
	SANE_Int len;

	DBG (DBG_MSG, "SANE HP_RTS88XX USB test version\n");

	if (argc != 7)
		main_UsageError();

	x = atoi(argv[1]);
	y = atoi(argv[2]);
	w = atoi(argv[3]);
	h = atoi(argv[4]);
	resolution = atoi(argv[5]);
	filename = argv[6];

	switch (resolution)
	{
	case 1200:
	case 600:
	case 400:
	case 300:
	case 200:
	case 150:
	case 100:
	case 75:
	case 50:
	case 25:
		break;

	default:
		fprintf(stderr, "Invalid resolution: %s\n", argv[5]);
		return 1;
	}

	multiplier = 1200 / resolution;
	if ((y + h) * multiplier > 16800)
	{
		fprintf(stderr, "Scan parameters take the image past the bottom of the scanner\n");
		return 1;
	}
	if ((x + w) * multiplier > 10451)
	{
		fprintf(stderr, "Scan parameters take the image past the right hand side of the scanner\n");
		return 1;
	}
	if (!x || !y || !w || !h)
	{
		fprintf(stderr, "None of the co-ordinates may be zero\n");
		return 1;
	}
	if (y * multiplier < 600)
	{
		fprintf(stderr, "Warning: at this resolution 'y' values under %d are in the pre-scan area\n",
				599 / multiplier + 1);
	}
	if (x * multiplier < 251)
	{
		fprintf(stderr, "Warning: at this resolution, 'x' values under %d are left of the scan area\n",
			250 / multiplier + 1);
	}

  s = malloc (sizeof (TScanner));
  if (!s)
    {
      DBG (DBG_MSG,"main : malloc for s failed\n");
      return SANE_STATUS_NO_MEM;
    }
  buf = malloc (5000);
  if (!buf)
    {
      DBG (DBG_MSG,"main : malloc buf failed\n");
      return SANE_STATUS_NO_MEM;
    }

	if (sane_init(&piVersion,pfnAuth) != SANE_STATUS_GOOD)
	{
		fprintf(stderr, "Could not initialise scanner\n");
		/* free scanner object memory */
		free ((void *) s);
		exit(1);
	}
	local = SANE_TRUE;
	if (sane_get_devices (&device_list, local) != SANE_STATUS_GOOD)
	{
		fprintf(stderr, "Could not sane_get_devices\n");
		/* free scanner object memory */
		free ((void *) s);
		exit(1);
	}

	status = sane_open ("libusb:001:002", &device);
	if (status != SANE_STATUS_GOOD)
	{
		fprintf(stderr, "Could not sane_open\n");
		/* free scanner object memory */
		free ((void *) s);
		exit(1);
	}

	/* Get the number of options. */
	status = sane_control_option (device, 0, SANE_ACTION_GET_VALUE, &num_dev_options, 0);
	if (status != SANE_STATUS_GOOD)
	{
		fprintf(stderr, "Could not read sane_control_option\n");
		/* free scanner object memory */
		free ((void *) s);
		exit(1);
	}

/*SANE_Word:
	case optDPI: case optTLX: case optTLY: case optBRX: case optBRY:
	case optBrightness: case optGainR: case optGainG: case optGainB:
SANE_TYPE_STRING
	case OPT_MODE: case optXPDA: case optCCD:
*/
	status = sane_control_option (device,optDPI, SANE_ACTION_SET_VALUE,
								  &resolution, &info);
	status = sane_control_option (device,optTLX, SANE_ACTION_SET_VALUE,
								  &x, &info);
	status = sane_control_option (device,optBRX, SANE_ACTION_SET_VALUE,
								  &w, &info);
	status = sane_control_option (device,optTLY, SANE_ACTION_SET_VALUE,
								  &y, &info);
	status = sane_control_option (device,optBRY, SANE_ACTION_SET_VALUE,
								  &h, &info);
#if 0
	free ((void *) s);
	exit(1);
#endif
	s = (TScanner *)device;

	/* TScanParams */
	s->ScanParams.brightness = 10;
	s->ScanParams.mode = 1;         /* B/W = 0; grayscale = 1 color = 2 */
	s->ScanParams.optXPA = 0;       /* 0=normal; 1 = XPA */
	s->ScanParams.oCCD_Type = 0;    /* 0/1 */

	fprintf(stdout, "Will open file %s\n",filename);
	fp = fopen(filename, "w");

	if (fp)
	{
		fprintf(fp, "P6\n%d %d\n255\n", w, h);

		switch (s->HWParams.ScannerModel)
		{
			case eHp3500c: case eHp3530c: case eHp3570c:
				if (Hp35x0c_init_scan(&s->HWParams, &s->ScanParams, &s->DataPipe))
					;
				else result = 1;
				break;

			case eHp4400c: case eHp4470c:
				if (Hp44x0_init_scan(&s->HWParams, &s->ScanParams, &s->DataPipe))
				{
					if (Hp44x0_start_scan(&s->HWParams, &s->ScanParams, &s->DataPipe))
					{
						s->fScanning = SANE_TRUE;
					}
				} /* if */

				break;
			default:
				fprintf(stderr, "Wrong scanner model\n");
				result = 1;
		}
	}
	else
	{
		perror(filename);
	}

	if (s->fScanning == SANE_TRUE)
	{
		while ( s->fScanning == SANE_FALSE )
		{
			status = sane_read(device, (SANE_Byte *)buf, 5000, &len);
/*			status = sane_read(device, &buf, 5000, &len);*/
			/* buf have the lenght maxlen; len returns the lenght of the retuned bytes  */
		}
	}
	/* free scanner object memory */
	free ((void *) s);
	return result;
}

#endif






# hp_rts88xx.conf: Configuration file for HP35x00C and HP44x0 USB scanners
# Read man sane-hp_rts88xx.man for documentation

# ALL:
# If autodetection doesn't work uncomment or add your device file
#/dev/usbscanner

# HP44x0C option_CCD
# CCD0 or CCD1 allowed
# if you receive a black image, change it to CCD1
#option CCD0

# HP44x0C option_color
# none or ENABLE_COLOR allowed
# allow the color mode
#option ENABLE_COLOR

# HP35x00C/HP44x0C enable all resolutions
# !!!!! only for test and development !!!!! 
#option ENABLE_T_RES




 /* sane - Scanner Access Now Easy.
   Copyright (C) 2003 Johannes Hub (JohannesHub@t-online.de)

   This file was initially copied from the hp3300 backend.
   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 exutable, 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.
*/

/*
    Concept for a backend for scanners based on the RTS88xx chipset,
    such as HP4400C, HP4470C, HP3500C, 3530C, and HP ScanJet 3570C.
    Parts of this source were inspired by other backends.

		History:

		Version 0.18  21.11.04 13.alpha,
				- source sorted,
				- now only SANEI_USB_SUPPORT for a better overview(xfermodules removed)
				- read and verify the MainBoardID 
		Version 0.17p 02.11.04 12.alpha, source sorted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17p 02.11.04 12.alpha, source sourted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17b 30.03.04 10.alpha, little fixes and libusb implemented
		Version 0.17  09.03.04 9. alpha, HP3500 included
		Version 0.16  06.02.04 8. alpha, wait counting on LCD
		Version 0.15a 29.01.04 7. alpha, CCD switch moved to config file
		Version 0.15  11.01.04 6. alpha, a second CCD implemented
		Version 0.13a 21.11.04 4. alpha, an little fix included
		Version 0.12  22.10.03 third alpha, Backend name changed to HP_RTS88xx
		Version 0.11  30.08.03 second alpha
		Version 0.10  19.07.03 first alpha
*/

/*
		Provides a simple interface to read and write data from the scanner,
		without any knowledge whether it's a parallel or USB scanner

		enable DEDUG output:
		use a nomal shell (konsole) and type
		export SANE_DEBUG_HP_RTS88XX=32
		export XSANE_DEBUG=100
		xsane
*/

#ifndef _HP_RTS88xx_H_
#define _HP_RTS88xx_H_


#define MM_TO_PIXEL(_mm_, _dpi_)    ((_mm_) * (_dpi_) / 25.4)
#define PIXEL_TO_MM(_pixel_, _dpi_) ((_pixel_) * 25.4 / (_dpi_))
#define ENABLE(OPTION)  s->opt[OPTION].cap &= ~SANE_CAP_INACTIVE
#define DISABLE(OPTION) s->opt[OPTION].cap |=  SANE_CAP_INACTIVE
#define IS_ACTIVE(OPTION) (((s->opt[OPTION].cap) & SANE_CAP_INACTIVE) == 0)
#define NUM_GAMMA_ENTRIES  65536

#define	RTS8801_GREYSCALE	1
#define	RTS8801_COLOUR		2
#define	RTS8801_BW		0

typedef enum
	{
		BLACK_WHITE = 0,
		GRAY,       /*1*/
		COLOR       /*2*/
	}
BACKEND_MODE;

/* options enumerator */
typedef enum {
	optCount = 0,

	optGroupGeometry,
		optTLX, optTLY, optBRX, optBRY,
		optDPI,
		optGroupImage,
		optGammaTableRed,		/* Gamma Tables */
		optGammaTableGreen,
		optGammaTableBlue,
	optGroupMisc,
		OPT_MODE,
		optXPDA,
		optCCD,
		optBrightness,
		optGainR,
		optGainG,
		optGainB,
	optLast
} EOptionIndex;


typedef union {
	SANE_Word w;
	SANE_Word *wa;     /* word array */
	SANE_String s;
} TOptionValue;


typedef struct {
	SANE_Int		iDpi;         /* horizontal resolution */
	SANE_Int		iLpi;         /* vertical resolution */
	SANE_Int		iY;           /* iTop in HW coordinates */
	SANE_Int		iX;           /* iLeft in HW coordinates */
	SANE_Int		iWidth;       /* pixels per line */
	SANE_Int		iLenght;      /* iHeight pixel lines */
	SANE_Int		iSkipLines;   /* Steps to pos. for scann */
	SANE_Int		iLinesLeft;   /* Lines witch left over to scan */
	SANE_Int		fCalib;       /* if TRUE, disable backtracking? */
	SANE_Int		brightness;
	SANE_Int		mode;         /* B/W = 0; grayscale = 1 color = 2 */
	SANE_Int		optXPA;       /* 0=normal; 1 = XPA */
	SANE_Int		oCCD_Type;    /* 0/1 */
	SANE_Int		GainR;
	SANE_Int		GainG;
	SANE_Int		GainB;
	#ifdef		DEBUG_FILE
	FILE			*FD_r;            /* rgb  test pnm file*/
	SANE_Int		DebugOpen;
	SANE_Int		DebugSeek0;
	#endif
} TScanParams;


typedef struct {
	/* transfer buffer */
	SANE_Byte		*pabXferBuf;
	SANE_Int		iCurLine, iBytesPerLine, iLinesPerXferBuf;
	SANE_Int		iLastLine;
	SANE_Int		iScanned;     /* Lines witch have scanned */
	SANE_Int		iLinesLeft;   /* Lines witch left over to scan */
	/* circular buffer */
	SANE_Byte		*pabCircBuf;
	SANE_Int		iLinesPerCircBuf;
	SANE_Int		iLinesInCircBuf;
	SANE_Int		iMisAlignment;
	SANE_Int		iRedLine, iGrnLine, iBluLine;
	/* current line buffer */
	SANE_Byte		*pabLineBuf;
	SANE_Int		iBytesLeft;

	SANE_Int		iZeroLines;
} TDataPipe;


typedef struct {
/*	EScannerModel		ScannerModel;*/
	SANE_Int		ScannerModel;
	SANE_Int		iXferHandle;    /* handle used for data transfer to HW */
	SANE_Int		iTopLeftX;      /* in mm */
	SANE_Int		iTopLeftY;      /* in mm */
	SANE_Int		iMainBoardID;   /*  */
	SANE_Bool		iReversedHead;  /* Head is reversed */
	SANE_Bool		lamp_warm;      /* TRUE = the lamp is warm */
	SANE_Byte		regs[0xff];
} THWParams;


typedef struct {
	SANE_Option_Descriptor	aOptions[optLast];
	TOptionValue						aValues[optLast];

	TScanParams						ScanParams;
	THWParams						HWParams;
	TDataPipe						DataPipe;

	SANE_Int						*aGammaTableR;	/* a 16-to-16 bit color lookup table */
	SANE_Int						*aGammaTableG;	/* a 16-to-16 bit color lookup table */
	SANE_Int						*aGammaTableB;	/* a 16-to-16 bit color lookup table */

	SANE_Bool						fScanning;    /* TRUE if actively scanning */
	SANE_Bool						fCanceled;
} TScanner;


/* option constraints */
static SANE_Bool OPT_CCD				=	SANE_TRUE;
static SANE_Bool OPT_COLOR				=	SANE_FALSE;
static SANE_Bool OPT_T_RES				=	SANE_FALSE;
static const SANE_Range	rangeGammaTable			=	{0,65535,1};
static const SANE_Int	Hp44x0c_setResolutions[]	=	{1,300};
static const SANE_Int	Hp44x0c_setResolutions_t[]	=	{2,300,600};
static const SANE_Int	Hp35x0c_setResolutions[]	=	{1,150};
static const SANE_Int	Hp35x0c_setResolutions_t[]	=	{3,150,300,600};

#ifndef WITH_TSTBACKEND
static const SANE_Range rangeXmm       = {0, 220, 1}; /* max. mm */
static const SANE_Range rangeYmm       = {0, 295, 1}; /* max. mm */
#endif
#ifdef WITH_TSTBACKEND
static const SANE_Range rangeXmm       = {0, 70, 1}; /* max. mm */
static const SANE_Range rangeYmm       = {0, 70, 1}; /* max. mm */
#endif
static const SANE_Range rangeBrightness     = {0, 20, 1};
/*static const SANE_Range rangeBrightness     = {0, 0x40, 1};*/
#if 0
static const SANE_Range rangeLampBrightness = {0xa1, 0xaf, 1};
#endif

static SANE_String_Const mode_list[5];
static SANE_String_Const scan_option_list[3];
static SANE_String_Const ccd_list[3];

/* Device filename for USB access */
SANE_Char * usb_devfile = "/dev/usb/scanner0";

SANE_Status _Init_Interface(THWParams *pHWParams, TScanParams *pParams);
void _Close_Interface(THWParams *pHWParams);
SANE_Bool _InitScan  (TScanParams *pParams,THWParams *pHWParams, TDataPipe *pDataPipe);
SANE_Bool _FinishScan     (SANE_Handle h);
#endif




 /* sane - Scanner Access Now Easy.
   Copyright (C) 2003 Johannes Hub (JohannesHub@t-online.de)

   This file was initially copied from the hp3300 backend.
   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 exutable, 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.
*/

/*
    Concept for a backend for scanners based on the RTS88xx chipset,
    such as HP3500C, 3530C, and HP ScanJet 3570C.
    Parts of this source were inspired by other backends.

		History:

		Version 0.18  21.11.04 13.alpha,
				- source sorted,
				- now only SANEI_USB_SUPPORT for a better overview(xfermodules removed)
				- read and verify the MainBoardID 
		Version 0.17p 02.11.04 12.alpha, source sorted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17p 02.11.04 12.alpha, source sourted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17b 30.03.04 10.alpha, little fixes and libusb implemented
		Version 0.17  09.03.04 9. alpha, HP3500 included
		Version 0.16  06.02.04 8. alpha, wait counting on LCD
		Version 0.15a 29.01.04 7. alpha, CCD switch moved to config file
		Version 0.15  11.01.04 6. alpha, a second CCD implemented
		Version 0.13a 21.11.04 4. alpha, an little fix included
		Version 0.12  22.10.03 third alpha, Backend name changed to HP_RTS88xx
		Version 0.11  30.08.03 second alpha
		Version 0.10  19.07.03 first alpha
*/

/*
    Core HP35x0c 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 <ctype.h>

#include "hp_rts_xfer.h"
#include "hp_rts_44x0c.h"
#include "hp_rts_35x0c.h"

static SANE_Byte sram_access_method = 0;
static SANE_Word sram_size = 0;

/****************************************************************************/
SANE_Int
Hp35x0c_queue_read_register( SANE_Int iHandle, SANE_Byte reg, SANE_Int bytes, SANE_Byte *data)
/****************************************************************************/
{
	if (bytes == 1)
		return ( Hp_rts_RegRead(iHandle,reg, data));
	else
		return ( Hp_rts_BulkRead( iHandle, reg, data, bytes, SANE_TRUE) );
  }

/****************************************************************************/
SANE_Int
Hp35x0c_read_register_immediate( SANE_Int iHandle, SANE_Int reg, SANE_Int bytes, SANE_Byte *data)
/****************************************************************************/
{
	if (bytes == 1)
		return ( Hp_rts_RegRead(iHandle,reg, data) );
	else
		return ( Hp_rts_BulkRead( iHandle, reg, data, bytes, SANE_TRUE) );
}

/****************************************************************************
SANE_Int
Hp35x0c_queue_set_register( SANE_Int iHandle, SANE_Int reg, SANE_Int bytes, void *data)
****************************************************************************
{
	if (bytes == 1)
		return( Hp_rts_RegWrite (iHandle, reg, data));
	else
		return( Hp_rts_BulkWrite(iHandle, reg, data, bytes, SANE_TRUE));
}*/

/****************************************************************************/
SANE_Int
Hp35x0c_set_register_immediate( SANE_Int iHandle, SANE_Int reg, SANE_Int bytes, SANE_Byte *data)
/****************************************************************************/
{
	if (reg < 0xb3 && reg + bytes > 0xb3)
	{
		SANE_Int	bytes_in_first_block = 0xb3 - reg;

		if (Hp35x0c_set_register_immediate(iHandle, reg, bytes_in_first_block, data) < 0 ||
		    Hp35x0c_set_register_immediate(iHandle, 0xb4, bytes - bytes_in_first_block - 1,
							data + bytes_in_first_block + 1) < 0)
			return -1;
		return 0;
	}
	if (bytes == 1){
		return( Hp_rts_RegWrite (iHandle, reg, *data));
	}else
		return( Hp_rts_BulkWrite(iHandle, reg, (SANE_Byte *)data, bytes, SANE_TRUE));
}


/****************************************************************************/
SANE_Int
Hp35x0c_send_command_immediate( SANE_Int iHandle, SANE_Int command,
/****************************************************************************/
				SANE_Byte	reg,
				SANE_Int	count,
				SANE_Int	bytes,
				SANE_Byte	*data,
				SANE_Int	readbytes,
				SANE_Byte	*readdata)
{
	callibration_buffer[0] = command;
	callibration_buffer[1] = reg;
	callibration_buffer[2] = count >> 8;
	callibration_buffer[3] = count;
	memcpy(callibration_buffer + 4, data, bytes);
	Hp_rts_BulkWrite(iHandle, 0,callibration_buffer, bytes+4, SANE_FALSE);
	if (readbytes)
	{
		return(Hp_rts_BulkRead(iHandle, 0,readdata,readbytes,SANE_FALSE));
	}
	return( 0 );
}


/****************************************************************************/
SANE_Int
Hp35x0c_write_sram( SANE_Int iHandle, SANE_Word	bytes, SANE_Byte	*data)
/****************************************************************************/
{
	callibration_buffer[0] = RTCMD_WRITESRAM;
	callibration_buffer[1] = 0x00;
	callibration_buffer[2] = bytes >> 8;
	callibration_buffer[3] = bytes;
	memcpy(callibration_buffer + 4, data, bytes);
	return( Hp_rts_BulkWrite(iHandle, 0,
		callibration_buffer, bytes+4, SANE_FALSE));
}

/****************************************************************************/
SANE_Int
Hp35x0c_read_sram( SANE_Int iHandle, SANE_Int	bytes, SANE_Byte *data)
/****************************************************************************/
{
	return Hp35x0c_send_command_immediate(iHandle,RTCMD_READSRAM, 0, bytes, 0, 0, bytes, data);
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_sram_page( SANE_Int iHandle, SANE_Byte	page)
/****************************************************************************/
{
	return(Hp_rts_Set_double_reg(iHandle,0x91,  page, page >> 8));
}

/****************************************************************************/
SANE_Int
Hp35x0c_detect_sram( SANE_Int iHandle, SANE_Word *totalbytes, SANE_Byte *r93setting)
/****************************************************************************/
{
	SANE_Byte	data[0x818];
	SANE_Byte	testbuf[0x818];
	SANE_Int	i;
	SANE_Int	test_values[] = { 6, 2, 1, -1 };

	for (i = 0; i < (SANE_Int)sizeof(data); ++i)
		data[i] = i % 0x61;


	for (i = 0; test_values[i] != -1; ++i)
	{
		if (Hp_rts_RegWrite(iHandle,0x93, test_values[i]) ||
			Hp35x0c_set_sram_page(iHandle,0x81) ||
			Hp35x0c_write_sram(iHandle,0x818, data) ||
			Hp35x0c_set_sram_page(iHandle,0x81) ||
			Hp_rts_Read_Sram (iHandle, testbuf,0x818) )
			return -1;
		if (!memcmp(testbuf, data, 0x818))
		{
			sram_access_method = test_values[i];
			if (r93setting)
				*r93setting = sram_access_method;
			break;
		}
	}
	if (!sram_access_method)
		return -1;

	for (i = 0; i < 16; ++i)
	{
		SANE_Int	j;
		SANE_Byte	write_data[32];
		SANE_Byte	read_data[32];
		SANE_Int	pagesetting;

		for (j = 0; j < 16; j++)
		{
			write_data[j * 2] = j * 2;
			write_data[j * 2 + 1] = i;
		}

		pagesetting = i * 4096;

		if (Hp35x0c_set_sram_page(iHandle,pagesetting) < 0||
		    Hp35x0c_write_sram(iHandle,32, write_data) < 0)
			return -1;
		if (i)
		{
			if (Hp35x0c_set_sram_page(iHandle,0) < 0 ||
			    Hp35x0c_read_sram(iHandle,32, read_data) < 0)
				return -1;
			if (!memcmp(read_data, write_data, 32))
			{
				sram_size = i * 0x20000;
				if (totalbytes)
					*totalbytes = sram_size;
				return 0;
			}
		}
		return -1;
	}
	return -1;
}

/****************************************************************************/
SANE_Int
Hp35x0c_is_rewound( SANE_Int iHandle )
/****************************************************************************/
{
	SANE_Byte	r;

	if (Hp35x0c_read_register_immediate( iHandle, 0x1d, 1, &r) < 0)
		return -1;
	if (r & 0x02)
		return 1;
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_direction_forwards(SANE_Byte *regs)
/****************************************************************************/
{
	regs[0xc6] |= 0x08;
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_direction_rewind(SANE_Byte *regs)
/****************************************************************************/
{
	regs[0xc6] &= 0xf7;
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_stop_when_rewound( SANE_Byte *regs, SANE_Int	stop)
/****************************************************************************/
{
	if (stop)
		regs[0xb2] |= 0x10;
	else
		regs[0xb2] &= 0xef;
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_distances( SANE_Int iHandle,SANE_Int location1,
		   SANE_Int location2)
/****************************************************************************/
{
	SANE_Byte	regbuffer[4];

	regbuffer[0] = location1;
	regbuffer[1] = location1 >> 8;
	regbuffer[2] = location2;
	regbuffer[3] = location2 >> 8;
	return Hp35x0c_set_register_immediate(iHandle,REG_DESTINATION_POSITION, 4, regbuffer);
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_powersave_mode( SANE_Int iHandle,SANE_Int enable)
/****************************************************************************/
{
	SANE_Byte r;

	if (Hp35x0c_read_register_immediate(iHandle,REG_MOVE_CONTROL_TEST, 1, &r) < 0)
		return -1;
	if (r & 0x04)
	{
		if (enable == 1)
			return 0;
		r &= ~0x04;
	}
	else
	{
		if (enable == 0)
			return 0;
		r |= 0x04;
	}
	if (Hp_rts_RegWrite(iHandle,REG_MOVE_CONTROL_TEST, r) < 0 ||
	    Hp_rts_RegWrite(iHandle,REG_MOVE_CONTROL_TEST, r) < 0)
		return -1;
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_lamp_ready( SANE_Int iHandle )
/****************************************************************************/
{
	SANE_Byte r;

	if (Hp35x0c_read_register_immediate(iHandle,0xd1, 1, &r) < 0)
		return -1;
	if (r & 0x40)
		return 0;
	return 1;
}

/****************************************************************************/
SANE_Int
Hp35x0c_turn_off_lamp( SANE_Int iHandle )
/****************************************************************************/
{
	return Hp_rts_RegWrite(iHandle,0x3a, 0);
}

/****************************************************************************/
SANE_Int
Hp35x0c_turn_on_lamp( SANE_Int iHandle )
/****************************************************************************/
{
	SANE_Byte r3a;
	SANE_Byte r10;
	SANE_Byte r58;

	if (Hp35x0c_read_register_immediate(iHandle,0x3a, 1, &r3a) < 0 ||
		Hp35x0c_read_register_immediate(iHandle,0x10, 1, &r10) < 0 ||
		Hp35x0c_read_register_immediate(iHandle,0x58, 1, &r58) < 0)
		return -1;
	r3a |= 0x80;
	r10 |= 0x01;
	r58 &= 0x0f;
	if (Hp_rts_RegWrite(iHandle,0x3a, r3a) < 0 ||
		Hp_rts_RegWrite(iHandle,0x10, r10) < 0 ||
		Hp_rts_RegWrite(iHandle,0x58, r58) < 0)
		return -1;
	return 0;
}

/****************************************************************************/
/****************************************************************************/
#if 0
static SANE_Int
Hp35x0c_set_value_msbfirst(	SANE_Byte	*regs,
			SANE_Int		firstreg,
			SANE_Int		totalregs,
			SANE_Word	value)
/****************************************************************************/
{
	while (totalregs--)
	{
		regs[firstreg + totalregs] = value & 0xff;
		value >>= 8;
	}
	return 0;
}
#endif
/****************************************************************************/
SANE_Int
Hp35x0c_set_ccd_shift_clock_multiplier(	SANE_Byte	*regs,
					SANE_Word	value)
/****************************************************************************/
{
	return Hp_rts_set_value_lsbfirst(regs, 0xf0, 3, value);
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_ccd_sample_clock_multiplier(	SANE_Byte	*regs,
					SANE_Word	value)
/****************************************************************************/
{
	return Hp_rts_set_value_lsbfirst(regs, 0xf6, 3, value);
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_ccd_clock_reset_interval(	SANE_Byte	*regs,
					SANE_Word	value)
/****************************************************************************/
{
	return Hp_rts_set_value_lsbfirst(regs, 0xf9, 3, value);
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_ccd_clamp_clock_multiplier(	SANE_Byte	*regs,
					SANE_Word	value)
/****************************************************************************/
{
	return Hp_rts_set_value_lsbfirst(regs, 0xfc, 3, value);
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_movement_pattern(		SANE_Byte	*regs,
					SANE_Word	value)
/****************************************************************************/
{
	return Hp_rts_set_value_lsbfirst(regs, 0xc0, 3, value);
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_motor_movement_clock_multiplier(	SANE_Byte	*regs,
					SANE_Word	value)
/****************************************************************************/
{
	regs[0x40] = (regs[0x40] & ~0xc0) | (value << 6);
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_motor_type(			SANE_Byte	*regs,
					SANE_Word	value)
/****************************************************************************/
{
	regs[0xc9] = (regs[0xc9] & 0xf8) | (value & 0x7);
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_basic_calibration(		SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	redoffset1,
					SANE_Int	redoffset2,
					SANE_Int	redgain,
					SANE_Int	greenoffset1,
					SANE_Int	greenoffset2,
					SANE_Int	greengain,
					SANE_Int	blueoffset1,
					SANE_Int	blueoffset2,
					SANE_Int	bluegain)
{
	regs[0x05] = redoffset1;
	regs[0x02] = redoffset2;
	regs[0x08] = redgain;
	regs[0x06] = greenoffset1;
	regs[0x03] = greenoffset2;
	regs[0x09] = greengain;
	regs[0x07] = blueoffset1;
	regs[0x04] = blueoffset2;
	regs[0x0a] = bluegain;
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_calibration_addresses(		SANE_Byte *regs,
/****************************************************************************/
					SANE_Word	redaddr,
					SANE_Word	blueaddr,
					SANE_Word	greenaddr)
{
	regs[0x84] = redaddr;
	regs[0x8e] = (regs[0x8e] * 0x0f) | ((redaddr >> 4) & 0xf0);
	Hp_rts_set_value_lsbfirst(regs, 0x85, 2, blueaddr);
	Hp_rts_set_value_lsbfirst(regs, 0x87, 2, greenaddr);
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_lamp_duty_cycle(			SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	enable,
					SANE_Int	frequency,
					SANE_Int	offduty)
{
	if (enable)
		regs[0x3b] |= 0x80;
	else
		regs[0x3b] &= 0x7f;

	regs[0x3b] = (regs[0x3b] & 0x80) | ((frequency & 0x7) << 4) | (offduty & 0x0f);
	regs[0x3d] = (regs[0x3d] & 0x7f) | ((frequency & 0x8) << 4);
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_data_feed_on(			SANE_Byte *regs)
/****************************************************************************/
{
	regs[0xb2] &= ~0x04;
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_data_feed_off(			SANE_Byte *regs)
/****************************************************************************/
{
	regs[0xb2] |= 0x04;
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_enable_ccd(				SANE_Byte *regs,
/****************************************************************************/
					SANE_Int enable)
{
	if (enable)
		regs[0x00] &= ~0x10;
	else
		regs[0x00] |= 0x10;
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_cdss(				SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	val1,
					SANE_Int	val2)
{
	regs[0x28] = (regs[0x28] & 0xe0) | (val1 & 0x1f);
	regs[0x2a] = (regs[0x2a] & 0xe0) | (val2 & 0x1f);
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_cdsc(				SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	val1,
					SANE_Int	val2)
{
	regs[0x29] = (regs[0x29] & 0xe0) | (val1 & 0x1f);
	regs[0x2b] = (regs[0x2b] & 0xe0) | (val2 & 0x1f);
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_update_after_setting_cdss2(		SANE_Byte *regs)
/****************************************************************************/
{
	SANE_Int	fullcolour = (!(regs[0x2f] & 0xc0) && (regs[0x2f] & 0x04));
	SANE_Int value = regs[0x2a] & 0x1f;

	regs[0x2a] = (regs[0x2a] & 0xe0) | (value & 0x1f);

	if (fullcolour)
		value *= 3;
	if ((regs[0x40] & 0xc0) == 0x40)
		value += 17;
	else
		value += 16;

	regs[0x2c] = (regs[0x2c] & 0xe0) | (value  % 24);
	regs[0x2d] = (regs[0x2d] & 0xe0) | ((value + 2) % 24);
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_cph0s(				SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	on)
{
	if (on)
		regs[0x2d] |= 0x20;	/* 1200dpi horizontal coordinate space */
	else
		regs[0x2d] &= ~0x20;	/* 600dpi horizontal coordinate space */
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_cvtr_lm(				SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	val1,
					SANE_Int	val2,
					SANE_Int	val3)
{
	regs[0x28] = (regs[0x28] & ~0xe0) | (val1 << 5);
	regs[0x29] = (regs[0x29] & ~0xe0) | (val2 << 5);
	regs[0x2a] = (regs[0x2a] & ~0xe0) | (val3 << 5);
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_cvtr_mpt(			SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	val1,
					SANE_Int	val2,
					SANE_Int	val3)
{
	regs[0x3c] = (val1 & 0x0f) | (val2 << 4);
	regs[0x3d] = (regs[0x3d] & 0xf0) | (val3 & 0x0f);
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_cvtr_wparams(			SANE_Byte *regs,
/****************************************************************************/
					SANE_Word fpw,
					SANE_Word bpw,
					SANE_Word w)
{
	regs[0x31] = (w & 0x0f) | ((bpw << 4) & 0x30) | (fpw << 6);
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_enable_movement(			SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	enable)
{
	if (enable)
		regs[0xc3] |= 0x80;
	else
		regs[0xc3] &= ~0x80;
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_scan_frequency(			SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	frequency)
{
	regs[0x64] = (regs[0x64] & 0xf0) | (frequency & 0x0f);
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_merge_channels(			SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	on)
{
	DBG( DBG_MSG , "start_scan: Hp35x0c_set_merge_channels\n");
	regs[0x2f] &= ~0x14;
	regs[0x2f] |= on ? 0x04 : 0x10;
#ifdef DEBUG
	Hp_rts_DumpBits(0x2f, regs[0x2f]);
#endif
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_channel(				SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	channel)
{
	DBG( DBG_MSG , "start_scan: Hp35x0c_set_channel %d\n",channel);
	regs[0x2f] = (regs[0x2f] & ~0xc0) | (channel << 6);
#ifdef DEBUG
	Hp_rts_DumpBits(0x2f, regs[0x2f]);
#endif
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_single_channel_scanning(		SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	on)
{
	if (on){
		regs[0x2f] |= 0x20;
		DBG( DBG_MSG , "start_scan: Hp35x0c_set_single_channel_scanning on\n");
	}else{
		regs[0x2f] &= ~0x20;
		DBG( DBG_MSG , "start_scan: Hp35x0c_set_single_channel_scanning off\n");
	}
#ifdef DEBUG
	Hp_rts_DumpBits(0x2f, regs[0x2f]);
#endif
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_colour_mode(			SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	on)
{
	if (on){
		DBG( DBG_MSG , "start_scan: Set register to color mode\n");
		regs[0x2f] |= 0x02;
	}else{
		DBG( DBG_MSG , "start_scan: Set register to gray mode\n");
		regs[0x2f] &= ~0x02;
	}
#ifdef DEBUG
	Hp_rts_DumpBits(0x2f, regs[0x2f]);
#endif
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_horizontal_resolution(		SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	resolution)
{
	if (regs[0x2d] & 0x20)
		regs[0x7a] = 1200 / resolution;
	else
		regs[0x7a] = 600 / resolution;
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_last_sram_page(			SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	pagenum)
{
	Hp_rts_set_value_lsbfirst(regs, 0x8b, 2, pagenum);
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_step_size(			SANE_Byte *regs,
/****************************************************************************/
					SANE_Int	stepsize)
{
	Hp_rts_set_value_lsbfirst(regs, 0xe2, 2, stepsize);
	Hp_rts_set_value_lsbfirst(regs, 0xe0, 2, 0);
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_set_all_registers( SANE_Int iHandle, void const *regs_)
/****************************************************************************/
{
	SANE_Byte	regs[255];

	memcpy(regs, regs_, 255);
	regs[32] &= ~0x40;

	if (Hp_rts_RegWrite(iHandle,0x32, regs[0x32]) < 0 ||
	    Hp35x0c_set_register_immediate(iHandle,0, 255, regs) < 0 ||
	    Hp_rts_RegWrite(iHandle,0x32, regs[0x32] | 0x40) < 0)
		return -1;
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_adjust_misc_registers(SANE_Byte *regs)
/****************************************************************************/
{
	/* Mostly unknown purposes - probably no need to adjust */
	regs[0xc6] = (regs[0xc6] & 0x0f) | 0x20; /* Purpose unknown - appears to do nothing */
	regs[0x2e] = 0x86;			/* ???? - Always has this value */
	regs[0x30] = 2;				/* CCPL = 1 */
	regs[0xc9] |= 0x38;			/* Doesn't have any obvious effect, but the Windows driver does this */
	return 0;
}


#define NVR_MAX_ADDRESS_SIZE	11
#define NVR_MAX_OPCODE_SIZE		3
#define NVR_DATA_SIZE			8
#define	NVR_MAX_COMMAND_SIZE	((NVR_MAX_ADDRESS_SIZE + \
				  NVR_MAX_OPCODE_SIZE + \
				  NVR_DATA_SIZE) * 2 + 1)

/****************************************************************************/
static SANE_Int
Hp35x0c_nvram_enable_controller(SANE_Int iHandle,SANE_Int enable)
/****************************************************************************/
{
	SANE_Byte r;

	if (Hp35x0c_read_register_immediate(iHandle,0x1d, 1, &r) < 0)
		return -1;
	if (enable)
		r |= 1;
	else
		r &= ~1;
	return Hp_rts_RegWrite(iHandle,0x1d, r);

}

/****************************************************************************/
static SANE_Int
Hp35x0c_nvram_init_command(SANE_Int iHandle)
/****************************************************************************/
{
	SANE_Byte regs[13];

	if (Hp35x0c_read_register_immediate(iHandle,0x10, 13, regs) < 0)
		return -1;
	regs[2] |= 0xf0;
	regs[4] = regs[4] & 0x1f | 0x60;
	return Hp35x0c_set_register_immediate(iHandle,0x10, 13, regs);
}

/****************************************************************************/
static SANE_Int
Hp35x0c_nvram_init_stdvars(SANE_Int iHandle,SANE_Int block,
/****************************************************************************/
			SANE_Int *addrbits,
			SANE_Byte *basereg)
{
	SANE_Int	bitsneeded;
	SANE_Int	capacity;

	switch (block)
	{
	case 0:
		bitsneeded = 7;
		break;

	case 1:
		bitsneeded = 9;
		break;

	case 2:
		bitsneeded = 11;
		break;

	default:
		bitsneeded = 0;
		capacity = 1;
		while (capacity < block)
			capacity <<= 1, ++bitsneeded;
		break;
	}

	*addrbits = bitsneeded;

	if (Hp35x0c_read_register_immediate(iHandle,0x10, 1, basereg) < 0)
		return -1;

	*basereg &= ~0x60;
	return 0;
}

/****************************************************************************/
static void
Hp35x0c_nvram_set_half_bit(	SANE_Byte *buffer,
/****************************************************************************/
			SANE_Int	value,
			SANE_Byte stdbits,
			SANE_Int	whichhalf)
{
	*buffer = stdbits | (value ? 0x40 : 0) | (whichhalf ? 0x20 : 0);
}

/****************************************************************************/
static void
Hp35x0c_nvram_set_command_bit(SANE_Byte *buffer,
/****************************************************************************/
			 SANE_Int value,
			 SANE_Byte stdbits)
{
	Hp35x0c_nvram_set_half_bit(buffer, value, stdbits, 0);
	Hp35x0c_nvram_set_half_bit(buffer + 1, value, stdbits, 1);
}

/****************************************************************************/
void
Hp35x0c_nvram_set_addressing_bits(	SANE_Byte *buffer,
/****************************************************************************/
				SANE_Int	location,
				SANE_Int	addressingbits,
				SANE_Byte stdbits)
{
	SANE_Int	currentbit = 1 << (addressingbits - 1);

	while (addressingbits--)
	{
		Hp35x0c_nvram_set_command_bit(buffer,
					 (location & currentbit) ? 1 : 0,
					 stdbits);
		buffer += 2;
		currentbit >>= 1;
	}
}

/****************************************************************************/
SANE_Int
Hp35x0c_nvram_enable_write(SANE_Int iHandle,SANE_Int	addressingbits,
/****************************************************************************/
			SANE_Int	enable,
			SANE_Byte stdbits)
{
	SANE_Byte cmdbuffer[NVR_MAX_COMMAND_SIZE];
	SANE_Byte cmdsize = 6 + addressingbits * 2;

	Hp35x0c_nvram_set_command_bit(cmdbuffer, 1, stdbits);
	Hp35x0c_nvram_set_command_bit(cmdbuffer + 2, 0, stdbits);
	Hp35x0c_nvram_set_command_bit(cmdbuffer + 4, 0, stdbits);
	Hp35x0c_nvram_set_command_bit(cmdbuffer + 6, enable, stdbits);
	if (addressingbits > 1)
		Hp35x0c_nvram_set_addressing_bits(cmdbuffer + 8, 0, addressingbits - 1, stdbits);

	if (Hp35x0c_nvram_enable_controller(iHandle,1) < 0 ||
	    Hp35x0c_send_command_immediate(iHandle,RTCMD_NVRAMCONTROL, 0, cmdsize, cmdsize, cmdbuffer, 0, 0) < 0 ||
	    Hp35x0c_nvram_enable_controller(iHandle,0) < 0)
	{
		return -1;
	}
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_nvram_write(SANE_Int iHandle, SANE_Int	block,
/****************************************************************************/
		SANE_Int	location,
		SANE_Char const *data,
		SANE_Int	bytes)
{
	SANE_Int addressingbits;
	SANE_Byte stdbits;
	SANE_Byte cmdbuffer[NVR_MAX_COMMAND_SIZE];
	SANE_Byte *address_bits;
	SANE_Byte *data_bits;
	SANE_Int	i;
	SANE_Int	cmdsize;
	SANE_Byte r;
	SANE_Byte cmd;

	/* This routine doesn't appear to work, but I can't see anything wrong with it */
	if (Hp35x0c_nvram_init_stdvars(iHandle,block, &addressingbits, &stdbits) < 0)
		return -1;

	cmdsize = (addressingbits + 8) * 2 + 6;
	address_bits = cmdbuffer + 6;
	data_bits = address_bits + (addressingbits * 2);

	Hp35x0c_nvram_set_command_bit(cmdbuffer, 1, stdbits);
	Hp35x0c_nvram_set_command_bit(cmdbuffer + 2, 0, stdbits);
	Hp35x0c_nvram_set_command_bit(cmdbuffer + 4, 1, stdbits);

	if (Hp35x0c_nvram_init_command(iHandle) < 0 ||
	    Hp35x0c_nvram_enable_write(iHandle,addressingbits, 1, stdbits) < 0)
		return -1;

	while (bytes--)
	{
		Hp35x0c_nvram_set_addressing_bits(address_bits, location, addressingbits, stdbits);
		Hp35x0c_nvram_set_addressing_bits(data_bits, *data++, 8, stdbits);

		if (Hp35x0c_nvram_enable_controller(iHandle,1) < 0 ||
		    Hp35x0c_send_command_immediate(iHandle,RTCMD_NVRAMCONTROL, 0, cmdsize, cmdsize, cmdbuffer, 0, 0) < 0 ||
		    Hp35x0c_nvram_enable_controller(iHandle,0) < 0)
			return -1;

		if (Hp35x0c_nvram_enable_controller(iHandle,1) < 0)
			return -1;
		for (i = 0; i < cmdsize; ++i)
		{
			Hp35x0c_nvram_set_half_bit(&cmd, 0, stdbits, i & 1);
			if (Hp35x0c_send_command_immediate(iHandle,RTCMD_NVRAMCONTROL, 0, 1, 1, &cmd, 0, 0) < 0 ||
			    Hp35x0c_read_register_immediate(iHandle,0x10, 1, &r) < 0)
			{
				return -1;
			}
			else if (r & 0x80)
			{
				break;
			}
		}
		if (Hp35x0c_nvram_enable_controller(iHandle,0) < 0)
			return -1;

		++location;
	}

	if (Hp35x0c_nvram_enable_write(iHandle,addressingbits, 0, stdbits) < 0)
		return -1;
	return 0;
}

/****************************************************************************/
SANE_Int
Hp35x0c_nvram_read(SANE_Int iHandle,SANE_Int	block,
/****************************************************************************/
		SANE_Int	location,
		SANE_Byte	*data,
		SANE_Int	bytes)
{
	SANE_Int addressingbits;
	SANE_Byte stdbits;
	SANE_Byte cmdbuffer[NVR_MAX_COMMAND_SIZE];
	SANE_Byte *address_bits;
	SANE_Byte readbit_command[2];
	SANE_Int	cmdsize;
	SANE_Byte r;
	SANE_Int	i;
	SANE_Char	c = 0;

	if (Hp35x0c_nvram_init_stdvars(iHandle,block, &addressingbits, &stdbits) < 0)
		return -1;

	cmdsize = addressingbits * 2 + 7;
	address_bits = cmdbuffer + 6;

	Hp35x0c_nvram_set_command_bit(cmdbuffer, 1, stdbits);
	Hp35x0c_nvram_set_command_bit(cmdbuffer + 2, 1, stdbits);
	Hp35x0c_nvram_set_command_bit(cmdbuffer + 4, 0, stdbits);
	Hp35x0c_nvram_set_half_bit(cmdbuffer + cmdsize - 1, 0, stdbits, 0);

	Hp35x0c_nvram_set_half_bit(readbit_command, 0, stdbits, 1);
	Hp35x0c_nvram_set_half_bit(readbit_command + 1, 0, stdbits, 0);

	if (Hp35x0c_nvram_init_command(iHandle) < 0)
		return -1;

	while (bytes--)
	{
		Hp35x0c_nvram_set_addressing_bits(address_bits, location, addressingbits, stdbits);

		if (Hp35x0c_nvram_enable_controller(iHandle,1) < 0 ||
		    Hp35x0c_send_command_immediate(iHandle,RTCMD_NVRAMCONTROL, 0x1d, cmdsize, cmdsize, cmdbuffer, 0, 0) < 0)
			return -1;

		for (i = 0; i < 8; ++i)
		{
			c <<= 1;

			if (Hp35x0c_send_command_immediate(iHandle,RTCMD_NVRAMCONTROL, 0x1d, 2, 2, readbit_command, 0, 0) < 0 ||
			    Hp35x0c_read_register_immediate(iHandle,0x10, 1, &r) < 0)
				return -1;
			if (r & 0x80)
				c |= 1;
		}
		if (Hp35x0c_nvram_enable_controller(iHandle,0) < 0)
			return -1;

		*data++ = c;
		++location;
	}
	return 0;
}


/****************************************************************************/
SANE_Int
Hp35x0c_rewind(THWParams *pHWParams)
/* Moves scanner to home position */
/****************************************************************************/
{
	SANE_Byte regs[255];
	SANE_Int iHandle;

	regs[1] = 0; /* only for the compiler */
	iHandle = pHWParams->iXferHandle;
	DBG(DBG_MSG,"Hp35x0c_rewind : park to home...");
#ifdef DEBUG_HP3500
	return 0;
#endif
  if (Hp35x0c_is_rewound(iHandle )){
		DBG(DBG_MSG,"Hp35x0c_rewind : i'm home\n");
		return 0;
	}
	DBG(DBG_MSG,"Hp35x0c_rewind : i must moving\n");
#if 0
	/* read all registers */
	Hp35x0c_read_register_immediate(iHandle,0, 255, regs);

	/* set registes 60/1 and 62/3 */
	Hp_rts_set_noscan_distance(regs, 59998);
	Hp_rts_set_total_distance(regs, 59999);

	/* clear Bit 4 from register b2 */
	Hp35x0c_set_stop_when_rewound(regs, 0);

	DBG(DBG_MSG,"Hp35x0c_rewind : Hp_rts_RegWrite 0xc6\n");
	Hp_rts_RegWrite(iHandle,0xc6, 0);
	DBG(DBG_MSG,"Hp35x0c_rewind : Hp_rts_RegWrite 0xc6\n");
	Hp_rts_RegWrite(iHandle,0xc6, 0);

	/* set register e2 to stepsize, e0 to 0 */
	Hp35x0c_set_step_size(regs, 0x0abd);

	/* set Bit 3 from register c6 to 0 */
	Hp35x0c_set_direction_rewind(regs);

	/* fast move */
	regs[0x39] = 15;
	/* Motor enable: It set bit 7. clear bit 0-2 and set bit 0
		regs[0xc3] = (regs[0xc3] & 0xf8) | 1; */
	regs[0xc3] |= 0x80;

	/* setzt in Register c6 step size auf 3 */
	regs[0xc6] = (regs[0xc6] & 0xf8) | 3;

	DBG(DBG_MSG,"Hp35x0c_rewind : Hp35x0c_set_all_registers\n");
	Hp35x0c_set_all_registers(iHandle,regs);
#else
	memcpy(pHWParams->regs,Hp35x0c_rewind_regs,255);
	/*-- motor resolution divisor*/
	pHWParams->regs[0x39] =0x0f;

	/*-- motor movement clock multiplier*/
	pHWParams->regs[0x40] =0xa0;

	/*-- noscan distance*/
	pHWParams->regs[0x60] =0x70;
	pHWParams->regs[0x61] =0xe7;

	/*-- total distance =noscan distance+1*/
	pHWParams->regs[0x62] =0x71;
	pHWParams->regs[0x63] =0xe7;

	/*-- no image data, stop when home*/
	/*   (careful, value becomes 0x12 after write)*/
	pHWParams->regs[0xb2] =0x14;

	/*-- coordinate space denominator=3D1, motor enable*/
	pHWParams->regs[0xc3] =0x81;

	/*-- backward direction, step size 0.5 (0x01) or 1 (0x03)*/
	/*    pHWParams->regs[0xc6] =0x21;*/
	pHWParams->regs[0xc6] =0x23;

	/*-- bounds movement range 1*/
	pHWParams->regs[0xe0] =0xf4;
	pHWParams->regs[0xe1] =0x07;

	/*-- Step size movement range 1*/
	pHWParams->regs[0xe2] =0xd0;
	pHWParams->regs[0xe3] =0x00;

	Hp35x0c_set_all_registers(iHandle,pHWParams->regs);

#endif
	Hp_rts_start_moving(iHandle);
	DBG(DBG_MSG,"Hp35x0c_rewind : Test, if the scanner is moving\n");
	while (!Hp35x0c_is_rewound(iHandle) /*&&
		(Hp_rts_data_ready(iHandle,&n) ||
		 Hp_rts_is_moving(iHandle) > 0)*/)
	{
		/*if (n)
		{
			SANE_Byte	buffer[0xffc0];

			if (n > (SANE_Int)sizeof(buffer))
				n = (SANE_Int)sizeof(buffer);
			Hp_rts_read_data(iHandle,n, buffer);
			DBG(DBG_MSG,"====> has read data\n");
		}
		else
		{*/
			DBG(DBG_MSG,"w");
			usleep(10000);
#if 0 /* short fix, because the scanner doesn't move  */
			break;
#endif
		/*}*/
	}
	DBG(DBG_MSG," moving done\n");
	return(Hp_rts_stop_moving(iHandle));
}


/****************************************************************************/
SANE_Bool Hp35x0c_init_scan(THWParams *pHWParams, TScanParams *pParams,
                    TDataPipe *pDataPipe)
/* code comes from rts8801_scan */
/****************************************************************************/
{
	SANE_Int	iHandle;
	SANE_Byte	offdutytime;
	SANE_Int	ires;
	SANE_Byte r93setting;
	SANE_Int	tg_setting;
	SANE_Word x1,x2,y,h;

	iHandle = pHWParams->iXferHandle;
	r93setting = r93setting;

	for (ires = 0; Hp35x0c_resparms[ires].resolution &&
								 Hp35x0c_resparms[ires].resolution != pParams->iDpi; ++ires);
	if (Hp35x0c_resparms[ires].resolution == 0){
		DBG(DBG_MSG,"Hp35x0c_init_scan: did not found this resolution %d\n",pParams->iDpi);
		return SANE_FALSE;
	}

	DBG(DBG_MSG,"Hp35x0c_init_scan: Use ires entry %d (%ddpi) for the resolution %d dpi\n",ires,
			Hp35x0c_resparms[ires].resolution, pParams->iDpi);

#ifdef ENABLE_VI8920
	DBG(DBG_MSG,"Vi8920 is enabled and will be run us a HP3500c\n");
#endif

	/* Initialise and power up */
#ifdef DEBUG_HP3500
	Hp35x0c_set_all_registers(iHandle,Hp44x0_switch_on_regs);
#else
	Hp35x0c_set_all_registers(iHandle,Hp35x0c_initial_regs);
	Hp35x0c_set_powersave_mode(iHandle,0);

	Hp35x0c_rewind(pHWParams);
  /* Warm up the lamp */
	Hp35x0c_detect_sram(iHandle,&sram_size, &r93setting);
	Hp35x0c_turn_on_lamp(iHandle);
	sleep(20);
#endif

  /* Set scan parameters */
	Hp35x0c_read_register_immediate(iHandle,0, 255, pHWParams->regs);
	pHWParams->regs[255] = 0;

	Hp35x0c_enable_ccd(pHWParams->regs, 1);
	Hp35x0c_enable_movement(pHWParams->regs, 1);
	Hp35x0c_set_scan_frequency(pHWParams->regs, 1);

	Hp35x0c_adjust_misc_registers(pHWParams->regs);
	Hp35x0c_set_cvtr_wparams(pHWParams->regs, 3, 0, 6);
	Hp35x0c_set_cvtr_mpt(pHWParams->regs, 15, 15, 15);
	Hp35x0c_set_cvtr_lm(pHWParams->regs, 7, 7, 7);
	Hp35x0c_set_motor_type(pHWParams->regs, 2);

 	offdutytime = 0;
	if (Hp35x0c_nvram_read(iHandle,0, 0x7b, &offdutytime, 1) < 0 ||
      offdutytime >= 15)
	{
  	offdutytime = 6;
	}
	Hp35x0c_set_lamp_duty_cycle(pHWParams->regs,
			1,		/* On */
			10,		/* Frequency */
			offdutytime);	/* Off duty time */

	Hp35x0c_set_movement_pattern(pHWParams->regs, 0x800000);

	tg_setting = Hp35x0c_resparms[ires].tg;
	Hp35x0c_set_ccd_shift_clock_multiplier(pHWParams->regs,
				tg_info[tg_setting].tg_cph0p);
	Hp35x0c_set_ccd_clock_reset_interval(pHWParams->regs,
				tg_info[tg_setting].tg_crsp);
	Hp35x0c_set_ccd_clamp_clock_multiplier(pHWParams->regs,
				tg_info[tg_setting].tg_cclpp);

	Hp_rts_RegWrite(iHandle,0xc6, 0);
	Hp_rts_RegWrite(iHandle,0xc6, 0);

	Hp35x0c_set_step_size(pHWParams->regs, Hp35x0c_resparms[ires].step_size);
	Hp35x0c_set_direction_forwards(pHWParams->regs);

	Hp35x0c_set_stop_when_rewound(pHWParams->regs, 0);
	Hp35x0c_set_data_feed_on(pHWParams->regs);

	Hp35x0c_set_calibration_addresses(pHWParams->regs, 0, 0, 0);

	Hp35x0c_set_basic_calibration(pHWParams->regs,
				0xc8, 0xc8, 0x0a,
				0xc6, 0xc6, 0x0c,
				0xc6, 0xc6, 0x0b);
	pHWParams->regs[0x0b] = 0x70;/* If set to 0x71, the alternative, all values are low*/

	switch (pParams->mode) {
		case GRAY:
			DBG(DBG_ERR, "Hp35x0c_init_scan: Use gray parameter\n");
			Hp35x0c_set_channel(pHWParams->regs, RT_CHANNEL_RED);
			Hp35x0c_set_single_channel_scanning(pHWParams->regs, 1); /* 0x20 on / 0ff*/
			Hp35x0c_set_merge_channels(pHWParams->regs, 1); /* 0x14 on / off */
			Hp35x0c_set_colour_mode(pHWParams->regs, 0); /* 0x02 on / off */
			break;
		case COLOR:
			DBG(DBG_ERR, "Hp35x0c_init_scan: use color parameter\n");
			Hp35x0c_set_channel(pHWParams->regs, RT_CHANNEL_ALL);
			Hp35x0c_set_single_channel_scanning(pHWParams->regs, 0); /* 0x20 on / 0ff*/
			Hp35x0c_set_merge_channels(pHWParams->regs, 1); /* 0x14 on / off */
			/*	Hp35x0c_set_merge_channels(pHWParams->regs, 0); * 0x14 on / off */
			Hp35x0c_set_colour_mode(pHWParams->regs, 1); /* 0x02 on / off */
			break;

		default:
			DBG(DBG_ERR, "Hp35x0c_init_scan: Invalid parameter\n");
			return SANE_FALSE;
	}/* switch */

	Hp35x0c_set_motor_movement_clock_multiplier(pHWParams->regs,
		Hp35x0c_resparms[ires].motor_movement_clock_multiplier);

	Hp35x0c_set_cdss(pHWParams->regs, tg_info[tg_setting].tg_cdss1,
		tg_info[tg_setting].tg_cdss2);
	Hp35x0c_set_cdsc(pHWParams->regs, tg_info[tg_setting].tg_cdsc1,
		tg_info[tg_setting].tg_cdsc2);

	Hp35x0c_update_after_setting_cdss2(pHWParams->regs);

	Hp35x0c_set_last_sram_page(pHWParams->regs, (sram_size - 1) >> 5);

	pHWParams->regs[0x39] = Hp35x0c_resparms[ires].reg_39_value;
	pHWParams->regs[0xc3] = (pHWParams->regs[0xc3] & 0xf8) |
		 	Hp35x0c_resparms[ires].reg_c3_value;
	pHWParams->regs[0xc6] = (pHWParams->regs[0xc6] & 0xf8) |
			 Hp35x0c_resparms[ires].reg_c6_value;
	Hp35x0c_set_scan_frequency(pHWParams->regs, Hp35x0c_resparms[ires].scan_frequency);
	Hp35x0c_set_cph0s(pHWParams->regs, Hp35x0c_resparms[ires].cph0s);

	x1 = pParams->iX;
	x2 = pParams->iWidth + pParams->iX;
	y = pParams->iY;
	h = pParams->iLenght;/* * 2;*/
	DBG(DBG_MSG,"Hp35x0c_init_scan: calculate scandata x1 = %d; x2 = %d; lenght = %d\n",x1,x2,h);
	pDataPipe->iScanned = h;
	DBG(DBG_MSG,"Hp35x0c_init_scan: Hp35x0c_set_horizontal_resolution %d.\n",pParams->iDpi);
	Hp35x0c_set_horizontal_resolution(pHWParams->regs, pParams->iDpi);

	/* modify reg 60 + 61 */
/*	Hp_rts_set_noscan_distance(pHWParams->regs, y *
			 Hp35x0c_resparms[ires].scan_frequency -  1);*/
	Hp_rts_set_noscan_distance(pHWParams->regs, 0x01 );

	/* modify reg 62 + 63 */
/*	Hp_rts_set_total_distance(pHWParams->regs, Hp35x0c_resparms[ires].scan_frequency *
				(y + h + ((pParams->mode == COLOR) ? (Hp35x0c_resparms[ires].red_green_offset +
				Hp35x0c_resparms[ires].green_blue_offset) : 0) +
				Hp35x0c_resparms[ires].intra_channel_offset));*/
	Hp_rts_set_total_distance(pHWParams->regs, h );

	/* modify reg 66 + 67 */
/*	Hp_rts_set_scanline_start(pHWParams->regs, x1 * (1200 / pParams->iDpi) / (Hp35x0c_resparms[ires].cph0s ? 1 : 2));*/
	Hp_rts_set_scanline_start(pHWParams->regs, x1 );

	/* modify reg 6C + 6D */
/*	Hp_rts_set_scanline_end(pHWParams->regs, (x1 + x2) * (1200 / pParams->iDpi) / (Hp35x0c_resparms[ires].cph0s ? 1 : 2));*/
	Hp_rts_set_scanline_end(pHWParams->regs, x2 );

#if 1
	DBG(DBG_MSG,"Hp35x0c_init_scan: Hp35x0c_set_all_registers\n");
	Hp_rts_DumpHex(pHWParams->regs,255,16,SANE_TRUE);
	Hp_rts_DumpBits(0x2f, pHWParams->regs[0x2f]);
#endif
#ifdef DEBUG_HP3500
	return SANE_FALSE;
#endif
	Hp35x0c_set_all_registers(iHandle, pHWParams->regs);

	Hp_rts_RegWrite(iHandle, 0x2c, pHWParams->regs[0x2c]);

	Hp_rts_start_moving(iHandle);
	usleep(10000);
	/* wait for moving and check it */
	return(Hp_rts_Check_Moving (iHandle));
}

/****************************************************************************/
SANE_Bool Hp35x0c_init_power_on(THWParams *pHWParams)
/****************************************************************************/
{
	SANE_Int	iHandle;

	iHandle = pHWParams->iXferHandle;
	Hp35x0c_set_all_registers(iHandle,Hp35x0c_initial_regs);
	Hp35x0c_set_powersave_mode(iHandle,0);
#ifndef DEBUG_HP3500
	return(Hp35x0c_rewind(pHWParams));
#else
	return 0;
#endif
}




 /* sane - Scanner Access Now Easy.
   Copyright (C) 2003 Johannes Hub (JohannesHub@t-online.de)

   This file was initially copied from the hp3300 backend.
   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 exutable, 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.
*/

/*
    Concept for a backend for scanners based on the RTS88xx chipset,
    such as HP3500C, 3530C, and HP ScanJet 3570C.
    Parts of this source were inspired by other backends.

		History:

		Version 0.18  21.11.04 13.alpha,
				- source sorted,
				- now only SANEI_USB_SUPPORT for a better overview(xfermodules removed)
				- read and verify the MainBoardID 
		Version 0.17p 02.11.04 12.alpha, source sorted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17p 02.11.04 12.alpha, source sourted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17b 30.03.04 10.alpha, little fixes and libusb implemented
		Version 0.17  09.03.04 9. alpha, HP3500 included
		Version 0.16  06.02.04 8. alpha, wait counting on LCD
		Version 0.15a 29.01.04 7. alpha, CCD switch moved to config file
		Version 0.15  11.01.04 6. alpha, a second CCD implemented
		Version 0.13a 21.11.04 4. alpha, an little fix included
		Version 0.12  22.10.03 third alpha, Backend name changed to HP_RTS88xx
		Version 0.11  30.08.03 second alpha
		Version 0.10  19.07.03 first alpha
*/

/*
    Core HP35x0c functions.
*/


#ifndef _HP_RTS_HP35x0C_H_
#define _HP_RTS_HP35x0C_H_

#include <unistd.h>

SANE_Byte	Hp35x0c_initial_regs[] =
{
	0xf5,0x41,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x00,
	0xe1,0xfc,0xff,0xff,0x00,0x00,0x00,0xfc,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x06,0x19,
	0xd0,0x7a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa0,0x37,0xff,0x0f,0x00,0x00,
	0x80,0x00,0x00,0x00,0x8c,0x76,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x20,0xbc,0x03,0x00,0x00,0x00,0x00,0x00,0x1d,0x1f,0x00,0x1f,0x00,0x00,0x00,0x00,
	0x5e,0xea,0x5f,0xea,0x00,0x80,0x64,0x00,0x00,0x00,0x00,0x00,0x84,0x04,0x00,0x00,
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,
	0x0f,0x02,0x4b,0x02,0x00,0xec,0x19,0xd8,0x2d,0x87,0x02,0xff,0x3f,0x78,0x60,0x00,
	0x1c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0x00,0x0c,0x27,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x12,0x08,0x06,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0x80,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0xff,0xbf,0xff,0xff,0x00,0x00,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
};

SANE_Byte	Hp35x0c_rewind_regs[] =
{
	0xe5,0x41,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x00,
	0x01,0x00,0x01,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xeb,0xed,0xe0,0x01,0x00,0x20,0x86,0x0b,
	0x02,0xa6,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa6,0xff,0x8f,0x00,0x00,
	0x20,0x00,0x00,0x00,0x8c,0x76,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1f,0x10,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x64,0x00,
	0x00,0x00,0x00,0x02,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0x01,0x0f,0x18,0x31,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0x80,0x00,0x10,0x0a,0x00,0x00,0x00,0x3a,0x0a,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0x1f,0x4c,0x00,0x0c,0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0x00,0x00,0xf8,0x2a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
	0xe0,0xff,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3c,0x00,0x30,0x00
};

struct Hp35x0c_tg_info__
{
	SANE_Word	tg_cph0p;
	SANE_Word	tg_crsp;
	SANE_Word	tg_cclpp;
	SANE_Word	tg_cdss1;
	SANE_Word	tg_cdsc1;
	SANE_Word	tg_cdss2;
	SANE_Word	tg_cdsc2;
} tg_info[] =
{
	/*	CPH0P		CRSP		CCLPP		CDSS1	CDSC1	CDSS2	CDSC2	*/
	{	0x01FFE0,	0x3c0000,	0x003000,	0xb,	0xd,	0x00,	0x01	},	/* NORMAL*/
	{	0x7ff800,	0xf00000,	0x01c000,	0xb,	0xc,	0x14,	0x15	}	/* DOUBLE*/
};

struct	Hp35x0c_resolution_parameters
{
	SANE_Int	resolution;
	SANE_Byte		reg_39_value;
	SANE_Byte		reg_c3_value;
	SANE_Byte		reg_c6_value;
	SANE_Byte		scan_frequency;
	SANE_Byte		cph0s;
	SANE_Byte		red_green_offset;
	SANE_Byte		green_blue_offset;
	SANE_Byte		intra_channel_offset;
	SANE_Byte		motor_movement_clock_multiplier;
	SANE_Byte		tg;
	SANE_Word		step_size;
};

static struct Hp35x0c_resolution_parameters Hp35x0c_resparms[] =
{
	/* My values - all work */
	/*res.,39, c3, c6, freq.chp,gre blu itr mm  tg  steps. */
	{	1200,	3,	6,	4,	2,	1,	22,	22,	4,	2,	0,	0x157b	},
	{	600,	3,	3,	1,	1,	0,	9,	10,	0,	2,	0,	0x157b	},
	{	400,	1,	1,	1,	1,	1,	6,	6,	1,	2,	0,	0x157b	},
	{	300,	3,	3,	3,	1,	0,	5,	4,	0,	2,	1,	0x157b	},
	{	200,	3,	1,	1,	1,	0,	3,	3,	0,	2,	1,	0x157b	},
	{	150,	3,	3,	3,	2,	0,	2,	2,	0,	2,	1,	0x157b	},
	{	100,	3,	1,	3,	1,	0,	1,	1,	0,	2,	1,	0x157b	},
	{	 75,	3,	3,	3,	4,	0,	1,	1,	0,	2,	1,	0x157b	},
	{	 50,	3,	1,	3,	2,	0,	0,	0,	0,	2,	1,	0x157b	},
	{	 25,	3,	1,	3,	4,	0,	0,	0,	0,	2,	1,	0x157b	},
	{	  0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0,	0x157b	}
};

#define	REG_DESTINATION_POSITION 0x60

#define RTCMD_GETREG		0x80
#define	RTCMD_READSRAM		0x81

#define	RTCMD_SETREG		0x88
#define	RTCMD_WRITESRAM		0x89

#define	RTCMD_NVRAMCONTROL	0x8a

#define	RTCMD_BYTESAVAIL	0x90
#define	RTCMD_READBYTES		0x91

#define	RT_CHANNEL_ALL		0
#define	RT_CHANNEL_RED		1
#define	RT_CHANNEL_GREEN	2
#define	RT_CHANNEL_BLUE		3

#if 0
static SANE_Int
Hp35x0c_set_value_msbfirst(	SANE_Byte	*regs,
			SANE_Int		firstreg,
			SANE_Int		totalregs,
			SANE_Word	value);
#endif
SANE_Int
Hp35x0c_queue_read_register( SANE_Int iHandle, SANE_Byte reg, SANE_Int bytes, SANE_Byte *data);

SANE_Int
Hp35x0c_read_register_immediate( SANE_Int iHandle, SANE_Int reg, SANE_Int bytes, SANE_Byte *data);

SANE_Int
Hp35x0c_set_register_immediate( SANE_Int iHandle, SANE_Int reg, SANE_Int bytes, SANE_Byte *data);

SANE_Int
Hp35x0c_send_command_immediate( SANE_Int iHandle, SANE_Int command,
				SANE_Byte	reg,
				SANE_Int	count,
				SANE_Int	bytes,
				SANE_Byte	*data,
				SANE_Int	readbytes,
				SANE_Byte	*readdata);

SANE_Int
Hp35x0c_write_sram( SANE_Int iHandle, SANE_Word	bytes, SANE_Byte	*data);

SANE_Int
Hp35x0c_read_sram( SANE_Int iHandle, SANE_Int	bytes, SANE_Byte *data);

SANE_Int
Hp35x0c_set_sram_page( SANE_Int iHandle, SANE_Byte	page);

SANE_Int
Hp35x0c_detect_sram( SANE_Int iHandle, SANE_Word *totalbytes, SANE_Byte *r93setting);

SANE_Int
Hp35x0c_is_rewound( SANE_Int iHandle );

SANE_Int
Hp35x0c_set_direction_forwards(SANE_Byte *regs);

SANE_Int
Hp35x0c_set_direction_rewind(SANE_Byte *regs);

SANE_Int
Hp35x0c_set_stop_when_rewound( SANE_Byte *regs, SANE_Int	stop);

SANE_Int
Hp35x0c_set_distances( SANE_Int iHandle,SANE_Int location1,
		   SANE_Int location2);

SANE_Int
Hp35x0c_set_powersave_mode(SANE_Int iHandle,SANE_Int enable);

SANE_Int
Hp35x0c_lamp_ready( SANE_Int iHandle );

SANE_Int
Hp35x0c_turn_off_lamp( SANE_Int iHandle );

SANE_Int
Hp35x0c_turn_on_lamp( SANE_Int iHandle );
#if 0
static SANE_Int
Hp35x0c_set_value_msbfirst(	SANE_Byte	*regs,SANE_Int firstreg,
			SANE_Int		totalregs,SANE_Word	value);
#endif
SANE_Int
Hp35x0c_set_ccd_shift_clock_multiplier(	SANE_Byte	*regs,
					SANE_Word	value);

SANE_Int
Hp35x0c_set_ccd_sample_clock_multiplier(	SANE_Byte	*regs,
					SANE_Word	value);

SANE_Int
Hp35x0c_set_ccd_clock_reset_interval(	SANE_Byte	*regs,
					SANE_Word	value);

SANE_Int
Hp35x0c_set_ccd_clamp_clock_multiplier(	SANE_Byte	*regs,
					SANE_Word	value);

SANE_Int
Hp35x0c_set_movement_pattern(		SANE_Byte	*regs,
					SANE_Word	value);

SANE_Int
Hp35x0c_set_motor_movement_clock_multiplier(	SANE_Byte	*regs,
					SANE_Word	value);

SANE_Int
Hp35x0c_set_motor_type(			SANE_Byte	*regs,
					SANE_Word	value);

SANE_Int
Hp35x0c_set_basic_calibration(		SANE_Byte *regs,
					SANE_Int	redoffset1,
					SANE_Int	redoffset2,
					SANE_Int	redgain,
					SANE_Int	greenoffset1,
					SANE_Int	greenoffset2,
					SANE_Int	greengain,
					SANE_Int	blueoffset1,
					SANE_Int	blueoffset2,
					SANE_Int	bluegain);

SANE_Int
Hp35x0c_set_calibration_addresses(		SANE_Byte *regs,
					SANE_Word	redaddr,
					SANE_Word	blueaddr,
					SANE_Word	greenaddr);

SANE_Int
Hp35x0c_set_lamp_duty_cycle(			SANE_Byte *regs,
					SANE_Int	enable,
					SANE_Int	frequency,
					SANE_Int	offduty);

SANE_Int
Hp35x0c_set_data_feed_on(			SANE_Byte *regs);

SANE_Int
Hp35x0c_set_data_feed_off(			SANE_Byte *regs);

SANE_Int
Hp35x0c_enable_ccd(				SANE_Byte *regs,
					SANE_Int enable);

SANE_Int
Hp35x0c_set_cdss(				SANE_Byte *regs,
					SANE_Int	val1,
					SANE_Int	val2);

SANE_Int
Hp35x0c_set_cdsc(				SANE_Byte *regs,
					SANE_Int	val1,
					SANE_Int	val2);

SANE_Int
Hp35x0c_update_after_setting_cdss2(		SANE_Byte *regs);

SANE_Int
Hp35x0c_set_cph0s(				SANE_Byte *regs,
					SANE_Int	on);

SANE_Int
Hp35x0c_set_cvtr_lm(				SANE_Byte *regs,
					SANE_Int	val1,
					SANE_Int	val2,
					SANE_Int	val3);

SANE_Int
Hp35x0c_set_cvtr_mpt(			SANE_Byte *regs,
					SANE_Int	val1,
					SANE_Int	val2,
					SANE_Int	val3);

SANE_Int
Hp35x0c_set_cvtr_wparams(			SANE_Byte *regs,
					SANE_Word fpw,
					SANE_Word bpw,
					SANE_Word w);

SANE_Int
Hp35x0c_enable_movement(			SANE_Byte *regs,
					SANE_Int	enable);

SANE_Int
Hp35x0c_set_scan_frequency(			SANE_Byte *regs,
					SANE_Int	frequency);

SANE_Int
Hp35x0c_set_merge_channels(			SANE_Byte *regs,
					SANE_Int	on);

SANE_Int
Hp35x0c_set_channel(				SANE_Byte *regs,
					SANE_Int	channel);

SANE_Int
Hp35x0c_set_single_channel_scanning(		SANE_Byte *regs,
					SANE_Int	on);

SANE_Int
Hp35x0c_set_colour_mode(			SANE_Byte *regs,
					SANE_Int	on);

SANE_Int
Hp35x0c_set_horizontal_resolution(		SANE_Byte *regs,
					SANE_Int	resolution);

SANE_Int
Hp35x0c_set_last_sram_page(			SANE_Byte *regs,
					SANE_Int	pagenum);

SANE_Int
Hp35x0c_set_step_size(			SANE_Byte *regs,
					SANE_Int	stepsize);

SANE_Int
Hp35x0c_set_all_registers( SANE_Int iHandle, void const *regs_);

SANE_Int
Hp35x0c_adjust_misc_registers(SANE_Byte *regs);

static SANE_Int
Hp35x0c_nvram_enable_controller(SANE_Int iHandle,SANE_Int enable);

static SANE_Int
Hp35x0c_nvram_init_command(SANE_Int iHandle);

static SANE_Int
Hp35x0c_nvram_init_stdvars(SANE_Int iHandle,SANE_Int block,
			SANE_Int *addrbits,
			SANE_Byte *basereg);

static void
Hp35x0c_nvram_set_half_bit(	SANE_Byte *buffer,
			SANE_Int	value,
			SANE_Byte stdbits,
			SANE_Int	whichhalf);

static void
Hp35x0c_nvram_set_command_bit(SANE_Byte *buffer,
			 SANE_Int value,
			 SANE_Byte stdbits);

void
Hp35x0c_nvram_set_addressing_bits(	SANE_Byte *buffer,
				SANE_Int	location,
				SANE_Int	addressingbits,
				SANE_Byte stdbits);

SANE_Int
Hp35x0c_nvram_enable_write(SANE_Int iHandle,SANE_Int	addressingbits,
			SANE_Int	enable,
			SANE_Byte stdbits);

SANE_Int
Hp35x0c_nvram_write(SANE_Int iHandle,SANE_Int	block,
		SANE_Int	location,
		SANE_Char const *data,
		SANE_Int	bytes);

SANE_Int
Hp35x0c_nvram_read(SANE_Int iHandle,SANE_Int	block,
		SANE_Int	location,
		SANE_Byte	*data,
		SANE_Int	bytes);

SANE_Int  Hp35x0c_rewind(THWParams *pHWParams);

SANE_Bool Hp35x0c_init_scan(THWParams *pHWParams, TScanParams *pParams,
                    TDataPipe *pDataPipe);

SANE_Bool Hp35x0c_init_power_on(THWParams *pHWParams);

#endif /* NO _HP_RTS_HP35x0C_H_ */





 /* sane - Scanner Access Now Easy.
   Copyright (C) 2003 Johannes Hub (JohannesHub@t-online.de)

   This file was initially copied from the hp3300 backend.
   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 exutable, 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.
*/

/*
    Concept for a backend for scanners based on the RTS88xx chipset,
    such as HP4400C, HP4470C.
    Parts of this source were inspired by other backends.

		History:

		Version 0.18  21.11.04 13.alpha,
				- source sorted,
				- now only SANEI_USB_SUPPORT for a better overview(xfermodules removed)
				- read and verify the MainBoardID 
		Version 0.17p 02.11.04 12.alpha, source sorted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17p 02.11.04 12.alpha, source sourted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17b 30.03.04 10.alpha, little fixes and libusb implemented
		Version 0.17  09.03.04 9. alpha, HP3500 included
		Version 0.16  06.02.04 8. alpha, wait counting on LCD
		Version 0.15a 29.01.04 7. alpha, CCD switch moved to config file
		Version 0.15  11.01.04 6. alpha, a second CCD implemented
		Version 0.13a 21.11.04 4. alpha, an little fix included
		Version 0.12  22.10.03 third alpha, Backend name changed to HP_RTS88xx
		Version 0.11  30.08.03 second alpha
		Version 0.10  19.07.03 first alpha
*/

/*
    Core HP44x0c 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 "hp_rts_xfer.h"
#include "hp_rts_44x0c.h"


/****************************************************************************/
SANE_Bool Hp44x0_Wakeup(THWParams *pHWParams,TScanParams *pParams)
/****************************************************************************/
{
	SANE_Byte Reg_10, Reg_11;
	SANE_Int iHandle;

	DBG(DBG_SCAN, "Hp44x0_Wakeup....\n");
	/* prevent compiler from complaining about unused parameters */
	pParams->mode = pParams->mode;
	iHandle = pHWParams->iXferHandle;

	if (iHandle < 0) {
		DBG(DBG_SCAN, "Hp44x0_Wakeup, wrong iHandle\n");
		return SANE_FALSE;
	}
	/* write magic startup sequence */
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x00))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x00))) return SANE_FALSE;
	/*  test_reg( 0xb2,0x00,20 );*/
	if ( !(Hp_rts_RegWrite(iHandle,0xb2,0x02))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xb1,0x00))) return SANE_FALSE;
	if (pParams->optXPA)
		Reg_11 = 0x08;
	else
		Reg_11 = 0x28;
	Reg_10 = 0x28;
	if ( !(Hp_rts_Set_double_reg(iHandle, LEDSTATUS, Reg_10, Reg_11 ))) return SANE_FALSE;
	usleep(1000);
	/*  test_double_reg( 0x20,0x3a,0xf2,21 );*/
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x01))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x01))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x00))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x00))) return SANE_FALSE;
	if ( !(Hp_rts_Set_double_reg(iHandle,0x12,0xff,0x20))) return SANE_FALSE;
	if ( !(Hp_rts_Set_double_reg(iHandle,0x14,0xf8,0x28))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x00))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x00))) return SANE_FALSE;
	if ( !(Hp_rts_Set_double_reg(iHandle, LEDSTATUS, Reg_10, Reg_11 ))) return SANE_FALSE;
	usleep(1000);
	if ( !(Hp_rts_RegWrite(iHandle,0xd9,0x80))) return SANE_FALSE;
	memcpy(pHWParams->regs,Hp44x0_switch_on_regs,254);
	pHWParams->regs[0x10] = Reg_10;
	pHWParams->regs[0x11] = Reg_11;
	if ( !(Hp_rts_BulkWrite (iHandle, 0x00,pHWParams->regs, 0xb3,SANE_TRUE))) return SANE_FALSE;
	return (Hp_rts_BulkWrite (iHandle, 0xb4,pHWParams->regs+0xb3, 0x3f,SANE_TRUE));

	/*  need we a new callibriation ? */
}


/****************************************************************************/
SANE_Bool Hp44x0_Down(SANE_Int iHandle)
/****************************************************************************/
{
	DBG(DBG_SCAN, "Hp44x0_Down....\n");
	if (iHandle <= 0) {
		return SANE_FALSE;
	}
	/* switch off the little green LEDs for color selector */
	if ( !(Hp_rts_Set_double_reg(iHandle,LEDSTATUS,0x08,0x28))) return SANE_FALSE;
	usleep(10000);
	/*test_reg( 0xb2, 0x02,13 ); */
	/* switch off the green power LED */
	if ( !(Hp_rts_RegWrite(iHandle,0xb2,0x00))) return SANE_FALSE;
	/* ?? */
	if ( !(Hp_rts_RegWrite(iHandle,0xb1,0x00))) return SANE_FALSE;
	/* switch off lamp, LCD and power LED */
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x04))) return SANE_FALSE;
	return (Hp_rts_RegWrite(iHandle,0xb3,0x04));
}

/****************************************************************************/
SANE_Bool Hp44x0_patch_and_send_values(SANE_Int iHandle, SANE_Byte *my_values){
/****************************************************************************/
	/* read registers, patch and write out them */
	SANE_Byte v1,v2;

	DBG(DBG_SCAN, "Hp44x0_patch_and_send_values....\n");
	Hp_rts_BulkReadall(iHandle,registers);
	v1 = *my_values++;
	v2 = *my_values++;
	registers[v1] = v2;
	while(*my_values){
		v1 = *my_values++;
		v2 = *my_values++;
		registers[v1] = v2;
	}
	if ( !(Hp_rts_BulkWrite(iHandle,0x00,registers,0xb3,SANE_TRUE))) return SANE_FALSE;
	return (Hp_rts_BulkWrite(iHandle,0xb4,registers+0xb3,0x3f,SANE_TRUE));
}

/****************************************************************************/
void Hp44x0_patch_regs(THWParams *pHWParams,SANE_Byte *my_values){
/****************************************************************************/
	/* read registers, patch and write out them */
	SANE_Byte v1,v2;

	DBG(DBG_SCAN, "Hp44x0_patch_regs....\n");
	v1 = *my_values++;
	v2 = *my_values++;
	pHWParams->regs[v1] = v2;
	while(*my_values){
		v1 = *my_values++;
		v2 = *my_values++;
		pHWParams->regs[v1] = v2;
	}
}

/****************************************************************************/
SANE_Bool Hp44x0_set_display( SANE_Int iHandle, SANE_Byte val )
/****************************************************************************/
{
	static SANE_Word LcdValues_h []=
	/* left char       0,      1,     2,     3 */
			{ 0xa18f2,0x0890,0x10b3,0x18b1};
	static SANE_Word LcdValues_l []=
	/* right char       0,      1,     2,     3      4 */
			{ 0xa68c,0x2280,0xe484,0x6684,0x6288,
	/*                  5,      6,     7,     8      9 */
			  0x468c,0xc68c,0x2284,0xe68c,0x668c};
	SANE_Byte reg_20,reg_21;

	DBG(DBG_SCAN, "Hp44x0_set_display.to %d\n",val);
	if (val < 40){
		reg_20 = (LcdValues_l [val%10]  >> 8) & 0x00ff;
		reg_21 =  LcdValues_l [val%10] & 0x00ff;
		reg_20 = reg_20 | (LcdValues_h [val/10]  >> 8) & 0x00ff;
		reg_21 = reg_21 |  LcdValues_h [val/10] & 0x00ff;
		if ( !(Hp_rts_RegWrite(iHandle,MOVE_START_STOP,0x00))) return SANE_FALSE;
		return (Hp_rts_Set_double_reg(iHandle, LCD_CONTROL1, reg_20, reg_21 ));
	};
	return SANE_TRUE;
}

/****************************************************************************/
SANE_Bool Hp44x0_write_cal_bytes( THWParams *pHWParams, SANE_Byte b ) {
/****************************************************************************/
  SANE_Word i,n;
  SANE_Int iHandle;

	DBG(DBG_SCAN, "Hp44x0_write_cal_bytes....\n");
  iHandle = pHWParams->iXferHandle;
  callibration_buffer[0]=0x89;
  callibration_buffer[1]=0x00;
  callibration_buffer[2]=0x00;
  callibration_buffer[3]=0x20;
  callibration_buffer[4]=0;
  n = 2;
  for(i=5;i<36;i++) {
     callibration_buffer[i]   = b;
     callibration_buffer[i+1] = n;
     i++;
     n = n + 2;
  }
  return (Hp_rts_BulkWrite(iHandle,0x00,callibration_buffer,36,SANE_FALSE));
}


/****************************************************************************/
SANE_Bool Hp44x0_cal_scanner(THWParams *pHWParams, TScanParams *pParams) {
/****************************************************************************/
  SANE_Word i,n;
  SANE_Int iHandle;
  SANE_Byte Reg_10, Reg_11;

	DBG(DBG_SCAN, "Hp44x0_cal_scanner....\n");
  iHandle = pHWParams->iXferHandle;
  if ( !(Hp_rts_RegWrite(iHandle,MOVE_START_STOP,0x00))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,MOVE_START_STOP,0x00))) return SANE_FALSE;
  memcpy(registers,Hp44x0_init_1,0xf4);
  if (pParams->mode == COLOR){
     Reg_10 = 0x28;
  } else {
     Reg_10 = 0x18;}
  if (pParams->optXPA){
     Reg_11 = 0x1b;
  } else {
     Reg_11 = 0x3b;}
  registers[0x10] = Reg_10;
  registers[0x11] = Reg_11;
  if ( !(Hp_rts_BulkWrite(iHandle,0x00,registers,0xb3,SANE_TRUE))) return SANE_FALSE;
  if ( !(Hp_rts_BulkWrite(iHandle,0xb4,registers+0xb3,0x3f,SANE_TRUE))) return SANE_FALSE;
  if ( !(Hp44x0_patch_and_send_values(iHandle,Hp44x0_patch_2))) return SANE_FALSE;
  if ( !(Hp44x0_patch_and_send_values(iHandle,Hp44x0_patch_3))) return SANE_FALSE;

/*  if (pParams->mode == COLOR){*/
     if ( !(Hp_rts_Set_double_reg(iHandle, LEDSTATUS, 0x20, 0x28))) return SANE_FALSE;
/*     usleep(10000);*/
     if ( !(Hp_rts_Set_double_reg(iHandle, LEDSTATUS, 0x28, 0x28))) return SANE_FALSE;
/*
  } else {
     if ( !(Hp_rts_Set_double_reg(iHandle, LEDSTATUS, 0x10, 0x28))) return SANE_FALSE;
     usleep(10000);
     if ( !(Hp_rts_Set_double_reg(iHandle, LEDSTATUS, 0x18, 0x28))) return SANE_FALSE;
  }
*/
  usleep(10000);
  if ( !(Hp_rts_RegWrite(iHandle,MOVE_START_STOP,0x02))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,MOVE_START_STOP,0x02))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,MOVE_START_STOP,0x00))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,MOVE_START_STOP,0x00))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,MOVE_START_STOP,0x00))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,MOVE_START_STOP,0x00))) return SANE_FALSE;
  if ( !(Hp44x0_patch_and_send_values(iHandle,Hp44x0_patch_4))) return SANE_FALSE;

  for (n=0;n<3;n++){
    switch (n){
      case 0: if ( !(Hp_rts_RegWrite(iHandle,0x93,0x06))) return SANE_FALSE; break;
      case 1: if ( !(Hp_rts_RegWrite(iHandle,0x93,0x02))) return SANE_FALSE; break;
      case 2: if ( !(Hp_rts_RegWrite(iHandle,0x93,0x01))) return SANE_FALSE; break;
      default:;
    }
    if ( !(Hp_rts_Set_double_reg(iHandle,0x91, 0x81, 0x00))) return SANE_FALSE;
    callibration_buffer[0]=0x89;
    callibration_buffer[1]=0x00;
    callibration_buffer[2]=0x08;
    callibration_buffer[3]=0x18;
    callibration_buffer[4]=0;
    for(i=5;i<0x818;i++) {
       callibration_buffer[i]=callibration_buffer[i-1]+1;
       if(callibration_buffer[i]==0x61) callibration_buffer[i]=0;
    };
    if ( !(Hp_rts_BulkWrite(iHandle,0x00,callibration_buffer,0x818+4,SANE_FALSE))) return SANE_FALSE;
    if ( !(Hp35x0c_set_sram_page(iHandle,0x81))) return SANE_FALSE;
/*    Hp_rts_Set_double_reg(iHandle,0x91, 0x81, 0x00);*/
    if ( !(Hp_rts_Read_Sram (iHandle, callibration_buffer,0x0818))) return SANE_FALSE;
#if 0
    read_bulk_callibriation_data(callibration_buffer,0x0818);
/*    read_bulk_callibriation_data(buffer2,0x0818); and verify it*/
#endif
	};
  memcpy(registers,Hp44x0_init_5,0xf4);
/*
  if (pParams->mode == COLOR){
     registers[LEDSTATUS] = 0x28;
  } else {
     registers[LEDSTATUS] = 0x18;
  }*/
  if ( !(Hp_rts_BulkWrite(iHandle,0x00,registers,0xb3,SANE_TRUE))) return SANE_FALSE;
  if ( !(Hp_rts_BulkWrite(iHandle,0xb4,registers+0xb3,0x3f,SANE_TRUE))) return SANE_FALSE;

  for(i=0;i<5;i++) {
    if ( !(Hp44x0_write_cal_bytes( pHWParams, i ))) return SANE_FALSE;
    if ( !(Hp_rts_Set_double_reg(iHandle, 0x91, 0x00, 0x10 ))) return SANE_FALSE;
/*    read_bulk_callibriation_data(buffer2,0x20); and verify it*/
  };
  if ( !(Hp_rts_RegWrite(iHandle,LAMPREG,0x80))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,LAMPREG,0xad))) return SANE_FALSE;
  if ( !(Hp_rts_Set_double_reg(iHandle, 0x14, 0x78, 0x28 ))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,LAMP_INTENSITY,0xa0))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,LAMP_INTENSITY,0xa7))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,LAMPREG,0x8d))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,LAMPREG,0xad))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,BUTTON_1,0x00))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,BUTTON_2,0x00))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,BUTTON_1,0x00))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,BUTTON_2,0x00))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,LAMP_INTENSITY,0xa0))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,LAMP_INTENSITY,0xa7))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,MOVE_START_STOP,0x00))) return SANE_FALSE;
  if ( !(Hp_rts_RegWrite(iHandle,MOVE_START_STOP,0x00))) return SANE_FALSE;

  if (pParams->mode == COLOR){
     if ( !(Hp_rts_Set_double_reg(iHandle, 0x10, 0x28, 0x3f))) return SANE_FALSE;
  } else {
     if ( !(Hp_rts_Set_double_reg(iHandle, 0x10, 0x18, 0x3f))) return SANE_FALSE;
  }
  usleep(10000);
  if ( !(Hp_rts_RegWrite(iHandle,LAMPREG,0xad))) return SANE_FALSE;
  usleep(10000);
/*  if (pParams->mode == COLOR){*/
     if ( !(Hp_rts_Set_double_reg(iHandle, LEDSTATUS, 0x20, 0x3f))) return SANE_FALSE;
/*  } else {
     if ( !(Hp_rts_Set_double_reg(iHandle, LEDSTATUS, 0x10, 0x3f))) return SANE_FALSE;
  }*/
  usleep(10000);
  return(SANE_TRUE);
}


/****************************************************************************/
SANE_Int Hp44x0_park_to_home(THWParams *pHWParams,TScanParams *pParams){
/* Moves scanner to home position */
/****************************************************************************/
	SANE_Int n,iHandle;
	SANE_Byte	buffer[0xffc0];

	iHandle = pHWParams->iXferHandle;

	DBG(DBG_SCAN, "Hp44x0_park_to_home....");
	/* make shure the scaner is stoped */
	if ( !(Hp_rts_stop_moving(iHandle))) return SANE_FALSE;

  if (Hp35x0c_is_rewound(iHandle )){
		DBG(DBG_SCAN,"i'm home\n");
/*	if(read_reg(iHandle,MICROSWITCH) & 0x02) {
		DBG(DBG_MSG,"i'm home\n");*/
		return(SANE_TRUE);
	} else {
		DBG(DBG_SCAN,"i must moving\n");
		memcpy(pHWParams->regs,Hp44x0_move_back,255);
/*
		pHWParams->regs[0x32] = 0x80;
		pHWParams->regs[0x33] = 0x81;
		pHWParams->regs[0x34] = 0x10;
		pHWParams->regs[0x35] = 0x10;
		pHWParams->regs[0x36] = 0x21; *0x24;*
		pHWParams->regs[0x39] = 0x02; * ??*
		pHWParams->regs[0x3A] = 0x0e;
		pHWParams->regs[0x60] = 0x40;
		pHWParams->regs[0x61] = 0x1f;
		pHWParams->regs[0x62] = 0x41;
		pHWParams->regs[0x63] = 0x1f;
		pHWParams->regs[0xb2] = 0x16;
		pHWParams->regs[0xe2-1] = 0x17; * StepSize */
		#if 1
		if (pParams->optXPA)
			pHWParams->regs[0x11] = pHWParams->regs[0x11] & 0xdf;
		else
			pHWParams->regs[0x11] = pHWParams->regs[0x11] | 0x02;
		#endif
		if ( !(Hp_rts_BulkWrite(iHandle,0x00,pHWParams->regs,0xb3,SANE_TRUE))) return SANE_FALSE;
		if ( !(Hp_rts_BulkWrite(iHandle,0xb4,pHWParams->regs+0xb3,0x3f,SANE_TRUE))) return SANE_FALSE;
		if ( !(Hp_rts_RegWrite(iHandle,0xd3,0x00))) return SANE_FALSE;
		if ( !(Hp_rts_start_moving(iHandle))) return SANE_FALSE;
		usleep(1000);
		while (!Hp35x0c_is_rewound(iHandle)  &&
/*			(Hp_rts_data_ready(iHandle,&n) ||*/
			 Hp_rts_is_moving(iHandle) > 0)
		{
			/*if ( !(*/Hp_rts_data_ready(iHandle,&n);/*)) return SANE_FALSE;*/
			if (n)
			{
				if (n > (SANE_Word)sizeof(buffer))
					n = sizeof(buffer);
				/*if ( !(*/Hp_rts_read_data(iHandle, n, buffer);/*)) return SANE_FALSE;*/
			}
			else
			{
				usleep(10000);
			}
		}
		return(Hp_rts_stop_moving(iHandle));
	}
}

/****************************************************************************/
SANE_Int Hp44x0_move_to_pos(THWParams *pHWParams, TScanParams *pParams){
/* Moves scanner to position */
/****************************************************************************/
	SANE_Int iHandle;
	SANE_Word pos;
	SANE_Int ypos;
	SANE_Byte r;

	iHandle = pHWParams->iXferHandle;

	ypos = MM_TO_PIXEL(pHWParams->iTopLeftY,pParams->iDpi);
	DBG(DBG_MSG,"Hp44x0_move_to_pos: %d dpi pParams->iY = %d pHWParams->iTopLeftY = %d ypos=%d \n",
							pParams->iDpi,(SANE_Int)pParams->iY,pHWParams->iTopLeftY,ypos);

	if (pParams->iDpi == 600)
		pos = ((pParams->iY) / 2 )+ ypos;
	else
		pos = (pParams->iY) + ypos;
	pos = pos / 2;

/*	DBG(DBG_MSG,"Hp44x0_move_to_pos: move to pos %d (pixel) %x (hex)\n",pos,pos-1);*/

	pHWParams->regs[0x33] = 0x81; /* 81 move fast, 82 lower */
	pHWParams->regs[0x36] = 0x29; /*29 fast; * 2C slow forward, 24 reverse */
	pHWParams->regs[0x3A] = 0x1b; /* 1b scan, 0e quick move */
	pHWParams->regs[0x60] = 0x01;
	pHWParams->regs[0x61] = 0x00;
	pHWParams->regs[0x62] = (pos+1) & 0xff;
	pHWParams->regs[0x63] = ((pos+1) >> 8) & 0xff;
	pHWParams->regs[0x65] = 0x00;  /* switch to move only (no scan)*/
	pHWParams->regs[0xE2-1] = 0x07 ; /* Stepsize */
	if (pParams->optXPA)
		pHWParams->regs[0x11] = pHWParams->regs[0x11] & 0xdf;
	else
		pHWParams->regs[0x11] = pHWParams->regs[0x11] | 0x02;

	usleep(10000);
#if 0
		printf("start_scan: start the moving!\n");
		Hp_rts_DumpHex(pHWParams->regs,252,16,SANE_TRUE);
#endif
	if ( !(Hp_rts_BulkWrite(iHandle,0x00,pHWParams->regs,0xb3,SANE_TRUE))) return SANE_FALSE;
	if ( !(Hp_rts_BulkWrite(iHandle,0xb4,pHWParams->regs+0xb3,0x3f,SANE_TRUE))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xd3,0x03))) return SANE_FALSE;

	if ( !(Hp_rts_start_moving(iHandle))) return SANE_FALSE;
	usleep(1000);
	
	/*DBG(DBG_MSG,"move_to_pos: check moving\n");*/
	r = 0x08;
	if ( Hp_rts_Check_Moving (iHandle)){
		while( r == 0x08){
			usleep(10000);
			usleep(10000);
			Hp_rts_RegRead(iHandle,MOVE_START_STOP, &r);
		}
		/*DBG(DBG_MSG,"move_to_pos: move finish\n");*/
	}else
	{
		DBG(DBG_ERR,"start_scan: Error, stop the moving!\n");
		Hp_rts_stop_moving(iHandle);
		return(SANE_FALSE);
	} 
	return(SANE_TRUE);
}


/****************************************************************************/
SANE_Int Hp44x0_wait_for_WarmUp(SANE_Int iHandle,THWParams *pHWParams){
/****************************************************************************/
  /* Reads 11 bytes and check the last one */
SANE_Char i;
#ifdef DEBUG_L
SANE_Char c;
#endif
	DBG(DBG_SCAN, "Hp44x0_wait_for_WarmUp....\n");
  /* we must here implement a wait loop for the lamp */
  if ( !(Hp_rts_BulkRead(iHandle,0x84,read_buffer,0x0b,SANE_TRUE))) return SANE_FALSE;
#ifdef DEBUG_L
  c = read_buffer[0xa];
  DBG(DBG_MSG,"wait_for_WarmUp: read %x\n",c);
  i = 1;
#else
  i = 15;
#endif
  if ( pHWParams->lamp_warm == SANE_FALSE ){
    while (i--){
      if ( !(Hp44x0_set_display( iHandle, i ))) return SANE_FALSE;
      sleep(1);
    }
    pHWParams->lamp_warm = SANE_TRUE;
  }
  return( /*(read_buffer[0xa] & 0x60) == 0x60*/ SANE_TRUE );
}

/****************************************************************************/
SANE_Bool Hp44x0_start_scan(THWParams *pHWParams, TScanParams *pParams,
								TDataPipe *pDataPipe){
/****************************************************************************/
#ifdef DEBUG
	SANE_Word lengtha1,lengtha2;
#endif
	SANE_Int brightness, iHandle;
	SANE_Int ires/*,result*/;
	SANE_Word x1,x2,length;

	iHandle = pHWParams->iXferHandle;
	brightness = 0;

	DBG(DBG_SCAN, "Hp44x0_start_scan....\n");
	DBG(DBG_MSG,"Hp44x0_start_scan: check resolution %d\n",pParams->iDpi);
	for (ires = 0; Hp44x0c_resparms[ires].resolution &&
		 Hp44x0c_resparms[ires].resolution != pParams->iDpi; ++ires);
	if (Hp44x0c_resparms[ires].resolution == 0){
		DBG(DBG_MSG,"start_scan:  did not found this resolution %d\n",pParams->iDpi);
		return SANE_FALSE;
	}

	DBG(DBG_MSG,"start_scan: Use ires entry %d (%ddpi) for the resolution %d dpi\n",ires,
			Hp44x0c_resparms[ires].resolution, pParams->iDpi);

	memcpy(pHWParams->regs,Hp44x0_myinit33,254);  /* CCD_Type 0*/
	
	if ( !(Hp44x0_move_to_pos(pHWParams,pParams))) return SANE_FALSE;
	x1 = pParams->iX;
	x2 = pParams->iWidth + pParams->iX;
	length = pParams->iLenght * 2;
	pDataPipe->iScanned = pParams->iLenght;
	DBG(DBG_MSG,"start_scan: calculate scandata x1 = %d; x2 = %d; lenght = %d\n",x1,x2,length);

	switch (pParams->mode) {

		case BLACK_WHITE:
			DBG(DBG_MSG,"Copy 300 DPI BW Regs\n");
			if (pParams->oCCD_Type){
				DBG(DBG_MSG,"Use CCD_Type 1 Regs\n");
				memcpy(pHWParams->regs,Hp44x0_300_BW_1,254);  /* CCD_Type 1*/
			}else{
				DBG(DBG_MSG,"Use CCD_Type 0 Regs\n");
				memcpy(pHWParams->regs,Hp44x0_myinit33,254);  /* CCD_Type 0*/
			}
			pHWParams->regs[0xD2 ]= 0x03;
			pHWParams->regs[0xD3 ]= 0x05;
			pHWParams->regs[0xE4 ]= 0x1c;
			pHWParams->regs[0xE5 ]= 0x10;
			pHWParams->regs[0xd5 ]= 0xab;/* ab gray */
			break;

		case GRAY:
			DBG(DBG_MSG,"Copy 300 DPI Regs\n");
			brightness = 0;
			if (pParams->oCCD_Type){
				DBG(DBG_MSG,"Use CCD_Type 1 Regs\n");
				memcpy(pHWParams->regs,Hp44x0_300_true_1_3,254); /* CCD_Type 1*/
			}else{
				DBG(DBG_MSG,"Use CCD_Type 0 Regs\n");
				memcpy(pHWParams->regs,Hp44x0_myinit33,254);  /* CCD_Type 0*/
			}
			if (pParams->iDpi == 600){
				DBG(DBG_MSG,"Patch to 600 DPI\n");
				Hp44x0_patch_regs(pHWParams,Hp44x0_patch_600);
				brightness = 43;
			}
			pHWParams->regs[0xd5 ]= 0xab;/* ab gray */
#if 1
			pHWParams->regs[0x08] = brightness + pParams->brightness;
			pHWParams->regs[0x09] = brightness + pParams->brightness;
			pHWParams->regs[0x0a] = brightness + pParams->brightness;
#endif
			#if 1
			if (pParams->optXPA)
				pHWParams->regs[0x11] = pHWParams->regs[0x11] & 0xdf;
			else
				pHWParams->regs[0x11] = pHWParams->regs[0x11] | 0x02;
			#endif
			break;

		case COLOR:
			DBG(DBG_MSG,"Copy 300 DPI Regs\n");
			if (pParams->oCCD_Type)
				memcpy(pHWParams->regs,Hp44x0_300_true_1_3,254); /* CCD_Type 1*/
			else
				memcpy(pHWParams->regs,Hp44x0_myinit33,254);  /* CCD_Type 0*/

			if (pParams->iDpi == 200){
				DBG(DBG_MSG,"Patch to 200 DPI\n");
				memcpy(pHWParams->regs,Hp44x0_200_TRUE_1,254);  /* CCD_Type 0*/
/*				Hp44x0_patch_regs(pHWParams,Hp44x0_200_TRUE_1);*/
			}

			if (pParams->iDpi == 300){
				DBG(DBG_MSG,"Patch to 300 DPI\n");
/*				memcpy(pHWParams->regs,Hp44x0_300_TRUE_1,254);  * CCD_Type 1*/
				Hp44x0_patch_regs(pHWParams,Hp44x0_patch_600);
			}

			if (pParams->iDpi == 600){
				DBG(DBG_MSG,"Patch to 600 DPI\n");
				Hp44x0_patch_regs(pHWParams,Hp44x0_patch_600);
			}
			pHWParams->regs[0xd5 ]= 0x0f;/* 0f color*/
			#if 1
			if (pParams->optXPA)
				pHWParams->regs[0x11] = pHWParams->regs[0x11] & 0xdf;
			else
				pHWParams->regs[0x11] = pHWParams->regs[0x11] | 0x02;
			#endif
#if 1
			pHWParams->regs[0x32 ]=  Hp44x0c_resparms[ires].reg_32_value;
			pHWParams->regs[0x33 ]=  Hp44x0c_resparms[ires].reg_33_value;
#endif
#if DEBUG_L
/*			pHWParams->regs[0xd5 ]= 0x1B;* 0f color*/
			/* horizon resolution */
			pHWParams->regs[0x10 ]=  Hp44x0c_resparms[ires].reg_10_value;
			pHWParams->regs[0x32 ]=  Hp44x0c_resparms[ires].reg_32_value;
			pHWParams->regs[0x33 ]=  Hp44x0c_resparms[ires].reg_33_value;
			pHWParams->regs[0x36 ]=  Hp44x0c_resparms[ires].reg_36_value;
			printf("pHWParams->regs[0xE1]= 0x%x to 0x%x\n",pHWParams->regs[0xE1],Hp44x0c_resparms[ires].step_size);
			pHWParams->regs[0xE1]= Hp44x0c_resparms[ires].step_size;
			#if 1
			printf("pHWParams->regs[0xE4]= 0x%x to 0x%x\n",pHWParams->regs[0xE4],Hp44x0c_resparms[ires].reg_E4_value);
			pHWParams->regs[0xE4]=  Hp44x0c_resparms[ires].reg_E4_value;
			printf("pHWParams->regs[0xE5]= 0x%x to 0x%x\n",pHWParams->regs[0xE5],Hp44x0c_resparms[ires].reg_E5_value);
			pHWParams->regs[0xE5]=  Hp44x0c_resparms[ires].reg_E5_value;
			#endif
			#if 1
			/* color releated */
			pHWParams->regs[0x72 ]=  Hp44x0c_resparms[ires].reg_72_value;
			pHWParams->regs[0x73 ]=  Hp44x0c_resparms[ires].reg_73_value;
			pHWParams->regs[0x74 ]=  Hp44x0c_resparms[ires].reg_74_value;
			#endif
			#if 1
			pHWParams->regs[0x11 ]=  Hp44x0c_resparms[ires].reg_11_value;
			pHWParams->regs[0x3a ]= 0x0e;/* for test*/
			/*	pHWParams->regs[0xCC ]=  Hp44x0c_resparms[ires].reg_CC_value;
			pHWParams->regs[0xCD ]=  Hp44x0c_resparms[ires].reg_CD_value;
			pHWParams->regs[0xCE ]=  Hp44x0c_resparms[ires].reg_CE_value;
			pHWParams->regs[0xCF ]=  Hp44x0c_resparms[ires].reg_CF_value;
			pHWParams->regs[0xd0 ]=  Hp44x0c_resparms[ires].reg_D0_value;*/
			/*	pHWParams->regs[0xd7 ]=  Hp44x0c_resparms[ires].reg_D7_value;
			pHWParams->regs[0xC4 ]=  Hp44x0c_resparms[ires].reg_C4_value; * colors ? *
			pHWParams->regs[0xC5 ]=  Hp44x0c_resparms[ires].reg_C5_value; * colors ? *
			pHWParams->regs[0xd5 ]=  Hp44x0c_resparms[ires].reg_D5_value;

			pHWParams->regs[0x35 ]=  Hp44x0c_resparms[ires].reg_35_value;
			pHWParams->regs[0x3A ]=  Hp44x0c_resparms[ires].reg_3A_value; */
			#endif
			/* vertical resolution */
			#if 0
			pHWParams->regs[0x3A ]=  Hp44x0c_resparms[ires].reg_3A_value;
			#endif
/*			pHWParams->regs[0x02 ]= 0xbb;
			pHWParams->regs[0x03 ]= 0x7d;
			pHWParams->regs[0x04 ]= 0x3e;
			pHWParams->regs[0x05 ]= 0xbb;
			pHWParams->regs[0x06 ]= 0x7d;
			pHWParams->regs[0x07 ]= 0x3e;

			pHWParams->regs[0x08 ]= 0x00;
			pHWParams->regs[0x09 ]= 0x00;
			pHWParams->regs[0x0a ]= 0x00;*/

			pHWParams->regs[0xBF ]=  Hp44x0c_resparms[ires].reg_BF_value;
			pHWParams->regs[0xC0 ]=  Hp44x0c_resparms[ires].reg_C0_value;
			pHWParams->regs[0xC1 ]=  Hp44x0c_resparms[ires].reg_C1_value;
			pHWParams->regs[0xc2 ]= 0xff;/* for test*/
			pHWParams->regs[0xc3 ]= 0x00;/* for test*/
			pHWParams->regs[0xc4 ]= 0xf0;/* for test*/
			pHWParams->regs[0xc5 ]= 0x00;/* for test*/
			pHWParams->regs[0xc6 ]= 0x7f;/* for test*/
			pHWParams->regs[0xc7 ]= 0x0f;/* for test*/
/*			pHWParams->regs[0xc9 ]= 0xff;* for test*/
			pHWParams->regs[0xca ]= 0xf1;/* for test*/
			pHWParams->regs[0xcb ]= 0xff;/* for test*/
			pHWParams->regs[0xcc ]= 0x00;/* for test*/
			pHWParams->regs[0xcd ]= 0xf0;/* for test*/
			pHWParams->regs[0xce ]= 0xed;/* for test*/
			pHWParams->regs[0xcf ]= 0xef;/* for test*/
			pHWParams->regs[0xd0 ]= 0xe2;/* for test*/
/*			pHWParams->regs[0xd1 ]=  Hp44x0c_resparms[ires].reg_D1_value;
			pHWParams->regs[0xd2 ]=  Hp44x0c_resparms[ires].reg_D2_value;
			pHWParams->regs[0xd3 ]=  Hp44x0c_resparms[ires].reg_D3_value;*/
			pHWParams->regs[0xd1 ]= 0x03;/* for test*/
			pHWParams->regs[0xd2 ]= 0x17;/* for test*/
			pHWParams->regs[0xd3 ]= 0x01;/* for test*/
			pHWParams->regs[0xd6 ]= 0x10;/* for test*/

			pHWParams->regs[0x80 ]= 0x2b;/* for test*/
			pHWParams->regs[0x81 ]= 0x02;/* for test*/
			pHWParams->regs[0x82 ]= 0x2C;/* for test*/
			pHWParams->regs[0x83 ]= 0x02;/* for test*/
			pHWParams->regs[0x85 ]= 0x18;/* for test*/
			pHWParams->regs[0x86 ]= 0x1b;/* for test*/
			pHWParams->regs[0x87 ]= 0x30;/* for test*/
			pHWParams->regs[0x88 ]= 0x30;/* for test*/
			pHWParams->regs[0x89 ]= 0x2d;/* for test*/
			pHWParams->regs[0x8a ]= 0x02;/* for test*/
			pHWParams->regs[0x8d ]= 0x21;/* for test*/
			pHWParams->regs[0x8e ]= 0x60;/* for test*/
#endif
		break;

		default:
			DBG(DBG_ERR, "Hp44x0_init_scan: Invalid parameter\n");
			return SANE_FALSE;
	}/* switch */




#if 0
	if (pParams->optXPA)
		pHWParams->regs[0x11] = pHWParams->regs[0x11] & 0xdf;
	else
		pHWParams->regs[0x11] = pHWParams->regs[0x11] | 0x02;
#endif

#if 0
	if (pParams->mode == COLOR)
		pHWParams->regs[0xd5 ]= 0x0f;/* 0f color*/
	else
		pHWParams->regs[0xd5 ]= 0xab;/* ab gray */
#endif

	/* modify reg 60 + 61 */
	Hp_rts_set_noscan_distance(pHWParams->regs, 0x01 );
	/* modify reg 62 + 63 */
#if 1
	Hp_rts_set_total_distance(pHWParams->regs, length+1 );
#endif
#if 0
	Hp_rts_set_total_distance(pHWParams->regs, 0x02 );
#endif

	pHWParams->regs[0x65]= 0x20; /* Schan mode on */

	/* modify reg 66 + 67 */
	Hp_rts_set_scanline_start(pHWParams->regs, x1 );
	/* modify reg 6C + 6D */
	Hp_rts_set_scanline_end(pHWParams->regs, x2 );

	#ifdef DEBUG
		lengtha1 = 0;
		lengtha2 = 0;
		lengtha1 = pHWParams->regs[0x60];
		lengtha1 = lengtha1 + ((pHWParams->regs[0x61] <<8) & 0xFF00);
		lengtha2 = pHWParams->regs[0x62];
		lengtha2 = lengtha2 + ((pHWParams->regs[0x63] <<8) & 0xFF00);
		DBG(DBG_MSG,"start_scan: Init scan_region: dpi=%d iLenght=%d, iScanned=%d lenght=%d mode=%x xPDA=%x\n",
		pParams->iDpi,pParams->iLenght,pDataPipe->iScanned,length,pParams->mode,pParams->optXPA);
		#endif

#if 0
	pHWParams->regs[0xDA-1]= pParams->intensity2; /* Lamp density */
#endif


#if 0  /* do not use by graymode ! */
		pHWParams->regs[0x05] = 0x20 - pParams->GainR;
		pHWParams->regs[0x06] = 0x20 - pParams->GainG;
		pHWParams->regs[0x07] = 0x20 - pParams->GainB;
#endif

#if 0
		pHWParams->regs[0x08] = 0x20 - pParams->GainR;
		pHWParams->regs[0x09] = 0x20 - pParams->GainG;
		pHWParams->regs[0x0a] = 0x20 - pParams->GainB;
#endif

#if 0  /* moved to graymode */
	pHWParams->regs[0x08] = /*0x20 -*/ pParams->brightness;
	pHWParams->regs[0x09] = /*0x20 -*/ pParams->brightness;
	pHWParams->regs[0x0a] = /*0x20 -*/ pParams->brightness;
#endif
#if 0
		printf("start_scan: start the scanner!\n");
		Hp_rts_DumpHex(pHWParams->regs,255,16,SANE_TRUE);
#endif

	if ( !(Hp_rts_Set_double_reg(iHandle,0x10,pHWParams->regs[0x10],pHWParams->regs[0x11]))) return SANE_FALSE;
	usleep(10000);

	if ( !(Hp_rts_BulkWrite(iHandle,0x00,pHWParams->regs,0xb3,SANE_TRUE))) return SANE_FALSE;
	if ( !(Hp_rts_BulkWrite(iHandle,0xb4,pHWParams->regs+0xb3,0x3f,SANE_TRUE))) return SANE_FALSE;
#if 0
	if (pParams->mode == BLACK_WHITE)
		Hp_rts_RegWrite(iHandle,0xd3,0x17);
	else
		Hp_rts_RegWrite(iHandle,0xd3,0x03);
#endif
#if 0
	DBG(DBG_MSG,"pHWParams->regs[0xd3]= 0x%x to 0x%x\n",
		pHWParams->regs[0xd3-1],pHWParams->regs[0xd3-1]);
#endif	
	if ( !(Hp_rts_RegWrite(iHandle,0xd3,pHWParams->regs[0xd3-1]))) return SANE_FALSE;

	if ( !(Hp_rts_start_moving(iHandle))) return SANE_FALSE;
	usleep(10000);
	/* wait for moving and check it */
	return(Hp_rts_Check_Moving (iHandle));
}


/****************************************************************************/
SANE_Bool Hp44x0_init_scan(THWParams *pHWParams, TScanParams *pParams,
													TDataPipe *pDataPipe){
/****************************************************************************/

	SANE_Int iHandle;
	SANE_Int	ires;

	iHandle = pHWParams->iXferHandle;
	DBG(DBG_MSG,"Hp44x0_init_scan: check resolution %d\n",pParams->iDpi);
	for (ires = 0; Hp44x0c_resparms[ires].resolution &&
								 Hp44x0c_resparms[ires].resolution != pParams->iDpi; ++ires);
	if (Hp44x0c_resparms[ires].resolution == 0){
		DBG(DBG_MSG,"Hp44x0_init_scan: this resolution %d not found\n",pParams->iDpi);
		return SANE_FALSE;
	}

	if ( !(Hp_rts_RegWrite(iHandle,LAMP_INTENSITY,0xa7))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,LAMP_INTENSITY,0xa0))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,LAMP_INTENSITY,0xa7))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x01))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x01))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x00))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x00))) return SANE_FALSE;
	if ( !(Hp_rts_Set_double_reg(iHandle, 0x12, 0xff, 0x20 ))) return SANE_FALSE;
	if ( !(Hp_rts_Set_double_reg(iHandle, 0x14, 0xf8, 0x28 ))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x00))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x00))) return SANE_FALSE;

	memcpy(pHWParams->regs,Hp44x0_init_1,0xf4);
	pHWParams->regs[0x10 ]=  Hp44x0c_resparms[ires].reg_10_value;
	pHWParams->regs[0x11 ]=  Hp44x0c_resparms[ires].reg_11_value;

	if (pParams->optXPA)
		pHWParams->regs[0x11] = pHWParams->regs[0x11] & 0xdf;
	else
		pHWParams->regs[0x11] = pHWParams->regs[0x11] | 0x02;

	if ( !(Hp_rts_Set_double_reg(iHandle,0x10,pHWParams->regs[0x10],
																		pHWParams->regs[0x11]))) return SANE_FALSE;
	usleep(10000);
	if ( !(Hp_rts_RegWrite(iHandle,0xd9,0x80))) return SANE_FALSE;

	#ifndef WITH_TSTBACKEND
	if ( !(Hp44x0_wait_for_WarmUp(iHandle,pHWParams))) return SANE_FALSE;
	#endif

	if ( !(Hp_rts_BulkWrite(iHandle,0x00,pHWParams->regs,0xb3,SANE_TRUE))) return SANE_FALSE;
	if ( !(Hp_rts_BulkWrite(iHandle,0xb4,pHWParams->regs+0xb3,0x3f,SANE_TRUE))) return SANE_FALSE;

	if ( !(Hp_rts_RegWrite(iHandle,LAMP_INTENSITY,0xa7))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xd9,0x8d))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xd9,0xad))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x00))) return SANE_FALSE;
	if ( !(Hp_rts_RegWrite(iHandle,0xb3,0x00))) return SANE_FALSE;
	/*  test_double_reg( LEDSTATUS, 0x28, 0x3f, 7 );  */
	usleep(10000);
	if ( !(Hp_rts_Set_double_reg(iHandle,0x10,pHWParams->regs[0x10],
																		pHWParams->regs[0x11]))) return SANE_FALSE;
	/*  if ( !(test_double_reg( LEDSTATUS, 0x28, 0x3f, 8 );  */
	if ( !(Hp_rts_RegWrite(iHandle,0xd9,0xad))) return SANE_FALSE;

	return(Hp44x0_start_scan(pHWParams,pParams,pDataPipe));
}



/****************************************************************************/
/*  Lamp control functions                                                  */
SANE_Bool Hp44x0_GetLamp(SANE_Int iHandle, SANE_Bool *pfLampIsOn)
/****************************************************************************/
{
	SANE_Byte bData;

	DBG(DBG_SCAN, "Hp44x0_GetLamp....\n");
	if ( !(Hp_rts_RegRead(iHandle, LAMPREG, &bData))) return SANE_FALSE;
	*pfLampIsOn = ((bData & 0x80) != 0);
	return SANE_TRUE;
}


/****************************************************************************/
SANE_Bool Hp44x0_SetLamp(SANE_Int iHandle, SANE_Bool fLampOn)
/****************************************************************************/
{
	SANE_Byte bData;

	DBG(DBG_SCAN, "Hp44x0_SetLamp....\n");
	if ( !(Hp_rts_RegRead(iHandle, LAMPREG, &bData))) return SANE_FALSE;
	if (fLampOn) {
		if ( !(Hp_rts_RegWrite(iHandle, LAMPREG, bData | 0x80))) return SANE_FALSE;
	}
	else {
		if ( !(Hp_rts_RegWrite(iHandle, LAMPREG, bData & ~0x80))) return SANE_FALSE;
	}
	return SANE_TRUE;
}


/****************************************************************************/
SANE_Int
Hp44x0c_nvram_enable_controller(SANE_Int iHandle,SANE_Int enable)
/****************************************************************************/
{
	SANE_Byte r;

	DBG(DBG_SCAN, "Hp44x0c_nvram_enable_controller....\n");
	if ( !(Hp_rts_RegRead(iHandle, 0x1d, &r))) return SANE_FALSE;
	if (enable)
		r |= 1;
	else
		r &= ~1;
	return Hp_rts_RegWrite(iHandle,0x1d, r);

}





 /* sane - Scanner Access Now Easy.
   Copyright (C) 2003 Johannes Hub (JohannesHub@t-online.de)

   This file was initially copied from the hp3300 backend.
   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 exutable, 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.
*/

/*
    Concept for a backend for scanners based on the RTS88xx chipset,
    such as HP4400C, HP4470C.
    Parts of this source were inspired by other backends.

		History:

		Version 0.18  21.11.04 13.alpha,
				- source sorted,
				- now only SANEI_USB_SUPPORT for a better overview(xfermodules removed)
				- read and verify the MainBoardID 
		Version 0.17p 02.11.04 12.alpha, source sorted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17p 02.11.04 12.alpha, source sourted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17b 30.03.04 10.alpha, little fixes and libusb implemented
		Version 0.17  09.03.04 9. alpha, HP3500 included
		Version 0.16  06.02.04 8. alpha, wait counting on LCD
		Version 0.15a 29.01.04 7. alpha, CCD switch moved to config file
		Version 0.15  11.01.04 6. alpha, a second CCD implemented
		Version 0.13a 21.11.04 4. alpha, an little fix included
		Version 0.12  22.10.03 third alpha, Backend name changed to HP_RTS88xx
		Version 0.11  30.08.03 second alpha
		Version 0.10  19.07.03 first alpha
*/

/*
    Core HP44x0c functions.
*/


#ifndef _HP_RTS_HP44x0C_H_
#define _HP_RTS_HP44x0C_H_

#include <unistd.h>

#define XFER_BUF_SIZE  0xFF00


#define HW_PIXELS   2000   /* number of pixels supported by hardware */
#define HW_DPI      300    /* horizontal resolution of hardware */
#define HW_LPI      300    /* vertical resolution of hardware */

/* thise rts8891 registers are known */
#define LEDSTATUS            0x10
#define LIGHT_SOURCE         0x11
#define TAP                  0x14
#define LCD_CONTROL1         0x20
#define LCD_CONTROL2         0x21
#define LCD_CONTROL3         0x22
#define BUTTON_1             0x25
#define BUTTON_2             0x1a
#define MICROSWITCH          0x1d
#define MOVEMENT_DIRECTION   0x36
#define SCAN_OR_QUICK_MOVE   0x3a
#define CHECK_SCANNER_LINKED 0xb0
#define MAINBOARD_ID         0xb1
#define MOVEMENT_REG_1       0xb2
#define MOVE_START_STOP      0xb3
#define LAMPREG              0xd9
#define LAMP_INTENSITY       0xda
#define STEP_SIZE            0xe1

struct	Hp44x0c_resolution_parameters
{
	SANE_Int	resolution;
	SANE_Byte		reg_10_value;
	SANE_Byte		reg_11_value;
	SANE_Byte		reg_32_value;
	SANE_Byte		reg_33_value;
	SANE_Byte		reg_35_value;
	SANE_Byte		reg_36_value;
	SANE_Byte		reg_3A_value;
	SANE_Byte		reg_72_value;
	SANE_Byte		reg_73_value;
	SANE_Byte		reg_74_value;
	SANE_Byte		reg_BF_value;
	SANE_Byte		reg_C0_value;
	SANE_Byte		reg_C1_value;
	SANE_Byte		reg_C4_value;
	SANE_Byte		reg_C5_value;
	SANE_Byte		reg_CC_value;
	SANE_Byte		reg_CD_value;
	SANE_Byte		reg_CE_value;
	SANE_Byte		reg_CF_value;
	SANE_Byte		reg_D0_value;
	SANE_Byte		reg_D1_value;
	SANE_Byte		reg_D2_value;
	SANE_Byte		reg_D3_value;
	SANE_Byte		reg_D5_value;
	SANE_Byte		reg_D7_value;
	SANE_Byte		step_size;
	SANE_Byte		reg_E4_value;
	SANE_Byte		reg_E5_value;
};

static struct Hp44x0c_resolution_parameters Hp44x0c_resparms[] =
{
/*res. 10   11   32  33   35   36   3a   72   73   74   bf   c0   c1   c5   cb   cc   cd   ce   cf   d0   d1   d2   d3   d5   d7 Step   e4  e5*/
/*             0x00,0x03,0x45,     0x43 */
{600,0x28,0x3b,0x80,0x82,0x1b,0x2C,0x1b,0x3a,0x15,0x62,0x00,0xff,0x0f,0xf8,0x07,0x80,0xff,0xf2,0xf4,0xe7,0x08,0x0e,0x10,0x0f,0x52,0x01,0x56,0x01},
{300,0x20,0x3b,0x80,0x82,0x0e,0x22,0x0e,0xe1,0x14,0x18,0xff,0x0f,0xf0,0x00,0x00,0xf0,0xff,0xf5,0xf7,0xea,0x0b,0x03,0x05,0xab,0xf6,0x01,0x56,0x01},
{200,0x20,0x3b,0x00,0x03,0x0e,0x22,0x0e,0xe1,0x14,0x18,0xff,0x0f,0xf0,0x00,0x00,0xf0,0xff,0xf5,0xf7,0xea,0x0b,0x03,0x05,0xab,0xf6,0x01,0xbd,0x0a},
{150,0x20,0x3f,0x80,0x81,0x1b,0x29,0x1b,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x00,0x01},
{0,  0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}
};



SANE_Byte Hp44x0_switch_on_regs[] = {
/*0    1    2    3    4    5    6    7    8    9    a    b    c    d    e    f*/
0xe5,0x41,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x0a,0x0a,0x0a,0x70,0x00,0x00,0x00,0x00,
/*10   11   12   13   14   15   16   17   18   19   1a   1b   1c   1d   1e   1f*/
0x28,0x28,0xff,0x20,0xf8,0x28,0x07,0x00,0xff,0x00,0x00,0x00,0x00,0x20,0x00,0x00,
/*20   21   22   23   24   25   26   27   28   29   2a   2b   2c   2d   2e   2f*/
0x3a,0xf2,0x00,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*30   31   32   33   34   35   36   37   38   39   3a   3b   3c   3d   3e   3f*/
0x00,0x00,0x00,0x00,0x10,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*40 41   42   43   44   45   46   47   48   49   4a   4b   4c   4d   4e   4f*/
0x20,0x00,0x00,0x00,0x8c,0x76,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*50   51   52   53   54   55   56   57   58   59   5a   5b   5c  5d   5e   5f*/
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*60   61   62   63   64   65   66   67   68   69   6a   6b   6c   6d   6e   6f*/
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*70   71   72   73   74   75   76   77   78   79   7a   7b   7c   7d   7e   7f*/
0x00,0x00,0xe1,0x14,0x18,0x15,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*80   81   82   83   84   85   86   87   88   89   8a   8b   8c   8d   8e   8f*/
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0x3f,0x80,0x68,0x00,
/*90   91   92   93   94   95   96   97   98   99   9a   9b   9c   9d   9e   9f*/
0x00,0x00,0x00,0x01,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*a0   a1   a2   a3   a4   a5   a6   a7   a8   a9   aa   ab   ac   ad   ae   af*/
0x00,0x00,0x00,0xcc,0x27,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*b0   b1   b2   b3   b4   b5   b6   b7   b8   b9   ba   bb   bc   bd   be   bf*/
0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,
/*c0   c1   c2   c3   c4   c5   c6   c7   c8   c9   ca   cb   cc   cd   ce   cf*/
0x0f,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x0e,0x00,0x00,0xf0,0xff,0xf5,0xf7,
/*d0   d1   d2   d3   d4   d5   d6   d7   d8   d9   da   db   dc   dd   de   df*/
0xea,0x0b,0x03,0x05,0x86,0x1b,0x30,0xf6,0xad,0x27,0x00,0x00,0x00,0x00,0x00,0x00,
/*e0   e1   e2   e3   e4   e5   e6   e7   e8   e9   ea   eb   ec   ed   ee   ef*/
0x00,0x01,0x00,0x00,0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*f0   f1   f2*/
0x00,0x00,0x00};

SANE_Byte Hp44x0_move_back[] = {
0xf5,0x41,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x10,0x10,0x10,0x70,0x00,0x00,0x00,0x00,
0x20,0x28,0xff,0x20,0xf8,0x28,0x07,0x00,0xff,0x00,0x00,0x00,0x00,0x20,0x00,0x00,
0x3a,0xf2,0x00,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x80,0x81,0x10,0x10,0x24,0x00,0x00,0x02,0x0e,0x00,0x00,0x00,0x00,0x00,
0x20,0x00,0x00,0x00,0x8c,0x76,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x40,0x1f,0x41,0x1f,0x01,0x20,0x64,0x00,0x00,0x00,0x00,0x00,0xc8,0x00,0x00,0x00,
0x00,0x00,0xe1,0x14,0x18,0x15,0x00,0x00,0x00,0x20,0x01,0x00,0x00,0x00,0x00,0x00,
0x32,0x00,0x33,0x00,0x00,0x00,0x06,0x00,0x06,0x34,0x00,0xff,0x3f,0x80,0x68,0x00,
0x1c,0x00,0x00,0x01,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0xcc,0x27,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x16,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x86,0x6b,0x00,0x00,0x80,0x27,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x17,0x0d,0x06,0xf9,0x00,0x53,0x02,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00};

SANE_Byte Hp44x0_init_1[] = {
0xe5,0x41,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x0a,0x0a,0x0a,0x70,0x00,0x00,0x00,0x00,
0x60,0x3b,0x00,0x20,0x00,0x20,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,
0x3a,0xf2,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x10,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x20,0x00,0x00,0x00,0x8c,0x76,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x68,0x00,
0x00,0x00,0x00,0x02,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0xcc,0x27,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x86,0x1b,0x00,0xff,0x00,0x27,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x01,0x00,0x00,0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00};

SANE_Byte Hp44x0_init_5[] = {
0xe5,0x41,0x1f,0x1f,0x1f,0x1f,0x1f,0x1f,0x0a,0x0a,0x0a,0x70,0x00,0x00,0x00,0x00,
0x28,0x28,0xff,0x20,0xf8,0x28,0x07,0x00,0xff,0x00,0x00,0x00,0x00,0x20,0x00,0x00,
0x3a,0xf2,0x00,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x10,0x00,0x07,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x20,0x00,0x00,0x00,0x8c,0x76,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0xe1,0x14,0x18,0x15,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x68,0x00,
0x00,0x00,0x00,0x01,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0xcc,0x27,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,
0x0f,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x0e,0x00,0x00,0xf0,0xff,0xf5,0xf7,
0xea,0x0b,0x03,0x05,0x86,0x1b,0x30,0xf6,0x80,0x27,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x01,0x00,0x00,0x14,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00};

SANE_Byte Hp44x0_myinit33[] = {
/*0    1    2    3    4    5    6    7    8    9    a    b    c    d    e    f*/
0xe5,0x41,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x10,0x10,0x10,0x70,0x00,0x00,0x00,0x00,
/*10   11   12   13   14   15   16   17   18   19   1a   1b   1c   1d   1e   1f*/
0x20,0x3f,0xff,0x20,0xf8,0x28,0x07,0x00,0xff,0x00,0x00,0x00,0x00,0x20,0x00,0x00,
/*20   21   22   23   24   25   26   27   28   29   2a   2b   2c   2d   2e   2f*/
0x3a,0xf2,0x00,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*30   31   32   33   34   35   36   37   38   39   3a   3b   3c   3d   3e   3f*/
0x00,0x00,0x80,0x81,0x10,0x1b,0x29,0x00,0x00,0x02,0x1b,0x00,0x00,0x00,0x00,0x00,
/*40   41   42   43   44   45   46   47   48   49   4a   4b   4c   4d   4e   4f*/
0x20,0x00,0x00,0x00,0x8c,0x76,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*50   51   52   53   54   55   56   57   58   59   5a   5b   5c  5d   5e   5f*/
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*60   61   62   63   64   65   66   67   68   69   6a   6b   6c   6d   6e   6f*/
0x12,0x00,0xc6,0x00,0x01,0x20,0x2c,0x01,0x00,0x00,0x00,0x00,0xdc,0x05,0x00,0x00,
/*70   71   72   73   74   75   76   77   78   79   7a   7b   7c   7d   7e   7f*/
0x00,0x00,0xe1,0x14,0x18,0x15,0x00,0x00,0x00,0x20,0x01,0x00,0x00,0x00,0x00,0x00,
/*80   81   82   83   84   85   86   87   88   89   8a   8b   8c   8d   8e   8f*/
0x32,0x00,0x33,0x00,0x00,0x00,0x06,0x00,0x06,0x34,0x00,0xff,0x3f,0x80,0x68,0x00,
/*90   91   92   93   94   95   96   97   98   99   9a   9b   9c   9d   9e   9f*/
0x1c,0x00,0x00,0x01,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*a0   a1   a2   a3   a4   a5   a6   a7   a8   a9   aa   ab   ac   ad   ae   af*/
0x00,0x00,0x00,0xcc,0x27,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*b0   b1   b2   b3   b4   b5   b6   b7   b8   b9   ba   bb   bc   bd   be   bf*/
0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,
/*c0   c1   c2   c3   c4   c5   c6   c7   c8   c9   ca   cb   cc   cd   ce   cf*/
0x0f,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x0e,0x00,0x00,0xf0,0xff,0xf5,0xf7,
/*d0   d1   d2   d3   d4   d5   d6   d7   d8   d9   da   db   dc   dd   de   df*/
0xea,0x0b,0x03,0x05,0x86,0xab,0x30,0xf6,0xad,0xa7,0x00,0x00,0x00,0x00,0x00,0x00,
/*e0   e1   e2   e3   e4   e5   e6   e7   e8   e9   ea   eb   ec   ed   ee   ef*/
0x00,0x01,0x00,0x00,0x1c,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*f0   f1   f2*/
0x00,0x00,0x00};

SANE_Byte Hp44x0_300_true_1_3[]  = {
0xe5,0x41,0x7f,0x7f,0x7f,0x7f,0x7f,0x7f,0x10,0x10,0x10,0x70,0x00,0x00,0x00,0x00,
0x20,0x3b,0xff,0x20,0xf8,0x28,0x07,0x00,0xff,0x00,0x00,0x00,0x00,0x20,0x00,0x00,
0x3a,0xf2,0x00,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x80,0x81,0x10,0x1b,0x29,0x00,0x00,0x02,0x1b,0x00,0x00,0x00,0x00,0x00,
0x20,0x00,0x00,0x00,0x8c,0x76,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x12,0x00,0xc6,0x00,0x01,0x20,0x2c,0x01,0x00,0x00,0x00,0x00,0xdc,0x05,0x00,0x00,
0x00,0x00,0xe1,0x14,0x18,0x15,0x00,0x00,0x00,0x20,0x01,0x00,0x00,0x00,0x00,0x00,
0x2b,0x02,0x2c,0x02,0x00,0x18,0x1b,0x30,0x30,0x2d,0x02,0xff,0x3f,0x21,0x60,0x00,
0x1c,0x00,0x00,0x01,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0xcc,0x27,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,
0x0f,0x00,0x00,0xf0,0xff,0xff,0x0f,0x00,0xff,0xf1,0xff,0x00,0xf0,0xff,0xf5,0xf7,
0xea,0x0b,0x03,0x05,0x86,0xab,0x10,0xf6,0xad,0xa7,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x01,0x00,0x00,0x1c,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00};

SANE_Byte Hp44x0_300_BW_1[]  = {
/*0    1    2    3    4    5    6    7    8    9    a    b    c    d    e    f*/
0xe5,0x41,0x82,0x86,0x81,0x82,0x86,0x81,0x07,0x05,0x0f,0x70,0x00,0x00,0x00,0x00,
/*10   11   12   13   14   15   16   17   18   19   1a   1b   1c   1d   1e   1f*/
0x20,0x3f,0xff,0x20,0xf8,0x28,0x07,0x00,0xff,0x00,0x00,0x00,0x00,0x20,0x00,0x00,
/*20   21   22   23   24   25   26   27   28   29   2a   2b   2c   2d   2e   2f*/
0x3a,0xf2,0x00,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*30   31   32   33   34   35   36   37   38   39   3a   3b   3c   3d   3e   3f*/
0x00,0x00,0x80,0x81,0x10,0x1b,0x29,0x00,0x00,0x02,0x1b,0x00,0x00,0x00,0x00,0x00,
/*0x00,0x00,0x20,0x83,0x10,0x0e,0x2c,0x00,0x00,0x02,0x0e,0x00,0x00,0x00,0x00,0x00,*/
/*40   41   42   43   44   45   46   47   48   49   4a   4b   4c   4d   4e   4f*/
0x20,0x00,0x00,0x00,0x8c,0x76,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*50   51   52   53   54   55   56   57   58   59   5a   5b   5c  5d   5e   5f*/
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*60   61   62   63   64   65   66   67   68   69   6a   6b   6c   6d   6e   6f*/
0x01,0x00,0x43,0x00,0x01,0x20,0x5e,0x00,0x00,0x00,0x00,0x00,0x54,0x0a,0x00,0x00,
/*70   71   72   73   74   75   76   77   78   79   7a   7b   7c   7d   7e   7f*/
0x00,0x00,0xe1,0x14,0x18,0x15,0x00,0x00,0x00,0x20,0x01,0x00,0x00,0x00,0x00,0x00,
/*80   81   82   83   84   85   86   87   88   89   8a   8b   8c   8d   8e   8f*/
0x32,0x00,0x33,0x00,0x00,0x00,0x06,0x00,0x06,0x34,0x00,0xff,0x3f,0x00,0x60,0x00,
/*90   91   92   93   94   95   96   97   98   99   9a   9b   9c   9d   9e   9f*/
0x1c,0x00,0x00,0x01,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*a0   a1   a2   a3   a4   a5   a6   a7   a8   a9   aa   ab   ac   ad   ae   af*/
0x00,0x00,0x00,0xcc,0x27,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*b0   b1   b2   b3   b4   b5   b6   b7   b8   b9   ba   bb   bc   bd   be   bf*/
0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,
/*c0   c1   c2   c3   c4   c5   c6   c7   c8   c9   ca   cb   cc   cd   ce   cf*/
0x0f,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x0e,0x00,0x00,0xf0,0xff,0xf5,0xf7,
/*d0   d1   d2   d3   d4   d5   d6   d7   d8   d9   da   db   dc   dd   de   df*/
0xea,0x0b,0x17,0x01,0x86,0x0f,0x30,0x52,0xad,0xa7,0x00,0x00,0x00,0x00,0x00,0x00,
/*e0   e1   e2   e3   e4   e5   e6   e7   e8   e9   ea   eb   ec   ed   ee   ef*/
0x00,0x05,0x00,0x00,0xc9,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*f0   f1   f2*/
0x00,0x00,0x00};

SANE_Byte Hp44x0_200_BW_1[]  = {
0xe5,0x41,0x82,0x86,0x81,0x82,0x86,0x81,0x07,0x05,0x0f,0x70,0x00,0x00,0x00,0x00,
0x20,0x3f,0xff,0x20,0xf8,0x28,0x01,0x00,0xff,0x00,0x00,0x00,0x00,0x20,0x00,0x00,
0x3a,0xf2,0x00,0x80,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x20,0x83,0x10,0x0e,0x2c,0x00,0x00,0x02,0x0e,0x00,0x00,0x00,0x00,0x00,
0x2c,0x00,0x00,0x00,0x8c,0x76,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x2d,0x00,0xef,0x0d,0x01,0x20,0x5e,0x00,0x00,0x00,0x00,0x00,0x54,0x0a,0x00,0x00,
0x00,0x00,0xe1,0x14,0x18,0x15,0x00,0x00,0x00,0x20,0x01,0x00,0x00,0x00,0x00,0x00,
0x2b,0x02,0x2c,0x02,0x00,0x18,0x1b,0x30,0x30,0x2d,0x02,0xff,0x3f,0xef,0x60,0x00,
0x18,0x00,0x00,0x01,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0xcc,0x27,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,
0x0f,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x0e,0x00,0x00,0xf0,0xff,0xf5,0xf7,
0xea,0x0b,0x17,0x01,0x86,0x0f,0x30,0x52,0xad,0xa7,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x07,0x00,0x00,0x56,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00};

SANE_Byte Hp44x0_200_BW_2[]  = {
0xe5,0x41,0x8c,0x8c,0x8c,0x8c,0x8c,0x8c,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x00,
0x20,0x3f,0xff,0x20,0xf8,0x28,0x07,0x00,0xff,0x00,0x00,0x00,0x00,0x20,0x00,0x00,
0x3a,0xf2,0x00,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x03,0x10,0x0e,0x22,0x00,0x00,0x02,0x0e,0x00,0x00,0x00,0x00,0x00,
0x20,0x00,0x00,0x00,0x8c,0x76,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x01,0x00,0x02,0x00,0x01,0x20,0x0d,0x00,0x00,0x00,0x00,0x00,0xfb,0x02,0x00,0x00,
0x00,0x00,0xe1,0x14,0x18,0x15,0x00,0x00,0x00,0x20,0x01,0x00,0x00,0x00,0x00,0x00,
0x32,0x00,0x33,0x00,0x00,0x00,0x06,0x00,0x06,0x34,0x00,0xff,0x3f,0x00,0x60,0x00,
0x1c,0x00,0x00,0x01,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0xcc,0x27,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,
0x0f,0x00,0xff,0xff,0xff,0xff,0xff,0xff,0x00,0x0e,0x00,0x00,0xf0,0xff,0xf5,0xf7,
0xea,0x0b,0x17,0x01,0x86,0x0f,0x30,0x52,0xad,0xa7,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x07,0x00,0x00,0x56,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00};

SANE_Byte Hp44x0_200_TRUE_1[]  = {
/*0    1    2    3    4    5    6    7    8    9    a    b    c    d    e    f*/
0xe5,0x41,0xfa,0xfa,0xfa,0xfa,0xfa,0xfa,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x00,
/*10   11   12   13   14   15   16   17   18   19   1a   1b   1c   1d   1e   1f*/
0x20,0x3b,0xff,0x20,0xf8,0x28,0x07,0x00,0xff,0x00,0x00,0x00,0x00,0x20,0x00,0x00,
/*20   21   22   23   24   25   26   27   28   29   2a   2b   2c   2d   2e   2f*/
0x3a,0xf2,0x00,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*30   31   32   33   34   35   36   37   38   39   3a   3b   3c   3d   3e   3f*/
0x00,0x00,0x00,0x03,0x10,0x0e,0x22,0x00,0x00,0x02,0x0e,0x00,0x00,0x00,0x00,0x00,
0x20,0x00,0x00,0x00,0x8c,0x76,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x01,0x00,0x02,0x00,0x01,0x20,0x15,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x00,0x00,
0x00,0x00,0xe1,0x14,0x18,0x15,0x00,0x00,0x00,0x20,0x01,0x00,0x00,0x00,0x00,0x00,
0x2b,0x02,0x2c,0x02,0x00,0x18,0x1b,0x30,0x30,0x2d,0x02,0xff,0x3f,0x21,0x60,0x00,
0x1c,0x00,0x00,0x01,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0xcc,0x27,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x02,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0xff,0x0f,0xff,0x00,0xf0,0x00,0xff,0x0f,0xff,0xff,0xf1,0xff,0x00,0xf0,0xed,0xef,
0xe2,0x03,0x17,0x01,0x86,0x0f,0x10,0x52,0xad,0xa7,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x07,0x00,0x00,0x56,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00};

SANE_Byte Hp44x0_300_TRUE_1[]  = {
/*0    1    2    3    4    5    6    7    8    9    a    b    c    d    e    f*/
0xe5,0x41,0xbb,0x7d,0x3e,0xbb,0x7d,0x3e,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x00,
/*10   11   12   13   14   15   16   17   18   19   1a   1b   1c   1d   1e   1f*/
0x20,0x3b,0xff,0x20,0xf8,0x28,0x07,0x00,0xff,0x00,0x00,0x00,0x00,0x20,0x00,0x00,
/*20   21   22   23   24   25   26   27   28   29   2a   2b   2c   2d   2e   2f*/
0x3a,0xf2,0x00,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*30   31   32   33   34   35   36   37   38   39   3a   3b   3c   3d   3e   3f*/
0x00,0x00,0x00,0x03,0x10,0x0e,0x22,0x00,0x00,0x02,0x0e,0x00,0x00,0x00,0x00,0x00,
0x20,0x00,0x00,0x00,0x8c,0x76,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x01,0x00,0x02,0x00,0x01,0x20,0x15,0x00,0x00,0x00,0x00,0x00,0x03,0x03,0x00,0x00,
0x00,0x00,0xe1,0x14,0x18,0x15,0x00,0x00,0x00,0x20,0x01,0x00,0x00,0x00,0x00,0x00,
0x2b,0x02,0x2c,0x02,0x00,0x18,0x1b,0x30,0x30,0x2d,0x02,0xff,0x3f,0x21,0x60,0x00,
0x1c,0x00,0x00,0x01,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0xcc,0x27,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*b0   b1   b2   b3   b4   b5   b6   b7   b8   b9   ba   bb   bc   bd   be   bf*/
0x00,0x00,0x02,     0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*c0   c1   c2   c3   c4   c5   c6   c7   c8   c9   ca   cb   cc   cd   ce   cf*/
0x00,0xff,0x0f,0xff,0x00,0xf0,0x00,0xff,0x0f,0xff,0xff,0xf1,0xff,0x00,0xf0,0xed,
/*d0   d1   d2   d3   d4   d5   d6   d7   d8   d9   da   db   dc   dd   de   df*/
0xef,0xe2,0x03,0x17,0x01,0x86,0x0f,0x10,0x52,0xad,0xa7,0x00,0x00,0x00,0x00,0x00,
/*e0   e1   e2   e3   e4   e5   e6   e7   e8   e9   ea   eb   ec   ed   ee   ef*/
0x00,0x00,0x07,0x00,0x00,0x56,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
/*f0   f1   f2*/
0x00,0x00,0x00};

/* CCD CHANGES to CCD1  80,81,82,83,85,86,87,88,89,8a,8d,8e,c2,c3,c6,c7,c8,c9,ca,d6 */


SANE_Byte Hp44x0_patch_2[] = {
0x12,0x8,0x16,0x8,0x1d,0x20,0xb0,0x0,0xce,0xe0,0xd4,0x86,
0xd5,0x1b,0xd6,0x0,0xd7,0xff,0xd8,0x0,0xd9,0x27,0xda,0x0,
0xe1,0x1,0xe2,0x0,0xe4,0x14,0xe5,0x0,0xf4,0x0,0xf5,0x0,
0xf6,0x0,0xf7,0x0,0xf8,0x0,0xf9,0x0,0xfa,0x0,0xfb,0x0,
0xfc,0x0,0xfd,0x0,0xfe,0x0,0x0,0x0};

SANE_Byte Hp44x0_patch_3[] = {
0x1d,0x20,0xb0,0x0,0xd4,0x86,0xd5,0x1b,0xd6,0x0,0xd7,0xff,
0xd8,0x0,0xd9,0x27,0xda,0x0,0xe1,0x1,0xe2,0x0,0xe4,0x14,
0xe5,0x0,0xf4,0x0,0xf7,0x0,0xf8,0x0,0xf9,0x0,0xfa,0x0,
0xfb,0x0,0xfc,0x0,0xfd,0x0,0xfe,0x0,0x0,0x0};

SANE_Byte Hp44x0_patch_4[] = {
0x10,0x28,0x11,0x28,0x12,0xff,0x14,0xf8,0x15,0x28,0x16,0x7,
0x18,0xff,0x1a,0x0,0x1d,0x20,0x23,0xff,0x24,0xff,0x72,0xe1,
0x73,0x14,0x74,0x18,0x75,0x15,0xb0,0x0,0xbf,0xff,0xc0,0xf,
0xc2,0xff,0xc3,0xff,0xc4,0xff,0xc5,0xff,0xc6,0xff,0xc7,0xff,
0xc9,0xe,0xcc,0xf0,0xcd,0xff,0xce,0xf5,0xcf,0xf7,0xd0,0xea,
0xd1,0xb,0xd2,0x3,0xd3,0x5,0xd4,0x86,0xd5,0x1b,0xd6,0x30,
0xd7,0xf6,0xd8,0x80,0xd9,0x27,0xda,0x0,0xe1,0x1,0xe2,0x0,
0xe4,0x14,0xe5,0x0,0xf7,0x0,0xf8,0x0,0xf9,0x0,0xfa,0x0,
0xfb,0x0,0xfc,0x0,0xfd,0x0,0xfe,0x0,0x0,0x0};

SANE_Byte Hp44x0_patch_600[] = {
0x10,0x28, 0x11,0x3b, 0x36,0x2c,
0xe4,0xbd, 0xe5,0x0a,

0x72,0x3a, 0x73,0x15, 0x74,0x62,
0xbf,0xf8, 0xc0,0x7f,
0xc4,0x00, 0xc5,0xf8,
0xcb,0x07, 0xcc,0x80, 0xce,0xf2,
0xcf,0xf4, 0xd0,0xe7, 0xd1,0x08, 0xd2,0x0e, 0xd3,0x10,
0xd5,0x0f, 0xd7,0x52,
0x60,0x01, 0x62,0x02, 0x66,0x2b, 0x67,0x00, 0x6c,0x19, 0x6d,0x03
};

SANE_Byte callibration_buffer[0x818+4];
SANE_Byte registers[0xff];
SANE_Byte read_buffer[0xff];

SANE_Bool Hp44x0_Wakeup(THWParams *pHWParams,TScanParams *pParams);
SANE_Bool Hp44x0_Down(SANE_Int iHandle);

SANE_Bool Hp44x0_patch_and_send_values (SANE_Int iHandle, SANE_Byte *my_values);
void Hp44x0_patch_regs            (THWParams *pHWParams,SANE_Byte *my_values);
SANE_Bool Hp44x0_set_display    ( SANE_Int iHandle, SANE_Byte val );

SANE_Bool Hp44x0_write_cal_bytes       (THWParams *pHWParams, SANE_Byte b );
SANE_Bool Hp44x0_cal_scanner      (THWParams *pHWParams, TScanParams *pParams);
SANE_Int Hp44x0_park_to_home	(THWParams *pHWParams,TScanParams *pParams);

SANE_Int Hp44x0_move_to_pos (THWParams *pHWParams, TScanParams *pParams);
SANE_Int Hp44x0_wait_for_WarmUp   (SANE_Int iHandle, THWParams *pHWParams);
SANE_Bool Hp44x0_start_scan       (THWParams *pHWParams,TScanParams *pParams,
                            TDataPipe *pDataPipe);
SANE_Bool Hp44x0_init_scan        (THWParams *pHWParams, TScanParams *pParams,
                            TDataPipe *pDataPipe);
SANE_Bool Hp44x0_GetLamp   (SANE_Int iHandle, SANE_Bool *pfLampIsOn);
SANE_Bool Hp44x0_SetLamp   (SANE_Int iHandle, SANE_Bool fLampOn);

SANE_Int  Hp44x0c_nvram_enable_controller(SANE_Int iHandle,SANE_Int enable);


#if 0
void _UnscrambleLine       (SANE_Handle h,SANE_Byte *pabLine,
                            SANE_Byte *pabRed, SANE_Byte *pabGrn, SANE_Byte *pabBlu,
                            SANE_Int iWidth, SANE_Bool iReversedHead);

#endif

#endif /* NO _HP_RTS__H_ */





 /* sane - Scanner Access Now Easy.
   Copyright (C) 2003 Johannes Hub (JohannesHub@t-online.de)

   This file was initially copied from the hp3300 backend.
   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 exutable, 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.
*/

/*
    Concept for a backend for scanners based on the RTS88xx chipset,
    such as HP4400C, HP4470C.
    Parts of this source were inspired by other backends.

		History:

		Version 0.18  21.11.04 13.alpha,
				- source sorted,
				- now only SANEI_USB_SUPPORT for a better overview(xfermodules removed)
				- read and verify the MainBoardID 
		Version 0.17p 02.11.04 12.alpha, source sorted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17p 02.11.04 12.alpha, source sourted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17b 30.03.04 10.alpha, little fixes and libusb implemented
		Version 0.17  09.03.04 9. alpha, HP3500 included
		Version 0.16  06.02.04 8. alpha, wait counting on LCD
		Version 0.15a 29.01.04 7. alpha, CCD switch moved to config file
		Version 0.15  11.01.04 6. alpha, a second CCD implemented
		Version 0.13a 21.11.04 4. alpha, an little fix included
		Version 0.12  22.10.03 third alpha, Backend name changed to HP_RTS88xx
		Version 0.11  30.08.03 second alpha
		Version 0.10  19.07.03 first alpha
*/

/*
		Provides a simple interface to read and write data from the scanner,
		without any knowledge whether it's a parallel or USB scanner

		enable DEDUG output:
		use a nomal shell (konsole) and type
		export SANE_DEBUG_HP_RTS88XX=32
		export XSANE_DEBUG=100
		xsane
*/


#include <unistd.h>    /* read, open, write */
#include <fcntl.h>     /* open */
#include <stdio.h>     /* printf */
#include <errno.h>     /* better error reports */
#include <string.h>    /* better error reports */
#include <stdlib.h>    /* malloc(), free() on FreeBSD */
#include "../include/sane/sanei_usb.h"

#include "hp_rts_xfer.h"

#ifdef STANDALONE
	#include "../include/sane/config.h"
	#include "hp_rts_35x0c.h"
	#include "hp_rts_44x0c.h"
#endif


static SANE_Int _fDeviceFound;
static TScannerModel *_pModel;
static TDevListEntry *_pFirstSaneDev = 0;
static SANE_Int iNumSaneDev = 0;
static const SANE_Device **_pSaneDevList = 0;

/* list of supported models */
TScannerModel ScannerModels[] = {
	{"Hewlett-Packard",	"UnknownModel",		0x3F0,	0x0000, eUnknownModel},
	{"Hewlett-Packard",	"ScanJet 3500C",	0x3F0,	0x2205, eHp3500c}, /*RTS8801C2*/
#ifdef DEBUG_HP3500
	{"Hewlett-Packard",	"ScanJet 3530C",	0x3F0,	0x0805, eHp3530c}, /*RTS8801C2*/
#else
	{"Hewlett-Packard",	"ScanJet 3530C",	0x3F0,	0x2005, eHp3530c}, /*RTS8801C2*/
#endif
	{"Hewlett-Packard",	"ScanJet 3570C",	0x3F0,	0x2005, eHp3570c}, /*RTS8801C2 is the same as 3500 */
	{"Hewlett-Packard",	"ScanJet 4400C",	0x3F0,	0x0705, eHp4400c}, /*RTS8891*/
	{"Hewlett-Packard",	"ScanJet 4470C",	0x3F0,	0x0805, eHp4470c}, /*RTS8891*/
#ifdef ENABLE_VI8920
	{"Visioneer",		"Onetouch 8920 USB",	0x0461,	0x0371, eVi8920}, /*RTS8801C2-004*/
#endif
#if 0
	{"Visioneer",		"Onetouch 8900 USB",	0x0461,	0x0371, eVi8900}, /*RTS8801C2-004*/
	{"Visioneer",		"Onetouch 8700 USB",	0x0461,	0x0371, eVi8700}, /*RTS8801C2-004*/
	{"Visioneer",		"OneTouch 5800 USB",	0x04a7,	0x0226, eVi5800}, /*RTS8801C2-004*/
	{"Visioneer",		"OneTouch 5300 USB",	0x04a7,	0x0226, eVi5300}, /*RTS8801C2-004*/
	{"Visioneer",		"OneTouch 4800 USB",	0x04a7,	0x0224, eVi4800}, /*RTS8801B-0001*/
	{"Vantas",			"3000",								0x04a7,	0x0224, eVa3000}, /*RTS8801B-0001*/
	{"Microtek",		"Scanport 3000",			0x04a7,	0x0224, eMi3000}, /*RTS8801B-0001*/
	{"Plustek",			"OpticPro S6",				0x0???,	0x????, ePlS6}, 	/*RTS8801D*/
	{"Prolink",			"Winscan Pro 2448U",	0x06dc,	0x0014, ePrlS6}, 	/*RTS8801C2-006*/
#endif
/* last entry all zeros */
  {0, 0, 0, 0, 0}
};


/****************************************************************************/
/* utility function to show a hexdump of a buffer */
void Hp_rts_DumpHex(SANE_Byte *pabData, SANE_Int iLen, SANE_Int iWidth, SANE_Int withLf)
/****************************************************************************/
{
  SANE_Int i;

  printf("    ");
  for (i = 0; i < iWidth ; i++) {
    printf(" %02X", i);
  }
  for (i = 0; i < iLen; i++) {
    if ((i % iWidth) == 0) {
      if (withLf) printf("\n");
      printf("%04X", i);
    }
    printf(" %02X", pabData[i]);
  }
  if (withLf) printf("\n");
}

/****************************************************************************/
/* utility function to show a bit dump of a byte */
void Hp_rts_DumpBits(SANE_Byte reg, SANE_Byte pabData)
/****************************************************************************/
{
	SANE_Int i = 0;

	printf("RegisterDump : Register %x will be set to the bits ", reg);
	for (i = 0; i < 8; i++) {
		if (pabData & 0x80)
			printf("1");
		else
			printf("0");
		if (i==3) printf(" ");
		pabData = pabData << 1;
	}
	printf("\n");
}

/****************************************************************************
  Hp_rts_MatchUsbDevice
  ==============
    Matches a given USB vendor and product id against a list of
    supported scanners.

  IN  iVendor   USB vendor ID
      iProduct  USB product ID
  OUT *ppModel  Pointer to TScannerModel structure

  Returns SANE_TRUE if a matching USB scanner was found
*/
SANE_Bool Hp_rts_MatchUsbDevice(SANE_Int iVendor, SANE_Int iProduct, TScannerModel **ppModel)
/****************************************************************************/
{
	TScannerModel *pModels = ScannerModels;

	DBG(DBG_MSG,"Hp_rts_MatchUsbDevice :Matching USB device 0x%04X-0x%04X ... \n", iVendor, iProduct);
	while (pModels->pszName != NULL)
	{
		if ((pModels->iVendor == iVendor) && (pModels->iProduct == iProduct))
		{
			DBG(DBG_MSG,"Hp_rts_MatchUsbDevice : found %s %s\n", pModels->pszVendor, pModels->pszName);
			*ppModel = pModels;
			return SANE_TRUE;
		}
		/* next model to match */
		pModels++;
	}
	DBG(DBG_MSG,"Hp_rts_MatchUsbDevice : nothing found\n");
	return SANE_FALSE;
}



/************************************************************************
  Public functions
************************************************************************/


/*static TFnReportDevice *_pfnReportDevice;*/
static TScannerModel *_pModel;

/****************************************************************************/
static int
_ReportDevice (TScannerModel * pModel, SANE_Char *pszDeviceName)
/****************************************************************************/
{
  TDevListEntry *pNew, *pDev;
#if 0
  DBG (DBG_MSG, "_ReportDevice '%s'", pszDeviceName);
#endif 
  pNew = malloc (sizeof (TDevListEntry));
  if (!pNew)
    {
      DBG (DBG_ERR, "_ReportDevice: no mem\n");
      return -1;
    }

  /* add new element to the end of the list */
  if (_pFirstSaneDev == 0)
    {
      _pFirstSaneDev = pNew;
    }
  else
    {
      for (pDev = _pFirstSaneDev; pDev->pNext; pDev = pDev->pNext)
	{
	  ;
	}
      pDev->pNext = pNew;
    }

  /* fill in new element */
  pNew->pNext = 0;
  pNew->dev.name = strdup (pszDeviceName);
  pNew->dev.vendor = pModel->pszVendor;
  pNew->dev.model = pModel->pszName;
  pNew->dev.type = "flatbed scanner";

  iNumSaneDev++;

  return 0;
}

/* callback for sanei_usb_attach_matching_devices */
/****************************************************************************/
static SANE_Status
_AttachUsb (SANE_String_Const devname)
/****************************************************************************/
{
  DBG (DBG_MSG, "_AttachUsb: found %s", devname);

	_fDeviceFound ++;
  _ReportDevice (_pModel, (SANE_Char *) devname);
/*  _pfnReportDevice (_pModel, (SANE_Char *) devname);*/

  return SANE_STATUS_GOOD;
}

/****************************************************************************
  Hp_rts_XferInit
  ===============
    Probes all registered modules to see if it can be used to access a
    compatible scanner. The first module that supports the scanner is
    used.

  Returns the handle to a TXferDev structure which was used to find the
  scanner, returns 0 or negative otherwise.
*/
SANE_Int Hp_rts_XferInit(/*EScannerModel *peModel*/void)
/****************************************************************************/
{
	TScannerModel *pModels = ScannerModels;

	DBG (DBG_MSG,"Hp_rts_XferInit ....\n");

  sanei_usb_init ();
	_fDeviceFound = 0;
/*	_pfnReportDevice = _ReportDevice;*/

	/* loop over all scanner models */
	while (pModels->pszName != NULL)
	{
		DBG (DBG_MSG, "Looking for %s...", pModels->pszName);
		_pModel = pModels;
		if (sanei_usb_find_devices ((SANE_Int) pModels->iVendor,
					(SANE_Int) pModels->iProduct,
					_AttachUsb) != SANE_STATUS_GOOD)
		{
			DBG (DBG_ERR, "Error invoking sanei_usb_find_devices\n");
			return SANE_FALSE;
		}
#if 0
		DBG(DBG_MSG, "Hp_rts_XferInit: found device ");
		if (pModels->eModel != eUnknownModel){
			_AttachUsb("libusb:001:002*");
		}
#endif
		DBG (DBG_MSG, "\n");
		pModels++;
	}

	if (_fDeviceFound)
		return SANE_TRUE;
	else
		return SANE_FALSE;
}


/****************************************************************************/
SANE_Int Hp_rts_XferOpen (SANE_String_Const devname,EScannerModel *peModel)
/****************************************************************************/
{
	SANE_Status status;
	SANE_Word vendor, product;
	int fd;
	TScannerModel *pModel;

	DBG (DBG_MSG, "Hp_rts_XferOpen, trying to open %s...\n", devname);

	status = sanei_usb_open (devname, &fd);
	if (status != SANE_STATUS_GOOD)
	{
		DBG (DBG_ERR, "Hp_rts_XferOpen: sanei_usb_open failed %s\n", devname);
		return -1;
	}
#if 0
	DBG (DBG_MSG, "Hp_rts_XferOpen, trying to get sanei_usb_get_vendor_product for fd %d\n", (int) fd);
#endif
	status = sanei_usb_get_vendor_product (fd, &vendor, &product);
	if (status == SANE_STATUS_GOOD)
	{
#if 0
		DBG (DBG_MSG, "Hp_rts_XferOpen, trying Hp_rts_MatchUsbDevice\n");
#endif		
		if (Hp_rts_MatchUsbDevice (vendor, product, &pModel)== SANE_TRUE)
		{
#if 0
			DBG (DBG_MSG, "pModel->eModel = %d\n",pModel->eModel);
#endif			
			*peModel = pModel->eModel;
		}else
		{
			DBG (DBG_ERR, "Hp_rts_XferOpen: Hp_rts_MatchUsbDevice failed %s\n", devname);
			sanei_usb_close (fd);
			return -1;
		}
	}else
	{
		DBG (DBG_ERR, "Hp_rts_XferOpen: sanei_usb_get_vendor_product failed %s\n", devname);
		sanei_usb_close (fd);
		return -1;
	}
#if 0
	DBG (DBG_MSG, "handle = %d\n", (int) fd);
#endif
	return fd;
}

/****************************************************************************/
SANE_Int Hp_rts_XferExit(SANE_Int iHandle)
/****************************************************************************/
{

	if (iHandle < 0) {
		return(-1);
	}
	/* close usb device */
	sanei_usb_close (iHandle);
	return SANE_TRUE;
}


/****************************************************************************/
SANE_Int Hp_rts_BulkWrite (SANE_Int iHandle, SANE_Byte reg, SANE_Byte *pabBuf,
                       SANE_Int iSize, SANE_Int wHeader)
/****************************************************************************/
{
	static SANE_Byte init[]={0x88,0,0x00,0x01};
	SANE_Char *request;     /* Compose a request string. */
	SANE_Int size;

#ifdef USBDEBUG
	DBG(DBG_USB,"UsbWriteBulk ...\n");
#endif
	if (iHandle == -1) {
		return(SANE_FALSE);
	}

	if (wHeader){
		request=malloc(iSize + 4);     /* Compose a request string. */
		init[1]=(SANE_Byte)reg;
		init[2]=(SANE_Byte)(iSize>>8); /* split count over these bytes.*/
		init[3]=(SANE_Byte)iSize;
		memcpy(request,init,4);        /* stick them together */
		memcpy(request+4,pabBuf,iSize);
		size = iSize + 4;
#ifdef USBDEBUG
		SANE_Byte *tmpw=request;
		SANE_Int tmp_size=size;
		fprintf(stderr,"WB1 transfer type=bulk size=%d dir=OUT\n",tmp_size);
		while(tmp_size--) fprintf(stderr,"%02hhx ",*tmpw++);
		fprintf(stderr,"\n");
#endif
		if (sanei_usb_write_bulk(iHandle, request,&size) != SANE_STATUS_GOOD) {
			DBG(DBG_ERR, "UsbWriteBulk: ERROR: Bulk write failed\n");
			return SANE_FALSE;
		}
		free(request);                  /* clean up */
	}else
	{
#ifdef USBDEBUG
		SANE_Byte *tmpw=pabBuf;
		SANE_Int tmp_size=iSize;
		fprintf(stderr,"WB2 transfer type=bulk size=%d dir=OUT\n",tmp_size);
		while(tmp_size--) fprintf(stderr,"%02hhx ",*tmpw++);
		fprintf(stderr,"\n");
#endif
    if (sanei_usb_write_bulk(iHandle,pabBuf,&iSize) != SANE_STATUS_GOOD) {
			DBG(DBG_ERR, "UsbWriteBulk: ERROR: Bulk write failed\n");
			return SANE_FALSE;
    }
  }
  return SANE_TRUE;
}


/****************************************************************************/
SANE_Int Hp_rts_BulkRead(SANE_Int iHandle, SANE_Byte reg, SANE_Byte *pabBuf,
                     SANE_Int iSize, SANE_Int wWrite)
/****************************************************************************/
{
	static SANE_Byte init[]={0x80,0,0x00,0x01};
	size_t size;

#ifdef USBDEBUG
	DBG(DBG_USB,"UsbReadBulk ...\n");
#endif
	if (iHandle == -1) {
		return SANE_FALSE;
	}

	if (wWrite){
#ifdef USBDEBUG
		DBG(DBG_USB,"UsbReadBulk with write\n");
#endif
		init[1] = reg;
		init[2] = (iSize>>8) & 0xFF; /*split count over these bytes.*/
		init[3] = (iSize) & 0xFF;
		size = 4;
#ifdef USBDEBUG
		SANE_Byte *tmpw=init;
		SANE_Int tmp_size=size;
		fprintf(stderr,"RR transfer type=bulk size=%d dir=OUT\n",tmp_size);
		while(tmp_size--) fprintf(stderr,"%02hhx ",*tmpw++);
		fprintf(stderr,"\n");
#endif
		if (sanei_usb_write_bulk(iHandle,(unsigned char *) init,&size) != SANE_STATUS_GOOD) {
			DBG(DBG_ERR,"UsbReadBulk: ERROR: Bulk write failed\n");
			return SANE_FALSE;
		}
	}
#ifdef USBDEBUG
	DBG(DBG_USB,"UsbReadBulk, now read ...\n");
#endif
	size = iSize;
	if (sanei_usb_read_bulk(iHandle, pabBuf,&size) != SANE_STATUS_GOOD) {
			DBG(DBG_ERR,"UsbReadBulk: ERROR: Bulk read failed\n");
			return SANE_FALSE;
	}
#ifdef USBDEBUG
	SANE_Byte *tmpr=pabBuf;
	SANE_Int tmp_size=size;
	fprintf(stderr,"RR transfer type=bulk size=%d dir=IN\n",tmp_size);
	while(tmp_size--) fprintf(stderr,"%02hhx ",*tmpr++);
	fprintf(stderr,"\n");
#endif
	return SANE_TRUE;
}


/****************************************************************************/
SANE_Int Hp_rts_RegWrite(SANE_Int iHandle, SANE_Byte bReg, SANE_Byte bData)
/****************************************************************************/
{
#ifdef USBDEBUG
	DBG(DBG_USB, "SaneiUsbWriteReg...\n");
#endif
	if (Hp_rts_BulkWrite(iHandle,bReg,&bData,1, SANE_TRUE))
		return(SANE_TRUE);
	else
		return(SANE_FALSE);
}


/****************************************************************************/
SANE_Int Hp_rts_RegRead(SANE_Int iHandle, SANE_Byte bReg, SANE_Byte *pbData)
/****************************************************************************/
{
#ifdef USBDEBUG
	DBG(DBG_USB, "SaneiUsbReadReg...\n");
#endif
	if (Hp_rts_BulkRead(iHandle,bReg,pbData,1,SANE_TRUE))
		return(SANE_TRUE);
	else
		return(SANE_FALSE);
}


/****************************************************************************/
SANE_Int Hp_rts_BulkReadall(SANE_Int iHandle, SANE_Byte *pabData)
/****************************************************************************/
{
	SANE_Byte init[]={0x80,0,0x00,0xf4};

#ifdef USBDEBUG
	DBG(DBG_USB, "SaneiUsbReadBulk_all_regs...\n");
#endif
	if (iHandle < 0) {
		return -1;
	}

	if (Hp_rts_BulkWrite(iHandle,1,(char *)init,4, SANE_FALSE))
	{
		if (Hp_rts_BulkRead(iHandle,0x81,pabData,192,SANE_FALSE))
		{
			if (Hp_rts_BulkRead(iHandle,0x81,pabData+192,52,SANE_FALSE))
				return(SANE_TRUE);

		} else return(SANE_FALSE);
	} else return(SANE_FALSE);
	return SANE_TRUE;
}

/*************************************************************************
  Returns SANE_TRUE if a known chipset was found. */
SANE_Bool Hp_rts_ProbeRegisters(THWParams *pHWParams)
/*************************************************************************/
{
	SANE_Byte bData1,r;
	SANE_Int iHandle;

	iHandle = pHWParams->iXferHandle;
	bData1 = 0;
	DBG(DBG_MSG, "Hp_rts_ProbeRegisters: iHandle = %d, Probing scanner...\n",(SANE_Int)iHandle);
	Hp_rts_RegRead( iHandle, 0x00, &bData1); /* read register 0x00 */
	if ((bData1 == 0xE5) || (bData1 == 0xF5)) {
		switch (pHWParams->ScannerModel) {
			case eHp3500c: case eHp3530c: case eHp3570c:
#ifdef ENABLE_VI8920
			case eVi8920:
#endif
				return SANE_STATUS_GOOD;
				break;
			case eHp4400c: case eHp4470c:
				Hp_rts_RegRead(iHandle,MAINBOARD_ID, &r);
				if (r == 0)
					return SANE_STATUS_GOOD;
				DBG(DBG_ERR, "Hp_rts_ProbeRegisters: Wrong MainBoardID = %d\n",r);
				DBG(DBG_ERR, "Hp_rts_ProbeRegisters: No valid scanner with RTS88xx chipset found!\n");
				Hp_rts_XferExit(iHandle);
				return SANE_STATUS_IO_ERROR ;
				break;
			default:
				DBG(DBG_ERR, "Hp_rts_ProbeRegisters: ERROR: unknown model! (%d) %s\n",
					(SANE_Int)pHWParams->ScannerModel, ScannerModels[(SANE_Int)pHWParams->ScannerModel].pszName);
			return SANE_STATUS_IO_ERROR;
		}
	}
	else
	{
		DBG(DBG_ERR, "Hp_rts_ProbeRegisters: No valid scanner with RTS88xx chipset found!\n");
		Hp_rts_XferExit(iHandle);
		return SANE_STATUS_IO_ERROR ;
	}
}

/****************************************************************************/
SANE_Int Hp_rts_Set_double_reg(SANE_Int iHandle, SANE_Byte reg,
                           SANE_Byte c1, SANE_Byte c2 )
/****************************************************************************/
{
  SANE_Byte regs[5];

#ifdef USBDEBUG
	DBG(DBG_SCAN, "Hp_rts_Set_double_reg....\n");
#endif
  regs[0] = c1;
  regs[1] = c2;
  return(Hp_rts_BulkWrite (iHandle, reg, regs, 2,SANE_TRUE));
}

/****************************************************************************/
SANE_Int Hp_rts_Read_double_reg(SANE_Int iHandle, SANE_Byte reg, SANE_Byte *pbData )
/****************************************************************************/
{
#ifdef USBDEBUG
	DBG(DBG_SCAN, "Hp_rts_Read_double_reg....\n");
#endif
	return(Hp_rts_BulkRead(iHandle,reg,pbData,2,SANE_TRUE));
}

/****************************************************************************/
/*Return the number of bytes ready for collection                           */
SANE_Word Hp_rts_data_ready(SANE_Int iHandle, SANE_Word *size){
/****************************************************************************/
	static SANE_Byte command[]={0x90,0x00,0x00,0x03};
	SANE_Byte data[5];

#if 0
	DBG(DBG_SCAN, "Hp_rts_data_ready....\n");
#endif
	/* check if the scanner is moving*/
	if (SANE_TRUE /*read_reg(iHandle,MOVE_START_STOP) & 0x08*/)
	{
		Hp_rts_BulkWrite(iHandle,0x00,command,4,SANE_FALSE);
		Hp_rts_BulkRead(iHandle,0x00,data,3,SANE_FALSE);
		*size = data[0];
		*size = *size + (data[1]<<8);
		*size = *size + (data[2]<<16);
		if(*size > 0xe500) *size=0xe500;
		DBG(DBG_SCAN, "     Hp_rts_data_ready....data %x\n",*size);
		if (*size > 0){
			return(SANE_TRUE); }
		else
			return(SANE_FALSE);
	}else return(SANE_FALSE);
}


/****************************************************************************/
SANE_Int Hp_rts_read_data(SANE_Int iHandle, SANE_Word size,SANE_Byte *data) {
/****************************************************************************/
  static SANE_Byte write_command[]={0x91,0x00,0x00,0x00};

  write_command[3]=size & 0xff;
  write_command[2]=(size>>8) & 0xff;
  write_command[1]=(size>>16) & 0xff;

#ifdef USBDEBUG
	DBG(DBG_SCAN, "Hp_rts_read_data..%x\n",size);
#endif
  Hp_rts_BulkWrite(iHandle,0x00,write_command,4,SANE_FALSE);
  Hp_rts_BulkRead(iHandle,0x00,data,size,SANE_FALSE);
  return(SANE_TRUE);
}

/****************************************************************************/
SANE_Bool
Hp_rts_is_moving( SANE_Int iHandle )
/****************************************************************************/
{
	SANE_Byte	r;

	Hp_rts_RegRead(iHandle,REG_MOVE_CONTROL_TEST, &r);
/*	if ( Hp_rts_RegRead(iHandle,REG_MOVE_CONTROL_TEST, &r) < 0)
		return -1;*/
	if (r == 0x08)
		return SANE_TRUE;
	return SANE_FALSE;
}

/****************************************************************************/
SANE_Int
Hp_rts_start_moving( SANE_Int iHandle )
/****************************************************************************/
{
	DBG(DBG_MSG,"Hp_rts_start_moving...");
	if (Hp_rts_RegWrite(iHandle,REG_MOVE_CONTROL_TEST, 2) &&
	    Hp_rts_RegWrite(iHandle,REG_MOVE_CONTROL_TEST, 2) &&
	    Hp_rts_RegWrite(iHandle,REG_MOVE_CONTROL_TEST, 0) &&
	    Hp_rts_RegWrite(iHandle,REG_MOVE_CONTROL_TEST, 0) &&
	    Hp_rts_RegWrite(iHandle,REG_MOVE_CONTROL_TEST, 8) &&
	    Hp_rts_RegWrite(iHandle,REG_MOVE_CONTROL_TEST, 8))
		{
			DBG(DBG_MSG,"Hp_rts_start_moving..TRUE\n");
			return SANE_TRUE;
		}
		else
		{
			DBG(DBG_MSG,"Hp_rts_start_moving..FALSE\n");
			return SANE_FALSE;
		}
}

/****************************************************************************/
SANE_Int
Hp_rts_stop_moving( SANE_Int iHandle )
/****************************************************************************/
{
	DBG(DBG_MSG,"Hp_rts_stop_moving...");
	if (Hp_rts_RegWrite(iHandle,REG_MOVE_CONTROL_TEST, 2) &&
	    Hp_rts_RegWrite(iHandle,REG_MOVE_CONTROL_TEST, 2) &&
	    Hp_rts_RegWrite(iHandle,REG_MOVE_CONTROL_TEST, 0) &&
	    Hp_rts_RegWrite(iHandle,REG_MOVE_CONTROL_TEST, 0))
		{
			DBG(DBG_MSG,"Hp_rts_stop_moving..TRUE\n");
			return SANE_TRUE;
		}
		else
		{
			DBG(DBG_MSG,"Hp_rts_stop_moving..FALSE\n");
			return SANE_FALSE;
		}
}


/****************************************************************************/
/* Write a gamma table */
void
Hp_rts_WriteGammaCalibTable (SANE_Int iHandle,
			const SANE_Int *pabGammaR, const SANE_Int *pabGammaG,  const SANE_Int *pabGammaB)
/****************************************************************************/
{
  SANE_Byte cmd[3];
  SANE_Byte *buffer;
  SANE_Int i, j;

  iHandle = iHandle;

  /* Setup dummy gamma correction table */
  buffer = malloc (2 * 65536);

  cmd[0] = 2;
  cmd[1] = 0;
  cmd[2] = 0;

  for (i = 0; i < 3; i++)
    {
      const SANE_Int *ptr = (i == 0) ? pabGammaR :
	(i == 1) ? pabGammaG : pabGammaB;

      for (j = 0; j < 65536; j++)	/* Truncate integers to shorts */
	buffer[j] = ptr[j];

/*      hp5400_bulk_command_write (iHandle, 0x2A01 + i, cmd, 3, 2 * 65536,
				 65536, (void *) buffer);*/
    }
  free (buffer);

  return;
}

/****************************************************************************
void
Hp_rts_SetDefaultGamma (SANE_Int iHandle)
****************************************************************************
{
  SANE_Int *buffer = malloc (sizeof (SANE_Int) * 65536);
  SANE_Int i;

  for (i = 0; i < 65336; i++)
    buffer[i] = i;

  Hp_rts_WriteGammaCalibTable (iHandle, buffer, buffer, buffer);
}*/

/****************************************************************************/
SANE_Bool
Hp_rts_Check_Moving (SANE_Int iHandle)
/****************************************************************************/
{
	SANE_Int i;
#if 0
	SANE_Word size;
#endif

	DBG(DBG_MSG,"Hp_rts_Check_Moving: wait for moving ...\n");
	i = 0;
	while( !(Hp_rts_is_moving(iHandle)) && ( i < 25 )){
		usleep(10000);
		i++;
		};
	if ( i >= 25 ){
		DBG(DBG_MSG,"Hp_rts_Check_Moving: Time over, no move : %d!, will stop the movement\n",i);
		/*stop it and make sure it stopped!!! */
		Hp_rts_stop_moving(iHandle);
		return(SANE_FALSE);
	}
#if 0
	/* the scanner is now moving. Check it */
	DBG(DBG_MSG,"Hp_rts_Check_Moving: the scanner is now scanning. Check it\n");
	i = 0;
	while( (Hp_rts_data_ready(iHandle,&size) == SANE_FALSE) && ( i < 25 )){
		usleep(10000);
		i++;
	}
	if ( i >= 25 ){
		DBG(DBG_MSG,"Hp_rts_Check_Scanning: Time over, scanner no data : %d, will stop the scanner!\n",i);
		/*stop it and make sure it stopped!!! */
		Hp_rts_stop_moving(iHandle);
		return(SANE_FALSE);
	}
#endif
	return(SANE_TRUE);
}

/****************************************************************************/
SANE_Int
Hp_rts_Read_Sram (SANE_Int iHandle, SANE_Byte *pabData,
                            SANE_Int iSize)
/****************************************************************************/
{
	SANE_Byte init[]={0x81,0x00,0x08,0x18};

	if (iHandle < 0) {
		return(-1);
	}
#ifdef USBDEBUG
	DBG(DBG_MSG,"Hp_rts_Read_Sram...\n");
#endif
	init[2]=(SANE_Byte)(iSize>>8); /*split count over these bytes.*/
	init[3]=(SANE_Byte)iSize;

	if (Hp_rts_BulkWrite(iHandle,0x00,/*(SANE_Byte *)*/init,4,SANE_FALSE)){
#if 0
		DBG(DBG_MSG,"Read SRAM, READ NOW %d bytes\n",iSize);
		if (iSize >= 0x800){
			DBG(DBG_MSG,"Read SRAM, READ the first %d bytes\n",2048);
			if (Hp_rts_BulkRead(iHandle,0x00,(SANE_Byte *)pabData, 2048,SANE_FALSE) == 0){
				DBG(DBG_MSG,"Read SRAM, READ the left %d bytes\n",iSize-2048);
				return (Hp_rts_BulkRead(iHandle,0x00,(SANE_Byte *)pabData, iSize-2048,SANE_FALSE));
			}
		}
		else{
#endif
			return (Hp_rts_BulkRead(iHandle,0x00,(SANE_Byte *)pabData, iSize,SANE_FALSE));
#if 0
		}
#endif
	}
	return(SANE_FALSE);
}

/****************************************************************************/
SANE_Int
Hp_rts_set_value_lsbfirst(	SANE_Byte	*regs,
			SANE_Int		firstreg,
			SANE_Int		totalregs,
			SANE_Word	value)
/****************************************************************************/
{
	while (totalregs--)
	{
		regs[firstreg++] = value & 0xff;
		value >>= 8;
	}
	return 0;
}

/****************************************************************************/
SANE_Int
Hp_rts_set_noscan_distance(			SANE_Byte	*regs,
					SANE_Word	value)
/****************************************************************************/
{
	return Hp_rts_set_value_lsbfirst(regs, 0x60, 2, value);
}

/****************************************************************************/
SANE_Int
Hp_rts_set_total_distance(			SANE_Byte	*regs,
					SANE_Word	value)
/****************************************************************************/
{
	return Hp_rts_set_value_lsbfirst(regs, 0x62, 2, value);
}

/****************************************************************************/
SANE_Int
Hp_rts_set_scanline_end(			SANE_Byte	*regs,
					SANE_Word	value)
/****************************************************************************/
{
	return Hp_rts_set_value_lsbfirst(regs, 0x6c, 2, value);
}

/****************************************************************************/
SANE_Int
Hp_rts_set_scanline_start(			SANE_Byte	*regs,
					SANE_Word	value)
/****************************************************************************/
{
	return Hp_rts_set_value_lsbfirst	(regs, 0x66, 2, value);
}


/****************************************************************************/
SANE_Status Hp_rts_CircBufferInit(SANE_Handle h, TDataPipe *p, SANE_Int iBytesPerLine,
													SANE_Int iMisAlignment, SANE_Bool mode)
/****************************************************************************/
{
	TScanner  *s;
	SANE_Int iHandle;
	SANE_Int bufsize;

	/* prevent compiler from complaining about unused parameters */
	mode = mode;

	s = (TScanner *)h;
	iHandle = s->HWParams.iXferHandle;
	p->iBytesPerLine = iBytesPerLine;
	bufsize = p->iBytesPerLine * 3;
	p->iLinesPerCircBuf = 1;
	p->iMisAlignment = iMisAlignment;

	DBG(DBG_SCAN, "Hp_rts_CircBufferInit: _iBytesPerLine = %d\n", p->iBytesPerLine);
	DBG(DBG_SCAN, "Hp_rts_CircBufferInit: _iLinesPerCircBuf = %d\n", p->iLinesPerCircBuf);

	p->pabCircBuf = (SANE_Byte *)malloc(bufsize+(3*p->iBytesPerLine));
	if (p->pabCircBuf == NULL) {
		DBG(DBG_ERR, "Hp_rts_CircBufferInit: Unable to allocate %d bytes for circular buffer (%x - %x)\n",
								(SANE_Int)bufsize,(unsigned int)p->pabCircBuf,(unsigned int)p->pabCircBuf+bufsize);
		return SANE_STATUS_NO_MEM;
	}
	DBG(DBG_SCAN,"Hp_rts_CircBufferInit: Allocate %d bytes for circular buffer (%x - %x)\n",
								(SANE_Int)bufsize,(unsigned int)p->pabCircBuf,(unsigned int)p->pabCircBuf+bufsize);
	/* init transfer buffer */
	return Hp_rts_XferBufferInit(h, p);
}


/****************************************************************************/
void Hp_rts_CircBufferExit(SANE_Handle h)
/****************************************************************************/
{
	TScanner  *s;

	s = (TScanner *)h;
	if (s->DataPipe.pabCircBuf != NULL) {
		free(s->DataPipe.pabCircBuf);
		s->DataPipe.pabCircBuf = NULL;
	}
	Hp_rts_XferBufferExit( h );
	DBG(DBG_SCAN,"Hp_rts_CircBufferExit\n");
}


/****************************************************************************/
/* gets an line from the circular buffer. */
SANE_Bool Hp_rts_CircBufferGetLine(SANE_Handle h, TDataPipe *p, SANE_Byte *pabLine,
												SANE_Bool mode){
/****************************************************************************/

	SANE_Int line_lenght,copy_lines;
	#ifdef DEBUG_FILE
	SANE_Word size_t,data_count;
	#endif

	TScanner  *s;

	s = (TScanner *)h;

	DBG(DBG_SCAN,"   Hp_rts_CircBufferGetLine starts here\n");
	mode = mode;
	line_lenght = p->iBytesPerLine;
	copy_lines = 0;

	if (pabLine != NULL) {
		if (Hp_rts_XferBufferGetLine(h, p, &p->pabCircBuf[0])){
			memcpy(pabLine, &p->pabCircBuf[0], p->iBytesPerLine);
			#ifdef DEBUG_FILE
				data_count = 0;
				size_t = p->iBytesPerLine;
				while(size_t--) fprintf(s->ScanParams.FD_r,"%c",p->pabCircBuf[data_count++]);
			#endif
			return SANE_TRUE;
		}
	}
	return SANE_FALSE;
}


/****************************************************************************/
SANE_Bool Hp_rts_XferBufferGetLine(SANE_Handle h, TDataPipe *p, SANE_Byte *pabLine)
/****************************************************************************/
{
	TScanner  *s;
	SANE_Word size;
	SANE_Word size_t;
	SANE_Word Lines, Skip, lBytes;
	SANE_Int iHandle,i,wt;
	SANE_Byte *buf;

	s = (TScanner *)h;
	iHandle = s->HWParams.iXferHandle;

	DBG(DBG_SCAN,"     Hp_rts_XferBufferGetLine in: = iBytesPerLine=%3d iLinesLeft=%3d\n",
								(SANE_Int)p->iBytesPerLine,(SANE_Int)s->ScanParams.iLinesLeft);

	switch (s->ScanParams.iDpi) {
		case 150:
		case 200:
		case 300:
		case 600:
			if (s->ScanParams.mode == COLOR)
				Skip = 1;
			else
				Skip = 2;
		break;
		default:
			Skip = 1;
		break;
	}
	lBytes = p->iBytesPerLine;

	/* Step 1, check if we have to receive more data from the scanner */
	if (p->iCurLine == 0){
		i = 0;
		while( i < 10 ){
			Hp_rts_data_ready(iHandle,&size);
			if (size > lBytes)
				i = 9;
			usleep(10);
			i++;
		}
		#if 0
			DBG(DBG_SCAN,"size %d  ",(SANE_Int) size);
		#endif
		Hp_rts_data_ready(iHandle,&size);
		Lines = (size / lBytes) / Skip; /* make shure we can div. it */
		size_t = (Lines * lBytes) * Skip;
		#ifdef DEBUG_SCAN
			DBG(DBG_SCAN,"     Hp_rts_XferBufferGetLine: size %d lBytes %d size_t %d\n",size,lBytes,size_t);
			DBG(DBG_SCAN,"     Hp_rts_XferBufferGetLine: write to buffer at 0x%x %d Lines\n",
									(unsigned int) p->pabXferBuf,Lines);
		#endif
		p->iLastLine = Lines * Skip;
		if ( size_t > 0 ){
			Hp_rts_read_data(iHandle,size_t,p->pabXferBuf);
		}else
		{ /* fix: the scanner is stoped.
					we have to read all bytes to
					restart him                  */
			#ifdef DEBUG_SCAN
				DBG(DBG_SCAN,"     Hp_rts_XferBufferGetLine: restart %d\n",size_t);
			#endif
			if ( size > 0 ){
				Hp_rts_read_data(iHandle,size,p->pabXferBuf);
				size_t = lBytes - size;
				i = 0;
				while( (Hp_rts_data_ready(iHandle,&size) == SANE_FALSE) && ( i < 3 )){
					sleep(1);
					i++;
				}
				#ifdef DEBUG_SCAN
					DBG(DBG_SCAN,"     Hp_rts_XferBufferGetLine: restart read %d\n",size_t);
				#endif
				Hp_rts_read_data(iHandle,size,p->pabXferBuf);
			}
			else{ /* no more data aviable */
				p->iLastLine = 0;
				return(SANE_FALSE);
			}
		}
		wt = (10 * (XFER_BUF_SIZE - size))/2;
		if (wt < 1) wt = 1;
		if (wt > 65000) wt = 65000;
		#ifdef DEBUG_SCAN
			DBG(DBG_SCAN,"     Wait %d s, size %d, iLastLine %d\n",wt, size,(SANE_Int)p->iLastLine);
		#endif
		usleep(wt);
	}

	/* Step 2, copy one line */
	if (pabLine != NULL) {
		buf = p->pabXferBuf + (p->iCurLine * lBytes);
		#ifdef DEBUG_SCAN
			DBG(DBG_SCAN,"     Hp_rts_XferBufferGetLine: read from buffer at 0x%x (%d), iLinesLeft %d, iScanned %d\n",
					(unsigned int) buf,p->iCurLine,(SANE_Int)s->ScanParams.iLinesLeft,(SANE_Int)p->iScanned);
		#endif
		memcpy(pabLine, buf, lBytes);
	}

	/* Step 3, set the advance pointer */
	p->iCurLine = p->iCurLine + Skip;
	p->iScanned = p->iScanned + 1;

	if ( p->iCurLine >= p->iLastLine  ){
		p->iCurLine = 0;
		#ifdef DEBUG_SCAN
			DBG(DBG_SCAN,"     Hp_rts_XferBufferGetLine: set p->iCurLine = 0\n");
		#endif
	}
	#ifdef DEBUG_SCAN
		DBG(DBG_SCAN,"     Hp_rts_XferBufferGetLine: exit\n");
	#endif
	return(SANE_TRUE);
}


/****************************************************************************/
SANE_Status Hp_rts_XferBufferInit(SANE_Handle h, TDataPipe *p)
/****************************************************************************/
{
	TScanner  *s;
	#ifdef DEBUG_FILE
	SANE_Word x1,x2,length ;
	#endif

	SANE_Int bufsize;

	s = (TScanner *)h;
	bufsize = XFER_BUF_SIZE/**10*/;

	p->iLinesPerXferBuf = bufsize / (p->iBytesPerLine);
	p->iLastLine = 0;
	DBG(DBG_SCAN,"Hp_rts_XferBufferInit: iLinesPerXferBuf = %d\n", p->iLinesPerXferBuf);
	DBG(DBG_SCAN,"Hp_rts_XferBufferInit: Xfer block size = 0x%x\n", p->iLinesPerXferBuf *
																													p->iBytesPerLine);

	#ifdef DEBUG_FILE
		/* Opening the testfile for debuging */
		if ( !s->ScanParams.DebugOpen ){
			s->ScanParams.DebugOpen = SANE_TRUE;
			s->ScanParams.FD_r = fopen("view_r.pnm","w");
			x1 = s->ScanParams.iX;
			x2 = s->ScanParams.iWidth ;
			length = s->ScanParams.iLenght - 1;
			DBG(DBG_SCAN,"TempFile, length:%d, x1:%d, x2:%d \n",length,x1,x2);
			switch (s->ScanParams.mode) {
				case BLACK_WHITE:
				case GRAY:
					fprintf(s->ScanParams.FD_r,"P5\n%d %d\n255\n",x2,length+100);
				break;
				case COLOR:
					fprintf(s->ScanParams.FD_r,"P6\n%d %d\n255\n",x2,length+100);
				break;
			}
		}
	#endif
	p->iCurLine = 0;

	p->pabXferBuf = (SANE_Byte *)malloc(bufsize);
	if (p->pabXferBuf == 0){
		DBG(DBG_ERR,"Hp_rts_XferBufferInit: MEM alloc is not not possible !\n");
		return SANE_STATUS_NO_MEM;
	} else{
		DBG(DBG_SCAN,"Hp_rts_XferBufferInit alloc: p->pabXferBuf = 0x%x bytes at 0x%x\n",
								bufsize,(unsigned int) p->pabXferBuf);
		return SANE_STATUS_GOOD;
	}
}


/****************************************************************************/
void Hp_rts_XferBufferExit( SANE_Handle h )
/****************************************************************************/
{
	TScanner *s;

	s = (TScanner *)h;
	if (s->DataPipe.pabXferBuf != NULL) {
		DBG(DBG_SCAN,"Hp_rts_XferBufferExit free: p->pabXferBuf at 0x%x\n",
				(unsigned int) s->DataPipe.pabXferBuf);
		free(s->DataPipe.pabXferBuf);
		s->DataPipe.pabXferBuf = NULL;
	}
	else { ;
		DBG(DBG_ERR, "Hp_rts_XferBufExit: Xfer buffer not initialised!\n");
	}
}






 /* sane - Scanner Access Now Easy.
   Copyright (C) 2003 Johannes Hub (JohannesHub@t-online.de)

   This file was initially copied from the hp3300 backend.
   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 exutable, 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.
*/

/*
    Concept for a backend for scanners based on the RTS88xx chipset,
    such as HP4400C, HP4470C.
    Parts of this source were inspired by other backends.

		History:

		Version 0.18  21.11.04 13.alpha,
				- source sorted,
				- now only SANEI_USB_SUPPORT for a better overview(xfermodules removed)
				- read and verify the MainBoardID 
		Version 0.17p 02.11.04 12.alpha, source sorted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17p 02.11.04 12.alpha, source sourted, little fixes, SANEI_USB_SUPPORT implemented
		Version 0.17b 30.03.04 10.alpha, little fixes and libusb implemented
		Version 0.17  09.03.04 9. alpha, HP3500 included
		Version 0.16  06.02.04 8. alpha, wait counting on LCD
		Version 0.15a 29.01.04 7. alpha, CCD switch moved to config file
		Version 0.15  11.01.04 6. alpha, a second CCD implemented
		Version 0.13a 21.11.04 4. alpha, an little fix included
		Version 0.12  22.10.03 third alpha, Backend name changed to HP_RTS88xx
		Version 0.11  30.08.03 second alpha
		Version 0.10  19.07.03 first alpha
*/

/*
    Provides a simple interface to read and write data from the scanner,
    without any knowledge whether it's a parallel or USB scanner
*/

#ifndef _HP_RTS_XFER_H_
#define _HP_RTS_XFER_H_

#include <stdio.h> /* for FILE * */

#ifdef STANDALONE

	#include <ctype.h>
	#include "../include/sane/config.h"
	#include "../include/sane/sane.h"

	#include "hp_rts88xx.h"
	#undef DBG
	#undef DBG_MSG
	#undef DBG_USB
	#undef DBG_OPT
	#undef DBG_SCAN
	#undef DBG_ASSERT
	#undef DBG_ERR

	#define DBG          fprintf
	#define DBG_MSG      stdout
	#define DBG_USB      stdout
	#define DBG_OPT      stdout
	#define DBG_SCAN     stdout
	#define DBG_ASSERT   stdout
	#define DBG_ERR      stdout

#endif


#define MAINBOARD_ID          0xb1
#define	REG_MOVE_CONTROL_TEST	0xb3

#define MAX_READ_WRITE	0x3fff    /* 4096 */
#define TIMEOUT         10000
#define XFER_BUF_SIZE  0xFF00

#ifndef MIN
#define MIN(a,b) (((a) < (b)) ? (a) : (b))
#endif
#ifndef MAX
#define MAX(a,b) (((a) > (b)) ? (a) : (b))
#endif


typedef enum {
	eUnknownModel = 0,
	eHp3500c,
	eHp3530c,
	eHp3570c,
	eHp4400c,
	eHp4470c,
	eVi8920,
	eVi8900,
	eVi8700,
	eVi5800,
	eVi5300,
	eVi4800,
	eVa3000,
	eMi3000,
	ePlS6,
	ePrlS6
} EScannerModel;


typedef struct {
	SANE_Char     *pszVendor;
	SANE_Char     *pszName;
	SANE_Int      iVendor;
	SANE_Int      iProduct;
	EScannerModel eModel;
} TScannerModel;


/* linked list of SANE_Device structures */
typedef struct TDevListEntry
{
  struct TDevListEntry *pNext;
  SANE_Device dev;
}
TDevListEntry;


typedef SANE_Int (TFnReportDevice)(TScannerModel *pModel, SANE_Char *pszDeviceName);

/* USB device file name */
extern SANE_Char * usb_devfile;

/* list of supported models, the actual list is in hp_rts_xfer.c */
extern TScannerModel ScannerModels[];

/*  The number returned by Hp_rts_XferInit is a handle. This handle needs to
    be passed to all other transfer functions.
    Internally it is a pointer to structure containg function pointers
*/
void			Hp_rts_DumpHex(SANE_Byte *pabData, SANE_Int iLen, SANE_Int iWidth, SANE_Int withLf);
void			Hp_rts_DumpBits(SANE_Byte reg, SANE_Byte pabData);

SANE_Int Hp_rts_XferInit(/*EScannerModel *peModel*/void);
/*SANE_Int  Hp_rts_XferInit        (EScannerModel *peModel);*/
SANE_Int  Hp_rts_XferExit        (SANE_Int iXferHandle);
SANE_Int  Hp_rts_RegWrite        (SANE_Int iXferHandle, SANE_Byte reg, SANE_Byte bData);
SANE_Int  Hp_rts_RegRead         (SANE_Int iXferHandle, SANE_Byte reg, SANE_Byte *pbData);
SANE_Int  Hp_rts_BulkWrite       (SANE_Int iXferHandle, SANE_Byte reg, SANE_Byte *pabBuf, SANE_Int iSize, SANE_Int wHeader);
SANE_Int  Hp_rts_BulkRead        (SANE_Int iXferHandle, SANE_Byte reg, SANE_Byte *pabBuf, SANE_Int iSize, SANE_Int wWrite);
SANE_Int  Hp_rts_BulkReadall     (SANE_Int iHandle,     SANE_Byte *pabData);
SANE_Bool Hp_rts_MatchUsbDevice  (SANE_Int iVendor,     SANE_Int iProduct, TScannerModel **ppeModel);
SANE_Bool Hp_rts_ProbeRegisters  (THWParams *pHWParams);
SANE_Int  Hp_rts_Set_double_reg  (SANE_Int iHandle, SANE_Byte reg, SANE_Byte c1, SANE_Byte c2 );
SANE_Int  Hp_rts_Read_double_reg (SANE_Int iHandle, SANE_Byte reg, SANE_Byte *pbData );
SANE_Int  Hp_rts_data_ready      (SANE_Int iHandle, SANE_Int *size);
SANE_Int  Hp_rts_read_data       (SANE_Int iHandle, SANE_Int size,SANE_Byte *data);
SANE_Int Hp_rts_set_value_lsbfirst(	SANE_Byte	*regs,SANE_Int	firstreg,SANE_Int totalregs, SANE_Word	value);

SANE_Bool  Hp_rts_is_moving       (SANE_Int iHandle);
SANE_Int  Hp_rts_start_moving    (SANE_Int iHandle);
SANE_Int  Hp_rts_stop_moving     (SANE_Int iHandle);
void      Hp_rts_WriteGammaCalibTable   (SANE_Int iHandle,
																	const SANE_Int *pabGammaR, const SANE_Int *pabGammaG,const SANE_Int *pabGammaB);
/*void      Hp_rts_SetDefaultGamma (SANE_Int iHandle);*/
SANE_Bool  Hp_rts_Check_Moving  (SANE_Int iHandle);
SANE_Int  Hp_rts_Read_Sram       (SANE_Int iHandle, SANE_Byte *pabData,
                                  SANE_Int iSize);
SANE_Int  Hp_rts_set_noscan_distance(SANE_Byte	*regs,SANE_Word	value);
SANE_Int  Hp_rts_set_total_distance(SANE_Byte	*regs,SANE_Word	value);
SANE_Int  Hp_rts_set_scanline_end(SANE_Byte	*regs,SANE_Word	value);
SANE_Int  Hp_rts_set_scanline_start(SANE_Byte	*regs,SANE_Word	value);

SANE_Status Hp_rts_CircBufferInit (SANE_Handle h, TDataPipe *p, SANE_Int iBytesPerLine,
                            SANE_Int iMisAlignment, SANE_Bool mode);

SANE_Bool Hp_rts_CircBufferGetLine     (SANE_Handle h, TDataPipe *p, SANE_Byte *pabLine,
                            SANE_Bool mode);

void Hp_rts_CircBufferExit        (SANE_Handle h);

SANE_Bool Hp_rts_XferBufferGetLine(SANE_Handle h, TDataPipe *p, SANE_Byte *pabLine);

void Hp_rts_XferBufferExit        (SANE_Handle h);
SANE_Status Hp_rts_XferBufferInit (SANE_Handle h, TDataPipe *p);

#endif /* _HP_RTS_XFER_H_ */




;
; SANE Backend specification file
;
:backend "hp_rts88xx"                                ; name of backend
;:version "(0.18)"                                   ; version of backend
;:manpage "sane-hp_rts88xx"                          ; name of manpage (if it exists)
:url "http://hp44x0backend.sourceforge.net" ; backend's web page

:devicetype :scanner                                  ; start of a list of devices....

:mfg "Hewlett-Packard"                                ; name a manufacturer
:url "http://www.hp.com/"

:model "HP4400C"                                      ; name models for above-specified mfg.
:interface "USB"
:status :basic
:comment "grayscale 300/600 DPI"

:model "HP4470C"
:interface "USB"
:status :basic
:comment "grayscale 300/600 DPI, XPA/bed mode"

:model "HP3500C"
:interface "USB"
:status :basic
:comment "not tested"

:model "HP3530C"
:interface "USB"
:status :basic
:comment "not tested"

:model "HP3570C"
:interface "USB"
:status :basic
:comment "not tested"




.\" $Id: sane-hp_rts88xx.man,v 1.2 2004/22/10 10:35:31 jh Exp $
.TH sane-hp_rts88xx 5 "22 Oct 2004"
.IX sane-hp_rts88xx

.SH NAME
sane-hp_rts88xx - SANE backend for scanners based on the RTS8891 chipset.

.SH DESCRIPTION
The
.B sane-hp_rts88xx
implements a SANE (Scanner Access Now Easy) backend that
provides access to RTS8891 chipset based scanners. This backend will try to support
the following models:

MANUFACTURER:    MODEL:         USB ID:
.br
---------------  --------------  ---------
.br
Hewlett-Packard  Scanjet 4400c   03F0-0705
.br
Hewlett-Packard  Scanjet 4470c   03F0-0805
.br
Hewlett-Packard  Scanjet 3500C   03F0-2205
.br
Hewlett-Packard  Scanjet 3530c   03F0-2005
.br
Hewlett-Packard  Scanjet 3570c   03F0-2005
.br
.PP
.br

.SH "DEVICE NAMES"
This backend expects device names of the form:
.PP
.RS
.I special
.RE
.PP
Where
.I special
is a path-name for the special device that corresponds to a USB scanner.
With GNU/Linux systems, such a device name could be
.I /dev/usb/scanner0
or
.IR /dev/usbscanner1 ,
for example.


.SH CONFIGURATION
The
.I hp_rts88xx.conf
file contains the device name that correspond to the hp44x0c
scanner.  Empty lines and lines starting with a hash mark (#) are
ignored.
.PP
A sample configuration file is shown below:
.PP
.RS
# Comment
.br
/dev/usbscanner
# option_CCD
# CCD0 or CCD1 allowed
# if you receive a black image, change it to CCD1
option CCD0
.RE
.PP
The first line is ignored. The second line is the device filename to use
in order to access the hp44x0c Scanner. If no device is given, the
backend will use libUSB.

.SH FILES
.TP
.I @CONFIGDIR@/hp_rts88xx.conf
The backend configuration file (see also description of SANE_CONFIG_DIR below).

.TP
.I @LIBDIR@/libsane-hp_rts88xx.a
The static library implementing this backend.

.TP
.I @LIBDIR@/libsane-hp_rts88xx.so
The shared library implementing this backend (present on systems that
support dynamic loading).
.SH ENVIRONMENT

.TP
.B SANE_CONFIG_DIR
This environment variable specifies the list of directories that may
contain the configuration file.  Under UNIX, the directories are
separated by a colon (`:'), under OS/2, they are separated by a
semi-colon (`;').  If this variable is not set, the configuration file
is searched in two default directories: first, the current working
directory (".") and then in @CONFIGDIR@.  If the value of the
environment variable ends with the directory separator character, then
the default directories are searched after the explicitly specified
directories.  For example, setting
.B SANE_CONFIG_DIR
to "/tmp/config:" would result in directories "tmp/config", ".", and
"@CONFIGDIR@" being searched (in this order).
.TP

.SH "SEE ALSO"
sane(7), sane\-usb(5)
.br
http://hp44x0backend.sourceforge.net
.SH AUTHOR
Johannes Hub <johanneshub@t-online.det>

Return to bug 247605

Lines 69-75 Link Here

(-)sane-backends-1.0.19/backend/Makefile.in (-3 / +6 lines)
69		69
70	@SET_MAKE@	70	@SET_MAKE@
71		71
72	PRELOADABLE_BACKENDS = @BACKENDS@	72	PRELOADABLE_BACKENDS = hp_rts88xx @BACKENDS@
73		73
74	ALL_BACKENDS = $(PRELOADABLE_BACKENDS) dll	74	ALL_BACKENDS = $(PRELOADABLE_BACKENDS) dll
75		75
Lines 87-93 Link Here
87		87
88	LIBOBJS = $(addprefix ../lib/,$(addsuffix .lo,$(LIBLIB_FUNCS)))	88	LIBOBJS = $(addprefix ../lib/,$(addsuffix .lo,$(LIBLIB_FUNCS)))
89		89
90	DISTFILES = Makefile.in saned.conf.in sane_strstatus.c stubs.c \	90	DISTFILES = hp_rts88xx.c hp_rts88xx.h Makefile.in saned.conf.in sane_strstatus.c stubs.c \
91	abaton.c abaton.conf.in abaton.h \	91	abaton.c abaton.conf.in abaton.h \
92	agfafocus.c agfafocus.conf.in agfafocus.h \	92	agfafocus.c agfafocus.conf.in agfafocus.h \
93	apple.c apple.conf.in apple.h \	93	apple.c apple.conf.in apple.h \
Lines 359-365 Link Here
359		359
360	libsane-abaton.la: ../sanei/sanei_config2.lo	360	libsane-abaton.la: ../sanei/sanei_config2.lo
361	libsane-abaton.la: ../sanei/sanei_constrain_value.lo	361	libsane-abaton.la: ../sanei/sanei_constrain_value.lo
362	libsane-abaton.la: ../sanei/sanei_scsi.lo	362	libsane-abaton.la: ../sanei/sanei_scsi.lo
		363	libsane-hp_rts88xx.la: ../sanei/sanei_config2.lo
		364	libsane-hp_rts88xx.la: ../sanei/sanei_constrain_value.lo
		365	libsane-hp_rts88xx.la: ../sanei/sanei_usb.lo
363	libsane-agfafocus.la: ../sanei/sanei_config2.lo	366	libsane-agfafocus.la: ../sanei/sanei_config2.lo
364	libsane-agfafocus.la: ../sanei/sanei_constrain_value.lo	367	libsane-agfafocus.la: ../sanei/sanei_constrain_value.lo
365	libsane-agfafocus.la: ../sanei/sanei_scsi.lo	368	libsane-agfafocus.la: ../sanei/sanei_scsi.lo

Line 0 Link Here

(-)sane-backends-1.0.19/backend/hp_rts88xx.conf (+20 lines)
	1	# hp_rts88xx.conf: Configuration file for HP35x00C and HP44x0 USB scanners
	2	# Read man sane-hp_rts88xx.man for documentation
	3
	4	# ALL:
	5	# If autodetection doesn't work uncomment or add your device file
	6	#/dev/usbscanner
	7
	8	# HP44x0C option_CCD
	9	# CCD0 or CCD1 allowed
	10	# if you receive a black image, change it to CCD1
	11	#option CCD0
	12
	13	# HP44x0C option_color
	14	# none or ENABLE_COLOR allowed
	15	# allow the color mode
	16	#option ENABLE_COLOR
	17
	18	# HP35x00C/HP44x0C enable all resolutions
	19	# !!!!! only for test and development !!!!!
	20	#option ENABLE_T_RES

Line 0 Link Here

(-)sane-backends-1.0.19/backend/hp_rts88xx.h (+242 lines)
		1	/* sane - Scanner Access Now Easy.
		2	Copyright (C) 2003 Johannes Hub (JohannesHub@t-online.de)
		3
		4	This file was initially copied from the hp3300 backend.
		5	This file is part of the SANE package.
		6
		7	This program is free software; you can redistribute it and/or
		8	modify it under the terms of the GNU General Public License
		9	as published by the Free Software Foundation; either version 2
		10	of the License, or (at your option) any later version.
		11
		12	This program is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	GNU General Public License for more details.
		16
		17	You should have received a copy of the GNU General Public License
		18	along with this program; if not, write to the Free Software
		19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
		20
		21	As a special exception, the authors of SANE give permission for
		22	additional uses of the libraries contained in this release of SANE.
		23
		24	The exception is that, if you link a SANE library with other files
		25	to produce an exutable, this does not by itself cause the
		26	resulting executable to be covered by the GNU General Public
		27	License. Your use of that executable is in no way restricted on
		28	account of linking the SANE library code into it.
		29
		30	This exception does not, however, invalidate any other reasons why
		31	the executable file might be covered by the GNU General Public
		32	License.
		33
		34	If you submit changes to SANE to the maintainers to be included in
		35	a subsequent release, you agree by submitting the changes that
		36	those changes may be distributed with this exception intact.
		37
		38	If you write modifications of your own for SANE, it is your choice
		39	whether to permit this exception to apply to your modifications.
		40	If you do not wish that, delete this exception notice.
		41	*/
		42
		43	/*
		44	Concept for a backend for scanners based on the RTS88xx chipset,
		45	such as HP4400C, HP4470C, HP3500C, 3530C, and HP ScanJet 3570C.
		46	Parts of this source were inspired by other backends.
		47
		48	History:
		49
		50	Version 0.18 21.11.04 13.alpha,
		51	- source sorted,
		52	- now only SANEI_USB_SUPPORT for a better overview(xfermodules removed)
		53	- read and verify the MainBoardID
		54	Version 0.17p 02.11.04 12.alpha, source sorted, little fixes, SANEI_USB_SUPPORT implemented
		55	Version 0.17p 02.11.04 12.alpha, source sourted, little fixes, SANEI_USB_SUPPORT implemented
		56	Version 0.17b 30.03.04 10.alpha, little fixes and libusb implemented
		57	Version 0.17 09.03.04 9. alpha, HP3500 included
		58	Version 0.16 06.02.04 8. alpha, wait counting on LCD
		59	Version 0.15a 29.01.04 7. alpha, CCD switch moved to config file
		60	Version 0.15 11.01.04 6. alpha, a second CCD implemented
		61	Version 0.13a 21.11.04 4. alpha, an little fix included
		62	Version 0.12 22.10.03 third alpha, Backend name changed to HP_RTS88xx
		63	Version 0.11 30.08.03 second alpha
		64	Version 0.10 19.07.03 first alpha
65	*/
66
67	/*
68	Provides a simple interface to read and write data from the scanner,
69	without any knowledge whether it's a parallel or USB scanner
70
71	enable DEDUG output:
72	use a nomal shell (konsole) and type
73	export SANE_DEBUG_HP_RTS88XX=32
74	export XSANE_DEBUG=100
75	xsane
76	*/
77
78	#ifndef _HP_RTS88xx_H_
79	#define _HP_RTS88xx_H_
80
81
82	#define MM_TO_PIXEL(_mm_, _dpi_) ((_mm_) * (_dpi_) / 25.4)
83	#define PIXEL_TO_MM(_pixel_, _dpi_) ((_pixel_) * 25.4 / (_dpi_))
84	#define ENABLE(OPTION) s->opt[OPTION].cap &= ~SANE_CAP_INACTIVE
85	#define DISABLE(OPTION) s->opt[OPTION].cap \|= SANE_CAP_INACTIVE
86	#define IS_ACTIVE(OPTION) (((s->opt[OPTION].cap) & SANE_CAP_INACTIVE) == 0)
87	#define NUM_GAMMA_ENTRIES 65536
88
89	#define RTS8801_GREYSCALE 1
90	#define RTS8801_COLOUR 2
91	#define RTS8801_BW 0
92
93	typedef enum
94	{
95	BLACK_WHITE = 0,
96	GRAY, /1/
97	COLOR /2/
98	}
99	BACKEND_MODE;
100
101	/* options enumerator */
102	typedef enum {
103	optCount = 0,
104
105	optGroupGeometry,
106	optTLX, optTLY, optBRX, optBRY,
107	optDPI,
108	optGroupImage,
109	optGammaTableRed, /* Gamma Tables */
110	optGammaTableGreen,
111	optGammaTableBlue,
112	optGroupMisc,
113	OPT_MODE,
114	optXPDA,
115	optCCD,
116	optBrightness,
117	optGainR,
118	optGainG,
119	optGainB,
120	optLast
121	} EOptionIndex;
122
123
124	typedef union {
125	SANE_Word w;
126	SANE_Word wa; / word array */
127	SANE_String s;
128	} TOptionValue;
129
130
131	typedef struct {
132	SANE_Int iDpi; /* horizontal resolution */
133	SANE_Int iLpi; /* vertical resolution */
134	SANE_Int iY; /* iTop in HW coordinates */
135	SANE_Int iX; /* iLeft in HW coordinates */
136	SANE_Int iWidth; /* pixels per line */
137	SANE_Int iLenght; /* iHeight pixel lines */
138	SANE_Int iSkipLines; /* Steps to pos. for scann */
139	SANE_Int iLinesLeft; /* Lines witch left over to scan */
140	SANE_Int fCalib; /* if TRUE, disable backtracking? */
141	SANE_Int brightness;
142	SANE_Int mode; /* B/W = 0; grayscale = 1 color = 2 */
143	SANE_Int optXPA; /* 0=normal; 1 = XPA */
144	SANE_Int oCCD_Type; /* 0/1 */
145	SANE_Int GainR;
146	SANE_Int GainG;
147	SANE_Int GainB;
148	#ifdef DEBUG_FILE
149	FILE FD_r; / rgb test pnm file*/
150	SANE_Int DebugOpen;
151	SANE_Int DebugSeek0;
152	#endif
153	} TScanParams;
154
155
156	typedef struct {
157	/* transfer buffer */
158	SANE_Byte *pabXferBuf;
159	SANE_Int iCurLine, iBytesPerLine, iLinesPerXferBuf;
160	SANE_Int iLastLine;
161	SANE_Int iScanned; /* Lines witch have scanned */
162	SANE_Int iLinesLeft; /* Lines witch left over to scan */
163	/* circular buffer */
164	SANE_Byte *pabCircBuf;
165	SANE_Int iLinesPerCircBuf;
166	SANE_Int iLinesInCircBuf;
167	SANE_Int iMisAlignment;
168	SANE_Int iRedLine, iGrnLine, iBluLine;
169	/* current line buffer */
170	SANE_Byte *pabLineBuf;
171	SANE_Int iBytesLeft;
172
173	SANE_Int iZeroLines;
174	} TDataPipe;
175
176
177	typedef struct {
178	/* EScannerModel ScannerModel;*/
179	SANE_Int ScannerModel;
180	SANE_Int iXferHandle; /* handle used for data transfer to HW */
181	SANE_Int iTopLeftX; /* in mm */
182	SANE_Int iTopLeftY; /* in mm */
183	SANE_Int iMainBoardID; /* */
184	SANE_Bool iReversedHead; /* Head is reversed */
185	SANE_Bool lamp_warm; /* TRUE = the lamp is warm */
186	SANE_Byte regs[0xff];
187	} THWParams;
188
189
190	typedef struct {
191	SANE_Option_Descriptor aOptions[optLast];
192	TOptionValue aValues[optLast];
193
194	TScanParams ScanParams;
195	THWParams HWParams;
196	TDataPipe DataPipe;
197
198	SANE_Int aGammaTableR; / a 16-to-16 bit color lookup table */
199	SANE_Int aGammaTableG; / a 16-to-16 bit color lookup table */
200	SANE_Int aGammaTableB; / a 16-to-16 bit color lookup table */
201
202	SANE_Bool fScanning; /* TRUE if actively scanning */
203	SANE_Bool fCanceled;
204	} TScanner;
205
206
207	/* option constraints */
208	static SANE_Bool OPT_CCD = SANE_TRUE;
209	static SANE_Bool OPT_COLOR = SANE_FALSE;
210	static SANE_Bool OPT_T_RES = SANE_FALSE;
211	static const SANE_Range rangeGammaTable = {0,65535,1};
212	static const SANE_Int Hp44x0c_setResolutions[] = {1,300};
213	static const SANE_Int Hp44x0c_setResolutions_t[] = {2,300,600};
214	static const SANE_Int Hp35x0c_setResolutions[] = {1,150};
215	static const SANE_Int Hp35x0c_setResolutions_t[] = {3,150,300,600};
216
217	#ifndef WITH_TSTBACKEND
218	static const SANE_Range rangeXmm = {0, 220, 1}; /* max. mm */
219	static const SANE_Range rangeYmm = {0, 295, 1}; /* max. mm */
220	#endif
221	#ifdef WITH_TSTBACKEND
222	static const SANE_Range rangeXmm = {0, 70, 1}; /* max. mm */
223	static const SANE_Range rangeYmm = {0, 70, 1}; /* max. mm */
224	#endif
225	static const SANE_Range rangeBrightness = {0, 20, 1};
226	/static const SANE_Range rangeBrightness = {0, 0x40, 1};/
227	#if 0
228	static const SANE_Range rangeLampBrightness = {0xa1, 0xaf, 1};
229	#endif
230
231	static SANE_String_Const mode_list[5];
232	static SANE_String_Const scan_option_list[3];
233	static SANE_String_Const ccd_list[3];
234
235	/* Device filename for USB access */
236	SANE_Char * usb_devfile = "/dev/usb/scanner0";
237
238	SANE_Status _Init_Interface(THWParams pHWParams, TScanParams pParams);
239	void _Close_Interface(THWParams *pHWParams);
240	SANE_Bool _InitScan (TScanParams pParams,THWParams pHWParams, TDataPipe *pDataPipe);
241	SANE_Bool _FinishScan (SANE_Handle h);
242	#endif

Line 0 Link Here

(-)sane-backends-1.0.19/backend/hp_rts_35x0c.h (+445 lines)
		1	/* sane - Scanner Access Now Easy.
		2	Copyright (C) 2003 Johannes Hub (JohannesHub@t-online.de)
		3
		4	This file was initially copied from the hp3300 backend.
		5	This file is part of the SANE package.
		6
		7	This program is free software; you can redistribute it and/or
		8	modify it under the terms of the GNU General Public License
		9	as published by the Free Software Foundation; either version 2
		10	of the License, or (at your option) any later version.
		11
		12	This program is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	GNU General Public License for more details.
		16
		17	You should have received a copy of the GNU General Public License
		18	along with this program; if not, write to the Free Software
		19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
		20
		21	As a special exception, the authors of SANE give permission for
		22	additional uses of the libraries contained in this release of SANE.
		23
		24	The exception is that, if you link a SANE library with other files
		25	to produce an exutable, this does not by itself cause the
		26	resulting executable to be covered by the GNU General Public
		27	License. Your use of that executable is in no way restricted on
		28	account of linking the SANE library code into it.
		29
		30	This exception does not, however, invalidate any other reasons why
		31	the executable file might be covered by the GNU General Public
		32	License.
		33
		34	If you submit changes to SANE to the maintainers to be included in
		35	a subsequent release, you agree by submitting the changes that
		36	those changes may be distributed with this exception intact.
		37
		38	If you write modifications of your own for SANE, it is your choice
		39	whether to permit this exception to apply to your modifications.
		40	If you do not wish that, delete this exception notice.
		41	*/
		42
		43	/*
		44	Concept for a backend for scanners based on the RTS88xx chipset,
		45	such as HP3500C, 3530C, and HP ScanJet 3570C.
		46	Parts of this source were inspired by other backends.
		47
		48	History:
		49
		50	Version 0.18 21.11.04 13.alpha,
		51	- source sorted,
		52	- now only SANEI_USB_SUPPORT for a better overview(xfermodules removed)
		53	- read and verify the MainBoardID
		54	Version 0.17p 02.11.04 12.alpha, source sorted, little fixes, SANEI_USB_SUPPORT implemented
		55	Version 0.17p 02.11.04 12.alpha, source sourted, little fixes, SANEI_USB_SUPPORT implemented
		56	Version 0.17b 30.03.04 10.alpha, little fixes and libusb implemented
		57	Version 0.17 09.03.04 9. alpha, HP3500 included
		58	Version 0.16 06.02.04 8. alpha, wait counting on LCD
		59	Version 0.15a 29.01.04 7. alpha, CCD switch moved to config file
		60	Version 0.15 11.01.04 6. alpha, a second CCD implemented
		61	Version 0.13a 21.11.04 4. alpha, an little fix included
		62	Version 0.12 22.10.03 third alpha, Backend name changed to HP_RTS88xx
		63	Version 0.11 30.08.03 second alpha
		64	Version 0.10 19.07.03 first alpha
65	*/
66
67	/*
68	Core HP35x0c functions.
69	*/
70
71
72	#ifndef _HP_RTS_HP35x0C_H_
73	#define _HP_RTS_HP35x0C_H_
74
75	#include <unistd.h>
76
77	SANE_Byte Hp35x0c_initial_regs[] =
78	{
79	0xf5,0x41,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x00,
80	0xe1,0xfc,0xff,0xff,0x00,0x00,0x00,0xfc,0x00,0x00,0x00,0x00,0x00,0x02,0x00,0x00,
81	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x01,0x06,0x19,
82	0xd0,0x7a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa0,0x37,0xff,0x0f,0x00,0x00,
83	0x80,0x00,0x00,0x00,0x8c,0x76,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
84	0x20,0xbc,0x03,0x00,0x00,0x00,0x00,0x00,0x1d,0x1f,0x00,0x1f,0x00,0x00,0x00,0x00,
85	0x5e,0xea,0x5f,0xea,0x00,0x80,0x64,0x00,0x00,0x00,0x00,0x00,0x84,0x04,0x00,0x00,
86	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,
87	0x0f,0x02,0x4b,0x02,0x00,0xec,0x19,0xd8,0x2d,0x87,0x02,0xff,0x3f,0x78,0x60,0x00,
88	0x1c,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
89	0x00,0x00,0x00,0x0c,0x27,0x64,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
90	0x12,0x08,0x06,0x04,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
91	0x00,0x00,0x80,0x00,0x10,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
92	0xff,0xbf,0xff,0xff,0x00,0x00,0xff,0xff,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
93	0x00,0x00,0x0f,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
94	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00
95	};
96
97	SANE_Byte Hp35x0c_rewind_regs[] =
98	{
99	0xe5,0x41,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x70,0x00,0x00,0x00,0x00,
100	0x01,0x00,0x01,0x00,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x20,0x00,0x00,
101	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xeb,0xed,0xe0,0x01,0x00,0x20,0x86,0x0b,
102	0x02,0xa6,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xa6,0xff,0x8f,0x00,0x00,
103	0x20,0x00,0x00,0x00,0x8c,0x76,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
104	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x1f,0x10,0x00,0x00,0x00,0x00,0x00,
105	0x00,0x00,0x00,0x00,0x00,0x80,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
106	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x40,0x00,0x00,0x00,0x00,0x00,0x00,
107	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x80,0x64,0x00,
108	0x00,0x00,0x00,0x02,0x0e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
109	0x00,0x00,0x01,0x0f,0x18,0x31,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
110	0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
111	0x00,0x00,0x80,0x00,0x10,0x0a,0x00,0x00,0x00,0x3a,0x0a,0x00,0x00,0x00,0x00,0x00,
112	0x00,0x00,0x1f,0x4c,0x00,0x0c,0x1e,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
113	0x00,0x00,0xf8,0x2a,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
114	0xe0,0xff,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3c,0x00,0x30,0x00
115	};
116
117	struct Hp35x0c_tg_info__
118	{
119	SANE_Word tg_cph0p;
120	SANE_Word tg_crsp;
121	SANE_Word tg_cclpp;
122	SANE_Word tg_cdss1;
123	SANE_Word tg_cdsc1;
124	SANE_Word tg_cdss2;
125	SANE_Word tg_cdsc2;
126	} tg_info[] =
127	{
128	/* CPH0P CRSP CCLPP CDSS1 CDSC1 CDSS2 CDSC2 */
129	{ 0x01FFE0, 0x3c0000, 0x003000, 0xb, 0xd, 0x00, 0x01 }, /* NORMAL*/
130	{ 0x7ff800, 0xf00000, 0x01c000, 0xb, 0xc, 0x14, 0x15 } /* DOUBLE*/
131	};
132
133	struct Hp35x0c_resolution_parameters
134	{
135	SANE_Int resolution;
136	SANE_Byte reg_39_value;
137	SANE_Byte reg_c3_value;
138	SANE_Byte reg_c6_value;
139	SANE_Byte scan_frequency;
140	SANE_Byte cph0s;
141	SANE_Byte red_green_offset;
142	SANE_Byte green_blue_offset;
143	SANE_Byte intra_channel_offset;
144	SANE_Byte motor_movement_clock_multiplier;
145	SANE_Byte tg;
146	SANE_Word step_size;
147	};
148
149	static struct Hp35x0c_resolution_parameters Hp35x0c_resparms[] =
150	{
151	/* My values - all work */
152	/res.,39, c3, c6, freq.chp,gre blu itr mm tg steps. /
153	{ 1200, 3, 6, 4, 2, 1, 22, 22, 4, 2, 0, 0x157b },
154	{ 600, 3, 3, 1, 1, 0, 9, 10, 0, 2, 0, 0x157b },
155	{ 400, 1, 1, 1, 1, 1, 6, 6, 1, 2, 0, 0x157b },
156	{ 300, 3, 3, 3, 1, 0, 5, 4, 0, 2, 1, 0x157b },
157	{ 200, 3, 1, 1, 1, 0, 3, 3, 0, 2, 1, 0x157b },
158	{ 150, 3, 3, 3, 2, 0, 2, 2, 0, 2, 1, 0x157b },
159	{ 100, 3, 1, 3, 1, 0, 1, 1, 0, 2, 1, 0x157b },
160	{ 75, 3, 3, 3, 4, 0, 1, 1, 0, 2, 1, 0x157b },
161	{ 50, 3, 1, 3, 2, 0, 0, 0, 0, 2, 1, 0x157b },
162	{ 25, 3, 1, 3, 4, 0, 0, 0, 0, 2, 1, 0x157b },
163	{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0x157b }
164	};
165
166	#define REG_DESTINATION_POSITION 0x60
167
168	#define RTCMD_GETREG 0x80
169	#define RTCMD_READSRAM 0x81
170
171	#define RTCMD_SETREG 0x88
172	#define RTCMD_WRITESRAM 0x89
173
174	#define RTCMD_NVRAMCONTROL 0x8a
175
176	#define RTCMD_BYTESAVAIL 0x90
177	#define RTCMD_READBYTES 0x91
178
179	#define RT_CHANNEL_ALL 0
180	#define RT_CHANNEL_RED 1
181	#define RT_CHANNEL_GREEN 2
182	#define RT_CHANNEL_BLUE 3
183
184	#if 0
185	static SANE_Int
186	Hp35x0c_set_value_msbfirst( SANE_Byte *regs,
187	SANE_Int firstreg,
188	SANE_Int totalregs,
189	SANE_Word value);
190	#endif
191	SANE_Int
192	Hp35x0c_queue_read_register( SANE_Int iHandle, SANE_Byte reg, SANE_Int bytes, SANE_Byte *data);
193
194	SANE_Int
195	Hp35x0c_read_register_immediate( SANE_Int iHandle, SANE_Int reg, SANE_Int bytes, SANE_Byte *data);
196
197	SANE_Int
198	Hp35x0c_set_register_immediate( SANE_Int iHandle, SANE_Int reg, SANE_Int bytes, SANE_Byte *data);
199
200	SANE_Int
201	Hp35x0c_send_command_immediate( SANE_Int iHandle, SANE_Int command,
202	SANE_Byte reg,
203	SANE_Int count,
204	SANE_Int bytes,
205	SANE_Byte *data,
206	SANE_Int readbytes,
207	SANE_Byte *readdata);
208
209	SANE_Int
210	Hp35x0c_write_sram( SANE_Int iHandle, SANE_Word bytes, SANE_Byte *data);
211
212	SANE_Int
213	Hp35x0c_read_sram( SANE_Int iHandle, SANE_Int bytes, SANE_Byte *data);
214
215	SANE_Int
216	Hp35x0c_set_sram_page( SANE_Int iHandle, SANE_Byte page);
217
218	SANE_Int
219	Hp35x0c_detect_sram( SANE_Int iHandle, SANE_Word totalbytes, SANE_Byte r93setting);
220
221	SANE_Int
222	Hp35x0c_is_rewound( SANE_Int iHandle );
223
224	SANE_Int
225	Hp35x0c_set_direction_forwards(SANE_Byte *regs);
226
227	SANE_Int
228	Hp35x0c_set_direction_rewind(SANE_Byte *regs);
229
230	SANE_Int
231	Hp35x0c_set_stop_when_rewound( SANE_Byte *regs, SANE_Int stop);
232
233	SANE_Int
234	Hp35x0c_set_distances( SANE_Int iHandle,SANE_Int location1,
235	SANE_Int location2);
236
237	SANE_Int
238	Hp35x0c_set_powersave_mode(SANE_Int iHandle,SANE_Int enable);
239
240	SANE_Int
241	Hp35x0c_lamp_ready( SANE_Int iHandle );
242
243	SANE_Int
244	Hp35x0c_turn_off_lamp( SANE_Int iHandle );
245
246	SANE_Int
247	Hp35x0c_turn_on_lamp( SANE_Int iHandle );
248	#if 0
249	static SANE_Int
250	Hp35x0c_set_value_msbfirst( SANE_Byte *regs,SANE_Int firstreg,
251	SANE_Int totalregs,SANE_Word value);
252	#endif
253	SANE_Int
254	Hp35x0c_set_ccd_shift_clock_multiplier( SANE_Byte *regs,
255	SANE_Word value);
256
257	SANE_Int
258	Hp35x0c_set_ccd_sample_clock_multiplier( SANE_Byte *regs,
259	SANE_Word value);
260
261	SANE_Int
262	Hp35x0c_set_ccd_clock_reset_interval( SANE_Byte *regs,
263	SANE_Word value);
264
265	SANE_Int
266	Hp35x0c_set_ccd_clamp_clock_multiplier( SANE_Byte *regs,
267	SANE_Word value);
268
269	SANE_Int
270	Hp35x0c_set_movement_pattern( SANE_Byte *regs,
271	SANE_Word value);
272
273	SANE_Int
274	Hp35x0c_set_motor_movement_clock_multiplier( SANE_Byte *regs,
275	SANE_Word value);
276
277	SANE_Int
278	Hp35x0c_set_motor_type( SANE_Byte *regs,
279	SANE_Word value);
280
281	SANE_Int
282	Hp35x0c_set_basic_calibration( SANE_Byte *regs,
283	SANE_Int redoffset1,
284	SANE_Int redoffset2,
285	SANE_Int redgain,
286	SANE_Int greenoffset1,
287	SANE_Int greenoffset2,
288	SANE_Int greengain,
289	SANE_Int blueoffset1,
290	SANE_Int blueoffset2,
291	SANE_Int bluegain);
292
293	SANE_Int
294	Hp35x0c_set_calibration_addresses( SANE_Byte *regs,
295	SANE_Word redaddr,
296	SANE_Word blueaddr,
297	SANE_Word greenaddr);
298
299	SANE_Int
300	Hp35x0c_set_lamp_duty_cycle( SANE_Byte *regs,
301	SANE_Int enable,
302	SANE_Int frequency,
303	SANE_Int offduty);
304
305	SANE_Int
306	Hp35x0c_set_data_feed_on( SANE_Byte *regs);
307
308	SANE_Int
309	Hp35x0c_set_data_feed_off( SANE_Byte *regs);
310
311	SANE_Int
312	Hp35x0c_enable_ccd( SANE_Byte *regs,
313	SANE_Int enable);
314
315	SANE_Int
316	Hp35x0c_set_cdss( SANE_Byte *regs,
317	SANE_Int val1,
318	SANE_Int val2);
319
320	SANE_Int
321	Hp35x0c_set_cdsc( SANE_Byte *regs,
322	SANE_Int val1,
323	SANE_Int val2);
324
325	SANE_Int
326	Hp35x0c_update_after_setting_cdss2( SANE_Byte *regs);
327
328	SANE_Int
329	Hp35x0c_set_cph0s( SANE_Byte *regs,
330	SANE_Int on);
331
332	SANE_Int
333	Hp35x0c_set_cvtr_lm( SANE_Byte *regs,
334	SANE_Int val1,
335	SANE_Int val2,
336	SANE_Int val3);
337
338	SANE_Int
339	Hp35x0c_set_cvtr_mpt( SANE_Byte *regs,
340	SANE_Int val1,
341	SANE_Int val2,
342	SANE_Int val3);
343
344	SANE_Int
345	Hp35x0c_set_cvtr_wparams( SANE_Byte *regs,
346	SANE_Word fpw,
347	SANE_Word bpw,
348	SANE_Word w);
349
350	SANE_Int
351	Hp35x0c_enable_movement( SANE_Byte *regs,
352	SANE_Int enable);
353
354	SANE_Int
355	Hp35x0c_set_scan_frequency( SANE_Byte *regs,
356	SANE_Int frequency);
357
358	SANE_Int
359	Hp35x0c_set_merge_channels( SANE_Byte *regs,
360	SANE_Int on);
361
362	SANE_Int
363	Hp35x0c_set_channel( SANE_Byte *regs,
364	SANE_Int channel);
365
366	SANE_Int
367	Hp35x0c_set_single_channel_scanning( SANE_Byte *regs,
368	SANE_Int on);
369
370	SANE_Int
371	Hp35x0c_set_colour_mode( SANE_Byte *regs,
372	SANE_Int on);
373
374	SANE_Int
375	Hp35x0c_set_horizontal_resolution( SANE_Byte *regs,
376	SANE_Int resolution);
377
378	SANE_Int
379	Hp35x0c_set_last_sram_page( SANE_Byte *regs,
380	SANE_Int pagenum);
381
382	SANE_Int
383	Hp35x0c_set_step_size( SANE_Byte *regs,
384	SANE_Int stepsize);
385
386	SANE_Int
387	Hp35x0c_set_all_registers( SANE_Int iHandle, void const *regs_);
388
389	SANE_Int
390	Hp35x0c_adjust_misc_registers(SANE_Byte *regs);
391
392	static SANE_Int
393	Hp35x0c_nvram_enable_controller(SANE_Int iHandle,SANE_Int enable);
394
395	static SANE_Int
396	Hp35x0c_nvram_init_command(SANE_Int iHandle);
397
398	static SANE_Int
399	Hp35x0c_nvram_init_stdvars(SANE_Int iHandle,SANE_Int block,
400	SANE_Int *addrbits,
401	SANE_Byte *basereg);
402
403	static void
404	Hp35x0c_nvram_set_half_bit( SANE_Byte *buffer,
405	SANE_Int value,
406	SANE_Byte stdbits,
407	SANE_Int whichhalf);
408
409	static void
410	Hp35x0c_nvram_set_command_bit(SANE_Byte *buffer,
411	SANE_Int value,
412	SANE_Byte stdbits);
413
414	void
415	Hp35x0c_nvram_set_addressing_bits( SANE_Byte *buffer,
416	SANE_Int location,
417	SANE_Int addressingbits,
418	SANE_Byte stdbits);
419
420	SANE_Int
421	Hp35x0c_nvram_enable_write(SANE_Int iHandle,SANE_Int addressingbits,
422	SANE_Int enable,
423	SANE_Byte stdbits);
424
425	SANE_Int
426	Hp35x0c_nvram_write(SANE_Int iHandle,SANE_Int block,
427	SANE_Int location,
428	SANE_Char const *data,
429	SANE_Int bytes);
430
431	SANE_Int
432	Hp35x0c_nvram_read(SANE_Int iHandle,SANE_Int block,
433	SANE_Int location,
434	SANE_Byte *data,
435	SANE_Int bytes);
436
437	SANE_Int Hp35x0c_rewind(THWParams *pHWParams);
438
439	SANE_Bool Hp35x0c_init_scan(THWParams pHWParams, TScanParams pParams,
440	TDataPipe *pDataPipe);
441
442	SANE_Bool Hp35x0c_init_power_on(THWParams *pHWParams);
443
444	#endif /* NO _HP_RTS_HP35x0C_H_ */
445

Line 0 Link Here

(-)sane-backends-1.0.19/backend/hp_rts_xfer.h (+214 lines)
		1	/* sane - Scanner Access Now Easy.
		2	Copyright (C) 2003 Johannes Hub (JohannesHub@t-online.de)
		3
		4	This file was initially copied from the hp3300 backend.
		5	This file is part of the SANE package.
		6
		7	This program is free software; you can redistribute it and/or
		8	modify it under the terms of the GNU General Public License
		9	as published by the Free Software Foundation; either version 2
		10	of the License, or (at your option) any later version.
		11
		12	This program is distributed in the hope that it will be useful,
		13	but WITHOUT ANY WARRANTY; without even the implied warranty of
		14	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		15	GNU General Public License for more details.
		16
		17	You should have received a copy of the GNU General Public License
		18	along with this program; if not, write to the Free Software
		19	Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
		20
		21	As a special exception, the authors of SANE give permission for
		22	additional uses of the libraries contained in this release of SANE.
		23
		24	The exception is that, if you link a SANE library with other files
		25	to produce an exutable, this does not by itself cause the
		26	resulting executable to be covered by the GNU General Public
		27	License. Your use of that executable is in no way restricted on
		28	account of linking the SANE library code into it.
		29
		30	This exception does not, however, invalidate any other reasons why
		31	the executable file might be covered by the GNU General Public
		32	License.
		33
		34	If you submit changes to SANE to the maintainers to be included in
		35	a subsequent release, you agree by submitting the changes that
		36	those changes may be distributed with this exception intact.
		37
		38	If you write modifications of your own for SANE, it is your choice
		39	whether to permit this exception to apply to your modifications.
		40	If you do not wish that, delete this exception notice.
		41	*/
		42
		43	/*
		44	Concept for a backend for scanners based on the RTS88xx chipset,
		45	such as HP4400C, HP4470C.
		46	Parts of this source were inspired by other backends.
		47
		48	History:
		49
		50	Version 0.18 21.11.04 13.alpha,
		51	- source sorted,
		52	- now only SANEI_USB_SUPPORT for a better overview(xfermodules removed)
		53	- read and verify the MainBoardID
		54	Version 0.17p 02.11.04 12.alpha, source sorted, little fixes, SANEI_USB_SUPPORT implemented
		55	Version 0.17p 02.11.04 12.alpha, source sourted, little fixes, SANEI_USB_SUPPORT implemented
		56	Version 0.17b 30.03.04 10.alpha, little fixes and libusb implemented
		57	Version 0.17 09.03.04 9. alpha, HP3500 included
		58	Version 0.16 06.02.04 8. alpha, wait counting on LCD
		59	Version 0.15a 29.01.04 7. alpha, CCD switch moved to config file
		60	Version 0.15 11.01.04 6. alpha, a second CCD implemented
		61	Version 0.13a 21.11.04 4. alpha, an little fix included
		62	Version 0.12 22.10.03 third alpha, Backend name changed to HP_RTS88xx
		63	Version 0.11 30.08.03 second alpha
		64	Version 0.10 19.07.03 first alpha
65	*/
66
67	/*
68	Provides a simple interface to read and write data from the scanner,
69	without any knowledge whether it's a parallel or USB scanner
70	*/
71
72	#ifndef _HP_RTS_XFER_H_
73	#define _HP_RTS_XFER_H_
74
75	#include <stdio.h> /* for FILE * */
76
77	#ifdef STANDALONE
78
79	#include <ctype.h>
80	#include "../include/sane/config.h"
81	#include "../include/sane/sane.h"
82
83	#include "hp_rts88xx.h"
84	#undef DBG
85	#undef DBG_MSG
86	#undef DBG_USB
87	#undef DBG_OPT
88	#undef DBG_SCAN
89	#undef DBG_ASSERT
90	#undef DBG_ERR
91
92	#define DBG fprintf
93	#define DBG_MSG stdout
94	#define DBG_USB stdout
95	#define DBG_OPT stdout
96	#define DBG_SCAN stdout
97	#define DBG_ASSERT stdout
98	#define DBG_ERR stdout
99
100	#endif
101
102
103	#define MAINBOARD_ID 0xb1
104	#define REG_MOVE_CONTROL_TEST 0xb3
105
106	#define MAX_READ_WRITE 0x3fff /* 4096 */
107	#define TIMEOUT 10000
108	#define XFER_BUF_SIZE 0xFF00
109
110	#ifndef MIN
111	#define MIN(a,b) (((a) < (b)) ? (a) : (b))
112	#endif
113	#ifndef MAX
114	#define MAX(a,b) (((a) > (b)) ? (a) : (b))
115	#endif
116
117
118	typedef enum {
119	eUnknownModel = 0,
120	eHp3500c,
121	eHp3530c,
122	eHp3570c,
123	eHp4400c,
124	eHp4470c,
125	eVi8920,
126	eVi8900,
127	eVi8700,
128	eVi5800,
129	eVi5300,
130	eVi4800,
131	eVa3000,
132	eMi3000,
133	ePlS6,
134	ePrlS6
135	} EScannerModel;
136
137
138	typedef struct {
139	SANE_Char *pszVendor;
140	SANE_Char *pszName;
141	SANE_Int iVendor;
142	SANE_Int iProduct;
143	EScannerModel eModel;
144	} TScannerModel;
145
146
147	/* linked list of SANE_Device structures */
148	typedef struct TDevListEntry
149	{
150	struct TDevListEntry *pNext;
151	SANE_Device dev;
152	}
153	TDevListEntry;
154
155
156	typedef SANE_Int (TFnReportDevice)(TScannerModel pModel, SANE_Char pszDeviceName);
157
158	/* USB device file name */
159	extern SANE_Char * usb_devfile;
160
161	/* list of supported models, the actual list is in hp_rts_xfer.c */
162	extern TScannerModel ScannerModels[];
163
164	/* The number returned by Hp_rts_XferInit is a handle. This handle needs to
165	be passed to all other transfer functions.
166	Internally it is a pointer to structure containg function pointers
167	*/
168	void Hp_rts_DumpHex(SANE_Byte *pabData, SANE_Int iLen, SANE_Int iWidth, SANE_Int withLf);
169	void Hp_rts_DumpBits(SANE_Byte reg, SANE_Byte pabData);
170
171	SANE_Int Hp_rts_XferInit(/EScannerModel peModel*/void);
172	/SANE_Int Hp_rts_XferInit (EScannerModel peModel);*/
173	SANE_Int Hp_rts_XferExit (SANE_Int iXferHandle);
174	SANE_Int Hp_rts_RegWrite (SANE_Int iXferHandle, SANE_Byte reg, SANE_Byte bData);
175	SANE_Int Hp_rts_RegRead (SANE_Int iXferHandle, SANE_Byte reg, SANE_Byte *pbData);
176	SANE_Int Hp_rts_BulkWrite (SANE_Int iXferHandle, SANE_Byte reg, SANE_Byte *pabBuf, SANE_Int iSize, SANE_Int wHeader);
177	SANE_Int Hp_rts_BulkRead (SANE_Int iXferHandle, SANE_Byte reg, SANE_Byte *pabBuf, SANE_Int iSize, SANE_Int wWrite);
178	SANE_Int Hp_rts_BulkReadall (SANE_Int iHandle, SANE_Byte *pabData);
179	SANE_Bool Hp_rts_MatchUsbDevice (SANE_Int iVendor, SANE_Int iProduct, TScannerModel **ppeModel);
180	SANE_Bool Hp_rts_ProbeRegisters (THWParams *pHWParams);
181	SANE_Int Hp_rts_Set_double_reg (SANE_Int iHandle, SANE_Byte reg, SANE_Byte c1, SANE_Byte c2 );
182	SANE_Int Hp_rts_Read_double_reg (SANE_Int iHandle, SANE_Byte reg, SANE_Byte *pbData );
183	SANE_Int Hp_rts_data_ready (SANE_Int iHandle, SANE_Int *size);
184	SANE_Int Hp_rts_read_data (SANE_Int iHandle, SANE_Int size,SANE_Byte *data);
185	SANE_Int Hp_rts_set_value_lsbfirst( SANE_Byte *regs,SANE_Int firstreg,SANE_Int totalregs, SANE_Word value);
186
187	SANE_Bool Hp_rts_is_moving (SANE_Int iHandle);
188	SANE_Int Hp_rts_start_moving (SANE_Int iHandle);
189	SANE_Int Hp_rts_stop_moving (SANE_Int iHandle);
190	void Hp_rts_WriteGammaCalibTable (SANE_Int iHandle,
191	const SANE_Int pabGammaR, const SANE_Int pabGammaG,const SANE_Int *pabGammaB);
192	/void Hp_rts_SetDefaultGamma (SANE_Int iHandle);/
193	SANE_Bool Hp_rts_Check_Moving (SANE_Int iHandle);
194	SANE_Int Hp_rts_Read_Sram (SANE_Int iHandle, SANE_Byte *pabData,
195	SANE_Int iSize);
196	SANE_Int Hp_rts_set_noscan_distance(SANE_Byte *regs,SANE_Word value);
197	SANE_Int Hp_rts_set_total_distance(SANE_Byte *regs,SANE_Word value);
198	SANE_Int Hp_rts_set_scanline_end(SANE_Byte *regs,SANE_Word value);
199	SANE_Int Hp_rts_set_scanline_start(SANE_Byte *regs,SANE_Word value);
200
201	SANE_Status Hp_rts_CircBufferInit (SANE_Handle h, TDataPipe *p, SANE_Int iBytesPerLine,
202	SANE_Int iMisAlignment, SANE_Bool mode);
203
204	SANE_Bool Hp_rts_CircBufferGetLine (SANE_Handle h, TDataPipe p, SANE_Byte pabLine,
205	SANE_Bool mode);
206
207	void Hp_rts_CircBufferExit (SANE_Handle h);
208
209	SANE_Bool Hp_rts_XferBufferGetLine(SANE_Handle h, TDataPipe p, SANE_Byte pabLine);
210
211	void Hp_rts_XferBufferExit (SANE_Handle h);
212	SANE_Status Hp_rts_XferBufferInit (SANE_Handle h, TDataPipe *p);
213
214	#endif /* _HP_RTS_XFER_H_ */

Lines 39-45 Link Here

(-)sane-backends-1.0.19/doc/Makefile.in (-2 / +2 lines)
39	@SET_MAKE@	39	@SET_MAKE@
40		40
41	SECT1 = scanimage.1 sane-config.1 sane-find-scanner.1 gamma4scanimage.1	41	SECT1 = scanimage.1 sane-config.1 sane-find-scanner.1 gamma4scanimage.1
42	SECT5 = sane-abaton.5 sane-agfafocus.5 sane-apple.5 sane-as6e.5 sane-dll.5 \	42	SECT5 = sane-abaton.5 sane-agfafocus.5 sane-apple.5 sane-as6e.5 sane-dll.5 sane-hp_rts88xx.5 \
43	sane-dc25.5 sane-dmc.5 sane-epson.5 sane-hp.5 sane-gphoto2.5 \	43	sane-dc25.5 sane-dmc.5 sane-epson.5 sane-hp.5 sane-gphoto2.5 \
44	sane-leo.5 sane-lexmark.5 sane-matsushita.5 sane-microtek.5 \	44	sane-leo.5 sane-lexmark.5 sane-matsushita.5 sane-microtek.5 \
45	sane-microtek2.5 sane-mustek.5 sane-nec.5 sane-net.5 sane-pie.5 \	45	sane-microtek2.5 sane-mustek.5 sane-nec.5 sane-net.5 sane-pie.5 \
Lines 98-104 Link Here
98	sane-artec.man sane-as6e.man sane-avision.man sane-bh.man \	98	sane-artec.man sane-as6e.man sane-avision.man sane-bh.man \
99	sane-canon.man sane-canon630u.man sane-config.man sane-coolscan.man \	99	sane-canon.man sane-canon630u.man sane-config.man sane-coolscan.man \
100	sane-coolscan2.man sane-dc210.man sane-dc240.man \	100	sane-coolscan2.man sane-dc210.man sane-dc240.man \
101	sane-dc25.man sane-dll.man sane-dmc.man sane-epson.man \	101	sane-dc25.man sane-dll.man sane-hp_rts88xx.man sane-dmc.man sane-epson.man \
102	sane-find-scanner.man sane-fujitsu.man sane-gphoto2.man sane-hp.man \	102	sane-find-scanner.man sane-fujitsu.man sane-gphoto2.man sane-hp.man \
103	sane-logo.png sane-logo2.jpg sane-matsushita.man sane-microtek.man \	103	sane-logo.png sane-logo2.jpg sane-matsushita.man sane-microtek.man \
104	sane-leo.man sane-lexmark.man sane-microtek2.man \	104	sane-leo.man sane-lexmark.man sane-microtek2.man \

Line 0 Link Here

(-)sane-backends-1.0.19/doc/descriptions/hp_rts88xx.desc (+37 lines)
	1	;
	2	; SANE Backend specification file
	3	;
	4	:backend "hp_rts88xx" ; name of backend
	5	;:version "(0.18)" ; version of backend
	6	;:manpage "sane-hp_rts88xx" ; name of manpage (if it exists)
	7	:url "http://hp44x0backend.sourceforge.net" ; backend's web page
	8
	9	:devicetype :scanner ; start of a list of devices....
	10
	11	:mfg "Hewlett-Packard" ; name a manufacturer
	12	:url "http://www.hp.com/"
	13
	14	:model "HP4400C" ; name models for above-specified mfg.
	15	:interface "USB"
	16	:status :basic
	17	:comment "grayscale 300/600 DPI"
	18
	19	:model "HP4470C"
	20	:interface "USB"
	21	:status :basic
	22	:comment "grayscale 300/600 DPI, XPA/bed mode"
	23
	24	:model "HP3500C"
	25	:interface "USB"
	26	:status :basic
	27	:comment "not tested"
	28
	29	:model "HP3530C"
	30	:interface "USB"
	31	:status :basic
	32	:comment "not tested"
	33
	34	:model "HP3570C"
	35	:interface "USB"
	36	:status :basic
	37	:comment "not tested"

Line 0 Link Here

(-)sane-backends-1.0.19/doc/sane-hp_rts88xx.man (+108 lines)
		1	.\" $Id: sane-hp_rts88xx.man,v 1.2 2004/22/10 10:35:31 jh Exp $
		2	.TH sane-hp_rts88xx 5 "22 Oct 2004"
		3	.IX sane-hp_rts88xx
		4
		5	.SH NAME
		6	sane-hp_rts88xx - SANE backend for scanners based on the RTS8891 chipset.
		7
		8	.SH DESCRIPTION
		9	The
		10	.B sane-hp_rts88xx
		11	implements a SANE (Scanner Access Now Easy) backend that
		12	provides access to RTS8891 chipset based scanners. This backend will try to support
		13	the following models:
		14
		15	MANUFACTURER: MODEL: USB ID:
		16	.br
		17	--------------- -------------- ---------
		18	.br
		19	Hewlett-Packard Scanjet 4400c 03F0-0705
		20	.br
		21	Hewlett-Packard Scanjet 4470c 03F0-0805
		22	.br
		23	Hewlett-Packard Scanjet 3500C 03F0-2205
		24	.br
		25	Hewlett-Packard Scanjet 3530c 03F0-2005
		26	.br
		27	Hewlett-Packard Scanjet 3570c 03F0-2005
		28	.br
		29	.PP
		30	.br
		31
		32	.SH "DEVICE NAMES"
		33	This backend expects device names of the form:
		34	.PP
		35	.RS
		36	.I special
		37	.RE
		38	.PP
		39	Where
		40	.I special
		41	is a path-name for the special device that corresponds to a USB scanner.
		42	With GNU/Linux systems, such a device name could be
		43	.I /dev/usb/scanner0
		44	or
		45	.IR /dev/usbscanner1 ,
		46	for example.
		47
		48
		49	.SH CONFIGURATION
		50	The
		51	.I hp_rts88xx.conf
		52	file contains the device name that correspond to the hp44x0c
		53	scanner. Empty lines and lines starting with a hash mark (#) are
		54	ignored.
		55	.PP
		56	A sample configuration file is shown below:
		57	.PP
		58	.RS
		59	# Comment
		60	.br
		61	/dev/usbscanner
		62	# option_CCD
		63	# CCD0 or CCD1 allowed
		64	# if you receive a black image, change it to CCD1
65	option CCD0
66	.RE
67	.PP
68	The first line is ignored. The second line is the device filename to use
69	in order to access the hp44x0c Scanner. If no device is given, the
70	backend will use libUSB.
71
72	.SH FILES
73	.TP
74	.I @CONFIGDIR@/hp_rts88xx.conf
75	The backend configuration file (see also description of SANE_CONFIG_DIR below).
76
77	.TP
78	.I @LIBDIR@/libsane-hp_rts88xx.a
79	The static library implementing this backend.
80
81	.TP
82	.I @LIBDIR@/libsane-hp_rts88xx.so
83	The shared library implementing this backend (present on systems that
84	support dynamic loading).
85	.SH ENVIRONMENT
86
87	.TP
88	.B SANE_CONFIG_DIR
89	This environment variable specifies the list of directories that may
90	contain the configuration file. Under UNIX, the directories are
91	separated by a colon (`:'), under OS/2, they are separated by a
92	semi-colon (`;'). If this variable is not set, the configuration file
93	is searched in two default directories: first, the current working
94	directory (".") and then in @CONFIGDIR@. If the value of the
95	environment variable ends with the directory separator character, then
96	the default directories are searched after the explicitly specified
97	directories. For example, setting
98	.B SANE_CONFIG_DIR
99	to "/tmp/config:" would result in directories "tmp/config", ".", and
100	"@CONFIGDIR@" being searched (in this order).
101	.TP
102
103	.SH "SEE ALSO"
104	sane(7), sane\-usb(5)
105	.br
106	http://hp44x0backend.sourceforge.net
107	.SH AUTHOR
108	Johannes Hub <johanneshub@t-online.det>