Initial import of sane-backends version 1.0.24-1.2

1 files changed, 851 insertions, 0 deletions

diff --git a/backend/u12-io.c b/backend/u12-io.c
new file mode 100644
index 0000000..cd65b72
--- /dev/null
+++ b/backend/u12-io.c
@@ -0,0 +1,851 @@
+/** @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 .............................................................*/