diff options
Diffstat (limited to 'backend/hp-scl.c')
| -rw-r--r-- | backend/hp-scl.c | 2118 |
1 files changed, 2118 insertions, 0 deletions
diff --git a/backend/hp-scl.c b/backend/hp-scl.c new file mode 100644 index 0000000..e58508b --- /dev/null +++ b/backend/hp-scl.c @@ -0,0 +1,2118 @@ +/* sane - Scanner Access Now Easy. + Copyright (C) 1997 Geoffrey T. Dairiki + 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 is part of a SANE backend for HP Scanners supporting + HP Scanner Control Language (SCL). +*/ + +/* + $Log$ + Revision 1.15 2008/03/28 14:37:36 kitno-guest + add usleep to improve usb performance, from jim a t meyering d o t net + + Revision 1.14 2004-10-04 18:09:05 kig-guest + Rename global function hp_init_openfd to sanei_hp_init_openfd + + Revision 1.13 2004/03/27 13:52:39 kig-guest + Keep USB-connection open (was problem with Linux 2.6.x) + + Revision 1.12 2003/10/09 19:34:57 kig-guest + Redo when TEST UNIT READY failed + Redo when read returns with 0 bytes (non-SCSI only) + + +*/ + +/* +#define STUBS +extern int sanei_debug_hp;*/ +#define DEBUG_DECLARE_ONLY +#include "../include/sane/config.h" +#include "../include/lalloca.h" /* Must be first */ + +#ifdef HAVE_UNISTD_H +# include <unistd.h> +#endif +#include <stdlib.h> +#include <ctype.h> +#include <stdio.h> +#include <string.h> +#include <errno.h> +#include "../include/lassert.h" +#include <signal.h> +#include <sys/types.h> +#include <sys/stat.h> +#include <fcntl.h> +#include "../include/sane/sanei_scsi.h" +#include "../include/sane/sanei_usb.h" +#include "../include/sane/sanei_pio.h" + +#include "hp.h" + +#include "../include/sane/sanei_backend.h" + +#include "hp-option.h" +#include "hp-scsi.h" +#include "hp-scl.h" +#include "hp-device.h" + +#define HP_SCSI_INQ_LEN (36) +#define HP_SCSI_CMD_LEN (6) +#define HP_SCSI_BUFSIZ (HP_SCSI_MAX_WRITE + HP_SCSI_CMD_LEN) + +#define HP_MAX_OPEN_FD 16 +static struct hp_open_fd_s /* structure to save info about open file descriptor */ +{ + char *devname; + HpConnect connect; + int fd; +} asHpOpenFd[HP_MAX_OPEN_FD]; + + +/* + * + */ +struct hp_scsi_s +{ + int fd; + char * devname; + + /* Output buffering */ + hp_byte_t buf[HP_SCSI_BUFSIZ]; + hp_byte_t * bufp; + + hp_byte_t inq_data[HP_SCSI_INQ_LEN]; +}; + +#define HP_TMP_BUF_SIZE (1024*4) +#define HP_WR_BUF_SIZE (1024*4) + +typedef struct +{ + HpProcessData procdata; + + int outfd; + const unsigned char *map; + + unsigned char *image_buf; /* Buffer to store complete image (if req.) */ + unsigned char *image_ptr; + int image_buf_size; + + unsigned char *tmp_buf; /* Buffer for scan data to get even number of bytes */ + int tmp_buf_size; + int tmp_buf_len; + + unsigned char wr_buf[HP_WR_BUF_SIZE]; + unsigned char *wr_ptr; + int wr_buf_size; + int wr_left; +} PROCDATA_HANDLE; + + +/* Initialize structure where we remember out open file descriptors */ +void +sanei_hp_init_openfd () +{int iCount; + memset (asHpOpenFd, 0, sizeof (asHpOpenFd)); + + for (iCount = 0; iCount < HP_MAX_OPEN_FD; iCount++) + asHpOpenFd[iCount].fd = -1; +} + + +/* Look if the device is still open */ +static SANE_Status +hp_GetOpenDevice (const char *devname, HpConnect connect, int *pfd) + +{int iCount; + + for (iCount = 0; iCount < HP_MAX_OPEN_FD; iCount++) + { + if (!asHpOpenFd[iCount].devname) continue; + if ( (strcmp (asHpOpenFd[iCount].devname, devname) == 0) + && (asHpOpenFd[iCount].connect == connect) ) + { + if (pfd) *pfd = asHpOpenFd[iCount].fd; + DBG(3, "hp_GetOpenDevice: device %s is open with fd=%d\n", devname, + asHpOpenFd[iCount].fd); + return SANE_STATUS_GOOD; + } + } + DBG(3, "hp_GetOpenDevice: device %s not open\n", devname); + return SANE_STATUS_INVAL; +} + +/* Add an open file descriptor. This also decides */ +/* if we keep a connection open or not. */ +static SANE_Status +hp_AddOpenDevice (const char *devname, HpConnect connect, int fd) + +{int iCount, iKeepOpen; + static int iInitKeepFlags = 1; + + /* The default values which connections to keep open or not */ + static int iKeepOpenSCSI = 0; + static int iKeepOpenUSB = 1; + static int iKeepOpenDevice = 0; + static int iKeepOpenPIO = 0; + + if (iInitKeepFlags) /* Change the defaults by environment */ + {char *eptr; + + iInitKeepFlags = 0; + + eptr = getenv ("SANE_HP_KEEPOPEN_SCSI"); + if ( (eptr != NULL) && ((*eptr == '0') || (*eptr == '1')) ) + iKeepOpenSCSI = (*eptr == '1'); + + eptr = getenv ("SANE_HP_KEEPOPEN_USB"); + if ( (eptr != NULL) && ((*eptr == '0') || (*eptr == '1')) ) + iKeepOpenUSB = (*eptr == '1'); + + eptr = getenv ("SANE_HP_KEEPOPEN_DEVICE"); + if ( (eptr != NULL) && ((*eptr == '0') || (*eptr == '1')) ) + iKeepOpenDevice = (*eptr == '1'); + + eptr = getenv ("SANE_HP_KEEPOPEN_PIO"); + if ( (eptr != NULL) && ((*eptr == '0') || (*eptr == '1')) ) + iKeepOpenPIO = (*eptr == '1'); + } + + /* Look if we should keep it open or not */ + iKeepOpen = 0; + switch (connect) + { + case HP_CONNECT_SCSI: iKeepOpen = iKeepOpenSCSI; + break; + case HP_CONNECT_PIO : iKeepOpen = iKeepOpenPIO; + break; + case HP_CONNECT_USB : iKeepOpen = iKeepOpenUSB; + break; + case HP_CONNECT_DEVICE : iKeepOpen = iKeepOpenDevice; + break; + case HP_CONNECT_RESERVE: + break; + } + if (!iKeepOpen) + { + DBG(3, "hp_AddOpenDevice: %s should not be kept open\n", devname); + return SANE_STATUS_INVAL; + } + + for (iCount = 0; iCount < HP_MAX_OPEN_FD; iCount++) + { + if (!asHpOpenFd[iCount].devname) /* Is this entry free ? */ + { + asHpOpenFd[iCount].devname = sanei_hp_strdup (devname); + if (!asHpOpenFd[iCount].devname) return SANE_STATUS_NO_MEM; + DBG(3, "hp_AddOpenDevice: added device %s with fd=%d\n", devname, fd); + asHpOpenFd[iCount].connect = connect; + asHpOpenFd[iCount].fd = fd; + return SANE_STATUS_GOOD; + } + } + DBG(3, "hp_AddOpenDevice: %s not added\n", devname); + return SANE_STATUS_NO_MEM; +} + + +/* Check if we have remembered an open file descriptor */ +static SANE_Status +hp_IsOpenFd (int fd, HpConnect connect) + +{int iCount; + + for (iCount = 0; iCount < HP_MAX_OPEN_FD; iCount++) + { + if ( (asHpOpenFd[iCount].devname != NULL) + && (asHpOpenFd[iCount].fd == fd) + && (asHpOpenFd[iCount].connect == connect) ) + { + DBG(3, "hp_IsOpenFd: %d is open\n", fd); + return SANE_STATUS_GOOD; + } + } + DBG(3, "hp_IsOpenFd: %d not open\n", fd); + return SANE_STATUS_INVAL; +} + + +static SANE_Status +hp_RemoveOpenFd (int fd, HpConnect connect) + +{int iCount; + + for (iCount = 0; iCount < HP_MAX_OPEN_FD; iCount++) + { + if ( (asHpOpenFd[iCount].devname != NULL) + && (asHpOpenFd[iCount].fd == fd) + && (asHpOpenFd[iCount].connect == connect) ) + { + sanei_hp_free (asHpOpenFd[iCount].devname); + asHpOpenFd[iCount].devname = NULL; + DBG(3, "hp_RemoveOpenFd: removed %d\n", asHpOpenFd[iCount].fd); + asHpOpenFd[iCount].fd = -1; + return SANE_STATUS_GOOD; + } + } + DBG(3, "hp_RemoveOpenFd: %d not removed\n", fd); + return SANE_STATUS_INVAL; +} + + +static SANE_Status +hp_nonscsi_write (HpScsi this, hp_byte_t *data, size_t len, HpConnect connect) + +{int n = -1; + size_t loc_len; + SANE_Status status = SANE_STATUS_GOOD; + + if (len <= 0) return SANE_STATUS_GOOD; + + switch (connect) + { + case HP_CONNECT_DEVICE: /* direct device-io */ + n = write (this->fd, data, len); + break; + + case HP_CONNECT_PIO: /* Use sanepio interface */ + n = sanei_pio_write (this->fd, data, len); + break; + + case HP_CONNECT_USB: /* Not supported */ + loc_len = len; + status = sanei_usb_write_bulk ((SANE_Int)this->fd, data, &loc_len); + n = loc_len; + break; + + case HP_CONNECT_RESERVE: + n = -1; + break; + + default: + n = -1; + break; + } + + if (n == 0) return SANE_STATUS_EOF; + else if (n < 0) return SANE_STATUS_IO_ERROR; + + return status; +} + +static SANE_Status +hp_nonscsi_read (HpScsi this, hp_byte_t *data, size_t *len, HpConnect connect, + int UNUSEDARG isResponse) + +{int n = -1; + static int retries = -1; + size_t save_len = *len; + SANE_Status status = SANE_STATUS_GOOD; + + if (*len <= 0) return SANE_STATUS_GOOD; + + if (retries < 0) /* Read environment */ + {char *eptr = getenv ("SANE_HP_RDREDO"); + + retries = 1; /* Set default value */ + if (eptr != NULL) + { + if (sscanf (eptr, "%d", &retries) != 1) retries = 1; /* Restore default */ + else if (retries < 0) retries = 0; /* Allow no retries here */ + } + } + + for (;;) /* Retry on EOF */ + { + switch (connect) + { + case HP_CONNECT_DEVICE: + n = read (this->fd, data, *len); + break; + + case HP_CONNECT_PIO: + n = sanei_pio_read (this->fd, data, *len); + break; + + case HP_CONNECT_USB: + status = sanei_usb_read_bulk((SANE_Int)this->fd, (SANE_Byte *)data, len); + n = *len; + break; + + case HP_CONNECT_RESERVE: + n = -1; + break; + + default: + n = -1; + break; + } + if ((n != 0) || (retries <= 0)) break; + retries--; + usleep (100*1000); /* sleep 0.1 seconds */ + *len = save_len; /* Restore value */ + } + + if (n == 0) return SANE_STATUS_EOF; + else if (n < 0) return SANE_STATUS_IO_ERROR; + + *len = n; + return status; +} + +static SANE_Status +hp_nonscsi_open (const char *devname, int *fd, HpConnect connect) + +{int lfd, flags; + SANE_Int dn; + SANE_Status status = SANE_STATUS_INVAL; + +#ifdef _O_RDWR + flags = _O_RDWR; +#else + flags = O_RDWR; +#endif +#ifdef _O_EXCL + flags |= _O_EXCL; +#else + flags |= O_EXCL; +#endif +#ifdef _O_BINARY + flags |= _O_BINARY; +#endif +#ifdef O_BINARY + flags |= O_BINARY; +#endif + + switch (connect) + { + case HP_CONNECT_DEVICE: + lfd = open (devname, flags); + if (lfd < 0) + { + DBG(1, "hp_nonscsi_open: open device %s failed (%s)\n", devname, + strerror (errno) ); + status = (errno == EACCES) ? SANE_STATUS_ACCESS_DENIED : SANE_STATUS_INVAL; + } + else + status = SANE_STATUS_GOOD; + break; + + case HP_CONNECT_PIO: + status = sanei_pio_open (devname, &lfd); + break; + + case HP_CONNECT_USB: + DBG(17, "hp_nonscsi_open: open usb with \"%s\"\n", devname); + status = sanei_usb_open (devname, &dn); + lfd = (int)dn; + break; + + case HP_CONNECT_RESERVE: + status = SANE_STATUS_INVAL; + break; + + default: + status = SANE_STATUS_INVAL; + break; + } + + if (status != SANE_STATUS_GOOD) + { + DBG(1, "hp_nonscsi_open: open device %s failed\n", devname); + } + else + { + DBG(17,"hp_nonscsi_open: device %s opened, fd=%d\n", devname, lfd); + } + + if (fd) *fd = lfd; + + return status; +} + +static void +hp_nonscsi_close (int fd, HpConnect connect) + +{ + switch (connect) + { + case HP_CONNECT_DEVICE: + close (fd); + break; + + case HP_CONNECT_PIO: + sanei_pio_close (fd); + break; + + case HP_CONNECT_USB: + sanei_usb_close (fd); + break; + + case HP_CONNECT_RESERVE: + break; + + default: + break; + } + DBG(17,"hp_nonscsi_close: closed fd=%d\n", fd); +} + +SANE_Status +sanei_hp_nonscsi_new (HpScsi * newp, const char * devname, HpConnect connect) +{ + HpScsi new; + SANE_Status status; + int iAlreadyOpen = 0; + + new = sanei_hp_allocz(sizeof(*new)); + if (!new) + return SANE_STATUS_NO_MEM; + + /* Is the device already open ? */ + if ( hp_GetOpenDevice (devname, connect, &new->fd) == SANE_STATUS_GOOD ) + { + iAlreadyOpen = 1; + } + else + { + status = hp_nonscsi_open(devname, &new->fd, connect); + if (FAILED(status)) + { + DBG(1, "nonscsi_new: open failed (%s)\n", sane_strstatus(status)); + sanei_hp_free(new); + return SANE_STATUS_IO_ERROR; + } + } + + /* For SCSI-devices we would have the inquire command here */ + strncpy ((char *)new->inq_data, "\003zzzzzzzHP ------ R000", + sizeof (new->inq_data)); + + new->bufp = new->buf + HP_SCSI_CMD_LEN; + new->devname = sanei_hp_alloc ( strlen ( devname ) + 1 ); + if ( new->devname ) strcpy (new->devname, devname); + + *newp = new; + + /* Remember the open device */ + if (!iAlreadyOpen) hp_AddOpenDevice (devname, connect, new->fd); + + return SANE_STATUS_GOOD; +} + +static void +hp_scsi_close (HpScsi this, int completely) +{HpConnect connect; + + DBG(3, "scsi_close: closing fd %ld\n", (long)this->fd); + + connect = sanei_hp_scsi_get_connect (this); + + if (!completely) /* May we keep the device open ? */ + { + if ( hp_IsOpenFd (this->fd, connect) == SANE_STATUS_GOOD ) + { + DBG(3, "scsi_close: not closing. Keep open\n"); + return; + } + + } + assert(this->fd >= 0); + + if (connect != HP_CONNECT_SCSI) + hp_nonscsi_close (this->fd, connect); + else + sanei_scsi_close (this->fd); + + DBG(3,"scsi_close: really closed\n"); + + /* Remove a remembered open device */ + hp_RemoveOpenFd (this->fd, connect); +} + + +SANE_Status +sanei_hp_scsi_new (HpScsi * newp, const char * devname) +{ + static hp_byte_t inq_cmd[] = { 0x12, 0, 0, 0, HP_SCSI_INQ_LEN, 0}; + static hp_byte_t tur_cmd[] = { 0x00, 0, 0, 0, 0, 0}; + size_t inq_len = HP_SCSI_INQ_LEN; + HpScsi new; + HpConnect connect; + SANE_Status status; + int iAlreadyOpen = 0; + + connect = sanei_hp_get_connect (devname); + + if (connect != HP_CONNECT_SCSI) + return sanei_hp_nonscsi_new (newp, devname, connect); + + new = sanei_hp_allocz(sizeof(*new)); + if (!new) + return SANE_STATUS_NO_MEM; + + /* Is the device still open ? */ + if ( hp_GetOpenDevice (devname, connect, &new->fd) == SANE_STATUS_GOOD ) + { + iAlreadyOpen = 1; + } + else + { + status = sanei_scsi_open(devname, &new->fd, 0, 0); + if (FAILED(status)) + { + DBG(1, "scsi_new: open failed (%s)\n", sane_strstatus(status)); + sanei_hp_free(new); + return SANE_STATUS_IO_ERROR; + } + } + + DBG(3, "scsi_inquire: sending INQUIRE\n"); + status = sanei_scsi_cmd(new->fd, inq_cmd, 6, new->inq_data, &inq_len); + if (FAILED(status)) + { + DBG(1, "scsi_inquire: inquiry failed: %s\n", sane_strstatus(status)); + sanei_scsi_close(new->fd); + sanei_hp_free(new); + return status; + } + + {char vendor[9], model[17], rev[5]; + memset (vendor, 0, sizeof (vendor)); + memset (model, 0, sizeof (model)); + memset (rev, 0, sizeof (rev)); + memcpy (vendor, new->inq_data + 8, 8); + memcpy (model, new->inq_data + 16, 16); + memcpy (rev, new->inq_data + 32, 4); + + DBG(3, "vendor=%s, model=%s, rev=%s\n", vendor, model, rev); + } + + DBG(3, "scsi_new: sending TEST_UNIT_READY\n"); + status = sanei_scsi_cmd(new->fd, tur_cmd, 6, 0, 0); + if (FAILED(status)) + { + DBG(1, "hp_scsi_open: test unit ready failed (%s)\n", + sane_strstatus(status)); + usleep (500*1000); /* Wait 0.5 seconds */ + DBG(3, "scsi_new: sending TEST_UNIT_READY second time\n"); + status = sanei_scsi_cmd(new->fd, tur_cmd, 6, 0, 0); + } + + if (FAILED(status)) + { + DBG(1, "hp_scsi_open: test unit ready failed (%s)\n", + sane_strstatus(status)); + + sanei_scsi_close(new->fd); + sanei_hp_free(new); + return status; /* Fix problem with non-scanner devices */ + } + + new->bufp = new->buf + HP_SCSI_CMD_LEN; + new->devname = sanei_hp_alloc ( strlen ( devname ) + 1 ); + if ( new->devname ) strcpy (new->devname, devname); + + *newp = new; + + /* Remember the open device */ + if (!iAlreadyOpen) hp_AddOpenDevice (devname, connect, new->fd); + + return SANE_STATUS_GOOD; +} + + + +/* The "completely" parameter was added for OfficeJet support. + * For JetDirect connections, closing and re-opening the scan + * channel is very time consuming. Also, the OfficeJet G85 + * unloads a loaded document in the ADF when the scan channel + * gets closed. The solution is to "completely" destroy the + * connection, including closing and deallocating the PTAL + * channel, when initially probing the device in hp-device.c, + * but leave it open while the frontend is actually using the + * device (from hp-handle.c), and "completely" destroy it when + * the frontend closes its handle. */ +void +sanei_hp_scsi_destroy (HpScsi this,int completely) +{ + /* Moved to hp_scsi_close(): + * assert(this->fd >= 0); + * DBG(3, "scsi_close: closing fd %d\n", this->fd); + */ + + hp_scsi_close (this, completely); + if ( this->devname ) sanei_hp_free (this->devname); + sanei_hp_free(this); +} + +hp_byte_t * +sanei_hp_scsi_inq (HpScsi this) +{ + return this->inq_data; +} + +const char * +sanei_hp_scsi_vendor (HpScsi this) +{ + static char buf[9]; + memcpy(buf, sanei_hp_scsi_inq(this) + 8, 8); + buf[8] = '\0'; + return buf; +} + +const char * +sanei_hp_scsi_model (HpScsi this) +{ + + static char buf[17]; + memcpy(buf, sanei_hp_scsi_inq(this) + 16, 16); + buf[16] = '\0'; + return buf; +} + +const char * +sanei_hp_scsi_devicename (HpScsi this) +{ + return this->devname; +} + +hp_bool_t +sanei_hp_is_active_xpa (HpScsi scsi) +{HpDeviceInfo *info; + int model_num; + + info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) ); + if (info->active_xpa < 0) + { + model_num = sanei_hp_get_max_model (scsi); + info->active_xpa = (model_num >= 17); + DBG(5,"sanei_hp_is_active_xpa: model=%d, active_xpa=%d\n", + model_num, info->active_xpa); + } + return info->active_xpa; +} + +int +sanei_hp_get_max_model (HpScsi scsi) + +{HpDeviceInfo *info; + + info = sanei_hp_device_info_get ( sanei_hp_scsi_devicename (scsi) ); + if (info->max_model < 0) + {enum hp_device_compat_e compat; + int model_num; + + if ( sanei_hp_device_probe_model ( &compat, scsi, &model_num, 0) + == SANE_STATUS_GOOD ) + info->max_model = model_num; + } + return info->max_model; +} + + +int +sanei_hp_is_flatbed_adf (HpScsi scsi) + +{int model = sanei_hp_get_max_model (scsi); + + return ((model == 2) || (model == 4) || (model == 5) || (model == 8)); +} + + +HpConnect +sanei_hp_get_connect (const char *devname) + +{const HpDeviceInfo *info; + HpConnect connect = HP_CONNECT_SCSI; + int got_connect_type = 0; + + info = sanei_hp_device_info_get (devname); + if (!info) + { + DBG(1, "sanei_hp_get_connect: Could not get info for %s. Assume SCSI\n", + devname); + connect = HP_CONNECT_SCSI; + } + else + if ( !(info->config_is_up) ) + { + DBG(1, "sanei_hp_get_connect: Config not initialized for %s. Assume SCSI\n", + devname); + connect = HP_CONNECT_SCSI; + } + else + { + connect = info->config.connect; + got_connect_type = info->config.got_connect_type; + } + + /* Beware of using a USB-device as a SCSI-device (not 100% perfect) */ + if ((connect == HP_CONNECT_SCSI) && !got_connect_type) + {int maybe_usb; + + maybe_usb = ( strstr (devname, "usb") + || strstr (devname, "uscanner") + || strstr (devname, "ugen")); + if (maybe_usb) + {static int print_warning = 1; + + if (print_warning) + { + print_warning = 0; + DBG(1,"sanei_hp_get_connect: WARNING\n"); + DBG(1," Device %s assumed to be SCSI, but device name\n",devname); + DBG(1," looks like USB. Will continue with USB.\n"); + DBG(1," If you really want it as SCSI, add the following\n"); + DBG(1," to your file .../etc/sane.d/hp.conf:\n"); + DBG(1," %s\n", devname); + DBG(1," option connect-scsi\n"); + DBG(1," The same warning applies to other device names containing\n"); + DBG(1," \"usb\", \"uscanner\" or \"ugen\".\n"); + } + connect = HP_CONNECT_DEVICE; + } + } + return connect; +} + +HpConnect +sanei_hp_scsi_get_connect (HpScsi this) + +{ + return sanei_hp_get_connect (sanei_hp_scsi_devicename (this)); +} + + +static SANE_Status +hp_scsi_flush (HpScsi this) +{ + hp_byte_t * data = this->buf + HP_SCSI_CMD_LEN; + size_t len = this->bufp - data; + HpConnect connect; + + assert(len < HP_SCSI_MAX_WRITE); + if (len == 0) + return SANE_STATUS_GOOD; + + this->bufp = this->buf; + + DBG(16, "scsi_flush: writing %lu bytes:\n", (unsigned long) len); + DBGDUMP(16, data, len); + + *this->bufp++ = 0x0A; + *this->bufp++ = 0; + *this->bufp++ = len >> 16; + *this->bufp++ = len >> 8; + *this->bufp++ = len; + *this->bufp++ = 0; + + connect = sanei_hp_scsi_get_connect (this); + if (connect == HP_CONNECT_SCSI) + return sanei_scsi_cmd (this->fd, this->buf, HP_SCSI_CMD_LEN + len, 0, 0); + else + return hp_nonscsi_write (this, this->buf+HP_SCSI_CMD_LEN, len, connect); +} + +static size_t +hp_scsi_room (HpScsi this) +{ + return this->buf + HP_SCSI_BUFSIZ - this->bufp; +} + +static SANE_Status +hp_scsi_need (HpScsi this, size_t need) +{ + assert(need < HP_SCSI_MAX_WRITE); + + if (need > hp_scsi_room(this)) + RETURN_IF_FAIL( hp_scsi_flush(this) ); + + return SANE_STATUS_GOOD; +} + +static SANE_Status +hp_scsi_write (HpScsi this, const void *data, size_t len) +{ + if ( len < HP_SCSI_MAX_WRITE ) + { + RETURN_IF_FAIL( hp_scsi_need(this, len) ); + memcpy(this->bufp, data, len); + this->bufp += len; + } + else + {size_t maxwrite = HP_SCSI_MAX_WRITE - 16; + const char *c_data = (const char *)data; + + while ( len > 0 ) + { + if ( maxwrite > len ) maxwrite = len; + RETURN_IF_FAIL( hp_scsi_write(this, c_data, maxwrite) ); + c_data += maxwrite; + len -= maxwrite; + } + } + return SANE_STATUS_GOOD; +} + +static SANE_Status +hp_scsi_scl(HpScsi this, HpScl scl, int val) +{ + char group = tolower(SCL_GROUP_CHAR(scl)); + char param = toupper(SCL_PARAM_CHAR(scl)); + int count; + + assert(IS_SCL_CONTROL(scl) || IS_SCL_COMMAND(scl)); + assert(isprint(group) && isprint(param)); + + RETURN_IF_FAIL( hp_scsi_need(this, 10) ); + + /* Dont try to optimize SCL-commands like using <ESC>*a1b0c5T */ + /* Some scanners have problems with it (e.g. HP Photosmart Photoscanner */ + /* with window position/extent, resolution) */ + count = sprintf((char *)this->bufp, "\033*%c%d%c", group, val, param); + this->bufp += count; + + assert(count > 0 && this->bufp < this->buf + HP_SCSI_BUFSIZ); + + return hp_scsi_flush(this); +} + +/* Read it bytewise */ +static SANE_Status +hp_scsi_read_slow (HpScsi this, void * dest, size_t *len) +{static hp_byte_t read_cmd[6] = { 0x08, 0, 0, 0, 0, 0 }; + size_t leftover = *len; + SANE_Status status = SANE_STATUS_GOOD; + unsigned char *start_dest = (unsigned char *)dest; + unsigned char *next_dest = start_dest; + + DBG(16, "hp_scsi_read_slow: Start reading %d bytes bytewise\n", (int)*len); + + while (leftover > 0) /* Until we got all the bytes */ + {size_t one = 1; + + read_cmd[2] = 0; + read_cmd[3] = 0; + read_cmd[4] = 1; /* Read one byte */ + + status = sanei_scsi_cmd (this->fd, read_cmd, sizeof(read_cmd), + next_dest, &one); + if ((status != SANE_STATUS_GOOD) || (one != 1)) + { + DBG(250,"hp_scsi_read_slow: Reading byte %d: status=%s, len=%d\n", + (int)(next_dest-start_dest), sane_strstatus(status), (int)one); + } + + if (status != SANE_STATUS_GOOD) break; /* Finish on error */ + + next_dest++; + leftover--; + } + + *len = next_dest-start_dest; /* This is the number of bytes we got */ + + DBG(16, "hp_scsi_read_slow: Got %d bytes\n", (int)*len); + + if ((status != SANE_STATUS_GOOD) && (*len > 0)) + { + DBG(16, "We got some data. Ignore the error \"%s\"\n", + sane_strstatus(status)); + status = SANE_STATUS_GOOD; + } + return status; +} + +/* The OfficeJets tend to return inquiry responses containing array + * data in two packets. The added "isResponse" parameter tells + * whether we should keep reading until we get + * a well-formed response. Naturally, this parameter would be zero + * when reading scan data. */ +static SANE_Status +hp_scsi_read (HpScsi this, void * dest, size_t *len, int isResponse) +{ + HpConnect connect; + + RETURN_IF_FAIL( hp_scsi_flush(this) ); + + connect = sanei_hp_scsi_get_connect (this); + if (connect == HP_CONNECT_SCSI) + {int read_bytewise = 0; + + if (*len <= 32) /* Is it a candidate for reading bytewise ? */ + {const HpDeviceInfo *info; + + info = sanei_hp_device_info_get (sanei_hp_scsi_devicename (this)); + if ((info != NULL) && (info->config_is_up) && info->config.dumb_read) + read_bytewise = 1; + } + + if ( ! read_bytewise ) + {static hp_byte_t read_cmd[6] = { 0x08, 0, 0, 0, 0, 0 }; + read_cmd[2] = *len >> 16; + read_cmd[3] = *len >> 8; + read_cmd[4] = *len; + + RETURN_IF_FAIL( sanei_scsi_cmd (this->fd, read_cmd, + sizeof(read_cmd), dest, len) ); + } + else + { + RETURN_IF_FAIL (hp_scsi_read_slow (this, dest, len)); + } + } + else + { + RETURN_IF_FAIL( hp_nonscsi_read (this, dest, len, connect, isResponse) ); + } + DBG(16, "scsi_read: %lu bytes:\n", (unsigned long) *len); + DBGDUMP(16, dest, *len); + return SANE_STATUS_GOOD; +} + + +static int signal_caught = 0; + +static RETSIGTYPE +signal_catcher (int sig) +{ + DBG(1,"signal_catcher(sig=%d): old signal_caught=%d\n",sig,signal_caught); + if (!signal_caught) + signal_caught = sig; +} + +static void +hp_data_map (register const unsigned char *map, register int count, + register unsigned char *data) +{ + if (count <= 0) return; + while (count--) + { + *data = map[*data]; + data++; + } +} + +static const unsigned char * +hp_get_simulation_map (const char *devname, const HpDeviceInfo *info) +{ + hp_bool_t sim_gamma, sim_brightness, sim_contrast; + int k, ind; + const unsigned char *map = NULL; + static unsigned char map8x8[256]; + + sim_gamma = info->simulate.gamma_simulate; + sim_brightness = sanei_hp_device_simulate_get (devname, SCL_BRIGHTNESS); + sim_contrast = sanei_hp_device_simulate_get (devname, SCL_CONTRAST); + + if ( sim_gamma ) + { + map = &(info->simulate.gamma_map[0]); + } + else if ( sim_brightness && sim_contrast ) + { + for (k = 0; k < 256; k++) + { + ind = info->simulate.contrast_map[k]; + map8x8[k] = info->simulate.brightness_map[ind]; + } + map = &(map8x8[0]); + } + else if ( sim_brightness ) + map = &(info->simulate.brightness_map[0]); + else if ( sim_contrast ) + map = &(info->simulate.contrast_map[0]); + + return map; +} + + +/* Check the native byte order on the local machine */ +static hp_bool_t +is_lowbyte_first_byteorder (void) + +{unsigned short testvar = 1; + unsigned char *testptr = (unsigned char *)&testvar; + + if (sizeof (unsigned short) == 2) + return (testptr[0] == 1); + else if (sizeof (unsigned short) == 4) + return ((testptr[0] == 1) || (testptr[2] == 1)); + else + return ( (testptr[0] == 1) || (testptr[2] == 1) + || (testptr[4] == 1) || (testptr[6] == 1)); +} + +/* The SANE standard defines that 2-byte data must use the full 16 bit range. + * Byte order returned by the backend must be native byte order. + * Scaling to 16 bit and byte order is achived by hp_scale_to_16bit. + * for >8 bits data, take the two data bytes and scale their content + * to the full 16 bit range, using + * scaled = unscaled << (newlen - oldlen) + + * unscaled >> (oldlen - (newlen - oldlen)), + * with newlen=16 and oldlen the original bit depth. + */ +static void +hp_scale_to_16bit(int count, register unsigned char *data, int depth, + hp_bool_t invert) +{ + register unsigned int tmp; + register unsigned int mask; + register hp_bool_t lowbyte_first = is_lowbyte_first_byteorder (); + unsigned int shift1 = 16 - depth; + unsigned int shift2 = 2*depth - 16; + int k; + + if (count <= 0) return; + + mask = 1; + for (k = 1; k < depth; k++) mask |= (1 << k); + + if (lowbyte_first) + { + while (count--) { + tmp = ((((unsigned int)data[0])<<8) | ((unsigned int)data[1])) & mask; + tmp = (tmp << shift1) + (tmp >> shift2); + if (invert) tmp = ~tmp; + *data++ = tmp & 255U; + *data++ = (tmp >> 8) & 255U; + } + } + else /* Highbyte first */ + { + while (count--) { + tmp = ((((unsigned int)data[0])<<8) | ((unsigned int)data[1])) & mask; + tmp = (tmp << shift1) + (tmp >> shift2); + if (invert) tmp = ~tmp; + *data++ = (tmp >> 8) & 255U; + *data++ = tmp & 255U; + } + } +} + + +static void +hp_scale_to_8bit(int count, register unsigned char *data, int depth, + hp_bool_t invert) +{ + register unsigned int tmp, mask; + register hp_bool_t lowbyte_first = is_lowbyte_first_byteorder (); + unsigned int shift1 = depth-8; + int k; + unsigned char *dataout = data; + + if ((count <= 0) || (shift1 <= 0)) return; + + mask = 1; + for (k = 1; k < depth; k++) mask |= (1 << k); + + if (lowbyte_first) + { + while (count--) { + tmp = ((((unsigned int)data[0])<<8) | ((unsigned int)data[1])) & mask; + tmp >>= shift1; + if (invert) tmp = ~tmp; + *(dataout++) = tmp & 255U; + data += 2; + } + } + else /* Highbyte first */ + { + while (count--) { + tmp = ((((unsigned int)data[0])<<8) | ((unsigned int)data[1])) & mask; + tmp >>= shift1; + if (invert) tmp = ~tmp; + *(dataout++) = tmp & 255U; + data += 2; + } + } +} + +static void +hp_soft_invert(int count, register unsigned char *data) { + while (count>0) { + *data = ~(*data); + data++; + count--; + } +} + +static PROCDATA_HANDLE * +process_data_init (HpProcessData *procdata, const unsigned char *map, + int outfd, hp_bool_t use_imgbuf) + +{PROCDATA_HANDLE *ph = sanei_hp_alloc (sizeof (PROCDATA_HANDLE)); + int tsz; + + if (ph == NULL) return NULL; + + memset (ph, 0, sizeof (*ph)); + memcpy (&(ph->procdata), procdata, sizeof (*procdata)); + procdata = &(ph->procdata); + + tsz = (HP_TMP_BUF_SIZE <= 0) ? procdata->bytes_per_line : HP_TMP_BUF_SIZE; + ph->tmp_buf = sanei_hp_alloc (tsz); + if (ph->tmp_buf == NULL) + { + sanei_hp_free (ph); + return NULL; + } + ph->tmp_buf_size = tsz; + ph->tmp_buf_len = 0; + + ph->map = map; + ph->outfd = outfd; + + if ( procdata->mirror_vertical || use_imgbuf) + { + tsz = procdata->lines*procdata->bytes_per_line; + if (procdata->out8) tsz /= 2; + ph->image_ptr = ph->image_buf = sanei_hp_alloc (tsz); + if ( !ph->image_buf ) + { + procdata->mirror_vertical = 0; + ph->image_buf_size = 0; + DBG(1, "process_scanline_init: Not enough memory to mirror image\n"); + } + else + ph->image_buf_size = tsz; + } + + ph->wr_ptr = ph->wr_buf; + ph->wr_buf_size = ph->wr_left = sizeof (ph->wr_buf); + + return ph; +} + + +static SANE_Status +process_data_write (PROCDATA_HANDLE *ph, unsigned char *data, int nbytes) + +{int ncopy; + + if (ph == NULL) return SANE_STATUS_INVAL; + + /* Fill up write buffer */ + ncopy = ph->wr_left; + if (ncopy > nbytes) ncopy = nbytes; + + memcpy (ph->wr_ptr, data, ncopy); + ph->wr_ptr += ncopy; + ph->wr_left -= ncopy; + data += ncopy; + nbytes -= ncopy; + + if ( ph->wr_left > 0 ) /* Did not fill up the write buffer ? Finished */ + return SANE_STATUS_GOOD; + + DBG(12, "process_data_write: write %d bytes\n", ph->wr_buf_size); + /* Don't write data if we got a signal in the meantime */ + if ( signal_caught + || (write (ph->outfd, ph->wr_buf, ph->wr_buf_size) != ph->wr_buf_size)) + { + DBG(1, "process_data_write: write failed: %s\n", + signal_caught ? "signal caught" : strerror(errno)); + return SANE_STATUS_IO_ERROR; + } + ph->wr_ptr = ph->wr_buf; + ph->wr_left = ph->wr_buf_size; + + /* For large amount of data write it from data-buffer */ + while ( nbytes > ph->wr_buf_size ) + { + if ( signal_caught + || (write (ph->outfd, data, ph->wr_buf_size) != ph->wr_buf_size)) + { + DBG(1, "process_data_write: write failed: %s\n", + signal_caught ? "signal caught" : strerror(errno)); + return SANE_STATUS_IO_ERROR; + } + nbytes -= ph->wr_buf_size; + data += ph->wr_buf_size; + } + + if ( nbytes > 0 ) /* Something left ? Save it to (empty) write buffer */ + { + memcpy (ph->wr_ptr, data, nbytes); + ph->wr_ptr += nbytes; + ph->wr_left -= nbytes; + } + return SANE_STATUS_GOOD; +} + +static SANE_Status +process_scanline (PROCDATA_HANDLE *ph, unsigned char *linebuf, + int bytes_per_line) + +{int out_bytes_per_line = bytes_per_line; + HpProcessData *procdata; + + if (ph == NULL) return SANE_STATUS_INVAL; + procdata = &(ph->procdata); + + if ( ph->map ) + hp_data_map (ph->map, bytes_per_line, linebuf); + + if (procdata->bits_per_channel > 8) + { + if (procdata->out8) + { + hp_scale_to_8bit( bytes_per_line/2, linebuf, + procdata->bits_per_channel, + procdata->invert); + out_bytes_per_line /= 2; + } + else + { + hp_scale_to_16bit( bytes_per_line/2, linebuf, + procdata->bits_per_channel, + procdata->invert); + } + } else if (procdata->invert) { + hp_soft_invert(bytes_per_line,linebuf); + } + + if ( ph->image_buf ) + { + DBG(5, "process_scanline: save in memory\n"); + + if ( ph->image_ptr+out_bytes_per_line-1 + <= ph->image_buf+ph->image_buf_size-1 ) + { + memcpy(ph->image_ptr, linebuf, out_bytes_per_line); + ph->image_ptr += out_bytes_per_line; + } + else + { + DBG(1, "process_scanline: would exceed image buffer\n"); + } + } + else /* Save scanlines in a bigger buffer. */ + { /* Otherwise we will get performance problems */ + + RETURN_IF_FAIL ( process_data_write (ph, linebuf, out_bytes_per_line) ); + } + return SANE_STATUS_GOOD; +} + + +static SANE_Status +process_data (PROCDATA_HANDLE *ph, unsigned char *read_ptr, int nread) + +{int bytes_left; + HpProcessData *procdata; + + if (nread <= 0) return SANE_STATUS_GOOD; + + if (ph == NULL) return SANE_STATUS_INVAL; + + procdata = &(ph->procdata); + if ( ph->tmp_buf_len > 0 ) /* Something left ? */ + { + bytes_left = ph->tmp_buf_size - ph->tmp_buf_len; + if (nread < bytes_left) /* All to buffer ? */ + { + memcpy (ph->tmp_buf+ph->tmp_buf_len, read_ptr, nread); + ph->tmp_buf_len += nread; + return SANE_STATUS_GOOD; + } + memcpy (ph->tmp_buf+ph->tmp_buf_len, read_ptr, bytes_left); + read_ptr += bytes_left; + nread -= bytes_left; + RETURN_IF_FAIL ( process_scanline (ph, ph->tmp_buf, ph->tmp_buf_size) ); + ph->tmp_buf_len = 0; + } + while (nread > 0) + { + if (nread >= ph->tmp_buf_size) + { + RETURN_IF_FAIL ( process_scanline (ph, read_ptr, ph->tmp_buf_size) ); + read_ptr += ph->tmp_buf_size; + nread -= ph->tmp_buf_size; + } + else + { + memcpy (ph->tmp_buf, read_ptr, nread); + ph->tmp_buf_len = nread; + nread = 0; + } + } + return SANE_STATUS_GOOD; +} + + +static SANE_Status +process_data_flush (PROCDATA_HANDLE *ph) + +{SANE_Status status = SANE_STATUS_GOOD; + HpProcessData *procdata; + unsigned char *image_data; + size_t image_len; + int num_lines, bytes_per_line; + int nbytes; + + if (ph == NULL) return SANE_STATUS_INVAL; + + if ( ph->tmp_buf_len > 0 ) + process_scanline (ph, ph->tmp_buf, ph->tmp_buf_len); + + if ( ph->wr_left != ph->wr_buf_size ) /* Something in write buffer ? */ + { + nbytes = ph->wr_buf_size - ph->wr_left; + if ( signal_caught || (write (ph->outfd, ph->wr_buf, nbytes) != nbytes)) + { + DBG(1, "process_data_flush: write failed: %s\n", + signal_caught ? "signal caught" : strerror(errno)); + return SANE_STATUS_IO_ERROR; + } + ph->wr_ptr = ph->wr_buf; + ph->wr_left = ph->wr_buf_size; + } + + procdata = &(ph->procdata); + if ( ph->image_buf ) + { + bytes_per_line = procdata->bytes_per_line; + if (procdata->out8) bytes_per_line /= 2; + image_len = (size_t) (ph->image_ptr - ph->image_buf); + num_lines = ((int)(image_len + bytes_per_line-1)) / bytes_per_line; + + DBG(3, "process_data_finish: write %d bytes from memory...\n", + (int)image_len); + + if ( procdata->mirror_vertical ) + { + image_data = ph->image_buf + (num_lines-1) * bytes_per_line; + while (num_lines > 0 ) + { + if ( signal_caught + || (write(ph->outfd, image_data, bytes_per_line) != bytes_per_line)) + { + DBG(1,"process_data_finish: write from memory failed: %s\n", + signal_caught ? "signal caught" : strerror(errno)); + status = SANE_STATUS_IO_ERROR; + break; + } + num_lines--; + image_data -= bytes_per_line; + } + } + else + { + image_data = ph->image_buf; + while (num_lines > 0 ) + { + if ( signal_caught + || (write(ph->outfd, image_data, bytes_per_line) != bytes_per_line)) + { + DBG(1,"process_data_finish: write from memory failed: %s\n", + signal_caught ? "signal caught" : strerror(errno)); + status = SANE_STATUS_IO_ERROR; + break; + } + num_lines--; + image_data += bytes_per_line; + } + } + } + return status; +} + + +static void +process_data_finish (PROCDATA_HANDLE *ph) + +{ + DBG(12, "process_data_finish called\n"); + + if (ph == NULL) return; + + if (ph->image_buf != NULL) sanei_hp_free (ph->image_buf); + + sanei_hp_free (ph->tmp_buf); + sanei_hp_free (ph); +} + + +SANE_Status +sanei_hp_scsi_pipeout (HpScsi this, int outfd, HpProcessData *procdata) +{ + /* We will catch these signals, and rethrow them after cleaning up, + * anything not in this list, we will ignore. */ + static int kill_sig[] = { + SIGHUP, SIGINT, SIGQUIT, SIGILL, SIGPIPE, SIGALRM, SIGTERM, + SIGUSR1, SIGUSR2, SIGBUS, +#ifdef SIGSTKFLT + SIGSTKFLT, +#endif +#ifdef SIGIO + SIGIO, +#else +# ifdef SIGPOLL + SIGPOLL, +# endif +#endif +#ifdef SIGXCPU + SIGXCPU, +#endif +#ifdef SIGXFSZ + SIGXFSZ, +#endif +#ifdef SIGVTALRM + SIGVTALRM, +#endif +#ifdef SIGPWR + SIGPWR, +#endif + }; +#define HP_NSIGS (sizeof(kill_sig)/sizeof(kill_sig[0])) + struct SIGACTION old_handler[HP_NSIGS]; + struct SIGACTION sa; + sigset_t old_set, sig_set; + int i; + int bits_per_channel = procdata->bits_per_channel; + +#define HP_PIPEBUF 32768 + SANE_Status status = SANE_STATUS_GOOD; + struct { + size_t len; + void * id; + hp_byte_t cmd[6]; + hp_byte_t data[HP_PIPEBUF]; + } buf[2], *req = NULL; + + int reqs_completed = 0; + int reqs_issued = 0; + char *image_buf = 0; + char *read_buf = 0; + const HpDeviceInfo *info; + const char *devname = sanei_hp_scsi_devicename (this); + int enable_requests = 1; + int enable_image_buffering = 0; + const unsigned char *map = NULL; + HpConnect connect; + PROCDATA_HANDLE *ph = NULL; + size_t count = procdata->lines * procdata->bytes_per_line; + + RETURN_IF_FAIL( hp_scsi_flush(this) ); + + connect = sanei_hp_get_connect (devname); + info = sanei_hp_device_info_get (devname); + + assert (info); + + if ( info->config_is_up ) + { + enable_requests = info->config.use_scsi_request; + enable_image_buffering = info->config.use_image_buffering; + } + else + { + enable_requests = 0; + } + + if (connect != HP_CONNECT_SCSI) + enable_requests = 0; + + /* Currently we can only simulate 8 bits mapping */ + if (bits_per_channel == 8) + map = hp_get_simulation_map (devname, info); + + sigfillset(&sig_set); + sigprocmask(SIG_BLOCK, &sig_set, &old_set); + + memset(&sa, 0, sizeof(sa)); + sa.sa_handler = signal_catcher; + sigfillset(&sa.sa_mask); + + sigemptyset(&sig_set); + for (i = 0; i < (int)(HP_NSIGS); i++) + { + sigaction(kill_sig[i], &sa, &old_handler[i]); + sigaddset(&sig_set, kill_sig[i]); + } + signal_caught = 0; + sigprocmask(SIG_UNBLOCK, &sig_set, 0); + + /* Wait for front button push ? */ + if ( procdata->startscan ) + { + for (;;) + {int val = 0; + + if (signal_caught) goto quit; + sanei_hp_scl_inquire (this, SCL_FRONT_BUTTON, &val, 0, 0); + if (val) break; + usleep ((unsigned long)333*1000); /* Wait 1/3 second */ + } + status = sanei_hp_scl_startScan (this, procdata->startscan); + if (status != SANE_STATUS_GOOD ) + { + DBG(1, "do_read: Error starting scan in reader process\n"); + goto quit; + } + } + ph = process_data_init (procdata, map, outfd, enable_image_buffering); + + if ( ph == NULL ) + { + DBG(1, "do_read: Error with process_data_init()\n"); + goto quit; + } + + DBG(1, "do_read: Start reading data from scanner\n"); + + if (enable_requests) /* Issue SCSI-requests ? */ + { + while (count > 0 || reqs_completed < reqs_issued) + { + while (count > 0 && reqs_issued < reqs_completed + 2) + { + req = buf + (reqs_issued++ % 2); + + req->len = HP_PIPEBUF; + if (count < req->len) + req->len = count; + count -= req->len; + + req->cmd[0] = 0x08; + req->cmd[1] = 0; + req->cmd[2] = req->len >> 16; + req->cmd[3] = req->len >> 8; + req->cmd[4] = req->len; + req->cmd[5] = 0; + + DBG(3, "do_read: entering request to read %lu bytes\n", + (unsigned long) req->len); + + status = sanei_scsi_req_enter(this->fd, req->cmd, 6, + req->data, &req->len, &req->id); + if (status != SANE_STATUS_GOOD) + { + DBG(1, "do_read: Error from scsi_req_enter: %s\n", + sane_strstatus(status)); + goto quit; + } + if (signal_caught) + goto quit; + } + + if (signal_caught) + goto quit; + + assert(reqs_completed < reqs_issued); + req = buf + (reqs_completed++ % 2); + + DBG(3, "do_read: waiting for data\n"); + status = sanei_scsi_req_wait(req->id); + if (status != SANE_STATUS_GOOD) + { + DBG(1, "do_read: Error from scsi_req_wait: %s\n", + sane_strstatus(status)); + goto quit; + } + if (signal_caught) + goto quit; + + status = process_data (ph, (unsigned char *)req->data, (int)req->len); + if ( status != SANE_STATUS_GOOD ) + { + DBG(1,"do_read: Error in process_data\n"); + goto quit; + } + } + } + else /* Read directly */ + { + read_buf = sanei_hp_alloc ( HP_PIPEBUF ); + if (!read_buf) + { + DBG(1, "do_read: not enough memory for read buffer\n"); + goto quit; + } + + while (count > 0) + {size_t nread; + + if (signal_caught) + goto quit; + + DBG(5, "do_read: %lu bytes left to read\n", (unsigned long)count); + + nread = HP_PIPEBUF; + if (nread > count) nread = count; + + DBG(3, "do_read: try to read data (%lu bytes)\n", (unsigned long)nread); + + status = hp_scsi_read (this, read_buf, &nread, 0); + if (status != SANE_STATUS_GOOD) + { + DBG(1, "do_read: Error from scsi_read: %s\n",sane_strstatus(status)); + goto quit; + } + + DBG(3, "do_read: got %lu bytes\n", (unsigned long)nread); + + if (nread <= 0) + { + DBG(1, "do_read: Nothing read\n"); + continue; + } + + status = process_data (ph, (unsigned char *)read_buf, (int)nread); + if ( status != SANE_STATUS_GOOD ) + { + DBG(1,"do_read: Error in process_data\n"); + goto quit; + } + count -= nread; + } + } + + process_data_flush (ph); + +quit: + + process_data_finish (ph); + + if ( image_buf ) sanei_hp_free ( image_buf ); + if ( read_buf ) sanei_hp_free ( read_buf ); + + if (enable_requests && (reqs_completed < reqs_issued)) + { + DBG(1, "do_read: cleaning up leftover requests\n"); + while (reqs_completed < reqs_issued) + { + req = buf + (reqs_completed++ % 2); + sanei_scsi_req_wait(req->id); + } + } + + sigfillset(&sig_set); + sigprocmask(SIG_BLOCK, &sig_set, 0); + for (i = 0; i < (int)(HP_NSIGS); i++) + sigaction(kill_sig[i], &old_handler[i], 0); + sigprocmask(SIG_SETMASK, &old_set, 0); + + if (signal_caught) + { + DBG(1, "do_read: caught signal %d\n", signal_caught); + raise(signal_caught); + return SANE_STATUS_CANCELLED; + } + + return status; +} + + + +/* + * + */ + +static SANE_Status +_hp_scl_inq (HpScsi scsi, HpScl scl, HpScl inq_cmnd, + void *valp, size_t *lengthp) +{ + size_t bufsize = 16 + (lengthp ? *lengthp: 0); + char * buf = alloca(bufsize); + char expect[16], expect_char; + int val, count; + SANE_Status status; + + if (!buf) + return SANE_STATUS_NO_MEM; + + /* Flush data before sending inquiry. */ + /* Otherwise scanner might not generate a response. */ + RETURN_IF_FAIL( hp_scsi_flush (scsi)) ; + + RETURN_IF_FAIL( hp_scsi_scl(scsi, inq_cmnd, SCL_INQ_ID(scl)) ); + usleep (1000); /* 500 works, too, but not 100 */ + + status = hp_scsi_read(scsi, buf, &bufsize, 1); + if (FAILED(status)) + { + DBG(1, "scl_inq: read failed (%s)\n", sane_strstatus(status)); + return status; + } + + if (SCL_PARAM_CHAR(inq_cmnd) == 'R') + expect_char = 'p'; + else + expect_char = tolower(SCL_PARAM_CHAR(inq_cmnd) - 1); + + count = sprintf(expect, "\033*s%d%c", SCL_INQ_ID(scl), expect_char); + if (memcmp(buf, expect, count) != 0) + { + DBG(1, "scl_inq: malformed response: expected '%s', got '%.*s'\n", + expect, count, buf); + return SANE_STATUS_IO_ERROR; + } + buf += count; + + if (buf[0] == 'N') + { /* null response */ + DBG(3, "scl_inq: parameter %d unsupported\n", SCL_INQ_ID(scl)); + return SANE_STATUS_UNSUPPORTED; + } + + if (sscanf(buf, "%d%n", &val, &count) != 1) + { + DBG(1, "scl_inq: malformed response: expected int, got '%.8s'\n", buf); + return SANE_STATUS_IO_ERROR; + } + buf += count; + + expect_char = lengthp ? 'W' : 'V'; + if (*buf++ != expect_char) + { + DBG(1, "scl_inq: malformed response: expected '%c', got '%.4s'\n", + expect_char, buf - 1); + return SANE_STATUS_IO_ERROR; + } + + if (!lengthp) + *(int *)valp = val; /* Get integer value */ + else + { + if (val > (int)*lengthp) + { + DBG(1, "scl_inq: inquiry returned %d bytes, expected <= %lu\n", + val, (unsigned long) *lengthp); + return SANE_STATUS_IO_ERROR; + } + *lengthp = val; + memcpy(valp, buf , *lengthp); /* Get binary data */ + } + + return SANE_STATUS_GOOD; +} + + +SANE_Status +sanei_hp_scl_upload_binary (HpScsi scsi, HpScl scl, size_t *lengthhp, + char **bufhp) +{ + size_t bufsize = 16, sv; + char * buf = alloca(bufsize); + char * bufstart = buf; + char * hpdata; + char expect[16], expect_char; + int n, val, count; + SANE_Status status; + + if (!buf) + return SANE_STATUS_NO_MEM; + + assert ( IS_SCL_DATA_TYPE (scl) ); + + /* Flush data before sending inquiry. */ + /* Otherwise scanner might not generate a response. */ + RETURN_IF_FAIL( hp_scsi_flush (scsi)) ; + + RETURN_IF_FAIL( hp_scsi_scl(scsi, SCL_UPLOAD_BINARY_DATA, SCL_INQ_ID(scl)) ); + + status = hp_scsi_read(scsi, buf, &bufsize, 0); + if (FAILED(status)) + { + DBG(1, "scl_upload_binary: read failed (%s)\n", sane_strstatus(status)); + return status; + } + + expect_char = 't'; + count = sprintf(expect, "\033*s%d%c", SCL_INQ_ID(scl), expect_char); + if (memcmp(buf, expect, count) != 0) + { + DBG(1, "scl_upload_binary: malformed response: expected '%s', got '%.*s'\n", + expect, count, buf); + return SANE_STATUS_IO_ERROR; + } + buf += count; + + if (buf[0] == 'N') + { /* null response */ + DBG(1, "scl_upload_binary: parameter %d unsupported\n", SCL_INQ_ID(scl)); + return SANE_STATUS_UNSUPPORTED; + } + + if (sscanf(buf, "%d%n", &val, &count) != 1) + { + DBG(1, "scl_inq: malformed response: expected int, got '%.8s'\n", buf); + return SANE_STATUS_IO_ERROR; + } + buf += count; + + expect_char = 'W'; + if (*buf++ != expect_char) + { + DBG(1, "scl_inq: malformed response: expected '%c', got '%.4s'\n", + expect_char, buf - 1); + return SANE_STATUS_IO_ERROR; + } + + *lengthhp = val; + *bufhp = hpdata = sanei_hp_alloc ( val ); + if (!hpdata) + return SANE_STATUS_NO_MEM; + + if (buf < bufstart + bufsize) + { + n = bufsize - (buf - bufstart); + if (n > val) n = val; + memcpy (hpdata, buf, n); + hpdata += n; + val -= n; + } + + status = SANE_STATUS_GOOD; + if ( val > 0 ) + { + sv = val; + status = hp_scsi_read(scsi, hpdata, &sv, 0); + if (status != SANE_STATUS_GOOD) + sanei_hp_free ( *bufhp ); + } + + return status; +} + + +SANE_Status +sanei_hp_scl_set(HpScsi scsi, HpScl scl, int val) +{ + RETURN_IF_FAIL( hp_scsi_scl(scsi, scl, val) ); + + +#ifdef PARANOID + RETURN_IF_FAIL( sanei_hp_scl_errcheck(scsi) ); +#endif + + return SANE_STATUS_GOOD; +} + +SANE_Status +sanei_hp_scl_inquire(HpScsi scsi, HpScl scl, int * valp, int * minp, int * maxp) +{ + HpScl inquiry = ( IS_SCL_CONTROL(scl) + ? SCL_INQUIRE_PRESENT_VALUE + : SCL_INQUIRE_DEVICE_PARAMETER ); + + assert(IS_SCL_CONTROL(scl) || IS_SCL_PARAMETER(scl)); + assert(IS_SCL_CONTROL(scl) || (!minp && !maxp)); + + if (valp) + RETURN_IF_FAIL( _hp_scl_inq(scsi, scl, inquiry, valp, 0) ); + if (minp) + RETURN_IF_FAIL( _hp_scl_inq(scsi, scl, + SCL_INQUIRE_MINIMUM_VALUE, minp, 0) ); + if (maxp) + RETURN_IF_FAIL( _hp_scl_inq(scsi, scl, + SCL_INQUIRE_MAXIMUM_VALUE, maxp, 0) ); + return SANE_STATUS_GOOD; +} + +#ifdef _HP_NOT_USED +static SANE_Status +hp_scl_get_bounds(HpScsi scsi, HpScl scl, int * minp, int * maxp) +{ + assert(IS_SCL_CONTROL(scl)); + RETURN_IF_FAIL( _hp_scl_inq(scsi, scl, SCL_INQUIRE_MINIMUM_VALUE, minp, 0) ); + return _hp_scl_inq(scsi, scl, SCL_INQUIRE_MAXIMUM_VALUE, maxp, 0); +} +#endif + +#ifdef _HP_NOT_USED +static SANE_Status +hp_scl_get_bounds_and_val(HpScsi scsi, HpScl scl, + int * minp, int * maxp, int * valp) +{ + assert(IS_SCL_CONTROL(scl)); + RETURN_IF_FAIL( _hp_scl_inq(scsi, scl, SCL_INQUIRE_MINIMUM_VALUE, minp, 0) ); + RETURN_IF_FAIL( _hp_scl_inq(scsi, scl, SCL_INQUIRE_MAXIMUM_VALUE, maxp, 0) ); + return _hp_scl_inq(scsi, scl, SCL_INQUIRE_PRESENT_VALUE, valp, 0); +} +#endif + +SANE_Status +sanei_hp_scl_download(HpScsi scsi, HpScl scl, const void * valp, size_t len) +{ + assert(IS_SCL_DATA_TYPE(scl)); + + sanei_hp_scl_clearErrors ( scsi ); + RETURN_IF_FAIL( hp_scsi_need(scsi, 16) ); + RETURN_IF_FAIL( hp_scsi_scl(scsi, SCL_DOWNLOAD_TYPE, SCL_INQ_ID(scl)) ); + /* Download type not supported ? */ + RETURN_IF_FAIL( sanei_hp_scl_errcheck(scsi) ); + RETURN_IF_FAIL( hp_scsi_scl(scsi, SCL_DOWNLOAD_LENGTH, len) ); + RETURN_IF_FAIL( hp_scsi_write(scsi, valp, len) ); + +#ifdef PARANOID + RETURN_IF_FAIL( sanei_hp_scl_errcheck(scsi) ); +#endif + + return SANE_STATUS_GOOD; +} + +SANE_Status +sanei_hp_scl_upload(HpScsi scsi, HpScl scl, void * valp, size_t len) +{ + size_t nread = len; + HpScl inquiry = ( IS_SCL_DATA_TYPE(scl) + ? SCL_UPLOAD_BINARY_DATA + : SCL_INQUIRE_DEVICE_PARAMETER ); + + assert(IS_SCL_DATA_TYPE(scl) || IS_SCL_PARAMETER(scl)); + + RETURN_IF_FAIL( _hp_scl_inq(scsi, scl, inquiry, valp, &nread) ); + if (IS_SCL_PARAMETER(scl) && nread < len) + ((char *)valp)[nread] = '\0'; + else if (len != nread) + { + DBG(1, "scl_upload: requested %lu bytes, got %lu\n", + (unsigned long) len, (unsigned long) nread); + return SANE_STATUS_IO_ERROR; + } + return SANE_STATUS_GOOD; +} + +SANE_Status +sanei_hp_scl_calibrate(HpScsi scsi) +{ + RETURN_IF_FAIL( hp_scsi_scl(scsi, SCL_CALIBRATE, 0) ); + return hp_scsi_flush(scsi); +} + +SANE_Status +sanei_hp_scl_startScan(HpScsi scsi, HpScl scl) +{ + char *msg = ""; + + if (scl == SCL_ADF_SCAN) msg = " (ADF)"; + else if (scl == SCL_XPA_SCAN) msg = " (XPA)"; + else scl = SCL_START_SCAN; + + DBG(1, "sanei_hp_scl_startScan: Start scan%s\n", msg); + + /* For active XPA we must not use XPA scan */ + if ((scl == SCL_XPA_SCAN) && sanei_hp_is_active_xpa (scsi)) + { + DBG(3,"Map XPA scan to scan because of active XPA\n"); + scl = SCL_START_SCAN; + } + + RETURN_IF_FAIL( hp_scsi_scl(scsi, scl, 0) ); + return hp_scsi_flush(scsi); +} + +SANE_Status +sanei_hp_scl_reset(HpScsi scsi) +{ + RETURN_IF_FAIL( hp_scsi_write(scsi, "\033E", 2) ); + RETURN_IF_FAIL( hp_scsi_flush(scsi) ); + return sanei_hp_scl_errcheck(scsi); +} + +SANE_Status +sanei_hp_scl_clearErrors(HpScsi scsi) +{ + RETURN_IF_FAIL( hp_scsi_flush(scsi) ); + RETURN_IF_FAIL( hp_scsi_write(scsi, "\033*oE", 4) ); + return hp_scsi_flush(scsi); +} + +static const char * +hp_scl_strerror (int errnum) +{ + static const char * errlist[] = { + "Command Format Error", + "Unrecognized Command", + "Parameter Error", + "Illegal Window", + "Scaling Error", + "Dither ID Error", + "Tone Map ID Error", + "Lamp Error", + "Matrix ID Error", + "Cal Strip Param Error", + "Gross Calibration Error" + }; + + if (errnum >= 0 && errnum < (int)(sizeof(errlist)/sizeof(errlist[0]))) + return errlist[errnum]; + else + switch(errnum) { + case 1024: return "ADF Paper Jam"; + case 1025: return "Home Position Missing"; + case 1026: return "Paper Not Loaded"; + default: return "??Unkown Error??"; + } +} + +/* Check for SCL errors */ +SANE_Status +sanei_hp_scl_errcheck (HpScsi scsi) +{ + int errnum; + int nerrors; + SANE_Status status; + + status = sanei_hp_scl_inquire(scsi, SCL_CURRENT_ERROR_STACK, &nerrors,0,0); + if (!FAILED(status) && nerrors) + status = sanei_hp_scl_inquire(scsi, SCL_OLDEST_ERROR, &errnum,0,0); + if (FAILED(status)) + { + DBG(1, "scl_errcheck: Can't read SCL error stack: %s\n", + sane_strstatus(status)); + return SANE_STATUS_IO_ERROR; + } + + if (nerrors) + { + DBG(1, "Scanner issued SCL error: (%d) %s\n", + errnum, hp_scl_strerror(errnum)); + + sanei_hp_scl_clearErrors (scsi); + return SANE_STATUS_IO_ERROR; + } + + return SANE_STATUS_GOOD; +} |