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

genesys: Cache physical register state in the device on reads

merge-requests/111/head
Povilas Kanapickas 2019-08-02 22:38:58 +03:00
rodzic 5bd9ab4941
commit 6014645664
10 zmienionych plików z 219 dodań i 247 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

17
backend/genesys_device.cc
Wyświetl plik

@ -72,6 +72,23 @@ void Genesys_Device::clear()
dark_average_data.clear();
}
uint8_t Genesys_Device::read_register(uint16_t address)
{
uint8_t value;
sanei_genesys_read_register(this, address, &value);
update_register_state(address, value);
return value;
}
void Genesys_Device::update_register_state(uint16_t address, uint8_t value)
{
if (physical_regs.has_reg(address)) {
physical_regs.set8(address, value);
} else {
physical_regs.init_reg(address, value);
}
}
void apply_reg_settings_to_device(Genesys_Device& dev, const GenesysRegisterSettingSet& regs)
{
for (const auto& reg : regs) {

8
backend/genesys_device.h
Wyświetl plik

@ -331,6 +331,14 @@ struct Genesys_Device
// binary logger file
FILE *binary = nullptr;
// A snapshot of the last known physical state of the device registers. This variable is updated
// whenever a register is written or read to the scanner.
Genesys_Register_Set physical_regs;
uint8_t read_register(uint16_t address);
private:
void update_register_state(uint16_t address, uint8_t value);
};
void apply_reg_settings_to_device(Genesys_Device& dev, const GenesysRegisterSettingSet& regs);

50
backend/genesys_gl124.cc
Wyświetl plik

@ -152,9 +152,8 @@ static Sensor_Profile *get_sensor_profile(int sensor_type, int dpi, int half_ccd
static void gl124_homsnr_gpio(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val;
sanei_genesys_read_register(dev, REG32, &val);
uint8_t val = dev->read_register(REG32);
val &= ~REG32_GPIO10;
sanei_genesys_write_register(dev, REG32, val);
}
@ -585,7 +584,7 @@ static void gl124_set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor, uint
dev->frontend = dev->frontend_initial;
}
sanei_genesys_read_register(dev, REG0A, &val);
val = dev->read_register(REG0A);
/* route to correct analog FE */
switch ((val & REG0A_SIFSEL)>>REG0AS_SIFSEL)
@ -1530,7 +1529,7 @@ static void gl124_stop_action(Genesys_Device* dev)
sanei_genesys_print_status (val);
}
sanei_genesys_read_register(dev, REG100, &val40);
val40 = dev->read_register(REG100);
/* only stop action if needed */
if (!(val40 & REG100_DATAENB) && !(val40 & REG100_MOTMFLG))
@ -1555,7 +1554,7 @@ static void gl124_stop_action(Genesys_Device* dev)
{
sanei_genesys_print_status (val);
}
sanei_genesys_read_register(dev, REG100, &val40);
val40 = dev->read_register(REG100);
/* if scanner is in command mode, we are done */
if (!(val40 & REG100_DATAENB) && !(val40 & REG100_MOTMFLG)
@ -1580,10 +1579,9 @@ static void gl124_stop_action(Genesys_Device* dev)
*/
static void gl124_setup_scan_gpio(Genesys_Device* dev, int resolution)
{
uint8_t val;
DBG_HELPER(dbg);
sanei_genesys_read_register(dev, REG32, &val);
uint8_t val = dev->read_register(REG32);
/* LiDE 110, 210 and 220 cases */
if(dev->model->gpo_type != GPO_CANONLIDE120)
@ -1635,8 +1633,6 @@ static void gl124_begin_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
(void) sensor;
(void) reg;
uint8_t val;
// set up GPIO for scan
gl124_setup_scan_gpio(dev,dev->settings.yres);
@ -1644,7 +1640,7 @@ static void gl124_begin_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
sanei_genesys_write_register(dev, REG0D, REG0D_CLRLNCNT | REG0D_CLRMCNT);
// enable scan and motor
sanei_genesys_read_register(dev, REG01, &val);
uint8_t val = dev->read_register(REG01);
val |= REG01_SCAN;
sanei_genesys_write_register(dev, REG01, val);
@ -1675,10 +1671,9 @@ static void gl124_end_scan(Genesys_Device* dev, Genesys_Register_Set* reg, SANE_
static void gl124_rewind(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t byte;
// set motor reverse
sanei_genesys_read_register(dev, 0x02, &byte);
uint8_t byte = dev->read_register(0x02);
byte |= 0x04;
sanei_genesys_write_register(dev, 0x02, byte);
@ -1689,13 +1684,13 @@ static void gl124_rewind(Genesys_Device* dev)
do
{
sanei_genesys_sleep_ms(100);
sanei_genesys_read_register(dev, REG100, &byte);
byte = dev->read_register(REG100);
}
while(byte & REG100_MOTMFLG);
gl124_end_scan(dev, &dev->reg, SANE_TRUE);
// restore direction
sanei_genesys_read_register(dev, 0x02, &byte);
byte = dev->read_register(0x02);
byte &= 0xfb;
sanei_genesys_write_register(dev, 0x02, byte);
}
@ -2095,10 +2090,10 @@ static void gl124_init_regs_for_shading(Genesys_Device* dev, const Genesys_Senso
static void gl124_wait_for_motor_stop(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val40, val;
uint8_t val;
sanei_genesys_get_status(dev, &val);
sanei_genesys_read_register(dev, REG100, &val40);
uint8_t val40 = dev->read_register(REG100);
if ((val & MOTORENB) == 0 && (val40 & REG100_MOTMFLG) == 0)
return;
@ -2106,7 +2101,7 @@ static void gl124_wait_for_motor_stop(Genesys_Device* dev)
do {
sanei_genesys_sleep_ms(10);
sanei_genesys_get_status(dev, &val);
sanei_genesys_read_register(dev, REG100, &val40);
val40 = dev->read_register(REG100);
} while ((val & MOTORENB) ||(val40 & REG100_MOTMFLG));
sanei_genesys_sleep_ms(50);
}
@ -2196,7 +2191,7 @@ static void gl124_send_shading_data(Genesys_Device* dev, const Genesys_Sensor& s
uint32_t addr, length, strpixel ,endpixel, x, factor, segcnt, pixels, i;
uint32_t lines, channels;
uint16_t dpiset,dpihw;
uint8_t val,*ptr,*src;
uint8_t *ptr, *src;
/* logical size of a color as seen by generic code of the frontend */
length = (uint32_t) (size / 3);
@ -2291,7 +2286,7 @@ static void gl124_send_shading_data(Genesys_Device* dev, const Genesys_Sensor& s
/* next shading coefficient */
ptr+=4;
}
sanei_genesys_read_register(dev, 0xd0+i, &val);
uint8_t val = dev->read_register(0xd0+i);
addr = val * 8192 + 0x10000000;
sanei_genesys_write_ahb(dev, addr, pixels*dev->segnb, buffer.data());
}
@ -2546,14 +2541,13 @@ static void gl124_offset_calibration(Genesys_Device* dev, const Genesys_Sensor&
Genesys_Register_Set& regs)
{
DBG_HELPER(dbg);
uint8_t reg0a;
unsigned int channels, bpp;
int pass = 0, avg, total_size;
int topavg, bottomavg, resolution, lines;
int top, bottom, black_pixels, pixels;
// no gain nor offset for TI AFE
sanei_genesys_read_register(dev, REG0A, &reg0a);
uint8_t reg0a = dev->read_register(REG0A);
if(((reg0a & REG0A_SIFSEL)>>REG0AS_SIFSEL)==3)
{
return;
@ -2697,7 +2691,6 @@ static void gl124_coarse_gain_calibration(Genesys_Device* dev, const Genesys_Sen
DBG_HELPER_ARGS(dbg, "dpi = %d", dpi);
int pixels;
int total_size;
uint8_t reg0a;
int i, j, channels;
int max[3];
float gain[3],coeff;
@ -2706,7 +2699,7 @@ static void gl124_coarse_gain_calibration(Genesys_Device* dev, const Genesys_Sen
int bpp;
// no gain nor offset for TI AFE
sanei_genesys_read_register(dev, REG0A, &reg0a);
uint8_t reg0a = dev->read_register(REG0A);
if(((reg0a & REG0A_SIFSEL)>>REG0AS_SIFSEL)==3)
{
return;
@ -2990,7 +2983,6 @@ static void gl124_init(Genesys_Device* dev)
static void gl124_boot(Genesys_Device* dev, SANE_Bool cold)
{
DBG_HELPER(dbg);
uint8_t val;
// reset ASIC in case of cold boot
if (cold) {
@ -3002,14 +2994,14 @@ static void gl124_boot(Genesys_Device* dev, SANE_Bool cold)
sanei_genesys_write_register(dev, 0x36, 0x01);
// set GPIO 17
sanei_genesys_read_register(dev, 0x33, &val);
uint8_t val = dev->read_register(0x33);
val |= 0x01;
sanei_genesys_write_register(dev, 0x33, val);
// test CHKVER
sanei_genesys_read_register(dev, REG100, &val);
val = dev->read_register(REG100);
if (val & REG100_CHKVER) {
sanei_genesys_read_register(dev, 0x00, &val);
val = dev->read_register(0x00);
DBG(DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __func__, val);
}
@ -3046,9 +3038,7 @@ static void gl124_update_hardware_sensors(Genesys_Scanner* s)
any of them.
*/
DBG_HELPER(dbg);
uint8_t val = 0;
sanei_genesys_read_register(s->dev, REG31, &val);
uint8_t val = s->dev->read_register(REG31);
/* TODO : for the next scanner special case,
* add another per scanner button profile struct to avoid growing

5
backend/genesys_gl646.cc
Wyświetl plik

@ -1024,7 +1024,6 @@ gl646_setup_sensor (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_
static void gl646_asic_test(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val;
size_t size, verify_size;
unsigned int i;
@ -1033,14 +1032,14 @@ static void gl646_asic_test(Genesys_Device* dev)
sanei_genesys_write_register(dev, 0x39, 0xad);
sanei_genesys_read_register(dev, 0x4e, &val);
uint8_t val = dev->read_register(0x4e);
if (val != 0xde) /* value of register 0x38 */
{
throw SaneException("register contains invalid value");
}
sanei_genesys_read_register(dev, 0x4f, &val);
val = dev->read_register(0x4f);
if (val != 0xad) /* value of register 0x39 */
{

77
backend/genesys_gl841.cc
Wyświetl plik

@ -292,7 +292,6 @@ static void sanei_gl841_asic_test(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val;
size_t size, verify_size;
unsigned int i;
@ -302,14 +301,14 @@ static void sanei_gl841_asic_test(Genesys_Device* dev)
sanei_genesys_write_register(dev, 0x38, 0xde);
sanei_genesys_write_register(dev, 0x39, 0xad);
sanei_genesys_read_register(dev, 0x38, &val);
uint8_t val = dev->read_register(0x38);
if (val != 0xde) /* value of register 0x38 */
{
throw SaneException("register contains invalid value");
}
sanei_genesys_read_register(dev, 0x39, &val);
val = dev->read_register(0x39);
if (val != 0xad) /* value of register 0x39 */
{
@ -483,28 +482,30 @@ gl841_init_lide80 (Genesys_Device * dev)
INITREG (0x88, 0x00);
INITREG (0x89, 0x00);
/* specific scanner settings, clock and gpio first */
sanei_genesys_read_register (dev, REG6B, &val);
// specific scanner settings, clock and gpio first
val = dev->read_register(REG6B);
sanei_genesys_write_register (dev, REG6B, 0x0c);
sanei_genesys_write_register (dev, 0x06, 0x10);
sanei_genesys_write_register (dev, REG6E, 0x6d);
sanei_genesys_write_register (dev, REG6F, 0x80);
sanei_genesys_write_register (dev, REG6B, 0x0e);
sanei_genesys_read_register (dev, REG6C, &val);
val = dev->read_register(REG6C);
sanei_genesys_write_register (dev, REG6C, 0x00);
sanei_genesys_read_register (dev, REG6D, &val);
val = dev->read_register(REG6D);
sanei_genesys_write_register (dev, REG6D, 0x8f);
sanei_genesys_read_register (dev, REG6B, &val);
val = dev->read_register(REG6B);
sanei_genesys_write_register (dev, REG6B, 0x0e);
sanei_genesys_read_register (dev, REG6B, &val);
val = dev->read_register(REG6B);
sanei_genesys_write_register (dev, REG6B, 0x0e);
sanei_genesys_read_register (dev, REG6B, &val);
val = dev->read_register(REG6B);
sanei_genesys_write_register (dev, REG6B, 0x0a);
sanei_genesys_read_register (dev, REG6B, &val);
val = dev->read_register(REG6B);
sanei_genesys_write_register (dev, REG6B, 0x02);
sanei_genesys_read_register (dev, REG6B, &val);
val = dev->read_register(REG6B);
sanei_genesys_write_register (dev, REG6B, 0x06);
(void) val; // FIXME: we don't use the information read from registers
sanei_genesys_write_0x8c(dev, 0x10, 0x94);
sanei_genesys_write_register (dev, 0x09, 0x10);
@ -2288,7 +2289,6 @@ dummy \ scanned lines
static void gl841_save_power(Genesys_Device* dev, SANE_Bool enable)
{
DBG_HELPER_ARGS(dbg, "enable = %d", enable);
uint8_t val;
const auto& sensor = sanei_genesys_find_sensor_any(dev);
@ -2301,32 +2301,32 @@ static void gl841_save_power(Genesys_Device* dev, SANE_Bool enable)
/* final state: GPIO8 disabled, GPIO9 enabled, GPIO17 disabled,
GPIO18 disabled*/
sanei_genesys_read_register(dev, REG6D, &val);
uint8_t val = dev->read_register(REG6D);
sanei_genesys_write_register(dev, REG6D, val | 0x80);
sanei_genesys_sleep_ms(1);
/*enable GPIO9*/
sanei_genesys_read_register(dev, REG6C, &val);
val = dev->read_register(REG6C);
sanei_genesys_write_register(dev, REG6C, val | 0x01);
/*disable GPO17*/
sanei_genesys_read_register(dev, REG6B, &val);
val = dev->read_register(REG6B);
sanei_genesys_write_register(dev, REG6B, val & ~REG6B_GPO17);
/*disable GPO18*/
sanei_genesys_read_register(dev, REG6B, &val);
val = dev->read_register(REG6B);
sanei_genesys_write_register(dev, REG6B, val & ~REG6B_GPO18);
sanei_genesys_sleep_ms(1);
sanei_genesys_read_register(dev, REG6D, &val);
val = dev->read_register(REG6D);
sanei_genesys_write_register(dev, REG6D, val & ~0x80);
}
if (dev->model->gpo_type == GPO_DP685)
{
sanei_genesys_read_register(dev, REG6B, &val);
uint8_t val = dev->read_register(REG6B);
sanei_genesys_write_register(dev, REG6B, val & ~REG6B_GPO17);
dev->reg.find_reg(0x6b).value &= ~REG6B_GPO17;
dev->calib_reg.find_reg(0x6b).value &= ~REG6B_GPO17;
@ -2344,27 +2344,27 @@ static void gl841_save_power(Genesys_Device* dev, SANE_Bool enable)
/* final state: GPIO8 enabled, GPIO9 disabled, GPIO17 enabled,
GPIO18 enabled*/
sanei_genesys_read_register(dev, REG6D, &val);
uint8_t val = dev->read_register(REG6D);
sanei_genesys_write_register(dev, REG6D, val | 0x80);
sanei_genesys_sleep_ms(10);
/*disable GPIO9*/
sanei_genesys_read_register(dev, REG6C, &val);
val = dev->read_register(REG6C);
sanei_genesys_write_register(dev, REG6C, val & ~0x01);
/*enable GPIO10*/
sanei_genesys_read_register(dev, REG6C, &val);
val = dev->read_register(REG6C);
sanei_genesys_write_register(dev, REG6C, val | 0x02);
/*enable GPO17*/
sanei_genesys_read_register(dev, REG6B, &val);
val = dev->read_register(REG6B);
sanei_genesys_write_register(dev, REG6B, val | REG6B_GPO17);
dev->reg.find_reg(0x6b).value |= REG6B_GPO17;
dev->calib_reg.find_reg(0x6b).value |= REG6B_GPO17;
/*enable GPO18*/
sanei_genesys_read_register(dev, REG6B, &val);
val = dev->read_register(REG6B);
sanei_genesys_write_register(dev, REG6B, val | REG6B_GPO18);
dev->reg.find_reg(0x6b).value |= REG6B_GPO18;
dev->calib_reg.find_reg(0x6b).value |= REG6B_GPO18;
@ -2373,7 +2373,7 @@ static void gl841_save_power(Genesys_Device* dev, SANE_Bool enable)
if (dev->model->gpo_type == GPO_DP665
|| dev->model->gpo_type == GPO_DP685)
{
sanei_genesys_read_register(dev, REG6B, &val);
uint8_t val = dev->read_register(REG6B);
sanei_genesys_write_register(dev, REG6B, val | REG6B_GPO17);
dev->reg.find_reg(0x6b).value |= REG6B_GPO17;
dev->calib_reg.find_reg(0x6b).value |= REG6B_GPO17;
@ -2457,7 +2457,7 @@ static void gl841_stop_action(Genesys_Device* dev)
{
DBG_HELPER(dbg);
Genesys_Register_Set local_reg;
uint8_t val40, val;
uint8_t val;
unsigned int loop;
sanei_genesys_get_status(dev, &val);
@ -2466,7 +2466,7 @@ static void gl841_stop_action(Genesys_Device* dev)
sanei_genesys_print_status (val);
}
sanei_genesys_read_register(dev, 0x40, &val40);
uint8_t val40 = dev->read_register(0x40);
/* only stop action if needed */
if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG))
@ -2488,7 +2488,7 @@ static void gl841_stop_action(Genesys_Device* dev)
loop = 10;
while (loop > 0) {
sanei_genesys_read_register(dev, 0x40, &val40);
val40 = dev->read_register(0x40);
if (DBG_LEVEL >= DBG_io) {
sanei_genesys_print_status(val);
}
@ -2509,9 +2509,8 @@ static void gl841_stop_action(Genesys_Device* dev)
static void gl841_get_paper_sensor(Genesys_Device* dev, SANE_Bool * paper_loaded)
{
DBG_HELPER(dbg);
uint8_t val;
sanei_genesys_read_register(dev, REG6D, &val);
uint8_t val = dev->read_register(REG6D);
*paper_loaded = (val & 0x1) == 0;
}
@ -2701,11 +2700,11 @@ static void gl841_detect_document_end(Genesys_Device* dev)
}
DBG(DBG_io, "%s: scancnt=%u lines\n", __func__, scancnt);
sanei_genesys_read_register(dev, 0x25, &val);
val = dev->read_register(0x25);
lincnt = 65536 * val;
sanei_genesys_read_register(dev, 0x26, &val);
val = dev->read_register(0x26);
lincnt += 256 * val;
sanei_genesys_read_register(dev, 0x27, &val);
val = dev->read_register(0x27);
lincnt += val;
DBG(DBG_io, "%s: lincnt=%u lines\n", __func__, lincnt);
postcnt = (SANE_UNFIX(dev->model->post_scan)/MM_PER_INCH) * dev->settings.yres;
@ -2740,7 +2739,7 @@ static void gl841_begin_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
uint8_t val;
if (dev->model->gpo_type == GPO_CANONLIDE80) {
sanei_genesys_read_register(dev, REG6B, &val);
val = dev->read_register(REG6B);
val = REG6B_GPO18;
sanei_genesys_write_register(dev, REG6B, val);
}
@ -2837,7 +2836,6 @@ static void gl841_slow_back_home(Genesys_Device* dev, SANE_Bool wait_until_home)
DBG_HELPER_ARGS(dbg, "wait_until_home = %d", wait_until_home);
Genesys_Register_Set local_reg;
GenesysRegister *r;
uint8_t val;
int loop = 0;
if (dev->model->is_sheetfed == SANE_TRUE)
@ -2848,13 +2846,14 @@ static void gl841_slow_back_home(Genesys_Device* dev, SANE_Bool wait_until_home)
}
// reset gpio pin
uint8_t val;
if (dev->model->gpo_type == GPO_CANONLIDE35) {
sanei_genesys_read_register(dev, REG6C, &val);
val = dev->read_register(REG6C);
val = dev->gpo.value[0];
sanei_genesys_write_register(dev, REG6C, val);
}
if (dev->model->gpo_type == GPO_CANONLIDE80) {
sanei_genesys_read_register(dev, REG6B, &val);
val = dev->read_register(REG6B);
val = REG6B_GPO18 | REG6B_GPO17;
sanei_genesys_write_register(dev, REG6B, val);
}
@ -4325,7 +4324,7 @@ static void gl841_update_hardware_sensors(Genesys_Scanner* s)
if (s->dev->model->gpo_type == GPO_CANONLIDE35
|| s->dev->model->gpo_type == GPO_CANONLIDE80)
{
sanei_genesys_read_register(s->dev, REG6D, &val);
val = s->dev->read_register(REG6D);
s->buttons[BUTTON_SCAN_SW].write((val & 0x01) == 0);
s->buttons[BUTTON_FILE_SW].write((val & 0x02) == 0);
s->buttons[BUTTON_EMAIL_SW].write((val & 0x04) == 0);
@ -4336,7 +4335,7 @@ static void gl841_update_hardware_sensors(Genesys_Scanner* s)
s->dev->model->gpo_type == GPO_DP665 ||
s->dev->model->gpo_type == GPO_DP685)
{
sanei_genesys_read_register(s->dev, REG6D, &val);
val = s->dev->read_register(REG6D);
s->buttons[BUTTON_PAGE_LOADED_SW].write((val & 0x01) == 0);
s->buttons[BUTTON_SCAN_SW].write((val & 0x02) == 0);

59
backend/genesys_gl843.cc
Wyświetl plik

@ -759,7 +759,6 @@ static void gl843_set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor, uint
set == AFE_SET ? "set" :
set == AFE_POWER_SAVE ? "powersave" : "huh?");
(void) sensor;
uint8_t val;
int i;
if (set == AFE_INIT)
@ -770,7 +769,7 @@ static void gl843_set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor, uint
// check analog frontend type
// FIXME: looks like we write to that register with initial data
sanei_genesys_read_register(dev, REG04, &val);
uint8_t val = dev->read_register(REG04);
if ((val & REG04_FESET) != 0x00)
{
// for now there is no support for AD fe
@ -1673,11 +1672,10 @@ gl843_calculate_current_setup(Genesys_Device * dev, const Genesys_Sensor& sensor
static void gl843_save_power(Genesys_Device* dev, SANE_Bool enable)
{
DBG_HELPER_ARGS(dbg, "enable = %d", enable);
uint8_t val;
// switch KV-SS080 lamp off
if (dev->model->gpo_type == GPO_KVSS080) {
sanei_genesys_read_register(dev, REG6C, &val);
uint8_t val = dev->read_register(REG6C);
if (enable) {
val &= 0xef;
} else {
@ -1712,7 +1710,7 @@ static void gl843_stop_action_no_move(Genesys_Device* dev, Genesys_Register_Set*
static void gl843_stop_action(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val40, val;
uint8_t val;
unsigned int loop;
sanei_genesys_get_status(dev, &val);
@ -1721,8 +1719,7 @@ static void gl843_stop_action(Genesys_Device* dev)
sanei_genesys_print_status (val);
}
val40 = 0;
sanei_genesys_read_register(dev, REG40, &val40);
uint8_t val40 = dev->read_register(REG40);
/* only stop action if needed */
if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG))
@ -1747,8 +1744,7 @@ static void gl843_stop_action(Genesys_Device* dev)
{
sanei_genesys_print_status (val);
}
val40 = 0;
sanei_genesys_read_register(dev, 0x40, &val40);
val40 = dev->read_register(0x40);
/* if scanner is in command mode, we are done */
if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG)
@ -1767,9 +1763,8 @@ static void gl843_stop_action(Genesys_Device* dev)
static void gl843_get_paper_sensor(Genesys_Device* dev, SANE_Bool * paper_loaded)
{
DBG_HELPER(dbg);
uint8_t val;
sanei_genesys_read_register(dev, REG6D, &val);
uint8_t val = dev->read_register(REG6D);
*paper_loaded = (val & 0x1) == 0;
}
@ -1917,47 +1912,47 @@ static void gl843_set_xpa_motor_power(Genesys_Device* dev, bool set)
if (dev->model->model_id == MODEL_CANON_CANOSCAN_8400F) {
if (set) {
sanei_genesys_read_register(dev, 0x6c, &val);
val = dev->read_register(0x6c);
val &= ~(REG6C_GPIO16 | REG6C_GPIO13);
if (dev->current_setup.xres >= 2400) {
val &= ~REG6C_GPIO10;
}
sanei_genesys_write_register(dev, 0x6c, val);
sanei_genesys_read_register(dev, 0xa9, &val);
val = dev->read_register(0xa9);
val |= REGA9_GPO30;
val &= ~REGA9_GPO29;
sanei_genesys_write_register(dev, 0xa9, val);
} else {
sanei_genesys_read_register(dev, 0x6c, &val);
val = dev->read_register(0x6c);
val |= REG6C_GPIO16 | REG6C_GPIO13;
sanei_genesys_write_register(dev, 0x6c, val);
sanei_genesys_read_register(dev, 0xa9, &val);
val = dev->read_register(0xa9);
val &= ~REGA9_GPO30;
val |= REGA9_GPO29;
sanei_genesys_write_register(dev, 0xa9, val);
}
} else if (dev->model->model_id == MODEL_CANON_CANOSCAN_8600F) {
if (set) {
sanei_genesys_read_register(dev, REG6C, &val);
val = dev->read_register(REG6C);
val &= ~REG6C_GPIO14;
if (dev->current_setup.xres >= 2400) {
val |= REG6C_GPIO10;
}
sanei_genesys_write_register(dev, REG6C, val);
sanei_genesys_read_register(dev, REGA6, &val);
val = dev->read_register(REGA6);
val |= REGA6_GPIO17;
val &= ~REGA6_GPIO23;
sanei_genesys_write_register(dev, REGA6, val);
} else {
sanei_genesys_read_register(dev, REG6C, &val);
val = dev->read_register(REG6C);
val |= REG6C_GPIO14;
val &= ~REG6C_GPIO10;
sanei_genesys_write_register(dev, REG6C, val);
sanei_genesys_read_register(dev, REGA6, &val);
val = dev->read_register(REGA6);
val &= ~REGA6_GPIO17;
val &= ~REGA6_GPIO23;
sanei_genesys_write_register(dev, REGA6, val);
@ -1965,37 +1960,37 @@ static void gl843_set_xpa_motor_power(Genesys_Device* dev, bool set)
} else if (dev->model->model_id == MODEL_HP_SCANJET_G4050) {
if (set) {
// set MULTFILM et GPOADF
sanei_genesys_read_register(dev, REG6B, &val);
val = dev->read_register(REG6B);
val |=REG6B_MULTFILM|REG6B_GPOADF;
sanei_genesys_write_register(dev, REG6B, val);
sanei_genesys_read_register(dev, REG6C, &val);
val = dev->read_register(REG6C);
val &= ~REG6C_GPIO15;
sanei_genesys_write_register(dev, REG6C, val);
/* Motor power ? No move at all without this one */
sanei_genesys_read_register(dev, REGA6, &val);
val = dev->read_register(REGA6);
val |= REGA6_GPIO20;
sanei_genesys_write_register(dev,REGA6,val);
sanei_genesys_read_register(dev, REGA8, &val);
val = dev->read_register(REGA8);
val &= ~REGA8_GPO27;
sanei_genesys_write_register(dev, REGA8, val);
sanei_genesys_read_register(dev, REGA9, &val);
val = dev->read_register(REGA9);
val |= REGA9_GPO32|REGA9_GPO31;
sanei_genesys_write_register(dev, REGA9, val);
} else {
// unset GPOADF
sanei_genesys_read_register(dev, REG6B, &val);
val = dev->read_register(REG6B);
val &= ~REG6B_GPOADF;
sanei_genesys_write_register(dev, REG6B, val);
sanei_genesys_read_register(dev, REGA8, &val);
val = dev->read_register(REGA8);
val |= REGA8_GPO27;
sanei_genesys_write_register(dev, REGA8, val);
sanei_genesys_read_register(dev, REGA9, &val);
val = dev->read_register(REGA9);
val &= ~REGA9_GPO31;
sanei_genesys_write_register(dev, REGA9, val);
}
@ -2084,7 +2079,6 @@ static void gl843_begin_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
Genesys_Register_Set* reg, SANE_Bool start_motor)
{
DBG_HELPER(dbg);
uint8_t val;
uint16_t dpiset, dpihw;
/* get back the target dpihw */
@ -2149,7 +2143,7 @@ static void gl843_begin_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
sanei_genesys_write_register(dev, REG0D, REG0D_CLRLNCNT | REG0D_CLRMCNT);
// enable scan and motor
sanei_genesys_read_register(dev, REG01, &val);
uint8_t val = dev->read_register(REG01);
val |= REG01_SCAN;
sanei_genesys_write_register(dev, REG01, val);
@ -3520,9 +3514,9 @@ static void gl843_boot(Genesys_Device* dev, SANE_Bool cold)
sanei_genesys_write_0x8c(dev, 0x0f, val);
// test CHKVER
sanei_genesys_read_register(dev, REG40, &val);
val = dev->read_register(REG40);
if (val & REG40_CHKVER) {
sanei_genesys_read_register(dev, 0x00, &val);
val = dev->read_register(0x00);
DBG(DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __func__, val);
}
@ -3607,9 +3601,8 @@ static void gl843_update_hardware_sensors(Genesys_Scanner* s)
/* do what is needed to get a new set of events, but try to not lose
any of them.
*/
uint8_t val;
sanei_genesys_read_register(s->dev, REG6D, &val);
uint8_t val = s->dev->read_register(REG6D);
switch (s->dev->model->gpo_type)
{

31
backend/genesys_gl846.cc
Wyświetl plik

@ -495,9 +495,8 @@ static void gl846_set_adi_fe(Genesys_Device* dev, uint8_t set)
static void gl846_homsnr_gpio(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val;
sanei_genesys_read_register(dev, REG6C, &val);
uint8_t val = dev->read_register(REG6C);
val |= 0x41;
sanei_genesys_write_register(dev, REG6C, val);
}
@ -664,7 +663,7 @@ static void gl846_init_motor_regs_scan(Genesys_Device* dev,
/* hi res motor speed GPIO */
/*
sanei_genesys_read_register(dev, REG6C, &effective);
uint8_t effective = dev->read_register(REG6C);
*/
/* if quarter step, bipolar Vref2 */
@ -689,7 +688,7 @@ static void gl846_init_motor_regs_scan(Genesys_Device* dev,
/* effective scan */
/*
sanei_genesys_read_register(dev, REG6C, &effective);
effective = dev->read_register(REG6C);
val = effective | REG6C_GPIO10;
sanei_genesys_write_register(dev, REG6C, val);
*/
@ -1360,7 +1359,7 @@ static void gl846_start_action(Genesys_Device* dev)
static void gl846_stop_action(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val40, val;
uint8_t val;
unsigned int loop;
// post scan gpio : without that HOMSNR is unreliable
@ -1371,7 +1370,7 @@ static void gl846_stop_action(Genesys_Device* dev)
sanei_genesys_print_status (val);
}
sanei_genesys_read_register(dev, REG40, &val40);
uint8_t val40 = dev->read_register(REG40);
/* only stop action if needed */
if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG))
@ -1395,7 +1394,7 @@ static void gl846_stop_action(Genesys_Device* dev)
{
sanei_genesys_print_status (val);
}
sanei_genesys_read_register(dev, REG40, &val40);
val40 = dev->read_register(REG40);
/* if scanner is in command mode, we are done */
if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG)
@ -1422,7 +1421,7 @@ static void gl846_begin_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
/* XXX STEF XXX SCAN GPIO */
/*
sanei_genesys_read_register(dev, REG6C, &val);
val = dev->read_register(REG6C);
sanei_genesys_write_register(dev, REG6C, val);
*/
@ -1431,7 +1430,7 @@ static void gl846_begin_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
val = REG0D_CLRMCNT;
sanei_genesys_write_register(dev, REG0D, val);
sanei_genesys_read_register(dev, REG01, &val);
val = dev->read_register(REG01);
val |= REG01_SCAN;
sanei_genesys_write_register(dev, REG01, val);
r = sanei_genesys_get_address (reg, REG01);
@ -2008,7 +2007,7 @@ static void gl846_send_shading_data(Genesys_Device* dev, const Genesys_Sensor& s
ptr+=4;
}
sanei_genesys_read_register(dev, 0xd0+i, &val);
val = dev->read_register(0xd0+i);
addr = val * 8192 + 0x10000000;
sanei_genesys_write_ahb(dev, addr, pixels, buffer.data());
}
@ -2269,9 +2268,9 @@ static void gl846_boot(Genesys_Device* dev, SANE_Bool cold)
sanei_genesys_write_0x8c(dev, 0x0f, val);
// test CHKVER
sanei_genesys_read_register(dev, REG40, &val);
val = dev->read_register(REG40);
if (val & REG40_CHKVER) {
sanei_genesys_read_register(dev, 0x00, &val);
val = dev->read_register(0x00);
DBG(DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __func__, val);
}
@ -2336,7 +2335,7 @@ static void gl846_update_hardware_sensors(Genesys_Scanner* s)
email=0x04;
copy=0x08;
}
sanei_genesys_read_register(s->dev, REG6D, &val);
val = s->dev->read_register(REG6D);
s->buttons[BUTTON_SCAN_SW].write((val & scan) == 0);
s->buttons[BUTTON_FILE_SW].write((val & file) == 0);
@ -2586,14 +2585,13 @@ static void gl846_offset_calibration(Genesys_Device* dev, const Genesys_Sensor&
Genesys_Register_Set& regs)
{
DBG_HELPER(dbg);
uint8_t reg04;
unsigned int channels, bpp;
int pass = 0, avg, total_size;
int topavg, bottomavg, resolution, lines;
int top, bottom, black_pixels, pixels;
// no gain nor offset for AKM AFE
sanei_genesys_read_register(dev, REG04, &reg04);
uint8_t reg04 = dev->read_register(REG04);
if ((reg04 & REG04_FESET) == 0x02)
{
return;
@ -2727,7 +2725,6 @@ static void gl846_coarse_gain_calibration(Genesys_Device* dev, const Genesys_Sen
DBG_HELPER(dbg);
int pixels;
int total_size;
uint8_t reg04;
int i, j, channels;
int max[3];
float gain[3],coeff;
@ -2738,7 +2735,7 @@ static void gl846_coarse_gain_calibration(Genesys_Device* dev, const Genesys_Sen
DBG(DBG_proc, "%s: dpi = %d\n", __func__, dpi);
// no gain nor offset for AKM AFE
sanei_genesys_read_register(dev, REG04, &reg04);
uint8_t reg04 = dev->read_register(REG04);
if ((reg04 & REG04_FESET) == 0x02)
{
return;

46
backend/genesys_gl847.cc
Wyświetl plik

@ -519,14 +519,14 @@ static void gl847_set_ad_fe(Genesys_Device* dev, uint8_t set)
static void gl847_homsnr_gpio(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val;
uint8_t val;
if (dev->model->gpo_type == GPO_CANONLIDE700) {
sanei_genesys_read_register(dev, REG6C, &val);
val = dev->read_register(REG6C);
val &= ~REG6C_GPIO10;
sanei_genesys_write_register(dev, REG6C, val);
} else {
sanei_genesys_read_register(dev, REG6C, &val);
val = dev->read_register(REG6C);
val |= REG6C_GPIO10;
sanei_genesys_write_register(dev, REG6C, val);
}
@ -541,8 +541,7 @@ static void gl847_set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor, uint
(void) sensor;
uint8_t val;
sanei_genesys_read_register(dev, REG04, &val);
uint8_t val = dev->read_register(REG04);
uint8_t frontend_type = val & REG04_FESET;
// route to AD devices
@ -581,7 +580,7 @@ static void gl847_init_motor_regs_scan(Genesys_Device* dev,
GenesysRegister *r;
uint32_t z1, z2;
unsigned int min_restep = 0x20;
uint8_t val, effective;
uint8_t val;
int fast_step_type;
unsigned int ccdlmt,tgtime;
@ -696,7 +695,7 @@ static void gl847_init_motor_regs_scan(Genesys_Device* dev,
tgtime=1<<(r->value & REG1C_TGTIME);
// hi res motor speed GPIO
sanei_genesys_read_register(dev, REG6C, &effective);
uint8_t effective = dev->read_register(REG6C);
/* if quarter step, bipolar Vref2 */
if (scan_step_type > 1)
@ -717,7 +716,7 @@ static void gl847_init_motor_regs_scan(Genesys_Device* dev,
sanei_genesys_write_register(dev, REG6C, val);
// effective scan
sanei_genesys_read_register(dev, REG6C, &effective);
effective = dev->read_register(REG6C);
val = effective | REG6C_GPIO10;
sanei_genesys_write_register(dev, REG6C, val);
@ -1377,7 +1376,7 @@ static void gl847_start_action(Genesys_Device* dev)
static void gl847_stop_action(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val40, val;
uint8_t val;
unsigned int loop;
// post scan gpio : without that HOMSNR is unreliable
@ -1388,7 +1387,7 @@ static void gl847_stop_action(Genesys_Device* dev)
sanei_genesys_print_status (val);
}
sanei_genesys_read_register(dev, REG40, &val40);
uint8_t val40 = dev->read_register(REG40);
/* only stop action if needed */
if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG))
@ -1413,7 +1412,7 @@ static void gl847_stop_action(Genesys_Device* dev)
{
sanei_genesys_print_status (val);
}
sanei_genesys_read_register(dev, REG40, &val40);
val40 = dev->read_register(REG40);
/* if scanner is in command mode, we are done */
if (!(val40 & REG40_DATAENB) && !(val40 & REG40_MOTMFLG)
@ -1440,7 +1439,7 @@ static void gl847_begin_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
// clear GPIO 10
if (dev->model->gpo_type != GPO_CANONLIDE700) {
sanei_genesys_read_register(dev, REG6C, &val);
val = dev->read_register(REG6C);
val &= ~REG6C_GPIO10;
sanei_genesys_write_register(dev, REG6C, val);
}
@ -1450,7 +1449,7 @@ static void gl847_begin_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
val = REG0D_CLRMCNT;
sanei_genesys_write_register(dev, REG0D, val);
sanei_genesys_read_register(dev, REG01, &val);
val = dev->read_register(REG01);
val |= REG01_SCAN;
sanei_genesys_write_register(dev, REG01, val);
r = sanei_genesys_get_address (reg, REG01);
@ -1487,7 +1486,7 @@ static void gl847_rewind(Genesys_Device* dev)
// set motor reverse
sanei_genesys_read_register(dev, 0x02, &byte);
uint8_t byte = dev->read_register(0x02);
byte |= 0x04;
sanei_genesys_write_register(dev, 0x02, byte);
@ -1496,13 +1495,13 @@ static void gl847_rewind(Genesys_Device* dev)
do
{
sanei_genesys_sleep_ms(100);
sanei_genesys_read_register(dev, REG40, &byte);
byte = dev->read_register(REG40);
}
while(byte & REG40_MOTMFLG);
gl847_end_scan(dev, dev->reg, SANE_TRUE);
// restore direction
sanei_genesys_read_register(dev, 0x02, &byte);
byte = dev->read_register(0x02);
byte &= 0xfb;
sanei_genesys_write_register(dev, 0x02, byte);
}
@ -2061,7 +2060,7 @@ static void gl847_send_shading_data(Genesys_Device* dev, const Genesys_Sensor& s
ptr+=4;
}
sanei_genesys_read_register(dev, 0xd0+i, &val);
val = dev->read_register(0xd0+i);
addr = val * 8192 + 0x10000000;
sanei_genesys_write_ahb(dev, addr, pixels, buffer.data());
}
@ -2352,7 +2351,6 @@ static void gl847_init_memory_layout(Genesys_Device* dev)
static void gl847_boot(Genesys_Device* dev, SANE_Bool cold)
{
DBG_HELPER(dbg);
uint8_t val;
// reset ASIC if cold boot
if (cold) {
@ -2361,9 +2359,9 @@ static void gl847_boot(Genesys_Device* dev, SANE_Bool cold)
}
// test CHKVER
sanei_genesys_read_register(dev, REG40, &val);
uint8_t val = dev->read_register(REG40);
if (val & REG40_CHKVER) {
sanei_genesys_read_register(dev, 0x00, &val);
val = dev->read_register(0x00);
DBG(DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __func__, val);
}
@ -2431,7 +2429,7 @@ static void gl847_update_hardware_sensors(Genesys_Scanner* s)
email=0x04;
copy=0x08;
}
sanei_genesys_read_register(s->dev, REG6D, &val);
val = s->dev->read_register(REG6D);
s->buttons[BUTTON_SCAN_SW].write((val & scan) == 0);
s->buttons[BUTTON_FILE_SW].write((val & file) == 0);
@ -2680,14 +2678,13 @@ static void gl847_offset_calibration(Genesys_Device* dev, const Genesys_Sensor&
Genesys_Register_Set& regs)
{
DBG_HELPER(dbg);
uint8_t reg04;
unsigned int channels, bpp;
int pass = 0, avg, total_size;
int topavg, bottomavg, resolution, lines;
int top, bottom, black_pixels, pixels;
// no gain nor offset for AKM AFE
sanei_genesys_read_register(dev, REG04, &reg04);
uint8_t reg04 = dev->read_register(REG04);
if ((reg04 & REG04_FESET) == 0x02)
{
return;
@ -2821,7 +2818,6 @@ static void gl847_coarse_gain_calibration(Genesys_Device* dev, const Genesys_Sen
DBG_HELPER_ARGS(dbg, "dpi = %d", dpi);
int pixels;
int total_size;
uint8_t reg04;
int i, j, channels;
int max[3];
float gain[3],coeff;
@ -2830,7 +2826,7 @@ static void gl847_coarse_gain_calibration(Genesys_Device* dev, const Genesys_Sen
int bpp;
// no gain nor offset for AKM AFE
sanei_genesys_read_register(dev, REG04, &reg04);
uint8_t reg04 = dev->read_register(REG04);
if ((reg04 & REG04_FESET) == 0x02)
{
return;

134
backend/genesys_low.cc
Wyświetl plik

@ -537,7 +537,6 @@ void sanei_genesys_set_buffer_address(Genesys_Device* dev, uint32_t addr)
void sanei_genesys_fe_read_data (Genesys_Device* dev, uint8_t addr, uint16_t* data)
{
DBG_HELPER(dbg);
uint8_t value;
Genesys_Register_Set reg;
reg.init_reg(0x50, addr);
@ -546,9 +545,9 @@ void sanei_genesys_fe_read_data (Genesys_Device* dev, uint8_t addr, uint16_t* da
dev->model->cmd_set->bulk_write_register(dev, reg);
// read data
sanei_genesys_read_register(dev, 0x46, &value);
uint8_t value = dev->read_register(0x46);
*data = 256 * value;
sanei_genesys_read_register(dev, 0x47, &value);
value = dev->read_register(0x47);
*data += value;
DBG(DBG_io, "%s (0x%02x, 0x%04x)\n", __func__, addr, *data);
@ -591,7 +590,7 @@ void sanei_genesys_get_status(Genesys_Device* dev, uint8_t* status)
sanei_genesys_read_hregister(dev, 0x101, status);
return;
}
sanei_genesys_read_register(dev, 0x41, status);
*status = dev->read_register(0x41);
}
/**
@ -656,54 +655,39 @@ genesys_dpiset (Genesys_Register_Set * reg)
void sanei_genesys_read_valid_words(Genesys_Device* dev, unsigned int* words)
{
DBG_HELPER(dbg);
uint8_t value;
switch (dev->model->asic_type)
{
case GENESYS_GL124:
sanei_genesys_read_hregister(dev, 0x102, &value);
*words = (value & 0x03);
sanei_genesys_read_hregister(dev, 0x103, &value);
*words = *words * 256 + value;
sanei_genesys_read_hregister(dev, 0x104, &value);
*words = *words * 256 + value;
sanei_genesys_read_hregister(dev, 0x105, &value);
*words = *words * 256 + value;
*words = dev->read_register(0x102) & 0x03;
*words = *words * 256 + dev->read_register(0x103);
*words = *words * 256 + dev->read_register(0x104);
*words = *words * 256 + dev->read_register(0x105);
break;
case GENESYS_GL845:
case GENESYS_GL846:
sanei_genesys_read_register(dev, 0x42, &value);
*words = value & 0x02;
sanei_genesys_read_register(dev, 0x43, &value);
*words = *words * 256 + value;
sanei_genesys_read_register(dev, 0x44, &value);
*words = *words * 256 + value;
sanei_genesys_read_register(dev, 0x45, &value);
*words = *words * 256 + value;
*words = dev->read_register(0x42) & 0x02;
*words = *words * 256 + dev->read_register(0x43);
*words = *words * 256 + dev->read_register(0x44);
*words = *words * 256 + dev->read_register(0x45);
break;
case GENESYS_GL847:
sanei_genesys_read_register(dev, 0x42, &value);
*words = value & 0x03;
sanei_genesys_read_register(dev, 0x43, &value);
*words = *words * 256 + value;
sanei_genesys_read_register(dev, 0x44, &value);
*words = *words * 256 + value;
sanei_genesys_read_register(dev, 0x45, &value);
*words = *words * 256 + value;
*words = dev->read_register(0x42) & 0x03;
*words = *words * 256 + dev->read_register(0x43);
*words = *words * 256 + dev->read_register(0x44);
*words = *words * 256 + dev->read_register(0x45);
break;
default:
sanei_genesys_read_register(dev, 0x44, &value);
*words = value;
sanei_genesys_read_register(dev, 0x43, &value);
*words += value * 256;
sanei_genesys_read_register(dev, 0x42, &value);
if (dev->model->asic_type == GENESYS_GL646)
*words += ((value & 0x03) * 256 * 256);
else
*words += ((value & 0x0f) * 256 * 256);
*words = dev->read_register(0x44);
*words += dev->read_register(0x43) * 256;
if (dev->model->asic_type == GENESYS_GL646) {
*words += ((dev->read_register(0x42) & 0x03) * 256 * 256);
} else {
*words += ((dev->read_register(0x42) & 0x0f) * 256 * 256);
}
}
DBG(DBG_proc, "%s: %d words\n", __func__, *words);
@ -715,28 +699,22 @@ void sanei_genesys_read_valid_words(Genesys_Device* dev, unsigned int* words)
void sanei_genesys_read_scancnt(Genesys_Device* dev, unsigned int* words)
{
DBG_HELPER(dbg);
uint8_t value;
if (dev->model->asic_type == GENESYS_GL124)
{
sanei_genesys_read_hregister(dev, 0x10b, &value);
*words = (value & 0x0f) << 16;
sanei_genesys_read_hregister(dev, 0x10c, &value);
*words += (value << 8);
sanei_genesys_read_hregister(dev, 0x10d, &value);
*words += value;
*words = (dev->read_register(0x10b) & 0x0f) << 16;
*words += (dev->read_register(0x10c) << 8);
*words += dev->read_register(0x10d);
}
else
{
sanei_genesys_read_register(dev, 0x4d, &value);
*words = value;
sanei_genesys_read_register(dev, 0x4c, &value);
*words += value * 256;
sanei_genesys_read_register(dev, 0x4b, &value);
if (dev->model->asic_type == GENESYS_GL646)
*words += ((value & 0x03) * 256 * 256);
else
*words += ((value & 0x0f) * 256 * 256);
*words = dev->read_register(0x4d);
*words += dev->read_register(0x4c) * 256;
if (dev->model->asic_type == GENESYS_GL646) {
*words += ((dev->read_register(0x4b) & 0x03) * 256 * 256);
} else {
*words += ((dev->read_register(0x4b) & 0x0f) * 256 * 256);
}
}
DBG(DBG_proc, "%s: %d lines\n", __func__, *words);
@ -803,30 +781,24 @@ void sanei_genesys_read_data_from_scanner(Genesys_Device* dev, uint8_t* data, si
void sanei_genesys_read_feed_steps(Genesys_Device* dev, unsigned int* steps)
{
DBG_HELPER(dbg);
uint8_t value;
if (dev->model->asic_type == GENESYS_GL124)
{
sanei_genesys_read_hregister(dev, 0x108, &value);
*steps = (value & 0x1f) << 16;
sanei_genesys_read_hregister(dev, 0x109, &value);
*steps += (value << 8);
sanei_genesys_read_hregister(dev, 0x10a, &value);
*steps += value;
*steps = (dev->read_register(0x108) & 0x1f) << 16;
*steps += (dev->read_register(0x109) << 8);
*steps += dev->read_register(0x10a);
}
else
{
sanei_genesys_read_register(dev, 0x4a, &value);
*steps = value;
sanei_genesys_read_register(dev, 0x49, &value);
*steps += value * 256;
sanei_genesys_read_register(dev, 0x48, &value);
if (dev->model->asic_type == GENESYS_GL646)
*steps += ((value & 0x03) * 256 * 256);
else if (dev->model->asic_type == GENESYS_GL841)
*steps += ((value & 0x0f) * 256 * 256);
else
*steps += ((value & 0x1f) * 256 * 256);
*steps = dev->read_register(0x4a);
*steps += dev->read_register(0x49) * 256;
if (dev->model->asic_type == GENESYS_GL646) {
*steps += ((dev->read_register(0x48) & 0x03) * 256 * 256);
} else if (dev->model->asic_type == GENESYS_GL841) {
*steps += ((dev->read_register(0x48) & 0x0f) * 256 * 256);
} else {
*steps += ((dev->read_register(0x48) & 0x1f) * 256 * 256);
}
}
DBG(DBG_proc, "%s: %d steps\n", __func__, *steps);
@ -1109,7 +1081,6 @@ void sanei_genesys_send_gamma_table(Genesys_Device* dev, const Genesys_Sensor& s
DBG_HELPER(dbg);
int size;
int i;
uint8_t val;
size = 256 + 1;
@ -1121,12 +1092,12 @@ void sanei_genesys_send_gamma_table(Genesys_Device* dev, const Genesys_Sensor& s
// loop sending gamma tables NOTE: 0x01000000 not 0x10000000
for (i = 0; i < 3; i++) {
// clear corresponding GMM_N bit
sanei_genesys_read_register(dev, 0xbd, &val);
uint8_t val = dev->read_register(0xbd);
val &= ~(0x01 << i);
sanei_genesys_write_register(dev, 0xbd, val);
// clear corresponding GMM_F bit
sanei_genesys_read_register(dev, 0xbe, &val);
val = dev->read_register(0xbe);
val &= ~(0x01 << i);
sanei_genesys_write_register(dev, 0xbe, val);
@ -1175,14 +1146,11 @@ void sanei_genesys_asic_init(Genesys_Device* dev, int /*max_regs*/)
dev->usb_mode = 2;
}
/* check if the device has already been initialized and powered up
* we read register 6 and check PWRBIT, if reset scanner has been
* freshly powered up. This bit will be set to later so that following
* reads can detect power down/up cycle*/
sanei_genesys_read_register(dev, 0x06, &val);
/* test for POWER bit */
if (val & 0x10)
{
/* Check if the device has already been initialized and powered up. We read register 0x06 and
check PWRBIT, if reset scanner has been freshly powered up. This bit will be set to later
so that following reads can detect power down/up cycle
*/
if (dev->read_register(0x06) & 0x10) {
cold = SANE_FALSE;
}
DBG (DBG_info, "%s: device is %s\n", __func__, cold ? "cold" : "warm");

5
backend/genesys_register.h
Wyświetl plik

@ -111,6 +111,11 @@ public:
std::sort(registers_.begin(), registers_.end());
}
bool has_reg(uint16_t address) const
{
return find_reg_index(address) >= 0;
}
void remove_reg(uint16_t address)
{
int i = find_reg_index(address);