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

genesys: Route sleep calls through low level scanner interface

merge-requests/240/head
Povilas Kanapickas 2019-10-26 11:38:47 +02:00
rodzic 521c042889
commit e2e3ea0947
14 zmienionych plików z 107 dodań i 102 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

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

@ -1532,11 +1532,11 @@ static void genesys_shading_calibration_impl(Genesys_Device* dev, const Genesys_
if (is_dark) {
// wait some time to let lamp to get dark
sanei_genesys_sleep_ms(200);
dev->interface->sleep_ms(200);
} else if (dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION) {
// make sure lamp is bright again
// FIXME: what about scanners that take a long time to warm the lamp?
sanei_genesys_sleep_ms(500);
dev->interface->sleep_ms(500);
}
bool start_motor = !is_dark;
@ -2986,7 +2986,7 @@ static void genesys_warmup_lamp(Genesys_Device* dev)
dev->cmd_set->end_scan(dev, &dev->reg, true);
sanei_genesys_sleep_ms(1000);
dev->interface->sleep_ms(1000);
seconds++;
dev->cmd_set->begin_scan(dev, sensor, &dev->reg, false);
@ -3043,10 +3043,9 @@ static void genesys_warmup_lamp(Genesys_Device* dev)
}
/* sleep another second before next loop */
sanei_genesys_sleep_ms(1000);
seconds++;
}
while (seconds < WARMUP_TIME);
dev->interface->sleep_ms(1000);
seconds++;
} while (seconds < WARMUP_TIME);
if (seconds >= WARMUP_TIME)
{
@ -3188,8 +3187,8 @@ static void genesys_start_scan(Genesys_Device* dev, bool lamp_off)
+ dev->reg.get8(0x3f);
do
{
// wait some time between each test to avoid overloading USB and CPU
sanei_genesys_sleep_ms(100);
// wait some time between each test to avoid overloading USB and CPU
dev->interface->sleep_ms(100);
sanei_genesys_read_feed_steps (dev, &steps);
}
while (steps < expected);
@ -3199,11 +3198,10 @@ static void genesys_start_scan(Genesys_Device* dev, bool lamp_off)
// we wait for at least one word of valid scan data
// this is also done in sanei_genesys_read_data_from_scanner -- pierre
if (!dev->model->is_sheetfed) {
do
{
sanei_genesys_sleep_ms(100);
do {
dev->interface->sleep_ms(100);
sanei_genesys_read_valid_words(dev, &steps);
}
}
while (steps < 1);
}
}

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

@ -1062,7 +1062,7 @@ static void gl124_stop_action(Genesys_Device* dev)
dev->reg.set8(REG_0x01, val);
dev->interface->write_register(REG_0x01, val);
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
loop = 10;
while (loop > 0)
@ -1079,7 +1079,7 @@ static void gl124_stop_action(Genesys_Device* dev)
return;
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
loop--;
}
@ -1199,7 +1199,7 @@ void CommandSetGl124::rewind(Genesys_Device* dev) const
begin_scan(dev, sensor, &dev->reg, true);
do
{
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
byte = dev->interface->read_register(REG_0x100);
} while (byte & REG_0x100_MOTMFLG);
end_scan(dev, &dev->reg, true);
@ -1235,7 +1235,7 @@ void CommandSetGl124::slow_back_home(Genesys_Device* dev, bool wait_until_home)
{
sanei_genesys_print_status (val);
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
// second is reliable
val = sanei_genesys_get_status(dev);
@ -1321,7 +1321,7 @@ void CommandSetGl124::slow_back_home(Genesys_Device* dev, bool wait_until_home)
dev->scanhead_position_in_steps = 0;
return;
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
++loop;
}
@ -1605,11 +1605,11 @@ void CommandSetGl124::wait_for_motor_stop(Genesys_Device* dev) const
return;
do {
sanei_genesys_sleep_ms(10);
dev->interface->sleep_ms(10);
val = sanei_genesys_get_status(dev);
val40 = dev->interface->read_register(REG_0x100);
} while ((val & MOTORENB) ||(val40 & REG_0x100_MOTMFLG));
sanei_genesys_sleep_ms(50);
dev->interface->sleep_ms(50);
}
/** @brief set up registers for the actual scan

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

@ -887,7 +887,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->interface->sleep_ms(200);
dev->interface->write_register(0x50, 0x00);
dev->frontend = dev->frontend_initial;
dev->interface->write_fe_register(0x01, dev->frontend.regs.get_value(0x01));
@ -1156,9 +1156,9 @@ void CommandSetGl646::load_document(Genesys_Device* dev) const
{
DBG(DBG_warn, "%s: no paper detected\n", __func__);
}
sanei_genesys_sleep_ms(200);
count++;
}
dev->interface->sleep_ms(200);
count++;
}
while (((val & 0x04) != 0x04) && (count < 300)); /* 1 min time out */
if (count == 300)
{
@ -1210,7 +1210,7 @@ void CommandSetGl646::load_document(Genesys_Device* dev) const
do
{
val = sanei_genesys_get_status(dev);
sanei_genesys_sleep_ms(200);
dev->interface->sleep_ms(200);
count++;
} while ((val & REG_0x41_MOTMFLG) && (count < 300));
@ -1332,7 +1332,7 @@ void CommandSetGl646::eject_document(Genesys_Device* dev) const
/* wait for motor to stop */
do
{
sanei_genesys_sleep_ms(200);
dev->interface->sleep_ms(200);
state = sanei_genesys_get_status(dev);
}
while (state & REG_0x41_MOTMFLG);
@ -1384,7 +1384,7 @@ void CommandSetGl646::eject_document(Genesys_Device* dev) const
state = sanei_genesys_get_status(dev);
print_status (state);
sanei_genesys_sleep_ms(200);
dev->interface->sleep_ms(200);
count++;
} while (((state & REG_0x41_HOMESNR) == 0) && (count < 150));
@ -1469,9 +1469,9 @@ static void end_scan_impl(Genesys_Device* dev, Genesys_Register_Set* reg, bool c
break; /* leave for loop */
}
sanei_genesys_sleep_ms(100);
}
}
dev->interface->sleep_ms(100);
}
}
}
else /* flat bed scanners */
{
@ -1500,9 +1500,9 @@ static void end_scan_impl(Genesys_Device* dev, Genesys_Register_Set* reg, bool c
break; /* leave while loop */
}
sanei_genesys_sleep_ms(100);
}
}
dev->interface->sleep_ms(100);
}
}
}
DBG(DBG_proc, "%s: end (i=%u)\n", __func__, i);
@ -1545,7 +1545,7 @@ void CommandSetGl646::slow_back_home(Genesys_Device* dev, bool wait_until_home)
/* stop motor if needed */
if (val & REG_0x41_MOTMFLG) {
gl646_stop_motor(dev);
sanei_genesys_sleep_ms(200);
dev->interface->sleep_ms(200);
}
/* when scanhead is moving then wait until scanhead stops or timeout */
@ -1561,7 +1561,7 @@ void CommandSetGl646::slow_back_home(Genesys_Device* dev, bool wait_until_home)
DBG(DBG_info, "%s: already at home and not moving\n", __func__);
return;
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
}
if (!i) /* the loop counted down to 0, scanner still is busy */
@ -1625,12 +1625,12 @@ void CommandSetGl646::slow_back_home(Genesys_Device* dev, bool wait_until_home)
{
DBG(DBG_info, "%s: reached home position\n", __func__);
DBG(DBG_proc, "%s: end\n", __func__);
sanei_genesys_sleep_ms(500);
return;
}
sanei_genesys_sleep_ms(100);
++loop;
}
dev->interface->sleep_ms(500);
return;
}
dev->interface->sleep_ms(100);
++loop;
}
// when we come here then the scanner needed too much time for this, so we better
// stop the motor
@ -2750,7 +2750,7 @@ static void gl646_repark_head(Genesys_Device* dev)
expected = dev->reg.get24(REG_FEEDL);
do
{
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
sanei_genesys_read_feed_steps (dev, &steps);
}
while (steps < expected);
@ -2817,7 +2817,7 @@ void CommandSetGl646::init(Genesys_Device* dev) const
// ASIC reset
dev->interface->write_register(0x0e, 0x00);
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
// Write initial registers
dev->interface->write_registers(dev->reg);

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

@ -1702,7 +1702,7 @@ void CommandSetGl841::save_power(Genesys_Device* dev, bool enable) const
uint8_t val = dev->interface->read_register(REG_0x6D);
dev->interface->write_register(REG_0x6D, val | 0x80);
sanei_genesys_sleep_ms(1);
dev->interface->sleep_ms(1);
/*enable GPIO9*/
val = dev->interface->read_register(REG_0x6C);
@ -1716,7 +1716,7 @@ void CommandSetGl841::save_power(Genesys_Device* dev, bool enable) const
val = dev->interface->read_register(REG_0x6B);
dev->interface->write_register(REG_0x6B, val & ~REG_0x6B_GPO18);
sanei_genesys_sleep_ms(1);
dev->interface->sleep_ms(1);
val = dev->interface->read_register(REG_0x6D);
dev->interface->write_register(REG_0x6D, val & ~0x80);
@ -1745,7 +1745,7 @@ void CommandSetGl841::save_power(Genesys_Device* dev, bool enable) const
uint8_t val = dev->interface->read_register(REG_0x6D);
dev->interface->write_register(REG_0x6D, val | 0x80);
sanei_genesys_sleep_ms(10);
dev->interface->sleep_ms(10);
/*disable GPIO9*/
val = dev->interface->read_register(REG_0x6C);
@ -1894,8 +1894,8 @@ static void gl841_stop_action(Genesys_Device* dev)
return;
}
sanei_genesys_sleep_ms(100);
loop--;
dev->interface->sleep_ms(100);
loop--;
}
throw SaneException(SANE_STATUS_IO_ERROR, "could not stop motor");
@ -1968,7 +1968,7 @@ void CommandSetGl841::eject_document(Genesys_Device* dev) const
DBG(DBG_proc, "%s: finished\n", __func__);
break;
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
--loop;
}
@ -2005,7 +2005,7 @@ void CommandSetGl841::eject_document(Genesys_Device* dev) const
break;
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
++loop;
}
@ -2028,10 +2028,10 @@ void CommandSetGl841::load_document(Genesys_Device* dev) const
dev->document = true;
// give user some time to place document correctly
sanei_genesys_sleep_ms(1000);
dev->interface->sleep_ms(1000);
break;
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
--loop;
}
@ -2195,7 +2195,7 @@ static void gl841_feed(Genesys_Device* dev, int steps)
dev->scanhead_position_in_steps += steps;
return;
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
++loop;
}
@ -2240,7 +2240,7 @@ void CommandSetGl841::slow_back_home(Genesys_Device* dev, bool wait_until_home)
{
sanei_genesys_print_status (val);
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
// second is reliable
val = sanei_genesys_get_status(dev);
@ -2307,7 +2307,7 @@ void CommandSetGl841::slow_back_home(Genesys_Device* dev, bool wait_until_home)
DBG(DBG_proc, "%s: finished\n", __func__);
return;
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
++loop;
}

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

@ -1331,7 +1331,7 @@ static void gl843_stop_action_no_move(Genesys_Device* dev, Genesys_Register_Set*
val &= ~REG_0x01_SCAN;
reg->set8(REG_0x01, val);
dev->interface->write_register(REG_0x01, val);
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
}
static void gl843_stop_action(Genesys_Device* dev)
@ -1361,7 +1361,7 @@ static void gl843_stop_action(Genesys_Device* dev)
dev->reg.set8(REG_0x01, val);
dev->interface->write_register(REG_0x01, val);
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
loop = 10;
while (loop > 0)
@ -1380,7 +1380,7 @@ static void gl843_stop_action(Genesys_Device* dev)
return;
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
loop--;
}
@ -1803,7 +1803,7 @@ static void gl843_park_xpa_lamp(Genesys_Device* dev)
return;
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
++loop;
}
@ -1831,7 +1831,7 @@ void CommandSetGl843::slow_back_home(Genesys_Device* dev, bool wait_until_home)
// first read gives HOME_SENSOR true
val = sanei_genesys_get_status(dev);
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
// second is reliable
val = sanei_genesys_get_status(dev);
@ -1911,7 +1911,7 @@ void CommandSetGl843::slow_back_home(Genesys_Device* dev, bool wait_until_home)
DBG(DBG_proc, "%s: finished\n", __func__);
return;
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
++loop;
}
@ -2103,7 +2103,7 @@ static void gl843_feed(Genesys_Device* dev, unsigned int steps)
} while (!(val & FEEDFSH));
// looks like the scanner locks up if we scan immediately after feeding
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
}
// init registers for shading calibration shading calibration is done at dpihw
@ -3024,7 +3024,7 @@ void CommandSetGl843::asic_boot(Genesys_Device* dev, bool cold) const
gl843_init_gpio(dev);
gl843_feed (dev, 300);
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
}
/* *

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

@ -308,9 +308,8 @@ static void gl846_set_adi_fe(Genesys_Device* dev, uint8_t set)
// wait for FE to be ready
std::uint8_t val8 = sanei_genesys_get_status(dev);
while (val8 & REG_0x41_FEBUSY)
{
sanei_genesys_sleep_ms(10);
while (val8 & REG_0x41_FEBUSY) {
dev->interface->sleep_ms(10);
val8 = sanei_genesys_get_status(dev);
};
@ -898,7 +897,7 @@ static void gl846_stop_action(Genesys_Device* dev)
val &= ~REG_0x01_SCAN;
dev->reg.set8(REG_0x01, val);
dev->interface->write_register(REG_0x01, val);
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
loop = 10;
while (loop > 0)
@ -917,7 +916,7 @@ static void gl846_stop_action(Genesys_Device* dev)
return;
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
loop--;
}
@ -990,7 +989,7 @@ void CommandSetGl846::slow_back_home(Genesys_Device* dev, bool wait_until_home)
{
sanei_genesys_print_status (val);
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
// second is reliable
val = sanei_genesys_get_status(dev);
@ -1078,7 +1077,7 @@ void CommandSetGl846::slow_back_home(Genesys_Device* dev, bool wait_until_home)
dev->scanhead_position_in_steps = 0;
return;
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
++loop;
}

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

@ -331,7 +331,7 @@ static void gl847_set_ad_fe(Genesys_Device* dev, uint8_t set)
// wait for FE to be ready
std::uint8_t val8 = sanei_genesys_get_status(dev);
while (val8 & REG_0x41_FEBUSY) {
sanei_genesys_sleep_ms(10);
dev->interface->sleep_ms(10);
val8 = sanei_genesys_get_status(dev);
};
@ -904,7 +904,7 @@ static void gl847_stop_action(Genesys_Device* dev)
dev->reg.set8(REG_0x01, val);
dev->interface->write_register(REG_0x01, val);
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
loop = 10;
while (loop > 0)
@ -923,7 +923,7 @@ static void gl847_stop_action(Genesys_Device* dev)
return;
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
loop--;
}
@ -997,7 +997,7 @@ static void gl847_rewind(Genesys_Device* dev)
gl847_begin_scan(dev, dev->reg, true);
do
{
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
byte = dev->interface->read_register(REG_0x40);
} while (byte & REG_0x40_MOTMFLG);
@ -1035,7 +1035,7 @@ void CommandSetGl847::slow_back_home(Genesys_Device* dev, bool wait_until_home)
{
sanei_genesys_print_status (val);
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
// second is reliable
val = sanei_genesys_get_status(dev);
@ -1121,7 +1121,7 @@ void CommandSetGl847::slow_back_home(Genesys_Device* dev, bool wait_until_home)
dev->scanhead_position_in_steps = 0;
return;
}
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
++loop;
}

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

@ -394,14 +394,14 @@ bool sanei_genesys_is_buffer_empty(Genesys_Device* dev)
DBG_HELPER(dbg);
uint8_t val = 0;
sanei_genesys_sleep_ms(1);
dev->interface->sleep_ms(1);
val = sanei_genesys_get_status(dev);
if (dev->cmd_set->test_buffer_empty_bit(val)) {
/* fix timing issue on USB3 (or just may be too fast) hardware
* spotted by John S. Weber <jweber53@gmail.com>
*/
sanei_genesys_sleep_ms(1);
dev->interface->sleep_ms(1);
DBG(DBG_io2, "%s: buffer is empty\n", __func__);
return true;
}
@ -423,7 +423,7 @@ void wait_until_buffer_non_empty(Genesys_Device* dev, bool check_status_twice)
}
bool empty = sanei_genesys_is_buffer_empty(dev);
sanei_genesys_sleep_ms(10);
dev->interface->sleep_ms(10);
if (!empty)
return;
}
@ -439,7 +439,7 @@ void wait_until_has_valid_words(Genesys_Device* dev)
sanei_genesys_read_valid_words(dev, &words);
if (words != 0)
break;
sanei_genesys_sleep_ms(sleep_time_ms);
dev->interface->sleep_ms(sleep_time_ms);
}
if (words == 0) {
@ -1589,7 +1589,7 @@ void sanei_genesys_wait_for_home(Genesys_Device* dev)
// read initial status, if head isn't at home and motor is on we are parking, so we wait.
// gl847/gl124 need 2 reads for reliable results
val = sanei_genesys_get_status(dev);
sanei_genesys_sleep_ms(10);
dev->interface->sleep_ms(10);
val = sanei_genesys_get_status(dev);
/* if at home, return */
@ -1604,7 +1604,7 @@ void sanei_genesys_wait_for_home(Genesys_Device* dev)
unsigned elapsed_ms = 0;
do
{
sanei_genesys_sleep_ms(100);
dev->interface->sleep_ms(100);
elapsed_ms += 100;
val = sanei_genesys_get_status(dev);
@ -1995,19 +1995,6 @@ void sanei_genesys_load_lut(unsigned char* lut,
}
}
void sanei_genesys_usleep(unsigned int useconds)
{
if (sanei_usb_is_replay_mode_enabled()) {
return;
}
usleep(useconds);
}
void sanei_genesys_sleep_ms(unsigned int milliseconds)
{
sanei_genesys_usleep(milliseconds * 1000);
}
static std::unique_ptr<std::vector<std::function<void()>>> s_functions_run_at_backend_exit;
void add_function_to_run_at_backend_exit(std::function<void()> function)

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

@ -528,12 +528,6 @@ inline T clamp(const T& value, const T& lo, const T& hi)
/* ASIC specific functions declarations */
/*---------------------------------------------------------------------------*/
// same as usleep, except that it does nothing if testing mode is enabled
extern void sanei_genesys_usleep(unsigned int useconds);
// same as sanei_genesys_usleep just that the duration is in milliseconds
extern void sanei_genesys_sleep_ms(unsigned int milliseconds);
void add_function_to_run_at_backend_exit(std::function<void()> function);
// calls functions added via add_function_to_run_at_backend_exit() in reverse order of being

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

@ -88,6 +88,14 @@ public:
virtual IUsbDevice& get_usb_device() = 0;
// sleeps the specified number of microseconds. Will not sleep if testing mode is enabled.
virtual void sleep_us(unsigned microseconds) = 0;
void sleep_ms(unsigned milliseconds)
{
sleep_us(milliseconds * 1000);
}
virtual void record_test_message(const char* msg) = 0;
};

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

@ -45,6 +45,7 @@
#include "scanner_interface_usb.h"
#include "low.h"
#include <thread>
namespace genesys {
@ -480,6 +481,14 @@ IUsbDevice& ScannerInterfaceUsb::get_usb_device()
return usb_dev_;
}
void ScannerInterfaceUsb::sleep_us(unsigned microseconds)
{
if (sanei_usb_is_replay_mode_enabled()) {
return;
}
std::this_thread::sleep_for(std::chrono::microseconds{microseconds});
}
void ScannerInterfaceUsb::record_test_message(const char* msg)
{
sanei_usb_testing_record_message(msg);

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

@ -76,9 +76,12 @@ public:
std::uint16_t read_fe_register(std::uint8_t address) override;
void write_fe_register(std::uint8_t address, std::uint16_t value) override;
IUsbDevice& get_usb_device() override;
void sleep_us(unsigned microseconds) override;
void record_test_message(const char* msg) override;
virtual IUsbDevice& get_usb_device() override;
private:
Genesys_Device* dev_;
UsbDevice usb_dev_;

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

@ -132,6 +132,11 @@ IUsbDevice& TestScannerInterface::get_usb_device()
return usb_dev_;
}
void TestScannerInterface::sleep_us(unsigned microseconds)
{
(void) microseconds;
}
void TestScannerInterface::record_test_message(const char* msg)
{
last_test_message_ = msg;

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

@ -76,6 +76,8 @@ public:
IUsbDevice& get_usb_device() override;
void sleep_us(unsigned microseconds) override;
void record_test_message(const char* msg) override;
const std::string& last_test_message() const;