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-if.c

601 wiersze
15 KiB
C
Czysty Wina Historia

/** @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 .............................................................*/
Reference in New Issue View Git Blame Kopiuj bezpośredni odnośnik