Lines Matching refs:ps
83 static void dacP98AdjustGainAverage( pScanData ps )
89 pDest = pSrce = ps->pScanBuffer1;
101 static void dacP98FillDarkDAC( pScanData ps )
103 IODataRegisterToDAC( ps, 0x20, ps->bRedDAC );
104 IODataRegisterToDAC( ps, 0x21, ps->bGreenDAC );
105 IODataRegisterToDAC( ps, 0x22, ps->bBlueDAC );
110 static void dacP98SetReadFBKRegister( pScanData ps )
112 IODataToRegister( ps, ps->RegModeControl, _ModeIdle );
114 ps->AsicReg.RD_ScanControl = _SCAN_12BITMODE + _SCAN_1ST_AVERAGE;
116 IOSelectLampSource( ps );
117 IODataToRegister( ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl );
119 ps->AsicReg.RD_Motor0Control = _MotorOn;
120 ps->AsicReg.RD_StepControl = _MOTOR0_SCANSTATE;
121 ps->AsicReg.RD_Origin = 4;
122 ps->AsicReg.RD_Pixels = 512;
123 ps->AsicReg.RD_Motor1Control = 0;
124 ps->AsicReg.RD_Motor0Control = 0;
126 ps->AsicReg.RD_ModelControl = _LED_CONTROL + _LED_ACTIVITY;
128 if( ps->bSetScanModeFlag & _ScanMode_AverageOut ) {
129 ps->AsicReg.RD_Dpi = 300;
130 ps->AsicReg.RD_ModelControl += _ModelDpi300;
133 ps->AsicReg.RD_Dpi = 600;
134 ps->AsicReg.RD_ModelControl += _ModelDpi600;
140 static UShort dacP98CalDarkOff( pScanData ps, UShort wChDarkOff,
145 if ((_CCD_518 == ps->Device.bCCDID) || (_CCD_535 == ps->Device.bCCDID)) {
149 if (_CCD_3797 == ps->Device.bCCDID) {
202 static Bool dacP98CheckChannelDarkLevel( pScanData ps )
206 dacP98AdjustDAC( ps->Shade.DarkOffset.Colors.Red,
207 ps->Shade.pCcdDac->DarkCmpHi.Colors.Red,
208 ps->Shade.pCcdDac->DarkCmpLo.Colors.Red,
209 &ps->bRedDAC, &fDACStopFlag );
210 dacP98AdjustDAC( ps->Shade.DarkOffset.Colors.Green,
211 ps->Shade.pCcdDac->DarkCmpHi.Colors.Green,
212 ps->Shade.pCcdDac->DarkCmpLo.Colors.Green,
213 &ps->bGreenDAC, &fDACStopFlag );
214 dacP98AdjustDAC( ps->Shade.DarkOffset.Colors.Blue,
215 ps->Shade.pCcdDac->DarkCmpHi.Colors.Blue,
216 ps->Shade.pCcdDac->DarkCmpLo.Colors.Blue,
217 &ps->bBlueDAC, &fDACStopFlag );
224 static void dacP98FillChannelDarkLevelControl( pScanData ps )
229 if( ps->bSetScanModeFlag & _ScanMode_AverageOut ) {
235 for (p.pw = (pUShort)(ps->pScanBuffer1 + dwPos), dwSum = 0, dw = 16;
240 ps->Shade.DarkOffset.Colors.Red = (UShort)(dwSum / 16);
242 for (p.pw = (pUShort)(ps->pScanBuffer1 + dwPos + 1024), dwSum = 0, dw = 16;
247 ps->Shade.DarkOffset.Colors.Green = (UShort)(dwSum / 16);
249 for (p.pw = (pUShort)(ps->pScanBuffer1 + dwPos + 1024 * 2), dwSum = 0, dw = 16;
254 ps->Shade.DarkOffset.Colors.Blue = (UShort)(dwSum / 16);
259 static void dacP98AdjustGain( pScanData ps )
267 dacP98AdjustGainAverage( ps );
269 pbReg[0] = &ps->bRedGainIndex;
270 pbReg[1] = &ps->bGreenGainIndex;
271 pbReg[2] = &ps->bBlueGainIndex;
273 for (w = 0, p.pb = ps->pScanBuffer1; w < 3; w++) {
293 static void dacP98CheckLastGain( pScanData ps )
301 dacP98AdjustGainAverage( ps );
303 pbReg[0] = &ps->bRedGainIndex;
304 pbReg[1] = &ps->bGreenGainIndex;
305 pbReg[2] = &ps->bBlueGainIndex;
307 for (w = 0, p.pb = ps->pScanBuffer1; w < 3; w++) {
321 static void dacP98FillGainInitialRestRegister( pScanData ps )
323 ps->OpenScanPath( ps );
325 IODataToRegister( ps, ps->RegThresholdGapControl, ps->AsicReg.RD_ThresholdGapCtrl );
326 IODataToRegister( ps, ps->RegModelControl, ps->AsicReg.RD_ModelControl );
328 ps->CloseScanPath( ps );
333 static void dacP98SetInitialGainRegister( pScanData ps )
335 DacP98FillGainOutDirectPort( ps ); /* R/G/B GainOut to scanner */
336 dacP98FillGainInitialRestRegister( ps );/* Model Control2, LED, Correct.*/
341 static void dacP98SetRGBGainRegister( pScanData ps )
343 IOCmdRegisterToScanner( ps, ps->RegModeControl, _ModeIdle );
345 ps->AsicReg.RD_ScanControl = _SCAN_BYTEMODE;
346 IOSelectLampSource( ps );
348 IOCmdRegisterToScanner( ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl);
349 dacP98SetInitialGainRegister( ps );
351 ps->AsicReg.RD_ModeControl = _ModeScan;
352 ps->AsicReg.RD_StepControl = _MOTOR0_SCANSTATE;
353 ps->AsicReg.RD_Motor0Control = _MotorOn + _MotorDirForward + _MotorHEightStep;
354 ps->AsicReg.RD_XStepTime = ps->bSpeed4;
356 if( ps->bSetScanModeFlag & _ScanMode_AverageOut ) {
357 ps->AsicReg.RD_ModelControl = _LED_CONTROL + _ModelDpi300;
358 ps->AsicReg.RD_Origin = 32 + 60 + 4;
360 ps->AsicReg.RD_ModelControl = _LED_CONTROL + _ModelDpi600;
361 ps->AsicReg.RD_Origin = 64 + 120 + 4;
363 ps->AsicReg.RD_Dpi = 300;
364 ps->AsicReg.RD_Pixels = 2560;
366 IOPutOnAllRegisters( ps );
386 static void dacP98DownloadMapTable( pScanData ps, pUChar pBuffer )
391 IODataToRegister( ps, ps->RegScanControl,
392 (Byte)((ps->AsicReg.RD_ScanControl & 0xfc) | _SCAN_BYTEMODE));
396 IODataToRegister( ps, ps->RegModeControl, _ModeMappingMem );
397 IODataToRegister( ps, ps->RegMemoryLow, 0);
398 IODataToRegister( ps, ps->RegMemoryHigh, bAddr );
400 IOMoveDataToScanner( ps, pBuffer, 4096 );
404 IODataToRegister( ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl );
409 static void dacP98DownloadShadingTable( pScanData ps,
412 IODataToRegister( ps, ps->RegModeControl, _ModeShadingMem );
413 IODataToRegister( ps, ps->RegMemoryLow, 0 );
414 IODataToRegister( ps, ps->RegMemoryHigh, 0 );
417 IODataToRegister( ps, ps->RegScanControl,
418 (Byte)(ps->AsicReg.RD_ScanControl | _SCAN_12BITMODE));
421 IOMoveDataToScanner( ps ,pBuffer, size );
423 if( _ASIC_IS_98003 == ps->sCaps.AsicID )
424 IODataToRegister( ps, ps->RegModeControl, _ModeScan );
426 IODataToRegister( ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl );
428 DacP98FillShadingDarkToShadingRegister( ps );
439 static void dacP98SetInitialGainRAM( pScanData ps )
441 memset( ps->pScanBuffer2, 0xff, (5400 * 2 * 3));
443 dacP98DownloadShadingTable( ps, ps->pScanBuffer2, (5400 * 2 * 3));
445 dacP98FillRGBMap( ps->pScanBuffer1 ); /* Fill 12 Bits R Map */
446 dacP98FillRGBMap( ps->pScanBuffer1 + 4096 ); /* Fill 12 Bits G Map */
447 dacP98FillRGBMap( ps->pScanBuffer1 + 8192 ); /* Fill 12 Bits B Map */
449 dacP98DownloadMapTable( ps, ps->pScanBuffer1 );
454 static void dacP98AdjustRGBGain( pScanData ps )
460 ps->OpenScanPath( ps );
461 dacP98SetInitialGainRAM( ps ); /* set shading ram and read out data to */
462 ps->CloseScanPath( ps );
464 ps->bRedGainIndex = 0x02;
465 ps->bGreenGainIndex = 0x02;
466 ps->bBlueGainIndex = 0x02;
470 dacP98SetRGBGainRegister( ps ); /* shading the most brightness &*/
471 ps->PauseColorMotorRunStates( ps ); /* stop scan states */
472 IOReadOneShadingLine( ps, ps->pScanBuffer1, 2560UL );
473 dacP98AdjustGain( ps );
476 dacP98SetRGBGainRegister( ps ); /* shading the most brightness & */
477 ps->PauseColorMotorRunStates( ps ); /* stop scan states */
479 IOReadOneShadingLine( ps, ps->pScanBuffer1, 2560UL );
481 dacP98CheckLastGain( ps );
482 DacP98FillGainOutDirectPort( ps );
487 static void dacP98SetAdjustShadingRegister( pScanData ps )
491 IOCmdRegisterToScanner( ps, ps->RegModeControl, _ModeIdle );
493 ps->AsicReg.RD_ScanControl = _SCAN_12BITMODE + _SCAN_1ST_AVERAGE;
494 IOSelectLampSource( ps );
496 IOCmdRegisterToScanner( ps, ps->RegScanControl,
497 ps->AsicReg.RD_ScanControl );
499 ps->AsicReg.RD_ModeControl = _ModeScan;
500 ps->AsicReg.RD_Motor0Control = _MotorOn + _MotorHEightStep + _MotorDirForward;
501 ps->AsicReg.RD_XStepTime = ps->bSpeed1;
502 ps->AsicReg.RD_ModelControl = _LED_ACTIVITY + _LED_CONTROL;
504 if (ps->bSetScanModeFlag & _ScanMode_AverageOut) {
505 ps->AsicReg.RD_Dpi = 300;
506 ps->AsicReg.RD_Pixels = 2700;
507 ps->AsicReg.RD_ModelControl += _ModelDpi300;
509 ps->AsicReg.RD_Dpi = 600;
510 ps->AsicReg.RD_Pixels = 5400;
511 ps->AsicReg.RD_ModelControl += _ModelDpi600;
513 ps->AsicReg.RD_Origin = 4;
515 IOPutOnAllRegisters( ps );
520 static void dacP98ReadShadingScanLine( pScanData ps )
526 ps->Scan.bFifoSelect = ps->RegGFifoOffset;
528 while((IOReadFifoLength( ps ) < dwReadyLen) &&
533 IOReadColorData( ps, ps->pScanBuffer2, ps->dwShadingLen );
559 static void dacP98SortHilightShadow( pScanData ps, pUShort pwData,
566 for (dwPixels = 0; dwPixels < (ps->dwShadingPixels - 4); dwPixels++) {
568 pw = (pUShort)ps->Shade.pHilight + dwHilightOff + dwPixels;
579 for (dwPixels = 0; dwPixels < (ps->dwShadingPixels - 4); dwPixels++) {
581 pw = ps->pwShadow + dwShadowOff + dwPixels;
597 static void dacP98WriteBackToShadingRAM( pScanData ps )
601 pUShort pBuffer = (pUShort)ps->pScanBuffer2;
605 if (ps->DataInf.wPhyDataType >= COLOR_TRUE24) {
609 *pBuffer = ((pUShort)ps->pScanBuffer1)[dw] -
610 ps->Shade.DarkOffset.Colors.Red;
612 ps->Shade.pCcdDac->GainResize.Colors.Red );
615 *pBuffer = ((pUShort)ps->pScanBuffer1)[dw + 5400] -
616 ps->Shade.DarkOffset.Colors.Green;
618 ps->Shade.pCcdDac->GainResize.Colors.Green );
621 *pBuffer = ((pUShort)ps->pScanBuffer1)[dw + 5400 * 2] -
622 ps->Shade.DarkOffset.Colors.Blue;
624 ps->Shade.pCcdDac->GainResize.Colors.Blue );
634 *pBuffer = ((pUShort)ps->pScanBuffer1)[dw + 5400] -
635 ps->Shade.DarkOffset.Colors.Green;
646 dacP98DownloadShadingTable( ps, ps->pScanBuffer2, (5400 * 2 * 3));
651 static void dacP98ShadingRunLoop( pScanData ps )
656 p.pb = ps->a_nbNewAdrPointer;
658 switch( ps->IO.portMode ) {
674 IOSetToMotorRegister( ps );
679 static void dacP98Adjust12BitShading( pScanData ps )
686 memset( ps->pScanBuffer1, 0, (5400 * 4 * 3));
688 if( ps->Shade.pHilight && (_Shading_32Times == ps->bShadingTimeFlag)) {
690 memset( ps->Shade.pHilight, 0, (ps->dwHilight * 2UL));
692 for (dw = 0; dw < ps->dwShadow; dw++)
693 ps->pwShadow[dw] = 0xfff;
700 dacP98SetAdjustShadingRegister( ps );
702 dacP98ShadingRunLoop( ps );
705 if ((ps->DataInf.dwScanFlag & SCANDEF_TPA ) ||
706 (_Shading_32Times == ps->bShadingTimeFlag)) {
709 if (_Shading_16Times == ps->bShadingTimeFlag) {
718 ps->Scan.bFifoSelect = ps->RegGFifoOffset;
720 dacP98ReadShadingScanLine( ps );
722 if((_Shading_32Times == ps->bShadingTimeFlag) && ps->Shade.pHilight ) {
724 dacP98SortHilightShadow( ps, (pUShort)ps->pScanBuffer2, 0, 0 );
725 dacP98SortHilightShadow( ps, (pUShort)ps->pScanBuffer2 +
726 ps->dwShadingPixels,
727 ps->dwHilightCh, ps->dwShadowCh );
729 dacP98SortHilightShadow( ps, (pUShort)ps->pScanBuffer2 +
730 ps->dwShadingPixels * 2,
731 ps->dwHilightCh * 2, ps->dwShadowCh * 2);
735 pd.pw = (pUShort)ps->pScanBuffer2;
736 pt.pdw = (pULong)(ps->pScanBuffer1 + dwADCPipeLine);
742 if( ps->bSetScanModeFlag & _ScanMode_AverageOut )
743 pd.pw = (pUShort)(ps->pScanBuffer2 + 2700 * 2);
745 pd.pw = (pUShort)(ps->pScanBuffer2 + 5400 * 2);
747 pt.pdw = (pULong)(ps->pScanBuffer1 + 5400 * 4 + dwADCPipeLine);
753 if( ps->bSetScanModeFlag & _ScanMode_AverageOut )
754 pd.pw = (pUShort)(ps->pScanBuffer2 + 2700 * 4);
756 pd.pw = (pUShort)(ps->pScanBuffer2 + 5400 * 4);
758 pt.pdw = (pULong)(ps->pScanBuffer1 + 5400 * 8 + dwADCPipeLine);
764 if (IOReadFifoLength( ps ) <= 2500)
765 IORegisterDirectToScanner( ps, ps->RegRefreshScanState );
768 TPAP98001AverageShadingData( ps );
770 ps->OpenScanPath( ps );
771 dacP98WriteBackToShadingRAM( ps );
772 ps->CloseScanPath( ps );
777 static Bool dacP98WaitForShading( pScanData ps )
786 ps->InitialSetCurrentSpeed( ps );
787 ps->ReInitAsic( ps, _TRUE );
789 IOCmdRegisterToScanner( ps, ps->RegLineControl,
790 ps->AsicReg.RD_LineControl );
792 ps->Shade.DarkOffset.Colors.Red = 0;
793 ps->Shade.DarkOffset.Colors.Green = 0;
794 ps->Shade.DarkOffset.Colors.Blue = 0;
799 IOSelectLampSource( ps );
800 IOCmdRegisterToScanner(ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl);
802 if( ps->bSetScanModeFlag & _ScanMode_AverageOut ) {
803 ps->AsicReg.RD_ModelControl = _LED_CONTROL + _ModelDpi300;
805 ps->AsicReg.RD_ModelControl = _LED_CONTROL + _ModelDpi600;
807 IOCmdRegisterToScanner( ps, ps->RegModelControl,
808 ps->AsicReg.RD_ModelControl );
810 IOCmdRegisterToScanner( ps, ps->RegModeControl, _ModeScan);
812 oldLineControl = ps->AsicReg.RD_LineControl;
813 IOSetXStepLineScanTime( ps, _DEFAULT_LINESCANTIME );
816 IOCmdRegisterToScanner( ps, ps->RegLineControl,
817 ps->AsicReg.RD_LineControl );
820 if( !ps->GotoShadingPosition( ps ))
823 ps->AsicReg.RD_LineControl = oldLineControl;
824 IOCmdRegisterToScanner( ps, ps->RegLineControl,
825 ps->AsicReg.RD_LineControl );
829 if( ps->bSetScanModeFlag & _ScanMode_AverageOut ) {
831 ps->dwShadingLen = 2700 * 2;
832 ps->dwShadingPixels = 2700;
835 ps->dwShadingLen = 5400 * 2;
836 ps->dwShadingPixels = 5400;
839 dacP98AdjustRGBGain ( ps );
840 DacP98AdjustDark ( ps );
841 dacP98Adjust12BitShading( ps );
843 ps->OpenScanPath( ps );
844 DacP98FillShadingDarkToShadingRegister( ps );
846 if ( COLOR_BW != ps->DataInf.wPhyDataType )
847 dacP98DownloadMapTable( ps, ps->a_bMapTable );
849 ps->CloseScanPath( ps );
856 static void dacP96FillWhole4kRAM( pScanData ps, pUChar pBuf )
858 ps->OpenScanPath( ps );
860 IODataToRegister( ps, ps->RegMemAccessControl,
861 ps->Asic96Reg.RD_MemAccessControl );
863 ps->AsicReg.RD_ModeControl = _ModeProgram;
864 IODataToRegister( ps, ps->RegModeControl, ps->AsicReg.RD_ModeControl );
866 IOMoveDataToScanner( ps, pBuf, ps->ShadingBankSize );
868 ps->AsicReg.RD_ModeControl = _ModeScan;
869 IODataToRegister( ps, ps->RegModeControl, ps->AsicReg.RD_ModeControl );
871 ps->CloseScanPath( ps );
876 static void dacP96FillChannelDarkOffset( pScanData ps )
878 ps->OpenScanPath( ps );
880 IODataToRegister( ps, ps->RegRedChDarkOffset,
881 ps->Asic96Reg.RD_RedChDarkOff );
882 IODataToRegister( ps, ps->RegGreenChDarkOffset,
883 ps->Asic96Reg.RD_GreenChDarkOff );
884 IODataToRegister( ps, ps->RegBlueChDarkOffset,
885 ps->Asic96Reg.RD_BlueChDarkOff );
887 ps->CloseScanPath( ps );
892 static void dacP96FillEvenOddControl( pScanData ps )
894 ps->OpenScanPath( ps );
896 IODataToRegister( ps, ps->RegRedChEvenOffset,
897 ps->Asic96Reg.RD_RedChEvenOff );
898 IODataToRegister( ps, ps->RegGreenChEvenOffset,
899 ps->Asic96Reg.RD_GreenChEvenOff );
900 IODataToRegister( ps, ps->RegBlueChEvenOffset,
901 ps->Asic96Reg.RD_BlueChEvenOff );
902 IODataToRegister( ps, ps->RegRedChOddOffset,
903 ps->Asic96Reg.RD_RedChOddOff );
904 IODataToRegister( ps, ps->RegGreenChOddOffset,
905 ps->Asic96Reg.RD_GreenChOddOff );
906 IODataToRegister( ps, ps->RegBlueChOddOffset,
907 ps->Asic96Reg.RD_BlueChOddOff );
909 ps->CloseScanPath( ps );
918 static void dacP96ReadDataWithinOneSecond( pScanData ps,
925 while((IODataRegisterFromScanner( ps, ps->RegFifoOffset) < bBlks) &&
928 IOReadScannerImageData( ps, ps->pPrescan16, dwLen );
949 static void dacP96SumAverageShading( pScanData ps, pUChar pDest, pUChar pSrce )
955 pSrce += ps->Offset70 + ps->Device.DataOriginX;
956 pDest += ps->Offset70 + ps->Device.DataOriginX;
966 for (dw = ps->BufferSizePerModel - 6; dw; dw--, pSrce++, pDest++) {
983 static void dacP96WriteLinearGamma( pScanData ps,
987 pULong pdw = (pULong)(pBuf + ps->ShadingBufferSize);
992 ps->Asic96Reg.RD_MemAccessControl = bBank;
994 dacP96FillWhole4kRAM( ps, pBuf );
999 static void dacP96FillChannelShadingOffset( pScanData ps )
1001 ps->OpenScanPath( ps );
1003 IODataToRegister( ps, ps->RegRedChShadingOffset,
1004 ps->Asic96Reg.u28.RD_RedChShadingOff);
1005 IODataToRegister( ps, ps->RegGreenChShadingOffset,
1006 ps->Asic96Reg.u29.RD_GreenChShadingOff);
1007 IODataToRegister( ps, ps->RegBlueChShadingOffset,
1008 ps->Asic96Reg.RD_BlueChShadingOff);
1010 ps->CloseScanPath( ps );
1015 static void dacP96GetHilightShadow( pScanData ps,
1020 /* GetShadingImageExtent (ps) */
1021 if (ps->DataInf.wAppDataType < COLOR_256GRAY)
1022 dw = (ULong)(ps->DataInf.crImage.cx & 0xfff8);
1024 dw = (ULong)ps->DataInf.crImage.cx;
1026 for( pBuf += ps->DataInf.crImage.x, *pChOff = 0xff, *pHigh = 0;
1039 static void dacP96ReadColorShadingLine( pScanData ps )
1046 /* ClearScanBuffer1 (ps) */
1048 memset( ps->pScanBuffer1, 0, ps->BufferForDataRead1 );
1050 b2ndDiscard = ps->b2ndLinesOffset;
1051 b3rdDiscard = ps->b1stLinesOffset;
1056 /* ReadShadingScanLine(ps) */
1057 dacP96ReadDataWithinOneSecond( ps, ps->ShadingScanLineLen,
1058 ps->ShadingScanLineBlks );
1065 for (dw = 0; dw < ps->BufferSizeBase; dw++)
1066 ((pUShort)ps->pScanBuffer1)[dw] += (UShort)ps->pPrescan16 [dw];
1073 for (dw = ps->BufferSizeBase;dw < (ULong)ps->BufferSizeBase * 2;dw++) {
1074 ((pUShort)ps->pScanBuffer1)[dw] +=
1075 (UShort)ps->pPrescan16[dw];
1085 for (dw = ps->BufferSizeBase * 2;
1086 dw < (ULong)ps->BufferSizeBase * 3; dw++) {
1087 ((pUShort)ps->pScanBuffer1)[dw] +=
1088 (UShort)ps->pPrescan16[dw];
1095 IORegisterDirectToScanner( ps, ps->RegRefreshScanState );
1098 for (dw = 0; dw < (ULong)ps->BufferSizeBase * 3; dw++) {
1101 Data.wOverlap.b2nd = (Byte)(((pUShort)ps->pScanBuffer1)[dw] / 8);
1102 ((pUShort)ps->pPrescan16)[dw] = Data.wValue;
1108 static void dacP96SetShadingGainProc( pScanData ps, Byte bHigh, ULong dwCh )
1120 pbChDark = &ps->Asic96Reg.u28.RD_RedChShadingOff;
1121 pbSrce = ps->pPrescan16;
1122 pbDest = ps->pScanBuffer1 + ps->Offset70 + ps->Device.DataOriginX;
1129 pbChDark = &ps->Asic96Reg.u29.RD_GreenChShadingOff;
1130 pbSrce = ps->pPrescan16 + ps->BufferSizePerModel;
1131 pbDest = ps->pScanBuffer1 + ps->Offset70 + ps->ShadingBankSize +
1132 ps->Device.DataOriginX;
1139 pbChDark = &ps->Asic96Reg.RD_BlueChShadingOff;
1140 pbSrce = ps->pPrescan16 + ps->BufferSizePerModel * 2;
1141 pbDest = ps->pScanBuffer1 + ps->Offset70 + ps->ShadingBankSize * 2 +
1142 ps->Device.DataOriginX;
1157 ps->Asic96Reg.RD_ShadingCorrectCtrl &= bMask;
1158 ps->Asic96Reg.RD_ShadingCorrectCtrl |= bGain;
1161 /* GammaGain1 (ps) */
1162 for (dw = ps->BufferSizePerModel; dw; dw--, pbSrce++, pbDest++)
1170 for (dw = ps->BufferSizePerModel; dw; dw--, pbSrce++, pbDest++)
1176 /* GammaGain4 (ps) */
1177 memcpy( pbDest, pbSrce, ps->BufferSizePerModel );
1184 static void dacP96FillShadingAndGammaTable( pScanData ps )
1186 ps->Asic96Reg.RD_MemAccessControl = ps->ShadingBankRed; /* R */
1187 dacP96FillWhole4kRAM( ps, ps->pPrescan16 );
1189 ps->Asic96Reg.RD_MemAccessControl = ps->ShadingBankGreen; /* G */
1190 dacP96FillWhole4kRAM( ps, ps->pPrescan16 );
1192 ps->Asic96Reg.RD_MemAccessControl = ps->ShadingBankBlue; /* B */
1193 dacP96FillWhole4kRAM( ps, ps->pPrescan16 );
1198 static void dacP96SetInitialGainRAM( pScanData ps )
1201 pULong pdw = (pULong)(ps->pPrescan16 + ps->ShadingBufferSize);
1203 memset( ps->pPrescan16, 0xff, ps->ShadingBufferSize );
1208 dacP96FillShadingAndGammaTable( ps );
1213 static void dacP96Adjust10BitShading( pScanData ps )
1219 /* ShadingMotorRunLoop(ps)
1224 pdw = (pULong)ps->a_nbNewAdrPointer;
1230 dacP96SetInitialGainRAM( ps); /* initiates the shading buffers and maps */
1232 /* SetAdjustShadingRegister(ps) */
1234 ps->AsicReg.RD_ScanControl = ps->bLampOn | _SCAN_BYTEMODE;
1235 ps->Asic96Reg.RD_MotorControl = ps->IgnorePF | ps->MotorOn |
1237 ps->AsicReg.RD_ModelControl = ps->Device.ModelCtrl | _ModelWhiteIs0;
1238 ps->AsicReg.RD_Dpi = ps->PhysicalDpi / 2;
1239 ps->AsicReg.RD_Origin = (UShort)(ps->Offset70 +
1240 ps->Device.DataOriginX);
1241 ps->AsicReg.RD_Pixels = ps->BufferSizeBase;
1242 IOPutOnAllRegisters( ps );
1244 ps->Asic96Reg.RD_ShadingCorrectCtrl = _ShadingRCorrectX4|_ShadingGCorrectX4|
1246 IOCmdRegisterToScanner( ps, ps->RegShadingCorrectCtrl,
1247 ps->Asic96Reg.RD_ShadingCorrectCtrl );
1250 dacP96ReadColorShadingLine( ps );
1252 /* ExpandAndAverage (ps) ------------------------------------------------*/
1257 Data.wOverlap.b2nd = (Byte)(((pUShort) ps->pScanBuffer1)[dw] / 8);
1258 ((pULong) ps->pPrescan16)[dw] = Data.wValue;
1261 /* CalculateShadingOffset (ps); */
1262 dacP96GetHilightShadow( ps, ps->pPrescan16,
1263 &ps->Asic96Reg.u28.RD_RedChShadingOff, &bRedHigh );
1265 dacP96GetHilightShadow( ps, ps->pPrescan16 + ps->BufferSizePerModel,
1266 &ps->Asic96Reg.u29.RD_GreenChShadingOff, &bGreenHigh );
1268 dacP96GetHilightShadow( ps, ps->pPrescan16 + ps->BufferSizePerModel * 2,
1269 &ps->Asic96Reg.RD_BlueChShadingOff, &bBlueHigh );
1271 /* SubTheImageDataBase (ps) */
1272 dacP96SetShadingGainProc( ps, bRedHigh, 0 ); /* red */
1273 dacP96SetShadingGainProc( ps, bGreenHigh, 1 ); /* green */
1274 dacP96SetShadingGainProc( ps, bBlueHigh, 2 ); /* blue */
1275 dacP96FillChannelShadingOffset( ps );
1277 IOCmdRegisterToScanner( ps, ps->RegShadingCorrectCtrl,
1278 ps->Asic96Reg.RD_ShadingCorrectCtrl );
1280 dacP96SumAverageShading( ps, ps->pPrescan16, ps->pScanBuffer1 );
1281 dacP96SumAverageShading( ps, ps->pPrescan16 + ps->ShadingBankSize,
1282 ps->pScanBuffer1 + ps->ShadingBankSize );
1283 dacP96SumAverageShading( ps, ps->pPrescan16 + ps->ShadingBankSize * 2,
1284 ps->pScanBuffer1 + ps->ShadingBankSize * 2 );
1288 /* PrewriteBackToGammaShadingRAM( ps) */
1289 dacP96WriteLinearGamma( ps, ps->pPrescan16, 256, ps->ShadingBankRed );
1290 dacP96WriteLinearGamma( ps, ps->pPrescan16 + ps->ShadingBankSize, 256,
1291 ps->ShadingBankGreen );
1292 dacP96WriteLinearGamma( ps, ps->pPrescan16 + ps->ShadingBankSize * 2,
1293 256, ps->ShadingBankBlue );
1298 static Bool dacP96003WaitForShading( pScanData ps )
1311 ps->AsicReg.RD_ScanControl |= ps->bLampOn;
1312 IOCmdRegisterToScanner(ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl);
1314 ps->Asic96Reg.RD_LedControl = _LedActControl | _LedMotorActEnable;
1315 IOCmdRegisterToScanner(ps, ps->RegLedControl, ps->Asic96Reg.RD_LedControl);
1317 if ( ps->GotoShadingPosition( ps )) {
1320 ps->Asic96Reg.RD_RedGainOut = ps->Asic96Reg.RD_GreenGainOut =
1321 ps->Asic96Reg.RD_BlueGainOut = 8;
1322 ps->Asic96Reg.u26.RD_ModelControl2 = _Model2DirectOutPort;
1324 IOCmdRegisterToScanner(ps, ps->RegModelControl2, _Model2DirectOutPort);
1328 ps->PauseColorMotorRunStates( ps );
1331 ps->AsicReg.RD_ScanControl = ps->bLampOn | _SCAN_BYTEMODE;
1332 dacP96SetInitialGainRAM( ps );
1335 ps->Asic96Reg.u28.RD_RedChShadingOff =
1336 ps->Asic96Reg.u29.RD_GreenChShadingOff =
1337 ps->Asic96Reg.RD_BlueChShadingOff =
1338 ps->Asic96Reg.RD_RedChDarkOff =
1339 ps->Asic96Reg.RD_GreenChDarkOff =
1340 ps->Asic96Reg.RD_BlueChDarkOff =
1341 ps->Asic96Reg.RD_RedChEvenOff =
1342 ps->Asic96Reg.RD_GreenChEvenOff =
1343 ps->Asic96Reg.RD_BlueChEvenOff =
1344 ps->Asic96Reg.RD_RedChOddOff =
1345 ps->Asic96Reg.RD_GreenChOddOff =
1346 ps->Asic96Reg.RD_BlueChOddOff = 0;
1347 ps->Asic96Reg.RD_ShadingCorrectCtrl = _ShadingRCorrectX4 |
1351 dacP96FillChannelShadingOffset( ps );
1352 dacP96FillChannelDarkOffset( ps );
1353 dacP96FillEvenOddControl( ps );
1356 ps->OpenScanPath( ps );
1357 IODataToRegister( ps, ps->RegRedGainOutDirect,
1358 ps->Asic96Reg.RD_RedGainOut );
1359 IODataToRegister( ps, ps->RegGreenGainOutDirect,
1360 ps->Asic96Reg.RD_GreenGainOut );
1361 IODataToRegister( ps, ps->RegBlueGainOutDirect,
1362 ps->Asic96Reg.RD_BlueGainOut );
1365 IODataToRegister( ps, ps->RegModelControl2,
1366 ps->Asic96Reg.u26.RD_ModelControl2 );
1367 IODataToRegister( ps, ps->RegThresholdGapControl,
1368 ps->AsicReg.RD_ThresholdGapCtrl );
1369 IODataToRegister( ps, ps->RegLedControl,
1370 ps->Asic96Reg.RD_LedControl );
1372 IODataToRegister( ps, ps->RegShadingCorrectCtrl,
1373 ps->Asic96Reg.RD_ShadingCorrectCtrl );
1375 ps->CloseScanPath( ps );
1377 ps->Asic96Reg.RD_MotorControl = 0;
1378 IOCmdRegisterToScanner( ps, ps->RegMotorControl, 0 );
1380 ps->AsicReg.RD_ModeControl = _ModeScan;
1381 ps->AsicReg.RD_ScanControl = ps->bLampOn | _SCAN_BYTEMODE;
1382 ps->Asic96Reg.RD_MotorControl = (ps->IgnorePF |
1383 ps->MotorOn | _MotorDirForward);
1385 ps->AsicReg.RD_Origin = 142;
1386 ps->AsicReg.RD_ModelControl = ps->Device.ModelCtrl | _ModelWhiteIs0;
1387 ps->AsicReg.RD_Dpi = ps->PhysicalDpi;
1388 ps->AsicReg.RD_Pixels = ps->BufferSizePerModel;
1390 IOPutOnAllRegisters( ps );
1395 dacP96ReadDataWithinOneSecond( ps, ps->OneScanLineLen, 11 );
1400 pbReg[0] = &ps->Asic96Reg.RD_RedGainOut;
1401 pbReg[1] = &ps->Asic96Reg.RD_GreenGainOut;
1402 pbReg[2] = &ps->Asic96Reg.RD_BlueGainOut;
1404 for (w = 0, p.pb = ps->pPrescan16; w < 3; w++) {
1406 for (dw = (ps->OneScanLineLen/3), b[w] = 0; dw; dw--, p.pb++) {
1424 memset( ps->pPrescan16, 0xff, ps->ShadingBankSize );
1426 for( dw = 0, p.pb = ps->pPrescan16 + ps->ShadingBufferSize;
1431 dacP96FillShadingAndGammaTable( ps );
1433 ps->PauseColorMotorRunStates( ps );
1436 ps->Asic96Reg.RD_MotorControl = 0;
1437 IOCmdRegisterToScanner( ps, ps->RegMotorControl, 0 );
1439 ps->AsicReg.RD_ModeControl = _ModeScan;
1440 ps->AsicReg.RD_ScanControl = ps->bLampOn | _SCAN_BYTEMODE;
1441 ps->Asic96Reg.RD_MotorControl = ps->IgnorePF | ps->MotorOn |
1444 ps->AsicReg.RD_Origin = 22;
1445 ps->AsicReg.RD_ModelControl = ps->Device.ModelCtrl | _ModelWhiteIs0;
1446 ps->AsicReg.RD_Dpi = ps->PhysicalDpi;
1447 ps->AsicReg.RD_Pixels = ps->FBKScanLineLenBase;
1449 IOPutOnAllRegisters( ps );
1452 dacP96ReadDataWithinOneSecond( ps, ps->FBKScanLineLen,
1453 ps->FBKScanLineBlks );
1456 if ( ps->fSonyCCD ) {
1459 for ( p.pb = ps->pPrescan16 + 32, w = 0, dw = 16;
1464 ps->Asic96Reg.RD_RedChDarkOff = (Byte)(w / 16);
1466 for ( p.pb = ps->pPrescan16 + 32 + ps->FBKScanLineLenBase, w = 0, dw = 16;
1471 ps->Asic96Reg.RD_GreenChDarkOff = (Byte)(w / 16);
1473 for ( p.pb = ps->pPrescan16 + 32 + ps->FBKScanLineLenBase * 2, w = 0, dw = 16;
1478 ps->Asic96Reg.RD_BlueChDarkOff = (Byte)(w / 16);
1480 dacP96FillChannelDarkOffset( ps );
1485 dacP96GetEvenOddOffset( ps->pPrescan16 + 32, &wv );
1486 ps->Asic96Reg.RD_RedChEvenOff = wv.b1st;
1487 ps->Asic96Reg.RD_RedChOddOff = wv.b2nd;
1489 dacP96GetEvenOddOffset( ps->pPrescan16 + 32 + ps->FBKScanLineLenBase, &wv );
1490 ps->Asic96Reg.RD_GreenChEvenOff = wv.b1st;
1491 ps->Asic96Reg.RD_GreenChOddOff = wv.b2nd;
1493 dacP96GetEvenOddOffset( ps->pPrescan16 + 32 + ps->FBKScanLineLenBase * 2, &wv );
1494 ps->Asic96Reg.RD_BlueChEvenOff = wv.b1st;
1495 ps->Asic96Reg.RD_BlueChOddOff = wv.b2nd;
1497 dacP96FillEvenOddControl( ps );
1501 dacP96Adjust10BitShading( ps );
1511 static void dacP96001ToSetShadingAddress( pScanData ps, pUChar pData )
1513 ps->OpenScanPath( ps );
1515 IODataToRegister( ps, ps->RegMemAccessControl,
1516 ps->Asic96Reg.RD_MemAccessControl);
1518 ps->AsicReg.RD_ModeControl = _ModeProgram;
1519 IODataToRegister( ps, ps->RegModeControl, _ModeProgram );
1521 ps->Asic96Reg.RD_MotorControl = ps->FullStep | _MotorDirForward;
1522 IODataToRegister( ps, ps->RegMotorControl, ps->Asic96Reg.RD_MotorControl);
1524 memset( ps->pScanBuffer1, 0, (64 + 8 + ps->Offset70));
1525 memcpy( ps->pScanBuffer1 + 64 + 8 + ps->Offset70, pData,
1528 IOMoveDataToScanner( ps, ps->pScanBuffer1,
1529 _BUF_SIZE_BASE_CONST * 2 + 64 + 8 + ps->Offset70 );
1531 ps->AsicReg.RD_ModeControl = _ModeScan;
1532 IODataToRegister( ps, ps->RegModeControl, _ModeScan );
1534 ps->CloseScanPath( ps );
1539 static void dacP96001WriteBackToColorShadingRam( pScanData ps )
1541 ps->Asic96Reg.RD_MemAccessControl = (_MemBankSize4k96001 | 0x3a);
1542 dacP96001ToSetShadingAddress( ps, ps->pPrescan16 );
1544 ps->Asic96Reg.RD_MemAccessControl = (_MemBankSize4k96001 | 0x3e);
1545 dacP96001ToSetShadingAddress( ps, ps->pPrescan16 + _BUF_SIZE_BASE_CONST*2);
1547 ps->Asic96Reg.RD_MemAccessControl = (_MemBankSize4k96001 | 0x3c);
1548 dacP96001ToSetShadingAddress( ps, ps->pPrescan16 + _BUF_SIZE_BASE_CONST*4);
1571 static Byte dacP96001FBKReading( pScanData ps, Byte bValue,
1590 IOCmdRegisterToScanner( ps, bReg, bFBKTemp );
1593 memset( ps->a_nbNewAdrPointer, bValue, _SCANSTATE_BYTES );
1594 MotorSetConstantMove( ps, 0 );
1597 ps->Asic96Reg.RD_MotorControl = ps->FullStep | _MotorDirForward;
1598 IOCmdRegisterToScanner( ps, ps->RegMotorControl,
1599 ps->Asic96Reg.RD_MotorControl );
1601 ps->AsicReg.RD_ModeControl = _ModeScan;
1602 ps->AsicReg.RD_ScanControl = _SCAN_BYTEMODE | ps->bLampOn;
1603 ps->AsicReg.RD_ModelControl =
1606 ps->AsicReg.RD_Dpi = 300;
1607 ps->AsicReg.RD_Origin = 22;
1608 ps->AsicReg.RD_Pixels = 1024;
1609 IOPutOnAllRegisters( ps );
1611 ps->Asic96Reg.RD_MotorControl =
1612 (ps->FullStep | ps->MotorOn | _MotorDirForward);
1613 IOCmdRegisterToScanner( ps, ps->RegMotorControl,
1614 ps->Asic96Reg.RD_MotorControl );
1617 while((IODataRegisterFromScanner( ps, ps->RegFifoOffset) < 1) &&
1620 IOCmdRegisterToScanner( ps, ps->RegMotorControl, 0 );
1621 IOReadScannerImageData( ps, ps->pScanBuffer1, 64 );
1624 wSum += ps->pScanBuffer1[w];
1642 static Bool dacP96001WaitForShading( pScanData ps )
1653 ps->AsicReg.RD_ScanControl |= ps->bLampOn;
1654 IOCmdRegisterToScanner(ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl);
1656 if ( ps->GotoShadingPosition( ps )) {
1662 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
1663 ps->a_nbNewAdrPointer[8] =
1664 ps->a_nbNewAdrPointer[24] = 0x30;
1666 MotorSetConstantMove( ps, 32 );
1669 ps->AsicReg.RD_ModeControl = _ModeScan;
1670 ps->AsicReg.RD_ScanControl = _SCAN_BYTEMODE | ps->bLampOn;
1672 ps->Asic96Reg.RD_MotorControl =
1673 (ps->MotorOn | ps->IgnorePF | _MotorDirForward);
1674 ps->AsicReg.RD_ModelControl =
1677 ps->AsicReg.RD_Dpi = 300;
1678 ps->AsicReg.RD_Origin = 64 + 8;
1679 ps->AsicReg.RD_Pixels = 2700;
1680 IOPutOnAllRegisters( ps );
1682 IOCmdRegisterToScanner( ps, ps->RegMotorControl,
1683 ps->Asic96Reg.RD_MotorControl );
1686 dacP96ReadDataWithinOneSecond( ps, 2700, 5 );
1694 dwSum += (ULong)ps->pPrescan16[dw];
1700 memcpy( ps->pScanBuffer1, ps->pPrescan16, 140 );
1701 memcpy( ps->pScanBuffer1 + 140,
1702 ps->pPrescan16 + _BUF_SIZE_BASE_CONST * 2, 140);
1706 if( ps->pScanBuffer1[dw] >= 0xe0 )
1714 if( ps->pScanBuffer1[dw] < 0xe0 )
1721 ps->Offset70 = (dwLeft + dwCenter) / 2 + 14;
1724 ps->Offset70 = 70;
1726 ps->Offset70 = dwCenter / 2 + 2;
1731 memset( ps->pPrescan16, 0, ps->BufferSizePerModel * 3 );
1732 dacP96001WriteBackToColorShadingRam( ps );
1735 if((IODataRegisterFromScanner(ps, ps->RegReadIOBufBus) & 0x0f) == 0x0f)
1740 dacP96001FBKReading(ps, 0x10, ps->RegRedDCAdjust, &bRSave,bFBKModify);
1741 dacP96001FBKReading(ps, 0x30, ps->RegGreenDCAdjust,&bGSave,bFBKModify);
1742 dacP96001FBKReading(ps, 0x20, ps->RegBlueDCAdjust, &bBSave,bFBKModify);
1744 ps->OpenScanPath( ps );
1745 IODataToRegister( ps, ps->RegRedDCAdjust, (Byte)(bRSave + 2));
1746 IODataToRegister( ps, ps->RegGreenDCAdjust, (Byte)(bGSave + 2));
1747 IODataToRegister( ps, ps->RegBlueDCAdjust, bBSave);
1748 ps->CloseScanPath( ps );
1751 IOCmdRegisterToScanner( ps, ps->RegMotorControl,
1752 (Byte)(ps->Asic96Reg.RD_MotorControl & ~ps->MotorOn));
1753 IOCmdRegisterToScanner( ps, ps->RegMotorControl,
1754 ps->Asic96Reg.RD_MotorControl );
1757 pdw = (pULong)ps->a_nbNewAdrPointer;
1763 IOSetToMotorRegister( ps );
1766 ps->Asic96Reg.RD_MotorControl = ps->FullStep | _MotorDirForward;
1767 IOCmdRegisterToScanner( ps, ps->RegMotorControl,
1768 ps->Asic96Reg.RD_MotorControl );
1769 ps->AsicReg.RD_ModeControl = _ModeScan;
1770 ps->AsicReg.RD_LineControl = ps->TimePerLine;
1771 ps->AsicReg.RD_ScanControl = _SCAN_BYTEMODE | ps->bLampOn;
1772 ps->Asic96Reg.RD_MotorControl = ps->FullStep | _MotorDirForward;
1774 ps->AsicReg.RD_ModelControl =
1776 ps->AsicReg.RD_Dpi = 150;
1777 ps->AsicReg.RD_Origin = (UShort)(64 + 8 + ps->Offset70);
1778 ps->AsicReg.RD_Pixels = ps->BufferSizeBase;
1779 IOPutOnAllRegisters( ps );
1781 IOCmdRegisterToScanner( ps, ps->RegMotorControl,
1782 (Byte)(ps->MotorOn | ps->IgnorePF | _MotorDirForward));
1784 dacP96ReadColorShadingLine( ps );
1787 dacP96001ModifyShadingColor( ps->pPrescan16, 103 );
1788 dacP96001ModifyShadingColor( ps->pPrescan16 +
1790 dacP96001WriteBackToColorShadingRam( ps );
1798 static void dacP98003GainOffsetToDAC( pScanData ps, Byte ch, Byte reg, Byte d )
1800 if( ps->Device.bDACType == _DA_SAMSUNG8531 ) {
1802 IODataToRegister( ps, ps->RegADCAddress, 0 );
1803 IODataToRegister( ps, ps->RegADCData, ch );
1804 IODataToRegister( ps, ps->RegADCSerialOutStr, ch);
1807 IODataToRegister( ps, ps->RegADCAddress, reg );
1808 IODataToRegister( ps, ps->RegADCData, d );
1809 IODataToRegister( ps, ps->RegADCSerialOutStr, d );
1814 static void dacP98003AdjustRGBGain( pScanData ps )
1821 ps->Shade.Gain.Colors.Red =
1822 ps->Shade.Gain.Colors.Green =
1823 ps->Shade.Gain.Colors.Blue = ps->Shade.bUniGain;
1825 ps->Shade.Hilight.Colors.Red =
1826 ps->Shade.Hilight.Colors.Green =
1827 ps->Shade.Hilight.Colors.Blue = 0;
1829 ps->Shade.bGainHigh = _GAIN_P98003_HIGH;
1830 ps->Shade.bGainLow = _GAIN_P98003_LOW;
1832 ps->Shade.fStop = _FALSE;
1834 for( i = 10; i-- && !ps->Shade.fStop; ) {
1836 ps->Shade.fStop = _TRUE;
1839 IODataToRegister( ps, ps->RegModeControl, _ModeIdle );
1841 ps->AsicReg.RD_ScanControl = _SCAN_BYTEMODE;
1842 IOSelectLampSource( ps );
1843 IODataToRegister( ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl );
1845 DacP98003FillToDAC( ps, &ps->Device.RegDACGain, &ps->Shade.Gain );
1847 ps->AsicReg.RD_ModeControl = _ModeScan;
1848 ps->AsicReg.RD_StepControl = _MOTOR0_SCANSTATE;
1849 ps->AsicReg.RD_Motor0Control = _FORWARD_MOTOR;
1851 if( ps->Shade.bIntermediate & _ScanMode_AverageOut )
1852 ps->AsicReg.RD_Origin = (UShort)ps->Device.DataOriginX >> 1;
1854 ps->AsicReg.RD_Origin = (UShort)ps->Device.DataOriginX;
1856 ps->AsicReg.RD_Dpi = 300;
1857 ps->AsicReg.RD_Pixels = 2560;
1860 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
1861 ps->a_nbNewAdrPointer[1] = 0x77;
1863 IOPutOnAllRegisters( ps );
1868 if( IOReadOneShadingLine( ps, (pUChar)ps->Bufs.b1.pShadingRam, 2560)) {
1870 if ( ps->DataInf.wPhyDataType <= COLOR_256GRAY ) {
1873 (pUChar)ps->Bufs.b1.pShadingRam + 2560, 2560);
1875 DacP98003AdjustGain( ps, _CHANNEL_GREEN, bHi[1] );
1877 ps->Shade.fStop = _FALSE;
1880 bHi[0] = DacP98003SumGains((pUChar)ps->Bufs.b1.pShadingRam, 2560);
1881 bHi[1] = DacP98003SumGains((pUChar)ps->Bufs.b1.pShadingRam + 2560, 2560);
1882 bHi[2] = DacP98003SumGains((pUChar)ps->Bufs.b1.pShadingRam + 5120, 2560);
1885 ps->Shade.fStop = _FALSE;
1887 DacP98003AdjustGain( ps, _CHANNEL_RED, bHi[0] );
1888 DacP98003AdjustGain( ps, _CHANNEL_GREEN, bHi[1] );
1889 DacP98003AdjustGain( ps, _CHANNEL_BLUE, bHi[2] );
1893 ps->Shade.fStop = _FALSE;
1897 if( !ps->Shade.fStop )
1901 DacP98003FillToDAC( ps, &ps->Device.RegDACGain, &ps->Shade.Gain );
1906 static UShort dacP98003SumDarks( pScanData ps, pUShort data )
1910 if( ps->Device.bCCDID == _CCD_3799 ) {
1911 if( ps->Shade.bIntermediate & _ScanMode_AverageOut )
1916 if( ps->Shade.bIntermediate & _ScanMode_AverageOut )
1931 static void dacP98003AdjustShadingWaveform( pScanData ps )
1943 memset( ps->Bufs.b2.pSumBuf, 0, (5400 * 3 * 2));
1946 IODataToRegister( ps, ps->RegModeControl, _ModeIdle );
1948 ps->AsicReg.RD_LineControl = _LOBYTE(ps->Shade.wExposure);
1949 ps->AsicReg.RD_ExtLineControl = _HIBYTE(ps->Shade.wExposure);
1950 IODataToRegister( ps, ps->RegExtendedLineControl,
1951 ps->AsicReg.RD_ExtLineControl );
1952 IODataToRegister( ps, ps->RegLineControl, ps->AsicReg.RD_LineControl );
1954 ps->AsicReg.RD_XStepTime = _LOBYTE(ps->Shade.wExposure);
1955 ps->AsicReg.RD_ExtXStepTime = _HIBYTE(ps->Shade.wExposure);
1956 IODataToRegister( ps, ps->RegExtendedXStep, ps->AsicReg.RD_ExtXStepTime );
1957 IODataToRegister( ps, ps->RegXStepTime, ps->AsicReg.RD_XStepTime );
1959 ps->AsicReg.RD_ModeControl = _ModeScan;
1960 ps->AsicReg.RD_StepControl = _MOTOR0_SCANSTATE;
1961 ps->AsicReg.RD_Motor0Control = _FORWARD_MOTOR;
1963 if( ps->Shade.bIntermediate & _ScanMode_AverageOut ) {
1965 ps->AsicReg.RD_Dpi = 300;
1966 ps->AsicReg.RD_Pixels = 2700;
1967 ps->Shade.shadingBytes = 2700 * 2;
1969 ps->AsicReg.RD_Dpi = 600;
1970 ps->AsicReg.RD_Pixels = 5400;
1971 ps->Shade.shadingBytes = 5400 * 2;
1973 ps->AsicReg.RD_Origin = _SHADING_BEGINX;
1975 for( pvar.pdw = (pULong)ps->a_nbNewAdrPointer,
1980 ps->Scan.fRefreshState = _FALSE;
1981 IOPutOnAllRegisters( ps );
1985 if( ps->Shade.pHilight ) {
1987 memset( ps->Shade.pHilight, 0,
1988 ps->Shade.shadingBytes * ps->Shade.skipHilight * 3 );
1990 memset((pUChar)ps->Shade.pHilight +
1991 ps->Shade.shadingBytes * ps->Shade.skipHilight * 3, 0xff,
1992 ps->Shade.shadingBytes * ps->Shade.skipShadow * 3 );
1998 IOReadOneShadingLine( ps,
1999 ((pUChar)ps->Bufs.b1.pShadingRam)+_SHADING_BEGINX,
2000 ps->Shade.shadingBytes );
2003 if( ps->Shade.pHilight ) {
2005 if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
2007 cp.red.usp = ps->Bufs.b1.pShadingRam + _SHADING_BEGINX;
2008 cp.green.usp = cp.red.usp + ps->AsicReg.RD_Pixels;
2009 cp.blue.usp = cp.green.usp + ps->AsicReg.RD_Pixels;
2010 pvar.pusrgb = (pRGBUShortDef)ps->Shade.pHilight +
2013 for( var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
2020 for( b = ps->Shade.skipHilight; b--;
2021 pRGB += ps->AsicReg.RD_Pixels) {
2043 for(b = ps->Shade.skipShadow; b--;
2044 pRGB += ps->AsicReg.RD_Pixels) {
2066 cp.green.usp = ps->Bufs.b1.pShadingRam +
2067 ps->AsicReg.RD_Pixels + _SHADING_BEGINX;
2068 cp.blue.usp = (pUShort) ps->Shade.pHilight + _SHADING_BEGINX;
2070 for (var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
2074 for( b = ps->Shade.skipHilight; b--;
2075 cp.red.usp += ps->AsicReg.RD_Pixels) {
2083 for (b = ps->Shade.skipShadow; b--;
2084 cp.red.usp += ps->AsicReg.RD_Pixels) {
2096 if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
2098 cp.red.usp = ps->Bufs.b1.pShadingRam + _SHADING_BEGINX;
2099 cp.green.usp = cp.red.usp + ps->AsicReg.RD_Pixels;
2100 cp.blue.usp = cp.green.usp + ps->AsicReg.RD_Pixels;
2102 pvar.pulrgb = (pRGBULongDef)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
2104 for( var.dwValue = (ULong)ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
2114 cp.green.usp = ps->Bufs.b1.pShadingRam + ps->AsicReg.RD_Pixels +
2116 pvar.pdw = (pULong)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
2117 for(var.dwValue = (ULong)ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
2123 if( IOReadFifoLength( ps ) < ps->AsicReg.RD_Pixels )
2124 IORegisterToScanner( ps, ps->RegRefreshScanState );
2128 if( ps->Shade.pHilight ) {
2130 if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
2132 psum.pulrgb = (pRGBULongDef)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
2133 pwsum = (pRGBUShortDef)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
2134 pvar.pusrgb = (pRGBUShortDef)ps->Shade.pHilight + _SHADING_BEGINX;
2136 for( var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
2140 for( b = ps->Shade.skipHilight + ps->Shade.skipShadow;
2141 b--; pRGB += ps->AsicReg.RD_Pixels ) {
2148 pwsum->Red = (UShort)(psum.pulrgb->Red / ps->Shade.dwDiv);
2149 pwsum->Green = (UShort)(psum.pulrgb->Green / ps->Shade.dwDiv);
2150 pwsum->Blue = (UShort)(psum.pulrgb->Blue / ps->Shade.dwDiv);
2155 cp.green.ulp = (pULong)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
2156 cp.blue.usp = (pUShort)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
2157 pvar.pw = (pUShort)ps->Shade.pHilight + _SHADING_BEGINX;
2159 for( var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
2163 for( b = ps->Shade.skipHilight + ps->Shade.skipShadow;
2164 b--; cp.red.usp += ps->AsicReg.RD_Pixels )
2167 *cp.blue.usp = (UShort)(*cp.green.ulp / ps->Shade.dwDiv);
2173 if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
2175 psum.pulrgb = (pRGBULongDef)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
2176 pwsum = (pRGBUShortDef)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
2178 for (var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
2187 cp.green.ulp = (pULong)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
2188 cp.blue.usp = (pUShort)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
2190 for (var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
2200 if( ps->DataInf.dwScanFlag & SCANDEF_TPA )
2201 TPAP98003FindCenterPointer( ps );
2203 if( ps->DataInf.dwScanFlag & SCANDEF_Negative )
2204 TPAP98003Reshading( ps );
2206 pRGB = (pRGBUShortDef)&ps->Shade.pCcdDac->GainResize;
2208 if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
2210 pwsum = (pRGBUShortDef)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
2212 for( var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
2215 if ((short)(pwsum->Red -= ps->Shade.DarkOffset.Colors.Red) > 0) {
2222 if((short)(pwsum->Green -= ps->Shade.DarkOffset.Colors.Green) > 0) {
2229 if ((short)(pwsum->Blue -= ps->Shade.DarkOffset.Colors.Blue) > 0) {
2249 cp.green.usp = (pUShort)ps->Bufs.b2.pSumBuf + _SHADING_BEGINX;
2251 for( var.dwValue = ps->AsicReg.RD_Pixels - _SHADING_BEGINX;
2254 if((short)(*cp.green.usp -= ps->Shade.DarkOffset.Colors.Green) > 0) {
2271 dacP98DownloadShadingTable( ps, ps->Bufs.b2.pSumBuf, (5400 * 3 * 2));
2276 static void dacP98003AdjustDark( pScanData ps )
2283 ps->Shade.DarkDAC.Colors = ps->Shade.pCcdDac->DarkDAC.Colors;
2284 ps->Shade.fStop = _FALSE;
2286 for( i = 16; i-- && !ps->Shade.fStop;) {
2288 ps->Shade.fStop = _TRUE;
2291 DacP98003FillToDAC( ps, &ps->Device.RegDACOffset, &ps->Shade.DarkDAC );
2293 IODataToRegister( ps, ps->RegModeControl, _ModeIdle );
2295 ps->AsicReg.RD_ScanControl = (_SCAN_12BITMODE + _SCAN_1ST_AVERAGE);
2296 IOSelectLampSource( ps );
2297 IODataToRegister( ps, ps->RegScanControl, ps->AsicReg.RD_ScanControl );
2299 ps->AsicReg.RD_StepControl = _MOTOR0_SCANSTATE;
2300 ps->AsicReg.RD_Motor0Control = _FORWARD_MOTOR;
2302 ps->AsicReg.RD_Origin = _SHADING_BEGINX;
2303 ps->AsicReg.RD_Pixels = 512;
2305 if( ps->Shade.bIntermediate & _ScanMode_AverageOut )
2306 ps->AsicReg.RD_Dpi = 300;
2308 ps->AsicReg.RD_Dpi = 600;
2312 memset( ps->a_nbNewAdrPointer, 0, _SCANSTATE_BYTES );
2313 ps->a_nbNewAdrPointer[1] = 0x77;
2315 IOPutOnAllRegisters( ps );
2319 if( IOReadOneShadingLine(ps, (pUChar)ps->Bufs.b1.pShadingRam, 512*2)) {
2321 if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
2323 wDarks[0] = dacP98003SumDarks( ps, ps->Bufs.b1.pShadingRam );
2324 wDarks[1] = dacP98003SumDarks( ps, ps->Bufs.b1.pShadingRam +
2325 ps->AsicReg.RD_Pixels );
2326 wDarks[2] = dacP98003SumDarks( ps, ps->Bufs.b1.pShadingRam +
2327 ps->AsicReg.RD_Pixels * 2UL);
2330 ps->Shade.fStop = _FALSE;
2332 ps->Shade.DarkOffset.wColors[0] = wDarks[0];
2333 ps->Shade.DarkOffset.wColors[1] = wDarks[1];
2334 ps->Shade.DarkOffset.wColors[2] = wDarks[2];
2335 (*(ps->Device).fnDACDark)( ps, ps->Shade.pCcdDac,
2337 (*(ps->Device).fnDACDark)( ps, ps->Shade.pCcdDac,
2339 (*(ps->Device).fnDACDark)( ps, ps->Shade.pCcdDac,
2343 wDarks[1] = dacP98003SumDarks( ps, ps->Bufs.b1.pShadingRam +
2344 ps->AsicReg.RD_Pixels );
2346 ps->Shade.fStop = _FALSE;
2348 ps->Shade.DarkOffset.wColors[1] = wDarks[1];
2349 (*(ps->Device).fnDACDark)( ps, ps->Shade.pCcdDac,
2354 ps->Shade.fStop = _FALSE;
2358 if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
2359 (*(ps->Device).fnDarkOffset)( ps, ps->Shade.pCcdDac, _CHANNEL_RED );
2360 (*(ps->Device).fnDarkOffset)( ps, ps->Shade.pCcdDac, _CHANNEL_GREEN );
2361 (*(ps->Device).fnDarkOffset)( ps, ps->Shade.pCcdDac, _CHANNEL_BLUE );
2363 (*(ps->Device).fnDarkOffset)( ps, ps->Shade.pCcdDac, _CHANNEL_GREEN );
2368 static Bool dacP98003WaitForShading( pScanData ps )
2378 ps->ReInitAsic( ps, _TRUE );
2380 ps->Shade.DarkOffset.Colors.Red = 0;
2381 ps->Shade.DarkOffset.Colors.Green = 0;
2382 ps->Shade.DarkOffset.Colors.Blue = 0;
2384 IORegisterToScanner( ps, ps->RegResetMTSC );
2386 IODataToRegister( ps, ps->RegModelControl, ps->AsicReg.RD_ModelControl);
2387 IODataToRegister( ps, ps->RegMotorDriverType,
2388 ps->AsicReg.RD_MotorDriverType );
2389 IODataToRegister( ps, ps->RegScanControl1,
2391 ps->GotoShadingPosition( ps );
2393 bScanControl = ps->AsicReg.RD_ScanControl;
2396 memset( ps->Bufs.b2.pSumBuf, 0xff, (5400 * 3 * 2));
2399 dacP98DownloadShadingTable( ps, ps->Bufs.b2.pSumBuf, (5400 * 3 * 2));
2402 ps->Bufs.b1.Buf.pdw[i] =
2403 ps->Bufs.b1.Buf.pdw[i+1] =
2404 ps->Bufs.b1.Buf.pdw[i+2] =
2405 ps->Bufs.b1.Buf.pdw[i+3] = tmp;
2408 memcpy( ps->Bufs.b1.pShadingMap + 4096, ps->Bufs.b1.pShadingMap, 4096 );
2409 memcpy( ps->Bufs.b1.pShadingMap + 8192, ps->Bufs.b1.pShadingMap, 4096 );
2410 dacP98DownloadMapTable( ps, ps->Bufs.b1.pShadingMap );
2412 DBG( DBG_LOW, "wExposure = %u\n", ps->Shade.wExposure);
2413 DBG( DBG_LOW, "wXStep = %u\n", ps->Shade.wXStep);
2415 ps->AsicReg.RD_LineControl = (_LOBYTE(ps->Shade.wExposure));
2416 ps->AsicReg.RD_ExtLineControl = (_HIBYTE(ps->Shade.wExposure));
2417 IODataToRegister(ps, ps->RegExtendedLineControl,
2418 ps->AsicReg.RD_ExtLineControl );
2419 IODataToRegister(ps, ps->RegLineControl, ps->AsicReg.RD_LineControl );
2421 dacP98003AdjustRGBGain( ps );
2422 dacP98003AdjustDark( ps );
2423 dacP98003AdjustShadingWaveform( ps );
2425 ps->AsicReg.RD_ScanControl = bScanControl;
2428 dacP98DownloadMapTable( ps, ps->a_bMapTable );
2430 MotorP98003BackToHomeSensor( ps );
2439 _LOC int DacInitialize( pScanData ps )
2443 if( NULL == ps )
2449 if( _ASIC_IS_98003 == ps->sCaps.AsicID ) {
2451 ps->WaitForShading = dacP98003WaitForShading;
2453 } else if( _ASIC_IS_98001 == ps->sCaps.AsicID ) {
2455 ps->WaitForShading = dacP98WaitForShading;
2457 } else if( _ASIC_IS_96003 == ps->sCaps.AsicID ) {
2459 ps->WaitForShading = dacP96003WaitForShading;
2461 } else if( _ASIC_IS_96001 == ps->sCaps.AsicID ) {
2463 ps->WaitForShading = dacP96001WaitForShading;
2475 _LOC void DacP98FillGainOutDirectPort( pScanData ps )
2477 ps->OpenScanPath( ps );
2479 IODataRegisterToDAC( ps, 0x28, ps->bRedGainIndex );
2480 IODataRegisterToDAC( ps, 0x29, ps->bGreenGainIndex );
2481 IODataRegisterToDAC( ps, 0x2a, ps->bBlueGainIndex );
2483 ps->CloseScanPath( ps );
2488 _LOC void DacP98FillShadingDarkToShadingRegister( pScanData ps )
2495 ps->AsicReg.RD_RedDarkOff = ps->Shade.DarkOffset.Colors.Red;
2496 ps->AsicReg.RD_GreenDarkOff = ps->Shade.DarkOffset.Colors.Green;
2497 ps->AsicReg.RD_BlueDarkOff = ps->Shade.DarkOffset.Colors.Blue;
2499 pValue = (pUChar)&ps->AsicReg.RD_RedDarkOff;
2500 for (bReg = ps->RegRedChDarkOffsetLow; bReg <= ps->RegBlueChDarkOffsetHigh;
2503 IODataToRegister( ps, bReg, *pValue );
2509 _LOC void DacP98AdjustDark( pScanData ps )
2515 ps->Shade.pCcdDac->DarkDAC.Colors.Red = ps->bsPreRedDAC;
2516 ps->Shade.pCcdDac->DarkDAC.Colors.Green = ps->bsPreGreenDAC;
2517 ps->Shade.pCcdDac->DarkDAC.Colors.Blue = ps->bsPreBlueDAC;
2519 if( ps->DataInf.dwScanFlag & SCANDEF_Negative ) {
2530 ps->OpenScanPath( ps );
2531 dacP98FillDarkDAC( ps );
2532 dacP98SetReadFBKRegister( ps );
2533 ps->CloseScanPath( ps );
2535 IOPutOnAllRegisters( ps );
2537 ps->PauseColorMotorRunStates( ps ); /* stop scan states */
2539 IOReadOneShadingLine( ps, ps->pScanBuffer1, 512*2 );
2541 dacP98FillChannelDarkLevelControl( ps );
2543 if(dacP98CheckChannelDarkLevel( ps ))
2547 ps->Shade.DarkOffset.Colors.Red=
2548 dacP98CalDarkOff( ps, ps->Shade.DarkOffset.Colors.Red,
2549 ps->Shade.pCcdDac->DarkCmpHi.Colors.Red,
2550 ps->Shade.pCcdDac->DarkOffSub.Colors.Red );
2552 ps->Shade.DarkOffset.Colors.Green =
2553 dacP98CalDarkOff( ps, ps->Shade.DarkOffset.Colors.Green,
2554 ps->Shade.pCcdDac->DarkCmpHi.Colors.Green,
2555 ps->Shade.pCcdDac->DarkOffSub.Colors.Green );
2557 ps->Shade.DarkOffset.Colors.Blue =
2558 dacP98CalDarkOff( ps, ps->Shade.DarkOffset.Colors.Blue,
2559 ps->Shade.pCcdDac->DarkCmpHi.Colors.Blue,
2560 ps->Shade.pCcdDac->DarkOffSub.Colors.Blue );
2565 _LOC void DacP96WriteBackToGammaShadingRAM( pScanData ps )
2567 /* ModifyGammaShadingOffset(ps) */
2568 ps->OpenScanPath( ps);
2570 IODataToRegister( ps, ps->RegRedChShadingOffset,
2571 ps->Asic96Reg.u28.RD_RedChShadingOff );
2572 IODataToRegister( ps, ps->RegGreenChShadingOffset,
2573 (Byte)((ULong)ps->Asic96Reg.u29.RD_GreenChShadingOff * 96UL/100UL));
2575 IODataToRegister( ps, ps->RegBlueChShadingOffset,
2576 (Byte)((ULong)ps->Asic96Reg.RD_BlueChShadingOff * 91UL/100UL));
2578 ps->CloseScanPath( ps );
2580 dacP96WriteLinearGamma( ps, ps->pPrescan16, 256, ps->ShadingBankRed);
2581 dacP96WriteLinearGamma( ps, ps->pPrescan16 + ps->ShadingBankSize,
2582 256, ps->ShadingBankGreen);
2583 dacP96WriteLinearGamma( ps, ps->pPrescan16 + ps->ShadingBankSize * 2,
2584 256, ps->ShadingBankBlue);
2589 _LOC void DacP98003FillToDAC( pScanData ps, pRGBByteDef regs, pColorByte data )
2591 if ( ps->DataInf.wPhyDataType > COLOR_256GRAY ) {
2593 dacP98003GainOffsetToDAC( ps, _DAC_RED, regs->Red, data->Colors.Red );
2594 dacP98003GainOffsetToDAC( ps, _DAC_GREENCOLOR,
2596 dacP98003GainOffsetToDAC( ps, _DAC_BLUE,
2599 dacP98003GainOffsetToDAC( ps, _DAC_GREENMONO, regs->Green,
2606 _LOC void DacP98003AdjustGain( pScanData ps, ULong color, Byte hilight )
2608 if( hilight < ps->Shade.bGainLow ) {
2610 if( ps->Shade.Hilight.bColors[color] < ps->Shade.bGainHigh ) {
2612 ps->Shade.fStop = _FALSE;
2613 ps->Shade.Hilight.bColors[color] = hilight;
2615 if( hilight <= (Byte)(ps->Shade.bGainLow - hilight))
2616 ps->Shade.Gain.bColors[color] += ps->Shade.bGainDouble;
2618 ps->Shade.Gain.bColors[color]++;
2621 if( hilight > ps->Shade.bGainHigh ) {
2622 ps->Shade.fStop = _FALSE;
2623 ps->Shade.Hilight.bColors[color] = hilight;
2624 ps->Shade.Gain.bColors[color]--;
2626 ps->Shade.Hilight.bColors[color] = hilight;
2629 if( ps->Shade.Gain.bColors[color] > ps->Shade.bMaxGain ) {
2630 ps->Shade.Gain.bColors[color] = ps->Shade.bMaxGain;