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

genesys: Add low level interface for interaction with the scanner

merge-requests/240/head
Povilas Kanapickas 2019-10-26 11:38:38 +02:00
rodzic 655c6b14b6
commit 0ea8ec115c
18 zmienionych plików z 564 dodań i 167 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

3
backend/Makefile.am
Wyświetl plik

@ -507,7 +507,10 @@ libgenesys_la_SOURCES = genesys/genesys.cpp genesys/genesys.h \
genesys/image.h genesys/image.cpp \
genesys/motor.h \
genesys/register.h \
genesys/register_cache.h \
genesys/sanei.h genesys/sanei.cpp \
genesys/scanner_interface.h genesys/scanner_interface.cpp \
genesys/scanner_interface_usb.h genesys/scanner_interface_usb.cpp \
genesys/sensor.h \
genesys/settings.h \
genesys/serialize.h \

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

@ -105,33 +105,24 @@ ImagePipelineNodeBytesSource& Genesys_Device::get_pipeline_source()
uint8_t Genesys_Device::read_register(uint16_t address)
{
uint8_t value;
sanei_genesys_read_register(this, address, &value);
update_register_state(address, value);
return value;
return interface->read_register(address);
}
void Genesys_Device::write_register(uint16_t address, uint8_t value)
{
sanei_genesys_write_register(this, address, value);
update_register_state(address, value);
interface->write_register(address, value);
}
void Genesys_Device::write_registers(Genesys_Register_Set& regs)
{
sanei_genesys_bulk_write_register(this, regs);
for (const auto& reg : regs) {
update_register_state(reg.address, reg.value);
}
interface->write_registers(regs);
}
void Genesys_Device::update_register_state(uint16_t address, uint8_t value)
UsbDevice& Genesys_Device::get_usb_device()
{
if (physical_regs.has_reg(address)) {
physical_regs.set8(address, value);
} else {
physical_regs.init_reg(address, value);
}
if (interface->is_mock())
throw SaneException("Can't get USB device of mock interface");
return usb_dev;
}
void apply_reg_settings_to_device(Genesys_Device& dev, const GenesysRegisterSettingSet& regs)

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

@ -54,6 +54,7 @@
#include "sensor.h"
#include "register.h"
#include "sanei.h"
#include "scanner_interface.h"
#include <vector>
namespace genesys {
@ -242,7 +243,6 @@ struct Genesys_Device
// frees commonly used data
void clear();
UsbDevice usb_dev;
SANE_Word vendorId = 0; /**< USB vendor identifier */
SANE_Word productId = 0; /**< USB product identifier */
@ -357,18 +357,20 @@ struct Genesys_Device
// image buffer where the scanned picture is stored
std::vector<std::uint8_t> img_buffer;
// A snapshot of the last known physical state of the device registers. This variable is updated
// whenever a register is written or read to the scanner.
Genesys_Register_Set physical_regs;
ImagePipelineNodeBytesSource& get_pipeline_source();
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;
private:
void update_register_state(std::uint16_t address, std::uint8_t value);
friend class ScannerInterfaceUsb;
};
void apply_reg_settings_to_device(Genesys_Device& dev, const GenesysRegisterSettingSet& regs);

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

@ -64,6 +64,7 @@
#include "conv.h"
#include "sanei.h"
#include "utilities.h"
#include "scanner_interface_usb.h"
#include "../include/sane/sanei_config.h"
#include "../include/sane/sanei_magic.h"
@ -922,7 +923,7 @@ static void genesys_send_offset_and_shading(Genesys_Device* dev, const Genesys_S
sanei_genesys_set_buffer_address(dev, start_address);
sanei_genesys_bulk_write_data(dev, 0x3c, data, size);
dev->interface->bulk_write_data(0x3c, data, size);
}
// ?
@ -1375,9 +1376,9 @@ static void genesys_coarse_calibration(Genesys_Device* dev, Genesys_Sensor& sens
dev->frontend.set_gain(1, 2);
dev->frontend.set_gain(2, 2);
sanei_genesys_fe_write_data(dev, 0x28, dev->frontend.get_gain(0));
sanei_genesys_fe_write_data(dev, 0x29, dev->frontend.get_gain(1));
sanei_genesys_fe_write_data(dev, 0x2a, dev->frontend.get_gain(2));
dev->interface->write_fe_register(0x28, dev->frontend.get_gain(0));
dev->interface->write_fe_register(0x29, dev->frontend.get_gain(1));
dev->interface->write_fe_register(0x2a, dev->frontend.get_gain(2));
}
if (i == 3) /* last line */
@ -1402,9 +1403,9 @@ static void genesys_coarse_calibration(Genesys_Device* dev, Genesys_Sensor& sens
dev->frontend.set_offset(j, curr_offset);
}
}
sanei_genesys_fe_write_data(dev, 0x20, dev->frontend.get_offset(0));
sanei_genesys_fe_write_data(dev, 0x21, dev->frontend.get_offset(1));
sanei_genesys_fe_write_data(dev, 0x22, dev->frontend.get_offset(2));
dev->interface->write_fe_register(0x20, dev->frontend.get_offset(0));
dev->interface->write_fe_register(0x21, dev->frontend.get_offset(1));
dev->interface->write_fe_register(0x22, dev->frontend.get_offset(2));
DBG(DBG_info,
"%s: doing scan: gain: %d/%d/%d, offset: %d/%d/%d\n", __func__,
@ -4801,6 +4802,7 @@ static void sane_open_impl(SANE_String_Const devicename, SANE_Handle * handle)
dbg.vstatus("open device '%s'", dev->file_name.c_str());
dev->usb_dev.open(dev->file_name.c_str());
dbg.clear();
dev->interface = std::unique_ptr<ScannerInterfaceUsb>{new ScannerInterfaceUsb{dev}};
s_scanners->push_back(Genesys_Scanner());

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

@ -393,7 +393,7 @@ static void gl124_send_slope_table(Genesys_Device* dev, int table_nr,
}
// slope table addresses are fixed
sanei_genesys_write_ahb(dev, 0x10000000 + 0x4000 * table_nr, steps * 2, table.data());
dev->interface->write_ahb(0x10000000 + 0x4000 * table_nr, steps * 2, table.data());
}
/** @brief * Set register values of 'special' ti type frontend
@ -416,28 +416,28 @@ static void gl124_set_ti_fe(Genesys_Device* dev, uint8_t set)
}
// start writing to DAC
sanei_genesys_fe_write_data(dev, 0x00, 0x80);
dev->interface->write_fe_register(0x00, 0x80);
/* write values to analog frontend */
for (uint16_t addr = 0x01; addr < 0x04; addr++)
{
sanei_genesys_fe_write_data(dev, addr, dev->frontend.regs.get_value(addr));
dev->interface->write_fe_register(addr, dev->frontend.regs.get_value(addr));
}
sanei_genesys_fe_write_data (dev, 0x04, 0x00);
dev->interface->write_fe_register(0x04, 0x00);
/* these are not really sign for this AFE */
for (i = 0; i < 3; i++)
{
sanei_genesys_fe_write_data(dev, 0x05 + i, dev->frontend.regs.get_value(0x24 + i));
dev->interface->write_fe_register(0x05 + i, dev->frontend.regs.get_value(0x24 + i));
}
if (dev->model->adc_id == AdcId::CANON_LIDE_120) {
sanei_genesys_fe_write_data(dev, 0x00, 0x01);
dev->interface->write_fe_register(0x00, 0x01);
}
else
{
sanei_genesys_fe_write_data(dev, 0x00, 0x11);
dev->interface->write_fe_register(0x00, 0x11);
}
}
@ -1754,7 +1754,7 @@ void CommandSetGl124::send_shading_data(Genesys_Device* dev, const Genesys_Senso
}
uint8_t val = dev->read_register(0xd0+i);
addr = val * 8192 + 0x10000000;
sanei_genesys_write_ahb(dev, addr, pixels * dev->session.segment_count, buffer.data());
dev->interface->write_ahb(addr, pixels * dev->session.segment_count, buffer.data());
}
}
@ -2457,8 +2457,8 @@ void CommandSetGl124::asic_boot(Genesys_Device* dev, bool cold) const
dev->reg.remove_reg(0x0b);
//set up end access
sanei_genesys_write_0x8c(dev, 0x10, 0x0b);
sanei_genesys_write_0x8c(dev, 0x13, 0x0e);
dev->interface->write_0x8c(0x10, 0x0b);
dev->interface->write_0x8c(0x13, 0x0e);
/* CIS_LINE */
SETREG(0x08, REG_0x08_CIS_LINE);

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

@ -837,7 +837,7 @@ static void gl646_send_slope_table(Genesys_Device* dev, int table_nr,
sanei_genesys_set_buffer_address(dev, start_address + table_nr * 0x100);
sanei_genesys_bulk_write_data(dev, 0x3c, table.data(), steps * 2);
dev->interface->bulk_write_data(0x3c, table.data(), steps * 2);
}
// Set values of Analog Device type frontend
@ -854,24 +854,22 @@ static void gl646_set_ad_fe(Genesys_Device* dev, uint8_t set)
dev->frontend = dev->frontend_initial;
// write them to analog frontend
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
dev->interface->write_fe_register(0x00, dev->frontend.regs.get_value(0x00));
dev->interface->write_fe_register(0x01, dev->frontend.regs.get_value(0x01));
}
if (set == AFE_SET)
{
for (i = 0; i < 3; i++)
{
sanei_genesys_fe_write_data(dev, 0x02 + i, dev->frontend.get_gain(i));
}
for (i = 0; i < 3; i++)
{
sanei_genesys_fe_write_data(dev, 0x05 + i, dev->frontend.get_offset(i));
}
for (i = 0; i < 3; i++) {
dev->interface->write_fe_register(0x02 + i, dev->frontend.get_gain(i));
}
for (i = 0; i < 3; i++) {
dev->interface->write_fe_register(0x05 + i, dev->frontend.get_offset(i));
}
}
/*
if (set == AFE_POWER_SAVE)
{
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.reg[0] | 0x04);
dev->interface->write_fe_register(0x00, dev->frontend.reg[0] | 0x04);
} */
}
@ -890,17 +888,17 @@ static void gl646_wm_hp3670(Genesys_Device* dev, const Genesys_Sensor& sensor, u
switch (set)
{
case AFE_INIT:
sanei_genesys_fe_write_data (dev, 0x04, 0x80);
dev->interface->write_fe_register(0x04, 0x80);
sanei_genesys_sleep_ms(200);
dev->write_register(0x50, 0x00);
dev->frontend = dev->frontend_initial;
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
sanei_genesys_fe_write_data(dev, 0x02, dev->frontend.regs.get_value(0x02));
dev->interface->write_fe_register(0x01, dev->frontend.regs.get_value(0x01));
dev->interface->write_fe_register(0x02, dev->frontend.regs.get_value(0x02));
gl646_gpio_output_enable(dev->usb_dev, 0x07);
break;
case AFE_POWER_SAVE:
sanei_genesys_fe_write_data(dev, 0x01, 0x06);
sanei_genesys_fe_write_data(dev, 0x06, 0x0f);
dev->interface->write_fe_register(0x01, 0x06);
dev->interface->write_fe_register(0x06, 0x0f);
return;
break;
default: /* AFE_SET */
@ -913,18 +911,16 @@ static void gl646_wm_hp3670(Genesys_Device* dev, const Genesys_Sensor& sensor, u
* fe_reg_0x03 set to 0x32 or 0x12 but not to 0x02 */
i = 0x12;
}
sanei_genesys_fe_write_data(dev, 0x03, i);
dev->interface->write_fe_register(0x03, i);
/* offset and sign (or msb/lsb ?) */
for (i = 0; i < 3; i++)
{
sanei_genesys_fe_write_data(dev, 0x20 + i, dev->frontend.get_offset(i));
sanei_genesys_fe_write_data(dev, 0x24 + i,
dev->frontend.regs.get_value(0x24 + i)); /* MSB/LSB ? */
}
for (i = 0; i < 3; i++) {
dev->interface->write_fe_register(0x20 + i, dev->frontend.get_offset(i));
dev->interface->write_fe_register(0x24 + i, dev->frontend.regs.get_value(0x24 + i));
}
// gain
for (i = 0; i < 3; i++) {
sanei_genesys_fe_write_data(dev, 0x28 + i, dev->frontend.get_gain(i));
dev->interface->write_fe_register(0x28 + i, dev->frontend.get_gain(i));
}
}
}
@ -974,7 +970,7 @@ static void gl646_set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor, uint
dev->frontend = dev->frontend_initial;
// reset only done on init
sanei_genesys_fe_write_data(dev, 0x04, 0x80);
dev->interface->write_fe_register(0x04, 0x80);
/* enable GPIO for some models */
if (dev->model->sensor_id == SensorId::CCD_HP2300) {
@ -986,7 +982,7 @@ static void gl646_set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor, uint
// set fontend to power saving mode
if (set == AFE_POWER_SAVE) {
sanei_genesys_fe_write_data(dev, 0x01, 0x02);
dev->interface->write_fe_register(0x01, 0x02);
return;
}
@ -996,35 +992,34 @@ static void gl646_set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor, uint
&& dev->model->ccd_type != SensorId::CCD_HP3670
&& dev->model->ccd_type != SensorId::CCD_HP2400) */
{
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
sanei_genesys_fe_write_data(dev, 0x02, dev->frontend.regs.get_value(0x02));
dev->interface->write_fe_register(0x00, dev->frontend.regs.get_value(0x00));
dev->interface->write_fe_register(0x02, dev->frontend.regs.get_value(0x02));
}
// start with reg3
sanei_genesys_fe_write_data(dev, 0x03, dev->frontend.regs.get_value(0x03));
dev->interface->write_fe_register(0x03, dev->frontend.regs.get_value(0x03));
switch (dev->model->sensor_id)
{
default:
for (i = 0; i < 3; i++)
{
sanei_genesys_fe_write_data(dev, 0x24 + i, dev->frontend.regs.get_value(0x24 + i));
sanei_genesys_fe_write_data(dev, 0x28 + i, dev->frontend.get_gain(i));
sanei_genesys_fe_write_data(dev, 0x20 + i, dev->frontend.get_offset(i));
}
for (i = 0; i < 3; i++) {
dev->interface->write_fe_register(0x24 + i, dev->frontend.regs.get_value(0x24 + i));
dev->interface->write_fe_register(0x28 + i, dev->frontend.get_gain(i));
dev->interface->write_fe_register(0x20 + i, dev->frontend.get_offset(i));
}
break;
/* just can't have it to work ....
case SensorId::CCD_HP2300:
case SensorId::CCD_HP2400:
case SensorId::CCD_HP3670:
sanei_genesys_fe_write_data(dev, 0x23, dev->frontend.get_offset(1));
sanei_genesys_fe_write_data(dev, 0x28, dev->frontend.get_gain(1));
dev->interface->write_fe_register(0x23, dev->frontend.get_offset(1));
dev->interface->write_fe_register(0x28, dev->frontend.get_gain(1));
break; */
}
// end with reg1
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
dev->interface->write_fe_register(0x01, dev->frontend.regs.get_value(0x01));
}
/** Set values of analog frontend
@ -1983,7 +1978,7 @@ void CommandSetGl646::send_gamma_table(Genesys_Device* dev, const Genesys_Sensor
sanei_genesys_set_buffer_address(dev, address);
// send data
sanei_genesys_bulk_write_data(dev, 0x3c, gamma.data(), size * 2 * 3);
dev->interface->bulk_write_data(0x3c, gamma.data(), size * 2 * 3);
}
/** @brief this function does the led calibration.
@ -2886,9 +2881,9 @@ void CommandSetGl646::init(Genesys_Device* dev) const
// for some reason, read fails here for MD6471, HP2300 and XP200 one time out of
// 2 scanimage launches
try {
sanei_genesys_bulk_read_data(dev, 0x45, dev->control, len);
dev->interface->bulk_read_data(0x45, dev->control, len);
} catch (...) {
sanei_genesys_bulk_read_data(dev, 0x45, dev->control, len);
dev->interface->bulk_read_data(0x45, dev->control, len);
}
DBG(DBG_info, "%s: control read=0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x\n", __func__,
dev->control[0], dev->control[1], dev->control[2], dev->control[3], dev->control[4],
@ -3285,7 +3280,7 @@ static void write_control(Genesys_Device* dev, const Genesys_Sensor& sensor, int
DBG(DBG_info, "%s: control write=0x%02x 0x%02x 0x%02x 0x%02x\n", __func__, control[0], control[1],
control[2], control[3]);
sanei_genesys_set_buffer_address(dev, addr);
sanei_genesys_bulk_write_data(dev, 0x3c, control, 4);
dev->interface->bulk_write_data(0x3c, control, 4);
}
/**

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

@ -363,7 +363,7 @@ gl841_init_lide80 (Genesys_Device * dev)
(void) val; // FIXME: we don't use the information read from registers
sanei_genesys_write_0x8c(dev, 0x10, 0x94);
dev->interface->write_0x8c(0x10, 0x94);
dev->write_register(0x09, 0x10);
// FIXME: the following code originally changed 0x6b, but due to bug the 0x6c register was
@ -573,7 +573,7 @@ static void gl841_send_slope_table(Genesys_Device* dev, int table_nr,
sanei_genesys_set_buffer_address(dev, start_address + table_nr * 0x200);
sanei_genesys_bulk_write_data(dev, 0x3c, table.data(), steps * 2);
dev->interface->bulk_write_data(0x3c, table.data(), steps * 2);
}
static void gl841_set_lide80_fe(Genesys_Device* dev, uint8_t set)
@ -588,16 +588,16 @@ static void gl841_set_lide80_fe(Genesys_Device* dev, uint8_t set)
dev->frontend = dev->frontend_initial;
// write them to analog frontend
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
sanei_genesys_fe_write_data(dev, 0x03, dev->frontend.regs.get_value(0x01));
sanei_genesys_fe_write_data(dev, 0x06, dev->frontend.regs.get_value(0x02));
dev->interface->write_fe_register(0x00, dev->frontend.regs.get_value(0x00));
dev->interface->write_fe_register(0x03, dev->frontend.regs.get_value(0x01));
dev->interface->write_fe_register(0x06, dev->frontend.regs.get_value(0x02));
}
if (set == AFE_SET)
{
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
sanei_genesys_fe_write_data(dev, 0x06, dev->frontend.regs.get_value(0x20));
sanei_genesys_fe_write_data(dev, 0x03, dev->frontend.regs.get_value(0x28));
dev->interface->write_fe_register(0x00, dev->frontend.regs.get_value(0x00));
dev->interface->write_fe_register(0x06, dev->frontend.regs.get_value(0x20));
dev->interface->write_fe_register(0x03, dev->frontend.regs.get_value(0x28));
}
}
@ -620,38 +620,38 @@ static void gl841_set_ad_fe(Genesys_Device* dev, uint8_t set)
dev->frontend = dev->frontend_initial;
// write them to analog frontend
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
dev->interface->write_fe_register(0x00, dev->frontend.regs.get_value(0x00));
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
dev->interface->write_fe_register(0x01, dev->frontend.regs.get_value(0x01));
for (i = 0; i < 6; i++) {
sanei_genesys_fe_write_data(dev, 0x02 + i, 0x00);
dev->interface->write_fe_register(0x02 + i, 0x00);
}
}
if (set == AFE_SET)
{
// write them to analog frontend
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
dev->interface->write_fe_register(0x00, dev->frontend.regs.get_value(0x00));
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
dev->interface->write_fe_register(0x01, dev->frontend.regs.get_value(0x01));
// Write fe 0x02 (red gain)
sanei_genesys_fe_write_data(dev, 0x02, dev->frontend.get_gain(0));
dev->interface->write_fe_register(0x02, dev->frontend.get_gain(0));
// Write fe 0x03 (green gain)
sanei_genesys_fe_write_data(dev, 0x03, dev->frontend.get_gain(1));
dev->interface->write_fe_register(0x03, dev->frontend.get_gain(1));
// Write fe 0x04 (blue gain)
sanei_genesys_fe_write_data(dev, 0x04, dev->frontend.get_gain(2));
dev->interface->write_fe_register(0x04, dev->frontend.get_gain(2));
// Write fe 0x05 (red offset)
sanei_genesys_fe_write_data(dev, 0x05, dev->frontend.get_offset(0));
dev->interface->write_fe_register(0x05, dev->frontend.get_offset(0));
// Write fe 0x06 (green offset)
sanei_genesys_fe_write_data(dev, 0x06, dev->frontend.get_offset(1));
dev->interface->write_fe_register(0x06, dev->frontend.get_offset(1));
// Write fe 0x07 (blue offset)
sanei_genesys_fe_write_data(dev, 0x07, dev->frontend.get_offset(2));
dev->interface->write_fe_register(0x07, dev->frontend.get_offset(2));
}
}
@ -662,7 +662,6 @@ void CommandSetGl841::set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor,
set == AFE_SET ? "set" :
set == AFE_POWER_SAVE ? "powersave" : "huh?");
(void) sensor;
int i;
/* Analog Device type frontend */
uint8_t frontend_type = dev->reg.find_reg(0x04).value & REG_0x04_FESET;
@ -683,36 +682,35 @@ void CommandSetGl841::set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor,
dev->frontend = dev->frontend_initial;
// reset only done on init
sanei_genesys_fe_write_data (dev, 0x04, 0x80);
dev->interface->write_fe_register(0x04, 0x80);
DBG(DBG_proc, "%s(): frontend reset complete\n", __func__);
}
if (set == AFE_POWER_SAVE)
{
sanei_genesys_fe_write_data (dev, 0x01, 0x02);
dev->interface->write_fe_register(0x01, 0x02);
return;
}
/* todo : base this test on cfg reg3 or a CCD family flag to be created */
/*if (dev->model->ccd_type!=SensorId::CCD_HP2300 && dev->model->ccd_type!=SensorId::CCD_HP2400) */
{
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
sanei_genesys_fe_write_data(dev, 0x02, dev->frontend.regs.get_value(0x02));
dev->interface->write_fe_register(0x00, dev->frontend.regs.get_value(0x00));
dev->interface->write_fe_register(0x02, dev->frontend.regs.get_value(0x02));
}
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
sanei_genesys_fe_write_data(dev, 0x03, dev->frontend.regs.get_value(0x03));
sanei_genesys_fe_write_data(dev, 0x06, dev->frontend.reg2[0]);
sanei_genesys_fe_write_data(dev, 0x08, dev->frontend.reg2[1]);
sanei_genesys_fe_write_data(dev, 0x09, dev->frontend.reg2[2]);
dev->interface->write_fe_register(0x01, dev->frontend.regs.get_value(0x01));
dev->interface->write_fe_register(0x03, dev->frontend.regs.get_value(0x03));
dev->interface->write_fe_register(0x06, dev->frontend.reg2[0]);
dev->interface->write_fe_register(0x08, dev->frontend.reg2[1]);
dev->interface->write_fe_register(0x09, dev->frontend.reg2[2]);
for (i = 0; i < 3; i++)
{
sanei_genesys_fe_write_data(dev, 0x24 + i, dev->frontend.regs.get_value(0x24 + i));
sanei_genesys_fe_write_data(dev, 0x28 + i, dev->frontend.get_gain(i));
sanei_genesys_fe_write_data(dev, 0x20 + i, dev->frontend.get_offset(i));
}
for (unsigned i = 0; i < 3; i++) {
dev->interface->write_fe_register(0x24 + i, dev->frontend.regs.get_value(0x24 + i));
dev->interface->write_fe_register(0x28 + i, dev->frontend.get_gain(i));
dev->interface->write_fe_register(0x20 + i, dev->frontend.get_offset(i));
}
}
#define MOTOR_ACTION_FEED 1
@ -817,7 +815,7 @@ uint8_t *table;
dev->write_register(0x66, 0x00);
dev->write_register(0x5b, 0x0c);
dev->write_register(0x5c, 0x00);
sanei_genesys_bulk_write_data(dev, 0x28, table, 128);
dev->interface->bulk_write_data(0x28, table, 128);
dev->write_register(0x5b, 0x00);
dev->write_register(0x5c, 0x00);
}
@ -2621,7 +2619,7 @@ void CommandSetGl841::send_gamma_table(Genesys_Device* dev, const Genesys_Sensor
gl841_set_buffer_address_gamma (dev, 0x00000);
// send data
sanei_genesys_bulk_write_data(dev, 0x28, gamma.data(), size * 2 * 3);
dev->interface->bulk_write_data(0x28, gamma.data(), size * 2 * 3);
}
@ -3928,7 +3926,7 @@ void CommandSetGl841::send_shading_data(Genesys_Device* dev, const Genesys_Senso
sanei_genesys_set_buffer_address(dev, 0x0000);
// shading data whole line
sanei_genesys_bulk_write_data(dev, 0x3c, data, size);
dev->interface->bulk_write_data(0x3c, data, size);
return;
}
@ -3989,7 +3987,7 @@ void CommandSetGl841::send_shading_data(Genesys_Device* dev, const Genesys_Senso
// 0x5400 alignment for LIDE80 internal memory
sanei_genesys_set_buffer_address(dev, 0x5400*i);
sanei_genesys_bulk_write_data(dev, 0x3c, buffer.data(), pixels);
dev->interface->bulk_write_data(0x3c, buffer.data(), pixels);
}
}

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

@ -84,7 +84,7 @@ static void write_data(Genesys_Device* dev, uint32_t addr, uint32_t size, uint8_
gl843_set_buffer_address(dev, addr);
// write actual data
sanei_genesys_bulk_write_data(dev, 0x28, data, size);
dev->interface->bulk_write_data(0x28, data, size);
// set back address to 0
gl843_set_buffer_address(dev, 0);
@ -714,7 +714,7 @@ gl843_init_registers (Genesys_Device * dev)
0x6a, 0x73, 0x63, 0x68, 0x69, 0x65, 0x6e, 0x00,
};
sanei_genesys_bulk_write_data(dev, 0x3c, data, 32);
dev->interface->bulk_write_data(0x3c, data, 32);
}
}
@ -752,7 +752,7 @@ static void gl843_send_slope_table(Genesys_Device* dev, int table_nr,
static void gl843_set_ad_fe(Genesys_Device* dev)
{
for (const auto& reg : dev->frontend.regs) {
sanei_genesys_fe_write_data(dev, reg.address, reg.value);
dev->interface->write_fe_register(reg.address, reg.value);
}
}
@ -790,22 +790,22 @@ void CommandSetGl843::set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor,
{
// FIXME: the check below is just historical artifact, we can remove it when convenient
if (!dev->frontend_is_init) {
sanei_genesys_fe_write_data(dev, i, 0x00);
dev->interface->write_fe_register(i, 0x00);
} else {
sanei_genesys_fe_write_data(dev, i, dev->frontend.regs.get_value(0x00 + i));
dev->interface->write_fe_register(i, dev->frontend.regs.get_value(0x00 + i));
}
}
for (const auto& reg : sensor.custom_fe_regs) {
sanei_genesys_fe_write_data(dev, reg.address, reg.value);
dev->interface->write_fe_register(reg.address, reg.value);
}
for (i = 0; i < 3; i++)
{
// FIXME: the check below is just historical artifact, we can remove it when convenient
if (!dev->frontend_is_init) {
sanei_genesys_fe_write_data(dev, 0x20 + i, 0x00);
dev->interface->write_fe_register(0x20 + i, 0x00);
} else {
sanei_genesys_fe_write_data(dev, 0x20 + i, dev->frontend.get_offset(i));
dev->interface->write_fe_register(0x20 + i, dev->frontend.get_offset(i));
}
}
@ -814,9 +814,9 @@ void CommandSetGl843::set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor,
{
// FIXME: the check below is just historical artifact, we can remove it when convenient
if (!dev->frontend_is_init) {
sanei_genesys_fe_write_data(dev, 0x24 + i, 0x00);
dev->interface->write_fe_register(0x24 + i, 0x00);
} else {
sanei_genesys_fe_write_data(dev, 0x24 + i, dev->frontend.regs.get_value(0x24 + i));
dev->interface->write_fe_register(0x24 + i, dev->frontend.regs.get_value(0x24 + i));
}
}
}
@ -825,9 +825,9 @@ void CommandSetGl843::set_fe(Genesys_Device* dev, const Genesys_Sensor& sensor,
{
// FIXME: the check below is just historical artifact, we can remove it when convenient
if (!dev->frontend_is_init) {
sanei_genesys_fe_write_data(dev, 0x28 + i, 0x00);
dev->interface->write_fe_register(0x28 + i, 0x00);
} else {
sanei_genesys_fe_write_data(dev, 0x28 + i, dev->frontend.get_gain(i));
dev->interface->write_fe_register(0x28 + i, dev->frontend.get_gain(i));
}
}
}
@ -2338,7 +2338,7 @@ void CommandSetGl843::send_gamma_table(Genesys_Device* dev, const Genesys_Sensor
gl843_set_buffer_address(dev, 0x0000);
// send data
sanei_genesys_bulk_write_data(dev, 0x28, gamma.data(), size * 2 * 3);
dev->interface->bulk_write_data(0x28, gamma.data(), size * 2 * 3);
}
/* this function does the led calibration by scanning one line of the calibration
@ -2969,7 +2969,7 @@ void CommandSetGl843::asic_boot(Genesys_Device* dev, bool cold) const
{
val = 0x11;
}
sanei_genesys_write_0x8c(dev, 0x0f, val);
dev->interface->write_0x8c(0x0f, val);
// test CHKVER
val = dev->read_register(REG_0x40);
@ -2998,18 +2998,18 @@ void CommandSetGl843::asic_boot(Genesys_Device* dev, bool cold) const
dev->reg.find_reg(0x0b).value = val;
if (dev->model->model_id == ModelId::CANON_8400F) {
sanei_genesys_write_0x8c(dev, 0x1e, 0x01);
sanei_genesys_write_0x8c(dev, 0x10, 0xb4);
sanei_genesys_write_0x8c(dev, 0x0f, 0x02);
dev->interface->write_0x8c(0x1e, 0x01);
dev->interface->write_0x8c(0x10, 0xb4);
dev->interface->write_0x8c(0x0f, 0x02);
}
else if (dev->model->model_id == ModelId::CANON_8600F) {
sanei_genesys_write_0x8c(dev, 0x10, 0xc8);
dev->interface->write_0x8c(0x10, 0xc8);
} else if (dev->model->model_id == ModelId::PLUSTEK_OPTICFILM_7300 ||
dev->model->model_id == ModelId::PLUSTEK_OPTICFILM_7500I)
{
sanei_genesys_write_0x8c(dev, 0x10, 0xd4);
dev->interface->write_0x8c(0x10, 0xd4);
} else {
sanei_genesys_write_0x8c(dev, 0x10, 0xb4);
dev->interface->write_0x8c(0x10, 0xb4);
}
/* CLKSET */
@ -3375,7 +3375,7 @@ void CommandSetGl843::send_shading_data(Genesys_Device* dev, const Genesys_Senso
// send data
sanei_genesys_set_buffer_address(dev, 0);
sanei_genesys_bulk_write_data(dev, 0x3c, final_data.data(), count);
dev->interface->bulk_write_data(0x3c, final_data.data(), count);
}
bool CommandSetGl843::needs_home_before_init_regs_for_scan(Genesys_Device* dev) const

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

@ -295,7 +295,7 @@ static void gl846_send_slope_table(Genesys_Device* dev, int table_nr,
}
// slope table addresses are fixed
sanei_genesys_write_ahb(dev, 0x10000000 + 0x4000 * table_nr, steps * 2, table.data());
dev->interface->write_ahb(0x10000000 + 0x4000 * table_nr, steps * 2, table.data());
}
/**
@ -322,15 +322,15 @@ static void gl846_set_adi_fe(Genesys_Device* dev, uint8_t set)
}
// write them to analog frontend
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
dev->interface->write_fe_register(0x00, dev->frontend.regs.get_value(0x00));
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
dev->interface->write_fe_register(0x01, dev->frontend.regs.get_value(0x01));
for (i = 0; i < 3; i++) {
sanei_genesys_fe_write_data(dev, 0x02 + i, dev->frontend.get_gain(i));
dev->interface->write_fe_register(0x02 + i, dev->frontend.get_gain(i));
}
for (i = 0; i < 3; i++) {
sanei_genesys_fe_write_data(dev, 0x05 + i, dev->frontend.get_offset(i));
dev->interface->write_fe_register(0x05 + i, dev->frontend.get_offset(i));
}
}
@ -1476,7 +1476,7 @@ void CommandSetGl846::send_shading_data(Genesys_Device* dev, const Genesys_Senso
val = dev->read_register(0xd0+i);
addr = val * 8192 + 0x10000000;
sanei_genesys_write_ahb(dev, addr, pixels, buffer.data());
dev->interface->write_ahb(addr, pixels, buffer.data());
}
}
@ -1727,7 +1727,7 @@ void CommandSetGl846::asic_boot(Genesys_Device* dev, bool cold) const
{
val = 0x11;
}
sanei_genesys_write_0x8c(dev, 0x0f, val);
dev->interface->write_0x8c(0x0f, val);
// test CHKVER
val = dev->read_register(REG_0x40);
@ -1756,8 +1756,8 @@ void CommandSetGl846::asic_boot(Genesys_Device* dev, bool cold) const
}
// set up clocks
sanei_genesys_write_0x8c(dev, 0x10, 0x0e);
sanei_genesys_write_0x8c(dev, 0x13, 0x0e);
dev->interface->write_0x8c(0x10, 0x0e);
dev->interface->write_0x8c(0x13, 0x0e);
// setup gpio
gl846_init_gpio(dev);

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

@ -317,7 +317,7 @@ static void gl847_send_slope_table(Genesys_Device* dev, int table_nr,
}
// slope table addresses are fixed
sanei_genesys_write_ahb(dev, 0x10000000 + 0x4000 * table_nr, steps * 2, table.data());
dev->interface->write_ahb(0x10000000 + 0x4000 * table_nr, steps * 2, table.data());
}
/**
@ -344,18 +344,18 @@ static void gl847_set_ad_fe(Genesys_Device* dev, uint8_t set)
}
// reset DAC
sanei_genesys_fe_write_data(dev, 0x00, 0x80);
dev->interface->write_fe_register(0x00, 0x80);
// write them to analog frontend
sanei_genesys_fe_write_data(dev, 0x00, dev->frontend.regs.get_value(0x00));
dev->interface->write_fe_register(0x00, dev->frontend.regs.get_value(0x00));
sanei_genesys_fe_write_data(dev, 0x01, dev->frontend.regs.get_value(0x01));
dev->interface->write_fe_register(0x01, dev->frontend.regs.get_value(0x01));
for (i = 0; i < 3; i++) {
sanei_genesys_fe_write_data(dev, 0x02 + i, dev->frontend.get_gain(i));
dev->interface->write_fe_register(0x02 + i, dev->frontend.get_gain(i));
}
for (i = 0; i < 3; i++) {
sanei_genesys_fe_write_data(dev, 0x05 + i, dev->frontend.get_offset(i));
dev->interface->write_fe_register(0x05 + i, dev->frontend.get_offset(i));
}
}
@ -1508,7 +1508,7 @@ void CommandSetGl847::send_shading_data(Genesys_Device* dev, const Genesys_Senso
val = dev->read_register(0xd0+i);
addr = val * 8192 + 0x10000000;
sanei_genesys_write_ahb(dev, addr, pixels, buffer.data());
dev->interface->write_ahb(addr, pixels, buffer.data());
}
}
@ -1816,8 +1816,8 @@ void CommandSetGl847::asic_boot(Genesys_Device* dev, bool cold) const
dev->write_register(0x08, dev->reg.find_reg(0x08).value);
// set up end access
sanei_genesys_write_0x8c(dev, 0x10, 0x0b);
sanei_genesys_write_0x8c(dev, 0x13, 0x0e);
dev->interface->write_0x8c(0x10, 0x0b);
dev->interface->write_0x8c(0x13, 0x0e);
// setup gpio
gl847_init_gpio(dev);

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

@ -831,7 +831,7 @@ void sanei_genesys_read_data_from_scanner(Genesys_Device* dev, uint8_t* data, si
wait_until_has_valid_words(dev);
sanei_genesys_bulk_read_data(dev, 0x45, data, size);
dev->interface->bulk_read_data(0x45, data, size);
}
Image read_unshuffled_image_from_scanner(Genesys_Device* dev, const ScanSession& session,
@ -1234,8 +1234,8 @@ void sanei_genesys_send_gamma_table(Genesys_Device* dev, const Genesys_Sensor& s
dev->write_register(0xc5+2*i, gamma[size*2*i+1]);
dev->write_register(0xc6+2*i, gamma[size*2*i]);
sanei_genesys_write_ahb(dev, 0x01000000 + 0x200 * i, (size-1) * 2,
gamma.data() + i * size * 2+2);
dev->interface->write_ahb(0x01000000 + 0x200 * i, (size-1) * 2,
gamma.data() + i * size * 2+2);
}
}
@ -1748,7 +1748,7 @@ void build_image_pipeline(Genesys_Device* dev, const ScanSession& session)
auto read_data_from_usb = [dev](std::size_t size, std::uint8_t* data)
{
sanei_genesys_bulk_read_data(dev, 0x45, data, size);
dev->interface->bulk_read_data(0x45, data, size);
return true;
};

2
backend/genesys/low.h
Wyświetl plik

@ -288,8 +288,6 @@ extern void sanei_genesys_bulk_write_register(Genesys_Device* dev,
extern void sanei_genesys_write_0x8c(Genesys_Device* dev, uint8_t index, uint8_t val);
unsigned sanei_genesys_get_bulk_max_size(AsicType asic_type);
extern void sanei_genesys_bulk_read_data(Genesys_Device * dev, uint8_t addr, uint8_t* data,
size_t len);

92
backend/genesys/register_cache.h 100644
Wyświetl plik

@ -0,0 +1,92 @@
/* sane - Scanner Access Now Easy.
Copyright (C) 2019 Povilas Kanapickas <povilas@radix.lt>
This file is part of the SANE package.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston,
MA 02111-1307, USA.
As a special exception, the authors of SANE give permission for
additional uses of the libraries contained in this release of SANE.
The exception is that, if you link a SANE library with other files
to produce an executable, this does not by itself cause the
resulting executable to be covered by the GNU General Public
License. Your use of that executable is in no way restricted on
account of linking the SANE library code into it.
This exception does not, however, invalidate any other reasons why
the executable file might be covered by the GNU General Public
License.
If you submit changes to SANE to the maintainers to be included in
a subsequent release, you agree by submitting the changes that
those changes may be distributed with this exception intact.
If you write modifications of your own for SANE, it is your choice
whether to permit this exception to apply to your modifications.
If you do not wish that, delete this exception notice.
*/
#ifndef BACKEND_GENESYS_REGISTER_CACHE_H
#define BACKEND_GENESYS_REGISTER_CACHE_H
#include "register.h"
namespace genesys {
template<class Value>
class RegisterCache
{
public:
void update(std::uint16_t address, Value value)
{
if (regs_.has_reg(address)) {
regs_.set(address, value);
} else {
regs_.init_reg(address, value);
}
}
void update(const Genesys_Register_Set& regs)
{
for (const auto& reg : regs) {
update(reg.address, reg.value);
}
}
Value get(std::uint16_t address) const
{
return regs_.get(address);
}
private:
RegisterContainer<Value> regs_;
template<class V>
friend std::ostream& operator<<(std::ostream& out, const RegisterCache<V>& cache);
};
template<class Value>
std::ostream& operator<<(std::ostream& out, const RegisterCache<Value>& cache)
{
out << cache.regs_;
return out;
}
} // namespace genesys
#endif // BACKEND_GENESYS_LINE_BUFFER_H

52
backend/genesys/scanner_interface.cpp 100644
Wyświetl plik

@ -0,0 +1,52 @@
/* sane - Scanner Access Now Easy.
Copyright (C) 2019 Povilas Kanapickas <povilas@radix.lt>
This file is part of the SANE package.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston,
MA 02111-1307, USA.
As a special exception, the authors of SANE give permission for
additional uses of the libraries contained in this release of SANE.
The exception is that, if you link a SANE library with other files
to produce an executable, this does not by itself cause the
resulting executable to be covered by the GNU General Public
License. Your use of that executable is in no way restricted on
account of linking the SANE library code into it.
This exception does not, however, invalidate any other reasons why
the executable file might be covered by the GNU General Public
License.
If you submit changes to SANE to the maintainers to be included in
a subsequent release, you agree by submitting the changes that
those changes may be distributed with this exception intact.
If you write modifications of your own for SANE, it is your choice
whether to permit this exception to apply to your modifications.
If you do not wish that, delete this exception notice.
*/
#define DEBUG_DECLARE_ONLY
#include "scanner_interface.h"
namespace genesys {
ScannerInterface::~ScannerInterface() = default;
} // namespace genesys

76
backend/genesys/scanner_interface.h 100644
Wyświetl plik

@ -0,0 +1,76 @@
/* sane - Scanner Access Now Easy.
Copyright (C) 2019 Povilas Kanapickas <povilas@radix.lt>
This file is part of the SANE package.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston,
MA 02111-1307, USA.
As a special exception, the authors of SANE give permission for
additional uses of the libraries contained in this release of SANE.
The exception is that, if you link a SANE library with other files
to produce an executable, this does not by itself cause the
resulting executable to be covered by the GNU General Public
License. Your use of that executable is in no way restricted on
account of linking the SANE library code into it.
This exception does not, however, invalidate any other reasons why
the executable file might be covered by the GNU General Public
License.
If you submit changes to SANE to the maintainers to be included in
a subsequent release, you agree by submitting the changes that
those changes may be distributed with this exception intact.
If you write modifications of your own for SANE, it is your choice
whether to permit this exception to apply to your modifications.
If you do not wish that, delete this exception notice.
*/
#ifndef BACKEND_GENESYS_SCANNER_INTERFACE_H
#define BACKEND_GENESYS_SCANNER_INTERFACE_H
#include "fwd.h"
#include <cstddef>
#include <cstdint>
namespace genesys {
// Represents an interface through which all low level operations are performed.
class ScannerInterface
{
public:
virtual ~ScannerInterface();
virtual bool is_mock() const = 0;
virtual std::uint8_t read_register(std::uint16_t address) = 0;
virtual void write_register(std::uint16_t address, std::uint8_t value) = 0;
virtual void write_registers(const Genesys_Register_Set& regs) = 0;
virtual void write_0x8c(std::uint8_t index, std::uint8_t value) = 0;
virtual void bulk_read_data(std::uint8_t addr, std::uint8_t* data, std::size_t size) = 0;
virtual void bulk_write_data(std::uint8_t addr, std::uint8_t* data, std::size_t size) = 0;
virtual void write_ahb(std::uint32_t addr, std::uint32_t size, std::uint8_t* data) = 0;
virtual std::uint16_t read_fe_register(std::uint8_t address) = 0;
virtual void write_fe_register(std::uint8_t address, std::uint16_t value) = 0;
};
} // namespace genesys
#endif

110
backend/genesys/scanner_interface_usb.cpp 100644
Wyświetl plik

@ -0,0 +1,110 @@
/* sane - Scanner Access Now Easy.
Copyright (C) 2019 Povilas Kanapickas <povilas@radix.lt>
This file is part of the SANE package.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston,
MA 02111-1307, USA.
As a special exception, the authors of SANE give permission for
additional uses of the libraries contained in this release of SANE.
The exception is that, if you link a SANE library with other files
to produce an executable, this does not by itself cause the
resulting executable to be covered by the GNU General Public
License. Your use of that executable is in no way restricted on
account of linking the SANE library code into it.
This exception does not, however, invalidate any other reasons why
the executable file might be covered by the GNU General Public
License.
If you submit changes to SANE to the maintainers to be included in
a subsequent release, you agree by submitting the changes that
those changes may be distributed with this exception intact.
If you write modifications of your own for SANE, it is your choice
whether to permit this exception to apply to your modifications.
If you do not wish that, delete this exception notice.
*/
#define DEBUG_DECLARE_ONLY
#include "scanner_interface_usb.h"
#include "low.h"
namespace genesys {
ScannerInterfaceUsb::~ScannerInterfaceUsb() = default;
ScannerInterfaceUsb::ScannerInterfaceUsb(Genesys_Device* dev) : dev_{dev} {}
bool ScannerInterfaceUsb::is_mock() const
{
return false;
}
std::uint8_t ScannerInterfaceUsb::read_register(std::uint16_t address)
{
std::uint8_t value;
sanei_genesys_read_register(dev_, address, &value);
return value;
}
void ScannerInterfaceUsb::write_register(std::uint16_t address, std::uint8_t value)
{
sanei_genesys_write_register(dev_, address, value);
}
void ScannerInterfaceUsb::write_registers(const Genesys_Register_Set& regs)
{
sanei_genesys_bulk_write_register(dev_, regs);
}
void ScannerInterfaceUsb::write_0x8c(std::uint8_t index, std::uint8_t value)
{
sanei_genesys_write_0x8c(dev_, index, value);
}
void ScannerInterfaceUsb::bulk_read_data(std::uint8_t addr, std::uint8_t* data, std::size_t size)
{
sanei_genesys_bulk_read_data(dev_, addr, data, size);
}
void ScannerInterfaceUsb::bulk_write_data(std::uint8_t addr, std::uint8_t* data, std::size_t size)
{
sanei_genesys_bulk_write_data(dev_, addr, data, size);
}
void ScannerInterfaceUsb::write_ahb(std::uint32_t addr, std::uint32_t size, std::uint8_t* data)
{
sanei_genesys_write_ahb(dev_, addr, size, data);
}
std::uint16_t ScannerInterfaceUsb::read_fe_register(std::uint8_t address)
{
std::uint16_t value;
sanei_genesys_fe_read_data(dev_, address, &value);
return value;
}
void ScannerInterfaceUsb::write_fe_register(std::uint8_t address, std::uint16_t value)
{
sanei_genesys_fe_write_data(dev_, address, value);
}
} // namespace genesys

78
backend/genesys/scanner_interface_usb.h 100644
Wyświetl plik

@ -0,0 +1,78 @@
/* sane - Scanner Access Now Easy.
Copyright (C) 2019 Povilas Kanapickas <povilas@radix.lt>
This file is part of the SANE package.
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston,
MA 02111-1307, USA.
As a special exception, the authors of SANE give permission for
additional uses of the libraries contained in this release of SANE.
The exception is that, if you link a SANE library with other files
to produce an executable, this does not by itself cause the
resulting executable to be covered by the GNU General Public
License. Your use of that executable is in no way restricted on
account of linking the SANE library code into it.
This exception does not, however, invalidate any other reasons why
the executable file might be covered by the GNU General Public
License.
If you submit changes to SANE to the maintainers to be included in
a subsequent release, you agree by submitting the changes that
those changes may be distributed with this exception intact.
If you write modifications of your own for SANE, it is your choice
whether to permit this exception to apply to your modifications.
If you do not wish that, delete this exception notice.
*/
#ifndef BACKEND_GENESYS_SCANNER_INTERFACE_USB_H
#define BACKEND_GENESYS_SCANNER_INTERFACE_USB_H
#include "scanner_interface.h"
namespace genesys {
class ScannerInterfaceUsb : public ScannerInterface
{
public:
ScannerInterfaceUsb(Genesys_Device* dev);
~ScannerInterfaceUsb() override;
bool is_mock() const override;
std::uint8_t read_register(std::uint16_t address) override;
void write_register(std::uint16_t address, std::uint8_t value) override;
void write_registers(const Genesys_Register_Set& regs) override;
void write_0x8c(std::uint8_t index, std::uint8_t value) override;
void bulk_read_data(std::uint8_t addr, std::uint8_t* data, std::size_t size) override;
void bulk_write_data(std::uint8_t addr, std::uint8_t* data, std::size_t size) override;
void write_ahb(std::uint32_t addr, std::uint32_t size, std::uint8_t* data) override;
std::uint16_t read_fe_register(std::uint8_t address) override;
void write_fe_register(std::uint8_t address, std::uint16_t value) override;
private:
Genesys_Device* dev_;
};
} // namespace genesys
#endif

2
backend/genesys/sensor.h
Wyświetl plik

@ -116,7 +116,7 @@ void serialize(Stream& str, GenesysFrontendLayout& x)
/** @brief Data structure to set up analog frontend.
The analog frontend converts analog value from image sensor to digital value. It has its own
control registers which are set up with this structure. The values are written using
sanei_genesys_fe_write_data.
fe_write_data.
*/
struct Genesys_Frontend
{