summaryrefslogtreecommitdiff
path: root/backend/hp4200.c
diff options
context:
space:
mode:
authorJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
committerJörg Frings-Fürst <debian@jff-webhosting.net>2014-10-06 14:00:40 +0200
commit6e9c41a892ed0e0da326e0278b3221ce3f5713b8 (patch)
tree2e301d871bbeeb44aa57ff9cc070fcf3be484487 /backend/hp4200.c
Initial import of sane-backends version 1.0.24-1.2
Diffstat (limited to 'backend/hp4200.c')
-rw-r--r--backend/hp4200.c2979
1 files changed, 2979 insertions, 0 deletions
diff --git a/backend/hp4200.c b/backend/hp4200.c
new file mode 100644
index 0000000..a069be6
--- /dev/null
+++ b/backend/hp4200.c
@@ -0,0 +1,2979 @@
+/*
+ Copyright (C) 2000 by Adrian Perez Jorge
+
+ This program is free software; you can redistribute it and/or
+ modify it under the terms of the GNU General Public License
+ as published by the Free Software Foundation; either version 2
+ of the License, or (at your option) any later version.
+
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
+
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+ */
+
+/* Developers:
+
+ Adrian Perez Jorge (APJ) -
+ Creator of the original HP4200C backend code.
+ adrianpj@easynews.com
+
+ Andrew John Lewis (AJL) -
+ lewi0235@tc.umn.edu
+
+ Arnar Mar Hrafnkelsson (AMH) -
+ addi@umich.edu
+
+ Frank Zago
+ some cleanups and integration into SANE
+
+ Henning Meier-Geinitz <henning@meier-geinitz.de>
+ more cleanups, bug fixes
+
+TODO:
+
+ - support more scanning resolutions.
+ - support different color depths.
+ - support gray and lineart.
+ - improve scanning speed. Compute scanning parameters based on the
+ image size and the scanner-to-host bandwidth.
+ - improve image quality.
+ - fix problem concerning mangled images
+
+*/
+
+#define BUILD 2
+#define BACKEND_NAME hp4200
+
+#include "../include/sane/config.h"
+
+#include <sys/ioctl.h>
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <string.h>
+#include <math.h>
+#include <sys/time.h>
+#include <stdlib.h>
+#include <getopt.h>
+#include <ctype.h>
+#include <assert.h>
+
+#include "../include/sane/sane.h"
+#include "../include/sane/sanei.h"
+#include "../include/sane/sanei_debug.h"
+#include "../include/sane/sanei_config.h"
+#include "../include/sane/sanei_usb.h"
+#include "../include/sane/sanei_pv8630.h"
+#include "../include/sane/saneopts.h"
+#include "../include/sane/sanei_backend.h"
+#include "hp4200.h"
+
+#include "hp4200_lm9830.c"
+
+#define HP4200_CONFIG_FILE "hp4200.conf"
+
+/*--------------------------------------------------------------------------*/
+
+#if 0
+/* Some of these resolution need work in color shifting. */
+static const SANE_Int dpi_list[] =
+ { 8, 50, 75, 100, 150, 200, 300, 400, 600 };
+#else
+static const SANE_Int dpi_list[] = { 4, 75, 150, 300, 600 };
+#endif
+static SANE_Range x_range = { SANE_FIX (0), SANE_FIX (8.5 * MM_PER_INCH), 0 };
+static SANE_Range y_range =
+ { SANE_FIX (0), SANE_FIX (11.75 * MM_PER_INCH), 0 };
+static const SANE_Range u8_range = { 0, 255, 0 };
+
+struct coarse_t
+{
+ int min_red;
+ int min_green;
+ int min_blue;
+ int max_red;
+ int max_green;
+ int max_blue;
+ int red_gain;
+ int red_offset;
+ int green_gain;
+ int green_offset;
+ int blue_gain;
+ int blue_offset;
+};
+
+static const double hdpi_mapping[8] = { 1, 1.5, 2, 3, 4, 6, 8, 12 };
+
+static HP4200_Device *first_device = NULL; /* device list head */
+static int n_devices = 0; /* the device count */
+static const SANE_Device **devlist = NULL;
+
+static unsigned char
+getreg (HP4200_Scanner * s, unsigned char reg)
+{
+ unsigned char reg_value;
+
+ if ((reg > 0x08) && (reg < 0x5b))
+ return (unsigned char) LOBYTE (s->regs[reg]);
+ else
+ {
+ lm9830_read_register (s->fd, reg, &reg_value);
+ return reg_value;
+ }
+}
+
+static void
+setreg (HP4200_Scanner * s, unsigned char reg, unsigned char reg_value)
+{
+ s->regs[reg] = reg_value; /* dirty bit should be clear with this */
+ if ((reg < 0x08) || (reg > 0x5b))
+ {
+ lm9830_write_register (s->fd, reg, reg_value);
+ }
+}
+
+static void
+setbits (HP4200_Scanner * s, unsigned char reg, unsigned char bitmap)
+{
+ s->regs[reg] = (s->regs[reg] & 0xff) | bitmap;
+ if ((reg < 0x08) || (reg > 0x5b))
+ {
+ lm9830_write_register (s->fd, reg, LOBYTE (s->regs[reg]));
+ }
+}
+
+static void
+clearbits (HP4200_Scanner * s, unsigned char reg, unsigned char mask)
+{
+ s->regs[reg] = (s->regs[reg] & ~mask) & 0xff;
+ if ((reg < 0x08) || (reg > 0x5b))
+ {
+ lm9830_write_register (s->fd, reg, LOBYTE (s->regs[reg]));
+ }
+}
+
+static int
+cache_write (HP4200_Scanner * s)
+{
+ int i;
+#ifdef DEBUG_REG_CACHE
+ int counter = 0;
+#endif
+
+ DBG (DBG_proc, "Writing registers\n");
+
+ for (i = 0; i < 0x80; i++)
+ if (!(s->regs[i] & 0x100))
+ { /* modified register */
+#ifdef DEBUG_REG_CACHE
+ fprintf (stderr, "%.2x", i);
+ if (counter == 8)
+ fprintf (stderr, "\n");
+ else
+ fprintf (stderr, ", ");
+ counter = (counter + 1) % 9;
+#endif
+ lm9830_write_register (s->fd, i, s->regs[i]);
+ s->regs[i] |= 0x100; /* register is updated */
+ }
+ return 0;
+}
+
+/*
+ * HP4200-dependent register initialization.
+ */
+
+static int
+hp4200_init_registers (HP4200_Scanner * s)
+{
+ /* set up hardware parameters */
+
+ s->hw_parms.crystal_frequency = 48000000;
+ s->hw_parms.SRAM_size = 128; /* Kb */
+ s->hw_parms.scan_area_width = 5100; /* pixels */
+ s->hw_parms.scan_area_length = 11; /* inches */
+ s->hw_parms.min_pixel_data_buffer_limit = 1024; /* bytes */
+ s->hw_parms.sensor_line_separation = 4; /* lines */
+ s->hw_parms.sensor_max_integration_time = 12; /* milliseconds */
+ s->hw_parms.home_sensor = 2;
+ s->hw_parms.sensor_resolution = 1; /* 600 dpi */
+ s->hw_parms.motor_full_steps_per_inch = 300;
+ s->hw_parms.motor_max_speed = 1.4; /* inches/second */
+ s->hw_parms.num_tr_pulses = 1;
+ s->hw_parms.guard_band_duration = 1;
+ s->hw_parms.pulse_duration = 3;
+ s->hw_parms.fsteps_25_speed = 3;
+ s->hw_parms.fsteps_50_speed = 3;
+ s->hw_parms.target_value.red = 1000;
+ s->hw_parms.target_value.green = 1000;
+ s->hw_parms.target_value.blue = 1000;
+
+ {
+ int i;
+
+ /*
+ * we are using a cache-like data structure so registers whose
+ * values were written to the lm9830 and aren't volatile, have
+ * bit 0x100 activated. This bit must be cleared if you want the
+ * value to be written to the chip once cache_write() is called.
+ */
+
+ /* clears the registers cache */
+ memset (s->regs, 0, sizeof (s->regs));
+
+ /*
+ * registers 0x00 - 0x07 are non-cacheable/volatile, so don't
+ * read the values using the cache. Instead use direct functions
+ * to read/write registers.
+ */
+
+ for (i = 0; i < 0x08; i++)
+ s->regs[i] = 0x100;
+ }
+
+ setreg (s, 0x70, 0x70); /* noise filter */
+
+ setreg (s, 0x0b,
+ INPUT_SIGNAL_POLARITY_NEGATIVE |
+ CDS_ON |
+ SENSOR_STANDARD |
+ SENSOR_RESOLUTION_600 | LINE_SKIPPING_COLOR_PHASE_DELAY (0));
+
+ setreg (s, 0x0c,
+ PHI1_POLARITY_POSITIVE |
+ PHI2_POLARITY_POSITIVE |
+ RS_POLARITY_POSITIVE |
+ CP1_POLARITY_POSITIVE |
+ CP2_POLARITY_POSITIVE |
+ TR1_POLARITY_NEGATIVE | TR2_POLARITY_NEGATIVE);
+
+ setreg (s, 0x0d,
+ PHI1_ACTIVE |
+ PHI2_ACTIVE |
+ RS_ACTIVE |
+ CP1_ACTIVE |
+ CP2_OFF |
+ TR1_ACTIVE |
+ TR2_OFF | NUMBER_OF_TR_PULSES (s->hw_parms.num_tr_pulses));
+
+ setreg (s, 0x0e,
+ TR_PULSE_DURATION (s->hw_parms.pulse_duration) |
+ TR_PHI1_GUARDBAND_DURATION (s->hw_parms.guard_band_duration));
+
+ /* for pixel rate timing */
+ setreg (s, 0x0f, 6);
+ setreg (s, 0x10, 23);
+ setreg (s, 0x11, 1);
+ setreg (s, 0x12, 3);
+ setreg (s, 0x13, 3); /* 0 */
+ setreg (s, 0x14, 5); /* 0 */
+ setreg (s, 0x15, 0);
+ setreg (s, 0x16, 0);
+ setreg (s, 0x17, 11);
+ setreg (s, 0x18, 2); /* 1 */
+
+ setreg (s, 0x19, CIS_TR1_TIMING_OFF | FAKE_OPTICAL_BLACK_PIXELS_OFF);
+
+ setreg (s, 0x1a, 0);
+ setreg (s, 0x1b, 0);
+
+ setreg (s, 0x1c, 0x0d);
+ setreg (s, 0x1d, 0x21);
+
+ setreg (s, 0x27, TR_RED_DROP (0) | TR_GREEN_DROP (0) | TR_BLUE_DROP (0));
+
+ setreg (s, 0x28, 0x00);
+
+ setreg (s, 0x29, ILLUMINATION_MODE (1));
+ setreg (s, 0x2a, HIBYTE (0)); /* 0 */
+ setreg (s, 0x2b, LOBYTE (0)); /* 0 */
+
+ setreg (s, 0x2c, HIBYTE (16383));
+ setreg (s, 0x2d, LOBYTE (16383));
+
+ setreg (s, 0x2e, HIBYTE (2)); /* 2 */
+ setreg (s, 0x2f, LOBYTE (2)); /* 1 */
+
+ setreg (s, 0x30, HIBYTE (0));
+ setreg (s, 0x31, LOBYTE (0));
+
+ setreg (s, 0x32, HIBYTE (0));
+ setreg (s, 0x33, LOBYTE (0));
+
+ setreg (s, 0x34, HIBYTE (32));
+ setreg (s, 0x35, LOBYTE (32));
+
+ setreg (s, 0x36, HIBYTE (48));
+ setreg (s, 0x37, LOBYTE (48));
+
+ setreg (s, 0x42, EPP_MODE | PPORT_DRIVE_CURRENT (3));
+
+ setreg (s, 0x43,
+ RAM_SIZE_128 |
+ SRAM_DRIVER_CURRENT (3) | SRAM_BANDWIDTH_8 | SCANNING_FULL_DUPLEX);
+
+ setreg (s, 0x45,
+ MICRO_STEPPING |
+ CURRENT_SENSING_PHASES (2) |
+ PHASE_A_POLARITY_POSITIVE |
+ PHASE_B_POLARITY_POSITIVE | STEPPER_MOTOR_OUTPUT);
+
+ setreg (s, 0x4a, HIBYTE (100));
+ setreg (s, 0x4b, LOBYTE (100));
+
+ setreg (s, 0x4c, HIBYTE (0));
+ setreg (s, 0x4d, LOBYTE (0));
+
+ /* resume scan threshold */
+ setreg (s, 0x4f, 64);
+ /* steps to reverse */
+ setreg (s, 0x50, 40);
+ setreg (s, 0x51,
+ ACCELERATION_PROFILE_STOPPED (3) |
+ ACCELERATION_PROFILE_25P (s->hw_parms.fsteps_25_speed) |
+ ACCELERATION_PROFILE_50P (s->hw_parms.fsteps_50_speed));
+ setreg (s, 0x54, NON_REVERSING_EXTRA_LINES (0) | FIRST_LINE_TO_PROCESS (0));
+ setreg (s, 0x55, KICKSTART_STEPS (0) | HOLD_CURRENT_TIMEOUT (2));
+
+ /* stepper PWM frequency */
+ setreg (s, 0x56, 8);
+ /* stepper pwm duty cycle */
+ setreg (s, 0x57, 23);
+
+ setreg (s, 0x58,
+ PAPER_SENSOR_1_POLARITY_HIGH |
+ PAPER_SENSOR_1_TRIGGER_EDGE |
+ PAPER_SENSOR_1_NO_STOP_SCAN |
+ PAPER_SENSOR_2_POLARITY_HIGH |
+ PAPER_SENSOR_2_TRIGGER_EDGE | PAPER_SENSOR_2_STOP_SCAN);
+ setreg (s, 0x59,
+ MISCIO_1_TYPE_OUTPUT |
+ MISCIO_1_POLARITY_HIGH |
+ MISCIO_1_TRIGGER_EDGE |
+ MISCIO_1_OUTPUT_STATE_HIGH |
+ MISCIO_2_TYPE_OUTPUT |
+ MISCIO_2_POLARITY_HIGH |
+ MISCIO_2_TRIGGER_EDGE | MISCIO_2_OUTPUT_STATE_HIGH);
+
+ return 0;
+}
+
+#ifdef DEBUG
+static int
+dump_register_cache (HP4200_Scanner * s)
+{
+ int i;
+
+ for (i = 0; i < 0x80; i++)
+ {
+ fprintf (stderr, "%.2x:0x%.2x", i, s->regs[i]);
+ if ((i + 1) % 8)
+ fprintf (stderr, ", ");
+ else
+ fprintf (stderr, "\n");
+ }
+ fputs ("", stderr);
+ return 0;
+}
+#endif
+
+/*
+ * returns the scanner head to home position
+ */
+
+static int
+hp4200_goto_home (HP4200_Scanner * s)
+{
+ unsigned char cmd_reg;
+ unsigned char status_reg;
+ unsigned char old_paper_sensor_reg;
+
+ cmd_reg = getreg (s, 0x07);
+ if (cmd_reg != 2)
+ {
+ unsigned char paper_sensor_reg;
+ unsigned char sensor_bit[2] = { 0x02, 0x10 };
+ /* sensor head is not returning */
+
+ /* let's see if it's already at home */
+ /* first put paper (head) sensor level sensitive */
+ paper_sensor_reg = getreg (s, 0x58);
+ old_paper_sensor_reg = paper_sensor_reg;
+ paper_sensor_reg &= ~sensor_bit[s->hw_parms.home_sensor - 1];
+ setreg (s, 0x58, paper_sensor_reg);
+ cache_write (s);
+
+ /* if the scan head is not at home then move motor backwards */
+ status_reg = getreg (s, 0x02);
+ setreg (s, 0x58, old_paper_sensor_reg);
+ cache_write (s);
+ if (!(status_reg & s->hw_parms.home_sensor))
+ {
+ setreg (s, 0x07, 0x08);
+ usleep (10 * 1000);
+ setreg (s, 0x07, 0x00);
+ usleep (10 * 1000);
+ setreg (s, 0x07, 0x02);
+ }
+ }
+ return 0;
+}
+
+#define HP4200_CHECK_INTERVAL 1000 /* usecs between status checks */
+static int
+hp4200_wait_homed (HP4200_Scanner * s)
+{
+ unsigned char cmd_reg;
+
+ cmd_reg = getreg (s, 0x07);
+ while (cmd_reg != 0)
+ {
+ usleep (HP4200_CHECK_INTERVAL);
+ cmd_reg = getreg (s, 0x07);
+ }
+ return 0;
+}
+
+static int
+compute_fastfeed_step_size (unsigned long crystal_freq, int mclk,
+ float max_speed, int steps_per_inch,
+ int color_mode)
+{
+ int aux;
+ int r;
+
+ if (color_mode == 0)
+ r = 24;
+ else
+ r = 8;
+
+ aux = floor (crystal_freq / ((double) mclk * max_speed * 4.0 *
+ steps_per_inch * r));
+
+
+ if (aux < 2)
+ aux = 2;
+ return aux;
+}
+
+static SANE_Status
+read_available_data (HP4200_Scanner * s, SANE_Byte * buffer,
+ size_t * byte_count)
+{
+ SANE_Status status;
+ unsigned char scankb1;
+ unsigned char scankb2;
+ size_t to_read;
+ size_t really_read;
+ size_t chunk;
+
+ assert (buffer != NULL);
+
+ *byte_count = 0;
+ do
+ {
+ scankb1 = getreg (s, 0x01);
+ scankb2 = getreg (s, 0x01);
+ if (s->aborted_by_user)
+ return SANE_STATUS_CANCELLED;
+ }
+ while ((scankb1 != scankb2) || (scankb1 < 12));
+
+ to_read = scankb1 * 1024;
+
+ while (to_read)
+ {
+ if (s->aborted_by_user)
+ return SANE_STATUS_CANCELLED;
+ chunk = (to_read > 0xffff) ? 0xffff : to_read;
+
+ sanei_pv8630_write_byte (s->fd, PV8630_REPPADDRESS, 0x00);
+ sanei_pv8630_prep_bulkread (s->fd, chunk);
+ really_read = chunk;
+ if ((status = sanei_usb_read_bulk (s->fd, buffer, &really_read)) !=
+ SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "sanei_usb_read_bulk failed (%s)\n",
+ sane_strstatus (status));
+ return status;
+ }
+ if (really_read > to_read)
+ {
+ DBG (DBG_error, "USB stack read more bytes than requested!\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+ *byte_count += really_read;
+ buffer += really_read;
+ to_read -= really_read;
+#ifdef DEBUG
+ fprintf (stderr, "read %d bytes\n", really_read);
+#endif
+ }
+ return SANE_STATUS_GOOD;
+}
+
+#ifdef unused
+static int
+compute_datalink_bandwidth (HP4200_Scanner * s)
+{
+ int line_size;
+ int pause_limit;
+ unsigned int color_mode;
+
+ /*
+ * Line size for 8 bpp, the entire scan area width (plus the
+ * status byte) at optical resolution.
+ */
+
+ if (s->user_parms.color)
+ {
+ line_size = 3 * s->hw_parms.scan_area_width + 1;
+ color_mode = 0;
+ setreg (s, 0x26, color_mode); /* 3 channel pixel rate color */
+ }
+ else
+ {
+ line_size = s->hw_parms.scan_area_width + 1;
+ color_mode = 4;
+ setreg (s, 0x26, 0x08 | color_mode); /* 1 channel mode A (green) */
+ }
+ setreg (s, 0x09, (3 << 3)); /* h-divider = 1, 8 bpp */
+
+ {
+ int first_white_pixel;
+ unsigned int line_end;
+
+ first_white_pixel = s->hw_parms.sensor_pixel_end - 10;
+ line_end = first_white_pixel + s->hw_parms.scan_area_width;
+ if (line_end > (s->hw_parms.sensor_num_pixels - 20))
+ line_end = s->hw_parms.sensor_num_pixels - 20;
+
+ setreg (s, 0x1c, HIBYTE (s->hw_parms.sensor_pixel_start));
+ setreg (s, 0x1d, LOBYTE (s->hw_parms.sensor_pixel_end));
+ setreg (s, 0x1e, HIBYTE (first_white_pixel));
+ setreg (s, 0x1f, LOBYTE (first_white_pixel));
+ setreg (s, 0x20, HIBYTE (s->hw_parms.sensor_num_pixels));
+ setreg (s, 0x21, LOBYTE (s->hw_parms.sensor_num_pixels));
+ setreg (s, 0x22, getreg (s, 0x1e));
+ setreg (s, 0x23, getreg (s, 0x1f));
+ setreg (s, 0x24, HIBYTE (line_end));
+ setreg (s, 0x25, LOBYTE (line_end));
+ }
+
+ /*
+ * During transfer rate calculation don't forward scanner sensor.
+ * Stay in the calibration region.
+ */
+
+ setreg (s, 0x4f, 0);
+ clearbits (s, 0x45, 0x10);
+
+ /*
+ * Pause the scan when memory is full.
+ */
+
+ pause_limit = s->hw_parms.SRAM_size - (line_size / 1024) - 1;
+ setreg (s, 0x4e, pause_limit & 0xff);
+
+ s->mclk = compute_min_mclk (s->hw_parms.SRAM_bandwidth,
+ s->hw_parms.crystal_frequency);
+
+
+ /*
+ * Set step size to fast speed.
+ */
+
+ {
+ int step_size;
+
+ step_size =
+ compute_fastfeed_step_size (s->hw_parms.crystal_frequency,
+ s->mclk,
+ s->hw_parms.scan_bar_max_speed,
+ s->hw_parms.motor_full_steps_per_inch,
+ color_mode);
+
+ setreg (s, 0x46, HIBYTE (step_size));
+ setreg (s, 0x47, LOBYTE (step_size));
+ setreg (s, 0x48, HIBYTE (step_size));
+ setreg (s, 0x49, LOBYTE (step_size));
+ }
+
+ cache_write (s);
+
+ /* dump_register_cache (s); */
+
+ /*
+ * scan during 1 sec. aprox.
+ */
+
+ setreg (s, 0x07, 0x08);
+ setreg (s, 0x07, 0x03);
+
+ {
+ struct timeval tv_before;
+ struct timeval tv_after;
+ int elapsed_time_ms = 0;
+ long bytes_read_total;
+ SANE_Byte *buffer;
+
+ buffer = malloc (2 * 98304); /* check this */
+ if (!buffer)
+ {
+ DBG (DBG_error, "compute_datalink_bandwidth: malloc failed\n");
+ return 0;
+ }
+ bytes_read_total = 0;
+ gettimeofday (&tv_before, NULL);
+ do
+ {
+ size_t bytes_read;
+ SANE_Status status;
+
+ status = read_available_data (s, buffer, &bytes_read);
+ if (status != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "read_available_data failed (%s)\n",
+ sane_strstatus (status));
+ return 0;
+ }
+ bytes_read_total += bytes_read;
+ gettimeofday (&tv_after, NULL);
+ elapsed_time_ms = (tv_after.tv_sec - tv_before.tv_sec) * 1000;
+ elapsed_time_ms += (tv_after.tv_usec - tv_before.tv_usec) / 1000;
+ }
+ while (elapsed_time_ms < 1000);
+
+ setreg (s, 0x07, 0x00);
+ free (buffer);
+
+ s->msrd_parms.datalink_bandwidth = bytes_read_total /
+ (elapsed_time_ms / 1000);
+
+#ifdef DEBUG
+ fprintf (stderr, "PC Transfer rate = %d bytes/sec. (%ld/%d)\n",
+ s->msrd_parms.datalink_bandwidth, bytes_read_total,
+ elapsed_time_ms);
+#endif
+ }
+ return 0;
+}
+#endif
+
+static void
+compute_first_gain_offset (int target, int max, int min, int *gain,
+ int *offset, int *max_gain, int *min_offset)
+{
+ *gain = (int) 15.0 *(target / (max - min) - 0.933);
+ *offset = (int) (-1.0 * min / (512.0 * 0.0195));
+ if (*gain >= 32)
+ {
+ *gain = (int) 15.0 *(target / 3.0 / (max - min) - 0.933);
+ *offset = (int) -3.0 * min / (512.0 * 0.0195);
+ }
+ if (*gain < 0)
+ *gain = 0;
+ else if (*gain > 63)
+ *gain = 63;
+
+ if (*offset < -31)
+ *offset = -31;
+ else if (*offset > 31)
+ *offset = 31;
+
+ *max_gain = 63;
+ *min_offset = -31;
+}
+
+#define DATA_PORT_READ (1 << 5)
+#define DATA_PORT_WRITE 0
+
+static int
+write_gamma (HP4200_Scanner * s)
+{
+ SANE_Status status;
+ int color;
+ int i;
+ unsigned char gamma[1024];
+ unsigned char read_gamma[1024];
+ int retval;
+ size_t to_read;
+ size_t to_write;
+
+ for (color = 0; color < 3; color++)
+ {
+ for (i = 0; i < 1024; i++)
+ gamma[i] = s->user_parms.gamma[color][i];
+
+ setreg (s, 0x03, color << 1);
+ setreg (s, 0x04, DATA_PORT_WRITE);
+ setreg (s, 0x05, 0x00);
+ sanei_pv8630_write_byte (s->fd, PV8630_REPPADDRESS, 0x06);
+ sanei_pv8630_prep_bulkwrite (s->fd, sizeof (gamma));
+ to_write = sizeof (gamma);
+ sanei_usb_write_bulk (s->fd, gamma, &to_write);
+
+ /* check if gamma vector was correctly written */
+
+ setreg (s, 0x03, color << 1);
+ setreg (s, 0x04, DATA_PORT_READ);
+ setreg (s, 0x05, 0x00);
+ sanei_pv8630_write_byte (s->fd, PV8630_REPPADDRESS, 0x06);
+ sanei_pv8630_prep_bulkread (s->fd, sizeof (read_gamma));
+ to_read = sizeof (read_gamma);
+ status = sanei_usb_read_bulk (s->fd, read_gamma, &to_read);
+ retval = memcmp (read_gamma, gamma, sizeof (read_gamma));
+ if (retval != 0)
+ {
+ DBG (DBG_error, "error: color %d has bad gamma table\n", color);
+ }
+#ifdef DEBUG
+ else
+ fprintf (stderr, "color %d gamma table is good\n", color);
+#endif
+ }
+
+ return 0;
+}
+
+static int
+write_default_offset_gain (HP4200_Scanner * s, SANE_Byte * gain_offset,
+ int size, int color)
+{
+ SANE_Byte *check_data;
+ int retval;
+ size_t to_read;
+ size_t to_write;
+
+ setreg (s, 0x03, (color << 1) | 1);
+ setreg (s, 0x04, DATA_PORT_WRITE);
+ setreg (s, 0x05, 0x00);
+ sanei_pv8630_write_byte (s->fd, PV8630_REPPADDRESS, 0x06);
+ sanei_pv8630_prep_bulkwrite (s->fd, size);
+ to_write = size;
+ sanei_usb_write_bulk (s->fd, gain_offset, &to_write);
+
+ check_data = malloc (size);
+ setreg (s, 0x03, (color << 1) | 1);
+ setreg (s, 0x04, DATA_PORT_READ);
+ setreg (s, 0x05, 0x00);
+ sanei_pv8630_write_byte (s->fd, PV8630_REPPADDRESS, 0x06);
+ sanei_pv8630_prep_bulkread (s->fd, size);
+ to_read = size;
+ sanei_usb_read_bulk (s->fd, check_data, &to_read);
+ retval = memcmp (gain_offset, check_data, size);
+ free (check_data);
+ if (retval != 0)
+ {
+ DBG (DBG_error, "error: color %d has bad gain/offset table\n", color);
+ }
+#ifdef DEBUG
+ else
+ fprintf (stderr, "color %d gain/offset table is good\n", color);
+#endif
+
+ return 0;
+}
+
+static int
+compute_gain_offset (int target, int max, int min, int *gain,
+ int *offset, int *max_gain, int *min_offset)
+{
+ int gain_stable;
+ int is_unstable;
+
+ gain_stable = 1; /* unless the opposite is said */
+ is_unstable = 0;
+
+ if (max > target)
+ {
+ if (*gain > 0)
+ {
+ (*gain)--;
+ *max_gain = *gain;
+ gain_stable = 0;
+ is_unstable |= 1;
+ }
+ else
+ {
+ DBG (DBG_error, "error: integration time too long.\n");
+ return -1;
+ }
+ }
+ else
+ {
+ if (*gain < *max_gain)
+ {
+ (*gain)++;
+ gain_stable = 0;
+ is_unstable |= 1;
+ }
+ }
+
+ if (min == 0)
+ {
+ if (*offset < 31)
+ {
+ (*offset)++;
+ if (gain_stable)
+ *min_offset = *offset;
+ is_unstable |= 1;
+ }
+ else
+ {
+ DBG (DBG_error, "error: max static has pixel value == 0\n");
+ return -1;
+ }
+ }
+ else
+ {
+ if (*offset > *min_offset)
+ {
+ (*offset)--;
+ is_unstable |= 1;
+ }
+ }
+ return is_unstable;
+}
+
+static int
+compute_bytes_per_line (int width_in_pixels, unsigned char hdpi_code,
+ unsigned char pixel_packing,
+ unsigned char data_mode,
+ unsigned char AFE_operation, int m)
+{
+ const int dpi_qot_mul[] = { 1, 2, 1, 1, 1, 1, 1, 1 };
+ const int dpi_qot_div[] = { 1, 3, 2, 3, 4, 6, 8, 12 };
+ int pixels_per_line;
+ int bytes_per_line;
+ int pixels_per_byte;
+ int status_bytes;
+ const int pixels_per_byte_mapping[] = { 8, 4, 2, 1 };
+
+ assert (hdpi_code <= 7);
+ pixels_per_line = (width_in_pixels * dpi_qot_mul[hdpi_code]) /
+ dpi_qot_div[hdpi_code];
+ if ((width_in_pixels * dpi_qot_mul[hdpi_code]) % dpi_qot_div[hdpi_code])
+ pixels_per_line++;
+
+
+ status_bytes = (m == 0) ? 1 : m;
+
+ if (data_mode == 1)
+ pixels_per_byte = 1; /* should be 0.5 but later
+ bytes_per_line will be multiplied
+ by 2, and also the number of status
+ bytes, that in this case should be
+ 2.
+ umm.. maybe this should be done in
+ the cleaner way.
+ */
+ else
+ {
+ assert (pixel_packing <= 3);
+ pixels_per_byte = pixels_per_byte_mapping[pixel_packing];
+ }
+
+ switch (AFE_operation)
+ {
+ case PIXEL_RATE_3_CHANNELS:
+ bytes_per_line = ((pixels_per_line * 3) / pixels_per_byte) +
+ status_bytes;
+ break;
+ case MODEA_1_CHANNEL:
+ bytes_per_line = (pixels_per_line / pixels_per_byte) + status_bytes;
+ break;
+ default:
+ /* Not implemented! (yet?) and not used.
+ * This case should not happen. */
+ assert (0);
+ }
+
+ if (data_mode == 1) /* see big note above */
+ bytes_per_line *= 2;
+
+ return bytes_per_line;
+}
+
+static int
+compute_pause_limit (hardware_parameters_t * hw_parms, int bytes_per_line)
+{
+ int coef_size;
+ const int coef_mapping[] = { 16, 32 };
+ int pause_limit;
+
+ coef_size = coef_mapping[hw_parms->sensor_resolution & 0x01];
+ pause_limit = hw_parms->SRAM_size - coef_size - (bytes_per_line / 1024) - 1;
+
+ if (pause_limit > 2)
+ pause_limit -= 2;
+
+ return pause_limit;
+}
+
+static int
+compute_dpd (HP4200_Scanner * s, int step_size, int line_end)
+{
+ int tr, dpd;
+
+ tr = 1 /* color mode */ *
+ (line_end + ((s->hw_parms.num_tr_pulses + 1) *
+ (2 * s->hw_parms.guard_band_duration +
+ s->hw_parms.pulse_duration + 1) +
+ 3 - s->hw_parms.num_tr_pulses));
+
+ if (tr == 0)
+ return 0;
+
+ dpd = (((s->hw_parms.fsteps_25_speed * 4) +
+ (s->hw_parms.fsteps_50_speed * 2) +
+ s->hw_parms.steps_to_reverse) * 4 * step_size) % tr;
+ dpd = tr - dpd;
+
+ return dpd;
+}
+
+static SANE_Status
+read_required_bytes (HP4200_Scanner * s, int required, SANE_Byte * buffer)
+{
+ int read_count = 0;
+ unsigned char scankb1;
+ unsigned char scankb2;
+ size_t to_read;
+ size_t really_read;
+ size_t chunk;
+ SANE_Status status;
+
+ assert (buffer != NULL);
+
+ while (required)
+ {
+ do
+ {
+ scankb1 = getreg (s, 0x01);
+ scankb2 = getreg (s, 0x01);
+ if (s->aborted_by_user)
+ return SANE_STATUS_CANCELLED;
+ }
+ while ((scankb1 != scankb2) || (scankb1 < 12));
+
+ to_read = min (required, (scankb1 * 1024));
+ while (to_read)
+ {
+ if (s->aborted_by_user)
+ return SANE_STATUS_CANCELLED;
+ chunk = (to_read > 0xffff) ? 0xffff : to_read;
+
+ sanei_pv8630_write_byte (s->fd, PV8630_REPPADDRESS, 0x00);
+ sanei_pv8630_prep_bulkread (s->fd, chunk);
+ really_read = chunk;
+ if ((status = sanei_usb_read_bulk (s->fd, buffer, &really_read)) !=
+ SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "sanei_usb_read_bulk failed (%s)\n",
+ sane_strstatus (status));
+ return status;
+ }
+ if (really_read > chunk)
+ {
+ DBG (DBG_error, "USB stack read more bytes than requested!\n");
+ return SANE_STATUS_IO_ERROR;
+ }
+ buffer += really_read;
+ required -= really_read;
+ to_read -= really_read;
+ read_count += really_read;
+ }
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+scanner_buffer_init (scanner_buffer_t * sb, int size_in_kb)
+{
+
+ sb->size = size_in_kb * 1024 + 3;
+ sb->buffer = malloc (sb->size);
+ if (!sb->buffer)
+ return SANE_STATUS_NO_MEM;
+ sb->num_bytes = 0;
+ sb->data_ptr = sb->buffer;
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+scanner_buffer_read (HP4200_Scanner * s)
+{
+ SANE_Status status;
+ size_t num_bytes_read_now;
+
+ assert (s->scanner_buffer.num_bytes <= 3);
+
+ memcpy (s->scanner_buffer.buffer, s->scanner_buffer.data_ptr, 3);
+
+ status = read_available_data (s, s->scanner_buffer.buffer +
+ s->scanner_buffer.num_bytes,
+ &num_bytes_read_now);
+ s->scanner_buffer.data_ptr = s->scanner_buffer.buffer;
+ s->scanner_buffer.num_bytes += num_bytes_read_now;
+ return status;
+}
+
+#define OFFSET_CODE_SIGN(off) (((off) < 0) ? (-(off) & 0x1f) | 0x20 : (off))
+#define OFFSET_DECODE_SIGN(off) (((off) & 0x20) ? -(off & 0x1f) : (off))
+
+static SANE_Status
+do_coarse_calibration (HP4200_Scanner * s, struct coarse_t *coarse)
+{
+ SANE_Status status;
+ unsigned char *cal_line = NULL;
+ unsigned char *cal_line_ptr;
+ int cal_line_size;
+ /* local scanning params */
+ int active_pixels_start;
+ int line_end;
+ int data_pixels_start;
+ int data_pixels_end;
+ int dpd;
+ int step_size;
+ int ff_step_size;
+ char steps_to_reverse;
+ char hdpi_div;
+ char line_rate_color;
+ int vdpi; /* vertical dots per inch */
+ int hdpi_code;
+ int calibrated;
+ int first_time;
+
+ int red_offset = 0;
+ int green_offset = 0;
+ int blue_offset = 0;
+
+ int red_gain = 1;
+ int green_gain = 1;
+ int blue_gain = 1;
+
+ int min_red_offset = -31;
+ int min_green_offset = -31;
+ int min_blue_offset = -31;
+
+ int max_red_gain = 63;
+ int max_green_gain = 63;
+ int max_blue_gain = 63;
+
+ int max_red;
+ int min_red;
+ int max_green;
+ int min_green;
+ int max_blue;
+ int min_blue;
+ static char me[] = "do_coarse_calibration";
+
+ DBG (DBG_proc, "%s\n", me);
+
+ setreg (s, 0x07, 0x00);
+ usleep (10 * 1000);
+
+ vdpi = 150;
+ hdpi_code = 0;
+ hdpi_div = hdpi_mapping[hdpi_code];
+ active_pixels_start = 0x40;
+ line_end = 0x2ee0;
+ s->mclk_div = 2;
+ data_pixels_start = 0x40;
+ data_pixels_end = (int) (data_pixels_start + s->hw_parms.scan_area_width);
+ data_pixels_end = min (data_pixels_end, line_end - 20);
+
+ cal_line_size = s->hw_parms.scan_area_width * 3 * 2 + 2;
+
+ setreg (s, 0x1e, HIBYTE (active_pixels_start));
+ setreg (s, 0x1f, LOBYTE (active_pixels_start));
+ setreg (s, 0x20, HIBYTE (line_end));
+ setreg (s, 0x21, LOBYTE (line_end));
+ setreg (s, 0x22, HIBYTE (data_pixels_start));
+ setreg (s, 0x23, LOBYTE (data_pixels_start));
+ setreg (s, 0x24, HIBYTE (data_pixels_end));
+ setreg (s, 0x25, LOBYTE (data_pixels_end));
+
+ setreg (s, 0x26,
+ PIXEL_RATE_3_CHANNELS |
+ GRAY_CHANNEL_RED | TR_RED (0) | TR_GREEN (0) | TR_BLUE (0));
+
+
+ setreg (s, 0x08, (s->mclk_div - 1) * 2);
+ setreg (s, 0x09, hdpi_code | PIXEL_PACKING (3) | DATAMODE (1));
+ setreg (s, 0x0a, 0); /* reserved and strange register */
+
+ setreg (s, 0x38, red_offset);
+ setreg (s, 0x39, green_offset);
+ setreg (s, 0x3a, blue_offset);
+ setreg (s, 0x3b, red_gain);
+ setreg (s, 0x3c, green_gain);
+ setreg (s, 0x3d, blue_gain);
+
+ setreg (s, 0x5e, 0x80);
+
+ setreg (s, 0x3e, 0x00); /* 1.5:1, 6/10 bits, 2*fixed */
+ setreg (s, 0x3f, 0x00);
+ setreg (s, 0x40, 0x00);
+ setreg (s, 0x41, 0x00);
+
+ setreg (s, 0x4e, 0x5b - 0x3c); /* max Kb to pause */
+ setreg (s, 0x4f, 0x02); /* min Kb to resume */
+
+ line_rate_color = 1;
+ step_size = (vdpi * line_end * line_rate_color) /
+ (4 * s->hw_parms.motor_full_steps_per_inch);
+
+ dpd = compute_dpd (s, step_size, line_end); /* 0x0ada; */
+#ifdef DEBUG
+ fprintf (stderr, "dpd = %d\n", dpd);
+#endif
+ setreg (s, 0x52, HIBYTE (dpd));
+ setreg (s, 0x53, LOBYTE (dpd));
+
+ setreg (s, 0x46, HIBYTE (step_size));
+ setreg (s, 0x47, LOBYTE (step_size));
+
+ ff_step_size = compute_fastfeed_step_size (s->hw_parms.crystal_frequency, s->mclk_div, s->hw_parms.motor_max_speed, s->hw_parms.motor_full_steps_per_inch, 0); /* 0x0190; */
+ setreg (s, 0x48, HIBYTE (ff_step_size));
+ setreg (s, 0x49, LOBYTE (ff_step_size));
+ setreg (s, 0x4b, 0x15);
+ steps_to_reverse = 0x3f;
+ setreg (s, 0x50, steps_to_reverse);
+ setreg (s, 0x51, 0x15); /* accel profile */
+
+ /* this is to stay the motor stopped */
+ clearbits (s, 0x45, (1 << 4));
+
+ cache_write (s);
+
+ calibrated = 0;
+ first_time = 1;
+ cal_line = malloc (cal_line_size + 1024);
+
+ do
+ {
+ unsigned char cmd_reg;
+
+ /* resets the lm9830 before start scanning */
+ setreg (s, 0x07, 0x08);
+ do
+ {
+ setreg (s, 0x07, 0x03);
+ cmd_reg = getreg (s, 0x07);
+ }
+ while (cmd_reg != 0x03);
+
+ cal_line_ptr = cal_line;
+ status = read_required_bytes (s, cal_line_size, cal_line_ptr);
+ if (status != SANE_STATUS_GOOD)
+ goto done;
+
+ setreg (s, 0x07, 0x00);
+ {
+ unsigned int i;
+ min_red = max_red = (cal_line[0] * 256 + cal_line[1]) >> 2;
+ min_green = max_green = (cal_line[2] * 256 + cal_line[3]) >> 2;
+ min_blue = max_blue = (cal_line[4] * 256 + cal_line[5]) >> 2;
+ for (i = 6; i < (s->hw_parms.scan_area_width * 3 * 2); i += 6)
+ {
+ int value;
+
+ value = cal_line[i] * 256 + cal_line[i + 1];
+ value >>= 2;
+ if (value > max_red)
+ max_red = value;
+ value = cal_line[i + 2] * 256 + cal_line[i + 3];
+ value >>= 2;
+ if (value > max_green)
+ max_green = value;
+ value = cal_line[i + 4] * 256 + cal_line[i + 5];
+ value >>= 2;
+ if (value > max_blue)
+ max_blue = value;
+ value = cal_line[i] * 256 + cal_line[i + 1];
+ value >>= 2;
+ if (value < min_red)
+ min_red = value;
+ value = cal_line[i + 2] * 256 + cal_line[i + 3];
+ value >>= 2;
+ if (value < min_green)
+ min_green = value;
+ value = cal_line[i + 4] * 256 + cal_line[i + 5];
+ value >>= 2;
+ if (value < min_blue)
+ min_blue = value;
+ }
+#ifdef DEBUG
+ fprintf (stderr, "max_red:%d max_green:%d max_blue:%d\n",
+ max_red, max_green, max_blue);
+ fprintf (stderr, "min_red:%d min_green:%d min_blue:%d\n",
+ min_red, min_green, min_blue);
+#endif
+
+ if (first_time)
+ {
+ first_time = 0;
+ compute_first_gain_offset (s->hw_parms.target_value.red,
+ max_red, min_red,
+ &red_gain, &red_offset,
+ &max_red_gain, &min_red_offset);
+ compute_first_gain_offset (s->hw_parms.target_value.green,
+ max_green, min_green,
+ &green_gain, &green_offset,
+ &max_green_gain, &min_green_offset);
+ compute_first_gain_offset (s->hw_parms.target_value.blue,
+ max_blue, min_blue, &blue_gain,
+ &blue_offset, &max_blue_gain,
+ &min_blue_offset);
+ }
+ else
+ {
+ int retval;
+
+ /* this code should check return value -1 for error */
+
+ retval = compute_gain_offset (s->hw_parms.target_value.red,
+ max_red, min_red,
+ &red_gain, &red_offset,
+ &max_red_gain, &min_red_offset);
+ if (retval < 0)
+ break;
+ retval |= compute_gain_offset (s->hw_parms.target_value.green,
+ max_green, min_green,
+ &green_gain, &green_offset,
+ &max_green_gain,
+ &min_green_offset);
+ if (retval < 0)
+ break;
+ retval |= compute_gain_offset (s->hw_parms.target_value.blue,
+ max_blue, min_blue,
+ &blue_gain, &blue_offset,
+ &max_blue_gain, &min_blue_offset);
+ if (retval < 0)
+ break;
+ calibrated = !retval;
+ }
+
+ setreg (s, 0x3b, red_gain);
+ setreg (s, 0x3c, green_gain);
+ setreg (s, 0x3d, blue_gain);
+
+ setreg (s, 0x38, OFFSET_CODE_SIGN (red_offset));
+ setreg (s, 0x39, OFFSET_CODE_SIGN (green_offset));
+ setreg (s, 0x3a, OFFSET_CODE_SIGN (blue_offset));
+
+#ifdef DEBUG
+ fprintf (stderr, "%d, %d, %d %d, %d, %d\n", red_gain,
+ green_gain, blue_gain, red_offset, green_offset,
+ blue_offset);
+#endif
+ cache_write (s);
+ }
+ }
+ while (!calibrated);
+ coarse->min_red = min_red;
+ coarse->min_green = min_green;
+ coarse->min_blue = min_blue;
+ coarse->max_red = max_red;
+ coarse->max_green = max_green;
+ coarse->max_blue = max_blue;
+ coarse->red_gain = red_gain;
+ coarse->green_gain = green_gain;
+ coarse->blue_gain = blue_gain;
+ coarse->red_offset = red_offset;
+ coarse->green_offset = green_offset;
+ coarse->blue_offset = blue_offset;
+
+ status = SANE_STATUS_GOOD;
+
+done:
+ if (cal_line)
+ free (cal_line);
+
+ return status;
+}
+
+static int
+compute_corr_code (int average, int min_color, int range, int target)
+{
+ int value;
+ int corr_code;
+
+ value = average - min_color;
+ if (value > 0)
+ corr_code =
+ (int) (range * ((double) target / (double) value - 1.0) + 0.5);
+ else
+ corr_code = 0;
+ if (corr_code < 0)
+ corr_code = 0;
+ else if (corr_code > 2048)
+ corr_code = 0;
+ else if (corr_code > 1023)
+ corr_code = 1023;
+ return corr_code;
+}
+
+static int
+compute_hdpi_code (int hres)
+{
+ int hdpi_code;
+
+ /* Calculate the horizontal DPI code based on the requested
+ horizontal resolution. Defaults to 150dpi. */
+ switch (hres)
+ {
+ case 600:
+ hdpi_code = 0;
+ break;
+ case 400:
+ hdpi_code = 1;
+ break;
+ case 300:
+ hdpi_code = 2;
+ break;
+ case 200:
+ hdpi_code = 3;
+ break;
+ case 150:
+ hdpi_code = 4;
+ break;
+ case 100:
+ hdpi_code = 5;
+ break;
+ case 75:
+ hdpi_code = 6;
+ break;
+ case 50:
+ hdpi_code = 7;
+ break;
+ default:
+ hdpi_code = 4;
+ }
+ return hdpi_code;
+}
+
+
+static SANE_Status
+do_fine_calibration (HP4200_Scanner * s, struct coarse_t *coarse)
+{
+ SANE_Status status;
+ unsigned char *cal_line;
+ unsigned char *cal_line_ptr;
+ int *average;
+ SANE_Byte red_gain_offset[5460 * 2];
+ SANE_Byte green_gain_offset[5460 * 2];
+ SANE_Byte blue_gain_offset[5460 * 2];
+ int *corr_red = NULL;
+ int *corr_green = NULL;
+ int *corr_blue = NULL;
+ int registro[30][5460 * 3];
+ int cal_line_size;
+ /* local scanning params */
+ int active_pixels_start;
+ int line_end;
+ int line_length;
+ int data_pixels_start;
+ int data_pixels_end;
+ int dpd;
+ int step_size;
+ int ff_step_size;
+ char steps_to_reverse;
+ char hdpi_div;
+ char line_rate_color;
+ int vdpi; /* vertical dots per inch */
+ int hdpi_code;
+ int calibrated;
+ int first_time;
+ int lines_to_process;
+
+ static char me[] = "do_fine_calibration";
+
+ DBG (DBG_proc, "%s\n", me);
+
+ setreg (s, 0x07, 0x00);
+ usleep (10 * 1000);
+
+ vdpi = 150;
+ hdpi_code = compute_hdpi_code (s->user_parms.horizontal_resolution);
+
+ /* figure out which horizontal divider to use based on the
+ calculated horizontal dpi code */
+ hdpi_div = hdpi_mapping[hdpi_code];
+ active_pixels_start = 0x40;
+ line_end = 0x2ee0;
+ line_length = s->user_parms.image_width * hdpi_div;
+ s->mclk_div = 2;
+ data_pixels_start = 0x72 + s->runtime_parms.first_pixel * hdpi_div;
+ data_pixels_end =
+ (int) (data_pixels_start + s->user_parms.image_width * hdpi_div);
+ data_pixels_end = min (data_pixels_end, line_end - 20);
+
+ cal_line_size = line_length * 3 * 2 + 2;
+
+ setreg (s, 0x1e, HIBYTE (active_pixels_start));
+ setreg (s, 0x1f, LOBYTE (active_pixels_start));
+ setreg (s, 0x20, HIBYTE (line_end));
+ setreg (s, 0x21, LOBYTE (line_end));
+ setreg (s, 0x22, HIBYTE (data_pixels_start));
+ setreg (s, 0x23, LOBYTE (data_pixels_start));
+ setreg (s, 0x24, HIBYTE (data_pixels_end));
+ setreg (s, 0x25, LOBYTE (data_pixels_end));
+
+ setreg (s, 0x26,
+ PIXEL_RATE_3_CHANNELS |
+ GRAY_CHANNEL_RED | TR_RED (0) | TR_GREEN (0) | TR_BLUE (0));
+
+
+ setreg (s, 0x08, (s->mclk_div - 1) * 2);
+ setreg (s, 0x09, 0 | PIXEL_PACKING (3) | DATAMODE (1));
+ setreg (s, 0x0a, 0); /* reserved and strange register */
+
+ setreg (s, 0x38, 1);
+ setreg (s, 0x39, 1);
+ setreg (s, 0x3a, 1);
+ setreg (s, 0x3b, coarse->red_gain);
+ setreg (s, 0x3c, coarse->green_gain);
+ setreg (s, 0x3d, coarse->blue_gain);
+
+ setreg (s, 0x5e, 0x80);
+
+ setreg (s, 0x3e, 0x00); /* 1.5:1, 6/10 bits, 2*fixed */
+ setreg (s, 0x3f, 0x00);
+ setreg (s, 0x40, 0x00);
+ setreg (s, 0x41, 0x00);
+
+ setreg (s, 0x4e, 0x5b - 0x3c); /* max Kb to pause */
+ setreg (s, 0x4f, 0x02); /* min Kb to resume */
+
+ line_rate_color = 1;
+ step_size = (vdpi * line_end * line_rate_color) /
+ (4 * s->hw_parms.motor_full_steps_per_inch);
+
+ dpd = compute_dpd (s, step_size, line_end); /* 0x0ada; */
+#ifdef DEBUG
+ fprintf (stderr, "dpd = %d\n", dpd);
+#endif
+ setreg (s, 0x52, HIBYTE (dpd));
+ setreg (s, 0x53, LOBYTE (dpd));
+
+ setreg (s, 0x46, HIBYTE (step_size));
+ setreg (s, 0x47, LOBYTE (step_size));
+
+ ff_step_size = compute_fastfeed_step_size (s->hw_parms.crystal_frequency, s->mclk_div, s->hw_parms.motor_max_speed, s->hw_parms.motor_full_steps_per_inch, 0); /* 0x0190; */
+ setreg (s, 0x48, HIBYTE (ff_step_size));
+ setreg (s, 0x49, LOBYTE (ff_step_size));
+ setreg (s, 0x4b, 0x15);
+ steps_to_reverse = 0x3f;
+ setreg (s, 0x50, steps_to_reverse);
+ setreg (s, 0x51, 0x15); /* accel profile */
+
+ /* this is to activate the motor */
+ setbits (s, 0x45, (1 << 4));
+
+ lines_to_process = 8 * step_size * 4 / line_end;
+ if (lines_to_process < 1)
+ lines_to_process = 1;
+
+#ifdef DEBUG
+ fprintf (stderr, "lines to process = %d\n", lines_to_process);
+#endif
+
+ setreg (s, 0x58, 0);
+
+ cache_write (s);
+
+ calibrated = 0;
+ first_time = 1;
+ cal_line = malloc (cal_line_size + 1024);
+ average = malloc (sizeof (int) * line_length * 3);
+ memset (average, 0, sizeof (int) * line_length * 3);
+ {
+ int i;
+ for (i = 0; i < 12; i++)
+ {
+ memset (registro[i], 0, 5460 * 3);
+ }
+ }
+
+ /* resets the lm9830 before start scanning */
+ setreg (s, 0x07, 0x08);
+ setreg (s, 0x07, 0x03);
+
+ usleep (100);
+
+ do
+ {
+
+ cal_line_ptr = cal_line;
+
+ status = read_required_bytes (s, cal_line_size, cal_line_ptr);
+ if (status != SANE_STATUS_GOOD)
+ goto done;
+ {
+ int i, j;
+
+ if (calibrated == 0)
+ for (j = 0, i = 0; i < (line_length * 3); i++, j += 2)
+ {
+ average[i] = (cal_line[j] * 256 + cal_line[j + 1]) >> 2;
+ registro[calibrated][i] = average[i];
+ }
+ else
+ for (j = 0, i = 0; i < (line_length * 3); i++, j += 2)
+ {
+ int value;
+ value = (cal_line[j] * 256 + cal_line[j + 1]) >> 2;
+ average[i] += value;
+ average[i] /= 2;
+ registro[calibrated][i] = value;
+ }
+ }
+ calibrated++;
+ }
+ while (calibrated < lines_to_process);
+ lm9830_write_register (s->fd, 0x07, 0x00);
+ usleep (10 * 1000);
+
+#if 0
+ {
+ int i;
+ int j = 0;
+ do
+ {
+ for (i = 3; (i + 6) < (line_length * 3); i += 3)
+ {
+ average[i] =
+ (2 * average[i - 3] + average[i] + 2 * average[i + 3]) / 5;
+ average[i + 1] =
+ (2 * average[i - 2] + average[i + 1] + 2 * average[i + 4]) / 5;
+ average[i + 2] =
+ (2 * average[i - 1] + average[i + 2] + 2 * average[i + 5]) / 5;
+ }
+ j++;
+ }
+ while (j < 3);
+ }
+#endif
+ {
+ int i;
+ int max_red;
+ int min_red;
+ int max_green;
+ int min_green;
+ int max_blue;
+ int min_blue;
+ min_red = max_red = average[0];
+ min_green = max_green = average[1];
+ min_blue = max_blue = average[2];
+ for (i = 3; i < (line_length * 3); i += 3)
+ {
+ int value;
+
+ value = average[i];
+ if (value > max_red)
+ max_red = value;
+ value = average[i + 1];
+ if (value > max_green)
+ max_green = value;
+ value = average[i + 2];
+ if (value > max_blue)
+ max_blue = value;
+ value = average[i];
+ if (value < min_red)
+ min_red = value;
+ value = average[i + 1];
+ if (value < min_green)
+ min_green = value;
+ value = average[i + 2];
+ if (value < min_blue)
+ min_blue = value;
+ }
+#ifdef DEBUG
+ fprintf (stderr, "max_red:%d max_green:%d max_blue:%d\n",
+ max_red, max_green, max_blue);
+ fprintf (stderr, "min_red:%d min_green:%d min_blue:%d\n",
+ min_red, min_green, min_blue);
+#endif
+
+ /* do fine calibration */
+ {
+ int min_white_red;
+ int min_white_green;
+ int min_white_blue;
+ double ratio;
+ int range;
+ double aux;
+ int min_white_err;
+ int j;
+
+ min_white_red = min_white_green = min_white_blue = 0x3ff;
+ for (i = 0; i < (line_length * 3); i += 3)
+ {
+ int value;
+
+ value = average[i] - coarse->min_red;
+ if ((value > 0) && (value < min_white_red))
+ min_white_red = value;
+ value = average[i + 1] - coarse->min_green;
+ if ((value > 0) && (value < min_white_green))
+ min_white_green = value;
+ value = average[i + 2] - coarse->min_blue;
+ if ((value > 0) && (value < min_white_blue))
+ min_white_blue = value;
+ }
+
+ ratio = 0;
+ min_white_err = 0x3ff;
+
+ aux = (double) s->hw_parms.target_value.red / min_white_red;
+ if (aux > ratio)
+ ratio = aux;
+ if (min_white_err > min_white_red)
+ min_white_err = min_white_red;
+ aux = (double) s->hw_parms.target_value.green / min_white_green;
+ if (aux > ratio)
+ ratio = aux;
+ if (min_white_err > min_white_green)
+ min_white_err = min_white_green;
+ aux = (double) s->hw_parms.target_value.blue / min_white_blue;
+ if (aux > ratio)
+ ratio = aux;
+ if (min_white_err > min_white_blue)
+ min_white_err = min_white_blue;
+
+#ifdef DEBUG
+ fprintf (stderr, "min_white_err = %d, ratio = %f\n",
+ min_white_err, ratio);
+#endif
+ if (ratio <= 1.5)
+ range = 2048;
+ else if (ratio <= 2.0)
+ range = 1024;
+ else
+ range = 512;
+
+ corr_red = malloc (sizeof (int) * line_length);
+ corr_green = malloc (sizeof (int) * line_length);
+ corr_blue = malloc (sizeof (int) * line_length);
+
+ for (i = 0, j = 0; i < (line_length * 3); i += 3, j++)
+ {
+ corr_red[j] = compute_corr_code (average[i],
+ coarse->min_red,
+ range,
+ s->hw_parms.target_value.red);
+ corr_green[j] =
+ compute_corr_code (average[i + 1], coarse->min_green,
+ range, s->hw_parms.target_value.green);
+ corr_blue[j] =
+ compute_corr_code (average[i + 2], coarse->min_blue,
+ range, s->hw_parms.target_value.blue);
+ }
+#ifdef DEBUG
+ {
+ FILE *kaka;
+ int i;
+ kaka = fopen ("corr.raw", "w");
+ for (i = 0; i < line_length; i++)
+ {
+ fprintf (kaka, "%d %d %d %d %d %d ",
+ corr_red[i], corr_green[i], corr_blue[i],
+ average[3 * i], average[3 * i + 1], average[3 * i + 2]);
+ fprintf (kaka, "%d %d %d %d %d %d %d %d %d ",
+ registro[0][3 * i], registro[0][3 * i + 1],
+ registro[0][3 * i + 2], registro[1][3 * i],
+ registro[1][3 * i + 1], registro[1][3 * i + 2],
+ registro[2][3 * i], registro[2][3 * i + 1],
+ registro[2][3 * i + 2]);
+ fprintf (kaka, "%d %d %d %d %d %d %d %d %d\n",
+ registro[3][3 * i], registro[3][3 * i + 1],
+ registro[3][3 * i + 2], registro[4][3 * i],
+ registro[4][3 * i + 1], registro[4][3 * i + 2],
+ registro[5][3 * i], registro[5][3 * i + 1],
+ registro[5][3 * i + 2]);
+ }
+ fclose (kaka);
+ }
+#endif
+ {
+ int max_black;
+ int use_six_eight_bits;
+
+ max_black = max (coarse->min_red, coarse->min_green);
+ max_black = max (max_black, coarse->min_blue);
+ use_six_eight_bits = (max_black < 64);
+
+ if (use_six_eight_bits)
+ {
+ setreg (s, 0x3e, (1 << 4) | (1 << 3) | (1024 / range));
+ }
+ else
+ {
+ setreg (s, 0x3e, (1 << 4) | (1 << 3) | (1 << 2) | (1024 / range));
+ }
+ memset (red_gain_offset, 0, sizeof (red_gain_offset));
+ memset (green_gain_offset, 0, sizeof (green_gain_offset));
+ memset (blue_gain_offset, 0, sizeof (blue_gain_offset));
+ for (i = 0, j = (data_pixels_start - active_pixels_start) * 2;
+ i < line_length; i++, j += 2)
+ {
+ if (use_six_eight_bits)
+ {
+ red_gain_offset[j] = (coarse->min_red << 2) |
+ ((corr_red[i] >> 8) & 0x03);
+ red_gain_offset[j + 1] = corr_red[i] & 0xff;
+ green_gain_offset[j] = (coarse->min_green << 2) |
+ ((corr_green[i] >> 8) & 0x03);
+ green_gain_offset[j + 1] = corr_green[i] & 0xff;
+ blue_gain_offset[j] = (coarse->min_blue << 2) |
+ ((corr_blue[i] >> 8) & 0x03);
+ blue_gain_offset[j + 1] = corr_blue[i] & 0xff;
+ }
+ else
+ {
+ red_gain_offset[j] = coarse->min_red;
+ red_gain_offset[j + 1] = corr_red[j] >> 2;
+ green_gain_offset[j] = coarse->min_green;
+ green_gain_offset[j + 1] = corr_green[j] >> 2;
+ blue_gain_offset[j] = coarse->min_blue;
+ blue_gain_offset[j + 1] = corr_blue[j] >> 2;
+ }
+ }
+ write_default_offset_gain (s, red_gain_offset, 5460 * 2, 0);
+ write_default_offset_gain (s, green_gain_offset, 5460 * 2, 1);
+ write_default_offset_gain (s, blue_gain_offset, 5460 * 2, 2);
+ }
+ }
+ }
+
+ status = SANE_STATUS_GOOD;
+
+done:
+ if (corr_red)
+ free (corr_red);
+ if (corr_green)
+ free (corr_green);
+ if (corr_blue)
+ free (corr_blue);
+ if (cal_line)
+ free (cal_line);
+ if (average)
+ free (average);
+
+ return status;
+}
+
+static void
+ciclic_buffer_init_offset_correction (ciclic_buffer_t * cb, int vres)
+{
+ cb->blue_idx = 0;
+ switch (vres)
+ {
+ case 600:
+ cb->green_idx = 4;
+ cb->red_idx = 8;
+ cb->first_good_line = 8;
+ break;
+ case 400:
+ cb->green_idx = 3;
+ cb->red_idx = 6;
+ cb->first_good_line = 6;
+ break;
+ case 300:
+ cb->green_idx = 2;
+ cb->red_idx = 4;
+ cb->first_good_line = 4;
+ break;
+ case 200:
+ cb->blue_idx = 0;
+ cb->green_idx = 1;
+ cb->red_idx = 2;
+ cb->first_good_line = 4;
+ break;
+ case 150:
+ cb->green_idx = 1;
+ cb->red_idx = 2;
+ cb->first_good_line = 2;
+ break;
+ case 75:
+ cb->green_idx = 1;
+ cb->red_idx = 2;
+ cb->first_good_line = 2;
+ break;
+ default:
+ cb->green_idx = 0;
+ cb->red_idx = 0;
+ cb->first_good_line = 0;
+ break;
+ }
+
+ cb->buffer_position = cb->buffer_ptrs[cb->first_good_line];
+}
+
+static SANE_Status
+ciclic_buffer_init (ciclic_buffer_t * cb, SANE_Int bytes_per_line,
+ int vres, int status_bytes)
+{
+ cb->good_bytes = 0;
+ cb->num_lines = 12;
+ cb->size = bytes_per_line * cb->num_lines;
+ cb->can_consume = cb->size + cb->num_lines * status_bytes;
+
+ cb->buffer = malloc (cb->size);
+ if (!cb->buffer)
+ return SANE_STATUS_NO_MEM;
+
+ {
+ int i;
+ unsigned char *buffer;
+ unsigned char **ptrs;
+
+ ptrs = cb->buffer_ptrs = (unsigned char **)
+ malloc (sizeof (unsigned char *) * cb->num_lines);
+ if (!cb->buffer_ptrs)
+ return SANE_STATUS_NO_MEM;
+
+ buffer = cb->buffer;
+ for (i = 0; i < cb->num_lines; i++)
+ {
+ ptrs[i] = buffer;
+ buffer += bytes_per_line;
+ }
+ }
+
+ cb->current_line = 0;
+ cb->pixel_position = 0;
+ ciclic_buffer_init_offset_correction (cb, vres);
+
+ return SANE_STATUS_GOOD;
+}
+
+static int
+prepare_for_a_scan (HP4200_Scanner * s)
+{
+ /* local scanning params */
+ int active_pixels_start;
+ int line_end;
+ int data_pixels_start;
+ int data_pixels_end;
+ int ff_step_size;
+ int dpd;
+ int step_size;
+ char steps_to_reverse;
+ char hdpi_div;
+ char line_rate_color;
+ int hdpi_code;
+ unsigned char pixel_packing;
+ unsigned char data_mode;
+ unsigned char AFE_operation;
+ int pause_limit;
+ int n = 0, m = 0;
+
+ setreg (s, 0x07, 0x00);
+ usleep (10 * 1000);
+
+ hdpi_code = compute_hdpi_code (s->user_parms.horizontal_resolution);
+ /* figure out which horizontal divider to use based on the
+ calculated horizontal dpi code */
+ hdpi_div = hdpi_mapping[hdpi_code];
+
+ /* image_width is set to the correct number of pixels by calling
+ fxn. This might be the reason we can't do high res full width
+ scans though...not sure. */
+ /*s->user_parms.image_width /= 4; */
+ active_pixels_start = 0x40;
+ line_end = 0x2ee0; /* 2ee0 */
+ s->mclk_div = 2;
+ data_pixels_start = 0x72 + s->runtime_parms.first_pixel * hdpi_div;
+ data_pixels_end =
+ (int) (data_pixels_start + s->user_parms.image_width * hdpi_div);
+ data_pixels_end = min (data_pixels_end, line_end - 20);
+ setreg (s, 0x1e, HIBYTE (active_pixels_start));
+ setreg (s, 0x1f, LOBYTE (active_pixels_start));
+ setreg (s, 0x20, HIBYTE (line_end));
+ setreg (s, 0x21, LOBYTE (line_end));
+ setreg (s, 0x22, HIBYTE (data_pixels_start));
+ setreg (s, 0x23, LOBYTE (data_pixels_start));
+ setreg (s, 0x24, HIBYTE (data_pixels_end));
+ setreg (s, 0x25, LOBYTE (data_pixels_end));
+
+ AFE_operation = PIXEL_RATE_3_CHANNELS;
+ setreg (s, 0x26,
+ AFE_operation |
+ GRAY_CHANNEL_RED | TR_RED (0) | TR_GREEN (0) | TR_BLUE (0));
+
+ setreg (s, 0x08, (s->mclk_div - 1) * 2);
+ pixel_packing = 3;
+ data_mode = 0;
+ setreg (s, 0x09, hdpi_code | PIXEL_PACKING (pixel_packing) |
+ DATAMODE (data_mode));
+ setreg (s, 0x0a, 0); /* reserved and strange register */
+
+ setreg (s, 0x5c, 0x00);
+ setreg (s, 0x5d, 0x00);
+ setreg (s, 0x5e, 0x00);
+
+ if (s->user_parms.vertical_resolution == 1200)
+ {
+ /* 1 out of 2 */
+ n = 1;
+ m = 2;
+ }
+ setreg (s, 0x44, (256 - n) & 0xff);
+ setreg (s, 0x5a, m);
+ s->runtime_parms.status_bytes = (m == 0) ? 1 : m;
+ if (data_mode == 1)
+ s->runtime_parms.status_bytes *= 2;
+
+ s->runtime_parms.scanner_line_size =
+ compute_bytes_per_line (data_pixels_end - data_pixels_start,
+ hdpi_code, pixel_packing, data_mode,
+ AFE_operation, m);
+ pause_limit = compute_pause_limit (&(s->hw_parms),
+ s->runtime_parms.scanner_line_size);
+
+#ifdef DEBUG
+ fprintf (stderr, "scanner_line_size = %d\npause_limit = %d\n",
+ s->runtime_parms.scanner_line_size, pause_limit);
+#endif
+
+ setreg (s, 0x4e, pause_limit); /* max Kb to pause */
+ setreg (s, 0x4f, 0x02); /* min Kb to resume */
+
+ line_rate_color = 1;
+ step_size =
+ (s->user_parms.vertical_resolution * line_end * line_rate_color) /
+ (4 * s->hw_parms.motor_full_steps_per_inch);
+
+ if (s->val[OPT_BACKTRACK].b)
+ {
+ steps_to_reverse = 0x3f;
+ setreg (s, 0x50, steps_to_reverse);
+ setreg (s, 0x51, 0x15); /* accel profile */
+ }
+ else
+ {
+ s->hw_parms.steps_to_reverse = 0;
+ setreg (s, 0x50, s->hw_parms.steps_to_reverse);
+ setreg (s, 0x51, 0); /* accel profile */
+ s->hw_parms.fsteps_25_speed = 0;
+ s->hw_parms.fsteps_50_speed = 0;
+ }
+
+ dpd = compute_dpd (s, step_size, line_end); /* 0x0ada; */
+#ifdef DEBUG
+ fprintf (stderr, "dpd = %d\n", dpd);
+#endif
+ setreg (s, 0x52, HIBYTE (dpd));
+ setreg (s, 0x53, LOBYTE (dpd));
+
+ setreg (s, 0x46, HIBYTE (step_size));
+ setreg (s, 0x47, LOBYTE (step_size));
+
+ ff_step_size = compute_fastfeed_step_size (s->hw_parms.crystal_frequency,
+ s->mclk_div,
+ s->hw_parms.motor_max_speed,
+ s->hw_parms.
+ motor_full_steps_per_inch, 0);
+ setreg (s, 0x48, HIBYTE (ff_step_size));
+ setreg (s, 0x49, LOBYTE (ff_step_size));
+ setreg (s, 0x4b, 0x15);
+ /* this is to stay the motor running */
+ setbits (s, 0x45, (1 << 4));
+
+ setreg (s, 0x4a, HIBYTE (47 + s->runtime_parms.steps_to_skip));
+ setreg (s, 0x4b, LOBYTE (47 + s->runtime_parms.steps_to_skip));
+
+ setreg (s, 0x58, 0);
+
+ ciclic_buffer_init (&(s->ciclic_buffer),
+ s->runtime_parms.image_line_size,
+ s->user_parms.vertical_resolution,
+ s->runtime_parms.status_bytes);
+
+ s->runtime_parms.num_bytes_left_to_scan =
+ s->user_parms.lines_to_scan * s->runtime_parms.image_line_size;
+
+#ifdef DEBUG
+ fprintf (stderr, "bytes to scan = %ld\n",
+ s->runtime_parms.num_bytes_left_to_scan);
+#endif
+
+ cache_write (s);
+
+#ifdef DEBUG
+ lm9830_dump_registers (s->fd);
+#endif
+
+ lm9830_reset (s->fd);
+
+ setreg (s, 0x07, 0x03);
+ usleep (100);
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+end_scan (HP4200_Scanner * s)
+{
+ s->scanning = SANE_FALSE;
+ setreg (s, 0x07, 0x00);
+ lm9830_reset (s->fd);
+ setbits (s, 0x58, PAPER_SENSOR_2_STOP_SCAN);
+ cache_write (s);
+ setreg (s, 0x07, 0x02);
+
+ /* Free some buffers */
+ if (s->ciclic_buffer.buffer)
+ {
+ free (s->ciclic_buffer.buffer);
+ s->ciclic_buffer.buffer = NULL;
+ }
+ if (s->ciclic_buffer.buffer_ptrs)
+ {
+ free (s->ciclic_buffer.buffer_ptrs);
+ s->ciclic_buffer.buffer_ptrs = NULL;
+ }
+ if (s->scanner_buffer.buffer)
+ {
+ free (s->scanner_buffer.buffer);
+ s->scanner_buffer.buffer = NULL;
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+static int
+hp4200_init_scanner (HP4200_Scanner * s)
+{
+ int ff_step_size;
+ int mclk_div;
+
+ lm9830_ini_scanner (s->fd, NULL);
+ hp4200_init_registers (s);
+ scanner_buffer_init (&(s->scanner_buffer), s->hw_parms.SRAM_size);
+ setreg (s, 0x07, 0x08);
+ usleep (10 * 1000);
+ setreg (s, 0x07, 0x00);
+ usleep (10 * 1000);
+ mclk_div = 2;
+
+ setreg (s, 0x08, (mclk_div - 1) * 2);
+ ff_step_size =
+ compute_fastfeed_step_size (s->hw_parms.crystal_frequency,
+ mclk_div,
+ s->hw_parms.motor_max_speed,
+ s->hw_parms.motor_full_steps_per_inch, 0);
+ setreg (s, 0x48, HIBYTE (ff_step_size));
+ setreg (s, 0x49, LOBYTE (ff_step_size));
+ setbits (s, 0x45, (1 << 4));
+ cache_write (s);
+ return 0;
+}
+
+static void
+ciclic_buffer_copy (ciclic_buffer_t * cb, SANE_Byte * buf,
+ SANE_Int num_bytes, int image_line_size, int status_bytes)
+{
+ int biggest_upper_block_size;
+ int upper_block_size;
+ int lower_block_size;
+ int bytes_to_be_a_entire_line;
+
+ /* copy the upper block */
+ biggest_upper_block_size = cb->size - (cb->buffer_position - cb->buffer);
+ upper_block_size = min (biggest_upper_block_size, num_bytes);
+ memcpy (buf, cb->buffer_position, upper_block_size);
+ cb->good_bytes -= upper_block_size;
+
+ bytes_to_be_a_entire_line = (cb->buffer_position - cb->buffer) %
+ image_line_size;
+ cb->can_consume += upper_block_size +
+ status_bytes * (((bytes_to_be_a_entire_line + upper_block_size) /
+ image_line_size) - 1);
+
+ if (num_bytes < biggest_upper_block_size)
+ {
+ cb->buffer_position += num_bytes;
+ return;
+ }
+
+ /* copy the lower block */
+ lower_block_size = num_bytes - biggest_upper_block_size;
+ if (lower_block_size > 0)
+ {
+ memcpy (buf + biggest_upper_block_size, cb->buffer, lower_block_size);
+ cb->good_bytes -= lower_block_size;
+ cb->can_consume += lower_block_size + status_bytes *
+ (lower_block_size / image_line_size);
+ cb->buffer_position = cb->buffer + lower_block_size;
+ }
+ else
+ {
+ cb->buffer_position = cb->buffer;
+ }
+ assert (cb->good_bytes >= 0);
+ assert (lower_block_size >= 0);
+}
+
+static void
+ciclic_buffer_consume (ciclic_buffer_t * cb,
+ scanner_buffer_t * scanner_buffer,
+ int image_width, int status_bytes)
+{
+ int to_consume;
+ int to_consume_now;
+ int i;
+ int processed;
+
+ to_consume = min (cb->can_consume, scanner_buffer->num_bytes);
+
+ while (to_consume)
+ {
+
+ if (cb->pixel_position == image_width)
+ {
+ if (scanner_buffer->num_bytes >= status_bytes)
+ {
+ /* forget status bytes */
+ scanner_buffer->data_ptr += status_bytes;
+ scanner_buffer->num_bytes -= status_bytes;
+ cb->can_consume -= status_bytes;
+ to_consume -= status_bytes;
+
+ cb->pixel_position = 0; /* back to the start pixel */
+
+ cb->red_idx = (cb->red_idx + 1) % cb->num_lines;
+ cb->green_idx = (cb->green_idx + 1) % cb->num_lines;
+ cb->blue_idx = (cb->blue_idx + 1) % cb->num_lines;
+ cb->current_line++;
+ }
+ else
+ break;
+ }
+
+ to_consume_now = min ((image_width - cb->pixel_position) * 3,
+ to_consume);
+
+ if (to_consume_now < 3)
+ break;
+
+ for (i = cb->pixel_position * 3; to_consume_now >= 3;
+ i += 3, to_consume_now -= 3)
+ {
+ cb->buffer_ptrs[cb->red_idx][i] = scanner_buffer->data_ptr[0];
+ cb->buffer_ptrs[cb->green_idx][i + 1] = scanner_buffer->data_ptr[1];
+ cb->buffer_ptrs[cb->blue_idx][i + 2] = scanner_buffer->data_ptr[2];
+ scanner_buffer->data_ptr += 3;
+ }
+ processed = i - (cb->pixel_position * 3);
+ cb->pixel_position = i / 3;
+ to_consume -= processed;
+ cb->can_consume -= processed;
+ scanner_buffer->num_bytes -= processed;
+ if (cb->current_line > cb->first_good_line)
+ cb->good_bytes += processed;
+ }
+}
+
+SANE_Status
+sane_read (SANE_Handle h, SANE_Byte * buf, SANE_Int maxlen, SANE_Int * len)
+{
+ SANE_Status status;
+ int to_copy_now;
+ int bytes_to_copy_to_frontend;
+ HP4200_Scanner *s = h;
+
+ static char me[] = "sane_read";
+ DBG (DBG_proc, "%s\n", me);
+
+ if (!(s->scanning))
+ {
+ /* OOPS, not scanning */
+ return SANE_STATUS_CANCELLED;
+ }
+
+ if (!buf || !len)
+ return SANE_STATUS_INVAL;
+
+ *len = 0;
+
+ if (s->runtime_parms.num_bytes_left_to_scan == 0)
+ {
+ end_scan (s);
+ return SANE_STATUS_EOF;
+ }
+
+ bytes_to_copy_to_frontend = min (s->runtime_parms.num_bytes_left_to_scan,
+ maxlen);
+
+ /* first copy available data from the ciclic buffer */
+ to_copy_now = min (s->ciclic_buffer.good_bytes, bytes_to_copy_to_frontend);
+
+ if (to_copy_now > 0)
+ {
+ ciclic_buffer_copy (&(s->ciclic_buffer), buf, to_copy_now,
+ s->runtime_parms.image_line_size,
+ s->runtime_parms.status_bytes);
+ buf += to_copy_now;
+ bytes_to_copy_to_frontend -= to_copy_now;
+ *len += to_copy_now;
+ }
+
+ /* if not enough bytes, get data from the scanner */
+ while (bytes_to_copy_to_frontend)
+ {
+ if (s->scanner_buffer.num_bytes < 3)
+ { /* cicl buf consumes modulo 3
+ bytes at least now for rgb
+ color 8 bpp fixme: but this
+ is ugly and not generic
+ */
+ status = scanner_buffer_read (s);
+
+ if (status == SANE_STATUS_CANCELLED)
+ {
+ end_scan (s);
+ s->aborted_by_user = SANE_FALSE;
+ return status;
+ }
+ if (status != SANE_STATUS_GOOD)
+ return status;
+ }
+
+ while ((s->scanner_buffer.num_bytes > 3) && bytes_to_copy_to_frontend)
+ {
+ ciclic_buffer_consume (&(s->ciclic_buffer), &(s->scanner_buffer),
+ s->user_parms.image_width,
+ s->runtime_parms.status_bytes);
+ to_copy_now = min (s->ciclic_buffer.good_bytes,
+ bytes_to_copy_to_frontend);
+
+ if (to_copy_now > 0)
+ {
+ ciclic_buffer_copy (&(s->ciclic_buffer), buf, to_copy_now,
+ s->runtime_parms.image_line_size,
+ s->runtime_parms.status_bytes);
+ buf += to_copy_now;
+ bytes_to_copy_to_frontend -= to_copy_now;
+ *len += to_copy_now;
+ }
+ }
+ }
+
+ s->runtime_parms.num_bytes_left_to_scan -= *len;
+
+ if (s->runtime_parms.num_bytes_left_to_scan < 0)
+ *len += s->runtime_parms.num_bytes_left_to_scan;
+
+ return SANE_STATUS_GOOD;
+}
+
+static HP4200_Device *
+find_device (SANE_String_Const name)
+{
+ static char me[] = "find_device";
+ HP4200_Device *dev;
+
+ DBG (DBG_proc, "%s\n", me);
+
+ for (dev = first_device; dev; dev = dev->next)
+ {
+ if (strcmp (dev->dev.name, name) == 0)
+ {
+ return dev;
+ }
+ }
+ return NULL;
+}
+
+static SANE_Status
+add_device (SANE_String_Const name, HP4200_Device ** argpd)
+{
+ int fd;
+ HP4200_Device *pd;
+ static const char me[] = "add_device";
+ SANE_Status status;
+
+ DBG (DBG_proc, "%s(%s)\n", me, name);
+
+ /* Avoid adding the same device more than once */
+ if ((pd = find_device (name)))
+ {
+ if (argpd)
+ *argpd = pd;
+ return SANE_STATUS_GOOD;
+ }
+
+ /* open the device file, but read only or read/write to perform
+ ioctl's ? */
+ if ((status = sanei_usb_open (name, &fd)) != SANE_STATUS_GOOD)
+ {
+ DBG (DBG_error, "%s: open(%s) failed: %s\n", me, name,
+ sane_strstatus (status));
+ return SANE_STATUS_INVAL;
+ }
+
+ /* put here some code to probe that the device attached to the
+ device file is a supported scanner. Maybe some ioctl */
+ sanei_usb_close (fd);
+
+ pd = (HP4200_Device *) calloc (1, sizeof (HP4200_Device));
+ if (!pd)
+ {
+ DBG (DBG_error, "%s: out of memory allocating device.\n", me);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ pd->dev.name = strdup (name);
+ pd->dev.vendor = "Hewlett-Packard";
+ pd->dev.model = "HP-4200";
+ pd->dev.type = "flatbed scanner";
+
+ if (!pd->dev.name || !pd->dev.vendor || !pd->dev.model || !pd->dev.type)
+ {
+ DBG (DBG_error,
+ "%s: out of memory allocating device descriptor strings.\n", me);
+ free (pd);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ pd->handle = NULL;
+ pd->next = first_device;
+ first_device = pd;
+ n_devices++;
+ if (argpd)
+ *argpd = pd;
+
+ return SANE_STATUS_GOOD;
+}
+
+static SANE_Status
+attach (SANE_String_Const name)
+{
+ static char me[] = "attach";
+ DBG (DBG_proc, "%s\n", me);
+ return add_device (name, NULL);
+}
+
+SANE_Status
+sane_init (SANE_Int * version_code, SANE_Auth_Callback authorize)
+{
+ static const char me[] = "sane_hp4200_init";
+ char dev_name[PATH_MAX];
+ FILE *fp;
+
+ authorize = authorize; /* keep gcc quiet */
+
+ DBG_INIT ();
+
+ DBG (DBG_proc, "%s\n", me);
+ DBG (DBG_error, "SANE hp4200 backend version %d.%d build %d from %s\n",
+ SANE_CURRENT_MAJOR, V_MINOR, BUILD, PACKAGE_STRING);
+ /* put some version_code checks here */
+
+ if (NULL != version_code)
+ {
+ *version_code = SANE_VERSION_CODE (SANE_CURRENT_MAJOR, V_MINOR, 0);
+ }
+
+ sanei_usb_init ();
+ sanei_pv8630_init ();
+
+ fp = sanei_config_open (HP4200_CONFIG_FILE);
+ if (!fp)
+ {
+ DBG (DBG_error, "%s: configuration file not found!\n", me);
+
+ return SANE_STATUS_INVAL;
+ }
+ else
+ {
+ while (sanei_config_read (dev_name, sizeof (dev_name), fp))
+ {
+ if (dev_name[0] == '#') /* ignore line comments */
+ continue;
+
+ if (strlen (dev_name) == 0)
+ continue; /* ignore empty lines */
+
+ DBG (DBG_info, "%s: looking for devices matching %s\n",
+ me, dev_name);
+
+ sanei_usb_attach_matching_devices (dev_name, attach);
+ }
+
+ fclose (fp);
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+void
+sane_exit (void)
+{
+ HP4200_Device *device, *next;
+
+ DBG (DBG_proc, "sane_hp4200_exit\n");
+
+ for (device = first_device; device; device = next)
+ {
+ next = device->next;
+ if (device->handle)
+ {
+ sane_close (device->handle);
+ }
+ if (device->dev.name)
+ {
+ free (device->dev.name);
+ }
+ free (device);
+ }
+ first_device = NULL;
+
+ if (devlist)
+ {
+ free (devlist);
+ devlist = NULL;
+ }
+
+ n_devices = 0;
+
+ DBG (DBG_proc, "sane_exit: exit\n");
+}
+
+SANE_Status
+sane_get_devices (const SANE_Device *** device_list, SANE_Bool local_only)
+{
+ int i;
+ HP4200_Device *pdev;
+
+ DBG (DBG_proc, "sane_get_devices (%p, %d)\n", (void *) device_list,
+ local_only);
+
+ /* Waste the last list returned from this function */
+ if (devlist)
+ free (devlist);
+
+ devlist = (const SANE_Device **)
+ malloc ((n_devices + 1) * sizeof (SANE_Device *));
+
+ if (!devlist)
+ {
+ DBG (DBG_error, "sane_get_devices: out of memory\n");
+ return SANE_STATUS_NO_MEM;
+ }
+
+ for (i = 0, pdev = first_device; pdev; i++, pdev = pdev->next)
+ {
+ devlist[i] = &(pdev->dev);
+ }
+ devlist[i] = NULL;
+
+ *device_list = devlist;
+
+ DBG (DBG_proc, "sane_get_devices: exit\n");
+
+ return SANE_STATUS_GOOD;
+}
+
+static void
+init_options (HP4200_Scanner * s)
+{
+ s->opt[OPT_NUM_OPTS].name = "";
+ s->opt[OPT_NUM_OPTS].title = SANE_TITLE_NUM_OPTIONS;
+ s->opt[OPT_NUM_OPTS].desc = SANE_DESC_NUM_OPTIONS;
+ s->opt[OPT_NUM_OPTS].cap = SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_NUM_OPTS].type = SANE_TYPE_INT;
+ s->opt[OPT_NUM_OPTS].unit = SANE_UNIT_NONE;
+ s->opt[OPT_NUM_OPTS].size = sizeof (SANE_Word);
+ s->opt[OPT_NUM_OPTS].constraint_type = SANE_CONSTRAINT_NONE;
+ s->val[OPT_NUM_OPTS].w = NUM_OPTIONS;
+
+ s->opt[OPT_RES].name = SANE_NAME_SCAN_RESOLUTION;
+ s->opt[OPT_RES].title = SANE_TITLE_SCAN_RESOLUTION;
+ s->opt[OPT_RES].desc = SANE_DESC_SCAN_RESOLUTION;
+ s->opt[OPT_RES].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_RES].type = SANE_TYPE_INT;
+ s->opt[OPT_RES].size = sizeof (SANE_Word);
+ s->opt[OPT_RES].unit = SANE_UNIT_DPI;
+ s->opt[OPT_RES].constraint_type = SANE_CONSTRAINT_WORD_LIST;
+ s->opt[OPT_RES].constraint.word_list = dpi_list;
+ s->val[OPT_RES].w = 150;
+
+ s->opt[OPT_TL_X].name = SANE_NAME_SCAN_TL_X;
+ s->opt[OPT_TL_X].title = SANE_TITLE_SCAN_TL_X;
+ s->opt[OPT_TL_X].desc = SANE_DESC_SCAN_TL_X;
+ s->opt[OPT_TL_X].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_TL_X].type = SANE_TYPE_FIXED;
+ s->opt[OPT_TL_X].size = sizeof (SANE_Fixed);
+ s->opt[OPT_TL_X].unit = SANE_UNIT_MM;
+ s->opt[OPT_TL_X].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_TL_X].constraint.range = &x_range;
+ s->val[OPT_TL_X].w = x_range.min;
+
+ s->opt[OPT_TL_Y].name = SANE_NAME_SCAN_TL_Y;
+ s->opt[OPT_TL_Y].title = SANE_TITLE_SCAN_TL_Y;
+ s->opt[OPT_TL_Y].desc = SANE_DESC_SCAN_TL_Y;
+ s->opt[OPT_TL_Y].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_TL_Y].type = SANE_TYPE_FIXED;
+ s->opt[OPT_TL_Y].size = sizeof (SANE_Fixed);
+ s->opt[OPT_TL_Y].unit = SANE_UNIT_MM;
+ s->opt[OPT_TL_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_TL_Y].constraint.range = &y_range;
+ s->val[OPT_TL_Y].w = y_range.min;
+
+ s->opt[OPT_BR_X].name = SANE_NAME_SCAN_BR_X;
+ s->opt[OPT_BR_X].title = SANE_TITLE_SCAN_BR_X;
+ s->opt[OPT_BR_X].desc = SANE_DESC_SCAN_BR_X;
+ s->opt[OPT_BR_X].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_BR_X].type = SANE_TYPE_FIXED;
+ s->opt[OPT_BR_X].size = sizeof (SANE_Fixed);
+ s->opt[OPT_BR_X].unit = SANE_UNIT_MM;
+ s->opt[OPT_BR_X].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_BR_X].constraint.range = &x_range;
+ s->val[OPT_BR_X].w = x_range.max;
+
+ s->opt[OPT_BR_Y].name = SANE_NAME_SCAN_BR_Y;
+ s->opt[OPT_BR_Y].title = SANE_TITLE_SCAN_BR_Y;
+ s->opt[OPT_BR_Y].desc = SANE_DESC_SCAN_BR_Y;
+ s->opt[OPT_BR_Y].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_BR_Y].type = SANE_TYPE_FIXED;
+ s->opt[OPT_BR_Y].size = sizeof (SANE_Fixed);
+ s->opt[OPT_BR_Y].unit = SANE_UNIT_MM;
+ s->opt[OPT_BR_Y].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_BR_Y].constraint.range = &y_range;
+ s->val[OPT_BR_Y].w = y_range.max;
+
+ s->opt[OPT_BACKTRACK].name = SANE_NAME_BACKTRACK;
+ s->opt[OPT_BACKTRACK].title = SANE_TITLE_BACKTRACK;
+ s->opt[OPT_BACKTRACK].desc = SANE_DESC_BACKTRACK;
+ s->opt[OPT_BACKTRACK].cap = SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_BACKTRACK].type = SANE_TYPE_BOOL;
+ s->opt[OPT_BACKTRACK].size = sizeof (SANE_Bool);
+ s->opt[OPT_BACKTRACK].unit = SANE_UNIT_NONE;
+ s->opt[OPT_BACKTRACK].constraint_type = SANE_CONSTRAINT_NONE;
+ s->val[OPT_BACKTRACK].b = SANE_TRUE;
+
+ s->opt[OPT_GAMMA_VECTOR_R].name = SANE_NAME_GAMMA_VECTOR_R;
+ s->opt[OPT_GAMMA_VECTOR_R].title = SANE_TITLE_GAMMA_VECTOR_R;
+ s->opt[OPT_GAMMA_VECTOR_R].desc = SANE_DESC_GAMMA_VECTOR_R;
+ s->opt[OPT_GAMMA_VECTOR_R].cap =
+ SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_GAMMA_VECTOR_R].type = SANE_TYPE_INT;
+ s->opt[OPT_GAMMA_VECTOR_R].size = 1024 * sizeof (SANE_Word);
+ s->opt[OPT_GAMMA_VECTOR_R].unit = SANE_UNIT_NONE;
+ s->opt[OPT_GAMMA_VECTOR_R].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_GAMMA_VECTOR_R].constraint.range = &u8_range;
+ s->val[OPT_GAMMA_VECTOR_R].wa = s->user_parms.gamma[0];
+
+ s->opt[OPT_GAMMA_VECTOR_G].name = SANE_NAME_GAMMA_VECTOR_G;
+ s->opt[OPT_GAMMA_VECTOR_G].title = SANE_TITLE_GAMMA_VECTOR_G;
+ s->opt[OPT_GAMMA_VECTOR_G].desc = SANE_DESC_GAMMA_VECTOR_G;
+ s->opt[OPT_GAMMA_VECTOR_G].cap =
+ SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_GAMMA_VECTOR_G].type = SANE_TYPE_INT;
+ s->opt[OPT_GAMMA_VECTOR_G].size = 1024 * sizeof (SANE_Word);
+ s->opt[OPT_GAMMA_VECTOR_G].unit = SANE_UNIT_NONE;
+ s->opt[OPT_GAMMA_VECTOR_G].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_GAMMA_VECTOR_G].constraint.range = &u8_range;
+ s->val[OPT_GAMMA_VECTOR_G].wa = s->user_parms.gamma[1];
+
+ s->opt[OPT_GAMMA_VECTOR_B].name = SANE_NAME_GAMMA_VECTOR_B;
+ s->opt[OPT_GAMMA_VECTOR_B].title = SANE_TITLE_GAMMA_VECTOR_B;
+ s->opt[OPT_GAMMA_VECTOR_B].desc = SANE_DESC_GAMMA_VECTOR_B;
+ s->opt[OPT_GAMMA_VECTOR_B].cap =
+ SANE_CAP_SOFT_SELECT | SANE_CAP_SOFT_DETECT;
+ s->opt[OPT_GAMMA_VECTOR_B].type = SANE_TYPE_INT;
+ s->opt[OPT_GAMMA_VECTOR_B].size = 1024 * sizeof (SANE_Word);
+ s->opt[OPT_GAMMA_VECTOR_B].unit = SANE_UNIT_NONE;
+ s->opt[OPT_GAMMA_VECTOR_B].constraint_type = SANE_CONSTRAINT_RANGE;
+ s->opt[OPT_GAMMA_VECTOR_B].constraint.range = &u8_range;
+ s->val[OPT_GAMMA_VECTOR_B].wa = s->user_parms.gamma[2];
+
+ {
+ int i;
+ double gamma = 2.0;
+ for (i = 0; i < 1024; i++)
+ {
+ s->user_parms.gamma[0][i] =
+ 255 * pow (((double) i + 1) / 1024, 1.0 / gamma);
+ s->user_parms.gamma[1][i] = s->user_parms.gamma[0][i];
+ s->user_parms.gamma[2][i] = s->user_parms.gamma[0][i];
+#ifdef DEBUG
+ printf ("%d %d\n", i, s->user_parms.gamma[0][i]);
+#endif
+ }
+ }
+
+ /* preview */
+ s->opt[OPT_PREVIEW].name = SANE_NAME_PREVIEW;
+ s->opt[OPT_PREVIEW].title = SANE_TITLE_PREVIEW;
+ s->opt[OPT_PREVIEW].desc = SANE_DESC_PREVIEW;
+ s->opt[OPT_PREVIEW].type = SANE_TYPE_BOOL;
+ s->opt[OPT_PREVIEW].size = sizeof (SANE_Word);
+ s->opt[OPT_PREVIEW].cap = SANE_CAP_SOFT_DETECT | SANE_CAP_SOFT_SELECT;
+ s->val[OPT_PREVIEW].w = SANE_FALSE;
+}
+
+SANE_Status
+sane_open (SANE_String_Const name, SANE_Handle * h)
+{
+ static const char me[] = "sane_hp4200_open";
+ SANE_Status status;
+ HP4200_Device *dev;
+ HP4200_Scanner *s;
+
+ DBG (DBG_proc, "%s (%s, %p)\n", me, name, (void *) h);
+
+ if (name && name[0])
+ {
+ dev = find_device (name);
+ if (!dev)
+ {
+ status = add_device (name, &dev);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+ }
+ }
+ else
+ {
+ dev = first_device;
+ }
+ if (!dev)
+ return SANE_STATUS_INVAL;
+
+ if (!h)
+ return SANE_STATUS_INVAL;
+
+ s = *h = (HP4200_Scanner *) calloc (1, sizeof (HP4200_Scanner));
+ if (!s)
+ {
+ DBG (DBG_error, "%s: out of memory creating scanner structure.\n", me);
+ return SANE_STATUS_NO_MEM;
+ }
+
+ dev->handle = s;
+ s->aborted_by_user = SANE_FALSE;
+ s->ciclic_buffer.buffer = NULL;
+ s->scanner_buffer.buffer = NULL;
+ s->dev = dev;
+ s->user_parms.image_width = 0;
+ s->user_parms.lines_to_scan = 0;
+ s->user_parms.vertical_resolution = 0;
+ s->scanning = SANE_FALSE;
+ s->fd = -1;
+
+ init_options (s);
+
+ if ((sanei_usb_open (dev->dev.name, &s->fd) != SANE_STATUS_GOOD))
+ {
+ DBG (DBG_error, "%s: Can't open %s.\n", me, dev->dev.name);
+ return SANE_STATUS_IO_ERROR; /* fixme: return busy when file is
+ being accessed already */
+ }
+
+ return SANE_STATUS_GOOD;
+}
+
+void
+sane_close (SANE_Handle h)
+{
+ HP4200_Scanner *s = (HP4200_Scanner *) h;
+ DBG (DBG_proc, "sane_hp4200_close (%p)\n", (void *) h);
+
+ if (s)
+ {
+ s->dev->handle = NULL;
+ if (s->fd != -1)
+ {
+ sanei_usb_close (s->fd);
+ }
+ free (s);
+ }
+}
+
+const SANE_Option_Descriptor *
+sane_get_option_descriptor (SANE_Handle h, SANE_Int n)
+{
+ static char me[] = "sane_get_option_descriptor";
+ HP4200_Scanner *s = (HP4200_Scanner *) h;
+
+ DBG (DBG_proc, "%s\n", me);
+
+ if ((n < 0) || (n >= NUM_OPTIONS))
+ return NULL;
+
+ return s->opt + n;
+}
+
+SANE_Status
+sane_control_option (SANE_Handle handle, SANE_Int option,
+ SANE_Action action, void *val, SANE_Int * info)
+{
+ HP4200_Scanner *s = (HP4200_Scanner *) handle;
+ SANE_Status status;
+ SANE_Int myinfo = 0;
+ SANE_Word cap;
+
+ DBG (DBG_proc, "sane_control_option\n");
+
+ if (info)
+ *info = 0;
+
+ if (s->scanning)
+ {
+ return SANE_STATUS_DEVICE_BUSY;
+ }
+
+ if (option < 0 || option >= NUM_OPTIONS)
+ {
+ return SANE_STATUS_INVAL;
+ }
+
+ cap = s->opt[option].cap;
+ if (!SANE_OPTION_IS_ACTIVE (cap))
+ {
+ return SANE_STATUS_INVAL;
+ }
+
+ if (action == SANE_ACTION_GET_VALUE)
+ {
+
+ switch (option)
+ {
+ case OPT_NUM_OPTS:
+ case OPT_RES:
+ case OPT_TL_X:
+ case OPT_TL_Y:
+ case OPT_BR_X:
+ case OPT_BR_Y:
+ case OPT_PREVIEW:
+ *(SANE_Word *) val = s->val[option].w;
+ break;
+
+ case OPT_BACKTRACK:
+ *(SANE_Bool *) val = s->val[option].b;
+ break;
+
+ case OPT_GAMMA_VECTOR_R:
+ case OPT_GAMMA_VECTOR_G:
+ case OPT_GAMMA_VECTOR_B:
+ memcpy (val, s->val[option].wa, s->opt[option].size);
+ break;
+ default:
+ return SANE_STATUS_UNSUPPORTED;
+ }
+ }
+ else if (action == SANE_ACTION_SET_VALUE)
+ {
+
+ if (!SANE_OPTION_IS_SETTABLE (cap))
+ {
+ DBG (DBG_error, "could not set option, not settable\n");
+ return SANE_STATUS_INVAL;
+ }
+
+ status = sanei_constrain_value (s->opt + option, val, &myinfo);
+ if (status != SANE_STATUS_GOOD)
+ return status;
+
+ switch (option)
+ {
+
+ /* Numeric side-effect free options */
+ case OPT_PREVIEW:
+ s->val[option].w = *(SANE_Word *) val;
+ return SANE_STATUS_GOOD;
+
+ /* Numeric side-effect options */
+ case OPT_RES:
+ case OPT_TL_X:
+ case OPT_TL_Y:
+ case OPT_BR_X:
+ case OPT_BR_Y:
+ myinfo |= SANE_INFO_RELOAD_PARAMS;
+ s->val[option].w = *(SANE_Word *) val;
+ break;
+
+ case OPT_BACKTRACK:
+ s->val[option].b = *(SANE_Bool *) val;
+ break;
+
+ case OPT_GAMMA_VECTOR_R:
+ case OPT_GAMMA_VECTOR_G:
+ case OPT_GAMMA_VECTOR_B:
+ memcpy (s->val[option].wa, val, s->opt[option].size);
+ break;
+ default:
+ return SANE_STATUS_UNSUPPORTED;
+ }
+ }
+ else
+ {
+ return SANE_STATUS_UNSUPPORTED;
+ }
+
+ if (info)
+ *info = myinfo;
+
+ return SANE_STATUS_GOOD;
+}
+
+static void
+compute_parameters (HP4200_Scanner * s)
+{
+ int resolution;
+ int opt_tl_x;
+ int opt_br_x;
+ int opt_tl_y;
+ int opt_br_y;
+
+ if (s->val[OPT_PREVIEW].w == SANE_TRUE)
+ {
+ resolution = 50;
+ opt_tl_x = SANE_UNFIX (x_range.min);
+ opt_tl_y = SANE_UNFIX (y_range.min);
+ opt_br_x = SANE_UNFIX (x_range.max);
+ opt_br_y = SANE_UNFIX (y_range.max);
+ }
+ else
+ {
+ resolution = s->val[OPT_RES].w;
+ opt_tl_x = SANE_UNFIX (s->val[OPT_TL_X].w);
+ opt_tl_y = SANE_UNFIX (s->val[OPT_TL_Y].w);
+ opt_br_x = SANE_UNFIX (s->val[OPT_BR_X].w);
+ opt_br_y = SANE_UNFIX (s->val[OPT_BR_Y].w);
+ }
+
+ s->user_parms.horizontal_resolution = resolution;
+ s->user_parms.vertical_resolution = resolution;
+
+ s->runtime_parms.steps_to_skip = floor (300.0 / MM_PER_INCH * opt_tl_y);
+ s->user_parms.lines_to_scan =
+ floor ((opt_br_y - opt_tl_y) / MM_PER_INCH * resolution);
+ s->user_parms.image_width =
+ floor ((opt_br_x - opt_tl_x) / MM_PER_INCH * resolution);
+ s->runtime_parms.first_pixel = floor (opt_tl_x / MM_PER_INCH * resolution);
+
+ /* fixme: add support for more depth's and bpp's. */
+ s->runtime_parms.image_line_size = s->user_parms.image_width * 3;
+}
+
+SANE_Status
+sane_get_parameters (SANE_Handle h, SANE_Parameters * p)
+{
+ static char me[] = "sane_get_parameters";
+ HP4200_Scanner *s = (HP4200_Scanner *) h;
+
+ DBG (DBG_proc, "%s\n", me);
+ if (!p)
+ return SANE_STATUS_INVAL;
+
+ p->format = SANE_FRAME_RGB;
+ p->last_frame = SANE_TRUE;
+ p->depth = 8;
+ if (!s->scanning)
+ {
+ compute_parameters (s);
+ }
+
+ p->lines = s->user_parms.lines_to_scan;
+ p->pixels_per_line = s->user_parms.image_width;
+ p->bytes_per_line = s->runtime_parms.image_line_size;
+
+ return SANE_STATUS_GOOD;
+}
+
+SANE_Status
+sane_start (SANE_Handle h)
+{
+ HP4200_Scanner *s = (HP4200_Scanner *) h;
+ struct coarse_t coarse;
+
+ static char me[] = "sane_start";
+ DBG (DBG_proc, "%s\n", me);
+
+ s->scanning = SANE_TRUE;
+ s->aborted_by_user = SANE_FALSE;
+ s->user_parms.color = SANE_TRUE;
+
+ compute_parameters (s);
+
+ hp4200_init_scanner (s);
+ hp4200_goto_home (s);
+ hp4200_wait_homed (s);
+ /* restore default register values here... */
+ write_gamma (s);
+ hp4200_init_registers (s);
+ lm9830_ini_scanner (s->fd, NULL);
+ /* um... do not call cache_write() here, don't know why :( */
+ do_coarse_calibration (s, &coarse);
+ do_fine_calibration (s, &coarse);
+ prepare_for_a_scan (s);
+
+ return SANE_STATUS_GOOD;
+}
+
+void
+sane_cancel (SANE_Handle h)
+{
+ static char me[] = "sane_cancel";
+ HP4200_Scanner *s = (HP4200_Scanner *) h;
+ DBG (DBG_proc, "%s\n", me);
+
+ s->aborted_by_user = SANE_TRUE;
+
+ end_scan (s);
+}
+
+SANE_Status
+sane_set_io_mode (SANE_Handle handle, SANE_Bool non_blocking)
+{
+ HP4200_Scanner *dev = handle;
+ SANE_Status status;
+
+ non_blocking = non_blocking; /* silence gcc */
+
+ if (dev->scanning == SANE_FALSE)
+ {
+ return SANE_STATUS_INVAL;
+ }
+
+ if (non_blocking == SANE_FALSE)
+ {
+ status = SANE_STATUS_GOOD;
+ }
+ else
+ {
+ status = SANE_STATUS_UNSUPPORTED;
+ }
+
+ DBG (DBG_proc, "sane_set_io_mode: exit\n");
+
+ return status;
+}
+
+SANE_Status
+sane_get_select_fd (SANE_Handle h, SANE_Int * fd)
+{
+ static char me[] = "sane_get_select_fd";
+
+ h = h; /* keep gcc quiet */
+ fd = fd; /* keep gcc quiet */
+
+ DBG (DBG_proc, "%s\n", me);
+ return SANE_STATUS_UNSUPPORTED;
+}