kopia lustrzana https://gitlab.com/sane-project/backends
Merge branch 'genesys-canoscan-8600f' into 'master'
genesys: Add initial support for 2400 and 4800 dpi transparency scanning on CanoScan 8600F See merge request sane-project/backends!81merge-requests/83/head
Povilas Kanapickas
commit
46e98476ac
Plik diff jest za duży
Load Diff
|
|
@ -374,7 +374,7 @@ cleanup:
|
|||
* SANE_STATUS_GOOD
|
||||
*/
|
||||
static SANE_Status
|
||||
genesys_deskew(Genesys_Scanner *s)
|
||||
genesys_deskew(Genesys_Scanner *s, const Genesys_Sensor& sensor)
|
||||
{
|
||||
SANE_Status status;
|
||||
Genesys_Device *dev = s->dev;
|
||||
|
|
@ -391,8 +391,8 @@ genesys_deskew(Genesys_Scanner *s)
|
|||
}
|
||||
status = sanei_magic_findSkew (&s->params,
|
||||
dev->img_buffer.data(),
|
||||
dev->sensor.optical_res,
|
||||
dev->sensor.optical_res,
|
||||
sensor.optical_res,
|
||||
sensor.optical_res,
|
||||
&x,
|
||||
&y,
|
||||
&slope);
|
||||
|
|
@ -474,5 +474,3 @@ genesys_derotate (Genesys_Scanner * s)
|
|||
DBGCOMPLETED;
|
||||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
|
||||
/* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */
|
||||
|
|
|
|||
Plik diff jest za duży
Load Diff
Plik diff jest za duży
Load Diff
|
|
@ -301,228 +301,7 @@
|
|||
#define REG_TRUEG 0x111
|
||||
#define REG_TRUEB 0x112
|
||||
|
||||
/**
|
||||
* writable scanner registers */
|
||||
enum
|
||||
{
|
||||
reg_0x01 = 0,
|
||||
reg_0x02,
|
||||
reg_0x03,
|
||||
reg_0x04,
|
||||
reg_0x05,
|
||||
reg_0x06,
|
||||
reg_0x07,
|
||||
reg_0x08,
|
||||
reg_0x09,
|
||||
reg_0x0a,
|
||||
reg_0x0b,
|
||||
reg_0x0c,
|
||||
reg_0x11,
|
||||
reg_0x12,
|
||||
reg_0x13,
|
||||
reg_0x14,
|
||||
reg_0x15,
|
||||
reg_0x16,
|
||||
reg_0x17,
|
||||
reg_0x18,
|
||||
reg_0x19,
|
||||
reg_0x1a,
|
||||
reg_0x1b,
|
||||
reg_0x1c,
|
||||
reg_0x1d,
|
||||
reg_0x1e,
|
||||
reg_0x1f,
|
||||
reg_0x20,
|
||||
reg_0x21,
|
||||
reg_0x22,
|
||||
reg_0x23,
|
||||
reg_0x24,
|
||||
reg_0x25,
|
||||
reg_0x26,
|
||||
reg_0x27,
|
||||
reg_0x28,
|
||||
reg_0x29,
|
||||
reg_0x2a,
|
||||
reg_0x2b,
|
||||
reg_0x2c,
|
||||
reg_0x2d,
|
||||
reg_0x3b,
|
||||
reg_0x3c,
|
||||
reg_0x3d,
|
||||
reg_0x3e,
|
||||
reg_0x3f,
|
||||
reg_0x40,
|
||||
reg_0x41,
|
||||
reg_0x42,
|
||||
reg_0x43,
|
||||
reg_0x44,
|
||||
reg_0x45,
|
||||
reg_0x46,
|
||||
reg_0x47,
|
||||
reg_0x48,
|
||||
reg_0x49,
|
||||
reg_0x4f,
|
||||
reg_0x52,
|
||||
reg_0x53,
|
||||
reg_0x54,
|
||||
reg_0x55,
|
||||
reg_0x56,
|
||||
reg_0x57,
|
||||
reg_0x58,
|
||||
reg_0x59,
|
||||
reg_0x5a,
|
||||
reg_0x5b,
|
||||
reg_0x5c,
|
||||
reg_0x5f,
|
||||
reg_0x60,
|
||||
reg_0x61,
|
||||
reg_0x62,
|
||||
reg_0x63,
|
||||
reg_0x64,
|
||||
reg_0x65,
|
||||
reg_0x66,
|
||||
reg_0x67,
|
||||
reg_0x68,
|
||||
reg_0x69,
|
||||
reg_0x6a,
|
||||
reg_0x6b,
|
||||
reg_0x6c,
|
||||
reg_0x6d,
|
||||
reg_0x6e,
|
||||
reg_0x6f,
|
||||
reg_0x70,
|
||||
reg_0x71,
|
||||
reg_0x72,
|
||||
reg_0x73,
|
||||
reg_0x74,
|
||||
reg_0x75,
|
||||
reg_0x76,
|
||||
reg_0x77,
|
||||
reg_0x78,
|
||||
reg_0x79,
|
||||
reg_0x7a,
|
||||
reg_0x7b,
|
||||
reg_0x7c,
|
||||
reg_0x7d,
|
||||
reg_0x7e,
|
||||
reg_0x7f,
|
||||
reg_0x80,
|
||||
reg_0x81,
|
||||
reg_0x82,
|
||||
reg_0x83,
|
||||
reg_0x84,
|
||||
reg_0x85,
|
||||
reg_0x86,
|
||||
reg_0x87,
|
||||
reg_0x88,
|
||||
reg_0x89,
|
||||
reg_0x8a,
|
||||
reg_0x8b,
|
||||
reg_0x8c,
|
||||
reg_0x8d,
|
||||
reg_0x8e,
|
||||
reg_0x8f,
|
||||
reg_0x90,
|
||||
reg_0x91,
|
||||
reg_0x92,
|
||||
reg_0x93,
|
||||
reg_0x94,
|
||||
reg_0x95,
|
||||
reg_0x96,
|
||||
reg_0x97,
|
||||
reg_0x98,
|
||||
reg_0x99,
|
||||
reg_0x9a,
|
||||
reg_0x9b,
|
||||
reg_0x9c,
|
||||
reg_0x9d,
|
||||
reg_0x9e,
|
||||
reg_0x9f,
|
||||
reg_0xa0,
|
||||
reg_0xa1,
|
||||
reg_0xa2,
|
||||
reg_0xa3,
|
||||
reg_0xa4,
|
||||
reg_0xa5,
|
||||
reg_0xa6,
|
||||
reg_0xa7,
|
||||
reg_0xa8,
|
||||
reg_0xa9,
|
||||
reg_0xaa,
|
||||
reg_0xab,
|
||||
reg_0xac,
|
||||
reg_0xad,
|
||||
reg_0xae,
|
||||
reg_0xaf,
|
||||
reg_0xb0,
|
||||
reg_0xb1,
|
||||
reg_0xb2,
|
||||
reg_0xb3,
|
||||
reg_0xb4,
|
||||
reg_0xb5,
|
||||
reg_0xb6,
|
||||
reg_0xb7,
|
||||
reg_0xb8,
|
||||
reg_0xbb,
|
||||
reg_0xbc,
|
||||
reg_0xbd,
|
||||
reg_0xbe,
|
||||
reg_0xc3,
|
||||
reg_0xc4,
|
||||
reg_0xc5,
|
||||
reg_0xc6,
|
||||
reg_0xc7,
|
||||
reg_0xc8,
|
||||
reg_0xc9,
|
||||
reg_0xca,
|
||||
reg_0xcb,
|
||||
reg_0xcc,
|
||||
reg_0xcd,
|
||||
reg_0xce,
|
||||
reg_0xd0,
|
||||
reg_0xd1,
|
||||
reg_0xd2,
|
||||
reg_0xd3,
|
||||
reg_0xd4,
|
||||
reg_0xd5,
|
||||
reg_0xd6,
|
||||
reg_0xd7,
|
||||
reg_0xd8,
|
||||
reg_0xd9,
|
||||
reg_0xe0,
|
||||
reg_0xe1,
|
||||
reg_0xe2,
|
||||
reg_0xe3,
|
||||
reg_0xe4,
|
||||
reg_0xe5,
|
||||
reg_0xe6,
|
||||
reg_0xe7,
|
||||
reg_0xe8,
|
||||
reg_0xe9,
|
||||
reg_0xea,
|
||||
reg_0xeb,
|
||||
reg_0xec,
|
||||
reg_0xed,
|
||||
reg_0xee,
|
||||
reg_0xef,
|
||||
reg_0xf0,
|
||||
reg_0xf1,
|
||||
reg_0xf2,
|
||||
reg_0xf3,
|
||||
reg_0xf4,
|
||||
reg_0xf5,
|
||||
reg_0xf6,
|
||||
reg_0xf7,
|
||||
reg_0xf8,
|
||||
reg_0xf9,
|
||||
reg_0xfa,
|
||||
reg_0xfb,
|
||||
reg_0xfc,
|
||||
reg_0xff,
|
||||
GENESYS_GL124_MAX_REGS
|
||||
};
|
||||
|
||||
#define SETREG(adr,val) {dev->reg[reg_##adr].address=adr;dev->reg[reg_##adr].value=val;}
|
||||
#define SETREG(adr,val) { dev->reg.init_reg(adr, val); }
|
||||
|
||||
typedef struct
|
||||
{
|
||||
|
|
@ -616,8 +395,6 @@ typedef struct {
|
|||
static size_t order_01[]={0,1};
|
||||
static size_t order_0213[]={0,2,1,3};
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
|
||||
/** @brief database of sensor profiles
|
||||
* database of sensor profiles giving for each sensor and a given resolution, the period, and timings
|
||||
* to setup the sensor for the scan.
|
||||
|
|
@ -684,9 +461,9 @@ static Motor_Profile motors[]={
|
|||
{MOTOR_CANONLIDE210, 20864, 2, lide210_max},
|
||||
{0, 0, 0, NULL},
|
||||
};
|
||||
/* *INDENT-ON* */
|
||||
|
||||
static
|
||||
SANE_Status gl124_init_scan_regs (Genesys_Device * dev,
|
||||
SANE_Status gl124_init_scan_regs (Genesys_Device * dev, const Genesys_Sensor& sensor,
|
||||
Genesys_Register_Set * reg,
|
||||
float xres, /*dpi */
|
||||
float yres, /*dpi */
|
||||
|
|
@ -703,15 +480,16 @@ SANE_Status gl124_init_scan_regs (Genesys_Device * dev,
|
|||
|
||||
static SANE_Status gl124_start_action (Genesys_Device * dev);
|
||||
static SANE_Status
|
||||
gl124_begin_scan (Genesys_Device * dev, Genesys_Register_Set * reg,
|
||||
gl124_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor, Genesys_Register_Set * reg,
|
||||
SANE_Bool start_motor);
|
||||
static SANE_Status
|
||||
gl124_end_scan (Genesys_Device * dev, Genesys_Register_Set * reg,
|
||||
SANE_Bool check_stop);
|
||||
static SANE_Status
|
||||
gl124_slow_back_home (Genesys_Device * dev, SANE_Bool wait_until_home);
|
||||
static SANE_Status gl124_init (Genesys_Device * dev);
|
||||
static SANE_Status gl124_send_shading_data (Genesys_Device * dev, uint8_t * data, int size);
|
||||
static SANE_Status gl124_init(Genesys_Device * dev);
|
||||
static SANE_Status gl124_send_shading_data (Genesys_Device * dev, const Genesys_Sensor& sensor,
|
||||
uint8_t * data, int size);
|
||||
|
||||
static SANE_Status gl124_feed (Genesys_Device * dev, unsigned int steps, int reverse);
|
||||
|
||||
|
|
@ -721,5 +499,3 @@ gl124_stop_action (Genesys_Device * dev);
|
|||
static SANE_Status
|
||||
gl124_send_slope_table (Genesys_Device * dev, int table_nr,
|
||||
uint16_t * slope_table, int steps);
|
||||
|
||||
/* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */
|
||||
|
|
|
|||
Plik diff jest za duży
Load Diff
|
|
@ -165,95 +165,11 @@
|
|||
|
||||
#include "genesys.h"
|
||||
|
||||
enum
|
||||
{
|
||||
reg_0x01 = 0,
|
||||
reg_0x02,
|
||||
reg_0x03,
|
||||
reg_0x04,
|
||||
reg_0x05,
|
||||
reg_0x06,
|
||||
reg_0x07,
|
||||
reg_0x08,
|
||||
reg_0x09,
|
||||
reg_0x0a,
|
||||
reg_0x0b,
|
||||
reg_0x10,
|
||||
reg_0x11,
|
||||
reg_0x12,
|
||||
reg_0x13,
|
||||
reg_0x14,
|
||||
reg_0x15,
|
||||
reg_0x16,
|
||||
reg_0x17,
|
||||
reg_0x18,
|
||||
reg_0x19,
|
||||
reg_0x1a,
|
||||
reg_0x1b,
|
||||
reg_0x1c,
|
||||
reg_0x1d,
|
||||
reg_0x1e,
|
||||
reg_0x1f,
|
||||
reg_0x20,
|
||||
reg_0x21,
|
||||
reg_0x22,
|
||||
reg_0x23,
|
||||
reg_0x24,
|
||||
reg_0x25,
|
||||
reg_0x26,
|
||||
reg_0x27,
|
||||
reg_0x28,
|
||||
reg_0x29,
|
||||
reg_0x2c,
|
||||
reg_0x2d,
|
||||
reg_0x2e,
|
||||
reg_0x2f,
|
||||
reg_0x30,
|
||||
reg_0x31,
|
||||
reg_0x32,
|
||||
reg_0x33,
|
||||
reg_0x34,
|
||||
reg_0x35,
|
||||
reg_0x36,
|
||||
reg_0x37,
|
||||
reg_0x38,
|
||||
reg_0x39,
|
||||
reg_0x3d,
|
||||
reg_0x3e,
|
||||
reg_0x3f,
|
||||
reg_0x52,
|
||||
reg_0x53,
|
||||
reg_0x54,
|
||||
reg_0x55,
|
||||
reg_0x56,
|
||||
reg_0x57,
|
||||
reg_0x58,
|
||||
reg_0x59,
|
||||
reg_0x5a,
|
||||
reg_0x5b,
|
||||
reg_0x5c,
|
||||
reg_0x5d,
|
||||
reg_0x5e,
|
||||
reg_0x60,
|
||||
reg_0x61,
|
||||
reg_0x62,
|
||||
reg_0x63,
|
||||
reg_0x64,
|
||||
reg_0x65,
|
||||
reg_0x66,
|
||||
reg_0x67,
|
||||
reg_0x68,
|
||||
reg_0x69,
|
||||
reg_0x6a,
|
||||
reg_0x6b,
|
||||
reg_0x6c,
|
||||
reg_0x6d,
|
||||
GENESYS_GL646_MAX_REGS
|
||||
};
|
||||
static SANE_Status gl646_set_fe(Genesys_Device * dev, const Genesys_Sensor& sensor,
|
||||
uint8_t set, int dpi);
|
||||
|
||||
static SANE_Status gl646_set_fe (Genesys_Device * dev, uint8_t set, int dpi);
|
||||
|
||||
static SANE_Status gl646_public_set_fe (Genesys_Device * dev, uint8_t set);
|
||||
static SANE_Status gl646_public_set_fe(Genesys_Device * dev, const Genesys_Sensor& sensor,
|
||||
uint8_t set);
|
||||
|
||||
static
|
||||
SANE_Status
|
||||
|
|
@ -281,6 +197,7 @@ gl646_move_to_ta (Genesys_Device * dev);
|
|||
*/
|
||||
static SANE_Status
|
||||
setup_for_scan (Genesys_Device *device,
|
||||
const Genesys_Sensor& sensor,
|
||||
Genesys_Register_Set *regs,
|
||||
Genesys_Settings settings,
|
||||
SANE_Bool split,
|
||||
|
|
@ -294,6 +211,7 @@ setup_for_scan (Genesys_Device *device,
|
|||
* */
|
||||
static SANE_Status
|
||||
gl646_setup_registers (Genesys_Device * dev,
|
||||
const Genesys_Sensor& sensor,
|
||||
Genesys_Register_Set * regs,
|
||||
Genesys_Settings scan_settings,
|
||||
uint16_t * slope_table1,
|
||||
|
|
@ -327,8 +245,9 @@ simple_move (Genesys_Device * dev, SANE_Int distance);
|
|||
* @param data pointer that will point to the scanned data
|
||||
*/
|
||||
static SANE_Status
|
||||
simple_scan (Genesys_Device * dev, Genesys_Settings settings, SANE_Bool move, SANE_Bool forward,
|
||||
SANE_Bool shading, std::vector<uint8_t>& data);
|
||||
simple_scan(Genesys_Device * dev, const Genesys_Sensor& sensor,
|
||||
Genesys_Settings settings, SANE_Bool move, SANE_Bool forward,
|
||||
SANE_Bool shading, std::vector<uint8_t>& data);
|
||||
|
||||
/**
|
||||
* Send the stop scan command
|
||||
|
|
@ -339,7 +258,8 @@ end_scan (Genesys_Device * dev, Genesys_Register_Set * reg,
|
|||
/**
|
||||
* writes control data to an area behind the last motor table.
|
||||
*/
|
||||
static SANE_Status write_control (Genesys_Device * dev, int resolution);
|
||||
static SANE_Status write_control (Genesys_Device * dev, const Genesys_Sensor& sensor,
|
||||
int resolution);
|
||||
|
||||
|
||||
/**
|
||||
|
|
@ -433,7 +353,6 @@ static uint8_t xp200_gray[6]={0x05, 0x0a, 0x0f, 0xa0, 0x10, 0x10};
|
|||
* master sensor settings, for a given sensor and dpi,
|
||||
* it gives exposure and CCD time
|
||||
*/
|
||||
/* *INDENT-OFF* */
|
||||
static Sensor_Master sensor_master[] = {
|
||||
/* HP3670 master settings */
|
||||
{CCD_HP3670, 75, SANE_TRUE , 75, 4879, 300, 4, 42, NULL, SANE_FALSE, 0x33, 0x43},
|
||||
|
|
@ -678,4 +597,3 @@ static Sensor_Settings sensor_settings[] = {
|
|||
{0x0f, 0x13, 0x17, 0x03, 0x07, 0x0b, 0x83} /* half ccd settings */
|
||||
},
|
||||
};
|
||||
/* *INDENT-ON* */
|
||||
|
|
|
|||
Plik diff jest za duży
Load Diff
|
|
@ -250,131 +250,14 @@
|
|||
|
||||
#define REG87_LEDADD 0x04
|
||||
|
||||
enum
|
||||
{
|
||||
reg_0x01 = 0,
|
||||
reg_0x02,
|
||||
reg_0x03,
|
||||
reg_0x04,
|
||||
reg_0x05,
|
||||
reg_0x06,
|
||||
reg_0x07,
|
||||
reg_0x08,
|
||||
reg_0x09,
|
||||
reg_0x0a,
|
||||
|
||||
reg_0x10,
|
||||
reg_0x11,
|
||||
reg_0x12,
|
||||
reg_0x13,
|
||||
reg_0x14,
|
||||
reg_0x15,
|
||||
reg_0x16,
|
||||
reg_0x17,
|
||||
reg_0x18,
|
||||
reg_0x19,
|
||||
reg_0x1a,
|
||||
reg_0x1b,
|
||||
reg_0x1c,
|
||||
reg_0x1d,
|
||||
reg_0x1e,
|
||||
reg_0x1f,
|
||||
reg_0x20,
|
||||
reg_0x21,
|
||||
reg_0x22,
|
||||
reg_0x23,
|
||||
reg_0x24,
|
||||
reg_0x25,
|
||||
reg_0x26,
|
||||
reg_0x27,
|
||||
|
||||
reg_0x29,
|
||||
|
||||
reg_0x2c,
|
||||
reg_0x2d,
|
||||
reg_0x2e,
|
||||
reg_0x2f,
|
||||
reg_0x30,
|
||||
reg_0x31,
|
||||
reg_0x32,
|
||||
reg_0x33,
|
||||
reg_0x34,
|
||||
reg_0x35,
|
||||
reg_0x36,
|
||||
reg_0x37,
|
||||
reg_0x38,
|
||||
reg_0x39,
|
||||
|
||||
reg_0x3d,
|
||||
reg_0x3e,
|
||||
reg_0x3f,
|
||||
|
||||
reg_0x52,
|
||||
reg_0x53,
|
||||
reg_0x54,
|
||||
reg_0x55,
|
||||
reg_0x56,
|
||||
reg_0x57,
|
||||
reg_0x58,
|
||||
reg_0x59,
|
||||
reg_0x5a,
|
||||
|
||||
reg_0x5d,
|
||||
reg_0x5e,
|
||||
reg_0x5f,
|
||||
reg_0x60,
|
||||
reg_0x61,
|
||||
reg_0x62,
|
||||
reg_0x63,
|
||||
reg_0x64,
|
||||
reg_0x65,
|
||||
reg_0x66,
|
||||
reg_0x67,
|
||||
reg_0x68,
|
||||
reg_0x69,
|
||||
reg_0x6a,
|
||||
reg_0x6b,
|
||||
reg_0x6c,
|
||||
reg_0x6d,
|
||||
reg_0x6e,
|
||||
reg_0x6f,
|
||||
reg_0x70,
|
||||
reg_0x71,
|
||||
reg_0x72,
|
||||
reg_0x73,
|
||||
reg_0x74,
|
||||
reg_0x75,
|
||||
reg_0x76,
|
||||
reg_0x77,
|
||||
reg_0x78,
|
||||
reg_0x79,
|
||||
reg_0x7a,
|
||||
reg_0x7b,
|
||||
reg_0x7c,
|
||||
reg_0x7d,
|
||||
reg_0x7e,
|
||||
reg_0x7f,
|
||||
reg_0x80,
|
||||
reg_0x81,
|
||||
reg_0x82,
|
||||
reg_0x83,
|
||||
reg_0x84,
|
||||
reg_0x85,
|
||||
reg_0x86,
|
||||
reg_0x87,
|
||||
reg_0x88,
|
||||
reg_0x89,
|
||||
GENESYS_GL841_MAX_REGS
|
||||
};
|
||||
|
||||
#define INITREG(adr,val) {dev->reg[index].address=adr;dev->reg[index].value=val;index++;}
|
||||
#define INITREG(adr,val) {dev->reg.init_reg(adr, val); }
|
||||
|
||||
/**
|
||||
* prototypes declaration in case of unit testing
|
||||
*/
|
||||
|
||||
static
|
||||
int gl841_exposure_time(Genesys_Device *dev,
|
||||
int gl841_exposure_time(Genesys_Device *dev, const Genesys_Sensor& sensor,
|
||||
float slope_dpi,
|
||||
int scan_step_type,
|
||||
int start,
|
||||
|
|
|
|||
Plik diff jest za duży
Load Diff
|
|
@ -382,154 +382,7 @@
|
|||
#define SCAN_FLAG_DISABLE_LAMP 0x040
|
||||
#define SCAN_FLAG_DYNAMIC_LINEART 0x080
|
||||
|
||||
/**
|
||||
* writable scanner registers */
|
||||
enum
|
||||
{
|
||||
reg_0x01 = 0,
|
||||
reg_0x02,
|
||||
reg_0x03,
|
||||
reg_0x04,
|
||||
reg_0x05,
|
||||
reg_0x06,
|
||||
reg_0x08,
|
||||
reg_0x09,
|
||||
reg_0x0a,
|
||||
reg_0x0b,
|
||||
reg_0x0c,
|
||||
reg_0x0f,
|
||||
reg_0x10,
|
||||
reg_0x11,
|
||||
reg_0x12,
|
||||
reg_0x13,
|
||||
reg_0x14,
|
||||
reg_0x15,
|
||||
reg_0x16,
|
||||
reg_0x17,
|
||||
reg_0x18,
|
||||
reg_0x19,
|
||||
reg_0x1a,
|
||||
reg_0x1b,
|
||||
reg_0x1c,
|
||||
reg_0x1d,
|
||||
reg_0x1e,
|
||||
reg_0x1f,
|
||||
reg_0x20,
|
||||
reg_0x21,
|
||||
reg_0x22,
|
||||
reg_0x23,
|
||||
reg_0x24,
|
||||
reg_0x25,
|
||||
reg_0x26,
|
||||
reg_0x27,
|
||||
reg_0x28,
|
||||
reg_0x2c,
|
||||
reg_0x2d,
|
||||
reg_0x2e,
|
||||
reg_0x2f,
|
||||
reg_0x30,
|
||||
reg_0x31,
|
||||
reg_0x32,
|
||||
reg_0x33,
|
||||
reg_0x34,
|
||||
reg_0x35,
|
||||
reg_0x36,
|
||||
reg_0x37,
|
||||
reg_0x38,
|
||||
reg_0x39,
|
||||
reg_0x3a,
|
||||
reg_0x3b,
|
||||
reg_0x3c,
|
||||
reg_0x3d,
|
||||
reg_0x3e,
|
||||
reg_0x3f,
|
||||
reg_0x51,
|
||||
reg_0x52,
|
||||
reg_0x53,
|
||||
reg_0x54,
|
||||
reg_0x55,
|
||||
reg_0x56,
|
||||
reg_0x57,
|
||||
reg_0x58,
|
||||
reg_0x59,
|
||||
reg_0x5a,
|
||||
reg_0x5d,
|
||||
reg_0x5e,
|
||||
reg_0x5f,
|
||||
reg_0x60,
|
||||
reg_0x61,
|
||||
reg_0x62,
|
||||
reg_0x63,
|
||||
reg_0x64,
|
||||
reg_0x65,
|
||||
reg_0x67,
|
||||
reg_0x68,
|
||||
reg_0x69,
|
||||
reg_0x6a,
|
||||
reg_0x6b,
|
||||
reg_0x70,
|
||||
reg_0x71,
|
||||
reg_0x72,
|
||||
reg_0x73,
|
||||
reg_0x74,
|
||||
reg_0x75,
|
||||
reg_0x76,
|
||||
reg_0x77,
|
||||
reg_0x78,
|
||||
reg_0x79,
|
||||
reg_0x7a,
|
||||
reg_0x7b,
|
||||
reg_0x7c,
|
||||
reg_0x7d,
|
||||
reg_0x7e,
|
||||
reg_0x7f,
|
||||
reg_0x80,
|
||||
reg_0x81,
|
||||
reg_0x82,
|
||||
reg_0x83,
|
||||
reg_0x84,
|
||||
reg_0x85,
|
||||
reg_0x86,
|
||||
reg_0x87,
|
||||
reg_0x88,
|
||||
reg_0x89,
|
||||
reg_0x8a,
|
||||
reg_0x8b,
|
||||
reg_0x8c,
|
||||
reg_0x8d,
|
||||
reg_0x8e,
|
||||
reg_0x8f,
|
||||
reg_0x90,
|
||||
reg_0x91,
|
||||
reg_0x92,
|
||||
reg_0x93,
|
||||
reg_0x94,
|
||||
reg_0x95,
|
||||
reg_0x96,
|
||||
reg_0x97,
|
||||
reg_0x98,
|
||||
reg_0x99,
|
||||
reg_0x9a,
|
||||
reg_0x9b,
|
||||
reg_0x9c,
|
||||
reg_0x9d,
|
||||
reg_0x9e,
|
||||
reg_0xa0,
|
||||
reg_0xa1,
|
||||
reg_0xa2,
|
||||
reg_0xa3,
|
||||
reg_0xa4,
|
||||
reg_0xa5,
|
||||
reg_0xaa,
|
||||
reg_0xab,
|
||||
reg_0xac,
|
||||
reg_0xad,
|
||||
reg_0xae,
|
||||
reg_0xaf,
|
||||
GENESYS_GL843_MAX_REGS
|
||||
};
|
||||
|
||||
#define SETREG(adr,val) {dev->reg[reg_##adr].address=adr;dev->reg[reg_##adr].value=val;}
|
||||
#define SETREG(adr,val) { dev->reg.init_reg(adr, val); }
|
||||
|
||||
typedef struct
|
||||
{
|
||||
|
|
@ -566,124 +419,6 @@ static Gpio_layout gpios[]={
|
|||
},
|
||||
};
|
||||
|
||||
/** @brief structure for sensor settings
|
||||
* this structure describes the sensor settings to use for a given
|
||||
* exposure.
|
||||
*/
|
||||
typedef struct {
|
||||
int sensor_type; /**> sensor id */
|
||||
int dpi; /**> maximum dpi for which data are valid, used only to select the sensor */
|
||||
|
||||
// exposure. The value of LPERIOD register depend on it
|
||||
int exposure;
|
||||
int ck1map; /**> CK1MAP */
|
||||
int ck3map; /**> CK2MAP */
|
||||
int ck4map; /**> CK3MAP */
|
||||
int segcnt; /**> SEGCNT */ // FIXME: not used
|
||||
int tg0cnt; /**> TG0CNT */ // FIXME: not used
|
||||
int expdummy; /**> exposure dummy */ // FIXME: not used
|
||||
int expr; /**> initial red exposure */ // FIXME: not used
|
||||
int expg; /**> initial green exposure */ // FIXME: not used
|
||||
int expb; /**> initial blue exposure */ // FIXME: not used
|
||||
uint8_t reg0c; /**> register 0x0c value */
|
||||
uint8_t reg70; /**> register 0x70 value */
|
||||
uint8_t reg71; /**> register 0x71 value */
|
||||
uint8_t reg9e; /**> register 0x9e value */
|
||||
uint8_t regaa; /**> either undocumented or mapping to somewhere else */
|
||||
|
||||
// 0x10-0x15 define the exposure and may be modified during calibration.
|
||||
uint8_t regs_0x10_0x1d[14];
|
||||
// 0x5b-0x5c defines download address and is later overwritten
|
||||
// 0x5d is unused.
|
||||
uint8_t regs_0x52_0x5e[13];
|
||||
} Sensor_Profile;
|
||||
|
||||
/**
|
||||
* database of sensor profiles
|
||||
*/
|
||||
static Sensor_Profile xpa_sensors[]={
|
||||
{CCD_G4050 , 600, 15624, 0x001c7f, 0x03ffff, 0x03ffff, 5168, 0, 0x2a, 0, 0, 0, 0x00, 0x00, 0x02, 0x00, 0x00,
|
||||
{0x2c, 0x09, 0x22, 0xb8, 0x10, 0xf0, 0x33, 0x4c, 0x01, 0x2a, 0x30, 0x00, 0x00, 0x08} ,
|
||||
{0x0e, 0x11, 0x02, 0x05, 0x08, 0x0b, 0x6b, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x6f},
|
||||
},
|
||||
{
|
||||
// sensor_type
|
||||
CCD_CS8600F,
|
||||
// dpi
|
||||
4800,
|
||||
// exposure
|
||||
0x5dc0,
|
||||
// ck1map, ck3map, ck4map
|
||||
0x03f0f0, 0x03fe00, 0x009249,
|
||||
// segcnt, tg0cnt
|
||||
0, 0,
|
||||
// expdummy, expr, expg, expb
|
||||
0, 0, 0, 0,
|
||||
// reg0c, reg70, reg71, reg9e, regaa
|
||||
0x00, 0x00, 0x02, 0x2d, 0x00,
|
||||
// regs_0x10_0x1d
|
||||
{ 0x9c, 0x40, 0x9c, 0x40, 0x9c, 0x40, 0x13, 0x0a, 0x10, 0x2a, 0x30, 0x00, 0x00, 0x6b },
|
||||
// regs_0x52_0x5e
|
||||
{ 0x0c, 0x0f, 0x00, 0x03, 0x06, 0x09, 0x6b, 0x00, 0x40, 0x00, 0x00, 0x00, 0x1f },
|
||||
}
|
||||
};
|
||||
static Sensor_Profile sensors[]={
|
||||
/* 0c 70 71 9e aa*/
|
||||
{CCD_KVSS080, 600, 8000, 0x000000, 0x00ffff, 0x03ffff, 5168, 0, 0x2a, 0, 0, 0, 0x00, 0x01, 0x03, 0x00, 0x00,
|
||||
/* 10 11 12 13 14 15 16 17 18 19 1a 1b 1c 1d */
|
||||
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x1c, 0x00, 0x2a, 0x2c, 0x00, 0x20, 0x04} ,
|
||||
/* 52 53 54 55 56 57 58 59 5a 5b 5c 5d 5e */
|
||||
{0x0c, 0x0f, 0x00, 0x03, 0x06, 0x09, 0x6b, 0x00, 0xc0, 0x00, 0x00, 0x00, 0x23},
|
||||
},
|
||||
|
||||
{CCD_G4050 , 600, 8016, 0x0001ff, 0x03ffff, 0x03ffff, 5168, 0, 0x2a, 0, 0, 0, 0x00, 0x00, 0x02, 0x00, 0x00,
|
||||
{0x2c, 0x09, 0x22, 0xb8, 0x10, 0xf0, 0x33, 0x0c, 0x00, 0x2a, 0x30, 0x00, 0x00, 0x08} ,
|
||||
{0x0b, 0x0e, 0x11, 0x02, 0x05, 0x08, 0x63, 0x00, 0x40, 0x00, 0x00, 0x00, 0x63},
|
||||
},
|
||||
|
||||
{CCD_G4050 , 1200, 56064, 0x0fffff, 0x0001ff, 0x0001ff, 5168, 0, 0x2a, 0, 0, 0, 0x20, 0x08, 0x0c, 0xc0, 0x05,
|
||||
{0x2c, 0x09, 0x22, 0xb8, 0x10, 0xf0, 0x3b, 0x0c, 0x10, 0x2a, 0x38, 0x10, 0x00, 0x08} ,
|
||||
{0x02, 0x05, 0x08, 0x0b, 0x0e, 0x11, 0x1b, 0x00, 0x40, 0x00, 0x00, 0x00, 0x63},
|
||||
},
|
||||
|
||||
{CCD_G4050 , 2400, 56064, 0x0fffff, 0x000000, 0x000000, 5168, 0, 0x2a, 0, 0, 0, 0x20, 0x08, 0x0a, 0xc0, 0x05,
|
||||
{0x2c, 0x09, 0x22, 0xb8, 0x10, 0xf0, 0x3b, 0x0c, 0x10, 0x2a, 0x38, 0x10, 0xc0, 0x08} ,
|
||||
{0x02, 0x05, 0x08, 0x0b, 0x0e, 0x11, 0x1b, 0x00, 0x40, 0x00, 0x00, 0x00, 0x63},
|
||||
},
|
||||
|
||||
{CCD_G4050 , 4800, 42752, 0x0fffff, 0x000000, 0x000000, 5168, 0, 0x2a, 0, 0, 0, 0x21, 0x08, 0x0a, 0xc0, 0x07,
|
||||
{0x2c, 0x09, 0x22, 0xb8, 0x10, 0xf0, 0x3b, 0x0c, 0x10, 0x2a, 0x38, 0x10, 0xc1, 0x08} ,
|
||||
{0x02, 0x05, 0x08, 0x0b, 0x0e, 0x11, 0x1b, 0x00, 0x40, 0x00, 0x00, 0x00, 0x63},
|
||||
},
|
||||
{CCD_CS4400F, 600, 11640, 0xf838, 0xfc00, 0x92a4, 5168, 0, 0x2a, 0x9c40, 0x9c40, 0x9c40, 0x00, 0x00, 0x02, 0x2d, 0x00,
|
||||
{0x9c, 0x40, 0x9c, 0x40, 0x9c, 0x40, 0x13, 0x0a, 0x10, 0x2a, 0x30, 0x00, 0x00, 0x6b},
|
||||
{0x0a, 0x0d, 0x00, 0x03, 0x06, 0x08, 0x5b, 0x00, 0x40, 0x00, 0x00, 0x00, 0x3f},
|
||||
},
|
||||
{CCD_CS8400F, 600, 7200, 0x0e3f, 0x0000, 0x1b6db, 5168, 0, 0x2a, 0x0, 0x0, 0x0, 0x00, 0x01, 0x02, 0x00, 0x00,
|
||||
{0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x33, 0x0c, 0x13, 0x2a, 0x30, 0x00, 0x00, 0x84},
|
||||
{0x0d, 0x10, 0x01, 0x04, 0x07, 0x0a, 0x6b, 0x00, 0x40, 0x00, 0x00, 0x00, 0x85},
|
||||
},
|
||||
{
|
||||
// sensor_type
|
||||
CCD_CS8600F,
|
||||
// dpi
|
||||
4800,
|
||||
// exposure
|
||||
0x5dc0,
|
||||
// ck1map, ck3map, ck4map
|
||||
0x03f0f0, 0x03fe00, 0x009249,
|
||||
// segcnt, tg0cnt
|
||||
0, 0,
|
||||
// expdummy, expr, expg, expb
|
||||
0, 0, 0, 0,
|
||||
// reg0c, reg70, reg71, reg9e, regaa
|
||||
0x00, 0x00, 0x02, 0x2d, 0x00,
|
||||
// regs_0x10_0x1d
|
||||
{ 0x9c, 0x40, 0x9c, 0x40, 0x9c, 0x40, 0x13, 0x0a, 0x10, 0x2a, 0x30, 0x00, 0x00, 0x6b },
|
||||
// regs_0x52_0x5e
|
||||
{ 0x0c, 0x0f, 0x00, 0x03, 0x06, 0x09, 0x6b, 0x00, 0x40, 0x00, 0x00, 0x00, 0x1f },
|
||||
}
|
||||
};
|
||||
|
||||
static uint32_t kvss080[]={44444, 34188, 32520, 29630, 26666, 24242, 22222, 19048, 16666, 15686, 14814, 14034, 12402, 11110, 8888, 7618, 6666, 5926, 5228, 4678, 4172, 3682, 3336, 3074, 2866, 2702, 2566, 2450, 2352, 2266, 2188, 2118, 2056, 2002, 1950, 1904, 1860, 1820, 1784, 1748, 1716, 1684, 1656, 1628, 1600, 1576, 1552, 1528, 1506, 1486, 1466, 1446, 1428, 1410, 1394, 1376, 1360, 1346, 1330, 1316, 1302, 1288, 1276, 1264, 1250, 1238, 1228, 1216, 1206, 1194, 1184, 1174, 1164, 1154, 1146, 1136, 1128, 1120, 1110, 1102, 1094, 1088, 1080, 1072, 1064, 1058, 1050, 1044, 1038, 1030, 1024, 1018, 1012, 1006, 1000, 994, 988, 984, 978, 972, 968, 962, 958, 952, 948, 942, 938, 934, 928, 924, 920, 916, 912, 908, 904, 900, 896, 892, 888, 884, 882, 878, 874, 870, 868, 864, 860, 858, 854, 850, 848, 844, 842, 838, 836, 832, 830, 826, 824, 822, 820, 816, 814, 812, 808, 806, 804, 802, 800, 796, 794, 792, 790, 788, 786, 784, 782, 778, 776, 774, 772, 770, 768, 766, 764, 762, 760, 758, 756, 754, 752, 750, 750, 748, 746, 744, 742, 740, 738, 736, 734, 734, 732, 730, 728, 726, 724, 724, 722, 720, 718, 716, 716, 714, 712, 710, 710, 708, 706, 704, 704, 702, 700, 698, 698, 696, 694, 694, 692, 690, 690, 688, 686, 686, 684, 682, 682, 680, 678, 678, 676, 674, 674, 672, 672, 670, 668, 668, 666, 666, 664, 662, 662, 660, 660, 658, 656, 656, 654, 654, 652, 652, 650, 650, 648, 646, 646, 644, 644, 642, 642, 640, 640, 638, 638, 636, 636, 636, 634, 634, 632, 632, 630, 630, 628, 628, 626, 626, 624, 624, 624, 622, 622, 620, 620, 618, 618, 618, 616, 616, 614, 614, 612, 612, 612, 610, 610, 608, 608, 608, 606, 606, 606, 604, 604, 602, 602, 602, 600, 600, 600, 598, 598, 596, 596, 596, 594, 594, 594, 592, 592, 592, 590, 590, 590, 588, 588, 588, 586, 586, 586, 584, 584, 584, 582, 582, 582, 590, 590, 590, 588, 588, 588, 586, 586, 586, 584, 584, 584, 582, 582, 582, 580, 580, 580, 578, 578, 578, 576, 576, 576, 576, 574, 574, 574, 572, 572, 572, 570, 570, 570, 568, 568, 568, 568, 566, 566, 566, 564, 564, 564, 562, 562, 562, 562, 560, 560, 560, 558, 558, 558, 558, 556, 556, 556, 554, 554, 554, 552, 552, 552, 552, 550, 550, 550, 548, 548, 548, 548, 546, 546, 546, 546, 544, 544, 544, 542, 542, 542, 542, 540, 540, 540, 538, 538, 538, 538, 536, 536, 536, 536, 534, 534, 534, 534, 532, 532, 532, 530, 530, 530, 530, 528, 528, 528, 528, 526, 526, 526, 526, 524, 524, 524, 524, 522, 522, 522, 522, 520, 520, 520, 520, 518, 518, 518, 516, 516, 516, 516, 514, 514, 514, 514, 514, 512, 512, 512, 512, 510, 510, 510, 510, 508, 508, 508, 508, 506, 506, 506, 506, 504, 504, 504, 504, 502, 502, 502, 502, 500, 500, 500, 500, 0};
|
||||
static uint32_t g4050_fast[]={7842,5898,4384,4258,4152,4052,3956,3864,3786,3714,3632,3564,3498,3444,3384,3324,3276,3228,3174,3128,3086,3044,3002,2968,2930,2892,2860,2824,2794,2760,2732,2704,2676,2650,2618,2594,2568,2548,2524,2500,2478,2454,2436,2414,2392,2376,2354,2338,2318,2302,2282,2266,2252,2232,2218,2202,2188,2174,2160,2142,2128,2116,2102,2088,2076,2062,2054,2040,2028,2020,2014,2008,2004,2002,2002,2002,1946,1882,1826,1770,1716,1662,1612,1568,1526,1488,1454,1422,1390,1362,1336,1310,1288,1264,1242,1222,1204,1184,1166,1150,1134,1118,1104,1090,1076,1064,1050,1038,1026,1016,1004,994,984,972,964,954,944,936,928,920,910,902,896,888,880,874,866,860,854,848,840,834,828,822,816,812,806,800,796,790,784,780,776,770,766,760,756,752,748,744,740,736,732,728,724,720,716,712,708,704,702,698,694,690,688,684,682,678,674,672,668,666,662,660,656,654,650,648,646,644,640,638,636,632,630,628,624,622,620,618,616,614,610,608,606,604,602,600,598,596,594,592,590,588,586,584,582,580,578,576,574,572,570,568,566,564,564,562,560,558,556,554,552,552,550,548,546,546,544,542,540,538,538,536,534,532,532,530,528,528,526,524,522,522,520,518,518,516,514,514,512,512,510,508,508,506,504,504,502,502,500,498,498,496,496,494,494,492,490,490,488,488,486,486,484,484,482,480,480,478,478,476,476,474,474,472,472,470,470,468,468,468,466,466,464,464,462,462,460,460,458,458,456,456,456,454,454,452,452,450,450,450,448,448,446,446,444,444,444,442,442,440,440,440,438,438,438,436,436,434,434,434,432,432,432,430,430,428,428,428,426,426,426,424,424,424,422,422,422,420,420,420,418,418,418,416,416,416,414,414,414,412,412,412,410,410,410,408,408,408,406,406,406,404,404,404,404,402,402,402,400,400,400,400,398,398,398,396,396,396,396,394,394,394,392,392,392,392,390,390,390,388,388,388,388,386,386,386,386,384,384,384,384,382,382,382,382,380,380,380,380,378,378,378,378,376,376,376,376,376,374,374,374,374,374,372,372,372,372,372,370,370,370,370,370,368,368,368,368,368,366,366,366,366,366,364,364,364,364,364,364,362,362,362,362,362,360,360,360,360,360,360,358,358,358,358,358,358,356,356,356,356,356,356,354,354,354,354,354,352,352,352,352,352,352,350,350,350,350,350,350,350,348,348,348,348,348,348,346,346,346,346,346,346,344,344,344,344,344,344,344,342,342,342,342,342,342,340,340,340,340,340,340,340,338,338,338,338,338,338,338,336,336,336,336,336,336,336,334,334,334,334,334,334,334,332,332,332,332,332,332,332,332,330,330,330,330,330,330,330,328,328,328,328,328,328,328,328,326,326,326,326,326,326,326,324,324,324,324,324,324,324,324,322,322,322,322,322,322,322,322,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320,320, 0};
|
||||
|
|
@ -721,7 +456,6 @@ static uint32_t motor_speeds_cs8600f[] = {
|
|||
* database of motor profiles
|
||||
*/
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
static Motor_Profile gl843_motors[]={
|
||||
/* KV-SS080 */
|
||||
{MOTOR_KVSS080, 8000, 1, kvss080},
|
||||
|
|
@ -736,6 +470,3 @@ static Motor_Profile gl843_motors[]={
|
|||
{ MOTOR_CS8600F, 0x59d8, 2, motor_speeds_cs8600f }, // FIXME: if the exposure is lower then we'll select another motor
|
||||
{ 0, 0, 0, NULL },
|
||||
};
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */
|
||||
|
|
|
|||
Plik diff jest za duży
Load Diff
|
|
@ -335,181 +335,14 @@
|
|||
#define REGF8_SMAXSEL 4
|
||||
#define REGF8_MINSEL 0x0f
|
||||
|
||||
/**
|
||||
* writable scanner registers */
|
||||
enum
|
||||
{
|
||||
reg_0x01 = 0,
|
||||
reg_0x02,
|
||||
reg_0x03,
|
||||
reg_0x04,
|
||||
reg_0x05,
|
||||
reg_0x06,
|
||||
reg_0x08,
|
||||
reg_0x09,
|
||||
reg_0x0a,
|
||||
reg_0x0b,
|
||||
reg_0x0c,
|
||||
reg_0x0d,
|
||||
reg_0x0e,
|
||||
reg_0x0f,
|
||||
reg_0x10,
|
||||
reg_0x11,
|
||||
reg_0x12,
|
||||
reg_0x13,
|
||||
reg_0x14,
|
||||
reg_0x15,
|
||||
reg_0x16,
|
||||
reg_0x17,
|
||||
reg_0x18,
|
||||
reg_0x19,
|
||||
reg_0x1a,
|
||||
reg_0x1b,
|
||||
reg_0x1c,
|
||||
reg_0x1d,
|
||||
reg_0x1e,
|
||||
reg_0x1f,
|
||||
reg_0x20,
|
||||
reg_0x21,
|
||||
reg_0x22,
|
||||
reg_0x23,
|
||||
reg_0x24,
|
||||
reg_0x25,
|
||||
reg_0x26,
|
||||
reg_0x27,
|
||||
reg_0x2c,
|
||||
reg_0x2d,
|
||||
reg_0x2e,
|
||||
reg_0x2f,
|
||||
reg_0x30,
|
||||
reg_0x31,
|
||||
reg_0x32,
|
||||
reg_0x33,
|
||||
reg_0x34,
|
||||
reg_0x35,
|
||||
reg_0x36,
|
||||
reg_0x37,
|
||||
reg_0x38,
|
||||
reg_0x39,
|
||||
reg_0x3a,
|
||||
reg_0x3b,
|
||||
reg_0x3d,
|
||||
reg_0x3e,
|
||||
reg_0x3f,
|
||||
reg_0x51,
|
||||
reg_0x52,
|
||||
reg_0x53,
|
||||
reg_0x54,
|
||||
reg_0x55,
|
||||
reg_0x56,
|
||||
reg_0x57,
|
||||
reg_0x58,
|
||||
reg_0x59,
|
||||
reg_0x5a,
|
||||
reg_0x5e,
|
||||
reg_0x5f,
|
||||
reg_0x60,
|
||||
reg_0x61,
|
||||
reg_0x62,
|
||||
reg_0x63,
|
||||
reg_0x64,
|
||||
reg_0x65,
|
||||
reg_0x67,
|
||||
reg_0x68,
|
||||
reg_0x69,
|
||||
reg_0x6a,
|
||||
reg_0x6b,
|
||||
reg_0x6c,
|
||||
reg_0x6d,
|
||||
reg_0x6e,
|
||||
reg_0x6f,
|
||||
reg_0x70,
|
||||
reg_0x71,
|
||||
reg_0x72,
|
||||
reg_0x73,
|
||||
reg_0x74,
|
||||
reg_0x75,
|
||||
reg_0x76,
|
||||
reg_0x77,
|
||||
reg_0x78,
|
||||
reg_0x79,
|
||||
reg_0x7a,
|
||||
reg_0x7b,
|
||||
reg_0x7c,
|
||||
reg_0x7d,
|
||||
reg_0x7e,
|
||||
reg_0x7f,
|
||||
reg_0x80,
|
||||
reg_0x87,
|
||||
reg_0x94,
|
||||
reg_0x98,
|
||||
reg_0x99,
|
||||
reg_0x9a,
|
||||
reg_0x9b,
|
||||
reg_0x9d,
|
||||
reg_0x9e,
|
||||
reg_0xa1,
|
||||
reg_0xa2,
|
||||
reg_0xa3,
|
||||
reg_0xa4,
|
||||
reg_0xa5,
|
||||
reg_0xa6,
|
||||
reg_0xa7,
|
||||
reg_0xa8,
|
||||
reg_0xa9,
|
||||
reg_0xab,
|
||||
reg_0xbb,
|
||||
reg_0xbc,
|
||||
reg_0xbd,
|
||||
reg_0xbe,
|
||||
reg_0xc5,
|
||||
reg_0xc6,
|
||||
reg_0xc7,
|
||||
reg_0xc8,
|
||||
reg_0xc9,
|
||||
reg_0xca,
|
||||
reg_0xd0,
|
||||
reg_0xd1,
|
||||
reg_0xd2,
|
||||
reg_0xdb,
|
||||
reg_0xe0,
|
||||
reg_0xe1,
|
||||
reg_0xe2,
|
||||
reg_0xe3,
|
||||
reg_0xe4,
|
||||
reg_0xe5,
|
||||
reg_0xe6,
|
||||
reg_0xe7,
|
||||
reg_0xe8,
|
||||
reg_0xe9,
|
||||
reg_0xea,
|
||||
reg_0xeb,
|
||||
reg_0xec,
|
||||
reg_0xed,
|
||||
reg_0xee,
|
||||
reg_0xef,
|
||||
reg_0xf0,
|
||||
reg_0xf1,
|
||||
reg_0xf2,
|
||||
reg_0xf3,
|
||||
reg_0xf4,
|
||||
reg_0xf5,
|
||||
reg_0xf6,
|
||||
reg_0xf7,
|
||||
reg_0xf8,
|
||||
reg_0xfe,
|
||||
reg_0xff,
|
||||
GENESYS_GL846_MAX_REGS
|
||||
};
|
||||
|
||||
#define SETREG(adr,val) {dev->reg[reg_##adr].address=adr;dev->reg[reg_##adr].value=val;}
|
||||
#define SETREG(adr,val) { dev->reg.init_reg(adr, val); }
|
||||
|
||||
|
||||
/** set up registers for an actual scan
|
||||
*
|
||||
* this function sets up the scanner to scan in normal or single line mode
|
||||
*/
|
||||
static SANE_Status gl846_init_scan_regs (Genesys_Device * dev,
|
||||
static SANE_Status gl846_init_scan_regs (Genesys_Device * dev, const Genesys_Sensor& sensor,
|
||||
Genesys_Register_Set * reg,
|
||||
float xres, /*dpi */
|
||||
float yres, /*dpi */
|
||||
|
|
@ -523,7 +356,8 @@ static SANE_Status gl846_init_scan_regs (Genesys_Device * dev,
|
|||
unsigned int flags);
|
||||
|
||||
/* Send the low-level scan command */
|
||||
static SANE_Status gl846_begin_scan (Genesys_Device * dev, Genesys_Register_Set * reg, SANE_Bool start_motor);
|
||||
static SANE_Status gl846_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor,
|
||||
Genesys_Register_Set * reg, SANE_Bool start_motor);
|
||||
|
||||
/* Send the stop scan command */
|
||||
static SANE_Status gl846_end_scan (Genesys_Device * dev, Genesys_Register_Set * reg, SANE_Bool check_stop);
|
||||
|
|
@ -643,8 +477,6 @@ typedef struct {
|
|||
uint8_t r17; /**> TG width */
|
||||
} Sensor_Profile;
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
|
||||
/**
|
||||
* order of the scanned pixel
|
||||
*/
|
||||
|
|
@ -657,7 +489,6 @@ static Sensor_Profile sensors[]={
|
|||
{CCD_IMG101, 1200, 11000, 60, 159, 85, 5136, 255, 0, 0, 0, order_01 , 0x13},
|
||||
{CCD_PLUSTEK3800, 1200, 11000, 60, 159, 85, 5136, 255, 0, 0, 0, order_01 , 0x13},
|
||||
};
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/* base motor slopes in full step unit */
|
||||
/* target=((exposure * dpi) / base_dpi)>>step_type; */
|
||||
|
|
@ -667,7 +498,6 @@ static uint32_t img101_high[] = {22000, 22000, 22000, 18450, 15974, 14284, 13054
|
|||
* database of motor profiles
|
||||
*/
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
static Motor_Profile gl846_motors[]={
|
||||
/* Image Formula 101 */
|
||||
{MOTOR_IMG101, 11000, HALF_STEP , img101_high},
|
||||
|
|
@ -676,6 +506,3 @@ static Motor_Profile gl846_motors[]={
|
|||
/* end of database entry */
|
||||
{0, 0, 0, NULL},
|
||||
};
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */
|
||||
|
|
|
|||
Plik diff jest za duży
Load Diff
|
|
@ -320,161 +320,14 @@
|
|||
#define REG_CK3MAP 0x77
|
||||
#define REG_CK4MAP 0x7a
|
||||
|
||||
/**
|
||||
* writable scanner registers */
|
||||
enum
|
||||
{
|
||||
reg_0x01 = 0,
|
||||
reg_0x02,
|
||||
reg_0x03,
|
||||
reg_0x04,
|
||||
reg_0x05,
|
||||
reg_0x06,
|
||||
reg_0x08,
|
||||
reg_0x09,
|
||||
reg_0x0a,
|
||||
reg_0x0b,
|
||||
reg_0x0c,
|
||||
reg_0x0d,
|
||||
reg_0x0e,
|
||||
reg_0x0f,
|
||||
reg_0x10,
|
||||
reg_0x11,
|
||||
reg_0x12,
|
||||
reg_0x13,
|
||||
reg_0x14,
|
||||
reg_0x15,
|
||||
reg_0x16,
|
||||
reg_0x17,
|
||||
reg_0x18,
|
||||
reg_0x19,
|
||||
reg_0x1a,
|
||||
reg_0x1b,
|
||||
reg_0x1c,
|
||||
reg_0x1d,
|
||||
reg_0x1e,
|
||||
reg_0x1f,
|
||||
reg_0x20,
|
||||
reg_0x21,
|
||||
reg_0x22,
|
||||
reg_0x23,
|
||||
reg_0x24,
|
||||
reg_0x25,
|
||||
reg_0x26,
|
||||
reg_0x27,
|
||||
reg_0x2c,
|
||||
reg_0x2d,
|
||||
reg_0x2e,
|
||||
reg_0x2f,
|
||||
reg_0x30,
|
||||
reg_0x31,
|
||||
reg_0x32,
|
||||
reg_0x33,
|
||||
reg_0x34,
|
||||
reg_0x35,
|
||||
reg_0x36,
|
||||
reg_0x37,
|
||||
reg_0x38,
|
||||
reg_0x39,
|
||||
reg_0x3a,
|
||||
reg_0x3b,
|
||||
reg_0x3d,
|
||||
reg_0x3e,
|
||||
reg_0x3f,
|
||||
reg_0x51,
|
||||
reg_0x52,
|
||||
reg_0x53,
|
||||
reg_0x54,
|
||||
reg_0x55,
|
||||
reg_0x56,
|
||||
reg_0x57,
|
||||
reg_0x58,
|
||||
reg_0x59,
|
||||
reg_0x5a,
|
||||
reg_0x5e,
|
||||
reg_0x5f,
|
||||
reg_0x60,
|
||||
reg_0x61,
|
||||
reg_0x62,
|
||||
reg_0x63,
|
||||
reg_0x64,
|
||||
reg_0x65,
|
||||
reg_0x67,
|
||||
reg_0x68,
|
||||
reg_0x69,
|
||||
reg_0x6a,
|
||||
reg_0x6b,
|
||||
reg_0x6c,
|
||||
reg_0x6d,
|
||||
reg_0x6e,
|
||||
reg_0x6f,
|
||||
reg_0x74,
|
||||
reg_0x75,
|
||||
reg_0x76,
|
||||
reg_0x77,
|
||||
reg_0x78,
|
||||
reg_0x79,
|
||||
reg_0x7a,
|
||||
reg_0x7b,
|
||||
reg_0x7c,
|
||||
reg_0x7d,
|
||||
reg_0x87,
|
||||
reg_0x9d,
|
||||
reg_0xa2,
|
||||
reg_0xa3,
|
||||
reg_0xa4,
|
||||
reg_0xa5,
|
||||
reg_0xa6,
|
||||
reg_0xa7,
|
||||
reg_0xa8,
|
||||
reg_0xa9,
|
||||
reg_0xbd,
|
||||
reg_0xbe,
|
||||
reg_0xc5,
|
||||
reg_0xc6,
|
||||
reg_0xc7,
|
||||
reg_0xc8,
|
||||
reg_0xc9,
|
||||
reg_0xca,
|
||||
reg_0xd0,
|
||||
reg_0xd1,
|
||||
reg_0xd2,
|
||||
reg_0xe0,
|
||||
reg_0xe1,
|
||||
reg_0xe2,
|
||||
reg_0xe3,
|
||||
reg_0xe4,
|
||||
reg_0xe5,
|
||||
reg_0xe6,
|
||||
reg_0xe7,
|
||||
reg_0xe8,
|
||||
reg_0xe9,
|
||||
reg_0xea,
|
||||
reg_0xeb,
|
||||
reg_0xec,
|
||||
reg_0xed,
|
||||
reg_0xee,
|
||||
reg_0xef,
|
||||
reg_0xf0,
|
||||
reg_0xf1,
|
||||
reg_0xf2,
|
||||
reg_0xf3,
|
||||
reg_0xf4,
|
||||
reg_0xf5,
|
||||
reg_0xf6,
|
||||
reg_0xf7,
|
||||
reg_0xf8,
|
||||
reg_0xfe,
|
||||
GENESYS_GL847_MAX_REGS
|
||||
};
|
||||
|
||||
#define SETREG(adr,val) {dev->reg[reg_##adr].address=adr;dev->reg[reg_##adr].value=val;}
|
||||
#define SETREG(adr,val) { dev->reg.init_reg(adr, val); }
|
||||
|
||||
/** set up registers for an actual scan
|
||||
*
|
||||
* this function sets up the scanner to scan in normal or single line mode
|
||||
*/
|
||||
static SANE_Status gl847_init_scan_regs (Genesys_Device * dev,
|
||||
const Genesys_Sensor& sensor,
|
||||
Genesys_Register_Set * reg,
|
||||
float xres, /*dpi */
|
||||
float yres, /*dpi */
|
||||
|
|
@ -488,7 +341,8 @@ static SANE_Status gl847_init_scan_regs (Genesys_Device * dev,
|
|||
unsigned int flags);
|
||||
|
||||
/* Send the low-level scan command */
|
||||
static SANE_Status gl847_begin_scan (Genesys_Device * dev, Genesys_Register_Set * reg, SANE_Bool start_motor);
|
||||
static SANE_Status gl847_begin_scan (Genesys_Device * dev, const Genesys_Sensor& sensor,
|
||||
Genesys_Register_Set * reg, SANE_Bool start_motor);
|
||||
|
||||
/* Send the stop scan command */
|
||||
static SANE_Status gl847_end_scan (Genesys_Device * dev, Genesys_Register_Set * reg, SANE_Bool check_stop);
|
||||
|
|
@ -585,8 +439,6 @@ typedef struct {
|
|||
uint8_t r17; /**> TG width */
|
||||
} Sensor_Profile;
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
|
||||
static size_t order_01[]={0,1};
|
||||
static size_t order_0213[]={0,2,1,3};
|
||||
static size_t order_0246[]={0,2,4,6,1,3,5,7};
|
||||
|
|
@ -622,7 +474,6 @@ static Sensor_Profile sensors[]={
|
|||
{CIS_CANONLIDE700, 2400, 10576, 135, 249, 85, 5187, 255, 2798, 1558, 972, new_order , 0x08},
|
||||
{CIS_CANONLIDE700, 4800, 10576, 135, 249, 85, 5187, 255, 2798, 1558, 972, order_0145, 0x06},
|
||||
};
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/* base motor sopes in full step unit */
|
||||
/* target=((exposure * dpi) / base_dpi)>>step_type; */
|
||||
|
|
@ -642,7 +493,6 @@ static uint32_t lide200_max[] = { 124992, 124992, 124992, 124992, 124992, 124992
|
|||
* database of motor profiles
|
||||
*/
|
||||
|
||||
/* *INDENT-OFF* */
|
||||
static Motor_Profile gl847_motors[]={
|
||||
/* LiDE 100 */
|
||||
{MOTOR_CANONLIDE100, 2848, HALF_STEP , lide200_base},
|
||||
|
|
@ -669,6 +519,3 @@ static Motor_Profile gl847_motors[]={
|
|||
/* end of database entry */
|
||||
{0, 0, 0, NULL},
|
||||
};
|
||||
/* *INDENT-ON* */
|
||||
|
||||
/* vim: set sw=2 cino=>2se-1sn-1s{s^-1st0(0u0 smarttab expandtab: */
|
||||
|
|
|
|||
|
|
@ -197,44 +197,6 @@ sanei_genesys_write_pnm_file (const char *filename, uint8_t * data, int depth,
|
|||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
|
||||
/* the following 2 functions are used to handle registers in a
|
||||
way that doesn't depend on the actual ASIC type */
|
||||
|
||||
/* Reads a register from a register set */
|
||||
SANE_Byte
|
||||
sanei_genesys_read_reg_from_set (Genesys_Register_Set * reg,
|
||||
uint16_t address)
|
||||
{
|
||||
SANE_Int i;
|
||||
|
||||
for (i = 0; i < GENESYS_MAX_REGS; i++)
|
||||
{
|
||||
if (reg[i].address == address)
|
||||
{
|
||||
return reg[i].value;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
/* Reads a register from a register set */
|
||||
void
|
||||
sanei_genesys_set_reg_from_set (Genesys_Register_Set * reg, uint16_t address,
|
||||
SANE_Byte value)
|
||||
{
|
||||
SANE_Int i;
|
||||
|
||||
for (i = 0; i < GENESYS_MAX_REGS; i++)
|
||||
{
|
||||
if (reg[i].address == address)
|
||||
{
|
||||
reg[i].value = value;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* ------------------------------------------------------------------------ */
|
||||
/* Read and write RAM, registers and AFE */
|
||||
/* ------------------------------------------------------------------------ */
|
||||
|
|
@ -751,16 +713,15 @@ sanei_genesys_fe_read_data (Genesys_Device * dev, uint8_t addr,
|
|||
{
|
||||
SANE_Status status;
|
||||
uint8_t value;
|
||||
Genesys_Register_Set reg[1];
|
||||
Genesys_Register_Set reg;
|
||||
|
||||
|
||||
DBG(DBG_proc, "%s: start\n", __func__);
|
||||
|
||||
reg[0].address = 0x50;
|
||||
reg[0].value = addr;
|
||||
reg.init_reg(0x50, addr);
|
||||
|
||||
/* set up read address */
|
||||
status = dev->model->cmd_set->bulk_write_register (dev, reg, 1);
|
||||
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__,
|
||||
|
|
@ -792,23 +753,20 @@ sanei_genesys_fe_write_data (Genesys_Device * dev, uint8_t addr,
|
|||
uint16_t data)
|
||||
{
|
||||
SANE_Status status;
|
||||
Genesys_Register_Set reg[3];
|
||||
Genesys_Register_Set reg(Genesys_Register_Set::SEQUENTIAL);
|
||||
|
||||
DBG(DBG_io, "%s (0x%02x, 0x%04x)\n", __func__, addr, data);
|
||||
|
||||
reg[0].address = 0x51;
|
||||
reg[0].value = addr;
|
||||
reg[1].address = 0x3a;
|
||||
reg[1].value = (data / 256) & 0xff;
|
||||
reg[2].address = 0x3b;
|
||||
reg[2].value = data & 0xff;
|
||||
if (dev->model->asic_type == GENESYS_GL124)
|
||||
{
|
||||
reg[1].address = 0x5d;
|
||||
reg[2].address = 0x5e;
|
||||
reg.init_reg(0x51, addr);
|
||||
if (dev->model->asic_type == GENESYS_GL124) {
|
||||
reg.init_reg(0x5d, (data / 256) & 0xff);
|
||||
reg.init_reg(0x5e, data & 0xff);
|
||||
} else {
|
||||
reg.init_reg(0x3a, (data / 256) & 0xff);
|
||||
reg.init_reg(0x3b, data & 0xff);
|
||||
}
|
||||
|
||||
status = dev->model->cmd_set->bulk_write_register (dev, reg, 3);
|
||||
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__,
|
||||
|
|
@ -991,171 +949,6 @@ sanei_genesys_read_scancnt (Genesys_Device * dev, unsigned int *words)
|
|||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
|
||||
/**
|
||||
* Find register in set
|
||||
* @param regs register set to search
|
||||
* @param addr addres of the searched register
|
||||
* @return a Genesys_Register_Set pointer corresponding to the required
|
||||
* address in ASIC space. Or NULL if not found.
|
||||
*/
|
||||
Genesys_Register_Set *
|
||||
sanei_genesys_get_address (Genesys_Register_Set * regs, uint16_t addr)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < GENESYS_MAX_REGS; i++)
|
||||
{
|
||||
if (regs[i].address == addr)
|
||||
return ®s[i];
|
||||
}
|
||||
DBG(DBG_error, "%s: failed to find address for register 0x%02x, crash expected !\n", __func__,
|
||||
addr);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
/**
|
||||
* set a 16 bit value in the given register set.
|
||||
* @param regs register set where to set values
|
||||
* @param addr address of the first register index to set
|
||||
* @param value value to set
|
||||
* @return SANE_STATUS_INVAL if the index doesn't exist in register set
|
||||
*/
|
||||
SANE_Status
|
||||
sanei_genesys_set_double(Genesys_Register_Set *regs, uint16_t addr, uint16_t value)
|
||||
{
|
||||
Genesys_Register_Set *r;
|
||||
|
||||
/* high byte */
|
||||
r = sanei_genesys_get_address (regs, addr);
|
||||
if(r==NULL)
|
||||
{
|
||||
return SANE_STATUS_INVAL;
|
||||
}
|
||||
r->value = HIBYTE (value);
|
||||
|
||||
/* low byte */
|
||||
r = sanei_genesys_get_address (regs, addr+1);
|
||||
if(r==NULL)
|
||||
{
|
||||
return SANE_STATUS_INVAL;
|
||||
}
|
||||
r->value = LOBYTE (value);
|
||||
|
||||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
|
||||
/**
|
||||
* set a 24 bit value in the given register set.
|
||||
* @param regs register set where to set values
|
||||
* @param addr address of the first register index to set
|
||||
* @param value value to set
|
||||
* @return SANE_STATUS_INVAL if the index doesn't exist in register set
|
||||
*/
|
||||
SANE_Status
|
||||
sanei_genesys_set_triple(Genesys_Register_Set *regs, uint16_t addr, uint32_t value)
|
||||
{
|
||||
Genesys_Register_Set *r;
|
||||
|
||||
/* low byte of highword */
|
||||
r = sanei_genesys_get_address (regs, addr);
|
||||
if(r==NULL)
|
||||
{
|
||||
return SANE_STATUS_INVAL;
|
||||
}
|
||||
r->value = LOBYTE (HIWORD(value));
|
||||
|
||||
/* high byte of low word */
|
||||
r = sanei_genesys_get_address (regs, addr+1);
|
||||
if(r==NULL)
|
||||
{
|
||||
return SANE_STATUS_INVAL;
|
||||
}
|
||||
r->value = HIBYTE (LOWORD(value));
|
||||
|
||||
/* low byte of low word */
|
||||
r = sanei_genesys_get_address (regs, addr+2);
|
||||
if(r==NULL)
|
||||
{
|
||||
return SANE_STATUS_INVAL;
|
||||
}
|
||||
r->value = LOBYTE (LOWORD(value));
|
||||
|
||||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
|
||||
/**
|
||||
* get a 16 bit value in the given register set.
|
||||
* @param regs register set where to read values
|
||||
* @param addr address of the first register index to read
|
||||
* @param value value to set
|
||||
* @return SANE_STATUS_INVAL if the index doesn't exist in register set
|
||||
*/
|
||||
SANE_Status
|
||||
sanei_genesys_get_double(Genesys_Register_Set *regs, uint16_t addr, uint16_t *value)
|
||||
{
|
||||
Genesys_Register_Set *r;
|
||||
uint16_t result=0;
|
||||
|
||||
/* high byte */
|
||||
r = sanei_genesys_get_address (regs, addr);
|
||||
if(r==NULL)
|
||||
{
|
||||
return SANE_STATUS_INVAL;
|
||||
}
|
||||
result=r->value<<8;
|
||||
|
||||
/* low byte */
|
||||
r = sanei_genesys_get_address (regs, addr+1);
|
||||
if(r==NULL)
|
||||
{
|
||||
return SANE_STATUS_INVAL;
|
||||
}
|
||||
result+=r->value;
|
||||
|
||||
*value=result;
|
||||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
|
||||
/**
|
||||
* get a 24 bit value in the given register set.
|
||||
* @param regs register set where to read values
|
||||
* @param addr address of the first register index to read
|
||||
* @param value value to set
|
||||
* @return SANE_STATUS_INVAL if the index doesn't exist in register set
|
||||
*/
|
||||
SANE_Status
|
||||
sanei_genesys_get_triple(Genesys_Register_Set *regs, uint16_t addr, uint32_t *value)
|
||||
{
|
||||
Genesys_Register_Set *r;
|
||||
uint32_t result=0;
|
||||
|
||||
/* low byte of highword */
|
||||
r = sanei_genesys_get_address (regs, addr);
|
||||
if(r==NULL)
|
||||
{
|
||||
return SANE_STATUS_INVAL;
|
||||
}
|
||||
result=r->value<<16;
|
||||
|
||||
/* high byte of low word */
|
||||
r = sanei_genesys_get_address (regs, addr+1);
|
||||
if(r==NULL)
|
||||
{
|
||||
return SANE_STATUS_INVAL;
|
||||
}
|
||||
result+=(r->value<<8);
|
||||
|
||||
/* low byte of low word */
|
||||
r = sanei_genesys_get_address (regs, addr+2);
|
||||
if(r==NULL)
|
||||
{
|
||||
return SANE_STATUS_INVAL;
|
||||
}
|
||||
result+=r->value;
|
||||
|
||||
*value=result;
|
||||
return SANE_STATUS_GOOD;
|
||||
}
|
||||
|
||||
/** @brief Check if the scanner's internal data buffer is empty
|
||||
* @param *dev device to test for data
|
||||
* @param *empty return value
|
||||
|
|
@ -1286,46 +1079,35 @@ sanei_genesys_read_feed_steps (Genesys_Device * dev, unsigned int *steps)
|
|||
* @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,
|
||||
size_t elems)
|
||||
SANE_Status sanei_genesys_bulk_write_register(Genesys_Device * dev, Genesys_Register_Set& reg)
|
||||
{
|
||||
SANE_Status status = SANE_STATUS_GOOD;
|
||||
size_t i;
|
||||
|
||||
if (dev->model->asic_type == GENESYS_GL646 ||
|
||||
dev->model->asic_type == GENESYS_GL841)
|
||||
{
|
||||
uint8_t outdata[8];
|
||||
uint8_t buffer[GENESYS_MAX_REGS * 2];
|
||||
size_t size;
|
||||
unsigned int i;
|
||||
|
||||
/* handle differently sized register sets, reg[0x00] may be the last one */
|
||||
i = 0;
|
||||
while ((i < elems) && (reg[i].address != 0))
|
||||
i++;
|
||||
elems = i;
|
||||
size = i * 2;
|
||||
std::vector<uint8_t> buffer;
|
||||
buffer.reserve(reg.size() * 2);
|
||||
|
||||
/* copy registers and values in data buffer */
|
||||
for (i = 0; i < size; i += 2) {
|
||||
buffer[i] = reg[i / 2].address;
|
||||
buffer[i + 1] = reg[i / 2].value;
|
||||
for (const auto& r : reg) {
|
||||
buffer.push_back(r.address);
|
||||
buffer.push_back(r.value);
|
||||
}
|
||||
|
||||
DBG(DBG_io, "%s (elems= %lu, size = %lu)\n", __func__, (u_long) elems, (u_long) size);
|
||||
DBG(DBG_io, "%s (elems= %lu, size = %lu)\n", __func__, (u_long) reg.size(),
|
||||
(u_long) buffer.size());
|
||||
|
||||
if (dev->model->asic_type == GENESYS_GL646) {
|
||||
outdata[0] = BULK_OUT;
|
||||
outdata[1] = BULK_REGISTER;
|
||||
outdata[2] = 0x00;
|
||||
outdata[3] = 0x00;
|
||||
outdata[4] = (size & 0xff);
|
||||
outdata[5] = ((size >> 8) & 0xff);
|
||||
outdata[6] = ((size >> 16) & 0xff);
|
||||
outdata[7] = ((size >> 24) & 0xff);
|
||||
outdata[4] = (buffer.size() & 0xff);
|
||||
outdata[5] = ((buffer.size() >> 8) & 0xff);
|
||||
outdata[6] = ((buffer.size() >> 16) & 0xff);
|
||||
outdata[7] = ((buffer.size() >> 24) & 0xff);
|
||||
|
||||
status = sanei_usb_control_msg(dev->dn, REQUEST_TYPE_OUT, REQUEST_BUFFER,
|
||||
VALUE_BUFFER, INDEX, sizeof(outdata), outdata);
|
||||
|
|
@ -1335,19 +1117,20 @@ sanei_genesys_bulk_write_register (Genesys_Device * dev,
|
|||
return status;
|
||||
}
|
||||
|
||||
status = sanei_usb_write_bulk (dev->dn, buffer, &size);
|
||||
size_t write_size = buffer.size();
|
||||
status = sanei_usb_write_bulk (dev->dn, buffer.data(), &write_size);
|
||||
if (status != SANE_STATUS_GOOD) {
|
||||
DBG(DBG_error, "%s: failed while writing bulk data: %s\n", __func__, sane_strstatus(status));
|
||||
return status;
|
||||
}
|
||||
} else {
|
||||
size_t c;
|
||||
for (i = 0; i < elems;) {
|
||||
c = elems - i;
|
||||
for (size_t i = 0; i < reg.size();) {
|
||||
size_t c = reg.size() - i;
|
||||
if (c > 32) /*32 is max on GL841. checked that.*/
|
||||
c = 32;
|
||||
status = sanei_usb_control_msg(dev->dn, REQUEST_TYPE_OUT, REQUEST_BUFFER,
|
||||
VALUE_SET_REGISTER, INDEX, c * 2, buffer + i * 2);
|
||||
VALUE_SET_REGISTER, INDEX, c * 2,
|
||||
buffer.data() + i * 2);
|
||||
if (status != SANE_STATUS_GOOD)
|
||||
{
|
||||
DBG(DBG_error, "%s: failed while writing command: %s\n", __func__,
|
||||
|
|
@ -1359,14 +1142,14 @@ sanei_genesys_bulk_write_register (Genesys_Device * dev,
|
|||
}
|
||||
}
|
||||
} else {
|
||||
for (i = 0; i < elems && status == SANE_STATUS_GOOD; i++) {
|
||||
if (reg[i].address != 0) {
|
||||
status = sanei_genesys_write_register (dev, reg[i].address, reg[i].value);
|
||||
}
|
||||
for (const auto& r : reg) {
|
||||
status = sanei_genesys_write_register (dev, r.address, r.value);
|
||||
if (status != SANE_STATUS_GOOD)
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
DBG (DBG_io, "%s: wrote %lu registers\n", __func__, (u_long) elems);
|
||||
DBG (DBG_io, "%s: wrote %lu registers\n", __func__, (u_long) reg.size());
|
||||
return status;
|
||||
}
|
||||
|
||||
|
|
@ -1448,6 +1231,19 @@ sanei_genesys_write_ahb(Genesys_Device* dev, uint32_t addr, uint32_t size, uint8
|
|||
return status;
|
||||
}
|
||||
|
||||
|
||||
std::vector<uint16_t> get_gamma_table(Genesys_Device* dev, const Genesys_Sensor& sensor,
|
||||
int color)
|
||||
{
|
||||
if (!dev->gamma_override_tables[color].empty()) {
|
||||
return dev->gamma_override_tables[color];
|
||||
} else {
|
||||
std::vector<uint16_t> ret;
|
||||
sanei_genesys_create_default_gamma_table(dev, ret, sensor.gamma[color]);
|
||||
return ret;
|
||||
}
|
||||
}
|
||||
|
||||
/** @brief generates gamma buffer to transfer
|
||||
* Generates gamma table buffer to send to ASIC. Applies
|
||||
* contrast and brightness if set.
|
||||
|
|
@ -1459,13 +1255,15 @@ sanei_genesys_write_ahb(Genesys_Device* dev, uint32_t addr, uint32_t size, uint8
|
|||
* @returns SANE_STATUS_GOOD or SANE_STATUS_NO_MEM
|
||||
*/
|
||||
SANE_Status sanei_genesys_generate_gamma_buffer(Genesys_Device * dev,
|
||||
const Genesys_Sensor& sensor,
|
||||
int bits,
|
||||
int max,
|
||||
int size,
|
||||
uint8_t *gamma)
|
||||
{
|
||||
int i;
|
||||
uint16_t value;
|
||||
std::vector<uint16_t> rgamma = get_gamma_table(dev, sensor, GENESYS_RED);
|
||||
std::vector<uint16_t> ggamma = get_gamma_table(dev, sensor, GENESYS_GREEN);
|
||||
std::vector<uint16_t> bgamma = get_gamma_table(dev, sensor, GENESYS_BLUE);
|
||||
|
||||
if(dev->settings.contrast!=0 || dev->settings.brightness!=0)
|
||||
{
|
||||
|
|
@ -1477,19 +1275,19 @@ SANE_Status sanei_genesys_generate_gamma_buffer(Genesys_Device * dev,
|
|||
max,
|
||||
dev->settings.contrast,
|
||||
dev->settings.brightness);
|
||||
for (i = 0; i < size; i++)
|
||||
for (int i = 0; i < size; i++)
|
||||
{
|
||||
value=dev->sensor.gamma_table[GENESYS_RED][i];
|
||||
uint16_t value=rgamma[i];
|
||||
value=lut[value];
|
||||
gamma[i * 2 + size * 0 + 0] = value & 0xff;
|
||||
gamma[i * 2 + size * 0 + 1] = (value >> 8) & 0xff;
|
||||
|
||||
value=dev->sensor.gamma_table[GENESYS_GREEN][i];
|
||||
value=ggamma[i];
|
||||
value=lut[value];
|
||||
gamma[i * 2 + size * 2 + 0] = value & 0xff;
|
||||
gamma[i * 2 + size * 2 + 1] = (value >> 8) & 0xff;
|
||||
|
||||
value=dev->sensor.gamma_table[GENESYS_BLUE][i];
|
||||
value=bgamma[i];
|
||||
value=lut[value];
|
||||
gamma[i * 2 + size * 4 + 0] = value & 0xff;
|
||||
gamma[i * 2 + size * 4 + 1] = (value >> 8) & 0xff;
|
||||
|
|
@ -1497,17 +1295,17 @@ SANE_Status sanei_genesys_generate_gamma_buffer(Genesys_Device * dev,
|
|||
}
|
||||
else
|
||||
{
|
||||
for (i = 0; i < size; i++)
|
||||
for (int i = 0; i < size; i++)
|
||||
{
|
||||
value=dev->sensor.gamma_table[GENESYS_RED][i];
|
||||
uint16_t value=rgamma[i];
|
||||
gamma[i * 2 + size * 0 + 0] = value & 0xff;
|
||||
gamma[i * 2 + size * 0 + 1] = (value >> 8) & 0xff;
|
||||
|
||||
value=dev->sensor.gamma_table[GENESYS_GREEN][i];
|
||||
value=ggamma[i];
|
||||
gamma[i * 2 + size * 2 + 0] = value & 0xff;
|
||||
gamma[i * 2 + size * 2 + 1] = (value >> 8) & 0xff;
|
||||
|
||||
value=dev->sensor.gamma_table[GENESYS_BLUE][i];
|
||||
value=bgamma[i];
|
||||
gamma[i * 2 + size * 4 + 0] = value & 0xff;
|
||||
gamma[i * 2 + size * 4 + 1] = (value >> 8) & 0xff;
|
||||
}
|
||||
|
|
@ -1524,7 +1322,7 @@ SANE_Status sanei_genesys_generate_gamma_buffer(Genesys_Device * dev,
|
|||
* @param dev device to write to
|
||||
*/
|
||||
SANE_Status
|
||||
sanei_genesys_send_gamma_table (Genesys_Device * dev)
|
||||
sanei_genesys_send_gamma_table(Genesys_Device * dev, const Genesys_Sensor& sensor)
|
||||
{
|
||||
int size;
|
||||
int i;
|
||||
|
|
@ -1538,7 +1336,7 @@ sanei_genesys_send_gamma_table (Genesys_Device * dev)
|
|||
/* allocate temporary gamma tables: 16 bits words, 3 channels */
|
||||
std::vector<uint8_t> gamma(size * 2 * 3, 255);
|
||||
|
||||
RIE(sanei_genesys_generate_gamma_buffer(dev, 16, 65535, size, gamma.data()));
|
||||
RIE(sanei_genesys_generate_gamma_buffer(dev, sensor, 16, 65535, size, gamma.data()));
|
||||
|
||||
/* loop sending gamma tables NOTE: 0x01000000 not 0x10000000 */
|
||||
for (i = 0; i < 3; i++)
|
||||
|
|
@ -1588,13 +1386,11 @@ sanei_genesys_send_gamma_table (Genesys_Device * dev)
|
|||
* @return SANE_STATUS_GOOD in case of success
|
||||
*/
|
||||
SANE_Status
|
||||
sanei_genesys_asic_init (Genesys_Device * dev, int max_regs)
|
||||
sanei_genesys_asic_init(Genesys_Device* dev, int /*max_regs*/)
|
||||
{
|
||||
SANE_Status status;
|
||||
uint8_t val;
|
||||
SANE_Bool cold = SANE_TRUE;
|
||||
int size; /**< size of the device's gamma table */
|
||||
int i;
|
||||
|
||||
DBGSTART;
|
||||
|
||||
|
|
@ -1617,20 +1413,6 @@ sanei_genesys_asic_init (Genesys_Device * dev, int max_regs)
|
|||
dev->usb_mode = 2;
|
||||
}
|
||||
|
||||
/* setup gamma tables */
|
||||
size = 256;
|
||||
for(i=0;i<3;i++)
|
||||
{
|
||||
dev->sensor.gamma_table[i].clear();
|
||||
dev->sensor.gamma_table[i].resize(size, 0);
|
||||
|
||||
sanei_genesys_create_gamma_table (dev->sensor.gamma_table[i].data(),
|
||||
size,
|
||||
65535,
|
||||
65535,
|
||||
dev->sensor.gamma[i]);
|
||||
}
|
||||
|
||||
/* check if the device has already been initialized and powered up
|
||||
* we read register 6 and check PWRBIT, if reset scanner has been
|
||||
* freshly powered up. This bit will be set to later so that following
|
||||
|
|
@ -1661,10 +1443,12 @@ sanei_genesys_asic_init (Genesys_Device * dev, int max_regs)
|
|||
dev->settings.color_filter = 0;
|
||||
|
||||
/* duplicate initial values into calibration registers */
|
||||
memcpy (dev->calib_reg, dev->reg, max_regs * sizeof (Genesys_Register_Set));
|
||||
dev->calib_reg = dev->reg;
|
||||
|
||||
const auto& sensor = sanei_genesys_find_sensor_any(dev);
|
||||
|
||||
/* Set analog frontend */
|
||||
RIE (dev->model->cmd_set->set_fe (dev, AFE_INIT));
|
||||
RIE (dev->model->cmd_set->set_fe(dev, sensor, AFE_INIT));
|
||||
|
||||
dev->already_initialized = SANE_TRUE;
|
||||
|
||||
|
|
@ -1763,12 +1547,12 @@ sanei_genesys_wait_for_home (Genesys_Device * dev)
|
|||
* @param xres x resolution of the scan
|
||||
* @return the hardware dpi to use
|
||||
*/
|
||||
int sanei_genesys_compute_dpihw(Genesys_Device *dev, int xres)
|
||||
int sanei_genesys_compute_dpihw(Genesys_Device *dev, const Genesys_Sensor& sensor, int xres)
|
||||
{
|
||||
/* some scanners use always hardware dpi for sensor */
|
||||
if (dev->model->flags & GENESYS_FLAG_FULL_HWDPI_MODE)
|
||||
{
|
||||
return dev->sensor.optical_res;
|
||||
return sensor.optical_res;
|
||||
}
|
||||
|
||||
/* can't be below 600 dpi */
|
||||
|
|
@ -1776,25 +1560,26 @@ int sanei_genesys_compute_dpihw(Genesys_Device *dev, int xres)
|
|||
{
|
||||
return 600;
|
||||
}
|
||||
if (xres <= dev->sensor.optical_res / 4)
|
||||
if (xres <= sensor.optical_res / 4)
|
||||
{
|
||||
return dev->sensor.optical_res / 4;
|
||||
return sensor.optical_res / 4;
|
||||
}
|
||||
if (xres <= dev->sensor.optical_res / 2)
|
||||
if (xres <= sensor.optical_res / 2)
|
||||
{
|
||||
return dev->sensor.optical_res / 2;
|
||||
return sensor.optical_res / 2;
|
||||
}
|
||||
return dev->sensor.optical_res;
|
||||
return sensor.optical_res;
|
||||
}
|
||||
|
||||
// sanei_genesys_compute_dpihw returns the dpihw that is written to register.
|
||||
// However the number of pixels depends on half_ccd mode
|
||||
int sanei_genesys_compute_dpihw_calibration(Genesys_Device *dev, int xres)
|
||||
int sanei_genesys_compute_dpihw_calibration(Genesys_Device *dev, const Genesys_Sensor& sensor,
|
||||
int xres)
|
||||
{
|
||||
if (dev->model->model_id == MODEL_CANON_CANOSCAN_8600F)
|
||||
{
|
||||
// real resolution is half of the "official" resolution - half_ccd mode
|
||||
int hwres = dev->sensor.optical_res / 4;
|
||||
int hwres = sensor.optical_res / sensor.get_ccd_size_divisor_for_dpi(xres);
|
||||
|
||||
if (xres <= hwres / 4)
|
||||
{
|
||||
|
|
@ -1807,7 +1592,7 @@ int sanei_genesys_compute_dpihw_calibration(Genesys_Device *dev, int xres)
|
|||
return hwres;
|
||||
}
|
||||
|
||||
return sanei_genesys_compute_dpihw(dev, xres);
|
||||
return sanei_genesys_compute_dpihw(dev, sensor, xres);
|
||||
}
|
||||
|
||||
/** @brief motor profile
|
||||
|
|
@ -2043,6 +1828,7 @@ int sanei_genesys_get_lowest_dpi(Genesys_Device *dev)
|
|||
* then given time. */
|
||||
SANE_Status
|
||||
sanei_genesys_is_compatible_calibration (Genesys_Device * dev,
|
||||
const Genesys_Sensor& sensor,
|
||||
Genesys_Calibration_Cache * cache,
|
||||
int for_overwrite)
|
||||
{
|
||||
|
|
@ -2060,7 +1846,7 @@ sanei_genesys_is_compatible_calibration (Genesys_Device * dev,
|
|||
return SANE_STATUS_UNSUPPORTED;
|
||||
}
|
||||
|
||||
status = dev->model->cmd_set->calculate_current_setup (dev);
|
||||
status = dev->model->cmd_set->calculate_current_setup(dev, sensor);
|
||||
if (status != SANE_STATUS_GOOD)
|
||||
{
|
||||
DBG (DBG_error, "%s: failed to calculate current setup: %s\n", __func__,
|
||||
|
|
@ -2076,22 +1862,22 @@ sanei_genesys_is_compatible_calibration (Genesys_Device * dev,
|
|||
if (dev->model->is_cis == SANE_FALSE)
|
||||
{
|
||||
resolution = dev->settings.xres;
|
||||
if(resolution>dev->sensor.optical_res)
|
||||
if(resolution>sensor.optical_res)
|
||||
{
|
||||
resolution=dev->sensor.optical_res;
|
||||
resolution=sensor.optical_res;
|
||||
}
|
||||
compatible = (resolution == ((int) cache->used_setup.xres));
|
||||
}
|
||||
else
|
||||
{
|
||||
resolution=sanei_genesys_compute_dpihw(dev,dev->settings.xres);
|
||||
compatible = (resolution == ((int) sanei_genesys_compute_dpihw(dev,cache->used_setup.xres)));
|
||||
resolution=sanei_genesys_compute_dpihw(dev, sensor, dev->settings.xres);
|
||||
compatible = (resolution == ((int) sanei_genesys_compute_dpihw(dev, sensor,cache->used_setup.xres)));
|
||||
}
|
||||
DBG (DBG_io, "%s: after resolution check current compatible=%d\n", __func__, compatible);
|
||||
if (dev->current_setup.half_ccd != cache->used_setup.half_ccd)
|
||||
if (dev->current_setup.ccd_size_divisor != cache->used_setup.ccd_size_divisor)
|
||||
{
|
||||
DBG (DBG_io, "%s: half_ccd=%d, used=%d\n", __func__,
|
||||
dev->current_setup.half_ccd, cache->used_setup.half_ccd);
|
||||
dev->current_setup.ccd_size_divisor, cache->used_setup.ccd_size_divisor);
|
||||
compatible = 0;
|
||||
}
|
||||
if (dev->current_setup.scan_method != cache->used_setup.scan_method)
|
||||
|
|
|
|||
Plik diff jest za duży
Load Diff
|
|
@ -2169,8 +2169,8 @@ sanei_usb_read_bulk (SANE_Int dn, SANE_Byte * buffer, size_t * size)
|
|||
|
||||
if (ret < 0)
|
||||
{
|
||||
DBG (1, "sanei_usb_read_bulk: read failed: %s\n",
|
||||
sanei_libusb_strerror (ret));
|
||||
DBG (1, "sanei_usb_read_bulk: read failed (still got %d bytes): %s\n",
|
||||
rsize, sanei_libusb_strerror (ret));
|
||||
|
||||
read_size = -1;
|
||||
}
|
||||
|
|
|
|||
Ładowanie…
Reference in New Issue