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

genesys: Return errors as exceptions from *bulk_write_register()

merge-requests/101/head
Povilas Kanapickas 2019-07-14 23:40:45 +03:00
rodzic 0dc3342be1
commit e388fc5058
9 zmienionych plików z 244 dodań i 417 usunięć
Pokaż statystyki Ściągnij plik aktualizacji Ściągnij plik porównania Expand all files Collapse all files

26
backend/genesys.cc
Wyświetl plik

@ -1807,13 +1807,7 @@ genesys_dark_shading_calibration(Genesys_Device * dev, const Genesys_Sensor& sen
sanei_genesys_set_motor_power(dev->calib_reg, motor);
}
status =
dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
// wait some time to let lamp to get dark
sanei_genesys_sleep_ms(200);
@ -2010,13 +2004,7 @@ genesys_white_shading_calibration (Genesys_Device * dev, const Genesys_Sensor& s
sanei_genesys_set_lamp_power(dev, sensor, dev->calib_reg, true);
sanei_genesys_set_motor_power(dev->calib_reg, motor);
status =
dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
if (dev->model->flags & GENESYS_FLAG_DARK_CALIBRATION)
sanei_genesys_sleep_ms(500); // make sure lamp is bright again
@ -2126,13 +2114,7 @@ genesys_dark_white_shading_calibration(Genesys_Device * dev, const Genesys_Senso
sanei_genesys_set_lamp_power(dev, sensor, dev->calib_reg, true);
sanei_genesys_set_motor_power(dev->calib_reg, motor);
status =
dev->model->cmd_set->bulk_write_register(dev, dev->calib_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
status = dev->model->cmd_set->begin_scan(dev, sensor, &dev->calib_reg, SANE_FALSE);
@ -3944,14 +3926,8 @@ genesys_start_scan (Genesys_Device * dev, SANE_Bool lamp_off)
}
}
/* now send registers for scan */
status =
// now send registers for scan
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers, status = %d\n", __func__, status);
return status;
}
/* start effective scan */
status = dev->model->cmd_set->begin_scan(dev, sensor, &dev->reg, SANE_TRUE);

81
backend/genesys_gl124.cc
Wyświetl plik

@ -1941,7 +1941,7 @@ gl124_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
r = sanei_genesys_get_address(&local_reg, REG02);
r->value |= REG02_MTRREV;
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
dev->model->cmd_set->bulk_write_register(dev, local_reg);
RIE(gl124_setup_scan_gpio(dev,resolution));
@ -1952,10 +1952,11 @@ gl124_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
try {
gl124_stop_action (dev);
} catch (...) {}
try {
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
} catch (...) {}
});
throw;
}
if (status != SANE_STATUS_GOOD) {
@ -1963,8 +1964,11 @@ gl124_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
try {
gl124_stop_action (dev);
} catch (...) {}
/* restore original registers */
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
});
return status;
}
@ -2071,17 +2075,31 @@ gl124_feed (Genesys_Device * dev, unsigned int steps, int reverse)
r->value |= REG02_MTRREV;
}
/* send registers */
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
// send registers
dev->model->cmd_set->bulk_write_register(dev, local_reg);
try {
status = gl124_start_action (dev);
} catch (...) {
catch_all_exceptions(__func__, [&]() { gl124_stop_action (dev); });
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
});
throw;
}
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus (status));
gl124_stop_action (dev);
catch_all_exceptions(__func__, [&](){ gl124_stop_action (dev); });
/* restore original registers */
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
});
return status;
}
@ -2146,13 +2164,8 @@ gl124_search_start_position (Genesys_Device * dev)
return status;
}
/* send to scanner */
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
// send to scanner
dev->model->cmd_set->bulk_write_register(dev, local_reg);
size = pixels * dev->model->search_lines;
@ -2253,12 +2266,7 @@ gl124_init_regs_for_coarse_calibration(Genesys_Device* dev, const Genesys_Sensor
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);
status = dev->model->cmd_set->bulk_write_register(dev, regs);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
dev->model->cmd_set->bulk_write_register(dev, regs);
return SANE_STATUS_GOOD;
}
@ -2336,14 +2344,7 @@ gl124_init_regs_for_shading(Genesys_Device * dev, const Genesys_Sensor& sensor,
dev->scanhead_position_in_steps += dev->calib_lines + move;
status = dev->model->cmd_set->bulk_write_register(dev, regs);
if (status != SANE_STATUS_GOOD)
{
DBG (DBG_error,
"%s: failed to bulk write registers: %s\n", __func__,
sane_strstatus (status));
return status;
}
dev->model->cmd_set->bulk_write_register(dev, regs);
return SANE_STATUS_GOOD;
}
@ -2624,8 +2625,8 @@ move_to_calibration_area (Genesys_Device * dev, const Genesys_Sensor& sensor,
size = pixels * 3;
std::vector<uint8_t> line(size);
/* write registers and scan data */
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
// write registers and scan data
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG (DBG_info, "%s: starting line reading\n", __func__);
RIE(gl124_begin_scan (dev, sensor, &regs, SANE_TRUE));
@ -2732,8 +2733,8 @@ gl124_led_calibration (Genesys_Device * dev, Genesys_Sensor& sensor, Genesys_Reg
sanei_genesys_set_triple(&regs,REG_EXPG,exp[1]);
sanei_genesys_set_triple(&regs,REG_EXPB,exp[2]);
/* write registers and scan data */
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
// write registers and scan data
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting line reading\n", __func__);
RIE(gl124_begin_scan (dev, sensor, &regs, SANE_TRUE));
@ -2913,7 +2914,7 @@ gl124_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
dev->frontend.set_offset(2, bottom);
RIE(gl124_set_fe(dev, sensor, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
RIE(gl124_begin_scan(dev, sensor, &regs, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size));
@ -2933,7 +2934,7 @@ gl124_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
dev->frontend.set_offset(1, top);
dev->frontend.set_offset(2, top);
RIE(gl124_set_fe(dev, sensor, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl124_begin_scan(dev, sensor, &regs, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner (dev, second_line.data(), total_size));
@ -2953,7 +2954,7 @@ gl124_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
/* scan with no move */
RIE(gl124_set_fe(dev, sensor, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl124_begin_scan(dev, sensor, &regs, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size));
@ -3073,7 +3074,7 @@ gl124_coarse_gain_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor
return status;
}
RIE (dev->model->cmd_set->bulk_write_register(dev, regs));
dev->model->cmd_set->bulk_write_register(dev, regs);
total_size = pixels * channels * (16/bpp) * lines;
@ -3205,7 +3206,7 @@ gl124_init_regs_for_warmup (Genesys_Device * dev,
*total_size = num_pixels * 3 * 1; /* colors * bytes_per_color * scan lines */
sanei_genesys_set_motor_power(*reg, false);
RIE (dev->model->cmd_set->bulk_write_register(dev, *reg));
dev->model->cmd_set->bulk_write_register(dev, *reg);
return SANE_STATUS_GOOD;
}
@ -3368,8 +3369,8 @@ gl124_boot (Genesys_Device * dev, SANE_Bool cold)
/* Set default values for registers */
gl124_init_registers (dev);
/* Write initial registers */
RIE (dev->model->cmd_set->bulk_write_register(dev, dev->reg));
// Write initial registers
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
/* tune reg 0B */
val = REG0B_30MHZ | REG0B_ENBDRAM | REG0B_64M;

62
backend/genesys_gl646.cc
Wyświetl plik

@ -1769,11 +1769,7 @@ gl646_set_powersaving (Genesys_Device * dev, int delay /* in minutes */ )
local_reg.find_reg(0x38).value = exposure_time / 256;
local_reg.find_reg(0x39).value = exposure_time & 255;
status = sanei_genesys_bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD) {
DBG(DBG_error, "%s: Failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_bulk_write_register(dev, local_reg);
return status;
}
@ -1882,12 +1878,7 @@ gl646_load_document (Genesys_Device * dev)
DBG(DBG_error, "%s: failed to send slope table 1: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_bulk_write_register(dev, regs);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_bulk_write_register(dev, regs);
status = gl646_start_motor (dev);
if (status != SANE_STATUS_GOOD)
@ -1922,13 +1913,7 @@ gl646_load_document (Genesys_Device * dev)
regs.set8(0x02, 0x71);
regs.set8(0x3f, 1);
regs.set8(0x6b, 8);
status = sanei_genesys_bulk_write_register(dev, regs);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write idle registers: %s\n", __func__,
sane_strstatus(status));
return status;
}
sanei_genesys_bulk_write_register(dev, regs);
return status;
}
@ -2106,12 +2091,7 @@ gl646_eject_document (Genesys_Device * dev)
DBG(DBG_error, "%s: failed to send slope table 1: %s\n", __func__, sane_strstatus(status));
return status;
}
status = sanei_genesys_bulk_write_register(dev, regs);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_bulk_write_register(dev, regs);
status = gl646_start_motor (dev);
if (status != SANE_STATUS_GOOD)
@ -2165,13 +2145,7 @@ gl646_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Re
local_reg.init_reg(0x0f, 0x00); // do not start motor yet
}
status = sanei_genesys_bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_bulk_write_register(dev, local_reg);
return status;
}
@ -2413,12 +2387,10 @@ gl646_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
/* write scan registers */
try {
status = sanei_genesys_bulk_write_register(dev, dev->reg);
sanei_genesys_bulk_write_register(dev, dev->reg);
} catch (...) {
DBG(DBG_error, "%s: failed to bulk write registers\n", __func__);
}
if (status != SANE_STATUS_GOOD)
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
/* registers are restored to an iddl state, give up if no head to park */
if (dev->model->is_sheetfed == SANE_TRUE)
@ -3701,7 +3673,7 @@ gl646_init_regs_for_warmup (Genesys_Device * dev,
/* now registers are ok, write them to scanner */
RIE (gl646_set_fe(dev, sensor, AFE_SET, settings.xres));
RIE(sanei_genesys_bulk_write_register(dev, *local_reg));
sanei_genesys_bulk_write_register(dev, *local_reg);
return status;
}
@ -3747,12 +3719,7 @@ gl646_repark_head (Genesys_Device * dev)
/* TODO seems wrong ... no effective scan */
dev->reg.find_reg(0x01).value &= ~REG01_SCAN;
status = sanei_genesys_bulk_write_register(dev, dev->reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to send registers: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_bulk_write_register(dev, dev->reg);
/* start scan */
status = gl646_begin_scan(dev, sensor, &dev->reg, SANE_TRUE);
@ -3850,8 +3817,8 @@ gl646_init (Genesys_Device * dev)
sanei_genesys_write_register(dev, 0x0e, 0x00);
sanei_genesys_sleep_ms(100);
/* Write initial registers */
RIE(sanei_genesys_bulk_write_register(dev, dev->reg));
// Write initial registers
sanei_genesys_bulk_write_register(dev, dev->reg);
/* Test ASIC and RAM */
if (!(dev->model->flags & GENESYS_FLAG_LAZY_INIT))
@ -4104,13 +4071,8 @@ simple_scan (Genesys_Device * dev, const Genesys_Sensor& sensor,
dev->reg.find_reg(0x02).value &= ~REG02_AGOHOME;
}
/* write scan registers */
status = sanei_genesys_bulk_write_register(dev, dev->reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
// write scan registers
sanei_genesys_bulk_write_register(dev, dev->reg);
/* starts scan */
status = gl646_begin_scan(dev, sensor, &dev->reg, move);

133
backend/genesys_gl841.cc
Wyświetl plik

@ -2724,9 +2724,7 @@ gl841_set_powersaving (Genesys_Device * dev,
local_reg.set8(0x38, exposure_time >> 8);
local_reg.set8(0x39, exposure_time & 255); /* lowbyte */
status = sanei_genesys_bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
sanei_genesys_bulk_write_register(dev, local_reg);
return status;
}
@ -2744,11 +2742,10 @@ gl841_stop_action (Genesys_Device * dev)
{
DBG_HELPER(dbg);
Genesys_Register_Set local_reg;
SANE_Status status = SANE_STATUS_GOOD;
uint8_t val40, val;
unsigned int loop;
status = sanei_genesys_get_status (dev, &val);
sanei_genesys_get_status (dev, &val);
if (DBG_LEVEL >= DBG_io)
{
sanei_genesys_print_status (val);
@ -2768,12 +2765,7 @@ gl841_stop_action (Genesys_Device * dev)
gl841_init_optical_regs_off(&local_reg);
gl841_init_motor_regs_off(&local_reg,0);
status = sanei_genesys_bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_bulk_write_register(dev, 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
@ -2856,12 +2848,7 @@ gl841_eject_document (Genesys_Device * dev)
gl841_init_motor_regs(dev, sensor, &local_reg,
65536,MOTOR_ACTION_FEED,0);
status = sanei_genesys_bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_bulk_write_register(dev, local_reg);
try {
status = gl841_start_action (dev);
@ -2870,10 +2857,11 @@ gl841_eject_document (Genesys_Device * dev)
try {
gl841_stop_action(dev);
} catch (...) {}
try {
// restore original registers
catch_all_exceptions(__func__, [&]()
{
sanei_genesys_bulk_write_register(dev, dev->reg);
} catch (...) {}
});
throw;
}
@ -2881,8 +2869,11 @@ gl841_eject_document (Genesys_Device * dev)
{
DBG(DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus(status));
gl841_stop_action (dev);
/* send original registers */
// restore original registers
catch_all_exceptions(__func__, [&]()
{
sanei_genesys_bulk_write_register(dev, dev->reg);
});
return status;
}
@ -3119,12 +3110,7 @@ gl841_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Re
local_reg.init_reg(0x0f, 0x00);
}
status = sanei_genesys_bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_bulk_write_register(dev, local_reg);
return status;
}
@ -3181,12 +3167,7 @@ gl841_feed (Genesys_Device * dev, int steps)
gl841_init_motor_regs(dev, sensor, &local_reg, steps,MOTOR_ACTION_FEED,0);
status = sanei_genesys_bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_bulk_write_register(dev, local_reg);
try {
status = gl841_start_action (dev);
@ -3195,10 +3176,11 @@ gl841_feed (Genesys_Device * dev, int steps)
try {
gl841_stop_action (dev);
} catch (...) {}
try {
// send original registers
// restore original registers
catch_all_exceptions(__func__, [&]()
{
sanei_genesys_bulk_write_register(dev, dev->reg);
} catch (...) {}
});
throw;
}
@ -3206,8 +3188,11 @@ gl841_feed (Genesys_Device * dev, int steps)
{
DBG(DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus(status));
gl841_stop_action (dev);
/* send original registers */
// restore original registers
catch_all_exceptions(__func__, [&]()
{
sanei_genesys_bulk_write_register(dev, dev->reg);
});
return status;
}
@ -3331,7 +3316,7 @@ gl841_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
r = sanei_genesys_get_address(&local_reg, REG01);
r->value &= ~REG01_SCAN;
RIE (sanei_genesys_bulk_write_register(dev, local_reg));
sanei_genesys_bulk_write_register(dev, local_reg);
try {
status = gl841_start_action (dev);
@ -3340,9 +3325,11 @@ gl841_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
try {
gl841_stop_action(dev);
} catch (...) {}
try {
// restore original registers
catch_all_exceptions(__func__, [&]()
{
sanei_genesys_bulk_write_register(dev, dev->reg);
} catch (...) {}
});
throw;
}
@ -3350,8 +3337,11 @@ gl841_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
{
DBG(DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus(status));
gl841_stop_action (dev);
/* send original registers */
// restore original registers
catch_all_exceptions(__func__, [&]()
{
sanei_genesys_bulk_write_register(dev, dev->reg);
});
return status;
}
@ -3435,13 +3425,8 @@ gl841_search_start_position (Genesys_Device * dev)
return status;
}
/* send to scanner */
status = sanei_genesys_bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
// send to scanner
sanei_genesys_bulk_write_register(dev, local_reg);
size = pixels * dev->model->search_lines;
@ -3542,13 +3527,7 @@ gl841_init_regs_for_coarse_calibration(Genesys_Device * dev, const Genesys_Senso
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);
status = sanei_genesys_bulk_write_register(dev, regs);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_bulk_write_register(dev, regs);
/* if (DBG_LEVEL >= DBG_info)
sanei_gl841_print_registers (regs);*/
@ -3623,12 +3602,7 @@ gl841_init_regs_for_shading(Genesys_Device * dev, const Genesys_Sensor& sensor,
dev->calib_pixels = dev->current_setup.pixels;
dev->scanhead_position_in_steps += dev->calib_lines + starty;
status = sanei_genesys_bulk_write_register(dev, regs);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_bulk_write_register(dev, regs);
return SANE_STATUS_GOOD;
}
@ -3859,7 +3833,7 @@ gl841_led_calibration (Genesys_Device * dev, Genesys_Sensor& sensor, Genesys_Reg
return status;
}
RIE(sanei_genesys_bulk_write_register(dev, regs));
sanei_genesys_bulk_write_register(dev, regs);
num_pixels = dev->current_setup.pixels;
@ -3898,7 +3872,7 @@ gl841_led_calibration (Genesys_Device * dev, Genesys_Sensor& sensor, Genesys_Reg
sanei_genesys_write_register(dev, 0x14, (sensor.exposure.blue >> 8) & 0xff);
sanei_genesys_write_register(dev, 0x15, sensor.exposure.blue & 0xff);
RIE(sanei_genesys_bulk_write_register(dev, regs));
sanei_genesys_bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting line reading\n", __func__);
RIE(gl841_begin_scan(dev, sensor, &regs, SANE_TRUE));
@ -4228,7 +4202,7 @@ gl841_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
do {
RIE(sanei_genesys_bulk_write_register(dev, regs));
sanei_genesys_bulk_write_register(dev, regs);
for (j=0; j < channels; j++) {
off[j] = (offh[j]+offl[j])/2;
@ -4357,7 +4331,7 @@ gl841_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
}
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(sanei_genesys_bulk_write_register(dev, regs));
sanei_genesys_bulk_write_register(dev, regs);
RIE(gl841_begin_scan(dev, sensor, &regs, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner (dev, second_line.data(), total_size));
@ -4575,7 +4549,7 @@ gl841_coarse_gain_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor
return status;
}
RIE(sanei_genesys_bulk_write_register(dev, regs));
sanei_genesys_bulk_write_register(dev, regs);
num_pixels = dev->current_setup.pixels;
@ -4742,7 +4716,7 @@ gl841_init_regs_for_warmup (Genesys_Device * dev,
*total_size = num_pixels * 3 * 2 * 1; /* colors * bytes_per_color * scan lines */
RIE(sanei_genesys_bulk_write_register(dev, *local_reg));
sanei_genesys_bulk_write_register(dev, *local_reg);
return status;
}
@ -4850,8 +4824,8 @@ gl841_init (Genesys_Device * dev)
/* Set default values for registers */
gl841_init_registers (dev);
/* Write initial registers */
RIE(sanei_genesys_bulk_write_register(dev, dev->reg));
// Write initial registers
sanei_genesys_bulk_write_register(dev, dev->reg);
/* Test ASIC and RAM */
if (!(dev->model->flags & GENESYS_FLAG_LAZY_INIT))
@ -4919,7 +4893,7 @@ gl841_init (Genesys_Device * dev)
status = gl841_init_scan_regs(dev, sensor, &regs, params);
RIE(sanei_genesys_bulk_write_register(dev, regs));
sanei_genesys_bulk_write_register(dev, regs);
size = dev->current_setup.pixels * 3 * 2 * 1; /* colors * bytes_per_color * scan lines */
@ -5070,19 +5044,14 @@ gl841_search_strip(Genesys_Device * dev, const Genesys_Sensor& sensor,
/* set up for reverse or forward */
r = sanei_genesys_get_address(&local_reg, 0x02);
if (forward)
if (forward) {
r->value &= ~4;
else
} else {
r->value |= 4;
status = sanei_genesys_bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
sanei_genesys_bulk_write_register(dev, local_reg);
status = gl841_begin_scan(dev, sensor, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
@ -5122,13 +5091,7 @@ gl841_search_strip(Genesys_Device * dev, const Genesys_Sensor& sensor,
found = 0;
while (pass < length && !found)
{
status = sanei_genesys_bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__,
sane_strstatus(status));
return status;
}
sanei_genesys_bulk_write_register(dev, local_reg);
/* now start scan */
status = gl841_begin_scan(dev, sensor, &local_reg, SANE_TRUE);

109
backend/genesys_gl843.cc
Wyświetl plik

@ -2352,8 +2352,8 @@ static SANE_Status gl843_park_xpa_lamp (Genesys_Device * dev)
r = sanei_genesys_get_address (&local_reg, REG01);
r->value &= ~REG01_SCAN;
/* write to scanner and start action */
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
// write to scanner and start action
dev->model->cmd_set->bulk_write_register(dev, local_reg);
RIE(gl843_set_xpa_motor_power(dev, true));
try {
status = gl843_start_action (dev);
@ -2362,19 +2362,22 @@ static SANE_Status gl843_park_xpa_lamp (Genesys_Device * dev)
try {
gl843_stop_action(dev);
} catch (...) {}
try {
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
} catch (...) {}
});
throw;
}
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus(status));
gl843_stop_action (dev);
/* restore original registers */
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
return status;
});
}
while (loop < 600) /* do not wait longer then 60 seconds */
@ -2495,7 +2498,7 @@ gl843_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
r = sanei_genesys_get_address(&local_reg, REG01);
r->value &= ~REG01_SCAN;
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
dev->model->cmd_set->bulk_write_register(dev, local_reg);
try {
status = gl843_start_action (dev);
@ -2504,19 +2507,22 @@ gl843_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
try {
gl843_stop_action(dev);
} catch (...) {}
try {
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
} catch (...) {}
});
throw;
}
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus(status));
gl843_stop_action (dev);
/* restore original registers */
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
return status;
});
}
if (wait_until_home)
@ -2604,13 +2610,8 @@ gl843_search_start_position (Genesys_Device * dev)
return status;
}
/* send to scanner */
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
// send to scanner
dev->model->cmd_set->bulk_write_register(dev, local_reg);
size = dev->read_bytes_left;
@ -2718,12 +2719,7 @@ gl843_init_regs_for_coarse_calibration(Genesys_Device * dev, const Genesys_Senso
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);
status = dev->model->cmd_set->bulk_write_register(dev, regs);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
dev->model->cmd_set->bulk_write_register(dev, regs);
return SANE_STATUS_GOOD;
}
@ -2782,8 +2778,8 @@ gl843_feed (Genesys_Device * dev, unsigned int steps)
r = sanei_genesys_get_address(&local_reg, REG01);
r->value &= ~REG01_SCAN;
/* send registers */
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
// send registers
dev->model->cmd_set->bulk_write_register(dev, local_reg);
try {
status = gl843_start_action (dev);
@ -2792,10 +2788,11 @@ gl843_feed (Genesys_Device * dev, unsigned int steps)
try {
gl843_stop_action(dev);
} catch (...) {}
try {
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
} catch (...) {}
});
throw;
}
if (status != SANE_STATUS_GOOD)
@ -2803,8 +2800,11 @@ gl843_feed (Genesys_Device * dev, unsigned int steps)
DBG(DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus(status));
gl843_stop_action (dev);
/* restore original registers */
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
});
return status;
}
@ -2930,12 +2930,7 @@ gl843_init_regs_for_shading(Genesys_Device * dev, const Genesys_Sensor& sensor,
sanei_genesys_get_double(&regs,REG_STRPIXEL,&strpixel);
DBG(DBG_info, "%s: STRPIXEL=%d\n", __func__, strpixel);
status = dev->model->cmd_set->bulk_write_register(dev, regs);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
dev->model->cmd_set->bulk_write_register(dev, regs);
return SANE_STATUS_GOOD;
}
@ -3150,7 +3145,7 @@ gl843_led_calibration (Genesys_Device * dev, Genesys_Sensor& sensor, Genesys_Reg
return status;
}
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
dev->model->cmd_set->bulk_write_register(dev, regs);
total_size = dev->read_bytes_left;
@ -3179,7 +3174,7 @@ gl843_led_calibration (Genesys_Device * dev, Genesys_Sensor& sensor, Genesys_Reg
sanei_genesys_set_exposure(regs, calib_sensor.exposure);
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
RIE (gl843_begin_scan(dev, calib_sensor, &regs, SANE_TRUE));
@ -3409,8 +3404,8 @@ gl843_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
}
RIE(gl843_set_fe(dev, calib_sensor, AFE_SET));
/* scan with obttom AFE settings */
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
// scan with obttom AFE settings
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
RIE(gl843_begin_scan(dev, calib_sensor, &regs, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size));
@ -3438,8 +3433,8 @@ gl843_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
}
RIE(gl843_set_fe(dev, calib_sensor, AFE_SET));
/* scan with top AFE values */
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
// scan with top AFE values
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl843_begin_scan(dev, calib_sensor, &regs, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size));
@ -3474,8 +3469,8 @@ gl843_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
}
RIE(gl843_set_fe(dev, calib_sensor, AFE_SET));
/* scan with no move */
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
// scan with no move
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl843_begin_scan(dev, calib_sensor, &regs, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, second_line.data(), total_size));
@ -3631,7 +3626,7 @@ gl843_coarse_gain_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor
return status;
}
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
dev->model->cmd_set->bulk_write_register(dev, regs);
total_size = dev->read_bytes_left;
@ -3800,7 +3795,7 @@ gl843_init_regs_for_warmup (Genesys_Device * dev,
}
sanei_genesys_set_motor_power(*reg, false);
RIE(dev->model->cmd_set->bulk_write_register(dev, *reg));
dev->model->cmd_set->bulk_write_register(dev, *reg);
return SANE_STATUS_GOOD;
}
@ -3886,8 +3881,8 @@ gl843_boot (Genesys_Device * dev, SANE_Bool cold)
sanei_genesys_write_register(dev, REG6B, 0x02);
}
/* Write initial registers */
RIE (dev->model->cmd_set->bulk_write_register(dev, dev->reg));
// Write initial registers
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
// Enable DRAM by setting a rising edge on bit 3 of reg 0x0b
val = dev->reg.find_reg(0x0b).value & REG0B_DRAMSEL;
@ -4088,19 +4083,14 @@ gl843_search_strip (Genesys_Device * dev, const Genesys_Sensor& sensor,
/* set up for reverse or forward */
r = sanei_genesys_get_address(&local_reg, REG02);
if (forward)
if (forward) {
r->value &= ~REG02_MTRREV;
else
} else {
r->value |= REG02_MTRREV;
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
dev->model->cmd_set->bulk_write_register(dev, local_reg);
status = gl843_begin_scan(dev, calib_sensor, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
@ -4141,14 +4131,7 @@ gl843_search_strip (Genesys_Device * dev, const Genesys_Sensor& sensor,
found = 0;
while (pass < 20 && !found)
{
status =
dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__,
sane_strstatus(status));
return status;
}
/* now start scan */
status = gl843_begin_scan(dev, calib_sensor, &local_reg, SANE_TRUE);

86
backend/genesys_gl846.cc
Wyświetl plik

@ -1680,7 +1680,7 @@ gl846_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
r = sanei_genesys_get_address(&local_reg, REG02);
r->value |= REG02_MTRREV;
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
dev->model->cmd_set->bulk_write_register(dev, local_reg);
try {
status = gl846_start_action(dev);
@ -1689,18 +1689,22 @@ gl846_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
try {
gl846_stop_action(dev);
} catch (...) {}
try {
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
} catch (...) {}
});
throw;
}
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus(status));
gl846_stop_action (dev);
/* send original registers */
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
});
return status;
}
@ -1787,13 +1791,8 @@ gl846_search_start_position (Genesys_Device * dev)
return status;
}
/* send to scanner */
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
// send to scanner
dev->model->cmd_set->bulk_write_register(dev, local_reg);
size = pixels * dev->model->search_lines;
@ -1894,12 +1893,7 @@ gl846_init_regs_for_coarse_calibration(Genesys_Device * dev, const Genesys_Senso
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);
status = dev->model->cmd_set->bulk_write_register(dev, regs);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
dev->model->cmd_set->bulk_write_register(dev, regs);
return SANE_STATUS_GOOD;
}
@ -1962,8 +1956,8 @@ gl846_feed (Genesys_Device * dev, unsigned int steps)
r = sanei_genesys_get_address(&local_reg, REG01);
r->value &= ~REG01_SCAN;
/* send registers */
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
// send registers
dev->model->cmd_set->bulk_write_register(dev, local_reg);
try {
status = gl846_start_action (dev);
@ -1972,10 +1966,11 @@ gl846_feed (Genesys_Device * dev, unsigned int steps)
try {
gl846_stop_action(dev);
} catch (...) {}
try {
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
} catch (...) {}
});
throw;
}
if (status != SANE_STATUS_GOOD)
@ -1983,8 +1978,11 @@ gl846_feed (Genesys_Device * dev, unsigned int steps)
DBG(DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus(status));
gl846_stop_action (dev);
/* restore original registers */
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
});
return status;
}
@ -2059,12 +2057,7 @@ gl846_init_regs_for_shading(Genesys_Device * dev, const Genesys_Sensor& sensor,
return status;
}
status = dev->model->cmd_set->bulk_write_register(dev, regs);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
dev->model->cmd_set->bulk_write_register(dev, regs);
/* we use GENESYS_FLAG_SHADING_REPARK */
dev->scanhead_position_in_steps = 0;
@ -2379,8 +2372,8 @@ gl846_led_calibration (Genesys_Device * dev, Genesys_Sensor& sensor, Genesys_Reg
sanei_genesys_set_double(&regs,REG_EXPG,exp[1]);
sanei_genesys_set_double(&regs,REG_EXPB,exp[2]);
/* write registers and scan data */
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
// write registers and scan data
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting line reading\n", __func__);
RIE(gl846_begin_scan(dev, sensor, &regs, SANE_TRUE));
@ -2573,8 +2566,8 @@ gl846_boot (Genesys_Device * dev, SANE_Bool cold)
/* Set default values for registers */
gl846_init_registers (dev);
/* Write initial registers */
RIE (dev->model->cmd_set->bulk_write_register(dev, dev->reg));
// Write initial registers
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
/* Enable DRAM by setting a rising edge on bit 3 of reg 0x0b */
val = dev->reg.find_reg(0x0b).value & REG0B_DRAMSEL;
@ -2731,19 +2724,14 @@ gl846_search_strip(Genesys_Device * dev, const Genesys_Sensor& sensor,
/* set up for reverse or forward */
r = sanei_genesys_get_address (&local_reg, REG02);
if (forward)
if (forward) {
r->value &= ~REG02_MTRREV;
else
} else {
r->value |= REG02_MTRREV;
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
dev->model->cmd_set->bulk_write_register(dev, local_reg);
status = gl846_begin_scan(dev, sensor, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
@ -2783,13 +2771,7 @@ gl846_search_strip(Genesys_Device * dev, const Genesys_Sensor& sensor,
found = 0;
while (pass < 20 && !found)
{
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to bulk write registers: %s\n", __func__,
sane_strstatus(status));
return status;
}
dev->model->cmd_set->bulk_write_register(dev, local_reg);
/* now start scan */
status = gl846_begin_scan(dev, sensor, &local_reg, SANE_TRUE);
@ -3028,7 +3010,7 @@ gl846_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
dev->frontend.set_offset(2, bottom);
RIE(gl846_set_fe(dev, sensor, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
RIE(gl846_begin_scan(dev, sensor, &regs, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner (dev, first_line.data(), total_size));
@ -3048,7 +3030,7 @@ gl846_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
dev->frontend.set_offset(1, top);
dev->frontend.set_offset(2, top);
RIE(gl846_set_fe(dev, sensor, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl846_begin_scan(dev, sensor, &regs, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner (dev, second_line.data(), total_size));
@ -3068,7 +3050,7 @@ gl846_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
/* scan with no move */
RIE(gl846_set_fe(dev, sensor, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl846_begin_scan(dev, sensor, &regs, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner (dev, second_line.data(), total_size));
@ -3179,7 +3161,7 @@ gl846_coarse_gain_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor
return status;
}
RIE (dev->model->cmd_set->bulk_write_register(dev, regs));
dev->model->cmd_set->bulk_write_register(dev, regs);
total_size = pixels * channels * (16/bpp) * lines;

76
backend/genesys_gl847.cc
Wyświetl plik

@ -1736,7 +1736,7 @@ gl847_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
r = sanei_genesys_get_address (&local_reg, REG02);
r->value |= REG02_MTRREV;
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
dev->model->cmd_set->bulk_write_register(dev, local_reg);
try {
status = gl847_start_action (dev);
@ -1745,18 +1745,22 @@ gl847_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home)
try {
gl847_stop_action(dev);
} catch (...) {}
try {
// restore original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
} catch (...) {}
});
throw;
}
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus(status));
gl847_stop_action (dev);
/* send original registers */
// send original registers
catch_all_exceptions(__func__, [&]()
{
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
});
return status;
}
@ -1843,13 +1847,8 @@ gl847_search_start_position (Genesys_Device * dev)
return status;
}
/* send to scanner */
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
// send to scanner
dev->model->cmd_set->bulk_write_register(dev, local_reg);
size = pixels * dev->model->search_lines;
@ -1950,13 +1949,7 @@ gl847_init_regs_for_coarse_calibration(Genesys_Device * dev, const Genesys_Senso
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);
status =
dev->model->cmd_set->bulk_write_register(dev, regs);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
return SANE_STATUS_GOOD;
}
@ -2018,8 +2011,8 @@ gl847_feed (Genesys_Device * dev, unsigned int steps)
r = sanei_genesys_get_address(&local_reg, REG01);
r->value &= ~REG01_SCAN;
/* send registers */
RIE (dev->model->cmd_set->bulk_write_register(dev, local_reg));
// send registers
dev->model->cmd_set->bulk_write_register(dev, local_reg);
try {
status = gl847_start_action (dev);
@ -2039,7 +2032,7 @@ gl847_feed (Genesys_Device * dev, unsigned int steps)
DBG(DBG_error, "%s: failed to start motor: %s\n", __func__, sane_strstatus(status));
gl847_stop_action (dev);
/* restore original registers */
// restore original registers
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
return status;
}
@ -2115,12 +2108,7 @@ gl847_init_regs_for_shading(Genesys_Device * dev, const Genesys_Sensor& sensor,
return status;
}
status = dev->model->cmd_set->bulk_write_register(dev, regs);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
dev->model->cmd_set->bulk_write_register(dev, regs);
/* we use GENESYS_FLAG_SHADING_REPARK */
dev->scanhead_position_in_steps = 0;
@ -2435,8 +2423,8 @@ gl847_led_calibration (Genesys_Device * dev, Genesys_Sensor& sensor, Genesys_Reg
sanei_genesys_set_double(&regs,REG_EXPG,exp[1]);
sanei_genesys_set_double(&regs,REG_EXPB,exp[2]);
/* write registers and scan data */
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
// write registers and scan data
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting line reading\n", __func__);
RIE(gl847_begin_scan(dev, sensor, &regs, SANE_TRUE));
@ -2667,8 +2655,8 @@ gl847_boot (Genesys_Device * dev, SANE_Bool cold)
/* Set default values for registers */
gl847_init_registers (dev);
/* Write initial registers */
RIE (dev->model->cmd_set->bulk_write_register(dev, dev->reg));
// Write initial registers
dev->model->cmd_set->bulk_write_register(dev, dev->reg);
/* Enable DRAM by setting a rising edge on bit 3 of reg 0x0b */
val = dev->reg.find_reg(0x0b).value & REG0B_DRAMSEL;
@ -2822,19 +2810,14 @@ gl847_search_strip (Genesys_Device * dev, const Genesys_Sensor& sensor,
/* set up for reverse or forward */
r = sanei_genesys_get_address(&local_reg, REG02);
if (forward)
if (forward) {
r->value &= ~REG02_MTRREV;
else
} else {
r->value |= REG02_MTRREV;
status = dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to bulk write registers: %s\n", __func__, sane_strstatus(status));
return status;
}
dev->model->cmd_set->bulk_write_register(dev, local_reg);
status = gl847_begin_scan(dev, sensor, &local_reg, SANE_TRUE);
if (status != SANE_STATUS_GOOD)
{
@ -2874,14 +2857,7 @@ gl847_search_strip (Genesys_Device * dev, const Genesys_Sensor& sensor,
found = 0;
while (pass < 20 && !found)
{
status =
dev->model->cmd_set->bulk_write_register(dev, local_reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: Failed to bulk write registers: %s\n", __func__,
sane_strstatus(status));
return status;
}
/* now start scan */
status = gl847_begin_scan(dev, sensor, &local_reg, SANE_TRUE);
@ -3120,7 +3096,7 @@ gl847_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
dev->frontend.set_offset(2, bottom);
RIE(gl847_set_fe(dev, sensor, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting first line reading\n", __func__);
RIE(gl847_begin_scan(dev, sensor, &regs, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner(dev, first_line.data(), total_size));
@ -3140,7 +3116,7 @@ gl847_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
dev->frontend.set_offset(1, top);
dev->frontend.set_offset(2, top);
RIE(gl847_set_fe(dev, sensor, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl847_begin_scan(dev, sensor, &regs, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner (dev, second_line.data(), total_size));
@ -3160,7 +3136,7 @@ gl847_offset_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor,
/* scan with no move */
RIE(gl847_set_fe(dev, sensor, AFE_SET));
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
dev->model->cmd_set->bulk_write_register(dev, regs);
DBG(DBG_info, "%s: starting second line reading\n", __func__);
RIE(gl847_begin_scan(dev, sensor, &regs, SANE_TRUE));
RIE(sanei_genesys_read_data_from_scanner (dev, second_line.data(), total_size));
@ -3271,7 +3247,7 @@ gl847_coarse_gain_calibration(Genesys_Device * dev, const Genesys_Sensor& sensor
return status;
}
RIE(dev->model->cmd_set->bulk_write_register(dev, regs));
dev->model->cmd_set->bulk_write_register(dev, regs);
total_size = pixels * channels * (16/bpp) * lines;

21
backend/genesys_low.cc
Wyświetl plik

@ -591,14 +591,8 @@ sanei_genesys_fe_read_data (Genesys_Device * dev, uint8_t addr,
reg.init_reg(0x50, addr);
/* set up read address */
status = dev->model->cmd_set->bulk_write_register(dev, reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed while bulk writing registers: %s\n", __func__,
sane_strstatus(status));
return status;
}
// set up read address
dev->model->cmd_set->bulk_write_register(dev, reg);
// read data
sanei_genesys_read_register(dev, 0x46, &value);
@ -635,13 +629,7 @@ sanei_genesys_fe_write_data (Genesys_Device * dev, uint8_t addr,
reg.init_reg(0x3b, data & 0xff);
}
status = dev->model->cmd_set->bulk_write_register(dev, reg);
if (status != SANE_STATUS_GOOD)
{
DBG(DBG_error, "%s: failed while bulk writing registers: %s\n", __func__,
sane_strstatus(status));
return status;
}
dev->model->cmd_set->bulk_write_register(dev, reg);
return status;
}
@ -993,7 +981,7 @@ void sanei_genesys_set_motor_power(Genesys_Register_Set& regs, bool set)
* @param reg pointer to an array of registers
* @param elems size of the array
*/
SANE_Status sanei_genesys_bulk_write_register(Genesys_Device * dev, Genesys_Register_Set& reg)
void sanei_genesys_bulk_write_register(Genesys_Device * dev, Genesys_Register_Set& reg)
{
DBG_HELPER(dbg);
@ -1048,7 +1036,6 @@ SANE_Status sanei_genesys_bulk_write_register(Genesys_Device * dev, Genesys_Regi
}
DBG (DBG_io, "%s: wrote %lu registers\n", __func__, (u_long) reg.size());
return SANE_STATUS_GOOD;
}

7
backend/genesys_low.h
Wyświetl plik

@ -1091,8 +1091,7 @@ typedef struct Genesys_Command_Set
SANE_Status (*slow_back_home) (Genesys_Device * dev, SANE_Bool wait_until_home);
SANE_Status (*rewind) (Genesys_Device * dev);
SANE_Status (*bulk_write_register) (Genesys_Device * dev,
Genesys_Register_Set& regs);
void (*bulk_write_register) (Genesys_Device* dev, Genesys_Register_Set& regs);
void (*bulk_write_data) (Genesys_Device* dev, uint8_t addr, uint8_t* data, size_t len);
void (*bulk_read_data) (Genesys_Device * dev, uint8_t addr, uint8_t * data, size_t len);
@ -1722,9 +1721,7 @@ extern void sanei_genesys_read_hregister(Genesys_Device* dev, uint16_t reg, uint
extern void sanei_genesys_write_hregister(Genesys_Device* dev, uint16_t reg, uint8_t val);
extern SANE_Status
sanei_genesys_bulk_write_register(Genesys_Device * dev,
Genesys_Register_Set& regs);
extern void sanei_genesys_bulk_write_register(Genesys_Device* dev, Genesys_Register_Set& regs);
extern void sanei_genesys_write_0x8c(Genesys_Device* dev, uint8_t index, uint8_t val);