Initial import of sane-backends version 1.0.24-1.2

1 files changed, 3348 insertions, 0 deletions

diff --git a/backend/plustek-pp_motor.c b/backend/plustek-pp_motor.c
new file mode 100644
index 0000000..f377b7e
--- /dev/null
+++ b/backend/plustek-pp_motor.c
@@ -0,0 +1,3348 @@
+/* @file plustek-pp_motor.c
+ * @brief all functions for motor control
+ *
+ * based on sources acquired from Plustek Inc.
+ * Copyright (C) 1998 Plustek Inc.
+ * Copyright (C) 2000-2013 Gerhard Jaeger <gerhard@gjaeger.de>
+ * also based on the work done by Rick Bronson
+ *
+ * History:
+ * - 0.30 - initial version
+ * - 0.31 - no changes
+ * - 0.32 - slight cosmetic changes
+ *        - added function MotorToHomePosition()
+ * - 0.33 - added additional debug-messages
+ *        - increased speed for returning to homeposition for Models >= 9630
+ *          (and ASIC 96003)
+ * - 0.34 - added FIFO overflow check in motorP96SetSpeed
+ *        - removed WaitBack() function from pScanData structure
+ *        - removed wStayMaxStep from pScanData structure
+ * - 0.35 - changed motorP96UpdateDataCurrentReadLine() to handle proper
+ *        - work of ASIC96003 based 600dpi models
+ * - 0.36 - merged motorP96WaitBack and motorP98WaitBack to motorWaitBack
+ *        - merged motorP96SetSpeed and motorP98SetSpedd to motorSetSpeed
+ *        - added Sensor-Check in function MotorToHomePosition
+ *        - reduced number of forward steps for MotorToHomePosition
+ * - 0.37 - removed function motorP96GetStartStopGap() - no longer used
+ *        - removed a_bStepDown1Table and a_bStepUp1Table
+ *        - removed // comments
+ *        - added A3I stuff
+ * - 0.38 - cosmetic changes
+ *        - added P12 stuff
+ * - 0.39 - Did some finetuning in MotorP98003ModuleForwardBackward()
+ *        - Fixed a problem, that could cause the driver to throw a
+ *          kernel exception
+ * - 0.40 - changed back to build 0.39-3 (disabled A3I stuff)
+ * - 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 definitons *********************************/
+
+/* #define _A3I_EN */
+
+/*
+ * adjustments for scanning in negative and tranparency mode
+ */
+#define _NEG_SCANNINGPOS 	    770
+#define _POS_SCANNINGPOS 	    660        /* original value was 710 */
+
+#define _P98_BACKMOVES			0x3d
+#define _P98_FORWARDMOVES		0x3b		/* Origin = 3c */
+
+#define _P98003_BACKSTEPS	    120
+#define _P98003_FORWARDSTEPS    120
+
+#define _P96_BACKMOVES			130
+#define _P96_FORWARDMOVES		87   /* 95 */
+#define _P96_FIFOOVERFLOWTHRESH	180
+
+
+#define _COLORRUNTABLE_RED		0x11
+#define _COLORRUNTABLE_GREEN	0x22
+#define _COLORRUNTABLE_BLUE		0x44
+
+#define	_BW_ORIGIN				0x0D
+#define	_GRAY_ORIGIN			0x0B
+#define	_COLOR_ORIGIN			0x0B
+
+#define _P98003_YOFFSET			300
+
+/**************************** local vars *************************************/
+
+static TimerDef p98003MotorTimer;
+
+static UShort 	a_wMoveStepTable [_NUMBER_OF_SCANSTEPS];
+static Byte		a_bScanStateTable[_SCANSTATE_TABLE_SIZE];
+static Byte		a_bHalfStepTable [_NUMBER_OF_SCANSTEPS];
+static Byte		a_bColorByteTable[_NUMBER_OF_SCANSTEPS];
+static Byte		a_bColorsSum[8] = {0, 1, 1, 2, 1, 2, 2, 3};
+
+static pUShort	pwEndMoveStepTable  = a_wMoveStepTable  + _NUMBER_OF_SCANSTEPS;
+static pUChar	pbEndColorByteTable = a_bColorByteTable + _NUMBER_OF_SCANSTEPS;
+static pUChar	pbEndHalfStepTable  = a_bHalfStepTable  + _NUMBER_OF_SCANSTEPS;
+
+/*
+ * for the 96001/3 based units
+ */
+static UShort wP96BaseDpi = 0;
+
+static Byte	a_bStepDown1Table[20]  = {3,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static Byte a_bStepUp1Table[20]    = {4,3,2,1,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0};
+static Byte	a_bMotorDown2Table[20] = {0,0,0,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2};
+
+#ifndef _A3I_EN
+static Byte	a_bHalfStep2Table[32] = {1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,
+									 1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1};
+static Byte	a_bHalfStep4Table[16] = {2,2,2,2,2,2,2,2,2,2,2,2,2,2,2,2};
+static Byte	a_bHalfStep6Table[12] = {3,3,3,3,3,3,3,3,3,3,3,3};
+static Byte	a_bHalfStep8Table[8]  = {4,4,4,4,4,4,4,4};
+static Byte	a_bHalfStep10Table[8] = {5,5,5,5,5,5,5,5};
+static Byte	a_bHalfStep12Table[6] = {6,6,6,6,6,6};
+static Byte	a_bHalfStep14Table[6] = {7,7,7,7,7,7};
+static Byte	a_bHalfStep16Table[4] = {8,8,8,8};
+static Byte	a_bHalfStep18Table[4] = {9,9,9,9};
+static Byte	a_bHalfStep20Table[4] = {10,10,10,10};
+static Byte	a_bHalfStep22Table[4] = {11,11,11,11};
+static Byte	a_bHalfStep24Table[4] = {12,12,12,12};
+static Byte	a_bHalfStep26Table[4] = {13,13,13,13};
+static Byte	a_bHalfStep28Table[4] = {14,14,14,14};
+static Byte	a_bHalfStep30Table[4] = {15,15,15,15};
+static Byte	a_bHalfStep32Table[2] = {16,16};
+static Byte	a_bHalfStep34Table[2] = {17,17};
+static Byte	a_bHalfStep36Table[2] = {18,18};
+static Byte	a_bHalfStep38Table[2] = {19,19};
+static Byte	a_bHalfStep40Table[2] = {20,20};
+
+
+static pUChar a_pbHalfStepTables[20] = {
+	a_bHalfStep2Table,  a_bHalfStep4Table,
+	a_bHalfStep6Table,  a_bHalfStep8Table,
+	a_bHalfStep10Table, a_bHalfStep12Table,
+	a_bHalfStep14Table, a_bHalfStep16Table,
+	a_bHalfStep18Table, a_bHalfStep20Table,
+	a_bHalfStep22Table, a_bHalfStep24Table,
+	a_bHalfStep26Table, a_bHalfStep28Table,
+	a_bHalfStep30Table, a_bHalfStep32Table,
+	a_bHalfStep34Table, a_bHalfStep36Table,
+	a_bHalfStep38Table, a_bHalfStep40Table
+};
+#endif
+
+/*************************** local functions *********************************/
+
+/*.............................................................................
+ *
+ */
+static void motorP96GetStartStopGap( pScanData ps, Bool fCheckState )
+{
+	UChar bMotorCountDownIndex;
+
+    if( fCheckState ) {
+
+		ps->bMotorStepTableNo = 0xff;
+		if( ps->Scan.bModuleState == _MotorInNormalState )
+	    	return;
+    }
+
+    bMotorCountDownIndex = ps->bMotorSpeedData / 2;
+
+    if( ps->bCurrentSpeed == 4 && ps->AsicReg.RD_Dpi < 80 )
+		ps->bMotorStepTableNo = 4;
+    else
+		if( ps->Scan.bModuleState == _MotorGoBackward )
+		    ps->bMotorStepTableNo = a_bStepUp1Table[bMotorCountDownIndex];
+		else
+	    	ps->bMotorStepTableNo = a_bStepDown1Table[bMotorCountDownIndex];
+}
+
+
+
+/*.............................................................................
+ * wait for the ScanState stop or ScanState reachs the dwScanStateCount
+ */
+static Bool motorCheckMotorPresetLength( pScanData ps )
+{
+    Byte	 bScanState;
+	TimerDef timer;
+
+	MiscStartTimer( &timer, (_SECOND * 4));
+    do {
+
+		bScanState = IOGetScanState( ps, _FALSE );
+
+		if (ps->fFullLength) {
+		    if (!(bScanState & _SCANSTATE_STOP)) /* still running */
+				if ((ULong)(bScanState & _SCANSTATE_MASK) != ps->dwScanStateCount )
+				    continue;
+		    return ps->fFullLength;
+		}
+
+ 		if (bScanState & _SCANSTATE_STOP)
+		    break;
+
+		/*
+		 * the code may work for all units
+		 */
+		if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
+
+			if (bScanState < ps->bOldStateCount)
+			    bScanState += _NUMBER_OF_SCANSTEPS;
+
+			bScanState -= ps->bOldStateCount;
+
+			if (bScanState >= 40)
+			    return ps->fFullLength;
+		}
+
+    } while ( !MiscCheckTimer( &timer ));
+
+	_DODELAY(1);			 /* delay one ms */
+
+    return ps->fFullLength;
+}
+
+/*.............................................................................
+ * 1) Keep the valid content of a_bColorByteTable, and fill others to 0:
+ * BeginFill = ((bCurrentLineCount + DL) < 64) ? bCurrentLineCount + DL :
+ *						  bCurrentLineCount + DL - 64;
+ *	FillLength = 64 - DL
+ *	[NOTE] Keep the content of a_bColorByteTable that begin at
+ *	       bCurrentLineCount and in DL bytes
+ * 2) Keep the valid content of a_bHalfStepTable, and fill the others to 0:
+ * BeginFill = ((bCurrentLineCount + bCurrentSpeed / 2 + 1) < 64) ?
+ *		      bCurrentLineCount + bCurrentSpeed / 2 + 1 :
+ *		      bCurrentLineCount + bCurrentSpeed / 2 + 1 - 64;
+ *	FillLength = 64 - (bMotorSpeedData / 2 + 1);
+ */
+static void motorClearColorByteTableLoop0( pScanData ps, Byte bColors )
+{
+	ULong  dw;
+   	pUChar pb;
+
+    if ((ps->bCurrentLineCount + bColors) >= _NUMBER_OF_SCANSTEPS) {
+		pb = a_bColorByteTable + (ULong)(ps->bCurrentLineCount + bColors -
+							 _NUMBER_OF_SCANSTEPS);
+	} else {
+		pb = a_bColorByteTable + (ULong)(ps->bCurrentLineCount + bColors);
+	}
+
+    for (dw = _NUMBER_OF_SCANSTEPS - bColors; dw; dw--) {
+
+		*pb++ = 0;
+		if (pb >= pbEndColorByteTable)
+	    	pb = a_bColorByteTable;
+    }
+
+    if ((ps->bCurrentLineCount+ps->bCurrentSpeed/2+1) >= _NUMBER_OF_SCANSTEPS) {
+
+		pb = a_bHalfStepTable + (ULong)(ps->bCurrentLineCount +
+								ps->bCurrentSpeed / 2 + 1 - _NUMBER_OF_SCANSTEPS);
+	} else {
+		pb = a_bHalfStepTable +
+			 (ULong)(ps->bCurrentLineCount + ps->bCurrentSpeed / 2 + 1);
+	}
+
+    for (dw = _NUMBER_OF_SCANSTEPS - ps->bMotorSpeedData / 2 - 1; dw; dw--) {
+		*pb++ = 0;
+		if (pb >= pbEndHalfStepTable)
+	    	pb = a_bHalfStepTable;
+    }
+}
+
+/*.............................................................................
+ * motorClearColorByteTableLoop1 ()
+ *   1) Adjust bNewGap:
+ *	bNewGap = (bNewGap <= bNewCurrentLineCountGap) ?
+ *			0 : bNewGap - bNewCurrentLineCount - 1;
+ *   2) Fill the 0 to a_bColorByteTable:
+ *	FillIndex = ((bCurrentLineCount + bNewGap + 1) < 64) ?
+ *				 bCurrentLineCount + bNewGap + 1 :
+ *				 bCurrentLineCount + bNewGap + 1 - 64;
+ *	FillCount = 64 - bNewGap - 1;
+ *   3) Adjust bNewGap:
+ *	bNewGap = (bCurrentLineCount <= bNewCurrentLineCountGap) ?
+ *			0 : bNewGap - bNewCurrentLineCount - 1;
+ *   4) Fill the a_bHalfStepTable:
+ *	FillIndex = ((bCurrentLineCount + bNewGap + 1) < 64) ?
+ *				 bCurrentLineCount + bNewGap + 1 :
+ *				 bCurrentLineCount + bNewGap + 1 - 64;
+ *	FillCount = 64 - bNewGap - 1;
+ */
+static void motorClearColorByteTableLoop1( pScanData ps )
+{
+	ULong  dw = _NUMBER_OF_SCANSTEPS - 1;
+    pUChar pb;
+
+    if (ps->bNewGap > ps->bNewCurrentLineCountGap) {
+		ps->bNewGap = ps->bNewGap - ps->bNewCurrentLineCountGap - 1;
+		dw -= (ULong)ps->bNewGap;
+    } else {
+		ps->bNewGap = 0;
+	}
+
+    if ((ps->bCurrentLineCount + ps->bNewGap + 1) >= _NUMBER_OF_SCANSTEPS) {
+		pb = a_bColorByteTable +
+				(ULong)(ps->bCurrentLineCount+ps->bNewGap+1-_NUMBER_OF_SCANSTEPS);
+    } else {
+		pb = a_bColorByteTable +
+							(ULong)(ps->bCurrentLineCount + ps->bNewGap + 1);
+	}
+
+    for (; dw; dw--) {
+		*pb++ = 0;
+		if (pb >= pbEndColorByteTable)
+	    	pb = a_bColorByteTable;
+    }
+
+   	if (ps->bCurrentSpeed > ps->bNewCurrentLineCountGap) {
+		ps->bNewGap = ps->bCurrentSpeed - ps->bNewCurrentLineCountGap;
+		dw = _NUMBER_OF_SCANSTEPS - 1 - (ULong)ps->bNewGap;
+    } else {
+		dw = _NUMBER_OF_SCANSTEPS - 1;
+		ps->bNewGap = 0;
+    }
+
+   	if ((ps->bCurrentLineCount + ps->bNewGap + 1) >= _NUMBER_OF_SCANSTEPS) {
+		pb = a_bHalfStepTable + (ULong)(ps->bCurrentLineCount +
+								ps->bNewGap + 1 - _NUMBER_OF_SCANSTEPS);
+	} else {
+		pb = a_bHalfStepTable + (ULong)(ps->bCurrentLineCount+ps->bNewGap +1);
+	}
+
+    for (; dw; dw--) {
+		*pb++ = 0;
+		if (pb >= pbEndHalfStepTable)
+	    	pb = a_bHalfStepTable;
+    }
+}
+
+/*.............................................................................
+ * According the flag to set motor direction
+ */
+static void motorSetRunPositionRegister( pScanData ps )
+{
+	Byte bData;
+
+	if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
+	    if( ps->Scan.fMotorBackward ) {
+			bData = ps->AsicReg.RD_Motor0Control & ~_MotorDirForward;
+		} else {
+			bData = ps->AsicReg.RD_Motor0Control | _MotorDirForward;
+		}
+
+	    IOCmdRegisterToScanner( ps, ps->RegMotor0Control, bData );
+
+	} else {
+
+		if( ps->Scan.fMotorBackward ) {
+			bData = ps->Asic96Reg.RD_MotorControl & ~_MotorDirForward;
+		} else {
+			bData = ps->Asic96Reg.RD_MotorControl | _MotorDirForward;
+		}
+
+	    IOCmdRegisterToScanner( ps, ps->RegMotorControl, bData );
+	}
+}
+
+/*.............................................................................
+ *
+ */
+static void motorPauseColorMotorRunStates( pScanData ps )
+{
+	memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES);
+
+	if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
+
+	    ps->a_nbNewAdrPointer[2] = 0x77;	/* Read color at the same time */
+
+	} else {
+	    ps->a_nbNewAdrPointer[2] = 1;
+	    ps->a_nbNewAdrPointer[3] = 3;
+    	ps->a_nbNewAdrPointer[4] = 2;
+	}
+
+	MotorSetConstantMove( ps, 0 );
+}
+
+/*.............................................................................
+ * Setup the a_nbNewAdrPointer for ASIC stepping register
+ */
+static void motorP98FillDataToColorTable( pScanData ps,
+										  Byte bIndex, ULong dwSteps)
+{
+	pUChar	pb;
+    pUShort	pw;
+    Byte	bColor;
+    UShort	w;
+
+    for ( pb = &a_bColorByteTable[bIndex],
+				 		pw = &a_wMoveStepTable[bIndex]; dwSteps; dwSteps-- ) {
+
+		if (*pw) {				/* valid state */
+
+			if( *pw >= ps->BufferForColorRunTable ) {
+				DBG( DBG_LOW, "*pw = %u > %u !!\n",
+						*pw, ps->BufferForColorRunTable );
+			} else {
+			    bColor = ps->pColorRunTable[*pw];  		/* get the colors 	 */
+			    if (a_bColorsSum[bColor & 7])		    /* need to read data */
+					*pb = bColor & 7;
+			}
+		}
+
+		if (++pw >= pwEndMoveStepTable)	{
+		    pw = a_wMoveStepTable;
+		    pb = a_bColorByteTable;
+		} else
+		    pb++;
+    }
+
+    /* ToCondense */
+    pb = a_bColorByteTable;
+
+    for (w = 0; w < _SCANSTATE_BYTES; w++, pb += 2)
+		ps->a_nbNewAdrPointer[w] = (Byte)((*pb & 7) + ((*(pb + 1) & 7) << 4));
+
+    /* ToCondenseMotor */
+    for (pb = a_bHalfStepTable, w = 0; w < _SCANSTATE_BYTES; w++) {
+		if (*pb++)
+			ps->a_nbNewAdrPointer [w] |= 8;
+
+		if (*pb++)
+		    ps->a_nbNewAdrPointer [w] |= 0x80;
+    }
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP98FillHalfStepTable( pScanData ps )
+{
+	pUChar	 pbHalfStepTbl, pb;
+    pUShort	 pwMoveStep;
+    DataType Data;
+    ULong	 dw;
+
+    if (1 == ps->bMotorSpeedData) {
+		for (dw = 0; dw < _NUMBER_OF_SCANSTEPS; dw++)
+		    a_bHalfStepTable [dw] =
+						(a_wMoveStepTable [dw] > ps->wMaxMoveStep) ? 0: 1;
+    } else {
+		pwMoveStep 	  = &a_wMoveStepTable[ps->bCurrentLineCount];
+		pbHalfStepTbl = &a_bHalfStepTable[ps->bCurrentLineCount];
+
+		if (ps->DataInf.wAppDataType >= COLOR_TRUE24)
+		    Data.dwValue = _NUMBER_OF_SCANSTEPS - 1;
+		else
+		    Data.dwValue = _NUMBER_OF_SCANSTEPS;
+
+		for (; Data.dwValue; Data.dwValue--, pbHalfStepTbl++, pwMoveStep++ ) {
+
+		    if (pwMoveStep >= pwEndMoveStepTable) {
+				pbHalfStepTbl = a_bHalfStepTable;
+				pwMoveStep    = a_wMoveStepTable;
+		    }
+
+		    if (*pwMoveStep) {		/* need to exposure */
+
+				dw = (ULong)ps->bMotorSpeedData;
+				if (Data.bValue < ps->bMotorSpeedData)
+				    *pwMoveStep = 0;
+				else {
+				    *pbHalfStepTbl = 1;
+
+				    if (ps->dwFullStateSpeed) {
+						dw -= ps->dwFullStateSpeed;
+						for (pb = pbHalfStepTbl; dw;
+												dw -= ps->dwFullStateSpeed) {
+						    pb += ps->dwFullStateSpeed;
+						    if (pb >= pbEndHalfStepTable)
+								pb -= _NUMBER_OF_SCANSTEPS;
+			    			*pb = 1;
+						}
+				    }
+				}
+		    }
+		}
+    }
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP98FillBackColorDataTable( pScanData ps )
+{
+	Byte bIndex;
+
+    if ((bIndex = ps->bCurrentLineCount + ps->bNewCurrentLineCountGap + 1) >=
+                        							     _NUMBER_OF_SCANSTEPS) {
+		bIndex -= _NUMBER_OF_SCANSTEPS;
+	}
+
+	motorP98FillDataToColorTable( ps, bIndex, (ULong)(_NUMBER_OF_SCANSTEPS -
+								  ps->bNewCurrentLineCountGap));
+}
+
+/*.............................................................................
+ * i/p:
+ *	pScanStep = pColorRunTable if forward, a_bScanStateTable if backward
+ *	dwState = how many states is requested to process
+ * NOTE:
+ *	The content of pScanStep contain:
+ *  0: Idle state
+ *  0xff: End mark
+ *  others: The motor speed value
+ */
+static void motorP98FillBackLoop( pScanData ps,
+								  pUChar pScanStep, ULong dwStates )
+{
+    for (ps->fFullLength = _FALSE; dwStates; dwStates--) {
+
+		if (*pScanStep == 0xff ) {
+
+		    ULong dw = ps->dwScanStateCount;
+
+		    for (; dwStates; dwStates--) {
+				ps->a_nbNewAdrPointer [dw / 2] &= ((dw & 1) ? 0x7f: 0xf7);
+				dw = (dw + 1U) & _SCANSTATE_MASK;
+		    }
+		    if (!ps->dwScanStateCount)
+				ps->dwScanStateCount = _NUMBER_OF_SCANSTEPS;
+
+		    ps->dwScanStateCount--;
+		    ps->fFullLength = _TRUE;
+	    	break;
+		} else {
+		    ps->a_nbNewAdrPointer [ps->dwScanStateCount / 2] |=
+					       ((ps->dwScanStateCount & 1) ? 0x80 : 0x08);
+	    	if (++ps->dwScanStateCount == _NUMBER_OF_SCANSTEPS)
+				ps->dwScanStateCount = 0;	/* reset to begin */
+
+			pScanStep++;
+		}
+    }
+    IOSetToMotorStepCount( ps );		/* put all scan states to ASIC */
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP98SetRunFullStep( pScanData ps )
+{
+    ps->OpenScanPath( ps );
+
+	ps->AsicReg.RD_StepControl = _MOTOR0_SCANSTATE;
+    IODataToRegister( ps, ps->RegStepControl,
+					  ps->AsicReg.RD_StepControl );
+    IODataToRegister( ps, ps->RegLineControl, 96 );
+
+    if ( ps->bFastMoveFlag == _FastMove_Low_C75_G150_Back ) {
+		IODataToRegister( ps, ps->RegMotor0Control,
+						  (_MotorHQuarterStep + _MotorOn + _MotorDirBackward));
+	} else {
+		IODataToRegister( ps, ps->RegMotor0Control,
+						  (_MotorHQuarterStep + _MotorOn + _MotorDirForward));
+	}
+
+    if (ps->bFastMoveFlag == _FastMove_Film_150) {
+		ps->AsicReg.RD_XStepTime = 12;
+	} else {
+		if (ps->bFastMoveFlag == _FastMove_Fast_C50_G100) {
+		    ps->AsicReg.RD_XStepTime =
+				((ps->DataInf.wPhyDataType >= COLOR_TRUE24) ? 4 : 8);
+		} else {
+		    ps->AsicReg.RD_XStepTime =
+				((ps->DataInf.wPhyDataType >= COLOR_TRUE24) ? 6 : 12);
+		}
+	}
+
+	DBG( DBG_LOW, "XStepTime = %u\n", ps->AsicReg.RD_XStepTime );
+	IODataToRegister( ps, ps->RegXStepTime, ps->AsicReg.RD_XStepTime);
+    ps->CloseScanPath( ps );
+}
+
+/*.............................................................................
+ * moves the sensor back home...
+ */
+static int motorP98BackToHomeSensor( pScanData ps )
+{
+	int		 result = _OK;
+	TimerDef timer;
+
+    MotorSetConstantMove( ps, 1 );
+
+	ps->OpenScanPath( ps );
+
+	ps->AsicReg.RD_StepControl =
+                         (_MOTOR_FREERUN + _MOTOR0_SCANSTATE+ _MOTOR0_ONESTEP);
+    IODataToRegister( ps, ps->RegStepControl, ps->AsicReg.RD_StepControl);
+
+    ps->AsicReg.RD_ModeControl = _ModeScan;
+    IODataToRegister( ps, ps->RegModeControl, ps->AsicReg.RD_ModeControl );
+
+    ps->AsicReg.RD_Motor0Control = _MotorHQuarterStep +
+												_MotorOn + _MotorDirBackward;
+    IODataToRegister( ps, ps->RegMotor0Control, ps->AsicReg.RD_Motor0Control );
+
+
+    if( ps->DataInf.wPhyDataType >= COLOR_TRUE24) {
+		ps->AsicReg.RD_XStepTime = ps->bSpeed24;
+	} else {
+		ps->AsicReg.RD_XStepTime = ps->bSpeed12;
+	}
+
+	DBG( DBG_HIGH, "XStepTime = %u\n", ps->AsicReg.RD_XStepTime );
+
+	IODataToRegister( ps, ps->RegXStepTime, ps->AsicReg.RD_XStepTime );
+    IORegisterToScanner( ps, ps->RegRefreshScanState );
+
+	/* CHANGE: We allow up to 25 seconds for returning (org. val was 10) */
+	MiscStartTimer( &timer, _SECOND * 25 );
+
+    do {
+		if (IODataFromRegister( ps, ps->RegStatus) & _FLAG_P98_PAPER ) {
+		    IODataToRegister( ps, ps->RegModelControl,
+				   	(Byte)(ps->AsicReg.RD_ModelControl | _HOME_SENSOR_POLARITY));
+		    if(!(IODataFromRegister(ps, ps->RegStatus) & _FLAG_P98_PAPER))
+				break;
+		}
+		_DODELAY( 10 );			/* delay 10 ms */
+
+    } while ( !(result = MiscCheckTimer( &timer )));
+
+    ps->CloseScanPath( ps );
+
+	if( _OK != result )
+		return result;
+
+    memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
+
+	IOSetToMotorRegister( ps );
+
+	return _OK;
+}
+
+/*.............................................................................
+ * 1) Clear scan states
+ * 2) Adjust the new scan state
+ */
+static void motorP98FillRunNewAdrPointer1( pScanData ps )
+{
+    ScanState sState;
+    Byte	  bTemp;
+
+    IOGetCurrentStateCount( ps, &sState);
+    bTemp = sState.bStep;
+    if (sState.bStep < ps->bOldStateCount) {
+		sState.bStep += _NUMBER_OF_SCANSTEPS;/* over table (table just can	 */
+	}										 /* holds 64 step, then reset to */
+											 /* 0, so if less than means over*/
+											 /* the table)                   */
+    sState.bStep   -= ps->bOldStateCount;	 /* how many states passed   	 */
+    ps->pScanState += sState.bStep;
+
+    /*
+	 * if current state != no stepped or stepped a cycle, fill the table with
+     * 1 in NOT STEPPED length. (1 means to this state has to be processing).
+	 */
+	ps->bOldStateCount   = bTemp;
+	ps->dwScanStateCount = (ULong)((bTemp + 1) & _SCANSTATE_MASK);
+
+	motorP98FillBackLoop( ps, ps->pScanState, _NUMBER_OF_SCANSTEPS );
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP98FillRunNewAdrPointer( pScanData ps )
+{
+    memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
+
+    motorP98FillRunNewAdrPointer1( ps );
+}
+
+/*.............................................................................
+ * move the sensor to a specific Y-position
+ */
+static void motorP98PositionYProc( pScanData ps, ULong dwStates )
+{
+    ScanState sState;
+
+    memset( ps->pColorRunTable, 1, dwStates );
+    memset( ps->pColorRunTable + dwStates, 0xff, (3800UL - dwStates));
+
+	IOGetCurrentStateCount( ps, &sState);
+
+	ps->bOldStateCount = sState.bStep;
+
+    ps->OpenScanPath( ps );
+    IODataToRegister( ps, ps->RegMotor0Control,
+					  (Byte)(_MotorOn + _MotorHEightStep +(ps->Scan.fMotorBackward)?
+						_MotorDirBackward :  _MotorDirForward));
+
+	DBG( DBG_LOW, "XStepTime = %u\n", ps->bSpeed6 );
+    IODataToRegister( ps, ps->RegXStepTime, ps->bSpeed6 );
+	ps->CloseScanPath( ps );
+
+    ps->pScanState = ps->pColorRunTable;
+
+    ps->FillRunNewAdrPointer( ps );
+
+    while(!motorCheckMotorPresetLength( ps ))
+		motorP98FillRunNewAdrPointer1( ps );
+}
+
+/*.............................................................................
+ * checks if the sensor is in it´s home position and moves it back if necessary
+ */
+static int motorP98CheckSensorInHome( pScanData ps )
+{
+	int result;
+
+    if (!(IODataRegisterFromScanner(ps,ps->RegStatus) & _FLAG_P98_PAPER)){
+
+		MotorSetConstantMove( ps, 1 );
+		ps->Scan.fMotorBackward  = _FALSE;
+		ps->bExtraMotorCtrl = 0;
+		motorP98PositionYProc( ps, 20 );
+
+		result = motorP98BackToHomeSensor( ps );
+		if( _OK != result )
+			return result;
+
+		_DODELAY( 250 );
+    }
+
+	return _OK;
+}
+
+/*.............................................................................
+ * move the sensor to the scan-start position
+ */
+static void motorP98WaitForPositionY( pScanData ps )
+{
+	ULong dw;
+    ULong dwBX, dwDX;
+
+    if( ps->DataInf.dwScanFlag & SCANDEF_TPA ) {
+
+		motorP98BackToHomeSensor( ps );
+		_DODELAY( 100 );
+
+/* CHECK do we need this block ? was test code in the original source code */
+		ps->OpenScanPath( ps );
+		IODataToRegister( ps, ps->RegModelControl, ps->AsicReg.RD_ModelControl);
+		IODataToRegister( ps, ps->RegStepControl, (Byte)(_MOTOR_FREERUN +
+                                         _MOTOR0_SCANSTATE + _MOTOR0_ONESTEP));
+		IODataToRegister( ps, ps->RegMotor0Control, (Byte)(_MotorOn +
+						  _MotorHQuarterStep + _MotorDirForward));
+		ps->CloseScanPath( ps );
+
+		for (dw=1000; dw; dw--) {
+	    	if (IODataRegisterFromScanner( ps, ps->RegStatus) & _FLAG_P98_PAPER) {
+				IORegisterDirectToScanner( ps, ps->RegForceStep );
+				_DODELAY( 1000 / 400 );
+	    	}
+		}
+/*-*/
+		ps->AsicReg.RD_ModeControl = _ModeScan;
+		IOCmdRegisterToScanner( ps, ps->RegModeControl,
+								ps->AsicReg.RD_ModeControl );
+
+		memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
+
+		ps->Scan.fMotorBackward	= _FALSE;
+		ps->bExtraMotorCtrl = 0;
+		ps->bFastMoveFlag 	= _FastMove_Film_150;
+
+		if (ps->DataInf.dwScanFlag & SCANDEF_Negative) {
+	    	MotorP98GoFullStep(ps, (ps->DataInf.crImage.y+_NEG_SCANNINGPOS)/2);
+		} else {
+		    MotorP98GoFullStep(ps, (ps->DataInf.crImage.y+_POS_SCANNINGPOS)/2);
+		}
+
+		return;
+    }
+
+    ps->AsicReg.RD_ModeControl = _ModeScan;
+
+    IOCmdRegisterToScanner( ps, ps->RegModeControl,
+							ps->AsicReg.RD_ModeControl );
+
+    memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
+
+    ps->Scan.fMotorBackward = _FALSE;
+    ps->bExtraMotorCtrl     = 0;
+
+    /* SetStartPoint */
+	dw = ps->wInitialStep + ps->DataInf.crImage.y;
+
+	/*
+	 * CHANGE: when checking out the values from the NT registry
+	 *		   I found that the values are NOT 0
+	 */
+    switch (ps->DataInf.wPhyDataType) {
+		case COLOR_BW:		dw += _BW_ORIGIN;    break;
+		case COLOR_256GRAY:	dw += _GRAY_ORIGIN;	 break;
+		default:			dw += _COLOR_ORIGIN; break;
+    }
+
+    if (dw & 0x80000000)
+		dw = 0; 		/* negative */
+
+    if (dw > 180) {
+		if (ps->bSetScanModeFlag & _ScanMode_Mono) {
+		    dwBX = 90;				/* go via 150 dpi, so 180 / 2 = 90 */
+		    dwDX = (dw -180) % 3;
+	    	dw   = (dw -180) / 3; 	/* 100 dpi */
+		} else {
+		    dwBX = 45;				/* go via 75 dpi, so 180 / 4 = 45 */
+		    dwDX = (dw -180) % 6;
+	    	dw 	 = (dw -180) / 6; 	/* 50 dpi */
+		}
+
+		dwDX = (dwDX * 3 + 1) / 2 + dwBX;
+
+		/*
+		 * 100/50 dpi lines is 3/2 times of 150/75
+		 * eax = (remainder * 3 + 1) / 2 + 180 / (2 or 4) lines
+		 */
+		ps->bFastMoveFlag = _FastMove_Low_C75_G150;
+		MotorP98GoFullStep( ps, dwDX);
+
+		if (dw) {
+			DBG( DBG_LOW, "FAST MOVE MODE !!!\n" );
+		    ps->bFastMoveFlag = _FastMove_Fast_C50_G100;
+	    	MotorP98GoFullStep( ps, dw);
+		}
+    } else {
+		dwBX = ((ps->bSetScanModeFlag & _ScanMode_Mono) ? 2: 4);
+		dw 	 = (dw + dwBX/2) / dwBX;
+		ps->bFastMoveFlag = _FastMove_Low_C75_G150;
+
+		MotorP98GoFullStep(ps, dw);
+    }
+}
+
+/*.............................................................................
+ * PreMove/EndMove
+ * PreMove is only in ADF and CFB mode
+ * In ADF version, there is a distance gap between Paper flag and Real initial
+ * position and it need premove to real initial position and turn the motor
+ * Inverse and start Fast move to start scan position
+ * In CFB version , PreMove 1 mm to avoid bouncing of PaperFlag sensor then
+ * fast move
+ * In CIS and CSP although there have not PreMove but there have End move
+ * when paper out there still have several mm need to read,
+ * So it need EndMove 2mm and set Inverse Paper
+ */
+static Bool motorP98GotoShadingPosition( pScanData ps )
+{
+	int result;
+
+	DBG( DBG_LOW, "motorP98GotoShadingPosition()\n" );
+
+	/* Modify Lamp Back to Home step for Scan twice in short time */
+	result =  motorP98CheckSensorInHome( ps );
+
+	if( _OK != result )
+		return _FALSE;
+
+    MotorSetConstantMove( ps, 0 );		/* clear scan states */
+
+    IOCmdRegisterToScanner( ps, ps->RegModelControl,
+							ps->AsicReg.RD_ModelControl );
+
+	ps->Scan.fMotorBackward = _FALSE;	/* forward */
+    ps->bExtraMotorCtrl     = 0;
+
+    if( ps->DataInf.dwScanFlag & SCANDEF_TPA ) {
+
+		ps->bFastMoveFlag = _FastMove_Low_C75_G150;
+		MotorP98GoFullStep( ps, 0x40 );
+
+		ps->bFastMoveFlag = _FastMove_Middle_C75_G150;
+		MotorP98GoFullStep( ps, ps->Device.dwModelOriginY );
+    }
+
+	memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
+    IOSetToMotorRegister( ps );
+
+    return _TRUE;
+}
+
+/*.............................................................................
+ * round to the next physical available value
+ */
+static void motorP98SetMaxDpiAndLength( pScanData ps,
+									    pUShort wLengthY, pUShort wBaseDpi )
+{
+    if (ps->DataInf.xyAppDpi.y > 600)
+		*wLengthY = ps->LensInf.rExtentY.wMax * 4 + 200;
+    else
+		*wLengthY = ps->LensInf.rExtentY.wMax * 2 + 200;
+
+    if ((ps->DataInf.wPhyDataType >= COLOR_TRUE24) &&
+							     (ps->DataInf.xyAppDpi.y <= ps->wMinCmpDpi)) {
+		*wBaseDpi = ps->wMinCmpDpi;
+	} else {
+		if ((ps->DataInf.wPhyDataType < COLOR_TRUE24) &&
+											(ps->DataInf.xyAppDpi.y <= 75)) {
+	    	*wBaseDpi = 75;
+		} else {
+		    if (ps->DataInf.xyAppDpi.y <= 150) {
+				*wBaseDpi = 150;
+			} else {
+				if (ps->DataInf.xyAppDpi.y <= 300) {
+				    *wBaseDpi = 300;
+				} else {
+				    if (ps->DataInf.xyAppDpi.y <= 600)
+						*wBaseDpi = 600;
+		    		else
+						*wBaseDpi = 1200;
+				}
+			}
+		}
+	}
+
+	DBG( DBG_LOW, "wBaseDPI = %u, %u\n", *wBaseDpi, ps->wMinCmpDpi );
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP98FillGBColorRunTable( pScanData ps, pUChar pTable,
+									     Byte bHi, Byte bLo, UShort wBaseDpi )
+{
+
+    if( ps->Device.f0_8_16 ) {
+
+		if (wBaseDpi == ps->wMinCmpDpi) {
+		    *pTable |= bHi;
+		    *(pTable + 1) |= bLo;
+		} else {
+			switch (wBaseDpi) {
+		    case 150:
+				*(pTable + 2) |= bHi;
+				*(pTable + 4) |= bLo;
+				break;
+
+		    case 300:
+				*(pTable + 4) |= bHi;
+				*(pTable + 8) |= bLo;
+				break;
+
+		    case 600:
+				*(pTable + 8) |= bHi;
+				*(pTable + 16) |= bLo;
+				break;
+
+		    default:
+				*(pTable + 16) |= bHi;
+				*(pTable + 32) |= bLo;
+				break;
+			}
+		}
+    } else {
+
+		if (wBaseDpi == ps->wMinCmpDpi) {
+		    *pTable |= bHi;
+		    *(pTable + 1) |= bLo;
+		} else {
+		    switch(wBaseDpi) {
+
+			case 150:
+			    *(pTable + 1) |= bHi;
+			    *(pTable + 2) |= bLo;
+		    	break;
+
+			case 300:
+			    *(pTable + 2) |= bHi;
+			    *(pTable + 4) |= bLo;
+			    break;
+
+			case 600:
+			    *(pTable + 4) |= bHi;
+			    *(pTable + 8) |= bLo;
+		    	break;
+
+			default:
+			    *(pTable + 8) |= bHi;
+			    *(pTable + 16) |= bLo;
+			    break;
+		    }
+		}
+    }
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP98SetupRunTable( pScanData ps )
+{
+	UShort wDpi, w, wBaseDpi, wLengthY;
+	pUChar pTable;
+
+	motorP98SetMaxDpiAndLength( ps, &wLengthY, &wBaseDpi );
+
+	/*ClearColorRunTable(); */
+    memset( ps->pColorRunTable, 0, ps->BufferForColorRunTable );
+
+    wDpi = wBaseDpi;
+    w 	 = wLengthY + 1000;
+    pTable = ps->pColorRunTable + (_NUMBER_OF_SCANSTEPS / 4);
+
+    if( ps->DataInf.wPhyDataType >= COLOR_TRUE24) {
+
+		for(; w; w--, pTable++) {
+		    if((short)(wDpi -= ps->DataInf.xyPhyDpi.y) <= 0) {
+				wDpi += wBaseDpi;
+				*pTable |= 0x44;
+				motorP98FillGBColorRunTable( ps, pTable, 0x22, 0x11, wBaseDpi );
+		    }
+		}
+    } else {
+		for(; w; w--, pTable++) {
+		    if((short)(wDpi -= ps->DataInf.xyPhyDpi.y) <= 0) {
+				wDpi += wBaseDpi;
+				*pTable = 0x22;
+		    }
+		}
+    }
+	ps->dwColorRunIndex = 0;
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP98UpdateDataCurrentReadLine( pScanData ps )
+{
+    if(!(ps->Scan.bNowScanState & _SCANSTATE_STOP)) {
+
+		Byte b;
+
+		if (ps->Scan.bNowScanState >= ps->bCurrentLineCount)
+		    b = ps->Scan.bNowScanState - ps->bCurrentLineCount;
+		else
+	    	b = ps->Scan.bNowScanState + _NUMBER_OF_SCANSTEPS - ps->bCurrentLineCount;
+
+		if (b < 40)
+		    return;
+    }
+
+	ps->SetMotorSpeed( ps, ps->bCurrentSpeed, _TRUE );
+    IOSetToMotorRegister( ps );
+
+    ps->Scan.bModuleState = _MotorAdvancing;
+}
+
+/*.............................................................................
+ *	Byte - Scan State Index (0-63) and StopStep bit
+ *	pScanState->bStep - Scan State Index (0-63)
+ *	pScanState->bStatus - Scanner Status Register value
+ */
+static void motorP96GetScanStateAndStatus( pScanData ps, pScanState pScanStep )
+{
+    ps->OpenScanPath( ps );
+
+    pScanStep->bStep   = IOGetScanState(ps, _TRUE);
+	pScanStep->bStep  &= _SCANSTATE_MASK;		/* org was. ~_ScanStateStop; */
+    pScanStep->bStatus = IODataFromRegister( ps, ps->RegStatus );
+
+    ps->CloseScanPath( ps );
+}
+
+/*.............................................................................
+ * Capture the image data and average them.
+ */
+static Byte motorP96ReadDarkData( pScanData ps )
+{
+	Byte	 bFifoOffset;
+    UShort	 wSum, w;
+    TimerDef timer;
+
+	MiscStartTimer( &timer, _SECOND/2);
+
+    do {
+
+		bFifoOffset = IODataRegisterFromScanner( ps, ps->RegFifoOffset );
+
+		/* stepped 1 block */
+		if( bFifoOffset ) {
+
+			/* read data */
+			IOReadScannerImageData( ps, ps->pScanBuffer1, 512UL);
+
+		    /* 320 = 192 + 128 (128 is size to fetch data) */
+		    for (w = 192, wSum = 0; w < 320; w++)
+				wSum += (UShort)ps->pScanBuffer1[w];/* average data from 	  */
+													/* offset 192 and size 128*/
+		    return (Byte)(wSum >> 7);				/* divided by 128 		  */
+		}
+
+    } while (!MiscCheckTimer(&timer));
+
+    return 0xff;					/* timed-out */
+}
+
+/*.............................................................................
+ * move the sensor to a specific Y-position
+ */
+static void motorP96PositionYProc( pScanData ps, ULong dwStates )
+{
+	ScanState sState;
+
+	memset( ps->pColorRunTable, 1, dwStates );
+
+#ifdef DEBUG
+	if( dwStates > 800UL )
+		DBG( DBG_HIGH, "!!!!! RUNTABLE OVERFLOW !!!!!\n" );
+#endif
+	memset( ps->pColorRunTable + dwStates, 0xff, 800UL - dwStates );
+
+	IOGetCurrentStateCount( ps, &sState );
+    ps->bOldStateCount = sState.bStep;
+
+    /* TurnOnMotorAndSetDirection (); */
+    if( ps->Scan.fMotorBackward ) {
+		IOCmdRegisterToScanner( ps, ps->RegMotorControl,
+										(Byte)(ps->IgnorePF | ps->MotorOn));
+	} else {
+		IOCmdRegisterToScanner( ps, ps->RegMotorControl,
+				      (Byte)(ps->IgnorePF | ps->MotorOn | _MotorDirForward));
+	}
+
+    ps->pScanState = ps->pColorRunTable;
+    do {
+		ps->FillRunNewAdrPointer( ps );
+
+    } while (!motorCheckMotorPresetLength( ps ));
+}
+
+/*.............................................................................
+ * move the sensor to the scan-start position
+ */
+static void motorP96WaitForPositionY( pScanData ps )
+{
+/* scheint OKAY zu sein fuer OP4830 */
+#ifdef _A3I_EN
+#warning "compiling for A3I"
+	ULong     dw;
+	ScanState sState;
+
+	memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
+
+    ps->Asic96Reg.RD_MotorControl = ps->IgnorePF|ps->MotorOn|_MotorDirForward;
+    ps->Scan.fMotorBackward = _FALSE;
+    ps->bExtraMotorCtrl     = ps->IgnorePF;
+
+    if( ps->DataInf.xyAppDpi.y <= ps->PhysicalDpi )
+		dw = 30UL;
+    else
+		dw = 46UL;
+
+    dw = (dw + ps->DataInf.crImage.y) * 4 / 3;
+
+    if( ps->DataInf.wPhyDataType == COLOR_TRUE24 )
+		dw += 99; /* dwStepsForColor; */
+
+    else if( ps->DataInf.wPhyDataType == COLOR_256GRAY )
+	    dw += 99; /* dwStepsForGray; */
+	else
+	    dw += 99; /* dwStepsForBW; */
+
+    if( dw >= 130UL ) {
+
+		dw -= 100UL;
+		dw <<= 1;
+	    /* GoFullStep (dw); */
+
+		memset( ps->pColorRunTable, 1, dw );
+		memset( ps->pColorRunTable + dw, 0xff, ps->BufferForColorRunTable - dw );
+
+		IOGetCurrentStateCount( ps, &sState );
+		ps->bOldStateCount = sState.bStep;
+
+		/* AdjustMotorTime () */
+		IOCmdRegisterToScanner( ps, ps->RegLineControl, 31 );
+
+		/* SetRunHalfStep () */
+		if( ps->Scan.fMotorBackward )
+		    IOCmdRegisterToScanner( ps, ps->RegMotorControl, _Motor1FullStep |
+								    ps->IgnorePF | ps->MotorOn );
+		else
+		    IOCmdRegisterToScanner( ps, ps->RegMotorControl, ps->IgnorePF |
+										    ps->MotorOn | _MotorDirForward );
+
+		ps->pScanState = ps->pColorRunTable;
+
+		do {
+			ps->FillRunNewAdrPointer( ps );
+
+		} while (!motorCheckMotorPresetLength(ps));
+
+		/* RestoreMotorTime () */
+		IOCmdRegisterToScanner( ps, ps->RegLineControl,
+								ps->AsicReg.RD_LineControl );
+
+		dw = 100UL;
+    }
+
+    if( ps->DataInf.wPhyDataType != COLOR_TRUE24 )
+		dw += 20;
+
+	motorP96PositionYProc( ps, dw );
+
+#else
+
+	ULong	  dw;
+    ScanState sState;
+
+	TimerDef  timer;
+
+	MiscStartTimer( &timer, _SECOND / 4);
+    while (!MiscCheckTimer( &timer ));
+
+	memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
+
+    ps->Asic96Reg.RD_MotorControl = ps->IgnorePF|ps->MotorOn|_MotorDirForward;
+    ps->Scan.fMotorBackward = _FALSE;
+    ps->bExtraMotorCtrl     = ps->IgnorePF;
+
+    if ((ps->DataInf.wPhyDataType >= COLOR_TRUE24) ||
+											(ps->DataInf.xyAppDpi.y <= 300)) {
+		dw = 6UL;
+
+    } else {
+
+		if (ps->DataInf.xyAppDpi.y <= 600) {
+			/* 50 is from 6/300 */
+		    dw = (ULong)ps->DataInf.xyAppDpi.y / 50UL + 3UL;
+		} else
+		    dw = 15;	/* 6UL * 600UL / 300UL + 3; */
+    }
+
+    dw += ps->DataInf.crImage.y;
+
+    if (dw >= 180UL) {
+
+		dw -= 180UL;
+    	/* GoFullStep (ps, dw);----------------------------------------------*/
+		memset( ps->pColorRunTable, 1, dw );
+#ifdef DEBUG
+		if( dw > 8000UL )
+			DBG( DBG_HIGH, "!!!!! RUNTABLE OVERFLOW !!!!!\n" );
+#endif
+		memset( ps->pColorRunTable + dw, 0xff, 8000UL - dw );
+
+		IOGetCurrentStateCount( ps, &sState );
+		ps->bOldStateCount = sState.bStep;
+
+		/* SetRunFullStep (ps) */
+		if( ps->Scan.fMotorBackward ) {
+		    IOCmdRegisterToScanner( ps, ps->RegMotorControl,
+						  (Byte)(ps->FullStep | ps->IgnorePF | ps->MotorOn));
+		} else {
+		    IOCmdRegisterToScanner( ps, ps->RegMotorControl,
+						  (Byte)(ps->FullStep | ps->IgnorePF | ps->MotorOn |
+															_MotorDirForward));
+		}
+
+		ps->pScanState = ps->pColorRunTable;
+
+		do {
+			ps->FillRunNewAdrPointer (ps);
+
+		} while (!motorCheckMotorPresetLength(ps));
+
+		/*-------------------------------------------------------------------*/
+
+		dw = 180UL;
+    }
+
+	if (ps->DataInf.wPhyDataType != COLOR_TRUE24)
+		dw = dw * 2 + 16;
+    else
+		dw *= 2;
+
+	motorP96PositionYProc( ps, dw );
+#endif
+}
+
+/*.............................................................................
+ * Position Scan Module to specified line number (Forward or Backward & wait
+ * for paper flag ON)
+ */
+static void motorP96ConstantMoveProc1( pScanData ps, ULong dwLines )
+{
+	Byte	  bRemainder, bLastState;
+    UShort	  wQuotient;
+    ULong	  dwDelayMaxTime;
+    ScanState StateStatus;
+	TimerDef  timer;
+	Bool	  fTimeout = _FALSE;
+
+	/* state cycles */
+    wQuotient  = (UShort)(dwLines / _NUMBER_OF_SCANSTEPS);
+    bRemainder = (Byte)(dwLines % _NUMBER_OF_SCANSTEPS);
+
+	/* 3.3 ms per line */
+#ifdef _A3I_EN
+    dwDelayMaxTime = dwLines * _MOTOR_ONE_LINE_TIME + _SECOND * 2;
+#else
+    dwDelayMaxTime = dwLines * _MOTOR_ONE_LINE_TIME + _SECOND * 20;
+#endif
+
+	/* step every time */
+	MotorSetConstantMove( ps, 1 );
+
+    ps->OpenScanPath( ps );
+
+    ps->AsicReg.RD_ModeControl = _ModeScan;
+    IODataToRegister( ps, ps->RegModeControl, _ModeScan );
+
+    ps->Asic96Reg.RD_MotorControl = ps->MotorFreeRun |
+											ps->MotorOn | _MotorDirForward;
+	IODataToRegister( ps, ps->RegMotorControl, ps->Asic96Reg.RD_MotorControl );
+
+    ps->CloseScanPath( ps );
+
+    bLastState = 0;
+
+	MiscStartTimer( &timer, dwDelayMaxTime );
+
+    do {
+
+		/* GetStatusAndScanStateAddr () */
+		motorP96GetScanStateAndStatus( ps, &StateStatus );
+		if (StateStatus.bStatus & _FLAG_P96_PAPER ) {
+		    if (wQuotient)  {
+
+				if (StateStatus.bStep != bLastState) {
+				    bLastState = StateStatus.bStep;
+
+				    if (!bLastState)
+						wQuotient--;
+				}
+		    } else
+				if (StateStatus.bStep >= bRemainder)
+				    break;
+			} else
+			    break;
+    } while (!(fTimeout = MiscCheckTimer( &timer )));
+
+    if (!fTimeout) {
+		memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
+		IOSetToMotorRegister( ps );
+    }
+}
+
+/*.............................................................................
+ * PreMove/EndMove
+ * PreMove is only in ADF and CFB mode
+ * In ADF version, there is a distance gap between Paper flag and Real initial
+ *   position and it need premove to real initial position and turn the motor
+ *   Inverse and start Fast move to start scan position
+ * In CFB version , PreMove 1 mm to avoid bouncing of PaperFlag sensor then
+ *   fast move
+ * In CIS and CSP although there have not PreMove but there have End move
+ *   when paper out there still have several mm need to read,
+ *   So it need EndMove 2mm and set Inverse Paper
+ */
+static Bool motorP96GotoShadingPosition( pScanData ps )
+{
+	DBG( DBG_LOW, "motorP96GotoShadingPosition()\n" );
+
+	MotorSetConstantMove( ps, 0 );		/* clear scan states */
+    ps->Scan.fMotorBackward = _FALSE;	/* forward			 */
+    ps->bExtraMotorCtrl     = ps->IgnorePF;
+
+	MotorP96ConstantMoveProc( ps, 15 * 12 ); 	/* forward 180 lines */
+
+    if (IODataRegisterFromScanner(ps, ps->RegStatus) & _FLAG_P96_PAPER ) {
+		ps->Asic96Reg.RD_MotorControl = 0;
+		IOCmdRegisterToScanner( ps, ps->RegMotorControl, 0 );
+
+		DBG( DBG_LOW, "motorP96GotoShadingPosition() failed\n" );
+		return _FALSE;
+    }
+    ps->Scan.fMotorBackward = _TRUE;	/* backward					 */
+    ps->bExtraMotorCtrl     = 0;	    /* no extra action for motor */
+
+	/* backward a few thousand lines to touch sensor */
+ 	MotorP96ConstantMoveProc( ps, ps->BackwardSteps );
+
+	_DODELAY( 250 );
+
+	IOCmdRegisterToScanner( ps, ps->RegModelControl,
+					  (Byte)(ps->AsicReg.RD_ModelControl | _ModelInvertPF));
+
+    ps->Scan.fMotorBackward = _FALSE;				/* forward 			*/
+    motorP96ConstantMoveProc1( ps, 14 * 12 * 2);	/* ahead 336 lines	*/
+
+	if( MODEL_OP_A3I == ps->sCaps.Model ) {
+
+		motorP96PositionYProc( ps, 80 );
+
+	} else {
+		/* forward 24 + pScanData->wOverBlue lines */
+    	if (!ps->fColorMoreRedFlag)
+			motorP96PositionYProc( ps, ps->wOverBlue + 12 * 2);
+	}
+
+    if( ps->DataInf.dwScanFlag & SCANDEF_TPA ) {
+		ps->Scan.fMotorBackward = _FALSE;
+		ps->bExtraMotorCtrl     = ps->IgnorePF;
+		MotorP96ConstantMoveProc( ps, 1200 );
+    }
+
+	IOCmdRegisterToScanner( ps, ps->RegModelControl,
+												ps->AsicReg.RD_ModelControl );
+    return _TRUE;
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP96FillHalfStepTable( pScanData ps )
+{
+#ifdef _A3I_EN
+	if ( ps->Scan.bModuleState == _MotorInStopState ) {
+
+		/* clear the table and get the step value */
+		memset( a_bHalfStepTable, 0, _NUMBER_OF_SCANSTEPS );
+		ps->bMotorStepTableNo = a_bMotorDown2Table[(ps->bMotorSpeedData-1)/2];
+    }
+
+	/* the fastest stepping */
+    if( ps->bMotorSpeedData & 1 ) {
+
+		memset( a_bHalfStepTable,
+		       ((ps->Scan.bModuleState != _MotorInStopState) ? 1 : 0),
+														_NUMBER_OF_SCANSTEPS );
+	} else {
+
+		pUChar   pbHalfStepTbl;
+		Byte     bHalfSteps;
+		pUShort	 pwMoveStep;
+		DataType Data;
+
+		bHalfSteps    = ps->bMotorSpeedData / 2;
+		pwMoveStep    = &a_wMoveStepTable[ps->bCurrentLineCount];
+		pbHalfStepTbl = &a_bHalfStepTable[ps->bCurrentLineCount];
+
+		if( ps->DataInf.wAppDataType == COLOR_TRUE24)
+		    Data.dwValue = _NUMBER_OF_SCANSTEPS - 1;
+		else
+		    Data.dwValue = _NUMBER_OF_SCANSTEPS;
+
+		/* FillDataToHalfStepTable */
+		for(; Data.dwValue; Data.dwValue-- ) {
+
+		    if( *pwMoveStep ) {		/* need to exposure */
+
+				if( Data.bValue >= bHalfSteps ) {
+
+				    pUChar pb = pbHalfStepTbl + bHalfSteps;
+
+				    /* AdjustHalfStepStart */
+				    if( ps->DataInf.wAppDataType == COLOR_TRUE24 ) {
+
+						if (bHalfSteps >= 2)
+						    pb -= (bHalfSteps - 1);
+				    }
+				    if( pb >= pbEndHalfStepTable )
+						pb -= _NUMBER_OF_SCANSTEPS;
+
+				    if( wP96BaseDpi <= ps->PhysicalDpi && *pwMoveStep != 2 )
+						*pb = 1;
+
+		    		pb += bHalfSteps;
+
+				    if( pb >= pbEndHalfStepTable )
+						pb -= _NUMBER_OF_SCANSTEPS;
+
+				    *pb = 1;
+				}
+				else
+				    *pwMoveStep = 0;		/* idle state */
+		    }
+		    if( ++pwMoveStep >= pwEndMoveStepTable ) {
+				pwMoveStep = a_wMoveStepTable;
+
+				pbHalfStepTbl = a_bHalfStepTable;
+		    }
+		    else
+				pbHalfStepTbl++;
+		}
+    }
+
+#else
+
+#ifdef DEBUG
+	if( 0 == wP96BaseDpi )
+		DBG( DBG_HIGH, "!!!! WARNING - motorP96FillHalfStepTable(), "
+					   "wP96BaseDpi == 0 !!!!\n" );
+#endif
+
+	if ( ps->Scan.bModuleState == _MotorInStopState ) {
+
+		/* clear the table and get the step value */
+		memset( a_bHalfStepTable, 0, _NUMBER_OF_SCANSTEPS );
+		ps->bMotorStepTableNo = a_bMotorDown2Table[(ps->bMotorSpeedData-1)/2];
+    }
+
+	/* the fastest stepping */
+    if( ps->bMotorSpeedData & 1 ) {
+
+		memset( a_bHalfStepTable,
+		       ((ps->Scan.bModuleState != _MotorInStopState) ? 1 : 0),
+														_NUMBER_OF_SCANSTEPS );
+	} else {
+
+		pUChar   pbHalfStepTbl, pbHalfStepContent;
+		pUShort	 pwMoveStep;
+		DataType Data;
+
+		pbHalfStepContent = a_pbHalfStepTables[ps->bMotorSpeedData / 2 - 1];
+
+		pwMoveStep    = &a_wMoveStepTable[ps->bCurrentLineCount];
+		pbHalfStepTbl = &a_bHalfStepTable[ps->bCurrentLineCount];
+
+		if (ps->DataInf.wAppDataType == COLOR_TRUE24)
+		    Data.dwValue = _NUMBER_OF_SCANSTEPS - 1;
+		else
+		    Data.dwValue = _NUMBER_OF_SCANSTEPS;
+
+		/* FillDataToHalfStepTable */
+		for (; Data.dwValue; Data.dwValue--) {
+
+		    if (*pwMoveStep) {		/* need to exposure */
+
+				if (Data.bValue >= *pbHalfStepContent) {
+
+				    pUChar pb = pbHalfStepTbl + *pbHalfStepContent;
+
+					if (pb >= pbEndHalfStepTable)
+						pb -= _NUMBER_OF_SCANSTEPS;
+
+				    /* JudgeStep1 () */
+				    if ((wP96BaseDpi != 600) && (*pwMoveStep != 2)) {
+						if (ps->Scan.bModuleState != _MotorInStopState) {
+						    *pb = 1;
+						} else {
+						    if (ps->bMotorStepTableNo) {
+								ps->bMotorStepTableNo--;
+								*pb = 1;
+			    			}
+						}
+					}
+
+				    pb += *pbHalfStepContent;
+				    if (pb >= pbEndHalfStepTable)
+						pb -= _NUMBER_OF_SCANSTEPS;
+
+				    /* JudgeStep2 () */
+				    if (ps->Scan.bModuleState == _MotorInStopState) {
+						if (ps->bMotorStepTableNo) {
+						    ps->bMotorStepTableNo--;
+						    *pb = 1;
+						}
+				    } else {
+						*pb = 1;
+					}
+
+					pbHalfStepContent++;
+				} else {
+				    *pwMoveStep = 0;		/* idle state */
+				}
+			}
+
+		    if (++pwMoveStep >= pwEndMoveStepTable) {
+				pwMoveStep = a_wMoveStepTable;
+				pbHalfStepTbl = a_bHalfStepTable;
+		    } else {
+				pbHalfStepTbl++;
+			}
+		}
+    }
+#endif
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP96FillDataToColorTable( pScanData ps,
+										  Byte bIndex, ULong dwSteps)
+{
+    Byte	 bColor, bColors;
+	pUChar	 pb, pb1;
+	pUShort	 pw;
+    DataType Data;
+
+    for (pb = &a_bColorByteTable[bIndex],
+		 pw = &a_wMoveStepTable[bIndex]; dwSteps; dwSteps--) {
+
+		if (*pw) {				/* valid state */
+
+			if( *pw >= ps->BufferForColorRunTable ) {
+				DBG( DBG_LOW, "*pw = %u > %u !!\n",
+						*pw, ps->BufferForColorRunTable );
+			} else {
+
+			    bColor  = ps->pColorRunTable [*pw];	/* get the colors	*/
+			    bColors = a_bColorsSum [bColor & 7];/* number of colors */
+
+			    if (bColors) {						/* need to read data */
+					if (dwSteps >= bColors) { 		/* enough room 		 */
+
+		    			/* separate the colors to byte */
+					    pb1 = pb;
+				    	if (bColor & ps->b1stColor) {
+
+							*pb1 = ps->b1stColorByte;
+							if (++pb1 >= pbEndColorByteTable)
+							    pb1 = a_bColorByteTable;
+					    }
+
+					    if (bColor & ps->b2ndColor) {
+
+							*pb1 = ps->b2ndColorByte;
+							if (++pb1 >= pbEndColorByteTable)
+							    pb1 = a_bColorByteTable;
+					    }
+
+				    	if (bColor & ps->b3rdColor)
+							*pb1 = ps->b3rdColorByte;
+					} else
+					    *pw = 0;
+	    		}
+			}
+		}
+
+		if (++pw >= pwEndMoveStepTable) {
+		    pw = a_wMoveStepTable;
+		    pb = a_bColorByteTable;
+		} else
+		    pb++;
+    }
+
+/*     ps->bOldSpeed = ps->bMotorRunStatus; non functional */
+
+    /* ToCondense, CondenseColorByteTable */
+    for (dwSteps = _SCANSTATE_BYTES, pw = (pUShort)a_bColorByteTable,
+		 pb = ps->a_nbNewAdrPointer; dwSteps; dwSteps--, pw++, pb++) {
+
+		Data.wValue = *pw & 0x0303;
+		*pb = Data.wOverlap.b1st | (Data.wOverlap.b2nd << 4);
+    }
+
+    /* ToCondenseMotor */
+    for (dwSteps = _SCANSTATE_BYTES, pb1 = a_bHalfStepTable,
+		 pb = ps->a_nbNewAdrPointer; dwSteps; dwSteps--, pb1++, pb++) {
+
+		if (*pb1++)
+		    *pb |= 4;
+
+		if (*pb1)
+		    *pb |= 0x40;
+    }
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP96FillBackColorDataTable( pScanData ps )
+{
+	Byte	bIndex;
+	ULong	dw;
+
+    if ((ps->bCurrentLineCount + ps->bNewCurrentLineCountGap + 1) >=
+    													_NUMBER_OF_SCANSTEPS){
+		bIndex = ps->bCurrentLineCount + ps->bNewCurrentLineCountGap + 1 -
+				 _NUMBER_OF_SCANSTEPS;
+	} else {
+		bIndex = ps->bCurrentLineCount + ps->bNewCurrentLineCountGap + 1;
+	}
+    dw = _NUMBER_OF_SCANSTEPS - ps->bNewCurrentLineCountGap;
+
+    motorP96FillDataToColorTable( ps, bIndex, dw );
+}
+
+/*.............................................................................
+ * i/p:
+ *    pScanStep = pScanData->pColorRunTable if forward, a_bScanStateTable if backward
+ *    dwState = how many states is requested to process
+ * NOTE:
+ *    The content of pScanStep contain:
+ *    0: Idle state
+ *    0xff: End mark
+ *    others: The motor speed value
+ */
+static void motorP96FillBackLoop( pScanData ps,
+								  pUChar pScanStep, ULong dwStates )
+{
+    for (; dwStates; dwStates--) {
+
+		if (*pScanStep == 0xff)
+		    break;					/* end of states */
+
+		if (*pScanStep) {
+		    if (*pScanStep == 1) {	/* speed == 1, this state has to step */
+
+				if (ps->dwScanStateCount & 1)
+				    ps->a_nbNewAdrPointer[ps->dwScanStateCount / 2] |= 0x40;
+				else
+				    ps->a_nbNewAdrPointer[ps->dwScanStateCount / 2] |= 0x04;
+			}
+
+		    *pScanStep -= 1;		/* speed decrease by 1 */
+
+		    if (!(*pScanStep))
+				pScanStep++;		/* state processed */
+		} else
+		    pScanStep++;			/* skip this state */
+
+		if (++ps->dwScanStateCount == _NUMBER_OF_SCANSTEPS)
+		    ps->dwScanStateCount = 0;					/* reset to begin */
+	}
+
+    if (*pScanStep != 0xff)
+		ps->fFullLength = _FALSE;
+    else
+		ps->fFullLength = _TRUE;
+
+    IOSetToMotorStepCount( ps );		/* put all scan states to ASIC */
+}
+
+/*.............................................................................
+ * 1) Clear scan states
+ * 2) Adjust the new scan state
+ */
+static void motorP96FillRunNewAdrPointer( pScanData ps )
+{
+	ScanState sState;
+
+	memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES);
+
+	IOGetCurrentStateCount( ps, &sState );
+
+    if (sState.bStep < ps->bOldStateCount )
+		sState.bStep += _NUMBER_OF_SCANSTEPS;/* over table (table just can   */
+											 /* holds 64 step, then reset to */
+											 /* 0, so if less than means over*/
+											 /* the table)					*/
+
+	sState.bStep -= ps->bOldStateCount;		 /* how many states passed */
+    ps->pScanState += sState.bStep;
+
+    /*
+	 * if current state != no stepped or stepped a cycle, fill the table with
+	 * 1 in NOT STEPPED length. (1 means to this state has to be processing).
+	 */
+    if (sState.bStep && sState.bStep != (_NUMBER_OF_SCANSTEPS - 1))
+		memset( ps->pScanState, 1, _NUMBER_OF_SCANSTEPS - sState.bStep - 1 );
+
+	IOGetCurrentStateCount( ps, &sState);
+    ps->bOldStateCount   = sState.bStep;			/* update current state */
+    ps->dwScanStateCount = (ULong)((sState.bStep + 1) & (_NUMBER_OF_SCANSTEPS - 1));
+
+	/* fill begin at next step */
+ 	motorP96FillBackLoop( ps, ps->pScanState, (_NUMBER_OF_SCANSTEPS - 1));
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP96SetupRunTable( pScanData ps )
+{
+	Short		siSum;
+	UShort		wLoop;
+	UShort		wLengthY;
+	DataPointer	p;
+
+	DBG( DBG_LOW, "motorP96SetupRunTable()\n" );
+
+    /* SetMaxDpiAndLength (ps) */
+#ifdef _A3I_EN
+    if( ps->DataInf.xyPhyDpi.y > ps->PhysicalDpi ) {
+
+		wLengthY    = 6800 * 2;
+		wP96BaseDpi = ps->PhysicalDpi *2;
+    } else {
+		wLengthY    = 6800;
+		wP96BaseDpi = ps->LensInf.rDpiY.wPhyMax >> 1;
+    }
+#else
+    if( ps->DataInf.xyPhyDpi.y > (ps->LensInf.rDpiY.wPhyMax / 2)) {
+
+		wLengthY    = ps->LensInf.rExtentY.wMax << 1;
+		wP96BaseDpi = ps->LensInf.rDpiY.wPhyMax;
+    } else {
+		wLengthY    = ps->LensInf.rExtentY.wMax;
+		wP96BaseDpi = ps->LensInf.rDpiY.wPhyMax >> 1;
+    }
+#endif
+
+	DBG( DBG_LOW, "wLengthY = %u, wP96BaseDpi = %u\n", wLengthY, wP96BaseDpi );
+
+    /* ClearColorRunTable (ps) */
+	memset( ps->pColorRunTable, 0, ps->BufferForColorRunTable ); /*wLengthY + 0x60 ); */
+
+    p.pb = ps->pColorRunTable + _SCANSTATE_BYTES;
+#ifdef _A3I_EN
+    wLoop = wLengthY + 200;
+#else
+    wLoop = wLengthY + 0x20;
+#endif
+    siSum = (Short)wP96BaseDpi;
+
+    if (ps->DataInf.wPhyDataType != COLOR_TRUE24) {
+		for (; wLoop; wLoop--, p.pb++)	{
+		    if ((siSum -= (Short)ps->DataInf.xyPhyDpi.y) <= 0) {
+				siSum += (Short)wP96BaseDpi;
+				*p.pb = _COLORRUNTABLE_GREEN;
+	    	}
+		}
+
+#ifdef _A3I_EN
+		memset( ps->pColorRunTable + _NUMBER_OF_SCANSTEPS / 8 + wLengthY,
+																0x77, 0x100 );
+#endif
+    } else {
+		/* CalColorRunTable */
+		DataType Data;
+
+		if (ps->fSonyCCD) {
+
+			if((ps->sCaps.Model == MODEL_OP_12000P) ||
+                                           (ps->sCaps.Model == MODEL_OP_A3I)) {
+				Data.wValue = (_COLORRUNTABLE_RED << 8) | _COLORRUNTABLE_BLUE;
+			} else {
+				Data.wValue = (_COLORRUNTABLE_GREEN << 8) | _COLORRUNTABLE_BLUE;
+			}
+		} else {
+			Data.wValue = (_COLORRUNTABLE_BLUE << 8) | _COLORRUNTABLE_GREEN;
+		}
+
+		for (; wLoop; wLoop--, p.pb++)	{
+
+		    if ((siSum -= (Short)ps->DataInf.xyPhyDpi.y) <= 0) {
+				siSum += (Short)wP96BaseDpi;
+
+    			if((ps->sCaps.Model == MODEL_OP_12000P)|| 
+                                           (ps->sCaps.Model == MODEL_OP_A3I)) {
+					*p.pb |= _COLORRUNTABLE_GREEN;
+                } else {
+					*p.pb |= _COLORRUNTABLE_RED;
+                }
+
+				/* Sony:Green,Toshiba:Blue */
+				*(p.pb + 8)  |= Data.wOverlap.b2nd;
+				*(p.pb + 16) |= Data.wOverlap.b1st;
+		    }
+		}
+
+#ifdef _A3I_EN
+		memset( ps->pColorRunTable + _NUMBER_OF_SCANSTEPS / 8 + wLengthY,
+																0x77, 0x100 );
+#endif
+		if (ps->DataInf.xyPhyDpi.y < 100) {
+
+		    Byte bColor;
+
+		    /* CheckColorTable () */
+		    if (ps->fSonyCCD)
+				Data.wValue = 0xdd22;
+		    else
+				Data.wValue = 0xbb44;
+
+		    for (wLoop = wLengthY - _SCANSTATE_BYTES,
+				 p.pb = ps->pColorRunTable + _SCANSTATE_BYTES;
+												 wLoop; wLoop--, p.pb++) {
+				bColor = 0;
+
+				switch (a_bColorsSum[*p.pb & 0x0f]) {
+
+			    case 3:
+					if (*(p.pb + 2))
+					    bColor = 1;
+			    case 2:
+					if (*(p.pb + 1))
+			    		bColor++;
+					if (bColor == 2) {
+					    *p.pb &= ~_COLORRUNTABLE_RED;
+					    *(p.pb - 2) = _COLORRUNTABLE_RED;
+					}
+
+					if (bColor) {
+				    	if (*p.pb & ps->RedDataReady) {
+							*p.pb &= ~_COLORRUNTABLE_RED;
+							*(p.pb - 1) = _COLORRUNTABLE_RED;
+					    } else {
+							*p.pb &= Data.wOverlap.b2nd;
+							*(p.pb - 1) = Data.wOverlap.b1st;
+				    	}
+					}
+				}
+	    	}
+		}
+	}
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP96UpdateDataCurrentReadLine( pScanData ps )
+{
+	ScanState	State1, State2;
+	TimerDef	timer;
+
+	IOGetCurrentStateCount( ps, &State1 );
+	IOGetCurrentStateCount( ps, &State2 );
+
+    if (State1.bStatus == State2.bStatus) {
+
+		if (!(State2.bStatus & _SCANSTATE_STOP)) {
+
+		    /* motor still running */
+		    if (State2.bStep < ps->bCurrentLineCount) {
+				State2.bStep = State2.bStep + _NUMBER_OF_SCANSTEPS -
+												       ps->bCurrentLineCount;
+			} else
+				State2.bStep -= ps->bCurrentLineCount;
+
+		    if (State2.bStep >= (_NUMBER_OF_SCANSTEPS - 3)) {
+
+				MiscStartTimer( &timer, _SECOND );
+
+				do {
+				    State2.bStatus = IOGetScanState( ps, _FALSE );
+
+				} while (!(State2.bStatus & _SCANSTATE_STOP) &&
+						 !MiscCheckTimer( &timer ));
+		    } else
+				if (State2.bStep < 40)
+				    return;
+		}
+
+#ifdef _A3I_EN
+		if( ps->bFifoCount >= 140) {
+#else
+		if( ps->bFifoCount >= 20) {
+#endif
+		    if( 1 == ps->bCurrentSpeed ) {
+				ps->bCurrentSpeed *= 2;
+		    } else {
+				if( COLOR_TRUE24 == ps->DataInf.wPhyDataType )
+		    		ps->bCurrentSpeed += 4;
+				else
+				    ps->bCurrentSpeed += 2;
+			}
+
+	    	MotorP96AdjustCurrentSpeed( ps, ps->bCurrentSpeed );
+		}
+
+		/*
+		 * when using the full-step speed on 600 dpi models, then set
+		 * the motor into half-step mode, to avoid that the scanner hits
+		 * the back of its bed
+		 */
+/* HEINER:A3I */
+#if 1
+    	if((600 == ps->PhysicalDpi) && (1 == ps->bCurrentSpeed)) {
+
+			if( ps->Asic96Reg.RD_MotorControl & ps->FullStep ) {
+				ps->Asic96Reg.RD_MotorControl &= ~ps->FullStep;
+    			IOCmdRegisterToScanner( ps, ps->RegMotorControl,
+											   ps->Asic96Reg.RD_MotorControl );
+			}
+		}
+#endif
+		ps->SetMotorSpeed( ps, ps->bCurrentSpeed, _TRUE );
+
+		IOSetToMotorRegister( ps);
+    }
+}
+
+/*.............................................................................
+ * 1) Save the current scan state
+ * 2) Set the motor direction
+ */
+static void motorGoHalfStep1( pScanData ps )
+{
+	ScanState sState;
+
+    IOGetCurrentStateCount( ps, &sState );
+
+	ps->bOldStateCount = sState.bStep;
+
+	motorSetRunPositionRegister(ps);
+   	ps->pScanState = a_bScanStateTable;
+
+	if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
+
+		ps->FillRunNewAdrPointer( ps );
+
+		while (!motorCheckMotorPresetLength(ps))
+			motorP98FillRunNewAdrPointer1( ps );
+	} else {
+
+	    while (!motorCheckMotorPresetLength( ps ))
+			ps->FillRunNewAdrPointer( ps );
+	}
+}
+
+/*.............................................................................
+ * when loosing data, we use this function to go back some lines and read them
+ * again...
+ */
+static void motorP96WaitBack( pScanData ps )
+{
+	DataPointer	p;
+	DataType	Data;
+	ULong		dw;
+	UShort		w;
+	UShort		wStayMaxStep;
+
+    /* FindMaxMoveStepIndex () */
+
+    p.pw = a_wMoveStepTable;
+
+    for( Data.dwValue = _NUMBER_OF_SCANSTEPS, wStayMaxStep = 1; Data.dwValue;
+													 Data.dwValue--, p.pw++ )
+		if( *p.pw > wStayMaxStep )
+		    wStayMaxStep = *p.pw;	/* save the largest step number */
+
+    if( ps->DataInf.xyPhyDpi.y > ps->PhysicalDpi )
+		wStayMaxStep -= 40;
+    else
+		wStayMaxStep -= 20;
+
+    IORegisterDirectToScanner( ps, ps->RegInitDataFifo );
+
+    memset( a_bScanStateTable, 1, _P96_BACKMOVES );
+    memset(&a_bScanStateTable[_P96_BACKMOVES], 0xff, 250 - _P96_BACKMOVES );
+
+    ps->Scan.fMotorBackward = _TRUE;
+    motorGoHalfStep1( ps );			/* backward 130 lines */
+
+    _DODELAY(200);			/* let the motor stable */
+
+    if( ps->DataInf.xyPhyDpi.y <= ps->PhysicalDpi ) {
+		if( ps->DataInf.wPhyDataType == COLOR_TRUE24 ) {
+		    dw = _P96_FORWARDMOVES - 1;
+		} else {
+	    	dw = _P96_FORWARDMOVES - 2;
+		}
+    } else {
+		dw = _P96_FORWARDMOVES;
+	}
+	
+	memset( a_bScanStateTable, 1, dw );
+    memset(&a_bScanStateTable[dw], 0xff, 250 - dw );
+
+    ps->Scan.fMotorBackward = _FALSE;
+    motorGoHalfStep1( ps );			/* move forward */
+
+    /* GetNowStepTable () */
+    ps->bCurrentLineCount = IOGetScanState( ps, _FALSE ) & _SCANSTATE_MASK;
+    ps->bNewCurrentLineCountGap = 0;
+
+    /* ClearColorByteTable () */
+    memset( a_bColorByteTable, 0, _NUMBER_OF_SCANSTEPS );
+
+    /* ClearHalfStepTable () */
+    memset( a_bHalfStepTable, 0, _NUMBER_OF_SCANSTEPS );
+
+    /* FillWaitMoveStepTable () */
+    p.pw = &a_wMoveStepTable[((ps->bCurrentLineCount + 1) & 0x3f)];
+    *p.pw = 1;
+    p.pw++;
+
+    for(w = wStayMaxStep, Data.bValue = ps->bMotorSpeedData, dw = 60;dw;dw--) {
+
+		if( p.pw >= pwEndMoveStepTable ) /* make sure pointer in range */
+		    p.pw = a_wMoveStepTable;
+
+		if (--Data.bValue)
+		    *p.pw = 0;			    			/* don't step */
+		else {
+		    Data.bValue = ps->bMotorSpeedData;  /* speed value       		 */
+		    *p.pw = w;			    			/* the ptr to pColorRunTable */
+		    w++;			    				/* pointer++ 				 */
+		}
+
+		p.pw++; 			    				/* to next entry */
+    }
+	motorP96FillHalfStepTable( ps );
+	motorP96FillBackColorDataTable( ps );
+}
+
+/*.............................................................................
+ * when loosing data, we use this function to go back some lines and read them
+ * again...
+ */
+static void motorP98WaitBack( pScanData ps )
+{
+	DataPointer	p;
+	DataType	Data;
+	ULong		dw;
+	UShort		w;
+	UShort		wStayMaxStep;
+	UShort		back, forward;
+
+    p.pw = &a_wMoveStepTable[ps->bCurrentLineCount];
+
+    if (0 == *p.pw) {
+
+		for (w = _NUMBER_OF_SCANSTEPS; w && !*p.pw; w--) {
+		    p.pw--;
+		    if (p.pw < a_wMoveStepTable)
+				p.pw = &a_wMoveStepTable[_NUMBER_OF_SCANSTEPS - 1];
+		}
+		wStayMaxStep = *p.pw + 1;
+    } else {
+		wStayMaxStep = *p.pw;	    /* save the largest step number */
+	}
+
+	if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
+
+		forward = _P98_FORWARDMOVES;
+		back	= _P98_BACKMOVES;
+	} else {
+		forward = _P96_FORWARDMOVES;
+		back	= _P96_BACKMOVES;
+	}
+
+	/*
+	 * Off to avoid the problem of block data re-read/lost
+	 */
+	memset( a_bScanStateTable, 1, back );
+	memset( &a_bScanStateTable[back], 0xff, (_SCANSTATE_TABLE_SIZE - back));
+	ps->Scan.fMotorBackward = _TRUE;
+    motorGoHalfStep1( ps );
+
+    _DODELAY(200);			/* let the motor stable */
+
+    memset(a_bScanStateTable, 1, forward );
+    memset(&a_bScanStateTable[forward], 0xff, (_SCANSTATE_TABLE_SIZE-forward));
+	ps->Scan.fMotorBackward = _FALSE;
+	motorGoHalfStep1( ps );
+
+    ps->bNewCurrentLineCountGap = 0;
+
+    memset( a_bColorByteTable, 0, _NUMBER_OF_SCANSTEPS );
+	memset( a_bHalfStepTable,  0, _NUMBER_OF_SCANSTEPS );
+
+	ps->bCurrentLineCount = (ps->bCurrentLineCount + 1) & 0x3f;
+
+    p.pw = &a_wMoveStepTable[ps->bCurrentLineCount];
+
+    for (w = wStayMaxStep, Data.bValue = ps->bMotorSpeedData,
+							    			dw = _NUMBER_OF_SCANSTEPS; dw; dw--) {
+		if (--Data.bValue) {
+		    *p.pw = 0;			    	/* don't step */
+		} else {
+
+			/* speed value */
+		    Data.bValue = ps->bMotorSpeedData;
+	    	*p.pw = w;	    		    	/* the pointer to pColorRunTable*/
+		    w++;			    			/* pointer++                    */
+	}
+	/* make sure pointer in range */
+	if (++p.pw >= pwEndMoveStepTable)
+	    p.pw = a_wMoveStepTable;
+    }
+
+	if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
+		motorP98FillHalfStepTable( ps );
+		motorP98FillBackColorDataTable( ps );
+	} else {
+		motorP96FillHalfStepTable( ps );
+		motorP96FillBackColorDataTable( ps );
+	}
+}
+
+/*.............................................................................
+ *
+ */
+static void motorFillMoveStepTable( pScanData ps,
+								    UShort wIndex, Byte bStep, pUShort pw )
+{
+    UShort w;
+    Byte   b;
+
+    if (++pw >= pwEndMoveStepTable )
+		pw = a_wMoveStepTable;
+
+    wIndex++;
+
+    b = ps->bMotorSpeedData;
+
+    for (w = _NUMBER_OF_SCANSTEPS - bStep; w; w--) {
+		if (b == 1) {
+		    b = ps->bMotorSpeedData;
+		    *pw = wIndex;
+	    	wIndex++;
+		} else {
+		    b--;
+		    *pw = 0;
+		}
+		if (++pw >= pwEndMoveStepTable)
+	    	pw = a_wMoveStepTable;
+    }
+
+	if( _ASIC_IS_98001 == ps->sCaps.AsicID )
+		motorP98FillHalfStepTable( ps );
+	else
+		motorP96FillHalfStepTable( ps );
+
+    if ((ps->bCurrentLineCount + 1) >= _NUMBER_OF_SCANSTEPS) {
+		b = ps->bCurrentLineCount + 1 - _NUMBER_OF_SCANSTEPS;
+    } else {
+		b = ps->bCurrentLineCount + 1;
+	}
+
+	if( _ASIC_IS_98001 == ps->sCaps.AsicID )
+		motorP98FillDataToColorTable( ps, b, _NUMBER_OF_SCANSTEPS - 1);
+	else
+		motorP96FillDataToColorTable( ps, b, _NUMBER_OF_SCANSTEPS - 1);
+}
+
+/*.............................................................................
+ *
+ */
+static void noMotorRunStatusStop( pScanData ps, Byte bScanState )
+{
+    Byte  	b, b1, bCur;
+    pUShort pw;
+    pByte	pb;
+    UShort  w;
+
+    ps->bCurrentLineCount = (bScanState & _SCANSTATE_MASK);
+
+    ps->Scan.fRefreshState  = _FALSE;
+
+    IORegisterDirectToScanner( ps, ps->RegRefreshScanState );
+
+    bCur = ps->bCurrentLineCount;
+    pw 	 = &a_wMoveStepTable[bCur];
+    pb 	 = ps->pColorRunTable;
+	b    = 0;
+    b1 	 = 0;
+    w 	 = _NUMBER_OF_SCANSTEPS;
+
+    if (*pw) {
+		b = a_bColorsSum[pb [*pw] >> 4];
+		if (b) {
+		    motorClearColorByteTableLoop0( ps, b );
+		    ps->bNewCurrentLineCountGap = b;
+
+	    	motorFillMoveStepTable( ps, *pw, 1, pw );
+		    return;
+		}
+		b1++;
+		bCur--;
+
+		if (--pw < a_wMoveStepTable) {
+		    pw = &a_wMoveStepTable [_NUMBER_OF_SCANSTEPS - 1];
+		    bCur = _NUMBER_OF_SCANSTEPS - 1;
+		}
+    }
+
+    for(; w; w--) {
+		if (*pw) {
+		    if (*pw < _SCANSTATE_BYTES) {
+				b = 0;
+				break;
+		    } else
+				if ((b = a_bColorsSum [pb [*pw] >> 4]))
+				    break;
+		}
+		b1++;
+		bCur--;
+
+		if (--pw < a_wMoveStepTable) {
+		    pw = &a_wMoveStepTable [_NUMBER_OF_SCANSTEPS - 1];
+	   		bCur = _NUMBER_OF_SCANSTEPS - 1;
+		}
+	}
+
+	if (b1 == _NUMBER_OF_SCANSTEPS) {
+		ps->bNewCurrentLineCountGap = 0;
+		ps->bNewGap = 0;
+	} else {
+		ps->bNewCurrentLineCountGap = b1;
+		ps->bNewGap = b;
+	}
+
+    motorClearColorByteTableLoop1( ps );
+
+	motorFillMoveStepTable( ps, *pw, 0, pw);
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP96SetSpeed( pScanData ps, Byte bSpeed, Bool fSetRunState )
+{
+#if 0
+    PUCHAR	pb;
+    Byte	 bScanState;
+#endif
+	Byte     bState, bData;
+	UShort   wMoveStep;
+	pUShort  pw;
+	ULong    dw;
+	TimerDef timer;
+
+    if( fSetRunState )
+		ps->Scan.bModuleState = _MotorInNormalState;
+
+    ps->bMotorSpeedData = bSpeed;
+
+    if( ps->bMoveDataOutFlag == _DataAfterRefreshState) {
+
+		ps->bMoveDataOutFlag = _DataInNormalState;
+
+		MiscStartTimer( &timer, (_SECOND /2));
+
+		while (!MiscCheckTimer(&timer)) {
+		    if ((bState = IOGetScanState( ps, _FALSE)) & _SCANSTATE_STOP) {
+				ps->bCurrentLineCount = bState & ~_SCANSTATE_STOP;
+				motorP96WaitBack( ps );
+				return;
+	    	}
+		}
+    }
+
+    bState = IOGetScanState( ps, _FALSE );
+
+    if((ps->Scan.bModuleState != _MotorInStopState) ||
+												!(bState & _SCANSTATE_STOP)) {
+
+		/* Try to find the available step for all rest steps.
+		 * 1) if current step is valid (with data request), fill all steps
+		 *    after it
+		 * 2) if current step is NULL (for delay purpose), backward search the
+		 *    valid entry, then fill all steps after it
+		 * 3) if no step is valid, fill all entries
+    	 */
+		Byte   bColors = 0;
+   		UShort w;
+
+		/* NoMotorRunStatusStop () */
+		ps->bCurrentLineCount  = (bState &= _SCANSTATE_MASK);
+		ps->Scan.fRefreshState = _TRUE;
+
+		IORegisterDirectToScanner( ps, ps->RegRefreshScanState );
+
+		pw     = &a_wMoveStepTable[bState];
+		bData  = 0;
+		bState = ps->bCurrentLineCount;
+		dw     = _NUMBER_OF_SCANSTEPS;
+
+		if( (wMoveStep = *pw) ) {
+
+		    bColors = a_bColorsSum[ ps->pColorRunTable[*pw] / 16];
+
+	    	if( bColors ) {
+
+				motorClearColorByteTableLoop0( ps, bColors );
+				ps->bNewCurrentLineCountGap = bColors;
+				bColors = 1;
+				goto FillMoveStepTable;
+
+		    } else {
+
+				bData++;
+				dw--;
+				if( --pw < a_wMoveStepTable ) {
+				    pw     = a_wMoveStepTable + _NUMBER_OF_SCANSTEPS - 1;
+				    bState = _NUMBER_OF_SCANSTEPS - 1;
+				}
+				else
+				    bState--;
+		    }
+		}
+
+		/* FindNextStep */
+		while( dw-- ) {
+
+		    if( (wMoveStep = *pw) ) {
+				if (wMoveStep < (_NUMBER_OF_SCANSTEPS / 2)) {
+				    bColors = 0;
+				    break;
+				}
+				if((bColors = a_bColorsSum [ps->pColorRunTable[wMoveStep] / 16]))
+				    break;
+		    }
+
+		    bData++;
+	    	if( --pw < a_wMoveStepTable ) {
+				pw     = a_wMoveStepTable + _NUMBER_OF_SCANSTEPS - 1;
+				bState = _NUMBER_OF_SCANSTEPS - 1;
+		    }
+	    	else
+				bState--;
+		}
+
+		if (bData == _NUMBER_OF_SCANSTEPS )
+		    bData = bColors = 0;
+
+		ps->bNewCurrentLineCountGap = bData;
+		ps->bNewGap = bColors;
+		motorClearColorByteTableLoop1( ps );
+		bColors = 0;
+
+		/* use pw (new pointer) and new speed to recreate MoveStepTable
+		 * wMoveStep = Index number from a_wMoveStepTable ([esi])
+		 * bColors = number of steps should be reserved
+		 * pw = where to fill
+		 */
+
+FillMoveStepTable:
+
+		motorP96GetStartStopGap( ps, _TRUE );
+
+		if( !ps->bMotorStepTableNo )
+		    ps->bMotorStepTableNo = 1;
+
+		if( ps->bMotorStepTableNo != 0xff && ps->IO.portMode == _PORT_SPP &&
+													    ps->DataInf.xyPhyDpi.y <= 200) {
+	    	ps->bMotorStepTableNo++;
+		}
+
+		if (++pw >= pwEndMoveStepTable)
+		    pw = a_wMoveStepTable;
+
+		for( dw = _NUMBER_OF_SCANSTEPS - bColors, wMoveStep++,
+								     bData = ps->bMotorSpeedData; dw; dw-- ) {
+		    if( bData == 1 ) {
+
+				bData = ps->bMotorSpeedData;
+				if( ps->bMotorStepTableNo ) {
+
+					ps->bMotorStepTableNo--;
+				    w = wMoveStep;
+				    wMoveStep++;
+
+				} else {
+				    bData--;
+				    w = 0;
+				}
+		    } else {
+				bData--;
+				w = 0;
+		    }
+		    *pw = w;
+
+		    if (++pw >= pwEndMoveStepTable)
+				pw = a_wMoveStepTable;
+		}
+
+		motorP96FillHalfStepTable( ps );
+
+		/* FillColorBytesTable */
+		if((ps->bCurrentLineCount + 1) < _NUMBER_OF_SCANSTEPS )
+		    bState = ps->bCurrentLineCount + 1;
+		else
+		    bState = ps->bCurrentLineCount + 1 - _NUMBER_OF_SCANSTEPS;
+
+		motorP96FillDataToColorTable( ps, bState, _NUMBER_OF_SCANSTEPS - 1);
+	}
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP98SetSpeed( pScanData ps, Byte bSpeed, Bool fSetRunState )
+{
+	static Byte lastFifoState = 0;
+
+	Bool overflow;
+	Byte bOld1ScanState, bData;
+
+    if( fSetRunState )
+		ps->Scan.bModuleState = _MotorInNormalState;
+
+    ps->bMotorSpeedData  = bSpeed;
+	overflow 			 = _FALSE;
+
+	if( _ASIC_IS_98001 != ps->sCaps.AsicID ) {
+		ps->bMoveDataOutFlag = _DataInNormalState;
+
+		bData = IODataRegisterFromScanner( ps, ps->RegFifoOffset );
+
+		if((lastFifoState > _P96_FIFOOVERFLOWTHRESH) &&
+													(bData < lastFifoState)) {
+			DBG( DBG_HIGH, "FIFO OVERFLOW, loosing data !!\n" );
+			overflow = _TRUE;
+        }
+        lastFifoState = bData;
+	}
+
+    bOld1ScanState = IOGetScanState( ps, _FALSE );
+
+    if(!(bOld1ScanState & _SCANSTATE_STOP) && !overflow)
+		noMotorRunStatusStop( ps, bOld1ScanState );
+    else {
+		ps->bCurrentLineCount = (bOld1ScanState & 0x3f);
+		ps->Scan.bModuleState = _MotorGoBackward;
+
+		motorP98WaitBack( ps );
+
+		if( overflow )
+	        lastFifoState = 0;
+
+		if( _ASIC_IS_98001 != ps->sCaps.AsicID )
+			ps->bMoveDataOutFlag = _DataFromStopState;
+    }
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP98003ModuleFreeRun( pScanData ps, ULong steps )
+{
+    IODataToRegister( ps, ps->RegMotorFreeRunCount1, (_HIBYTE(steps)));
+    IODataToRegister( ps, ps->RegMotorFreeRunCount0, (_LOBYTE(steps)));
+    IORegisterToScanner( ps, ps->RegMotorFreeRunTrigger );
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP98003ModuleToHome( pScanData ps )
+{
+    if(!(IODataFromRegister( ps, ps->RegStatus ) & _FLAG_P98_PAPER)) {
+
+    	IODataToRegister( ps, ps->RegMotor0Control,
+            			(Byte)(ps->AsicReg.RD_Motor0Control|_MotorDirForward));
+
+    	MotorP98003PositionYProc( ps, 40 );
+    	MotorP98003BackToHomeSensor( ps );
+	    _DODELAY( 250 );
+    }
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP98003DownloadNullScanStates( pScanData ps )
+{
+    memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
+    IODownloadScanStates( ps );
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP98003Force16Steps( pScanData ps )
+{
+    ULong dw;
+
+    IODataToRegister( ps, ps->RegStepControl, _MOTOR0_ONESTEP);
+    IODataToRegister( ps, ps->RegMotor0Control, _FORWARD_MOTOR );
+
+    for(dw = 16; dw; dw--) {
+    	IORegisterToScanner( ps, ps->RegForceStep );
+    	_DODELAY( 10 );
+    }
+
+    IODataToRegister( ps, ps->RegStepControl, _MOTOR0_SCANSTATE );
+}
+
+/*.............................................................................
+ *
+ */
+static void motorP98003WaitForPositionY( pScanData ps )
+{
+    Byte  bXStep;
+    ULong dwBeginY;
+
+    dwBeginY = (ULong)ps->DataInf.crImage.y * 4 + ps->Scan.dwScanOrigin;
+
+    if( ps->DataInf.wPhyDataType <= COLOR_256GRAY ) {
+    	if( ps->Device.f0_8_16 )
+	        dwBeginY += 16;
+    	else
+	        dwBeginY += 8;
+    }
+
+    bXStep = (Byte)((ps->DataInf.wPhyDataType <= COLOR_256GRAY) ?
+				      ps->Device.XStepMono : ps->Device.XStepColor);
+
+    if( ps->Shade.bIntermediate & _ScanMode_AverageOut )
+    	bXStep = 8;
+
+    motorP98003Force16Steps( ps);
+    dwBeginY -= 16;
+
+    if (dwBeginY > (_RFT_SCANNING_ORG + _P98003_YOFFSET) &&
+                						  bXStep < ps->AsicReg.RD_XStepTime) {
+
+    	IODataToRegister( ps, ps->RegMotorDriverType, ps->Scan.motorPower );
+        _DODELAY( 12 );
+    	IODataToRegister( ps, ps->RegXStepTime, bXStep);
+	    IODataToRegister( ps, ps->RegExtendedXStep, 0 );
+    	IODataToRegister( ps, ps->RegScanControl1,
+	            		(UChar)(ps->AsicReg.RD_ScanControl1 & ~_MFRC_RUNSCANSTATE));
+    	MotorP98003PositionYProc( ps, dwBeginY - 64 );
+	    dwBeginY = 64;
+    }
+
+    IODataToRegister( ps, ps->RegFifoFullLength0, _LOBYTE(ps->AsicReg.RD_BufFullSize));
+    IODataToRegister( ps, ps->RegFifoFullLength1, _HIBYTE(ps->AsicReg.RD_BufFullSize));
+    IODataToRegister( ps, ps->RegFifoFullLength2, _LOBYTE(_HIWORD(ps->AsicReg.RD_BufFullSize)));
+
+    IODataToRegister( ps, ps->RegMotorDriverType, ps->AsicReg.RD_MotorDriverType);
+    _DODELAY( 12 );
+
+    if(!ps->Device.f2003 || (ps->Shade.bIntermediate & _ScanMode_AverageOut) ||
+		    (  ps->DataInf.xyAppDpi.y <= 75 &&
+                                  ps->DataInf.wPhyDataType <= COLOR_256GRAY)) {
+	    IODataToRegister( ps, ps->RegMotorDriverType,
+                   (Byte)(ps->Scan.motorPower & (_MOTORR_MASK | _MOTORR_STRONG)));
+    } else {
+    	IODataToRegister( ps, ps->RegMotorDriverType,
+                          ps->AsicReg.RD_MotorDriverType );
+    }
+
+    IODataToRegister( ps, ps->RegXStepTime,     ps->AsicReg.RD_XStepTime );
+    IODataToRegister( ps, ps->RegExtendedXStep, ps->AsicReg.RD_ExtXStepTime );
+    IODataToRegister( ps, ps->RegScanControl1,
+                    (Byte)(ps->AsicReg.RD_ScanControl1 & ~_MFRC_RUNSCANSTATE));
+
+    if( ps->DataInf.dwVxdFlag & _VF_PREVIEW ) {
+
+        TimerDef timer;
+
+	    motorP98003ModuleFreeRun( ps, dwBeginY );
+        _DODELAY( 15 );
+
+    	MiscStartTimer( &timer, (_SECOND * 20));
+
+	    while(( IOGetExtendedStatus( ps ) & _STILL_FREE_RUNNING) &&
+                                                      !MiscCheckTimer(&timer));
+        	IODataToRegister( ps, ps->RegModeControl, _ModeScan );
+    } else {
+    	MotorP98003PositionYProc( ps, dwBeginY );
+        IORegisterToScanner( ps, ps->RegRefreshScanState );
+    }
+}
+
+/*.............................................................................
+ * move the sensor to the appropriate shading position
+ */
+static Bool motorP98003GotoShadingPosition( pScanData ps )
+{
+    motorP98003ModuleToHome( ps );
+
+    /* position to somewhere under the transparency adapter */
+    if( ps->DataInf.dwScanFlag & SCANDEF_TPA ) {
+
+    	MotorP98003ForceToLeaveHomePos( ps );
+        motorP98003DownloadNullScanStates( ps );
+
+    	IODataToRegister( ps, ps->RegStepControl, _MOTOR0_SCANSTATE );
+	    IODataToRegister( ps, ps->RegModeControl, _ModeScan);
+    	IODataToRegister( ps, ps->RegMotor0Control, _FORWARD_MOTOR );
+	    IODataToRegister( ps, ps->RegXStepTime, 6);
+    	IODataToRegister( ps, ps->RegExtendedXStep, 0);
+	    IODataToRegister( ps, ps->RegScanControl1, _MFRC_BY_XSTEP);
+
+    	MotorP98003PositionYProc( ps, _TPA_P98003_SHADINGORG );
+    }
+
+    return _TRUE;
+}
+
+/*.............................................................................
+ * initialize this module and setup the correct function pointer according
+ * to the ASIC
+ */
+static void motorP98003PositionModuleToHome( pScanData ps )
+{
+    Byte save, saveModel;
+
+    saveModel = ps->AsicReg.RD_ModelControl;
+
+    ps->Scan.fRefreshState = _FALSE;
+	motorP98003DownloadNullScanStates( ps );
+
+	_DODELAY( 1000UL / 8UL);
+
+	save = ps->Shade.bIntermediate;
+
+	ps->Shade.bIntermediate = _ScanMode_AverageOut;
+	ps->ReInitAsic( ps, _FALSE );
+    ps->Shade.bIntermediate = save;
+
+	IODataToRegister( ps, ps->RegModeControl, _ModeScan );
+	IORegisterToScanner( ps, ps->RegResetMTSC );
+	IODataToRegister( ps, ps->RegScanControl1, 0 );
+
+	IODataToRegister( ps, ps->RegModelControl,
+                          ps->Device.ModelCtrl | _ModelDpi300 );
+
+	IODataToRegister( ps, ps->RegLineControl, 80);
+	IODataToRegister( ps, ps->RegXStepTime, ps->Device.XStepBack);
+	IODataToRegister( ps, ps->RegMotorDriverType, ps->Scan.motorPower);
+
+	_DODELAY( 12 );
+
+	IODataToRegister( ps, ps->RegMotor0Control,
+                			(_MotorHHomeStop | _MotorOn | _MotorHQuarterStep |
+							 _MotorPowerEnable));
+	IODataToRegister( ps, ps->RegStepControl,
+                                        (_MOTOR0_SCANSTATE | _MOTOR_FREERUN));
+
+    memset( ps->a_nbNewAdrPointer, 0x88, _SCANSTATE_BYTES );
+	IODownloadScanStates( ps );
+	IORegisterToScanner( ps, ps->RegRefreshScanState );
+
+    ps->AsicReg.RD_ModelControl = saveModel;
+}
+
+/************************ exported functions *********************************/
+
+/*.............................................................................
+ * initialize this module and setup the correct function pointer according
+ * to the ASIC
+ */
+_LOC int MotorInitialize( pScanData ps )
+{
+	DBG( DBG_HIGH, "MotorInitialize()\n" );
+
+	if( NULL == ps )
+		return _E_NULLPTR;
+
+	ps->a_wMoveStepTable  = a_wMoveStepTable;
+	ps->a_bColorByteTable =	a_bColorByteTable;
+	wP96BaseDpi 		  = 0;
+
+	ps->PauseColorMotorRunStates = motorPauseColorMotorRunStates;
+
+	/*
+	 * depending on the asic, we set some functions
+	 */
+	if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
+
+		ps->WaitForPositionY	 	  = motorP98WaitForPositionY;
+		ps->GotoShadingPosition	 	  = motorP98GotoShadingPosition;
+		ps->FillRunNewAdrPointer   	  = motorP98FillRunNewAdrPointer;
+		ps->SetupMotorRunTable	      = motorP98SetupRunTable;
+		ps->UpdateDataCurrentReadLine = motorP98UpdateDataCurrentReadLine;
+		ps->SetMotorSpeed 		 	  = motorP98SetSpeed;
+
+	} else if( _ASIC_IS_98003 == ps->sCaps.AsicID ) {
+
+		ps->WaitForPositionY    = motorP98003WaitForPositionY;
+		ps->GotoShadingPosition	= motorP98003GotoShadingPosition;
+		ps->SetMotorSpeed 	    = motorP98SetSpeed;
+
+    } else if( _IS_ASIC96(ps->sCaps.AsicID)) {
+
+		ps->WaitForPositionY		  = motorP96WaitForPositionY;
+		ps->GotoShadingPosition	 	  = motorP96GotoShadingPosition;
+		ps->FillRunNewAdrPointer   	  = motorP96FillRunNewAdrPointer;
+		ps->SetupMotorRunTable	      = motorP96SetupRunTable;
+		ps->UpdateDataCurrentReadLine = motorP96UpdateDataCurrentReadLine;
+		ps->SetMotorSpeed 		 	  = motorP96SetSpeed;
+
+	} else {
+
+		DBG( DBG_HIGH , "NOT SUPPORTED ASIC !!!\n" );
+		return _E_NOSUPP;
+	}
+	return _OK;
+}
+
+/*.............................................................................
+ *
+ */
+_LOC void MotorSetConstantMove( pScanData ps, Byte bMovePerStep )
+{
+	DataPointer p;
+    ULong	    dw;
+
+    p.pb = ps->a_nbNewAdrPointer;
+
+    switch( bMovePerStep )
+    {
+	case 0: 	/* doesn't move at all */
+	    for (dw = _NUMBER_OF_SCANSTEPS / 8; dw; dw--, p.pdw++) {
+
+			if( _ASIC_IS_98001 == ps->sCaps.AsicID )
+				*p.pdw &= 0x77777777;
+			else
+				*p.pdw &= 0xbbbbbbbb;
+		}
+	    break;
+
+	case 1:
+	    for (dw = _NUMBER_OF_SCANSTEPS / 8; dw; dw--, p.pdw++) {
+			if( _ASIC_IS_98001 == ps->sCaps.AsicID )
+				*p.pdw |= 0x88888888;
+			else
+				*p.pdw |= 0x44444444;
+		}
+	    break;
+
+	case 2:
+	    for (dw = _NUMBER_OF_SCANSTEPS / 8; dw; dw--, p.pdw++) {
+			if( _ASIC_IS_98001 == ps->sCaps.AsicID )
+				*p.pdw |= 0x80808080;
+			else
+				*p.pdw |= 0x40404040;
+		}
+	    break;
+
+	default:
+	    {
+			Byte bMoves = bMovePerStep;
+
+			for (dw = _SCANSTATE_BYTES; dw; dw--, p.pb++) {
+		    	if (!(--bMoves)) {
+					if( _ASIC_IS_98001 == ps->sCaps.AsicID )
+						*p.pb |= 8;
+					else
+						*p.pb |= 4;
+					bMoves = bMovePerStep;
+			    }
+			    if (!(--bMoves)) {
+					if( _ASIC_IS_98001 == ps->sCaps.AsicID )
+						*p.pb |= 0x80;
+					else
+						*p.pb |= 0x40;
+					bMoves = bMovePerStep;
+			    }
+			}
+	    }
+    }
+	IOSetToMotorRegister( ps );
+}
+
+/*.............................................................................
+ * function to bring the sensor back home
+ */
+_LOC void MotorToHomePosition( pScanData ps )
+{
+    TimerDef    timer;
+    ScanState	StateStatus;
+
+	DBG( DBG_HIGH, "Waiting for Sensor to be back in position\n" );
+	_DODELAY( 250 );
+
+	if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
+
+    	if (!(IODataRegisterFromScanner(ps,ps->RegStatus) & _FLAG_P98_PAPER)){
+			ps->GotoShadingPosition( ps );
+		}
+    } else if( _ASIC_IS_98003 == ps->sCaps.AsicID ) {
+
+        ps->OpenScanPath( ps );
+
+	    if( !(IODataFromRegister( ps, ps->RegStatus ) & _FLAG_P98_PAPER)) {
+
+            motorP98003PositionModuleToHome( ps );
+
+            MiscStartTimer( &timer, _SECOND * 20);
+            do {
+
+                if( IODataFromRegister( ps, ps->RegStatus ) & _FLAG_P98_PAPER)
+                    break;
+            } while( !MiscCheckTimer( &timer));
+        }
+        ps->CloseScanPath( ps );
+
+	} else {
+
+		if( ps->sCaps.Model >= MODEL_OP_9630P ) {
+			if( ps->sCaps.Model == MODEL_OP_A3I )
+				IOCmdRegisterToScanner( ps, ps->RegLineControl, 0x34 );
+			else
+				IOCmdRegisterToScanner( ps, ps->RegLineControl, 0x30 );
+		}
+
+		ps->bExtraMotorCtrl     = 0;
+    	ps->Scan.fMotorBackward = _FALSE;
+		MotorP96ConstantMoveProc( ps, 25 );
+
+	    ps->Scan.fMotorBackward = _TRUE;
+		for(;;) {
+
+			motorP96GetScanStateAndStatus( ps, &StateStatus );
+
+			if ( StateStatus.bStatus & _FLAG_P96_PAPER ) {
+			    break;
+			}
+
+ 			MotorP96ConstantMoveProc( ps, 50000 );
+		}
+
+    	ps->Scan.fMotorBackward = _FALSE;
+		ps->Asic96Reg.RD_MotorControl = 0;
+		IOCmdRegisterToScanner( ps, ps->RegMotorControl, 0 );
+
+	    memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
+		IOSetToMotorRegister( ps );
+		_DODELAY(250);
+
+	    ps->Asic96Reg.RD_LedControl = 0;
+    	IOCmdRegisterToScanner(ps, ps->RegLedControl, ps->Asic96Reg.RD_LedControl);
+	}
+
+	DBG( DBG_HIGH, "- done !\n" );
+}
+
+/*.............................................................................
+ *
+ */
+_LOC void MotorP98GoFullStep( pScanData ps, ULong dwStep )
+{
+	memset( ps->pColorRunTable, 1, dwStep );
+    memset( ps->pColorRunTable + dwStep, 0xff, 0x40);
+
+    ps->bOldStateCount = IOGetScanState( ps, _FALSE ) & _SCANSTATE_MASK;
+    motorP98SetRunFullStep( ps );
+
+    ps->pScanState = ps->pColorRunTable;
+    ps->FillRunNewAdrPointer( ps );
+
+    while(!motorCheckMotorPresetLength( ps ))
+		motorP98FillRunNewAdrPointer1( ps );
+}
+
+/*.............................................................................
+ *
+ */
+_LOC void MotorP96SetSpeedToStopProc( pScanData ps )
+{
+	Byte	 bData;
+    TimerDef timer;
+
+	MiscStartTimer( &timer, _SECOND);
+    while( !MiscCheckTimer( &timer )) {
+
+		bData = IODataRegisterFromScanner( ps, ps->RegFifoOffset );
+
+		if ((bData > ps->bMinReadFifo) && (bData != ps->bFifoCount))
+		    break;
+    }
+    bData = IOGetScanState( ps, _FALSE );
+
+    if (!(bData & _SCANSTATE_STOP)) {
+
+		MiscStartTimer( &timer, (_SECOND / 2));
+
+		while (!MiscCheckTimer( &timer )) {
+
+		    if (IOGetScanState( ps, _FALSE) != bData )
+				break;
+		}
+    }
+
+    ps->Scan.bModuleState = _MotorInStopState;
+    ps->SetMotorSpeed( ps, ps->bCurrentSpeed, _FALSE );
+
+	IOSetToMotorRegister( ps );
+}
+
+/*.............................................................................
+ * Position Scan Module to specified line number (Forward or Backward & wait
+ * for paper flag ON)
+ */
+_LOC void MotorP96ConstantMoveProc( pScanData ps, ULong dwLines )
+{
+	Byte		bRemainder, bLastState;
+    UShort		wQuotient;
+    ULong		dwDelayMaxTime;
+    ScanState	StateStatus;
+	TimerDef	timer;
+	Bool		fTimeout = _FALSE;
+
+    wQuotient  = (UShort)(dwLines / _NUMBER_OF_SCANSTEPS);	/* state cycles */
+    bRemainder = (Byte)(dwLines % _NUMBER_OF_SCANSTEPS);
+
+	/* 3.3 ms per line */
+    dwDelayMaxTime = dwLines * _MOTOR_ONE_LINE_TIME + _SECOND * 2;
+
+	MotorSetConstantMove( ps, 1 );	/* step every time */
+
+    ps->OpenScanPath( ps );
+
+    ps->AsicReg.RD_ModeControl = _ModeScan;
+    IODataToRegister( ps, ps->RegModeControl, _ModeScan );
+
+    if( ps->Scan.fMotorBackward ) {
+		ps->Asic96Reg.RD_MotorControl = (ps->MotorFreeRun | ps->MotorOn |
+										   ps->FullStep | ps->bExtraMotorCtrl);
+    } else {
+		ps->Asic96Reg.RD_MotorControl = (ps->MotorFreeRun | ps->MotorOn |
+									  _MotorDirForward | ps->bExtraMotorCtrl);
+	}
+
+	IODataToRegister( ps, ps->RegMotorControl, ps->Asic96Reg.RD_MotorControl );
+    ps->CloseScanPath( ps );
+
+    bLastState = 0;
+
+	MiscStartTimer( &timer, dwDelayMaxTime );
+
+    do {
+
+		motorP96GetScanStateAndStatus( ps, &StateStatus );
+
+		if( ps->Scan.fMotorBackward && (StateStatus.bStatus&_FLAG_P96_PAPER)) {
+		    break;
+		} else {
+
+		    /*
+			 * 1) Forward will not reach the sensor.
+			 * 2) Backwarding, doesn't reach the sensor
+			 */
+		    if (wQuotient) {
+
+				/* stepped */
+				if (StateStatus.bStep != bLastState) {
+				    bLastState = StateStatus.bStep;
+				    if (!bLastState)	/* done a cycle! */
+						wQuotient--;
+				}
+		    } else {
+				if (StateStatus.bStep >= bRemainder) {
+			    	break;
+				}
+			}
+		}
+
+		fTimeout = MiscCheckTimer( &timer );
+
+	} while ( _OK == fTimeout );
+
+    if ( _OK == fTimeout ) {
+		memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
+		IOSetToMotorRegister( ps );
+    }
+}
+
+/*.............................................................................
+ *
+ */
+_LOC Bool MotorP96AheadToDarkArea( pScanData ps )
+{
+	Byte	 bDark;
+	UShort   wTL;
+    UShort 	 wTotalLastLine;
+    TimerDef timer;
+
+    ps->fColorMoreRedFlag  = _FALSE;
+	ps->fColorMoreBlueFlag = _FALSE;
+    ps->wOverBlue = 0;
+
+    /* FillToDarkCounter () */
+    memset( ps->a_nbNewAdrPointer, 0x30, _SCANSTATE_BYTES);
+    MotorSetConstantMove( ps, 2 );
+
+    /* SetToDarkRegister () */
+    ps->AsicReg.RD_ModeControl    = _ModeScan;
+    ps->AsicReg.RD_ScanControl    = ps->bLampOn | _SCAN_BYTEMODE;
+    ps->Asic96Reg.RD_MotorControl = _MotorDirForward | ps->FullStep;
+	ps->AsicReg.RD_ModelControl   = ps->Device.ModelCtrl | _ModelWhiteIs0;
+
+    ps->AsicReg.RD_Dpi = 300;
+	wTL = 296;
+/*	if( MODEL_OP_A3I == ps->sCaps.Model ) { */
+	if( ps->PhysicalDpi > 300 ) {
+		wTL = 400;
+	    ps->AsicReg.RD_Origin = (UShort)(ps->Offset70 + 64 + 8 + 2048);
+	} else {
+	    ps->AsicReg.RD_Origin = (UShort)(ps->Offset70 + 64 + 8 + 1024);
+	}
+    ps->AsicReg.RD_Pixels = 512;
+
+	IOPutOnAllRegisters( ps );
+
+    ps->Asic96Reg.RD_MotorControl = (ps->MotorFreeRun | ps->IgnorePF |
+											 ps->MotorOn | _MotorDirForward );
+
+	IOCmdRegisterToScanner( ps, ps->RegMotorControl,
+											  ps->Asic96Reg.RD_MotorControl );
+
+	MiscStartTimer( &timer, _SECOND * 2 );
+    wTotalLastLine = 0;
+
+#ifdef _A3I_EN
+    while( !MiscCheckTimer( &timer )) {
+
+		bDark = motorP96ReadDarkData( ps );
+
+		wTotalLastLine++;
+		if((bDark < 0x80) || (wTotalLastLine==wTL)) {
+
+		    IOCmdRegisterToScanner( ps, ps->RegMotorControl, 0 );
+	    	return _TRUE;
+		}
+    }
+#else
+    while (!MiscCheckTimer( &timer )) {
+
+		bDark = motorP96ReadDarkData( ps );
+
+		wTotalLastLine++;
+		if (((ps->sCaps.AsicID == _ASIC_IS_96001) && (bDark > 0x80)) ||
+			((ps->sCaps.AsicID != _ASIC_IS_96001) && (bDark < 0x80)) ||
+                                            (wTotalLastLine==wTL)) {
+
+		    IOCmdRegisterToScanner( ps, ps->RegModeControl, _ModeProgram );
+
+		    if (wTotalLastLine <= 24)
+				ps->fColorMoreRedFlag = _TRUE;
+		    else
+				if (wTotalLastLine >= 120) {
+				    ps->wOverBlue = wTotalLastLine - 80;
+				    ps->fColorMoreBlueFlag = _TRUE;
+				}
+
+	    	return _TRUE;
+		}
+    }
+#endif
+
+    return _FALSE;	/* already timed out */
+}
+
+/*.............................................................................
+ * limit the speed settings for 96001/3 based models
+ */
+_LOC void MotorP96AdjustCurrentSpeed( pScanData ps, Byte bSpeed )
+{
+    if (bSpeed != 1) {
+
+		if (bSpeed > 34)
+		    ps->bCurrentSpeed = 34;
+		else
+		    ps->bCurrentSpeed = (bSpeed + 1) & 0xfe;
+    }
+}
+
+/*.............................................................................
+ *
+ */
+_LOC void MotorP98003ForceToLeaveHomePos( pScanData ps )
+{
+    TimerDef timer;
+
+    IODataToRegister( ps, ps->RegStepControl, _MOTOR0_ONESTEP );
+    IODataToRegister( ps, ps->RegMotor0Control, _FORWARD_MOTOR );
+
+	MiscStartTimer( &timer, _SECOND );
+
+    do {
+        if( !(IODataFromRegister( ps, ps->RegStatus ) & _FLAG_P98_PAPER))
+    	    break;
+
+        IORegisterToScanner( ps, ps->RegForceStep );
+    	_DODELAY( 10 );
+
+    } while( _OK == MiscCheckTimer( &timer ));
+
+    IODataToRegister( ps, ps->RegStepControl, _MOTOR0_SCANSTATE );
+}
+
+/*.............................................................................
+ *
+ */
+_LOC void MotorP98003BackToHomeSensor( pScanData ps )
+{
+    TimerDef timer;
+
+	DBG( DBG_HIGH, "MotorP98003BackToHomeSensor()\n" );
+
+    IODataToRegister( ps, ps->RegStepControl, _MOTOR0_SCANSTATE );
+    IODataToRegister( ps, ps->RegModeControl, _ModeScan );
+
+    /* stepping every state */
+    memset( ps->a_nbNewAdrPointer, 0x88, _SCANSTATE_BYTES );
+    IODownloadScanStates( ps );
+
+	MiscStartTimer( &timer, _SECOND * 2 );
+
+    while(!(IOGetScanState( ps, _TRUE ) & _SCANSTATE_STOP) &&
+                                                    !MiscCheckTimer( &timer ));
+
+	_DODELAY( 1000UL );
+
+    ps->AsicReg.RD_ModeControl = _ModeScan;
+
+    if (!(ps->DataInf.dwScanFlag & SCANDEF_TPA)) {
+        IODataToRegister( ps, ps->RegLineControl, _LOBYTE(ps->Shade.wExposure));
+        IODataToRegister( ps, ps->RegXStepTime,   _LOBYTE(ps->Shade.wXStep));
+
+    } else {
+    	IODataToRegister( ps, ps->RegLineControl, _DEFAULT_LINESCANTIME );
+	    IODataToRegister( ps, ps->RegXStepTime, 6);
+    }
+
+    IODataToRegister( ps, ps->RegStepControl,
+                                         (_MOTOR_FREERUN | _MOTOR0_SCANSTATE));
+    IODataToRegister( ps, ps->RegModeControl, ps->AsicReg.RD_ModeControl );
+    IODataToRegister( ps, ps->RegMotor0Control,
+                  	    (_MotorHQuarterStep | _MotorOn | _MotorDirBackward |
+                                    	_MotorPowerEnable | _MotorHHomeStop));
+    IORegisterToScanner( ps, ps->RegRefreshScanState );
+
+	MiscStartTimer( &timer, _SECOND * 5 );
+
+    do {
+        if( IODataFromRegister( ps, ps->RegStatus ) & _FLAG_P98_PAPER )
+    	    break;
+
+    	_DODELAY( 55 );
+
+    } while( !MiscCheckTimer( &timer ));
+
+    IODataToRegister( ps, ps->RegLineControl, ps->AsicReg.RD_LineControl);
+    IODataToRegister( ps, ps->RegXStepTime, ps->AsicReg.RD_XStepTime);
+
+   	DBG( DBG_HIGH, "LineCtrl=%u, XStepTime=%u\n",
+                    ps->AsicReg.RD_LineControl, ps->AsicReg.RD_XStepTime );
+
+    motorP98003DownloadNullScanStates( ps );
+}
+
+/*.............................................................................
+ *
+ */
+_LOC void MotorP98003ModuleForwardBackward( pScanData ps )
+{
+    switch( ps->Scan.bModuleState ) {
+
+	case _MotorInNormalState:
+	    ps->Scan.bModuleState = _MotorGoBackward;
+	    IODataToRegister( ps, ps->RegScanControl1,
+    			   (UChar)(ps->AsicReg.RD_ScanControl1 & ~_MFRC_RUNSCANSTATE));
+	    IODataToRegister( ps, ps->RegMotor0Control,
+    			    (UChar)(ps->AsicReg.RD_Motor0Control & ~_MotorDirForward));
+	    motorP98003ModuleFreeRun( ps, _P98003_BACKSTEPS );
+	    MiscStartTimer( &p98003MotorTimer, (15 * _MSECOND));
+	    break;
+
+	case _MotorGoBackward:
+	    if( MiscCheckTimer(& p98003MotorTimer)) {
+    		if (!(IOGetExtendedStatus( ps ) & _STILL_FREE_RUNNING )) {
+    		    ps->Scan.bModuleState = _MotorInStopState;
+	    	    MiscStartTimer( &p98003MotorTimer, (50 *_MSECOND));
+		    }
+	    }
+	    break;
+
+	case _MotorInStopState:
+	    if( MiscCheckTimer(&p98003MotorTimer)) {
+
+    		if( IOReadFifoLength( ps ) < ps->Scan.dwMaxReadFifo ) {
+    		    ps->Scan.bModuleState = _MotorAdvancing;
+	    	    IODataToRegister( ps, ps->RegScanControl1, ps->AsicReg.RD_ScanControl1);
+		        IODataToRegister( ps, ps->RegMotor0Control, ps->AsicReg.RD_Motor0Control);
+        	    motorP98003ModuleFreeRun( ps, _P98003_FORWARDSTEPS );
+        	    MiscStartTimer( &p98003MotorTimer, (15 * _MSECOND));
+		    }
+	    }
+	    break;
+
+	case _MotorAdvancing:
+	    if( MiscCheckTimer(&p98003MotorTimer)) {
+    		if( !(IOGetScanState( ps, _TRUE ) & _SCANSTATE_STOP))
+	    	    ps->Scan.bModuleState = _MotorInNormalState;
+    		else {
+    		    if (!(IOGetExtendedStatus( ps ) & _STILL_FREE_RUNNING )) {
+        			IORegisterToScanner( ps, ps->RegRefreshScanState );
+		        	ps->Scan.bModuleState = _MotorInNormalState;
+                }
+		    }
+		}
+        break;
+    }
+}
+
+/*.............................................................................
+ *
+ */
+_LOC void MotorP98003PositionYProc( pScanData ps, ULong steps)
+{
+    TimerDef timer;
+
+	DBG( DBG_HIGH, "MotorP98003PositionYProc()\n" );
+
+	MiscStartTimer( &timer, _SECOND * 5 );
+
+    while(!(IOGetScanState( ps, _TRUE ) & _SCANSTATE_STOP) &&
+                                                (!MiscCheckTimer( &timer )));
+
+    _DODELAY( 12 );
+
+    motorP98003ModuleFreeRun( ps, steps );
+
+    _DODELAY( 15 );
+
+	MiscStartTimer( &timer, _SECOND * 30 );
+
+    do  {
+    	if (!(IOGetExtendedStatus( ps ) & _STILL_FREE_RUNNING) ||
+                    	        !(IOGetScanState( ps, _TRUE ) & _SCANSTATE_STOP))
+	    break;
+
+    } while( !MiscCheckTimer( &timer ));
+
+	DBG( DBG_HIGH, "MotorP98003PositionYProc() - done\n" );
+}
+
+/* END PLUSTEK-PP_MOTOR.C ...................................................*/