Lines Matching refs:ps
179 static void motorP96GetStartStopGap( pScanData ps, Bool fCheckState )
185 ps->bMotorStepTableNo = 0xff;
186 if( ps->Scan.bModuleState == _MotorInNormalState )
190 bMotorCountDownIndex = ps->bMotorSpeedData / 2;
192 if( ps->bCurrentSpeed == 4 && ps->AsicReg.RD_Dpi < 80 )
193 ps->bMotorStepTableNo = 4;
195 if( ps->Scan.bModuleState == _MotorGoBackward )
196 ps->bMotorStepTableNo = a_bStepUp1Table[bMotorCountDownIndex];
198 ps->bMotorStepTableNo = a_bStepDown1Table[bMotorCountDownIndex];
206 static Bool motorCheckMotorPresetLength( pScanData ps )
214 bScanState = IOGetScanState( ps, _FALSE );
216 if (ps->fFullLength) {
218 if ((ULong)(bScanState & _SCANSTATE_MASK) != ps->dwScanStateCount )
220 return ps->fFullLength;
229 if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
231 if (bScanState < ps->bOldStateCount)
234 bScanState -= ps->bOldStateCount;
237 return ps->fFullLength;
244 return ps->fFullLength;
260 static void motorClearColorByteTableLoop0( pScanData ps, Byte bColors )
265 if ((ps->bCurrentLineCount + bColors) >= _NUMBER_OF_SCANSTEPS) {
266 pb = a_bColorByteTable + (ULong)(ps->bCurrentLineCount + bColors -
269 pb = a_bColorByteTable + (ULong)(ps->bCurrentLineCount + bColors);
279 if ((ps->bCurrentLineCount+ps->bCurrentSpeed/2+1) >= _NUMBER_OF_SCANSTEPS) {
281 pb = a_bHalfStepTable + (ULong)(ps->bCurrentLineCount +
282 ps->bCurrentSpeed / 2 + 1 - _NUMBER_OF_SCANSTEPS);
285 (ULong)(ps->bCurrentLineCount + ps->bCurrentSpeed / 2 + 1);
288 for (dw = _NUMBER_OF_SCANSTEPS - ps->bMotorSpeedData / 2 - 1; dw; dw--) {
314 static void motorClearColorByteTableLoop1( pScanData ps )
319 if (ps->bNewGap > ps->bNewCurrentLineCountGap) {
320 ps->bNewGap = ps->bNewGap - ps->bNewCurrentLineCountGap - 1;
321 dw -= (ULong)ps->bNewGap;
323 ps->bNewGap = 0;
326 if ((ps->bCurrentLineCount + ps->bNewGap + 1) >= _NUMBER_OF_SCANSTEPS) {
328 (ULong)(ps->bCurrentLineCount+ps->bNewGap+1-_NUMBER_OF_SCANSTEPS);
331 (ULong)(ps->bCurrentLineCount + ps->bNewGap + 1);
340 if (ps->bCurrentSpeed > ps->bNewCurrentLineCountGap) {
341 ps->bNewGap = ps->bCurrentSpeed - ps->bNewCurrentLineCountGap;
342 dw = _NUMBER_OF_SCANSTEPS - 1 - (ULong)ps->bNewGap;
345 ps->bNewGap = 0;
348 if ((ps->bCurrentLineCount + ps->bNewGap + 1) >= _NUMBER_OF_SCANSTEPS) {
349 pb = a_bHalfStepTable + (ULong)(ps->bCurrentLineCount +
350 ps->bNewGap + 1 - _NUMBER_OF_SCANSTEPS);
352 pb = a_bHalfStepTable + (ULong)(ps->bCurrentLineCount+ps->bNewGap +1);
365 static void motorSetRunPositionRegister( pScanData ps )
369 if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
370 if( ps->Scan.fMotorBackward ) {
371 bData = ps->AsicReg.RD_Motor0Control & ~_MotorDirForward;
373 bData = ps->AsicReg.RD_Motor0Control | _MotorDirForward;
376 IOCmdRegisterToScanner( ps, ps->RegMotor0Control, bData );
380 if( ps->Scan.fMotorBackward ) {
381 bData = ps->Asic96Reg.RD_MotorControl & ~_MotorDirForward;
383 bData = ps->Asic96Reg.RD_MotorControl | _MotorDirForward;
386 IOCmdRegisterToScanner( ps, ps->RegMotorControl, bData );
393 static void motorPauseColorMotorRunStates( pScanData ps )
395 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES);
397 if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
399 ps->a_nbNewAdrPointer[2] = 0x77; /* Read color at the same time */
402 ps->a_nbNewAdrPointer[2] = 1;
403 ps->a_nbNewAdrPointer[3] = 3;
404 ps->a_nbNewAdrPointer[4] = 2;
407 MotorSetConstantMove( ps, 0 );
413 static void motorP98FillDataToColorTable( pScanData ps,
426 if( *pw >= ps->BufferForColorRunTable ) {
428 *pw, ps->BufferForColorRunTable );
430 bColor = ps->pColorRunTable[*pw]; /* get the colors */
447 ps->a_nbNewAdrPointer[w] = (Byte)((*pb & 7) + ((*(pb + 1) & 7) << 4));
452 ps->a_nbNewAdrPointer [w] |= 8;
455 ps->a_nbNewAdrPointer [w] |= 0x80;
462 static void motorP98FillHalfStepTable( pScanData ps )
469 if (1 == ps->bMotorSpeedData) {
472 (a_wMoveStepTable [dw] > ps->wMaxMoveStep) ? 0: 1;
474 pwMoveStep = &a_wMoveStepTable[ps->bCurrentLineCount];
475 pbHalfStepTbl = &a_bHalfStepTable[ps->bCurrentLineCount];
477 if (ps->DataInf.wAppDataType >= COLOR_TRUE24)
491 dw = (ULong)ps->bMotorSpeedData;
492 if (Data.bValue < ps->bMotorSpeedData)
497 if (ps->dwFullStateSpeed) {
498 dw -= ps->dwFullStateSpeed;
500 dw -= ps->dwFullStateSpeed) {
501 pb += ps->dwFullStateSpeed;
516 static void motorP98FillBackColorDataTable( pScanData ps )
520 if ((bIndex = ps->bCurrentLineCount + ps->bNewCurrentLineCountGap + 1) >=
525 motorP98FillDataToColorTable( ps, bIndex, (ULong)(_NUMBER_OF_SCANSTEPS -
526 ps->bNewCurrentLineCountGap));
539 static void motorP98FillBackLoop( pScanData ps,
542 for (ps->fFullLength = _FALSE; dwStates; dwStates--) {
546 ULong dw = ps->dwScanStateCount;
549 ps->a_nbNewAdrPointer [dw / 2] &= ((dw & 1) ? 0x7f: 0xf7);
552 if (!ps->dwScanStateCount)
553 ps->dwScanStateCount = _NUMBER_OF_SCANSTEPS;
555 ps->dwScanStateCount--;
556 ps->fFullLength = _TRUE;
559 ps->a_nbNewAdrPointer [ps->dwScanStateCount / 2] |=
560 ((ps->dwScanStateCount & 1) ? 0x80 : 0x08);
561 if (++ps->dwScanStateCount == _NUMBER_OF_SCANSTEPS)
562 ps->dwScanStateCount = 0; /* reset to begin */
567 IOSetToMotorStepCount( ps ); /* put all scan states to ASIC */
573 static void motorP98SetRunFullStep( pScanData ps )
575 ps->OpenScanPath( ps );
577 ps->AsicReg.RD_StepControl = _MOTOR0_SCANSTATE;
578 IODataToRegister( ps, ps->RegStepControl,
579 ps->AsicReg.RD_StepControl );
580 IODataToRegister( ps, ps->RegLineControl, 96 );
582 if ( ps->bFastMoveFlag == _FastMove_Low_C75_G150_Back ) {
583 IODataToRegister( ps, ps->RegMotor0Control,
586 IODataToRegister( ps, ps->RegMotor0Control,
590 if (ps->bFastMoveFlag == _FastMove_Film_150) {
591 ps->AsicReg.RD_XStepTime = 12;
593 if (ps->bFastMoveFlag == _FastMove_Fast_C50_G100) {
594 ps->AsicReg.RD_XStepTime =
595 ((ps->DataInf.wPhyDataType >= COLOR_TRUE24) ? 4 : 8);
597 ps->AsicReg.RD_XStepTime =
598 ((ps->DataInf.wPhyDataType >= COLOR_TRUE24) ? 6 : 12);
602 DBG( DBG_LOW, "XStepTime = %u\n", ps->AsicReg.RD_XStepTime );
603 IODataToRegister( ps, ps->RegXStepTime, ps->AsicReg.RD_XStepTime);
604 ps->CloseScanPath( ps );
610 static int motorP98BackToHomeSensor( pScanData ps )
615 MotorSetConstantMove( ps, 1 );
617 ps->OpenScanPath( ps );
619 ps->AsicReg.RD_StepControl =
621 IODataToRegister( ps, ps->RegStepControl, ps->AsicReg.RD_StepControl);
623 ps->AsicReg.RD_ModeControl = _ModeScan;
624 IODataToRegister( ps, ps->RegModeControl, ps->AsicReg.RD_ModeControl );
626 ps->AsicReg.RD_Motor0Control = _MotorHQuarterStep +
628 IODataToRegister( ps, ps->RegMotor0Control, ps->AsicReg.RD_Motor0Control );
631 if( ps->DataInf.wPhyDataType >= COLOR_TRUE24) {
632 ps->AsicReg.RD_XStepTime = ps->bSpeed24;
634 ps->AsicReg.RD_XStepTime = ps->bSpeed12;
637 DBG( DBG_HIGH, "XStepTime = %u\n", ps->AsicReg.RD_XStepTime );
639 IODataToRegister( ps, ps->RegXStepTime, ps->AsicReg.RD_XStepTime );
640 IORegisterToScanner( ps, ps->RegRefreshScanState );
646 if (IODataFromRegister( ps, ps->RegStatus) & _FLAG_P98_PAPER ) {
647 IODataToRegister( ps, ps->RegModelControl,
648 (Byte)(ps->AsicReg.RD_ModelControl | _HOME_SENSOR_POLARITY));
649 if(!(IODataFromRegister(ps, ps->RegStatus) & _FLAG_P98_PAPER))
656 ps->CloseScanPath( ps );
661 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
663 IOSetToMotorRegister( ps );
672 static void motorP98FillRunNewAdrPointer1( pScanData ps )
677 IOGetCurrentStateCount( ps, &sState);
679 if (sState.bStep < ps->bOldStateCount) {
684 sState.bStep -= ps->bOldStateCount; /* how many states passed */
685 ps->pScanState += sState.bStep;
691 ps->bOldStateCount = bTemp;
692 ps->dwScanStateCount = (ULong)((bTemp + 1) & _SCANSTATE_MASK);
694 motorP98FillBackLoop( ps, ps->pScanState, _NUMBER_OF_SCANSTEPS );
700 static void motorP98FillRunNewAdrPointer( pScanData ps )
702 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
704 motorP98FillRunNewAdrPointer1( ps );
710 static void motorP98PositionYProc( pScanData ps, ULong dwStates )
714 memset( ps->pColorRunTable, 1, dwStates );
715 memset( ps->pColorRunTable + dwStates, 0xff, (3800UL - dwStates));
717 IOGetCurrentStateCount( ps, &sState);
719 ps->bOldStateCount = sState.bStep;
721 ps->OpenScanPath( ps );
722 IODataToRegister( ps, ps->RegMotor0Control,
723 (Byte)(_MotorOn + _MotorHEightStep +(ps->Scan.fMotorBackward)?
726 DBG( DBG_LOW, "XStepTime = %u\n", ps->bSpeed6 );
727 IODataToRegister( ps, ps->RegXStepTime, ps->bSpeed6 );
728 ps->CloseScanPath( ps );
730 ps->pScanState = ps->pColorRunTable;
732 ps->FillRunNewAdrPointer( ps );
734 while(!motorCheckMotorPresetLength( ps ))
735 motorP98FillRunNewAdrPointer1( ps );
741 static int motorP98CheckSensorInHome( pScanData ps )
745 if (!(IODataRegisterFromScanner(ps,ps->RegStatus) & _FLAG_P98_PAPER)){
747 MotorSetConstantMove( ps, 1 );
748 ps->Scan.fMotorBackward = _FALSE;
749 ps->bExtraMotorCtrl = 0;
750 motorP98PositionYProc( ps, 20 );
752 result = motorP98BackToHomeSensor( ps );
765 static void motorP98WaitForPositionY( pScanData ps )
770 if( ps->DataInf.dwScanFlag & SCANDEF_TPA ) {
772 motorP98BackToHomeSensor( ps );
776 ps->OpenScanPath( ps );
777 IODataToRegister( ps, ps->RegModelControl, ps->AsicReg.RD_ModelControl);
778 IODataToRegister( ps, ps->RegStepControl, (Byte)(_MOTOR_FREERUN +
780 IODataToRegister( ps, ps->RegMotor0Control, (Byte)(_MotorOn +
782 ps->CloseScanPath( ps );
785 if (IODataRegisterFromScanner( ps, ps->RegStatus) & _FLAG_P98_PAPER) {
786 IORegisterDirectToScanner( ps, ps->RegForceStep );
791 ps->AsicReg.RD_ModeControl = _ModeScan;
792 IOCmdRegisterToScanner( ps, ps->RegModeControl,
793 ps->AsicReg.RD_ModeControl );
795 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
797 ps->Scan.fMotorBackward = _FALSE;
798 ps->bExtraMotorCtrl = 0;
799 ps->bFastMoveFlag = _FastMove_Film_150;
801 if (ps->DataInf.dwScanFlag & SCANDEF_Negative) {
802 MotorP98GoFullStep(ps, (ps->DataInf.crImage.y+_NEG_SCANNINGPOS)/2);
804 MotorP98GoFullStep(ps, (ps->DataInf.crImage.y+_POS_SCANNINGPOS)/2);
810 ps->AsicReg.RD_ModeControl = _ModeScan;
812 IOCmdRegisterToScanner( ps, ps->RegModeControl,
813 ps->AsicReg.RD_ModeControl );
815 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
817 ps->Scan.fMotorBackward = _FALSE;
818 ps->bExtraMotorCtrl = 0;
821 dw = ps->wInitialStep + ps->DataInf.crImage.y;
827 switch (ps->DataInf.wPhyDataType) {
837 if (ps->bSetScanModeFlag & _ScanMode_Mono) {
853 ps->bFastMoveFlag = _FastMove_Low_C75_G150;
854 MotorP98GoFullStep( ps, dwDX);
858 ps->bFastMoveFlag = _FastMove_Fast_C50_G100;
859 MotorP98GoFullStep( ps, dw);
862 dwBX = ((ps->bSetScanModeFlag & _ScanMode_Mono) ? 2: 4);
864 ps->bFastMoveFlag = _FastMove_Low_C75_G150;
866 MotorP98GoFullStep(ps, dw);
882 static Bool motorP98GotoShadingPosition( pScanData ps )
889 result = motorP98CheckSensorInHome( ps );
894 MotorSetConstantMove( ps, 0 ); /* clear scan states */
896 IOCmdRegisterToScanner( ps, ps->RegModelControl,
897 ps->AsicReg.RD_ModelControl );
899 ps->Scan.fMotorBackward = _FALSE; /* forward */
900 ps->bExtraMotorCtrl = 0;
902 if( ps->DataInf.dwScanFlag & SCANDEF_TPA ) {
904 ps->bFastMoveFlag = _FastMove_Low_C75_G150;
905 MotorP98GoFullStep( ps, 0x40 );
907 ps->bFastMoveFlag = _FastMove_Middle_C75_G150;
908 MotorP98GoFullStep( ps, ps->Device.dwModelOriginY );
911 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
912 IOSetToMotorRegister( ps );
920 static void motorP98SetMaxDpiAndLength( pScanData ps,
923 if (ps->DataInf.xyAppDpi.y > 600)
924 *wLengthY = ps->LensInf.rExtentY.wMax * 4 + 200;
926 *wLengthY = ps->LensInf.rExtentY.wMax * 2 + 200;
928 if ((ps->DataInf.wPhyDataType >= COLOR_TRUE24) &&
929 (ps->DataInf.xyAppDpi.y <= ps->wMinCmpDpi)) {
930 *wBaseDpi = ps->wMinCmpDpi;
932 if ((ps->DataInf.wPhyDataType < COLOR_TRUE24) &&
933 (ps->DataInf.xyAppDpi.y <= 75)) {
936 if (ps->DataInf.xyAppDpi.y <= 150) {
939 if (ps->DataInf.xyAppDpi.y <= 300) {
942 if (ps->DataInf.xyAppDpi.y <= 600)
951 DBG( DBG_LOW, "wBaseDPI = %u, %u\n", *wBaseDpi, ps->wMinCmpDpi );
957 static void motorP98FillGBColorRunTable( pScanData ps, pUChar pTable,
961 if( ps->Device.f0_8_16 ) {
963 if (wBaseDpi == ps->wMinCmpDpi) {
991 if (wBaseDpi == ps->wMinCmpDpi) {
1024 static void motorP98SetupRunTable( pScanData ps )
1029 motorP98SetMaxDpiAndLength( ps, &wLengthY, &wBaseDpi );
1032 memset( ps->pColorRunTable, 0, ps->BufferForColorRunTable );
1036 pTable = ps->pColorRunTable + (_NUMBER_OF_SCANSTEPS / 4);
1038 if( ps->DataInf.wPhyDataType >= COLOR_TRUE24) {
1041 if((short)(wDpi -= ps->DataInf.xyPhyDpi.y) <= 0) {
1044 motorP98FillGBColorRunTable( ps, pTable, 0x22, 0x11, wBaseDpi );
1049 if((short)(wDpi -= ps->DataInf.xyPhyDpi.y) <= 0) {
1055 ps->dwColorRunIndex = 0;
1061 static void motorP98UpdateDataCurrentReadLine( pScanData ps )
1063 if(!(ps->Scan.bNowScanState & _SCANSTATE_STOP)) {
1067 if (ps->Scan.bNowScanState >= ps->bCurrentLineCount)
1068 b = ps->Scan.bNowScanState - ps->bCurrentLineCount;
1070 b = ps->Scan.bNowScanState + _NUMBER_OF_SCANSTEPS - ps->bCurrentLineCount;
1076 ps->SetMotorSpeed( ps, ps->bCurrentSpeed, _TRUE );
1077 IOSetToMotorRegister( ps );
1079 ps->Scan.bModuleState = _MotorAdvancing;
1087 static void motorP96GetScanStateAndStatus( pScanData ps, pScanState pScanStep )
1089 ps->OpenScanPath( ps );
1091 pScanStep->bStep = IOGetScanState(ps, _TRUE);
1093 pScanStep->bStatus = IODataFromRegister( ps, ps->RegStatus );
1095 ps->CloseScanPath( ps );
1101 static Byte motorP96ReadDarkData( pScanData ps )
1111 bFifoOffset = IODataRegisterFromScanner( ps, ps->RegFifoOffset );
1117 IOReadScannerImageData( ps, ps->pScanBuffer1, 512UL);
1121 wSum += (UShort)ps->pScanBuffer1[w];/* average data from */
1134 static void motorP96PositionYProc( pScanData ps, ULong dwStates )
1138 memset( ps->pColorRunTable, 1, dwStates );
1144 memset( ps->pColorRunTable + dwStates, 0xff, 800UL - dwStates );
1146 IOGetCurrentStateCount( ps, &sState );
1147 ps->bOldStateCount = sState.bStep;
1150 if( ps->Scan.fMotorBackward ) {
1151 IOCmdRegisterToScanner( ps, ps->RegMotorControl,
1152 (Byte)(ps->IgnorePF | ps->MotorOn));
1154 IOCmdRegisterToScanner( ps, ps->RegMotorControl,
1155 (Byte)(ps->IgnorePF | ps->MotorOn | _MotorDirForward));
1158 ps->pScanState = ps->pColorRunTable;
1160 ps->FillRunNewAdrPointer( ps );
1162 } while (!motorCheckMotorPresetLength( ps ));
1168 static void motorP96WaitForPositionY( pScanData ps )
1176 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
1178 ps->Asic96Reg.RD_MotorControl = ps->IgnorePF|ps->MotorOn|_MotorDirForward;
1179 ps->Scan.fMotorBackward = _FALSE;
1180 ps->bExtraMotorCtrl = ps->IgnorePF;
1182 if( ps->DataInf.xyAppDpi.y <= ps->PhysicalDpi )
1187 dw = (dw + ps->DataInf.crImage.y) * 4 / 3;
1189 if( ps->DataInf.wPhyDataType == COLOR_TRUE24 )
1192 else if( ps->DataInf.wPhyDataType == COLOR_256GRAY )
1203 memset( ps->pColorRunTable, 1, dw );
1204 memset( ps->pColorRunTable + dw, 0xff, ps->BufferForColorRunTable - dw );
1206 IOGetCurrentStateCount( ps, &sState );
1207 ps->bOldStateCount = sState.bStep;
1210 IOCmdRegisterToScanner( ps, ps->RegLineControl, 31 );
1213 if( ps->Scan.fMotorBackward )
1214 IOCmdRegisterToScanner( ps, ps->RegMotorControl, _Motor1FullStep |
1215 ps->IgnorePF | ps->MotorOn );
1217 IOCmdRegisterToScanner( ps, ps->RegMotorControl, ps->IgnorePF |
1218 ps->MotorOn | _MotorDirForward );
1220 ps->pScanState = ps->pColorRunTable;
1223 ps->FillRunNewAdrPointer( ps );
1225 } while (!motorCheckMotorPresetLength(ps));
1228 IOCmdRegisterToScanner( ps, ps->RegLineControl,
1229 ps->AsicReg.RD_LineControl );
1234 if( ps->DataInf.wPhyDataType != COLOR_TRUE24 )
1237 motorP96PositionYProc( ps, dw );
1249 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
1251 ps->Asic96Reg.RD_MotorControl = ps->IgnorePF|ps->MotorOn|_MotorDirForward;
1252 ps->Scan.fMotorBackward = _FALSE;
1253 ps->bExtraMotorCtrl = ps->IgnorePF;
1255 if ((ps->DataInf.wPhyDataType >= COLOR_TRUE24) ||
1256 (ps->DataInf.xyAppDpi.y <= 300)) {
1261 if (ps->DataInf.xyAppDpi.y <= 600) {
1263 dw = (ULong)ps->DataInf.xyAppDpi.y / 50UL + 3UL;
1268 dw += ps->DataInf.crImage.y;
1273 /* GoFullStep (ps, dw);----------------------------------------------*/
1274 memset( ps->pColorRunTable, 1, dw );
1279 memset( ps->pColorRunTable + dw, 0xff, 8000UL - dw );
1281 IOGetCurrentStateCount( ps, &sState );
1282 ps->bOldStateCount = sState.bStep;
1284 /* SetRunFullStep (ps) */
1285 if( ps->Scan.fMotorBackward ) {
1286 IOCmdRegisterToScanner( ps, ps->RegMotorControl,
1287 (Byte)(ps->FullStep | ps->IgnorePF | ps->MotorOn));
1289 IOCmdRegisterToScanner( ps, ps->RegMotorControl,
1290 (Byte)(ps->FullStep | ps->IgnorePF | ps->MotorOn |
1294 ps->pScanState = ps->pColorRunTable;
1297 ps->FillRunNewAdrPointer (ps);
1299 } while (!motorCheckMotorPresetLength(ps));
1306 if (ps->DataInf.wPhyDataType != COLOR_TRUE24)
1311 motorP96PositionYProc( ps, dw );
1319 static void motorP96ConstantMoveProc1( pScanData ps, ULong dwLines )
1340 MotorSetConstantMove( ps, 1 );
1342 ps->OpenScanPath( ps );
1344 ps->AsicReg.RD_ModeControl = _ModeScan;
1345 IODataToRegister( ps, ps->RegModeControl, _ModeScan );
1347 ps->Asic96Reg.RD_MotorControl = ps->MotorFreeRun |
1348 ps->MotorOn | _MotorDirForward;
1349 IODataToRegister( ps, ps->RegMotorControl, ps->Asic96Reg.RD_MotorControl );
1351 ps->CloseScanPath( ps );
1360 motorP96GetScanStateAndStatus( ps, &StateStatus );
1378 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
1379 IOSetToMotorRegister( ps );
1395 static Bool motorP96GotoShadingPosition( pScanData ps )
1399 MotorSetConstantMove( ps, 0 ); /* clear scan states */
1400 ps->Scan.fMotorBackward = _FALSE; /* forward */
1401 ps->bExtraMotorCtrl = ps->IgnorePF;
1403 MotorP96ConstantMoveProc( ps, 15 * 12 ); /* forward 180 lines */
1405 if (IODataRegisterFromScanner(ps, ps->RegStatus) & _FLAG_P96_PAPER ) {
1406 ps->Asic96Reg.RD_MotorControl = 0;
1407 IOCmdRegisterToScanner( ps, ps->RegMotorControl, 0 );
1412 ps->Scan.fMotorBackward = _TRUE; /* backward */
1413 ps->bExtraMotorCtrl = 0; /* no extra action for motor */
1416 MotorP96ConstantMoveProc( ps, ps->BackwardSteps );
1420 IOCmdRegisterToScanner( ps, ps->RegModelControl,
1421 (Byte)(ps->AsicReg.RD_ModelControl | _ModelInvertPF));
1423 ps->Scan.fMotorBackward = _FALSE; /* forward */
1424 motorP96ConstantMoveProc1( ps, 14 * 12 * 2); /* ahead 336 lines */
1426 if( MODEL_OP_A3I == ps->sCaps.Model ) {
1428 motorP96PositionYProc( ps, 80 );
1432 if (!ps->fColorMoreRedFlag)
1433 motorP96PositionYProc( ps, ps->wOverBlue + 12 * 2);
1436 if( ps->DataInf.dwScanFlag & SCANDEF_TPA ) {
1437 ps->Scan.fMotorBackward = _FALSE;
1438 ps->bExtraMotorCtrl = ps->IgnorePF;
1439 MotorP96ConstantMoveProc( ps, 1200 );
1442 IOCmdRegisterToScanner( ps, ps->RegModelControl,
1443 ps->AsicReg.RD_ModelControl );
1450 static void motorP96FillHalfStepTable( pScanData ps )
1453 if ( ps->Scan.bModuleState == _MotorInStopState ) {
1457 ps->bMotorStepTableNo = a_bMotorDown2Table[(ps->bMotorSpeedData-1)/2];
1461 if( ps->bMotorSpeedData & 1 ) {
1464 ((ps->Scan.bModuleState != _MotorInStopState) ? 1 : 0),
1473 bHalfSteps = ps->bMotorSpeedData / 2;
1474 pwMoveStep = &a_wMoveStepTable[ps->bCurrentLineCount];
1475 pbHalfStepTbl = &a_bHalfStepTable[ps->bCurrentLineCount];
1477 if( ps->DataInf.wAppDataType == COLOR_TRUE24)
1492 if( ps->DataInf.wAppDataType == COLOR_TRUE24 ) {
1500 if( wP96BaseDpi <= ps->PhysicalDpi && *pwMoveStep != 2 )
1531 if ( ps->Scan.bModuleState == _MotorInStopState ) {
1535 ps->bMotorStepTableNo = a_bMotorDown2Table[(ps->bMotorSpeedData-1)/2];
1539 if( ps->bMotorSpeedData & 1 ) {
1542 ((ps->Scan.bModuleState != _MotorInStopState) ? 1 : 0),
1550 pbHalfStepContent = a_pbHalfStepTables[ps->bMotorSpeedData / 2 - 1];
1552 pwMoveStep = &a_wMoveStepTable[ps->bCurrentLineCount];
1553 pbHalfStepTbl = &a_bHalfStepTable[ps->bCurrentLineCount];
1555 if (ps->DataInf.wAppDataType == COLOR_TRUE24)
1574 if (ps->Scan.bModuleState != _MotorInStopState) {
1577 if (ps->bMotorStepTableNo) {
1578 ps->bMotorStepTableNo--;
1589 if (ps->Scan.bModuleState == _MotorInStopState) {
1590 if (ps->bMotorStepTableNo) {
1591 ps->bMotorStepTableNo--;
1618 static void motorP96FillDataToColorTable( pScanData ps,
1631 if( *pw >= ps->BufferForColorRunTable ) {
1633 *pw, ps->BufferForColorRunTable );
1636 bColor = ps->pColorRunTable [*pw]; /* get the colors */
1644 if (bColor & ps->b1stColor) {
1646 *pb1 = ps->b1stColorByte;
1651 if (bColor & ps->b2ndColor) {
1653 *pb1 = ps->b2ndColorByte;
1658 if (bColor & ps->b3rdColor)
1659 *pb1 = ps->b3rdColorByte;
1673 /* ps->bOldSpeed = ps->bMotorRunStatus; non functional */
1677 pb = ps->a_nbNewAdrPointer; dwSteps; dwSteps--, pw++, pb++) {
1685 pb = ps->a_nbNewAdrPointer; dwSteps; dwSteps--, pb1++, pb++) {
1698 static void motorP96FillBackColorDataTable( pScanData ps )
1703 if ((ps->bCurrentLineCount + ps->bNewCurrentLineCountGap + 1) >=
1705 bIndex = ps->bCurrentLineCount + ps->bNewCurrentLineCountGap + 1 -
1708 bIndex = ps->bCurrentLineCount + ps->bNewCurrentLineCountGap + 1;
1710 dw = _NUMBER_OF_SCANSTEPS - ps->bNewCurrentLineCountGap;
1712 motorP96FillDataToColorTable( ps, bIndex, dw );
1725 static void motorP96FillBackLoop( pScanData ps,
1736 if (ps->dwScanStateCount & 1)
1737 ps->a_nbNewAdrPointer[ps->dwScanStateCount / 2] |= 0x40;
1739 ps->a_nbNewAdrPointer[ps->dwScanStateCount / 2] |= 0x04;
1749 if (++ps->dwScanStateCount == _NUMBER_OF_SCANSTEPS)
1750 ps->dwScanStateCount = 0; /* reset to begin */
1754 ps->fFullLength = _FALSE;
1756 ps->fFullLength = _TRUE;
1758 IOSetToMotorStepCount( ps ); /* put all scan states to ASIC */
1765 static void motorP96FillRunNewAdrPointer( pScanData ps )
1769 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES);
1771 IOGetCurrentStateCount( ps, &sState );
1773 if (sState.bStep < ps->bOldStateCount )
1779 sState.bStep -= ps->bOldStateCount; /* how many states passed */
1780 ps->pScanState += sState.bStep;
1787 memset( ps->pScanState, 1, _NUMBER_OF_SCANSTEPS - sState.bStep - 1 );
1789 IOGetCurrentStateCount( ps, &sState);
1790 ps->bOldStateCount = sState.bStep; /* update current state */
1791 ps->dwScanStateCount = (ULong)((sState.bStep + 1) & (_NUMBER_OF_SCANSTEPS - 1));
1794 motorP96FillBackLoop( ps, ps->pScanState, (_NUMBER_OF_SCANSTEPS - 1));
1800 static void motorP96SetupRunTable( pScanData ps )
1809 /* SetMaxDpiAndLength (ps) */
1811 if( ps->DataInf.xyPhyDpi.y > ps->PhysicalDpi ) {
1814 wP96BaseDpi = ps->PhysicalDpi *2;
1817 wP96BaseDpi = ps->LensInf.rDpiY.wPhyMax >> 1;
1820 if( ps->DataInf.xyPhyDpi.y > (ps->LensInf.rDpiY.wPhyMax / 2)) {
1822 wLengthY = ps->LensInf.rExtentY.wMax << 1;
1823 wP96BaseDpi = ps->LensInf.rDpiY.wPhyMax;
1825 wLengthY = ps->LensInf.rExtentY.wMax;
1826 wP96BaseDpi = ps->LensInf.rDpiY.wPhyMax >> 1;
1832 /* ClearColorRunTable (ps) */
1833 memset( ps->pColorRunTable, 0, ps->BufferForColorRunTable ); /*wLengthY + 0x60 ); */
1835 p.pb = ps->pColorRunTable + _SCANSTATE_BYTES;
1843 if (ps->DataInf.wPhyDataType != COLOR_TRUE24) {
1845 if ((siSum -= (Short)ps->DataInf.xyPhyDpi.y) <= 0) {
1852 memset( ps->pColorRunTable + _NUMBER_OF_SCANSTEPS / 8 + wLengthY,
1859 if (ps->fSonyCCD) {
1861 if((ps->sCaps.Model == MODEL_OP_12000P) ||
1862 (ps->sCaps.Model == MODEL_OP_A3I)) {
1873 if ((siSum -= (Short)ps->DataInf.xyPhyDpi.y) <= 0) {
1876 if((ps->sCaps.Model == MODEL_OP_12000P)||
1877 (ps->sCaps.Model == MODEL_OP_A3I)) {
1890 memset( ps->pColorRunTable + _NUMBER_OF_SCANSTEPS / 8 + wLengthY,
1893 if (ps->DataInf.xyPhyDpi.y < 100) {
1898 if (ps->fSonyCCD)
1904 p.pb = ps->pColorRunTable + _SCANSTATE_BYTES;
1923 if (*p.pb & ps->RedDataReady) {
1940 static void motorP96UpdateDataCurrentReadLine( pScanData ps )
1945 IOGetCurrentStateCount( ps, &State1 );
1946 IOGetCurrentStateCount( ps, &State2 );
1953 if (State2.bStep < ps->bCurrentLineCount) {
1955 ps->bCurrentLineCount;
1957 State2.bStep -= ps->bCurrentLineCount;
1964 State2.bStatus = IOGetScanState( ps, _FALSE );
1974 if( ps->bFifoCount >= 140) {
1976 if( ps->bFifoCount >= 20) {
1978 if( 1 == ps->bCurrentSpeed ) {
1979 ps->bCurrentSpeed *= 2;
1981 if( COLOR_TRUE24 == ps->DataInf.wPhyDataType )
1982 ps->bCurrentSpeed += 4;
1984 ps->bCurrentSpeed += 2;
1987 MotorP96AdjustCurrentSpeed( ps, ps->bCurrentSpeed );
1997 if((600 == ps->PhysicalDpi) && (1 == ps->bCurrentSpeed)) {
1999 if( ps->Asic96Reg.RD_MotorControl & ps->FullStep ) {
2000 ps->Asic96Reg.RD_MotorControl &= ~ps->FullStep;
2001 IOCmdRegisterToScanner( ps, ps->RegMotorControl,
2002 ps->Asic96Reg.RD_MotorControl );
2006 ps->SetMotorSpeed( ps, ps->bCurrentSpeed, _TRUE );
2008 IOSetToMotorRegister( ps);
2016 static void motorGoHalfStep1( pScanData ps )
2020 IOGetCurrentStateCount( ps, &sState );
2022 ps->bOldStateCount = sState.bStep;
2024 motorSetRunPositionRegister(ps);
2025 ps->pScanState = a_bScanStateTable;
2027 if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
2029 ps->FillRunNewAdrPointer( ps );
2031 while (!motorCheckMotorPresetLength(ps))
2032 motorP98FillRunNewAdrPointer1( ps );
2035 while (!motorCheckMotorPresetLength( ps ))
2036 ps->FillRunNewAdrPointer( ps );
2044 static void motorP96WaitBack( pScanData ps )
2061 if( ps->DataInf.xyPhyDpi.y > ps->PhysicalDpi )
2066 IORegisterDirectToScanner( ps, ps->RegInitDataFifo );
2071 ps->Scan.fMotorBackward = _TRUE;
2072 motorGoHalfStep1( ps ); /* backward 130 lines */
2076 if( ps->DataInf.xyPhyDpi.y <= ps->PhysicalDpi ) {
2077 if( ps->DataInf.wPhyDataType == COLOR_TRUE24 ) {
2089 ps->Scan.fMotorBackward = _FALSE;
2090 motorGoHalfStep1( ps ); /* move forward */
2093 ps->bCurrentLineCount = IOGetScanState( ps, _FALSE ) & _SCANSTATE_MASK;
2094 ps->bNewCurrentLineCountGap = 0;
2103 p.pw = &a_wMoveStepTable[((ps->bCurrentLineCount + 1) & 0x3f)];
2107 for(w = wStayMaxStep, Data.bValue = ps->bMotorSpeedData, dw = 60;dw;dw--) {
2115 Data.bValue = ps->bMotorSpeedData; /* speed value */
2122 motorP96FillHalfStepTable( ps );
2123 motorP96FillBackColorDataTable( ps );
2130 static void motorP98WaitBack( pScanData ps )
2139 p.pw = &a_wMoveStepTable[ps->bCurrentLineCount];
2153 if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
2167 ps->Scan.fMotorBackward = _TRUE;
2168 motorGoHalfStep1( ps );
2174 ps->Scan.fMotorBackward = _FALSE;
2175 motorGoHalfStep1( ps );
2177 ps->bNewCurrentLineCountGap = 0;
2182 ps->bCurrentLineCount = (ps->bCurrentLineCount + 1) & 0x3f;
2184 p.pw = &a_wMoveStepTable[ps->bCurrentLineCount];
2186 for (w = wStayMaxStep, Data.bValue = ps->bMotorSpeedData,
2193 Data.bValue = ps->bMotorSpeedData;
2202 if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
2203 motorP98FillHalfStepTable( ps );
2204 motorP98FillBackColorDataTable( ps );
2206 motorP96FillHalfStepTable( ps );
2207 motorP96FillBackColorDataTable( ps );
2214 static void motorFillMoveStepTable( pScanData ps,
2225 b = ps->bMotorSpeedData;
2229 b = ps->bMotorSpeedData;
2240 if( _ASIC_IS_98001 == ps->sCaps.AsicID )
2241 motorP98FillHalfStepTable( ps );
2243 motorP96FillHalfStepTable( ps );
2245 if ((ps->bCurrentLineCount + 1) >= _NUMBER_OF_SCANSTEPS) {
2246 b = ps->bCurrentLineCount + 1 - _NUMBER_OF_SCANSTEPS;
2248 b = ps->bCurrentLineCount + 1;
2251 if( _ASIC_IS_98001 == ps->sCaps.AsicID )
2252 motorP98FillDataToColorTable( ps, b, _NUMBER_OF_SCANSTEPS - 1);
2254 motorP96FillDataToColorTable( ps, b, _NUMBER_OF_SCANSTEPS - 1);
2260 static void noMotorRunStatusStop( pScanData ps, Byte bScanState )
2267 ps->bCurrentLineCount = (bScanState & _SCANSTATE_MASK);
2269 ps->Scan.fRefreshState = _FALSE;
2271 IORegisterDirectToScanner( ps, ps->RegRefreshScanState );
2273 bCur = ps->bCurrentLineCount;
2275 pb = ps->pColorRunTable;
2283 motorClearColorByteTableLoop0( ps, b );
2284 ps->bNewCurrentLineCountGap = b;
2286 motorFillMoveStepTable( ps, *pw, 1, pw );
2317 ps->bNewCurrentLineCountGap = 0;
2318 ps->bNewGap = 0;
2320 ps->bNewCurrentLineCountGap = b1;
2321 ps->bNewGap = b;
2324 motorClearColorByteTableLoop1( ps );
2326 motorFillMoveStepTable( ps, *pw, 0, pw);
2332 static void motorP96SetSpeed( pScanData ps, Byte bSpeed, Bool fSetRunState )
2345 ps->Scan.bModuleState = _MotorInNormalState;
2347 ps->bMotorSpeedData = bSpeed;
2349 if( ps->bMoveDataOutFlag == _DataAfterRefreshState) {
2351 ps->bMoveDataOutFlag = _DataInNormalState;
2356 if ((bState = IOGetScanState( ps, _FALSE)) & _SCANSTATE_STOP) {
2357 ps->bCurrentLineCount = bState & ~_SCANSTATE_STOP;
2358 motorP96WaitBack( ps );
2364 bState = IOGetScanState( ps, _FALSE );
2366 if((ps->Scan.bModuleState != _MotorInStopState) ||
2380 ps->bCurrentLineCount = (bState &= _SCANSTATE_MASK);
2381 ps->Scan.fRefreshState = _TRUE;
2383 IORegisterDirectToScanner( ps, ps->RegRefreshScanState );
2387 bState = ps->bCurrentLineCount;
2392 bColors = a_bColorsSum[ ps->pColorRunTable[*pw] / 16];
2396 motorClearColorByteTableLoop0( ps, bColors );
2397 ps->bNewCurrentLineCountGap = bColors;
2422 if((bColors = a_bColorsSum [ps->pColorRunTable[wMoveStep] / 16]))
2438 ps->bNewCurrentLineCountGap = bData;
2439 ps->bNewGap = bColors;
2440 motorClearColorByteTableLoop1( ps );
2451 motorP96GetStartStopGap( ps, _TRUE );
2453 if( !ps->bMotorStepTableNo )
2454 ps->bMotorStepTableNo = 1;
2456 if( ps->bMotorStepTableNo != 0xff && ps->IO.portMode == _PORT_SPP &&
2457 ps->DataInf.xyPhyDpi.y <= 200) {
2458 ps->bMotorStepTableNo++;
2465 bData = ps->bMotorSpeedData; dw; dw-- ) {
2468 bData = ps->bMotorSpeedData;
2469 if( ps->bMotorStepTableNo ) {
2471 ps->bMotorStepTableNo--;
2489 motorP96FillHalfStepTable( ps );
2492 if((ps->bCurrentLineCount + 1) < _NUMBER_OF_SCANSTEPS )
2493 bState = ps->bCurrentLineCount + 1;
2495 bState = ps->bCurrentLineCount + 1 - _NUMBER_OF_SCANSTEPS;
2497 motorP96FillDataToColorTable( ps, bState, _NUMBER_OF_SCANSTEPS - 1);
2504 static void motorP98SetSpeed( pScanData ps, Byte bSpeed, Bool fSetRunState )
2512 ps->Scan.bModuleState = _MotorInNormalState;
2514 ps->bMotorSpeedData = bSpeed;
2517 if( _ASIC_IS_98001 != ps->sCaps.AsicID ) {
2518 ps->bMoveDataOutFlag = _DataInNormalState;
2520 bData = IODataRegisterFromScanner( ps, ps->RegFifoOffset );
2530 bOld1ScanState = IOGetScanState( ps, _FALSE );
2533 noMotorRunStatusStop( ps, bOld1ScanState );
2535 ps->bCurrentLineCount = (bOld1ScanState & 0x3f);
2536 ps->Scan.bModuleState = _MotorGoBackward;
2538 motorP98WaitBack( ps );
2543 if( _ASIC_IS_98001 != ps->sCaps.AsicID )
2544 ps->bMoveDataOutFlag = _DataFromStopState;
2551 static void motorP98003ModuleFreeRun( pScanData ps, ULong steps )
2553 IODataToRegister( ps, ps->RegMotorFreeRunCount1, (_HIBYTE(steps)));
2554 IODataToRegister( ps, ps->RegMotorFreeRunCount0, (_LOBYTE(steps)));
2555 IORegisterToScanner( ps, ps->RegMotorFreeRunTrigger );
2561 static void motorP98003ModuleToHome( pScanData ps )
2563 if(!(IODataFromRegister( ps, ps->RegStatus ) & _FLAG_P98_PAPER)) {
2565 IODataToRegister( ps, ps->RegMotor0Control,
2566 (Byte)(ps->AsicReg.RD_Motor0Control|_MotorDirForward));
2568 MotorP98003PositionYProc( ps, 40 );
2569 MotorP98003BackToHomeSensor( ps );
2577 static void motorP98003DownloadNullScanStates( pScanData ps )
2579 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
2580 IODownloadScanStates( ps );
2586 static void motorP98003Force16Steps( pScanData ps )
2590 IODataToRegister( ps, ps->RegStepControl, _MOTOR0_ONESTEP);
2591 IODataToRegister( ps, ps->RegMotor0Control, _FORWARD_MOTOR );
2594 IORegisterToScanner( ps, ps->RegForceStep );
2598 IODataToRegister( ps, ps->RegStepControl, _MOTOR0_SCANSTATE );
2604 static void motorP98003WaitForPositionY( pScanData ps )
2609 dwBeginY = (ULong)ps->DataInf.crImage.y * 4 + ps->Scan.dwScanOrigin;
2611 if( ps->DataInf.wPhyDataType <= COLOR_256GRAY ) {
2612 if( ps->Device.f0_8_16 )
2618 bXStep = (Byte)((ps->DataInf.wPhyDataType <= COLOR_256GRAY) ?
2619 ps->Device.XStepMono : ps->Device.XStepColor);
2621 if( ps->Shade.bIntermediate & _ScanMode_AverageOut )
2624 motorP98003Force16Steps( ps);
2628 bXStep < ps->AsicReg.RD_XStepTime) {
2630 IODataToRegister( ps, ps->RegMotorDriverType, ps->Scan.motorPower );
2632 IODataToRegister( ps, ps->RegXStepTime, bXStep);
2633 IODataToRegister( ps, ps->RegExtendedXStep, 0 );
2634 IODataToRegister( ps, ps->RegScanControl1,
2635 (UChar)(ps->AsicReg.RD_ScanControl1 & ~_MFRC_RUNSCANSTATE));
2636 MotorP98003PositionYProc( ps, dwBeginY - 64 );
2640 IODataToRegister( ps, ps->RegFifoFullLength0, _LOBYTE(ps->AsicReg.RD_BufFullSize));
2641 IODataToRegister( ps, ps->RegFifoFullLength1, _HIBYTE(ps->AsicReg.RD_BufFullSize));
2642 IODataToRegister( ps, ps->RegFifoFullLength2, _LOBYTE(_HIWORD(ps->AsicReg.RD_BufFullSize)));
2644 IODataToRegister( ps, ps->RegMotorDriverType, ps->AsicReg.RD_MotorDriverType);
2647 if(!ps->Device.f2003 || (ps->Shade.bIntermediate & _ScanMode_AverageOut) ||
2648 ( ps->DataInf.xyAppDpi.y <= 75 &&
2649 ps->DataInf.wPhyDataType <= COLOR_256GRAY)) {
2650 IODataToRegister( ps, ps->RegMotorDriverType,
2651 (Byte)(ps->Scan.motorPower & (_MOTORR_MASK | _MOTORR_STRONG)));
2653 IODataToRegister( ps, ps->RegMotorDriverType,
2654 ps->AsicReg.RD_MotorDriverType );
2657 IODataToRegister( ps, ps->RegXStepTime, ps->AsicReg.RD_XStepTime );
2658 IODataToRegister( ps, ps->RegExtendedXStep, ps->AsicReg.RD_ExtXStepTime );
2659 IODataToRegister( ps, ps->RegScanControl1,
2660 (Byte)(ps->AsicReg.RD_ScanControl1 & ~_MFRC_RUNSCANSTATE));
2662 if( ps->DataInf.dwVxdFlag & _VF_PREVIEW ) {
2666 motorP98003ModuleFreeRun( ps, dwBeginY );
2671 while(( IOGetExtendedStatus( ps ) & _STILL_FREE_RUNNING) &&
2673 IODataToRegister( ps, ps->RegModeControl, _ModeScan );
2675 MotorP98003PositionYProc( ps, dwBeginY );
2676 IORegisterToScanner( ps, ps->RegRefreshScanState );
2683 static Bool motorP98003GotoShadingPosition( pScanData ps )
2685 motorP98003ModuleToHome( ps );
2688 if( ps->DataInf.dwScanFlag & SCANDEF_TPA ) {
2690 MotorP98003ForceToLeaveHomePos( ps );
2691 motorP98003DownloadNullScanStates( ps );
2693 IODataToRegister( ps, ps->RegStepControl, _MOTOR0_SCANSTATE );
2694 IODataToRegister( ps, ps->RegModeControl, _ModeScan);
2695 IODataToRegister( ps, ps->RegMotor0Control, _FORWARD_MOTOR );
2696 IODataToRegister( ps, ps->RegXStepTime, 6);
2697 IODataToRegister( ps, ps->RegExtendedXStep, 0);
2698 IODataToRegister( ps, ps->RegScanControl1, _MFRC_BY_XSTEP);
2700 MotorP98003PositionYProc( ps, _TPA_P98003_SHADINGORG );
2710 static void motorP98003PositionModuleToHome( pScanData ps )
2714 saveModel = ps->AsicReg.RD_ModelControl;
2716 ps->Scan.fRefreshState = _FALSE;
2717 motorP98003DownloadNullScanStates( ps );
2721 save = ps->Shade.bIntermediate;
2723 ps->Shade.bIntermediate = _ScanMode_AverageOut;
2724 ps->ReInitAsic( ps, _FALSE );
2725 ps->Shade.bIntermediate = save;
2727 IODataToRegister( ps, ps->RegModeControl, _ModeScan );
2728 IORegisterToScanner( ps, ps->RegResetMTSC );
2729 IODataToRegister( ps, ps->RegScanControl1, 0 );
2731 IODataToRegister( ps, ps->RegModelControl,
2732 ps->Device.ModelCtrl | _ModelDpi300 );
2734 IODataToRegister( ps, ps->RegLineControl, 80);
2735 IODataToRegister( ps, ps->RegXStepTime, ps->Device.XStepBack);
2736 IODataToRegister( ps, ps->RegMotorDriverType, ps->Scan.motorPower);
2740 IODataToRegister( ps, ps->RegMotor0Control,
2743 IODataToRegister( ps, ps->RegStepControl,
2746 memset( ps->a_nbNewAdrPointer, 0x88, _SCANSTATE_BYTES );
2747 IODownloadScanStates( ps );
2748 IORegisterToScanner( ps, ps->RegRefreshScanState );
2750 ps->AsicReg.RD_ModelControl = saveModel;
2759 _LOC int MotorInitialize( pScanData ps )
2763 if( NULL == ps )
2766 ps->a_wMoveStepTable = a_wMoveStepTable;
2767 ps->a_bColorByteTable = a_bColorByteTable;
2770 ps->PauseColorMotorRunStates = motorPauseColorMotorRunStates;
2775 if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
2777 ps->WaitForPositionY = motorP98WaitForPositionY;
2778 ps->GotoShadingPosition = motorP98GotoShadingPosition;
2779 ps->FillRunNewAdrPointer = motorP98FillRunNewAdrPointer;
2780 ps->SetupMotorRunTable = motorP98SetupRunTable;
2781 ps->UpdateDataCurrentReadLine = motorP98UpdateDataCurrentReadLine;
2782 ps->SetMotorSpeed = motorP98SetSpeed;
2784 } else if( _ASIC_IS_98003 == ps->sCaps.AsicID ) {
2786 ps->WaitForPositionY = motorP98003WaitForPositionY;
2787 ps->GotoShadingPosition = motorP98003GotoShadingPosition;
2788 ps->SetMotorSpeed = motorP98SetSpeed;
2790 } else if( _IS_ASIC96(ps->sCaps.AsicID)) {
2792 ps->WaitForPositionY = motorP96WaitForPositionY;
2793 ps->GotoShadingPosition = motorP96GotoShadingPosition;
2794 ps->FillRunNewAdrPointer = motorP96FillRunNewAdrPointer;
2795 ps->SetupMotorRunTable = motorP96SetupRunTable;
2796 ps->UpdateDataCurrentReadLine = motorP96UpdateDataCurrentReadLine;
2797 ps->SetMotorSpeed = motorP96SetSpeed;
2810 _LOC void MotorSetConstantMove( pScanData ps, Byte bMovePerStep )
2815 p.pb = ps->a_nbNewAdrPointer;
2822 if( _ASIC_IS_98001 == ps->sCaps.AsicID )
2831 if( _ASIC_IS_98001 == ps->sCaps.AsicID )
2840 if( _ASIC_IS_98001 == ps->sCaps.AsicID )
2853 if( _ASIC_IS_98001 == ps->sCaps.AsicID )
2860 if( _ASIC_IS_98001 == ps->sCaps.AsicID )
2869 IOSetToMotorRegister( ps );
2875 _LOC void MotorToHomePosition( pScanData ps )
2883 if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
2885 if (!(IODataRegisterFromScanner(ps,ps->RegStatus) & _FLAG_P98_PAPER)){
2886 ps->GotoShadingPosition( ps );
2888 } else if( _ASIC_IS_98003 == ps->sCaps.AsicID ) {
2890 ps->OpenScanPath( ps );
2892 if( !(IODataFromRegister( ps, ps->RegStatus ) & _FLAG_P98_PAPER)) {
2894 motorP98003PositionModuleToHome( ps );
2899 if( IODataFromRegister( ps, ps->RegStatus ) & _FLAG_P98_PAPER)
2903 ps->CloseScanPath( ps );
2907 if( ps->sCaps.Model >= MODEL_OP_9630P ) {
2908 if( ps->sCaps.Model == MODEL_OP_A3I )
2909 IOCmdRegisterToScanner( ps, ps->RegLineControl, 0x34 );
2911 IOCmdRegisterToScanner( ps, ps->RegLineControl, 0x30 );
2914 ps->bExtraMotorCtrl = 0;
2915 ps->Scan.fMotorBackward = _FALSE;
2916 MotorP96ConstantMoveProc( ps, 25 );
2918 ps->Scan.fMotorBackward = _TRUE;
2921 motorP96GetScanStateAndStatus( ps, &StateStatus );
2927 MotorP96ConstantMoveProc( ps, 50000 );
2930 ps->Scan.fMotorBackward = _FALSE;
2931 ps->Asic96Reg.RD_MotorControl = 0;
2932 IOCmdRegisterToScanner( ps, ps->RegMotorControl, 0 );
2934 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
2935 IOSetToMotorRegister( ps );
2938 ps->Asic96Reg.RD_LedControl = 0;
2939 IOCmdRegisterToScanner(ps, ps->RegLedControl, ps->Asic96Reg.RD_LedControl);
2948 _LOC void MotorP98GoFullStep( pScanData ps, ULong dwStep )
2950 memset( ps->pColorRunTable, 1, dwStep );
2951 memset( ps->pColorRunTable + dwStep, 0xff, 0x40);
2953 ps->bOldStateCount = IOGetScanState( ps, _FALSE ) & _SCANSTATE_MASK;
2954 motorP98SetRunFullStep( ps );
2956 ps->pScanState = ps->pColorRunTable;
2957 ps->FillRunNewAdrPointer( ps );
2959 while(!motorCheckMotorPresetLength( ps ))
2960 motorP98FillRunNewAdrPointer1( ps );
2966 _LOC void MotorP96SetSpeedToStopProc( pScanData ps )
2974 bData = IODataRegisterFromScanner( ps, ps->RegFifoOffset );
2976 if ((bData > ps->bMinReadFifo) && (bData != ps->bFifoCount))
2979 bData = IOGetScanState( ps, _FALSE );
2987 if (IOGetScanState( ps, _FALSE) != bData )
2992 ps->Scan.bModuleState = _MotorInStopState;
2993 ps->SetMotorSpeed( ps, ps->bCurrentSpeed, _FALSE );
2995 IOSetToMotorRegister( ps );
3002 _LOC void MotorP96ConstantMoveProc( pScanData ps, ULong dwLines )
3017 MotorSetConstantMove( ps, 1 ); /* step every time */
3019 ps->OpenScanPath( ps );
3021 ps->AsicReg.RD_ModeControl = _ModeScan;
3022 IODataToRegister( ps, ps->RegModeControl, _ModeScan );
3024 if( ps->Scan.fMotorBackward ) {
3025 ps->Asic96Reg.RD_MotorControl = (ps->MotorFreeRun | ps->MotorOn |
3026 ps->FullStep | ps->bExtraMotorCtrl);
3028 ps->Asic96Reg.RD_MotorControl = (ps->MotorFreeRun | ps->MotorOn |
3029 _MotorDirForward | ps->bExtraMotorCtrl);
3032 IODataToRegister( ps, ps->RegMotorControl, ps->Asic96Reg.RD_MotorControl );
3033 ps->CloseScanPath( ps );
3041 motorP96GetScanStateAndStatus( ps, &StateStatus );
3043 if( ps->Scan.fMotorBackward && (StateStatus.bStatus&_FLAG_P96_PAPER)) {
3071 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
3072 IOSetToMotorRegister( ps );
3079 _LOC Bool MotorP96AheadToDarkArea( pScanData ps )
3086 ps->fColorMoreRedFlag = _FALSE;
3087 ps->fColorMoreBlueFlag = _FALSE;
3088 ps->wOverBlue = 0;
3091 memset( ps->a_nbNewAdrPointer, 0x30, _SCANSTATE_BYTES);
3092 MotorSetConstantMove( ps, 2 );
3095 ps->AsicReg.RD_ModeControl = _ModeScan;
3096 ps->AsicReg.RD_ScanControl = ps->bLampOn | _SCAN_BYTEMODE;
3097 ps->Asic96Reg.RD_MotorControl = _MotorDirForward | ps->FullStep;
3098 ps->AsicReg.RD_ModelControl = ps->Device.ModelCtrl | _ModelWhiteIs0;
3100 ps->AsicReg.RD_Dpi = 300;
3102 /* if( MODEL_OP_A3I == ps->sCaps.Model ) { */
3103 if( ps->PhysicalDpi > 300 ) {
3105 ps->AsicReg.RD_Origin = (UShort)(ps->Offset70 + 64 + 8 + 2048);
3107 ps->AsicReg.RD_Origin = (UShort)(ps->Offset70 + 64 + 8 + 1024);
3109 ps->AsicReg.RD_Pixels = 512;
3111 IOPutOnAllRegisters( ps );
3113 ps->Asic96Reg.RD_MotorControl = (ps->MotorFreeRun | ps->IgnorePF |
3114 ps->MotorOn | _MotorDirForward );
3116 IOCmdRegisterToScanner( ps, ps->RegMotorControl,
3117 ps->Asic96Reg.RD_MotorControl );
3125 bDark = motorP96ReadDarkData( ps );
3130 IOCmdRegisterToScanner( ps, ps->RegMotorControl, 0 );
3137 bDark = motorP96ReadDarkData( ps );
3140 if (((ps->sCaps.AsicID == _ASIC_IS_96001) && (bDark > 0x80)) ||
3141 ((ps->sCaps.AsicID != _ASIC_IS_96001) && (bDark < 0x80)) ||
3144 IOCmdRegisterToScanner( ps, ps->RegModeControl, _ModeProgram );
3147 ps->fColorMoreRedFlag = _TRUE;
3150 ps->wOverBlue = wTotalLastLine - 80;
3151 ps->fColorMoreBlueFlag = _TRUE;
3165 _LOC void MotorP96AdjustCurrentSpeed( pScanData ps, Byte bSpeed )
3170 ps->bCurrentSpeed = 34;
3172 ps->bCurrentSpeed = (bSpeed + 1) & 0xfe;
3179 _LOC void MotorP98003ForceToLeaveHomePos( pScanData ps )
3183 IODataToRegister( ps, ps->RegStepControl, _MOTOR0_ONESTEP );
3184 IODataToRegister( ps, ps->RegMotor0Control, _FORWARD_MOTOR );
3189 if( !(IODataFromRegister( ps, ps->RegStatus ) & _FLAG_P98_PAPER))
3192 IORegisterToScanner( ps, ps->RegForceStep );
3197 IODataToRegister( ps, ps->RegStepControl, _MOTOR0_SCANSTATE );
3203 _LOC void MotorP98003BackToHomeSensor( pScanData ps )
3209 IODataToRegister( ps, ps->RegStepControl, _MOTOR0_SCANSTATE );
3210 IODataToRegister( ps, ps->RegModeControl, _ModeScan );
3213 memset( ps->a_nbNewAdrPointer, 0x88, _SCANSTATE_BYTES );
3214 IODownloadScanStates( ps );
3218 while(!(IOGetScanState( ps, _TRUE ) & _SCANSTATE_STOP) &&
3224 ps->AsicReg.RD_ModeControl = _ModeScan;
3226 if (!(ps->DataInf.dwScanFlag & SCANDEF_TPA)) {
3227 IODataToRegister( ps, ps->RegLineControl, _LOBYTE(ps->Shade.wExposure));
3228 IODataToRegister( ps, ps->RegXStepTime, _LOBYTE(ps->Shade.wXStep));
3231 IODataToRegister( ps, ps->RegLineControl, _DEFAULT_LINESCANTIME );
3232 IODataToRegister( ps, ps->RegXStepTime, 6);
3235 IODataToRegister( ps, ps->RegStepControl,
3237 IODataToRegister( ps, ps->RegModeControl, ps->AsicReg.RD_ModeControl );
3238 IODataToRegister( ps, ps->RegMotor0Control,
3241 IORegisterToScanner( ps, ps->RegRefreshScanState );
3246 if( IODataFromRegister( ps, ps->RegStatus ) & _FLAG_P98_PAPER )
3253 IODataToRegister( ps, ps->RegLineControl, ps->AsicReg.RD_LineControl);
3254 IODataToRegister( ps, ps->RegXStepTime, ps->AsicReg.RD_XStepTime);
3257 ps->AsicReg.RD_LineControl, ps->AsicReg.RD_XStepTime );
3259 motorP98003DownloadNullScanStates( ps );
3265 _LOC void MotorP98003ModuleForwardBackward( pScanData ps )
3267 switch( ps->Scan.bModuleState ) {
3270 ps->Scan.bModuleState = _MotorGoBackward;
3271 IODataToRegister( ps, ps->RegScanControl1,
3272 (UChar)(ps->AsicReg.RD_ScanControl1 & ~_MFRC_RUNSCANSTATE));
3273 IODataToRegister( ps, ps->RegMotor0Control,
3274 (UChar)(ps->AsicReg.RD_Motor0Control & ~_MotorDirForward));
3275 motorP98003ModuleFreeRun( ps, _P98003_BACKSTEPS );
3281 if (!(IOGetExtendedStatus( ps ) & _STILL_FREE_RUNNING )) {
3282 ps->Scan.bModuleState = _MotorInStopState;
3291 if( IOReadFifoLength( ps ) < ps->Scan.dwMaxReadFifo ) {
3292 ps->Scan.bModuleState = _MotorAdvancing;
3293 IODataToRegister( ps, ps->RegScanControl1, ps->AsicReg.RD_ScanControl1);
3294 IODataToRegister( ps, ps->RegMotor0Control, ps->AsicReg.RD_Motor0Control);
3295 motorP98003ModuleFreeRun( ps, _P98003_FORWARDSTEPS );
3303 if( !(IOGetScanState( ps, _TRUE ) & _SCANSTATE_STOP))
3304 ps->Scan.bModuleState = _MotorInNormalState;
3306 if (!(IOGetExtendedStatus( ps ) & _STILL_FREE_RUNNING )) {
3307 IORegisterToScanner( ps, ps->RegRefreshScanState );
3308 ps->Scan.bModuleState = _MotorInNormalState;
3319 _LOC void MotorP98003PositionYProc( pScanData ps, ULong steps)
3327 while(!(IOGetScanState( ps, _TRUE ) & _SCANSTATE_STOP) &&
3333 motorP98003ModuleFreeRun( ps, steps );
3340 if (!(IOGetExtendedStatus( ps ) & _STILL_FREE_RUNNING) ||
3341 !(IOGetScanState( ps, _TRUE ) & _SCANSTATE_STOP))