diff options
Diffstat (limited to 'backend/u12-hw.c')
| -rw-r--r-- | backend/u12-hw.c | 978 |
1 files changed, 978 insertions, 0 deletions
diff --git a/backend/u12-hw.c b/backend/u12-hw.c new file mode 100644 index 0000000..89f37be --- /dev/null +++ b/backend/u12-hw.c @@ -0,0 +1,978 @@ +/** @file u12-hw.c + * @brief The HW-access functions to the U12 backend stuff. + * + * Copyright (c) 2003-2004 Gerhard Jaeger <gerhard@gjaeger.de> + * + * History: + * - 0.01 - initial version + * - 0.02 - cleanup + * - added lampTimer stuff + * - fixed issue for Genius device - reported by + * Jose Alberto Reguero <jareguero@telefonica.net> + * . + * <hr> + * This file is part of the SANE package. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License as + * published by the Free Software Foundation; either version 2 of the + * License, or (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, but + * WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, + * MA 02111-1307, USA. + * + * As a special exception, the authors of SANE give permission for + * additional uses of the libraries contained in this release of SANE. + * + * The exception is that, if you link a SANE library with other files + * to produce an executable, this does not by itself cause the + * resulting executable to be covered by the GNU General Public + * License. Your use of that executable is in no way restricted on + * account of linking the SANE library code into it. + * + * This exception does not, however, invalidate any other reasons why + * the executable file might be covered by the GNU General Public + * License. + * + * If you submit changes to SANE to the maintainers to be included in + * a subsequent release, you agree by submitting the changes that + * those changes may be distributed with this exception intact. + * + * If you write modifications of your own for SANE, it is your choice + * whether to permit this exception to apply to your modifications. + * If you do not wish that, delete this exception notice. + * <hr> + */ + +#define _TEST_SIZE 1000 + +/*************************** some local vars *********************************/ + +static RegDef u12CcdStop[] = { +/* this was the original sequence from parport backend*/ +#if 0 +#define _STOP_LEN 13 + + {0x41, 0xff}, {0x42, 0xff}, {0x60, 0xff}, {0x61, 0xff}, + {0x4b, 0xff}, {0x4c, 0xff}, {0x4d, 0xff}, {0x4e, 0xff}, + {0x2a, 0x01}, {0x2b, 0x00}, {0x2d, 0x00}, {0x1b, 0x19}, {0x15, 0x00} +#else +#define _STOP_LEN 29 +/* this is what we see from usb-snoop... */ + {0x60, 0xff}, {0x61, 0xff}, {0x1b, 0x19}, {0x15, 0x00}, {0x20, 0x14}, + {0x2c, 0x02}, {0x39, 0x00}, {0x3a, 0x00}, {0x3b, 0x00}, {0x3c, 0x00}, + {0x41, 0x00}, {0x42, 0x00}, {0x43, 0x00}, {0x44, 0x00}, {0x45, 0x01}, + {0x46, 0x00}, {0x47, 0x00}, {0x48, 0x00}, {0x49, 0x00}, {0x4a, 0x09}, + {0x4b, 0x00}, {0x4c, 0x00}, {0x4d, 0x00}, {0x4e, 0x01}, {0x50, 0x00}, + {0x51, 0x00}, {0x52, 0x00}, {0x53, 0x01}, {0x67, 0x00} +#endif +}; + +/** + */ +static void u12hw_SelectLampSource( U12_Device *dev ) +{ + dev->regs.RD_ScanControl &= (~_SCAN_LAMPS_ON); + + if( dev->DataInf.dwScanFlag & (_SCANDEF_TPA)) { + dev->regs.RD_ScanControl |= _SCAN_TPALAMP_ON; + } else { + dev->regs.RD_ScanControl |= _SCAN_NORMALLAMP_ON; + } +} + +/** as the function name says + */ +static void u12hw_PutToIdleMode( U12_Device *dev ) +{ + DBG( _DBG_INFO, "CCD-Stop\n" ); + u12io_DataToRegs( dev, (SANE_Byte*)u12CcdStop, _STOP_LEN ); +} + +/** program the CCD relevant stuff + */ +static void u12hw_ProgramCCD( U12_Device *dev ) +{ + SANE_Byte *reg_val; + + DBG( _DBG_INFO, "u12hw_ProgramCCD: 0x%08lx[%lu]\n", + (u_long)dev->CCDRegs, + ((u_long)dev->numCCDRegs * dev->shade.intermediate)); + + DBG( _DBG_INFO, " * %u regs * %u (intermediate)\n", + dev->numCCDRegs, dev->shade.intermediate ); + + reg_val = (SANE_Byte*)(dev->CCDRegs + + (u_long)dev->numCCDRegs * dev->shade.intermediate); + + u12io_DataToRegs( dev, reg_val, dev->numCCDRegs ); +} + +/** init the stuff according to the buttons + */ +static void u12hw_ButtonSetup( U12_Device *dev, SANE_Byte numButtons ) +{ + dev->Buttons = numButtons; + + dev->regs.RD_MotorDriverType |= _BUTTON_DISABLE; + dev->MotorPower |= _BUTTON_DISABLE; +} + +/** According to what we have detected, set the other stuff + */ +static void u12hw_InitiateComponentModel( U12_Device *dev ) +{ + /* preset some stuff and do the differences later */ + dev->Buttons = 0; + dev->ModelOriginY = 64; + dev->Tpa = SANE_FALSE; + dev->ModelCtrl = (_LED_ACTIVITY | _LED_CONTROL); + + switch( dev->PCBID ) { + + /* typical for Plustek OpticPro U12 and 1212U */ + case _PLUSTEK_SCANNER: + DBG( _DBG_INFO, "We have a Plustek Scanner ;-)\n" ); + break; + + case _SCANNER_WITH_TPA: + DBG( _DBG_INFO, "Scanner has TPA\n" ); + dev->Tpa = SANE_TRUE; + break; + + case _SCANNER4Button: + DBG( _DBG_INFO, "Scanner has 4 Buttons\n" ); + u12hw_ButtonSetup( dev, 4 ); + break; + + /* typical for Plustek OpticPro UT12 */ + case _SCANNER4ButtonTPA: + DBG( _DBG_INFO, "Scanner has 4 Buttons & TPA\n" ); + dev->Tpa = SANE_TRUE; + u12hw_ButtonSetup( dev, 4 ); + break; + + case _SCANNER5Button: + DBG( _DBG_INFO, "Scanner has 5 Buttons\n" ); + dev->ModelOriginY += 20; + u12hw_ButtonSetup( dev, 5 ); + break; + + /* typical for Genius Colorpage HR6 */ + case _SCANNER5ButtonTPA: + DBG( _DBG_INFO, "Scanner has 5 Buttons & TPA\n" ); + dev->ModelOriginY += 20; + dev->Tpa = SANE_TRUE; + u12hw_ButtonSetup( dev, 5 ); + break; + + case _SCANNER1Button: + DBG( _DBG_INFO, "Scanner has 1 Button\n" ); + u12hw_ButtonSetup( dev, 1 ); + break; + + case _SCANNER1ButtonTPA: + DBG( _DBG_INFO, "Scanner has 1 Button & TPA\n" ); + dev->Tpa = SANE_TRUE; + u12hw_ButtonSetup( dev, 1 ); + break; + + case _AGFA_SCANNER: + DBG( _DBG_INFO, "Agfa Scanner\n" ); + dev->ModelOriginY = 24; /* 1200 dpi */ + break; + + case _SCANNER2Button: + DBG( _DBG_INFO, "Scanner has 2 Buttons\n" ); + dev->ModelOriginY -= 33; + u12hw_ButtonSetup( dev, 2 ); + break; + + default: + DBG( _DBG_INFO, "Default Model: U12\n" ); + break; + } + +#if 0 + if( _MOTOR0_2003 == dev->MotorID ) { + dev->f2003 = SANE_TRUE; + dev->XStepMono = 10; + dev->XStepColor = 6; + dev->XStepBack = 5; + dev->regs.RD_MotorDriverType |= _MOTORR_STRONG; + } else { +#endif + dev->f2003 = SANE_FALSE; + dev->XStepMono = 8; + dev->XStepColor = 4; + dev->XStepBack = 5; + dev->regs.RD_MotorDriverType |= _MOTORR_WEAK; +/* } */ +} + +/** + */ +static SANE_Status u12hw_InitAsic( U12_Device *dev, SANE_Bool shading ) +{ + SANE_Byte rb[6]; + int c; + + DBG( _DBG_INFO, "u12hw_InitAsic(%d)\n", shading ); + + /* get DAC and motor stuff */ + dev->DACType = u12io_DataFromRegister( dev, REG_RESETCONFIG ); + dev->MotorID = (SANE_Byte)(dev->DACType & _MOTOR0_MASK); + + dev->regs.RD_MotorDriverType = + (SANE_Byte)((dev->DACType & _MOTOR0_MASK) >> 3); + dev->regs.RD_MotorDriverType |= + (SANE_Byte)((dev->DACType & _MOTOR1_MASK) >> 1); + dev->DACType &= _ADC_MASK; + + dev->MotorPower = dev->regs.RD_MotorDriverType | _MOTORR_STRONG; + + /*get CCD and PCB ID */ + dev->PCBID = u12io_DataFromRegister( dev, REG_CONFIG ); + dev->CCDID = dev->PCBID & 0x07; + dev->PCBID &= 0xf0; + + if( _AGFA_SCANNER == dev->PCBID ) + dev->DACType = _DA_WOLFSON8141; + + DBG( _DBG_INFO, "* PCB-ID=0x%02x, CCD-ID=0x%02x, DAC-TYPE=0x%02x\n", + dev->PCBID, dev->CCDID, dev->DACType ); + + u12hw_InitiateComponentModel( dev ); + u12ccd_InitCCDandDAC( dev, shading ); + + dev->regs.RD_Model1Control = _CCD_SHIFT_GATE; + if( dev->Buttons != 0 ) + dev->regs.RD_Model1Control += _BUTTON_MODE; + + if( dev->shade.intermediate & _ScanMode_Mono ) + dev->regs.RD_Model1Control += _SCAN_GRAYTYPE; + + DBG( _DBG_INFO, "* MotorDrvType = 0x%02x\n", dev->regs.RD_MotorDriverType); + DBG( _DBG_INFO, "* Model1Cntrl = 0x%02x\n", dev->regs.RD_Model1Control ); + +#if 0 + u12io_DataToRegister( dev, REG_MOTORDRVTYPE, dev->regs.RD_MotorDriverType); + u12io_DataToRegister( dev, REG_WAITSTATEINSERT, 4 ); + u12io_DataToRegister( dev, REG_MODEL1CONTROL, dev->regs.RD_Model1Control ); +#else + c = 0; + _SET_REG( rb, c, REG_MOTORDRVTYPE, dev->regs.RD_MotorDriverType); + _SET_REG( rb, c, REG_WAITSTATEINSERT, 4 ); + _SET_REG( rb, c, REG_MODEL1CONTROL, dev->regs.RD_Model1Control ); + u12io_DataToRegs( dev, rb, c ); +#endif + + u12hw_ProgramCCD( dev ); + DBG( _DBG_INFO, "u12hw_InitAsic done.\n" ); + return SANE_STATUS_GOOD; +} + +/** + */ +static void u12hw_ControlLampOnOff( U12_Device *dev ) +{ + SANE_Byte lampStatus; + + dev->warmupNeeded = SANE_TRUE; + + lampStatus = dev->regs.RD_ScanControl & _SCAN_LAMPS_ON; + + if ( dev->lastLampStatus != lampStatus ) { + + DBG( _DBG_INFO, "* Using OTHER Lamp --> warmup needed\n" ); + dev->lastLampStatus = lampStatus; + + u12io_DataToRegister( dev, REG_SCANCONTROL, dev->regs.RD_ScanControl ); + return; + } + + dev->warmupNeeded = SANE_FALSE; + DBG( _DBG_INFO, "* Using SAME Lamp --> no warmup needed\n" ); +} + +/** set all necessary register contents + */ +static void u12hw_SetGeneralRegister( U12_Device *dev ) +{ + DBG( _DBG_INFO, "u12hw_SetGeneralRegister()\n" ); + + dev->scan.motorBackward = SANE_FALSE; + dev->scan.refreshState = SANE_FALSE; + + if( COLOR_BW == dev->DataInf.wPhyDataType ) + dev->regs.RD_ScanControl = _SCAN_BITMODE; + else { + if( dev->DataInf.wPhyDataType <= COLOR_TRUE24 ) + dev->regs.RD_ScanControl = _SCAN_BYTEMODE; + else + dev->regs.RD_ScanControl = _SCAN_12BITMODE; + } + + u12hw_SelectLampSource( dev ); + + dev->regs.RD_ModelControl = (_LED_CONTROL | _LED_ACTIVITY); + if( dev->shade.intermediate & _ScanMode_AverageOut ) + dev->regs.RD_ModelControl |= _MODEL_DPI300; + else + dev->regs.RD_ModelControl |= _MODEL_DPI600; + + dev->regs.RD_Motor0Control = _MotorOn | _MotorHQuarterStep | _MotorPowerEnable; + dev->regs.RD_ScanControl1 = _SCANSTOPONBUFFULL | _MFRC_BY_XSTEP; + dev->regs.RD_StepControl = _MOTOR0_SCANSTATE; +} + +/** + */ +static void u12hw_SetupPreviewCondition( U12_Device *dev ) +{ + int i, c; + u_long channel; + SANE_Byte rb[100]; + + DBG( _DBG_INFO, "u12_SetupPreviewCondition()\n" ); + + u12hw_SetGeneralRegister( dev ); + + u12io_RegisterToScanner( dev, REG_RESETMTSC ); + _DODELAY(250); + + /* ------- Set the max. read fifo to Asic ------- */ + memset( dev->scanStates, 0, _SCANSTATE_BYTES ); + if( dev->DataInf.xyAppDpi.x >= 38 ) { /* 38 <= x <= 75 */ + + for(i = 0; i < _SCANSTATE_BYTES; i++ ) + dev->scanStates[i] = 0xad; + + } else if( dev->DataInf.xyAppDpi.x >= 19 ) { /* 19 <= x <= 30(37) */ + + u_short *pState = (u_short*)dev->scanStates; + + for( i = 0; i < (_SCANSTATE_BYTES / 2); i++ ) + pState[i] = 0x89ac; + + } else { /* 16 <= x <= 18 */ + + u_long *pState = (u_long*)dev->scanStates; + + for(i = 0; i < (_SCANSTATE_BYTES / 4); i++) + pState[i] = 0x888889ac; + } + + dev->regs.RD_BufFullSize = dev->DataInf.dwAppPixelsPerLine * + ((dev->DataInf.xyPhyDpi.y * dev->max_y + 299) / 300) + 1; + if( dev->regs.RD_BufFullSize > _SIZE_BLUEFIFO ) + dev->regs.RD_BufFullSize = _SIZE_BLUEFIFO - + dev->DataInf.dwAppPixelsPerLine - 1; + + dev->scan.dwMaxReadFifo = + dev->scan.dwMinReadFifo = dev->DataInf.dwAppPixelsPerLine *2 ; + + if( dev->scan.dwMinReadFifo < 1024) + dev->scan.dwMinReadFifo = dev->scan.dwMaxReadFifo = 1024; + + dev->scan.dwMaxReadFifo += (dev->DataInf.dwAsicBytesPerPlane / 2); + + if( dev->DataInf.wPhyDataType > COLOR_256GRAY ) + dev->scan.bFifoSelect = REG_BFIFOOFFSET; + else + dev->scan.bFifoSelect = REG_GFIFOOFFSET; + + channel = _BLUE_FULLSIZE << 16; + dev->regs.RD_BufFullSize = _SIZE_BLUEFIFO; + + dev->regs.RD_LineControl = _LOBYTE(dev->shade.wExposure); + dev->regs.RD_ExtLineControl = _HIBYTE(dev->shade.wExposure); + dev->regs.RD_XStepTime = _LOBYTE(dev->shade.wXStep); + dev->regs.RD_ExtXStepTime = _HIBYTE(dev->shade.wXStep); + dev->regs.RD_Motor0Control = _FORWARD_MOTOR; + dev->regs.RD_StepControl = _MOTOR0_SCANSTATE | _MOTOR_FREERUN; + dev->regs.RD_ModeControl = _ModeScan; + + if( dev->DataInf.wPhyDataType == COLOR_BW ) { + dev->regs.RD_ScanControl = _SCAN_BITMODE; + } else if( dev->DataInf.wPhyDataType <= COLOR_TRUE24 ) + dev->regs.RD_ScanControl = _SCAN_BYTEMODE; + else { + dev->regs.RD_ScanControl = _SCAN_12BITMODE; + } + + dev->regs.RD_ScanControl |= _SCAN_1ST_AVERAGE; + u12hw_SelectLampSource( dev ); + + dev->regs.RD_MotorTotalSteps = (dev->DataInf.crImage.cy * 4) + + (dev->f0_8_16 ? 32 : 16) + + (dev->scan.bDiscardAll ? 32 : 0); + DBG( _DBG_INFO, "* RD_MotorTotalSteps = 0x%04x\n", + dev->regs.RD_MotorTotalSteps); + + dev->regs.RD_ScanControl1 = (_MTSC_ENABLE | _SCANSTOPONBUFFULL | + _MFRC_RUNSCANSTATE | _MFRC_BY_XSTEP); + DBG( _DBG_INFO, "* RD_ScanControl1 = 0x%02x\n", dev->regs.RD_ScanControl1); + + dev->regs.RD_Dpi = dev->DataInf.xyPhyDpi.x; + + dev->regs.RD_Origin = (u_short)(dev->adj.leftNormal*2+_DATA_ORIGIN_X); + dev->regs.RD_Origin += dev->DataInf.crImage.x; + + if( dev->shade.intermediate & _ScanMode_AverageOut ) + dev->regs.RD_Origin >>= 1; + + if( dev->DataInf.wPhyDataType == COLOR_BW ) + dev->regs.RD_Pixels = dev->DataInf.dwAsicBytesPerPlane; + else + dev->regs.RD_Pixels = dev->DataInf.dwAppPixelsPerLine; + + /* ------- Wait for scan state stop ------- */ + u12io_DataToRegister( dev, REG_MODECONTROL, _ModeIdle ); + + u12io_DownloadScanStates( dev ); + + c = 0; + _SET_REG( rb, c, REG_LINECONTROL, dev->regs.RD_LineControl ); + _SET_REG( rb, c, REG_EXTENDEDLINECONTROL, + dev->regs.RD_ExtLineControl); + _SET_REG( rb, c, REG_XSTEPTIME, dev->regs.RD_XStepTime ); + _SET_REG( rb, c, REG_EXTENDEDXSTEP, dev->regs.RD_ExtXStepTime ); + _SET_REG( rb, c, REG_MOTORDRVTYPE, + dev->regs.RD_MotorDriverType ); + _SET_REG( rb, c, REG_STEPCONTROL, dev->regs.RD_StepControl ); + _SET_REG( rb, c, REG_MOTOR0CONTROL, dev->regs.RD_Motor0Control ); + _SET_REG( rb, c, REG_MODELCONTROL, dev->regs.RD_ModelControl ); + _SET_REG( rb, c, REG_DPILO, (_LOBYTE(dev->regs.RD_Dpi))); + _SET_REG( rb, c, REG_DPIHI, (_HIBYTE(dev->regs.RD_Dpi))); + _SET_REG( rb, c, REG_SCANPOSLO, (_LOBYTE(dev->regs.RD_Origin))); + _SET_REG( rb, c, REG_SCANPOSHI,(_HIBYTE(dev->regs.RD_Origin))); + _SET_REG( rb, c, REG_WIDTHPIXELLO,(_LOBYTE(dev->regs.RD_Pixels))); + _SET_REG( rb, c, REG_WIDTHPIXELHI,(_HIBYTE(dev->regs.RD_Pixels))); + _SET_REG( rb, c, REG_THRESHOLDLO, + (_LOBYTE(dev->regs.RD_ThresholdControl))); + _SET_REG( rb, c, REG_THRESHOLDHI, + (_HIBYTE(dev->regs.RD_ThresholdControl))); + _SET_REG( rb, c, REG_MOTORTOTALSTEP0, + (_LOBYTE(dev->regs.RD_MotorTotalSteps))); + _SET_REG( rb, c, REG_MOTORTOTALSTEP1, + (_HIBYTE(dev->regs.RD_MotorTotalSteps))); + _SET_REG( rb, c, REG_SCANCONTROL, dev->regs.RD_ScanControl); + u12io_DataToRegs( dev, rb, c ); + _DODELAY(100); + + u12io_RegisterToScanner( dev, REG_INITDATAFIFO ); +} + +/** + */ +static void u12hw_SetupScanningCondition( U12_Device *dev ) +{ + TimerDef timer; + u_long channel; + int c; + SANE_Byte state; + SANE_Byte rb[100]; + SANE_Byte *pState; + + DBG( _DBG_INFO, "u12_SetupScanningCondition()\n" ); + + u12hw_SetGeneralRegister( dev ); + + u12io_RegisterToScanner( dev, REG_RESETMTSC ); + _DODELAY(250); + + /* ------- Setup MinRead/MaxRead Fifo size ------- */ + if( dev->DataInf.wPhyDataType <= COLOR_TRUE24 ) { + dev->scan.dwMaxReadFifo = + dev->scan.dwMinReadFifo = dev->DataInf.dwAsicBytesPerPlane * 2; + } else { + dev->scan.dwMaxReadFifo = + dev->scan.dwMinReadFifo = dev->DataInf.dwAppPixelsPerLine << 1; + } + + if( dev->scan.dwMinReadFifo < 1024) + dev->scan.dwMinReadFifo = dev->scan.dwMaxReadFifo = 1024; + + dev->scan.dwMaxReadFifo += (dev->DataInf.dwAsicBytesPerPlane / 2); + + DBG( _DBG_INFO, "* MinReadFifo=%lu, MaxReadFifo=%lu\n", + dev->scan.dwMinReadFifo, dev->scan.dwMaxReadFifo ); + + /* ------- Set the max. read fifo to asic ------- */ + if( dev->DataInf.wPhyDataType > COLOR_256GRAY ) { + + dev->scan.bFifoSelect = REG_BFIFOOFFSET; + + if( !dev->scan.p48BitBuf.pb ) { + + long lRed, lGreen; + + lRed = (_SIZE_REDFIFO - _SIZE_BLUEFIFO) / + dev->DataInf.dwAsicBytesPerPlane - dev->scan.bd_rk.wRedKeep; + + lGreen = (_SIZE_GREENFIFO - _SIZE_BLUEFIFO) / + dev->DataInf.dwAsicBytesPerPlane - dev->scan.gd_gk.wGreenKeep; + + if((lRed < 0) || (lGreen < 0)) { + + if( lRed < lGreen ) { + channel = _RED_FULLSIZE << 16; + dev->regs.RD_BufFullSize = _SIZE_REDFIFO; + lGreen = lRed; + } else { + channel = _GREEN_FULLSIZE << 16; + dev->regs.RD_BufFullSize = _SIZE_GREENFIFO; + } + + lGreen = (u_long)(-lGreen * dev->DataInf.dwAsicBytesPerPlane); + + if( dev->DataInf.wPhyDataType > COLOR_TRUE24 ) + lGreen >>= 1; + + dev->scan.dwMinReadFifo += (u_long)lGreen; + dev->scan.dwMaxReadFifo += (u_long)lGreen; + + } else { + channel = _BLUE_FULLSIZE << 16; + dev->regs.RD_BufFullSize = _SIZE_BLUEFIFO; + } + } else { + channel = _BLUE_FULLSIZE << 16; + dev->regs.RD_BufFullSize = _SIZE_BLUEFIFO; + } + } else { + dev->scan.bFifoSelect = REG_GFIFOOFFSET; + channel = _GREEN_FULLSIZE << 16; + dev->regs.RD_BufFullSize = _SIZE_GRAYFIFO; + } + + dev->regs.RD_BufFullSize -= (dev->DataInf.dwAsicBytesPerPlane << 1); + + if( dev->DataInf.wPhyDataType > COLOR_TRUE24 ) + dev->regs.RD_BufFullSize >>= 1; + + dev->regs.RD_BufFullSize |= channel; + + dev->scan.bRefresh = (SANE_Byte)(dev->scan.dwInterval << 1); + dev->regs.RD_LineControl = _LOBYTE(dev->shade.wExposure); + dev->regs.RD_ExtLineControl = _HIBYTE(dev->shade.wExposure); + dev->regs.RD_XStepTime = _LOBYTE(dev->shade.wXStep); + dev->regs.RD_ExtXStepTime = _HIBYTE(dev->shade.wXStep); + dev->regs.RD_Motor0Control = _FORWARD_MOTOR; + dev->regs.RD_StepControl = _MOTOR0_SCANSTATE; + dev->regs.RD_ModeControl = _ModeScan/*(_ModeScan | _ModeFifoGSel)*/; + + DBG( _DBG_INFO, "* bRefresh = %i\n", dev->scan.bRefresh ); + + if( dev->DataInf.wPhyDataType == COLOR_BW ) { + dev->regs.RD_ScanControl = _SCAN_BITMODE; + } else if( dev->DataInf.wPhyDataType <= COLOR_TRUE24 ) + dev->regs.RD_ScanControl = _SCAN_BYTEMODE; + else { + dev->regs.RD_ScanControl = _SCAN_12BITMODE; + } + + dev->regs.RD_ScanControl |= _SCAN_1ST_AVERAGE; + u12hw_SelectLampSource( dev ); + + DBG( _DBG_INFO, "* RD_ScanControl = 0x%02x\n", dev->regs.RD_ScanControl ); + + DBG( _DBG_INFO, "* ImageInfo: x=%u,y=%u,dx=%u,dy=%u\n", + dev->DataInf.crImage.x, dev->DataInf.crImage.y, + dev->DataInf.crImage.cx, dev->DataInf.crImage.cy ); + + dev->regs.RD_MotorTotalSteps = (dev->DataInf.crImage.cy * 4) + + (dev->f0_8_16 ? 32 : 16) + + (dev->scan.bDiscardAll ? 32 : 0); + DBG( _DBG_INFO, "* RD_MotorTotalSteps = 0x%04x\n", + dev->regs.RD_MotorTotalSteps); + + dev->regs.RD_ScanControl1 = (_MTSC_ENABLE | _SCANSTOPONBUFFULL | + _MFRC_RUNSCANSTATE | _MFRC_BY_XSTEP); + DBG( _DBG_INFO, "* RD_ScanControl1 = 0x%02x\n", dev->regs.RD_ScanControl1); + + dev->regs.RD_Dpi = dev->DataInf.xyPhyDpi.x; + + if(!(dev->DataInf.dwScanFlag & _SCANDEF_TPA )) { + dev->regs.RD_Origin = (u_short)(dev->adj.leftNormal*2+_DATA_ORIGIN_X); + + } else if( dev->DataInf.dwScanFlag & _SCANDEF_Transparency ) { + dev->regs.RD_Origin = (u_short)dev->scan.posBegin; + } else { + dev->regs.RD_Origin = (u_short)dev->scan.negBegin; + } + dev->regs.RD_Origin += dev->DataInf.crImage.x; + + if( dev->shade.intermediate & _ScanMode_AverageOut ) + dev->regs.RD_Origin >>= 1; + + if( dev->DataInf.wPhyDataType == COLOR_BW ) + dev->regs.RD_Pixels = (u_short)dev->DataInf.dwAsicBytesPerPlane; + else + dev->regs.RD_Pixels = (u_short)dev->DataInf.dwAppPixelsPerLine; + + DBG( _DBG_INFO, "* RD_Origin = %u, RD_Pixels = %u\n", + dev->regs.RD_Origin, dev->regs.RD_Pixels ); + + /* ------- Prepare scan states ------- */ + memset( dev->scanStates, 0, _SCANSTATE_BYTES ); + memset( dev->bufs.b1.pReadBuf, 0, _NUMBER_OF_SCANSTEPS ); + + if( dev->DataInf.wPhyDataType <= COLOR_256GRAY ) + state = (_SS_MONO | _SS_STEP); + else + state = (_SS_COLOR | _SS_STEP); + + for( channel = _NUMBER_OF_SCANSTEPS, pState = dev->bufs.b1.pReadBuf; + channel; channel -= dev->scan.dwInterval ) { + *pState = state; + pState += dev->scan.dwInterval; + } + for( channel = 0, pState = dev->bufs.b1.pReadBuf; + channel < _SCANSTATE_BYTES; channel++) { + dev->scanStates[channel] = pState[0] | (pState[1] << 4); + pState += 2; + } + + /* ------- Wait for scan state stop ------- */ + u12io_StartTimer( &timer, _SECOND * 2 ); + + u12io_ResetFifoLen(); + while(!(u12io_GetScanState( dev ) & _SCANSTATE_STOP) && + !u12io_CheckTimer(&timer)); + u12io_DownloadScanStates( dev ); + + c = 0; + _SET_REG( rb, c, REG_LINECONTROL, dev->regs.RD_LineControl ); + _SET_REG( rb, c, REG_EXTENDEDLINECONTROL, + dev->regs.RD_ExtLineControl); + _SET_REG( rb, c, REG_XSTEPTIME, dev->regs.RD_XStepTime ); + _SET_REG( rb, c, REG_EXTENDEDXSTEP, dev->regs.RD_ExtXStepTime ); + _SET_REG( rb, c, REG_MOTORDRVTYPE, + dev->regs.RD_MotorDriverType ); + _SET_REG( rb, c, REG_STEPCONTROL, dev->regs.RD_StepControl ); + _SET_REG( rb, c, REG_MOTOR0CONTROL, dev->regs.RD_Motor0Control ); + _SET_REG( rb, c, REG_MODELCONTROL, dev->regs.RD_ModelControl ); + _SET_REG( rb, c, REG_DPILO, (_LOBYTE(dev->regs.RD_Dpi))); + _SET_REG( rb, c, REG_DPIHI, (_HIBYTE(dev->regs.RD_Dpi))); + _SET_REG( rb, c, REG_SCANPOSLO, (_LOBYTE(dev->regs.RD_Origin))); + _SET_REG( rb, c, REG_SCANPOSHI,(_HIBYTE(dev->regs.RD_Origin))); + _SET_REG( rb, c, REG_WIDTHPIXELLO,(_LOBYTE(dev->regs.RD_Pixels))); + _SET_REG( rb, c, REG_WIDTHPIXELHI,(_HIBYTE(dev->regs.RD_Pixels))); + _SET_REG( rb, c, REG_THRESHOLDLO, + (_LOBYTE(dev->regs.RD_ThresholdControl))); + _SET_REG( rb, c, REG_THRESHOLDHI, + (_HIBYTE(dev->regs.RD_ThresholdControl))); + _SET_REG( rb, c, REG_MOTORTOTALSTEP0, + (_LOBYTE(dev->regs.RD_MotorTotalSteps))); + _SET_REG( rb, c, REG_MOTORTOTALSTEP1, + (_HIBYTE(dev->regs.RD_MotorTotalSteps))); + _SET_REG( rb, c, REG_SCANCONTROL, dev->regs.RD_ScanControl); + u12io_DataToRegs( dev, rb, c ); + _DODELAY(100); + + u12io_RegisterToScanner( dev, REG_INITDATAFIFO ); +} + +/** + */ +static SANE_Status u12hw_Memtest( U12_Device *dev ) +{ + SANE_Byte tmp; + SANE_Byte buf[_TEST_SIZE]; + int i; + + DBG( _DBG_INFO, "u12hw_Memtest()\n" ); + + /* prepare buffer */ + for( i = 0; i < _TEST_SIZE; i++ ) { + buf[i] = (SANE_Byte)((i * 3) & 0xff); + } + + /* avoid switching to Lamp0, when previously scanned in transp./neg mode */ + tmp = dev->lastLampStatus + _SCAN_BYTEMODE; + u12io_DataToRegister( dev, REG_SCANCONTROL, tmp ); + + u12io_DataToRegister( dev, REG_MODECONTROL, _ModeMappingMem ); + u12io_DataToRegister( dev, REG_MEMORYLO, 0 ); + u12io_DataToRegister( dev, REG_MEMORYHI, 0 ); + + /* fill to buffer */ + u12io_MoveDataToScanner( dev, buf, _TEST_SIZE ); + + u12io_DataToRegister( dev, REG_MODECONTROL, _ModeMappingMem ); + u12io_DataToRegister( dev, REG_MEMORYLO, 0 ); + u12io_DataToRegister( dev, REG_MEMORYHI, 0 ); + + u12io_DataToRegister( dev, REG_WIDTHPIXELLO, 0 ); + u12io_DataToRegister( dev, REG_WIDTHPIXELHI, 5 ); + + memset( buf, 0, _TEST_SIZE ); + + dev->regs.RD_ModeControl = _ModeReadMappingMem; + u12io_ReadData( dev, buf, _TEST_SIZE ); + + for( i = 0; i < _TEST_SIZE; i++ ) { + if((SANE_Byte)((i * 3) & 0xff) != buf[i] ) { + DBG( _DBG_ERROR, "* Memtest failed at pos %u: %u != %u\n", + i+1, buf[i], (SANE_Byte)((i * 3) & 0xff) ); + return SANE_STATUS_INVAL; + } + } + DBG( _DBG_INFO, "* Memtest passed.\n" ); + return SANE_STATUS_GOOD; +} + +/** check if ASIC can be accessed, if the version is supported and the memory + * is also accessible... + */ +static SANE_Status u12hw_CheckDevice( U12_Device *dev ) +{ +#ifndef _FAKE_DEVICE + SANE_Byte tmp; + SANE_Byte rb[8]; + int c; + +#if 1 + if( !u12io_IsConnected( dev )) { + + if( !u12io_OpenScanPath( dev )) + return SANE_STATUS_IO_ERROR; + } +#else +/* u12io_IsConnected( dev ); */ + if( !u12io_OpenScanPath( dev )) + return SANE_STATUS_IO_ERROR; +#endif + + /* some setup stuff... */ + tmp = u12io_GetExtendedStatus( dev ); + DBG( _DBG_INFO, "* REG_STATUS2 = 0x%02x\n", tmp ); + if( tmp & _REFLECTIONLAMP_ON ) { + DBG( _DBG_INFO, "* Normal lamp is ON\n" ); + dev->lastLampStatus = _SCAN_NORMALLAMP_ON; + } else if( tmp & _TPALAMP_ON ) { + dev->lastLampStatus = _SCAN_TPALAMP_ON; + DBG( _DBG_INFO, "* TPA lamp is ON\n" ); + } + + c = 0; + _SET_REG( rb, c, REG_PLLPREDIV, 1 ); + _SET_REG( rb, c, REG_PLLMAINDIV, 0x20 ); + _SET_REG( rb, c, REG_PLLPOSTDIV, 2 ); + _SET_REG( rb, c, REG_CLOCKSELECTOR, 2 ); + u12io_DataToRegs( dev, rb, c ); + +#if 0 + return u12hw_Memtest( dev ); +#else + if( !dev->initialized ) + return u12hw_Memtest( dev ); + else + return SANE_STATUS_GOOD; +#endif +#else + _VAR_NOT_USED( dev ); + return SANE_STATUS_GOOD; +#endif +} + +/* prototypes... */ +static void u12motor_PositionModuleToHome( U12_Device *); +static void u12motor_ToHomePosition( U12_Device *, SANE_Bool ); + +/** + */ +static void u12hw_CancelSequence( U12_Device *dev ) +{ + int c = 0; + SANE_Byte rb[6]; + + DBG( _DBG_INFO, "u12hw_CancelSequence()\n" ); + + u12motor_PositionModuleToHome( dev ); + + u12motor_ToHomePosition( dev, SANE_TRUE ); + + u12io_DataToRegister( dev, REG_MOTOR0CONTROL, 0 ); + u12io_DataToRegister( dev, REG_MODELCONTROL, 0x1a ); + + u12hw_PutToIdleMode( dev ); + + if( strcmp( dev->usbId, "0x0458-0x2004" )) + u12io_SoftwareReset( dev ); + + u12motor_PositionModuleToHome( dev ); + + u12io_DataToRegister( dev, REG_SCANCONTROL, 0x05 ); + u12io_DataToRegister( dev, REG_MODELCONTROL, 0x1f ); + + u12hw_PutToIdleMode( dev ); + + u12io_DataToRegister( dev, REG_MODELCONTROL, 0x00 ); + + u12io_DataToRegister( dev, REG_ADCADDR, 0x01 ); + u12io_DataToRegister( dev, REG_ADCDATA, 0x00 ); + u12io_DataToRegister( dev, REG_ADCSERIALOUT, 0x00 ); + + _SET_REG( rb, c, REG_MODECONTROL, 0x19 ); + _SET_REG( rb, c, REG_STEPCONTROL, 0xff ); + _SET_REG( rb, c, REG_MOTOR0CONTROL, 0 ); + u12io_DataToRegs( dev, rb, c ); + + u12io_CloseScanPath( dev ); +} + +/** + */ +static SANE_Status u12hw_WarmupLamp( U12_Device *dev ) +{ + TimerDef timer; + + DBG( _DBG_INFO, "u12hw_WarmupLamp()\n" ); + + if( dev->warmupNeeded ) { + DBG( _DBG_INFO, "* warming up...\n" ); + u12io_StartTimer( &timer, _SECOND * dev->adj.warmup ); + while( !u12io_CheckTimer( &timer )) { + if( u12io_IsEscPressed()) { + DBG( _DBG_INFO, "* CANCEL detected!\n" ); + return SANE_STATUS_CANCELLED; + } + } + } else { + DBG( _DBG_INFO, "* skipped\n" ); + } + return SANE_STATUS_GOOD; +} + +/* FIXME: replace!!! */ +static U12_Device *dev_xxx = NULL; + +/** ISR to switch lamp off after time has elapsed + */ +static void usb_LampTimerIrq( int sig ) +{ + SANE_Byte tmp; + int handle = -1; + + if( NULL == dev_xxx ) + return; + + _VAR_NOT_USED( sig ); + DBG( _DBG_INFO, "*** LAMP OFF!!! ***\n" ); + + if( -1 == dev_xxx->fd ) { + + if( SANE_STATUS_GOOD == sanei_usb_open(dev_xxx->sane.name, &handle)) { + dev_xxx->fd = handle; + } + } + + if( -1 != dev_xxx->fd ) { + + if( !u12io_IsConnected( dev_xxx )) { + + if( u12io_OpenScanPath( dev_xxx )) { + + /* some setup stuff... */ + tmp = u12io_GetExtendedStatus( dev_xxx ); + if( tmp & _REFLECTIONLAMP_ON ) { + DBG( _DBG_INFO, "* Normal lamp is ON\n" ); + } else if( tmp & _TPALAMP_ON ) { + DBG( _DBG_INFO, "* TPA lamp is ON\n" ); + } + + u12io_DataToRegister( dev_xxx, REG_SCANCONTROL, 0 ); + u12io_CloseScanPath( dev_xxx ); + } + } + } + + if( -1 != handle ) { + dev_xxx->fd = -1; + sanei_usb_close( handle ); + } +} + +/** + */ +static void u12hw_StartLampTimer( U12_Device *dev ) +{ + sigset_t block, pause_mask; + struct sigaction s; +#ifdef HAVE_SETITIMER + struct itimerval interval; +#endif + + /* block SIGALRM */ + sigemptyset( &block ); + sigaddset ( &block, SIGALRM ); + sigprocmask( SIG_BLOCK, &block, &pause_mask ); + + /* setup handler */ + sigemptyset( &s.sa_mask ); + sigaddset ( &s.sa_mask, SIGALRM ); + s.sa_flags = 0; + s.sa_handler = usb_LampTimerIrq; + + if( sigaction( SIGALRM, &s, NULL ) < 0 ) + DBG( _DBG_ERROR, "Can't setup timer-irq handler\n" ); + + sigprocmask( SIG_UNBLOCK, &block, &pause_mask ); + +#ifdef HAVE_SETITIMER + /* + * define a one-shot timer + */ + interval.it_value.tv_usec = 0; + interval.it_value.tv_sec = dev->adj.lampOff; + interval.it_interval.tv_usec = 0; + interval.it_interval.tv_sec = 0; + + if( 0 != dev->adj.lampOff ) { + dev_xxx = dev; + setitimer( ITIMER_REAL, &interval, &dev->saveSettings ); + DBG( _DBG_INFO, "Lamp-Timer started (using ITIMER)\n" ); + } +#else + if( 0 != dev->adj.lampOff ) { + dev_xxx = dev; + alarm( dev->adj.lampOff ); + DBG( _DBG_INFO, "Lamp-Timer started (using ALARM)\n" ); + } +#endif +} + +/** + */ +static void u12hw_StopLampTimer( U12_Device *dev ) +{ + sigset_t block, pause_mask; + + /* block SIGALRM */ + sigemptyset( &block ); + sigaddset ( &block, SIGALRM ); + sigprocmask( SIG_BLOCK, &block, &pause_mask ); + + dev_xxx = NULL; + +#ifdef HAVE_SETITIMER + if( 0 != dev->adj.lampOff ) + setitimer( ITIMER_REAL, &dev->saveSettings, NULL ); +#else + _VAR_NOT_USED( dev ); + alarm( 0 ); +#endif + DBG( _DBG_INFO, "Lamp-Timer stopped\n" ); +} + +/* END U12-HW.C .............................................................*/ |