/** @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, see <https://www.gnu.org/licenses/>.
 *
 * 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: Probably 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 .............................................................*/