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

genesys: Move low level data writing API to scanner interface

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

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

@ -921,9 +921,7 @@ static void genesys_send_offset_and_shading(Genesys_Device* dev, const Genesys_S
start_address = 0x00;
}
sanei_genesys_set_buffer_address(dev, start_address);
dev->interface->bulk_write_data(0x3c, data, size);
dev->interface->write_buffer(0x3c, start_address, data, size);
}
// ?

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

@ -835,9 +835,7 @@ static void gl646_send_slope_table(Genesys_Device* dev, int table_nr,
table[i * 2 + 1] = slope_table[i] >> 8;
}
sanei_genesys_set_buffer_address(dev, start_address + table_nr * 0x100);
dev->interface->bulk_write_data(0x3c, table.data(), steps * 2);
dev->interface->write_buffer(0x3c, start_address + table_nr * 0x100, table.data(), steps * 2);
}
// Set values of Analog Device type frontend
@ -1974,11 +1972,7 @@ void CommandSetGl646::send_gamma_table(Genesys_Device* dev, const Genesys_Sensor
throw SaneException("invalid dpi");
}
// send address
sanei_genesys_set_buffer_address(dev, address);
// send data
dev->interface->bulk_write_data(0x3c, gamma.data(), size * 2 * 3);
dev->interface->write_buffer(0x3c, address, gamma.data(), size * 2 * 3);
}
/** @brief this function does the led calibration.
@ -3279,8 +3273,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);
dev->interface->bulk_write_data(0x3c, control, 4);
dev->interface->write_buffer(0x3c, addr, control, 4);
}
/**

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

@ -59,19 +59,6 @@
namespace genesys {
// Set address for writing data
static void gl841_set_buffer_address_gamma(Genesys_Device* dev, uint32_t addr)
{
DBG_HELPER_ARGS(dbg, "setting address to 0x%05x", addr & 0xfffffff0);
addr = addr >> 4;
dev->interface->write_register(0x5c, (addr & 0xff));
addr = addr >> 8;
dev->interface->write_register(0x5b, (addr & 0xff));
}
bool CommandSetGl841::get_gain4_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, 0x06);
@ -571,9 +558,7 @@ static void gl841_send_slope_table(Genesys_Device* dev, int table_nr,
DBG(DBG_io, "%s: %s\n", __func__, msg);
}
sanei_genesys_set_buffer_address(dev, start_address + table_nr * 0x200);
dev->interface->bulk_write_data(0x3c, table.data(), steps * 2);
dev->interface->write_buffer(0x3c, start_address + table_nr * 0x200, table.data(), steps * 2);
}
static void gl841_set_lide80_fe(Genesys_Device* dev, uint8_t set)
@ -813,9 +798,8 @@ uint8_t *table;
table=tdefault;
}
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->interface->write_gamma(0x28, 0xc000, table, 128,
ScannerInterface::FLAG_SWAP_REGISTERS);
dev->interface->write_register(0x5b, 0x00);
dev->interface->write_register(0x5c, 0x00);
}
@ -2615,11 +2599,7 @@ void CommandSetGl841::send_gamma_table(Genesys_Device* dev, const Genesys_Sensor
sanei_genesys_generate_gamma_buffer(dev, sensor, 16, 65535, size, gamma.data());
// send address
gl841_set_buffer_address_gamma (dev, 0x00000);
// send data
dev->interface->bulk_write_data(0x28, gamma.data(), size * 2 * 3);
dev->interface->write_gamma(0x28, 0x0000, gamma.data(), size * 2 * 3);
}
@ -3922,11 +3902,7 @@ void CommandSetGl841::send_shading_data(Genesys_Device* dev, const Genesys_Senso
/* old method if no SHDAREA */
if ((dev->reg.find_reg(0x01).value & REG_0x01_SHDAREA) == 0) {
// start address
sanei_genesys_set_buffer_address(dev, 0x0000);
// shading data whole line
dev->interface->bulk_write_data(0x3c, data, size);
dev->interface->write_buffer(0x3c, 0x0000, data, size);
return;
}
@ -3986,8 +3962,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);
dev->interface->bulk_write_data(0x3c, buffer.data(), pixels);
dev->interface->write_buffer(0x3c, 0x5400 * i, buffer.data(), pixels);
}
}

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

@ -61,35 +61,6 @@ static void gl843_set_buffer_address(Genesys_Device* dev, uint32_t addr)
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->interface->write_register(0x29, ((addr >> 16) & 0x1f));
dev->interface->write_register(0x2a, ((addr >> 8) & 0xff));
dev->interface->write_register(0x2b, (addr & 0xff));
}
/**
* writes a block of data to RAM
* @param dev USB device
* @param addr RAM address to write to
* @param size size of the chunk of data
* @param data pointer to the data to write
*/
static void write_data(Genesys_Device* dev, uint32_t addr, uint32_t size, uint8_t* data)
{
DBG_HELPER(dbg);
gl843_set_buffer_address(dev, addr);
// write actual data
dev->interface->bulk_write_data(0x28, data, size);
// set back address to 0
gl843_set_buffer_address(dev, 0);
}
bool CommandSetGl843::get_gain4_bit(Genesys_Register_Set* regs) const
{
GenesysRegister *r = sanei_genesys_get_address(regs, REG_0x06);
@ -705,8 +676,6 @@ gl843_init_registers (Genesys_Device * dev)
dev->calib_reg = dev->reg;
if (dev->model->model_id == ModelId::PLUSTEK_OPTICFILM_7200I) {
gl843_set_ram_address(dev, 0x03ff00);
uint8_t data[32] = {
0x8c, 0x8f, 0xc9, 0x00, 0x01, 0x00, 0x00, 0x00,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
@ -714,7 +683,8 @@ gl843_init_registers (Genesys_Device * dev)
0x6a, 0x73, 0x63, 0x68, 0x69, 0x65, 0x6e, 0x00,
};
dev->interface->bulk_write_data(0x3c, data, 32);
dev->interface->write_buffer(0x3c, 0x3ff000, data, 32,
ScannerInterface::FLAG_SWAP_REGISTERS);
}
}
@ -744,9 +714,13 @@ static void gl843_send_slope_table(Genesys_Device* dev, int table_nr,
DBG(DBG_io, "%s: %s\n", __func__, msg);
}
// slope table addresses are fixed : 0x4000, 0x4800, 0x5000, 0x5800, 0x6000
// slope table addresses are fixed : 0x40000, 0x48000, 0x50000, 0x58000, 0x60000
// XXX STEF XXX USB 1.1 ? sanei_genesys_write_0x8c (dev, 0x0f, 0x14);
write_data(dev, 0x4000 + 0x800 * table_nr, steps * 2, table.data());
dev->interface->write_gamma(0x28, 0x40000 + 0x8000 * table_nr, table.data(), steps * 2,
ScannerInterface::FLAG_SWAP_REGISTERS);
// FIXME: remove this when updating tests
gl843_set_buffer_address(dev, 0);
}
static void gl843_set_ad_fe(Genesys_Device* dev)
@ -2334,11 +2308,8 @@ void CommandSetGl843::send_gamma_table(Genesys_Device* dev, const Genesys_Sensor
gamma[i * 2 + size * 4 + 1] = (bgamma[i] >> 8) & 0xff;
}
// send address
gl843_set_buffer_address(dev, 0x0000);
// send data
dev->interface->bulk_write_data(0x28, gamma.data(), size * 2 * 3);
dev->interface->write_gamma(0x28, 0x0000, gamma.data(), size * 2 * 3,
ScannerInterface::FLAG_SWAP_REGISTERS);
}
/* this function does the led calibration by scanning one line of the calibration
@ -3372,10 +3343,8 @@ void CommandSetGl843::send_shading_data(Genesys_Device* dev, const Genesys_Senso
}
}
// send data
sanei_genesys_set_buffer_address(dev, 0);
dev->interface->bulk_write_data(0x3c, final_data.data(), count);
dev->interface->write_buffer(0x3c, 0, final_data.data(), count,
ScannerInterface::FLAG_SMALL_ADDRESS);
}
bool CommandSetGl843::needs_home_before_init_regs_for_scan(Genesys_Device* dev) const

16
backend/genesys/scanner_interface.h
Wyświetl plik

@ -54,6 +54,12 @@ namespace genesys {
class ScannerInterface
{
public:
enum Flags {
FLAG_NONE = 0,
FLAG_SWAP_REGISTERS = 1 << 0,
FLAG_SMALL_ADDRESS = 1 << 1
};
virtual ~ScannerInterface();
virtual bool is_mock() const = 0;
@ -65,6 +71,16 @@ public:
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;
// GL646, GL841, GL843 have different ways to write to RAM and to gamma tables
// FIXME: remove flags when updating tests
virtual void write_buffer(std::uint8_t type, std::uint32_t addr, std::uint8_t* data,
std::size_t size, Flags flags = FLAG_NONE) = 0;
virtual void write_gamma(std::uint8_t type, std::uint32_t addr, std::uint8_t* data,
std::size_t size, Flags flags = FLAG_NONE) = 0;
// GL845, GL846, GL847 and GL124 have a uniform way to write to RAM tables
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;

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

@ -351,10 +351,71 @@ void ScannerInterfaceUsb::bulk_write_data(std::uint8_t addr, std::uint8_t* data,
}
}
void ScannerInterfaceUsb::write_buffer(std::uint8_t type, std::uint32_t addr, std::uint8_t* data,
std::size_t size, Flags flags)
{
DBG_HELPER_ARGS(dbg, "type: 0x%02x, addr: 0x%08x, size: 0x%08zx", type, addr, size);
if (dev_->model->asic_type != AsicType::GL646 &&
dev_->model->asic_type != AsicType::GL841 &&
dev_->model->asic_type != AsicType::GL843)
{
throw SaneException("Unsupported transfer mode");
}
if (dev_->model->asic_type == AsicType::GL843) {
if (flags & FLAG_SWAP_REGISTERS) {
if (!(flags & FLAG_SMALL_ADDRESS)) {
write_register(0x29, ((addr >> 20) & 0xff));
}
write_register(0x2a, ((addr >> 12) & 0xff));
write_register(0x2b, ((addr >> 4) & 0xff));
} else {
write_register(0x2b, ((addr >> 4) & 0xff));
write_register(0x2a, ((addr >> 12) & 0xff));
if (!(flags & FLAG_SMALL_ADDRESS)) {
write_register(0x29, ((addr >> 20) & 0xff));
}
}
} else {
write_register(0x2b, ((addr >> 4) & 0xff));
write_register(0x2a, ((addr >> 12) & 0xff));
}
bulk_write_data(type, data, size);
}
void ScannerInterfaceUsb::write_gamma(std::uint8_t type, std::uint32_t addr, std::uint8_t* data,
std::size_t size, Flags flags)
{
DBG_HELPER_ARGS(dbg, "type: 0x%02x, addr: 0x%08x, size: 0x%08zx", type, addr, size);
if (dev_->model->asic_type != AsicType::GL646 &&
dev_->model->asic_type != AsicType::GL841 &&
dev_->model->asic_type != AsicType::GL843)
{
throw SaneException("Unsupported transfer mode");
}
if (flags & FLAG_SWAP_REGISTERS) {
write_register(0x5b, ((addr >> 12) & 0xff));
write_register(0x5c, ((addr >> 4) & 0xff));
} else {
write_register(0x5c, ((addr >> 4) & 0xff));
write_register(0x5b, ((addr >> 12) & 0xff));
}
bulk_write_data(type, data, size);
}
void ScannerInterfaceUsb::write_ahb(std::uint32_t addr, std::uint32_t size, std::uint8_t* data)
{
DBG_HELPER_ARGS(dbg, "size %d", static_cast<unsigned>(size));
DBG_HELPER_ARGS(dbg, "address: 0x%08x, size: %d", static_cast<unsigned>(addr),
static_cast<unsigned>(size));
if (dev_->model->asic_type != AsicType::GL845 &&
dev_->model->asic_type != AsicType::GL846 &&
dev_->model->asic_type != AsicType::GL847 &&
dev_->model->asic_type != AsicType::GL124)
{
throw SaneException("Unsupported transfer type");
}
std::uint8_t outdata[8];
outdata[0] = addr & 0xff;
outdata[1] = ((addr >> 8) & 0xff);

6
backend/genesys/scanner_interface_usb.h
Wyświetl plik

@ -64,6 +64,12 @@ public:
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_buffer(std::uint8_t type, std::uint32_t addr, std::uint8_t* data,
std::size_t size, Flags flags) override;
void write_gamma(std::uint8_t type, std::uint32_t addr, std::uint8_t* data,
std::size_t size, Flags flags) 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;

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

@ -90,6 +90,26 @@ void TestScannerInterface::bulk_write_data(std::uint8_t addr, std::uint8_t* data
(void) size;
}
void TestScannerInterface::write_buffer(std::uint8_t type, std::uint32_t addr, std::uint8_t* data,
std::size_t size, Flags flags)
{
(void) type;
(void) addr;
(void) data;
(void) size;
(void) flags;
}
void TestScannerInterface::write_gamma(std::uint8_t type, std::uint32_t addr, std::uint8_t* data,
std::size_t size, Flags flags)
{
(void) type;
(void) addr;
(void) data;
(void) size;
(void) flags;
}
void TestScannerInterface::write_ahb(std::uint32_t addr, std::uint32_t size, std::uint8_t* data)
{
(void) addr;

5
backend/genesys/test_scanner_interface.h
Wyświetl plik

@ -63,6 +63,11 @@ public:
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_buffer(std::uint8_t type, std::uint32_t addr, std::uint8_t* data,
std::size_t size, Flags flags) override;
void write_gamma(std::uint8_t type, std::uint32_t addr, std::uint8_t* data,
std::size_t size, Flags flags) 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;