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

genesys: Remove unneeded wrapper for scanner interface functions

merge-requests/240/head
Povilas Kanapickas 2019-10-26 11:38:41 +02:00
rodzic 0582b5448c
commit 0fed92b0ff
11 zmienionych plików z 518 dodań i 537 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

19
backend/genesys/device.cpp
Wyświetl plik

@ -103,21 +103,6 @@ ImagePipelineNodeBytesSource& Genesys_Device::get_pipeline_source()
return static_cast<ImagePipelineNodeBytesSource&>(pipeline.front());
}
uint8_t Genesys_Device::read_register(uint16_t address)
{
return interface->read_register(address);
}
void Genesys_Device::write_register(uint16_t address, uint8_t value)
{
interface->write_register(address, value);
}
void Genesys_Device::write_registers(Genesys_Register_Set& regs)
{
interface->write_registers(regs);
}
UsbDevice& Genesys_Device::get_usb_device()
{
if (interface->is_mock())
@ -128,9 +113,9 @@ UsbDevice& Genesys_Device::get_usb_device()
void apply_reg_settings_to_device(Genesys_Device& dev, const GenesysRegisterSettingSet& regs)
{
for (const auto& reg : regs) {
uint8_t val = dev.read_register(reg.address);
uint8_t val = dev.interface->read_register(reg.address);
val = (val & ~reg.mask) | (reg.value & reg.mask);
dev.write_register(reg.address, val);
dev.interface->write_register(reg.address, val);
}
}

4
backend/genesys/device.h
Wyświetl plik

@ -361,10 +361,6 @@ struct Genesys_Device
std::unique_ptr<ScannerInterface> interface;
std::uint8_t read_register(std::uint16_t address);
void write_register(std::uint16_t address, std::uint8_t value);
void write_registers(Genesys_Register_Set& regs);
UsbDevice& get_usb_device();
UsbDevice usb_dev;

8
backend/genesys/genesys.cpp
Wyświetl plik

@ -1530,7 +1530,7 @@ static void genesys_shading_calibration_impl(Genesys_Device* dev, const Genesys_
sanei_genesys_set_motor_power(dev->calib_reg, motor);
}
dev->write_registers(dev->calib_reg);
dev->interface->write_registers(dev->calib_reg);
if (is_dark) {
// wait some time to let lamp to get dark
@ -1735,7 +1735,7 @@ static void genesys_dark_white_shading_calibration(Genesys_Device* dev,
sanei_genesys_set_lamp_power(dev, sensor, dev->calib_reg, true);
sanei_genesys_set_motor_power(dev->calib_reg, motor);
dev->write_registers(dev->calib_reg);
dev->interface->write_registers(dev->calib_reg);
dev->cmd_set->begin_scan(dev, sensor, &dev->calib_reg, false);
@ -3184,7 +3184,7 @@ static void genesys_start_scan(Genesys_Device* dev, bool lamp_off)
}
// now send registers for scan
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
// start effective scan
dev->cmd_set->begin_scan(dev, sensor, &dev->reg, true);
@ -4906,7 +4906,7 @@ sane_close_impl(SANE_Handle handle)
s->dev->clear();
// LAMP OFF : same register across all the ASICs */
s->dev->write_register(0x03, 0x00);
s->dev->interface->write_register(0x03, 0x00);
catch_all_exceptions(__func__, [&](){ s->dev->usb_dev.clear_halt(); });

182
backend/genesys/gl124.cpp
Wyświetl plik

@ -65,9 +65,9 @@ static void gl124_homsnr_gpio(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val = dev->read_register(REG_0x32);
uint8_t val = dev->interface->read_register(REG_0x32);
val &= ~REG_0x32_GPIO10;
dev->write_register(REG_0x32, val);
dev->interface->write_register(REG_0x32, val);
}
/** @brief set all registers to default values .
@ -458,7 +458,7 @@ void CommandSetGl124::set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor,
dev->frontend = dev->frontend_initial;
}
val = dev->read_register(REG_0x0A);
val = dev->interface->read_register(REG_0x0A);
/* route to correct analog FE */
switch ((val & REG_0x0A_SIFSEL) >> REG_0x0AS_SIFSEL) {
@ -788,8 +788,8 @@ static void gl124_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
!(session.params.flags & SCAN_FLAG_DISABLE_LAMP));
// BW threshold
dev->write_register(REG_0x114, dev->settings.threshold);
dev->write_register(REG_0x115, dev->settings.threshold);
dev->interface->write_register(REG_0x114, dev->settings.threshold);
dev->interface->write_register(REG_0x115, dev->settings.threshold);
/* monochrome / color scan */
r = sanei_genesys_get_address (reg, REG_0x04);
@ -862,9 +862,9 @@ static void gl124_init_optical_regs_scan(Genesys_Device* dev, const Genesys_Sens
r->value &= ~REG_0x01_TRUEGRAY;
if (session.enable_ledadd) {
r->value |= REG_0x01_TRUEGRAY;
dev->write_register(REG_TRUER, 0x80);
dev->write_register(REG_TRUEG, 0x80);
dev->write_register(REG_TRUEB, 0x80);
dev->interface->write_register(REG_TRUER, 0x80);
dev->interface->write_register(REG_TRUEG, 0x80);
dev->interface->write_register(REG_TRUEB, 0x80);
}
}
@ -1030,7 +1030,7 @@ void CommandSetGl124::set_powersaving(Genesys_Device* dev, int delay /* in minut
static void gl124_start_action(Genesys_Device* dev)
{
DBG_HELPER(dbg);
dev->write_register(0x0f, 0x01);
dev->interface->write_register(0x0f, 0x01);
}
static void gl124_stop_action(Genesys_Device* dev)
@ -1048,7 +1048,7 @@ static void gl124_stop_action(Genesys_Device* dev)
sanei_genesys_print_status (val);
}
val40 = dev->read_register(REG_0x100);
val40 = dev->interface->read_register(REG_0x100);
/* only stop action if needed */
if (!(val40 & REG_0x100_DATAENB) && !(val40 & REG_0x100_MOTMFLG)) {
@ -1060,7 +1060,7 @@ static void gl124_stop_action(Genesys_Device* dev)
val = dev->reg.get8(REG_0x01);
val &= ~REG_0x01_SCAN;
dev->reg.set8(REG_0x01, val);
dev->write_register(REG_0x01, val);
dev->interface->write_register(REG_0x01, val);
sanei_genesys_sleep_ms(100);
@ -1072,7 +1072,7 @@ static void gl124_stop_action(Genesys_Device* dev)
{
sanei_genesys_print_status (val);
}
val40 = dev->read_register(REG_0x100);
val40 = dev->interface->read_register(REG_0x100);
/* if scanner is in command mode, we are done */
if (!(val40 & REG_0x100_DATAENB) && !(val40 & REG_0x100_MOTMFLG) && !(val & MOTORENB)) {
@ -1097,7 +1097,7 @@ static void gl124_setup_scan_gpio(Genesys_Device* dev, int resolution)
{
DBG_HELPER(dbg);
uint8_t val = dev->read_register(REG_0x32);
uint8_t val = dev->interface->read_register(REG_0x32);
/* LiDE 110, 210 and 220 cases */
if(dev->model->gpio_id != GpioId::CANON_LIDE_120) {
@ -1136,7 +1136,7 @@ static void gl124_setup_scan_gpio(Genesys_Device* dev, int resolution)
}
}
val |= 0x02;
dev->write_register(REG_0x32, val);
dev->interface->write_register(REG_0x32, val);
}
// Send the low-level scan command
@ -1152,17 +1152,17 @@ void CommandSetGl124::begin_scan(Genesys_Device* dev, const Genesys_Sensor& sens
gl124_setup_scan_gpio(dev,dev->settings.yres);
// clear scan and feed count
dev->write_register(REG_0x0D, REG_0x0D_CLRLNCNT | REG_0x0D_CLRMCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRLNCNT | REG_0x0D_CLRMCNT);
// enable scan and motor
uint8_t val = dev->read_register(REG_0x01);
uint8_t val = dev->interface->read_register(REG_0x01);
val |= REG_0x01_SCAN;
dev->write_register(REG_0x01, val);
dev->interface->write_register(REG_0x01, val);
if (start_motor) {
dev->write_register(REG_0x0F, 1);
dev->interface->write_register(REG_0x0F, 1);
} else {
dev->write_register(REG_0x0F, 0);
dev->interface->write_register(REG_0x0F, 0);
}
}
@ -1189,9 +1189,9 @@ void CommandSetGl124::rewind(Genesys_Device* dev) const
DBG_HELPER(dbg);
// set motor reverse
uint8_t byte = dev->read_register(0x02);
uint8_t byte = dev->interface->read_register(0x02);
byte |= 0x04;
dev->write_register(0x02, byte);
dev->interface->write_register(0x02, byte);
const auto& sensor = sanei_genesys_find_sensor_any(dev);
@ -1200,14 +1200,14 @@ void CommandSetGl124::rewind(Genesys_Device* dev) const
do
{
sanei_genesys_sleep_ms(100);
byte = dev->read_register(REG_0x100);
byte = dev->interface->read_register(REG_0x100);
} while (byte & REG_0x100_MOTMFLG);
end_scan(dev, &dev->reg, true);
// restore direction
byte = dev->read_register(0x02);
byte = dev->interface->read_register(0x02);
byte &= 0xfb;
dev->write_register(0x02, byte);
dev->interface->write_register(0x02, byte);
}
@ -1283,13 +1283,13 @@ void CommandSetGl124::slow_back_home(Genesys_Device* dev, bool wait_until_home)
gl124_init_scan_regs(dev, sensor, &local_reg, session);
// clear scan and feed count
dev->write_register(REG_0x0D, REG_0x0D_CLRLNCNT | REG_0x0D_CLRMCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRLNCNT | REG_0x0D_CLRMCNT);
/* set up for reverse and no scan */
r = sanei_genesys_get_address(&local_reg, REG_0x02);
r->value |= REG_0x02_MTRREV;
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
gl124_setup_scan_gpio(dev,resolution);
@ -1300,7 +1300,7 @@ void CommandSetGl124::slow_back_home(Genesys_Device* dev, bool wait_until_home)
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
});
throw;
}
@ -1377,8 +1377,8 @@ static void gl124_feed(Genesys_Device* dev, unsigned int steps, int reverse)
local_reg.set24(REG_EXPB, 0);
// clear scan and feed count
dev->write_register(REG_0x0D, REG_0x0D_CLRLNCNT);
dev->write_register(REG_0x0D, REG_0x0D_CLRMCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRLNCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRMCNT);
/* set up for no scan */
r = sanei_genesys_get_address (&local_reg, REG_0x01);
@ -1392,7 +1392,7 @@ static void gl124_feed(Genesys_Device* dev, unsigned int steps, int reverse)
}
// send registers
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
try {
gl124_start_action(dev);
@ -1402,7 +1402,7 @@ static void gl124_feed(Genesys_Device* dev, unsigned int steps, int reverse)
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
});
throw;
}
@ -1456,7 +1456,7 @@ void CommandSetGl124::search_start_position(Genesys_Device* dev) const
gl124_init_scan_regs(dev, sensor, &local_reg, session);
// send to scanner
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
size = pixels * dev->model->search_lines;
@ -1521,7 +1521,7 @@ void CommandSetGl124::init_regs_for_coarse_calibration(Genesys_Device* dev,
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
sensor.optical_res / sensor.ccd_pixels_per_system_pixel(), dev->settings.xres);
dev->write_registers(regs);
dev->interface->write_registers(regs);
}
@ -1590,7 +1590,7 @@ void CommandSetGl124::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
dev->scanhead_position_in_steps += dev->calib_lines + move;
dev->write_registers(regs);
dev->interface->write_registers(regs);
}
void CommandSetGl124::wait_for_motor_stop(Genesys_Device* dev) const
@ -1599,7 +1599,7 @@ void CommandSetGl124::wait_for_motor_stop(Genesys_Device* dev) const
uint8_t val;
val = sanei_genesys_get_status(dev);
uint8_t val40 = dev->read_register(REG_0x100);
uint8_t val40 = dev->interface->read_register(REG_0x100);
if ((val & MOTORENB) == 0 && (val40 & REG_0x100_MOTMFLG) == 0)
return;
@ -1607,7 +1607,7 @@ void CommandSetGl124::wait_for_motor_stop(Genesys_Device* dev) const
do {
sanei_genesys_sleep_ms(10);
val = sanei_genesys_get_status(dev);
val40 = dev->read_register(REG_0x100);
val40 = dev->interface->read_register(REG_0x100);
} while ((val & MOTORENB) ||(val40 & REG_0x100_MOTMFLG));
sanei_genesys_sleep_ms(50);
}
@ -1752,7 +1752,7 @@ void CommandSetGl124::send_shading_data(Genesys_Device* dev, const Genesys_Senso
/* next shading coefficient */
ptr+=4;
}
uint8_t val = dev->read_register(0xd0+i);
uint8_t val = dev->interface->read_register(0xd0+i);
addr = val * 8192 + 0x10000000;
dev->interface->write_ahb(addr, pixels * dev->session.segment_count, buffer.data());
}
@ -1800,7 +1800,7 @@ static void move_to_calibration_area(Genesys_Device* dev, const Genesys_Sensor&
std::vector<uint8_t> line(size);
// write registers and scan data
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG (DBG_info, "%s: starting line reading\n", __func__);
dev->cmd_set->begin_scan(dev, sensor, &regs, true);
@ -1894,7 +1894,7 @@ SensorExposure CommandSetGl124::led_calibration(Genesys_Device* dev, const Genes
regs.set24(REG_EXPB, exp[2]);
// write registers and scan data
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting line reading\n", __func__);
begin_scan(dev, sensor, &regs, true);
@ -2007,7 +2007,7 @@ void CommandSetGl124::offset_calibration(Genesys_Device* dev, const Genesys_Sens
int top, bottom, black_pixels, pixels;
// no gain nor offset for TI AFE
uint8_t reg0a = dev->read_register(REG_0x0A);
uint8_t reg0a = dev->interface->read_register(REG_0x0A);
if (((reg0a & REG_0x0A_SIFSEL) >> REG_0x0AS_SIFSEL) == 3) {
return;
}
@ -2060,7 +2060,7 @@ void CommandSetGl124::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->frontend.set_offset(2, bottom);
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size);
@ -2081,7 +2081,7 @@ void CommandSetGl124::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->frontend.set_offset(1, top);
dev->frontend.set_offset(2, top);
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size);
@ -2101,7 +2101,7 @@ void CommandSetGl124::offset_calibration(Genesys_Device* dev, const Genesys_Sens
// scan with no move
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size);
@ -2157,7 +2157,7 @@ void CommandSetGl124::coarse_gain_calibration(Genesys_Device* dev, const Genesys
int val, code, lines;
// no gain nor offset for TI AFE
uint8_t reg0a = dev->read_register(REG_0x0A);
uint8_t reg0a = dev->interface->read_register(REG_0x0A);
if (((reg0a & REG_0x0A_SIFSEL) >> REG_0x0AS_SIFSEL) == 3) {
return;
}
@ -2201,7 +2201,7 @@ void CommandSetGl124::coarse_gain_calibration(Genesys_Device* dev, const Genesys
sanei_genesys_set_motor_power(regs, false);
dev->write_registers(regs);
dev->interface->write_registers(regs);
total_size = pixels * channels * (16 / session.params.depth) * lines;
@ -2307,7 +2307,7 @@ void CommandSetGl124::init_regs_for_warmup(Genesys_Device* dev, const Genesys_Se
*total_size = num_pixels * 3 * 1; /* colors * bytes_per_color * scan lines */
sanei_genesys_set_motor_power(*reg, false);
dev->write_registers(*reg);
dev->interface->write_registers(*reg);
}
/** @brief default GPIO values
@ -2330,13 +2330,13 @@ static void gl124_init_gpio(Genesys_Device* dev)
idx = 1;
}
dev->write_register(REG_0x31, gpios[idx].r31);
dev->write_register(REG_0x32, gpios[idx].r32);
dev->write_register(REG_0x33, gpios[idx].r33);
dev->write_register(REG_0x34, gpios[idx].r34);
dev->write_register(REG_0x35, gpios[idx].r35);
dev->write_register(REG_0x36, gpios[idx].r36);
dev->write_register(REG_0x38, gpios[idx].r38);
dev->interface->write_register(REG_0x31, gpios[idx].r31);
dev->interface->write_register(REG_0x32, gpios[idx].r32);
dev->interface->write_register(REG_0x33, gpios[idx].r33);
dev->interface->write_register(REG_0x34, gpios[idx].r34);
dev->interface->write_register(REG_0x35, gpios[idx].r35);
dev->interface->write_register(REG_0x36, gpios[idx].r36);
dev->interface->write_register(REG_0x38, gpios[idx].r38);
}
/**
@ -2361,48 +2361,48 @@ static void gl124_init_memory_layout(Genesys_Device* dev)
/* setup base address for shading data. */
/* values must be multiplied by 8192=0x4000 to give address on AHB */
/* R-Channel shading bank0 address setting for CIS */
dev->write_register(0xd0, layouts[idx].rd0);
dev->interface->write_register(0xd0, layouts[idx].rd0);
/* G-Channel shading bank0 address setting for CIS */
dev->write_register(0xd1, layouts[idx].rd1);
dev->interface->write_register(0xd1, layouts[idx].rd1);
/* B-Channel shading bank0 address setting for CIS */
dev->write_register(0xd2, layouts[idx].rd2);
dev->interface->write_register(0xd2, layouts[idx].rd2);
/* setup base address for scanned data. */
/* values must be multiplied by 1024*2=0x0800 to give address on AHB */
/* R-Channel ODD image buffer 0x0124->0x92000 */
/* size for each buffer is 0x16d*1k word */
dev->write_register(0xe0, layouts[idx].re0);
dev->write_register(0xe1, layouts[idx].re1);
dev->interface->write_register(0xe0, layouts[idx].re0);
dev->interface->write_register(0xe1, layouts[idx].re1);
/* R-Channel ODD image buffer end-address 0x0291->0x148800 => size=0xB6800*/
dev->write_register(0xe2, layouts[idx].re2);
dev->write_register(0xe3, layouts[idx].re3);
dev->interface->write_register(0xe2, layouts[idx].re2);
dev->interface->write_register(0xe3, layouts[idx].re3);
/* R-Channel EVEN image buffer 0x0292 */
dev->write_register(0xe4, layouts[idx].re4);
dev->write_register(0xe5, layouts[idx].re5);
dev->interface->write_register(0xe4, layouts[idx].re4);
dev->interface->write_register(0xe5, layouts[idx].re5);
/* R-Channel EVEN image buffer end-address 0x03ff*/
dev->write_register(0xe6, layouts[idx].re6);
dev->write_register(0xe7, layouts[idx].re7);
dev->interface->write_register(0xe6, layouts[idx].re6);
dev->interface->write_register(0xe7, layouts[idx].re7);
/* same for green, since CIS, same addresses */
dev->write_register(0xe8, layouts[idx].re0);
dev->write_register(0xe9, layouts[idx].re1);
dev->write_register(0xea, layouts[idx].re2);
dev->write_register(0xeb, layouts[idx].re3);
dev->write_register(0xec, layouts[idx].re4);
dev->write_register(0xed, layouts[idx].re5);
dev->write_register(0xee, layouts[idx].re6);
dev->write_register(0xef, layouts[idx].re7);
dev->interface->write_register(0xe8, layouts[idx].re0);
dev->interface->write_register(0xe9, layouts[idx].re1);
dev->interface->write_register(0xea, layouts[idx].re2);
dev->interface->write_register(0xeb, layouts[idx].re3);
dev->interface->write_register(0xec, layouts[idx].re4);
dev->interface->write_register(0xed, layouts[idx].re5);
dev->interface->write_register(0xee, layouts[idx].re6);
dev->interface->write_register(0xef, layouts[idx].re7);
/* same for blue, since CIS, same addresses */
dev->write_register(0xf0, layouts[idx].re0);
dev->write_register(0xf1, layouts[idx].re1);
dev->write_register(0xf2, layouts[idx].re2);
dev->write_register(0xf3, layouts[idx].re3);
dev->write_register(0xf4, layouts[idx].re4);
dev->write_register(0xf5, layouts[idx].re5);
dev->write_register(0xf6, layouts[idx].re6);
dev->write_register(0xf7, layouts[idx].re7);
dev->interface->write_register(0xf0, layouts[idx].re0);
dev->interface->write_register(0xf1, layouts[idx].re1);
dev->interface->write_register(0xf2, layouts[idx].re2);
dev->interface->write_register(0xf3, layouts[idx].re3);
dev->interface->write_register(0xf4, layouts[idx].re4);
dev->interface->write_register(0xf5, layouts[idx].re5);
dev->interface->write_register(0xf6, layouts[idx].re6);
dev->interface->write_register(0xf7, layouts[idx].re7);
}
/**
@ -2427,22 +2427,22 @@ void CommandSetGl124::asic_boot(Genesys_Device* dev, bool cold) const
// reset ASIC in case of cold boot
if (cold) {
dev->write_register(0x0e, 0x01);
dev->write_register(0x0e, 0x00);
dev->interface->write_register(0x0e, 0x01);
dev->interface->write_register(0x0e, 0x00);
}
// enable GPOE 17
dev->write_register(0x36, 0x01);
dev->interface->write_register(0x36, 0x01);
// set GPIO 17
uint8_t val = dev->read_register(0x33);
uint8_t val = dev->interface->read_register(0x33);
val |= 0x01;
dev->write_register(0x33, val);
dev->interface->write_register(0x33, val);
// test CHKVER
val = dev->read_register(REG_0x100);
val = dev->interface->read_register(REG_0x100);
if (val & REG_0x100_CHKVER) {
val = dev->read_register(0x00);
val = dev->interface->read_register(0x00);
DBG(DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __func__, val);
}
@ -2450,10 +2450,10 @@ void CommandSetGl124::asic_boot(Genesys_Device* dev, bool cold) const
gl124_init_registers (dev);
// Write initial registers
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
// tune reg 0B
dev->write_register(REG_0x0B, REG_0x0B_30MHZ | REG_0x0B_ENBDRAM | REG_0x0B_64M);
dev->interface->write_register(REG_0x0B, REG_0x0B_30MHZ | REG_0x0B_ENBDRAM | REG_0x0B_64M);
dev->reg.remove_reg(0x0b);
//set up end access
@ -2462,7 +2462,7 @@ void CommandSetGl124::asic_boot(Genesys_Device* dev, bool cold) const
/* CIS_LINE */
SETREG(0x08, REG_0x08_CIS_LINE);
dev->write_register(0x08, dev->reg.find_reg(0x08).value);
dev->interface->write_register(0x08, dev->reg.find_reg(0x08).value);
// setup gpio
gl124_init_gpio(dev);
@ -2478,7 +2478,7 @@ void CommandSetGl124::update_hardware_sensors(Genesys_Scanner* s) const
any of them.
*/
DBG_HELPER(dbg);
uint8_t val = s->dev->read_register(REG_0x31);
uint8_t val = s->dev->interface->read_register(REG_0x31);
/* TODO : for the next scanner special case,
* add another per scanner button profile struct to avoid growing

42
backend/genesys/gl646.cpp
Wyświetl plik

@ -123,7 +123,7 @@ print_status (uint8_t val)
static void gl646_start_motor(Genesys_Device* dev)
{
DBG_HELPER(dbg);
dev->write_register(0x0f, 0x01);
dev->interface->write_register(0x0f, 0x01);
}
@ -134,7 +134,7 @@ static void gl646_start_motor(Genesys_Device* dev)
static void gl646_stop_motor(Genesys_Device* dev)
{
DBG_HELPER(dbg);
dev->write_register(0x0f, 0x00);
dev->interface->write_register(0x0f, 0x00);
}
/**
@ -890,7 +890,7 @@ static void gl646_wm_hp3670(Genesys_Device* dev, const Genesys_Sensor& sensor, u
case AFE_INIT:
dev->interface->write_fe_register(0x04, 0x80);
sanei_genesys_sleep_ms(200);
dev->write_register(0x50, 0x00);
dev->interface->write_register(0x50, 0x00);
dev->frontend = dev->frontend_initial;
dev->interface->write_fe_register(0x01, dev->frontend.regs.get_value(0x01));
dev->interface->write_fe_register(0x02, dev->frontend.regs.get_value(0x02));
@ -1111,7 +1111,7 @@ void CommandSetGl646::set_powersaving(Genesys_Device* dev, int delay /* in minut
local_reg.find_reg(0x38).value = exposure_time / 256;
local_reg.find_reg(0x39).value = exposure_time & 255;
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
}
@ -1203,7 +1203,7 @@ void CommandSetGl646::load_document(Genesys_Device* dev) const
// wait e1 status to become e0
gl646_send_slope_table(dev, 1, slope_table, 50);
dev->write_registers(regs);
dev->interface->write_registers(regs);
gl646_start_motor(dev);
@ -1228,7 +1228,7 @@ void CommandSetGl646::load_document(Genesys_Device* dev) const
regs.set8(0x02, 0x71);
regs.set8(0x3f, 1);
regs.set8(0x6b, 8);
dev->write_registers(regs);
dev->interface->write_registers(regs);
}
/**
@ -1329,7 +1329,7 @@ void CommandSetGl646::eject_document(Genesys_Device* dev) const
}
// there is a document inserted, eject it
dev->write_register(0x01, 0xb0);
dev->interface->write_register(0x01, 0xb0);
/* wait for motor to stop */
do
@ -1374,7 +1374,7 @@ void CommandSetGl646::eject_document(Genesys_Device* dev) const
// wait c1 status to become c8 : HOMESNR and ~MOTFLAG
gl646_send_slope_table(dev, 1, slope_table, 60);
dev->write_registers(regs);
dev->interface->write_registers(regs);
gl646_start_motor(dev);
@ -1414,7 +1414,7 @@ void CommandSetGl646::begin_scan(Genesys_Device* dev, const Genesys_Sensor& sens
local_reg.init_reg(0x0f, 0x00); // do not start motor yet
}
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
}
@ -1443,7 +1443,7 @@ static void end_scan_impl(Genesys_Device* dev, Genesys_Register_Set* reg, bool c
val = reg->get8(0x01);
val &= ~REG_0x01_SCAN;
reg->set8(0x01, val);
dev->write_register(0x01, val);
dev->interface->write_register(0x01, val);
/* for sheetfed scanners, we may have to eject document */
if (dev->model->is_sheetfed) {
@ -1602,7 +1602,7 @@ void CommandSetGl646::slow_back_home(Genesys_Device* dev, bool wait_until_home)
/* write scan registers */
try {
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
} catch (...) {
DBG(DBG_error, "%s: failed to bulk write registers\n", __func__);
}
@ -2710,7 +2710,7 @@ void CommandSetGl646::init_regs_for_warmup(Genesys_Device* dev, const Genesys_Se
// now registers are ok, write them to scanner
gl646_set_fe(dev, local_sensor, AFE_SET, settings.xres);
dev->write_registers(*local_reg);
dev->interface->write_registers(*local_reg);
}
@ -2748,7 +2748,7 @@ static void gl646_repark_head(Genesys_Device* dev)
/* TODO seems wrong ... no effective scan */
dev->reg.find_reg(0x01).value &= ~REG_0x01_SCAN;
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
// start scan
dev->cmd_set->begin_scan(dev, sensor, &dev->reg, true);
@ -2822,11 +2822,11 @@ void CommandSetGl646::init(Genesys_Device* dev) const
dev->usb_dev.control_msg(REQUEST_TYPE_OUT, REQUEST_REGISTER, VALUE_INIT, INDEX, 1, &val);
// ASIC reset
dev->write_register(0x0e, 0x00);
dev->interface->write_register(0x0e, 0x00);
sanei_genesys_sleep_ms(100);
// Write initial registers
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
// send gamma tables if needed
dev->cmd_set->send_gamma_table(dev, sensor);
@ -2840,8 +2840,8 @@ void CommandSetGl646::init(Genesys_Device* dev) const
/* GPO enabling for XP200 */
if (dev->model->sensor_id == SensorId::CIS_XP200) {
dev->write_register(0x68, dev->gpo.regs.get_value(0x68));
dev->write_register(0x69, dev->gpo.regs.get_value(0x69));
dev->interface->write_register(0x68, dev->gpo.regs.get_value(0x68));
dev->interface->write_register(0x69, dev->gpo.regs.get_value(0x69));
// enable GPIO
gl646_gpio_output_enable(dev->usb_dev, 6);
@ -2852,9 +2852,9 @@ void CommandSetGl646::init(Genesys_Device* dev) const
// clear GPIO enable
gl646_gpio_output_enable(dev->usb_dev, 0);
dev->write_register(0x66, 0x10);
dev->write_register(0x66, 0x00);
dev->write_register(0x66, 0x10);
dev->interface->write_register(0x66, 0x10);
dev->interface->write_register(0x66, 0x00);
dev->interface->write_register(0x66, 0x10);
}
/* MD6471/G2410 and XP200 read/write data from an undocumented memory area which
@ -3009,7 +3009,7 @@ static void simple_scan(Genesys_Device* dev, const Genesys_Sensor& sensor,
}
// write scan registers
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
// starts scan
dev->cmd_set->begin_scan(dev, sensor, &dev->reg, move);

192
backend/genesys/gl841.cpp
Wyświetl plik

@ -66,10 +66,10 @@ static void gl841_set_buffer_address_gamma(Genesys_Device* dev, uint32_t addr)
addr = addr >> 4;
dev->write_register(0x5c, (addr & 0xff));
dev->interface->write_register(0x5c, (addr & 0xff));
addr = addr >> 8;
dev->write_register(0x5b, (addr & 0xff));
dev->interface->write_register(0x5b, (addr & 0xff));
}
bool CommandSetGl841::get_gain4_bit(Genesys_Register_Set* regs) const
@ -340,31 +340,31 @@ gl841_init_lide80 (Genesys_Device * dev)
}
// specific scanner settings, clock and gpio first
val = dev->read_register(REG_0x6B);
dev->write_register(REG_0x6B, 0x0c);
dev->write_register(0x06, 0x10);
dev->write_register(REG_0x6E, 0x6d);
dev->write_register(REG_0x6F, 0x80);
dev->write_register(REG_0x6B, 0x0e);
val = dev->read_register(REG_0x6C);
dev->write_register(REG_0x6C, 0x00);
val = dev->read_register(REG_0x6D);
dev->write_register(REG_0x6D, 0x8f);
val = dev->read_register(REG_0x6B);
dev->write_register(REG_0x6B, 0x0e);
val = dev->read_register(REG_0x6B);
dev->write_register(REG_0x6B, 0x0e);
val = dev->read_register(REG_0x6B);
dev->write_register(REG_0x6B, 0x0a);
val = dev->read_register(REG_0x6B);
dev->write_register(REG_0x6B, 0x02);
val = dev->read_register(REG_0x6B);
dev->write_register(REG_0x6B, 0x06);
val = dev->interface->read_register(REG_0x6B);
dev->interface->write_register(REG_0x6B, 0x0c);
dev->interface->write_register(0x06, 0x10);
dev->interface->write_register(REG_0x6E, 0x6d);
dev->interface->write_register(REG_0x6F, 0x80);
dev->interface->write_register(REG_0x6B, 0x0e);
val = dev->interface->read_register(REG_0x6C);
dev->interface->write_register(REG_0x6C, 0x00);
val = dev->interface->read_register(REG_0x6D);
dev->interface->write_register(REG_0x6D, 0x8f);
val = dev->interface->read_register(REG_0x6B);
dev->interface->write_register(REG_0x6B, 0x0e);
val = dev->interface->read_register(REG_0x6B);
dev->interface->write_register(REG_0x6B, 0x0e);
val = dev->interface->read_register(REG_0x6B);
dev->interface->write_register(REG_0x6B, 0x0a);
val = dev->interface->read_register(REG_0x6B);
dev->interface->write_register(REG_0x6B, 0x02);
val = dev->interface->read_register(REG_0x6B);
dev->interface->write_register(REG_0x6B, 0x06);
(void) val; // FIXME: we don't use the information read from registers
dev->interface->write_0x8c(0x10, 0x94);
dev->write_register(0x09, 0x10);
dev->interface->write_register(0x09, 0x10);
// FIXME: the following code originally changed 0x6b, but due to bug the 0x6c register was
// effectively changed. The current behavior matches the old code, but should probably be fixed.
@ -812,12 +812,12 @@ uint8_t *table;
default:
table=tdefault;
}
dev->write_register(0x66, 0x00);
dev->write_register(0x5b, 0x0c);
dev->write_register(0x5c, 0x00);
dev->interface->write_register(0x66, 0x00);
dev->interface->write_register(0x5b, 0x0c);
dev->interface->write_register(0x5c, 0x00);
dev->interface->bulk_write_data(0x28, table, 128);
dev->write_register(0x5b, 0x00);
dev->write_register(0x5c, 0x00);
dev->interface->write_register(0x5b, 0x00);
dev->interface->write_register(0x5c, 0x00);
}
}
@ -1715,33 +1715,33 @@ void CommandSetGl841::save_power(Genesys_Device* dev, bool enable) const
/* final state: GPIO8 disabled, GPIO9 enabled, GPIO17 disabled,
GPIO18 disabled*/
uint8_t val = dev->read_register(REG_0x6D);
dev->write_register(REG_0x6D, val | 0x80);
uint8_t val = dev->interface->read_register(REG_0x6D);
dev->interface->write_register(REG_0x6D, val | 0x80);
sanei_genesys_sleep_ms(1);
/*enable GPIO9*/
val = dev->read_register(REG_0x6C);
dev->write_register(REG_0x6C, val | 0x01);
val = dev->interface->read_register(REG_0x6C);
dev->interface->write_register(REG_0x6C, val | 0x01);
/*disable GPO17*/
val = dev->read_register(REG_0x6B);
dev->write_register(REG_0x6B, val & ~REG_0x6B_GPO17);
val = dev->interface->read_register(REG_0x6B);
dev->interface->write_register(REG_0x6B, val & ~REG_0x6B_GPO17);
/*disable GPO18*/
val = dev->read_register(REG_0x6B);
dev->write_register(REG_0x6B, val & ~REG_0x6B_GPO18);
val = dev->interface->read_register(REG_0x6B);
dev->interface->write_register(REG_0x6B, val & ~REG_0x6B_GPO18);
sanei_genesys_sleep_ms(1);
val = dev->read_register(REG_0x6D);
dev->write_register(REG_0x6D, val & ~0x80);
val = dev->interface->read_register(REG_0x6D);
dev->interface->write_register(REG_0x6D, val & ~0x80);
}
if (dev->model->gpio_id == GpioId::DP685)
{
uint8_t val = dev->read_register(REG_0x6B);
dev->write_register(REG_0x6B, val & ~REG_0x6B_GPO17);
uint8_t val = dev->interface->read_register(REG_0x6B);
dev->interface->write_register(REG_0x6B, val & ~REG_0x6B_GPO17);
dev->reg.find_reg(0x6b).value &= ~REG_0x6B_GPO17;
dev->calib_reg.find_reg(0x6b).value &= ~REG_0x6B_GPO17;
}
@ -1758,28 +1758,28 @@ void CommandSetGl841::save_power(Genesys_Device* dev, bool enable) const
/* final state: GPIO8 enabled, GPIO9 disabled, GPIO17 enabled,
GPIO18 enabled*/
uint8_t val = dev->read_register(REG_0x6D);
dev->write_register(REG_0x6D, val | 0x80);
uint8_t val = dev->interface->read_register(REG_0x6D);
dev->interface->write_register(REG_0x6D, val | 0x80);
sanei_genesys_sleep_ms(10);
/*disable GPIO9*/
val = dev->read_register(REG_0x6C);
dev->write_register(REG_0x6C, val & ~0x01);
val = dev->interface->read_register(REG_0x6C);
dev->interface->write_register(REG_0x6C, val & ~0x01);
/*enable GPIO10*/
val = dev->read_register(REG_0x6C);
dev->write_register(REG_0x6C, val | 0x02);
val = dev->interface->read_register(REG_0x6C);
dev->interface->write_register(REG_0x6C, val | 0x02);
/*enable GPO17*/
val = dev->read_register(REG_0x6B);
dev->write_register(REG_0x6B, val | REG_0x6B_GPO17);
val = dev->interface->read_register(REG_0x6B);
dev->interface->write_register(REG_0x6B, val | REG_0x6B_GPO17);
dev->reg.find_reg(0x6b).value |= REG_0x6B_GPO17;
dev->calib_reg.find_reg(0x6b).value |= REG_0x6B_GPO17;
/*enable GPO18*/
val = dev->read_register(REG_0x6B);
dev->write_register(REG_0x6B, val | REG_0x6B_GPO18);
val = dev->interface->read_register(REG_0x6B);
dev->interface->write_register(REG_0x6B, val | REG_0x6B_GPO18);
dev->reg.find_reg(0x6b).value |= REG_0x6B_GPO18;
dev->calib_reg.find_reg(0x6b).value |= REG_0x6B_GPO18;
@ -1787,8 +1787,8 @@ void CommandSetGl841::save_power(Genesys_Device* dev, bool enable) const
if (dev->model->gpio_id == GpioId::DP665
|| dev->model->gpio_id == GpioId::DP685)
{
uint8_t val = dev->read_register(REG_0x6B);
dev->write_register(REG_0x6B, val | REG_0x6B_GPO17);
uint8_t val = dev->interface->read_register(REG_0x6B);
dev->interface->write_register(REG_0x6B, val | REG_0x6B_GPO17);
dev->reg.find_reg(0x6b).value |= REG_0x6B_GPO17;
dev->calib_reg.find_reg(0x6b).value |= REG_0x6B_GPO17;
}
@ -1857,13 +1857,13 @@ void CommandSetGl841::set_powersaving(Genesys_Device* dev, int delay /* in minut
local_reg.set8(0x38, exposure_time >> 8);
local_reg.set8(0x39, exposure_time & 255); /* lowbyte */
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
}
static void gl841_start_action(Genesys_Device* dev)
{
DBG_HELPER(dbg);
dev->write_register(0x0f, 0x01);
dev->interface->write_register(0x0f, 0x01);
}
static void gl841_stop_action(Genesys_Device* dev)
@ -1879,7 +1879,7 @@ static void gl841_stop_action(Genesys_Device* dev)
sanei_genesys_print_status (val);
}
uint8_t val40 = dev->read_register(0x40);
uint8_t val40 = dev->interface->read_register(0x40);
/* only stop action if needed */
if (!(val40 & REG_0x40_DATAENB) && !(val40 & REG_0x40_MOTMFLG)) {
@ -1892,7 +1892,7 @@ static void gl841_stop_action(Genesys_Device* dev)
gl841_init_optical_regs_off(&local_reg);
gl841_init_motor_regs_off(&local_reg,0);
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
/* looks like writing the right registers to zero is enough to get the chip
out of scan mode into command mode, actually triggering(writing to
@ -1900,7 +1900,7 @@ static void gl841_stop_action(Genesys_Device* dev)
loop = 10;
while (loop > 0) {
val40 = dev->read_register(0x40);
val40 = dev->interface->read_register(0x40);
if (DBG_LEVEL >= DBG_io) {
sanei_genesys_print_status(val);
}
@ -1921,7 +1921,7 @@ static bool gl841_get_paper_sensor(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val = dev->read_register(REG_0x6D);
uint8_t val = dev->interface->read_register(REG_0x6D);
return (val & 0x1) == 0;
}
@ -1955,7 +1955,7 @@ void CommandSetGl841::eject_document(Genesys_Device* dev) const
gl841_init_motor_regs(dev, sensor, &local_reg,
65536,MOTOR_ACTION_FEED,0);
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
try {
gl841_start_action(dev);
@ -1964,7 +1964,7 @@ void CommandSetGl841::eject_document(Genesys_Device* dev) const
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
});
throw;
}
@ -2131,9 +2131,9 @@ void CommandSetGl841::begin_scan(Genesys_Device* dev, const Genesys_Sensor& sens
uint8_t val;
if (dev->model->gpio_id == GpioId::CANON_LIDE_80) {
val = dev->read_register(REG_0x6B);
val = dev->interface->read_register(REG_0x6B);
val = REG_0x6B_GPO18;
dev->write_register(REG_0x6B, val);
dev->interface->write_register(REG_0x6B, val);
}
if (dev->model->sensor_id != SensorId::CCD_PLUSTEK_OPTICPRO_3600) {
@ -2153,7 +2153,7 @@ void CommandSetGl841::begin_scan(Genesys_Device* dev, const Genesys_Sensor& sens
local_reg.init_reg(0x0f, 0x00);
}
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
}
@ -2187,7 +2187,7 @@ static void gl841_feed(Genesys_Device* dev, int steps)
gl841_init_motor_regs(dev, sensor, &local_reg, steps,MOTOR_ACTION_FEED,0);
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
try {
gl841_start_action(dev);
@ -2196,7 +2196,7 @@ static void gl841_feed(Genesys_Device* dev, int steps)
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
});
throw;
}
@ -2238,14 +2238,14 @@ void CommandSetGl841::slow_back_home(Genesys_Device* dev, bool wait_until_home)
// reset gpio pin
uint8_t val;
if (dev->model->gpio_id == GpioId::CANON_LIDE_35) {
val = dev->read_register(REG_0x6C);
val = dev->interface->read_register(REG_0x6C);
val = dev->gpo.regs.get_value(0x6c);
dev->write_register(REG_0x6C, val);
dev->interface->write_register(REG_0x6C, val);
}
if (dev->model->gpio_id == GpioId::CANON_LIDE_80) {
val = dev->read_register(REG_0x6B);
val = dev->interface->read_register(REG_0x6B);
val = REG_0x6B_GPO18 | REG_0x6B_GPO17;
dev->write_register(REG_0x6B, val);
dev->interface->write_register(REG_0x6B, val);
}
dev->cmd_set->save_power(dev, false);
@ -2278,7 +2278,7 @@ void CommandSetGl841::slow_back_home(Genesys_Device* dev, bool wait_until_home)
/* end previous scan if any */
r = sanei_genesys_get_address(&dev->reg, REG_0x01);
r->value &= ~REG_0x01_SCAN;
dev->write_register(REG_0x01, r->value);
dev->interface->write_register(REG_0x01, r->value);
/* if motor is on, stop current action */
if (val & REG_0x41_MOTORENB) {
@ -2297,7 +2297,7 @@ void CommandSetGl841::slow_back_home(Genesys_Device* dev, bool wait_until_home)
r = sanei_genesys_get_address(&local_reg, REG_0x01);
r->value &= ~REG_0x01_SCAN;
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
try {
gl841_start_action(dev);
@ -2306,7 +2306,7 @@ void CommandSetGl841::slow_back_home(Genesys_Device* dev, bool wait_until_home)
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
});
throw;
}
@ -2377,7 +2377,7 @@ void CommandSetGl841::search_start_position(Genesys_Device* dev) const
gl841_init_scan_regs(dev, sensor, &local_reg, session);
// send to scanner
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
size = pixels * dev->model->search_lines;
@ -2439,7 +2439,7 @@ void CommandSetGl841::init_regs_for_coarse_calibration(Genesys_Device* dev,
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
sensor.optical_res / sensor.ccd_pixels_per_system_pixel(), dev->settings.xres);
dev->write_registers(regs);
dev->interface->write_registers(regs);
/* if (DBG_LEVEL >= DBG_info)
sanei_gl841_print_registers (regs);*/
@ -2510,7 +2510,7 @@ void CommandSetGl841::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
dev->scanhead_position_in_steps += dev->calib_lines + starty;
dev->write_registers(regs);
dev->interface->write_registers(regs);
}
// set up registers for the actual scan
@ -2685,7 +2685,7 @@ SensorExposure CommandSetGl841::led_calibration(Genesys_Device* dev, const Genes
gl841_init_scan_regs(dev, calib_sensor_base, &regs, session);
dev->write_registers(regs);
dev->interface->write_registers(regs);
total_size = num_pixels * channels * 2 * 1; /* colors * bytes_per_color * scan lines */
@ -2719,14 +2719,14 @@ SensorExposure CommandSetGl841::led_calibration(Genesys_Device* dev, const Genes
calib_sensor.exposure.blue = exp[2];
sanei_genesys_set_exposure(regs, calib_sensor.exposure);
dev->write_register(0x10, (calib_sensor.exposure.red >> 8) & 0xff);
dev->write_register(0x11, calib_sensor.exposure.red & 0xff);
dev->write_register(0x12, (calib_sensor.exposure.green >> 8) & 0xff);
dev->write_register(0x13, calib_sensor.exposure.green & 0xff);
dev->write_register(0x14, (calib_sensor.exposure.blue >> 8) & 0xff);
dev->write_register(0x15, calib_sensor.exposure.blue & 0xff);
dev->interface->write_register(0x10, (calib_sensor.exposure.red >> 8) & 0xff);
dev->interface->write_register(0x11, calib_sensor.exposure.red & 0xff);
dev->interface->write_register(0x12, (calib_sensor.exposure.green >> 8) & 0xff);
dev->interface->write_register(0x13, calib_sensor.exposure.green & 0xff);
dev->interface->write_register(0x14, (calib_sensor.exposure.blue >> 8) & 0xff);
dev->interface->write_register(0x15, calib_sensor.exposure.blue & 0xff);
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting line reading\n", __func__);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
@ -2910,7 +2910,7 @@ static void ad_fe_offset_calibration(Genesys_Device* dev, const Genesys_Sensor&
/* scan line */
DBG(DBG_info, "%s: starting line reading\n", __func__);
dev->write_registers(regs);
dev->interface->write_registers(regs);
dev->cmd_set->set_fe(dev, calib_sensor, AFE_SET);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, line.data(), total_size);
@ -3050,7 +3050,7 @@ void CommandSetGl841::offset_calibration(Genesys_Device* dev, const Genesys_Sens
bool acceptable = false;
do {
dev->write_registers(regs);
dev->interface->write_registers(regs);
for (j=0; j < channels; j++) {
off[j] = (offh[j]+offl[j])/2;
@ -3167,7 +3167,7 @@ void CommandSetGl841::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->cmd_set->set_fe(dev, calib_sensor, AFE_SET);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
dev->write_registers(regs);
dev->interface->write_registers(regs);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size);
@ -3377,7 +3377,7 @@ void CommandSetGl841::coarse_gain_calibration(Genesys_Device* dev, const Genesys
gl841_init_scan_regs(dev, calib_sensor, &regs, session);
dev->write_registers(regs);
dev->interface->write_registers(regs);
total_size = num_pixels * channels * 2 * lines; /* colors * bytes_per_color * scan lines */
@ -3526,7 +3526,7 @@ void CommandSetGl841::init_regs_for_warmup(Genesys_Device* dev, const Genesys_Se
*total_size = num_pixels * 3 * 2 * 1; /* colors * bytes_per_color * scan lines */
dev->write_registers(*local_reg);
dev->interface->write_registers(*local_reg);
}
@ -3575,14 +3575,14 @@ void CommandSetGl841::init(Genesys_Device* dev) const
dev->settings.color_filter = ColorFilter::RED;
// ASIC reset
dev->write_register(0x0e, 0x01);
dev->write_register(0x0e, 0x00);
dev->interface->write_register(0x0e, 0x01);
dev->interface->write_register(0x0e, 0x00);
/* Set default values for registers */
gl841_init_registers (dev);
// Write initial registers
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
const auto& sensor = sanei_genesys_find_sensor_any(dev);
@ -3641,7 +3641,7 @@ void CommandSetGl841::init(Genesys_Device* dev) const
gl841_init_scan_regs(dev, calib_sensor, &regs, session);
dev->write_registers(regs);
dev->interface->write_registers(regs);
size = num_pixels * 3 * 2 * 1; // colors * bytes_per_color * scan lines
@ -3677,7 +3677,7 @@ void CommandSetGl841::update_hardware_sensors(Genesys_Scanner* s) const
if (s->dev->model->gpio_id == GpioId::CANON_LIDE_35
|| s->dev->model->gpio_id == GpioId::CANON_LIDE_80)
{
val = s->dev->read_register(REG_0x6D);
val = s->dev->interface->read_register(REG_0x6D);
s->buttons[BUTTON_SCAN_SW].write((val & 0x01) == 0);
s->buttons[BUTTON_FILE_SW].write((val & 0x02) == 0);
s->buttons[BUTTON_EMAIL_SW].write((val & 0x04) == 0);
@ -3688,7 +3688,7 @@ void CommandSetGl841::update_hardware_sensors(Genesys_Scanner* s) const
s->dev->model->gpio_id == GpioId::DP665 ||
s->dev->model->gpio_id == GpioId::DP685)
{
val = s->dev->read_register(REG_0x6D);
val = s->dev->interface->read_register(REG_0x6D);
s->buttons[BUTTON_PAGE_LOADED_SW].write((val & 0x01) == 0);
s->buttons[BUTTON_SCAN_SW].write((val & 0x02) == 0);
@ -3774,7 +3774,7 @@ void CommandSetGl841::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
r->value |= 4;
}
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
dev->cmd_set->begin_scan(dev, sensor, &local_reg, true);
@ -3799,7 +3799,7 @@ void CommandSetGl841::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
found = 0;
while (pass < length && !found)
{
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
//now start scan
dev->cmd_set->begin_scan(dev, sensor, &local_reg, true);

202
backend/genesys/gl843.cpp
Wyświetl plik

@ -57,17 +57,17 @@ static void gl843_set_buffer_address(Genesys_Device* dev, uint32_t addr)
{
DBG_HELPER_ARGS(dbg, "setting address to 0x%05x", addr & 0xffff);
dev->write_register(0x5b, ((addr >> 8) & 0xff));
dev->write_register(0x5c, (addr & 0xff));
dev->interface->write_register(0x5b, ((addr >> 8) & 0xff));
dev->interface->write_register(0x5c, (addr & 0xff));
}
static void gl843_set_ram_address(Genesys_Device* dev, uint32_t addr)
{
DBG_HELPER_ARGS(dbg, "setting address to 0x%05x", addr & 0x1fffff);
dev->write_register(0x29, ((addr >> 16) & 0x1f));
dev->write_register(0x2a, ((addr >> 8) & 0xff));
dev->write_register(0x2b, (addr & 0xff));
dev->interface->write_register(0x29, ((addr >> 16) & 0x1f));
dev->interface->write_register(0x2a, ((addr >> 8) & 0xff));
dev->interface->write_register(0x2b, (addr & 0xff));
}
/**
@ -775,7 +775,7 @@ void CommandSetGl843::set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor,
// check analog frontend type
// FIXME: looks like we write to that register with initial data
uint8_t fe_type = dev->read_register(REG_0x04) & REG_0x04_FESET;
uint8_t fe_type = dev->interface->read_register(REG_0x04) & REG_0x04_FESET;
if (fe_type == 2) {
gl843_set_ad_fe(dev);
return;
@ -1328,13 +1328,13 @@ void CommandSetGl843::save_power(Genesys_Device* dev, bool enable) const
// switch KV-SS080 lamp off
if (dev->model->gpio_id == GpioId::KVSS080) {
uint8_t val = dev->read_register(REG_0x6C);
uint8_t val = dev->interface->read_register(REG_0x6C);
if (enable) {
val &= 0xef;
} else {
val |= 0x10;
}
dev->write_register(REG_0x6C, val);
dev->interface->write_register(REG_0x6C, val);
}
}
@ -1347,7 +1347,7 @@ void CommandSetGl843::set_powersaving(Genesys_Device* dev, int delay /* in minut
static void gl843_start_action(Genesys_Device* dev)
{
DBG_HELPER(dbg);
dev->write_register(0x0f, 0x01);
dev->interface->write_register(0x0f, 0x01);
}
static void gl843_stop_action_no_move(Genesys_Device* dev, Genesys_Register_Set* reg)
@ -1356,7 +1356,7 @@ static void gl843_stop_action_no_move(Genesys_Device* dev, Genesys_Register_Set*
uint8_t val = reg->get8(REG_0x01);
val &= ~REG_0x01_SCAN;
reg->set8(REG_0x01, val);
dev->write_register(REG_0x01, val);
dev->interface->write_register(REG_0x01, val);
sanei_genesys_sleep_ms(100);
}
@ -1372,7 +1372,7 @@ static void gl843_stop_action(Genesys_Device* dev)
sanei_genesys_print_status (val);
}
uint8_t val40 = dev->read_register(REG_0x40);
uint8_t val40 = dev->interface->read_register(REG_0x40);
/* only stop action if needed */
if (!(val40 & REG_0x40_DATAENB) && !(val40 & REG_0x40_MOTMFLG))
@ -1385,7 +1385,7 @@ static void gl843_stop_action(Genesys_Device* dev)
val = dev->reg.get8(REG_0x01);
val &= ~REG_0x01_SCAN;
dev->reg.set8(REG_0x01, val);
dev->write_register(REG_0x01, val);
dev->interface->write_register(REG_0x01, val);
sanei_genesys_sleep_ms(100);
@ -1397,7 +1397,7 @@ static void gl843_stop_action(Genesys_Device* dev)
{
sanei_genesys_print_status (val);
}
val40 = dev->read_register(0x40);
val40 = dev->interface->read_register(0x40);
/* if scanner is in command mode, we are done */
if (!(val40 & REG_0x40_DATAENB) && !(val40 & REG_0x40_MOTMFLG)
@ -1417,7 +1417,7 @@ static bool gl843_get_paper_sensor(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val = dev->read_register(REG_0x6D);
uint8_t val = dev->interface->read_register(REG_0x6D);
return (val & 0x1) == 0;
}
@ -1492,87 +1492,87 @@ static void gl843_set_xpa_motor_power(Genesys_Device* dev, bool set)
if (dev->model->model_id == ModelId::CANON_8400F) {
if (set) {
val = dev->read_register(0x6c);
val = dev->interface->read_register(0x6c);
val &= ~(REG_0x6C_GPIO16 | REG_0x6C_GPIO13);
if (dev->session.output_resolution >= 2400) {
val &= ~REG_0x6C_GPIO10;
}
dev->write_register(0x6c, val);
dev->interface->write_register(0x6c, val);
val = dev->read_register(0xa9);
val = dev->interface->read_register(0xa9);
val |= REG_0xA9_GPO30;
val &= ~REG_0xA9_GPO29;
dev->write_register(0xa9, val);
dev->interface->write_register(0xa9, val);
} else {
val = dev->read_register(0x6c);
val = dev->interface->read_register(0x6c);
val |= REG_0x6C_GPIO16 | REG_0x6C_GPIO13;
dev->write_register(0x6c, val);
dev->interface->write_register(0x6c, val);
val = dev->read_register(0xa9);
val = dev->interface->read_register(0xa9);
val &= ~REG_0xA9_GPO30;
val |= REG_0xA9_GPO29;
dev->write_register(0xa9, val);
dev->interface->write_register(0xa9, val);
}
} else if (dev->model->model_id == ModelId::CANON_8600F) {
if (set) {
val = dev->read_register(REG_0x6C);
val = dev->interface->read_register(REG_0x6C);
val &= ~REG_0x6C_GPIO14;
if (dev->session.output_resolution >= 2400) {
val |= REG_0x6C_GPIO10;
}
dev->write_register(REG_0x6C, val);
dev->interface->write_register(REG_0x6C, val);
val = dev->read_register(REG_0xA6);
val = dev->interface->read_register(REG_0xA6);
val |= REG_0xA6_GPIO17;
val &= ~REG_0xA6_GPIO23;
dev->write_register(REG_0xA6, val);
dev->interface->write_register(REG_0xA6, val);
} else {
val = dev->read_register(REG_0x6C);
val = dev->interface->read_register(REG_0x6C);
val |= REG_0x6C_GPIO14;
val &= ~REG_0x6C_GPIO10;
dev->write_register(REG_0x6C, val);
dev->interface->write_register(REG_0x6C, val);
val = dev->read_register(REG_0xA6);
val = dev->interface->read_register(REG_0xA6);
val &= ~REG_0xA6_GPIO17;
val &= ~REG_0xA6_GPIO23;
dev->write_register(REG_0xA6, val);
dev->interface->write_register(REG_0xA6, val);
}
} else if (dev->model->model_id == ModelId::HP_SCANJET_G4050) {
if (set) {
// set MULTFILM et GPOADF
val = dev->read_register(REG_0x6B);
val = dev->interface->read_register(REG_0x6B);
val |=REG_0x6B_MULTFILM|REG_0x6B_GPOADF;
dev->write_register(REG_0x6B, val);
dev->interface->write_register(REG_0x6B, val);
val = dev->read_register(REG_0x6C);
val = dev->interface->read_register(REG_0x6C);
val &= ~REG_0x6C_GPIO15;
dev->write_register(REG_0x6C, val);
dev->interface->write_register(REG_0x6C, val);
/* Motor power ? No move at all without this one */
val = dev->read_register(REG_0xA6);
val = dev->interface->read_register(REG_0xA6);
val |= REG_0xA6_GPIO20;
dev->write_register(REG_0xA6, val);
dev->interface->write_register(REG_0xA6, val);
val = dev->read_register(REG_0xA8);
val = dev->interface->read_register(REG_0xA8);
val &= ~REG_0xA8_GPO27;
dev->write_register(REG_0xA8, val);
dev->interface->write_register(REG_0xA8, val);
val = dev->read_register(REG_0xA9);
val = dev->interface->read_register(REG_0xA9);
val |= REG_0xA9_GPO32|REG_0xA9_GPO31;
dev->write_register(REG_0xA9, val);
dev->interface->write_register(REG_0xA9, val);
} else {
// unset GPOADF
val = dev->read_register(REG_0x6B);
val = dev->interface->read_register(REG_0x6B);
val &= ~REG_0x6B_GPOADF;
dev->write_register(REG_0x6B, val);
dev->interface->write_register(REG_0x6B, val);
val = dev->read_register(REG_0xA8);
val = dev->interface->read_register(REG_0xA8);
val |= REG_0xA8_GPO27;
dev->write_register(REG_0xA8, val);
dev->interface->write_register(REG_0xA8, val);
val = dev->read_register(REG_0xA9);
val = dev->interface->read_register(REG_0xA9);
val &= ~REG_0xA9_GPO31;
dev->write_register(REG_0xA9, val);
dev->interface->write_register(REG_0xA9, val);
}
}
}
@ -1681,21 +1681,21 @@ void CommandSetGl843::begin_scan(Genesys_Device* dev, const Genesys_Sensor& sens
switch(dev->model->gpio_id) {
/* KV case */
case GpioId::KVSS080:
dev->write_register(REG_0xA9, 0x00);
dev->write_register(REG_0xA6, 0xf6);
dev->interface->write_register(REG_0xA9, 0x00);
dev->interface->write_register(REG_0xA6, 0xf6);
// blinking led
dev->write_register(0x7e, 0x04);
dev->interface->write_register(0x7e, 0x04);
break;
case GpioId::G4050:
dev->write_register(REG_0xA7, 0xfe);
dev->write_register(REG_0xA8, 0x3e);
dev->write_register(REG_0xA9, 0x06);
dev->interface->write_register(REG_0xA7, 0xfe);
dev->interface->write_register(REG_0xA8, 0x3e);
dev->interface->write_register(REG_0xA9, 0x06);
if ((reg->get8(0x05) & REG_0x05_DPIHW) == REG_0x05_DPIHW_600) {
dev->write_register(REG_0x6C, 0x20);
dev->write_register(REG_0xA6, 0x44);
dev->interface->write_register(REG_0x6C, 0x20);
dev->interface->write_register(REG_0xA6, 0x44);
} else {
dev->write_register(REG_0x6C, 0x60);
dev->write_register(REG_0xA6, 0x46);
dev->interface->write_register(REG_0x6C, 0x60);
dev->interface->write_register(REG_0xA6, 0x46);
}
if (reg->state.is_xpa_on && reg->state.is_lamp_on) {
@ -1708,7 +1708,7 @@ void CommandSetGl843::begin_scan(Genesys_Device* dev, const Genesys_Sensor& sens
}
// blinking led
dev->write_register(REG_0x7E, 0x01);
dev->interface->write_register(REG_0x7E, 0x01);
break;
case GpioId::CANON_8400F:
case GpioId::CANON_8600F:
@ -1734,17 +1734,17 @@ void CommandSetGl843::begin_scan(Genesys_Device* dev, const Genesys_Sensor& sens
}
// clear scan and feed count
dev->write_register(REG_0x0D, REG_0x0D_CLRLNCNT | REG_0x0D_CLRMCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRLNCNT | REG_0x0D_CLRMCNT);
// enable scan and motor
uint8_t val = dev->read_register(REG_0x01);
uint8_t val = dev->interface->read_register(REG_0x01);
val |= REG_0x01_SCAN;
dev->write_register(REG_0x01, val);
dev->interface->write_register(REG_0x01, val);
if (start_motor) {
dev->write_register(REG_0x0F, 1);
dev->interface->write_register(REG_0x0F, 1);
} else {
dev->write_register(REG_0x0F, 0);
dev->interface->write_register(REG_0x0F, 0);
}
}
@ -1756,7 +1756,7 @@ void CommandSetGl843::end_scan(Genesys_Device* dev, Genesys_Register_Set* reg,
DBG_HELPER_ARGS(dbg, "check_stop = %d", check_stop);
// post scan gpio
dev->write_register(0x7e, 0x00);
dev->interface->write_register(0x7e, 0x00);
// turn off XPA lamp if needed
// BUG: the if condition below probably shouldn't be enabled when XPA is off
@ -1787,7 +1787,7 @@ static void gl843_park_xpa_lamp(Genesys_Device* dev)
local_reg.set24(REG_FEEDL, 0xbdcd);
// clear scan and feed count
dev->write_register(REG_0x0D, REG_0x0D_CLRLNCNT | REG_0x0D_CLRMCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRLNCNT | REG_0x0D_CLRMCNT);
/* set up for reverse and no scan */
r = sanei_genesys_get_address (&local_reg, REG_0x02);
@ -1796,7 +1796,7 @@ static void gl843_park_xpa_lamp(Genesys_Device* dev)
r->value &= ~REG_0x01_SCAN;
// write to scanner and start action
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
gl843_set_xpa_motor_power(dev, true);
try {
gl843_start_action(dev);
@ -1805,7 +1805,7 @@ static void gl843_park_xpa_lamp(Genesys_Device* dev)
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
});
throw;
}
@ -1897,7 +1897,7 @@ void CommandSetGl843::slow_back_home(Genesys_Device* dev, bool wait_until_home)
gl843_init_scan_regs(dev, sensor, &local_reg, session);
// clear scan and feed count
dev->write_register(REG_0x0D, REG_0x0D_CLRLNCNT | REG_0x0D_CLRMCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRLNCNT | REG_0x0D_CLRMCNT);
/* set up for reverse and no scan */
r = sanei_genesys_get_address(&local_reg, REG_0x02);
@ -1905,7 +1905,7 @@ void CommandSetGl843::slow_back_home(Genesys_Device* dev, bool wait_until_home)
r = sanei_genesys_get_address(&local_reg, REG_0x01);
r->value &= ~REG_0x01_SCAN;
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
try {
gl843_start_action(dev);
@ -1914,7 +1914,7 @@ void CommandSetGl843::slow_back_home(Genesys_Device* dev, bool wait_until_home)
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
});
throw;
}
@ -1990,7 +1990,7 @@ void CommandSetGl843::search_start_position(Genesys_Device* dev) const
gl843_init_scan_regs(dev, sensor, &local_reg, session);
// send to scanner
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
dev->cmd_set->begin_scan(dev, sensor, &local_reg, true);
@ -2058,7 +2058,7 @@ void CommandSetGl843::init_regs_for_coarse_calibration(Genesys_Device* dev,
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
sensor.optical_res / sensor.ccd_pixels_per_system_pixel(), dev->settings.xres);
dev->write_registers(regs);
dev->interface->write_registers(regs);
}
/** @brief moves the slider to steps at motor base dpi
@ -2101,15 +2101,15 @@ static void gl843_feed(Genesys_Device* dev, unsigned int steps)
gl843_init_scan_regs(dev, sensor, &local_reg, session);
// clear scan and feed count
dev->write_register(REG_0x0D, REG_0x0D_CLRLNCNT);
dev->write_register(REG_0x0D, REG_0x0D_CLRMCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRLNCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRMCNT);
/* set up for no scan */
r = sanei_genesys_get_address(&local_reg, REG_0x01);
r->value &= ~REG_0x01_SCAN;
// send registers
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
try {
gl843_start_action(dev);
@ -2118,7 +2118,7 @@ static void gl843_feed(Genesys_Device* dev, unsigned int steps)
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
});
throw;
}
@ -2226,7 +2226,7 @@ void CommandSetGl843::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
dev->scanhead_position_in_steps += dev->calib_lines + move;
dev->write_registers(regs);
dev->interface->write_registers(regs);
}
/** @brief set up registers for the actual scan
@ -2387,7 +2387,7 @@ SensorExposure CommandSetGl843::led_calibration(Genesys_Device* dev, const Genes
gl843_init_scan_regs(dev, calib_sensor, &regs, session);
dev->write_registers(regs);
dev->interface->write_registers(regs);
/*
we try to get equal bright leds here:
@ -2413,7 +2413,7 @@ SensorExposure CommandSetGl843::led_calibration(Genesys_Device* dev, const Genes
sanei_genesys_set_exposure(regs, calib_sensor.exposure);
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
@ -2618,7 +2618,7 @@ void CommandSetGl843::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->cmd_set->set_fe(dev, calib_sensor, AFE_SET);
// scan with bottom AFE settings
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
@ -2647,7 +2647,7 @@ void CommandSetGl843::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->cmd_set->set_fe(dev, calib_sensor, AFE_SET);
// scan with top AFE values
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
@ -2682,7 +2682,7 @@ void CommandSetGl843::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->cmd_set->set_fe(dev, calib_sensor, AFE_SET);
// scan with no move
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
second_line = read_unshuffled_image_from_scanner(dev, session,
@ -2824,7 +2824,7 @@ void CommandSetGl843::coarse_gain_calibration(Genesys_Device* dev, const Genesys
sanei_genesys_set_motor_power(regs, false);
dev->write_registers(regs);
dev->interface->write_registers(regs);
dev->cmd_set->set_fe(dev, calib_sensor, AFE_SET);
dev->cmd_set->begin_scan(dev, calib_sensor, &regs, true);
@ -2928,7 +2928,7 @@ void CommandSetGl843::init_regs_for_warmup(Genesys_Device* dev, const Genesys_Se
gl843_init_scan_regs(dev, calib_sensor, reg, session);
sanei_genesys_set_motor_power(*reg, false);
dev->write_registers(*reg);
dev->interface->write_registers(*reg);
}
/**
@ -2943,7 +2943,7 @@ static void gl843_init_gpio(Genesys_Device* dev)
DBG_HELPER(dbg);
apply_registers_ordered(dev->gpo.regs, { 0x6e, 0x6f }, [&](const GenesysRegisterSetting& reg)
{
dev->write_register(reg.address, reg.value);
dev->interface->write_register(reg.address, reg.value);
});
}
@ -2957,8 +2957,8 @@ void CommandSetGl843::asic_boot(Genesys_Device* dev, bool cold) const
uint8_t val;
if (cold) {
dev->write_register(0x0e, 0x01);
dev->write_register(0x0e, 0x00);
dev->interface->write_register(0x0e, 0x01);
dev->interface->write_register(0x0e, 0x00);
}
if(dev->usb_mode == 1)
@ -2972,9 +2972,9 @@ void CommandSetGl843::asic_boot(Genesys_Device* dev, bool cold) const
dev->interface->write_0x8c(0x0f, val);
// test CHKVER
val = dev->read_register(REG_0x40);
val = dev->interface->read_register(REG_0x40);
if (val & REG_0x40_CHKVER) {
val = dev->read_register(0x00);
val = dev->interface->read_register(0x00);
DBG(DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __func__, val);
}
@ -2983,18 +2983,18 @@ void CommandSetGl843::asic_boot(Genesys_Device* dev, bool cold) const
if (dev->model->model_id == ModelId::CANON_8600F) {
// turns on vref control for maximum current of the motor driver
dev->write_register(REG_0x6B, 0x72);
dev->interface->write_register(REG_0x6B, 0x72);
} else {
dev->write_register(REG_0x6B, 0x02);
dev->interface->write_register(REG_0x6B, 0x02);
}
// Write initial registers
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
// Enable DRAM by setting a rising edge on bit 3 of reg 0x0b
val = dev->reg.find_reg(0x0b).value & REG_0x0B_DRAMSEL;
val = (val | REG_0x0B_ENBDRAM);
dev->write_register(REG_0x0B, val);
dev->interface->write_register(REG_0x0B, val);
dev->reg.find_reg(0x0b).value = val;
if (dev->model->model_id == ModelId::CANON_8400F) {
@ -3031,7 +3031,7 @@ void CommandSetGl843::asic_boot(Genesys_Device* dev, bool cold) const
val = (dev->reg.find_reg(0x0b).value & ~REG_0x0B_CLKSET) | clock_freq;
dev->write_register(REG_0x0B, val);
dev->interface->write_register(REG_0x0B, val);
dev->reg.find_reg(0x0b).value = val;
/* prevent further writings by bulk write register */
@ -3040,14 +3040,14 @@ void CommandSetGl843::asic_boot(Genesys_Device* dev, bool cold) const
if (dev->model->model_id != ModelId::CANON_8600F) {
// set up end access
// FIXME: this is overwritten in gl843_init_gpio
dev->write_register(REG_0xA7, 0x04);
dev->write_register(REG_0xA9, 0x00);
dev->interface->write_register(REG_0xA7, 0x04);
dev->interface->write_register(REG_0xA9, 0x00);
}
// set RAM read address
dev->write_register(REG_0x29, 0x00);
dev->write_register(REG_0x2A, 0x00);
dev->write_register(REG_0x2B, 0x00);
dev->interface->write_register(REG_0x29, 0x00);
dev->interface->write_register(REG_0x2A, 0x00);
dev->interface->write_register(REG_0x2B, 0x00);
// setup gpio
gl843_init_gpio(dev);
@ -3075,7 +3075,7 @@ void CommandSetGl843::update_hardware_sensors(Genesys_Scanner* s) const
any of them.
*/
uint8_t val = s->dev->read_register(REG_0x6D);
uint8_t val = s->dev->interface->read_register(REG_0x6D);
switch (s->dev->model->gpio_id)
{
@ -3179,7 +3179,7 @@ void CommandSetGl843::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
r->value |= REG_0x02_MTRREV;
}
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
dev->cmd_set->begin_scan(dev, calib_sensor, &local_reg, true);
@ -3204,7 +3204,7 @@ void CommandSetGl843::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
found = 0;
while (pass < 20 && !found)
{
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
// now start scan
dev->cmd_set->begin_scan(dev, calib_sensor, &local_reg, true);

118
backend/genesys/gl846.cpp
Wyświetl plik

@ -338,9 +338,9 @@ static void gl846_homsnr_gpio(Genesys_Device* dev)
{
DBG_HELPER(dbg);
uint8_t val = dev->read_register(REG_0x6C);
uint8_t val = dev->interface->read_register(REG_0x6C);
val |= 0x41;
dev->write_register(REG_0x6C, val);
dev->interface->write_register(REG_0x6C, val);
}
// Set values of analog frontend
@ -504,7 +504,7 @@ static void gl846_init_motor_regs_scan(Genesys_Device* dev,
/* hi res motor speed GPIO */
/*
uint8_t effective = dev->read_register(REG_0x6C);
uint8_t effective = dev->interface->read_register(REG_0x6C);
*/
/* if quarter step, bipolar Vref2 */
@ -524,14 +524,14 @@ static void gl846_init_motor_regs_scan(Genesys_Device* dev,
{
val = effective;
}
dev->write_register(REG_0x6C, val);
dev->interface->write_register(REG_0x6C, val);
*/
/* effective scan */
/*
effective = dev->read_register(REG_0x6C);
effective = dev->interface->read_register(REG_0x6C);
val = effective | REG_0x6C_GPIO10;
dev->write_register(REG_0x6C, val);
dev->interface->write_register(REG_0x6C, val);
*/
if(dev->model->gpio_id == GpioId::IMG101) {
@ -542,7 +542,7 @@ static void gl846_init_motor_regs_scan(Genesys_Device* dev,
{
val=0;
}
dev->write_register(REG_0x7E, val);
dev->interface->write_register(REG_0x7E, val);
}
min_restep=scan_steps/2-1;
@ -868,7 +868,7 @@ void CommandSetGl846::set_powersaving(Genesys_Device* dev, int delay /* in minut
static void gl846_start_action(Genesys_Device* dev)
{
DBG_HELPER(dbg);
dev->write_register(0x0f, 0x01);
dev->interface->write_register(0x0f, 0x01);
}
static void gl846_stop_action(Genesys_Device* dev)
@ -885,7 +885,7 @@ static void gl846_stop_action(Genesys_Device* dev)
sanei_genesys_print_status (val);
}
uint8_t val40 = dev->read_register(REG_0x40);
uint8_t val40 = dev->interface->read_register(REG_0x40);
/* only stop action if needed */
if (!(val40 & REG_0x40_DATAENB) && !(val40 & REG_0x40_MOTMFLG)) {
@ -897,7 +897,7 @@ static void gl846_stop_action(Genesys_Device* dev)
val = dev->reg.get8(REG_0x01);
val &= ~REG_0x01_SCAN;
dev->reg.set8(REG_0x01, val);
dev->write_register(REG_0x01, val);
dev->interface->write_register(REG_0x01, val);
sanei_genesys_sleep_ms(100);
loop = 10;
@ -908,7 +908,7 @@ static void gl846_stop_action(Genesys_Device* dev)
{
sanei_genesys_print_status (val);
}
val40 = dev->read_register(REG_0x40);
val40 = dev->interface->read_register(REG_0x40);
/* if scanner is in command mode, we are done */
if (!(val40 & REG_0x40_DATAENB) && !(val40 & REG_0x40_MOTMFLG) &&
@ -935,25 +935,25 @@ void CommandSetGl846::begin_scan(Genesys_Device* dev, const Genesys_Sensor& sens
/* XXX STEF XXX SCAN GPIO */
/*
val = dev->read_register(REG_0x6C);
dev->write_register(REG_0x6C, val);
val = dev->interface->read_register(REG_0x6C);
dev->interface->write_register(REG_0x6C, val);
*/
val = REG_0x0D_CLRLNCNT;
dev->write_register(REG_0x0D, val);
dev->interface->write_register(REG_0x0D, val);
val = REG_0x0D_CLRMCNT;
dev->write_register(REG_0x0D, val);
dev->interface->write_register(REG_0x0D, val);
val = dev->read_register(REG_0x01);
val = dev->interface->read_register(REG_0x01);
val |= REG_0x01_SCAN;
dev->write_register(REG_0x01, val);
dev->interface->write_register(REG_0x01, val);
r = sanei_genesys_get_address (reg, REG_0x01);
r->value = val;
if (start_motor) {
dev->write_register(REG_0x0F, 1);
dev->interface->write_register(REG_0x0F, 1);
} else {
dev->write_register(REG_0x0F, 0);
dev->interface->write_register(REG_0x0F, 0);
}
}
@ -1040,13 +1040,13 @@ void CommandSetGl846::slow_back_home(Genesys_Device* dev, bool wait_until_home)
dev->settings.scan_mode=scan_mode;
// clear scan and feed count
dev->write_register(REG_0x0D, REG_0x0D_CLRLNCNT | REG_0x0D_CLRMCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRLNCNT | REG_0x0D_CLRMCNT);
/* set up for reverse */
r = sanei_genesys_get_address(&local_reg, REG_0x02);
r->value |= REG_0x02_MTRREV;
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
try {
gl846_start_action(dev);
@ -1057,7 +1057,7 @@ void CommandSetGl846::slow_back_home(Genesys_Device* dev, bool wait_until_home)
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
});
throw;
}
@ -1131,7 +1131,7 @@ void CommandSetGl846::search_start_position(Genesys_Device* dev) const
gl846_init_scan_regs(dev, sensor, &local_reg, session);
// send to scanner
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
size = pixels * dev->model->search_lines;
@ -1195,7 +1195,7 @@ void CommandSetGl846::init_regs_for_coarse_calibration(Genesys_Device* dev,
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
sensor.optical_res / sensor.ccd_pixels_per_system_pixel(), dev->settings.xres);
dev->write_registers(regs);
dev->interface->write_registers(regs);
}
/** @brief moves the slider to steps at motor base dpi
@ -1240,15 +1240,15 @@ static void gl846_feed(Genesys_Device* dev, unsigned int steps)
local_reg.set24(REG_EXPB, 0);
// clear scan and feed count
dev->write_register(REG_0x0D, REG_0x0D_CLRLNCNT);
dev->write_register(REG_0x0D, REG_0x0D_CLRMCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRLNCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRMCNT);
/* set up for no scan */
r = sanei_genesys_get_address(&local_reg, REG_0x01);
r->value &= ~REG_0x01_SCAN;
// send registers
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
try {
gl846_start_action(dev);
@ -1259,7 +1259,7 @@ static void gl846_feed(Genesys_Device* dev, unsigned int steps)
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
});
throw;
}
@ -1323,7 +1323,7 @@ void CommandSetGl846::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
gl846_init_scan_regs(dev, sensor, &regs, session);
dev->write_registers(regs);
dev->interface->write_registers(regs);
/* we use GENESYS_FLAG_SHADING_REPARK */
dev->scanhead_position_in_steps = 0;
@ -1474,7 +1474,7 @@ void CommandSetGl846::send_shading_data(Genesys_Device* dev, const Genesys_Senso
ptr+=4;
}
val = dev->read_register(0xd0+i);
val = dev->interface->read_register(0xd0+i);
addr = val * 8192 + 0x10000000;
dev->interface->write_ahb(addr, pixels, buffer.data());
}
@ -1565,7 +1565,7 @@ SensorExposure CommandSetGl846::led_calibration(Genesys_Device* dev, const Genes
regs.set16(REG_EXPB, exp[2]);
// write registers and scan data
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting line reading\n", __func__);
begin_scan(dev, sensor, &regs, true);
@ -1658,17 +1658,17 @@ static void gl846_init_gpio(Genesys_Device* dev)
static_cast<unsigned>(dev->model->sensor_id));
}
dev->write_register(REG_0xA7, gpios[idx].ra7);
dev->write_register(REG_0xA6, gpios[idx].ra6);
dev->interface->write_register(REG_0xA7, gpios[idx].ra7);
dev->interface->write_register(REG_0xA6, gpios[idx].ra6);
dev->write_register(REG_0x6B, gpios[idx].r6b);
dev->write_register(REG_0x6C, gpios[idx].r6c);
dev->write_register(REG_0x6D, gpios[idx].r6d);
dev->write_register(REG_0x6E, gpios[idx].r6e);
dev->write_register(REG_0x6F, gpios[idx].r6f);
dev->interface->write_register(REG_0x6B, gpios[idx].r6b);
dev->interface->write_register(REG_0x6C, gpios[idx].r6c);
dev->interface->write_register(REG_0x6D, gpios[idx].r6d);
dev->interface->write_register(REG_0x6E, gpios[idx].r6e);
dev->interface->write_register(REG_0x6F, gpios[idx].r6f);
dev->write_register(REG_0xA8, gpios[idx].ra8);
dev->write_register(REG_0xA9, gpios[idx].ra9);
dev->interface->write_register(REG_0xA8, gpios[idx].ra8);
dev->interface->write_register(REG_0xA9, gpios[idx].ra9);
}
/**
@ -1692,7 +1692,7 @@ static void gl846_init_memory_layout(Genesys_Device* dev)
/* CLKSET and DRAMSEL */
val = layouts[idx].dramsel;
dev->write_register(REG_0x0B, val);
dev->interface->write_register(REG_0x0B, val);
dev->reg.find_reg(0x0b).value = val;
/* prevent further writings by bulk write register */
@ -1701,7 +1701,7 @@ static void gl846_init_memory_layout(Genesys_Device* dev)
/* setup base address for shading and scanned data. */
for(i=0;i<10;i++)
{
dev->write_register(0xe0+i, layouts[idx].rx[i]);
dev->interface->write_register(0xe0+i, layouts[idx].rx[i]);
}
}
@ -1715,8 +1715,8 @@ void CommandSetGl846::asic_boot(Genesys_Device* dev, bool cold) const
// reset ASIC if cold boot
if (cold) {
dev->write_register(0x0e, 0x01);
dev->write_register(0x0e, 0x00);
dev->interface->write_register(0x0e, 0x01);
dev->interface->write_register(0x0e, 0x00);
}
if(dev->usb_mode == 1)
@ -1730,9 +1730,9 @@ void CommandSetGl846::asic_boot(Genesys_Device* dev, bool cold) const
dev->interface->write_0x8c(0x0f, val);
// test CHKVER
val = dev->read_register(REG_0x40);
val = dev->interface->read_register(REG_0x40);
if (val & REG_0x40_CHKVER) {
val = dev->read_register(0x00);
val = dev->interface->read_register(0x00);
DBG(DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __func__, val);
}
@ -1740,19 +1740,19 @@ void CommandSetGl846::asic_boot(Genesys_Device* dev, bool cold) const
gl846_init_registers (dev);
// Write initial registers
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
/* Enable DRAM by setting a rising edge on bit 3 of reg 0x0b */
val = dev->reg.find_reg(0x0b).value & REG_0x0B_DRAMSEL;
val = (val | REG_0x0B_ENBDRAM);
dev->write_register(REG_0x0B, val);
dev->interface->write_register(REG_0x0B, val);
dev->reg.find_reg(0x0b).value = val;
/* CIS_LINE */
if (dev->model->is_cis)
{
SETREG(0x08, REG_0x08_CIS_LINE);
dev->write_register(0x08, dev->reg.find_reg(0x08).value);
dev->interface->write_register(0x08, dev->reg.find_reg(0x08).value);
}
// set up clocks
@ -1766,7 +1766,7 @@ void CommandSetGl846::asic_boot(Genesys_Device* dev, bool cold) const
gl846_init_memory_layout(dev);
SETREG (0xf8, 0x05);
dev->write_register(0xf8, dev->reg.find_reg(0xf8).value);
dev->interface->write_register(0xf8, dev->reg.find_reg(0xf8).value);
}
/**
@ -1797,7 +1797,7 @@ void CommandSetGl846::update_hardware_sensors(Genesys_Scanner* s) const
email=0x04;
copy=0x08;
}
val = s->dev->read_register(REG_0x6D);
val = s->dev->interface->read_register(REG_0x6D);
s->buttons[BUTTON_SCAN_SW].write((val & scan) == 0);
s->buttons[BUTTON_FILE_SW].write((val & file) == 0);
@ -1870,7 +1870,7 @@ void CommandSetGl846::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
r->value |= REG_0x02_MTRREV;
}
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
begin_scan(dev, sensor, &local_reg, true);
@ -1894,7 +1894,7 @@ void CommandSetGl846::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
found = 0;
while (pass < 20 && !found)
{
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
// now start scan
begin_scan(dev, sensor, &local_reg, true);
@ -2049,7 +2049,7 @@ void CommandSetGl846::offset_calibration(Genesys_Device* dev, const Genesys_Sens
int top, bottom, black_pixels, pixels;
// no gain nor offset for AKM AFE
uint8_t reg04 = dev->read_register(REG_0x04);
uint8_t reg04 = dev->interface->read_register(REG_0x04);
if ((reg04 & REG_0x04_FESET) == 0x02) {
return;
}
@ -2101,7 +2101,7 @@ void CommandSetGl846::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->frontend.set_offset(2, bottom);
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size);
@ -2122,7 +2122,7 @@ void CommandSetGl846::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->frontend.set_offset(1, top);
dev->frontend.set_offset(2, top);
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size);
@ -2142,7 +2142,7 @@ void CommandSetGl846::offset_calibration(Genesys_Device* dev, const Genesys_Sens
// scan with no move
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size);
@ -2190,7 +2190,7 @@ void CommandSetGl846::coarse_gain_calibration(Genesys_Device* dev, const Genesys
DBG(DBG_proc, "%s: dpi = %d\n", __func__, dpi);
// no gain nor offset for AKM AFE
uint8_t reg04 = dev->read_register(REG_0x04);
uint8_t reg04 = dev->interface->read_register(REG_0x04);
if ((reg04 & REG_0x04_FESET) == 0x02) {
return;
}
@ -2237,7 +2237,7 @@ void CommandSetGl846::coarse_gain_calibration(Genesys_Device* dev, const Genesys
sanei_genesys_set_motor_power(regs, false);
dev->write_registers(regs);
dev->interface->write_registers(regs);
total_size = pixels * channels * (16 / session.params.depth) * lines;

196
backend/genesys/gl847.cpp
Wyświetl plik

@ -264,10 +264,10 @@ gl847_init_registers (Genesys_Device * dev)
/* we write to these registers only once */
val=0;
dev->write_register(REG_0x7E, val);
dev->write_register(REG_0x9E, val);
dev->write_register(REG_0x9F, val);
dev->write_register(REG_0xAB, val);
dev->interface->write_register(REG_0x7E, val);
dev->interface->write_register(REG_0x9E, val);
dev->interface->write_register(REG_0x9F, val);
dev->interface->write_register(REG_0xAB, val);
}
const auto& sensor = sanei_genesys_find_sensor_any(dev);
@ -365,13 +365,13 @@ static void gl847_homsnr_gpio(Genesys_Device* dev)
uint8_t val;
if (dev->model->gpio_id == GpioId::CANON_LIDE_700F) {
val = dev->read_register(REG_0x6C);
val = dev->interface->read_register(REG_0x6C);
val &= ~REG_0x6C_GPIO10;
dev->write_register(REG_0x6C, val);
dev->interface->write_register(REG_0x6C, val);
} else {
val = dev->read_register(REG_0x6C);
val = dev->interface->read_register(REG_0x6C);
val |= REG_0x6C_GPIO10;
dev->write_register(REG_0x6C, val);
dev->interface->write_register(REG_0x6C, val);
}
}
@ -384,7 +384,7 @@ void CommandSetGl847::set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor,
(void) sensor;
uint8_t val = dev->read_register(REG_0x04);
uint8_t val = dev->interface->read_register(REG_0x04);
uint8_t frontend_type = val & REG_0x04_FESET;
// route to AD devices
@ -536,7 +536,7 @@ static void gl847_init_motor_regs_scan(Genesys_Device* dev,
tgtime = 1<<(r->value & REG_0x1C_TGTIME);
// hi res motor speed GPIO
uint8_t effective = dev->read_register(REG_0x6C);
uint8_t effective = dev->interface->read_register(REG_0x6C);
// if quarter step, bipolar Vref2
@ -547,12 +547,12 @@ static void gl847_init_motor_regs_scan(Genesys_Device* dev,
} else {
val = effective;
}
dev->write_register(REG_0x6C, val);
dev->interface->write_register(REG_0x6C, val);
// effective scan
effective = dev->read_register(REG_0x6C);
effective = dev->interface->read_register(REG_0x6C);
val = effective | REG_0x6C_GPIO10;
dev->write_register(REG_0x6C, val);
dev->interface->write_register(REG_0x6C, val);
min_restep=scan_steps/2-1;
if (min_restep < 1) {
@ -873,7 +873,7 @@ void CommandSetGl847::set_powersaving(Genesys_Device* dev, int delay /* in minut
static void gl847_start_action(Genesys_Device* dev)
{
DBG_HELPER(dbg);
dev->write_register(0x0f, 0x01);
dev->interface->write_register(0x0f, 0x01);
}
static void gl847_stop_action(Genesys_Device* dev)
@ -890,7 +890,7 @@ static void gl847_stop_action(Genesys_Device* dev)
sanei_genesys_print_status (val);
}
uint8_t val40 = dev->read_register(REG_0x40);
uint8_t val40 = dev->interface->read_register(REG_0x40);
/* only stop action if needed */
if (!(val40 & REG_0x40_DATAENB) && !(val40 & REG_0x40_MOTMFLG)) {
@ -902,7 +902,7 @@ static void gl847_stop_action(Genesys_Device* dev)
val = dev->reg.get8(REG_0x01);
val &= ~REG_0x01_SCAN;
dev->reg.set8(REG_0x01, val);
dev->write_register(REG_0x01, val);
dev->interface->write_register(REG_0x01, val);
sanei_genesys_sleep_ms(100);
@ -914,7 +914,7 @@ static void gl847_stop_action(Genesys_Device* dev)
{
sanei_genesys_print_status (val);
}
val40 = dev->read_register(REG_0x40);
val40 = dev->interface->read_register(REG_0x40);
/* if scanner is in command mode, we are done */
if (!(val40 & REG_0x40_DATAENB) && !(val40 & REG_0x40_MOTMFLG) &&
@ -941,26 +941,26 @@ void CommandSetGl847::begin_scan(Genesys_Device* dev, const Genesys_Sensor& sens
// clear GPIO 10
if (dev->model->gpio_id != GpioId::CANON_LIDE_700F) {
val = dev->read_register(REG_0x6C);
val = dev->interface->read_register(REG_0x6C);
val &= ~REG_0x6C_GPIO10;
dev->write_register(REG_0x6C, val);
dev->interface->write_register(REG_0x6C, val);
}
val = REG_0x0D_CLRLNCNT;
dev->write_register(REG_0x0D, val);
dev->interface->write_register(REG_0x0D, val);
val = REG_0x0D_CLRMCNT;
dev->write_register(REG_0x0D, val);
dev->interface->write_register(REG_0x0D, val);
val = dev->read_register(REG_0x01);
val = dev->interface->read_register(REG_0x01);
val |= REG_0x01_SCAN;
dev->write_register(REG_0x01, val);
dev->interface->write_register(REG_0x01, val);
r = sanei_genesys_get_address (reg, REG_0x01);
r->value = val;
if (start_motor) {
dev->write_register(REG_0x0F, 1);
dev->interface->write_register(REG_0x0F, 1);
} else {
dev->write_register(REG_0x0F, 0);
dev->interface->write_register(REG_0x0F, 0);
}
}
@ -989,24 +989,24 @@ static void gl847_rewind(Genesys_Device* dev)
// set motor reverse
uint8_t byte = dev->read_register(0x02);
uint8_t byte = dev->interface->read_register(0x02);
byte |= 0x04;
dev->write_register(0x02, byte);
dev->interface->write_register(0x02, byte);
// and start scan, then wait completion
gl847_begin_scan(dev, dev->reg, true);
do
{
sanei_genesys_sleep_ms(100);
byte = dev->read_register(REG_0x40);
byte = dev->interface->read_register(REG_0x40);
} while (byte & REG_0x40_MOTMFLG);
gl847_end_scan(dev, dev->reg, true);
// restore direction
byte = dev->read_register(0x02);
byte = dev->interface->read_register(0x02);
byte &= 0xfb;
dev->write_register(0x02, byte);
dev->interface->write_register(0x02, byte);
}
#endif
@ -1085,13 +1085,13 @@ void CommandSetGl847::slow_back_home(Genesys_Device* dev, bool wait_until_home)
dev->settings.scan_mode = scan_mode;
// clear scan and feed count
dev->write_register(REG_0x0D, REG_0x0D_CLRLNCNT | REG_0x0D_CLRMCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRLNCNT | REG_0x0D_CLRMCNT);
/* set up for reverse */
r = sanei_genesys_get_address (&local_reg, REG_0x02);
r->value |= REG_0x02_MTRREV;
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
try {
gl847_start_action(dev);
@ -1100,7 +1100,7 @@ void CommandSetGl847::slow_back_home(Genesys_Device* dev, bool wait_until_home)
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
});
throw;
}
@ -1174,7 +1174,7 @@ void CommandSetGl847::search_start_position(Genesys_Device* dev) const
gl847_init_scan_regs(dev, sensor, &local_reg, session);
// send to scanner
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
size = pixels * dev->model->search_lines;
@ -1238,7 +1238,7 @@ void CommandSetGl847::init_regs_for_coarse_calibration(Genesys_Device* dev,
DBG(DBG_info, "%s: optical sensor res: %d dpi, actual res: %d\n", __func__,
sensor.optical_res / sensor.ccd_pixels_per_system_pixel(), dev->settings.xres);
dev->write_registers(regs);
dev->interface->write_registers(regs);
}
/** @brief moves the slider to steps at motor base dpi
@ -1283,15 +1283,15 @@ static void gl847_feed(Genesys_Device* dev, unsigned int steps)
local_reg.set24(REG_EXPB,0);
// clear scan and feed count
dev->write_register(REG_0x0D, REG_0x0D_CLRLNCNT);
dev->write_register(REG_0x0D, REG_0x0D_CLRMCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRLNCNT);
dev->interface->write_register(REG_0x0D, REG_0x0D_CLRMCNT);
/* set up for no scan */
r = sanei_genesys_get_address(&local_reg, REG_0x01);
r->value &= ~REG_0x01_SCAN;
// send registers
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
try {
gl847_start_action(dev);
@ -1300,7 +1300,7 @@ static void gl847_feed(Genesys_Device* dev, unsigned int steps)
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
});
throw;
}
@ -1356,7 +1356,7 @@ void CommandSetGl847::init_regs_for_shading(Genesys_Device* dev, const Genesys_S
gl847_init_scan_regs(dev, sensor, &regs, session);
dev->write_registers(regs);
dev->interface->write_registers(regs);
/* we use GENESYS_FLAG_SHADING_REPARK */
dev->scanhead_position_in_steps = 0;
@ -1506,7 +1506,7 @@ void CommandSetGl847::send_shading_data(Genesys_Device* dev, const Genesys_Senso
ptr+=4;
}
val = dev->read_register(0xd0+i);
val = dev->interface->read_register(0xd0+i);
addr = val * 8192 + 0x10000000;
dev->interface->write_ahb(addr, pixels, buffer.data());
}
@ -1598,7 +1598,7 @@ SensorExposure CommandSetGl847::led_calibration(Genesys_Device* dev, const Genes
regs.set16(REG_EXPB,exp[2]);
// write registers and scan data
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting line reading\n", __func__);
begin_scan(dev, sensor, &regs, true);
@ -1684,20 +1684,20 @@ static void gl847_init_gpio(Genesys_Device* dev)
static_cast<unsigned>(dev->model->sensor_id));
}
dev->write_register(REG_0xA7, gpios[idx].ra7);
dev->write_register(REG_0xA6, gpios[idx].ra6);
dev->interface->write_register(REG_0xA7, gpios[idx].ra7);
dev->interface->write_register(REG_0xA6, gpios[idx].ra6);
dev->write_register(REG_0x6E, gpios[idx].r6e);
dev->write_register(REG_0x6C, 0x00);
dev->interface->write_register(REG_0x6E, gpios[idx].r6e);
dev->interface->write_register(REG_0x6C, 0x00);
dev->write_register(REG_0x6B, gpios[idx].r6b);
dev->write_register(REG_0x6C, gpios[idx].r6c);
dev->write_register(REG_0x6D, gpios[idx].r6d);
dev->write_register(REG_0x6E, gpios[idx].r6e);
dev->write_register(REG_0x6F, gpios[idx].r6f);
dev->interface->write_register(REG_0x6B, gpios[idx].r6b);
dev->interface->write_register(REG_0x6C, gpios[idx].r6c);
dev->interface->write_register(REG_0x6D, gpios[idx].r6d);
dev->interface->write_register(REG_0x6E, gpios[idx].r6e);
dev->interface->write_register(REG_0x6F, gpios[idx].r6f);
dev->write_register(REG_0xA8, gpios[idx].ra8);
dev->write_register(REG_0xA9, gpios[idx].ra9);
dev->interface->write_register(REG_0xA8, gpios[idx].ra8);
dev->interface->write_register(REG_0xA9, gpios[idx].ra9);
}
/**
@ -1726,7 +1726,7 @@ static void gl847_init_memory_layout(Genesys_Device* dev)
/* CLKSET nd DRAMSEL */
val = layouts[idx].dramsel;
dev->write_register(REG_0x0B, val);
dev->interface->write_register(REG_0x0B, val);
dev->reg.find_reg(0x0b).value = val;
/* prevent further writings by bulk write register */
@ -1735,48 +1735,48 @@ static void gl847_init_memory_layout(Genesys_Device* dev)
/* setup base address for shading data. */
/* values must be multiplied by 8192=0x4000 to give address on AHB */
/* R-Channel shading bank0 address setting for CIS */
dev->write_register(0xd0, layouts[idx].rd0);
dev->interface->write_register(0xd0, layouts[idx].rd0);
/* G-Channel shading bank0 address setting for CIS */
dev->write_register(0xd1, layouts[idx].rd1);
dev->interface->write_register(0xd1, layouts[idx].rd1);
/* B-Channel shading bank0 address setting for CIS */
dev->write_register(0xd2, layouts[idx].rd2);
dev->interface->write_register(0xd2, layouts[idx].rd2);
/* setup base address for scanned data. */
/* values must be multiplied by 1024*2=0x0800 to give address on AHB */
/* R-Channel ODD image buffer 0x0124->0x92000 */
/* size for each buffer is 0x16d*1k word */
dev->write_register(0xe0, layouts[idx].re0);
dev->write_register(0xe1, layouts[idx].re1);
dev->interface->write_register(0xe0, layouts[idx].re0);
dev->interface->write_register(0xe1, layouts[idx].re1);
/* R-Channel ODD image buffer end-address 0x0291->0x148800 => size=0xB6800*/
dev->write_register(0xe2, layouts[idx].re2);
dev->write_register(0xe3, layouts[idx].re3);
dev->interface->write_register(0xe2, layouts[idx].re2);
dev->interface->write_register(0xe3, layouts[idx].re3);
/* R-Channel EVEN image buffer 0x0292 */
dev->write_register(0xe4, layouts[idx].re4);
dev->write_register(0xe5, layouts[idx].re5);
dev->interface->write_register(0xe4, layouts[idx].re4);
dev->interface->write_register(0xe5, layouts[idx].re5);
/* R-Channel EVEN image buffer end-address 0x03ff*/
dev->write_register(0xe6, layouts[idx].re6);
dev->write_register(0xe7, layouts[idx].re7);
dev->interface->write_register(0xe6, layouts[idx].re6);
dev->interface->write_register(0xe7, layouts[idx].re7);
/* same for green, since CIS, same addresses */
dev->write_register(0xe8, layouts[idx].re0);
dev->write_register(0xe9, layouts[idx].re1);
dev->write_register(0xea, layouts[idx].re2);
dev->write_register(0xeb, layouts[idx].re3);
dev->write_register(0xec, layouts[idx].re4);
dev->write_register(0xed, layouts[idx].re5);
dev->write_register(0xee, layouts[idx].re6);
dev->write_register(0xef, layouts[idx].re7);
dev->interface->write_register(0xe8, layouts[idx].re0);
dev->interface->write_register(0xe9, layouts[idx].re1);
dev->interface->write_register(0xea, layouts[idx].re2);
dev->interface->write_register(0xeb, layouts[idx].re3);
dev->interface->write_register(0xec, layouts[idx].re4);
dev->interface->write_register(0xed, layouts[idx].re5);
dev->interface->write_register(0xee, layouts[idx].re6);
dev->interface->write_register(0xef, layouts[idx].re7);
/* same for blue, since CIS, same addresses */
dev->write_register(0xf0, layouts[idx].re0);
dev->write_register(0xf1, layouts[idx].re1);
dev->write_register(0xf2, layouts[idx].re2);
dev->write_register(0xf3, layouts[idx].re3);
dev->write_register(0xf4, layouts[idx].re4);
dev->write_register(0xf5, layouts[idx].re5);
dev->write_register(0xf6, layouts[idx].re6);
dev->write_register(0xf7, layouts[idx].re7);
dev->interface->write_register(0xf0, layouts[idx].re0);
dev->interface->write_register(0xf1, layouts[idx].re1);
dev->interface->write_register(0xf2, layouts[idx].re2);
dev->interface->write_register(0xf3, layouts[idx].re3);
dev->interface->write_register(0xf4, layouts[idx].re4);
dev->interface->write_register(0xf5, layouts[idx].re5);
dev->interface->write_register(0xf6, layouts[idx].re6);
dev->interface->write_register(0xf7, layouts[idx].re7);
}
/* *
@ -1788,14 +1788,14 @@ void CommandSetGl847::asic_boot(Genesys_Device* dev, bool cold) const
// reset ASIC if cold boot
if (cold) {
dev->write_register(0x0e, 0x01);
dev->write_register(0x0e, 0x00);
dev->interface->write_register(0x0e, 0x01);
dev->interface->write_register(0x0e, 0x00);
}
// test CHKVER
uint8_t val = dev->read_register(REG_0x40);
uint8_t val = dev->interface->read_register(REG_0x40);
if (val & REG_0x40_CHKVER) {
val = dev->read_register(0x00);
val = dev->interface->read_register(0x00);
DBG(DBG_info, "%s: reported version for genesys chip is 0x%02x\n", __func__, val);
}
@ -1803,17 +1803,17 @@ void CommandSetGl847::asic_boot(Genesys_Device* dev, bool cold) const
gl847_init_registers (dev);
// Write initial registers
dev->write_registers(dev->reg);
dev->interface->write_registers(dev->reg);
/* Enable DRAM by setting a rising edge on bit 3 of reg 0x0b */
val = dev->reg.find_reg(0x0b).value & REG_0x0B_DRAMSEL;
val = (val | REG_0x0B_ENBDRAM);
dev->write_register(REG_0x0B, val);
dev->interface->write_register(REG_0x0B, val);
dev->reg.find_reg(0x0b).value = val;
/* CIS_LINE */
SETREG(0x08, REG_0x08_CIS_LINE);
dev->write_register(0x08, dev->reg.find_reg(0x08).value);
dev->interface->write_register(0x08, dev->reg.find_reg(0x08).value);
// set up end access
dev->interface->write_0x8c(0x10, 0x0b);
@ -1826,7 +1826,7 @@ void CommandSetGl847::asic_boot(Genesys_Device* dev, bool cold) const
gl847_init_memory_layout (dev);
SETREG (0xf8, 0x01);
dev->write_register(0xf8, dev->reg.find_reg(0xf8).value);
dev->interface->write_register(0xf8, dev->reg.find_reg(0xf8).value);
}
/**
@ -1862,7 +1862,7 @@ void CommandSetGl847::update_hardware_sensors(Genesys_Scanner* s) const
email=0x04;
copy=0x08;
}
val = s->dev->read_register(REG_0x6D);
val = s->dev->interface->read_register(REG_0x6D);
s->buttons[BUTTON_SCAN_SW].write((val & scan) == 0);
s->buttons[BUTTON_FILE_SW].write((val & file) == 0);
@ -1934,7 +1934,7 @@ void CommandSetGl847::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
r->value |= REG_0x02_MTRREV;
}
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
begin_scan(dev, sensor, &local_reg, true);
@ -1958,7 +1958,7 @@ void CommandSetGl847::search_strip(Genesys_Device* dev, const Genesys_Sensor& se
found = 0;
while (pass < 20 && !found)
{
dev->write_registers(local_reg);
dev->interface->write_registers(local_reg);
// now start scan
begin_scan(dev, sensor, &local_reg, true);
@ -2114,7 +2114,7 @@ void CommandSetGl847::offset_calibration(Genesys_Device* dev, const Genesys_Sens
int top, bottom, black_pixels, pixels;
// no gain nor offset for AKM AFE
uint8_t reg04 = dev->read_register(REG_0x04);
uint8_t reg04 = dev->interface->read_register(REG_0x04);
if ((reg04 & REG_0x04_FESET) == 0x02) {
return;
}
@ -2167,7 +2167,7 @@ void CommandSetGl847::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->frontend.set_offset(2, bottom);
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size);
@ -2188,7 +2188,7 @@ void CommandSetGl847::offset_calibration(Genesys_Device* dev, const Genesys_Sens
dev->frontend.set_offset(1, top);
dev->frontend.set_offset(2, top);
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size);
@ -2208,7 +2208,7 @@ void CommandSetGl847::offset_calibration(Genesys_Device* dev, const Genesys_Sens
// scan with no move
set_fe(dev, sensor, AFE_SET);
dev->write_registers(regs);
dev->interface->write_registers(regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
begin_scan(dev, sensor, &regs, true);
sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size);
@ -2254,7 +2254,7 @@ void CommandSetGl847::coarse_gain_calibration(Genesys_Device* dev, const Genesys
int val, code, lines;
// no gain nor offset for AKM AFE
uint8_t reg04 = dev->read_register(REG_0x04);
uint8_t reg04 = dev->interface->read_register(REG_0x04);
if ((reg04 & REG_0x04_FESET) == 0x02) {
return;
}
@ -2301,7 +2301,7 @@ void CommandSetGl847::coarse_gain_calibration(Genesys_Device* dev, const Genesys
sanei_genesys_set_motor_power(regs, false);
dev->write_registers(regs);
dev->interface->write_registers(regs);
total_size = pixels * channels * (16 / session.params.depth) * lines;

82
backend/genesys/low.cpp
Wyświetl plik

@ -248,10 +248,10 @@ void sanei_genesys_set_buffer_address(Genesys_Device* dev, uint32_t addr)
addr = addr >> 4;
dev->write_register(0x2b, (addr & 0xff));
dev->interface->write_register(0x2b, (addr & 0xff));
addr = addr >> 8;
dev->write_register(0x2a, (addr & 0xff));
dev->interface->write_register(0x2a, (addr & 0xff));
}
/* ------------------------------------------------------------------------ */
@ -267,7 +267,7 @@ std::uint8_t sanei_genesys_get_status(Genesys_Device* dev)
if (dev->model->asic_type == AsicType::GL124) {
address = 0x101;
}
return dev->read_register(address);
return dev->interface->read_register(address);
}
/**
@ -324,34 +324,34 @@ void sanei_genesys_read_valid_words(Genesys_Device* dev, unsigned int* words)
switch (dev->model->asic_type)
{
case AsicType::GL124:
*words = dev->read_register(0x102) & 0x03;
*words = *words * 256 + dev->read_register(0x103);
*words = *words * 256 + dev->read_register(0x104);
*words = *words * 256 + dev->read_register(0x105);
*words = dev->interface->read_register(0x102) & 0x03;
*words = *words * 256 + dev->interface->read_register(0x103);
*words = *words * 256 + dev->interface->read_register(0x104);
*words = *words * 256 + dev->interface->read_register(0x105);
break;
case AsicType::GL845:
case AsicType::GL846:
*words = dev->read_register(0x42) & 0x02;
*words = *words * 256 + dev->read_register(0x43);
*words = *words * 256 + dev->read_register(0x44);
*words = *words * 256 + dev->read_register(0x45);
*words = dev->interface->read_register(0x42) & 0x02;
*words = *words * 256 + dev->interface->read_register(0x43);
*words = *words * 256 + dev->interface->read_register(0x44);
*words = *words * 256 + dev->interface->read_register(0x45);
break;
case AsicType::GL847:
*words = dev->read_register(0x42) & 0x03;
*words = *words * 256 + dev->read_register(0x43);
*words = *words * 256 + dev->read_register(0x44);
*words = *words * 256 + dev->read_register(0x45);
*words = dev->interface->read_register(0x42) & 0x03;
*words = *words * 256 + dev->interface->read_register(0x43);
*words = *words * 256 + dev->interface->read_register(0x44);
*words = *words * 256 + dev->interface->read_register(0x45);
break;
default:
*words = dev->read_register(0x44);
*words += dev->read_register(0x43) * 256;
*words = dev->interface->read_register(0x44);
*words += dev->interface->read_register(0x43) * 256;
if (dev->model->asic_type == AsicType::GL646) {
*words += ((dev->read_register(0x42) & 0x03) * 256 * 256);
*words += ((dev->interface->read_register(0x42) & 0x03) * 256 * 256);
} else {
*words += ((dev->read_register(0x42) & 0x0f) * 256 * 256);
*words += ((dev->interface->read_register(0x42) & 0x0f) * 256 * 256);
}
}
@ -366,18 +366,18 @@ void sanei_genesys_read_scancnt(Genesys_Device* dev, unsigned int* words)
DBG_HELPER(dbg);
if (dev->model->asic_type == AsicType::GL124) {
*words = (dev->read_register(0x10b) & 0x0f) << 16;
*words += (dev->read_register(0x10c) << 8);
*words += dev->read_register(0x10d);
*words = (dev->interface->read_register(0x10b) & 0x0f) << 16;
*words += (dev->interface->read_register(0x10c) << 8);
*words += dev->interface->read_register(0x10d);
}
else
{
*words = dev->read_register(0x4d);
*words += dev->read_register(0x4c) * 256;
*words = dev->interface->read_register(0x4d);
*words += dev->interface->read_register(0x4c) * 256;
if (dev->model->asic_type == AsicType::GL646) {
*words += ((dev->read_register(0x4b) & 0x03) * 256 * 256);
*words += ((dev->interface->read_register(0x4b) & 0x03) * 256 * 256);
} else {
*words += ((dev->read_register(0x4b) & 0x0f) * 256 * 256);
*words += ((dev->interface->read_register(0x4b) & 0x0f) * 256 * 256);
}
}
@ -518,20 +518,20 @@ void sanei_genesys_read_feed_steps(Genesys_Device* dev, unsigned int* steps)
DBG_HELPER(dbg);
if (dev->model->asic_type == AsicType::GL124) {
*steps = (dev->read_register(0x108) & 0x1f) << 16;
*steps += (dev->read_register(0x109) << 8);
*steps += dev->read_register(0x10a);
*steps = (dev->interface->read_register(0x108) & 0x1f) << 16;
*steps += (dev->interface->read_register(0x109) << 8);
*steps += dev->interface->read_register(0x10a);
}
else
{
*steps = dev->read_register(0x4a);
*steps += dev->read_register(0x49) * 256;
*steps = dev->interface->read_register(0x4a);
*steps += dev->interface->read_register(0x49) * 256;
if (dev->model->asic_type == AsicType::GL646) {
*steps += ((dev->read_register(0x48) & 0x03) * 256 * 256);
*steps += ((dev->interface->read_register(0x48) & 0x03) * 256 * 256);
} else if (dev->model->asic_type == AsicType::GL841) {
*steps += ((dev->read_register(0x48) & 0x0f) * 256 * 256);
*steps += ((dev->interface->read_register(0x48) & 0x0f) * 256 * 256);
} else {
*steps += ((dev->read_register(0x48) & 0x1f) * 256 * 256);
*steps += ((dev->interface->read_register(0x48) & 0x1f) * 256 * 256);
}
}
@ -714,14 +714,14 @@ void sanei_genesys_send_gamma_table(Genesys_Device* dev, const Genesys_Sensor& s
// loop sending gamma tables NOTE: 0x01000000 not 0x10000000
for (i = 0; i < 3; i++) {
// clear corresponding GMM_N bit
uint8_t val = dev->read_register(0xbd);
uint8_t val = dev->interface->read_register(0xbd);
val &= ~(0x01 << i);
dev->write_register(0xbd, val);
dev->interface->write_register(0xbd, val);
// clear corresponding GMM_F bit
val = dev->read_register(0xbe);
val = dev->interface->read_register(0xbe);
val &= ~(0x01 << i);
dev->write_register(0xbe, val);
dev->interface->write_register(0xbe, val);
// FIXME: currently the last word of each gamma table is not initialied, so to work around
// unstable data, just set it to 0 which is the most likely value of uninitialized memory
@ -730,8 +730,8 @@ void sanei_genesys_send_gamma_table(Genesys_Device* dev, const Genesys_Sensor& s
gamma[size * 2 * i + size * 2 - 1] = 0;
/* set GMM_Z */
dev->write_register(0xc5+2*i, gamma[size*2*i+1]);
dev->write_register(0xc6+2*i, gamma[size*2*i]);
dev->interface->write_register(0xc5+2*i, gamma[size*2*i+1]);
dev->interface->write_register(0xc6+2*i, gamma[size*2*i]);
dev->interface->write_ahb(0x01000000 + 0x200 * i, (size-1) * 2,
gamma.data() + i * size * 2+2);
@ -1499,7 +1499,7 @@ void sanei_genesys_asic_init(Genesys_Device* dev, bool /*max_regs*/)
check PWRBIT, if reset scanner has been freshly powered up. This bit will be set to later
so that following reads can detect power down/up cycle
*/
if (dev->read_register(0x06) & 0x10) {
if (dev->interface->read_register(0x06) & 0x10) {
cold = false;
}
DBG (DBG_info, "%s: device is %s\n", __func__, cold ? "cold" : "warm");

10
backend/genesys/scanner_interface_usb.cpp
Wyświetl plik

@ -194,7 +194,7 @@ void ScannerInterfaceUsb::write_registers(const Genesys_Register_Set& regs)
}
} else {
for (const auto& r : regs) {
dev_->write_register(r.address, r.value);
write_register(r.address, r.value);
}
}
@ -389,11 +389,11 @@ std::uint16_t ScannerInterfaceUsb::read_fe_register(std::uint8_t address)
reg.init_reg(0x50, address);
// set up read address
dev_->write_registers(reg);
write_registers(reg);
// read data
std::uint16_t value = dev_->read_register(0x46) << 8;
value |= dev_->read_register(0x47);
std::uint16_t value = read_register(0x46) << 8;
value |= read_register(0x47);
DBG(DBG_io, "%s (0x%02x, 0x%04x)\n", __func__, address, value);
return value;
@ -413,7 +413,7 @@ void ScannerInterfaceUsb::write_fe_register(std::uint8_t address, std::uint16_t
reg.init_reg(0x3b, value & 0xff);
}
dev_->write_registers(reg);
write_registers(reg);
}
} // namespace genesys