Initial import of sane-backends version 1.0.24-1.2

1 files changed, 999 insertions, 0 deletions

diff --git a/backend/plustek-pp_io.c b/backend/plustek-pp_io.c
new file mode 100644
index 0000000..ba68599
--- /dev/null
+++ b/backend/plustek-pp_io.c
@@ -0,0 +1,999 @@
+/* @file plustekpp-io.c
+ * @brief as the name says, here we have all the I/O
+ *        functions according to the parallel port hardware
+ *
+ * based on sources acquired from Plustek Inc.
+ * Copyright (C) 1998 Plustek Inc.
+ * Copyright (C) 2000-2013 Gerhard Jaeger <gerhard@gjaeger.de>
+ *
+ * History:
+ * - 0.37 - initial version
+ *        - added Kevins' suggestions
+ * - 0.38 - added Asic 98003 stuff and ioP98ReadWriteTest()
+ *        - added IODataRegisterToDAC()
+ *        - replaced function IOSPPWrite by IOMoveDataToScanner
+ *        - modified ioP98OpenScanPath again and reuse V0.36 stuff again
+ *        - added IO functions
+ * - 0.39 - added IO functions
+ *        - added f97003 stuff from A3I code
+ * - 0.40 - no changes
+ * - 0.41 - no changes
+ * - 0.42 - changed include names
+ * - 0.43 - no changes
+ * - 0.44 - fix format string issues, as Long types default to int32_t
+ *          now
+ * .
+ * <hr>
+ * This file is part of the SANE package.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston,
+ * MA 02111-1307, USA.
+ *
+ * As a special exception, the authors of SANE give permission for
+ * additional uses of the libraries contained in this release of SANE.
+ *
+ * The exception is that, if you link a SANE library with other files
+ * to produce an executable, this does not by itself cause the
+ * resulting executable to be covered by the GNU General Public
+ * License.  Your use of that executable is in no way restricted on
+ * account of linking the SANE library code into it.
+ *
+ * This exception does not, however, invalidate any other reasons why
+ * the executable file might be covered by the GNU General Public
+ * License.
+ *
+ * If you submit changes to SANE to the maintainers to be included in
+ * a subsequent release, you agree by submitting the changes that
+ * those changes may be distributed with this exception intact.
+ *
+ * If you write modifications of your own for SANE, it is your choice
+ * whether to permit this exception to apply to your modifications.
+ * If you do not wish that, delete this exception notice.
+ * <hr>
+ */
+#include "plustek-pp_scan.h"
+
+/*************************** some prototypes *********************************/
+
+static Bool fnEPPRead  ( pScanData ps, pUChar pBuffer, ULong ulSize );
+static Bool fnSPPRead  ( pScanData ps, pUChar pBuffer, ULong ulSize );
+static Bool fnBiDirRead( pScanData ps, pUChar pBuffer, ULong ulSize );
+
+typedef struct {
+	pFnReadData func;
+	char       *name;
+} ioReadFuncDef;
+
+static ioReadFuncDef ioReadFunc[3] = {
+	{ fnEPPRead,   "fnEPPRead"   },
+	{ fnSPPRead,   "fnSPPRead"   },
+	{ fnBiDirRead, "fnBiDirRead" }
+};
+
+/*************************** some definitions ********************************/
+
+#define _MEMTEST_SIZE   1280
+
+/*************************** local functions *********************************/
+
+/** we provide some functions to read data from SPP port according to
+ * the speed we have detected (ReadWriteTest!!)
+ */
+static Byte ioDataFromSPPFast( pScanData ps )
+{
+	Byte bData, tmp;
+
+	/* notify asic we will read the high nibble data from status port */
+	if( _FALSE == ps->f97003 ) {
+		_OUTB_CTRL( ps, ps->CtrlReadHighNibble );
+		_DO_UDELAY( 1 );
+	}
+
+	/* read high nibble */
+    bData  = _INB_STATUS( ps );
+	bData &= 0xf0;
+
+    _OUTB_CTRL( ps, ps->CtrlReadLowNibble );
+	_DO_UDELAY( 1 );
+
+	/* read low nibble */
+	tmp = _INB_STATUS( ps );
+	
+	/* combine with low nibble */
+    bData |= (tmp >> 4);
+
+    _OUTB_CTRL( ps, _CTRL_GENSIGNAL );
+	_DO_UDELAY( 1 );
+
+    return bData;
+}
+
+static Byte ioDataFromSPPMiddle( pScanData ps )
+{
+	Byte bData, tmp;
+
+	/* notify asic we will read the high nibble data from status port */
+	if( _FALSE == ps->f97003 ) {
+		_OUTB_CTRL( ps, ps->CtrlReadHighNibble );
+		_DO_UDELAY( 1 );
+	}
+
+	/* read high nibble */
+	_INB_STATUS( ps );
+    bData  = _INB_STATUS( ps );
+	bData &= 0xf0;
+
+    _OUTB_CTRL( ps, ps->CtrlReadLowNibble );
+	_DO_UDELAY( 1 );
+
+	/* read low nibble */
+	_INB_STATUS( ps );
+	tmp = _INB_STATUS( ps );
+	
+	/* combine with low nibble */
+    bData |= (tmp >> 4);
+
+    _OUTB_CTRL( ps, _CTRL_GENSIGNAL );
+	_DO_UDELAY( 1 );
+
+    return bData;
+}
+
+static UChar ioDataFromSPPSlow( pScanData ps )
+{
+	Byte bData, tmp;
+
+	/* notify asic we will read the high nibble data from status port */
+	if( _FALSE == ps->f97003 ) {
+		_OUTB_CTRL( ps, ps->CtrlReadHighNibble );
+		_DO_UDELAY( 2 );
+	}
+
+	/* read high nibble */
+	_INB_STATUS( ps );
+	_INB_STATUS( ps );
+    bData  = _INB_STATUS( ps );
+	bData &= 0xf0;
+
+    _OUTB_CTRL( ps, ps->CtrlReadLowNibble );
+	_DO_UDELAY( 2 );
+
+	/* read low nibble */
+	_INB_STATUS( ps );
+	_INB_STATUS( ps );
+	tmp = _INB_STATUS( ps );
+	
+	/* combine with low nibble */
+    bData |= (tmp >> 4);
+
+    _OUTB_CTRL( ps, _CTRL_GENSIGNAL );
+	_DO_UDELAY( 2 );
+
+    return bData;
+}
+
+static UChar ioDataFromSPPSlowest( pScanData ps )
+{
+	Byte bData, tmp;
+
+	/* notify asic we will read the high nibble data from status port */
+	if( _FALSE == ps->f97003 ) {
+		_OUTB_CTRL( ps, ps->CtrlReadHighNibble );
+		_DO_UDELAY( 3 );
+	}
+
+	/* read high nibble */
+	_INB_STATUS( ps );
+	_INB_STATUS( ps );
+	_INB_STATUS( ps );
+    bData  = _INB_STATUS( ps );
+	bData &= 0xf0;
+
+    _OUTB_CTRL( ps, ps->CtrlReadLowNibble );
+	_DO_UDELAY( 3 );
+
+	/* read low nibble */
+	_INB_STATUS( ps );
+	_INB_STATUS( ps );
+	_INB_STATUS( ps );
+	tmp = _INB_STATUS( ps );
+	
+	/* combine with low nibble */
+    bData |= (tmp >> 4);
+
+    _OUTB_CTRL( ps, _CTRL_GENSIGNAL );
+	_DO_UDELAY( 3 );
+
+    return bData;
+}
+
+/** Read data from STATUS port. We have to read twice and combine two nibble
+ *  data to one byte.
+ */
+static Bool fnSPPRead( pScanData ps, pUChar pBuffer, ULong ulSize )
+{
+	switch( ps->IO.delay ) {
+
+		case 0:
+			for (; ulSize; ulSize--, pBuffer++)
+				*pBuffer = ioDataFromSPPFast( ps );
+			break;
+
+		case 1:
+			for (; ulSize; ulSize--, pBuffer++)
+				*pBuffer = ioDataFromSPPMiddle( ps );
+			break;
+
+		case 2:
+			for (; ulSize; ulSize--, pBuffer++)
+				*pBuffer = ioDataFromSPPSlow( ps );
+			break;
+
+		default:
+			for (; ulSize; ulSize--, pBuffer++)
+				*pBuffer = ioDataFromSPPSlowest( ps );
+			break;
+	}
+
+    return _TRUE;
+}
+
+
+/** Using buffered I/O to read data from EPP Data Port
+ */
+static Bool fnEPPRead( pScanData ps, pUChar pBuffer, ULong ulSize )
+{
+	register ULong i;
+
+	if( _IS_ASIC98(ps->sCaps.AsicID)) {
+
+#ifndef __KERNEL__
+		sanei_pp_set_datadir( ps->pardev, SANEI_PP_DATAIN );
+#else
+		_OUTB_CTRL( ps, (_CTRL_GENSIGNAL + _CTRL_DIRECTION));
+		_DO_UDELAY( 1 );
+#endif
+		for( i = 0; i < ulSize; i++ )
+			pBuffer[i] = _INB_EPPDATA( ps );
+
+#ifndef __KERNEL__
+		sanei_pp_set_datadir( ps->pardev, SANEI_PP_DATAOUT );
+#else
+		_OUTB_CTRL( ps, _CTRL_GENSIGNAL );
+		_DO_UDELAY( 1 );
+#endif
+	} else {
+
+		for( i = 0; i < ulSize; i++ )
+			pBuffer[i] = _INB_EPPDATA( ps );
+	}
+
+	return _TRUE;
+}
+
+/**
+ */
+static Bool fnBiDirRead( pScanData ps, pUChar pBuffer, ULong ulSize )
+{
+	UChar start, end;
+
+	start = _CTRL_START_BIDIREAD;
+	end   = _CTRL_END_BIDIREAD;
+
+#ifndef __KERNEL__
+	sanei_pp_set_datadir( ps->pardev, SANEI_PP_DATAIN );
+
+	if( !sanei_pp_uses_directio()) {
+		start &= ~_CTRL_DIRECTION;
+		end   &= ~_CTRL_DIRECTION;
+	}
+#else
+	if( _IS_ASIC98(ps->sCaps.AsicID)) {
+		_OUTB_CTRL( ps, (_CTRL_GENSIGNAL + _CTRL_DIRECTION));
+	}
+#endif
+
+	switch( ps->IO.delay ) {
+
+		case 0:
+		    for( ; ulSize; ulSize--, pBuffer++ ) {
+				_OUTB_CTRL( ps, start );   
+				*pBuffer = _INB_DATA( ps );
+				_OUTB_CTRL( ps, end );   
+			}
+			break;
+
+		case 1:
+			_DO_UDELAY( 1 );
+		    for(; ulSize; ulSize--, pBuffer++ ) {
+				_OUTB_CTRL( ps, start );
+				_DO_UDELAY( 1 );
+
+				*pBuffer = _INB_DATA( ps );
+
+				_OUTB_CTRL( ps, end );
+				_DO_UDELAY( 1 );
+			}
+			break;
+		
+		default:
+			_DO_UDELAY( 2 );
+		    for(; ulSize; ulSize--, pBuffer++ ) {
+				_OUTB_CTRL( ps, start );
+				_DO_UDELAY( 2 );
+
+				*pBuffer = _INB_DATA( ps );
+
+				_OUTB_CTRL( ps, end );
+				_DO_UDELAY( 2 );
+			}
+			break;
+
+	}
+
+#ifndef __KERNEL__
+	sanei_pp_set_datadir( ps->pardev, SANEI_PP_DATAOUT );
+#else
+	if( _IS_ASIC98(ps->sCaps.AsicID)) {
+		_OUTB_CTRL( ps, _CTRL_GENSIGNAL );
+	}
+#endif
+	return _TRUE;
+}
+
+/** as the name says, we switch to SPP mode
+ */
+static void ioSwitchToSPPMode( pScanData ps )
+{
+	/* save the control and data port value
+	 */
+	ps->IO.bOldControlValue = _INB_CTRL( ps );
+	ps->IO.bOldDataValue    = _INB_DATA( ps );
+
+	_OUTB_CTRL( ps, _CTRL_GENSIGNAL );	/* 0xc4 */
+	_DO_UDELAY( 2 );
+}
+
+/** restore the port settings
+ */
+static void ioRestoreParallelMode( pScanData ps )
+{
+	_OUTB_CTRL( ps, ps->IO.bOldControlValue & 0x3f );
+	_DO_UDELAY( 1 );
+
+	_OUTB_DATA( ps, ps->IO.bOldDataValue );
+	_DO_UDELAY( 1 );
+}
+
+/** try to connect to scanner (ASIC 9600x and 98001)
+ */
+_LOC void ioP98001EstablishScannerConnection( pScanData ps, ULong delTime )
+{
+	_OUTB_DATA( ps, _ID_TO_PRINTER );
+    _DO_UDELAY( delTime );
+
+	_OUTB_DATA( ps, _ID1ST );
+    _DO_UDELAY( delTime );
+
+	_OUTB_DATA( ps, _ID2ND );
+    _DO_UDELAY( delTime );
+
+	_OUTB_DATA( ps, _ID3RD );
+    _DO_UDELAY( delTime );
+
+    _OUTB_DATA( ps, _ID4TH );
+    _DO_UDELAY( delTime );
+}
+
+/** try to connect to scanner (ASIC 98003)
+ */
+static void ioP98003EstablishScannerConnection( pScanData ps, ULong delTime )
+{
+	_OUTB_DATA( ps, _ID1ST );
+	_DO_UDELAY( delTime );
+
+	_OUTB_DATA( ps, _ID2ND );
+	_DO_UDELAY( delTime );
+
+	_OUTB_DATA( ps, _ID3RD );
+	_DO_UDELAY( delTime );
+
+	_OUTB_DATA( ps, _ID4TH );
+	_DO_UDELAY( delTime );
+}
+
+/** switch the printer interface to scanner
+ */
+static Bool ioP96OpenScanPath( pScanData ps )
+{
+	if( 0 == ps->IO.bOpenCount ) {
+
+		/* not established */
+		ioSwitchToSPPMode( ps );
+
+		/* Scanner command sequence to open scanner path */
+		ioP98001EstablishScannerConnection( ps, 5 );
+	}
+#ifdef DEBUG
+	else
+		DBG( DBG_IO, "!!!! Path already open (%u)!!!!\n", ps->IO.bOpenCount );
+#endif
+
+	ps->IO.bOpenCount++;			/* increment the opened count */
+
+/*
+ * CHECK to we really need that !!
+ */
+	ps->IO.useEPPCmdMode = _FALSE;
+	return _TRUE;
+}
+
+/** try to connect to scanner
+ */
+static Bool ioP98OpenScanPath( pScanData ps )
+{
+    Byte  tmp;
+    ULong dw;
+	ULong dwTime = 1;
+
+	if( 0 == ps->IO.bOpenCount ) {
+
+		/* not established */
+		ioSwitchToSPPMode( ps );
+
+		for( dw = 10; dw; dw-- ) {
+
+			/*
+			 * this seems to be necessary...
+			 */
+ 			if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
+				ioP98001EstablishScannerConnection( ps, dw );
+#if 0
+				ioP98001EstablishScannerConnection( ps, dw );
+				ioP98001EstablishScannerConnection( ps, dw );
+#endif
+			} else {
+				ioP98003EstablishScannerConnection( ps, dw );
+			}			
+
+			_INB_STATUS( ps );
+			tmp = _INB_STATUS( ps );
+
+			if( 0x50 == ( tmp & 0xf0 )) {
+
+				ps->IO.bOpenCount = 1;
+
+				if( ps->sCaps.AsicID == IODataFromRegister(ps, ps->RegAsicID)) {
+					return _TRUE;
+				}
+				ps->IO.bOpenCount = 0;
+			}
+
+			dwTime++;
+		}
+		DBG( DBG_IO, "ioP98OpenScanPath() failed!\n" );
+		return _FALSE;
+	}
+#ifdef DEBUG
+	else
+		DBG( DBG_IO, "!!!! Path already open (%u)!!!!\n", ps->IO.bOpenCount );
+#endif
+
+	ps->IO.bOpenCount++;			/* increment the opened count */
+	return _TRUE;
+}
+
+/** Switch back to printer mode.
+ * Restore the printer control/data port value.
+ */
+static void ioCloseScanPath( pScanData ps )
+{
+	if( ps->IO.bOpenCount && !(--ps->IO.bOpenCount)) {
+
+#ifdef DEBUG
+		ps->IO.bOpenCount = 1;
+#endif
+		IORegisterToScanner( ps, 0xff );
+
+		/*
+		 * back to pass-through printer mode
+		 */
+		IORegisterToScanner( ps, ps->RegSwitchBus );
+#ifdef DEBUG
+        ps->IO.bOpenCount = 0;
+#endif
+		ps->IO.useEPPCmdMode = _FALSE;
+
+		ioRestoreParallelMode( ps );
+	}
+}
+
+/** check the memory to see that the data-transfers will work.
+ * (ASIC 9800x only)
+ */
+static int ioP98ReadWriteTest( pScanData ps )
+{	
+	UChar  tmp;
+	ULong  ul;
+	pUChar buffer;
+	int	   retval;
+
+	DBG( DBG_LOW, "ioP98ReadWriteTest()\n" );
+
+	/* _MEMTEST_SIZE: Read, _MEMTEST_SIZE:Write */
+	buffer = _KALLOC( sizeof(UChar) * _MEMTEST_SIZE*2, GFP_KERNEL );
+	if( NULL == buffer )
+		return _E_ALLOC;
+
+	/* prepare content */
+	for( ul = 0; ul < _MEMTEST_SIZE; ul++ )
+	    buffer[ul] = (UChar)ul;	
+
+	ps->OpenScanPath(ps);
+	
+	/* avoid switching to Lamp0, when previously scanned in transp./neg mode */
+	tmp = ps->bLastLampStatus + _SCAN_BYTEMODE;
+	IODataToRegister( ps, ps->RegScanControl, tmp );
+
+	IODataToRegister( ps, ps->RegModelControl, (_LED_ACTIVITY | _LED_CONTROL));
+
+	IODataToRegister( ps, ps->RegModeControl, _ModeMappingMem );
+	IODataToRegister( ps, ps->RegMemoryLow,  0 );
+	IODataToRegister( ps, ps->RegMemoryHigh, 0 );
+
+	/* fill to buffer */
+	IOMoveDataToScanner( ps, buffer, _MEMTEST_SIZE );
+
+	IODataToRegister( ps, ps->RegModeControl, _ModeMappingMem );
+	IODataToRegister( ps, ps->RegMemoryLow,  0 );
+	IODataToRegister( ps, ps->RegMemoryHigh, 0 );
+	IODataToRegister( ps, ps->RegWidthPixelsLow,  0 );
+	IODataToRegister( ps, ps->RegWidthPixelsHigh, 5 );
+
+	ps->AsicReg.RD_ModeControl = _ModeReadMappingMem;
+
+	if( _ASIC_IS_98001 == ps->sCaps.AsicID )
+		ps->CloseScanPath( ps );
+
+	IOReadScannerImageData( ps, buffer + _MEMTEST_SIZE, _MEMTEST_SIZE );
+
+	if( _ASIC_IS_98003 == ps->sCaps.AsicID )
+		ps->CloseScanPath( ps );
+
+	/* check the result ! */
+	retval = _OK;
+
+	for( ul = 0; ul < _MEMTEST_SIZE; ul++ ) {
+		if( buffer[ul] != buffer[ul+_MEMTEST_SIZE] ) {
+			DBG( DBG_HIGH, "Error in memory test at pos %u (%u != %u)\n",
+				 ul, buffer[ul], buffer[ul+_MEMTEST_SIZE] );
+			retval = _E_NO_DEV;
+			break;
+		}
+	}
+
+	_KFREE(buffer);
+	return retval;
+}
+
+/** Put data to DATA port and trigger hardware through CONTROL port to read it.
+ */
+static void ioSPPWrite( pScanData ps, pUChar pBuffer, ULong size )
+{
+	DBG( DBG_IO , "Moving %u bytes to scanner, IODELAY = %u...\n",
+					size, ps->IO.delay );
+	switch( ps->IO.delay ) {
+	
+		case 0:
+		    for (; size; size--, pBuffer++) {
+				_OUTB_DATA( ps, *pBuffer );
+				_OUTB_CTRL( ps, _CTRL_START_DATAWRITE );
+				_OUTB_CTRL( ps, _CTRL_END_DATAWRITE );
+        	}
+			break;
+		
+		case 1:
+		case 2:
+		    for (; size; size--, pBuffer++) {
+				_OUTB_DATA( ps, *pBuffer );
+				_DO_UDELAY( 1 );
+				_OUTB_CTRL( ps, _CTRL_START_DATAWRITE );
+				_DO_UDELAY( 1 );
+				_OUTB_CTRL( ps, _CTRL_END_DATAWRITE );
+				_DO_UDELAY( 2 );
+        	}
+			break;
+
+		default:
+		    for (; size; size--, pBuffer++) {
+				_OUTB_DATA( ps, *pBuffer );
+				_DO_UDELAY( 1 );
+				_OUTB_CTRL( ps, _CTRL_START_DATAWRITE );
+				_DO_UDELAY( 2 );
+				_OUTB_CTRL( ps, _CTRL_END_DATAWRITE );
+				_DO_UDELAY( 3 );
+        	}
+			break;
+	}
+	DBG( DBG_IO , "... done.\n" );
+}
+
+/** set the scanner to "read" data mode
+ */
+static void ioEnterReadMode( pScanData ps )
+{
+	if( ps->IO.portMode != _PORT_SPP ) {
+
+		_DO_UDELAY( 1 );
+		IORegisterToScanner( ps, ps->RegEPPEnable );
+
+		if( _IS_ASIC98( ps->sCaps.AsicID ))
+			ps->IO.useEPPCmdMode = _TRUE;
+	}
+
+	if( _ASIC_IS_98003 == ps->sCaps.AsicID )
+		ps->IO.bOldControlValue = _INB_CTRL( ps );
+
+	/* ask ASIC to enter read mode */
+	IORegisterToScanner( ps, ps->RegReadDataMode );	
+}
+
+/************************ exported functions *********************************/
+
+/** here we do some init work
+ */
+_LOC int IOInitialize( pScanData ps )
+{
+	DBG( DBG_HIGH, "IOInitialize()\n" );
+
+	if( NULL == ps )
+		return _E_NULLPTR;
+
+	if( _IS_ASIC98(ps->sCaps.AsicID)) {
+
+		ps->OpenScanPath  = ioP98OpenScanPath;
+		ps->ReadWriteTest = ioP98ReadWriteTest;
+
+	} else if( _IS_ASIC96(ps->sCaps.AsicID)) {
+
+		ps->OpenScanPath = ioP96OpenScanPath;
+
+	} else {
+
+		DBG( DBG_HIGH , "NOT SUPPORTED ASIC !!!\n" );
+		return _E_NOSUPP;
+	}
+
+	ps->CloseScanPath   = ioCloseScanPath;
+	ps->Device.ReadData = ioReadFunc[ps->IO.portMode].func;
+	DBG( DBG_HIGH, "* using readfunction >%s<\n",
+	                  ioReadFunc[ps->IO.portMode].name );
+	return _OK;
+}
+
+/** Write specific length buffer to scanner
+ * The scan path is already established
+ */
+_LOC void IOMoveDataToScanner( pScanData ps, pUChar pBuffer, ULong size )
+{
+#ifdef DEBUG
+	if( 0 == ps->IO.bOpenCount )
+		DBG( DBG_IO, "IOMoveDataToScanner - no connection!\n" );
+#endif
+
+	IORegisterToScanner( ps, ps->RegInitDataFifo );
+	IORegisterToScanner( ps, ps->RegWriteDataMode );
+
+	ioSPPWrite( ps, pBuffer, size );
+}
+
+/** Calling SITUATION: Scanner path is established.
+ * download a scanstate-table
+ */
+_LOC void IODownloadScanStates( pScanData ps )
+{
+	TimerDef timer;
+#ifdef DEBUG
+	if( 0 == ps->IO.bOpenCount )
+		DBG( DBG_IO, "IODownloadScanStates - no connection!\n" );
+#endif
+
+	IORegisterToScanner( ps, ps->RegScanStateControl );
+
+	ioSPPWrite( ps, ps->a_nbNewAdrPointer, _SCANSTATE_BYTES );
+
+	if( ps->Scan.fRefreshState ) {
+
+		IORegisterToScanner( ps, ps->RegRefreshScanState );
+
+		MiscStartTimer( &timer, (_SECOND/2));
+		do {
+
+			if (!( IOGetScanState( ps, _TRUE) & _SCANSTATE_STOP))
+				break;
+		}
+		while( !MiscCheckTimer(&timer));
+	}
+}
+
+/** Calling SITUATION: Scanner path is established.
+ * Write a data to asic
+ */
+_LOC void IODataToScanner( pScanData ps, Byte bValue )
+{
+	ULong deltime = 4;
+
+#ifdef DEBUG
+	if( 0 == ps->IO.bOpenCount )
+        DBG( DBG_IO, "IODataToScanner - no connection!\n" );
+#endif
+
+	if( ps->IO.delay < 2 )
+		deltime = 2;
+
+    /* output data */
+   	_OUTB_DATA( ps, bValue );
+	_DO_UDELAY( deltime );
+
+	/* notify asic there is data */
+    _OUTB_CTRL( ps, _CTRL_START_DATAWRITE );
+	_DO_UDELAY( deltime );
+						
+		/* end write cycle */
+   	_OUTB_CTRL( ps, _CTRL_END_DATAWRITE );
+	_DO_UDELAY( deltime-1 );
+}
+
+/** Calling SITUATION: Scanner path is established.
+ * Write a data to specific asic's register
+ */
+_LOC void IODataToRegister( pScanData ps, Byte bReg, Byte bData )
+{
+#ifdef DEBUG
+    if( 0 == ps->IO.bOpenCount )
+        DBG( DBG_IO, "IODataToRegister - no connection!\n" );
+#endif
+
+	/* specify register */
+    IORegisterToScanner( ps, bReg );	
+
+	/* then write the content */
+	IODataToScanner( ps, bData );
+}
+
+/** Calling SITUATION: Scanner path is established.
+ * Read the content of specific asic's register
+ */
+_LOC Byte IODataFromRegister( pScanData ps, Byte bReg )
+{
+	IORegisterToScanner( ps, bReg );
+
+	if( 0 == ps->IO.delay )
+		return ioDataFromSPPFast( ps );
+	else if( 1 == ps->IO.delay )
+		return ioDataFromSPPMiddle( ps );
+	else if( 2 == ps->IO.delay )
+		return ioDataFromSPPSlow( ps );
+	else
+		return ioDataFromSPPSlowest( ps );
+}
+
+/** Calling SITUATION: Scanner path is established.
+ * Write a register to asic (used for a command without parameter)
+ */
+_LOC void IORegisterToScanner( pScanData ps, Byte bReg )
+{
+#ifdef DEBUG
+    if( 0 == ps->IO.bOpenCount )
+        DBG( DBG_IO, "IORegisterToScanner - no connection!\n" );
+#endif
+
+    /*
+     * write data to port
+     */
+	_OUTB_DATA( ps, bReg );
+
+    /*
+     * depending on the mode, generate the trigger signals
+     */
+    if( ps->IO.useEPPCmdMode ) {
+
+		_DO_UDELAY( 5 );
+
+		_OUTB_CTRL( ps, _CTRL_EPPSIGNAL_WRITE);	/* 0xc5 */
+		_DO_UDELAY( 5 );
+
+		_OUTB_CTRL( ps, _CTRL_EPPTRIG_REGWRITE);/* 0xcd */
+		_DO_UDELAY( 5 );
+
+		_OUTB_CTRL( ps, _CTRL_EPPSIGNAL_WRITE);	/* 0xc5 */
+		_DO_UDELAY( 5 );
+
+		_OUTB_CTRL( ps, _CTRL_END_REGWRITE);    /* 0xc4 */
+
+    } else {
+		if( ps->IO.delay < 2 ) {
+
+			_DO_UDELAY( 1 );
+			_OUTB_CTRL( ps, _CTRL_START_REGWRITE);
+			_DO_UDELAY( 1 );
+			_OUTB_CTRL( ps, _CTRL_END_REGWRITE);
+		} else {
+
+			_DO_UDELAY( 2 );
+			_OUTB_CTRL( ps, _CTRL_START_REGWRITE);
+			_DO_UDELAY( 2 );
+			_OUTB_CTRL( ps, _CTRL_END_REGWRITE);
+			_DO_UDELAY( 2 );
+		}
+    }
+}
+
+/** write data to the DAC - ASIC 98001/3 only
+ */
+_LOC void IODataRegisterToDAC( pScanData ps, Byte bReg, Byte bData )
+{
+    ULong i;
+
+	IODataToRegister( ps, ps->RegADCAddress, bReg );
+    IODataToRegister( ps, ps->RegADCData,    bData );
+    IODataToRegister( ps, ps->RegADCSerialOutStr, bData );
+
+    /* TEST: ORG was 1 ms for ASIC 98001 */
+    _DO_UDELAY( 12 );
+
+    for( i = 4; i; i-- ) {
+
+    	_OUTB_CTRL( ps, _CTRL_START_DATAWRITE );
+        _DO_UDELAY( 5 );
+    	_OUTB_CTRL( ps, _CTRL_END_DATAWRITE );
+        _DO_UDELAY( 12 );
+    }
+}
+
+/** Calling SITUATION: Scanner path was not established.
+ * Read the content of specific asics' register
+ */
+_LOC Byte IODataRegisterFromScanner( pScanData ps, Byte bReg )
+{
+    Byte bData;
+
+    ps->OpenScanPath( ps );
+    bData = IODataFromRegister( ps, bReg );
+    ps->CloseScanPath( ps );
+
+    return bData;
+}
+
+/** Calling SITUATION: Scanner path not established.
+ * Write a value of register to asic
+ */
+_LOC void IOCmdRegisterToScanner( pScanData ps, Byte bReg, Byte bData )
+{
+    ps->OpenScanPath( ps );
+    IODataToRegister( ps, bReg, bData );
+    ps->CloseScanPath( ps );
+}
+
+/** Calling SITUATION: Scanner path not established.
+ * Write a register to asic (used for a command without parameter)
+ */
+_LOC void IORegisterDirectToScanner( pScanData ps, Byte bReg )
+{
+    ps->OpenScanPath( ps );				/* establish the connection */
+    IORegisterToScanner( ps, bReg );	/* write register to asic	*/
+    ps->CloseScanPath( ps );			/* disconnect				*/
+}
+
+/** perform a SW reset of ASIC 98003 models
+ */
+_LOC void IOSoftwareReset( pScanData ps )
+{
+    if( _ASIC_IS_98003 != ps->sCaps.AsicID )
+        return;
+
+    ps->OpenScanPath( ps );
+
+    IODataToRegister( ps, ps->RegTestMode, _SW_TESTMODE );
+
+    ioSwitchToSPPMode( ps );
+
+    _OUTB_DATA( ps, _RESET1ST );
+    _DODELAY( 5 );
+
+    _OUTB_DATA( ps, _RESET2ND );
+    _DODELAY( 5 );
+
+    _OUTB_DATA( ps, _RESET3RD );
+    _DODELAY( 5 );
+
+    _OUTB_DATA( ps, _RESET4TH );
+    _DODELAY( 5 );
+
+    ioRestoreParallelMode( ps );
+
+    /* reset test mode register */
+    IODataToRegister( ps, ps->RegTestMode, 0 );
+    IODataToRegister( ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl );
+
+    ps->CloseScanPath( ps );
+}
+
+/** Read specific length data from scanner and the method depends on the
+ *  mode defined in registry.
+ */
+_LOC void IOReadScannerImageData( pScanData ps, pUChar pBuf, ULong size )
+{
+	if( _ASIC_IS_98003 != ps->sCaps.AsicID )
+		ps->OpenScanPath( ps);
+
+	if( _IS_ASIC98( ps->sCaps.AsicID))
+		IODataToRegister( ps, ps->RegModeControl, ps->AsicReg.RD_ModeControl );
+
+	/* enter read mode */
+	ioEnterReadMode( ps );
+
+	/* call corresponding read proc */
+	ps->Device.ReadData( ps, pBuf, size );
+
+	/* Clear EPP/ECP read mode by simply close scanner path and re-open it */
+	ps->CloseScanPath( ps );
+
+	if( _ASIC_IS_98003 == ps->sCaps.AsicID )
+		ps->OpenScanPath( ps );
+}
+
+#ifdef __KERNEL__
+
+/** the wrapper functions to support delayed and non-delayed I/O
+ */
+_LOC void IOOut( Byte data, UShort port )
+{
+	DBG( DBG_IOF, "outb(0x%04x, 0x%02x)\n", port, data );
+	outb( data, port );
+}
+
+_LOC void IOOutDelayed( Byte data, UShort port )
+{
+	DBG( DBG_IOF, "outb_p(0x%04x, 0x%02x)\n", port, data );
+	outb_p( data, port );
+}
+
+_LOC Byte IOIn( UShort port )
+{
+#ifdef DEBUG
+	Byte data = inb( port );
+
+	DBG( DBG_IOF, "inb(0x%04x) = 0x%02x\n", port, data );
+	return data;
+#else
+	return inb( port );
+#endif
+}
+
+_LOC Byte IOInDelayed( UShort port )
+{
+#ifdef DEBUG
+	Byte data = inb_p( port );
+
+	DBG( DBG_IOF, "inb_p(0x%04x) = 0x%02x\n", port, data );
+	return data;
+#else
+	return inb_p( port );
+#endif
+}
+#endif /* guard __KERNEL__ */
+
+/* END PLUSTEK-PP_IO.C ......................................................*/