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

genesys: Return errors as exceptions from *fe_write_data()

merge-requests/101/head
Povilas Kanapickas 2019-07-14 23:40:51 +03:00
rodzic 32a2eeaa5f
commit 612ff9487c
9 zmienionych plików z 115 dodań i 583 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

46
backend/genesys.cc
Wyświetl plik

@ -1520,29 +1520,9 @@ static SANE_Status genesys_coarse_calibration(Genesys_Device * dev, Genesys_Sens
dev->frontend.set_gain(1, 2);
dev->frontend.set_gain(2, 2);
status =
sanei_genesys_fe_write_data(dev, 0x28, dev->frontend.get_gain(0));
if (status != SANE_STATUS_GOOD) /* todo: this was 0x28 + 3 ? */
{
DBG(DBG_error, "%s: Failed to write gain[0]: %s\n", __func__, sane_strstatus(status));
return status;
}
status =
sanei_genesys_fe_write_data(dev, 0x29, dev->frontend.get_gain(1));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to write gain[1]: %s\n", __func__, sane_strstatus(status));
return status;
}
status =
sanei_genesys_fe_write_data(dev, 0x2a, dev->frontend.get_gain(2));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to write gain[2]: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x28, dev->frontend.get_gain(0));
sanei_genesys_fe_write_data(dev, 0x29, dev->frontend.get_gain(1));
sanei_genesys_fe_write_data(dev, 0x2a, dev->frontend.get_gain(2));
}
if (i == 3) /* last line */
@ -1568,29 +1548,9 @@ static SANE_Status genesys_coarse_calibration(Genesys_Device * dev, Genesys_Sens
dev->frontend.set_offset(j, curr_offset);
}
}
status =
sanei_genesys_fe_write_data(dev, 0x20, dev->frontend.get_offset(0));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to write offset[0]: %s\n", __func__, sane_strstatus(status));
return status;
}
status =
sanei_genesys_fe_write_data(dev, 0x21, dev->frontend.get_offset(1));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to write offset[1]: %s\n", __func__, sane_strstatus(status));
return status;
}
status =
sanei_genesys_fe_write_data(dev, 0x22, dev->frontend.get_offset(2));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to write offset[2]: %s\n", __func__, sane_strstatus(status));
return status;
}
DBG(DBG_info,
"%s: doing scan: gain: %d/%d/%d, offset: %d/%d/%d\n", __func__,

45
backend/genesys_gl124.cc
Wyświetl plik

@ -550,62 +550,31 @@ gl124_set_ti_fe (Genesys_Device * dev, uint8_t set)
dev->frontend = dev->frontend_initial;
}
/* start writing to DAC */
status = sanei_genesys_fe_write_data (dev, 0x00, 0x80);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to write reg0: %s\n", __func__,
sane_strstatus (status));
return status;
}
// start writing to DAC
sanei_genesys_fe_write_data(dev, 0x00, 0x80);
/* write values to analog frontend */
for (uint16_t addr = 0x01; addr < 0x04; addr++)
{
status = sanei_genesys_fe_write_data(dev, addr, dev->frontend.regs.get_value(addr));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to write reg %d: %s\n", __func__, addr,
sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, addr, dev->frontend.regs.get_value(addr));
}
status = sanei_genesys_fe_write_data (dev, 0x04, 0x00);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to write reg4: %s\n", __func__,
sane_strstatus (status));
return status;
}
sanei_genesys_fe_write_data (dev, 0x04, 0x00);
/* these are not really sign for this AFE */
for (i = 0; i < 3; i++)
{
status = sanei_genesys_fe_write_data(dev, 0x05 + i, dev->frontend.regs.get_value(0x24 + i));
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to write reg %d: %s\n", __func__, i+5,
sane_strstatus (status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x05 + i, dev->frontend.regs.get_value(0x24 + i));
}
/* close writing to DAC */
if(dev->model->dac_type == DAC_CANONLIDE120)
{
status = sanei_genesys_fe_write_data (dev, 0x00, 0x01);
sanei_genesys_fe_write_data(dev, 0x00, 0x01);
}
else
{
status = sanei_genesys_fe_write_data (dev, 0x00, 0x11);
}
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to write reg0: %s\n", __func__,
sane_strstatus (status));
return status;
sanei_genesys_fe_write_data(dev, 0x00, 0x11);
}
return status;

216
backend/genesys_gl646.cc
Wyświetl plik

@ -1343,53 +1343,25 @@ gl646_set_ad_fe (Genesys_Device * dev, uint8_t set)
dev->frontend = dev->frontend_initial;
/* write them to analog frontend */
status = sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to write reg0: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to write reg1: %s\n", __func__, sane_strstatus(status));
return status;
}
// write them to analog frontend
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
}
if (set == AFE_SET)
{
for (i = 0; i < 3; i++)
{
status = sanei_genesys_fe_write_data(dev, 0x02 + i, dev->frontend.get_gain(i));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to write gain %d: %s\n", __func__, i,
sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x02 + i, dev->frontend.get_gain(i));
}
for (i = 0; i < 3; i++)
{
status = sanei_genesys_fe_write_data(dev, 0x05 + i, dev->frontend.get_offset(i));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to write offset %d: %s\n", __func__, i,
sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x05 + i, dev->frontend.get_offset(i));
}
}
/*
if (set == AFE_POWER_SAVE)
{
status =
sanei_genesys_fe_write_data (dev, 0x00, dev->frontend.reg[0] | 0x04);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to write reg0: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.reg[0] | 0x04);
} */
return status;
@ -1412,43 +1384,18 @@ gl646_wm_hp3670(Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set,
switch (set)
{
case AFE_INIT:
status = sanei_genesys_fe_write_data (dev, 0x04, 0x80);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: reset failed: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data (dev, 0x04, 0x80);
sanei_genesys_sleep_ms(200);
sanei_genesys_write_register(dev, 0x50, 0x00);
dev->frontend = dev->frontend_initial;
status = sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg1 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_fe_write_data(dev, 0x02, dev->frontend.regs.get_value(0x02));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg2 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
sanei_genesys_fe_write_data(dev, 0x02, dev->frontend.regs.get_value(0x02));
gl646_gpio_output_enable(dev->usb_dev, 0x07);
break;
case AFE_POWER_SAVE:
status = sanei_genesys_fe_write_data (dev, 0x01, 0x06);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg1 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_fe_write_data (dev, 0x06, 0x0f);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg6 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
return status;
sanei_genesys_fe_write_data(dev, 0x01, 0x06);
sanei_genesys_fe_write_data(dev, 0x06, 0x0f);
return status;
break;
default: /* AFE_SET */
/* mode setup */
@ -1460,45 +1407,19 @@ gl646_wm_hp3670(Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set,
* fe_reg_0x03 set to 0x32 or 0x12 but not to 0x02 */
i = 0x12;
}
status = sanei_genesys_fe_write_data (dev, 0x03, i);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg3 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x03, i);
/* offset and sign (or msb/lsb ?) */
for (i = 0; i < 3; i++)
{
status =
sanei_genesys_fe_write_data(dev, 0x20 + i, dev->frontend.get_offset(i));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing offset%d failed: %s\n", __func__, i,
sane_strstatus (status));
return status;
}
status = sanei_genesys_fe_write_data(dev, 0x24 + i,
dev->frontend.regs.get_value(0x24 + i)); /* MSB/LSB ? */
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing sign%d failed: %s\n", __func__, i,
sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x20 + i, dev->frontend.get_offset(i));
sanei_genesys_fe_write_data(dev, 0x24 + i,
dev->frontend.regs.get_value(0x24 + i)); /* MSB/LSB ? */
}
/* gain */
for (i = 0; i < 3; i++)
{
status =
// gain
for (i = 0; i < 3; i++) {
sanei_genesys_fe_write_data(dev, 0x28 + i, dev->frontend.get_gain(i));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing gain%d failed: %s\n", __func__, i,
sane_strstatus(status));
return status;
}
}
}
}
return status;
@ -1549,13 +1470,8 @@ gl646_set_fe(Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set, in
DBG(DBG_proc, "%s(): setting DAC %u\n", __func__, dev->model->dac_type);
dev->frontend = dev->frontend_initial;
/* reset only done on init */
status = sanei_genesys_fe_write_data (dev, 0x04, 0x80);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: init fe failed: %s\n", __func__, sane_strstatus(status));
return status;
}
// reset only done on init
sanei_genesys_fe_write_data(dev, 0x04, 0x80);
/* enable GPIO for some models */
if (dev->model->ccd_type == CCD_HP2300)
@ -1566,15 +1482,10 @@ gl646_set_fe(Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set, in
return status;
}
/* set fontend to power saving mode */
if (set == AFE_POWER_SAVE)
{
status = sanei_genesys_fe_write_data (dev, 0x01, 0x02);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing data failed: %s\n", __func__, sane_strstatus(status));
}
return status;
// set fontend to power saving mode
if (set == AFE_POWER_SAVE) {
sanei_genesys_fe_write_data(dev, 0x01, 0x02);
return status;
}
/* here starts AFE_SET */
@ -1583,60 +1494,21 @@ gl646_set_fe(Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set, in
&& dev->model->ccd_type != CCD_HP3670
&& dev->model->ccd_type != CCD_HP2400) */
{
status = sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg0 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_fe_write_data(dev, 0x02, dev->frontend.regs.get_value(0x02));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg2 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
sanei_genesys_fe_write_data(dev, 0x02, dev->frontend.regs.get_value(0x02));
}
/* start with reg3 */
status = sanei_genesys_fe_write_data(dev, 0x03, dev->frontend.regs.get_value(0x03));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg3 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
// start with reg3
sanei_genesys_fe_write_data(dev, 0x03, dev->frontend.regs.get_value(0x03));
switch (dev->model->ccd_type)
{
default:
for (i = 0; i < 3; i++)
{
status =
sanei_genesys_fe_write_data(dev, 0x24 + i,
dev->frontend.regs.get_value(0x24 + i));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing sign[%d] failed: %s\n", __func__, i,
sane_strstatus(status));
return status;
}
status =
sanei_genesys_fe_write_data(dev, 0x28 + i, dev->frontend.get_gain(i));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing gain[%d] failed: %s\n", __func__, i,
sane_strstatus(status));
return status;
}
status =
sanei_genesys_fe_write_data(dev, 0x20 + i, dev->frontend.get_offset(i));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing offset[%d] failed: %s\n", __func__, i,
sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x24 + i, dev->frontend.regs.get_value(0x24 + i));
sanei_genesys_fe_write_data(dev, 0x28 + i, dev->frontend.get_gain(i));
sanei_genesys_fe_write_data(dev, 0x20 + i, dev->frontend.get_offset(i));
}
break;
/* just can't have it to work ....
@ -1644,29 +1516,13 @@ gl646_set_fe(Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set, in
case CCD_HP2400:
case CCD_HP3670:
status =
sanei_genesys_fe_write_data(dev, 0x23, dev->frontend.get_offset(1));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing offset[1] failed: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_fe_write_data(dev, 0x28, dev->frontend.get_gain(1));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing gain[1] failed: %s\n", __func__, sane_strstatus (status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x23, dev->frontend.get_offset(1));
sanei_genesys_fe_write_data(dev, 0x28, dev->frontend.get_gain(1));
break; */
}
/* end with reg1 */
status = sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg1 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
// end with reg1
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
return SANE_STATUS_GOOD;
}

244
backend/genesys_gl841.cc
Wyświetl plik

@ -757,47 +757,17 @@ gl841_set_lide80_fe (Genesys_Device * dev, uint8_t set)
dev->frontend = dev->frontend_initial;
/* write them to analog frontend */
status = sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg 0x00 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_fe_write_data(dev, 0x03, dev->frontend.regs.get_value(0x01));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg 0x03 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_fe_write_data(dev, 0x06, dev->frontend.regs.get_value(0x02));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg 0x06 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
// write them to analog frontend
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
sanei_genesys_fe_write_data(dev, 0x03, dev->frontend.regs.get_value(0x01));
sanei_genesys_fe_write_data(dev, 0x06, dev->frontend.regs.get_value(0x02));
}
if (set == AFE_SET)
{
status = sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg 0x00 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_fe_write_data(dev, 0x06, dev->frontend.regs.get_value(0x20));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing offset failed: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_fe_write_data(dev, 0x03, dev->frontend.regs.get_value(0x28));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing gain failed: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
sanei_genesys_fe_write_data(dev, 0x06, dev->frontend.regs.get_value(0x20));
sanei_genesys_fe_write_data(dev, 0x03, dev->frontend.regs.get_value(0x28));
}
return status;
@ -823,100 +793,39 @@ gl841_set_ad_fe (Genesys_Device * dev, uint8_t set)
dev->frontend = dev->frontend_initial;
/* write them to analog frontend */
status = sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg 0x00 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
// write them to analog frontend
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
status = sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg 0x01 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
for (i = 0; i < 6; i++)
{
status =
sanei_genesys_fe_write_data (dev, 0x02 + i, 0x00);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing sign[%d] failed: %s\n", __func__, 0x02 + i,
sane_strstatus(status));
return status;
}
for (i = 0; i < 6; i++) {
sanei_genesys_fe_write_data(dev, 0x02 + i, 0x00);
}
}
if (set == AFE_SET)
{
/* write them to analog frontend */
status = sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg 0x00 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
// write them to analog frontend
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
status = sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg 0x01 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
/* Write fe 0x02 (red gain)*/
status = sanei_genesys_fe_write_data(dev, 0x02, dev->frontend.get_gain(0));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing fe 0x02 (gain r) fail: %s\n", __func__, sane_strstatus(status));
return status;
}
// Write fe 0x02 (red gain)
sanei_genesys_fe_write_data(dev, 0x02, dev->frontend.get_gain(0));
/* Write fe 0x03 (green gain)*/
status = sanei_genesys_fe_write_data(dev, 0x03, dev->frontend.get_gain(1));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing fe 0x03 (gain g) fail: %s\n", __func__, sane_strstatus(status));
return status;
}
// Write fe 0x03 (green gain)
sanei_genesys_fe_write_data(dev, 0x03, dev->frontend.get_gain(1));
/* Write fe 0x04 (blue gain)*/
status = sanei_genesys_fe_write_data(dev, 0x04, dev->frontend.get_gain(2));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing fe 0x04 (gain b) fail: %s\n", __func__, sane_strstatus(status));
return status;
}
// Write fe 0x04 (blue gain)
sanei_genesys_fe_write_data(dev, 0x04, dev->frontend.get_gain(2));
/* Write fe 0x05 (red offset)*/
status =
sanei_genesys_fe_write_data(dev, 0x05, dev->frontend.get_offset(0));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: write fe 0x05 (offset r) fail: %s\n", __func__, sane_strstatus(status));
return status;
}
// Write fe 0x05 (red offset)
sanei_genesys_fe_write_data(dev, 0x05, dev->frontend.get_offset(0));
/* Write fe 0x06 (green offset)*/
status =
sanei_genesys_fe_write_data(dev, 0x06, dev->frontend.get_offset(1));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: write fe 0x06 (offset g) fail: %s\n", __func__, sane_strstatus(status));
return status;
}
// Write fe 0x06 (green offset)
sanei_genesys_fe_write_data(dev, 0x06, dev->frontend.get_offset(1));
/* Write fe 0x07 (blue offset)*/
status =
sanei_genesys_fe_write_data(dev, 0x07, dev->frontend.get_offset(2));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: write fe 0x07 (offset b) fail: %s\n", __func__, sane_strstatus(status));
return status;
}
// Write fe 0x07 (blue offset)
sanei_genesys_fe_write_data(dev, 0x07, dev->frontend.get_offset(2));
}
return status;
@ -951,109 +860,36 @@ gl841_set_fe(Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set)
DBG(DBG_proc, "%s(): setting DAC %u\n", __func__, dev->model->dac_type);
dev->frontend = dev->frontend_initial;
/* reset only done on init */
status = sanei_genesys_fe_write_data (dev, 0x04, 0x80);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: reset fe failed: %s\n", __func__, sane_strstatus(status));
return status;
}
// reset only done on init
sanei_genesys_fe_write_data (dev, 0x04, 0x80);
DBG(DBG_proc, "%s(): frontend reset complete\n", __func__);
}
if (set == AFE_POWER_SAVE)
{
status = sanei_genesys_fe_write_data (dev, 0x01, 0x02);
if (status != SANE_STATUS_GOOD) {
DBG(DBG_error, "%s: writing data failed: %s\n", __func__, sane_strstatus(status));
sanei_genesys_fe_write_data (dev, 0x01, 0x02);
return status;
}
return status;
}
/* todo : base this test on cfg reg3 or a CCD family flag to be created */
/*if (dev->model->ccd_type!=CCD_HP2300 && dev->model->ccd_type!=CCD_HP2400) */
{
status = sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg0 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_fe_write_data(dev, 0x02, dev->frontend.regs.get_value(0x02));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg2 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
sanei_genesys_fe_write_data(dev, 0x02, dev->frontend.regs.get_value(0x02));
}
status = sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg1 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_fe_write_data(dev, 0x03, dev->frontend.regs.get_value(0x03));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg3 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_fe_write_data (dev, 0x06, dev->frontend.reg2[0]);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg6 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_fe_write_data (dev, 0x08, dev->frontend.reg2[1]);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg8 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_fe_write_data (dev, 0x09, dev->frontend.reg2[2]);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg9 failed: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
sanei_genesys_fe_write_data(dev, 0x03, dev->frontend.regs.get_value(0x03));
sanei_genesys_fe_write_data(dev, 0x06, dev->frontend.reg2[0]);
sanei_genesys_fe_write_data(dev, 0x08, dev->frontend.reg2[1]);
sanei_genesys_fe_write_data(dev, 0x09, dev->frontend.reg2[2]);
for (i = 0; i < 3; i++)
{
status =
sanei_genesys_fe_write_data(dev, 0x24 + i, dev->frontend.regs.get_value(0x24 + i));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing sign[%d] failed: %s\n", __func__, i,
sane_strstatus(status));
return status;
}
status =
sanei_genesys_fe_write_data(dev, 0x28 + i, dev->frontend.get_gain(i));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing gain[%d] failed: %s\n", __func__, i,
sane_strstatus(status));
return status;
}
status =
sanei_genesys_fe_write_data(dev, 0x20 + i,
dev->frontend.get_offset(i));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing offset[%d] failed: %s\n", __func__, i,
sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x24 + i, dev->frontend.regs.get_value(0x24 + i));
sanei_genesys_fe_write_data(dev, 0x28 + i, dev->frontend.get_gain(i));
sanei_genesys_fe_write_data(dev, 0x20 + i, dev->frontend.get_offset(i));
}
return SANE_STATUS_GOOD;

46
backend/genesys_gl843.cc
Wyświetl plik

@ -792,7 +792,6 @@ gl843_set_fe (Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set)
set == AFE_SET ? "set" :
set == AFE_POWER_SAVE ? "powersave" : "huh?");
(void) sensor;
SANE_Status status = SANE_STATUS_GOOD;
uint8_t val;
int i;
@ -820,38 +819,23 @@ gl843_set_fe (Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set)
// FIXME: BUG: we should initialize dev->frontend before first use. Right now it's
// initialized during genesys_coarse_calibration()
if (dev->frontend.regs.empty()) {
status = sanei_genesys_fe_write_data(dev, i, 0x00);
sanei_genesys_fe_write_data(dev, i, 0x00);
} else {
status = sanei_genesys_fe_write_data(dev, i, dev->frontend.regs.get_value(0x00 + i));
sanei_genesys_fe_write_data(dev, i, dev->frontend.regs.get_value(0x00 + i));
}
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing reg[%d] failed: %s\n", __func__, i, sane_strstatus(status));
return status;
}
}
for (const auto& reg : sensor.custom_fe_regs) {
status = sanei_genesys_fe_write_data(dev, reg.address, reg.value);
if (status != SANE_STATUS_GOOD) {
DBG(DBG_error, "%s: writing reg[%d] failed: %s\n", __func__, i, sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, reg.address, reg.value);
}
for (i = 0; i < 3; i++)
{
// FIXME: BUG: see above
if (dev->frontend.regs.empty()) {
status = sanei_genesys_fe_write_data(dev, 0x20 + i, 0x00);
sanei_genesys_fe_write_data(dev, 0x20 + i, 0x00);
} else {
status = sanei_genesys_fe_write_data(dev, 0x20 + i, dev->frontend.get_offset(i));
sanei_genesys_fe_write_data(dev, 0x20 + i, dev->frontend.get_offset(i));
}
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing offset[%d] failed: %s\n", __func__, i,
sane_strstatus(status));
return status;
}
}
if (dev->model->ccd_type == CCD_KVSS080)
@ -860,17 +844,10 @@ gl843_set_fe (Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set)
{
// FIXME: BUG: see above
if (dev->frontend.regs.empty()) {
status = sanei_genesys_fe_write_data(dev, 0x24 + i, 0x00);
sanei_genesys_fe_write_data(dev, 0x24 + i, 0x00);
} else {
status = sanei_genesys_fe_write_data(dev, 0x24 + i,
dev->frontend.regs.get_value(0x24 + i));
sanei_genesys_fe_write_data(dev, 0x24 + i, dev->frontend.regs.get_value(0x24 + i));
}
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing sign[%d] failed: %s\n", __func__, i,
sane_strstatus(status));
return status;
}
}
}
@ -878,15 +855,10 @@ gl843_set_fe (Genesys_Device * dev, const Genesys_Sensor& sensor, uint8_t set)
{
// FIXME: BUG: see above
if (dev->frontend.regs.empty()) {
status = sanei_genesys_fe_write_data(dev, 0x28 + i, 0x00);
sanei_genesys_fe_write_data(dev, 0x28 + i, 0x00);
} else {
status = sanei_genesys_fe_write_data(dev, 0x28 + i, dev->frontend.get_gain(i));
sanei_genesys_fe_write_data(dev, 0x28 + i, dev->frontend.get_gain(i));
}
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: writing gain[%d] failed: %s\n", __func__, i, sane_strstatus(status));
return status;
}
}
return SANE_STATUS_GOOD;

43
backend/genesys_gl846.cc
Wyświetl plik

@ -486,43 +486,16 @@ gl846_set_adi_fe (Genesys_Device * dev, uint8_t set)
dev->frontend = dev->frontend_initial;
}
/* write them to analog frontend */
status = sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to write reg0: %s\n", __func__,
sane_strstatus (status));
return status;
}
status = sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to write reg1: %s\n", __func__,
sane_strstatus (status));
return status;
}
// write them to analog frontend
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
for (i = 0; i < 3; i++)
{
status = sanei_genesys_fe_write_data(dev, 0x02 + i, dev->frontend.get_gain(i));
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to write gain %d: %s\n", __func__, i,
sane_strstatus (status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
for (i = 0; i < 3; i++) {
sanei_genesys_fe_write_data(dev, 0x02 + i, dev->frontend.get_gain(i));
}
for (i = 0; i < 3; i++)
{
status = sanei_genesys_fe_write_data(dev, 0x05 + i, dev->frontend.get_offset(i));
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to write offset %d: %s\n", __func__, i,
sane_strstatus (status));
return status;
}
for (i = 0; i < 3; i++) {
sanei_genesys_fe_write_data(dev, 0x05 + i, dev->frontend.get_offset(i));
}
return status;

47
backend/genesys_gl847.cc
Wyświetl plik

@ -507,46 +507,19 @@ gl847_set_ad_fe (Genesys_Device * dev, uint8_t set)
dev->frontend = dev->frontend_initial;
}
/* reset DAC */
status = sanei_genesys_fe_write_data (dev, 0x00, 0x80);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to write reg0: %s\n", __func__, sane_strstatus(status));
return status;
}
// reset DAC
sanei_genesys_fe_write_data(dev, 0x00, 0x80);
/* write them to analog frontend */
status = sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to write reg0: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to write reg1: %s\n", __func__, sane_strstatus(status));
return status;
}
// write them to analog frontend
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
for (i = 0; i < 3; i++)
{
status = sanei_genesys_fe_write_data(dev, 0x02 + i, dev->frontend.get_gain(i));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to write gain %d: %s\n", __func__, i, sane_strstatus(status));
return status;
}
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
for (i = 0; i < 3; i++) {
sanei_genesys_fe_write_data(dev, 0x02 + i, dev->frontend.get_gain(i));
}
for (i = 0; i < 3; i++)
{
status = sanei_genesys_fe_write_data(dev, 0x05 + i, dev->frontend.get_offset(i));
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to write offset %d: %s\n", __func__, i,
sane_strstatus(status));
return status;
}
for (i = 0; i < 3; i++) {
sanei_genesys_fe_write_data(dev, 0x05 + i, dev->frontend.get_offset(i));
}
return status;

7
backend/genesys_low.cc
Wyświetl plik

@ -612,12 +612,9 @@ sanei_genesys_fe_read_data (Genesys_Device * dev, uint8_t addr,
* @param addr AFE rister address
* @param data value to write to AFE register
**/
SANE_Status
sanei_genesys_fe_write_data (Genesys_Device * dev, uint8_t addr,
uint16_t data)
void sanei_genesys_fe_write_data(Genesys_Device* dev, uint8_t addr, uint16_t data)
{
DBG_HELPER_ARGS(dbg, "0x%02x, 0x%04x", addr, data);
SANE_Status status = SANE_STATUS_GOOD;
Genesys_Register_Set reg(Genesys_Register_Set::SEQUENTIAL);
reg.init_reg(0x51, addr);
@ -630,8 +627,6 @@ sanei_genesys_fe_write_data (Genesys_Device * dev, uint8_t addr,
}
dev->model->cmd_set->bulk_write_register(dev, reg);
return status;
}
/* ------------------------------------------------------------------------ */

4
backend/genesys_low.h
Wyświetl plik

@ -1794,9 +1794,7 @@ sanei_genesys_fe_read_data (Genesys_Device * dev, uint8_t addr,
* Writes data to analog frontend register at the given address.
* The use and address of registers change from model to model.
*/
extern SANE_Status
sanei_genesys_fe_write_data (Genesys_Device * dev, uint8_t addr,
uint16_t data);
extern void sanei_genesys_fe_write_data(Genesys_Device* dev, uint8_t addr, uint16_t data);
extern SANE_Int
sanei_genesys_exposure_time2 (Genesys_Device * dev,