From 6e9c41a892ed0e0da326e0278b3221ce3f5713b8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=B6rg=20Frings-F=C3=BCrst?= Date: Mon, 6 Oct 2014 14:00:40 +0200 Subject: Initial import of sane-backends version 1.0.24-1.2 --- backend/canon-scsi.c | 733 +++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 733 insertions(+) create mode 100644 backend/canon-scsi.c (limited to 'backend/canon-scsi.c') diff --git a/backend/canon-scsi.c b/backend/canon-scsi.c new file mode 100644 index 0000000..423a07e --- /dev/null +++ b/backend/canon-scsi.c @@ -0,0 +1,733 @@ +/* sane - Scanner Access Now Easy. + Copyright (C) 1997 BYTEC GmbH Germany + Written by Helmut Koeberle, Email: helmut.koeberle@bytec.de + Modified by Manuel Panea + and Markus Mertinat + + 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 low-level scsi-commands. */ + +static SANE_Status +test_unit_ready (int fd) +{ + static u_char cmd[6]; + int status; + DBG (31, ">> test_unit_ready\n"); + + memset (cmd, 0, sizeof (cmd)); + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, NULL, NULL); + + DBG (31, "<< test_unit_ready\n"); + return (status); +} + +#ifdef IMPLEMENT_ALL_SCANNER_SCSI_COMMANDS +static SANE_Status +request_sense (int fd, void *buf, size_t *buf_size) +{ + static u_char cmd[6]; + int status; + DBG (31, ">> request_sense\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x03; + cmd[4] = 14; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, buf, buf_size); + + DBG (31, "<< request_sense\n"); + return (status); +} +#endif + +static SANE_Status +inquiry (int fd, int evpd, void *buf, size_t *buf_size) +{ + static u_char cmd[6]; + int status; + DBG (31, ">> inquiry\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x12; + cmd[1] = evpd; + cmd[2] = evpd ? 0xf0 : 0; + cmd[4] = evpd ? 74 : 36; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, buf, buf_size); + + DBG (31, "<< inquiry\n"); + return (status); +} + +#ifdef IMPLEMENT_ALL_SCANNER_SCSI_COMMANDS +static SANE_Status +mode_select (int fd) +{ + static u_char cmd[6 + 12]; + int status; + DBG (31, ">> mode_select\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x15; + cmd[1] = 16; + cmd[4] = 12; + cmd[6 + 4] = 3; + cmd[6 + 5] = 6; + cmd[6 + 8] = 0x02; + cmd[6 + 9] = 0x58; + status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), NULL, NULL); + + DBG (31, "<< mode_select\n"); + return (status); +} +#endif + +static SANE_Status +reserve_unit (int fd) +{ + static u_char cmd[6]; + int status; + DBG (31, ">> reserve_unit\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x16; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, NULL, NULL); + + DBG (31, "<< reserve_unit\n"); + return (status); +} + +#ifdef IMPLEMENT_ALL_SCANNER_SCSI_COMMANDS +static SANE_Status +release_unit (int fd) +{ + static u_char cmd[6]; + int status; + DBG (31, ">> release_unit\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x17; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, NULL, NULL); + + DBG (31, "<< release_unit\n"); + return (status); +} +#endif + +static SANE_Status +mode_sense (int fd, void *buf, size_t *buf_size) +{ + static u_char cmd[6]; + int status; + DBG (31, ">> mode_sense\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x1a; + cmd[2] = 3; + cmd[4] = 12; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, buf, buf_size); + + DBG (31, "<< mode_sense\n"); + return (status); +} + +static SANE_Status +scan (int fd) +{ + static u_char cmd[6 + 1]; + int status; + DBG (31, ">> scan\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x1b; + cmd[4] = 1; + status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), NULL, NULL); + + DBG (31, "<< scan\n"); + return (status); +} + +static SANE_Status +send_diagnostic (int fd) +{ + static u_char cmd[6]; + int status; + DBG (31, ">> send_diagnostic\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x1d; + cmd[1] = 4; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, NULL, NULL); + + DBG (31, "<< send_diagnostic\n"); + return (status); +} + +static SANE_Status +set_window (int fd, void *data) +{ + static u_char cmd[10]; + int status; + DBG (31, ">> set_window\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x24; + cmd[8] = 72; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), data, 72, NULL, NULL); + + DBG (31, "<< set_window\n"); + return (status); +} + +static SANE_Status +get_window (int fd, void *buf, size_t *buf_size) +{ + static u_char cmd[10]; + int status; + DBG (31, ">> get_window\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x25; + cmd[1] = 1; + cmd[8] = 72; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, buf, buf_size); + + DBG (31, "<< get_window\n"); + return (status); +} + +static SANE_Status +read_data (int fd, void *buf, size_t *buf_size) +{ + static u_char cmd[10]; + int status; + DBG (31, ">> read_data\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x28; + cmd[6] = *buf_size >> 16; + cmd[7] = *buf_size >> 8; + cmd[8] = *buf_size; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, buf, buf_size); + + DBG (31, "<< read_data\n"); + return (status); +} + +static SANE_Status +medium_position (int fd) +{ + static u_char cmd[10]; + int status; + DBG (31, ">> medium_position\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x31; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, NULL, NULL); + + DBG (31, "<< medium_position\n"); + return (status); +} + +#ifdef IMPLEMENT_ALL_SCANNER_SCSI_COMMANDS +static SANE_Status +execute_shading (int fd) +{ + static u_char cmd[10]; + int status; + DBG (31, ">> execute shading\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0xe2; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, NULL, NULL); + + DBG (31, "<< execute shading\n"); + return (status); +} +#endif + +static SANE_Status +execute_auto_focus (int fd, int AF, int speed, int AE, int count) +{ + static u_char cmd[10]; + int status; + DBG (7, ">> execute_auto_focus\n"); + DBG (7, ">> focus: mode='%d', speed='%d', AE='%d', count='%d'\n", + AF, speed, AE, count); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0xe0; + cmd[1] = (u_char) AF; + cmd[2] = (u_char) ((speed << 7) | AE); +#if 1 + cmd[4] = (u_char) count; /* seems to work, but may be unsafe */ +#else /* The Canon software uses this: */ + cmd[4] = (u_char) (28 * ((int) (count / 28.5)) + 16); +#endif + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, NULL, NULL); + + DBG (7, "<< execute_auto_focus\n"); + return (status); +} + +static SANE_Status +set_adf_mode (int fd, u_char priority) +{ + static u_char cmd[6]; + int status; + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0xd4; + cmd[4] = 0x01; + + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), &priority, 1, NULL, NULL); + + return (status); +} + +static SANE_Status +get_scan_mode (int fd, u_char page, void *buf, size_t *buf_size) +{ + static u_char cmd[6]; + int status; + int PageLen = 0x00; + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0xd5; + cmd[2] = page; + + switch (page) + { + case AUTO_DOC_FEEDER_UNIT: + case TRANSPARENCY_UNIT: + cmd[4] = 0x0c + PageLen; + break; + + case SCAN_CONTROL_CONDITIONS: + cmd[4] = 0x14 + PageLen; + break; + + case SCAN_CONTROL_CON_FB1200: + cmd[2] = 0x20; + cmd[4] = 0x17 + PageLen; + break; + + default: + cmd[4] = 0x24 + PageLen; + break; + } + + DBG (31, "get scan mode: cmd[4]='0x%0X'\n", cmd[4]); + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, buf, buf_size); + + DBG (31, "<< get scan mode\n"); + return (status); +} + +static SANE_Status +define_scan_mode (int fd, u_char page, void *data) +{ + static u_char cmd[6]; + u_char pdata[36]; + size_t i; + int status, pdatalen; + DBG (31, ">> define scan mode\n"); + + memset (cmd, 0, sizeof (cmd)); + memset (pdata, 0, sizeof (pdata)); + cmd[0] = 0xd6; + cmd[1] = 0x10; + cmd[4] = (page == TRANSPARENCY_UNIT) ? 0x0c + : (page == TRANSPARENCY_UNIT_FB1200) ? 0x0c + : (page == SCAN_CONTROL_CONDITIONS) ? 0x14 + : (page == SCAN_CONTROL_CON_FB1200) ? 0x17 : 0x24; + + memcpy (pdata + 4, data, (page == TRANSPARENCY_UNIT) ? 8 + : (page == TRANSPARENCY_UNIT_FB1200) ? 10 + : (page == SCAN_CONTROL_CONDITIONS) ? 16 + : (page == SCAN_CONTROL_CON_FB1200) ? 19 : 32); + + for (i = 0; i < sizeof (cmd); i++) + DBG (31, "define scan mode: cmd[%d]='0x%0X'\n", (int) i, + cmd[i]); + + for (i = 0; i < sizeof (pdata); i++) + DBG (31, "define scan mode: pdata[%d]='0x%0X'\n", (int) i, + pdata[i]); + + pdatalen = (page == TRANSPARENCY_UNIT) ? 12 + : (page == TRANSPARENCY_UNIT_FB1200) ? 14 + : (page == SCAN_CONTROL_CONDITIONS) ? 20 + : (page == SCAN_CONTROL_CON_FB1200) ? 23 : 36; + + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), pdata, pdatalen, NULL, + NULL); + DBG (31, "<< define scan mode\n"); + return (status); +} + +static SANE_Status +get_density_curve (int fd, int component, void *buf, size_t *buf_size, + int transfer_data_type) +{ + static u_char cmd[10]; + int status; + DBG (31, ">> get_density_curve\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x28; + cmd[2] = transfer_data_type; + cmd[4] = component; + cmd[5] = 0; + cmd[6] = ((*buf_size) >> 16) & 0xff; + cmd[7] = ((*buf_size) >> 8) & 0xff; + cmd[8] = (*buf_size) & 0xff; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, buf, buf_size); + + DBG (31, "<< get_density_curve\n"); + return (status); +} + +#ifdef IMPLEMENT_ALL_SCANNER_SCSI_COMMANDS +static SANE_Status +get_density_curve_data_format (int fd, void *buf, size_t *buf_size) +{ + static u_char cmd[10]; + int status; + DBG (31, ">> get_density_curve_data_format\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x28; + cmd[2] = 0x03; + cmd[4] = 0xff; + cmd[5] = 0; + cmd[6] = 0; + cmd[7] = 0; + cmd[8] = 14; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, buf, buf_size); + + DBG (31, "<< get_density_curve_data_format\n"); + return (status); +} +#endif + +static SANE_Status +set_density_curve (int fd, int component, void *buf, size_t *buf_size, + int transfer_data_type) +{ + static u_char cmd[10]; + int status; + DBG (31, ">> set_density_curve\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x2a; + cmd[2] = transfer_data_type; + cmd[4] = component; + cmd[5] = 0; + cmd[6] = ((*buf_size) >> 16) & 0xff; + cmd[7] = ((*buf_size) >> 8) & 0xff; + cmd[8] = (*buf_size) & 0xff; + + status = + sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), buf, *buf_size, NULL, NULL); + + DBG (31, "<< set_density_curve\n"); + return (status); +} + + +/* static SANE_Status */ +/* set_density_curve_data_format (int fd, void *buf, size_t *buf_size) */ +/* { */ +/* static u_char cmd[10]; */ +/* int status, i; */ +/* DBG (31, ">> set_density_curve_data_format\n"); */ + +/* memset (cmd, 0, sizeof (cmd)); */ +/* cmd[0] = 0x2a; */ +/* cmd[2] = 0x03; */ +/* cmd[4] = 0xff; */ +/* cmd[5] = 0; */ +/* cmd[6] = 0; */ +/* cmd[7] = 0; */ +/* cmd[8] = 14; */ +/* status = sanei_scsi_cmd (fd, cmd, sizeof (cmd), buf, buf_size); */ + +/* DBG (31, "<< set_density_curve_data_format\n"); */ +/* return (status); */ +/* } */ + +#ifdef IMPLEMENT_ALL_SCANNER_SCSI_COMMANDS +static SANE_Status +get_power_on_timer (int fd, void *buf, size_t *buf_size) +{ + static u_char cmd[10]; + int status; + DBG (31, ">> get power on timer\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0xe3; + cmd[6] = 1; + cmd[7] = 0; + cmd[8] = 0; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, buf, buf_size); + + DBG (31, "<< get power on timer\n"); + return (status); +} +#endif + +static SANE_Status +get_film_status (int fd, void *buf, size_t *buf_size) +{ + static u_char cmd[10]; + int status; + DBG (31, ">> get film status\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0xe1; + cmd[6] = 0; + cmd[7] = 0; + cmd[8] = 4; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, buf, buf_size); + + DBG (31, "<< get film status\n"); + return (status); +} + +static SANE_Status +get_data_status (int fd, void *buf, size_t *buf_size) +{ + static u_char cmd[10]; + int status; + DBG (31, ">> get_data_status\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0x34; + cmd[8] = 28; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, buf, buf_size); + + DBG (31, "<< get_data_status\n"); + return (status); +} + +/*************** modification for FB620S ***************/ +static SANE_Status +reset_scanner (int fd) +{ + static u_char cmd[6]; + int status; + DBG (31, ">> reset_scanner\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0xc1; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, NULL, NULL); + + DBG (31, "<< reset_scanner \n"); + return (status); +} + +static SANE_Status +execute_calibration (int fd) +{ + static u_char cmd[6]; + u_char data[2]; + int status; + DBG (31, ">> execute_calibration\n"); + + memset (cmd, 0, sizeof (cmd)); + memset (data, 0, sizeof (data)); + cmd[0] = 0xc2; + cmd[4] = 2; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), data, sizeof (data), + NULL, NULL); + + DBG (31, "<< execute_calibration\n"); + return (status); +} + +static SANE_Status +get_calibration_status (int fd, void *buf, size_t *buf_size) +{ + static u_char cmd[6]; + int status; + DBG (31, ">> get_calibration_status\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0xc3; + cmd[4] = *buf_size; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, buf, buf_size); + + DBG (31, "<< get_calibration_status\n"); + return (status); +} + +#if 0 +static SANE_Status +get_switch_status (int fd, void *buf, size_t *buf_size) +{ + static u_char cmd[6]; + int status; + DBG (31, ">> get_switch_status\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0xc4; + cmd[4] = 2; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, buf, buf_size); + + DBG (31, "<< get_switch_status\n"); + return (status); +} + +static SANE_Status +wait_ready(int fd) +{ + SANE_Status status; + int retry = 0; + + while ((status = test_unit_ready (fd)) != SANE_STATUS_GOOD) + { + DBG(5, "wait_ready failed (%d)\n", retry); + if (retry++ > 15) + return SANE_STATUS_IO_ERROR; + sleep(3); + } + return(status); +} +#endif + +/*************** modification for FB1200S ***************/ +static SANE_Status +cancel (int fd) +{ + static u_char cmd[10]; + int status; + DBG (31, ">> cancel_FB1200S\n"); + + memset (cmd, 0, sizeof (cmd)); + cmd[0] = 0xe4; + status = sanei_scsi_cmd2 (fd, cmd, sizeof (cmd), NULL, 0, NULL, NULL); + + DBG (31, "<< cancel_FB1200S \n"); + return (status); +} + +/**************************************************************************/ +/* As long as we do not know how this scanner stores its density curves, + we do the gamma correction with a 8 <--> 12 bit translation table + stored in the CANON_Scanner structure. */ + +static SANE_Status +get_density_curve_fs2710 (SANE_Handle handle, int component, u_char *buf, + size_t *buf_size) +{ + CANON_Scanner *s = handle; + int i; + + for (i = 0; i < 256; i++) + *buf++ = s->gamma_map[component][i << 4]; + *buf_size = 256; + return (SANE_STATUS_GOOD); +} + +static SANE_Status +set_density_curve_fs2710 (SANE_Handle handle, int component, u_char *buf) +{ + CANON_Scanner *s = handle; + int i, j, hi, lo; + u_char *p; + + for (i = 1, hi = *buf++, p = &s->gamma_map[component][0]; i <= 256; i++) + { + lo = hi; + hi = (i < 256) ? *buf++ : 2 * *(buf - 1) - *(buf - 2); + if (hi > 255) + hi = 255; + for (j = 0; j < 16; j++) /* do a linear interpolation */ + *p++ = (u_char) (lo + ((double) ((hi - lo) * j)) / 16.0 + 0.5); + } + return (SANE_STATUS_GOOD); +} + +static SANE_Status +set_parameters_fs2710 (SANE_Handle handle) +{ + CANON_Scanner *s = handle; + int i, j, invert, shadow[4], hilite[4]; + double x, b, c; + + shadow[1] = s->ShadowR << 4; + shadow[2] = s->ShadowG << 4; + shadow[3] = s->ShadowB << 4; + hilite[1] = s->HiliteR << 4; + hilite[2] = s->HiliteG << 4; + hilite[3] = s->HiliteB << 4; + c = ((double) s->contrast) / 128.0; + b = ((double) (s->brightness - 128)) / 128.0; + + invert = strcmp (filmtype_list[1], s->val[OPT_NEGATIVE].s); + + for (i = 1; i < 4; i++) + { + for (j = 0; j < 4096; j++) + { + if (j <= shadow[i]) + s->gamma_map[i][j] = (u_char) ((s->brightness >= 128) ? + 2 * s->brightness - 256 : 0); + else if (j < hilite[i]) + { + x = ((double) (j - shadow[i])) + / ((double) (hilite[i] - shadow[i])); + /* first do the contrast correction */ + x = (x <= 0.5) ? 0.5 * pow (2 * x, c) + : 1.0 - 0.5 * pow (2 * (1.0 - x), c); + x = pow (x, 0.5); /* default gamma correction */ + x += b; /* brightness correction */ + s->gamma_map[i][j] = (u_char) MAX (0, MIN (255, + (int) (255.0 * x))); + } + else + s->gamma_map[i][j] = (u_char) ((s->brightness >= 128) ? + 255 : 2 * s->brightness); + } + } + + return (SANE_STATUS_GOOD); +} + +/**************************************************************************/ -- cgit v1.2.3