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

Merge branch 'gl843'

merge-requests/1/head
Stphane Voltz 2011-11-19 09:53:06 +01:00
rodzic c648a4411e c84445039d
commit 0e409babcc
16 zmienionych plików z 488 dodań i 259 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

113
backend/genesys.c
Wyświetl plik

@ -58,33 +58,12 @@
* SANE backend for Genesys Logic GL646/GL841/GL842/GL843/GL847/GL124 based scanners * SANE backend for Genesys Logic GL646/GL841/GL842/GL843/GL847/GL124 based scanners
*/ */
#include "../include/sane/config.h" #define BUILD 65
#define BUILD 64
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <math.h>
#ifdef HAVE_MKDIR
#include <sys/stat.h>
#include <sys/types.h>
#endif
#include "../include/sane/sane.h"
#include "../include/sane/sanei.h"
#include "../include/sane/saneopts.h"
#define BACKEND_NAME genesys #define BACKEND_NAME genesys
#include "../include/sane/sanei_backend.h"
#include "../include/sane/sanei_usb.h"
#include "../include/sane/sanei_config.h"
#include "../include/_stdint.h"
#include "../include/sane/sanei_magic.h"
#include "genesys.h" #include "genesys.h"
#include "../include/sane/sanei_config.h"
#include "../include/sane/sanei_magic.h"
#include "genesys_devices.c" #include "genesys_devices.c"
static SANE_Int num_devices = 0; static SANE_Int num_devices = 0;
@ -437,62 +416,6 @@ sanei_genesys_create_slope_table3 (Genesys_Device * dev,
return sum_time; return sum_time;
} }
/* Generate slope table for motor movement */
/* This function translates a call of the old slope creation function to a
call to the new one
*/
static SANE_Int
genesys_create_slope_table4 (Genesys_Device * dev,
uint16_t * slope_table, int steps,
int step_type, int exposure_time,
SANE_Bool same_speed, double yres,
int power_mode)
{
unsigned int sum_time = 0;
unsigned int vtarget;
unsigned int vend;
unsigned int vstart;
DBG (DBG_proc,
"sanei_genesys_create_slope_table: %d steps, step_type = %d, "
"exposure_time = %d, same_speed = %d, yres = %.2f, power_mode = %d\n",
steps, step_type, exposure_time, same_speed, yres, power_mode);
/* final speed */
vtarget = (exposure_time * yres) / dev->motor.base_ydpi;
vstart = dev->motor.slopes[power_mode][step_type].maximum_start_speed;
vend = dev->motor.slopes[power_mode][step_type].maximum_speed;
vtarget >>= step_type;
if (vtarget > 65535)
vtarget = 65535;
vstart >>= step_type;
if (vstart > 65535)
vstart = 65535;
vend >>= step_type;
if (vend > 65535)
vend = 65535;
sum_time = sanei_genesys_generate_slope_table (slope_table, 128,
steps,
vtarget,
vstart,
vend,
dev->motor.slopes[power_mode]
[step_type].minimum_steps <<
step_type,
dev->motor.slopes[power_mode]
[step_type].g, NULL, NULL);
DBG (DBG_proc,
"sanei_genesys_create_slope_table: returns sum_time=%d, completed\n",
sum_time);
return sum_time;
}
/* alternate slope table creation function */ /* alternate slope table creation function */
/* the hardcoded values (g and vstart) will go in a motor struct */ /* the hardcoded values (g and vstart) will go in a motor struct */
@ -635,11 +558,6 @@ sanei_genesys_create_slope_table (Genesys_Device * dev,
dev = dev; dev = dev;
if (dev->model->flags & GENESYS_FLAG_ALT_SLOPE_CREATE)
return genesys_create_slope_table4 (dev, slope_table, steps,
step_type, exposure_time,
same_speed, yres, power_mode);
if (dev->model->motor_type == MOTOR_5345 if (dev->model->motor_type == MOTOR_5345
|| dev->model->motor_type == MOTOR_HP2300 || dev->model->motor_type == MOTOR_HP2300
|| dev->model->motor_type == MOTOR_HP2400) || dev->model->motor_type == MOTOR_HP2400)
@ -5777,7 +5695,14 @@ init_options (Genesys_Scanner * s)
s->opt[OPT_SOURCE].size = max_string_size (source_list); s->opt[OPT_SOURCE].size = max_string_size (source_list);
s->opt[OPT_SOURCE].constraint.string_list = source_list; s->opt[OPT_SOURCE].constraint.string_list = source_list;
s->val[OPT_SOURCE].s = strdup (FLATBED); s->val[OPT_SOURCE].s = strdup (FLATBED);
DISABLE (OPT_SOURCE); if (!(model->flags & GENESYS_FLAG_HAS_UTA))
{
DISABLE (OPT_SOURCE);
}
else
{
ENABLE (OPT_SOURCE);
}
/* preview */ /* preview */
s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW; s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
@ -7001,6 +6926,7 @@ sane_close (SANE_Handle handle)
Genesys_Scanner *prev, *s; Genesys_Scanner *prev, *s;
Genesys_Calibration_Cache *cache, *next_cache; Genesys_Calibration_Cache *cache, *next_cache;
SANE_Status status; SANE_Status status;
SANE_Range *range;
DBG (DBG_proc, "sane_close: start\n"); DBG (DBG_proc, "sane_close: start\n");
@ -7064,19 +6990,22 @@ sane_close (SANE_Handle handle)
FREE_IFNOT_NULL (s->dev->sensor.blue_gamma_table); FREE_IFNOT_NULL (s->dev->sensor.blue_gamma_table);
/* for an handful of bytes .. */ /* for an handful of bytes .. */
free (s->opt[OPT_RESOLUTION].constraint.word_list); free ((void *)s->opt[OPT_RESOLUTION].constraint.word_list);
free (s->val[OPT_SOURCE].s); free (s->val[OPT_SOURCE].s);
free (s->val[OPT_MODE].s); free (s->val[OPT_MODE].s);
free (s->val[OPT_COLOR_FILTER].s); free (s->val[OPT_COLOR_FILTER].s);
FREE_IFNOT_NULL (s->opt[OPT_TL_X].constraint.range); range=s->opt[OPT_TL_X].constraint.range;
FREE_IFNOT_NULL (s->opt[OPT_TL_Y].constraint.range); FREE_IFNOT_NULL (range);
range=s->opt[OPT_TL_Y].constraint.range;
FREE_IFNOT_NULL (range);
if (prev) if (prev)
prev->next = s->next; prev->next = s->next;
else else
first_handle = s->next; first_handle = s->next;
/* maybe todo: shut down scanner */ /* LAMP OFF : same register across all the ASICs */
sanei_genesys_write_register (s->dev, 0x03, 0x00);
/* we need this to avoid ASIC getting stuck /* we need this to avoid ASIC getting stuck
* in bulk writes */ * in bulk writes */
@ -7334,8 +7263,8 @@ set_option_value (Genesys_Scanner * s, int option, void *val,
} }
/* assign new values */ /* assign new values */
free(s->opt[OPT_TL_X].constraint.range); free((SANE_Range *)s->opt[OPT_TL_X].constraint.range);
free(s->opt[OPT_TL_Y].constraint.range); free((SANE_Range *)s->opt[OPT_TL_Y].constraint.range);
s->opt[OPT_TL_X].constraint.range = x_range; s->opt[OPT_TL_X].constraint.range = x_range;
s->val[OPT_TL_X].w = 0; s->val[OPT_TL_X].w = 0;
s->opt[OPT_TL_Y].constraint.range = y_range; s->opt[OPT_TL_Y].constraint.range = y_range;

3
backend/genesys.conf.in
Wyświetl plik

@ -97,6 +97,9 @@ usb 0x04a7 0x04ac
# Panasonic KV-SS080 # Panasonic KV-SS080
usb 0x04da 0x100f usb 0x04da 0x100f
# Hewlett Packard ScanJet 4850C
usb 0x03f0 0x1b05
# Hewlett Packard ScanJet G4010 # Hewlett Packard ScanJet G4010
usb 0x03f0 0x4505 usb 0x03f0 0x4505

69
backend/genesys_devices.c
Wyświetl plik

@ -515,7 +515,7 @@ static Genesys_Sensor Sensor[] = {
/* 08 09 0a 0b */ /* 08 09 0a 0b */
{0x00, 0x00, 0x18, 0x69} , {0x00, 0x00, 0x18, 0x69} ,
/* 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d */ /* 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d */
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x0c, 0x00, 0x2a, 0x30, 0x00, 0x00, 0x08} , {0x2c, 0x09, 0x22, 0xb8, 0x10, 0xf0, 0x33, 0x0c, 0x00, 0x2a, 0x30, 0x00, 0x00, 0x08} ,
/* 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e */ /* 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e */
{0x0b, 0x0e, 0x11, 0x02, 0x05, 0x08, 0x63, 0x00, 0x40, 0x00, 0x00, 0x00, 0x6f} , {0x0b, 0x0e, 0x11, 0x02, 0x05, 0x08, 0x63, 0x00, 0x40, 0x00, 0x00, 0x00, 0x6f} ,
1.0, 1.0, 1.0, 1.0, 1.0, 1.0,
@ -1151,6 +1151,61 @@ static Genesys_Model panasonic_kvss080_model = {
100 100
}; };
static Genesys_Model hp4850c_model = {
"hewlett-packard-scanjet-4850c", /* Name */
"Hewlett Packard", /* Device vendor string */
"ScanJet 4850C", /* Device model name */
GENESYS_GL843,
NULL,
{ 2400, 1200, 600, 400, 300, 200, 150, 100, 0},
{ 2400, 1200, 600, 400, 300, 200, 150, 100, 0},
{16, 8, 0}, /* possible depths in gray mode */
{16, 8, 0}, /* possible depths in color mode */
SANE_FIX (8.0), /* Start of scan area in mm (x) */
SANE_FIX (13.00), /* Start of scan area in mm (y) */
SANE_FIX (217.9), /* Size of scan area in mm (x) 5148 pixels at 600 dpi*/
SANE_FIX (315.0), /* Size of scan area in mm (y) */
SANE_FIX (3.0), /* Start of white strip in mm (y) */
SANE_FIX (0.0), /* Start of black mark in mm (x) */
SANE_FIX (0.0), /* Start of scan area in TA mode in mm (x) */
SANE_FIX (0.0), /* Start of scan area in TA mode in mm (y) */
SANE_FIX (100.0), /* Size of scan area in TA mode in mm (x) */
SANE_FIX (100.0), /* Size of scan area in TA mode in mm (y) */
SANE_FIX (0.0), /* Start of white strip in TA mode in mm (y) */
SANE_FIX (0.0), /* Size of scan area after paper sensor stops
sensing document in mm */
SANE_FIX (0.0), /* Amount of feeding needed to eject document
after finishing scanning in mm */
0, 24, 48, /* RGB CCD Line-distance correction in line number */
/* 0 38 76 OK 1200/2400 */
/* 0 24 48 OK [100,600] dpi */
COLOR_ORDER_RGB, /* Order of the CCD/CIS colors */
SANE_FALSE, /* Is this a CIS scanner? */
SANE_FALSE, /* Is this a sheetfed scanner? */
CCD_G4050,
DAC_G4050,
GPO_G4050,
MOTOR_G4050,
GENESYS_FLAG_LAZY_INIT |
GENESYS_FLAG_OFFSET_CALIBRATION |
GENESYS_FLAG_STAGGERED_LINE |
GENESYS_FLAG_SKIP_WARMUP |
GENESYS_FLAG_DARK_CALIBRATION |
GENESYS_FLAG_CUSTOM_GAMMA,
GENESYS_HAS_SCAN_SW | GENESYS_HAS_FILE_SW | GENESYS_HAS_COPY_SW,
100,
100
};
static Genesys_Model hpg4010_model = { static Genesys_Model hpg4010_model = {
"hewlett-packard-scanjet-g4010", /* Name */ "hewlett-packard-scanjet-g4010", /* Name */
"Hewlett Packard", /* Device vendor string */ "Hewlett Packard", /* Device vendor string */
@ -1226,12 +1281,12 @@ static Genesys_Model hpg4050_model = {
SANE_FIX (3.0), /* Start of white strip in mm (y) */ SANE_FIX (3.0), /* Start of white strip in mm (y) */
SANE_FIX (0.0), /* Start of black mark in mm (x) */ SANE_FIX (0.0), /* Start of black mark in mm (x) */
SANE_FIX (0.0), /* Start of scan area in TA mode in mm (x) */ SANE_FIX (8.0), /* Start of scan area in TA mode in mm (x) */
SANE_FIX (0.0), /* Start of scan area in TA mode in mm (y) */ SANE_FIX (13.00), /* Start of scan area in TA mode in mm (y) */
SANE_FIX (100.0), /* Size of scan area in TA mode in mm (x) */ SANE_FIX (217.9), /* Size of scan area in TA mode in mm (x) */
SANE_FIX (100.0), /* Size of scan area in TA mode in mm (y) */ SANE_FIX (250.0), /* Size of scan area in TA mode in mm (y) */
SANE_FIX (0.0), /* Start of white strip in TA mode in mm (y) */ SANE_FIX (40.0), /* Start of white strip in TA mode in mm (y) */
SANE_FIX (0.0), /* Size of scan area after paper sensor stops SANE_FIX (0.0), /* Size of scan area after paper sensor stops
sensing document in mm */ sensing document in mm */
@ -1255,6 +1310,7 @@ static Genesys_Model hpg4050_model = {
GENESYS_FLAG_STAGGERED_LINE | GENESYS_FLAG_STAGGERED_LINE |
GENESYS_FLAG_SKIP_WARMUP | GENESYS_FLAG_SKIP_WARMUP |
GENESYS_FLAG_DARK_CALIBRATION | GENESYS_FLAG_DARK_CALIBRATION |
GENESYS_FLAG_HAS_UTA |
GENESYS_FLAG_CUSTOM_GAMMA, GENESYS_FLAG_CUSTOM_GAMMA,
GENESYS_HAS_SCAN_SW | GENESYS_HAS_FILE_SW | GENESYS_HAS_COPY_SW, GENESYS_HAS_SCAN_SW | GENESYS_HAS_FILE_SW | GENESYS_HAS_COPY_SW,
100, 100,
@ -2790,6 +2846,7 @@ static Genesys_USB_Device_Entry genesys_usb_device_list[] = {
{0x04a9, 0x1907, &canon_lide_700f_model}, {0x04a9, 0x1907, &canon_lide_700f_model},
/* GL843 devices */ /* GL843 devices */
{0x04da, 0x100f, &panasonic_kvss080_model}, {0x04da, 0x100f, &panasonic_kvss080_model},
{0x03f0, 0x1b05, &hp4850c_model},
{0x03f0, 0x4505, &hpg4010_model}, {0x03f0, 0x4505, &hpg4010_model},
{0x03f0, 0x4605, &hpg4050_model}, {0x03f0, 0x4605, &hpg4050_model},
/* GL124 devices */ /* GL124 devices */

3
backend/genesys_gl124.c
Wyświetl plik

@ -42,6 +42,9 @@
If you do not wish that, delete this exception notice. If you do not wish that, delete this exception notice.
*/ */
#undef BACKEND_NAME
#define BACKEND_NAME genesys_gl124
#include "genesys_gl124.h" #include "genesys_gl124.h"
/**************************************************************************** /****************************************************************************

3
backend/genesys_gl124.h
Wyświetl plik

@ -41,9 +41,6 @@
If you do not wish that, delete this exception notice. If you do not wish that, delete this exception notice.
*/ */
#undef BACKEND_NAME
#define BACKEND_NAME genesys_gl124
#include "genesys.h" #include "genesys.h"
#define REG01 0x01 #define REG01 0x01

3
backend/genesys_gl646.c
Wyświetl plik

@ -48,6 +48,9 @@
If you do not wish that, delete this exception notice. If you do not wish that, delete this exception notice.
*/ */
#undef BACKEND_NAME
#define BACKEND_NAME genesys_gl646
#include "genesys_gl646.h" #include "genesys_gl646.h"
/** /**

3
backend/genesys_gl646.h
Wyświetl plik

@ -44,9 +44,6 @@
If you do not wish that, delete this exception notice. If you do not wish that, delete this exception notice.
*/ */
#undef BACKEND_NAME
#define BACKEND_NAME genesys_gl646
#include "genesys.h" #include "genesys.h"
/* /*

8
backend/genesys_gl841.c
Wyświetl plik

@ -3,7 +3,7 @@
Copyright (C) 2003 Oliver Rauch Copyright (C) 2003 Oliver Rauch
Copyright (C) 2003, 2004 Henning Meier-Geinitz <henning@meier-geinitz.de> Copyright (C) 2003, 2004 Henning Meier-Geinitz <henning@meier-geinitz.de>
Copyright (C) 2004 Gerhard Jaeger <gerhard@gjaeger.de> Copyright (C) 2004 Gerhard Jaeger <gerhard@gjaeger.de>
Copyright (C) 2004-2010 Stephane Voltz <stef.dev@free.fr> Copyright (C) 2004-2011 Stéphane Voltz <stef.dev@free.fr>
Copyright (C) 2005 Philipp Schmid <philipp8288@web.de> Copyright (C) 2005 Philipp Schmid <philipp8288@web.de>
Copyright (C) 2005-2009 Pierre Willenbrock <pierre@pirsoft.dnsalias.org> Copyright (C) 2005-2009 Pierre Willenbrock <pierre@pirsoft.dnsalias.org>
Copyright (C) 2006 Laurent Charpentier <laurent_pubs@yahoo.com> Copyright (C) 2006 Laurent Charpentier <laurent_pubs@yahoo.com>
@ -50,6 +50,9 @@
If you do not wish that, delete this exception notice. If you do not wish that, delete this exception notice.
*/ */
#undef BACKEND_NAME
#define BACKEND_NAME genesys_gl841
#include "genesys_gl841.h" #include "genesys_gl841.h"
/**************************************************************************** /****************************************************************************
@ -1298,9 +1301,6 @@ gl841_set_fe (Genesys_Device * dev, uint8_t set)
return SANE_STATUS_GOOD; return SANE_STATUS_GOOD;
} }
#define MOTOR_FLAG_AUTO_GO_HOME 1
#define MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE 2
#define MOTOR_ACTION_FEED 1 #define MOTOR_ACTION_FEED 1
#define MOTOR_ACTION_GO_HOME 2 #define MOTOR_ACTION_GO_HOME 2
#define MOTOR_ACTION_HOME_FREE 3 #define MOTOR_ACTION_HOME_FREE 3

3
backend/genesys_gl841.h
Wyświetl plik

@ -41,9 +41,6 @@
If you do not wish that, delete this exception notice. If you do not wish that, delete this exception notice.
*/ */
#undef BACKEND_NAME
#define BACKEND_NAME genesys_gl841
#include "genesys.h" #include "genesys.h"
/* Individual bits */ /* Individual bits */

401
backend/genesys_gl843.c
Wyświetl plik

@ -42,6 +42,9 @@
If you do not wish that, delete this exception notice. If you do not wish that, delete this exception notice.
*/ */
#undef BACKEND_NAME
#define BACKEND_NAME genesys_gl843
#include "genesys_gl843.h" #include "genesys_gl843.h"
/**************************************************************************** /****************************************************************************
@ -444,25 +447,37 @@ gl843_test_motor_flag_bit (SANE_Byte val)
* profile is at a specific dpihw. Use first entry of table by default. * profile is at a specific dpihw. Use first entry of table by default.
* @param sensor_type sensor id * @param sensor_type sensor id
* @param dpi hardware dpi for the scan * @param dpi hardware dpi for the scan
* @param flags to select between XPA, XPA+IR or regular scan from OPTICAL_FLAGS_*
* @return a pointer to a Sensor_Profile struct * @return a pointer to a Sensor_Profile struct
*/ */
static Sensor_Profile *get_sensor_profile(int sensor_type, int dpi) static Sensor_Profile *get_sensor_profile(int sensor_type, int dpi, int flags)
{ {
unsigned int i; unsigned int i, count;
int idx; int idx;
Sensor_Profile *sp;
if(flags & OPTICAL_FLAG_USE_XPA)
{
sp=xpa_sensors;
count=sizeof(xpa_sensors)/sizeof(Sensor_Profile);
}
else
{
sp=sensors;
count=sizeof(sensors)/sizeof(Sensor_Profile);
}
i=0; i=0;
idx=-1; idx=-1;
while(i<sizeof(sensors)/sizeof(Sensor_Profile)) while(i<count)
{ {
/* exact match */ /* exact match */
if(sensors[i].sensor_type==sensor_type && sensors[i].dpi==dpi) if(sp[i].sensor_type==sensor_type && sp[i].dpi==dpi)
{ {
return &(sensors[i]); return &(sp[i]);
} }
/* closest match */ /* closest match */
if(sensors[i].sensor_type==sensor_type) if(sp[i].sensor_type==sensor_type)
{ {
if(idx<0) if(idx<0)
{ {
@ -470,8 +485,8 @@ static Sensor_Profile *get_sensor_profile(int sensor_type, int dpi)
} }
else else
{ {
if(sensors[i].dpi>=dpi if(sp[i].dpi>=dpi
&& sensors[i].dpi<sensors[idx].dpi) && sp[i].dpi<sp[idx].dpi)
{ {
idx=i; idx=i;
} }
@ -487,13 +502,13 @@ static Sensor_Profile *get_sensor_profile(int sensor_type, int dpi)
idx=0; idx=0;
} }
return &(sensors[idx]); return &(sp[idx]);
} }
/** copy sensor specific settings */ /** copy sensor specific settings */
static void static void
gl843_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi) gl843_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi,int flags)
{ {
Genesys_Register_Set *r; Genesys_Register_Set *r;
Sensor_Profile *sensor; Sensor_Profile *sensor;
@ -502,7 +517,7 @@ gl843_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi)
DBGSTART; DBGSTART;
dpihw=sanei_genesys_compute_dpihw(dev,dpi); dpihw=sanei_genesys_compute_dpihw(dev,dpi);
sensor=get_sensor_profile(dev->model->ccd_type, dpihw); sensor=get_sensor_profile(dev->model->ccd_type, dpihw, flags);
for (i = 0x06; i < 0x0e; i++) for (i = 0x06; i < 0x0e; i++)
{ {
@ -533,6 +548,11 @@ gl843_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi)
{ {
r->value = sensor->reg71; r->value = sensor->reg71;
} }
r = sanei_genesys_get_address (regs, 0x7d);
if (r)
{
r->value = 0x90;
}
r = sanei_genesys_get_address (regs, 0x9e); r = sanei_genesys_get_address (regs, 0x9e);
if (r) if (r)
{ {
@ -550,7 +570,7 @@ gl843_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi)
sanei_genesys_set_triple(regs,REG_CK3MAP,sensor->ck3map); sanei_genesys_set_triple(regs,REG_CK3MAP,sensor->ck3map);
sanei_genesys_set_triple(regs,REG_CK4MAP,sensor->ck4map); sanei_genesys_set_triple(regs,REG_CK4MAP,sensor->ck4map);
DBG (DBG_proc, "gl843_setup_sensor: completed \n"); DBGCOMPLETED;
} }
@ -696,6 +716,15 @@ gl843_init_registers (Genesys_Device * dev)
SETREG (0x06, 0xd8); /* SCANMOD=110, PWRBIT and GAIN4 */ SETREG (0x06, 0xd8); /* SCANMOD=110, PWRBIT and GAIN4 */
SETREG (0x0a, 0x18); SETREG (0x0a, 0x18);
SETREG (0x0b, 0x69); SETREG (0x0b, 0x69);
/* CIS exposure is used for XPA lamp movement */
SETREG (0x10, 0x2c);
SETREG (0x11, 0x09);
SETREG (0x12, 0x22);
SETREG (0x13, 0xb8);
SETREG (0x14, 0x10);
SETREG (0x15, 0xf0);
SETREG (0x6b, 0xf4); SETREG (0x6b, 0xf4);
SETREG (0x70, 0x00); SETREG (0x70, 0x00);
@ -1084,11 +1113,11 @@ gl843_init_motor_regs_scan (Genesys_Device * dev,
/**@brief compute exposure to use /**@brief compute exposure to use
* compute the sensor exposure based on target resolution * compute the sensor exposure based on target resolution
*/ */
static int gl843_compute_exposure(Genesys_Device *dev, int xres) static int gl843_compute_exposure(Genesys_Device *dev, int xres, int flags)
{ {
Sensor_Profile *sensor; Sensor_Profile *sensor;
sensor=get_sensor_profile(dev->model->ccd_type, xres); sensor=get_sensor_profile(dev->model->ccd_type, xres, flags);
return sensor->exposure; return sensor->exposure;
} }
@ -1100,6 +1129,7 @@ static int gl843_compute_exposure(Genesys_Device *dev, int xres)
* scan's one * scan's one
* @param start logical start pixel coordinate * @param start logical start pixel coordinate
* @param pixels logical number of pixels to use * @param pixels logical number of pixels to use
* @param flags to drive specific settings such no calibration, XPA use ...
* @return SANE_STATUS_GOOD if OK * @return SANE_STATUS_GOOD if OK
*/ */
static SANE_Status static SANE_Status
@ -1111,7 +1141,9 @@ gl843_init_optical_regs_scan (Genesys_Device * dev,
unsigned int pixels, unsigned int pixels,
int channels, int channels,
int depth, int depth,
SANE_Bool half_ccd, int color_filter, int flags) SANE_Bool half_ccd,
int color_filter,
int flags)
{ {
unsigned int words_per_line; unsigned int words_per_line;
unsigned int startx, endx, used_pixels; unsigned int startx, endx, used_pixels;
@ -1128,11 +1160,6 @@ gl843_init_optical_regs_scan (Genesys_Device * dev,
exposure, exposure,
used_res, start, pixels, channels, depth, half_ccd, flags); used_res, start, pixels, channels, depth, half_ccd, flags);
/* resolution is divided according to CKSEL */
r = sanei_genesys_get_address (reg, REG18);
cksel= (r->value & REG18_CKSEL)+1;
DBG (DBG_io2, "%s: cksel=%d\n", __FUNCTION__, cksel);
/* tgtime */ /* tgtime */
tgtime=1; tgtime=1;
if (dev->model->ccd_type == CCD_G4050 && used_res>2400) if (dev->model->ccd_type == CCD_G4050 && used_res>2400)
@ -1148,7 +1175,12 @@ gl843_init_optical_regs_scan (Genesys_Device * dev,
DBG (DBG_io2, "%s: dpihw=%d (factor=%d)\n", __FUNCTION__, dpihw, factor); DBG (DBG_io2, "%s: dpihw=%d (factor=%d)\n", __FUNCTION__, dpihw, factor);
/* sensor parameters */ /* sensor parameters */
gl843_setup_sensor (dev, reg, dpihw); gl843_setup_sensor (dev, reg, dpihw, flags);
/* resolution is divided according to CKSEL which is known once sensor is set up*/
r = sanei_genesys_get_address (reg, REG18);
cksel= (r->value & REG18_CKSEL)+1;
DBG (DBG_io2, "%s: cksel=%d\n", __FUNCTION__, cksel);
dpiset = used_res * cksel; dpiset = used_res * cksel;
/* start and end coordinate in optical dpi coordinates */ /* start and end coordinate in optical dpi coordinates */
@ -1205,6 +1237,13 @@ gl843_init_optical_regs_scan (Genesys_Device * dev,
else else
r->value |= REG03_LAMPPWR; r->value |= REG03_LAMPPWR;
/* select XPA */
r->value &= ~REG03_XPASEL;
if (flags & OPTICAL_FLAG_USE_XPA)
{
r->value |= REG03_XPASEL;
}
/* BW threshold */ /* BW threshold */
r = sanei_genesys_get_address (reg, REG2E); r = sanei_genesys_get_address (reg, REG2E);
r->value = dev->settings.threshold; r->value = dev->settings.threshold;
@ -1398,6 +1437,23 @@ gl843_init_scan_regs (Genesys_Device * dev,
} }
DBG (DBG_info, "%s : stagger=%d lines\n", __FUNCTION__, stagger); DBG (DBG_info, "%s : stagger=%d lines\n", __FUNCTION__, stagger);
/* we enable true gray for cis scanners only, and just when doing
* scan since color calibration is OK for this mode
*/
oflags = 0;
if (flags & SCAN_FLAG_DISABLE_SHADING)
oflags |= OPTICAL_FLAG_DISABLE_SHADING;
if (flags & SCAN_FLAG_DISABLE_GAMMA)
oflags |= OPTICAL_FLAG_DISABLE_GAMMA;
if (flags & SCAN_FLAG_DISABLE_LAMP)
oflags |= OPTICAL_FLAG_DISABLE_LAMP;
if (flags & SCAN_FLAG_CALIBRATION)
oflags |= OPTICAL_FLAG_DISABLE_DOUBLE;
if(stagger)
oflags |= OPTICAL_FLAG_STAGGER;
if (flags & SCAN_FLAG_USE_XPA)
oflags |= OPTICAL_FLAG_USE_XPA;
/** @brief compute used resolution */ /** @brief compute used resolution */
if (flags & SCAN_FLAG_USE_OPTICAL_RES) if (flags & SCAN_FLAG_USE_OPTICAL_RES)
{ {
@ -1432,6 +1488,7 @@ gl843_init_scan_regs (Genesys_Device * dev,
used_pixels++; used_pixels++;
dummy = 0; dummy = 0;
/* dummy = 1; XXX STEF XXX */
/* slope_dpi */ /* slope_dpi */
/* cis color scan is effectively a gray scan with 3 gray lines per color line and a FILTER of 0 */ /* cis color scan is effectively a gray scan with 3 gray lines per color line and a FILTER of 0 */
@ -1439,16 +1496,17 @@ gl843_init_scan_regs (Genesys_Device * dev,
slope_dpi = yres * channels; slope_dpi = yres * channels;
else else
slope_dpi = yres; slope_dpi = yres;
slope_dpi = slope_dpi * (1 + dummy);
/* scan_step_type */ /* scan_step_type */
if(flags & SCAN_FLAG_FEEDING) if(flags & SCAN_FLAG_FEEDING)
{ {
exposure=gl843_compute_exposure (dev, sanei_genesys_get_lowest_ydpi(dev)); exposure=gl843_compute_exposure (dev, sanei_genesys_get_lowest_ydpi(dev), oflags);
scan_step_type=sanei_genesys_compute_step_type (gl843_motors, dev->model->motor_type, exposure); scan_step_type=sanei_genesys_compute_step_type (gl843_motors, dev->model->motor_type, exposure);
} }
else else
{ {
exposure = gl843_compute_exposure (dev, used_res); exposure = gl843_compute_exposure (dev, used_res, oflags);
scan_step_type = sanei_genesys_compute_step_type(gl843_motors, dev->model->motor_type, exposure); scan_step_type = sanei_genesys_compute_step_type(gl843_motors, dev->model->motor_type, exposure);
} }
@ -1464,23 +1522,10 @@ gl843_init_scan_regs (Genesys_Device * dev,
} }
/* no 16 bit gamma for this ASIC */ /* no 16 bit gamma for this ASIC */
if (depth == 16) if (depth == 16)
flags |= SCAN_FLAG_DISABLE_GAMMA; {
flags |= SCAN_FLAG_DISABLE_GAMMA;
/* we enable true gray for cis scanners only, and just when doing oflags |= OPTICAL_FLAG_DISABLE_GAMMA;
* scan since color calibration is OK for this mode }
*/
oflags = 0;
if (flags & SCAN_FLAG_DISABLE_SHADING)
oflags |= OPTICAL_FLAG_DISABLE_SHADING;
if (flags & SCAN_FLAG_DISABLE_GAMMA)
oflags |= OPTICAL_FLAG_DISABLE_GAMMA;
if (flags & SCAN_FLAG_DISABLE_LAMP)
oflags |= OPTICAL_FLAG_DISABLE_LAMP;
if (flags & SCAN_FLAG_CALIBRATION)
oflags |= OPTICAL_FLAG_DISABLE_DOUBLE;
if(stagger)
oflags |= OPTICAL_FLAG_STAGGER;
/* now _LOGICAL_ optical values used are known, setup registers */ /* now _LOGICAL_ optical values used are known, setup registers */
status = gl843_init_optical_regs_scan (dev, status = gl843_init_optical_regs_scan (dev,
@ -1530,17 +1575,19 @@ gl843_init_scan_regs (Genesys_Device * dev,
mflags|=MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE; mflags|=MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE;
if(flags & SCAN_FLAG_FEEDING) if(flags & SCAN_FLAG_FEEDING)
mflags|=MOTOR_FLAG_FEED; mflags|=MOTOR_FLAG_FEED;
if (flags & SCAN_FLAG_USE_XPA)
mflags |= MOTOR_FLAG_USE_XPA;
status = gl843_init_motor_regs_scan (dev, status = gl843_init_motor_regs_scan (dev,
reg, reg,
exposure, exposure,
slope_dpi, slope_dpi,
scan_step_type, scan_step_type,
dev->model->is_cis ? lincnt * channels : lincnt, dev->model->is_cis ? lincnt * channels : lincnt,
dummy, dummy,
move, move,
scan_power_mode, scan_power_mode,
mflags); mflags);
if (status != SANE_STATUS_GOOD) if (status != SANE_STATUS_GOOD)
return status; return status;
@ -1639,6 +1686,7 @@ gl843_calculate_current_setup (Genesys_Device * dev)
SANE_Bool half_ccd; /* false: full CCD res is used, true, half max CCD res is used */ SANE_Bool half_ccd; /* false: full CCD res is used, true, half max CCD res is used */
int optical_res; int optical_res;
int oflags;
DBG (DBG_info, DBG (DBG_info,
"gl843_calculate_current_setup settings:\n" "gl843_calculate_current_setup settings:\n"
@ -1667,6 +1715,12 @@ gl843_calculate_current_setup (Genesys_Device * dev)
start += dev->settings.tl_x; start += dev->settings.tl_x;
start = (start * dev->sensor.optical_res) / MM_PER_INCH; start = (start * dev->sensor.optical_res) / MM_PER_INCH;
/* optical flags */
oflags=0;
if(dev->settings.scan_method==SCAN_METHOD_TRANSPARENCY)
{
oflags=OPTICAL_FLAG_USE_XPA;
}
xres = dev->settings.xres; xres = dev->settings.xres;
yres = dev->settings.yres; yres = dev->settings.yres;
@ -1733,7 +1787,7 @@ gl843_calculate_current_setup (Genesys_Device * dev)
slope_dpi = yres; slope_dpi = yres;
/* exposure */ /* exposure */
exposure = gl843_compute_exposure (dev, used_res); exposure = gl843_compute_exposure (dev, used_res, oflags);
/* scan_step_type */ /* scan_step_type */
scan_step_type = sanei_genesys_compute_step_type(gl843_motors, dev->model->motor_type, exposure); scan_step_type = sanei_genesys_compute_step_type(gl843_motors, dev->model->motor_type, exposure);
@ -1803,30 +1857,26 @@ gl843_set_lamp_power (Genesys_Device * dev,
{ {
Genesys_Register_Set *r; Genesys_Register_Set *r;
int i; int i;
uint8_t val;
val = sanei_genesys_read_reg_from_set (regs, REG03);
if (set) if (set)
{ {
sanei_genesys_set_reg_from_set (regs, 0x03, val |= REG03_LAMPPWR;
sanei_genesys_read_reg_from_set (regs, sanei_genesys_set_reg_from_set (regs, REG03, val);
0x03)
| REG03_LAMPPWR);
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++)
{ {
r = sanei_genesys_get_address (dev->calib_reg, 0x10 + i); r = sanei_genesys_get_address (regs, 0x10 + i);
r->value = dev->sensor.regs_0x10_0x1d[i]; r->value = dev->sensor.regs_0x10_0x1d[i];
} }
} }
else else
{ {
sanei_genesys_set_reg_from_set (regs, 0x03, val &= ~REG03_LAMPPWR;
sanei_genesys_read_reg_from_set (regs, sanei_genesys_set_reg_from_set (regs, REG03, val);
0x03)
& ~REG03_LAMPPWR);
for (i = 0; i < 6; i++) for (i = 0; i < 6; i++)
{ {
r = sanei_genesys_get_address (dev->calib_reg, 0x10 + i); r = sanei_genesys_get_address (regs, 0x10 + i);
r->value = 0x00; r->value = 0x00;
} }
} }
@ -2154,16 +2204,14 @@ gl843_begin_scan (Genesys_Device * dev, Genesys_Register_Set * reg,
SANE_Bool start_motor) SANE_Bool start_motor)
{ {
SANE_Status status; SANE_Status status;
uint8_t val; uint8_t val,r03;
uint16_t dpiset,dpihw; uint16_t dpiset, dpihw;
DBGSTART; DBGSTART;
if (reg == NULL)
return SANE_STATUS_INVAL;
/* get back the target dpihw */ /* get back the target dpihw */
sanei_genesys_get_double(reg,REG_DPISET,&dpiset); sanei_genesys_get_double (reg, REG_DPISET, &dpiset);
dpihw=sanei_genesys_compute_dpihw(dev,dpiset); dpihw = sanei_genesys_compute_dpihw (dev, dpiset);
/* set up GPIO for scan */ /* set up GPIO for scan */
/* KV case */ /* KV case */
@ -2172,31 +2220,73 @@ gl843_begin_scan (Genesys_Device * dev, Genesys_Register_Set * reg,
RIE (sanei_genesys_write_register (dev, REGA9, 0x00)); RIE (sanei_genesys_write_register (dev, REGA9, 0x00));
RIE (sanei_genesys_write_register (dev, REGA6, 0xf6)); RIE (sanei_genesys_write_register (dev, REGA6, 0xf6));
/* blinking led */ /* blinking led */
RIE(sanei_genesys_write_register(dev,0x7e,0x04)); RIE (sanei_genesys_write_register (dev, 0x7e, 0x04));
} }
if (dev->model->gpo_type == GPO_G4050) if (dev->model->gpo_type == GPO_G4050)
{ {
RIE (sanei_genesys_write_register (dev, REGA7, 0xfe)); RIE (sanei_genesys_write_register (dev, REGA7, 0xfe));
RIE (sanei_genesys_write_register (dev, REGA8, 0x3e)); RIE (sanei_genesys_write_register (dev, REGA8, 0x3e));
RIE (sanei_genesys_write_register (dev, REGA9, 0x06)); RIE (sanei_genesys_write_register (dev, REGA9, 0x06));
switch(dpihw) switch (dpihw)
{
case 1200:
case 2400:
case 4800:
RIE (sanei_genesys_write_register (dev, REG6C, 0x60));
RIE (sanei_genesys_write_register (dev, REGA6, 0x46));
break;
default: /* 600 dpi case */
RIE (sanei_genesys_write_register (dev, REG6C, 0x20));
RIE (sanei_genesys_write_register (dev, REGA6, 0x44));
}
/* turn on XPA lamp if XPA is selected and lamp power on*/
r03 = sanei_genesys_read_reg_from_set (reg, REG03);
if ((r03 & REG03_XPASEL) && (r03 & REG03_LAMPPWR))
{ {
case 1200: RIE (sanei_genesys_read_register (dev, REGA6, &val));
case 2400:
case 4800: /* switch off regular lamp */
RIE (sanei_genesys_write_register (dev, REG6C, 0x60)); val &= 0xbf;
RIE (sanei_genesys_write_register (dev, REGA6, 0x46));
break; /* light XPA lamp at full power (2 bits for level: __11 ____) */
default: /* 600 dpi case */ val |= 0x30;
RIE (sanei_genesys_write_register (dev, REG6C, 0x20));
RIE (sanei_genesys_write_register (dev, REGA6, 0x44)); RIE (sanei_genesys_write_register (dev, REGA6, val));
} }
/* enable XPA lamp motor */
if (r03 & REG03_XPASEL)
{
/* set MULTFILM et GPOADF */
RIE (sanei_genesys_read_register (dev, REG6B, &val));
val |=REG6B_MULTFILM|REG6B_GPOADF;
RIE (sanei_genesys_write_register (dev, REG6B, val));
RIE (sanei_genesys_read_register (dev, REG6C, &val));
val &= ~REG6C_GPIO15;
RIE (sanei_genesys_write_register (dev, REG6C, val));
RIE (sanei_genesys_read_register (dev, REGA6, &val));
val |= REGA6_GPIO20;
RIE (sanei_genesys_write_register(dev,REGA6,val));
RIE (sanei_genesys_read_register (dev, REGA8, &val));
val &= ~REGA8_GPO27;
RIE (sanei_genesys_write_register (dev, REGA8, val));
RIE (sanei_genesys_read_register (dev, REGA9, &val));
val |= REGA9_GPO32|REGA9_GPO31;
RIE (sanei_genesys_write_register (dev, REGA9, val));
}
/* blinking led */ /* blinking led */
RIE(sanei_genesys_write_register(dev,0x7e,0x01)); RIE (sanei_genesys_write_register (dev, REG7E, 0x01));
} }
/* clear scan and feed count */ /* clear scan and feed count */
RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRLNCNT | REG0D_CLRMCNT)); RIE (sanei_genesys_write_register
(dev, REG0D, REG0D_CLRLNCNT | REG0D_CLRMCNT));
/* enable scan and motor */ /* enable scan and motor */
RIE (sanei_genesys_read_register (dev, REG01, &val)); RIE (sanei_genesys_read_register (dev, REG01, &val));
@ -2226,6 +2316,7 @@ gl843_end_scan (Genesys_Device * dev, Genesys_Register_Set * reg,
SANE_Bool check_stop) SANE_Bool check_stop)
{ {
SANE_Status status; SANE_Status status;
uint8_t val;
DBG (DBG_proc, "gl843_end_scan (check_stop = %d)\n", check_stop); DBG (DBG_proc, "gl843_end_scan (check_stop = %d)\n", check_stop);
if (reg == NULL) if (reg == NULL)
@ -2234,6 +2325,21 @@ gl843_end_scan (Genesys_Device * dev, Genesys_Register_Set * reg,
/* post scan gpio */ /* post scan gpio */
RIE(sanei_genesys_write_register(dev,0x7e,0x00)); RIE(sanei_genesys_write_register(dev,0x7e,0x00));
/* turn off XPA lamp if XPA is selected and lamp power on*/
val = sanei_genesys_read_reg_from_set (reg, REG03);
if (val & (REG03_XPASEL|REG03_LAMPPWR))
{
sanei_genesys_read_register (dev, REGA6, &val);
/* switch on regular lamp */
val |= 0x40;
/* no XPA lamp power (2 bits for level: __11 ____) */
val &= ~0x30;
RIE (sanei_genesys_write_register (dev, REGA6, val));
}
if (dev->model->is_sheetfed == SANE_TRUE) if (dev->model->is_sheetfed == SANE_TRUE)
{ {
status = SANE_STATUS_GOOD; status = SANE_STATUS_GOOD;
@ -2254,6 +2360,82 @@ gl843_end_scan (Genesys_Device * dev, Genesys_Register_Set * reg,
return status; return status;
} }
/** @brief park XPA lamp
* park the XPA lamp if needed
*/
static SANE_Status gl843_park_xpa_lamp (Genesys_Device * dev)
{
Genesys_Register_Set local_reg[GENESYS_GL843_MAX_REGS];
SANE_Status status;
Genesys_Register_Set *r;
uint8_t val;
int loop = 0;
DBGSTART;
/* copy scan settings */
memset (local_reg, 0, sizeof (local_reg));
memcpy (local_reg, dev->reg, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
/* set a huge feedl and reverse direction */
sanei_genesys_set_triple(local_reg,REG_FEEDL,0xbdcd);
/* clear scan and feed count */
RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRLNCNT | REG0D_CLRMCNT));
/* set up for reverse and no scan */
r = sanei_genesys_get_address (local_reg, REG02);
r->value |= REG02_MTRREV;
r = sanei_genesys_get_address (local_reg, REG01);
r->value &= ~REG01_SCAN;
/* write to scanner and start action */
RIE (gl843_bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS));
status = gl843_start_action (dev);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to start motor: %s\n",__FUNCTION__, sane_strstatus (status));
gl843_stop_action (dev);
/* restore original registers */
gl843_bulk_write_register (dev, dev->reg, GENESYS_GL843_MAX_REGS);
return status;
}
while (loop < 600) /* do not wait longer then 60 seconds */
{
status = sanei_genesys_get_status (dev, &val);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to read home sensor: %s\n",__FUNCTION__,
sane_strstatus (status));
return status;
}
if (DBG_LEVEL >= DBG_io2)
{
sanei_genesys_print_status (val);
}
if (val & REG41_HOMESNR) /* home sensor */
{
DBG (DBG_info, "%s: reached home position\n",__FUNCTION__);
DBG (DBG_proc, "%s: finished\n",__FUNCTION__);
/* clear GPOADF to avoid reparking again */
sanei_genesys_read_register (dev, REG6B, &val);
val &= ~REG6B_GPOADF;
sanei_genesys_write_register (dev, REG6B, val);
return SANE_STATUS_GOOD;
}
usleep (100000); /* sleep 100 ms */
++loop;
}
/* we are not parked here.... should we fail ? */
DBG (DBG_info, "%s: XPA lamp is not parked\n", __FUNCTION__);
DBGCOMPLETED;
return SANE_STATUS_GOOD;
}
/** @brief Moves the slider to the home (top) position slowly /** @brief Moves the slider to the home (top) position slowly
* */ * */
@ -2273,15 +2455,24 @@ gl843_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
DBG (DBG_proc, "gl843_slow_back_home (wait_until_home = %d)\n", DBG (DBG_proc, "gl843_slow_back_home (wait_until_home = %d)\n",
wait_until_home); wait_until_home);
if (dev->model->gpo_type == GPO_G4050)
{
/* test if we need to park XPA lamp, we check GPOADF */
RIE (sanei_genesys_read_register (dev, REG6B, &val));
if(val & REG6B_GPOADF)
{
RIE(gl843_park_xpa_lamp(dev));
}
}
/* regular slow back home */
dev->scanhead_position_in_steps = 0; dev->scanhead_position_in_steps = 0;
/* first read gives HOME_SENSOR true */ /* first read gives HOME_SENSOR true */
status = sanei_genesys_get_status (dev, &val); status = sanei_genesys_get_status (dev, &val);
if (status != SANE_STATUS_GOOD) if (status != SANE_STATUS_GOOD)
{ {
DBG (DBG_error, DBG (DBG_error, "%s: failed to read home sensor: %s\n", __FUNCTION__, sane_strstatus (status));
"gl124_slow_back_home: failed to read home sensor: %s\n",
sane_strstatus (status));
return status; return status;
} }
usleep (100000); /* sleep 100 ms */ usleep (100000); /* sleep 100 ms */
@ -2384,7 +2575,7 @@ gl843_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
return SANE_STATUS_IO_ERROR; return SANE_STATUS_IO_ERROR;
} }
DBG (DBG_info, "gl124_slow_back_home: scanhead is still moving\n"); DBG (DBG_info, "%s: scanhead is still moving\n", __FUNCTION__);
DBGCOMPLETED; DBGCOMPLETED;
return SANE_STATUS_GOOD; return SANE_STATUS_GOOD;
} }
@ -2609,9 +2800,6 @@ gl843_feed (Genesys_Device * dev, unsigned int steps)
SCAN_FLAG_DISABLE_GAMMA | SCAN_FLAG_DISABLE_GAMMA |
SCAN_FLAG_FEEDING | SCAN_FLAG_FEEDING |
SCAN_FLAG_IGNORE_LINE_DISTANCE); SCAN_FLAG_IGNORE_LINE_DISTANCE);
sanei_genesys_set_triple(local_reg,REG_EXPR,0);
sanei_genesys_set_triple(local_reg,REG_EXPG,0);
sanei_genesys_set_triple(local_reg,REG_EXPB,0);
/* clear scan and feed count */ /* clear scan and feed count */
RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRLNCNT)); RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRLNCNT));
@ -3800,6 +3988,31 @@ gl843_update_hardware_sensors (Genesys_Scanner * s)
return status; return status;
} }
#ifndef UNIT_TESTING
static
#endif
SANE_Status
gl843_move_to_ta (Genesys_Device * dev)
{
SANE_Status status = SANE_STATUS_GOOD;
float resolution;
unsigned int feed;
DBGSTART;
resolution=sanei_genesys_get_lowest_ydpi(dev);
feed = 16*(SANE_UNFIX (dev->model->y_offset_calib_ta) * resolution) / MM_PER_INCH;
status = gl843_feed (dev, feed);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to move to XPA calibration area\n", __FUNCTION__);
return status;
}
DBGCOMPLETED;
return status;
}
/** @brief search for a full width black or white strip. /** @brief search for a full width black or white strip.
* This function searches for a black or white stripe across the scanning area. * This function searches for a black or white stripe across the scanning area.
@ -4251,7 +4464,7 @@ static Genesys_Command_Set gl843_cmd_set = {
gl843_search_strip, gl843_search_strip,
sanei_genesys_is_compatible_calibration, sanei_genesys_is_compatible_calibration,
NULL, gl843_move_to_ta,
gl843_send_shading_data, gl843_send_shading_data,
gl843_calculate_current_setup gl843_calculate_current_setup
}; };

58
backend/genesys_gl843.h
Wyświetl plik

File diff suppressed because one or more lines are too long

3
backend/genesys_gl847.c
Wyświetl plik

@ -42,6 +42,9 @@
If you do not wish that, delete this exception notice. If you do not wish that, delete this exception notice.
*/ */
#undef BACKEND_NAME
#define BACKEND_NAME genesys_gl847
#include "genesys_gl847.h" #include "genesys_gl847.h"
/**************************************************************************** /****************************************************************************

3
backend/genesys_gl847.h
Wyświetl plik

@ -41,9 +41,6 @@
If you do not wish that, delete this exception notice. If you do not wish that, delete this exception notice.
*/ */
#undef BACKEND_NAME
#define BACKEND_NAME genesys_gl847
#include "genesys.h" #include "genesys.h"
#define REG01 0x01 #define REG01 0x01

19
backend/genesys_low.c
Wyświetl plik

@ -41,28 +41,9 @@
whether to permit this exception to apply to your modifications. whether to permit this exception to apply to your modifications.
If you do not wish that, delete this exception notice. If you do not wish that, delete this exception notice.
*/ */
#include "../include/sane/config.h"
#include <errno.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <math.h>
#include "../include/sane/sane.h"
#include "../include/sane/sanei.h"
#include "../include/sane/saneopts.h"
#ifndef HACK
#undef BACKEND_NAME #undef BACKEND_NAME
#define BACKEND_NAME genesys_low #define BACKEND_NAME genesys_low
#endif
#include "../include/sane/sanei_backend.h"
#include "../include/sane/sanei_config.h"
#include "../include/sane/sanei_usb.h"
#include "../include/_stdint.h"
#include "genesys_low.h" #include "genesys_low.h"
/* ------------------------------------------------------------------------ */ /* ------------------------------------------------------------------------ */

47
backend/genesys_low.h
Wyświetl plik

@ -67,6 +67,10 @@
#ifdef HAVE_SYS_TYPES_H #ifdef HAVE_SYS_TYPES_H
#include <sys/types.h> #include <sys/types.h>
#endif #endif
#ifdef HAVE_MKDIR
#include <sys/stat.h>
#include <sys/types.h>
#endif
#include "../include/sane/sane.h" #include "../include/sane/sane.h"
#include "../include/sane/sanei.h" #include "../include/sane/sanei.h"
@ -115,7 +119,7 @@
#define GENESYS_FLAG_MUST_WAIT (1 << 10) /**> tells wether the scanner must wait for the head when parking */ #define GENESYS_FLAG_MUST_WAIT (1 << 10) /**> tells wether the scanner must wait for the head when parking */
#define GENESYS_FLAG_ALT_SLOPE_CREATE (1 << 11) /**> use alternative slope creation function */ #define GENESYS_FLAG_HAS_UTA (1 << 11) /**> scanner has a transparency adapter */
#define GENESYS_FLAG_DARK_WHITE_CALIBRATION (1 << 12) /**> yet another calibration method. does white and dark shading in one run, depending on a black and a white strip*/ #define GENESYS_FLAG_DARK_WHITE_CALIBRATION (1 << 12) /**> yet another calibration method. does white and dark shading in one run, depending on a black and a white strip*/
#define GENESYS_FLAG_CUSTOM_GAMMA (1 << 13) /**> allow custom gamma tables */ #define GENESYS_FLAG_CUSTOM_GAMMA (1 << 13) /**> allow custom gamma tables */
@ -744,27 +748,30 @@ typedef struct {
#define FAST_TABLE 3 /* table 4 at 0x5800 for gl124 */ #define FAST_TABLE 3 /* table 4 at 0x5800 for gl124 */
#define HOME_TABLE 4 /* table 5 at 0x6000 for gl124 */ #define HOME_TABLE 4 /* table 5 at 0x6000 for gl124 */
#define SCAN_FLAG_SINGLE_LINE 0x001 #define SCAN_FLAG_SINGLE_LINE 0x001
#define SCAN_FLAG_DISABLE_SHADING 0x002 #define SCAN_FLAG_DISABLE_SHADING 0x002
#define SCAN_FLAG_DISABLE_GAMMA 0x004 #define SCAN_FLAG_DISABLE_GAMMA 0x004
#define SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE 0x008 #define SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE 0x008
#define SCAN_FLAG_IGNORE_LINE_DISTANCE 0x010 #define SCAN_FLAG_IGNORE_LINE_DISTANCE 0x010
#define SCAN_FLAG_USE_OPTICAL_RES 0x020 #define SCAN_FLAG_USE_OPTICAL_RES 0x020
#define SCAN_FLAG_DISABLE_LAMP 0x040 #define SCAN_FLAG_DISABLE_LAMP 0x040
#define SCAN_FLAG_DYNAMIC_LINEART 0x080 #define SCAN_FLAG_DYNAMIC_LINEART 0x080
#define SCAN_FLAG_CALIBRATION 0x100 #define SCAN_FLAG_CALIBRATION 0x100
#define SCAN_FLAG_FEEDING 0x200 #define SCAN_FLAG_FEEDING 0x200
#define SCAN_FLAG_USE_XPA 0x400
#define MOTOR_FLAG_AUTO_GO_HOME 1 #define MOTOR_FLAG_AUTO_GO_HOME 0x01
#define MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE 2 #define MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE 0x02
#define MOTOR_FLAG_FEED 4 #define MOTOR_FLAG_FEED 0x04
#define MOTOR_FLAG_USE_XPA 0x08
#define OPTICAL_FLAG_DISABLE_GAMMA 1 #define OPTICAL_FLAG_DISABLE_GAMMA 0x01
#define OPTICAL_FLAG_DISABLE_SHADING 2 #define OPTICAL_FLAG_DISABLE_SHADING 0x02
#define OPTICAL_FLAG_DISABLE_LAMP 4 #define OPTICAL_FLAG_DISABLE_LAMP 0x04
#define OPTICAL_FLAG_ENABLE_LEDADD 8 #define OPTICAL_FLAG_ENABLE_LEDADD 0x08
#define OPTICAL_FLAG_DISABLE_DOUBLE 16 #define OPTICAL_FLAG_DISABLE_DOUBLE 0x10
#define OPTICAL_FLAG_STAGGER 32 #define OPTICAL_FLAG_STAGGER 0x20
#define OPTICAL_FLAG_USE_XPA 0x40
/*--------------------------------------------------------------------------*/ /*--------------------------------------------------------------------------*/
/* common functions needed by low level specific functions */ /* common functions needed by low level specific functions */

8
doc/descriptions/genesys.desc
Wyświetl plik

@ -74,7 +74,13 @@
:interface "USB" :interface "USB"
:usbid "0x03f0" "0x1405" :usbid "0x03f0" "0x1405"
:status :complete :status :complete
:comment "1200x1200 dpi max, same as HP3670C" :comment "1200x1200 dpi max, same as HP 3670C"
:model "ScanJet 4850C"
:interface "USB"
:usbid "0x03f0" "0x1b05"
:status :untested
:comment "resolution from 100 to 2400 supported, UTA not supported yet"
:model "ScanJet G4010" :model "ScanJet G4010"
:interface "USB" :interface "USB"