mirror
/
sane-project-backends
kopia lustrzana https://gitlab.com/sane-project/backends
1
0
Forkuj 0
Kod Zgłoszenia Projekty Wydania Wiki Aktywność
sane-project-backends/backend/u12-io.c

852 wiersze
20 KiB
C
Czysty Wina Historia

/** @file u12-io.c
* @brief The I/O functions to the U12 backend stuff.
*
* Copyright (c) 2003-2004 Gerhard Jaeger <gerhard@gjaeger.de>
* GeneSys Logic I/O stuff derived from canon630u-common.c which has
* been written by Nathan Rutman <nathan@gordian.com>
*
* History:
* - 0.01 - initial version
* - 0.02 - changed u12io_GetFifoLength() behaviour
* - added delays to reset function
* .
* <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>
*/
/** Format:
* cacheLen[0] = ASIC-ID
* cacheLen[1] = SCANSTATE ?
* cacheLen[2] = REG-STATUS ?
* cacheLen[3] = ??
* cacheLen[4] = FIFO-LEN (RED) HiByte LW
* cacheLen[5] = FIFO-LEN (RED) LoByte LW
* cacheLen[6] = FIFO-LEN (RED) LoByte HW
* cacheLen[7] = FIFO-LEN (GREEN) HiByte LW
* cacheLen[8] = FIFO-LEN (GREEN) LoByte LW
* cacheLen[9] = FIFO-LEN (GREEN) LoByte HW
* cacheLen[10] = FIFO-LEN (BLUE) HiByte LW
* cacheLen[11] = FIFO-LEN (BLUE) LoByte LW
* cacheLen[12] = FIFO-LEN (BLUE) LoByte HW
*/
static SANE_Byte cacheLen[13];
/** This function is used to detect a cancel condition,
* our ESC key is the SIGUSR1 signal. It is sent by the backend when the
* cancel button has been pressed
*
* @param - none
* @return the function returns SANE_TRUE if a cancel condition has been
* detected, if not, it returns SANE_FALSE
*/
static SANE_Bool u12io_IsEscPressed( void )
{
sigset_t sigs;
sigpending( &sigs );
if( sigismember( &sigs, SIGUSR1 )) {
DBG( _DBG_INFO, "SIGUSR1 is pending --> Cancel detected\n" );
return SANE_TRUE;
}
return SANE_FALSE;
}
/** fall asleep for some micro-seconds...
*/
static void u12io_udelay( unsigned long usec )
{
struct timeval now, deadline;
if( usec == 0 )
return;
gettimeofday( &deadline, NULL );
deadline.tv_usec += usec;
deadline.tv_sec += deadline.tv_usec / 1000000;
deadline.tv_usec %= 1000000;
do {
gettimeofday( &now, NULL );
} while ((now.tv_sec < deadline.tv_sec) ||
(now.tv_sec == deadline.tv_sec && now.tv_usec < deadline.tv_usec));
}
/** Initializes a timer.
* @param timer - pointer to the timer to start
* @param us - timeout value in micro-seconds
*/
static void u12io_StartTimer( TimerDef *timer , unsigned long us )
{
struct timeval start_time;
gettimeofday( &start_time, NULL );
*timer = start_time.tv_sec * 1e6 + start_time.tv_usec + us;
}
/** Checks if a timer has been expired or not.
* @param timer - pointer to the timer to check
* @return Function returns SANE_TRUE when the timer has been expired,
* otherwise SANE_FALSE
*/
static SANE_Bool u12io_CheckTimer( TimerDef *timer )
{
struct timeval current_time;
gettimeofday(&current_time, NULL);
if((current_time.tv_sec * 1e6 + current_time.tv_usec) > *timer )
return SANE_TRUE;
return SANE_FALSE;
}
/* GL640 communication functions for Genesys Logic GL640USB
* USB-IEEE1284 parallel port bridge
*/
/* Assign status and verify a good return code */
#define CHK(A) {if( (status = A) != SANE_STATUS_GOOD ) { \
DBG( _DBG_ERROR, "Failure on line of %s: %d\n", __FILE__, \
__LINE__ ); return A; }}
/** Register codes for the bridge. These are NOT the registers for the ASIC
* on the other side of the bridge.
*/
typedef enum
{
GL640_BULK_SETUP = 0x82,
GL640_EPP_ADDR = 0x83,
GL640_EPP_DATA_READ = 0x84,
GL640_EPP_DATA_WRITE = 0x85,
GL640_SPP_STATUS = 0x86,
GL640_SPP_CONTROL = 0x87,
GL640_SPP_DATA = 0x88,
GL640_GPIO_OE = 0x89,
GL640_GPIO_READ = 0x8a,
GL640_GPIO_WRITE = 0x8b
} GL640_Request;
/** for setting up bulk transfers */
static SANE_Byte bulk_setup_data[] = { 0, 0x11, 0, 0, 0, 0, 0, 0 };
/** Write to the usb-parallel port bridge.
*/
static SANE_Status
gl640WriteControl(int fd, GL640_Request req, u_char * data, unsigned int size)
{
SANE_Status status;
status = sanei_usb_control_msg( fd,
/* rqttype */ USB_TYPE_VENDOR |
USB_RECIP_DEVICE | USB_DIR_OUT /*0x40 */ ,
/* rqt */ (size > 1) ? 0x04 : 0x0C,
/* val */ (SANE_Int) req,
/* ind */ 0,
/* len */ size,
/* dat */ data);
if( status != SANE_STATUS_GOOD ) {
DBG( _DBG_ERROR, "gl640WriteControl error\n");
}
return status;
}
/** Read from the usb-parallel port bridge.
*/
static SANE_Status
gl640ReadControl( int fd, GL640_Request req, u_char *data, unsigned int size )
{
SANE_Status status;
status = sanei_usb_control_msg( fd,
/* rqttype */ USB_TYPE_VENDOR |
USB_RECIP_DEVICE | USB_DIR_IN /*0xc0 */ ,
/* rqt */ (size > 1) ? 0x04 : 0x0C,
/* val */ (SANE_Int) req,
/* ind */ 0,
/* len */ size,
/* dat */ data);
if( status != SANE_STATUS_GOOD ) {
DBG( _DBG_ERROR, "gl640ReadControl error\n");
}
return status;
}
/** Wrappers to write a single byte to the bridge */
static inline SANE_Status
gl640WriteReq( int fd, GL640_Request req, u_char data )
{
return gl640WriteControl( fd, req, &data, 1);
}
/** Wrappers to read a single byte from the bridge */
static inline SANE_Status
gl640ReadReq( int fd, GL640_Request req, u_char *data )
{
return gl640ReadControl( fd, req, data, 1 );
}
/** Write USB bulk data
* setup is an apparently scanner-specific sequence:
* {(0=read, 1=write), 0x00, 0x00, 0x00, sizelo, sizehi, 0x00, 0x00}
* setup[1] = 0x11 --> data to register
* setup[1] = 0x01 --> data to scanner memory
*/
static SANE_Status
gl640WriteBulk( int fd, u_char *setup, u_char *data, size_t size )
{
SANE_Status status;
setup[0] = 1;
setup[4] = (size) & 0xFF;
setup[5] = (size >> 8) & 0xFF;
setup[6] = 0;
CHK (gl640WriteControl (fd, GL640_BULK_SETUP, setup, 8));
status = sanei_usb_write_bulk (fd, data, &size);
if( status != SANE_STATUS_GOOD ) {
DBG( _DBG_ERROR, "gl640WriteBulk error\n");
}
return status;
}
/** Read USB bulk data
* setup is an apparently scanner-specific sequence:
* {(0=read, 1=write), 0x00, 0x00, 0x00, sizelo, sizehi, 0x00, 0x00}
* setup[1] = 0x00 --> data from scanner memory
* setup[1] = 0x0c --> data from scanner fifo?
*/
static SANE_Status
gl640ReadBulk( int fd, u_char *setup, u_char *data, size_t size, int mod )
{
SANE_Byte *len_info;
size_t complete, current, toget;
SANE_Status status;
setup[0] = 0;
setup[4] = (size) & 0xFF;
setup[5] = (size >> 8) & 0xFF;
setup[6] = mod;
CHK (gl640WriteControl (fd, GL640_BULK_SETUP, setup, 8));
len_info = NULL;
toget = size;
if( mod ) {
toget *= mod;
len_info = data + toget;
toget += 13;
}
for( complete = 0; complete < toget; ) {
current = toget - complete;
status = sanei_usb_read_bulk( fd, data, &current );
if( status != SANE_STATUS_GOOD ) {
DBG( _DBG_ERROR, "gl640ReadBulk error\n");
break;
}
data += current;
complete += current;
}
if( len_info ) {
memcpy( cacheLen, len_info, 13 );
}
return status;
}
/* now the functions to access PP registers */
/** read the contents of the status register */
static SANE_Byte
inb_status( int fd )
{
u_char data = 0xff;
gl640ReadReq( fd, GL640_SPP_STATUS, &data );
return data;
}
/** write a byte to the SPP data port */
static SANE_Status
outb_data( int fd, u_char data )
{
return gl640WriteReq( fd, GL640_SPP_DATA, data);
}
/** write to the parport control register */
static SANE_Status
outb_ctrl( int fd, u_char data )
{
return gl640WriteReq( fd, GL640_SPP_CONTROL, data);
}
/************************* ASIC access stuff *********************************/
/** write a register number to the ASIC
*/
static void u12io_RegisterToScanner( U12_Device *dev, SANE_Byte reg )
{
if( dev->mode == _PP_MODE_EPP ) {
gl640WriteReq( dev->fd, GL640_EPP_ADDR, reg );
} else {
/* write register number to read from to SPP data-port
*/
outb_data( dev->fd, reg );
/* signal that to the ASIC */
outb_ctrl( dev->fd, _CTRL_SIGNAL_REGWRITE );
_DODELAY(20);
outb_ctrl( dev->fd, _CTRL_END_REGWRITE );
}
}
/** as the name says, we switch to SPP mode
*/
static void u12io_SwitchToSPPMode( U12_Device *dev )
{
dev->mode = _PP_MODE_SPP;
outb_ctrl( dev->fd, _CTRL_GENSIGNAL );
}
/** as the name says, we switch to SPP mode
*/
static void u12io_SwitchToEPPMode( U12_Device *dev )
{
u12io_RegisterToScanner( dev, REG_EPPENABLE );
dev->mode = _PP_MODE_EPP;
}
/** read data from SPP status port
*/
static SANE_Byte u12io_DataFromSPP( U12_Device *dev )
{
SANE_Byte data, tmp;
/* read low nibble */
tmp = inb_status( dev->fd );
outb_ctrl( dev->fd, (_CTRL_GENSIGNAL + _CTRL_STROBE));
/* read high nibble */
data = inb_status( dev->fd );
data &= 0xf0;
/* combine with low nibble */
data |= (tmp >> 4);
return data;
}
/** Read the content of specific ASIC register
*/
static SANE_Byte u12io_DataFromRegister( U12_Device *dev, SANE_Byte reg )
{
SANE_Byte val;
if( dev->mode == _PP_MODE_EPP ) {
gl640WriteReq( dev->fd, GL640_EPP_ADDR, reg );
gl640ReadReq ( dev->fd, GL640_EPP_DATA_READ, &val );
} else {
u12io_RegisterToScanner( dev, reg );
val = u12io_DataFromSPP( dev );
}
return val;
}
/**
*/
static void u12io_CloseScanPath( U12_Device *dev )
{
DBG( _DBG_INFO, "u12io_CloseScanPath()\n" );
/* FIXME: Probaly not needed */
#if 0
u12io_RegisterToScanner( dev, 0xff );
#endif
u12io_RegisterToScanner( dev, REG_SWITCHBUS );
dev->mode = _PP_MODE_SPP;
}
/** try to connect to scanner
*/
static SANE_Bool u12io_OpenScanPath( U12_Device *dev )
{
u_char tmp;
DBG( _DBG_INFO, "u12io_OpenScanPath()\n" );
u12io_SwitchToSPPMode( dev );
outb_data( dev->fd, _ID_TO_PRINTER );
_DODELAY(20);
outb_data( dev->fd, _ID1ST );
_DODELAY(5);
outb_data( dev->fd, _ID2ND );
_DODELAY(5);
outb_data( dev->fd, _ID3RD );
_DODELAY(5);
outb_data( dev->fd, _ID4TH );
_DODELAY(5);
tmp = u12io_DataFromRegister( dev, REG_ASICID );
if( ASIC_ID == tmp ) {
u12io_SwitchToEPPMode( dev );
return SANE_TRUE;
}
DBG( _DBG_ERROR, "u12io_OpenScanPath() failed!\n" );
return SANE_FALSE;
}
/** Write data to asic (SPP mode only)
*/
static void u12io_DataToScanner( U12_Device *dev , SANE_Byte bValue )
{
if( dev->mode != _PP_MODE_SPP ) {
DBG( _DBG_ERROR, "u12io_DataToScanner() in wrong mode!\n" );
return;
}
/* output data */
outb_data( dev->fd, bValue );
/* notify asic there is data */
outb_ctrl( dev->fd, _CTRL_SIGNAL_DATAWRITE );
/* end write cycle */
outb_ctrl( dev->fd, _CTRL_END_DATAWRITE );
}
/** Write data to specific ASIC's register
*/
static SANE_Status u12io_DataToRegister( U12_Device *dev,
SANE_Byte reg, SANE_Byte data )
{
SANE_Status status;
SANE_Byte buf[2];
if( dev->mode == _PP_MODE_EPP ) {
buf[0] = reg;
buf[1] = data;
bulk_setup_data[1] = 0x11;
CHK( gl640WriteBulk ( dev->fd, bulk_setup_data, buf, 2 ));
} else {
u12io_RegisterToScanner( dev, reg );
u12io_DataToScanner( dev, data );
}
return SANE_STATUS_GOOD;
}
/** Write data-buffer to specific ASIC's register
* The format in the buffer is
* reg(0),val(0),reg(1),val(1),..., reg(len-1),val(len-1)
*/
static SANE_Status u12io_DataToRegs( U12_Device *dev, SANE_Byte *buf, int len )
{
SANE_Status status;
if( dev->mode != _PP_MODE_EPP ) {
DBG( _DBG_ERROR, "u12io_DataToRegs() in wrong mode!\n" );
return SANE_STATUS_IO_ERROR;
}
bulk_setup_data[1] = 0x11;
CHK( gl640WriteBulk ( dev->fd, bulk_setup_data, buf, len*2 ));
return SANE_STATUS_GOOD;
}
/** write data to the DAC
*/
static void
u12io_DataRegisterToDAC( U12_Device *dev, SANE_Byte reg, SANE_Byte val )
{
SANE_Byte buf[6];
buf[0] = REG_ADCADDR;
buf[1] = reg;
buf[2] = REG_ADCDATA;
buf[3] = val;
buf[4] = REG_ADCSERIALOUT;
buf[5] = val;
u12io_DataToRegs( dev, buf, 3 );
}
/** write data block to scanner
*/
static SANE_Status u12io_MoveDataToScanner( U12_Device *dev,
SANE_Byte *buf, int len )
{
SANE_Status status;
/* u12io_RegisterToScanner( dev, REG_INITDATAFIFO ); */
u12io_RegisterToScanner( dev, REG_WRITEDATAMODE );
bulk_setup_data[1] = 0x01;
CHK( gl640WriteBulk( dev->fd, bulk_setup_data, buf, len ));
bulk_setup_data[1] = 0x11;
return SANE_STATUS_GOOD;
}
static SANE_Status u12io_ReadData( U12_Device *dev, SANE_Byte *buf, int len )
{
SANE_Status status;
u12io_DataToRegister( dev, REG_MODECONTROL, dev->regs.RD_ModeControl );
/* u12io_RegisterToScanner( dev, REG_INITDATAFIFO ); */
u12io_RegisterToScanner( dev, REG_READDATAMODE );
bulk_setup_data[1] = 0x00;
CHK (gl640ReadBulk( dev->fd, bulk_setup_data, buf, len, 0 ));
bulk_setup_data[1] = 0x11;
return SANE_STATUS_GOOD;
}
/** perform a SW reset of ASIC P98003
*/
static void u12io_SoftwareReset( U12_Device *dev )
{
DBG( _DBG_INFO, "Device reset (%i)!!!\n", dev->fd );
u12io_DataToRegister( dev, REG_TESTMODE, _SW_TESTMODE );
outb_data( dev->fd, _ID_TO_PRINTER );
_DODELAY(20);
outb_data( dev->fd, _RESET1ST );
_DODELAY(5);
outb_data( dev->fd, _RESET2ND );
_DODELAY(5);
outb_data( dev->fd, _RESET3RD );
_DODELAY(5);
outb_data( dev->fd, _RESET4TH );
_DODELAY(250);
}
/**
*/
static SANE_Bool u12io_IsConnected( U12_Device *dev )
{
int c, mode;
SANE_Byte tmp, rb[6];
DBG( _DBG_INFO, "u12io_IsConnected()\n" );
tmp = inb_status( dev->fd );
DBG( _DBG_INFO, "* tmp1 = 0x%02x\n", tmp );
gl640WriteReq( dev->fd, GL640_EPP_ADDR, REG_ASICID );
gl640ReadReq ( dev->fd, GL640_EPP_DATA_READ, &tmp );
DBG( _DBG_INFO, "* REG_ASICID = 0x%02x\n", tmp );
if( tmp != ASIC_ID ) {
DBG( _DBG_INFO, "* Scanner is NOT connected!\n" );
tmp = inb_status( dev->fd );
DBG( _DBG_INFO, "* tmp2 = 0x%02x\n", tmp );
gl640WriteReq( dev->fd, GL640_EPP_ADDR, REG_ASICID );
gl640ReadReq ( dev->fd, GL640_EPP_DATA_READ, &tmp );
DBG( _DBG_INFO, "* REG_ASICID = 0x%02x\n", tmp );
if( tmp == 0x02 ) {
mode = dev->mode;
dev->mode = _PP_MODE_EPP;
u12io_DataToRegister( dev, REG_ADCADDR, 0x01 );
u12io_DataToRegister( dev, REG_ADCDATA, 0x00 );
u12io_DataToRegister( dev, REG_ADCSERIALOUT, 0x00 );
c = 0;
_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 );
dev->mode = mode ;
}
return SANE_FALSE;
}
u12io_SwitchToEPPMode( dev );
DBG( _DBG_INFO, "* Scanner is connected!\n" );
return SANE_TRUE;
}
/**
*/
static SANE_Byte u12io_GetExtendedStatus( U12_Device *dev )
{
SANE_Byte b;
b = u12io_DataFromRegister( dev, REG_STATUS2 );
if( b == 0xff )
return 0;
return b;
}
/**
*/
static SANE_Status u12io_ReadMonoData( U12_Device *dev, SANE_Byte *buf, u_long len )
{
SANE_Status status;
bulk_setup_data[1] = 0x0c;
bulk_setup_data[2] = ((dev->regs.RD_ModeControl >> 3) + 1);
CHK (gl640ReadBulk( dev->fd, bulk_setup_data, buf, len, 1 ));
bulk_setup_data[1] = 0x11;
bulk_setup_data[2] = 0;
return SANE_STATUS_GOOD;
}
/**
*/
static SANE_Status
u12io_ReadColorData( U12_Device *dev, SANE_Byte *buf, u_long len )
{
SANE_Status status;
bulk_setup_data[1] = 0x0c;
CHK (gl640ReadBulk( dev->fd, bulk_setup_data, buf, len, 3 ));
bulk_setup_data[1] = 0x11;
return SANE_STATUS_GOOD;
}
/** read the recent state count
*/
static SANE_Byte u12io_GetScanState( U12_Device *dev )
{
if( cacheLen[0] == 0x83 ) {
DBG( _DBG_READ, "u12io_GetScanState(cached) = 0x%02x\n", cacheLen[1] );
return cacheLen[1];
}
return u12io_DataFromRegister( dev, REG_GETSCANSTATE );
}
/** download a scanstate-table
*/
static SANE_Status u12io_DownloadScanStates( U12_Device *dev )
{
SANE_Status status;
TimerDef timer;
u12io_RegisterToScanner( dev, REG_SCANSTATECONTROL );
bulk_setup_data[1] = 0x01;
CHK( gl640WriteBulk( dev->fd, bulk_setup_data,
dev->scanStates, _SCANSTATE_BYTES ));
bulk_setup_data[1] = 0x11;
/* FIXME: refreshState probably always FALSE */
if( dev->scan.refreshState ) {
u12io_RegisterToScanner( dev, REG_REFRESHSCANSTATE );
u12io_StartTimer( &timer, (_SECOND/2));
do {
if (!( u12io_GetScanState( dev ) & _SCANSTATE_STOP))
break;
}
while( !u12io_CheckTimer(&timer));
}
return SANE_STATUS_GOOD;
}
/** - initializes the scan states
* - sets all necessary registers
* FIXME: first copy to buffer, then use u12io_DataToRegs()
*/
static void u12io_PutOnAllRegisters( U12_Device *dev )
{
SANE_Byte *val, reg;
SANE_Byte *rb, buf[100];
int c;
/* setup scan states */
u12io_DownloadScanStates( dev );
c = 0;
rb = buf;
*(rb++) = REG_MODECONTROL;
*(rb++) = dev->regs.RD_ModeControl;
c++;
*(rb++) = REG_STEPCONTROL;
*(rb++) = dev->regs.RD_StepControl;
c++;
*(rb++) = REG_MOTOR0CONTROL;
*(rb++) = dev->regs.RD_Motor0Control;
c++;
*(rb++) = REG_LINECONTROL;
*(rb++) = dev->regs.RD_LineControl;
c++;
*(rb++) = REG_XSTEPTIME;
*(rb++) = dev->regs.RD_XStepTime;
c++;
*(rb++) = REG_MODELCONTROL;
*(rb++) = dev->regs.RD_ModelControl;
c++;
/* the 1st register to write */
val = (SANE_Byte*)&dev->regs.RD_Dpi;
/* 0x21 - 0x28 */
for( reg = REG_DPILO; reg <= REG_THRESHOLDHI; reg++, val++ ) {
*(rb++) = reg;
*(rb++) = *val;
c++;
}
u12io_DataToRegs( dev, buf, c );
u12io_RegisterToScanner( dev, REG_INITDATAFIFO );
u12io_DataToRegister( dev, REG_MODECONTROL, _ModeScan );
}
/**
*/
static void u12io_ResetFifoLen( void )
{
memset( cacheLen, 0, 13 );
}
/**
*/
static u_long u12io_GetFifoLength( U12_Device *dev )
{
SANE_Status status;
size_t toget;
SANE_Byte data[64];
u_long len, len_r, len_g, len_b;
if( cacheLen[0] == 0x83 ) {
DBG( _DBG_READ, "Using cached FIFO len\n" );
memcpy( data, cacheLen, 13 );
u12io_ResetFifoLen();
} else {
memset( bulk_setup_data, 0, 8 );
bulk_setup_data[1] = 0x0c;
CHK (gl640WriteControl(dev->fd, GL640_BULK_SETUP, bulk_setup_data, 8));
toget = 13;
status = sanei_usb_read_bulk( dev->fd, data, &toget );
if( status != SANE_STATUS_GOOD ) {
DBG( _DBG_ERROR, "ReadBulk error\n");
return SANE_FALSE;
}
bulk_setup_data[1] = 0x11;
memcpy( cacheLen, data, 13 );
}
len_r = (u_long)data[5] * 256 + (u_long)data[4];
len_g = (u_long)data[8] * 256 + (u_long)data[7];
len_b = (u_long)data[11] * 256 + (u_long)data[10];
if( dev->DataInf.wPhyDataType < COLOR_TRUE24 ) {
len = len_g;
} else {
len = len_r;
if( len_g < len )
len = len_g;
if( len_b < len )
len = len_b;
}
DBG( _DBG_READ, "FIFO-LEN: %lu %lu %lu = %lu\n", len_r, len_g, len_b, len );
return len;
}
/**
*/
static SANE_Bool
u12io_ReadOneShadingLine( U12_Device *dev, SANE_Byte *buf, u_long len )
{
TimerDef timer;
SANE_Status status;
DBG( _DBG_READ, "u12io_ReadOneShadingLine()\n" );
u12io_StartTimer( &timer, _SECOND );
dev->scan.bFifoSelect = REG_GFIFOOFFSET;
do {
u12io_ResetFifoLen();
if( u12io_GetFifoLength( dev ) >= dev->regs.RD_Pixels ) {
status = u12io_ReadColorData( dev, buf, len );
if( status != SANE_STATUS_GOOD ) {
DBG( _DBG_ERROR, "ReadColorData error\n");
return SANE_FALSE;
}
DBG( _DBG_READ, "* done\n" );
return SANE_TRUE;
}
} while( !u12io_CheckTimer( &timer ));
DBG( _DBG_ERROR, "u12io_ReadOneShadingLine() failed!\n" );
return SANE_FALSE;
}
/* END U12-IO.C .............................................................*/
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik