diff options
Diffstat (limited to 'backend/mustek_pp_ccd300.c')
| -rw-r--r-- | backend/mustek_pp_ccd300.c | 2061 |
1 files changed, 2061 insertions, 0 deletions
diff --git a/backend/mustek_pp_ccd300.c b/backend/mustek_pp_ccd300.c new file mode 100644 index 0000000..c5351a4 --- /dev/null +++ b/backend/mustek_pp_ccd300.c @@ -0,0 +1,2061 @@ +/* sane - Scanner Access Now Easy. + Copyright (C) 2000-2003 Jochen Eisinger <jochen.eisinger@gmx.net> + This file is part of the SANE package. + + 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. + + As a special exception, the authors of SANE give permission for + additional uses of the libraries contained in this release of SANE. + + The exception is that, if you link a SANE library with other files + to produce an executable, this does not by itself cause the + resulting executable to be covered by the GNU General Public + License. Your use of that executable is in no way restricted on + account of linking the SANE library code into it. + + This exception does not, however, invalidate any other reasons why + the executable file might be covered by the GNU General Public + License. + + If you submit changes to SANE to the maintainers to be included in + a subsequent release, you agree by submitting the changes that + those changes may be distributed with this exception intact. + + If you write modifications of your own for SANE, it is your choice + whether to permit this exception to apply to your modifications. + If you do not wish that, delete this exception notice. + + This file implements the hardware driver scanners using a 300dpi CCD */ + +#include "mustek_pp_ccd300.h" + +#define MUSTEK_PP_CCD300 4 + +static void config_ccd_101x (Mustek_pp_Handle * dev); +static void config_ccd (Mustek_pp_Handle * dev); +static void lamp (Mustek_pp_Handle * dev, int lamp_on); + +#define CCD300_ASIC1013 0xa8 +#define CCD300_ASIC1015 0xa5 + +#define CCD300_CHANNEL_RED 0 +#define CCD300_CHANNEL_GREEN 1 +#define CCD300_CHANNEL_BLUE 2 +#define CCD300_CHANNEL_GRAY 1 + +#define CCD300_MAXHSIZE 2600 +#define CCD300_MAXVSIZE 3500 + +/* + * Here starts the driver code for the different chipsets + * + * The 1013 & 1015 chipsets share large portions of the code. This + * shared functions end with _101x. + */ + +static const u_char chan_codes_1013[] = { 0x82, 0x42, 0xC2 }; +static const u_char chan_codes_1015[] = { 0x80, 0x40, 0xC0 }; +static const u_char fullstep[] = { 0x09, 0x0C, 0x06, 0x03 }; +static const u_char halfstep[] = { 0x02, 0x03, 0x01, 0x09, + 0x08, 0x0C, 0x04, 0x06 +}; +static const u_char voltages[4][3] = { {0x5C, 0x5A, 0x63}, +{0xE6, 0xB4, 0xBE}, +{0xB4, 0xB4, 0xB4}, +{0x64, 0x50, 0x64} +}; + +/* Forward declarations of 1013/1015 functions */ +static void set_ccd_channel_1013 (Mustek_pp_Handle * dev, int channel); +static void motor_backward_1013 (Mustek_pp_Handle * dev); +static void return_home_1013 (Mustek_pp_Handle * dev); +static void motor_forward_1013 (Mustek_pp_Handle * dev); +static void config_ccd_1013 (Mustek_pp_Handle * dev); + +static void set_ccd_channel_1015 (Mustek_pp_Handle * dev, int channel); +/* static void motor_backward_1015 (Mustek_pp_Handle * dev); */ +static void return_home_1015 (Mustek_pp_Handle * dev, SANE_Bool nowait); +static void motor_forward_1015 (Mustek_pp_Handle * dev); +static void config_ccd_1015 (Mustek_pp_Handle * dev); + + +/* These functions are common to all 1013/1015 chipsets */ + +static void +set_led (Mustek_pp_Handle * dev) +{ + mustek_pp_ccd300_priv *priv = dev->priv; + + sanei_pa4s2_writebyte (dev->fd, 6, + (priv->motor_step % 5 == 0 ? 0x03 : 0x13)); + +} + +static void +set_sti (Mustek_pp_Handle * dev) +{ + mustek_pp_ccd300_priv *priv = dev->priv; + + sanei_pa4s2_writebyte (dev->fd, 3, 0); + priv->bank_count++; + priv->bank_count &= 7; + +} + +static void +get_bank_count (Mustek_pp_Handle * dev) +{ + u_char val; + mustek_pp_ccd300_priv *priv = dev->priv; + + sanei_pa4s2_readbegin (dev->fd, 3); + sanei_pa4s2_readbyte (dev->fd, &val); + sanei_pa4s2_readend (dev->fd); + + priv->bank_count = (val & 0x07); + +} + +static void +reset_bank_count (Mustek_pp_Handle * dev) +{ + sanei_pa4s2_writebyte (dev->fd, 6, 7); +} + +static void +wait_bank_change (Mustek_pp_Handle * dev, int bankcount, int niceload) +{ + struct timeval start, end; + unsigned long diff; + mustek_pp_ccd300_priv *priv = dev->priv; + int first_time = 1; + + gettimeofday (&start, NULL); + + do + { + if ((niceload == 0) && (first_time == 0)) + { + usleep (1); /* could be as well sched_yield */ + first_time = 0; + } + get_bank_count (dev); + + gettimeofday (&end, NULL); + diff = (end.tv_sec * 1000 + end.tv_usec / 1000) - + (start.tv_sec * 1000 + start.tv_usec / 1000); + + } + while ((priv->bank_count != bankcount) && (diff < priv->wait_bank)); + +} + +static void +set_dpi_value (Mustek_pp_Handle * dev) +{ + u_char val = 0; + mustek_pp_ccd300_priv *priv = dev->priv; + + sanei_pa4s2_writebyte (dev->fd, 6, 0x80); + + switch (priv->hwres) + { + case 100: + val = 0x00; + break; + case 200: + val = 0x10; + break; + case 300: + val = 0x20; + break; + } + + + if (priv->ccd_type == 1) + val |= 0x01; + + sanei_pa4s2_writebyte (dev->fd, 5, val); + + sanei_pa4s2_writebyte (dev->fd, 6, 0x00); + + DBG (5, "set_dpi_value: value 0x%02x\n", val); + +} + +static void +set_line_adjust (Mustek_pp_Handle * dev) +{ + int adjustline; + mustek_pp_ccd300_priv *priv = dev->priv; + + adjustline = (dev->bottomX - dev->topX) * priv->hwres / 300; + priv->adjustskip = priv->adjustskip * priv->hwres / 300; + + DBG (5, "set_line_adjust: ppl %u (%u), adjust %u, skip %u\n", + dev->params.pixels_per_line, (dev->bottomX - dev->topX), adjustline, + priv->adjustskip); + + + sanei_pa4s2_writebyte (dev->fd, 6, 0x11); + sanei_pa4s2_writebyte (dev->fd, 5, (adjustline + priv->adjustskip) >> 8); + sanei_pa4s2_writebyte (dev->fd, 6, 0x21); + sanei_pa4s2_writebyte (dev->fd, 5, (adjustline + priv->adjustskip) & 0xFF); + + sanei_pa4s2_writebyte (dev->fd, 6, 0x01); + +} + +static void +set_lamp (Mustek_pp_Handle * dev, int lamp_on) +{ + + int ctr; + mustek_pp_ccd300_priv *priv = dev->priv; + + sanei_pa4s2_writebyte (dev->fd, 6, 0xC3); + + for (ctr = 0; ctr < 3; ctr++) + { + sanei_pa4s2_writebyte (dev->fd, 6, (lamp_on ? 0x47 : 0x57)); + sanei_pa4s2_writebyte (dev->fd, 6, 0x77); + } + + priv->motor_step = lamp_on; + + set_led (dev); + +} + +static void +send_voltages (Mustek_pp_Handle * dev) +{ + + int voltage, sel = 8, ctr; + mustek_pp_ccd300_priv *priv = dev->priv; + + switch (priv->ccd_type) + { + case 0: + voltage = 0; + break; + case 1: + voltage = 1; + break; + default: + voltage = 2; + break; + } + + for (ctr = 0; ctr < 3; ctr++) + { + + sel <<= 1; + sanei_pa4s2_writebyte (dev->fd, 6, sel); + sanei_pa4s2_writebyte (dev->fd, 5, voltages[voltage][ctr]); + + } + + sanei_pa4s2_writebyte (dev->fd, 6, 0x00); + +} + +static int +compar (const void *a, const void *b) +{ + return (signed int) (*(const SANE_Byte *) a) - + (signed int) (*(const SANE_Byte *) b); +} + +static void +set_ccd_channel_101x (Mustek_pp_Handle * dev, int channel) +{ + mustek_pp_ccd300_priv *priv = dev->priv; + switch (priv->asic) + { + case CCD300_ASIC1013: + set_ccd_channel_1013 (dev, channel); + break; + + case CCD300_ASIC1015: + set_ccd_channel_1015 (dev, channel); + break; + } +} + +static void +motor_forward_101x (Mustek_pp_Handle * dev) +{ + mustek_pp_ccd300_priv *priv = dev->priv; + switch (priv->asic) + { + case CCD300_ASIC1013: + motor_forward_1013 (dev); + break; + + case CCD300_ASIC1015: + motor_forward_1015 (dev); + break; + } +} + +static void +motor_backward_101x (Mustek_pp_Handle * dev) +{ + mustek_pp_ccd300_priv *priv = dev->priv; + switch (priv->asic) + { + case CCD300_ASIC1013: + motor_backward_1013 (dev); + break; + + case CCD300_ASIC1015: +/* motor_backward_1015 (dev); */ + break; + } +} + +static void +move_motor_101x (Mustek_pp_Handle * dev, int forward) +{ + mustek_pp_ccd300_priv *priv = dev->priv; + if (forward == SANE_TRUE) + motor_forward_101x (dev); + else + motor_backward_101x (dev); + + wait_bank_change (dev, priv->bank_count, 1); + reset_bank_count (dev); +} + + +static void +config_ccd_101x (Mustek_pp_Handle * dev) +{ + mustek_pp_ccd300_priv *priv = dev->priv; + switch (priv->asic) + { + case CCD300_ASIC1013: + config_ccd_1013 (dev); + break; + + case CCD300_ASIC1015: + config_ccd_1015 (dev); + break; + } +} + + + +static void +read_line_101x (Mustek_pp_Handle * dev, SANE_Byte * buf, SANE_Int pixel, + SANE_Int RefBlack, SANE_Byte * calib, SANE_Int * gamma) +{ + + SANE_Byte *cal = calib; + u_char color; + mustek_pp_ccd300_priv *priv = dev->priv; + int ctr, skips = priv->adjustskip + 1, cval; + + if (pixel <= 0) + return; + + sanei_pa4s2_readbegin (dev->fd, 1); + + + if (priv->hwres == dev->res) + { + + while (skips--) + sanei_pa4s2_readbyte (dev->fd, &color); + + for (ctr = 0; ctr < pixel; ctr++) + { + + sanei_pa4s2_readbyte (dev->fd, &color); + + cval = color; + + if (cval < RefBlack) + cval = 0; + else + cval -= RefBlack; + + if (cal) + { + if (cval >= cal[ctr]) + cval = 0xFF; + else + { + cval <<= 8; + cval /= (int) cal[ctr]; + } + } + + if (gamma) + cval = gamma[cval]; + + buf[ctr] = cval; + + } + + } + else + { + + int pos = 0, bpos = 0; + + while (skips--) + sanei_pa4s2_readbyte (dev->fd, &color); + + ctr = 0; + + do + { + + sanei_pa4s2_readbyte (dev->fd, &color); + + cval = color; + + if (ctr < (pos >> SANE_FIXED_SCALE_SHIFT)) + { + ctr++; + continue; + } + + ctr++; + pos += priv->res_step; + + + if (cval < RefBlack) + cval = 0; + else + cval -= RefBlack; + + if (cal) + { + if (cval >= cal[bpos]) + cval = 0xFF; + else + { + cval <<= 8; + cval /= (int) cal[bpos]; + } + } + + if (gamma) + cval = gamma[cval]; + + buf[bpos++] = cval; + + } + while (bpos < pixel); + + } + + sanei_pa4s2_readend (dev->fd); + +} + +static void +read_average_line_101x (Mustek_pp_Handle * dev, SANE_Byte * buf, int pixel, + int RefBlack) +{ + + SANE_Byte lbuf[4][CCD300_MAXHSIZE * 2]; + int ctr, sum; + mustek_pp_ccd300_priv *priv = dev->priv; + + for (ctr = 0; ctr < 4; ctr++) + { + + wait_bank_change (dev, priv->bank_count, 1); + read_line_101x (dev, lbuf[ctr], pixel, RefBlack, NULL, NULL); + reset_bank_count (dev); + if (ctr < 3) + set_sti (dev); + + } + + for (ctr = 0; ctr < pixel; ctr++) + { + + sum = lbuf[0][ctr] + lbuf[1][ctr] + lbuf[2][ctr] + lbuf[3][ctr]; + + buf[ctr] = (sum / 4); + + } + +} + +static void +find_black_side_edge_101x (Mustek_pp_Handle * dev) +{ + SANE_Byte buf[CCD300_MAXHSIZE * 2]; + SANE_Byte blackposition[5]; + int pos = 0, ctr, blackpos; + mustek_pp_ccd300_priv *priv = dev->priv; + + + for (ctr = 0; ctr < 20; ctr++) + { + + motor_forward_101x (dev); + wait_bank_change (dev, priv->bank_count, 1); + read_line_101x (dev, buf, CCD300_MAXHSIZE, 0, NULL, NULL); + reset_bank_count (dev); + + priv->ref_black = priv->ref_red = priv->ref_green = priv->ref_blue = + buf[0]; + + blackpos = CCD300_MAXHSIZE / 4; + + while ((abs (buf[blackpos] - buf[0]) >= 15) && (blackpos > 0)) + blackpos--; + + if (blackpos > 1) + blackposition[pos++] = blackpos; + + if (pos == 5) + break; + + } + + blackpos = 0; + + for (ctr = 0; ctr < pos; ctr++) + if (blackposition[ctr] > blackpos) + blackpos = blackposition[ctr]; + + if (blackpos < 0x66) + blackpos = 0x6A; + + priv->blackpos = blackpos; + priv->saved_skipcount = (blackpos + 12) & 0xFF; + +} + +static void +min_color_levels_101x (Mustek_pp_Handle * dev) +{ + + SANE_Byte buf[CCD300_MAXHSIZE * 2]; + int ctr, sum = 0; + mustek_pp_ccd300_priv *priv = dev->priv; + + for (ctr = 0; ctr < 8; ctr++) + { + + set_ccd_channel_101x (dev, CCD300_CHANNEL_RED); + set_sti (dev); + wait_bank_change (dev, priv->bank_count, 1); + + read_line_101x (dev, buf, CCD300_MAXHSIZE, 0, NULL, NULL); + + reset_bank_count (dev); + + sum += buf[3]; + + } + + priv->ref_red = sum / 8; + + sum = 0; + + for (ctr = 0; ctr < 8; ctr++) + { + + set_ccd_channel_101x (dev, CCD300_CHANNEL_GREEN); + set_sti (dev); + wait_bank_change (dev, priv->bank_count, 1); + + read_line_101x (dev, buf, CCD300_MAXHSIZE, 0, NULL, NULL); + + reset_bank_count (dev); + + sum += buf[3]; + + } + + priv->ref_green = sum / 8; + + sum = 0; + + for (ctr = 0; ctr < 8; ctr++) + { + + set_ccd_channel_101x (dev, CCD300_CHANNEL_BLUE); + set_sti (dev); + wait_bank_change (dev, priv->bank_count, 1); + + read_line_101x (dev, buf, CCD300_MAXHSIZE, 0, NULL, NULL); + + reset_bank_count (dev); + + sum += buf[3]; + + } + + priv->ref_blue = sum / 8; + +} + + +static void +max_color_levels_101x (Mustek_pp_Handle * dev) +{ + + int ctr, line, sum; + SANE_Byte rbuf[32][CCD300_MAXHSIZE * 2]; + SANE_Byte gbuf[32][CCD300_MAXHSIZE * 2]; + SANE_Byte bbuf[32][CCD300_MAXHSIZE * 2]; + mustek_pp_ccd300_priv *priv = dev->priv; + + SANE_Byte maxbuf[32]; + + for (ctr = 0; ctr < 32; ctr++) + { + + if (dev->mode == MODE_COLOR) + { + + set_ccd_channel_101x (dev, CCD300_CHANNEL_RED); + motor_forward_101x (dev); + + read_average_line_101x (dev, rbuf[ctr], dev->params.pixels_per_line, + priv->ref_red); + + set_ccd_channel_101x (dev, CCD300_CHANNEL_GREEN); + set_sti (dev); + + read_average_line_101x (dev, gbuf[ctr], dev->params.pixels_per_line, + priv->ref_green); + + set_ccd_channel_101x (dev, CCD300_CHANNEL_BLUE); + set_sti (dev); + + read_average_line_101x (dev, bbuf[ctr], dev->params.pixels_per_line, + priv->ref_blue); + + } + else + { + + priv->channel = CCD300_CHANNEL_GRAY; + + motor_forward_101x (dev); + + read_average_line_101x (dev, gbuf[ctr], dev->params.pixels_per_line, + priv->ref_black); + + } + + } + + + for (ctr = 0; ctr < dev->params.pixels_per_line; ctr++) + { + for (line = 0; line < 32; line++) + maxbuf[line] = gbuf[line][ctr]; + + qsort (maxbuf, 32, sizeof (maxbuf[0]), compar); + + sum = maxbuf[4] + maxbuf[5] + maxbuf[6] + maxbuf[7]; + + priv->calib_g[ctr] = sum / 4; + + } + + if (dev->mode == MODE_COLOR) + { + + for (ctr = 0; ctr < dev->params.pixels_per_line; ctr++) + { + for (line = 0; line < 32; line++) + maxbuf[line] = rbuf[line][ctr]; + + qsort (maxbuf, 32, sizeof (maxbuf[0]), compar); + + sum = maxbuf[4] + maxbuf[5] + maxbuf[6] + maxbuf[7]; + + priv->calib_r[ctr] = sum / 4; + + } + + for (ctr = 0; ctr < dev->params.pixels_per_line; ctr++) + { + for (line = 0; line < 32; line++) + maxbuf[line] = bbuf[line][ctr]; + + qsort (maxbuf, 32, sizeof (maxbuf[0]), compar); + + sum = maxbuf[4] + maxbuf[5] + maxbuf[6] + maxbuf[7]; + + priv->calib_b[ctr] = sum / 4; + + } + + } + +} + +static void +find_black_top_edge_101x (Mustek_pp_Handle * dev) +{ + + int lines = 0, ctr, pos; + SANE_Byte buf[CCD300_MAXHSIZE * 2]; + mustek_pp_ccd300_priv *priv = dev->priv; + + priv->channel = CCD300_CHANNEL_GRAY; + + do + { + + motor_forward_101x (dev); + wait_bank_change (dev, priv->bank_count, 1); + + read_line_101x (dev, buf, CCD300_MAXHSIZE, priv->ref_black, NULL, NULL); + + reset_bank_count (dev); + + pos = 0; + + for (ctr = priv->blackpos; ctr > priv->blackpos - 10; ctr--) + if (buf[ctr] <= 15) + pos++; + + } + while ((pos >= 8) && (lines++ < 67)); + +} + +static void +calibrate_device_101x (Mustek_pp_Handle * dev) +{ + + int saved_ppl = dev->params.pixels_per_line, ctr; + mustek_pp_ccd300_priv *priv = dev->priv; + + priv->saved_mode = dev->mode; + priv->saved_invert = dev->invert; + priv->saved_skipcount = priv->skipcount; + priv->saved_skipimagebyte = priv->skipimagebytes; + priv->saved_adjustskip = priv->adjustskip; + priv->saved_res = dev->res; + priv->saved_hwres = priv->hwres; + priv->saved_res_step = priv->res_step; + priv->saved_line_step = priv->line_step; + priv->saved_channel = priv->channel; + + dev->params.pixels_per_line = CCD300_MAXHSIZE; + priv->hwres = dev->res = 300; + dev->mode = MODE_GRAYSCALE; + priv->skipcount = priv->skipimagebytes = 0; + dev->invert = SANE_FALSE; + priv->channel = CCD300_CHANNEL_GRAY; + + config_ccd_101x (dev); + get_bank_count (dev); + + find_black_side_edge_101x (dev); + + for (ctr = 0; ctr < 4; ctr++) + move_motor_101x (dev, SANE_TRUE); + + dev->mode = priv->saved_mode; + dev->invert = priv->saved_invert; + priv->skipcount = priv->saved_skipcount; + priv->skipimagebytes = priv->saved_skipimagebyte; + priv->adjustskip = priv->saved_adjustskip; + dev->res = priv->saved_res; + priv->hwres = priv->saved_hwres; + priv->res_step = priv->saved_res_step; + priv->line_step = priv->saved_line_step; + priv->channel = priv->saved_channel; + + priv->hwres = dev->res = 300; + priv->skipcount = priv->skipimagebytes = 0; + dev->invert = SANE_FALSE; + + config_ccd_101x (dev); + get_bank_count (dev); + + if ((dev->mode == MODE_COLOR) && (priv->ccd_type != 0)) + min_color_levels_101x (dev); + + dev->mode = priv->saved_mode; + dev->invert = priv->saved_invert; + priv->skipcount = priv->saved_skipcount; + priv->skipimagebytes = priv->saved_skipimagebyte; + priv->adjustskip = priv->saved_adjustskip; + dev->res = priv->saved_res; + priv->hwres = priv->saved_hwres; + priv->res_step = priv->saved_res_step; + priv->line_step = priv->saved_line_step; + priv->channel = priv->saved_channel; + + dev->params.pixels_per_line = saved_ppl; + dev->invert = SANE_FALSE; + + config_ccd_101x (dev); + get_bank_count (dev); + + max_color_levels_101x (dev); + + dev->params.pixels_per_line = CCD300_MAXHSIZE; + dev->mode = MODE_GRAYSCALE; + priv->hwres = dev->res = 300; + priv->skipcount = priv->skipimagebytes = 0; + dev->invert = SANE_FALSE; + + config_ccd_101x (dev); + get_bank_count (dev); + + find_black_top_edge_101x (dev); + + dev->mode = priv->saved_mode; + dev->invert = priv->saved_invert; + priv->skipcount = priv->saved_skipcount; + priv->skipimagebytes = priv->saved_skipimagebyte; + priv->adjustskip = priv->saved_adjustskip; + dev->res = priv->saved_res; + priv->hwres = priv->saved_hwres; + priv->res_step = priv->saved_res_step; + priv->line_step = priv->saved_line_step; + priv->channel = priv->saved_channel; + + dev->params.pixels_per_line = saved_ppl; + + config_ccd_101x (dev); + get_bank_count (dev); + +} + +static void +get_grayscale_line_101x (Mustek_pp_Handle * dev, SANE_Byte * buf) +{ + + int skips; + mustek_pp_ccd300_priv *priv = dev->priv; + + priv->line_diff += SANE_FIX (300.0 / (float) dev->res); + + skips = (priv->line_diff >> SANE_FIXED_SCALE_SHIFT); + + while (--skips) + { + motor_forward_101x (dev); + wait_bank_change (dev, priv->bank_count, 1); + reset_bank_count (dev); + } + + priv->line_diff &= 0xFFFF; + + motor_forward_101x (dev); + wait_bank_change (dev, priv->bank_count, 1); + + read_line_101x (dev, buf, dev->params.pixels_per_line, priv->ref_black, + priv->calib_g, NULL); + + reset_bank_count (dev); + +} + +static void +get_lineart_line_101x (Mustek_pp_Handle * dev, SANE_Byte * buf) +{ + + int ctr; + SANE_Byte gbuf[CCD300_MAXHSIZE * 2]; + mustek_pp_ccd300_priv *priv = dev->priv; + + get_grayscale_line_101x (dev, gbuf); + + memset (buf, 0xFF, dev->params.bytes_per_line); + + for (ctr = 0; ctr < dev->params.pixels_per_line; ctr++) + buf[ctr >> 3] ^= ((gbuf[ctr] > priv->bw) ? (1 << (7 - ctr % 8)) : 0); + +} + +static void +get_color_line_101x (Mustek_pp_Handle * dev, SANE_Byte * buf) +{ + + SANE_Byte *red, *blue, *src, *dest; + int gotline = 0, ctr; + int gored, goblue, gogreen; + mustek_pp_ccd300_priv *priv = dev->priv; + int step = priv->line_step; + + do + { + + red = priv->red[priv->redline]; + blue = priv->blue[priv->blueline]; + + priv->ccd_line++; + + if ((priv->rdiff >> SANE_FIXED_SCALE_SHIFT) == priv->ccd_line) + { + gored = 1; + priv->rdiff += step; + } + else + gored = 0; + + if ((priv->bdiff >> SANE_FIXED_SCALE_SHIFT) == priv->ccd_line) + { + goblue = 1; + priv->bdiff += step; + } + else + goblue = 0; + + if ((priv->gdiff >> SANE_FIXED_SCALE_SHIFT) == priv->ccd_line) + { + gogreen = 1; + priv->gdiff += step; + } + else + gogreen = 0; + + if (!gored && !goblue && !gogreen) + { + motor_forward_101x (dev); + wait_bank_change (dev, priv->bank_count, 1); + reset_bank_count (dev); + if (priv->ccd_line >= (priv->line_step >> SANE_FIXED_SCALE_SHIFT)) + priv->redline = ++priv->redline % priv->green_offs; + if (priv->ccd_line >= + priv->blue_offs + (priv->line_step >> SANE_FIXED_SCALE_SHIFT)) + priv->blueline = ++priv->blueline % priv->blue_offs; + continue; + } + + if (gored) + priv->channel = CCD300_CHANNEL_RED; + else if (goblue) + priv->channel = CCD300_CHANNEL_BLUE; + else + priv->channel = CCD300_CHANNEL_GREEN; + + motor_forward_101x (dev); + wait_bank_change (dev, priv->bank_count, 1); + + if (priv->ccd_line >= priv->green_offs && gogreen) + { + src = red; + dest = buf; + + for (ctr = 0; ctr < dev->params.pixels_per_line; ctr++) + { + *dest = *src++; + dest += 3; + } + } + + if (gored) + { + + read_line_101x (dev, red, dev->params.pixels_per_line, + priv->ref_red, priv->calib_r, NULL); + + reset_bank_count (dev); + + } + + priv->redline = ++priv->redline % priv->green_offs; + + if (priv->ccd_line >= priv->green_offs && gogreen) + { + src = blue; + dest = buf + 2; + + + for (ctr = 0; ctr < dev->params.pixels_per_line; ctr++) + { + *dest = *src++; + dest += 3; + } + + } + + if (goblue) + { + if (gored) + { + set_ccd_channel_101x (dev, CCD300_CHANNEL_BLUE); + set_sti (dev); + wait_bank_change (dev, priv->bank_count, 1); + } + + read_line_101x (dev, blue, dev->params.pixels_per_line, + priv->ref_blue, priv->calib_b, NULL); + + reset_bank_count (dev); + + } + + if (priv->ccd_line >= + priv->blue_offs + (priv->line_step >> SANE_FIXED_SCALE_SHIFT)) + priv->blueline = ++priv->blueline % priv->blue_offs; + + if (gogreen) + { + + if (gored || goblue) + { + set_ccd_channel_101x (dev, CCD300_CHANNEL_GREEN); + set_sti (dev); + wait_bank_change (dev, priv->bank_count, 1); + } + + read_line_101x (dev, priv->green, dev->params.pixels_per_line, + priv->ref_green, priv->calib_g, NULL); + + reset_bank_count (dev); + + src = priv->green; + dest = buf + 1; + + for (ctr = 0; ctr < dev->params.pixels_per_line; ctr++) + { + *dest = *src++; + dest += 3; + } + + gotline = 1; + } + + } + while (!gotline); + +} + + + +/* these functions are for the 1013 chipset */ + +static void +set_ccd_channel_1013 (Mustek_pp_Handle * dev, int channel) +{ + mustek_pp_ccd300_priv *priv = dev->priv; + priv->channel = channel; + sanei_pa4s2_writebyte (dev->fd, 6, chan_codes_1013[channel]); +} + +static void +motor_backward_1013 (Mustek_pp_Handle * dev) +{ + mustek_pp_ccd300_priv *priv = dev->priv; + + priv->motor_step++; + set_led (dev); + + if (priv->motor_phase > 3) + priv->motor_phase = 3; + + sanei_pa4s2_writebyte (dev->fd, 6, 0x62); + sanei_pa4s2_writebyte (dev->fd, 5, fullstep[priv->motor_phase]); + + priv->motor_phase = (priv->motor_phase == 0 ? 3 : priv->motor_phase - 1); + + set_ccd_channel_1013 (dev, priv->channel); + set_sti (dev); + +} + +static void +return_home_1013 (Mustek_pp_Handle * dev) +{ + u_char ishome; + int ctr; + mustek_pp_ccd300_priv *priv = dev->priv; + + /* 1013 can't return home all alone, nowait ignored */ + + for (ctr = 0; ctr < 4500; ctr++) + { + + /* check_is_home_1013 */ + sanei_pa4s2_readbegin (dev->fd, 2); + sanei_pa4s2_readbyte (dev->fd, &ishome); + sanei_pa4s2_readend (dev->fd); + + /* yes, it should be is_not_home */ + if ((ishome & 1) == 0) + break; + + motor_backward_1013 (dev); + wait_bank_change (dev, priv->bank_count, 0); + reset_bank_count (dev); + + } + +} + +static void +motor_forward_1013 (Mustek_pp_Handle * dev) +{ + + int ctr; + mustek_pp_ccd300_priv *priv = dev->priv; + + priv->motor_step++; + set_led (dev); + + for (ctr = 0; ctr < 2; ctr++) + { + + sanei_pa4s2_writebyte (dev->fd, 6, 0x62); + sanei_pa4s2_writebyte (dev->fd, 5, halfstep[priv->motor_phase]); + + priv->motor_phase = + (priv->motor_phase == 7 ? 0 : priv->motor_phase + 1); + + } + + set_ccd_channel_1013 (dev, priv->channel); + set_sti (dev); +} + + + +static void +config_ccd_1013 (Mustek_pp_Handle * dev) +{ + mustek_pp_ccd300_priv *priv = dev->priv; + + if (dev->res != 0) + priv->res_step = SANE_FIX ((float) priv->hwres / (float) dev->res); + + set_dpi_value (dev); + + /* set_start_channel_1013 (dev); */ + + sanei_pa4s2_writebyte (dev->fd, 6, 0x05); + + switch (dev->mode) + { + case MODE_BW: + case MODE_GRAYSCALE: + priv->channel = CCD300_CHANNEL_GRAY; + break; + + case MODE_COLOR: + priv->channel = CCD300_CHANNEL_RED; + break; + + } + + set_ccd_channel_1013 (dev, priv->channel); + + /* set_invert_1013 (dev); */ + + sanei_pa4s2_writebyte (dev->fd, 6, + (dev->invert == SANE_TRUE ? 0x04 : 0x14)); + + sanei_pa4s2_writebyte (dev->fd, 6, 0x37); + reset_bank_count (dev); + + sanei_pa4s2_writebyte (dev->fd, 6, 0x27); + sanei_pa4s2_writebyte (dev->fd, 6, 0x67); + sanei_pa4s2_writebyte (dev->fd, 6, 0x17); + sanei_pa4s2_writebyte (dev->fd, 6, 0x77); + + /* set_initial_skip_1013 (dev); */ + + sanei_pa4s2_writebyte (dev->fd, 6, 0x41); + + priv->adjustskip = priv->skipcount + priv->skipimagebytes; + + DBG (5, "config_ccd_1013: adjustskip %u\n", priv->adjustskip); + + sanei_pa4s2_writebyte (dev->fd, 5, priv->adjustskip / 16 + 2); + + priv->adjustskip %= 16; + + sanei_pa4s2_writebyte (dev->fd, 6, 0x81); + sanei_pa4s2_writebyte (dev->fd, 5, 0x70); + sanei_pa4s2_writebyte (dev->fd, 6, 0x01); + + + set_line_adjust (dev); + + get_bank_count (dev); + +} + +/* these functions are for the 1015 chipset */ + + +static void +motor_control_1015 (Mustek_pp_Handle * dev, u_char control) +{ + u_char val; + + DBG (5, "motor_controll_1015: control code 0x%02x\n", + (unsigned int) control); + + sanei_pa4s2_writebyte (dev->fd, 6, 0xF6); + sanei_pa4s2_writebyte (dev->fd, 6, 0x22); + sanei_pa4s2_writebyte (dev->fd, 5, control); + sanei_pa4s2_writebyte (dev->fd, 6, 0x02); + + do + { + + sanei_pa4s2_readbegin (dev->fd, 2); + sanei_pa4s2_readbyte (dev->fd, &val); + sanei_pa4s2_readend (dev->fd); + + } + while ((val & 0x08) != 0); + +} + +static void +return_home_1015 (Mustek_pp_Handle * dev, SANE_Bool nowait) +{ + + u_char ishome, control = 0xC3; + + motor_control_1015 (dev, control); + + do + { + + /* check_is_home_1015 */ + sanei_pa4s2_readbegin (dev->fd, 2); + sanei_pa4s2_readbyte (dev->fd, &ishome); + sanei_pa4s2_readend (dev->fd); + + if (nowait) + break; + + usleep (1000); /* much nicer load */ + + } + while ((ishome & 2) == 0); + +} + +static void +motor_forward_1015 (Mustek_pp_Handle * dev) +{ + u_char control = 0x1B; + mustek_pp_ccd300_priv *priv = dev->priv; + + priv->motor_step++; + set_led (dev); + + + motor_control_1015 (dev, control); + + set_ccd_channel_1015 (dev, priv->channel); + set_sti (dev); + +} + +/* +static void +motor_backward_1015 (Mustek_pp_Handle * dev) +{ + u_char control = 0x43; + mustek_pp_ccd300_priv *priv = dev->priv; + + priv->motor_step++; + + set_led (dev); + + switch (priv->ccd_type) + { + case 1: + control = 0x1B; + break; + + default: + control = 0x43; + break; + } + + motor_control_1015 (dev, control); + + set_ccd_channel_1015 (dev, priv->channel); + set_sti (dev); + +} +*/ + + +static void +set_ccd_channel_1015 (Mustek_pp_Handle * dev, int channel) +{ + + u_char chancode = chan_codes_1015[channel]; + mustek_pp_ccd300_priv *priv = dev->priv; + + priv->channel = channel; + + priv->image_control &= 0x34; + chancode |= priv->image_control; + + + priv->image_control = chancode; + + sanei_pa4s2_writebyte (dev->fd, 6, chancode); + +} + + +static void +config_ccd_1015 (Mustek_pp_Handle * dev) +{ + + u_char val; + mustek_pp_ccd300_priv *priv = dev->priv; + + if (dev->res != 0) + priv->res_step = SANE_FIX ((float) priv->hwres / (float) dev->res); + + + set_dpi_value (dev); + + priv->image_control = 4; + + /* set_start_channel_1015 (dev); */ + + switch (dev->mode) + { + case MODE_BW: + case MODE_GRAYSCALE: + priv->channel = CCD300_CHANNEL_GRAY; + break; + + case MODE_COLOR: + priv->channel = CCD300_CHANNEL_RED; + break; + + } + + set_ccd_channel_1015 (dev, priv->channel); + + + /* set_invert_1015 (dev); */ + + priv->image_control &= 0xE4; + + if (dev->invert == SANE_FALSE) + priv->image_control |= 0x10; + + + sanei_pa4s2_writebyte (dev->fd, 6, priv->image_control); + + sanei_pa4s2_writebyte (dev->fd, 6, 0x23); + sanei_pa4s2_writebyte (dev->fd, 5, 0x00); + + sanei_pa4s2_writebyte (dev->fd, 6, 0x43); + + switch (priv->ccd_type) + { + case 1: + val = 0x6B; + break; + case 4: + val = 0x9F; + break; + default: + val = 0x92; + break; + } + + sanei_pa4s2_writebyte (dev->fd, 5, val); + sanei_pa4s2_writebyte (dev->fd, 6, 0x03); + + sanei_pa4s2_writebyte (dev->fd, 6, 0x37); + reset_bank_count (dev); + + sanei_pa4s2_writebyte (dev->fd, 6, 0x27); + sanei_pa4s2_writebyte (dev->fd, 6, 0x67); + sanei_pa4s2_writebyte (dev->fd, 6, 0x17); + sanei_pa4s2_writebyte (dev->fd, 6, 0x77); + + /* set_initial_skip_1015 (dev); */ + + sanei_pa4s2_writebyte (dev->fd, 6, 0x41); + + priv->adjustskip = priv->skipcount + priv->skipimagebytes; + + /* if (dev->CCD.mode == MODE_COLOR) + dev->CCD.adjustskip <<= 3; */ + + + sanei_pa4s2_writebyte (dev->fd, 5, priv->adjustskip / 32 + 1); + + priv->adjustskip %= 32; + + + sanei_pa4s2_writebyte (dev->fd, 6, 0x81); + + /* expose time */ + switch (priv->ccd_type) + { + case 1: + + val = 0xA8; + break; + case 0: + val = 0x8A; + break; + default: + val = 0xA8; + break; + } + + sanei_pa4s2_writebyte (dev->fd, 5, val); + + sanei_pa4s2_writebyte (dev->fd, 6, 0x01); + + + set_line_adjust (dev); + + get_bank_count (dev); + +} + + +/* these functions are interfaces only */ +static void +config_ccd (Mustek_pp_Handle * dev) +{ + mustek_pp_ccd300_priv *priv = dev->priv; + + DBG (5, "config_ccd: %d dpi, mode %d, invert %d, size %d\n", + priv->hwres, dev->mode, dev->invert, dev->params.pixels_per_line); + + switch (priv->asic) + { + case CCD300_ASIC1013: + config_ccd_1013 (dev); + break; + + case CCD300_ASIC1015: + config_ccd_1015 (dev); + break; + } + +} + +static void +return_home (Mustek_pp_Handle * dev, SANE_Bool nowait) +{ + mustek_pp_ccd300_priv *priv = dev->priv; + + priv->saved_mode = dev->mode; + priv->saved_invert = dev->invert; + priv->saved_skipcount = priv->skipcount; + priv->saved_skipimagebyte = priv->skipimagebytes; + priv->saved_adjustskip = priv->adjustskip; + priv->saved_res = dev->res; + priv->saved_hwres = priv->hwres; + priv->saved_res_step = priv->res_step; + priv->saved_line_step = priv->line_step; + priv->saved_channel = priv->channel; + + + priv->hwres = dev->res = 100; + dev->mode = MODE_GRAYSCALE; + + priv->skipcount = priv->skipimagebytes = 0; + + config_ccd (dev); + + switch (priv->asic) + { + case CCD300_ASIC1013: + return_home_1013 (dev); + break; + + case CCD300_ASIC1015: + return_home_1015 (dev, nowait); + break; + } + + + dev->mode = priv->saved_mode; + dev->invert = priv->saved_invert; + priv->skipcount = priv->saved_skipcount; + priv->skipimagebytes = priv->saved_skipimagebyte; + priv->adjustskip = priv->saved_adjustskip; + dev->res = priv->saved_res; + priv->hwres = priv->saved_hwres; + priv->res_step = priv->saved_res_step; + priv->line_step = priv->saved_line_step; + priv->channel = priv->saved_channel; + priv->motor_step = 0; + + config_ccd (dev); +} + +static void +lamp (Mustek_pp_Handle * dev, int lamp_on) +{ + + set_lamp (dev, lamp_on); + +} + +static void +set_voltages (Mustek_pp_Handle * dev) +{ + send_voltages (dev); +} + +static void +move_motor (Mustek_pp_Handle * dev, int count, int forward) +{ + + int ctr; + + DBG (5, "move_motor: %u steps (%s)\n", count, + (forward == SANE_TRUE ? "forward" : "backward")); + + + for (ctr = 0; ctr < count; ctr++) + { + + move_motor_101x (dev, forward); + + } + + +} + +static void +calibrate (Mustek_pp_Handle * dev) +{ + mustek_pp_ccd300_priv *priv = dev->priv; + + DBG (5, "calibrate entered (asic = 0x%02x)\n", priv->asic); + + calibrate_device_101x (dev); + + DBG (5, "calibrate: ref_black %d, blackpos %d\n", + priv->ref_black, priv->blackpos); + +} + + +static void +get_lineart_line (Mustek_pp_Handle * dev, SANE_Byte * buf) +{ + get_lineart_line_101x (dev, buf); +} + +static void +get_grayscale_line (Mustek_pp_Handle * dev, SANE_Byte * buf) +{ + + get_grayscale_line_101x (dev, buf); +} + +static void +get_color_line (Mustek_pp_Handle * dev, SANE_Byte * buf) +{ + + get_color_line_101x (dev, buf); + +} + + +static SANE_Status +ccd300_init (SANE_Int options, SANE_String_Const port, + SANE_String_Const name, SANE_Attach_Callback attach) +{ + SANE_Status status; + unsigned char asic, ccd; + int fd; + + if (options != CAP_NOTHING) + { + DBG (1, "ccd300_init: called with unknown options (%#02x)\n", options); + return SANE_STATUS_INVAL; + } + + /* try to attach to he supplied port */ + status = sanei_pa4s2_open (port, &fd); + + if (status != SANE_STATUS_GOOD) + { + DBG (2, "ccd300_init: couldn't attach to port ``%s'' (%s)\n", + port, sane_strstatus (status)); + return status; + } + + sanei_pa4s2_enable (fd, SANE_TRUE); + sanei_pa4s2_readbegin (fd, 0); + sanei_pa4s2_readbyte (fd, &asic); + sanei_pa4s2_readend (fd); + sanei_pa4s2_readbegin (fd, 2); + sanei_pa4s2_readbyte (fd, &ccd); + sanei_pa4s2_readend (fd); + sanei_pa4s2_enable (fd, SANE_FALSE); + sanei_pa4s2_close (fd); + + if (asic != CCD300_ASIC1013 && asic != CCD300_ASIC1015) + { + DBG (2, "ccd300_init: scanner not recognized (unknown ASIC id %#02x)\n", + asic); + return SANE_STATUS_INVAL; + } + + ccd &= (asic == CCD300_ASIC1013 ? 0x04 : 0x05); + + DBG (3, "ccd_init: found scanner on port ``%s'' (ASIC id %#02x, CCD %d)\n", + port, asic, ccd); + + return attach (port, name, MUSTEK_PP_CCD300, options); + +} + +static void +ccd300_capabilities (SANE_Int info, SANE_String * model, + SANE_String * vendor, SANE_String * type, + SANE_Int * maxres, SANE_Int * minres, + SANE_Int * maxhsize, SANE_Int * maxvsize, + SANE_Int * caps) +{ + *model = strdup ("600 III EP Plus"); + *vendor = strdup ("Mustek"); + *type = strdup ("flatbed (CCD 300 dpi)"); + DBG (3, + "ccd300_capabilities: 600 III EP Plus flatbed CCD (300 dpi) scanner\n"); + + *maxres = 300; + *minres = 50; + *maxhsize = CCD300_MAXHSIZE; + *maxvsize = CCD300_MAXVSIZE; + *caps = info | CAP_INVERT | CAP_LAMP_OFF; +} + +static SANE_Status +ccd300_open (SANE_String port, SANE_Int caps, SANE_Int * fd) +{ + SANE_Status status; + + if (caps & ~(CAP_NOTHING | CAP_INVERT | CAP_LAMP_OFF)) + { + DBG (1, "ccd300_open: called with unknonw capabilities (%#02x)\n", + caps); + return SANE_STATUS_INVAL; + } + + DBG (3, "ccd300_open: called for port ``%s''\n", port); + + status = sanei_pa4s2_open (port, fd); + + if (status != SANE_STATUS_GOOD) + DBG (2, "ccd300_open: open failed (%s)\n", sane_strstatus (status)); + + return status; +} + +static void +ccd300_setup (SANE_Handle handle) +{ + Mustek_pp_Handle *dev = handle; + mustek_pp_ccd300_priv *priv; + unsigned char asic, ccd; + + DBG (3, "ccd300_setup: called for port ``%s''\n", dev->dev->port); + + if ((priv = malloc (sizeof (mustek_pp_ccd300_priv))) == NULL) + { + DBG (1, "ccd300_setup: not enough memory\n"); + return; /* can you here the shit hitting the fan? */ + } + + dev->priv = priv; + memset (priv, 0, sizeof (mustek_pp_ccd300_priv)); + + priv->bw = 128; + priv->wait_bank = 700; + priv->top = 47; + + sanei_pa4s2_enable (dev->fd, SANE_TRUE); + + sanei_pa4s2_readbegin (dev->fd, 0); + sanei_pa4s2_readbyte (dev->fd, &asic); + sanei_pa4s2_readend (dev->fd); + sanei_pa4s2_readbegin (dev->fd, 2); + sanei_pa4s2_readbyte (dev->fd, &ccd); + sanei_pa4s2_readend (dev->fd); + ccd &= (asic == CCD300_ASIC1013 ? 0x04 : 0x05); + priv->asic = asic; + priv->ccd_type = ccd; + + return_home (dev, SANE_TRUE); + lamp (dev, SANE_TRUE); + sanei_pa4s2_enable (dev->fd, SANE_FALSE); + dev->lamp_on = time (NULL); + dev->res = priv->hwres = 300; + dev->mode = MODE_COLOR; +} + +static void +ccd300_close (SANE_Handle handle) +{ + + Mustek_pp_Handle *dev = handle; + mustek_pp_ccd300_priv *priv = dev->priv; + + DBG (3, "ccd300_close: called for port ``%s''\n", dev->dev->port); + + sanei_pa4s2_enable (dev->fd, SANE_TRUE); + lamp (dev, SANE_FALSE); + return_home (dev, SANE_FALSE); + sanei_pa4s2_enable (dev->fd, SANE_FALSE); + + sanei_pa4s2_close (dev->fd); + free (priv); + + DBG (3, "ccd300_close: device shut down and all buffers freed\n"); +} + +static SANE_Status +ccd300_config (SANE_Handle handle, SANE_String_Const optname, + SANE_String_Const optval) +{ + Mustek_pp_Handle *dev = handle; + mustek_pp_ccd300_priv *priv = dev->priv; + int value = -1; + + DBG (3, "ccd300_config: called for port ``%s'' (%s%s%s)\n", + dev->dev->port, + optname, (optval ? " = " : ""), (optval ? optval : "")); + + if (!strcmp (optname, "bw")) + { + + if (!optval) + { + DBG (1, "ccd300_config: missing value for option ``bw''\n"); + return SANE_STATUS_INVAL; + } + + /* ok, ok, should be strtol... know what? send me a patch. */ + value = atoi (optval); + + if ((value < 0) || (value > 255)) + { + DBG (1, + "ccd300_config: value ``%s'' for option ``bw'' is out of range (0 <= bw <= 255)\n", + optval); + return SANE_STATUS_INVAL; + } + + priv->bw = value; + + } + else if (!strcmp (optname, "waitbank")) + { + + if (!optval) + { + DBG (1, "ccd300_config: missing value for option ``waitbank''\n"); + return SANE_STATUS_INVAL; + } + + value = atoi (optval); + + if (value < 0) + { + DBG (1, + "ccd300_config: value ``%s'' for option ``waitbank'' is out of range (>= 0)\n", + optval); + return SANE_STATUS_INVAL; + } + + priv->wait_bank = value; + } + else if (!strcmp (optname, "top")) + { + + if (!optval) + { + DBG (1, "ccd300_config: missing value for option ``top''\n"); + return SANE_STATUS_INVAL; + } + + value = atoi (optval); + + if (value < 0) + { + DBG (1, + "ccd300_config: value ``%s'' for option ``top'' is out of range (>= 0)\n", + optval); + return SANE_STATUS_INVAL; + } + + priv->top = value; + } + else + { + DBG (1, "ccd300_config: unkown option ``%s''", optname); + return SANE_STATUS_INVAL; + } + + return SANE_STATUS_GOOD; + +} + +static void +ccd300_stop (SANE_Handle handle) +{ + Mustek_pp_Handle *dev = handle; + mustek_pp_ccd300_priv *priv = dev->priv; + int cnt; + + DBG (3, "ccd300_stop: stopping scan operating on port ``%s''\n", + dev->dev->port); + + sanei_pa4s2_enable (dev->fd, SANE_TRUE); + return_home (dev, SANE_TRUE); + sanei_pa4s2_enable (dev->fd, SANE_FALSE); + + free (priv->calib_r); + free (priv->calib_g); + free (priv->calib_b); + + if (priv->red) + { + for (cnt = 0; cnt < priv->green_offs; cnt++) + free (priv->red[cnt]); + free (priv->red); + } + if (priv->blue) + { + for (cnt = 0; cnt < priv->blue_offs; cnt++) + free (priv->blue[cnt]); + free (priv->blue); + } + free (priv->green); + + priv->calib_r = priv->calib_g = priv->calib_b = NULL; + priv->red = priv->blue = NULL; + priv->green = NULL; + +} + +static SANE_Status +ccd300_start (SANE_Handle handle) +{ + Mustek_pp_Handle *dev = handle; + mustek_pp_ccd300_priv *priv = dev->priv; + + DBG (3, "ccd300_start: called for port ``%s''\n", dev->dev->port); + + if (dev->res <= 100) + priv->hwres = 100; + else if (dev->res <= 200) + priv->hwres = 200; + else if (dev->res <= 300) + priv->hwres = 300; + + DBG (4, "ccd300_start: setting hardware resolution to %d dpi\n", + priv->hwres); + + priv->skipimagebytes = dev->topX; + + sanei_pa4s2_enable (dev->fd, SANE_TRUE); + config_ccd (dev); + set_voltages (dev); + get_bank_count (dev); + + if (priv->bank_count != 0) + { + DBG (2, "ccd300_start: bank count is not zero...\n"); + } + + return_home (dev, SANE_FALSE); + + priv->motor_step = 0; + + /* allocate memory for calibration */ + if ((priv->calib_g = malloc (dev->params.pixels_per_line)) == NULL) + { + sanei_pa4s2_enable (dev->fd, SANE_FALSE); + DBG (1, "ccd300_start: not enough memory\n"); + return SANE_STATUS_NO_MEM; + } + + if (dev->mode == MODE_COLOR) + { + priv->calib_r = malloc (dev->params.pixels_per_line); + priv->calib_b = malloc (dev->params.pixels_per_line); + + if ((priv->calib_r == NULL) || (priv->calib_b == NULL)) + { + free (priv->calib_g); + free (priv->calib_r); + free (priv->calib_b); + priv->calib_r = priv->calib_g = priv->calib_b = NULL; + + sanei_pa4s2_enable (dev->fd, SANE_FALSE); + DBG (1, "ccd300_start: not enough memory\n"); + return SANE_STATUS_NO_MEM; + } + } + + calibrate (dev); + + if (priv->ccd_type == 1) + { + priv->blue_offs = 4; + priv->green_offs = 8; + } + else + { + priv->blue_offs = 8; + priv->green_offs = 16; + } + + move_motor (dev, priv->top + dev->topY - + (dev->mode == MODE_COLOR ? priv->green_offs : 0), SANE_TRUE); + + if (priv->ccd_type == 1) + sanei_pa4s2_writebyte (dev->fd, 6, 0x15); + + sanei_pa4s2_enable (dev->fd, SANE_FALSE); + + if (dev->mode == MODE_COLOR) + { + int failed = SANE_FALSE, cnt; + + priv->line_step = SANE_FIX (300.0 / (float) dev->res); + priv->rdiff = priv->line_step; + priv->bdiff = priv->rdiff + (priv->blue_offs << SANE_FIXED_SCALE_SHIFT); + priv->gdiff = + priv->rdiff + (priv->green_offs << SANE_FIXED_SCALE_SHIFT); + + priv->red = malloc (sizeof (SANE_Byte *) * priv->green_offs); + priv->blue = malloc (sizeof (SANE_Byte *) * priv->blue_offs); + priv->green = malloc (dev->params.pixels_per_line); + + if ((priv->red == NULL) || (priv->blue == NULL) + || (priv->green == NULL)) + { + free (priv->calib_r); + free (priv->calib_g); + free (priv->calib_b); + priv->calib_r = priv->calib_g = priv->calib_b = NULL; + + free (priv->red); + free (priv->green); + free (priv->blue); + priv->red = priv->blue = NULL; + priv->green = NULL; + + DBG (1, "ccd300_start: not enough memory for ld buffers\n"); + return SANE_STATUS_NO_MEM; + } + + /* note to myself: better allocate one huge chunk of memory and set + pointers */ + for (cnt = 0; cnt < priv->green_offs; cnt++) + if ((priv->red[cnt] = malloc (dev->params.pixels_per_line)) == NULL) + failed = SANE_TRUE; + + for (cnt = 0; cnt < priv->blue_offs; cnt++) + if ((priv->blue[cnt] = malloc (dev->params.pixels_per_line)) == NULL) + failed = SANE_TRUE; + + if (failed == SANE_TRUE) + { + free (priv->calib_r); + free (priv->calib_g); + free (priv->calib_b); + priv->calib_r = priv->calib_g = priv->calib_b = NULL; + + for (cnt = 0; cnt < priv->green_offs; cnt++) + free (priv->red[cnt]); + for (cnt = 0; cnt < priv->blue_offs; cnt++) + free (priv->blue[cnt]); + + free (priv->red); + free (priv->green); + free (priv->blue); + priv->red = priv->blue = NULL; + priv->green = NULL; + + DBG (1, "ccd300_start: not enough memory for ld buffers\n"); + return SANE_STATUS_NO_MEM; + } + + priv->redline = priv->blueline = priv->ccd_line = 0; + } + + priv->lines = 0; + priv->lines_left = dev->params.lines; + + DBG (3, "ccd300_start: device ready for scanning\n"); + + return SANE_STATUS_GOOD; +} + +static void +ccd300_read (SANE_Handle handle, SANE_Byte * buffer) +{ + Mustek_pp_Handle *dev = handle; + mustek_pp_ccd300_priv *priv = dev->priv; + + DBG (3, "ccd300_read: receiving one line from port ``%s''\n", + dev->dev->port); + + sanei_pa4s2_enable (dev->fd, SANE_TRUE); + + switch (dev->mode) + { + case MODE_BW: + get_lineart_line (dev, buffer); + break; + + case MODE_GRAYSCALE: + get_grayscale_line (dev, buffer); + break; + + case MODE_COLOR: + get_color_line (dev, buffer); + break; + } + + priv->lines_left--; + priv->lines++; + + DBG (4, "ccd300_read: %d lines read (%d to go)\n", priv->lines, + priv->lines_left); + + if (priv->lines_left == 0) + { + DBG (3, "ccd300_read: scan finished\n"); + return_home (dev, SANE_TRUE); + } + + sanei_pa4s2_enable (dev->fd, SANE_FALSE); + +} |