kopia lustrzana https://gitlab.com/sane-project/backends
601 wiersze
15 KiB
C
601 wiersze
15 KiB
C
/** @file u12-if.c
|
|
* @brief The interface functions to the U12 backend stuff.
|
|
*
|
|
* Copyright (c) 2003-2004 Gerhard Jaeger <gerhard@gjaeger.de>
|
|
*
|
|
* History:
|
|
* - 0.01 - initial version
|
|
* - 0.02 - added model tweaking
|
|
* - fixed autodetection bug
|
|
* - added line-scaling stuff
|
|
* - removed u12if_setScanEnv()
|
|
* .
|
|
* <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>
|
|
*/
|
|
|
|
#define _DEF_BRIGHTEST_SKIP 3
|
|
#define _DEF_DARKEST_SKIP 5
|
|
|
|
/** useful for description tables
|
|
*/
|
|
typedef struct {
|
|
int id;
|
|
char *desc;
|
|
} TabDef;
|
|
|
|
typedef struct {
|
|
char *vp;
|
|
char *name;
|
|
} DevDesc;
|
|
|
|
#define _PLUSTEK_VENID 0x07B3
|
|
#define _KYE_VENID 0x0458
|
|
|
|
/** to allow different vendors...
|
|
*/
|
|
static TabDef u12Vendors[] = {
|
|
|
|
{ _PLUSTEK_VENID, "Plustek" },
|
|
{ _KYE_VENID, "KYE/Genius" },
|
|
{ 0xFFFF, NULL }
|
|
};
|
|
|
|
/** list of supported devices
|
|
*/
|
|
static DevDesc u12Devices[] = {
|
|
{ "0x07B3-0x0001", "1212U/U12" },
|
|
{ "0x0458-0x2004", "Colorpage HR6" },
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
/** for autodetection */
|
|
static SANE_Char USB_devname[1024];
|
|
|
|
/********************** the USB scanner interface ****************************/
|
|
|
|
/**
|
|
*/
|
|
static SANE_Status u12_initDev( U12_Device *dev, int handle, int vendor )
|
|
{
|
|
int i;
|
|
SANE_Status res;
|
|
TimerDef timer;
|
|
|
|
/* well now we patch the vendor string...
|
|
* if not found, the default vendor will be Plustek
|
|
*/
|
|
for( i = 0; u12Vendors[i].desc != NULL; i++ ) {
|
|
|
|
if( u12Vendors[i].id == vendor ) {
|
|
dev->sane.vendor = u12Vendors[i].desc;
|
|
DBG( _DBG_INFO, "Vendor adjusted to: >%s<\n", dev->sane.vendor );
|
|
break;
|
|
}
|
|
}
|
|
dev->fd = handle;
|
|
|
|
dev->adj.upNormal = 0;
|
|
dev->adj.upNegative = 20;
|
|
dev->adj.upPositive = -30;
|
|
dev->adj.leftNormal = 51;
|
|
|
|
res = SANE_STATUS_IO_ERROR;
|
|
if( !(u12io_DataFromRegister( dev, REG_STATUS ) & _FLAG_PAPER)) {
|
|
|
|
u12motor_PositionModuleToHome( dev );
|
|
|
|
u12io_StartTimer( &timer, _SECOND * 20);
|
|
do {
|
|
if( u12io_DataFromRegister( dev, REG_STATUS ) & _FLAG_PAPER) {
|
|
res = SANE_STATUS_GOOD;
|
|
break;
|
|
}
|
|
} while( !u12io_CheckTimer( &timer ));
|
|
} else {
|
|
res = u12hw_InitAsic( dev, SANE_FALSE );
|
|
}
|
|
|
|
if( res == SANE_STATUS_GOOD )
|
|
u12hw_PutToIdleMode( dev );
|
|
return res;
|
|
}
|
|
|
|
/** will be called upon sane_exit
|
|
*/
|
|
static void u12if_shutdown( U12_Device *dev )
|
|
{
|
|
SANE_Int handle;
|
|
TimerDef timer;
|
|
|
|
DBG( _DBG_INFO, "Shutdown called (dev->fd=%d, %s)\n",
|
|
dev->fd, dev->sane.name );
|
|
if( SANE_STATUS_GOOD == sanei_usb_open( dev->sane.name, &handle )) {
|
|
|
|
dev->fd = handle;
|
|
u12io_OpenScanPath( dev );
|
|
|
|
u12hw_PutToIdleMode( dev );
|
|
|
|
if( !(u12io_DataFromRegister( dev, REG_STATUS ) & _FLAG_PAPER)) {
|
|
|
|
u12motor_PositionModuleToHome( dev );
|
|
|
|
u12io_StartTimer( &timer, _SECOND * 20);
|
|
do {
|
|
if( u12io_DataFromRegister( dev, REG_STATUS ) & _FLAG_PAPER) {
|
|
break;
|
|
}
|
|
} while( !u12io_CheckTimer( &timer ));
|
|
}
|
|
DBG( _DBG_INFO, "* Home position reached.\n" );
|
|
|
|
if( 0 != dev->adj.lampOffOnEnd ) {
|
|
|
|
DBG( _DBG_INFO, "* Switching lamp off...\n" );
|
|
dev->regs.RD_ScanControl &= ~_SCAN_LAMPS_ON;
|
|
u12io_DataToRegister(dev,REG_SCANCONTROL, dev->regs.RD_ScanControl );
|
|
}
|
|
|
|
u12io_CloseScanPath( dev );
|
|
dev->fd = -1;
|
|
sanei_usb_close( handle );
|
|
}
|
|
|
|
#if 0
|
|
usb_StopLampTimer( dev );
|
|
#endif
|
|
DBG( _DBG_INFO, "Shutdown done.\n" );
|
|
}
|
|
|
|
/** This function checks whether a device, described by a given
|
|
* string(vendor and product ID), is supported by this backend or not
|
|
*
|
|
* @param usbIdStr - string consisting out of product and vendor ID
|
|
* format: "0xVVVV-0xPPPP" VVVV = Vendor ID, PPP = Product ID
|
|
* @returns; SANE_TRUE if supported, SANE_FALSE if not
|
|
*/
|
|
static SANE_Bool u12if_IsDeviceSupported( U12_Device *dev )
|
|
{
|
|
int i;
|
|
|
|
for( i = 0; NULL != u12Devices[i].name; i++ ) {
|
|
|
|
if( !strcmp( dev->usbId, u12Devices[i].vp )) {
|
|
dev->sane.model = u12Devices[i].name;
|
|
return SANE_TRUE;
|
|
}
|
|
}
|
|
|
|
return SANE_FALSE;
|
|
}
|
|
|
|
/**
|
|
*/
|
|
static SANE_Status u12if_usbattach( SANE_String_Const dev_name )
|
|
{
|
|
if( USB_devname[0] == '\0' ) {
|
|
DBG( _DBG_INFO, "Found device at >%s<\n", dev_name );
|
|
strncpy( USB_devname, dev_name, 1023 );
|
|
USB_devname[1023] = '\0';
|
|
} else {
|
|
DBG( _DBG_INFO, "Device >%s< ignoring\n", dev_name );
|
|
}
|
|
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
#ifndef _FAKE_DEVICE
|
|
/** here we roam through our list of supported devices and
|
|
* cross check with the ones the system reports...
|
|
* @param vendor - pointer to receive vendor ID
|
|
* @param product - pointer to receive product ID
|
|
* @return SANE_TRUE if a matching device has been found or
|
|
* SANE_FALSE if nothing supported found...
|
|
*/
|
|
static SANE_Bool usbDev_autodetect( SANE_Word *vendor, SANE_Word *product )
|
|
{
|
|
int i;
|
|
SANE_Word p, v;
|
|
|
|
DBG( _DBG_INFO, "Autodetection...\n" );
|
|
|
|
for( i = 0; NULL != u12Devices[i].name; i++ ) {
|
|
|
|
v = strtol( &(u12Devices[i].vp)[0], 0, 0 );
|
|
p = strtol( &(u12Devices[i].vp)[7], 0, 0 );
|
|
DBG( _DBG_INFO, "* checking for 0x%04x-0x%04x\n", v, p );
|
|
|
|
sanei_usb_find_devices( v, p, u12if_usbattach );
|
|
|
|
if( USB_devname[0] != '\0' ) {
|
|
|
|
*vendor = v;
|
|
*product = p;
|
|
DBG( _DBG_INFO, "* using device >%s<\n", USB_devname );
|
|
return SANE_TRUE;
|
|
}
|
|
}
|
|
|
|
return SANE_FALSE;
|
|
}
|
|
#endif
|
|
|
|
/**
|
|
*/
|
|
static int u12if_open( U12_Device *dev )
|
|
{
|
|
char devStr[50];
|
|
int result;
|
|
SANE_Int handle;
|
|
SANE_Word vendor, product;
|
|
SANE_Bool was_empty;
|
|
|
|
DBG( _DBG_INFO, "u12if_open(%s,%s)\n", dev->name, dev->usbId );
|
|
|
|
USB_devname[0] = '\0';
|
|
|
|
#ifdef _FAKE_DEVICE
|
|
dev->name = strdup( "auto" );
|
|
dev->sane.name = dev->name;
|
|
was_empty = SANE_FALSE;
|
|
|
|
result = SANE_STATUS_UNSUPPORTED;
|
|
#else
|
|
if( !strcmp( dev->name, "auto" )) {
|
|
|
|
if( dev->usbId[0] == '\0' ) {
|
|
|
|
if( !usbDev_autodetect( &vendor, &product )) {
|
|
DBG( _DBG_ERROR, "No supported device found!\n" );
|
|
return -1;
|
|
}
|
|
|
|
} else {
|
|
|
|
vendor = strtol( &dev->usbId[0], 0, 0 );
|
|
product = strtol( &dev->usbId[7], 0, 0 );
|
|
|
|
sanei_usb_find_devices( vendor, product, u12if_usbattach );
|
|
|
|
if( USB_devname[0] == '\0' ) {
|
|
DBG( _DBG_ERROR, "No matching device found!\n" );
|
|
return -1;
|
|
}
|
|
}
|
|
|
|
if( SANE_STATUS_GOOD != sanei_usb_open( USB_devname, &handle )) {
|
|
return -1;
|
|
}
|
|
|
|
/* replace the old devname, so we are able to have multiple
|
|
* auto-detected devices
|
|
*/
|
|
free( dev->name );
|
|
dev->name = strdup( USB_devname );
|
|
dev->sane.name = dev->name;
|
|
|
|
} else {
|
|
|
|
if( SANE_STATUS_GOOD != sanei_usb_open( dev->name, &handle ))
|
|
return -1;
|
|
}
|
|
was_empty = SANE_FALSE;
|
|
|
|
result = sanei_usb_get_vendor_product( handle, &vendor, &product );
|
|
#endif
|
|
|
|
if( SANE_STATUS_GOOD == result ) {
|
|
|
|
sprintf( devStr, "0x%04X-0x%04X", vendor, product );
|
|
|
|
DBG(_DBG_INFO,"Vendor ID=0x%04X, Product ID=0x%04X\n",vendor,product);
|
|
|
|
if( dev->usbId[0] != '\0' ) {
|
|
|
|
if( 0 != strcmp( dev->usbId, devStr )) {
|
|
DBG( _DBG_ERROR, "Specified Vendor and Product ID "
|
|
"doesn't match with the ones\n"
|
|
"in the config file\n" );
|
|
sanei_usb_close( handle );
|
|
return -1;
|
|
}
|
|
} else {
|
|
sprintf( dev->usbId, "0x%04X-0x%04X", vendor, product );
|
|
was_empty = SANE_TRUE;
|
|
}
|
|
|
|
} else {
|
|
|
|
DBG( _DBG_INFO, "Can't get vendor & product ID from driver...\n" );
|
|
|
|
/* if the ioctl stuff is not supported by the kernel and we have
|
|
* nothing specified, we have to give up...
|
|
*/
|
|
if( dev->usbId[0] == '\0' ) {
|
|
DBG( _DBG_ERROR, "Cannot autodetect Vendor an Product ID, "
|
|
"please specify in config file.\n" );
|
|
sanei_usb_close( handle );
|
|
return -1;
|
|
}
|
|
|
|
vendor = strtol( &dev->usbId[0], 0, 0 );
|
|
product = strtol( &dev->usbId[7], 0, 0 );
|
|
DBG( _DBG_INFO, "... using the specified: "
|
|
"0x%04X-0x%04X\n", vendor, product );
|
|
}
|
|
|
|
/* before accessing the scanner, check if supported!
|
|
*/
|
|
if( !u12if_IsDeviceSupported( dev )) {
|
|
DBG( _DBG_ERROR, "Device >%s<, is not supported!\n", dev->usbId );
|
|
sanei_usb_close( handle );
|
|
return -1;
|
|
}
|
|
|
|
dev->mode = _PP_MODE_SPP;
|
|
dev->fd = handle;
|
|
|
|
/* is it accessible ? */
|
|
if( SANE_STATUS_GOOD != u12hw_CheckDevice( dev )) {
|
|
dev->fd = -1;
|
|
sanei_usb_close( handle );
|
|
return -1;
|
|
}
|
|
|
|
DBG( _DBG_INFO, "Detected vendor & product ID: "
|
|
"0x%04X-0x%04X\n", vendor, product );
|
|
|
|
if( was_empty )
|
|
dev->usbId[0] = '\0';
|
|
|
|
/* now initialize the device */
|
|
if( SANE_STATUS_GOOD != u12_initDev( dev, handle, vendor )) {
|
|
dev->fd = -1;
|
|
sanei_usb_close( handle );
|
|
return -1;
|
|
}
|
|
|
|
if( _PLUSTEK_VENID == vendor ) {
|
|
if( dev->Tpa )
|
|
dev->sane.model = "UT12";
|
|
}
|
|
|
|
dev->initialized = SANE_TRUE;
|
|
return handle;
|
|
}
|
|
|
|
/**
|
|
*/
|
|
static int u12if_close( U12_Device *dev )
|
|
{
|
|
DBG( _DBG_INFO, "u12if_close()\n" );
|
|
u12io_CloseScanPath( dev );
|
|
sanei_usb_close( dev->fd );
|
|
dev->fd = -1;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
*/
|
|
static SANE_Status u12if_getCaps( U12_Device *dev )
|
|
{
|
|
int cntr;
|
|
int res_x = 600 ; /*dev->caps.OpticDpi.x */
|
|
DBG( _DBG_INFO, "u12if_getCaps()\n" );
|
|
|
|
/* FIXME: set dpi_range.max, max_x & max_y on a per model base */
|
|
dev->dpi_max_x = 600;
|
|
dev->dpi_max_y = 1200;
|
|
|
|
/* A4 devices */
|
|
dev->max_x = 8.5 * (double)_MM_PER_INCH;
|
|
dev->max_y = 11.6934 * (double)_MM_PER_INCH;
|
|
|
|
/* limit the range */
|
|
dev->dpi_range.min = _DEF_DPI;
|
|
dev->dpi_range.max = dev->dpi_max_y;
|
|
dev->dpi_range.quant = 0;
|
|
dev->x_range.min = 0;
|
|
dev->x_range.max = SANE_FIX(dev->max_x);
|
|
dev->x_range.quant = 0;
|
|
dev->y_range.min = 0;
|
|
dev->y_range.max = SANE_FIX(dev->max_y);
|
|
dev->y_range.quant = 0;
|
|
|
|
/* calculate the size of the resolution list +
|
|
* one more to avoid a buffer overflow, then allocate it...
|
|
*/
|
|
dev->res_list = (SANE_Int *)
|
|
calloc((((res_x * 16)-_DEF_DPI)/25+1),
|
|
sizeof (SANE_Int));
|
|
|
|
if (NULL == dev->res_list) {
|
|
DBG( _DBG_ERROR, "alloc fail, resolution problem\n" );
|
|
u12if_close(dev);
|
|
return SANE_STATUS_INVAL;
|
|
}
|
|
|
|
/* build up the resolution table */
|
|
dev->res_list_size = 0;
|
|
for( cntr = _DEF_DPI; cntr <= (res_x*16); cntr += 25 ) {
|
|
dev->res_list_size++;
|
|
dev->res_list[dev->res_list_size - 1] = (SANE_Int)cntr;
|
|
}
|
|
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
/**
|
|
*/
|
|
static SANE_Status u12if_startScan( U12_Device *dev )
|
|
{
|
|
DBG( _DBG_INFO, "u12if_startScan()\n" );
|
|
u12hw_StopLampTimer( dev );
|
|
u12hw_SetGeneralRegister( dev );
|
|
u12hw_ControlLampOnOff( dev );
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
/**
|
|
*/
|
|
static SANE_Status u12if_stopScan( U12_Device *dev )
|
|
{
|
|
DBG( _DBG_INFO, "u12if_stopScan()\n" );
|
|
|
|
#if 0
|
|
u12motor_ToHomePosition( dev, SANE_FALSE );
|
|
#else
|
|
#if 0
|
|
u12motor_ToHomePosition( dev, SANE_TRUE );
|
|
u12io_SoftwareReset( dev );
|
|
#endif
|
|
u12hw_CancelSequence( dev );
|
|
#endif
|
|
u12hw_StartLampTimer( dev );
|
|
dev->DataInf.dwAppLinesPerArea = 0;
|
|
dev->DataInf.dwScanFlag &= ~_SCANDEF_SCANNING;
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
/**
|
|
*/
|
|
static SANE_Status u12if_prepare( U12_Device *dev )
|
|
{
|
|
SANE_Status res;
|
|
|
|
DBG( _DBG_INFO, "u12if_prepare()\n" );
|
|
|
|
u12motor_ToHomePosition( dev, SANE_TRUE );
|
|
|
|
res = u12hw_WarmupLamp( dev );
|
|
if( res != SANE_STATUS_GOOD )
|
|
return res;
|
|
|
|
res = u12shading_DoCalibration( dev );
|
|
if( res != SANE_STATUS_GOOD )
|
|
return res;
|
|
|
|
u12image_PrepareScaling( dev );
|
|
|
|
u12motor_ForceToLeaveHomePos( dev );
|
|
if( dev->DataInf.dwScanFlag & _SCANDEF_PREVIEW )
|
|
u12hw_SetupPreviewCondition( dev );
|
|
else
|
|
u12hw_SetupScanningCondition( dev );
|
|
|
|
res = u12motor_WaitForPositionY( dev );
|
|
|
|
_DODELAY(100);
|
|
u12io_ResetFifoLen();
|
|
u12io_GetFifoLength(dev);
|
|
|
|
dev->scan.bModuleState = _MotorAdvancing;
|
|
dev->scan.oldScanState = u12io_GetScanState( dev );
|
|
dev->scan.oldScanState &= _SCANSTATE_MASK;
|
|
dev->DataInf.dwScanFlag |= _SCANDEF_SCANNING;
|
|
DBG( _DBG_INFO, "* oldScanState = %u\n", dev->scan.oldScanState );
|
|
DBG( _DBG_INFO, "u12if_prepare() done.\n" );
|
|
return res;
|
|
}
|
|
|
|
/**
|
|
*/
|
|
static SANE_Status u12if_readLine( U12_Device *dev, SANE_Byte *line_buffer )
|
|
{
|
|
SANE_Status res;
|
|
|
|
DBG( _DBG_READ, "u12if_readLine()\n" );
|
|
|
|
if( u12io_IsEscPressed()) {
|
|
DBG( _DBG_INFO, "u12if_readLine() - cancel detected!\n" );
|
|
return SANE_STATUS_CANCELLED;
|
|
}
|
|
|
|
if( dev->scaleBuf != NULL ) {
|
|
res = u12image_ReadOneImageLine( dev, dev->scaleBuf );
|
|
if( SANE_STATUS_GOOD != res )
|
|
return res;
|
|
|
|
u12image_ScaleX( dev, dev->scaleBuf, line_buffer );
|
|
|
|
} else {
|
|
res = u12image_ReadOneImageLine( dev, line_buffer );
|
|
if( SANE_STATUS_GOOD != res )
|
|
return res;
|
|
}
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
/**
|
|
*/
|
|
static SANE_Status u12if_SetupBuffer( U12_Device *dev )
|
|
{
|
|
void *buffer;
|
|
|
|
DBG( _DBG_INFO, "u12if_SetupBuffer()\n" );
|
|
buffer = malloc(_SIZE_TOTAL_BUF_TPA);
|
|
if( buffer == NULL )
|
|
return SANE_STATUS_NO_MEM;
|
|
|
|
dev->shade.pHilight = NULL;
|
|
dev->bufs.b1.pReadBuf = buffer;
|
|
dev->bufs.b2.pSumBuf = dev->bufs.b1.pReadBuf + _SIZE_DATA_BUF;
|
|
dev->bufs.TpaBuf.pb = &((SANE_Byte*)dev->bufs.b2.pSumBuf)[_SIZE_SHADING_SUM_BUF];
|
|
|
|
/* CHECK: We might should play around with these values... */
|
|
dev->shade.skipHilight = _DEF_BRIGHTEST_SKIP;
|
|
dev->shade.skipShadow = _DEF_DARKEST_SKIP;
|
|
|
|
if( dev->shade.skipHilight && dev->shade.skipShadow ) {
|
|
|
|
u_long skipSize;
|
|
|
|
skipSize = (u_long)((dev->shade.skipHilight + dev->shade.skipShadow)
|
|
* _SIZE_DATA_BUF * 3);
|
|
dev->shade.pHilight = (RGBUShortDef*)malloc( skipSize );
|
|
if( NULL != dev->shade.pHilight ) {
|
|
dev->shade.dwDiv = (u_long)(32UL - dev->shade.skipHilight -
|
|
dev->shade.skipShadow);
|
|
}
|
|
}
|
|
return SANE_STATUS_GOOD;
|
|
}
|
|
|
|
/* END U12-IF.C .............................................................*/
|