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

genesys: Improve type safety of Genesys_Register_Set

merge-requests/81/head
Povilas Kanapickas 2019-06-02 11:47:26 +03:00
rodzic 6d95bc191f
commit 04c5b4afde
15 zmienionych plików z 1247 dodań i 2389 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

82
backend/genesys.cc
Wyświetl plik

@ -906,7 +906,7 @@ genesys_send_offset_and_shading (Genesys_Device * dev, uint8_t * data,
}
/* gl646, gl84[123] case */
dpihw = sanei_genesys_read_reg_from_set (dev->reg, 0x05) >> 6;
dpihw = dev->reg.get8(0x05) >> 6;
/* TODO invert the test so only the 2 models behaving like that are
* tested instead of adding all the others */
@ -1545,7 +1545,7 @@ genesys_coarse_calibration (Genesys_Device * dev)
dev->frontend.offset[2]);
status =
dev->model->cmd_set->begin_scan (dev, dev->calib_reg, SANE_FALSE);
dev->model->cmd_set->begin_scan(dev, &dev->calib_reg, SANE_FALSE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to begin scan: %s\n", __func__, sane_strstatus(status));
@ -1577,7 +1577,7 @@ genesys_coarse_calibration (Genesys_Device * dev)
}
}
status = dev->model->cmd_set->end_scan (dev, dev->calib_reg, SANE_TRUE);
status = dev->model->cmd_set->end_scan(dev, &dev->calib_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to end scan: %s\n", __func__, sane_strstatus(status));
@ -1736,19 +1736,17 @@ genesys_dark_shading_calibration (Genesys_Device * dev)
* because they have a calibration sheet with a sufficient black strip */
if (dev->model->is_sheetfed == SANE_FALSE)
{
dev->model->cmd_set->set_lamp_power (dev, dev->calib_reg, SANE_FALSE);
dev->model->cmd_set->set_motor_power (dev->calib_reg, motor);
dev->model->cmd_set->set_lamp_power(dev, &dev->calib_reg, SANE_FALSE);
dev->model->cmd_set->set_motor_power(&dev->calib_reg, motor);
}
else
{
dev->model->cmd_set->set_lamp_power (dev, dev->calib_reg, SANE_TRUE);
dev->model->cmd_set->set_motor_power (dev->calib_reg, motor);
dev->model->cmd_set->set_lamp_power(dev, &dev->calib_reg, SANE_TRUE);
dev->model->cmd_set->set_motor_power(&dev->calib_reg, motor);
}
status =
dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg,
dev->model->
cmd_set->bulk_full_size ());
dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
@ -1758,7 +1756,7 @@ genesys_dark_shading_calibration (Genesys_Device * dev)
// wait some time to let lamp to get dark
sanei_genesys_sleep_ms(200);
status = dev->model->cmd_set->begin_scan (dev, dev->calib_reg, SANE_FALSE);
status = dev->model->cmd_set->begin_scan(dev, &dev->calib_reg, SANE_FALSE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to begin scan: %s\n", __func__, sane_strstatus(status));
@ -1772,7 +1770,7 @@ genesys_dark_shading_calibration (Genesys_Device * dev)
return status;
}
status = dev->model->cmd_set->end_scan (dev, dev->calib_reg, SANE_TRUE);
status = dev->model->cmd_set->end_scan(dev, &dev->calib_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to end scan: %s\n", __func__, sane_strstatus(status));
@ -1924,8 +1922,8 @@ genesys_white_shading_calibration (Genesys_Device * dev)
}
/* turn on motor and lamp power */
dev->model->cmd_set->set_lamp_power (dev, dev->calib_reg, SANE_TRUE);
dev->model->cmd_set->set_motor_power (dev->calib_reg, motor);
dev->model->cmd_set->set_lamp_power(dev, &dev->calib_reg, SANE_TRUE);
dev->model->cmd_set->set_motor_power(&dev->calib_reg, motor);
/* if needed, go back before doing next scan */
if (dev->model->flags & GENESYS_FLAG_SHADING_REPARK)
@ -1943,9 +1941,7 @@ genesys_white_shading_calibration (Genesys_Device * dev)
}
status =
dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg,
dev->model->
cmd_set->bulk_full_size ());
dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
@ -1955,7 +1951,7 @@ genesys_white_shading_calibration (Genesys_Device * dev)
if (dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION)
sanei_genesys_sleep_ms(500); // make sure lamp is bright again
status = dev->model->cmd_set->begin_scan (dev, dev->calib_reg, SANE_TRUE);
status = dev->model->cmd_set->begin_scan(dev, &dev->calib_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to begin scan: %s\n", __func__, sane_strstatus(status));
@ -1969,7 +1965,7 @@ genesys_white_shading_calibration (Genesys_Device * dev)
return status;
}
status = dev->model->cmd_set->end_scan (dev, dev->calib_reg, SANE_TRUE);
status = dev->model->cmd_set->end_scan(dev, &dev->calib_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to end scan: %s\n", __func__, sane_strstatus(status));
@ -2055,20 +2051,18 @@ genesys_dark_white_shading_calibration (Genesys_Device * dev)
}
/* turn on motor and lamp power */
dev->model->cmd_set->set_lamp_power (dev, dev->calib_reg, SANE_TRUE);
dev->model->cmd_set->set_motor_power (dev->calib_reg, motor);
dev->model->cmd_set->set_lamp_power(dev, &dev->calib_reg, SANE_TRUE);
dev->model->cmd_set->set_motor_power(&dev->calib_reg, motor);
status =
dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg,
dev->model->
cmd_set->bulk_full_size ());
dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
status = dev->model->cmd_set->begin_scan (dev, dev->calib_reg, SANE_FALSE);
status = dev->model->cmd_set->begin_scan(dev, &dev->calib_reg, SANE_FALSE);
if (status != SANE_STATUS_GOOD)
{
@ -2083,7 +2077,7 @@ genesys_dark_white_shading_calibration (Genesys_Device * dev)
return status;
}
status = dev->model->cmd_set->end_scan (dev, dev->calib_reg, SANE_TRUE);
status = dev->model->cmd_set->end_scan(dev, &dev->calib_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to end scan: %s\n", __func__, sane_strstatus(status));
@ -2677,7 +2671,7 @@ genesys_send_shading_coefficient (Genesys_Device * dev)
* to the next one, which allow to write the 3 channels in 1 write
* during genesys_send_shading_coefficient, some values are words, other bytes
* hence the x2 factor */
switch (sanei_genesys_read_reg_from_set (dev->reg, 0x05) >> 6)
switch (dev->reg.get8(0x05) >> 6)
{
/* 600 dpi */
case 0:
@ -2716,7 +2710,7 @@ genesys_send_shading_coefficient (Genesys_Device * dev)
Wn = white average for column n
Dn = dark average for column n
*/
if (dev->model->cmd_set->get_gain4_bit (dev->calib_reg))
if (dev->model->cmd_set->get_gain4_bit(&dev->calib_reg))
coeff = 0x4000;
else
coeff = 0x2000;
@ -3550,14 +3544,14 @@ genesys_warmup_lamp (Genesys_Device * dev)
return status;
}
dev->model->cmd_set->init_regs_for_warmup (dev, dev->reg, &channels, &total_size);
dev->model->cmd_set->init_regs_for_warmup(dev, &dev->reg, &channels, &total_size);
std::vector<uint8_t> first_line(total_size);
std::vector<uint8_t> second_line(total_size);
do
{
DBG(DBG_info, "%s: one more loop\n", __func__);
RIE(dev->model->cmd_set->begin_scan(dev, dev->reg, SANE_FALSE));
RIE(dev->model->cmd_set->begin_scan(dev, &dev->reg, SANE_FALSE));
do
{
sanei_genesys_test_buffer_empty (dev, &empty);
@ -3570,12 +3564,12 @@ genesys_warmup_lamp (Genesys_Device * dev)
RIE(sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size));
}
RIE(dev->model->cmd_set->end_scan (dev, dev->reg, SANE_TRUE));
RIE(dev->model->cmd_set->end_scan(dev, &dev->reg, SANE_TRUE));
sleep (1); /* sleep 1 s */
seconds++;
RIE(dev->model->cmd_set->begin_scan(dev, dev->reg, SANE_FALSE));
RIE(dev->model->cmd_set->begin_scan(dev, &dev->reg, SANE_FALSE));
do
{
sanei_genesys_test_buffer_empty (dev, &empty);
@ -3583,13 +3577,13 @@ genesys_warmup_lamp (Genesys_Device * dev)
}
while (empty);
RIE(sanei_genesys_read_data_from_scanner (dev, second_line.data(), total_size));
RIE(dev->model->cmd_set->end_scan (dev, dev->reg, SANE_TRUE));
RIE(dev->model->cmd_set->end_scan(dev, &dev->reg, SANE_TRUE));
/* compute difference between the two scans */
for (pixel = 0; pixel < total_size; pixel++)
{
/* 16 bit data */
if (dev->model->cmd_set->get_bitset_bit (dev->reg))
if (dev->model->cmd_set->get_bitset_bit(&dev->reg))
{
first_average += (first_line[pixel] + first_line[pixel + 1] * 256);
second_average += (second_line[pixel] + second_line[pixel + 1] * 256);
@ -3601,7 +3595,7 @@ genesys_warmup_lamp (Genesys_Device * dev)
second_average += second_line[pixel];
}
}
if (dev->model->cmd_set->get_bitset_bit (dev->reg))
if (dev->model->cmd_set->get_bitset_bit(&dev->reg))
{
first_average /= pixel;
second_average /= pixel;
@ -3825,7 +3819,7 @@ genesys_start_scan (Genesys_Device * dev, SANE_Bool lamp_off)
/* no lamp during scan */
if(lamp_off == SANE_TRUE)
{
dev->model->cmd_set->set_lamp_power (dev, dev->reg, SANE_FALSE);
dev->model->cmd_set->set_lamp_power(dev, &dev->reg, SANE_FALSE);
}
/* GL124 is using SHDAREA, so we have to wait for scan to be set up before
@ -3844,9 +3838,7 @@ genesys_start_scan (Genesys_Device * dev, SANE_Bool lamp_off)
/* now send registers for scan */
status =
dev->model->cmd_set->bulk_write_register (dev, dev->reg,
dev->model->
cmd_set->bulk_full_size ());
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers, status = %d\n", __func__, status);
@ -3854,7 +3846,7 @@ genesys_start_scan (Genesys_Device * dev, SANE_Bool lamp_off)
}
/* start effective scan */
status = dev->model->cmd_set->begin_scan (dev, dev->reg, SANE_TRUE);
status = dev->model->cmd_set->begin_scan(dev, &dev->reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to begin scan: %s\n", __func__, sane_strstatus(status));
@ -3863,9 +3855,9 @@ genesys_start_scan (Genesys_Device * dev, SANE_Bool lamp_off)
/*do we really need this? the valid data check should be sufficent -- pierre*/
/* waits for head to reach scanning position */
expected = sanei_genesys_read_reg_from_set (dev->reg, 0x3d) * 65536
+ sanei_genesys_read_reg_from_set (dev->reg, 0x3e) * 256
+ sanei_genesys_read_reg_from_set (dev->reg, 0x3f);
expected = dev->reg.get8(0x3d) * 65536
+ dev->reg.get8(0x3e) * 256
+ dev->reg.get8(0x3f);
do
{
// wait some time between each test to avoid overloading USB and CPU
@ -4746,7 +4738,7 @@ Problems with the first approach:
/* end scan if all needed data have been read */
if(dev->total_bytes_read >= dev->total_bytes_to_read)
{
dev->model->cmd_set->end_scan (dev, dev->reg, SANE_TRUE);
dev->model->cmd_set->end_scan(dev, &dev->reg, SANE_TRUE);
if (dev->model->is_sheetfed == SANE_TRUE)
{
dev->model->cmd_set->eject_document (dev);
@ -7441,7 +7433,7 @@ void sane_cancel_impl(SANE_Handle handle)
/* no need to end scan if we are parking the head */
if(s->dev->parking==SANE_FALSE)
{
status = s->dev->model->cmd_set->end_scan (s->dev, s->dev->reg, SANE_TRUE);
status = s->dev->model->cmd_set->end_scan(s->dev, &s->dev->reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to end scan: %s\n", __func__, sane_strstatus(status));

346
backend/genesys_gl124.cc
Wyświetl plik

@ -52,59 +52,29 @@
Mid level functions
****************************************************************************/
static SANE_Bool
gl124_get_fast_feed_bit (Genesys_Register_Set * regs)
static SANE_Bool gl124_get_fast_feed_bit(Genesys_Register_Set* regs)
{
Genesys_Register_Set *r = NULL;
r = sanei_genesys_get_address (regs, REG02);
if (r && (r->value & REG02_FASTFED))
return SANE_TRUE;
return SANE_FALSE;
return (bool)(regs->get8(REG02) & REG02_FASTFED);
}
static SANE_Bool
gl124_get_filter_bit (Genesys_Register_Set * regs)
static SANE_Bool gl124_get_filter_bit(Genesys_Register_Set* regs)
{
Genesys_Register_Set *r = NULL;
r = sanei_genesys_get_address (regs, REG04);
if (r && (r->value & REG04_FILTER))
return SANE_TRUE;
return SANE_FALSE;
return (bool)(regs->get8(REG04) & REG04_FILTER);
}
static SANE_Bool
gl124_get_lineart_bit (Genesys_Register_Set * regs)
static SANE_Bool gl124_get_lineart_bit(Genesys_Register_Set* regs)
{
Genesys_Register_Set *r = NULL;
r = sanei_genesys_get_address (regs, REG04);
if (r && (r->value & REG04_LINEART))
return SANE_TRUE;
return SANE_FALSE;
return (bool)(regs->get8(REG04) & REG04_LINEART);
}
static SANE_Bool
gl124_get_bitset_bit (Genesys_Register_Set * regs)
static SANE_Bool gl124_get_bitset_bit(Genesys_Register_Set* regs)
{
Genesys_Register_Set *r = NULL;
r = sanei_genesys_get_address (regs, REG04);
if (r && (r->value & REG04_BITSET))
return SANE_TRUE;
return SANE_FALSE;
return (bool)(regs->get8(REG04) & REG04_BITSET);
}
static SANE_Bool
gl124_get_gain4_bit (Genesys_Register_Set * regs)
static SANE_Bool gl124_get_gain4_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
r = sanei_genesys_get_address (regs, REG06);
if (r && (r->value & REG06_GAIN4))
return SANE_TRUE;
return SANE_FALSE;
return (bool)(regs->get8(REG06) & REG06_GAIN4);
}
static SANE_Bool
@ -179,13 +149,6 @@ static Sensor_Profile *get_sensor_profile(int sensor_type, int dpi, int half_ccd
}
/* returns the max register bulk size */
static int
gl124_bulk_full_size (void)
{
return GENESYS_GL124_MAX_REGS;
}
static SANE_Status
gl124_homsnr_gpio(Genesys_Device *dev)
{
@ -227,7 +190,7 @@ gl124_init_registers (Genesys_Device * dev)
{
DBGSTART;
memset (dev->reg, 0, GENESYS_GL124_MAX_REGS * sizeof (Genesys_Register_Set));
dev->reg.clear();
/* default to LiDE 110 */
SETREG (0x01,0xa2); /* + REG01_SHDAREA */
@ -500,26 +463,24 @@ gl124_init_registers (Genesys_Device * dev)
SETREG (0xff,0x00);
/* fine tune upon device description */
dev->reg[reg_0x05].value &= ~REG05_DPIHW;
dev->reg.find_reg(0x05).value &= ~REG05_DPIHW;
switch (dev->sensor.optical_res)
{
case 600:
dev->reg[reg_0x05].value |= REG05_DPIHW_600;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_600;
break;
case 1200:
dev->reg[reg_0x05].value |= REG05_DPIHW_1200;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_1200;
break;
case 2400:
dev->reg[reg_0x05].value |= REG05_DPIHW_2400;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_2400;
break;
case 4800:
dev->reg[reg_0x05].value |= REG05_DPIHW_4800;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_4800;
break;
}
/* initalize calibration reg */
memcpy (dev->calib_reg, dev->reg,
GENESYS_GL124_MAX_REGS * sizeof (Genesys_Register_Set));
dev->calib_reg = dev->reg;
DBGCOMPLETED;
}
@ -739,7 +700,6 @@ gl124_init_motor_regs_scan (Genesys_Device * dev,
uint16_t fast_table[SLOPE_TABLE_SIZE];
int scan_steps,fast_steps,factor;
unsigned int feedl,dist;
Genesys_Register_Set *r;
uint32_t z1, z2;
float yres;
int min_speed;
@ -801,21 +761,25 @@ gl124_init_motor_regs_scan (Genesys_Device * dev,
DBG (DBG_io, "%s: lincnt=%d\n", __func__, lincnt);
/* compute register 02 value */
r = sanei_genesys_get_address (reg, REG02);
r->value = REG02_NOTHOME;
r->value |= REG02_MTRPWR;
uint8_t r02 = REG02_NOTHOME;
r02 |= REG02_MTRPWR;
if (use_fast_fed)
r->value |= REG02_FASTFED;
else
r->value &= ~REG02_FASTFED;
if (use_fast_fed) {
r02 |= REG02_FASTFED;
} else {
r02 &= ~REG02_FASTFED;
}
if (flags & MOTOR_FLAG_AUTO_GO_HOME)
r->value |= REG02_AGOHOME;
if (flags & MOTOR_FLAG_AUTO_GO_HOME)
r02 |= REG02_AGOHOME;
if ((flags & MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE)
||(yres>=dev->sensor.optical_res))
r->value |= REG02_ACDCDIS;
if ((flags & MOTOR_FLAG_DISABLE_BUFFER_FULL_MOVE)
||(yres>=dev->sensor.optical_res))
{
r02 |= REG02_ACDCDIS;
}
reg->set8(REG02, r02);
/* SCANFED */
sanei_genesys_set_double(reg,REG_SCANFED,4);
@ -905,11 +869,8 @@ gl124_init_motor_regs_scan (Genesys_Device * dev,
DBG(DBG_info, "%s: z2 = %d\n", __func__, z2);
/* LINESEL */
r = sanei_genesys_get_address (reg, REG1D);
r->value = (r->value & ~REG1D_LINESEL) | linesel;
r = sanei_genesys_get_address (reg, REGA0);
r->value = (scan_step_type << REGA0S_STEPSEL) | (scan_step_type << REGA0S_FSTPSEL);
reg->set8_mask(REG1D, linesel, REG1D_LINESEL);
reg->set8(REGA0, (scan_step_type << REGA0S_STEPSEL) | (scan_step_type << REGA0S_FSTPSEL));
/* FMOVDEC */
sanei_genesys_set_double(reg,REG_FMOVDEC,fast_steps);
@ -934,76 +895,38 @@ gl124_init_motor_regs_scan (Genesys_Device * dev,
static void
gl124_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi, int half_ccd)
{
Genesys_Register_Set *r;
int i;
Sensor_Profile *sensor;
int dpihw;
uint32_t exp;
DBGSTART;
/* we start at 6, 0-5 is a 16 bits cache for exposure */
for (i = 0x06; i < 0x0e; i++)
{
r = sanei_genesys_get_address (regs, 0x10 + i);
if (r)
{
r->value = dev->sensor.regs_0x10_0x1d[i];
}
// we start at 6, 0-5 is a 16 bits cache for exposure
for (int i = 0x06; i < 0x0e; i++) {
regs->set8(0x10 + i, dev->sensor.regs_0x10_0x1d[i]);
}
/* skip writing 5d,5e which is AFE address because
* they are not deifned in register set */
for (i = 0; i < 11; i++)
{
r = sanei_genesys_get_address (regs, 0x52 + i);
if (r)
{
r->value = dev->sensor.regs_0x52_0x5e[i];
}
// skip writing 5d,5e which is AFE address because
// they are not deifned in register set */
for (int i = 0; i < 11; i++) {
regs->set8(0x52 + i, dev->sensor.regs_0x52_0x5e[i]);
}
/* set EXPDUMMY and CKxMAP */
dpihw=sanei_genesys_compute_dpihw(dev,dpi);
sensor=get_sensor_profile(dev->model->ccd_type, dpihw, half_ccd);
r = sanei_genesys_get_address (regs, 0x18);
if (r)
{
r->value = sensor->reg18;
regs->set8(0x18, sensor->reg18);
regs->set8(0x20, sensor->reg20);
regs->set8(0x61, sensor->reg61);
regs->set8(0x98, sensor->reg98);
if (sensor->reg16 != 0) {
regs->set8(0x16, sensor->reg16);
}
r = sanei_genesys_get_address (regs, 0x20);
if (r)
{
r->value = sensor->reg20;
}
r = sanei_genesys_get_address (regs, 0x61);
if (r)
{
r->value = sensor->reg61;
}
r = sanei_genesys_get_address (regs, 0x98);
if (r)
{
r->value = sensor->reg98;
if (sensor->reg70 != 0) {
regs->set8(0x70, sensor->reg70);
}
if(sensor->reg16!=0)
{
r = sanei_genesys_get_address (regs, 0x16);
if (r)
{
r->value = sensor->reg16;
}
}
if(sensor->reg70!=0)
{
r = sanei_genesys_get_address (regs, 0x70);
if (r)
{
r->value = sensor->reg70;
}
}
sanei_genesys_set_triple(regs,REG_SEGCNT,sensor->segcnt);
sanei_genesys_set_double(regs,REG_TG0CNT,sensor->tg0cnt);
@ -1076,7 +999,7 @@ gl124_init_optical_regs_scan (Genesys_Device * dev,
unsigned int startx, endx, used_pixels, segnb;
unsigned int dpiset, cksel, dpihw, factor;
unsigned int bytes;
Genesys_Register_Set *r;
GenesysRegister *r;
SANE_Status status;
uint32_t expmax, exp;
@ -1248,9 +1171,9 @@ gl124_init_optical_regs_scan (Genesys_Device * dev,
{
expmax=exp;
}
sanei_genesys_set_triple(dev->reg,REG_EXPR,expmax);
sanei_genesys_set_triple(dev->reg,REG_EXPG,expmax);
sanei_genesys_set_triple(dev->reg,REG_EXPB,expmax);
sanei_genesys_set_triple(&dev->reg,REG_EXPR,expmax);
sanei_genesys_set_triple(&dev->reg,REG_EXPG,expmax);
sanei_genesys_set_triple(&dev->reg,REG_EXPB,expmax);
}
/* RGB weighting, REG_TRUER,G and B are to be set */
r = sanei_genesys_get_address (reg, 0x01);
@ -1775,11 +1698,11 @@ gl124_save_power (Genesys_Device * dev, SANE_Bool enable)
static SANE_Status
gl124_set_powersaving (Genesys_Device * dev, int delay /* in minutes */ )
{
Genesys_Register_Set *r;
GenesysRegister *r;
DBG(DBG_proc, "%s (delay = %d)\n", __func__, delay);
r = sanei_genesys_get_address (dev->reg, REG03);
r = sanei_genesys_get_address (&dev->reg, REG03);
r->value &= ~0xf0;
if(delay<15)
{
@ -1835,9 +1758,9 @@ gl124_stop_action (Genesys_Device * dev)
}
/* ends scan */
val = sanei_genesys_read_reg_from_set (dev->reg, REG01);
val = dev->reg.get8(REG01);
val &= ~REG01_SCAN;
sanei_genesys_set_reg_from_set (dev->reg, REG01, val);
dev->reg.set8(REG01, val);
status = sanei_genesys_write_register (dev, REG01, val);
if (status != SANE_STATUS_GOOD)
{
@ -2029,14 +1952,14 @@ SANE_Status gl124_rewind(Genesys_Device * dev)
RIE (sanei_genesys_write_register(dev, 0x02, byte));
/* and start scan, then wait completion */
RIE (gl124_begin_scan (dev, dev->reg, SANE_TRUE));
RIE (gl124_begin_scan (dev, &dev->reg, SANE_TRUE));
do
{
sanei_genesys_sleep_ms(100);
RIE (sanei_genesys_read_register (dev, REG100, &byte));
}
while(byte & REG100_MOTMFLG);
RIE (gl124_end_scan (dev, dev->reg, SANE_TRUE));
RIE (gl124_end_scan (dev, &dev->reg, SANE_TRUE));
/* restore direction */
RIE (sanei_genesys_read_register (dev, 0x02, &byte));
@ -2057,9 +1980,9 @@ static
SANE_Status
gl124_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
{
Genesys_Register_Set local_reg[GENESYS_GL124_MAX_REGS];
Genesys_Register_Set local_reg;
SANE_Status status;
Genesys_Register_Set *r;
GenesysRegister *r;
uint8_t val;
float resolution;
int loop = 0;
@ -2114,11 +2037,11 @@ gl124_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
}
}
memcpy (local_reg, dev->reg, GENESYS_GL124_MAX_REGS * sizeof (Genesys_Register_Set));
local_reg = dev->reg;
resolution=sanei_genesys_get_lowest_dpi(dev);
status = gl124_init_scan_regs (dev,
local_reg,
&local_reg,
resolution,
resolution,
100,
@ -2144,10 +2067,10 @@ gl124_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
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 = sanei_genesys_get_address(&local_reg, REG02);
r->value |= REG02_MTRREV;
RIE (dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL124_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
RIE(gl124_setup_scan_gpio(dev,resolution));
@ -2157,7 +2080,7 @@ gl124_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
DBG(DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus(status));
gl124_stop_action (dev);
/* restore original registers */
dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL124_MAX_REGS);
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
return status;
}
@ -2207,9 +2130,9 @@ gl124_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
static SANE_Status
gl124_feed (Genesys_Device * dev, unsigned int steps, int reverse)
{
Genesys_Register_Set local_reg[GENESYS_GL124_MAX_REGS];
Genesys_Register_Set local_reg;
SANE_Status status;
Genesys_Register_Set *r;
GenesysRegister *r;
float resolution;
uint8_t val;
@ -2217,11 +2140,11 @@ gl124_feed (Genesys_Device * dev, unsigned int steps, int reverse)
DBG (DBG_io, "%s: steps=%d\n", __func__, steps);
/* prepare local registers */
memcpy (local_reg, dev->reg, GENESYS_GL124_MAX_REGS * sizeof (Genesys_Register_Set));
local_reg = dev->reg;
resolution=sanei_genesys_get_lowest_ydpi(dev);
status = gl124_init_scan_regs (dev,
local_reg,
&local_reg,
resolution,
resolution,
0,
@ -2246,27 +2169,27 @@ gl124_feed (Genesys_Device * dev, unsigned int steps, int reverse)
}
/* set exposure to zero */
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);
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 */
RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRLNCNT));
RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRMCNT));
/* set up for no scan */
r = sanei_genesys_get_address (local_reg, REG01);
r = sanei_genesys_get_address (&local_reg, REG01);
r->value &= ~REG01_SCAN;
/* set up for reverse if needed */
if(reverse)
{
r = sanei_genesys_get_address (local_reg, REG02);
r = sanei_genesys_get_address (&local_reg, REG02);
r->value |= REG02_MTRREV;
}
/* send registers */
RIE (dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL124_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
status = gl124_start_action (dev);
if (status != SANE_STATUS_GOOD)
@ -2275,7 +2198,7 @@ gl124_feed (Genesys_Device * dev, unsigned int steps, int reverse)
gl124_stop_action (dev);
/* restore original registers */
dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL124_MAX_REGS);
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
return status;
}
@ -2302,7 +2225,7 @@ gl124_search_start_position (Genesys_Device * dev)
{
int size;
SANE_Status status;
Genesys_Register_Set local_reg[GENESYS_GL124_MAX_REGS];
Genesys_Register_Set local_reg = dev->reg;
int steps;
int pixels = 600;
@ -2310,14 +2233,11 @@ gl124_search_start_position (Genesys_Device * dev)
DBGSTART;
memcpy (local_reg, dev->reg,
GENESYS_GL124_MAX_REGS * sizeof (Genesys_Register_Set));
/* sets for a 200 lines * 600 pixels */
/* normal scan with no shading */
status = gl124_init_scan_regs (dev,
local_reg,
&local_reg,
dpi,
dpi,
0,
@ -2340,7 +2260,7 @@ gl124_search_start_position (Genesys_Device * dev)
}
/* send to scanner */
status = dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL124_MAX_REGS);
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
@ -2351,7 +2271,7 @@ gl124_search_start_position (Genesys_Device * dev)
std::vector<uint8_t> data(size);
status = gl124_begin_scan (dev, local_reg, SANE_TRUE);
status = gl124_begin_scan (dev, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to begin scan: %s\n", __func__, sane_strstatus(status));
@ -2375,7 +2295,7 @@ gl124_search_start_position (Genesys_Device * dev)
sanei_genesys_write_pnm_file("gl124_search_position.pnm", data.data(), 8, 1, pixels,
dev->model->search_lines);
status = gl124_end_scan (dev, local_reg, SANE_TRUE);
status = gl124_end_scan (dev, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to end scan: %s\n", __func__, sane_strstatus(status));
@ -2383,8 +2303,7 @@ gl124_search_start_position (Genesys_Device * dev)
}
/* update regs to copy ASIC internal state */
memcpy (dev->reg, local_reg,
GENESYS_GL124_MAX_REGS * sizeof (Genesys_Register_Set));
dev->reg = local_reg;
status =
sanei_genesys_search_reference_point (dev, data.data(), 0, dpi, pixels,
@ -2411,7 +2330,7 @@ gl124_init_regs_for_coarse_calibration (Genesys_Device * dev)
uint8_t cksel;
DBGSTART;
cksel = (dev->calib_reg[reg_0x18].value & REG18_CKSEL) + 1; /* clock speed = 1..4 clocks */
cksel = (dev->calib_reg.find_reg(0x18).value & REG18_CKSEL) + 1; /* clock speed = 1..4 clocks */
/* set line size */
if (dev->settings.scan_mode == SCAN_MODE_COLOR) /* single pass color */
@ -2420,7 +2339,7 @@ gl124_init_regs_for_coarse_calibration (Genesys_Device * dev)
channels = 1;
status = gl124_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
dev->settings.xres,
dev->settings.yres,
0,
@ -2442,12 +2361,12 @@ gl124_init_regs_for_coarse_calibration (Genesys_Device * dev)
DBG(DBG_error, "%s: failed to setup scan: %s\n", __func__, sane_strstatus(status));
return status;
}
gl124_set_motor_power (dev->calib_reg, SANE_FALSE);
gl124_set_motor_power(&dev->calib_reg, SANE_FALSE);
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
dev->sensor.optical_res / cksel, dev->settings.xres);
status = dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL124_MAX_REGS);
status = dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
@ -2470,7 +2389,7 @@ gl124_init_regs_for_shading (Genesys_Device * dev)
DBGSTART;
/* initial calibration reg values */
memcpy (dev->calib_reg, dev->reg, GENESYS_GL124_MAX_REGS * sizeof (Genesys_Register_Set));
dev->calib_reg = dev->reg;
dev->calib_channels = 3;
dev->calib_lines = dev->model->shading_lines;
@ -2502,7 +2421,7 @@ gl124_init_regs_for_shading (Genesys_Device * dev)
DBG (DBG_io, "%s: move=%d steps\n", __func__, move);
status = gl124_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
resolution,
resolution,
0,
@ -2518,7 +2437,7 @@ gl124_init_regs_for_shading (Genesys_Device * dev)
SCAN_FLAG_DISABLE_GAMMA |
SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE |
SCAN_FLAG_IGNORE_LINE_DISTANCE);
gl124_set_motor_power (dev->calib_reg, SANE_FALSE);
gl124_set_motor_power(&dev->calib_reg, SANE_FALSE);
if (status != SANE_STATUS_GOOD)
{
@ -2529,7 +2448,7 @@ gl124_init_regs_for_shading (Genesys_Device * dev)
dev->scanhead_position_in_steps += dev->calib_lines + move;
status = dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL124_MAX_REGS);
status = dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
@ -2657,7 +2576,7 @@ gl124_init_regs_for_scan (Genesys_Device * dev)
}
status = gl124_init_scan_regs (dev,
dev->reg,
&dev->reg,
dev->settings.xres,
dev->settings.yres,
start,
@ -2696,9 +2615,9 @@ gl124_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
/* logical size of a color as seen by generic code of the frontend */
length = (uint32_t) (size / 3);
sanei_genesys_get_triple(dev->reg,REG_STRPIXEL,&strpixel);
sanei_genesys_get_triple(dev->reg,REG_ENDPIXEL,&endpixel);
sanei_genesys_get_triple(dev->reg,REG_SEGCNT,&segcnt);
sanei_genesys_get_triple(&dev->reg,REG_STRPIXEL,&strpixel);
sanei_genesys_get_triple(&dev->reg,REG_ENDPIXEL,&endpixel);
sanei_genesys_get_triple(&dev->reg,REG_SEGCNT,&segcnt);
if(endpixel==0)
{
endpixel=segcnt;
@ -2706,7 +2625,7 @@ gl124_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
DBG( DBG_io2, "%s: STRPIXEL=%d, ENDPIXEL=%d, PIXELS=%d, SEGCNT=%d\n",__func__,strpixel,endpixel,endpixel-strpixel,segcnt);
/* compute deletion factor */
sanei_genesys_get_double(dev->reg,REG_DPISET,&dpiset);
sanei_genesys_get_double(&dev->reg,REG_DPISET,&dpiset);
dpihw=sanei_genesys_compute_dpihw(dev,dpiset);
factor=dpihw/dpiset;
DBG( DBG_io2, "%s: factor=%d\n",__func__,factor);
@ -2715,7 +2634,7 @@ gl124_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
if(DBG_LEVEL>=DBG_data)
{
dev->binary=fopen("binary.pnm","wb");
sanei_genesys_get_triple(dev->reg, REG_LINCNT, &lines);
sanei_genesys_get_triple(&dev->reg, REG_LINCNT, &lines);
channels=dev->current_setup.channels;
if(dev->binary!=NULL)
{
@ -2821,11 +2740,11 @@ move_to_calibration_area (Genesys_Device * dev)
pixels = (dev->sensor.sensor_pixels*600)/dev->sensor.optical_res;
/* initial calibration reg values */
memcpy (dev->calib_reg, dev->reg, GENESYS_GL124_MAX_REGS * sizeof (Genesys_Register_Set));
dev->calib_reg = dev->reg;
/* set up for the calibration scan */
status = gl124_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
600,
600,
0,
@ -2851,10 +2770,10 @@ move_to_calibration_area (Genesys_Device * dev)
std::vector<uint8_t> line(size);
/* write registers and scan data */
RIE(dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL124_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG (DBG_info, "%s: starting line reading\n", __func__);
RIE(gl124_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl124_begin_scan (dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, line.data(), size));
/* stop scanning */
@ -2914,11 +2833,11 @@ gl124_led_calibration (Genesys_Device * dev)
num_pixels = (dev->sensor.sensor_pixels*resolution)/dev->sensor.optical_res;
/* initial calibration reg values */
memcpy (dev->calib_reg, dev->reg, GENESYS_GL124_MAX_REGS * sizeof (Genesys_Register_Set));
dev->calib_reg = dev->reg;
/* set up for the calibration scan */
status = gl124_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
resolution,
resolution,
0,
@ -2952,19 +2871,19 @@ gl124_led_calibration (Genesys_Device * dev)
turn = 0;
/* no move during led calibration */
gl124_set_motor_power (dev->calib_reg, SANE_FALSE);
gl124_set_motor_power (&dev->calib_reg, SANE_FALSE);
do
{
/* set up exposure */
sanei_genesys_set_triple(dev->calib_reg,REG_EXPR,exp[0]);
sanei_genesys_set_triple(dev->calib_reg,REG_EXPG,exp[1]);
sanei_genesys_set_triple(dev->calib_reg,REG_EXPB,exp[2]);
sanei_genesys_set_triple(&dev->calib_reg,REG_EXPR,exp[0]);
sanei_genesys_set_triple(&dev->calib_reg,REG_EXPG,exp[1]);
sanei_genesys_set_triple(&dev->calib_reg,REG_EXPB,exp[2]);
/* write registers and scan data */
RIE(dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL124_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting line reading\n", __func__);
RIE(gl124_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl124_begin_scan (dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner (dev, line.data(), total_size));
/* stop scanning */
@ -3018,9 +2937,9 @@ gl124_led_calibration (Genesys_Device * dev)
DBG(DBG_info, "%s: acceptable exposure: %d,%d,%d\n", __func__, exp[0], exp[1], exp[2]);
/* set these values as final ones for scan */
sanei_genesys_set_triple(dev->reg,REG_EXPR,exp[0]);
sanei_genesys_set_triple(dev->reg,REG_EXPG,exp[1]);
sanei_genesys_set_triple(dev->reg,REG_EXPB,exp[2]);
sanei_genesys_set_triple(&dev->reg,REG_EXPR,exp[0]);
sanei_genesys_set_triple(&dev->reg,REG_EXPG,exp[1]);
sanei_genesys_set_triple(&dev->reg,REG_EXPB,exp[2]);
/* store in this struct since it is the one used by cache calibration */
dev->sensor.regs_0x10_0x1d[0] = (exp[0] >> 8) & 0xff;
@ -3103,7 +3022,7 @@ gl124_offset_calibration (Genesys_Device * dev)
DBG(DBG_io2, "%s: black_pixels=%d\n", __func__, black_pixels);
status = gl124_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
resolution,
resolution,
0,
@ -3124,7 +3043,7 @@ gl124_offset_calibration (Genesys_Device * dev)
DBG(DBG_error, "%s: failed to setup scan: %s\n", __func__, sane_strstatus(status));
return status;
}
gl124_set_motor_power (dev->calib_reg, SANE_FALSE);
gl124_set_motor_power (&dev->calib_reg, SANE_FALSE);
/* allocate memory for scans */
total_size = pixels * channels * lines * (bpp/8); /* colors * bytes_per_color * scan lines */
@ -3144,9 +3063,9 @@ gl124_offset_calibration (Genesys_Device * dev)
dev->frontend.offset[2] = bottom;
RIE(gl124_set_fe(dev, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL124_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting first line reading\n", __func__);
RIE(gl124_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl124_begin_scan(dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size));
if (DBG_LEVEL >= DBG_data)
{
@ -3164,9 +3083,9 @@ gl124_offset_calibration (Genesys_Device * dev)
dev->frontend.offset[1] = top;
dev->frontend.offset[2] = top;
RIE(gl124_set_fe(dev, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL124_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl124_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl124_begin_scan(dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner (dev, second_line.data(), total_size));
topavg = dark_average(second_line.data(), pixels, lines, channels, black_pixels);
@ -3184,9 +3103,9 @@ gl124_offset_calibration (Genesys_Device * dev)
/* scan with no move */
RIE(gl124_set_fe(dev, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL124_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl124_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl124_begin_scan(dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size));
if (DBG_LEVEL >= DBG_data)
@ -3272,7 +3191,7 @@ gl124_coarse_gain_calibration (Genesys_Device * dev, int dpi)
pixels = (dev->sensor.sensor_pixels * resolution) / dev->sensor.optical_res;
status = gl124_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
resolution,
resolution,
0,
@ -3288,7 +3207,7 @@ gl124_coarse_gain_calibration (Genesys_Device * dev, int dpi)
SCAN_FLAG_DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE);
gl124_set_motor_power (dev->calib_reg, SANE_FALSE);
gl124_set_motor_power(&dev->calib_reg, SANE_FALSE);
if (status != SANE_STATUS_GOOD)
{
@ -3296,15 +3215,14 @@ gl124_coarse_gain_calibration (Genesys_Device * dev, int dpi)
return status;
}
RIE (dev->model->cmd_set->bulk_write_register
(dev, dev->calib_reg, GENESYS_GL124_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
total_size = pixels * channels * (16/bpp) * lines;
std::vector<uint8_t> line(total_size);
RIE(gl124_set_fe(dev, AFE_SET));
RIE(gl124_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl124_begin_scan(dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, line.data(), total_size));
if (DBG_LEVEL >= DBG_data)
@ -3394,7 +3312,7 @@ gl124_init_regs_for_warmup (Genesys_Device * dev,
*channels=3;
memcpy (reg, dev->reg, (GENESYS_GL124_MAX_REGS + 1) * sizeof (Genesys_Register_Set));
*reg = dev->reg;
status = gl124_init_scan_regs (dev,
reg,
dev->sensor.optical_res,
@ -3424,7 +3342,7 @@ gl124_init_regs_for_warmup (Genesys_Device * dev,
*total_size = num_pixels * 3 * 1; /* colors * bytes_per_color * scan lines */
gl124_set_motor_power (reg, SANE_FALSE);
RIE (dev->model->cmd_set->bulk_write_register (dev, reg, GENESYS_GL124_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, *reg));
DBGCOMPLETED;
return SANE_STATUS_GOOD;
@ -3552,7 +3470,7 @@ gl124_init (Genesys_Device * dev)
DBG_INIT ();
DBGSTART;
status=sanei_genesys_asic_init(dev, GENESYS_GL124_MAX_REGS);
status=sanei_genesys_asic_init(dev, 0);
DBGCOMPLETED;
return status;
@ -3597,12 +3515,12 @@ gl124_boot (Genesys_Device * dev, SANE_Bool cold)
gl124_init_registers (dev);
/* Write initial registers */
RIE (dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL124_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, dev->reg));
/* tune reg 0B */
val = REG0B_30MHZ | REG0B_ENBDRAM | REG0B_64M;
RIE (sanei_genesys_write_register (dev, REG0B, val));
dev->reg[reg_0x0b].address = 0x00;
dev->reg.remove_reg(0x0b);
/* set up end access */
RIE (sanei_genesys_write_0x8c (dev, 0x10, 0x0b));
@ -3610,7 +3528,7 @@ gl124_boot (Genesys_Device * dev, SANE_Bool cold)
/* CIS_LINE */
SETREG (0x08, REG08_CIS_LINE);
RIE (sanei_genesys_write_register (dev, 0x08, dev->reg[reg_0x08].value));
RIE (sanei_genesys_write_register (dev, 0x08, dev->reg.find_reg(0x08).value));
/* setup gpio */
RIE (gl124_init_gpio (dev));
@ -3685,8 +3603,6 @@ static Genesys_Command_Set gl124_cmd_set = {
gl124_test_buffer_empty_bit,
gl124_test_motor_flag_bit,
gl124_bulk_full_size,
gl124_set_fe,
gl124_set_powersaving,
gl124_save_power,

223
backend/genesys_gl124.h
Wyświetl plik

@ -301,228 +301,7 @@
#define REG_TRUEG 0x111
#define REG_TRUEB 0x112
/**
* writable scanner registers */
enum
{
reg_0x01 = 0,
reg_0x02,
reg_0x03,
reg_0x04,
reg_0x05,
reg_0x06,
reg_0x07,
reg_0x08,
reg_0x09,
reg_0x0a,
reg_0x0b,
reg_0x0c,
reg_0x11,
reg_0x12,
reg_0x13,
reg_0x14,
reg_0x15,
reg_0x16,
reg_0x17,
reg_0x18,
reg_0x19,
reg_0x1a,
reg_0x1b,
reg_0x1c,
reg_0x1d,
reg_0x1e,
reg_0x1f,
reg_0x20,
reg_0x21,
reg_0x22,
reg_0x23,
reg_0x24,
reg_0x25,
reg_0x26,
reg_0x27,
reg_0x28,
reg_0x29,
reg_0x2a,
reg_0x2b,
reg_0x2c,
reg_0x2d,
reg_0x3b,
reg_0x3c,
reg_0x3d,
reg_0x3e,
reg_0x3f,
reg_0x40,
reg_0x41,
reg_0x42,
reg_0x43,
reg_0x44,
reg_0x45,
reg_0x46,
reg_0x47,
reg_0x48,
reg_0x49,
reg_0x4f,
reg_0x52,
reg_0x53,
reg_0x54,
reg_0x55,
reg_0x56,
reg_0x57,
reg_0x58,
reg_0x59,
reg_0x5a,
reg_0x5b,
reg_0x5c,
reg_0x5f,
reg_0x60,
reg_0x61,
reg_0x62,
reg_0x63,
reg_0x64,
reg_0x65,
reg_0x66,
reg_0x67,
reg_0x68,
reg_0x69,
reg_0x6a,
reg_0x6b,
reg_0x6c,
reg_0x6d,
reg_0x6e,
reg_0x6f,
reg_0x70,
reg_0x71,
reg_0x72,
reg_0x73,
reg_0x74,
reg_0x75,
reg_0x76,
reg_0x77,
reg_0x78,
reg_0x79,
reg_0x7a,
reg_0x7b,
reg_0x7c,
reg_0x7d,
reg_0x7e,
reg_0x7f,
reg_0x80,
reg_0x81,
reg_0x82,
reg_0x83,
reg_0x84,
reg_0x85,
reg_0x86,
reg_0x87,
reg_0x88,
reg_0x89,
reg_0x8a,
reg_0x8b,
reg_0x8c,
reg_0x8d,
reg_0x8e,
reg_0x8f,
reg_0x90,
reg_0x91,
reg_0x92,
reg_0x93,
reg_0x94,
reg_0x95,
reg_0x96,
reg_0x97,
reg_0x98,
reg_0x99,
reg_0x9a,
reg_0x9b,
reg_0x9c,
reg_0x9d,
reg_0x9e,
reg_0x9f,
reg_0xa0,
reg_0xa1,
reg_0xa2,
reg_0xa3,
reg_0xa4,
reg_0xa5,
reg_0xa6,
reg_0xa7,
reg_0xa8,
reg_0xa9,
reg_0xaa,
reg_0xab,
reg_0xac,
reg_0xad,
reg_0xae,
reg_0xaf,
reg_0xb0,
reg_0xb1,
reg_0xb2,
reg_0xb3,
reg_0xb4,
reg_0xb5,
reg_0xb6,
reg_0xb7,
reg_0xb8,
reg_0xbb,
reg_0xbc,
reg_0xbd,
reg_0xbe,
reg_0xc3,
reg_0xc4,
reg_0xc5,
reg_0xc6,
reg_0xc7,
reg_0xc8,
reg_0xc9,
reg_0xca,
reg_0xcb,
reg_0xcc,
reg_0xcd,
reg_0xce,
reg_0xd0,
reg_0xd1,
reg_0xd2,
reg_0xd3,
reg_0xd4,
reg_0xd5,
reg_0xd6,
reg_0xd7,
reg_0xd8,
reg_0xd9,
reg_0xe0,
reg_0xe1,
reg_0xe2,
reg_0xe3,
reg_0xe4,
reg_0xe5,
reg_0xe6,
reg_0xe7,
reg_0xe8,
reg_0xe9,
reg_0xea,
reg_0xeb,
reg_0xec,
reg_0xed,
reg_0xee,
reg_0xef,
reg_0xf0,
reg_0xf1,
reg_0xf2,
reg_0xf3,
reg_0xf4,
reg_0xf5,
reg_0xf6,
reg_0xf7,
reg_0xf8,
reg_0xf9,
reg_0xfa,
reg_0xfb,
reg_0xfc,
reg_0xff,
GENESYS_GL124_MAX_REGS
};
#define SETREG(adr,val) {dev->reg[reg_##adr].address=adr;dev->reg[reg_##adr].value=val;}
#define SETREG(adr,val) { dev->reg.init_reg(adr, val); }
typedef struct
{

601
backend/genesys_gl646.cc
Wyświetl plik

Plik diff jest za duży Load Diff

86
backend/genesys_gl646.h
Wyświetl plik

@ -165,92 +165,6 @@
#include "genesys.h"
enum
{
reg_0x01 = 0,
reg_0x02,
reg_0x03,
reg_0x04,
reg_0x05,
reg_0x06,
reg_0x07,
reg_0x08,
reg_0x09,
reg_0x0a,
reg_0x0b,
reg_0x10,
reg_0x11,
reg_0x12,
reg_0x13,
reg_0x14,
reg_0x15,
reg_0x16,
reg_0x17,
reg_0x18,
reg_0x19,
reg_0x1a,
reg_0x1b,
reg_0x1c,
reg_0x1d,
reg_0x1e,
reg_0x1f,
reg_0x20,
reg_0x21,
reg_0x22,
reg_0x23,
reg_0x24,
reg_0x25,
reg_0x26,
reg_0x27,
reg_0x28,
reg_0x29,
reg_0x2c,
reg_0x2d,
reg_0x2e,
reg_0x2f,
reg_0x30,
reg_0x31,
reg_0x32,
reg_0x33,
reg_0x34,
reg_0x35,
reg_0x36,
reg_0x37,
reg_0x38,
reg_0x39,
reg_0x3d,
reg_0x3e,
reg_0x3f,
reg_0x52,
reg_0x53,
reg_0x54,
reg_0x55,
reg_0x56,
reg_0x57,
reg_0x58,
reg_0x59,
reg_0x5a,
reg_0x5b,
reg_0x5c,
reg_0x5d,
reg_0x5e,
reg_0x60,
reg_0x61,
reg_0x62,
reg_0x63,
reg_0x64,
reg_0x65,
reg_0x66,
reg_0x67,
reg_0x68,
reg_0x69,
reg_0x6a,
reg_0x6b,
reg_0x6c,
reg_0x6d,
GENESYS_GL646_MAX_REGS
};
static SANE_Status gl646_set_fe (Genesys_Device * dev, uint8_t set, int dpi);
static SANE_Status gl646_public_set_fe (Genesys_Device * dev, uint8_t set);

519
backend/genesys_gl841.cc
Wyświetl plik

Plik diff jest za duży Load Diff

119
backend/genesys_gl841.h
Wyświetl plik

@ -250,124 +250,7 @@
#define REG87_LEDADD 0x04
enum
{
reg_0x01 = 0,
reg_0x02,
reg_0x03,
reg_0x04,
reg_0x05,
reg_0x06,
reg_0x07,
reg_0x08,
reg_0x09,
reg_0x0a,
reg_0x10,
reg_0x11,
reg_0x12,
reg_0x13,
reg_0x14,
reg_0x15,
reg_0x16,
reg_0x17,
reg_0x18,
reg_0x19,
reg_0x1a,
reg_0x1b,
reg_0x1c,
reg_0x1d,
reg_0x1e,
reg_0x1f,
reg_0x20,
reg_0x21,
reg_0x22,
reg_0x23,
reg_0x24,
reg_0x25,
reg_0x26,
reg_0x27,
reg_0x29,
reg_0x2c,
reg_0x2d,
reg_0x2e,
reg_0x2f,
reg_0x30,
reg_0x31,
reg_0x32,
reg_0x33,
reg_0x34,
reg_0x35,
reg_0x36,
reg_0x37,
reg_0x38,
reg_0x39,
reg_0x3d,
reg_0x3e,
reg_0x3f,
reg_0x52,
reg_0x53,
reg_0x54,
reg_0x55,
reg_0x56,
reg_0x57,
reg_0x58,
reg_0x59,
reg_0x5a,
reg_0x5d,
reg_0x5e,
reg_0x5f,
reg_0x60,
reg_0x61,
reg_0x62,
reg_0x63,
reg_0x64,
reg_0x65,
reg_0x66,
reg_0x67,
reg_0x68,
reg_0x69,
reg_0x6a,
reg_0x6b,
reg_0x6c,
reg_0x6d,
reg_0x6e,
reg_0x6f,
reg_0x70,
reg_0x71,
reg_0x72,
reg_0x73,
reg_0x74,
reg_0x75,
reg_0x76,
reg_0x77,
reg_0x78,
reg_0x79,
reg_0x7a,
reg_0x7b,
reg_0x7c,
reg_0x7d,
reg_0x7e,
reg_0x7f,
reg_0x80,
reg_0x81,
reg_0x82,
reg_0x83,
reg_0x84,
reg_0x85,
reg_0x86,
reg_0x87,
reg_0x88,
reg_0x89,
GENESYS_GL841_MAX_REGS
};
#define INITREG(adr,val) {dev->reg[index].address=adr;dev->reg[index].value=val;index++;}
#define INITREG(adr,val) {dev->reg.init_reg(adr, val); }
/**
* prototypes declaration in case of unit testing

246
backend/genesys_gl843.cc
Wyświetl plik

@ -135,7 +135,7 @@ write_data (Genesys_Device * dev, uint32_t addr, uint32_t size,
static SANE_Bool
gl843_get_fast_feed_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
r = sanei_genesys_get_address (regs, REG02);
if (r && (r->value & REG02_FASTFED))
@ -146,7 +146,7 @@ gl843_get_fast_feed_bit (Genesys_Register_Set * regs)
static SANE_Bool
gl843_get_filter_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
r = sanei_genesys_get_address (regs, REG04);
if (r && (r->value & REG04_FILTER))
@ -157,7 +157,7 @@ gl843_get_filter_bit (Genesys_Register_Set * regs)
static SANE_Bool
gl843_get_lineart_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
r = sanei_genesys_get_address (regs, REG04);
if (r && (r->value & REG04_LINEART))
@ -168,7 +168,7 @@ gl843_get_lineart_bit (Genesys_Register_Set * regs)
static SANE_Bool
gl843_get_bitset_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
r = sanei_genesys_get_address (regs, REG04);
if (r && (r->value & REG04_BITSET))
@ -179,7 +179,7 @@ gl843_get_bitset_bit (Genesys_Register_Set * regs)
static SANE_Bool
gl843_get_gain4_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
r = sanei_genesys_get_address (regs, REG06);
if (r && (r->value & REG06_GAIN4))
@ -193,7 +193,7 @@ gl843_get_gain4_bit (Genesys_Register_Set * regs)
static int
gl843_get_step_multiplier (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
int value = 1;
r = sanei_genesys_get_address (regs, REG9D);
@ -299,7 +299,7 @@ static Sensor_Profile *get_sensor_profile(int sensor_type, int dpi, int flags)
static void
gl843_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi,int flags)
{
Genesys_Register_Set *r;
GenesysRegister *r;
Sensor_Profile *sensor;
int i,dpihw;
@ -366,13 +366,6 @@ gl843_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi,i
}
/* returns the max register bulk size */
static int
gl843_bulk_full_size (void)
{
return GENESYS_GL843_MAX_REGS;
}
/** @brief set all registers to default values .
* This function is called only once at the beginning and
* fills register startup values for registers reused across scans.
@ -389,7 +382,7 @@ gl843_init_registers (Genesys_Device * dev)
DBGSTART;
memset (dev->reg, 0, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
dev->reg.clear();
/* default to KV-SS080 */
SETREG (0xa2, 0x0f);
@ -411,20 +404,20 @@ gl843_init_registers (Genesys_Device * dev)
SETREG (0x05, 0x08);
}
dev->reg[reg_0x05].value &= ~REG05_DPIHW;
dev->reg.find_reg(0x05).value &= ~REG05_DPIHW;
switch (dev->sensor.optical_res)
{
case 600:
dev->reg[reg_0x05].value |= REG05_DPIHW_600;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_600;
break;
case 1200:
dev->reg[reg_0x05].value |= REG05_DPIHW_1200;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_1200;
break;
case 2400:
dev->reg[reg_0x05].value |= REG05_DPIHW_2400;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_2400;
break;
case 4800:
dev->reg[reg_0x05].value |= REG05_DPIHW_4800;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_4800;
break;
}
@ -452,9 +445,9 @@ gl843_init_registers (Genesys_Device * dev)
SETREG(0x15, 0x00); // SENSOR_DEF
if (dev->model->model_id == MODEL_CANON_CANOSCAN_8600F)
{
sanei_genesys_set_double(dev->reg,REG_EXPR,0x9c40);
sanei_genesys_set_double(dev->reg,REG_EXPG,0x9c40);
sanei_genesys_set_double(dev->reg,REG_EXPB,0x9c40);
dev->reg.set16(REG_EXPR, 0x9c40);
dev->reg.set16(REG_EXPG, 0x9c40);
dev->reg.set16(REG_EXPB, 0x9c40);
}
// CCD signal settings.
SETREG(0x16, 0x33); // SENSOR_DEF
@ -801,9 +794,9 @@ gl843_init_registers (Genesys_Device * dev)
SETREG (0x9d, 0x08); /* STEPTIM=2 */
SETREG (0xa2, 0x1f);
SETREG (0xab, 0x00);
sanei_genesys_set_double(dev->reg,REG_EXPR,0x9c40);
sanei_genesys_set_double(dev->reg,REG_EXPG,0x9c40);
sanei_genesys_set_double(dev->reg,REG_EXPB,0x9c40);
sanei_genesys_set_double(&dev->reg,REG_EXPR,0x9c40);
sanei_genesys_set_double(&dev->reg,REG_EXPG,0x9c40);
sanei_genesys_set_double(&dev->reg,REG_EXPB,0x9c40);
}
if (dev->model->model_id == MODEL_CANON_CANOSCAN_8400F)
@ -824,8 +817,7 @@ gl843_init_registers (Genesys_Device * dev)
SETREG (0x9d, 0x08); /* STEPTIM=2 */
}
/* initalize calibration reg */
memcpy (dev->calib_reg, dev->reg, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
dev->calib_reg = dev->reg;
DBGCOMPLETED;
}
@ -899,7 +891,7 @@ gl843_set_fe (Genesys_Device * dev, uint8_t set)
{
/* for now there is no support for AD fe */
DBG(DBG_proc, "%s(): unsupported frontend type %d\n", __func__,
dev->reg[reg_0x04].value & REG04_FESET);
dev->reg.find_reg(0x04).value & REG04_FESET);
return SANE_STATUS_UNSUPPORTED;
}
@ -978,7 +970,7 @@ gl843_init_motor_regs_scan (Genesys_Device * dev,
uint16_t fast_table[1024];
int scan_steps,fast_steps, fast_step_type;
unsigned int feedl,factor,dist;
Genesys_Register_Set *r;
GenesysRegister *r;
uint32_t z1, z2;
DBGSTART;
@ -1203,7 +1195,7 @@ gl843_init_optical_regs_scan (Genesys_Device * dev,
unsigned int bytes;
unsigned int tgtime; /**> exposure time multiplier */
unsigned int cksel; /**> clock per system pixel time in capturing image */
Genesys_Register_Set *r;
GenesysRegister *r;
SANE_Status status;
DBG(DBG_proc, "%s : exposure=%d, used_res=%d, start=%d, pixels=%d, channels=%d, depth=%d, "
@ -1931,7 +1923,7 @@ static void
gl843_set_lamp_power (Genesys_Device * dev,
Genesys_Register_Set * regs, SANE_Bool set)
{
Genesys_Register_Set *r;
GenesysRegister *r;
int i;
uint8_t val;
@ -2055,9 +2047,9 @@ gl843_stop_action (Genesys_Device * dev)
}
/* ends scan 646 */
val = sanei_genesys_read_reg_from_set (dev->reg, REG01);
val = dev->reg.get8(REG01);
val &= ~REG01_SCAN;
sanei_genesys_set_reg_from_set (dev->reg, REG01, val);
dev->reg.set8(REG01, val);
status = sanei_genesys_write_register (dev, REG01, val);
if (status != SANE_STATUS_GOOD)
{
@ -2533,31 +2525,31 @@ gl843_end_scan (Genesys_Device * dev, Genesys_Register_Set * reg,
*/
static SANE_Status gl843_park_xpa_lamp (Genesys_Device * dev)
{
Genesys_Register_Set local_reg[GENESYS_GL843_MAX_REGS];
Genesys_Register_Set local_reg;
SANE_Status status;
Genesys_Register_Set *r;
GenesysRegister *r;
uint8_t val;
int loop = 0;
DBGSTART;
/* copy scan settings */
memcpy (local_reg, dev->reg, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
local_reg = dev->reg;
/* set a huge feedl and reverse direction */
sanei_genesys_set_triple(local_reg,REG_FEEDL,0xbdcd);
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 = sanei_genesys_get_address (&local_reg, REG02);
r->value |= REG02_MTRREV;
r = sanei_genesys_get_address (local_reg, REG01);
r = sanei_genesys_get_address (&local_reg, REG01);
r->value &= ~REG01_SCAN;
/* write to scanner and start action */
RIE (dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
RIE (gl843_xpa_motor_on(dev));
status = gl843_start_action (dev);
if (status != SANE_STATUS_GOOD)
@ -2565,7 +2557,7 @@ static SANE_Status gl843_park_xpa_lamp (Genesys_Device * dev)
DBG(DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus(status));
gl843_stop_action (dev);
/* restore original registers */
dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL843_MAX_REGS);
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
return status;
}
@ -2608,9 +2600,9 @@ static SANE_Status gl843_park_xpa_lamp (Genesys_Device * dev)
static SANE_Status
gl843_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
{
Genesys_Register_Set local_reg[GENESYS_GL843_MAX_REGS];
Genesys_Register_Set local_reg;
SANE_Status status;
Genesys_Register_Set *r;
GenesysRegister *r;
uint8_t val;
float resolution;
int loop = 0;
@ -2650,11 +2642,11 @@ gl843_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
return SANE_STATUS_GOOD;
}
memcpy (local_reg, dev->reg, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
local_reg = dev->reg;
resolution=sanei_genesys_get_lowest_ydpi(dev);
status = gl843_init_scan_regs (dev,
local_reg,
&local_reg,
resolution,
resolution,
100,
@ -2680,12 +2672,12 @@ gl843_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
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 = sanei_genesys_get_address(&local_reg, REG02);
r->value |= REG02_MTRREV;
r = sanei_genesys_get_address (local_reg, REG01);
r = sanei_genesys_get_address(&local_reg, REG01);
r->value &= ~REG01_SCAN;
RIE (dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
status = gl843_start_action (dev);
if (status != SANE_STATUS_GOOD)
@ -2693,7 +2685,7 @@ gl843_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
DBG(DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus(status));
gl843_stop_action (dev);
/* restore original registers */
dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL843_MAX_REGS);
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
return status;
}
@ -2742,7 +2734,7 @@ gl843_search_start_position (Genesys_Device * dev)
{
int size;
SANE_Status status;
Genesys_Register_Set local_reg[GENESYS_GL843_MAX_REGS];
Genesys_Register_Set local_reg;
int steps;
int pixels = 600;
@ -2750,13 +2742,13 @@ gl843_search_start_position (Genesys_Device * dev)
DBG(DBG_proc, "%s\n", __func__);
memcpy (local_reg, dev->reg, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
local_reg = dev->reg;
/* sets for a 200 lines * 600 pixels */
/* normal scan with no shading */
status = gl843_init_scan_regs (dev,
local_reg,
&local_reg,
dpi,
dpi,
0,
@ -2778,7 +2770,7 @@ gl843_search_start_position (Genesys_Device * dev)
}
/* send to scanner */
status = dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS);
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
@ -2789,7 +2781,7 @@ gl843_search_start_position (Genesys_Device * dev)
std::vector<uint8_t> data(size);
status = gl843_begin_scan (dev, local_reg, SANE_TRUE);
status = gl843_begin_scan(dev, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to begin scan: %s\n", __func__, sane_strstatus(status));
@ -2808,13 +2800,13 @@ gl843_search_start_position (Genesys_Device * dev)
DBG(DBG_error, "%s: failed to read data: %s\n", __func__, sane_strstatus(status));
return status;
}
RIE(gl843_stop_action_no_move(dev, local_reg));
RIE(gl843_stop_action_no_move(dev, &local_reg));
if (DBG_LEVEL >= DBG_data)
sanei_genesys_write_pnm_file("gl843_search_position.pnm", data.data(), 8, 1, pixels,
dev->model->search_lines);
status = gl843_end_scan (dev, local_reg, SANE_TRUE);
status = gl843_end_scan(dev, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to end scan: %s\n", __func__, sane_strstatus(status));
@ -2822,7 +2814,7 @@ gl843_search_start_position (Genesys_Device * dev)
}
/* update regs to copy ASIC internal state */
memcpy (dev->reg, local_reg, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
dev->reg = local_reg;
status =
sanei_genesys_search_reference_point (dev, data.data(), 0, dpi, pixels,
@ -2848,7 +2840,7 @@ gl843_init_regs_for_coarse_calibration (Genesys_Device * dev)
uint8_t cksel;
DBGSTART;
cksel = (dev->calib_reg[reg_0x18].value & REG18_CKSEL) + 1; /* clock speed = 1..4 clocks */
cksel = (dev->calib_reg.find_reg(0x18).value & REG18_CKSEL) + 1; /* clock speed = 1..4 clocks */
/* set line size */
if (dev->settings.scan_mode == SCAN_MODE_COLOR) /* single pass color */
@ -2865,7 +2857,7 @@ gl843_init_regs_for_coarse_calibration (Genesys_Device * dev)
flags |= SCAN_FLAG_USE_XPA;
status = gl843_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
dev->settings.xres,
dev->settings.yres,
0,
@ -2883,12 +2875,12 @@ gl843_init_regs_for_coarse_calibration (Genesys_Device * dev)
DBG(DBG_error, "%s: failed to setup scan: %s\n", __func__, sane_strstatus(status));
return status;
}
gl843_set_motor_power (dev->calib_reg, SANE_FALSE);
gl843_set_motor_power (&dev->calib_reg, SANE_FALSE);
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
dev->sensor.optical_res / cksel, dev->settings.xres);
status = dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS);
status = dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
@ -2906,20 +2898,20 @@ gl843_init_regs_for_coarse_calibration (Genesys_Device * dev)
static SANE_Status
gl843_feed (Genesys_Device * dev, unsigned int steps)
{
Genesys_Register_Set local_reg[GENESYS_GL843_MAX_REGS];
Genesys_Register_Set local_reg;
SANE_Status status;
Genesys_Register_Set *r;
GenesysRegister *r;
float resolution;
uint8_t val;
DBGSTART;
/* prepare local registers */
memcpy (local_reg, dev->reg, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
local_reg = dev->reg;
resolution=sanei_genesys_get_lowest_ydpi(dev);
status = gl843_init_scan_regs (dev,
local_reg,
&local_reg,
resolution,
resolution,
0,
@ -2946,11 +2938,11 @@ gl843_feed (Genesys_Device * dev, unsigned int steps)
RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRMCNT));
/* set up for no scan */
r = sanei_genesys_get_address (local_reg, REG01);
r = sanei_genesys_get_address(&local_reg, REG01);
r->value &= ~REG01_SCAN;
/* send registers */
RIE (dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
status = gl843_start_action (dev);
if (status != SANE_STATUS_GOOD)
@ -2959,7 +2951,7 @@ gl843_feed (Genesys_Device * dev, unsigned int steps)
gl843_stop_action (dev);
/* restore original registers */
dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL843_MAX_REGS);
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
return status;
}
@ -2992,7 +2984,7 @@ gl843_init_regs_for_shading (Genesys_Device * dev)
DBGSTART;
/* initial calibration reg values */
memcpy (dev->calib_reg, dev->reg, GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
dev->calib_reg = dev->reg;
dev->calib_channels = 3;
if (dev->settings.scan_method == SCAN_METHOD_TRANSPARENCY)
@ -3026,7 +3018,7 @@ gl843_init_regs_for_shading (Genesys_Device * dev)
status = gl843_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
resolution,
resolution,
0,
@ -3051,10 +3043,10 @@ gl843_init_regs_for_shading (Genesys_Device * dev)
dev->calib_total_bytes_to_read = dev->read_bytes_left;
dev->scanhead_position_in_steps += dev->calib_lines + move;
sanei_genesys_get_double(dev->calib_reg,REG_STRPIXEL,&strpixel);
sanei_genesys_get_double(&dev->calib_reg,REG_STRPIXEL,&strpixel);
DBG(DBG_info, "%s: STRPIXEL=%d\n", __func__, strpixel);
status = dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS);
status = dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
@ -3141,7 +3133,7 @@ gl843_init_regs_for_scan (Genesys_Device * dev)
}
status = gl843_init_scan_regs (dev,
dev->reg,
&dev->reg,
dev->settings.xres,
dev->settings.yres,
start,
@ -3227,7 +3219,7 @@ gl843_led_calibration (Genesys_Device * dev)
int avg[3], avga, avge;
int turn;
uint16_t expr, expg, expb;
Genesys_Register_Set *r;
GenesysRegister *r;
SANE_Bool acceptable = SANE_FALSE;
@ -3241,11 +3233,10 @@ gl843_led_calibration (Genesys_Device * dev)
(dev->sensor.sensor_pixels * used_res) / dev->sensor.optical_res;
/* initial calibration reg values */
memcpy (dev->calib_reg, dev->reg,
GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
dev->calib_reg = dev->reg;
status = gl843_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
used_res,
dev->motor.base_ydpi,
0,
@ -3267,9 +3258,7 @@ gl843_led_calibration (Genesys_Device * dev)
return status;
}
RIE (dev->model->cmd_set->bulk_write_register
(dev, dev->calib_reg, GENESYS_GL843_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
total_size = dev->read_bytes_left;
@ -3301,17 +3290,16 @@ gl843_led_calibration (Genesys_Device * dev)
for (i = 0; i < 6; i++)
{
r = sanei_genesys_get_address (dev->calib_reg, 0x10 + i);
r = sanei_genesys_get_address(&dev->calib_reg, 0x10 + i);
r->value = dev->sensor.regs_0x10_0x1d[i];
}
RIE (dev->model->cmd_set->bulk_write_register
(dev, dev->calib_reg, GENESYS_GL843_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting first line reading\n", __func__);
RIE (gl843_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE (gl843_begin_scan(dev, &dev->calib_reg, SANE_TRUE));
RIE (sanei_genesys_read_data_from_scanner(dev, line.data(), total_size));
RIE(gl843_stop_action_no_move(dev, dev->calib_reg));
RIE(gl843_stop_action_no_move(dev, &dev->calib_reg));
if (DBG_LEVEL >= DBG_data)
{
@ -3485,7 +3473,7 @@ gl843_offset_calibration (Genesys_Device * dev)
}
status = gl843_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
resolution,
resolution,
0,
@ -3502,7 +3490,7 @@ gl843_offset_calibration (Genesys_Device * dev)
DBG(DBG_error, "%s: failed to setup scan: %s\n", __func__, sane_strstatus(status));
return status;
}
gl843_set_motor_power (dev->calib_reg, SANE_FALSE);
gl843_set_motor_power(&dev->calib_reg, SANE_FALSE);
/* allocate memory for scans */
total_size = dev->read_bytes_left;
@ -3520,11 +3508,11 @@ gl843_offset_calibration (Genesys_Device * dev)
RIE(gl843_set_fe(dev, AFE_SET));
/* scan with obttom AFE settings */
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg, GENESYS_GL843_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting first line reading\n", __func__);
RIE(gl843_begin_scan(dev, dev->calib_reg, SANE_TRUE));
RIE(gl843_begin_scan(dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size));
RIE(gl843_stop_action_no_move(dev, dev->calib_reg));
RIE(gl843_stop_action_no_move(dev, &dev->calib_reg));
if (DBG_LEVEL >= DBG_data)
{
@ -3549,11 +3537,11 @@ gl843_offset_calibration (Genesys_Device * dev)
RIE(gl843_set_fe (dev, AFE_SET));
/* scan with top AFE values */
RIE(dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl843_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl843_begin_scan(dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size));
RIE(gl843_stop_action_no_move(dev, dev->calib_reg));
RIE(gl843_stop_action_no_move(dev, &dev->calib_reg));
for (i = 0; i < 3; i++)
{
@ -3585,11 +3573,11 @@ gl843_offset_calibration (Genesys_Device * dev)
RIE(gl843_set_fe (dev, AFE_SET));
/* scan with no move */
RIE(dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL843_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl843_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl843_begin_scan(dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size));
RIE(gl843_stop_action_no_move(dev, dev->calib_reg));
RIE(gl843_stop_action_no_move(dev, &dev->calib_reg));
if (DBG_LEVEL >= DBG_data)
{
@ -3706,7 +3694,7 @@ gl843_coarse_gain_calibration (Genesys_Device * dev, int dpi)
}
status = gl843_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
resolution,
resolution,
0,
@ -3718,7 +3706,7 @@ gl843_coarse_gain_calibration (Genesys_Device * dev, int dpi)
SCAN_MODE_COLOR,
dev->settings.color_filter,
flags);
gl843_set_motor_power (dev->calib_reg, SANE_FALSE);
gl843_set_motor_power(&dev->calib_reg, SANE_FALSE);
if (status != SANE_STATUS_GOOD)
{
@ -3726,17 +3714,16 @@ gl843_coarse_gain_calibration (Genesys_Device * dev, int dpi)
return status;
}
RIE (dev->model->cmd_set->bulk_write_register
(dev, dev->calib_reg, GENESYS_GL843_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
total_size = dev->read_bytes_left;
std::vector<uint8_t> line(total_size);
RIE(gl843_set_fe(dev, AFE_SET));
RIE(gl843_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl843_begin_scan(dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner (dev, line.data(), total_size));
RIE(gl843_stop_action_no_move(dev, dev->calib_reg));
RIE(gl843_stop_action_no_move(dev, &dev->calib_reg));
if (DBG_LEVEL >= DBG_data)
sanei_genesys_write_pnm_file("gl843_coarse.pnm", line.data(), bpp, channels, pixels, lines);
@ -3854,7 +3841,7 @@ gl843_init_regs_for_warmup (Genesys_Device * dev,
num_pixels=dev->sensor.sensor_pixels/(factor*2);
*total_size = num_pixels * 3 * 1;
memcpy (reg, dev->reg, (GENESYS_GL843_MAX_REGS + 1) * sizeof (Genesys_Register_Set));
*reg = dev->reg;
status = gl843_init_scan_regs (dev,
reg,
resolution,
@ -3879,7 +3866,7 @@ gl843_init_regs_for_warmup (Genesys_Device * dev,
}
gl843_set_motor_power (reg, SANE_FALSE);
RIE (dev->model->cmd_set->bulk_write_register (dev, reg, GENESYS_GL843_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, *reg));
DBGCOMPLETED;
return SANE_STATUS_GOOD;
@ -3976,13 +3963,13 @@ gl843_boot (Genesys_Device * dev, SANE_Bool cold)
}
/* Write initial registers */
RIE (dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL843_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, dev->reg));
// Enable DRAM by setting a rising edge on bit 3 of reg 0x0b
val = dev->reg[reg_0x0b].value & REG0B_DRAMSEL;
val = dev->reg.find_reg(0x0b).value & REG0B_DRAMSEL;
val = (val | REG0B_ENBDRAM);
RIE (sanei_genesys_write_register (dev, REG0B, val));
dev->reg[reg_0x0b].value = val;
dev->reg.find_reg(0x0b).value = val;
if (dev->model->model_id == MODEL_CANON_CANOSCAN_8600F)
{
@ -3998,13 +3985,13 @@ gl843_boot (Genesys_Device * dev, SANE_Bool cold)
if (dev->model->model_id == MODEL_CANON_CANOSCAN_8600F)
clock_freq = REG0B_60MHZ;
val = (dev->reg[reg_0x0b].value & ~REG0B_CLKSET) | clock_freq;
val = (dev->reg.find_reg(0x0b).value & ~REG0B_CLKSET) | clock_freq;
RIE (sanei_genesys_write_register (dev, REG0B, val));
dev->reg[reg_0x0b].value = val;
dev->reg.find_reg(0x0b).value = val;
/* prevent further writings by bulk write register */
dev->reg[reg_0x0b].address = 0x00;
dev->reg.remove_reg(0x0b);
if (dev->model->model_id != MODEL_CANON_CANOSCAN_8600F)
{
@ -4041,7 +4028,7 @@ gl843_init (Genesys_Device * dev)
DBG_INIT ();
DBGSTART;
status=sanei_genesys_asic_init(dev, GENESYS_GL843_MAX_REGS);
status=sanei_genesys_asic_init(dev, 0);
DBGCOMPLETED;
return status;
@ -4124,11 +4111,11 @@ gl843_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
{
unsigned int pixels, lines, channels;
SANE_Status status;
Genesys_Register_Set local_reg[GENESYS_GL843_MAX_REGS];
Genesys_Register_Set local_reg;
size_t size;
int steps, depth, dpi;
unsigned int pass, count, found, x, y;
Genesys_Register_Set *r;
GenesysRegister *r;
DBG(DBG_proc, "%s %s %s\n", __func__, black ? "black" : "white", forward ? "forward" : "reverse");
@ -4153,11 +4140,10 @@ gl843_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
dev->scanhead_position_in_steps = 0;
memcpy (local_reg, dev->reg,
GENESYS_GL843_MAX_REGS * sizeof (Genesys_Register_Set));
local_reg = dev->reg;
status = gl843_init_scan_regs (dev,
local_reg,
&local_reg,
dpi,
dpi,
0,
@ -4180,21 +4166,21 @@ gl843_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
std::vector<uint8_t> data(size);
/* set up for reverse or forward */
r = sanei_genesys_get_address (local_reg, REG02);
r = sanei_genesys_get_address(&local_reg, REG02);
if (forward)
r->value &= ~REG02_MTRREV;
else
r->value |= REG02_MTRREV;
status = dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS);
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
status = gl843_begin_scan (dev, local_reg, SANE_TRUE);
status = gl843_begin_scan(dev, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to begin scan: %s\n", __func__, sane_strstatus(status));
@ -4235,7 +4221,7 @@ gl843_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
while (pass < 20 && !found)
{
status =
dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL843_MAX_REGS);
dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__,
@ -4244,7 +4230,7 @@ gl843_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
}
/* now start scan */
status = gl843_begin_scan (dev, local_reg, SANE_TRUE);
status = gl843_begin_scan(dev, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to begin scan: %s\n", __func__, sane_strstatus(status));
@ -4384,23 +4370,23 @@ gl843_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
int count,offset;
unsigned int tgtime;
unsigned int cksel;
Genesys_Register_Set *r;
GenesysRegister *r;
uint16_t dpiset, strpixel, endpixel, startx, factor;
DBGSTART;
offset=0;
length=size;
r = sanei_genesys_get_address (dev->reg, REG01);
r = sanei_genesys_get_address(&dev->reg, REG01);
if(r->value & REG01_SHDAREA)
{
/* recompute STRPIXEL used shading calibration so we can
* compute offset within data for SHDAREA case */
r = sanei_genesys_get_address (dev->reg, REG18);
r = sanei_genesys_get_address(&dev->reg, REG18);
cksel= (r->value & REG18_CKSEL)+1;
sanei_genesys_get_double(dev->reg,REG_DPISET,&strpixel);
sanei_genesys_get_double(&dev->reg,REG_DPISET,&strpixel);
tgtime=1;
sanei_genesys_get_double(dev->reg,REG_DPISET,&dpiset);
sanei_genesys_get_double(&dev->reg,REG_DPISET,&dpiset);
factor=dev->sensor.optical_res/sanei_genesys_compute_dpihw(dev,dpiset);
if (dev->model->ccd_type == CCD_G4050 && dpiset>2400)
{
@ -4411,8 +4397,8 @@ gl843_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
startx = ((dev->sensor.dummy_pixel * tgtime)/cksel)/factor;
/* current scan coordinates */
sanei_genesys_get_double(dev->reg,REG_STRPIXEL,&strpixel);
sanei_genesys_get_double(dev->reg,REG_ENDPIXEL,&endpixel);
sanei_genesys_get_double(&dev->reg,REG_STRPIXEL,&strpixel);
sanei_genesys_get_double(&dev->reg,REG_ENDPIXEL,&endpixel);
strpixel*=tgtime;
endpixel*=tgtime;
@ -4490,8 +4476,6 @@ static Genesys_Command_Set gl843_cmd_set = {
gl843_test_buffer_empty_bit,
gl843_test_motor_flag_bit,
gl843_bulk_full_size,
gl843_set_fe,
gl843_set_powersaving,
gl843_save_power,

149
backend/genesys_gl843.h
Wyświetl plik

@ -382,154 +382,7 @@
#define SCAN_FLAG_DISABLE_LAMP 0x040
#define SCAN_FLAG_DYNAMIC_LINEART 0x080
/**
* writable scanner registers */
enum
{
reg_0x01 = 0,
reg_0x02,
reg_0x03,
reg_0x04,
reg_0x05,
reg_0x06,
reg_0x08,
reg_0x09,
reg_0x0a,
reg_0x0b,
reg_0x0c,
reg_0x0f,
reg_0x10,
reg_0x11,
reg_0x12,
reg_0x13,
reg_0x14,
reg_0x15,
reg_0x16,
reg_0x17,
reg_0x18,
reg_0x19,
reg_0x1a,
reg_0x1b,
reg_0x1c,
reg_0x1d,
reg_0x1e,
reg_0x1f,
reg_0x20,
reg_0x21,
reg_0x22,
reg_0x23,
reg_0x24,
reg_0x25,
reg_0x26,
reg_0x27,
reg_0x28,
reg_0x2c,
reg_0x2d,
reg_0x2e,
reg_0x2f,
reg_0x30,
reg_0x31,
reg_0x32,
reg_0x33,
reg_0x34,
reg_0x35,
reg_0x36,
reg_0x37,
reg_0x38,
reg_0x39,
reg_0x3a,
reg_0x3b,
reg_0x3c,
reg_0x3d,
reg_0x3e,
reg_0x3f,
reg_0x51,
reg_0x52,
reg_0x53,
reg_0x54,
reg_0x55,
reg_0x56,
reg_0x57,
reg_0x58,
reg_0x59,
reg_0x5a,
reg_0x5d,
reg_0x5e,
reg_0x5f,
reg_0x60,
reg_0x61,
reg_0x62,
reg_0x63,
reg_0x64,
reg_0x65,
reg_0x67,
reg_0x68,
reg_0x69,
reg_0x6a,
reg_0x6b,
reg_0x70,
reg_0x71,
reg_0x72,
reg_0x73,
reg_0x74,
reg_0x75,
reg_0x76,
reg_0x77,
reg_0x78,
reg_0x79,
reg_0x7a,
reg_0x7b,
reg_0x7c,
reg_0x7d,
reg_0x7e,
reg_0x7f,
reg_0x80,
reg_0x81,
reg_0x82,
reg_0x83,
reg_0x84,
reg_0x85,
reg_0x86,
reg_0x87,
reg_0x88,
reg_0x89,
reg_0x8a,
reg_0x8b,
reg_0x8c,
reg_0x8d,
reg_0x8e,
reg_0x8f,
reg_0x90,
reg_0x91,
reg_0x92,
reg_0x93,
reg_0x94,
reg_0x95,
reg_0x96,
reg_0x97,
reg_0x98,
reg_0x99,
reg_0x9a,
reg_0x9b,
reg_0x9c,
reg_0x9d,
reg_0x9e,
reg_0xa0,
reg_0xa1,
reg_0xa2,
reg_0xa3,
reg_0xa4,
reg_0xa5,
reg_0xaa,
reg_0xab,
reg_0xac,
reg_0xad,
reg_0xae,
reg_0xaf,
GENESYS_GL843_MAX_REGS
};
#define SETREG(adr,val) {dev->reg[reg_##adr].address=adr;dev->reg[reg_##adr].value=val;}
#define SETREG(adr,val) { dev->reg.init_reg(adr, val); }
typedef struct
{

207
backend/genesys_gl846.cc
Wyświetl plik

@ -60,7 +60,7 @@
static SANE_Bool
gl846_get_fast_feed_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
r = sanei_genesys_get_address (regs, REG02);
if (r && (r->value & REG02_FASTFED))
@ -71,7 +71,7 @@ gl846_get_fast_feed_bit (Genesys_Register_Set * regs)
static SANE_Bool
gl846_get_filter_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
r = sanei_genesys_get_address (regs, REG04);
if (r && (r->value & REG04_FILTER))
@ -82,7 +82,7 @@ gl846_get_filter_bit (Genesys_Register_Set * regs)
static SANE_Bool
gl846_get_lineart_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
r = sanei_genesys_get_address (regs, REG04);
if (r && (r->value & REG04_LINEART))
@ -93,7 +93,7 @@ gl846_get_lineart_bit (Genesys_Register_Set * regs)
static SANE_Bool
gl846_get_bitset_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
r = sanei_genesys_get_address (regs, REG04);
if (r && (r->value & REG04_BITSET))
@ -104,7 +104,7 @@ gl846_get_bitset_bit (Genesys_Register_Set * regs)
static SANE_Bool
gl846_get_gain4_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
r = sanei_genesys_get_address (regs, 0x06);
if (r && (r->value & REG06_GAIN4))
@ -134,7 +134,7 @@ gl846_test_motor_flag_bit (SANE_Byte val)
static int
gl846_get_step_multiplier (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
int value = 1;
r = sanei_genesys_get_address (regs, 0x9d);
@ -215,7 +215,7 @@ static int gl846_compute_exposure(Genesys_Device *dev, int xres)
static void
gl846_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi)
{
Genesys_Register_Set *r;
GenesysRegister *r;
Sensor_Profile *sensor;
int dpihw, i;
uint16_t exp;
@ -279,13 +279,6 @@ gl846_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi)
}
/* returns the max register bulk size */
static int
gl846_bulk_full_size (void)
{
return GENESYS_GL846_MAX_REGS;
}
/** @brief set all registers to default values .
* This function is called only once at the beginning and
* fills register startup values for registers reused across scans.
@ -298,8 +291,7 @@ gl846_init_registers (Genesys_Device * dev)
{
DBGSTART;
memset (dev->reg, 0,
GENESYS_GL846_MAX_REGS * sizeof (Genesys_Register_Set));
dev->reg.clear();
SETREG (0x01,0x60);
SETREG (0x02,0x38);
@ -410,26 +402,25 @@ gl846_init_registers (Genesys_Device * dev)
SETREG (0xf8,0x05);
/* fine tune upon device description */
dev->reg[reg_0x05].value &= ~REG05_DPIHW;
dev->reg.find_reg(0x05).value &= ~REG05_DPIHW;
switch (dev->sensor.optical_res)
{
case 600:
dev->reg[reg_0x05].value |= REG05_DPIHW_600;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_600;
break;
case 1200:
dev->reg[reg_0x05].value |= REG05_DPIHW_1200;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_1200;
break;
case 2400:
dev->reg[reg_0x05].value |= REG05_DPIHW_2400;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_2400;
break;
case 4800:
dev->reg[reg_0x05].value |= REG05_DPIHW_4800;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_4800;
break;
}
/* initalize calibration reg */
memcpy (dev->calib_reg, dev->reg,
GENESYS_GL846_MAX_REGS * sizeof (Genesys_Register_Set));
dev->calib_reg = dev->reg;
DBGCOMPLETED;
}
@ -588,14 +579,14 @@ gl846_set_fe (Genesys_Device * dev, uint8_t set)
set == AFE_POWER_SAVE ? "powersave" : "huh?");
/* route to specific analog frontend setup */
switch (dev->reg[reg_0x04].value & REG04_FESET)
switch (dev->reg.find_reg(0x04).value & REG04_FESET)
{
case 0x02: /* ADI FE */
status = gl846_set_adi_fe(dev, set);
break;
default:
DBG(DBG_proc, "%s(): unsupported frontend type %d\n", __func__,
dev->reg[reg_0x04].value & REG04_FESET);
dev->reg.find_reg(0x04).value & REG04_FESET);
status = SANE_STATUS_UNSUPPORTED;
}
@ -625,7 +616,7 @@ gl846_init_motor_regs_scan (Genesys_Device * dev,
uint16_t fast_table[SLOPE_TABLE_SIZE];
int scan_steps, fast_steps, factor;
unsigned int feedl, dist;
Genesys_Register_Set *r;
GenesysRegister *r;
uint32_t z1, z2;
unsigned int min_restep = 0x20;
uint8_t val;
@ -878,7 +869,7 @@ gl846_init_optical_regs_scan (Genesys_Device * dev,
unsigned int startx, endx, used_pixels;
unsigned int dpiset, dpihw,segnb,cksel,factor;
unsigned int bytes;
Genesys_Register_Set *r;
GenesysRegister *r;
SANE_Status status;
Sensor_Profile *sensor;
@ -1611,9 +1602,9 @@ gl846_stop_action (Genesys_Device * dev)
}
/* ends scan */
val = sanei_genesys_read_reg_from_set (dev->reg, REG01);
val = dev->reg.get8(REG01);
val &= ~REG01_SCAN;
sanei_genesys_set_reg_from_set (dev->reg, REG01, val);
dev->reg.set8(REG01, val);
status = sanei_genesys_write_register (dev, REG01, val);
if (status != SANE_STATUS_GOOD)
{
@ -1661,7 +1652,7 @@ gl846_begin_scan (Genesys_Device * dev, Genesys_Register_Set * reg,
{
SANE_Status status;
uint8_t val;
Genesys_Register_Set *r;
GenesysRegister *r;
DBGSTART;
@ -1730,9 +1721,9 @@ gl846_end_scan (Genesys_Device * dev, Genesys_Register_Set * reg,
static SANE_Status
gl846_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
{
Genesys_Register_Set local_reg[GENESYS_GL846_MAX_REGS];
Genesys_Register_Set local_reg;
SANE_Status status;
Genesys_Register_Set *r;
GenesysRegister *r;
float resolution;
uint8_t val;
int loop = 0;
@ -1777,7 +1768,7 @@ gl846_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
return SANE_STATUS_GOOD;
}
memcpy (local_reg, dev->reg, GENESYS_GL846_MAX_REGS * sizeof (Genesys_Register_Set));
local_reg = dev->reg;
resolution=sanei_genesys_get_lowest_ydpi(dev);
@ -1785,7 +1776,7 @@ gl846_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
scan_mode= dev->settings.scan_mode;
dev->settings.scan_mode=SCAN_MODE_LINEART;
status = gl846_init_scan_regs (dev,
local_reg,
&local_reg,
resolution,
resolution,
100,
@ -1810,10 +1801,10 @@ gl846_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRLNCNT | REG0D_CLRMCNT));
/* set up for reverse */
r = sanei_genesys_get_address (local_reg, REG02);
r = sanei_genesys_get_address(&local_reg, REG02);
r->value |= REG02_MTRREV;
RIE (dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL846_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
status = gl846_start_action (dev);
if (status != SANE_STATUS_GOOD)
@ -1821,7 +1812,7 @@ gl846_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
DBG(DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus(status));
gl846_stop_action (dev);
/* send original registers */
dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL846_MAX_REGS);
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
return status;
}
@ -1870,7 +1861,7 @@ gl846_search_start_position (Genesys_Device * dev)
{
int size;
SANE_Status status;
Genesys_Register_Set local_reg[GENESYS_GL846_MAX_REGS];
Genesys_Register_Set local_reg;
int steps;
int pixels = 600;
@ -1878,13 +1869,12 @@ gl846_search_start_position (Genesys_Device * dev)
DBG(DBG_proc, "%s\n", __func__);
memcpy (local_reg, dev->reg,
GENESYS_GL846_MAX_REGS * sizeof (Genesys_Register_Set));
local_reg = dev->reg;
/* sets for a 200 lines * 600 pixels */
/* normal scan with no shading */
status = gl846_init_scan_regs (dev, local_reg, dpi, dpi, 0, 0, /*we should give a small offset here~60 steps */
status = gl846_init_scan_regs (dev, &local_reg, dpi, dpi, 0, 0, /*we should give a small offset here~60 steps */
600, dev->model->search_lines, 8, 1, 1, /*green */
SCAN_FLAG_DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA |
@ -1897,7 +1887,7 @@ gl846_search_start_position (Genesys_Device * dev)
}
/* send to scanner */
status = dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL846_MAX_REGS);
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
@ -1909,7 +1899,7 @@ gl846_search_start_position (Genesys_Device * dev)
std::vector<uint8_t> data(size);
status = gl846_begin_scan (dev, local_reg, SANE_TRUE);
status = gl846_begin_scan(dev, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to begin scan: %s\n", __func__, sane_strstatus(status));
@ -1933,7 +1923,7 @@ gl846_search_start_position (Genesys_Device * dev)
sanei_genesys_write_pnm_file("gl846_search_position.pnm", data.data(), 8, 1, pixels,
dev->model->search_lines);
status = gl846_end_scan (dev, local_reg, SANE_TRUE);
status = gl846_end_scan (dev, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to end scan: %s\n", __func__, sane_strstatus(status));
@ -1941,8 +1931,7 @@ gl846_search_start_position (Genesys_Device * dev)
}
/* update regs to copy ASIC internal state */
memcpy (dev->reg, local_reg,
GENESYS_GL846_MAX_REGS * sizeof (Genesys_Register_Set));
dev->reg = local_reg;
/*TODO: find out where sanei_genesys_search_reference_point
stores information, and use that correctly*/
@ -1972,7 +1961,7 @@ gl846_init_regs_for_coarse_calibration (Genesys_Device * dev)
DBG(DBG_proc, "%s\n", __func__);
cksel = (dev->calib_reg[reg_0x18].value & REG18_CKSEL) + 1; /* clock speed = 1..4 clocks */
cksel = (dev->calib_reg.find_reg(0x18).value & REG18_CKSEL) + 1; /* clock speed = 1..4 clocks */
/* set line size */
if (dev->settings.scan_mode == SCAN_MODE_COLOR) /* single pass color */
@ -1981,7 +1970,7 @@ gl846_init_regs_for_coarse_calibration (Genesys_Device * dev)
channels = 1;
status = gl846_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
dev->settings.xres,
dev->settings.yres,
0,
@ -2004,7 +1993,7 @@ gl846_init_regs_for_coarse_calibration (Genesys_Device * dev)
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
dev->sensor.optical_res / cksel, dev->settings.xres);
status = dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL846_MAX_REGS);
status = dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
@ -2022,9 +2011,9 @@ gl846_init_regs_for_coarse_calibration (Genesys_Device * dev)
static SANE_Status
gl846_feed (Genesys_Device * dev, unsigned int steps)
{
Genesys_Register_Set local_reg[GENESYS_GL846_MAX_REGS];
Genesys_Register_Set local_reg;
SANE_Status status;
Genesys_Register_Set *r;
GenesysRegister *r;
float resolution;
uint8_t val;
@ -2032,11 +2021,11 @@ gl846_feed (Genesys_Device * dev, unsigned int steps)
DBG(DBG_io, "%s: steps=%d\n", __func__, steps);
/* prepare local registers */
memcpy (local_reg, dev->reg, GENESYS_GL846_MAX_REGS * sizeof (Genesys_Register_Set));
local_reg = dev->reg;
resolution=sanei_genesys_get_lowest_ydpi(dev);
status = gl846_init_scan_regs (dev,
local_reg,
&local_reg,
resolution,
resolution,
0,
@ -2058,20 +2047,20 @@ gl846_feed (Genesys_Device * dev, unsigned int steps)
}
/* set exposure to zero */
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);
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 */
RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRLNCNT));
RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRMCNT));
/* set up for no scan */
r = sanei_genesys_get_address (local_reg, REG01);
r = sanei_genesys_get_address(&local_reg, REG01);
r->value &= ~REG01_SCAN;
/* send registers */
RIE (dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL846_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
status = gl846_start_action (dev);
if (status != SANE_STATUS_GOOD)
@ -2080,7 +2069,7 @@ gl846_feed (Genesys_Device * dev, unsigned int steps)
gl846_stop_action (dev);
/* restore original registers */
dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL846_MAX_REGS);
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
return status;
}
@ -2111,7 +2100,7 @@ gl846_init_regs_for_shading (Genesys_Device * dev)
dev->calib_channels = 3;
/* initial calibration reg values */
memcpy (dev->calib_reg, dev->reg, GENESYS_GL846_MAX_REGS * sizeof (Genesys_Register_Set));
dev->calib_reg = dev->reg;
dev->calib_resolution = sanei_genesys_compute_dpihw(dev,dev->settings.xres);
dev->calib_total_bytes_to_read = 0;
@ -2131,7 +2120,7 @@ gl846_init_regs_for_shading (Genesys_Device * dev)
}
status = gl846_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
dev->calib_resolution,
dev->calib_resolution,
0,
@ -2152,7 +2141,7 @@ gl846_init_regs_for_shading (Genesys_Device * dev)
return status;
}
status = dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL846_MAX_REGS);
status = dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
@ -2261,7 +2250,7 @@ gl846_init_regs_for_scan (Genesys_Device * dev)
flags |= SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE;
status = gl846_init_scan_regs (dev,
dev->reg,
&dev->reg,
dev->settings.xres,
dev->settings.yres,
start,
@ -2305,13 +2294,13 @@ gl846_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
write(0x10068000,0x00000dd8)
*/
length = (uint32_t) (size / 3);
sanei_genesys_get_double(dev->reg,REG_STRPIXEL,&tempo);
sanei_genesys_get_double(&dev->reg,REG_STRPIXEL,&tempo);
strpixel=tempo;
sanei_genesys_get_double(dev->reg,REG_ENDPIXEL,&tempo);
sanei_genesys_get_double(&dev->reg,REG_ENDPIXEL,&tempo);
endpixel=tempo;
/* compute deletion factor */
sanei_genesys_get_double(dev->reg,REG_DPISET,&tempo);
sanei_genesys_get_double(&dev->reg,REG_DPISET,&tempo);
dpiset=tempo;
DBG(DBG_io2, "%s: STRPIXEL=%d, ENDPIXEL=%d, PIXELS=%d, DPISET=%d\n", __func__, strpixel, endpixel,
endpixel-strpixel, dpiset);
@ -2322,7 +2311,7 @@ gl846_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
if(DBG_LEVEL>=DBG_data)
{
dev->binary=fopen("binary.pnm","wb");
sanei_genesys_get_triple(dev->reg, REG_LINCNT, &lines);
sanei_genesys_get_triple(&dev->reg, REG_LINCNT, &lines);
channels=dev->current_setup.channels;
if(dev->binary!=NULL)
{
@ -2424,11 +2413,11 @@ gl846_led_calibration (Genesys_Device * dev)
num_pixels = (dev->sensor.sensor_pixels*used_res)/dev->sensor.optical_res;
/* initial calibration reg values */
memcpy (dev->calib_reg, dev->reg, GENESYS_GL846_MAX_REGS * sizeof (Genesys_Register_Set));
dev->calib_reg = dev->reg;
/* set up for the calibration scan */
status = gl846_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
used_res,
used_res,
0,
@ -2467,19 +2456,19 @@ gl846_led_calibration (Genesys_Device * dev)
turn = 0;
/* no move during led calibration */
gl846_set_motor_power (dev->calib_reg, SANE_FALSE);
gl846_set_motor_power (&dev->calib_reg, SANE_FALSE);
do
{
/* set up exposure */
sanei_genesys_set_double(dev->calib_reg,REG_EXPR,exp[0]);
sanei_genesys_set_double(dev->calib_reg,REG_EXPG,exp[1]);
sanei_genesys_set_double(dev->calib_reg,REG_EXPB,exp[2]);
sanei_genesys_set_double(&dev->calib_reg,REG_EXPR,exp[0]);
sanei_genesys_set_double(&dev->calib_reg,REG_EXPG,exp[1]);
sanei_genesys_set_double(&dev->calib_reg,REG_EXPB,exp[2]);
/* write registers and scan data */
RIE(dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL846_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting line reading\n", __func__);
RIE(gl846_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl846_begin_scan (dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, line.data(), total_size));
/* stop scanning */
@ -2537,9 +2526,9 @@ gl846_led_calibration (Genesys_Device * dev)
DBG(DBG_info, "%s: acceptable exposure: %d,%d,%d\n", __func__, exp[0], exp[1], exp[2]);
/* set these values as final ones for scan */
sanei_genesys_set_double(dev->reg,REG_EXPR,exp[0]);
sanei_genesys_set_double(dev->reg,REG_EXPG,exp[1]);
sanei_genesys_set_double(dev->reg,REG_EXPB,exp[2]);
sanei_genesys_set_double(&dev->reg,REG_EXPR,exp[0]);
sanei_genesys_set_double(&dev->reg,REG_EXPG,exp[1]);
sanei_genesys_set_double(&dev->reg,REG_EXPB,exp[2]);
/* store in this struct since it is the one used by cache calibration */
dev->sensor.regs_0x10_0x1d[0] = (exp[0] >> 8) & 0xff;
@ -2626,10 +2615,10 @@ gl846_init_memory_layout (Genesys_Device * dev)
/* CLKSET and DRAMSEL */
val = layouts[idx].dramsel;
RIE (sanei_genesys_write_register (dev, REG0B, val));
dev->reg[reg_0x0b].value = val;
dev->reg.find_reg(0x0b).value = val;
/* prevent further writings by bulk write register */
dev->reg[reg_0x0b].address = 0x00;
dev->reg.remove_reg(0x0b);
/* setup base address for shading and scanned data. */
for(i=0;i<10;i++)
@ -2681,19 +2670,19 @@ gl846_boot (Genesys_Device * dev, SANE_Bool cold)
gl846_init_registers (dev);
/* Write initial registers */
RIE (dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL846_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, dev->reg));
/* Enable DRAM by setting a rising edge on bit 3 of reg 0x0b */
val = dev->reg[reg_0x0b].value & REG0B_DRAMSEL;
val = dev->reg.find_reg(0x0b).value & REG0B_DRAMSEL;
val = (val | REG0B_ENBDRAM);
RIE (sanei_genesys_write_register (dev, REG0B, val));
dev->reg[reg_0x0b].value = val;
dev->reg.find_reg(0x0b).value = val;
/* CIS_LINE */
if (dev->model->is_cis)
{
SETREG (0x08, REG08_CIS_LINE);
RIE (sanei_genesys_write_register (dev, 0x08, dev->reg[reg_0x08].value));
RIE (sanei_genesys_write_register (dev, 0x08, dev->reg.find_reg(0x08).value));
}
/* set up clocks */
@ -2707,7 +2696,7 @@ gl846_boot (Genesys_Device * dev, SANE_Bool cold)
RIE (gl846_init_memory_layout (dev));
SETREG (0xf8, 0x05);
RIE (sanei_genesys_write_register (dev, 0xf8, dev->reg[reg_0xf8].value));
RIE (sanei_genesys_write_register (dev, 0xf8, dev->reg.find_reg(0xf8).value));
DBGCOMPLETED;
return SANE_STATUS_GOOD;
@ -2724,7 +2713,7 @@ static SANE_Status gl846_init (Genesys_Device * dev)
DBG_INIT ();
DBGSTART;
status=sanei_genesys_asic_init(dev, GENESYS_GL846_MAX_REGS);
status=sanei_genesys_asic_init(dev, 0);
DBGCOMPLETED;
return status;
@ -2775,12 +2764,12 @@ gl846_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
{
unsigned int pixels, lines, channels;
SANE_Status status;
Genesys_Register_Set local_reg[GENESYS_GL846_MAX_REGS];
Genesys_Register_Set local_reg;
size_t size;
int steps, depth, dpi;
unsigned int pass, count, found, x, y;
char title[80];
Genesys_Register_Set *r;
GenesysRegister *r;
DBG(DBG_proc, "%s %s %s\n", __func__, black ? "black" : "white", forward ? "forward" : "reverse");
@ -2817,11 +2806,10 @@ gl846_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
dev->scanhead_position_in_steps = 0;
memcpy (local_reg, dev->reg,
GENESYS_GL846_MAX_REGS * sizeof (Genesys_Register_Set));
local_reg = dev->reg;
status = gl846_init_scan_regs (dev,
local_reg,
&local_reg,
dpi,
dpi,
0,
@ -2840,21 +2828,21 @@ gl846_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
}
/* set up for reverse or forward */
r = sanei_genesys_get_address (local_reg, REG02);
r = sanei_genesys_get_address (&local_reg, REG02);
if (forward)
r->value &= ~REG02_MTRREV;
else
r->value |= REG02_MTRREV;
status = dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL846_MAX_REGS);
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
status = gl846_begin_scan (dev, local_reg, SANE_TRUE);
status = gl846_begin_scan (dev, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to begin scan: %s\n", __func__, sane_strstatus(status));
@ -2893,7 +2881,7 @@ gl846_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
found = 0;
while (pass < 20 && !found)
{
status = dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL846_MAX_REGS);
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to bulk write registers: %s\n", __func__,
@ -2902,7 +2890,7 @@ gl846_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
}
/* now start scan */
status = gl846_begin_scan (dev, local_reg, SANE_TRUE);
status = gl846_begin_scan (dev, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to begin scan: %s\n", __func__, sane_strstatus(status));
@ -3097,7 +3085,7 @@ gl846_offset_calibration (Genesys_Device * dev)
DBG(DBG_io2, "%s: black_pixels=%d\n", __func__, black_pixels);
status = gl846_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
resolution,
resolution,
0,
@ -3116,7 +3104,7 @@ gl846_offset_calibration (Genesys_Device * dev)
DBG(DBG_error, "%s: failed to setup scan: %s\n", __func__, sane_strstatus(status));
return status;
}
gl846_set_motor_power (dev->calib_reg, SANE_FALSE);
gl846_set_motor_power (&dev->calib_reg, SANE_FALSE);
/* allocate memory for scans */
total_size = pixels * channels * lines * (bpp/8); /* colors * bytes_per_color * scan lines */
@ -3136,9 +3124,9 @@ gl846_offset_calibration (Genesys_Device * dev)
dev->frontend.offset[2] = bottom;
RIE(gl846_set_fe(dev, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg, GENESYS_GL846_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting first line reading\n", __func__);
RIE(gl846_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl846_begin_scan (dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner (dev, first_line.data(), total_size));
if (DBG_LEVEL >= DBG_data)
{
@ -3156,9 +3144,9 @@ gl846_offset_calibration (Genesys_Device * dev)
dev->frontend.offset[1] = top;
dev->frontend.offset[2] = top;
RIE(gl846_set_fe(dev, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL846_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl846_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl846_begin_scan(dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner (dev, second_line.data(), total_size));
topavg = dark_average(second_line.data(), pixels, lines, channels, black_pixels);
@ -3176,9 +3164,9 @@ gl846_offset_calibration (Genesys_Device * dev)
/* scan with no move */
RIE(gl846_set_fe(dev, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL846_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl846_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl846_begin_scan(dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner (dev, second_line.data(), total_size));
if (DBG_LEVEL >= DBG_data)
@ -3254,7 +3242,7 @@ gl846_coarse_gain_calibration (Genesys_Device * dev, int dpi)
pixels = (dev->sensor.sensor_pixels * resolution) / dev->sensor.optical_res;
status = gl846_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
resolution,
resolution,
0,
@ -3268,7 +3256,7 @@ gl846_coarse_gain_calibration (Genesys_Device * dev, int dpi)
SCAN_FLAG_DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE);
gl846_set_motor_power (dev->calib_reg, SANE_FALSE);
gl846_set_motor_power(&dev->calib_reg, SANE_FALSE);
if (status != SANE_STATUS_GOOD)
{
@ -3276,15 +3264,14 @@ gl846_coarse_gain_calibration (Genesys_Device * dev, int dpi)
return status;
}
RIE (dev->model->cmd_set->bulk_write_register
(dev, dev->calib_reg, GENESYS_GL846_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
total_size = pixels * channels * (16/bpp) * lines;
std::vector<uint8_t> line(total_size);
RIE(gl846_set_fe(dev, AFE_SET));
RIE(gl846_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl846_begin_scan(dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, line.data(), total_size));
if (DBG_LEVEL >= DBG_data)
@ -3355,8 +3342,6 @@ static Genesys_Command_Set gl846_cmd_set = {
gl846_test_buffer_empty_bit,
gl846_test_motor_flag_bit,
gl846_bulk_full_size,
gl846_set_fe,
gl846_set_powersaving,
gl846_save_power,

169
backend/genesys_gl846.h
Wyświetl plik

@ -335,174 +335,7 @@
#define REGF8_SMAXSEL 4
#define REGF8_MINSEL 0x0f
/**
* writable scanner registers */
enum
{
reg_0x01 = 0,
reg_0x02,
reg_0x03,
reg_0x04,
reg_0x05,
reg_0x06,
reg_0x08,
reg_0x09,
reg_0x0a,
reg_0x0b,
reg_0x0c,
reg_0x0d,
reg_0x0e,
reg_0x0f,
reg_0x10,
reg_0x11,
reg_0x12,
reg_0x13,
reg_0x14,
reg_0x15,
reg_0x16,
reg_0x17,
reg_0x18,
reg_0x19,
reg_0x1a,
reg_0x1b,
reg_0x1c,
reg_0x1d,
reg_0x1e,
reg_0x1f,
reg_0x20,
reg_0x21,
reg_0x22,
reg_0x23,
reg_0x24,
reg_0x25,
reg_0x26,
reg_0x27,
reg_0x2c,
reg_0x2d,
reg_0x2e,
reg_0x2f,
reg_0x30,
reg_0x31,
reg_0x32,
reg_0x33,
reg_0x34,
reg_0x35,
reg_0x36,
reg_0x37,
reg_0x38,
reg_0x39,
reg_0x3a,
reg_0x3b,
reg_0x3d,
reg_0x3e,
reg_0x3f,
reg_0x51,
reg_0x52,
reg_0x53,
reg_0x54,
reg_0x55,
reg_0x56,
reg_0x57,
reg_0x58,
reg_0x59,
reg_0x5a,
reg_0x5e,
reg_0x5f,
reg_0x60,
reg_0x61,
reg_0x62,
reg_0x63,
reg_0x64,
reg_0x65,
reg_0x67,
reg_0x68,
reg_0x69,
reg_0x6a,
reg_0x6b,
reg_0x6c,
reg_0x6d,
reg_0x6e,
reg_0x6f,
reg_0x70,
reg_0x71,
reg_0x72,
reg_0x73,
reg_0x74,
reg_0x75,
reg_0x76,
reg_0x77,
reg_0x78,
reg_0x79,
reg_0x7a,
reg_0x7b,
reg_0x7c,
reg_0x7d,
reg_0x7e,
reg_0x7f,
reg_0x80,
reg_0x87,
reg_0x94,
reg_0x98,
reg_0x99,
reg_0x9a,
reg_0x9b,
reg_0x9d,
reg_0x9e,
reg_0xa1,
reg_0xa2,
reg_0xa3,
reg_0xa4,
reg_0xa5,
reg_0xa6,
reg_0xa7,
reg_0xa8,
reg_0xa9,
reg_0xab,
reg_0xbb,
reg_0xbc,
reg_0xbd,
reg_0xbe,
reg_0xc5,
reg_0xc6,
reg_0xc7,
reg_0xc8,
reg_0xc9,
reg_0xca,
reg_0xd0,
reg_0xd1,
reg_0xd2,
reg_0xdb,
reg_0xe0,
reg_0xe1,
reg_0xe2,
reg_0xe3,
reg_0xe4,
reg_0xe5,
reg_0xe6,
reg_0xe7,
reg_0xe8,
reg_0xe9,
reg_0xea,
reg_0xeb,
reg_0xec,
reg_0xed,
reg_0xee,
reg_0xef,
reg_0xf0,
reg_0xf1,
reg_0xf2,
reg_0xf3,
reg_0xf4,
reg_0xf5,
reg_0xf6,
reg_0xf7,
reg_0xf8,
reg_0xfe,
reg_0xff,
GENESYS_GL846_MAX_REGS
};
#define SETREG(adr,val) {dev->reg[reg_##adr].address=adr;dev->reg[reg_##adr].value=val;}
#define SETREG(adr,val) { dev->reg.init_reg(adr, val); }
/** set up registers for an actual scan

206
backend/genesys_gl847.cc
Wyświetl plik

@ -55,7 +55,7 @@
static SANE_Bool
gl847_get_fast_feed_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
r = sanei_genesys_get_address (regs, REG02);
if (r && (r->value & REG02_FASTFED))
@ -66,7 +66,7 @@ gl847_get_fast_feed_bit (Genesys_Register_Set * regs)
static SANE_Bool
gl847_get_filter_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
r = sanei_genesys_get_address (regs, REG04);
if (r && (r->value & REG04_FILTER))
@ -77,7 +77,7 @@ gl847_get_filter_bit (Genesys_Register_Set * regs)
static SANE_Bool
gl847_get_lineart_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
r = sanei_genesys_get_address (regs, REG04);
if (r && (r->value & REG04_LINEART))
@ -88,7 +88,7 @@ gl847_get_lineart_bit (Genesys_Register_Set * regs)
static SANE_Bool
gl847_get_bitset_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
r = sanei_genesys_get_address (regs, REG04);
if (r && (r->value & REG04_BITSET))
@ -99,7 +99,7 @@ gl847_get_bitset_bit (Genesys_Register_Set * regs)
static SANE_Bool
gl847_get_gain4_bit (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
r = sanei_genesys_get_address (regs, 0x06);
if (r && (r->value & REG06_GAIN4))
@ -129,7 +129,7 @@ gl847_test_motor_flag_bit (SANE_Byte val)
static int
gl847_get_step_multiplier (Genesys_Register_Set * regs)
{
Genesys_Register_Set *r = NULL;
GenesysRegister *r = NULL;
int value = 1;
r = sanei_genesys_get_address (regs, 0x9d);
@ -210,7 +210,7 @@ static int gl847_compute_exposure(Genesys_Device *dev, int xres)
static void
gl847_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi)
{
Genesys_Register_Set *r;
GenesysRegister *r;
Sensor_Profile *sensor;
int dpihw, i;
uint16_t exp;
@ -274,13 +274,6 @@ gl847_setup_sensor (Genesys_Device * dev, Genesys_Register_Set * regs, int dpi)
}
/* returns the max register bulk size */
static int
gl847_bulk_full_size (void)
{
return GENESYS_GL847_MAX_REGS;
}
/** @brief set all registers to default values .
* This function is called only once at the beginning and
* fills register startup values for registers reused across scans.
@ -301,8 +294,7 @@ gl847_init_registers (Genesys_Device * dev)
lide700 = 1;
}
memset (dev->reg, 0,
GENESYS_GL847_MAX_REGS * sizeof (Genesys_Register_Set));
dev->reg.clear();
SETREG (0x01, 0x82);
SETREG (0x02, 0x18);
@ -432,26 +424,25 @@ gl847_init_registers (Genesys_Device * dev)
}
/* fine tune upon device description */
dev->reg[reg_0x05].value &= ~REG05_DPIHW;
dev->reg.find_reg(0x05).value &= ~REG05_DPIHW;
switch (dev->sensor.optical_res)
{
case 600:
dev->reg[reg_0x05].value |= REG05_DPIHW_600;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_600;
break;
case 1200:
dev->reg[reg_0x05].value |= REG05_DPIHW_1200;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_1200;
break;
case 2400:
dev->reg[reg_0x05].value |= REG05_DPIHW_2400;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_2400;
break;
case 4800:
dev->reg[reg_0x05].value |= REG05_DPIHW_4800;
dev->reg.find_reg(0x05).value |= REG05_DPIHW_4800;
break;
}
/* initalize calibration reg */
memcpy (dev->calib_reg, dev->reg,
GENESYS_GL847_MAX_REGS * sizeof (Genesys_Register_Set));
dev->calib_reg = dev->reg;
DBGCOMPLETED;
}
@ -631,7 +622,7 @@ gl847_set_fe (Genesys_Device * dev, uint8_t set)
/* for now there is no support yet for wolfson fe */
DBG(DBG_proc, "%s(): unsupported frontend type %d\n", __func__,
dev->reg[reg_0x04].value & REG04_FESET);
dev->reg.find_reg(0x04).value & REG04_FESET);
DBGCOMPLETED;
return SANE_STATUS_UNSUPPORTED;
@ -659,7 +650,7 @@ gl847_init_motor_regs_scan (Genesys_Device * dev,
uint16_t fast_table[SLOPE_TABLE_SIZE];
int scan_steps, fast_steps, factor;
unsigned int feedl, dist;
Genesys_Register_Set *r;
GenesysRegister *r;
uint32_t z1, z2;
unsigned int min_restep = 0x20;
uint8_t val, effective;
@ -893,7 +884,7 @@ gl847_init_optical_regs_scan (Genesys_Device * dev,
unsigned int startx, endx, used_pixels;
unsigned int dpiset, dpihw,segnb,cksel,factor;
unsigned int bytes;
Genesys_Register_Set *r;
GenesysRegister *r;
SANE_Status status;
Sensor_Profile *sensor;
@ -1626,9 +1617,9 @@ gl847_stop_action (Genesys_Device * dev)
}
/* ends scan */
val = sanei_genesys_read_reg_from_set (dev->reg, REG01);
val = dev->reg.get8(REG01);
val &= ~REG01_SCAN;
sanei_genesys_set_reg_from_set (dev->reg, REG01, val);
sanei_genesys_set_reg_from_set(&dev->reg, REG01, val);
status = sanei_genesys_write_register (dev, REG01, val);
if (status != SANE_STATUS_GOOD)
{
@ -1676,7 +1667,7 @@ gl847_begin_scan (Genesys_Device * dev, Genesys_Register_Set * reg,
{
SANE_Status status;
uint8_t val;
Genesys_Register_Set *r;
GenesysRegister *r;
DBGSTART;
@ -1792,9 +1783,9 @@ static
SANE_Status
gl847_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
{
Genesys_Register_Set local_reg[GENESYS_GL847_MAX_REGS];
Genesys_Register_Set local_reg;
SANE_Status status;
Genesys_Register_Set *r;
GenesysRegister *r;
float resolution;
uint8_t val;
int loop = 0;
@ -1839,7 +1830,7 @@ gl847_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
return SANE_STATUS_GOOD;
}
memcpy (local_reg, dev->reg, GENESYS_GL847_MAX_REGS * sizeof (Genesys_Register_Set));
local_reg = dev->reg;
resolution=sanei_genesys_get_lowest_ydpi(dev);
@ -1847,7 +1838,7 @@ gl847_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
scan_mode= dev->settings.scan_mode;
dev->settings.scan_mode=SCAN_MODE_LINEART;
status = gl847_init_scan_regs (dev,
local_reg,
&local_reg,
resolution,
resolution,
100,
@ -1873,10 +1864,10 @@ gl847_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRLNCNT | REG0D_CLRMCNT));
/* set up for reverse */
r = sanei_genesys_get_address (local_reg, REG02);
r = sanei_genesys_get_address (&local_reg, REG02);
r->value |= REG02_MTRREV;
RIE (dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL847_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
status = gl847_start_action (dev);
if (status != SANE_STATUS_GOOD)
@ -1884,7 +1875,7 @@ gl847_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
DBG(DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus(status));
gl847_stop_action (dev);
/* send original registers */
dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL847_MAX_REGS);
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
return status;
}
@ -1933,7 +1924,7 @@ gl847_search_start_position (Genesys_Device * dev)
{
int size;
SANE_Status status;
Genesys_Register_Set local_reg[GENESYS_GL847_MAX_REGS];
Genesys_Register_Set local_reg;
int steps;
int pixels = 600;
@ -1941,13 +1932,12 @@ gl847_search_start_position (Genesys_Device * dev)
DBG(DBG_proc, "%s\n", __func__);
memcpy (local_reg, dev->reg,
GENESYS_GL847_MAX_REGS * sizeof (Genesys_Register_Set));
local_reg = dev->reg;
/* sets for a 200 lines * 600 pixels */
/* normal scan with no shading */
status = gl847_init_scan_regs (dev, local_reg, dpi, dpi, 0, 0, /*we should give a small offset here~60 steps */
status = gl847_init_scan_regs (dev, &local_reg, dpi, dpi, 0, 0, /*we should give a small offset here~60 steps */
600, dev->model->search_lines, 8, 1, 1, /*green */
SCAN_FLAG_DISABLE_SHADING |
SCAN_FLAG_DISABLE_GAMMA |
@ -1960,7 +1950,7 @@ gl847_search_start_position (Genesys_Device * dev)
}
/* send to scanner */
status = dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL847_MAX_REGS);
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
@ -1972,7 +1962,7 @@ gl847_search_start_position (Genesys_Device * dev)
std::vector<uint8_t> data(size);
status = gl847_begin_scan (dev, local_reg, SANE_TRUE);
status = gl847_begin_scan(dev, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to begin scan: %s\n", __func__, sane_strstatus(status));
@ -1996,7 +1986,7 @@ gl847_search_start_position (Genesys_Device * dev)
sanei_genesys_write_pnm_file("gl847_search_position.pnm", data.data(), 8, 1, pixels,
dev->model->search_lines);
status = gl847_end_scan (dev, local_reg, SANE_TRUE);
status = gl847_end_scan(dev, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to end scan: %s\n", __func__, sane_strstatus(status));
@ -2004,8 +1994,7 @@ gl847_search_start_position (Genesys_Device * dev)
}
/* update regs to copy ASIC internal state */
memcpy (dev->reg, local_reg,
GENESYS_GL847_MAX_REGS * sizeof (Genesys_Register_Set));
dev->reg = local_reg;
/*TODO: find out where sanei_genesys_search_reference_point
stores information, and use that correctly*/
@ -2035,7 +2024,7 @@ gl847_init_regs_for_coarse_calibration (Genesys_Device * dev)
DBG(DBG_proc, "%s\n", __func__);
cksel = (dev->calib_reg[reg_0x18].value & REG18_CKSEL) + 1; /* clock speed = 1..4 clocks */
cksel = (dev->calib_reg.find_reg(0x18).value & REG18_CKSEL) + 1; /* clock speed = 1..4 clocks */
/* set line size */
if (dev->settings.scan_mode == SCAN_MODE_COLOR) /* single pass color */
@ -2044,7 +2033,7 @@ gl847_init_regs_for_coarse_calibration (Genesys_Device * dev)
channels = 1;
status = gl847_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
dev->settings.xres,
dev->settings.yres,
0,
@ -2068,7 +2057,7 @@ gl847_init_regs_for_coarse_calibration (Genesys_Device * dev)
dev->sensor.optical_res / cksel, dev->settings.xres);
status =
dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL847_MAX_REGS);
dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
@ -2086,21 +2075,20 @@ gl847_init_regs_for_coarse_calibration (Genesys_Device * dev)
static SANE_Status
gl847_feed (Genesys_Device * dev, unsigned int steps)
{
Genesys_Register_Set local_reg[GENESYS_GL847_MAX_REGS];
Genesys_Register_Set local_reg;
SANE_Status status;
Genesys_Register_Set *r;
GenesysRegister *r;
float resolution;
uint8_t val;
DBGSTART;
DBG(DBG_io, "%s: steps=%d\n", __func__, steps);
/* prepare local registers */
memcpy (local_reg, dev->reg, GENESYS_GL847_MAX_REGS * sizeof (Genesys_Register_Set));
local_reg = dev->reg;
resolution=sanei_genesys_get_lowest_ydpi(dev);
status = gl847_init_scan_regs (dev,
local_reg,
&local_reg,
resolution,
resolution,
0,
@ -2122,20 +2110,20 @@ gl847_feed (Genesys_Device * dev, unsigned int steps)
}
/* set exposure to zero */
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);
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 */
RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRLNCNT));
RIE (sanei_genesys_write_register (dev, REG0D, REG0D_CLRMCNT));
/* set up for no scan */
r = sanei_genesys_get_address (local_reg, REG01);
r = sanei_genesys_get_address(&local_reg, REG01);
r->value &= ~REG01_SCAN;
/* send registers */
RIE (dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL847_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
status = gl847_start_action (dev);
if (status != SANE_STATUS_GOOD)
@ -2144,7 +2132,7 @@ gl847_feed (Genesys_Device * dev, unsigned int steps)
gl847_stop_action (dev);
/* restore original registers */
dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL847_MAX_REGS);
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
return status;
}
@ -2175,7 +2163,7 @@ gl847_init_regs_for_shading (Genesys_Device * dev)
dev->calib_channels = 3;
/* initial calibration reg values */
memcpy (dev->calib_reg, dev->reg, GENESYS_GL847_MAX_REGS * sizeof (Genesys_Register_Set));
dev->calib_reg = dev->reg;
dev->calib_resolution = sanei_genesys_compute_dpihw(dev,dev->settings.xres);
dev->calib_total_bytes_to_read = 0;
@ -2195,7 +2183,7 @@ gl847_init_regs_for_shading (Genesys_Device * dev)
}
status = gl847_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
dev->calib_resolution,
dev->calib_resolution,
0,
@ -2216,7 +2204,7 @@ gl847_init_regs_for_shading (Genesys_Device * dev)
return status;
}
status = dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL847_MAX_REGS);
status = dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
@ -2325,7 +2313,7 @@ gl847_init_regs_for_scan (Genesys_Device * dev)
flags |= SCAN_FLAG_DISABLE_BUFFER_FULL_MOVE;
status = gl847_init_scan_regs (dev,
dev->reg,
&dev->reg,
dev->settings.xres,
dev->settings.yres,
start,
@ -2369,13 +2357,13 @@ gl847_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
write(0x10068000,0x00000dd8)
*/
length = (uint32_t) (size / 3);
sanei_genesys_get_double(dev->reg,REG_STRPIXEL,&tempo);
sanei_genesys_get_double(&dev->reg,REG_STRPIXEL,&tempo);
strpixel=tempo;
sanei_genesys_get_double(dev->reg,REG_ENDPIXEL,&tempo);
sanei_genesys_get_double(&dev->reg,REG_ENDPIXEL,&tempo);
endpixel=tempo;
/* compute deletion factor */
sanei_genesys_get_double(dev->reg,REG_DPISET,&tempo);
sanei_genesys_get_double(&dev->reg,REG_DPISET,&tempo);
dpiset=tempo;
DBG(DBG_io2, "%s: STRPIXEL=%d, ENDPIXEL=%d, PIXELS=%d, DPISET=%d\n", __func__, strpixel, endpixel,
endpixel-strpixel, dpiset);
@ -2386,7 +2374,7 @@ gl847_send_shading_data (Genesys_Device * dev, uint8_t * data, int size)
if(DBG_LEVEL>=DBG_data)
{
dev->binary=fopen("binary.pnm","wb");
sanei_genesys_get_triple(dev->reg, REG_LINCNT, &lines);
sanei_genesys_get_triple(&dev->reg, REG_LINCNT, &lines);
channels=dev->current_setup.channels;
if(dev->binary!=NULL)
{
@ -2488,11 +2476,11 @@ gl847_led_calibration (Genesys_Device * dev)
num_pixels = (dev->sensor.sensor_pixels*used_res)/dev->sensor.optical_res;
/* initial calibration reg values */
memcpy (dev->calib_reg, dev->reg, GENESYS_GL847_MAX_REGS * sizeof (Genesys_Register_Set));
dev->calib_reg = dev->reg;
/* set up for the calibration scan */
status = gl847_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
used_res,
used_res,
0,
@ -2531,19 +2519,19 @@ gl847_led_calibration (Genesys_Device * dev)
turn = 0;
/* no move during led calibration */
gl847_set_motor_power (dev->calib_reg, SANE_FALSE);
gl847_set_motor_power(&dev->calib_reg, SANE_FALSE);
do
{
/* set up exposure */
sanei_genesys_set_double(dev->calib_reg,REG_EXPR,exp[0]);
sanei_genesys_set_double(dev->calib_reg,REG_EXPG,exp[1]);
sanei_genesys_set_double(dev->calib_reg,REG_EXPB,exp[2]);
sanei_genesys_set_double(&dev->calib_reg,REG_EXPR,exp[0]);
sanei_genesys_set_double(&dev->calib_reg,REG_EXPG,exp[1]);
sanei_genesys_set_double(&dev->calib_reg,REG_EXPB,exp[2]);
/* write registers and scan data */
RIE(dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL847_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting line reading\n", __func__);
RIE(gl847_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl847_begin_scan (dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, line.data(), total_size));
/* stop scanning */
@ -2601,9 +2589,9 @@ gl847_led_calibration (Genesys_Device * dev)
DBG(DBG_info, "%s: acceptable exposure: %d,%d,%d\n", __func__, exp[0], exp[1], exp[2]);
/* set these values as final ones for scan */
sanei_genesys_set_double(dev->reg,REG_EXPR,exp[0]);
sanei_genesys_set_double(dev->reg,REG_EXPG,exp[1]);
sanei_genesys_set_double(dev->reg,REG_EXPB,exp[2]);
sanei_genesys_set_double(&dev->reg,REG_EXPR,exp[0]);
sanei_genesys_set_double(&dev->reg,REG_EXPG,exp[1]);
sanei_genesys_set_double(&dev->reg,REG_EXPB,exp[2]);
/* store in this struct since it is the one used by cache calibration */
dev->sensor.regs_0x10_0x1d[0] = (exp[0] >> 8) & 0xff;
@ -2699,10 +2687,10 @@ gl847_init_memory_layout (Genesys_Device * dev)
/* CLKSET nd DRAMSEL */
val = layouts[idx].dramsel;
RIE (sanei_genesys_write_register (dev, REG0B, val));
dev->reg[reg_0x0b].value = val;
dev->reg.find_reg(0x0b).value = val;
/* prevent further writings by bulk write register */
dev->reg[reg_0x0b].address = 0x00;
dev->reg.remove_reg(0x0b);
/* setup base address for shading data. */
/* values must be multiplied by 8192=0x4000 to give address on AHB */
@ -2784,17 +2772,17 @@ gl847_boot (Genesys_Device * dev, SANE_Bool cold)
gl847_init_registers (dev);
/* Write initial registers */
RIE (dev->model->cmd_set->bulk_write_register (dev, dev->reg, GENESYS_GL847_MAX_REGS));
RIE (dev->model->cmd_set->bulk_write_register(dev, dev->reg));
/* Enable DRAM by setting a rising edge on bit 3 of reg 0x0b */
val = dev->reg[reg_0x0b].value & REG0B_DRAMSEL;
val = dev->reg.find_reg(0x0b).value & REG0B_DRAMSEL;
val = (val | REG0B_ENBDRAM);
RIE (sanei_genesys_write_register (dev, REG0B, val));
dev->reg[reg_0x0b].value = val;
dev->reg.find_reg(0x0b).value = val;
/* CIS_LINE */
SETREG (0x08, REG08_CIS_LINE);
RIE (sanei_genesys_write_register (dev, 0x08, dev->reg[reg_0x08].value));
RIE (sanei_genesys_write_register (dev, 0x08, dev->reg.find_reg(0x08).value));
/* set up end access */
RIE (sanei_genesys_write_0x8c (dev, 0x10, 0x0b));
@ -2807,7 +2795,7 @@ gl847_boot (Genesys_Device * dev, SANE_Bool cold)
RIE (gl847_init_memory_layout (dev));
SETREG (0xf8, 0x01);
RIE (sanei_genesys_write_register (dev, 0xf8, dev->reg[reg_0xf8].value));
RIE (sanei_genesys_write_register (dev, 0xf8, dev->reg.find_reg(0xf8).value));
DBGCOMPLETED;
return SANE_STATUS_GOOD;
@ -2824,7 +2812,7 @@ static SANE_Status gl847_init (Genesys_Device * dev)
DBG_INIT ();
DBGSTART;
status=sanei_genesys_asic_init(dev, GENESYS_GL847_MAX_REGS);
status=sanei_genesys_asic_init(dev, 0);
DBGCOMPLETED;
return status;
@ -2881,12 +2869,12 @@ gl847_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
{
unsigned int pixels, lines, channels;
SANE_Status status;
Genesys_Register_Set local_reg[GENESYS_GL847_MAX_REGS];
Genesys_Register_Set local_reg;
size_t size;
int steps, depth, dpi;
unsigned int pass, count, found, x, y;
char title[80];
Genesys_Register_Set *r;
GenesysRegister *r;
DBG(DBG_proc, "%s %s %s\n", __func__, black ? "black" : "white", forward ? "forward" : "reverse");
@ -2916,11 +2904,10 @@ gl847_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
std::vector<uint8_t> data(size);
dev->scanhead_position_in_steps = 0;
memcpy (local_reg, dev->reg,
GENESYS_GL847_MAX_REGS * sizeof (Genesys_Register_Set));
local_reg = dev->reg;
status = gl847_init_scan_regs (dev,
local_reg,
&local_reg,
dpi,
dpi,
0,
@ -2939,21 +2926,21 @@ gl847_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
}
/* set up for reverse or forward */
r = sanei_genesys_get_address (local_reg, REG02);
r = sanei_genesys_get_address(&local_reg, REG02);
if (forward)
r->value &= ~REG02_MTRREV;
else
r->value |= REG02_MTRREV;
status = dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL847_MAX_REGS);
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
status = gl847_begin_scan (dev, local_reg, SANE_TRUE);
status = gl847_begin_scan(dev, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to begin scan: %s\n", __func__, sane_strstatus(status));
@ -2993,7 +2980,7 @@ gl847_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
while (pass < 20 && !found)
{
status =
dev->model->cmd_set->bulk_write_register (dev, local_reg, GENESYS_GL847_MAX_REGS);
dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to bulk write registers: %s\n", __func__,
@ -3002,7 +2989,7 @@ gl847_search_strip (Genesys_Device * dev, SANE_Bool forward, SANE_Bool black)
}
/* now start scan */
status = gl847_begin_scan (dev, local_reg, SANE_TRUE);
status = gl847_begin_scan(dev, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to begin scan: %s\n", __func__, sane_strstatus(status));
@ -3197,7 +3184,7 @@ gl847_offset_calibration (Genesys_Device * dev)
DBG(DBG_io2, "%s: black_pixels=%d\n", __func__, black_pixels);
status = gl847_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
resolution,
resolution,
0,
@ -3216,7 +3203,7 @@ gl847_offset_calibration (Genesys_Device * dev)
DBG(DBG_error, "%s: failed to setup scan: %s\n", __func__, sane_strstatus(status));
return status;
}
gl847_set_motor_power (dev->calib_reg, SANE_FALSE);
gl847_set_motor_power(&dev->calib_reg, SANE_FALSE);
/* allocate memory for scans */
total_size = pixels * channels * lines * (bpp/8); /* colors * bytes_per_color * scan lines */
@ -3236,9 +3223,9 @@ gl847_offset_calibration (Genesys_Device * dev)
dev->frontend.offset[2] = bottom;
RIE(gl847_set_fe(dev, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL847_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting first line reading\n", __func__);
RIE(gl847_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl847_begin_scan(dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size));
if (DBG_LEVEL >= DBG_data)
{
@ -3256,9 +3243,9 @@ gl847_offset_calibration (Genesys_Device * dev)
dev->frontend.offset[1] = top;
dev->frontend.offset[2] = top;
RIE(gl847_set_fe(dev, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL847_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl847_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl847_begin_scan(dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner (dev, second_line.data(), total_size));
topavg = dark_average(second_line.data(), pixels, lines, channels, black_pixels);
@ -3276,9 +3263,9 @@ gl847_offset_calibration (Genesys_Device * dev)
/* scan with no move */
RIE(gl847_set_fe(dev, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register (dev, dev->calib_reg, GENESYS_GL847_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl847_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl847_begin_scan (dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner (dev, second_line.data(), total_size));
if (DBG_LEVEL >= DBG_data)
@ -3354,7 +3341,7 @@ gl847_coarse_gain_calibration (Genesys_Device * dev, int dpi)
pixels = (dev->sensor.sensor_pixels * resolution) / dev->sensor.optical_res;
status = gl847_init_scan_regs (dev,
dev->calib_reg,
&dev->calib_reg,
resolution,
resolution,
0,
@ -3368,7 +3355,7 @@ gl847_coarse_gain_calibration (Genesys_Device * dev, int dpi)
SCAN_FLAG_DISABLE_GAMMA |
SCAN_FLAG_SINGLE_LINE |
SCAN_FLAG_IGNORE_LINE_DISTANCE);
gl847_set_motor_power (dev->calib_reg, SANE_FALSE);
gl847_set_motor_power(&dev->calib_reg, SANE_FALSE);
if (status != SANE_STATUS_GOOD)
{
@ -3376,15 +3363,14 @@ gl847_coarse_gain_calibration (Genesys_Device * dev, int dpi)
return status;
}
RIE (dev->model->cmd_set->bulk_write_register
(dev, dev->calib_reg, GENESYS_GL847_MAX_REGS));
RIE(dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg));
total_size = pixels * channels * (16/bpp) * lines;
std::vector<uint8_t> line(total_size);
RIE(gl847_set_fe(dev, AFE_SET));
RIE(gl847_begin_scan (dev, dev->calib_reg, SANE_TRUE));
RIE(gl847_begin_scan(dev, &dev->calib_reg, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, line.data(), total_size));
if (DBG_LEVEL >= DBG_data)
@ -3475,8 +3461,6 @@ static Genesys_Command_Set gl847_cmd_set = {
gl847_test_buffer_empty_bit,
gl847_test_motor_flag_bit,
gl847_bulk_full_size,
gl847_set_fe,
gl847_set_powersaving,
gl847_save_power,

150
backend/genesys_gl847.h
Wyświetl plik

@ -320,155 +320,7 @@
#define REG_CK3MAP 0x77
#define REG_CK4MAP 0x7a
/**
* writable scanner registers */
enum
{
reg_0x01 = 0,
reg_0x02,
reg_0x03,
reg_0x04,
reg_0x05,
reg_0x06,
reg_0x08,
reg_0x09,
reg_0x0a,
reg_0x0b,
reg_0x0c,
reg_0x0d,
reg_0x0e,
reg_0x0f,
reg_0x10,
reg_0x11,
reg_0x12,
reg_0x13,
reg_0x14,
reg_0x15,
reg_0x16,
reg_0x17,
reg_0x18,
reg_0x19,
reg_0x1a,
reg_0x1b,
reg_0x1c,
reg_0x1d,
reg_0x1e,
reg_0x1f,
reg_0x20,
reg_0x21,
reg_0x22,
reg_0x23,
reg_0x24,
reg_0x25,
reg_0x26,
reg_0x27,
reg_0x2c,
reg_0x2d,
reg_0x2e,
reg_0x2f,
reg_0x30,
reg_0x31,
reg_0x32,
reg_0x33,
reg_0x34,
reg_0x35,
reg_0x36,
reg_0x37,
reg_0x38,
reg_0x39,
reg_0x3a,
reg_0x3b,
reg_0x3d,
reg_0x3e,
reg_0x3f,
reg_0x51,
reg_0x52,
reg_0x53,
reg_0x54,
reg_0x55,
reg_0x56,
reg_0x57,
reg_0x58,
reg_0x59,
reg_0x5a,
reg_0x5e,
reg_0x5f,
reg_0x60,
reg_0x61,
reg_0x62,
reg_0x63,
reg_0x64,
reg_0x65,
reg_0x67,
reg_0x68,
reg_0x69,
reg_0x6a,
reg_0x6b,
reg_0x6c,
reg_0x6d,
reg_0x6e,
reg_0x6f,
reg_0x74,
reg_0x75,
reg_0x76,
reg_0x77,
reg_0x78,
reg_0x79,
reg_0x7a,
reg_0x7b,
reg_0x7c,
reg_0x7d,
reg_0x87,
reg_0x9d,
reg_0xa2,
reg_0xa3,
reg_0xa4,
reg_0xa5,
reg_0xa6,
reg_0xa7,
reg_0xa8,
reg_0xa9,
reg_0xbd,
reg_0xbe,
reg_0xc5,
reg_0xc6,
reg_0xc7,
reg_0xc8,
reg_0xc9,
reg_0xca,
reg_0xd0,
reg_0xd1,
reg_0xd2,
reg_0xe0,
reg_0xe1,
reg_0xe2,
reg_0xe3,
reg_0xe4,
reg_0xe5,
reg_0xe6,
reg_0xe7,
reg_0xe8,
reg_0xe9,
reg_0xea,
reg_0xeb,
reg_0xec,
reg_0xed,
reg_0xee,
reg_0xef,
reg_0xf0,
reg_0xf1,
reg_0xf2,
reg_0xf3,
reg_0xf4,
reg_0xf5,
reg_0xf6,
reg_0xf7,
reg_0xf8,
reg_0xfe,
GENESYS_GL847_MAX_REGS
};
#define SETREG(adr,val) {dev->reg[reg_##adr].address=adr;dev->reg[reg_##adr].value=val;}
#define SETREG(adr,val) { dev->reg.init_reg(adr, val); }
/** set up registers for an actual scan
*

289
backend/genesys_low.cc
Wyświetl plik

@ -197,44 +197,6 @@ sanei_genesys_write_pnm_file (const char *filename, uint8_t * data, int depth,
return SANE_STATUS_GOOD;
}
/* the following 2 functions are used to handle registers in a
way that doesn't depend on the actual ASIC type */
/* Reads a register from a register set */
SANE_Byte
sanei_genesys_read_reg_from_set (Genesys_Register_Set * reg,
uint16_t address)
{
SANE_Int i;
for (i = 0; i < GENESYS_MAX_REGS; i++)
{
if (reg[i].address == address)
{
return reg[i].value;
}
}
return 0;
}
/* Reads a register from a register set */
void
sanei_genesys_set_reg_from_set (Genesys_Register_Set * reg, uint16_t address,
SANE_Byte value)
{
SANE_Int i;
for (i = 0; i < GENESYS_MAX_REGS; i++)
{
if (reg[i].address == address)
{
reg[i].value = value;
break;
}
}
}
/* ------------------------------------------------------------------------ */
/* Read and write RAM, registers and AFE */
/* ------------------------------------------------------------------------ */
@ -751,16 +713,15 @@ sanei_genesys_fe_read_data (Genesys_Device * dev, uint8_t addr,
{
SANE_Status status;
uint8_t value;
Genesys_Register_Set reg[1];
Genesys_Register_Set reg;
DBG(DBG_proc, "%s: start\n", __func__);
reg[0].address = 0x50;
reg[0].value = addr;
reg.init_reg(0x50, addr);
/* set up read address */
status = dev->model->cmd_set->bulk_write_register (dev, reg, 1);
status = dev->model->cmd_set->bulk_write_register(dev, reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed while bulk writing registers: %s\n", __func__,
@ -792,23 +753,20 @@ sanei_genesys_fe_write_data (Genesys_Device * dev, uint8_t addr,
uint16_t data)
{
SANE_Status status;
Genesys_Register_Set reg[3];
Genesys_Register_Set reg(Genesys_Register_Set::SEQUENTIAL);
DBG(DBG_io, "%s (0x%02x, 0x%04x)\n", __func__, addr, data);
reg[0].address = 0x51;
reg[0].value = addr;
reg[1].address = 0x3a;
reg[1].value = (data / 256) & 0xff;
reg[2].address = 0x3b;
reg[2].value = data & 0xff;
if (dev->model->asic_type == GENESYS_GL124)
{
reg[1].address = 0x5d;
reg[2].address = 0x5e;
reg.init_reg(0x51, addr);
if (dev->model->asic_type == GENESYS_GL124) {
reg.init_reg(0x5d, (data / 256) & 0xff);
reg.init_reg(0x5e, data & 0xff);
} else {
reg.init_reg(0x3a, (data / 256) & 0xff);
reg.init_reg(0x3b, data & 0xff);
}
status = dev->model->cmd_set->bulk_write_register (dev, reg, 3);
status = dev->model->cmd_set->bulk_write_register(dev, reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed while bulk writing registers: %s\n", __func__,
@ -991,171 +949,6 @@ sanei_genesys_read_scancnt (Genesys_Device * dev, unsigned int *words)
return SANE_STATUS_GOOD;
}
/**
* Find register in set
* @param regs register set to search
* @param addr addres of the searched register
* @return a Genesys_Register_Set pointer corresponding to the required
* address in ASIC space. Or NULL if not found.
*/
Genesys_Register_Set *
sanei_genesys_get_address (Genesys_Register_Set * regs, uint16_t addr)
{
int i;
for (i = 0; i < GENESYS_MAX_REGS; i++)
{
if (regs[i].address == addr)
return &regs[i];
}
DBG(DBG_error, "%s: failed to find address for register 0x%02x, crash expected !\n", __func__,
addr);
return NULL;
}
/**
* set a 16 bit value in the given register set.
* @param regs register set where to set values
* @param addr address of the first register index to set
* @param value value to set
* @return SANE_STATUS_INVAL if the index doesn't exist in register set
*/
SANE_Status
sanei_genesys_set_double(Genesys_Register_Set *regs, uint16_t addr, uint16_t value)
{
Genesys_Register_Set *r;
/* high byte */
r = sanei_genesys_get_address (regs, addr);
if(r==NULL)
{
return SANE_STATUS_INVAL;
}
r->value = HIBYTE (value);
/* low byte */
r = sanei_genesys_get_address (regs, addr+1);
if(r==NULL)
{
return SANE_STATUS_INVAL;
}
r->value = LOBYTE (value);
return SANE_STATUS_GOOD;
}
/**
* set a 24 bit value in the given register set.
* @param regs register set where to set values
* @param addr address of the first register index to set
* @param value value to set
* @return SANE_STATUS_INVAL if the index doesn't exist in register set
*/
SANE_Status
sanei_genesys_set_triple(Genesys_Register_Set *regs, uint16_t addr, uint32_t value)
{
Genesys_Register_Set *r;
/* low byte of highword */
r = sanei_genesys_get_address (regs, addr);
if(r==NULL)
{
return SANE_STATUS_INVAL;
}
r->value = LOBYTE (HIWORD(value));
/* high byte of low word */
r = sanei_genesys_get_address (regs, addr+1);
if(r==NULL)
{
return SANE_STATUS_INVAL;
}
r->value = HIBYTE (LOWORD(value));
/* low byte of low word */
r = sanei_genesys_get_address (regs, addr+2);
if(r==NULL)
{
return SANE_STATUS_INVAL;
}
r->value = LOBYTE (LOWORD(value));
return SANE_STATUS_GOOD;
}
/**
* get a 16 bit value in the given register set.
* @param regs register set where to read values
* @param addr address of the first register index to read
* @param value value to set
* @return SANE_STATUS_INVAL if the index doesn't exist in register set
*/
SANE_Status
sanei_genesys_get_double(Genesys_Register_Set *regs, uint16_t addr, uint16_t *value)
{
Genesys_Register_Set *r;
uint16_t result=0;
/* high byte */
r = sanei_genesys_get_address (regs, addr);
if(r==NULL)
{
return SANE_STATUS_INVAL;
}
result=r->value<<8;
/* low byte */
r = sanei_genesys_get_address (regs, addr+1);
if(r==NULL)
{
return SANE_STATUS_INVAL;
}
result+=r->value;
*value=result;
return SANE_STATUS_GOOD;
}
/**
* get a 24 bit value in the given register set.
* @param regs register set where to read values
* @param addr address of the first register index to read
* @param value value to set
* @return SANE_STATUS_INVAL if the index doesn't exist in register set
*/
SANE_Status
sanei_genesys_get_triple(Genesys_Register_Set *regs, uint16_t addr, uint32_t *value)
{
Genesys_Register_Set *r;
uint32_t result=0;
/* low byte of highword */
r = sanei_genesys_get_address (regs, addr);
if(r==NULL)
{
return SANE_STATUS_INVAL;
}
result=r->value<<16;
/* high byte of low word */
r = sanei_genesys_get_address (regs, addr+1);
if(r==NULL)
{
return SANE_STATUS_INVAL;
}
result+=(r->value<<8);
/* low byte of low word */
r = sanei_genesys_get_address (regs, addr+2);
if(r==NULL)
{
return SANE_STATUS_INVAL;
}
result+=r->value;
*value=result;
return SANE_STATUS_GOOD;
}
/** @brief Check if the scanner's internal data buffer is empty
* @param *dev device to test for data
* @param *empty return value
@ -1286,46 +1079,35 @@ sanei_genesys_read_feed_steps (Genesys_Device * dev, unsigned int *steps)
* @param reg pointer to an array of registers
* @param elems size of the array
*/
SANE_Status
sanei_genesys_bulk_write_register (Genesys_Device * dev,
Genesys_Register_Set * reg,
size_t elems)
SANE_Status sanei_genesys_bulk_write_register(Genesys_Device * dev, Genesys_Register_Set& reg)
{
SANE_Status status = SANE_STATUS_GOOD;
size_t i;
if (dev->model->asic_type == GENESYS_GL646 ||
dev->model->asic_type == GENESYS_GL841)
{
uint8_t outdata[8];
uint8_t buffer[GENESYS_MAX_REGS * 2];
size_t size;
unsigned int i;
/* handle differently sized register sets, reg[0x00] may be the last one */
i = 0;
while ((i < elems) && (reg[i].address != 0))
i++;
elems = i;
size = i * 2;
std::vector<uint8_t> buffer;
buffer.reserve(reg.size() * 2);
/* copy registers and values in data buffer */
for (i = 0; i < size; i += 2) {
buffer[i] = reg[i / 2].address;
buffer[i + 1] = reg[i / 2].value;
for (const auto& r : reg) {
buffer.push_back(r.address);
buffer.push_back(r.value);
}
DBG(DBG_io, "%s (elems= %lu, size = %lu)\n", __func__, (u_long) elems, (u_long) size);
DBG(DBG_io, "%s (elems= %lu, size = %lu)\n", __func__, (u_long) reg.size(),
(u_long) buffer.size());
if (dev->model->asic_type == GENESYS_GL646) {
outdata[0] = BULK_OUT;
outdata[1] = BULK_REGISTER;
outdata[2] = 0x00;
outdata[3] = 0x00;
outdata[4] = (size & 0xff);
outdata[5] = ((size >> 8) & 0xff);
outdata[6] = ((size >> 16) & 0xff);
outdata[7] = ((size >> 24) & 0xff);
outdata[4] = (buffer.size() & 0xff);
outdata[5] = ((buffer.size() >> 8) & 0xff);
outdata[6] = ((buffer.size() >> 16) & 0xff);
outdata[7] = ((buffer.size() >> 24) & 0xff);
status = sanei_usb_control_msg(dev->dn, REQUEST_TYPE_OUT, REQUEST_BUFFER,
VALUE_BUFFER, INDEX, sizeof(outdata), outdata);
@ -1335,19 +1117,20 @@ sanei_genesys_bulk_write_register (Genesys_Device * dev,
return status;
}
status = sanei_usb_write_bulk (dev->dn, buffer, &size);
size_t write_size = buffer.size();
status = sanei_usb_write_bulk (dev->dn, buffer.data(), &write_size);
if (status != SANE_STATUS_GOOD) {
DBG(DBG_error, "%s: failed while writing bulk data: %s\n", __func__, sane_strstatus(status));
return status;
}
} else {
size_t c;
for (i = 0; i < elems;) {
c = elems - i;
for (size_t i = 0; i < reg.size();) {
size_t c = reg.size() - i;
if (c > 32) /*32 is max on GL841. checked that.*/
c = 32;
status = sanei_usb_control_msg(dev->dn, REQUEST_TYPE_OUT, REQUEST_BUFFER,
VALUE_SET_REGISTER, INDEX, c * 2, buffer + i * 2);
VALUE_SET_REGISTER, INDEX, c * 2,
buffer.data() + i * 2);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed while writing command: %s\n", __func__,
@ -1359,14 +1142,14 @@ sanei_genesys_bulk_write_register (Genesys_Device * dev,
}
}
} else {
for (i = 0; i < elems && status == SANE_STATUS_GOOD; i++) {
if (reg[i].address != 0) {
status = sanei_genesys_write_register (dev, reg[i].address, reg[i].value);
}
for (const auto& r : reg) {
status = sanei_genesys_write_register (dev, r.address, r.value);
if (status != SANE_STATUS_GOOD)
break;
}
}
DBG (DBG_io, "%s: wrote %lu registers\n", __func__, (u_long) elems);
DBG (DBG_io, "%s: wrote %lu registers\n", __func__, (u_long) reg.size());
return status;
}
@ -1661,7 +1444,7 @@ sanei_genesys_asic_init (Genesys_Device * dev, int max_regs)
dev->settings.color_filter = 0;
/* duplicate initial values into calibration registers */
memcpy (dev->calib_reg, dev->reg, max_regs * sizeof (Genesys_Register_Set));
dev->calib_reg = dev->reg;
/* Set analog frontend */
RIE (dev->model->cmd_set->set_fe (dev, AFE_INIT));

244
backend/genesys_low.h
Wyświetl plik

@ -1,4 +1,4 @@
/* sane - Scanner Access Now Easy.
/* sane - Scanner Access Now Easy.
Copyright (C) 2003 Oliver Rauch
Copyright (C) 2003, 2004 Henning Meier-Geinitz <henning@meier-geinitz.de>
@ -217,11 +217,169 @@
#define FEBUSY 0x02
#define MOTORENB 0x01
typedef struct Genesys_Register_Set
#define GENESYS_MAX_REGS 256
struct GenesysRegister {
uint16_t address = 0;
uint8_t value = 0;
};
inline bool operator<(const GenesysRegister& lhs, const GenesysRegister& rhs)
{
uint16_t address;
uint8_t value;
} Genesys_Register_Set;
return lhs.address < rhs.address;
}
class Genesys_Register_Set {
public:
using container = std::vector<GenesysRegister>;
using iterator = typename container::iterator;
using const_iterator = typename container::const_iterator;
enum Options {
SEQUENTIAL = 1
};
Genesys_Register_Set()
{
registers_.reserve(GENESYS_MAX_REGS);
}
// by default the register set is sorted by address. In certain cases it's importand to send
// the registers in certain order: use the SEQUENTIAL option for that
Genesys_Register_Set(Options opts) : Genesys_Register_Set()
{
if ((opts & SEQUENTIAL) == SEQUENTIAL) {
sorted_ = false;
}
}
void init_reg(uint16_t address, uint8_t default_value)
{
if (find_reg_index(address) >= 0) {
set8(address, default_value);
return;
}
GenesysRegister reg;
reg.address = address;
reg.value = default_value;
registers_.push_back(reg);
if (sorted_)
std::sort(registers_.begin(), registers_.end());
}
void remove_reg(uint16_t address)
{
int i = find_reg_index(address);
if (i < 0) {
throw std::runtime_error("the register does not exist");
}
registers_.erase(registers_.begin() + i);
}
GenesysRegister& find_reg(uint16_t address)
{
int i = find_reg_index(address);
if (i < 0) {
throw std::runtime_error("the register does not exist");
}
return registers_[i];
}
const GenesysRegister& find_reg(uint16_t address) const
{
int i = find_reg_index(address);
if (i < 0) {
throw std::runtime_error("the register does not exist");
}
return registers_[i];
}
GenesysRegister* find_reg_address(uint16_t address)
{
return &find_reg(address);
}
const GenesysRegister* find_reg_address(uint16_t address) const
{
return &find_reg(address);
}
void set8(uint16_t address, uint8_t value)
{
find_reg(address).value = value;
}
void set8_mask(uint16_t address, uint8_t value, uint8_t mask)
{
auto& reg = find_reg(address);
reg.value = (reg.value & ~mask) | value;
}
void set16(uint16_t address, uint16_t value)
{
find_reg(address).value = (value >> 8) & 0xff;
find_reg(address + 1).value = value & 0xff;
}
void set24(uint16_t address, uint32_t value)
{
find_reg(address).value = (value >> 16) & 0xff;
find_reg(address + 1).value = (value >> 8) & 0xff;
find_reg(address + 2).value = value & 0xff;
}
uint8_t get8(uint16_t address) const
{
return find_reg(address).value;
}
uint16_t get16(uint16_t address) const
{
return (find_reg(address).value << 8) | find_reg(address + 1).value;
}
uint32_t get24(uint16_t address) const
{
return (find_reg(address).value << 16) |
(find_reg(address + 1).value << 8) |
find_reg(address + 2).value;
}
void clear() { registers_.clear(); }
size_t size() const { return registers_.size(); }
iterator begin() { return registers_.begin(); }
const_iterator begin() const { return registers_.begin(); }
iterator end() { return registers_.end(); }
const_iterator end() const { return registers_.end(); }
private:
int find_reg_index(uint16_t address) const
{
if (!sorted_) {
for (size_t i = 0; i < registers_.size(); i++) {
if (registers_[i].address == address) {
return i;
}
}
return -1;
}
GenesysRegister search;
search.address = address;
auto it = std::lower_bound(registers_.begin(), registers_.end(), search);
if (it == registers_.end())
return -1;
if (it->address != address)
return -1;
return std::distance(registers_.begin(), it);
}
// registers are stored in a sorted vector
bool sorted_ = true;
std::vector<GenesysRegister> registers_;
};
/** @brief Data structure to set up analog frontend.
* The analog frontend converts analog value from image sensor to
@ -378,8 +536,6 @@ Genesys_Color_Order;
#define GENESYS_GL123 123
#define GENESYS_GL124 124
#define GENESYS_MAX_REGS 256
enum Genesys_Model_Type
{
MODEL_UMAX_ASTRA_4500 = 0,
@ -591,8 +747,6 @@ typedef struct Genesys_Command_Set
SANE_Bool (*test_buffer_empty_bit) (SANE_Byte val);
SANE_Bool (*test_motor_flag_bit) (SANE_Byte val);
int (*bulk_full_size) (void);
SANE_Status (*set_fe) (Genesys_Device * dev, uint8_t set);
SANE_Status (*set_powersaving) (Genesys_Device * dev, int delay);
SANE_Status (*save_power) (Genesys_Device * dev, SANE_Bool enable);
@ -623,8 +777,8 @@ typedef struct Genesys_Command_Set
SANE_Status (*rewind) (Genesys_Device * dev);
SANE_Status (*bulk_write_register) (Genesys_Device * dev,
Genesys_Register_Set * reg,
size_t elems);
Genesys_Register_Set& reg);
SANE_Status (*bulk_write_data) (Genesys_Device * dev, uint8_t addr,
uint8_t * data, size_t len);
@ -921,8 +1075,8 @@ struct Genesys_Device
SANE_Int force_calibration = 0;
Genesys_Model *model = nullptr;
Genesys_Register_Set reg[256] = {};
Genesys_Register_Set calib_reg[256] = {};
Genesys_Register_Set reg;
Genesys_Register_Set calib_reg;
Genesys_Settings settings = {};
Genesys_Frontend frontend = {};
Genesys_Sensor sensor;
@ -1091,13 +1245,26 @@ typedef struct {
/* common functions needed by low level specific functions */
/*--------------------------------------------------------------------------*/
extern Genesys_Register_Set *sanei_genesys_get_address (Genesys_Register_Set * regs, uint16_t addr);
inline GenesysRegister* sanei_genesys_get_address(Genesys_Register_Set* regs, uint16_t addr)
{
auto* ret = regs->find_reg_address(addr);
if (ret == nullptr) {
DBG(DBG_error, "%s: failed to find address for register 0x%02x, crash expected !\n",
__func__, addr);
}
return ret;
}
extern SANE_Byte
sanei_genesys_read_reg_from_set (Genesys_Register_Set * regs, uint16_t address);
inline uint8_t sanei_genesys_read_reg_from_set(Genesys_Register_Set* regs, uint16_t address)
{
return regs->get8(address);
}
extern void
sanei_genesys_set_reg_from_set (Genesys_Register_Set * regs, uint16_t address, SANE_Byte value);
inline void sanei_genesys_set_reg_from_set(Genesys_Register_Set* regs, uint16_t address,
uint8_t value)
{
regs->set8(address, value);
}
extern SANE_Status sanei_genesys_init_cmd_set (Genesys_Device * dev);
@ -1114,9 +1281,8 @@ extern SANE_Status
sanei_genesys_write_hregister (Genesys_Device * dev, uint16_t reg, uint8_t val);
extern SANE_Status
sanei_genesys_bulk_write_register (Genesys_Device * dev,
Genesys_Register_Set * reg,
size_t elems);
sanei_genesys_bulk_write_register(Genesys_Device * dev,
Genesys_Register_Set& reg);
extern SANE_Status sanei_genesys_write_0x8c (Genesys_Device * dev, uint8_t index, uint8_t val);
@ -1246,17 +1412,25 @@ extern SANE_Status
sanei_genesys_read_data_from_scanner (Genesys_Device * dev, uint8_t * data,
size_t size);
extern SANE_Status
sanei_genesys_set_double(Genesys_Register_Set *regs, uint16_t addr, uint16_t value);
inline void sanei_genesys_set_double(Genesys_Register_Set* regs, uint16_t addr, uint16_t value)
{
regs->set16(addr, value);
}
extern SANE_Status
sanei_genesys_set_triple(Genesys_Register_Set *regs, uint16_t addr, uint32_t value);
inline void sanei_genesys_set_triple(Genesys_Register_Set* regs, uint16_t addr, uint32_t value)
{
regs->set24(addr, value);
}
extern SANE_Status
sanei_genesys_get_double(Genesys_Register_Set *regs, uint16_t addr, uint16_t *value);
inline void sanei_genesys_get_double(Genesys_Register_Set* regs, uint16_t addr, uint16_t* value)
{
*value = regs->get16(addr);
}
extern SANE_Status
sanei_genesys_get_triple(Genesys_Register_Set *regs, uint16_t addr, uint32_t *value);
inline void sanei_genesys_get_triple(Genesys_Register_Set* regs, uint16_t addr, uint32_t* value)
{
*value = regs->get24(addr);
}
extern SANE_Status
sanei_genesys_wait_for_home(Genesys_Device *dev);
@ -1379,10 +1553,10 @@ SANE_Status wrap_exceptions_to_status_code(const char* func, F&& function)
} catch (const std::bad_alloc& exc) {
return SANE_STATUS_NO_MEM;
} catch (const std::exception& exc) {
DBG(DBG_error, "%s: got uncaught exception: %s", func, exc.what());
DBG(DBG_error, "%s: got uncaught exception: %s\n", func, exc.what());
return SANE_STATUS_INVAL;
} catch (...) {
DBG(DBG_error, "%s: got unknown uncaught exception", func);
DBG(DBG_error, "%s: got unknown uncaught exception\n", func);
return SANE_STATUS_INVAL;
}
}
@ -1393,13 +1567,13 @@ void catch_all_exceptions(const char* func, F&& function)
try {
function();
} catch (const SaneException& exc) {
// ignore, this will already be logged
DBG(DBG_error, "%s: got exception: %s\n", func, exc.what());
} catch (const std::bad_alloc& exc) {
// ignore, this will already be logged
DBG(DBG_error, "%s: got exception: could not allocate memory: %s\n", func, exc.what());
} catch (const std::exception& exc) {
DBG(DBG_error, "%s: got uncaught exception: %s", func, exc.what());
DBG(DBG_error, "%s: got uncaught exception: %s\n", func, exc.what());
} catch (...) {
DBG(DBG_error, "%s: got unknown uncaught exception", func);
DBG(DBG_error, "%s: got unknown uncaught exception\n", func);
}
}